Belo Horizonte

Setembro/1999

Em FORTRAN existem basicamente duas formas de se escrever um programa: com formulário fixo ("fixed form") ou com formulário livre ("free form"). Sendo este segundo disponível apenas para compiladores baseados em WINDOWS. Outro ponto importante são os comandos validos somente nos novos compiladores ( por exemplo Microsoft Developer Studio) que aceitam programas em FORTRAN 90. Por isso será adotado o seguinte critério para as explicações :

• tópicos precedidos do identificação WIN só são validos para WINDOWS;
• tópicos precedidos de F90 são válidos apenas para os compiladores que aceitam comandos FORTRAN 90.

Deve ficar claro que compiladores para FORTRAN 90 aceitam também os outros dois tipos, e os baseados em WINDOWNS aceitam todos os comandos dos compiladores mais antigos (FORTRAN 77), e que a reciproca não é verdadeira.

Os programas podem ser escritos em qualquer editor de texto, desde que sejam salvos com as extensões .for ou .f90. Esta segunda forma somente para FORTRAN 90. Os compiladores em WINDOWNS possuem um editor próprio, que deve ser usado pois possui muitos recursos adicionais, como por exemplo o destaque das palavras chaves.

Os seguintes critérios devem ser seguidos para se escrever um programa em FORTRAN no modo de formulário fixo:

• colunas 1 a 5: são usadas escrever os rótulos "label" ou números de comando. Estes números dever ser inteiros e estar totalmente contido nestas colunas. Não podem se repetir e não precisão estar em ordem crescente. Serão usados para que outros comandos possam identificar aquela linha;
• coluna 6: qualquer caractere diferente de 0 "zero" nesta coluna indica que o que vem a seguir é continuação da linha anterior ou da ultima linha que não seja um comentário (próximo item), podem existir até 19 linhas de continuação;
• colunas 7 a 72: comandos ou comentários;
• colunas 73 a 80: campos de identificação, são usados pelo computador, portanto não se deve escrever nestas colunas.

F90 – O programa pode ser escrito em qualquer posição, desde que o modo "free form" esteja ativado. Alguns pontos devem ser observados para este formato:

• as linhas de continuação são indicadas pelo símbolo ‘&’ no fim da sentença, e o que estiver na linha abaixo será tomado como continuação. É permitido a inserção de comentários após o ‘&’;
• os rótulos dever ser os primeiros caracteres da linha, e podem estar em qualquer coluna.

WIN – o ponto de exclamação ‘!’ indica que o que vem após ele é comentário, ele pode vir em qualquer posição, inclusive após comandos.

3. Variáveis e Nomes de Blocos: devem ter no máximo seis letras, não é permitido o uso de caracteres espaciais e não podem começar com um número.

WIN – podem ter 31 caracteres, inclusive o caracter upercase ‘_’

4. Constantes:

• Numéricas: podem conter qualquer valor real, inteiro ou complexo. A parte decimal é separado da inteira por um ponto’.’. Os zeros antes e depois do ponto decimal podem ser omitidos, se não forem significantes. O expoente decimal é indicado pela letra ‘e’ ou ‘E’, deve vir entre o número seu expoente sem o uso de espaços entre eles. Números negativos assim como a parte exponencial quando for negativa deve vir precedida do sinal menos ‘-‘. O sinal ‘+’ é opcional em ambas as partes. Os números imaginários devem vir entre parênteses e aparte real deve ser separada por uma virgula da parte imaginária.
• Alfanuméricas: (são as ‘strings’, seqüências de letras e/ou números) podem conter qualquer seqüência de caracteres. Deve vir entre aspas " " ou apóstrofos ‘ ‘. As aspas tem preferencia sobre os apóstrofos, portanto um valor literal pode conter apóstrofos, desde que seu valor venha entre aspas. Não é permitido o uso de caracteres especiais e letras acentuadas. Uma outra forma de se declarar valores alfanuméricos é o uso de wHvalorliteral, onde w é o número de caracteres do valor alfanumérico.

3. Maiúsculas e Minúsculas: o FORTRAN não faz qualquer distinção entre letras maiúsculas e minúsculas. É permitido inclusive o uso do nome da variável escrita de formas diferentes no mesmo programa. EX.: VAR = var = Var.
4. Os programas podem conter no início o seu nome (program nome_do _programa), e devem terminar com a palavra ‘end’.
5. Outra forma de parar o programa, e esta pode ser usada em qualquer parte dele, é usando a palavra ‘stop’. O programa terminará independentemente de haver mais comandos na seqüência.

