lia - linguagem interpretada de algoritmos

Rafael Martins – rafael84@gmail.com

Instituto Superior de Tecnologia em Ciência da Computação

Petrópolis, Outubro de 2007

O Algoritmo Organização das idéias em passos:

Bem estruturados

Concisos

Coerentes com o resultado esperado

Disciplina base para o estudo das linguagens de programação

Possibilita avaliar os pormenores do programa a ser desenvolvido

O Algoritmo Construído e validado através de lápis e papel:

Estimula o raciocínio, porém torna o aprendizado

mais difícil.

Impossibilita a visualização dos resultados de

algoritmos complexos.

Construído e executado no computador:

Facilita e agiliza o aprendizado.

Algoritmos e Programas

Programação: codificação de um algoritmo, segundo uma linguagem de programação específica

Formas de representar um algoritmo:

Fluxogramas

Linguagens naturais

Pseudo-linguagens

Algoritmos e Programas Fluxograma:

É um tipo de diagrama

Representa um processo

Permite visualizar os caminhos (fluxos) e as etapas de processamento

Mais intuitivo que uma descrição textual

Linguagem natural:

Linguagem convencional, escrita e/ou falada

Algoritmos e ProgramasPseudo-linguagem:

Linguagem textual

Pseudocódigo:

Uma das formas mais utilizadas atualmente

Instruções descritas de forma imperativa

Sintaxe semelhante à do Português

Conceitos Linguagem de máquina:

Linguagem que os computadores podem compreender

Linguagem de baixo nível:

Utiliza números binários, hexadecimais, alguns símbolos e letras

Próxima da linguagem de máquina

Linguagens de alto nível:

Utilizam notações matemáticas e grupos de palavras

Próxima da linguagem natural

Conceitos

Código fonte: programa escrito em linguagem de programação

Código objeto: programa escrito em linguagem de máquina

Tradutor: transforma o código fonte em código objeto

Ligador (Linker): programa ou módulo que faz a ligação entre o

programa e as bibliotecas relacionadas

Conceitos

Programação estruturada:

Simples

Amplamente utilizada

Segmentação da solução em sub-rotinas

Linguagem de Máquina

Totalmente expressa em forma binária (0s e 1s)

É a única linguagem diretamente reconhecida pelo

computador

Exige grande conhecimento dos dispositivos de

máquina

Linguagem de Máquina

Extremamente trabalhosa

Difícil aprendizado

Pouco expressiva para a maioria das pessoas

Linguagens de Programação

Criadas para tornar a programação mais acessível

Utilizadas para a codificação de algoritmos

Indispensáveis para o desenvolvimento de software comercial

Tradução e Execução de Programas

Estratégias dos tradutores

Compilação

Interpretação

Híbrida

A Solução LIA LIA – Linguagem Interpretada de Algoritmos:

Ferramenta que objetiva facilitar o aprendizado do processo de construção de algoritmos e programas de computador

Aperfeiçoamento de programadores experientes

O pacote LIA:

Linguagem

Interpretador

Ambiente de Desenvolvimento Integrado (ADI)

Manual

Exemplos

Backus-Naur Form

Definições Modelo para a representação de gramáticas

Proposto por John Backus e aprimorado por Peter Naur

Baseia-se em regras de produção

Utilizado para expressar gramáticas livres de contexto

EBNF

NotaçõesNotação Representação Descrição

Produções ::= Separa o lado esquerdo do lado direito de uma produção

Terminais “terminal” Texto delimitado por aspas

Não-terminais <não-terminal> Texto delimitado pelos símbolos < e >

Operadores | Operador lógico “OU”

[...] Opcional

{...} Opcional com repetição (zero ou mais)

{...}+ Repetição (uma ou mais)

(...|...|...) Escolha múltipla

Exemplo de gramática em EBNF<programa> ::= “begin” <comandos> “end”

<comandos> ::= <comando> {";" <comando>}

<comando> ::= <ident> "=" <expressão>

<ident> ::= <letra> {<letra> | <digito>}

<letra> ::= A | B | C | ... |Z

<digito> ::= 0 | 1 | 2 | ... | 9

<expressão> ::= <termo> [ (+|-) <expressão> ]

