Branch: Tag:

1999-11-11

1999-11-11 15:12:17 by Henrik Grubbström (Grubba) <grubba@grubba.org>

Support for SHARED_NODES.
print_tree() now writes to stderr.

Rev: src/las.c:1.100

5:   \*/   /**/   #include "global.h" - RCSID("$Id: las.c,v 1.99 1999/11/08 20:50:50 grubba Exp $"); + RCSID("$Id: las.c,v 1.100 1999/11/11 15:12:17 grubba Exp $");      #include "language.h"   #include "interpret.h"
57:    return 0;       default: -  return !!CAR(n); +  return !!_CAR(n);    }   }   
74:    return 0;       default: -  return !!CDR(n); +  return !!_CDR(n);    }   }   
86: Inside #if defined(PIKE_DEBUG)
   if(n->token==USHRT_MAX)    fatal("Free node in tree.\n");    +  check_node_hash(n); +     if(d_flag<2) return;       if(!(depth & 1023))
206:   #undef BLOCK_ALLOC_NEXT   #define BLOCK_ALLOC_NEXT next    + #ifdef SHARED_NODES +  + struct node_hash_table node_hash; +  + static unsigned INT32 hash_node(node *n) + { +  return hashmem((unsigned char *)&(n->token), +  sizeof(node) - OFFSETOF(node_s, token), sizeof(node)); + } +  + static void add_node(node *n) + { +  unsigned INT32 hval = n->hash % node_hash.size; +  +  n->next = node_hash.table[hval]; +  node_hash.table[hval] = n; + } +  + static void sub_node(node *n) + { +  node *prior; +  +  if (!node_hash.size) { +  return; +  } +  +  prior = node_hash.table[n->hash % node_hash.size]; +  +  if (!prior) { +  return; +  } +  if (prior == n) { +  node_hash.table[n->hash % node_hash.size] = n->next; +  } else { +  while(prior && (prior->next != n)) { +  prior = prior->next; +  } +  if (!prior) { +  return; +  } +  prior->next = n->next; +  } + } +  + static node *freeze_node(node *orig) + { +  unsigned INT32 hash = hash_node(orig); +  node *n = node_hash.table[hash % node_hash.size]; +  +  while (n) { +  if ((n->hash == hash) && +  !MEMCMP(&(n->token), &(orig->token), +  sizeof(node) - OFFSETOF(node_s, token))) { + #if 0 +  fprintf(stderr, "Found node: "); +  print_tree(n); + #endif /* 0 */ +  free_node(orig); +  n->refs++; +  return n; +  } +  n = n->next; +  } +  orig->hash = hash; +  add_node(orig); +  return orig; + } +  + #else /* !SHARED_NODES */ +  + #define freeze_node(X) (X) +  + #endif /* SHARED_NODES */ +    void free_all_nodes(void)   {    if(!compiler_frame)
220:   #endif       for(tmp2=node_s_blocks;tmp2;tmp2=tmp2->next) e+=NODES; -  for(tmp=free_node_ss;tmp;tmp=CAR(tmp)) e--; +  for(tmp=free_node_ss;tmp;tmp=_CAR(tmp)) e--;    if(e)    {    int e2=e;
228:    {    for(e=0;e<NODES;e++)    { -  for(tmp=free_node_ss;tmp;tmp=CAR(tmp)) +  for(tmp=free_node_ss;tmp;tmp=_CAR(tmp))    if(tmp==tmp2->x+e)    break;       if(!tmp)    {    tmp=tmp2->x+e; - #ifdef PIKE_DEBUG + #if defined(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, tmp->token); +  fprintf(stderr,"Free node at %p, (%s:%d) (token=%d).\n", +  tmp, tmp->current_file->str, tmp->line_number, +  tmp->token);       debug_malloc_dump_references(tmp);       if(tmp->token==F_CONSTANT)    print_tree(tmp);    } -  else +  /* else */   #endif    {    /* Free the node and be happy */    /* Make sure we don't free any nodes twice */ -  if(car_is_node(tmp)) CAR(tmp)=0; -  if(cdr_is_node(tmp)) CDR(tmp)=0; +  if(car_is_node(tmp)) _CAR(tmp)=0; +  if(cdr_is_node(tmp)) _CDR(tmp)=0; + #ifdef SHARED_NODES +  tmp->hash = hash_node(tmp); +  /* Force the node to be freed. */ +  tmp->refs = 1; + #endif /* SHARED_NODES */    debug_malloc_touch(tmp->type);    free_node(tmp);    }    }    }    } - #ifdef PIKE_DEBUG + #if defined(PIKE_DEBUG)    if(!cumulative_parse_error)    fatal("Failed to free %d nodes when compiling!\n",e2);   #endif
268:   #endif    free_all_node_s_blocks();    cumulative_parse_error=0; +  + #ifdef SHARED_NODES +  MEMSET(node_hash.table, 0, sizeof(node *) * node_hash.size); + #endif /* SHARED_NODES */    }   }   
277: Inside #if defined(PIKE_DEBUG)
  #ifdef PIKE_DEBUG    if(l_flag>9)    print_tree(n); - #endif +     -  + #ifdef SHARED_NODES +  { +  unsigned INT32 hash; +  if ((hash = hash_node(n)) != n->hash) { +  fprintf(stderr, "Hash-value is bad 0x%08x != 0x%08x\n", hash, n->hash); + #if 0 +  print_tree(n); +  fatal("token:%d, car:%p cdr:%p file:%s line:%d\n", +  n->token, CAR(n), CDR(n), n->current_file->str, n->line_number); + #endif /* 0 */ +  } +  } + #endif /* SHARED_NODES */ + #endif /* PIKE_DEBUG */ +  + #ifdef SHARED_NODES +  if (--n->refs) { +  return; +  } + #endif /* SHARED_NODES */ +     switch(n->token)    {    case USHRT_MAX:
303:   }       + node *debug_check_node_hash(node *n) + { + #if defined(PIKE_DEBUG) && defined(SHARED_NODES) +  if (n && (n->hash != hash_node(n))) { +  fatal("Bad node hash!\n"); +  } + #endif /* PIKE_DEBUG && SHARED_NODES */ +  return n; + } +    /* here starts routines to make nodes */   static node *mkemptynode(void)   {    node *res=alloc_node_s(); -  +  + #ifdef SHARED_NODES +  MEMSET(res, 0, sizeof(node)); +  res->hash = 0; +  res->refs = 1; + #endif /* SHARED_NODES */ +     res->token=0;    res->line_number=lex.current_line;   #ifdef PIKE_DEBUG
320:    return res;   }    - node *mknode(short token,node *a,node *b) + node *mknode(short token, node *a, node *b)   {    node *res; - #ifdef PIKE_DEBUG +  + #if defined(PIKE_DEBUG) && !defined(SHARED_NODES)    if(a && a==b)    fatal("mknode: a and be are the same!\n");   #endif    -  +     check_tree(a,0);    check_tree(b,0); -  +     res = mkemptynode(); -  CAR(res) = a; -  CDR(res) = b; +  _CAR(res) = a; +  _CDR(res) = b;    res->node_info = 0;    res->tree_info = 0; -  if(a) a->parent = res; -  if(b) b->parent = res; +  if(a) { +  a->parent = res; + #ifdef SHARED_NODES +  a->refs++; + #endif /* SHARED_NODES */ +  } +  if(b) { +  b->parent = res; + #ifdef SHARED_NODES +  b->refs++; + #endif /* SHARED_NODES */ +  }    -  +  res->token = token; +  res->type = 0;    -  + #ifdef SHARED_NODES +  { +  node *res2 = freeze_node(res); +  +  if (res2 != res) { +  return res2; +  } +  } + #endif /* SHARED_NODES */ +     switch(token)    {    case F_CATCH:
404:    if(a) res->tree_info |= a->tree_info;    if(b) res->tree_info |= b->tree_info;    } -  res->token = token; -  res->type = 0; +     -  +    #ifdef PIKE_DEBUG    if(d_flag > 3)    verify_shared_strings_tables();
439:    res->u.sval.subtype = 0;   #endif    copy_shared_string(res->u.sval.u.string, str); -  return res; +  +  return freeze_node(res);   }      node *mkintnode(int nr)
451:    res->u.sval.subtype = NUMBER_NUMBER;    res->u.sval.u.integer = nr;    res->type=get_type_of_svalue( & res->u.sval); +  +  return freeze_node(res); + } +  + /* FIXME: Should probably have a flag on these nodes so they aren't reused. */ + node *mknewintnode(int nr) + { +  node *res = mkemptynode(); +  res->token = F_CONSTANT; +  res->node_info = 0; +  res->u.sval.type = T_INT; +  res->u.sval.subtype = NUMBER_NUMBER; +  res->u.sval.u.integer = nr; +  res->type=get_type_of_svalue( & res->u.sval); + #ifdef SHARED_NODES +  res->refs = 1; +  res->hash = hash_node(res); + #endif /* SHARED_NODES */ +     return res;   }   
464:    res->u.sval.subtype = 0;   #endif    res->u.sval.u.float_number = foo; -  return res; +  +  return freeze_node(res);   }      
472:   {    struct svalue s;    s.u.program=p; -  s.type=T_PROGRAM; +  s.type = T_PROGRAM; + #ifdef __CHECKER__ +  s.subtype = 0; + #endif    return mkconstantsvaluenode(&s);   }   
491:    my_yyerror("Internally used efun undefined: %s",function);    return mkintnode(0);    } -  n=mkapplynode(n, args); +  n = mkapplynode(n, args);    return n;   }   
517:    res->node_info = OPT_NOT_CONST;    res->tree_info=res->node_info;   #ifdef __CHECKER__ -  CDR(res)=0; +  _CDR(res) = 0;   #endif    res->u.integer.a = var;    res->u.integer.b = depth; -  +  + #ifdef SHARED_NODES +  /* FIXME: Not common-subexpression optimized. */ +  res->hash = hash_node(res); +  res->refs = 1; +  +  /* return freeze_node(res); */ + #endif /* SHARED_NODES */ +     return res;   }   
540:    res->tree_info=res->node_info;      #ifdef __CHECKER__ -  CDR(res)=0; +  CDR(res) = 0;   #endif -  res->u.number = i; +  res->u.id.number = i; + #ifdef SHARED_NODES +  res->u.id.prog = new_program; + #endif /* SHARED_NODES */ +  +  res = freeze_node(res); +     check_tree(res,0);    return res;   }
557:    copy_shared_string(res->type, id->type);       /* FIXME */ -  if(IDENTIFIER_IS_CONSTANT(ID_FROM_INT(parent_compilation(level), i)->identifier_flags)) +  if(IDENTIFIER_IS_CONSTANT(ID_FROM_INT(parent_compilation(level), +  i)->identifier_flags))    {    res->node_info = OPT_EXTERNAL_DEPEND;    }else{    res->node_info = OPT_NOT_CONST;    } -  res->tree_info=res->node_info; +  res->tree_info = res->node_info;      #ifdef __CHECKER__ -  CDR(res)=0; +  _CDR(res) = 0;   #endif    res->u.integer.a = level;    res->u.integer.b = i;
574:    /* Bzot-i-zot */    new_program->flags |= PROGRAM_USES_PARENT;    -  return res; +  return freeze_node(res);   }      node *mkcastnode(struct pike_string *type,node *n)   {    node *res; -  +     if(!n) return 0; -  +  + #ifdef SHARED_NODES +  n->refs++; + #endif /* SHARED_NODES */    if(type==n->type) return n; -  +     res = mkemptynode();    res->token = F_CAST;    copy_shared_string(res->type,type);
590:    match_types(object_type_string, type))    res->node_info |= OPT_SIDE_EFFECT;    -  CAR(res) = n; +  _CAR(res) = n; + #ifdef SHARED_NODES +  _CDR(res) = (node *)type; + #else /* !SHARED_NODES */   #ifdef __CHECKER__ -  CDR(res)=0; +  _CDR(res) = 0;   #endif -  + #endif /* SHARED_NODES */ +     n->parent=res; -  return res; +  +  return freeze_node(res);   }      void resolv_constant(node *n)
629:       case F_IDENTIFIER:    p=new_program; -  numid=n->u.number; +  numid=n->u.id.number;    break;       case F_LOCAL:
872:       case F_IDENTIFIER:    case F_TRAMPOLINE: /* FIXME, the context has to be the same! */ -  return a->u.number == b->u.number; +  return a->u.id.number == b->u.id.number;       case F_CAST:    return a->type == b->type && node_is_eq(CAR(a), CAR(b));
893:    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)) +  if(s->type == T_OBJECT || +  (s->type==T_FUNCTION && s->subtype!=FUNCTION_BUILTIN))    {    res->node_info|=OPT_EXTERNAL_DEPEND;    }    res->type = get_type_of_svalue(s); -  return res; +  return freeze_node(res);   }      node *mkliteralsvaluenode(struct svalue *s)   {    node *res = mkconstantsvaluenode(s);    -  +  /* FIXME: The following affects other instances of this node, +  * but probably not too much. +  */    if(s->type!=T_STRING && s->type!=T_INT && s->type!=T_FLOAT)    res->node_info|=OPT_EXTERNAL_DEPEND;   
973:    * optimizer    */    + #ifdef DEAD_CODE +    node *copy_node(node *n)   {    node *b;
983:    case F_LOCAL:    case F_IDENTIFIER:    case F_TRAMPOLINE: -  b=mkintnode(0); +  b=mknewintnode(0);    *b=*n;    copy_shared_string(b->type, n->type);    return b;    -  +  default: + #ifdef SHARED_NODES +  n->refs++; +  return n; + #else /* !SHARED_NODES */    case F_CAST:    b=mkcastnode(n->type,copy_node(CAR(n)));    break;
1019:    copy_shared_string(b->type, n->type);    else    b->type=0; + #endif /* SHARED_NODES */    }    if(n->name)    {
1034:    return b;   }    + #endif /* DEAD_CODE */    -  +    int is_const(node *n)   {    if(!n) return 1;
1092:   {    node **n;    if(!a || !*a) return (node **)NULL; -  if((*a)->token == F_CAST) return last_cmd(&CAR(*a)); +  if((*a)->token == F_CAST) return last_cmd(&_CAR(*a));    if(((*a)->token != F_ARG_LIST) &&    ((*a)->token != F_COMMA_EXPR)) return a;    if(CDR(*a))    {    if(CDR(*a)->token != F_CAST && CAR(*a)->token != F_ARG_LIST &&    CAR(*a)->token != F_COMMA_EXPR) -  return &CDR(*a); -  if((n=last_cmd(&CDR(*a)))) +  return &_CDR(*a); +  if((n=last_cmd(&_CDR(*a))))    return n;    }    if(CAR(*a))    {    if(CAR(*a)->token != F_CAST && CAR(*a)->token != F_ARG_LIST &&    CAR(*a)->token != F_COMMA_EXPR) -  return &CAR(*a); -  if((n=last_cmd(&CAR(*a)))) +  return &_CAR(*a); +  if((n=last_cmd(&_CAR(*a))))    return n;    }    return 0;
1125:    return NULL;    }    if(CAR(*a)) -  if((n=low_get_arg(&CAR(*a),nr))) +  if((n=low_get_arg(&_CAR(*a),nr)))    return n;       if(CDR(*a)) -  if((n=low_get_arg(&CDR(*a),nr))) +  if((n=low_get_arg(&_CDR(*a),nr)))    return n;       return 0;
1147:    CAR(n)->u.sval.type == T_FUNCTION &&    CAR(n)->u.sval.subtype == FUNCTION_BUILTIN &&    CAR(n)->u.sval.u.efun->function == f) -  return & CDR(n); +  return &_CDR(n);    }    return 0;   }
1158:    if(!foo) return;    if(l_flag>9)    { -  printf("/*%x*/",foo->tree_info); +  fprintf(stderr, "/*%x*/",foo->tree_info);    }    switch(foo->token)    { -  +  case USHRT_MAX: +  fprintf(stderr, "FREED_NODE"); +  break;    case F_LOCAL: -  if(needlval) putchar('&'); +  if(needlval) fputc('&', stderr);    if(foo->u.integer.b)    { -  printf("$<%ld>%ld",(long)foo->u.integer.b,(long)foo->u.integer.a); +  fprintf(stderr, "$<%ld>%ld",(long)foo->u.integer.b,(long)foo->u.integer.a);    }else{ -  printf("$%ld",(long)foo->u.integer.a); +  fprintf(stderr, "$%ld",(long)foo->u.integer.a);    }    break;       case '?': -  printf("("); -  low_print_tree(CAR(foo),0); -  printf(")?("); -  low_print_tree(CADR(foo),0); -  printf("):("); -  low_print_tree(CDDR(foo),0); -  printf(")"); +  fprintf(stderr, "("); +  low_print_tree(_CAR(foo),0); +  fprintf(stderr, ")?("); +  low_print_tree(_CADR(foo),0); +  fprintf(stderr, "):("); +  low_print_tree(_CDDR(foo),0); +  fprintf(stderr, ")");    break;       case F_IDENTIFIER: -  if(needlval) putchar('&'); -  printf("%s",ID_FROM_INT(new_program, foo->u.number)->name->str); +  if(needlval) fputc('&', stderr); +  if (new_program) { +  fprintf(stderr, "%s",ID_FROM_INT(new_program, foo->u.id.number)->name->str); +  } else { +  fprintf(stderr, "unknown identifier"); +  }    break;       case F_TRAMPOLINE: -  printf("trampoline<%s>",ID_FROM_INT(new_program, foo->u.number)->name->str); +  if (new_program) { +  fprintf(stderr, "trampoline<%s>", +  ID_FROM_INT(new_program, foo->u.id.number)->name->str); +  } else { +  fprintf(stderr, "trampoline<unknown identifier>"); +  }    break;       case F_ASSIGN: -  low_print_tree(CDR(foo),1); -  printf("="); -  low_print_tree(CAR(foo),0); +  low_print_tree(_CDR(foo),1); +  fprintf(stderr, "="); +  low_print_tree(_CAR(foo),0);    break;       case F_CAST:
1203:    init_buf();    low_describe_type(foo->type->str);    s=simple_free_buf(); -  printf("(%s){",s); +  fprintf(stderr, "(%s){",s);    free(s); -  low_print_tree(CAR(foo),0); -  printf("}"); +  low_print_tree(_CAR(foo),0); +  fprintf(stderr, "}");    break;    }       case F_COMMA_EXPR:    case F_ARG_LIST: -  low_print_tree(CAR(foo),0); -  if(CAR(foo) && CDR(foo)) +  low_print_tree(_CAR(foo),0); +  if(_CAR(foo) && _CDR(foo))    { -  if(CAR(foo)->type == void_type_string && -  CDR(foo)->type == void_type_string) -  printf(";\n"); +  if(_CAR(foo)->type == void_type_string && +  _CDR(foo)->type == void_type_string) +  fprintf(stderr, ";\n");    else -  putchar(','); +  fputc(',', stderr);    } -  low_print_tree(CDR(foo),needlval); +  low_print_tree(_CDR(foo),needlval);    return;       case F_ARRAY_LVALUE: -  putchar('['); -  low_print_tree(CAR(foo),1); -  putchar(']'); +  fputc('[', stderr); +  low_print_tree(_CAR(foo),1); +  fputc(']', stderr);    break;       case F_LVALUE_LIST: -  low_print_tree(CAR(foo),1); -  if(CAR(foo) && CDR(foo)) putchar(','); -  low_print_tree(CDR(foo),1); +  low_print_tree(_CAR(foo),1); +  if(_CAR(foo) && _CDR(foo)) fputc(',', stderr); +  low_print_tree(_CDR(foo),1);    return;       case F_CONSTANT:
1242:    init_buf();    describe_svalue(& foo->u.sval, 0, 0);    s=simple_free_buf(); -  printf("%s",s); +  fprintf(stderr, "%s",s);    free(s);    break;    }       case F_VAL_LVAL: -  low_print_tree(CAR(foo),0); -  printf(",&"); -  low_print_tree(CDR(foo),0); +  low_print_tree(_CAR(foo),0); +  fprintf(stderr, ",&"); +  low_print_tree(_CDR(foo),0);    return;       case F_APPLY: -  low_print_tree(CAR(foo),0); -  printf("("); -  low_print_tree(CDR(foo),0); -  printf(")"); +  low_print_tree(_CAR(foo),0); +  fprintf(stderr, "("); +  low_print_tree(_CDR(foo),0); +  fprintf(stderr, ")");    return;       default:    if(!car_is_node(foo) && !cdr_is_node(foo))    { -  printf("%s",get_token_name(foo->token)); +  fprintf(stderr, "%s",get_token_name(foo->token));    return;    }    if(foo->token<256)    { -  printf("%c(",foo->token); +  fprintf(stderr, "%c(",foo->token);    }else{ -  printf("%s(",get_token_name(foo->token)); +  fprintf(stderr, "%s(",get_token_name(foo->token));    } -  if(car_is_node(foo)) low_print_tree(CAR(foo),0); +  if(car_is_node(foo)) low_print_tree(_CAR(foo),0);    if(car_is_node(foo) && cdr_is_node(foo)) -  putchar(','); -  if(cdr_is_node(foo)) low_print_tree(CDR(foo),0); -  printf(")"); +  fputc(',', stderr); +  if(cdr_is_node(foo)) low_print_tree(_CDR(foo),0); +  fprintf(stderr, ")");    return;    }   }
1285:   {    check_tree(n,0);    low_print_tree(n,0); -  printf("\n"); +  fprintf(stderr, "\n");    fflush(stdout);   }   
1336:    goto set_pointer;       case F_IDENTIFIER: -  q=p->globals+n->u.number; -  if(n->u.number > MAX_GLOBAL) +  q=p->globals+n->u.id.number; +  if(n->u.id.number > MAX_GLOBAL)    {    p->err=1;    return 0;
1416:    case F_IDENTIFIER:    if(lvalue)    { -  if(n->u.number>=MAX_GLOBAL) +  if(n->u.id.number>=MAX_GLOBAL)    {    p->err=1;    return;    } -  p->globals[n->u.number]=VAR_USED; +  p->globals[n->u.id.number]=VAR_USED;    }    break;   
1691:    case F_TRAMPOLINE;   #endif    case F_IDENTIFIER: -  name=ID_FROM_INT(new_program, CAR(n)->u.number)->name->str; +  name=ID_FROM_INT(new_program, CAR(n)->u.id.number)->name->str;    break;       case F_CONSTANT:
1885:    (CAR(n)->tree_info & OPT_TRY_OPTIMIZE) &&    CAR(n)->token != ':')    { -  CAR(n) = eval(CAR(n)); + #ifdef SHARED_NODES +  sub_node(n); + #endif /* SHARED_NODES */ +  _CAR(n) = eval(CAR(n)); + #ifdef SHARED_NODES +  n->hash = hash_node(n); +  add_node(n); + #endif /* SHARED_NODES */    if(CAR(n)) CAR(n)->parent = n;    zapp_try_optimize(CAR(n)); /* avoid infinite loops */    continue;
1898:    (CDR(n)->tree_info & OPT_TRY_OPTIMIZE) &&    CDR(n)->token != ':')    { -  CDR(n) = eval(CDR(n)); + #ifdef SHARED_NODES +  sub_node(n); + #endif /* SHARED_NODES */ +  _CDR(n) = eval(CDR(n)); + #ifdef SHARED_NODES +  n->hash = hash_node(n); +  add_node(n); + #endif /* SHARED_NODES */    if(CDR(n)) CDR(n)->parent = n;    zapp_try_optimize(CDR(n)); /* avoid infinite loops */    continue;
1921:   #include "treeopt.h"    use_car:    tmp1=CAR(n); -  CAR(n)=0; + #ifndef SHARED_NODES +  _CAR(n) = 0; + #endif /* !SHARED_NODES */    goto use_tmp1;       use_cdr:    tmp1=CDR(n); -  CDR(n)=0; + #ifndef SHARED_NODES +  _CDR(n) = 0; + #endif /* !SHARED_NODES */    goto use_tmp1;       zap_node:
1934:    goto use_tmp1;       use_tmp1: + #ifdef SHARED_NODES +  sub_node(n->parent); + #endif /* SHARED_NODES */ +     if(CAR(n->parent) == n)    CAR(n->parent) = tmp1;    else    CDR(n->parent) = tmp1;    -  + #ifdef SHARED_NODES +  n->parent->hash = hash_node(n->parent); +  add_node(n->parent); + #endif /* SHARED_NODES */ +     if(tmp1)    tmp1->parent = n->parent;    else    tmp1 = n->parent; -  +     free_node(n); -  n=tmp1; +  n = tmp1; +    #ifdef PIKE_DEBUG    if(l_flag > 3)    {
2221:    int args, vargs, ret;    struct svalue *foo;    -  check_tree(n,0); +  check_tree(check_node_hash(n),0);      #ifdef PIKE_DEBUG    if(a_flag > 1)
2247:    }   #endif    }else{ -  n=mknode(F_ARG_LIST,n,0); +  n=mknode(F_ARG_LIST,check_node_hash(n),0);    -  if((foo=is_stupid_func(n, args, vargs, type))) +  if((foo=is_stupid_func(check_node_hash(n), args, vargs, type)))    {    if(foo->type == T_FUNCTION && foo->subtype==FUNCTION_BUILTIN)    {
2276: Inside #if defined(PIKE_DEBUG)
   if(a_flag > 2)    {    fprintf(stderr,"Coding: "); -  print_tree(n); +  print_tree(check_node_hash(n));    }   #endif    if(!num_parse_error)
2284:    extern int remove_clear_locals;    remove_clear_locals=args;    if(vargs) remove_clear_locals++; -  do_code_block(n); +  do_code_block(check_node_hash(n));    remove_clear_locals=0x7fffffff;    }    }