@c Language: Portuguese
@c Source: stringproc.texi (en) 1.6
@menu
* Introdu@value{cedilha}@~ao a manipula@value{cedilha}@~ao de sequ@^encias de caracteres::
* Defini@value{cedilha}@~oes para entrada e sa@'{@dotless{i}}da::
* Defini@value{cedilha}@~oes para caracteres::
* Defini@value{cedilha}@~oes para sequ@^encias de caracteres::
@end menu

@node Introdu@value{cedilha}@~ao a manipula@value{cedilha}@~ao de sequ@^encias de caracteres, Defini@value{cedilha}@~oes para entrada e sa@'{@dotless{i}}da, stringproc, stringproc
@section Introdu@value{cedilha}@~ao a manipula@value{cedilha}@~ao de sequ@^encias de caracteres

O ficheiro @code{stringproc.lisp} amplia a compatibilidade do Maxima de trabalhar com sequ@^encias de caracteres 
e adiciona algumas fun@,{c}@~oes @'uteis a entrada e sa@'{@dotless{i}}da de dados.

Para esclarecimentos e erros por favor mande um e-mail para van.nek at arcor.de .

Para disponibilizar @code{stringproc.lisp} para uso digite @code{load("stringproc");}.

No Maxima uma sequ@^encia de caracteres @'e facilmente contru@'{@dotless{i}}da digitando "texto" (qualquer texto desejado entre aspas duplas).
Note que sequ@^encias de caracteres do Maxima n@~ao s@~ao sequ@^encias de caracteres do Lisp e vice-versa.
Testes podem ser conclu@'{@dotless{i}}dos com @code{stringp} e @code{lstringp}.
Se por alguma raz@~ao tiver um valor,
que @'e uma sequ@^encia de caracteres do Lisp, talvez quando estiver usando a fun@,{c}@~ao @code{sconcat} do Maxima, poder@'a converter via @code{sunlisp}. 


@c ===beg===
@c load("stringproc")$
@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) load("stringproc")$
(%i2) m: "text";
(%o2)                         text
(%i3) [stringp(m),lstringp(m)];
(%o3)                     [true, false]
(%i4) l: sconcat("text");
(%o4)                         text
(%i5) [stringp(l),lstringp(l)];
(%o5)                     [false, true]
(%i6) stringp( sunlisp(l) );
(%o6)                         true
@end example

Todas as fun@,{c}@~oes em @code{stringproc.lisp}, que retornarem sequ@^encias de caracteres, retornam sequ@^encias de caracteres do Maxima.

Caracteres s@~ao introduzidos como sequ@^encias de caracteres do Maxima de comprimento 1.
Com certeza, esses caracteres n@~ao s@~ao caracteres do Lisp.
Testes podem ser realizados com @code{charp} ( @code{lcharp} e convers@~oes do Lisp para o Maxima com @code{cunlisp}).


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

Novamente, todas as fun@,{c}@~oes em @code{stringproc.lisp}, que
retornam caracteres, retornam caracteres do Maxima.  devido a esse
facto, que os caracteres introduzidos s@~ao sequ@^encias de caracteres
de comprimento 1, pode usar muitas das fun@,{c}@~oes de sequ@^encia de
caracteres tamb@'em para caracteres. Como visto, @code{supcase} @'e um
exemplo.

@'E importante saber,
que o primeiro caractere em uma sequ@^encia de caracteres do Maxima @'est@'a na posi@,{c}@~ao 1.
Isso @'e designado devido ao facto de o primeiro elemento em uma lista do Maxima est@'a na posi@,{c}@~ao 1 tamb@'em.
Veja defini@,{c}@~oes de @code{charat} e de @code{charlist} para obter exemplos.

Em aplica@,{c}@~oes fn@,{c}@~oes de sequ@^encia de caractere s@~ao
muitas vezes usadas quando estamos trabalhando com ficheiros.  Poder@'a
encontrar@'a algumas fun@,{c}@~oes @'uteis de fluxo e de impress@~ao em
@code{stringproc.lisp}.  O seguinte exemplo mostra algumas das
fun@,{c}@~oes aqui introduzidas no trabalho.

Exemplo: 

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

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