<termo> ::= <fator> [ (*|/) <termo> ]

<fator> ::= <identificador>

| "(" <expressão> ")"

Histórico, hierarquia, projeto e construção

Início Os primeiros compiladores:

Datam em torno do ano 1950

Consumiam muito tempo de desenvolvimento

FORTRAN (FORmula TRANslator):

Primeira linguagem de alto nível

Desenvolvida entre 1954 e 1957

Hierarquia das Linguagens

Fases de um compilador

Análise

Análise Léxica

Análise Sintática

Análise Semântica

Síntese

Geração e Otimização de código

Interpretação de código

Fases de um compilador

Fase de Análise

Definição Realizada a análise do código fonte:

Caracteres Lexemas

Lexemas Tokens

Geralmente implementada como uma função ou classe:

Código fonte só é lido uma vez

Exemplo Como exemplo, a análise léxica da instrução de atribuição:

Horas <- Minutos / 60;

Agrupa os caracteres nos seguinte tokens: Identificador Horas

Símbolo de atribuição

Identificador Minutos

Símbolo de divisão

Número 60

Fase de Análise

Definição

Agrupa tokens em frases gramaticais

A frase gramatical é uma regra da sintaxe da linguagem

Funções

Assegurar que a sintaxe da linguagem é atendida

Reunir os tokens em estruturas básicas para geração de instruções

Fase de Análise

Conceitos

A especificação da sintaxe:

Apenas define os padrões de formação das instruções

Não determina o significado coletivo de cada construção

Exemplo: “Fulano comeu cinco litros de roupa.”

Definição

Processo de validação das estruturas sintáticas no contexto geral do programa fonte

Regras semânticas não possuem um modelo representação amplamente difundido

Funções

Análise de escopo

Múltiplas declarações de uma mesma variável

Compatibilidade entre tipos

Coerência entre declaração e uso de identificadores

Correlação entre parâmetros formais e atuais

Técnicas utilizadas

Resumo

Implementação sem o auxilio de ferramentas de apoio

Programação Orientada a Objetos (POO)

Etapas de compilação e interpretação estão em uma DLL

Funções ativadas por uma interface gráfica

Diagrama – O Interpretador LIA

Regras em EBNF e algoritmos exemplo

Elementos BásicosNúm. Regras

1 <id> ::= "_" | <letra> { "_" | <letra> | <digito> }

2 <letra> ::= "a" | "b" | ... | "z" | "A" | "B" | ... | "Z"

3 <digito> ::= "0" | "1" | ... | "9"

4 <num_int> ::= { <digito> }+

5 <num_real> ::= <num_int> "." <num_int>

6 <caracteres> ::= """ { <caractere ASCII> } """

7 <const> ::=<num_int> | <num_real> | "verdadeiro" | "falso" |<caracteres>

8 <tipo> ::= "inteiro" | "real" | "caractere" | "logico"

ExpressõesNúm. Regras

9 <expressao> ::= <log_rel>

10 <log_rel> ::=<soma_sub> [ ("="|">"|">="|"<"|"<="|"<>"|"e"|"ou") <soma_sub>]

11 <soma_sub> ::= <mult_div> [ ("+"|"-") <mult_div> ]

12 <mult_div> ::= <unario> [ ("*"|"/"|"mod"|"div") <unario> ]

13 <unario> ::= [ ("nao"|"+"|"-") ] <parenteses>

14 <parenteses> ::="(" <log_rel> ")" | <id> [<elem_vet>|<params_atuais>] |<const>

15 <elem_vet> ::= "[" <expressoes> "]"

16 <expressoes> ::= <expressao> ["," <expressao>]

17 <params_atuais> ::= "(" <expressoes> ")"

Declarações

Núm. Regra

18 <decs> ::=

[ { <vars_dec>

| <consts_dec>

| <func_dec>

| <proc_dec> } ]

Algoritmo decs;

Procedimento SubRotina;

Constantes

A = 1; B = 2; C = 3;

Constante

N = “XYZ”;

Procedimento Aninhado;

Variavel AA: real;

Inicio

AA <- A + B + C;

Fim;

Inicio { SubRotina}

Aninhado;

Fim;