As variáveis podem ser inteiras, reais ou literais. A declaração de uma variável deve vir antes que ela seja usada, se isto não ocorrer o compilador assumirá as variáveis que começam com as letras I até N como inteiras (INTEGER*4) e todas as outras como reais (REAL*4).

Esta forma de declaração implícita pode ser modificada usando o comando ‘implicit tipo (a1-a2,b1-b2,...)’ antes do tipo de variável. Sendo a1, a2, b1, b2 quaisquer letras da alfabeto. Quando não se deseja que nenhuma variável seja declarada implicitamente usa-se o comando ‘implicit none’.

Para se declarar variáveis que sejam matrizes e vetores deve-se indicar suas dimensões logo após o nome da variável; entre parênteses, e separadas umas das outras por vírgula. Ex.: a(4,3) indica uma matriz de 4 linhas por 3 colunas. As variáveis podem receber valores iniciais usando ‘/valor/’, logo após sua declaração.

Podem assumir os seguintes valores:

INTEGER*1 –128 a 127

INTEGER*2 –32,768 a 32,767

INTEGER*4 –2,147,483,648 a 2,147,483,647

INTEGER*4 pode ser representado somente por: INTEGER

Precisão simples até 6 casas decimais:

Precisão dupla até 15 casas decimais:

A parte exponencial deve ser separada por um ‘d’ ou ’D’ no lugar do ‘e’ ou ‘E’.

WIN – pode ser usado o ‘e’ ou ‘E’ para separar a parte exponencial. Não só isso mas também todas as outras funções (item 6 primeira parte) podem ser iguais a de um real comum para compiladores baseados em WINDOWS.

Precisão simples até 6 casas decimais:

COMPLEX*8 ou COMPLEX

Precisão dupla até 15 casas decimais:

COMPLEX*16

Os valores que um complexo pode assumir são os mesmos que os reais.

CHARACTER NOME*w

Onde w representa o número máximo de caracteres que a variável pode conter dentro do programa.

Ou CHARACTER *wvar1,var2

(var1 e var2 possuem o mesmo tamanho w)

Ou CHARACTER (LEN = w) var1, (LEN=w2) var2

(var1 tem tamanho w e var2 tamanho w2)

LOGICAL NOME

Podem assumir os valores .TRUE. (VERDADEIRO) ou .FALSE. (FALSO)

Ou somente T e F

O sinal ‘=’ atribui a variável o valor que vem á sua direita (item 5).

F90 – estas declarações poderiam estar na mesma linha desde que fossem separadas por ponto e vírgula ‘;’.

Quando uma variável inteira recebe o resultado de uma divisão com resto, este resto é desprezado ou seja o valor é truncado.

O uso de parênteses pode ser feito para trocar a ordem de prioridade.

Existem várias funções predefinidas em FORTRAN, que podem ser usadas em qualquer parte do programa.

Outras funções trigonométricas podem ser encontradas no Apêndice A.

Outras funções intrínsecas podem ser encontradas no Apêndice A.

Funções e subrotinas podem ser usadas para economizar espaço e tempo de programação já que podem ser usadas várias vezes num mesmo programa. Outro ponto importante é que elas podem dar ao programa maior clareza, pois várias seqüências de cálculos ou execuções podem vir separadas do restante dos comandos.

O que dá grande versatilidade as funções e subrotinas, são os argumentos passados a elas, que quando variam produzem resultados diferentes. As funções e subrotinas podem vir em qualquer parte do programa, mas o mais comum é que apareçam no fim (após o ‘end’ de termino do programa), por motivo de clareza. As variáveis usadas em funções e subrotinas são locais e por isso devem ser declaradas novamente, podendo ser usado os mesmos nomes de variáveis de outras funções e subrotinas ou mesmo do programa principal. Os parâmetros necessários devem ser passados junto com a chamada da função ou subrotina, devem vir entre parênteses e separados por virgula. Os nomes das variáveis não precisão ser os mesmos na chamada e definição de uma função ou subrotina, devendo apenas estar na mesma ordem.

