lab1/main.cc

@@ -10,7 +10,7 @@ using namespace std;
 typedef struct
 {
     int      token;
-    char    *name;
+    const char    *name;
 } tTokenName;
 
 
@@ -75,7 +75,7 @@ int main(int argc, char **argv)
     int     token;
     extern  FILE *yyin;
     extern  int yylex();
-    
+
     /*
      * Open the input file, if any
      */
@@ -92,7 +92,7 @@ int main(int argc, char **argv)
             perror(argv[1]);
             exit(1);
         }
-        break;	
+        break;
     default:
         cerr << "Usage: " << argv[0] << " [ filename ]\n";
         exit(1);

lab1/test/code

+/*
+	This test checks the fibonacci function
+	Author: John Tinnerholm
+*/
+declare
+a : integer;
+function fib (x : integer) : integer
+begin
+  if x == 0 then
+    begin
+      return 0;
+    end
+  elseif x == 1 then
+    begin
+      return 1;
+    end
+  else
+    begin
+      return fib(x - 1) + fib(x-2);
+    end
+  if;
+end;
+
+begin
+  a := 0;
+  while a < 10 do
+    begin
+      putint(fib(a));
+      putline();
+      a := a + 1;
+    end
+  while;
+end;

lab2/Makefile

 CC      = g++
 CCFLAGS = -g
+CFLAGS  = -g
 LDFLAGS =
 
 lab2 : lex.o main.o lab2.o

lab2/lab2.cc

@@ -25,7 +25,7 @@ double Parser::Parse(void)
      * Parse the input using recursive descent parsing. You'll need
      * an object of type Scanner to get tokens from the input. Call
      * the Scan method of this object to get the next token in the
-     * input stream. 
+     * input stream.
      */
 
     /* --- End your code --- */
