GALS

Gerador de Analisadores Lxicos e Sintticos

Introduo Opes Opes Gerais Opes do Analisador Lxico Opes do Analisador Sinttico Definio de Aspectos Lxicos Definies Regulares Tokens Expresses Regulares Exemplo Definio de Aspectos Sintticos Smbolos Terminais (Tokens) Smbolos No-Terminais Produes Restries Exemplo Definio de Aspectos Semnticos e de Gerao de Cdigo Exemplo Utilizao do Cdigo Gerado Analisador Lxico Analisador Sinttico Analisador Semntico Tabelas de Erros Tratamento de Excees

Introduo
GALS um ambiente para a gerao de analisadores lxicos e sintticos, desenvolvido por Carlos Eduardo Gesser como trabalho de concluso de curso do Curso de Bacharelado em Cincias da Computao, da Universidade Federal de Santa Catarina, sendo desenvolvido sob a orientao do Prof. Olinto Jos Varela Furtado. Esta ferramenta pode ser obtida em http://gals.sourceforge.net. GALS uma ferramenta de Software Livre. Seu cdigo fonte liberado sob a Licena Publica GNU. (http://www.gnu.org). Topo

Opes
As opes permitem configurar aspectos dos analisadores gerados.

Opes Gerais
Gerar Analisador Lxico Analisador Sinttico Analisadores Lxico e Sinttico Esta opo permite definir o modo de trabalho do gerador. Escolhendo a opo Analisador Lxico, ser gerado apenas um analisador lxico, sendo pedido que o usurio entre com a definies dos aspctos lxicos. A opo Analisador Sinttico gera um analisador sinttico completo, e analisadores lxico e semntico vazios, que devem ser implementados pelo usurio. Neste modo o usurio entra apenas com os aspectos sintticos. A ltima opo faz com que gera gerado um analisador lxico em conjunto com um sinttico. Ser gerado ainda um analisador semantico vazio, para a implementao do usurio. Linguagem Java C++ Delphi Est opo permite ao usurio escolher a linguagem em que o analisador ser gerado. Classes Analisador Lxico Analisador Sinttico Analisador Semntico Package/Namespace Estas so opes para que o usurio possa ter controle sobre os nomes das classes geradas. Para Java e C++ pode-se especificar a package e o namespace respectivamente onde sero geradas as classes (o que recomendavel). Topo

Opes do Analisador Lxico

Forma de Entrada Stream String

Pode-se escolher de onde o analisador lxico gerado ir obter seu fluxo de caracteres: de uma classe de stream (geralmente utilizada para se ler diretamente de um arquivo) ou de uma string contendo toda a entrada a ser processada (que pode ser obtida de um componente de interface grfica, por exemplo). Implementao do Autmata Tabela Completa Tabela Comprimida Especfica O analisador lxico implementado sobre um autmato finito. Esta opo permite escolher sua forma de implementao. As duas primeiras opes geram um analisador genrico, com uma tabela de transies. A primeira opo gera uma tabela simples, que permite o acesso mais rpido, a custa de espao (na grande maioria dos casos a tabela gerada bem esparsa). A segunda opo gera uma tabela comprimida, mais eficiente em termos de espao (em casos de tabelas esparsas), mas de desempenho inferior em tempo de busca. A ltima opo gera um analisador especfico, com as transies programadas diratamente dentro do analisador lxico, o que pode serar um analisador bem eficiente. A desvantagem desta opo que qualquer alteraco na especificao lxica requer a recompilao do analisador, enquanto que nas outras opes basta recompilar o arquivo de constantes. Diferencias maiscula/minscula em casos especiais O analisador gerado sempre passa os tokens ao sinttico (que passa ao semntico) exatamente como eles estavam no texto original, sem qualquer converso entre maisculas e minsculas. Se se pretende gerar um analisador que no faa diferenciao entre maisculas minsculas para os identificadores, esta capacidade deve ser programada em nvel semntico. Ento para que serve esta opo? Esta opo tem a ver com casos especiais, utilizados (geralmente) para a definio de palavras chave. Com esta opo desabilitada, tanto Begin quanto begin quanto BEGIN seriam reconhecidos como o mesmo token, caso se tenha um caso especial de identificador com a representao igual a begin. Topo

Opes do Analisador Sinttico

Classe do Analisador Sinttico Descendente Recursivo LL(1)

