pike.git / src / las.c

version» Context lines:

pike.git/src/las.c:1:   /*\   ||| This file a part of Pike, and is copyright by Fredrik Hubinette   ||| Pike is distributed as GPL (General Public License)   ||| See the files COPYING and DISCLAIMER for more information.   \*/   /**/   #include "global.h" - RCSID("$Id: las.c,v 1.248 2001/03/28 17:59:36 grubba Exp $"); + RCSID("$Id: las.c,v 1.249 2001/04/01 15:40:23 grubba Exp $");      #include "language.h"   #include "interpret.h"   #include "las.h"   #include "array.h"   #include "object.h"   #include "stralloc.h"   #include "dynamic_buffer.h"   #include "lex.h"   #include "pike_types.h"
pike.git/src/las.c:297:       check_tree(n,0);       fatal_check_c_stack(16384);       if(!n) return 0;       if (n->token == F_RETURN) {    if (CAR(n)) {    if (CAR(n)->type) { -  copy_type(a, CAR(n)->type); +  copy_pike_type(a, CAR(n)->type);    } else {   #ifdef PIKE_DEBUG    if (l_flag > 2) {    fprintf(stderr, "Return with untyped argument.\n");    print_tree(n);    }   #endif /* PIKE_DEBUG */ -  copy_type(a, mixed_type_string); +  copy_pike_type(a, mixed_type_string);    }    } else { -  copy_type(a, zero_type_string); +  copy_pike_type(a, zero_type_string);    }    return a;    }       if(!(n->tree_info & OPT_RETURN)) return 0;       if(car_is_node(n))    a=find_return_type(CAR(n));    else    a=0;
pike.git/src/las.c:388: Inside #if defined(SHARED_NODES)
     static void add_node(node *n)   {    size_t hval = (n->hash % node_hash.size);      #ifdef PIKE_DEBUG    node *probe = node_hash.table[hval];    while(probe) {    if (probe == n)    { -  fprintf(stderr, "add_node(%p == %p): Node already added!\n", probe, n); +  fprintf(stderr, "add_node(%p == %p): Node already added!\n", +  (void *)probe, (void *)n);    fprintf( stderr, " %ld <-> %ld\n",    DO_NOT_WARN((long)hval),    DO_NOT_WARN((long)(n->hash % node_hash.size)) );    probe = node_hash.table[hval];    while( probe )    { -  fprintf(stderr, " %p\n", probe); +  fprintf(stderr, " %p\n", (void *)probe);    probe = probe->next;    }    fatal( "Node already added!\n" );    }    probe = probe->next;    }   #endif /* PIKE_DEBUG */    n->next = node_hash.table[hval];    node_hash.table[hval] = n;   }
pike.git/src/las.c:473: Inside #if defined(SHARED_NODES)
   }    }    if ((n->hash == hash) &&    !MEMCMP(&(n->token), &(orig->token),    sizeof(node) - OFFSETOF(node_s, token))) {    if (orig->type && (orig->type != n->type)) {    if (n->type) {    /* Use the new type if it's stricter. */    if (pike_types_le(orig->type, n->type)) {    free_type(n->type); -  copy_type(n->type, orig->type); +  copy_pike_type(n->type, orig->type);    }    } else {    /* This probably doesn't happen, but... */ -  copy_type(n->type, orig->type); +  copy_pike_type(n->type, orig->type);    }    }    if (!found) {    node *scan = n;    while(scan->next) {    if (scan->next == orig) {    scan->next = orig->next;    break;    }    scan = scan->next;
pike.git/src/las.c:556:    if(tmp==tmp2->x+e)    break;       if(!tmp)    {    tmp=tmp2->x+e;   #ifdef PIKE_DEBUG    if(!cumulative_parse_error)    {    fprintf(stderr,"Free node at %p, (%s:%d) (token=%d).\n", -  tmp, tmp->current_file->str, tmp->line_number, +  (void *)tmp, tmp->current_file->str, tmp->line_number,    tmp->token);       debug_malloc_dump_references(tmp,0,2,0);       if(tmp->token==F_CONSTANT)    print_tree(tmp);    }    /* else */   #endif    {
pike.git/src/las.c:795:    break;    } while (n->parent);   }         node *debug_check_node_hash(node *n)   {   #if defined(PIKE_DEBUG) && defined(SHARED_NODES)    if (n && !(n->tree_info & (OPT_DEFROSTED|OPT_NOT_SHARED)) && (n->hash != hash_node(n))) {    fprintf(stderr,"Bad node hash at %p, (%s:%d) (token=%d).\n", -  n, n->current_file->str, n->line_number, +  (void *)n, n->current_file->str, n->line_number,    n->token);    debug_malloc_dump_references(n,0,0,0);    print_tree(n);    fatal("Bad node hash!\n");    }   #endif /* PIKE_DEBUG && SHARED_NODES */    return n;   }      /* here starts routines to make nodes */
pike.git/src/las.c:920:    }    } else {    res->node_info |= opt_flags;    }    res->node_info |= OPT_APPLY;    if(b) res->tree_info |= b->tree_info;    }    break;       case F_POP_VALUE: -  copy_type(res->type, void_type_string); +  copy_pike_type(res->type, void_type_string);       if(a) res->tree_info |= a->tree_info;    if(b) res->tree_info |= b->tree_info;    break;       case F_MAGIC_SET_INDEX:    res->node_info |= OPT_ASSIGNMENT;    /* FALL_THROUGH */    case F_MAGIC_INDEX:    res->node_info |= OPT_EXTERNAL_DEPEND;
pike.git/src/las.c:1054:    verify_shared_strings_tables();   #endif       return res;   }      node *debug_mkstrnode(struct pike_string *str)   {    node *res = mkemptynode();    res->token = F_CONSTANT; -  copy_type(res->type, string_type_string); +  copy_pike_type(res->type, string_type_string);    res->node_info = 0;    res->u.sval.type = T_STRING;   #ifdef __CHECKER__    res->u.sval.subtype = 0;   #endif    copy_shared_string(res->u.sval.u.string, str);       return freeze_node(res);   }   
pike.git/src/las.c:1100:    /* res->hash = hash_node(res); */   #endif /* SHARED_NODES */       return res;   }      node *debug_mkfloatnode(FLOAT_TYPE foo)   {    node *res = mkemptynode();    res->token = F_CONSTANT; -  copy_type(res->type, float_type_string); +  copy_pike_type(res->type, float_type_string);    res->u.sval.type = T_FLOAT;   #ifdef __CHECKER__    res->u.sval.subtype = 0;   #endif    res->u.sval.u.float_number = foo;       return freeze_node(res);   }      
pike.git/src/las.c:1158:      node *debug_mklocalnode(int var, int depth)   {    struct compiler_frame *f;    int e;    node *res = mkemptynode();    res->token = F_LOCAL;       f=Pike_compiler->compiler_frame;    for(e=0;e<depth;e++) f=f->previous; -  copy_type(res->type, f->variable[var].type); +  copy_pike_type(res->type, f->variable[var].type);       res->node_info = OPT_NOT_CONST | OPT_NOT_SHARED;    res->tree_info = res->node_info;   #ifdef __CHECKER__    _CDR(res) = 0;   #endif    res->u.integer.a = var;    res->u.integer.b = depth;      #ifdef SHARED_NODES
pike.git/src/las.c:1221:       check_tree(res,0);    return res;   #endif   }      node *debug_mktrampolinenode(int i)   {    node *res = mkemptynode();    res->token = F_TRAMPOLINE; -  copy_type(res->type, ID_FROM_INT(Pike_compiler->new_program, i)->type); +  copy_pike_type(res->type, ID_FROM_INT(Pike_compiler->new_program, i)->type);       /* FIXME */    if(IDENTIFIER_IS_CONSTANT(ID_FROM_INT(Pike_compiler->new_program, i)->identifier_flags))    {    res->node_info = OPT_EXTERNAL_DEPEND;    }else{    res->node_info = OPT_NOT_CONST;    }    res->tree_info=res->node_info;   
pike.git/src/las.c:1261:       id = ID_FROM_INT(parent_prog, i);   #ifdef PIKE_DEBUG    if(d_flag)    {    check_type_string(id->type);    check_string(id->name);    }   #endif    -  copy_type(res->type, id->type); +  copy_pike_type(res->type, id->type);       /* FIXME */    if(IDENTIFIER_IS_CONSTANT(id->identifier_flags))    {    res->node_info = OPT_EXTERNAL_DEPEND;    }else{    res->node_info = OPT_NOT_CONST;    }    res->tree_info = res->node_info;   
pike.git/src/las.c:1321: Inside #if defined(PIKE_DEBUG)
   fatal("Casting to no type!\n");    }   #endif /* PIKE_DEBUG */       if (type == void_type_string) return mknode(F_POP_VALUE, n, 0);       if(type==n->type) return n;       res = mkemptynode();    res->token = F_CAST; -  copy_type(res->type, type); +  copy_pike_type(res->type, type);       if(match_types(object_type_string, type) ||    match_types(program_type_string, type))    res->node_info |= OPT_SIDE_EFFECT;       res->tree_info |= n->tree_info;       _CAR(res) = n;    _CDR(res) = mktypenode(type);   
pike.git/src/las.c:1380:    }    /* FIXME: check_soft_cast() is weaker than pike_types_le()    * The resulting type should probably be the and between the old    * and the new type.    */    }    }       res = mkemptynode();    res->token = F_SOFT_CAST; -  copy_type(res->type, type); +  copy_pike_type(res->type, type);       res->tree_info |= n->tree_info;       _CAR(res) = n;    _CDR(res) = mktypenode(type);       n->parent = res;       return freeze_node(res);   }
pike.git/src/las.c:1797:    if(car_is_node(a) && !node_is_eq(CAR(a), CAR(b))) return 0;    if(cdr_is_node(a) && !node_is_eq(CDR(a), CDR(b))) return 0;    return 1;    }   }      node *debug_mktypenode(struct pike_type *t)   {    node *res = mkemptynode();    res->token = F_CONSTANT; -  copy_type(res->u.sval.u.type, t); +  copy_pike_type(res->u.sval.u.type, t);    res->u.sval.type = T_TYPE; -  copy_type(res->type, type_type_string); +  /* FIXME: Should be type(val) */ +  copy_pike_type(res->type, type_type_string);    return freeze_node(res);   }      node *low_mkconstantsvaluenode(struct svalue *s)   {    node *res = mkemptynode();    res->token = F_CONSTANT;    assign_svalue_no_free(& res->u.sval, s);    if(s->type == T_OBJECT ||    (s->type==T_FUNCTION && s->subtype!=FUNCTION_BUILTIN))
pike.git/src/las.c:1910:    check_tree(n,0);    if(!n) return n;    switch(n->token)    {    case F_LOCAL:    case F_IDENTIFIER:    case F_TRAMPOLINE:    b=mknewintnode(0);    if(b->type) free_type(b->type);    *b=*n; -  copy_type(b->type, n->type); +  copy_pike_type(b->type, n->type);    return b;       default:   #ifdef SHARED_NODES    n->refs++;    return n;   #else /* !SHARED_NODES */       fatal_check_c_stack(16384);   
pike.git/src/las.c:1940:    break;       case 1:    b=mknode(n->token, CAR(n), copy_node(CDR(n)));    break;       case 0:    b=mknode(n->token, CAR(n), CDR(n));    }    if(n->type) -  copy_type(b->type, n->type); +  copy_pike_type(b->type, n->type);    else    b->type=0;       break;       case F_CAST:    b=mkcastnode(n->type,copy_node(CAR(n)));    break;       case F_SOFT_CAST:
pike.git/src/las.c:2005: Inside #if defined(SHARED_NODES)
   }       switch(n->token)    {    case F_LOCAL:    case F_IDENTIFIER:    case F_TRAMPOLINE:    b=mknewintnode(0);    if(b->type) free_type(b->type);    *b=*n; -  copy_type(b->type, n->type); +  copy_pike_type(b->type, n->type);    return b;       default:    fatal_check_c_stack(16384);       b=mkemptynode();    if(car_is_node(n)) _CAR(b)=copy_node(CAR(n));    if(cdr_is_node(n)) _CDR(b)=copy_node(CDR(n));       if(n->type) -  copy_type(b->type, n->type); +  copy_pike_type(b->type, n->type);    else    b->type=0;       break;       case F_CAST:    case F_SOFT_CAST:    b=mkemptynode();    _CAR(b)=copy_node(CAR(n));    _CDR(b)=copy_node(CDR(n));    if(n->type) -  copy_type(b->type, n->type); +  copy_pike_type(b->type, n->type);    else    b->type=0;    break;       case F_CONSTANT:    b=low_mkconstantsvaluenode(&(n->u.sval));    break;    }    if(n->name)    {
pike.git/src/las.c:3149:    free_string(t1);    }    /* FIXME: check_soft_cast() is weaker than pike_types_le()    * The resulting type should probably be the and between the old    * and the new type.    */    }    /* FALL_THROUGH */    case F_CAST:    /* Type-field is correct by definition. */ -  copy_type(n->type, old_type); +  copy_pike_type(n->type, old_type);    break;       case F_LAND:    case F_LOR:    if (!CAR(n) || CAR(n)->type == void_type_string) {    yyerror("Conditional uses void expression."); -  copy_type(n->type, mixed_type_string); +  copy_pike_type(n->type, mixed_type_string);    break;    }    if(!match_types(CAR(n)->type, mixed_type_string))    yyerror("Bad conditional expression.");       if (!CDR(n) || CDR(n)->type == void_type_string) -  copy_type(n->type, void_type_string); +  copy_pike_type(n->type, void_type_string);    else if(n->token == F_LAND || CAR(n)->type == CDR(n)->type)    { -  copy_type(n->type, CDR(n)->type); +  copy_pike_type(n->type, CDR(n)->type);    }else{    n->type = or_pike_types(CAR(n)->type, CDR(n)->type, 0);    }    break;       case F_ASSIGN:    if (!CAR(n) || (CAR(n)->type == void_type_string)) {    my_yyerror("Assigning a void expression."); -  copy_type(n->type, void_type_string); +  copy_pike_type(n->type, void_type_string);    break;    } else if(CAR(n) && CDR(n)) {    /* Ensure that the type-fields are up to date. */    fix_type_field(CAR(n));    fix_type_field(CDR(n));    if (!pike_types_le(CAR(n)->type, CDR(n)->type)) {    /* a["b"]=c and a->b=c can be valid when a is an array */    if (CDR(n)->token != F_INDEX && CDR(n)->token != F_ARROW &&    !match_types(CDR(n)->type,CAR(n)->type)) {    yytype_error("Bad type in assignment.",
pike.git/src/las.c:3212:    }    }    n->type = and_pike_types(CAR(n)->type, CDR(n)->type);    break;       case F_INDEX:    case F_ARROW:    if (!CAR(n) || (CAR(n)->type == void_type_string)) {    my_yyerror("Indexing a void expression.");    /* The optimizer converts this to an expression returning 0. */ -  copy_type(n->type, zero_type_string); +  copy_pike_type(n->type, zero_type_string);    } else {    type_a=CAR(n)->type;    type_b=CDR(n)->type;    if(!check_indexing(type_a, type_b, n))    if(!Pike_compiler->catch_level)    my_yyerror("Indexing on illegal type.");    n->type=index_type(type_a, type_b,n);    }    break;   
pike.git/src/las.c:3236:    } else {    struct pike_type *f; /* Expected type. */    struct pike_type *s; /* Actual type */    char *name;    INT32 max_args,args;      #if defined(USE_PIKE_TYPE) && defined(NEW_ARG_CHECK)       args = 0;    -  copy_type(f, CAR(n)->type); +  copy_pike_type(f, CAR(n)->type);       f = new_check_call(CAR(n), &args, f, CDR(n));       if (f && (n->type = get_ret_type(f))) {    /* Type/argument-check OK. */    free_type(f);    break;    }      #else /* !(USE_PIKE_TYPE && NEW_ARG_CHECK) */
pike.git/src/las.c:3367:       default:    name="unknown function";    }       if(max_args < args)    {    if(TEST_COMPAT(0,6))    {    free_type(s); -  copy_type(n->type, mixed_type_string); +  copy_pike_type(n->type, mixed_type_string);    break;    }    my_yyerror("Too many arguments to %s.",name);    }    else if(max_correct_args == args)    {    my_yyerror("Too few arguments to %s.",name);    }else{    my_yyerror("Bad argument %d to %s.",    max_correct_args+1, name);    }       yytype_error(NULL, f, s, 0);       /* print_tree(n); */       free_type(s);   #endif /* USE_PIKE_TYPE && NEW_ARG_CHECK */    } -  copy_type(n->type, mixed_type_string); +  copy_pike_type(n->type, mixed_type_string);    break;       case '?':    if (!CAR(n) || (CAR(n)->type == void_type_string)) {    yyerror("Conditional expression is void.");    } else if(!match_types(CAR(n)->type, mixed_type_string))    yyerror("Bad conditional expression.");       if(!CDR(n) || !CADR(n) || !CDDR(n) ||    CADR(n)->type == void_type_string ||    CDDR(n)->type == void_type_string)    { -  copy_type(n->type, void_type_string); +  copy_pike_type(n->type, void_type_string);    break;    }       if(CADR(n)->type == CDDR(n)->type)    { -  copy_type(n->type, CADR(n)->type); +  copy_pike_type(n->type, CADR(n)->type);    break;    }       n->type = or_pike_types(CADR(n)->type, CDDR(n)->type, 0);    break;       case F_AND_EQ:    case F_OR_EQ:    case F_XOR_EQ:    case F_LSH_EQ:
pike.git/src/las.c:3471:    case F_DIV_EQ:    MAKE_CONSTANT_SHARED_STRING(op_string, "`/");    break;    default:    fatal("fix_type_field(): Unhandled token: %d\n", n->token);    break;    }    if (!(op_node = find_module_identifier(op_string, 0))) {    my_yyerror("Internally used efun undefined for token %d: %s()",    n->token, op_string->str); -  copy_type(n->type, mixed_type_string); +  copy_pike_type(n->type, mixed_type_string);    free_string(op_string);    break;    }    if (!op_node->type) {    fix_type_field(op_node);    }       push_finished_type(CAR(n)->type);    push_type(T_VOID);    push_type(T_MANY);
pike.git/src/las.c:3509:    free_string(op_string);    break;    }    my_yyerror("Bad arguments to %s=().", op_string->str);    yytype_error(NULL, op_node->type ? op_node->type : mixed_type_string,    call_type, 0);    free_node(op_node);    free_type(call_type);    free_string(op_string);    } -  copy_type(n->type, mixed_type_string); +  copy_pike_type(n->type, mixed_type_string);    break;    case F_RANGE:    case F_INC:    case F_DEC:    case F_POST_INC:    case F_POST_DEC:    if (CAR(n)) {    /* The expression gets the type from the variable. */    /* FIXME: Ought to strip non-applicable subtypes from the type. */ -  copy_type(n->type, CAR(n)->type); +  copy_pike_type(n->type, CAR(n)->type);    } else { -  copy_type(n->type, mixed_type_string); +  copy_pike_type(n->type, mixed_type_string);    }    break;       case F_RETURN:    if (!CAR(n) || (CAR(n)->type == void_type_string)) {    yywarning("Returning a void expression.");    if (!CAR(n)) {   #ifdef SHARED_NODES    sub_node(n);   #endif /* SHARED_NODES */    _CAR(n) = mkintnode(0); -  copy_type(n->type, CAR(n)->type); +  copy_pike_type(n->type, CAR(n)->type);   #ifdef SHARED_NODES    if (!(n->tree_info & OPT_NOT_SHARED)) {    n->hash = hash_node(n);    }    n->node_info |= OPT_DEFROSTED;    add_node(n);   #endif /* SHARED_NODES */    break;    }    } else if(Pike_compiler->compiler_frame &&
pike.git/src/las.c:3569:    }    else if (lex.pragmas & ID_STRICT_TYPES)    {    yytype_error("Return type mismatch.",    Pike_compiler->compiler_frame->current_return_type,    CAR(n)->type,    YYTE_IS_WARNING);    }    }    } -  copy_type(n->type, void_type_string); +  copy_pike_type(n->type, void_type_string);    break;       case F_CASE:    if (CDR(n) && CAR(n) && !TEST_COMPAT(0,6)) {    /* case 1 .. 2: */    if (!match_types(CAR(n)->type, CDR(n)->type)) {    if (!match_types(CAR(n)->type, int_type_string) ||    !match_types(CDR(n)->type, int_type_string)) {    yytype_error("Type mismatch in case range.",    CAR(n)->type, CDR(n)->type, 0);
pike.git/src/las.c:3610:    /* FALL_THROUGH */    case F_INC_LOOP:    case F_DEC_LOOP:    case F_DEC_NEQ_LOOP:    case F_INC_NEQ_LOOP:    case F_LOOP:    case F_CONTINUE:    case F_BREAK:    case F_DEFAULT:    case F_POP_VALUE: -  copy_type(n->type, void_type_string); +  copy_pike_type(n->type, void_type_string);    break;       case F_DO:    if (!CDR(n) || (CDR(n)->type == void_type_string)) {    yyerror("do - while(): Conditional expression is void.");    } else if(!match_types(CDR(n)->type, mixed_type_string))    yyerror("Bad conditional expression do - while()."); -  copy_type(n->type, void_type_string); +  copy_pike_type(n->type, void_type_string);    break;       case F_FOR:    if (!CAR(n) || (CAR(n)->type == void_type_string)) {    yyerror("for(): Conditional expression is void.");    } else if(!match_types(CAR(n)->type, mixed_type_string))    yyerror("Bad conditional expression for()."); -  copy_type(n->type, void_type_string); +  copy_pike_type(n->type, void_type_string);    break;       case F_SWITCH:    if (!CAR(n) || (CAR(n)->type == void_type_string)) {    yyerror("switch(): Conditional expression is void.");    } else if(!match_types(CAR(n)->type, mixed_type_string))    yyerror("Bad switch expression."); -  copy_type(n->type, void_type_string); +  copy_pike_type(n->type, void_type_string);    break;       case F_CONSTANT:    n->type = get_type_of_svalue(& n->u.sval);    break;       case F_FOREACH:    if (!CAR(n) || (CAR(n)->token != F_VAL_LVAL)) {    yyerror("foreach(): No expression to loop over.");    } else {
pike.git/src/las.c:3779:    }    }    free_type(value_type);    }    }    free_type(array_zero);    }    }    }    foreach_type_check_done: -  copy_type(n->type, void_type_string); +  copy_pike_type(n->type, void_type_string);    break;       case F_SSCANF:    if (!CAR(n) || (CAR(n)->token != F_ARG_LIST) ||    !CAAR(n) || !CDAR(n)) {    yyerror("Too few arguments to sscanf().");    } else {    if (!pike_types_le(CAAR(n)->type, string_type_string)) {    if (!match_types(CAAR(n)->type, string_type_string)) {    yytype_error("Bad argument 1 to sscanf().",
pike.git/src/las.c:3811:    yytype_error("Argument 2 to sscanf() has bad type.",    string_type_string, CDAR(n)->type, YYTE_IS_WARNING);    }    }    }    /* FIXME: */    MAKE_CONSTANT_TYPE(n->type, tIntPos);    break;       case F_UNDEFINED: -  copy_type(n->type, zero_type_string); +  copy_pike_type(n->type, zero_type_string);    break;       case F_ARG_LIST:    if (n->parent) {    /* Propagate the changed type all the way up to the apply node. */    n->parent->node_info |= OPT_TYPE_NOT_FIXED;    }    /* FALL_THROUGH */    case F_COMMA_EXPR:    if(!CAR(n) || CAR(n)->type==void_type_string)    {    if(CDR(n)) -  copy_type(n->type, CDR(n)->type); +  copy_pike_type(n->type, CDR(n)->type);    else -  copy_type(n->type, void_type_string); +  copy_pike_type(n->type, void_type_string);    break;    }       if(!CDR(n) || CDR(n)->type == void_type_string)    {    if(CAR(n)) -  copy_type(n->type, CAR(n)->type); +  copy_pike_type(n->type, CAR(n)->type);    else -  copy_type(n->type, void_type_string); +  copy_pike_type(n->type, void_type_string);    break;    }    if (n->token == F_ARG_LIST) {    n->type = or_pike_types(CAR(n)->type, CDR(n)->type, 0);    } else { -  copy_type(n->type, CDR(n)->type); +  copy_pike_type(n->type, CDR(n)->type);    }    break;       case F_MAGIC_INDEX:    /* FIXME: Could have a stricter type for ::`->(). */    /* FIXME: */    MAKE_CONSTANT_TYPE(n->type, tFunc(tMix,tMix));    break;    case F_MAGIC_SET_INDEX:    /* FIXME: Could have a stricter type for ::`->=(). */    /* FIXME: */    MAKE_CONSTANT_TYPE(n->type, tFunc(tMix tSetvar(0,tMix), tVar(0)));    break;       case F_CATCH:    /* FALL_THROUGH */    default: -  copy_type(n->type, mixed_type_string); +  copy_pike_type(n->type, mixed_type_string);    }       if (n->type != old_type) {    if (n->parent) {    n->parent->node_info |= OPT_TYPE_NOT_FIXED;    }    }    if (old_type) {    free_type(old_type);    }
pike.git/src/las.c:5024:    return n;    }    if (n->token == F_SOFT_CAST) {    new = mksoftcastnode(n->type, mksvaluenode(Pike_sp-1));    } else {    new = mksvaluenode(Pike_sp-1);    if (n->type && (!new->type || ((n->type != new->type) &&    pike_types_le(n->type,new->type)))) {    if (new->type)    free_type(new->type); -  copy_type(new->type, n->type); +  copy_pike_type(new->type, n->type);    }    }    free_node(n);    n = new;    pop_stack();    break;       default:    if (n->token != F_SOFT_CAST) {    free_node(n);