fixed CGTFile to work under unix

d00mas · d00mas · commit 0b5f054a580a · 2003-11-30T12:14:42.000Z
diff --git a/INSTALL b/INSTALL
@@ -6,19 +6,26 @@ i) On GCC based environments
 Be sure that you have a gcc version >= 3.0.
 You will also need GNU make.
 
-then type: make -f gcc-linux.mak
+then type: make -f Makefile.gcc
 And it will compile the library in directory ./lib
 
 ii) On HPUX
-type: make -f acc-hpux.mak
+type: make -f Makefile.acc
 
 the compiled library will be created on ./lib
 
+The examples contained in ./examples can be 
+compiled separately in the same way as the 
+library.
 
 WINDOWS
 -------
 
 Go to the projfiles directory and load the desired 
 Visual Studio project.
+Add in the tools->directories>include the path to the
+include directory in the cpp-gpengine directory.
+
+Project files are also provided for the examples.
 
 
diff --git a/examples/XML/XML.cpp b/examples/XML/XML.cpp
@@ -77,7 +77,7 @@ int main(int argc, char *argv[])
   
   // If there are errors report them
   if (myErrors->errors.size() > 0) {
-    for (int i=0; i < myErrors->errors.size(); i++) {
+    for (unsigned int i=0; i < myErrors->errors.size(); i++) {
         cout << filename << ":";
         cout << myReporter.composeErrorMsg (*myErrors->errors[i]) << endl;
     }
@@ -96,7 +96,7 @@ int main(int argc, char *argv[])
    
   myErrors = lalr->getErrors(); 
   if (myErrors->errors.size() != 0) {
-    for (int i=0; i < myErrors->errors.size(); i++) {
+    for (unsigned int i=0; i < myErrors->errors.size(); i++) {
         cout << filename << ":";
         cout << myReporter.composeErrorMsg (*myErrors->errors[i]) << endl;
     }
diff --git a/examples/XML/ex_xml.xml b/examples/XML/ex_xml.xml
@@ -1,6 +1,6 @@
 <?xml version="1.0" standalone="no"?>
 <svg width="5cm" height="4cm"
-     xmlns="http://www.w3.org/2000/svg"
+     xmlns="http://www.w3.org/2000/svg">
   <desc>Four separate rectangles
   </desc>
     <rect x="0.5cm" y="0.5cm" width="2cm" height="1cm"/>
diff --git a/examples/logic/LogicASTCreator.cpp b/examples/logic/LogicASTCreator.cpp
@@ -7,7 +7,7 @@
 // Please read AbstractSyntaxGrammr.txt for info on the abstract grammar
 
 ASTNode *LogicASTCreator::getASTNode (const Symbol *reduction, 
-				      ASTNode *parent) {    
+				                      ASTNode *parent) {    
   vector <ASTNode*> *children = NULL;
   int ind; 
   
@@ -31,7 +31,8 @@ ASTNode *LogicASTCreator::getASTNode (const Symbol *reduction,
     // <Start> ::= <NewLineList> <AxiomList>
     // Start := AxiomList
     if ( ind == RULE_START) {
-      CREATE_NODE (Start, start);
+      Start *start = new Start ();
+      start->init (reduction, parent);
       
       start->addChild (getASTNode(rdcChildren[1], start));
       return start;
@@ -40,7 +41,8 @@ ASTNode *LogicASTCreator::getASTNode (const Symbol *reduction,
     // <AxiomList> ::= <Axiom> <AxiomList>
     // AxiomList := Axiom*
     if (ind == RULE_AXIOMLIST) {
-      CREATE_NODE (AxiomList, axiomList);
+      AxiomList *axiomList = new AxiomList ();
+      axiomList->init (reduction, parent);
       
       axiomList->addChild (getASTNode (rdcChildren[0], axiomList));
       
@@ -53,7 +55,8 @@ ASTNode *LogicASTCreator::getASTNode (const Symbol *reduction,
     // <Implication> ::= <DoubleImplication> '->' <Implication>
     // Implication:Axiom := Axiom Axiom
     if (ind == RULE_IMPLICATION_MINUSGT) {
-      CREATE_NODE (Implication, implication);
+      Implication *implication = new Implication ();
+      implication->init (reduction, parent);
       
       implication->addChild (getASTNode (rdcChildren[0], implication));
       implication->addChild (getASTNode (rdcChildren[2], implication));
@@ -63,7 +66,8 @@ ASTNode *LogicASTCreator::getASTNode (const Symbol *reduction,
     // <DoubleImplication> ::= <Or> '<->' <DoubleImplication>
     // DoubleImplication:Axiom := Axiom Axiom
     if (ind == RULE_DOUBLEIMPLICATION_LTMINUSGT) {
-      CREATE_NODE (DoubleImplication, doubleImplication);
+      DoubleImplication *doubleImplication = new DoubleImplication ();
+      doubleImplication->init (reduction, parent);
       
       doubleImplication->addChild (getASTNode (rdcChildren[0], 
 					       doubleImplication));
@@ -75,52 +79,58 @@ ASTNode *LogicASTCreator::getASTNode (const Symbol *reduction,
     // <Or> ::= <And> OR <Or>
     // Or:Axiom := Axiom Axiom
     if (ind == RULE_OR_OR) {
-      CREATE_NODE (Or, or);
+      Or *_or = new Or ();
+      _or->init (reduction, parent);
       
-      or->addChild (getASTNode (rdcChildren[0], or));
-      or->addChild (getASTNode (rdcChildren[2], or));
-      return or;
+      _or->addChild (getASTNode (rdcChildren[0], _or));
+      _or->addChild (getASTNode (rdcChildren[2], _or));
+      return _or;
     }
     
     // <And> ::= <Not> AND <And>
     // And:Axiom := Axiom Axiom
     if (ind == RULE_AND_AND) {
-      CREATE_NODE (And, and);
+      And *_and = new And ();
+      _and->init (reduction, parent);
       
-      and->addChild (getASTNode (rdcChildren[0], and));
-      and->addChild (getASTNode (rdcChildren[2], and));
-      return and;
+      _and->addChild (getASTNode (rdcChildren[0], _and));
+      _and->addChild (getASTNode (rdcChildren[2], _and));
+      return _and;
     }
     
     // <Not> ::= NOT <Value> 
     // Not:Axiom := Axiom
     if (ind == RULE_NOT_NOT) {
-      CREATE_NODE (Not, not);
+      Not *_not = new Not ();
+      _not->init (reduction, parent);
       
-      not->addChild (getASTNode (rdcChildren[1], not));
-      return not;
+      _not->addChild (getASTNode (rdcChildren[1], _not));
+      return _not;
     }    
     
     
     // <Proposition> ::= ID
     // Proposition:Axiom := ID
     if (ind == RULE_PROPOSITION_ID) {
-      CREATE_NODE (Proposition, proposition);
+      Proposition *proposition = new Proposition ();
+      proposition->init (reduction, parent);
       proposition->addChild (getASTNode (rdcChildren[0],proposition));
       return proposition;
         }
     
-    // Process Terminal Symbols (just create nodes for everyone of it, maybe
-    // Convert data types from wstring to other more convenient types
+    // Process Terminal Symbols (just create nodes for everyone of it, maybe also
+    // convert data types from wstring to other more convenient types)
   } else {
     ind = reduction->symbolIndex;
     // Terminal:
     // ID
     if (ind == SYMBOL_ID) {
-      CREATE_NODE (Terminal_ID, id);
+      Terminal_ID *id = new Terminal_ID ();
+      id->init (reduction, parent);
       return id;
     }
   }
   
+  // Search for equivalent nodes among the childrens of this reduction
   return searchEquivNode( rdcChildren, parent);
 }
diff --git a/examples/logic/logic.cpp b/examples/logic/logic.cpp
@@ -39,7 +39,7 @@ int main(int argc, char *argv[])
   ErrorTable       *myErrors;
   ErrorReporter    myReporter;
   LogicASTCreator  myASTCreator;
-
+ 
   // Load grammar file
   if (cgtFile.load ("logic.cgt")) {
     wprintf (L"%s\n", "Grammar loaded succesfully");
@@ -70,7 +70,7 @@ int main(int argc, char *argv[])
   
   // If there are errors report them
   if (myErrors->errors.size() > 0) {
-    for (int i=0; i < myErrors->errors.size(); i++) {
+    for (unsigned int i=0; i < myErrors->errors.size(); i++) {
         cout << filename << ":";
         cout << myReporter.composeErrorMsg (*myErrors->errors[i]) << endl;
     }
@@ -89,7 +89,7 @@ int main(int argc, char *argv[])
    
   myErrors = lalr->getErrors(); 
   if (myErrors->errors.size() != 0) {
-    for (int i=0; i < myErrors->errors.size(); i++) {
+    for (unsigned int i=0; i < myErrors->errors.size(); i++) {
         cout << filename << ":";
         cout << myReporter.composeErrorMsg (*myErrors->errors[i]) << endl;
     }
diff --git a/examples/logic/logic.dsw b/examples/logic/logic.dsw
@@ -3,6 +3,18 @@ Microsoft Developer Studio Workspace File, Format Version 6.00
 
 ###############################################################################
 
+Project: "gpengine"="..\..\projfiles\VC6\gpengine.dsp" - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
 Project: "logic"=".\logic.dsp" - Package Owner=<4>
 
 Package=<5>
diff --git a/examples/logic/logic.ncb b/examples/logic/logic.ncb
diff --git a/include/ASTNode.h b/include/ASTNode.h
@@ -38,19 +38,18 @@
  
  class ASTNode {
  protected:
-    std::wstring  symbol;
-    std::wstring  image;
+    std::wstring  m_symbol;
+    std::wstring  m_image;
 
-	unsigned short line, col;
+    ASTNode *m_parent;
+	unsigned short m_line, m_col;
 	
 	std::vector <ASTNode*> children;
-	ASTNode *parent;
-
+	
  public:
-    ASTNode ();
 	virtual ~ASTNode ();
 
-	void    init      (const Symbol &s);
+	void    init      (const Symbol *s, ASTNode *parent);
 	void    setImage  (wstring image);
     void    setSymbol (wstring symbol);
     std::wstring getImage  ();
diff --git a/include/ErrorReporter.h b/include/ErrorReporter.h
@@ -55,7 +55,7 @@ class ErrorReporter {
     string composeLineCol (const GPError &err);
 public:
     ErrorReporter ();
-    ~ErrorReporter ();
+    virtual ~ErrorReporter ();
 
     string  composeErrorMsg   (const GPError &err);
     wstring composeErrorMsgU  (const GPError &err);
diff --git a/src/ASTCreator.cpp b/src/ASTCreator.cpp
@@ -66,7 +66,8 @@
 	<Start> ::= <ConstList> <DefsList> <StatementList>
 
 	 if ( sym == L"Start" ) {
-		CREATE_NODE (Start, start); // Check this macro definition for more details
+		Start *start = new Start ();
+        start->init (reduction, parent);
 
 		start->addChild (getASTNode(rdcChildren[1], start));
 		start->addChild (getASTNode(rdcChildren[3], start));
@@ -84,7 +85,8 @@
 	<StatementList> ::= <Statement>*
 
 	 if (sym == L"StatementList") {
-		CREATE_NODE (StatementList, statementList);
+		StatementList *statementList = new StatementList ();
+        statementList->init (reduction, parent);
 		
 		if (rdcChildren.size() == 3) {
 			statementList->addChild (getASTNode (rdcChildren[0], stmtList));
@@ -98,30 +100,30 @@
 */
 
 	 /*
-        If the symbol constants are included it is possible to use a switch-case 
-        for all the rules:
-
-        switch (reduction->symbolIndex) {
+        If the symbol constants are included it is possible to do it in the possible way: 
 
             // <If Statement> ::= if <Expression> then <StatementList> end
-            case RULE_IF_THEN_END_STATEMENT:
-                CREATE_NODE (IfStatement, ifStmt);
+            if (sym == RULE_IF_THEN_END_STATEMENT) {
+                IfStatement *ifStatement = new IfStatement ();
+                ifStatement->init (reduction, parent);
                     
                 ifStmt->addChild (getASTNode(rdcChildren[1], ifStmt));
                 ifStmt->addChild (getASTNode(rdcChildren[3], ifStmt));
 	
                 return ifStmt;
+            }
 
             // <If Statement> ::= if <Expression> then <StatementList> else <StatementList> end
-            case RULE_IF_THEN_END_ELSE_STATEMENT:
-                CREATE_NODE (IfStatement, ifStatement);
+            if ( sym == RULE_IF_THEN_END_ELSE_STATEMENT) {
+                IfStatement *ifStatement = new IfStatement ();
+                ifStatement->init (reduction, parent);
 
                 ifStmt->addChild (getASTNode(rdcChildren[1], ifStmt));
                 ifStmt->addChild (getASTNode(rdcChildren[3], ifStmt));
 	            ifStmt->addChild (getASTNode(rdcChildren[5], ifStmt));
                 return ifStmt;
-            default: return searchEquivNode( rdcChildren, parent);
-        }
+            }
+           
 
      */
 
diff --git a/src/ASTNode.cpp b/src/ASTNode.cpp
diff --git a/src/CGTFile.cpp b/src/CGTFile.cpp