SLR(1) LALR(1) LR(1) Cannico Esta opo controla o tipo do analisador seinttico que ser gerado. Algumas classes impem restries sobre a gramtica que aceitam, que devem ser observadas quando se for descrev-la Topo

Definio dos Aspectos Lxicos

Os aspectos lxicos de uma especificao GALS so definidos pela declarao dos Tokens e pela declarao de Definies Regulares. Os Tokens definem quais construes lxicas sero aceitas pelo Scanner e o valor lxico de cada uma destas construes. As Definies Regulares atuam como expresses auxiliares para a definio de Tokens. O Analisador Lxico gerado utilizar as expresses regulares dos token para a criao de um Autmato Finito com mltiplos estados finais, cada um deles correspondendo a um dos Tokens declarados. Topo

Definies Regulares
Uma definio sempre segue a forma:
[identificador] : [expresso regular]

Cada linha do campo de definies pode conter apenas uma definio regular. As definies aqui declaradas podero ser utilizadas em outras expresses regulares, utilizando seu identificador entre { e }. Topo

Tokens
Antes de se mostrar como so declarados os Tokens preciso se dar uma pequena explicao sobre o funcionamento do analisador lxico. O analisador gerado funciona simulando um autmato finito, rodando em cima de uma tabela de transies. O analisador verifica o prximo caractere da entrada e o estado atual do autmato (inicialmente zero) e move o autmato para seu prximo estado. Se eventualmente o autmato chegar a um estado final, sempre correspondente a um token, ele ainda no pode dar a anlise deste token como concluda, pois preciso tentar identificar a seqncia de caracteres mais longa possvel (um analisador para Pascal no pode identificar o token ":" no momento que encontrar este caractere, ele precisa continuar, pois pode ser que o token seja ":="). Assim, o analisador somente para quando no consegue mais prosseguir na tabela de

