UNIVERSIDADE FEDERAL DE SERGIPE DEPARTAMENTO DE COMPUTAO PROGRAMA DE PS-GRADUO EM CINCIA DA COMPUTAO

RELATRIO TCNICO LINGUAGEM FORTRAN

Trabalho apresentado ao Curso de Mestrado em Cincia da Computao da UFS - Universidade Federal de Sergipe, pelos discentes Rafael Xavier de Oliveira Souza e Pricles Couto Cabral, para a disciplina Paradigmas de Linguagens de Programao. Orientador: Prof. Alberto Costa Neto.

So Cristvao Junho/2011

SUMRIO

1.
1.1. 1.2.

Introduo.......................................................................................... 5
Histrico ................................................................................................................... 5 Viso Geral e Caractersticas ................................................................................ 7

2.
2.1.

Tipos de Dados ................................................................................. 9

Tipos Primitivos ..................................................................................................... 10 Tipo Inteiro ..................................................................................................... 10 Tipo Real ........................................................................................................ 10 Tipo Caractere ............................................................................................... 11 Tipo Lgico .................................................................................................... 11 Tipo Complexo .............................................................................................. 11 2.1.1. 2.1.2. 2.1.3. 2.1.4. 2.1.5.

2.2.

Tipos Compostos .................................................................................................. 12 Tipo Array....................................................................................................... 12 Tipo Apontador .............................................................................................. 14 Tipo Registro ................................................................................................. 14 Tipo Unio...................................................................................................... 15

2.2.1. 2.2.2. 2.2.3. 2.2.4. 2.3. 2.4.

Tipos Recursivos................................................................................................... 16 Tipos de Dados Implcitos .................................................................................... 16

3. 4. 5.
5.1. 5.2. 5.3. 5.4. 5.5. 5.6. 5.7. 5.8.

Verificao de Tipos ........................................................................17 Equivalncia de Tipos .....................................................................18 Expresses ......................................................................................18

Operador de Atribuio ........................................................................................ 19 Operador de Apontamento................................................................................... 19 Operadores Aritmticos ........................................................................................ 20 Operadores Relacionais ....................................................................................... 20 Operadores Lgicos ............................................................................................. 21 Operador de Concatenao................................................................................. 22 Precedncia de Operadores ................................................................................ 23 Avaliao de Expresses com Curto-Circuito .................................................... 24

6.
6.1.

Comandos .......................................................................................25
Comando de Atribuio ........................................................................................ 25

3 6.2. Comandos Condicionais ...................................................................................... 26 Seleo de Caminho Condicionado ............................................................ 26 Seleo de Caminho Duplo .......................................................................... 27 Seleo de Caminhos Mltiplos................................................................... 28

6.2.1. 6.2.2. 6.2.3. 6.3.

Comandos de Repetio ...................................................................................... 30 Comando DO-WHILE ................................................................................... 30 Comando DO iterativo .................................................................................. 31

6.3.1. 6.3.2. 6.4. 6.5.

Chamadas de Procedimento ............................................................................... 31 Comandos de Desvio Incondicional .................................................................... 32 Desvio Irrestrito ............................................................................................. 32 Escapes ......................................................................................................... 32 Excees........................................................................................................ 34

6.5.1. 6.5.2. 6.5.3.

7.
7.1. 7.2. 7.3.

Vnculos ...........................................................................................34
Vinculao de Tipos ................................................................................................. 35 Vinculao de Armazenamento ............................................................................... 35 Tempo de Vida ........................................................................................................ 36

8. 9.
9.1.

Escopo .............................................................................................37 Declaraes.....................................................................................38

Declaraes de Variveis ......................................................................................... 38 Inicializao de Variveis .................................................................................. 40 9.1.1.

9.2.

Declaraes de Constantes ...................................................................................... 41

10. Abstraes.......................................................................................42
10.1. 10.2. 10.3. 10.3.1. 10.3.2. 10.3.3. Abstrao de Procedimento ................................................................................. 42 Abstrao de Funes .......................................................................................... 43 Parmetros .......................................................................................................... 44 Argumentos associados ou dummy ............................................................... 45 Objetos Locais .................................................................................................. 46 Passagem de parmetros ................................................................................. 46

11. Mdulos ...........................................................................................48

11.1. Visibilidade .......................................................................................................... 49

12. Estratgias de Avaliao .................................................................50 13. Polimorfismo ....................................................................................51

13.1. Coero ............................................................................................................... 51

4 13.2. 13.3. Sobrecarga........................................................................................................... 52 Operadores definidos pelo usurio ...................................................................... 53

14. Efeitos Colaterais ............................................................................55 15. Critrios Gerais de Avaliao ..........................................................56

15.1. 15.1.1. 15.1.2. 15.1.3. 15.1.4. 15.2. 15.2.1. 15.2.2. 15.2.3. 15.3. 15.3.1. 15.3.2. 15.3.3. 15.3.4. 15.4. Legibilidade ......................................................................................................... 56 Simplicidade Global.......................................................................................... 56 Ortogonalidade ................................................................................................ 57 Tipos de Dados e Estruturas ............................................................................. 58 Sintaxe ............................................................................................................. 58 Capacidade de Escrita .......................................................................................... 59 Simplicidade e Ortogonalidade......................................................................... 59 Suporte para abstrao .................................................................................... 60 Expressividade ................................................................................................. 60 Confiabilidade...................................................................................................... 60 Verificao de Tipos ......................................................................................... 61 Manipulao de Excees ................................................................................ 61 Apelidos ........................................................................................................... 61 Legibilidade e Capacidade de Escrita ................................................................ 61 Custo ................................................................................................................... 62

16. Concluses ......................................................................................63 Referncias ..............................................................................................64

1. Introduo

1.1.

Histrico

FORTRAN (FORmula TRANslation System) foi a primeira linguagem considerada de alto nvel (High Level prxima a linguagem humana), desenvolvida por John Backus, na IBM, em 1954, e comercializada em 1957. Continua sendo muito utilizada nos dias de hoje nas reas de programao cientifica e aplicaes matemticas. FORTRAN inicialmente era um

interpretador de cdigo digital para o computador IBM 701, sendo originalmente chamado de Speedcoding. A primeira gerao de cdigos para programao de computadores era designada de linguagem de mquina ou cdigo de mquina, que na verdade, a nica linguagem que o computador interpreta. So instrues codificadas em sequncias de 0s e 1s (Sequncia binria). A segunda gerao de cdigos foi chamada de linguagem Assembly (montagem). Esta linguagem torna a sequncia de 0s e 1s em palavras compreensveis, como ADD, STORE, LOAD. Na verdade, esta linguagem traduzida para cdigo de mquina por programas chamados Assemblers (montadoras). A terceira gerao de cdigos foi chamada de High level language ou HLL, na qual existem palavras e sintaxe de acordo com a linguagem humana (como palavras em uma sentena). Para que um computador entenda uma HLL, necessrio um compilador que traduza o cdigo para Assembly ou para cdigo de mquina. John Backus chefiou a equipe de pesquisadores da IBM que criou o FORTRAN, no Watson Scientific Laboratory NY. Esta equipe no inventou a ideia de HLL ou a ideia de compilar uma linguagem para cdigo de mquina, mas o FORTRAN foi uma das primeiras HLL. O primeiro compilador FORTRAN representou um marco na histria da Computao, no tempo em que computadores tinham bem pouca memria (aproximadamente 15kb), eram bastante lentos e usavam Sistemas

Operacionais primitivos.

O primeiro compilador FORTRAN foi projetado e escrito entre 1954 e 1957 pela IBM por um grupo liderado por John W. Backus e contou com a participao de excelentes programadores como Sheldon F. Best, Harlan Herrick, Peter Sheridan, Roy Nutt, Robert Nelson, Irving Ziller, Richard Goldberg, Lois Haibt e David Sayre. Backus tambm foi responsvel pelo projeto do primeiro computador a usar o FORTRAN, o IBM 704. A inveno ficou famosa rapidamente, o que no era de se admirar, visto que programas que levavam semanas para serem escritos poderiam agora ser feitos em questo de horas, alm de exigir muito menos trabalho. Outra grande vantagem da inveno era a portabilidade dos programas escritos em FORTRAN. A linguagem foi adotada pelas comunidades militares e usada extensivamente em programas espaciais e projetos militares. Em 1966, quando a primeira verso padronizada da linguagem estava disponvel, FORTRAN j era a linguagem de escolha da comunidade cientfica. Como os computadores nessa poca eram usados quase que exclusivamente para clculos e por pessoas do meio acadmico e cientfico, a linguagem foi desenvolvida sem praticamente nenhuma preocupao com estruturao lgica ou clareza em sua codificao que facilitasse a escrita de programas grandes, mesmo porque no havia programas realmente grandes naquela poca. FORTRAN passou por algumas grandes revises. A linguagem foi modernizada a partir de 1970 e o novo padro, FORTRAN 77, introduzia algumas pequenas modificaes na estrutura dos comandos, como o uso de blocos IF-THEN-ELSE. No entanto, nessa poca, existiam outras linguagens como C, PASCAL, ADA e MODULA que haviam introduzido novos conceitos ou sedimentado outros, como a tipagem explcita de variveis; definio de novos tipos de dados, permitindo a criao de estruturas de dados mais adequadas para resolver problemas; alocao dinmica de dados; subprogramas recursivos; controle de exceo (uma das principais caractersticas da linguagem ADA); e estabelecimento de mdulos. FORTRAN 77 no oferecia quaisquer desses recursos e, por isso, acabou sendo relegada quase que a segundo plano. Por meados da dcada de 1980, uma nova reviso da linguagem estava por vir. Batizada ento de FORTRAN 8X, ela viria a incorporar praticamente todos os outros conceitos j citados (exceto a tipagem explcita e o controle de

exceo). O processo de definio do novo padro foi demorado, porm permitiu que muitas das ideias a serem inseridas nesse padro fossem amadurecidas. Assim, surgiu a linguagem FORTRAN 90, que se assemelha a linguagens como C e PASCAL, para os fins a que ela se destina. Mais do que isso, ela incorpora mecanismos para a manipulao de arranjos que no so oferecidos em qualquer outra linguagem e que em muito auxiliam no desenvolvimento de programas cientficos. Em 1996, foi feita mais uma reviso da linguagem, chamada de FORTRAN 95 (ver KERRIGAN, 1993), a qual incorporou pequenas modificaes linguagem FORTRAN 90, motivada pela necessidade de aproximar o padro linguagem HIGH PERFORMANCE FORTRAN HPF, a qual voltada para o uso de computadores de arquiteturas avanadas, vetoriais e/ou paralelas. A linguagem HPF pode ser considerada uma extenso da linguagem FORTRAN 95 e, atualmente, muitos fabricantes oferecem compiladores HPF baseados na linguagem FORTRAN 95. Desde 1997, a linguagem encontra-se em processo de reviso. As novas verses da linguagem FORTRAN (ver ISO/IEC JTC1/SC22/WG5, 2003 e ISO/IEC JTC1/SC22/WG5/N1791, 2009), denominadas FORTRAN 2003 e FORTRAN 2008, incorporaro uma srie de novos comandos que permitiro, entre outros, o controle de excees, programao orientada a objetos e suporte programao paralela. Essas revises aumentaro ainda mais os recursos da linguagem e, por conseguinte, seu uso pela comunidade cientfica. Apesar de ter surgido na dcada de 50, FORTRAN ainda a linguagem mais utilizada em programao cientfica (clculo numrico), principalmente na Fsica. Estima-se que mais de 90% do software utilizado nesse campo da Cincia est escrito em Fortran. Outras linguagens surgiram ao longo do tempo, prometendo desbancar o FORTRAN, como Algol, Basic, Pascal, C e C++. Com a exceo de C e C++, que se tornaram linguagens extremamente poderosas, as demais foram perdendo o seu prestgio.

