pike.git / src / encode.c

version» Context lines:

pike.git/src/encode.c:1:   /*   || This file is part of Pike. For copyright information see COPYRIGHT.   || Pike is distributed under GPL, LGPL and MPL. See the file COPYING   || for more information. - || $Id: encode.c,v 1.265 2008/05/03 15:29:24 nilsson Exp $ + || $Id: encode.c,v 1.266 2008/05/16 18:20:07 grubba Exp $   */      #include "global.h"   #include "stralloc.h"   #include "pike_macros.h"   #include "object.h"   #include "constants.h"   #include "interpret.h"   #include "svalue.h"   #include "mapping.h"
pike.git/src/encode.c:1156:    p->inherits[d].prog->id););    }       for(d=0;d<p->num_identifiers;d++)    {    adddata(p->identifiers[d].name);    encode_type(p->identifiers[d].type, data);    code_number(p->identifiers[d].identifier_flags,data);    code_number(p->identifiers[d].run_time_type,data);    code_number(p->identifiers[d].opt_flags,data); +  code_number(p->identifiers[d].filename_strno, data); +  code_number(p->identifiers[d].linenumber, data);    if (IDENTIFIER_IS_ALIAS(p->identifiers[d].identifier_flags)) {    code_number(p->identifiers[d].func.ext_ref.depth,data);    code_number(p->identifiers[d].func.ext_ref.id,data);    } else if (!IDENTIFIER_IS_C_FUNCTION(p->identifiers[d].identifier_flags)) {    code_number(p->identifiers[d].func.offset,data);    } else {    Pike_error("Cannot encode functions implemented in C "    "(identifier=\"%S\").\n",    p->identifiers[d].name);    }
pike.git/src/encode.c:1429:    fprintf(stderr, "%*sencode: already encoded reference\n",    data->depth, ""));    goto next_identifier_ref;    }    id_dumped[ref->identifier_offset] = 1;       if (id->name && (id->name->len>3) &&    (index_shared_string(id->name, 0) == '`') &&    (index_shared_string(id->name, 1) == '-') &&    (index_shared_string(id->name, 2) == '>')) { +  /* Potential old-style getter/setter. */    struct pike_string *symbol = NULL;    if (index_shared_string(id->name, id->name->len-1) != '=') {    /* Getter callback. */    symbol = string_slice(id->name, 3, id->name->len - 3);    } else if (id->name->len > 4) {    /* Setter callback. */    symbol = string_slice(id->name, 3, id->name->len - 4);    }    if (symbol) {    int i = really_low_find_shared_string_identifier(symbol, p,    SEE_STATIC|SEE_PRIVATE);    if (i >= 0) {    /* Found the symbol. */    gs_flags = PTR_FROM_INT(p, i)->id_flags;    }    free_string(symbol);    } -  +  } else if (id->name && (id->name->len>1) && +  (index_shared_string(id->name, 0) == '`') && +  ((((unsigned)index_shared_string(id->name, 1)) >= +  256) || +  isidchar(index_shared_string(id->name, 1)))) { +  /* New-style getter/setter. */ +  struct pike_string *symbol = NULL; +  if (index_shared_string(id->name, id->name->len-1) != '=') { +  /* Getter callback. */ +  symbol = string_slice(id->name, 1, id->name->len - 1); +  } else if (id->name->len > 2) { +  /* Setter callback. */ +  symbol = string_slice(id->name, 1, id->name->len - 2);    } -  +  if (symbol) { +  int i = really_low_find_shared_string_identifier(symbol, p, +  SEE_STATIC|SEE_PRIVATE); +  if (i >= 0) { +  /* Found the symbol. */ +  gs_flags = PTR_FROM_INT(p, i)->id_flags; +  } +  free_string(symbol); +  } +  }       if (IDENTIFIER_IS_ALIAS(id->identifier_flags)) {    if ((!id->func.ext_ref.depth) &&    IDENTIFIER_IS_VARIABLE(id->identifier_flags)) {    struct identifier *other =    ID_FROM_INT(p, id->func.ext_ref.id);    if (other->name == id->name) {    /* Let define_variable() handle the decoding. */    EDB(3, fprintf(stderr,    "%*sencode: encoding aliased variable\n",
pike.git/src/encode.c:1473:       code_number(ID_ENTRY_ALIAS, data);       /* flags */    code_number(ref->id_flags, data);       /* 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); +  +  /* linenumber */ +  code_number(id->linenumber, data); +     /* depth */    code_number(id->func.ext_ref.depth, data);       /* refno */    code_number(id->func.ext_ref.id, data);    -  /* type */ -  ref_push_type_value(id->type); -  encode_value2(Pike_sp-1, data, 0); -  pop_stack(); +     } 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);    if (gs_flags >= 0) {    code_number(gs_flags, data);    } else {    code_number(ref->id_flags, data);    }       /* name */    str_sval.u.string = id->name;    encode_value2(&str_sval, data, 0);    -  /* offset */ -  code_number(id->func.offset, data); -  +     /* type */    ref_push_type_value(id->type);    encode_value2(Pike_sp-1, data, 0);    pop_stack();    -  +  /* filename */ +  code_number(id->filename_strno, data); +  +  /* linenumber */ +  code_number(id->linenumber, data); +  +  /* offset */ +  code_number(id->func.offset, data); +     /* run-time type */    code_number(id->run_time_type, data);    break;       case IDENTIFIER_PIKE_FUNCTION:    EDB(3,    fprintf(stderr, "%*sencode: encoding function\n",    data->depth, ""));       code_number(ID_ENTRY_FUNCTION, data);
pike.git/src/encode.c:1533:       /* 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); +  +  /* linenumber */ +  code_number(id->linenumber, data); +     /* func_flags (aka identifier_flags) */    code_number(id->identifier_flags, data);       /* func */   #ifdef PIKE_PORTABLE_BYTECODE    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,
pike.git/src/encode.c:1583:    }       /* 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); +  +  /* linenumber */ +  code_number(id->linenumber, data); +     break;       default:;   #ifdef PIKE_DEBUG    Pike_fatal ("Unknown identifier type: 0x%04x for symbol \"%s\".\n",    id->identifier_flags & IDENTIFIER_TYPE_MASK,    id->name->str);   #endif    }    }
pike.git/src/encode.c:3362:    SET_ONERROR(err2, restore_type_mark, Pike_compiler->pike_type_mark_stackp);       debug_malloc_touch(p);    for(d=0;d<p->num_identifiers;d++)    {    getdata(p->identifiers[d].name);    decode_type(p->identifiers[d].type,data);    decode_number(p->identifiers[d].identifier_flags,data);    decode_number(p->identifiers[d].run_time_type,data);    decode_number(p->identifiers[d].opt_flags,data); +  decode_number(p->identifiers[d].filename_strno, data); +  decode_number(p->identifiers[d].linenumber, data);    if (IDENTIFIER_IS_ALIAS(p->identifiers[d].identifier_flags)) {    decode_number(p->identifiers[d].func.ext_ref.depth, data);    decode_number(p->identifiers[d].func.ext_ref.id, data);    } else if (!IDENTIFIER_IS_C_FUNCTION(p->identifiers[d].identifier_flags))    {    decode_number(p->identifiers[d].func.offset,data);    } else {    ref_push_program (p);    ref_push_string (p->identifiers[d].name);    decode_error(Pike_sp - 1, Pike_sp - 2,
pike.git/src/encode.c:3639:    struct program *p;    ONERROR err;    ONERROR err2;    int byteorder;    int bytecode_method;    int entry_type;    INT16 id_flags;    INT16 p_flags;    ptrdiff_t old_pragmas;    struct compilation *c; +  struct pike_string *save_current_file; +  unsigned INT32 save_current_line;   #define FOO(NUMTYPE,Y,ARGTYPE,NAME) \    NUMTYPE PIKE_CONCAT(local_num_, NAME) = 0;   #include "program_areas.h"      #ifdef ENCODE_DEBUG    data->depth += 2;   #endif       /* Decode byte-order. */    decode_number(byteorder, data);
pike.git/src/encode.c:3704:    enter_compiler(NULL, 0);       c = THIS_COMPILATION;       /* We don't want to be affected by #pragma save_parent or    * __pragma_save_parent__.    */    old_pragmas = c->lex.pragmas;    c->lex.pragmas = (old_pragmas & ~ID_SAVE_PARENT)|ID_DONT_SAVE_PARENT;    +  copy_shared_string(save_current_file, c->lex.current_file); +  save_current_line = c->lex.current_line; +     /* Start the new program. */    low_start_new_program(p, 1, NULL, 0, NULL);    p = Pike_compiler->new_program;   #if TWO_PASS_DECODE_WORKS    if(! data->supporter.prog)    data->supporter.prog = p;   #endif       p->flags = p_flags;   
pike.git/src/encode.c:3942:    pop_stack();    constant->sval = Pike_sp[-1];    dmalloc_touch_svalue(Pike_sp-1);    Pike_sp -= 1;   #endif /* 0 */    decode_number(entry_type, data);    }       while (entry_type != ID_ENTRY_EOT) {    decode_number(id_flags, data); +  if ((entry_type != ID_ENTRY_RAW) && +  (entry_type != ID_ENTRY_INHERIT)) { +  /* Common identifier fields. */ +  +  unsigned INT32 filename_strno; +  +  /* name */ +  decode_value2(data); +  if (Pike_sp[-1].type != T_STRING) { +  ref_push_program (p); +  decode_error(Pike_sp - 1, Pike_sp - 2, +  "Bad identifier name (not a string): "); +  } +  +  /* type */ +  decode_value2(data); +  if (Pike_sp[-1].type != T_TYPE) { +  ref_push_program (p); +  decode_error(Pike_sp - 1, Pike_sp - 2, +  "Bad identifier type (not a type): "); +  } +  +  /* filename */ +  decode_number(filename_strno, data); +  if (filename_strno >= p->num_strings) { +  ref_push_program(p); +  decode_error(NULL, 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); +  +  /* 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;   
pike.git/src/encode.c:3984:    else {    p->identifier_references[no] = ref;    }    }    break;       case ID_ENTRY_VARIABLE:    {    int no, n;    -  /* name */ -  decode_value2(data); -  if (Pike_sp[-1].type != T_STRING) { -  ref_push_program (p); -  decode_error(Pike_sp - 1, Pike_sp - 2, -  "Bad variable name (not a string): "); -  } -  -  /* type */ -  decode_value2(data); -  if (Pike_sp[-1].type != T_TYPE) { -  ref_push_program (p); -  decode_error(Pike_sp - 1, Pike_sp - 2, -  "Bad variable type (not a type): "); -  } -  +     /* Expected identifier offset */    decode_number(no, data);       EDB(5,    fprintf(stderr,    "%*sdefine_variable(\"%s\", X, 0x%04x)\n",    data->depth, "",    Pike_sp[-2].u.string->str, id_flags));       /* Alters
pike.git/src/encode.c:4035:    }    break;    case ID_ENTRY_FUNCTION:    {    union idptr func;    unsigned INT8 func_flags;    unsigned INT16 opt_flags;    int no;    int n;    -  /* name */ -  decode_value2(data); -  if (Pike_sp[-1].type != T_STRING) { -  ref_push_program (p); -  decode_error(Pike_sp - 1, Pike_sp - 2, -  "Bad function name (not a string): "); -  } -  -  /* type */ -  decode_value2(data); -  if (Pike_sp[-1].type != T_TYPE) { -  ref_push_program (p); -  decode_error(Pike_sp - 1, Pike_sp - 2, -  "Bad function type (not a type): "); -  } -  +     /* func_flags (aka identifier_flags) */    decode_number(func_flags, data);       /* func */    decode_number(func.offset, data);    if (bytecode_method == PIKE_BYTECODE_PORTABLE &&    func.offset != -1) {   #ifdef ENCODE_DEBUG    int old_a_flag;   #endif
pike.git/src/encode.c:4126:    pop_n_elems(2);    }    break;    case ID_ENTRY_CONSTANT:    {    struct identifier id;    struct reference ref;    int no;    int n;    -  /* name */ -  decode_value2(data); -  if (Pike_sp[-1].type != T_STRING) { -  ref_push_program (p); -  decode_error(Pike_sp - 1, Pike_sp - 2, -  "Bad constant name (not a string): "); -  } -  id.name = Pike_sp[-1].u.string; +  id.name = Pike_sp[-2].u.string; +  id.type = Pike_sp[-1].u.type;       /* identifier_flags */    id.identifier_flags = IDENTIFIER_CONSTANT;       /* offset */    decode_number(id.func.offset, data);       /* FIXME:    * Verify validity of func.offset    */    -  /* type */ -  decode_value2(data); -  if (Pike_sp[-1].type != T_TYPE) { -  ref_push_program (p); -  decode_error(Pike_sp - 1, Pike_sp - 2, -  "Bad constant type (not a type): "); -  } -  id.type = Pike_sp[-1].u.type; -  +     /* run_time_type */    decode_number(id.run_time_type, data);       /* Expected identifier number. */    decode_number(no, data);       n = isidentifier(id.name);      #ifdef PROFILING    id.self_time=0;
pike.git/src/encode.c:4217:       }    break;    case ID_ENTRY_ALIAS:    {    int depth;    int refno;    int no;    int n;    -  /* name */ -  decode_value2(data); -  if (Pike_sp[-1].type != T_STRING) { -  ref_push_program (p); -  decode_error(Pike_sp - 1, Pike_sp - 2, -  "Bad alias name (not a string): "); -  } -  +     /* depth */    decode_number(depth, data);       /* refno */    decode_number(refno, data);       /* FIXME:    * Verify validity of depth and refno.    */    -  /* type */ -  decode_value2(data); -  if (Pike_sp[-1].type != T_TYPE) { -  ref_push_program (p); -  decode_error(Pike_sp - 1, Pike_sp - 2, -  "Bad constant type (not a type): "); -  } -  +     /* Expected identifier number. */    decode_number(no, data);       EDB(5,    fprintf(stderr,    "%*slow_define_alias(\"%s\", X, 0x%04x)\n",    data->depth, "",    Pike_sp[-2].u.string->str, id_flags));       /* Alters
pike.git/src/encode.c:4369:       pop_n_elems(3);    }    break;    default:    Pike_error("Unsupported id entry type: %d\n", entry_type);    }    decode_number(entry_type, data);    }    +  /* Restore c->lex. */ +  free_string(c->lex.current_file); +  c->lex.current_file = save_current_file; +  c->lex.current_line = save_current_line; +    #ifdef ENCODE_DEBUG    data->depth-=2;   #endif       UNSET_ONERROR(err);       /* De-kludge to get end_first_pass() to free the program. */    Pike_compiler->num_parse_error--;       p->flags |= PROGRAM_PASS_1_DONE;