Delphi - Segredos e Solues

CAPTULO 9
 
Trabalhando Arquivos

Este captulo mostra como voc, dentro de um aplicativo Delphi, deve
manipular discos e arquivos armazenados nesses discos. Comeamos com os
comandos no Delphi que  interagem com DOS - por exemplo, voc pode
renomear arquivos, mudar o drive conectado, ou mudar de diretrio
utilizando cdigo Delphi. Depois voc ver os comandos  no Delphi que
facilitam o tratamento com os arquivos - por exemplo, como descobrir
quanto espao de disco est sobrando. Em seguida, voc ver
co################################  #######
########################################################################
###
###!###"#######$###%###&###'###(###)###*###+###,###-###.###/###







mo utilizar os componentes do sistema de
arquivo na paleta  Component. Finalmente, h uma introduo ao
tratamento de arquivos no Delphi. O Delphi tem aptido para tratar tanto
os arquivos ASCII como os arquivos que contm  dados binrios, e voc
ver as tcnicas para trabalhar com os dois tipos. (Vale a pena observar
que embora o Delphi tenha muitos recursos para manipular bases de
dados, conforme discutido no Captulo 13, voc ainda tem de saber como
instalar e trabalhar diretamente com arquivos. )

NOTA: Ao trabalhar com arquivos, com freqncia voc vai querer utilizar
as caixas de dilogo comuns que acompanham o Delphi. Elas so abordadas
no Captulo 12.  Lembre-se: os usurios Windows esperam ver essas caixas
ao trabalhar com arquivos!

Comandos de Arquivo

O Delphi tem cinco comandos, resumidos na Tabela 9.1, que interagem
diretamente com DOS e imitam os comandos normais do sistema operacional.

NOTA: Qualquer funo que acesse um disco gerar um erro de
processamento se o DOS no conseguir realizar a tarefa. Veja maiores
detalhes de como tratar com esses  tipos de erro no Captulo 7.

        Desses comandos, os trs primeiros so utilizados simplesmente
seguindo-os com uma string ou expresso string. Por exemplo

      MkDir('TESTDIR')

acrescentaria um subdiretrio chamado TESTDIR ao diretrio atual. A
linha

        MkDir('C:\TESTDIR');

acrescentaria o subdiretrio ao diretrio-raiz do drive C.
        Os comandos Rename ou Erase exigem que voc atribua primeiro uma