Ap@'os fechar o fluxo pode abr@'{@dotless{i}}-lo novamente, dessa vez
com dire@,{c}@~ao de entrada.  @code{readline} retorna a linha completa
como uma sequ@^encia de caracteres. O pacote @code{stringproc} agora
oferece muitas fun@,{c}@~oes para manipula@,{c}@~ao de sequ@^encias de
caracteres. A troca de indica@,{c}@~oes/fichas pode ser realizada por
@code{split} ou por @code{tokens}.

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

@code{parsetoken} somente analiza n@'umeros inteiros e em ponto flutuante. A an@'alise de s@'{@dotless{i}}mbolos ou grandes n@'umeros em ponto flutuante 
precisa de @code{parse_string}, que pode ser disponibilizada para uso atrav@'es de @code{eval_string.lisp}.

@example 
(%i11) load("eval_string")$
(%i12) map( parse_string, list );
(%o12)           [42, 1.234, sqrt(2), %pi, 0.01, 0.01, 1.0b-2]
(%i13) float(%);
(%o13) [42.0, 1.234, 1.414213562373095, 3.141592653589793, 0.01, 0.01, 0.01]
(%i14) readline(s);
(%o14)                               false
(%i15) close(s)$
@end example

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

@node Defini@value{cedilha}@~oes para entrada e sa@'{@dotless{i}}da, Defini@value{cedilha}@~oes para caracteres, Introdu@value{cedilha}@~ao a manipula@value{cedilha}@~ao de sequ@^encias de caracteres, stringproc
@section Defini@value{cedilha}@~oes para entrada e sa@'{@dotless{i}}da

Exemplo: 

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


@deffn {Fun@,{c}@~ao} close (@var{fluxo}) 
Fecha  @var{fluxo} e retorna @code{true} se @var{fluxo} tiver sido aberto anteriormente. 

@end deffn

@deffn {Fun@,{c}@~ao} flength (@var{fluxo})
Retorna o n@'umero de elementos em @var{fluxo}. 

@end deffn

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

@end deffn

@deffn {Fun@,{c}@~ao} freshline () 
@deffnx {Fun@,{c}@~ao} freshline (@var{fluxo}) 
escreve uma nova linha (em @var{fluxo}),
se a posi@,{c}@~ao actual n@~ao for um in@'{@dotless{i}}cio de linha.
Veja tamb@'em @code{newline}.
@end deffn

@deffn {Fun@,{c}@~ao} newline () 
@deffnx {Fun@,{c}@~ao} 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@~ao trabalha como esperado. 

@end deffn

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

@end deffn

@deffn {Fun@,{c}@~ao} openr (@var{ficheiro}) 
Retorna um fluxo para @var{ficheiro}.
Se @var{ficheiro} n@~ao existir, ele ser@'a criado.

@end deffn

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

@end deffn

@deffn {Fun@,{c}@~ao} printf (@var{dest}, @var{seq_caracte})
@deffnx {Fun@,{c}@~ao} printf (@var{dest}, @var{seq_caracte}, @var{expr_1}, ..., @var{expr_n})
Torna a fun@,{c}@~ao FORMAT do Lisp Comum dispon@'{@dotless{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@,{c}@~ao e oa exemplos podem fornecer uma id@'eia de uso de @code{printf}.
Veja um refer@^encia de Lisp para maiores informa@,{c}@~oes.

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