1.2.

Viso Geral e Caractersticas

Em FORTRAN existem basicamente duas formas de se escrever um programa: com formulrio fixo (fixed form) ou com formulrio livre (free form).

No formato livre, um comando pode iniciar em qualquer caractere da linha, a qual contm at 132 caracteres. Nesse formato, os comandos podem aparecer um em cada linha ou, ento, mais de um comando numa mesma linha, quando eles devem ser separados por ; (ponto-e-vrgula). Caso um comando no caiba numa linha, ele deve ser interrompido com o caractere &, e a continuao do comando deve aparecer na linha seguinte. Nomes podem ter no mximo 31 caracteres. O caractere "c" no comeo da linha indica que a partir dali se encontra um comentrio. Como no so permitidas linhas em branco, linhas apenas com o "c" inicial utilizado para criar espaos em branco nos programas. No caso do FORTRAN 90/95, usa-se a "!" que tambm pode ser usado no fim do comentrio. J no formato fixo, herdado da linguagem FORTRAN 77, uma linha tem apenas 72 caracteres, e os comandos devem aparecer apenas a partir da coluna 7, um comando por linha. As colunas 1 5 so reservadas para se identificar um comando atravs de um rtulo numrico; e a coluna 6 reservada para a colocao de um caractere de continuao (diferente de 0 ou espao em branco). Comentrios podem ser inseridos atravs do caractere C ou *, na coluna 1, ou atravs do caractere ! , o qual s ser considerado como incio de comentrio se aparecer nas colunas 1 a 5 ou 7 a 72. O cdigo FORTRAN foi por muito tempo estruturado em linhas que poderiam conter no mximo 72 caracteres cada um. Essa restrio vinha do tempo em que o cdigo FORTRAN era inserido nos computadores atravs de cartes, os quais s comportavam 80 caracteres por linha. Assim, se a linha de comando precisa de mais de 70 caracteres, esta dividida em duas ou mais linhas utilizando um caractere especial para indicar sua diviso (* ou s vezes &) na sexta posio da linha. digno de notar que programas em FORTRAN so mais bem manipulados por programadores com muita experincia. Para programadores que s trabalham com linguagens de programao modernas, um primeiro contato com FORTRAN pode ser traumtico. Devido a limitaes em compiladores antigos, programas podem ser arquivos bem grandes. Programas de 200.000 linhas ou mais so comuns. O cdigo pesado e raramente bem estruturado. So poucos os comentrios. Grande parte das advertncias a

respeito do uso da ferramenta GOTO vem da experincia com o cdigo FORTRAN. Um programa ou cdigo-fonte escrito na linguagem FORTRAN composto por blocos, os quais definem as diferentes sees do mesmo. Ele tem, no mnimo, uma seo chamada de programa principal, a qual composta por comandos no-executveis (declaraes e comentrios) e executveis, e englobada pelos comandos PROGRAM <nome-do-programa> e END

PROGRAM <nome-do-programa>. A estrutura bsica um programa em FORTRAN pode, ento, ser descrita como: PROGRAM <nome-do-programa> [ <declaraes> ] [ <comandos-executveis> ] END PROGRAM <nome-do-programa> Onde:
o

<declaraes> um conjunto de comandos no executveis que definem os dados e subprogramas a serem usados no programa;

<comandos-executveis> um conjunto de comandos que sero executados, na ordem em que aparecem listados e atendendo a quaisquer desvios em seu fluxo de execuo, conforme expresso pelo programador, valendo-se dos diferentes comandos de controle de fluxo de execuo.

FORTRAN, ao contrrio de linguagens como o Java, por exemplo, no case sensitive, isso para diferenciar a prtica comum de apenas usar letras maisculas para as linhas de cdigo, e tambm por que antigamente muitos sistemas no suportavam o uso de letras minsculas.

2. Tipos de Dados O FORTRAN tem uma considervel versatilidade no que se refere aos tipos de dados que pode manipular. Um tipo de dados define um conjunto de valores com determinadas caractersticas. FORTRAN oferece os tipos primitivos inteiro, real, caracter, complexo e lgico. H tambm os tipos compostos array (vetor ou quadro), apontador (ponteiro) e registro.

10

2.1.

Tipos Primitivos

2.1.1. Tipo Inteiro Conjunto de nmeros inteiros positivos e negativos. A escrita dos inteiros obedece a regras. Assim, so vlidas as seguintes constantes inteiras: -435 ; +256 ou 256; 10000 mas invlidas: 10,000 ou 10.000 ou 10 000. Na escrita de inteiros no so admitidos os separadores frequentemente utilizados na escrita normal. Podem assumir os seguintes valores:
o o o o

INTEGER*1: 128 a 127; INTEGER*2: 32768 a 32767; INTEGER*4: 2147483648 a 2147483,647; INTEGER*4 pode ser representado somente por: INTEGER.

Os nmeros aps o * indicam quantos bytes a varivel ocupa na memria do computador. Esta observao vlida para todos os tipos de variveis. Para variveis do tipo inteiro ou real pode-se ainda usar o comando KIND para especificar a preciso numrica. Exemplo: INTEGER (KIND=2) x.

2.1.2. Tipo Real Conjunto de nmeros reais positivos e negativos. A escrita pode ser efetuada em notao decimal ou cientfica sujeita, tambm, a regras. Assim, em notao decimal, so vlidas as seguintes constantes: +2.56 ou 2.56 ; 3.4567 mas invlidas: +2,56 ou 2,56 ; -3,4567. A notao decimal no admite a vrgula. No que se refere notao cientfica, uma vez que o Fortran no admite sobre ou subndices, o smbolo 1.34 10 -5 no vlido. Em vez dele, escrevese: 1.34E-5 ou 1.34e-5, onde o E, ou e, representa a base 10. H dois tipos de representao:
o

Preciso simples, 6 casas decimais (padro): REAL*4 ou REAL 3.402823E+38. Incremento mnimo de 1.175494E-38.

11
o

Preciso dupla, 15 casas decimais (padro): REAL*8 ou DOUBLE PRECISION 1.797693134862316D+308. Incremento mnimo de 2.225073858507201D-308.

A parte exponencial deve ser separada por um d ou D no lugar do e ou E para real do tipo *8.

2.1.3. Tipo Caractere Sequncia de smbolos (pertencentes ao conjunto de caracteres do Fortran) escritos entre aspas ou apstrofes. Exemplos deste tipo so as constantes: Ana Maria ; media*/ ; 2567 ou 2567. representado da seguinte forma: CHARACTER*w NOME; onde w representa o nmero mximo de caracteres que a varivel pode conter dentro do programa, ou CHARACTER *w var1,var2 (var1 e var2 possuem o mesmo tamanho w), ou ainda CHARACTER (LEN = w) var1, (LEN=w2) var2 (var1 tem tamanho w e var2 tamanho w2).

2.1.4. Tipo Lgico Conjunto dos dois valores lgicos verdadeiro e falso (true e false) escritos entre pontos: .TRUE. ; .FALSE. ou .true. ; .false. ou somente T e F ou ainda 1 e 0 ou diferente de zero e 0.

2.1.5. Tipo Complexo Representa valores complexo, ou seja, que possuem uma parte real e uma imaginria. H dois tipos de representao:
o

Preciso simples, com 6 casas decimais: COMPLEX*8 ou COMPLEX.

Preciso dupla, com 15 casas decimais: COMPLEX*16.

Os valores que um complexo pode assumir so os mesmos que os reais. Exemplo: complex c/(4.,.3)/ (c vale 4,0 reais e 0,3 imaginrios).

12

2.2.

Tipos Compostos

2.2.1. Tipo Array O FORTRAN permite declarar variveis indexadas, isto , so designadas pelo mesmo nome e distinguem-se umas das outras atravs do valor de um ndice, designado por array (vetor ou quadro) as quais podem conter os tipos primitivos de dados. Trata-se de um tipo estruturado de dados apropriado para manipular vetores e matrizes de diferentes dimenses. Por exemplo, a seguinte declarao: real, dimension (5) :: x; reserva 10 clulas na memria central cujos nomes so: x(1), x(2), x(3), x(4), x(5). Diz-se, ento, que se definiu um array real de dimenso 1 com extenso 5. Essas clulas podem agora ser inicializadas por atribuio ou leitura, por exemplo: x(1) = 4.5 ou read(*,*) x(1) x(2) = 3.2 ou read(*,*) x(2) x(3) = 2.0 ou read(*,*) x(3) x(4) = 6.1 ou read(*,*) x(4) x(5) = 1.2 ou read(*,*) x(5)

Tambm se pode inicializar o array anterior com a seguinte atribuio global: x = ( /4.5, 3.2, 2.0, 6.1, 1.2/ ). O membro direito da atribuio designa-se por constante tipo vector (array constant). Se houver um vetor com uma extenso muito grande os processos de inicializao anteriores tornam-se impraticveis. Assim, preciso que haja um comando estruturado que tire partido do ndice da varivel e que no obrigue a mencionar explicitamente cada elemento do vetor. Uma estrutura que permita escrever um nico comando e a repeti-lo (a iter-lo) tantas vezes quantas as necessrias. Tal estrutura o ciclo iterativo com ndice: do i = 1, 5 read (*,*) x(i) end do A iterao controlada pelo ndice inteiro i, o qual varia o seu valor de 1 at 5.

13

So permitidos arrays at 7 dimenses (com 7 ndices diferentes). Por exemplo, pode-se tratar matrizes definindo um array de duas dimenses: real, dimension (3,2) :: x. Assim, foi definido um array de duas dimenses, com 3x2 = 6 elementos (clulas). FORTRAN oferece arrays com tanto estticos (definido em tempo de compilao) quanto dinmicos (definido em tempo de execuo). Em ambos os casos o tamanho alocado fixo. Os arrays dinmicos podem ser alocados e desalocados mediante solicitao. Suas faixas de subscrito podem ser mudadas por qualquer processo de salvar, de desalocar ou de realocar. Por exemplo, para que uma matriz seja declarada como dinmica, deve-se usar o comando ALLOCATABLE: INTEGER, ALLOCATABLE, ARRAY (:,:) :: MAT Neste exemplo, MAT declarada como uma matriz de elementos do tipo INTEGER que pode ser dinamicamente alocada e cuja especificao feita com uma instruo ALLOCATE, como, por exemplo: ALLOCATE (MAT(10, N)) As faixas de subscrito podem ser especificadas por variveis de programa, bem como por literais. Os limites inferiores das faixas de subscrito so assumidos como 1. As matrizes dinmicas podem ser destrudas pela instruo

DEALLOCATE, como em: DEALLOCATE (MAT). Para tornar uma matriz dinmica maior ou menor, seus elementos devem ser salvos temporariamente em outra matriz, e ela deve ser desalocada e, depois, realocada com o novo tamanho. O FORTRAN inclui um grande nmero de operaes de matrizes chamados elementares porque so operadores entre pares de elementos da matriz. Por exemplo, o operador de adio (+) entre dois vetores resulta num vetor das somas dos pares de elementos dos dois. Os operadores de atribuio, aritmticos, relacionais ou lgicos podem ser sobrecarregados para matrizes de qualquer tamanho ou forma. Ele Inclui tambm funes intrnsecas ou de biblioteca para multiplicao de matrizes, para transposio de matrizes e para produto escalar de vetores.

