Updated structure

tests/sprint2/other/calc.h

@@ -0,0 +1,48 @@
+/* Function type. */
+typedef double (func_t) (double);
+/* Data type for links in the chain of symbols. */
+struct symrec
+{
+  char *name;  /* name of symbol */
+  int type;    /* type of symbol: either VAR or FUN */
+  union
+  {
+    double var;    /* value of a VAR */
+    func_t *fun;   /* value of a FUN */
+  } value;
+  struct symrec *next;  /* link field */
+};
+typedef struct symrec symrec;
+
+/* The symbol table: a chain of 'struct symrec'. */
+extern symrec *sym_table;
+
+symrec *putsym (char const *name, int sym_type);
+symrec *getsym (char const *name);
+struct init
+{
+  char const *name;
+  func_t *fun;
+};
+struct init const funs[] =
+{
+  { "atan", atan },
+  { "cos",  cos  },
+  { "exp",  exp  },
+  { "ln",   log  },
+  { "sin",  sin  },
+  { "sqrt", sqrt },
+  { 0, 0 },
+};
+/* The symbol table: a chain of 'struct symrec'. */
+symrec *sym_table;
+/* Put functions in table. */
+static void
+init_table (void)
+{
+  for (int i = 0; funs[i].name; i++)
+    {
+      symrec *ptr = putsym (funs[i].name, FUN);
+      ptr->value.fun = funs[i].fun;
+    }
+}

tests/sprint2/other/test.c

@@ -0,0 +1,74 @@
+#include <stdlib.h>
+#include <string.h>
+#include "symbol_table.h"
+
+int main(void){
+        char *prim = strdup("primitive");
+        char *inte = strdup("integer");
+        SymbolTable * parant = CreateScope(NULL, 1,1);
+        char *boole = strdup("Boolean");
+        char *chare = strdup("character");
+        char *str = strdup("string");
+        char *arg = strdup("arg");
+        char *one_to_char = strdup("1 -> character");
+        char *int_to_int = strdup("integer -> integer");
+        char *int2int = strdup("int2int");
+        char *str_to_int = strdup("string -> integer");
+        char *str2int = strdup("string2int");
+        char *square = strdup("square");
+        char *string2int = strdup("string2int");
+        char *entry = strdup("entry");
+        char *x = strdup("x");
+        char *input = strdup("input");
+        char *expected = strdup("expected");
+        char *actual = strdup("actual");
+        char *$_und_type = strdup("$_undefined_type");
+        char *result = strdup("result");
+        char *BOO = strdup("BOO");
+        char *YAZOO = strdup("YAZOO");
+
+        CreateEntry(parant, prim, boole);
+        CreateEntry(parant, prim, chare);
+        CreateEntry(parant, prim, inte);
+        CreateEntry(parant, one_to_char, str);
+        CreateEntry(parant, int_to_int, int2int);
+        CreateEntry(parant, str_to_int, str2int);
+        CreateEntry(parant, int2int, square);
+        CreateEntry(parant, string2int, entry);
+        SymbolTable * child = CreateScope(parant, 14,14);
+        CreateEntry(child, inte, x);
+        SymbolTable * second = CreateScope(parant, 21,15);
+        CreateEntry(second, str, arg);
+        CreateEntry(second, inte, input);
+        CreateEntry(second, inte, expected);
+        CreateEntry(second, inte, actual);
+        CreateEntry(second, $_und_type, result);
+        SymbolTable * third = CreateScope(second, 33,44);
+        CreateEntry(third, BOO, arg);
+        CreateEntry(third, YAZOO, input);
+
+        TableNode *ret = table_lookup(third, "arg");
+        printf("%s == %s\n", ret->theName, "arg");
+
+        ret = table_lookup(third, "hello");
+        printf("This should be nil %p != %s\n", ret, "BOO");
+
+        ret = look_up(second, "input");
+        printf("%s == %s\n", ret->theName, "input");
+
+        ret = look_up(second, "square");
+        printf("%s == %s\n", ret->theName, "square");
+
+        ret = look_up(second, "spuare");
+        printf("This should be nil %p == %s\n", ret, "square");
+
+        print_symbol_table(parant, stderr);
+        free(inte);
+        free(boole);
+        free(prim);
+        free(str);
+        free(chare);
+        free(arg);
+        return 0;
+}
+

tests/sprint2/other/testGrammar.y

@@ -0,0 +1,41 @@
+%{
+  #include <stdio.h>  /* For printf, etc. */
+  #include <math.h>   /* For pow, used in the grammar. */
+  #include "calc.h"   /* Contains definition of 'symrec'. */
+  int yylex (void);
+  void yyerror (char const *);
+%}
+%define api.value.type union /* Generate YYSTYPE from these types: */
+%token <double>  NUM     /* Double precision number. */
+%token <symrec*> VAR FUN /* Symbol table pointer: variable/function. */
+%nterm <double>  exp
+%precedence '='
+%left '-' '+'
+%left '*' '/'
+%precedence NEG /* negation--unary minus */
+%right '^'      /* exponentiation */
+%% /* The grammar follows. */
+input:
+  %empty
+| input line
+;
+line:
+  '\n'
+| exp '\n'   { printf ("%.10g\n", $1); }
+| error '\n' { yyerrok;                }
+;
+exp:
+  NUM
+| VAR                { $$ = $1->value.var;              }
+| VAR '=' exp        { $$ = $3; $1->value.var = $3;     }
+| FUN '(' exp ')'    { $$ = $1->value.fun ($3);         }
+| exp '+' exp        { $$ = $1 + $3;                    }
+| exp '-' exp        { $$ = $1 - $3;                    }
+| exp '*' exp        { $$ = $1 * $3;                    }
+| exp '/' exp        { $$ = $1 / $3;                    }
+| '-' exp  %prec NEG { $$ = -$2;                        }
+| exp '^' exp        { $$ = pow ($1, $3);               }
+| '(' exp ')'        { $$ = $2;                         }
+;
+/* End of grammar. */
+%%