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_debug_info(struct component *c) { struct debug_info *info; dump_vector_header(c->ndebug_infos); for (info = c->debug_info; info != NULL; info = info->next) { dump_op(fop_VECTOR3); dump_integer(info->line); dump_integer(info->bytes); if (info->scope) dump_vars(info->scope); else dump_op(fop_NIL); } }
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_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); }
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)); } }
static void dump_body(struct body *body) { struct constituent *c; int nconstits = 0; for (c = body->head; c != NULL; c = c->next) nconstits++; dump_integer(nconstits); for (c = body->head; c != NULL; c = c->next) (*DumpConstituents[(int)c->kind])(c); }
static void dump_call_expr(struct call_expr *expr) { struct argument *args; int nargs = 0; dump_op(fop_CALL_EXPR); dump_expr(expr->func); for (args = expr->args; args != NULL; args = args->next) nargs++; dump_integer(nargs); for (args = expr->args; args != NULL; args = args->next) dump_expr(args->expr); }
static void dump_local_constituent(struct local_constituent *c) { struct method *m; int nlocals = 0; dump_op(fop_LOCAL_CONSTITUENT); for (m = c->methods; m != NULL; m = m->next_local) nlocals++; dump_integer(nlocals); for (m = c->methods; m != NULL; m = m->next_local) dump_method_parse(m); dump_body(c->body); }
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); }
static void dump_rettypes(struct return_type_list *rettypes) { struct return_type *r; int nreq = 0; if (rettypes != NULL) { for (r = rettypes->req_types; r != NULL; r = r->next) nreq++; dump_integer(nreq); for (r = rettypes->req_types; r != NULL; r = r->next) if (r->type) dump_expr(r->type); else dump_op(fop_FALSE); if (rettypes->rest_type) dump_expr(r->type); else dump_op(fop_FALSE); } else dump_op(fop_FALSE); }
static void dump_component(struct component *c) { struct constant *constant; struct block *block; int bytes; if (c->nconstants <= UCHAR_MAX && c->bytes <= USHRT_MAX) { dump_op(fop_SHORT_COMPONENT); dump_byte(c->nconstants); dump_short((short)(c->bytes)); } else { dump_op(fop_COMPONENT); dump_int(c->nconstants); dump_int(c->bytes); } if (c->debug_name) dump_literal(c->debug_name); else dump_op(fop_FALSE); dump_integer(c->frame_size); dump_debug_info(c); for (constant = c->constants; constant != NULL; constant = constant->next) dump_constant(constant); bytes = 0; for (block = c->blocks; block != NULL; block = block->next) { int count = block->end - block->bytes; dump_bytes(block->bytes, count); bytes += count; } if (bytes != c->bytes) lose("Planned on writing %d bytes, but ended up writing %d instead.", c->bytes, bytes); }
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); }
static void dump_integer_literal(struct integer_literal *literal) { dump_integer(literal->value); }
/*! @brief internal implementation of the serialization function This function is called by the public member function dump and organizes the serialization internally. The indentation level is propagated as additional parameter. In case of arrays and objects, the function is called recursively. - strings and object keys are escaped using `escape_string()` - integer numbers are converted implicitly via `operator<<` - floating-point numbers are converted to a string using `"%g"` format @param[in] val value to serialize @param[in] pretty_print whether the output shall be pretty-printed @param[in] indent_step the indent level @param[in] current_indent the current indent level (only used internally) */ void dump(const BasicJsonType& val, const bool pretty_print, const bool ensure_ascii, const unsigned int indent_step, const unsigned int current_indent = 0) { switch (val.m_type) { case value_t::object: { if (val.m_value.object->empty()) { o->write_characters("{}", 2); return; } if (pretty_print) { o->write_characters("{\n", 2); // variable to hold indentation for recursive calls const auto new_indent = current_indent + indent_step; if (JSON_UNLIKELY(indent_string.size() < new_indent)) { indent_string.resize(indent_string.size() * 2, ' '); } // first n-1 elements auto i = val.m_value.object->cbegin(); for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i) { o->write_characters(indent_string.c_str(), new_indent); o->write_character('\"'); dump_escaped(i->first, ensure_ascii); o->write_characters("\": ", 3); dump(i->second, true, ensure_ascii, indent_step, new_indent); o->write_characters(",\n", 2); } // last element assert(i != val.m_value.object->cend()); assert(std::next(i) == val.m_value.object->cend()); o->write_characters(indent_string.c_str(), new_indent); o->write_character('\"'); dump_escaped(i->first, ensure_ascii); o->write_characters("\": ", 3); dump(i->second, true, ensure_ascii, indent_step, new_indent); o->write_character('\n'); o->write_characters(indent_string.c_str(), current_indent); o->write_character('}'); } else { o->write_character('{'); // first n-1 elements auto i = val.m_value.object->cbegin(); for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i) { o->write_character('\"'); dump_escaped(i->first, ensure_ascii); o->write_characters("\":", 2); dump(i->second, false, ensure_ascii, indent_step, current_indent); o->write_character(','); } // last element assert(i != val.m_value.object->cend()); assert(std::next(i) == val.m_value.object->cend()); o->write_character('\"'); dump_escaped(i->first, ensure_ascii); o->write_characters("\":", 2); dump(i->second, false, ensure_ascii, indent_step, current_indent); o->write_character('}'); } return; } case value_t::array: { if (val.m_value.array->empty()) { o->write_characters("[]", 2); return; } if (pretty_print) { o->write_characters("[\n", 2); // variable to hold indentation for recursive calls const auto new_indent = current_indent + indent_step; if (JSON_UNLIKELY(indent_string.size() < new_indent)) { indent_string.resize(indent_string.size() * 2, ' '); } // first n-1 elements for (auto i = val.m_value.array->cbegin(); i != val.m_value.array->cend() - 1; ++i) { o->write_characters(indent_string.c_str(), new_indent); dump(*i, true, ensure_ascii, indent_step, new_indent); o->write_characters(",\n", 2); } // last element assert(not val.m_value.array->empty()); o->write_characters(indent_string.c_str(), new_indent); dump(val.m_value.array->back(), true, ensure_ascii, indent_step, new_indent); o->write_character('\n'); o->write_characters(indent_string.c_str(), current_indent); o->write_character(']'); } else { o->write_character('['); // first n-1 elements for (auto i = val.m_value.array->cbegin(); i != val.m_value.array->cend() - 1; ++i) { dump(*i, false, ensure_ascii, indent_step, current_indent); o->write_character(','); } // last element assert(not val.m_value.array->empty()); dump(val.m_value.array->back(), false, ensure_ascii, indent_step, current_indent); o->write_character(']'); } return; } case value_t::string: { o->write_character('\"'); dump_escaped(*val.m_value.string, ensure_ascii); o->write_character('\"'); return; } case value_t::boolean: { if (val.m_value.boolean) { o->write_characters("true", 4); } else { o->write_characters("false", 5); } return; } case value_t::number_integer: { dump_integer(val.m_value.number_integer); return; } case value_t::number_unsigned: { dump_integer(val.m_value.number_unsigned); return; } case value_t::number_float: { dump_float(val.m_value.number_float); return; } case value_t::discarded: { o->write_characters("<discarded>", 11); return; } case value_t::null: { o->write_characters("null", 4); return; } } }