transies. Se durante este processo ele encontrou algum token, ele produz o token correspondente ao ltimo estado final alcanado (a seqncia mais longa de caracteres). Se nenhum token foi encontrado ento um erro lxico gerado. Existem diversos meio para a definio de Tokens, cada um deles mais adequado a um tipo de Token. Como nas Definies Regulares, aqui tambm s permitida a declarao de um token por linha. Definindo Token a partir do identificador Pode-se declarar um token apenas declarando um identificador para ele. Esta a forma mais simples de se declarar um token, porm a menos flexvel. Pode-se utilizar duas formas de identificadores: Identificadores Normais Qualquer sequncia de caracteres entre aspas (") Um token declarado desta forma ir gerar um autmato finito que identifica o prprio identificador, ou seja, sempre que o analisador encontrar a sequncia de caracteres relativa ao identificador ele produzir o Token correspondente. Por exemplo: begin identificaria begin, e "!=" identificaria !=. Definindo Token a partir de uma Expresso Regular Esta a forma mais genrica de se definir um token. Seu caso mais geral idntico declarao de uma Definio Regular:
[identificador] : [expresso regular]

Sempre que o analisador identificar a expresso regular ele produzir o token correspondente. Pode-se especificar para um token uma segunda expresso regular, chamada neste caso de contexto.
[identificador] : [expresso regular] ^ [expresso de contexto]

Se um contexto for especificado, sempre que o token vier a ser identificado, o analisador tenta analisar a expresso de contexto. Se a expresso no puder ser encontrada aps o token o analisador considera este token como invlido (como se chegasse a um ponto sem transio possvel na tabela de transies). Esta construo pode ser entendida como: somente identifique este token se, depois dele, for possvel identificar a expresso de contexto. O contexto analisado, porm no consumido pelo analisador lxico. Podem existir casos em que ao ser encontrado um erro (nenhuma transio possvel), este deve ser reportado de qualquer forma, mesmo que durante a anlise deste token tenha-se encontrado outros tokens validos possveis. Por exemplo: em uma linguagem com comentrios delimitados por "(*" e "*)", um

comentrio no fechado seria um erro. Este erro far com que o analisador verifique se durante a anlise ele no encontrou nenhum outro token valido. Se a linguagem tambm possuir a declarao de um token correspondente a "(", o analisador o teria encontrado nesse processo, o retornaria, continuando a anlise a partir do "*" do comentrio. Para prevenir isto, o token correspondente ao comentrio deveria ser declarado desta forma:
[identificador] :! [expresso regular]

Um token declarado deste modo no verifica outros tokens validos encontrados antes em caso de erro. Nos trs casos, o identificador pode ser omitido (a declarao comea diretamente pelo ":" ou ":!"). Quando o identificador no fornecido, o analisador gerado passa a ignorar tokens gerados pela expresso regular correspondente. Deste modo pode-se fornecer expresses para comentrios e caracteres de espao em branco (espao, quebra de linha, tabulao, etc.) para que o analisador gerado ignore. Definindo Token como caso especial de outro Token Pode-se definir um token como sendo um caso particular de um outro token base. Nestes casos, sempre que o analisador identifica o token base, ele procura pelo valor do token em uma lista de casos especiais. Se for encontrado, o caso especial retornado, seno produzido o token base. Esta declarao feita da seguinte forma:
[identificador] = [token base] : [valor]

onde token base um token declarado previamente, e valor uma sequncia de caracteres entre aspas. Como pode-se deduzir, esta construo especialmente til para a declarao das palavras reservadas de uma linguagem. Em geral, as palavras reservadas seguem o mesmo padro dos identificadores. Utilizar esta construo faz com que o autmato gerado seja bem menor de que se cada caso especial fosse declarado como um token comum. A lista dos casos gerada em ordem, e a localizao de um caso feita por busca binria. Topo

Expresses Regulares
Esta tabela ilustra as possibilidades de expresses regulares. Quaisquer combinaes entre estes padres possvel. Espaos em branco so ignorados (exceto entre aspas). a ab a|b [abc] reconhece a reconhece a seguido de b reconhece a ou b reconhece a, b ou c

[^abc] reconhece qualquer caractere, exceto a, b e c [a-z] a* a+ a? (a|b)* . \123 reconhece a, b, c, ... ou z reconhece zero ou mais a's reconhece um ou mais a's reconhece um a ou nenhum a. reconhece qualquer nmero de a's ou b's reconhece qualquer caractere, exceto quebra de linha reconhece o caractere ASCII 123 (decimal)

Os operadores posfixos (*, + e ?) tem a maior prioridade. Em seguida est a concatenao e por fim a unio ( | ). Parnteses podem ser utilizador para agrupar smbolos. Os caracteres " \ | * + ? ( ) [ ] { } . ^ - possuem significado especial. Para utiliz- los como caracteres normais deve-se preced-los por \, ou coloc-los entre aspas. Qualquer seqncia de caracteres entre aspas tratada como caracteres ordinrios. \+ "+*" reconhece + reconhece + seguido de *

"a""b" reconhece a, seguido de ", seguido de b \" reconhece "

Existem ainda os caracteres no imprimveis, representados por seqncias de escape \n \r \s \t \b \e Line Feed Carriage Return Espao Tabulao Backspace Esc

\XXX O caractere ASCII XXX (XXX um nmero decimal) Topo

Exemplo
Definies Regulares

L : [A-Za-z] D : [0-9] WS : [\ \t\n\r] COMMENT : "(*" [^ "*" ]* "*)"

Tokens
//pontuao"(" ")" ";" //tokens id : {L} ( {L} | {D} | _ )* num : {D}+ ^ [^ {L} ]//um ou mais dgitos, seguido de qqr char menos letra //palavras begin = id end = id if = id then = id else = id while = id do = id write = id chave : "begin" : "end" : "if" : "then" : "else" : "while" : "do" : "write"

//ignorar espaos em branco e comentrios : {WS}* :! {COMMENT}

Topo

Definio dos Aspectos Sintticos

Os Aspectos Sintticos so compostos pela declarao de Smbolos Terminais (Tokens), Smbolos No-Terminais e Produes.

Smbolos Terminais (Tokens)

O modo como estes smbolos so declarados depende do tipo de projeto que esta sendo feito. Analisadores Lxico e Sinttico conjuntos Neste tipo de projeto os Tokens declarados na Especificao Lxica so tomados como Smbolos Terminais. Analisador Sinttico sozinho Aqui os Tokens devem ser declarados explicitamente. Um Token pode ser declarado desta forma pode ser definido por um Identificador, ou uma expresso qualquer entre aspas. Cada linha deve conter a declarao de apenas um Token. Topo

Smbolos No-Terminais
O Smbolos No-Terminais devem ser todos declarados antes de poderem ser utilizados em produes. Sua forma a de um identificador entre < e >. Assim como no caso dos Tokens, apenas um smbolo pode ser declarado por linha. O primeiro smbolo declarado considerado o smbolo inicial da gramtica. Topo

Produes
A declarao das produes segue um formato baseado na notao BNF:
<no-terminal> ::= <lista de smbolos> | <lista de smbolos> | ... ;

Pode-se agrupar as definies ou deix-las separadas, ou seja:

<A> ::= <B> | <C> ;

igual a:
<A> ::= <B> ; <A> ::= <C>; Somente so aceitos nas produes smbolos j previamente declarados. O uso de um smbolo (terminal ou no=terminal) no declarado gera um erro semntico. Uma exceo a essa regra diz respeito ao smbolo terminal especial (letra i, com um acento circunflexo), que representa o smbolo epsilon (sentena vazia).

Topo

Restries
Existem restries impostas forma das produes, de acordo com a classe de analisador sinttico que se pretende gerar. Para Analisadores Descendentes (LL e Descendente Recursivo) no permitido que a gramtica possua Recurso Esquerda ou que no esteja na sua Forma Fatorada. A tentativa de se gerar um analisador com uma gramtica neste estado resultar em erro. A terceira restrio para gramticas LL checada, mas no impede que seja gerado o analisador. Enquanto as duas outras restries podem ser facilmente removidas aplicando-se algoritmos de transformao gramtica, esta ultima no o . Gramticas com este problema so ambguas, e durante a gerao do analisador ser pedido ao usurio para indicar qual produo deve ser escolhida para eliminar a ambiguidade. Analisadores Ascendentes (LR, LALR e SLR) no possuem problemas com recurso esquerda ou fatorao, mas mesmo assim no conseguem tratar gramticas ambiguas.

Neste caso, assim como nas analisadores descendentes, o usurio dever escolher em casos de ambiguidade entre empilhar um smbolo ou reduzir por uma produo, ou ento entre duas produes atraves das quais se pode reduzir. Topo

Exemplo
Tokens
"(" ")" ";" id num begin end if then else while do write

No-Terminais
<C> <C_LIST> <IF> <ELSE> <WHILE> <WRITE> <E>

Produes
<C> ::= <IF> | <WHILE> | <WRITE> | begin <C_LIST> end; <C_LIST> ::= <C> ";" <C_LIST> |; <IF> ::= if <E> then <C> <ELSE>; <ELSE> ::= else <C> | ; <WHILE> ::= while <E> do <C>; <WRITE> ::= write "(" <E> ")"; <E> ::= id | num;

Obs. 1: Pode-se utilizar neste exemplo os tokens do exemplo do analisador lxico. Obs. 2: Esta gramtica ambgua. Para gerar-se um analisador descendente preciso escolher a produo <ELSE> ::= else <C> durante a etapa de resoluo de ambigidades, e para analisadores ascendentes deve-se escolher empilhar "else".

Topo

Definio dos Aspectos Semnticos e de Gerao de Cdigo

Aspectos Semnticos so definidos atraves da introduo de Aes Semnticas dentro das produes da especificao sinttica. Estas aes so da forma:
#<nmero>

Durante a analise sinttica, ao semnticas instruem o analisador sinttico a envocar o analisador semntico, passando-lhe como parmetros o nmero da ao, e o mais recente token produzido pelo analisador lxico. Cabe ao usurio implementar as aes semnticas, na linguagem de destino. Estas aes podem ser responsveis por tarefas de anlise semntica (adicionar algum smbolo tabela de smbolos, checar tipos, verificar se um smbolo ja foi declarado, etc) ou pela gerao de cdigo (fazendo-se com que a ao semntica chame o gerador de cdigo). Topo

Exemplo
Foram colocadas na gramtica do exemplo anterior algumas aes. Cabe ao usurio dar sentido a elas, implementando-as. A ao 2 poderia ser resposvel por checar o tipo da expresso e gerar o cdigo para imprimir seu valor.
<C> ::= <IF> | <WHILE> | <WRITE> | begin <C_LIST> end; <C_LIST> ::= <C> ";" <C_LIST> | ; <IF> ::= if <E> #1 then <C> <ELSE>; <ELSE> ::= else <C> | ; <WHILE> ::= while <E> #1 do <C>; <WRITE> ::= write "(" <E> #2 ")"; <E> ::= id #3 | num #4;

Topo

Utilizao do Cdigo Gerado

Ser demonstrada agora a forma de utilizao dos analisadores.

Os exemplos sero dados em Java, o uso para as outras linguagens anlogo (exceto em casos especiais, que sero demonstrados). Topo

Analisador Lxico
Um analisador lxico possui os seguintes mtodos:
Lexico();

Construtor padro
Lexico(String input);

Construtor de inicializao
void setInput(String input);

Mtodo para passar a entrada ao analisador

void setPosition(int pos);

Mtodo para indicar a posio a partir da qual o prximo token deve ser procurado
Token nextToken() throws LexicalError;

Mtodo chamado para se obter o prximo token da entrada No caso de estar utilizando streams como forma de entrada, o construtor de inicializao e o mtodo setInput recebero como parmetro um objeto da classe Reader (istream em c++ e TStream em Delphi) em vez de uma string. O mtodo nextToken o pricipal desta classe. A cada chamada o analisador tenta identificar um token a partir da posio atual na entrada. Existem trs resultados possveis: Um token encontrado Neste caso, retornado um novo objeto da classe Token. A posio de leitura era o fim da entrada Neste caso retornado null ao chamador, indicando o fim do fluxo de tokens Nenhum token reconhecido Se nenhum token foi reconhecido pelo analisador, ser lanada uma exceo A cada chamada com sucesso, um novo token alocado. Em C++ e Delphi ele deve ser desalocado quando no for mais necessrio. O token retornado possui trs atributos: seu valor numrico (id), seu valor textual (lexeme) e a posio na entrada onde foi encontrado (position). Exemplo de uso do Analisador Lxico Em Java
Lexico lexico = new Lexico(); //... lexico.setInput( /* entrada */ ); //... try {

Token t = null; while ( (t = lexico.nextToken()) != null ) { System.out.println(t.getLexeme()); } } catch ( LexicalError e ) { System.err.println(e.getMessage() + &quote;, em &quote; + e.getPosition()); }

