sábado, 25 de abril de 2009

:= Pascal EBNF =:

Programs and Blocks

program
program-heading block "."
program-heading
program identifier "(" identifier-list ")" ";"
block
declaration-part statement-part
declaration-part
[ label-declaration-part ]
[ constant-definition-part ]
[ type-definition-part ]
[ variable-declaration-part ]
procedure-and-function-declaration-part
label-declaration-part
label label { "," label } ";"
constant-definition-part
const constant-definition ";" { constant-definition ";" }
constant-definition
identifier "=" constant
type-definition-part
type type-definition ";" { type-definition ";" }
type-definition
identifier "=" type
variable-declaration-part
var variable-declaration ";" { variable-declaration ";" }
variable-declaration
identifier-list ":" type
procedure-and-function-declaration-part
{ (procedure-declaration | function-declaration) ";" }
procedure-declaration
procedure-heading ";" procedure-body |
procedure-heading ";" directive |
procedure-identification ";" procedure-body
procedure-body
block
function-declaration
function-heading ";" function-body |
function-heading ";" directive |
function-identification ";" function-body
function-body
block
directive
forward | compiler-defined-directives
statement-part
begin statement-sequence end

Procedure and Function Definitions

procedure-heading
procedure identifier [ formal-parameter-list ]
function-heading
function identifier [ formal-parameter-list ] ":" result-type
result-type
type-identifier
procedure-identification
procedure procedure-identifier
function-identification
function function-identifier
formal-parameter-list
"(" formal-parameter-section { ";" formal-parameter-section } ")"
formal-parameter-section
value-parameter-section |
variable-parameter-section |
procedure-parameter-section |
function-parameter-section
value-parameter-section
identifier-list ":" parameter-type
variable-parameter-section
var identifier-list ":" parameter-type
procedure-parameter-section
procedure-heading
function-parameter-section
function-heading
parameter-type
type-identifier | conformant-array-schema
conformant-array-schema
packed-conformant-array-schema |
unpacked-conformant-array-schema
packed-conformant-array-schema
packed array "[ " bound-specification " ]" of type-idnetifier
unpacked-conformant-array-schema
array "[ " bound-specification { ";" bound-specification } " ]"
of (type-identifier | conformant-array-schema)
bound-specification
identifier ".." identifier ":" ordinal-type-identifier
ordinal-type-identifier
type-identifier

Statements

statement-sequence
statement { ";" statement }
statement
[ label ":" ] (simple-statement | structured-statement)
simple-statement
[ assignment-statement | procedure-statement | goto-statement ]
assignment-statement
(variable | function-identifier) ":=" expression
procedure-statement
procedure-identifier [ actual-parameter-list ]
goto-statement
goto label
structured-statement
compound-statement | repetitive-statement | conditional-statement | with-statement
compound-statement
begin statement-sequence end
repetitive-statement
while-statement | repeat-statement | for-statement
while-statement
while expression do statement
repeat-statement
repeat statement-sequence until expression
for-statement
for variable-identifier ":=" initial-expression (to | downto) final-expression do statement
initial-expression
expression
final-expression
expression
conditional-statement
if-statement | case-statement
if-statement
if expression then statement [ else statement ]
case-statement
case expression of
case-limb { ";" case-limb } [ ";" ]
end
case-limb
case-label-list ":" statement
case-label-list
constant { "," constant }
with-statement
with record-variable { "," record-variable } do statement
actual-parameter-list
"(" actual-parameter { "," actual-parameter } ")"
actual-parameter
actual-value | actual-variable | actual-procedure | actual-function
actual-value
expression
actual-procedure
procedure-identifier
actual-function
function-identifier

Expressions