14

2.2.2. Tipo Apontador Em FORTRAN, os ponteiros so usados para apontar tanto para variveis dinmicas no monte quanto para variveis estticas. Por exemplo: INTEGER, POINTER :: p INTEGER, POINTER, DIMENSION (:) :: list O ponteiro p pode apontar para qualquer valor do tipo INTEGER e o ponteiro list pode apontar para qualquer vetor unidimensional de elementos INTEGER. Os ponteiros do FORTRAN so implicitamente desreferenciados na maioria dos usos. Por exemplo, quando um ponteiro aparece numa expresso normal, ele sempre implicitamente desreferenciado. Uma forma da instruo de atribuio especial, pointer => target, usada quando o desreferenciamento no desejado. Essa atribuio usada para ajustar variveis de ponteiro direcionado a variveis particulares e, tambm, para defini-los de maneira que tenham os valores de endereo de outros ponteiros. Qualquer varivel para a qual se deva direcionar um ponteiro deve ter o atributo TARGET definido em sua declarao. Por exemplo: INTEGER, POINTER :: p INTEGER, TARGET :: x INTEGER y p=>x Pode-se apontar para x com p, mas no para y. Aps p apontar para x, a atribuio de um valor a p altera o valor de x. Os ponteiros do FORTRAN podem facilmente tornar-se pendurados porque a instruo DEALLOCATE, que assume um ponteiro como um argumento, no faz nenhuma tentativa de determinar se outros ponteiros esto apontados para uma varivel dinmica no monte que est sendo desalocada.

2.2.3. Tipo Registro Um registro um agregado possivelmente heterogneo de elementos de dados. Cada elemento individual identificado pelo seu nome. As declaraes

15

de registro no FORTRAN exigem que quaisquer registros aninhados sejam previamente definidos como tipos. Exemplo: type t1 integer i end type

type t2 type(t1) t real xi end type A maioria das linguagens usa uma notao de pontos para as referncias a campos, cujos componentes da referncia so conectados com pontos. Nas referncias a campos do FORTRAN se usa os smbolos de porcentagem (%) em vez de pontos. Por exemplo: type t1 integer i end type

type(t1) f1 f1%i = 9

2.2.4. Tipo Unio O FORTRAN oferece construes de unio em que no h nenhum suporte de linguagem para verificao de tipos. O comando EQUIVALENCE usado para especificar unies. Ele especifica que a mesma rea de armazenamento da memria ser compartilhada por dois ou mais objetos em um programa. Possui a seguinte sintaxe: EQUIVALENCE (lista_variveis). Exemplo: INTEGER A(20) REAL Y(20) EQUIVALENCE (A,Y)

16

Este comando no pode ser utilizado com: argumentos, conjuntos com comando ALLOCATABLE, ponteiro, nome de funo ou resultado desta, nome constante, componente de estrutura. Portanto, apesar da sua existncia seu uso em computao cientfica no recomendvel.

2.3.

Tipos Recursivos

Tipos recursivos so tipos de dados cujos valores so compostos por valores do mesmo tipo. Um tipo recursivo definido em termos de si mesmo. Assim como em linguagens como C, C++, ADA e Pascal, em FORTRAN tipos recursivos podem ser definidos a partir de ponteiros. Exemplo: TYPE milhas REAL :: mil TYPE(milhas), pointer :: pt END TYPE milhas

2.4.

Tipos de Dados Implcitos

Se num programa, uma varivel for referenciada sem ter sido declarada, ento o tipo implcito ser atribudo (REAL ou INTEGER). uma caracterstica automtica de toda implementao FORTRAN. A atribuio se baseia na primeira letra do nome de uma varivel: I, J, K, L, M ou N, ser definida como Inteiro (INTEGER) e qualquer outra letra ser definida como Real (REAL). Um tipo de dado implcito potencialmente perigoso e deve ser evitado, podendo ser modificado ou desligado, obrigando ao usurio definir todas as variveis que sero utilizadas no programa. Para isso, utiliza-se o comando: IMPLICIT <tipo> ( <lista de letras>, ... ) IMPLICIT REAL(A-H,O-Z),INTEGER(I-N) IMPLICIT NONE ! Definio implcita desligada

O Comando IMPLICIT deve ser utilizado logo aps a definio da estrutura do programa. PROGRAM teste

17

IMPLICIT NONE ...

3. Verificao de Tipos
Define-se uma linguagem de programao como fortemente tipada se erros de tipo sempre forem detectados. O FORTRAN no fortemente tipado porque a relao entre parmetros reais e formais no verificada quanto ao tipo. Alm disso, o uso de EQUIVALENCE entre variveis de tipos diferentes permite que uma varivel de um tipo se refira a um valor de um tipo diferente sem que o sistema seja capaz de verificar o tipo do valor quando uma das variveis em EQUIVALENCE referenciada ou atribuda. De fato, a verificao de tipos de variveis em EQUIVALENCE eliminaria a maior parte de sua utilidade. Assim, a verificao de tipos em FORTRAN esttica, ou seja, em tempo de compilao. Por exemplo, se for declarado um vetor dinmico, a varivel correspondente ao seu tamanho deve ser do tipo INTEGER, do contrrio, o compilador acusa erro de tipo. Caso a varivel seja lida durante a execuo do programa e seja informado um valor diferente de INTEGER para ela, o programa acusar um erro e ir travar, ou seja, a checagem dos tipos somente executada na compilao, no momento da declarao de cada varivel. O cdigo abaixo exemplifica tal situao: PROGRAM teste integer :: a de tipo integer,allocatable :: c(:) allocate(c(a)) read *,a ! ser exibido um erro durante a execuo ! o programa ser encerrado caso o valor lido no seja do tipo integer END PROGRAM teste ! deve ser integer, seno o compilador acusar erro

18

4. Equivalncia de Tipos
H dois tipos diferentes de equivalncia de tipos: a equivalncia de nome e a equivalncia de estrutura. A equivalncia de nome significa que duas variveis tm tipos equivalentes somente se estiverem na mesma declarao ou em declaraes que usam o mesmo nome de tipo. A equivalncia de estrutura significa que duas variveis tm tipos compatveis se os seus tipos tiverem estruturas idnticas. O FORTRAN utiliza a equivalncia estrutural de tipos. Exemplo: TYPE item INTEGER id END TYPE

TYPE prod INTEGER id END TYPE

type(item) p type(prod) q q=p No exemplo acima, foram definidos dois registros com estruturas idnticas. Nesse caso, mesmo sendo de tipos com nomes diferentes, eles so considerados equivalentes e um pode ser atribudo ao outro.

5. Expresses
Uma expresso uma frase do programa que necessita ser avaliada e produz como resultado um valor. Expresses so caracterizadas pelo uso de operadores, pelos tipos dos operandos e pelo tipo de resultado que produzem. Operadores designam o tipo de operao a ser realizada. Operandos indicam os valores sobre os quais a operao deve ser avaliada. O resultado o valor produzido pela avaliao da expresso.

19

Em FORTRAN, expresses so construdas com pelo menos um operador e, com pelo menos um operando, o tipo de uma expresso deriva do tipo dos operandos e os operandos podem ser: expresses, nmeros, caracteres ou funes. Esto disponveis operadores de atribuio,

apontamento, aritmticos, relacionais, lgicos e de caracteres. Alm disso, um programador pode definir outros operadores. Os operadores definidos pelo usurio sero abordados na seo 13.3.

5.1.

Operador de Atribuio

Normalmente uma expresso em FORTRAN utilizada em conjunto com o operador de atribuio =, que ir definir ou atribuir um valor a uma nova varivel. Exemplo: INTEGER a INTEGER :: b = 5 a=b ! a recebe o valor 5

5.2.

Operador de Apontamento

Uma varivel com atributo POINTER no pode ter atribudo um valor. Ela apenas pode apontar para outro apontador. Nesse caso, utiliza-se o operador =>. Sintaxe: <nome-apontador-1> => <nome-apontador-2> Onde: <nome-apontador-1> e <nome-apontador-2> so os nomes de variveis de mesmo tipo e declaradas com o atributo POINTER; um apontamento faz com que o apontador <nome-apontador-1> contenha o mesmo endereo de memria do dado apontado por <nome-apontador-2>. Exemplo: REAL, POINTER:: p REAL, TARGET:: x = 3 p=>x

20

5.3.

Operadores Aritmticos

Em FORTRAN 95, existem os operadores aritmticos usuais, para realizar a soma (+), subtrao e negao de sinal (-), multiplicao (*), diviso (/) e elevar um nmero a uma potncia inteira (**). Sintaxe: <expresso> ::= [-] <expresso-1> [ <op-arit> <expresso-2> ] <op-arit> ::= + | - | * | / | ** [-] Onde: <expresso-1> e <expresso-2> so expresses aritmticas admissveis na linguagem, envolvendo literais numricos, variveis e chamadas a funes e intrnsecos matemticos; se o operador utilizado for **, ento <expresso-2> deve ser de tipo INTEGER e, se o sinal - preceder <expresso-2>, ento <expresso-2> deve ser englobado por abre e fecha parnteses ( , ); <expresso> o resultado numrico.

Exemplos: Exponencial (**) (Avaliado da direita para esquerda): 10**2 ou a**b. Multiplicao (*) e Diviso (/) (Avaliado da esquerda para direita): 10*7/4 ou a*b/c. Adio (+) e Subtrao (-) (Avaliado da esquerda para direita): 7+8-3 ou a+b-c.

5.4.

Operadores Relacionais

Os operadores relacionais so utilizados para realizar a comparao lgica entre os valores de expresses aritmticas. So utilizados tambm em expresses lgicas, entre dois operandos, retornando um valor lgico (.TRUE. ou .FALSE.) .

21

Os operadores relacionais, como mnemnicos, so sempre utilizados entre dois pontos, maisculo ou minsculo. Esses operadores so os seguintes: igual == ou .EQ. diferente /= ou .NE. menor < ou .LT. maior > ou .GT. menor ou igual <= ou .LE. maior ou igual >= ou .GE.

Sintaxe: <expresso> ::= <expresso-1> <op-rel> <expresso-2> Onde: <expresso-1> e <expresso-2> so expresses aritmticas admissveis na linguagem, envolvendo literais numricos,

variveis e chamadas a funes e intrnsecos matemticos; <expresso> o resultado lgico, podendo assumir os valores .TRUE. e .FALSE. Exemplos: a == b ou a .EQ. b a /= b ou a .NE. b a < b ou a .LT. b a > b ou a .GT. b a <= b ou a .LE. b a >= b ou a .GE. b

5.5.

Operadores Lgicos

Os operadores lgicos permitem combinar expresses lgicas. So utilizados em expresses lgicas, com um ou dois operandos, retornando um valor lgico (.TRUE. ou .FALSE.). Os operadores disponveis so os seguintes: negao lgica .NOT. multiplicao lgica .AND. adio lgica .OR.

22

equivalncia lgica .EQV. negao da equivalncia lgica .NEQV.

Sintaxe: <expresso> ::= .NOT. <expresso-1> | <expresso-1> <op-log-binrio> <expresso-2> <op-log-binrio> ::= .AND. | .OR. | .EQV. | .NEQV. Onde: <expresso-1> e <expresso-2> so expresses lgicas