Retornam sempre um valor, e a ela podem ser passados qualquer número de parâmetros. As funções funcionam de forma semelhante as funções intrínsecas, com a diferença de que agora é o programador que define o que a função de gerar como resultado. O tipo da função deve ser declarado no programa principal, como se fosse uma variável comum. Uma função pode utilizar outras funções.

Chamada:

Definição:

A função retornará o valor do ultimo comando do tipo:

Exemplo:

Chamada:

Definição:

A palavra chave ‘return’ é opcional.

Na maior parte dos programas é preciso haver uma interação entre o programa e o usuário, essa interação pode ser feita em FORTRAN pelos comandos de leitura e escrita de dados. Esses comandos na sua forma mais simplificada possuem a seguinte estrutura:

leitura :

impressão:

Onde lista_de_parâmetros representa os dados que serão impressos, e devem vir separados por vírgula. Podendo conter variáveis ou expressões alfanuméricas, esta ultimas devem vir entre apóstrofos ‘ ‘. Unidade representa a unidade onde os dados serão impressos ou de onde serão lidos. Formato pode conter uma lista de formatos de impressão (mostrado a seguir), um rótulo que indique um comando ‘format’, que contenha alista de formatos ou o símbolo ‘*’ que indica impressão ou leitura de forma livre.

As unidades ‘6’ e ‘*’ se não forem definidas dentro do programa, serão consideradas como a tela do computador (‘write’ ou ‘print’). Da mesma forma as unidades ‘5’ ou ‘*’ são definidas como o teclado (‘read’). O comando ‘print’ imprime sempre os resultados na unidade definida por ‘*’ ou na tela caso não haja nenhuma definição para de uma unidade usando especificada pelo ‘*’.

Na leitura os dados devem vir separados por espaços ou vir na linha seguinte. Caso se tenha mais dados em uma linha do que os que serão lidos por um comando ‘read’ eles serão desprezados, inclusive pelo próximo comando ‘read’. Na escrita os dados virão um após o outro separados por espaços (no casa de ‘strings’ verão sem espaço entre elas), ou na linha seguinte quando não houver mais espaço. O próximo comando ‘write’ ou ‘print’ começará a escrever na linha seguinte.

F90 – para que se leia ou escreva dados na mesma linha mesmo após mudar o comando pode-se usar a opção ‘advance=’advance’’ no comando anterior. Onde advance pode ser ‘yes’ ou ‘no’ e indica se o comando deve ou não avançar automaticamente para a próxima linha. São usados somente nos comandos ‘read’ e ‘write’ onde a opção formato não seja livre.

a significa que será impressa um string de qualquer tamanho (item 9).

Outras opções de impressão e leitura são encontrados no Apêndice B.

Os formatos servem para que os dados sejam impressos ou lidos de uma forma especifica, determinado pelo programador. Os formatos são compostos por uma seqüência de especificações que determinarão como os dados serão processados. Cada uma dessas especificações devem vir separadas por vírgulas. Pode-se ainda imprimir constantes numéricas e alfanuméricas, sendo que esta ultima deve vir entre apóstrofos ‘ ‘. O uso do ‘*’ no lugar do formato indica que todos os dados serão impressão de forma livre, com o número de casas especificados pelo próprio compilador. É um recurso útil para se evitar erros.

O FORTRAN não considera a primeira coluna da umidade de leitura e impressão quando a saída ou entrada é formatada, por isso deve-se incluir uma casa de impressão a mais para dados. Para formato livre não é necessário pois o FORTRAN os posiciona automaticamente.

Quando mais de um dado usar a mesma especificação, ela pode ser feita da seguinte forma: nespecificação1, n2especificação2 ou n( especificação1 , especificação2, ...), onde n e n2 representam o número de vezes que a seqüência deve se repetir.

Caso o número de especificações seja menor que o de variáveis a serem lidos ou impressos, a ultima especificação ou a ultima seqüência, caso seja usado o recurso n(especificação1, especificação2, ...), será repetida até que se complete o número necessário. Isto não é valido para constantes.

Quando o número de especificações é maior que os de dados a serem impressos as ultimas serão desprezadas.

A forma de se declarar os formatos é a seguinte:

Onde r é um numero inteiro, e representa o rótulo do ‘format’. Um mesmo ‘format’ pode ser usado por vários comandos de escrita e leitura.

WIN – o formato pode vir entre apóstrofos e parênteses ‘(esp.1, esp2,..)’, dentro do próprio comando de impressão ou leitura.

