III.2.3 - A declarao type

    Alm dos tipos de dados pr-definidos no Turbo Pascal,  podemos  tambm
    definir novos tipos atravs da declarao Type. A sua sintaxe geral :

    Type identificador = (valor1,valor2,valor3,valor4, ... ,valorN);

    O identificador deve seguir as regras  dadas  anteriormente  e entre os
    parentses esto os valores que podem ser assumidos. Exemplos:

    Type
        cor        = (azul,vermelho,branco,verde,amarelo);
        dia_til   = (segunda,tera,quarta,quinta,sexta);
        linha      = string[80];
        idade      = 1..99;

    (* a partir deste instante, alm dos tipos de dados pr-definidos,
       podemos  tambm utilizar os novos tipos definidos cor,dia_til,
       linha e idade *)

    Var
        i       : integer;
        d       : idade;
        nome    : linha;
        dia     : dia_til;
        cores   : cor;

                (* etc. *)

    Observao: Quando damos os valores que os dados podem assumir  atravs
                da declarao type, o Turbo Pascal assume,  automaticamente,
                que o valor da direita vale mais que  o da esquerda e  assim
                por diante. Por exemplo: no caso da definio de cor,amarelo
                vale mais que verde, que por sua vez  vale mais que branco e
                assim por diante.


III.3 - Constantes
        ----------

III.3.1 - A declarao const

    Nesta subrea, podemos definir  tantas  constantes  quantas  quisermos.
    Sintaxe:

    Const
            Meu_nome = 'Thelmo';
            cor_preferida = 'verde';
            nmero_mximo = 24345;

        (* e assim por diante *)

    Toda  vez  que  nos  referirmos   s  constantes  acima, o Turbo Pascal
    substitui-las- pelos seus respectivos valores.


III.3.2 - Constantes pr-definidas

    Existem  algumas constantes pr-definidas e que podemos utiliz-las sem
    ter que declar-las. So elas:

    PI = 3.1415926536E + 00
    FALSE
    TRUE
    NIL                      Pointer nulo, veremos mais adiante.
    MAXINT = 32767


III.3.3 - Constantes tipadas

    A declarao  de   variveis  na  subrea Var, apenas reserva espao de
    memria  para  elas, mas no as inicializa, ou seja, at que se atribua
    valores   a  elas,   seus  valores   sero   desconhecidos.  Sob certas
    circunstncias, seria interessante que pudssemos ao mesmo tempo em que
    declaramos  a  varivel,  dar  seu valor inicial. Isto  possvel com o
    conceito de constante tipada cuja sintaxe :

    Const varivel : tipo = valor;

    Exemplos:

    const Contador : integer = 100;
          c : char = 'A';

    Estamos  definindo  duas  variveis, uma chamada contador que  inteira
    e  vale  inicialmente  100, e outra chamada c que  do tipo char e cujo
    valor inicial  'A'.


III.4 Operadores
      ----------

III.4.1 - Operadores aritmticos

    +   adio
    -   subtrao
    *   multiplicao
    /   diviso entre nmeros reais
    DIV diviso entre nmeros inteiros
    MOD resto da diviso

    (*******************************************************)
       PROGRAMA EXEMPLO : Mostra como utilizar operadores
                           aritmeticos
    ********************************************************)

    Program Operadores_aritimeticos;
    Uses CRT;

    Var    x,y,z : integer;
           r1,r2 : real;

    Begin
       ClrScr;       (* limpa a tela *)
       x:=10;
       y:=20;
       z:=x+y;
       writeln(z);   (* escreve o valor de z na tela de
                        video *)
       x:= 20 DIV 3;
       y:= 20 MOD 3;
       writeln(x);   (* escreve 6 na tela *)
       writeln(y);   (* escreve 2 na tela *)
       r1:=3.24;
       r2:=r1/2.3;
       writeln(r2);
    end.


