void dump_defmethod(struct id *name, struct component *c) { if (!ModuleDumped) { dump_op(fop_IN_MODULE); dump_symbol(ModuleName); ModuleDumped = true; } dump_op(fop_DEFINE_METHOD); dump_symbol(name->symbol); dump_component(c); }
void dump_defgeneric(struct id *name, struct component *tlf) { if (!ModuleDumped) { dump_op(fop_IN_MODULE); dump_symbol(ModuleName); ModuleDumped = true; } dump_op(fop_DEFINE_GENERIC); dump_symbol(name->symbol); dump_component(tlf); }
static void dump_vars(struct scope_info *scope) { struct var_info *var_info; if (scope->handle != -1) dump_ref(scope->handle); else { scope->handle = dump_store(); if (scope->outer) dump_op(fop_DOTTED_LIST1); else dump_op(fop_LIST1); dump_vector_header(scope->nvars); for (var_info=scope->vars; var_info != NULL; var_info=var_info->next) { int loc_info = var_info->offset << 2; if (var_info->indirect) loc_info |= 2; if (var_info->argument) loc_info |= 1; dump_op(fop_VECTOR2); dump_symbol(var_info->var->symbol); dump_integer(loc_info); } if (scope->outer) dump_vars(scope->outer); } }
static void dump_symboltable_rec (FILE* outfile, astree* root, int depth) { if (root == NULL) return; //fprintf (outfile, "%*s%s ", depth * 3, "", // root->lexinfo->c_str()); dump_symbol (root, depth); fprintf (outfile, "\n"); for (size_t child = 0; child < root->children.size(); ++child) { //print after all children have symbol_stack.push_back(nullptr); next_block++; //print here dump_symboltable_rec_helper(outfile, symbol_stack.back()); //tabLinesSym.erase(tabLinesSym.end()-4,tabLinesSym.end()); next_block--; symbol_stack.pop_back(); } printf("TEST3\n"); //type_check(root, *symbol_stack.back()); printf("TEST4\n"); dump_symboltable_rec_helper(outfile, symbol_stack.back()); //tabLinesSym.erase(tabLinesSym.end()-4,tabLinesSym.end()); printf("TEST5\n"); next_block--; symbol_stack.pop_back(); printf("TEST6\n"); // dump_symboltable_rec (outfile, root->children[child],depth + 1); //delete root; }
static void dump_defconst_or_var(struct param_list *params) { int count; struct param *p; count = 0; for (p = params->required_params; p != NULL; p = p->next) count++; if (params->rest_param) count++; dump_integer(count); for (p = params->required_params; p != NULL; p = p->next) dump_symbol(p->id->symbol); if (params->rest_param) dump_symbol(params->rest_param->symbol); }
void dump_setup_output(char *source, FILE *file) { struct stat buf; time_t tv; int statres; File = file; #if ! NO_SHARP_BANG fprintf(File, "#! /usr/bin/env mindy -x\n"); #endif fprintf(File, "# %s (%d.%d) of %s\n", "compilation", file_MajorVersion, file_MinorVersion, source); statres = stat(source, &buf); if (statres >= 0) fprintf(File, "# last modified on %s", ctime(&buf.st_mtime)); fprintf(File, "# produced with the %s version of mindycomp\n", Version); time(&tv); fprintf(File, "# at %s", ctime(&tv)); dump_op(fop_HEADER); dump_byte(file_MajorVersion); dump_byte(file_MinorVersion); dump_byte(sizeof(short)); dump_byte(sizeof(int)); dump_byte(sizeof(long)); dump_byte(sizeof(float)); dump_byte(sizeof(double)); dump_byte(sizeof(long double)); dump_short(1); dump_int(dbc_MagicNumber); dump_op(fop_IN_LIBRARY); if (LibraryName) dump_symbol(LibraryName); else dump_symbol(sym_DylanUser); if (source != NULL) { dump_op(fop_SOURCE_FILE); if (statres >= 0) dump_integer(buf.st_mtime); else dump_integer(0); dump_string_guts(fop_SHORT_STRING, fop_STRING, source, strlen(source)); } }
void dump_top_level_form(struct component *c) { if (!ModuleDumped) { dump_op(fop_IN_MODULE); dump_symbol(ModuleName); ModuleDumped = true; } dump_op(fop_TOP_LEVEL_FORM); dump_component(c); }
void dump_defvar(struct param_list *params, struct component *initializer) { if (!ModuleDumped) { dump_op(fop_IN_MODULE); dump_symbol(ModuleName); ModuleDumped = true; } dump_op(fop_DEFINE_VARIABLE); dump_defconst_or_var(params); dump_component(initializer); }
void dump_defclass(struct id *name, struct slot_spec *slots, struct component *tlf1, struct component *tlf2) { struct slot_spec *slot; if (!ModuleDumped) { dump_op(fop_IN_MODULE); dump_symbol(ModuleName); ModuleDumped = true; } dump_op(fop_DEFINE_CLASS); dump_symbol(name->symbol); for (slot = slots; slot != NULL; slot = slot->next) { dump_symbol(slot->getter->symbol); if (slot->setter) dump_symbol(slot->setter->symbol); } dump_op(fop_FALSE); dump_component(tlf1); dump_component(tlf2); }
static void dump_method(struct method *method) { struct param_list *params = method->params; struct keyword_param *k; int param_info, nkeys; int nclosure_vars; struct closes_over *over; if (params->rest_param) param_info = 1; else param_info = 0; if (params->all_keys) param_info |= 2; if (params->allow_keys) { nkeys = 0; for (k = params->keyword_params; k != NULL; k = k->next) nkeys++; param_info = param_info | (nkeys+1)<<2; } nclosure_vars = 0; for (over = method->closes_over; over != NULL; over = over->next) nclosure_vars++; if (param_info < 256 && nclosure_vars < 256) { dump_op(fop_SHORT_METHOD); dump_byte(param_info); dump_byte(nclosure_vars); } else { dump_op(fop_METHOD); dump_int(param_info); dump_int(nclosure_vars); } for (k = params->keyword_params; k != NULL; k = k->next) { struct literal_expr *def = (struct literal_expr *)k->def; dump_symbol(k->keyword); if (def) { if (def->kind != expr_LITERAL) lose("non-literal keyword default made it though expand?"); dump_literal(def->lit); } else dump_op(fop_FALSE); } dump_component(method->component); }
static void dump_param_list(struct param_list *params) { struct param *p; int nparams = 0; for (p = params->required_params; p != NULL; p = p->next) nparams++; dump_integer(nparams); for (p = params->required_params; p != NULL; p = p->next) { dump_id(p->id); if (p->type) dump_expr(p->type); else dump_op(fop_FALSE); } if (params->next_param) dump_id(params->next_param); else dump_op(fop_FALSE); if (params->rest_param) dump_id(params->rest_param); else dump_op(fop_FALSE); if (params->allow_keys) { struct keyword_param *k; int nkeys = 0; for (k = params->keyword_params; k != NULL; k = k->next) nkeys++; dump_integer(nkeys); for (k = params->keyword_params; k != NULL; k = k->next) { dump_symbol(k->keyword); dump_id(k->id); if (k->type) dump_expr(k->type); else dump_op(fop_FALSE); if (k->def) dump_expr(k->def); else dump_op(fop_FALSE); } } else dump_op(fop_FALSE); }
static void dump_plist(struct plist *plist) { if (plist) { struct property *p; int nprops = 0; for (p = plist->head; p != NULL; p = p->next) nprops++; dump_integer(nprops); for (p = plist->head; p != NULL; p = p->next) { dump_symbol(p->keyword); dump_expr(p->expr); } } else dump_integer(0); }
static void dump_varref(struct id *id, bool written) { if (id->line) { dump_op(fop_NOTE_REFERENCE); dump_int(id->line); } if (id->internal) if (written) dump_op(fop_BUILTIN_WRITABLE_VALUE_CELL); else dump_op(fop_BUILTIN_VALUE_CELL); else if (written) dump_op(fop_WRITABLE_VALUE_CELL); else dump_op(fop_VALUE_CELL); dump_symbol(id->symbol); }
void dump_symbol_tables ( void ) { unsigned char i; sb_symbol_node_t *n; printf ( "Scope depth: %d\n", g_sb_scopemax_highest ); for ( i = 0; i <= g_sb_scopemax_highest; i++ ) { printf ( "Symbol table %d\n", i ); n = g_sb_symbolstack [ i ]; g_sb_indent += 2; dump_symbol ( n ); g_sb_indent -= 2; printf ( "End table %d\n", i ); } // for } // dump_tables
static void dump_symbol_literal(struct symbol_literal *literal) { dump_symbol(literal->symbol); }
static void dump_defclass_constituent(struct defclass_constituent *c) { struct superclass *super; struct slot_spec *slot; struct initarg_spec *initarg; struct inherited_spec *inherited; int n; dump_op(fop_DEFINE_CLASS); n = 0; for (super = c->supers; super != NULL; super = super->next) n++; dump_integer(n); for (super = c->supers; super != NULL; super = super->next) dump_expr(super->expr); n = 0; for (slot = c->slots; slot != NULL; slot = slot->next) n++; dump_integer(n); for (slot = c->slots; slot != NULL; slot = slot->next) { switch (slot->alloc) { case alloc_INSTANCE: dump_symbol(sym_Instance); break; case alloc_CLASS: dump_symbol(sym_Class); break; case alloc_EACH_SUBCLASS: dump_symbol(sym_Each_Subclass); break; case alloc_VIRTUAL: dump_symbol(sym_Virtual); break; default: lose("strange slot allocation"); } if (slot->name) dump_id(slot->name); else dump_op(fop_FALSE); if (slot->type) dump_expr(slot->type); else dump_op(fop_FALSE); dump_plist(slot->plist); } n = 0; for (initarg = c->initargs; initarg != NULL; initarg = initarg->next) n++; dump_integer(n); for (initarg = c->initargs; initarg != NULL; initarg = initarg->next) { dump_symbol(initarg->keyword); dump_plist(initarg->plist); } n = 0; for (inherited = c->inheriteds; inherited != NULL; inherited = inherited->next) n++; dump_integer(n); for (inherited = c->inheriteds; inherited != NULL; inherited = inherited->next) { dump_id(inherited->name); dump_plist(inherited->plist); } }
static void dump_id(struct id *id) { dump_symbol(id->symbol); dump_op(id->internal ? fop_TRUE : fop_FALSE); dump_integer(id->line); }