41.1, Depuração do Código Fonte

Maxima tem um depurador interno de código fonte. O utilizador pode escolher um ponto de parada numa função, e executar o programa linha por linha a partir daí. A pilha de chamadas pode ser examinada, juntamente com as variáveis existentes nesse nível.

O comando :help ou :h mostra a lista de comandos de depuração. (Em geral, os comandos podem ser abreviados se a abreviação for única. Se não for única, as alternativas podem ser listadas.) Dentro do depurador, o utilizador pode também usar quaisquer funções comuns do Maxima para examinar, definir, e manipular variáveis e expressões.

Um ponto de parada é escolhido através do comando :br na linha de comando do Maxima. Dentro do depurador, o utilizador pode avançar uma linha de cada vez usando o comando :n (“next”). o comando :bt (“backtrace”) mostra uma lista da pilha de frames. O comando :r (“resume”) sai do depurador e continua com a execução. Esses comandos são demostrados no exemplo a seguir.

(%i1) load ("/tmp/foobar.mac");

(%o1)                           /tmp/foobar.mac

(%i2) :br foo
Turning on debugging debugmode(true)
Bkpt 0 for foo (in /tmp/foobar.mac line 1) 

(%i2) bar (2,3);
Bkpt 0:(foobar.mac 1)
/tmp/foobar.mac:1::

(dbm:1) :bt                        <-- :bt digitado aqui lista os frames
#0: foo(y=5)(foobar.mac line 1)
#1: bar(x=2,y=3)(foobar.mac line 9)

(dbm:1) :n                         <-- Aqui digite :n para avançar linha
(foobar.mac 2)
/tmp/foobar.mac:2::

(dbm:1) :n                         <-- Aqui digite :n para avançar linha
(foobar.mac 3)
/tmp/foobar.mac:3::

(dbm:1) u;                         <-- Investiga o valor de u
28

(dbm:1) u: 33;                     <-- Altera u para ser 33
33

(dbm:1) :r                         <-- Digite :r para retomar a computação

(%o2)                                1094

O ficheiro /tmp/foobar.mac é o seguinte:

foo(y) := block ([u:y^2],
  u: u+3,
  u: u^2,
  u);
 
bar(x,y) := (
  x: x+2,
  y: y+2,
  x: foo(y),
  x+y);

USO DO DEPURADOR ATRAVÉS DO EMACS E DE XMAXIMA

Se o utilizador estiver a executar o código sob o GNU Emacs numa janela shell (shel dbl), ou estiver usando a interface gráfica, xmaxima, então quando parar num ponto de parada, verá a sua posição actual no ficheiro fonte apresentada na outra metade da janela, ou em vermelho brilhante, ou com uma pequena seta apontando na direita da linha. Poderá avançar uma linha por vez digitando M-n (Alt-n).

No Emacs pode executar o Maxima numa shell dbl, o qual requer o ficheiro dbl.el no directório elisp. Verifique que tenha instalado os ficheiros elisp ou adicionado o directório elisp do Maxima ao seu caminho: e.g., adicione o seguinte ao seu ficheiro .emacs ou ao seu ficheiro site-init.el

