pike.git / src / program.c

version» Context lines:

pike.git/src/program.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: program.c,v 1.641 2008/01/24 13:58:26 mast Exp $ + || $Id: program.c,v 1.642 2008/01/26 22:34:23 mast Exp $   */      #include "global.h"   #include "program.h"   #include "object.h"   #include "dynamic_buffer.h"   #include "pike_types.h"   #include "stralloc.h"   #include "las.h"   #include "lex.h"
pike.git/src/program.c:1650:    ret=mkconstantsvaluenode(Pike_sp-1);    }    }    pop_stack();    }    else {    if(Pike_compiler->compiler_pass==2) {    if (throw_value.type == T_STRING) {    my_yyerror("%S", throw_value.u.string);    free_svalue(&throw_value); -  throw_value.type = T_INT; +  mark_free_svalue (&throw_value);    }    else {    handle_compile_exception ("Error resolving %S.", ident);    }    }    else {    /* FIXME: Error goes to /dev/null. Now we get a warning at    * least in rtldebug mode, but this borken, borken, boRKen. :P */    struct svalue thrown;    move_svalue (&thrown, &throw_value); -  throw_value.type = T_INT; +  mark_free_svalue (&throw_value);   #ifdef PIKE_DEBUG    {    struct pike_string *msg = format_exception_for_error_msg (&thrown);    if (msg) {    yywarning ("Ignoring resolv() exception in pass %d:",    Pike_compiler->compiler_pass);    yywarning ("%S", msg);    free_string (msg);    }    else
pike.git/src/program.c:6747:    else {    pop_stack();    return NULL;    }   }      void handle_compile_exception (const char *yyerror_fmt, ...)   {    struct svalue thrown;    move_svalue (&thrown, &throw_value); -  throw_value.type = T_INT; +  mark_free_svalue (&throw_value);       if (yyerror_fmt) {    va_list args;    va_start (args, yyerror_fmt);    va_yyerror (yyerror_fmt, args);    va_end (args);    }       push_svalue(&thrown);    low_safe_apply_handler("compile_exception", error_handler, compat_handler, 1);
pike.git/src/program.c:7343:    {    struct program *p = c->target;    /* Free the constants in the failed program, to untangle the    * cyclic references we might have to this program, typically    * in parent pointers in nested classes. */    if (p->constants) {    int i;    for (i = 0; i < p->num_constants; i++) {    free_svalue(&p->constants[i].sval);    p->constants[i].sval.type = T_INT; +  p->constants[i].sval.subtype = NUMBER_NUMBER;    }    }       /* We have to notify the master object that    * a previous compile() actually failed, even    * if we did not know it at the time    */    CDFPRINTF((stderr, "th(%ld) %p unregistering failed delayed compile.\n",    (long) th_self(), p));    ref_push_program(p);
pike.git/src/program.c:7461:       debug_malloc_touch(c);    c->p = NULL;    add_ref(c->prog=aprog);    if((c->handler=ahandler)) add_ref(ahandler);    c->major=amajor;    c->minor=aminor;    if((c->target=atarget)) add_ref(atarget);    if((c->placeholder=aplaceholder)) add_ref(aplaceholder);    c->default_module.type=T_INT; +  c->default_module.subtype = NUMBER_NUMBER;       if (c->handler)    {    if (safe_apply_handler ("get_default_module", c->handler, NULL,    0, BIT_MAPPING|BIT_OBJECT|BIT_ZERO)) {    if(SAFE_IS_ZERO(Pike_sp-1))    {    pop_stack();    ref_push_mapping(get_builtin_constants());    }
pike.git/src/program.c:8136:    int e;    if(p->parent)    {    free_program(p->parent);    p->parent=0;    }    for(e=0;e<p->num_constants;e++)    {    free_svalue(& p->constants[e].sval);    p->constants[e].sval.type=T_INT; +  p->constants[e].sval.subtype = NUMBER_NUMBER;    }       for(e=0;e<p->num_inherits;e++)    {    if(p->inherits[e].parent)    {    free_object(p->inherits[e].parent);    p->inherits[e].parent=0;    }    if(e && p->inherits[e].prog)