III.4.2 - Operadores lgicos

    AND     E lgico
    OR      OU lgico
    XOR     OU EXCLUSIVO lgico

    Estes operadores s aceitam como operandos, valores lgicos, ou  seja :
    TRUE e FALSE .

    A operao AND resulta em TRUE se e somente se todos os operandos forem
    TRUE, se um deles ou mais de um for FALSE ento o resultado ser FALSE.

    A operao OR resulta TRUE quando pelo menos um dos operandos for TRUE.

    A operao XOR resulta TRUE quando os operandos forem diferentes  entre
    si, isto , quando um for TRUE o outro dever ser FALSE.

    Exemplo:
    (*******************************************************)
      PROGRAMA UTILIZANDO OS OPERADORES LOGICOS
    (*******************************************************)

    Program operadores_logicos;
    Uses CRT;

    Var x,y : boolean;

    Begin
       x:=TRUE;
       y:=FALSE;
       Writeln( x OR y );         (* escreve TRUE *)
       Writeln( x AND y );        (* escreve FALSE *)
       Weiteln( x XOR y );        (* escreve TRUE *);
    End.

III.4.3 - Operadores relacionais

    O Turbo Pascal possui ao todo 7 operadores relacionais que  so   muito
    utilizados nas tomadas de decises, so eles:

    =       igual
    <>      diferente
    >       maior que
    <       menor que
    >=      maior ou igual que
    <=      menor ou igual que
    IN      testa se um elemento est incluso em um conjunto

    Exemplos:

    1-) Se A=30  e B=50     ento

     ( A = B )      FALSE
     ( A < B )      TRUE

    2-) Se A=TRUE e B=FALSE

     ( A <> B )     TRUE
     ( A = B  )     FALSE

    3-) Se A=50 , B=35, C='A' , D='B'

     ( ( A < B ) OR ( C < D ) )          TRUE

        A  avaliao  ser  verdadeira se   uma  ou  outra  expresso   for
        verdadeira, no caso, como C < D ento a resposta  TRUE


