First commit

Author: nyeap96

CMPS 104A.zip

@@ -0,0 +1,52 @@
+COMPILECPP 	= g++ -std=gnu++17 -g -O0 -Wall -Wextra
+FLEX 			= flex --outfile=${CLGEN}
+
+BISON			= bison --defines=${HYGEN} \
+				  --output=${CYGEN}
+
+EXECBIN		= oc
+SOURCES		= astree.cpp lyutils.cpp \
+				  string_set.cpp auxlib.cpp \
+				  symtable.cpp attr_bitset.cpp \
+				  oiler.cpp main.cpp
+ALLSOURCES  = ${SOURCES} ${CLGEN} ${CYGEN}
+HEADERS     = astree.h lyutils.h string_set.h auxlib.h \
+				  symtable.h attr_bitset.h oiler.h
+LSOURCES		= scanner.l
+CLGEN			= yylex.cpp
+YSOURCES  	= parser.y
+HYGEN 		= yyparse.h
+CYGEN 		= yyparse.cpp
+
+OBJECTS		= ${ALLSOURCES:.cpp=.o}
+	MAKEFILE 	= Makefile
+
+all : ${EXECBIN}
+
+
+${EXECBIN} : ${CYGEN} ${HYGEN} ${OBJECTS}
+	${COMPILECPP} -o ${EXECBIN} ${OBJECTS}
+
+%.o : %.cpp
+	#checksource ${SOURCES}
+	${COMPILECPP} -c $<
+
+yylex.o : yylex.cpp
+	g++ -std=gnu++14 -g -O0 -c $<
+
+${CLGEN}	: ${LSOURCES}
+	${FLEX} ${LSOURCES}
+
+${CYGEN} ${HYGEN} : ${YSOURCES}
+	${BISON} ${YSOURCES}
+
+clean		:
+	rm -f ${CLGEN} ${CYGEN} ${HYGEN} ${DEPFILE} \
+		*.output *.o *.out *.err *.str *.tok *.ast *.sym \
+		*.oil
+
+spotless    :
+	${MAKE} clean; rm -f ${EXECBIN}
+
+ci	:
+

Makefile

@@ -0,0 +1,48 @@
+This program is a quarter long project in which my partner and i wrote a 3 code language called "oc"
+through a combination of C++, Flex, and Bison. The included files were written using pair programming
+containing code from the both of us. The Makefile was not written by us and was provided by the professor
+the code written by us are contained in the following files
+
+astree.h
+astree.c
+parser.y
+scanner.l
+string_set.h
+string_set.c
+symtable.h
+symtable.c
+oiler.h
+oiler.c
+
+all other files were provided by the professor.
+included in the zip is a very very brief writeup of the project
+i submitted for my senior portfolio
+
+
+
+
+
+
+
+
+This program was completed using pair programming.
+Partner:  Nelson Yeap ([email protected])
+Partner:  Chenxing Ji ([email protected])
+
+We acknowledge that each partner in a programming pair should
+drive roughly 50% of the time the pair is working together, and
+at most 25% of an individual's effort for an assignment should
+be spent working alone.  Any work done by a solitary programmer
+must be reviewed by the partner.  The object is to work
+together, learning from each other, not to divide the work into
+two pieces with each partner working on a different piece.
+
+Nelson Yeap spent       0 hours working alone.
+Chenxing Ji spent       0 hours working alone.
+We spent                50 hours working together.
+Nelson Yeap spent       25 hours driving.
+Chenxing Ji spent       25 hours driving.
+
+Please grade the work submitted by [email protected]
+and not the work submitted by [email protected].
+

README

