pike.git / src / las.c

version» Context lines:

pike.git/src/las.c:1:   /*   || This file is part of Pike. For copyright information see COPYRIGHT.   || Pike is distributed under GPL, LGPL and MPL. See the file COPYING   || for more information. - || $Id: las.c,v 1.347 2004/06/30 00:19:27 nilsson Exp $ + || $Id: las.c,v 1.348 2004/07/05 22:54:13 nilsson Exp $   */      #include "global.h" - RCSID("$Id: las.c,v 1.347 2004/06/30 00:19:27 nilsson Exp $"); + RCSID("$Id: las.c,v 1.348 2004/07/05 22:54:13 nilsson Exp $");      #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"   #include "constants.h"
pike.git/src/las.c:128: Inside #if defined(PIKE_DEBUG)
   if (state && id_no != IDREF_MAGIC_THIS) {    struct identifier *id = ID_FROM_INT(state->new_program, id_no);    if (id) {   #if 0   #ifdef PIKE_DEBUG    /* FIXME: This test crashes on valid code because the type of the    * identifier can change in pass 2 - Hubbe    */    if(id->type != n->type)    { -  fprintf(stderr, "Type of external node " -  "is not matching its identifier.\nid->type: "); +  fputs("Type of external node " +  "is not matching its identifier.\nid->type: ",stderr);    simple_describe_type(id->type); -  fprintf(stderr, "\nn->type : "); +  fputs("\nn->type : ", stderr);    simple_describe_type(n->type); -  fprintf(stderr, "\n"); +  fputc('\n', stderr);       Pike_fatal("Type of external node is not matching its identifier.\n");    }   #endif   #endif    }    }    }    }   
pike.git/src/las.c:206:    if(CDR(n->parent)->parent != n->parent)    Pike_fatal("Parent is wrong.\n");   #endif /* !SHARED_NODES */    n = CDR(n->parent);    continue;    }    break;    }       if (n != orig_n) { -  fprintf(stderr, "check_tree() lost track.\n"); +  fputs("check_tree() lost track.\n", stderr);    d_flag = 0; -  fprintf(stderr, "n:"); +  fputs("n:", stderr);    print_tree(n); -  fprintf(stderr, "orig_n:"); +  fputs("orig_n:", stderr);    print_tree(orig_n);    Pike_fatal("check_tree() lost track.\n");    }    n->parent = parent;   }   #endif      /* FIXME: Ought to use parent pointer to avoid recursion. */   INT32 count_args(node *n)   {
pike.git/src/las.c:309:       optimize(n);       if (n->token == F_RETURN) {    if (CAR(n)) {    if (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"); +  fputs("Return with untyped argument.\n", stderr);    print_tree(n);    }   #endif /* PIKE_DEBUG */    copy_pike_type(a, mixed_type_string);    }    } else {    copy_pike_type(a, zero_type_string);    }    return a;    }
pike.git/src/las.c:2457:    if(l_flag>9)    {    fprintf(stderr, "/*%x*/",foo->tree_info);    }       fatal_check_c_stack(16384);       switch(l_flag > 99 ? -1 : foo->token)    {    case USHRT_MAX: -  fprintf(stderr, "FREED_NODE"); +  fputs("FREED_NODE", stderr);    break;    case F_LOCAL:    if(needlval) fputc('&', stderr);    if(foo->u.integer.b)    {    fprintf(stderr, "$<%ld>%ld",(long)foo->u.integer.b,(long)foo->u.integer.a);    }else{    fprintf(stderr, "$%ld",(long)foo->u.integer.a);    }    break;       case '?': -  fprintf(stderr, "("); +  fputc('(', stderr);    low_print_tree(_CAR(foo),0); -  fprintf(stderr, ")?("); +  fputs(")?(", stderr);    if (_CDR(foo)) {    low_print_tree(_CADR(foo),0); -  fprintf(stderr, "):("); +  fputs("):(", stderr);    low_print_tree(_CDDR(foo),0);    } else { -  fprintf(stderr, "0:0"); +  fputs("0:0", stderr);    } -  fprintf(stderr, ")"); +  fputc(')', stderr);    break;       case F_IDENTIFIER:    if(needlval) fputc('&', stderr);    if (Pike_compiler->new_program) {    fprintf(stderr, "id(%s)",ID_FROM_INT(Pike_compiler->new_program, foo->u.id.number)->name->str);    } else { -  fprintf(stderr, "unknown identifier"); +  fputs("unknown identifier", stderr);    }    break;       case F_EXTERNAL:    if(needlval) fputc('&', stderr);    {    struct program_state *state = Pike_compiler;    char *name = "?";    int program_id = foo->u.integer.a;    int level = 0;
pike.git/src/las.c:2521:    }    fprintf(stderr, "ext(%d:%s)", level, name);    }    break;       case F_TRAMPOLINE:    if (Pike_compiler->new_program) {    fprintf(stderr, "trampoline<%s>",    ID_FROM_INT(Pike_compiler->new_program, foo->u.trampoline.ident)->name->str);    } else { -  fprintf(stderr, "trampoline<unknown identifier>"); +  fputs("trampoline<unknown identifier>", stderr);    }    break;       case F_ASSIGN:    low_print_tree(_CDR(foo),1); -  fprintf(stderr, "="); +  fputc('=', stderr);    low_print_tree(_CAR(foo),0);    break;       case F_POP_VALUE: -  fprintf(stderr, "{"); +  fputc('{', stderr);    low_print_tree(_CAR(foo), 0); -  fprintf(stderr, "}"); +  fputc('}', stderr);    break;       case F_CAST:    {    dynamic_buffer save_buf;    char *s;    init_buf(&save_buf);    my_describe_type(foo->type);    s=simple_free_buf(&save_buf);    fprintf(stderr, "(%s){",s);    free(s);    low_print_tree(_CAR(foo),0); -  fprintf(stderr, "}"); +  fputc('}', stderr);    break;    }       case F_SOFT_CAST:    {    dynamic_buffer save_buf;    char *s;    init_buf(&save_buf);    my_describe_type(foo->type);    s=simple_free_buf(&save_buf);    fprintf(stderr, "[%s]{",s);    free(s);    low_print_tree(_CAR(foo),0); -  fprintf(stderr, "}"); +  fputc('}', stderr);    break;    }       case F_COMMA_EXPR:    low_print_tree(_CAR(foo),0);    if(_CAR(foo) && _CDR(foo))    {    if(_CAR(foo)->type == void_type_string &&    _CDR(foo)->type == void_type_string) -  fprintf(stderr, ";\n"); +  fputs(";\n", stderr);    else -  fprintf(stderr, ",\n"); +  fputs(",\n", stderr);    }    low_print_tree(_CDR(foo),needlval);    return;       case F_ARG_LIST:    low_print_tree(_CAR(foo),0);    if(_CAR(foo) && _CDR(foo))    {    if(_CAR(foo)->type == void_type_string &&    _CDR(foo)->type == void_type_string) -  fprintf(stderr, ";\n"); +  fputs(";\n", stderr);    else    fputc(',', stderr);    }    low_print_tree(_CDR(foo),needlval);    return;       case F_ARRAY_LVALUE:    fputc('[', stderr);    low_print_tree(_CAR(foo),1);    fputc(']', stderr);
pike.git/src/las.c:2617:    init_buf(&save_buf);    describe_svalue(& foo->u.sval, 0, 0);    s=simple_free_buf(&save_buf);    fprintf(stderr, "const(%s)",s);    free(s);    break;    }       case F_VAL_LVAL:    low_print_tree(_CAR(foo),0); -  fprintf(stderr, ",&"); +  fputs(",&", stderr);    low_print_tree(_CDR(foo),0);    return;       case F_AUTO_MAP: -  fprintf(stderr, "__automap__ "); +  fputs("__automap__ ", stderr);    low_print_tree(_CAR(foo),0); -  fprintf(stderr, "("); +  fputc('(', stderr);    low_print_tree(_CDR(foo),0); -  fprintf(stderr, ")"); +  fputc(')', stderr);    return;    case F_AUTO_MAP_MARKER:    low_print_tree(_CAR(foo),0); -  fprintf(stderr, "[*]"); +  fputs("[*]", stderr);    return;    case F_APPLY:    low_print_tree(_CAR(foo),0); -  fprintf(stderr, "("); +  fputc('(', stderr);    low_print_tree(_CDR(foo),0); -  fprintf(stderr, ")"); +  fputc(')', stderr);    return;       case F_NORMAL_STMT_LABEL:    case F_CUSTOM_STMT_LABEL:    fprintf(stderr, "%s:", _CAR(foo)->u.sval.u.string->str);    low_print_tree(_CDR(foo),0);    return;       case F_LOOP: -  fprintf(stderr, "loop("); +  fputs("loop(", stderr);    if(car_is_node(foo)) low_print_tree(_CAR(foo),0); -  fprintf(stderr, ",{"); +  fputs(",{", stderr);    if(cdr_is_node(foo)) low_print_tree(_CDR(foo),0); -  fprintf(stderr, "})"); +  fputs("})", stderr);    return;       default:    if(!car_is_node(foo) && !cdr_is_node(foo))    { -  fprintf(stderr, "%s",get_token_name(foo->token)); +  fputs(get_token_name(foo->token), stderr);    return;    }    if(foo->token<256)    { -  fprintf(stderr, "%c(",foo->token); +  fputc(foo->token, stderr);    }else{ -  fprintf(stderr, "%s(",get_token_name(foo->token)); +  fputs(get_token_name(foo->token), stderr);    } -  +  fputc('(', stderr);    if(car_is_node(foo)) low_print_tree(_CAR(foo),0);    if(car_is_node(foo) && cdr_is_node(foo))    fputc(',', stderr);    if(cdr_is_node(foo)) low_print_tree(_CDR(foo),0); -  fprintf(stderr, ")"); +  fputc(')', stderr);    return;    }   }      void print_tree(node *n)   {    check_tree(n,0);    low_print_tree(n,0); -  fprintf(stderr, "\n"); -  fflush(stdout); +  fputc('\n', stderr);   }         /* The following routines need much better commenting. */   /* They also needed to support lexical scoping and external variables.    * /grubba 2000-08-27    */      /*    * Known bugs:
pike.git/src/las.c:2845: Inside #if defined(PIKE_DEBUG)
   if (l_flag > 3) {    fprintf(stderr, "find_q %d:%d\n", scope_id, num);    }   #endif /* PIKE_DEBUG */    while (*a && ((*a)->scope_id < scope_id)) {    a = &((*a)->next);    }    if ((*a) && ((*a)->scope_id == scope_id)) {   #ifdef PIKE_DEBUG    if (l_flag > 4) { -  fprintf(stderr, "scope found.\n"); +  fputs("scope found.\n", stderr);    }   #endif /* PIKE_DEBUG */    return (*a)->vars + num;    }   #ifdef PIKE_DEBUG    if (l_flag > 4) { -  fprintf(stderr, "Creating new scope.\n"); +  fputs("Creating new scope.\n", stderr);    }   #endif /* PIKE_DEBUG */    new = (struct scope_info *)xalloc(sizeof(struct scope_info));    MEMSET(new, VAR_UNUSED, sizeof(struct scope_info));    new->next = *a;    new->scope_id = scope_id;    *a = new;    return new->vars + num;   }   
pike.git/src/las.c:2924:    }   #endif /* PIKE_DEBUG */       set_pointer:    if(overwrite)    {    if(*q == VAR_UNUSED && !noblock) {    *q = VAR_BLOCKED;   #ifdef PIKE_DEBUG    if (l_flag > 2) { -  fprintf(stderr, "blocked\n"); +  fputs("blocked\n", stderr);    }    } else {    if (l_flag > 2) { -  fprintf(stderr, "overwritten\n"); +  fputs("overwritten\n", stderr);    }   #endif /* PIKE_DEBUG */    }    }    else    {    if(*q == VAR_UNUSED) {    *q = VAR_USED;   #ifdef PIKE_DEBUG    if (l_flag > 2) { -  fprintf(stderr, "used\n"); +  fputs("used\n", stderr);    }    } else {    if (l_flag > 2) { -  fprintf(stderr, "kept\n"); +  fputs("kept\n", stderr);    }   #endif /* PIKE_DEBUG */    }    }    break;       case F_ARROW:    case F_INDEX:   #ifdef PARANOID_INDEXING    /* Be paranoid, and assume aliasing. */
pike.git/src/las.c:3196:       /* A depends on B if A uses stuff that is written to by B. */       find_used_variables(a, &aa, 0, 0);    find_written_vars(b, &bb, 0);      #ifdef PIKE_DEBUG    if (l_flag > 2) {    struct scope_info *aaa = aa.locals;    while (aaa) { -  fprintf(stderr, "Used locals:\n"); +  fputs("Used locals:\n", stderr);    for (e = 0; e < MAX_VAR; e++) {    if (aaa->vars[e] == VAR_USED) {    fprintf(stderr, "\t%d:%d\n", aaa->scope_id, e);    }    }    aaa = aaa->next;    }    aaa = bb.locals;    while (aaa) { -  fprintf(stderr, "Written locals:\n"); +  fputs("Written locals:\n", stderr);    for (e = 0; e < MAX_VAR; e++) {    if (aaa->vars[e] != VAR_UNUSED) {    fprintf(stderr, "\t%d:%d\n", aaa->scope_id, e);    }    }    aaa = aaa->next;    }    }   #endif /* PIKE_DEBUG */   
pike.git/src/las.c:3323:       return depend_p2(a,b);   }      #ifdef PIKE_DEBUG   static int depend_p(node *a,node *b)   {    int ret;    if(l_flag > 3)    { -  fprintf(stderr,"Checking if: "); +  fputs("Checking if: ", stderr);    print_tree(a); -  fprintf(stderr,"Depends on: "); +  fputs("Depends on: ", stderr);    print_tree(b);    if(depend_p3(a,b))    { -  fprintf(stderr,"The answer is (durumroll) : yes\n"); +  fputs("The answer is (drumroll) : yes\n", stderr);    return 1;    }else{ -  fprintf(stderr,"The answer is (durumroll) : no\n"); +  fputs("The answer is (drumroll) : no\n", stderr);    return 0;    }    }    return depend_p3(a,b);   }   #else   #define depend_p depend_p3   #endif      /* Check if n depends on the lvalue lval */
pike.git/src/las.c:3568:    CDR(n)->token != F_ARROW) ||    !match_types(array_type_string, CDR(n)->type)) &&    !match_types(CDR(n)->type,CAR(n)->type)) {    yytype_error("Bad type in assignment.",    CDR(n)->type, CAR(n)->type, 0);    } else if (lex.pragmas & ID_STRICT_TYPES) {    struct pike_string *t1 = describe_type(CAR(n)->type);    struct pike_string *t2 = describe_type(CDR(n)->type);   #ifdef PIKE_DEBUG    if (l_flag > 0) { -  fprintf(stderr, "Warning: Invalid assignment: "); +  fputs("Warning: Invalid assignment: ", stderr);    print_tree(n);    }   #endif /* PIKE_DEBUG */    yywarning("An expression type %S cannot be assigned to "    "a variable of type %S.", t1, t2);    free_string(t2);    free_string(t1);    }    }    }
pike.git/src/las.c:5111: Inside #if defined(SHARED_NODES)
   MEMSET(b_usage, 0, MAX_LOCAL);    MEMSET(c_usage, 0, MAX_LOCAL);    MEMSET(s_usage, 0, MAX_LOCAL);    MEMSET(catch_usage, 0, MAX_LOCAL);       n2 = low_localopt(n, usage, s_usage, c_usage, b_usage, catch_usage);      #ifdef PIKE_DEBUG    if (l_flag > 0) {    if ((n2 != n) || (l_flag > 4)) { -  fprintf(stderr, "\nBefore localopt: "); +  fputs("\nBefore localopt: ", stderr);    print_tree(n);    -  fprintf(stderr, "After localopt: "); +  fputs("After localopt: ", stderr);    print_tree(n2);    }    }   #endif /* PIKE_DEBUG */       free_node(n);    return n2;   }   #endif /* SHARED_NODES */   
pike.git/src/las.c:5286:    ADD_NODE_REF2(CDR(n), tmp1 = CDR(n));    goto use_tmp1;       zap_node:    tmp1 = 0;    goto use_tmp1;       use_tmp1:   #ifdef PIKE_DEBUG    if (l_flag > 4) { -  fprintf(stderr, "Optimized: "); +  fputs("Optimized: ", stderr);    print_tree(n); -  fprintf(stderr, "Result: "); +  fputs("Result: ", stderr);    print_tree(tmp1);    }   #endif /* PIKE_DEBUG */      #ifdef SHARED_NODES    sub_node(n->parent);   #endif /* SHARED_NODES */       if(CAR(n->parent) == n)    _CAR(n->parent) = tmp1;
pike.git/src/las.c:5325:    tmp1->parent = n->parent;    else    tmp1 = n->parent;       free_node(n);    n = tmp1;      #ifdef PIKE_DEBUG    if(l_flag > 3)    { -  fprintf(stderr,"Result: "); +  fputs("Result: ", stderr);    print_tree(n);    }   #endif    continue;       }    n->node_info |= OPT_OPTIMIZED;    n=n->parent;    }while(n);   
pike.git/src/las.c:5686: Inside #if defined(PIKE_DEBUG)
   if(a_flag > 5)    fprintf(stderr, "Extra identifier flags:0x%02x\n", vargs);   #endif       if(Pike_compiler->compiler_pass==1)    {    tmp.offset=-1;   #ifdef PIKE_DEBUG    if(a_flag > 4)    { -  fprintf(stderr,"Making prototype (pass 1) for: "); +  fputs("Making prototype (pass 1) for: ", stderr);    print_tree(n);    }   #endif    }else{   #if defined(SHARED_NODES) && 0    /* Try the local variable usage analyser. */    n = localopt(check_node_hash(n));    /* Try optimizing some more. */    optimize(n);   #endif /* SHARED_NODES && 0 */
pike.git/src/las.c:5736:    }    }    }       tmp.offset=PIKE_PC;    Pike_compiler->compiler_frame->num_args=args;      #ifdef PIKE_DEBUG    if(a_flag > 2)    { -  fprintf(stderr,"Coding: "); +  fputs("Coding: ", stderr);    print_tree(check_node_hash(n));    }   #endif    if(!Pike_compiler->num_parse_error)    {    extern int remove_clear_locals;    remove_clear_locals=args;    if(vargs) remove_clear_locals++;    tmp.offset=do_code_block(check_node_hash(n));    remove_clear_locals=0x7fffffff;