pike.git / src / encode.c

version» Context lines:

pike.git/src/encode.c:3300:    if (!num) {    DECODE_WERR(".entry object");    } else if (num == 2) {    DECODE_WERR(".bignum");    } else {    DECODE_WERR(".entry object, %ld", num);    }    });    if (num == 4) {    decode_number(subtype, data); +  EDB(1, { +  DECODE_WERR_COMMENT("inherit", ".number %ld", subtype); +  });    }    decode_value2(data);       switch(num)    {    case 0:    apply(decoder_codec (data),"objectof", 1);    break;       case 1:
pike.git/src/encode.c:3668:    EDB(1, {    DECODE_WERR(".entry program, 4");    });       /* Decode byte-order. */    decode_number(byteorder, data);       EDB(4,    fprintf(stderr, "%*sbyte order:%d\n",    data->depth, "", byteorder)); +  EDB(1, { +  DECODE_WERR_COMMENT("byte-order", ".number %ld", byteorder); +  });       if ((byteorder != PIKE_BYTEORDER)   #if (PIKE_BYTEORDER == 1234)    && (byteorder != 4321)   #else   #if (PIKE_BYTEORDER == 4321)    && (byteorder != 1234)   #endif   #endif    ) {    decode_error (data, NULL, "Unsupported byte-order. "    "Native:%d Encoded:%d\n", PIKE_BYTEORDER, byteorder);    }       /* Decode flags. */    decode_number(p_flags,data); -  +  EDB(1, { +  DECODE_WERR_COMMENT("flags", ".number %ld", p_flags); +  });    p_flags &= ~(PROGRAM_FINISHED | PROGRAM_OPTIMIZED |    PROGRAM_FIXED | PROGRAM_PASS_1_DONE);    p_flags |= PROGRAM_AVOID_CHECK;       if (delayed_enc_val) {    EDB(2,fprintf(stderr, "%*sdecoding a delay encoded program: ",    data->depth, "");    print_svalue(stderr, delayed_enc_val);    fputc('\n', stderr););    if (TYPEOF(*delayed_enc_val) != T_PROGRAM ||
pike.git/src/encode.c:3776:    fputc('\n', stderr););    mapping_insert(data->decoded, &entry_id, &prog);    debug_malloc_touch(p);    } else {    data->delay_counter--;    }       debug_malloc_touch(p);       /* Check the version. */ +  EDB(1, { +  DECODE_WERR("# version"); +  });    decode_value2(data);    push_compact_version();    if(!is_eq(Pike_sp-1,Pike_sp-2)   #ifdef ENCODE_DEBUG    && !data->debug   #endif    )    decode_error(data, NULL, "Cannot decode programs encoded with "    "other pike version %O.\n", Pike_sp - 2);    pop_n_elems(2);       debug_malloc_touch(p);      #ifdef ENCODE_DEBUG    if (!data->debug)   #endif    data->pickyness++;       /* parent */ -  +  EDB(1, { +  DECODE_WERR("# parent"); +  });    decode_value2(data);    if (TYPEOF(Pike_sp[-1]) == T_PROGRAM) {    p->parent = Pike_sp[-1].u.program;    debug_malloc_touch(p->parent);    } else if ((TYPEOF(Pike_sp[-1]) == T_INT) &&    (!Pike_sp[-1].u.integer)) {    p->parent = NULL;    } else {    decode_error (data, NULL, "Bad type for parent program (%s).\n",    get_name_of_type(TYPEOF(Pike_sp[-1])));    }    dmalloc_touch_svalue(Pike_sp-1);    Pike_sp--;       /* Decode lengths. */ - #define FOO(NUMTYPE,TYPE,ARGTYPE,NAME) \ -  decode_number(PIKE_CONCAT(local_num_, NAME), data); + #define FOO(NUMTYPE,TYPE,ARGTYPE,NAME) do { \ +  decode_number(PIKE_CONCAT(local_num_, NAME), data); \ +  EDB(1, { \ +  DECODE_WERR_COMMENT(TOSTR(NAME), ".number %ld", \ +  PIKE_CONCAT(local_num_,NAME)); \ +  }); \ +  } while(0);   #include "program_areas.h"       /* Byte-code method */    decode_number(bytecode_method, data);    if (bytecode_method != PIKE_BYTECODE_PORTABLE) {    decode_error(data, NULL, "Unsupported byte-code method: %d\n",    bytecode_method);    } -  +  EDB(1, { +  DECODE_WERR("byte-code", ".number %ld", bytecode_method); +  });       /* Decode strings */    for (e=0; e<local_num_strings; e++) {    decode_value2(data);    if (TYPEOF(Pike_sp[-1]) != T_STRING) {    ref_push_program (p);    decode_error(data, Pike_sp - 1,    "Nonstrings in string table: %O\n", Pike_sp - 2);    }    add_to_strings(Pike_sp[-1].u.string);
pike.git/src/encode.c:3848:    {    struct program_constant constant;    SET_SVAL(constant.sval, T_INT, NUMBER_UNDEFINED, integer, 0);    constant.offset = -1;       for(e=0;e<local_num_constants;e++) {    add_to_constants(constant);    }    }    +  EDB(1, { +  DECODE_WERR("# Constant table."); +  });    /* Decode identifier_references, inherits and identifiers. */    decode_number(entry_type, data);    EDB(4,    fprintf(stderr, "%*sDecoding identifier references.\n",    data->depth, ""));   #ifdef ENCODE_DEBUG    data->depth+=2;   #endif    while ((entry_type == ID_ENTRY_EFUN_CONSTANT) ||    (entry_type == ID_ENTRY_TYPE_CONSTANT)) {    INT32 efun_no;    struct program_constant *constant; -  +  EDB(1, { +  if (entry_type == ID_ENTRY_EFUN_CONSTANT) { +  DECODE_WERR(".ident efun_constant"); +  } else { +  DECODE_WERR(".ident type_constant"); +  } +  });    decode_number(efun_no, data); -  +  EDB(1, { +  DECODE_WERR_COMMENT("constant #", ".number %ld", efun_no); +  });    EDB(2,    fprintf(stderr, "%*sDecoding efun/type constant #%d.\n",    data->depth, "", efun_no));    if ((efun_no < 0) || (efun_no >= local_num_constants)) {    ref_push_program (p);    decode_error(data, Pike_sp - 1,    "Bad efun/type number: %d (expected 0 - %d).\n",    efun_no, local_num_constants-1);    }    constant = p->constants+efun_no;
pike.git/src/encode.c:3908:    decode_value2(data);    constant->offset = -1;    pop_stack();    constant->sval = Pike_sp[-1];    dmalloc_touch_svalue(Pike_sp-1);    Pike_sp -= 1;    decode_number(entry_type, data);    }       while (entry_type != ID_ENTRY_EOT) { +  EDB(1, { +  switch(entry_type) { +  case ID_ENTRY_TYPE_CONSTANT: +  DECODE_WERR(".ident type_constant"); +  break; +  case ID_ENTRY_EFUN_CONSTANT: +  DECODE_WERR(".ident efun_constant"); +  break; +  case ID_ENTRY_RAW: +  DECODE_WERR(".ident raw"); +  break; +  case ID_ENTRY_EOT: +  /* NOT reached. Here for completion. */ +  DECODE_WERR(".ident eot"); +  break; +  case ID_ENTRY_VARIABLE: +  DECODE_WERR(".ident variable"); +  break; +  case ID_ENTRY_FUNCTION: +  DECODE_WERR(".ident function"); +  break; +  case ID_ENTRY_CONSTANT: +  DECODE_WERR(".ident constant"); +  break; +  case ID_ENTRY_INHERIT: +  DECODE_WERR(".ident inherit"); +  break; +  case ID_ENTRY_ALIAS: +  DECODE_WERR(".ident alias"); +  break; +  default: +  DECODE_WERR_COMMENT("Unknown", ".ident %ld", entry_type); +  break; +  } +  });    decode_number(id_flags, data); -  +  EDB(1, { +  DECODE_WERR_COMMENT("modifiers", +  ".number %ld", id_flags); +  });    if ((entry_type != ID_ENTRY_RAW) &&    (entry_type != ID_ENTRY_INHERIT)) {    /* Common identifier fields. */       unsigned INT32 filename_strno;       /* name */    decode_value2(data);    if (TYPEOF(Pike_sp[-1]) != T_STRING) {    ref_push_program (p);
pike.git/src/encode.c:3935:    decode_value2(data);    if (TYPEOF(Pike_sp[-1]) != T_TYPE) {    ref_push_program (p);    decode_error(data, Pike_sp - 1,    "Bad identifier type (not a type): %O\n",    Pike_sp - 2);    }       /* filename */    decode_number(filename_strno, data); +  EDB(1, { +  DECODE_WERR_COMMENT("filename_strno", +  ".number %ld", filename_strno); +  });    if (filename_strno >= p->num_strings) {    ref_push_program(p);    decode_error(data, NULL,    "String number out of range: %ld >= %ld",    (long)filename_strno, (long)p->num_strings);    }    free_string(c->lex.current_file);    copy_shared_string(c->lex.current_file,    p->strings[filename_strno]);       /* linenumber */    decode_number(c->lex.current_line, data); -  +  EDB(1, { +  DECODE_WERR_COMMENT("linenumber", +  ".number %ld", c->lex.current_line); +  });       /* Identifier name and type on the pike stack.    * Definition location in c->lex.    */    }    switch(entry_type) {    case ID_ENTRY_RAW:    {    int no;    int ref_no;    struct reference ref;       /* id_flags */    ref.id_flags = id_flags;       /* inherit_offset */    decode_number(ref.inherit_offset, data); -  +  EDB(1, { +  DECODE_WERR_COMMENT("inherit_offset", +  ".number %ld", ref.inherit_offset); +  });       /* identifier_offset */    /* Actually the id ref number from the inherited program */    decode_number(ref_no, data); -  +  EDB(1, { +  DECODE_WERR_COMMENT("ref_no", ".number %ld", ref_no); +  });       if (ref.inherit_offset >= p->num_inherits)    decode_error(data, NULL, "Inherit offset out of range %u vs %u.\n",    ref.inherit_offset, p->num_inherits);    if (ref_no < 0 || ref_no >= p->inherits[ref.inherit_offset].prog->num_identifier_references)    decode_error(data, NULL, "Identifier reference out of range %u vs %u.\n",    ref_no, p->inherits[ref.inherit_offset].prog->num_identifier_references);       ref.identifier_offset = p->inherits[ref.inherit_offset].prog->    identifier_references[ref_no].identifier_offset;       ref.run_time_type = PIKE_T_UNKNOWN;    ref.func.offset = 0;       /* Expected identifier reference number */    decode_number(no, data); -  +  EDB(1, { +  DECODE_WERR_COMMENT("ref_no", +  ".number %ld", no); +  });       if (no < 0 || no > p->num_identifier_references) {    EDB (3, dump_program_tables (p, data->depth));    ref_push_program (p);    decode_error(data, Pike_sp - 1,    "Bad identifier reference offset: %d != %d\n",    no,    Pike_compiler->new_program->    num_identifier_references);    } else if (no == p->num_identifier_references) {
pike.git/src/encode.c:4008:    }    }    break;       case ID_ENTRY_VARIABLE:    {    int no, n;       /* Expected identifier offset */    decode_number(no, data); +  EDB(1, { +  DECODE_WERR_COMMENT("ref_no", +  ".number %ld", no); +  });       EDB(5,    fprintf(stderr,    "%*sdefine_variable(\"%s\", X, 0x%04x)\n",    data->depth, "",    Pike_sp[-2].u.string->str, id_flags));       /* Alters    *    * storage, variable_index, identifiers and
pike.git/src/encode.c:4043:    case ID_ENTRY_FUNCTION:    {    union idptr func;    unsigned INT8 func_flags;    unsigned INT16 opt_flags;    int no;    int n;       /* func_flags (aka identifier_flags) */    decode_number(func_flags, data); +  EDB(1, { +  DECODE_WERR_COMMENT("identifier_flags", +  ".number %ld", +  func_flags); +  });       /* func */    decode_number(func.offset, data); -  +  EDB(1, { +  DECODE_WERR_COMMENT("offset", +  ".number %ld", +  func.offset); +  });    if (func.offset != -1) {   #ifdef ENCODE_DEBUG    int old_a_flag;   #endif    EDB(2,    {    fprintf(stderr, "%*sDecoding portable bytecode.\n",    data->depth, "");    old_a_flag = a_flag;    a_flag = (a_flag > (data->debug-1))?a_flag:(data->debug-1);    });    func.offset = decode_portable_bytecode(data, func.offset);    EDB(2, a_flag = old_a_flag);    }       /* opt_flags */    decode_number(opt_flags, data); -  +  EDB(1, { +  DECODE_WERR_COMMENT("opt_flags", +  ".number %ld", opt_flags); +  });       /* FIXME:    * Verify validity of func_flags, func.offset & opt_flags    */       /* Expected identifier offset */    decode_number(no, data); -  +  EDB(1, { +  DECODE_WERR_COMMENT("ref_no", +  ".number %ld", no); +  });       EDB(5, {    INT_TYPE line;    struct pike_string *file =    get_line(func.offset + p->program, p, &line);    fprintf(stderr,    "%*sdefine_function(\"%s\", X, 0x%04x, 0x%04x,\n"    "%*s 0x%04lx, 0x%04x)\n"    "%*s @ %s:%ld\n",    data->depth, "",
pike.git/src/encode.c:4138:       /* offset */    decode_number(id.func.const_info.offset, data);       /* FIXME:    * Verify validity of func.const_info.offset    */       /* run_time_type */    decode_number(id.run_time_type, data); +  EDB(1, { +  DECODE_WERR_COMMENT("run_time_type", +  ".number %ld", id.run_time_type); +  });       /* opt_flags */    decode_number(id.opt_flags, data); -  +  EDB(1, { +  DECODE_WERR_COMMENT("opt_flags", +  ".number %ld", id.opt_flags); +  });       ref.run_time_type = PIKE_T_UNKNOWN;    ref.func.offset = 0;       /* Expected identifier number. */    decode_number(no, data); -  +  EDB(1, { +  DECODE_WERR_COMMENT("ref_no", +  ".number %ld", no); +  });       n = isidentifier(id.name);      #ifdef PROFILING    id.self_time=0;    id.num_calls=0;    id.recur_depth=0;    id.total_time=0;   #endif   
pike.git/src/encode.c:4208:    break;    case ID_ENTRY_ALIAS:    {    int depth;    int refno;    int no;    int n;       /* depth */    decode_number(depth, data); +  EDB(1, { +  DECODE_WERR_COMMENT("depth", +  ".number %ld", +  depth); +  });       /* refno */    decode_number(refno, data); -  +  EDB(1, { +  DECODE_WERR_COMMENT("refno", +  ".number %ld", +  refno); +  });       /* FIXME:    * Verify validity of depth and refno.    */       /* Expected identifier number. */    decode_number(no, data); -  +  EDB(1, { +  DECODE_WERR_COMMENT("ref_no", +  ".number %ld", no); +  });       EDB(5,    fprintf(stderr,    "%*slow_define_alias(\"%s\", X, 0x%04x)\n",    data->depth, "",    Pike_sp[-2].u.string->str, id_flags));       /* Alters    *    * variable_index, identifiers and
pike.git/src/encode.c:4255:    case ID_ENTRY_INHERIT:    {    struct program *prog;    struct object *parent = NULL;    int parent_identifier;    int parent_offset;    struct pike_string *name = NULL;    int no;       decode_number(no, data); +  EDB(1, { +  DECODE_WERR_COMMENT("ref_no", +  ".number %ld", no); +  });    if (no !=    Pike_compiler->new_program->num_identifier_references) {    ref_push_program (p);    decode_error(data, Pike_sp - 1,    "Bad inherit identifier offset: %d\n", no);    }       /* name */    decode_value2(data);    if (TYPEOF(Pike_sp[-1]) == T_STRING) {
pike.git/src/encode.c:4310:    } else if ((TYPEOF(Pike_sp[-1]) != T_INT) ||    Pike_sp[-1].u.integer) {    ref_push_program (p);    decode_error(data, Pike_sp - 1,    "Bad inherit: Parent isn't an object: %O\n",    Pike_sp - 2);    }       /* parent_identifier */    decode_number(parent_identifier, data); +  EDB(1, { +  DECODE_WERR_COMMENT("parent_id", +  ".number %ld", parent_identifier); +  });       /* parent_offset */    decode_number(parent_offset, data); -  +  EDB(1, { +  DECODE_WERR_COMMENT("parent_offset", +  ".number %ld", parent_offset); +  });       /* Expected number of identifier references. */    decode_number(no, data); -  +  EDB(1, { +  DECODE_WERR_COMMENT("ref_no", +  ".number %ld", no); +  });       if (prog->num_identifier_references != no) {    ref_push_program (p);    decode_error(data, Pike_sp - 1, "Bad number of identifiers "    "in inherit (%d != %d).\n",    no, prog->num_identifier_references);    }       EDB(5,    fprintf(stderr,
pike.git/src/encode.c:4344:    lower_inherit(prog, parent, parent_identifier,    parent_offset + 42, id_flags, name);       pop_n_elems(3);    }    break;    default:    decode_error(data, NULL, "Unsupported id entry type: %d\n",    entry_type);    } +  EDB(1, { +  DECODE_FLUSH(); +  }); +     decode_number(entry_type, data);    } -  +  EDB(1, { +  DECODE_WERR(".ident eot"); +  });       /* Restore c->lex. */    CALL_AND_UNSET_ONERROR(err2);    c->lex.current_line = save_current_line;      #ifdef ENCODE_DEBUG    data->depth-=2;   #endif       UNSET_ONERROR(err);