admissveis na linguagem; <expresso> o resultado lgico, podendo assumir os valores .TRUE. e .FALSE. Os resultados possveis da utilizao desses operadores so mostrados nas Tabelas 1 e 2.
<exp1> .FALSE. .FALSE. .TRUE. .TRUE. <exp2> .FALSE. .TRUE. .FALSE. .TRUE. .AND. .FALSE. .FALSE. .FALSE. .TRUE. .OR. .FALSE. .TRUE. .TRUE. .TRUE. .EQV. .TRUE. .FALSE. .FALSE. .TRUE. .NEQV. .FALSE. .TRUE. .TRUE. .FALSE.

Tabela 1 Tabela verdade para os operadores lgicos .AND., .OR., .EQV. e .NEQV. <expresso> .TRUE. .FALSE. .NOT. .FALSE. .TRUE.

Tabela 2 Tabela verdade para .NOT.

5.6.

Operador de Concatenao

Para concatenar duas strings de caracteres, utiliza-se o operador //. Sintaxe: <expresso> ::= <expresso-1> // <expresso-2> Onde:

23

<expresso-1> e <expresso-2> so expresses de caracteres; <expresso> uma string de caracteres, a qual formada pelos caracteres presentes em <expresso-1>, seguidos dos caracteres em <expresso-2>; o tamanho de <expresso> a soma dos tamanhos de <expresso-1> e <expresso-2>; se <expresso> for atribuda a uma varivel do tipo

CHARACTER(LEN=<tamanho>), tal que <tamanho> for menor do que o tamanho de <expresso>, ento apenas <tamanho> caracteres sero armazenados. Exemplo: CHARACTER(LEN=10) :: a CHARACTER(LEN=10) :: b CHARACTER(LEN=20) :: c c = a//b

5.7.

Precedncia de Operadores

Os operadores, inclusive aqueles definidos pelo usurio, so aplicados de acordo com uma ordem de precedncia, como especificado na Tabela 3.
Expresso Definida pelo usurio Aritmtica Aritmtica Aritmtica Caractere Relacional Relacional Relacional Operador Unrio ** *, / +, // ==, .EQ. /=, .NE. <, .LT. Operao qualquer potenciao multiplicao, diviso adio, subtrao concatenao igualdade desigualdade menor do que Ordem de Precedncia 1 2 3 4 5 6 6 6

24

Relacional Relacional Relacional Relacional Lgica Lgica Lgica Lgica Lgica Definida pelo usurio

>, .GT. <, .LT. <=, .LE. >=, .GE. .NOT. .AND. .OR. .EQV. .NEQV. Binrio

maior do que menor do que menor ou igual do que maior ou igual do que negao lgica multiplicao lgica adio lgica equivalncia no equivalncia qualquer

6 6 6 6 7 8 9 10 10 11

Tabela 3 Ordem de precedncia de operadores (o nvel 1 o de maior precedncia).

Observaes: Toda expresso que vier entre parntesis, ser avaliada primeiro; Em expresses aritmticas, com o mesmo nvel de avaliao, o que vier da esquerda para direita, ser avaliado primeiro, com exceo do expoente.

5.8.

Avaliao de Expresses com Curto-Circuito

Uma avaliao com curto-circuito de uma expresso tem seu resultado determinado sem avaliar todos os operandos e/ou operadores. Assim como Java, FORTRAN permite que suas expresses sejam avaliadas com curto-circuito. No exemplo abaixo, caso FORTRAN no implementasse esse tipo de avaliao ambas as expresses relacionais na expresso booleana do comando DO WHILE seriam avaliadas,

independentemente do valor da primeira. Assim, se a varivel chave no estivesse no array lista, a rotina terminaria com erro de subscrito fora da faixa. PROGRAM avaliacao

25

INTEGER :: i=0, chave INTEGER :: lista(3) = (/1,2,3/) READ *, chave DO WHILE (i<=3 .AND. lista(i) /= chave) i=i+1 END DO END PROGRAM avaliacao

6. Comandos
Um comando um trecho de cdigo do programa que ao ser executado, atualiza variveis. FORTRAN oferece os seguintes tipos de comandos: atribuio, condicionais, repetio, chamadas de procedimento e desvio incondicional.

6.1.

Comando de Atribuio

O comando de atribuio envolve o uso de um smbolo que designa o comando, uma expresso que produz uma referncia varivel cujo valor ser atualizado e uma expresso que produz como resultado um valor a ser armazenado nessa varivel. Em FORTRAN, o comando de atribuio representado pelo smbolo =. FORTRAN permite apenas um tipo de atribuio: a atribuio simples, onde o operando da esquerda representa uma varivel e o operando da direita representa uma expresso que retorna um valor do mesmo tipo ou de tipos equivalentes, o qual ser atribudo varivel. Exemplos: a=b c = SIN(0.7)*12.7 nome = iniciais//sobrenome l = (a.EQ.b.OR.c.NE.d). .

26

6.2.

Comandos Condicionais

Um comando condicional (tambm conhecido como comando de seleo) permite a especificao de caminhos alternativos para o fluxo de controle do programa. Ele possui um nmero de subcomandos dos quais, exatamente um, escolhido para ser executado. Podem ser de trs tipos: seleo de caminho condicionado, seleo de caminho duplo e seleo de caminhos mltiplos.

6.2.1. Seleo de Caminho Condicionado Esse comando permite que um trecho de programa seja executado se determinada condio satisfeita. Em FORTRAN, o comando IF pode atuar dessa maneira.

6.2.1.1.

Comando IF

a forma mais bsica de execuo condicional; determina a execuo de um nico comando, se uma expresso lgica for verdadeira, caso contrrio a execuo passa para a prxima linha. Sintaxe: IF <(expresso lgica)> <comando> Exemplo: IF (x>10) y=5

6.2.1.2.

Comando IF...THEN...END IF

Determina a execuo de um bloco de comandos se uma condio lgica for verdadeira. Sintaxe: IF <(expresso lgica)> THEN <bloco de comandos> END IF

27

Exemplo: IF( X == 0 ) THEN X=X+1 Y=10**X END IF

6.2.2. Seleo de Caminho Duplo Esse comando permite que exista uma condio para a escolha entre dois trechos alternativos de programa. Em FORTRAN, o comando IF tambm pode atuar dessa maneira.

6.2.2.1.

Comando IF...THEN...ELSE...END IF

Determina a execuo de um bloco de comandos se uma condio lgica for verdadeira ou falsa. No entanto, o bloco de comandos para condio falsa, opcional. Sintaxe: IF <(expresso lgica)> THEN <bloco de comandos> [ELSE <bloco de comandos> ] END IF Exemplo: IF( X == 0 ) THEN X=X+1 Y=10**X ELSE Y=X END IF

28

6.2.3. Seleo de Caminhos Mltiplos Esse comando permite que exista uma escolha entre vrias alternativas de execuo do programa conforme o resultado de uma expresso. Para isso, alm do prprio comando IF (combinado com o uso do comando ELSEIF), outro comando usado em FORTRAN o SELECT-CASE.

6.2.3.1.

Comando IF...THEN...ELSEIF...END IF

Determina a execuo recursiva de vrios comandos IFs dentro da condio lgica do IF principal, atravs do comando ELSEIF. Sintaxe: IF <(expresso lgica)> THEN <bloco de comandos> [ELSEIF <(expresso lgica)> THEN <bloco de comandos> ] [ELSE <bloco de comandos> ] END IF Exemplo: IF( X == 0 ) THEN X=X+1 Y=10**X ELSEIF(X > 0) THEN Y=1/10**X ELSE Y=X END IF Observaes: Podem existir vrios ELSEIF dentro da lgica de um IF;

29

No existe ENDIF para ELSEIF, pois ele est ligado lgica do IF principal; Pode existir um IF dentro do bloco de comandos de um ELSEIF, neste caso, existe o ENDIF;

6.2.3.2.

Comando SELECT-CASE

Construo similar ao IF, muito til quando o valor analisado na expresso lgica possuir diversos valores. Sintaxe: SELECT CASE <(expresso)> CASE <(seleo)> <comando> CASE <(seleo)> <comando> ... CASE DEFAULT <comando> END SELECT Observaes: A seleo de valores nos comandos CASE pode representar uma lista de valores, quando se utiliza os caracteres especiais , e/ou :. o (6, 10, 100): Valores iguais a 6, 10 ou 100 o (10:65,67:98): Valores entre 10 e 65, inclusive, ou entre 67 e 98 o (100:): Valores maiores ou iguais a 100 Inmeros comandos CASE podem existir em um nico SELECT CASE. S existe um CASE DEFAULT em um SELECT CASE.

Exemplo: SELECT CASE (I) CASE (1)

30

PRINT*, I igual a 1 CASE (2:9) PRINT*, I maior ou igual a 2 e menor ou igual a 9 CASE (10:) PRINT*, I maior ou igual a 10 CASE DEFAULT PRINT*, I menor ou igual a 0 END SELECT

6.3.

Comandos de Repetio

Um comando iterativo ou comando de repetio permite a especificao de ciclos no fluxo de controle do programa. Em FORTRAN, o comando de repetio usado o DO. O comando DO permite a execuo repetitiva de um bloco de comandos (loops). O nmero de iteraes pode ser uma constante, varivel ou uma expresso, desde que resultem para um valor constante. FORTRAN aceita loops encadeados (um loop dentro de outro loop).

6.3.1. Comando DO-WHILE O comando DO-WHILE um loop com a lgica do faa-enquanto, ou seja, condiciona a execuo dos comandos dentro do loop, somente se, e enquanto a expresso for verdadeira. A expresso que condiciona o loop tem que vir entre parnteses; quando a expresso for falsa o loop no ser mais executado. Sintaxe: DO WHILE <(expresso lgica)> ... END DO Exemplo: READ *, Salrio=?, salario DO WHILE ( salario .LE. 5000 ) salario=salario*1.05 END DO

31

6.3.2. Comando DO iterativo O comando DO iterativo um loop que possui um nmero fixo de ciclos, determinados pelo programador. Sintaxe: DO <varivel>=<expresso1>, <expresso2> [,<expresso3>] ... END DO Onde: expresso1: Valor inicial expresso2: Valor final expresso3: Valor de incremento Exemplos: DO i=1, 100, 2 ... ! i ser: 1,3,5,7... ... ! 50 iteraes END DO DO j=1, 30 ... ! j ser: 1,2,3...30 ... ! 30 iteraes END DO

6.4.

Chamadas de Procedimento

Chamadas de procedimento tm por objetivo atualizar variveis. Em FORTRAN, usa-se o comando CALL para realizar a chamada de subrotinas. Sua sintaxe : CALL <subrotina> ([parmetro1, parmetro2,...]) Exemplo: CALL ImprimeNumero(10)

32

6.5.

Comandos de Desvio Incondicional

Um comando de desvio incondicional transfere o controle da execuo para um lugar especfico do programa.

6.5.1. Desvio Irrestrito O comando de desvio irrestrito (mais conhecido como goto) confere um grande poder e flexibilidade ao programador. Ele direciona a execuo do programa para uma linha de comando identificada por um nmero. Bastante poderoso, mas deve ser evitado ou utilizado com cuidado em situaes que necessitam uma ao de emergncia. Exemplo: GOTO 50. (desvia a execuo do programa para a linha 50)