III.4.4 - Operadores entre bits

    Os operadores entre bits s podem ser aplicados em dados dos tipos byte
    ou integer e o resultado  do tipo integer. Eles agem bit a bit e podem
    ser aplicados na notao hexadecimal ou decimal. So eles:

    SHL - SHift Left

    Desloca  n  bits  esquerda. Durante o deslocamento, os bits  esquerda
    so perdidos e dgitos zeros preenchem a posio direita. Exemplos:

    1-) Se X = 00010101 ento

        X shl 2 = 01010100
        X shl 5 = 10100000

    2-) 55 shl 3 = 184

        55 = 00110111  deslocando 3  esquerda ficaria:
        10111000 que  igual a 184

    3-) $F0 shl 2 = $C0

        $F0 = 11110000 deslocando 2  esquerda ficaria:
        11000000 que  igual a $C0

    SHR - SHift Right

    Desloca n bits  direita. Durante o deslocamento,os bits  esquerda so
    preenchidos com zeros e os da direita so perdidos. Exemplos:

    1-) Se X = 10101100 ento

        X shr 3 = 00010101
        X shr 6 = 00000010

    2-) 55 shr 3 = 6

        55 = 00110111 deslocando 3  direita ficaria:
        00000110 que  igual a 6

    3-) $F0 shr 2 = $3C

        $F0 = 11110000 deslocando 2  direita ficaria:
        00111100 que  igual a $3C

    OBS: J sei, vc no manja de base 2, eh eh eh, entonces  complica,  bem
         vou tentar em poucas palavras explicar a base 2. Ns   operamos na
         base 10, porque trabalhamos com 10 algarismos, 0..9, certo? Bem na
         base 2 operamos  somente com 2 algarismos, o 0 e o 1. Dessa forma,
         temos que  representar  todos  os   nmeros  da base 10 utilizando
         somente o 0 e 1.  Parece complicado ? Nem  tanto,  veja  abaixo  a
         correspondncia:

        BASE 10      BASE 2
           0            0
           1            1
           2           10
           3           11
           4          100
           5          101
           6          110
           7          111
           8         1000
           9         1001
          10         1010
          11         1011
         e assim por diante

    Para converter um nmero da base 10 para a  base  2,  basta  dividir  o
    nmero, o qual queremos converter, por dois sucessivamente  at  que  o
    resto seja 0, depois pegamos  os  restos  de  baixo para cima, exemplo:

        (23)    --> (    )
            10            2

    23 / 2 d 11 e sobra 1
    11 / 2 d 5  e sobra 1
     5 / 2 d 2  e sobra 1
     2 / 2 d 1  e sobra 0
     1 / 2 d 0  e sobra 1

    Portanto (23) --> (10111)
                 10          2

    Para coverter da base 2 para a base 10, devemos fazer ao contrrio:

    (10111)  -->  (  )
           2          10


           4  3  2  1  0
        (  1  0  1  1  1 )

               4        3        2        1        0
          1 x 2  + 0 x 2  + 1 x 2  + 1 x 2  + 1 x 2 =
           16    +   0    +   4    +   2    +   1   = 23


    NOT

    O operador NOT nega os bits, isto  os bits iguais a 1 se tornam 0 e os
    bits zero se tornam 1. Devemos lembrar,  no  entanto,   que os inteiros
    possuem 2 bytes, portanto,ao se trabalhar com nmeros decimais inteiros
    ser afetado o byte de mais alta ordem e tambm o sinal. Exemplo:

    NOT (255) = -256

    Para suprimir este problema, voc deve trabalhar com bytes:

    Program Exemplo;
    Uses CRT;

    Var i,j : Byte;

    Begin
       ClrScr;
       i:=255;
       j:=NOT(i);
       Writeln(j);     (* ser escrito 0 *)
    End.


    AND

    Este  operador  realiza  a operao E lgico bit a bit. Relembrando,  a
    operao  E resulta em 1 se e somente se os dois operandos forem iguais
    a 1, caso contrrio, o resultado ser igual a 0. Exemplos:

    1-) $0F AND $F0 = $0 pois
        $0F = 00001111
        $F0 = 11110000
            00001111 AND 11110000 = 00000000

    2-) 255 AND 55 = 55 pois
        255 = 11111111
        55  = 00110111
            11111111 AND 00110111 = 00110111

    3-) 34 AND 76 = 0 pois
        34 = 00100010
        76 = 01001100
            00100010 AND 01001100 = 00000000

    OR

    Este  operador  realiza  a operao OU lgico bit a bit. Relembrando, a
    operao  OU  resulta  em 1 se um ou os dois operandos forem iguais a 1.
    Exemplos:

    1-) $0F OR $F0 = $FF pois
        $0F = 00001111
        $F0 = 11110000
            00001111 OR 11110000 = 11111111

    2-) 255 OR 55 = 255 pois
        255 = 11111111
        55  = 00110111
            11111111 OR 00110111 = 11111111

    3-) 34 OR 76 = 110 pois
        34 = 00100010
        76 = 01001100
            00100010 OR 01001100 = 01101110

    XOR

    Este   operador  realiza  a  operao   OU  EXCLUSIVO lgico bit a bit.
    Relembrando, a operao OU EXCLUSIVO resulta em 1 se os operandos forem
    diferentes entre si . Exemplos:

    1-) $0F XOR $F0 = $FF pois
        $0F = 00001111
        $F0 = 11110000
            00001111 XOR 11110000 = 11111111

    2-) 255 XOR 55 = 200 pois
        255 = 11111111
        55  = 00110111
            11111111 XOR 00110111 = 11001000

    3-) 34 XOR 76 = 110 pois
        34 = 00100010
        76 = 01001100
            00100010 XOR 01001100 = 01101110


III.4.5 - Concatenao

    Esta  operao   representada   pelo  sinal de adio, ou seja, +.  Os
    operandos devem ser do tipo string ou char. Exemplo:

    'Isto  uma ' + 'string' = 'Isto  uma string'

Ŀ
IV - Entrada e sada de dados


