// Fichier ptqsup.c : code supplémentaire pour ptq
// ----------------------------------------------------------------------
#include "ptq.h"

// ----------------------------------------------------------------------
// recherche générale pour un identificateur : 
// on regarde dans le lexique, puis dans la tds
//-----------------------------------------------------------------------
int recherche_id(char *s)
{
  int r ; 
  if ((r = recherche_lexique(s))==0)
    return recherche_tds(s) ;
  return r ; 

}

// ----------------------------------------------------------------------
// Gestion de la table des symboles
// ----------------------------------------------------------------------

struct {
  char nom[22] ; 
  int type ;
  int val ; 
} tds[30] ; 

int next_tds = 0 ; 


/*
TDS : 
------------------------------
NOM       TYPE     VALEUR
char[22]  int      int

+ le type correspond au token (défini dans y.tab.h)
+ la valeur est un entier arbitraire, pour distinguer les objets de même
type. On donne une valeur implicite (le premier predicat vaut 0, le
second 1, etc.).
*/

void insere_tds(char * s, int type) 
{
  int i, c=0 ; 
  for (i=0 ; i<next_tds ; i++)
    if (tds[i].type == type) c++ ;

  strcpy(tds[next_tds].nom, s) ;
  tds[next_tds].type = type ;
  tds[next_tds].val = c ; 
  next_tds++ ; 
}

void defaut_tds()
{
  insere_tds("x", VAR) ; 
  insere_tds("y", VAR) ; 
  insere_tds("z", VAR) ;
  insere_tds("j", CTE) ;
  insere_tds("m", CTE) ;
  insere_tds("H", PRED) ; 
  insere_tds("M", PRED) ; 
}


void affiche_tds()
{
  int i ;
  for (i=0 ; i<next_tds ; i++)
    printf("Id: %s ; type : %d, valeur : %d\n", tds[i].nom, tds[i].type, tds[i].val) ; 
}

int recherche_tds(char * s)
{ 
  int i ;
  //  printf("Je cherche %s...", s) ;
  for (i=0 ; i<next_tds ; i++) 
    if (!strcmp(tds[i].nom, s)) {
      //  printf(" je l'ai trouvé (ligne %d), type %d\n", i,  tds[i].type) ; 
      return tds[i].type ; 
  }
  //  printf("je ne le connais pas\n") ; 
  return ID ; 
}

int val_tds(char * s)
{ 
  int i ;
  for (i=0 ; i<next_tds ; i++)
    if (!strcmp(tds[i].nom, s)) return tds[i].val ; 
  return 0 ; 
}

char * string_tds(int t, int v)
{
  int i ;
  for (i=0 ; i<next_tds ; i++)
    if (tds[i].type==t && tds[i].val == v) return tds[i].nom ; 
  return "epsilon" ; 
}

// ----------------------------------------------------------------------
// Gestion du lexique
// ----------------------------------------------------------------------

struct {
  char lexeme[22] ;
  int cat ; 
  noeud * lambda ;
} lexique[100] ; 

int next_lexeme = 0 ;


void insere_lexique(char * s , int c, noeud * l)
{
  strcpy(lexique[next_lexeme].lexeme, s) ;
  lexique[next_lexeme].cat = c ;
  lexique[next_lexeme].lambda = l ; 
  next_lexeme++ ; 
}

int recherche_lexique(char * s)
{
  int i ;
  for (i=0 ; i<next_lexeme ; i++) 
    if (!strcmp(lexique[i].lexeme, s)) {
      return lexique[i].cat ; 
  }
  return 0 ; 
}  

void affiche_lexique()
{
  int i ;
  for (i=0 ; i<next_lexeme ; i++)
    printf("Id: %s ; categorie : %d\n", lexique[i].lexeme, lexique[i].cat) ; 
}

// ----------------------------------------------------------------------
// Construction de l'arbre associé à une formule
// ----------------------------------------------------------------------

noeud * cree_n(int type, int val, noeud * fg, noeud * fd)
{
  noeud * x = (noeud *) malloc (sizeof(noeud)) ;
  if (x == (noeud *) NULL) exit(-1) ; 
  x->type = type ;
  x->val  = val ;
  x->fg   = fg ;
  x->fd   = fd ;
  return x ;
}

void affiche_formule(noeud * racine)
{
  if (racine == NULL) return ;
  switch (racine->type) {
  case AF:
    printf("[") ; affiche_formule(racine->fg) ; printf("]") ; 
    affiche_formule(racine->fd) ; 
    break ; 
  case LBD :
    printf("L") ; affiche_formule(racine->fg) ; printf(".") ;
    printf(" ") ; affiche_formule(racine->fd) ; 
    break ; 
  case QUANT :
    printf("%c ", (racine->val==1)?'A':'E') ; affiche_formule(racine->fg) ;
    printf(" ") ; affiche_formule(racine->fd) ; 
    break ;
  case CON1 : printf("~ ") ; affiche_formule(racine->fg) ; 
    break ;
  case CON2 : 
    printf("("); affiche_formule(racine->fg) ; 
    printf(" %s ", (racine->val==1)?"&":(racine->val==2)?"|":"->") ; 
    affiche_formule(racine->fd) ; printf(")"); 
    break ; 
  case PRED : 
  case VAR   : 
  case CTE   : {
    printf("%s", string_tds(racine->type,racine->val)) ; 
    break ; 
  }
  }
}