pike.git / src / encode.c

version» Context lines:

pike.git/src/encode.c:982:    if (SUBTYPEOF(*val)) {    /* Subtyped object.    *    * Encode the subtype, and then try encoding the plain object.    */    code_entry(TAG_OBJECT, 4, data);    EDB(1, {    ENCODE_WERR(".entry object, 4");    });    code_number(SUBTYPEOF(*val), data); +  EDB(1, { +  ENCODE_WERR_COMMENT("inherit", +  ".number %ld", SUBTYPEOF(*val)); +  });    pop_stack();    ref_push_object(val->u.object);    break;    }    -  /* We have to remove ourself from the cache */ +  /* We have to remove ourselves from the cache */    map_delete(data->encoded, val);       pop_stack();    push_svalue(val);    f_object_program(1);       /* Code the program */    code_entry(TAG_OBJECT, 3,data);    EDB(1, {    ENCODE_WERR(".entry object, 3");
pike.git/src/encode.c:1201:       EDB(1, fprintf(stderr, "%*sencode: encoding program in new style\n",    data->depth, ""));    code_entry(TAG_PROGRAM, 4, data);    EDB(1, {    ENCODE_WERR(".entry program, 4");    });       /* Byte-order. */    code_number(PIKE_BYTEORDER, data); +  EDB(1, { +  ENCODE_WERR_COMMENT("byte-order", ".number %ld", PIKE_BYTEORDER); +  });       /* flags */    code_number(p->flags,data); -  +  EDB(1, { +  ENCODE_WERR_COMMENT("flags", ".number %ld", p->flags); +  });       /* version */    push_compact_version(); -  +  EDB(1, { +  ENCODE_WERR("# version"); +  });    encode_value2(Pike_sp-1, data, 0);    pop_stack();       /* parent */ -  +  EDB(1, { +  ENCODE_WERR("# parent"); +  });    if (p->parent) {    ref_push_program(p->parent);    } else {    push_int(0);    }    encode_value2(Pike_sp-1, data, 0);    pop_stack();       /* num_* */ - #define FOO(NUMTYPE,TYPE,ARGTYPE,NAME) \ -  code_number( p->PIKE_CONCAT(num_,NAME), data); + #define FOO(NUMTYPE,TYPE,ARGTYPE,NAME) do { \ +  code_number( p->PIKE_CONCAT(num_,NAME), data); \ +  EDB(1, { \ +  ENCODE_WERR_COMMENT(TOSTR(NAME), ".number %ld", \ +  p->PIKE_CONCAT(num_,NAME)); \ +  }); \ +  } while(0); +    #include "program_areas.h"       /* Byte-code method    */    code_number(PIKE_BYTECODE_PORTABLE, data); -  +  EDB(1, { +  ENCODE_WERR("byte-code", ".number %ld", PIKE_BYTECODE_PORTABLE); +  });       {    struct svalue str_sval;    SET_SVAL(str_sval, T_STRING, 0, string, NULL);    /* strings */    for(d=0;d<p->num_strings;d++) {    str_sval.u.string = p->strings[d];    encode_value2(&str_sval, data, 0);    }    }       EDB(5, dump_program_tables(p, data->depth));       /* Encode the efun constants since they are needed by the optimizer. */    {    struct svalue str_sval;    SET_SVAL(str_sval, T_STRING, 0, string, NULL);    -  +  EDB(1, { +  ENCODE_WERR("# Constant table."); +  });    /* constants */    for(d=0;d<p->num_constants;d++)    {    if ((TYPEOF(p->constants[d].sval) == T_FUNCTION) &&    (SUBTYPEOF(p->constants[d].sval) == FUNCTION_BUILTIN)) {    code_number(ID_ENTRY_EFUN_CONSTANT, data); -  +  EDB(1, { +  ENCODE_WERR(".ident efun_constant"); +  });    } else if (TYPEOF(p->constants[d].sval) == T_TYPE) {    code_number(ID_ENTRY_TYPE_CONSTANT, data); -  +  EDB(1, { +  ENCODE_WERR(".ident constant"); +  });    } else {    continue;    }    code_number(d, data); -  +  EDB(1, { +  ENCODE_WERR_COMMENT("constant #", ".number %ld", d); +  });    /* value */    encode_value2(&p->constants[d].sval, data, 0);       /* name */    push_int(0);    encode_value2(Pike_sp-1, data, 0);    dmalloc_touch_svalue(Pike_sp-1);    Pike_sp--;    }    }
pike.git/src/encode.c:1285:    SET_SVAL(str_sval, T_STRING, 0, string, NULL);       EDB(2,    fprintf(stderr, "%*sencode: encoding references\n",    data->depth, ""));      #ifdef ENCODE_DEBUG    data->depth += 2;   #endif    +  EDB(1, { +  ENCODE_WERR("# Identifier reference table."); +  });    /* NOTE: d is incremented by hand inside the loop. */    for (d=0; d < p->num_identifier_references;)    {    int d_max = p->num_identifier_references;       /* Find insertion point of next inherit. */    if (inherit_num < p->num_inherits) {    d_max = p->inherits[inherit_num].identifier_ref_offset;    }   
pike.git/src/encode.c:1357:       if (ref->inherit_offset || ref->id_flags & ID_HIDDEN) {    int ref_no = -1;    /* Explicit reference to inherited symbol. */       EDB(3,    fprintf(stderr, "%*sencode: encoding raw reference\n",    data->depth, ""));       code_number(ID_ENTRY_RAW, data); +  EDB(1, { +  ENCODE_WERR(".ident raw"); +  });    code_number(ref->id_flags, data); -  +  EDB(1, { +  ENCODE_WERR_COMMENT("modifiers", +  ".number %ld", ref->id_flags); +  });       /* inherit_offset */    code_number(ref->inherit_offset, data); -  +  EDB(1, { +  ENCODE_WERR_COMMENT("inherit_offset", +  ".number %ld", ref->inherit_offset); +  });       /* identifier_offset */    /* Find the corresponding identifier reference    * in the inherit. */    {    struct program *p2 = p->inherits[ref->inherit_offset].prog;    int i;    debug_malloc_touch(p);    debug_malloc_touch(p2);    for (i=0; i < p2->num_identifier_references; i++) {
pike.git/src/encode.c:1384:    (ref2->identifier_offset == ref->identifier_offset)) {    ref_no = i;    break;    }    }    }    if (ref_no == -1) {    Pike_error("Failed to reverse explicit reference\n");    }    code_number(ref_no, data); +  EDB(1, { +  ENCODE_WERR_COMMENT("ref_no", ".number %ld", ref_no); +  });    } else {    int gs_flags = -1;       if (id_dumped[ref->identifier_offset]) {    EDB(3,    fprintf(stderr, "%*sencode: already encoded reference\n",    data->depth, ""));    goto next_identifier_ref;    }    id_dumped[ref->identifier_offset] = 1;
pike.git/src/encode.c:1485:    EDB(3, fprintf(stderr,    "%*sencode: encoding aliased variable\n",    data->depth, ""));    goto encode_entry_variable;    }    }    EDB(3, fprintf(stderr, "%*sencode: encoding alias\n",    data->depth, ""));       code_number(ID_ENTRY_ALIAS, data); +  EDB(1, { +  ENCODE_WERR(".ident alias"); +  });       /* flags */    code_number(ref->id_flags, data); -  +  EDB(1, { +  ENCODE_WERR_COMMENT("modifiers", +  ".number %ld", ref->id_flags); +  });       /* name */    str_sval.u.string = id->name;    encode_value2(&str_sval, data, 0);       /* type */    ref_push_type_value(id->type);    encode_value2(Pike_sp-1, data, 0);    pop_stack();       /* filename */    code_number(id->filename_strno, data); -  +  EDB(1, { +  ENCODE_WERR_COMMENT("filename_strno", +  ".number %ld", id->filename_strno); +  });       /* linenumber */    code_number(id->linenumber, data); -  +  EDB(1, { +  ENCODE_WERR_COMMENT("linenumber", +  ".number %ld", id->linenumber); +  });       /* depth */    code_number(id->func.ext_ref.depth, data); -  +  EDB(1, { +  ENCODE_WERR_COMMENT("depth", +  ".number %ld", +  id->func.ext_ref.depth); +  });       /* refno */    code_number(id->func.ext_ref.id, data); -  +  EDB(1, { +  ENCODE_WERR_COMMENT("refno", +  ".number %ld", +  id->func.ext_ref.id); +  });       } else switch (id->identifier_flags & IDENTIFIER_TYPE_MASK) {    case IDENTIFIER_CONSTANT:    EDB(3,    fprintf(stderr, "%*sencode: encoding constant\n",    data->depth, ""));       code_number(ID_ENTRY_CONSTANT, data); -  +  EDB(1, { +  ENCODE_WERR(".ident constant"); +  });    if (gs_flags >= 0) {    code_number(gs_flags, data); -  +  EDB(1, { +  ENCODE_WERR_COMMENT("modifiers", +  ".number %ld", gs_flags); +  });    } else {    code_number(ref->id_flags, data); -  +  EDB(1, { +  ENCODE_WERR_COMMENT("modifiers", +  ".number %ld", ref->id_flags); +  });    }       /* name */    str_sval.u.string = id->name;    encode_value2(&str_sval, data, 0);       /* type */    ref_push_type_value(id->type);    encode_value2(Pike_sp-1, data, 0);    pop_stack();       /* filename */    code_number(id->filename_strno, data); -  +  EDB(1, { +  ENCODE_WERR_COMMENT("filename_strno", +  ".number %ld", id->filename_strno); +  });       /* linenumber */    code_number(id->linenumber, data); -  +  EDB(1, { +  ENCODE_WERR_COMMENT("linenumber", +  ".number %ld", id->linenumber); +  });       /* offset */    code_number(id->func.const_info.offset, data); -  +  EDB(1, { +  ENCODE_WERR_COMMENT("offset", +  ".number %ld", +  id->func.const_info.offset); +  });       /* run-time type */    code_number(id->run_time_type, data); -  +  EDB(1, { +  ENCODE_WERR_COMMENT("run_time_type", +  ".number %ld", id->run_time_type); +  });       /* opt flags */    code_number(id->opt_flags, data); -  +  EDB(1, { +  ENCODE_WERR_COMMENT("opt_flags", +  ".number %ld", id->opt_flags); +  });    break;       case IDENTIFIER_PIKE_FUNCTION:    encode_pike_function:    EDB(3,    fprintf(stderr, "%*sencode: encoding function\n",    data->depth, ""));       code_number(ID_ENTRY_FUNCTION, data); -  +  EDB(1, { +  ENCODE_WERR(".ident function"); +  });    if (gs_flags >= 0) {    code_number(gs_flags, data); -  +  EDB(1, { +  ENCODE_WERR_COMMENT("modifiers", +  ".number %ld", gs_flags); +  });    } else {    code_number(ref->id_flags, data); -  +  EDB(1, { +  ENCODE_WERR_COMMENT("modifiers", +  ".number %ld", ref->id_flags); +  });    }       /* name */    str_sval.u.string = id->name;    encode_value2(&str_sval, data, 0);       /* type */    ref_push_type_value(id->type);    encode_value2(Pike_sp-1, data, 0);    pop_stack();       /* filename */    code_number(id->filename_strno, data); -  +  EDB(1, { +  ENCODE_WERR_COMMENT("filename_strno", +  ".number %ld", id->filename_strno); +  });       /* linenumber */    code_number(id->linenumber, data); -  +  EDB(1, { +  ENCODE_WERR_COMMENT("linenumber", +  ".number %ld", id->linenumber); +  });       /* func_flags (aka identifier_flags) */    code_number(id->identifier_flags, data); -  +  EDB(1, { +  ENCODE_WERR_COMMENT("identifier_flags", +  ".number %ld", +  id->identifier_flags); +  });       /* func */    if (id->func.offset >= 0) {    /* Code the number of the string containing    * the raw bytecode.    */    code_number(read_program_data(p->program + id->func.offset,    -1), data);    } else {    /* Prototype */    code_number(-1, data);    } -  +  EDB(1, { +  ENCODE_WERR_COMMENT("offset", +  ".number %ld", +  id->func.const_info.offset); +  });       /* opt_flags */    code_number(id->opt_flags, data); -  +  EDB(1, { +  ENCODE_WERR_COMMENT("opt_flags", +  ".number %ld", id->opt_flags); +  });    break;       case IDENTIFIER_C_FUNCTION:    if (is_variant_dispatcher(p, d)) {    int k;    int j;    struct identifier *other = NULL;    /* This is handled by end_first_pass() et al. */    /* NB: This can be reached even though id_dumped    * for it gets set by the variant functions,
pike.git/src/encode.c:1616:    * function must have the variant modifier (since    * otherwise it would have overridden the old def    * and not the dispatcher). This is handled    * automatically by the use of id_dumped for the    * dispatcher as marker for whether the first    * variant has been added or not.    */    EDB(3,    fprintf(stderr, "%*sencode: encoding variant dispatcher\n",    data->depth, "")); +  EDB(1, { +  ENCODE_WERR("# Variant dispatcher.\n"); +  });       for(k = 0; k < p->num_identifiers; k++) {    other = p->identifiers + k;    if (other->name == id->name) break;    }    if (other >= id) {    /* variant before termination function. */    EDB(3, fprintf(stderr, "%*sVariant before termination function.\n",    data->depth, "")); -  +  EDB(1, { +  ENCODE_WERR("# Before termination function (skipped)."); +  });    goto next_identifier_ref;    }    if ((other->identifier_flags & IDENTIFIER_TYPE_MASK) ==    IDENTIFIER_PIKE_FUNCTION) {    struct reference *r = NULL;    for (j = 0; j < p->num_identifier_references; j++) {    r = p->identifier_references + j;    if (!r->inherit_offset && (r->identifier_offset == k)) {    /* Found the override. */    break;
pike.git/src/encode.c:1649:    * that was overridden by the variant dispatcher.    *    * We need to encode it here at its original place.    */    id_dumped[k] = 1;    gs_flags = r->id_flags & ref->id_flags;    id = other;    ref = r;    EDB(3, fprintf(stderr, "%*sEncoding termination function.\n",    data->depth, "")); +  EDB(1, { +  ENCODE_WERR("# Encoding termination function."); +  });    goto encode_pike_function;    }    }    }    /* Not supported. */    Pike_error("Cannot encode functions implemented in C "    "(identifier=\"%S\").\n",    id->name);    break;   
pike.git/src/encode.c:1674:    id->name->str));    /* We still want to dump it later... */    id_dumped[ref->identifier_offset] = 0;    goto next_identifier_ref;    }    EDB(3,    fprintf(stderr, "%*sencode: encoding variable\n",    data->depth, ""));    encode_entry_variable:    code_number(ID_ENTRY_VARIABLE, data); +  EDB(1, { +  ENCODE_WERR(".ident variable"); +  });    if (gs_flags >= 0) {    code_number(gs_flags, data); -  +  EDB(1, { +  ENCODE_WERR_COMMENT("modifiers", +  ".number %ld", gs_flags); +  });    } else {    code_number(ref->id_flags, data); -  +  EDB(1, { +  ENCODE_WERR_COMMENT("modifiers", +  ".number %ld", ref->id_flags); +  });    }       /* name */    str_sval.u.string = id->name;    encode_value2(&str_sval, data, 0);       /* type */    ref_push_type_value(id->type);    encode_value2(Pike_sp-1, data, 0);    pop_stack();       /* filename */    code_number(id->filename_strno, data); -  +  EDB(1, { +  ENCODE_WERR_COMMENT("filename_strno", +  ".number %ld", id->filename_strno); +  });       /* linenumber */    code_number(id->linenumber, data); -  +  EDB(1, { +  ENCODE_WERR_COMMENT("linenumber", +  ".number %ld", id->linenumber); +  });       break;      #ifdef PIKE_DEBUG    default:    Pike_fatal ("Unknown identifier type: 0x%04x for symbol \"%s\".\n",    id->identifier_flags & IDENTIFIER_TYPE_MASK,    id->name->str);   #endif    }    }       /* Identifier reference number */    code_number(d, data); -  +  EDB(1, { +  ENCODE_WERR_COMMENT("ref_no", +  ".number %ld", d); +  });       next_identifier_ref:    ; /* C requires a statement after lables. */   #ifdef ENCODE_DEBUG    data->depth -= 2;   #endif    }       /* Encode next inherit. */    if (inherit_num < p->num_inherits) {
pike.git/src/encode.c:1742:       EDB(3,    fprintf(stderr, "%*sencode: encoding inherit\n",    data->depth, ""));      #ifdef ENCODE_DEBUG    data->depth += 2;   #endif       code_number(ID_ENTRY_INHERIT, data); +  EDB(1, { +  ENCODE_WERR(".ident inherit"); +  });       /* Calculate id_flags */    for (i = 0; i < inh->prog->num_identifier_references; i++) {    if (ref[i].inherit_offset) {    INT16 id_flags = ref[i].id_flags;    INT16 inh_id_flags =    inh->prog->identifier_references[i].id_flags;    /* Ignore identifiers that have been hidden. */    if (!(id_flags & ID_HIDDEN)) {    inherit_flags_set |= id_flags & ~inh_id_flags;
pike.git/src/encode.c:1772:    * it can not have been a local inherit. */    inherit_flags_mask &= ~ID_LOCAL;    }    }    EDB(5,    fprintf(stderr, "%*sraw inherit_flags_set: %04x:%04x\n",    data->depth, "",    inherit_flags_set, inherit_flags_mask));    inherit_flags_set &= inherit_flags_mask;    code_number(inherit_flags_set, data); +  EDB(1, { +  ENCODE_WERR_COMMENT("modifiers", +  ".number %ld", inherit_flags_set); +  });       EDB(5,    fprintf(stderr, "%*sinherit_flags: %04x\n",    data->depth, "", inherit_flags_set));       /* Identifier reference level at insertion. */    code_number(d_max, data); -  +  EDB(1, { +  ENCODE_WERR_COMMENT("max_ref_no", +  ".number %ld", d_max); +  });       /* name */    if (!inh->name)    Pike_error("Cannot encode programs with unnamed inherits.\n");    str_sval.u.string = inh->name;    encode_value2(&str_sval, data, 0);       /* prog */    ref_push_program(inh->prog);    encode_value2(Pike_sp-1, data, 1);
pike.git/src/encode.c:1802:    if (inh->parent) {    ref_push_object(inh->parent);    } else {    push_int(0);    }    encode_value2(Pike_sp-1, data, 0);    pop_stack();       /* parent_identifier */    code_number(inh->parent_identifier, data); +  EDB(1, { +  ENCODE_WERR_COMMENT("parent_id", +  ".number %ld", inh->parent_identifier); +  });       /* parent_offset */    code_number(inh->parent_offset, data); -  +  EDB(1, { +  ENCODE_WERR_COMMENT("parent_offset", +  ".number %ld", inh->parent_offset); +  });       /* Number of identifier references. */    code_number(inh->prog->num_identifier_references, data); -  +  EDB(1, { +  ENCODE_WERR_COMMENT("num_refs", +  ".number %ld", +  inh->prog->num_identifier_references); +  });       inherit_num += inh->prog->num_inherits;      #ifdef ENCODE_DEBUG    data->depth -= 2;   #endif    }    }    /* End-marker */    code_number(ID_ENTRY_EOT, data); -  +  EDB(1, { +  ENCODE_WERR_COMMENT("End of identifier table", +  ".ident eot"); +  });      #ifdef ENCODE_DEBUG    data->depth -= 2;   #endif    }       /* Encode the constant values table. */    {    struct svalue str_sval;    SET_SVAL(str_sval, T_STRING, 0, string, NULL);       EDB(2,    fprintf(stderr, "%*sencode: encoding constants\n",    data->depth, "")); -  +  EDB(1, { +  ENCODE_WERR("# Constant table"); +  });       /* constants */    for(d=0;d<p->num_constants;d++)    {    EDB(5,    fprintf(stderr, "%*sencode: encoding constant #%d\n",    data->depth, "", d));    -  +  EDB(1, { +  ENCODE_WERR("# Constant #%ld", d); +  }); +     if (((TYPEOF(p->constants[d].sval) == T_FUNCTION) &&    (SUBTYPEOF(p->constants[d].sval) == FUNCTION_BUILTIN)) ||    (TYPEOF(p->constants[d].sval) == T_TYPE)) {    /* Already encoded above. */    continue;    }       /* value */    encode_value2(&p->constants[d].sval, data, 0);