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;

sexta-feira, 24 de abril de 2009

:= Pascal =:

Operadores

Pascal possui 3 tipos de operadores aritméticos, relacionais e lógicos.
Operadores aritméticos: o resultado das expressões aritméticas são sempre numéricos. Os operadores para as expressões aritméticas são:

Operador

Exemplo

Descrição

Adição ( + )

2 + 2

Definida para operandos inteiros e reais. Se um ou os dois operandos forem reais, o resultado será real; se os dois forem inteiros, o resultado será inteiro.

Concatenação ( + )

Valor1 + “val”

Definida sobre operandos caracteres e strings. O resultado será string.

Subtração ( - )

5 – 3

Definida para operandos inteiros e reais. Se um ou os dois operandos forem reais, o resultado será real; se os dois forem inteiros, o resultado será inteiro.

Multiplicação ( * )

X * Z

Funciona da mesma maneira que a adição e subtração

Divisão ( / )

Y / X

Este operador de divisão só pode ser utilizado quando um dos operandos for real. O resultado também será real.

Divisão (div)

B div 2

Este operador de divisão só pode ser utilizado quando um dos operandos for inteiro.

Resto da divisão inteira ( mod )

A mod 2

Este operador retorna o resto da divisão.

Operadores relacionais: os operadores relacionais permitem comparações entre valores ou expressões de tipos equivalentes, retornando sempre valores lógicos. São eles:

Operador

Exemplo

Descrição

Maior que ( > )

X > Y

Retorna true se X for Maior que Y e false caso contrário.

Menor que ( < )

X < Y

Retorna true se X for Menor que Y e false caso contrário.

Igual a ( = )

X = Y

Retorna true se X for igual a Y e false caso contrário

Diferente de ( <> )

X <> Y

Retorna true se X for diferente de Y e false caso contrário.

Operadores lógicos: os operadores lógicos compõem expressões lógicas, que também retornam valores lógicos (true ou false). Os operadores lógicos são:

a) AND – e
b) OR – ou
c) NOT – não

O resultado de cada expressão que envolve estes operadores é dado pela tabela-verdade de cada um deles. Em pascal as expressões são consideradas a seguinte ordem de precedência:

1º) funções e parênteses
2º) not
3º) *, /, div, mod, and
4º) +, -, or
< 5º) <>, =, >, <, >=, <=



<anterior Próximo>

:= Pascal =:

Definição

Pascal é uma linguagem de programação estruturada na década de 70 pelo suíço Niklaus Wirth, professor da Faculdade Politécnica de Zurique, na Suíça, que colocou este nome em homenagem ao matemático Blaise Pascal.
Pascal é muito usada para fins acadêmicos, pois é uma linguagem de alto nível muito próxima da linguagem escrita.

Palavras reservadas

Palavra

Descrição

And

Operador (booleano)

Array

Tipo

Begin

Marcador de bloco

Case

Instrução

class

Tipo

Const

Declaração ou diretiva (parâmetros)

Div

Operador

Do

Instrução

Downto

Instrução (parte do for)

Else

Instrução (parte do if ou case)

End

Marcador de bloco

File

Tipo

For

Instrução

Function

Declaração

Goto

Instrução

If

Instrução

In

Operador (conjunto) - estrutura de projeto

Label

Declaração

Mod

Operador (matemático)

Nil

Valor

Not

Operador (booleano)

Of

Instrução (parte do case)

Or

Operador (booleano)

Packed

Diretiva (registro)

Procedure

Declaração

Program

Estrutura de programa

Record

Tipo

Repeat

Instrução

Set

Tipo

String

Tipo

Then

Instrução (parte do if)

To

Instrução (parte do for)

Type

Declaração

Until

Instrução

Var

Declaração

While

Instrução

With

Instrução

Proximo>