varivel de um tipo especial chamada tipo File ao nome do arquivo. Por
exemplo, se voc  quiser renomear um arquivo denominado NOVO, para que
seja denominado VELHO, voc utilizaria o

        var
          NomeArquivo: file;
        begin
          AssignFile(NomeArquivo, 'NOVO');
          Rename(NomeArqivo, 'VELHO'I;
        end;

        Em geral, o procedimento AssignFile liga um nome de arquivo a
uma varivel de arquivo (anteriormente declarada) do tipo File.

Tabela 9.1 Comandos Delphi para Tarefas DOS.

        Comando - Funo

        ChDir - Muda o diretrio padro e o drive conectado para DOS.
        MkDir - Faz um diretrio novo.
        RmDir - Remove um diretrio.
        Rename - Muda o nome de um arquivo.
        Erase - Apaga um arquivo do disco. (H tambm uma funo
DeleteFile que funciona de maneira parecida.)

DICA PASCAL: Voc ainda pode utilizar o procedimento Assign antigo,
embora os projetistas do Delphi recomendem a utilizao do procedimento
AssignFile mais novo.

        Observe que o valor de uma varivel de arquivo tem de ser um
nome de arquivo vlido. As regras para nomes de arquivo so aquelas
impostas pelo DOS. Elas  incluem os oito caracteres padro mais uma
extenso de trs caracteres (separados por um pont

        A-Z,0-9,(It}@#$%&!-_'/~

NOTAL: Os comandos que cuidam de arquivos com freqGncia aceitam os
coringas especiais normais do DOS. Por exemplo, Erase('*.*'); apaga
todos os arquivos no diretrio  atual (no deve ser feito
acidentalmente).

 

Outras Funes de Arquivo e de E/S

Determinadas tarefas so to comuns que os projetistas do Delphi
decidiram adicion-las  prpria linguagem em vez de obrigar voc a
utilizar as chamadas API do  Windows ou shell ao DOS. (Para aqueles que
conhecem DOS, muitas delas substituem funes que utilizam a Int21 H. )
        Por exemplo, a funo DiskFree permite-lhe descobrir quanto
espao de disco est livre em um drive. A sintaxe dessa funo 

        function DiskFree(Drive: Byte): Longint

        Utilize 0 para o drive padro, 1 para A, 2 para B, 3 para C, e
assim por diante. Quando voc utiliza essa funo, o inteiro longo
devolvido  a quantidade  de espao de disco disponvel.
        Como outro exemplo, o procedimento GetDir devolve uma string que
fornece o diretrio atual de um determinado drive. Por exemplo, se voc
estabeleceu uma  varivel string chamada Drive, ento depois de uma
linha de cdigo como

        GetDir(3, Drivel;

o valor do parmetro da string Drive seria o diretrio atual no drive C.
A sintaxe geral desse procedimento 

        procedure GetDir(D: Byte; var S: String)
 
        Se o drive no  vlido, ento o procedimento estabelece o valor
do parmetro da string S como sendo string X:\.
        O que segue so discusses rpidas das mais importantes dessas
funes (consulte a ajuda on-line para obter maiores detalhes e para as
funes restantes).

        ChangeFileExt - Essa funo permite-lhe mudar a extenso do
arquivo (por exemplo, para indicar uma duplicao). A sintaxe 

       function ChangeFileExt(const NomeArguivo, Extenso: String):
String;

        A string fornecida pelo parmetro Extenso torna-se a nova
extenso do nome de arquivo dado pelo parmetro NomeArguivo.

        DiskSize - Esta funo devolve um inteiro longo que tem o
tamanho (em bytes) do drive especificado. A sintaxe 

         function DiskSize(Drive: Byte): Longint;

onde, como sempre, o parmetro Drive  0 para o drive atual, 1 para A, e
assim por diante.

        ExpandFileName - Essa funo bastante til devolve uma string
que lhe fornece o nome completo do caminho de um arquivo. A sintaxe 

        function ExpandFileName(const NomeArguivo: String): String;

        ExtractFileFxt, ExtractFileName - Como  de se esperar de seus
nomes, essas funes tomam um nome de arquivo e devolvem a extenso de
arquivo ou o nome sem  uma extenso.
        ExtractFilePath - Com freqncia, voc precisa saber o caminho
de um determinado arquivo. Esta funo pega um nome de arquivo e devolve
a letra de drive  e os diretrios que levam ao arquivo.
        FileAge, FileGetData, FileDateToDateTime - A funo FileAge
fornece a idade do arquivo; a funo FileGetDate fornece a identificao
de horrio DOS. Entretanto,  essas duas funes devolvem inteiros
longos. Utilize a funo FileDateToDateTime para pelas rotinas de data e
horrio do Delphi).
        FileExists - Essa funo Booleana muito til devolve True se o
arquivo existir e devolve False em caso contrrio. A sintaxe 
        
        function FileExists(const NomeArquivo: String): Boolean;

        A Funo FileGetAttr - A funo FileGetAttr um inteiro. Utilizar
tcnicas de mascaramento de bit no valor devolvido com as constantes
"fa" (faReadOnly, faHidden,  e assim por diante) permite-lhe determinar
como os diversos atributos so especificados. A sintaxe dessa funo 

        function FileGetAttr(const NomeArcluivo: String): Integer;

        FileSearch - Essa funo permite-lhe procurar por um arquivo em
determinados diretrios. A sintaxe 

        function FileSearch(const Nome,ListDir: String): String;

onde o parmetro Nome  o nome de arquivo e o parmetro ListDir  uma
lista de diretrios (separe-os por ponto-e-vrgula). A string devolvida
 a string vazia ou  o nome de caminho completo. Por exemplo:

        if FileSearch('CH1', 'C:\; D:\') = ' then
          ShowMessage('Oh, o arquivo est perdido!');

        A Funo FileSeAttr A funo FileSetAttr estabelece informao
de atributo para arquivos. As mesmas constantes "fa" para os diversos
atributos possveis  que foram utilizadas com a funo FileGetAttr
permitem que voc mude os diversos atributos d

        function FileSetAttr(NomeArguivo: String, ValorAtributo: Byte);
        Por exemplo
        FileSetAttr(NomeArquivo, faReadOnly + faHidden);

esconderia o arquivo e o especificaria como sendo apenas de leitura.

DICA: Utilize a funo FileSetAttr para esconder os arquivos que voc
no quer que sejam conhecidos por usurios casuais.

        Por exemplo, colocar uma senha criptografada em um arquivo
escondido para depois examin-lo  um mtodo comum (e razoavelmente
seguro) de garantir que o  programa esteja sendo utilizado pela pessoa
certa.

       FindFirst, FindNext - Essas duas funes pesquisam um diretrio
por um nome de arquivo especificado, com um conjunto de atributos
especificados.

        A sintaxe para FindFirst 
 
        function FindFirst(const Caminho: String; Atributo: Word;
           var F: TSearchRec): Integer;

        O parmetro Caminho  o nome do caminho (pode incluir coringas).
O parmetro Atributo utiliza quaisquer combinaes das constantes "fa"
que voc j viu antes.  O parmetro "F" utiliza um tipo de registro
interno que conter os resultados da pesqui

        TSearchRec = record
          Fill: array[1..21] of Byte;
          Attr: Byte;
          Time: Longlnt;
          Size: Longlnt;
          Name: string[12);
        end;

        Quando voc vai analisar esse registro, ento, por exemplo, o
campo Size fornece o tamanho do campo e o campo Name fornece seu nome.
        A sintaxe para FindNext 
 
      function FindNext(var F: TSearchRec): Integer;
       A funo FindNext utiliza a informao contida na chamada
anterior  FindFirst.

Os Componentes do Sistema de Arquivo

Os componentes do sistema de arquivo no Delphi permitem aos usurios
selecionar um drive novo, ver a estrutura de diretrio hierrquica de um
disco, ou ver os nomes  dos arquivos em um dado diretrio. Como com
todos os componentes Delphi, voc tem que escrever um cdigo para
aproveitar todas as vantagens existentes no poder dos  componentes do
sistema de arquivo. Adicionalmente, se voc quiser que o DOS mude de
drive ou diretrio como resultado de um clique no mouse pelo usurio,
ter de  escrever um cdigo que utilize os comandos dados na primeira
seo deste captulo.

NOTA: Os componentes do sistema de arquivo complementam as caixas de
dilogo comuns que voc vai ver no Captulo 12.

        Eis a paleta Component com os componentes do sistema de arquivo
marcados.

                FileListBox FiIterComboBox


                DirectoryListBox DriveComboBox

        Os componentes do sistema de arquivo so projetados para
trabalhar juntos. Por exemplo, seu cdigo verifica o que o usurio fez
a, digamos, uma DriveComboBox  e em seguida passa essa informao para
uma DirectoryListBox. As alteraes em uma Direc




O Componente FileListBox

Por padro, uma FileListBox exibe os arquivos do diretrio atual. Como
com qualquer caixa de lista, voc pode controlar a posio, o tamanho, a
cor e caracterstica  da fonte durante o projeto ou com cdigo. A
maioria das propriedades de uma FileListBox  idntica quelas das
caixas de lista comuns. Por exemplo, como com qualquer  caixa de lista,
quando o nmero de itens no combina com o tamanho atual do componente,
o Delphi adiciona automaticamente barras de deslocamento verticais. Isso
permite ao usurio se movimentar pela lista de arquivos utilizando a
barra de deslocamento.
        Igualmente, uma FileListBox pode responder a todos os eventos
que as caixas de lista conseguem detectar. Alm disso, voc pode
escrever manipuladores de  eventos para teclas pressionadas ou para um
movimento do mouse. Um ponto que vale a pena lemb simples, seleciona o
arquivo. Isso  importante de ser lembrado especialmente ao trabalhar
com uma FileListBox, porque a utilizao de uma tecla de direo para  a
movimentao pela FileListBox chamaria qualquer manipulador OnClick que
voc escreveu.
         (Lembre-se de que os movimentos das setas so funcionalmente
equivalentes a um nico clique do mouse para uma caixa de lista.)

DICA:  bastante comum utilizar as propriedades Items e Itemlndex de uma
FileListBox em vez de utilizar o comando GetDir.

Propriedades Especiais do Componente FileListBox

Voc pode utilizar a propriedade FileType de uma FileListBox para exibir
unicamente os arquivos que so apenas de leitura (o que  bom para os
usurios novatos)  ou apenas aqueles que tm o bit Archive ativado ou
desativado (isto , para indicar se os arquivos foram duplicados desde a
ltima alterao). H sete propriedades  Booleanas (True, False) que
controlam tipos de arquivo que so mostrados em uma FileListBox. So
Archive, Hidden, Normal, ReadOnly, System, VolumeID e Directory.  A
especificao padro  True para a propriedade Normal e False para as
demais propriedades.
        As outras propriedades mais importantes para uma FileListBox so
Mask, FileName e Directory. A propriedade Mask determina quais os
arquivos que so exibidos  na FileListBox. A propriedade Mask aceita os
caracteres especiais comuns do DOS: * (combi  colocada em *.* para
exibir todos os arquivos. (Evidentemente que, a propriedade Mask olha
para as especificaes das diversas propriedades de atributo antes da
exibio dos arquivos pelo Delphi. )
        As propriedades Directory e FileName estabelecem ou devolvem o
caminho atual da FileListBox, mas no para o DOS. Para informar ao DOS
que mude o caminho  atual a partir do Delphi, voc precisa do comando
ChDir. Por outro lado, voc pode apenas ter perturbar o caminho padro.
Quando voc muda a propriedade Directory ou FileName, o Delphi verifica
se voc escreveu um manipulador de evento OnChange para a FileListBox
e, nesse caso, faz sua ativao.

O Componente DirectoryListBox

Uma DirectoryListBox exibe a estrutura de diretrio do drive atual. O
diretrio atual  exibido como um envelope de arquivo aberto, e os
subdiretrios do diretrio  atual so mostrados como envelopes fechados.
Os diretrios acima do diretrio atual so exibidos como envelopes
abertos no-sombreados.

NOTA: Quando o usurio d um clique em um item ou se movimenta pela
lista, aquele item  destacado. Quando ele d um clique duplo, o Delphi
atualiza automaticamente  a DirectoryListBox.

O Componente DriveComboBox

Ao contrrio de FiIterComboBoxes e DirectoryListBoxes, as caixas
DriveComboBoxes so suspensas. Uma DriveComboBox comea exibindo o drive
atual, e depois, quando  o usurio d um clique na seta, o Delphi
apresenta uma lista com todos os drives vlidos.
        A propriedade-chave para uma DriveComboBox  a propriedade
Drive, que pode ser utilizada para devolver ou restaurar o drive atual.
Por exemplo, para sincronizar  uma DriveComboBox com uma
DirectorListBox, tudo o que voc precisa  ligar os compone para ligar
uma DriveComboBox a uma DirectoryListBox:

        DriveComboBox1.DirList := DirectoryListBoxl;

O Com ponen fe Fil terComboBox

O componente FilterComboBox  utilizado para controlar o tipo de
arquivos que o Delphi exibe em uma FileListBox. Depois de especificar a
propriedade FileList de  FilterComboBox com um nome de uma FileListBox,
especifique a propriedade Filter com os tipos de arquivo que voc quer
exibir. Eis um exemplo de cdigo:

FiIterComboBoxl.Filter :='Arquivos Doc (*.doc) |*.doc |Arquivos de Texto
*.txt) |*.txt';

Interligando Todos os Componentes de Arquivo entre Si

Quando voc est com todos os componentes de um sistema de arquivo em um
formulrio, apenas tem de especificar as propriedades de
DriveComboBox.Dirlist e DirectoryListBox.FileList  para poder comunicar
qualquer mudana entre os componentes. Em seguida, o Delphi mostra o que
o usurio quer ver.
        Voc tambm pode escrever cdigo para comunicar as mudanas
entre os componentes do sistema de arquivo. Por exemplo, se o usurio
seleciona um drive novo,  o Delphi ativa o manipulador de eventos
OnChange de DriveComboBox. Depois disso, execute os


        1. No manipulador de eventos OnChange de DriveComboBox, atribua
a propriedade DriveComboBox.Drive  propriedade DirectoryListBox.Drive.
Isso muda a exibio  em DirectoryListBox ativando seu manipulador de
eventos OnChange.
        2. No manipulador de eventos OnChange de DirectoryListBox,
atribua a propriedade DirectoryListBox.Directory  propriedade
FileListBox.Directory. Isto atualiza  FileListBox.



Arquivos de Texto

Os arquivos de texto contm caracteres ASCII legveis e so exatamente
aqueles em que voc pode utilizar o comando TYI'E do DOS para ler - sem
que um monte de lixo  venha encher a sua tela. Pense no trabalho com um
arquivo de texto no Delphi como anlogo  gravao de informao em uma
fita cassete. As operaes com arquivos  de texto anlogas s tarefas
simples realizadas com um gravador cassete, como gravar uma msica em
uma fita em branco, sero fceis de realizar. Aquelas anlogas  s
tarefas mais difceis, como emendar fitas ou fazer uma alterao em uma
fita, sero mais difceis.
        Para evitar trabalhos desnecessrios, utilize um arquivo de
texto apenas quando souber que est trabalhando com texto normal e

        *Raramente far mudanas dentro do arquivo.
        *Vai tratar (processar) a informao contida no arquivo do
comeo ao fim, sem precisar ficar pulando de um lado para outro.
        *Far acrscimos ao arquivo no seu final.

         possvel fazer mudanas dentro do arquivo, tanto pulando de um
lado para outro ao processar informao, quanto fazendo adies ao
arquivo em lugares alm  do seu final; contudo esses procedimentos so
mais dolorosos para 9 bits.

NOTA: Todas as linhas em um arquivo de texto terminam com uma combinao
retorno de carro/nova linha (Carriage Return/Line Feed).

Da mesma forma que com algumas das funes de tratamento de arquivos,
como a funo Erase que voc j viu,  preciso utilizar primeiro o
procedimento AssignFile  para poder associar um arquivo em disco com uma
varivel de arquivo. Dessa vez, porm, a declarao  assim:

        var
          IdentficadorArquivo: TextFile;
        begin
          AssignFile(IdentificadorArquivo, nomearquivo);

#ࡱ#################>###
#############################################u######






##S#u#m#m#a#r#y#I#n#f#o
#r#m#a#t#i#o#n###########################(##################
###################################

#################################################################
###################################################################
####################################

############################################################
#####################################################################
###########################

##############################################@####<ty#############
########################################################################
#############@####_###############

#####################Microsoft Word
6.0######################################################2##############
#####################################################



####n##

#######################################################################
########################################################################
####################################

########################################################################
########################################################################
####################################

########################################################################
####################################################################c
#######&###B###P###r#############X##

#Y#################O###P#################################G
##H ###### #######################A###U###z###############
#######l#######################################################
##############################################################
##############################

##############################################################
##############################################################
##############-l###m#############

#######/###0###############5###<#########O###\###~############
###/###C###Q###R###S###$###%###?###@###########################
####### ### ###
##############################################################
#############################################################
###############################

##############################################################
###############################################################
#####-# ## ## ##  ##
###!##9!##H!##!##!##!##!##>"##?"##############$##$##$##$##|%
##}%##~%##%##%##B'##I'##e'##m'##l(##m(##(##(##(##(##
)###)##d)##)##)##)##  *##
*###*#########################################################
##############################################################
###############################

##############################################################
##############################################################
##########-#*###*###*##*##*##*##'

+##G+##+##+##+###,###,##-##7/##0###2###2##P2##2##2###3###3##L3##m
3##n3##3##3###4###4##54##64##h4##s4##4##4##4##4##4##4###6##]7##
9##9##9###:####################

#############################################################
##############################################################
###############################

##############################################################
################################################-#:##8:##E:##Z:##f
:##:##:##:##:##:###;###;##
;###<###<##7<##8<##>##l@##m@##rA##sA###C###C###D###D###D###D##E##E##
F##F##H##H##H##H##H##H###I###I##iI##jI##I##I##I##I#########
###############################

##############################################################
##############################################################
##############################

##############################################################
############################-I##L##L##L##L##nN##oN##N##N##N##J
P##KP##LP##Q##Q##)S##*S##CS##DS##

T##T##T##T##2U##3U##LU##MU##V##V###W###W##8W##9W##gX##$Z##%Z##s[##t
[###\###\##\##]##_##.`##`###b#################################
###############################

##############################################################
##############################################################
##############################

################################################################
##-#b###c###d##d##we##f##g##h##i##Zj##+k##,k##|m##}m##~m##m##m##
m## o##>q##r##r##r##r##r

##ws##ot##pt##t##t##t##bu##cu##ou##u##u##u##u##u##u##
v##!v##v##v##v##v############################################
#############################################################
###############################

##############################################################
##############################################################
########################-v##
w##6w##Uw##jw##w##w##x##x##x##x##x##x##W|##X|##.##/##0##:##;
#######}#######Ǒ##ȑ##ݑ##ޑ##Д##R##S##T##\##]#####$##3
##4##)##*############

##############################################################
##############################################################
###############################

#############################################################
################################################################
##-####ʟ##D##@########

##?####}##8##9#####é##ǩ##################ج##*##׮##C
##D##`##a##X##################U##[##\######N##O
##m##########################

##############################################################
##############################################################
###############################

#############################################################
##########################################-m##n##·##÷##ָ##D##L
##M#############C##h##

##ݼ####
#####<##]######½##ڽ################x######
##############5##S##r################################
###############################

#############################################################
##############################################################
###############################

###############################################################
######-######################J##S##m##n##y####
###################!

##"##/##N##O########n##o###################
##########################################################
###############################

#############################################################
##############################################################
###############################

#############################################-##########
#####N##O##~##V##W##############\##q##x######
#####@##J##K##########

########!##K##y##X############################
##############################################################
###############################

#############################################################
##############################################################
###############################

#####################-#########'##Z##h##i##########
##a##j##o##########>#############B##Q######
####0##^#########!##>##P

##w##########@########################################
##############################################################
###############################

#############################################################
##############################################################
############################-@##I

##t#######################7##m########d##e
##################"##Q##]############%##&##
##########+##,######

##############################################################
##############################################################
###############################

#############################################################
################################################################
##-##################

########"##############!##"##########
##!############3###4###
#############################4###5###K###L######y
##############################################################
#########################################

#############################################################
##############################################################
###############################

###########################-y ## ## ##g ##h
########R###S#########5###6###y###z######`#########f###g###z###{#
##r###s###7###8###############;###<###U###V###############
#######-###.########## ###
##############################################################
#############################################################
######

##############################################################
##############################################################
###############################-#

 ## ## ## ##
###!##8!##d!##q!##r!##U"#####################$##A$##s$##$##$##$
##$###%##_%##t'##u'##((##)(##\*##Z+##c+##e+##m+##+##+###,###,##1,##2,
##Q.##R.##S.##.##

.#############################################################
#############################################################
###############################

##############################################################
###############################################################
######-.##/###1###1##31##41##s2##

3##3##3##3##"4###4##I4##J4##4##<5##=5##^5##_5##77##87##[7##\7##7##
7###8###8##,8##-8##(:##):##O:##P:##:##:##:##J;##K;##t;##u;##*<##+<##A
<##B<###=#######################

##############################################################
#############################################################
###############################

##############################################################
#############################################-#=###=##&=##'=##z?##{
?##?##?##?##q@##@##0A##A##%B##f

B##gB##B##B##C##C##C###D###D##LD##D##D##D##E##E##E##E##G##
H##H##H##H##H###I###I##AI##TI##I##I##I##I##I################
###############################

##############################################################
#############################################################
###############################

##############################################################
#####################-I##LJ##YJ##ZJ##SL##TL##L##L###M###M##|M##}M##1
N##2N##O##lP##mP##P##P##P##P###

Q###Q##*Q##XQ##Q##Q##Q##Q##3R##IR##SR##TR##tR##uR##(T##)T##VT##WT##4
U##5U##BU##iU##jU##V##W########################################
###############################

##############################################################
#############################################################
###############################

###########################################################-W##
W##W##W##W###X##AX##BX###Y###Y##Y##Y##Y##Y##[##[###\###\##u\##v
\##\##\##\##\##"_###_##`##sb##

c##c##c##c##4e##5e##e##e##'f##(f##_f##`f##f##f##dg##g###h##Qh##
##############################################################
###############################

##############################################################
#############################################################
###############################

###################################-Qh##h##h##/i##i###j###j##Lj##M
j###m##;p##q##q##Ir##Jr##r##r##s##s###t###t##u##w##
x##Ex##x##y##Nz##Oz##{##a~##b~##~##~##############A##B##4
####g##h#################################################
###############################

##############################################################
#############################################################
###############################

####################################################-####s###
#####~####7##8##C##D##################k##g##ڛ##
##########S##=##>####

##ͣ##Σ##ܣ##ݣ############P########L##M#########
##############################################################
###############################

##############################################################
#############################################################
###############################

############################-M##x##y##ª##ê##4##5##6##_##`##;
########(##)##I#######g####Ӹ##]####¹##ù##Ҽ##Ӽ######
########&##'###########

#########Q##R#######################################
##############################################################
###############################

##############################################################
#############################################################
#################################

##-####1##2##O##P#################,##9##:####
############R##r#######################
#####################

######{###################################################
##############################################################
###############################

##############################################################
#############################################################
#################-{##]##^##x##y

################)##*##########n##o##########
##o##p######3##4#######################$##%
########################

#############################################################
##############################################################
###############################

##############################################################
######################################################-####
############e##y######

####s##t##A##B##########;##c##d############
#####'##4##5########
##d##e##########?##@#################################
##############################################################
###############################

##############################################################
#############################################################
#################################

##-@###############################,##-##u####,
##-#############(##0##1##O##P##|##}##6##7##R##S##O
###############$##]##^##

###########################################################
##############################################################
###############################

##############################################################
##############################################################
##########-#########,##-##.

#################
############K###v###w###^###_##################&###4###m###n###
##############################################################
####

#############################################################
###############################################################
####################################

########################################################################
###############################################################K########
##@#####Normal#######a############

######### #A@# ##Fonte parg.
padro################n#######W##!###!###!###!###!###!
###!###!###! ##! ##!###!###!
##!###!###!###!###!###!###!###!###!###!###!###!#
##!###!###!###!###!###!###!
##!!##!"##!###!$##!%##!&##!'##!(##!)##!*##!+

##!,##!-##!.##!/##!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#####!############$######!##
'##:-##1###8##s>##D##I##)P###U##[##c##j##)q##~u##

@|####׋##R##t#####@##X##x##################z####
############L
##g###V######!##e(##3.##3##*9##>##fD##TI##N##'T##vY##e`##e##l##s
##z##B

#############`##װ########O####^########
##$####O##-#####n#######################d###########1############
######## #'### ###############
############J##########e###########F#####L##########L###############
################C#####^###########"###
####!#M###"#m#########$####%#p###&#####'#5###(#  ###)#3###
*#W###+#####,#T###-#####.####/#L###0#]###1#####2#####3#a###4#####5#F###
6#b###7####8#####9####:#####;#^###<#9###=#|###>#(###?#x###@####A#J###
B####C#>###D#d###E#
###F####G#r###H####I####J#####K#+###L#####M#=###N####O#####P####Q#Q
###R#Z###S#~###T#####U#m###V#########n#########l####
###*###:##I###b##v####m########@####y  ###
##.###=##I##W##Qh####M####{####@####n########### # #####
#####################################
#!###dahmmse;0x#-+'`.,,LC##AUTOR#COMENTRIOS#DATACRIAO
EDITARHORA#NOMEARQUIVO#TAMANHOARQUIVO PALAVRASCHAVE
GRAVADOPOR#NUMCARAC#NUMPG#NUMPALAVRAS DATAIMPRESSO#PRIVADO#DR
NUMREVISO#DATAGRAVAO#ASSUNTO#VARINDAN#MODELO#TTULO VARINDREM
ALFABTICO#ARBICO#MAISCMINSC#EXTENSO#FORMATOCARAC#TEXTOVAR
INICIALMAISC#HEX MINSCULAS#FORMATOMESCLAR#ORDINAL#TEXTORDINAL#ROMANO
MAISCULAS#ABS#ARRED#DEF#INT#E#FALSO#MX#MN#MOD#MDIA#CONT#NO#OU#PRODU
TO#SE#SINAL#SOMA VERDADEIRO ##Ronald Peixoto#A:\DELPHI3.DOC@Epson
FX-1050#LPT1:#EPSON9#Epson
FX-1050########################@##f##############x##################
###############################

#########################################@#MSUD##Epson
FX-1050##################################d#####Epson
FX-1050########################@##f##############x#################

########################################################################
#@#MSUD##Epson
FX-1050##################################d##############
##############1######

Times New
Roman######Symbol##&###Arial#"###################|##############
########################################$#0########Ronald
Peixoto#Ronald Peixoto###########ࡱ#

################>###
#############################################u######



R#o#o#t#
#E#n#t#r#y######################################################
############F#####z8##ٸ##66###@#########C#o#m#p#O#b#j###########
###

############################################################
###################q#######W#o#r#d#D#o#c#u#m#e#n#t######################
############################

###################################>###I]######O#b#j#e#c#t#P#o#o#l######
####################################################################
####O9###O9###################

###############F################
###############################################
###!###"#######$###%###&###'###N###

3###5###8###9###:###;###<###=###?###@###A
###B###C###D###E#######G###H###I###J###K###L###M#######O###P###Q###R###S
###T###U###7###






########################################################################
###
###!###"#######$###%###&###'###(###)###*###+###,###-###.###/###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###v###w###x###y
###z###{###|###}###~###########S#u#m#m#a#r#y#I#n#f#o#r#m#a#t#i#o#n####
#######################(###

####################################################################
############################################################
####################################

###################################################################
#################################################################
####################################

############################################################
############################### ###
###########








#########################@
####<ty###########################

#######################################################################@
####_####################################Microsoft Word
6.0###############################################

#######3###############################################################
#



### ### ############F####Microsoft Word 6.0
(Documento)#
###MSWordDoc#####Word.Document.6#9q#############ࡱ###########_##
####################Oh###+'0######
#############################$#######H### ###l#################
################# ### ###D#######h###formamos em um parmetro var,
mas, uma
v########C:\WINWORD\MODELOS\NORMAL.DOT##################################
#####Ronald  Peixoto######################Ronald
Peixoto##############@#####y##########################@####Y##!'#
#!(##!)##!*##!+##!,##!-##!.##!/##!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#####!############$######!##
'##:-##1###8##s>##D##I##)P###U##[##c##j##)q##~u##@|####׋##R##t
#####@##X##x#########

#########z################L
##g###V######!##e(##3.##3##*9##>##fD##TI##N##'T##vY##e`##e##l##s
##z##B#############`##װ########O####^

########
##$####O##-#####n#######################d###########1############
######## #'### ###############
############J##########e###########F#####L##########L###############
################C#####^###########"###
####!#M###"#m#########$####%#p###&#####'#5###(#  ###)#3###
*#W###+#####,#T###-#####.####/#L###0#]###1#####2#####3#a###4#####5#F###
6#b###7####8#####9####:#####;#^###<#9###=#|###>#(###?#x###@####A#J###
B####C#>###D#d###E#
###F####G#r###H####I####J#####K#+###L#####M#=###N####O#####P####Q#Q
###R#Z###S#~###T#####U#m###V##########O########l####
###*###:##I###b##v####m########@####y  ###
##.###=##I##W##Qh####M####{####@####n########### # #####
#####################################
#!###dahmmse;0x#-+'`.,,LC##AUTOR#COMENTRIOS#DATACRIAO
EDITARHORA#NOMEARQUIVO#TAMANHOARQUIVO PALAVRASCHAVE
GRAVADOPOR#NUMCARAC#NUMPG#NUMPALAVRAS DATAIMPRESSO#PRIVADO#DR
NUMREVISO#DATAGRAVAO#ASSUNTO#VARINDAN#MODELO#TTULO VARINDREM
ALFABTICO#ARBICO#MAISCMINSC#EXTENSO#FORMATOCARAC#TEXTOVAR
INICIALMAISC#HEX MINSCULAS#FORMATOMESCLAR#ORDINAL#TEXTORDINAL#ROMANO
MAISCULAS#ABS#ARRED#DEF#INT#E#FALSO#MX#MN#MOD#MDIA#CONT#NO#OU#PRODU
TO#SE#SINAL#SOMA VERDADEIRO ##Ronald
Peixoto#A:\DELPHI3.DOC@################################################
########################################################################
################

########################################################################
########################################################################
####################################

########################################################################
########################################################################
####################################

########################################################################
########################################################################
####################################

########################################################################
########################################################################
#########################Epson  FX-1050#LPT1:#EPSON9#Epson
FX-1050########################@##f##############x##################
########################################################################
@#MSUD##E

pson FX-1050##################################d#####Epson
FX-1050########################@##f##############x##################
#################################################

#######################@#MSUD##Epson
FX-1050##################################d##############
#######################m###n#############m#####1######Times  New
Roman######Symbol##&###Arial#"###################|##############
########################################$#0########Ronald
Peixoto#Ronald Peixoto###########ࡱ######

###########>###
#################0###########4###########2###u###1###

ܥe

#5######e###############n###I]##################n######################
##############D##h####D##h####O#######O#######O#######O#######O######T#
#####T######T######T######T#####

#T##
###T#####T######\##1###MU######MU######MU######MU######MU######MU###
###MU######MU######CW######Z######Z######Z######Z#####[#####U\###
###\##T####]##0###s\##!############

########O#######W################MU######MU#######################W#####
##W######s\#######W#######O#######O######MU######################MU#####
##W#######W#######W#######W#######O#

#####MU#######O######MU######CW#######################O######'Q##j####O#
######O#######O#######O######MU#####CW#######W##
####W#####################################################

########################################I######################(####
var
          Analise: Longint;
        begin
          Analise := GetWinFlags;
          if (Analise and WF 50x87) = WF 80x87 then
             ShowMessage/'Voc tem um co-processador matemtico');
          if (Analise and WF CPU2B6) = WF CPU286 then
             ShowMessage('Voc ainda tem um chip 286?');

        Como outro exemplo da utilizao da funo Windows API,
considere a funo GetSystemMetrics. A sintaxe dessa funo  assim:
       
        function GetSystemMetrics(Index: Integer): Integer;
      
        Nesse caso, voc envia para essa funo um valor inteiro que diz
a ela qual a informao que voc quer que seja relatada. (A maioria das
constantes que voc  precisa esto disponveis como constantes internas
no Delphi - verifique a existncia del muito detalhadas a respeito do
sistema utilizado pelo seu aplicativo. Por exemplo, voc pode utilizar
essa funo API para descobrir se o Windows est informando  que um
mouse est sendo utilizado. Aqui est um fragmento que faz isso:

        if GetSystemMetrics(SM MOUSEPRESENT)<> 0 then
          ShowMessage('Voc tem um mouse.');

NOTA: As chamadas Windows API com freqncia requerem que voc envie
para elas as alas do objeto. No Delphi esse  o valor da propriedade
(de processamento), chamada,  naturalmente, de Handle. A propriedade
Handle est disponvel para todos os componentes colocados em janelas.




Funes e Procedimentos Definidos pelo Usurio

Como com qualquer linguagem de programao sofisticada, o Delphi
permite-lhe desdobrar o cdigo de seu programa em pedaos
administrveis. Da mesmaforma que o Visual Basic (mas ao contrrio de
C), o Delphi distingue entre as funes, que devolvem valores, e
procedimentos, que no devolvem. No Delphi, as pessoas se referem aos
subprogramas quando querem falar a respeito de funes e de
procedimentos ao mesmo tempo. A terminologia  til se nos ajuda a
lembrar que, para todos os propsitos particulares, as funes e os
procedimentos se comportam como miniprogramas. Em particular, eles podem
ter seu tipo prprio, constante, constantes tipificadas e declaraes de
variveis definidas em seu interior. Eles podem at ter subprogramas
prprios aninhados dentro deles. (O motivo de se aninhar' um subprograma
dentro de outro se deve s regras de escopo para os subprogramas. Um
subprograma aninhado  considerado local ao subprograma container e no
pode ser utilizado por outras partes do programa. Igualmente, as
variveis declaradas em um subprograma aninhado so locais quele
subprograma.)

NOTA: Quanto um programa deve ser modulado , evidentemente, uma questo
de gosto. Ns gostamos de manter os procedimentos de eventos e
subprogramas com o tamanho de uma tela aproximadamente.

        Por exemplo, aqui est uma funo que conta o nmero de vezes
que um caractere aparece em uma string e devolve este valor (inteiro):

        function ContaOcorrencias(const Foo: string; const QualCaract:
Char): Integer;
       var
         i, Cont, TamString: Integer;
       begin
         TamString := Length/Foo);
         Cont := 0;
         for i := 1 to TamStrinng do
             begin
              if foo[i] = QuaICaract then Cont := Cont + 1;
             end;
         ContaOcorrencias := Cont;
  egveis e so exatamente aqueles em que voc pode utilizar o comando
TYI'E do DOS para ler - sem que um monte de lixo venha encher a sua
tela. Pense no trabalho com um arquivo de texto no Delphi como anlogo 
gravao de informao em uma fita cassete. com um gravador cassete,
como gravar uma msica em uma fita em branco, sero fceis de realizar.
Aquelas anlogas s tarefas mais difceis, como emendar fitas ou fazer
uma alterao em uma fita, sero mais difceis.
        Para evitar trabalhos desnecessrios, utilize um arquivo de
texto apenas quando souber que est trabalhando com texto normal e

        *Raramente far mudanas dentro do arquivo.
        *Vai tratar (processar) a informao contida no arquivo do
comeo ao fim, sem precisar ficar pulando de um lado para outro.
        *Far acrscimos ao arquivo no seu final.

         possvel fazer mudanas dentro do arquivo, tanto pulando de um
lado para outro ao processar informao, quanto fazendo adies ao
arquivo em lugares alm do seu final; contudo esses procedimentos so
mais dolorosos para 9 bits.

NOTA: Todas as linhas em um arquivo de texto terminam com uma combinao
retorno de carro/nova linha (Carriage Return/Line Feed).

Da mesma forma que com algumas das funes de tratamento de arquivos,
como a funo Erase que voc j viu,  preciso utilizar primeiro o
procedimento AssignFile  para poder associar um arquivo em disco com uma
varivel de arquivo. Dessa vez, porm, a declarao  assim:

        var
          IdentficadorArquivo: TextFile;
        begin
          AssignFile(IdentificadorArquivo, nomearquivo);
onde TextFile informa ao Delphi que voc ir trabalhar com um arquivo de
texto. A no ser que o nome de arquivo esteja no diretrio atual, voc
tem de fornecer informao suficiente para identificar seu caminho.
Tambm, o valor de uma varivel de texto tem de ser um nome de arquivo
legal.
        Eis uma tabela com algumas operaes comuns em uma fita cassete
e as operaes anlogas em um arquivo de texto seqencial que foi
atribudo a uma varivel de texto denominada ArqTxt:

        Operao - Equivalente Delphi

        Coloca a mquina no modo de reproduo e pressiona pause -
Reset(ArqTxt);
        Coloca a mquina no modo de gravao e pressiona pause -
Rewrite(ArqTxt); Pressiona stop - CloseFile(ArqTxt);
        Inicia gravao no final da fita - Append(ArqTxt);

        Todas as vezes que o Delphi processa um comando Reset, Rewrite
ou Append, ele est pronto para enviar ou retirar informaes do
arquivo. (O jargo  que  ele "estabelece um canal" para se comunicar
com o arquivo.) O que segue o comando Reset, Rewr Rewrite realmente
apaga qualquer arquivo com o mesmo nome que existia antes.
        Normalmente, o comando CloseFile esvazia o buffer e informa ao
DOS para atualizar a tabela de alocao de arquivo (FAT). Mas, por causa
das tcnicas de buffer  do prprio Windows, isso poder no acontecer
exatamente quando o Delphi processa o com est com um arquivo aberto
quase sempre leva  perda de informao e ocasionalmente at a um disco
corrompido. (O comando CHICDSIC/f, ou a utilizao de SCANDISIC,  
freqentemente necessrio quando isso acontece.)

NOTA: O procedimento Flush permite-lhe obrigar o Delphi a salvar o
buffer de sada no disco antes que seja preenchido.

Ao processar arquivos grandes, o buffer padro tem apenas 128 bytes.
Isso, com freqncia, faz com que seu aplicativo fique visivelmente mais
lento. O Delphi fornece  o procedimento SetTextBuf para mudar o tamanho
do buffer de um arquivo de texto. (Um tamanho grande provavelmente
acelerar bastante os programas que se utilizam  muito do disco.)

Enviando Informao a um Arquivo

O comando Writeln  provavelmente a maneira mais comum de enviar
elementos de informao individuais a um arquivo. Eis o exemplo de um
fragmento que envia um elemento  de informao a um arquivo denominado
TEST.DAT:

        {Escrevendo em um arquivo}
        var:
          ArqTxt: TextFile;
        begin
          AssignFile(ArqTxt, 'TEST.DAT');
          Rewrite(ArqTxt);
          Writeln(ArqTxt, 'TESTING,12 3'); CloseFile(ArqTxt);
        end;

        Depois da declarao de comentrio usual, a declarao da
varivel informa ao Delphi que voc est preparando uma varivel de
arquivo de texto denominada  ArqTxt. A declarao AssignFile associa
essa varivel de arquivo, ArqTxt, ao arquivo denomin o ponteiro de
arquivo no comeo deste. A declarao Writeln realmente envia a
informao ao arquivo. O que aparece no arquivo so os caracteres entre
apstrofes  - o arquivo no contm aspas. O comando Writeln tambm envia
uma combinao retorno de carro/nova linha - um CR (retorno de carro),
ASCII 13, e um LF (nova linha),  ASCII 10, ao arquivo. Isso significa
que o arquivo conter a palavra "TESTING", seguido de uma vrgula,
seguido por um espao, seguido pelo nmero 1, seguido por  mais um
espao, seguido pelo nmero 2, seguido por um espao, seguido pelo
nmero 3, e depois um ASCII 13 seguido de um ASCII 10.

NOTA: Em raras ocasies, voc vai querer enviar dados a um arquivo de
texto sem acrescentar a combinao CR/LF. Para isso, utilize a funo
Write em lugar de Writeln. # Por outro lado, se voc precisa enviar o
contedo de qualquer lista de string (como a propriedade Lines de uma
caixa memo) diretamente a um arquivo, o Delphi  permite-lhe fazer isso
com uma nica linha de cdigo. O que voc faz  utilizar o mtodo
SaveToFile do objeto String como a seguir:
 
       String ListName.SaveTo File(NomeArquivo);

Lendo Informaes de um Arquivo de Texto

Se voc quiser ler o contedo de um arquivo em uma lista de string,
ento a sua tarefa ser fcil - novamente uma linha de cdigo ser
suficiente.

StringListName.LoadFromFile(NomeArquivo);

        Por outro lado, para ler a informao de um arquivo item a item,
voc ter de abrir o arquivo para dar entrada utilizando o procedimento
Reset. A sintaxe  

        Reset(varivel arquivo);

        Assim que um arquivo estiver restaurado, voc poder ler a
informao deste com os procedimentos Readln ou Read. Eis um exemplo
utilizando Readln:

        {Lendo de um arquivo)
        var:
          ArqTxt: TextFile;
          S: string[80];
        begin
          Assignfile(ArqTxt, 'TEST.DAT');
          Reset(ArqTxt);
          Readln(ArqTxt, S); CloseFile(ArqTxt);
        end;

        Readln ler os nmeros de caracteres especificados (baseado no
tamanho da varivel string) ou at uma combinao CR/LF - aquele que
vier primeiro. Tambm  move o ponteiro de arquivo ao comeo da prxima
linha quando terminar. Se a linha que o Delp (80 em nosso exemplo),
ento os caracteres restantes sero ignorados e o ponteiro de arquivo
ser posicionado de qualquer forma no comeo da prxima linha.
        Read, por outro lado, funciona da mesma forma que Readln, exceto
por ele no mover o ponteiro para a prxima linha - deixa o ponteiro
onde est. Isto significa  que, como alternativa para nosso exemplo,
voc poderia ter utilizado o seguinte:

        {Lendo de um arquivo)
        var
          ArqTxt: TextFile;
          S1, S2, S3: string[51;
        begin
           AssignFile(ArqTxt, 'TEST.DAT');
           Reset(ArqTxt);
           Readln(ArqTxt, S1, S2, S3); CloseFile(ArqTxt);
        end;

NOTA: Conforme mostrado pelo exemplo anterior, voc pode utilizar
diversas variveis em cada declarao Read (ou Readln).

Lendo Nmeros de Arquivos de Texto

Alm de armazenar strings, os arquivos de texto tambm podem armazenar
nmeros. O que acontece  que, quando voc utiliza variveis numricas
na declarao Read  ou Readln, o Delphi converte automaticamente uma
string de nmeros no nmero apropriado. Mais precisamente, o Delphi

        *Pula espaos vazios.
        *L todos os numerais at chegar a um espao vazio, um caractere
que no  dgito, ou um segundo ponto.
        *Converte a string de dgitos resultante no tipo numrico
apropriado e o atribui  varivel numrica.

NOTA: Se a converso no tem sucesso, o Delphi gera um erro de E/S.

A funo Eof

Se voc souber exatamente a quantidade de informao que est contida em
um arquivo, poder utilizar um lao For para reler a informao. Na
maioria das vezes, porm,  isso no  prtico: voc simplesmente no
sabe quais limites utilizar para o lao. O que voc realmente precisa 
de uma maneira para implementar o seguinte esboo:

       Enquanto h informao deixada no arquivo
          Pegue o prximo elemento de informao
       Lao

        Para fazer isso, voc precisa de uma maneira para determinar
quando voc estar no final de um arquivo. A funo no Delphi que lhe
permite fazer isso  chamada  de funo Eof (Fim de Arquivo). A sintaxe
 assim:

        function Eof (var IDArquivoTexto: TextFile):Boolean;

        Essa funo devolve True quando voc leu alm do ltimo
caractere no arquivo e devolve False em caso contrrio. Isso significa
que voc pode escrever um  lao While que  assim:

        var
          VariavelString: String;
          IDArquivoTexto: TextFile;
        begin
         AssignFile(IDArquivoTexto, 'TEST.DAT');
         Reset(IDArquivoTexto);
         while not Eof(IDArquivoTexto) do
            begin
              Readln(IDArquivoTexto, VariavelString);
              ShowMessage(VariavelString);
            end;
        end;

        Isto exibir o contedo do arquivo nas caixas de mensagem - uma
linha por vez.
        Observe que voc utiliza um lao While em lugar de um lao Until
para levar em conta a possibilidade improvvel de que o arquivo existe,
mas no contm nenhuma  informao - isto , ele foi aberto para dar
sada mas nada foi realmente enviado ao a pega uma linha de dados (isto
, at 255 caracteres ou at o prximo par retorno de carro/alimentao
de linha), e continua fazendo isso at chegar ao final do arquivo.

Arquivos Tipificados

Arquivos tip ficados so aqueles que contm dados de apenas um
determinado tipo, como Integer, Real, ou um tipo Record anteriormente
definido. Uma vez que os arquivos  tipificados tm uma estrutura
definida pelo tipo de dados que contm, voc pode ler e escrever
informao para frente e para trs com bastante eficincia. Por exemplo,
ler nmeros de um arquivo tipificado  muito mais rpido do que de um
arquivo de texto porque no  necessria nenhuma converso - os arquivos
digitados armazenam  nmeros e strings no mesmo formato em que so
armazenados pelo programa. As strings em um arquivo tipificado so
armazenadas com o primeiro byte contendo o tamanho  do string, os bytes
seguintes armazenam os caracteres em si. (Tambm pode haver alguns
caracteres de refugo utilizados como recheio se a varivel string no
foi  preenchida ao seu tamanho declarado. )
        Evidentemente que a velocidade adicional requer alguma
programao adicional. Eis um exemplo do que voc precisa para trabalhar
com um arquivo tipificado:

        var RealFile: File of Real; RealNumber: Real;
        begin AssignFile(RealFile, 'NUMBER.DAT'); Rewrite(RealFile);
RealNumber := Pi; Write(RealFile, RealNumber); RealNumber := exp(1);
Write(RealFile, RealNumber); Reset(RealFile); Read(RealFile,
RealNumber); ShowMessage('O valor de pi '+ FloatToStr(RealNumber));
Close(RealFile);
         end;

        Em geral, voc utiliza o comando Write para escrever informaes
em um arquivo tipificado e o comando Read para obt-lo de volta (mais
comumente com um lao  Eof, como viu antes).

Registros em Arquivos Tipificados

Os arquivos tipificados tambm podem conter tipos de dados definidos
pelo usurio. Por exemplo, vamos supor que voc tenha um registro do
tipo BookInfo:

        type
          BookInfo = record
             Author: string[20]; Title: string[30]; Subject: string[15];
             Publisher: string[20];
             Miscellaneous: string[13);
          end;
        var BookData: BookInfo; BookFile: file of BookInfo;

Agora voc pode utilizar os comandos Read e Write para escrever ou ler
um arquivo inteiro por vez.

Arquivos No-Tipificados

Arquivos no-tipificados so utilizados quando voc tem de (ou quer)
impor a estrutura mnima a um arquivo. Enquanto os arquivos de texto
consistem de linhas terminadas  com uma combinao CR/LF, e os
tipificados digitados consistem de dados tomados de um determinado tipo
de estrutura de dados, os arquivos no-tipificados no tm  nenhuma
estrutura.
        Voc pode ler a informao de um arquivo no-tipificado em
qualquer tipo de dado. Evidentemente que, isto poder levar a certos
comportamentos bem estranhos  por parte de seu programa se tentar ler
dados incompatveis em suas variveis. Por outro  transferir dados de um
disco ao seu programa.
        O fragmento de cdigo que segue l um arquivo e o escreve em um
segundo arquivo. Esse exemplo ilustra a utilizao da palavra-chave file
para arquivos no-tipificados  e dois procedimentos novos, BlockRead e
BlockWrite:

        var
          SrcFile: file;
          DestFile: file;
          RecsRead: Integer;
          Buffer: array (1..2048] of Byte;

        begin
          AssignFile(ScrFile, 'file.in');
          Reset(ScrFile,1); {NOTA: o segundo argumento indica o tamanho
do registro}
          {NOTA: Este  um local apropriado para manuseio de erros de
E/S}

          AssignFile(DestFile, 'file.out'); Rewrite(DestFile,1); {NOTA:
o segundo argumento indica o tamanho do registro} BlockRead(SrcFile,
Buffer, SizeOf(Buffer), RecsRead);
          while RecsRead > 0 do BlockWrite(DestFille, Buffer,
SizeOf(Buffer)); BlockRead(ScrFile, Buffer, SizeOf(Buffer), RecsREad);
          end;
          Close(SrcFile);
          Close(DestFile);
        end;

        O exemplo de cdigo anterior utiliza diversos recursos novos que
vale a pena repassar. Quando utilizados com arquivos no-tipificados,
Reset e Rewrite tm  um segundo argumento que define o tamanho do
registro. Em nosso exemplo, escolhemos um tama sendo uma matriz de bytes
- a estrutura de dados  a mais primitiva possvel.
        Ao utilizar arquivos no-tipificados, voc utilizar sempre os
procedimentos BlockRead e BlockWrite. Os parmetros desses dois
procedimentos so semelhantes.  O primeiro parmetro  o nome de
arquivo, o segundo  o nome da estrutura de dados, o te nmero real de
registros que deve ser lido ou escrito.
        Algumas vezes, voc vai querer posicionar o ponteiro de arquivo
em um determinado registro em um arquivo. O procedimento Seek pega a
varivel de arquivo  como primeiro argumento e utiliza o segundo
argumento para a posio de arquivo para a qual v

       Seek(SrcFile, 0);

DICA: Mais duas funes de E/S de arquivo que voc pode precisar para
trabalhar com arquivos no-tipificados so FileSize e FilePos. FileSize
devolve o tamanho do  arquivo em bytes. FilePos devolve a posio atual
do ponteiro de arquivo.

Informao da Linha de Comando

A maioria dos programas profissionais permite (ou exige) que o usurio
digite informaes adicionais ao invocar o programa. Normalmente essa
informao extra  chamada  de informao da linha de comando. Por
exemplo, quando voc escreve

        COPY A:*.* B:

a informao da linha de comando  a string "A:*.*B:". O programa
utilitrio COPY utiliza essa informao para saber o que fazer. O Delphi
facilita a leitura dessa  informao. Quando voc processa qualquer
programa do Gerenciador de Arquivo e utiliza o modelo

        FileExeName info1 info2 info3...

ento o valor da funo ParamCount  o nmero de parmetros que h na
linha de comando, enquanto que a lista ParamStr() fornece os parmetros
propriamente ditos  da linha de comando. ParamStr(0)  o caminho e o
nome de arquivo do executvel. ParamStr( 1 )  a primeira string e assim
por diante.

NOTA: Evidentemente que voc precisa de uma maneira para criar exemplos
de informao da linha de comando enquanto desenvolve o programa; caso
contrrio, voc no  teria nenhum dado de teste com que depurar o
programa. Voc faz isso com a opo Parameters no menu Run.