Por favor note que n@~ao existe especificador de formato para grandes
n@'umeros em ponto flutuante. Todavia grandes n@'umeros em ponto
flutuante podem simplesmente serem mostrados por meio da directiva
@code{~a}.  @code{~s} mostra as sequ@^encias de caracteres entre "aspas
duplas"; pode evitar isso usando @code{~a}.  Note que a directiva de
selec@,{c}@~ao @code{~[} @'e indexada em zero.  Tamb@'em note que existem
algumas directivas, que n@~ao trabalham no Maxima.  Por exemplo,
@code{~:[} falha.

@c ===beg===
@c load("stringproc")$
@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) load("stringproc")$
(%i2) printf( false, "~a ~a ~4f ~a ~@@r", 
              "String",sym,bound,sqrt(12),144), bound = 1.234;
(%o2)                 String sym 1.23 2*sqrt(3) CXLIV
(%i3) printf( false,"~@{~a ~@}",["one",2,"THREE"] );
(%o3)                          one 2 THREE 
(%i4) 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 
(%i5) control: "~:(~r~) bird~p ~[is~;are~] singing."$
(%i6) printf( false,control, n,n,if n=1 then 0 else 1 ), n=2;
(%o6)                    Two birds are singing.
@end example

Se @var{dest} for um fluxo ou @code{true}, ent@~ao @code{printf} retorna @code{false}.
De outra forma, @code{printf} retorna uma sequ@^encia de caracteres contendo a sa@'{@dotless{i}}da.

@end deffn

@deffn {Fun@,{c}@~ao} readline (@var{fluxo}) 
Retorna uma sequ@^encia de caracteres contendo os caracteres a partir da posi@,{c}@~ao corrente em @var{fluxo} at@'e o fim de linha ou @var{false} se o fim de linha do ficheiro for encontrado.

@end deffn

@deffn {Fun@,{c}@~ao} sprint (@var{expr_1}, ..., @var{expr_n})
Avalia e mostra seus argumentos um ap@'os o outro `sobre uma linha'
iniciando na posi@,{c}@~ao mais @`a esquerda.  Os n@'umeros s@~ao
mostrados com o '-' @`a direita do n@'umero, e isso desconsidera o
comprimento da linha. @code{newline()}, que pode ser chamada a partir de
@code{stringproc.lisp} pode ser @'util, se desejar colocar uma parada de
linha interm@'edia.

@c ===beg===
@c for n:0 thru 22 do sprint( fib(n) )$
@c load("stringproc")$
@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) load("stringproc")$
(%i3) 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 Defini@value{cedilha}@~oes para caracteres, Defini@value{cedilha}@~oes para sequ@^encias de caracteres, Defini@value{cedilha}@~oes para entrada e sa@'{@dotless{i}}da, stringproc
@section Defini@value{cedilha}@~oes para caracteres

@deffn {Fun@,{c}@~ao} alphacharp (@var{caractere})    
Retorna @code{true} se @var{caractere} for um caractere alfab@'etico. 

@end deffn

@deffn {Fun@,{c}@~ao} alphanumericp (@var{caractere}) 
Retorna @code{true} se @var{caractere} for um caractere alfab@'etico ou um d@'{@dotless{i}}gito. 

@end deffn

@deffn {Fun@,{c}@~ao} ascii (@var{int}) 
Retorna o caractere correspondente ao c@'odigo num@'erico ASCII @var{int}.
( -1 < int < 256 )

@c ===beg===
@c load("stringproc")$
@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) load("stringproc")$
(%i2) 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@,{c}@~ao} 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@,{c}@~ao} cequalignore (@var{caractere_1}, @var{caractere_2})    
como @code{cequal} mas ignora a caixa alta/baixa. 

@end deffn

@deffn {Fun@,{c}@~ao} cgreaterp (@var{caractere_1}, @var{caractere_2})       
Retorna @code{true} se o c@'odigo num@'erico ASCII do @var{caractere_1} for maior que o c@'odigo num@'erico ASCII do @var{caractere_2}. 

@end deffn

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

@end deffn

@deffn {Fun@,{c}@~ao} charp (@var{obj}) 
Retorna @code{true} se @var{obj} for um caractere do Maxima.
Veja na se@,{c}@~ao "Introdu@value{cedilha}@~ao a manipula@value{cedilha}@~ao de sequ@^encias de caracteres" para ter um exemplo.

@end deffn

@deffn {Fun@,{c}@~ao} cint (@var{caractere}) 
Retorna o c@'odigo num@'eico ASCII de @var{caractere}.

@end deffn

@deffn {Fun@,{c}@~ao} clessp (@var{caractere_1}, @var{caractere_2})
Retorna @code{true} se o c@'odigo num@'erico ASCII de @var{caractere_1} for menor que o c@'odigo num@'erico ASCII de @var{caractere_2}. 

@end deffn

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

@end deffn

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

