infija a postfija

/include
/include
//#include

/include
/include
/define TAMBUFF 128
/define NINGUNO -1
/define FDC    '\0'
/define NUM     256
/define DIV     257
/define MOD    258
/define ID     259
/define FIN    260
/define MAXLEX 9999
/define MAXSIMB 1000

int analex(void);
void termino();
int busca(char s[]);
void error(char *m);
int inserta(char s[], int clex);
void expr();
void parea(int t);
void factor();
void emite(int t, int tval);
void inic();
void analsint();

int main(){

printf("\nInserte el respectivo termino finalizando con ; \n");
printf("\nPresione Enter al final del ingreso de la expresion \n");
    printf("\nInserte la expresion: \n");
    inic();
    analsint();
    //getch();
printf("\nFINALIZADA LA COMPILACION\n");
}

struct entrada{        //forma que tiene la esctructura entrada

    char *aplex;
    int complex;
};

struct entrada tablasimb[TAMBUFF];

char buflex[TAMBUFF];
int numlinea = 1;
int valcomplex = NINGUNO;

int analex()
{
    int t;
    while(1)
    {
    t = getchar();

    if(t == ' ' || t == '\t')
        ;
    else if(t == '\n')
        ;
    else if(isdigit(t)){
        ungetc(t, stdin);
        scanf("%d\n", &valcomplex);
        return NUM;
    }
    else if(isalpha(t)){
        int p, b = 0;
        while(isalnum(t)){
            buflex[b] = t;
            t = getchar();
            b = b + 1;
            if(b >= TAMBUFF)
                error("Error...");
        }//fin del while
        buflex[b]=FDC;
        if(t != EOF)
            ungetc(t, stdin);

        p= busca(buflex);
        if(p == 0)
            p= inserta(buflex, ID);

        valcomplex = p;
        return tablasimb[p].complex;
    }
    else if (t == EOF)
        return FIN;
    else {
        valcomplex = NINGUNO;
        return t;
          }
    }
}


int preanalisis;

void analsint()
{
    preanalisis = analex();
    while(preanalisis != FIN)
    {
        expr();
        parea(';');
        numlinea= numlinea + 1;
            }
}


void expr()
{
    int t;
    termino();
    while(1)
        switch(preanalisis)
        {
            case '+':
            case '-':
            t= preanalisis;
                    parea (preanalisis);
            termino();
            emite(t, NINGUNO);
            printf("\n");
            continue;
        default:
            return;
        }
}// fin de expr


void termino()
{
    int t;
    factor();
    while(1)
        switch(preanalisis)
        {
            case '*':
            case '/':
            case DIV:
            case MOD:
            t = preanalisis;
             parea(preanalisis);
            factor();
            emite(t, NINGUNO);
            continue;
             default:
            return;
        }
}



void factor()
{
    switch(preanalisis)
    {
        case '(':
            parea('(');
            expr();
            parea(')');
            break;
        case NUM:
            emite(NUM, valcomplex);
            parea(NUM);
            break;
        case ID:
            emite(ID, valcomplex);
            parea(ID);
            break;
        default:
            error("Error de compilacion....  \n ");
    }
}



void parea(int t)
{
    if(preanalisis==t)
        preanalisis= analex();
            else error("Error...\n ");
}




void emite(int t,int tval)
{
            switch(t) {
         case '+':
         case '-':
         case '*':
         case '/':
        printf("%c   ", t); break;
         case DIV:
        printf("DIV    "); break;
          case MOD:
        printf("MOD   "); break;
         case NUM:
        printf("%d   ",tval); break;
         case ID:
        printf("%s   ",tablasimb[tval].aplex);
        break;
         default:
        printf("complex %d\n",t);
        break;
    }
}


char lexemas[MAXLEX];
int ultcar = -1;
int ultent = 0;

char s[80];
int busca(char s[])

 {
    int p;
    for(p=ultent;p>0;p=p-1)
        if(strcmp(tablasimb[p].aplex, s)== 0)
            return p;
    return 0;
 }



int inserta(char s[],int clex)
 {
    int lon;
    lon=strlen(s);

    if(ultent + 1 >= MAXSIMB)
        error("tabla de simbolos llena");
    if(ultcar + lon + 1 >= MAXLEX)
        error ("matriz de lexemas llena");
    ultent = ultent + 1;
    tablasimb[ultent].complex=clex;
    tablasimb[ultent].aplex = &lexemas[ultcar + 1];
    ultcar = ultcar + lon + 1;
    strcpy(tablasimb[ultent].aplex,s);
    return ultent;
 }



struct entrada palsclave[] = {
        "div", DIV,
        "mod", MOD,
        0, 0
};
void inic()
{
    struct entrada *p;
    for(p = palsclave; p-> complex; p++)
    {

        inserta(p->aplex, p->complex);
    }
}

void error(char *m)
{
    fprintf(stderr, "linea %d: %s\n", numlinea, m);
    getchar();

}