Lisp-com-ponto/lisp.c

/* Código gerado automaticamente */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#define ESPACO_MEM 100

static int listas[ESPACO_MEM*2 +1];
static int pilha[ESPACO_MEM+1];
static int simbolos[ESPACO_MEM*3 +1];

static void adc_carac_simbolo(
    int carac
);

static void adc_pilha(
    int valor
);

static void avaliar(void);

static void celula_lateral(
    int valor
);

static void def_topo_pilha(
    int valor
);

static int desc_topo_pilha(void);

static void erro(
    char *msg
);

static void fechar_nivel(void);

static void limpar_simbolos(void);

static void mostrar_simbolo(
    int indice
);

static void novo_nivel(void);

static inline void adc_lista_vazia(void);

static inline void def_ponteiro_lista(
    int indice,
    int ponteiro
);

static inline void def_valor_lista(
    int indice,
    int valor
);

static inline void limpar_listas(void);

static inline void limpar_pilha(void);

static inline int ponteiro_lista(
    int indice
);

static inline int tam_pilha(void);

static inline int topo_pilha(void);

static inline int ult_simbolo(void);

static inline int valor_lista(
    int indice
);

static inline void adc_lista_vazia(void) {
    if (listas[0] == ESPACO_MEM) {
      erro("Espaço de memória insuficiente");
    } else {
    }
    listas[ listas[0]*2+1 ] = 0;
    listas[ listas[0]*2+2 ] = 0;
    listas[0] ++;
}

static inline void def_ponteiro_lista(
    int indice,
    int ponteiro
) {
    listas[ (indice-1)*2+2 ] = ponteiro;
}

static inline void def_valor_lista(
    int indice,
    int valor
) {
    listas[ (indice-1)*2+1 ] = valor;
}

static inline void limpar_listas(void) {
    listas[0] = 0;
}

static inline void limpar_pilha(void) {
    pilha[0] = 0;
}

static inline int ponteiro_lista(
    int indice
) {
    return listas[ (indice-1)*2+2 ];
}

static inline int tam_pilha(void) {
    return pilha[0];
}

static inline int topo_pilha(void) {
    return pilha[ pilha[0] ];
}

static inline int ult_simbolo(void) {
    return simbolos[0];
}

static inline int valor_lista(
    int indice
) {
    return listas[ (indice-1)*2+1 ];
}

static void adc_carac_simbolo(
    int carac
) {
    if (simbolos[0] == ESPACO_MEM*3) {
      erro("Estouro de símbolos");
    } else {
    }
    simbolos[ ++simbolos[0] ] = carac;
}

static void adc_pilha(
    int valor
) {
    if (pilha[0] == ESPACO_MEM) {
      erro("Estouro de pilha");
    } else {
    }
    pilha[ ++pilha[0] ] = valor;
}

static void avaliar(void) {
    int ult_lista;
    while (getchar() != '\n');;
    limpar_pilha();
    adc_pilha(1);
    item_165 :
    ult_lista = topo_pilha();
    def_topo_pilha(ponteiro_lista(ult_lista));
    if (valor_lista(ult_lista) < 0) {
      mostrar_simbolo(-valor_lista(ult_lista));
      goto item_180;
    } else {
    }
    if (valor_lista(ult_lista) != 0) {
      putchar('(');
      adc_pilha(valor_lista(ult_lista));
    } else {
    }
    item_180 :
    if (topo_pilha() == 0) {
    } else {
      goto item_165;
    }
    if (pilha[0] == 1) {
      putchar('\n');
      limpar_listas();
      adc_lista_vazia();
      limpar_pilha();
      adc_pilha(1);
      limpar_simbolos();
    } else {
      putchar(')');
      desc_topo_pilha();
      goto item_180;
    }
}

static void celula_lateral(
    int valor
) {
    int ult_lista = topo_pilha();
    adc_lista_vazia();
    def_ponteiro_lista(ult_lista, listas[0]);
    def_valor_lista(ult_lista, valor);
    def_topo_pilha(listas[0]);
}

static void def_topo_pilha(
    int valor
) {
    pilha[ pilha[0] ] = valor;
}

static int desc_topo_pilha(void) {
    if (pilha[0] == 0) {
      erro("Tentou descartar topo de pilha vazia");
    } else {
    }
    return pilha[ pilha[0]-- ];
}

static void erro(
    char *msg
) {
    puts(msg);
    exit(1);
}

static void fechar_nivel(void) {
    if (pilha[0] == 1) {
      erro(") sobrando");
    } else {
    }
    desc_topo_pilha();
    adc_lista_vazia();
    int ult_lista = topo_pilha();
    def_ponteiro_lista(ult_lista, listas[0]);
    def_topo_pilha(listas[0]);
}

static void limpar_simbolos(void) {
    simbolos[0] = 0;
}

static void mostrar_simbolo(
    int indice
) {
    item_137 :
    if (simbolos[indice] != 0) {
      putchar(simbolos[indice]);
      indice++;
      goto item_137;
    } else {
    }
}

static void novo_nivel(void) {
    int ult_lista = topo_pilha();
    adc_lista_vazia();
    def_valor_lista(ult_lista, listas[0]);
    adc_pilha(listas[0]);
}

int main(void) {
    int carac;
    int comeco_simbolo = 0;
    adc_lista_vazia();
    adc_pilha(1);
    item_195 :
    if ((carac = getchar()) != EOF) {
    } else {
      return 0;
    }
    if (carac == '(') {
    } else {
      goto item_2060002;
    }
    if (comeco_simbolo) {
      adc_carac_simbolo(0);
      celula_lateral(-comeco_simbolo);
      comeco_simbolo = 0;
    } else {
    }
    novo_nivel();
    goto item_195;
    item_2060002 :
    if (carac == ')') {
    } else {
      goto item_2060003;
    }
    if (comeco_simbolo) {
      adc_carac_simbolo(0);
      celula_lateral(-comeco_simbolo);
      comeco_simbolo = 0;
    } else {
    }
    fechar_nivel();
    goto item_195;
    item_2060003 :
    if (carac == '.') {
    } else {
      goto item_244;
    }
    if (comeco_simbolo) {
      adc_carac_simbolo(0);
      celula_lateral(-comeco_simbolo);
      comeco_simbolo = 0;
    } else {
    }
    avaliar();
    goto item_195;
    item_244 :
    if (comeco_simbolo) {
    } else {
      comeco_simbolo = ult_simbolo()+1;
    }
    adc_carac_simbolo(carac);
    goto item_195;
}