IV.1 - Write e Writeln
       ---------------
    Estas  so  as principais procedures destinadas a exibir todos os tipos
    de dados no vdeo. A diferena entre write  e writeln reside no fato de
    que  a  procedure  write escreve o parmetro, e mantm o cursor do lado
    daquilo   que  foi  escrito, enquanto que writeln passa o cursor para a
    prxima linha. Estas procedures possuem 3 formas de sintaxes, a saber:

    Primeira forma:

    Write(parmetro_1,Parmetro_2, ...);

    Exemplo:

    Program Exemplo;
    Uses CRT;
    Var  i : integer;
         r : real;
         c : char;
         s : string[20];

    Begin
       ClrScr;         (* apaga a tela e coloca o cursor em 1,1 *)
       Writeln('Exemplos de aplicacao de writeln e write');
       writeln;   (* apenas pula uma linha *)
       i:=100;
       r:=3.14;
       c:='A';
       s:='interessante';
       writeln('Valor de i e igual a ',i);
       write('valor de r = ');
       writeln(r);
       writeln(c,'   ',s);
    end.

    Este programa resultaria na seguinte tela:

    ---------------------------------------------------------
    Exemplos de aplicacao de writeln e write

    Valor de i e igual a 100
    valor de r =   3.1400000000E+00
    A interessante
    ---------------------------------------------------------

    Segunda forma:

    Write(parmetro : n);

    onde n  um nmero inteiro que determina quantas colunas o cursor  deve
    ser  deslocado  direita, antes do parmetro ser escrito. Alm disso, o
    parmetro  escrito da direita para a esquerda, exemplo:

    Program Exemplo;
    Uses CRT;
    Begin
       Writeln('A');
       Writeln('A':5);
    end.

    Resultaria a seguinte tela:
    ---------------------------------------------------------
    A
    .....A
    ---------------------------------------------------------
    Os pontos representam espaos em branco

    Terceira forma:

    Write(parmetro : n : d);

    Neste   caso,  n   tem  a  mesma funo que o caso anterior sendo que d
    representa o nmero de casas decimais. Obviamente, parmetro  ter  que
    ser do tipo Real. Exemplo:

    Program Exemplo;
    Uses CRT;
    Var r : real;

    Begin
        ClrScr;
        r:=3.14156;
        Writeln(r);
        Writeln(r:10:2);
    End.

    resultaria a seguinte tela:
    ---------------------------------------------------------
    3.1415600000E+00
           3.14
    ---------------------------------------------------------


IV.2 - Read e Readln
       -------------

    Estas   procedures   so   utilizadas  para  fazer leitura de dados via
    teclado. A procedure Read l  um dado do teclado at que se pressione a
    tecla ENTER, sendo que cada tecla digitada  ecoada para o vdeo.  Aps
    pressionarmos   ENTER,  o  cursor   permanecer  no  mesmo lugar. J, a
    procedure Readln faz a mesma coisa s que o cursor passa para a prxima
    linha. A sintaxe geral para estas procedures :

    Read (Var_1,Var_2,Var_3,...);

    Ao  se digitar os valores das variveis pedidas, deve-se separ-los por
    espaos.

    Exemplo 1:

    Program teste;
    Uses CRT;

    Var a,b,c:integer;

    Begin
       clrscr;
       readln(a,b,c);
       writeln (a,' ',b,' ',c);
    end.

    Exemplo 2:

    Program teste;
    Uses CRT;

    Var i : integer;
        r : real;
        c : char;
        s : string[10];

    Begin
       ClrScr;
       Write('Digite um numero inteiro ------> ');
       Readln(i);
       Write('Digite um numero real ---------> ');
       Readln(r);
       Write('Digite um caractere -----------> ');
       Readln(c);
       Write('Digite uma string -------------> ');
       Readln(s);
       Writeln;Writeln;  (* pula duas linhas *)
       Writeln(i);
       Writeln(r);
       Writeln(c);
       Writeln(s);
    End.

    Exemplo 3:

    (*******************************************************)
     PROGRAMA AREA_DE_TRIANGULOS : calcula area de triangulos
    (*******************************************************)

    Program Area_de_Triangulos;
    Uses CRT;

    Var Base,        (* base do triangulo   *)
        altura:      (* altura do triangulo *)
                Real;

    Begin
       ClrScr;
       Writeln('CALCULO DA AREA DE TRIANGULOS':55);
       Writeln;
       Write('Valor da base ------> ');
       Readln(base);
       Writeln;
       Write('Valor da altura ----> ');
       Readln(altura);
       Writeln;
       Writeln;
       Writeln('Area do triangulo = ',base*altura/2 : 10 : 2);
    End.

    ReadKey: L uma tecla do teclado, sem que seja necessrio pressionar  a
             tecla ENTER

    Program Exemplo;
    Uses CRT;
    Var tecla:char;
    Begin
        Write('digite uma tecla ->');
        Tecla:=readkey;
        Writeln;
        writeln('vc digitou ',tecla);
    end.

