Ir ao conteúdo
  • Cadastre-se
Regras do Clube do Hardware

Compilador léxico e sintático

univac

Por univac
em Programação - outros

Posts recomendados

univac
 

univac

Postado
Postado

Pessoal...boa tarde

Estou precisando, para concluir um trabalho na faculdade, de um programa feito de preferência em linguagem C, C++, pascal, delphi ou vb que faça o trabalho de um compilador simples. Esse compilador deverá executar as tarefas sintáticas e léxicas de um compilador. Quem estuda Ciências da Computação sabe do que estou falando....

Se alguém puder me enviar o fonte desse trabalho ficarei muito grato.....é urgete!

obrigado

Link para o comentário
Compartilhar em outros sites
  • 2 semanas depois...
josemanzoli
 

josemanzoli

Postado
Postado

Aí carinha eu tenho este só que não faz analise sintática, o que faz análise sintática esta em outro micro vou ver se acho pra você posto outro dia bele?

#include <iostream.h>

#include <iomanip.h>

#include <string.h>

#include <stdio.h>

#include <stdlib.h>

#include <conio.h>

#include <ctype.h>

/* Definição de tipos */

typedef

enum {T_ID, T_NUM, T_ME, T_MEI, T_MA, T_MAI, T_IG, T_DI, T_FIM, T_SO, T_SU,

T_MU, T_DIV, T_PROGRAMA, T_VAR, T_INICIO, T_END, T_SE, T_ENTAO, T_SENAO,

T_ENQUANTO, T_FACA, T_E, T_OU, T_NAO, T_PONTO, T_VIRGULA, T_PVIRGULA,

T_DPONTO, T_ATRIBUICAO, T_APARENTESES, T_FPARENTESES} TATOMO;

/* Informações de um átomo */

typedef

struct

{

TATOMO tipo;

union

{

char string[256];

int valor;

} val;

} TOKEN;

/* Lista Encadeada como Tabela de Símbolos */

typedef

struct no

{

TOKEN info;

struct no *prox;

} NO_TS;

/* Funcoes da ficha 2... */

void PROG();

void DECL();

void VAR_ID();

void LIST_ID();

void BLOCO();

void COM();

void COMANDO();

void LIST_COM();

void COND();

void ITER();

void ATRIB();

void EXPR();

void T_EXPR();

void EXP();

void T_EXP();

void TERMO();

void T_TERMO();

void FATOR();

/* Funções Auxiliares da função LeUmAtomo */

int ISSPACE (char ch); // verifica se ch é um caracter de espaço

int ISCARACTER (char ch); // verifica se ch é uma letra

int ISNUM (char ch); // verifica se ch é um número

int ISSOMA (char ch); // verifica se ch e um simbolo

int ISPRO (char ch); // verifica se ch e um simbolo

/* Funções */

TATOMO LeUmAtomo (FILE *fp, TOKEN *token); /* Função - Analisador Léxico */

void InsereNo (NO_TS **nots, TOKEN info); /* Insere um no' na T.S. */

TATOMO ProcuraAtomo (NO_TS *nots, char *s); /* Procura um atomo na T.S. */

int hashpjw (char *s);

int linha = 1; // variável global para controle de linha

char s[80];

NO_TS *nots[211];

int main(int argc, char *argv[])

