converting to more concrete ast

Author: tierney

Makefile.am

@@ -14,6 +14,7 @@ AM_LFLAGS = -olex.yy.c
 
 bin_PROGRAMS += wiki_main
 wiki_main_SOURCES = lexer.ll parser.y wiki_main.cc expression.c
+wiki_main_LDADD = libproposition.la
 
 clean-local:
 	-rm -f lexer.c lexer.cc lexer.h lexer.hh parser.c parser.cc parser.h parser.hh

lexer.ll

@@ -5,14 +5,16 @@
  * To generate the lexical analyzer run: "flex Lexer.l"
  */
 
-#include "expression.h"
-#include "parser.hh"
-
 #include <cstdio>
 #include <string>
 
-/* #define YY_DECL extern "C" int yylex() */
+#include "norms.h"
+#include "expression.h"
+#include "parser.hh"
 
+#define SAVE_TOKEN yylval.string = new std::string(yytext, yyleng)
+#define TOKEN(t) (yylval.token = t)
+  /*extern "C" int yywrap() {} */
 %}
 %option outfile="lexer.cc" header-file="lexer.hh"
 
@@ -37,7 +39,7 @@ STRING      [a-zA-Z0-9]+
 {WS}            { /* Skip blanks. */ }
 {NUMBER}        { sscanf(yytext, "%d", &yylval->value); return TOKEN_NUMBER; }
 
-{STRING}        { yylval->string = strdup(yytext); return TOKEN_STRING; }
+{STRING}        { yylval->string = new std::string(strdup(yytext)); return TOKEN_STRING; }
 
 {MULTIPLY}      { return TOKEN_MULTIPLY; }
 {PLUS}          { return TOKEN_PLUS; }

norms.h

@@ -0,0 +1,86 @@
+#pragma once
+
+#include <iostream>
+#include <vector>
+#include <string>
+
+class NStatement;
+class NExpression;
+class NVariableDeclaration;
+
+typedef std::vector<NStatement*> StatementList;
+typedef std::vector<NExpression*> ExpressionList;
+typedef std::vector<NVariableDeclaration*> VariableList;
+
+class Norm {
+ public:
+  virtual ~Norm() {}
+};
+
+class NExpression : public Norm {
+};
+
+class NStatement : public Norm {
+};
+
+class NIdentifier : public NExpression {
+ public:
+  std::string name;
+  NIdentifier(const std::string& name) : name(name) {}
+};
+
+class NMethodCall : public NExpression {
+ public:
+  const NIdentifier& id;
+  ExpressionList arguments;
+  NMethodCall(const NIdentifier& id, ExpressionList& arguments) :
+      id(id), arguments(arguments) {}
+  NMethodCall(const NIdentifier& id) : id(id) {}
+};
+
+class NBinaryOperator : public NExpression {
+ public:
+  NExpression& lhs;
+  int op;
+  NExpression& rhs;
+  NBinaryOperator(NExpression& lhs, int op, NExpression& rhs) :
+      lhs(lhs), op(op), rhs(rhs) {}
+};
+
+class NBlock : public NExpression {
+ public:
+  StatementList statements;
+  NBlock() {}
+};
+
+class NExpressionStatement : public NStatement {
+public:
+    NExpression& expression;
+    NExpressionStatement(NExpression& expression) :
+        expression(expression) {}
+};
+
+class NVariableDeclaration : public NStatement {
+ public:
+  const NIdentifier& type;
+  NIdentifier& id;
+  NExpression *assignmentExpr;
+
+  NVariableDeclaration(const NIdentifier& type, NIdentifier& id) :
+      type(type), id(id) {}
+
+  NVariableDeclaration(const NIdentifier& type, NIdentifier& id,
+                       NExpression *assignmentExpr) :
+      type(type), id(id), assignmentExpr(assignmentExpr) {}
+};
+
+class NFunctionDeclaration : public NStatement {
+ public:
+  const NIdentifier& type;
+  const NIdentifier& id;
+  VariableList arguments;
+  NBlock& block;
+  NFunctionDeclaration(const NIdentifier& type, const NIdentifier& id,
+                       const VariableList& arguments, NBlock& block) :
+      type(type), id(id), arguments(arguments), block(block) {}
+};

parser.y

