<programa> ::= [<declaracoes_globais>] function main { <bloco> }
<declaracoes_globais> ::= { <declaracao_constante_global> | <declaracao_funcao> |
<declaracao_procedimento> }
<declaracao_constante_global> ::= const <identificador> : <tipo> = <expressao> ;
<declaracao_funcao> ::= function <identificador> ( [<parametros>] ) : <tipo>
{ <bloco_funcao> }
<declaracao_procedimento> ::= procedure <identificador> ( [<parametros>] )
{ <bloco> }
<parametros> ::= <identificador> {, <identificador>}
<bloco> ::= { <comando> { <comando> } }
<bloco_funcao> ::= { <comando> { <comando> } <retorno> } // O bloco de uma função
termina obrigatoriamente com um return
<comando> ::= <declaracao_variavel> | <atribuicao> | <expressao> | <if> | <laco> |
<imprimir> | <retorno> | <procedimento> | <parar> | <continuar>
<retorno> ::= return <expressao> ; // Alterado para tornar o retorno obrigatório
com uma expressão
<declaracao_variavel> ::= var <lista_identificadores> : <tipo> [= <expressao>] ;
<lista_identificadores> ::= <identificador> {, <identificador>}
<tipo> ::= inteiro | booleano | string
<if> ::= if (<expressao>) { <bloco> } [ { else if (<expressao>) { <bloco> } } ]
[ else { <bloco> } ]
<laco> ::= <while> | <for>
<while> ::= while (<expressao>) { <bloco> }
<for> ::= for ( <atribuicao> ; <expressao> ; <atualizacao> ) { <bloco> }
<imprimir> ::= print ( <expressao> ) ;
<atualizacao> ::= <identificador> = <expressao>
<atribuicao> ::= <identificador> = <expressao> ;
<expressao> ::= <expressao logica> [<operador relacional> <expressao logica>]
<expressao logica> ::= <expressao aritmetica> { (&& | ||) <expressao aritmetica> }
<expressao aritmetica> ::= [ + | - ] <termo> { ( + | - ) <termo> }
<termo> ::= <fator> { ( * | // ) <fator> }
<fator> ::= (<variavel> | <numero> | <chamada de função> | (<expressao>) |
verdadeiro | falso | ! <fator>)
<operador relacional> ::= (== | != | < | <= | > | >=)
<variavel> ::= <identificador>
<chamada de função> ::= <identificador>
<booleano> ::= verdadeiro | falso
<string_literal> ::= " <letra> { <letra> | <digito> } "
<identificador> ::= <letra> { <letra> | <digito> | _ }
<numero> ::= <digito> { <digito> }
<digito> ::= (0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9)
<letra> ::= (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)
// Declarações globais
const LIMITE : inteiro = 100;
const MENSAGEM : string = "Bem-vindo ao programa";
const PI: inteiro = 3
// Função que calcula a área de um círculo
function calcularArea(raio: inteiro) : inteiro {
var area : inteiro = PI * raio * raio; // Supondo 3 como uma aproximação para
PI
return area;
}
// Procedimento que exibe uma mensagem de boas-vindas
procedure exibirMensagem() {
printf(MENSAGEM);
}
// Procedimento que exibe a área de um círculo com o raio fornecido
procedure exibirArea(raio: inteiro) {
var area : inteiro = calcularArea(raio);
printf("A área do círculo é: ");
printf(area);
}
// Função principal (main)
function main {
// Declaração de variáveis locais
var raio : inteiro = 5;
var resultado : inteiro;
var ativo : booleano = verdadeiro;
// Exibindo uma mensagem de boas-vindas
exibirMensagem();
// Atribuição de uma expressão a uma variável
resultado = calcularArea(raio);
// Condicional simples para verificar se o resultado está dentro do limite
if (resultado < LIMITE) {
printf("A área está dentro do limite.");
} else {
printf("A área ultrapassa o limite.");
}
// Loop para exibir a área de círculos de raio 1 a 3
var i : inteiro = 1;
while (i <= 3) {
exibirArea(i);
i = i + 1;
}
}
<programa>: Define que um programa consiste em declarações globais (funções e/ou
classes) seguidas do main, onde o código principal é executado.
<declaracoes_globais>: Permite a definição de funções e variaveis fora do main.
<bloco>: Define que o bloco principal de código no main (ou em uma função) é
delimitado por { } e pode conter uma série de comandos.
<comando>: Lista os diferentes tipos de comandos que podem ser usados dentro de um
bloco.
// Constantes globais
const PI : inteiro = 3;
const MENSAGEM : string = "Bem-vindo ao programa!";
// Funções globais
function soma(a: inteiro, b: inteiro): inteiro {
return a + b;
}
function exibirMensagem() {
console.log(MENSAGEM);
}
// Programa principal
function main {
var resultado : inteiro = soma(10, 20);
console.log("Resultado da soma:", resultado);
exibirMensagem();
console.log("Valor de PI:", PI);
}
