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.40 1998/03/03 11:24:32 hubbe Exp $"); + RCSID("$Id: las.c,v 1.41 1998/03/03 22:30:21 hubbe 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:37:   dynamic_buffer areas[NUM_AREAS];   node *init_node = 0;   int num_parse_error;   int cumulative_parse_error=0;   extern char *get_type_name(int);      #define MAX_GLOBAL 2048      int car_is_node(node *n)   { +  check_node(n);    switch(n->token)    {    case F_IDENTIFIER:    case F_CONSTANT:    case F_LOCAL:    return 0;       default:    return !!CAR(n);    }   }      int cdr_is_node(node *n)   { -  +  check_node(n);    switch(n->token)    {    case F_IDENTIFIER:    case F_CONSTANT:    case F_LOCAL:    case F_CAST:    return 0;       default:    return !!CDR(n);    }   }      INT32 count_args(node *n)   {    int a,b;    if(!n) return 0; -  +  check_node(n);    switch(n->token)    {    case F_VAL_LVAL:    case F_ARG_LIST:    a=count_args(CAR(n));    if(a==-1) return -1;    b=count_args(CDR(n));    if(b==-1) return -1;    return a+b;   
pike.git/src/las.c:167: Inside #if defined(DEBUG)
  #ifdef DEBUG    if(!cumulative_parse_error)    {    fprintf(stderr,"Free node at %p, (%d) (token=%d).\n",tmp, tmp->line_number, tmp->token);    if(tmp->token==F_CONSTANT)    print_tree(tmp);    }    else   #endif    { +  check_node(tmp);    /* Free the node and be happy */    /* Make sure we don't free any nodes twice */ -  +  dmalloc_dump_track(tmp);    if(car_is_node(tmp)) CAR(tmp)=0;    if(cdr_is_node(tmp)) CDR(tmp)=0;    debug_malloc_touch(tmp->type);    free_node(tmp);    }    }    }    }   #ifdef DEBUG    if(!cumulative_parse_error)