IV.3 - Impressora
       ----------

    Podemos  enviar  dados para a impressora atravs das procedures Write e
    Writeln.  Para tanto,   devemos  colocar,  antes dos parmetros a serem
    enviados  impressora, o nome lgico LST. Exemplo:

    Writeln('isto vai para o vdeo');
    Writeln(lst,'isto vai para a impressora',' e isto tambm');


IV.4 - Funes e procedures para controle de vdeo
       -------------------------------------------

IV.4.1 - ClrScr

    Esta  procedure tem a finalidade de limpar a tela de vdeo e colocar  o
    cursor na primeira coluna da primeira linha. A tela de vdeo  dividida
    em  80  colunas  e 25 linhas. O canto superior esquerdo tem coordenadas
    (1,1) e o inferior direito (80,25).

IV.4.2 - Gotoxy(x,y)

    Move o cursor para a coluna x e linha y.

    Exemplo:

    Program Exemplo;
    Uses CRT;

    Var x,y : Byte;

    Begin
        ClrScr;
        Gotoxy(10,2);
        Write('Coluna 10 da linha 2');
        x:=40;
        y:=10;
        Gotoxy(x,y);
        Write('Coluna 40 da linha 10');
    End.


IV.4.3 - ClrEol

    Esta  procedure   limpa  desde a posio atual do cursor at o final da
    linha.


IV.4.4 - CrtExit

    Envia   para  a  tela  de   vdeo  a  string de finalizao definida na
    instalao


IV.4.5 - CrtInit

    Envia para  a   tela  de  vdeo  a  string de inicializao definida na
    instalao.


IV.4.6 - Delline

    Procedure   que  elimina   a  linha   em  que  est o cursor. As linhas
    posteriores sobem, ocupando a que foi eliminada.

    Exemplo:

    Program exemplo;
    Uses CRT;
    Begin
        ClrScr;
        Writeln('linha 1');
        Writeln('linha 2');
        Writeln('linha 3');
        Writeln('linha 4');
        Gotoxy(1,2);        (* posicionei o cursor no incio da linha 2 *)
        Delline;
    End.

    O programa anterior ir provocar a seguinte tela:
    ---------------------------------------------------------
    linha 1
    linha 3
    linha 4
    ---------------------------------------------------------
    Repare que a string 'linha 2' foi eliminada.


IV.4.7 - HighVideo

    Coloca o   vdeo   no  modo  normal.   Esta  procedure  equivalente  a
    NormVdeo.


IV.4.8 - InsLine

    Esta procedure faz examente o contrrio de Delline, ou seja, insere uma
    linha na posio atual do cursor.

    Exemplo

    Program Exemplo;

    Begin
        ClrScr;
        Writeln('linha 1');
        Writeln('linha 2');
        Writeln('linha 3');
        Writeln('linha 4');
        Gotoxy(1,3);        (* cursor na 1a. coluna da 3a. linha *)
        InsLine;
        Write('teste');
        Gotoxy(1,20);
    End.

    Este Programa provocar a seguinte tela
    ---------------------------------------------------------
    linha 1
    linha 2
    teste
    linha 3
    linha 4
    ---------------------------------------------------------


IV.4.9 - LowVideo

    Coloca   o  vdeo  em  baixa intensidade at que se execute a procedure
    NormVideo ou HighVideo.


IV.4.10 - NormVideo

    O mesmo que HighVideo


IV.4.11 - TextBackGround

    Esta   procedure   seleciona  a  cor do fundo sobre o qual o texto ser
    escrito. Sua sintaxe geral :

    TextBackGround(cor);

    Tabela de cores

    0   Black   Preto
    1   Blue    Azul
    2   Green   Verde
    3   Cyan    Ciano
    4   Red Vermelho
    5   Magenta Magenta
    6   LightGray   Cinza-claro

    Ns podemos entrar com o nmero ou o nome da cor em ingls

    Exemplo:

    Program Exemplo;
    Uses CRT;

    Begin
        ClrScr;
        WriteLn('teste');
        TextBackGround(7);
        Writeln('teste');
        TextBackGround(Brown);
        Writeln('teste');
    End.