{

TOKEN token;

int posicao;

clrscr();

//-------------------------------------------------------------------

token.tipo = T_PROGRAMA;

strcpy (token.val.string, "PROGRAMA");

posicao = hashpjw ("PROGRAMA");

InsereNo (&nots[posicao], token);

//-------------------------------------------------------------------

token.tipo = T_VAR;

strcpy (token.val.string, "VAR");

posicao = hashpjw ("VAR");

InsereNo (&nots[posicao], token);

//-------------------------------------------------------------------

token.tipo = T_INICIO;

strcpy (token.val.string, "INICIO");

posicao = hashpjw ("INICIO");

InsereNo (&nots[posicao], token);

//-------------------------------------------------------------------

token.tipo = T_END;

strcpy (token.val.string, "FIM");

posicao = hashpjw ("FIM");

InsereNo (&nots[posicao], token);

//-------------------------------------------------------------------

token.tipo = T_SE;

strcpy (token.val.string, "SE");

posicao = hashpjw ("SE");

InsereNo (&nots[posicao], token);

//-------------------------------------------------------------------

token.tipo = T_ENTAO;

strcpy (token.val.string, "então");

posicao = hashpjw ("então");

InsereNo (&nots[posicao], token);

//-------------------------------------------------------------------

token.tipo = T_SENAO;

strcpy (token.val.string, "SENAO");

posicao = hashpjw ("SENAO");

InsereNo (&nots[posicao], token);

//-------------------------------------------------------------------

token.tipo = T_ENQUANTO;

strcpy (token.val.string, "ENQUANTO");

posicao = hashpjw ("ENQUANTO");

InsereNo (&nots[posicao], token);

//-------------------------------------------------------------------

token.tipo = T_FACA;

strcpy (token.val.string, "FACA");

posicao = hashpjw ("FACA");

InsereNo (&nots[posicao], token);

//-------------------------------------------------------------------

token.tipo = T_E;

strcpy (token.val.string, "E");

posicao = hashpjw ("E");

InsereNo (&nots[posicao], token);

//-------------------------------------------------------------------

token.tipo = T_OU;

strcpy (token.val.string, "OU");

posicao = hashpjw ("OU");

InsereNo (&nots[posicao], token);

//-------------------------------------------------------------------

token.tipo = T_NAO;

strcpy (token.val.string, "não");

posicao = hashpjw ("não");

InsereNo (&nots[posicao], token);

//-------------------------------------------------------------------

// cout << ">> ";

// enquanto o átomo for diferente de T_FIM

while (LeUmAtomo (stdin, &token) != T_FIM)

{

cout << setw(3) << linha << ": ";

switch (token.tipo)

{

case T_ID:

cout << "Identificador " << token.val.string;

// InsereNo (&nots, token);

break;

case T_NUM: cout << "Numero " << token.val.valor; break;

case T_ME: cout << "Operador relacional <"; break;

case T_MEI: cout << "Operador relacional <="; break;

case T_MA: cout << "Operador relacional >"; break;

case T_MAI: cout << "Operador relacional >="; break;

case T_IG: cout << "Operador relacional ="; break;

case T_DI: cout << "Operador relacional <>"; break;

case T_SO: cout << "Operador matematico +"; break;

case T_SU: cout << "Operador matematico -"; break;

case T_DIV: cout << "Operador matematico /"; break;

case T_MU: cout << "Operador matematico *"; break;

case T_PROGRAMA: cout << "Palavra Reservada Programa"; break;

case T_VAR: cout << "Palavra Reservada Var"; break;

case T_INICIO: cout << "Palavra Reservada Inicio"; break;

case T_END: cout << "Palavra Reservada Fim"; break;

case T_SE: cout << "Palavra Reservada Se"; break;

case T_ENTAO: cout << "Palavra Reservada então"; break;

case T_SENAO: cout << "Palavra Reservada Senao"; break;

case T_ENQUANTO: cout << "Palavra Reservada Enquanto"; break;

case T_FACA: cout << "Palavra Reservada Faca"; break;

case T_E: cout << "Palavra Reservada E"; break;

case T_OU: cout << "Palavra Reservada Ou"; break;

case T_NAO: cout << "Palavra Reservada não"; break;

case T_PONTO: cout << "Delimitador ."; break;

case T_VIRGULA: cout << "Delimitador ,"; break;

case T_PVIRGULA: cout << "Delimitador ;"; break;

case T_DPONTO: cout << "Delimitador :"; break;

case T_ATRIBUICAO: cout << "Delimitador :="; break;

case T_APARENTESES: cout << "Delimitador ("; break;

case T_FPARENTESES: cout << "Delimitador )"; break;

// cout << ">> ";

}

cout << endl;

}

return 0;

}

int hashpjw (char *s)

{

char *p;

unsigned h = 0, g;

for (p = s; *p != '\0'; p++) //s aponta para o 1§ elemento da var digitada

{

h = (h << 4) + (*p); //h << 4 - deslocamento de bit

if (g = h & 0xF0000000) //& seria o & binario

{

h = h ^ (g >> 24);

h = h ^ g;

} // fim if

} // fim for

return (h % 211);

}

