@c Language: Brazilian Portuguese, Encoding: iso-8859-1
@c /stringproc.texi/1.8/Sat Jun  2 00:13:34 2007//
@menu
* Introdu@value{cedilha}@~{a}o a manipula@value{cedilha}@~{a}o de seq@"{u}@^{e}ncias de caracteres::
* Fun@value{cedilha}@~{o}es e Vari@'{a}veis para entrada e sa@'{i}da::
* Fun@value{cedilha}@~{o}es e Vari@'{a}veis para caracteres::
* Fun@value{cedilha}@~{o}es e Vari@'{a}veis para seq@"{u}@^{e}ncias de caracteres::
@end menu

@node Introdu@value{cedilha}@~{a}o a manipula@value{cedilha}@~{a}o de seq@"{u}@^{e}ncias de caracteres, Fun@value{cedilha}@~{o}es e Vari@'{a}veis para entrada e sa@'{i}da, stringproc, stringproc
@section Introdu@value{cedilha}@~{a}o a manipula@value{cedilha}@~{a}o de seq@"{u}@^{e}ncias de caracteres

O arquivo @code{stringproc.lisp} amplia a compatibilidade do Maxima de trabalhar com seq@"{u}@^{e}ncias de caracteres 
e adiciona algumas fun@value{cedilha}@~{o}es @'{u}teis a entrada e sa@'{i}da de dados.

Para esclarecimentos e corre@value{cedilha}@~{o}es por favor mande um e-mail para van.nek at arcor.de .

No Maxima uma seq@"{u}@^{e}ncia de caracteres @'{e} facilmente contru@'{i}da digitando "texto" (qualquer texto desejado entre aspas duplas).
Note que seq@"{u}@^{e}ncias de caracteres do Maxima n@~{a}o s@~{a}o seq@"{u}@^{e}ncias de caracteres do Lisp e vice-versa.
@code{stringp} realiza testes para seq@"{u}@^{e}ncias de caracteres
do Maxima, e @code{lstringp} realiza testes para seq@"{u}@^{e}ncias de caracteres do Lisp.
Se por alguma raz@~{a}o voce tiver um valor,
que @'{e} uma seq@"{u}@^{e}ncia de caracteres do Lisp, talvez quando estiver usando a fun@value{cedilha}@~{a}o @code{sconcat} do Maxima, voc@^{e} pode converter via @code{sunlisp}. 


@c ===beg===
@c m: "text";
@c [stringp(m),lstringp(m)];
@c l: sconcat("text");
@c [stringp(l),lstringp(l)];
@c stringp( sunlisp(l) );
@c ===end===
@example
(%i1) m: "text";
(%o1)                         text
(%i2) [stringp(m),lstringp(m)];
(%o2)                     [true, false]
(%i3) l: sconcat("text");
(%o3)                         text
(%i4) [stringp(l),lstringp(l)];
(%o4)                     [false, true]
(%i5) stringp( sunlisp(l) );
(%o5)                         true
@end example

Todas as fun@value{cedilha}@~{o}es em @code{stringproc.lisp}, que retornarem seq@"{u}@^{e}ncias de caracteres, retornam seq@"{u}@^{e}ncias de caracteres do Maxima.

Caracteres s@~{a}o introduzidos como seq@"{u}@^{e}ncias de caracteres do Maxima de comprimento 1.
Com certeza, esses caracteres n@~{a}o s@~{a}o caracteres do Lisp.
Testes podem ser realizados com @code{charp} ( @code{lcharp} e convers@~{o}es do Lisp para o Maxima com @code{cunlisp}).


@c ===beg===
@c c: "e";
@c [charp(c),lcharp(c)];
@c supcase(c);
@c charp(%);
@c ===end===
@example
(%i1) c: "e";
(%o1)                           e
(%i2) [charp(c),lcharp(c)];
(%o2)                     [true, false]
(%i3) supcase(c);
(%o3)                           E
(%i4) charp(%);
(%o4)                         true
@end example

Novamente, todas as fun@value{cedilha}@~{o}es em @code{stringproc.lisp}, que retornam caracteres, retornam caracteres do Maxima.
devido a esse fato, que os caracteres introduzidos s@~{a}o seq@"{u}@^{e}ncias de caracteres comprimento 1,
voc@^{e} pode usar muitas das fun@value{cedilha}@~{o}es de seq@"{u}@^{e}ncia de caracteres tamb@'{e}m para caracteres.
Como visto, @code{supcase} @'{e} um exemplo.

@'{E} importante saber,
que o primeiro caractere em uma seq@"{u}@^{e}ncia de caracteres do Maxima @'{e}st@'{a} na posi@value{cedilha}@~{a}o 1.
Isso @'{e} designado devido ao fato de o primeiro elemento em uma lista do Maxima est@'{a} na posi@value{cedilha}@~{a}o 1 tamb@'{e}m.
Veja defini@value{cedilha}@~{o}es de @code{charat} e de @code{charlist} para obter exemplos.

Em aplica@value{cedilha}@~{o}es fn@value{cedilha}@~{o}es de seq@"{u}@^{e}ncia de caractere s@~{a}o muitas vezes usadas quando estamos trabalhando com arquivos.
Voc@^{e} encontrar@'{a} algumas @'{u}teis fun@value{cedilha}@~{o}es de fluxo e fun@value{cedilha}@~{o}es de impress@~{o}es em @code{stringproc.lisp}.
O seguinte exemplo mostra algumas das fun@value{cedilha}@~{o}es aqui introduzidas no trabalho.

Exemplo: 

@code{openw} retorna um fluxo de sa@'{i}da para um arquivo, @code{printf} ent@~{a}o permite escrita formatada 
para esse arquivo. Veja @code{printf} para detalhes.