Inicio { decs }

SubRotina;

Fim.

Declaração de VariáveisNúm. Regras

19 <vars_dec> ::="variavel" <var_dec> ";"

| "variaveis" { <var_dec> }+ ";"

20 <var_dec> ::= <id> {"," <id>} ":" [<vet_def>] <tipo> ";"

21 <vet_def> ::= ( "matriz" | "vetor" ) "[" <faixas> "]" "de"

22 <faixas> ::= { <faixa> }+

23 <faixa> ::= <num_int> ":" <num_int>

algoritmo MultiDeclaracoes;

variaveis nota1,nota2,media: real; nome: caractere;

inicio

escreva("Digite o seu nome: ", nome); leia(nome);

escreva("Entre com Nota 1: "); leia(nota1);

escreva("Entre com Nota 2: "); leia(nota2);

media <- (nota1 + nota2) / 2;

escrevaln("Aluno: ", nome, " - Média: ", media);

fim.

Declaração de ConstantesNúm. Regras

24 <consts_dec> ::= "constante" <const_dec> ";” | "constantes" { <const_dec> }+ ";"

25 <const_dec> ::= <id> "=" <expressao> ";"

algoritmo MultiDeclaracoes2;

constantes APROVADO = 7.0; RECUPERACAO = 4.0;

variaveis nota1,nota2,media: real; nome: caractere;

inicio

escreva("Digite o seu nome: ", nome); leia(nome);

escreva("Entre com Nota 1: "); leia(nota1);

escreva("Entre com Nota 2: "); leia(nota2);

media <- (nota1 + nota2) / 2;

se media >= APROVADO entao

escrevaln("Aluno: ", nome, " aprovado.");

senao

se media >= RECUPERACAO então

escrevaln("Aluno: ", nome, " em recuperação.");

senao

escrevaln("Aluno: ", nome, " reprovado.");

fim_se;

fim_se;

fim.

Declaração de FunçõesNúm. Regras

26 <func_dec> ::=

"funcao" [<param_formais>] ":" <tipo> ";"

<decs>

"inicio"

<cmds>

"fim" ";"27 <param_formais> ::= "(" {<param_formal>}+ ")"28 <param_formal> ::= ["ref"] <id> {"," <id>} ":" <tipo> ";"

algoritmo testeFunc;

funcao PI: real;

inicio

retorno <- 3.14159;

fim;

variavel C, r: real;

inicio

r <- 3;

C <- 2 * PI * r;

escrevaln(C);

fim.

Declaração de ProcedimentosNúm. Regras

29 <proc_dec> ::= "procedimento" <params_formais> ";"

<decs>

"inicio"

<cmds>

"fim" ";"

algoritmo testeProc;

procedimento Imprimir(nome,valor: caractere);

inicio

escrevaln(nome, “: ”, valor);

fim;

inicio

Imprimir(“LIA”, “Linguagem Interpretada de Algoritmos”);

fim.

ComandosNúm. Regras

30 <cmds> ::= { <cmd> ";" }31 <cmd> ::= <cmd_atrib>

| <cmd_se>

| <cmd_para>

| <cmd_enq>

| <cmd_rep>

| <cmd_esc>

| <cmd_escreva>

| <cmd_escrevaln>

| <cmd_leia>

| <sub_rot>

Comando de AtribuiçãoNúm. Regra

32 <cmd_atrib> ::= <id> [<elem_vet>] "<-" <expressao>

algoritmo Atribuicoes;

variaveis

i: inteiro;

r: real;

l: logico;

c: caractere;

inicio

r <- 3.14159;

r <- r * r;

escrevaLn(r);

l <- verdadeiro ou falso;

escrevaLn(l);

l <- 2 > 1;

escrevaLn(l);

c <- "Como é fácil fazer uma atribuição de valor!";

escrevaLn(c);

fim.

Comando SeNúm. Regra

33 <cmd_se> ::= "se" <expressao> "entao"

<cmds>

["senao" <cmds>]

"fim_se"

algoritmo teste_condicional;

inicio

se 2 > 1 entao

escrevaln("Esta instrução será escrita na tela.");

escrevaln("E esta também.");

senão