// [] -------------------------------------------------------------------------

int ISSPACE (char ch)

{ return (ch == '\t' || ch == ' ' || ch == '\r'); }

// [] -------------------------------------------------------------------------

int ISCARACTER (char ch)

{ return ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')); }

// [] -------------------------------------------------------------------------

int ISNUM (char ch)

{ return (ch >= '0' && ch <= '9'); }

// [] -------------------------------------------------------------------------

int ISSOMA (char ch)

{ return (ch == '+'); }

// [] -------------------------------------------------------------------------

int ISSUB (char ch)

{return (ch == '-'); }

// [] -------------------------------------------------------------------------

int ISMULTI (char ch)

{return (ch == '*'); }

// [] -------------------------------------------------------------------------

int ISDIV (char ch)

{return (ch == '/'); }

// [] -------------------------------------------------------------------------

// [] --------------------------LISTA 2-----------------------------------

void PROG()

{

reconhece (T_PROGRAMA);

reconhece (T_ID);

reconhece (T_PVIRGULA);

DECL();

BLOCO();

reconhece (T_PONTO);

}

void DECL()

{

reconhece (T_VAR);

VAR_ID();

reconhece (T_DPONTO);

reconhece (T_INTEIRO);

}

void VAR_ID()

{

reconhece (T_ID);

LIST_ID();

}

void LIST_ID()

{

if (LeUmAtomo == T_VIRGULA)

{

reconhece (T_VIRGULA);

reconhece (T_ID);

LIST_ID();

}

}

void BLOCO()

{

reconhece (T_INICIO);

COM();

reconhece (T_FIM);

}

void COM()

{

COMANDO();

reconhece (T_PVIRGULA);

LIST_COM();

}

void COMANDO();

{

if (LeUmAtomo == T_SE)

COND();

else if (LeUmAtomo == T_ENQUANTO)

ITER();

else if (LeUmAtomo == T_ID)

ATRIB();

}

void LIST_COM()

{

}

void

TATOMO LeUmAtomo (FILE *fp, TOKEN *token)

{

int estado = 0, indice = 0;

char ch = 0;

double valor;

TATOMO atomo;

while (estado != 99)

{

ch = fgetc (fp);

ch = toupper(ch);

switch (estado)

{

// estado inicial do autômato

case 0:

if (ISSPACE(ch) || ch == '\n')

{

estado = 0;

if (ch == '\n') linha++;

}

else if (ISCARACTER (ch) || ch == '_')

{

token->val.string[indice++] = ch;

estado = 1;

}

else if (ISNUM (ch))

{

token->val.valor = (ch - '0');

estado = 2;

}

else if (ch == '+') estado = 3;

else if (ch == '-') estado = 4;

else if (ch == '*') estado = 5;

else if (ch == '/') estado = 6;

else if (ch == '<') estado = 7;

else if (ch == '>') estado = 8;

else if (ch == '=') estado = 9;

else if (ch == '.') estado = 10;

else if (ch == ',') estado = 11;

else if (ch == ';') estado = 12;

else if (ch == ':') estado = 13;

else if (ch == ':=') estado = 14;

else if (ch == '(') estado = 15;

else if (ch == ')') estado = 16;

else estado = 99;

break;

case 1:

if (ISCARACTER (ch) ||ch == '_'||ISNUM (ch))

token->val.string[indice++] = ch;

else

{

ungetc (ch, fp);

token->val.string[indice] = '\0';

int posicao = hashpjw (token->val.string);

atomo = ProcuraAtomo (nots[posicao], token->val.string);

if (atomo != T_ID)

return (token->tipo = atomo);

else

{

token->tipo = T_ID;

InsereNo (&nots[posicao], *token);

}

return (T_ID);

}

break;

case 2:

if (ISNUM (ch))

token->val.valor = (token->val.valor * 10) + (ch - '0');

else

{

ungetc (ch, fp);

return (token->tipo = T_NUM);

}

break;

case 3:

{

ungetc (ch, fp);

return (token->tipo = T_SO);

}

case 4:

{

ungetc (ch, fp);

return (token->tipo = T_SU);

}

case 5:

{

ungetc (ch, fp);

return (token->tipo = T_MU);

}

case 6:

{

ungetc (ch, fp);

return (token->tipo = T_DIV);

}

case 7:

if (ch == '=') return (token->tipo = T_MEI);

else if (ch == '>') return (token->tipo = T_DI);

else

{

ungetc (ch, fp);

return (token->tipo = T_ME);

}

break;

case 8:

if (ch == '=') return (token->tipo = T_MAI);

else

{

ungetc (ch, fp);

return (token->tipo = T_MA);

}

break;

case 9:

ungetc (ch, fp);

return (token->tipo = T_IG);

case 10:

{

ungetc (ch, fp);

return (token->tipo = T_PONTO);

}

case 11:

{

ungetc (ch, fp);

return (token->tipo = T_VIRGULA);

}

case 12:

{

ungetc (ch, fp);

return (token->tipo = T_PVIRGULA);

}

case 13:

{

ungetc (ch, fp);

return (token->tipo = T_DPONTO);

}

case 14:

{

ungetc (ch, fp);

return (token->tipo = T_ATRIBUICAO);

}

case 15:

{

ungetc (ch, fp);

return (token->tipo = T_APARENTESES);

}

case 16:

{

ungetc (ch, fp);

return (token->tipo = T_FPARENTESES);

}

} // fim switch

} // fim while

return T_FIM;

} // fim LeUmAtomo

// [] -------------------------------------------------------------------------

void InsereNo (NO_TS **nots, TOKEN info) /* Insere um no' na T.S. */

{

NO_TS *no = (NO_TS *)0;

NO_TS *temp = (NO_TS *)0;

no = new NO_TS;

no->info = info;

no->prox = (NO_TS *)0;

// se o início da lista for vazia

if (*nots == (NO_TS*)0)

*nots = no;

else

{

temp = *nots;

while (temp->prox != (NO_TS *)0)

temp = temp->prox;

temp->prox = no;

} // fim else

}

// [] -------------------------------------------------------------------------

TATOMO ProcuraAtomo (NO_TS *nots, char *s) /* Procura um atomo na T.S. */

{

while ((nots != (NO_TS *)0) &&

(strcmp(nots->info.val.string, s) != 0))

nots = nots->prox;

if (nots != (NO_TS *)0)

return nots->info.tipo;

return T_ID;

}

#include <iostream.h>

#include <iomanip.h>

#include <string.h>

#include <stdio.h>

#include <stdlib.h>

#include <conio.h>

#include <ctype.h>

/* Definição de tipos */

typedef

enum {T_ID, T_NUM, T_ME, T_MEI, T_MA, T_MAI, T_IG, T_DI, T_FIM, T_SO, T_SU,

T_MU, T_DIV, T_PROGRAMA, T_VAR, T_INICIO, T_END, T_SE, T_ENTAO, T_SENAO,

T_ENQUANTO, T_FACA, T_E, T_OU, T_NAO, T_PONTO, T_VIRGULA, T_PVIRGULA,

T_DPONTO, T_ATRIBUICAO, T_APARENTESES, T_FPARENTESES} TATOMO;

/* Informações de um átomo */

typedef

struct

{

TATOMO tipo;

union

{

char string[256];

int valor;

} val;

} TOKEN;

/* Lista Encadeada como Tabela de Símbolos */

typedef

struct no

{

TOKEN info;

struct no *prox;

} NO_TS;

/* Funcoes da ficha 2... */

void PROG();

void DECL();

void VAR_ID();

void LIST_ID();

void BLOCO();

void COM();

void COMANDO();

void LIST_COM();

void COND();

void ITER();

void ATRIB();

void EXPR();

void T_EXPR();

void EXP();

void T_EXP();

void TERMO();

void T_TERMO();

void FATOR();

/* Funções Auxiliares da função LeUmAtomo */

int ISSPACE (char ch); // verifica se ch é um caracter de espaço

int ISCARACTER (char ch); // verifica se ch é uma letra

int ISNUM (char ch); // verifica se ch é um número

int ISSOMA (char ch); // verifica se ch e um simbolo

int ISPRO (char ch); // verifica se ch e um simbolo

/* Funções */

TATOMO LeUmAtomo (FILE *fp, TOKEN *token); /* Função - Analisador Léxico */

void InsereNo (NO_TS **nots, TOKEN info); /* Insere um no' na T.S. */

TATOMO ProcuraAtomo (NO_TS *nots, char *s); /* Procura um atomo na T.S. */

int hashpjw (char *s);

int linha = 1; // variável global para controle de linha

char s[80];

NO_TS *nots[211];

int main(int argc, char *argv[])

{

TOKEN token;

int posicao;

clrscr();

//-------------------------------------------------------------------

token.tipo = T_PROGRAMA;

strcpy (token.val.string, "PROGRAMA");

posicao = hashpjw ("PROGRAMA");

InsereNo (&nots[posicao], token);

//-------------------------------------------------------------------

token.tipo = T_VAR;

strcpy (token.val.string, "VAR");

posicao = hashpjw ("VAR");

InsereNo (&nots[posicao], token);

//-------------------------------------------------------------------

token.tipo = T_INICIO;

strcpy (token.val.string, "INICIO");

posicao = hashpjw ("INICIO");

InsereNo (&nots[posicao], token);

//-------------------------------------------------------------------

token.tipo = T_END;

strcpy (token.val.string, "FIM");

posicao = hashpjw ("FIM");

InsereNo (&nots[posicao], token);

//-------------------------------------------------------------------

token.tipo = T_SE;

strcpy (token.val.string, "SE");

posicao = hashpjw ("SE");

InsereNo (&nots[posicao], token);

//-------------------------------------------------------------------

token.tipo = T_ENTAO;

strcpy (token.val.string, "então");

posicao = hashpjw ("então");

InsereNo (&nots[posicao], token);

//-------------------------------------------------------------------

token.tipo = T_SENAO;

strcpy (token.val.string, "SENAO");

posicao = hashpjw ("SENAO");

InsereNo (&nots[posicao], token);

//-------------------------------------------------------------------

token.tipo = T_ENQUANTO;

strcpy (token.val.string, "ENQUANTO");

posicao = hashpjw ("ENQUANTO");

InsereNo (&nots[posicao], token);

//-------------------------------------------------------------------

token.tipo = T_FACA;

strcpy (token.val.string, "FACA");

posicao = hashpjw ("FACA");

InsereNo (&nots[posicao], token);

//-------------------------------------------------------------------

token.tipo = T_E;

strcpy (token.val.string, "E");

posicao = hashpjw ("E");

InsereNo (&nots[posicao], token);

//-------------------------------------------------------------------

token.tipo = T_OU;

strcpy (token.val.string, "OU");

posicao = hashpjw ("OU");

InsereNo (&nots[posicao], token);

//-------------------------------------------------------------------

token.tipo = T_NAO;

strcpy (token.val.string, "não");

posicao = hashpjw ("não");

InsereNo (&nots[posicao], token);

//-------------------------------------------------------------------

// cout << ">> ";

// enquanto o átomo for diferente de T_FIM

while (LeUmAtomo (stdin, &token) != T_FIM)

{

cout << setw(3) << linha << ": ";

switch (token.tipo)

{

case T_ID:

cout << "Identificador " << token.val.string;

// InsereNo (&nots, token);

break;

case T_NUM: cout << "Numero " << token.val.valor; break;

case T_ME: cout << "Operador relacional <"; break;

case T_MEI: cout << "Operador relacional <="; break;

case T_MA: cout << "Operador relacional >"; break;

case T_MAI: cout << "Operador relacional >="; break;

case T_IG: cout << "Operador relacional ="; break;

case T_DI: cout << "Operador relacional <>"; break;

case T_SO: cout << "Operador matematico +"; break;

case T_SU: cout << "Operador matematico -"; break;

case T_DIV: cout << "Operador matematico /"; break;

case T_MU: cout << "Operador matematico *"; break;

case T_PROGRAMA: cout << "Palavra Reservada Programa"; break;

case T_VAR: cout << "Palavra Reservada Var"; break;

case T_INICIO: cout << "Palavra Reservada Inicio"; break;

case T_END: cout << "Palavra Reservada Fim"; break;

case T_SE: cout << "Palavra Reservada Se"; break;

case T_ENTAO: cout << "Palavra Reservada então"; break;

case T_SENAO: cout << "Palavra Reservada Senao"; break;

case T_ENQUANTO: cout << "Palavra Reservada Enquanto"; break;

case T_FACA: cout << "Palavra Reservada Faca"; break;

case T_E: cout << "Palavra Reservada E"; break;

case T_OU: cout << "Palavra Reservada Ou"; break;

case T_NAO: cout << "Palavra Reservada não"; break;

case T_PONTO: cout << "Delimitador ."; break;

case T_VIRGULA: cout << "Delimitador ,"; break;

case T_PVIRGULA: cout << "Delimitador ;"; break;

case T_DPONTO: cout << "Delimitador :"; break;

case T_ATRIBUICAO: cout << "Delimitador :="; break;

case T_APARENTESES: cout << "Delimitador ("; break;

case T_FPARENTESES: cout << "Delimitador )"; break;

// cout << ">> ";

}

cout << endl;

}

return 0;

}

int hashpjw (char *s)

{

char *p;

unsigned h = 0, g;

for (p = s; *p != '\0'; p++) //s aponta para o 1§ elemento da var digitada

{

h = (h << 4) + (*p); //h << 4 - deslocamento de bit

if (g = h & 0xF0000000) //& seria o & binario

{

h = h ^ (g >> 24);

h = h ^ g;

} // fim if

} // fim for

return (h % 211);

}

// [] -------------------------------------------------------------------------

int ISSPACE (char ch)

{ return (ch == '\t' || ch == ' ' || ch == '\r'); }

// [] -------------------------------------------------------------------------

int ISCARACTER (char ch)

{ return ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')); }

// [] -------------------------------------------------------------------------

int ISNUM (char ch)

{ return (ch >= '0' && ch <= '9'); }

// [] -------------------------------------------------------------------------

int ISSOMA (char ch)

{ return (ch == '+'); }

// [] -------------------------------------------------------------------------

int ISSUB (char ch)

{return (ch == '-'); }

// [] -------------------------------------------------------------------------

int ISMULTI (char ch)

{return (ch == '*'); }

// [] -------------------------------------------------------------------------

int ISDIV (char ch)

{return (ch == '/'); }

// [] -------------------------------------------------------------------------

// [] --------------------------LISTA 2-----------------------------------

void PROG()

{

reconhece (T_PROGRAMA);

reconhece (T_ID);

reconhece (T_PVIRGULA);

DECL();

BLOCO();

reconhece (T_PONTO);

}

void DECL()

{

reconhece (T_VAR);

VAR_ID();

reconhece (T_DPONTO);

reconhece (T_INTEIRO);

}

void VAR_ID()

{

reconhece (T_ID);

LIST_ID();

}

void LIST_ID()

{

if (LeUmAtomo == T_VIRGULA)

{

reconhece (T_VIRGULA);

reconhece (T_ID);

LIST_ID();

}

}

void BLOCO()

{

reconhece (T_INICIO);

COM();

reconhece (T_FIM);

}

void COM()

{

COMANDO();

reconhece (T_PVIRGULA);

LIST_COM();

}

void COMANDO();

{

if (LeUmAtomo == T_SE)

COND();

else if (LeUmAtomo == T_ENQUANTO)

ITER();

else if (LeUmAtomo == T_ID)

ATRIB();

}

void LIST_COM()

{

}

void

TATOMO LeUmAtomo (FILE *fp, TOKEN *token)

{

int estado = 0, indice = 0;

char ch = 0;

double valor;

TATOMO atomo;

while (estado != 99)

{

ch = fgetc (fp);

ch = toupper(ch);

switch (estado)

{

// estado inicial do autômato

case 0:

if (ISSPACE(ch) || ch == '\n')

{

estado = 0;

if (ch == '\n') linha++;

}

else if (ISCARACTER (ch) || ch == '_')

{

token->val.string[indice++] = ch;

estado = 1;

}

else if (ISNUM (ch))

{

token->val.valor = (ch - '0');

estado = 2;

}

else if (ch == '+') estado = 3;

else if (ch == '-') estado = 4;

else if (ch == '*') estado = 5;

else if (ch == '/') estado = 6;

else if (ch == '<') estado = 7;

else if (ch == '>') estado = 8;

else if (ch == '=') estado = 9;

else if (ch == '.') estado = 10;

else if (ch == ',') estado = 11;

else if (ch == ';') estado = 12;

else if (ch == ':') estado = 13;

else if (ch == ':=') estado = 14;

else if (ch == '(') estado = 15;

else if (ch == ')') estado = 16;

else estado = 99;

break;

case 1:

if (ISCARACTER (ch) ||ch == '_'||ISNUM (ch))

token->val.string[indice++] = ch;

else

{

ungetc (ch, fp);

token->val.string[indice] = '\0';

int posicao = hashpjw (token->val.string);

atomo = ProcuraAtomo (nots[posicao], token->val.string);

if (atomo != T_ID)

return (token->tipo = atomo);

else

{

token->tipo = T_ID;

InsereNo (&nots[posicao], *token);

}

return (T_ID);

}

break;

case 2:

if (ISNUM (ch))

token->val.valor = (token->val.valor * 10) + (ch - '0');

else

{

ungetc (ch, fp);

return (token->tipo = T_NUM);

}

break;

case 3:

{

ungetc (ch, fp);

return (token->tipo = T_SO);

}

case 4:

{

ungetc (ch, fp);

return (token->tipo = T_SU);

}

case 5:

{

ungetc (ch, fp);

return (token->tipo = T_MU);

}

case 6:

{

ungetc (ch, fp);

return (token->tipo = T_DIV);

}

case 7:

if (ch == '=') return (token->tipo = T_MEI);

else if (ch == '>') return (token->tipo = T_DI);

else

{

ungetc (ch, fp);

return (token->tipo = T_ME);

}

break;

case 8:

if (ch == '=') return (token->tipo = T_MAI);

else

{

ungetc (ch, fp);

return (token->tipo = T_MA);

}

break;

case 9:

ungetc (ch, fp);

return (token->tipo = T_IG);

case 10:

{

ungetc (ch, fp);

return (token->tipo = T_PONTO);

}

case 11:

{

ungetc (ch, fp);

return (token->tipo = T_VIRGULA);

}

case 12:

{

ungetc (ch, fp);

return (token->tipo = T_PVIRGULA);

}

case 13:

{

ungetc (ch, fp);

return (token->tipo = T_DPONTO);

}

case 14:

{

ungetc (ch, fp);

return (token->tipo = T_ATRIBUICAO);

}

case 15:

{

ungetc (ch, fp);

return (token->tipo = T_APARENTESES);

}

case 16:

{

ungetc (ch, fp);

return (token->tipo = T_FPARENTESES);

}

} // fim switch

} // fim while

return T_FIM;

} // fim LeUmAtomo

// [] -------------------------------------------------------------------------

void InsereNo (NO_TS **nots, TOKEN info) /* Insere um no' na T.S. */

{

NO_TS *no = (NO_TS *)0;

NO_TS *temp = (NO_TS *)0;

no = new NO_TS;

no->info = info;

no->prox = (NO_TS *)0;

// se o início da lista for vazia

if (*nots == (NO_TS*)0)

*nots = no;

else

{

temp = *nots;

while (temp->prox != (NO_TS *)0)

temp = temp->prox;

temp->prox = no;

} // fim else

}

// [] -------------------------------------------------------------------------

TATOMO ProcuraAtomo (NO_TS *nots, char *s) /* Procura um atomo na T.S. */

{

while ((nots != (NO_TS *)0) &&

(strcmp(nots->info.val.string, s) != 0))

nots = nots->prox;

if (nots != (NO_TS *)0)

return nots->info.tipo;

return T_ID;

}

Link para o comentário
Compartilhar em outros sites

Arquivado

Este tópico foi arquivado e está fechado para novas respostas.

Ir à lista de tópicos

Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas comunidades sobre tecnologia do Brasil. Leia mais

Direitos autorais

Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

Mais

×
×
  • Criar novo...

 

GRÁTIS: ebook Redes Wi-Fi – 2ª Edição

EBOOK GRÁTIS!

CLIQUE AQUI E BAIXE AGORA MESMO!