Strings devem vir entre apóstrofos duplos (‘’string’’) nesse formato.

‘w’ representa o tamanho do campo a ser impresso ou lido, ‘m’ representa o número de zeros que virá antes do número, ‘d’ representa o número de casas decimais e ‘e’ representa o número de casas para o expoente.

O ponto decimal, o ‘e’ do expoente e o sinal ‘-‘ devem ser contados ao se dar o tamanho do campo (‘w’). Ao ler um dado que não possui ponto decimal e no seu formato é esperado um, o compilador lerá este dado como se lá houvesse um ponto.

Quando o ponto existe mas não está na posição especificada, a sua posição original é mantida.

A notação com zeros ‘m’ só é válida quando m é maior que o número de casas que o número ocuparia no formato livre.

Nas notações com expoente (ENw.d[Ee], ESw.d[Ee], ...) não se pode omitir o ‘E’ ou ‘e’. Sempre que houver este termo, a parte exponencial vai existir independente do seu valor.

Caso as strings sejam maiores que o espaço reservado à elas, serão tomados apenas os w primeiros caracteres. Se forem menores, elas serão alinhadas a direita e os outros espaços deixados em branco.

F90 – os valores dos campos podem ser variáveis desde que venham entre ‘<var1>’. Não é valido para ‘print’.

Para valores numéricos que precisão de mais casas de impressão que as indicadas no ‘format’, serão impressos somente ‘*’ naquele campo.

Antes ou depois de ‘, ‘’, /, \, nH, $ ou : a vírgula é opcional.

produz o seguinte resultado:

Quando se deseja trabalhar com grandes quantidades de dados, o melhor é armazena-los numa unidade de memória secundaria, ou seja em arquivos. Um programa pode gerar tantos dados que todos eles não caberiam na tela de uma só vez, e ainda seriam perdidos ao finalizar o programa. Os dados salvos em arquivos podem ser usados pelo próprio programa ou exportados para serem processados de outra forma. Arquivos de leitura economizam um tempo precioso para o usuário do programa pois ele não vai precisar de enviar dados via teclado, e com arquivos milhares de dados podem ser lidos em segundos.

O primeiro passo para se usar arquivos em FORTRAN é indicar ao programa qual é o nome do arquivo e o número de unidade referente a ele.

Outras opções para abertura e fechamento de arquivos podem ser encontradas no Apêndice B.

Onde unidade deve ser um inteiro maior ou igual a zero, e é uma referencia a este arquivo. O número da unidade deve vir no comando ‘read’ ou ‘write’ indicando que os dados serão retirados ou colocados neta unidade. A disposição dos dados em arquivos são as mesmas utilizadas nas unidades de entrada e saída padrão (Item 8 Primeira Parte), com uma única diferença, as strings devem vir entre apóstrofos ‘ ‘. A abertura do arquivo pode ser feita em qualquer parte do programa (inclusive dentro de funções e subrotinas), desde que venha antes de um comando que o utilize.

Apesar de se poder usar qualquer extensão de arquivo ou até omiti-la, as extensões .dat para leitura e .out para saída são mais comumente encontradas.

Quando não for utilizado o comando ‘open’, o programa emitirá uma mensagem na tela pedindo o seu nome, podendo o usuário escolher um nome diferente a cada vez que o programa for executado. Todos os arquivos dever estar ou serão criados no mesmo diretório em que estiver o programa.

Um arquivo pode também ser fechado, isto fará com que o FORTRAN coloque uma marca de fim de arquivo naquele ponto, esta marca pode ser identificado por outro comando ou função (Apêndices A e B).

Onde status=’estado’ é opcional. Estado pode ser ‘keep’ que mantém o arquivo na memória (esta é a opção assumida quando status=’estado’ é omitida), ou ‘delete’ que apaga o arquivo da memória.

Arquivos fechados podem ser reabertos em qualquer parte do programa.

Os programas em FORTRAN devem conter os comandos escritos na ordem em que serão executados, com exceção das funções, subrotinas e laços de repetição. Portanto um programa em FORTRAN deve seguir o seguinte padrão:

Onde as declarações são opcionais ( item 4 primeira parte).

O comando end indica o fim do programa. Se o programador preferir pode finalizar o programa prematuramente usando o comando ‘stop’ ou ‘call exit’.

O quando se deseja que o comando do programa avance ou recue em sua estrutura, usa-se o comando ‘goto’ ou ‘go to’.

