[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Índice] | [ ? ]

# 41. Depurando

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Índice] | [ ? ]

## 41.1 Depurando o Código Fonte

Maxima tem um depurador interno de código fonte. O usuário pode escolher um ponto de parada em uma função, e então caminhar linha por linha a partir daí. A pilha de chamadas po ser examinada, juntamente com as variáveis associadas àquele nível.

O comando `:help` ou `:h` mostra a lista de comando de depuração. (Em geral, comandos podem ser abreviados se a abreviação for única. Se não for única, as alternativas podem ser listadas.) Dentro do depurador, o usuário pode também usar qualquer 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 usuário 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 abaixo.

    (%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 arquivo `/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

Se o usuário estiver rodando o código sob o GNU emacs em uma janela shell (shell dbl), ou está rodando a versão de interface gráfica, Xmaxima, então se ele para em um ponto de parada, ele verá sua posição corrente no arquivo fonte a qua será mostrada na outra metade da janela, ou em vermelho brilhante, ou com um pequeno seta apontando na direita da linha. Ele pode avançar uma linha por vez digitando M-n (Alt-n).

Sob Emacs você pode executar em um shell `dbl`, o qual requer o arquivo `dbl.el` no diretório elisp. Tenha certeza que instalou os arquivos elisp ou adicionou o diretório elisp do Macima ao seu caminho: e.g., adicione o seguinte ao seu arquivo ``.emacs'` ou ao seu arquivo ``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 você 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 usuário pode escolher um ponto de parada em certa linha do arquivo digitando `C-x space`. Isso encontra qual a função que o cursor está posicionado, e então mostra qual a linha daquela função que 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 usuário deve ter maxima-mode.el habilitado na janela na qual o arquivo `foobar.mac` estiver interagindo. Existe comandos adicional disponíveis naquela janela de arquivo, tais como avaliando a função dentro do Maxima, através da digitação de `Alt-Control-x`.

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Índice] | [ ? ]

## 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, `:`. Por exemplo, para avaliar uma forma Lisp você pode digitar `:lisp` seguido pela forma a ser avaliada.

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

O número de argumentos tomados depende do comando em particular. Também, você não precisa digitar 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 seqüência de caracteres, então essa seqüência de caracteres é assumida referir-se a um arquivo, e `n` é o deslocamente a partir do início do arquivo. O deslocamento é opcional. Se for omitido, é assumido ser zero (primeira linha da função ou do arquivo).

`:bt`

  Imprime na tela uma lista da pilha de frames

`:continue`

  Continua a computação

`:delete`

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

`:disable`

  Desabilita os pontos de parada selecionados, 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`, exceto `: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

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Índice] | [ ? ]

## 41.3 Funções e Variáveis Definidas para Depuração

Variável de opção: refcheck

  Valor padrã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 padrã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 atualmente 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 padrã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. Conseqüentemente, 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. Conseqüentemente, 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 (all)
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 coletadas. `timer(f)$ timer(g)$` coloca `f` e então `g` sobre a lista; a lista acumula de uma chamada para a chamada seguinte.

  `timer(all)` coloca todas as funções definidas pelo usuário (a saber pela variável global `functions`) na lista de funções monitoradas pela função `time`.

  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 atualmente na lista de funções estatisticamente monitoradas.

  Após `untimer (f)` ser executada, `timer_info (f)` ainda retorna estatisticas de tempo previamente coletadas, embora `timer_info()` (sem argumentos) não retorna informações sobre qualquer função que não estiver atualmente 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 atualmente 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 (all)
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.

  `trace(all)` coloca todas as funções definidas pelo usuário (a saber pela variável global `functions`) na lista de funções a serem monitoradas pela função `trace`.

  Sem argumentos, `trace` retorna uma lista de todas as funções atualmente 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 pela função `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 objetos 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`.

[ << ] | [ >> ] |  |  |  |  |  | [Top] | [Contents] | [Índice] | [ ? ]

This document was generated by Viktor T. Toth on Setembro, 27 2018 using texi2html 1.76.