Em C++
Lexico lexico; //... lexico.setInput( /* entrada */ ); //... try { Token *t = 0; while ( (t = lexico->nextToken()) != 0 ) { std::cout &l;t< t->getLexeme() << '\n'; delete t; } } catch ( LexicalError &e ) { std::cerr << e.getMessage() << &quote;, em &quote; << e.getPosition() << '\n'; }

Em Delphi
lexico : TLexico; t : TToken; //... lexico := TLexico.create; //... lexico.setInput( (* entrada *) ); //... try t := lexico.nextToken; while (t <> nil) begin writeln(e.getLexeme); t.Destroy; t := lexico.nextToken; end; except on e : ELexicalError do writeln(e.getMessage, ', em ', e.getPosition); end; //... lexico.destroy;

Topo

Analisador Sinttico
O analisador sinttico possui apenas um mtodo pblico (alm de seu construtor padro):

void parse(Lexico scanner, Semantico semanticAnalyser) throws LexicalError, SyntaticError, SemanticError

Para este mtodo passado um analisador lxico e um semntico (em c++ via ponteiros). Se nenhum erro for detectado, o mtodo termina de forma normal (o analisador semntico deve ser programado de forma que ele guarde os resultados finais da anlise, se houverem). Este mtodo o "corao" do processo de anlise, e os erros detectados durante esta devem ser tratados pelo chamador deste mtodo. Erros lxicos vem do analisador lxico na forma da exceo LexicalError. Erros semnticos sero reportados via a exceo SemanticError. O prprio analisador sinttico detecta erros, e lana a exceo SyntaticError quando os encontra. Interface com o Analisador Lxico Sempre que um novo token for preciso, o mtodo nextToken do analisador lxico envocado. esperado que este mtodo retorne null quando no houverem mais tokens para serem processados, e que lance uma exceo LexicalError quando encontre um erro lxico. Em C++ e em Delphi, esperado quea cada chamada o token retornado seja alocado dinamicamente, pois o mesmo ser desalocado posteriormente (via delete/Destroy); Interface com o Analisador Semntico Sempre que uma acao semntica for necessria, o analisador semntico ser chamado, pelo mtodo executeAction, que recebe de parmetro o nmero da ao atual, e o mais recente token produzido pelo lxico. esperado que o analisador semntico lance um SemanticError quando encontrar uma situao de erro semntico. Topo

