pike.git / src / builtin_functions.c

version» Context lines:

pike.git/src/builtin_functions.c:1151:    SIMPLE_ARG_TYPE_ERROR("has_prefix", 2, "string");       b = Pike_sp[1-args].u.string;       if (TYPEOF(Pike_sp[-args]) == T_OBJECT) {    ptrdiff_t i;    struct object *o = Pike_sp[-args].u.object;    int inherit_no = SUBTYPEOF(Pike_sp[-args]);       if (!o->prog || FIND_LFUN(o->prog, LFUN__SIZEOF) < 0) { -  Pike_error("has_prefix(): Object in argument 1 lacks lfun::_sizeof().\n"); +  Pike_error("Object in argument 1 lacks lfun::_sizeof().\n");    }       apply_lfun(o, LFUN__SIZEOF, 0);    if ((TYPEOF(Pike_sp[-1]) != T_INT) || (Pike_sp[-1].u.integer < b->len)) {    pop_n_elems(args + 1);    push_int(0);    return;    }       for (i = 0; i < b->len; i++) {
pike.git/src/builtin_functions.c:1225:    pop_n_elems(args); \    push_int(len == -1); \    return; \    } \    break       CASE_SHIFT(1,0);    CASE_SHIFT(2,0);    CASE_SHIFT(2,1);    default: -  Pike_error("has_prefix(): Unexpected string shift combination: a:%d, b:%d!\n", +  Pike_error("Unexpected string shift combination: a:%d, b:%d!\n",    a->size_shift, b->size_shift);    break;    }   #undef CASE_SHIFT   #undef TWO_SHIFTS   }      /*! @decl int has_suffix(string s, string suffix)    *!    *! Returns @expr{1@} if the string @[s] ends with @[suffix],
pike.git/src/builtin_functions.c:1299:    pop_n_elems(args); \    push_int(len == -1); \    return; \    } \    break       CASE_SHIFT(1,0);    CASE_SHIFT(2,0);    CASE_SHIFT(2,1);    default: -  Pike_error("has_prefix(): Unexpected string shift combination: a:%d, b:%d!\n", +  Pike_error("Unexpected string shift combination: a:%d, b:%d!\n",    a->size_shift, b->size_shift);    break;    }   #undef CASE_SHIFT   #undef TWO_SHIFTS   }      /*! @decl int has_index(string haystack, int index)    *! @decl int has_index(array haystack, int index)    *! @decl int has_index(mapping|multiset|object|program haystack, mixed index)
pike.git/src/builtin_functions.c:1617:    push_int(0);    }    else    {    pop_n_elems(args-1);    Pike_sp[-1].u.integer = SUBTYPEOF(Pike_sp[-1]);    SET_SVAL_SUBTYPE(Pike_sp[-1], NUMBER_NUMBER);    }   }    - static int generate_zero_type(node *n) + static int generate_arg_for(node *n)   { -  struct compilation *c = THIS_COMPILATION; -  CHECK_COMPILER(); +     if(count_args(CDR(n)) != 1) return 0;    if(do_docode(CDR(n),DO_NOT_COPY) != 1)    Pike_fatal("Count args was wrong in generate_zero_type().\n"); -  +  return 1; + } +  + static int generate_zero_type(node *n) + { +  struct compilation *c = THIS_COMPILATION; +  if( generate_arg_for( n ) )    emit0(F_ZERO_TYPE); -  +  else +  return 0;    return 1;   }    -  + static int generate_undefinedp(node *n) + { +  struct compilation *c = THIS_COMPILATION; +  if( generate_arg_for(n) ) +  emit0(F_UNDEFINEDP); +  else +  return 0; +  return 1; + } +  + static int generate_destructedp(node *n) + { +  struct compilation *c = THIS_COMPILATION; +  if( generate_arg_for(n) ) +  emit0(F_DESTRUCTEDP); +  else +  return 0; +  return 1; + } +    /*    * Some wide-strings related functions    */      /*! @decl string(0..255) string_to_unicode(string s)    *!    *! Converts a string into an UTF16 compliant byte-stream.    *!    *! @note    *! Throws an error if characters not legal in an UTF16 stream are
pike.git/src/builtin_functions.c:1718:    p_wchar2 *str2 = STR2(in);    ptrdiff_t j;    len = in->len * 2;    /* Check how many extra wide characters there are. */    for(i = in->len; i--;) {    if (str2[i] > 0xfffd) {    if (str2[i] < 0x10000) {    /* 0xfffe: Byte-order detection illegal character.    * 0xffff: Illegal character.    */ -  Pike_error("string_to_unicode(): Illegal character 0x%04x (index %ld) " +  Pike_error("Illegal character 0x%04x (index %ld) "    "is not a Unicode character.",    str2[i], PTRDIFF_T_TO_LONG(i));    }    if (str2[i] > 0x10ffff) { -  Pike_error("string_to_unicode(): Character 0x%08x (index %ld) " +  Pike_error("Character 0x%08x (index %ld) "    "is out of range (0x00000000..0x0010ffff).",    str2[i], PTRDIFF_T_TO_LONG(i));    }    /* Extra wide characters take two unicode characters in space.    * ie One unicode character extra.    */    len += 2;    }    }    out = begin_shared_string(len);
pike.git/src/builtin_functions.c:1956:   {    struct pike_string *in;    INT32 min,max;    int i;    static const p_wchar1 replace = 0xfffd;    static const PCHARP repl_char = {(void*)&replace,1};       get_all_args("filter_non_unicode", args, "%W", &in);    check_string_range( in, 1, &min, &max );    -  +     if( !in->len || (min >= 0 && max < 0xd800) )    return; /* The string is obviously ok. */       if( (max < 0 || min > 0x10ffff) || (max < 0xe000 && min > 0xd7ff) )    {    /* All invalid. Could probably be optimized. */    debug_make_shared_binary_pcharp( repl_char, 1 );    push_int( in->len );    o_multiply();    }
pike.git/src/builtin_functions.c:2475:    }    }    out_str[j++] = c;    }    break;    }    }      #ifdef PIKE_DEBUG    if (j != len) { -  Pike_fatal("utf8_to_string(): Calculated and actual lengths differ: " +  Pike_fatal("Calculated and actual lengths differ: "    "%"PRINTPTRDIFFT"d != %"PRINTPTRDIFFT"d\n",    len, j);    }   #endif /* PIKE_DEBUG */    out = low_end_shared_string(out);   #ifdef PIKE_DEBUG    check_string (out);   #endif    pop_n_elems(args);    push_string(out);
pike.git/src/builtin_functions.c:4986:    SIMPLE_TOO_FEW_ARGS_ERROR(NAME, 1); \    if (TYPEOF(Pike_sp[-args]) == T_OBJECT && \    (p = Pike_sp[-args].u.object->prog)) \    { \    int fun = FIND_LFUN(p->inherits[SUBTYPEOF(Pike_sp[-args])].prog, \    LFUN__IS_TYPE); \    if (fun != -1) \    { \    int id_level = \    p->inherits[SUBTYPEOF(Pike_sp[-args])].identifier_level; \ -  push_constant_text(TYPE_NAME); \ +  ref_push_string(literal_##TYPE_NAME##_string); \    apply_low(Pike_sp[-args-1].u.object, fun + id_level, 1); \    stack_unlink(args); \    return; \    } \    } \    t = TYPEOF(Pike_sp[-args]) == TYPE; \    pop_n_elems(args); \    push_int(t); \    }   
pike.git/src/builtin_functions.c:5116:   /*! @decl int floatp(mixed arg)    *!    *! Returns @expr{1@} if @[arg] is a float, @expr{0@} (zero) otherwise.    *!    *! @seealso    *! @[intp()], @[programp()], @[arrayp()], @[multisetp()], @[objectp()],    *! @[mappingp()], @[stringp()], @[functionp()]    */       - TYPEP(f_intp, "intp", T_INT, "int") - TYPEP(f_mappingp, "mappingp", T_MAPPING, "mapping") - TYPEP(f_arrayp, "arrayp", T_ARRAY, "array") - TYPEP(f_multisetp, "multisetp", T_MULTISET, "multiset") - TYPEP(f_stringp, "stringp", T_STRING, "string") - TYPEP(f_floatp, "floatp", T_FLOAT, "float") + TYPEP(f_intp, "intp", T_INT, int) + TYPEP(f_mappingp, "mappingp", T_MAPPING, mapping) + TYPEP(f_arrayp, "arrayp", T_ARRAY, array) + TYPEP(f_multisetp, "multisetp", T_MULTISET, multiset) + TYPEP(f_stringp, "stringp", T_STRING, string) + TYPEP(f_floatp, "floatp", T_FLOAT, float)      /*! @decl array sort(array(mixed) index, array(mixed) ... data)    *!    *! Sort arrays destructively.    *!    *! This function sorts the array @[index] destructively. That means    *! that the array itself is changed and returned, no copy is created.    *!    *! If extra arguments are given, they are supposed to be arrays of the    *! same size as @[index]. Each of these arrays will be modified in the
pike.git/src/builtin_functions.c:5344:    do_debug(); /* Calls do_gc() since d_flag > 3. */   #else    do_gc(NULL, 1);   #endif    d_flag=tmp;    pop_n_elems(args);   }      #ifdef PIKE_DEBUG    - /*! @decl int debug(int(0..) level) + /*! @decl int(0..) debug(int(0..) level)    *! @belongs Debug    *!    *! Set the run-time debug level.    *!    *! @returns    *! The old debug level will be returned.    *!    *! @note    *! This function is only available if the Pike runtime has been compiled    *! with RTL debug.    */   PMOD_EXPORT void f__debug(INT32 args)   {    INT_TYPE d;       ASSERT_SECURITY_ROOT("_debug");    -  get_all_args("_debug", args, "%i", &d); +  get_all_args("_debug", args, "%+", &d);    pop_n_elems(args);    push_int(d_flag);    d_flag = d;   }    - /*! @decl int optimizer_debug(int(0..) level) + /*! @decl int(0..) optimizer_debug(int(0..) level)    *! @belongs Debug    *!    *! Set the optimizer debug level.    *!    *! @returns    *! The old optimizer debug level will be returned.    *!    *! @note    *! This function is only available if the Pike runtime has been compiled    *! with RTL debug.    */   PMOD_EXPORT void f__optimizer_debug(INT32 args)   {    INT_TYPE l;       ASSERT_SECURITY_ROOT("_optimizer_debug");    -  get_all_args("_optimizer_debug", args, "%i", &l); +  get_all_args("_optimizer_debug", args, "%+", &l);    pop_n_elems(args);    push_int(l_flag);    l_flag = l;   }       - /*! @decl int assembler_debug(int(0..) level) + /*! @decl int(0..) assembler_debug(int(0..) level)    *! @belongs Debug    *!    *! Set the assembler debug level.    *!    *! @returns    *! The old assembler debug level will be returned.    *!    *! @note    *! This function is only available if the Pike runtime has been compiled    *! with RTL debug.    */   PMOD_EXPORT void f__assembler_debug(INT32 args)   {    INT_TYPE l;       ASSERT_SECURITY_ROOT("_assembler_debug");    -  get_all_args("_assembler_debug", args, "%i", &l); +  get_all_args("_assembler_debug", args, "%+", &l);    pop_n_elems(args);    push_int(a_flag);    a_flag = l;   }    - /*! @decl void dump_program_tables(program p, int|void indent) + /*! @decl void dump_program_tables(program p, int(0..)|void indent)    *! @belongs Debug    *!    *! Dumps the internal tables for the program @[p] on stderr.    *!    *! @param p    *! Program to dump.    *!    *! @param indent    *! Number of spaces to indent the output.    *!    *! @note    *! In Pike 7.8.308 and earlier @[indent] wasn't supported.    */   void f__dump_program_tables(INT32 args)   {    struct program *p;    int indent = 0;       ASSERT_SECURITY_ROOT("_dump_program_tables"); /* FIXME: Might want lower. */ -  get_all_args("_dump_program_tables", args, "%p.%d", &p, &indent); +  get_all_args("_dump_program_tables", args, "%p.%+", &p, &indent);       dump_program_tables(p, indent);    pop_n_elems(args);   }      #ifdef YYDEBUG    - /*! @decl int compiler_trace(int(0..) level) + /*! @decl int(0..) compiler_trace(int(0..) level)    *! @belongs Debug    *!    *! Set the compiler trace level.    *!    *! @returns    *! The old compiler trace level will be returned.    *!    *! @note    *! This function is only available if the Pike runtime has been compiled    *! with RTL debug.
pike.git/src/builtin_functions.c:6308:       /* Initialize the min array */    for (i = 0; i < arr->size; i++) {    struct mapping_data *md;    /* e and k are used by NEW_MAPPING_LOOP() */    INT32 e;    struct keypair *k;    INT_TYPE low = MAX_INT_TYPE;   #ifdef PIKE_DEBUG    if (TYPEOF(ITEM(arr)[i]) != T_MAPPING) { -  Pike_error("interleave_array(): Element %d is not a mapping!\n", i); +  Pike_error("Element %d is not a mapping!\n", i);    }   #endif /* PIKE_DEBUG */    md = ITEM(arr)[i].u.mapping->data;    NEW_MAPPING_LOOP(md) {    if (TYPEOF(k->ind) != T_INT) { -  Pike_error("interleave_array(): Index not an integer in mapping %d!\n", i); +  Pike_error("Index not an integer in mapping %d!\n", i);    }    if (low > k->ind.u.integer) {    low = k->ind.u.integer;    if (low < 0) { -  Pike_error("interleave_array(): Index %"PRINTPIKEINT"d in mapping %d is negative!\n", +  Pike_error("Index %"PRINTPIKEINT"d in mapping %d is negative!\n",    low, i);    }    }    if (max < k->ind.u.integer) {    max = k->ind.u.integer;    }    nelems++;    }    ITEM(min)[i].u.integer = low;    }
pike.git/src/builtin_functions.c:6405:    while(tab[minfree]) {    minfree++;    }    ITEM(min)[i].u.integer = offset;       /* Check need for realloc */    if (offset >= size) {    char *newtab = realloc(tab, size*2 + max);    if (!newtab) {    free(tab); -  Pike_error("interleave_array(): Couldn't extend table!\n"); +  Pike_error("Couldn't extend table!\n");    }    tab = newtab;    MEMSET(tab + size + max, 0, size);    size = size * 2;    }    }    free(tab);    }       /* We want these two to survive the stackpopping. */
pike.git/src/builtin_functions.c:8443: Inside #if defined(DEBUG_MALLOC)
   *! @note    *! Only available when compiled with dmalloc.    */   PMOD_EXPORT void f__reset_dmalloc(INT32 args)   {    ASSERT_SECURITY_ROOT("_reset_dmalloc");    pop_n_elems(args);    reset_debug_malloc();   }    - /*! @decl void dmalloc_set_name(string filename, int linenumber) + /*! @decl void dmalloc_set_name(string filename, int(1..) linenumber)    *! @belongs Debug    *!    *! @note    *! Only available when compiled with dmalloc.    */   PMOD_EXPORT void f__dmalloc_set_name(INT32 args)   {    char *s;    INT_TYPE i;    extern char * dynamic_location(const char *file, INT_TYPE line);    extern char * dmalloc_default_location;       if(args)    { -  get_all_args("_dmalloc_set_name", args, "%s%i", &s, &i); +  get_all_args("_dmalloc_set_name", args, "%s%+", &s, &i);    dmalloc_default_location = dynamic_location(s, i);    }else{    dmalloc_default_location=0;    }    pop_n_elems(args);   }      /*! @decl void list_open_fds()    *! @belongs Debug    *!
pike.git/src/builtin_functions.c:8740:       mysp=Pike_sp+3-args;       push_svalue(mysp-3);    push_constant_text("cast");    f_arrow(2);    if (!UNSAFE_IS_ZERO(Pike_sp-1))    {    pop_stack();    -  push_constant_text("array"); +  ref_push_string(literal_array_string);    /* FIXME: Object subtype! */    safe_apply(mysp[-3].u.object,"cast",1);    if (TYPEOF(Pike_sp[-1]) == T_ARRAY)    {    free_svalue(mysp-3);    mysp[-3]=*(--Pike_sp);    dmalloc_touch_svalue(Pike_sp);    f_map(args);    return;    }    pop_stack();    -  push_constant_text("mapping"); +  ref_push_string(literal_mapping_string);    /* FIXME: Object subtype! */    safe_apply(mysp[-3].u.object,"cast",1);    if (TYPEOF(Pike_sp[-1]) == T_MAPPING)    {    free_svalue(mysp-3);    mysp[-3]=*(--Pike_sp);    dmalloc_touch_svalue(Pike_sp);    f_map(args);    return;    }    pop_stack();    -  push_constant_text("multiset"); +  ref_push_string(literal_multiset_string);    /* FIXME: Object subtype! */    safe_apply(mysp[-3].u.object,"cast",1);    if (TYPEOF(Pike_sp[-1]) == T_MULTISET)    {    free_svalue(mysp-3);    mysp[-3]=*(--Pike_sp);    dmalloc_touch_svalue(Pike_sp);    f_map(args);    return;    }
pike.git/src/builtin_functions.c:9171:    case T_OBJECT:    mysp=Pike_sp+3-args;       push_svalue(mysp-3);    push_constant_text("cast");    f_arrow(2);    if (!UNSAFE_IS_ZERO(Pike_sp-1))    {    pop_stack();    -  push_constant_text("array"); +  ref_push_string(literal_array_string);    /* FIXME: Object subtype! */    safe_apply(mysp[-3].u.object,"cast",1);    if (TYPEOF(Pike_sp[-1]) == T_ARRAY)    {    free_svalue(mysp-3);    mysp[-3]=*(--Pike_sp);    dmalloc_touch_svalue(Pike_sp);    f_filter(args);    return;    }    pop_stack();    -  push_constant_text("mapping"); +  ref_push_string(literal_mapping_string);    /* FIXME: Object subtype! */    safe_apply(mysp[-3].u.object,"cast",1);    if (TYPEOF(Pike_sp[-1]) == T_MAPPING)    {    free_svalue(mysp-3);    mysp[-3]=*(--Pike_sp);    dmalloc_touch_svalue(Pike_sp);    f_filter(args);    return;    }    pop_stack();    -  push_constant_text("multiset"); +  ref_push_string(literal_multiset_string);    /* FIXME: Object subtype! */    safe_apply(mysp[-3].u.object,"cast",1);    if (TYPEOF(Pike_sp[-1]) == T_MULTISET)    {    free_svalue(mysp-3);    mysp[-3]=*(--Pike_sp);    dmalloc_touch_svalue(Pike_sp);    f_filter(args);    return;    }
pike.git/src/builtin_functions.c:9312:    push_int(0);    args++;    }       if (args<=3 &&    (TYPEOF(Pike_sp[1-args]) == T_INT &&    TYPEOF(Pike_sp[2-args]) == T_INT))    {    INT_TYPE step,start;    -  get_all_args("enumerate", args, "%i%i%i", &n, &step, &start); -  if (n<0) -  SIMPLE_BAD_ARG_ERROR("enumerate",1,"int(0..)"); -  +  get_all_args("enumerate", args, "%+%i%i", &n, &step, &start);    pop_n_elems(args);    push_array(d=allocate_array(n));    for (i=0; i<n; i++)    {    ITEM(d)[i].u.integer=start;    if ((step>0 && start+step<start) ||    (step<0 && start+step>start)) /* overflow */    {    pop_stack();    push_int(n);
pike.git/src/builtin_functions.c:9345:    d->type_field = BIT_INT;    }    else if (args<=3 &&    ((TYPEOF(Pike_sp[1-args]) == T_INT ||    TYPEOF(Pike_sp[1-args]) == T_FLOAT) &&    (TYPEOF(Pike_sp[2-args]) == T_INT ||    TYPEOF(Pike_sp[2-args]) == T_FLOAT) ) )    {    FLOAT_TYPE step, start;    -  get_all_args("enumerate", args, "%i%F%F", &n, &step, &start); -  if (n<0) -  SIMPLE_BAD_ARG_ERROR("enumerate",1,"int(0..)"); -  +  get_all_args("enumerate", args, "%+%F%F", &n, &step, &start);    pop_n_elems(args); -  +     push_array(d=allocate_array(n));    for (i=0; i<n; i++)    {    SET_SVAL(d->item[i], T_FLOAT, 0, float_number, start);    start+=step;    }    d->type_field = BIT_FLOAT;    }    else    {    TYPE_FIELD types = 0; -  get_all_args("enumerate", args, "%i", &n); -  if (n<0) SIMPLE_BAD_ARG_ERROR("enumerate",1,"int(0..)"); +  get_all_args("enumerate", args, "%+", &n);    if (args>4) pop_n_elems(args-4);    push_array(d=allocate_array(n));    if (args<4)    {    push_svalue(Pike_sp-2); /* start */    for (i=0; i<n; i++)    {    assign_svalue_no_free(ITEM(d)+i,Pike_sp-1);    types |= 1 << TYPEOF(ITEM(d)[i]);    if (i<n-1)
pike.git/src/builtin_functions.c:9815:       ADD_EFUN2("indices",f_indices,    tOr3(tFunc(tArray,tArr(tIntPos)),    tFunc(tOr3(tMap(tSetvar(1,tMix),tMix),    tSet(tSetvar(1,tMix)),    tNStr(tSetvar(1,tInt))),    tArr(tVar(1))),    tFunc(tOr(tObj,tPrg(tObj)),tArr(tStr))),    OPT_TRY_OPTIMIZE,fix_indices_type,0);    -  ADD_EFUN("undefinedp", f_undefinedp, tFunc(tMix,tInt01), OPT_TRY_OPTIMIZE); -  ADD_EFUN("destructedp", f_destructedp, tFunc(tMix,tInt01), OPT_TRY_OPTIMIZE); +  ADD_EFUN2("undefinedp", f_undefinedp, tFunc(tMix,tInt01), OPT_TRY_OPTIMIZE, 0, generate_undefinedp); +  ADD_EFUN2("destructedp", f_destructedp, tFunc(tMix,tInt01), OPT_TRY_OPTIMIZE,0, generate_destructedp);      /* function(mixed:int) */    ADD_EFUN("intp", f_intp,tFunc(tMix,tInt01),OPT_TRY_OPTIMIZE);      /* function(mixed:int) */    ADD_EFUN("multisetp", f_multisetp,tFunc(tMix,tInt01),OPT_TRY_OPTIMIZE);      /* function(string:string)|function(int:int) */    ADD_EFUN("lower_case",f_lower_case,    tOr(tFunc(tStr,tStr), tFunc(tInt,tInt)),OPT_TRY_OPTIMIZE);
pike.git/src/builtin_functions.c:10098:   #endif      /* function(:void) */    ADD_EFUN("_verify_internals",f__verify_internals,    tFunc(tNone,tVoid),OPT_SIDE_EFFECT|OPT_EXTERNAL_DEPEND);      #ifdef PIKE_DEBUG      /* function(int:int) */    ADD_EFUN("_debug",f__debug, -  tFunc(tInt,tInt),OPT_SIDE_EFFECT|OPT_EXTERNAL_DEPEND); +  tFunc(tIntPos,tIntPos),OPT_SIDE_EFFECT|OPT_EXTERNAL_DEPEND);      /* function(int:int) */    ADD_EFUN("_optimizer_debug",f__optimizer_debug, -  tFunc(tInt,tInt),OPT_SIDE_EFFECT|OPT_EXTERNAL_DEPEND); +  tFunc(tIntPos,tIntPos),OPT_SIDE_EFFECT|OPT_EXTERNAL_DEPEND);      /* function(int:int) */    ADD_EFUN("_assembler_debug",f__assembler_debug, -  tFunc(tInt,tInt), OPT_SIDE_EFFECT|OPT_EXTERNAL_DEPEND); +  tFunc(tInt,tIntPos), OPT_SIDE_EFFECT|OPT_EXTERNAL_DEPEND);       ADD_EFUN("_dump_program_tables", f__dump_program_tables, -  tFunc(tPrg(tObj),tVoid), OPT_SIDE_EFFECT|OPT_EXTERNAL_DEPEND); +  tFunc(tPrg(tObj) tIntPos,tVoid), OPT_SIDE_EFFECT|OPT_EXTERNAL_DEPEND);      #ifdef YYDEBUG      /* function(int:int) */    ADD_EFUN("_compiler_trace",f__compiler_trace, -  tFunc(tInt,tInt),OPT_SIDE_EFFECT|OPT_EXTERNAL_DEPEND); +  tFunc(tIntPos,tIntPos),OPT_SIDE_EFFECT|OPT_EXTERNAL_DEPEND);   #endif /* YYDEBUG */   #endif      /* function(:mapping(string:int)) */    ADD_EFUN("_memory_usage",f__memory_usage,    tFunc(tNone,tMap(tStr,tInt)),OPT_EXTERNAL_DEPEND);       ADD_EFUN("_size_object",f__size_object,    tFunc(tObj,tInt),OPT_EXTERNAL_DEPEND);   
pike.git/src/builtin_functions.c:10282:    tFunc(tOr(tObj,tPrg(tObj)) tString,tString), 0, OPT_TRY_OPTIMIZE);    ADD_FUNCTION2("function_defined", f_function_defined,    tFunc(tFunction,tString), 0, OPT_TRY_OPTIMIZE);      #ifdef DEBUG_MALLOC      /* function(void:void) */    ADD_EFUN("_reset_dmalloc",f__reset_dmalloc,    tFunc(tVoid,tVoid),OPT_SIDE_EFFECT);    ADD_EFUN("_dmalloc_set_name",f__dmalloc_set_name, -  tOr(tFunc(tStr tInt,tVoid), tFunc(tVoid,tVoid)),OPT_SIDE_EFFECT); +  tOr(tFunc(tStr tIntPos,tVoid), tFunc(tVoid,tVoid)),OPT_SIDE_EFFECT);    ADD_EFUN("_list_open_fds",f__list_open_fds,    tFunc(tVoid,tVoid),OPT_SIDE_EFFECT);    ADD_EFUN("_dump_dmalloc_locations",f__dump_dmalloc_locations,    tFunc(tSetvar(1,tMix),tVar(1)),OPT_SIDE_EFFECT);   #endif   #ifdef PIKE_DEBUG      /* function(1=mixed:1) */    ADD_EFUN("_locate_references",f__locate_references,    tFunc(tSetvar(1,tMix),tVar(1)),OPT_SIDE_EFFECT);