escrevaln("Já esta será ignorada.");

fim_se;

fim.

Comando ParaNúm. Regras

34 <cmd_para> ::= "para" <id> "de" <expressao> "ate" <expressao> "faca"

<cmds>

"fim_para"

algoritmo instrucao_para_10;

variavel

i: inteiro;

inicio

para i de 1 ate 10 faca

escrevaln("Valor de i é: ", i);

fim_para;

fim.

Comando EnquantoNúm. Regra

35 <cmd_enq> ::= "enquanto" <expressao> "faca"

<cmds>

"fim_enquanto"

algoritmo testeValor;

variavel

val: inteiro;

inicio

escreva("Digite 9 para sair: ");

leia(val);

enquanto val <> 9 faca

escreva("Digite 9 para sair: ");

leia(val);

fim_enquanto;

fim.

Comando RepitaNúm. Regra

36 <cmd_rep> ::= "repita"

<cmds>

"ate" <expressao>

algoritmo testeValor;

variavel

val: inteiro;

inicio

repita

escreva("Digite 9 para sair: ");

leia(val);

ate val = 9;

fim.

Comando EscolhaNúm. Regras

37 <cmd_esc> ::= "escolha" <expressao>

<casos>

["senao" <cmds>]

"fim_escolha"38 <casos> ::= {<caso>}+

39 <caso> ::= "caso" <expressoes> ":" <cmds> "fim_caso" ";"

algoritmo Calculadora;

variaveis

op1,op2: inteiro;

operacao: caractere;

inicio

escreva("Operando 1: "); leia(op1);

escreva("Operando 2: "); leia(op2);

escreva("Operacao: "); leia(operacao);

escolha operacao

caso "+","somar": escreva(op1 + op2); fim_caso;

caso "-","subtrair": escreva(op1 - op2); fim_caso;

caso "*","multiplicar": escreva(op1 * op2); fim_caso;

caso "/","dividir": escreva(op1 / op2); fim_caso;

fim_escolha;

fim.

Comando Escreva / EscrevaLnNúm. Regras

40 <cmd_escreva> ::= "escreva" [ "(" <expressões> ")" ]41 <cmd_escrevaln> ::= "escrevaln" [ "(" <expressões> ")" ]

algoritmo Tabuada;

variaveis

t: inteiro;

i: inteiro;

v: vetor[1:10] de inteiro;

inicio

para t de 1 ate 10 faca

escrevaln ("-------------");

escrevaln ("Tabuada de ", t);

escrevaln ("-------------");

para i de 1 ate 10 faca

v[i] <- i * t;

escrevaln(t, " x ", i , " = ", v[i]);

fim_para;

escrevaln;

fim_para;

fim.

Comando LeiaNúm. Regra

42 <cmd_leia> ::= "leia" "(" <var> { "," <var> } ")"43 <var> ::= <id> [<elem_vet>]

algoritmo teste_leia;

variaveis

n1,n2: inteiro;

soma: inteiro;

inicio

escrevaln("Calculo de Soma");

escrevaln;

escreva("Entre com o primeiro número: ");

leia(n1);

escreva("Entre com o segundo número: ");

leia(n2);

soma <- n1 + n2;

escreva("Resultado: ", soma);

fim.

Chamadas à sub-rotinasNúm. Regra

17 <params_atuais> ::= "(“ <expressoes> ")"44 <sub_rot> ::= <id> [<param_atuais>]

Algoritmo rotinas;

Procedimento A;

Inicio

Fim;

Procedimento B(i: inteiro);

Inicio

Fim;

Inicio

A;

B(1);

Fim.

AlgoritmoNúm. Regras

45 <algoritmo> ::= "algoritmo" <id> ";"

<decs>

"inicio"

<cmds>

"fim" "."

Para a Linguagem LIA

Definições

Tipos especiais de variáveis

Capacidade para armazenar mais um valor ao mesmo tempo

Para a linguagem LIA, vetor é sinônimo de matriz

Multidimensionais

Possuem um tipo e um nome pré-definidos

Acesso aos elementos

Através do índice do elemento entre COLCHETES, logo após o nome do vetor:

Nome do vetor [ índice do elemento ]