Analisador Semntico
O Analisador Semntico sempre implementado pelo usurio. Sua interface consiste do mtodo:
void executeAction(int action, Token token) throws SemanticError;

Os parmetros indicam a ao semntica que deve ser executada e o mais recente token produzido pelo analisador lxico (em c++ ele passado via ponteiro). Pode-se implementar de varios modos este mtodo. Para gramticas com poucas aoes semnticas, pode-se construir um switch/case em funo do parametro action e colocar o cdigo da ao diretamente dentro deste comando, ou delegar um outro mtodo para execut-la (com certeza mais recomendado)

Em gramticas com muitas aes, pode ser mais interessante criar um array de callbacks , indexado pelo nmero da ao semntica. Se um erro semntico for detectado, ele deve ser informado ao analisador sinttico lanando uma excesso do tipo SemanticError. Isto importante para manter a uniformidade na deteco de erros Topo

Tabelas de Erros
As excees geradas pelos analisadores lxico e sinttico utilizam como mensagens de erro constates literais declaradas nos arquivos ScannerConstants.java e ParserConstants.java, Constants.cpp ou ainda UConstants.pas, dependendo da linguagem objeto. So geradas mensagens padro, mas na maioria dos casos mensagens personalisadas iro identificar melhor os erros para o usurio final da aplicao. Topo

