
Captulo 13 - procedimentos e funes para manipulao de strings e de converses
Neste ponto, veremos algumas funes e procedimentos que nos permitem a
manipulao de variveis alfanumricas  e ainda as de converses de tipo
numrico para alfanumrico, e vice-versa.

LENGTH
A funo LENGTH retorna a quantidade de caracteres contidos em uma string.
Sua sintaxe:
            LENGTH(<s>:STRING):INTEGER;

exemplo:
PROGRAM teste_length;

VAR
    S:STRING[100];
BEGIN
    READLN(S);
    WRITELN(O tamanho da varivel   , LENGTH(s));
    READLN;
END.

O maior valor que a funo LENGTH retorna  igual ao valor do tamanho
definido na declarao da varivel, ou seja, se no exemplo anterior,
digitarmos uma quantidade de caracteres superior a 100, a funo nos
retornar o valor 100.

CONCAT
A funo CONCAT nos retorna uma string, que  a unio entre uma ou mais
strings passadas como parmetro na funo. Caso o resultado seja uma strng
de tamanho maior que 255, esta ser truncada em 255. Esta funo pode ser
substituda pelo operador mais(+). Sua sintaxe:
            CONCAT(<s1>[s2,...sn]:STRING):STRING;

PROGRAM teste_concat;

BEGIN
    WRITELN(CONCAT(TURBO +PASCAL));
END.
     
Esta funo pode ser substituda pelo uso do operador "+" sem diferena alguma.

DELETE
O procedimento DELETE permite-nos retirar um ou mais caracteres de uma
determinada string, passada como parmetro, em uma posio predefinida. Sua sintaxe:
            DELETE(VAR<s>:STRING;<indice>,<contador>:INTEGER);

PROGRAM teste_delete;

VAR
    s       :STRING;
    indice  :BYTE;

BEGIN
    WRITE(Digite uma palavra );
    READLN(s);
    WRITE(digite a posio que ser removid);
    READLN(indice);
    DELETE(s,indice,1);
    WRITELN;
    WRITELN(A palavra ficou assim : ,s);
    READLN;
END.

COPY
A funo COPY retorna uma substring de uma string passada como armetro, de
acordo com a posio e quantidade de caracteres predefinidos. Sua sintaxe:
            COPY(<s>:STRING;<indice>,<contador>:INTEGER):STRING;

PROGRAM teste_copy;

VAR
    s              :STRING;
    indice,cont    :BYTE;
BEGIN
    WRITE(Digite uma palavra );
    READLN(s);
    WRITE(Digite a posio que ser copiada );
    READLN(indice);
    WRITE(Digite quantos caracteres devem ser, copiados );
    READLN(A cpia da palavra ficou assim: , COPY(s, indice,cont));
    READLN;
END.

INSERT
Procedimento que permite inserir uma substring, em uma string em uma posio
preestabelecida. Caso a soma da string original mais a fonte seja maior que
255bytes, ser truncada em 255. Sua sintaxe:
            INSERT(<fonte>:STRING;VAR<destino>:STRING;<ind>:INTEGER);

PROGRAM teste_insert;

VAR
    destino:STRING[10];

BEGIN
    destino :=123456;
    INSERT(',',destino,5);
    INSERT('.', destino,2);
    WRITELN(destino);            {saida 1.234,56}
    READLN;
END.

POS
Esta funo retorna aposio que uma substring ocupa dentro de uma string
passada como parmetro. Se a funo retornar 0,  porque o elemento de
pesquisa no foi encontrado na string. Sua sintaxe:
            POS(<pesq>:STRING;<objeto>:STRING):BYTE;

PROGRAM teste_pos;

BEGIN
    WRITELN(A posio do primeiro espao nesta , frase  :, POS( , A
posio d, primeiro espao nesta frase  :));
    READLN;
END.

VAL 
Este procedimento converte uma string passada como parmetro para valor
numrico. Caso o contedo da string no seja numrico, o fato ser informado
em uma varivel de retorno de erro. Se o retorno de erro for <>de 0, implica
em um erro de converso. Esta  a posio onde ocorreu o primeiro erro. Se
no for usada a diretiva de compilao {$R-}, os erros de faixa tambm sero
acusados. Sua sintaxe:
            VAL(<fonte>:STRING; VAR<destino>;VAR<erro>:INTEGER);

PROGRAM teste_val;

USES        CRT;

VAR
    s     :STRING[13];
    int   :REAL;
    erro  :INTEGER;

BEGIN
    CLRSCR;
    REPEAT
    GOTOXY(12,10);
    WRITE(Entre com um valor numric, real :        );
    GOTOXY(47,10);
    REDALN(s);
    VAL(s,int,erro);
    IF erro<>0
        THEN
            BEGIN
            GOTOXY(12,12);
            WRITE(Houve um erro na posio , erro);
            DELAY (1000);
            GOTOXY(12,12);
            WRITE(                     );
        END;
    UNTIL erro=0;
    DELAY(1000);