(setq load-path (cons "/usr/share/maxima/5.9.1/emacs" load-path))
(autoload 'dbl "dbl")

então no Emacs

M-x dbl

pode iniciar uma janela shell na qual pode executar programas, por exemplo Maxima, gcl, gdb etc. Essa janela de shell também reconhece informações sobre depuração de código fonte, e mostra o código fonte em outra janela.

O utilizador pode escolher um ponto de parada em certa linha do ficheiro digitando C-x space. Isso encontra qual a função onde o cursor está posicionado, e mostra qual a linha daquela função onde o cursor está habilitado. Se o cursor estiver habilitado, digamos, na linha 2 de foo, então isso irá inserir na outra janela o comando, “:br foo 2”, para parar foo nessa segunda linha. Para ter isso habilitado, o utilizador deve ter maxima-mode.el habilitado na janela na qual o ficheiro foobar.mac estiver interagindo. Existe comandos adicional disponíveis naquela janela de ficheiro, tais como avaliando a função dentro do Maxima, através da digitação de Alt-Control-x.

41.2, Comandos Palavra Chave

Comandos palavra chave são palavras chaves especiais que não são interpretadas como expressões do Maxima. Um comando palavra chave pode ser inserido na linha de comando do Maxima ou na linha de comando do depurador, embora não possa ser inserido na linha de comando de parada. Comandos palavra chave iniciam com um dois pontos Keyword commands start with a colon, ’:’. Por exemplo, para avaliar um comando do Lisp, pode escrever :lisp seguido pelo comando a ser avaliado.

(%i1) :lisp (+ 2 3) 
5

O número de argumentos necessários depende do comando em particular. Também, não precisa escrever o comando completo, apenas o suficiente para ser único no meio das palavras chave de parada. Dessa forma :br será suficiente para :break.

Os comandos de palavra chave são listados abaixo.

:break F n

Escolhe um ponto de parada em uma função F na linha n a partir do início da função. Se F for dado como uma sequência de caracteres, então essa sequência de caracteres é assumida referir-se a um ficheiro, e n é o deslocamente a partir do início do ficheiro. O deslocamento é opcional. Se for omitido, é assumido ser zero (primeira linha da função ou do ficheiro).

:bt

Imprime na tela uma lista da pilha de frames

:continue

Continua a computação

:delete

Remove o ponto de parada seleccionado, ou todos se nenum for especificado

:disable

Desabilita os pontos de parada seleccionados, ou todos se nenhum for especificado

:enable

Habilita os pontos de de parada especificados, ou todos se nenhum for especificado

:frame n

Imprime na tela a pilha de frame n, ou o corrente frame se nenhum for especificado

:help

Imprime na tela a ajuda sobre um comando do depurador, ou todos os comandos se nenhum for especificado

:info

Imprime na tela informações sobre um item

:lisp alguma-forma

Avalia alguma-forma como uma forma Lisp

:lisp-quiet alguma-forma

Avalia a forma Lisp alguma-forma sem qualquer saída

:next

Como :step, excepto :next passos sobre chamadas de fução

:quit

Sai do nível corrente do depurador sem concluir a computação

:resume

Continua a computação

:step

Continua a computação até encontraruma nova linha de códico

:top

Retorne para a linha de comando do Maxima (saindo de qualquer nível do depurador) sem completar a computação

41.3, Definições para Depuração

Variável de opção: refcheck ¶

Valor por omissão: false

Quando refcheck for true, Maxima imprime uma mensagem cada vez que uma variável associada for usada pela primeira vez em uma computação.

Variável de opção: setcheck ¶

Valor por omissão: false

Se setcheck for escolhido para uma lista de variáveis (as quais podem ser subscritas), Maxima mostra uma mensagem quando as variáveis, ou ocorrências subscritas delas, forem associadas com o operador comum de atribuição :, o operador :: de atribuição, ou associando argumentos de função, mas não com o operador de atribuição de função := nem o operador de atribuição ::= de macro. A mensagem compreende o nome das variáveis e o valor associado a ela.

setcheck pode ser escolhida para all ou true incluindo desse modo todas as variáveis.

Cada nova atribuição de setcheck estabelece uma nova lista de variáveis para verificar, e quaisquer variáveis previamente atribuídas a setcheck são esquecidas.

Os nomes atribuídos a setcheck devem ter um apóstrofo no início se eles forem de outra forma avaliam para alguma outra coisa que não eles mesmo. Por exemplo, se x, y, e z estiverem actualmente associados, então digite

setcheck: ['x, 'y, 'z]$

para colocá-los na lista de variáveis monitoradas.

Nenhuma saída é gerada quando uma variável na lista setcheck for atribuída a sí mesma, e.g., X: 'X.

Variável de opção: setcheckbreak ¶

Valor por omissão: false

Quando setcheckbreak for true, Maxima mostrará um ponto de parada quando uma variável sob a lista setcheck for atribuída a um novo valor. A parada ocorre antes que a atribuíção seja concluída. Nesse ponto, setval retém o valor para o qual a variável está para ser atribuída. Consequentemente, se pode atribuir um valor diferente através da atribuição a setval.

Veja também setcheck e setval.

Variável de sistema: setval ¶

Mantém o valor para o qual a variável está para ser escolhida quando um setcheckbreak ocorrer. Consequentemente, se pode atribuir um valor diferente através da atribuição a setval.

Veja também setcheck e setcheckbreak.

Função: timer (f_1, ..., f_n) ¶

Função: timer () ¶

Dadas as funções f_1, ..., f_n, timer coloca cada uma na lista de funções para as quais cronometragens estatísticas são colectadas. timer(f)$ timer(g)$ coloca f e então g sobre a lista; a lista acumula de uma chamada para a chamada seguinte.

Sem argumentos, timer retorna a lista das funções tempo estatisticamente monitoradas.

Maxima armazena quanto tempo é empregado executando cada função na lista de funções tempo estatisticamente monitoradas. timer_info retorna a coronometragem estatística, incluindo o tempo médio decorrido por chamada de função, o número de chamadas, e o tempo total decorrido. untimer remove funções da lista de funções tempo estatisticamente monitoradas.

timer não avalia seus argumentos. f(x) := x^2$ g:f$ timer(g)$ não coloca f na lista de funções estatisticamente monitoradas.

Se trace(f) está vigorando, então timer(f) não tem efeito; trace e timer não podem ambas atuarem ao mesmo tempo.

Veja também timer_devalue.

Função: untimer (f_1, ..., f_n) ¶

Função: untimer () ¶

Dadas as funções f_1, ..., f_n, untimer remove cada uma das funções listadas da lista de funções estatisticamente monitoradas.

Sem argumentos, untimer remove todas as funções actualmente na lista de funções estatisticamente monitoradas.

Após untimer (f) ser executada, timer_info (f) ainda retorna estatisticas de tempo previamente colectadas, embora timer_info() (sem argumentos) não retorna informações sobre qualquer função que não estiver actualmente na lista de funções tempo estatisticamente monitoradas. timer (f) reposiciona todas as estatisticas de tempo para zero e coloca f na lista de funções estatisticamente monitoradas novamente.

Variável de opção: timer_devalue ¶

Valor Padrão: false

Quando timer_devalue for true, Maxima subtrai de cada função estatisticamente monitorada o tempo empregado em ou funções estatisticamente monitoradas. De outra forma, o tempo reportado para cada função inclui o tempo empregado em outras funções. Note que tempo empregado em funções não estatisticamente monitoradas não é subtraído do tempo total.

Veja também timer e timer_info.

Função: timer_info (f_1, ..., f_n) ¶

Função: timer_info () ¶

Dadas as funções f_1, ..., f_n, timer_info retorna uma matriz contendo informações de cronometragem para cada função. Sem argumentos, timer_info retorna informações de cronometragem para todas as funções actualmente na lista de funções estatisticamente monitoradas.

A matriz retornada através de timer_info contém o nome da função, tempo por chamda de função, número de chamadas a funções,tempo total, e gctime, cujja forma "tempo de descarte" no Macsyma original mas agora é sempre zero.

Os dados sobre os quais timer_info constrói seu valor de retorno podem também serem obtidos através da função get:

get(f, 'calls);  get(f, 'runtime);  get(f, 'gctime);

Veja também timer.

Função: trace (f_1, ..., f_n) ¶

Função: trace () ¶

Dadas as funções f_1, ..., f_n, trace instrui Maxima para mostrar informações de depuração quando essas funções forem chamadas. trace(f)$ trace(g)$ coloca f e então g na lista de funções para serem colocadas sob a ação de trace; a lista acumula de uma chamada para a seguinte.

Sem argumentos, trace retorna uma lista de todas as funções actualmente sob a ação de trace.

A função untrace desabilita a ação de trace. Veja também trace_options.

trace não avalia seus argumentos. Dessa forma, f(x) := x^2$ g:f$ trace(g)$ não coloca f sobre a lista de funções monitoradas por trace.

Quando uma função for redefinida, ela é removida da lista de timer. Dessa forma após timer(f)$ f(x) := x^2$, a função f não mais está na lista de timer.

Se timer (f) estiver em efeito, então trace (f) não está agindo; trace e timer não podem ambas estar agindo para a mesma função.

Função: trace_options (f, option_1, ..., option_n) ¶

Função: trace_options (f) ¶

Escolhe as opções de trace para a função f. Quaisquer opções anteriores são substituídas. trace_options (f, ...) não tem efeito a menos que trace (f) tenha sido também chamada (ou antes ou após trace_options).

trace_options (f) reposiciona todas as opções para seus valores padrão.

As opções de palavra chave são:

• noprint Não mostre uma mensagem na entrada da função e saia.
• break Coloque um ponto de parada antes da função ser inserida, e após a funçãos er retirada. Veja break.
• lisp_print Mostre argumentos e valores de retorno com objectos Lisp.
• info Mostre -> true na entrada da funçào e saia.
• errorcatch Capture os erros, fornecendo a opção para sinalizar um erro, tentar novamente a chamada de função, ou especificar um valor de retorno.

Opções para trace são especificadas em duas formas. A presença da palavra chave de opção sozinha coloca a opção para ter efeito incondicionalmente. (Note que opção foo não coloca para ter efeito especificando foo: true ou uma forma similar; note também que palavras chave não precisam estar com apóstrofo.) Especificando a opção palavra chave com uma função predicado torna a opção condicional sobre o predicado.

A lista de argumentos para a função predicado é sempre [level, direction, function, item] onde level é o nível rerecursão para a função, direction é ou enter ou exit, function é o nome da função, e item é a lista de argumentos (sobre entrada) ou o valor de retorno (sobre a saída).

Aqui está um exemplo de opções incondicionais de trace:

(%i1) ff(n) := if equal(n, 0) then 1 else n * ff(n - 1)$

(%i2) trace (ff)$

(%i3) trace_options (ff, lisp_print, break)$

(%i4) ff(3);

Aqui está a mesma função, com a opção break condicional sobre um predicado:

(%i5) trace_options (ff, break(pp))$

(%i6) pp (level, direction, function, item) := block (print (item),
    return (function = 'ff and level = 3 and direction = exit))$

(%i7) ff(6);

Função: untrace (f_1, ..., f_n) ¶

Função: untrace () ¶

Dadas as funções f_1, ..., f_n, untrace desabilita a a monitoração habilitada pela função trace. Sem argumentos, untrace desabilita a atuação da função trade para todas as funções.

untrace retorne uma lista das funções para as quais untrace desabilita a atuação de trace.