@c ===beg===
@c load("stringproc")$
@c for n from 0 thru 255 do ( 
@c    tmp: ascii(n), if constituent(tmp) then sprint(tmp) )$
@c ===end===
@example
(%i1) load("stringproc")$
(%i2) 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@,{c}@~ao} cunlisp (@var{lisp_char}) 
Converte um caractere do Lisp em um caractere do Maxima.  (@'E
poss@'{@dotless{i}}vel que n@~ao chegue a precisar dessa fun@,{c}@~ao.)

@end deffn

@deffn {Fun@,{c}@~ao} digitcharp (@var{caractere})    
Retorna @code{true} se @var{caractere} for um d@'{@dotless{i}}gito (algarismo de 0 a 9). 

@end deffn

@deffn {Fun@,{c}@~ao} lcharp (@var{obj}) 
Retorna @code{true} se @var{obj} for um caractere do Lisp.
(Pode n@~ao precisar dessa fun@,{c}@~ao.)

@end deffn

@deffn {Fun@,{c}@~ao} 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@'avel} space   
O caractere de espa@,{c}o em branco.

@end defvr

@defvr {Vari@'avel} tab     
O caractere de tabula@,{c}@~ao.

@end defvr

@deffn {Fun@,{c}@~ao} uppercasep (@var{caractere})    
Retorna @code{true} se @var{caractere} for um caractere em caixa alta. 

@end deffn

@node Defini@value{cedilha}@~oes para sequ@^encias de caracteres,  , Defini@value{cedilha}@~oes para caracteres, stringproc
@section Defini@value{cedilha}@~oes para sequ@^encias de caracteres

@deffn {Fun@,{c}@~ao} sunlisp (@var{lisp_string}) 
Converte uma sequ@^encia de caracteres do Lisp em uma sequ@^encia de caracteres do Maxima.
(Em geral, pode n@~ao chegar a precisar dessa fun@,{c}@~ao.)

@end deffn

@deffn {Fun@,{c}@~ao} lstringp (@var{obj}) 
Retorna @code{true} se @var{obj} is uma sequ@^encia de caracteres do Lisp.
(Em geral, pode n@~ao chegar a precisar dessa fun@,{c}@~ao.)

@end deffn

@deffn {Fun@,{c}@~ao} stringp (@var{obj}) 
Retorna @code{true} se @var{obj} for uma sequ@^encia de caracteres do Maxima.
Veja a introdu@,{c}@~ao para obter exemplos.

@end deffn

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

@c ===beg===
@c load("stringproc")$
@c charat("Lisp",1);
@c ===end===
@example
(%i1) load("stringproc")$
(%i2) charat("Lisp",1);
(%o2)                           L
@end example

@end deffn

@deffn {Fun@,{c}@~ao} charlist (@var{seq_caracte}) 
Retorna a lsita de todos os caracteres em @var{seq_caracte}. 

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

@end deffn

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

Nota de tradu@,{c}@~ao:
espa@,{c}o, v@'{@dotless{i}}rgula, ponto e v@'{@dotless{i}}rgula, tabula@,{c}@~ao e nova linha.

@c ===beg===
@c load("stringproc")$
@c 2*parsetoken("1.234 5.678");
@c ===end===
@example
(%i1) load("stringproc")$
(%i2) 2*parsetoken("1.234 5.678");
(%o2)                         2.468
@end example

Para analizar, pode tamb@'em usar a fun@,{c}@~ao @code{parse_string}.
Veja a descri@,{c}@~ao no ficheiro 'share\contrib\eval_string.lisp'.

@end deffn

@deffn {Fun@,{c}@~ao} sconc (@var{expr_1}, ..., @var{expr_n})
Avalia seus argumentos e concatena-os em uma sequ@^encia de caracteres.
@code{sconc} @'e como @code{sconcat} mas retorna uma sequ@^encia de caracteres do Maxima.

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

@end deffn

@deffn {Fun@,{c}@~ao} scopy (@var{seq_caracte}) 
Retorna uma c@'opia de @var{seq_caracte} como uma nova sequ@^encia de caracteres. 

@end deffn

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

@end deffn

@deffn {Fun@,{c}@~ao} 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@,{c}@~ao} sequalignore (@var{seq_caracte__1}, @var{seq_caracte__2})
Como em @code{sequal} mas igonara a caixa alta/baixa. 

@end deffn

@deffn {Fun@,{c}@~ao} sexplode (@var{seq_caracte})
@code{sexplode} @'e um apelido para a fun@,{c}@~ao @code{charlist}.

@end deffn

@deffn {Fun@,{c}@~ao} simplode (@var{lista})  
@deffnx {Fun@,{c}@~ao} simplode (@var{lista}, @var{delim})  
@code{simplode} takes uma @code{lista} ou express@~oes  e concatena-as em uma sequ@^encia de caracteres.
Se nenhum delimitador @var{delim} for usado, @code{simplode} funciona como @code{sconc} e n@~ao utiliza delimitador.
@var{delim} pode ser qualquer sequ@^encia de caracteres.

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

@end deffn

@deffn {Fun@,{c}@~ao} sinsert (@var{seq}, @var{seq_caracte}, @var{pos})  
Retorna uma sequ@^encia de caracteres que @'e uma concatena@,{c}@~ao de @code{substring (@var{seq_caracte}, 1, @var{pos} - 1)},
a sequ@^encia 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@,{c}@~ao 1.

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

@end deffn

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

@c ===beg===
@c load("stringproc")$
@c sinvertcase("sInvertCase");
@c ===end===
@example
(%i1) load("stringproc")$
(%i2) sinvertcase("sInvertCase");
(%o2)                      SiNVERTcASE
@end example

@end deffn

@deffn {Fun@,{c}@~ao} slength (@var{seq_caracte}) 
Retorna n@'umero de caracteres em @var{seq_caracte}. 

@end deffn

@deffn {Fun@,{c}@~ao} smake (@var{num}, @var{caractere}) 
Retorna uma nova sequ@^encia de caracteres repetindo @var{num} vezes @var{caractere}. 

@c ===beg===
@c load("stringproc")$
@c smake(3,"w");
@c ===end===
@example
(%i1) load("stringproc")$
(%i2) smake(3,"w");
(%o2)                          www
@end example

@end deffn

@deffn {Fun@,{c}@~ao} smismatch (@var{seq_caracte__1}, @var{seq_caracte__2}) 
@deffnx {Fun@,{c}@~ao} smismatch (@var{seq_caracte__1}, @var{seq_caracte__2}, @var{test}) 
Retorna a posi@,{c}@~ao 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@'ario.
A fun@,{c}@~ao padrao de teste para coincid@^encia @'e @code{sequal}.
Se @code{smismatch} pode ignorar a caixa alta/baixa, use @code{sequalignore} como fun@,{c}@~ao de teste.

@c ===beg===
@c load("stringproc")$
@c smismatch("seven","seventh");
@c ===end===
@example
(%i1) load("stringproc")$
(%i2) smismatch("seven","seventh");
(%o2)                           6
@end example

@end deffn

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

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

@end deffn

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

@end deffn

@deffn {Fun@,{c}@~ao} sremove (@var{seq}, @var{seq_caracte})  
@deffnx {Fun@,{c}@~ao} sremove (@var{seq}, @var{seq_caracte}, @var{test})  
@deffnx {Fun@,{c}@~ao} sremove (@var{seq}, @var{seq_caracte}, @var{test}, @var{in@'{@dotless{i}}cio})  
@deffnx {Fun@,{c}@~ao} sremove (@var{seq}, @var{seq_caracte}, @var{test}, @var{in@'{@dotless{i}}cio}, @var{fim})  
Retorna uma sequ@^encia de caracteres como @var{seq_caracte} mas com todas as subsequ@^encias de caracteres que coincidirem com @var{seq}.
A fun@,{c}@~ao padr@~ao de teste de coincid@^encia @'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@'{@dotless{i}}cio} e @var{fim} para limitar a busca.
Note que o primeiro caractere em @var{seq_caracte} est@'a na posi@,{c}@~ao 1.

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

@end deffn

@deffn {Fun@,{c}@~ao} sremovefirst (@var{seq}, @var{seq_caracte})  
@deffnx {Fun@,{c}@~ao} sremovefirst (@var{seq}, @var{seq_caracte}, @var{test})  
@deffnx {Fun@,{c}@~ao} sremovefirst (@var{seq}, @var{seq_caracte}, @var{test}, @var{in@'{@dotless{i}}cio})  
@deffnx {Fun@,{c}@~ao} sremovefirst (@var{seq}, @var{seq_caracte}, @var{test}, @var{in@'{@dotless{i}}cio}, @var{fim})  
Como em @code{sremove} excepto que a primeira subsequ@^encia de caracteres que coincide com @code{seq} @'e removida. 

@end deffn

@deffn {Fun@,{c}@~ao} sreverse (@var{seq_caracte}) 
Retorna uma sequ@^encia de caracteres com todos os caracteres de @var{seq_caracte} em ordem reversa. 

@end deffn

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

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

@end deffn

@deffn {Fun@,{c}@~ao} ssort (@var{seq_caracte}) 
@deffnx {Fun@,{c}@~ao} ssort (@var{seq_caracte}, @var{test}) 
Retorna uma sequ@^encia de caracteres que cont@'em todos os caracteres de @var{seq_caracte} em uma ordem tal que n@~ao 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@,{c}@~ao padr@~ao de teste para ordena@,{c}@~ao @'e @var{clessp}.
O conjunto de fun@,{c}@~oes de teste @'e @code{@{clessp, clesspignore, cgreaterp, cgreaterpignore, cequal, cequalignore@}}.

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

@end deffn

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

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

@end deffn

@deffn {Fun@,{c}@~ao} ssubstfirst (@var{nova}, @var{antiga}, @var{seq_caracte}) 
@deffnx {Fun@,{c}@~ao} ssubstfirst (@var{nova}, @var{antiga}, @var{seq_caracte}, @var{test}) 
@deffnx {Fun@,{c}@~ao} ssubstfirst (@var{nova}, @var{antiga}, @var{seq_caracte}, @var{test}, @var{in@'{@dotless{i}}cio}) 
@deffnx {Fun@,{c}@~ao} ssubstfirst (@var{nova}, @var{antiga}, @var{seq_caracte}, @var{test}, @var{in@'{@dotless{i}}cio}, @var{fim}) 
Como em @code{subst} excepto que somente a primeira subsequ@^encia de caracteres que coincidir com @var{antiga} @'e substitu@'{@dotless{i}}da. 

@end deffn

@deffn {Fun@,{c}@~ao} strim (@var{seq},@var{seq_caracte}) 
Retorna uma sequ@^encia de caracteres como @var{seq_caracte},
mas com todos os caracteres que aparecerem em @var{seq} removidos de ambas as extremidades. 

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

@end deffn

@deffn {Fun@,{c}@~ao} striml (@var{seq}, @var{seq_caracte}) 
Como em @code{strim} excepto que somente a extremidade esquerda de @var{seq_caracte} @'e recordada. 

@end deffn

@deffn {Fun@,{c}@~ao} strimr (@var{seq}, @var{seq_caracte}) 
Como em @code{strim} excepto que somente a extremidade direita de sequ@^encia de caracteres @'e recortada. 

@end deffn

@deffn {Fun@,{c}@~ao} substring (@var{seq_caracte}, @var{in@'{@dotless{i}}cio})
@deffnx {Fun@,{c}@~ao} substring (@var{seq_caracte}, @var{in@'{@dotless{i}}cio}, @var{fim}) 
Retorna a subsequ@^encia de caracteres de @var{seq_caracte} come@,{c}ando na posi@,{c}@~ao @var{in@'{@dotless{i}}cio} e terminando na posi@,{c}@~ao @var{fim}.
O caractere na posi@,{c}@~ao @var{fim} n@~ao @'e inclu@'{@dotless{i}}do.
Se @var{fim} n@~ao for fornecido, a subsequ@^encia de caracteres cont@'em o restante da sequ@^encia de caracteres.
Note que o primeiro caractere em @var{seq_caracte} est@'a na posi@,{c}@~ao 1.

@c ===beg===
@c load("stringproc")$
@c substring("substring",4);
@c substring(%,4,6);
@c ===end===
@example
(%i1) load("stringproc")$
(%i2) substring("substring",4);
(%o2)                        string
(%i3) substring(%,4,6);
(%o3)                          in
@end example

@end deffn

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

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

@end deffn

@deffn {Fun@,{c}@~ao} tokens (@var{seq_caracte}) 
@deffnx {Fun@,{c}@~ao} tokens (@var{seq_caracte}, @var{test}) 
Retorna uma lista de fichas, que tiverem sido extr@'{@dotless{i}}dos de @var{seq_caracte}.
As fichas s@~ao subsequ@^encias de caracteres cujos caracteres satisfazem a uma determinada fun@,{c}@~ao de teste.
Se o teste n@~ao for fornecido, @var{constituent} @'e usada como teste padr@~ao.
@code{@{constituent, alphacharp, digitcharp, lowercasep, uppercasep, charp, characterp, alphanumericp@}} @'e o conjunto de fn@,{c}~oes de teste. 
(A vers@~ao 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) load("stringproc")$
(%i2) tokens("24 October 2005");
(%o2)                  [24, October, 2005]
(%i3) tokens("05-10-24",'digitcharp);
(%o3)                     [05, 10, 24]
(%i4) map(parsetoken,%);
(%o4)                      [5, 10, 24]
@end example

@end deffn