@example
+(%i1) s: openw("E:/file.txt");
+(%o1)                    #<output stream E:/file.txt>
+(%i2) for n:0 thru 10 do printf( s, "~d ", fib(n) );
+(%o2)                                done
+(%i3) printf( s, "~%~d ~f ~a ~a ~f ~e ~a~%", 
               42,1.234,sqrt(2),%pi,1.0e-2,1.0e-2,1.0b-2 );
+(%o3)                                false
+(%i4) close(s);
+(%o4)                                true
@end example

Ap@'{o}s fechar o fluxo voc@^{e} pode abr@'{i}-lo novamente, dessa vez com dire@value{cedilha}@~{a}o de entrada. 
@code{readline} retorna a linha completa como uma seq@"{u}@^{e}ncia de caracteres. O pacote @code{stringproc} 
agora oferece muitas fun@value{cedilha}@~{o}es para manipula@value{cedilha}@~{a}o de seq@"{u}@^{e}ncias de caracteres. A troca de indica@value{cedilha}@~{o}es/fichas pode ser realizada por 
@code{split} ou por @code{tokens}.

@example
(%i5) s: openr("E:/file.txt");
(%o5)                     #<input stream E:/file.txt>
(%i6) readline(s);
(%o6)                     0 1 1 2 3 5 8 13 21 34 55 
(%i7) line: readline(s);
(%o7)               42 1.234 sqrt(2) %pi 0.01 1.0E-2 1.0b-2
(%i8) list: tokens(line);
(%o8)           [42, 1.234, sqrt(2), %pi, 0.01, 1.0E-2, 1.0b-2]
(%i9) map( parsetoken, list );
(%o9)           [42, 1.234, false, false, 0.01, 0.01, false]
@end example

@code{parsetoken} somente analiza n@'{u}meros inteiros e em ponto flutuante. A an@'{a}lise de s@'{i}mbolos ou grandes n@'{u}meros em ponto flutuante 
precisa de @code{parse_string}, que ir@'{a} ser disponibilizada para uso automaticamente atrav@'{e}s de @code{eval_string.lisp}.

@example 
(%i10) map( parse_string, list );
(%o10)           [42, 1.234, sqrt(2), %pi, 0.01, 0.01, 1.0b-2]
(%i11) float(%);
(%o11) [42.0, 1.234, 1.414213562373095, 3.141592653589793, 0.01, 0.01, 0.01]
(%i12) readline(s);
(%o12)                               false
(%i13) close(s)$
@end example

@code{readline} retorna @code{false} quado o fim de arquivo acontecer.

@node Fun@value{cedilha}@~{o}es e Vari@'{a}veis para entrada e sa@'{i}da, Fun@value{cedilha}@~{o}es e Vari@'{a}veis para caracteres, Introdu@value{cedilha}@~{a}o a manipula@value{cedilha}@~{a}o de seq@"{u}@^{e}ncias de caracteres, stringproc
@section Fun@value{cedilha}@~{o}es e Vari@'{a}veis para entrada e sa@'{i}da

Exemplo: 

@c ===beg===
@c s: openw("E:/file.txt");
@c control: 
@c  "~2tAn atom: ~20t~a~%~2tand a list: ~20t~@{~r ~@}~%~2tand an integer: ~20t~d~%"$
@c printf( s,control, 'true,[1,2,3],42 )$
@c close(s);
@c s: openr("E:/file.txt");
@c while stringp( tmp:readline(s) ) do print(tmp)$
@c close(s)$
@c ===end===
@example
(%i1) s: openw("E:/file.txt");
(%o1)                     #<output stream E:/file.txt>
(%i2) control: 
 "~2tAn atom: ~20t~a~%~2tand a list: ~20t~@{~r ~@}~%~2tand an integer: ~20t~d~%"$
(%i3) printf( s,control, 'true,[1,2,3],42 )$
(%o3)                                false
(%i4) close(s);
(%o4)                                true
(%i5) s: openr("E:/file.txt");
(%o5)                     #<input stream E:/file.txt>
(%i6) while stringp( tmp:readline(s) ) do print(tmp)$
  An atom:          true 
  and a list:       one two three  
  and an integer:   42 
(%i7) close(s)$
@end example


@deffn {Fun@value{cedilha}@~{a}o} close (@var{fluxo}) 
Fecha  @var{fluxo} e retorna @code{true} se @var{fluxo} tiver sido aberto anteriormente. 

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} flength (@var{fluxo})
Retorna o n@'{u}mero de elementos em @var{fluxo}. 

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} fposition (@var{fluxo})
@deffnx {Fun@value{cedilha}@~{a}o} fposition (@var{fluxo}, @var{pos})
Retorna a posi@value{cedilha}@~{a}o corrente em @var{fluxo}, se @var{pos} n@~{a}o est@'{a} sendo usada.
Se @var{pos} estiver sendo usada,
@code{fposition} escolhe a posi@value{cedilha}@~{a}o em @var{fluxo}.
@var{pos} tem que ser um n@'{u}mero positivo,
o primeiro elemento em @var{fluxo} est@'{a} na posi@value{cedilha}@~{a}o 1.

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} freshline () 
@deffnx {Fun@value{cedilha}@~{a}o} freshline (@var{fluxo}) 
escreve uma nova linha (em @var{fluxo}),
se a posi@value{cedilha}@~{a}o atual n@~{a}o for um in@'{i}cio de linha.
Veja tamb@'{e}m @code{newline}.
@end deffn