6.5.2. Escapes Escapes so usados para permitir uma finalizao diferente da usual em um comando, subprograma ou programa. Comandos de escapes so desvios incondicionais considerados estruturados, uma vez que s permitem a realizao de desvios disciplinados no fluxo de controle do programa. Os comandos de escape oferecidos pelo FORTRAN so: RETURN, STOP, EXIT e CYCLE.

6.5.2.1.

Comando RETURN

Utilizado em subrotinas e funes, este comando transfere a execuo para a ltima linha de um procedimento, ou seja, finaliza a execuo do procedimento e retorna para o programa principal. Exemplo: SUBROUTINE sub(ierror) INTEGER, INTENT(OUT) :: ierror ... ALLOCATE(A(100),STAT=ierror) IF (ierror>0) THEN PRINT*, 'memory fault'

33

RETURN END IF END SUBROUTINE

6.5.2.2.

Comando STOP

Comando que causa a parada imediata da execuo do programa. Exemplo: OPEN(1,FILE='file1.dat', status='OLD', ERR=100) STOP 'Ocorreu um erro na abertura do arquivo!'

6.5.2.3.

Comando EXIT

Loop consiste de um bloco de comandos que so executados ciclicamente, infinitamente. necessrio um mecanismo condicional para sair do loop. O bloco de comandos que executado ciclicamente delimitado pelos comandos DO...END DO e o comando EXIT, que determina a sada do loop. Exemplo: DO i=i+1 IF (i .GT. 100) EXIT PRINT*, I , i END DO

6.5.2.4.

Comando CYCLE

Loop cclico que possui um mecanismo condicional para sair e iniciar o loop novamente. O comando CYCLE determina que a ao retorne para o incio do loop. Exemplo: DO i=i+1 IF (i >= 50 .AND. I <= 59) CYCLE IF (i .GT. 100) EXIT

34

PRINT*, I , i END DO

6.5.3. Excees Uma exceo uma condio provocada por uma situao excepcional a qual requer uma ao especfica imediata. FORTRAN no possui um mecanismo especfico e mais sofisticado para o tratamento de excees, como JAVA, por exemplo. Porm, apresenta alguns comandos para manipulao de excees de comandos de I/O: ERR=, END=, EOR=. Tais comandos so opes de comandos de I/O que funcionam como o comando GOTO, em determinadas situaes de emergncia (erro geral de I/O, erro de fim de arquivo encontrado e erro de fim de registro encontrado), direcionando a soluo do problema para um determinada posio do programa.
o o

O operador END manipula uma condio de fim de arquivo. O operador EOR lida com uma condio de fim de registro para a no continuao da leitura.

O operador ERR lida com todas as condies de erro.

Exemplos: READ (12,70,END=550) READ (UNIT=20, FMT=150, SIZE=X, ADVANCE='NO', EOR=700) A, F, I OPEN (UNIT=10, FILE='FILNAM', STATUS='OLD', ERR=999)

7. Vnculos
Um vnculo, tambm conhecido como amarrao ou binding, pode ser definido como uma associao entre um identificador e a entidade (constante, varivel, funo, procedimento, tipo, etc.) que ele ir representar. Se o vnculo ocorre antes da execuo do programa e permanece inalterado ao longo do mesmo, chamado de esttico. Caso ocorra ou seja alterado durante a execuo do programa, ele dinmico.

35

7.1.

Vinculao de Tipos

Em FORTRAN, assim como a checagem de tipos, a vinculao de tipos esttica, ou seja, o tipo de uma varivel especificado por meio de uma declarao implcita ou explcita. A declarao implcita associa variveis a tipos por convenes padro. Por exemplo, quando um identificador aparece em um programa e no explicitamente declarado fica implicitamente declarado de acordo com a seguinte conveno: se ele for iniciado com uma das letras I, J, K, L, M, ou N, ele ser implicitamente declarado como do tipo INTEGER; caso contrrio, ser do tipo REAL. Se o comando IMPLICIT NONE for usado, tal conveno no poder ser adotada no programa e o compilador acusar um erro. Assim, todas as variveis devero ter seus tipos devidamente declarados de forma explcita, como no exemplo a seguir: PROGRAM teste IMPLICIT NONE REAL :: a,b INTEGER :: c(10) ... END PROGRAM teste

7.2.

Vinculao de Armazenamento

O FORTRAN realiza, na maioria dos casos, a vinculao de armazenamento em tempo de compilao, quando as variveis declaradas so associadas a clulas de memria. Porm, tambm possvel realizar este tipo de vinculao em tempo de execuo, pois o FORTRAN permite ao programador alocar e desalocar clulas de memria de forma explcita, atravs dos comandos ALLOCATE e DEALLOCATE, como pode ser observado no exemplo abaixo, onde declarado um array dinmico cujo tamanho s

36

especificado durante a execuo do programa, atravs de valor informado pelo usurio: INTEGER, ALLOCATABLE :: c(:) INTEGER a READ *,a ALLOCATE(c(a)) DO i=1,a READ *,c(i) PRINT *,c(i) END DO DEALLOCATE (c)

7.3.

Tempo de Vida