IV.4.12 - TextColor

    Esta procedure permite selecionar a cor com que o texto ser imprimido.

        Tabela de cores

    0   Black   Preto
    1   Blue    Azul
    2   Green   Verde
    3   Cyan    Ciano
    4   Red Vermelho
    5   Magenta Magenta
    6   Brown   Marrom
    7   LightGray   Cinza-claro
    8   DarkGray    Cinza-escuro
    9   LightBlue   Azul-claro
    10  LightGreen  Verde-claro
    11  LightCyan   Ciano-claro
    12  LightRed    Vermelho-claro
    13  LightMagenta    Magenta-claro
    14  Yellow  Amarelo
    15  White   Branco
    16  Blink   Piscante

    Exemplo:

    Program Exemplo;
    Uses CRT;

    Begin
       Clrscr;
       TextBackGround(7);
       TextColor(black);
       writeln('teste');
       TextColor(black+blink);
       write('teste');
    End.


IV.4.13 - Window

    Sintaxe:  Window(x1,y1,x2,y2);

    Esta  procedure  tem o poder de definir uma janela de texto cujo  canto
    esquerdo  superior  x1,y1  e canto inferior direito  x2,y2. Aps esta
    instruo,  as  instrues ClrScr, Write Writeln agem somente dentro da
    janela    recm   definida.  A  instruo  Gotoxy passa a utilizar como
    referencial o ponto x1,y1 que passa a ser considerado 1,1.

    Exemplo:

    Program Exemplo;
    Uses CRT;
    Begin
        Window(10,10,70,20);
        ClrScr;               (* limpa somente a janela *);
        Writeln('teste');     (* escreve 'teste' em 10,10 *)
    End.


IV.4.14 - WhereX

    Funo que retorna o nmero da coluna onde est o cursor.


IV.4.15 - WhereY

    Funo que retorna o nmero da linha onde est o cursor.


IV.5 - Controle do teclado
       -------------------

IV.5.1 - Kbd

    Quando  quisermos  ler dados do teclado e que no sejam ecoados para  o
    monitor   de  vdeo  at  que  sejam processados e aceitos, ns podemos
    utilizar a seguinte sintaxe:

    Read(Kbd,Varivel);

    No  caso  de  nmeros inteiros ou reais, o nmero s ser aceito quando
    pressionarmos  a  tecla <enter>, no  caso  de variveis do tipo char, o
    caractere  ser   aceito  sem  que   seja necessrio pressionar a tecla
    <enter>, idem para o tipo string.

    Exemplo:

    Program Exemplo;
    Uses CRT;
    Var i:integer;

    Begin
        ClrScr;
        Write('Entre com um inteiro --> ');
        Readln(Kbd,i);
        Writeln(i);
    End.


IV.5.2 - BufLen

    Buflen    uma varivel interna pr-definida em Turbo Pascal cujo valor
    inicial  126.Ela contm o nmero mximo de caracteres aceitos por Read.

    Exemplo:

    Program Exemplo;
    Uses CRT;

    Var i : Integer;

    Begin
        ClrScr;
        Writeln(Buflen);    (* escreve 126 *)
        Buflen:=2;
        Write('Digite um inteiro --> ');
        Readln(i);          (* se voc tentar digitar inteiros com
                               mais de dois dgitos,  readln   no
                               permitir *)
    End.


IV.5.3 - Keypressed

    O  identificador  Keypressed   uma funo especial do Turbo Pascal que
    retorna um valor booleano - TRUE se uma tecla foi pressionada, ou FALSE
    caso contrrio. Ela  muito utilizada para detectar teclas pressionadas
    no teclado.

    Exemplo

    Program Exemplo;
    Uses CRT;
    Begin
        ClrScr;
        Write('Pressione uma tecla -> ');
        Repeat until Keypressed; (* repita at que   uma  tecla
                                    seja pressionada. O comando
                                    Repeat Until  ser estudado
                                    mais adiante *)
    End.