@deffn {Fun@value{cedilha}@~{a}o} newline () 
@deffnx {Fun@value{cedilha}@~{a}o} newline (@var{fluxo}) 
Escreve uma nova linha (para @var{fluxo}).
Veja @code{sprint} para um exemplo de uso de @code{newline()}.
Note que existem alguns casos, onde @code{newline()}n@~{a}o trabalha como esperado. 

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} opena (@var{arquivo}) 
Retorna um fluxo de sa@'{i}da para @var{arquivo}.
Se um arquivo j@'{a} existente tiver sido aberto, @code{opena} anexa os elementos ao final do arquivo.

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} openr (@var{arquivo}) 
Retorna um fluxo para @var{arquivo}.
Se @var{arquivo} n@~{a}o existir, ele ser@'{a} criado.

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} openw (@var{arquivo}) 
Retorna um fluxo de sa@'{i}da para @var{arquivo}.
Se @var{arquivo} n@~{a}o existir, ser@'{a} criado.
Se um arquivo j@'{a} existente for aberto, @code{openw} modifica destrutivametne o @var{arquivo}.

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} printf (@var{dest}, @var{seq_caracte})
@deffnx {Fun@value{cedilha}@~{a}o} printf (@var{dest}, @var{seq_caracte}, @var{expr_1}, ..., @var{expr_n})
Torna a fun@value{cedilha}@~{a}o FORMAT do Lisp Comum dispon@'{i}vel no Maxima. 
(Retirado de gcl.info: "format produces formatted output by outputting the caracteres of 
control-string string and observing that a tilde introduces a directive.
The caractere after the tilde,
possibly preceded by prefix parameters and modifiers,
specifies what kind of formatting is desired.
Most directives use one or more elements of args to create their output.")

A seguinte descri@value{cedilha}@~{a}o e oa exemplos podem fornecer uma id@'{e}ia de uso de @code{printf}.
Veja um refer@^{e}ncia de Lisp para maiores informa@value{cedilha}@~{o}es.

@example
   ~%       nova linha
   ~&       nov@'{i}ssima line
   ~t       tabula@value{cedilha}@~{a}o
   ~$       monet@'{a}rio
   ~d       inteiro decimal
   ~b       inteiro bin@'{a}rio
   ~o       inteiro octal
   ~x       inteiro hexadecimal
   ~br      inteiro de base b
   ~r       soletra um inteiro
   ~p       plural
   ~f       ponto flutuante
   ~e       nota@value{cedilha}@~{a}o cient@'{i}fica
   ~g       ~f ou ~e, dependendo  da magnitude
   ~a       como mostrado pela fun@value{cedilha}@~{a}o print do Maxima
   ~s       seq@"{u}@^{e}ncias de caracteres entre "aspas duplas"
   ~~       ~
   ~<       justifica@value{cedilha}@~{a}o de texto, ~> terminador de justifica@value{cedilha}@~{a}o de texto
   ~(       convers@~{a}o de caixa alta/baixa, ~) terminador de convers@~{a}o de caixa
   ~[       sele@value{cedilha}@~{a}o, ~] terminador de sele@value{cedilha}@~{a}o 
   ~@{       itera@value{cedilha}@~{a}o, ~@} terminador de itera@value{cedilha}@~{a}o
@end example

Por favor note que n@~{a}o existe especificador de formato para grandes n@'{u}meros em ponto flutuante. Todavia grandes n@'{u}meros em ponto flutuante podem 
simplesmente serem mostrados por meio da diretiva @code{~a}. 
@code{~s} mostra a seq@"{u}@^{e}ncias de caracteres entre "aspas duplas", voc@^{e} pode evitar isso usando @code{~a}.
Note que a diretiva de sele@value{cedilha}@~{a}o @code{~[} @'{e} indexada em zero.
Tamb@'{e}m note que existem algumas diretivas, que n@~{a}o trabalham no Maxima.
Por exemplo, @code{~:[} falha.

@c ===beg===
@c printf( false, "~a ~a ~4f ~a ~@@r", 
@c         "String",sym,bound,sqrt(12),144), bound = 1.234;
@c printf( false,"~@{~a ~@}",["one",2,"THREE"] );
@c printf( true,"~@{~@{~9,1f ~@}~%~@}",mat ),
@c         mat = args( matrix([1.1,2,3.33],[4,5,6],[7,8.88,9]) )$
@c control: "~:(~r~) bird~p ~[is~;are~] singing."$
@c printf( false,control, n,n,if n=1 then 0 else 1 ), n=2;
@c ===end===
@example
(%i1) printf( false, "~a ~a ~4f ~a ~@@r", 
              "String",sym,bound,sqrt(12),144), bound = 1.234;
(%o1)                 String sym 1.23 2*sqrt(3) CXLIV
(%i2) printf( false,"~@{~a ~@}",["one",2,"THREE"] );
(%o2)                          one 2 THREE 
(%i3) printf( true,"~@{~@{~9,1f ~@}~%~@}",mat ),
              mat = args( matrix([1.1,2,3.33],[4,5,6],[7,8.88,9]) )$
      1.1       2.0       3.3 
      4.0       5.0       6.0 
      7.0       8.9       9.0 
(%i4) control: "~:(~r~) bird~p ~[is~;are~] singing."$
(%i5) printf( false,control, n,n,if n=1 then 0 else 1 ), n=2;
(%o5)                    Two birds are singing.
@end example

Se @var{dest} for um fluxo ou @code{true}, ent@~{a}o @code{printf} retorna @code{false}.
De outra forma, @code{printf} retorna uma seq@"{u}@^{e}ncia de caracteres contendo a sa@'{i}da.

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} readline (@var{fluxo}) 
Retorna uma seq@"{u}@^{e}ncia de caracteres contendo os caracteres a partir da posi@value{cedilha}@~{a}o corrente em @var{fluxo} at@'{e} o fim de linha ou @var{false} se o fim de linha do arquivo for encontrado.

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} sprint (@var{expr_1}, ..., @var{expr_n})
Avalia e mostra seus argumentos um ap@'{o}s o outro `sobre uma linha' iniciando na posi@value{cedilha}@~{a}o mais @`a esquerda.
Os n@'{u}meros s@~{a}o mostrados com o '-' @`a direita do n@'{u}mero,
e isso desconsidera o comprimento da linha. @code{newline()}, que ir@'{a} ser chamada automaticamente a partir de @code{stringproc.lisp} 
pode ser @'{u}til, se voc@^{e} desejar colocar uma parada de linha intermedi@'{a}ria.

@c ===beg===
@c for n:0 thru 22 do sprint( fib(n) )$
@c for n:0 thru 22 do ( 
@c    sprint(fib(n)), if mod(n,10)=9 then newline() )$
@c ===end===
@example
(%i1) for n:0 thru 22 do sprint( fib(n) )$
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 
(%i2) for n:0 thru 22 do ( 
         sprint(fib(n)), if mod(n,10)=9 then newline() )$
0 1 1 2 3 5 8 13 21 34 
55 89 144 233 377 610 987 1597 2584 4181 
6765 10946 17711 
@end example

@end deffn

@node Fun@value{cedilha}@~{o}es e Vari@'{a}veis para caracteres, Fun@value{cedilha}@~{o}es e Vari@'{a}veis para seq@"{u}@^{e}ncias de caracteres, Fun@value{cedilha}@~{o}es e Vari@'{a}veis para entrada e sa@'{i}da, stringproc
@section Fun@value{cedilha}@~{o}es e Vari@'{a}veis para caracteres

@deffn {Fun@value{cedilha}@~{a}o} alphacharp (@var{caractere})    
Retorna @code{true} se @var{caractere} for um caractere alfab@'{e}tico. 

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} alphanumericp (@var{caractere}) 
Retorna @code{true} se @var{caractere} for um caractere alfab@'{e}tico ou um d@'{i}gito. 

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} ascii (@var{int}) 
Retorna o caractere correspondente ao c@'{o}digo num@'{e}rico ASCII @var{int}.
( -1 < int < 256 )