No modelo acima, índice do elemento é qualquer expressão cujo valor seja um número inteiro.

Exemplosnotas[1] <- 6.5;

notas[2] <- 7.5;

media <- notas[1] + notas[2];

dias[1+2] <- "Terça-feira";

alunos[1] <- "Ana";

alunos[2] <- "Beto";

reprovados[1] <- 2;

escrevaLn("Aluno reprovado: ", alunos[ reprovados[1] ]);

Declaração

VARIAVEL nome: VETOR [ dimensão1, dimensão2, ... , dimensãoN ] : TIPO;

VARIAVEIS nomes: VETOR [ dimensão1, dimensão2, ... , dimensãoN ] : TIPO;

VARIAVEL nome: MATRIZ [ dimensão1, dimensão2,... , dimensãoN ] : TIPO ;

VARIAVEIS nomes: MATRIZ [ dimensão1, dimensão2,... , dimensãoN ] : TIPO;

Dimensões

Limite Inferior : Limite Superior

Exemploalgoritmo Media;

variaveis

notas: vetor[1:3] de real;

soma, media: real;

inicio

notas[1] <- 5.5;

notas[2] <- 6.0;

notas[3] <- 8.0;

soma <- notas[1] + notas[2] + notas[3];

media <- soma / 3;

escreva(media);

fim.

Ambiente de Desenvolvimento Integrado

Apresentação Interface gráfica para facilitar a manipulação de algoritmos

na linguagem LIA

Principais funcionalidades

Editor de textos com suporte à coloração do código fonte;

Execução passo a passo (instrução a instrução) de algoritmos;

Inspeção de símbolos do algoritmo em estrutura de árvore;

Funcionalidades

Exportação de entradas e saídas de dados para arquivo

Controle de ativação de sub-rotinas representada em estrutura de pilha numerada

Especificação de pontos de parada em instruções

Funcionalidades

Possibilidade de manter vários arquivos abertos simultaneamente

Histórico dos últimos arquivos abertos

Manual integrado da linguagem LIA

Tela Principal

Manipulando algoritmos LIA Manipulando diversos arquivos simultaneamente

Módulo de Entrada e Saída Meio pelo qual as rotinas de entrada e saída de dados coletam e

exibem dados ao usuário.

Assemelha-se a uma janela de comandos tipo DOS, normalmente chamada de console.

Registra histórico de leituras e escritas realizadas pelo algoritmo

Na leitura de valor o nome da variável é exibido na barra horizontal azul

Módulo de Entrada e Saída

Módulo Inspetor de Símbolos Instrumento de depuração

Permite visualizar automaticamente o conteúdo de cada variável modificada ao longo do processo de execução do algoritmo

Monitora Variáveis simples

Vetores/matrizes

Constantes

Dados organizados em estrutura de árvore, por escopo

Módulo Inspetor de Símbolos

Módulo Pilha de Ativação

Registra as ativações de sub-rotinas em uma lista numerada e organizada em forma de pilha

Exibe o nome e os valores dos parâmetros

Módulo Pilha de Ativação

Utilizando o ADI para a linguagem LIA

Funcionalidades do Depurador Execução passo a passo

Pausar e abortar a execução

Acompanhar todo o processo de execução, instrução a instrução

Visualizar o conteúdo das variáveis

Observar a pilha de ativação das sub-rotinas

Inspecionar a entrada e a saída de dados

Tratamento de Erros

Apresenta mensagens que auxiliam a correção

Sempre que possível, o cursor do teclado é movido para a coluna e a linha onde está o erro

Modos de ExecuçãoFuncionalidade ou Característica Padrão Rápido

Abortar execução Sim SimExecução passo a passo Sim NãoInspeção de símbolos Sim NãoPilha de ativação Sim Não

Eficiência – Velocidade de execução Não Sim

Baixa utilização de memória e processador Não Sim

Possibilidade de salvar o histórico de E/S Sim Sim

Pontos de parada Sim Não

Conclusão O propósito do autor/desenvolvedor é disseminar a

solução LIA que foi construída:

Linguagem

Interpretador

Ambiente de Desenvolvimento Integrado

Sempre que possível, funcionalidades e eventuais correções serão incluídas em novas versões