pike.git / src / docode.c

version» Context lines:

pike.git/src/docode.c:315:    i=do_docode2(n, flags);    current_stack_depth = stack_depth_save + i;       c->lex.current_line=save_current_line;    return i;   }      static int is_efun(node *n, c_fun fun)   {    return n && n->token == F_CONSTANT && -  n->u.sval.subtype == FUNCTION_BUILTIN && +  SUBTYPEOF(n->u.sval) == FUNCTION_BUILTIN &&    n->u.sval.u.efun->function == fun;   }      static void code_expression(node *n, int flags, char *err)   {    switch(do_docode(n, flags & ~DO_POP))    {    case 0: my_yyerror("Void expression for %s",err);    case 1: return;    case 2:
pike.git/src/docode.c:540:    struct pike_string *n1=make_shared_string(func);    node *n=find_module_identifier(n1,0);    free_string(n1);       switch(n?n->token:0)    {    case F_CONSTANT:    tmp1=store_constant(&n->u.sval,    !(n->tree_info & OPT_EXTERNAL_DEPEND),    n->name); -  if(n->u.sval.type == T_FUNCTION && -  n->u.sval.subtype == FUNCTION_BUILTIN) +  if(TYPEOF(n->u.sval) == T_FUNCTION && +  SUBTYPEOF(n->u.sval) == FUNCTION_BUILTIN)    emit1(F_CALL_BUILTIN, DO_NOT_WARN((INT32)tmp1));    else    emit1(F_APPLY, DO_NOT_WARN((INT32)tmp1));    break;       default:    my_yyerror("docode: Failed to make call to %s",func);    }    free_node(n);   }
pike.git/src/docode.c:604:    struct compilation *c = THIS_COMPILATION;    struct pike_string *n1=make_shared_string(func);    node *n=find_module_identifier(n1,0);    free_string(n1);       switch(n?n->token:0)    {    case F_CONSTANT:    tmp1=store_constant(&n->u.sval,    (!(n->tree_info & OPT_EXTERNAL_DEPEND)) && -  (n->u.sval.type != T_TYPE), +  (TYPEOF(n->u.sval) != T_TYPE),    n->name);    emit1(F_CONSTANT, DO_NOT_WARN((INT32)tmp1));    break;       default:    my_yyerror("docode: Failed to make svalue for builtin %s",func);    }    free_node(n);   }   
pike.git/src/docode.c:931:    if (IDENTIFIER_IS_CONSTANT(id->identifier_flags) &&    (ref->id_flags & ID_INLINE) && !ref->inherit_offset &&    (id->func.const_info.offset >= 0)) {    /* An inline, local or final constant identifier in    * a lexically surrounding (aka parent) class.    * Avoid vtable traversal during runtime by moving    * the constant to this class.    */    struct svalue *s = &state->new_program->    constants[id->func.const_info.offset].sval; -  if (s->type == T_PROGRAM && +  if (TYPEOF(*s) == T_PROGRAM &&    s->u.program->flags & PROGRAM_USES_PARENT) {    /* An external reference is required. */    emit2(F_EXTERNAL, n->u.integer.b, level);    } else {    int tmp1 = store_constant(s, 1, NULL);    emit1(F_CONSTANT, tmp1);    }    } else {    emit2(F_EXTERNAL, n->u.integer.b, level);    }
pike.git/src/docode.c:959:    * prototype. */    emit1(F_LFUN, n->u.integer.b);    } else if (IDENTIFIER_IS_CONSTANT(id->identifier_flags) &&    (ref->id_flags & ID_INLINE) && !ref->inherit_offset &&    (id->func.const_info.offset >= 0)) {    /* An inline, local or final constant identifier.    * No need for vtable traversal during runtime.    */    struct svalue *s = &state->new_program->    constants[id->func.const_info.offset].sval; -  if (s->type == T_PROGRAM && +  if (TYPEOF(*s) == T_PROGRAM &&    s->u.program->flags & PROGRAM_USES_PARENT) {    /* Program using parent. Convert to an LFUN. */    emit1(F_LFUN, n->u.integer.b);    } else {    emit1(F_CONSTANT, id->func.const_info.offset);    }    }else{    emit1(F_GLOBAL, n->u.integer.b);    }    }
pike.git/src/docode.c:1280:    if (CAR (n)->token == F_RANGE)    emit_range (CAR (n) DO_IF_DEBUG (COMMA num_args));    else    emit0(CAR(n)->token);       emit0(n->token);    return n->token==F_ASSIGN; /* So when is this false? /mast */    }    case F_APPLY:    if ((CAAR(n)->token == F_CONSTANT) && -  (CAAR(n)->u.sval.type == T_FUNCTION) && -  (CAAR(n)->u.sval.subtype == FUNCTION_BUILTIN) && +  (TYPEOF(CAAR(n)->u.sval) == T_FUNCTION) && +  (SUBTYPEOF(CAAR(n)->u.sval) == FUNCTION_BUILTIN) &&    (CAAR(n)->u.sval.u.efun->function != f_map) &&    (CAAR(n)->u.sval.u.efun->function != f_filter)) {    /* efuns typically don't access object variables. */    node *args = CDAR(n);    if (args) {    node **arg = my_get_arg(&args, 0);    if (arg && node_is_eq(CDR(n), *arg) &&    !(args->tree_info & OPT_ASSIGNMENT)) {    /* First arg is the lvalue.    *
pike.git/src/docode.c:1849:    tmp1 = do_docode(CAR(n), 0);    if(!tmp1)    emit0(F_CONST0);    else if(tmp1>1)    do_pop(DO_NOT_WARN((INT32)(tmp1-1)));    return 1;    }    }    {    struct svalue sv; -  sv.type = T_TYPE; -  sv.subtype = 0; -  sv.u.type = n->type; +  SET_SVAL(sv, T_TYPE, 0, type, n->type);    tmp1 = store_constant(&sv, 0, n->name);    emit1(F_CONSTANT, DO_NOT_WARN((INT32)tmp1));    }       tmp1=do_docode(CAR(n),0);    if(!tmp1) { emit0(F_CONST0); tmp1=1; }    if(tmp1>1) do_pop(DO_NOT_WARN((INT32)(tmp1-1)));       emit0(F_CAST);    return 1;       case F_SOFT_CAST:    if (runtime_options & RUNTIME_CHECK_TYPES) {    {    struct svalue sv; -  sv.type = T_TYPE; -  sv.subtype = 0; -  sv.u.type = n->type; +  SET_SVAL(sv, T_TYPE, 0, type, n->type);    tmp1 = store_constant(&sv, 0, n->name);    emit1(F_CONSTANT, DO_NOT_WARN((INT32)tmp1));    }    tmp1 = do_docode(CAR(n), 0);    if (!tmp1) { emit0(F_CONST0); tmp1 = 1; }    if (tmp1 > 1) do_pop(DO_NOT_WARN((INT32)(tmp1 - 1)));    emit0(F_SOFT_CAST);    return 1;    }    tmp1 = do_docode(CAR(n), flags);    if (tmp1 > 1) do_pop(DO_NOT_WARN((INT32)(tmp1 - 1)));    return !!tmp1;       case F_APPLY:    if(CAR(n)->token == F_CONSTANT)    { -  if(CAR(n)->u.sval.type == T_FUNCTION) +  if(TYPEOF(CAR(n)->u.sval) == T_FUNCTION)    { -  if(CAR(n)->u.sval.subtype == FUNCTION_BUILTIN) /* driver fun? */ +  if(SUBTYPEOF(CAR(n)->u.sval) == FUNCTION_BUILTIN) /* driver fun? */    {    if(!CAR(n)->u.sval.u.efun->docode ||    !CAR(n)->u.sval.u.efun->docode(n))    {    if(count_args(CDR(n))==1)    {    do_docode(CDR(n),0);    tmp1=store_constant(& CAR(n)->u.sval,    !(CAR(n)->tree_info & OPT_EXTERNAL_DEPEND),    CAR(n)->name);
pike.git/src/docode.c:1917:    emit1(F_CALL_BUILTIN, DO_NOT_WARN((INT32)tmp1));    POP_AND_DONT_CLEANUP;    }    }    if(n->type == void_type_string)    return 0;       return 1;    }else{    if(CAR(n)->u.sval.u.object == Pike_compiler->fake_object) -  return do_lfun_call(CAR(n)->u.sval.subtype, CDR(n)); +  return do_lfun_call(SUBTYPEOF(CAR(n)->u.sval), CDR(n));    }    }       emit0(F_MARK);    PUSH_CLEANUP_FRAME(do_pop_mark, 0);    do_docode(CDR(n),0);    tmp1=store_constant(& CAR(n)->u.sval,    !(CAR(n)->tree_info & OPT_EXTERNAL_DEPEND),    CAR(n)->name);    emit1(F_APPLY, DO_NOT_WARN((INT32)tmp1));
pike.git/src/docode.c:1975:    do_docode(CAR(n),0);    do_docode(CDR(n),0);       tmp=findstring("call_function");    if(!tmp) yyerror("No call_function efun.");    foo=find_module_identifier(tmp,0);    if(!foo || foo->token!=F_CONSTANT)    {    yyerror("No call_function efun.");    }else{ -  if(foo->u.sval.type == T_FUNCTION && -  foo->u.sval.subtype == FUNCTION_BUILTIN && +  if(TYPEOF(foo->u.sval) == T_FUNCTION && +  SUBTYPEOF(foo->u.sval) == FUNCTION_BUILTIN &&    foo->u.sval.u.efun->function == f_call_function)    {    emit0(F_CALL_FUNCTION);    }else{    /* We might want to put "predef::"+foo->name here /Hubbe */    tmp1=store_constant(& foo->u.sval, 1, foo->name);    emit1(F_APPLY, DO_NOT_WARN((INT32)tmp1));    }    }    free_node(foo);
pike.git/src/docode.c:2453:    case F_ARRAY_LVALUE:    tmp1=do_docode(CAR(n),DO_LVALUE);   #ifdef PIKE_DEBUG    if(tmp1 & 1)    Pike_fatal("Very internal compiler error.\n");   #endif    emit1(F_ARRAY_LVALUE, DO_NOT_WARN((INT32)(tmp1>>1)));    return 2;       case F_ARROW: -  if(CDR(n)->token != F_CONSTANT || CDR(n)->u.sval.type!=T_STRING) +  if(CDR(n)->token != F_CONSTANT || TYPEOF(CDR(n)->u.sval) != T_STRING)    Pike_fatal("Bugg in F_ARROW, index not string.\n");    if(flags & WANT_LVALUE)    {    /* FIXME!!!! ??? I wonder what needs fixing... /Hubbe */    tmp1=do_docode(CAR(n), 0);    emit1(F_ARROW_STRING, store_prog_string(CDR(n)->u.sval.u.string));    return 2;    }else{    tmp1 = do_docode(CAR(n), DO_NOT_COPY);    if ((tmp2 = lfun_lookup_id(CDR(n)->u.sval.u.string)) != -1) {
pike.git/src/docode.c:2518:    if(!(flags & DO_NOT_COPY))    {    while(n && (n->token==F_INDEX || n->token==F_ARROW)) n=CAR(n);    if(n->token==F_CONSTANT && !(n->node_info & OPT_EXTERNAL_DEPEND))    emit0(F_COPY_VALUE);    }    }    return DO_NOT_WARN((INT32)tmp1);       case F_CONSTANT: -  switch(n->u.sval.type) +  switch(TYPEOF(n->u.sval))    {    case T_INT: -  if(!n->u.sval.u.integer && n->u.sval.subtype==NUMBER_UNDEFINED) +  if(!n->u.sval.u.integer && SUBTYPEOF(n->u.sval) == NUMBER_UNDEFINED)    {    emit0(F_UNDEFINED);    }else{   #if SIZEOF_INT_TYPE > 4    INT_TYPE i=n->u.sval.u.integer;    if (i != (INT32)i)    {    unsigned INT_TYPE ip=(unsigned INT_TYPE)i;    INT32 a,b;    a=(INT32)(ip>>32);
pike.git/src/docode.c:2549:   #endif    }    return 1;       case T_STRING:    tmp1=store_prog_string(n->u.sval.u.string);    emit1(F_STRING, DO_NOT_WARN((INT32)tmp1));    return 1;       case T_FUNCTION: -  if(n->u.sval.subtype!=FUNCTION_BUILTIN) +  if(SUBTYPEOF(n->u.sval) != FUNCTION_BUILTIN)    {    if(n->u.sval.u.object == Pike_compiler->fake_object)    {    /* When does this occur? /mast */ -  emit1(F_GLOBAL,n->u.sval.subtype); +  emit1(F_GLOBAL, SUBTYPEOF(n->u.sval));    return 1;    }       if(n->u.sval.u.object->next == n->u.sval.u.object)    {    int x=0;   #if 0    struct object *o;       for(o=Pike_compiler->fake_object;o!=n->u.sval.u.object;o=o->parent) {
pike.git/src/docode.c:2577: Inside #if 0
   x++;    }   #else    struct program_state *state=Pike_compiler;    for(;state->fake_object!=n->u.sval.u.object;state=state->previous) {    state->new_program->flags |=    PROGRAM_USES_PARENT | PROGRAM_NEEDS_PARENT;    x++;    }   #endif -  emit2(F_EXTERNAL, n->u.sval.subtype, x); +  emit2(F_EXTERNAL, SUBTYPEOF(n->u.sval), x);    Pike_compiler->new_program->flags |=    PROGRAM_USES_PARENT | PROGRAM_NEEDS_PARENT;    return 1;    }    }    /* FALL_THROUGH */    default:   #ifdef PIKE_DEBUG -  if((n->u.sval.type == T_OBJECT) && +  if((TYPEOF(n->u.sval) == T_OBJECT) &&    (n->u.sval.u.object->next == n->u.sval.u.object))    Pike_fatal("Internal error: Pointer to parent cannot be a compile time constant!\n");   #endif    tmp1=store_constant(&(n->u.sval),    !(n->tree_info & OPT_EXTERNAL_DEPEND),    n->name);    emit1(F_CONSTANT, DO_NOT_WARN((INT32)tmp1));    return 1;       case T_TYPE:
pike.git/src/docode.c:2614:    tmp1=store_constant(&(n->u.sval),    !(n->tree_info & OPT_EXTERNAL_DEPEND),    n->name);    emit1(F_CONSTANT, DO_NOT_WARN((INT32)tmp1));       /* copy now or later ? */    if(!(flags & DO_NOT_COPY) && !(n->tree_info & OPT_EXTERNAL_DEPEND))    {    if(flags & DO_NOT_COPY_TOPLEVEL)    { -  switch(n->u.sval.type) +  switch(TYPEOF(n->u.sval))    {    case T_ARRAY:    if(array_fix_type_field(n->u.sval.u.array) & BIT_COMPLEX)    emit0(F_COPY_VALUE);    break;       case T_MAPPING:    mapping_fix_type_field(n->u.sval.u.mapping);    if((n->u.sval.u.mapping->data->ind_types |    n->u.sval.u.mapping->data->val_types) & BIT_COMPLEX)