@c ===beg===
@c for n from 0 thru 255 do ( 
@c    tmp: ascii(n), if alphacharp(tmp) then sprint(tmp), if n=96 then newline() )$
@c ===end===
@example
(%i1) for n from 0 thru 255 do ( 
tmp: ascii(n), if alphacharp(tmp) then sprint(tmp), if n=96 then newline() )$
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z 
a b c d e f g h i j k l m n o p q r s t u v w x y z
@end example

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} cequal (@var{caractere_1}, @var{caractere_2})          
Retorna @code{true} se @var{caractere_1} e @var{caractere_2} forem os mesmos. 

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} cequalignore (@var{caractere_1}, @var{caractere_2})    
como @code{cequal} mas ignora a caixa alta/baixa. 

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} cgreaterp (@var{caractere_1}, @var{caractere_2})       
Retorna @code{true} se o c@'{o}digo num@'{e}rico ASCII do @var{caractere_1} for maior que o c@'{o}digo num@'{e}rico ASCII do @var{caractere_2}. 

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} cgreaterpignore (@var{caractere_1}, @var{caractere_2})
Como @code{cgreaterp} mas ignora a caixa alta/baixa. 

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} charp (@var{obj}) 
Retorna @code{true} se @var{obj} for um caractere do Maxima.
Veja na se@value{cedilha}@~{a}o "Introdu@value{cedilha}@~{a}o a manipula@value{cedilha}@~{a}o de seq@"{u}@^{e}ncias de caracteres" para ter um exemplo.

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} cint (@var{caractere}) 
Retorna o c@'{o}digo num@'{e}ico ASCII de @var{caractere}.

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} clessp (@var{caractere_1}, @var{caractere_2})
Retorna @code{true} se o c@'{o}digo num@'{e}rico ASCII de @var{caractere_1} for menor que o c@'{o}digo num@'{e}rico ASCII de @var{caractere_2}. 

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} clesspignore (@var{caractere_1}, @var{caractere_2})
Como em @code{clessp} ignora a caixa alta/baixa. 

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} constituent (@var{caractere})   
Retorna @code{true} se @var{caractere} for caractere  gr@'{a}fico e n@~{a}o o caractere de espa@value{cedilha}o em branco.
Um caractere gr@'{a}fico @'{e} um caractere que se pode ver, adicionado o caractere de espa@value{cedilha}o em branco.
(@code{constituent} foi definida por Paul Graham, em ANSI Common Lisp, 1996, p@'{a}gina 67.)

@c ===beg===
@c for n from 0 thru 255 do ( 
@c    tmp: ascii(n), if constituent(tmp) then sprint(tmp) )$
@c ===end===
@example
(%i1) for n from 0 thru 255 do ( 
tmp: ascii(n), if constituent(tmp) then sprint(tmp) )$
! " #  %  ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @@ A B
C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c
d e f g h i j k l m n o p q r s t u v w x y z @{ | @} ~
@end example

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} cunlisp (@var{lisp_char}) 
Converte um caractere do Lisp em um caractere do Maxima.
(Voc@^{e} pode n@~{a}o precisar dessa fun@value{cedilha}@~{a}o.)

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} digitcharp (@var{caractere})    
Retorna @code{true} se @var{caractere} for um d@'{i}gito (algarismo de 0 a 9). 

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} lcharp (@var{obj}) 
Retorna @code{true} se @var{obj} for um caractere do Lisp.
(Voc@^{e} pode n@~{a}o precisar dessa fun@value{cedilha}@~{a}o.)

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} lowercasep (@var{caractere})    
Retorna @code{true} se @var{caractere} for um caractere em caixa baixa. 

@end deffn

@defvr {Variable} newline 
O caractere de nova linha. 

@end defvr