expression
simple-expression [ relational-operator simple-expression ]
simple-expression
[ sign ] term { addition-operator term }
term
factor { multiplication-operator factor }
factor
variable | number | string | set | nil | constant-identifier | bound-identifier | function-designator | "(" expression ")" | not factor
relational-operator
"=" | "<>" | "<" | "<=" | ">" | ">=" | "in"
addition-operator
"+" | "-" | or
multiplication-operator
"*" | "/" | div | mod | and
variable
entire-variable | component-variable | referenced-variable
entire-variable
variable-identifier | field-identifier
component-variable
indexed-variable | field-designator | file-buffer
indexed-variable
array-variable "[ " expression-list " ]"
field-designator
record-variable "." field-identifier
set
"[ " element-list " ]"
element-list
[ expression { "," expression } ]
function-designator
function-identifier [ actual-parameter-list ]
file-buffer
file-variable "^"

Types

type
simple-type | structured-type | pointer-type | type-identifier
simple-type
subrange-type | enumerated-type
enumerated-type
"(" identifier-list ")"
subrange-type
lower-bound ".." upper-bound
lower-bound
constant
upper-bound
constant
structured-type
[ packed ] unpacked-structured-type
unpacked-structured-type
array-type | record-type | set-type | file-type
array-type
array "[ " index-type { "," index-type } " ]" of element-type
index-type
simple-type
element-type
type
record-type
record field-list end
set-type
set of base-type
base-type
type
file-type
file of file-component-type
file-component-type
type
pointer-type
"^" type-identifier

Record Fields

field-list
[ (fixed-part [ ";" variant-part ] | variant-part) [ ";" ] ]
fixed-part
record-section { ";" record-section }
record-section
identifier-list ":" type
variant-part
case tag-field type-identifier of variant { ";" variant }
tag-field
[ identifier ":" ]
variant
case-label-list ":" "(" field-list ")"

Input/Output

output-list
output-value { "," output-value }
output-value
expression [ ";" field-width [ ":" fraction-length ] ]
field-width
expression
fraction-length
expression

Variable and Identifier Categories

identifier
letter { letter | digit }
file-variable
variable
referenced-variable
pointer-variable "^"
record-variable
variable
pointer-variable
variable
actual-variable
variable
array-variable
variable
field-identifier
identifier
constant-identifier
identifier
variable-identifier
identifier
type-identifier
identifier
procedure-identifier
identifier
function-identifier
identifier
bound-identifier
identifier

Low Level Definitions

variable-list
variable { "," variable }
identifier-list
identifier { "," identifier }
expression-list
expression { "," expression }
number
integer-number | real-number
integer-number
digit-sequence
real-number
digit-sequence "." [ digit-sequence ] [ scale-factor ] |
digit-sequence scale-factor
scale-factor
("E" | "e") [ sign ] digit-sequence
unsigned-digit-sequence
digit { digit }
digit-sequence
[ sign ] unsigned-digit-sequence
sign
"+" | "-"
letter
"A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J" | "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" | "S" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z" | "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z"
digit
"0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"
string
"'" string-character { string-character } "'"
string-character
any-character-except-quote | "''"
label
integer-number
constant
[ sign ] (constant-identifier | number) | string

:= Pascal =:

Definição de Tipos

Possibilita q declaração de seus próprios tipos de dados. Uma vez criado o novo tipo, pode-se declarar quantas variáveis quiser do tipo criado. Usa-se a palavra reservada Type para declarar um tipo de dado definido pelo programador.

A seção Type é declarada antes da seção Var, pois na seção Var pode-se declarar as variáveis que pertencem aos tipos padrão e aos tipos definidos pelo usuário.

type valor = real;
var salario : valor;

Vetores (Arrays unidimensionais)

O tipo vetor permite armazenar mais de um valor em uma mesma variável. Esta é dividida em posições, e cada posição pode receber um valor diferente, porém do mesmo tipo.

type
Vetor = array[1..100] of Real
var
Notas : Vetor;

Matrizes (Arrays bidimendionais)

Igual nas características do vetor, porém, possui mais de duas dimensões, ou seja, possui linhas e colunas.

type
Matriz = array[1..100, 1..100] of Real { onde: array[linha, coluna] }
var
Notas : Matriz;

Record (Registro)

