[CI/PA2] Added initial setup with a rough grammar

34 files changed, 2630 insertions, 1 deletions

diff --git a/Year 3/Compilers, Introduction/coolc-spim/docker-container/Dockerfile b/Year 3/Compilers, Introduction/coolc-spim/docker-container/Dockerfile
index b8d93e6..606a380 100644
--- a/Year 3/Compilers, Introduction/coolc-spim/docker-container/Dockerfile
+++ b/Year 3/Compilers, Introduction/coolc-spim/docker-container/Dockerfile
@@ -4,7 +4,7 @@ RUN apt-get update && \
     apt-get upgrade -y && \
     apt-get clean
 
-RUN apt install vim spim build-essential csh flex -y
+RUN apt install vim spim build-essential csh flex bison -y
 
 RUN mkdir /usr/class
 RUN mkdir /usr/code
diff --git a/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/1.cl b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/1.cl
new file mode 100644
index 0000000..4ee157d
--- /dev/null
+++ b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/1.cl
@@ -0,0 +1 @@
+class Main { main(): Int { 1 }; };
diff --git a/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/Makefile b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/Makefile
new file mode 100644
index 0000000..c590776
--- /dev/null
+++ b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/Makefile
@@ -0,0 +1,89 @@
+
+ASSN = 3
+CLASS= cs143
+CLASSDIR= /usr/class/cs143/cool
+LIB= /lib/x86_64-linux-gnu/libfl.a
+AR= gar
+ARCHIVE_NEW= -cr
+RANLIB= gar -qs
+
+SRC= cool.y cool-tree.handcode.h good.cl bad.cl README
+CSRC= parser-phase.cc utilities.cc stringtab.cc dumptype.cc \
+      tree.cc cool-tree.cc tokens-lex.cc  handle_flags.cc 
+TSRC= myparser mycoolc cool-tree.aps
+CGEN= cool-parse.cc
+HGEN= cool-parse.h
+LIBS= lexer semant cgen
+CFIL= ${CSRC} ${CGEN}
+HFIL= cool-tree.h cool-tree.handcode.h 
+LSRC= Makefile
+OBJS= ${CFIL:.cc=.o}
+OUTPUT= good.output bad.output
+
+
+CPPINCLUDE= -I. -I${CLASSDIR}/include/PA${ASSN} -I${CLASSDIR}/src/PA${ASSN}
+
+BFLAGS = -d -v -y -b cool --debug -p cool_yy
+
+CC=g++
+CFLAGS=-g -Wall -Wno-unused -Wno-deprecated -Wno-write-strings -DDEBUG ${CPPINCLUDE}
+FLEX=flex ${FFLAGS}
+BISON= bison ${BFLAGS}
+DEPEND = ${CC} -MM ${CPPINCLUDE}
+
+source: ${SRC} ${TSRC} ${LIBS} lsource
+
+lsource: ${LSRC}
+
+${OUTPUT}:	parser good.cl bad.cl
+	@rm -f ${OUTPUT}
+	./myparser good.cl >good.output 2>&1 
+	-./myparser bad.cl >bad.output 2>&1 
+
+parser: ${OBJS}
+	${CC} ${CFLAGS} ${OBJS} ${LIB} -o parser
+
+.cc.o:
+	${CC} ${CFLAGS} -c $<
+
+cool-parse.cc cool-parse.h: cool.y
+	bison ${BFLAGS} cool.y
+	mv -f cool.tab.c cool-parse.cc
+
+dotest:	parser good.cl bad.cl
+	@echo "\nRunning parser on good.cl\n"
+	-./myparser good.cl 
+	@echo "\nRunning parser on bad.cl\n"
+	-./myparser bad.cl
+
+${LIBS}:
+	${CLASSDIR}/etc/link-object ${ASSN} $@
+
+# These dependencies allow you to get the starting files for
+# the assignment.  They will not overwrite a file you already have.
+
+${SRC} :								
+	-${CLASSDIR}/etc/copy-skel ${ASSN} ${SRC}
+
+${LSRC} :
+	-${CLASSDIR}/etc/link-shared ${ASSN} ${LSRC}
+
+${TSRC} ${CSRC}:
+	-ln -s ${CLASSDIR}/src/PA${ASSN}/$@ $@
+
+${HSRC}:
+	-ln -s ${CLASSDIR}/include/PA${ASSN}/$@ $@
+
+submit-clean: ${OUTPUT}
+	-rm -f *.s core ${OBJS} ${CGEN} ${HGEN} lexer *~ parser cgen semant
+
+clean :
+	-rm -f ${OUTPUT} *.s core ${OBJS} ${CGEN} ${HGEN} lexer parser cgen semant *~ *.a *.o 
+
+clean-compile:
+	@-rm -f core ${OBJS} ${CGEN} ${HGEN} ${LSRC}
+
+%.d: %.cc ${LSRC}
+	${SHELL} -ec '${DEPEND} $< | sed '\''s/\($*\.o\)[ :]*/\1 $@ : /g'\'' > $@'
+
+-include ${CFIL:.cc=.d}
diff --git a/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/README b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/README
new file mode 100644
index 0000000..f72ab40
--- /dev/null
+++ b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/README
@@ -0,0 +1,117 @@
+README file for Programming Assignment 3 (C++ edition)
+======================================================
+
+Your directory should now contain the following files:
+
+ Makefile		  -> [course dir]/src/PA3/Makefile
+ README
+ cool.y
+ bad.cl
+ good.cl
+ cool-tree.handcode.h
+ cool-tree.cc		  -> [course dir]/src/PA3/cool-tree.cc
+ cool-tree.aps		  -> [course dir]/src/PA3/cool-tree.aps
+ dumptype.cc		  -> [course dir]/src/PA3/dumptype.cc
+ handle_flags.c           -> [course dir]/src/PA3/handle_flags.cc
+ parser-phase.cc	  -> [course dir]/src/PA3/parser-phase.cc
+ stringtab.cc		  -> [course dir]/src/PA3/stringtab.cc
+ tokens-lex.cc		  -> [course dir]/src/PA3/tokens-lex.cc
+ tree.cc		  -> [course dir]/src/PA3/tree.cc
+ utilities.cc		  -> [course dir]/src/PA3/utilities.cc
+ *.d			  dependency files
+ *.*			  other generated files
+
+The include (.h) files for this assignment can be found in 
+[course dir]/include/PA3
+
+	The Makefile contains targets for compiling and running your
+	program. DO NOT MODIFY.
+    
+	cool.y is the skeleton for the parser specification that you
+	are to write. It already contains productions for the program
+	and the classes. Use them as an example to write the remaining
+	productions.  You should also read the bison documentation.
+	This skeleton will compile and run as is, but it doesn't
+	do much.
+
+	good.cl, bad.cl test a few features of the grammar. You should
+	add tests to ensure that good.cl exercises every legal
+	construction of the grammar and that bad.cl exercises as many
+	different parsing errors as you can squeeze into one file.
+
+	cool-tree.aps contains the definitions for the tree language
+	which you use to construct the abstract syntax tree (AST).
+	From this file, cool-tree.h and cool-tree.cc are automatically 
+        generated by a utility that compiles the specification into
+        C++ functions for producing and consuming the tree nodes.
+        This file is provided for your reference.  DO NOT MODIFY.
+
+        tree.{cc|h} contain definitions used by the tree package.
+        cool-tree.handcode.h is the handwritten extension to
+        cool-tree.h.  If you read cool-tree.h and cool-tree.cc, you will
+        note that there are "hooks" for extending the classes
+        declarations.  Extending and modifying the tree package is
+        discussed in the "Cool Tour", but you do not need to (and should
+        not) modify the tree package for this assignment.
+
+	tokens-lex.cc is a lexer capable of reading a token stream from
+	console in the format produced by the lexer phase. DO NOT
+	MODIFY.
+
+        parser-phase.cc contains a driver to test the parser. DO NOT
+        MODIFY.
+
+	dumptype.cc prints the AST out in a form readable by the
+	semant phase of the compiler. DO NOT MODIFY.
+
+	handle_flags.cc implements routines for parsing command line
+        flags. DO NOT MODIFY.
+
+        The rest of the files are created as byproducts of `bison'.
+        `cool-parse.cc' is the generated C++ file containing the
+        parser.
+
+	Files not discussed are covered in the README for PA2.
+
+Instructions
+------------
+
+	To compile your parser program type:
+
+	% make parser
+
+	This produces an executable named "parser" which is standalone
+	phase of the Cool compiler.  It requires lexer, semant, and cgen
+	to do anything useful.
+
+	To test your parser on a file 'foo.cl' type
+
+	% myparser foo.cl
+
+	myparser is a shell script that "glues" together lexer and
+	parser using pipes.
+
+	To run your parser on the files good.cl and bad.cl type:
+
+	% make dotest
+
+	To run the (provided) lexer and your parser on a file called test.cl type:
+
+	% ./lexer test.cl | ./parser
+
+	If you think your parser is correct and behaves like
+	the one we wrote, you may want to run a COOL compiler using
+	your parser:
+
+	% mycoolc foo.cl
+
+	To overwrite the default lexical analyzer with yours, replace 
+	lexer (which is a symbolic link to the "official" lexer) with
+        your lexer from PA2.
+
+
+        Instructions for turning in the assignment will be posted on the
+        course web page.
+
+        GOOD LUCK!
+
diff --git a/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/bad.cl b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/bad.cl
new file mode 100644
index 0000000..c7102a2
--- /dev/null
+++ b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/bad.cl
@@ -0,0 +1,29 @@
+
+(*
+ *  execute "coolc bad.cl" to see the error messages that the coolc parser
+ *  generates
+ *
+ *  execute "myparser bad.cl" to see the error messages that your parser
+ *  generates
+ *)
+
+(* no error *)
+class A {
+};
+
+(* error:  b is not a type identifier *)
+Class b inherits A {
+};
+
+(* error:  a is not a type identifier *)
+Class C inherits a {
+};
+
+(* error:  keyword inherits is misspelled *)
+Class D inherts A {
+};
+
+(* error:  closing brace is missing *)
+Class E inherits A {
+;
+
diff --git a/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/cgen b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/cgen
new file mode 120000
index 0000000..24473d8
--- /dev/null
+++ b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/cgen
@@ -0,0 +1 @@
+/usr/class/cs143/cool/etc/../lib/.i686/PA3/cgen
\ No newline at end of file
diff --git a/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/cool-parse.cc b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/cool-parse.cc
new file mode 100644
index 0000000..00d6e28
--- /dev/null
+++ b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/cool-parse.cc
@@ -0,0 +1,1552 @@
+/* A Bison parser, made by GNU Bison 3.8.2.  */
+
+/* Bison implementation for Yacc-like parsers in C
+
+   Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software Foundation,
+   Inc.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
+
+/* As a special exception, you may create a larger work that contains
+   part or all of the Bison parser skeleton and distribute that work
+   under terms of your choice, so long as that work isn't itself a
+   parser generator using the skeleton or a modified version thereof
+   as a parser skeleton.  Alternatively, if you modify or redistribute
+   the parser skeleton itself, you may (at your option) remove this
+   special exception, which will cause the skeleton and the resulting
+   Bison output files to be licensed under the GNU General Public
+   License without this special exception.
+
+   This special exception was added by the Free Software Foundation in
+   version 2.2 of Bison.  */
+
+/* C LALR(1) parser skeleton written by Richard Stallman, by
+   simplifying the original so-called "semantic" parser.  */
+
+/* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual,
+   especially those whose name start with YY_ or yy_.  They are
+   private implementation details that can be changed or removed.  */
+
+/* All symbols defined below should begin with yy or YY, to avoid
+   infringing on user name space.  This should be done even for local
+   variables, as they might otherwise be expanded by user macros.
+   There are some unavoidable exceptions within include files to
+   define necessary library symbols; they are noted "INFRINGES ON
+   USER NAME SPACE" below.  */
+
+/* Identify Bison output, and Bison version.  */
+#define YYBISON 30802
+
+/* Bison version string.  */
+#define YYBISON_VERSION "3.8.2"
+
+/* Skeleton name.  */
+#define YYSKELETON_NAME "yacc.c"
+
+/* Pure parsers.  */
+#define YYPURE 0
+
+/* Push parsers.  */
+#define YYPUSH 0
+
+/* Pull parsers.  */
+#define YYPULL 1
+
+
+/* Substitute the variable and function names.  */
+#define yyparse         cool_yyparse
+#define yylex           cool_yylex
+#define yyerror         cool_yyerror
+#define yydebug         cool_yydebug
+#define yynerrs         cool_yynerrs
+#define yylval          cool_yylval
+#define yychar          cool_yychar
+#define yylloc          cool_yylloc
+
+/* First part of user prologue.  */
+#line 6 "cool.y"
+
+  #include <iostream>
+  #include "cool-tree.h"
+  #include "stringtab.h"
+  #include "utilities.h"
+  
+  extern char *curr_filename;
+  
+  
+  /* Locations */
+  #define YYLTYPE int              /* the type of locations */
+  #define cool_yylloc curr_lineno  /* use the curr_lineno from the lexer
+  for the location of tokens */
+    
+    extern int node_lineno;          /* set before constructing a tree node
+    to whatever you want the line number
+    for the tree node to be */
+      
+      
+      #define YYLLOC_DEFAULT(Current, Rhs, N)         \
+      Current = Rhs[1];                             \
+      node_lineno = Current;
+    
+    
+    #define SET_NODELOC(Current)  \
+    node_lineno = Current;
+    
+    /* IMPORTANT NOTE ON LINE NUMBERS
+    *********************************
+    * The above definitions and macros cause every terminal in your grammar to 
+    * have the line number supplied by the lexer. The only task you have to
+    * implement for line numbers to work correctly, is to use SET_NODELOC()
+    * before constructing any constructs from non-terminals in your grammar.
+    * Example: Consider you are matching on the following very restrictive 
+    * (fictional) construct that matches a plus between two integer constants. 
+    * (SUCH A RULE SHOULD NOT BE  PART OF YOUR PARSER):
+    
+    plus_consts	: INT_CONST '+' INT_CONST 
+    
+    * where INT_CONST is a terminal for an integer constant. Now, a correct
+    * action for this rule that attaches the correct line number to plus_const
+    * would look like the following:
+    
+    plus_consts	: INT_CONST '+' INT_CONST 
+    {
+      // Set the line number of the current non-terminal:
+      // ***********************************************
+      // You can access the line numbers of the i'th item with @i, just
+      // like you acess the value of the i'th exporession with $i.
+      //
+      // Here, we choose the line number of the last INT_CONST (@3) as the
+      // line number of the resulting expression (@$). You are free to pick
+      // any reasonable line as the line number of non-terminals. If you 
+      // omit the statement @$=..., bison has default rules for deciding which 
+      // line number to use. Check the manual for details if you are interested.
+      @$ = @3;
+      
+      
+      // Observe that we call SET_NODELOC(@3); this will set the global variable
+      // node_lineno to @3. Since the constructor call "plus" uses the value of 
+      // this global, the plus node will now have the correct line number.
+      SET_NODELOC(@3);
+      
+      // construct the result node:
+      $$ = plus(int_const($1), int_const($3));
+    }
+    
+    */
+    
+    
+    
+    void yyerror(char *s);        /*  defined below; called for each parse error */
+    extern int yylex();           /*  the entry point to the lexer  */
+    
+    /************************************************************************/
+    /*                DONT CHANGE ANYTHING IN THIS SECTION                  */
+    
+    Program ast_root;	      /* the result of the parse  */
+    Classes parse_results;        /* for use in semantic analysis */
+    int omerrs = 0;               /* number of errors in lexing and parsing */
+    
+
+#line 162 "cool.tab.c"
+
+# ifndef YY_CAST
+#  ifdef __cplusplus
+#   define YY_CAST(Type, Val) static_cast<Type> (Val)
+#   define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val)
+#  else
+#   define YY_CAST(Type, Val) ((Type) (Val))
+#   define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val))
+#  endif
+# endif
+# ifndef YY_NULLPTR
+#  if defined __cplusplus
+#   if 201103L <= __cplusplus
+#    define YY_NULLPTR nullptr
+#   else
+#    define YY_NULLPTR 0
+#   endif
+#  else
+#   define YY_NULLPTR ((void*)0)
+#  endif
+# endif
+
+#include "cool.tab.h"
+/* Symbol kind.  */
+enum yysymbol_kind_t
+{
+  YYSYMBOL_YYEMPTY = -2,
+  YYSYMBOL_YYEOF = 0,                      /* "end of file"  */
+  YYSYMBOL_YYerror = 1,                    /* error  */
+  YYSYMBOL_YYUNDEF = 2,                    /* "invalid token"  */
+  YYSYMBOL_CLASS = 3,                      /* CLASS  */
+  YYSYMBOL_ELSE = 4,                       /* ELSE  */
+  YYSYMBOL_FI = 5,                         /* FI  */
+  YYSYMBOL_IF = 6,                         /* IF  */
+  YYSYMBOL_IN = 7,                         /* IN  */
+  YYSYMBOL_INHERITS = 8,                   /* INHERITS  */
+  YYSYMBOL_LET = 9,                        /* LET  */
+  YYSYMBOL_LOOP = 10,                      /* LOOP  */
+  YYSYMBOL_POOL = 11,                      /* POOL  */
+  YYSYMBOL_THEN = 12,                      /* THEN  */
+  YYSYMBOL_WHILE = 13,                     /* WHILE  */
+  YYSYMBOL_CASE = 14,                      /* CASE  */
+  YYSYMBOL_ESAC = 15,                      /* ESAC  */
+  YYSYMBOL_OF = 16,                        /* OF  */
+  YYSYMBOL_DARROW = 17,                    /* DARROW  */
+  YYSYMBOL_NEW = 18,                       /* NEW  */
+  YYSYMBOL_ISVOID = 19,                    /* ISVOID  */
+  YYSYMBOL_STR_CONST = 20,                 /* STR_CONST  */
+  YYSYMBOL_INT_CONST = 21,                 /* INT_CONST  */
+  YYSYMBOL_BOOL_CONST = 22,                /* BOOL_CONST  */
+  YYSYMBOL_TYPEID = 23,                    /* TYPEID  */
+  YYSYMBOL_OBJECTID = 24,                  /* OBJECTID  */
+  YYSYMBOL_ASSIGN = 25,                    /* ASSIGN  */
+  YYSYMBOL_NOT = 26,                       /* NOT  */
+  YYSYMBOL_LE = 27,                        /* LE  */
+  YYSYMBOL_ERROR = 28,                     /* ERROR  */
+  YYSYMBOL_29_ = 29,                       /* '{'  */
+  YYSYMBOL_30_ = 30,                       /* '}'  */
+  YYSYMBOL_31_ = 31,                       /* ';'  */
+  YYSYMBOL_YYACCEPT = 32,                  /* $accept  */
+  YYSYMBOL_program = 33,                   /* program  */
+  YYSYMBOL_class_list = 34,                /* class_list  */
+  YYSYMBOL_class = 35,                     /* class  */
+  YYSYMBOL_dummy_feature_list = 36         /* dummy_feature_list  */
+};
+typedef enum yysymbol_kind_t yysymbol_kind_t;
+
+
+
+
+#ifdef short
+# undef short
+#endif
+
+/* On compilers that do not define __PTRDIFF_MAX__ etc., make sure
+   <limits.h> and (if available) <stdint.h> are included
+   so that the code can choose integer types of a good width.  */
+
+#ifndef __PTRDIFF_MAX__
+# include <limits.h> /* INFRINGES ON USER NAME SPACE */
+# if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
+#  include <stdint.h> /* INFRINGES ON USER NAME SPACE */
+#  define YY_STDINT_H
+# endif
+#endif
+
+/* Narrow types that promote to a signed type and that can represent a
+   signed or unsigned integer of at least N bits.  In tables they can
+   save space and decrease cache pressure.  Promoting to a signed type
+   helps avoid bugs in integer arithmetic.  */
+
+#ifdef __INT_LEAST8_MAX__
+typedef __INT_LEAST8_TYPE__ yytype_int8;
+#elif defined YY_STDINT_H
+typedef int_least8_t yytype_int8;
+#else
+typedef signed char yytype_int8;
+#endif
+
+#ifdef __INT_LEAST16_MAX__
+typedef __INT_LEAST16_TYPE__ yytype_int16;
+#elif defined YY_STDINT_H
+typedef int_least16_t yytype_int16;
+#else
+typedef short yytype_int16;
+#endif
+
+/* Work around bug in HP-UX 11.23, which defines these macros
+   incorrectly for preprocessor constants.  This workaround can likely
+   be removed in 2023, as HPE has promised support for HP-UX 11.23
+   (aka HP-UX 11i v2) only through the end of 2022; see Table 2 of
+   <https://h20195.www2.hpe.com/V2/getpdf.aspx/4AA4-7673ENW.pdf>.  */
+#ifdef __hpux
+# undef UINT_LEAST8_MAX
+# undef UINT_LEAST16_MAX
+# define UINT_LEAST8_MAX 255
+# define UINT_LEAST16_MAX 65535
+#endif
+
+#if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__
+typedef __UINT_LEAST8_TYPE__ yytype_uint8;
+#elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \
+       && UINT_LEAST8_MAX <= INT_MAX)
+typedef uint_least8_t yytype_uint8;
+#elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX
+typedef unsigned char yytype_uint8;
+#else
+typedef short yytype_uint8;
+#endif
+
+#if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__
+typedef __UINT_LEAST16_TYPE__ yytype_uint16;
+#elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \
+       && UINT_LEAST16_MAX <= INT_MAX)
+typedef uint_least16_t yytype_uint16;
+#elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX
+typedef unsigned short yytype_uint16;
+#else
+typedef int yytype_uint16;
+#endif
+
+#ifndef YYPTRDIFF_T
+# if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__
+#  define YYPTRDIFF_T __PTRDIFF_TYPE__
+#  define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__
+# elif defined PTRDIFF_MAX
+#  ifndef ptrdiff_t
+#   include <stddef.h> /* INFRINGES ON USER NAME SPACE */
+#  endif
+#  define YYPTRDIFF_T ptrdiff_t
+#  define YYPTRDIFF_MAXIMUM PTRDIFF_MAX
+# else
+#  define YYPTRDIFF_T long
+#  define YYPTRDIFF_MAXIMUM LONG_MAX
+# endif
+#endif
+
+#ifndef YYSIZE_T
+# ifdef __SIZE_TYPE__
+#  define YYSIZE_T __SIZE_TYPE__
+# elif defined size_t
+#  define YYSIZE_T size_t
+# elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
+#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
+#  define YYSIZE_T size_t
+# else
+#  define YYSIZE_T unsigned
+# endif
+#endif
+
+#define YYSIZE_MAXIMUM                                  \
+  YY_CAST (YYPTRDIFF_T,                                 \
+           (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1)  \
+            ? YYPTRDIFF_MAXIMUM                         \
+            : YY_CAST (YYSIZE_T, -1)))
+
+#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
+
+
+/* Stored state numbers (used for stacks). */
+typedef yytype_int8 yy_state_t;
+
+/* State numbers in computations.  */
+typedef int yy_state_fast_t;
+
+#ifndef YY_
+# if defined YYENABLE_NLS && YYENABLE_NLS
+#  if ENABLE_NLS
+#   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
+#   define YY_(Msgid) dgettext ("bison-runtime", Msgid)
+#  endif
+# endif
+# ifndef YY_
+#  define YY_(Msgid) Msgid
+# endif
+#endif
+
+
+#ifndef YY_ATTRIBUTE_PURE
+# if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
+#  define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
+# else
+#  define YY_ATTRIBUTE_PURE
+# endif
+#endif
+
+#ifndef YY_ATTRIBUTE_UNUSED
+# if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
+#  define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
+# else
+#  define YY_ATTRIBUTE_UNUSED
+# endif
+#endif
+
+/* Suppress unused-variable warnings by "using" E.  */
+#if ! defined lint || defined __GNUC__
+# define YY_USE(E) ((void) (E))
+#else
+# define YY_USE(E) /* empty */
+#endif
+
+/* Suppress an incorrect diagnostic about yylval being uninitialized.  */
+#if defined __GNUC__ && ! defined __ICC && 406 <= __GNUC__ * 100 + __GNUC_MINOR__
+# if __GNUC__ * 100 + __GNUC_MINOR__ < 407
+#  define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN                           \
+    _Pragma ("GCC diagnostic push")                                     \
+    _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")
+# else
+#  define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN                           \
+    _Pragma ("GCC diagnostic push")                                     \
+    _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")              \
+    _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
+# endif
+# define YY_IGNORE_MAYBE_UNINITIALIZED_END      \
+    _Pragma ("GCC diagnostic pop")
+#else
+# define YY_INITIAL_VALUE(Value) Value
+#endif
+#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+# define YY_IGNORE_MAYBE_UNINITIALIZED_END
+#endif
+#ifndef YY_INITIAL_VALUE
+# define YY_INITIAL_VALUE(Value) /* Nothing. */
+#endif
+
+#if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
+# define YY_IGNORE_USELESS_CAST_BEGIN                          \
+    _Pragma ("GCC diagnostic push")                            \
+    _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
+# define YY_IGNORE_USELESS_CAST_END            \
+    _Pragma ("GCC diagnostic pop")
+#endif
+#ifndef YY_IGNORE_USELESS_CAST_BEGIN
+# define YY_IGNORE_USELESS_CAST_BEGIN
+# define YY_IGNORE_USELESS_CAST_END
+#endif
+
+
+#define YY_ASSERT(E) ((void) (0 && (E)))
+
+#if !defined yyoverflow
+
+/* The parser invokes alloca or malloc; define the necessary symbols.  */
+
+# ifdef YYSTACK_USE_ALLOCA
+#  if YYSTACK_USE_ALLOCA
+#   ifdef __GNUC__
+#    define YYSTACK_ALLOC __builtin_alloca
+#   elif defined __BUILTIN_VA_ARG_INCR
+#    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
+#   elif defined _AIX
+#    define YYSTACK_ALLOC __alloca
+#   elif defined _MSC_VER
+#    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
+#    define alloca _alloca
+#   else
+#    define YYSTACK_ALLOC alloca
+#    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
+#     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+      /* Use EXIT_SUCCESS as a witness for stdlib.h.  */
+#     ifndef EXIT_SUCCESS
+#      define EXIT_SUCCESS 0
+#     endif
+#    endif
+#   endif
+#  endif
+# endif
+
+# ifdef YYSTACK_ALLOC
+   /* Pacify GCC's 'empty if-body' warning.  */
+#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
+#  ifndef YYSTACK_ALLOC_MAXIMUM
+    /* The OS might guarantee only one guard page at the bottom of the stack,
+       and a page size can be as small as 4096 bytes.  So we cannot safely
+       invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
+       to allow for a few compiler-allocated temporary stack slots.  */
+#   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
+#  endif
+# else
+#  define YYSTACK_ALLOC YYMALLOC
+#  define YYSTACK_FREE YYFREE
+#  ifndef YYSTACK_ALLOC_MAXIMUM
+#   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
+#  endif
+#  if (defined __cplusplus && ! defined EXIT_SUCCESS \
+       && ! ((defined YYMALLOC || defined malloc) \
+             && (defined YYFREE || defined free)))
+#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+#   ifndef EXIT_SUCCESS
+#    define EXIT_SUCCESS 0
+#   endif
+#  endif
+#  ifndef YYMALLOC
+#   define YYMALLOC malloc
+#   if ! defined malloc && ! defined EXIT_SUCCESS
+void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
+#   endif
+#  endif
+#  ifndef YYFREE
+#   define YYFREE free
+#   if ! defined free && ! defined EXIT_SUCCESS
+void free (void *); /* INFRINGES ON USER NAME SPACE */
+#   endif
+#  endif
+# endif
+#endif /* !defined yyoverflow */
+
+#if (! defined yyoverflow \
+     && (! defined __cplusplus \
+         || (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
+             && defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
+
+/* A type that is properly aligned for any stack member.  */
+union yyalloc
+{
+  yy_state_t yyss_alloc;
+  YYSTYPE yyvs_alloc;
+  YYLTYPE yyls_alloc;
+};
+
+/* The size of the maximum gap between one aligned stack and the next.  */
+# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
+
+/* The size of an array large to enough to hold all stacks, each with
+   N elements.  */
+# define YYSTACK_BYTES(N) \
+     ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE) \
+             + YYSIZEOF (YYLTYPE)) \
+      + 2 * YYSTACK_GAP_MAXIMUM)
+
+# define YYCOPY_NEEDED 1
+
+/* Relocate STACK from its old location to the new one.  The
+   local variables YYSIZE and YYSTACKSIZE give the old and new number of
+   elements in the stack, and YYPTR gives the new location of the
+   stack.  Advance YYPTR to a properly aligned location for the next
+   stack.  */
+# define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
+    do                                                                  \
+      {                                                                 \
+        YYPTRDIFF_T yynewbytes;                                         \
+        YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
+        Stack = &yyptr->Stack_alloc;                                    \
+        yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
+        yyptr += yynewbytes / YYSIZEOF (*yyptr);                        \
+      }                                                                 \
+    while (0)
+
+#endif
+
+#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
+/* Copy COUNT objects from SRC to DST.  The source and destination do
+   not overlap.  */
+# ifndef YYCOPY
+#  if defined __GNUC__ && 1 < __GNUC__
+#   define YYCOPY(Dst, Src, Count) \
+      __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
+#  else
+#   define YYCOPY(Dst, Src, Count)              \
+      do                                        \
+        {                                       \
+          YYPTRDIFF_T yyi;                      \
+          for (yyi = 0; yyi < (Count); yyi++)   \
+            (Dst)[yyi] = (Src)[yyi];            \
+        }                                       \
+      while (0)
+#  endif
+# endif
+#endif /* !YYCOPY_NEEDED */
+
+/* YYFINAL -- State number of the termination state.  */
+#define YYFINAL  6
+/* YYLAST -- Last index in YYTABLE.  */
+#define YYLAST   21
+
+/* YYNTOKENS -- Number of terminals.  */
+#define YYNTOKENS  32
+/* YYNNTS -- Number of nonterminals.  */
+#define YYNNTS  5
+/* YYNRULES -- Number of rules.  */
+#define YYNRULES  7
+/* YYNSTATES -- Number of states.  */
+#define YYNSTATES  18
+
+/* YYMAXUTOK -- Last valid token kind.  */
+#define YYMAXUTOK   284
+
+
+/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
+   as returned by yylex, with out-of-bounds checking.  */
+#define YYTRANSLATE(YYX)                                \
+  (0 <= (YYX) && (YYX) <= YYMAXUTOK                     \
+   ? YY_CAST (yysymbol_kind_t, yytranslate[YYX])        \
+   : YYSYMBOL_YYUNDEF)
+
+/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
+   as returned by yylex.  */
+static const yytype_int8 yytranslate[] =
+{
+       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,    31,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,    29,     2,    30,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
+       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
+      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
+      25,    26,    27,    28,     2
+};
+
+#if YYDEBUG
+/* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
+static const yytype_uint8 yyrline[] =
+{
+       0,   147,   147,   151,   154,   160,   163,   169
+};
+#endif
+
+/** Accessing symbol of state STATE.  */
+#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State])
+
+#if YYDEBUG || 0
+/* The user-facing name of the symbol whose (internal) number is
+   YYSYMBOL.  No bounds checking.  */
+static const char *yysymbol_name (yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED;
+
+/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
+   First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
+static const char *const yytname[] =
+{
+  "\"end of file\"", "error", "\"invalid token\"", "CLASS", "ELSE", "FI",
+  "IF", "IN", "INHERITS", "LET", "LOOP", "POOL", "THEN", "WHILE", "CASE",
+  "ESAC", "OF", "DARROW", "NEW", "ISVOID", "STR_CONST", "INT_CONST",
+  "BOOL_CONST", "TYPEID", "OBJECTID", "ASSIGN", "NOT", "LE", "ERROR",
+  "'{'", "'}'", "';'", "$accept", "program", "class_list", "class",
+  "dummy_feature_list", YY_NULLPTR
+};
+
+static const char *
+yysymbol_name (yysymbol_kind_t yysymbol)
+{
+  return yytname[yysymbol];
+}
+#endif
+
+#define YYPACT_NINF (-26)
+
+#define yypact_value_is_default(Yyn) \
+  ((Yyn) == YYPACT_NINF)
+
+#define YYTABLE_NINF (-1)
+
+#define yytable_value_is_error(Yyn) \
+  0
+
+/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
+   STATE-NUM.  */
+static const yytype_int8 yypact[] =
+{
+      -2,   -21,     3,    -2,   -26,    -8,   -26,   -26,   -19,   -26,
+     -24,   -23,   -26,   -25,   -22,   -26,   -20,   -26
+};
+
+/* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
+   Performed when YYTABLE does not specify something else to do.  Zero
+   means the default is an error.  */
+static const yytype_int8 yydefact[] =
+{
+       0,     0,     0,     2,     3,     0,     1,     4,     0,     7,
+       0,     0,     7,     0,     0,     5,     0,     6
+};
+
+/* YYPGOTO[NTERM-NUM].  */
+static const yytype_int8 yypgoto[] =
+{
+     -26,   -26,   -26,     6,     0
+};
+
+/* YYDEFGOTO[NTERM-NUM].  */
+static const yytype_int8 yydefgoto[] =
+{
+       0,     2,     3,     4,    11
+};
+
+/* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM.  If
+   positive, shift that token.  If negative, reduce the rule whose
+   number is the opposite.  If YYTABLE_NINF, syntax error.  */
+static const yytype_int8 yytable[] =
+{
+       8,     1,     5,     6,    10,    12,    15,    13,    16,     7,
+       0,    17,    14,     0,     0,     0,     0,     0,     0,     0,
+       0,     9
+};
+
+static const yytype_int8 yycheck[] =
+{
+       8,     3,    23,     0,    23,    29,    31,    30,    30,     3,
+      -1,    31,    12,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    29
+};
+
+/* YYSTOS[STATE-NUM] -- The symbol kind of the accessing symbol of
+   state STATE-NUM.  */
+static const yytype_int8 yystos[] =
+{
+       0,     3,    33,    34,    35,    23,     0,    35,     8,    29,
+      23,    36,    29,    30,    36,    31,    30,    31
+};
+
+/* YYR1[RULE-NUM] -- Symbol kind of the left-hand side of rule RULE-NUM.  */
+static const yytype_int8 yyr1[] =
+{
+       0,    32,    33,    34,    34,    35,    35,    36
+};
+
+/* YYR2[RULE-NUM] -- Number of symbols on the right-hand side of rule RULE-NUM.  */
+static const yytype_int8 yyr2[] =
+{
+       0,     2,     1,     1,     2,     6,     8,     0
+};
+
+
+enum { YYENOMEM = -2 };
+
+#define yyerrok         (yyerrstatus = 0)
+#define yyclearin       (yychar = YYEMPTY)
+
+#define YYACCEPT        goto yyacceptlab
+#define YYABORT         goto yyabortlab
+#define YYERROR         goto yyerrorlab
+#define YYNOMEM         goto yyexhaustedlab
+
+
+#define YYRECOVERING()  (!!yyerrstatus)
+
+#define YYBACKUP(Token, Value)                                    \
+  do                                                              \
+    if (yychar == YYEMPTY)                                        \
+      {                                                           \
+        yychar = (Token);                                         \
+        yylval = (Value);                                         \
+        YYPOPSTACK (yylen);                                       \
+        yystate = *yyssp;                                         \
+        goto yybackup;                                            \
+      }                                                           \
+    else                                                          \
+      {                                                           \
+        yyerror (YY_("syntax error: cannot back up")); \
+        YYERROR;                                                  \
+      }                                                           \
+  while (0)
+
+/* Backward compatibility with an undocumented macro.
+   Use YYerror or YYUNDEF. */
+#define YYERRCODE YYUNDEF
+
+/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
+   If N is 0, then set CURRENT to the empty location which ends
+   the previous symbol: RHS[0] (always defined).  */
+
+#ifndef YYLLOC_DEFAULT
+# define YYLLOC_DEFAULT(Current, Rhs, N)                                \
+    do                                                                  \
+      if (N)                                                            \
+        {                                                               \
+          (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
+          (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
+          (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
+          (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
+        }                                                               \
+      else                                                              \
+        {                                                               \
+          (Current).first_line   = (Current).last_line   =              \
+            YYRHSLOC (Rhs, 0).last_line;                                \
+          (Current).first_column = (Current).last_column =              \
+            YYRHSLOC (Rhs, 0).last_column;                              \
+        }                                                               \
+    while (0)
+#endif
+
+#define YYRHSLOC(Rhs, K) ((Rhs)[K])
+
+
+/* Enable debugging if requested.  */
+#if YYDEBUG
+
+# ifndef YYFPRINTF
+#  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
+#  define YYFPRINTF fprintf
+# endif
+
+# define YYDPRINTF(Args)                        \
+do {                                            \
+  if (yydebug)                                  \
+    YYFPRINTF Args;                             \
+} while (0)
+
+
+/* YYLOCATION_PRINT -- Print the location on the stream.
+   This macro was not mandated originally: define only if we know
+   we won't break user code: when these are the locations we know.  */
+
+# ifndef YYLOCATION_PRINT
+
+#  if defined YY_LOCATION_PRINT
+
+   /* Temporary convenience wrapper in case some people defined the
+      undocumented and private YY_LOCATION_PRINT macros.  */
+#   define YYLOCATION_PRINT(File, Loc)  YY_LOCATION_PRINT(File, *(Loc))
+
+#  elif defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
+
+/* Print *YYLOCP on YYO.  Private, do not rely on its existence. */
+
+YY_ATTRIBUTE_UNUSED
+static int
+yy_location_print_ (FILE *yyo, YYLTYPE const * const yylocp)
+{
+  int res = 0;
+  int end_col = 0 != yylocp->last_column ? yylocp->last_column - 1 : 0;
+  if (0 <= yylocp->first_line)
+    {
+      res += YYFPRINTF (yyo, "%d", yylocp->first_line);
+      if (0 <= yylocp->first_column)
+        res += YYFPRINTF (yyo, ".%d", yylocp->first_column);
+    }
+  if (0 <= yylocp->last_line)
+    {
+      if (yylocp->first_line < yylocp->last_line)
+        {
+          res += YYFPRINTF (yyo, "-%d", yylocp->last_line);
+          if (0 <= end_col)
+            res += YYFPRINTF (yyo, ".%d", end_col);
+        }
+      else if (0 <= end_col && yylocp->first_column < end_col)
+        res += YYFPRINTF (yyo, "-%d", end_col);
+    }
+  return res;
+}
+
+#   define YYLOCATION_PRINT  yy_location_print_
+
+    /* Temporary convenience wrapper in case some people defined the
+       undocumented and private YY_LOCATION_PRINT macros.  */
+#   define YY_LOCATION_PRINT(File, Loc)  YYLOCATION_PRINT(File, &(Loc))
+
+#  else
+
+#   define YYLOCATION_PRINT(File, Loc) ((void) 0)
+    /* Temporary convenience wrapper in case some people defined the
+       undocumented and private YY_LOCATION_PRINT macros.  */
+#   define YY_LOCATION_PRINT  YYLOCATION_PRINT
+
+#  endif
+# endif /* !defined YYLOCATION_PRINT */
+
+
+# define YY_SYMBOL_PRINT(Title, Kind, Value, Location)                    \
+do {                                                                      \
+  if (yydebug)                                                            \
+    {                                                                     \
+      YYFPRINTF (stderr, "%s ", Title);                                   \
+      yy_symbol_print (stderr,                                            \
+                  Kind, Value, Location); \
+      YYFPRINTF (stderr, "\n");                                           \
+    }                                                                     \
+} while (0)
+
+
+/*-----------------------------------.
+| Print this symbol's value on YYO.  |
+`-----------------------------------*/
+
+static void
+yy_symbol_value_print (FILE *yyo,
+                       yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp)
+{
+  FILE *yyoutput = yyo;
+  YY_USE (yyoutput);
+  YY_USE (yylocationp);
+  if (!yyvaluep)
+    return;
+  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+  YY_USE (yykind);
+  YY_IGNORE_MAYBE_UNINITIALIZED_END
+}
+
+
+/*---------------------------.
+| Print this symbol on YYO.  |
+`---------------------------*/
+
+static void
+yy_symbol_print (FILE *yyo,
+                 yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp)
+{
+  YYFPRINTF (yyo, "%s %s (",
+             yykind < YYNTOKENS ? "token" : "nterm", yysymbol_name (yykind));
+
+  YYLOCATION_PRINT (yyo, yylocationp);
+  YYFPRINTF (yyo, ": ");
+  yy_symbol_value_print (yyo, yykind, yyvaluep, yylocationp);
+  YYFPRINTF (yyo, ")");
+}
+
+/*------------------------------------------------------------------.
+| yy_stack_print -- Print the state stack from its BOTTOM up to its |
+| TOP (included).                                                   |
+`------------------------------------------------------------------*/
+
+static void
+yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop)
+{
+  YYFPRINTF (stderr, "Stack now");
+  for (; yybottom <= yytop; yybottom++)
+    {
+      int yybot = *yybottom;
+      YYFPRINTF (stderr, " %d", yybot);
+    }
+  YYFPRINTF (stderr, "\n");
+}
+
+# define YY_STACK_PRINT(Bottom, Top)                            \
+do {                                                            \
+  if (yydebug)                                                  \
+    yy_stack_print ((Bottom), (Top));                           \
+} while (0)
+
+
+/*------------------------------------------------.
+| Report that the YYRULE is going to be reduced.  |
+`------------------------------------------------*/
+
+static void
+yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp, YYLTYPE *yylsp,
+                 int yyrule)
+{
+  int yylno = yyrline[yyrule];
+  int yynrhs = yyr2[yyrule];
+  int yyi;
+  YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n",
+             yyrule - 1, yylno);
+  /* The symbols being reduced.  */
+  for (yyi = 0; yyi < yynrhs; yyi++)
+    {
+      YYFPRINTF (stderr, "   $%d = ", yyi + 1);
+      yy_symbol_print (stderr,
+                       YY_ACCESSING_SYMBOL (+yyssp[yyi + 1 - yynrhs]),
+                       &yyvsp[(yyi + 1) - (yynrhs)],
+                       &(yylsp[(yyi + 1) - (yynrhs)]));
+      YYFPRINTF (stderr, "\n");
+    }
+}
+
+# define YY_REDUCE_PRINT(Rule)          \
+do {                                    \
+  if (yydebug)                          \
+    yy_reduce_print (yyssp, yyvsp, yylsp, Rule); \
+} while (0)
+
+/* Nonzero means print parse trace.  It is left uninitialized so that
+   multiple parsers can coexist.  */
+int yydebug;
+#else /* !YYDEBUG */
+# define YYDPRINTF(Args) ((void) 0)
+# define YY_SYMBOL_PRINT(Title, Kind, Value, Location)
+# define YY_STACK_PRINT(Bottom, Top)
+# define YY_REDUCE_PRINT(Rule)
+#endif /* !YYDEBUG */
+
+
+/* YYINITDEPTH -- initial size of the parser's stacks.  */
+#ifndef YYINITDEPTH
+# define YYINITDEPTH 200
+#endif
+
+/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
+   if the built-in stack extension method is used).
+
+   Do not make this value too large; the results are undefined if
+   YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
+   evaluated with infinite-precision integer arithmetic.  */
+
+#ifndef YYMAXDEPTH
+# define YYMAXDEPTH 10000
+#endif
+
+
+
+
+
+
+/*-----------------------------------------------.
+| Release the memory associated to this symbol.  |
+`-----------------------------------------------*/
+
+static void
+yydestruct (const char *yymsg,
+            yysymbol_kind_t yykind, YYSTYPE *yyvaluep, YYLTYPE *yylocationp)
+{
+  YY_USE (yyvaluep);
+  YY_USE (yylocationp);
+  if (!yymsg)
+    yymsg = "Deleting";
+  YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp);
+
+  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+  YY_USE (yykind);
+  YY_IGNORE_MAYBE_UNINITIALIZED_END
+}
+
+
+/* Lookahead token kind.  */
+int yychar;
+
+/* The semantic value of the lookahead symbol.  */
+YYSTYPE yylval;
+/* Location data for the lookahead symbol.  */
+YYLTYPE yylloc
+# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
+  = { 1, 1, 1, 1 }
+# endif
+;
+/* Number of syntax errors so far.  */
+int yynerrs;
+
+
+
+
+/*----------.
+| yyparse.  |
+`----------*/
+
+int
+yyparse (void)
+{
+    yy_state_fast_t yystate = 0;
+    /* Number of tokens to shift before error messages enabled.  */
+    int yyerrstatus = 0;
+
+    /* Refer to the stacks through separate pointers, to allow yyoverflow
+       to reallocate them elsewhere.  */
+
+    /* Their size.  */
+    YYPTRDIFF_T yystacksize = YYINITDEPTH;
+
+    /* The state stack: array, bottom, top.  */
+    yy_state_t yyssa[YYINITDEPTH];
+    yy_state_t *yyss = yyssa;
+    yy_state_t *yyssp = yyss;
+
+    /* The semantic value stack: array, bottom, top.  */
+    YYSTYPE yyvsa[YYINITDEPTH];
+    YYSTYPE *yyvs = yyvsa;
+    YYSTYPE *yyvsp = yyvs;
+
+    /* The location stack: array, bottom, top.  */
+    YYLTYPE yylsa[YYINITDEPTH];
+    YYLTYPE *yyls = yylsa;
+    YYLTYPE *yylsp = yyls;
+
+  int yyn;
+  /* The return value of yyparse.  */
+  int yyresult;
+  /* Lookahead symbol kind.  */
+  yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY;
+  /* The variables used to return semantic value and location from the
+     action routines.  */
+  YYSTYPE yyval;
+  YYLTYPE yyloc;
+
+  /* The locations where the error started and ended.  */
+  YYLTYPE yyerror_range[3];
+
+
+
+#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
+
+  /* The number of symbols on the RHS of the reduced rule.
+     Keep to zero when no symbol should be popped.  */
+  int yylen = 0;
+
+  YYDPRINTF ((stderr, "Starting parse\n"));
+
+  yychar = YYEMPTY; /* Cause a token to be read.  */
+
+  yylsp[0] = yylloc;
+  goto yysetstate;
+
+
+/*------------------------------------------------------------.
+| yynewstate -- push a new state, which is found in yystate.  |
+`------------------------------------------------------------*/
+yynewstate:
+  /* In all cases, when you get here, the value and location stacks
+     have just been pushed.  So pushing a state here evens the stacks.  */
+  yyssp++;
+
+
+/*--------------------------------------------------------------------.
+| yysetstate -- set current state (the top of the stack) to yystate.  |
+`--------------------------------------------------------------------*/
+yysetstate:
+  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
+  YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
+  YY_IGNORE_USELESS_CAST_BEGIN
+  *yyssp = YY_CAST (yy_state_t, yystate);
+  YY_IGNORE_USELESS_CAST_END
+  YY_STACK_PRINT (yyss, yyssp);
+
+  if (yyss + yystacksize - 1 <= yyssp)
+#if !defined yyoverflow && !defined YYSTACK_RELOCATE
+    YYNOMEM;
+#else
+    {
+      /* Get the current used size of the three stacks, in elements.  */
+      YYPTRDIFF_T yysize = yyssp - yyss + 1;
+
+# if defined yyoverflow
+      {
+        /* Give user a chance to reallocate the stack.  Use copies of
+           these so that the &'s don't force the real ones into
+           memory.  */
+        yy_state_t *yyss1 = yyss;
+        YYSTYPE *yyvs1 = yyvs;
+        YYLTYPE *yyls1 = yyls;
+
+        /* Each stack pointer address is followed by the size of the
+           data in use in that stack, in bytes.  This used to be a
+           conditional around just the two extra args, but that might
+           be undefined if yyoverflow is a macro.  */
+        yyoverflow (YY_("memory exhausted"),
+                    &yyss1, yysize * YYSIZEOF (*yyssp),
+                    &yyvs1, yysize * YYSIZEOF (*yyvsp),
+                    &yyls1, yysize * YYSIZEOF (*yylsp),
+                    &yystacksize);
+        yyss = yyss1;
+        yyvs = yyvs1;
+        yyls = yyls1;
+      }
+# else /* defined YYSTACK_RELOCATE */
+      /* Extend the stack our own way.  */
+      if (YYMAXDEPTH <= yystacksize)
+        YYNOMEM;
+      yystacksize *= 2;
+      if (YYMAXDEPTH < yystacksize)
+        yystacksize = YYMAXDEPTH;
+
+      {
+        yy_state_t *yyss1 = yyss;
+        union yyalloc *yyptr =
+          YY_CAST (union yyalloc *,
+                   YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
+        if (! yyptr)
+          YYNOMEM;
+        YYSTACK_RELOCATE (yyss_alloc, yyss);
+        YYSTACK_RELOCATE (yyvs_alloc, yyvs);
+        YYSTACK_RELOCATE (yyls_alloc, yyls);
+#  undef YYSTACK_RELOCATE
+        if (yyss1 != yyssa)
+          YYSTACK_FREE (yyss1);
+      }
+# endif
+
+      yyssp = yyss + yysize - 1;
+      yyvsp = yyvs + yysize - 1;
+      yylsp = yyls + yysize - 1;
+
+      YY_IGNORE_USELESS_CAST_BEGIN
+      YYDPRINTF ((stderr, "Stack size increased to %ld\n",
+                  YY_CAST (long, yystacksize)));
+      YY_IGNORE_USELESS_CAST_END
+
+      if (yyss + yystacksize - 1 <= yyssp)
+        YYABORT;
+    }
+#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
+
+
+  if (yystate == YYFINAL)
+    YYACCEPT;
+
+  goto yybackup;
+
+
+/*-----------.
+| yybackup.  |
+`-----------*/
+yybackup:
+  /* Do appropriate processing given the current state.  Read a
+     lookahead token if we need one and don't already have one.  */
+
+  /* First try to decide what to do without reference to lookahead token.  */
+  yyn = yypact[yystate];
+  if (yypact_value_is_default (yyn))
+    goto yydefault;
+
+  /* Not known => get a lookahead token if don't already have one.  */
+
+  /* YYCHAR is either empty, or end-of-input, or a valid lookahead.  */
+  if (yychar == YYEMPTY)
+    {
+      YYDPRINTF ((stderr, "Reading a token\n"));
+      yychar = yylex ();
+    }
+
+  if (yychar <= YYEOF)
+    {
+      yychar = YYEOF;
+      yytoken = YYSYMBOL_YYEOF;
+      YYDPRINTF ((stderr, "Now at end of input.\n"));
+    }
+  else if (yychar == YYerror)
+    {
+      /* The scanner already issued an error message, process directly
+         to error recovery.  But do not keep the error token as
+         lookahead, it is too special and may lead us to an endless
+         loop in error recovery. */
+      yychar = YYUNDEF;
+      yytoken = YYSYMBOL_YYerror;
+      yyerror_range[1] = yylloc;
+      goto yyerrlab1;
+    }
+  else
+    {
+      yytoken = YYTRANSLATE (yychar);
+      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
+    }
+
+  /* If the proper action on seeing token YYTOKEN is to reduce or to
+     detect an error, take that action.  */
+  yyn += yytoken;
+  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
+    goto yydefault;
+  yyn = yytable[yyn];
+  if (yyn <= 0)
+    {
+      if (yytable_value_is_error (yyn))
+        goto yyerrlab;
+      yyn = -yyn;
+      goto yyreduce;
+    }
+
+  /* Count tokens shifted since error; after three, turn off error
+     status.  */
+  if (yyerrstatus)
+    yyerrstatus--;
+
+  /* Shift the lookahead token.  */
+  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
+  yystate = yyn;
+  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+  *++yyvsp = yylval;
+  YY_IGNORE_MAYBE_UNINITIALIZED_END
+  *++yylsp = yylloc;
+
+  /* Discard the shifted token.  */
+  yychar = YYEMPTY;
+  goto yynewstate;
+
+
+/*-----------------------------------------------------------.
+| yydefault -- do the default action for the current state.  |
+`-----------------------------------------------------------*/
+yydefault:
+  yyn = yydefact[yystate];
+  if (yyn == 0)
+    goto yyerrlab;
+  goto yyreduce;
+
+
+/*-----------------------------.
+| yyreduce -- do a reduction.  |
+`-----------------------------*/
+yyreduce:
+  /* yyn is the number of a rule to reduce with.  */
+  yylen = yyr2[yyn];
+
+  /* If YYLEN is nonzero, implement the default value of the action:
+     '$$ = $1'.
+
+     Otherwise, the following line sets YYVAL to garbage.
+     This behavior is undocumented and Bison
+     users should not rely upon it.  Assigning to YYVAL
+     unconditionally makes the parser a bit smaller, and it avoids a
+     GCC warning that YYVAL may be used uninitialized.  */
+  yyval = yyvsp[1-yylen];
+
+  /* Default location. */
+  YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
+  yyerror_range[1] = yyloc;
+  YY_REDUCE_PRINT (yyn);
+  switch (yyn)
+    {
+  case 2: /* program: class_list  */
+#line 147 "cool.y"
+                                { (yyloc) = (yylsp[0]); ast_root = program((yyvsp[0].classes)); }
+#line 1301 "cool.tab.c"
+    break;
+
+  case 3: /* class_list: class  */
+#line 152 "cool.y"
+    { (yyval.classes) = single_Classes((yyvsp[0].class_));
+    parse_results = (yyval.classes); }
+#line 1308 "cool.tab.c"
+    break;
+
+  case 4: /* class_list: class_list class  */
+#line 155 "cool.y"
+    { (yyval.classes) = append_Classes((yyvsp[-1].classes),single_Classes((yyvsp[0].class_))); 
+    parse_results = (yyval.classes); }
+#line 1315 "cool.tab.c"
+    break;
+
+  case 5: /* class: CLASS TYPEID '{' dummy_feature_list '}' ';'  */
+#line 161 "cool.y"
+    { (yyval.class_) = class_((yyvsp[-4].symbol),idtable.add_string("Object"),(yyvsp[-2].features),
+    stringtable.add_string(curr_filename)); }
+#line 1322 "cool.tab.c"
+    break;
+
+  case 6: /* class: CLASS TYPEID INHERITS TYPEID '{' dummy_feature_list '}' ';'  */
+#line 164 "cool.y"
+    { (yyval.class_) = class_((yyvsp[-6].symbol),(yyvsp[-4].symbol),(yyvsp[-2].features),stringtable.add_string(curr_filename)); }
+#line 1328 "cool.tab.c"
+    break;
+
+  case 7: /* dummy_feature_list: %empty  */
+#line 169 "cool.y"
+    {  (yyval.features) = nil_Features(); }
+#line 1334 "cool.tab.c"
+    break;
+
+
+#line 1338 "cool.tab.c"
+
+      default: break;
+    }
+  /* User semantic actions sometimes alter yychar, and that requires
+     that yytoken be updated with the new translation.  We take the
+     approach of translating immediately before every use of yytoken.
+     One alternative is translating here after every semantic action,
+     but that translation would be missed if the semantic action invokes
+     YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
+     if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
+     incorrect destructor might then be invoked immediately.  In the
+     case of YYERROR or YYBACKUP, subsequent parser actions might lead
+     to an incorrect destructor call or verbose syntax error message
+     before the lookahead is translated.  */
+  YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc);
+
+  YYPOPSTACK (yylen);
+  yylen = 0;
+
+  *++yyvsp = yyval;
+  *++yylsp = yyloc;
+
+  /* Now 'shift' the result of the reduction.  Determine what state
+     that goes to, based on the state we popped back to and the rule
+     number reduced by.  */
+  {
+    const int yylhs = yyr1[yyn] - YYNTOKENS;
+    const int yyi = yypgoto[yylhs] + *yyssp;
+    yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
+               ? yytable[yyi]
+               : yydefgoto[yylhs]);
+  }
+
+  goto yynewstate;
+
+
+/*--------------------------------------.
+| yyerrlab -- here on detecting error.  |
+`--------------------------------------*/
+yyerrlab:
+  /* Make sure we have latest lookahead translation.  See comments at
+     user semantic actions for why this is necessary.  */
+  yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar);
+  /* If not already recovering from an error, report this error.  */
+  if (!yyerrstatus)
+    {
+      ++yynerrs;
+      yyerror (YY_("syntax error"));
+    }
+
+  yyerror_range[1] = yylloc;
+  if (yyerrstatus == 3)
+    {
+      /* If just tried and failed to reuse lookahead token after an
+         error, discard it.  */
+
+      if (yychar <= YYEOF)
+        {
+          /* Return failure if at end of input.  */
+          if (yychar == YYEOF)
+            YYABORT;
+        }
+      else
+        {
+          yydestruct ("Error: discarding",
+                      yytoken, &yylval, &yylloc);
+          yychar = YYEMPTY;
+        }
+    }
+
+  /* Else will try to reuse lookahead token after shifting the error
+     token.  */
+  goto yyerrlab1;
+
+
+/*---------------------------------------------------.
+| yyerrorlab -- error raised explicitly by YYERROR.  |
+`---------------------------------------------------*/
+yyerrorlab:
+  /* Pacify compilers when the user code never invokes YYERROR and the
+     label yyerrorlab therefore never appears in user code.  */
+  if (0)
+    YYERROR;
+  ++yynerrs;
+
+  /* Do not reclaim the symbols of the rule whose action triggered
+     this YYERROR.  */
+  YYPOPSTACK (yylen);
+  yylen = 0;
+  YY_STACK_PRINT (yyss, yyssp);
+  yystate = *yyssp;
+  goto yyerrlab1;
+
+
+/*-------------------------------------------------------------.
+| yyerrlab1 -- common code for both syntax error and YYERROR.  |
+`-------------------------------------------------------------*/
+yyerrlab1:
+  yyerrstatus = 3;      /* Each real token shifted decrements this.  */
+
+  /* Pop stack until we find a state that shifts the error token.  */
+  for (;;)
+    {
+      yyn = yypact[yystate];
+      if (!yypact_value_is_default (yyn))
+        {
+          yyn += YYSYMBOL_YYerror;
+          if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror)
+            {
+              yyn = yytable[yyn];
+              if (0 < yyn)
+                break;
+            }
+        }
+
+      /* Pop the current state because it cannot handle the error token.  */
+      if (yyssp == yyss)
+        YYABORT;
+
+      yyerror_range[1] = *yylsp;
+      yydestruct ("Error: popping",
+                  YY_ACCESSING_SYMBOL (yystate), yyvsp, yylsp);
+      YYPOPSTACK (1);
+      yystate = *yyssp;
+      YY_STACK_PRINT (yyss, yyssp);
+    }
+
+  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+  *++yyvsp = yylval;
+  YY_IGNORE_MAYBE_UNINITIALIZED_END
+
+  yyerror_range[2] = yylloc;
+  ++yylsp;
+  YYLLOC_DEFAULT (*yylsp, yyerror_range, 2);
+
+  /* Shift the error token.  */
+  YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp);
+
+  yystate = yyn;
+  goto yynewstate;
+
+
+/*-------------------------------------.
+| yyacceptlab -- YYACCEPT comes here.  |
+`-------------------------------------*/
+yyacceptlab:
+  yyresult = 0;
+  goto yyreturnlab;
+
+
+/*-----------------------------------.
+| yyabortlab -- YYABORT comes here.  |
+`-----------------------------------*/
+yyabortlab:
+  yyresult = 1;
+  goto yyreturnlab;
+
+
+/*-----------------------------------------------------------.
+| yyexhaustedlab -- YYNOMEM (memory exhaustion) comes here.  |
+`-----------------------------------------------------------*/
+yyexhaustedlab:
+  yyerror (YY_("memory exhausted"));
+  yyresult = 2;
+  goto yyreturnlab;
+
+
+/*----------------------------------------------------------.
+| yyreturnlab -- parsing is finished, clean up and return.  |
+`----------------------------------------------------------*/
+yyreturnlab:
+  if (yychar != YYEMPTY)
+    {
+      /* Make sure we have latest lookahead translation.  See comments at
+         user semantic actions for why this is necessary.  */
+      yytoken = YYTRANSLATE (yychar);
+      yydestruct ("Cleanup: discarding lookahead",
+                  yytoken, &yylval, &yylloc);
+    }
+  /* Do not reclaim the symbols of the rule whose action triggered
+     this YYABORT or YYACCEPT.  */
+  YYPOPSTACK (yylen);
+  YY_STACK_PRINT (yyss, yyssp);
+  while (yyssp != yyss)
+    {
+      yydestruct ("Cleanup: popping",
+                  YY_ACCESSING_SYMBOL (+*yyssp), yyvsp, yylsp);
+      YYPOPSTACK (1);
+    }
+#ifndef yyoverflow
+  if (yyss != yyssa)
+    YYSTACK_FREE (yyss);
+#endif
+
+  return yyresult;
+}
+
+#line 173 "cool.y"
+
+    
+    /* This function is called automatically when Bison detects a parse error. */
+    void yyerror(char *s)
+    {
+      extern int curr_lineno;
+      
+      cerr << "\"" << curr_filename << "\", line " << curr_lineno << ": " \
+      << s << " at or near ";
+      print_cool_token(yychar);
+      cerr << endl;
+      omerrs++;
+      
+      if(omerrs>50) {fprintf(stdout, "More than 50 errors\n"); exit(1);}
+    }
+    
+    
diff --git a/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/cool-parse.d b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/cool-parse.d
new file mode 100644
index 0000000..ea01764
--- /dev/null
+++ b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/cool-parse.d
@@ -0,0 +1,10 @@
+cool-parse.o cool-parse.d : cool-parse.cc /usr/class/cs143/cool/include/PA3/cool-tree.h \
+ /usr/class/cs143/cool/include/PA3/tree.h \
+ /usr/class/cs143/cool/include/PA3/copyright.h \
+ /usr/class/cs143/cool/include/PA3/stringtab.h \
+ /usr/class/cs143/cool/include/PA3/list.h \
+ /usr/class/cs143/cool/include/PA3/cool-io.h cool-tree.handcode.h \
+ /usr/class/cs143/cool/include/PA3/tree.h \
+ /usr/class/cs143/cool/include/PA3/cool.h \
+ /usr/class/cs143/cool/include/PA3/stringtab.h \
+ /usr/class/cs143/cool/include/PA3/utilities.h cool.tab.h
diff --git a/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/cool-tree.aps b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/cool-tree.aps
new file mode 120000
index 0000000..6180485
--- /dev/null
+++ b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/cool-tree.aps
@@ -0,0 +1 @@
+/usr/class/cs143/cool/src/PA3/cool-tree.aps
\ No newline at end of file
diff --git a/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/cool-tree.cc b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/cool-tree.cc
new file mode 120000
index 0000000..a09dc6e
--- /dev/null
+++ b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/cool-tree.cc
@@ -0,0 +1 @@
+/usr/class/cs143/cool/src/PA3/cool-tree.cc
\ No newline at end of file
diff --git a/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/cool-tree.d b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/cool-tree.d
new file mode 100644
index 0000000..fe5b579
--- /dev/null
+++ b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/cool-tree.d
@@ -0,0 +1,9 @@
+cool-tree.o cool-tree.d : cool-tree.cc /usr/class/cs143/cool/include/PA3/tree.h \
+ /usr/class/cs143/cool/include/PA3/copyright.h \
+ /usr/class/cs143/cool/include/PA3/stringtab.h \
+ /usr/class/cs143/cool/include/PA3/list.h \
+ /usr/class/cs143/cool/include/PA3/cool-io.h cool-tree.handcode.h \
+ /usr/class/cs143/cool/include/PA3/cool.h \
+ /usr/class/cs143/cool/include/PA3/stringtab.h \
+ /usr/class/cs143/cool/include/PA3/cool-tree.h \
+ /usr/class/cs143/cool/include/PA3/tree.h cool-tree.handcode.h
diff --git a/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/cool-tree.handcode.h b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/cool-tree.handcode.h
new file mode 100644
index 0000000..a71e9a7
--- /dev/null
+++ b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/cool-tree.handcode.h
@@ -0,0 +1,106 @@
+//
+// The following include files must come first.
+
+#ifndef COOL_TREE_HANDCODE_H
+#define COOL_TREE_HANDCODE_H
+
+#include <iostream>
+#include "tree.h"
+#include "cool.h"
+#include "stringtab.h"
+#define yylineno curr_lineno;
+extern int yylineno;
+
+inline Boolean copy_Boolean(Boolean b) {return b; }
+inline void assert_Boolean(Boolean) {}
+inline void dump_Boolean(ostream& stream, int padding, Boolean b)
+	{ stream << pad(padding) << (int) b << "\n"; }
+
+void dump_Symbol(ostream& stream, int padding, Symbol b);
+void assert_Symbol(Symbol b);
+Symbol copy_Symbol(Symbol b);
+
+class Program_class;
+typedef Program_class *Program;
+class Class__class;
+typedef Class__class *Class_;
+class Feature_class;
+typedef Feature_class *Feature;
+class Formal_class;
+typedef Formal_class *Formal;
+class Expression_class;
+typedef Expression_class *Expression;
+class Case_class;
+typedef Case_class *Case;
+
+typedef list_node<Class_> Classes_class;
+typedef Classes_class *Classes;
+typedef list_node<Feature> Features_class;
+typedef Features_class *Features;
+typedef list_node<Formal> Formals_class;
+typedef Formals_class *Formals;
+typedef list_node<Expression> Expressions_class;
+typedef Expressions_class *Expressions;
+typedef list_node<Case> Cases_class;
+typedef Cases_class *Cases;
+
+#define Program_EXTRAS                          \
+virtual void dump_with_types(ostream&, int) = 0; 
+
+
+
+#define program_EXTRAS                          \
+void dump_with_types(ostream&, int);            
+
+#define Class__EXTRAS                   \
+virtual Symbol get_filename() = 0;      \
+virtual void dump_with_types(ostream&,int) = 0; 
+
+
+#define class__EXTRAS                                 \
+Symbol get_filename() { return filename; }             \
+void dump_with_types(ostream&,int);                    
+
+
+#define Feature_EXTRAS                                        \
+virtual void dump_with_types(ostream&,int) = 0; 
+
+
+#define Feature_SHARED_EXTRAS                                       \
+void dump_with_types(ostream&,int);    
+
+
+
+
+
+#define Formal_EXTRAS                              \
+virtual void dump_with_types(ostream&,int) = 0;
+
+
+#define formal_EXTRAS                           \
+void dump_with_types(ostream&,int);
+
+
+#define Case_EXTRAS                             \
+virtual void dump_with_types(ostream& ,int) = 0;
+
+
+#define branch_EXTRAS                                   \
+void dump_with_types(ostream& ,int);
+
+
+#define Expression_EXTRAS                    \
+Symbol type;                                 \
+Symbol get_type() { return type; }           \
+Expression set_type(Symbol s) { type = s; return this; } \
+virtual void dump_with_types(ostream&,int) = 0;  \
+void dump_type(ostream&, int);               \
+Expression_class() { type = (Symbol) NULL; }
+
+
+
+#define Expression_SHARED_EXTRAS           \
+void dump_with_types(ostream&,int); 
+
+
+#endif
diff --git a/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/cool.output b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/cool.output
new file mode 100644
index 0000000..254c7e5
--- /dev/null
+++ b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/cool.output
@@ -0,0 +1,235 @@
+Terminals unused in grammar
+
+    ELSE
+    FI
+    IF
+    IN
+    LET
+    LOOP
+    POOL
+    THEN
+    WHILE
+    CASE
+    ESAC
+    OF
+    DARROW
+    NEW
+    ISVOID
+    STR_CONST
+    INT_CONST
+    BOOL_CONST
+    OBJECTID
+    ASSIGN
+    NOT
+    LE
+    ERROR
+
+
+Grammar
+
+    0 $accept: program $end
+
+    1 program: class_list
+
+    2 class_list: class
+    3           | class_list class
+
+    4 class: CLASS TYPEID '{' dummy_feature_list '}' ';'
+    5      | CLASS TYPEID INHERITS TYPEID '{' dummy_feature_list '}' ';'
+
+    6 dummy_feature_list: %empty
+
+
+Terminals, with rules where they appear
+
+    $end (0) 0
+    ';' (59) 4 5
+    '{' (123) 4 5
+    '}' (125) 4 5
+    error (256)
+    CLASS (258) 4 5
+    ELSE (259)
+    FI (260)
+    IF (261)
+    IN (262)
+    INHERITS (263) 5
+    LET (264)
+    LOOP (265)
+    POOL (266)
+    THEN (267)
+    WHILE (268)
+    CASE (269)
+    ESAC (270)
+    OF (271)
+    DARROW (272)
+    NEW (273)
+    ISVOID (274)
+    STR_CONST <symbol> (275)
+    INT_CONST <symbol> (276)
+    BOOL_CONST <boolean> (277)
+    TYPEID <symbol> (278) 4 5
+    OBJECTID <symbol> (279)
+    ASSIGN (280)
+    NOT (281)
+    LE (282)
+    ERROR (283)
+
+
+Nonterminals, with rules where they appear
+
+    $accept (32)
+        on left: 0
+    program <program> (33)
+        on left: 1
+        on right: 0
+    class_list <classes> (34)
+        on left: 2 3
+        on right: 1 3
+    class <class_> (35)
+        on left: 4 5
+        on right: 2 3
+    dummy_feature_list <features> (36)
+        on left: 6
+        on right: 4 5
+
+
+State 0
+
+    0 $accept: . program $end
+
+    CLASS  shift, and go to state 1
+
+    program     go to state 2
+    class_list  go to state 3
+    class       go to state 4
+
+
+State 1
+
+    4 class: CLASS . TYPEID '{' dummy_feature_list '}' ';'
+    5      | CLASS . TYPEID INHERITS TYPEID '{' dummy_feature_list '}' ';'
+
+    TYPEID  shift, and go to state 5
+
+
+State 2
+
+    0 $accept: program . $end
+
+    $end  shift, and go to state 6
+
+
+State 3
+
+    1 program: class_list .
+    3 class_list: class_list . class
+
+    CLASS  shift, and go to state 1
+
+    $default  reduce using rule 1 (program)
+
+    class  go to state 7
+
+
+State 4
+
+    2 class_list: class .
+
+    $default  reduce using rule 2 (class_list)
+
+
+State 5
+
+    4 class: CLASS TYPEID . '{' dummy_feature_list '}' ';'
+    5      | CLASS TYPEID . INHERITS TYPEID '{' dummy_feature_list '}' ';'
+
+    INHERITS  shift, and go to state 8
+    '{'       shift, and go to state 9
+
+
+State 6
+
+    0 $accept: program $end .
+
+    $default  accept
+
+
+State 7
+
+    3 class_list: class_list class .
+
+    $default  reduce using rule 3 (class_list)
+
+
+State 8
+
+    5 class: CLASS TYPEID INHERITS . TYPEID '{' dummy_feature_list '}' ';'
+
+    TYPEID  shift, and go to state 10
+
+
+State 9
+
+    4 class: CLASS TYPEID '{' . dummy_feature_list '}' ';'
+
+    $default  reduce using rule 6 (dummy_feature_list)
+
+    dummy_feature_list  go to state 11
+
+
+State 10
+
+    5 class: CLASS TYPEID INHERITS TYPEID . '{' dummy_feature_list '}' ';'
+
+    '{'  shift, and go to state 12
+
+
+State 11
+
+    4 class: CLASS TYPEID '{' dummy_feature_list . '}' ';'
+
+    '}'  shift, and go to state 13
+
+
+State 12
+
+    5 class: CLASS TYPEID INHERITS TYPEID '{' . dummy_feature_list '}' ';'
+
+    $default  reduce using rule 6 (dummy_feature_list)
+
+    dummy_feature_list  go to state 14
+
+
+State 13
+
+    4 class: CLASS TYPEID '{' dummy_feature_list '}' . ';'
+
+    ';'  shift, and go to state 15
+
+
+State 14
+
+    5 class: CLASS TYPEID INHERITS TYPEID '{' dummy_feature_list . '}' ';'
+
+    '}'  shift, and go to state 16
+
+
+State 15
+
+    4 class: CLASS TYPEID '{' dummy_feature_list '}' ';' .
+
+    $default  reduce using rule 4 (class)
+
+
+State 16
+
+    5 class: CLASS TYPEID INHERITS TYPEID '{' dummy_feature_list '}' . ';'
+
+    ';'  shift, and go to state 17
+
+
+State 17
+
+    5 class: CLASS TYPEID INHERITS TYPEID '{' dummy_feature_list '}' ';' .
+
+    $default  reduce using rule 5 (class)
diff --git a/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/cool.tab.h b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/cool.tab.h
new file mode 100644
index 0000000..cd57a2b
--- /dev/null
+++ b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/cool.tab.h
@@ -0,0 +1,169 @@
+/* A Bison parser, made by GNU Bison 3.8.2.  */
+
+/* Bison interface for Yacc-like parsers in C
+
+   Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software Foundation,
+   Inc.
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
+
+/* As a special exception, you may create a larger work that contains
+   part or all of the Bison parser skeleton and distribute that work
+   under terms of your choice, so long as that work isn't itself a
+   parser generator using the skeleton or a modified version thereof
+   as a parser skeleton.  Alternatively, if you modify or redistribute
+   the parser skeleton itself, you may (at your option) remove this
+   special exception, which will cause the skeleton and the resulting
+   Bison output files to be licensed under the GNU General Public
+   License without this special exception.
+
+   This special exception was added by the Free Software Foundation in
+   version 2.2 of Bison.  */
+
+/* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual,
+   especially those whose name start with YY_ or yy_.  They are
+   private implementation details that can be changed or removed.  */
+
+#ifndef YY_COOL_YY_COOL_TAB_H_INCLUDED
+# define YY_COOL_YY_COOL_TAB_H_INCLUDED
+/* Debug traces.  */
+#ifndef YYDEBUG
+# define YYDEBUG 1
+#endif
+#if YYDEBUG
+extern int cool_yydebug;
+#endif
+
+/* Token kinds.  */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+  enum yytokentype
+  {
+    YYEMPTY = -2,
+    YYEOF = 0,                     /* "end of file"  */
+    YYerror = 256,                 /* error  */
+    YYUNDEF = 284,                 /* "invalid token"  */
+    CLASS = 258,                   /* CLASS  */
+    ELSE = 259,                    /* ELSE  */
+    FI = 260,                      /* FI  */
+    IF = 261,                      /* IF  */
+    IN = 262,                      /* IN  */
+    INHERITS = 263,                /* INHERITS  */
+    LET = 264,                     /* LET  */
+    LOOP = 265,                    /* LOOP  */
+    POOL = 266,                    /* POOL  */
+    THEN = 267,                    /* THEN  */
+    WHILE = 268,                   /* WHILE  */
+    CASE = 269,                    /* CASE  */
+    ESAC = 270,                    /* ESAC  */
+    OF = 271,                      /* OF  */
+    DARROW = 272,                  /* DARROW  */
+    NEW = 273,                     /* NEW  */
+    ISVOID = 274,                  /* ISVOID  */
+    STR_CONST = 275,               /* STR_CONST  */
+    INT_CONST = 276,               /* INT_CONST  */
+    BOOL_CONST = 277,              /* BOOL_CONST  */
+    TYPEID = 278,                  /* TYPEID  */
+    OBJECTID = 279,                /* OBJECTID  */
+    ASSIGN = 280,                  /* ASSIGN  */
+    NOT = 281,                     /* NOT  */
+    LE = 282,                      /* LE  */
+    ERROR = 283                    /* ERROR  */
+  };
+  typedef enum yytokentype yytoken_kind_t;
+#endif
+/* Token kinds.  */
+#define YYEMPTY -2
+#define YYEOF 0
+#define YYerror 256
+#define YYUNDEF 284
+#define CLASS 258
+#define ELSE 259
+#define FI 260
+#define IF 261
+#define IN 262
+#define INHERITS 263
+#define LET 264
+#define LOOP 265
+#define POOL 266
+#define THEN 267
+#define WHILE 268
+#define CASE 269
+#define ESAC 270
+#define OF 271
+#define DARROW 272
+#define NEW 273
+#define ISVOID 274
+#define STR_CONST 275
+#define INT_CONST 276
+#define BOOL_CONST 277
+#define TYPEID 278
+#define OBJECTID 279
+#define ASSIGN 280
+#define NOT 281
+#define LE 282
+#define ERROR 283
+
+/* Value type.  */
+#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
+union YYSTYPE
+{
+#line 89 "cool.y"
+
+      Boolean boolean;
+      Symbol symbol;
+      Program program;
+      Class_ class_;
+      Classes classes;
+      Feature feature;
+      Features features;
+      Formal formal;
+      Formals formals;
+      Case case_;
+      Cases cases;
+      Expression expression;
+      Expressions expressions;
+      char *error_msg;
+    
+
+#line 141 "cool.tab.h"
+
+};
+typedef union YYSTYPE YYSTYPE;
+# define YYSTYPE_IS_TRIVIAL 1
+# define YYSTYPE_IS_DECLARED 1
+#endif
+
+/* Location type.  */
+#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
+typedef struct YYLTYPE YYLTYPE;
+struct YYLTYPE
+{
+  int first_line;
+  int first_column;
+  int last_line;
+  int last_column;
+};
+# define YYLTYPE_IS_DECLARED 1
+# define YYLTYPE_IS_TRIVIAL 1
+#endif
+
+
+extern YYSTYPE cool_yylval;
+extern YYLTYPE cool_yylloc;
+
+int cool_yyparse (void);
+
+
+#endif /* !YY_COOL_YY_COOL_TAB_H_INCLUDED  */
diff --git a/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/cool.y b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/cool.y
new file mode 100644
index 0000000..40a8a47
--- /dev/null
+++ b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/cool.y
@@ -0,0 +1,229 @@
+/*
+*  cool.y
+*              Parser definition for the COOL language.
+*
+*/
+%{
+  #include <iostream>
+  #include "cool-tree.h"
+  #include "stringtab.h"
+  #include "utilities.h"
+  
+  extern char *curr_filename;
+  
+  
+  /* Locations */
+  #define YYLTYPE int              /* the type of locations */
+  #define cool_yylloc curr_lineno  /* use the curr_lineno from the lexer
+  for the location of tokens */
+    
+    extern int node_lineno;          /* set before constructing a tree node
+    to whatever you want the line number
+    for the tree node to be */
+      
+      
+      #define YYLLOC_DEFAULT(Current, Rhs, N)         \
+      Current = Rhs[1];                             \
+      node_lineno = Current;
+    
+    
+    #define SET_NODELOC(Current)  \
+    node_lineno = Current;
+    
+    /* IMPORTANT NOTE ON LINE NUMBERS
+    *********************************
+    * The above definitions and macros cause every terminal in your grammar to 
+    * have the line number supplied by the lexer. The only task you have to
+    * implement for line numbers to work correctly, is to use SET_NODELOC()
+    * before constructing any constructs from non-terminals in your grammar.
+    * Example: Consider you are matching on the following very restrictive 
+    * (fictional) construct that matches a plus between two integer constants. 
+    * (SUCH A RULE SHOULD NOT BE  PART OF YOUR PARSER):
+    
+    plus_consts	: INT_CONST '+' INT_CONST 
+    
+    * where INT_CONST is a terminal for an integer constant. Now, a correct
+    * action for this rule that attaches the correct line number to plus_const
+    * would look like the following:
+    
+    plus_consts	: INT_CONST '+' INT_CONST 
+    {
+      // Set the line number of the current non-terminal:
+      // ***********************************************
+      // You can access the line numbers of the i'th item with @i, just
+      // like you acess the value of the i'th exporession with $i.
+      //
+      // Here, we choose the line number of the last INT_CONST (@3) as the
+      // line number of the resulting expression (@$). You are free to pick
+      // any reasonable line as the line number of non-terminals. If you 
+      // omit the statement @$=..., bison has default rules for deciding which 
+      // line number to use. Check the manual for details if you are interested.
+      @$ = @3;
+      
+      
+      // Observe that we call SET_NODELOC(@3); this will set the global variable
+      // node_lineno to @3. Since the constructor call "plus" uses the value of 
+      // this global, the plus node will now have the correct line number.
+      SET_NODELOC(@3);
+      
+      // construct the result node:
+      $$ = plus(int_const($1), int_const($3));
+    }
+    
+    */
+    
+    
+    
+    void yyerror(char *s);        /*  defined below; called for each parse error */
+    extern int yylex();           /*  the entry point to the lexer  */
+    
+    /************************************************************************/
+    /*                DONT CHANGE ANYTHING IN THIS SECTION                  */
+    
+    Program ast_root;	      /* the result of the parse  */
+    Classes parse_results;        /* for use in semantic analysis */
+    int omerrs = 0;               /* number of errors in lexing and parsing */
+    %}
+    
+    /* A union of all the types that can be the result of parsing actions. */
+    %union {
+      Boolean boolean;
+      Symbol symbol;
+      Program program;
+      Class_ class_;
+      Classes classes;
+      Feature feature;
+      Features features;
+      Formal formal;
+      Formals formals;
+      Case case_;
+      Cases cases;
+      Expression expression;
+      Expressions expressions;
+      char *error_msg;
+    }
+    
+    /* 
+    Declare the terminals; a few have types for associated lexemes.
+    The token ERROR is never used in the parser; thus, it is a parse
+    error when the lexer returns it.
+    
+    The integer following token declaration is the numeric constant used
+    to represent that token internally.  Typically, Bison generates these
+    on its own, but we give explicit numbers to prevent version parity
+    problems (bison 1.25 and earlier start at 258, later versions -- at
+    257)
+    */
+    %token CLASS 258 ELSE 259 FI 260 IF 261 IN 262 
+    %token INHERITS 263 LET 264 LOOP 265 POOL 266 THEN 267 WHILE 268
+    %token CASE 269 ESAC 270 OF 271 DARROW 272 NEW 273 ISVOID 274
+    %token <symbol>  STR_CONST 275 INT_CONST 276 
+    %token <boolean> BOOL_CONST 277
+    %token <symbol>  TYPEID 278 OBJECTID 279 
+    %token ASSIGN 280 NOT 281 LE 282 ERROR 283
+    
+    /*  DON'T CHANGE ANYTHING ABOVE THIS LINE, OR YOUR PARSER WONT WORK       */
+    /**************************************************************************/
+    
+    /* Complete the nonterminal list below, giving a type for the semantic
+    value of each non terminal. (See section 3.6 in the bison 
+    documentation for details). */
+    
+    /* Declare types for the grammar's non-terminals. */
+    %type <program> program
+    %type <classes> class_list
+    %type <class_> class
+    
+    /* You will want to change the following line. */
+    %type <features> dummy_feature_list
+    
+    /* Precedence declarations go here. */
+    
+    
+    %%
+
+    program: class_list  { @$ = @1; ast_root = program($1); }
+           ;
+    
+    class_list: class             { $$ = single_Classes($1); parse_results = $$; } /* single class */
+              | class_list class  { $$ = append_Classes($1,single_Classes($2)); parse_results = $$; } /* several classes */
+              ;
+    
+    /* If no parent is specified, the class inherits from the Object class. */
+    class: CLASS TYPEID '{' dummy_feature_list '}' ';'                  { $$ = class_($2,idtable.add_string("Object"),$4, stringtable.add_string(curr_filename)); }
+         | CLASS TYPEID INHERITS TYPEID '{' dummy_feature_list '}' ';'  { $$ = class_($2,$4,$6,stringtable.add_string(curr_filename)); }
+         ;
+
+    attribute: OBJECTID ':' TYPEID
+             | OBJECTID ':' TYPEID ASSIGN expression ';'
+             ;
+
+    method: OBJECTID '(' method_attr ')' ':' TYPEID '{' expression '}' ';'
+          ;
+
+    method_attr: OBJECTID ':' TYPEID
+               | OBJECTID ':' TYPEID ',' method_attr
+               ;
+
+    expression: BOOL_CONST
+              | INT_CONST
+              | STR_CONST
+              | OBJECTID
+              | OBJECTID ASSIGN expression
+              | expression '.' OBJECTID '(' expression_list ')'
+              | OBJECTID '.' '(' expression_list ')'
+              | expression '@' TYPEID '.' 'i' 'd' '(' expression_list ')'
+              | IF expression THEN expression ELSE expression FI
+              | WHILE expression LOOP expression POOL
+              | expression_block
+              | LET OBJECTID ':' TYPED 
+              | CASE expression OF expression_cases ESAC
+              | NEW TYPEID
+              | ISVOID expression
+              | expression operator expression
+              | NOT expression
+              ;
+
+    expression_list: expression
+                   | expression ',' expression_list
+                   ;
+
+    expression_block: expression
+                    | expression ';' expression_block
+                    ;
+
+    expression_cases:
+                    | OBJECTID ':' TYPEID DARROW expression ';' expression_cases
+                    ;
+
+    operator: '+'
+            | '-'
+            | '*'
+            | '/'
+            | '<'
+            | '<' '='
+            | '='
+            ;
+
+    
+    /* Feature list may be empty, but no empty features in list. */
+    dummy_feature_list:  {  $$ = nil_Features(); } /* empty */
+                      ;
+    
+    
+    /* end of grammar */
+    %%
+    
+    /* This function is called automatically when Bison detects a parse error. */
+    void yyerror(char *s)
+    {
+      extern int curr_lineno;
+      
+      cerr << "\"" << curr_filename << "\", line " << curr_lineno << ": " \
+      << s << " at or near ";
+      print_cool_token(yychar);
+      cerr << endl;
+      omerrs++;
+      
+      if(omerrs>50) {fprintf(stdout, "More than 50 errors\n"); exit(1);}
+    }
diff --git a/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/dumptype.cc b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/dumptype.cc
new file mode 120000
index 0000000..b19d826
--- /dev/null
+++ b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/dumptype.cc
@@ -0,0 +1 @@
+/usr/class/cs143/cool/src/PA3/dumptype.cc
\ No newline at end of file
diff --git a/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/dumptype.d b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/dumptype.d
new file mode 100644
index 0000000..cff7235
--- /dev/null
+++ b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/dumptype.d
@@ -0,0 +1,11 @@
+dumptype.o dumptype.d : dumptype.cc /usr/class/cs143/cool/include/PA3/copyright.h \
+ /usr/class/cs143/cool/include/PA3/cool.h \
+ /usr/class/cs143/cool/include/PA3/copyright.h \
+ /usr/class/cs143/cool/include/PA3/cool-io.h \
+ /usr/class/cs143/cool/include/PA3/tree.h \
+ /usr/class/cs143/cool/include/PA3/stringtab.h \
+ /usr/class/cs143/cool/include/PA3/list.h \
+ /usr/class/cs143/cool/include/PA3/cool-tree.h \
+ /usr/class/cs143/cool/include/PA3/tree.h cool-tree.handcode.h \
+ /usr/class/cs143/cool/include/PA3/stringtab.h \
+ /usr/class/cs143/cool/include/PA3/utilities.h
diff --git a/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/good.cl b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/good.cl
new file mode 100644
index 0000000..8e61bd2
--- /dev/null
+++ b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/good.cl
@@ -0,0 +1,8 @@
+class A {
+ana(): Int {
+(let x:Int <- 1 in 2)+3
+};
+};
+
+Class BB__ inherits A {
+};
diff --git a/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/handle_flags.cc b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/handle_flags.cc
new file mode 120000
index 0000000..a125543
--- /dev/null
+++ b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/handle_flags.cc
@@ -0,0 +1 @@
+/usr/class/cs143/cool/src/PA3/handle_flags.cc
\ No newline at end of file
diff --git a/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/handle_flags.d b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/handle_flags.d
new file mode 100644
index 0000000..631279d
--- /dev/null
+++ b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/handle_flags.d
@@ -0,0 +1,5 @@
+handle_flags.o handle_flags.d : handle_flags.cc \
+ /usr/class/cs143/cool/include/PA3/copyright.h \
+ /usr/class/cs143/cool/include/PA3/cool-io.h \
+ /usr/class/cs143/cool/include/PA3/copyright.h \
+ /usr/class/cs143/cool/include/PA3/cgen_gc.h
diff --git a/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/mycoolc b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/mycoolc
new file mode 120000
index 0000000..609979e
--- /dev/null
+++ b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/mycoolc
@@ -0,0 +1 @@
+/usr/class/cs143/cool/src/PA3/mycoolc
\ No newline at end of file
diff --git a/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/myparser b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/myparser
new file mode 120000
index 0000000..13a2151
--- /dev/null
+++ b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/myparser
@@ -0,0 +1 @@
+/usr/class/cs143/cool/src/PA3/myparser
\ No newline at end of file
diff --git a/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/parser b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/parser
new file mode 100755
index 0000000..bdbd46f
--- /dev/null
+++ b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/parser
diff --git a/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/parser-phase.cc b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/parser-phase.cc
new file mode 120000
index 0000000..c8b3a98
--- /dev/null
+++ b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/parser-phase.cc
@@ -0,0 +1 @@
+/usr/class/cs143/cool/src/PA3/parser-phase.cc
\ No newline at end of file
diff --git a/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/parser-phase.d b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/parser-phase.d
new file mode 100644
index 0000000..5e57471
--- /dev/null
+++ b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/parser-phase.d
@@ -0,0 +1,14 @@
+parser-phase.o parser-phase.d : parser-phase.cc \
+ /usr/class/cs143/cool/include/PA3/copyright.h \
+ /usr/class/cs143/cool/include/PA3/cool-io.h \
+ /usr/class/cs143/cool/include/PA3/copyright.h \
+ /usr/class/cs143/cool/include/PA3/cool-tree.h \
+ /usr/class/cs143/cool/include/PA3/tree.h \
+ /usr/class/cs143/cool/include/PA3/stringtab.h \
+ /usr/class/cs143/cool/include/PA3/list.h \
+ /usr/class/cs143/cool/include/PA3/cool-io.h cool-tree.handcode.h \
+ /usr/class/cs143/cool/include/PA3/tree.h \
+ /usr/class/cs143/cool/include/PA3/cool.h \
+ /usr/class/cs143/cool/include/PA3/stringtab.h \
+ /usr/class/cs143/cool/include/PA3/utilities.h \
+ /usr/class/cs143/cool/include/PA3/cool-parse.h
diff --git a/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/semant b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/semant
new file mode 120000
index 0000000..5042ee2
--- /dev/null
+++ b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/semant
@@ -0,0 +1 @@
+/usr/class/cs143/cool/etc/../lib/.i686/PA3/semant
\ No newline at end of file
diff --git a/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/stringtab.cc b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/stringtab.cc
new file mode 120000
index 0000000..520e452
--- /dev/null
+++ b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/stringtab.cc
@@ -0,0 +1 @@
+/usr/class/cs143/cool/src/PA3/stringtab.cc
\ No newline at end of file
diff --git a/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/stringtab.d b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/stringtab.d
new file mode 100644
index 0000000..2399723
--- /dev/null
+++ b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/stringtab.d
@@ -0,0 +1,7 @@
+stringtab.o stringtab.d : stringtab.cc /usr/class/cs143/cool/include/PA3/copyright.h \
+ /usr/class/cs143/cool/include/PA3/stringtab_functions.h \
+ /usr/class/cs143/cool/include/PA3/copyright.h \
+ /usr/class/cs143/cool/include/PA3/cool-io.h \
+ /usr/class/cs143/cool/include/PA3/stringtab.h \
+ /usr/class/cs143/cool/include/PA3/list.h \
+ /usr/class/cs143/cool/include/PA3/stringtab.h
diff --git a/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/tokens-lex.cc b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/tokens-lex.cc
new file mode 120000
index 0000000..3f6ba60
--- /dev/null
+++ b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/tokens-lex.cc
@@ -0,0 +1 @@
+/usr/class/cs143/cool/src/PA3/tokens-lex.cc
\ No newline at end of file
diff --git a/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/tokens-lex.d b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/tokens-lex.d
new file mode 100644
index 0000000..4e4b4a1
--- /dev/null
+++ b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/tokens-lex.d
@@ -0,0 +1,9 @@
+tokens-lex.o tokens-lex.d : tokens-lex.cc \
+ /usr/class/cs143/cool/include/PA3/cool-parse.h \
+ /usr/class/cs143/cool/include/PA3/copyright.h \
+ /usr/class/cs143/cool/include/PA3/cool-io.h \
+ /usr/class/cs143/cool/include/PA3/tree.h \
+ /usr/class/cs143/cool/include/PA3/stringtab.h \
+ /usr/class/cs143/cool/include/PA3/list.h \
+ /usr/class/cs143/cool/include/PA3/stringtab.h \
+ /usr/class/cs143/cool/include/PA3/utilities.h
diff --git a/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/tree.cc b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/tree.cc
new file mode 120000
index 0000000..d4f4881
--- /dev/null
+++ b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/tree.cc
@@ -0,0 +1 @@
+/usr/class/cs143/cool/src/PA3/tree.cc
\ No newline at end of file
diff --git a/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/tree.d b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/tree.d
new file mode 100644
index 0000000..1d0c8f8
--- /dev/null
+++ b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/tree.d
@@ -0,0 +1,6 @@
+tree.o tree.d : tree.cc /usr/class/cs143/cool/include/PA3/copyright.h \
+ /usr/class/cs143/cool/include/PA3/tree.h \
+ /usr/class/cs143/cool/include/PA3/copyright.h \
+ /usr/class/cs143/cool/include/PA3/stringtab.h \
+ /usr/class/cs143/cool/include/PA3/list.h \
+ /usr/class/cs143/cool/include/PA3/cool-io.h
diff --git a/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/utilities.cc b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/utilities.cc
new file mode 120000
index 0000000..f31bd84
--- /dev/null
+++ b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/utilities.cc
@@ -0,0 +1 @@
+/usr/class/cs143/cool/src/PA3/utilities.cc
\ No newline at end of file
diff --git a/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/utilities.d b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/utilities.d
new file mode 100644
index 0000000..dda9a4e
--- /dev/null
+++ b/Year 3/Compilers, Introduction/coolc-spim/my-code/coursework/pa2/utilities.d
@@ -0,0 +1,10 @@
+utilities.o utilities.d : utilities.cc /usr/class/cs143/cool/include/PA3/copyright.h \
+ /usr/class/cs143/cool/include/PA3/cool-io.h \
+ /usr/class/cs143/cool/include/PA3/copyright.h \
+ /usr/class/cs143/cool/include/PA3/cool-parse.h \
+ /usr/class/cs143/cool/include/PA3/cool-io.h \
+ /usr/class/cs143/cool/include/PA3/tree.h \
+ /usr/class/cs143/cool/include/PA3/stringtab.h \
+ /usr/class/cs143/cool/include/PA3/list.h \
+ /usr/class/cs143/cool/include/PA3/stringtab.h \
+ /usr/class/cs143/cool/include/PA3/utilities.h