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.72 1999/01/29 12:29:02 hubbe Exp $"); + RCSID("$Id: las.c,v 1.73 1999/01/31 09:01:51 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:42:   extern char *get_type_name(int);      #define MAX_GLOBAL 2048      int car_is_node(node *n)   {    switch(n->token)    {    case F_EXTERNAL:    case F_IDENTIFIER: +  case F_TRAMPOLINE:    case F_CONSTANT:    case F_LOCAL:    return 0;       default:    return !!CAR(n);    }   }      int cdr_is_node(node *n)   {    switch(n->token)    {    case F_EXTERNAL:    case F_IDENTIFIER: -  +  case F_TRAMPOLINE:    case F_CONSTANT:    case F_LOCAL:    case F_CAST:    return 0;       default:    return !!CDR(n);    }   }   
pike.git/src/las.c:496:   }      node *mkopernode(char *oper_id, node *arg1, node *arg2)   {    if(arg1 && arg2)    arg1=mknode(F_ARG_LIST,arg1,arg2);       return mkefuncallnode(oper_id, arg1);   }    - node *mklocalnode(int var) + node *mklocalnode(int var, int depth)   { -  +  struct compiler_frame *f; +  int e;    node *res = mkemptynode();    res->token = F_LOCAL; -  copy_shared_string(res->type, compiler_frame->variable[var].type); +  +  f=compiler_frame; +  for(e=0;e<depth;e++) f=f->previous; +  copy_shared_string(res->type, f->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; +  res->u.integer.a = var; +  res->u.integer.b = depth;    return res;   }      node *mkidentifiernode(int i)   {    node *res = mkemptynode();    res->token = F_IDENTIFIER;    copy_shared_string(res->type, ID_FROM_INT(new_program, i)->type);       /* FIXME */
pike.git/src/las.c:784:    check_tree(a,0);    check_tree(b,0);       if(a == b) return 1;    if(!a || !b) return 0;    if(a->token != b->token) return 0;       switch(a->token)    {    case F_LOCAL: +  return a->u.integer.a == b->u.integer.b; +     case F_IDENTIFIER: -  +  case F_TRAMPOLINE: /* FIXME, the context has to be the same! */    return a->u.number == b->u.number;       case F_CAST:    return a->type == b->type && node_is_eq(CAR(a), CAR(b));       case F_CONSTANT:    return is_equal(&(a->u.sval), &(b->u.sval));       default:    if( a->type != b->type ) return 0;
pike.git/src/las.c:895:      node *copy_node(node *n)   {    node *b;    check_tree(n,0);    if(!n) return n;    switch(n->token)    {    case F_LOCAL:    case F_IDENTIFIER: +  case F_TRAMPOLINE:    b=mkintnode(0);    *b=*n;    copy_shared_string(b->type, n->type);    return b;       case F_CAST:    b=mkcastnode(n->type,copy_node(CAR(n)));    break;       case F_CONSTANT:
pike.git/src/las.c:1065:   {    if(!foo) return;    if(l_flag>9)    {    printf("/*%x*/",foo->tree_info);    }    switch(foo->token)    {    case F_LOCAL:    if(needlval) putchar('&'); -  printf("$%ld",(long)foo->u.number); +  if(foo->u.integer.b) +  { +  printf("$<%ld>%ld",(long)foo->u.integer.b,(long)foo->u.integer.a); +  }else{ +  printf("$%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(")");    break;       case F_IDENTIFIER:    if(needlval) putchar('&');    printf("%s",ID_FROM_INT(new_program, foo->u.number)->name->str);    break;    -  +  case F_TRAMPOLINE: +  printf("trampoline<%s>",ID_FROM_INT(new_program, foo->u.number)->name->str); +  break; +     case F_ASSIGN:    low_print_tree(CDR(foo),1);    printf("=");    low_print_tree(CAR(foo),0);    break;       case F_CAST:    {    char *s;    init_buf();
pike.git/src/las.c:1222:    int noblock,    int overwrite)   {    struct used_vars *a;    char *q;       if(!n) return 0;    switch(n->token)    {    case F_LOCAL: -  q=p->locals+n->u.number; +  /* FIXME: handle local variable depth */ +  q=p->locals+n->u.integer.a;    goto set_pointer;       case F_IDENTIFIER:    q=p->globals+n->u.number;    if(n->u.number > MAX_GLOBAL)    {    p->err=1;    return 0;    }   
pike.git/src/las.c:1300:   /* no subtility needed */   static void find_written_vars(node *n,    struct used_vars *p,    int lvalue)   {    if(!n) return;       switch(n->token)    {    case F_LOCAL: -  if(lvalue) p->locals[n->u.number]=VAR_USED; +  if(lvalue) p->locals[n->u.integer.a]=VAR_USED;    break;       case F_IDENTIFIER:    if(lvalue)    {    if(n->u.number>=MAX_GLOBAL)    {    p->err=1;    return;    }
pike.git/src/las.c:1562:    n->type=check_call(s,f);    args=count_arguments(s);    max_args=count_arguments(f);    if(max_args<0) max_args=0x7fffffff;       if(!n->type)    {    char *name;    switch(CAR(n)->token)    { + #if 0 /* FIXME */ +  case F_TRAMPOLINE; + #endif    case F_IDENTIFIER:    name=ID_FROM_INT(new_program, CAR(n)->u.number)->name->str;    break;       case F_CONSTANT:    switch(CAR(n)->u.sval.type)    {    case T_FUNCTION:    if(CAR(n)->u.sval.subtype == FUNCTION_BUILTIN)    {
pike.git/src/las.c:2327:       if(stupid_args(CAR(n), expected,vargs) == expected+1)    return 65535;    return -1;       case F_ARG_LIST:    expected=stupid_args(CAR(n), expected,vargs);    if(expected==-1) return -1;    return stupid_args(CDR(n), expected,vargs);    case F_LOCAL: -  return n->u.number==expected ? expected + 1 : -1; +  return (!n->u.integer.b && n->u.integer.a==expected) ? expected + 1 : -1;    default:    return -1;    }   }      static int is_null_branch(node *n)   {    if(!n) return 1;    if(n->token==F_CAST && n->type==void_type_string)    return is_null_branch(CAR(n));