@@ -0,0 +1,139 @@
+// $Id: astree.cpp,v 1.9 2017-10-04 15:59:50-07 - - $
+// Chenxing Ji
+// cji13
+// Nelson Yeap
+// nyeap
+
+#include <assert.h>
+#include <inttypes.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+//#include "attr_bitset.h"
+#include "astree.h"
+#include "string_set.h"
+#include "lyutils.h"
+#include "symtable.h"
+
+astree::astree (int symbol_, const location& lloc_, const char* info) {
+   symbol = symbol_;
+   lloc = lloc_;
+   lexinfo = string_set::intern (info);
+   // vector defaults to empty -- no children
+}
+
+astree::~astree() {
+   while (not children.empty()) {
+      astree* child = children.back();
+      children.pop_back();
+      delete child;
+   }
+   if (yydebug) {
+      fprintf (stderr, "Deleting astree (");
+      astree::dump (stderr, this);
+      fprintf (stderr, ")\n");
+   }
+}
+
+astree* astree::adopt (astree* child1, astree* child2) {
+   if (child1 != nullptr) children.push_back (child1);
+   if (child2 != nullptr) children.push_back (child2);
+   return this;
+}
+
+astree* astree::adopt_sym (astree* child, int symbol_) {
+   symbol = symbol_;
+   return adopt (child);
+}
+
+void astree::dump_node (FILE* outfile) {
+   char *tok_name = strdup(parser::get_tname(symbol));
+   if (strstr(tok_name, "TOK_") == tok_name)
+      tok_name += 4;
+   //printf("%s\n", to_string_array(attribute).c_str());
+   //fprintf(outfile,"{%zu}", block_count);
+   fprintf(outfile, "%s \"%s\" (%zu.%zu.%zu) {%zu} ",
+         tok_name, lexinfo->c_str(),lloc.filenr, lloc.linenr,
+         lloc.offset, block_num);
+   if(attribute[static_cast<unsigned>(attr::STRUCT)]){
+      //fprintf(outfile,"struct ");
+      fprintf(outfile, "struct \"%s\" ", struct_name->c_str());
+   }
+   fprintf(outfile, "%s", to_string_array(attribute).c_str());
+   //fprintf(
+   if(decl_lloc.linenr == 0){
+      fprintf(outfile,"\n");
+   }else{
+      fprintf(outfile, " (%zd.%zd.%zd)\n", decl_lloc.filenr,
+            decl_lloc.linenr, decl_lloc.offset);
+   }
+}
+
+void astree::dump_tree (FILE* outfile, int depth) {
+   for(int i = 0; i < depth; i++){
+      if(depth == 0)
+         break;
+      else{
+         fprintf(outfile, "%s", "|  ");
+      }
+   }
+   dump_node (outfile);
+   //fprintf (outfile, "\n");
+   for (astree* child: children) child->dump_tree (outfile, depth + 1);
+   fflush (nullptr);
+}
+
+void astree::dump (FILE* outfile, astree* tree) {
+   if (tree == nullptr) fprintf (outfile, "nullptr");
+                   else tree->dump_tree (outfile, 0);
+}
+
+
+void astree::print (FILE* outfile, astree* tree, int depth) {
+   fprintf (outfile, "; %*s", depth * 3, "");
+   fprintf (outfile, "%s \"%s\" (%zd.%zd.%zd) {%zu} %s",
+            parser::get_tname (tree->symbol), tree->lexinfo->c_str(),
+            tree->lloc.filenr, tree->lloc.linenr, tree->lloc.offset,
+            tree->block_num, to_string_array(tree->attribute).c_str());
+   if(tree->decl_lloc.linenr == 0){
+      //printf("Not a declared ident yet\n");
+      fprintf(outfile, "\n");
+   }else{
+      //printf("Existed symbol\n");
+      fprintf(outfile, " (%zd.%zd.%zd)\n", tree->decl_lloc.filenr, \
+            tree->decl_lloc.linenr, tree->decl_lloc.offset);
+   }
+   for (astree* child: tree->children) {
+      astree::print (outfile, child, depth + 1);
+   }
+}
+
+void destroy (astree* tree1, astree* tree2) {
+   if (tree1 != nullptr) {
+      while(tree1->children.size() != 0){
+         tree1->children.pop_back();
+         destroy(tree1);
+      }
+      delete tree1;
+   }
+   if (tree2 != nullptr) {
+      while(tree2->children.size() != 0){
+         tree2->children.pop_back();
+         destroy(tree2);
+      }
+      delete tree2;
+   }
+}
+
+void errllocprintf (const location& lloc, const char* format,
+                    const char* arg) {
+   static char buffer[0x1000];
+   assert (sizeof buffer > strlen (format) + strlen (arg));
+   snprintf (buffer, sizeof buffer, format, arg);
+   errprintf ("%s:%zd.%zd: %s", 
+              lexer::filename (lloc.filenr), lloc.linenr, lloc.offset,
+              buffer);
+}
+
+