O tempo de vida de uma varivel o tempo em que esta vinculada a uma localizao de memria especfica. Com relao ao tempo de vida, pode-se encontrar em FORTRAN trs categorias de variveis: as estticas (aquelas vinculadas a clulas de memria antes que a execuo do programa inicie e assim permanecem at o fim da execuo, as dinmicas na pilha (aquelas cujas vinculaes de

armazenamento criam-se a partir da elaborao de suas instrues de declarao, mas cujos tipos so estaticamente vinculados) e as dinmicas no monte (aquelas cujas clulas de memria so alocadas e desalocadas por instrues explcitas em tempo de execuo). Em suas verses mais antigas, o FORTRAN possua apenas variveis estticas. Nas verses mais atuais, as variveis globais, declaradas no incio dos programas, so estticas. Elas so visveis tambm nos blocos mais internos, como se pode observar no exemplo abaixo, onde a varivel usada dentro da funo f: PROGRAM teste REAL :: c PRINT *, f(c) REAL FUNCTION f(x)

37

REAL :: x f = x*c END FUNCTION f END PROGRAM teste FORTRAN 77 e FORTRAN 90 permitem tambm o uso de variveis dinmicas na pilha (conhecidas como stack-dinmicas) para as variveis locais, mas incluem a instruo SAVE, a qual permite ao programador especificar que algumas ou todas as variveis (aquelas que esto na lista) do subprograma em que SAVE colocado sejam estticas. Exemplo: SUBROUTINE CH REAL, SAVE :: X X=X+1 PRINT *, X END SUBROUTINE CH No exemplo acima, a varivel X declarada como esttica. Assim, toda vez que a subrotina CH chamada o valor de X incrementado (inicia com 0), ou seja, se CH chamada uma vez, o valor exibido 1, se for chamada duas vezes, exibido o valor 2, e assim por diante. Caso a instruo SAVE no fosse usada na declarao de X dentro da subrotina, esta seria stack-dinmica e, desta forma, todas as vezes que CH fosse chamada exibiria o valor 1 na tela. J as variveis dinmicas no monte (conhecidas como heap-dinmicas) so representadas em FORTRAN pelos arrays alocados dinamicamente de forma explcita pelo programador. Exemplo: REAL, ALLOCATABLE :: array(:) INTEGER :: length READ *, length ALLOCATE(array(length))

8. Escopo
O escopo de uma varivel de programa a faixa de instrues na qual esta visvel. Um bloco delimita o escopo de qualquer amarrao que ele possa conter.

38

Em FORTRAN, o escopo das variveis esttico, ou seja, pode ser determinado estaticamente, antes da execuo. FORTRAN adota a estrutura de blocos no aninhada, onde o programa dividido em vrios blocos, todos os subprogramas so separados e cada um atua como um bloco. Assim, a visibilidade dos identificadores o bloco onde foram criados. No exemplo a seguir, a varivel x visvel apenas na funo f, onde foi declarada, ou seja, ela local f. J a varivel a visvel em toda a extenso do programa, pois foi declarada no bloco principal do mesmo, sendo assim, uma varivel global. PROGRAM exemplo REAL :: a READ *, a PRINT *, f REAL FUNCTION f REAL :: x = 2 f=x*a END FUNCTION f END PROGRAM exemplo

9. Declaraes
Uma declarao pode ser entendida como uma construo de um programa a partir da qual os vnculos so definidos. Ela produz amarraes entre identificadores e entidades criadas na prpria definio

9.1.

Declaraes de Variveis

Uma declarao de varivel cria uma varivel e produz um vnculo. A sintaxe da declarao de variveis em FORTRAN : <tipo> [(<opes>,...), <atributos,...> <::>] <variveis> [=valor] Onde:

39

<tipo>: Representa o tipo da varivel. Pode ser omitido, passando a obedecer a conveno mencionada anteriormente. <opes>: Opcional. Pode ser: o LEN=: Usada para definir o tamanho de variveis do tipo CHARACTER (Padro: 1 byte ou 1 caractere). Exemplo: CHARACTER(LEN=10) :: x. o KIND=: Usada para definir a preciso numrica de variveis do tipo INTEGER ou REAL (Padro: 4 bytes ou preciso simples). Exemplo: INTEGER(KIND=4) x.

Observao: A notao utilizando o smbolo *, padro do FORTRAN 77, para indicar o tamanho das variveis, ainda aceito pelo FORTRAN 90. Exemplo: REAL*8 x ou CHARACTER*20 a. Pode ainda ser usada a notao com o tamanho entre parnteses, sem o KIND nem o *. Exemplo: REAL(8) y. <atributos>: Opcional. Pode ser: o PARAMETER: Determina que um valor seja fixado para a varivel. Exemplo: REAL, PARAMETER :: x = 10; o DIMENSION: Determina a que a varivel ir compor um conjunto de dados, em vrias dimenses, com vrios elementos em cada dimenso. Exemplo: INTEGER, DIMENSION (2,2) :: y. o ALLOCATABLE: Determina que o nmero de elementos de uma dimenso da varivel ser alocado durante a execuo do programa. Exemplo: REAL, ALLOCATABLE :: v(10). o SAVE: Determina que o tipo e valor de uma varivel seja global, esttico, visvel por todo o programa. Exemplo: INTEGER, SAVE :: y. o INTENT: Utilizado na declarao de variveis em funes e subrotinas, serve para identificar se a varivel de entrada ou sada. Exemplo: REAL, INTENT(IN) :: x. <::>: No obrigatrio, a menos que se especifique um atributo ou um valor inicial para a varivel. <variveis>: Nome das variveis, separadas por ,.

40

=valor: Valor inicial da varivel (opcional).

Observaes: O tipo DOUBLE PRECISION pode ser substitudo por REAL(8). S existem dois valores para o tipo LOGICAL, que devem vir entre pontos: .true. ou .false. As sintaxes alternativas de declarao de variveis existem devido a necessidade de manter a compatibilidade com as verses mais antigas do FORTRAN.

9.1.1. Inicializao de Variveis Quando um programa executado, o contedo das variveis declaradas normalmente indefinido, mas na maioria das extenses FORTRAN, assume o valor zero. possvel, e recomendado, atribuir um valor inicial a uma varivel e alter-la no decorrer da execuo do programa. possvel declarar uma varivel como sendo o resultado de uma expresso aritmtica entre outras variveis que j foram declaradas e iniciadas, mas com o atributo PARAMETER. O atributo DATA serve para inicializar variveis. Tais variveis contm os valores com as quais foram inicializadas j quando do incio da execuo do bloco no qual foram inicializadas; elas podem ter seus valores modificados subsequentemente. Existem duas formas de sintaxe para esse atributo: <tipo>[,<lista-atributos>] [::] <nome-1> [= <valor-nome-1> [,... [,<nome-m> = <valor-nome-m> ]]

<tipo>[,<lista-atributos>] [::] <nome-1> [,... [,<nome-m> ] ]

DATA <nome-1> [,... [,<nome-m> ] ] / <valor-nome-1> [,... [,<valor-nome-m] ] /

<lista-atributos> ::= <atributo-1>

41

[,... [,<atributo-n>] ]

Exemplo: INTEGER, DIMENSION(4) :: U = (/ 1, 2, 9, 16 /) REAL :: X = 1.0, Y, K, Z = 5.0 DATA Y, K / -1.0, 6.0 / No exemplo, U um arranjo com uma dimenso, com quatro elementos, os quais foram inicializados como U(1)=1, U(2)=2, U(3)=9, U(4)=16; X e Z so variveis escalares, as quais foram inicializadas como X=1.0 e Z=5.0; e Y e K foram declaradas como do tipo REAL, mas foram inicializadas posteriormente com o atributo DATA, recebendo os valores -1.0 e 6.0, respectivamente.

9.2.

Declaraes de Constantes

Constantes simblicas, que no podem mudar de valor durante a execuo de um programa so definidas pelo comando PARAMETER (FORTRAN 77) ou, na declarao da varivel, utilizando o atributo PARAMETER (FORTRAN 90). No comando PARAMETER, a varivel deve ter sido declarada antes de receber o valor constante. Exemplo: INTEGER pre PARAMETER (pre=252) No atributo PARAMETER, a varivel declarada e, ao mesmo tempo, recebe um valor constante. Exemplo: REAL, PARAMETER :: pi=3.14159 Na declarao de constantes caracteres, pode-se utilizar a opo LEN=* em conjunto com o atributo PARAMETER, indicando que o valor constante atribudo a varivel, determinar o tamanho dessa varivel CHARACTER. No exemplo abaixo, n1 possui 5 caracteres e n2 possui 9 caracteres. CHARACTER(LEN=*), PARAMETER :: n1=Paulo, n2=Francisco O atributo PARAMETER determina que o valor da varivel no possa mudar durante a execuo do programa.

42

10.

Abstraes

Uma abstrao pode ser definida como uma entidade que incorpora alguma computao. H dois tipos de abstrao: de funo e de procedimento. Ambas so utilizadas em FORTRAN.

10.1. Abstrao de Procedimento Em FORTRAN, uma subrotina representa a abstrao de procedimento. um programa com parmetros de entrada e sada, comandos de declarao e lgica de execuo, que pode ser chamada de dentro do programa principal com o comando CALL. Sintaxe de chamada: CALL <subrotina> ([parmetro1, parmetro2,...]) As subrotinas no retornam nenhum valor, e tambm a elas podem ser passados qualquer nmero de parmetros inclusive nenhum. Elas podem conter quaisquer tipos de comandos como imprimir resultados, abrir arquivos ou executar clculos. Sintaxe: SUBROUTINE <nome> [(<argumentos>)] <Declarao dos argumentos associados> <Declarao local dos objetos> ... <Comandos executveis> END [SUBROUTINE [<nome>]] Observaes:
o

Uma subrotina enxerga todas as variveis declaradas no programa principal.

o o

Uma subrotina pode incluir chamadas a outras subrotinas. Subrotinas so posicionadas entre o comando CONTAINS e o comando END PROGRAM.

FORTRAN permite execuo recursiva de subrotinas, ou seja, subrotina que chama ela mesma, basta acrescentar o comando RECURSIVE antes de SUBROUTINE.

Exemplo: PROGRAM algo

43

IMPLICIT NONE REAL, DIMENSION(100) :: numeros ... CALL ImprimeNum(numeros) ... CONTAINS SUBROUTINE ImprimeNum(num) REAL, DIMENSION(:), INTENT(IN) :: num PRINT*,Esses so os nmeros, num END SUBROUTINE ImprimeNum END PROGRAM algo Uma subrotina pode ser interna ou externa. No primeiro caso, ela s pode ser invocada no bloco dentro do qual foi definida, aps o comando CONTAINS. No segundo, ela pode existir como um cdigo separado do programa principal e outras subrotinas, ou dentro de um MODULE.

10.2. Abstrao de Funes Uma funo em FORTRAN retorna um valor, que pode ser atribudo a uma varivel ou ser comparado a algum outro valor. Por exemplo se F(X) uma funo que recebe um argumento X e retorna um valor real ao final de sua execuo, podemos atribuir este valor varivel real Y: Y=F(X). A funo similar a uma subrotina, podendo ter vrios parmetros de entrada, comandos de declarao e lgica de execuo, no entanto, retorna apenas um nico valor que armazenado no nome da funo. A funo pode ser executada dentro de outro comando. Exemplo: PRINT*, Resultado da Funo :, f(x) Sintaxe: [<Tipo da Funo>] FUNCTION <nome> [(<argumentos>)] Declarao dos argumentos Comandos executveis Comando de atribuio do resultado END [FUNCTION [<nome>]]

44

Existem funes pr-definidas, como SIN(X), EXP(X), entre outras. Entretanto, o programador tambm pode definir funes que sejam convenientes para seu programa. Isto feito por meio da declarao FUNCTION. Exemplo: CONTAINS REAL FUNCTION f(x) REAL :: x f = x*x END FUNCTION f Observaes:
o

Uma funo pode ser definida na rea de declarao de variveis quando se identifica o tipo da funo e sua definio deve estar aps o comando CONTAINS.

O tipo da funo pode ser especificado quando for definida a funo, ou dentro da definio da funo, pois o nome da funo receber o resultado.

FORTRAN permite execuo recursiva de funes, ou seja, funo que chama ela mesma, basta acrescentar o comando RECURSIVE antes de FUNCTION. A palavra chave return opcional, pode aparecer em qualquer ponto e mais de uma vez. Ela indica que o comando deve retornar ao programa principal ou funo ou subrotina que a chamou.

A funo retornar o valor do ultimo comando do tipo: nome_da_funo = expresso.

10.3. Parmetros Uma abstrao pode ser parametrizada, o que evita a repetio do cdigo para a mesma computao. Um Argumento um valor que pode ser passado para uma abstrao parametrizada. Os parmetros podem ser reais ou formais:

45
o

Parmetro formal: identificador usado na abstrao para denotar um argumento.

Parmetro real: uma expresso passada como argumento e fornecida no momento da invocao da abstrao (chamada da abstrao).

10.3.1.

Argumentos associados ou dummy

A lista de argumentos pode conter variveis, arrays ou ambos que so passados pela chamada do programa para a subrotina. Estas variveis so chamadas dummy arguments desde que a subrotina no aloque nenhuma memria para elas. No exemplo abaixo, os argumentos do programa principal: a e b, esto associados aos argumentos dummy: x e y, da funo F. Se os valores dos argumentos dummy forem alterados durante a execuo da funo, ento os valores associados, tambm sero modificados. Comando: PRINT*, F(a,b) Definio da funo: REAL FUNCTION F(x,y) Exemplo: PROGRAM dummy INTEGER :: a=1 PRINT *, "f: ", f(a) ! Imprime o valor 4 PRINT *, "a: ", a CONTAINS INTEGER FUNCTION f(x) INTEGER :: x x = x+1 f=x END FUNCTION f END PROGRAM dummy ! Imprime o valor 2

46

10.3.2.

Objetos Locais

Na definio do procedimento abaixo a e x so conhecidos como objetos locais, e x, pode ter uma aparncia e tamanho diferente a cada chamada do procedimento. SUBROUTINE madras(i,j) INTEGER, INTENT(IN) :: i,j REAL :: a REAL, DIMENSION(i,j) :: x END SUBROUTINE madras Isso significa que, os objetos locais: So iniciados cada vez que o procedimento chamado; So eliminados quando o procedimento finaliza sua execuo; No mantm seus valores entre chamadas, a no ser que na declarao, sejam iniciados com um determinado valor (REAL :: a=0); No utilizam o mesmo espao de endereamento de memria do programa principal.

10.3.3.

Passagem de parmetros

A passagem de parmetros o processo no qual os parmetros formais assumem seus respectivos valores durante a execuo de um subprograma. Quando uma abstrao chamada, cada parmetro formal vinculado ao argumento correspondente.

10.3.3.1. Mecanismos de passagem de parmetros Em FORTRAN, a passagem de parmetros pode ser feita por valor (que envolve a criao de uma cpia do parmetro real no ambiente local do subprograma) ou por referncia (que envolve a criao de uma referncia ao parmetro real no ambiente local do subprograma).

47

A passagem por valor restrita apenas a constantes e literais da linguagem. Exemplo: SUBROUTINE exp(arg1) INTEGER :: arg1,x x = arg1**2 PRINT *, x END SUBROUTINE exp CALL exp(4) ! Chamada da subrotina

J a passagem por referncia ocorre quando uma varivel (no constante) passada como parmetro do subprograma. Exemplo: SUBROUTINE exp(arg1) INTEGER :: arg1,x x = arg1**2 PRINT *, x END SUBROUTINE exp INTEGER :: a = 2 CALL exp(a) ! Chamada da subrotina

10.3.3.2. Direo de passagem de parmetros A direo da passagem de parmetros pode ser unidirecional de entrada, unidirecional de sada e bidirecional de entrada e sada. Em FORTRAN, a direo da passagem de parmetros representada pelo atributo INTENT. Este comando especifica a inteno de utilizar um ou mais argumentos. Sintaxe: <Tipo> INTENT (especificadores) [ , lista_atributos] :: nome_argumentos Os especificadores podem ser: IN: Especifica que os argumentos sero utilizados somente para fornecer dados para o programa. Os argumentos no devem ser redefinidos durante a execuo do programa. OUT: Especifica que os argumentos sero utilizados para transportar dados de um subprograma para um programa

48

principal. O argumento est indefinido na entrada e deve ser definido antes de ser utilizada no procedimento. INOUT: Especifica que os argumentos podem ser utilizados para fornecer dados para um procedimento e ser transferido para um programa principal. Exemplo: SUBROUTINE ex(arg1,arg2,arg3) REAL, INTENT(IN) :: arg1 INTEGER, INTENT(OUT) :: arg2 CHARACTER, INTENT(INOUT) :: arg3 REAL r r=arg1*ICHAR(arg3) arg2=ANINT(r) arg3=CHAR(MOD(127,arg2)) END SUBROUTINE ex

11.

Mdulos

Um mdulo uma estrutura de um programa em FORTRAN, independente do programa principal, podendo ser compilado e utilizado por diversos programas como se fosse um procedimento externo. O uso de mdulos permite uma melhor estruturao e controle de bibliotecas de subprogramas na linguagem. Normalmente, um mdulo criado quando se percebe que o cdigo pode ser utilizado em diversas situaes diferentes. Um mdulo utilizado no programa principal atravs do comando USE e pode conter: Declarao global de objetos; Diversos procedimentos SUBROUTINE e/ou FUNCTION; Definio de tipos de dados (TYPE);

Sintaxe: MODULE <nome> <Comandos de declarao> [ CONTAINS

49

<Definio de procedimentos>] END [ MODULE [ <nome> ]] Exemplo: MODULE global REAL, SAVE :: x = 2, y=5 END MODULE global Utilizao do mdulo: PROGRAM teste USE global REAL :: a a = x+y PRINT *, a END PROGRAM teste

11.1. Visibilidade Os comandos PRIVATE e PUBLIC especificam a acessibilidade dos elementos contidos no MODULE. Eles podem assumir as formas de comando propriamente dito ou comando de declarao de tipos segundo as seguintes sintaxes: Comando de declarao de tipos: <Tipo> PRIVATE [ , lista_atributos] :: entidade <Tipo> PUBLIC [ , lista_atributos] :: entidade Exemplo: REAL, PRIVATE :: A, B, C Comando: PRIVATE [[::] entidade] PUBLIC [[::] entidade] Exemplo: MODULE SOME_DATA REAL ALL_B PUBLIC ALL_B TYPE RESTRICTED_DATA

50

REAL LOCAL_C DIMENSION LOCAL_C (50) END TYPE RESTRICTED_DATA PRIVATE RESTRICTED_DATA END MODULE Observaes: O atributo PUBLIC indica que uma varivel declarada em um mdulo visvel fora do mdulo, isto , pode ser lida e alterada. Esse atributo default da linguagem; qualquer varivel declarada em um mdulo que no tenha o atributo PRIVATE considerada como PUBLIC. O atributo PRIVATE indica que uma varivel (ou partes de um tipo) visvel apenas dentro de um mdulo. Se um tipo derivado for declarado como PRIVATE, como no exemplo anterior, seus componentes tambm sero privados e no sero acessveis fora do mdulo. Assim, no exemplo acima, embora os dados e as definies do modulo sejam acessveis pois foi declarado como PUBLIC os componentes e as especificaes do tipo derivado no so.

12.

Estratgias de Avaliao

A avaliao dos parmetros reais em FORTRAN obedece a estratgia Eager Evaluation, onde a mesma realizada uma nica vez, no local da chamada, e o valor resultante substitudo para cada ocorrncia do parmetro formal na abstrao. Exemplo: PROGRAM teste REAL :: a=4,b=5 PRINT *, f(g(a))

CONTAINS REAL FUNCTION f(x) REAL :: x

51

f = x*x END FUNCTION f REAL FUNCTION g(y) REAL :: y g = y*b b = b+1 END FUNCTION g END PROGRAM teste No exemplo acima, na avaliao de f(g(a)), g ser avaliada antes de f. Assim, o parmetro passado para f ser o valor produzido como resultado de g. Ou seja, com a=4 e b=5, g(a) = a*b = 20, f(g(a)) = f(20) = 20*20 = 400. Caso a estratgia fosse do tipo Normal-order, por exemplo, a avaliao de g seria feita no corpo de f. Como o valor de b incrementado durante a execuo de g, desta forma teramos valores distintos para as duas chamadas de g. Ou seja, f(g(a)) = g(a)*g(a) = (a*b) * g(a) = 20 * (a*b) = 20 * 24 = 480.

13.

Polimorfismo

Polimorfismo se refere a possibilidade de se criar cdigo capaz de operar sobre valores de tipos diferentes. Assim como Pascal, por exemplo, FORTRAN possui um sistema de tipos monomrfico, ou seja, no qual todas as constantes, variveis e funes devem ser definidos com um tipo especfico. Entretanto, tambm da mesma forma que o Pascal, FORTRAN no puramente monomrfica. Em FORTRAN, o polimorfismo pode ser implementado atravs de coero ou sobrecarga.

13.1. Coero Coero significa converso implcita de tipos. No caso do FORTRAN, a coero realizada entre variveis dos tipos numricos (INTEGER, REAL e COMPLEX). Exemplo: INTEGER*4 :: a=-3, b=5

52

REAL*8 :: x=2.5, y=-0.9 COMPLEX :: c=(4.,.3) x = a+b y = x*a a = b+x b = x-y c=x+y No exemplo acima, todas as operaes so permitidas

independentemente do tamanho do conjunto de valores dos tipos. Assim, podese perder informao quando efetuada uma operao em que o resultado armazenado numa varivel de tipo menor.

13.2. Sobrecarga Uma sobrecarga ocorre quando um mesmo identificador (ou operador) usado para designar duas ou mais operaes distintas. aceitvel quando o uso do identificador (ou operador) no ambguo, isto , quando a operao apropriada pode ser identificada usando-se apenas as informaes disponveis a respeito dos tipos dos operandos. Em FORTRAN, subprogramas pr-definidos, tais como READ e PRINT aceitam valores de vrios tipos em sua chamada. Alm disso, operadores aritmticos podem atuar sobre tipos no-numricos, como os arrays, e tambm podem ser sobrecarregados. Exemplo: INTEGER a CHARACTER*20 c REAL :: x(2) = (/1.6,2.7/) REAL :: y(2) = (/-3.0,2.5/) REAL :: z(2) z = x+y READ *,a READ *,c PRINT *,a

53

PRINT *,c DO i=1,2 PRINT *,z(i) END DO Operadores tambm podem ser sobrecarregados atravs da criao de uma nova definio para estes por parte do usurio.

13.3. Operadores definidos pelo usurio Em FORTRAN, possvel definir novos operadores (por exemplo, a soluo de um sistema de equaes lineares pode ser expresso por um operador) e, tambm, efetuar sobrecarga de operadores j existentes (por exemplo, efetuar a operao equivalente soma sobre dados de um tipo definido pelo usurio). possvel, tambm, definir como feita uma atribuio de um valor a uma varivel. Essa definies so feitas utilizando o bloco INTERFACE...END INTERFACE. Nesse caso, deve-se fazer uso das palavras-chave OPERATOR (<smbolo>) ou ASSIGNMENT (=). No entanto, existem regras especficas que um subprograma deve atender para que definir um operador, as quais so as seguintes: Definio de operador: o subprograma s pode ser uma funo externa, com apenas um ou dois argumentos no opcionais, declarados com o atributo INTENT(IN); o resultado no pode ser uma string de tamanho assumido; um operador que tenha um s argumento dito unrio; um operador com dois argumentos dito binrio. Definio de atribuio: o subprograma s pode ser um subrotina externa, com apenas dois argumentos no opcionais; o primeiro deve ser declarado com o atributo INTENT(OUT) ou

INTENT(INOUT); o segundo deve ser declarado com o atributo INTENT(IN). Deve-se salientar que esses subprogramas tambm podem ser invocados da forma usual de invocao de subprogramas, porm, quando for

54

encontrado <smbolo> numa expresso ou uma atribuio, eles sero invocados, desde que os tipos dos operadores sejam idnticos aos declarados nos subprogramas. Exemplo: PROGRAM TESTE

INTERFACE OPERATOR (+) INTEGER FUNCTION SOMA(A,B) RESULT C INTEGER INTENT(IN) :: A,B END FUNCTION SOMA END INTERFACE

INTERFACE ASSIGNMENT(=) SUBROUTINE ATRIBUI(A,B) INTEGER INTENT(OUT) :: A INTEGER INTENT(IN) :: B END SUBROUTINE ATRIBUI END INTERFACE

INTEGER :: I,J REAL :: U U=-4.0 I=1 J=-1 K=I+J

END PROGRAM TESTE

SUBROUTINE ATRIBUI(A,B) INTEGER INTENT(OUT) :: A INTEGER INTENT(IN) :: B A=ABS(B) END SUBROUTINE ATRIBUI INTEGER FUNCTION SOMA(A,B) RESULT C

55

INTEGER INTENT(IN) :: A,B C=A*B+A+B END FUNCTION SOMA No exemplo acima, um nico arquivo, contendo o cdigo fonte do programa TESTE e de dois subprogramas externos, ATRIBUI e SOMA, define um operador de atribuio e uma sobrecarga ao operador predefinido para a adio. Note que a atribuio de um valor do tipo INTEGER a uma varivel do mesmo tipo ser sempre feita, nesse exemplo, tomando-se a parte absoluta do valor. Alm disso, a soma feita de acordo com o definido na funo SOMA. Pode-se observar tambm que a atribuio U=-4.0 feita de acordo com a definio padro da linguagem, j que o tipo da varivel U e da expresso do lado direito do operador de atribuio no INTEGER.

14.

Efeitos Colaterais

Um efeito colateral pode ser definido como uma mudana adicional promovida no estado do programa durante a avaliao de determinada expresso ou a execuo de um comando ou subprograma. Um exemplo de efeito colateral existente em FORTRAN o chamado efeito colateral funcional, o qual ocorre quando uma funo modifica seus parmetros ou uma varivel global. Como em FORTRAN quando uma varivel global (que no uma constante) passada como parmetro de uma funo, a passagem feita por referncia, sendo assim, pode ocorrer o efeito colateral desta modificar o valor da varivel, podendo provocar mudana no resultado esperado para a avaliao de uma expresso. Exemplo: PROGRAM colateral INTEGER :: b = 2 PRINT *, b + g(b) CONTAINS INTEGER FUNCTION g(y) INTEGER :: y y= y + 1

56

g=y*2 END FUNCTION g END PROGRAM colateral No exemplo acima, o resultado esperado pela expresso b+g(b) 8. Porm, como a passagem de parmetros da funo feita por referncia, ao ser alterado o valor de y em g, tambm alterado o valor de b. Assim, a expresso retorna o valor 9 como resultado.

15.

Critrios Gerais de Avaliao

15.1. Legibilidade Avalia se a linguagem oferece fcil leitura e entendimento de seus programas. De um modo geral, os programas em FORTRAN so bem estruturados, com blocos bem definidos e comandos bastante intuitivos. Mas tambm possvel observar alguns problemas como a grande quantidade de recursos bsicos, algumas excees regra e as interpretaes possveis diferentes para um mesmo recurso. Os principais fatores que influenciam na legibilidade so apresentados nas sees 15.1.1 a 15.1.4.

15.1.1.

Simplicidade Global

Afeta fortemente a legibilidade, como tambm a redigibilidade da linguagem. Devido ao nmero de verses e ao fato dos novos recursos implementados em cada uma delas ser incorporado linguagem sem que funcionalidades antigas fossem retiradas, FORTRAN tornou-se uma linguagem bastante extensa em termos de componentes bsicos, o que a deixou tambm mais complexa. Alguns fatores afetam significativamente a simplicidade de uma linguagem, tais como:

57

Grande nmero de componentes bsicos: Torna a linguagem mais difcil de ser aprendida. FORTRAN possui atualmente um nmero bastante grande de componentes, o que dificulta sua aprendizagem.

Multiplicidade de recursos: Mais de uma maneira de realizar uma operao em particular tambm complica a linguagem.

FORTRAN apresenta alguns casos de multiplicidade de recursos, como, por exemplo, a declarao de variveis, que pode ser feita de diversas maneiras diferentes. Sobrecarga de operadores: Ocorre quando um nico smbolo tem mais de um significado. Em FORTRAN, pode-se citar como exemplo de sobrecarga de operador o fato de que o smbolo + usado tanto para realizar soma de valores de variveis numricas quanto para somar os valores dos ndices correspondentes de um array. Alm disso, permitido ao usurio criar novos operadores ou sobrecarregue um j existente, implementando uma nova funcionalidade.

15.1.2.

Ortogonalidade

Avalia a capacidade da linguagem de programao permitir ao programador combinar seus conceitos bsicos sem que sejam produzidos efeitos anmalos nessa combinao. Regras bem definidas na linguagem afetam positivamente a

ortogonalidade, como por exemplo, em FORTRAN, as declaraes de variveis devem ser realizadas sempre antes de qualquer outra instruo do programa. Outro aspecto positivo o uso de combinao de primitivas. Ponteiros em FORTRAN podem apontar para qualquer tipo de dado e operadores aritmticos podem ser usados por todos os tipos numricos, como tambm por combinaes entre eles. A ortogonalidade tambm influenciada pela quantidade de excees a regra presentes na linguagem. FORTRAN apresenta alguns problemas nesse sentido como:

58

Funes podem retornar tipos estruturados, como registros, mas no arrays; A associatividade de operadores da esquerda para direita, exceto no caso do operador **; Passagem de parmetros feita por referncia, mas passagem por valor permitida para constantes e literais.

15.1.3.

Tipos de Dados e Estruturas

A presena de facilidades adequadas para definir tipos e estruturas de dados em uma linguagem outro auxlio significativo para a legibilidade. Assim como em Pascal, por exemplo, FORTRAN oferece a possibilidade de criar registros, o que traz uma melhoria importante para a representao de determinadas estruturas, d flexibilidade e afeta positivamente a legibilidade.

15.1.4.

Sintaxe

A sintaxe ou a forma dos elementos de uma linguagem tem um efeito significativo sobre a legibilidade dos programas. Dentre as opes do projeto sinttico da linguagem que afetam a legibilidade, destacam-se: Formas identificadoras: Restringir os identificadores a tamanhos pequenos dificulta a legibilidade. At a verso 77 s era possvel definir nomes de variveis com at 6 caracteres, problema solucionado nas verses subsequentes, sendo permitido

atualmente nomes com at 31 caracteres. Palavras especiais: A legibilidade fortemente influenciada pelas formas das palavras especiais de uma linguagem. Em FORTRAN, o uso de comandos de fechamento como END IF, END DO e END PROGRAM torna o escopo de cada grupo de instrues mais claro. Porm, permitido o uso das palavras especiais como nomes de variveis, de forma que o aparecimento de tais palavras num programa pode conotar ou no algo especial, tornando-os mais confusos.

59

Forma e significado: Instrues projetadas a fim de que sua aparncia indique, pelo menos em parte, sua finalidade, um auxlio evidente para a legibilidade. De modo geral, as instrues do FORTRAN so bastante intuitivas em relao sua finalidade, como por exemplo, FUNCTION (indica declarao de uma funo), DIMENSION (indica a especificao da dimenso de um array), POINTER (indica que a varivel do tipo apontador) e ALLOCATABLE (indica que a varivel pode ser alocada dinamicamente).

15.2. Capacidade de Escrita Avalia o quanto a linguagem oferece de facilidade para criar programas para um domnio de problema escolhido. A capacidade de escrita deve ser considerada no domnio de problema alvo da linguagem. FORTRAN destina-se ao desenvolvimento de aplicaes cientficas, sendo assim, apesar de possuir problemas no que diz respeito sua simplicidade e sua ortogonalidade, como tambm na sua expressividade, a sua capacidade de abstrao, atravs da modularizao de cdigo, traz um importante benefcio para a escrita voltada para tal domnio. Os fatores que influenciam diretamente a capacidade de escrita so apresentados nas sees 15.2.1 a 15.2.3.

15.2.1.

Simplicidade e Ortogonalidade

A simplicidade e a ortogonalidade afetam tambm a capacidade de escrita de uma linguagem. O grande nmero de construes presente em FORTRAN afeta negativamente esse aspecto, pois pode causar problemas como o uso inadequado de alguns recursos e o desuso de outros que podem ser mais elegantes ou eficientes (ou ambos) do que aqueles usados, sobretudo pela possvel falta de familiaridade do programador com tais recursos, pela sua

60

insero na linguagem ou modificao ao longo das diferentes verses da mesma.

15.2.2.

Suporte para abstrao

Avalia se a linguagem possui a capacidade de definir e, depois, de usar estruturas ou operaes complicadas de uma maneira que permita ignorar muitos dos detalhes. FORTRAN oferece suporte para abstrao de forma bastante efetiva atravs da modularizao do cdigo, com o uso de estruturas como MODULE, SUBROUTINE e FUNCTION, como tambm de registros.

15.2.3.

Expressividade

Avalia se a linguagem oferece uma variedade de formas convenientes de especificar computaes. FORTRAN apresenta poucos recursos conhecidos como acar sinttico, ou seja, aquelas que tornam mais simples a escrita de determinada computao. Um exemplo desse tipo de recurso o uso do DO iterativo, que facilita a escrita de laos de contagem. Porm, este pode ser considerado um exemplo isolado na linguagem.

15.3. Confiabilidade Avalia se a linguagem promove o projeto e implementao de sistemas computacionais confiveis atravs do uso de conceitos que maximizem a deteco automtica de erros e no estimulem a ocorrncia de erros. FORTRAN oferece alguns recursos nesse sentido, mas peca por permitir brechas perigosas, o que afeta diretamente esse aspecto,

comprometendo-o. Alguns fatores influenciam significativamente a confiabilidade. Eles so apresentados nas sees 15.3.1 a 15.3.4.

61

15.3.1.

Verificao de Tipos

Verificar tipos simplesmente testar se existem erros de tipo em determinado programa, ou pelo compilador ou durante a execuo do programa. um fator importante na confiabilidade da linguagem. A verificao de tipos em FORTRAN realizada estaticamente, em tempo de compilao, assim previne-se a maioria dos erros e se ganha eficincia na execuo. Porm, h uma brecha na linguagem no caso do uso do comando EQUIVALENCE, o qual no realiza nenhuma verificao de tipos, permitindo assim a ocorrncia de erros de tipo durante a execuo.

15.3.2.

Manipulao de Excees

A capacidade de um programa de interceptar erros em tempo de execuo, pr em prtica medidas corretivas e, depois, prosseguir um grande auxlio para a confiabilidade. FORTRAN no oferece esse tipo de tratamento, apesar de utilizar alguns comandos que manipulam alguns erros em casos especficos.

15.3.3.

Apelidos

Possuir dois ou mais mtodos (ou nomes) distintos para fazer referncia mesma clula de memria amplamente aceito como um conceito perigoso em uma linguagem de programao. FORTRAN permite apelidos pelo uso de ponteiros e tambm pelo comando EQUIVALENCE, que faz com que duas variveis compartilhem a mesma clula de memria, inclusive no caso de serem de tipos distintos, o que tambm bastante perigoso.

15.3.4.

Legibilidade e Capacidade de Escrita

Tanto a legibilidade quanto a capacidade de escrita influenciam a confiabilidade. Em FORTRAN, numa viso inicial pode-se ter a impresso de uma boa legibilidade, mas, com o uso de recursos mais complexos e pela

62

infinidade de comandos bsicos, dentre outros problemas destacados nas sees 15.1.1 a 15.1.4, este aspecto bastante comprometido na linguagem. A capacidade de escrita em FORTRAN tambm apresenta alguns problemas, muito por no possuir uma alta expressividade e pelos seus problemas de simplicidade e ortogonalidade.

15.4. Custo Avalia o custo financeiro necessrio para o uso da linguagem, para a aquisio das ferramentas de desenvolvimento (tais como, editores de programas, compiladores, depuradores) na plataforma na qual ser

desenvolvida a aplicao e para uso da aplicao (tal como, por exemplo, se existe custo para executar a aplicao utilizando uma mquina virtual). O custo final de uma linguagem funo de muitas das suas caractersticas, tais como: Treinamento de programadores para usar a linguagem: uma funo da simplicidade e da ortogonalidade. Os problemas relativos a esses fatores em FORTRAN fazem com que o custo de treinamento aumente, sobretudo pela diversidade de recursos adicionados pelas novas verses. Custo para escrever programas na linguagem: uma funo da capacidade de escrita. Novamente a simplicidade e a

ortogonalidade contribuem para o aumento do custo em FORTRAN, juntamente com a baixa expressividade e a falta de ambientes de programao. Custo de compilao: Reduzido ao longo do tempo com o desenvolvimento de novos compiladores, mais eficientes. Custo de execuo: Relacionado ao projeto da linguagem. Como o foco do FORTRAN foi a busca pela eficincia, o custo de execuo baixo, o que pode ser evidenciado pela verificao esttica de tipos.

63

Custo do sistema de implementao da linguagem: Pode ser considerado como baixo no FORTRAN, pela disponibilidade gratuita de compiladores e demais ferramentas de apoio.

Confiabilidade: Influenciado pelo risco de falhas. A verificao de tipos esttica (apesar de haver uma brecha) contribui

positivamente nesse critrio, mas, a confiabilidade do FORTRAN influenciada negativamente pelos problemas de simplicidade e ortogonalidade, uso de apelidos e palavras especiais como nomes e no tratamento de excees. Manuteno: Inclui tanto correes como modificaes para adicionar novas capacidades. Depende principalmente da

legibilidade. Em FORTRAN, os problemas de legibilidade podem levar a custos mais altos de manuteno, apesar de no serem considerados to elevados quando comparados a outras linguagens, como ADA, por exemplo. Dentre todos os fatores apresentados, os mais influentes no custo final so a confiabilidade, a manuteno (afetada pela legibilidade) e o desenvolvimento de programas (afetado pela capacidade de escrita).

16.

Concluses

Pode-se observar que FORTRAN possui problemas nos trs principais aspectos, muito pelo fato de ser uma linguagem antiga, com diversas verses, nas quais foram adicionados recursos variados, sem que houvesse a retirada de outros, o que tornou a linguagem mais difcil tanto de ler quanto de escrever. O uso de alguns recursos considerados perigosos tambm afeta a confiabilidade. O projeto da linguagem sempre foi focado na eficincia, sobretudo na execuo de clculos pesados. A incorporao de recursos refletiu a sua evoluo em relao s novas linguagens que surgiram. Porm, a preocupao continuou a mesma, e aspectos como manuteno de cdigo e confiabilidade foram deixados em segundo plano. Assim, nas suas verses atuais, pode-se considerar FORTRAN como uma linguagem de custo relativamente alto

64

comparado com o custo de outras linguagens mais novas, apesar de possuir um foco diferente da maioria delas.

Referncias

SEBESTA, Robert W. Conceitos de Linguagens de Programao. 5. ed. So Paulo: Artmed, 2003. CUNHA, Rudnei D. da. Programao Cientfica em Fortran 95. Porto Alegre: Edio do autor, 2010. KUSEL, Ricardo Almeida de M. Introduo ao Fortran90. Campinas: Centro Nacional de Processamento de Alto Desempenho, 2008. Disponvel em: <http://www.cenapad.unicamp.br/servicos/treinamentos/apostilas/fortran_aposti la.pdf>. Acesso em: 30 mai. 2011. VAREJO, Flvio. Linguagens de Programao: conceitos e tcnicas. 1. ed. So Paulo: Campus, 2004. CRISTO, Helder P. Programao em Linguagem Fortran 90. Belo Horizonte, 2003. Disponvel em: <http://www.inf.ufes.br/~thomas/fortran/tutorials/helder/for tran.pdf>. Acesso em: 30 mai. 2011. SUN MICROSYSTEMS. Fortran Programming Guide. Disponvel em: <http://www.lncc.br/sta/manuais/Fortran_Prog_Guide.pdf>. Acesso em: 30 mai. 2011. DURHAM UNIVERSITY. An Introduction to Programming in Fortran 90. Disponvel em: <http://www.dur.ac.uk/resources/its/info/guides/138fortran90.pdf >. Acesso em: 30 mai. 2011.