@defvr {Vari@'{a}vel} space   
O caractere de espa@value{cedilha}o em branco.

@end defvr

@defvr {Vari@'{a}vel} tab     
O caractere de tabula@value{cedilha}@~{a}o.

@end defvr

@deffn {Fun@value{cedilha}@~{a}o} uppercasep (@var{caractere})    
Retorna @code{true} se @var{caractere} for um caractere em caixa alta. 

@end deffn

@node Fun@value{cedilha}@~{o}es e Vari@'{a}veis para seq@"{u}@^{e}ncias de caracteres,  , Fun@value{cedilha}@~{o}es e Vari@'{a}veis para caracteres, stringproc
@section Fun@value{cedilha}@~{o}es e Vari@'{a}veis para seq@"{u}@^{e}ncias de caracteres

@deffn {Fun@value{cedilha}@~{a}o} sunlisp (@var{lisp_string}) 
Converte uma seq@"{u}@^{e}ncia de caracteres do Lisp em uma seq@"{u}@^{e}ncia de caracteres do Maxima.
(Em geral voc@^{e} pode n@~{a}o precisar dessa fun@value{cedilha}@~{a}o.)

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} lstringp (@var{obj}) 
Retorna @code{true} se @var{obj} is uma seq@"{u}@^{e}ncia de caracteres do Lisp.
(Em geral voc@^{e} pode n@~{a}o precisar dessa fun@value{cedilha}@~{a}o.)

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} stringp (@var{obj}) 
Retorna @code{true} se @var{obj} for uma seq@"{u}@^{e}ncia de caracteres do Maxima.
Veja a introdu@value{cedilha}@~{a}o para obter exemplos.

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} charat (@var{seq_caracte}, @var{n}) 
Retorna o @var{n}-@'{e}simo caractere de @var{seq_caracte}.
O primeiro caractere em @var{seq_caracte} @'{e} retornado com @var{n} = 1.

@c ===beg===
@c charat("Lisp",1);
@c ===end===
@example
(%i1) charat("Lisp",1);
(%o1)                           L
@end example

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} charlist (@var{seq_caracte}) 
Retorna a lsita de todos os caracteres em @var{seq_caracte}. 

@c ===beg===
@c charlist("Lisp");
@c %[1];
@c ===end===
@example
(%i1) charlist("Lisp");
(%o1)                     [L, i, s, p]
(%i2) %[1];
(%o2)                           L
@end example

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} parsetoken (@var{seq_caracte})  
@code{parsetoken} converte a primeira ficha em @var{seq_caracte} para o correspondente n@'{u}mero ou retorna @code{false} se o n@'{u}mero n@~{a}o puder ser determinado.
O conjunto de delimitadores para a troca de fichas @'{e} @code{@{space, comma, semicolon, tab, newline@}}

Nota de tradu@value{cedilha}@~{a}o:
espa@value{cedilha}o, v@'{i}rgula, ponto e v@'{i}rgula, tabula@value{cedilha}@~{a}o e nova linha.

@c ===beg===
@c 2*parsetoken("1.234 5.678");
@c ===end===
@example
(%i1) 2*parsetoken("1.234 5.678");
(%o1)                         2.468
@end example

Para analizar voc@^{e} pode tamb@'{e}m usar  a fun@value{cedilha}@~{a}o @code{parse_string}.
Veja a descri@value{cedilha}@~{a}o no arquivo 'share\contrib\eval_string.lisp'. 

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} sconc (@var{expr_1}, ..., @var{expr_n})
Avalia seus argumentos e concatena-os em uma seq@"{u}@^{e}ncia de caracteres.
@code{sconc} @'{e} como @code{sconcat} mas retorna uma seq@"{u}@^{e}ncia de caracteres do Maxima.

@c ===beg===
@c sconc("xx[",3,"]:",expand((x+y)^3));
@c stringp(%);
@c ===end===
@example
(%i1) sconc("xx[",3,"]:",expand((x+y)^3));
(%o1)             xx[3]:y^3+3*x*y^2+3*x^2*y+x^3
(%i2) stringp(%);
(%o2)                         true
@end example

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} scopy (@var{seq_caracte}) 
Retorna uma c@'{o}pia de @var{seq_caracte} como uma nova seq@"{u}@^{e}ncia de caracteres. 

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} sdowncase (@var{seq_caracte}) 
@deffnx {Fun@value{cedilha}@~{a}o} sdowncase (@var{seq_caracte}, @var{in@'{i}cio}) 
@deffnx {Fun@value{cedilha}@~{a}o} sdowncase (@var{seq_caracte}, @var{in@'{i}cio}, @var{fim}) 
Como em @code{supcase}, mas caracteres em caixa alta s@~{a}o convertidos para caracteres em caixa baixa. 

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} sequal (@var{seq_caracte__1}, @var{seq_caracte__2}) 
Retorna @code{true} se @var{seq_caracte__1} e @var{seq_caracte__2} tiverem o mesmo comprimento e contiverem os mesmos caracteres. 

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} sequalignore (@var{seq_caracte__1}, @var{seq_caracte__2})
Como em @code{sequal} mas igonara a caixa alta/baixa. 

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} sexplode (@var{seq_caracte})
@code{sexplode} @'{e} um apelido para a fun@value{cedilha}@~{a}o @code{charlist}.

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} simplode (@var{lista})  
@deffnx {Fun@value{cedilha}@~{a}o} simplode (@var{lista}, @var{delim})  
@code{simplode} takes uma @code{lista} ou express@~{o}es  e concatena-as em uma seq@"{u}@^{e}ncia de caracteres.
Se nenhum delimitador @var{delim} for usado, @code{simplode} funciona como @code{sconc} e n@~{a}o utiliza delimitador.
@var{delim} pode ser qualquer seq@"{u}@^{e}ncia de caracteres.

@c ===beg===
@c simplode(["xx[",3,"]:",expand((x+y)^3)]);
@c simplode( sexplode("stars")," * " );
@c simplode( ["One","more","coffee."]," " );
@c ===end===
@example
(%i1) simplode(["xx[",3,"]:",expand((x+y)^3)]);
(%o1)             xx[3]:y^3+3*x*y^2+3*x^2*y+x^3
(%i2) simplode( sexplode("stars")," * " );
(%o2)                   s * t * a * r * s
(%i3) simplode( ["One","more","coffee."]," " );
(%o3)                   One more coffee.
@end example

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} sinsert (@var{seq}, @var{seq_caracte}, @var{pos})  
Retorna uma seq@"{u}@^{e}ncia de caracteres que @'{e} uma concatena@value{cedilha}@~{a}o de @code{substring (@var{seq_caracte}, 1, @var{pos} - 1)},
a seq@"{u}@^{e}ncia de caracteres @var{seq} e @code{substring (@var{seq_caracte}, @var{pos})}.
Note que o primeiro caractere est@'{a} em @var{seq_caracte} e est@'{a} na posi@value{cedilha}@~{a}o 1.