Em um registro poderemos utilizar uma estrutura que agrupe várias informações, que podem ser de tipos de dados diferentes. Por esta razão, este tipo de dado é considerado heterogêneo. Em Pascal, os tipos registro devem ser declarados ou atribuídos antes das definições das variáveis, pois é muito comum ocorrer à necessidade de se declarar uma variável com o tipo de registro atribuído. Um tipo registro é declarado em Pascal com a instrução type em conjunto com a instrução record.

type
Pessoa = record
                    Nome, Endereco : string [35];
                    Fone : string [20]; 
                    Sexo : char;
                    Idade : byte;
                    Salario : real;
end;
var
funcionario, aluno : Pessoa;

Uma forma fácil de acessar os campos para preenchê-los é usando o comando with:

with data do
begin
       write(‘Digite um dia: ‘);
readln(dia);

:= Pascal =:

Comandos de entrada e saída

Os comandos de entrada permitem que o usuário informe dados ao programa, e os comandos de saída permitem que o programa mostre dados ao usuário.

Entrada: Read ou Realn à Read(<variável>), Readln(<variável>);

Saída: Write ou Writeln à Write(<variável>), Write(“texto”, <variável>), Writeln(<variável>), Writeln(“texto”, <variável>);

Estrutura de decisão

Comando if...then...else: if (se) realiza um teste de condicional que permite a implementação de desvios de execução dos comandos, dependendo da condição especificada.

Sintaxe: if <condição>
              then
                  <codigo1>
               else
                   <codigo2 >;

Comando case: é um comando condicional de múltipla escolha. Ao contrário do if, que permite somente a escolha da condição verdadeira ou falsa, case permite especificar duas ou mais escolhas.

Sintaxe: case: <expessão> of
             Opção1 : <código1>;
             Opção2 : <código2>;
             Opçãon : <códigon>;

Estrutura de Repetição

Estrutura While ... do: é uma estrutura de repetição condicional, também chamado de laço condicional ou loops, que se repete um conjunto de instruções enquanto uma dada condição for satisfeita (verdadeira).

Sintaxe: while <condição> do
                Instruções;

Estrutura for ... do: também é uma estrutura de repetição, porém contado. Ao invés de especificarmos uma condição que deve ser satisfeita para que o laço seja executado, o for possui uma variável de controle (contador) própria, que é incrementada automaticamente até que ela seja maior que o valor final estipulado.

Sintaxe: for variável := valor_inicial to valor_final do
                  instruções;

Estrutura repeat ... until: também é um laço de condicional como o while e for, porém existem uma pequena diferença: as instruções contidas dentro do repeat são executadas pelo menos uma vez, pois a condição é testada somente no final do repeat, no until;

Sintaxe: repeat
                Instruções;
             until <condição>

Sub-rotinas

O pascal permite a utilização de dois tipos de sub-rotinas: procedure (procedimento) e function (função). A diferença entre os dois tipos é que a função sempre retorna um valor após o seu processamento, enquanto o procedimento pode ou não retornar um valor.

Procedure: é uma estrutura de programa autônoma que está incluída num programa em Pascal. Nele podem ser colocados todos os elementos da linguagem Pascal, como se fosse um programa completo; isso é feito através de sua declaração. Um procedimento pode ser referido escrevendo simplesmente o seu nome seguido de uma lista opcional de parâmetros. Quando um procedimento é referenciado, o controle de execução do programa é automaticamente transferido para o início do procedimento. As instruções de execução dentro do procedimento são então executadas, tendo em conta quaisquer declarações especiais que sejam únicas para o procedimento. Quando todas as instruções de execução tiverem sido executadas, o controle passa automaticamente para a instrução imediatamente a seguir à da chamada do procedimento.

procedure <nome> ( parâmetros)
{ declaração de variáveis – locais }
  begin { início principal do procedimento }
         <instruções>
   end;

Function: Uma function, assim com uma procedure, é um bloco de programa, ao qual são válidas todas as regras estudadas de programação. Sua diferença em relação a uma procedure está no fato de retornar sempre um valor.

Function <nome> ( parâmentros) : <tipo>;
{ declaração de variáveis - locais }
begin { início principal da função }
     <instruções>
end;