pike.git / src / builtin_functions.c

version» Context lines:

pike.git/src/builtin_functions.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: builtin_functions.c,v 1.482 2003/04/02 19:16:03 nilsson Exp $ + || $Id: builtin_functions.c,v 1.483 2003/04/07 17:28:55 nilsson Exp $   */      #include "global.h" - RCSID("$Id: builtin_functions.c,v 1.482 2003/04/02 19:16:03 nilsson Exp $"); + RCSID("$Id: builtin_functions.c,v 1.483 2003/04/07 17:28:55 nilsson Exp $");   #include "interpret.h"   #include "svalue.h"   #include "pike_macros.h"   #include "object.h"   #include "program.h"   #include "array.h"   #include "pike_error.h"   #include "constants.h"   #include "mapping.h"   #include "stralloc.h"
pike.git/src/builtin_functions.c:112:   #endif       a=aggregate_array(args);    push_array(a); /* beware, macro */   }         /*! @decl int hash_7_4(string s)    *! @decl int hash_7_4(string s, int max)    *! -  *! This function will return an @tt{int@} derived from the string @[s]. +  *! This function will return an @expr{int@} derived from the string @[s].    *! The same string will always hash to the same value.    *! If @[max] is given, the result will be >= 0 and < @[max], otherwise    *! the result will be >= 0 and <= 0x7fffffff.    *!    *! @note    *! This function is provided for backward compatibility reasons.    *!    *! This function is byte-order dependant.    *!    *! @seealso
pike.git/src/builtin_functions.c:156:       i%=(unsigned INT32)Pike_sp[1-args].u.integer;    }    pop_n_elems(args);    push_int64(i);   }      /*! @decl int hash_7_0(string s)    *! @decl int hash_7_0(string s, int max)    *! -  *! This function will return an @tt{int@} derived from the string @[s]. +  *! This function will return an @expr{int@} derived from the string @[s].    *! The same string will always hash to the same value.    *! If @[max] is given, the result will be >= 0 and < @[max], otherwise    *! the result will be >= 0 and <= 0x7fffffff.    *!    *! @note    *! This function is provided for backward compatibility reasons.    *!    *! This function is not NUL-safe, and is byte-order dependant.    *!    *! @seealso
pike.git/src/builtin_functions.c:203:       i%=(unsigned INT32)Pike_sp[1-args].u.integer;    }    pop_n_elems(args);    push_int( i );   }      /*! @decl int hash(string s)    *! @decl int hash(string s, int max)    *! -  *! This function will return an @tt{int@} derived from the string @[s]. +  *! This function will return an @expr{int@} derived from the string @[s].    *! The same string will always hash to the same value.    *! If @[max] is given, the result will be >= 0 and < @[max], otherwise    *! the result will be >= 0 and <= 0x7fffffff.    *!    *! @note    *! The hash algorithm was changed in Pike 7.5. If you want a hash    *! that is compatible with Pike 7.4 and earlier, use @[hash_7_4()].    *!    *! The hash algorithm was also changed in Pike 7.1. If you want a hash    *! that is compatible with Pike 7.0 and earlier, use @[hash_7_0()].
pike.git/src/builtin_functions.c:603:   {    pop_n_elems(args);    push_int(Pike_fp ? Pike_fp->args : 0);   }      /*! @decl int search(string haystack, string|int needle, int|void start)    *! @decl int search(array haystack, mixed needle, int|void start)    *! @decl mixed search(mapping haystack, mixed needle, mixed|void start)    *!    *! Search for @[needle] in @[haystack]. Return the position of @[needle] in -  *! @[haystack] or @tt{-1@} if not found. +  *! @[haystack] or @expr{-1@} if not found.    *!    *! If the optional argument @[start] is present search is started at    *! this position.    *!    *! When @[haystack] is a string @[needle] must be a string or an int,    *! and the first occurrence of the string or int is returned.    *!    *! When @[haystack] is an array, @[needle] is compared only to one value at    *! a time in @[haystack].    *!
pike.git/src/builtin_functions.c:752:    pop_n_elems(args-1);    return;       default:    SIMPLE_BAD_ARG_ERROR("search", 1, "string|array|mapping");    }   }      /*! @decl int has_prefix(string s, string prefix)    *! -  *! Returns @tt{1@} if the string @[s] starts with @[prefix], -  *! returns @tt{0@} (zero) otherwise. +  *! Returns @expr{1@} if the string @[s] starts with @[prefix], +  *! returns @expr{0@} (zero) otherwise.    */   PMOD_EXPORT void f_has_prefix(INT32 args)   {    struct pike_string *a, *b;       get_all_args("has_prefix", args, "%W%W", &a, &b);       /* First handle some common special cases. */    if ((b->len > a->len) || (b->size_shift > a->size_shift)) {    pop_n_elems(args);
pike.git/src/builtin_functions.c:813:    Pike_error("has_prefix(): 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 @tt{1@} if the string @[s] ends with @[suffix], -  *! returns @tt{0@} (zero) otherwise. +  *! Returns @expr{1@} if the string @[s] ends with @[suffix], +  *! returns @expr{0@} (zero) otherwise.    */   PMOD_EXPORT void f_has_suffix(INT32 args)   {    struct pike_string *a, *b;       get_all_args("has_suffix", args, "%W%W", &a, &b);       /* First handle some common special cases. */    if ((b->len > a->len) || (b->size_shift > a->size_shift)) {    pop_n_elems(args);
pike.git/src/builtin_functions.c:880:   #undef TWO_SHIFTS   }      /*! @decl int has_index(string haystack, int index)    *! @decl int has_index(array haystack, int index)    *! @decl int has_index(mapping haystack, mixed index)    *!    *! Search for @[index] in @[haystack].    *!    *! @returns -  *! Returns @tt{1@} if @[index] is in the index domain of @[haystack], -  *! or @tt{0@} (zero) if not found. +  *! Returns @expr{1@} if @[index] is in the index domain of @[haystack], +  *! or @expr{0@} (zero) if not found.    *!    *! This function is equivalent to (but sometimes faster than):    *!    *! @code    *! search(indices(haystack), index) != -1    *! @endcode    *!    *! @note    *! A negative index in strings and arrays as recognized by the -  *! index operators @tt{`[]()@} and @tt{`[]=()@} is not considered +  *! index operators @expr{`[]()@} and @expr{`[]=()@} is not considered    *! a proper index by @[has_index()]    *!    *! @seealso    *! @[has_value()], @[indices()], @[search()], @[values()], @[zero_type()]    */   PMOD_EXPORT void f_has_index(INT32 args)   {    int t = 0;       if(args < 2)
pike.git/src/builtin_functions.c:970:   }      /*! @decl int has_value(string haystack, string value)    *! @decl int has_value(string haystack, int value)    *! @decl int has_value(array haystack, int value)    *! @decl int has_value(mapping haystack, mixed value)    *!    *! Search for @[value] in @[haystack].    *!    *! @returns -  *! Returns @tt{1@} if @[value] is in the value domain of @[haystack], -  *! or @tt{0@} (zero) if not found. +  *! Returns @expr{1@} if @[value] is in the value domain of @[haystack], +  *! or @expr{0@} (zero) if not found.    *!    *! This function is in all cases except when both arguments are strings    *! equivalent to (but sometimes faster than):    *!    *! @code    *! search(values(@[haystack]), @[value]) != -1    *! @endcode    *!    *! If both arguments are strings, @[has_value()] is equivalent to:    *!
pike.git/src/builtin_functions.c:1081:    low_add_efun(Pike_sp[-args].u.string, 0);    }    pop_n_elems(args);   }      /*! @decl string combine_path(string absolute, string ... relative)    *! @decl string combine_path_unix(string absolute, string ... relative)    *! @decl string combine_path_nt(string absolute, string ... relative)    *!    *! Concatenate a relative path to an absolute path and remove any -  *! @tt{"//"@}, @tt{"/.."@} or @tt{"/."@} to produce a straightforward -  *! absolute path as result. +  *! @expr{"//"@}, @expr{"/.."@} or @expr{"/."@} to produce a +  *! straightforward absolute path as result.    *!    *! @[combine_path_nt()] concatenates according to NT-filesystem conventions,    *! while @[combine_path_unix()] concatenates according to UNIX-style.    *!    *! @[combine_path()] is equvivalent to @[combine_path_unix()] on UNIX-like    *! operating systems, and equvivalent to @[combine_path_nt()] on NT-like    *! operating systems.    *!    *! @seealso    *! @[getcwd()], @[Stdio.append_path()]
pike.git/src/builtin_functions.c:1114:    *!    *! Return the type of zero.    *!    *! There are many types of zeros out there, or at least there are two.    *! One is returned by normal functions, and one returned by mapping    *! lookups and @[find_call_out()] when what you looked for wasn't there.    *! The only way to separate these two kinds of zeros is @[zero_type()].    *!    *! @returns    *! When doing a @[find_call_out()] or mapping lookup, @[zero_type()] on -  *! this value will return @tt{1@} if there was no such thing present in +  *! this value will return @expr{1@} if there was no such thing present in    *! the mapping, or if no such @tt{call_out@} could be found.    *!    *! If the argument to @[zero_type()] is a destructed object or a function -  *! in a destructed object, @tt{2@} will be returned. +  *! in a destructed object, @expr{2@} will be returned.    *! -  *! In all other cases @[zero_type()] will return @tt{0@} (zero). +  *! In all other cases @[zero_type()] will return @expr{0@} (zero).    *!    *! @seealso    *! @[find_call_out()]    */   PMOD_EXPORT void f_zero_type(INT32 args)   {    if(args < 1)    SIMPLE_TOO_FEW_ARGS_ERROR("zero_type",1);       if((Pike_sp[-args].type==T_OBJECT || Pike_sp[-args].type==T_FUNCTION)
pike.git/src/builtin_functions.c:1602:      /*! @decl string utf8_to_string(string s)    *! @decl string utf8_to_string(string s, int extended)    *!    *! Converts an UTF8 byte-stream into a string.    *!    *! @note    *! Throws an error if the stream is not a legal UFT8 byte-stream.    *!    *! Accepts and decodes the extension used by @[string_to_utf8()], if -  *! @[extended] is @tt{1@}. +  *! @[extended] is @expr{1@}.    *!    *! @seealso    *! @[Locale.Charset.encoder()], @[string_to_unicode()], @[string_to_utf8()],    *! @[unicode_to_string()]    */   PMOD_EXPORT void f_utf8_to_string(INT32 args)   {    struct pike_string *in;    struct pike_string *out;    int len = 0;
pike.git/src/builtin_functions.c:1955:    assign_svalue(&throw_value,Pike_sp-args);    pop_n_elems(args);    throw_severity=0;    pike_throw();   }      /*! @decl void exit(int returncode)    *!    *! Exit the whole Pike program with the given @[returncode].    *! -  *! Using @[exit()] with any other value than @tt{0@} (zero) indicates that -  *! something went wrong during execution. See your system manuals for -  *! more information about return codes. +  *! Using @[exit()] with any other value than @expr{0@} (zero) indicates +  *! that something went wrong during execution. See your system manuals +  *! for more information about return codes.    *!    *! @seealso    *! @[_exit()]    */   PMOD_EXPORT void f_exit(INT32 args)   {    static int in_exit=0;    CHECK_SECURITY_OR_ERROR(SECURITY_BIT_SECURITY, ("exit: permission denied.\n"));    if(args < 1)    SIMPLE_TOO_FEW_ARGS_ERROR("exit", 1);
pike.git/src/builtin_functions.c:2018:       exit(Pike_sp[-args].u.integer);   }      /*! @decl int time();    *! @decl int time(int(1..1) one)    *! @decl float time(int(2..) t)    *!    *! This function returns the number of seconds since 1 Jan 1970.    *! -  *! The second syntax does not call the system call @tt{time()@} as often, +  *! The second syntax does not call the system call @[time()] as often,    *! but is only updated in the backed (when Pike code isn't running).    *!    *! The third syntax can be used to measure time more preciely than one    *! second. It return how many seconds has passed since @[t]. The precision    *! of this function varies from system to system.    *!    *! @seealso    *! @[ctime()], @[localtime()], @[mktime()], @[gmtime()],    *! @[System.gettimeofday], @[gethrtime]    */
pike.git/src/builtin_functions.c:2061:   /*! @decl string crypt(string password)    *! @decl int(0..1) crypt(string typed_password, string crypted_password)    *!    *! This function crypts and verifies a short string (only the first    *! 8 characters are significant).    *!    *! The first syntax crypts the string @[password] into something that    *! is hopefully hard to decrypt.    *!    *! The second syntax is used to verify @[typed_password] against -  *! @[crypted_password], and returns @tt{1@} if they match, and @tt{0@} -  *! (zero) otherwise. +  *! @[crypted_password], and returns @expr{1@} if they match, and +  *! @expr{0@} (zero) otherwise.    */   PMOD_EXPORT void f_crypt(INT32 args)   {    char salt[2];    char *ret, *saltp;    char *choise =    "cbhisjKlm4k65p7qrJfLMNQOPxwzyAaBDFgnoWXYCZ0123tvdHueEGISRTUV89./";       if(args < 1)    SIMPLE_TOO_FEW_ARGS_ERROR("crypt", 1);
pike.git/src/builtin_functions.c:2122:    i=!strcmp(ret,Pike_sp[1-args].u.string->str);    pop_n_elems(args);    push_int(i);    }   }      /*! @decl void destruct(object o)    *!    *! Mark an object as destructed.    *! -  *! Calls @tt{o->destroy()@}, and then clears all variables in the object. +  *! Calls @expr{o->destroy()@}, and then clears all variables in the object.    *!    *! All pointers and function pointers to this object will become zero.    *! The destructed object will be freed from memory as soon as possible.    */   PMOD_EXPORT void f_destruct(INT32 args)   {    struct object *o;    if(args)    {    if(Pike_sp[-args].type != T_OBJECT) {
pike.git/src/builtin_functions.c:2466:    return NULL;   }      /*! @decl array values(string|array|mapping|multiset|object x)    *!    *! Return an array of all possible values from indexing the value @[x].    *!    *! For strings an array of int with the ISO10646 codes of the characters in    *! the string is returned.    *! -  *! For a multiset an array filled with ones (@tt{1@}) is returned. +  *! For a multiset an array filled with ones (@expr{1@}) is returned.    *!    *! For arrays a single-level copy of @[x] is returned.    *!    *! For mappings the array may contain any value.    *!    *! For objects which define @[lfun::_values()] that return value will be used.    *!    *! For other objects an array with the values of all non-static symbols    *! will be returned.    *!
pike.git/src/builtin_functions.c:2599:    push_int(0);    }else{    ref_push_object(o);    }   }      /*! @decl program object_program(mixed o)    *!    *! Return the program from which @[o] was instantiated.    *! -  *! If @[o] is not an object or has been destructed @tt{0@} (zero) +  *! If @[o] is not an object or has been destructed @expr{0@} (zero)    *! will be returned.    */   PMOD_EXPORT void f_object_program(INT32 args)   {    if(args < 1)    SIMPLE_TOO_FEW_ARGS_ERROR("object_program", 1);       if(Pike_sp[-args].type == T_OBJECT)    {    struct object *o=Pike_sp[-args].u.object;
pike.git/src/builtin_functions.c:3207:    pop_n_elems(args);    push_program(p);   }         /*! @decl array|mapping|multiset set_weak_flag(array|mapping|multiset m, @    *! int state)    *!    *! Set the value @[m] to use weak or normal references in its    *! indices and/or values (whatever is applicable). @[state] is a -  *! bitfield built by using @tt{|@} between the following flags: +  *! bitfield built by using @expr{|@} between the following flags:    *!    *! @int    *! @value Pike.WEAK_INDICES    *! Use weak references for indices. Only applicable for    *! multisets and mappings.    *! @value Pike.WEAK_VALUES    *! Use weak references for values. Only applicable for arrays    *! and mappings.    *! @value Pike.WEAK -  *! Shorthand for @tt{Pike.WEAK_INDICES|Pike.WEAK_VALUES@}. +  *! Shorthand for @expr{Pike.WEAK_INDICES|Pike.WEAK_VALUES@}.    *! @endint    *!    *! If a flag is absent, the corresponding field will use normal -  *! references. @[state] can also be @tt{1@} as a compatibility +  *! references. @[state] can also be @expr{1@} as a compatibility    *! measure; it's treated like @[Pike.WEAK].    *!    *! @returns    *! @[m] will be returned.    */   #define SETFLAG(FLAGS,FLAG,ONOFF) \    FLAGS = (FLAGS & ~FLAG) | ( ONOFF ? FLAG : 0 )   void f_set_weak_flag(INT32 args)   {    struct svalue *s;
pike.git/src/builtin_functions.c:3270:   #endif    break;    default:    SIMPLE_BAD_ARG_ERROR("set_weak_flag",1,"array|mapping|multiset");    }    pop_n_elems(args-1);   }      /*! @decl int objectp(mixed arg)    *! -  *! Returns @tt{1@} if @[arg] is an object, @tt{0@} (zero) otherwise. +  *! Returns @expr{1@} if @[arg] is an object, @expr{0@} (zero) otherwise.    *!    *! @seealso    *! @[mappingp()], @[programp()], @[arrayp()], @[stringp()], @[functionp()],    *! @[multisetp()], @[floatp()], @[intp()]    */   PMOD_EXPORT void f_objectp(INT32 args)   {    if(args<1)    SIMPLE_TOO_FEW_ARGS_ERROR("objectp", 1);    if(Pike_sp[-args].type != T_OBJECT || !Pike_sp[-args].u.object->prog
pike.git/src/builtin_functions.c:3296:    pop_n_elems(args);    push_int(0);    }else{    pop_n_elems(args);    push_int(1);    }   }      /*! @decl int functionp(mixed arg)    *! -  *! Returns @tt{1@} if @[arg] is a function, @tt{0@} (zero) otherwise. +  *! Returns @expr{1@} if @[arg] is a function, @expr{0@} (zero) otherwise.    *!    *! @seealso    *! @[mappingp()], @[programp()], @[arrayp()], @[stringp()], @[objectp()],    *! @[multisetp()], @[floatp()], @[intp()]    */   PMOD_EXPORT void f_functionp(INT32 args)   {    int res = 0;    if(args<1)    SIMPLE_TOO_FEW_ARGS_ERROR("functionp", 1);    if( Pike_sp[-args].type == T_FUNCTION &&    (Pike_sp[-args].subtype == FUNCTION_BUILTIN || Pike_sp[-args].u.object->prog))    res=1;    pop_n_elems(args);    push_int(res);   }      /*! @decl int callablep(mixed arg)    *! -  *! Returns @tt{1@} if @[arg] is a callable, @tt{0@} (zero) otherwise. +  *! Returns @expr{1@} if @[arg] is a callable, @expr{0@} (zero) otherwise.    *!    *! @seealso    *! @[mappingp()], @[programp()], @[arrayp()], @[stringp()], @[objectp()],    *! @[multisetp()], @[floatp()], @[intp()]    */   PMOD_EXPORT void f_callablep(INT32 args)   {    int res = 0;    if(args<1)    SIMPLE_TOO_FEW_ARGS_ERROR("callablep", 1);
pike.git/src/builtin_functions.c:3634:    } \    } \    t=Pike_sp[-args].type == TYPE; \    pop_n_elems(args); \    push_int(t); \   }         /*! @decl int programp(mixed arg)    *! -  *! Returns @tt{1@} if @[arg] is a program, @tt{0@} (zero) otherwise. +  *! Returns @expr{1@} if @[arg] is a program, @expr{0@} (zero) otherwise.    *!    *! @seealso    *! @[mappingp()], @[intp()], @[arrayp()], @[stringp()], @[objectp()],    *! @[multisetp()], @[floatp()], @[functionp()]    */   PMOD_EXPORT void f_programp(INT32 args)   {    if(args<1)    SIMPLE_TOO_FEW_ARGS_ERROR("programp", 1);    switch(Pike_sp[-args].type)
pike.git/src/builtin_functions.c:3667:    }       default:    pop_n_elems(args);    push_int(0);    }   }      /*! @decl int intp(mixed arg)    *! -  *! Returns @tt{1@} if @[arg] is an int, @tt{0@} (zero) otherwise. +  *! Returns @expr{1@} if @[arg] is an int, @expr{0@} (zero) otherwise.    *!    *! @seealso    *! @[mappingp()], @[programp()], @[arrayp()], @[stringp()], @[objectp()],    *! @[multisetp()], @[floatp()], @[functionp()]    */      /*! @decl int mappingp(mixed arg)    *! -  *! Returns @tt{1@} if @[arg] is a mapping, @tt{0@} (zero) otherwise. +  *! Returns @expr{1@} if @[arg] is a mapping, @expr{0@} (zero) otherwise.    *!    *! @seealso    *! @[intp()], @[programp()], @[arrayp()], @[stringp()], @[objectp()],    *! @[multisetp()], @[floatp()], @[functionp()]    */      /*! @decl int arrayp(mixed arg)    *! -  *! Returns @tt{1@} if @[arg] is an array, @tt{0@} (zero) otherwise. +  *! Returns @expr{1@} if @[arg] is an array, @expr{0@} (zero) otherwise.    *!    *! @seealso    *! @[intp()], @[programp()], @[mappingp()], @[stringp()], @[objectp()],    *! @[multisetp()], @[floatp()], @[functionp()]    */      /*! @decl int multisetp(mixed arg)    *! -  *! Returns @tt{1@} if @[arg] is a multiset, @tt{0@} (zero) otherwise. +  *! Returns @expr{1@} if @[arg] is a multiset, @expr{0@} (zero) otherwise.    *!    *! @seealso    *! @[intp()], @[programp()], @[arrayp()], @[stringp()], @[objectp()],    *! @[mappingp()], @[floatp()], @[functionp()]    */      /*! @decl int stringp(mixed arg)    *! -  *! Returns @tt{1@} if @[arg] is a string, @tt{0@} (zero) otherwise. +  *! Returns @expr{1@} if @[arg] is a string, @expr{0@} (zero) otherwise.    *!    *! @seealso    *! @[intp()], @[programp()], @[arrayp()], @[multisetp()], @[objectp()],    *! @[mappingp()], @[floatp()], @[functionp()]    */      /*! @decl int floatp(mixed arg)    *! -  *! Returns @tt{1@} if @[arg] is a float, @tt{0@} (zero) otherwise. +  *! 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")
pike.git/src/builtin_functions.c:4062: Inside #if defined(HAVE_LOCALTIME)
   *! Is daylight savings time.    *! @member int "timezone"    *! Offset from UTC.    *! @endmapping    *!    *! An error is thrown if the localtime(2) call failed on the system.    *! It's platform dependent what time ranges that function can handle,    *! e.g. Windows doesn't handle a negative @[timestamp].    *!    *! @note -  *! The field @tt{"timezone"@} may not be available on all platforms. +  *! The field @expr{"timezone"@} may not be available on all platforms.    *!    *! @seealso    *! @[Calendar], @[gmtime()], @[time()], @[ctime()], @[mktime()]    */   PMOD_EXPORT void f_localtime(INT32 args)   {    struct tm *tm;    INT_TYPE tt;    time_t t;   
pike.git/src/builtin_functions.c:4436:      /*! @decl int(0..1) glob(string glob, string str)    *! @decl array(string) glob(string glob, array(string) arr)    *!    *! Match strings against globs.    *!    *! In a glob string a question sign matches any character and    *! an asterisk matches any string.    *!    *! When the second argument is a string and @[str] matches -  *! the glob @[glob] @tt{1@} will be returned, @tt{0@} (zero) otherwise. +  *! the glob @[glob] @expr{1@} will be returned, @expr{0@} (zero) otherwise.    *!    *! If the second array is an array and array containing the strings in    *! @[arr] that match @[glob] will be returned.    *!    *! @seealso    *! @[sscanf()], @[Regexp]    */   PMOD_EXPORT void f_glob(INT32 args)   {    INT32 i,matches;
pike.git/src/builtin_functions.c:6200: Inside #if defined(PROFILING)
   stack_swap();    pop_stack();   }   #endif /* PROFILING */      /*! @decl int(0..1) object_variablep(object o, string var)    *!    *! Find out if an object identifier is a variable.    *!    *! @returns -  *! This function returns @tt{1@} if @[var] exists as a non-static variable -  *! in @[o], and returns @tt{0@} (zero) otherwise. +  *! This function returns @expr{1@} if @[var] exists as a non-static variable +  *! in @[o], and returns @expr{0@} (zero) otherwise.    *!    *! @seealso    *! @[indices()], @[values()]    */   PMOD_EXPORT void f_object_variablep(INT32 args)   {    struct object *o;    struct pike_string *s;    int ret;   
pike.git/src/builtin_functions.c:6504:   #endif      #ifdef PIKE_DEBUG   /*! @decl mapping(string:int) locate_references(string|array|mapping| @    *! multiset|function|object| @    *! program|type o)    *! @belongs Debug    *!    *! This function is mostly intended for debugging. It will search through    *! all data structures in Pike looking for @[o] and print the -  *! locations on stderr. @[o] can be anything but @tt{int@} or -  *! @tt{float@}. +  *! locations on stderr. @[o] can be anything but @expr{int@} or +  *! @expr{float@}.    *!    *! @note    *! This function only exists if the Pike runtime has been compiled    *! with RTL debug.    */   PMOD_EXPORT void f__locate_references(INT32 args)   {    CHECK_SECURITY_OR_ERROR(SECURITY_BIT_SECURITY,    ("_locate_references: permission denied.\n"));    if(args)
pike.git/src/builtin_functions.c:7547:    */      /*! @module Function    */      /*! @decl string defined(function fun)    *!    *! Returns a string with filename and linenumber where @[fun]    *! was defined.    *! -  *! Returns @tt{0@} (zero) when no line can be found, e.g. for +  *! Returns @expr{0@} (zero) when no line can be found, e.g. for    *! builtin functions and functions in destructed objects.    */   PMOD_EXPORT void f_function_defined(INT32 args)   {    check_all_args("Function.defined",args,BIT_FUNCTION, 0);       if(Pike_sp[-args].subtype != FUNCTION_BUILTIN &&    Pike_sp[-args].u.object->prog)    {    struct program *p = Pike_sp[-args].u.object->prog;