Onde r é um rótulo de uma linha que possui ou não um comando. Como uma linha rotulada não pode estar em branco, se não for necessária à inclusão de nenhum comando, pode-se usar a palavra chave ‘continue’, que não irá interferir em nada no programa.

Quando a expressão de teste for verdadeira os comandos serão executados, quando for falsa o programa segue para o próximo comando logo abaixo da estrutura condicional. A primeira opção só é valida quando for executado um único comando. Este comando pode ser de qualquer tipo, atribuição, escrita, leitura ou ‘goto’.

Quando a expressão de teste for falsa a seqüência de comandos 2 será executada. Mesmo quando só há um comando na seqüência de comandos 1, não se pode omitir a palavra chave ‘then’.

É permitido o uso de estruturas condicionais umas dento das outras.

Onde ‘exp. case' é uma expressão ou constante inteira, lógica ou literal (somente um caractere ‘character*1’). Caso o valor de ‘exp. case’ estiver na ‘lista de seleção 1’, os ‘comandos 1’ serão executados. Se o valor não estiver na ‘lista de seleção 1’ o computador irá avaliar a ‘lista de seleção 2’, se for verdadeira serão executados os ‘comandos 2’ e assim até terminar os comandos ‘case (lista de seleção n)’. O comando ‘case default’ é opcional, e faz com que os ‘comandos d’ sejam executados caso nenhuma das outras avaliações sejam verdadeiras. ‘nome_case’ é opcional, deve seguir as mesmas regras usadas para dar nomes as variáveis. A sua utilidade é apenas de dar maior clareza ao programa

As listas de seleção podem ser da seguinte forma: 

Não é permitida a superposição de valores.

Os valores literais devem vir entre apóstrofos e seus valores serão avaliados de acordo com o padrão ASCII. Uma tabela com os valores ASCII pode ser encontrada no Apêndice C.

Quando o mesmo comando precisa ser executado várias vezes até que se atinja uma certa condição ou um número certo de repetições, o melhor é usar as estruturas de repetição. Estas estruturas são bem simples e podem economizar várias linhas de comando.

Esta é uma estrutura de repetição muito simples, mas não recomendada para programação. Estruturas mais aceitas, pois possuem equivalentes em outras linguagens, são da seguinte forma:

‘var’ é uma variável inteira que recebe inicialmente o valor ‘n1’, a seqüência de comandos se repete, e o valor de ‘var’ aumenta de ‘n3’ a cada vez que o comando volta para a linha do ‘do’. A repetição só para quando o valor de ‘var’ ultrapassa ‘n2’.

A palavra chave ‘end do’ pode ser escrita como ‘enddo’. ‘n1’, ‘n2’ e ‘n3’ podem ser constantes ou variáveis inteiras ou reais, positivas ou negativas. Quando ‘n3’ for igual a um ele pode ser omitido.

Uma forma de se usar uma expressão de teste no comando ‘do’, é o uso do ‘do while’.

Enquanto ‘exp. teste’ for verdadeira a seqüência de comandos será executada.

Onde ‘variável’ é uma variável inteira que deve ter valor máximo igual ao número de rótulos que estão dentro dos parênteses. Quando esta variável tiver valor 1 o comando do programa vai para a linha rotulada com ‘r1’, quando tiver valor 2 vai para a linha com o rótulo r2, e assim por diante. Se o valor de ‘variável’ for maior que o número de rótulos o comando do programa vai para a linha imediatamente abaixo do ‘goto’.

Exp. numérica não pode ser complexa. r1, r2, r3 são rótulos. Se o valor de ‘exp. numérica’ for menor que zero o comando vai para a linha com o rótulo r1, quando for igual a zero o comando vai para linha com o rótulo r2 e quando for maior que zero vai para r3.

‘tipo’ pode ser qualquer tipo de variável inteira, real, lógica, complexa ou literal. Li1, Li2,..., Lin são os índices inferiores, e Ls1, Ls2,..., Ln são os índices superiores da matriz ou vetor. Os valores de Li e Ls podem ser positivos, nulos ou negativos desde que sejam inteiros. Quando o valor de Li é omitido, o valor um é usado como padrão. As variáveis podem ter duas ou mais dimensões, sendo declaradas da mesma forma, com cada dimensão separada das outras por vírgulas.