Tratamento de Excees
Muitas pessoas no esto familiarizadas com o mecanismo de tratamento de excesses utilizado pelo GALS para o tratamento de erros, por isso aqui segue uma breve descrio sobre seu funcionamento. Lanando uma exceo Em uma situao de erro pode-se lanar uma exceo, indicando este erro. Isto feito da seguite forma: Em Java
throw new ClasseDeExcecao(parametros);

Em C++
throw ClasseDeExcecao(parametros);

Em Delphi
raise ClasseDeExcecao.Create(parametros);

Tratando uma exceo Quando se executa um pedao de cdigo que pode eventualmente gerar uma exceo, deve-se tratar esta possvel condio da seguinte forma: Em Java
try { //codigo que pode gerar exceo }

catch (ClasseDeExcessao e) { //trata exceo do tipo ClasseDeExcessao }

Em C++
try { //codigo que pode gerar exceo } catch (ClasseDeExcessao &e) { //trata exceo do tipo ClasseDeExcessao }

Em Delphi
try //codigo que pode gerar exceo except on e : ClasseDeExcessao do //trata exceo do tipo ClasseDeExcessao end;

As excees geralmente possuem atributos que indicam o motivo do erro. Excees no GALS As excees utilizados no GALS possuem dois atributos: uma mensagem de erro e a posio (na entrada) onde o erro aconteceu. Existem trs classes concretas de excees: LexicalError SyntaticError SemanticError que so produzidas pelos analisadores lxico, sinttico e semntico respectivamente. Existe ainda uma quarta classe: AnalysisError, que serve de base para as outras trs. Quando se for tratar os erros gerados pelo mtodo parse do analisador sinttico, pode-se tratar cada exceo separadamente, ou tratar todas de uma vez s tratando-se AnalysisError. Em Java
Lexico lexico = new Lexico(); Sintatico sintatico = new Sintatico(); Semantico semantico = new Semantico(); //... lexico.setInput( /* entrada */ ); //... try { sintatico.parse(lexico, semantico); } catch ( LexicalError e ) { //Trada erros lxicos } catch ( SyntaticError e ) { //Trada erros sintticos } catch ( SemanticError e ) {

//Trada erros semnticos }

Em C++
Lexico lexico; Sintatico sintatico; Semantico semantico; //... lexico.setInput( /* entrada */ ); //... try { sintatico.parse(&lexico, &semantico); } catch ( LexicalError &e ) { //Trada erros lxicos } catch ( SyntaticError &e ) { //Trada erros sintticos } catch ( SemanticError &e ) { //Trada erros semnticos }

Em Delphi
lexico : TLexico; sintatico : TSintatico; semantico : TSemantico; //... lexico := TLexico.create; sintatico := TSintatico.create; semantico := TSemantico.create; //... lexico.setInput( (* entrada *) ); //... try sintatico.parse(lexico, semantico); except on e : ELexicalError do //Trada erros lxicos on e : ESyntaticError do //Trada erros sintticos on e : ESemanticError do //Trada erros semnticos end; //... lexico.destroy; sintatico.destroy; semantico.destroy;

Topo