END.

STR
Este procedimento permite a converso de uma varivel numrica em string,
inclusive determinando o tamanho da string e quantas casas deciamis, para
nmeros reais, dever ter a mesma. Sua sintaxe:
            STR(<valor>[:<tamanho>[:<dec>]];VAR<dest>:STRING);

PROGRAM teste_str;
VAR
    s:STRING[20];

BEGIN
    STR(987.65,s);
    WRITELN(Converso sem especificao d, tamanho ,s);
    STR(987.65:12,s);
    WRITELN (Converso com especificao d,tamanho ,s);
    STR(987.65:12:2,s);
    WRITELN(Converso com especificao ,decimal 2 ,s);
    STR(987.65:12:0,S);
    WRITELN(Converso com especificao ,decimal 0 ,s);
    READLN;
END.

A primeira sada o tamanho da converso  feita de acordo com a necessidade
para a escrita do nmero no formato cientfico, ficando o resultado de "s"
9.8765000000E+02. J na segunda sada, aconverso foi feita utilizando a
especificao de tamanho total mximo, ficando o resultado em "s" no formato
cientfico 9.87650E+02. Na terceira sada, foram especificados tantoo
tamanho total quanto o nmero de casasdecimais, ficando a string"s"com seu
tamanho total 12, porm o nmero foi convertido no formato aritmtico e o
contedode "s"ficou 987.65, por fim na ltima sada, temos especificado o
mesmo tamanho total, 12,para a converso, porm com o valor decimal 0. Sendo
assim o contedo de "s" arredondado e mostrado como um valor inteiro 988.
Vejamos agora, um exemplo um pouco mais completo, usando os conhecimentos
adquiridos at este momento:

PROGRAM exemplo_str_x_val;

USES    CRT;

VAR
    x    :STRING[30];
    r1,r2:REAL;
    aux  :BYTE;
    erro :INTEGER;
    op   :CHAR;
BEGIN
    REPEAT
    CLRSCR;
    x:=Calculadora computadorizada ;
    GOTOXY((80-LENGTH(x))DIV 2,2);
                                   {centraliza amensagem}
    WRITE(x);
    REPEAT
        GOTXY(10,10);
        WRITE(Entre com o primeiro operando:    );
        GOTOXY(42,10);
        READLN(x);
        WHILE POS(.,x) <> 0DO
        DELETE(x,POS(.,x),1);
                           {retira os pontos de edio}
        aux :=POS(,,x);
        IF aux <> 0
            THEN
            BEGIN
                DELETE(x,aux,1);       {retira a vrgula}
                INSERT(.,x,aux);     {e coloca um ponto}
            END;
        VAL(x,r1,erro);
    UNTIL erro=0;
    GOTOXY(10,12);
    WRITE(Entre com o tipo de operao(+,-,*,/));
    REPEAT
        op :=READKEY;
    UNTIL op IN [+,-,*,/];
    WRITE(op);
    REPEAT
        GOTOXY(10,14);
        WRITE(Entre com o segundo operando :     );
        GOTOXY(42,14);
        READLN(x);
        WHILE POS(,,x) <> 0 DO
            DELETE(x,POS(.,X),1);
                        {retira os pontos de dio}
        aux :=POS(,,x);
        IF aux <> 0
            THEN
                BEGIN
                    DELETE (x,aux,1);   {retira a vrgula}
                    INSERT(.,x,aux);  {e coloca um ponto}
                END;
            VAL(x,r2,err);
        UNTIL erro=0;
        CASE op OF
            +:STR ((r1 +r2) :15:2,x);
            -:STR((r1 - r2) :15:2,x);
            *:STR((r1 * r2) :15:2,x);
            /:STR((r1 / r2) :15:2,x);
        END;
        WHILE POS ( ,x) <> 0DO
            DELETE (x,POS( ,x),1);
        IF POS (.,x) <> 0 
            THEN        
                BEGIN
                    aux :=POS(.,x);
                    DELETE (x,aux,1);
                    INSERT(,,x,aux);
                END;
            IF LENGTH(x) >6
                THEN
                    INSERT(.,x,LENGTH(x)-5);
            IF LENGTH(x) >10
                THEN
                    INSERT(.,x,LENGTH(X)-9);
                    IF LENGTH (x) >14
                THEN
                    INSERT(.,x,LENGTH(x)-13);
                GOTOXY(10,16);
                WRITE(O resultado da operao   ,x);
                GOTOXY(10,25);
                WRITE (Deseja nova operao ?  S/N? );
                REPEAT
                  op := UPCASE(READKEY);
                UNTIL op IN [S,N];
            UNTIL op = N;
END.