@@ -37,17 +37,17 @@ void Parser::Recover(void)
 {
 
     cerr << "Error recovery.\n" << flush;
-    
+
     /* --- Your code here ---
      *
      * Error recovery routine
-     * 
+     *
      * Unless you come up with something better, this function should
      * scan tokens until it sees the end of line or end of file.
      * Parsing may be resumed at that point. This means that if an end
      * of line token caused the error, this routine doesn't need to do
      * anything.
-     * 
+     *
      * Be sure not to scan more tokens than necessary, or it won't be
      * possible to resume parsing.
      */

lab2/lab2.hh

@@ -17,6 +17,7 @@ using namespace std;
 class Parser
 {
 public:
+    Scanner scanner;
     void Recover(void);         // Error recovery routine
     double Parse(void);         // Main entry point
 };
@@ -24,10 +25,10 @@ public:
 class Trace
 {
     static int indent;
-    char *name;
+    const char *name;
 
 public:
-    Trace(char *s)
+    Trace(const char *s)
     {
         name = s;
         cerr.width(indent);

lab2/lex.cc

@@ -8,7 +8,7 @@
 // Human-readable representations of token types
 //
 
-static char *kTokenTypeNames[] =
+static const char *kTokenTypeNames[] =
 {
     "uninitialized",
     "number",
@@ -81,12 +81,12 @@ void Scanner::PutbackChar(unsigned char c)
 Token Scanner::Scan(void)
 {
     int c;
-    
+
     Reset();
     while (1)
     {
         c = GetChar();
-        
+
         switch (state)
         {
         case 0:                     // Initial state
@@ -238,7 +238,7 @@ Token Scanner::Scan(void)
 // multiple-character token.
 //
 
-void Scanner::Accumulate(char c)
+void Scanner::Accumulate(const char c)
 {
     if (position >= kMaxTokenLength)
     {
@@ -311,13 +311,12 @@ ostream& operator<<(ostream& s, ScannerError& e)
 // Lookup just returns the textual representation of a token type. The
 // no argument version returns the type of the token.
 //
-
-char *Token::Lookup(void)
+const char *Token::Lookup(void)
 {
     return kTokenTypeNames[type];
 }
 
-char *Token::Lookup(TokenType t)
+const char *Token::Lookup(TokenType t)
 {
     return kTokenTypeNames[t];
 }

lab2/lex.hh

@@ -30,11 +30,11 @@ class ScannerError
 {
 public:
     char errorCharacter;
-    char *message;
+    const char *message;
     int  state;
 
     ScannerError(char c, int s) : errorCharacter(c), state(s) {};
-    ScannerError(char *s) : message(s) {};
+    ScannerError(const char *s) : message(s) {};
     ScannerError()       : errorCharacter(0) {};
 };
 
@@ -86,8 +86,8 @@ public:
     double          numberValue;
     char           *symbolValue;
 
-    char *Lookup(TokenType);
-    char *Lookup(void);
+    const char *Lookup(TokenType);
+    const char *Lookup(void);
     Token() : type(kUninitialized) {};
     Token(TokenType t) : type(t) {};
     Token(TokenType t, double x) : type(t), numberValue(x) {};

lab2/main.cc

@@ -9,11 +9,12 @@ int main(void)
     Parser parser;
     double val;
 
-    while (1)
+    while (true)
     {
         try
         {
             cout << "Expression: " << flush;
+            /* Implement the parser.Parse method */
             val = parser.Parse();
             cout << "Result:     " << val << '\n' << flush;
         }

lab3-4/Makefile.dependencies

+symtab.o: symtab.cc symtab.hh string.hh ast.hh codegen.hh
+ast.o: ast.cc ast.hh symtab.hh string.hh codegen.hh
+codegen.o: codegen.cc ast.hh symtab.hh string.hh codegen.hh
+main.o: main.cc ast.hh symtab.hh string.hh codegen.hh parser.hh
+string.o: string.cc string.hh

lab3-4/ast.cc

@@ -45,7 +45,7 @@ void ASTNode::print(ostream& o)
     o << "ASTNode";
 }
 
-void ASTNode::xprint(ostream& o, char *cls)
+void ASTNode::xprint(ostream& o, const char *cls)
 {
     o << "ASTNode (" << cls << ")";
 }
@@ -228,7 +228,7 @@ void BinaryOperation::print(ostream& o)
     xprint(o, "BinaryOperation");
 }
 
-void BinaryOperation::xprint(ostream& o, char *cls)
+void BinaryOperation::xprint(ostream& o, const char *cls)
 {
     o << cls << " (left, right) ["
       << ShortSymbols << valueType << LongSymbols
@@ -241,7 +241,7 @@ void BinaryOperation::xprint(ostream& o, char *cls)
     endChild(o);
 }
 
-void Plus::print(ostream& o) { xprint(o, "Plus"); } // 
+void Plus::print(ostream& o) { xprint(o, "Plus"); } //
 void Minus::print(ostream& o) { xprint(o, "Minus"); }
 void Times::print(ostream& o) { xprint(o, "Times"); }
 void Divide::print(ostream& o) {xprint(o, "Divide"); }
@@ -293,7 +293,7 @@ void BinaryRelation::print(ostream& o)
     xprint(o, "BinaryRelation");
 }
 
-void BinaryRelation::xprint(ostream& o, char *cls)
+void BinaryRelation::xprint(ostream& o, const char *cls)
 {
     o << cls << " (left, right)\n";
     beginChild(o);
@@ -316,7 +316,7 @@ void BinaryCondition::print(ostream& o)
     xprint(o, "BinaryCondition");
 }
 
-void BinaryCondition::xprint(ostream& o, char *cls)
+void BinaryCondition::xprint(ostream& o, const char *cls)
 {
     o << cls << " (left, right)\n";
     beginChild(o);
@@ -328,7 +328,7 @@ void BinaryCondition::xprint(ostream& o, char *cls)
 }
 
 void And::print(ostream& o) { xprint(o, "And"); }
-void Or::print(ostream& o) { xprint(o, "Or"); } // 
+void Or::print(ostream& o) { xprint(o, "Or"); } //
 
 void Not::print(ostream& o)
 {

lab3-4/ast.hh

@@ -59,7 +59,7 @@ protected:
     void endChild(ostream& o);
     void lastChild(ostream& o);
     virtual void print(ostream& o);
-    virtual void xprint(ostream& o, char* cls);
+    virtual void xprint(ostream& o, const char* cls);
 
 public:
     virtual VariableInformation *GenerateCode(QuadsList &q) = 0;
@@ -318,7 +318,7 @@ class BinaryOperation :  public Expression
 {
 protected:
     virtual void print(ostream& o);
-    virtual void xprint(ostream& o, char *);
+    virtual void xprint(ostream& o, const char *);
 
 public:
     Expression          *left, *right;
@@ -480,7 +480,7 @@ class BinaryRelation :  public Condition
 {
 protected:
     virtual void print(ostream& o);
-    virtual void xprint(ostream& o, char *cls);
+    virtual void xprint(ostream& o, const char *cls);
 
 public:
     Expression      *left;
@@ -563,7 +563,7 @@ class BinaryCondition : public Condition
 {
 protected:
     virtual void print(ostream& o);
-    virtual void xprint(ostream&o, char *cls);
+    virtual void xprint(ostream&o, const char *cls);
     
 public:
     Condition *left, *right;

lab3-4/main.cc

@@ -6,14 +6,12 @@
 #include "symtab.hh"
 #include <unistd.h>
 
-using namespace std;
-
 extern int yyparse(void);
 extern int yydebug;
 extern int errorCount;
 extern int warningCount;
 
-static char *optionString = "dhc";
+static const char *OPTION_STRING = "dhc";
 
 void Usage(char *program)
 {
@@ -33,10 +31,12 @@ int main(int argc, char **argv)
 {
     int          option;
     extern FILE *yyin;
-    
-    //
-    // Set up the symbol table
-    //
+
+    /*
+     Set up the symbol table.
+     Adds builtin functions used by the language.
+     Builtin functions include routines to print reals integers etc.
+    */
 
     currentFunction = new FunctionInformation("main");
     kIntegerType    = new TypeInformation("integer", sizeof(long));
@@ -55,7 +55,7 @@ int main(int argc, char **argv)
     kIReadFunction->SetReturnType(kIntegerType);
     kFReadFunction->SetReturnType(kRealType);
     kIReadFunction->SetReturnType(kIntegerType);
-    
+
     currentFunction->AddSymbol(kIntegerType);
     currentFunction->AddSymbol(kRealType);
     currentFunction->AddSymbol(kIPrintFunction);
@@ -70,7 +70,7 @@ int main(int argc, char **argv)
 
     opterr = 0;
     optopt = '?';
-    while ((option = getopt(argc, argv, optionString)) != EOF)
+    while ((option = getopt(argc, argv, OPTION_STRING)) != EOF)
     {
         switch (option)
         {
@@ -82,13 +82,13 @@ int main(int argc, char **argv)
             break;
         case '?':
             Usage(argv[0]);
-            break;    
-	case 'c':
-	  std::cout << "/*Using standard-library*/\n";
-	  std::cout << "#include \"stl.h\"\n";
-	  SymbolInformation::outputFormat = SymbolInformation::kCFormat;
-	  currentFunction->outputFormat = SymbolInformation::kCFormat;
-	  break;
+            break;
+        case 'c':
+          std::cout << "/*Using standard-library*/\n";
+          std::cout << "#include \"stl.h\"\n";
+          SymbolInformation::outputFormat = SymbolInformation::kCFormat;
+          currentFunction->outputFormat = SymbolInformation::kCFormat;
+          break;
         }
     }
 
@@ -102,7 +102,7 @@ int main(int argc, char **argv)
         }
         optind += 1;
     }
-    
+
     if (optind < argc)
         Usage(argv[0]);
 
@@ -113,4 +113,3 @@ int main(int argc, char **argv)
     int retcode = yyparse();
     return retcode;
 }
-    

lab3-4/parser.y

@@ -7,10 +7,10 @@
 
 extern char                    *yytext;
 extern int                      yylineno, errorCount, warningCount;
-extern FunctionInformation     *currentFunction; 
+extern FunctionInformation     *currentFunction;
 
 extern int yylex(void);
-extern void yyerror(char *);
+extern void yyerror(const char *);
 extern char CheckCompatibleTypes(Expression **, Expression **);
 extern char CheckAssignmentTypes(LeftValue **, Expression **);
 extern char CheckFunctionParameters(FunctionInformation *,
@@ -45,12 +45,12 @@ extern ostream& warning(void);
     FunctionCall            *call;
     LeftValue               *lvalue;
     ElseIfList              *elseIfList;
-    
+
     VariableInformation     *variable;
     TypeInformation         *type;
     FunctionInformation     *function;
 
-  ::string                  *id;
+    ::string                  *id;
     int                      integer;
     double                   real;
     void                    *null;
@@ -81,7 +81,7 @@ extern ostream& warning(void);
  */
 
 %token FUNCTION ID DECLARE ARRAY INTEGER OF REAL XBEGIN XEND IF THEN
-%token ELSE WHILE DO ASSIGN RETURN GE LE EQ NE ARRAY TRUE FALSE PROGRAM
+%token ELSE WHILE DO ASSIGN RETURN GE LE EQ NE TRUE FALSE PROGRAM
 %token ELSEIF
 
 
@@ -184,10 +184,10 @@ functions   :   functions function
  */
 
 function :
-	{
-	  cerr << "Function here" << endl;
-	}
-	;
+        {
+          cerr << "Function here" << endl;
+        }
+        ;
 
 /* --- End your code --- */
 
@@ -249,7 +249,7 @@ type        :   id
                 else
                 {
                     typeInfo = info->SymbolAsType();
-                
+
                     if (typeInfo == NULL)
                     {
                         error() << *($1) << " is not a type" << "\n" <<flush;
@@ -299,7 +299,7 @@ statements  :   statements statement
                 if ($2 == NULL)
                     $$ = NULL;
                 else
-  		  $$ = new StatementList($1, $2);
+                  $$ = new StatementList($1, $2);
             }
             |   /* Empty */
             {
@@ -403,7 +403,7 @@ returnstmt  :   RETURN expression
                         error() << "  attempt to return "
                                 << ShortSymbols << expr->valueType << '\n';
                         error() << " in function declared to return "
-                                << ShortSymbols 
+                                << ShortSymbols
                                 << currentFunction->GetReturnType()
                                 << LongSymbols << '\n';
                         $$ = NULL;
@@ -454,13 +454,13 @@ variable    :   id
                         << *($1)
                         << "\n"
                         << flush;
-                          
+
                     $$ = NULL;
                 }
                 else
                 {
                     varInfo = info->SymbolAsVariable();
-                    
+
                     if (varInfo == NULL)
                     {
                         error()
@@ -545,7 +545,7 @@ call        :   funcname '(' expressions ')'
 
 id          :   ID
             {
-	        $$ = new ::string(yytext);
+                $$ = new ::string(yytext);
             }
             ;
 
@@ -576,13 +576,13 @@ real        :   REAL
  */
 
 expression :
-	{
-	  cerr << "Expression here" << endl;
-	}
-	;
+        {
+          cerr << "Expression here" << endl;
+        }
+        ;
 
 /* --- End your code --- */
-  
+
 
 expressions : expressionz
             {
@@ -620,10 +620,10 @@ expressionz : expressionz ',' expression
  */
 
 condition :
-	{
-	  cerr << "Condition here" << endl;
-	}
-	;
+        {
+          cerr << "Condition here" << endl;
+        }
+        ;
 
 /* --- End your code --- */
 
@@ -632,7 +632,7 @@ condition :
 
 int errorCount = 0;
 int warningCount = 0;
-            
+
 
 /* --- Your code here ---
  *
@@ -642,14 +642,14 @@ int warningCount = 0;
 /* It is reasonable to believe that you will need a function
  * that checks that two expressions are of compatible types,
  * and if possible makes a type conversion.
- * For your convenience a skeleton for such a function is 
+ * For your convenience a skeleton for such a function is
  * provided below. It will be very similar to CheckAssignmentTypes.
  */
 
 /*
  * CheckCompatibleTypes checks that the expressions indirectly pointed
  * to by left and right are compatible. If type conversion is
- * necessary, the pointers left and right point to will be modified to 
+ * necessary, the pointers left and right point to will be modified to
  * point to the node representing type conversion. That's why you have
  * to pass a pointer to pointer to Expression in these arguments.
  */
@@ -702,7 +702,7 @@ char CheckAssignmentTypes(LeftValue **left, Expression **right)
 
 /*
  * CheckFunctionParameters is used to check parameters passed to a
- * function. func is the function we're passing parameters to, formals 
+ * function. func is the function we're passing parameters to, formals
  * is a pointer to the last formal parameter we're checking against
  * and params is a pointer to the ExpressionList we're checking. If
  * type conversion is necessary, the Expressions pointed to by the
@@ -769,7 +769,7 @@ char CheckFunctionParameters(FunctionInformation *func,
                         << params->expression->valueType
                         << '\n'
                         << LongSymbols << flush;
-                return 0;                
+                return 0;
             }
         }
     }
@@ -800,7 +800,7 @@ char CheckReturnType(Expression **expr, TypeInformation *info)
 }
 
 
-void yyerror(char *message)
+void yyerror(const char *message)
 {
     error() << message << '\n' << flush;
 }

lab3-4/string.cc

@@ -73,6 +73,16 @@ string::string(char *s)
     chunk_size = 10;
 }
 
+string::string(const char *s)
+{
+    text = strdup(s);
+    if (text == NULL)
+        abort();
+    size = strlen(s) + 1;
+    position = strlen(s);
+    chunk_size = 10;
+}
+
 string::string(char c, int sz)
 {
     text = (char *)malloc(sz);

lab3-4/string.hh

@@ -20,7 +20,7 @@ using std::ostream;
 // really necessary. If strings were considered read only (no
 // destructive update), then it would be possible to keep a pool of
 // strings with reference counts and just pass along references to
-// that pool. 
+// that pool.
 //
 
 class string
@@ -34,10 +34,14 @@ private:
     void ensure_size(int);
 
 public:
+   //To kill warnings and make this custom string play nice...
+
+
     class error {};             // Exception thrown when out of memory
 
     string();                   // Default constructor creates empty string
     string(char *);             // Create string from character pointer
+    string(const char *);        // Create string from a constant character pointer
     string(char, int);          // Create string filles with characters
     string(const string &);     // Copy constructor
     string(int);                // Convert an integer
@@ -50,7 +54,7 @@ public:
     string& operator=(const string&); // Assignment operator
     string& operator=(const char *);  // Assignment operator
     string& operator=(const char);    // Assignment operator
-    
+
     string& operator+=(const string&); // Append operator
     string& operator+=(const char);    // Append operator
     string& operator+=(const char *);  // Append operator

lab3-4/symtab.cc

@@ -44,7 +44,7 @@ ostream& SymbolInformation::print(ostream& o)
         break;
     case kCFormat:
         o << id;
-        break;		
+        break;
     default:
         o << "Bad output format\n";
         abort();
@@ -80,10 +80,10 @@ ostream& TypeInformation::print(ostream& o)
         {
             o << id;
         }
-        
+
         o << " [" << size << "]";
         break;
-        
+
     case kShortFormat:
         if (elementType != NULL)
         {
@@ -103,7 +103,7 @@ ostream& TypeInformation::print(ostream& o)
         }
         else
         {
-	  o << id;
+          o << id;
         }
         break;
 
@@ -200,21 +200,21 @@ ostream& FunctionInformation::print(ostream& o)
                 tmp = tmp->prev;
             }
             o << LongSymbols;
-	    o << '\n';
+            o << '\n';
         }
         else
         {
             o << "  Locals: none\n";
         }
-        
+
         o << "  Body:  " << (void*)body << '\n';
         if (body) o << body;
-	o << '\n';
-	
+        o << '\n';
+
         o << "  Quads: " << (void*)quads << '\n';
         if (quads) o << quads;
         o << '\n';
-        
+
         o << symbolTable;
         break;
 
@@ -240,59 +240,59 @@ ostream& FunctionInformation::print(ostream& o)
         break;
 
     case kCFormat:
-      	/*C-Code preamble*/
-	if (returnType == NULL) {
-	  o << "void\n";
-	} else {
-	  o << returnType << "\n";
-	}
-	    
-	o << "" << id << "(";
-	//Parameters
-	if (lastParam != NULL)
+        /*C-Code preamble*/
+        if (returnType == NULL) {
+          o << "void\n";
+        } else {
+          o << returnType << "\n";
+        }
+
+        o << "" << id << "(";
+        //Parameters
+        if (lastParam != NULL)
         {
             tmp = lastParam;
             while (tmp != NULL)
             {
-	      if (tmp->type->elementType != NULL){ //Array... 
-		o << tmp->type->elementType << "*" << "\t";
-	      } else {
-		//		o << tmp->type->elementType;
-		o << tmp->type << "\t";
-	      }
-	      if (tmp->prev == NULL) {
-		o << tmp->id;
-	      } else {
-		o << tmp->id << ",";
-	      }
-	      tmp = tmp->prev;
+              if (tmp->type->elementType != NULL){ //Array...
+                o << tmp->type->elementType << "*" << "\t";
+              } else {
+                //              o << tmp->type->elementType;
+                o << tmp->type << "\t";
+              }
+              if (tmp->prev == NULL) {
+                o << tmp->id;
+              } else {
+                o << tmp->id << ",";
+              }
+              tmp = tmp->prev;
             }
         }
-	o << ")\n";
-	/* Generate C-Code for the body! */
-	o << "{\n";
-	if (lastLocal)
+        o << ")\n";
+        /* Generate C-Code for the body! */
+        o << "{\n";
+        if (lastLocal)
         {
-	  o << "//Locals:\n";
+          o << "//Locals:\n";
             tmp = lastLocal;
             while (tmp != NULL)
             {
-	      if (tmp->type->elementType != NULL){ //Array...
-		o << tmp->type->elementType;
-		o << "\t";
-		o << tmp;
-		o << tmp->type << ";\n";
-	      }
-	      else {
-		o << tmp->type << "\t" << tmp << ";\n";
-	      }
-	      tmp = tmp->prev;
+              if (tmp->type->elementType != NULL){ //Array...
+                o << tmp->type->elementType;
+                o << "\t";
+                o << tmp;
+                o << tmp->type << ";\n";
+              }
+              else {
+                o << tmp->type << "\t" << tmp << ";\n";
+              }
+              tmp = tmp->prev;
             }
         }
-	quads->print_c(o);
-	o << "}\n";
-	break;
-        
+        quads->print_c(o);
+        o << "}\n";
+        break;
+
     default:
         o << "Bad output format.\n";
         abort();
@@ -397,7 +397,7 @@ TypeInformation *FunctionInformation::AddArrayType(TypeInformation *elemType,
     else
     {
 
-        name = elemType->id + "<" + dimensions + ">.";
+        name =  elemType->id + (char*)"<" + dimensions + (char*)">.";
         xinfo = symbolTable.LookupSymbol(name);
         if (xinfo == NULL)
         {
@@ -430,14 +430,14 @@ FunctionInformation *FunctionInformation::AddFunction(const ::string& name,
     if (xinfo != NULL && xinfo->tag == kTypeInformation)
     {
         cerr << "Bug: you tried to create a function that's also a type\n";
-	abort();
+        abort();
     }
 
     xinfo = symbolTable.LookupSymbol(name);
     if (xinfo != NULL)
     {
         cerr << "Bug: you tried to create a function with a name "
-	     << "that's already in use\n";
+             << "that's already in use\n";
     }
 
     fn->id = name;
@@ -458,7 +458,7 @@ VariableInformation *FunctionInformation::TemporaryVariable(TypeInformation *typ
 
     return info;
 }
-                                                      
+
 
 char FunctionInformation::OkToAddSymbol(const ::string& name)
 {

lab3-4/symtab.hh

@@ -91,7 +91,7 @@ protected:
     friend class SymbolTable;
     friend ostream& LongSymbols(ostream&);
     friend ostream& SummarySymbols(ostream&);
-    friend ostream& ShortSymbols(ostream&);        
+    friend ostream& ShortSymbols(ostream&);
 public:
     typedef enum { kFullFormat, kSummaryFormat, kShortFormat, kCFormat } tFormatType;
     static tFormatType outputFormat;
@@ -100,8 +100,8 @@ public:
     SymbolTable                *table;
 
     SymbolInformation(SymbolInformationType t, const ::string &i) :
-        tag(t),
-        id(i) {};
+	tag(t),
+	id(i) {};
     virtual ~SymbolInformation() {}
 
     virtual FunctionInformation *SymbolAsFunction(void) { return NULL; };
@@ -141,13 +141,13 @@ private:
 public:
 
     FunctionInformation(const ::string& i) :
-        SymbolInformation(kFunctionInformation, i),
-        parent(NULL),
-        returnType(NULL),
-        lastParam(NULL),
-        lastLocal(NULL),
-        body(NULL),
-        quads(NULL) {};
+	SymbolInformation(kFunctionInformation, i),
+	parent(NULL),
+	returnType(NULL),
+	lastParam(NULL),
+	lastLocal(NULL),
+	body(NULL),
+	quads(NULL) {};
 
     virtual FunctionInformation *SymbolAsFunction(void) { return this; };
 
@@ -164,7 +164,7 @@ public:
 
     FunctionInformation *AddFunction(const ::string&, FunctionInformation *);
     VariableInformation *AddParameter(const ::string&, TypeInformation *);
-   VariableInformation *AddVariable(const ::string&, TypeInformation *);
+    VariableInformation *AddVariable(const ::string&, TypeInformation *);
     SymbolInformation   *AddSymbol(SymbolInformation *);
     TypeInformation     *AddArrayType(TypeInformation *, int);
 
@@ -197,10 +197,10 @@ public:
     virtual VariableInformation *SymbolAsVariable(void) { return this; };
 
     VariableInformation(const ::string& i) :
-        SymbolInformation(kVariableInformation, i) {};
+	SymbolInformation(kVariableInformation, i) {};
     VariableInformation(const ::string& i, TypeInformation *t) :
-        SymbolInformation(kVariableInformation, i),
-        type(t) {};
+	SymbolInformation(kVariableInformation, i),
+	type(t) {};
 
 };
 
@@ -220,8 +220,8 @@ public:
     virtual TypeInformation     *SymbolAsType(void)      { return this; };
 
     TypeInformation(const ::string& i, unsigned long s) :
-        SymbolInformation(kTypeInformation, i),
-        size(s) {};
+	SymbolInformation(kTypeInformation, i),
+	size(s) {};
 };