asg1-stringset.pdf

@@ -0,0 +1,55 @@
+// $Id: astree.h,v 1.7 2016-10-06 16:13:39-07 - - $
+// Chenxing Ji
+// cji13
+// Nelson Yeap
+// nyeap
+
+#ifndef __ASTREE_H__
+#define __ASTREE_H__
+
+#include <string>
+#include <vector>
+//#include <bitset>
+//#include "auxlib.h"
+//#include "symtable.h"
+#include <unordered_map>
+#include "attr_bitset.h"
+using namespace std;
+
+struct location {
+   size_t filenr;
+   size_t linenr;
+   size_t offset;
+};
+
+struct astree {
+
+   // Fields.
+   int symbol;               // token code
+   location lloc;            // source location
+   location decl_lloc;       // symbol declared location 
+   const string* lexinfo;    // pointer to lexical information
+   vector<astree*> children; // children of this n-way node
+   attr_bitset attribute;
+   size_t block_num;
+   size_t block_count;
+   const string* struct_name; //parent struct name
+   //symbol_table* struct_table;
+   
+   // Functions.
+   astree (int symbol, const location&, const char* lexinfo);
+   ~astree();
+   astree* adopt (astree* child1, astree* child2 = nullptr);
+   astree* adopt_sym (astree* child, int symbol);
+   void dump_node (FILE*);
+   void dump_tree (FILE*, int depth = 0);
+   static void dump (FILE* outfile, astree* tree);
+   static void print (FILE* outfile, astree* tree, int depth = 0);
+};
+
+void destroy (astree* tree1, astree* tree2 = nullptr);
+
+void errllocprintf (const location&, const char* format, const char*);
+
+#endif
+

astree.cpp

@@ -0,0 +1,44 @@
+#include <unordered_map>
+#include <bitset>
+#include <string>
+#include <iostream>
+#include "attr_bitset.h"
+using namespace std;
+const string attr_to_string (int i) {
+
+   static const unordered_map<int,string> hash {
+      {0       , "void "       },
+      {1       , "int "        },
+      {2       , "null "       },
+      {3       , "string "     },
+      {4       , ""            },
+      {5       , "array "      },
+      {6       , "function "   },
+      {7       , "variable "   },
+      {8       , "field "      },
+      {9       , "typeid "     },
+      {10      , "lval "       },
+      {11      , "local "      },
+      {12      , "param "      },
+      {13      , "const "      },
+      {14      , "vreg "       },
+      {15      , "vaddr "      },
+      {16      , "char "       },
+      {17      , "bitset_size "}
+   };
+   auto str = hash.find (i);
+   if (str == hash.end()) throw invalid_argument (__PRETTY_FUNCTION__);
+   return str->second;
+   //return store;
+}
+const string to_string_array(attr_bitset attributes){
+   string store;
+   //string temp = attributes.to_string();
+   for (size_t i = 0; i < attributes.size(); ++i)
+   {
+      if(attributes[i]){
+         store.append(attr_to_string(i));
+      }
+   }
+   return store;
+}

astree.h

@@ -0,0 +1,21 @@
+#ifndef __ATTR_BITSET_H__
+#define __ATTR_BITSET_H__
+
+#include <string>
+#include <vector>
+#include <bitset>
+#include <string>
+#include <iostream>
+#include <unordered_map>
+using namespace std;
+
+enum class attr{
+       VOID, INT, NULLX, STRING, STRUCT, ARRAY, FUNCTION, VARIABLE,
+       FIELD, TYPEID, LVAL, LOCAL, PARAM, CONST, VREG, VADDR, CHAR, 
+       BITSET_SIZE,
+};
+
+using attr_bitset = bitset<unsigned(attr::BITSET_SIZE)>;
+const string attr_to_string (int i);
+const string to_string_array(attr_bitset attributes);
+#endif