@@ -1,28 +1,26 @@
 %{
-
-/*
- * Parser.y file
- * To generate the parser run: "bison Parser.y"
- */
-
 #include <string>
 
+#include "norms.h"
 #include "expression.h"
 #include "parser.hh"
 #include "lexer.hh"
 
 namespace {
-int yyerror(yyscan_t scanner,
-                   SExpression **expression,
-                   const char *msg) {
-  fprintf(stderr,"SPECIAL Error:%s %s\n",msg, (*expression)->string); return 0;
-}
-int yyerror(
-                   SExpression **expression,
-           yyscan_t scanner,        const char *msg) {
-  fprintf(stderr,"SPECIAL Error:%s %s\n",msg, (*expression)->string); return 0;
+
+int yyerror(yyscan_t scanner, SExpression **expression, const char *msg) {
+  fprintf(stderr,"SPECIAL Error:%s %s\n",msg, (*expression)->string);
+  return 0;
 }
+int yyerror(SExpression **expression, yyscan_t scanner, const char *msg) {
+  fprintf(stderr,"SPECIAL Error:%s %s\n",msg, (*expression)->string);
+  return 0;
 }
+
+NBlock *normBlock;
+extern int yylex();
+
+} /* namespace */
 %}
 
 %code requires {
@@ -43,9 +41,19 @@ typedef void* yyscan_t;
 %parse-param { yyscan_t scanner }
 
 %union {
-  char *string;
   int value;
   SExpression *expression;
+
+  Norm *node;
+  NBlock *block;
+  NExpression *expr;
+  NStatement *stmt;
+  NIdentifier *ident;
+  NVariableDeclaration *var_decl;
+  std::vector<NVariableDeclaration*> *varvec;
+  std::vector<NExpression*> *expvec;
+  std::string *string;
+  int token;
 }
 
 %left '+' TOKEN_PLUS
@@ -78,6 +86,6 @@ expr
     | expr TOKEN_OR expr { $$ = createOperation( eOR, $1, $3 ); }
     | TOKEN_LPAREN expr TOKEN_RPAREN { $$ = $2; }
     | TOKEN_NUMBER { $$ = createNumber($1); }
-    | TOKEN_STRING { $$ = createString($1); }
+    | TOKEN_STRING { $$ = createString($1->c_str()); }
     ;
 %%

proposition.h

@@ -60,8 +60,8 @@ class Proposition {
   };
 
   typedef shared_ptr<Base> pointer;
-
   pointer value;
+
   Proposition(const pointer& value_) : value(value_) {}
 
   struct Variable : Base {

wiki_main.cc

@@ -1,10 +1,19 @@
+#include <cassert>
 #include <iostream>
 #include <cstdio>
+#include <set>
+#include <string>
 
+#include "norms.h"
 #include "expression.h"
 #include "parser.hh"
 #include "lexer.hh"
 
+#include "proposition.h"
+
+using std::set;
+using std::string;
+
 int yyparse(SExpression **expression, yyscan_t scanner);
 
 SExpression *getAST(const char *expr) {
@@ -35,6 +44,7 @@ int evaluate(SExpression *e) {
   switch (e->type) {
     case eSTRING:
       printf("String: %s\n", e->string);
+      assert(V(e->string).evaluate({e->string}));
       return 1;
     case eVALUE:
       return e->value;
@@ -52,10 +62,26 @@ int evaluate(SExpression *e) {
   }
 }
 
+Proposition prop_evaluate(SExpression* e, set<string>* vars) {
+  assert(vars != NULL);
+  switch (e->type) {
+    case eSTRING:
+      printf("String: %s\n", e->string);
+      vars->insert(e->string);
+      return V(e->string);
+    case eAND:
+      return prop_evaluate(e->left, vars) && prop_evaluate(e->right, vars);
+    case eOR:
+      return prop_evaluate(e->left, vars) || prop_evaluate(e->right, vars);
+    default:
+      assert(false);
+  }
+}
+
 int main(int argc, char **argv) {
   SExpression *e = NULL;
   // char test[]=" 4 + 2*10 + 3*( 5 + 1 )";
-  char test[] = "4 + makeItHappen + hello";
+  char test[] = "makeItHappen || hello";
   int result = 0;
 
   e = getAST(test);
@@ -64,6 +90,15 @@ int main(int argc, char **argv) {
 
   printf("Result of '%s' is %d\n", test, result);
 
+  set<string> vars;
+  Proposition prop = prop_evaluate(e, &vars);
+  auto truth_assignments = prop.evaluate_all(vars);
+  for (auto truth_assignment : truth_assignments) {
+    for (auto variable : vars)
+      cout << (truth_assignment.count(variable) ? "1" : "0") << "    ";
+    cout << endl;
+  }
+
   deleteExpression(e);
 
   return 0;