Beginning of the symbol table implementation

4 files changed, 110 insertions, 24 deletions

diff --git a/src/symboltable.c b/src/symboltable.c
new file mode 100644
index 0000000..852d1b8
--- /dev/null
+++ b/src/symboltable.c
@@ -0,0 +1,35 @@
+#include "symboltable.h"
+
+extern int lineno; /* from lexical analyser */
+
+SymbolTable symbol_table = {{{{0},0}},MAXSYMBOLS,0};
+
+void addVar(const char name[], int type) {
+  int count;
+  for (count = 0; count < symbol_table.size; count++) {
+    if (!strcmp(symbol_table.entries[count].name, name)) {
+      printf("semantic error, redefinition of variable %s near line %d\n", name,
+             lineno);
+      return;
+    }
+  }
+  if (++symbol_table.size > symbol_table.maxsize) {
+    printf("too many variables near line %d\n", lineno);
+    exit(1);
+  }
+  strcpy(symbol_table.entries[symbol_table.size - 1].name, name);
+  symbol_table.entries[symbol_table.size - 1].type = type;
+}
+
+void lookup(const char name[]) {
+  int count;
+
+  for (count = 0; count < symbol_table.size; count++) {
+    if (!strcmp(symbol_table.entries[count].name, name)) {
+      return;
+    }
+    printf("No definition of the variable %s near line %d\n", name,
+           lineno);
+  }
+}
+
diff --git a/src/symboltable.h b/src/symboltable.h
new file mode 100644
index 0000000..cc828fa
--- /dev/null
+++ b/src/symboltable.h
@@ -0,0 +1,30 @@
+#ifndef __SYMBOLTABLE_H__
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define MAXNAME 32
+#define INT 0
+#define CHAR 1
+#define MAXSYMBOLS 256
+
+
+typedef struct {
+    char name[MAXNAME];
+    int type;
+} STentry;
+
+
+typedef struct {
+        STentry entries[MAXSYMBOLS];
+        int maxsize;
+        int size;
+} SymbolTable;
+
+
+void addVar(const char name[], int type);
+void lookup(const char name[]);
+void display_table();
+
+#endif
\ No newline at end of file
diff --git a/src/tpc.lex b/src/tpc.lex
index 8b824c0..5137d39 100644
--- a/src/tpc.lex
+++ b/src/tpc.lex
@@ -18,12 +18,12 @@ int lineno = 1;
 "/*"                    { BEGIN COMMENT; }
 "&&"                    { return AND; }
 "||"                    { return OR; }
-"*"|"/"|%               { return DIVSTAR; }
-"+"|-                   { return ADDSUB; }
-"<"|"<="|">"|">="       { return ORDER; }
-==|!=                   { return EQ; }
-int                     { return TYPE; }
-char                    { return TYPE; }
+"*"|"/"|%               { yylval.divstar=yytext[0]; return DIVSTAR; }
+"+"|-                   { yylval.addsub=yytext[0]; return ADDSUB; }
+"<"|"<="|">"|">="       { strcpy(yylval.comp, yytext); return ORDER; }
+==|!=                   { strcpy(yylval.comp, yytext); return EQ; }
+entier                  { strcpy(yylval.type, yytext); return TYPE; }
+caractere               { strcpy(yylval.type, yytext); return TYPE; }
 void                    { return VOID; }
 const                   { return CONST; }
 if                      { return IF; }
@@ -33,9 +33,16 @@ return                  { return RETURN; }
 print                   { return PRINT; }
 readc                   { return READC; }
 reade                   { return READE; }
-[a-zA-Z_][a-zA-Z0-9_]*  { return IDENT; }
-[0-9]+                  { return NUM; }
-'\\?.'                  { return CARACTERE; }
+[a-zA-Z_][a-zA-Z0-9_]*  { strcpy(yylval.ident, yytext); return IDENT; }
+[0-9]+                  { sscanf(yytext, "%d", &(yylval.num)); return NUM; }
+'\\?.'                  { if (strlen(yytext)==3)
+                            yylval.caractere=yytext[1];
+                          else switch(yytext[2]) {
+                            case 'n': yylval.caractere='\n'; break;
+                            case 't': yylval.caractere='\t'; break;
+                            case '\'': yylval.caractere='\''; break;
+                            }
+                          return CARACTERE; }
 .                       { return yytext[0]; }
 <COMMENT>"*/"           { BEGIN INITIAL; }
 <COMMENT>\n             { lineno++; }
diff --git a/src/tpc.y b/src/tpc.y
index a44a9aa..f1a51ff 100644
--- a/src/tpc.y
+++ b/src/tpc.y
@@ -5,6 +5,7 @@
  */
 
 #include <stdio.h>
+#include "symboltable.h"
 
 extern int lineno;
 int yylex();
@@ -12,12 +13,25 @@ void yyerror(char *);
 
 %}
 
-%token CARACTERE NUM IDENT
-%token ADDSUB DIVSTAR
-%token ORDER EQ OR AND
-%token IF WHILE RETURN
-%token CONST VOID TYPE
-%token PRINT READC READE
+%union {
+    char caractere;
+    int num;
+    char ident[64];
+    char type[32];
+    char comp[3];
+    char addsub;
+    char divstar;
+}
+%token <caractere> CARACTERE
+%token <num> NUM
+%token <ident> IDENT
+%token <comp> ORDER EQ
+%token <addsub> ADDSUB
+%token <divstar> DIVSTAR
+%token OR AND CONST IF ELSE WHILE RETURN VOID PRINT READC READE
+%token <type> TYPE
+
+%type <num> Exp EB TB FB M E T F LValue
 
 %left ','
 %precedence ')'
@@ -122,17 +136,17 @@ T:
   |  F
   ;
 F:
-     ADDSUB F
-  |  '!' F
-  |  '(' Exp ')'
-  |  LValue
-  |  NUM
-  |  CARACTERE
-  |  IDENT '(' Arguments  ')'
+     ADDSUB F                   {$$ = $2;} //on fait remonter le type
+  |  '!' F                      {$$ = $2;} 
+  |  '(' Exp ')'                {$$ = $2;}
+  |  LValue                     //Il faut trouver le type de LValue
+  |  NUM                        {$$ = INT;} // on stocke les types pour l'analyse sémantique
+  |  CARACTERE                  {$$ = CHAR;}
+  |  IDENT '(' Arguments  ')'   {$$ = INT;} //tableau d'entiers uniquement
   ;
 LValue:
-     IDENT
-  |  IDENT  '[' Exp  ']'
+     IDENT                      {lookup($<ident>1);}
+  |  IDENT  '[' Exp  ']'        {lookup($<ident>1);}
   ;
 Arguments:
      ListExp