@c ===beg===
@c s: "A submarine."$
@c sconc( substring(s,1,3),"yellow ",substring(s,3) );
@c sinsert("hollow ",s,3);
@c ===end===
@example
(%i1) s: "A submarine."$
(%i2) sconc( substring(s,1,3),"yellow ",substring(s,3) );
(%o2)                  A yellow submarine.
(%i3) sinsert("hollow ",s,3);
(%o3)                  A hollow submarine.
@end example

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} sinvertcase (@var{seq_caracte})  
@deffnx {Fun@value{cedilha}@~{a}o} sinvertcase (@var{seq_caracte}, @var{in@'{i}cio})  
@deffnx {Fun@value{cedilha}@~{a}o} sinvertcase (@var{seq_caracte}, @var{in@'{i}cio}, @var{fim})  
Retorna @var{seq_caracte} exceto que cada caractere da posi@value{cedilha}@~{a}o @var{in@'{i}cio} at@'{e} a posi@value{cedilha}@~{a}o @var{fim} est@'{a} invertido.
Se a posi@value{cedilha}@~{a}o @var{fim} n@~{a}o for fornecida,
todos os caracteres do in@'{i}cio ao @var{fim} de @var{seq_caracte} s@~{a}o substitu@'{i}dos.

@c ===beg===
@c sinvertcase("sInvertCase");
@c ===end===
@example
(%i1) sinvertcase("sInvertCase");
(%o1)                      SiNVERTcASE
@end example

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} slength (@var{seq_caracte}) 
Retorna n@'{u}mero de caracteres em @var{seq_caracte}. 

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} smake (@var{num}, @var{caractere}) 
Retorna uma nova seq@"{u}@^{e}ncia de caracteres repetindo @var{num} vezes @var{caractere}. 

@c ===beg===
@c smake(3,"w");
@c ===end===
@example
(%i1) smake(3,"w");
(%o1)                          www
@end example

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} smismatch (@var{seq_caracte__1}, @var{seq_caracte__2}) 
@deffnx {Fun@value{cedilha}@~{a}o} smismatch (@var{seq_caracte__1}, @var{seq_caracte__2}, @var{test}) 
Retorna a posi@value{cedilha}@~{a}o do primeiro caractere de @var{seq_caracte__1} no qual @var{seq_caracte__1} e @var{seq_caracte__2} diferem ou @code{false} em caso contr@'{a}rio.
A fun@value{cedilha}@~{a}o padrao de teste para coincid@^{e}ncia @'{e} @code{sequal}.
Se @code{smismatch} pode ignorar a caixa alta/baixa, use @code{sequalignore} como fun@value{cedilha}@~{a}o de teste.

@c ===beg===
@c smismatch("seven","seventh");
@c ===end===
@example
(%i1) smismatch("seven","seventh");
(%o1)                           6
@end example

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} split (@var{seq_caracte})  
@deffnx {Fun@value{cedilha}@~{a}o} split (@var{seq_caracte}, @var{delim})  
@deffnx {Fun@value{cedilha}@~{a}o} split (@var{seq_caracte}, @var{delim}, @var{multiple})  
Retorna a lista de todas as fichas em @var{seq_caracte}.
Cada ficha @'{e} uma seq@"{u}@^{e}ncia de caracteres n@~{a}o analisada.
@code{split} usa @var{delim} como delimitador.
Se @var{delim} n@~{a}o for fornecido, o caractere de espa@value{cedilha}o @'{e} o delimitador padr@~{a}o.
@var{multiple} @'{e} uma vari@'{a}vel booleana com @code{true} como valor padr@~{a}o.
Multiplos delimitadores s@~{a}o lidos como um.
Essa fun@value{cedilha}@~{a}o @'{e} @'{u}til se tabula@value{cedilha}@~{o}es s@~{a}o gravadas com caracteres de espa@value{cedilha}o multiplos.
Se @var{multiple} for escolhido para @code{false}, cada delimitador @'{e} considerado.

@c ===beg===
@c split("1.2   2.3   3.4   4.5");
@c split("first;;third;fourth",";",false);
@c ===end===
@example
(%i1) split("1.2   2.3   3.4   4.5");
(%o1)                 [1.2, 2.3, 3.4, 4.5]
(%i2) split("first;;third;fourth",";",false);
(%o2)               [first, , third, fourth]
@end example

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} sposition (@var{caractere}, @var{seq_caracte}) 
Retorna a posi@value{cedilha}@~{a}o do primeiro caractere em @var{seq_caracte} que coincide com @var{caractere}.
O primeiro caractere em @var{seq_caracte} est@'{a} na posi@value{cedilha}@~{a}o 1.
Para que os caracteres que coincidirem desconsiderem a caixa alta/baixa veja @code{ssearch}.

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} sremove (@var{seq}, @var{seq_caracte})  
@deffnx {Fun@value{cedilha}@~{a}o} sremove (@var{seq}, @var{seq_caracte}, @var{test})  
@deffnx {Fun@value{cedilha}@~{a}o} sremove (@var{seq}, @var{seq_caracte}, @var{test}, @var{in@'{i}cio})  
@deffnx {Fun@value{cedilha}@~{a}o} sremove (@var{seq}, @var{seq_caracte}, @var{test}, @var{in@'{i}cio}, @var{fim})  
Retorna uma seq@"{u}@^{e}ncia de caracteres como @var{seq_caracte} mas com todas as subseq@"{u}@^{e}ncias de caracteres que coincidirem com @var{seq}.
A fun@value{cedilha}@~{a}o padr@~{a}o de teste de coincid@^{e}ncia @'{e} @code{sequal}.
Se @code{sremove} puder ignorar a caixa alta/baixa enquanto busca por @var{seq}, use @code{sequalignore} como teste.
Use @var{in@'{i}cio} e @var{fim} para limitar a busca.
Note que o primeiro caractere em @var{seq_caracte} est@'{a} na posi@value{cedilha}@~{a}o 1.

@c ===beg===
@c sremove("n't","I don't like coffee.");
@c sremove ("DO ",%,'sequalignore);
@c ===end===
@example
(%i1) sremove("n't","I don't like coffee.");
(%o1)                   I do like coffee.
(%i2) sremove ("DO ",%,'sequalignore);
(%o2)                    I like coffee.
@end example

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} sremovefirst (@var{seq}, @var{seq_caracte})  
@deffnx {Fun@value{cedilha}@~{a}o} sremovefirst (@var{seq}, @var{seq_caracte}, @var{test})  
@deffnx {Fun@value{cedilha}@~{a}o} sremovefirst (@var{seq}, @var{seq_caracte}, @var{test}, @var{in@'{i}cio})  
@deffnx {Fun@value{cedilha}@~{a}o} sremovefirst (@var{seq}, @var{seq_caracte}, @var{test}, @var{in@'{i}cio}, @var{fim})  
Como em @code{sremove} exceto qie a primeira subseq@"{u}@^{e}ncia de caracteres que coincide com @code{seq} @'{e} removida. 

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} sreverse (@var{seq_caracte}) 
Retorna uma seq@"{u}@^{e}ncia de caracteres com todos os caracteres de @var{seq_caracte} em ordem reversa. 

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} ssearch (@var{seq}, @var{seq_caracte})  
@deffnx {Fun@value{cedilha}@~{a}o} ssearch (@var{seq}, @var{seq_caracte}, @var{test})  
@deffnx {Fun@value{cedilha}@~{a}o} ssearch (@var{seq}, @var{seq_caracte}, @var{test}, @var{in@'{i}cio})  
@deffnx {Fun@value{cedilha}@~{a}o} ssearch (@var{seq}, @var{seq_caracte}, @var{test}, @var{in@'{i}cio}, @var{fim})
Retorna a posi@value{cedilha}@~{a}o da primeira subseq@"{u}@^{e}ncia de caracteres de @var{seq_caracte} que coincide com a seq@"{u}@^{e}ncia de caracteres @var{seq}.
A fun@value{cedilha}@~{a}o padr@~{a}o de teste de coincid@^{e}ncia @'{e} @code{sequal}.
Se @code{ssearch} puder igonorar a caixa alta/baixa, use @code{sequalignore} como fun@value{cedilha}@~{a}o de teste.
Use @var{in@'{i}cio} e @var{fim} para limitar a busca.
Note que o primeiro caractere em @var{seq_caracte} est@'{a} na posi@value{cedilha}@~{a}o 1.

@example
(%i1) ssearch("~s","~@{~S ~@}~%",'sequalignore);
(%o1)                                  4
@end example

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} ssort (@var{seq_caracte}) 
@deffnx {Fun@value{cedilha}@~{a}o} ssort (@var{seq_caracte}, @var{test}) 
Retorna uma seq@"{u}@^{e}ncia de caracteres que cont@'{e}m todos os caracteres de @var{seq_caracte} em uma ordem tal que n@~{a}o existam dois caracteres @var{c} sucessivos e @var{d} seja tal que @code{test (@var{c}, @var{d})} seja @code{false} e @code{test (@var{d}, @var{c})} seja @code{true}.
A fun@value{cedilha}@~{a}o padr@~{a}o de teste para ordena@value{cedilha}@`ao @'{e} @var{clessp}.
O conjunto de fun@value{cedilha}@~oes de teste @'{e} @code{@{clessp, clesspignore, cgreaterp, cgreaterpignore, cequal, cequalignore@}}.

@c ===beg===
@c ssort("I don't like Mondays.");
@c ssort("I don't like Mondays.",'cgreaterpignore);
@c ===end===
@example
(%i1) ssort("I don't like Mondays.");
(%o1)                    '.IMaddeiklnnoosty
(%i2) ssort("I don't like Mondays.",'cgreaterpignore);
(%o2)                 ytsoonnMlkIiedda.'   
@end example

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} ssubst (@var{nova}, @var{antiga}, @var{seq_caracte}) 
@deffnx {Fun@value{cedilha}@~{a}o} ssubst (@var{nova}, @var{antiga}, @var{seq_caracte}, @var{test}) 
@deffnx {Fun@value{cedilha}@~{a}o} ssubst (@var{nova}, @var{antiga}, @var{seq_caracte}, @var{test}, @var{in@'{i}cio}) 
@deffnx {Fun@value{cedilha}@~{a}o} ssubst (@var{nova}, @var{antiga}, @var{seq_caracte}, @var{test}, @var{in@'{i}cio}, @var{fim}) 
Retorna uma seq@"{u}@^{e}ncia de caracteres como @var{seq_caracte} exceto que todas as subseq@"{u}@^{e}ncias de caracteres que coincidirem com @var{antiga} s@~{a}o substitu@'{i}das por @var{nova}.
@var{antiga} e @var{nova} n@~{a}o precisam ser de mesmo comprimento.
A fun@value{cedilha}@~{a}o padr@~{a}o de teste para coincid@^{e}ncia @'{e} para coincid@^{e}ncias @'{e} @code{sequal}.
Se @code{ssubst} puder ignorar a cixa alta/baixa enquanto procurando por @var{antiga}, use @code{sequalignore} como fun@value{cedilha}@~{a}o de teste.
Use @var{in@'{i}cio} e @var{fim} para limitar a busca.
Note que o primeiro caractere em @var{seq_caracte} est@'{a} na posi@value{cedilha}@~{a}o 1.

@c ===beg===
@c ssubst("like","hate","I hate Thai food. I hate green tea.");
@c ssubst("Indian","thai",%,'sequalignore,8,12);
@c ===end===
@example
(%i1) ssubst("like","hate","I hate Thai food. I hate green tea.");
(%o1)          I like Thai food. I like green tea.
(%i2) ssubst("Indian","thai",%,'sequalignore,8,12);
(%o2)         I like Indian food. I like green tea.
@end example

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} ssubstfirst (@var{nova}, @var{antiga}, @var{seq_caracte}) 
@deffnx {Fun@value{cedilha}@~{a}o} ssubstfirst (@var{nova}, @var{antiga}, @var{seq_caracte}, @var{test}) 
@deffnx {Fun@value{cedilha}@~{a}o} ssubstfirst (@var{nova}, @var{antiga}, @var{seq_caracte}, @var{test}, @var{in@'{i}cio}) 
@deffnx {Fun@value{cedilha}@~{a}o} ssubstfirst (@var{nova}, @var{antiga}, @var{seq_caracte}, @var{test}, @var{in@'{i}cio}, @var{fim}) 
Como em @code{subst} exceto que somente a primeira subseq@"{u}@^{e}ncia de caracteres que coincidir com @var{antiga} @'{e} substitu@'{i}da. 

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} strim (@var{seq},@var{seq_caracte}) 
Retorna uma seq@"{u}@^{e}ncia de caracteres como @var{seq_caracte},
mas com todos os caracteres que aparecerem em @var{seq} removidos de ambas as extremidades. 

@c ===beg===
@c "/* comment */"$
@c strim(" /*",%);
@c slength(%);
@c ===end===
@example
(%i1) "/* comment */"$
(%i2) strim(" /*",%);
(%o2)                        comment
(%i3) slength(%);
(%o3)                           7
@end example

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} striml (@var{seq}, @var{seq_caracte}) 
Como em @code{strim} exceto que somente a extremidade esquerda de @var{seq_caracte} @'{e} recordada. 

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} strimr (@var{seq}, @var{seq_caracte}) 
Como em @code{strim} exceto que somente a extremidade direita de seq@"{u}@^{e}ncia de caracteres @'{e} recortada. 

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} substring (@var{seq_caracte}, @var{in@'{i}cio})
@deffnx {Fun@value{cedilha}@~{a}o} substring (@var{seq_caracte}, @var{in@'{i}cio}, @var{fim}) 
Retorna a subseq@"{u}@^{e}ncia de caracteres de @var{seq_caracte} come@value{cedilha}ando na posi@value{cedilha}@~{a}o @var{in@'{i}cio} e terminando na posi@value{cedilha}@~{a}o @var{fim}.
O caractere na posi@value{cedilha}@~{a}o @var{fim} n@~{a}o @'{e} inclu@'{i}do.
Se @var{fim} n@~{a}o for fornecido, a subseq@"{u}@^{e}ncia de caracteres cont@'{e}m o restante da seq@"{u}@^{e}ncia de caracteres.
Note que o primeiro caractere em @var{seq_caracte} est@'{a} na posi@value{cedilha}@~{a}o 1.

@c ===beg===
@c substring("substring",4);
@c substring(%,4,6);
@c ===end===
@example
(%i1) substring("substring",4);
(%o1)                        string
(%i2) substring(%,4,6);
(%o2)                          in
@end example

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} supcase (@var{seq_caracte}) 
@deffnx {Fun@value{cedilha}@~{a}o} supcase (@var{seq_caracte}, @var{in@'{i}cio}) 
@deffnx {Fun@value{cedilha}@~{a}o} supcase (@var{seq_caracte}, @var{in@'{i}cio}, @var{fim}) 
Retorna @var{seq_caracte} exceto que caracteres em caixa baixa a partir da posi@value{cedilha}@~{a}o @var{in@'{i}cio} at@'{e} a posi@value{cedilha}@~{a}o @var{fim} s@~{a}o substitu@'{i}dos pelo correspondente caracteres em caixa alta.
Se @var{fim} n@~{a}o for fornecido,
todos os caracteres em caixa baixa de @var{in@'{i}cio} at@'{e} o fim de @var{seq_caracte} s@~{a}o substitu@'{i}dos.

@c ===beg===
@c supcase("english",1,2);
@c ===end===
@example
(%i1) load("stringproc")$
(%i1) supcase("english",1,2);
(%o1)                        English
@end example

@end deffn

@deffn {Fun@value{cedilha}@~{a}o} tokens (@var{seq_caracte}) 
@deffnx {Fun@value{cedilha}@~{a}o} tokens (@var{seq_caracte}, @var{test}) 
Retorna uma lista de fichas, que tiverem sido extr@'{i}dos de @var{seq_caracte}.
As fichas s@~{a}o subseq@"{u}@^{e}ncias de caracteres cujos caracteres satisfazem a uma determinada fun@value{cedilha}@~{a}o de teste.
Se o teste n@~{a}o for fornecido, @var{constituent} @'{e} usada como teste padr@~{a}o.
@code{@{constituent, alphacharp, digitcharp, lowercasep, uppercasep, charp, characterp, alphanumericp@}} @'{e} o conjunto de fn@value{cedilha}@~oes de teste. 
(A ver@~{a}o Lisp de @code{tokens} @'{e} escrita por Paul Graham. ANSI Common Lisp, 1996, page 67.)

@c ===beg===
@c load("stringproc")$
@c tokens("24 October 2005");
@c tokens("05-10-24",'digitcharp);
@c map(parsetoken,%);
@c ===end===
@example
(%i1) tokens("24 October 2005");
(%o1)                  [24, October, 2005]
(%i2) tokens("05-10-24",'digitcharp);
(%o2)                     [05, 10, 24]
(%i3) map(parsetoken,%);
(%o3)                      [5, 10, 24]
@end example

@end deffn