Os parênteses são opcionais. ‘tipo’ pode ser ‘integer’, real ou qualquer outro tipo de variáveis. Em ‘parameter’ não se pode declarar vetores e matrizes.

F90 – Uma forma simplificada de se atribuir o valor e o tipo da constante é feito da seguinte forma.

Declaração:

Associação:

Atribuição:

Os valores de vetores e matrizes devem ser declarados todos de uma vez, com separação entre eles feita por vírgula.

O nome do bloco é opcional, e se for repetido as variáveis serão agrupadas em um bloco de mesmo nome. A ausência do nome e o nome ‘/ /’ tem o mesmo significado. As variáveis de um ‘common’ sem nome não podem ser declaradas pelo comando ‘data’. Uma mesma variável não pode ocupar mais de um comando ‘common’.

As variáveis declaradas em um ‘common’ com nome podem receber valores iniciais de uma forma mais estruturada. No ‘block data’ podem ser usados os seguintes recursos: common(com nome), parameter, data, dimension e variáveis derivadas de um type.

O ‘nome_bloco’ é opcional e deve seguir as mesmas regras para nomes de variáveis.

Nome e extensão podem ser qualquer um, mas a extensão ‘.inc’ é a mais comum para este tipo de arquivo. É permitido o uso de caminhos completos no lugar do nome.

Resto da divisão de X por Y

( se Y > X o valor é zero)

Os valores absolutos dos dados complexos são calculados pela seguinte formula:

As opções contidas aqui foram baseadas no compilador FORTRAN Visual Workbrench v 1.00. Outros compiladores possuem outros nomes para estas opções, e podem possuir outras alem destas.

As opções entre colchetes são opcionais. Elas podem vir em qualquer ordem, exceto quando explicitado.

OPEN ([UNIT=]unit [ , ACCESS=access] [ , BLANK=blanks]

[ , BLOCKSIZE=blocksize] [ , ERR=errlabel] [ , FILE=file]

[ , FORM=form] [ , IOSTAT=iocheck] [ , MODE=mode]

[ , RECL=recl] [ , SHARE=share] [ , STATUS=status])

UNIT= - Quando omitido, o primeiro valor será o número da unidade (unit).

unit – Expressão inteira. Indica o número da unidade.

access – Expressão alfanumérica. ‘APPEND’ , ‘DIRECT’ ou ‘SEQUENTIAL’ (padrão, quando access é omitido)

blanck – Expressão alfanumérica. ‘NULL’ ignora zeros e espaços, ‘ZERO’ espaços são substituídos por zeros. Os formatos BN e BZ podem anular este efeito.

blocksize – Expressão inteira. Especifica o tamanho da unidade (em bytes).

errlabel – Expressão inteira. Indica o rótulo de uma linha no mesmo arquivo para onde o comando vai se houver erro. Quando omitido o efeito é determinado pela presença ou não de iocheck.

file – Expressão alfanumérica. Indica o nome do arquivo. Quando omitido o programa pede ao usuário um nome.

form – Expressão alfanumérica. ‘FORMATED’ (padrão quando access=’SEQUENTIAL’), ‘UNFORMATED’ (padrão quando access=’DIRECT’), ‘BINARY’.

iocheck – Variável inteira. Retorna zero quando não ocorre erros, retorna um número negativo se encontrar a marca de fim de arquivo (EOF), retorna o número do erro quando um ocorre.

mode – Expressão alfanumérica. ‘READ’ o arquivo é só para leitura, ‘WRITE’ o arquivo é só para escrita, ‘READWRITE’ o arquivo pode ser usado para leitura ou escrita.

recl – Expressão inteira. Representa o tamanho de cada dado em bytes. É obrigatório para access=’DIRECT’.

share – Expressão alfanumérica. ‘DENYRW’ ignora mode=’READWRITE’, ‘DENYWR’ ignora mode=’WRITE’, ‘DENYRD’ ignora mode=’READ’, ‘DENYNONE’ ignora qualquer mode,

status – Expressão alfanumérica. ‘OLD’ indica que o arquiva já existe, ‘NEW’ indica que o arquivo deve ser criado, ‘UNKOWN’ (padrão) verifica a existencia do arquivo, se ele não existir será criado um, ‘SCRATHC’

CLOSE ( [UNIT=] unit [,ERR=errlabel] [,IOSTAT=iocheck]

[,STATUS=status] )