pike.git/src/las.c:196:    {    tmp2=node_chunks;    node_chunks=tmp2->next;    free((char *)tmp2);    }    free_nodes=0;    cumulative_parse_error=0;    }   }    - void free_node(node *n) + void debug_free_node(node *n)   {    if(!n) return; -  +  check_node(n);    switch(n->token)    {    case USHRT_MAX:    fatal("Freeing node again!\n");    break;       case F_CONSTANT:    free_svalue(&(n->u.sval));    break;       default:    if(car_is_node(n)) free_node(CAR(n));    if(cdr_is_node(n)) free_node(CDR(n));    }    n->token=USHRT_MAX;    if(n->type) free_string(n->type); -  +  dmalloc_untrack(n);    CAR(n)=free_nodes;    free_nodes=n;   }         /* here starts routines to make nodes */   static node *mkemptynode(void)   {    node *res;    if(!free_nodes)
pike.git/src/las.c:244:    free_nodes=tmp->nodes;    }    res=free_nodes;    free_nodes=CAR(res);    res->token=0;    res->line_number=current_line;    res->type=0;    res->node_info=0;    res->tree_info=0;    res->parent=0; +  dmalloc_track(res);    return res;   }    - node *mknode(short token,node *a,node *b) + node *debug_mknode(short token,node *a,node *b)   {    node *res;    res = mkemptynode();    CAR(res) = a;    CDR(res) = b;    res->node_info = 0;    res->tree_info = 0;    switch(token)    {    case F_CATCH:
pike.git/src/las.c:316:       if(a) a->parent = res;    if(b) b->parent = res;    if(!num_parse_error) optimize(res);      #ifdef DEBUG    if(d_flag > 3)    verify_shared_strings_tables();   #endif    +  check_node(res);    return res;   }      node *mkstrnode(struct pike_string *str)   {    node *res = mkemptynode();    res->token = F_CONSTANT;    copy_shared_string(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); -  +  check_node(res);    return res;   }      node *mkintnode(int nr)   {    node *res = mkemptynode();    res->token = F_CONSTANT;    if(nr)    copy_shared_string(res->type, int_type_string);    else    copy_shared_string(res->type, mixed_type_string);    res->node_info = 0;    res->u.sval.type = T_INT;    res->u.sval.subtype = NUMBER_NUMBER;    res->u.sval.u.integer = nr; -  +  check_node(res);    return res;   }      node *mkfloatnode(FLOAT_TYPE foo)   {    node *res = mkemptynode();    res->token = F_CONSTANT;    copy_shared_string(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; -  +  check_node(res);    return res;   }      node *mkapplynode(node *func,node *args)   {    return mknode(F_APPLY, func, args);   }      node *mkefuncallnode(char *function, node *args)   {    struct pike_string *name;    node *n;    name = findstring(function);    if(!name || !find_module_identifier(name))    {    my_yyerror("Internally used efun undefined: %s",function);    return mkintnode(0);    }    n=mkapplynode(mksvaluenode(sp-1), args);    pop_stack(); -  +  check_node(n);    return n;   }      node *mkopernode(char *oper_id, node *arg1, node *arg2)   {    if(arg1 && arg2)    arg1=mknode(F_ARG_LIST,arg1,arg2);       return mkefuncallnode(oper_id, arg1);   }
pike.git/src/las.c:400:   {    node *res = mkemptynode();    res->token = F_LOCAL;    copy_shared_string(res->type, local_variables->variable[var].type);    res->node_info = OPT_NOT_CONST;    res->tree_info=res->node_info;   #ifdef __CHECKER__    CDR(res)=0;   #endif    res->u.number = var; +  check_node(res);    return res;   }      node *mkidentifiernode(int i)   {    node *res = mkemptynode();    res->token = F_IDENTIFIER;    setup_fake_program();    copy_shared_string(res->type, ID_FROM_INT(&fake_program, i)->type);   
pike.git/src/las.c:423:    res->node_info = OPT_EXTERNAL_DEPEND;    }else{    res->node_info = OPT_NOT_CONST;    }    res->tree_info=res->node_info;      #ifdef __CHECKER__    CDR(res)=0;   #endif    res->u.number = i; +  check_node(res);    return res;   }      node *mkcastnode(struct pike_string *type,node *n)   {    node *res;    if(!n) return 0;    if(type==n->type) return n;    res = mkemptynode();    res->token = F_CAST;
pike.git/src/las.c:444:       if(match_types(object_type_string, type) ||    match_types(object_type_string, type))    res->node_info |= OPT_SIDE_EFFECT;       CAR(res) = n;   #ifdef __CHECKER__    CDR(res)=0;   #endif    n->parent=res; +  check_node(res);    return res;   }      void resolv_constant(node *n)   {    struct identifier *i; -  +  check_node(n);    if(!n)    {    push_int(0);    }else{ -  +  check_node(n);    switch(n->token)    {    case F_CONSTANT:    push_svalue(& n->u.sval);    break;       case F_IDENTIFIER:    setup_fake_program();    i=ID_FROM_INT(& fake_program, n->u.number);   
pike.git/src/las.c:491:    push_int(0);    break;    }    }   }      node *debug_index_node(node *n, struct pike_string * id)   {    node *ret;    JMP_BUF tmp; +  check_node(n);    if(SETJMP(tmp))    {    ONERROR tmp;    SET_ONERROR(tmp,exit_on_error,"Error in handle_error in master object!");    assign_svalue_no_free(sp++, & throw_value);    APPLY_MASTER("handle_error", 1);    pop_stack();    UNSET_ONERROR(tmp);       yyerror("Couldn't index module.");
pike.git/src/las.c:1171:    push_type(T_MIXED);    }    }   }         void fix_type_field(node *n)   {    struct pike_string *type_a,*type_b;    +  check_node(n); +     if(n->type) return; /* assume it is correct */       switch(n->token)    {    case F_LAND:    case F_LOR:    if(!match_types(CAR(n)->type,mixed_type_string))    yyerror("Bad conditional expression.\n");       if(!match_types(CDR(n)->type,mixed_type_string))
pike.git/src/las.c:1204:    my_yyerror("Bad type in assignment.");    copy_shared_string(n->type, CDR(n)->type);    break;       case F_INDEX:    type_a=CAR(n)->type;    type_b=CDR(n)->type;    if(!check_indexing(type_a, type_b, n))    my_yyerror("Indexing on illegal type.");    n->type=index_type(type_a,n); +  check_node(n);    break;       case F_ARROW:    type_a=CAR(n)->type;    type_b=CDR(n)->type;    if(!check_indexing(type_a, type_b, n))    my_yyerror("Indexing on illegal type.");    n->type=index_type(type_a,n); -  +  check_node(n);    break;       case F_APPLY:    {    struct pike_string *s;    struct pike_string *f;    push_type(T_MIXED); /* match any return type, even void */    push_type(T_VOID); /* not varargs */    push_type(T_MANY);    low_build_function_type(CDR(n));
pike.git/src/las.c:1250:    name="`() (function call)";    }       if(max_correct_args == count_arguments(s))    {    my_yyerror("To few arguments to %s.\n",name);    }else{    my_yyerror("Bad argument %d to %s.",    max_correct_args+1, name);    } +  check_node(n);    copy_shared_string(n->type, mixed_type_string);    }    free_string(s);    break;    }       case '?':    if(!match_types(CAR(n)->type,mixed_type_string))    yyerror("Bad conditional expression.\n");   
pike.git/src/las.c:1349:    if(CAR(n))    copy_shared_string(n->type,CAR(n)->type);    else    copy_shared_string(n->type,void_type_string);    return;    }       default:    copy_shared_string(n->type,mixed_type_string);    } +  check_node(n);   }      static void zapp_try_optimize(node *n)   {    if(!n) return; -  +  check_node(n);    n->node_info &=~ OPT_TRY_OPTIMIZE;    n->tree_info &=~ OPT_TRY_OPTIMIZE;    if(car_is_node(n)) zapp_try_optimize(CAR(n));    if(cdr_is_node(n)) zapp_try_optimize(CDR(n));   }      static void optimize(node *n)   {    node *tmp1, *tmp2, *tmp3;    INT32 save_line = current_line; -  +  check_node(n);    do    {    if(car_is_node(n) && !(CAR(n)->node_info & OPT_OPTIMIZED))    {    n=CAR(n);    continue;    }    if(cdr_is_node(n) && !(CDR(n)->node_info & OPT_OPTIMIZED))    {    n=CDR(n);
pike.git/src/las.c:1427:    fix_type_field(n);      #ifdef DEBUG    if(l_flag > 3 && n)    {    fprintf(stderr,"Optimizing (tree info=%x):",n->tree_info);    print_tree(n);    }   #endif    +  check_node(n); +     switch(n->token)    {    case F_APPLY:    if(CAR(n)->token == F_CONSTANT &&    CAR(n)->u.sval.type == T_FUNCTION &&    CAR(n)->u.sval.subtype == FUNCTION_BUILTIN && /* driver fun? */    CAR(n)->u.sval.u.efun->optimize)    {    if((tmp1=CAR(n)->u.sval.u.efun->optimize(n)))    {