{"header":{"message":"Add coollang","description":null,"timestamp":"2024-05-02T23:00:40.757025067Z","authors":[{}]},"hash":"HVO7VLDMVEQEJOCLSKHWAICBXRYKCGKEDKXZOI44ITYTCDJBZ4UAC","authors":[{"key":"8Cqo1QjSCQ3F66Vh3nan9N8dv1MjQSAEz8RNwt2cTacK"}],"deps":{"hashes":[["HVO7VLDMVEQEJOCLSKHWAICBXRYKCGKEDKXZOI44ITYTCDJBZ4UAC","Add coollang"],["AA",null],["WHVW6V3W3CLY7I5JULWGSE44GYIN4O4IFYMXGXF2NGANED5AMC4QC",""]],"deps":["WHVW6V3W3CLY7I5JULWGSE44GYIN4O4IFYMXGXF2NGANED5AMC4QC"],"known":[]},"hunks":[{"FileAdd":{"meta":{"basename":"coollang","metadata":576},"context":[{"change":2,"pos":1}],"contents":[]}},{"FileAdd":{"meta":{"basename":"test","metadata":576},"context":[{"change":0,"pos":1}],"contents":[]}},{"FileAdd":{"meta":{"basename":"src","metadata":576},"context":[{"change":0,"pos":1}],"contents":[]}},{"FileAdd":{"meta":{"basename":"cgen.cc","metadata":0},"context":[{"change":0,"pos":41}],"contents":[{"Add":"// This is a personal academic project. Dear PVS-Studio, please check it."},{"Add":"// PVS-Studio Static Code Analyzer for C, C++, C#, and Java: https://pvs-studio.com"},{"Add":"/*********************************************************************"},{"Add":" Intermediate code generator for COOL: SKELETON"},{"Add":""},{"Add":" Read the comments carefully and add code to build an LLVM program"},{"Add":"*********************************************************************/"},{"Add":""},{"Add":"#define EXTERN"},{"Add":"#include \"cgen.h\""},{"Add":""},{"Add":"#include "},{"Add":"#include "},{"Add":"#include "},{"Add":"#include "},{"Add":""},{"Add":"// special assert that allows debugging to continue"},{"Add":"// https://nullprogram.com/blog/2024/01/28/"},{"Add":"#ifdef _MSC_VER"},{"Add":"#undef assert"},{"Add":"#define assert(c) do if (!(c)) { fprintf(stderr, \"Assertion %s failed [%d]\\n\", #c, __LINE__); __debugbreak(); } while (0)"},{"Add":"#define assertm(c, msg) do if (!(c)) { fprintf(stderr, \"Assertion %s failed [%d]: %s\\n\", #c, __LINE__, msg); __debugbreak(); } while (0)"},{"Add":"#elif defined __x86_64__"},{"Add":"#undef assert"},{"Add":"#define assert(c) do if (!(c)) { fprintf(stderr, \"Assertion %s failed [%d]\\n\", #c, __LINE__); asm (\"int3; nop\"); } while (0)"},{"Add":"#define assertm(c, msg) do if (!(c)) { fprintf(stderr, \"Assertion %s failed [%d]: %s\\n\", #c, __LINE__, msg); asm (\"int3; nop\"); } while (0)"},{"Add":"#endif"},{"Add":""},{"Add":""},{"Add":"extern int cgen_debug, curr_lineno;"},{"Add":"using namespace llvm;"},{"Add":"/*********************************************************************"},{"Add":" For convenience, a large number of symbols are predefined here."},{"Add":" These symbols include the primitive type and method names, as well"},{"Add":" as fixed names used by the runtime system. Feel free to add your"},{"Add":" own definitions as you see fit."},{"Add":"*********************************************************************/"},{"Add":"EXTERN Symbol"},{"Add":" // required classes"},{"Add":" Object,"},{"Add":" IO, String, Int, Bool, Main,"},{"Add":""},{"Add":" // class methods"},{"Add":" cool_abort, type_name, cool_copy, out_string, out_int, in_string, in_int,"},{"Add":" length, concat, substr,"},{"Add":""},{"Add":" // class members"},{"Add":" val,"},{"Add":""},{"Add":" // special symbols"},{"Add":" No_class, // symbol that can't be the name of any user-defined class"},{"Add":" No_type, // If e : No_type, then no code is generated for e."},{"Add":" SELF_TYPE, // Special code is generated for new SELF_TYPE."},{"Add":" self, // self generates code differently than other references"},{"Add":""},{"Add":" // extras"},{"Add":" arg, arg2, newobj, Mainmain, prim_string, prim_int, prim_bool;"},{"Add":""},{"Add":"namespace"},{"Add":"{"},{"Add":"std::string as_string(Symbol) __attribute((pure));"},{"Add":""},{"Add":"std::vector unfuck(Expressions) __attribute((pure));"},{"Add":""},{"Add":"std::vector unfuck(Formals) __attribute((pure));"},{"Add":""},{"Add":"std::vector unfuck(Features) __attribute((pure));"},{"Add":""},{"Add":"std::pair resolve_opaque(Value*) __attribute((pure));"},{"Add":""},{"Add":"std::pair split(const std::string&, char) __attribute((pure));"},{"Add":""},{"Add":"template"},{"Add":"std::vector map(std::vector src, std::function mapper) __attribute((pure, optimize(\"O3\")));"},{"Add":""},{"Add":" "},{"Add":"// Initializing the predefined symbols."},{"Add":"void initialize_constants()"},{"Add":"{"},{"Add":" Object = idtable.add_string(\"Object\");"},{"Add":" IO = idtable.add_string(\"IO\");"},{"Add":" String = idtable.add_string(\"String\");"},{"Add":" Int = idtable.add_string(\"Int\");"},{"Add":" Bool = idtable.add_string(\"Bool\");"},{"Add":" Main = idtable.add_string(\"Main\");"},{"Add":""},{"Add":" cool_abort = idtable.add_string(\"abort\");"},{"Add":" type_name = idtable.add_string(\"type_name\");"},{"Add":" cool_copy = idtable.add_string(\"copy\");"},{"Add":" out_string = idtable.add_string(\"out_string\");"},{"Add":" out_int = idtable.add_string(\"out_int\");"},{"Add":" in_string = idtable.add_string(\"in_string\");"},{"Add":" in_int = idtable.add_string(\"in_int\");"},{"Add":" length = idtable.add_string(\"length\");"},{"Add":" ::concat = idtable.add_string(\"concat\");"},{"Add":" substr = idtable.add_string(\"substr\");"},{"Add":""},{"Add":" val = idtable.add_string(\"val\");"},{"Add":""},{"Add":" No_class = idtable.add_string(\"_no_class\");"},{"Add":" No_type = idtable.add_string(\"_no_type\");"},{"Add":" SELF_TYPE = idtable.add_string(\"SELF_TYPE\");"},{"Add":" self = idtable.add_string(\"self\");"},{"Add":""},{"Add":" arg = idtable.add_string(\"arg\");"},{"Add":" arg2 = idtable.add_string(\"arg2\");"},{"Add":" newobj = idtable.add_string(\"_newobj\");"},{"Add":" Mainmain = idtable.add_string(\"main\");"},{"Add":" prim_string = idtable.add_string(\"sbyte*\");"},{"Add":" prim_int = idtable.add_string(\"int\");"},{"Add":" prim_bool = idtable.add_string(\"bool\");"},{"Add":"}"},{"Add":"}"},{"Add":""},{"Add":"#pragma region \"CgenClassTable\""},{"Add":"// CgenClassTable constructor orchestrates all code generation"},{"Add":"CgenClassTable::CgenClassTable(Classes classes)"},{"Add":" : nds(), current_tag(0), context(), builder(this->context),"},{"Add":" the_module(stringtable.get_file(), this->context), di_builder(the_module)"},{"Add":"{"},{"Add":" if (cgen_debug)"},{"Add":" std::cerr << \"Building CgenClassTable\" << std::endl;"},{"Add":""},{"Add":" i1 = Type::getInt1Ty(this->context);"},{"Add":" i8 = Type::getInt8Ty(this->context);"},{"Add":" i32 = Type::getInt32Ty(this->context);"},{"Add":" ptr = i8->getPointerTo();"},{"Add":" void_ = Type::getVoidTy(this->context);"},{"Add":""},{"Add":" #ifdef EMIT_DBG"},{"Add":" the_module.addModuleFlag(Module::Warning, \"Debug Info Version\", DEBUG_METADATA_VERSION);"},{"Add":""},{"Add":" di_file = di_builder.createFile(stringtable.get_file(), \".\");"},{"Add":" di_cu = di_builder.createCompileUnit(dwarf::DW_LANG_C, di_file, \"ibn222_ece479k_lab2\","},{"Add":" false, (cgen_debug) ? \"-d\" : \"\", 0);"},{"Add":""},{"Add":" di1 = di_builder.createBasicType(\"bool\", 1, dwarf::DW_ATE_signed);"},{"Add":" di8 = di_builder.createBasicType(\"cbool\", 8, dwarf::DW_ATE_signed);"},{"Add":" di32 = di_builder.createBasicType(\"int\", 32, dwarf::DW_ATE_signed);"},{"Add":" dptr = di_builder.createPointerType(di8, 64, 0, std::nullopt, \"opaque_ptr\");"},{"Add":" dvoid = di_builder.createNullPtrType();"},{"Add":" #endif"},{"Add":""},{"Add":""},{"Add":" // Make sure we have a scope, both for classes and for constants"},{"Add":" enterscope();"},{"Add":""},{"Add":" // Create an inheritance tree with one CgenNode per class."},{"Add":" install_basic_classes();"},{"Add":" install_classes(classes);"},{"Add":" build_inheritance_tree();"},{"Add":""},{"Add":" // First pass"},{"Add":" setup();"},{"Add":""},{"Add":" // Second pass"},{"Add":" code_module();"},{"Add":" // Done with code generation: exit scopes"},{"Add":" exitscope();"},{"Add":""},{"Add":" #ifdef EMIT_DBG"},{"Add":" // finalize debug info"},{"Add":" di_builder.finalize();"},{"Add":" #endif"},{"Add":"}"},{"Add":""},{"Add":"// Creates AST nodes for the basic classes and installs them in the class list"},{"Add":"void CgenClassTable::install_basic_classes()"},{"Add":"{"},{"Add":" // The tree package uses these globals to annotate the classes built below."},{"Add":" curr_lineno = 0;"},{"Add":" Symbol filename = stringtable.add_string(\"\");"},{"Add":""},{"Add":" //"},{"Add":" // A few special class names are installed in the lookup table but not"},{"Add":" // the class list. Thus, these classes exist, but are not part of the"},{"Add":" // inheritance hierarchy."},{"Add":""},{"Add":" // No_class serves as the parent of Object and the other special classes."},{"Add":" Class_ noclasscls = class_(No_class, No_class, nil_Features(), filename);"},{"Add":" install_special_class(new CgenNode(noclasscls, CgenNode::Basic, this));"},{"Add":" delete noclasscls;"},{"Add":""},{"Add":""},{"Add":" // SELF_TYPE is the self class; it cannot be redefined or inherited."},{"Add":" Class_ selftypecls = class_(SELF_TYPE, No_class, nil_Features(), filename);"},{"Add":" install_special_class(new CgenNode(selftypecls, CgenNode::Basic, this));"},{"Add":" delete selftypecls;"},{"Add":" //"},{"Add":" // Primitive types masquerading as classes. This is done so we can"},{"Add":" // get the necessary Symbols for the innards of String, Int, and Bool"},{"Add":" //"},{"Add":" Class_ primstringcls ="},{"Add":" class_(prim_string, No_class, nil_Features(), filename);"},{"Add":" install_special_class(new CgenNode(primstringcls, CgenNode::Basic, this));"},{"Add":" delete primstringcls;"},{"Add":""},{"Add":" Class_ primintcls = class_(prim_int, No_class, nil_Features(), filename);"},{"Add":" install_special_class(new CgenNode(primintcls, CgenNode::Basic, this));"},{"Add":" delete primintcls;"},{"Add":" Class_ primboolcls = class_(prim_bool, No_class, nil_Features(), filename);"},{"Add":" install_special_class(new CgenNode(primboolcls, CgenNode::Basic, this));"},{"Add":" delete primboolcls;"},{"Add":" //"},{"Add":" // The Object class has no parent class. Its methods are"},{"Add":" // cool_abort() : Object aborts the program"},{"Add":" // type_name() : Str returns a string representation of class name"},{"Add":" // copy() : SELF_TYPE returns a copy of the object"},{"Add":" //"},{"Add":" // There is no need for method bodies in the basic classes---these"},{"Add":" // are already built in to the runtime system."},{"Add":" //"},{"Add":" Class_ objcls = class_("},{"Add":" Object, No_class,"},{"Add":" append_Features("},{"Add":" append_Features(single_Features(method(cool_abort, nil_Formals(),"},{"Add":" Object, no_expr())),"},{"Add":" single_Features(method(type_name, nil_Formals(),"},{"Add":" String, no_expr()))),"},{"Add":" single_Features("},{"Add":" method(cool_copy, nil_Formals(), SELF_TYPE, no_expr()))),"},{"Add":" filename);"},{"Add":" install_class(new CgenNode(objcls, CgenNode::Basic, this));"},{"Add":" delete objcls;"},{"Add":""},{"Add":" //"},{"Add":" // The Int class has no methods and only a single attribute, the"},{"Add":" // \"val\" for the integer."},{"Add":" //"},{"Add":" Class_ intcls = class_("},{"Add":" Int, Object, single_Features(attr(val, prim_int, no_expr())), filename);"},{"Add":" install_class(new CgenNode(intcls, CgenNode::Basic, this));"},{"Add":" delete intcls;"},{"Add":""},{"Add":" //"},{"Add":" // Bool also has only the \"val\" slot."},{"Add":" //"},{"Add":" Class_ boolcls = class_("},{"Add":" Bool, Object, single_Features(attr(val, prim_bool, no_expr())),"},{"Add":" filename);"},{"Add":" install_class(new CgenNode(boolcls, CgenNode::Basic, this));"},{"Add":" delete boolcls;"},{"Add":""},{"Add":""},{"Add":" //"},{"Add":" // The class String has a number of slots and operations:"},{"Add":" // val the string itself"},{"Add":" // length() : Int length of the string"},{"Add":" // concat(arg: Str) : Str string concatenation"},{"Add":" // substr(arg: Int, arg2: Int): Str substring"},{"Add":" //"},{"Add":" Class_ stringcls ="},{"Add":" class_(String, Object,"},{"Add":" append_Features("},{"Add":" append_Features("},{"Add":" append_Features("},{"Add":" single_Features("},{"Add":" attr(val, prim_string, no_expr())),"},{"Add":" single_Features("},{"Add":" method(length, nil_Formals(), Int,"},{"Add":" no_expr()))),"},{"Add":" single_Features(method(::concat,"},{"Add":" single_Formals("},{"Add":" formal(arg, String)),"},{"Add":" String, no_expr()))),"},{"Add":" single_Features("},{"Add":" method(substr,"},{"Add":" append_Formals("},{"Add":" single_Formals(formal(arg, Int)),"},{"Add":" single_Formals(formal(arg2, Int))),"},{"Add":" String, no_expr()))),"},{"Add":" filename);"},{"Add":" install_class(new CgenNode(stringcls, CgenNode::Basic, this));"},{"Add":" delete stringcls;"},{"Add":""},{"Add":""},{"Add":" //"},{"Add":" // The IO class inherits from Object. Its methods are"},{"Add":" // out_string(Str) : SELF_TYPE writes a string to the output"},{"Add":" // out_int(Int) : SELF_TYPE \" an int \" \" \""},{"Add":" // in_string() : Str reads a string from the input"},{"Add":" // in_int() : Int \" an int \" \" \""},{"Add":" //"},{"Add":" Class_ iocls = class_("},{"Add":" IO, Object,"},{"Add":" append_Features("},{"Add":" append_Features("},{"Add":" append_Features("},{"Add":" single_Features(method(out_string,"},{"Add":" single_Formals(formal(arg, String)),"},{"Add":" SELF_TYPE, no_expr())),"},{"Add":" single_Features(method(out_int,"},{"Add":" single_Formals(formal(arg, Int)),"},{"Add":" SELF_TYPE, no_expr()))),"},{"Add":" single_Features("},{"Add":" method(in_string, nil_Formals(), String, no_expr()))),"},{"Add":" single_Features(method(in_int, nil_Formals(), Int, no_expr()))),"},{"Add":" filename);"},{"Add":" install_class(new CgenNode(iocls, CgenNode::Basic, this));"},{"Add":" delete iocls;"},{"Add":"}"},{"Add":""},{"Add":"// install_classes enters a list of classes in the symbol table."},{"Add":"void CgenClassTable::install_classes(Classes cs)"},{"Add":"{"},{"Add":" for (auto cls: cs) {"},{"Add":" install_class(new CgenNode(cls, CgenNode::NotBasic, this));"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"// Add this CgenNode to the class list and the lookup table"},{"Add":"void CgenClassTable::install_class(CgenNode* nd)"},{"Add":"{"},{"Add":" Symbol name = nd->get_name();"},{"Add":" if (!this->find(name)) {"},{"Add":" // The class name is legal, so add it to the list of classes"},{"Add":" // and the symbol table."},{"Add":" nds.push_back(nd);"},{"Add":" this->insert(name, nd);"},{"Add":" }"},{"Add":" // Prevent circular dependency issues when using this CgenNode later"},{"Add":" nd->premake_type();"},{"Add":" // nd->premake_debug_type();"},{"Add":"}"},{"Add":""},{"Add":"// Add this CgenNode to the special class list and the lookup table"},{"Add":"void CgenClassTable::install_special_class(CgenNode* nd)"},{"Add":"{"},{"Add":" Symbol name = nd->get_name();"},{"Add":" if (!this->find(name)) {"},{"Add":" // The class name is legal, so add it to the list of special classes"},{"Add":" // and the symbol table."},{"Add":" special_nds.push_back(nd);"},{"Add":" this->insert(name, nd);"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"// CgenClassTable::build_inheritance_tree"},{"Add":"void CgenClassTable::build_inheritance_tree()"},{"Add":"{"},{"Add":" for (auto node: nds)"},{"Add":" set_relations(node);"},{"Add":"}"},{"Add":""},{"Add":"// CgenClassTable::set_relations"},{"Add":"// Takes a CgenNode and locates its, and its parent's, inheritance nodes"},{"Add":"// via the class table. Parent and child pointers are added as appropriate."},{"Add":"//"},{"Add":"void CgenClassTable::set_relations(CgenNode* nd)"},{"Add":"{"},{"Add":" Symbol parent = nd->get_parent();"},{"Add":" auto parent_node = this->find(parent);"},{"Add":" if (!parent_node) {"},{"Add":" throw std::runtime_error(\"Class \" + nd->get_name()->get_string() +"},{"Add":" \" inherits from an undefined class \" +"},{"Add":" parent->get_string());"},{"Add":" }"},{"Add":" nd->set_parent(parent_node);"},{"Add":"}"},{"Add":""},{"Add":"// Sets up declarations for extra functions needed for code generation"},{"Add":"// You should not need to modify this code for Lab1"},{"Add":"void CgenClassTable::setup_external_functions()"},{"Add":"{"},{"Add":" // setup function: external int strcmp(ptr, ptr)"},{"Add":" create_llvm_function(\"strcmp\", i32, {ptr, ptr}, false);"},{"Add":" // setup function: external int printf(ptr, ...)"},{"Add":" create_llvm_function(\"printf\", i32, {ptr}, true);"},{"Add":" // setup function: external void abort(void)"},{"Add":" create_llvm_function(\"abort\", void_, {}, false);"},{"Add":" // setup function: external ptr malloc(i32)"},{"Add":" create_llvm_function(\"malloc\", ptr, {i32}, false);"},{"Add":" // setup function: external void free(ptr)"},{"Add":" create_llvm_function(\"free\", void_, {ptr}, false);"},{"Add":""},{"Add":""},{"Add":" auto* ObjectTy = ptr;"},{"Add":" create_function(\"Object_new\", ObjectTy, {}, GlobalValue::ExternalLinkage);"},{"Add":""},{"Add":" auto* IntTy = ptr;"},{"Add":" create_function(\"Int_new\", IntTy, {}, GlobalValue::ExternalLinkage);"},{"Add":" create_function(\"Int_init\", IntTy, {IntTy, i32}, GlobalValue::ExternalLinkage);"},{"Add":""},{"Add":" auto* BoolTy = ptr;"},{"Add":" create_function(\"Bool_new\", BoolTy, {}, GlobalValue::ExternalLinkage);"},{"Add":" // this takes a i8 because C's bool is byte"},{"Add":" create_function(\"Bool_init\", BoolTy, {BoolTy, i8}, GlobalValue::ExternalLinkage);"},{"Add":""},{"Add":" auto* StringTy = ptr;"},{"Add":" create_function(\"String_new\", StringTy, {}, GlobalValue::ExternalLinkage);"},{"Add":""},{"Add":" auto* IoTy = ptr;"},{"Add":" create_function(\"IO_new\", IoTy, {}, GlobalValue::ExternalLinkage);"},{"Add":"}"},{"Add":""},{"Add":"void CgenClassTable::setup_classes(CgenNode* c, int depth)"},{"Add":"{"},{"Add":" c->setup(current_tag++, depth);"},{"Add":" for (auto child: c->get_children()) {"},{"Add":" setup_classes(child, depth + 1);"},{"Add":" }"},{"Add":" c->set_max_child(current_tag - 1);"},{"Add":"}"},{"Add":""},{"Add":"// The code generation first pass. Define these two functions to traverse"},{"Add":"// the tree and setup each CgenNode"},{"Add":"void CgenClassTable::setup()"},{"Add":"{"},{"Add":" setup_external_functions();"},{"Add":" setup_classes(root(), 0);"},{"Add":""},{"Add":" // setup_external_functions();"},{"Add":"}"},{"Add":""},{"Add":"// The code generation second pass. Add code here to traverse the tree and"},{"Add":"// emit code for each CgenNode"},{"Add":"void CgenClassTable::code_module()"},{"Add":"{"},{"Add":" code_constants();"},{"Add":" code_classes(root());"},{"Add":" code_main();"},{"Add":""},{"Add":" if (cgen_debug)"},{"Add":" std::cerr << \"\\n\";"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"void CgenClassTable::code_classes(CgenNode* c)"},{"Add":"{"},{"Add":" // emit Object first"},{"Add":" if (c->get_type_name() == \"Object\") {"},{"Add":" if (cgen_debug)"},{"Add":" std::cerr << \"\\n\\nEmitting classes\\n\";"},{"Add":" c->code_class();"},{"Add":" }"},{"Add":""},{"Add":" std::vector classes{c->get_children()};"},{"Add":""},{"Add":" for (auto const i: classes)"},{"Add":" i->code_class();"},{"Add":""},{"Add":" // we need to generate top down so that the types are populated for inherited classes"},{"Add":" for (auto* i: classes)"},{"Add":" code_classes(i);"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"// Create global definitions for constant Cool objects"},{"Add":"void CgenClassTable::code_constants()"},{"Add":"{"},{"Add":" if (cgen_debug)"},{"Add":" std::cerr << \"\\n\\nEmitting constants\\n\";"},{"Add":""},{"Add":" stringtable.code_string_table(this);"},{"Add":"}"},{"Add":""},{"Add":"// Create LLVM entry point. This function will initiate our Cool program"},{"Add":"// by generating the code to execute (new Main).main()"},{"Add":"//"},{"Add":"void CgenClassTable::code_main()"},{"Add":"{"},{"Add":" if (cgen_debug)"},{"Add":" std::cerr << \"\\n\\nEmitting main\\n\";"},{"Add":" // Define a function main that has no parameters and returns an i32"},{"Add":" auto* fn = create_function(\"main\", i32, {},"},{"Add":" GlobalValue::ExternalLinkage);"},{"Add":" // Define an entry basic block"},{"Add":" auto* bb = BasicBlock::Create(this->context, \"main_entry_point\", fn);"},{"Add":" builder.SetInsertPoint(bb);"},{"Add":""},{"Add":" // Call Main_new() to create a Main"},{"Add":" auto* main_new = the_module.getFunction(\"Main_new\");"},{"Add":" assertm(main_new, \"Main_new exists\");"},{"Add":" auto* main = builder.CreateCall(main_new, {});"},{"Add":""},{"Add":" // Call Main_main"},{"Add":" auto* main_main = the_module.getFunction(\"Main_main\");"},{"Add":" assertm(main_main, \"Main_main exists\");"},{"Add":" auto* main_returned = builder.CreateCall(main_main, {main});"},{"Add":""},{"Add":" // Always return 0"},{"Add":" builder.CreateRet(builder.getInt32(0));"},{"Add":"}"},{"Add":""},{"Add":"// Get the root of the class tree."},{"Add":"CgenNode* CgenClassTable::root()"},{"Add":"{"},{"Add":" auto root = this->find(Object);"},{"Add":" if (!root) {"},{"Add":" throw std::runtime_error(\"Class Object is not defined.\");"},{"Add":" }"},{"Add":" return root;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"Function* CgenClassTable::create_llvm_function(const std::string &funcName,"},{"Add":" Type* retType,"},{"Add":" ArrayRef argTypes,"},{"Add":" bool isVarArgs)"},{"Add":"{"},{"Add":" assert(retType);"},{"Add":" auto* ft = FunctionType::get(retType, argTypes, isVarArgs);"},{"Add":" auto* func = Function::Create(ft, Function::ExternalLinkage, funcName,"},{"Add":" this->the_module);"},{"Add":" if (!func) {"},{"Add":" errs() << \"Function creation failed for function \" << funcName;"},{"Add":" llvm_unreachable(\"Function creation failed\");"},{"Add":" }"},{"Add":" return func;"},{"Add":"}"},{"Add":""},{"Add":"Function* CgenClassTable::create_function(const std::string &name,"},{"Add":" Type* ret_type,"},{"Add":" ArrayRef arg_types,"},{"Add":" GlobalValue::LinkageTypes linkage)"},{"Add":"{"},{"Add":" assert(ret_type);"},{"Add":" auto* ft = FunctionType::get(ret_type, arg_types, false);"},{"Add":" auto* func = Function::Create(ft, linkage, name,"},{"Add":" this->the_module);"},{"Add":" if (!func) {"},{"Add":" errs() << \"Function creation failed for function \" << name;"},{"Add":" llvm_unreachable(\"Function creation failed\");"},{"Add":" }"},{"Add":" return func;"},{"Add":"}"},{"Add":""},{"Add":"Function* CgenClassTable::create_var_function(const std::string &name,"},{"Add":" Type* ret_type,"},{"Add":" ArrayRef arg_types,"},{"Add":" GlobalValue::LinkageTypes linkage)"},{"Add":"{"},{"Add":" assert(ret_type);"},{"Add":" auto* ft = FunctionType::get(ret_type, arg_types, true);"},{"Add":" auto* func = Function::Create(ft, linkage, name,"},{"Add":" this->the_module);"},{"Add":" if (!func) {"},{"Add":" errs() << \"Function creation failed for function \" << name;"},{"Add":" llvm_unreachable(\"Function creation failed\");"},{"Add":" }"},{"Add":" return func;"},{"Add":"}"},{"Add":""},{"Add":"#pragma endregion"},{"Add":""},{"Add":"#pragma region \"stringtab\""},{"Add":"/*********************************************************************"},{"Add":""},{"Add":" StrTable / IntTable methods"},{"Add":""},{"Add":" Coding string, int, and boolean constants"},{"Add":""},{"Add":" Cool has three kinds of constants: strings, ints, and booleans."},{"Add":" This section defines code generation for each type."},{"Add":""},{"Add":" All string constants are listed in the global \"stringtable\" and have"},{"Add":" type stringEntry. stringEntry methods are defined both for string"},{"Add":" constant definitions and references."},{"Add":""},{"Add":" All integer constants are listed in the global \"inttable\" and have"},{"Add":" type IntEntry. IntEntry methods are defined for Int constant references only."},{"Add":""},{"Add":" Since there are only two Bool values, there is no need for a table."},{"Add":" The two booleans are represented by instances of the class BoolConst,"},{"Add":" which defines the definition and reference methods for Bools."},{"Add":""},{"Add":"*********************************************************************/"},{"Add":""},{"Add":"// Create definitions for all String constants"},{"Add":"void StrTable::code_string_table(CgenClassTable* ct)"},{"Add":"{"},{"Add":" if (cgen_debug)"},{"Add":" std::cerr << \"Emitting string table\\n\";"},{"Add":""},{"Add":" for (auto &[_, entry]: this->_table) {"},{"Add":" entry.code_def(ct);"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"std::string StrTable::get_file() const"},{"Add":"{"},{"Add":" auto it = _table.cbegin();"},{"Add":" for (int i = 0; i < _table.size() - 1; ++i)"},{"Add":" it++;"},{"Add":" return it->first;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"// generate code to define a global string constant"},{"Add":"void StringEntry::code_def(CgenClassTable* ct)"},{"Add":"{"},{"Add":" if (cgen_debug)"},{"Add":" std::cerr << \"\\tEmitting \\\"\" << this->str << \"\\\"\\n\";"},{"Add":""},{"Add":" auto* string = ct->find(String);"},{"Add":""},{"Add":" auto* gstr = ct->builder.CreateGlobalStringPtr(this->str, \"\", 0, &ct->the_module);"},{"Add":" auto* init = ConstantStruct::get(string->type, {string->vtable, gstr});"},{"Add":""},{"Add":" ptr = new GlobalVariable(ct->the_module, string->type, true,"},{"Add":" GlobalValue::InternalLinkage, init);"},{"Add":"}"},{"Add":""},{"Add":"void StringEntry::code_ref(CgenClassTable *ct)"},{"Add":"{"},{"Add":" // TODO: add code here"},{"Add":"}"},{"Add":""},{"Add":"void IntEntry::code_ref(CgenClassTable *ct)"},{"Add":"{"},{"Add":" // TODO: add code here"},{"Add":"}"},{"Add":"#pragma endregion"},{"Add":""},{"Add":"#pragma region \"CgenNode\""},{"Add":"//"},{"Add":"// Class setup. You may need to add parameters to this function so that"},{"Add":"// the classtable can provide setup information (such as the class tag"},{"Add":"// that should be used by this class)."},{"Add":"//"},{"Add":"// Things that setup should do:"},{"Add":"// - layout the features of the class"},{"Add":"// - create the types for the class and its vtable"},{"Add":"// - create global definitions used by the class such as the class vtable"},{"Add":"//"},{"Add":"void CgenNode::setup(int const tag, int const depth)"},{"Add":"{"},{"Add":" if (cgen_debug)"},{"Add":" std::cerr << \"Setting up \" << get_type_name() << \"\\n\";"},{"Add":""},{"Add":" this->tag = tag;"},{"Add":""},{"Add":" auto* env = new CgenEnvironment(this);"},{"Add":""},{"Add":" layout_features();"},{"Add":""},{"Add":" this->make_vtable_type(env);"},{"Add":" this->make_type_forrealz(env);"},{"Add":" this->make_vtable_prototype(env);"},{"Add":""},{"Add":" if (cgen_debug) {"},{"Add":" std::cerr << \"\\t\";"},{"Add":" this->type->print(errs(), true), errs() << \"\\n\";"},{"Add":" std::cerr << \"\\t\";"},{"Add":" this->vtable_type->print(errs(), true), errs() << \"\\n\";"},{"Add":" }"},{"Add":""},{"Add":" // need to declare an init function if it doesn't already exist"},{"Add":" if (!basic())"},{"Add":" class_table->create_function(get_init_function_name(), type->getPointerTo(), {}, GlobalValue::ExternalLinkage);"},{"Add":""},{"Add":" delete env;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"// Laying out the features involves creating a Function for each method"},{"Add":"// and assigning each attribute a slot in the class structure."},{"Add":"void CgenNode::layout_features()"},{"Add":"{"},{"Add":" // append parent's shit to our shit (so that the object methods come first)"},{"Add":" if (parentnd && parentnd->get_type_name() != \"_no_class\") {"},{"Add":" methods.insert(methods.end(), parentnd->methods.begin(), parentnd->methods.end());"},{"Add":" attributes.insert(attributes.end(), parentnd->attributes.begin(), parentnd->attributes.end());"},{"Add":" }"},{"Add":""},{"Add":" // the type for the class is declared when its CgenNode is installed"},{"Add":" // so that other classes can be referenced when features are laid out"},{"Add":" for (int i = features->first(); features->more(i); i = features->next(i))"},{"Add":" features->nth(i)->layout_feature(this);"},{"Add":"}"},{"Add":""},{"Add":"// Class codegen. This should performed after every class has been setup."},{"Add":"// Generate code for each method of the class."},{"Add":"void CgenNode::code_class()"},{"Add":"{"},{"Add":" // No code generation for basic classes. The runtime will handle that."},{"Add":" if (basic())"},{"Add":" return;"},{"Add":""},{"Add":" if (cgen_debug)"},{"Add":" std::cerr << \"\\n\\nEmitting \" + get_type_name() << \"\\n\";"},{"Add":""},{"Add":" auto* env = new CgenEnvironment(this);"},{"Add":""},{"Add":" if (cgen_debug)"},{"Add":" std::cerr << \"Emitting methods\\n\";"},{"Add":" for (auto [m, _]: methods) {"},{"Add":" if (cgen_debug)"},{"Add":" std::cerr << \"\\tEmitting \" << m->qualified_name << \"\\n\";"},{"Add":""},{"Add":" m->code(env);"},{"Add":" }"},{"Add":""},{"Add":" this->code_init_function(env);"},{"Add":""},{"Add":" delete env;"},{"Add":"}"},{"Add":""},{"Add":""},{"Add":"void CgenNode::code_init_function(CgenEnvironment* env) const"},{"Add":"{"},{"Add":" assert(type != nullptr);"},{"Add":" assert(vtable_type != nullptr);"},{"Add":" assert(vtable != nullptr);"},{"Add":" if (cgen_debug)"},{"Add":" std::cerr << \"Emitting constructor \" << get_init_function_name() << \"\\n\";"},{"Add":""},{"Add":" auto* init = env->the_module.getFunction(get_init_function_name());"},{"Add":" assert(init);"},{"Add":" auto* bb = BasicBlock::Create(env->context, \"constructor\", init);"},{"Add":" auto* gbb = BasicBlock::Create(env->context, \"alloc_success\", init);"},{"Add":" auto* abort = env->get_or_insert_abort_block(init);"},{"Add":" env->builder.SetInsertPoint(bb);"},{"Add":""},{"Add":" // allocate space for ptr to type"},{"Add":" assert(type->isSized());"},{"Add":" auto* heap = env->builder.CreateCall(env->the_module.getFunction(\"malloc\"), {"},{"Add":" ConstantInt::get(i32,"},{"Add":" env->data_layout.getTypeAllocSize(type))"},{"Add":" });"},{"Add":""},{"Add":" Value* is_nullptr = env->builder.CreateICmpEQ(heap, ConstantPointerNull::get(ptr));"},{"Add":" env->builder.CreateCondBr(is_nullptr, abort, gbb);"},{"Add":""},{"Add":" env->builder.SetInsertPoint(gbb);"},{"Add":" auto* mem = env->insert_alloca_at_head(type->getPointerTo(), \"n.mem\");"},{"Add":" env->builder.CreateStore(heap, mem);"},{"Add":" auto* hptr = env->builder.CreateLoad(type->getPointerTo(), mem, \"n.hptr\");"},{"Add":""},{"Add":" env->builder.CreateStore(vtable, env->builder.CreateStructGEP(type, hptr, 0, \"n.set_vtbl\"));"},{"Add":""},{"Add":" // create a fake self pointer in case any methods are called during init"},{"Add":" env->open_scope();"},{"Add":" env->add_binding(self, mem);"},{"Add":""},{"Add":" for (int i = 0; i < attributes.size(); ++i) {"},{"Add":" auto* val = attributes.at(i).first->code(env); // code attrs here so that we can conform them as needed"},{"Add":" auto* attrptr = env->builder.CreateStructGEP(type, hptr, i + 1, \"n.attrptr_\" + attributes.at(i).first->get_name()->get_string());"},{"Add":" // make sure we default init"},{"Add":" if (val == ConstantPointerNull::get(env->ptr))"},{"Add":" env->builder.CreateStore(env->conform(env->default_value(attributes.at(i).second), env->ptr), attrptr);"},{"Add":" else"},{"Add":" env->builder.CreateStore(env->conform(val, env->ptr), attrptr);"},{"Add":" }"},{"Add":""},{"Add":" env->close_scope();"},{"Add":""},{"Add":" env->builder.CreateRet(env->builder.CreateLoad(type->getPointerTo(), mem));"},{"Add":"}"},{"Add":""},{"Add":"void CgenNode::make_vtable_type(CgenEnvironment *env)"},{"Add":"{"},{"Add":" assert(vtable_type == nullptr);"},{"Add":" vtable_type = StructType::create(this->ctx, std::string{\"_\"} + name->get_string() + \"_vtable\");"},{"Add":""},{"Add":" if (cgen_debug)"},{"Add":" std::cerr << \"Creating vtable type\\n\";"},{"Add":""},{"Add":" // tag, size, ptr to name"},{"Add":" std::vector vtable_elems{"},{"Add":" i32, i32,"},{"Add":" ptr"},{"Add":" };"},{"Add":" for (auto [_, t] : methods)"},{"Add":" vtable_elems.emplace_back(t->getPointerTo());"},{"Add":""},{"Add":" vtable_type->setBody(vtable_elems);"},{"Add":" assert(vtable_type != nullptr);"},{"Add":"}"},{"Add":""},{"Add":"void CgenNode::make_type_forrealz(CgenEnvironment *env)"},{"Add":"{"},{"Add":" assert(type != nullptr);"},{"Add":" assert(vtable_type != nullptr);"},{"Add":""},{"Add":" std::vector type_elems{vtable_type->getPointerTo()};"},{"Add":" type_elems.reserve(attributes.size() + 1);"},{"Add":""},{"Add":" // prior art: clang codegen record / cxxRecord"},{"Add":" if (cgen_debug)"},{"Add":" std::cerr << \"Creating type\\n\";"},{"Add":""},{"Add":" for (auto [_, i] : attributes) {"},{"Add":" type_elems.emplace_back(env->ptr); // we always box everything"},{"Add":" }"},{"Add":""},{"Add":" type->setBody(type_elems);"},{"Add":"}"},{"Add":""},{"Add":"void CgenNode::make_vtable_prototype(CgenEnvironment *env)"},{"Add":"{"},{"Add":" assert(vtable_type != nullptr);"},{"Add":" assert(vtable == nullptr);"},{"Add":" // Build global with vtable"},{"Add":" if (cgen_debug)"},{"Add":" std::cerr << \"Emitting vtable \" << get_vtable_name() << \"\\n\";"},{"Add":""},{"Add":" using me = std::pair;"},{"Add":" auto methods = map(this->methods,"},{"Add":" [this](me fn) -> Constant* {"},{"Add":" auto f = this->class_table->the_module.getFunction(fn.first->qualified_name);"},{"Add":" assertm(f, (\"Couldn't find \" + fn.first->qualified_name).c_str());"},{"Add":" return f;"},{"Add":" });"},{"Add":""},{"Add":" auto* str = env->builder.CreateGlobalStringPtr(get_type_name(), name->get_string() + \"_str\", 0, &env->the_module);"},{"Add":""},{"Add":" assert(type->isSized());"},{"Add":" std::vector consts{ConstantInt::get(i32, tag), ConstantInt::get(i32,"},{"Add":" env->data_layout.getTypeAllocSize(type)),"},{"Add":" str,"},{"Add":" };"},{"Add":" consts.insert(consts.end(), methods.begin(), methods.end());"},{"Add":""},{"Add":" auto* cstrct = ConstantStruct::get(vtable_type, {consts});"},{"Add":" vtable = new GlobalVariable(env->the_module, this->vtable_type, true, GlobalValue::ExternalLinkage,"},{"Add":" cstrct, get_vtable_name());"},{"Add":" assert(vtable != nullptr);"},{"Add":"}"},{"Add":""},{"Add":"void CgenNode::make_debug_type(CgenEnvironment* env)"},{"Add":"{"},{"Add":" auto scope = class_table->di_cu;"},{"Add":" auto name = get_type_name();"},{"Add":" auto file = class_table->di_file;"},{"Add":" auto line_num = this->name->get_index();"},{"Add":" auto size_in_bits = env->data_layout.getTypeSizeInBits(type);"},{"Add":" auto align_in_bits = env->data_layout.getABITypeAlign(type).value();"},{"Add":" auto offset_in_bits = 0;"},{"Add":" auto flags = DINode::FlagZero;"},{"Add":" DIType* derived_from = nullptr;"},{"Add":" if (parentnd && parentnd->get_type_name() != \"_no_class\")"},{"Add":" derived_from = parentnd->dtype;"},{"Add":" auto elements = di_builder.getOrCreateArray(dfeats);"},{"Add":""},{"Add":" this->dtype = di_builder.createClassType(scope, name, file, line_num,"},{"Add":" size_in_bits, align_in_bits, offset_in_bits, flags, derived_from,"},{"Add":" elements);"},{"Add":"}"},{"Add":""},{"Add":"void CgenNode::premake_debug_type()"},{"Add":"{"},{"Add":" auto scope = class_table->di_cu;"},{"Add":" auto name = get_type_name();"},{"Add":" auto file = class_table->di_file;"},{"Add":" auto line_num = this->name->get_index();"},{"Add":" auto size_in_bits = 0;"},{"Add":" auto align_in_bits = 0;"},{"Add":" auto offset_in_bits = 0;"},{"Add":" auto flags = DINode::FlagZero;"},{"Add":" DIType* derived_from = nullptr;"},{"Add":" auto elements = di_builder.getOrCreateArray(dfeats);"},{"Add":""},{"Add":" this->dtype = di_builder.createClassType(scope, name, file, line_num,"},{"Add":" size_in_bits, align_in_bits, offset_in_bits, flags, derived_from,"},{"Add":" elements);"},{"Add":"}"},{"Add":""},{"Add":"#pragma endregion"},{"Add":""},{"Add":"#pragma region \"CgenEvironment\""},{"Add":"// Look up a CgenNode given a symbol"},{"Add":"CgenNode* CgenEnvironment::type_to_class(Symbol t) const"},{"Add":"{"},{"Add":" return t == SELF_TYPE"},{"Add":" ? get_class()"},{"Add":" : get_class()->get_classtable()->find_in_scopes(t);"},{"Add":"}"},{"Add":""},{"Add":"BasicBlock* CgenEnvironment::get_or_insert_abort_block(Function* f)"},{"Add":"{"},{"Add":" for (auto &bb: *f) {"},{"Add":" if (bb.getName() == \"abort\") {"},{"Add":" return &bb;"},{"Add":" }"},{"Add":" }"},{"Add":" auto* abort_bb = BasicBlock::Create(this->context, \"abort\", f);"},{"Add":" Type* void_ = Type::getVoidTy(this->context);"},{"Add":" IRBuilder<> builder(abort_bb);"},{"Add":" FunctionCallee abort = this->the_module.getOrInsertFunction(\"abort\", void_);"},{"Add":" builder.CreateCall(abort, {});"},{"Add":" builder.CreateUnreachable();"},{"Add":" return abort_bb;"},{"Add":"}"},{"Add":""},{"Add":"std::optional CgenEnvironment::find_if_exists(Symbol name) const"},{"Add":"{"},{"Add":" if (auto* f = vars.find_in_scopes(name)) {"},{"Add":" return std::make_optional(f);"},{"Add":" }"},{"Add":""},{"Add":" return std::nullopt;"},{"Add":"}"},{"Add":""},{"Add":"std::pair CgenEnvironment::find_in_scopes(Symbol name) const"},{"Add":"{"},{"Add":" // Value* val;"},{"Add":" // if (name->get_string() == \"self\")"},{"Add":" // val = vars.find_in_scopes(self);"},{"Add":" // else"},{"Add":" // val = vars.find_in_scopes(name);"},{"Add":" // TODO: will there be an issue if there is a self that doesn't have an indentical index as the self global?"},{"Add":" auto val = find_if_exists(name);"},{"Add":""},{"Add":" assertm(val, (\"Variable \" + name->get_string() + \" not found\").c_str());"},{"Add":""},{"Add":" return resolve_opaque(*val);"},{"Add":"}"},{"Add":""},{"Add":"AllocaInst* CgenEnvironment::insert_alloca_at_head(Type* ty)"},{"Add":"{"},{"Add":" BasicBlock &entry_bb = builder.GetInsertBlock()->getParent()->"},{"Add":" getEntryBlock();"},{"Add":" if (entry_bb.empty()) {"},{"Add":" // Insert \"at the end\" of this bb"},{"Add":" return new AllocaInst(ty, 0, \"\", &entry_bb);"},{"Add":" } else {"},{"Add":" // Insert before the first instruction of this bb"},{"Add":" return new AllocaInst(ty, 0, \"\", &entry_bb.front());"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"AllocaInst* CgenEnvironment::insert_alloca_at_head(Type* ty, Twine const &msg)"},{"Add":"{"},{"Add":" assert(builder.GetInsertBlock());"},{"Add":" BasicBlock &entry_bb = builder.GetInsertBlock()->getParent()->"},{"Add":" getEntryBlock();"},{"Add":" if (entry_bb.empty()) {"},{"Add":" // Insert \"at the end\" of this bb"},{"Add":" return new AllocaInst(ty, 0, msg, &entry_bb);"},{"Add":" } else {"},{"Add":" // Insert before the first instruction of this bb"},{"Add":" return new AllocaInst(ty, 0, msg, &entry_bb.front());"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"Type* CgenEnvironment::as_type(Symbol const s) const"},{"Add":"{"},{"Add":" auto const _s = as_string(s);"},{"Add":""},{"Add":" if (_s == \"Int\" || _s == \"int\" /* prim int */) return i32;"},{"Add":" if (_s == \"Bool\" || _s == \"bool\" /* prim bool */) return i1;"},{"Add":" if (_s == \"sbyte*\" /* prim string */) return ptr;"},{"Add":""},{"Add":" return this->type_to_class(s)->type;"},{"Add":"}"},{"Add":""},{"Add":"Type* CgenEnvironment::as_mostly_boxed_type(Symbol const s) const"},{"Add":"{"},{"Add":" auto const _s = as_string(s);"},{"Add":""},{"Add":" if (_s == \"Int\" || _s == \"int\" /* prim int */) return i32;"},{"Add":" if (_s == \"Bool\" || _s == \"bool\" /* prim bool */) return i1;"},{"Add":""},{"Add":" return ptr;"},{"Add":"}"},{"Add":""},{"Add":"DIType* CgenEnvironment::as_boxed_dtype(Symbol s) const"},{"Add":"{"},{"Add":" auto const _s = as_string(s);"},{"Add":""},{"Add":" // if (_s == \"Int\" || _s == \"int\" /* prim int */) return class_table.di32;"},{"Add":" // if (_s == \"Bool\" || _s == \"bool\" /* prim bool */) return class_table.di1;"},{"Add":""},{"Add":" // return class_table.di_builder.createPointerType(type_to_class(s)->dtype, 64);"},{"Add":" // return type_to_class(s)->dtype;"},{"Add":" return class_table.dptr;"},{"Add":"}"},{"Add":""},{"Add":"Value* CgenEnvironment::default_value(Type* ty) const"},{"Add":"{"},{"Add":" if (ty->isIntegerTy())"},{"Add":" switch (ty->getIntegerBitWidth()) {"},{"Add":" case 1: return builder.getFalse();"},{"Add":" case 32: return builder.getInt32(0);"},{"Add":" default: llvm_unreachable("},{"Add":" \"Unhandled integer bit with\");"},{"Add":" }"},{"Add":" if (ty->isStructTy() && ty->getStructName() == \"String\")"},{"Add":" return builder.CreateGlobalString(\"\");"},{"Add":""},{"Add":" return ConstantPointerNull::get(ptr);"},{"Add":"}"},{"Add":""},{"Add":"Value* CgenEnvironment::conform(Value* src, Type* dest_type)"},{"Add":"{"},{"Add":" Type* src_type = src->getType();"},{"Add":" if (src_type == dest_type)"},{"Add":" return src;"},{"Add":""},{"Add":" if (src_type->isPointerTy() && dest_type->isPointerTy())"},{"Add":" return src;"},{"Add":""},{"Add":" if (src_type->isIntegerTy() && dest_type->isIntegerTy()) {"},{"Add":" return builder.CreateZExtOrTrunc(src, dest_type);"},{"Add":" }"},{"Add":""},{"Add":" // box to Int or Bool"},{"Add":" if (src_type->isIntegerTy() && dest_type->isPointerTy()) {"},{"Add":" // if (cgen_debug) errs() << \"\\t\\t\\t\\tBoxing \", src->print(errs(), true), errs() << \" to object\\n\";"},{"Add":" switch (src_type->getIntegerBitWidth()) {"},{"Add":" case 1: {"},{"Add":" auto* bool_new = the_module.getFunction(\"Bool_new\");"},{"Add":" assert(bool_new);"},{"Add":" auto* bool_init = the_module.getFunction(\"Bool_init\");"},{"Add":" assert(bool_init);"},{"Add":""},{"Add":" // allocate storage for ptr to Bool"},{"Add":" auto* r = insert_alloca_at_head(ptr, \"box.i1\");"},{"Add":" // create a new Bool"},{"Add":" auto* b = builder.CreateCall(bool_new->getFunctionType(), bool_new, {});"},{"Add":" // store the ptr to the bool so we can return it later"},{"Add":" builder.CreateStore(b, r);"},{"Add":" // upconvert to a cbool"},{"Add":" auto* c = builder.CreateZExt(src, i8);"},{"Add":" // initalize the bool"},{"Add":" auto* bptr1 = builder.CreateLoad(ptr, r);"},{"Add":" builder.CreateCall(bool_init->getFunctionType(), bool_init, {bptr1, c});"},{"Add":" // return the initalized bool"},{"Add":" return builder.CreateLoad(ptr, r, \"boxed.i1\");"},{"Add":" }"},{"Add":" case 32: {"},{"Add":" auto* int_new = the_module.getFunction(\"Int_new\");"},{"Add":" assert(int_new);"},{"Add":" auto* int_init = the_module.getFunction(\"Int_init\");"},{"Add":" assert(int_init);"},{"Add":""},{"Add":" // allocate storage for ptr to Int"},{"Add":" auto* r = insert_alloca_at_head(ptr, \"box.i32\");"},{"Add":" // create a new Int"},{"Add":" auto* b = builder.CreateCall(int_new->getFunctionType(), int_new, {});"},{"Add":" // store the ptr to the int so we can return it later"},{"Add":" builder.CreateStore(b, r);"},{"Add":" // initalize the int"},{"Add":" auto* iptr1 = builder.CreateLoad(ptr, r);"},{"Add":" builder.CreateCall(int_init->getFunctionType(), int_init, {iptr1, src});"},{"Add":" // return the initalized int"},{"Add":" return builder.CreateLoad(ptr, r, \"boxed.i32\");"},{"Add":" }"},{"Add":" default: llvm_unreachable(\"Unsupported integer width to conform to\");"},{"Add":" }"},{"Add":" }"},{"Add":""},{"Add":" // rawdog a gep and hope for the best"},{"Add":" if (src_type->isPointerTy() && dest_type->isIntegerTy()) {"},{"Add":" // if (cgen_debug) errs() << \"\\t\\t\\t\\tUnboxing \", src->print(errs(), true), errs() << \" to prim\\n\";"},{"Add":" auto* ptr = builder.CreateStructGEP(type_to_class(Int)->type, src, 1, \"unboxedptr\");"},{"Add":" return builder.CreateLoad(dest_type, ptr, \"unboxed\");"},{"Add":" }"},{"Add":""},{"Add":" errs() << \"Source ty: \", src_type->print(errs(), true), errs() << \"\\n\";"},{"Add":" errs() << \"Dest ty: \", dest_type->print(errs(), true), errs() << \"\\n\";"},{"Add":" llvm_unreachable(\"Couldn't conform types\");"},{"Add":"}"},{"Add":""},{"Add":"#pragma endregion"},{"Add":""},{"Add":"/*********************************************************************"},{"Add":""},{"Add":" APS class methods"},{"Add":""},{"Add":" Fill in the following methods to produce code for the"},{"Add":" appropriate expression. You may add or remove parameters"},{"Add":" as you wish, but if you do, remember to change the parameters"},{"Add":" of the declarations in `cool-tree.handcode.h'."},{"Add":""},{"Add":"*********************************************************************/"},{"Add":"void program_class::cgen(const std::optional &outfile)"},{"Add":"{"},{"Add":" initialize_constants();"},{"Add":" class_table = new CgenClassTable(classes);"},{"Add":" if (outfile) {"},{"Add":" std::error_code err;"},{"Add":" raw_fd_ostream s(*outfile, err, sys::fs::FA_Write);"},{"Add":" if (err) {"},{"Add":" std::cerr << \"Cannot open output file \" << *outfile << std::endl;"},{"Add":" exit(1);"},{"Add":" }"},{"Add":" s << class_table->the_module;"},{"Add":" } else {"},{"Add":" outs() << class_table->the_module;"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"// Create a method body"},{"Add":"Value* method_class::code(CgenEnvironment* env)"},{"Add":"{"},{"Add":" if (env->get_class()->get_type_name() != split(qualified_name, '_').first)"},{"Add":" return nullptr;"},{"Add":""},{"Add":" if (cgen_debug) {"},{"Add":" std::cerr << \"\\t\\tmethod\" << std::endl;"},{"Add":" }"},{"Add":""},{"Add":" env->open_scope();"},{"Add":""},{"Add":" auto* bb = BasicBlock::Create(env->context, \"entry\", fn);"},{"Add":" env->builder.SetInsertPoint(bb);"},{"Add":""},{"Add":" // name and bind function args"},{"Add":" assert(fn->arg_size() == formals->len() + 1);"},{"Add":" for (auto* arg = fn->arg_begin(); arg != fn->arg_end(); ++arg) {"},{"Add":" int idx = arg->getArgNo();"},{"Add":""},{"Add":" // store arg"},{"Add":" auto* arg_ptr = env->insert_alloca_at_head(arg->getType());"},{"Add":" env->builder.CreateStore(arg, arg_ptr);"},{"Add":""},{"Add":" // name and bind arg"},{"Add":" if (0 == idx) {"},{"Add":" arg->setName(\"self\");"},{"Add":" env->add_binding(self, arg_ptr);"},{"Add":" } else {"},{"Add":" auto* name = formals->nth(idx - 1)->get_name();"},{"Add":" arg->setName(name->get_string());"},{"Add":" env->add_binding(name, arg_ptr);"},{"Add":" }"},{"Add":" }"},{"Add":""},{"Add":" env->open_scope(); // body can redef args"},{"Add":" Value* val = expr->code(env);"},{"Add":" env->builder.CreateRet(env->conform(val, fn->getFunctionType()->getReturnType()));"},{"Add":" env->close_scope();"},{"Add":""},{"Add":" env->close_scope();"},{"Add":" return fn;"},{"Add":"}"},{"Add":""},{"Add":"// Codegen for expressions. Note that each expression has a value."},{"Add":""},{"Add":"Value* assign_class::code(CgenEnvironment* env)"},{"Add":"{"},{"Add":" if (cgen_debug)"},{"Add":" std::cerr << \"\\t\\tassign\" << std::endl;"},{"Add":""},{"Add":" Value* r = expr->code(env);"},{"Add":""},{"Add":" if (auto ptr = env->find_if_exists(name)) {"},{"Add":" auto [ty, val] = resolve_opaque(*ptr);"},{"Add":" env->builder.CreateStore(env->conform(r, ty), val, \"a.local\");"},{"Add":" return r;"},{"Add":" }"},{"Add":""},{"Add":" // since we are here, it must be a class attribute"},{"Add":" assert(env->get_class()->type->getNumElements() > 1);"},{"Add":" auto attrs = env->get_class()->attributes;"},{"Add":" for (int i = 0; i < attrs.size(); ++i)"},{"Add":" if (attrs.at(i).first->get_name() == name) {"},{"Add":" // TODO: will this just check pointer equality, or is this a real comparision?"},{"Add":" // emit a load to the element in self"},{"Add":" auto [ty, val] = env->find_in_scopes(self);"},{"Add":" auto* self = env->builder.CreateLoad(ty, val, \"a.self\");"},{"Add":" // TODO: figure out how to resolve an actual self out of this properly"},{"Add":" // hardcoding it for now"},{"Add":" auto v = env->builder.CreateStructGEP(env->get_class()->type, self, 1 + i, \"a.attrptr\");"},{"Add":" auto x = env->builder.CreateStore(env->conform(r, env->ptr), v, \"a.attr\");"},{"Add":" return r;"},{"Add":" }"},{"Add":""},{"Add":" llvm_unreachable((\"Couldn't assign to \" + name->get_string() + \", reference not found\").c_str());"},{"Add":"}"},{"Add":""},{"Add":"Value* cond_class::code(CgenEnvironment* env)"},{"Add":"{"},{"Add":" if (cgen_debug)"},{"Add":" std::cerr << \"\\t\\tcond\" << std::endl;"},{"Add":""},{"Add":" // allocate the result"},{"Add":" auto* res = env->insert_alloca_at_head(env->as_mostly_boxed_type(type), \"cond\");"},{"Add":" BasicBlock* startbb = env->builder.GetInsertBlock();"},{"Add":" Function* fn = startbb->getParent();"},{"Add":""},{"Add":" // create basic blocks for the true and false branches"},{"Add":" auto* truebb = BasicBlock::Create(env->context, \"true\", fn);"},{"Add":" auto* falsebb = BasicBlock::Create(env->context, \"false\", fn);"},{"Add":" // and a basic block for the result"},{"Add":" auto* mergebb = BasicBlock::Create(env->context, \"merge\", fn);"},{"Add":""},{"Add":" // branch"},{"Add":" env->builder.SetInsertPoint(startbb);"},{"Add":" Value* cond = env->conform(pred->code(env), env->i1);"},{"Add":" env->builder.CreateCondBr(cond, truebb, falsebb);"},{"Add":""},{"Add":" // emit true"},{"Add":" env->builder.SetInsertPoint(truebb);"},{"Add":" env->builder.CreateStore(then_exp->code(env), res);"},{"Add":" env->builder.CreateBr(mergebb); // jump to merge to close bb"},{"Add":""},{"Add":" // emit false"},{"Add":" env->builder.SetInsertPoint(falsebb);"},{"Add":" env->builder.CreateStore(else_exp->code(env), res);"},{"Add":" env->builder.CreateBr(mergebb); // jump to merge to close bb"},{"Add":""},{"Add":" // load and return result"},{"Add":" env->builder.SetInsertPoint(mergebb);"},{"Add":" return env->builder.CreateLoad(res->getAllocatedType(), res);"},{"Add":"}"},{"Add":""},{"Add":"Value* loop_class::code(CgenEnvironment* env)"},{"Add":"{"},{"Add":" if (cgen_debug)"},{"Add":" std::cerr << \"\\t\\tloop\" << std::endl;"},{"Add":""},{"Add":" BasicBlock* startbb = env->builder.GetInsertBlock();"},{"Add":" Function* fn = startbb->getParent();"},{"Add":""},{"Add":" // create basic blocks for conditional, loop, and end"},{"Add":" auto* condbb = BasicBlock::Create(env->context, \"conditional\", fn);"},{"Add":" auto* loopbb = BasicBlock::Create(env->context, \"loop\", fn);"},{"Add":" auto* endbb = BasicBlock::Create(env->context, \"end\", fn);"},{"Add":""},{"Add":" // explicitly jump to conditional"},{"Add":" env->builder.SetInsertPoint(startbb);"},{"Add":" env->builder.CreateBr(condbb);"},{"Add":""},{"Add":" // emit conditional"},{"Add":" env->builder.SetInsertPoint(condbb);"},{"Add":" // check loop conditional"},{"Add":" Value* cond = env->conform(pred->code(env), env->i1);"},{"Add":" env->builder.CreateCondBr(cond, loopbb, endbb);"},{"Add":""},{"Add":" // emit loop"},{"Add":" env->builder.SetInsertPoint(loopbb);"},{"Add":" body->code(env);"},{"Add":" // end bb by jumping to conditional"},{"Add":" env->builder.CreateBr(condbb);"},{"Add":""},{"Add":" // emit end"},{"Add":" env->builder.SetInsertPoint(endbb);"},{"Add":" // loops return void"},{"Add":" return ConstantPointerNull::get(env->ptr);"},{"Add":"}"},{"Add":""},{"Add":"Value* block_class::code(CgenEnvironment* env)"},{"Add":"{"},{"Add":" if (cgen_debug)"},{"Add":" std::cerr << \"\\t\\tblock\" << std::endl;"},{"Add":""},{"Add":" return map(unfuck(body),"},{"Add":" [env](Expression const &e) -> Value* {"},{"Add":" return e->code(env);"},{"Add":" }).back();"},{"Add":"}"},{"Add":""},{"Add":"Value* let_class::code(CgenEnvironment* env)"},{"Add":"{"},{"Add":" if (cgen_debug)"},{"Add":" std::cerr << \"\\tlet\" << std::endl;"},{"Add":""},{"Add":" auto* ty = env->as_mostly_boxed_type(type_decl);"},{"Add":" // allocate let variable"},{"Add":" auto* var_ptr = env->insert_alloca_at_head(ty, \"let\");"},{"Add":""},{"Add":" // store inital code to var_ptr"},{"Add":" Value* initial_val = init->code(env);"},{"Add":" if (!ConstantPointerNull::classof(initial_val))"},{"Add":" env->builder.CreateStore(initial_val, var_ptr);"},{"Add":" else // otherwise init with default value"},{"Add":" env->builder.CreateStore(env->default_value(ty), var_ptr);"},{"Add":""},{"Add":" // bind memory location so the body can use it"},{"Add":" env->open_scope();"},{"Add":" env->add_binding(identifier, var_ptr);"},{"Add":" // return result of the let expr"},{"Add":" Value* r = body->code(env);"},{"Add":""},{"Add":" env->close_scope();"},{"Add":" return r;"},{"Add":"}"},{"Add":""},{"Add":"Value* plus_class::code(CgenEnvironment* env)"},{"Add":"{"},{"Add":" if (cgen_debug)"},{"Add":" std::cerr << \"\\t\\tplus\" << std::endl;"},{"Add":""},{"Add":" Value* r1 = env->conform(e1->code(env), env->i32);"},{"Add":" Value* r2 = env->conform(e2->code(env), env->i32);"},{"Add":" return env->builder.CreateAdd(r1, r2, \"add\");"},{"Add":"}"},{"Add":""},{"Add":"Value* sub_class::code(CgenEnvironment* env)"},{"Add":"{"},{"Add":" if (cgen_debug)"},{"Add":" std::cerr << \"\\t\\tsub\" << std::endl;"},{"Add":""},{"Add":" Value* r1 = env->conform(e1->code(env), env->i32);"},{"Add":" Value* r2 = env->conform(e2->code(env), env->i32);"},{"Add":" return env->builder.CreateSub(r1, r2, \"sub\");"},{"Add":"}"},{"Add":""},{"Add":"Value* mul_class::code(CgenEnvironment* env)"},{"Add":"{"},{"Add":" if (cgen_debug)"},{"Add":" std::cerr << \"\\t\\tmul\" << std::endl;"},{"Add":""},{"Add":" Value* r1 = env->conform(e1->code(env), env->i32);"},{"Add":" Value* r2 = env->conform(e2->code(env), env->i32);"},{"Add":" return env->builder.CreateMul(r1, r2, \"mul\");"},{"Add":"}"},{"Add":""},{"Add":"Value* divide_class::code(CgenEnvironment* env)"},{"Add":"{"},{"Add":" if (cgen_debug)"},{"Add":" std::cerr << \"\\t\\tdiv\" << std::endl;"},{"Add":""},{"Add":" Value* r1 = env->conform(e1->code(env), env->i32);"},{"Add":" Value* r2 = env->conform(e2->code(env), env->i32);"},{"Add":""},{"Add":" auto* curbb = env->builder.GetInsertBlock();"},{"Add":" auto* div = BasicBlock::Create(env->context, \"div\", curbb->getParent());"},{"Add":" auto* abort = env->get_or_insert_abort_block(curbb->getParent());"},{"Add":""},{"Add":" env->builder.SetInsertPoint(curbb);"},{"Add":" Value* is_zero = env->builder.CreateICmpEQ(env->builder.getInt32(0), r2);"},{"Add":" env->builder.CreateCondBr(is_zero, abort, div);"},{"Add":""},{"Add":" env->builder.SetInsertPoint(div);"},{"Add":" return env->builder.CreateSDiv(r1, r2, \"div\");"},{"Add":"}"},{"Add":""},{"Add":"Value* neg_class::code(CgenEnvironment* env)"},{"Add":"{"},{"Add":" if (cgen_debug)"},{"Add":" std::cerr << \"\\t\\tneg\" << std::endl;"},{"Add":""},{"Add":" Value* r = env->conform(e1->code(env), env->i32);"},{"Add":" return env->builder.CreateNeg(r, \"neg\");"},{"Add":"}"},{"Add":""},{"Add":"Value* lt_class::code(CgenEnvironment* env)"},{"Add":"{"},{"Add":" if (cgen_debug)"},{"Add":" std::cerr << \"\\t\\tlt\" << std::endl;"},{"Add":""},{"Add":" Value* r1 = env->conform(e1->code(env), env->i32);"},{"Add":" Value* r2 = env->conform(e2->code(env), env->i32);"},{"Add":" return env->builder.CreateICmpSLT(r1, r2, \"cmpl\");"},{"Add":"}"},{"Add":""},{"Add":"Value* eq_class::code(CgenEnvironment* env)"},{"Add":"{"},{"Add":" if (cgen_debug)"},{"Add":" std::cerr << \"\\t\\teq\" << std::endl;"},{"Add":""},{"Add":" Value* r1 = e1->code(env);"},{"Add":" Value* r2 = e2->code(env);"},{"Add":" if (env->as_type(e1->get_type())->isIntegerTy() || env->as_type(e2->get_type())->isIntegerTy())"},{"Add":" return env->builder.CreateICmpEQ(env->conform(r1, env->i32), env->conform(r2, env->i32));"},{"Add":""},{"Add":" return env->builder.CreateICmpEQ(r1, r2, \"eq\");"},{"Add":"}"},{"Add":""},{"Add":"Value* leq_class::code(CgenEnvironment* env)"},{"Add":"{"},{"Add":" if (cgen_debug)"},{"Add":" std::cerr << \"\\t\\tleq\" << std::endl;"},{"Add":""},{"Add":" Value* r1 = env->conform(e1->code(env), env->i32);"},{"Add":" Value* r2 = env->conform(e2->code(env), env->i32);"},{"Add":" return env->builder.CreateICmpSLE(r1, r2, \"leq\");"},{"Add":"}"},{"Add":""},{"Add":"Value* comp_class::code(CgenEnvironment* env)"},{"Add":"{"},{"Add":" if (cgen_debug)"},{"Add":" std::cerr << \"\\t\\tcomplement\" << std::endl;"},{"Add":""},{"Add":" Value* r = env->conform(e1->code(env), env->i1); // todo: check you can get an i32 here"},{"Add":" return env->builder.CreateNot(r, \"comp\");"},{"Add":"}"},{"Add":""},{"Add":"Value* int_const_class::code(CgenEnvironment* env)"},{"Add":"{"},{"Add":" if (cgen_debug)"},{"Add":" std::cerr << \"\\t\\tint_const\" << std::endl;"},{"Add":""},{"Add":" return env->builder.getInt32((uint32_t) std::stol(token->get_string()));"},{"Add":"}"},{"Add":""},{"Add":"Value* bool_const_class::code(CgenEnvironment* env)"},{"Add":"{"},{"Add":" if (cgen_debug)"},{"Add":" std::cerr << \"\\t\\tbool_const\" << std::endl;"},{"Add":""},{"Add":" return env->builder.getInt1(this->val);"},{"Add":"}"},{"Add":""},{"Add":"Value* object_class::code(CgenEnvironment* env)"},{"Add":"{"},{"Add":" if (cgen_debug)"},{"Add":" std::cerr << \"\\t\\tobject\" << std::endl;"},{"Add":""},{"Add":" if (auto f = env->find_if_exists(name)) {"},{"Add":" auto [ty, val] = resolve_opaque(*f);"},{"Add":" return env->builder.CreateLoad(ty, val, \"o.local_\" + name->get_string());"},{"Add":" }"},{"Add":""},{"Add":" // since we are here, it must be a class attribute"},{"Add":" assert(env->get_class()->type->getNumElements() > 1);"},{"Add":" auto attrs = env->get_class()->attributes;"},{"Add":" for (int i = 0; i < attrs.size(); ++i)"},{"Add":" if (attrs.at(i).first->get_name() == name) {"},{"Add":" // TODO: will this just check pointer equality, or is this a real comparision?"},{"Add":" // emit a load to the element in self"},{"Add":" auto [ty, val] = env->find_in_scopes(self);"},{"Add":" auto* self = env->builder.CreateLoad(ty, val, \"o.self\");"},{"Add":" // TODO: figure out how to resolve an actual self out of this properly"},{"Add":" // hardcoding it for now"},{"Add":" auto v = env->builder.CreateStructGEP(env->get_class()->type, self, 1 + i, \"o.attrptr_\" + name->get_string());"},{"Add":" auto r = env->builder.CreateLoad(env->ptr, v, \"o.attr_\" + name->get_string());"},{"Add":" return r;"},{"Add":" }"},{"Add":""},{"Add":" llvm_unreachable((\"Couldn't resolve a reference to \" + name->get_string()).c_str());"},{"Add":"}"},{"Add":""},{"Add":"Value* no_expr_class::code(CgenEnvironment* env)"},{"Add":"{"},{"Add":" if (cgen_debug)"},{"Add":" std::cerr << \"\\t\\tno expr\" << std::endl;"},{"Add":""},{"Add":" // emit a nullptr"},{"Add":" return ConstantPointerNull::get(env->ptr);"},{"Add":"}"},{"Add":""},{"Add":"//*****************************************************************"},{"Add":"// The next few functions are for node types not supported in Phase 1"},{"Add":"// but these functions must be defined because they are declared as"},{"Add":"// methods via the Expression_SHARED_EXTRAS hack."},{"Add":"//*****************************************************************"},{"Add":""},{"Add":"Value* static_dispatch_class::code(CgenEnvironment* env)"},{"Add":"{"},{"Add":" if (cgen_debug)"},{"Add":" std::cerr << \"\\t\\tstatic dispatch\" << std::endl;"},{"Add":""},{"Add":""},{"Add":" // evaluate args"},{"Add":" auto args = map(unfuck(actual), [env](Expression const& e) -> Value* {"},{"Add":" return e->code(env);"},{"Add":" });"},{"Add":""},{"Add":" // figure out the calling class"},{"Add":" auto* caller_class = env->type_to_class(type_name);"},{"Add":" auto* caller = expr->code(env);"},{"Add":""},{"Add":" // box prims"},{"Add":" if (caller->getType()->isIntegerTy()) {"},{"Add":" auto* orig = caller;"},{"Add":" caller = env->conform(orig, env->ptr);"},{"Add":" }"},{"Add":" // sanity check caller"},{"Add":" assert(caller->getType()->isPointerTy());"},{"Add":""},{"Add":" if (cgen_debug)"},{"Add":" errs() << \"\\t\\t\\tLooking for \" << as_string(name) << \"\\n\";"},{"Add":""},{"Add":" // figure out method index into vtable"},{"Add":" auto get_method_idx = [](CgenNode* cls, Symbol name) -> int {"},{"Add":" auto methods = cls->methods;"},{"Add":" // search in reverse so we get the overload instead of the original"},{"Add":" for (int i = methods.size() - 1; i > 0; --i) {"},{"Add":" if (methods.at(i).first->get_name() == name) {"},{"Add":" return i;"},{"Add":" }"},{"Add":" }"},{"Add":""},{"Add":" llvm_unreachable((\"Couldn't find \" + as_string(name) + \" in \" + as_string(cls->get_name())).c_str());"},{"Add":" };"},{"Add":" int method_idx = get_method_idx(caller_class, name);"},{"Add":""},{"Add":" auto n = as_string(name);"},{"Add":" auto* curbb = env->builder.GetInsertBlock();"},{"Add":" auto* abort = env->get_or_insert_abort_block(curbb->getParent());"},{"Add":" auto* validbb = BasicBlock::Create(env->context, \"sdispatch_\" + n, curbb->getParent());"},{"Add":""},{"Add":" // emit nulltpr check"},{"Add":" env->builder.SetInsertPoint(curbb);"},{"Add":" Value* is_nullptr = env->builder.CreateICmpEQ(caller, ConstantPointerNull::get(env->ptr));"},{"Add":" env->builder.CreateCondBr(is_nullptr, abort, validbb);"},{"Add":""},{"Add":" // emit call global vtable if successful"},{"Add":" env->builder.SetInsertPoint(validbb);"},{"Add":" // get method's signature"},{"Add":" auto* method_ty = caller_class->methods.at(method_idx).second;"},{"Add":" // get pointer from vtable"},{"Add":" Value* method_ptr = env->builder.CreateStructGEP(caller_class->vtable_type,"},{"Add":" caller_class->vtable, method_idx + 3, \"sd.mptr\"); // first three elems of the vtable aren't methods"},{"Add":" auto* method = env->builder.CreateLoad(method_ty->getPointerTo(), method_ptr, \"sd.\" + n);"},{"Add":" // build method args"},{"Add":" std::vector real_args{caller};"},{"Add":" real_args.reserve(1 + args.size());"},{"Add":" for (int i = 0; i < args.size(); ++i) { // make sure args are unboxed as needed"},{"Add":" real_args.emplace_back(env->conform(args.at(i), method_ty->getParamType(i + 1)));"},{"Add":" }"},{"Add":" // call method"},{"Add":" return env->builder.CreateCall(method_ty, method, real_args);"},{"Add":"}"},{"Add":""},{"Add":"Value* string_const_class::code(CgenEnvironment* env)"},{"Add":"{"},{"Add":" if (cgen_debug)"},{"Add":" std::cerr << \"\\t\\tstring_const\" << std::endl;"},{"Add":""},{"Add":" auto* e = stringtable.lookup_string(as_string(token));"},{"Add":" auto* global = reinterpret_cast(e)->ptr;"},{"Add":" return global;"},{"Add":"}"},{"Add":""},{"Add":"Value* dispatch_class::code(CgenEnvironment* env)"},{"Add":"{"},{"Add":" if (cgen_debug)"},{"Add":" std::cerr << \"\\t\\tdispatch\\n\" << std::endl;"},{"Add":""},{"Add":" // evaluate args"},{"Add":" auto args = map(unfuck(actual), [env](Expression const& e) -> Value* {"},{"Add":" return e->code(env);"},{"Add":" });"},{"Add":""},{"Add":" // figure out the calling class"},{"Add":" auto* caller_class = env->type_to_class(expr->get_type());"},{"Add":" Value* caller = expr->code(env);"},{"Add":""},{"Add":" // box prims"},{"Add":" if (caller->getType()->isIntegerTy()) {"},{"Add":" auto* orig = caller;"},{"Add":" caller = env->conform(orig, env->ptr);"},{"Add":" }"},{"Add":" // sanity check caller"},{"Add":" assert(caller->getType()->isPointerTy());"},{"Add":""},{"Add":" if (cgen_debug)"},{"Add":" errs() << \"\\t\\t\\tLooking for \" << as_string(name) << \"\\n\";"},{"Add":""},{"Add":" // figure out method index into vtable"},{"Add":" auto get_method_idx = [](CgenNode* cls, Symbol name) -> int {"},{"Add":" auto methods = cls->methods;"},{"Add":" // search in reverse so we get the overload instead of the original"},{"Add":" for (int i = methods.size() - 1; i >= 0; --i) {"},{"Add":" if (methods.at(i).first->get_name() == name) {"},{"Add":" return i;"},{"Add":" }"},{"Add":" }"},{"Add":""},{"Add":" llvm_unreachable((\"Couldn't find \" + as_string(name) + \" in \" + as_string(cls->get_name())).c_str());"},{"Add":" };"},{"Add":" int method_idx = get_method_idx(caller_class, name);"},{"Add":""},{"Add":" auto n = as_string(name);"},{"Add":" auto* curbb = env->builder.GetInsertBlock();"},{"Add":" auto* abort = env->get_or_insert_abort_block(curbb->getParent());"},{"Add":" auto* validbb = BasicBlock::Create(env->context, \"dispatch_\" + n, curbb->getParent());"},{"Add":""},{"Add":" // emit nulltpr check"},{"Add":" env->builder.SetInsertPoint(curbb);"},{"Add":" Value* is_nullptr = env->builder.CreateICmpEQ(caller, ConstantPointerNull::get(env->ptr));"},{"Add":" env->builder.CreateCondBr(is_nullptr, abort, validbb);"},{"Add":""},{"Add":""},{"Add":" // emit call through vtable if successful"},{"Add":" env->builder.SetInsertPoint(validbb);"},{"Add":" // get vtable ptr"},{"Add":" auto* vtable_ptr = env->builder.CreateStructGEP(caller_class->type, caller, 0, \"d.vtblptr\");"},{"Add":" // load vtable"},{"Add":" auto* vtable = env->builder.CreateLoad(env->ptr, vtable_ptr, \"d.vtbl\");"},{"Add":" // get method's signature"},{"Add":" auto* method_ty = caller_class->methods.at(method_idx).second;"},{"Add":" // get pointer from vtable"},{"Add":" Value* method_ptr = env->builder.CreateStructGEP(caller_class->vtable_type,"},{"Add":" vtable, method_idx + 3, \"d.mptr\"); // first three elems of the vtable aren't methods"},{"Add":" auto* method = env->builder.CreateLoad(method_ty->getPointerTo(), method_ptr, \"d.\" + n);"},{"Add":" // build method args"},{"Add":" std::vector real_args{caller};"},{"Add":" real_args.reserve(1 + args.size());"},{"Add":" for (int i = 0; i < args.size(); ++i) { // make sure args are unboxed as needed"},{"Add":" // if (cgen_debug) errs() << \"\\t\\t\\t\", method_ty->getParamType(i + 1)->print(errs(), true), errs() << \" <- \", args.at(i)->print(errs(), true), errs() << \"\\n\";"},{"Add":" real_args.emplace_back(env->conform(args.at(i), method_ty->getParamType(i + 1)));"},{"Add":" // if (cgen_debug) errs() << \"\\t\\t\\t\", real_args.at(i + 1)->print(errs(), true), errs() << \"\\n\";"},{"Add":" assert(real_args.at(i + 1)->getType() == method_ty->getParamType(i + 1));"},{"Add":" }"},{"Add":" assert(real_args.size() == method_ty->getNumParams());"},{"Add":" // call method"},{"Add":""},{"Add":" if (cgen_debug)"},{"Add":" errs() << \"\\t\\tend dispatch\\n\";"},{"Add":" return env->builder.CreateCall(method_ty, method, real_args);"},{"Add":"}"},{"Add":""},{"Add":"// Handle a Cool case expression (selecting based on the type of an object)"},{"Add":"Value* typcase_class::code(CgenEnvironment* env)"},{"Add":"{"},{"Add":" if (cgen_debug)"},{"Add":" std::cerr << \"\\t\\ttype case\" << std::endl;"},{"Add":""},{"Add":" auto e_class = env->type_to_class(expr->get_type());"},{"Add":" auto sumty = env->type_to_class(type);"},{"Add":" Value* e = expr->code(env);"},{"Add":""},{"Add":" // box prims"},{"Add":" if (e->getType()->isIntegerTy()) {"},{"Add":" auto* orig = e;"},{"Add":" e = env->conform(orig, env->ptr);"},{"Add":" }"},{"Add":" assert(e->getType()->isPointerTy());"},{"Add":""},{"Add":""},{"Add":" auto* curbb = env->builder.GetInsertBlock();"},{"Add":" auto* abort = env->get_or_insert_abort_block(curbb->getParent());"},{"Add":" auto* goodbb = BasicBlock::Create(env->context, \"typcase.good\", curbb->getParent());"},{"Add":" auto* matchbb = BasicBlock::Create(env->context, \"typcase.match\", curbb->getParent());"},{"Add":" auto* resbb = BasicBlock::Create(env->context, \"typcase.result\", curbb->getParent());"},{"Add":""},{"Add":" // emit void check"},{"Add":" env->builder.SetInsertPoint(curbb);"},{"Add":" auto* test = env->builder.CreateICmpEQ(e, ConstantPointerNull::get(env->ptr), \"typcase.isvoid\");"},{"Add":" env->builder.CreateCondBr(test, abort, goodbb);"},{"Add":""},{"Add":" env->builder.SetInsertPoint(goodbb);"},{"Add":" // get tag"},{"Add":" auto* vtable_ptr = env->builder.CreateStructGEP(e_class->type, e, 0, \"typcase.vtblptr\");"},{"Add":" auto* vtable = env->builder.CreateLoad(env->ptr, vtable_ptr, \"typcase.vtbl\");"},{"Add":" auto* tag_ptr = env->builder.CreateStructGEP(e_class->vtable_type, vtable, 0, \"typcase.tagptr\");"},{"Add":" auto* tag = env->builder.CreateLoad(env->i32, tag_ptr, \"typcase.tag\");"},{"Add":""},{"Add":" // stack slot for result, case is always boxed"},{"Add":" auto* res = env->insert_alloca_at_head(env->ptr);"},{"Add":" // store nullptr"},{"Add":" env->builder.CreateStore(ConstantPointerNull::get(env->ptr), res);"},{"Add":""},{"Add":" // sort cases largest tag to smallest"},{"Add":" std::vector branches;"},{"Add":" branches.reserve(cases->len());"},{"Add":" for (auto c: cases) {"},{"Add":" branches.emplace_back(c);"},{"Add":" }"},{"Add":" std::sort(branches.begin(), branches.end(), [env](Case a, Case b) {"},{"Add":" return env->type_to_class(a->get_type_decl())->get_tag() > env->type_to_class(b->get_type_decl())->get_tag();"},{"Add":" });"},{"Add":" std::for_each(branches.begin(), branches.end(), [env, e, tag, res, matchbb](Case c) {"},{"Add":" c->code(e, tag, res, matchbb, env);"},{"Add":" });"},{"Add":" // abort if no match"},{"Add":" env->builder.CreateBr(abort);"},{"Add":""},{"Add":" env->builder.SetInsertPoint(matchbb);"},{"Add":" // test if result is null"},{"Add":" auto* r = env->builder.CreateLoad(env->ptr, res, \"typcase.res\");"},{"Add":" auto* test_res = env->builder.CreateICmpEQ(r, ConstantPointerNull::get(env->ptr), \"typcase.res.isvoid\");"},{"Add":" env->builder.CreateCondBr(test_res, abort, resbb);"},{"Add":""},{"Add":" // clean up"},{"Add":" env->builder.SetInsertPoint(resbb);"},{"Add":" return r;"},{"Add":"}"},{"Add":""},{"Add":"Value* new__class::code(CgenEnvironment* env)"},{"Add":"{"},{"Add":" if (cgen_debug)"},{"Add":" std::cerr << \"\\t\\tnew\" << std::endl;"},{"Add":""},{"Add":" // return nullptr;"},{"Add":""},{"Add":" auto init = env->type_to_class(type_name)->get_init_function_name();"},{"Add":" auto* initfn = env->the_module.getFunction(init);"},{"Add":" assert(initfn);"},{"Add":" return env->builder.CreateCall(initfn->getFunctionType(), initfn, {});"},{"Add":"}"},{"Add":""},{"Add":"Value* isvoid_class::code(CgenEnvironment* env)"},{"Add":"{"},{"Add":" if (cgen_debug)"},{"Add":" std::cerr << \"\\t\\tisvoid\" << std::endl;"},{"Add":""},{"Add":" Value* e = e1->code(env);"},{"Add":""},{"Add":" if (e->getType()->isIntegerTy())"},{"Add":" return env->builder.getTrue();"},{"Add":""},{"Add":" assert(e->getType()->isPointerTy());"},{"Add":""},{"Add":" auto* ret = env->insert_alloca_at_head(env->i1);"},{"Add":" auto* curbb = env->builder.GetInsertBlock();"},{"Add":" auto* truebb = BasicBlock::Create(env->context, \"isvoid.true\", curbb->getParent());"},{"Add":" auto* falsebb = BasicBlock::Create(env->context, \"isvoid.false\", curbb->getParent());"},{"Add":" auto* mergebb = BasicBlock::Create(env->context, \"isvoid.result\", curbb->getParent());"},{"Add":""},{"Add":" env->builder.SetInsertPoint(curbb);"},{"Add":" auto* test = env->builder.CreateICmpEQ(e, ConstantPointerNull::get(env->ptr), \"isvoid\");"},{"Add":" env->builder.CreateCondBr(test, truebb, falsebb);"},{"Add":""},{"Add":" env->builder.SetInsertPoint(truebb);"},{"Add":" env->builder.CreateStore(env->builder.getTrue(), ret);"},{"Add":" env->builder.CreateBr(mergebb);"},{"Add":""},{"Add":" env->builder.SetInsertPoint(falsebb);"},{"Add":" env->builder.CreateStore(env->builder.getFalse(), ret);"},{"Add":" env->builder.CreateBr(mergebb);"},{"Add":""},{"Add":" env->builder.SetInsertPoint(mergebb);"},{"Add":" return env->builder.CreateLoad(env->i1, ret);"},{"Add":"}"},{"Add":""},{"Add":"// Record the method"},{"Add":"void method_class::layout_feature(CgenNode* cls)"},{"Add":"{"},{"Add":" // if (cls->basic())"},{"Add":" // return; // handled by the runtime"},{"Add":" auto* env = new CgenEnvironment(cls);"},{"Add":""},{"Add":" assert(qualified_name.empty());"},{"Add":" qualified_name = cls->get_type_name() + \"_\" + this->get_name()->get_string();"},{"Add":""},{"Add":" std::vector real_args;"},{"Add":" real_args.reserve(formals->len() + 1);"},{"Add":" real_args.emplace_back(env->ptr); // first arg is always self ptr"},{"Add":" auto _formals = unfuck(formals);"},{"Add":" auto args = map(_formals,"},{"Add":" [env](Formal const &f) -> Type* {"},{"Add":" return env->as_mostly_boxed_type(f->get_type_decl());"},{"Add":" });"},{"Add":" real_args.insert(real_args.end(), args.begin(), args.end());"},{"Add":""},{"Add":" // real function"},{"Add":" auto* ty = CgenNode::create_functionty(env->as_mostly_boxed_type(return_type), real_args);"},{"Add":" fn = cls->create_function(as_string(get_name()), ty);"},{"Add":""},{"Add":" #ifdef EMIT_DBG"},{"Add":" if (!cls->basic()) {"},{"Add":" // debug function type"},{"Add":" std::vector dtys;"},{"Add":" dtys.emplace_back(env->as_boxed_dtype(return_type));"},{"Add":" for (auto f: _formals)"},{"Add":" dtys.emplace_back(env->as_boxed_dtype(f->get_type_decl()));"},{"Add":" auto dty = cls->di_builder.createSubroutineType(cls->di_builder.getOrCreateTypeArray(dtys));"},{"Add":" auto dfn = cls->di_builder.createFunction(env->class_table.di_cu, this->get_name()->get_string(), cls->get_type_name() + \"_\" + this->get_name()->get_string(), env->class_table.di_file, this->get_name()->get_index(), dty,this->get_name()->get_index(), DINode::FlagPrototyped, DISubprogram::SPFlagDefinition);"},{"Add":" fn->setSubprogram(dfn);"},{"Add":" cls->dfeats.emplace_back(dfn);"},{"Add":" }"},{"Add":" #endif"},{"Add":""},{"Add":" cls->methods.emplace_back(this, ty);"},{"Add":" delete env;"},{"Add":"}"},{"Add":""},{"Add":"// Handle one branch of a Cool case expression."},{"Add":"// If the source tag is >= the branch tag"},{"Add":"// and <= (max child of the branch class) tag,"},{"Add":"// then the branch is a superclass of the source."},{"Add":"// See the LAB2 handout for more information about our use of class tags."},{"Add":"void branch_class::code(Value* expr_val, Value* tag, Value* mem, BasicBlock* sbb, CgenEnvironment* env)"},{"Add":"{"},{"Add":" if (cgen_debug)"},{"Add":" std::cerr << \"\\t\\tbranch\\n\";"},{"Add":""},{"Add":" auto cls = env->type_to_class(type_decl);"},{"Add":" int start_tag = cls->get_tag();"},{"Add":" int end_tag = cls->get_max_child();"},{"Add":""},{"Add":" auto* curbb = env->builder.GetInsertBlock();"},{"Add":" auto* maxbb = BasicBlock::Create(env->context, \"typcase.br.match.max.\" + name->get_string(), curbb->getParent());"},{"Add":" auto* minbb = BasicBlock::Create(env->context, \"typcase.br.match.min.\" + name->get_string(), curbb->getParent());"},{"Add":" auto* endbb = BasicBlock::Create(env->context, \"typcase.br.nomatch.\" + name->get_string(), curbb->getParent());"},{"Add":""},{"Add":" env->builder.SetInsertPoint(curbb);"},{"Add":" // test min tag first, since we test largest to smallest cases"},{"Add":" auto* mintest = env->builder.CreateICmpSGE(tag, ConstantInt::get(env->i32, start_tag, true), \"typcase.br.min.\" + name->get_string());"},{"Add":" env->builder.CreateCondBr(mintest, minbb, endbb);"},{"Add":""},{"Add":" env->builder.SetInsertPoint(minbb);"},{"Add":" // test max tag"},{"Add":" auto* maxtest = env->builder.CreateICmpSLE(tag, ConstantInt::get(env->i32, end_tag, true), \"typcase.br.max.\" + name->get_string());"},{"Add":" env->builder.CreateCondBr(maxtest, maxbb, endbb);"},{"Add":""},{"Add":" env->builder.SetInsertPoint(maxbb);"},{"Add":" auto* branchptr = env->insert_alloca_at_head(env->ptr);"},{"Add":" env->builder.CreateStore(expr_val, branchptr);"},{"Add":" env->open_scope(); // eval branch with new scope"},{"Add":" env->add_binding(name, branchptr);"},{"Add":" auto* res = expr->code(env);"},{"Add":" env->close_scope();"},{"Add":" // store into result"},{"Add":" env->builder.CreateStore(res, mem);"},{"Add":" env->builder.CreateBr(sbb);"},{"Add":""},{"Add":" env->builder.SetInsertPoint(endbb);"},{"Add":"}"},{"Add":""},{"Add":"// Assign this attribute a slot in the class structure"},{"Add":"void attr_class::layout_feature(CgenNode* cls)"},{"Add":"{"},{"Add":" auto* env = new CgenEnvironment(cls);"},{"Add":" auto ty = env->as_mostly_boxed_type(type_decl);"},{"Add":" cls->attributes.emplace_back(this, ty);"},{"Add":" #ifdef EMIT_DBG"},{"Add":" // build debug info"},{"Add":" cls->dfeats.emplace_back(env->as_boxed_dtype(type_decl));"},{"Add":" #endif"},{"Add":" delete env;"},{"Add":"}"},{"Add":""},{"Add":"Value* attr_class::code(CgenEnvironment* env)"},{"Add":"{"},{"Add":" val = init->code(env);"},{"Add":" // return env->conform(val, env->ptr);"},{"Add":" return val;"},{"Add":"}"},{"Add":""},{"Add":"#pragma region \"utils\""},{"Add":"namespace"},{"Add":"{"},{"Add":"std::string as_string(Symbol const s)"},{"Add":"{"},{"Add":" return s->get_string();"},{"Add":"}"},{"Add":""},{"Add":"std::vector unfuck(Expressions const fuck_this)"},{"Add":"{"},{"Add":" std::vector r{};"},{"Add":" r.reserve(fuck_this->len());"},{"Add":""},{"Add":" for (int i = fuck_this->first(); fuck_this->more(i); i = fuck_this->next(i))"},{"Add":" r.push_back(fuck_this->nth(i));"},{"Add":""},{"Add":" return r;"},{"Add":"}"},{"Add":""},{"Add":"std::vector unfuck(Formals const fuck_this)"},{"Add":"{"},{"Add":" std::vector r{};"},{"Add":" r.reserve(fuck_this->len());"},{"Add":""},{"Add":" for (int i = fuck_this->first(); fuck_this->more(i); i = fuck_this->next(i))"},{"Add":" r.push_back(fuck_this->nth(i));"},{"Add":""},{"Add":" return r;"},{"Add":"}"},{"Add":""},{"Add":"std::vector unfuck(Features const fuck_this)"},{"Add":"{"},{"Add":" std::vector r{};"},{"Add":" r.reserve(fuck_this->len());"},{"Add":""},{"Add":" for (int i = fuck_this->first(); fuck_this->more(i); i = fuck_this->next(i))"},{"Add":" r.push_back(fuck_this->nth(i));"},{"Add":""},{"Add":" return r;"},{"Add":"}"},{"Add":""},{"Add":"std::pair resolve_opaque(Value* val)"},{"Add":"{"},{"Add":" // TODO: resolve malloced things"},{"Add":""},{"Add":" if (auto* a = dyn_cast(val))"},{"Add":" return {a->getAllocatedType(), val};"},{"Add":""},{"Add":" if (auto* g = dyn_cast(val))"},{"Add":" return {g->getValueType(), val};"},{"Add":""},{"Add":" if (auto* s = dyn_cast(val))"},{"Add":" return {s->getSourceElementType(), val};"},{"Add":""},{"Add":" errs() << \"Unresolved opaque value: \", val->print(errs(), true), errs() << \"\\n\";"},{"Add":" llvm_unreachable(\"couldn't get original type for value\");"},{"Add":"}"},{"Add":""},{"Add":"template"},{"Add":"std::vector map(std::vector src, std::function mapper)"},{"Add":"{"},{"Add":" std::vector r{};"},{"Add":" r.reserve(src.size());"},{"Add":""},{"Add":" for (auto i: src)"},{"Add":" r.emplace_back(mapper(i));"},{"Add":""},{"Add":" return r;"},{"Add":"}"},{"Add":""},{"Add":"std::pair split(const std::string& s, char const c)"},{"Add":"{"},{"Add":" size_t pos = s.find(c);"},{"Add":" if (pos == std::string::npos)"},{"Add":" return {s, \"\"};"},{"Add":""},{"Add":""},{"Add":" return {s.substr(0, pos), s.substr(pos + 1)};"},{"Add":"}"},{"Add":"}"},{"Add":"#pragma endregion"}]}},{"FileAdd":{"meta":{"basename":"rt","metadata":576},"context":[{"change":0,"pos":1}],"contents":[]}},{"FileAdd":{"meta":{"basename":"coolrt.h","metadata":0},"context":[{"change":0,"pos":65775}],"contents":[{"Add":"/*"},{"Add":" * This file provides the runtime library for cool. It implements"},{"Add":" * the cool classes in C. Feel free to change it to match the structure"},{"Add":" * of your code generator."},{"Add":" */"},{"Add":""},{"Add":"#include "},{"Add":""},{"Add":"#if defined _MSC_VER && !defined __clang__"},{"Add":"#define __attribute(...)"},{"Add":"#endif"},{"Add":""},{"Add":"typedef struct Object Object;"},{"Add":"typedef struct Int Int;"},{"Add":"typedef struct Bool Bool;"},{"Add":"typedef struct String String;"},{"Add":"typedef struct IO IO;"},{"Add":""},{"Add":"typedef struct _Object_vtable Object_vtable;"},{"Add":"typedef struct _Int_vtable Int_vtable;"},{"Add":"typedef struct _Bool_vtable Bool_vtable;"},{"Add":"typedef struct _String_vtable String_vtable;"},{"Add":"typedef struct _IO_vtable IO_vtable;"},{"Add":""},{"Add":"/* class type definitions */"},{"Add":"struct Object {"},{"Add":" const Object_vtable *vtblptr;"},{"Add":"};"},{"Add":""},{"Add":"struct Int {"},{"Add":" const Int_vtable *vtblptr;"},{"Add":" int val;"},{"Add":"};"},{"Add":""},{"Add":"struct Bool {"},{"Add":" const Bool_vtable *vtblptr;"},{"Add":" bool val;"},{"Add":"};"},{"Add":""},{"Add":"struct String {"},{"Add":" const String_vtable *vtblptr;"},{"Add":" const char *val;"},{"Add":"};"},{"Add":""},{"Add":"struct IO {"},{"Add":" const IO_vtable *vtblptr;"},{"Add":"};"},{"Add":""},{"Add":"/* vtable type definitions */"},{"Add":"struct _Object_vtable {"},{"Add":" int tag;"},{"Add":" int size;"},{"Add":" const char *name;"},{"Add":""},{"Add":" Object *(*abort_object)(Object *self);"},{"Add":" String *(*type_name_object)(Object *self);"},{"Add":" Object *(*copy_object)(Object *self);"},{"Add":"};"},{"Add":""},{"Add":"struct _Int_vtable {"},{"Add":" int tag;"},{"Add":" int size;"},{"Add":" const char *name;"},{"Add":""},{"Add":" Object *(*abort_int)(Object *self);"},{"Add":" String *(*type_name_int)(Object *self);"},{"Add":" Object *(*copy_int)(Object *self);"},{"Add":"};"},{"Add":""},{"Add":"struct _Bool_vtable {"},{"Add":" int tag;"},{"Add":" int size;"},{"Add":" const char *name;"},{"Add":""},{"Add":" Object *(*abort_bool)(Object *self);"},{"Add":" String *(*type_name_bool)(Object *self);"},{"Add":" Object *(*copy_bool)(Object *self);"},{"Add":"};"},{"Add":""},{"Add":"struct _String_vtable {"},{"Add":" int tag;"},{"Add":" int size;"},{"Add":" const char *name;"},{"Add":""},{"Add":" Object *(*abort_string)(Object *self);"},{"Add":" String *(*type_name_string)(Object *self);"},{"Add":" Object *(*copy_string)(Object *self);"},{"Add":" int (*length_string)(String *self);"},{"Add":" String *(*concat_string)(String *self, String *s);"},{"Add":" String *(*substr_string)(String *self, int i, int l);"},{"Add":"};"},{"Add":""},{"Add":"struct _IO_vtable {"},{"Add":" int tag;"},{"Add":" int size;"},{"Add":" const char *name;"},{"Add":""},{"Add":" Object *(*abort_io)(Object *self);"},{"Add":" String *(*type_name_io)(Object *self);"},{"Add":" Object *(*copy_io)(Object *self);"},{"Add":" IO *(*out_string_io)(IO *self, String *s);"},{"Add":" IO *(*out_int_io)(IO *self, int x);"},{"Add":" String *(*in_string_io)(IO *self);"},{"Add":" int (*in_int_io)(IO *self);"},{"Add":"};"},{"Add":""},{"Add":"/* Class vtable prototypes */"},{"Add":"extern const Object_vtable _Object_vtable_prototype;"},{"Add":"extern const Int_vtable _Int_vtable_prototype;"},{"Add":"extern const Bool_vtable _Bool_vtable_prototype;"},{"Add":"extern const String_vtable _String_vtable_prototype;"},{"Add":"extern const IO_vtable _IO_vtable_prototype;"},{"Add":""},{"Add":"/* methods in class Object */"},{"Add":"Object *Object_new(void);"},{"Add":"Object *Object_abort(Object *self) __attribute((noreturn));"},{"Add":"String *Object_type_name(Object *self);"},{"Add":"Object *Object_copy(Object *self);"},{"Add":""},{"Add":"/* methods in class Int */"},{"Add":"Int *Int_new(void);"},{"Add":"void Int_init(Int *self, int i);"},{"Add":""},{"Add":"/* methods in class Bool */"},{"Add":"Bool *Bool_new(void);"},{"Add":"void Bool_init(Bool *self, bool b);"},{"Add":""},{"Add":"/* methods in class String */"},{"Add":"String *String_new(void);"},{"Add":"int String_length(String *self);"},{"Add":"String *String_concat(String *self, String *s);"},{"Add":"String *String_substr(String *self, int i, int l);"},{"Add":""},{"Add":"/* methods in class IO */"},{"Add":"IO *IO_new(void);"},{"Add":"IO *IO_out_string(IO *self, String *s);"},{"Add":"IO *IO_out_int(IO *self, int x);"},{"Add":"String *IO_in_string(IO *self);"},{"Add":"int IO_in_int(IO *self);"}]}},{"FileAdd":{"meta":{"basename":"coolrt.c","metadata":0},"context":[{"change":0,"pos":65775}],"contents":[{"Add":"#include \"coolrt.h\""},{"Add":"#include "},{"Add":"#include "},{"Add":"#include "},{"Add":"#include "},{"Add":""},{"Add":"/* This file provides the runtime library for cool. It implements"},{"Add":" the functions of the cool classes in C"},{"Add":" */"},{"Add":""},{"Add":""},{"Add":"/* Class name strings */"},{"Add":"const char Object_string[] = \"Object\";"},{"Add":"const char Int_string[] = \"Int\";"},{"Add":"const char Bool_string[] = \"Bool\";"},{"Add":"const char String_string[] = \"String\";"},{"Add":"const char IO_string[] = \"IO\";"},{"Add":""},{"Add":"const char default_string[] = \"\";"},{"Add":""},{"Add":"/* Class vtable prototypes */"},{"Add":"/*"},{"Add":"const Object_vtable _Object_vtable_prototype = {"},{"Add":" .tag = 0,"},{"Add":" .size = sizeof(struct Object),"},{"Add":" .name = Object_string,"},{"Add":""},{"Add":" .abort_object = Object_abort,"},{"Add":" .type_name_object = Object_type_name,"},{"Add":" .copy_object = Object_copy"},{"Add":"};"},{"Add":""},{"Add":"const Int_vtable _Int_vtable_prototype = {"},{"Add":" .tag = 1,"},{"Add":" .size = sizeof(struct Int),"},{"Add":" .name = Int_string,"},{"Add":""},{"Add":" .abort_int = Object_abort,"},{"Add":" .type_name_int = Object_type_name,"},{"Add":" .copy_int = Object_copy"},{"Add":"};"},{"Add":""},{"Add":"const Bool_vtable _Bool_vtable_prototype = {"},{"Add":" .tag = 2,"},{"Add":" .size = sizeof(struct Bool),"},{"Add":" .name = Bool_string,"},{"Add":""},{"Add":" .abort_bool = Object_abort,"},{"Add":" .type_name_bool = Object_type_name,"},{"Add":" .copy_bool = Object_copy"},{"Add":"};"},{"Add":""},{"Add":"const String_vtable _String_vtable_prototype = {"},{"Add":" .tag = 3,"},{"Add":" .size = sizeof(struct String),"},{"Add":" .name = String_string,"},{"Add":""},{"Add":" .abort_string = Object_abort,"},{"Add":" .type_name_string = Object_type_name,"},{"Add":" .copy_string = Object_copy,"},{"Add":" .length_string = String_length,"},{"Add":" .concat_string = String_concat,"},{"Add":" .substr_string = String_substr"},{"Add":"};"},{"Add":""},{"Add":"const IO_vtable _IO_vtable_prototype = {"},{"Add":" .tag = 4,"},{"Add":" .size = sizeof(struct IO),"},{"Add":" .name = IO_string,"},{"Add":""},{"Add":" .abort_io = Object_abort,"},{"Add":" .type_name_io = Object_type_name,"},{"Add":" .copy_io = Object_copy,"},{"Add":" .out_string_io = IO_out_string,"},{"Add":" .out_int_io = IO_out_int,"},{"Add":" .in_string_io = IO_in_string,"},{"Add":" .in_int_io = IO_in_int"},{"Add":"};"},{"Add":""},{"Add":"*/"},{"Add":""},{"Add":"/*"},{"Add":"// Methods in class object (only some are provided to you)"},{"Add":"*/"},{"Add":"Object* Object_new()"},{"Add":"{"},{"Add":" Object* o = (Object *) malloc(sizeof(Object));"},{"Add":" if (o == 0) {"},{"Add":" fprintf(stderr, \"At %s(line %d): Out of memory\\n\", __FILE__, __LINE__);"},{"Add":" Object_abort((Object *) 0);"},{"Add":" }"},{"Add":" o->vtblptr = &_Object_vtable_prototype;"},{"Add":" return o;"},{"Add":"}"},{"Add":""},{"Add":"Object* Object_abort(Object* self)"},{"Add":"{"},{"Add":" printf(\"Abort called from class %s\\n\","},{"Add":" !self ? \"Unknown\" : self->vtblptr->name);"},{"Add":" exit(1);"},{"Add":" return self;"},{"Add":"}"},{"Add":""},{"Add":"String* Object_type_name(Object* self)"},{"Add":"{"},{"Add":" if (self == 0) {"},{"Add":" fprintf(stderr, \"At %s(line %d): self is NULL\\n\", __FILE__, __LINE__);"},{"Add":" abort();"},{"Add":" }"},{"Add":" String* s = String_new();"},{"Add":" s->val = self->vtblptr->name;"},{"Add":" return s;"},{"Add":"}"},{"Add":""},{"Add":"Object* Object_copy(Object* self)"},{"Add":"{"},{"Add":" if (self == 0) {"},{"Add":" fprintf(stderr, \"At %s(line %d): self is NULL\\n\", __FILE__, __LINE__);"},{"Add":" abort();"},{"Add":" }"},{"Add":""},{"Add":" unsigned size = self->vtblptr->size;"},{"Add":" assert(size > 0);"},{"Add":" Object* obj = (Object *) malloc(size);"},{"Add":" if (obj == 0) {"},{"Add":" fprintf(stderr, \"At %s(line %d): malloc failed in Object::copy()\\n\","},{"Add":" __FILE__, __LINE__);"},{"Add":" abort();"},{"Add":" }"},{"Add":" memcpy(obj, self, size);"},{"Add":" return obj;"},{"Add":"}"},{"Add":""},{"Add":"/*"},{"Add":"// Methods in class IO (only some are provided to you)"},{"Add":"*/"},{"Add":"IO* IO_new()"},{"Add":"{"},{"Add":" IO* io = (IO *) malloc(sizeof(IO));"},{"Add":" if (io == 0) {"},{"Add":" fprintf(stderr, \"At %s(line %d): Out of memory\\n\", __FILE__, __LINE__);"},{"Add":" Object_abort((Object *) 0);"},{"Add":" }"},{"Add":" io->vtblptr = &_IO_vtable_prototype;"},{"Add":" return io;"},{"Add":"}"},{"Add":""},{"Add":"IO* IO_out_string(IO* self, String* s)"},{"Add":"{"},{"Add":" if (self == 0 || s == 0) {"},{"Add":" fprintf(stderr, \"At %s(line %d): NULL object\\n\", __FILE__, __LINE__);"},{"Add":" abort();"},{"Add":" }"},{"Add":" printf(\"%s\", s->val);"},{"Add":" return self;"},{"Add":"}"},{"Add":""},{"Add":"IO* IO_out_int(IO* self, int x)"},{"Add":"{"},{"Add":" if (self == 0) {"},{"Add":" fprintf(stderr, \"At %s(line %d): NULL object\\n\", __FILE__, __LINE__);"},{"Add":" abort();"},{"Add":" }"},{"Add":" printf(\"%d\", x);"},{"Add":" return self;"},{"Add":"}"},{"Add":""},{"Add":"/*"},{"Add":" * Get one line from stream using get_line(), then discard newline character."},{"Add":" * Allocate string *in_string_p and store result there."},{"Add":" * Return number of chars read."},{"Add":" */"},{"Add":"static int get_one_line(char** in_string_p, FILE* stream)"},{"Add":"{"},{"Add":" /* Get one line worth of input */"},{"Add":" size_t len = 0;"},{"Add":" ssize_t num_chars_read;"},{"Add":" num_chars_read = getline(in_string_p, &len, stdin);"},{"Add":" if (*in_string_p == 0) {"},{"Add":" fprintf("},{"Add":" stderr, \"At %s(line %d): allocation failed in IO::in_string()\\n\","},{"Add":" __FILE__, __LINE__);"},{"Add":" exit(1);"},{"Add":" }"},{"Add":""},{"Add":" /* Discard the newline char, if any. It may not exist if EOF reached. */"},{"Add":" if (num_chars_read > 0 && (*in_string_p)[num_chars_read - 1] == '\\n') {"},{"Add":" (*in_string_p)[num_chars_read - 1] = '\\0';"},{"Add":" --len;"},{"Add":" }"},{"Add":""},{"Add":" return len;"},{"Add":"}"},{"Add":""},{"Add":"/*"},{"Add":" * The method IO::in_string(): String reads a string from"},{"Add":" * the standard input, up to but not including a newline character."},{"Add":" */"},{"Add":"String* IO_in_string(IO* self)"},{"Add":"{"},{"Add":" if (self == 0) {"},{"Add":" fprintf(stderr, \"At %s(line %d): self is NULL\\n\", __FILE__, __LINE__);"},{"Add":" abort();"},{"Add":" }"},{"Add":""},{"Add":" /* Get one line worth of input with the newline, if any, discarded */"},{"Add":" char* in_string = 0;"},{"Add":" ssize_t len = get_one_line(&in_string, stdin);"},{"Add":" assert(in_string);"},{"Add":""},{"Add":" /* We can take advantage of knowing the internal layout of String objects */"},{"Add":" String* str = String_new();"},{"Add":" str->val = in_string;"},{"Add":" return str;"},{"Add":"}"},{"Add":""},{"Add":"/*"},{"Add":" * The method IO::in_int(): Int reads a single integer, which may be preceded"},{"Add":" * by whitespace."},{"Add":" * Any characters following the integer, up to and including the next newline,"},{"Add":" * are discarded by in_int."},{"Add":" */"},{"Add":"int IO_in_int(IO* self)"},{"Add":"{"},{"Add":" if (self == 0) {"},{"Add":" fprintf(stderr, \"At %s(line %d): self is NULL\\n\", __FILE__, __LINE__);"},{"Add":" abort();"},{"Add":" }"},{"Add":""},{"Add":" /* Get one line worth of input with the newline, if any, discarded */"},{"Add":" char* in_string = 0;"},{"Add":" ssize_t len = get_one_line(&in_string, stdin);"},{"Add":" assert(in_string);"},{"Add":""},{"Add":" /* Now extract initial int and ignore the rest of the line */"},{"Add":" int x;"},{"Add":" int num_ints = 0;"},{"Add":" if (len)"},{"Add":" /* Discards initial spaces*/"},{"Add":" num_ints = sscanf(in_string, \" %d\", &x);"},{"Add":""},{"Add":" /* If no text found, abort. */"},{"Add":" if (num_ints == 0) {"},{"Add":" fprintf(stderr,"},{"Add":" \"At %s(line %d): Invalid integer on input in IO::in_int()\\n\","},{"Add":" __FILE__, __LINE__);"},{"Add":" Object_abort((Object *) self);"},{"Add":" }"},{"Add":" return x;"},{"Add":"}"},{"Add":""},{"Add":"/*"},{"Add":"// Methods in class Int"},{"Add":"*/"},{"Add":"Int* Int_new()"},{"Add":"{"},{"Add":" Int* x = (Int *) malloc(sizeof(Int));"},{"Add":" if (x == 0) {"},{"Add":" fprintf(stderr, \"At %s(line %d): Out of memory\\n\", __FILE__, __LINE__);"},{"Add":" Object_abort((Object *) 0);"},{"Add":" }"},{"Add":" x->vtblptr = &_Int_vtable_prototype;"},{"Add":" x->val = 0;"},{"Add":" return x;"},{"Add":"}"},{"Add":""},{"Add":"void Int_init(Int* self, int i) { self->val = i; }"},{"Add":""},{"Add":"/*"},{"Add":"// Methods in class Bool"},{"Add":"*/"},{"Add":"Bool* Bool_new()"},{"Add":"{"},{"Add":" Bool* b = (Bool *) malloc(sizeof(Bool));"},{"Add":" if (b == 0) {"},{"Add":" fprintf(stderr, \"At %s(line %d): Out of memory\\n\", __FILE__, __LINE__);"},{"Add":" Object_abort((Object *) 0);"},{"Add":" }"},{"Add":" b->vtblptr = &_Bool_vtable_prototype;"},{"Add":" b->val = false;"},{"Add":" return b;"},{"Add":"}"},{"Add":""},{"Add":"void Bool_init(Bool* self, bool b) { self->val = b; }"},{"Add":""},{"Add":"/*"},{"Add":"// Methods in class String"},{"Add":"*/"},{"Add":"String* String_new()"},{"Add":"{"},{"Add":" String* s = (String *) malloc(sizeof(String));"},{"Add":" if (s == 0) {"},{"Add":" fprintf(stderr, \"At %s(line %d): Out of memory\\n\", __FILE__, __LINE__);"},{"Add":" Object_abort((Object *) 0);"},{"Add":" }"},{"Add":" s->vtblptr = &_String_vtable_prototype;"},{"Add":" s->val = \"\";"},{"Add":" return s;"},{"Add":"}"},{"Add":""},{"Add":"int String_length(String* self)"},{"Add":"{"},{"Add":" if (self == 0) {"},{"Add":" fprintf(stderr, \"At %s(line %d): self is NULL\\n\", __FILE__, __LINE__);"},{"Add":" abort();"},{"Add":" }"},{"Add":""},{"Add":" return strlen(self->val);"},{"Add":"}"},{"Add":""},{"Add":"String* String_concat(String* self, String* s)"},{"Add":"{"},{"Add":" if (self == 0 || s == 0) {"},{"Add":" fprintf(stderr, \"At %s(line %d): NULL object\\n\", __FILE__, __LINE__);"},{"Add":" abort();"},{"Add":" }"},{"Add":""},{"Add":" String* s1 = (String *) malloc(sizeof(String));"},{"Add":" if (s1 == 0) {"},{"Add":" fprintf(stderr, \"At %s(line %d): Out of memory\\n\", __FILE__, __LINE__);"},{"Add":" Object_abort((Object *) 0);"},{"Add":" }"},{"Add":" s1->vtblptr = &_String_vtable_prototype;"},{"Add":""},{"Add":" char* cats = (char *) malloc(strlen(self->val) + strlen(s->val) + 1);"},{"Add":" if (cats == 0) {"},{"Add":" fprintf(stderr, \"At %s(line %d): Out of memory\\n\", __FILE__, __LINE__);"},{"Add":" Object_abort((Object *) 0);"},{"Add":" }"},{"Add":" strcpy(cats, self->val);"},{"Add":" strcat(cats, s->val);"},{"Add":" s1->val = cats;"},{"Add":""},{"Add":" return s1;"},{"Add":"}"},{"Add":""},{"Add":"String* String_substr(String* self, int i, int l)"},{"Add":"{"},{"Add":" if (self == 0) {"},{"Add":" fprintf(stderr, \"At %s(line %d): self is NULL\\n\", __FILE__, __LINE__);"},{"Add":" abort();"},{"Add":" }"},{"Add":""},{"Add":" int len = strlen(self->val);"},{"Add":" if (i >= len || i + l - 1 >= len) {"},{"Add":" fprintf(stderr, \"At %s(line %d): Substring out of range\\n\", __FILE__,"},{"Add":" __LINE__);"},{"Add":" Object_abort((Object *) 0);"},{"Add":" }"},{"Add":""},{"Add":" String* s1 = (String *) malloc(sizeof(String));"},{"Add":" if (s1 == 0) {"},{"Add":" fprintf(stderr, \"At %s(line %d): Out of memory\\n\", __FILE__, __LINE__);"},{"Add":" Object_abort((Object *) 0);"},{"Add":" }"},{"Add":" s1->vtblptr = &_String_vtable_prototype;"},{"Add":""},{"Add":" char* subs = (char *) malloc(l + 1);"},{"Add":" if (subs == 0) {"},{"Add":" fprintf(stderr, \"At %s(line %d): Out of memory\\n\", __FILE__, __LINE__);"},{"Add":" Object_abort((Object *) 0);"},{"Add":" }"},{"Add":" strncpy(subs, &(self->val[i]), l);"},{"Add":" subs[l] = '\\0';"},{"Add":" s1->val = subs;"},{"Add":""},{"Add":" return s1;"},{"Add":"}"}]}},{"FileAdd":{"meta":{"basename":"lib","metadata":576},"context":[{"change":0,"pos":1}],"contents":[]}},{"FileAdd":{"meta":{"basename":"win","metadata":576},"context":[{"change":0,"pos":78394}],"contents":[]}},{"FileAdd":{"meta":{"basename":"unistd.h","metadata":0},"context":[{"change":0,"pos":78411}],"contents":[{"Add":"//"},{"Add":"// Created by isaac on 2/18/2024."},{"Add":"//"},{"Add":""},{"Add":"#ifdef _WIN32"},{"Add":"#ifndef UNISTD_H"},{"Add":"#define UNISTD_H"},{"Add":""},{"Add":"#include "},{"Add":"#include "},{"Add":"#include "},{"Add":""},{"Add":"#include /* for getpid() and the exec..() family */"},{"Add":"#include /* for _getcwd() and _chdir() */"},{"Add":""},{"Add":"#define srandom srand"},{"Add":"#define random rand"},{"Add":""},{"Add":"/* Values for the second argument to access."},{"Add":" These may be OR'd together. */"},{"Add":"#define R_OK 4 /* Test for read permission. */"},{"Add":"#define W_OK 2 /* Test for write permission. */"},{"Add":"//#define X_OK 1 /* execute permission - unsupported in windows*/"},{"Add":"#define F_OK 0 /* Test for existence. */"},{"Add":""},{"Add":"#define access _access"},{"Add":"#define dup2 _dup2"},{"Add":"#define execve _execve"},{"Add":"#define ftruncate _chsize"},{"Add":"#define unlink _unlink"},{"Add":"#define fileno _fileno"},{"Add":"#define getcwd _getcwd"},{"Add":"#define chdir _chdir"},{"Add":"#define isatty _isatty"},{"Add":"#define lseek _lseek"},{"Add":"/* read, write, and close are NOT being #defined here, because while there are file handle specific versions for Windows, they probably don't work for sockets. You need to look at your app and consider whether to call e.g. closesocket(). */"},{"Add":""},{"Add":"#ifdef _WIN64"},{"Add":"#define ssize_t __int64"},{"Add":"#else"},{"Add":"#define ssize_t long"},{"Add":"#endif"},{"Add":""},{"Add":"#define STDIN_FILENO 0"},{"Add":"#define STDOUT_FILENO 1"},{"Add":"#define STDERR_FILENO 2"},{"Add":"/* should be in some equivalent to */"},{"Add":"// typedef __int8 int8_t;"},{"Add":"// typedef __int16 int16_t;"},{"Add":"// typedef __int32 int32_t;"},{"Add":"// typedef __int64 int64_t;"},{"Add":"// typedef unsigned __int8 uint8_t;"},{"Add":"// typedef unsigned __int16 uint16_t;"},{"Add":"// typedef unsigned __int32 uint32_t;"},{"Add":"// typedef unsigned __int64 uint64_t;"},{"Add":""},{"Add":"#endif //UNISTD_H"},{"Add":"#endif //WIN32"}]}},{"FileAdd":{"meta":{"basename":"getopt.h","metadata":0},"context":[{"change":0,"pos":78411}],"contents":[{"Add":"#ifndef __GETOPT_H__"},{"Add":"/**"},{"Add":" * DISCLAIMER"},{"Add":" * This file has no copyright assigned and is placed in the Public Domain."},{"Add":" * This file is a part of the w64 mingw-runtime package."},{"Add":" *"},{"Add":" * The w64 mingw-runtime package and its code is distributed in the hope that it "},{"Add":" * will be useful but WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESSED OR "},{"Add":" * IMPLIED ARE HEREBY DISCLAIMED. This includes but is not limited to "},{"Add":" * warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."},{"Add":" */"},{"Add":""},{"Add":"#define __GETOPT_H__"},{"Add":""},{"Add":"/* All the headers include this file. */"},{"Add":"#include "},{"Add":""},{"Add":"#if defined( WINGETOPT_SHARED_LIB )"},{"Add":"# if defined( BUILDING_WINGETOPT_DLL )"},{"Add":"# define WINGETOPT_API __declspec(dllexport)"},{"Add":"# else"},{"Add":"# define WINGETOPT_API __declspec(dllimport)"},{"Add":"# endif"},{"Add":"#else"},{"Add":"# define WINGETOPT_API"},{"Add":"#endif"},{"Add":""},{"Add":"#ifdef __cplusplus"},{"Add":"extern \"C\" {"},{"Add":"#endif"},{"Add":""},{"Add":"WINGETOPT_API extern int optind;\t\t/* index of first non-option in argv */"},{"Add":"WINGETOPT_API extern int optopt;\t\t/* single option character, as parsed */"},{"Add":"WINGETOPT_API extern int opterr;\t\t/* flag to enable built-in diagnostics... */"},{"Add":"\t\t\t\t/* (user may set to zero, to suppress) */"},{"Add":""},{"Add":"WINGETOPT_API extern char *optarg;\t\t/* pointer to argument of current option */"},{"Add":""},{"Add":"extern int getopt(int nargc, char * const *nargv, const char *options);"},{"Add":""},{"Add":"#ifdef _BSD_SOURCE"},{"Add":"/*"},{"Add":" * BSD adds the non-standard `optreset' feature, for reinitialisation"},{"Add":" * of `getopt' parsing. We support this feature, for applications which"},{"Add":" * proclaim their BSD heritage, before including this header; however,"},{"Add":" * to maintain portability, developers are advised to avoid it."},{"Add":" */"},{"Add":"# define optreset __mingw_optreset"},{"Add":"extern int optreset;"},{"Add":"#endif"},{"Add":"#ifdef __cplusplus"},{"Add":"}"},{"Add":"#endif"},{"Add":"/*"},{"Add":" * POSIX requires the `getopt' API to be specified in `unistd.h';"},{"Add":" * thus, `unistd.h' includes this header. However, we do not want"},{"Add":" * to expose the `getopt_long' or `getopt_long_only' APIs, when"},{"Add":" * included in this manner. Thus, close the standard __GETOPT_H__"},{"Add":" * declarations block, and open an additional __GETOPT_LONG_H__"},{"Add":" * specific block, only when *not* __UNISTD_H_SOURCED__, in which"},{"Add":" * to declare the extended API."},{"Add":" */"},{"Add":"#endif /* !defined(__GETOPT_H__) */"},{"Add":""},{"Add":"#if !defined(__UNISTD_H_SOURCED__) && !defined(__GETOPT_LONG_H__)"},{"Add":"#define __GETOPT_LONG_H__"},{"Add":""},{"Add":"#ifdef __cplusplus"},{"Add":"extern \"C\" {"},{"Add":"#endif"},{"Add":""},{"Add":"struct option\t\t/* specification for a long form option...\t*/"},{"Add":"{"},{"Add":" const char *name;\t\t/* option name, without leading hyphens */"},{"Add":" int has_arg;\t\t/* does it take an argument?\t\t*/"},{"Add":" int *flag;\t\t/* where to save its status, or NULL\t*/"},{"Add":" int val;\t\t/* its associated status value\t\t*/"},{"Add":"};"},{"Add":""},{"Add":"enum \t\t/* permitted values for its `has_arg' field...\t*/"},{"Add":"{"},{"Add":" no_argument = 0, \t/* option never takes an argument\t*/"},{"Add":" required_argument,\t\t/* option always requires an argument\t*/"},{"Add":" optional_argument\t\t/* option may take an argument\t\t*/"},{"Add":"};"},{"Add":""},{"Add":"extern int getopt_long(int nargc, char * const *nargv, const char *options,"},{"Add":" const struct option *long_options, int *idx);"},{"Add":"extern int getopt_long_only(int nargc, char * const *nargv, const char *options,"},{"Add":" const struct option *long_options, int *idx);"},{"Add":"/*"},{"Add":" * Previous MinGW implementation had..."},{"Add":" */"},{"Add":"#ifndef HAVE_DECL_GETOPT"},{"Add":"/*"},{"Add":" * ...for the long form API only; keep this for compatibility."},{"Add":" */"},{"Add":"# define HAVE_DECL_GETOPT\t1"},{"Add":"#endif"},{"Add":""},{"Add":"#ifdef __cplusplus"},{"Add":"}"},{"Add":"#endif"},{"Add":""},{"Add":"#endif /* !defined(__UNISTD_H_SOURCED__) && !defined(__GETOPT_LONG_H__) */"}]}},{"FileAdd":{"meta":{"basename":"getopt.c","metadata":0},"context":[{"change":0,"pos":78411}],"contents":[{"Add":""},{"Add":"/*\t$OpenBSD: getopt_long.c,v 1.23 2007/10/31 12:34:57 chl Exp $\t*/"},{"Add":"/*\t$NetBSD: getopt_long.c,v 1.15 2002/01/31 22:43:40 tv Exp $\t*/"},{"Add":""},{"Add":"/*"},{"Add":" * Copyright (c) 2002 Todd C. Miller "},{"Add":" *"},{"Add":" * Permission to use, copy, modify, and distribute this software for any"},{"Add":" * purpose with or without fee is hereby granted, provided that the above"},{"Add":" * copyright notice and this permission notice appear in all copies."},{"Add":" *"},{"Add":" * THE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES"},{"Add":" * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF"},{"Add":" * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR"},{"Add":" * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES"},{"Add":" * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN"},{"Add":" * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF"},{"Add":" * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE."},{"Add":" *"},{"Add":" * Sponsored in part by the Defense Advanced Research Projects"},{"Add":" * Agency (DARPA) and Air Force Research Laboratory, Air Force"},{"Add":" * Materiel Command, USAF, under agreement number F39502-99-1-0512."},{"Add":" */"},{"Add":"/*-"},{"Add":" * Copyright (c) 2000 The NetBSD Foundation, Inc."},{"Add":" * All rights reserved."},{"Add":" *"},{"Add":" * This code is derived from software contributed to The NetBSD Foundation"},{"Add":" * by Dieter Baron and Thomas Klausner."},{"Add":" *"},{"Add":" * Redistribution and use in source and binary forms, with or without"},{"Add":" * modification, are permitted provided that the following conditions"},{"Add":" * are met:"},{"Add":" * 1. Redistributions of source code must retain the above copyright"},{"Add":" * notice, this list of conditions and the following disclaimer."},{"Add":" * 2. Redistributions in binary form must reproduce the above copyright"},{"Add":" * notice, this list of conditions and the following disclaimer in the"},{"Add":" * documentation and/or other materials provided with the distribution."},{"Add":" *"},{"Add":" * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS"},{"Add":" * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED"},{"Add":" * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR"},{"Add":" * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS"},{"Add":" * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR"},{"Add":" * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF"},{"Add":" * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS"},{"Add":" * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN"},{"Add":" * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)"},{"Add":" * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE"},{"Add":" * POSSIBILITY OF SUCH DAMAGE."},{"Add":" */"},{"Add":"#ifdef _WIN32"},{"Add":"#include "},{"Add":"#include "},{"Add":"#include "},{"Add":"#include "},{"Add":"#include "},{"Add":"#include "},{"Add":"#include "},{"Add":""},{"Add":"#define\tREPLACE_GETOPT\t\t/* use this getopt as the system getopt(3) */"},{"Add":""},{"Add":"#ifdef REPLACE_GETOPT"},{"Add":"int\topterr = 1;\t\t/* if error message should be printed */"},{"Add":"int\toptind = 1;\t\t/* index into parent argv vector */"},{"Add":"int\toptopt = '?';\t\t/* character checked for validity */"},{"Add":"#undef\toptreset\t\t/* see getopt.h */"},{"Add":"#define\toptreset\t\t__mingw_optreset"},{"Add":"int\toptreset;\t\t/* reset getopt */"},{"Add":"char *optarg;\t\t/* argument associated with option */"},{"Add":"#endif"},{"Add":""},{"Add":"#define PRINT_ERROR\t((opterr) && (*options != ':'))"},{"Add":""},{"Add":"#define FLAG_PERMUTE\t0x01\t/* permute non-options to the end of argv */"},{"Add":"#define FLAG_ALLARGS\t0x02\t/* treat non-options as args to option \"-1\" */"},{"Add":"#define FLAG_LONGONLY\t0x04\t/* operate as getopt_long_only */"},{"Add":""},{"Add":"/* return values */"},{"Add":"#define\tBADCH\t\t(int)'?'"},{"Add":"#define\tBADARG\t\t((*options == ':') ? (int)':' : (int)'?')"},{"Add":"#define\tINORDER \t(int)1"},{"Add":""},{"Add":"#ifndef __CYGWIN__"},{"Add":"#define __progname __argv[0]"},{"Add":"#else"},{"Add":"extern char __declspec(dllimport) *__progname;"},{"Add":"#endif"},{"Add":""},{"Add":"#ifdef __CYGWIN__"},{"Add":"static char EMSG[] = \"\";"},{"Add":"#else"},{"Add":"#define\tEMSG\t\t\"\""},{"Add":"#endif"},{"Add":""},{"Add":"static int getopt_internal(int, char * const *, const char *,"},{"Add":"\t\t\t const struct option *, int *, int);"},{"Add":"static int parse_long_options(char * const *, const char *,"},{"Add":"\t\t\t const struct option *, int *, int);"},{"Add":"static int gcd(int, int);"},{"Add":"static void permute_args(int, int, int, char * const *);"},{"Add":""},{"Add":"static char *place = EMSG; /* option letter processing */"},{"Add":""},{"Add":"/* XXX: set optreset to 1 rather than these two */"},{"Add":"static int nonopt_start = -1; /* first non option argument (for permute) */"},{"Add":"static int nonopt_end = -1; /* first option after non options (for permute) */"},{"Add":""},{"Add":"/* Error messages */"},{"Add":"static const char recargchar[] = \"option requires an argument -- %c\";"},{"Add":"static const char recargstring[] = \"option requires an argument -- %s\";"},{"Add":"static const char ambig[] = \"ambiguous option -- %.*s\";"},{"Add":"static const char noarg[] = \"option doesn't take an argument -- %.*s\";"},{"Add":"static const char illoptchar[] = \"unknown option -- %c\";"},{"Add":"static const char illoptstring[] = \"unknown option -- %s\";"},{"Add":""},{"Add":"static void"},{"Add":"_vwarnx(const char *fmt,va_list ap)"},{"Add":"{"},{"Add":" (void)fprintf(stderr,\"%s: \",__progname);"},{"Add":" if (fmt != NULL)"},{"Add":" (void)vfprintf(stderr,fmt,ap);"},{"Add":" (void)fprintf(stderr,\"\\n\");"},{"Add":"}"},{"Add":""},{"Add":"static void"},{"Add":"warnx(const char *fmt,...)"},{"Add":"{"},{"Add":" va_list ap;"},{"Add":" va_start(ap,fmt);"},{"Add":" _vwarnx(fmt,ap);"},{"Add":" va_end(ap);"},{"Add":"}"},{"Add":""},{"Add":"/*"},{"Add":" * Compute the greatest common divisor of a and b."},{"Add":" */"},{"Add":"static int"},{"Add":"gcd(int a, int b)"},{"Add":"{"},{"Add":"\tint c;"},{"Add":""},{"Add":"\tc = a % b;"},{"Add":"\twhile (c != 0) {"},{"Add":"\t\ta = b;"},{"Add":"\t\tb = c;"},{"Add":"\t\tc = a % b;"},{"Add":"\t}"},{"Add":""},{"Add":"\treturn (b);"},{"Add":"}"},{"Add":""},{"Add":"/*"},{"Add":" * Exchange the block from nonopt_start to nonopt_end with the block"},{"Add":" * from nonopt_end to opt_end (keeping the same order of arguments"},{"Add":" * in each block)."},{"Add":" */"},{"Add":"static void"},{"Add":"permute_args(int panonopt_start, int panonopt_end, int opt_end,"},{"Add":"\tchar * const *nargv)"},{"Add":"{"},{"Add":"\tint cstart, cyclelen, i, j, ncycle, nnonopts, nopts, pos;"},{"Add":"\tchar *swap;"},{"Add":""},{"Add":"\t/*"},{"Add":"\t * compute lengths of blocks and number and size of cycles"},{"Add":"\t */"},{"Add":"\tnnonopts = panonopt_end - panonopt_start;"},{"Add":"\tnopts = opt_end - panonopt_end;"},{"Add":"\tncycle = gcd(nnonopts, nopts);"},{"Add":"\tcyclelen = (opt_end - panonopt_start) / ncycle;"},{"Add":""},{"Add":"\tfor (i = 0; i < ncycle; i++) {"},{"Add":"\t\tcstart = panonopt_end+i;"},{"Add":"\t\tpos = cstart;"},{"Add":"\t\tfor (j = 0; j < cyclelen; j++) {"},{"Add":"\t\t\tif (pos >= panonopt_end)"},{"Add":"\t\t\t\tpos -= nnonopts;"},{"Add":"\t\t\telse"},{"Add":"\t\t\t\tpos += nopts;"},{"Add":"\t\t\tswap = nargv[pos];"},{"Add":"\t\t\t/* LINTED const cast */"},{"Add":"\t\t\t((char **) nargv)[pos] = nargv[cstart];"},{"Add":"\t\t\t/* LINTED const cast */"},{"Add":"\t\t\t((char **)nargv)[cstart] = swap;"},{"Add":"\t\t}"},{"Add":"\t}"},{"Add":"}"},{"Add":""},{"Add":"/*"},{"Add":" * parse_long_options --"},{"Add":" *\tParse long options in argc/argv argument vector."},{"Add":" * Returns -1 if short_too is set and the option does not match long_options."},{"Add":" */"},{"Add":"static int"},{"Add":"parse_long_options(char * const *nargv, const char *options,"},{"Add":"\tconst struct option *long_options, int *idx, int short_too)"},{"Add":"{"},{"Add":"\tchar *current_argv, *has_equal;"},{"Add":"\tsize_t current_argv_len;"},{"Add":"\tint i, ambiguous, match;"},{"Add":""},{"Add":"#define IDENTICAL_INTERPRETATION(_x, _y) \\"},{"Add":"\t(long_options[(_x)].has_arg == long_options[(_y)].has_arg && \\"},{"Add":"\t long_options[(_x)].flag == long_options[(_y)].flag && \\"},{"Add":"\t long_options[(_x)].val == long_options[(_y)].val)"},{"Add":""},{"Add":"\tcurrent_argv = place;"},{"Add":"\tmatch = -1;"},{"Add":"\tambiguous = 0;"},{"Add":""},{"Add":"\toptind++;"},{"Add":""},{"Add":"\tif ((has_equal = strchr(current_argv, '=')) != NULL) {"},{"Add":"\t\t/* argument found (--option=arg) */"},{"Add":"\t\tcurrent_argv_len = has_equal - current_argv;"},{"Add":"\t\thas_equal++;"},{"Add":"\t} else"},{"Add":"\t\tcurrent_argv_len = strlen(current_argv);"},{"Add":""},{"Add":"\tfor (i = 0; long_options[i].name; i++) {"},{"Add":"\t\t/* find matching long option */"},{"Add":"\t\tif (strncmp(current_argv, long_options[i].name,"},{"Add":"\t\t current_argv_len))"},{"Add":"\t\t\tcontinue;"},{"Add":""},{"Add":"\t\tif (strlen(long_options[i].name) == current_argv_len) {"},{"Add":"\t\t\t/* exact match */"},{"Add":"\t\t\tmatch = i;"},{"Add":"\t\t\tambiguous = 0;"},{"Add":"\t\t\tbreak;"},{"Add":"\t\t}"},{"Add":"\t\t/*"},{"Add":"\t\t * If this is a known short option, don't allow"},{"Add":"\t\t * a partial match of a single character."},{"Add":"\t\t */"},{"Add":"\t\tif (short_too && current_argv_len == 1)"},{"Add":"\t\t\tcontinue;"},{"Add":""},{"Add":"\t\tif (match == -1)\t/* partial match */"},{"Add":"\t\t\tmatch = i;"},{"Add":"\t\telse if (!IDENTICAL_INTERPRETATION(i, match))"},{"Add":"\t\t\tambiguous = 1;"},{"Add":"\t}"},{"Add":"\tif (ambiguous) {"},{"Add":"\t\t/* ambiguous abbreviation */"},{"Add":"\t\tif (PRINT_ERROR)"},{"Add":"\t\t\twarnx(ambig, (int)current_argv_len,"},{"Add":"\t\t\t current_argv);"},{"Add":"\t\toptopt = 0;"},{"Add":"\t\treturn (BADCH);"},{"Add":"\t}"},{"Add":"\tif (match != -1) {\t\t/* option found */"},{"Add":"\t\tif (long_options[match].has_arg == no_argument"},{"Add":"\t\t && has_equal) {"},{"Add":"\t\t\tif (PRINT_ERROR)"},{"Add":"\t\t\t\twarnx(noarg, (int)current_argv_len,"},{"Add":"\t\t\t\t current_argv);"},{"Add":"\t\t\t/*"},{"Add":"\t\t\t * XXX: GNU sets optopt to val regardless of flag"},{"Add":"\t\t\t */"},{"Add":"\t\t\tif (long_options[match].flag == NULL)"},{"Add":"\t\t\t\toptopt = long_options[match].val;"},{"Add":"\t\t\telse"},{"Add":"\t\t\t\toptopt = 0;"},{"Add":"\t\t\treturn (BADARG);"},{"Add":"\t\t}"},{"Add":"\t\tif (long_options[match].has_arg == required_argument ||"},{"Add":"\t\t long_options[match].has_arg == optional_argument) {"},{"Add":"\t\t\tif (has_equal)"},{"Add":"\t\t\t\toptarg = has_equal;"},{"Add":"\t\t\telse if (long_options[match].has_arg =="},{"Add":"\t\t\t required_argument) {"},{"Add":"\t\t\t\t/*"},{"Add":"\t\t\t\t * optional argument doesn't use next nargv"},{"Add":"\t\t\t\t */"},{"Add":"\t\t\t\toptarg = nargv[optind++];"},{"Add":"\t\t\t}"},{"Add":"\t\t}"},{"Add":"\t\tif ((long_options[match].has_arg == required_argument)"},{"Add":"\t\t && (optarg == NULL)) {"},{"Add":"\t\t\t/*"},{"Add":"\t\t\t * Missing argument; leading ':' indicates no error"},{"Add":"\t\t\t * should be generated."},{"Add":"\t\t\t */"},{"Add":"\t\t\tif (PRINT_ERROR)"},{"Add":"\t\t\t\twarnx(recargstring,"},{"Add":"\t\t\t\t current_argv);"},{"Add":"\t\t\t/*"},{"Add":"\t\t\t * XXX: GNU sets optopt to val regardless of flag"},{"Add":"\t\t\t */"},{"Add":"\t\t\tif (long_options[match].flag == NULL)"},{"Add":"\t\t\t\toptopt = long_options[match].val;"},{"Add":"\t\t\telse"},{"Add":"\t\t\t\toptopt = 0;"},{"Add":"\t\t\t--optind;"},{"Add":"\t\t\treturn (BADARG);"},{"Add":"\t\t}"},{"Add":"\t} else {\t\t\t/* unknown option */"},{"Add":"\t\tif (short_too) {"},{"Add":"\t\t\t--optind;"},{"Add":"\t\t\treturn (-1);"},{"Add":"\t\t}"},{"Add":"\t\tif (PRINT_ERROR)"},{"Add":"\t\t\twarnx(illoptstring, current_argv);"},{"Add":"\t\toptopt = 0;"},{"Add":"\t\treturn (BADCH);"},{"Add":"\t}"},{"Add":"\tif (idx)"},{"Add":"\t\t*idx = match;"},{"Add":"\tif (long_options[match].flag) {"},{"Add":"\t\t*long_options[match].flag = long_options[match].val;"},{"Add":"\t\treturn (0);"},{"Add":"\t} else"},{"Add":"\t\treturn (long_options[match].val);"},{"Add":"#undef IDENTICAL_INTERPRETATION"},{"Add":"}"},{"Add":""},{"Add":"/*"},{"Add":" * getopt_internal --"},{"Add":" *\tParse argc/argv argument vector. Called by user level routines."},{"Add":" */"},{"Add":"static int"},{"Add":"getopt_internal(int nargc, char * const *nargv, const char *options,"},{"Add":"\tconst struct option *long_options, int *idx, int flags)"},{"Add":"{"},{"Add":"\tconst char *oli;\t\t\t\t/* option letter list index */"},{"Add":"\tint optchar, short_too;"},{"Add":"\tstatic int posixly_correct = -1;"},{"Add":""},{"Add":"\tif (options == NULL)"},{"Add":"\t\treturn (-1);"},{"Add":""},{"Add":"\t/*"},{"Add":"\t * XXX Some GNU programs (like cvs) set optind to 0 instead of"},{"Add":"\t * XXX using optreset. Work around this braindamage."},{"Add":"\t */"},{"Add":"\tif (optind == 0)"},{"Add":"\t\toptind = optreset = 1;"},{"Add":""},{"Add":"\t/*"},{"Add":"\t * Disable GNU extensions if POSIXLY_CORRECT is set or options"},{"Add":"\t * string begins with a '+'."},{"Add":"\t *"},{"Add":"\t * CV, 2009-12-14: Check POSIXLY_CORRECT anew if optind == 0 or"},{"Add":"\t * optreset != 0 for GNU compatibility."},{"Add":"\t */"},{"Add":"\tif (posixly_correct == -1 || optreset != 0)"},{"Add":"\t\tposixly_correct = (getenv(\"POSIXLY_CORRECT\") != NULL);"},{"Add":"\tif (*options == '-')"},{"Add":"\t\tflags |= FLAG_ALLARGS;"},{"Add":"\telse if (posixly_correct || *options == '+')"},{"Add":"\t\tflags &= ~FLAG_PERMUTE;"},{"Add":"\tif (*options == '+' || *options == '-')"},{"Add":"\t\toptions++;"},{"Add":""},{"Add":"\toptarg = NULL;"},{"Add":"\tif (optreset)"},{"Add":"\t\tnonopt_start = nonopt_end = -1;"},{"Add":"start:"},{"Add":"\tif (optreset || !*place) {\t\t/* update scanning pointer */"},{"Add":"\t\toptreset = 0;"},{"Add":"\t\tif (optind >= nargc) { /* end of argument vector */"},{"Add":"\t\t\tplace = EMSG;"},{"Add":"\t\t\tif (nonopt_end != -1) {"},{"Add":"\t\t\t\t/* do permutation, if we have to */"},{"Add":"\t\t\t\tpermute_args(nonopt_start, nonopt_end,"},{"Add":"\t\t\t\t optind, nargv);"},{"Add":"\t\t\t\toptind -= nonopt_end - nonopt_start;"},{"Add":"\t\t\t}"},{"Add":"\t\t\telse if (nonopt_start != -1) {"},{"Add":"\t\t\t\t/*"},{"Add":"\t\t\t\t * If we skipped non-options, set optind"},{"Add":"\t\t\t\t * to the first of them."},{"Add":"\t\t\t\t */"},{"Add":"\t\t\t\toptind = nonopt_start;"},{"Add":"\t\t\t}"},{"Add":"\t\t\tnonopt_start = nonopt_end = -1;"},{"Add":"\t\t\treturn (-1);"},{"Add":"\t\t}"},{"Add":"\t\tif (*(place = nargv[optind]) != '-' ||"},{"Add":"\t\t (place[1] == '\\0' && strchr(options, '-') == NULL)) {"},{"Add":"\t\t\tplace = EMSG;\t\t/* found non-option */"},{"Add":"\t\t\tif (flags & FLAG_ALLARGS) {"},{"Add":"\t\t\t\t/*"},{"Add":"\t\t\t\t * GNU extension:"},{"Add":"\t\t\t\t * return non-option as argument to option 1"},{"Add":"\t\t\t\t */"},{"Add":"\t\t\t\toptarg = nargv[optind++];"},{"Add":"\t\t\t\treturn (INORDER);"},{"Add":"\t\t\t}"},{"Add":"\t\t\tif (!(flags & FLAG_PERMUTE)) {"},{"Add":"\t\t\t\t/*"},{"Add":"\t\t\t\t * If no permutation wanted, stop parsing"},{"Add":"\t\t\t\t * at first non-option."},{"Add":"\t\t\t\t */"},{"Add":"\t\t\t\treturn (-1);"},{"Add":"\t\t\t}"},{"Add":"\t\t\t/* do permutation */"},{"Add":"\t\t\tif (nonopt_start == -1)"},{"Add":"\t\t\t\tnonopt_start = optind;"},{"Add":"\t\t\telse if (nonopt_end != -1) {"},{"Add":"\t\t\t\tpermute_args(nonopt_start, nonopt_end,"},{"Add":"\t\t\t\t optind, nargv);"},{"Add":"\t\t\t\tnonopt_start = optind -"},{"Add":"\t\t\t\t (nonopt_end - nonopt_start);"},{"Add":"\t\t\t\tnonopt_end = -1;"},{"Add":"\t\t\t}"},{"Add":"\t\t\toptind++;"},{"Add":"\t\t\t/* process next argument */"},{"Add":"\t\t\tgoto start;"},{"Add":"\t\t}"},{"Add":"\t\tif (nonopt_start != -1 && nonopt_end == -1)"},{"Add":"\t\t\tnonopt_end = optind;"},{"Add":""},{"Add":"\t\t/*"},{"Add":"\t\t * If we have \"-\" do nothing, if \"--\" we are done."},{"Add":"\t\t */"},{"Add":"\t\tif (place[1] != '\\0' && *++place == '-' && place[1] == '\\0') {"},{"Add":"\t\t\toptind++;"},{"Add":"\t\t\tplace = EMSG;"},{"Add":"\t\t\t/*"},{"Add":"\t\t\t * We found an option (--), so if we skipped"},{"Add":"\t\t\t * non-options, we have to permute."},{"Add":"\t\t\t */"},{"Add":"\t\t\tif (nonopt_end != -1) {"},{"Add":"\t\t\t\tpermute_args(nonopt_start, nonopt_end,"},{"Add":"\t\t\t\t optind, nargv);"},{"Add":"\t\t\t\toptind -= nonopt_end - nonopt_start;"},{"Add":"\t\t\t}"},{"Add":"\t\t\tnonopt_start = nonopt_end = -1;"},{"Add":"\t\t\treturn (-1);"},{"Add":"\t\t}"},{"Add":"\t}"},{"Add":""},{"Add":"\t/*"},{"Add":"\t * Check long options if:"},{"Add":"\t * 1) we were passed some"},{"Add":"\t * 2) the arg is not just \"-\""},{"Add":"\t * 3) either the arg starts with -- we are getopt_long_only()"},{"Add":"\t */"},{"Add":"\tif (long_options != NULL && place != nargv[optind] &&"},{"Add":"\t (*place == '-' || (flags & FLAG_LONGONLY))) {"},{"Add":"\t\tshort_too = 0;"},{"Add":"\t\tif (*place == '-')"},{"Add":"\t\t\tplace++;\t\t/* --foo long option */"},{"Add":"\t\telse if (*place != ':' && strchr(options, *place) != NULL)"},{"Add":"\t\t\tshort_too = 1;\t\t/* could be short option too */"},{"Add":""},{"Add":"\t\toptchar = parse_long_options(nargv, options, long_options,"},{"Add":"\t\t idx, short_too);"},{"Add":"\t\tif (optchar != -1) {"},{"Add":"\t\t\tplace = EMSG;"},{"Add":"\t\t\treturn (optchar);"},{"Add":"\t\t}"},{"Add":"\t}"},{"Add":""},{"Add":"\tif ((optchar = (int)*place++) == (int)':' ||"},{"Add":"\t (optchar == (int)'-' && *place != '\\0') ||"},{"Add":"\t (oli = strchr(options, optchar)) == NULL) {"},{"Add":"\t\t/*"},{"Add":"\t\t * If the user specified \"-\" and '-' isn't listed in"},{"Add":"\t\t * options, return -1 (non-option) as per POSIX."},{"Add":"\t\t * Otherwise, it is an unknown option character (or ':')."},{"Add":"\t\t */"},{"Add":"\t\tif (optchar == (int)'-' && *place == '\\0')"},{"Add":"\t\t\treturn (-1);"},{"Add":"\t\tif (!*place)"},{"Add":"\t\t\t++optind;"},{"Add":"\t\tif (PRINT_ERROR)"},{"Add":"\t\t\twarnx(illoptchar, optchar);"},{"Add":"\t\toptopt = optchar;"},{"Add":"\t\treturn (BADCH);"},{"Add":"\t}"},{"Add":"\tif (long_options != NULL && optchar == 'W' && oli[1] == ';') {"},{"Add":"\t\t/* -W long-option */"},{"Add":"\t\tif (*place)\t\t\t/* no space */"},{"Add":"\t\t\t/* NOTHING */;"},{"Add":"\t\telse if (++optind >= nargc) {\t/* no arg */"},{"Add":"\t\t\tplace = EMSG;"},{"Add":"\t\t\tif (PRINT_ERROR)"},{"Add":"\t\t\t\twarnx(recargchar, optchar);"},{"Add":"\t\t\toptopt = optchar;"},{"Add":"\t\t\treturn (BADARG);"},{"Add":"\t\t} else\t\t\t\t/* white space */"},{"Add":"\t\t\tplace = nargv[optind];"},{"Add":"\t\toptchar = parse_long_options(nargv, options, long_options,"},{"Add":"\t\t idx, 0);"},{"Add":"\t\tplace = EMSG;"},{"Add":"\t\treturn (optchar);"},{"Add":"\t}"},{"Add":"\tif (*++oli != ':') {\t\t\t/* doesn't take argument */"},{"Add":"\t\tif (!*place)"},{"Add":"\t\t\t++optind;"},{"Add":"\t} else {\t\t\t\t/* takes (optional) argument */"},{"Add":"\t\toptarg = NULL;"},{"Add":"\t\tif (*place)\t\t\t/* no white space */"},{"Add":"\t\t\toptarg = place;"},{"Add":"\t\telse if (oli[1] != ':') {\t/* arg not optional */"},{"Add":"\t\t\tif (++optind >= nargc) {\t/* no arg */"},{"Add":"\t\t\t\tplace = EMSG;"},{"Add":"\t\t\t\tif (PRINT_ERROR)"},{"Add":"\t\t\t\t\twarnx(recargchar, optchar);"},{"Add":"\t\t\t\toptopt = optchar;"},{"Add":"\t\t\t\treturn (BADARG);"},{"Add":"\t\t\t} else"},{"Add":"\t\t\t\toptarg = nargv[optind];"},{"Add":"\t\t}"},{"Add":"\t\tplace = EMSG;"},{"Add":"\t\t++optind;"},{"Add":"\t}"},{"Add":"\t/* dump back option letter */"},{"Add":"\treturn (optchar);"},{"Add":"}"},{"Add":""},{"Add":"#ifdef REPLACE_GETOPT"},{"Add":"/*"},{"Add":" * getopt --"},{"Add":" *\tParse argc/argv argument vector."},{"Add":" *"},{"Add":" * [eventually this will replace the BSD getopt]"},{"Add":" */"},{"Add":"int"},{"Add":"getopt(int nargc, char * const *nargv, const char *options)"},{"Add":"{"},{"Add":""},{"Add":"\t/*"},{"Add":"\t * We don't pass FLAG_PERMUTE to getopt_internal() since"},{"Add":"\t * the BSD getopt(3) (unlike GNU) has never done this."},{"Add":"\t *"},{"Add":"\t * Furthermore, since many privileged programs call getopt()"},{"Add":"\t * before dropping privileges it makes sense to keep things"},{"Add":"\t * as simple (and bug-free) as possible."},{"Add":"\t */"},{"Add":"\treturn (getopt_internal(nargc, nargv, options, NULL, NULL, 0));"},{"Add":"}"},{"Add":"#endif /* REPLACE_GETOPT */"},{"Add":""},{"Add":"/*"},{"Add":" * getopt_long --"},{"Add":" *\tParse argc/argv argument vector."},{"Add":" */"},{"Add":"int"},{"Add":"getopt_long(int nargc, char * const *nargv, const char *options,"},{"Add":" const struct option *long_options, int *idx)"},{"Add":"{"},{"Add":""},{"Add":"\treturn (getopt_internal(nargc, nargv, options, long_options, idx,"},{"Add":"\t FLAG_PERMUTE));"},{"Add":"}"},{"Add":""},{"Add":"/*"},{"Add":" * getopt_long_only --"},{"Add":" *\tParse argc/argv argument vector."},{"Add":" */"},{"Add":"int"},{"Add":"getopt_long_only(int nargc, char * const *nargv, const char *options,"},{"Add":" const struct option *long_options, int *idx)"},{"Add":"{"},{"Add":""},{"Add":"\treturn (getopt_internal(nargc, nargv, options, long_options, idx,"},{"Add":"\t FLAG_PERMUTE|FLAG_LONGONLY));"},{"Add":"}"},{"Add":"#endif"}]}},{"FileAdd":{"meta":{"basename":"utils.cc","metadata":0},"context":[{"change":0,"pos":78394}],"contents":[{"Add":""},{"Add":"#include \"utils.h\""},{"Add":"#include "},{"Add":"#include "},{"Add":"#include "},{"Add":""},{"Add":"std::string pad(int n) {"},{"Add":" if (n <= 0) {"},{"Add":" return \"\";"},{"Add":" }"},{"Add":" return std::string(std::min(n, 80), ' ');"},{"Add":"}"},{"Add":""},{"Add":"void print_escaped_string(std::ostream &str, const std::string &s) {"},{"Add":" for (char c : s) {"},{"Add":" switch (c) {"},{"Add":" case '\\\\':"},{"Add":" str << \"\\\\\\\\\";"},{"Add":" break;"},{"Add":" case '\\\"':"},{"Add":" str << \"\\\\\\\"\";"},{"Add":" break;"},{"Add":" case '\\n':"},{"Add":" str << \"\\\\n\";"},{"Add":" break;"},{"Add":" case '\\t':"},{"Add":" str << \"\\\\t\";"},{"Add":" break;"},{"Add":" case '\\b':"},{"Add":" str << \"\\\\b\";"},{"Add":" break;"},{"Add":" case '\\f':"},{"Add":" str << \"\\\\f\";"},{"Add":" break;"},{"Add":""},{"Add":" default:"},{"Add":" if (isprint(c))"},{"Add":" str << c;"},{"Add":" else"},{"Add":" //"},{"Add":" // Unprintable characters are printed using octal equivalents."},{"Add":" // To get the sign of the octal number correct, the character"},{"Add":" // must be cast to an unsigned char before coverting it to an"},{"Add":" // integer."},{"Add":" //"},{"Add":" str << '\\\\' << std::oct << std::setfill('0') << std::setw(3)"},{"Add":" << (int)((unsigned char)(c)) << std::dec << std::setfill(' ');"},{"Add":" break;"},{"Add":" }"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"void dump_Boolean(std::ostream &stream, int padding, bool b) {"},{"Add":" stream << pad(padding) << (int)b << \"\\n\";"},{"Add":"}"},{"Add":"void dump_Symbol(std::ostream &s, int n, Symbol sym) {"},{"Add":" s << pad(n) << sym->get_string() << std::endl;"},{"Add":"}"}]}},{"FileAdd":{"meta":{"basename":"tree.cc","metadata":0},"context":[{"change":0,"pos":78394}],"contents":[{"Add":""},{"Add":"//"},{"Add":"// See copyright.h for copyright notice and limitation of liability"},{"Add":"// and disclaimer of warranty provisions."},{"Add":"//"},{"Add":"#include \"copyright.h\""},{"Add":""},{"Add":"///////////////////////////////////////////////////////////////////////////"},{"Add":"//"},{"Add":"// file: tree.cc"},{"Add":"//"},{"Add":"// This file defines the basic class of tree node"},{"Add":"//"},{"Add":"///////////////////////////////////////////////////////////////////////////"},{"Add":""},{"Add":"#include \"tree.h\""},{"Add":""},{"Add":"extern int curr_lineno;"},{"Add":""},{"Add":"///////////////////////////////////////////////////////////////////////////"},{"Add":"//"},{"Add":"// tree_node::tree_node"},{"Add":"//"},{"Add":"// constructor of tree node"},{"Add":"//"},{"Add":"///////////////////////////////////////////////////////////////////////////"},{"Add":"tree_node::tree_node() { line_number = curr_lineno; }"},{"Add":""},{"Add":"///////////////////////////////////////////////////////////////////////////"},{"Add":"//"},{"Add":"// tree_node::get_line_number"},{"Add":"//"},{"Add":"///////////////////////////////////////////////////////////////////////////"},{"Add":"int tree_node::get_line_number() { return line_number; }"},{"Add":""},{"Add":"//"},{"Add":"// Set up common area from existing node"},{"Add":"//"},{"Add":"tree_node *tree_node::set(tree_node *t) {"},{"Add":" line_number = t->line_number;"},{"Add":" return this;"},{"Add":"}"}]}},{"FileAdd":{"meta":{"basename":"stringtab.cc","metadata":0},"context":[{"change":0,"pos":78394}],"contents":[{"Add":""},{"Add":"#include \"stringtab.h\""},{"Add":""},{"Add":"IntTable inttable;"},{"Add":"IdTable idtable;"},{"Add":"StrTable stringtable;"}]}},{"FileAdd":{"meta":{"basename":"dumptype.cc","metadata":0},"context":[{"change":0,"pos":78394}],"contents":[{"Add":""},{"Add":"//"},{"Add":"// See copyright.h for copyright notice and limitation of liability"},{"Add":"// and disclaimer of warranty provisions."},{"Add":"//"},{"Add":"#include \"copyright.h\""},{"Add":""},{"Add":"#include \"cool_tree.h\""},{"Add":"#include \"tree.h\""},{"Add":"#include \"utils.h\""},{"Add":""},{"Add":"//////////////////////////////////////////////////////////////////"},{"Add":"//"},{"Add":"// dumptype.cc"},{"Add":"//"},{"Add":"// dumptype defines a simple recursive traversal of the abstract"},{"Add":"// syntax tree (AST) that prints each node and any associated"},{"Add":"// type information. Use dump_with_types to inspect the results of"},{"Add":"// type inference."},{"Add":"//"},{"Add":"// dump_with_types takes two argumenmts:"},{"Add":"// an output stream"},{"Add":"// an indentation \"n\", the number of blanks to insert at the beginning of"},{"Add":"// a new line."},{"Add":"//"},{"Add":"// dump_with_types is just a simple pretty printer, formatting the output"},{"Add":"// to show the AST relationships between nodes and their types."},{"Add":"// dump_type is a virtual function, with a separate implementation for"},{"Add":"// each kind of AST node."},{"Add":"//"},{"Add":"// dump_type prints the type of an Expression on the output stream,"},{"Add":"// after indenting the correct number of spaces. A check is made to"},{"Add":"// see if no type is assigned to the node."},{"Add":"//"},{"Add":"// Note that the \"type\" member referred to here is inherited from tree_node"},{"Add":"// by all subclasses of Expression_class. Note also that dump_type is"},{"Add":"// defined for the Phylum Expression here, and is therefore inherited by"},{"Add":"// every distinct subclass of Expression."},{"Add":"//"},{"Add":""},{"Add":"void Expression_class::dump_type(std::ostream &stream, int n) {"},{"Add":" if (type) {"},{"Add":" stream << pad(n) << \": \" << type->get_string() << std::endl;"},{"Add":" } else {"},{"Add":" stream << pad(n) << \": _no_type\" << std::endl;"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"void dump_line(std::ostream &stream, int n, tree_node *t) {"},{"Add":" stream << pad(n) << \"#\" << t->get_line_number() << \"\\n\";"},{"Add":"}"},{"Add":""},{"Add":"//"},{"Add":"// program_class prints \"program\" and then each of the"},{"Add":"// component classes of the program, one at a time, at a"},{"Add":"// greater indentation. The recursive invocation on"},{"Add":"// \"classes->nth(i)->dump_with_types(...)\" shows how useful"},{"Add":"// and compact virtual functions are for this kind of computation."},{"Add":"//"},{"Add":"// Note the use of the iterator to cycle through all of the"},{"Add":"// classes. The methods first, more, next, and nth on AST lists"},{"Add":"// are defined in tree.h."},{"Add":"//"},{"Add":"void program_class::dump_with_types(std::ostream &stream, int n) {"},{"Add":" dump_line(stream, n, this);"},{"Add":" stream << pad(n) << \"_program\\n\";"},{"Add":" for (int i = classes->first(); classes->more(i); i = classes->next(i)) {"},{"Add":" classes->nth(i)->dump_with_types(stream, n + 2);"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"//"},{"Add":"// Prints the components of a class, including all of the features."},{"Add":"// Note that printing the Features is another use of an iterator."},{"Add":"//"},{"Add":"void class__class::dump_with_types(std::ostream &stream, int n) {"},{"Add":" dump_line(stream, n, this);"},{"Add":" stream << pad(n) << \"_class\\n\";"},{"Add":" dump_Symbol(stream, n + 2, name);"},{"Add":" dump_Symbol(stream, n + 2, parent);"},{"Add":" stream << pad(n + 2) << \"\\\"\";"},{"Add":" print_escaped_string(stream, filename->get_string());"},{"Add":" stream << \"\\\"\\n\" << pad(n + 2) << \"(\\n\";"},{"Add":" for (int i = features->first(); features->more(i); i = features->next(i))"},{"Add":" features->nth(i)->dump_with_types(stream, n + 2);"},{"Add":" stream << pad(n + 2) << \")\\n\";"},{"Add":"}"},{"Add":""},{"Add":"//"},{"Add":"// dump_with_types for method_class first prints that this is a method,"},{"Add":"// then prints the method name followed by the formal parameters"},{"Add":"// (another use of an iterator, this time access all of the list members"},{"Add":"// of type Formal), the return type, and finally calls dump_type recursively"},{"Add":"// on the method body."},{"Add":""},{"Add":"void method_class::dump_with_types(std::ostream &stream, int n) {"},{"Add":" dump_line(stream, n, this);"},{"Add":" stream << pad(n) << \"_method\\n\";"},{"Add":" dump_Symbol(stream, n + 2, name);"},{"Add":" for (int i = formals->first(); formals->more(i); i = formals->next(i))"},{"Add":" formals->nth(i)->dump_with_types(stream, n + 2);"},{"Add":" dump_Symbol(stream, n + 2, return_type);"},{"Add":" expr->dump_with_types(stream, n + 2);"},{"Add":"}"},{"Add":""},{"Add":"//"},{"Add":"// attr_class::dump_with_types prints the attribute name, type declaration,"},{"Add":"// and any initialization expression at the appropriate offset."},{"Add":"//"},{"Add":"void attr_class::dump_with_types(std::ostream &stream, int n) {"},{"Add":" dump_line(stream, n, this);"},{"Add":" stream << pad(n) << \"_attr\\n\";"},{"Add":" dump_Symbol(stream, n + 2, name);"},{"Add":" dump_Symbol(stream, n + 2, type_decl);"},{"Add":" init->dump_with_types(stream, n + 2);"},{"Add":"}"},{"Add":""},{"Add":"//"},{"Add":"// formal_class::dump_with_types dumps the name and type declaration"},{"Add":"// of a formal parameter."},{"Add":"//"},{"Add":"void formal_class::dump_with_types(std::ostream &stream, int n) {"},{"Add":" dump_line(stream, n, this);"},{"Add":" stream << pad(n) << \"_formal\\n\";"},{"Add":" dump_Symbol(stream, n + 2, name);"},{"Add":" dump_Symbol(stream, n + 2, type_decl);"},{"Add":"}"},{"Add":""},{"Add":"//"},{"Add":"// branch_class::dump_with_types dumps the name, type declaration,"},{"Add":"// and body of any case branch."},{"Add":"//"},{"Add":"void branch_class::dump_with_types(std::ostream &stream, int n) {"},{"Add":" dump_line(stream, n, this);"},{"Add":" stream << pad(n) << \"_branch\\n\";"},{"Add":" dump_Symbol(stream, n + 2, name);"},{"Add":" dump_Symbol(stream, n + 2, type_decl);"},{"Add":" expr->dump_with_types(stream, n + 2);"},{"Add":"}"},{"Add":""},{"Add":"//"},{"Add":"// assign_class::dump_with_types prints \"assign\" and then (indented)"},{"Add":"// the variable being assigned, the expression, and finally the type"},{"Add":"// of the result. Note the call to dump_type (see above) at the"},{"Add":"// end of the method."},{"Add":"//"},{"Add":"void assign_class::dump_with_types(std::ostream &stream, int n) {"},{"Add":" dump_line(stream, n, this);"},{"Add":" stream << pad(n) << \"_assign\\n\";"},{"Add":" dump_Symbol(stream, n + 2, name);"},{"Add":" expr->dump_with_types(stream, n + 2);"},{"Add":" dump_type(stream, n);"},{"Add":"}"},{"Add":""},{"Add":"//"},{"Add":"// static_dispatch_class::dump_with_types prints the expression,"},{"Add":"// static dispatch class, function name, and actual arguments"},{"Add":"// of any static dispatch."},{"Add":"//"},{"Add":"void static_dispatch_class::dump_with_types(std::ostream &stream, int n) {"},{"Add":" dump_line(stream, n, this);"},{"Add":" stream << pad(n) << \"_static_dispatch\\n\";"},{"Add":" expr->dump_with_types(stream, n + 2);"},{"Add":" dump_Symbol(stream, n + 2, type_name);"},{"Add":" dump_Symbol(stream, n + 2, name);"},{"Add":" stream << pad(n + 2) << \"(\\n\";"},{"Add":" for (int i = actual->first(); actual->more(i); i = actual->next(i))"},{"Add":" actual->nth(i)->dump_with_types(stream, n + 2);"},{"Add":" stream << pad(n + 2) << \")\\n\";"},{"Add":" dump_type(stream, n);"},{"Add":"}"},{"Add":""},{"Add":"//"},{"Add":"// dispatch_class::dump_with_types is similar to"},{"Add":"// static_dispatch_class::dump_with_types"},{"Add":"//"},{"Add":"void dispatch_class::dump_with_types(std::ostream &stream, int n) {"},{"Add":" dump_line(stream, n, this);"},{"Add":" stream << pad(n) << \"_dispatch\\n\";"},{"Add":" expr->dump_with_types(stream, n + 2);"},{"Add":" dump_Symbol(stream, n + 2, name);"},{"Add":" stream << pad(n + 2) << \"(\\n\";"},{"Add":" for (int i = actual->first(); actual->more(i); i = actual->next(i))"},{"Add":" actual->nth(i)->dump_with_types(stream, n + 2);"},{"Add":" stream << pad(n + 2) << \")\\n\";"},{"Add":" dump_type(stream, n);"},{"Add":"}"},{"Add":""},{"Add":"//"},{"Add":"// cond_class::dump_with_types dumps each of the three expressions"},{"Add":"// in the conditional and then the type of the entire expression."},{"Add":"//"},{"Add":"void cond_class::dump_with_types(std::ostream &stream, int n) {"},{"Add":" dump_line(stream, n, this);"},{"Add":" stream << pad(n) << \"_cond\\n\";"},{"Add":" pred->dump_with_types(stream, n + 2);"},{"Add":" then_exp->dump_with_types(stream, n + 2);"},{"Add":" else_exp->dump_with_types(stream, n + 2);"},{"Add":" dump_type(stream, n);"},{"Add":"}"},{"Add":""},{"Add":"//"},{"Add":"// loop_class::dump_with_types dumps the predicate and then the"},{"Add":"// body of the loop, and finally the type of the entire expression."},{"Add":"//"},{"Add":"void loop_class::dump_with_types(std::ostream &stream, int n) {"},{"Add":" dump_line(stream, n, this);"},{"Add":" stream << pad(n) << \"_loop\\n\";"},{"Add":" pred->dump_with_types(stream, n + 2);"},{"Add":" body->dump_with_types(stream, n + 2);"},{"Add":" dump_type(stream, n);"},{"Add":"}"},{"Add":""},{"Add":"//"},{"Add":"// typcase_class::dump_with_types dumps each branch of the"},{"Add":"// the Case_ one at a time. The type of the entire expression"},{"Add":"// is dumped at the end."},{"Add":"//"},{"Add":"void typcase_class::dump_with_types(std::ostream &stream, int n) {"},{"Add":" dump_line(stream, n, this);"},{"Add":" stream << pad(n) << \"_typcase\\n\";"},{"Add":" expr->dump_with_types(stream, n + 2);"},{"Add":" for (int i = cases->first(); cases->more(i); i = cases->next(i))"},{"Add":" cases->nth(i)->dump_with_types(stream, n + 2);"},{"Add":" dump_type(stream, n);"},{"Add":"}"},{"Add":""},{"Add":"//"},{"Add":"// The rest of the cases for Expression are very straightforward"},{"Add":"// and introduce nothing that isn't already in the code discussed"},{"Add":"// above."},{"Add":"//"},{"Add":"void block_class::dump_with_types(std::ostream &stream, int n) {"},{"Add":" dump_line(stream, n, this);"},{"Add":" stream << pad(n) << \"_block\\n\";"},{"Add":" for (int i = body->first(); body->more(i); i = body->next(i))"},{"Add":" body->nth(i)->dump_with_types(stream, n + 2);"},{"Add":" dump_type(stream, n);"},{"Add":"}"},{"Add":""},{"Add":"void let_class::dump_with_types(std::ostream &stream, int n) {"},{"Add":" dump_line(stream, n, this);"},{"Add":" stream << pad(n) << \"_let\\n\";"},{"Add":" dump_Symbol(stream, n + 2, identifier);"},{"Add":" dump_Symbol(stream, n + 2, type_decl);"},{"Add":" init->dump_with_types(stream, n + 2);"},{"Add":" body->dump_with_types(stream, n + 2);"},{"Add":" dump_type(stream, n);"},{"Add":"}"},{"Add":""},{"Add":"void plus_class::dump_with_types(std::ostream &stream, int n) {"},{"Add":" dump_line(stream, n, this);"},{"Add":" stream << pad(n) << \"_plus\\n\";"},{"Add":" e1->dump_with_types(stream, n + 2);"},{"Add":" e2->dump_with_types(stream, n + 2);"},{"Add":" dump_type(stream, n);"},{"Add":"}"},{"Add":""},{"Add":"void sub_class::dump_with_types(std::ostream &stream, int n) {"},{"Add":" dump_line(stream, n, this);"},{"Add":" stream << pad(n) << \"_sub\\n\";"},{"Add":" e1->dump_with_types(stream, n + 2);"},{"Add":" e2->dump_with_types(stream, n + 2);"},{"Add":" dump_type(stream, n);"},{"Add":"}"},{"Add":""},{"Add":"void mul_class::dump_with_types(std::ostream &stream, int n) {"},{"Add":" dump_line(stream, n, this);"},{"Add":" stream << pad(n) << \"_mul\\n\";"},{"Add":" e1->dump_with_types(stream, n + 2);"},{"Add":" e2->dump_with_types(stream, n + 2);"},{"Add":" dump_type(stream, n);"},{"Add":"}"},{"Add":""},{"Add":"void divide_class::dump_with_types(std::ostream &stream, int n) {"},{"Add":" dump_line(stream, n, this);"},{"Add":" stream << pad(n) << \"_divide\\n\";"},{"Add":" e1->dump_with_types(stream, n + 2);"},{"Add":" e2->dump_with_types(stream, n + 2);"},{"Add":" dump_type(stream, n);"},{"Add":"}"},{"Add":""},{"Add":"void neg_class::dump_with_types(std::ostream &stream, int n) {"},{"Add":" dump_line(stream, n, this);"},{"Add":" stream << pad(n) << \"_neg\\n\";"},{"Add":" e1->dump_with_types(stream, n + 2);"},{"Add":" dump_type(stream, n);"},{"Add":"}"},{"Add":""},{"Add":"void lt_class::dump_with_types(std::ostream &stream, int n) {"},{"Add":" dump_line(stream, n, this);"},{"Add":" stream << pad(n) << \"_lt\\n\";"},{"Add":" e1->dump_with_types(stream, n + 2);"},{"Add":" e2->dump_with_types(stream, n + 2);"},{"Add":" dump_type(stream, n);"},{"Add":"}"},{"Add":""},{"Add":"void eq_class::dump_with_types(std::ostream &stream, int n) {"},{"Add":" dump_line(stream, n, this);"},{"Add":" stream << pad(n) << \"_eq\\n\";"},{"Add":" e1->dump_with_types(stream, n + 2);"},{"Add":" e2->dump_with_types(stream, n + 2);"},{"Add":" dump_type(stream, n);"},{"Add":"}"},{"Add":""},{"Add":"void leq_class::dump_with_types(std::ostream &stream, int n) {"},{"Add":" dump_line(stream, n, this);"},{"Add":" stream << pad(n) << \"_leq\\n\";"},{"Add":" e1->dump_with_types(stream, n + 2);"},{"Add":" e2->dump_with_types(stream, n + 2);"},{"Add":" dump_type(stream, n);"},{"Add":"}"},{"Add":""},{"Add":"void comp_class::dump_with_types(std::ostream &stream, int n) {"},{"Add":" dump_line(stream, n, this);"},{"Add":" stream << pad(n) << \"_comp\\n\";"},{"Add":" e1->dump_with_types(stream, n + 2);"},{"Add":" dump_type(stream, n);"},{"Add":"}"},{"Add":""},{"Add":"void int_const_class::dump_with_types(std::ostream &stream, int n) {"},{"Add":" dump_line(stream, n, this);"},{"Add":" stream << pad(n) << \"_int\\n\";"},{"Add":" dump_Symbol(stream, n + 2, token);"},{"Add":" dump_type(stream, n);"},{"Add":"}"},{"Add":""},{"Add":"void bool_const_class::dump_with_types(std::ostream &stream, int n) {"},{"Add":" dump_line(stream, n, this);"},{"Add":" stream << pad(n) << \"_bool\\n\";"},{"Add":" dump_Boolean(stream, n + 2, val);"},{"Add":" dump_type(stream, n);"},{"Add":"}"},{"Add":""},{"Add":"void string_const_class::dump_with_types(std::ostream &stream, int n) {"},{"Add":" dump_line(stream, n, this);"},{"Add":" stream << pad(n) << \"_string\\n\";"},{"Add":" stream << pad(n + 2) << \"\\\"\";"},{"Add":" print_escaped_string(stream, token->get_string());"},{"Add":" stream << \"\\\"\\n\";"},{"Add":" dump_type(stream, n);"},{"Add":"}"},{"Add":""},{"Add":"void new__class::dump_with_types(std::ostream &stream, int n) {"},{"Add":" dump_line(stream, n, this);"},{"Add":" stream << pad(n) << \"_new\\n\";"},{"Add":" dump_Symbol(stream, n + 2, type_name);"},{"Add":" dump_type(stream, n);"},{"Add":"}"},{"Add":""},{"Add":"void isvoid_class::dump_with_types(std::ostream &stream, int n) {"},{"Add":" dump_line(stream, n, this);"},{"Add":" stream << pad(n) << \"_isvoid\\n\";"},{"Add":" e1->dump_with_types(stream, n + 2);"},{"Add":" dump_type(stream, n);"},{"Add":"}"},{"Add":""},{"Add":"void no_expr_class::dump_with_types(std::ostream &stream, int n) {"},{"Add":" dump_line(stream, n, this);"},{"Add":" stream << pad(n) << \"_no_expr\\n\";"},{"Add":" dump_type(stream, n);"},{"Add":"}"},{"Add":""},{"Add":"void object_class::dump_with_types(std::ostream &stream, int n) {"},{"Add":" dump_line(stream, n, this);"},{"Add":" stream << pad(n) << \"_object\\n\";"},{"Add":" dump_Symbol(stream, n + 2, name);"},{"Add":" dump_type(stream, n);"},{"Add":"}"}]}},{"FileAdd":{"meta":{"basename":"cool_tree.cc","metadata":0},"context":[{"change":0,"pos":78394}],"contents":[{"Add":""},{"Add":"//////////////////////////////////////////////////////////"},{"Add":"//"},{"Add":"// file: cool-tree.cc"},{"Add":"//"},{"Add":"// This file defines the functions of each class"},{"Add":"//"},{"Add":"//////////////////////////////////////////////////////////"},{"Add":""},{"Add":"#include \"cool_tree.h\""},{"Add":"#include \"tree.h\""},{"Add":""},{"Add":"// constructors' functions"},{"Add":"Program program_class::copy_Program() {"},{"Add":" return new program_class(classes->copy_list());"},{"Add":"}"},{"Add":""},{"Add":"void program_class::dump(std::ostream &stream, int n) {"},{"Add":" stream << pad(n) << \"program\\n\";"},{"Add":" classes->dump(stream, n + 2);"},{"Add":"}"},{"Add":""},{"Add":"Class_ class__class::copy_Class_() {"},{"Add":" return new class__class(name, parent, features->copy_list(), filename);"},{"Add":"}"},{"Add":""},{"Add":"void class__class::dump(std::ostream &stream, int n) {"},{"Add":" stream << pad(n) << \"class_\\n\";"},{"Add":" dump_Symbol(stream, n + 2, name);"},{"Add":" dump_Symbol(stream, n + 2, parent);"},{"Add":" features->dump(stream, n + 2);"},{"Add":" dump_Symbol(stream, n + 2, filename);"},{"Add":"}"},{"Add":""},{"Add":"Feature method_class::copy_Feature() {"},{"Add":" return new method_class(name, formals->copy_list(), return_type,"},{"Add":" expr->copy_Expression());"},{"Add":"}"},{"Add":""},{"Add":"void method_class::dump(std::ostream &stream, int n) {"},{"Add":" stream << pad(n) << \"method\\n\";"},{"Add":" dump_Symbol(stream, n + 2, name);"},{"Add":" formals->dump(stream, n + 2);"},{"Add":" dump_Symbol(stream, n + 2, return_type);"},{"Add":" expr->dump(stream, n + 2);"},{"Add":"}"},{"Add":""},{"Add":"Feature attr_class::copy_Feature() {"},{"Add":" return new attr_class(name, type_decl, init->copy_Expression());"},{"Add":"}"},{"Add":""},{"Add":"void attr_class::dump(std::ostream &stream, int n) {"},{"Add":" stream << pad(n) << \"attr\\n\";"},{"Add":" dump_Symbol(stream, n + 2, name);"},{"Add":" dump_Symbol(stream, n + 2, type_decl);"},{"Add":" init->dump(stream, n + 2);"},{"Add":"}"},{"Add":""},{"Add":"Formal formal_class::copy_Formal() { return new formal_class(name, type_decl); }"},{"Add":""},{"Add":"void formal_class::dump(std::ostream &stream, int n) {"},{"Add":" stream << pad(n) << \"formal\\n\";"},{"Add":" dump_Symbol(stream, n + 2, name);"},{"Add":" dump_Symbol(stream, n + 2, type_decl);"},{"Add":"}"},{"Add":""},{"Add":"Case branch_class::copy_Case() {"},{"Add":" return new branch_class(name, type_decl, expr->copy_Expression());"},{"Add":"}"},{"Add":""},{"Add":"void branch_class::dump(std::ostream &stream, int n) {"},{"Add":" stream << pad(n) << \"branch\\n\";"},{"Add":" dump_Symbol(stream, n + 2, name);"},{"Add":" dump_Symbol(stream, n + 2, type_decl);"},{"Add":" expr->dump(stream, n + 2);"},{"Add":"}"},{"Add":""},{"Add":"Expression assign_class::copy_Expression() {"},{"Add":" return new assign_class(name, expr->copy_Expression());"},{"Add":"}"},{"Add":""},{"Add":"void assign_class::dump(std::ostream &stream, int n) {"},{"Add":" stream << pad(n) << \"assign\\n\";"},{"Add":" dump_Symbol(stream, n + 2, name);"},{"Add":" expr->dump(stream, n + 2);"},{"Add":"}"},{"Add":""},{"Add":"Expression static_dispatch_class::copy_Expression() {"},{"Add":" return new static_dispatch_class(expr->copy_Expression(), type_name, name,"},{"Add":" actual->copy_list());"},{"Add":"}"},{"Add":""},{"Add":"void static_dispatch_class::dump(std::ostream &stream, int n) {"},{"Add":" stream << pad(n) << \"static_dispatch\\n\";"},{"Add":" expr->dump(stream, n + 2);"},{"Add":" dump_Symbol(stream, n + 2, type_name);"},{"Add":" dump_Symbol(stream, n + 2, name);"},{"Add":" actual->dump(stream, n + 2);"},{"Add":"}"},{"Add":""},{"Add":"Expression dispatch_class::copy_Expression() {"},{"Add":" return new dispatch_class(expr->copy_Expression(), name, actual->copy_list());"},{"Add":"}"},{"Add":""},{"Add":"void dispatch_class::dump(std::ostream &stream, int n) {"},{"Add":" stream << pad(n) << \"dispatch\\n\";"},{"Add":" expr->dump(stream, n + 2);"},{"Add":" dump_Symbol(stream, n + 2, name);"},{"Add":" actual->dump(stream, n + 2);"},{"Add":"}"},{"Add":""},{"Add":"Expression cond_class::copy_Expression() {"},{"Add":" return new cond_class(pred->copy_Expression(), then_exp->copy_Expression(),"},{"Add":" else_exp->copy_Expression());"},{"Add":"}"},{"Add":""},{"Add":"void cond_class::dump(std::ostream &stream, int n) {"},{"Add":" stream << pad(n) << \"cond\\n\";"},{"Add":" pred->dump(stream, n + 2);"},{"Add":" then_exp->dump(stream, n + 2);"},{"Add":" else_exp->dump(stream, n + 2);"},{"Add":"}"},{"Add":""},{"Add":"Expression loop_class::copy_Expression() {"},{"Add":" return new loop_class(pred->copy_Expression(), body->copy_Expression());"},{"Add":"}"},{"Add":""},{"Add":"void loop_class::dump(std::ostream &stream, int n) {"},{"Add":" stream << pad(n) << \"loop\\n\";"},{"Add":" pred->dump(stream, n + 2);"},{"Add":" body->dump(stream, n + 2);"},{"Add":"}"},{"Add":""},{"Add":"Expression typcase_class::copy_Expression() {"},{"Add":" return new typcase_class(expr->copy_Expression(), cases->copy_list());"},{"Add":"}"},{"Add":""},{"Add":"void typcase_class::dump(std::ostream &stream, int n) {"},{"Add":" stream << pad(n) << \"typcase\\n\";"},{"Add":" expr->dump(stream, n + 2);"},{"Add":" cases->dump(stream, n + 2);"},{"Add":"}"},{"Add":""},{"Add":"Expression block_class::copy_Expression() {"},{"Add":" return new block_class(body->copy_list());"},{"Add":"}"},{"Add":""},{"Add":"void block_class::dump(std::ostream &stream, int n) {"},{"Add":" stream << pad(n) << \"block\\n\";"},{"Add":" body->dump(stream, n + 2);"},{"Add":"}"},{"Add":""},{"Add":"Expression let_class::copy_Expression() {"},{"Add":" return new let_class(identifier, type_decl, init->copy_Expression(),"},{"Add":" body->copy_Expression());"},{"Add":"}"},{"Add":""},{"Add":"void let_class::dump(std::ostream &stream, int n) {"},{"Add":" stream << pad(n) << \"let\\n\";"},{"Add":" dump_Symbol(stream, n + 2, identifier);"},{"Add":" dump_Symbol(stream, n + 2, type_decl);"},{"Add":" init->dump(stream, n + 2);"},{"Add":" body->dump(stream, n + 2);"},{"Add":"}"},{"Add":""},{"Add":"Expression plus_class::copy_Expression() {"},{"Add":" return new plus_class(e1->copy_Expression(), e2->copy_Expression());"},{"Add":"}"},{"Add":""},{"Add":"void plus_class::dump(std::ostream &stream, int n) {"},{"Add":" stream << pad(n) << \"plus\\n\";"},{"Add":" e1->dump(stream, n + 2);"},{"Add":" e2->dump(stream, n + 2);"},{"Add":"}"},{"Add":""},{"Add":"Expression sub_class::copy_Expression() {"},{"Add":" return new sub_class(e1->copy_Expression(), e2->copy_Expression());"},{"Add":"}"},{"Add":""},{"Add":"void sub_class::dump(std::ostream &stream, int n) {"},{"Add":" stream << pad(n) << \"sub\\n\";"},{"Add":" e1->dump(stream, n + 2);"},{"Add":" e2->dump(stream, n + 2);"},{"Add":"}"},{"Add":""},{"Add":"Expression mul_class::copy_Expression() {"},{"Add":" return new mul_class(e1->copy_Expression(), e2->copy_Expression());"},{"Add":"}"},{"Add":""},{"Add":"void mul_class::dump(std::ostream &stream, int n) {"},{"Add":" stream << pad(n) << \"mul\\n\";"},{"Add":" e1->dump(stream, n + 2);"},{"Add":" e2->dump(stream, n + 2);"},{"Add":"}"},{"Add":""},{"Add":"Expression divide_class::copy_Expression() {"},{"Add":" return new divide_class(e1->copy_Expression(), e2->copy_Expression());"},{"Add":"}"},{"Add":""},{"Add":"void divide_class::dump(std::ostream &stream, int n) {"},{"Add":" stream << pad(n) << \"divide\\n\";"},{"Add":" e1->dump(stream, n + 2);"},{"Add":" e2->dump(stream, n + 2);"},{"Add":"}"},{"Add":""},{"Add":"Expression neg_class::copy_Expression() {"},{"Add":" return new neg_class(e1->copy_Expression());"},{"Add":"}"},{"Add":""},{"Add":"void neg_class::dump(std::ostream &stream, int n) {"},{"Add":" stream << pad(n) << \"neg\\n\";"},{"Add":" e1->dump(stream, n + 2);"},{"Add":"}"},{"Add":""},{"Add":"Expression lt_class::copy_Expression() {"},{"Add":" return new lt_class(e1->copy_Expression(), e2->copy_Expression());"},{"Add":"}"},{"Add":""},{"Add":"void lt_class::dump(std::ostream &stream, int n) {"},{"Add":" stream << pad(n) << \"lt\\n\";"},{"Add":" e1->dump(stream, n + 2);"},{"Add":" e2->dump(stream, n + 2);"},{"Add":"}"},{"Add":""},{"Add":"Expression eq_class::copy_Expression() {"},{"Add":" return new eq_class(e1->copy_Expression(), e2->copy_Expression());"},{"Add":"}"},{"Add":""},{"Add":"void eq_class::dump(std::ostream &stream, int n) {"},{"Add":" stream << pad(n) << \"eq\\n\";"},{"Add":" e1->dump(stream, n + 2);"},{"Add":" e2->dump(stream, n + 2);"},{"Add":"}"},{"Add":""},{"Add":"Expression leq_class::copy_Expression() {"},{"Add":" return new leq_class(e1->copy_Expression(), e2->copy_Expression());"},{"Add":"}"},{"Add":""},{"Add":"void leq_class::dump(std::ostream &stream, int n) {"},{"Add":" stream << pad(n) << \"leq\\n\";"},{"Add":" e1->dump(stream, n + 2);"},{"Add":" e2->dump(stream, n + 2);"},{"Add":"}"},{"Add":""},{"Add":"Expression comp_class::copy_Expression() {"},{"Add":" return new comp_class(e1->copy_Expression());"},{"Add":"}"},{"Add":""},{"Add":"void comp_class::dump(std::ostream &stream, int n) {"},{"Add":" stream << pad(n) << \"comp\\n\";"},{"Add":" e1->dump(stream, n + 2);"},{"Add":"}"},{"Add":""},{"Add":"Expression int_const_class::copy_Expression() {"},{"Add":" return new int_const_class(token);"},{"Add":"}"},{"Add":""},{"Add":"void int_const_class::dump(std::ostream &stream, int n) {"},{"Add":" stream << pad(n) << \"int_const\\n\";"},{"Add":" dump_Symbol(stream, n + 2, token);"},{"Add":"}"},{"Add":""},{"Add":"Expression bool_const_class::copy_Expression() {"},{"Add":" return new bool_const_class(val);"},{"Add":"}"},{"Add":""},{"Add":"void bool_const_class::dump(std::ostream &stream, int n) {"},{"Add":" stream << pad(n) << \"bool_const\\n\";"},{"Add":" dump_Boolean(stream, n + 2, val);"},{"Add":"}"},{"Add":""},{"Add":"Expression string_const_class::copy_Expression() {"},{"Add":" return new string_const_class(token);"},{"Add":"}"},{"Add":""},{"Add":"void string_const_class::dump(std::ostream &stream, int n) {"},{"Add":" stream << pad(n) << \"string_const\\n\";"},{"Add":" dump_Symbol(stream, n + 2, token);"},{"Add":"}"},{"Add":""},{"Add":"Expression new__class::copy_Expression() { return new new__class(type_name); }"},{"Add":""},{"Add":"void new__class::dump(std::ostream &stream, int n) {"},{"Add":" stream << pad(n) << \"new_\\n\";"},{"Add":" dump_Symbol(stream, n + 2, type_name);"},{"Add":"}"},{"Add":""},{"Add":"Expression isvoid_class::copy_Expression() {"},{"Add":" return new isvoid_class(e1->copy_Expression());"},{"Add":"}"},{"Add":""},{"Add":"void isvoid_class::dump(std::ostream &stream, int n) {"},{"Add":" stream << pad(n) << \"isvoid\\n\";"},{"Add":" e1->dump(stream, n + 2);"},{"Add":"}"},{"Add":""},{"Add":"Expression no_expr_class::copy_Expression() { return new no_expr_class(); }"},{"Add":""},{"Add":"void no_expr_class::dump(std::ostream &stream, int n) {"},{"Add":" stream << pad(n) << \"no_expr\\n\";"},{"Add":"}"},{"Add":""},{"Add":"Expression object_class::copy_Expression() { return new object_class(name); }"},{"Add":""},{"Add":"void object_class::dump(std::ostream &stream, int n) {"},{"Add":" stream << pad(n) << \"object\\n\";"},{"Add":" dump_Symbol(stream, n + 2, name);"},{"Add":"}"},{"Add":""},{"Add":"// interfaces used by Bison"},{"Add":"Classes nil_Classes() { return new nil_node(); }"},{"Add":""},{"Add":"Classes single_Classes(Class_ e) { return new single_list_node(e); }"},{"Add":""},{"Add":"Classes append_Classes(Classes p1, Classes p2) {"},{"Add":" return new append_node(p1, p2);"},{"Add":"}"},{"Add":""},{"Add":"Features nil_Features() { return new nil_node(); }"},{"Add":""},{"Add":"Features single_Features(Feature e) { return new single_list_node(e); }"},{"Add":""},{"Add":"Features append_Features(Features p1, Features p2) {"},{"Add":" return new append_node(p1, p2);"},{"Add":"}"},{"Add":""},{"Add":"Formals nil_Formals() { return new nil_node(); }"},{"Add":""},{"Add":"Formals single_Formals(Formal e) { return new single_list_node(e); }"},{"Add":""},{"Add":"Formals append_Formals(Formals p1, Formals p2) {"},{"Add":" return new append_node(p1, p2);"},{"Add":"}"},{"Add":""},{"Add":"Expressions nil_Expressions() { return new nil_node(); }"},{"Add":""},{"Add":"Expressions single_Expressions(Expression e) {"},{"Add":" return new single_list_node(e);"},{"Add":"}"},{"Add":""},{"Add":"Expressions append_Expressions(Expressions p1, Expressions p2) {"},{"Add":" return new append_node(p1, p2);"},{"Add":"}"},{"Add":""},{"Add":"Cases nil_Cases() { return new nil_node(); }"},{"Add":""},{"Add":"Cases single_Cases(Case e) { return new single_list_node(e); }"},{"Add":""},{"Add":"Cases append_Cases(Cases p1, Cases p2) { return new append_node(p1, p2); }"},{"Add":""},{"Add":"Program program(Classes classes) { return new program_class(classes); }"},{"Add":""},{"Add":"Class_ class_(Symbol name, Symbol parent, Features features, Symbol filename) {"},{"Add":" return new class__class(name, parent, features, filename);"},{"Add":"}"},{"Add":""},{"Add":"Feature method(Symbol name, Formals formals, Symbol return_type,"},{"Add":" Expression expr) {"},{"Add":" return new method_class(name, formals, return_type, expr);"},{"Add":"}"},{"Add":""},{"Add":"Feature attr(Symbol name, Symbol type_decl, Expression init) {"},{"Add":" return new attr_class(name, type_decl, init);"},{"Add":"}"},{"Add":""},{"Add":"Formal formal(Symbol name, Symbol type_decl) {"},{"Add":" return new formal_class(name, type_decl);"},{"Add":"}"},{"Add":""},{"Add":"Case branch(Symbol name, Symbol type_decl, Expression expr) {"},{"Add":" return new branch_class(name, type_decl, expr);"},{"Add":"}"},{"Add":""},{"Add":"Expression assign(Symbol name, Expression expr) {"},{"Add":" return new assign_class(name, expr);"},{"Add":"}"},{"Add":""},{"Add":"Expression static_dispatch(Expression expr, Symbol type_name, Symbol name,"},{"Add":" Expressions actual) {"},{"Add":" return new static_dispatch_class(expr, type_name, name, actual);"},{"Add":"}"},{"Add":""},{"Add":"Expression dispatch(Expression expr, Symbol name, Expressions actual) {"},{"Add":" return new dispatch_class(expr, name, actual);"},{"Add":"}"},{"Add":""},{"Add":"Expression cond(Expression pred, Expression then_exp, Expression else_exp) {"},{"Add":" return new cond_class(pred, then_exp, else_exp);"},{"Add":"}"},{"Add":""},{"Add":"Expression loop(Expression pred, Expression body) {"},{"Add":" return new loop_class(pred, body);"},{"Add":"}"},{"Add":""},{"Add":"Expression typcase(Expression expr, Cases cases) {"},{"Add":" return new typcase_class(expr, cases);"},{"Add":"}"},{"Add":""},{"Add":"Expression block(Expressions body) { return new block_class(body); }"},{"Add":""},{"Add":"Expression let(Symbol identifier, Symbol type_decl, Expression init,"},{"Add":" Expression body) {"},{"Add":" return new let_class(identifier, type_decl, init, body);"},{"Add":"}"},{"Add":""},{"Add":"Expression plus(Expression e1, Expression e2) { return new plus_class(e1, e2); }"},{"Add":""},{"Add":"Expression sub(Expression e1, Expression e2) { return new sub_class(e1, e2); }"},{"Add":""},{"Add":"Expression mul(Expression e1, Expression e2) { return new mul_class(e1, e2); }"},{"Add":""},{"Add":"Expression divide(Expression e1, Expression e2) {"},{"Add":" return new divide_class(e1, e2);"},{"Add":"}"},{"Add":""},{"Add":"Expression neg(Expression e1) { return new neg_class(e1); }"},{"Add":""},{"Add":"Expression lt(Expression e1, Expression e2) { return new lt_class(e1, e2); }"},{"Add":""},{"Add":"Expression eq(Expression e1, Expression e2) { return new eq_class(e1, e2); }"},{"Add":""},{"Add":"Expression leq(Expression e1, Expression e2) { return new leq_class(e1, e2); }"},{"Add":""},{"Add":"Expression comp(Expression e1) { return new comp_class(e1); }"},{"Add":""},{"Add":"Expression int_const(Symbol token) { return new int_const_class(token); }"},{"Add":""},{"Add":"Expression bool_const(bool val) { return new bool_const_class(val); }"},{"Add":""},{"Add":"Expression string_const(Symbol token) { return new string_const_class(token); }"},{"Add":""},{"Add":"Expression new_(Symbol type_name) { return new new__class(type_name); }"},{"Add":""},{"Add":"Expression isvoid(Expression e1) { return new isvoid_class(e1); }"},{"Add":""},{"Add":"Expression no_expr() { return new no_expr_class(); }"},{"Add":""},{"Add":"Expression object(Symbol name) { return new object_class(name); }"}]}},{"FileAdd":{"meta":{"basename":"cgen_main.cc","metadata":0},"context":[{"change":0,"pos":78394}],"contents":[{"Add":""},{"Add":"//"},{"Add":"// See copyright.h for copyright notice and limitation of liability"},{"Add":"// and disclaimer of warranty provisions."},{"Add":"//"},{"Add":"#include \"copyright.h\""},{"Add":""},{"Add":"#include \"cool_tree.h\""},{"Add":"#include "},{"Add":"#include "},{"Add":"#include "},{"Add":"#include "},{"Add":""},{"Add":"extern Program ast_root; // root of the abstract syntax tree"},{"Add":"FILE* ast_file = stdin; // we read the AST from standard input"},{"Add":"extern int ast_yyparse(void); // entry point to the AST parser"},{"Add":""},{"Add":"std::string out_filename; // file name for generated code"},{"Add":"int cgen_debug, curr_lineno; // for code gen"},{"Add":"extern char* optarg; // used for option processing (man 3 getopt for more info)"},{"Add":""},{"Add":"void handle_flags(int argc, char* argv[])"},{"Add":"{"},{"Add":" int c;"},{"Add":" int unknownopt = 0;"},{"Add":""},{"Add":" // no debugging or optimization by default"},{"Add":" cgen_debug = 0;"},{"Add":""},{"Add":" while ((c = getopt(argc, argv, \"do:\")) != -1) {"},{"Add":" switch (c) {"},{"Add":"#ifdef DEBUG"},{"Add":" case 'd':"},{"Add":" cgen_debug = 1;"},{"Add":" break;"},{"Add":"#else"},{"Add":" case 'd':"},{"Add":" std::cerr << \"No debugging available\\n\";"},{"Add":" break;"},{"Add":"#endif"},{"Add":" case 'o': // set the name of the output file"},{"Add":" out_filename = optarg;"},{"Add":" break;"},{"Add":" case '?':"},{"Add":" unknownopt = 1;"},{"Add":" break;"},{"Add":" case ':':"},{"Add":" unknownopt = 1;"},{"Add":" break;"},{"Add":" }"},{"Add":" }"},{"Add":""},{"Add":" if (unknownopt) {"},{"Add":" std::cerr << \"usage: \" << argv[0] <<"},{"Add":"#ifdef DEBUG"},{"Add":" \" [-d -o outname]\\n\";"},{"Add":"#else"},{"Add":" \" [-o outname]\\n\";"},{"Add":"#endif"},{"Add":" exit(1);"},{"Add":" }"},{"Add":"}"},{"Add":""},{"Add":"int main(int argc, char* argv[])"},{"Add":"{"},{"Add":" handle_flags(argc, argv);"},{"Add":" if (optind < argc) {"},{"Add":" ast_file = fopen(argv[optind], \"r\");"},{"Add":" if (!ast_file) {"},{"Add":" std::cerr << \"Cannot open input file \" << argv[optind] << std::endl;"},{"Add":" exit(1);"},{"Add":" }"},{"Add":" }"},{"Add":""},{"Add":" // Don't touch the output file until we know that earlier phases of the"},{"Add":" // compiler have succeeded."},{"Add":" ast_yyparse();"},{"Add":""},{"Add":" if (!out_filename.empty()) {"},{"Add":" ast_root->cgen(out_filename);"},{"Add":" }"},{"Add":" else {"},{"Add":" ast_root->cgen(std::nullopt);"},{"Add":" }"},{"Add":"}"}]}},{"FileAdd":{"meta":{"basename":"ast_parse.cc","metadata":0},"context":[{"change":0,"pos":78394}],"contents":[{"Add":""},{"Add":"/* A Bison parser, made from ast.y"},{"Add":" by GNU bison 1.35. */"},{"Add":""},{"Add":"#define YYBISON 1 /* Identify Bison output. */"},{"Add":""},{"Add":"#define yyparse ast_yyparse"},{"Add":"#define yylex ast_yylex"},{"Add":"#define yyerror ast_yyerror"},{"Add":"#define yylval ast_yylval"},{"Add":"#define yychar ast_yychar"},{"Add":"#define yydebug ast_yydebug"},{"Add":"#define yynerrs ast_yynerrs"},{"Add":"#define PROGRAM 257"},{"Add":"#define CLASS 258"},{"Add":"#define METHOD 259"},{"Add":"#define ATTR 260"},{"Add":"#define FORMAL 261"},{"Add":"#define BRANCH 262"},{"Add":"#define ASSIGN 263"},{"Add":"#define STATIC_DISPATCH 264"},{"Add":"#define DISPATCH 265"},{"Add":"#define COND 266"},{"Add":"#define LOOP 267"},{"Add":"#define TYPCASE 268"},{"Add":"#define BLOCK 269"},{"Add":"#define LET 270"},{"Add":"#define PLUS 271"},{"Add":"#define SUB 272"},{"Add":"#define MUL 273"},{"Add":"#define DIVIDE 274"},{"Add":"#define NEG 275"},{"Add":"#define LESSTHAN 276"},{"Add":"#define EQUAL 277"},{"Add":"#define LEQ 278"},{"Add":"#define COMP 279"},{"Add":"#define INT 280"},{"Add":"#define STR 281"},{"Add":"#define BOOL 282"},{"Add":"#define NEW 283"},{"Add":"#define ISVOID 284"},{"Add":"#define NO_EXPR 285"},{"Add":"#define OBJECT 286"},{"Add":"#define NO_TYPE 287"},{"Add":"#define STR_CONST 288"},{"Add":"#define INT_CONST 289"},{"Add":"#define IDENT 290"},{"Add":"#define LINENO 291"},{"Add":""},{"Add":"#line 6 \"ast.y\""},{"Add":""},{"Add":"#include \"cool_tree.h\""},{"Add":"#include \"stringtab.h\""},{"Add":"#include \"utils.h\""},{"Add":""},{"Add":"void ast_yyerror(char *);"},{"Add":"extern int curr_lineno;"},{"Add":"extern int yylex(); /* the entry point to the lexer */"},{"Add":"Program ast_root; /* the result of the parse */"},{"Add":"Classes parse_results; /* for use in parsing multiple files */"},{"Add":"int omerrs = 0; /* number of errors in lexing and parsing */"},{"Add":""},{"Add":"#line 21 \"ast.y\""},{"Add":"#ifndef YYSTYPE"},{"Add":"typedef union {"},{"Add":" int lineno;"},{"Add":" bool boolean;"},{"Add":" Symbol symbol;"},{"Add":" Program program;"},{"Add":" Class_ class_;"},{"Add":" Classes classes;"},{"Add":" Feature feature;"},{"Add":" Features features;"},{"Add":" Formal formal;"},{"Add":" Formals formals;"},{"Add":" Case case_;"},{"Add":" Cases cases;"},{"Add":" Expression expression;"},{"Add":" Expressions expressions;"},{"Add":"} yystype;"},{"Add":"#define YYSTYPE yystype"},{"Add":"#define YYSTYPE_IS_TRIVIAL 1"},{"Add":"#endif"},{"Add":"#ifndef YYDEBUG"},{"Add":"#define YYDEBUG 1"},{"Add":"#endif"},{"Add":""},{"Add":"#define YYFINAL 121"},{"Add":"#define YYFLAG -32768"},{"Add":"#define YYNTBASE 41"},{"Add":""},{"Add":"/* YYTRANSLATE(YYLEX) -- Bison token number corresponding to YYLEX. */"},{"Add":"#define YYTRANSLATE(x) ((unsigned)(x) <= 291 ? yytranslate[x] : 56)"},{"Add":""},{"Add":"/* YYTRANSLATE[YYLEX] -- Bison token number corresponding to YYLEX. */"},{"Add":"static const char yytranslate[] = {"},{"Add":" 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,"},{"Add":" 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,"},{"Add":" 2, 2, 38, 39, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,"},{"Add":" 2, 40, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,"},{"Add":" 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,"},{"Add":" 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,"},{"Add":" 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,"},{"Add":" 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,"},{"Add":" 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,"},{"Add":" 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,"},{"Add":" 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,"},{"Add":" 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,"},{"Add":" 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,"},{"Add":" 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 3, 4, 5, 6, 7, 8, 9, 10, 11,"},{"Add":" 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,"},{"Add":" 31, 32, 33, 34, 35, 36, 37};"},{"Add":""},{"Add":"#if YYDEBUG"},{"Add":"static const short yyprhs[] = {"},{"Add":" 0, 0, 4, 5, 7, 10, 19, 20, 22, 24, 27, 34, 40,"},{"Add":" 41, 43, 45, 48, 53, 57, 61, 66, 73, 79, 85, 90, 94,"},{"Add":" 101, 106, 110, 114, 119, 124, 129, 134, 138, 143, 148, 153, 157,"},{"Add":" 161, 165, 169, 173, 176, 179, 183, 185, 188, 190, 193};"},{"Add":"static const short yyrhs[] = {"},{"Add":" 37, 3, 42, 0, 0, 43, 0, 42, 43, 0, 37, 4, 36, 36, 34, 38, 44, 39, 0,"},{"Add":" 0, 45, 0, 46, 0, 45, 46, 0, 37, 5, 36, 47, 36, 50, 0, 37, 6, 36, 36,"},{"Add":" 50, 0, 0, 48, 0, 49, 0, 48, 49, 0, 37, 7, 36, 36, 0, 51, 40, 36, 0,"},{"Add":" 51, 40, 33, 0, 37, 9, 36, 50, 0, 37, 10, 50, 36, 36, 52, 0, 37, 11, 50,"},{"Add":" 36, 52, 0, 37, 12, 50, 50, 50, 0, 37, 13, 50, 50, 0, 37, 15, 53, 0, 37,"},{"Add":" 16, 36, 36, 50, 50, 0, 37, 14, 50, 54, 0, 37, 29, 36, 0, 37, 30, 50, 0,"},{"Add":" 37, 17, 50, 50, 0, 37, 18, 50, 50, 0, 37, 19, 50, 50, 0, 37, 20, 50, 50,"},{"Add":" 0, 37, 21, 50, 0, 37, 22, 50, 50, 0, 37, 23, 50, 50, 0, 37, 24, 50, 50,"},{"Add":" 0, 37, 25, 50, 0, 37, 26, 35, 0, 37, 27, 34, 0, 37, 28, 35, 0, 37, 32,"},{"Add":" 36, 0, 37, 31, 0, 38, 39, 0, 38, 53, 39, 0, 50, 0, 53, 50, 0, 55, 0,"},{"Add":" 54, 55, 0, 37, 8, 36, 36, 50, 0};"},{"Add":""},{"Add":"#endif"},{"Add":""},{"Add":"#if YYDEBUG"},{"Add":"/* YYRLINE[YYN] -- source line where rule number YYN was defined. */"},{"Add":"static const short yyrline[] = {"},{"Add":" 0, 68, 70, 75, 78, 83, 89, 91, 96, 98, 102, 104, 108,"},{"Add":" 110, 115, 117, 121, 125, 129, 132, 135, 138, 141, 144, 147, 150,"},{"Add":" 153, 156, 159, 162, 165, 168, 171, 174, 177, 180, 183, 186, 189,"},{"Add":" 192, 195, 203, 206, 210, 212, 217, 219, 224, 226, 231};"},{"Add":"#endif"},{"Add":""},{"Add":"#if (YYDEBUG) || defined YYERROR_VERBOSE"},{"Add":""},{"Add":"/* YYTNAME[TOKEN_NUM] -- String name of the token TOKEN_NUM. */"},{"Add":"static const char *const yytname[] = {\"$\","},{"Add":" \"error\","},{"Add":" \"$undefined.\","},{"Add":" \"PROGRAM\","},{"Add":" \"CLASS\","},{"Add":" \"METHOD\","},{"Add":" \"ATTR\","},{"Add":" \"FORMAL\","},{"Add":" \"BRANCH\","},{"Add":" \"ASSIGN\","},{"Add":" \"STATIC_DISPATCH\","},{"Add":" \"DISPATCH\","},{"Add":" \"COND\","},{"Add":" \"LOOP\","},{"Add":" \"TYPCASE\","},{"Add":" \"BLOCK\","},{"Add":" \"LET\","},{"Add":" \"PLUS\","},{"Add":" \"SUB\","},{"Add":" \"MUL\","},{"Add":" \"DIVIDE\","},{"Add":" \"NEG\","},{"Add":" \"LESSTHAN\","},{"Add":" \"EQUAL\","},{"Add":" \"LEQ\","},{"Add":" \"COMP\","},{"Add":" \"INT\","},{"Add":" \"STR\","},{"Add":" \"BOOL\","},{"Add":" \"NEW\","},{"Add":" \"ISVOID\","},{"Add":" \"NO_EXPR\","},{"Add":" \"OBJECT\","},{"Add":" \"NO_TYPE\","},{"Add":" \"STR_CONST\","},{"Add":" \"INT_CONST\","},{"Add":" \"IDENT\","},{"Add":" \"LINENO\","},{"Add":" \"'('\","},{"Add":" \"')'\","},{"Add":" \"':'\","},{"Add":" \"program\","},{"Add":" \"class_list\","},{"Add":" \"class\","},{"Add":" \"optional_feature_list\","},{"Add":" \"feature_list\","},{"Add":" \"feature\","},{"Add":" \"formals\","},{"Add":" \"formal_list\","},{"Add":" \"formal\","},{"Add":" \"expr\","},{"Add":" \"expr_aux\","},{"Add":" \"actuals\","},{"Add":" \"expr_list\","},{"Add":" \"case_list\","},{"Add":" \"simple_case\","},{"Add":" 0};"},{"Add":"#endif"},{"Add":""},{"Add":"/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */"},{"Add":"static const short yyr1[] = {0, 41, 41, 42, 42, 43, 44, 44, 45, 45, 46, 46, 47,"},{"Add":" 47, 48, 48, 49, 50, 50, 51, 51, 51, 51, 51, 51, 51,"},{"Add":" 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51,"},{"Add":" 51, 51, 51, 51, 52, 52, 53, 53, 54, 54, 55};"},{"Add":""},{"Add":"/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */"},{"Add":"static const short yyr2[] = {0, 3, 0, 1, 2, 8, 0, 1, 1, 2, 6, 5, 0, 1, 1, 2, 4,"},{"Add":" 3, 3, 4, 6, 5, 5, 4, 3, 6, 4, 3, 3, 4, 4, 4, 4, 3,"},{"Add":" 4, 4, 4, 3, 3, 3, 3, 3, 2, 2, 3, 1, 2, 1, 2, 5};"},{"Add":""},{"Add":"/* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE"},{"Add":" doesn't specify something else to do. Zero means the default is an"},{"Add":" error. */"},{"Add":"static const short yydefact[] = {"},{"Add":" 2, 0, 0, 0, 1, 3, 0, 4, 0, 0, 0, 6, 0, 0, 7, 8, 0, 0,"},{"Add":" 5, 9, 12, 0, 0, 0, 13, 14, 0, 0, 0, 15, 0, 11, 0, 0, 10, 0,"},{"Add":" 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,"},{"Add":" 0, 0, 0, 42, 0, 0, 16, 0, 0, 0, 0, 0, 0, 45, 24, 0, 0, 0,"},{"Add":" 0, 0, 33, 0, 0, 0, 37, 38, 39, 40, 27, 28, 41, 18, 17, 19, 0, 0,"},{"Add":" 0, 23, 0, 26, 47, 46, 0, 29, 30, 31, 32, 34, 35, 36, 0, 0, 21, 22,"},{"Add":" 0, 48, 0, 20, 43, 0, 0, 25, 44, 0, 49, 0, 0, 0};"},{"Add":""},{"Add":"static const short yydefgoto[] = {119, 4, 5, 13, 14, 15, 23, 24,"},{"Add":" 25, 67, 32, 106, 68, 93, 94};"},{"Add":""},{"Add":"static const short yypact[] = {"},{"Add":" -30, 6, -11, 23, -11, -32768, -8, -32768, -7,"},{"Add":" -3, -6, -4, 10, -5, -4, -32768, 0, 1,"},{"Add":" -32768, -32768, 3, 5, 36, 12, 3, -32768, 15,"},{"Add":" 17, 15, -32768, 83, -32768, 14, 19, -32768, 20,"},{"Add":" 15, 15, 15, 15, 15, 15, 21, 15, 15,"},{"Add":" 15, 15, 15, 15, 15, 15, 15, 24, 26,"},{"Add":" 27, 22, 15, -32768, 25, -32, -32768, 15, 29,"},{"Add":" 30, 15, 15, 31, -32768, 15, 33, 15, 15,"},{"Add":" 15, 15, -32768, 15, 15, 15, -32768, -32768, -32768,"},{"Add":" -32768, -32768, -32768, -32768, -32768, -32768, -32768, 35, 34,"},{"Add":" 15, -32768, 55, 31, -32768, -32768, 15, -32768, -32768,"},{"Add":" -32768, -32768, -32768, -32768, -32768, 34, -34, -32768, -32768,"},{"Add":" 37, -32768, 15, -32768, -32768, -31, 38, -32768, -32768,"},{"Add":" 15, -32768, 67, 75, -32768};"},{"Add":""},{"Add":"static const short yypgoto[] = {-32768, -32768, 72, -32768, -32768,"},{"Add":" 63, -32768, -32768, 54, -26,"},{"Add":" -32768, -25, -24, -32768, -13};"},{"Add":""},{"Add":"#define YYLAST 115"},{"Add":""},{"Add":"static const short yytable[] = {"},{"Add":" 31, 85, 34, 30, 86, 112, 30, 1, 116, 2, 62, 63, 64, 65, 66,"},{"Add":" 16, 17, 70, 71, 72, 73, 74, 75, 76, 77, 78, 3, 6, 8, 9,"},{"Add":" 83, 10, 11, 12, 18, 87, 20, 21, 90, 91, 22, 26, 95, 27, 97,"},{"Add":" 98, 99, 100, 28, 101, 102, 103, 30, 33, 59, 60, 61, 69, 82, 79,"},{"Add":" 80, 84, 81, 108, 107, 88, 89, 120, 92, 96, 110, 104, 105, 114, 117,"},{"Add":" 121, 7, 19, 29, 111, 109, 113, 0, 0, 115, 0, 0, 95, 0, 0,"},{"Add":" 0, 118, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,"},{"Add":" 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58};"},{"Add":""},{"Add":"static const short yycheck[] = {"},{"Add":" 26, 33, 28, 37, 36, 39, 37, 37, 39, 3, 36, 37, 38, 39, 40, 5, 6,"},{"Add":" 43, 44, 45, 46, 47, 48, 49, 50, 51, 37, 4, 36, 36, 56, 34, 38, 37,"},{"Add":" 39, 61, 36, 36, 64, 65, 37, 36, 68, 7, 70, 71, 72, 73, 36, 75, 76,"},{"Add":" 77, 37, 36, 40, 36, 36, 36, 36, 35, 34, 36, 35, 8, 90, 36, 36, 0,"},{"Add":" 37, 36, 96, 36, 38, 36, 36, 0, 4, 14, 24, 104, 93, 105, -1, -1, 110,"},{"Add":" -1, -1, 113, -1, -1, -1, 117, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,"},{"Add":" 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32};"},{"Add":"/* -*-C-*- Note some compilers choke on comments on `#line' lines. */"},{"Add":"#line 3 \"/usr/share/bison/bison.simple\""},{"Add":""},{"Add":"/* Skeleton output parser for bison,"},{"Add":""},{"Add":" Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software"},{"Add":" Foundation, Inc."},{"Add":""},{"Add":" This program is free software; you can redistribute it and/or modify"},{"Add":" it under the terms of the GNU General Public License as published by"},{"Add":" the Free Software Foundation; either version 2, or (at your option)"},{"Add":" any later version."},{"Add":""},{"Add":" This program is distributed in the hope that it will be useful,"},{"Add":" but WITHOUT ANY WARRANTY; without even the implied warranty of"},{"Add":" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the"},{"Add":" GNU General Public License for more details."},{"Add":""},{"Add":" You should have received a copy of the GNU General Public License"},{"Add":" along with this program; if not, write to the Free Software"},{"Add":" Foundation, Inc., 59 Temple Place - Suite 330,"},{"Add":" Boston, MA 02111-1307, USA. */"},{"Add":""},{"Add":"/* As a special exception, when this file is copied by Bison into a"},{"Add":" Bison output file, you may use that output file without restriction."},{"Add":" This special exception was added by the Free Software Foundation"},{"Add":" in version 1.24 of Bison. */"},{"Add":""},{"Add":"/* This is the parser code that is written into each bison parser when"},{"Add":" the %semantic_parser declaration is not specified in the grammar."},{"Add":" It was written by Richard Stallman by simplifying the hairy parser"},{"Add":" used when %semantic_parser is specified. */"},{"Add":""},{"Add":"/* All symbols defined below should begin with yy or YY, to avoid"},{"Add":" infringing on user name space. This should be done even for local"},{"Add":" variables, as they might otherwise be expanded by user macros."},{"Add":" There are some unavoidable exceptions within include files to"},{"Add":" define necessary library symbols; they are noted \"INFRINGES ON"},{"Add":" USER NAME SPACE\" below. */"},{"Add":""},{"Add":"#if !defined(yyoverflow) || defined(YYERROR_VERBOSE)"},{"Add":""},{"Add":"/* The parser invokes alloca or malloc; define the necessary symbols. */"},{"Add":""},{"Add":"#if YYSTACK_USE_ALLOCA"},{"Add":"#define YYSTACK_ALLOC alloca"},{"Add":"#else"},{"Add":"#ifndef YYSTACK_USE_ALLOCA"},{"Add":"#if defined(alloca) || defined(_ALLOCA_H)"},{"Add":"#define YYSTACK_ALLOC alloca"},{"Add":"#else"},{"Add":"#ifdef __GNUC__"},{"Add":"#define YYSTACK_ALLOC __builtin_alloca"},{"Add":"#endif"},{"Add":"#endif"},{"Add":"#endif"},{"Add":"#endif"},{"Add":""},{"Add":"#ifdef YYSTACK_ALLOC"},{"Add":"/* Pacify GCC's `empty if-body' warning. */"},{"Add":"#define YYSTACK_FREE(Ptr) \\"},{"Add":" do { /* empty */ \\"},{"Add":" ; \\"},{"Add":" } while (0)"},{"Add":"#else"},{"Add":"#if defined(__STDC__) || defined(__cplusplus)"},{"Add":"#include /* INFRINGES ON USER NAME SPACE */"},{"Add":"#define YYSIZE_T size_t"},{"Add":"#endif"},{"Add":"#define YYSTACK_ALLOC malloc"},{"Add":"#define YYSTACK_FREE free"},{"Add":"#endif"},{"Add":"#endif /* ! defined (yyoverflow) || defined (YYERROR_VERBOSE) */"},{"Add":""},{"Add":"#if (!defined(yyoverflow) && \\"},{"Add":" (!defined(__cplusplus) || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))"},{"Add":""},{"Add":"/* A type that is properly aligned for any stack member. */"},{"Add":"union yyalloc {"},{"Add":" short yyss;"},{"Add":" YYSTYPE yyvs;"},{"Add":"#if YYLSP_NEEDED"},{"Add":" YYLTYPE yyls;"},{"Add":"#endif"},{"Add":"};"},{"Add":""},{"Add":"/* The size of the maximum gap between one aligned stack and the next. */"},{"Add":"#define YYSTACK_GAP_MAX (sizeof(union yyalloc) - 1)"},{"Add":""},{"Add":"/* The size of an array large to enough to hold all stacks, each with"},{"Add":" N elements. */"},{"Add":"#if YYLSP_NEEDED"},{"Add":"#define YYSTACK_BYTES(N) \\"},{"Add":" ((N) * (sizeof(short) + sizeof(YYSTYPE) + sizeof(YYLTYPE)) + \\"},{"Add":" 2 * YYSTACK_GAP_MAX)"},{"Add":"#else"},{"Add":"#define YYSTACK_BYTES(N) \\"},{"Add":" ((N) * (sizeof(short) + sizeof(YYSTYPE)) + YYSTACK_GAP_MAX)"},{"Add":"#endif"},{"Add":""},{"Add":"/* Copy COUNT objects from FROM to TO. The source and destination do"},{"Add":" not overlap. */"},{"Add":"#ifndef YYCOPY"},{"Add":"#if 1 < __GNUC__"},{"Add":"#define YYCOPY(To, From, Count) \\"},{"Add":" __builtin_memcpy(To, From, (Count) * sizeof(*(From)))"},{"Add":"#else"},{"Add":"#define YYCOPY(To, From, Count) \\"},{"Add":" do { \\"},{"Add":" register YYSIZE_T yyi; \\"},{"Add":" for (yyi = 0; yyi < (Count); yyi++) \\"},{"Add":" (To)[yyi] = (From)[yyi]; \\"},{"Add":" } while (0)"},{"Add":"#endif"},{"Add":"#endif"},{"Add":""},{"Add":"/* Relocate STACK from its old location to the new one. The"},{"Add":" local variables YYSIZE and YYSTACKSIZE give the old and new number of"},{"Add":" elements in the stack, and YYPTR gives the new location of the"},{"Add":" stack. Advance YYPTR to a properly aligned location for the next"},{"Add":" stack. */"},{"Add":"#define YYSTACK_RELOCATE(Stack) \\"},{"Add":" do { \\"},{"Add":" YYSIZE_T yynewbytes; \\"},{"Add":" YYCOPY(&yyptr->Stack, Stack, yysize); \\"},{"Add":" Stack = &yyptr->Stack; \\"},{"Add":" yynewbytes = yystacksize * sizeof(*Stack) + YYSTACK_GAP_MAX; \\"},{"Add":" yyptr += yynewbytes / sizeof(*yyptr); \\"},{"Add":" } while (0)"},{"Add":""},{"Add":"#endif"},{"Add":""},{"Add":"#if !defined(YYSIZE_T) && defined(__SIZE_TYPE__)"},{"Add":"#define YYSIZE_T __SIZE_TYPE__"},{"Add":"#endif"},{"Add":"#if !defined(YYSIZE_T) && defined(size_t)"},{"Add":"#define YYSIZE_T size_t"},{"Add":"#endif"},{"Add":"#if !defined(YYSIZE_T)"},{"Add":"#if defined(__STDC__) || defined(__cplusplus)"},{"Add":"#include /* INFRINGES ON USER NAME SPACE */"},{"Add":"#define YYSIZE_T size_t"},{"Add":"#endif"},{"Add":"#endif"},{"Add":"#if !defined(YYSIZE_T)"},{"Add":"#define YYSIZE_T unsigned int"},{"Add":"#endif"},{"Add":""},{"Add":"#define yyerrok (yyerrstatus = 0)"},{"Add":"#define yyclearin (yychar = YYEMPTY)"},{"Add":"#define YYEMPTY -2"},{"Add":"#define YYEOF 0"},{"Add":"#define YYACCEPT goto yyacceptlab"},{"Add":"#define YYABORT goto yyabortlab"},{"Add":"#define YYERROR goto yyerrlab1"},{"Add":"/* Like YYERROR except do call yyerror. This remains here temporarily"},{"Add":" to ease the transition to the new meaning of YYERROR, for GCC."},{"Add":" Once GCC version 2 has supplanted version 1, this can go. */"},{"Add":"#define YYFAIL goto yyerrlab"},{"Add":"#define YYRECOVERING() (!!yyerrstatus)"},{"Add":"#define YYBACKUP(Token, Value) \\"},{"Add":" do \\"},{"Add":" if (yychar == YYEMPTY && yylen == 1) { \\"},{"Add":" yychar = (Token); \\"},{"Add":" yylval = (Value); \\"},{"Add":" yychar1 = YYTRANSLATE(yychar); \\"},{"Add":" YYPOPSTACK; \\"},{"Add":" goto yybackup; \\"},{"Add":" } else { \\"},{"Add":" yyerror(\"syntax error: cannot back up\"); \\"},{"Add":" YYERROR; \\"},{"Add":" } \\"},{"Add":" while (0)"},{"Add":""},{"Add":"#define YYTERROR 1"},{"Add":"#define YYERRCODE 256"},{"Add":""},{"Add":"/* YYLLOC_DEFAULT -- Compute the default location (before the actions"},{"Add":" are run)."},{"Add":""},{"Add":" When YYLLOC_DEFAULT is run, CURRENT is set the location of the"},{"Add":" first token. By default, to implement support for ranges, extend"},{"Add":" its range to the last symbol. */"},{"Add":""},{"Add":"#ifndef YYLLOC_DEFAULT"},{"Add":"#define YYLLOC_DEFAULT(Current, Rhs, N) \\"},{"Add":" Current.last_line = Rhs[N].last_line; \\"},{"Add":" Current.last_column = Rhs[N].last_column;"},{"Add":"#endif"},{"Add":""},{"Add":"/* YYLEX -- calling `yylex' with the right arguments. */"},{"Add":""},{"Add":"#if YYPURE"},{"Add":"#if YYLSP_NEEDED"},{"Add":"#ifdef YYLEX_PARAM"},{"Add":"#define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM)"},{"Add":"#else"},{"Add":"#define YYLEX yylex(&yylval, &yylloc)"},{"Add":"#endif"},{"Add":"#else /* !YYLSP_NEEDED */"},{"Add":"#ifdef YYLEX_PARAM"},{"Add":"#define YYLEX yylex(&yylval, YYLEX_PARAM)"},{"Add":"#else"},{"Add":"#define YYLEX yylex(&yylval)"},{"Add":"#endif"},{"Add":"#endif /* !YYLSP_NEEDED */"},{"Add":"#else /* !YYPURE */"},{"Add":"#define YYLEX yylex()"},{"Add":"#endif /* !YYPURE */"},{"Add":""},{"Add":"/* Enable debugging if requested. */"},{"Add":"#if YYDEBUG"},{"Add":""},{"Add":"#ifndef YYFPRINTF"},{"Add":"#include /* INFRINGES ON USER NAME SPACE */"},{"Add":"#define YYFPRINTF fprintf"},{"Add":"#endif"},{"Add":""},{"Add":"#define YYDPRINTF(Args) \\"},{"Add":" do { \\"},{"Add":" if (yydebug) \\"},{"Add":" YYFPRINTF Args; \\"},{"Add":" } while (0)"},{"Add":"/* Nonzero means print parse trace. It is left uninitialized so that"},{"Add":" multiple parsers can coexist. */"},{"Add":"int yydebug;"},{"Add":"#else /* !YYDEBUG */"},{"Add":"#define YYDPRINTF(Args)"},{"Add":"#endif /* !YYDEBUG */"},{"Add":""},{"Add":"/* YYINITDEPTH -- initial size of the parser's stacks. */"},{"Add":"#ifndef YYINITDEPTH"},{"Add":"#define YYINITDEPTH 200"},{"Add":"#endif"},{"Add":""},{"Add":"/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only"},{"Add":" if the built-in stack extension method is used)."},{"Add":""},{"Add":" Do not make this value too large; the results are undefined if"},{"Add":" SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)"},{"Add":" evaluated with infinite-precision integer arithmetic. */"},{"Add":""},{"Add":"#if YYMAXDEPTH == 0"},{"Add":"#undef YYMAXDEPTH"},{"Add":"#endif"},{"Add":""},{"Add":"#ifndef YYMAXDEPTH"},{"Add":"#define YYMAXDEPTH 10000"},{"Add":"#endif"},{"Add":""},{"Add":"#ifdef YYERROR_VERBOSE"},{"Add":""},{"Add":"#ifndef yystrlen"},{"Add":"#if defined(__GLIBC__) && defined(_STRING_H)"},{"Add":"#define yystrlen strlen"},{"Add":"#else"},{"Add":"/* Return the length of YYSTR. */"},{"Add":"static YYSIZE_T"},{"Add":"#if defined(__STDC__) || defined(__cplusplus)"},{"Add":"yystrlen(const char *yystr)"},{"Add":"#else"},{"Add":" yystrlen(yystr) const char *yystr;"},{"Add":"#endif"},{"Add":"{"},{"Add":" register const char *yys = yystr;"},{"Add":""},{"Add":" while (*yys++ != '\\0')"},{"Add":" continue;"},{"Add":""},{"Add":" return yys - yystr - 1;"},{"Add":"}"},{"Add":"#endif"},{"Add":"#endif"},{"Add":""},{"Add":"#ifndef yystpcpy"},{"Add":"#if defined(__GLIBC__) && defined(_STRING_H) && defined(_GNU_SOURCE)"},{"Add":"#define yystpcpy stpcpy"},{"Add":"#else"},{"Add":"/* Copy YYSRC to YYDEST, returning the address of the terminating '\\0' in"},{"Add":" YYDEST. */"},{"Add":"static char *"},{"Add":"#if defined(__STDC__) || defined(__cplusplus)"},{"Add":"yystpcpy(char *yydest, const char *yysrc)"},{"Add":"#else"},{"Add":" yystpcpy(yydest, yysrc) char *yydest;"},{"Add":"const char *yysrc;"},{"Add":"#endif"},{"Add":"{"},{"Add":" register char *yyd = yydest;"},{"Add":" register const char *yys = yysrc;"},{"Add":""},{"Add":" while ((*yyd++ = *yys++) != '\\0')"},{"Add":" continue;"},{"Add":""},{"Add":" return yyd - 1;"},{"Add":"}"},{"Add":"#endif"},{"Add":"#endif"},{"Add":"#endif"},{"Add":""},{"Add":"#line 315 \"/usr/share/bison/bison.simple\""},{"Add":""},{"Add":"/* The user can define YYPARSE_PARAM as the name of an argument to be passed"},{"Add":" into yyparse. The argument should have type void *."},{"Add":" It should actually point to an object."},{"Add":" Grammar actions can access the variable by casting it"},{"Add":" to the proper pointer type. */"},{"Add":""},{"Add":"#ifdef YYPARSE_PARAM"},{"Add":"#if defined(__STDC__) || defined(__cplusplus)"},{"Add":"#define YYPARSE_PARAM_ARG void *YYPARSE_PARAM"},{"Add":"#define YYPARSE_PARAM_DECL"},{"Add":"#else"},{"Add":"#define YYPARSE_PARAM_ARG YYPARSE_PARAM"},{"Add":"#define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;"},{"Add":"#endif"},{"Add":"#else /* !YYPARSE_PARAM */"},{"Add":"#define YYPARSE_PARAM_ARG"},{"Add":"#define YYPARSE_PARAM_DECL"},{"Add":"#endif /* !YYPARSE_PARAM */"},{"Add":""},{"Add":"/* Prevent warning if -Wstrict-prototypes. */"},{"Add":"#ifdef __GNUC__"},{"Add":"#ifdef YYPARSE_PARAM"},{"Add":"int yyparse(void *);"},{"Add":"#else"},{"Add":"int yyparse(void);"},{"Add":"#endif"},{"Add":"#endif"},{"Add":""},{"Add":"/* YY_DECL_VARIABLES -- depending whether we use a pure parser,"},{"Add":" variables are global, or local to YYPARSE. */"},{"Add":""},{"Add":"#define YY_DECL_NON_LSP_VARIABLES \\"},{"Add":" /* The lookahead symbol. */ \\"},{"Add":" int yychar; \\"},{"Add":" \\"},{"Add":" /* The semantic value of the lookahead symbol. */ \\"},{"Add":" YYSTYPE yylval; \\"},{"Add":" \\"},{"Add":" /* Number of parse errors so far. */ \\"},{"Add":" int yynerrs;"},{"Add":""},{"Add":"#if YYLSP_NEEDED"},{"Add":"#define YY_DECL_VARIABLES \\"},{"Add":" YY_DECL_NON_LSP_VARIABLES \\"},{"Add":" \\"},{"Add":" /* Location data for the lookahead symbol. */ \\"},{"Add":" YYLTYPE yylloc;"},{"Add":"#else"},{"Add":"#define YY_DECL_VARIABLES YY_DECL_NON_LSP_VARIABLES"},{"Add":"#endif"},{"Add":""},{"Add":"/* If nonreentrant, generate the variables here. */"},{"Add":""},{"Add":"#if !YYPURE"},{"Add":"YY_DECL_VARIABLES"},{"Add":"#endif /* !YYPURE */"},{"Add":""},{"Add":"int yyparse(YYPARSE_PARAM_ARG) YYPARSE_PARAM_DECL {"},{"Add":" /* If reentrant, generate the variables here. */"},{"Add":"#if YYPURE"},{"Add":" YY_DECL_VARIABLES"},{"Add":"#endif /* !YYPURE */"},{"Add":""},{"Add":" register int yystate;"},{"Add":" register int yyn;"},{"Add":" int yyresult;"},{"Add":" /* Number of tokens to shift before error messages enabled. */"},{"Add":" int yyerrstatus;"},{"Add":" /* Lookahead token as an internal (translated) token number. */"},{"Add":" int yychar1 = 0;"},{"Add":""},{"Add":" /* Three stacks and their tools:"},{"Add":" `yyss': related to states,"},{"Add":" `yyvs': related to semantic values,"},{"Add":" `yyls': related to locations."},{"Add":""},{"Add":" Refer to the stacks thru separate pointers, to allow yyoverflow"},{"Add":" to reallocate them elsewhere. */"},{"Add":""},{"Add":" /* The state stack. */"},{"Add":" short yyssa[YYINITDEPTH];"},{"Add":" short *yyss = yyssa;"},{"Add":" register short *yyssp;"},{"Add":""},{"Add":" /* The semantic value stack. */"},{"Add":" YYSTYPE yyvsa[YYINITDEPTH];"},{"Add":" YYSTYPE *yyvs = yyvsa;"},{"Add":" register YYSTYPE *yyvsp;"},{"Add":""},{"Add":"#if YYLSP_NEEDED"},{"Add":" /* The location stack. */"},{"Add":" YYLTYPE yylsa[YYINITDEPTH];"},{"Add":" YYLTYPE *yyls = yylsa;"},{"Add":" YYLTYPE *yylsp;"},{"Add":"#endif"},{"Add":""},{"Add":"#if YYLSP_NEEDED"},{"Add":"#define YYPOPSTACK (yyvsp--, yyssp--, yylsp--)"},{"Add":"#else"},{"Add":"#define YYPOPSTACK (yyvsp--, yyssp--)"},{"Add":"#endif"},{"Add":""},{"Add":" YYSIZE_T yystacksize = YYINITDEPTH;"},{"Add":""},{"Add":" /* The variables used to return semantic value and location from the"},{"Add":" action routines. */"},{"Add":" YYSTYPE yyval;"},{"Add":"#if YYLSP_NEEDED"},{"Add":" YYLTYPE yyloc;"},{"Add":"#endif"},{"Add":""},{"Add":" /* When reducing, the number of symbols on the RHS of the reduced"},{"Add":" rule. */"},{"Add":" int yylen;"},{"Add":""},{"Add":" YYDPRINTF((stderr, \"Starting parse\\n\"));"},{"Add":""},{"Add":" yystate = 0;"},{"Add":" yyerrstatus = 0;"},{"Add":" yynerrs = 0;"},{"Add":" yychar = YYEMPTY; /* Cause a token to be read. */"},{"Add":""},{"Add":" /* Initialize stack pointers."},{"Add":" Waste one element of value and location stack"},{"Add":" so that they stay on the same level as the state stack."},{"Add":" The wasted elements are never initialized. */"},{"Add":""},{"Add":" yyssp = yyss;"},{"Add":" yyvsp = yyvs;"},{"Add":"#if YYLSP_NEEDED"},{"Add":" yylsp = yyls;"},{"Add":"#endif"},{"Add":" goto yysetstate;"},{"Add":""},{"Add":" /*------------------------------------------------------------."},{"Add":" | yynewstate -- Push a new state, which is found in yystate. |"},{"Add":" `------------------------------------------------------------*/"},{"Add":"yynewstate:"},{"Add":" /* In all cases, when you get here, the value and location stacks"},{"Add":" have just been pushed. so pushing a state here evens the stacks."},{"Add":" */"},{"Add":" yyssp++;"},{"Add":""},{"Add":"yysetstate:"},{"Add":" *yyssp = yystate;"},{"Add":""},{"Add":" if (yyssp >= yyss + yystacksize - 1) {"},{"Add":" /* Get the current used size of the three stacks, in elements. */"},{"Add":" YYSIZE_T yysize = yyssp - yyss + 1;"},{"Add":""},{"Add":"#ifdef yyoverflow"},{"Add":" {"},{"Add":" /* Give user a chance to reallocate the stack. Use copies of"},{"Add":" these so that the &'s don't force the real ones into"},{"Add":" memory. */"},{"Add":" YYSTYPE *yyvs1 = yyvs;"},{"Add":" short *yyss1 = yyss;"},{"Add":""},{"Add":" /* Each stack pointer address is followed by the size of the"},{"Add":" data in use in that stack, in bytes. */"},{"Add":"#if YYLSP_NEEDED"},{"Add":" YYLTYPE *yyls1 = yyls;"},{"Add":" /* This used to be a conditional around just the two extra args,"},{"Add":" but that might be undefined if yyoverflow is a macro. */"},{"Add":" yyoverflow(\"parser stack overflow\", &yyss1, yysize * sizeof(*yyssp),"},{"Add":" &yyvs1, yysize * sizeof(*yyvsp), &yyls1,"},{"Add":" yysize * sizeof(*yylsp), &yystacksize);"},{"Add":" yyls = yyls1;"},{"Add":"#else"},{"Add":" yyoverflow(\"parser stack overflow\", &yyss1, yysize * sizeof(*yyssp),"},{"Add":" &yyvs1, yysize * sizeof(*yyvsp), &yystacksize);"},{"Add":"#endif"},{"Add":" yyss = yyss1;"},{"Add":" yyvs = yyvs1;"},{"Add":" }"},{"Add":"#else /* no yyoverflow */"},{"Add":"#ifndef YYSTACK_RELOCATE"},{"Add":" goto yyoverflowlab;"},{"Add":"#else"},{"Add":" /* Extend the stack our own way. */"},{"Add":" if (yystacksize >= YYMAXDEPTH)"},{"Add":" goto yyoverflowlab;"},{"Add":" yystacksize *= 2;"},{"Add":" if (yystacksize > YYMAXDEPTH)"},{"Add":" yystacksize = YYMAXDEPTH;"},{"Add":""},{"Add":" {"},{"Add":" short *yyss1 = yyss;"},{"Add":" union yyalloc *yyptr ="},{"Add":" (union yyalloc *)YYSTACK_ALLOC(YYSTACK_BYTES(yystacksize));"},{"Add":" if (!yyptr)"},{"Add":" goto yyoverflowlab;"},{"Add":" YYSTACK_RELOCATE(yyss);"},{"Add":" YYSTACK_RELOCATE(yyvs);"},{"Add":"#if YYLSP_NEEDED"},{"Add":" YYSTACK_RELOCATE(yyls);"},{"Add":"#endif"},{"Add":"#undef YYSTACK_RELOCATE"},{"Add":" if (yyss1 != yyssa)"},{"Add":" YYSTACK_FREE(yyss1);"},{"Add":" }"},{"Add":"#endif"},{"Add":"#endif /* no yyoverflow */"},{"Add":""},{"Add":" yyssp = yyss + yysize - 1;"},{"Add":" yyvsp = yyvs + yysize - 1;"},{"Add":"#if YYLSP_NEEDED"},{"Add":" yylsp = yyls + yysize - 1;"},{"Add":"#endif"},{"Add":""},{"Add":" YYDPRINTF((stderr, \"Stack size increased to %lu\\n\","},{"Add":" (unsigned long int)yystacksize));"},{"Add":""},{"Add":" if (yyssp >= yyss + yystacksize - 1)"},{"Add":" YYABORT;"},{"Add":" }"},{"Add":""},{"Add":" YYDPRINTF((stderr, \"Entering state %d\\n\", yystate));"},{"Add":""},{"Add":" goto yybackup;"},{"Add":""},{"Add":"/*-----------."},{"Add":"| yybackup. |"},{"Add":"`-----------*/"},{"Add":"yybackup:"},{"Add":""},{"Add":" /* Do appropriate processing given the current state. */"},{"Add":" /* Read a lookahead token if we need one and don't already have one. */"},{"Add":" /* yyresume: */"},{"Add":""},{"Add":" /* First try to decide what to do without reference to lookahead token. */"},{"Add":""},{"Add":" yyn = yypact[yystate];"},{"Add":" if (yyn == YYFLAG)"},{"Add":" goto yydefault;"},{"Add":""},{"Add":" /* Not known => get a lookahead token if don't already have one. */"},{"Add":""},{"Add":" /* yychar is either YYEMPTY or YYEOF"},{"Add":" or a valid token in external form. */"},{"Add":""},{"Add":" if (yychar == YYEMPTY) {"},{"Add":" YYDPRINTF((stderr, \"Reading a token: \"));"},{"Add":" yychar = YYLEX;"},{"Add":" }"},{"Add":""},{"Add":" /* Convert token to internal form (in yychar1) for indexing tables with */"},{"Add":""},{"Add":" if (yychar <= 0) /* This means end of input. */"},{"Add":" {"},{"Add":" yychar1 = 0;"},{"Add":" yychar = YYEOF; /* Don't call YYLEX any more */"},{"Add":""},{"Add":" YYDPRINTF((stderr, \"Now at end of input.\\n\"));"},{"Add":" } else {"},{"Add":" yychar1 = YYTRANSLATE(yychar);"},{"Add":""},{"Add":"#if YYDEBUG"},{"Add":" /* We have to keep this `#if YYDEBUG', since we use variables"},{"Add":" which are defined only if `YYDEBUG' is set. */"},{"Add":" if (yydebug) {"},{"Add":" YYFPRINTF(stderr, \"Next token is %d (%s\", yychar, yytname[yychar1]);"},{"Add":" /* Give the individual parser a way to print the precise"},{"Add":" meaning of a token, for further debugging info. */"},{"Add":"#ifdef YYPRINT"},{"Add":" YYPRINT(stderr, yychar, yylval);"},{"Add":"#endif"},{"Add":" YYFPRINTF(stderr, \")\\n\");"},{"Add":" }"},{"Add":"#endif"},{"Add":" }"},{"Add":""},{"Add":" yyn += yychar1;"},{"Add":" if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)"},{"Add":" goto yydefault;"},{"Add":""},{"Add":" yyn = yytable[yyn];"},{"Add":""},{"Add":" /* yyn is what to do for this token type in this state."},{"Add":" Negative => reduce, -yyn is rule number."},{"Add":" Positive => shift, yyn is new state."},{"Add":" New state is final state => don't bother to shift,"},{"Add":" just return success."},{"Add":" 0, or most negative number => error. */"},{"Add":""},{"Add":" if (yyn < 0) {"},{"Add":" if (yyn == YYFLAG)"},{"Add":" goto yyerrlab;"},{"Add":" yyn = -yyn;"},{"Add":" goto yyreduce;"},{"Add":" } else if (yyn == 0)"},{"Add":" goto yyerrlab;"},{"Add":""},{"Add":" if (yyn == YYFINAL)"},{"Add":" YYACCEPT;"},{"Add":""},{"Add":" /* Shift the lookahead token. */"},{"Add":" YYDPRINTF((stderr, \"Shifting token %d (%s), \", yychar, yytname[yychar1]));"},{"Add":""},{"Add":" /* Discard the token being shifted unless it is eof. */"},{"Add":" if (yychar != YYEOF)"},{"Add":" yychar = YYEMPTY;"},{"Add":""},{"Add":" *++yyvsp = yylval;"},{"Add":"#if YYLSP_NEEDED"},{"Add":" *++yylsp = yylloc;"},{"Add":"#endif"},{"Add":""},{"Add":" /* Count tokens shifted since error; after three, turn off error"},{"Add":" status. */"},{"Add":" if (yyerrstatus)"},{"Add":" yyerrstatus--;"},{"Add":""},{"Add":" yystate = yyn;"},{"Add":" goto yynewstate;"},{"Add":""},{"Add":"/*-----------------------------------------------------------."},{"Add":"| yydefault -- do the default action for the current state. |"},{"Add":"`-----------------------------------------------------------*/"},{"Add":"yydefault:"},{"Add":" yyn = yydefact[yystate];"},{"Add":" if (yyn == 0)"},{"Add":" goto yyerrlab;"},{"Add":" goto yyreduce;"},{"Add":""},{"Add":"/*-----------------------------."},{"Add":"| yyreduce -- Do a reduction. |"},{"Add":"`-----------------------------*/"},{"Add":"yyreduce:"},{"Add":" /* yyn is the number of a rule to reduce with. */"},{"Add":" yylen = yyr2[yyn];"},{"Add":""},{"Add":" /* If YYLEN is nonzero, implement the default value of the action:"},{"Add":" `$$ = $1'."},{"Add":""},{"Add":" Otherwise, the following line sets YYVAL to the semantic value of"},{"Add":" the lookahead token. This behavior is undocumented and Bison"},{"Add":" users should not rely upon it. Assigning to YYVAL"},{"Add":" unconditionally makes the parser a bit smaller, and it avoids a"},{"Add":" GCC warning that YYVAL may be used uninitialized. */"},{"Add":" yyval = yyvsp[1 - yylen];"},{"Add":""},{"Add":"#if YYLSP_NEEDED"},{"Add":" /* Similarly for the default location. Let the user run additional"},{"Add":" commands if for instance locations are ranges. */"},{"Add":" yyloc = yylsp[1 - yylen];"},{"Add":" YYLLOC_DEFAULT(yyloc, (yylsp - yylen), yylen);"},{"Add":"#endif"},{"Add":""},{"Add":"#if YYDEBUG"},{"Add":" /* We have to keep this `#if YYDEBUG', since we use variables which"},{"Add":" are defined only if `YYDEBUG' is set. */"},{"Add":" if (yydebug) {"},{"Add":" int yyi;"},{"Add":""},{"Add":" YYFPRINTF(stderr, \"Reducing via rule %d (line %d), \", yyn, yyrline[yyn]);"},{"Add":""},{"Add":" /* Print the symbols being reduced, and their result. */"},{"Add":" for (yyi = yyprhs[yyn]; yyrhs[yyi] > 0; yyi++)"},{"Add":" YYFPRINTF(stderr, \"%s \", yytname[yyrhs[yyi]]);"},{"Add":" YYFPRINTF(stderr, \" -> %s\\n\", yytname[yyr1[yyn]]);"},{"Add":" }"},{"Add":"#endif"},{"Add":""},{"Add":" switch (yyn) {"},{"Add":""},{"Add":" case 1:"},{"Add":"#line 69 \"ast.y\""},{"Add":" {"},{"Add":" curr_lineno = yyvsp[-2].lineno;"},{"Add":" ast_root = program(yyvsp[0].classes);"},{"Add":" } break;"},{"Add":" case 2:"},{"Add":"#line 71 \"ast.y\""},{"Add":" {"},{"Add":" exit(1);"},{"Add":" } break;"},{"Add":" case 3:"},{"Add":"#line 76 \"ast.y\""},{"Add":" {"},{"Add":" yyval.classes = single_Classes(yyvsp[0].class_);"},{"Add":" parse_results = yyval.classes;"},{"Add":" } break;"},{"Add":" case 4:"},{"Add":"#line 79 \"ast.y\""},{"Add":" {"},{"Add":" yyval.classes ="},{"Add":" append_Classes(yyvsp[-1].classes, single_Classes(yyvsp[0].class_));"},{"Add":" parse_results = yyval.classes;"},{"Add":" } break;"},{"Add":" case 5:"},{"Add":"#line 84 \"ast.y\""},{"Add":" {"},{"Add":" curr_lineno = yyvsp[-7].lineno;"},{"Add":" yyval.class_ = class_(yyvsp[-5].symbol, yyvsp[-4].symbol,"},{"Add":" yyvsp[-1].features, yyvsp[-3].symbol);"},{"Add":" } break;"},{"Add":" case 6:"},{"Add":"#line 90 \"ast.y\""},{"Add":" {"},{"Add":" yyval.features = nil_Features();"},{"Add":" } break;"},{"Add":" case 7:"},{"Add":"#line 92 \"ast.y\""},{"Add":" {"},{"Add":" yyval.features = yyvsp[0].features;"},{"Add":" } break;"},{"Add":" case 8:"},{"Add":"#line 97 \"ast.y\""},{"Add":" {"},{"Add":" yyval.features = single_Features(yyvsp[0].feature);"},{"Add":" } break;"},{"Add":" case 9:"},{"Add":"#line 99 \"ast.y\""},{"Add":" {"},{"Add":" yyval.features ="},{"Add":" append_Features(yyvsp[-1].features, single_Features(yyvsp[0].feature));"},{"Add":" } break;"},{"Add":" case 10:"},{"Add":"#line 103 \"ast.y\""},{"Add":" {"},{"Add":" curr_lineno = yyvsp[-5].lineno;"},{"Add":" yyval.feature = method(yyvsp[-3].symbol, yyvsp[-2].formals,"},{"Add":" yyvsp[-1].symbol, yyvsp[0].expression);"},{"Add":" } break;"},{"Add":" case 11:"},{"Add":"#line 105 \"ast.y\""},{"Add":" {"},{"Add":" curr_lineno = yyvsp[-4].lineno;"},{"Add":" yyval.feature ="},{"Add":" attr(yyvsp[-2].symbol, yyvsp[-1].symbol, yyvsp[0].expression);"},{"Add":" } break;"},{"Add":" case 12:"},{"Add":"#line 109 \"ast.y\""},{"Add":" {"},{"Add":" yyval.formals = nil_Formals();"},{"Add":" } break;"},{"Add":" case 13:"},{"Add":"#line 111 \"ast.y\""},{"Add":" {"},{"Add":" yyval.formals = yyvsp[0].formals;"},{"Add":" } break;"},{"Add":" case 14:"},{"Add":"#line 116 \"ast.y\""},{"Add":" {"},{"Add":" yyval.formals = single_Formals(yyvsp[0].formal);"},{"Add":" } break;"},{"Add":" case 15:"},{"Add":"#line 118 \"ast.y\""},{"Add":" {"},{"Add":" yyval.formals ="},{"Add":" append_Formals(yyvsp[-1].formals, single_Formals(yyvsp[0].formal));"},{"Add":" } break;"},{"Add":" case 16:"},{"Add":"#line 122 \"ast.y\""},{"Add":" {"},{"Add":" curr_lineno = yyvsp[-3].lineno;"},{"Add":" yyval.formal = formal(yyvsp[-1].symbol, yyvsp[0].symbol);"},{"Add":" } break;"},{"Add":" case 17:"},{"Add":"#line 126 \"ast.y\""},{"Add":" {"},{"Add":" yyval.expression = yyvsp[-2].expression;"},{"Add":" yyval.expression->set_type(yyvsp[0].symbol);"},{"Add":" } break;"},{"Add":" case 18:"},{"Add":"#line 130 \"ast.y\""},{"Add":" {"},{"Add":" yyval.expression = yyvsp[-2].expression;"},{"Add":" } break;"},{"Add":" case 19:"},{"Add":"#line 133 \"ast.y\""},{"Add":" {"},{"Add":" curr_lineno = yyvsp[-3].lineno;"},{"Add":" yyval.expression = assign(yyvsp[-1].symbol, yyvsp[0].expression);"},{"Add":" } break;"},{"Add":" case 20:"},{"Add":"#line 136 \"ast.y\""},{"Add":" {"},{"Add":" curr_lineno = yyvsp[-5].lineno;"},{"Add":" yyval.expression = static_dispatch(yyvsp[-3].expression, yyvsp[-2].symbol,"},{"Add":" yyvsp[-1].symbol, yyvsp[0].expressions);"},{"Add":" } break;"},{"Add":" case 21:"},{"Add":"#line 139 \"ast.y\""},{"Add":" {"},{"Add":" curr_lineno = yyvsp[-4].lineno;"},{"Add":" yyval.expression ="},{"Add":" dispatch(yyvsp[-2].expression, yyvsp[-1].symbol, yyvsp[0].expressions);"},{"Add":" } break;"},{"Add":" case 22:"},{"Add":"#line 142 \"ast.y\""},{"Add":" {"},{"Add":" curr_lineno = yyvsp[-4].lineno;"},{"Add":" yyval.expression ="},{"Add":" cond(yyvsp[-2].expression, yyvsp[-1].expression, yyvsp[0].expression);"},{"Add":" } break;"},{"Add":" case 23:"},{"Add":"#line 145 \"ast.y\""},{"Add":" {"},{"Add":" curr_lineno = yyvsp[-3].lineno;"},{"Add":" yyval.expression = loop(yyvsp[-1].expression, yyvsp[0].expression);"},{"Add":" } break;"},{"Add":" case 24:"},{"Add":"#line 148 \"ast.y\""},{"Add":" {"},{"Add":" curr_lineno = yyvsp[-2].lineno;"},{"Add":" yyval.expression = block(yyvsp[0].expressions);"},{"Add":" } break;"},{"Add":" case 25:"},{"Add":"#line 151 \"ast.y\""},{"Add":" {"},{"Add":" curr_lineno = yyvsp[-5].lineno;"},{"Add":" yyval.expression = let(yyvsp[-3].symbol, yyvsp[-2].symbol,"},{"Add":" yyvsp[-1].expression, yyvsp[0].expression);"},{"Add":" } break;"},{"Add":" case 26:"},{"Add":"#line 154 \"ast.y\""},{"Add":" {"},{"Add":" curr_lineno = yyvsp[-3].lineno;"},{"Add":" yyval.expression = typcase(yyvsp[-1].expression, yyvsp[0].cases);"},{"Add":" } break;"},{"Add":" case 27:"},{"Add":"#line 157 \"ast.y\""},{"Add":" {"},{"Add":" curr_lineno = yyvsp[-2].lineno;"},{"Add":" yyval.expression = new_(yyvsp[0].symbol);"},{"Add":" } break;"},{"Add":" case 28:"},{"Add":"#line 160 \"ast.y\""},{"Add":" {"},{"Add":" curr_lineno = yyvsp[-2].lineno;"},{"Add":" yyval.expression = isvoid(yyvsp[0].expression);"},{"Add":" } break;"},{"Add":" case 29:"},{"Add":"#line 163 \"ast.y\""},{"Add":" {"},{"Add":" curr_lineno = yyvsp[-3].lineno;"},{"Add":" yyval.expression = plus(yyvsp[-1].expression, yyvsp[0].expression);"},{"Add":" } break;"},{"Add":" case 30:"},{"Add":"#line 166 \"ast.y\""},{"Add":" {"},{"Add":" curr_lineno = yyvsp[-3].lineno;"},{"Add":" yyval.expression = sub(yyvsp[-1].expression, yyvsp[0].expression);"},{"Add":" } break;"},{"Add":" case 31:"},{"Add":"#line 169 \"ast.y\""},{"Add":" {"},{"Add":" curr_lineno = yyvsp[-3].lineno;"},{"Add":" yyval.expression = mul(yyvsp[-1].expression, yyvsp[0].expression);"},{"Add":" } break;"},{"Add":" case 32:"},{"Add":"#line 172 \"ast.y\""},{"Add":" {"},{"Add":" curr_lineno = yyvsp[-3].lineno;"},{"Add":" yyval.expression = divide(yyvsp[-1].expression, yyvsp[0].expression);"},{"Add":" } break;"},{"Add":" case 33:"},{"Add":"#line 175 \"ast.y\""},{"Add":" {"},{"Add":" curr_lineno = yyvsp[-2].lineno;"},{"Add":" yyval.expression = neg(yyvsp[0].expression);"},{"Add":" } break;"},{"Add":" case 34:"},{"Add":"#line 178 \"ast.y\""},{"Add":" {"},{"Add":" curr_lineno = yyvsp[-3].lineno;"},{"Add":" yyval.expression = lt(yyvsp[-1].expression, yyvsp[0].expression);"},{"Add":" } break;"},{"Add":" case 35:"},{"Add":"#line 181 \"ast.y\""},{"Add":" {"},{"Add":" curr_lineno = yyvsp[-3].lineno;"},{"Add":" yyval.expression = eq(yyvsp[-1].expression, yyvsp[0].expression);"},{"Add":" } break;"},{"Add":" case 36:"},{"Add":"#line 184 \"ast.y\""},{"Add":" {"},{"Add":" curr_lineno = yyvsp[-3].lineno;"},{"Add":" yyval.expression = leq(yyvsp[-1].expression, yyvsp[0].expression);"},{"Add":" } break;"},{"Add":" case 37:"},{"Add":"#line 187 \"ast.y\""},{"Add":" {"},{"Add":" curr_lineno = yyvsp[-2].lineno;"},{"Add":" yyval.expression = comp(yyvsp[0].expression);"},{"Add":" } break;"},{"Add":" case 38:"},{"Add":"#line 190 \"ast.y\""},{"Add":" {"},{"Add":" curr_lineno = yyvsp[-2].lineno;"},{"Add":" yyval.expression = int_const(yyvsp[0].symbol);"},{"Add":" } break;"},{"Add":" case 39:"},{"Add":"#line 193 \"ast.y\""},{"Add":" {"},{"Add":" curr_lineno = yyvsp[-2].lineno;"},{"Add":" yyval.expression = string_const(yyvsp[0].symbol);"},{"Add":" } break;"},{"Add":" case 40:"},{"Add":"#line 196 \"ast.y\""},{"Add":" {"},{"Add":" curr_lineno = yyvsp[-2].lineno;"},{"Add":" if (yyvsp[0].symbol->get_string() == \"1\")"},{"Add":" yyval.expression = bool_const(1);"},{"Add":" else"},{"Add":" yyval.expression = bool_const(0);"},{"Add":" } break;"},{"Add":" case 41:"},{"Add":"#line 204 \"ast.y\""},{"Add":" {"},{"Add":" curr_lineno = yyvsp[-2].lineno;"},{"Add":" yyval.expression = object(yyvsp[0].symbol);"},{"Add":" } break;"},{"Add":" case 42:"},{"Add":"#line 207 \"ast.y\""},{"Add":" {"},{"Add":" curr_lineno = yyvsp[-1].lineno;"},{"Add":" yyval.expression = no_expr();"},{"Add":" } break;"},{"Add":" case 43:"},{"Add":"#line 211 \"ast.y\""},{"Add":" {"},{"Add":" yyval.expressions = nil_Expressions();"},{"Add":" } break;"},{"Add":" case 44:"},{"Add":"#line 213 \"ast.y\""},{"Add":" {"},{"Add":" yyval.expressions = yyvsp[-1].expressions;"},{"Add":" } break;"},{"Add":" case 45:"},{"Add":"#line 218 \"ast.y\""},{"Add":" {"},{"Add":" yyval.expressions = single_Expressions(yyvsp[0].expression);"},{"Add":" } break;"},{"Add":" case 46:"},{"Add":"#line 220 \"ast.y\""},{"Add":" {"},{"Add":" yyval.expressions = append_Expressions("},{"Add":" yyvsp[-1].expressions, single_Expressions(yyvsp[0].expression));"},{"Add":" } break;"},{"Add":" case 47:"},{"Add":"#line 225 \"ast.y\""},{"Add":" {"},{"Add":" yyval.cases = single_Cases(yyvsp[0].case_);"},{"Add":" } break;"},{"Add":" case 48:"},{"Add":"#line 227 \"ast.y\""},{"Add":" {"},{"Add":" yyval.cases = append_Cases(yyvsp[-1].cases, single_Cases(yyvsp[0].case_));"},{"Add":" } break;"},{"Add":" case 49:"},{"Add":"#line 232 \"ast.y\""},{"Add":" {"},{"Add":" curr_lineno = yyvsp[-4].lineno;"},{"Add":" yyval.case_ ="},{"Add":" branch(yyvsp[-2].symbol, yyvsp[-1].symbol, yyvsp[0].expression);"},{"Add":" } break;"},{"Add":" }"},{"Add":""},{"Add":"#line 705 \"/usr/share/bison/bison.simple\""},{"Add":""},{"Add":" yyvsp -= yylen;"},{"Add":" yyssp -= yylen;"},{"Add":"#if YYLSP_NEEDED"},{"Add":" yylsp -= yylen;"},{"Add":"#endif"},{"Add":""},{"Add":"#if YYDEBUG"},{"Add":" if (yydebug) {"},{"Add":" short *yyssp1 = yyss - 1;"},{"Add":" YYFPRINTF(stderr, \"state stack now\");"},{"Add":" while (yyssp1 != yyssp)"},{"Add":" YYFPRINTF(stderr, \" %d\", *++yyssp1);"},{"Add":" YYFPRINTF(stderr, \"\\n\");"},{"Add":" }"},{"Add":"#endif"},{"Add":""},{"Add":" *++yyvsp = yyval;"},{"Add":"#if YYLSP_NEEDED"},{"Add":" *++yylsp = yyloc;"},{"Add":"#endif"},{"Add":""},{"Add":" /* Now `shift' the result of the reduction. Determine what state"},{"Add":" that goes to, based on the state we popped back to and the rule"},{"Add":" number reduced by. */"},{"Add":""},{"Add":" yyn = yyr1[yyn];"},{"Add":""},{"Add":" yystate = yypgoto[yyn - YYNTBASE] + *yyssp;"},{"Add":" if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)"},{"Add":" yystate = yytable[yystate];"},{"Add":" else"},{"Add":" yystate = yydefgoto[yyn - YYNTBASE];"},{"Add":""},{"Add":" goto yynewstate;"},{"Add":""},{"Add":"/*------------------------------------."},{"Add":"| yyerrlab -- here on detecting error |"},{"Add":"`------------------------------------*/"},{"Add":"yyerrlab:"},{"Add":" /* If not already recovering from an error, report this error. */"},{"Add":" if (!yyerrstatus) {"},{"Add":" ++yynerrs;"},{"Add":""},{"Add":"#ifdef YYERROR_VERBOSE"},{"Add":" yyn = yypact[yystate];"},{"Add":""},{"Add":" if (yyn > YYFLAG && yyn < YYLAST) {"},{"Add":" YYSIZE_T yysize = 0;"},{"Add":" char *yymsg;"},{"Add":" int yyx, yycount;"},{"Add":""},{"Add":" yycount = 0;"},{"Add":" /* Start YYX at -YYN if negative to avoid negative indexes in"},{"Add":" YYCHECK. */"},{"Add":" for (yyx = yyn < 0 ? -yyn : 0;"},{"Add":" yyx < (int)(sizeof(yytname) / sizeof(char *)); yyx++)"},{"Add":" if (yycheck[yyx + yyn] == yyx)"},{"Add":" yysize += yystrlen(yytname[yyx]) + 15, yycount++;"},{"Add":" yysize += yystrlen(\"parse error, unexpected \") + 1;"},{"Add":" yysize += yystrlen(yytname[YYTRANSLATE(yychar)]);"},{"Add":" yymsg = (char *)YYSTACK_ALLOC(yysize);"},{"Add":" if (yymsg != 0) {"},{"Add":" char *yyp = yystpcpy(yymsg, \"parse error, unexpected \");"},{"Add":" yyp = yystpcpy(yyp, yytname[YYTRANSLATE(yychar)]);"},{"Add":""},{"Add":" if (yycount < 5) {"},{"Add":" yycount = 0;"},{"Add":" for (yyx = yyn < 0 ? -yyn : 0;"},{"Add":" yyx < (int)(sizeof(yytname) / sizeof(char *)); yyx++)"},{"Add":" if (yycheck[yyx + yyn] == yyx) {"},{"Add":" const char *yyq = !yycount ? \", expecting \" : \" or \";"},{"Add":" yyp = yystpcpy(yyp, yyq);"},{"Add":" yyp = yystpcpy(yyp, yytname[yyx]);"},{"Add":" yycount++;"},{"Add":" }"},{"Add":" }"},{"Add":" yyerror(yymsg);"},{"Add":" YYSTACK_FREE(yymsg);"},{"Add":" } else"},{"Add":" yyerror(\"parse error; also virtual memory exhausted\");"},{"Add":" } else"},{"Add":"#endif /* defined (YYERROR_VERBOSE) */"},{"Add":" yyerror(\"parse error\");"},{"Add":" }"},{"Add":" goto yyerrlab1;"},{"Add":""},{"Add":"/*--------------------------------------------------."},{"Add":"| yyerrlab1 -- error raised explicitly by an action |"},{"Add":"`--------------------------------------------------*/"},{"Add":"yyerrlab1:"},{"Add":" if (yyerrstatus == 3) {"},{"Add":" /* If just tried and failed to reuse lookahead token after an"},{"Add":" error, discard it. */"},{"Add":""},{"Add":" /* return failure if at end of input */"},{"Add":" if (yychar == YYEOF)"},{"Add":" YYABORT;"},{"Add":" YYDPRINTF("},{"Add":" (stderr, \"Discarding token %d (%s).\\n\", yychar, yytname[yychar1]));"},{"Add":" yychar = YYEMPTY;"},{"Add":" }"},{"Add":""},{"Add":" /* Else will try to reuse lookahead token after shifting the error"},{"Add":" token. */"},{"Add":""},{"Add":" yyerrstatus = 3; /* Each real token shifted decrements this */"},{"Add":""},{"Add":" goto yyerrhandle;"},{"Add":""},{"Add":"/*-------------------------------------------------------------------."},{"Add":"| yyerrdefault -- current state does not do anything special for the |"},{"Add":"| error token. |"},{"Add":"`-------------------------------------------------------------------*/"},{"Add":"yyerrdefault:"},{"Add":"#if 0"},{"Add":" /* This is wrong; only states that explicitly want error tokens"},{"Add":" should shift them. */"},{"Add":""},{"Add":" /* If its default is to accept any token, ok. Otherwise pop it. */"},{"Add":" yyn = yydefact[yystate];"},{"Add":" if (yyn)"},{"Add":" goto yydefault;"},{"Add":"#endif"},{"Add":""},{"Add":"/*---------------------------------------------------------------."},{"Add":"| yyerrpop -- pop the current state because it cannot handle the |"},{"Add":"| error token |"},{"Add":"`---------------------------------------------------------------*/"},{"Add":"yyerrpop:"},{"Add":" if (yyssp == yyss)"},{"Add":" YYABORT;"},{"Add":" yyvsp--;"},{"Add":" yystate = *--yyssp;"},{"Add":"#if YYLSP_NEEDED"},{"Add":" yylsp--;"},{"Add":"#endif"},{"Add":""},{"Add":"#if YYDEBUG"},{"Add":" if (yydebug) {"},{"Add":" short *yyssp1 = yyss - 1;"},{"Add":" YYFPRINTF(stderr, \"Error: state stack now\");"},{"Add":" while (yyssp1 != yyssp)"},{"Add":" YYFPRINTF(stderr, \" %d\", *++yyssp1);"},{"Add":" YYFPRINTF(stderr, \"\\n\");"},{"Add":" }"},{"Add":"#endif"},{"Add":""},{"Add":"/*--------------."},{"Add":"| yyerrhandle. |"},{"Add":"`--------------*/"},{"Add":"yyerrhandle:"},{"Add":" yyn = yypact[yystate];"},{"Add":" if (yyn == YYFLAG)"},{"Add":" goto yyerrdefault;"},{"Add":""},{"Add":" yyn += YYTERROR;"},{"Add":" if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)"},{"Add":" goto yyerrdefault;"},{"Add":""},{"Add":" yyn = yytable[yyn];"},{"Add":" if (yyn < 0) {"},{"Add":" if (yyn == YYFLAG)"},{"Add":" goto yyerrpop;"},{"Add":" yyn = -yyn;"},{"Add":" goto yyreduce;"},{"Add":" } else if (yyn == 0)"},{"Add":" goto yyerrpop;"},{"Add":""},{"Add":" if (yyn == YYFINAL)"},{"Add":" YYACCEPT;"},{"Add":""},{"Add":" YYDPRINTF((stderr, \"Shifting error token, \"));"},{"Add":""},{"Add":" *++yyvsp = yylval;"},{"Add":"#if YYLSP_NEEDED"},{"Add":" *++yylsp = yylloc;"},{"Add":"#endif"},{"Add":""},{"Add":" yystate = yyn;"},{"Add":" goto yynewstate;"},{"Add":""},{"Add":"/*-------------------------------------."},{"Add":"| yyacceptlab -- YYACCEPT comes here. |"},{"Add":"`-------------------------------------*/"},{"Add":"yyacceptlab:"},{"Add":" yyresult = 0;"},{"Add":" goto yyreturn;"},{"Add":""},{"Add":"/*-----------------------------------."},{"Add":"| yyabortlab -- YYABORT comes here. |"},{"Add":"`-----------------------------------*/"},{"Add":"yyabortlab:"},{"Add":" yyresult = 1;"},{"Add":" goto yyreturn;"},{"Add":""},{"Add":"/*---------------------------------------------."},{"Add":"| yyoverflowab -- parser overflow comes here. |"},{"Add":"`---------------------------------------------*/"},{"Add":"yyoverflowlab:"},{"Add":" yyerror(\"parser stack overflow\");"},{"Add":" yyresult = 2;"},{"Add":" /* Fall through. */"},{"Add":""},{"Add":"yyreturn:"},{"Add":"#ifndef yyoverflow"},{"Add":" if (yyss != yyssa)"},{"Add":" YYSTACK_FREE(yyss);"},{"Add":"#endif"},{"Add":" return yyresult;"},{"Add":"}"},{"Add":"#line 237 \"ast.y\""},{"Add":""},{"Add":"void ast_yyerror(char *) {"},{"Add":" std::cerr << \"??? unexpected error in ast parsing.\" << std::endl;"},{"Add":" exit(1);"},{"Add":"}"}]}},{"FileAdd":{"meta":{"basename":"ast_lex.cc","metadata":0},"context":[{"change":0,"pos":78394}],"contents":[{"Add":""},{"Add":"#line 2 \"ast-lex.cc\""},{"Add":"/* A lexical scanner generated by flex */"},{"Add":""},{"Add":"/* Scanner skeleton version:"},{"Add":" * $Header:"},{"Add":" * /home/vadve/Teaching/CVSClassRepository/CS426-Current/MPSolutions/mp2-text/cool-support/src/ast-lex.cc,v"},{"Add":" * 1.1 2011-09-29 13:07:27 bmmoore Exp $"},{"Add":" */"},{"Add":""},{"Add":"#define FLEX_SCANNER"},{"Add":"#define YY_FLEX_MAJOR_VERSION 2"},{"Add":"#define YY_FLEX_MINOR_VERSION 5"},{"Add":""},{"Add":"#include "},{"Add":"#include "},{"Add":""},{"Add":"/* cfront 1.2 defines \"c_plusplus\" instead of \"__cplusplus\" */"},{"Add":"#ifdef c_plusplus"},{"Add":"#ifndef __cplusplus"},{"Add":"#define __cplusplus"},{"Add":"#endif"},{"Add":"#endif"},{"Add":""},{"Add":"#ifdef __cplusplus"},{"Add":""},{"Add":"#include "},{"Add":""},{"Add":"/* Use prototypes in function declarations. */"},{"Add":"#define YY_USE_PROTOS"},{"Add":""},{"Add":"/* The \"const\" storage-class-modifier is valid. */"},{"Add":"#define YY_USE_CONST"},{"Add":""},{"Add":"#else /* ! __cplusplus */"},{"Add":""},{"Add":"#if __STDC__"},{"Add":""},{"Add":"#define YY_USE_PROTOS"},{"Add":"#define YY_USE_CONST"},{"Add":""},{"Add":"#endif /* __STDC__ */"},{"Add":"#endif /* ! __cplusplus */"},{"Add":""},{"Add":"#ifdef __TURBOC__"},{"Add":"#pragma warn - rch"},{"Add":"#pragma warn - use"},{"Add":"#include "},{"Add":"#include "},{"Add":"#define YY_USE_CONST"},{"Add":"#define YY_USE_PROTOS"},{"Add":"#endif"},{"Add":""},{"Add":"#ifdef YY_USE_CONST"},{"Add":"#define yyconst const"},{"Add":"#else"},{"Add":"#define yyconst"},{"Add":"#endif"},{"Add":""},{"Add":"#ifdef YY_USE_PROTOS"},{"Add":"#define YY_PROTO(proto) proto"},{"Add":"#else"},{"Add":"#define YY_PROTO(proto) ()"},{"Add":"#endif"},{"Add":""},{"Add":"/* Returned upon end-of-file. */"},{"Add":"#define YY_NULL 0"},{"Add":""},{"Add":"/* Promotes a possibly negative, possibly signed char to an unsigned"},{"Add":" * integer for use as an array index. If the signed char is negative,"},{"Add":" * we want to instead treat it as an 8-bit unsigned char, hence the"},{"Add":" * double cast."},{"Add":" */"},{"Add":"#define YY_SC_TO_UI(c) ((unsigned int)(unsigned char)c)"},{"Add":""},{"Add":"/* Enter a start condition. This macro really ought to take a parameter,"},{"Add":" * but we do it the disgusting crufty way forced on us by the ()-less"},{"Add":" * definition of BEGIN."},{"Add":" */"},{"Add":"#define BEGIN yy_start = 1 + 2 *"},{"Add":""},{"Add":"/* Translate the current start state into a value that can be later handed"},{"Add":" * to BEGIN to return to the state. The YYSTATE alias is for lex"},{"Add":" * compatibility."},{"Add":" */"},{"Add":"#define YY_START ((yy_start - 1) / 2)"},{"Add":"#define YYSTATE YY_START"},{"Add":""},{"Add":"/* Action number for EOF rule of a given start state. */"},{"Add":"#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)"},{"Add":""},{"Add":"/* Special action meaning \"start processing a new file\". */"},{"Add":"#define YY_NEW_FILE yyrestart(yyin)"},{"Add":""},{"Add":"#define YY_END_OF_BUFFER_CHAR 0"},{"Add":""},{"Add":"/* Size of default input buffer. */"},{"Add":"#define YY_BUF_SIZE 16384"},{"Add":""},{"Add":"typedef struct yy_buffer_state *YY_BUFFER_STATE;"},{"Add":""},{"Add":"extern int yyleng;"},{"Add":"extern FILE *yyin, *yyout;"},{"Add":""},{"Add":"#define EOB_ACT_CONTINUE_SCAN 0"},{"Add":"#define EOB_ACT_END_OF_FILE 1"},{"Add":"#define EOB_ACT_LAST_MATCH 2"},{"Add":""},{"Add":"/* The funky do-while in the following #define is used to turn the definition"},{"Add":" * int a single C statement (which needs a semi-colon terminator). This"},{"Add":" * avoids problems with code like:"},{"Add":" *"},{"Add":" * \tif ( condition_holds )"},{"Add":" *\t\tyyless( 5 );"},{"Add":" *\telse"},{"Add":" *\t\tdo_something_else();"},{"Add":" *"},{"Add":" * Prior to using the do-while the compiler would get upset at the"},{"Add":" * \"else\" because it interpreted the \"if\" statement as being all"},{"Add":" * done when it reached the ';' after the yyless() call."},{"Add":" */"},{"Add":""},{"Add":"/* Return all but the first 'n' matched characters back to the input stream. */"},{"Add":""},{"Add":"#define yyless(n) \\"},{"Add":" do { \\"},{"Add":" /* Undo effects of setting up yytext. */ \\"},{"Add":" *yy_cp = yy_hold_char; \\"},{"Add":" YY_RESTORE_YY_MORE_OFFSET \\"},{"Add":" yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \\"},{"Add":" YY_DO_BEFORE_ACTION; /* set up yytext again */ \\"},{"Add":" } while (0)"},{"Add":""},{"Add":"#define unput(c) yyunput(c, yytext_ptr)"},{"Add":""},{"Add":"/* The following is because we cannot portably get our hands on size_t"},{"Add":" * (without autoconf's help, which isn't available because we want"},{"Add":" * flex-generated scanners to compile on their own)."},{"Add":" */"},{"Add":"typedef unsigned int yy_size_t;"},{"Add":""},{"Add":"struct yy_buffer_state {"},{"Add":" FILE *yy_input_file;"},{"Add":""},{"Add":" char *yy_ch_buf; /* input buffer */"},{"Add":" char *yy_buf_pos; /* current position in input buffer */"},{"Add":""},{"Add":" /* Size of input buffer in bytes, not including room for EOB"},{"Add":" * characters."},{"Add":" */"},{"Add":" yy_size_t yy_buf_size;"},{"Add":""},{"Add":" /* Number of characters read into yy_ch_buf, not including EOB"},{"Add":" * characters."},{"Add":" */"},{"Add":" int yy_n_chars;"},{"Add":""},{"Add":" /* Whether we \"own\" the buffer - i.e., we know we created it,"},{"Add":" * and can realloc() it to grow it, and should free() it to"},{"Add":" * delete it."},{"Add":" */"},{"Add":" int yy_is_our_buffer;"},{"Add":""},{"Add":" /* Whether this is an \"interactive\" input source; if so, and"},{"Add":" * if we're using stdio for input, then we want to use getc()"},{"Add":" * instead of fread(), to make sure we stop fetching input after"},{"Add":" * each newline."},{"Add":" */"},{"Add":" int yy_is_interactive;"},{"Add":""},{"Add":" /* Whether we're considered to be at the beginning of a line."},{"Add":" * If so, '^' rules will be active on the next match, otherwise"},{"Add":" * not."},{"Add":" */"},{"Add":" int yy_at_bol;"},{"Add":""},{"Add":" /* Whether to try to fill the input buffer when we reach the"},{"Add":" * end of it."},{"Add":" */"},{"Add":" int yy_fill_buffer;"},{"Add":""},{"Add":" int yy_buffer_status;"},{"Add":"#define YY_BUFFER_NEW 0"},{"Add":"#define YY_BUFFER_NORMAL 1"},{"Add":" /* When an EOF's been seen but there's still some text to process"},{"Add":" * then we mark the buffer as YY_EOF_PENDING, to indicate that we"},{"Add":" * shouldn't try reading from the input source any more. We might"},{"Add":" * still have a bunch of tokens to match, though, because of"},{"Add":" * possible backing-up."},{"Add":" *"},{"Add":" * When we actually see the EOF, we change the status to \"new\""},{"Add":" * (via yyrestart()), so that the user can continue scanning by"},{"Add":" * just pointing yyin at a new input file."},{"Add":" */"},{"Add":"#define YY_BUFFER_EOF_PENDING 2"},{"Add":"};"},{"Add":""},{"Add":"static YY_BUFFER_STATE yy_current_buffer = 0;"},{"Add":""},{"Add":"/* We provide macros for accessing buffer states in case in the"},{"Add":" * future we want to put the buffer states in a more general"},{"Add":" * \"scanner state\"."},{"Add":" */"},{"Add":"#define YY_CURRENT_BUFFER yy_current_buffer"},{"Add":""},{"Add":"/* yy_hold_char holds the character lost when yytext is formed. */"},{"Add":"static char yy_hold_char;"},{"Add":""},{"Add":"static int yy_n_chars; /* number of characters read into yy_ch_buf */"},{"Add":""},{"Add":"int yyleng;"},{"Add":""},{"Add":"/* Points to current character in buffer. */"},{"Add":"static char *yy_c_buf_p = (char *)0;"},{"Add":"static int yy_init = 1; /* whether we need to initialize */"},{"Add":"static int yy_start = 0; /* start state number */"},{"Add":""},{"Add":"/* Flag which is used to allow yywrap()'s to do buffer switches"},{"Add":" * instead of setting up a fresh yyin. A bit of a hack ..."},{"Add":" */"},{"Add":"static int yy_did_buffer_switch_on_eof;"},{"Add":""},{"Add":"void yyrestart YY_PROTO((FILE * input_file));"},{"Add":""},{"Add":"void yy_switch_to_buffer YY_PROTO((YY_BUFFER_STATE new_buffer));"},{"Add":"void yy_load_buffer_state YY_PROTO((void));"},{"Add":"YY_BUFFER_STATE yy_create_buffer YY_PROTO((FILE * file, int size));"},{"Add":"void yy_delete_buffer YY_PROTO((YY_BUFFER_STATE b));"},{"Add":"void yy_init_buffer YY_PROTO((YY_BUFFER_STATE b, FILE *file));"},{"Add":"void yy_flush_buffer YY_PROTO((YY_BUFFER_STATE b));"},{"Add":"#define YY_FLUSH_BUFFER yy_flush_buffer(yy_current_buffer)"},{"Add":""},{"Add":"YY_BUFFER_STATE yy_scan_buffer YY_PROTO((char *base, yy_size_t size));"},{"Add":"YY_BUFFER_STATE yy_scan_string YY_PROTO((yyconst char *yy_str));"},{"Add":"YY_BUFFER_STATE yy_scan_bytes YY_PROTO((yyconst char *bytes, int len));"},{"Add":""},{"Add":"static void *yy_flex_alloc YY_PROTO((yy_size_t));"},{"Add":"static void *yy_flex_realloc YY_PROTO((void *, yy_size_t));"},{"Add":"static void yy_flex_free YY_PROTO((void *));"},{"Add":""},{"Add":"#define yy_new_buffer yy_create_buffer"},{"Add":""},{"Add":"#define yy_set_interactive(is_interactive) \\"},{"Add":" { \\"},{"Add":" if (!yy_current_buffer) \\"},{"Add":" yy_current_buffer = yy_create_buffer(yyin, YY_BUF_SIZE); \\"},{"Add":" yy_current_buffer->yy_is_interactive = is_interactive; \\"},{"Add":" }"},{"Add":""},{"Add":"#define yy_set_bol(at_bol) \\"},{"Add":" { \\"},{"Add":" if (!yy_current_buffer) \\"},{"Add":" yy_current_buffer = yy_create_buffer(yyin, YY_BUF_SIZE); \\"},{"Add":" yy_current_buffer->yy_at_bol = at_bol; \\"},{"Add":" }"},{"Add":""},{"Add":"#define YY_AT_BOL() (yy_current_buffer->yy_at_bol)"},{"Add":""},{"Add":"#define FLEX_DEBUG"},{"Add":"typedef unsigned char YY_CHAR;"},{"Add":"FILE *yyin = (FILE *)0, *yyout = (FILE *)0;"},{"Add":"typedef int yy_state_type;"},{"Add":""},{"Add":"#define FLEX_DEBUG"},{"Add":"extern char *yytext;"},{"Add":"#define yytext_ptr yytext"},{"Add":""},{"Add":"static yy_state_type yy_get_previous_state YY_PROTO((void));"},{"Add":"static yy_state_type yy_try_NUL_trans YY_PROTO((yy_state_type current_state));"},{"Add":"static int yy_get_next_buffer YY_PROTO((void));"},{"Add":"static void yy_fatal_error YY_PROTO((yyconst char msg[]));"},{"Add":""},{"Add":"/* Done after the current pattern has been matched and before the"},{"Add":" * corresponding action - sets up yytext."},{"Add":" */"},{"Add":"#define YY_DO_BEFORE_ACTION \\"},{"Add":" yytext_ptr = yy_bp; \\"},{"Add":" yyleng = (int)(yy_cp - yy_bp); \\"},{"Add":" yy_hold_char = *yy_cp; \\"},{"Add":" *yy_cp = '\\0'; \\"},{"Add":" yy_c_buf_p = yy_cp;"},{"Add":""},{"Add":"#define YY_NUM_RULES 47"},{"Add":"#define YY_END_OF_BUFFER 48"},{"Add":"static yyconst short int yy_accept[163] = {"},{"Add":" 0, 0, 0, 0, 0, 48, 47, 1, 37, 3, 35, 2, 36, 47, 46, 38, 45,"},{"Add":" 1, 3, 2, 36, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,"},{"Add":" 0, 44, 45, 43, 41, 42, 39, 40, 0, 0, 0, 0, 0, 0, 0, 0, 24,"},{"Add":" 0, 0, 0, 0, 0, 23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,"},{"Add":" 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 27, 0, 25, 17, 0, 0, 20,"},{"Add":" 22, 30, 0, 0, 0, 0, 0, 0, 19, 0, 0, 7, 0, 29, 0, 0,"},{"Add":""},{"Add":" 26, 13, 0, 0, 0, 0, 14, 0, 0, 0, 0, 18, 0, 0, 0, 0, 0,"},{"Add":" 16, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 9,"},{"Add":" 0, 21, 8, 31, 6, 0, 0, 34, 0, 0, 28, 0, 0, 32, 33, 4, 0,"},{"Add":" 15, 12, 0, 0, 0, 0, 0, 0, 0, 11, 0};"},{"Add":""},{"Add":"static yyconst int yy_ec[256] = {"},{"Add":" 0, 1, 1, 1, 1, 1, 1, 1, 2, 2, 3, 2, 2, 2, 1, 1, 1, 1, 1,"},{"Add":" 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 4, 5, 1, 1,"},{"Add":" 1, 1, 6, 6, 1, 1, 1, 1, 1, 1, 7, 7, 7, 7, 7, 7, 7, 7, 7,"},{"Add":" 7, 6, 1, 1, 1, 1, 1, 1, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,"},{"Add":" 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 1, 9, 1, 1,"},{"Add":" 10, 1, 11, 12, 13, 14,"},{"Add":""},{"Add":" 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,"},{"Add":" 34, 35, 8, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,"},{"Add":" 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,"},{"Add":" 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,"},{"Add":" 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,"},{"Add":" 1, 1, 1, 1, 1,"},{"Add":""},{"Add":" 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,"},{"Add":" 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,"},{"Add":" 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};"},{"Add":""},{"Add":"static yyconst int yy_meta[36] = {0, 1, 1, 1, 1, 1, 1, 2, 2, 1, 2, 2,"},{"Add":" 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,"},{"Add":" 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2};"},{"Add":""},{"Add":"static yyconst short int yy_base[166] = {"},{"Add":" 0, 0, 10, 18, 20, 180, 181, 23, 181, 172, 181, 171, 0, 19, 181,"},{"Add":" 181, 46, 34, 170, 169, 0, 10, 29, 34, 156, 147, 148, 23, 48, 46,"},{"Add":" 3, 160, 38, 34, 136, 181, 163, 181, 181, 181, 181, 181, 140, 138, 142,"},{"Add":" 141, 154, 153, 44, 40, 181, 135, 132, 129, 44, 135, 181, 129, 136, 58,"},{"Add":" 147, 136, 124, 129, 68, 141, 126, 132, 122, 136, 126, 123, 117, 119, 130,"},{"Add":" 117, 123, 118, 181, 115, 181, 181, 113, 120, 181, 181, 181, 65, 122, 107,"},{"Add":" 118, 104, 114, 181, 119, 114, 181, 109, 181, 116, 99,"},{"Add":""},{"Add":" 181, 181, 116, 112, 114, 105, 181, 98, 88, 86, 107, 181, 91, 99, 93,"},{"Add":" 105, 91, 181, 96, 181, 83, 97, 89, 96, 95, 82, 81, 76, 94, 91,"},{"Add":" 86, 73, 181, 181, 88, 181, 181, 181, 181, 66, 78, 181, 69, 80, 181,"},{"Add":" 74, 70, 181, 181, 181, 73, 181, 181, 67, 56, 58, 72, 52, 68, 28,"},{"Add":" 181, 181, 96, 98, 6};"},{"Add":""},{"Add":"static yyconst short int yy_def[166] = {"},{"Add":" 0, 163, 163, 164, 164, 162, 162, 162, 162, 162, 162, 162, 165, 162, 162,"},{"Add":" 162, 162, 162, 162, 162, 165, 162, 162, 162, 162, 162, 162, 162, 162, 162,"},{"Add":" 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162,"},{"Add":" 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162,"},{"Add":" 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162,"},{"Add":" 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162,"},{"Add":" 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162,"},{"Add":""},{"Add":" 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162,"},{"Add":" 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162,"},{"Add":" 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162,"},{"Add":" 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162,"},{"Add":" 162, 0, 162, 162, 162};"},{"Add":""},{"Add":"static yyconst short int yy_nxt[217] = {"},{"Add":" 0, 6, 7, 7, 8, 9, 10, 11, 20, 6, 13, 6, 7, 7, 8,"},{"Add":" 9, 10, 11, 59, 6, 13, 6, 15, 6, 15, 17, 17, 16, 60, 16,"},{"Add":" 21, 22, 23, 24, 25, 26, 17, 17, 27, 42, 43, 28, 29, 30, 31,"},{"Add":" 32, 161, 52, 33, 34, 35, 44, 53, 36, 45, 37, 47, 46, 38, 48,"},{"Add":" 62, 57, 39, 54, 64, 65, 63, 73, 74, 75, 40, 80, 76, 55, 81,"},{"Add":" 85, 41, 58, 56, 91, 109, 160, 159, 158, 157, 156, 155, 154, 153, 152,"},{"Add":" 151, 86, 150, 149, 148, 110, 92, 12, 12, 14, 14,"},{"Add":""},{"Add":" 147, 146, 145, 144, 143, 142, 141, 140, 139, 138, 137, 136, 135, 134, 133,"},{"Add":" 132, 131, 130, 129, 128, 127, 126, 125, 124, 123, 122, 121, 120, 119, 118,"},{"Add":" 117, 116, 115, 114, 113, 112, 111, 108, 107, 106, 105, 104, 103, 102, 101,"},{"Add":" 100, 99, 98, 97, 96, 95, 94, 93, 90, 89, 88, 87, 84, 83, 82,"},{"Add":" 79, 78, 77, 72, 71, 70, 69, 68, 67, 36, 66, 61, 51, 50, 49,"},{"Add":" 19, 18, 19, 18, 162, 5, 162, 162, 162, 162, 162, 162, 162, 162, 162,"},{"Add":" 162, 162, 162, 162, 162, 162, 162, 162, 162, 162,"},{"Add":""},{"Add":" 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162,"},{"Add":" 162};"},{"Add":""},{"Add":"static yyconst short int yy_chk[217] = {"},{"Add":" 0, 1, 1, 1, 1, 1, 1, 1, 165, 1, 1, 2, 2, 2, 2,"},{"Add":" 2, 2, 2, 30, 2, 2, 3, 3, 4, 4, 7, 7, 3, 30, 4,"},{"Add":" 13, 13, 13, 13, 13, 13, 17, 17, 13, 21, 21, 13, 13, 13, 13,"},{"Add":" 13, 160, 27, 13, 13, 16, 22, 27, 16, 22, 16, 23, 22, 16, 23,"},{"Add":" 32, 29, 16, 28, 33, 33, 32, 48, 48, 49, 16, 54, 49, 28, 54,"},{"Add":" 59, 16, 29, 28, 64, 87, 159, 158, 157, 156, 155, 154, 151, 147, 146,"},{"Add":" 144, 59, 143, 141, 140, 87, 64, 163, 163, 164, 164,"},{"Add":""},{"Add":" 135, 132, 131, 130, 129, 128, 127, 126, 125, 124, 123, 122, 121, 119, 117,"},{"Add":" 116, 115, 114, 113, 111, 110, 109, 108, 106, 105, 104, 103, 100, 99, 97,"},{"Add":" 95, 94, 92, 91, 90, 89, 88, 83, 82, 79, 77, 76, 75, 74, 73,"},{"Add":" 72, 71, 70, 69, 68, 67, 66, 65, 63, 62, 61, 60, 58, 57, 55,"},{"Add":" 53, 52, 51, 47, 46, 45, 44, 43, 42, 36, 34, 31, 26, 25, 24,"},{"Add":" 19, 18, 11, 9, 5, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162,"},{"Add":" 162, 162, 162, 162, 162, 162, 162, 162, 162, 162,"},{"Add":""},{"Add":" 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, 162,"},{"Add":" 162};"},{"Add":""},{"Add":"static yy_state_type yy_last_accepting_state;"},{"Add":"static char *yy_last_accepting_cpos;"},{"Add":""},{"Add":"extern int yy_flex_debug;"},{"Add":"int yy_flex_debug = 0;"},{"Add":""},{"Add":"static yyconst short int yy_rule_linenum[47] = {"},{"Add":" 0, 47, 48, 51, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,"},{"Add":" 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,"},{"Add":" 82, 83, 84, 86, 89, 101, 103, 113, 114, 115, 116, 117, 118, 120, 125};"},{"Add":""},{"Add":"/* The intent behind this definition is that it'll catch"},{"Add":" * any uses of REJECT which flex missed."},{"Add":" */"},{"Add":"#define REJECT reject_used_but_not_detected"},{"Add":"#define yymore() yymore_used_but_not_detected"},{"Add":"#define YY_MORE_ADJ 0"},{"Add":"#define YY_RESTORE_YY_MORE_OFFSET"},{"Add":"char *yytext;"},{"Add":"#line 1 \"ast.flex\""},{"Add":"#define INITIAL 0"},{"Add":"/*"},{"Add":" * A scanner definition for COOL ASTs."},{"Add":" */"},{"Add":"#line 5 \"ast.flex\""},{"Add":"#include \"ast_parse.h\""},{"Add":"#include \"stringtab.h\""},{"Add":"#include \"utils.h\""},{"Add":""},{"Add":"extern FILE *ast_file; /* we read from this file */"},{"Add":""},{"Add":"/* define YY_INPUT so we read from the FILE fin:"},{"Add":" * This change makes it possible to use this scanner in"},{"Add":" * the Cool compiler."},{"Add":" */"},{"Add":"#undef YY_INPUT"},{"Add":"#define YY_INPUT(buf, result, max_size) \\"},{"Add":" if ((result = fread((char *)buf, sizeof(char), max_size, ast_file)) < 0) \\"},{"Add":" YY_FATAL_ERROR(\"read() in flex scanner failed\");"},{"Add":""},{"Add":"char string_buf[MAX_STR_CONST]; /* to assemble string constants */"},{"Add":"char *string_buf_ptr;"},{"Add":""},{"Add":"extern int verbose_flag;"},{"Add":"YYSTYPE cool_yylval; /* needed to link ast code with utilities.cc */"},{"Add":"#define yywrap() 1"},{"Add":""},{"Add":"#define STRING 1"},{"Add":""},{"Add":"#line 519 \"ast-lex.cc\""},{"Add":""},{"Add":"/* Macros after this point can all be overridden by user definitions in"},{"Add":" * section 1."},{"Add":" */"},{"Add":""},{"Add":"#ifndef YY_SKIP_YYWRAP"},{"Add":"#ifdef __cplusplus"},{"Add":"extern \"C\" int yywrap YY_PROTO((void));"},{"Add":"#else"},{"Add":"extern int yywrap YY_PROTO((void));"},{"Add":"#endif"},{"Add":"#endif"},{"Add":""},{"Add":"#ifndef YY_NO_UNPUT"},{"Add":"static void yyunput YY_PROTO((int c, char *buf_ptr));"},{"Add":"#endif"},{"Add":""},{"Add":"#ifndef yytext_ptr"},{"Add":"static void yy_flex_strncpy YY_PROTO((char *, yyconst char *, int));"},{"Add":"#endif"},{"Add":""},{"Add":"#ifdef YY_NEED_STRLEN"},{"Add":"static int yy_flex_strlen YY_PROTO((yyconst char *));"},{"Add":"#endif"},{"Add":""},{"Add":"#ifndef YY_NO_INPUT"},{"Add":"#ifdef __cplusplus"},{"Add":"static int yyinput YY_PROTO((void));"},{"Add":"#else"},{"Add":"static int input YY_PROTO((void));"},{"Add":"#endif"},{"Add":"#endif"},{"Add":""},{"Add":"#if YY_STACK_USED"},{"Add":"static int yy_start_stack_ptr = 0;"},{"Add":"static int yy_start_stack_depth = 0;"},{"Add":"static int *yy_start_stack = 0;"},{"Add":"#ifndef YY_NO_PUSH_STATE"},{"Add":"static void yy_push_state YY_PROTO((int new_state));"},{"Add":"#endif"},{"Add":"#ifndef YY_NO_POP_STATE"},{"Add":"static void yy_pop_state YY_PROTO((void));"},{"Add":"#endif"},{"Add":"#ifndef YY_NO_TOP_STATE"},{"Add":"static int yy_top_state YY_PROTO((void));"},{"Add":"#endif"},{"Add":""},{"Add":"#else"},{"Add":"#define YY_NO_PUSH_STATE 1"},{"Add":"#define YY_NO_POP_STATE 1"},{"Add":"#define YY_NO_TOP_STATE 1"},{"Add":"#endif"},{"Add":""},{"Add":"#ifdef YY_MALLOC_DECL"},{"Add":"YY_MALLOC_DECL"},{"Add":"#else"},{"Add":"#if __STDC__"},{"Add":"#ifndef __cplusplus"},{"Add":"#include "},{"Add":"#endif"},{"Add":"#else"},{"Add":"/* Just try to get by without declaring the routines. This will fail"},{"Add":" * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)"},{"Add":" * or sizeof(void*) != sizeof(int)."},{"Add":" */"},{"Add":"#endif"},{"Add":"#endif"},{"Add":""},{"Add":"/* Amount of stuff to slurp up with each read. */"},{"Add":"#ifndef YY_READ_BUF_SIZE"},{"Add":"#define YY_READ_BUF_SIZE 8192"},{"Add":"#endif"},{"Add":""},{"Add":"/* Copy whatever the last rule matched to the standard output. */"},{"Add":""},{"Add":"#ifndef ECHO"},{"Add":"/* This used to be an fputs(), but since the string might contain NUL's,"},{"Add":" * we now use fwrite()."},{"Add":" */"},{"Add":"#define ECHO (void)fwrite(yytext, yyleng, 1, yyout)"},{"Add":"#endif"},{"Add":""},{"Add":"/* Gets input and stuffs it into \"buf\". number of characters read, or YY_NULL,"},{"Add":" * is returned in \"result\"."},{"Add":" */"},{"Add":"#ifndef YY_INPUT"},{"Add":"#define YY_INPUT(buf, result, max_size) \\"},{"Add":" if (yy_current_buffer->yy_is_interactive) { \\"},{"Add":" int c = '*', n; \\"},{"Add":" for (n = 0; n < max_size && (c = getc(yyin)) != EOF && c != '\\n'; ++n) \\"},{"Add":" buf[n] = (char)c; \\"},{"Add":" if (c == '\\n') \\"},{"Add":" buf[n++] = (char)c; \\"},{"Add":" if (c == EOF && ferror(yyin)) \\"},{"Add":" YY_FATAL_ERROR(\"input in flex scanner failed\"); \\"},{"Add":" result = n; \\"},{"Add":" } else if (((result = fread(buf, 1, max_size, yyin)) == 0) && ferror(yyin)) \\"},{"Add":" YY_FATAL_ERROR(\"input in flex scanner failed\");"},{"Add":"#endif"},{"Add":""},{"Add":"/* No semi-colon after return; correct usage is to write \"yyterminate();\" -"},{"Add":" * we don't want an extra ';' after the \"return\" because that will cause"},{"Add":" * some compilers to complain about unreachable statements."},{"Add":" */"},{"Add":"#ifndef yyterminate"},{"Add":"#define yyterminate() return YY_NULL"},{"Add":"#endif"},{"Add":""},{"Add":"/* Number of entries by which start-condition stack grows. */"},{"Add":"#ifndef YY_START_STACK_INCR"},{"Add":"#define YY_START_STACK_INCR 25"},{"Add":"#endif"},{"Add":""},{"Add":"/* Report a fatal error. */"},{"Add":"#ifndef YY_FATAL_ERROR"},{"Add":"#define YY_FATAL_ERROR(msg) yy_fatal_error(msg)"},{"Add":"#endif"},{"Add":""},{"Add":"/* Default declaration of generated scanner - a define so the user can"},{"Add":" * easily add parameters."},{"Add":" */"},{"Add":"#ifndef YY_DECL"},{"Add":"#define YY_DECL int yylex YY_PROTO((void))"},{"Add":"#endif"},{"Add":""},{"Add":"/* Code executed at the beginning of each rule, after yytext and yyleng"},{"Add":" * have been set up."},{"Add":" */"},{"Add":"#ifndef YY_USER_ACTION"},{"Add":"#define YY_USER_ACTION"},{"Add":"#endif"},{"Add":""},{"Add":"/* Code executed at the end of each rule. */"},{"Add":"#ifndef YY_BREAK"},{"Add":"#define YY_BREAK break;"},{"Add":"#endif"},{"Add":""},{"Add":"#define YY_RULE_SETUP YY_USER_ACTION"},{"Add":""},{"Add":"YY_DECL {"},{"Add":" register yy_state_type yy_current_state;"},{"Add":" register char *yy_cp = NULL, *yy_bp = NULL;"},{"Add":" register int yy_act;"},{"Add":""},{"Add":"#line 45 \"ast.flex\""},{"Add":""},{"Add":"#line 673 \"ast-lex.cc\""},{"Add":""},{"Add":" if (yy_init) {"},{"Add":" yy_init = 0;"},{"Add":""},{"Add":"#ifdef YY_USER_INIT"},{"Add":" YY_USER_INIT;"},{"Add":"#endif"},{"Add":""},{"Add":" if (!yy_start)"},{"Add":" yy_start = 1; /* first start state */"},{"Add":""},{"Add":" if (!yyin)"},{"Add":" yyin = stdin;"},{"Add":""},{"Add":" if (!yyout)"},{"Add":" yyout = stdout;"},{"Add":""},{"Add":" if (!yy_current_buffer)"},{"Add":" yy_current_buffer = yy_create_buffer(yyin, YY_BUF_SIZE);"},{"Add":""},{"Add":" yy_load_buffer_state();"},{"Add":" }"},{"Add":""},{"Add":" while (1) /* loops until end-of-file is reached */"},{"Add":" {"},{"Add":" yy_cp = yy_c_buf_p;"},{"Add":""},{"Add":" /* Support of yytext. */"},{"Add":" *yy_cp = yy_hold_char;"},{"Add":""},{"Add":" /* yy_bp points to the position in yy_ch_buf of the start of"},{"Add":" * the current run."},{"Add":" */"},{"Add":" yy_bp = yy_cp;"},{"Add":""},{"Add":" yy_current_state = yy_start;"},{"Add":" yy_match:"},{"Add":" do {"},{"Add":" register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];"},{"Add":" if (yy_accept[yy_current_state]) {"},{"Add":" yy_last_accepting_state = yy_current_state;"},{"Add":" yy_last_accepting_cpos = yy_cp;"},{"Add":" }"},{"Add":" while (yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state) {"},{"Add":" yy_current_state = (int)yy_def[yy_current_state];"},{"Add":" if (yy_current_state >= 163)"},{"Add":" yy_c = yy_meta[(unsigned int)yy_c];"},{"Add":" }"},{"Add":" yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int)yy_c];"},{"Add":" ++yy_cp;"},{"Add":" } while (yy_base[yy_current_state] != 181);"},{"Add":""},{"Add":" yy_find_action:"},{"Add":" yy_act = yy_accept[yy_current_state];"},{"Add":" if (yy_act == 0) { /* have to back up */"},{"Add":" yy_cp = yy_last_accepting_cpos;"},{"Add":" yy_current_state = yy_last_accepting_state;"},{"Add":" yy_act = yy_accept[yy_current_state];"},{"Add":" }"},{"Add":""},{"Add":" YY_DO_BEFORE_ACTION;"},{"Add":""},{"Add":" do_action: /* This label is used only to access EOF actions. */"},{"Add":""},{"Add":" if (yy_flex_debug) {"},{"Add":" if (yy_act == 0)"},{"Add":" fprintf(stderr, \"--scanner backing up\\n\");"},{"Add":" else if (yy_act < 47)"},{"Add":" fprintf(stderr, \"--accepting rule at line %d (\\\"%s\\\")\\n\","},{"Add":" yy_rule_linenum[yy_act], yytext);"},{"Add":" else if (yy_act == 47)"},{"Add":" fprintf(stderr, \"--accepting default rule (\\\"%s\\\")\\n\", yytext);"},{"Add":" else if (yy_act == 48)"},{"Add":" fprintf(stderr, \"--(end of buffer or a NUL)\\n\");"},{"Add":" else"},{"Add":" fprintf(stderr, \"--EOF (start condition %d)\\n\", YY_START);"},{"Add":" }"},{"Add":""},{"Add":" switch (yy_act) { /* beginning of action switch */"},{"Add":" case 0: /* must back up */"},{"Add":" /* undo the effects of YY_DO_BEFORE_ACTION */"},{"Add":" *yy_cp = yy_hold_char;"},{"Add":" yy_cp = yy_last_accepting_cpos;"},{"Add":" yy_current_state = yy_last_accepting_state;"},{"Add":" goto yy_find_action;"},{"Add":""},{"Add":" case 1:"},{"Add":" YY_RULE_SETUP"},{"Add":"#line 47 \"ast.flex\""},{"Add":" {"},{"Add":" }"},{"Add":" YY_BREAK"},{"Add":" case 2:"},{"Add":" YY_RULE_SETUP"},{"Add":"#line 48 \"ast.flex\""},{"Add":" {"},{"Add":" yylval.symbol = inttable.add_string(std::string(yytext, yyleng));"},{"Add":" return (INT_CONST);"},{"Add":" }"},{"Add":" YY_BREAK"},{"Add":" case 3:"},{"Add":" YY_RULE_SETUP"},{"Add":"#line 51 \"ast.flex\""},{"Add":" {"},{"Add":" yylval.lineno = atoi(yytext + 1);"},{"Add":" return (LINENO);"},{"Add":" }"},{"Add":" YY_BREAK"},{"Add":" case 4:"},{"Add":" YY_RULE_SETUP"},{"Add":"#line 54 \"ast.flex\""},{"Add":" {"},{"Add":" return (PROGRAM);"},{"Add":" }"},{"Add":" YY_BREAK"},{"Add":" case 5:"},{"Add":" YY_RULE_SETUP"},{"Add":"#line 55 \"ast.flex\""},{"Add":" {"},{"Add":" return (CLASS);"},{"Add":" }"},{"Add":" YY_BREAK"},{"Add":" case 6:"},{"Add":" YY_RULE_SETUP"},{"Add":"#line 56 \"ast.flex\""},{"Add":" {"},{"Add":" return (METHOD);"},{"Add":" }"},{"Add":" YY_BREAK"},{"Add":" case 7:"},{"Add":" YY_RULE_SETUP"},{"Add":"#line 57 \"ast.flex\""},{"Add":" {"},{"Add":" return (ATTR);"},{"Add":" }"},{"Add":" YY_BREAK"},{"Add":" case 8:"},{"Add":" YY_RULE_SETUP"},{"Add":"#line 58 \"ast.flex\""},{"Add":" {"},{"Add":" return (FORMAL);"},{"Add":" }"},{"Add":" YY_BREAK"},{"Add":" case 9:"},{"Add":" YY_RULE_SETUP"},{"Add":"#line 59 \"ast.flex\""},{"Add":" {"},{"Add":" return (BRANCH);"},{"Add":" }"},{"Add":" YY_BREAK"},{"Add":" case 10:"},{"Add":" YY_RULE_SETUP"},{"Add":"#line 60 \"ast.flex\""},{"Add":" {"},{"Add":" return (ASSIGN);"},{"Add":" }"},{"Add":" YY_BREAK"},{"Add":" case 11:"},{"Add":" YY_RULE_SETUP"},{"Add":"#line 61 \"ast.flex\""},{"Add":" {"},{"Add":" return (STATIC_DISPATCH);"},{"Add":" }"},{"Add":" YY_BREAK"},{"Add":" case 12:"},{"Add":" YY_RULE_SETUP"},{"Add":"#line 62 \"ast.flex\""},{"Add":" {"},{"Add":" return (DISPATCH);"},{"Add":" }"},{"Add":" YY_BREAK"},{"Add":" case 13:"},{"Add":" YY_RULE_SETUP"},{"Add":"#line 63 \"ast.flex\""},{"Add":" {"},{"Add":" return (COND);"},{"Add":" }"},{"Add":" YY_BREAK"},{"Add":" case 14:"},{"Add":" YY_RULE_SETUP"},{"Add":"#line 64 \"ast.flex\""},{"Add":" {"},{"Add":" return (LOOP);"},{"Add":" }"},{"Add":" YY_BREAK"},{"Add":" case 15:"},{"Add":" YY_RULE_SETUP"},{"Add":"#line 65 \"ast.flex\""},{"Add":" {"},{"Add":" return (TYPCASE);"},{"Add":" }"},{"Add":" YY_BREAK"},{"Add":" case 16:"},{"Add":" YY_RULE_SETUP"},{"Add":"#line 66 \"ast.flex\""},{"Add":" {"},{"Add":" return (BLOCK);"},{"Add":" }"},{"Add":" YY_BREAK"},{"Add":" case 17:"},{"Add":" YY_RULE_SETUP"},{"Add":"#line 67 \"ast.flex\""},{"Add":" {"},{"Add":" return (LET);"},{"Add":" }"},{"Add":" YY_BREAK"},{"Add":" case 18:"},{"Add":" YY_RULE_SETUP"},{"Add":"#line 68 \"ast.flex\""},{"Add":" {"},{"Add":" return (PLUS);"},{"Add":" }"},{"Add":" YY_BREAK"},{"Add":" case 19:"},{"Add":" YY_RULE_SETUP"},{"Add":"#line 69 \"ast.flex\""},{"Add":" {"},{"Add":" return (SUB);"},{"Add":" }"},{"Add":" YY_BREAK"},{"Add":" case 20:"},{"Add":" YY_RULE_SETUP"},{"Add":"#line 70 \"ast.flex\""},{"Add":" {"},{"Add":" return (MUL);"},{"Add":" }"},{"Add":" YY_BREAK"},{"Add":" case 21:"},{"Add":" YY_RULE_SETUP"},{"Add":"#line 71 \"ast.flex\""},{"Add":" {"},{"Add":" return (DIVIDE);"},{"Add":" }"},{"Add":" YY_BREAK"},{"Add":" case 22:"},{"Add":" YY_RULE_SETUP"},{"Add":"#line 72 \"ast.flex\""},{"Add":" {"},{"Add":" return (NEG);"},{"Add":" }"},{"Add":" YY_BREAK"},{"Add":" case 23:"},{"Add":" YY_RULE_SETUP"},{"Add":"#line 73 \"ast.flex\""},{"Add":" {"},{"Add":" return (LESSTHAN);"},{"Add":" }"},{"Add":" YY_BREAK"},{"Add":" case 24:"},{"Add":" YY_RULE_SETUP"},{"Add":"#line 74 \"ast.flex\""},{"Add":" {"},{"Add":" return (EQUAL);"},{"Add":" }"},{"Add":" YY_BREAK"},{"Add":" case 25:"},{"Add":" YY_RULE_SETUP"},{"Add":"#line 75 \"ast.flex\""},{"Add":" {"},{"Add":" return (LEQ);"},{"Add":" }"},{"Add":" YY_BREAK"},{"Add":" case 26:"},{"Add":" YY_RULE_SETUP"},{"Add":"#line 76 \"ast.flex\""},{"Add":" {"},{"Add":" return (COMP);"},{"Add":" }"},{"Add":" YY_BREAK"},{"Add":" case 27:"},{"Add":" YY_RULE_SETUP"},{"Add":"#line 77 \"ast.flex\""},{"Add":" {"},{"Add":" return (INT);"},{"Add":" }"},{"Add":" YY_BREAK"},{"Add":" case 28:"},{"Add":" YY_RULE_SETUP"},{"Add":"#line 78 \"ast.flex\""},{"Add":" {"},{"Add":" return (STR);"},{"Add":" }"},{"Add":" YY_BREAK"},{"Add":" case 29:"},{"Add":" YY_RULE_SETUP"},{"Add":"#line 79 \"ast.flex\""},{"Add":" {"},{"Add":" return (BOOL);"},{"Add":" }"},{"Add":" YY_BREAK"},{"Add":" case 30:"},{"Add":" YY_RULE_SETUP"},{"Add":"#line 80 \"ast.flex\""},{"Add":" {"},{"Add":" return (NEW);"},{"Add":" }"},{"Add":" YY_BREAK"},{"Add":" case 31:"},{"Add":" YY_RULE_SETUP"},{"Add":"#line 81 \"ast.flex\""},{"Add":" {"},{"Add":" return (ISVOID);"},{"Add":" }"},{"Add":" YY_BREAK"},{"Add":" case 32:"},{"Add":" YY_RULE_SETUP"},{"Add":"#line 82 \"ast.flex\""},{"Add":" {"},{"Add":" return (NO_EXPR);"},{"Add":" }"},{"Add":" YY_BREAK"},{"Add":" case 33:"},{"Add":" YY_RULE_SETUP"},{"Add":"#line 83 \"ast.flex\""},{"Add":" {"},{"Add":" return (NO_TYPE);"},{"Add":" }"},{"Add":" YY_BREAK"},{"Add":" case 34:"},{"Add":" YY_RULE_SETUP"},{"Add":"#line 84 \"ast.flex\""},{"Add":" {"},{"Add":" return (OBJECT);"},{"Add":" }"},{"Add":" YY_BREAK"},{"Add":" case 35:"},{"Add":" YY_RULE_SETUP"},{"Add":"#line 86 \"ast.flex\""},{"Add":" {"},{"Add":" return (*yytext);"},{"Add":" }"},{"Add":" YY_BREAK"},{"Add":" case 36:"},{"Add":" YY_RULE_SETUP"},{"Add":"#line 89 \"ast.flex\""},{"Add":" {"},{"Add":" yylval.symbol = idtable.add_string(std::string(yytext, yyleng));"},{"Add":" return (IDENT);"},{"Add":" }"},{"Add":" YY_BREAK"},{"Add":" /*"},{"Add":" * String constants (C syntax, taken from lexdoc(1) )"},{"Add":" * Escape sequence \\c is accepted for all characters c. Except for"},{"Add":" * \\n \\t \\b \\f, the result is c."},{"Add":" *"},{"Add":" */"},{"Add":" case 37:"},{"Add":" YY_RULE_SETUP"},{"Add":"#line 101 \"ast.flex\""},{"Add":" string_buf_ptr = string_buf;"},{"Add":" BEGIN(STRING);"},{"Add":" YY_BREAK"},{"Add":" case 38:"},{"Add":" YY_RULE_SETUP"},{"Add":"#line 103 \"ast.flex\""},{"Add":" {"},{"Add":" /* saw closing quote - all done */"},{"Add":""},{"Add":" BEGIN(INITIAL);"},{"Add":" *string_buf_ptr = '\\0';"},{"Add":" yylval.symbol = stringtable.add_string(std::string(string_buf));"},{"Add":" return (STR_CONST);"},{"Add":" }"},{"Add":" YY_BREAK"},{"Add":" case 39:"},{"Add":" YY_RULE_SETUP"},{"Add":"#line 113 \"ast.flex\""},{"Add":" {"},{"Add":" *string_buf_ptr++ = '\\n';"},{"Add":" }"},{"Add":" YY_BREAK"},{"Add":" case 40:"},{"Add":" YY_RULE_SETUP"},{"Add":"#line 114 \"ast.flex\""},{"Add":" {"},{"Add":" *string_buf_ptr++ = '\\t';"},{"Add":" }"},{"Add":" YY_BREAK"},{"Add":" case 41:"},{"Add":" YY_RULE_SETUP"},{"Add":"#line 115 \"ast.flex\""},{"Add":" {"},{"Add":" *string_buf_ptr++ = '\\b';"},{"Add":" }"},{"Add":" YY_BREAK"},{"Add":" case 42:"},{"Add":" YY_RULE_SETUP"},{"Add":"#line 116 \"ast.flex\""},{"Add":" {"},{"Add":" *string_buf_ptr++ = '\\f';"},{"Add":" }"},{"Add":" YY_BREAK"},{"Add":" case 43:"},{"Add":" YY_RULE_SETUP"},{"Add":"#line 117 \"ast.flex\""},{"Add":" {"},{"Add":" *string_buf_ptr++ = '\\\\';"},{"Add":" }"},{"Add":" YY_BREAK"},{"Add":" case 44:"},{"Add":" YY_RULE_SETUP"},{"Add":"#line 118 \"ast.flex\""},{"Add":" {"},{"Add":" *string_buf_ptr++ = '\\\"';"},{"Add":" }"},{"Add":" YY_BREAK"},{"Add":" case 45:"},{"Add":" YY_RULE_SETUP"},{"Add":"#line 120 \"ast.flex\""},{"Add":" {"},{"Add":" /* unprintable characters are represented as octal numbers */"},{"Add":" *string_buf_ptr++ = strtol(yytext + 1, 0, 8);"},{"Add":" }"},{"Add":" YY_BREAK"},{"Add":" case 46:"},{"Add":" YY_RULE_SETUP"},{"Add":"#line 125 \"ast.flex\""},{"Add":" {"},{"Add":" *string_buf_ptr++ = yytext[0];"},{"Add":" }"},{"Add":" YY_BREAK"},{"Add":" case YY_STATE_EOF(INITIAL):"},{"Add":" case YY_STATE_EOF(STRING):"},{"Add":"#line 127 \"ast.flex\""},{"Add":" {"},{"Add":" yyterminate();"},{"Add":" }"},{"Add":" YY_BREAK"},{"Add":" case 47:"},{"Add":" YY_RULE_SETUP"},{"Add":"#line 129 \"ast.flex\""},{"Add":" ECHO;"},{"Add":" YY_BREAK"},{"Add":"#line 1031 \"ast-lex.cc\""},{"Add":""},{"Add":" case YY_END_OF_BUFFER: {"},{"Add":" /* Amount of text matched not including the EOB char. */"},{"Add":" int yy_amount_of_matched_text = (int)(yy_cp - yytext_ptr) - 1;"},{"Add":""},{"Add":" /* Undo the effects of YY_DO_BEFORE_ACTION. */"},{"Add":" *yy_cp = yy_hold_char;"},{"Add":" YY_RESTORE_YY_MORE_OFFSET"},{"Add":""},{"Add":" if (yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW) {"},{"Add":" /* We're scanning a new file or input source. It's"},{"Add":" * possible that this happened because the user"},{"Add":" * just pointed yyin at a new source and called"},{"Add":" * yylex(). If so, then we have to assure"},{"Add":" * consistency between yy_current_buffer and our"},{"Add":" * globals. Here is the right place to do so, because"},{"Add":" * this is the first action (other than possibly a"},{"Add":" * back-up) that will match for the new input source."},{"Add":" */"},{"Add":" yy_n_chars = yy_current_buffer->yy_n_chars;"},{"Add":" yy_current_buffer->yy_input_file = yyin;"},{"Add":" yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;"},{"Add":" }"},{"Add":""},{"Add":" /* Note that here we test for yy_c_buf_p \"<=\" to the position"},{"Add":" * of the first EOB in the buffer, since yy_c_buf_p will"},{"Add":" * already have been incremented past the NUL character"},{"Add":" * (since all states make transitions on EOB to the"},{"Add":" * end-of-buffer state). Contrast this with the test"},{"Add":" * in input()."},{"Add":" */"},{"Add":" if (yy_c_buf_p <="},{"Add":" &yy_current_buffer"},{"Add":" ->yy_ch_buf[yy_n_chars]) { /* This was really a NUL. */"},{"Add":" yy_state_type yy_next_state;"},{"Add":""},{"Add":" yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;"},{"Add":""},{"Add":" yy_current_state = yy_get_previous_state();"},{"Add":""},{"Add":" /* Okay, we're now positioned to make the NUL"},{"Add":" * transition. We couldn't have"},{"Add":" * yy_get_previous_state() go ahead and do it"},{"Add":" * for us because it doesn't know how to deal"},{"Add":" * with the possibility of jamming (and we don't"},{"Add":" * want to build jamming into it because then it"},{"Add":" * will run more slowly)."},{"Add":" */"},{"Add":""},{"Add":" yy_next_state = yy_try_NUL_trans(yy_current_state);"},{"Add":""},{"Add":" yy_bp = yytext_ptr + YY_MORE_ADJ;"},{"Add":""},{"Add":" if (yy_next_state) {"},{"Add":" /* Consume the NUL. */"},{"Add":" yy_cp = ++yy_c_buf_p;"},{"Add":" yy_current_state = yy_next_state;"},{"Add":" goto yy_match;"},{"Add":" }"},{"Add":""},{"Add":" else {"},{"Add":" yy_cp = yy_c_buf_p;"},{"Add":" goto yy_find_action;"},{"Add":" }"},{"Add":" }"},{"Add":""},{"Add":" else"},{"Add":" switch (yy_get_next_buffer()) {"},{"Add":" case EOB_ACT_END_OF_FILE: {"},{"Add":" yy_did_buffer_switch_on_eof = 0;"},{"Add":""},{"Add":" if (yywrap()) {"},{"Add":" /* Note: because we've taken care in"},{"Add":" * yy_get_next_buffer() to have set up"},{"Add":" * yytext, we can now set up"},{"Add":" * yy_c_buf_p so that if some total"},{"Add":" * hoser (like flex itself) wants to"},{"Add":" * call the scanner after we return the"},{"Add":" * YY_NULL, it'll still work - another"},{"Add":" * YY_NULL will get returned."},{"Add":" */"},{"Add":" yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;"},{"Add":""},{"Add":" yy_act = YY_STATE_EOF(YY_START);"},{"Add":" goto do_action;"},{"Add":" }"},{"Add":""},{"Add":" else {"},{"Add":" if (!yy_did_buffer_switch_on_eof)"},{"Add":" YY_NEW_FILE;"},{"Add":" }"},{"Add":" break;"},{"Add":" }"},{"Add":""},{"Add":" case EOB_ACT_CONTINUE_SCAN:"},{"Add":" yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;"},{"Add":""},{"Add":" yy_current_state = yy_get_previous_state();"},{"Add":""},{"Add":" yy_cp = yy_c_buf_p;"},{"Add":" yy_bp = yytext_ptr + YY_MORE_ADJ;"},{"Add":" goto yy_match;"},{"Add":""},{"Add":" case EOB_ACT_LAST_MATCH:"},{"Add":" yy_c_buf_p = &yy_current_buffer->yy_ch_buf[yy_n_chars];"},{"Add":""},{"Add":" yy_current_state = yy_get_previous_state();"},{"Add":""},{"Add":" yy_cp = yy_c_buf_p;"},{"Add":" yy_bp = yytext_ptr + YY_MORE_ADJ;"},{"Add":" goto yy_find_action;"},{"Add":" }"},{"Add":" break;"},{"Add":" }"},{"Add":""},{"Add":" default:"},{"Add":" YY_FATAL_ERROR(\"fatal flex scanner internal error--no action found\");"},{"Add":" } /* end of action switch */"},{"Add":" } /* end of scanning one token */"},{"Add":"} /* end of yylex */"},{"Add":""},{"Add":"/* yy_get_next_buffer - try to read in a new buffer"},{"Add":" *"},{"Add":" * Returns a code representing an action:"},{"Add":" *\tEOB_ACT_LAST_MATCH -"},{"Add":" *\tEOB_ACT_CONTINUE_SCAN - continue scanning from current position"},{"Add":" *\tEOB_ACT_END_OF_FILE - end of file"},{"Add":" */"},{"Add":""},{"Add":"static int yy_get_next_buffer() {"},{"Add":" register char *dest = yy_current_buffer->yy_ch_buf;"},{"Add":" register char *source = yytext_ptr;"},{"Add":" register int number_to_move, i;"},{"Add":" int ret_val;"},{"Add":""},{"Add":" if (yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1])"},{"Add":" YY_FATAL_ERROR(\"fatal flex scanner internal error--end of buffer missed\");"},{"Add":""},{"Add":" if (yy_current_buffer->yy_fill_buffer =="},{"Add":" 0) { /* Don't try to fill the buffer, so this is an EOF. */"},{"Add":" if (yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1) {"},{"Add":" /* We matched a single character, the EOB, so"},{"Add":" * treat this as a final EOF."},{"Add":" */"},{"Add":" return EOB_ACT_END_OF_FILE;"},{"Add":" }"},{"Add":""},{"Add":" else {"},{"Add":" /* We matched some text prior to the EOB, first"},{"Add":" * process it."},{"Add":" */"},{"Add":" return EOB_ACT_LAST_MATCH;"},{"Add":" }"},{"Add":" }"},{"Add":""},{"Add":" /* Try to read more data. */"},{"Add":""},{"Add":" /* First move last chars to start of buffer. */"},{"Add":" number_to_move = (int)(yy_c_buf_p - yytext_ptr) - 1;"},{"Add":""},{"Add":" for (i = 0; i < number_to_move; ++i)"},{"Add":" *(dest++) = *(source++);"},{"Add":""},{"Add":" if (yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING)"},{"Add":" /* don't do the read, it's not guaranteed to return an EOF,"},{"Add":" * just force an EOF"},{"Add":" */"},{"Add":" yy_current_buffer->yy_n_chars = yy_n_chars = 0;"},{"Add":""},{"Add":" else {"},{"Add":" int num_to_read = yy_current_buffer->yy_buf_size - number_to_move - 1;"},{"Add":""},{"Add":" while (num_to_read <= 0) { /* Not enough room in the buffer - grow it. */"},{"Add":"#ifdef YY_USES_REJECT"},{"Add":" YY_FATAL_ERROR(\"input buffer overflow, can't enlarge buffer because \""},{"Add":" \"scanner uses REJECT\");"},{"Add":"#else"},{"Add":""},{"Add":" /* just a shorter name for the current buffer */"},{"Add":" YY_BUFFER_STATE b = yy_current_buffer;"},{"Add":""},{"Add":" int yy_c_buf_p_offset = (int)(yy_c_buf_p - b->yy_ch_buf);"},{"Add":""},{"Add":" if (b->yy_is_our_buffer) {"},{"Add":" int new_size = b->yy_buf_size * 2;"},{"Add":""},{"Add":" if (new_size <= 0)"},{"Add":" b->yy_buf_size += b->yy_buf_size / 8;"},{"Add":" else"},{"Add":" b->yy_buf_size *= 2;"},{"Add":""},{"Add":" b->yy_ch_buf = (char *)"},{"Add":" /* Include room in for 2 EOB chars. */"},{"Add":" yy_flex_realloc((void *)b->yy_ch_buf, b->yy_buf_size + 2);"},{"Add":" } else"},{"Add":" /* Can't grow it, we don't own it. */"},{"Add":" b->yy_ch_buf = 0;"},{"Add":""},{"Add":" if (!b->yy_ch_buf)"},{"Add":" YY_FATAL_ERROR(\"fatal error - scanner input buffer overflow\");"},{"Add":""},{"Add":" yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];"},{"Add":""},{"Add":" num_to_read = yy_current_buffer->yy_buf_size - number_to_move - 1;"},{"Add":"#endif"},{"Add":" }"},{"Add":""},{"Add":" if (num_to_read > YY_READ_BUF_SIZE)"},{"Add":" num_to_read = YY_READ_BUF_SIZE;"},{"Add":""},{"Add":" /* Read in more data. */"},{"Add":" YY_INPUT((&yy_current_buffer->yy_ch_buf[number_to_move]), yy_n_chars,"},{"Add":" num_to_read);"},{"Add":""},{"Add":" yy_current_buffer->yy_n_chars = yy_n_chars;"},{"Add":" }"},{"Add":""},{"Add":" if (yy_n_chars == 0) {"},{"Add":" if (number_to_move == YY_MORE_ADJ) {"},{"Add":" ret_val = EOB_ACT_END_OF_FILE;"},{"Add":" yyrestart(yyin);"},{"Add":" }"},{"Add":""},{"Add":" else {"},{"Add":" ret_val = EOB_ACT_LAST_MATCH;"},{"Add":" yy_current_buffer->yy_buffer_status = YY_BUFFER_EOF_PENDING;"},{"Add":" }"},{"Add":" }"},{"Add":""},{"Add":" else"},{"Add":" ret_val = EOB_ACT_CONTINUE_SCAN;"},{"Add":""},{"Add":" yy_n_chars += number_to_move;"},{"Add":" yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;"},{"Add":" yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;"},{"Add":""},{"Add":" yytext_ptr = &yy_current_buffer->yy_ch_buf[0];"},{"Add":""},{"Add":" return ret_val;"},{"Add":"}"},{"Add":""},{"Add":"/* yy_get_previous_state - get the state just before the EOB char was reached */"},{"Add":""},{"Add":"static yy_state_type yy_get_previous_state() {"},{"Add":" register yy_state_type yy_current_state;"},{"Add":" register char *yy_cp;"},{"Add":""},{"Add":" yy_current_state = yy_start;"},{"Add":""},{"Add":" for (yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp) {"},{"Add":" register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);"},{"Add":" if (yy_accept[yy_current_state]) {"},{"Add":" yy_last_accepting_state = yy_current_state;"},{"Add":" yy_last_accepting_cpos = yy_cp;"},{"Add":" }"},{"Add":" while (yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state) {"},{"Add":" yy_current_state = (int)yy_def[yy_current_state];"},{"Add":" if (yy_current_state >= 163)"},{"Add":" yy_c = yy_meta[(unsigned int)yy_c];"},{"Add":" }"},{"Add":" yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int)yy_c];"},{"Add":" }"},{"Add":""},{"Add":" return yy_current_state;"},{"Add":"}"},{"Add":""},{"Add":"/* yy_try_NUL_trans - try to make a transition on the NUL character"},{"Add":" *"},{"Add":" * synopsis"},{"Add":" *\tnext_state = yy_try_NUL_trans( current_state );"},{"Add":" */"},{"Add":""},{"Add":"#ifdef YY_USE_PROTOS"},{"Add":"static yy_state_type yy_try_NUL_trans(yy_state_type yy_current_state)"},{"Add":"#else"},{"Add":"static yy_state_type"},{"Add":" yy_try_NUL_trans(yy_current_state) yy_state_type yy_current_state;"},{"Add":"#endif"},{"Add":"{"},{"Add":" register int yy_is_jam;"},{"Add":" register char *yy_cp = yy_c_buf_p;"},{"Add":""},{"Add":" register YY_CHAR yy_c = 1;"},{"Add":" if (yy_accept[yy_current_state]) {"},{"Add":" yy_last_accepting_state = yy_current_state;"},{"Add":" yy_last_accepting_cpos = yy_cp;"},{"Add":" }"},{"Add":" while (yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state) {"},{"Add":" yy_current_state = (int)yy_def[yy_current_state];"},{"Add":" if (yy_current_state >= 163)"},{"Add":" yy_c = yy_meta[(unsigned int)yy_c];"},{"Add":" }"},{"Add":" yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int)yy_c];"},{"Add":" yy_is_jam = (yy_current_state == 162);"},{"Add":""},{"Add":" return yy_is_jam ? 0 : yy_current_state;"},{"Add":"}"},{"Add":""},{"Add":"#ifndef YY_NO_UNPUT"},{"Add":"#ifdef YY_USE_PROTOS"},{"Add":"static void yyunput(int c, register char *yy_bp)"},{"Add":"#else"},{"Add":"static void yyunput(c, yy_bp) int c;"},{"Add":"register char *yy_bp;"},{"Add":"#endif"},{"Add":"{"},{"Add":" register char *yy_cp = yy_c_buf_p;"},{"Add":""},{"Add":" /* undo effects of setting up yytext */"},{"Add":" *yy_cp = yy_hold_char;"},{"Add":""},{"Add":" if (yy_cp < yy_current_buffer->yy_ch_buf +"},{"Add":" 2) { /* need to shift things up to make room */"},{"Add":" /* +2 for EOB chars. */"},{"Add":" register int number_to_move = yy_n_chars + 2;"},{"Add":" register char *dest ="},{"Add":" &yy_current_buffer->yy_ch_buf[yy_current_buffer->yy_buf_size + 2];"},{"Add":" register char *source = &yy_current_buffer->yy_ch_buf[number_to_move];"},{"Add":""},{"Add":" while (source > yy_current_buffer->yy_ch_buf)"},{"Add":" *--dest = *--source;"},{"Add":""},{"Add":" yy_cp += (int)(dest - source);"},{"Add":" yy_bp += (int)(dest - source);"},{"Add":" yy_current_buffer->yy_n_chars = yy_n_chars = yy_current_buffer->yy_buf_size;"},{"Add":""},{"Add":" if (yy_cp < yy_current_buffer->yy_ch_buf + 2)"},{"Add":" YY_FATAL_ERROR(\"flex scanner push-back overflow\");"},{"Add":" }"},{"Add":""},{"Add":" *--yy_cp = (char)c;"},{"Add":""},{"Add":" yytext_ptr = yy_bp;"},{"Add":" yy_hold_char = *yy_cp;"},{"Add":" yy_c_buf_p = yy_cp;"},{"Add":"}"},{"Add":"#endif /* ifndef YY_NO_UNPUT */"},{"Add":""},{"Add":"#ifndef YY_NO_INPUT"},{"Add":"#ifdef __cplusplus"},{"Add":"static int yyinput()"},{"Add":"#else"},{"Add":"static int input()"},{"Add":"#endif"},{"Add":"{"},{"Add":" int c;"},{"Add":""},{"Add":" *yy_c_buf_p = yy_hold_char;"},{"Add":""},{"Add":" if (*yy_c_buf_p == YY_END_OF_BUFFER_CHAR) {"},{"Add":" /* yy_c_buf_p now points to the character we want to return."},{"Add":" * If this occurs *before* the EOB characters, then it's a"},{"Add":" * valid NUL; if not, then we've hit the end of the buffer."},{"Add":" */"},{"Add":" if (yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars])"},{"Add":" /* This was really a NUL. */"},{"Add":" *yy_c_buf_p = '\\0';"},{"Add":""},{"Add":" else { /* need more input */"},{"Add":" int offset = yy_c_buf_p - yytext_ptr;"},{"Add":" ++yy_c_buf_p;"},{"Add":""},{"Add":" switch (yy_get_next_buffer()) {"},{"Add":" case EOB_ACT_LAST_MATCH:"},{"Add":" /* This happens because yy_g_n_b()"},{"Add":" * sees that we've accumulated a"},{"Add":" * token and flags that we need to"},{"Add":" * try matching the token before"},{"Add":" * proceeding. But for input(),"},{"Add":" * there's no matching to consider."},{"Add":" * So convert the EOB_ACT_LAST_MATCH"},{"Add":" * to EOB_ACT_END_OF_FILE."},{"Add":" */"},{"Add":""},{"Add":" /* Reset buffer status. */"},{"Add":" yyrestart(yyin);"},{"Add":""},{"Add":" /* fall through */"},{"Add":""},{"Add":" case EOB_ACT_END_OF_FILE: {"},{"Add":" if (yywrap())"},{"Add":" return EOF;"},{"Add":""},{"Add":" if (!yy_did_buffer_switch_on_eof)"},{"Add":" YY_NEW_FILE;"},{"Add":"#ifdef __cplusplus"},{"Add":" return yyinput();"},{"Add":"#else"},{"Add":" return input();"},{"Add":"#endif"},{"Add":" }"},{"Add":""},{"Add":" case EOB_ACT_CONTINUE_SCAN:"},{"Add":" yy_c_buf_p = yytext_ptr + offset;"},{"Add":" break;"},{"Add":" }"},{"Add":" }"},{"Add":" }"},{"Add":""},{"Add":" c = *(unsigned char *)yy_c_buf_p; /* cast for 8-bit char's */"},{"Add":" *yy_c_buf_p = '\\0'; /* preserve yytext */"},{"Add":" yy_hold_char = *++yy_c_buf_p;"},{"Add":""},{"Add":" return c;"},{"Add":"}"},{"Add":"#endif /* YY_NO_INPUT */"},{"Add":""},{"Add":"#ifdef YY_USE_PROTOS"},{"Add":"void yyrestart(FILE *input_file)"},{"Add":"#else"},{"Add":"void yyrestart(input_file) FILE *input_file;"},{"Add":"#endif"},{"Add":"{"},{"Add":" if (!yy_current_buffer)"},{"Add":" yy_current_buffer = yy_create_buffer(yyin, YY_BUF_SIZE);"},{"Add":""},{"Add":" yy_init_buffer(yy_current_buffer, input_file);"},{"Add":" yy_load_buffer_state();"},{"Add":"}"},{"Add":""},{"Add":"#ifdef YY_USE_PROTOS"},{"Add":"void yy_switch_to_buffer(YY_BUFFER_STATE new_buffer)"},{"Add":"#else"},{"Add":"void yy_switch_to_buffer(new_buffer) YY_BUFFER_STATE new_buffer;"},{"Add":"#endif"},{"Add":"{"},{"Add":" if (yy_current_buffer == new_buffer)"},{"Add":" return;"},{"Add":""},{"Add":" if (yy_current_buffer) {"},{"Add":" /* Flush out information for old buffer. */"},{"Add":" *yy_c_buf_p = yy_hold_char;"},{"Add":" yy_current_buffer->yy_buf_pos = yy_c_buf_p;"},{"Add":" yy_current_buffer->yy_n_chars = yy_n_chars;"},{"Add":" }"},{"Add":""},{"Add":" yy_current_buffer = new_buffer;"},{"Add":" yy_load_buffer_state();"},{"Add":""},{"Add":" /* We don't actually know whether we did this switch during"},{"Add":" * EOF (yywrap()) processing, but the only time this flag"},{"Add":" * is looked at is after yywrap() is called, so it's safe"},{"Add":" * to go ahead and always set it."},{"Add":" */"},{"Add":" yy_did_buffer_switch_on_eof = 1;"},{"Add":"}"},{"Add":""},{"Add":"#ifdef YY_USE_PROTOS"},{"Add":"void yy_load_buffer_state(void)"},{"Add":"#else"},{"Add":"void yy_load_buffer_state()"},{"Add":"#endif"},{"Add":"{"},{"Add":" yy_n_chars = yy_current_buffer->yy_n_chars;"},{"Add":" yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;"},{"Add":" yyin = yy_current_buffer->yy_input_file;"},{"Add":" yy_hold_char = *yy_c_buf_p;"},{"Add":"}"},{"Add":""},{"Add":"#ifdef YY_USE_PROTOS"},{"Add":"YY_BUFFER_STATE yy_create_buffer(FILE *file, int size)"},{"Add":"#else"},{"Add":"YY_BUFFER_STATE yy_create_buffer(file, size) FILE *file;"},{"Add":"int size;"},{"Add":"#endif"},{"Add":"{"},{"Add":" YY_BUFFER_STATE b;"},{"Add":""},{"Add":" b = (YY_BUFFER_STATE)yy_flex_alloc(sizeof(struct yy_buffer_state));"},{"Add":" if (!b)"},{"Add":" YY_FATAL_ERROR(\"out of dynamic memory in yy_create_buffer()\");"},{"Add":""},{"Add":" b->yy_buf_size = size;"},{"Add":""},{"Add":" /* yy_ch_buf has to be 2 characters longer than the size given because"},{"Add":" * we need to put in 2 end-of-buffer characters."},{"Add":" */"},{"Add":" b->yy_ch_buf = (char *)yy_flex_alloc(b->yy_buf_size + 2);"},{"Add":" if (!b->yy_ch_buf)"},{"Add":" YY_FATAL_ERROR(\"out of dynamic memory in yy_create_buffer()\");"},{"Add":""},{"Add":" b->yy_is_our_buffer = 1;"},{"Add":""},{"Add":" yy_init_buffer(b, file);"},{"Add":""},{"Add":" return b;"},{"Add":"}"},{"Add":""},{"Add":"#ifdef YY_USE_PROTOS"},{"Add":"void yy_delete_buffer(YY_BUFFER_STATE b)"},{"Add":"#else"},{"Add":"void yy_delete_buffer(b) YY_BUFFER_STATE b;"},{"Add":"#endif"},{"Add":"{"},{"Add":" if (!b)"},{"Add":" return;"},{"Add":""},{"Add":" if (b == yy_current_buffer)"},{"Add":" yy_current_buffer = (YY_BUFFER_STATE)0;"},{"Add":""},{"Add":" if (b->yy_is_our_buffer)"},{"Add":" yy_flex_free((void *)b->yy_ch_buf);"},{"Add":""},{"Add":" yy_flex_free((void *)b);"},{"Add":"}"},{"Add":""},{"Add":"#ifdef YY_USE_PROTOS"},{"Add":"void yy_init_buffer(YY_BUFFER_STATE b, FILE *file)"},{"Add":"#else"},{"Add":"void yy_init_buffer(b, file) YY_BUFFER_STATE b;"},{"Add":"FILE *file;"},{"Add":"#endif"},{"Add":""},{"Add":"{"},{"Add":" yy_flush_buffer(b);"},{"Add":""},{"Add":" b->yy_input_file = file;"},{"Add":" b->yy_fill_buffer = 1;"},{"Add":""},{"Add":"#if YY_ALWAYS_INTERACTIVE"},{"Add":" b->yy_is_interactive = 1;"},{"Add":"#else"},{"Add":"#if YY_NEVER_INTERACTIVE"},{"Add":" b->yy_is_interactive = 0;"},{"Add":"#else"},{"Add":" b->yy_is_interactive = file ? (isatty(fileno(file)) > 0) : 0;"},{"Add":"#endif"},{"Add":"#endif"},{"Add":"}"},{"Add":""},{"Add":"#ifdef YY_USE_PROTOS"},{"Add":"void yy_flush_buffer(YY_BUFFER_STATE b)"},{"Add":"#else"},{"Add":"void yy_flush_buffer(b) YY_BUFFER_STATE b;"},{"Add":"#endif"},{"Add":""},{"Add":"{"},{"Add":" if (!b)"},{"Add":" return;"},{"Add":""},{"Add":" b->yy_n_chars = 0;"},{"Add":""},{"Add":" /* We always need two end-of-buffer characters. The first causes"},{"Add":" * a transition to the end-of-buffer state. The second causes"},{"Add":" * a jam in that state."},{"Add":" */"},{"Add":" b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;"},{"Add":" b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;"},{"Add":""},{"Add":" b->yy_buf_pos = &b->yy_ch_buf[0];"},{"Add":""},{"Add":" b->yy_at_bol = 1;"},{"Add":" b->yy_buffer_status = YY_BUFFER_NEW;"},{"Add":""},{"Add":" if (b == yy_current_buffer)"},{"Add":" yy_load_buffer_state();"},{"Add":"}"},{"Add":""},{"Add":"#ifndef YY_NO_SCAN_BUFFER"},{"Add":"#ifdef YY_USE_PROTOS"},{"Add":"YY_BUFFER_STATE yy_scan_buffer(char *base, yy_size_t size)"},{"Add":"#else"},{"Add":"YY_BUFFER_STATE yy_scan_buffer(base, size) char *base;"},{"Add":"yy_size_t size;"},{"Add":"#endif"},{"Add":"{"},{"Add":" YY_BUFFER_STATE b;"},{"Add":""},{"Add":" if (size < 2 || base[size - 2] != YY_END_OF_BUFFER_CHAR ||"},{"Add":" base[size - 1] != YY_END_OF_BUFFER_CHAR)"},{"Add":" /* They forgot to leave room for the EOB's. */"},{"Add":" return 0;"},{"Add":""},{"Add":" b = (YY_BUFFER_STATE)yy_flex_alloc(sizeof(struct yy_buffer_state));"},{"Add":" if (!b)"},{"Add":" YY_FATAL_ERROR(\"out of dynamic memory in yy_scan_buffer()\");"},{"Add":""},{"Add":" b->yy_buf_size = size - 2; /* \"- 2\" to take care of EOB's */"},{"Add":" b->yy_buf_pos = b->yy_ch_buf = base;"},{"Add":" b->yy_is_our_buffer = 0;"},{"Add":" b->yy_input_file = 0;"},{"Add":" b->yy_n_chars = b->yy_buf_size;"},{"Add":" b->yy_is_interactive = 0;"},{"Add":" b->yy_at_bol = 1;"},{"Add":" b->yy_fill_buffer = 0;"},{"Add":" b->yy_buffer_status = YY_BUFFER_NEW;"},{"Add":""},{"Add":" yy_switch_to_buffer(b);"},{"Add":""},{"Add":" return b;"},{"Add":"}"},{"Add":"#endif"},{"Add":""},{"Add":"#ifndef YY_NO_SCAN_STRING"},{"Add":"#ifdef YY_USE_PROTOS"},{"Add":"YY_BUFFER_STATE yy_scan_string(yyconst char *yy_str)"},{"Add":"#else"},{"Add":"YY_BUFFER_STATE yy_scan_string(yy_str) yyconst char *yy_str;"},{"Add":"#endif"},{"Add":"{"},{"Add":" int len;"},{"Add":" for (len = 0; yy_str[len]; ++len)"},{"Add":" ;"},{"Add":""},{"Add":" return yy_scan_bytes(yy_str, len);"},{"Add":"}"},{"Add":"#endif"},{"Add":""},{"Add":"#ifndef YY_NO_SCAN_BYTES"},{"Add":"#ifdef YY_USE_PROTOS"},{"Add":"YY_BUFFER_STATE yy_scan_bytes(yyconst char *bytes, int len)"},{"Add":"#else"},{"Add":"YY_BUFFER_STATE yy_scan_bytes(bytes, len) yyconst char *bytes;"},{"Add":"int len;"},{"Add":"#endif"},{"Add":"{"},{"Add":" YY_BUFFER_STATE b;"},{"Add":" char *buf;"},{"Add":" yy_size_t n;"},{"Add":" int i;"},{"Add":""},{"Add":" /* Get memory for full buffer, including space for trailing EOB's. */"},{"Add":" n = len + 2;"},{"Add":" buf = (char *)yy_flex_alloc(n);"},{"Add":" if (!buf)"},{"Add":" YY_FATAL_ERROR(\"out of dynamic memory in yy_scan_bytes()\");"},{"Add":""},{"Add":" for (i = 0; i < len; ++i)"},{"Add":" buf[i] = bytes[i];"},{"Add":""},{"Add":" buf[len] = buf[len + 1] = YY_END_OF_BUFFER_CHAR;"},{"Add":""},{"Add":" b = yy_scan_buffer(buf, n);"},{"Add":" if (!b)"},{"Add":" YY_FATAL_ERROR(\"bad buffer in yy_scan_bytes()\");"},{"Add":""},{"Add":" /* It's okay to grow etc. this buffer, and we should throw it"},{"Add":" * away when we're done."},{"Add":" */"},{"Add":" b->yy_is_our_buffer = 1;"},{"Add":""},{"Add":" return b;"},{"Add":"}"},{"Add":"#endif"},{"Add":""},{"Add":"#ifndef YY_NO_PUSH_STATE"},{"Add":"#ifdef YY_USE_PROTOS"},{"Add":"static void yy_push_state(int new_state)"},{"Add":"#else"},{"Add":"static void yy_push_state(new_state) int new_state;"},{"Add":"#endif"},{"Add":"{"},{"Add":" if (yy_start_stack_ptr >= yy_start_stack_depth) {"},{"Add":" yy_size_t new_size;"},{"Add":""},{"Add":" yy_start_stack_depth += YY_START_STACK_INCR;"},{"Add":" new_size = yy_start_stack_depth * sizeof(int);"},{"Add":""},{"Add":" if (!yy_start_stack)"},{"Add":" yy_start_stack = (int *)yy_flex_alloc(new_size);"},{"Add":""},{"Add":" else"},{"Add":" yy_start_stack = (int *)yy_flex_realloc((void *)yy_start_stack, new_size);"},{"Add":""},{"Add":" if (!yy_start_stack)"},{"Add":" YY_FATAL_ERROR(\"out of memory expanding start-condition stack\");"},{"Add":" }"},{"Add":""},{"Add":" yy_start_stack[yy_start_stack_ptr++] = YY_START;"},{"Add":""},{"Add":" BEGIN(new_state);"},{"Add":"}"},{"Add":"#endif"},{"Add":""},{"Add":"#ifndef YY_NO_POP_STATE"},{"Add":"static void yy_pop_state() {"},{"Add":" if (--yy_start_stack_ptr < 0)"},{"Add":" YY_FATAL_ERROR(\"start-condition stack underflow\");"},{"Add":""},{"Add":" BEGIN(yy_start_stack[yy_start_stack_ptr]);"},{"Add":"}"},{"Add":"#endif"},{"Add":""},{"Add":"#ifndef YY_NO_TOP_STATE"},{"Add":"static int yy_top_state() { return yy_start_stack[yy_start_stack_ptr - 1]; }"},{"Add":"#endif"},{"Add":""},{"Add":"#ifndef YY_EXIT_FAILURE"},{"Add":"#define YY_EXIT_FAILURE 2"},{"Add":"#endif"},{"Add":""},{"Add":"#ifdef YY_USE_PROTOS"},{"Add":"static void yy_fatal_error(yyconst char msg[])"},{"Add":"#else"},{"Add":"static void yy_fatal_error(msg) char msg[];"},{"Add":"#endif"},{"Add":"{"},{"Add":" (void)fprintf(stderr, \"%s\\n\", msg);"},{"Add":" exit(YY_EXIT_FAILURE);"},{"Add":"}"},{"Add":""},{"Add":"/* Redefine yyless() so it works in section 3 code. */"},{"Add":""},{"Add":"#undef yyless"},{"Add":"#define yyless(n) \\"},{"Add":" do { \\"},{"Add":" /* Undo effects of setting up yytext. */ \\"},{"Add":" yytext[yyleng] = yy_hold_char; \\"},{"Add":" yy_c_buf_p = yytext + n; \\"},{"Add":" yy_hold_char = *yy_c_buf_p; \\"},{"Add":" *yy_c_buf_p = '\\0'; \\"},{"Add":" yyleng = n; \\"},{"Add":" } while (0)"},{"Add":""},{"Add":"/* Internal utility routines. */"},{"Add":""},{"Add":"#ifndef yytext_ptr"},{"Add":"#ifdef YY_USE_PROTOS"},{"Add":"static void yy_flex_strncpy(char *s1, yyconst char *s2, int n)"},{"Add":"#else"},{"Add":"static void yy_flex_strncpy(s1, s2, n) char *s1;"},{"Add":"yyconst char *s2;"},{"Add":"int n;"},{"Add":"#endif"},{"Add":"{"},{"Add":" register int i;"},{"Add":" for (i = 0; i < n; ++i)"},{"Add":" s1[i] = s2[i];"},{"Add":"}"},{"Add":"#endif"},{"Add":""},{"Add":"#ifdef YY_NEED_STRLEN"},{"Add":"#ifdef YY_USE_PROTOS"},{"Add":"static int yy_flex_strlen(yyconst char *s)"},{"Add":"#else"},{"Add":"static int yy_flex_strlen(s) yyconst char *s;"},{"Add":"#endif"},{"Add":"{"},{"Add":" register int n;"},{"Add":" for (n = 0; s[n]; ++n)"},{"Add":" ;"},{"Add":""},{"Add":" return n;"},{"Add":"}"},{"Add":"#endif"},{"Add":""},{"Add":"#ifdef YY_USE_PROTOS"},{"Add":"static void *yy_flex_alloc(yy_size_t size)"},{"Add":"#else"},{"Add":"static void *yy_flex_alloc(size) yy_size_t size;"},{"Add":"#endif"},{"Add":"{"},{"Add":" return (void *)malloc(size);"},{"Add":"}"},{"Add":""},{"Add":"#ifdef YY_USE_PROTOS"},{"Add":"static void *yy_flex_realloc(void *ptr, yy_size_t size)"},{"Add":"#else"},{"Add":"static void *yy_flex_realloc(ptr, size) void *ptr;"},{"Add":"yy_size_t size;"},{"Add":"#endif"},{"Add":"{"},{"Add":" /* The cast to (char *) in the following accommodates both"},{"Add":" * implementations that use char* generic pointers, and those"},{"Add":" * that use void* generic pointers. It works with the latter"},{"Add":" * because both ANSI C and C++ allow castless assignment from"},{"Add":" * any pointer type to void*, and deal with argument conversions"},{"Add":" * as though doing an assignment."},{"Add":" */"},{"Add":" return (void *)realloc((char *)ptr, size);"},{"Add":"}"},{"Add":""},{"Add":"#ifdef YY_USE_PROTOS"},{"Add":"static void yy_flex_free(void *ptr)"},{"Add":"#else"},{"Add":"static void yy_flex_free(ptr) void *ptr;"},{"Add":"#endif"},{"Add":"{"},{"Add":" free(ptr);"},{"Add":"}"},{"Add":""},{"Add":"#if YY_MAIN"},{"Add":"int main() {"},{"Add":" yylex();"},{"Add":" return 0;"},{"Add":"}"},{"Add":"#endif"},{"Add":"#line 129 \"ast.flex\""}]}},{"FileAdd":{"meta":{"basename":"include","metadata":576},"context":[{"change":0,"pos":1}],"contents":[]}},{"FileAdd":{"meta":{"basename":"utils.h","metadata":0},"context":[{"change":0,"pos":222547}],"contents":[{"Add":"//"},{"Add":"// See copyright.h for copyright notice and limitation of liability"},{"Add":"// and disclaimer of warranty provisions."},{"Add":"//"},{"Add":"#include \"copyright.h\""},{"Add":""},{"Add":"#ifndef _UTILS_H_"},{"Add":"#define _UTILS_H_"},{"Add":""},{"Add":"#include \"stringtab.h\""},{"Add":"#include "},{"Add":""},{"Add":"std::string pad(int n);"},{"Add":"void print_escaped_string(std::ostream &str, const std::string &s);"},{"Add":"void dump_Boolean(std::ostream &stream, int padding, bool b);"},{"Add":"void dump_Symbol(std::ostream &s, int n, Symbol sym);"},{"Add":""},{"Add":"#endif"}]}},{"FileAdd":{"meta":{"basename":"tree.h","metadata":0},"context":[{"change":0,"pos":222547}],"contents":[{"Add":"//"},{"Add":"// See copyright.h for copyright notice and limitation of liability"},{"Add":"// and disclaimer of warranty provisions."},{"Add":"//"},{"Add":"#include \"copyright.h\""},{"Add":""},{"Add":"#ifndef TREE_H"},{"Add":"#define TREE_H"},{"Add":"///////////////////////////////////////////////////////////////////////////"},{"Add":"//"},{"Add":"// file: tree.h"},{"Add":"//"},{"Add":"// This file defines the basic class of tree node and list"},{"Add":"//"},{"Add":"///////////////////////////////////////////////////////////////////////////"},{"Add":""},{"Add":"#include \"utils.h\""},{"Add":"#include "},{"Add":""},{"Add":"/////////////////////////////////////////////////////////////////////"},{"Add":"//"},{"Add":"// tree_node"},{"Add":"//"},{"Add":"// All APS nodes are derived from tree_node. There is a"},{"Add":"// protected field:"},{"Add":"// int line_number line in the source file from which this node came;"},{"Add":"// this is read from a global variable when the"},{"Add":"// node is created."},{"Add":"//"},{"Add":"//"},{"Add":"//"},{"Add":"// The public methods are:"},{"Add":"// tree_node()"},{"Add":"// builds a new tree_node. The type field is NULL, the"},{"Add":"// line_number is set to the value of the global yylineno."},{"Add":"//"},{"Add":"// void dump(std::ostream& s,int n);"},{"Add":"// dump is a pretty printer for tree nodes. The std::ostream argument"},{"Add":"// is the output stream on which the node is to be printed; n is"},{"Add":"// the number of spaces to indent the output."},{"Add":"//"},{"Add":"// int get_line_number(); return the line number"},{"Add":"// Symbol get_type(); return the type"},{"Add":"//"},{"Add":"// tree_node *set(tree_node *t)"},{"Add":"// sets the line number and type of \"this\" to the values in"},{"Add":"// the argument tree_node. Returns \"this\"."},{"Add":"//"},{"Add":"//"},{"Add":"////////////////////////////////////////////////////////////////////////////"},{"Add":"class tree_node {"},{"Add":"protected:"},{"Add":" int line_number; // stash the line number when node is made"},{"Add":"public:"},{"Add":" tree_node();"},{"Add":" virtual tree_node *copy() = 0;"},{"Add":" virtual void dump(std::ostream &stream, int n) = 0;"},{"Add":" int get_line_number();"},{"Add":" tree_node *set(tree_node *);"},{"Add":" virtual ~tree_node() {}"},{"Add":"};"},{"Add":""},{"Add":"///////////////////////////////////////////////////////////////////"},{"Add":"//"},{"Add":"// Lists of APS objects are implemented by the \"list_node\""},{"Add":"// template. List elements have type Elem. The interface is:"},{"Add":"//"},{"Add":"// tree_node *copy()"},{"Add":"// list_node *copy_list()"},{"Add":"//"},{"Add":"// These functions have identical behavior; they return a deep"},{"Add":"// copy of the list (i.e., all elements of the list are copied)."},{"Add":"// When possible, the second function should be used, as it"},{"Add":"// has a more accurate result type. The \"copy\" function is for"},{"Add":"// copying an entire APS tree of which a list is just one component"},{"Add":"// (see the definition of copy() in class tree_node)."},{"Add":"//"},{"Add":"// Elem nth(int n);"},{"Add":"// returns the nth element of a list. If the list has fewer than n"},{"Add":"// elements, an error is generated."},{"Add":"//"},{"Add":"// int first();"},{"Add":"// int next(int n);"},{"Add":"// int more(int n);"},{"Add":"// These three functions define a simple iterator for stepping through"},{"Add":"// list elements in order. If l is a list, a typical use would be:"},{"Add":"//"},{"Add":"// for(int i = l->first(); l->more(i); i = l->next(i))"},{"Add":"// ... operate on l->nth(i) ..."},{"Add":"//"},{"Add":"//"},{"Add":"// int len()"},{"Add":"// returns the length of the list"},{"Add":"//"},{"Add":"// nth_length(int n, int &len);"},{"Add":"// Returns the nth element of the list or NULL if there are not n elements."},{"Add":"// \"len\" is set to the length of the list. This method is used internally"},{"Add":"// by the APS package to efficiently traverse the list representation."},{"Add":"//"},{"Add":"// static list_node *nil();"},{"Add":"// static list_node *single(Elem);"},{"Add":"// static list_node *append(list_node *, list_node *);"},{"Add":"//"},{"Add":"// These three functions construct an empty list, a list of one element,"},{"Add":"// and append two lists, respectively. Note that the functions are static;"},{"Add":"// there is no \"this\" parameter. Example uses:"},{"Add":"//"},{"Add":"// list_node::nil();"},{"Add":"// list_node::single(e); where \"e\" has type Elem"},{"Add":"// list_node::append(l1,l2);"},{"Add":"//"},{"Add":"//////////////////////////////////////////////////////////////////////////////"},{"Add":""},{"Add":"template class list_node;"},{"Add":""},{"Add":"template class list_node_iterator {"},{"Add":" list_node *list;"},{"Add":" int index;"},{"Add":""},{"Add":"public:"},{"Add":" list_node_iterator(list_node *list_) : list(list_), index(0) {}"},{"Add":" list_node_iterator(list_node *list_, int index_)"},{"Add":" : list(list_), index(index_) {}"},{"Add":""},{"Add":" list_node_iterator &operator++() {"},{"Add":" ++index;"},{"Add":" return *this;"},{"Add":" }"},{"Add":" Elem operator*() const { return list->nth(index); }"},{"Add":" bool operator!=(const list_node_iterator &rhs) const {"},{"Add":" return index != rhs.index;"},{"Add":" }"},{"Add":"};"},{"Add":""},{"Add":"template class list_node : public tree_node {"},{"Add":"public:"},{"Add":" tree_node *copy() { return copy_list(); }"},{"Add":" Elem nth(int n);"},{"Add":" //"},{"Add":" // The next three define a simple iterator."},{"Add":" //"},{"Add":" int first() { return 0; }"},{"Add":" int next(int n) { return n + 1; }"},{"Add":" int more(int n) { return (n < len()); }"},{"Add":""},{"Add":" virtual list_node *copy_list() = 0;"},{"Add":" virtual int len() = 0;"},{"Add":" virtual Elem nth_length(int n, int &len) = 0;"},{"Add":""},{"Add":" static list_node *nil();"},{"Add":" static list_node *single(Elem);"},{"Add":" static list_node *append(list_node *l1, list_node *l2);"},{"Add":"};"},{"Add":"template list_node_iterator begin(list_node &list) {"},{"Add":" return list_node_iterator(&list);"},{"Add":"}"},{"Add":""},{"Add":"template list_node_iterator end(list_node &list) {"},{"Add":" return list_node_iterator(&list, list.len());"},{"Add":"}"},{"Add":""},{"Add":"template list_node_iterator begin(list_node *list) {"},{"Add":" return list_node_iterator(list);"},{"Add":"}"},{"Add":""},{"Add":"template list_node_iterator end(list_node *list) {"},{"Add":" return list_node_iterator(list, list->len());"},{"Add":"}"},{"Add":""},{"Add":"template class nil_node : public list_node {"},{"Add":"public:"},{"Add":" list_node *copy_list();"},{"Add":" int len();"},{"Add":" Elem nth_length(int n, int &len);"},{"Add":" void dump(std::ostream &stream, int n);"},{"Add":"};"},{"Add":""},{"Add":"template class single_list_node : public list_node {"},{"Add":" Elem elem;"},{"Add":""},{"Add":"public:"},{"Add":" single_list_node(Elem t) { elem = t; }"},{"Add":" list_node *copy_list();"},{"Add":" int len();"},{"Add":" Elem nth_length(int n, int &len);"},{"Add":" void dump(std::ostream &stream, int n);"},{"Add":"};"},{"Add":""},{"Add":"template class append_node : public list_node {"},{"Add":"private:"},{"Add":" list_node *some, *rest;"},{"Add":""},{"Add":"public:"},{"Add":" append_node(list_node *l1, list_node *l2) {"},{"Add":" some = l1;"},{"Add":" rest = l2;"},{"Add":" }"},{"Add":" list_node *copy_list();"},{"Add":" int len();"},{"Add":" Elem nth_length(int n, int &len);"},{"Add":" void dump(std::ostream &stream, int n);"},{"Add":"};"},{"Add":""},{"Add":"template single_list_node *list(Elem x);"},{"Add":"template append_node *cons(Elem x, list_node *l);"},{"Add":"template append_node *xcons(list_node *l, Elem x);"},{"Add":""},{"Add":"template list_node *list_node::nil() {"},{"Add":" return new nil_node();"},{"Add":"}"},{"Add":"template list_node *list_node::single(Elem e) {"},{"Add":" return new single_list_node(e);"},{"Add":"}"},{"Add":"template "},{"Add":"list_node *list_node::append(list_node *l1,"},{"Add":" list_node *l2) {"},{"Add":" return new append_node(l1, l2);"},{"Add":"}"},{"Add":""},{"Add":"///////////////////////////////////////////////////////////////////////////"},{"Add":"//"},{"Add":"// list_node::nth"},{"Add":"//"},{"Add":"// function to find the nth element of the list"},{"Add":"//"},{"Add":"///////////////////////////////////////////////////////////////////////////"},{"Add":""},{"Add":"template Elem list_node::nth(int n) {"},{"Add":" int len;"},{"Add":" Elem tmp = nth_length(n, len);"},{"Add":""},{"Add":" if (tmp) {"},{"Add":" return tmp;"},{"Add":" }"},{"Add":" throw std::runtime_error(\"nth: outside the range of the list\");"},{"Add":"}"},{"Add":""},{"Add":"///////////////////////////////////////////////////////////////////////////"},{"Add":"//"},{"Add":"// nil_node::copy_list"},{"Add":"//"},{"Add":"// return the deep copy of the nil_node"},{"Add":"//"},{"Add":"///////////////////////////////////////////////////////////////////////////"},{"Add":"template list_node *nil_node::copy_list() {"},{"Add":" return new nil_node();"},{"Add":"}"},{"Add":""},{"Add":"///////////////////////////////////////////////////////////////////////////"},{"Add":"//"},{"Add":"// nil_node::len"},{"Add":"//"},{"Add":"// return the length of the nil_node"},{"Add":"//"},{"Add":"///////////////////////////////////////////////////////////////////////////"},{"Add":"template int nil_node::len() { return 0; }"},{"Add":""},{"Add":"///////////////////////////////////////////////////////////////////////////"},{"Add":"//"},{"Add":"// nil_node::nth_length"},{"Add":"//"},{"Add":"// return the nth element on the list"},{"Add":"//"},{"Add":"///////////////////////////////////////////////////////////////////////////"},{"Add":"template Elem nil_node::nth_length(int, int &len) {"},{"Add":" len = 0;"},{"Add":" return NULL;"},{"Add":"}"},{"Add":""},{"Add":"///////////////////////////////////////////////////////////////////////////"},{"Add":"//"},{"Add":"// nil_node::dump"},{"Add":"//"},{"Add":"// dump for list node"},{"Add":"//"},{"Add":"///////////////////////////////////////////////////////////////////////////"},{"Add":"template void nil_node::dump(std::ostream &stream, int n) {"},{"Add":" stream << pad(n) << \"(nil)\\n\";"},{"Add":"}"},{"Add":""},{"Add":"///////////////////////////////////////////////////////////////////////////"},{"Add":"//"},{"Add":"// single_list_node::copy_list"},{"Add":"//"},{"Add":"// return the deep copy of the single_list_node"},{"Add":"//"},{"Add":"///////////////////////////////////////////////////////////////////////////"},{"Add":"template list_node *single_list_node::copy_list() {"},{"Add":" return new single_list_node((Elem)elem->copy());"},{"Add":"}"},{"Add":""},{"Add":"///////////////////////////////////////////////////////////////////////////"},{"Add":"//"},{"Add":"// single_list_node::len"},{"Add":"//"},{"Add":"// return the length of the single_list_node"},{"Add":"//"},{"Add":"///////////////////////////////////////////////////////////////////////////"},{"Add":"template int single_list_node::len() { return 1; }"},{"Add":""},{"Add":"///////////////////////////////////////////////////////////////////////////"},{"Add":"//"},{"Add":"// single_list_node::nth_length"},{"Add":"//"},{"Add":"// return the nth element on the list"},{"Add":"//"},{"Add":"///////////////////////////////////////////////////////////////////////////"},{"Add":"template Elem single_list_node::nth_length(int n, int &len) {"},{"Add":" len = 1;"},{"Add":" if (n)"},{"Add":" return NULL;"},{"Add":" else"},{"Add":" return elem;"},{"Add":"}"},{"Add":""},{"Add":"///////////////////////////////////////////////////////////////////////////"},{"Add":"//"},{"Add":"// single_list_node::dump"},{"Add":"//"},{"Add":"// dump for list node"},{"Add":"//"},{"Add":"///////////////////////////////////////////////////////////////////////////"},{"Add":"template "},{"Add":"void single_list_node::dump(std::ostream &stream, int n) {"},{"Add":" elem->dump(stream, n);"},{"Add":"}"},{"Add":""},{"Add":"///////////////////////////////////////////////////////////////////////////"},{"Add":"//"},{"Add":"// append_node::copy_list"},{"Add":"//"},{"Add":"// return the deep copy of the append_node"},{"Add":"//"},{"Add":"///////////////////////////////////////////////////////////////////////////"},{"Add":"template list_node *append_node::copy_list() {"},{"Add":" return new append_node(some->copy_list(), rest->copy_list());"},{"Add":"}"},{"Add":""},{"Add":"///////////////////////////////////////////////////////////////////////////"},{"Add":"//"},{"Add":"// append_node::len"},{"Add":"//"},{"Add":"// return the length of the append_node"},{"Add":"//"},{"Add":"///////////////////////////////////////////////////////////////////////////"},{"Add":"template int append_node::len() {"},{"Add":" return some->len() + rest->len();"},{"Add":"}"},{"Add":""},{"Add":"///////////////////////////////////////////////////////////////////////////"},{"Add":"//"},{"Add":"// append_node::nth_length"},{"Add":"//"},{"Add":"// return the nth element on the list"},{"Add":"//"},{"Add":"///////////////////////////////////////////////////////////////////////////"},{"Add":"template Elem append_node::nth_length(int n, int &len) {"},{"Add":" int rlen;"},{"Add":" Elem tmp = some->nth_length(n, len);"},{"Add":""},{"Add":" if (!tmp) {"},{"Add":" tmp = rest->nth_length(n - len, rlen);"},{"Add":" len += rlen;"},{"Add":" }"},{"Add":" return tmp;"},{"Add":"}"},{"Add":""},{"Add":"///////////////////////////////////////////////////////////////////////////"},{"Add":"//"},{"Add":"// append_node::dump"},{"Add":"//"},{"Add":"// dump for list node"},{"Add":"//"},{"Add":"///////////////////////////////////////////////////////////////////////////"},{"Add":"template "},{"Add":"void append_node::dump(std::ostream &stream, int n) {"},{"Add":" int i, size;"},{"Add":""},{"Add":" size = len();"},{"Add":" stream << pad(n) << \"list\\n\";"},{"Add":" for (i = 0; i < size; i++)"},{"Add":" this->nth(i)->dump(stream, n + 2);"},{"Add":" stream << pad(n) << \"(end_of_list)\\n\";"},{"Add":"}"},{"Add":""},{"Add":"///////////////////////////////////////////////////////////////////////////"},{"Add":"//"},{"Add":"// list"},{"Add":"//"},{"Add":"///////////////////////////////////////////////////////////////////////////"},{"Add":"template single_list_node *list(Elem x) {"},{"Add":" return new single_list_node(x);"},{"Add":"}"},{"Add":""},{"Add":"///////////////////////////////////////////////////////////////////////////"},{"Add":"//"},{"Add":"// cons"},{"Add":"//"},{"Add":"///////////////////////////////////////////////////////////////////////////"},{"Add":"template append_node *cons(Elem x, list_node *l) {"},{"Add":" return new append_node(list(x), l);"},{"Add":"}"},{"Add":""},{"Add":"///////////////////////////////////////////////////////////////////////////"},{"Add":"//"},{"Add":"// xcons"},{"Add":"//"},{"Add":"///////////////////////////////////////////////////////////////////////////"},{"Add":"template append_node *xcons(list_node *l, Elem x) {"},{"Add":" return new append_node(l, list(x));"},{"Add":"}"},{"Add":""},{"Add":"#endif /* TREE_H */"}]}},{"FileAdd":{"meta":{"basename":"symtab.h","metadata":0},"context":[{"change":0,"pos":222547}],"contents":[{"Add":"//"},{"Add":"// See copyright.h for copyright notice and limitation of liability"},{"Add":"// and disclaimer of warranty provisions."},{"Add":"//"},{"Add":"#include \"copyright.h\""},{"Add":""},{"Add":"#ifndef _SYMTAB_H_"},{"Add":"#define _SYMTAB_H_"},{"Add":""},{"Add":"#include "},{"Add":"#include "},{"Add":"#include "},{"Add":""},{"Add":"// added to prevent clash with llvm::SymbolTable"},{"Add":"namespace cool {"},{"Add":""},{"Add":"// SymbolTable describes a symbol table mapping symbols of"},{"Add":"// type `K` to data of type `V`. It is implemented as a"},{"Add":"// vector of vectors of `SymtabEntry`."},{"Add":"//"},{"Add":"// `enterscope` makes the table point to a new scope whose parent"},{"Add":"// is the scope it pointed to previously."},{"Add":"//"},{"Add":"// `exitscope` makes the table point to the parent scope of the"},{"Add":"// current scope. Note that the old child scope is not"},{"Add":"// deallocated. One may save the state of a symbol table"},{"Add":"// at a given point by copying it with `operator =`"},{"Add":"//"},{"Add":"// `insert(k, v)` adds a symbol table entry to the current scope of"},{"Add":"// the symbol table mapping symbol `k` to data `v`."},{"Add":"//"},{"Add":"// `find_in_scopes(k)` looks for the symbol `k` in all scopes starting at the"},{"Add":"// top scope,"},{"Add":"// returning the data item associated with the entry, or nullptr if"},{"Add":"// not found."},{"Add":"//"},{"Add":"// `find(s)` looks for the symbol `k` in the current scope only."},{"Add":"//"},{"Add":"// `dump()` prints the symbols in the symbol table."},{"Add":"//"},{"Add":""},{"Add":"template class SymbolTable {"},{"Add":"private:"},{"Add":" using TableEntry = std::pair;"},{"Add":" using Scope = std::unordered_map;"},{"Add":""},{"Add":" std::vector scopes;"},{"Add":""},{"Add":"public:"},{"Add":" SymbolTable() = default;"},{"Add":""},{"Add":" void enterscope() { this->scopes.emplace_back(); }"},{"Add":""},{"Add":" void exitscope() {"},{"Add":" // It is an error to exit a scope that doesn't exist."},{"Add":" if (this->scopes.empty()) {"},{"Add":" throw std::runtime_error("},{"Add":" \"exitscope: Can't remove scope from an empty symbol table.\");"},{"Add":" }"},{"Add":" this->scopes.pop_back();"},{"Add":" }"},{"Add":""},{"Add":" void insert(const Symbol &k, V *v) {"},{"Add":" // There must be at least one scope to add a symbol."},{"Add":" if (this->scopes.empty()) {"},{"Add":" throw std::runtime_error(\"insert: Can't add a symbol without a scope.\");"},{"Add":" }"},{"Add":" if (v == nullptr) {"},{"Add":" throw std::runtime_error(\"insert: Can't add a nullptr value.\");"},{"Add":" }"},{"Add":" this->scopes.back().emplace(k, v);"},{"Add":" }"},{"Add":""},{"Add":" V *find(const Symbol &k) const {"},{"Add":" if (this->scopes.empty()) {"},{"Add":" throw std::runtime_error(\"probe: No scope in symbol table.\");"},{"Add":" }"},{"Add":" auto it = this->scopes.back().find(k);"},{"Add":" if (it == this->scopes.back().end()) {"},{"Add":" return nullptr;"},{"Add":" }"},{"Add":" return it->second;"},{"Add":" }"},{"Add":""},{"Add":" V *find_in_scopes(const Symbol &k) const {"},{"Add":" for (auto it = this->scopes.rbegin(); it != this->scopes.rend(); ++it) {"},{"Add":" auto entry = it->find(k);"},{"Add":" if (entry != it->end()) {"},{"Add":" return entry->second;"},{"Add":" }"},{"Add":" }"},{"Add":" return nullptr;"},{"Add":" }"},{"Add":""},{"Add":" void dump(std::ostream &s) const {"},{"Add":" s << \"SymbolTable(\\n\";"},{"Add":" for (auto &scope : this->scopes) {"},{"Add":" s << \" Scope(\\n\";"},{"Add":" for (auto &[k, v] : scope) {"},{"Add":" s << \" \" << k->get_string() << \" -> \" << v << \"\\n\";"},{"Add":" }"},{"Add":" s << \" )\\n\";"},{"Add":" }"},{"Add":" s << \")\\n\";"},{"Add":" }"},{"Add":"};"},{"Add":""},{"Add":"template "},{"Add":"std::ostream &operator<<(std::ostream &s, const SymbolTable &symtab) {"},{"Add":" symtab.dump(s);"},{"Add":" return s;"},{"Add":"}"},{"Add":""},{"Add":"} // namespace cool"},{"Add":""},{"Add":"#endif"}]}},{"FileAdd":{"meta":{"basename":"stringtab.handcode.h","metadata":0},"context":[{"change":0,"pos":222547}],"contents":[{"Add":"// This file defines extra methods for classes in stringtab.h"},{"Add":"// that are specific to code generation."},{"Add":"#ifndef STRINGTAB_HANDCODE_H"},{"Add":"#define STRINGTAB_HANDCODE_H"},{"Add":""},{"Add":"#include "},{"Add":"class CgenClassTable;"},{"Add":"namespace llvm { class GlobalVariable; }"},{"Add":""},{"Add":"// Extra methods added to classes in stringtab.h"},{"Add":"#define StringEntry_EXTRAS \\"},{"Add":" void code_def(CgenClassTable *class_table); \\"},{"Add":" void code_ref(CgenClassTable *class_table); \\"},{"Add":" llvm::GlobalVariable* ptr;"},{"Add":""},{"Add":"#define IntEntry_EXTRAS \\"},{"Add":" void code_ref(CgenClassTable *class_table);"},{"Add":""},{"Add":"#define StrTable_EXTRAS \\"},{"Add":" void code_string_table(CgenClassTable *class_table); \\"},{"Add":" std::string get_file() const;"},{"Add":""},{"Add":"#endif /* STRINGTAB_HANDCODE_H */"}]}},{"FileAdd":{"meta":{"basename":"stringtab.h","metadata":0},"context":[{"change":0,"pos":222547}],"contents":[{"Add":"// -*-Mode: C++;-*-"},{"Add":"//"},{"Add":"// See copyright.h for copyright notice and limitation of liability"},{"Add":"// and disclaimer of warranty provisions."},{"Add":"//"},{"Add":"#include \"copyright.h\""},{"Add":""},{"Add":"#ifndef _STRINGTAB_H_"},{"Add":"#define _STRINGTAB_H_"},{"Add":""},{"Add":"#include \"stringtab.handcode.h\""},{"Add":"#include "},{"Add":"#include "},{"Add":"#include "},{"Add":"#include "},{"Add":""},{"Add":"class Entry {"},{"Add":"protected:"},{"Add":" std::string str;"},{"Add":" int index;"},{"Add":""},{"Add":"public:"},{"Add":" Entry() = default;"},{"Add":" Entry(std::string s, int i) : str(std::move(s)), index(i) {}"},{"Add":""},{"Add":" const std::string &get_string() const { return str; }"},{"Add":" int get_index() const { return index; }"},{"Add":"};"},{"Add":""},{"Add":"using Symbol = Entry *;"},{"Add":""},{"Add":"inline std::ostream &operator<<(std::ostream &s, const Entry &sym) {"},{"Add":" return s << \"{\" << sym.get_string() << \", \" << sym.get_index() << \"}\\n\";"},{"Add":"}"},{"Add":""},{"Add":"//"},{"Add":"// There are three kinds of string table entries:"},{"Add":"// a true string, an string representation of an identifier, and"},{"Add":"// a string representation of an integer."},{"Add":"//"},{"Add":"// Having separate tables is convenient for code generation. Different"},{"Add":"// data definitions are generated for string constants (StringEntry) and"},{"Add":"// integer constants (IntEntry). Identifiers (IdEntry) don't produce"},{"Add":"// static data definitions."},{"Add":"//"},{"Add":"// code_def and code_ref are used by the code to produce definitions and"},{"Add":"// references (respectively) to constants."},{"Add":"//"},{"Add":"class StringEntry : public Entry {"},{"Add":"public:"},{"Add":" StringEntry() = default;"},{"Add":" StringEntry(std::string s, int i) : Entry(std::move(s), i) {}"},{"Add":""},{"Add":"#ifdef StringEntry_EXTRAS"},{"Add":" StringEntry_EXTRAS"},{"Add":"#endif"},{"Add":"};"},{"Add":""},{"Add":"class IdEntry : public Entry {"},{"Add":"public:"},{"Add":" IdEntry() = default;"},{"Add":" IdEntry(std::string s, int i) : Entry(std::move(s), i) {}"},{"Add":"};"},{"Add":""},{"Add":"class IntEntry : public Entry {"},{"Add":"public:"},{"Add":" IntEntry() = default;"},{"Add":" IntEntry(std::string s, int i) : Entry(std::move(s), i) {}"},{"Add":"#ifdef IntEntry_EXTRAS"},{"Add":" IntEntry_EXTRAS"},{"Add":"#endif"},{"Add":"};"},{"Add":""},{"Add":"//////////////////////////////////////////////////////////////////////////"},{"Add":"//"},{"Add":"// String Tables"},{"Add":"//"},{"Add":"//////////////////////////////////////////////////////////////////////////"},{"Add":""},{"Add":"template class StringTable {"},{"Add":"protected:"},{"Add":" std::unordered_map _table;"},{"Add":""},{"Add":"public:"},{"Add":" Symbol add_string(const std::string &s) {"},{"Add":" if (_table.find(s) == _table.end()) {"},{"Add":" _table[s] = Entry(s, _table.size());"},{"Add":" }"},{"Add":" // unordered_map pointer is stable, so we are safe here."},{"Add":" return &_table.find(s)->second;"},{"Add":" }"},{"Add":""},{"Add":" Symbol lookup_string(const std::string &s) {"},{"Add":" auto found = _table.find(s);"},{"Add":" return found == _table.end() ? nullptr : &found->second;"},{"Add":" }"},{"Add":"};"},{"Add":""},{"Add":"class IdTable : public StringTable {};"},{"Add":""},{"Add":"class StrTable : public StringTable {"},{"Add":"public:"},{"Add":"#ifdef StrTable_EXTRAS"},{"Add":" StrTable_EXTRAS"},{"Add":"#endif"},{"Add":"};"},{"Add":""},{"Add":"class IntTable : public StringTable {"},{"Add":"public:"},{"Add":"#ifdef IntTable_EXTRAS"},{"Add":" IntTable_EXTRAS"},{"Add":"#endif"},{"Add":"};"},{"Add":""},{"Add":"extern IdTable idtable;"},{"Add":"extern IntTable inttable;"},{"Add":"extern StrTable stringtable;"},{"Add":"#endif"}]}},{"FileAdd":{"meta":{"basename":"copyright.h","metadata":0},"context":[{"change":0,"pos":222547}],"contents":[{"Add":"/*"},{"Add":"Copyright (c) 1995,1996 The Regents of the University of California."},{"Add":"All rights reserved."},{"Add":""},{"Add":"Permission to use, copy, modify, and distribute this software for any"},{"Add":"purpose, without fee, and without written agreement is hereby granted,"},{"Add":"provided that the above copyright notice and the following two"},{"Add":"paragraphs appear in all copies of this software."},{"Add":""},{"Add":"IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR"},{"Add":"DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT"},{"Add":"OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF"},{"Add":"CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."},{"Add":""},{"Add":"THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,"},{"Add":"INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY"},{"Add":"AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS"},{"Add":"ON AN \"AS IS\" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATION TO"},{"Add":"PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS."},{"Add":"*/"}]}},{"FileAdd":{"meta":{"basename":"cool_tree.handcode.h","metadata":0},"context":[{"change":0,"pos":222547}],"contents":[{"Add":"//"},{"Add":"// The following include files must come first."},{"Add":""},{"Add":"#ifndef COOL_TREE_HANDCODE_H"},{"Add":"#define COOL_TREE_HANDCODE_H"},{"Add":""},{"Add":"#include \"stringtab.h\""},{"Add":"#include \"symtab.h\""},{"Add":"#include \"tree.h\""},{"Add":"#include \"utils.h\""},{"Add":"#include "},{"Add":"#include "},{"Add":"#include "},{"Add":""},{"Add":"class CgenEnvironment;"},{"Add":"class CgenNode;"},{"Add":""},{"Add":"class Program_class;"},{"Add":"typedef Program_class *Program;"},{"Add":"class Class__class;"},{"Add":"typedef Class__class *Class_;"},{"Add":"class Feature_class;"},{"Add":"typedef Feature_class *Feature;"},{"Add":"class Formal_class;"},{"Add":"typedef Formal_class *Formal;"},{"Add":"class Expression_class;"},{"Add":"typedef Expression_class *Expression;"},{"Add":"class Case_class;"},{"Add":"typedef Case_class *Case;"},{"Add":""},{"Add":"typedef list_node Classes_class;"},{"Add":"typedef Classes_class *Classes;"},{"Add":"typedef list_node Features_class;"},{"Add":"typedef Features_class *Features;"},{"Add":"typedef list_node Formals_class;"},{"Add":"typedef Formals_class *Formals;"},{"Add":"typedef list_node Expressions_class;"},{"Add":"typedef Expressions_class *Expressions;"},{"Add":"typedef list_node Cases_class;"},{"Add":"typedef Cases_class *Cases;"},{"Add":""},{"Add":"namespace llvm {"},{"Add":" class Value;"},{"Add":" class Function;"},{"Add":" class BasicBlock;"},{"Add":"}"},{"Add":""},{"Add":"// Abstract classes:"},{"Add":""},{"Add":"#define Program_EXTRAS \\"},{"Add":" virtual void dump_with_types(std::ostream &, int) = 0; \\"},{"Add":" virtual void cgen(const std::optional &) = 0;"},{"Add":""},{"Add":"#define Class__EXTRAS virtual void dump_with_types(std::ostream &, int) = 0;"},{"Add":""},{"Add":"#define Feature_EXTRAS \\"},{"Add":" virtual void dump_with_types(std::ostream &, int) = 0; \\"},{"Add":" virtual void layout_feature(CgenNode *cls) = 0; \\"},{"Add":" virtual llvm::Value *code(CgenEnvironment *) = 0; \\"},{"Add":" virtual Symbol get_name() = 0;"},{"Add":""},{"Add":"#define Expression_EXTRAS \\"},{"Add":" virtual void dump_with_types(std::ostream &, int) = 0; \\"},{"Add":" virtual llvm::Value *code(CgenEnvironment *) = 0; \\"},{"Add":" Symbol type; \\"},{"Add":" Symbol get_type() { return type; } \\"},{"Add":" Expression set_type(Symbol s) { \\"},{"Add":" type = s; \\"},{"Add":" return this; \\"},{"Add":" } \\"},{"Add":" virtual int no_code() { return 0; } /* ## */ \\"},{"Add":" void dump_type(std::ostream &, int); \\"},{"Add":" Expression_class() { type = (Symbol)NULL; }"},{"Add":""},{"Add":"#define program_EXTRAS \\"},{"Add":" void dump_with_types(std::ostream &, int); \\"},{"Add":" void cgen(const std::optional &);"},{"Add":""},{"Add":"#define class__EXTRAS \\"},{"Add":" Symbol get_name() { return name; } \\"},{"Add":" Symbol get_parent() { return parent; } \\"},{"Add":" Symbol get_filename() { return filename; } \\"},{"Add":" void dump_with_types(std::ostream &, int);"},{"Add":""},{"Add":"#define Feature_SHARED_EXTRAS \\"},{"Add":" void dump_with_types(std::ostream &, int); \\"},{"Add":" void layout_feature(CgenNode *cls); \\"},{"Add":" Symbol get_name() { return name; }"},{"Add":""},{"Add":"#define method_EXTRAS \\"},{"Add":" virtual Symbol get_return_type() { return return_type; } \\"},{"Add":" llvm::Value* code(CgenEnvironment *) override; \\"},{"Add":" llvm::Function* fn; \\"},{"Add":" std::string qualified_name;"},{"Add":""},{"Add":"#define attr_EXTRAS \\"},{"Add":" llvm::Value *code(CgenEnvironment *) override; \\"},{"Add":" llvm::Value* val;"},{"Add":""},{"Add":"#define Formal_EXTRAS \\"},{"Add":" virtual Symbol get_type_decl() = 0; /* ## */ \\"},{"Add":" virtual Symbol get_name() = 0; /* ## */ \\"},{"Add":" virtual void dump_with_types(std::ostream &, int) = 0;"},{"Add":""},{"Add":"#define formal_EXTRAS \\"},{"Add":" Symbol get_type_decl() { return type_decl; } /* ## */ \\"},{"Add":" Symbol get_name() { return name; } /* ## */ \\"},{"Add":" void dump_with_types(std::ostream &, int);"},{"Add":""},{"Add":"#define Case_EXTRAS \\"},{"Add":" virtual Symbol get_type_decl() = 0; \\"},{"Add":" virtual void code(llvm::Value *, llvm::Value *, llvm::Value*, llvm::BasicBlock*, \\"},{"Add":" CgenEnvironment *) = 0; \\"},{"Add":" virtual void dump_with_types(std::ostream &, int) = 0;"},{"Add":""},{"Add":"#define branch_EXTRAS \\"},{"Add":" Symbol get_type_decl() { return type_decl; } \\"},{"Add":" Expression get_expr() { return expr; } \\"},{"Add":" void code(llvm::Value *expr_val, llvm::Value *tag, llvm::Value* mem, llvm::BasicBlock* sbb, \\"},{"Add":" CgenEnvironment *env); \\"},{"Add":" void dump_with_types(std::ostream &, int);"},{"Add":""},{"Add":"#define Expression_SHARED_EXTRAS \\"},{"Add":" llvm::Value *code(CgenEnvironment *); \\"},{"Add":" void dump_with_types(std::ostream &, int);"},{"Add":""},{"Add":"#define no_expr_EXTRAS /* ## */ \\"},{"Add":" int no_code() { return 1; } /* ## */"},{"Add":""},{"Add":"#endif /* COOL_TREE_HANDCODE_H */"}]}},{"FileAdd":{"meta":{"basename":"cool_tree.h","metadata":0},"context":[{"change":0,"pos":222547}],"contents":[{"Add":"#ifndef COOL_TREE_H"},{"Add":"#define COOL_TREE_H"},{"Add":"/*"},{"Add":" file: cool_tree.h"},{"Add":""},{"Add":" This file defines classes for each phylum and constructor"},{"Add":""},{"Add":" (Partly copied over from dumptype.cc)"},{"Add":" It may help to know the inheritance hierarchy of the classes"},{"Add":" that define the structure of the Cool AST."},{"Add":" In the list below, the outer classes are the Phyla"},{"Add":" which group together related kinds of abstract tree nodes"},{"Add":" (e.g., the two kinds of Features and the many different kinds of Expression)."},{"Add":" The inner, indented classes inherit from the nearest Phyla class;"},{"Add":" these are the concrete classes that appear in the AST."},{"Add":""},{"Add":" Program_class"},{"Add":" program_class"},{"Add":""},{"Add":" Class__class"},{"Add":" class_class"},{"Add":""},{"Add":" Feature_class"},{"Add":" method_class (_class omitted below)"},{"Add":" attr"},{"Add":""},{"Add":" Formal_class"},{"Add":" formal"},{"Add":""},{"Add":" Case_class"},{"Add":" branch"},{"Add":""},{"Add":" Expression_class"},{"Add":" assign"},{"Add":" static_dispatch"},{"Add":" dispatch"},{"Add":" cond"},{"Add":" loop"},{"Add":" typcase"},{"Add":" block"},{"Add":" let"},{"Add":" plus"},{"Add":" sub"},{"Add":" mul"},{"Add":" divide"},{"Add":" neg"},{"Add":" lt"},{"Add":" eq"},{"Add":" leq"},{"Add":" comp"},{"Add":" int_const"},{"Add":" bool_const"},{"Add":" string_const"},{"Add":" new_"},{"Add":" isvoid"},{"Add":" no_expr"},{"Add":" object"},{"Add":""},{"Add":" All of the Phyla inherit from the tree_node class."},{"Add":""},{"Add":" Some AST nodes have lists of other tree nodes as components. Lists in the"},{"Add":" AST are built using the class list_node defined in tree.h. The list"},{"Add":" classes in the Cool AST are:"},{"Add":""},{"Add":" Classes a list of Class_"},{"Add":" Features a list of Feature"},{"Add":" Expressions a list of Expression"},{"Add":" Cases a list of Case"},{"Add":"*/"},{"Add":""},{"Add":"#include \"cool_tree.handcode.h\""},{"Add":"#include \"tree.h\""},{"Add":"#include \"utils.h\""},{"Add":""},{"Add":"class CgenClassTable;"},{"Add":""},{"Add":"// define the class for phylum"},{"Add":"// define simple phylum - Program"},{"Add":"typedef class Program_class *Program;"},{"Add":""},{"Add":"class Program_class : public tree_node {"},{"Add":"public:"},{"Add":" tree_node *copy() { return copy_Program(); }"},{"Add":" virtual Program copy_Program() = 0;"},{"Add":" CgenClassTable *class_table;"},{"Add":""},{"Add":"#ifdef Program_EXTRAS"},{"Add":" Program_EXTRAS"},{"Add":"#endif"},{"Add":"};"},{"Add":""},{"Add":"// define simple phylum - Class_"},{"Add":"typedef class Class__class *Class_;"},{"Add":""},{"Add":"class Class__class : public tree_node {"},{"Add":"public:"},{"Add":" tree_node *copy() { return copy_Class_(); }"},{"Add":" virtual Class_ copy_Class_() = 0;"},{"Add":""},{"Add":"#ifdef Class__EXTRAS"},{"Add":" Class__EXTRAS"},{"Add":"#endif"},{"Add":"};"},{"Add":""},{"Add":"// define simple phylum - Feature"},{"Add":"typedef class Feature_class *Feature;"},{"Add":""},{"Add":"class Feature_class : public tree_node {"},{"Add":"public:"},{"Add":" tree_node *copy() { return copy_Feature(); }"},{"Add":" virtual Feature copy_Feature() = 0;"},{"Add":""},{"Add":"#ifdef Feature_EXTRAS"},{"Add":" Feature_EXTRAS"},{"Add":"#endif"},{"Add":"};"},{"Add":""},{"Add":"// define simple phylum - Formal"},{"Add":"typedef class Formal_class *Formal;"},{"Add":""},{"Add":"class Formal_class : public tree_node {"},{"Add":"public:"},{"Add":" tree_node *copy() { return copy_Formal(); }"},{"Add":" virtual Formal copy_Formal() = 0;"},{"Add":""},{"Add":"#ifdef Formal_EXTRAS"},{"Add":" Formal_EXTRAS"},{"Add":"#endif"},{"Add":"};"},{"Add":""},{"Add":"// define simple phylum - Expression"},{"Add":"typedef class Expression_class *Expression;"},{"Add":""},{"Add":"class Expression_class : public tree_node {"},{"Add":"public:"},{"Add":" tree_node *copy() { return copy_Expression(); }"},{"Add":" virtual Expression copy_Expression() = 0;"},{"Add":""},{"Add":"#ifdef Expression_EXTRAS"},{"Add":" Expression_EXTRAS"},{"Add":"#endif"},{"Add":"};"},{"Add":""},{"Add":"// define simple phylum - Case"},{"Add":"typedef class Case_class *Case;"},{"Add":""},{"Add":"class Case_class : public tree_node {"},{"Add":"public:"},{"Add":" tree_node *copy() { return copy_Case(); }"},{"Add":" virtual Case copy_Case() = 0;"},{"Add":""},{"Add":"#ifdef Case_EXTRAS"},{"Add":" Case_EXTRAS"},{"Add":"#endif"},{"Add":"};"},{"Add":""},{"Add":"// define the class for phylum - LIST"},{"Add":"// define list phlyum - Classes"},{"Add":"typedef list_node Classes_class;"},{"Add":"typedef Classes_class *Classes;"},{"Add":""},{"Add":"// define list phlyum - Features"},{"Add":"typedef list_node Features_class;"},{"Add":"typedef Features_class *Features;"},{"Add":""},{"Add":"// define list phlyum - Formals"},{"Add":"typedef list_node Formals_class;"},{"Add":"typedef Formals_class *Formals;"},{"Add":""},{"Add":"// define list phlyum - Expressions"},{"Add":"typedef list_node Expressions_class;"},{"Add":"typedef Expressions_class *Expressions;"},{"Add":""},{"Add":"// define list phlyum - Cases"},{"Add":"typedef list_node Cases_class;"},{"Add":"typedef Cases_class *Cases;"},{"Add":""},{"Add":"// define the class for constructors"},{"Add":"// define constructor - program"},{"Add":"class program_class : public Program_class {"},{"Add":"protected:"},{"Add":" Classes classes;"},{"Add":""},{"Add":"public:"},{"Add":" program_class(Classes a1) { classes = a1; }"},{"Add":" Program copy_Program();"},{"Add":" void dump(std::ostream &stream, int n);"},{"Add":""},{"Add":"#ifdef Program_SHARED_EXTRAS"},{"Add":" Program_SHARED_EXTRAS"},{"Add":"#endif"},{"Add":"#ifdef program_EXTRAS"},{"Add":" program_EXTRAS"},{"Add":"#endif"},{"Add":"};"},{"Add":""},{"Add":"// define constructor - class_"},{"Add":"class class__class : public Class__class {"},{"Add":"protected:"},{"Add":" Symbol name;"},{"Add":" Symbol parent;"},{"Add":" Features features;"},{"Add":" Symbol filename;"},{"Add":""},{"Add":"public:"},{"Add":" class__class(Symbol a1, Symbol a2, Features a3, Symbol a4) {"},{"Add":" name = a1;"},{"Add":" parent = a2;"},{"Add":" features = a3;"},{"Add":" filename = a4;"},{"Add":" }"},{"Add":" Class_ copy_Class_();"},{"Add":" void dump(std::ostream &stream, int n);"},{"Add":""},{"Add":"#ifdef Class__SHARED_EXTRAS"},{"Add":" Class__SHARED_EXTRAS"},{"Add":"#endif"},{"Add":"#ifdef class__EXTRAS"},{"Add":" class__EXTRAS"},{"Add":"#endif"},{"Add":"};"},{"Add":""},{"Add":"// define constructor - method"},{"Add":"class method_class : public Feature_class {"},{"Add":"protected:"},{"Add":" Symbol name;"},{"Add":" Formals formals;"},{"Add":" Symbol return_type;"},{"Add":" Expression expr;"},{"Add":""},{"Add":"public:"},{"Add":" method_class(Symbol a1, Formals a2, Symbol a3, Expression a4) {"},{"Add":" name = a1;"},{"Add":" formals = a2;"},{"Add":" return_type = a3;"},{"Add":" expr = a4;"},{"Add":" }"},{"Add":" Feature copy_Feature();"},{"Add":" void dump(std::ostream &stream, int n);"},{"Add":""},{"Add":"#ifdef Feature_SHARED_EXTRAS"},{"Add":" Feature_SHARED_EXTRAS"},{"Add":"#endif"},{"Add":"#ifdef method_EXTRAS"},{"Add":" method_EXTRAS"},{"Add":"#endif"},{"Add":"};"},{"Add":""},{"Add":"// define constructor - attr"},{"Add":"class attr_class : public Feature_class {"},{"Add":"protected:"},{"Add":" Symbol name;"},{"Add":" Symbol type_decl;"},{"Add":" Expression init;"},{"Add":""},{"Add":"public:"},{"Add":" attr_class(Symbol a1, Symbol a2, Expression a3) {"},{"Add":" name = a1;"},{"Add":" type_decl = a2;"},{"Add":" init = a3;"},{"Add":" }"},{"Add":" Feature copy_Feature();"},{"Add":" void dump(std::ostream &stream, int n);"},{"Add":""},{"Add":"#ifdef Feature_SHARED_EXTRAS"},{"Add":" Feature_SHARED_EXTRAS"},{"Add":"#endif"},{"Add":"#ifdef attr_EXTRAS"},{"Add":" attr_EXTRAS"},{"Add":"#endif"},{"Add":"};"},{"Add":""},{"Add":"// define constructor - formal"},{"Add":"class formal_class : public Formal_class {"},{"Add":"protected:"},{"Add":" Symbol name;"},{"Add":" Symbol type_decl;"},{"Add":""},{"Add":"public:"},{"Add":" formal_class(Symbol a1, Symbol a2) {"},{"Add":" name = a1;"},{"Add":" type_decl = a2;"},{"Add":" }"},{"Add":" Formal copy_Formal();"},{"Add":" void dump(std::ostream &stream, int n);"},{"Add":""},{"Add":"#ifdef Formal_SHARED_EXTRAS"},{"Add":" Formal_SHARED_EXTRAS"},{"Add":"#endif"},{"Add":"#ifdef formal_EXTRAS"},{"Add":" formal_EXTRAS"},{"Add":"#endif"},{"Add":"};"},{"Add":""},{"Add":"// define constructor - branch"},{"Add":"class branch_class : public Case_class {"},{"Add":"protected:"},{"Add":" Symbol name;"},{"Add":" Symbol type_decl;"},{"Add":" Expression expr;"},{"Add":""},{"Add":"public:"},{"Add":" branch_class(Symbol a1, Symbol a2, Expression a3) {"},{"Add":" name = a1;"},{"Add":" type_decl = a2;"},{"Add":" expr = a3;"},{"Add":" }"},{"Add":" Case copy_Case();"},{"Add":" void dump(std::ostream &stream, int n);"},{"Add":""},{"Add":"#ifdef Case_SHARED_EXTRAS"},{"Add":" Case_SHARED_EXTRAS"},{"Add":"#endif"},{"Add":"#ifdef branch_EXTRAS"},{"Add":" branch_EXTRAS"},{"Add":"#endif"},{"Add":"};"},{"Add":""},{"Add":"// define constructor - assign"},{"Add":"class assign_class : public Expression_class {"},{"Add":"protected:"},{"Add":" Symbol name;"},{"Add":" Expression expr;"},{"Add":""},{"Add":"public:"},{"Add":" assign_class(Symbol a1, Expression a2) {"},{"Add":" name = a1;"},{"Add":" expr = a2;"},{"Add":" }"},{"Add":" Expression copy_Expression();"},{"Add":" void dump(std::ostream &stream, int n);"},{"Add":""},{"Add":"#ifdef Expression_SHARED_EXTRAS"},{"Add":" Expression_SHARED_EXTRAS"},{"Add":"#endif"},{"Add":"#ifdef assign_EXTRAS"},{"Add":" assign_EXTRAS"},{"Add":"#endif"},{"Add":"};"},{"Add":""},{"Add":"// define constructor - static_dispatch"},{"Add":"class static_dispatch_class : public Expression_class {"},{"Add":"protected:"},{"Add":" Expression expr;"},{"Add":" Symbol type_name;"},{"Add":" Symbol name;"},{"Add":" Expressions actual;"},{"Add":""},{"Add":"public:"},{"Add":" static_dispatch_class(Expression a1, Symbol a2, Symbol a3, Expressions a4) {"},{"Add":" expr = a1;"},{"Add":" type_name = a2;"},{"Add":" name = a3;"},{"Add":" actual = a4;"},{"Add":" }"},{"Add":" Expression copy_Expression();"},{"Add":" void dump(std::ostream &stream, int n);"},{"Add":""},{"Add":"#ifdef Expression_SHARED_EXTRAS"},{"Add":" Expression_SHARED_EXTRAS"},{"Add":"#endif"},{"Add":"#ifdef static_dispatch_EXTRAS"},{"Add":" static_dispatch_EXTRAS"},{"Add":"#endif"},{"Add":"};"},{"Add":""},{"Add":"// define constructor - dispatch"},{"Add":"class dispatch_class : public Expression_class {"},{"Add":"protected:"},{"Add":" Expression expr;"},{"Add":" Symbol name;"},{"Add":" Expressions actual;"},{"Add":""},{"Add":"public:"},{"Add":" dispatch_class(Expression a1, Symbol a2, Expressions a3) {"},{"Add":" expr = a1;"},{"Add":" name = a2;"},{"Add":" actual = a3;"},{"Add":" }"},{"Add":" Expression copy_Expression();"},{"Add":" void dump(std::ostream &stream, int n);"},{"Add":""},{"Add":"#ifdef Expression_SHARED_EXTRAS"},{"Add":" Expression_SHARED_EXTRAS"},{"Add":"#endif"},{"Add":"#ifdef dispatch_EXTRAS"},{"Add":" dispatch_EXTRAS"},{"Add":"#endif"},{"Add":"};"},{"Add":""},{"Add":"// define constructor - cond"},{"Add":"class cond_class : public Expression_class {"},{"Add":"protected:"},{"Add":" Expression pred;"},{"Add":" Expression then_exp;"},{"Add":" Expression else_exp;"},{"Add":""},{"Add":"public:"},{"Add":" cond_class(Expression a1, Expression a2, Expression a3) {"},{"Add":" pred = a1;"},{"Add":" then_exp = a2;"},{"Add":" else_exp = a3;"},{"Add":" }"},{"Add":" Expression copy_Expression();"},{"Add":" void dump(std::ostream &stream, int n);"},{"Add":""},{"Add":"#ifdef Expression_SHARED_EXTRAS"},{"Add":" Expression_SHARED_EXTRAS"},{"Add":"#endif"},{"Add":"#ifdef cond_EXTRAS"},{"Add":" cond_EXTRAS"},{"Add":"#endif"},{"Add":"};"},{"Add":""},{"Add":"// define constructor - loop"},{"Add":"class loop_class : public Expression_class {"},{"Add":"protected:"},{"Add":" Expression pred;"},{"Add":" Expression body;"},{"Add":""},{"Add":"public:"},{"Add":" loop_class(Expression a1, Expression a2) {"},{"Add":" pred = a1;"},{"Add":" body = a2;"},{"Add":" }"},{"Add":" Expression copy_Expression();"},{"Add":" void dump(std::ostream &stream, int n);"},{"Add":""},{"Add":"#ifdef Expression_SHARED_EXTRAS"},{"Add":" Expression_SHARED_EXTRAS"},{"Add":"#endif"},{"Add":"#ifdef loop_EXTRAS"},{"Add":" loop_EXTRAS"},{"Add":"#endif"},{"Add":"};"},{"Add":""},{"Add":"// define constructor - typcase"},{"Add":"class typcase_class : public Expression_class {"},{"Add":"protected:"},{"Add":" Expression expr;"},{"Add":" Cases cases;"},{"Add":""},{"Add":"public:"},{"Add":" typcase_class(Expression a1, Cases a2) {"},{"Add":" expr = a1;"},{"Add":" cases = a2;"},{"Add":" }"},{"Add":" Expression copy_Expression();"},{"Add":" void dump(std::ostream &stream, int n);"},{"Add":""},{"Add":"#ifdef Expression_SHARED_EXTRAS"},{"Add":" Expression_SHARED_EXTRAS"},{"Add":"#endif"},{"Add":"#ifdef typcase_EXTRAS"},{"Add":" typcase_EXTRAS"},{"Add":"#endif"},{"Add":"};"},{"Add":""},{"Add":"// define constructor - block"},{"Add":"class block_class : public Expression_class {"},{"Add":"protected:"},{"Add":" Expressions body;"},{"Add":""},{"Add":"public:"},{"Add":" block_class(Expressions a1) { body = a1; }"},{"Add":" Expression copy_Expression();"},{"Add":" void dump(std::ostream &stream, int n);"},{"Add":""},{"Add":"#ifdef Expression_SHARED_EXTRAS"},{"Add":" Expression_SHARED_EXTRAS"},{"Add":"#endif"},{"Add":"#ifdef block_EXTRAS"},{"Add":" block_EXTRAS"},{"Add":"#endif"},{"Add":"};"},{"Add":""},{"Add":"// define constructor - let"},{"Add":"class let_class : public Expression_class {"},{"Add":"protected:"},{"Add":" Symbol identifier;"},{"Add":" Symbol type_decl;"},{"Add":" Expression init;"},{"Add":" Expression body;"},{"Add":""},{"Add":"public:"},{"Add":" let_class(Symbol a1, Symbol a2, Expression a3, Expression a4) {"},{"Add":" identifier = a1;"},{"Add":" type_decl = a2;"},{"Add":" init = a3;"},{"Add":" body = a4;"},{"Add":" }"},{"Add":" Expression copy_Expression();"},{"Add":" void dump(std::ostream &stream, int n);"},{"Add":""},{"Add":"#ifdef Expression_SHARED_EXTRAS"},{"Add":" Expression_SHARED_EXTRAS"},{"Add":"#endif"},{"Add":"#ifdef let_EXTRAS"},{"Add":" let_EXTRAS"},{"Add":"#endif"},{"Add":"};"},{"Add":""},{"Add":"// define constructor - plus"},{"Add":"class plus_class : public Expression_class {"},{"Add":"protected:"},{"Add":" Expression e1;"},{"Add":" Expression e2;"},{"Add":""},{"Add":"public:"},{"Add":" plus_class(Expression a1, Expression a2) {"},{"Add":" e1 = a1;"},{"Add":" e2 = a2;"},{"Add":" }"},{"Add":" Expression copy_Expression();"},{"Add":" void dump(std::ostream &stream, int n);"},{"Add":""},{"Add":"#ifdef Expression_SHARED_EXTRAS"},{"Add":" Expression_SHARED_EXTRAS"},{"Add":"#endif"},{"Add":"#ifdef plus_EXTRAS"},{"Add":" plus_EXTRAS"},{"Add":"#endif"},{"Add":"};"},{"Add":""},{"Add":"// define constructor - sub"},{"Add":"class sub_class : public Expression_class {"},{"Add":"protected:"},{"Add":" Expression e1;"},{"Add":" Expression e2;"},{"Add":""},{"Add":"public:"},{"Add":" sub_class(Expression a1, Expression a2) {"},{"Add":" e1 = a1;"},{"Add":" e2 = a2;"},{"Add":" }"},{"Add":" Expression copy_Expression();"},{"Add":" void dump(std::ostream &stream, int n);"},{"Add":""},{"Add":"#ifdef Expression_SHARED_EXTRAS"},{"Add":" Expression_SHARED_EXTRAS"},{"Add":"#endif"},{"Add":"#ifdef sub_EXTRAS"},{"Add":" sub_EXTRAS"},{"Add":"#endif"},{"Add":"};"},{"Add":""},{"Add":"// define constructor - mul"},{"Add":"class mul_class : public Expression_class {"},{"Add":"protected:"},{"Add":" Expression e1;"},{"Add":" Expression e2;"},{"Add":""},{"Add":"public:"},{"Add":" mul_class(Expression a1, Expression a2) {"},{"Add":" e1 = a1;"},{"Add":" e2 = a2;"},{"Add":" }"},{"Add":" Expression copy_Expression();"},{"Add":" void dump(std::ostream &stream, int n);"},{"Add":""},{"Add":"#ifdef Expression_SHARED_EXTRAS"},{"Add":" Expression_SHARED_EXTRAS"},{"Add":"#endif"},{"Add":"#ifdef mul_EXTRAS"},{"Add":" mul_EXTRAS"},{"Add":"#endif"},{"Add":"};"},{"Add":""},{"Add":"// define constructor - divide"},{"Add":"class divide_class : public Expression_class {"},{"Add":"protected:"},{"Add":" Expression e1;"},{"Add":" Expression e2;"},{"Add":""},{"Add":"public:"},{"Add":" divide_class(Expression a1, Expression a2) {"},{"Add":" e1 = a1;"},{"Add":" e2 = a2;"},{"Add":" }"},{"Add":" Expression copy_Expression();"},{"Add":" void dump(std::ostream &stream, int n);"},{"Add":""},{"Add":"#ifdef Expression_SHARED_EXTRAS"},{"Add":" Expression_SHARED_EXTRAS"},{"Add":"#endif"},{"Add":"#ifdef divide_EXTRAS"},{"Add":" divide_EXTRAS"},{"Add":"#endif"},{"Add":"};"},{"Add":""},{"Add":"// define constructor - neg"},{"Add":"class neg_class : public Expression_class {"},{"Add":"protected:"},{"Add":" Expression e1;"},{"Add":""},{"Add":"public:"},{"Add":" neg_class(Expression a1) { e1 = a1; }"},{"Add":" Expression copy_Expression();"},{"Add":" void dump(std::ostream &stream, int n);"},{"Add":""},{"Add":"#ifdef Expression_SHARED_EXTRAS"},{"Add":" Expression_SHARED_EXTRAS"},{"Add":"#endif"},{"Add":"#ifdef neg_EXTRAS"},{"Add":" neg_EXTRAS"},{"Add":"#endif"},{"Add":"};"},{"Add":""},{"Add":"// define constructor - lt"},{"Add":"class lt_class : public Expression_class {"},{"Add":"protected:"},{"Add":" Expression e1;"},{"Add":" Expression e2;"},{"Add":""},{"Add":"public:"},{"Add":" lt_class(Expression a1, Expression a2) {"},{"Add":" e1 = a1;"},{"Add":" e2 = a2;"},{"Add":" }"},{"Add":" Expression copy_Expression();"},{"Add":" void dump(std::ostream &stream, int n);"},{"Add":""},{"Add":"#ifdef Expression_SHARED_EXTRAS"},{"Add":" Expression_SHARED_EXTRAS"},{"Add":"#endif"},{"Add":"#ifdef lt_EXTRAS"},{"Add":" lt_EXTRAS"},{"Add":"#endif"},{"Add":"};"},{"Add":""},{"Add":"// define constructor - eq"},{"Add":"class eq_class : public Expression_class {"},{"Add":"protected:"},{"Add":" Expression e1;"},{"Add":" Expression e2;"},{"Add":""},{"Add":"public:"},{"Add":" eq_class(Expression a1, Expression a2) {"},{"Add":" e1 = a1;"},{"Add":" e2 = a2;"},{"Add":" }"},{"Add":" Expression copy_Expression();"},{"Add":" void dump(std::ostream &stream, int n);"},{"Add":""},{"Add":"#ifdef Expression_SHARED_EXTRAS"},{"Add":" Expression_SHARED_EXTRAS"},{"Add":"#endif"},{"Add":"#ifdef eq_EXTRAS"},{"Add":" eq_EXTRAS"},{"Add":"#endif"},{"Add":"};"},{"Add":""},{"Add":"// define constructor - leq"},{"Add":"class leq_class : public Expression_class {"},{"Add":"protected:"},{"Add":" Expression e1;"},{"Add":" Expression e2;"},{"Add":""},{"Add":"public:"},{"Add":" leq_class(Expression a1, Expression a2) {"},{"Add":" e1 = a1;"},{"Add":" e2 = a2;"},{"Add":" }"},{"Add":" Expression copy_Expression();"},{"Add":" void dump(std::ostream &stream, int n);"},{"Add":""},{"Add":"#ifdef Expression_SHARED_EXTRAS"},{"Add":" Expression_SHARED_EXTRAS"},{"Add":"#endif"},{"Add":"#ifdef leq_EXTRAS"},{"Add":" leq_EXTRAS"},{"Add":"#endif"},{"Add":"};"},{"Add":""},{"Add":"// define constructor - comp"},{"Add":"class comp_class : public Expression_class {"},{"Add":"protected:"},{"Add":" Expression e1;"},{"Add":""},{"Add":"public:"},{"Add":" comp_class(Expression a1) { e1 = a1; }"},{"Add":" Expression copy_Expression();"},{"Add":" void dump(std::ostream &stream, int n);"},{"Add":""},{"Add":"#ifdef Expression_SHARED_EXTRAS"},{"Add":" Expression_SHARED_EXTRAS"},{"Add":"#endif"},{"Add":"#ifdef comp_EXTRAS"},{"Add":" comp_EXTRAS"},{"Add":"#endif"},{"Add":"};"},{"Add":""},{"Add":"// define constructor - int_const"},{"Add":"class int_const_class : public Expression_class {"},{"Add":"protected:"},{"Add":" Symbol token;"},{"Add":""},{"Add":"public:"},{"Add":" int_const_class(Symbol a1) { token = a1; }"},{"Add":" Expression copy_Expression();"},{"Add":" void dump(std::ostream &stream, int n);"},{"Add":""},{"Add":"#ifdef Expression_SHARED_EXTRAS"},{"Add":" Expression_SHARED_EXTRAS"},{"Add":"#endif"},{"Add":"#ifdef int_const_EXTRAS"},{"Add":" int_const_EXTRAS"},{"Add":"#endif"},{"Add":"};"},{"Add":""},{"Add":"// define constructor - bool_const"},{"Add":"class bool_const_class : public Expression_class {"},{"Add":"protected:"},{"Add":" bool val;"},{"Add":""},{"Add":"public:"},{"Add":" bool_const_class(bool a1) { val = a1; }"},{"Add":" Expression copy_Expression();"},{"Add":" void dump(std::ostream &stream, int n);"},{"Add":""},{"Add":"#ifdef Expression_SHARED_EXTRAS"},{"Add":" Expression_SHARED_EXTRAS"},{"Add":"#endif"},{"Add":"#ifdef bool_const_EXTRAS"},{"Add":" bool_const_EXTRAS"},{"Add":"#endif"},{"Add":"};"},{"Add":""},{"Add":"// define constructor - string_const"},{"Add":"class string_const_class : public Expression_class {"},{"Add":"protected:"},{"Add":" Symbol token;"},{"Add":""},{"Add":"public:"},{"Add":" string_const_class(Symbol a1) { token = a1; }"},{"Add":" Expression copy_Expression();"},{"Add":" void dump(std::ostream &stream, int n);"},{"Add":""},{"Add":"#ifdef Expression_SHARED_EXTRAS"},{"Add":" Expression_SHARED_EXTRAS"},{"Add":"#endif"},{"Add":"#ifdef string_const_EXTRAS"},{"Add":" string_const_EXTRAS"},{"Add":"#endif"},{"Add":"};"},{"Add":""},{"Add":"// define constructor - new_"},{"Add":"class new__class : public Expression_class {"},{"Add":"protected:"},{"Add":" Symbol type_name;"},{"Add":""},{"Add":"public:"},{"Add":" new__class(Symbol a1) { type_name = a1; }"},{"Add":" Expression copy_Expression();"},{"Add":" void dump(std::ostream &stream, int n);"},{"Add":""},{"Add":"#ifdef Expression_SHARED_EXTRAS"},{"Add":" Expression_SHARED_EXTRAS"},{"Add":"#endif"},{"Add":"#ifdef new__EXTRAS"},{"Add":" new__EXTRAS"},{"Add":"#endif"},{"Add":"};"},{"Add":""},{"Add":"// define constructor - isvoid"},{"Add":"class isvoid_class : public Expression_class {"},{"Add":"protected:"},{"Add":" Expression e1;"},{"Add":""},{"Add":"public:"},{"Add":" isvoid_class(Expression a1) { e1 = a1; }"},{"Add":" Expression copy_Expression();"},{"Add":" void dump(std::ostream &stream, int n);"},{"Add":""},{"Add":"#ifdef Expression_SHARED_EXTRAS"},{"Add":" Expression_SHARED_EXTRAS"},{"Add":"#endif"},{"Add":"#ifdef isvoid_EXTRAS"},{"Add":" isvoid_EXTRAS"},{"Add":"#endif"},{"Add":"};"},{"Add":""},{"Add":"// define constructor - no_expr"},{"Add":"class no_expr_class : public Expression_class {"},{"Add":"protected:"},{"Add":"public:"},{"Add":" no_expr_class() {}"},{"Add":" Expression copy_Expression();"},{"Add":" void dump(std::ostream &stream, int n);"},{"Add":""},{"Add":"#ifdef Expression_SHARED_EXTRAS"},{"Add":" Expression_SHARED_EXTRAS"},{"Add":"#endif"},{"Add":"#ifdef no_expr_EXTRAS"},{"Add":" no_expr_EXTRAS"},{"Add":"#endif"},{"Add":"};"},{"Add":""},{"Add":"// define constructor - object"},{"Add":"class object_class : public Expression_class {"},{"Add":"protected:"},{"Add":" Symbol name;"},{"Add":""},{"Add":"public:"},{"Add":" object_class(Symbol a1) { name = a1; }"},{"Add":" Expression copy_Expression();"},{"Add":" void dump(std::ostream &stream, int n);"},{"Add":""},{"Add":"#ifdef Expression_SHARED_EXTRAS"},{"Add":" Expression_SHARED_EXTRAS"},{"Add":"#endif"},{"Add":"#ifdef object_EXTRAS"},{"Add":" object_EXTRAS"},{"Add":"#endif"},{"Add":"};"},{"Add":""},{"Add":"// define the prototypes of the interface"},{"Add":"Classes nil_Classes();"},{"Add":"Classes single_Classes(Class_);"},{"Add":"Classes append_Classes(Classes, Classes);"},{"Add":"Features nil_Features();"},{"Add":"Features single_Features(Feature);"},{"Add":"Features append_Features(Features, Features);"},{"Add":"Formals nil_Formals();"},{"Add":"Formals single_Formals(Formal);"},{"Add":"Formals append_Formals(Formals, Formals);"},{"Add":"Expressions nil_Expressions();"},{"Add":"Expressions single_Expressions(Expression);"},{"Add":"Expressions append_Expressions(Expressions, Expressions);"},{"Add":"Cases nil_Cases();"},{"Add":"Cases single_Cases(Case);"},{"Add":"Cases append_Cases(Cases, Cases);"},{"Add":"Program program(Classes);"},{"Add":"Class_ class_(Symbol, Symbol, Features, Symbol);"},{"Add":"Feature method(Symbol, Formals, Symbol, Expression);"},{"Add":"Feature attr(Symbol, Symbol, Expression);"},{"Add":"Formal formal(Symbol, Symbol);"},{"Add":"Case branch(Symbol, Symbol, Expression);"},{"Add":"Expression assign(Symbol, Expression);"},{"Add":"Expression static_dispatch(Expression, Symbol, Symbol, Expressions);"},{"Add":"Expression dispatch(Expression, Symbol, Expressions);"},{"Add":"Expression cond(Expression, Expression, Expression);"},{"Add":"Expression loop(Expression, Expression);"},{"Add":"Expression typcase(Expression, Cases);"},{"Add":"Expression block(Expressions);"},{"Add":"Expression let(Symbol, Symbol, Expression, Expression);"},{"Add":"Expression plus(Expression, Expression);"},{"Add":"Expression sub(Expression, Expression);"},{"Add":"Expression mul(Expression, Expression);"},{"Add":"Expression divide(Expression, Expression);"},{"Add":"Expression neg(Expression);"},{"Add":"Expression lt(Expression, Expression);"},{"Add":"Expression eq(Expression, Expression);"},{"Add":"Expression leq(Expression, Expression);"},{"Add":"Expression comp(Expression);"},{"Add":"Expression int_const(Symbol);"},{"Add":"Expression bool_const(bool);"},{"Add":"Expression string_const(Symbol);"},{"Add":"Expression new_(Symbol);"},{"Add":"Expression isvoid(Expression);"},{"Add":"Expression no_expr();"},{"Add":"Expression object(Symbol);"},{"Add":""},{"Add":"#endif"}]}},{"FileAdd":{"meta":{"basename":"cgen.h","metadata":0},"context":[{"change":0,"pos":222547}],"contents":[{"Add":"#pragma once"},{"Add":"/*"},{"Add":" This is the Lab1 skeleton cgen header. As given, it contains only basic"},{"Add":" functionality. You will need to add members to each of the classes"},{"Add":" to get them to perform their desired functions. Document your important"},{"Add":" design decisions below. We should be able to read your documentation and"},{"Add":" get a general overview of how your compiler generates code. For instance,"},{"Add":" how does your compiler generate structures for classes, how is inheritance"},{"Add":" modeled, how do you handle dynamic binding, etc."},{"Add":"*/"},{"Add":""},{"Add":"// ------------------ INSERT DESIGN DOCUMENTATION HERE --------------------- //"},{"Add":"/*"},{"Add":" * Types for classes are declared when its CgenNode is installed to deal with circular dependencies"},{"Add":" *"},{"Add":" */"},{"Add":"// ----------------------------- END DESIGN DOCS --------------------------- //"},{"Add":""},{"Add":"#include \"cool_tree.h\""},{"Add":"// #include \"stringtab.h\""},{"Add":"// #include \"symtab.h\""},{"Add":"#include "},{"Add":"#include "},{"Add":"#include "},{"Add":"#include "},{"Add":"#include \"llvm/IR/DebugInfoMetadata.h\""},{"Add":"#include "},{"Add":""},{"Add":"#if defined _MSC_VER && !defined __clang__"},{"Add":"#define __attribute(...)"},{"Add":"#endif"},{"Add":""},{"Add":"class CgenNode;"},{"Add":""},{"Add":"#pragma region \"CgenClassTable\""},{"Add":"// CgenClassTable represents the top level of a Cool program, which is"},{"Add":"// basically a list of classes. The class table is used to look up classes"},{"Add":"// (CgenNodes) by name, and it also handles global code generation tasks."},{"Add":"// The CgenClassTable constructor is where you'll find the entry point for"},{"Add":"// code generation for an entire Cool program."},{"Add":"class CgenClassTable : public cool::SymbolTable {"},{"Add":"public:"},{"Add":" // CgenClassTable constructor begins and ends the code generation process"},{"Add":" CgenClassTable(Classes);"},{"Add":""},{"Add":"private:"},{"Add":" // The following creates an inheritance graph from a list of classes."},{"Add":" // The graph is implemented as a tree of `CgenNode', and class names"},{"Add":" // are placed in the base class symbol table."},{"Add":" void install_basic_classes();"},{"Add":""},{"Add":" void install_classes(Classes cs);"},{"Add":""},{"Add":" void install_class(CgenNode *nd);"},{"Add":""},{"Add":" void install_special_class(CgenNode *nd);"},{"Add":""},{"Add":" void build_inheritance_tree();"},{"Add":""},{"Add":" void set_relations(CgenNode *nd);"},{"Add":""},{"Add":" // Create declarations for C runtime functions we need to generate code"},{"Add":" void setup_external_functions();"},{"Add":""},{"Add":" void setup_classes(CgenNode *c, int depth);"},{"Add":""},{"Add":" // Setup each class in the table and prepare for code generation phase"},{"Add":" void setup();"},{"Add":""},{"Add":" // Code generation functions. You need to write these functions."},{"Add":" void code_module();"},{"Add":""},{"Add":" void code_classes(CgenNode *c);"},{"Add":""},{"Add":" void code_constants();"},{"Add":""},{"Add":" void code_main();"},{"Add":""},{"Add":" /* Util functions */"},{"Add":" CgenNode *root(); // Get the root of the class Tree, i.e. Object"},{"Add":"public:"},{"Add":" int get_num_classes() const { return current_tag; }"},{"Add":""},{"Add":"private:"},{"Add":" // Class lists and current class tag"},{"Add":" std::vector nds, special_nds;"},{"Add":" int current_tag;"},{"Add":""},{"Add":"public:"},{"Add":" // LLVM Util"},{"Add":" llvm::Function *create_llvm_function(const std::string &funcName,"},{"Add":" llvm::Type *retType,"},{"Add":" llvm::ArrayRef argTypes,"},{"Add":" bool isVarArgs);"},{"Add":""},{"Add":" llvm::Function *create_function(const std::string &name,"},{"Add":" llvm::Type *ret_type,"},{"Add":" llvm::ArrayRef arg_types,"},{"Add":" llvm::GlobalValue::LinkageTypes linkage);"},{"Add":""},{"Add":" llvm::Function *create_var_function(const std::string &name,"},{"Add":" llvm::Type *ret_type,"},{"Add":" llvm::ArrayRef arg_types,"},{"Add":" llvm::GlobalValue::LinkageTypes"},{"Add":" linkage);"},{"Add":""},{"Add":" // CgenClassTable owns the current LLVM module and everything attached."},{"Add":" // One program, one class table, one module."},{"Add":" llvm::LLVMContext context;"},{"Add":" llvm::IRBuilder<> builder;"},{"Add":" llvm::Module the_module;"},{"Add":" llvm::DIBuilder di_builder;"},{"Add":" llvm::DIFile* di_file;"},{"Add":" llvm::DICompileUnit* di_cu;"},{"Add":""},{"Add":" llvm::Type *i1;"},{"Add":" llvm::Type *i8;"},{"Add":" llvm::PointerType *ptr;"},{"Add":" llvm::Type *i32;"},{"Add":" llvm::Type *void_;"},{"Add":""},{"Add":" llvm::DIBasicType* di1;"},{"Add":" llvm::DIBasicType* di8;"},{"Add":" llvm::DIBasicType* di32;"},{"Add":" llvm::DIDerivedType* dptr;"},{"Add":" llvm::DIBasicType* dvoid;"},{"Add":"};"},{"Add":"#pragma endregion"},{"Add":""},{"Add":"#pragma region \"CgenNode\""},{"Add":"// Each CgenNode corresponds to a Cool class. As such, it is responsible for"},{"Add":"// performing code generation on the class level. This includes laying out"},{"Add":"// the class attributes, creating the necessary Types for the class and"},{"Add":"// generating code for each of its methods."},{"Add":"class CgenNode : public class__class {"},{"Add":"public:"},{"Add":" enum Basicness { Basic, NotBasic };"},{"Add":""},{"Add":" CgenNode(Class_ c, Basicness bstatus, CgenClassTable *class_table)"},{"Add":" : class__class((const class__class &) *c), parentnd(0), children(0),"},{"Add":" basic_status(bstatus), class_table(class_table), tag(-1), ctx(class_table->context),"},{"Add":" i1(class_table->i1), i8(class_table->i8), ptr(class_table->ptr),"},{"Add":" i32(class_table->i32), void_(class_table->void_),"},{"Add":" type(nullptr), vtable_type(nullptr), vtable(nullptr),"},{"Add":" di_builder(class_table->di_builder)"},{"Add":" {}"},{"Add":""},{"Add":" // Relationships with other nodes in the tree"},{"Add":" void set_parent(CgenNode *p)"},{"Add":" {"},{"Add":" assert(this->parentnd == nullptr && p != nullptr);"},{"Add":" p->children.push_back(this);"},{"Add":" this->parentnd = p;"},{"Add":" }"},{"Add":""},{"Add":" std::optional get_direct_parent() const"},{"Add":" {"},{"Add":" if (parentnd->basic())"},{"Add":" return std::nullopt;"},{"Add":" return parentnd;"},{"Add":" }"},{"Add":""},{"Add":" int basic() const { return basic_status == Basic; }"},{"Add":" std::vector &get_children() { return children; }"},{"Add":" void set_max_child(int mc) { max_child = mc; }"},{"Add":" int get_max_child() const { return max_child; }"},{"Add":""},{"Add":" // Accessors for other provided fields"},{"Add":" int get_tag() const { return tag; }"},{"Add":" CgenClassTable *get_classtable() const { return class_table; }"},{"Add":""},{"Add":" llvm::StructType *type;"},{"Add":" llvm::StructType *vtable_type;"},{"Add":" llvm::GlobalVariable *vtable;"},{"Add":""},{"Add":" llvm::DIType* dtype;"},{"Add":""},{"Add":" std::string get_type_name() const { return name->get_string(); }"},{"Add":""},{"Add":" std::string get_vtable_type_name() const"},{"Add":" {"},{"Add":" return \"_\" + get_type_name() + \"_vtable\";"},{"Add":" }"},{"Add":""},{"Add":" std::string get_vtable_name() const"},{"Add":" {"},{"Add":" return \"_\" + get_type_name() + \"_vtable_prototype\";"},{"Add":" }"},{"Add":""},{"Add":" std::string get_init_function_name() const { return get_type_name() + \"_new\"; }"},{"Add":""},{"Add":" // Class setup. You need to write the body of this function."},{"Add":" void setup(int tag, int depth);"},{"Add":""},{"Add":" // Layout the methods and attributes for code generation"},{"Add":" void layout_features();"},{"Add":""},{"Add":" // Class codegen. You need to write the body of this function."},{"Add":" void code_class();"},{"Add":""},{"Add":" // Codegen for the init function of every class"},{"Add":" void code_init_function(CgenEnvironment *env) const;"},{"Add":""},{"Add":" void make_vtable_type(CgenEnvironment *env);"},{"Add":""},{"Add":" std::vector > methods;"},{"Add":" std::vector > attributes;"},{"Add":""},{"Add":" llvm::Function *create_function(const std::string &fName, llvm::FunctionType *ty) const"},{"Add":" {"},{"Add":" return llvm::Function::Create(ty, llvm::GlobalValue::ExternalLinkage,"},{"Add":" this->name->get_string() + \"_\" + fName,"},{"Add":" this->class_table->the_module);"},{"Add":" }"},{"Add":""},{"Add":" static llvm::FunctionType *create_functionty(llvm::Type *retType,"},{"Add":" llvm::ArrayRef argTypes)"},{"Add":" {"},{"Add":" return llvm::FunctionType::get(retType, argTypes, false);"},{"Add":" }"},{"Add":""},{"Add":" void make_vtable_prototype(CgenEnvironment *env);"},{"Add":""},{"Add":" void premake_type()"},{"Add":" {"},{"Add":" assert(type == nullptr);"},{"Add":" this->type = llvm::StructType::create(ctx,"},{"Add":" this->name->get_string());"},{"Add":" assert(type != nullptr);"},{"Add":" }"},{"Add":" void premake_debug_type();"},{"Add":""},{"Add":" llvm::DIBuilder &di_builder;"},{"Add":" std::vector dfeats;"},{"Add":"private:"},{"Add":" CgenNode *parentnd; // Parent of class"},{"Add":" std::vector children; // Children of class"},{"Add":" Basicness basic_status; // `Basic' or 'NotBasic'"},{"Add":" CgenClassTable *class_table;"},{"Add":" // Class tag. Should be unique for each class in the tree"},{"Add":" int tag, max_child;"},{"Add":" llvm::LLVMContext &ctx;"},{"Add":""},{"Add":""},{"Add":" llvm::Type *i1;"},{"Add":" llvm::Type *i8;"},{"Add":" llvm::PointerType *ptr;"},{"Add":" llvm::Type *i32;"},{"Add":" llvm::Type *void_;"},{"Add":""},{"Add":" void make_type_forrealz(CgenEnvironment *env);"},{"Add":""},{"Add":" void make_debug_type(CgenEnvironment* env);"},{"Add":"};"},{"Add":"#pragma endregion"},{"Add":""},{"Add":"#pragma region \"CgenEnvironment\""},{"Add":"// CgenEnvironment provides the environment for code generation of a method."},{"Add":"// Its main task is to provide a mapping from Cool names to LLVM Values."},{"Add":"// This mapping needs to be maintained as scopes are entered and exited, new"},{"Add":"// variables are declared, and so on. CgenEnvironment is also a good place"},{"Add":"// to put non-local information you will need during code generation. Two"},{"Add":"// examples are the current CgenNode and the current Function."},{"Add":"class CgenEnvironment {"},{"Add":"public:"},{"Add":" // Class CgenEnvironment should be constructed by a class prior to code"},{"Add":" // generation for each method. You may need to add parameters to this"},{"Add":" // constructor."},{"Add":" CgenEnvironment(CgenNode *cur_class)"},{"Add":" : cur_class(cur_class),"},{"Add":" class_table(*cur_class->get_classtable()),"},{"Add":" context(class_table.context),"},{"Add":" builder(class_table.builder), the_module(class_table.the_module), data_layout(&the_module),"},{"Add":" i1(class_table.i1), i8(class_table.i8), ptr(class_table.ptr),"},{"Add":" i32(class_table.i32), void_(class_table.void_)"},{"Add":" {"},{"Add":" vars.enterscope();"},{"Add":" }"},{"Add":""},{"Add":" CgenNode *get_class() const { return cur_class; }"},{"Add":" void set_class(CgenNode *c) { cur_class = c; }"},{"Add":""},{"Add":" // Must return the CgenNode for a class given the symbol of its name"},{"Add":" CgenNode *type_to_class(Symbol t) const;"},{"Add":""},{"Add":" std::pair find_in_scopes(Symbol name) const;"},{"Add":" std::optional find_if_exists(Symbol name) const;"},{"Add":""},{"Add":""},{"Add":" void add_binding(Symbol name, llvm::Value *val_ptr)"},{"Add":" {"},{"Add":" vars.insert(name, val_ptr);"},{"Add":" }"},{"Add":""},{"Add":" void open_scope() { vars.enterscope(); }"},{"Add":" void close_scope() { vars.exitscope(); }"},{"Add":""},{"Add":" // LLVM Utils:"},{"Add":" // Create a new llvm function in the current module with class name appended"},{"Add":" llvm::Function *get_function(Symbol name) const"},{"Add":" {"},{"Add":" return the_module.getFunction(name->get_string());"},{"Add":" }"},{"Add":""},{"Add":" // Insert a new BasicBlock at the end of the current function (the function"},{"Add":" // that builder is in)"},{"Add":" llvm::BasicBlock *new_bb_at_end(const std::string &name)"},{"Add":" {"},{"Add":" return llvm::BasicBlock::Create(context, name,"},{"Add":" builder.GetInsertBlock()->getParent());"},{"Add":" }"},{"Add":""},{"Add":" // Insert an alloca instruction in the head BasicBlock of the current"},{"Add":" // function, such that this alloca is available in all BasicBlocks of the"},{"Add":" // function."},{"Add":" llvm::AllocaInst *insert_alloca_at_head(llvm::Type *ty);"},{"Add":""},{"Add":" llvm::AllocaInst *insert_alloca_at_head(llvm::Type *, llvm::Twine const &);"},{"Add":""},{"Add":" // Get or insert a BasicBlock with the name \"abort\" which calls the ::abort"},{"Add":" // function. This block will be inserted at the end of the given function,"},{"Add":" // without moving the builder."},{"Add":" llvm::BasicBlock *get_or_insert_abort_block(llvm::Function *f);"},{"Add":""},{"Add":" llvm::Type *as_type(Symbol) const __attribute((pure));"},{"Add":" llvm::Type *as_mostly_boxed_type(Symbol) const __attribute((pure));"},{"Add":" llvm::DIType* as_boxed_dtype(Symbol) const __attribute((pure));"},{"Add":""},{"Add":" llvm::Value* default_value(llvm::Type*) const __attribute((pure));"},{"Add":" // Generate any code necessary to convert from given Value* to"},{"Add":" // dest_type, assuming it has already been checked to be compatible"},{"Add":" llvm::Value* conform(llvm::Value* src, llvm::Type* dest_type) __attribute((pure));"},{"Add":"private:"},{"Add":" // mapping from variable names to memory locations"},{"Add":" cool::SymbolTable vars;"},{"Add":" CgenNode *cur_class;"},{"Add":""},{"Add":"public:"},{"Add":" CgenClassTable &class_table;"},{"Add":" // These are references to the current LLVM context and module,"},{"Add":" // and they point to the ones in CgenClassTable."},{"Add":" llvm::LLVMContext &context;"},{"Add":" llvm::IRBuilder<> &builder;"},{"Add":" llvm::Module &the_module;"},{"Add":" llvm::DataLayout data_layout;"},{"Add":""},{"Add":" llvm::Type *i1;"},{"Add":" llvm::Type *i8;"},{"Add":" llvm::PointerType *ptr;"},{"Add":" llvm::Type *i32;"},{"Add":" llvm::Type *void_;"},{"Add":"};"},{"Add":"#pragma endregion"},{"Add":""}]}},{"FileAdd":{"meta":{"basename":"ast_parse.h","metadata":0},"context":[{"change":0,"pos":222547}],"contents":[{"Add":"#ifndef _AST_PARSE_H"},{"Add":"#define _AST_PARSE_H"},{"Add":"//"},{"Add":"// See copyright.h for copyright notice and limitation of liability"},{"Add":"// and disclaimer of warranty provisions."},{"Add":"//"},{"Add":"#include \"copyright.h\""},{"Add":""},{"Add":"class Entry;"},{"Add":"typedef Entry *Symbol;"},{"Add":""},{"Add":"#define MAX_STR_CONST 1025"},{"Add":"#define YY_NO_UNPUT"},{"Add":"#define yylval ast_yylval"},{"Add":"#define yylex ast_yylex"},{"Add":""},{"Add":"#include \"tree.h\""},{"Add":"typedef class Program_class *Program;"},{"Add":"typedef class Class__class *Class_;"},{"Add":"typedef class Feature_class *Feature;"},{"Add":"typedef class Formal_class *Formal;"},{"Add":"typedef class Expression_class *Expression;"},{"Add":"typedef class Case_class *Case;"},{"Add":"typedef list_node Classes_class;"},{"Add":"typedef Classes_class *Classes;"},{"Add":"typedef list_node Features_class;"},{"Add":"typedef Features_class *Features;"},{"Add":"typedef list_node Formals_class;"},{"Add":"typedef Formals_class *Formals;"},{"Add":"typedef list_node Expressions_class;"},{"Add":"typedef Expressions_class *Expressions;"},{"Add":"typedef list_node Cases_class;"},{"Add":"typedef Cases_class *Cases;"},{"Add":"#ifndef BISON_AST_TAB_H"},{"Add":"#define BISON_AST_TAB_H"},{"Add":""},{"Add":"#ifndef YYSTYPE"},{"Add":"typedef union {"},{"Add":" int lineno;"},{"Add":" bool boolean;"},{"Add":" Symbol symbol;"},{"Add":" Program program;"},{"Add":" Class_ class_;"},{"Add":" Classes classes;"},{"Add":" Feature feature;"},{"Add":" Features features;"},{"Add":" Formal formal;"},{"Add":" Formals formals;"},{"Add":" Case case_;"},{"Add":" Cases cases;"},{"Add":" Expression expression;"},{"Add":" Expressions expressions;"},{"Add":"} yystype;"},{"Add":"#define YYSTYPE yystype"},{"Add":"#define YYSTYPE_IS_TRIVIAL 1"},{"Add":"#endif"},{"Add":"#define PROGRAM 257"},{"Add":"#define CLASS 258"},{"Add":"#define METHOD 259"},{"Add":"#define ATTR 260"},{"Add":"#define FORMAL 261"},{"Add":"#define BRANCH 262"},{"Add":"#define ASSIGN 263"},{"Add":"#define STATIC_DISPATCH 264"},{"Add":"#define DISPATCH 265"},{"Add":"#define COND 266"},{"Add":"#define LOOP 267"},{"Add":"#define TYPCASE 268"},{"Add":"#define BLOCK 269"},{"Add":"#define LET 270"},{"Add":"#define PLUS 271"},{"Add":"#define SUB 272"},{"Add":"#define MUL 273"},{"Add":"#define DIVIDE 274"},{"Add":"#define NEG 275"},{"Add":"#define LESSTHAN 276"},{"Add":"#define EQUAL 277"},{"Add":"#define LEQ 278"},{"Add":"#define COMP 279"},{"Add":"#define INT 280"},{"Add":"#define STR 281"},{"Add":"#define BOOL 282"},{"Add":"#define NEW 283"},{"Add":"#define ISVOID 284"},{"Add":"#define NO_EXPR 285"},{"Add":"#define OBJECT 286"},{"Add":"#define NO_TYPE 287"},{"Add":"#define STR_CONST 288"},{"Add":"#define INT_CONST 289"},{"Add":"#define IDENT 290"},{"Add":"#define LINENO 291"},{"Add":""},{"Add":"extern YYSTYPE yylval;"},{"Add":""},{"Add":"#endif /* not BISON_AST_TAB_H */"},{"Add":"#endif"}]}},{"FileAdd":{"meta":{"basename":"README.md","metadata":0},"context":[{"change":0,"pos":1}],"contents":[{"Add":"`src`: COOL codegen and frontend"},{"Add":"`lib`: COOL AST and auxiliary code"},{"Add":"`rt`: COOL runtime"}]}},{"FileAdd":{"meta":{"basename":"CMakeLists.txt","metadata":0},"context":[{"change":0,"pos":1}],"contents":[{"Add":" "}]}},{"FileAdd":{"meta":{"basename":"BUILD.bazel","metadata":0},"context":[{"change":0,"pos":1}],"contents":[{"Add":"load(\"//:pch.bzl\", \"pch\")"},{"Add":""},{"Add":""},{"Add":"cc_library("},{"Add":" name = \"support\","},{"Add":" srcs = glob([\"lib/*.cc\"]) + select({"},{"Add":" \"@bazel_tools//src/conditions:windows\": ["},{"Add":" \"lib/win/getopt.c\","},{"Add":" \"lib/win/getopt.h\","},{"Add":" \"lib/win/unistd.h\","},{"Add":" ],"},{"Add":" \"//conditions:default\": [],"},{"Add":" }),"},{"Add":" hdrs = ["},{"Add":" \"include/ast_parse.h\","},{"Add":" \"include/cool_tree.h\","},{"Add":" \"include/cool_tree.handcode.h\","},{"Add":" \"include/copyright.h\","},{"Add":" \"include/stringtab.h\","},{"Add":" \"include/stringtab.handcode.h\","},{"Add":" \"include/symtab.h\","},{"Add":" \"include/tree.h\","},{"Add":" \"include/utils.h\","},{"Add":" ],"},{"Add":" includes = [\"include\"],"},{"Add":" copts = [\"-Os\", \"-std=c++17\", \"-Wno-register\"],"},{"Add":" deps = [],"},{"Add":")"},{"Add":""},{"Add":"pch("},{"Add":" name = \"support_pch\","},{"Add":" includes = ["},{"Add":" \"ast_parse.h\","},{"Add":" \"cool_tree.h\","},{"Add":" \"cool_tree.handcode.h\","},{"Add":" \"copyright.h\","},{"Add":" \"stringtab.h\","},{"Add":" \"stringtab.handcode.h\","},{"Add":" \"symtab.h\","},{"Add":" \"tree.h\","},{"Add":" \"utils.h\","},{"Add":" ],"},{"Add":" deps = [\":support\"],"},{"Add":")"},{"Add":""},{"Add":""},{"Add":"cc_library("},{"Add":" name = \"runtime\","},{"Add":" srcs = glob([\"rt/*.c\"]),"},{"Add":" hdrs = glob([\"rt/*.h\"]),"},{"Add":" copts = [\"-Os\", \"-DNDEBUG\"],"},{"Add":" visibility = [\"//visibility:public\"],"},{"Add":")"},{"Add":""},{"Add":"cc_library("},{"Add":" name = \"codegen\","},{"Add":" srcs = [\"src/cgen.cc\"],"},{"Add":" hdrs = [\"include/cgen.h\"],"},{"Add":" deps = ["},{"Add":" \":support_pch\","},{"Add":" \":support\","},{"Add":" \"//llvm:ir_headers_pch\","},{"Add":" \"//llvm:support_pch\","},{"Add":" \"//llvm:Core\","},{"Add":" \"//llvm:Support\","},{"Add":" ],"},{"Add":" copts = [\"-std=c++17\"]"},{"Add":")"},{"Add":""},{"Add":"cc_binary("},{"Add":" name = \"cgen\","},{"Add":" deps = [\":codegen\"],"},{"Add":" visibility = [\"//visibility:public\"],"},{"Add":")"}]}}],"owner":"nuudlman","repo":"llvm","token":"YYpix9KfOCROPhrk4Y3We+YJJsvyQ8A9ja6BUqUpewE=","login":null}

…

Dependencies

Change contents