UNIT= - Quando omitido, o primeiro valor será o número da unidade (unit).

unit – Expressão inteira. Indica o número da unidade.

errlabel – Expressão inteira. Indica o rótulo de uma linha no mesmo arquivo para onde o comando vai se houver erro. Quando omitido o efeito é determinado pela presença ou não de iocheck.

iocheck – Variável inteira. Retorna zero quando não ocorre erros, retorna um número negativo se encontrar a marca de fim de arquivo (EOF), retorna o número do erro quando um ocorre.

status – Expressão alfanumérica. ‘KEEP’ indica que o arquiva deve ser mantido, ‘DELETE’ indica que o arquivo deve ser apagado.

WRITE ([UNIT=] unit [ , [{[ FMT=] format] | [ NML=] nml }]

[ , ERR=errlabel] [ , IOSTAT=iocheck] [ , REC=rec] ) iolist

UNIT= - Quando omitido, o primeiro valor será o número da unidade (unit). Se FMT= ou NML= forem omitidos, format ou nml devem ser o segundo parâmetro.

unit – Expressão inteira. Indica o número da unidade.

format – Expressão inteira. Indica o rótulo de um comando ‘format’. Expressão alfanumérica. Expressão que contenha os formatos de impressão.

nml – Lista de variáveis á serem impressas, se estiver presente iolist deve ser omitida.

errlabel – Expressão inteira. Indica o rótulo de uma linha no mesmo arquivo para onde o comando vai se houver erro. Quando omitido o efeito é determinado pela presença ou não de iocheck.

iocheck – Variável inteira. Retorna zero quando não ocorre erros, retorna o número do erro quando um ocorre.

rec – Expressão inteira. Indica a posição do arquivo onde o dado será impresso. Somente para arquivos com access=’DIRECT’.

iolist – Lista de variáveis á serem impressas.

READ { { format, | nml } | ([UNIT=]unit [ , [ {[FMT=] format] |

[NML=]nmlspec}] [ , END=endlabel] [ , ERR=errlabel] [ , IOSTAT=iocheck]

[, REC=rec])} iolist

UNIT= - Quando omitido, o primeiro valor será o número da unidade (unit). Se FMT= ou NML= forem omitidos, format ou nml devem ser o segundo parâmetro.

unit – Expressão inteira. Indica o número da unidade.

format – Expressão inteira. Indica o rótulo de um comando ‘format’. Expressão alfanumérica. Expressão que contenha os formatos de leitura.

nml – Lista de variáveis á serem lidas, se estiver presente iolist deve ser omitida.

endlabel – Expressão inteira. Indica o rótulo de uma linha no mesmo arquivo para onde o comando vai se a marca de fim de arquivo (EOF) for encontrada.

errlabel – Expressão inteira. Indica o rótulo de uma linha no mesmo arquivo para onde o comando vai se houver erro. Quando omitido o efeito é determinado pela presença ou não de iocheck.

iocheck – Variável inteira. Retorna zero quando não ocorre erros, retorna 1 se encontrar EOF, retorna o número do erro quando um ocorre.

rec – Expressão inteira. Indica a posição do arquivo de onde o dado será lido.

iolist – Lista de variáveis á serem lidas.

REWIND { unit | ([UNIT=]unit [ , ERR=errlabel] [ , IOSTAT=iocheck])}

UNIT= - Quando omitido, o primeiro valor será o número da unidade (unit).

unit – Expressão inteira. Indica o número da unidade.

errlabel – Expressão inteira. Indica o rótulo de uma linha no mesmo arquivo para onde o comando vai se houver erro. Quando omitido o efeito é determinado pela presença ou não de iocheck.

iocheck – Variável inteira. Retorna zero quando não ocorre erros, retorna o número do erro quando um ocorre.

BACKSPACE {unit|( [UNIT=] unit [,ERR=errlabel] [,IOSTAT=iocheck ]] ) }

UNIT= - Quando omitido, o primeiro valor será o número da unidade (unit).

unit – Expressão inteira. Indica o número da unidade.

errlabel – Expressão inteira. Indica o rótulo de uma linha no mesmo arquivo para onde o comando vai se houver erro. Quando omitido o efeito é determinado pela presença ou não de iocheck.

iocheck – Variável inteira. Retorna zero quando não ocorre erros, retorna o número do erro quando um ocorre.

Valor ASCII – Caracter Correspondente