




                               CAPTULO 13          
            
                                 UNIDADES       
                                          
            
            
            13.1. AS UNIDADES PADRO     
            
                 Uma unidade  (unit)  uma coleo de constantes, tipos,
            variveis, funes  e procedimentos.    uma  biblioteca  de
            declaraes e  comandos que pode ser compilada separadamente
            e incorporada a outros programa atravs do USES:
            
                           USES unidade1, unidade2, ... ;
            
                 O Pascal  tem 8  unidades padro: SYSTEM, CRT, PRINTER,
            DOS, OVERLAY,  GRAPH, TURBO3  e GRAPH3. As 5 primeiras esto
            armazenadas no  arquivo TURBO.TPL.  As 3 ltimas em arquivos
            prprios (GRAPH.TPU,  TURBO3.TPU, GRAPH3.TPU). Descreveremos
            brevemente cada uma dessas unidades a seguir.
            
                 SYSTEM   ---> Contm  todas as  funes e procedimentos
            padro do Pascal:
            
                 Abs         Addr         Append       ArcTan
                 Assign      BlockRead    BlockWrite   ChDir
                 Chr         Close        Concat       Copy
                 Cos         CSeg         Dec          Delete
                 Dispose     DSeg         Eof          Eoln
                 Erase       Exit         Exp          FilePos
                 FileSize    FillChar     Flush        Frac
                 FreeMem     GetDir       GetMem       Halt
                 Hi          Inc          Insert       Int
                 IOResult    Length       Ln           Lo
                 Mark        MaxAvail     MemAvail     MkDir
                 Move        New          Odd          Ofs
                 Ord         ParamCount   ParamStr     Pi
                 Pos         Pred         Ptr          Random
                 Randomize   Read         ReadLn       Release
                 Rename      Reset        Rewrite      RmDir
                 Round       RunError     Seek         SeekEof
                 SeekEoln    Seg          SetTextBuf   Sin
                 SizeOf      SPtr         Sqr          Sqrt
                 SSeg        Str          Succ         Swap
                 Trunc       Truncate     UpCase       Val
                 Write       WriteLn
            
                 Para maiores  informaes a  respeito de cada um desses
            comandos, use  as telas  de ajuda  (help) do  Pascal (veja o
            apndice C). Digite o nome do comando na janela de edio do
            Pascal, posicione  o cursor  em cima  do  nome  e  pressione
            simultaneamente CTRL e F1.
            

                                       - 201 -





                 DOS       --->  Define procedimentos  e funes que so
            equivalentes aos comandos do MS-DOS mais comuns:
            
                DiskFree     DiskSize    DosExitCode   DosVersion
                EnvCount     EnvStr      Exec          FExpand
                FSearch      FSplit      FindFirst     FindNext
                GetCBreak    GetDate     GetEnv        GetFAttr
                GetFTime     GetIntVec   GetTime       GetVerify
                Intr         Keep        MsDos         PackTime
                SetCBreak    SetDate     SetFAttr      SetFTime
                SetIntVec    SetVerify   SetTime       SwapVectors
                UnpackTime
            
                 CRT       --->  Contm comandos para entrada e sada de
            dados e manipulao da tela em modo texto.
            
                 AssignCrt    ClrEol     ClrScr           Delay
                 DelLine      GotoXY     HighVideo        InsLine
                 KeyPressed   LowVideo   NormVideo        NoSound
                 ReadKey      Sound      TextBackground   TextColor
                 TextMode     WhereX     WhereY           Window
            
                 OVERLAY --->  D suporte  ao sistema  de  "overlay"  do
            Pascal. "Overlays" so partes de um programa que compatilham
            uma mesma rea da memria.
            
                 PRINTER --->  Contm a declarao de um arquivo chamado
            LST, associado  impressora.
            
                 GRAPH    --->  Conjunto de constantes e comandos para a
            construo  de   telas  grficas.  Contm  os  seguintes  79
            procedimentos e funes:
            
                Arc                Bar                Bar3D
                Circle             ClearDevice        ClearViewPort
                CloseGraph         DetectGraph        Drawpoly
                Ellipse            FillEllipse        FillPoly
                FloodFill          GetArcCoords       GetAspectRatio
                GetBkColor         GetColor           GetDefaultPalette
                GetDriverName      GetFillPattern     GetFillSettings
                GetGraphMode       GetImage           GetLineSettings
                GetMaxMode         GetMaxColor        GetMaxX
                GetMaxY            GetModeName        GetModeRange
                GetPalette         GetPaletteSize     GetPixel
                GetTextSettings    GetViewSettings    GetX
                GetY               GraphDefaults      GraphErrorMsg
                GraphResult        ImageSize          InitGraph
                InstallUserDriver  InstallUserFont    Line
                LineRel            LineTo             MoveRel
                MoveTo             OutText            OutTextXY
                PieSlice           PutImage           PutPixel
                Rectangle          RegisterBGIdriver  RegisterBGIfont
                RestoreCrtMode     Sector             SetActivePage
                SetAllPalette      SetAspectRatio     SetBkColor

                                       - 202 -





                SetColor           SetFillPattern     SetFillStyle
                SetGraphBufSize    SetGraphMode       SetLineStyle
                SetPalette         SetRGBPalette      SetTextJustify
                SetTextStyle       SetUserCharSize    SetViewPort
                SetVisualPage      SetWriteMode       TextHeight
                TextWidth
            
                 GRAPH3   ---> Comandos  grficos da  verso 3  do Turbo
            Pascal.  uma espcie de verso antiga da unidade GRAPH.
            
                 TURBO3   ---> Comandos  da verso 3 do Pascal que foram
            modificados a partir da verso 4.
            
                 As unidades  GRAPH3 e TURBO3 s tm alguma utilidade na
            compilao de  algum programa velho, feito com a verso 3 ou
            anterior.
            
            
            13.2. UNIDADES DO USURIO  
            
                 O  usurio   pode  construir  suas  prprias  unidades,
            compostas das  funes, constantes,  etc. que  ele  desejar.
            Para isso, ele deve:
            
                 (1) Iniciar  com um cabealho identificado pela palavra
            reservada UNIT,  seguido do  nome da  unidade e  um ponto-e-
            vrgula:
                                UNIT NomeDaUnidade;
            
                 (2) Logo  depois  do  cabealho,  a  palavra  reservada
            INTERFACE identifica  a parte  da unidade que ser acessvel
            pelo programa que a usar.
            
                 (3) Depois  da palavra  INTERFACE,  deve-se  listar  as
            constantes, tipos,  variveis e  o   cabealho das funes e
            procedimentos que vo fazer parte da unidade e que vo poder
            ser usadas  por outros programas. Se for necessrio, deve-se
            colocar logo  depois da  palavra INTERFACE,  um comando USES
            listando o  nome de  outras unidades que vo ser usadas pela
            unidade que  est sendo  definida.  Assim,    possvel  uma
            unidade usar outras unidades.
            
                 (4) A  palavra reservada  IMPLEMENTATION sinaliza o fim
            da interface  da unidade  e o  incio da  implementao,  ou
            seja, das definies das funes e procedimentos da unidade.
            
                 (5) Opcionalmente,  a implementao pode iniciar com um
            USES, listando o nome de outras unidades que vo ser usadas.
            
                 (6) Na implementao deve-se definir todas as funes e
            procedimentos listados  na interface.  Nestes  casos,  basta
            escrever o  cabealho da funo ou procedimento e defini-los
            da maneira  habitual.   possvel se  omitir os parmetros e
            tipos na  segunda vez  em que  cada cabealho  for  escrito.

                                       - 203 -





            Pode-se tambm  declarar e definir na implementao funes,
            procedimentos,  constantes,  etc.  que  vo  ser  conhecidos
            apenas pelos outros objetos da unidade.
            
                 (7) A  definio de uma unidade deve se encerrar com um
            END seguido de um ponto. Se for necessrio se atribuir valor
            inicial a  alguma varivel  da unidade,  ento coloca-se  um
            BEGIN  antes   do  END   final  e  fazem-se  as  atribuies
            desejadas.
            
                 Uma unidade tem, ento, o seguinte aspecto:
            
                 UNIT Nome_da_unidade;
                 INTERFACE
                 USES unidade1, unidade2, ...;            (* opcional *)
                 ...
                  (* Declaraes e cabealhos  dos objetos "pblicos" *)
                  (* da unidade.                                      *)
                 ...
                 IMPLEMENTATION
                 USES unidade3, unidade4, ...;            (* opcional *)
                 ...
                  (* Declaraes e definies  dos objetos "privados" *)
                  (* da unidade. Implementaes das funes e  proce- *)
                  (* dimentos.                                        *)
                 ...
                 BEGIN                                    (* opcional *)
                 (* Inicializao de variveis *)         (* opcional *)
                 END.
            
                 Quando uma  unidade EXEMPLO.PAS  compilada em disco, 
            criado um  arquivo com  extenso .TPU (EXEMPLO.TPU). Da, os
            objetos "pblicos"  (aqueles  declarados  na  interface)  de
            EXEMPLO podem  ser usados por qualquer programa que contenha
            um USES EXEMPLO; .
                 O uso  de unidades   parecido com o uso de arquivos de
            incluso, com  uma vantagem:  a unidade  pode ser  compilada
            previamente no disco, enquanto o arquivo de incluso tem que
            estar no disco em modo texto (programa fonte).
            
            Exemplo: Construiremos  agora uma  unidade formada  por  uma
            varivel W  cujo valor  inicial    -3*Pi/4,  as  constantes
            LINHASPORPAGINA  =  50  e  MAX  =  100,  o  tipo  VETOR,  os
            procedimentos  TROCA  e  COR  (j  conhecidos  de  captulos
            anteriores) e  uma funo  potncia de expoente inteiro POT.
            Chamaremos esta  unidade de  TESTE, que  ser  compilada  em
            disco sob o nome de TESTE.TPU.
            
            
            (* ====================================================== *)
            (*                      TESTE.PAS                         *)
            (* ====================================================== *)
            
            UNIT Teste;

                                       - 204 -





            
            INTERFACE
            
            VAR
              W: real;
            
            CONST
              LinhasPorPagina = 50;
              Max = 100;
            
            TYPE
              vetor = array [1..Max] of integer;
            
            PROCEDURE Troca(VAR x, y: real);
            PROCEDURE Cor(x, y: byte);
            FUNCTION Pot(x: real; n: byte): real;
            
            (* ====================================================== *)
            
            IMPLEMENTATION                 (* Inicio da implementacao *)
            
            USES
              Crt;     (* O uso de CRT  feito pelo procedimento COR *)
            
            (* ------------------------------------------------------ *)
            
            PROCEDURE Troca;
            
            VAR
              aux: real;
            
            BEGIN
              aux := x; x := y; y := aux
            END;
            
            (* ------------------------------------------------------ *)
            
            PROCEDURE Cor;
            
            BEGIN
              TextColor(x); TextBackground(y)
            END;
            
            (* ------------------------------------------------------ *)
            
            FUNCTION Pot;
            
            VAR
              i: byte;
              aux: real;
            
            BEGIN
              aux := 1;
              for i := 1 to n do

                                       - 205 -





                aux := aux*x;
              Pot := aux
            END;
            
            (* ------------------------------------------------------ *)
            
            BEGIN
              W := -3*Pi/4
            END.                              (* Fim da implementacao *)
            
            (* ====================================================== *)
            
            
                 Um programa que usa a unidade TESTE acima :
            
            
            PROGRAM Usando_TESTE;
            
            USES
              Teste;
            
            BEGIN
              Writeln('O valor de ', W, ' elevado a 5 e'' ', Pot(W, 5))
            END.
            
            Exemplo: Nosso  ltimo exemplo  constri uma unidade chamada
            MAX_MIN formada de duas funes, MAX3 e MIN3, que calculam o
            maior e  o menor  entre 3  nmeros  reais,  respectivamente.
            Observe que  MAX3 e  MIN3 usam  na sua definio duas outras
            funes, MAX2 e MIN2, definidas na implementao da unidade.
            Essas funes MAX2 e MIN2 no podem ser usadas por programas
            que usem a unidade MAX_MIN, porque elas no esto declaradas
            na interface.
            
            
            UNIT Max_Min;
            
            INTERFACE
            
            FUNCTION Max3(x, y, z: real): real; (* Calcula o maior *)
                                                (* entre x, y e z  *)
            
            FUNCTION Min3(x, y, z: real): real; (* Calcula o menor *)
                                                (* entre x, y e z  *)
            
            (* ------------------ Fim da interface ------------------ *)
            
            IMPLEMENTATION
            
            
            FUNCTION Max2(x, y: real): real;
            
            (* Calcula o maior entre x e y *)
            

                                       - 206 -





            BEGIN
              if (x > y) then Max2 := x else Max2 := y
            END;
            
            
            FUNCTION Min2(x, y: real): real;
            
            (* Calcula o menor entre x e y *)
            
            BEGIN
              if (x < y) then Min2 := x else Min2 := y
            END;
            
            
            FUNCTION Max3(x, y, z: real): real;        (* Poderia ser *)
                                       (* simplesmente FUNCTION Max3; *)
            
            BEGIN
              Max3 := Max2(Max2(x, y), z)
            END;
            
            
            FUNCTION Min3(x, y, z: real ): real;       (* Poderia ser *)
                                       (* simplesmente FUNCTION Min3; *)
            
            BEGIN
              Min3 := Min2(Min2(x, y), z)
            END;
            
            
            END. (* Fim da unidade *)
            
            
                 Como exemplo  do uso  dessa unidade,  temos o  seguinte
            programa:
            
            
            PROGRAM Usando_MAX_MIN;
            
            USES
              Max_Min;
            
            VAR
              a, b, c: real;
            
            BEGIN
              Write('Forneca 3 numeros reais: '); Readln(a, b, c);
              Writeln;
              Writeln('O maior dos tres e'' ', Max3(a, b, c):10:4);
              Writeln('e o menor e'' ', Min3(a, b, c):10:4)
            END.
            
                 Deixamos, como  exerccio, que  o leitor  construa suas
            prprias unidades  com as funes que ele achou interessante

                                       - 207 -





            ao longo  dos captulos  deste texto.  Talvez fosse  uma boa
            opo  juntar   as  funes   matemticas  (trigonomtricas,
            hiperblicas, fatorial, MD MM etc.) do captulo 5 em uma
            unidade chamada FUNCOES.TPU.
                 As funes  ou procedimentos  que fazem  parte  de  uma
            unidade e  que no  forem usadas  efetivamente pelo programa
            no sero  incorporadas   verso  executvel  do  programa.
            Dessa forma  no h  perigo de  se aumentar  o tamanho de um
            programa .EXE  usando uma  unidade que tenha mais funes do
            que o necessrio.
            
            
            13.3. USANDO TPUMOVER      
            
                 O arquivo  TURBO.TPL das  unidades padro  System, Crt,
            Dos, Printer  e Overlay,  pode ser  alterado   vontade pelo
            usurio. Para isso ele deve usar um utilitrio que faz parte
            dos arquivos do Pascal, chamado TPUMOVER.EXE. O usurio pode
            retirar ou  acrescentar a  TURBO.TPL qualquer  outra unidade
            que ele ache interessante.
                 Para ver  quais  as  unidades  contidas  atualmente  em
            TURBO.TPL digite  no "prompt"  do DOS  a palavra  TPUMOVER e
            pressione a  tecla ENTER. Aps um pequeno intervalo de tempo
            aparecero as duas janelas do "Turbo Pascal Unit Librarian",
            com os nomes das unidades na primeira janela.
                 Para retirar uma unidade de TURBO.TPL, digite:
            
                      [C:\] TPUMOVER TURBO.TPL /-Nome_da_unidade
            
                 Para acrescentar uma unidade a TURBO.TPL, digite:
            
                      [C:\] TPUMOVER TURBO.TPL /+Nome_da_unidade
            
                 Por exemplo,  TPUMOVER Turbo.Tpl  /-Overlay /+Graph.Tpu
            retira  a   unidade  OVERLAY   de  TURBO.TPL   e  acrescenta
            GRAPH.TPU.
            
                 As unidades  incorporadas a  TURBO.TPL podem ser usadas
            de imediato  por qualquer  programa. No  caso de uma unidade
            TESTE.TPU ter sido incorporada a TURBO.TPL, basta colocar um
            USES TESTE;  no programa. No  necessrio assim ter arquivo
            TESTE.TPU nem  TESTE.PAS no disco, na hora em que o programa
            for compilado ou executado.
            
            
            
            
            
            
            
            
            
            
            

                                       - 208 -
