Log of autodoc.git/autodoc.xml

1999-01-01

1999-01-01 00:00:00 by Fredrik Hübinette (Hubbe) <hubbe@hubbe.net>

431c43b084c78078983a5a72e59d91b0c2c05c72 (25104 lines) (+8395/-16709) ^{[

Show
| Annotate

]}
Branch: 8.0

Pike 0.7

Rev: about_pike/.cvsignore:1.1(DEAD)
Rev: about_pike/README:1.1(DEAD)
Rev: about_pike/about_versions:1.1(DEAD)
Rev: about_pike/client-server.pike:1.1(DEAD)
Rev: about_pike/crypto_stuff.pike:1.1(DEAD)
Rev: about_pike/draw_stuff.pike:1.3(DEAD)
Rev: about_pike/foo.ppm:1.1(DEAD)
Rev: about_pike/mail_stuff.pike:1.1(DEAD)
Rev: about_pike/matrix2.foo:1.1(DEAD)
Rev: about_pike/perl_tcl_python_pike:1.2(DEAD)
Rev: about_pike/why_pike_long:1.1(DEAD)
Rev: about_pike/why_pike_short:1.1(DEAD)
Rev: doc/README:1.1.1.1(DEAD)
Rev: doc/builtin/_memory_usage:1.1(DEAD)
Rev: doc/builtin/_next:1.1(DEAD)
Rev: doc/builtin/_prev:1.1(DEAD)
Rev: doc/builtin/_verify_internals:1.1.1.1(DEAD)
Rev: doc/builtin/add_constant:1.1.1.1(DEAD)
Rev: doc/builtin/aggregage_multiset:1.1.1.1(DEAD)
Rev: doc/builtin/aggregate:1.1.1.1(DEAD)
Rev: doc/builtin/aggregate_mapping:1.1.1.1(DEAD)
Rev: doc/builtin/alarm:1.1.1.1(DEAD)
Rev: doc/builtin/all_constants:1.1.1.1(DEAD)
Rev: doc/builtin/allocate:1.1.1.1(DEAD)
Rev: doc/builtin/arrayp:1.1.1.1(DEAD)
Rev: doc/builtin/backtrace:1.2(DEAD)
Rev: doc/builtin/call_function:1.1.1.1(DEAD)
Rev: doc/builtin/clone:1.1.1.1(DEAD)
Rev: doc/builtin/column:1.1.1.1(DEAD)
Rev: doc/builtin/combine_path:1.1.1.1(DEAD)
Rev: doc/builtin/compile_file:1.1.1.1(DEAD)
Rev: doc/builtin/compile_string:1.1.1.1(DEAD)
Rev: doc/builtin/copy_value:1.1.1.1(DEAD)
Rev: doc/builtin/crypt:1.1.1.1(DEAD)
Rev: doc/builtin/ctime:1.1.1.1(DEAD)
Rev: doc/builtin/destruct:1.1.1.1(DEAD)
Rev: doc/builtin/equal:1.1.1.1(DEAD)
Rev: doc/builtin/exit:1.1.1.1(DEAD)
Rev: doc/builtin/floatp:1.1.1.1(DEAD)
Rev: doc/builtin/function_name:1.1.1.1(DEAD)
Rev: doc/builtin/function_object:1.1.1.1(DEAD)
Rev: doc/builtin/functionp:1.1.1.1(DEAD)
Rev: doc/builtin/gc:1.1.1.1(DEAD)
Rev: doc/builtin/getpid:1.1.1.1(DEAD)
Rev: doc/builtin/glob:1.1.1.1(DEAD)
Rev: doc/builtin/hash:1.1.1.1(DEAD)
Rev: doc/builtin/indices:1.1.1.1(DEAD)
Rev: doc/builtin/intp:1.1.1.1(DEAD)
Rev: doc/builtin/kill:1.1.1.1(DEAD)
Rev: doc/builtin/load_module:1.1(DEAD)
Rev: doc/builtin/localtime:1.1.1.1(DEAD)
Rev: doc/builtin/lower_case:1.1.1.1(DEAD)
Rev: doc/builtin/m_delete:1.1.1.1(DEAD)
Rev: doc/builtin/mappingp:1.1.1.1(DEAD)
Rev: doc/builtin/mkmapping:1.1.1.1(DEAD)
Rev: doc/builtin/multisetp:1.1.1.1(DEAD)
Rev: doc/builtin/next_object:1.1.1.1(DEAD)
Rev: doc/builtin/object_program:1.2(DEAD)
Rev: doc/builtin/objectp:1.1.1.1(DEAD)
Rev: doc/builtin/programp:1.1.1.1(DEAD)
Rev: doc/builtin/query_host_name:1.1.1.1(DEAD)
Rev: doc/builtin/query_num_arg:1.1.1.1(DEAD)
Rev: doc/builtin/random:1.1.1.1(DEAD)
Rev: doc/builtin/random_seed:1.1.1.1(DEAD)
Rev: doc/builtin/replace:1.1.1.1(DEAD)
Rev: doc/builtin/reverse:1.1.1.1(DEAD)
Rev: doc/builtin/rows:1.1.1.1(DEAD)
Rev: doc/builtin/rusage:1.1.1.1(DEAD)
Rev: doc/builtin/search:1.1.1.1(DEAD)
Rev: doc/builtin/signal:1.1.1.1(DEAD)
Rev: doc/builtin/signame:1.1.1.1(DEAD)
Rev: doc/builtin/signum:1.1.1.1(DEAD)
Rev: doc/builtin/sizeof:1.1.1.1(DEAD)
Rev: doc/builtin/sleep:1.1.1.1(DEAD)
Rev: doc/builtin/sort:1.1.1.1(DEAD)
Rev: doc/builtin/stringp:1.1.1.1(DEAD)
Rev: doc/builtin/this_object:1.1.1.1(DEAD)
Rev: doc/builtin/this_thread:1.1(DEAD)
Rev: doc/builtin/thread_create:1.2(DEAD)
Rev: doc/builtin/throw:1.1.1.1(DEAD)
Rev: doc/builtin/time:1.1.1.1(DEAD)
Rev: doc/builtin/trace:1.1.1.1(DEAD)
Rev: doc/builtin/ualarm:1.1.1.1(DEAD)
Rev: doc/builtin/upper_case:1.1.1.1(DEAD)
Rev: doc/builtin/values:1.1.1.1(DEAD)
Rev: doc/builtin/zero_type:1.3(DEAD)
Rev: doc/index.bmml:1.2(DEAD)
Rev: doc/internal/.bmmlrc:1.1(DEAD)
Rev: doc/internal/array/aggregate_array:1.1(DEAD)
Rev: doc/internal/array/allocate_array:1.1(DEAD)
Rev: doc/internal/array/array:1.2(DEAD)
Rev: doc/internal/array/array_index:1.2(DEAD)
Rev: doc/internal/array/array_remove:1.1(DEAD)
Rev: doc/internal/array/array_search:1.1(DEAD)
Rev: doc/internal/array/array_set_index:1.1(DEAD)
Rev: doc/internal/array/copy_array:1.1(DEAD)
Rev: doc/internal/array/free_array:1.1(DEAD)
Rev: doc/internal/array/push_array_items:1.1(DEAD)
Rev: doc/internal/array/resize_array:1.1(DEAD)
Rev: doc/internal/array/slice_array:1.1(DEAD)
Rev: doc/internal/low_level/hashmem:1.1(DEAD)
Rev: doc/internal/low_level/init_memsearch:1.1(DEAD)
Rev: doc/internal/low_level/low_level:1.2(DEAD)
Rev: doc/internal/low_level/memory_search:1.1(DEAD)
Rev: doc/internal/low_level/reorder:1.1(DEAD)
Rev: doc/internal/low_level/set_close_on_exec:1.1(DEAD)
Rev: doc/internal/low_level/set_nonblocking:1.1(DEAD)
Rev: doc/internal/low_level/set_read_callback:1.1(DEAD)
Rev: doc/internal/low_level/set_write_callback:1.1(DEAD)
Rev: doc/internal/low_level/xalloc:1.1(DEAD)
Rev: doc/internal/mappings/copy_mapping:1.1(DEAD)
Rev: doc/internal/mappings/free_mapping:1.1(DEAD)
Rev: doc/internal/mappings/low_mapping_lookup:1.1(DEAD)
Rev: doc/internal/mappings/m_sizeof:1.1(DEAD)
Rev: doc/internal/mappings/map_delete:1.1(DEAD)
Rev: doc/internal/mappings/mapping:1.1(DEAD)
Rev: doc/internal/mappings/mapping_indices:1.1(DEAD)
Rev: doc/internal/mappings/mapping_insert:1.1(DEAD)
Rev: doc/internal/mappings/mapping_replace:1.1(DEAD)
Rev: doc/internal/mappings/mapping_values:1.1(DEAD)
Rev: doc/internal/mappings/mkmapping:1.1(DEAD)
Rev: doc/internal/object/object:1.1(DEAD)
Rev: doc/internal/pike/SETJMP:1.2(DEAD)
Rev: doc/internal/pike/SET_ONERROR:1.2(DEAD)
Rev: doc/internal/pike/UNSETJMP:1.2(DEAD)
Rev: doc/internal/pike/UNSET_ONERROR:1.2(DEAD)
Rev: doc/internal/pike/data_types:1.1(DEAD)
Rev: doc/internal/pike/error:1.3(DEAD)
Rev: doc/internal/pike/error_handling:1.1(DEAD)
Rev: doc/internal/pike/fatal:1.2(DEAD)
Rev: doc/internal/pike/frame:1.2(DEAD)
Rev: doc/internal/pike/throw:1.2(DEAD)
Rev: doc/internal/pike/type_field:1.2(DEAD)
Rev: doc/internal/pike/types:1.2(DEAD)
Rev: doc/internal/program/add_function:1.1(DEAD)
Rev: doc/internal/program/add_storage:1.1(DEAD)
Rev: doc/internal/program/end_c_program:1.1(DEAD)
Rev: doc/internal/program/program:1.2(DEAD)
Rev: doc/internal/program/set_exit_callback:1.1(DEAD)
Rev: doc/internal/program/set_init_callback:1.1(DEAD)
Rev: doc/internal/program/start_new_program:1.1(DEAD)
Rev: doc/internal/strings/add_shared_strings:1.1(DEAD)
Rev: doc/internal/strings/begin_shared_string:1.1(DEAD)
Rev: doc/internal/strings/binary_findstring:1.1(DEAD)
Rev: doc/internal/strings/end_shared_string:1.1(DEAD)
Rev: doc/internal/strings/findstring:1.1(DEAD)
Rev: doc/internal/strings/free_string:1.2(DEAD)
Rev: doc/internal/strings/make_shared_binary_string:1.1(DEAD)
Rev: doc/internal/strings/make_shared_string:1.2(DEAD)
Rev: doc/internal/strings/my_strcmp:1.1(DEAD)
Rev: doc/internal/strings/pike_string:1.2(DEAD)
Rev: doc/internal/strings/push_string:1.1(DEAD)
Rev: doc/internal/strings/string_replace:1.1(DEAD)
Rev: doc/internal/svalue/IS_ZERO:1.1(DEAD)
Rev: doc/internal/svalue/assign_svalue:1.1(DEAD)
Rev: doc/internal/svalue/free_svalue:1.1(DEAD)
Rev: doc/internal/svalue/is_eq:1.1(DEAD)
Rev: doc/internal/svalue/is_equal:1.1(DEAD)
Rev: doc/internal/svalue/is_lt:1.1(DEAD)
Rev: doc/internal/svalue/svalue:1.1(DEAD)
Rev: doc/manual/example1:1.1.1.1(DEAD)
Rev: doc/manual/example2:1.1.1.1(DEAD)
Rev: doc/manual/example3:1.2(DEAD)
Rev: doc/manual/tutorial:1.1.1.1(DEAD)
Rev: doc/operators/and:1.1.1.1(DEAD)
Rev: doc/operators/complement:1.1.1.1(DEAD)
Rev: doc/operators/divide:1.1.1.1(DEAD)
Rev: doc/operators/index:1.1.1.1(DEAD)
Rev: doc/operators/is_equal:1.1.1.1(DEAD)
Rev: doc/operators/is_greater_or_equal:1.1.1.1(DEAD)
Rev: doc/operators/is_greater_than:1.1.1.1(DEAD)
Rev: doc/operators/is_lesser_or_equal:1.1.1.1(DEAD)
Rev: doc/operators/is_lesser_than:1.1.1.1(DEAD)
Rev: doc/operators/logical_and:1.1.1.1(DEAD)
Rev: doc/operators/logical_or:1.1.1.1(DEAD)
Rev: doc/operators/minus:1.1.1.1(DEAD)
Rev: doc/operators/modulo:1.1.1.1(DEAD)
Rev: doc/operators/mult:1.1.1.1(DEAD)
Rev: doc/operators/not:1.1.1.1(DEAD)
Rev: doc/operators/not_equal:1.1.1.1(DEAD)
Rev: doc/operators/operators:1.1.1.1(DEAD)
Rev: doc/operators/or:1.1.1.1(DEAD)
Rev: doc/operators/plus:1.1.1.1(DEAD)
Rev: doc/operators/range:1.1.1.1(DEAD)
Rev: doc/operators/shift_left:1.1.1.1(DEAD)
Rev: doc/operators/shift_right:1.1.1.1(DEAD)
Rev: doc/operators/xor:1.1.1.1(DEAD)
Rev: doc/pike/all.bmml:1.1.1.1(DEAD)
Rev: doc/pike/cast:1.1.1.1(DEAD)
Rev: doc/pike/catch:1.2(DEAD)
Rev: doc/pike/class:1.1.1.1(DEAD)
Rev: doc/pike/command_line_options:1.1.1.1(DEAD)
Rev: doc/pike/control_structures/break:1.1.1.1(DEAD)
Rev: doc/pike/control_structures/catch:1.1.1.1(DEAD)
Rev: doc/pike/control_structures/continue:1.1.1.1(DEAD)
Rev: doc/pike/control_structures/do-while:1.1.1.1(DEAD)
Rev: doc/pike/control_structures/for:1.1.1.1(DEAD)
Rev: doc/pike/control_structures/foreach:1.1.1.1(DEAD)
Rev: doc/pike/control_structures/if-else:1.1.1.1(DEAD)
Rev: doc/pike/control_structures/return:1.1.1.1(DEAD)
Rev: doc/pike/control_structures/switch:1.1.1.1(DEAD)
Rev: doc/pike/control_structures/while:1.1.1.1(DEAD)
Rev: doc/pike/efuns.bmml:1.1.1.1(DEAD)
Rev: doc/pike/functions:1.1.1.1(DEAD)
Rev: doc/pike/gauge:1.2(DEAD)
Rev: doc/pike/hilfe:1.1.1.1(DEAD)
Rev: doc/pike/how_to_make_modules:1.1.1.1(DEAD)
Rev: doc/pike/inherit:1.1.1.1(DEAD)
Rev: doc/pike/lambda:1.1.1.1(DEAD)
Rev: doc/pike/modifier:1.1.1.1(DEAD)
Rev: doc/pike/preprocessor:1.1.1.1(DEAD)
Rev: doc/pike/reserved.bmml:1.1.1.1(DEAD)
Rev: doc/pike/sscanf:1.1.1.1(DEAD)
Rev: doc/pike/typeof:1.1.1.1(DEAD)
Rev: doc/pike/variables:1.1.1.1(DEAD)
Rev: doc/precompiled/FILE:1.1(DEAD)
Rev: doc/precompiled/condition:1.1(DEAD)
Rev: doc/precompiled/fifo:1.1(DEAD)
Rev: doc/precompiled/mutex:1.1(DEAD)
Rev: doc/precompiled/queue:1.1(DEAD)
Rev: doc/precompiled/sql:1.5(DEAD)
Rev: doc/precompiled/sql_result:1.5(DEAD)
Rev: doc/precompiled/stack:1.1(DEAD)
Rev: doc/precompiled/string_buffer:1.2(DEAD)
Rev: doc/simulated/PI:1.1.1.1(DEAD)
Rev: doc/simulated/add_efun:1.1.1.1(DEAD)
Rev: doc/simulated/aggregage_list:1.1.1.1(DEAD)
Rev: doc/simulated/all_efuns:1.1.1.1(DEAD)
Rev: doc/simulated/capitalize:1.1.1.1(DEAD)
Rev: doc/simulated/describe_backtrace:1.1.1.1(DEAD)
Rev: doc/simulated/exec:1.1.1.1(DEAD)
Rev: doc/simulated/explode:1.1.1.1(DEAD)
Rev: doc/simulated/file_size:1.2(DEAD)
Rev: doc/simulated/filter:1.1.1.1(DEAD)
Rev: doc/simulated/filter_array:1.1.1.1(DEAD)
Rev: doc/simulated/find_option:1.1(DEAD)
Rev: doc/simulated/get_args:1.1(DEAD)
Rev: doc/simulated/get_function:1.1.1.1(DEAD)
Rev: doc/simulated/getenv:1.1.1.1(DEAD)
Rev: doc/simulated/implode:1.1.1.1(DEAD)
Rev: doc/simulated/implode_nicely:1.1(DEAD)
Rev: doc/simulated/l_sizeof:1.1.1.1(DEAD)
Rev: doc/simulated/listp:1.1.1.1(DEAD)
Rev: doc/simulated/m_indices:1.1.1.1(DEAD)
Rev: doc/simulated/m_sizeof:1.1.1.1(DEAD)
Rev: doc/simulated/m_values:1.1.1.1(DEAD)
Rev: doc/simulated/map:1.1.1.1(DEAD)
Rev: doc/simulated/map_array:1.1.1.1(DEAD)
Rev: doc/simulated/master:1.1.1.1(DEAD)
Rev: doc/simulated/member_array:1.1.1.1(DEAD)
Rev: doc/simulated/mklist:1.1.1.1(DEAD)
Rev: doc/simulated/mkmultiset:1.1.1.1(DEAD)
Rev: doc/simulated/perror:1.1.1.1(DEAD)
Rev: doc/simulated/popen:1.1.1.1(DEAD)
Rev: doc/simulated/previous_object:1.1.1.1(DEAD)
Rev: doc/simulated/putenv:1.1.1.1(DEAD)
Rev: doc/simulated/read_bytes:1.2(DEAD)
Rev: doc/simulated/read_file:1.2(DEAD)
Rev: doc/simulated/regexp:1.1.1.1(DEAD)
Rev: doc/simulated/search_array:1.1.1.1(DEAD)
Rev: doc/simulated/sort_array:1.2(DEAD)
Rev: doc/simulated/spawn:1.1.1.1(DEAD)
Rev: doc/simulated/stderr:1.1(DEAD)
Rev: doc/simulated/stdin:1.1(DEAD)
Rev: doc/simulated/stdout:1.1(DEAD)
Rev: doc/simulated/strlen:1.1.1.1(DEAD)
Rev: doc/simulated/strmult:1.1(DEAD)
Rev: doc/simulated/strstr:1.1.1.1(DEAD)
Rev: doc/simulated/sum:1.1.1.1(DEAD)
Rev: doc/simulated/sum_arrays:1.1.1.1(DEAD)
Rev: doc/simulated/system:1.1.1.1(DEAD)
Rev: doc/simulated/this_function:1.1.1.1(DEAD)
Rev: doc/simulated/uniq:1.1(DEAD)
Rev: doc/simulated/version:1.1.1.1(DEAD)
Rev: doc/simulated/write:1.1.1.1(DEAD)
Rev: doc/simulated/write_file:1.2(DEAD)
Rev: doc/types/array:1.1.1.1(DEAD)
Rev: doc/types/float:1.1.1.1(DEAD)
Rev: doc/types/function:1.1.1.1(DEAD)
Rev: doc/types/int:1.1.1.1(DEAD)
Rev: doc/types/mapping:1.1.1.1(DEAD)
Rev: doc/types/mixed:1.1.1.1(DEAD)
Rev: doc/types/multiset:1.1.1.1(DEAD)
Rev: doc/types/object:1.1.1.1(DEAD)
Rev: doc/types/program:1.1.1.1(DEAD)
Rev: doc/types/string:1.1.1.1(DEAD)

1: <?xml version='1.0' encoding='utf-8'?> <autodoc> - <namespace name='c'> - <docgroup homogen-name='IS_ZERO' homogen-type='method'> - <method name='IS_ZERO'/><doc placeholder='true'> - <text> - <tt>IS_ZERO</tt> - is this svalue considered 'false' - - <tt>#include <simulate.h> - - - int IS_ZERO(struct svalue *s); - - </tt> - IS_ZERO returns true if the svalue 's' is a zero. (or an object with - `! operator that returned true..) - </text> - - <group><note/><text> - IS_ZERO is actually a macro - - svalue</text></group> - - <group><seealso/><text> - <ref resolved='c::is_eq' to='is_eq'>is_eq</ref>, <ref resolved='c::is_equal' to='is_equal'>is_equal</ref> and <ref resolved='c::is_lt' to='is_lt'>is_lt</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='SETJMP' homogen-type='method'> - <method name='SETJMP'/><doc placeholder='true'> - <text> - <tt>SETJMP</tt> - catch errors - - <tt>#include "error.h" - - - int SETJMP(JMP_BUF buf); - - </tt> - These macros are wrappers to the setjmp/longjmp routines with some - added support for cleaning up the Pike stack and other things that - might need freeing. What SETJUMP does is that it lets you catch - Pike errors much like the Pike function catch(). When called, - SETJMP returns zero, so the 'failsafe' code is executed. If an error - occurs in that code the processor will jump directly to the SETJMP - again and it will return 'true'. Then the 'error' code will be - executed. - </text> - - <group><note/><text> - SETJMP is a macro - - 'buf' has to be a local variable - - There are some limitations to how you can use local variables in the - same function as setjump/longjump. See setjup(3) for more details. - </text></group> - - <group><example/><text> - <tt>#include "error.h" - - - void do_catch() - { - <dl><group><text>JMP_BUF buf; - </text></group></dl> - - <dl><group><text>if(SETJMP(buf)) { - <dl><group><text>/* An error / longjump occured */ - </text></group></dl>} else { - <dl><group><text>/* Execute failsafe code here */ - </text></group></dl>} - </text></group></dl> - - <dl><group><text>UNSETJMP(foo) - </text></group></dl>} - - </tt> - error_handling</text></group> - - <group><seealso/><text> - <ref resolved='c::throw' to='throw'>throw</ref>, <ref resolved='c::error' to='error'>error</ref>, <ref resolved='c::UNSETJMP' to='UNSETJMP'>UNSETJMP</ref>, <ref resolved='c::SET_ONERROR' to='SET_ONERROR'>SET_ONERROR</ref> and <ref resolved='c::UNSET_ONERROR' to='UNSET_ONERROR'>UNSET_ONERROR</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='SET_ONERROR' homogen-type='method'> - <method name='SET_ONERROR'/><doc placeholder='true'> - <text> - <tt>SET_ONERROR</tt> - call this function if an error occurs - - <tt>#include "error.h" - - - void SET_ONERROR(ONERROR tmp, void (*func)(void *), void *arg); - - </tt> - This function sets an error handler to be called when an error - occurs. When an error occurs the function 'func' is called with - the argument 'arg'. The advantage of this method over using SETJMP - for cleanup handling is that this should be slightly faster and it - does not have problems with undefined local variables. - </text> - - <group><note/><text> - SET_ONERROR is a macro - - 'tmp' has to be a local variable. - </text></group> - - <group><example/><text> - <tt>#include "error.h" - #include "memory.h" - - - void do_something() - { - <dl><group><text>ONERROR tmp; - char *mem=xalloc(4711); - </text></group></dl> - - <dl><group><text>SET_ONERROR(tmp, (void (*)(void *)) free, mem); - </text></group></dl> - - <dl><group><text>/* Do some code that might cause an Pike error */ - </text></group></dl> - - <dl><group><text>UNSET_ONERROR(tmp); - </text></group></dl>} - - </tt> - error_handling</text></group> - - <group><seealso/><text> - <ref resolved='c::UNSET_ONERROR' to='UNSET_ONERROR'>UNSET_ONERROR</ref> and <ref resolved='c::error' to='error'>error</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='UNSETJMP' homogen-type='method'> - <method name='UNSETJMP'/><doc placeholder='true'> - <text> - <tt>UNSETJMP</tt> - stop catching error - - This macro cleans up after calling SETJMP. See the page for SETJMP - for more details. - - error_handling</text> - - <group><seealso/><text> - <ref resolved='c::SETJMP' to='SETJMP'>SETJMP</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='UNSET_ONERROR' homogen-type='method'> - <method name='UNSET_ONERROR'/><doc placeholder='true'> - <text> - <tt>UNSET_ONERROR</tt> - cleanup after an SET_ONERROR - - This function cleans up after a SET_ONERROR call. - See SET_ONERROR for more details. - - error_handling</text> - - <group><seealso/><text> - <ref resolved='c::SET_ONERROR' to='SET_ONERROR'>SET_ONERROR</ref> and <ref resolved='c::SETJMP' to='SETJMP'>SETJMP</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='add_function' homogen-type='method'> - <method name='add_function'/><doc placeholder='true'> - <text> - <tt>add_function</tt> - add a function to the program - - <tt>#include "program.h" - - - void add_function(char *name, - <dl><group><text>void (*fun)(INT32), - char *type, - INT16 flags) - </text></group></dl> - </tt> - This function adds a function to the program you are building. - The function will have the name 'name' and the type 'type'. - The function 'fun' will be called with an integer telling it how - many arguments are on the stack and is expected to remove those - elements from the stack and replace them with a return value. - The flags are zero or more of the following or:ed together: - ID_STATIC, ID_PRIVATE, ID_NOMASK, ID_PUBLIC, ID_PROTECTED and - ID_INLINE. - - program</text> - - <group><seealso/><text> - <ref resolved='c::start_new_program' to='start_new_program'>start_new_program</ref> and <ref resolved='c::types' to='types'>types</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='add_shared_strings' homogen-type='method'> - <method name='add_shared_strings'/><doc placeholder='true'> - <text> - <tt>add_shared_strings</tt> - add two pike strings - - <tt>#include "stralloc.h" - - - struct pike_string *add_shared_strings(struct pike_string *a, - <dl><group><text>struct pike_string *b); - </text></group></dl> - </tt> - This function builds the string a+b, that is the string a with the - string b appended to it. Note that the string returned will have - an extra reference. - - pike_string</text> - - <group><seealso/><text> - <ref resolved='c::begin_shared_string' to='begin_shared_string'>begin_shared_string</ref> and <ref resolved='c::make_shared_string' to='make_shared_string'>make_shared_string</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='add_storage' homogen-type='method'> - <method name='add_storage'/><doc placeholder='true'> - <text> - <tt>add_storage</tt> - allocate space for object-local data - - <tt>#include "program.h" - - - void add_storage(INT32 size); - - </tt> - This function allocates 'size' bytes in every object cloned from the - program you are in the process of building. (Be sure to call - start_new_program first...) Whenever one of your methods are called - fp->current_storage will point to this area. - - program</text> - - <group><seealso/><text> - <ref resolved='c::start_new_program' to='start_new_program'>start_new_program</ref> and <ref resolved='c::frame' to='frame'>frame</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='aggregate_array' homogen-type='method'> - <method name='aggregate_array'/><doc placeholder='true'> - <text> - <tt>aggregate_array</tt> - build an array from the stack - - <tt>#include "array.h" - - - struct array *aggregate_array(INT32 num) - - </tt> - This pops 'num' args off the stack an puts them in an array. - The 'top' of the stack will be the last element in the array. - - array</text> - - <group><seealso/><text> - <ref to='check_stack'>check_stack</ref> and <ref resolved='c::push_array_items' to='push_array_items'>push_array_items</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='allocate_array' homogen-type='method'> - <method name='allocate_array'/><doc placeholder='true'> - <text> - <tt>allocate_array</tt> - allocate an array - - <tt>#include "array.h" - - - struct array *allocate_array(INT32 size); - - </tt> - This function allocates an array of size 'size'. The returned - array will have 'size' struct svalues in the member 'item'. - The array can contain any svalue, and the type field will be - initalized to -1. - </text> - - <group><note/><text> - When building arrays, it is recommended that you push the values - on the stack and call aggregate_array or f_aggregate instead of - allocating and filling in the values 'by hand'. - - array</text></group> - - </doc> - </docgroup> - <docgroup homogen-name='array' homogen-type='method'> - <method name='array'/><doc placeholder='true'> - <text> - <tt>array</tt> - the internal representation of an array - - A Pike array is represented as a 'struct array' with all the - needed svalues malloced in the same block. The relevant members - are: - - <matrix> - <r><c> refs </c><c> reference count </c></r> - <r><c> size </c><c> the number of svalues in the array </c></r> - <r><c> malloced_size </c><c> the number of svalues that can fit in this block </c></r> - <r><c> type_field </c><c> a bitfield indicating what types the array contains </c></r> - <r><c> item </c><c> the array of svalues </c></r> - </matrix> - - </text> - - <group><seealso/><text> - <ref resolved='c::type_field' to='type_field'>type_field</ref> - - internals</text></group> - - </doc> - </docgroup> - <docgroup homogen-name='array_index' homogen-type='method'> - <method name='array_index'/><doc placeholder='true'> - <text> - <tt>array_index</tt> - get an index from an array - - <tt>#include "array.h" - - - void array_index(struct svalue *to, struct array *a, INT32 n); - - </tt> - This function frees the contents of the svalue 'to' and replaces - it with a copy of the contents from index 'n' in the array 'a'. - Basically, what it does is: - - <matrix> - <r><c> </c><c> assign_svalue(to, a->item + n); </c></r> - <r><c> </c></r> - </matrix> - - - The only differance is that it adds some debug and safety - measures. Usually you don't really need to use this function. - </text> - - <group><note/><text> - If n is out of bounds (n < 0 or n >= a->size) Pike will dump - core. If Pike was compiled with DEBUG, a message will be written - first stating what the problem was. - - array</text></group> - - <group><seealso/><text> - <ref resolved='c::assign_svalue' to='assign_svalue'>assign_svalue</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='array_remove' homogen-type='method'> - <method name='array_remove'/><doc placeholder='true'> - <text> - <tt>array_remove</tt> - remove an index from an array - - <tt>#include "array.h" - - - struct array *array_remove(struct array *a, INT32 ind); - - </tt> - This function removes the index 'ind' from the array 'a' destructively. - The returned array should be used instead of 'a' and can be the same - as 'a'. Because this function is destructive and might free the - memory region for 'a' it may only be used on arrays which has not been - sent to any lpc functions yet. - - array</text> - - <group><seealso/><text> - <ref to='array_insert'>array_insert</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='array_search' homogen-type='method'> - <method name='array_search'/><doc placeholder='true'> - <text> - <tt>array_search</tt> - search an array - - <tt>#include "array.h" - - - INT32 array_search(struct array *a, - <dl><group><text>struct svalue *val, - INT32 start); - </text></group></dl> - </tt> - This function loops over the array 'a' starting at 'start' until - it finds an index that is_eq to 'val'. When it finds such a value - the number for that index will be returned. If no such value is - found -1 is returned. - </text> - - <group><note/><text> - This function checks the type_field in the array, and also re-builds - the type-field if the value is not found. - - array</text></group> - - <group><seealso/><text> - <ref resolved='c::is_eq' to='is_eq'>is_eq</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='array_set_index' homogen-type='method'> - <method name='array_set_index'/><doc placeholder='true'> - <text> - <tt>array_set_index</tt> - get an index from an array - - <tt>#include "array.h" - - - void array_set_index(struct array *a, - <dl><group><text>INT32 ind, - struct svalue *from); - </text></group></dl> - </tt> - This function frees the contents of the index 'ind' in the array - 'a' and replaces it with a copy of the contents from 'from'. - Basically, what it does is: - - <matrix> - <r><c> </c><c> assign_svalue(a->item + n, from); </c></r> - <r><c> </c></r> - </matrix> - - - The only differance is that it adds some debug and safety - measures. Usually you don't really need to use this function. - </text> - - <group><note/><text> - If n is out of bounds (n < 0 or n >= a->size) Pike will dump - core. If Pike was compiled with DEBUG, a message will be written - first stating what the problem was. - - array</text></group> - - <group><seealso/><text> - <ref resolved='c::assign_svalue' to='assign_svalue'>assign_svalue</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='assign_svalue' homogen-type='method'> - <method name='assign_svalue'/><doc placeholder='true'> - <text> - <tt>assign_svalue</tt> - copy svalues from one place to another - - <tt>#include <svalue.h> - - - void assign_svalue(struct svale *to, struct svalue *from); - - </tt> - This function copies an svalue from one struct svalue to another. - It frees the contents of 'to' first and updates the involved - refcounts. - - svalue</text> - - <group><seealso/><text> - <ref resolved='c::free_svalue' to='free_svalue'>free_svalue</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='begin_shared_string' homogen-type='method'> - <method name='begin_shared_string'/><doc placeholder='true'> - <text> - <tt>begin_shared_string</tt> - allocate space for a shared string - - <tt>#include "stralloc.h" - - - struct pike_string *begin_shared_string(INT32 len); - - </tt> - This function allocates space for a shared string of length 'len'. - You should then MEMCPY 'len' bytes into the s->str. (s being the - returned value) And then call end_shared_string. - - pike_string</text> - - <group><seealso/><text> - <ref resolved='c::end_shared_string' to='end_shared_string'>end_shared_string</ref> and <ref resolved='c::make_shared_string' to='make_shared_string'>make_shared_string</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='binary_findstring' homogen-type='method'> - <method name='binary_findstring'/><doc placeholder='true'> - <text> - <tt>binary_findstring</tt> - find a string - - <tt>#include "stralloc.h" - - - struct pike_string *binary_findstring(char *str, INT32 length); - - </tt> - This function looks for the 'str' with length 'len' in the - global hash table. It returns the shared string if found, otherwise - zero. It does not increase/decrease the references to the string. - - pike_string</text> - - <group><seealso/><text> - <ref resolved='c::findstring' to='findstring'>findstring</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='copy_array' homogen-type='method'> - <method name='copy_array'/><doc placeholder='true'> - <text> - <tt>copy_array</tt> - copy an array - - <tt>#include "array.h" - - - struct array *copy_array(struct svalue *a); - - </tt> - This function returns a copy of the array 'a'. It is not recursive, - arrays within 'a' will only get extra references. - - array</text> - - </doc> - </docgroup> - <docgroup homogen-name='copy_mapping' homogen-type='method'> - <method name='copy_mapping'/><doc placeholder='true'> - <text> - <tt>copy_mapping</tt> - copy a mapping - - <tt>#include "mapping.h" - - - struct mapping *copy_mapping(struct mapping *m) - - </tt> - This function returns a copy of the mapping m. If you change the - contents of the new mapping the contents of the mapping m will not - change. Note that this function is not recursive. - - mapping</text> - - </doc> - </docgroup> - <docgroup homogen-name='data_types' homogen-type='method'> - <method name='data_types'/><doc placeholder='true'> - <text> - <tt>data_types</tt> - Pike internal data types - - Of course the Pike source uses a lot of data types except for those - that represents mappings, arrays, strings etc. Callbacks, stack frames - and type fields are just the beginning. - - internals</text> - - </doc> - </docgroup> - <docgroup homogen-name='end_c_program' homogen-type='method'> - <method name='end_c_program'/><doc placeholder='true'> - <text> - <tt>end_c_program</tt> - finish building a 'struct program' - - <tt>#include "program.h" - - - struct program *end_c_program(char *name); - - </tt> - This function finishes up the process of building a 'struct program'. - It initializes the struct program and calls - master()->add_precompiled_program with the program and the suggested - name. (As sent to end_c_program). It then returns the newly built - program. Note that the new program does NOT have an extra reference, - if you want to keep it around and use it you have to add that reference - yourself. - - program</text> - - <group><seealso/><text> - <ref resolved='c::start_new_program' to='start_new_program'>start_new_program</ref> and <ref resolved='c::add_function' to='add_function'>add_function</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='end_shared_string' homogen-type='method'> - <method name='end_shared_string'/><doc placeholder='true'> - <text> - <tt>end_shared_string</tt> - link a shared string into the hashtable - - <tt>#include "stralloc.h" - - - struct pike_string *end_shared_string(struct pike_string *p); - - </tt> - This function the prepared output from a begin_shared_string and - links the string into the hash table. If an identical string is - already present in the hash table, p is freed and that string is - returned instead. The returned string will have one extra reference - added. - </text> - - <group><example/><text> - <tt>#include "global.h" - #include "stralloc.h" - - - struct pike_string *mkcharstring(int ch) - { - <dl><group><text>struct pike_string *ret; - ret=begin_shared_string(1); - ret->str[0]=ch; - return end_shared_string(ret); - </text></group></dl>} - - </tt> - pike_string</text></group> - - <group><seealso/><text> - <ref resolved='c::begin_shared_string' to='begin_shared_string'>begin_shared_string</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='error' homogen-type='method'> - <method name='error'/><doc placeholder='true'> - <text> - <tt>error</tt> - throw an error - - <tt>#include "error.h" - - - void error(char *format_string, ...); - - </tt> - This function takes the same kind of arguments as printf, puts it - all together to a string and throws this as an error message - togehter with a backtrace that tells the catcher where the error - was. Note that this function does _not_ return. Instead it calls - the C function lonjump and continues executing from the most - resent active catch() call. - - error_handling</text> - - <group><seealso/><text> - <ref resolved='c::SET_ONERROR' to='SET_ONERROR'>SET_ONERROR</ref>, <ref resolved='c::fatal' to='fatal'>fatal</ref> and <ref resolved='c::throw' to='throw'>throw</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='error_handling' homogen-type='method'> - <method name='error_handling'/><doc placeholder='true'> - <text> - <tt>error_handling</tt> - how to error handling works inside Pike - - Error handling in Pike is implemented with the setjmp/longjmp - functionality. This means that functions that can cause errors - will NOT return if an error occurs. Special care has to be taken - so that no memory is left unfreed if an error occurs. Almost all - functions that can cause Pike code to be executed can cause an - error. Also functions that implements Pike operators / functions - can cause errors. If you are paranoid you should assume that all - functions can cause errors. You may also read the code for the - function to see if there are any calls to error() in it. If the - function is documented in this manual, it will say if the function - can cause errors. - - internals</text> - - </doc> - </docgroup> - <docgroup homogen-name='fatal' homogen-type='method'> - <method name='fatal'/><doc placeholder='true'> - <text> - <tt>fatal</tt> - print a message and dump core - - <tt>#include "error.h" - - - void fatal(char *format_string, ...); - - </tt> - This function takes the same type of argument as 'printf', and - prints these with any available debug information. (A trace of - the 512 last executed instructions if you compiled with DEBUG.) - Then it forces the driver to dump core so you can examine the - bug with a debugger. Use with extreme caution, an error() might - sometimes be a lot better... - - error_handling</text> - - <group><seealso/><text> - <ref resolved='c::error' to='error'>error</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='findstring' homogen-type='method'> - <method name='findstring'/><doc placeholder='true'> - <text> - <tt>findstring</tt> - find a string - - <tt>#include "stralloc.h" - - - struct pike_string *findstring(char *str); - - </tt> - This function looks for the null terminated C string 'str' in the - global hash table. It returns the shared string if found, otherwise - zero. It does not increase/decrease the references to the string. - - pike_string</text> - - <group><seealso/><text> - <ref resolved='c::make_shared_string' to='make_shared_string'>make_shared_string</ref> and <ref resolved='c::binary_findstring' to='binary_findstring'>binary_findstring</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='frame' homogen-type='method'> - <method name='frame'/><doc placeholder='true'> - <text> - <tt>frame</tt> - the current frame of exectution - - The frame pointer is called 'fp' and is of type 'struct frame'. - The frame pointer contains information about what function we - are executing in, what is the current object, the current program, - where the local variables are etc. It also contains a pointer to - the previous frame in the call stack. The most important members - of 'fp' are: - - <matrix> - <r><c> current_object </c><c> same as the Pike function this_object() </c></r> - <r><c> context.program </c><c> the program in which this function resides </c></r> - <r><c> current_storage </c><c> a 'char *' pointer into the data area for this </c></r> - </matrix> - <dl><group><text><matrix> - <r><c> </c><c> object. This is the pointer to the area reserved </c></r> - <r><c> </c></r> - </matrix> - <dl><group><text><matrix> - <r><c> </c><c> for you if you have done add_storage() earlier. </c></r> - <r><c> </c></r> - </matrix> - </text></group></dl></text></group></dl> - - data_types</text> - - </doc> - </docgroup> - <docgroup homogen-name='free_array' homogen-type='method'> - <method name='free_array'/><doc placeholder='true'> - <text> - <tt>free_array</tt> - free one reference to a array - - <tt>#include "array.h" - - - void free_array(struct array *a) - - </tt> - This function frees one reference to the array a. If the reference - is the last reference to the array, it will free the memory used - by the array a. - </text> - - <group><note/><text> - free_array is a macro - - array</text></group> - - </doc> - </docgroup> - <docgroup homogen-name='free_mapping' homogen-type='method'> - <method name='free_mapping'/><doc placeholder='true'> - <text> - <tt>free_mapping</tt> - free one reference to a mapping - - <tt>#include "mapping.h" - - - void free_mapping(struct mapping *m) - - </tt> - This function frees one reference to the mapping m. If the reference - is the last reference to the mapping, it will free the memory used - by the mapping m. - </text> - - <group><note/><text> - free_mapping is a macro - - mapping</text></group> - - </doc> - </docgroup> - <docgroup homogen-name='free_string' homogen-type='method'> - <method name='free_string'/><doc placeholder='true'> - <text> - <tt>free_string</tt> - free a pike string - - <tt>#include "stralloc.h" - - - void free_string(struct pike_string *p) - - </tt> - This function frees the string 'p'. What it actually does is that it - decreases the reference count of 'p' and frees the memory reserved - for it if the refereneces reach zero. - </text> - - <group><note/><text> - free_string is actually a macro - - pike_string</text></group> - - </doc> - </docgroup> - <docgroup homogen-name='free_svalue' homogen-type='method'> - <method name='free_svalue'/><doc placeholder='true'> - <text> - <tt>free_svalue</tt> - free the contents of an svalue - - <tt>#include <svalue.h> - - - void free_svalue(struct svalue *s); - - </tt> - This function frees the contents of an svalue with respect to - ref counts. It does not however free the storage for svalue itself. - That is up to the caller to do. - - svalue</text> - - <group><seealso/><text> - <ref resolved='c::assign_svalue' to='assign_svalue'>assign_svalue</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='hashmem' homogen-type='method'> - <method name='hashmem'/><doc placeholder='true'> - <text> - <tt>hashmem</tt> - hash a memory region - - <tt>#include "memory.h" - - - unsigned INT32 hashmem(const unsigned char *a,INT32 len,INT32 mlen); - - </tt> - This function looks at the memory region beginning at 'a' and is 'len' - bytes long and returns a hash value depending on the bytes in that - region. The argument 'mlen' is how many bytes it should actually look - at, larger mlen gives better values but slower hashing. - - low_level</text> - - </doc> - </docgroup> - <docgroup homogen-name='init_memsearch' homogen-type='method'> - <method name='init_memsearch'/><doc placeholder='true'> - <text> - <tt>init_memsearch</tt> - initialize a memory search struct - - <tt>#include "memory.h" - - - <matrix> - <r><c> void init_memsearch(struct mem_searcher *s, </c></r> - <r><c> </c><c> </c><c> char *needle, SIZE_T needlelen, SIZE_T max_haystacklen); </c></r> - </matrix> - - </tt> - This function initializes a struct mem_searcher to be used with - the function memory_search. 'needle' is the byte sequence to - search for, and needlelen is how many bytes long the 'needle' is. - The argument 'max_haystacklen' is an approximation of how much - this memory searcher will be used. More time will be spent optimizing - the memory searcher struct if max_haystacklen is large. - </text> - - <group><note/><text> - The needle is not copied by this function. It must still be available - when memory_search is called. - - low_level</text></group> - - <group><seealso/><text> - <ref resolved='c::memory_search' to='memory_search'>memory_search</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='is_eq' homogen-type='method'> - <method name='is_eq'/><doc placeholder='true'> - <text> - <tt>is_eq</tt> - compare two svalues - - <tt>#include <svalue.h> - - - int is_eq(struct svalue *a, struct svalue *b); - - </tt> - This is the equivialent of the Pike operator `==. It compares two - svalues and returns one if they are the same. Otherwise zero. - - svalue</text> - - <group><seealso/><text> - <ref resolved='c::is_equal' to='is_equal'>is_equal</ref>, <ref resolved='c::is_lt' to='is_lt'>is_lt</ref> and <ref resolved='c::IS_ZERO' to='IS_ZERO'>IS_ZERO</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='is_equal' homogen-type='method'> - <method name='is_equal'/><doc placeholder='true'> - <text> - <tt>is_equal</tt> - compare two svalues recursively - - <tt>#include <svalue.h> - - - int is_equal(struct svalue *a, struct svalue *b); - - </tt> - This is the equivialent of the Pike function equal(), it compares - two svalues recursively and returns 1 if their contents are equal, - zero otherwise. - - svalue</text> - - <group><seealso/><text> - <ref resolved='c::is_eq' to='is_eq'>is_eq</ref>, <ref resolved='c::is_lt' to='is_lt'>is_lt</ref> and <ref resolved='c::IS_ZERO' to='IS_ZERO'>IS_ZERO</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='is_lt' homogen-type='method'> - <method name='is_lt'/><doc placeholder='true'> - <text> - <tt>is_lt</tt> - compare two svalues - - <tt>#include <svalue.h> - - - int is_lt(struct svalue *a, struct svalue *b); - - </tt> - This is the equivialent of the Pike operator `<. It compares the - contents of two svalues and returns true if the 'a' is lesser than - 'b'. It will give an error if the types are not comparable. - </text> - - <group><note/><text> - is_gt, is_ge and is_le are also available. They are all macros that - call this function. - - svalue</text></group> - - <group><seealso/><text> - <ref resolved='c::is_eq' to='is_eq'>is_eq</ref> and <ref resolved='c::is_equal' to='is_equal'>is_equal</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='low_level' homogen-type='method'> - <method name='low_level'/><doc placeholder='true'> - <text> - <tt>low_level</tt> - low level routines supplied by pike - - These functions are here to help you write fast and portable modules. - Pike itself also uses them for the same purpose. - - internals</text> - - </doc> - </docgroup> - <docgroup homogen-name='low_mapping_lookup' homogen-type='method'> - <method name='low_mapping_lookup'/><doc placeholder='true'> - <text> - <tt>low_mapping_lookup</tt> - lookup a key in a mapping - - <tt>#include "mapping.h" - - - struct svalue *low_mapping_lookup(struct mapping *m, - <dl><group><text>struct svalue *key); - </text></group></dl> - </tt> - This function looks up the key-index pair that has the key 'key' in - the mapping 'm' and returns a pointer to the 'value'. If no such - key-index pair is found, zero is returned. - </text> - - <group><note/><text> - Any call to an internal Pike function may re-allocate the mapping - 'm', which means that the pointer returned from this call is only - valid until your next function call. - </text></group> - - <group><note/><text> - This function is intended for _reading_ mappings, it is forbidden - to change the contents of the returned svalue. - - mapping</text></group> - - <group><seealso/><text> - <ref to='map_insert'>map_insert</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='m_sizeof' homogen-type='method'> - <method name='m_sizeof'/><doc placeholder='true'> - <text> - <tt>m_sizeof</tt> - return the number of key-value pairs in a mapping - - <tt>#include "mapping.h" - - - int m_sizeof(struct mapping *m) - - </tt> - This function returns the number of key-index pairs in the mapping, - just like the function sizeof() in Pike. - </text> - - <group><note/><text> - m_sizeof is a macro - - mapping</text></group> - - </doc> - </docgroup> - <docgroup homogen-name='make_shared_binary_string' homogen-type='method'> - <method name='make_shared_binary_string'/><doc placeholder='true'> - <text> - <tt>make_shared_binary_string</tt> - make a shared string - - <tt>#include "stralloc.h" - - - struct pike_string *make_shared_binary_string(const char *str, int len); - - </tt> - This function makes a shared string from the memory area beginning - at 'str' and ends at str+len. The returned string will have one - extra reference. - - pike_string</text> - - <group><seealso/><text> - <ref resolved='c::make_shared_string' to='make_shared_string'>make_shared_string</ref>, <ref resolved='c::begin_shared_string' to='begin_shared_string'>begin_shared_string</ref>, <ref resolved='c::push_string' to='push_string'>push_string</ref> and <ref resolved='c::free_string' to='free_string'>free_string</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='make_shared_string' homogen-type='method'> - <method name='make_shared_string'/><doc placeholder='true'> - <text> - <tt>make_shared_string</tt> - make a shared string - - <tt>#include "stralloc.h" - - - struct pike_string *make_shared_string(const char *str); - - </tt> - This function does the same thing as make_shared_binary_string, but - expects a zero terminated string instead. - - pike_string</text> - - <group><seealso/><text> - <ref resolved='c::make_shared_binary_string' to='make_shared_binary_string'>make_shared_binary_string</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='map_delete' homogen-type='method'> - <method name='map_delete'/><doc placeholder='true'> - <text> - <tt>map_delete</tt> - delete an item from a mapping - - <tt>#include "mapping.h" - - - void map_delete(struct mapping *m, struct svalue *key); - - </tt> - This function removes the key-index pair that has they key 'key' - from the mapping. If there is no such key-index pair in the mapping - nothing will be done. - - mapping</text> - - <group><seealso/><text> - <ref resolved='c::mapping_insert' to='mapping_insert'>mapping_insert</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='mapping' homogen-type='method'> - <method name='mapping'/><doc placeholder='true'> - <text> - <tt>mapping</tt> - internal pike mappings - - 'struct mapping' is the C representation of a Pike mapping. The struct - itself contains no user servicable parts except for the member 'refs' - which has to be increased when putting a 'struct mapping *' into a - svalue. Never _ever_ decrease the ref counter manually, use - free_mapping instead. Also note that you should never ever allocate - a mapping statically, you should always use the functions provided by - pike to allocate mappings. - - A mapping is basically a hash table with a linked list of key-value - pairs in each hash bin. The hash table and the key-index pairs are - allocated together in one large block to minimize memory fragmentation. - Also note that whenever you search for a specific key-value pair in - the mapping that key-value pair is propagated to the top of the linked - list in that hash bin, which makes the search time very very small for - most cases. - - internals</text> - - </doc> - </docgroup> - <docgroup homogen-name='mapping_indices' homogen-type='method'> - <method name='mapping_indices'/><doc placeholder='true'> - <text> - <tt>mapping_indices</tt> - return all the keys from a mapping - - <tt>#include "mapping.h" - - - struct array *mapping_indices(struct mapping *m) - - </tt> - This function returns an array with all the keys from the mapping m. - The keys in the array are ordered in the same order as the values - when using mapping_values. But only if no other mapping operations - are done in between. - - mapping</text> - - <group><seealso/><text> - <ref resolved='c::mapping_values' to='mapping_values'>mapping_values</ref> and <ref resolved='c::mkmapping' to='mkmapping'>mkmapping</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='mapping_insert' homogen-type='method'> - <method name='mapping_insert'/><doc placeholder='true'> - <text> - <tt>mapping_insert</tt> - insert a key-value pair into a mapping - - <tt>#include "mapping.h" - - - void mapping_insert(struct mapping *m, - <dl><group><text>struct svalue *key, - struct svalue *value) - </text></group></dl> - </tt> - This function inserts a new key-value pair into the mapping m. - If there is a already key-value pair with the same key in the mapping - it will be replaced with the new key-value pair. If there isn't - such a key-value pair in the mapping the mapping will grow in size - to accomodate the new key-value pair. This is identical to the - Pike operation: m[key]=value - - mapping</text> - - <group><seealso/><text> - <ref resolved='c::map_delete' to='map_delete'>map_delete</ref> and <ref resolved='c::low_mapping_lookup' to='low_mapping_lookup'>low_mapping_lookup</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='mapping_replace' homogen-type='method'> - <method name='mapping_replace'/><doc placeholder='true'> - <text> - <tt>mapping_replace</tt> - replace values in a mapping - - <tt>#include "mapping.h" - - - void mapping_replace(struct mapping *m, - <dl><group><text>struct svalue *from, - struct svalue *to) - </text></group></dl> - </tt> - This function replaces all values of the value 'from' in the mapping - 'm' with 'to'. It is a part of the Pike function replace(). - - mapping</text> - - </doc> - </docgroup> - <docgroup homogen-name='mapping_values' homogen-type='method'> - <method name='mapping_values'/><doc placeholder='true'> - <text> - <tt>mapping_values</tt> - return all the values from a mapping - - <tt>#include "mapping.h" - - - struct array *mapping_values(struct mapping *m) - - </tt> - This function returns an array with all the values from the mapping m. - The values in the array are ordered in the same order as the keys - when using mapping_indices, but only if no other mapping operations - are done between the mapping_values and the mapping_indices. - </text> - - <group><example/><text> - <tt>struct mapping *slow_copy_mapping(struct mapping *m) - { - <dl><group><text>struct array *indices, *values; - indices=mapping_indices(m); - values=mapping_indices(m); - m=mkmapping(indices,values); - free_array(indices); - free_array(values); - return m; - </text></group></dl>} - - </tt> - mapping</text></group> - - <group><seealso/><text> - <ref resolved='c::mapping_indices' to='mapping_indices'>mapping_indices</ref>, <ref resolved='c::copy_mapping' to='copy_mapping'>copy_mapping</ref> and <ref resolved='c::mkmapping' to='mkmapping'>mkmapping</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='memory_search' homogen-type='method'> - <method name='memory_search'/><doc placeholder='true'> - <text> - <tt>memory_search</tt> - search memory for a sequence of bytes - - <tt><matrix> - <r><c> #include "memory.h" </c></r> - <r><c> </c></r> - <r><c> char *memory_search(struct mem_searcher *s, </c></r> - <r><c> </c><c> </c><c> char *haystack, SIZE_T haystacklen); </c></r> - </matrix> - - </tt> - This function searches through a memory region (called 'haystack') - for a sequence of bytes (called 'needle'). If found, a pointer to - the first occurance of 'needle' in 'haystack' is returned. The needle - is given by calling init_memsearch to initialize a struct mem_searcher - that can then be used with this function. - - low_level</text> - - <group><seealso/><text> - <ref resolved='c::init_memsearch' to='init_memsearch'>init_memsearch</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='mkmapping' homogen-type='method'> - <method name='mkmapping'/><doc placeholder='true'> - <text> - <tt>mkmapping</tt> - make a mapping - - <tt>#include <mapping.h> - - - struct mapping *mkmapping(struct array *keys, struct array *values) - - </tt> - This function is the same as the Pike function mkmapping. It - makes a mapping out of an array of keys and an array of values. - Note that the returned mapping will have one extra reference. - - mapping</text> - - <group><seealso/><text> - <ref resolved='c::mapping_indices' to='mapping_indices'>mapping_indices</ref> and <ref resolved='c::mapping_values' to='mapping_values'>mapping_values</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='my_strcmp' homogen-type='method'> - <method name='my_strcmp'/><doc placeholder='true'> - <text> - <tt>my_strcmp</tt> - my own strcmp function - - <tt>#include "stralloc.h" - - - int my_strcmp(struct pike_string *a, struct pike_string *b) - - </tt> - This function compares two pike strings and takes locales into - account if the system supports locales. It returns zero if the - strings are the same, a number greater than zero zero if 'a' - is greater than 'b', and a number below zero otherwise. - - pike_string</text> - - <group><seealso/><text> - <ref resolved='c::make_shared_string' to='make_shared_string'>make_shared_string</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='object' homogen-type='method'> - <method name='object'/><doc placeholder='true'> - <text> - <tt>object</tt> - internal representation of an object - - Pike uses a 'struct object' with all the global variables - allocated in the same block to represent the Pike type 'object'. - An object without any global variables is only the size of 4 C - pointers. (usually 16 bytes) The only important members of the - 'struct object' are the ref counts and the pointer to the - program from which the object was cloned. - - internals</text> - - </doc> - </docgroup> - <docgroup homogen-name='pike_string' homogen-type='method'> - <method name='pike_string'/><doc placeholder='true'> - <text> - <tt>pike_string</tt> - internal pike shared strings - - This is the internal type for representing pike strings. They have - ref counts and they are shared though a global hash table. The C - type is a struct pike_string that has two public members: str and - len. str is an array of char which contain the actual string. It - is guaranteed that the string is null terminated, but the string - can also contain zeroes before the end. len is of course the - length of the string. Since strings are shared you may _never_ - modify the contents of a string, except for adding/subtracting - references when approperiate. The only exception to this is when - creating a new shared string with begin_shared_string which has - not yet been linked to the hash table with end_shared_string. - - internals</text> - - </doc> - </docgroup> - <docgroup homogen-name='program' homogen-type='method'> - <method name='program'/><doc placeholder='true'> - <text> - <tt>program</tt> - internal representation of a program - - A 'struct program' is basically what C++ hackers call a 'class'. - It contains the byte code, information about line numbers, - global variables etc. etc. Mostly you won't have to bother with - any of the contents of a 'struct program'. Usually you only need - to create them with start_new_program()/end_c_program() or - clone them with clone(). - </text> - - <group><seealso/><text> - <ref resolved='c::frame' to='frame'>frame</ref> - - internals</text></group> - - </doc> - </docgroup> - <docgroup homogen-name='push_array_items' homogen-type='method'> - <method name='push_array_items'/><doc placeholder='true'> - <text> - <tt>push_array_items</tt> - push array contents on stack - - <tt>#include "array.h" - - - void push_array_items(struct array *a) - - </tt> - This function is mainly used by the @ operator. It pushes all elements - in the array 'a' on the stack. It also frees one ref count on 'a', so - be sure to do a->refs++ first if you want to use the array after - calling this function. This function also calls check_stack properly. - - array</text> - - <group><seealso/><text> - <ref resolved='c::aggregate_array' to='aggregate_array'>aggregate_array</ref> and <ref to='check_stack'>check_stack</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='push_string' homogen-type='method'> - <method name='push_string'/><doc placeholder='true'> - <text> - <tt>push_string</tt> - push a string on the pike stack - - <tt>#include "interpret.h" - - - void push_string(struct pike_string *p) - - </tt> - <matrix> - <r><c> This function pushes the string p on the pike stack. Note that this </c></r> - <r><c> function does _not_ add any extra references to 'p'. Most functions </c></r> - <r><c> that create shared strings give one extra reference to them though. </c></r> - <r><c> If you get your string from a function that does not add extra </c><c> </c></r> - <r><c> references you will have to add a reference manually. </c></r> - </matrix> - - </text> - - <group><note/><text> - push_string is actually a macro - - pike_string</text></group> - - </doc> - </docgroup> - <docgroup homogen-name='reorder' homogen-type='method'> - <method name='reorder'/><doc placeholder='true'> - <text> - <tt>reorder</tt> - re-order an array of memory blocks - - <tt>#include "memory.h" - - - void reorder(char *memory, INT32 nitems, INT32 size,INT32 *order); - - </tt> - This function takes an array of memory blocks and re-organizes them - according to the argument 'order'. 'nitems' tells how many memory - blocks there are, and 'size' tells how big they are in bytes. - 'order' is simply an array of INT32 of size 'nitems' in which each - int tells which memory block from 'memory' should be placed in that - position. In pseudo code, this could be written as: - - mem_copy=copy_memory(memory); - for(int e=0;e<nitems;e++) - <dl><group><text>memory[e]=mem_copy[order[e]]; - </text></group></dl> - - low_level</text> - - </doc> - </docgroup> - <docgroup homogen-name='resize_array' homogen-type='method'> - <method name='resize_array'/><doc placeholder='true'> - <text> - <tt>resize_array</tt> - change the size of an array destructively - - <tt>#include "array.h" - - - struct array *resize_array(struct array *a, INT32 new_size); - - </tt> - This function makes an array from 'a' with the size 'new_size'. - Note that the returned might or might not be the same as 'a'. - If 'a' is too small or too big for 'new_size', a copy of 'a' will - be made with enough room and then 'a' will be freed. This means - that you can only use this function on arrays which has not been - passed to any lpc functions yet. - - array</text> - - <group><seealso/><text> - <ref to='array_insert'>array_insert</ref> and <ref resolved='c::array_remove' to='array_remove'>array_remove</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='set_close_on_exec' homogen-type='method'> - <method name='set_close_on_exec'/><doc placeholder='true'> - <text> - <tt>set_close_on_exec</tt> - set the close-on-exec flag on a filedescriptor - - <tt>#include "fd_control.h" - - - void set_close_on_exec(int fd, int onoff) - - </tt> - This function sets the close-on-exec flag on a filedescriptor. If - onoff is true, the filedescriptor will be closed whenever an exec() - is executed. If it is false, the fildescriptor will remain open. - - low_level</text> - - <group><seealso/><text> - <ref resolved='c::set_nonblocking' to='set_nonblocking'>set_nonblocking</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='set_exit_callback' homogen-type='method'> - <method name='set_exit_callback'/><doc placeholder='true'> - <text> - <tt>set_exit_callback</tt> - set function to call att destruct() - - <tt>#include "program.h" - - - void set_exit_callback(void (*exit)(struct object *) fun); - - </tt> - This function sets what function will be called when an object - cloned from your program is destructed. This function is - mainly for de-initializing the fp->current_storage region. - The function will be called with the object about to be destructed - as argument. - - program</text> - - <group><seealso/><text> - <ref resolved='c::start_new_program' to='start_new_program'>start_new_program</ref> and <ref resolved='c::set_init_callback' to='set_init_callback'>set_init_callback</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='set_init_callback' homogen-type='method'> - <method name='set_init_callback'/><doc placeholder='true'> - <text> - <tt>set_init_callback</tt> - set function to call att clone() - - <tt>#include "program.h" - - - void set_init_callback(void (*init)(struct object *) fun); - - </tt> - This function sets what function will be called when someone - clones the struct program your are building. This function is - mainly for initializing the fp->current_storage region. - The initalizer function will be called with the newly cloned - object as argument. - - program</text> - - <group><seealso/><text> - <ref resolved='c::start_new_program' to='start_new_program'>start_new_program</ref> and <ref resolved='c::set_exit_callback' to='set_exit_callback'>set_exit_callback</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='set_nonblocking' homogen-type='method'> - <method name='set_nonblocking'/><doc placeholder='true'> - <text> - <tt>set_nonblocking</tt> - set a filedescriptor nonblocking - - <tt>#include "fd_control.h" - - - void set_nonblocking(int fd, int onoff) - - </tt> - This function sets a filedescriptor in nonblocking mode. Nonblocking - mode means that any read() or write() exits insteads of waits when - no more data can be read/written immediately. If 'onoff' is true, - the fd will be set to nonblocking, otherwise it will be set to - blocking mode. - - low_level</text> - - <group><seealso/><text> - <ref resolved='c::set_close_on_exec' to='set_close_on_exec'>set_close_on_exec</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='set_read_callback' homogen-type='method'> - <method name='set_read_callback'/><doc placeholder='true'> - <text> - <tt>set_read_callback</tt> - set 'data available' callback - - <tt>#include "backend.h" - - - void set_read_callback(int fd,file_callback cb,void *data); - - </tt> - This function sets what function should be called when there is - more data to be read from 'fd'. The 'file_callback' should be a - function like this: - - void file_callback(int fd, void *data); - - The arguments are the same as sent to set_read_callback(). - To disable the read callback, call set_read_callback again with - cb and data equal to zero. - - low_level</text> - - <group><seealso/><text> - <ref to='set_write_callback'>set_write_callback</ref> and <ref resolved='c::set_nonblocking' to='set_nonblocking'>set_nonblocking</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='set_read_callback' homogen-type='method'> - <method name='set_read_callback'/><doc placeholder='true'> - <text> - <tt>set_read_callback</tt> - set 'buffer available' callback - - <tt>#include "backend.h" - - - void set_write_callback(int fd,file_callback cb,void *data); - - </tt> - This function sets what function should be called when there is - time to write more data to 'fd'. The 'file_callback' should be a - function like this: - - void file_callback(int fd, void *data); - - The arguments are the same as sent to set_write_callback(). - To disable the write callback, call set_write_callback again with - cb and data equal to zero. - - low_level</text> - - <group><seealso/><text> - <ref resolved='c::set_read_callback' to='set_read_callback'>set_read_callback</ref> and <ref resolved='c::set_nonblocking' to='set_nonblocking'>set_nonblocking</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='slice_array' homogen-type='method'> - <method name='slice_array'/><doc placeholder='true'> - <text> - <tt>slice_array</tt> - slice a pice of an array - - <tt>#include "array.h" - - - struct array *slice_array(struct array *a, INT32 start, INT32 end); - - </tt> - This is the equivialent of the pike operation a[start..end]. A new - array will be returned with one reference. - - array</text> - - </doc> - </docgroup> - <docgroup homogen-name='start_new_program' homogen-type='method'> - <method name='start_new_program'/><doc placeholder='true'> - <text> - <tt>start_new_program</tt> - start building a new 'struct program' - - <tt>#include "program.h" - - - void start_new_program(void); - - </tt> - This function initalizes a new 'struct program' to be be fitted - with functions, variables, inherits etc. etc. - - program</text> - - <group><seealso/><text> - <ref resolved='c::end_c_program' to='end_c_program'>end_c_program</ref>, <ref resolved='c::add_function' to='add_function'>add_function</ref> and <ref resolved='c::add_storage' to='add_storage'>add_storage</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='string_replace' homogen-type='method'> - <method name='string_replace'/><doc placeholder='true'> - <text> - <tt>string_replace</tt> - do string replacements - - <tt>#include "stralloc.h" - - - struct pike_string *string_replace(struct pike_string *str, - <dl><group><text>struct pike_string *from, - struct pike_string *to); - </text></group></dl> - </tt> - This function builds a new string from 'str' with all occurances - of 'from' replaced by 'to'. Note that the new string will have one - extra reference. - - pike_string</text> - - </doc> - </docgroup> - <docgroup homogen-name='svalue' homogen-type='method'> - <method name='svalue'/><doc placeholder='true'> - <text> - <tt>svalue</tt> - internal type for storing Pike values - - The 'struct svalue' contains one Pike 'value', variables, arrays - and the evaluator are all svalues. An svalue consists of three - elements: type, subtype and a union containing the actual value. - The type is a short which tells you what type the svalue is. The - value is one of the following: - - <matrix> - <r><c> T_ARRAY </c><c> When type is T_ARRAY, the array is stored in </c></r> - <r><c> </c></r> - </matrix> - <dl><group><text><matrix> - <r><c> </c><c> the 'array' member of the union. So if sval is </c></r> - <r><c> </c></r> - </matrix> - <matrix> - <r><c> </c><c> the pointer to the svalue, you would use sval->u.array </c></r> - <r><c> </c></r> - </matrix> - <matrix> - <r><c> </c><c> to access the actual array. </c></r> - <r><c> </c></r> - </matrix> - </text></group></dl><matrix> - <r><c> T_MAPPING </c><c> In this case, you use sval->u.mapping. </c></r> - <r><c> T_MULTISET </c><c> sval->u.multiset </c></r> - <r><c> T_OBJECT </c><c> sval->u.object </c></r> - <r><c> T_FUNCTION </c><c> Functions are a bit more difficult, sval->u.object </c></r> - </matrix> - <dl><group><text><matrix> - <r><c> </c><c> is the object the function is in, and sval->subtype </c></r> - <r><c> </c></r> - </matrix> - <matrix> - <r><c> </c><c> is the number of the function in that object. </c></r> - <r><c> </c></r> - </matrix> - </text></group></dl><matrix> - <r><c> T_PROGRAM </c><c> sval->u.program is the struct program you want. </c></r> - <r><c> T_STRING </c><c> sval->u.string </c></r> - <r><c> T_FLOAT </c><c> sval->u.float_number </c></r> - <r><c> T_INT </c><c> sval->u.integer, a special case is that sval->subtype </c></r> - </matrix> - <dl><group><text><matrix> - <r><c> </c><c> is used in some cases to represent the value </c></r> - <r><c> </c><c> 'undefined'. This is what zero_type detects. </c></r> - </matrix> - </text></group></dl> - - There are lots of functions operating on svalues, so you shouldn't - have to do all that much stuff with them yourself. However, for now - you do need to check the type and extract the proper member of the - union yourself when writing your own C functions for Pike. - - internals</text> - - </doc> - </docgroup> - <docgroup homogen-name='throw' homogen-type='method'> - <method name='throw'/><doc placeholder='true'> - <text> - <tt>throw</tt> - throw an exception - - <tt>#include "error.h" - - - int throw(void); - - </tt> - This function calls longjmp and does all the cleanup and popping - the Pike stack etc. etc. This function does not setup any error - message or backtrace like error() does. error() calls this function - after doing all that. Since this function calls longjmp, it does - not return. See SETJMP for more details. - - error_handling</text> - - <group><seealso/><text> - <ref resolved='c::SETJMP' to='SETJMP'>SETJMP</ref> and <ref resolved='c::error' to='error'>error</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='type_field' homogen-type='method'> - <method name='type_field'/><doc placeholder='true'> - <text> - <tt>type_field</tt> - bit field used for optimizations - - Type fields are used by arrays, mappings and some svalue operations - for optimization. The type field consists of OR:ed bits, one for - each type. The bit for an array is 1<<T_ARRAY (same as BIT_ARRAY) - The bit for a string is 1<<T_STRING (or BIT_STRING) etc. - - A bit field never has to be exact, it needs to have at least those - bits that are present in the operation. It is never harmful to have - too many bits though. It seldom pays off to calculate the bit field - explicitly, so if you don't know what types are involved you should - use -1 for the type field. - - data_types</text> - - <group><seealso/><text> - <ref resolved='c::mapping' to='mapping'>mapping</ref>, <ref resolved='c::array' to='array'>array</ref> and <ref resolved='c::svalue' to='svalue'>svalue</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='types' homogen-type='method'> - <method name='types'/><doc placeholder='true'> - <text> - <tt>types</tt> - how to describe types internally - - When describing types to add_function or add_efun you always write - it in a string. You write the type just as you would in Pike. The - internal types have a few extra features though. Here is a brief - explanation of the syntax: - - <matrix> - <r><c> type </c><c> you write: </c></r> - <r><c> int </c><c> "int" </c></r> - <r><c> float </c><c> "float" </c></r> - <r><c> string </c><c> "string" </c></r> - <r><c> mapping </c><c> "mapping(mixed:mixed)" or "mapping" </c></r> - <r><c> array of int </c><c> </c><c> "array(int)" or "int *" </c></r> - <r><c> function(int:int) </c><c> "function(int:int)" </c></r> - <r><c> varargs function </c><c> "function(int ...:int)" </c></r> - <r><c> int or string </c><c> </c><c> "int|string" </c></r> - </matrix> - - - Then there are a few tricks you can use, say you have a function which - returns an int except if you call it with a string in which case it - return a string: - - "!function(string:mixed)&function(mixed:int)|function(string:string)" - - The & and ! operators work as you might expect but are only useful - together. - - data_types</text> - - <group><seealso/><text> - <ref resolved='c::add_function' to='add_function'>add_function</ref> and <ref to='add_efun'>add_efun</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='xalloc' homogen-type='method'> - <method name='xalloc'/><doc placeholder='true'> - <text> - <tt>xalloc</tt> - fail-safe memory allocation - - <tt>#include "memory.h" - - - char *xalloc(long size); - - </tt> - This function works exactly like the malloc() function, it will - never return NULL. Instead it will try to free up any pike resources - that are not needed any longer and try again. If that doesn't work - either it will call fatal("out of memory\n"); and Pike will dump core. - This type of error handling makes it easier to code, but is not - always what you want. - - low_level</text> - - </doc> - </docgroup> - </namespace> - <namespace name='cpp'> - <doc placeholder='true'> - <text> - <tt>preprocessor</tt> - textually process code before compiling - - Pike has a builtin C-style preprocessor. It works similar to old - C preprocessors but has a few extra features. This file describes - the different preprocessor directives. - - <tt><dl><group><text>#! - #define - #elif - #else - #elseif - #endif - #error - #if - #ifdef - #ifndef - #include - #line - #pragma - #undef - </text></group></dl> - </tt> - pike</text> - - </doc> - <docgroup homogen-name='#!' homogen-type='directive'> - <directive name='#!'> - </directive> - <doc placeholder='true'> - <text> - - This directive is in effect a comment statement, since the - preprocessor will ignore everything to the end of the line. - This is used to write unix type scripts in Pike by starting - the script with - - #!/usr/local/bin/pike - - </text> - - </doc> - </docgroup> - <docgroup homogen-name='#define' homogen-type='directive'> - <directive name='#define'> - </directive> - <doc placeholder='true'> - <text> - - The simplest way to use define is to write - - <dl><group><text>#define <identifier> <replacement string> - </text></group></dl> - - which will cause all subsequent occurances of 'identifier' to be - replaced with the replacement string. - - Define also has the capability to use arguments, thus a line like - - <dl><group><text>#define <identifier>(arg1, arg2) <replacement string> - </text></group></dl> - - would cause identifer to be a macro. All occurances of - 'identifier(something1,something2d)' would be replaced with - the replacement string. And in the replacement string, arg1 and arg2 - will be replaced with something1 and something2. - </text> - - <group><bugs/><text> - Note that it is not a good idea to do something like this: - - #define foo bar // a comment - - The comment will be included in the define, and thus inserted in the - code. This will have the effect that the rest of the line will be - ignored when the word foo is used. Not exactly what you might expect. - - - </text></group> - - </doc> - </docgroup> - <docgroup homogen-type='directive'> - <directive name='#if'> - </directive> - <directive name='#elif'> - </directive> - <directive name='#elseif'> - </directive> - <directive name='#else'> - </directive> - <directive name='#endif'> - </directive> - <doc placeholder='true'> - <text> - - The #if directive causes conditional compiling of code depending on - the expression after the #if directive. That is, if the expression - is true, the code up to the next #else, #elif, #elseif or #endif is - compiled. If the expression is false, that code will be skipped. - If the skip leads up to a #else, the code after the else will be - compiled. #elif and #elseif are equivialent and causes the code that - follow them to be compiled if the previous #if or #elif evaluated - false and the expression after the #elif evaluates true. - - Expressions given to #if, #elif or #endif are special, all identifiers - evaluate to zero unless they are defined to something else. Integers, - strings and floats are the only types that can be used, but all pike - operators can be used on these types. - - Also, two special functions can be used, defined() and constant(). - defined(<identifer>) expands to '1' if the identifier is defined, - '0' otherwise. constant(<identifier>) expands to '1' if identifer is - an predefined constant (with add_constant), '0' otherwise. - </text> - - <group><example/><text> - <tt>#if 1 - <dl><group><text>write("foo"); - </text></group></dl>#else - <dl><group><text>write("bar"); - </text></group></dl>#endif - - - #if defined(FOO) - <dl><group><text>write(FOO); - </text></group></dl>#elif defined(BAR) - <dl><group><text>write(BAR); - </text></group></dl>#else - <dl><group><text>write("default"); - </text></group></dl>#endif - - - #if !constant(write_file) - inherit "simulate.pike" - #endif - - - </tt></text></group> - - </doc> - </docgroup> - <docgroup homogen-name='#error' homogen-type='directive'> - <directive name='#error'> - </directive> - <doc placeholder='true'> - <text> - - This directive causes a compiler error, it can be used to notify - the user that certain functions are missing and similar things. - </text> - - <group><example/><text> - <tt>#if !constant(write_file) - #error write_file efun is missing - #endif - - - </tt></text></group> - - </doc> - </docgroup> - <docgroup homogen-name='#include' homogen-type='directive'> - <directive name='#include'> - </directive> - <doc placeholder='true'> - <text> - - This directive should be given a file as argument, it will then be - compiled as if all those lines were written at the #include line. - The compiler then continues to compile this file. - </text> - - <group><example/><text> - <tt>#include "foo.h" - - - </tt></text></group> - - </doc> - </docgroup> - <docgroup homogen-name='#line' homogen-type='directive'> - <directive name='#line'> - </directive> - <doc placeholder='true'> - <text> - - This directive tells the compiler what line and file we are compiling. - This is for instance used by the #include directive to tell the - compiler that we are compiling another file. The directive takes - the line number first, and optionally, the file afterwards. - - This can also be used when generating pike from something else, to - tell teh compiler where the code originally originated from. - </text> - - <group><example/><text> - <tt>#line 4 "foo.cf" /* The next line was generated from 4 in foo.cf */ - - - </tt></text></group> - - </doc> - </docgroup> - <docgroup homogen-name='#pragma' homogen-type='directive'> - <directive name='#pragma'> - </directive> - <doc placeholder='true'> - <text> - - This is a generic directive for flags to the compiler. Currently, the - only flag available is 'all_inline' which is the same as adding the - modifier 'inline' to all functions that follows. - - </text> - - </doc> - </docgroup> - <docgroup homogen-name='#undef' homogen-type='directive'> - <directive name='#undef'> - </directive> - <doc placeholder='true'> - <text> - - This removes the effect of a #define, all subsequent occurances of - the undefined identifier will not be replaced by anything. Note that - when undefining a macro, you just give the identifer, not the - arguments. - </text> - - <group><example/><text> - <tt>#define foo bar - #undef foo - #define foo(bar) gazonk bar - #undef foo - - - </tt></text></group> - - </doc> - </docgroup> - </namespace> + <namespace name='predef'> - <docgroup homogen-name='&&' homogen-type='method'> - <method name='&&'/><doc placeholder='true'> - <text> - <tt>&&</tt> - logical and - - <tt>a && b - - </tt> - This operator does logical 'and' between expressions. It first - evaluates a and returns zero if a is zero. Otherwise it returns - b. Note that b is not evaluated at all if a returns zero. - - operators</text> - - <group><seealso/><text> - <ref resolved='predef::`&' to='`&'>`&</ref> and <ref resolved='predef::&&' to='||'>||</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='PI' homogen-type='constant'> - <constant name='PI'/><doc placeholder='true'> - <text> - <tt>PI</tt> - pi - - <tt>#include <simulate.h> - - - PI - - </tt> - This is not a function, it is a constant added by simulate.pike. - - float</text> - - </doc> - </docgroup> + <docgroup homogen-name='_do_call_outs' homogen-type='method'> <method name='_do_call_outs'/><doc placeholder='true'> <text>
2188: </text> <group><seealso/><text> - <ref resolved='predef::call_out' to='call_out'>call_out</ref>, <ref resolved='predef::remove_call_out' to='remove_call_out'>remove_call_out</ref>, <ref resolved='predef::call_out_info' to='call_out_info'>call_out_info</ref> and <ref resolved='predef::time' to='time'>time</ref> + <ref resolved='predef::call_out' to='call_out'>call_out</ref>, <ref resolved='predef::remove_call_out' to='remove_call_out'>remove_call_out</ref>, <ref resolved='predef::call_out_info' to='call_out_info'>call_out_info</ref> and <ref to='time'>time</ref> </text></group> </doc> </docgroup> - <docgroup homogen-name='_memory_usage' homogen-type='method'> - <method name='_memory_usage'/><doc placeholder='true'> - <text> - <tt>_memory_usage</tt> - check memory usage - - <tt>mapping(string:int) _memory_usage(); - - </tt> - This function is mostly intended for debugging. It delivers a mapping - with information about how many arrays/mappings/strings etc. there - are currently allocated and how much memory they use. Try evaluating - the function in hilfe to see precisly what it returns. - </text> - - <group><seealso/><text> - <ref resolved='predef::_verify_internals' to='_verify_internals'>_verify_internals</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='_next' homogen-type='method'> - <method name='_next'/><doc placeholder='true'> - <text> - <tt>_next</tt> - find the next object/array/whatever - - <tt>mixed _next(mixed p); - - </tt> - This function returns the 'next' object/array/mapping/string/etc - in the linked list. It is mainly meant for debugging Pike but - can also be used to control memory usage. - </text> - - <group><seealso/><text> - <ref resolved='predef::next_object' to='next_object'>next_object</ref> and <ref resolved='predef::_prev' to='_prev'>_prev</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='_prev' homogen-type='method'> - <method name='_prev'/><doc placeholder='true'> - <text> - <tt>_prev</tt> - find the previous object/array/whatever - - <tt>mixed _next(mixed p); - - </tt> - This function returns the 'previous' object/array/mapping/etc - in the linked list. It is mainly meant for debugging Pike but - can also be used to control memory usage. Note that this function - does not work on strings. - </text> - - <group><seealso/><text> - <ref resolved='predef::_next' to='_next'>_next</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='_verify_internals' homogen-type='method'> - <method name='_verify_internals'/><doc placeholder='true'> - <text> - <tt>_verify_internals</tt> - check Pike internals - - <tt>void _verify_internals(); - - </tt> - This function goes through most of the internal Pike structures and - generates a fatal error if one of them is found to be out of order. - It is only used for debugging. - - debugging</text> - - </doc> - </docgroup> - <docgroup homogen-name='`!' homogen-type='method'> - <method name='`!'/><doc placeholder='true'> - <text> - <tt>`!</tt> - is not true - - <tt>! a - or - int `!(mixed a) - - </tt> - Returns 1 if a is zero, 0 otherwise. - - operators</text> - - </doc> - </docgroup> - <docgroup homogen-name='`!=' homogen-type='method'> - <method name='`!='/><doc placeholder='true'> - <text> - <tt>`!=</tt> - check if not equal - - <tt>a != b - or - int `!=(mixed a, mixed b) - - </tt> - This operator compares two values and returns 0 if they are the same, - 1 otherwise. Note that pointer equivialenec is required for arrays, - objects, programs, mappings and multisets. (Thus it is not enough that - two arrays LOOK alike, it must be the same array.) - - operators</text> - - <group><seealso/><text> - <ref resolved='predef::`==' to='`=='>`==</ref>, <ref resolved='predef::`<' to='`<'>`<</ref>, <ref resolved='predef::`>' to='`>'>`></ref>, <ref resolved='predef::`<=' to='`<='>`<=</ref>, <ref resolved='predef::`>=' to='`>='>`>=</ref> and <ref to='efuns/equal'>efuns/equal</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='`%' homogen-type='method'> - <method name='`%'/><doc placeholder='true'> - <text> - <tt>`%</tt> - modulo - - <tt>a % b - or - int `%(int a, int b) - or - float `%(int|float a,int|float b) - - </tt> - This operator computes the rest of a division. For integers, this - is the same as same as computing a-(a/b)*a. For floats, modulo is - interpreted as a-floor(a/b)*a - - </text> - - <group><example/><text> - <tt><matrix> - <r><c> 9%3 </c><c> returns 0 </c></r> - <r><c> 10%3 </c><c> returns 1 </c></r> - <r><c> 2%0.3 </c><c> returns 0.2 </c></r> - </matrix> - - </tt> - operators</text></group> - - <group><seealso/><text> - <ref resolved='predef::`/' to='`/'>`/</ref> and <ref resolved='predef::`*' to='`*'>`*</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='`&' homogen-type='method'> - <method name='`&'/><doc placeholder='true'> - <text> - <tt>`&</tt> - intersection - - <tt>a & b - or - mixed `&(mixed ... args) - - </tt> - This operator does logical intersections. For ints this means - bitwise and. - - Arrays and multisets are treated as sets, so intersecting two arrays - will result in an array with containing all values present in all - arguments. - - For mappings, the intersection will be done on the indexes solely, - however, the values will be taken from the rightmost mapping. - - operators</text> - - <group><seealso/><text> - <ref resolved='predef::`|' to='`|'>`|</ref>, <ref resolved='predef::`^' to='`^'>`^</ref> and <ref resolved='predef::`&' to='&&'>&&</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='`*' homogen-type='method'> - <method name='`*'/><doc placeholder='true'> - <text> - <tt>`*</tt> - multiplication - - <tt>a * b - or - int `*(int ... args) - or - float `*(int|float ... args) - or - string `*(string *strings, string delimeter) - - </tt> - For ints and floats, this operator simply multiplies its arguments. - If the first argument is an array, and the second a string, all - strings in the arrays will be concatenated, with the delimiter in - between each string and the result will be returned. - </text> - - <group><example/><text> - <tt><matrix> - <r><c> 2*2 </c><c> returns 4 </c></r> - <r><c> 2.0*2.0 </c><c> returns 4.0 </c></r> - <r><c> 2.0*2 </c><c> returns 4.0 </c></r> - <r><c> ({"f","",""})*"o") </c><c> Returns "foo" </c></r> - <r><c> `*(2,2,2) </c><c> returns 8 </c></r> - </matrix> - - </tt> - operators</text></group> - - <group><seealso/><text> - <ref resolved='predef::`/' to='`/'>`/</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='`+' homogen-type='method'> - <method name='`+'/><doc placeholder='true'> - <text> - <tt>`+</tt> - add things together - - <tt>a + b - or - mixed `+(mixed ... args) - - </tt> - For ints and floats this operator simply adds the two operators - together. For strings and arrays, concatenation is done. For multisets - and mapping this creates a new multiset/mapping with all indices and data as - in a and b. Note that this can cause a multiset to contain - several equal indices. Also, when adding a string to an int or float - the number is converted to a printable string first. - </text> - - <group><example/><text> - <tt><matrix> - <r><c> "a"+10 </c><c> returns "a10" </c></r> - <r><c> 10+20 </c><c> returns 30 </c></r> - <r><c> ({1})+({2}) </c><c> returns ({1,2}) </c></r> - <r><c> (<1>)+(<1>) </c><c> returns (<1,1>) </c></r> - <r><c> `+(2,2,2) </c><c> returns 6 </c></r> - </matrix> - - </tt> - operators</text></group> - - <group><seealso/><text> - <ref resolved='predef::`-' to='`-'>`-</ref> and <ref resolved='predef::`*' to='`*'>`*</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='`-' homogen-type='method'> - <method name='`-'/><doc placeholder='true'> - <text> - <tt>`-</tt> - subtract/negate - - <tt>- a - or - `-(mixed a); - or - a - b - or - mixed `-(mixed a, mixed b) - - </tt> - This is the negation and subtraction operator, for ints and floats - the operation should be obvious. - - For arrays, an array containing all elements present in a and not in - b is returne. The order of the remaining values from a will be kept. - - For multisets, the same operation is done as for arrays, except order is - of course not considered. - - <matrix> - <r><c> For mappings, a mapping is returned with every key-index pair from </c></r> - <r><c> a whos index is not present as an index in b. </c></r> - <r><c> EXAMPLES </c></r> - <r><c> 5-10 </c><c> returns -5 </c></r> - <r><c> 10-2.0 </c><c> returns 8.0 </c></r> - <r><c> ({1,2})-({2}) </c><c> returns ({1}) </c></r> - <r><c> ([1:2,2:1])-([1:0]) </c><c> returns ([2:1]) </c></r> - </matrix> - - - operators</text> - - <group><seealso/><text> - <ref resolved='predef::`+' to='`+'>`+</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='`/' homogen-type='method'> - <method name='`/'/><doc placeholder='true'> - <text> - <tt>`/</tt> - division - - <tt>a / b - or - int `/(int a, int b) - or - float `/(int|float a,int|float b) - or - string* `/(string a,string b) - - </tt> - For ints and floats, this operator simply divide its arguments. - If the arguments are strings, the first string will be divided - at every occurance of the second string. The resulting pieces - are then returned in the form of an array. - </text> - - <group><example/><text> - <tt><matrix> - <r><c> 2/2 </c><c> returns 1 </c></r> - <r><c> 3/2 </c><c> returns 1 </c></r> - <r><c> 2.0/2.0 </c><c> returns 1.0 </c></r> - <r><c> 2.0/2 </c><c> returns 1.0 </c></r> - <r><c> "foo"/"o" </c><c> returns ({"f","",""}) </c></r> - <r><c> `/(2,2) </c><c> returns 1 </c></r> - </matrix> - - </tt> - operators</text></group> - - <group><seealso/><text> - <ref resolved='predef::`*' to='`*'>`*</ref> and <ref resolved='predef::`%' to='`%'>`%</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='`<' homogen-type='method'> - <method name='`<'/><doc placeholder='true'> - <text> - <tt>`<</tt> - is lesser than? - - <tt>a < b - or - int `<(int|float|string a,int|float|string b) - - </tt> - This operator compares two values and returns 1 if the first one - is lesser than the second one. - - operators</text> - - <group><seealso/><text> - <ref resolved='predef::`!=' to='`!='>`!=</ref>, <ref resolved='predef::`==' to='`=='>`==</ref>, <ref resolved='predef::`>' to='`>'>`></ref>, <ref resolved='predef::`<=' to='`<='>`<=</ref> and <ref resolved='predef::`>=' to='`>='>`>=</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='`<<' homogen-type='method'> - <method name='`<<'/><doc placeholder='true'> - <text> - <tt>`<<</tt> - shift left - - <tt>a << b - or - int `<<(int a, int b) - - </tt> - This operator shift the integer a b steps left. This is equal to - multiplying a by 2 b times. - - operators</text> - - <group><seealso/><text> - <ref resolved='predef::`>>' to='`>>'>`>></ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='`<=' homogen-type='method'> - <method name='`<='/><doc placeholder='true'> - <text> - <tt>`<=</tt> - is lesser or equal than? - - <tt>a <= b - or - int `<=(int|float|string a,int|float|string b) - - </tt> - This operator compares two values and returns 1 if the first one - is lesser than or equal to the second one. - - operators</text> - - <group><seealso/><text> - <ref resolved='predef::`!=' to='`!='>`!=</ref>, <ref resolved='predef::`==' to='`=='>`==</ref>, <ref resolved='predef::`>' to='`>'>`></ref>, <ref resolved='predef::`<' to='`<'>`<</ref> and <ref resolved='predef::`>=' to='`>='>`>=</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='`==' homogen-type='method'> - <method name='`=='/><doc placeholder='true'> - <text> - <tt>`==</tt> - compare values - - <tt>a == b - or - int `==(mixed a, mixed b) - - </tt> - This operator compares two values and returns 1 if they are the same, - 0 otherwise. Note that pointer equivialenec is required for arrays, - objects, programs, mappings and multisets. (Thus it is not enough that - two arrays LOOK alike, it must be the same array.) - - operators</text> - - <group><seealso/><text> - <ref resolved='predef::`!=' to='`!='>`!=</ref>, <ref resolved='predef::`<' to='`<'>`<</ref>, <ref resolved='predef::`>' to='`>'>`></ref>, <ref resolved='predef::`<=' to='`<='>`<=</ref>, <ref resolved='predef::`>=' to='`>='>`>=</ref> and <ref to='efuns/equal'>efuns/equal</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='`>' homogen-type='method'> - <method name='`>'/><doc placeholder='true'> - <text> - <tt>`></tt> - is lesser than? - - <tt>a > b - or - int `>(int|float|string a,int|float|string b) - - </tt> - This operator compares two values and returns 1 if the first one - is greater than the second one. - - operators</text> - - <group><seealso/><text> - <ref resolved='predef::`!=' to='`!='>`!=</ref>, <ref resolved='predef::`==' to='`=='>`==</ref>, <ref resolved='predef::`<' to='`<'>`<</ref>, <ref resolved='predef::`<=' to='`<='>`<=</ref> and <ref resolved='predef::`>=' to='`>='>`>=</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='`>=' homogen-type='method'> - <method name='`>='/><doc placeholder='true'> - <text> - <tt>`>=</tt> - is greater than or equal to? - - <tt>a >= b - or - int `>=(int|float|string a,int|float|string b) - - </tt> - This operator compares two values and returns 1 if the first one - is greater than or equal to the second one. - - operators</text> - - <group><seealso/><text> - <ref resolved='predef::`!=' to='`!='>`!=</ref>, <ref resolved='predef::`==' to='`=='>`==</ref>, <ref resolved='predef::`>' to='`>'>`></ref>, <ref resolved='predef::`<' to='`<'>`<</ref> and <ref resolved='predef::`<=' to='`<='>`<=</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='`>>' homogen-type='method'> - <method name='`>>'/><doc placeholder='true'> - <text> - <tt>`>></tt> - shift right - - <tt>a >> b - or - int `>>(int a, int b) - - </tt> - This operator shift the integer a b steps right. This is equal to - dividing a by 2 b times. - - operators</text> - - <group><seealso/><text> - <ref resolved='predef::`<<' to='`<<'>`<<</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='`^' homogen-type='method'> - <method name='`^'/><doc placeholder='true'> - <text> - <tt>`^</tt> - exclusive or - - <tt>a ^ b - or - mixed `^(mixed ... args) - - </tt> - This operator does logical exclusive or operations For ints this means - bitwise xor. - - Arrays and multisets are treated as sets, so xoring two arrays will - result in an array with containing all values present in either but - not both arrays. - - For mappings, the intersection will be done on the indexes solely, - however, the values will be taken from the rightmost mapping. - - operators</text> - - <group><seealso/><text> - <ref resolved='predef::`|' to='`|'>`|</ref> and <ref resolved='predef::`&' to='`&'>`&</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='`|' homogen-type='method'> - <method name='`|'/><doc placeholder='true'> - <text> - <tt>`|</tt> - union - - <tt>a | b - or - mixed `|(mixed ... args) - - </tt> - This operator does logical unions. For ints this means bitwise or. - - Arrays and multisets are treated as sets, so doing a union on two arrays - will result in an array with containing all values present in either - array. Although values present in both ararys will only be present - once in the result. - - For mappings, the intersection will be done on the indexes solely, - however, the values will be taken from the rightmost mapping. - - operators</text> - - <group><seealso/><text> - <ref resolved='predef::`&' to='`&'>`&</ref>, <ref resolved='predef::`^' to='`^'>`^</ref> and <ref resolved='predef::`|' to='||'>||</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='`~' homogen-type='method'> - <method name='`~'/><doc placeholder='true'> - <text> - <tt>`~</tt> - bitwise complement - - <tt>~ a - or - int `~(int a) - - </tt> - This operator inverses all bits in an integer and returns the - new integer. - - operators</text> - - <group><seealso/><text> - <ref resolved='predef::`&' to='`&'>`&</ref>, <ref resolved='predef::`|' to='`|'>`|</ref> and <ref resolved='predef::`^' to='`^'>`^</ref> - </text></group> - - </doc> - </docgroup> + <docgroup homogen-name='acos' homogen-type='method'> <method name='acos'/><doc placeholder='true'> <text>
2768: </doc> </docgroup> - <docgroup homogen-name='add_constant' homogen-type='method'> - <method name='add_constant'/><doc placeholder='true'> - <text> - <tt>add_constant</tt> - add new predefined functions or constants - - <tt>void add_constant(string name, mixed value); - or - void add_constant(string name); - - </tt> - This function adds a new constant to Pike, it is often used to - add builin functions (efuns). All programs compiled after add_constant - function is called can access 'value' by the name given by 'name'. - If there is a constant called 'name' already, it will be replaced by - by the new definition. This will not affect already compiled programs. - - Calling add_constant without a value will remove that name from the list - <dl><group><text><matrix> - <r><c> </c><c> of of constant. As with replacing, this will not affect already compiled </c></r> - <r><c> </c></r> - </matrix> - </text></group></dl>programs. - - </text> - - <group><example/><text> - <tt>add_constant("true",1); - add_constant("false",0); - add_constant("PI",4.0); - add_constant("sqr",lambda(mixed x) { return x * x; }); - add_constant("add_constant"); - - </tt></text></group> - - <group><seealso/><text> - <ref resolved='predef::all_constants' to='all_constants'>all_constants</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='add_efun' homogen-type='method'> - <method name='add_efun'/><doc placeholder='true'> - <text> - <tt>add_efun</tt> - add an efun or constant - - <tt>#include <simulate.h> - - - void add_efun(string func_name, mixed function) - or - void add_efun(string func_name) - - </tt> - This function is the same as add_constant. - </text> - - <group><seealso/><text> - <ref resolved='predef::add_constant' to='predef::add_constant'>builtin/add_constant</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='aggregage_list' homogen-type='method'> - <method name='aggregage_list'/><doc placeholder='true'> - <text> - <tt>aggregage_list</tt> - aggregate a multiset - - <tt>#include <simulate.h> - - - multiset aggregage_list(mixed ... args); - - </tt> - This function is exactly the same as aggregate_multiset. - </text> - - <group><seealso/><text> - <ref resolved='predef::aggregate_multiset' to='predef::aggregate_multiset'>builtin/aggregate_multiset</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='aggregate' homogen-type='method'> - <method name='aggregate'/><doc placeholder='true'> - <text> - <tt>aggregate</tt> - construct an array - - <tt>mixed *aggregate(mixed ... elems); - or - ({ elem1, elem2, ... }) - - </tt> - Construct an array with the arguments as indices. This function - could be written in Pike as: - - mixed *aggregate(mixed ... elems) { return elems; } - </text> - - <group><note/><text> - Arrays are dynamically allocated there is no need to declare them - like int a[10]=allocate(10); (and it isn't possible either) like - in C, just int *a=allocate(10); will do. - - array</text></group> - - <group><seealso/><text> - <ref resolved='predef::sizeof' to='sizeof'>sizeof</ref>, <ref resolved='predef::arrayp' to='arrayp'>arrayp</ref> and <ref resolved='predef::allocate' to='allocate'>allocate</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='aggregate_mapping' homogen-type='method'> - <method name='aggregate_mapping'/><doc placeholder='true'> - <text> - <tt>aggregate_mapping</tt> - construct a mapping - - <tt>mapping aggregate_mapping(mixed ... elems); - or - ([ key1:val1, key2:val2, ... ]) - - </tt> - Groups the arguments together two and two to key-index pairs and - creates a mapping of those pairs. The second syntax is always - preferable. - - mapping</text> - - <group><seealso/><text> - <ref resolved='predef::sizeof' to='sizeof'>sizeof</ref>, <ref resolved='predef::mappingp' to='mappingp'>mappingp</ref> and <ref resolved='predef::mkmapping' to='mkmapping'>mkmapping</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='aggregate_multiset' homogen-type='method'> - <method name='aggregate_multiset'/><doc placeholder='true'> - <text> - <tt>aggregate_multiset</tt> - construct a multiset - - <tt>multiset aggregate_multiset(mixed ... elems); - or - (< elem1, elem2, ... >) - - </tt> - Construct an multiset with the arguments as indexes. This function - could be written in Pike as: - - multiset aggregate(mixed ... elems) { return mkmultiset(elems); } - - The only problem is that mkmultiset is implemented using - aggregage_multiset... - - multiset</text> - - <group><seealso/><text> - <ref resolved='predef::sizeof' to='sizeof'>sizeof</ref>, <ref resolved='predef::multisetp' to='multisetp'>multisetp</ref> and <ref resolved='predef::mkmultiset' to='mkmultiset'>mkmultiset</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='alarm' homogen-type='method'> - <method name='alarm'/><doc placeholder='true'> - <text> - <tt>alarm</tt> - set an alarm clock for delivery of a signal - - <tt>int alarm(int seconds); - - </tt> - alarm arranges for a SIGALRM signal to be delivered to the - process in seconds seconds. - - If seconds is zero, no new alarm is scheduled. - - In any event any previously set alarm is cancelled. - </text> - - <group><returns/><text> - alarm returns the number of seconds remaining until any - previously scheduled alarm was due to be delivered, or - zero if there was no previously scheduled alarm. - </text></group> - - <group><seealso/><text> - <ref resolved='predef::signal' to='signal'>signal</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='all_constants' homogen-type='method'> - <method name='all_constants'/><doc placeholder='true'> - <text> - <tt>all_constants</tt> - return all predefined constants - - <tt>mapping (string:mixed) all_constant(); - - </tt> - Return a mapping containing all constants, indexed on the names of the - constant, and with the value of the efun as argument. - </text> - - <group><seealso/><text> - <ref resolved='predef::add_constant' to='add_constant'>add_constant</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='all_efuns' homogen-type='method'> - <method name='all_efuns'/><doc placeholder='true'> - <text> - <tt>all_efuns</tt> - return all 'efuns' - - <tt>#include <simulate.h> - - - mapping all_efuns(); - - </tt> - This function is the same as all_constants. - </text> - - <group><seealso/><text> - <ref resolved='predef::all_constants' to='all_constants'>all_constants</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='allocate' homogen-type='method'> - <method name='allocate'/><doc placeholder='true'> - <text> - <tt>allocate</tt> - allocate an array - - <tt>mixed *allocate(int size); - - </tt> - Allocate an array of size elements and initialize them to zero. - </text> - - <group><example/><text> - <tt>mixed *a=allocate(17); - - </tt></text></group> - - <group><note/><text> - Arrays are dynamically allocated there is no need to declare them - like int a[10]=allocate(10); (and it isn't possible either) like - in C, just int *a=allocate(10); will do. - - array</text></group> - - <group><seealso/><text> - <ref resolved='predef::sizeof' to='sizeof'>sizeof</ref>, <ref resolved='predef::aggregate' to='aggregate'>aggregate</ref> and <ref resolved='predef::arrayp' to='arrayp'>arrayp</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='array' homogen-type='method'> - <method name='array'/><doc placeholder='true'> - <text> - <tt>array</tt> - an array of values - - <tt>({ 1, 2, 3 }) - allocate(10); - - </tt> - Arrays are basically a place to store a number of other values. - Arrays in pike are allocated blocks of values. They are dynamically - allocated and does not need to be declared as in C. The values in - the array can be set when creating the array as in the first - construction or anytime afterwards like this: arr[index]=data where - index is an integer. Index is normally 0 <= index < sizeof(arr), and - refers to the corresponding element in the array. If index is less - than zero, it is the same as doing arr[sizeof(arr)+index]. This - means that negative index will index the array from the end rather - than from the beginning. - - Note that arrays are shared and use reference counts to keep - track of their references. This will have the effect that you can - have two variables pointing to the same array, and when you change - an index in in it, both variables will show the change. - - Here follows a list of operators that applies to arrays: - In this list a and b is used to represent an array expression: - - <matrix> - <r><c> a + b </c><c> summation ( ({1}) + ({2}) returns ({1,2}) ) </c></r> - <r><c> a - b </c><c> subtraction, returns a copy of a with all values that are present in b removed, ( ({1, 2, 3}) - ({2}) returns ({1,3}) ) </c></r> - <r><c> a & b </c><c> intersection, return an array with all values that are present in both a and b </c></r> - <r><c> a | b </c><c> union, return an array with all values that are present in a or b, differs from summation in that values that are present in both a and b are only returned once. </c></r> - <r><c> a ^ b </c><c> xor, return an array with all values that are present in a or b but not in both. </c></r> - <r><c> a * c </c><c> multiplication (c is a string) same thing as implode(a,c) </c></r> - <r><c> a == b </c><c> returns 1 if a is the same array as b, same size and values is not enough. </c></r> - <r><c> a != b </c><c> returns 0 if a is the same array as b, same size and values is not enough. </c></r> - <r><c> ! a </c><c> boolean not, returns 0 </c></r> - <r><c> a[c] </c><c> indexing, returns element c in the array (c is an int) </c></r> - <r><c> a[c]=d </c><c> setting, sets element c in the array to d (c is an int) </c></r> - <r><c> a[c..d] </c><c> range (c & d are ints) returns an array containing a pice of the array a. The piece starts at element c and ends (and includes) element d. </c></r> - </matrix> - - - types</text> - - <group><seealso/><text> - <ref resolved='predef::mapping' to='mapping'>mapping</ref>, <ref resolved='predef::multiset' to='multiset'>multiset</ref>, <ref resolved='predef::allocate' to='predef::allocate'>builtin/allocate</ref> and <ref resolved='predef::sizeof' to='predef::sizeof'>builtin/sizeof</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='arrayp' homogen-type='method'> - <method name='arrayp'/><doc placeholder='true'> - <text> - <tt>arrayp</tt> - is the argument an array? - - <tt>int arrayp(mixed arg); - - </tt> - Returns 1 if arg is an array, zero otherwise. - - array</text> - - <group><seealso/><text> - <ref resolved='predef::allocate' to='allocate'>allocate</ref>, <ref resolved='predef::intp' to='intp'>intp</ref>, <ref resolved='predef::programp' to='programp'>programp</ref>, <ref resolved='predef::floatp' to='floatp'>floatp</ref>, <ref resolved='predef::stringp' to='stringp'>stringp</ref>, <ref resolved='predef::objectp' to='objectp'>objectp</ref>, <ref resolved='predef::mappingp' to='mappingp'>mappingp</ref>, <ref resolved='predef::multisetp' to='multisetp'>multisetp</ref> and <ref resolved='predef::functionp' to='functionp'>functionp</ref> - </text></group> - - </doc> - </docgroup> + <docgroup homogen-name='asin' homogen-type='method'> <method name='asin'/><doc placeholder='true'> <text>
3128: </doc> </docgroup> - <docgroup homogen-name='backtrace' homogen-type='method'> - <method name='backtrace'/><doc placeholder='true'> - <text> - <tt>backtrace</tt> - get a description of the call stack - - <tt>mixed *backtrace(); - - </tt> - This function returns a description of the call stack at this moment. - The description is returned in an array with one entry for each call - in the stack. Each entry has this format: - - ({ - <dl><group><text><matrix> - <r><c> file, </c><c> /* a string with the filename if known, else zero */ </c></r> - <r><c> line, </c><c> /* an integer containing the line if known, else zero */ </c></r> - <r><c> function, </c><c> /* The function-pointer to the called function */ </c></r> - </matrix> - </text></group></dl>}) - - - The current call frame will be last in the array, and the one above - that the last but one and so on. - </text> - - <group><seealso/><text> - <ref resolved='predef::catch' to='catch'>catch</ref> and <ref resolved='predef::throw' to='throw'>throw</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='break' homogen-type='method'> - <method name='break'/><doc placeholder='true'> - <text> - <tt>break</tt> - break a loop or switch - - <tt>break - - </tt> - Break jumps directly out of any loop or switch statement, it is - a very vital part of every switch statement. - - control</text> - - <group><seealso/><text> - <ref to='do-while'>do-while</ref>, <ref resolved='predef::while' to='while'>while</ref>, <ref resolved='predef::for' to='for'>for</ref> and <ref resolved='predef::switch' to='switch'>switch</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='call_function' homogen-type='method'> - <method name='call_function'/><doc placeholder='true'> - <text> - <tt>call_function</tt> - call a function with arguments - - <tt>mixed call_function(function fun,mixed ... args); - or - mixed fun ( mixed ... args ); - - </tt> - This function takes a a function pointer as first argument and calls - this function with the rest of the arguments as arguments. Normally, - you will never have to write call_function(), because you will use the - second syntax instead. - - function</text> - - <group><seealso/><text> - <ref resolved='predef::backtrace' to='backtrace'>backtrace</ref> and <ref resolved='predef::get_function' to='get_function'>get_function</ref> - </text></group> - - </doc> - </docgroup> + <docgroup homogen-name='call_out' homogen-type='method'> <method name='call_out'/><doc placeholder='true'> <text>
3252: </doc> </docgroup> - <docgroup homogen-name='capitalize' homogen-type='method'> - <method name='capitalize'/><doc placeholder='true'> - <text> - <tt>capitalize</tt> - capitalize a string - - <tt>#include <simulate.h> - - - string capitalize(string str) - - </tt> - Convert the first character in str to upper case, and return the - new string. - - string</text> - - <group><seealso/><text> - <ref resolved='predef::lower_case' to='predef::lower_case'>builtin/lower_case</ref> and <ref resolved='predef::upper_case' to='predef::upper_case'>builtin/upper_case</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='cast' homogen-type='method'> - <method name='cast'/><doc placeholder='true'> - <text> - <tt>cast</tt> - convert one type to another - - <tt>( type ) expression - - </tt> - Casts convert types, in most cases it just tells the compiler what - type the expression has, but it can also be used to actually convert - the value of the expression into something else. - - Casting from float or int to string will convert the given number - into a decimal ascii string representation. - - Casting from string to float or int will do the opposite. IE. - Read a decimal number from the string and return that. - - Casting from string to program will call cast_to_program in the - master object and request a program to return. The standard master - object will consider the string a file name and compile the program - given by that string. It will then put the program in a chache in - case you cast the same string to a program again later. - - Castring from string to object will call cast_to_object in the - master object and request an object to return. The standard master - object will consider the string a file name, cast it to a program - and return a clone of that file. If the same cast is attempted again - later, the _same_ object will be returned. - - When casting an object, the method o->cast will be called with a string - with the name of the type as argument. o->cast can then return any - value. - - In all other cases, casts are just compiler hints. - </text> - - <group><example/><text> - <tt><matrix> - <r><c> (program)"Stdio.File" </c><c> // returns the file program </c></r> - <r><c> (object)"Stdio.File" </c><c> // returns a clone of the file program </c></r> - <r><c> (int)(object)"Gmp.mpz" // returns 0 </c></r> - </matrix> - - </tt> - pike</text></group> - - <group><seealso/><text> - <ref resolved='predef::compile_file' to='compile_file'>compile_file</ref> and <ref resolved='predef::sscanf' to='sscanf'>sscanf</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='catch' homogen-type='method'> - <method name='catch'/><doc placeholder='true'> - <text> - <tt>catch</tt> - catch errors - - <tt>catch { commands } - or - catch ( expression ) - - </tt> - catch traps exceptions such as run time errors or calls to throw() and - returns the argument given to throw. For a run time error, this value - is ({ "error message", backtrace }) - - control</text> - - <group><seealso/><text> - <ref resolved='predef::throw' to='predef::throw'>builtin/throw</ref> - </text></group> - - </doc> - </docgroup> + <docgroup homogen-name='cd' homogen-type='method'> <method name='cd'/><doc placeholder='true'> <text>
3415: </doc> </docgroup> - <docgroup homogen-name='class' homogen-type='method'> - <method name='class'/><doc placeholder='true'> - <text> - <tt>class</tt> - define a inlined program - - <tt>class { program definition } - - </tt> - Class is a way of writing serveral programs in one file. - The program written between the brackets will be returned by - class. - </text> - - <group><example/><text> - <tt>complex=clone(class { float r, i; }); - complex->r=1.0; - complex->i=1.0; - - </tt> - pike</text></group> - - <group><seealso/><text> - <ref resolved='predef::inherit' to='inherit'>inherit</ref> and <ref resolved='predef::lambda' to='lambda'>lambda</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='clone' homogen-type='method'> - <method name='clone'/><doc placeholder='true'> - <text> - <tt>clone</tt> - clone an object from a program - - <tt>object clone(program p,mixed ... args); - - </tt> - clone() creates an object from the program p. Or in C++ terms: - It creates an instance of the class p. This clone will first have - all global variables initalized, and then create() will be called - with args as arguments. - - object and program</text> - - <group><seealso/><text> - <ref resolved='predef::destruct' to='destruct'>destruct</ref>, <ref resolved='predef::compile_string' to='compile_string'>compile_string</ref> and <ref resolved='predef::compile_file' to='compile_file'>compile_file</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='column' homogen-type='method'> - <method name='column'/><doc placeholder='true'> - <text> - <tt>column</tt> - extract a column - - <tt>array column(mixed *data,mixed index) - - </tt> - This function is exactly equivialent to: - - map_array(index,lambda(mixed x,mixed y) { return x[y]; },data) - - Except of course it is a lot shorter and faster. - That is, it indexes every index in the array data on the value of - the argument index and returns an array with the results. - - array</text> - - <group><seealso/><text> - <ref resolved='predef::rows' to='rows'>rows</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='combine_path' homogen-type='method'> - <method name='combine_path'/><doc placeholder='true'> - <text> - <tt>combine_path</tt> - concatenate paths - - <tt>string combine_path(string absolute, string relative); - - </tt> - Concatenate a relative path to an absolute path and remove any - "//", "/.." or "/." to produce a straightforward absolute path - as a result. - </text> - - <group><example/><text> - <tt>> combine_path("/foo/bar/",".."); - Result: /foo - > combine_path("/foo/bar/","../apa.c"); - Result: /foo/apa.c - > combine_path("/foo/bar","./sune.c"); - Result: /foo/bar/sune.c - - </tt> - file</text></group> - - <group><seealso/><text> - <ref resolved='predef::getcwd' to='getcwd'>getcwd</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='compile_file' homogen-type='method'> - <method name='compile_file'/><doc placeholder='true'> - <text> - <tt>compile_file</tt> - compile a file to a program - - <tt>program compile_file(string filename); - - </tt> - This function will compile the filename to an Pike program that can - later be used for cloning. - - program</text> - - <group><seealso/><text> - <ref resolved='predef::clone' to='clone'>clone</ref> and <ref resolved='predef::compile_string' to='compile_string'>compile_string</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='compile_string' homogen-type='method'> - <method name='compile_string'/><doc placeholder='true'> - <text> - <tt>compile_string</tt> - compile a string to a program - - <tt>program compile_string(string prog, string name); - - </tt> - Compile_string takes a complete Pike program as an argument in a the - string prog and compiles it to clonable program. The second argument - will be used as the file name of the program and will be used for - error messages and such. - - program</text> - - <group><seealso/><text> - <ref resolved='predef::compile_string' to='compile_string'>compile_string</ref> and <ref resolved='predef::clone' to='clone'>clone</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='continue' homogen-type='method'> - <method name='continue'/><doc placeholder='true'> - <text> - <tt>continue</tt> - continue a loop - - <tt>continue - - </tt> - Continue work similarly to break only it does't finish the loop, - it just aborts the rest of this turn in the loop. - - control</text> - - <group><seealso/><text> - <ref to='do-while'>do-while</ref>, <ref resolved='predef::while' to='while'>while</ref> and <ref resolved='predef::for' to='for'>for</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='copy_value' homogen-type='method'> - <method name='copy_value'/><doc placeholder='true'> - <text> - <tt>copy_value</tt> - copy a value recursively - - <tt>mixed copy_value(mixed value); - - </tt> - Copy value will copy the value given to it recursively. If the result - value is changed destructively (only possible for multisets, arrays and - mappings) the copied value will not be changed. The resulting value - will always be equal to the copied (tested with the efun equal), but - they may not the the same value. (tested with ==) - </text> - - <group><seealso/><text> - <ref resolved='predef::equal' to='equal'>equal</ref> - </text></group> - - </doc> - </docgroup> + <docgroup homogen-name='cos' homogen-type='method'> <method name='cos'/><doc placeholder='true'> <text>
3615: </doc> </docgroup> - <docgroup homogen-name='crypt' homogen-type='method'> - <method name='crypt'/><doc placeholder='true'> - <text> - <tt>crypt</tt> - crypt a password - - <tt>string crypt(string password); - or - int crypt(string typed_password, string crypted_password); - - </tt> - This function crypts and verifies a short string. (normally only - the first 8 characters are significant) The first syntax crypts - the string password into something that is hopefully hard to decrypt, - and the second function crypts the first string and verifies that the - crypted result matches the second argument and returns 1 if they - matched, 0 otherwise. - </text> - - <group><example/><text> - <tt>To crypt a password use: - <dl><group><text>crypted_password = crypt(typed_password); - </text></group></dl>To see if the same password was used again use: - <dl><group><text>matched = crypt(typed_password, crypted_password); - </text></group></dl> - </tt> - string</text></group> - - </doc> - </docgroup> - <docgroup homogen-name='ctime' homogen-type='method'> - <method name='ctime'/><doc placeholder='true'> - <text> - <tt>ctime</tt> - convert time int to readable date string - - <tt>string ctime(int current_time); - - </tt> - Convert the output from a previous call to time() into a readable - string containing the currnent year, month, day and time. - </text> - - <group><example/><text> - <tt>> ctime(time()); - Result: Wed Jan 14 03:36:08 1970 - - </tt></text></group> - - <group><seealso/><text> - <ref resolved='predef::time' to='time'>time</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='describe_backtrace' homogen-type='method'> - <method name='describe_backtrace'/><doc placeholder='true'> - <text> - <tt>describe_backtrace</tt> - make a backtrace readable - - <tt>#include <simulate.h> - - - string describe_backtrace(mixed **backtrace); - - </tt> - Describe backtrace returns a string containing a readable message - that describes where the backtrace was made. The argument 'backtrace' - should normally be the return value from a call to backtrace() - </text> - - <group><seealso/><text> - <ref resolved='predef::backtrace' to='predef::backtrace'>builtin/backtrace</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='destruct' homogen-type='method'> - <method name='destruct'/><doc placeholder='true'> - <text> - <tt>destruct</tt> - destruct an object - - <tt>void destruct(object o); - - </tt> - Destruct marks an object as destructed, all pointers and function - pointers to this object will become zero. The destructed object will - be freed from memory as soon as possible. This will also call - o->destroy. - - object</text> - - <group><seealso/><text> - <ref resolved='predef::clone' to='clone'>clone</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='do-while' homogen-type='method'> - <method name='do-while'/><doc placeholder='true'> - <text> - <tt>do-while</tt> - execute a statement while an expression is true - - <tt>do statement while ( expression ); - - </tt> - do - while only differs from the ordinary while-loop in that it does - _not_ evaluate the expression until after the statement has been - executed once. Thus it always runs the statement once. - </text> - - <group><example/><text> - <tt>int i=circular_buffer_pos; - do - { - <dl><group><text>write(circular_buffer[i]); - i=(i+1) % sizeof(circular_buffer); - </text></group></dl>}while(i != circular_buffer_pos); - - </tt> - control</text></group> - - <group><seealso/><text> - <ref to='do-while'>do-while</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='equal' homogen-type='method'> - <method name='equal'/><doc placeholder='true'> - <text> - <tt>equal</tt> - check if two values are equal or not - - <tt>int equal(mixed a, mixed b); - - </tt> - This function checks if the values a and b are equal. For all types but - arrays, multisets and mappings, this operation is the same as doing a == b. - For arrays, mappings and multisets however, their contents are checked - recursively, and if all their contents are the same and in the same - place, they are considered equal. - </text> - - <group><example/><text> - <tt>> ({ 1 }) == ({ 1 }); - Result: 0 - > equal( ({ 1 }), ({ 1 }) ); - Result: 1 - > - - </tt></text></group> - - <group><seealso/><text> - <ref resolved='predef::copy_value' to='copy_value'>copy_value</ref> - </text></group> - - </doc> - </docgroup> + <docgroup homogen-name='errno' homogen-type='method'> <method name='errno'/><doc placeholder='true'> <text>
3790: </doc> </docgroup> - <docgroup homogen-name='exec' homogen-type='method'> - <method name='exec'/><doc placeholder='true'> - <text> - <tt>exec</tt> - simple way to use exece() - - <tt>#include <process.h> - - - int exec(string file, string ... args); - - </tt> - This function destroys the Pike parser and runs the program - 'file' instead with the arguments. If no there are no '/' in - the filename, the variable PATH will be consulted when looking - for the program. This function does not return except when - the exec fails for some reason. - </text> - - <group><example/><text> - <tt>exec("/bin/echo","hello","world"); - - - </tt></text></group> - - </doc> - </docgroup> + <docgroup homogen-name='exece' homogen-type='method'> <method name='exece'/><doc placeholder='true'> <text>
3852: </doc> </docgroup> - <docgroup homogen-name='exit' homogen-type='method'> - <method name='exit'/><doc placeholder='true'> - <text> - <tt>exit</tt> - exit Pike interpreter - - <tt>void exit(int returncode); - - </tt> - This function exits the whole 'pike' program with the return code - given. Using exit() with any other value than 0 indicates that - something went wrong during execution. See your system manuals for - more information about return codes. - - </text> - - </doc> - </docgroup> + <docgroup homogen-name='exp' homogen-type='method'> <method name='exp'/><doc placeholder='true'> <text>
3888: </doc> </docgroup> - <docgroup homogen-name='explode' homogen-type='method'> - <method name='explode'/><doc placeholder='true'> - <text> - <tt>explode</tt> - explode a string on a delimeter - - <tt>#include <simulate.h> - - - string *explode(string victim, string delimeter); - - </tt> - Explode divides the string called victim at every occurance of - the string delimeter and returns the resulting parts in an array. - If delimeter is an empty string, victim will be divided into strings - of length 1. - - Explode is the same as division. - </text> - - <group><example/><text> - <tt>> explode("foobar","o"); - Result: ({ "f", "", "bar" }) - > explode("10101001010100010101","10"); - Result: ({ "", "", "", "0", "", "", "00", "", "1" }) - > explode("/foo/bar/gazonk","/"); - Result: ({ "", "foo", "bar", "gazonk" }) - > explode("foobar",""); - Result: ({ "f", "o", "o", "b", "a", "r" }) - - </tt> - string</text></group> - - <group><seealso/><text> - <ref resolved='predef::implode' to='implode'>implode</ref> and <ref resolved='predef::`/' to='`/'>`/</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='file_size' homogen-type='method'> - <method name='file_size'/><doc placeholder='true'> - <text> - <tt>file_size</tt> - return the size of a file in bytes - - <tt>#include <stdio.h> - - - int file_size(string file); - - </tt> - Give the size of a file. Size -1 indicates that the file either - does not exist, or that it is not readable by you. Size -2 - indicates that it is a directory. - - file</text> - - <group><seealso/><text> - <ref resolved='predef::write_file' to='write_file'>write_file</ref> and <ref resolved='predef::read_bytes' to='read_bytes'>read_bytes</ref> - </text></group> - - </doc> - </docgroup> + <docgroup homogen-name='file_stat' homogen-type='method'> <method name='file_stat'/><doc placeholder='true'> <text>
4040: </doc> </docgroup> - <docgroup homogen-name='filter' homogen-type='method'> - <method name='filter'/><doc placeholder='true'> - <text> - <tt>filter</tt> - filter an array or mapping through a function - - <tt>#include <array.h> - - - mixed *filter(mixed arr,function fun,mixed ... args); - or - mixed *filter(object *arr,string fun,mixed ... args); - or - mixed *filter(function *arr,-1,mixed ... args); - - </tt> - First syntax: - Filter array returns an array holding the items of arr for which - fun returns true. - - Second syntax: - Filter array calls fun in all the objects in the array arr, and - return all objects that returned true. - - Third syntax: - Filter array calls all functionpointers in the array arr, and - return all that returned true. - - array</text> - - <group><seealso/><text> - <ref resolved='predef::sum_arrays' to='sum_arrays'>sum_arrays</ref> and <ref resolved='predef::map' to='map'>map</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='filter_array' homogen-type='method'> - <method name='filter_array'/><doc placeholder='true'> - <text> - <tt>filter_array</tt> - filter an array through a function - - <tt>#include <simulate.h> - - - mixed *filter_array(mixed *arr,function fun,mixed ... args); - or - mixed *filter_array(object *arr,string fun,mixed ... args); - or - mixed *filter_array(function *arr,-1,mixed ... args); - - </tt> - Filter array is the same function as filter. - - array</text> - - <group><seealso/><text> - <ref resolved='predef::sum_arrays' to='sum_arrays'>sum_arrays</ref>, <ref resolved='predef::map_array' to='map_array'>map_array</ref> and <ref resolved='predef::filter' to='filter'>filter</ref> - </text></group> - - </doc> - </docgroup> + <docgroup homogen-name='find_call_out' homogen-type='method'> <method name='find_call_out'/><doc placeholder='true'> <text>
4125: </doc> </docgroup> - <docgroup homogen-name='find_option' homogen-type='method'> - <method name='find_option'/><doc placeholder='true'> - <text> - <tt>find_option</tt> - find command line options - - <tt>#include <getopt.h> - - - mixed find_option(string *argv, - <dl><group><text>string shortform, - string longform, - string envvar, - mixed def); - </text></group></dl> - </tt> - This is a generic function to parse command line options of the - type '-f', '--foo' or '--foo=bar'. The first argument should be - the array of strings that is sent as second argument to your - main() function, the second is a string with the short form of - your option. The short form must be only one character long. - The 'longform' is an alternative and maybe more readable way to - give the same option. If you give "foo" as longform your program - will accept --foo as argument. The envvar argument specifies what - environment variable can be used to specify the same option. The - envvar option exists to make it easier to custimizer program usage. - The 'def' has two functions: It specifies that the option takes an - argument and it tells find_option what to return if the option is - not present. If 'def' is given and the option does not have an - argument find_option will print an error message and exit the program. - - Also, as an extra bonus: shortform, longform and envvar can all be - arrays, in which case either of the options in the array will be - accpted. - </text> - - <group><note/><text> - find_option modifies argv. - </text></group> - - <group><example/><text> - <tt>int main(int argc, string *argv) - { - <dl><group><text>if(find_option(argv,"f","foo")) - <dl><group><text>werror("The FOO option was given.\n"); - </text></group></dl></text></group></dl> - - <dl><group><text>werror("The BAR option got the "+ - find_option(argv,"b","bar","BAR_OPTION","default")+ - " argument.\n"); - </text></group></dl>} - - </tt></text></group> - - <group><seealso/><text> - <ref resolved='predef::get_args' to='get_args'>get_args</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='float' homogen-type='method'> - <method name='float'/><doc placeholder='true'> - <text> - <tt>float</tt> - floating point numbers - - <tt>0.9 - 1.0 - 2.7e7 - - </tt> - This type stores a floating point number, normally it use 4 bytes - of storage when used in a global variable. - - A list of operators that applies to floats follows: - In this list a and b is used to represent a float expression: - - <matrix> - <r><c> a + b </c><c> summation </c></r> - <r><c> a - b </c><c> subtraction </c></r> - <r><c> a * b </c><c> multiplication </c></r> - <r><c> a / b </c><c> division </c></r> - <r><c> a % b </c><c> modulo ( same thing as a - floor( a / b ) * b ) </c></r> - <r><c> - a </c><c> negation </c></r> - <r><c> a == b </c><c> return 1 if a is equal to b, 0 otherwise </c></r> - <r><c> a != b </c><c> return 0 if a is equal to b, 1 otherwise </c></r> - <r><c> a <c> returns 1 if a is lesser than b, 0 otherwise </c></r> - <r><c> a <= b </c><c> returns 1 if a is lesser or equal to b, 0 otherwise </c></r> - <r><c> a > b </c><c> returns 1 if a is greater than b, 0 otherwise </c></r> - <r><c> a >= b </c><c> returns 1 if a is greater or equal to b, 0 otherwise </c></r> - </matrix> - - </text> - - <group><note/><text> - floats and ints cannot be used together, they have to be cast - to the same type first. - - types</text></group> - - <group><seealso/><text> - <ref resolved='predef::sin' to='predef::sin'>math/sin</ref>, <ref resolved='predef::cos' to='predef::cos'>math/cos</ref>, <ref resolved='predef::tan' to='predef::tan'>math/tan</ref> and <ref resolved='predef::sqrt' to='predef::sqrt'>math/sqrt</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='floatp' homogen-type='method'> - <method name='floatp'/><doc placeholder='true'> - <text> - <tt>floatp</tt> - is the argument an float? - - <tt>int floatp(mixed arg); - - </tt> - Returns 1 if arg is a float, zero otherwise. - - float</text> - - <group><seealso/><text> - <ref resolved='predef::intp' to='intp'>intp</ref>, <ref resolved='predef::programp' to='programp'>programp</ref>, <ref resolved='predef::arrayp' to='arrayp'>arrayp</ref>, <ref resolved='predef::stringp' to='stringp'>stringp</ref>, <ref resolved='predef::objectp' to='objectp'>objectp</ref>, <ref resolved='predef::mappingp' to='mappingp'>mappingp</ref>, <ref resolved='predef::multisetp' to='multisetp'>multisetp</ref> and <ref resolved='predef::functionp' to='functionp'>functionp</ref> - </text></group> - - </doc> - </docgroup> + <docgroup homogen-name='floor' homogen-type='method'> <method name='floor'/><doc placeholder='true'> <text>
4266: </doc> </docgroup> - <docgroup homogen-name='for' homogen-type='method'> - <method name='for'/><doc placeholder='true'> - <text> - <tt>for</tt> - generic loop statement - - <tt>for ( expression1 ; expression2 ; expression3 ) statement - - </tt> - the above statement is exactly equal to: - - expression1; - while( expression2 ) - { - <dl><group><text><statement> - expression3; - </text></group></dl>} - - - Except when using 'continue'. When using continue in <statement> - expresstion3 will not be called. - </text> - - <group><example/><text> - <tt>int e; - for(e=0;e<10;e++) write(e+"\n"); - - </tt> - control</text></group> - - <group><seealso/><text> - <ref resolved='predef::while' to='while'>while</ref>, <ref resolved='predef::break' to='break'>break</ref> and <ref resolved='predef::continue' to='continue'>continue</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='foreach' homogen-type='method'> - <method name='foreach'/><doc placeholder='true'> - <text> - <tt>foreach</tt> - loop over an array - - <tt>foreach ( array, variable ) statement - - </tt> - For each element in array, set variable to that value and execute - 'statement'. - </text> - - <group><example/><text> - <tt>string word; - foreach( explode(sentence," "), word) foo(word); - - </tt> - control</text></group> - - <group><seealso/><text> - <ref resolved='predef::for' to='for'>for</ref> and <ref resolved='predef::while' to='while'>while</ref> - </text></group> - - </doc> - </docgroup> + <docgroup homogen-name='fork' homogen-type='method'> <method name='fork'/><doc placeholder='true'> <text>
4343: </text></group> <group><seealso/><text> - <ref resolved='predef::exec' to='predef::exec'>files/exec</ref> and <ref to='file->pipe'>file->pipe</ref> + <ref to='predef::exec'>files/exec</ref> and <ref to='file->pipe'>file->pipe</ref> </text></group> </doc> </docgroup> - <docgroup homogen-name='function' homogen-type='method'> - <method name='function'/><doc placeholder='true'> - <text> - <tt>function</tt> - a function pointer - - <tt>foo /* if foo is a function in this object */ - bar::foo /* if foo is a function in the inherited program 'bar' */ - o->foo /* function (or variable) foo in the object o */ - - </tt> - A functionpointer is a reference to a function in an object. It can be - called with call_function which can also be written as just (). - If the object the functionpointer is in is destructed the pointer will - become 0. If you try to call a functionpointer that has is 0 then 0 - will be returned. - - types</text> - - <group><seealso/><text> - <ref resolved='predef::object' to='object'>object</ref>, <ref resolved='predef::call_function' to='predef::call_function'>builtin/call_function</ref>, <ref resolved='predef::functionp' to='predef::functionp'>builtin/functionp</ref>, <ref resolved='predef::function_object' to='predef::function_object'>builtin/function_object</ref> and <ref resolved='predef::function_name' to='predef::function_name'>builtin/function_name</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='function_name' homogen-type='method'> - <method name='function_name'/><doc placeholder='true'> - <text> - <tt>function_name</tt> - return the name of a function, if known - - <tt>string function_name(function f); - - </tt> - This function returns the name of the function f. If the function is - a pre-defined function in the driver, zero will be returned. - - function</text> - - <group><seealso/><text> - <ref resolved='predef::function_object' to='function_object'>function_object</ref> and <ref resolved='predef::get_function' to='get_function'>get_function</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='function_object' homogen-type='method'> - <method name='function_object'/><doc placeholder='true'> - <text> - <tt>function_object</tt> - return what object a function is in - - <tt>object function_object(function f); - - </tt> - Function_object will return the object the function f is in. If the - function is a predefined function from the driver, zero will be - returned. - - function</text> - - <group><seealso/><text> - <ref resolved='predef::function_name' to='function_name'>function_name</ref> and <ref resolved='predef::get_function' to='get_function'>get_function</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='functionp' homogen-type='method'> - <method name='functionp'/><doc placeholder='true'> - <text> - <tt>functionp</tt> - is the argument an function? - - <tt>int functionp(mixed arg); - - </tt> - Returns 1 if arg is a function, zero otherwise. - - function</text> - - <group><seealso/><text> - <ref resolved='predef::intp' to='intp'>intp</ref>, <ref resolved='predef::programp' to='programp'>programp</ref>, <ref resolved='predef::arrayp' to='arrayp'>arrayp</ref>, <ref resolved='predef::stringp' to='stringp'>stringp</ref>, <ref resolved='predef::objectp' to='objectp'>objectp</ref>, <ref resolved='predef::mappingp' to='mappingp'>mappingp</ref>, <ref resolved='predef::multisetp' to='multisetp'>multisetp</ref> and <ref resolved='predef::floatp' to='floatp'>floatp</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='functions' homogen-type='method'> - <method name='functions'/><doc placeholder='true'> - <text> - <tt>functions</tt> - how to write a function - - <tt>modifier type function_name (argument_specification) - { - <dl><group><text>/* function body */ - </text></group></dl>} - - </tt> - A function is basically a piece of code which takes some data - does some things, and hands some data back. Data sent to a - a function is called an 'argument'. - - This defines a function called 'function_name' returning the type - 'type'. The argument_specification is a comma separated list of - arguments. Each argument is specified with a type, whitespace and - the name of the argument. The last argument may have ... before - the name to indicate that that argument shall contain an array of - the rest of the arguments given by the caller. Note that using - ... automatically makes an the variable an array, so writing - - <matrix> - <r><c> </c><c> int foo(int * ... ints); </c></r> - <r><c> </c></r> - </matrix> - - - means that 'ints' is an array of arrays of integers. Which might not - be what you want. - - The modifiers can be zero or more of: static, no_mask, varargs, inline - and private. Varargs means that it is ok to call the function with - less arguments that would otherwise be needed. Inline means that - the function may be inlined in other code. Inline also makes the - function no_mask. Static means that the function can not be called - from other objects. Private means that the function can not be accessed - from programs that inherits this program. - - Some times you need to use a function before it is defined, then you - can write a 'forward declaration' of the function. This is done by - copying the function definition up until (but not including) the '{' - and putting a semicolon after it. The forward declaration should be - put before the use of the function of course. - - Function definitions and forward declarations are toplevel constructs, - they can not be written inside functions or expressions. - </text> - - <group><example/><text> - <tt>/* Forward declare foobar as taking an array of int as argument - <dl><group><text>*and returning an int - */ - </text></group></dl>static int foobar(int *a); - - - /* This function takes a format string and any number of integers - <dl><group><text>* as argument and returns a string - */ - </text></group></dl>string dofobar(string format ,int ... rest) - { - <dl><group><text>return sprintf(format, foobar(rest)); - </text></group></dl>} - - - /* Define foobar */ - static int foobar(int *a) - { - <dl><group><text>int e, ret; - ret=1; - </text></group></dl> - - <dl><group><text>for(e=0;e<sizeof(a);e++) - <dl><group><text>ret*=a[e]; - </text></group></dl></text></group></dl> - - <dl><group><text>return ret; - </text></group></dl>} - - </tt> - pike</text></group> - - <group><seealso/><text> - <ref resolved='predef::lambda' to='lambda'>lambda</ref>, <ref resolved='predef::return' to='return'>return</ref> and <ref resolved='predef::modifier' to='modifier'>modifier</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='gauge' homogen-type='method'> - <method name='gauge'/><doc placeholder='true'> - <text> - <tt>gauge</tt> - measure system time - - <tt>gauge { commands } - or - gauge ( expression ) - - </tt> - Gauge measure how much cpu time is used to execute the commands - given as arguments. The number of milliseconds used is returned - as an integer. - - control</text> - - <group><seealso/><text> - <ref resolved='predef::catch' to='catch'>catch</ref> and <ref resolved='predef::rusage' to='predef::rusage'>builtin/rusage</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='gc' homogen-type='method'> - <method name='gc'/><doc placeholder='true'> - <text> - <tt>gc</tt> - do garbage collection - - <tt>int gc(); - - </tt> - <matrix> - <r><c> This function checks all the memory for cyclic structures such </c></r> - <r><c> as arrays containing themselves and frees them if approperiate. </c></r> - <r><c> It also frees up destructed objects. It then returns how many </c></r> - <r><c> arrays/objects/programs/etc. it managed </c><c> to free by doing this. </c></r> - <r><c> Normally there is no need to call this function since Pike will </c></r> - <r><c> call it by itself every now and then. (Pike will try to predict </c></r> - <r><c> when 20% of all arrays/object/programs in memory is 'garbage' </c></r> - <r><c> and call this routine then.) </c></r> - </matrix> - - - - </text> - - </doc> - </docgroup> - <docgroup homogen-name='get_args' homogen-type='method'> - <method name='get_args'/><doc placeholder='true'> - <text> - <tt>get_args</tt> - get the non-option arguments - - <tt>#include <getopt.h> - - - string *get_args(string *argv); - - </tt> - This function returns the remaining command line arguments after - you have run find_options to find all the options in the - argument list. If there are any options left not handled by - find_options an error message will be written and the program will - exit. Otherwise a new 'argv' array without the parsed options is - returned. - </text> - - <group><example/><text> - <tt>int main(int argc, string *argv) - { - <dl><group><text>if(find_option(argv,"f","foo")) - <dl><group><text>werror("The FOO option was given.\n"); - </text></group></dl></text></group></dl> - - <dl><group><text>argv=get_args(argv); - werror("The arguments are: "+(argv*" ")+".\n"); - </text></group></dl>} - - </tt></text></group> - - <group><seealso/><text> - <ref resolved='predef::find_option' to='find_option'>find_option</ref> - </text></group> - - </doc> - </docgroup> + <docgroup homogen-name='get_dir' homogen-type='method'> <method name='get_dir'/><doc placeholder='true'> <text>
4622: </doc> </docgroup> - <docgroup homogen-name='get_function' homogen-type='method'> - <method name='get_function'/><doc placeholder='true'> - <text> - <tt>get_function</tt> - fetch a function from an object - - <tt>#include <simulate.h> - - - function get_function(object o, string name); - - </tt> - Defined as: return o[name]; - - function</text> - - </doc> - </docgroup> + <docgroup homogen-name='getcwd' homogen-type='method'> <method name='getcwd'/><doc placeholder='true'> <text>
4670: Usersecurity</text> <group><seealso/><text> - <ref resolved='predef::system' to='system/setuid'>system/setuid</ref>, <ref resolved='predef::system' to='system/getuid'>system/getuid</ref>, <ref resolved='predef::system' to='system/setgid'>system/setgid</ref>, <ref resolved='predef::system' to='system/getgid'>system/getgid</ref>, <ref resolved='predef::system' to='system/seteuid'>system/seteuid</ref>, <ref resolved='predef::system' to='system/geteuid'>system/geteuid</ref> and <ref resolved='predef::system' to='system/setegid'>system/setegid</ref> + <ref to='system/setuid'>system/setuid</ref>, <ref to='system/getuid'>system/getuid</ref>, <ref to='system/setgid'>system/setgid</ref>, <ref to='system/getgid'>system/getgid</ref>, <ref to='system/seteuid'>system/seteuid</ref>, <ref to='system/geteuid'>system/geteuid</ref> and <ref to='system/setegid'>system/setegid</ref> </text></group> </doc> </docgroup> - <docgroup homogen-name='getenv' homogen-type='method'> - <method name='getenv'/><doc placeholder='true'> - <text> - <tt>getenv</tt> - get an environment variable - - <tt>string getenv(string varname); - - </tt> - Reurns the value of the environment variable with the name varname, - if no such environment variable exists, zero is returned. - </text> - - <group><note/><text> - This function is provided by master.c - - </text></group> - - </doc> - </docgroup> + <docgroup homogen-name='geteuid' homogen-type='method'> <method name='geteuid'/><doc placeholder='true'> <text>
4707: Usersecurity</text> <group><seealso/><text> - <ref resolved='predef::system' to='system/setuid'>system/setuid</ref>, <ref resolved='predef::system' to='system/getuid'>system/getuid</ref>, <ref resolved='predef::system' to='system/setgid'>system/setgid</ref>, <ref resolved='predef::system' to='system/getgid'>system/getgid</ref>, <ref resolved='predef::system' to='system/seteuid'>system/seteuid</ref>, <ref resolved='predef::system' to='system/setegid'>system/setegid</ref> and <ref resolved='predef::system' to='system/getegid'>system/getegid</ref> + <ref to='system/setuid'>system/setuid</ref>, <ref to='system/getuid'>system/getuid</ref>, <ref to='system/setgid'>system/setgid</ref>, <ref to='system/getgid'>system/getgid</ref>, <ref to='system/seteuid'>system/seteuid</ref>, <ref to='system/setegid'>system/setegid</ref> and <ref to='system/getegid'>system/getegid</ref> </text></group> </doc>
4725: Usersecurity</text> <group><seealso/><text> - <ref resolved='predef::system' to='system/setuid'>system/setuid</ref>, <ref resolved='predef::system' to='system/getuid'>system/getuid</ref>, <ref resolved='predef::system' to='system/setgid'>system/setgid</ref>, <ref resolved='predef::system' to='system/seteuid'>system/seteuid</ref>, <ref resolved='predef::system' to='system/geteuid'>system/geteuid</ref>, <ref resolved='predef::system' to='system/setegid'>system/setegid</ref> and <ref resolved='predef::system' to='system/getegid'>system/getegid</ref> + <ref to='system/setuid'>system/setuid</ref>, <ref to='system/getuid'>system/getuid</ref>, <ref to='system/setgid'>system/setgid</ref>, <ref to='system/seteuid'>system/seteuid</ref>, <ref to='system/geteuid'>system/geteuid</ref>, <ref to='system/setegid'>system/setegid</ref> and <ref to='system/getegid'>system/getegid</ref> </text></group> </doc>
4822: Processes</text> <group><seealso/><text> - <ref resolved='predef::system' to='system/getpid'>system/getpid</ref> and <ref resolved='predef::system' to='system/getppid'>system/getppid</ref> + <ref to='system/getpid'>system/getpid</ref> and <ref to='system/getppid'>system/getppid</ref> </text></group> </doc>
4830: <docgroup homogen-name='getpid' homogen-type='method'> <method name='getpid'/><doc placeholder='true'> <text> - <tt>getpid</tt> - get the process id of this process - - <tt>int getpid(); - - </tt> - This returns the pid of this process. Useful for sending - signals to yourself. - </text> - - <group><seealso/><text> - <ref resolved='predef::kill' to='kill'>kill</ref>, <ref resolved='predef::fork' to='fork'>fork</ref> and <ref resolved='predef::signal' to='signal'>signal</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='getpid' homogen-type='method'> - <method name='getpid'/><doc placeholder='true'> - <text> + <tt>getpid</tt> - get the process ID <tt>int getpid(); 
4858: Processes</text> <group><seealso/><text> - <ref resolved='predef::system' to='system/getppid'>system/getppid</ref> and <ref resolved='predef::system' to='system/getpgrp'>system/getpgrp</ref> + <ref to='system/getppid'>system/getppid</ref> and <ref to='system/getpgrp'>system/getpgrp</ref> </text></group> </doc>
4876: Processes</text> <group><seealso/><text> - <ref resolved='predef::system' to='system/getpid'>system/getpid</ref> and <ref resolved='predef::system' to='system/getpgrp'>system/getpgrp</ref> + <ref to='system/getpid'>system/getpid</ref> and <ref to='system/getpgrp'>system/getpgrp</ref> </text></group> </doc>
4894: Usersecurity</text> <group><seealso/><text> - <ref resolved='predef::system' to='system/setuid'>system/setuid</ref>, <ref resolved='predef::system' to='system/setgid'>system/setgid</ref>, <ref resolved='predef::system' to='system/getgid'>system/getgid</ref>, <ref resolved='predef::system' to='system/seteuid'>system/seteuid</ref>, <ref resolved='predef::system' to='system/geteuid'>system/geteuid</ref>, <ref resolved='predef::system' to='system/setegid'>system/setegid</ref> and <ref resolved='predef::system' to='system/getegid'>system/getegid</ref> + <ref to='system/setuid'>system/setuid</ref>, <ref to='system/setgid'>system/setgid</ref>, <ref to='system/getgid'>system/getgid</ref>, <ref to='system/seteuid'>system/seteuid</ref>, <ref to='system/geteuid'>system/geteuid</ref>, <ref to='system/setegid'>system/setegid</ref> and <ref to='system/getegid'>system/getegid</ref> </text></group> </doc> </docgroup> - <docgroup homogen-name='glob' homogen-type='method'> - <method name='glob'/><doc placeholder='true'> - <text> - <tt>glob</tt> - match strings against globs - - <tt>int glob(string glob, string str); - or - string *glob(string glob, string *arr); - - </tt> - This function matches "globs". A in the glob string a question sign - matches any character and an asterisk matches any string. When - given two strings as argument a true/false value is returned - which reflects if the 'str' matches 'glob'. When given an array as - second argument, an array containing all matching strings is returned. - </text> - - <group><seealso/><text> - <ref resolved='predef::sscanf' to='sscanf'>sscanf</ref> and <ref resolved='predef::regexp' to='regexp'>regexp</ref> - </text></group> - - </doc> - </docgroup> + <docgroup homogen-name='hardlink' homogen-type='method'> <method name='hardlink'/><doc placeholder='true'> <text>
4935: file</text> <group><seealso/><text> - <ref resolved='predef::system' to='system/symlink'>system/symlink</ref>, <ref resolved='predef::mv' to='predef::mv'>files/mv</ref> and <ref resolved='predef::rm' to='predef::rm'>files/rm</ref> + <ref to='system/symlink'>system/symlink</ref>, <ref resolved='predef::mv' to='predef::mv'>files/mv</ref> and <ref resolved='predef::rm' to='predef::rm'>files/rm</ref> </text></group> </doc> </docgroup> - <docgroup homogen-name='hash' homogen-type='method'> - <method name='hash'/><doc placeholder='true'> - <text> - <tt>hash</tt> - hash a string - - <tt>int hash(string s); - or - int hash(string s, int max); - - </tt> - This function will return an int derived from the string s. The same - string will always hash to the same value. If a second argument - is given, the result will be >= 0 and lesser than that argument. - - string</text> - - </doc> - </docgroup> - <docgroup homogen-name='hilfe' homogen-type='method'> - <method name='hilfe'/><doc placeholder='true'> - <text> - <tt>hilfe</tt> - Hubbe's Incremental Pike FrontEnd - - <tt>$ hilfe - or - $ pike -Cstay hilfe - - </tt> - Hilfe is a Pike-script that supplies an incremental environment for - Pike. It allowes you to evaluate Pike 'on the fly'. If you're running - UNIX, you only have to write 'hilfe' to start it, otherwise you will - have to write 'driver -Cstay hilfe' to run it. If you don't know what - 'incremeantal' means in this context, ask you local LISP junkie. - - Hilfe has the following commands: - - quit - exit hilfe - new - clear all variables and function definition - dump - dump all current variables - . - clear input buffer - - Hilfe parses a subset of Pike, there many things it doesn't handle. Here - is a list of what you can do: - - Define a function: - <type> <name>( <arguments> ) { <statements > } - Note that hilfe simulates a function defenition by defining a variable - and setting it to the function pointer. Therefor actual typechecking is - almost nil. Also note that hilfe doesn't recognize type modifiers such - as static, private, varargs etc. - - Declare one or many global variables: - <type> <name> [=<value>], <name> [=value>] ..... ; - Hilfe simulates variable handling, and typechecking is almost nil, - therefor all global variables are declared as mixed, whatever the - <type> may be. - - Evaluate a statement: - <statement> ; - Statements include the following examples: - - <dl><group><text>for(e=0;e<10;e++) ; - </text></group></dl> - - <dl><group><text>e=10; - </text></group></dl> - - <dl><group><text>write(e); - </text></group></dl> - - <dl><group><text>if(foo) return bar; else return gazonk; - </text></group></dl> - - Statements beginning with for, while, switch, if, do or return will - not automatically return anything, and no result will be printed. - - </text> - - </doc> - </docgroup> - <docgroup homogen-name='if-else' homogen-type='method'> - <method name='if-else'/><doc placeholder='true'> - <text> - <tt>if-else</tt> - run on condition - - <tt>if( expression ) statement - or - if( expression ) statement else statement - - </tt> - If is the simplest of all control structures, in the first form - it runs the statement if the expression is true and in the second - form it runs the first statement if the expression is true and the - second if it is false. - - control</text> - - <group><seealso/><text> - <ref resolved='predef::switch' to='switch'>switch</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='implode' homogen-type='method'> - <method name='implode'/><doc placeholder='true'> - <text> - <tt>implode</tt> - implode an array of strings - - <tt>#include <simulate.h> - - - string implode(string *a, string delimeter); - or - a * delimeter - - </tt> - This function is the inverse of explode. It contatenates all the - strings in a with a delimeter in between each. - - This function is the same as multiplication. - </text> - - <group><example/><text> - <tt>> implode( ({ "foo","bar","gazonk"}), "-" ); - Result: foo-bar-gazonk - > ({ "a","b","c" })*" and "; - Result: a and b and c - > - - </tt> - string</text></group> - - <group><seealso/><text> - <ref resolved='predef::explode' to='explode'>explode</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='implode_nicely' homogen-type='method'> - <method name='implode_nicely'/><doc placeholder='true'> - <text> - <tt>implode_nicely</tt> - make an english comma separated list - - <tt>#include <string.h> - - - string implode_nicely(string *words, string|void separator) - - </tt> - This function implodes a list of words to a readable string. - If the separator is omitted, the default is 'and'. - </text> - - <group><example/><text> - <tt>> implode_nicely(({"green"})); - Result: green - > implode_nicely(({"green","blue"})); - Result: green and blue - > implode_nicely(({"green","blue","white"})); - Result: green, blue and white - > implode_nicely(({"green","blue","white"}),"or"); - Result: green, blue or white - - </tt> - string</text></group> - - <group><seealso/><text> - <ref resolved='predef::`*' to='`*'>`*</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='index' homogen-type='method'> - <method name='index'/><doc placeholder='true'> - <text> - <tt>index</tt> - get/set an element in an array/string/mapping/object - - <tt>a [ b ] - or - a [ b ] = c - or - a -> b - - </tt> - <matrix> - <r><c> This operator does a lookup in 'a' to find the element named 'b' in </c></r> - <r><c> 'a'. The last syntax (a->b) is equal to a [ "b" ]. Different usage </c></r> - <r><c> applies </c><c> to different types. </c></r> - </matrix> - - - <matrix> - <r><c> Strings </c><c> With strings, the index operator can only be used to get values </c></r> - <r><c> </c><c> not change them. The index must be an integer, and the return value will be the ascii value of the corresponding character in the string. The first character is numbered 0. </c></r> - <r><c> Arrays </c><c> As with strings, arrays can only be indexed on integers. However, values can also be changed by using indexing on the left side of an assignment. The values in the array can have any type. As with strings, the first index is 0. </c></r> - <r><c> Mappings </c><c> Mappings can be indexed on any type of value, quite often they are indexed on strings. Values can be changed as with arrays. Mappings do not have a fixed size, nor do they have a specific order in which the values are stored. If you attempt to set a value in a mapping that does not already exists, the mapping will grow to include the new value. There is no 'first' index for mappings. </c></r> - <r><c> Multisets </c><c> Multisets can be also be indexed on any value, but the return value only reflects a true/false status depending on weather that index was present in the multiset. As with mappings, multisets will grow when you try to set a value in it that is does not already exists. However multisets will only grow if the inserted 'c' is nonzero. </c></r> - <r><c> Object </c><c> Objects can only be indexed on strings. It then gets/sets the value of the variable with that name. If the 'variable' isn't a variable at all, but a function it will return a pointer to that function but you can't change it. </c></r> - </matrix> - - </text> - - <group><example/><text> - <tt><matrix> - <r><c> "foobar"[2] </c><c> returns 111 /* ascii for 'o' */ </c></r> - <r><c> "foobar"[0] </c><c> returns 102 /* ascii for 'f' */ </c></r> - <r><c> ({1,2,3})[1] </c><c> returns 2 </c></r> - <r><c> ([1:2})[1] </c><c> returns 2 </c></r> - <r><c> (<1,2,3>)[2] </c><c> returns 1 </c></r> - </matrix> - - </tt> - operators</text></group> - - <group><seealso/><text> - <ref resolved='predef::index' to='index'>index</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='indices' homogen-type='method'> - <method name='indices'/><doc placeholder='true'> - <text> - <tt>indices</tt> - return an array of all index possible for a value - - <tt>mixed *indices(string|array|mapping|multiset|object foo); - - </tt> - Indices returns an array of all values you can use as index when - indexing foo. For strings and arrays this is simply an array of the - ascending numbers. For mappings and multisets, the array may contain any - kind of value. For objects, the result is an array of strings. - - mapping and multiset</text> - - <group><seealso/><text> - <ref resolved='predef::values' to='values'>values</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='inherit' homogen-type='method'> - <method name='inherit'/><doc placeholder='true'> - <text> - <tt>inherit</tt> - use definitions from another program - - <tt>inherit "<program name>"; - or - inherit "<program name>" : local_name; - - </tt> - <matrix> - <r><c> Inherit copies the global identifiers (functions and global variables) </c></r> - <r><c> from the named program. These functions and variables can then be </c></r> - <r><c> used as </c><c> if they were defined in this program. All the inherited </c></r> - <r><c> identifiers that was no declared as no_mask in the inherited program </c></r> - <r><c> can be also be redefined. The redefinition will not only </c></r> - <r><c> affect functions following the redefinition, but all functions in </c></r> - <r><c> this program, including the inherited ones. </c></r> - </matrix> - - - Even if an identifier is redefined you can still access the original - though. Prepending the identifier name with :: will return the original - identifier, OR an array of all inherited identifiers with that name. - - You can also use the local_name to access a specific identifier, just - prepend it like 'local_name::identifier'. This will return the named - identifer in the program inherited with the given local_name. If no - local_name was given to inherit , the last part of the path in the - program name will be used as local_name. - - Inherit calls master()->cast_to_program(<program name>) to get the - program to inherit. For this reason there can be no inherits in the - master object. - - Inherit is not an expression or statement, it is a toplevel construct - and must not be written inside a function body. - </text> - - <group><example/><text> - <tt>/* This is file hworld.pike */ - int hello_world() { write("Hello world.\n"); } - - - /* This is the file hello_world.pike */ - inherit "hworld.pike"; - - int main() - { - <dl><group><text>hello_world(); - exit(0); - </text></group></dl>} - - </tt> - pike</text></group> - - <group><seealso/><text> - <ref resolved='predef::class' to='class'>class</ref> - </text></group> - - </doc> - </docgroup> + <docgroup homogen-name='initgroups' homogen-type='method'> <method name='initgroups'/><doc placeholder='true'> <text>
5258: Usersecurity</text> <group><seealso/><text> - <ref resolved='predef::system' to='system/setuid'>system/setuid</ref>, <ref resolved='predef::system' to='system/getuid'>system/getuid</ref>, <ref resolved='predef::system' to='system/setgid'>system/setgid</ref>, <ref resolved='predef::system' to='system/getgid'>system/getgid</ref>, <ref resolved='predef::system' to='system/seteuid'>system/seteuid</ref>, <ref resolved='predef::system' to='system/geteuid'>system/geteuid</ref>, <ref resolved='predef::system' to='system/setegid'>system/setegid</ref>, <ref resolved='predef::system' to='system/getegid'>system/getegid</ref>, <ref resolved='predef::system' to='system/getgroups'>system/getgroups</ref> and <ref resolved='predef::system' to='system/setgroups'>system/setgroups</ref> + <ref to='system/setuid'>system/setuid</ref>, <ref to='system/getuid'>system/getuid</ref>, <ref to='system/setgid'>system/setgid</ref>, <ref to='system/getgid'>system/getgid</ref>, <ref to='system/seteuid'>system/seteuid</ref>, <ref to='system/geteuid'>system/geteuid</ref>, <ref to='system/setegid'>system/setegid</ref>, <ref to='system/getegid'>system/getegid</ref>, <ref to='system/getgroups'>system/getgroups</ref> and <ref to='system/setgroups'>system/setgroups</ref> </text></group> </doc> </docgroup> - <docgroup homogen-name='int' homogen-type='method'> - <method name='int'/><doc placeholder='true'> - <text> - <tt>int</tt> - integers numbers - - <tt>9797 /* decimal number */ - 0x20 /* hexadecimal number */ - 020 /* octal number */ - - </tt> - This type stores an integer, normally it is 32 bits and use 4 bytes - of storage when used in a global variable. - - A list of operators that applies to ints follows: - - In this list a and b is used to represent an integer expression: - - <matrix> - <r><c> a + b </c><c> summation </c></r> - <r><c> a - b </c><c> subtraction </c></r> - <r><c> a * b </c><c> multiplication </c></r> - <r><c> a / b </c><c> integer division </c></r> - <r><c> a % b </c><c> modulo ( same thing as a - ( a / b ) * b ) </c></r> - <r><c> a | b </c><c> bitwise or </c></r> - <r><c> a & b </c><c> bitwise and </c></r> - <r><c> a ^ b </c><c> bitwise xor </c></r> - <r><c> ! a </c><c> boolean not, returns 1 if a is zero 0 otherwise </c></r> - <r><c> ~ a </c><c> bitwise complement </c></r> - <r><c> - a </c><c> negation </c></r> - <r><c> a == b </c><c> return 1 if a is equal to b, 0 otherwise </c></r> - <r><c> a != b </c><c> return 0 if a is equal to b, 1 otherwise </c></r> - <r><c> a <c> returns 1 if a is lesser than b, 0 otherwise </c></r> - <r><c> a <= b </c><c> returns 1 if a is lesser or equal to b, 0 otherwise </c></r> - <r><c> a > b </c><c> returns 1 if a is greater than b, 0 otherwise </c></r> - <r><c> a >= b </c><c> returns 1 if a is greater or equal to b, 0 otherwise </c></r> - </matrix> - - - types</text> - - <group><seealso/><text> - <ref resolved='predef::float' to='float'>float</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='intp' homogen-type='method'> - <method name='intp'/><doc placeholder='true'> - <text> - <tt>intp</tt> - is the argument an int? - - <tt>array intp(mixed arg); - - </tt> - Returns 1 if arg is an int, zero otherwise. - - int</text> - - <group><seealso/><text> - <ref resolved='predef::arrayp' to='arrayp'>arrayp</ref>, <ref resolved='predef::programp' to='programp'>programp</ref>, <ref resolved='predef::floatp' to='floatp'>floatp</ref>, <ref resolved='predef::stringp' to='stringp'>stringp</ref>, <ref resolved='predef::objectp' to='objectp'>objectp</ref>, <ref resolved='predef::mappingp' to='mappingp'>mappingp</ref>, <ref resolved='predef::multisetp' to='multisetp'>multisetp</ref> and <ref resolved='predef::functionp' to='functionp'>functionp</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='kill' homogen-type='method'> - <method name='kill'/><doc placeholder='true'> - <text> - <tt>kill</tt> - send signal to other process - - <tt>int kill(int pid, int signal) - - </tt> - Kill sends a signal to another process. If something goes wrong - -1 is returned, 0 otherwise. - - Some signals and their supposed purpose: - - <matrix> - <r><c> SIGHUP </c><c> Hangup, sent to process when user logs out </c></r> - <r><c> SIGINT </c><c> Interrupt, normally sent by ctrl-c </c></r> - <r><c> SIGQUIT </c><c> Quit, sent by ctrl-\ </c></r> - <r><c> SIGILL </c><c> Illegal instruction </c></r> - <r><c> SIGTRAP </c><c> Trap, mostly used by debuggers </c></r> - <r><c> SIGABRT </c><c> Aborts process, can be caught, used by Pike whenever something goes seriously wrong. </c></r> - <r><c> SIGBUS </c><c> Bus error </c></r> - <r><c> SIGFPE </c><c> Floating point error (such as division by zero) </c></r> - <r><c> SIGKILL </c><c> Really kill a process, cannot be caught </c></r> - <r><c> SIGUSR1 </c><c> Signal reserved for whatever you want to use it for. </c></r> - <r><c> SIGSEGV </c><c> Segmentation fault, caused by accessing memory where you shouldn't. Should never happen to Pike. </c></r> - <r><c> SIGUSR2 </c><c> Signal reserved for whatever you want to use it for. </c></r> - <r><c> SIGALRM </c><c> Signal used for timer interrupts. </c></r> - <r><c> SIGTERM </c><c> Termination signal </c></r> - <r><c> SIGSTKFLT </c><c> Stack fault </c></r> - <r><c> SIGCHLD </c><c> Child process died </c></r> - <r><c> SIGCONT </c><c> Continue suspended </c></r> - <r><c> SIGSTOP </c><c> Stop process </c></r> - <r><c> SIGSTP </c><c> Suspend process </c></r> - <r><c> SIGTTIN </c><c> tty input for background process </c></r> - <r><c> SIGTTOU </c><c> tty output for background process </c></r> - <r><c> SIGXCPU </c><c> Out of cpu </c></r> - <r><c> SIGXFSZ </c><c> File size limit exceeded </c></r> - <r><c> SIGPROF </c><c> Profile trap </c></r> - <r><c> SIGWINCH </c><c> Window change signal </c></r> - </matrix> - - - Note that you have to use signame to translate the name of a signal - to it's number. - </text> - - <group><seealso/><text> - <ref resolved='predef::signal' to='signal'>signal</ref>, <ref resolved='predef::signum' to='signum'>signum</ref>, <ref resolved='predef::signame' to='signame'>signame</ref> and <ref resolved='predef::fork' to='predef::fork'>files/fork</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='l_sizeof' homogen-type='method'> - <method name='l_sizeof'/><doc placeholder='true'> - <text> - <tt>l_sizeof</tt> - Return the size of a multiset - - <tt>#include <simulate.h> - - - int l_sizeof(multiset m); - - </tt> - This function is equal to sizeof. - - multiset</text> - - <group><seealso/><text> - <ref resolved='predef::sizeof' to='predef::sizeof'>builtin/sizeof</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='lambda' homogen-type='method'> - <method name='lambda'/><doc placeholder='true'> - <text> - <tt>lambda</tt> - write nameless functions - - <tt>lambda(<argument specifications>) { code } - - </tt> - Lambda let's you write a function as a value to a function call - or anywhere where you can enter an expression. Using lambda is - basically the same as defining the function before the current - function with a temporary name and then use the name instead. - </text> - - <group><example/><text> - <tt>/* These two lettersort routines are equal */ - string *lettersort(string *words) - { - <dl><group><text>return sort_array(lettersort, lambda(string a,string b) - <dl><group><text>{ - <dl><group><text>return a < b; - </text></group></dl>}); - </text></group></dl></text></group></dl>} - - - int tmp_cmp_fun(string a, string b) - { - <dl><group><text>return a < b; - </text></group></dl>} - - - string *lettersort(string *words) - { - <dl><group><text>return sort_array(lettersort, tmp_cmp_fun); - </text></group></dl>} - - </tt></text></group> - - <group><note/><text> - function_name() will return something for lambda functions, - what it returns is unspecified though. - </text></group> - - <group><bugs/><text> - confuses the hell out of C indent programs - - pike</text></group> - - <group><seealso/><text> - <ref resolved='predef::class' to='class'>class</ref> and <ref resolved='predef::function' to='function'>function</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='listp' homogen-type='method'> - <method name='listp'/><doc placeholder='true'> - <text> - <tt>listp</tt> - is the argument a list? (multiset) - - <tt>#include <simulate.h> - - - int listp(mixed l) - - </tt> - This function is the same as multisetp. - </text> - - <group><seealso/><text> - <ref resolved='predef::multisetp' to='predef::multisetp'>builtin/multisetp</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='load_module' homogen-type='method'> - <method name='load_module'/><doc placeholder='true'> - <text> - <tt>load_module</tt> - load a binary module - - <tt>int load_module(string module_name); - - </tt> - This function loads a module written in C or some other language - into Pike. The module is initialized and any programs or constants - defined will immediately be available. - - When a module is loaded the functions init_module_efuns and - init_module_programs are called to initialize it. When Pike exits - exit_module is called in all dynamically loaded modules. These - functions _must_ be available in the module. - - Please see the source and any examples available at - ftp://www.infovav.se/pub/pike for more information on how to - write modules for Pike in C. - </text> - - <group><bugs/><text> - Please use "./name.so" instead of just "foo.so" for the module - name. If you use just "foo.se" the module will not be found. - - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='localtime' homogen-type='method'> - <method name='localtime'/><doc placeholder='true'> - <text> - <tt>localtime</tt> - break down time() into intelligible components - - <tt>mapping(string:int) localtime(int time); - - </tt> - Given a time represented as second since 1970, as returned by the - function time(), this function returns a mapping with the following - components: - - <matrix> - <r><c> sec </c><c> seconds over the minute </c><c> 0 - 59 </c></r> - <r><c> min </c><c> minutes over the hour </c><c> 0 - 59 </c></r> - <r><c> hour </c><c> what hour in the day </c><c> 0 - 23 </c></r> - <r><c> mday </c><c> day of the month </c><c> 1 - 31 </c></r> - <r><c> mon </c><c> what month </c><c> 0 - 11 </c></r> - <r><c> year </c><c> years since 1900 </c><c> 0 - </c></r> - <r><c> wday </c><c> day of week (0=sunday) </c><c> 0 - 6 </c></r> - <r><c> yday </c><c> day of year </c><c> 0 - 365 </c></r> - <r><c> isdst </c><c> is daylight saving time </c><c> 0/1 </c></r> - <r><c> timezone </c><c> differance between </c></r> - <r><c> </c><c> </c><c> local time and UTC </c></r> - </matrix> - - </text> - - <group><note/><text> - The 'timezone' might not be available on all platforms. - </text></group> - - <group><seealso/><text> - <ref resolved='predef::time' to='time'>time</ref> - </text></group> - - </doc> - </docgroup> + <docgroup homogen-name='log' homogen-type='method'> <method name='log'/><doc placeholder='true'> <text>
5561: </doc> </docgroup> - <docgroup homogen-name='lower_case' homogen-type='method'> - <method name='lower_case'/><doc placeholder='true'> - <text> - <tt>lower_case</tt> - convert a string to lower case - - <tt>string lower_case(string s); - - </tt> - Return a string with all capital letters converted to lower case. - - string</text> - - <group><seealso/><text> - <ref resolved='predef::upper_case' to='upper_case'>upper_case</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='m_delete' homogen-type='method'> - <method name='m_delete'/><doc placeholder='true'> - <text> - <tt>m_delete</tt> - remove an index from a mapping - - <tt>mapping m_delete(mapping map, mixed index); - - </tt> - Remove the entry with index 'index' from mapping 'map' destructively. - Return the changed mapping. If the mapping does not have an - entry with index 'index', nothing is done. - Note that m_delete changes map destructively and only returns - the mapping for compatibility reasons. - - mapping</text> - - <group><seealso/><text> - <ref resolved='predef::mappingp' to='mappingp'>mappingp</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='m_indices' homogen-type='method'> - <method name='m_indices'/><doc placeholder='true'> - <text> - <tt>m_indices</tt> - return all indices from a mapping - - <tt>#include <simulate.h> - - - mixed *m_indices(mapping m); - - </tt> - This function is equal to indices - - mapping</text> - - <group><seealso/><text> - <ref resolved='predef::indices' to='predef::indices'>builtin/indices</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='m_sizeof' homogen-type='method'> - <method name='m_sizeof'/><doc placeholder='true'> - <text> - <tt>m_sizeof</tt> - Return the size of a mapping - - <tt>#include <simulate.h> - - - int m_sizeof(mapping m); - - </tt> - This function is equal to sizeof. - - mapping</text> - - <group><seealso/><text> - <ref resolved='predef::sizeof' to='predef::sizeof'>builtin/sizeof</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='m_values' homogen-type='method'> - <method name='m_values'/><doc placeholder='true'> - <text> - <tt>m_values</tt> - return all values from a mapping - - <tt>#include <simulate.h> - - - mixed *m_values(mapping m); - - </tt> - This function is equal to values - - mapping</text> - - <group><seealso/><text> - <ref resolved='predef::values' to='predef::values'>builtin/values</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='map' homogen-type='method'> - <method name='map'/><doc placeholder='true'> - <text> - <tt>map</tt> - map an array or mapping over a function - - <tt>mixed *map(mixed arr,function fun,mixed ... args); - or - mixed *map(object *arr,string fun,mixed ... args); - or - mixed *map(function *arr,-1,mixed ... arg); - - </tt> - First syntax: - Map array returns an array holding the items of arr mapped thrugh - the function fun. ie. arr[x]=fun(arr[x], @args) for all x. - - Second syntax: - Map array calls function fun in all objects in the array arr. - ie. arr[x]=arr[x]->fun(@ args); - - Third syntax: - Map array calls the functions in the array arr: - arr[x]=arr[x]->fun(@ args); - - array</text> - - <group><seealso/><text> - <ref resolved='predef::sum_arrays' to='sum_arrays'>sum_arrays</ref> and <ref resolved='predef::filter' to='filter'>filter</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='map_array' homogen-type='method'> - <method name='map_array'/><doc placeholder='true'> - <text> - <tt>map_array</tt> - map an array over a function - - <tt>mixed *map_array(mixed *arr,function fun,mixed ... args); - or - mixed *map_array(object *arr,string fun,mixed ... args); - or - mixed *map_array(function *arr,-1,mixed ... arg); - - </tt> - This function is the same as map. - - array</text> - - <group><seealso/><text> - <ref resolved='predef::filter_array' to='filter_array'>filter_array</ref>, <ref resolved='predef::sum_arrays' to='sum_arrays'>sum_arrays</ref> and <ref resolved='predef::map' to='map'>map</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='mapping' homogen-type='method'> - <method name='mapping'/><doc placeholder='true'> - <text> - <tt>mapping</tt> - an associative array - - <tt>([ index1:data1, index2:data2 ]) - - </tt> - A mapping is basically an array that can be indexed on any type, not - not just integers. It can also be seen as a way of linking data - (usaully strings) together. It consists of a lot of index-data pairs - which are linked togeter in such a way that map[index1] returns data1. - It is also possible to set that data by writing map[index1]=new_data1. - If you try to set an index in a mapping that isn't already present in - the mapping then it will be added. - - Here follows a list of operators that applies to mappings: - In this list a and b is used to represent a mapping expression: - - <matrix> - <r><c> a + b </c><c> summation ( ([1:1]) + ([2:2,2:2]) returns ([1:1,2:2,2:2]) ) </c></r> - <r><c> a - b </c><c> subtraction, returns a copy of a with all pairs whos index is present in b removed. </c></r> - <r><c> a & b </c><c> intersection, return a mapping with all indices that are resent in both a and b, if an index is present in both a & b the data for that index will be taken from b. </c></r> - <r><c> a | b </c><c> union, return a mapping with all values that are present in a or b, differs from summation in that values that are present in both a and b are only returned once, as with intersection, data will be taken from b when possible. </c></r> - <r><c> a ^ b </c><c> xor, return a mapping with all indices that are present in a or b but not in both. </c></r> - <r><c> a == b </c><c> returns 1 if a is the same mapping as b, same size, indices and values is not enough, 0 otherwise. </c></r> - <r><c> a != b </c><c> returns 0 if a is the same mapping as b, same size, indices and values is not enough, 1 otherwise. </c></r> - <r><c> ! a </c><c> boolean not, returns 0 </c></r> - <r><c> a[c] </c><c> indexing, returns the value associated with the value c in the mapping a. If there is no index c in the mapping zero will be returned. (With zero_type = 1) </c></r> - <r><c> a[c]=d </c><c> setting, this associates d with c in the mapping, the index c will be added to the mapping automatically if it isn't already there. </c></r> - </matrix> - - - types</text> - - <group><seealso/><text> - <ref resolved='predef::array' to='array'>array</ref>, <ref resolved='predef::multiset' to='multiset'>multiset</ref>, <ref resolved='predef::sizeof' to='predef::sizeof'>builtin/sizeof</ref>, <ref resolved='predef::indices' to='predef::indices'>builtin/indices</ref>, <ref resolved='predef::values' to='predef::values'>builtin/values</ref> and <ref resolved='predef::zero_type' to='predef::zero_type'>builtin/zero_type</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='mappingp' homogen-type='method'> - <method name='mappingp'/><doc placeholder='true'> - <text> - <tt>mappingp</tt> - is the argument an mapping? - - <tt>int mappingp(mixed arg); - - </tt> - Returns 1 if arg is a mapping, zero otherwise. - - mapping</text> - - <group><seealso/><text> - <ref resolved='predef::intp' to='intp'>intp</ref>, <ref resolved='predef::programp' to='programp'>programp</ref>, <ref resolved='predef::arrayp' to='arrayp'>arrayp</ref>, <ref resolved='predef::stringp' to='stringp'>stringp</ref>, <ref resolved='predef::objectp' to='objectp'>objectp</ref>, <ref resolved='predef::multisetp' to='multisetp'>multisetp</ref>, <ref resolved='predef::floatp' to='floatp'>floatp</ref> and <ref resolved='predef::functionp' to='functionp'>functionp</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='master' homogen-type='method'> - <method name='master'/><doc placeholder='true'> - <text> - <tt>master</tt> - return the master object - - <tt>object master(); - - </tt> - Master is added by the master object to make it easier to access it. - - object</text> - - </doc> - </docgroup> - <docgroup homogen-name='member_array' homogen-type='method'> - <method name='member_array'/><doc placeholder='true'> - <text> - <tt>member_array</tt> - find first occurance of a value in an array - - <tt>#include <simulate.h> - - - int member_array(mixed item, mixed *arr); - - </tt> - Returns the index of the first occurence of item in array arr. - If not found, then -1 is returned. - - array</text> - - </doc> - </docgroup> - <docgroup homogen-name='mixed' homogen-type='method'> - <method name='mixed'/><doc placeholder='true'> - <text> - <tt>mixed</tt> - any type - - This is not really a type. But this keyword can be used to specify - that a variable, argument or return type can be of any type. - </text> - - <group><example/><text> - <tt>mixed i=1; - mixed j="foo"; - mixed foo() { return "bar"; } - mixed bar() { return ({}); } - - </tt> - types</text></group> - - </doc> - </docgroup> + <docgroup homogen-name='mkdir' homogen-type='method'> <method name='mkdir'/><doc placeholder='true'> <text>
5847: </doc> </docgroup> - <docgroup homogen-name='mklist' homogen-type='method'> - <method name='mklist'/><doc placeholder='true'> - <text> - <tt>mklist</tt> - make a multiset - - <tt>#include <simulate.h> - - - multiset mklist(mixed *a) - - </tt> - This function creates a multiset from an array. - </text> - - <group><example/><text> - <tt>> mklist( ({1,2,3}) ); - Result: (< /* 3 elements */ - <dl><group><text>1, - 2, - 3 - </text></group></dl>>) - - </tt> - multiset</text></group> - - <group><seealso/><text> - <ref resolved='predef::aggregate_multiset' to='predef::aggregate_multiset'>builtin/aggregate_multiset</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='mkmapping' homogen-type='method'> - <method name='mkmapping'/><doc placeholder='true'> - <text> - <tt>mkmapping</tt> - make a mapping from two arrays - - <tt>mapping mkmapping(mixed *ind, mixed *val); - - </tt> - Makes a mapping ind[x]:val[x], 0<=x<sizeof(ind). - Ind and val must have the same size. - This is the inverse operation of indices and values. - - mapping</text> - - <group><seealso/><text> - <ref resolved='predef::indices' to='indices'>indices</ref> and <ref resolved='predef::values' to='values'>values</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='mkmultiset' homogen-type='method'> - <method name='mkmultiset'/><doc placeholder='true'> - <text> - <tt>mkmultiset</tt> - make a multiset - - <tt>multiset mkmultiset(mixed *a) - - </tt> - This function creates a multiset from an array. - </text> - - <group><example/><text> - <tt>> mkmultiset( ({1,2,3}) ); - Result: (< /* 3 elements */ - <dl><group><text>1, - 2, - 3 - </text></group></dl>>) - - </tt> - multiset</text></group> - - <group><seealso/><text> - <ref resolved='predef::aggregate_multiset' to='predef::aggregate_multiset'>builtin/aggregate_multiset</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='modifier' homogen-type='method'> - <method name='modifier'/><doc placeholder='true'> - <text> - <tt>modifier</tt> - modify function / variable definitions - - Modifiers makes it possible to give functions and gobal variables - certain characteristics. A list of modifiers follows: - - <matrix> - <r><c> static </c><c> make this identifier unavailable by indexing </c></r> - <r><c> inline </c><c> allow inlining this function </c></r> - <r><c> private </c><c> hide this identifier to inheriting programs </c></r> - <r><c> nomask </c><c> don't allow this identifier to be re-defined </c></r> - </matrix> - - - pike</text> - - <group><seealso/><text> - <ref resolved='predef::functions' to='functions'>functions</ref> and <ref resolved='predef::variables' to='variables'>variables</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='multiset' homogen-type='method'> - <method name='multiset'/><doc placeholder='true'> - <text> - <tt>multiset</tt> - a set of values - - <tt>(< 1, 7, 8, 9 >) - - </tt> - A multiset is basically a mapping without data values, when indexing a - multiset 1 willl be returned if the index is present, zero otherwise. - - Here follows a list of operators that applies to multisets: - In this list a and b is used to represent a multiset expression: - - <matrix> - <r><c> a + b </c><c> summation ( (<1>) + (<2>) returns (<1,2>) ) </c></r> - <r><c> a - b </c><c> subtraction, returns a copy of a with all values that are present in b removed. </c></r> - <r><c> a & b </c><c> intersection, return a multiset with all values that are present in both a & b. </c></r> - <r><c> a | b </c><c> union, return a multiset with all values that are present in a or b, differs from summation in that values that are present in both a and b are only returned once. </c></r> - <r><c> a ^ b </c><c> xor, return a multiset with all indices that are present in a or b but not in both. </c></r> - <r><c> a == b </c><c> returns 1 if a is the same multiset as b, same size and values is not enough. </c></r> - <r><c> a != b </c><c> returns 1 if a is the same multiset as b, same size and values is not enough. </c></r> - <r><c> ! a </c><c> boolean not, returns 0 </c></r> - <r><c> a[c] </c><c> indexing, returns 1 c is present in the multiset a. </c></r> - <r><c> a[c]=d </c><c> setting, if d is true, c is added to the multiset if it is not present already. If d is false, it is removed if it is present. </c></r> - </matrix> - - - types</text> - - <group><seealso/><text> - <ref resolved='predef::mapping' to='mapping'>mapping</ref>, <ref resolved='predef::array' to='array'>array</ref>, <ref resolved='predef::indices' to='predef::indices'>builtin/indices</ref> and <ref resolved='predef::sizeof' to='predef::sizeof'>builtin/sizeof</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='multisetp' homogen-type='method'> - <method name='multisetp'/><doc placeholder='true'> - <text> - <tt>multisetp</tt> - is the argument a multiset? - - <tt>int multisetp(mixed arg); - - </tt> - Returns 1 if arg is a multiset, zero otherwise. - - multiset</text> - - <group><seealso/><text> - <ref resolved='predef::intp' to='intp'>intp</ref>, <ref resolved='predef::programp' to='programp'>programp</ref>, <ref resolved='predef::arrayp' to='arrayp'>arrayp</ref>, <ref resolved='predef::stringp' to='stringp'>stringp</ref>, <ref resolved='predef::objectp' to='objectp'>objectp</ref>, <ref resolved='predef::mappingp' to='mappingp'>mappingp</ref>, <ref resolved='predef::floatp' to='floatp'>floatp</ref> and <ref resolved='predef::functionp' to='functionp'>functionp</ref> - </text></group> - - </doc> - </docgroup> + <docgroup homogen-name='mv' homogen-type='method'> <method name='mv'/><doc placeholder='true'> <text>
6024: </doc> </docgroup> - <docgroup homogen-name='next_object' homogen-type='method'> - <method name='next_object'/><doc placeholder='true'> - <text> - <tt>next_object</tt> - get next object - - <tt>object next_object(object o); - or - object next_object(); - - </tt> - All objects are stored in a linked list, next_object() returns the - first object in this list, and next_object(o) the next object in the - list after o. - </text> - - <group><example/><text> - <tt>/* This example calls shutting_down() in all cloned objects */ - object o; - for(o=next_object();o;o=next_object(o)) - <dl><group><text>o->shutting_down(); - </text></group></dl> - </tt> - object</text></group> - - <group><seealso/><text> - <ref resolved='predef::clone' to='clone'>clone</ref> and <ref resolved='predef::destruct' to='destruct'>destruct</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='object' homogen-type='method'> - <method name='object'/><doc placeholder='true'> - <text> - <tt>object</tt> - an instance of a class (program) - - There is no syntax example in this file because there is no way to - write constant object. The only way to make new objects is to use - clone() on a program. - - Here follows a list of operators that applies to objects: - In this list, o and o2 are used to represent object expressions, - and s is a string expression: - - <matrix> - <r><c> o[s] </c><c> indexing, returns the identifier named s in the object o, </c></r> - <r><c> </c><c> an identifier is a global variable or a function. </c></r> - <r><c> o[s]=c </c><c> This sets the global variable s int the object o to c, if s is a function however, an error is produced. </c></r> - <r><c> o->foo </c><c> same as o["foo"] </c></r> - <r><c> o == o2 </c><c> return 1 if o and o2 are the same object </c></r> - <r><c> o != o2 </c><c> return 0 if o and o2 are the same object </c></r> - </matrix> - - - types</text> - - <group><seealso/><text> - <ref resolved='predef::program' to='program'>program</ref>, <ref resolved='predef::function' to='function'>function</ref>, <ref resolved='predef::clone' to='predef::clone'>builtin/clone</ref> and <ref resolved='predef::destruct' to='predef::destruct'>builtin/destruct</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='object_program' homogen-type='method'> - <method name='object_program'/><doc placeholder='true'> - <text> - <tt>object_program</tt> - get the program asociated with the object - - <tt>program object_program(object o); - - </tt> - This function returns the program from which o was cloned. - If o is not an object, or o was destructed zero is returned. - - object</text> - - <group><seealso/><text> - <ref resolved='predef::clone' to='clone'>clone</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='objectp' homogen-type='method'> - <method name='objectp'/><doc placeholder='true'> - <text> - <tt>objectp</tt> - is the argument an object? - - <tt>int objectp(mixed arg); - - </tt> - Returns 1 if arg is an object, zero otherwise. - - object</text> - - <group><seealso/><text> - <ref resolved='predef::intp' to='intp'>intp</ref>, <ref resolved='predef::programp' to='programp'>programp</ref>, <ref resolved='predef::floatp' to='floatp'>floatp</ref>, <ref resolved='predef::stringp' to='stringp'>stringp</ref>, <ref resolved='predef::arrayp' to='arrayp'>arrayp</ref>, <ref resolved='predef::mappingp' to='mappingp'>mappingp</ref>, <ref resolved='predef::multisetp' to='multisetp'>multisetp</ref> and <ref resolved='predef::functionp' to='functionp'>functionp</ref> - </text></group> - - </doc> - </docgroup> + <docgroup homogen-name='openlog' homogen-type='method'> <method name='openlog'/><doc placeholder='true'> <text>
6180: </doc> </docgroup> - <docgroup homogen-name='operators' homogen-type='method'> - <method name='operators'/><doc placeholder='true'> - <text> - <tt>operators</tt> - arethmics and other stuff - - Pike has the following operators: - - <matrix> - <r><c> a(args) </c><c> function call </c></r> - <r><c> a[b..c] </c><c> range </c></r> - <r><c> a[b] </c><c> index </c></r> - <r><c> --a </c><c> pre decrement </c></r> - <r><c> a-- </c><c> post decrement </c></r> - <r><c> ++a </c><c> pre increment </c></r> - <r><c> a++ </c><c> post increment </c></r> - <r><c> (type)a </c><c> cast </c></r> - <r><c> ~a </c><c> complement </c></r> - <r><c> !a </c><c> not </c></r> - <r><c> -a </c><c> negate </c></r> - <r><c> a/b </c><c> divide </c></r> - <r><c> a%b </c><c> modulo </c></r> - <r><c> a*b </c><c> multiply </c></r> - <r><c> a-b </c><c> subtract </c></r> - <r><c> a+b </c><c> add </c></r> - <r><c> >> </c><c> shift right </c></r> - <r><c> << </c><c> shift left </c></r> - <r><c> a>b </c><c> greater than? </c></r> - <r><c> a<c> lesser than? </c></r> - <r><c> a>=b </c><c> greater or equal than? </c></r> - <r><c> a<=b </c><c> lesser or equal than? </c></r> - <r><c> a!=b </c><c> not equal to? </c></r> - <r><c> a==b </c><c> equal to? </c></r> - <r><c> a&b </c><c> intersection </c></r> - <r><c> a^b </c><c> xor (symmetric differance) </c></r> - <r><c> a|b </c><c> union </c></r> - <r><c> a&&b </c><c> logical and </c></r> - <r><c> a||b </c><c> logical or </c></r> - <r><c> a?b:c </c><c> condition </c></r> - <r><c> a=b </c><c> assignment </c></r> - </matrix> - - - The ones at the top of the list are parsed before operators lower - down on the list. This means that a|b&c means a|(b&c) not (a|b)&c. - Look at the individual pages for fuller explanations of what they do. - - Then there is also the @ "splice" operator which can only be used in - argument lists. - - Arguments to operators are always computed from left to right. - - Many (but not all) of these operators can also be used as by prepending - with a ` sign. For instance `+(a,b) is the same as a+b. These functions - are called "operator functions" and the following are currently - available: - - `== `!= `! `< `<= `> `>= `+ `- `& `| `^ `<< `>> `* `/ `% `~ - - These operator functions are basically "efuns", but beware, if you - re-define the `+ function a+b will also be redefined. - - On top of all this, many operators can also be overloaded. Overloading - an operator lets you specify how operators works on your objects. - To overload an operator you simply put the corresponding operator - function as a method in your object. An example: - - > program nine=class { - <dl><group><text>int `+(int arg) { return arg+9; } - </text></group></dl>}; - Result: program - > clone(nine)+1; - Result: 10 - > - - - This little example defines a program that works almost like the number - nine. As you can see, clone(nine)+1 is the same as clone(nine)->`+(1) - in this case, and that is the whole point of operator overloading. - Note however that it would not have worked to write 1+clone(nine) - because operator overloading only works if the first argument is the - object with the overloaded function. Well, almost anyway, the operators - <, >, <=, >= can check both sides. In fact, the methods `<= and `>= - will never be called since Pike will translate a<=b to !(a>b). - - These are the operators you can overload: - - <matrix> - <r><c> `== </c><c> also overloads `!= </c></r> - <r><c> `! </c><c> This is also used by if-statements to find out if the object in question is 'true' or not. </c></r> - <r><c> `< </c><c> also overloads `>= </c></r> - <r><c> `> </c><c> also overloads `<= </c></r> - <r><c> `+ </c><c> </c></r> - <r><c> `- </c><c> </c></r> - <r><c> `& </c><c> </c></r> - <r><c> `| </c><c> </c></r> - <r><c> `^ </c><c> </c></r> - <r><c> `<< </c><c> </c></r> - <r><c> `>> </c><c> </c></r> - <r><c> `* </c><c> </c></r> - <r><c> `/ </c><c> </c></r> - <r><c> `% </c><c> </c></r> - <r><c> `~ </c><c> </c></r> - </matrix> - - - If you also define a function __hash to return an integer, which - must be equal for all objects where `== is true you can index mappings - on the contents of your objects rather than on the object itself. - More details about this will come later. - </text> - - <group><seealso/><text> - <ref resolved='predef::Gmp.mpz' to='Gmp.mpz'>Gmp.mpz</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='perror' homogen-type='method'> - <method name='perror'/><doc placeholder='true'> - <text> - <tt>perror</tt> - print error - - <tt>#include <stdio.h> - - - void perror(string s); - - </tt> - This function prints a message to stderr along with a description - of what went wrong if available. It uses the system errno to find - out what went wrong, so it is only applicable to IO errors. - - file</text> - - <group><seealso/><text> - <ref resolved='predef::werror' to='werror'>werror</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='popen' homogen-type='method'> - <method name='popen'/><doc placeholder='true'> - <text> - <tt>popen</tt> - pipe open - - <tt>#include <process.h> - - - string popen(string cmd); - - </tt> - This function runs the command cmd as in a shell and returns the - output. See your unix/C manual for details on popen. - - - </text> - - </doc> - </docgroup> + <docgroup homogen-name='pow' homogen-type='method'> <method name='pow'/><doc placeholder='true'> <text>
6357: </doc> </docgroup> - <docgroup homogen-name='previous_object' homogen-type='method'> - <method name='previous_object'/><doc placeholder='true'> - <text> - <tt>previous_object</tt> - return the calling object - - <tt>#include <simulate.h> - - - object previous_object(); - - </tt> - Returns an object pointer to the object that called current function, - if any. - </text> - - <group><seealso/><text> - <ref resolved='predef::call_function' to='predef::call_function'>builtin/call_function</ref> and <ref resolved='predef::backtrace' to='predef::backtrace'>builtin/backtrace</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='program' homogen-type='method'> - <method name='program'/><doc placeholder='true'> - <text> - <tt>program</tt> - a class, or blueprint for an object - - There is no syntax example in this file because there is no way to - write constant programs. (yet) New programs are made with - compile_file() or compile_string(). Programs are only useful as - arguments to clone() and the only operators that applies to programs - are == and !=. - </text> - - <group><note/><text> - In Pike the term 'program' is somewhat confusing, becuase it is used - both to reference a complete runnable software package, and to a - structure in Pike containing code. - - types</text></group> - - <group><seealso/><text> - <ref resolved='predef::object' to='object'>object</ref>, <ref resolved='predef::function' to='function'>function</ref>, <ref resolved='predef::compile_file' to='predef::compile_file'>builtin/compile_file</ref>, <ref resolved='predef::compile_string' to='predef::compile_string'>builtin/compile_string</ref> and <ref resolved='predef::clone' to='predef::clone'>builtin/clone</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='programp' homogen-type='method'> - <method name='programp'/><doc placeholder='true'> - <text> - <tt>programp</tt> - is the argument an program? - - <tt>int programp(mixed arg); - - </tt> - Returns 1 if arg is a program, zero otherwise. - - program</text> - - <group><seealso/><text> - <ref resolved='predef::intp' to='intp'>intp</ref>, <ref resolved='predef::multisetp' to='multisetp'>multisetp</ref>, <ref resolved='predef::arrayp' to='arrayp'>arrayp</ref>, <ref resolved='predef::stringp' to='stringp'>stringp</ref>, <ref resolved='predef::objectp' to='objectp'>objectp</ref>, <ref resolved='predef::mappingp' to='mappingp'>mappingp</ref>, <ref resolved='predef::floatp' to='floatp'>floatp</ref> and <ref resolved='predef::functionp' to='functionp'>functionp</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='putenv' homogen-type='method'> - <method name='putenv'/><doc placeholder='true'> - <text> - <tt>putenv</tt> - put environment variable - - <tt>void putenv(string varname, string value); - - </tt> - This function sets the environment variable 'varname' to 'value'. - </text> - - <group><seealso/><text> - <ref resolved='predef::getenv' to='getenv'>getenv</ref> and <ref resolved='predef::exece' to='exece'>exece</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='query_host_name' homogen-type='method'> - <method name='query_host_name'/><doc placeholder='true'> - <text> - <tt>query_host_name</tt> - return the name of the host we are running on - - <tt>string query_host_name(); - - </tt> - This function returns the name of the machine the interpreter is - running on. This is the same thing that the command 'hostname' - prints. - - </text> - - </doc> - </docgroup> - <docgroup homogen-name='query_num_arg' homogen-type='method'> - <method name='query_num_arg'/><doc placeholder='true'> - <text> - <tt>query_num_arg</tt> - find out how many arguments were given - - <tt>int query_num_arg(); - - </tt> - Query_num_arg returns the number of arguments given when this - function was called. This is only useful for varargs functions. - </text> - - <group><seealso/><text> - <ref resolved='predef::call_function' to='call_function'>call_function</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='random' homogen-type='method'> - <method name='random'/><doc placeholder='true'> - <text> - <tt>random</tt> - return a random number - - <tt>int random(int max); - - </tt> - This function returns a random number in the range 0 - max-1. - - int</text> - - <group><seealso/><text> - <ref resolved='predef::random_seed' to='random_seed'>random_seed</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='random_seed' homogen-type='method'> - <method name='random_seed'/><doc placeholder='true'> - <text> - <tt>random_seed</tt> - seed random generator - - <tt>void random_seed(int seed); - - </tt> - This function sets the initial value for the random generator. - </text> - - <group><example/><text> - <tt>Pike v1.0E-13 Running Hilfe v1.2 (Hubbe's Incremental Pike FrontEnd) - > random_seed(17); - Result: 0 - > random(1000); - Result: 732 - > random(1000); - Result: 178 - > random(1000); - Result: 94 - > random_seed(17); - Result: 0 - > random(1000); - Result: 732 - > random(1000); - Result: 178 - > random(1000); - Result: 94 - > - - </tt> - int</text></group> - - <group><seealso/><text> - <ref resolved='predef::random' to='random'>random</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='range' homogen-type='method'> - <method name='range'/><doc placeholder='true'> - <text> - <tt>range</tt> - cut a slice of an array or string - - <tt>a [ b .. c ] - or - a [ .. c ] - or - a [ b .. ] - - </tt> - This operator cuts out a piece of an array or string. If a is an array - a[b..c] will return an array containing a[b], a[b+1], a[b+2] to a[c]. - Given a string about the same thing will happen, except the the result - will be a string of course. If b is omitted, everything from the - beginning up to and including c will be included. If c is omitted - the result will include everything from (and including) b to the end. - </text> - - <group><example/><text> - <tt><matrix> - <r><c> "foobar"[0..2] </c><c> returns "foo" </c></r> - <r><c> "foobar"[3..5] </c><c> returns "bar" </c></r> - <r><c> ({1,2,3})[..1] </c><c> returns ({1,2}) </c></r> - <r><c> ({1,2,3})[1..] </c><c> returns ({2,3}) </c></r> - <r><c> ({1,2,3})[..] </c><c> returns ({1,2,3}) </c></r> - </matrix> - - </tt> - operators</text></group> - - <group><seealso/><text> - <ref resolved='predef::index' to='index'>index</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='read_bytes' homogen-type='method'> - <method name='read_bytes'/><doc placeholder='true'> - <text> - <tt>read_bytes</tt> - read a number of bytes into a string from a file - - <tt>#include <stdio.h> - - - string read_bytes(string file,int start,int len); - - </tt> - Read len number of bytes from file file staring at byte start and - return it as a string. - - file</text> - - <group><seealso/><text> - <ref resolved='predef::write_file' to='write_file'>write_file</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='read_file' homogen-type='method'> - <method name='read_file'/><doc placeholder='true'> - <text> - <tt>read_file</tt> - read a number of lines into a string from file - - <tt>#include <stdio.h> - - - string read_file(string file, int start, int len); - - </tt> - Read 'len' lines from the file 'file' after skipping 'start' lines - and return those lines as a string. If start and len are omitted - the whole file is read. - - file</text> - - <group><seealso/><text> - <ref resolved='predef::read_bytes' to='read_bytes'>read_bytes</ref> and <ref resolved='predef::write_file' to='write_file'>write_file</ref> - </text></group> - - </doc> - </docgroup> + <docgroup homogen-name='readline' homogen-type='method'> <method name='readline'/><doc placeholder='true'> <text>
6646: file</text> <group><seealso/><text> - <ref resolved='predef::system' to='system/symlink'>system/symlink</ref> + <ref to='system/symlink'>system/symlink</ref> </text></group> </doc> </docgroup> - <docgroup homogen-name='regexp' homogen-type='method'> - <method name='regexp'/><doc placeholder='true'> - <text> - <tt>regexp</tt> - filter an array through a regexp - - <tt>#include <simulate.h> - - - string *regexp(string *arr, string reg); - - </tt> - Return those strings in arr that matches the regexp in reg. - - string</text> - - <group><seealso/><text> - <ref resolved='predef::regexp' to='regexp/regexp'>regexp/regexp</ref> - </text></group> - - </doc> - </docgroup> + <docgroup homogen-name='remove_call_out' homogen-type='method'> <method name='remove_call_out'/><doc placeholder='true'> <text>
6695: </doc> </docgroup> - <docgroup homogen-name='replace' homogen-type='method'> - <method name='replace'/><doc placeholder='true'> - <text> - <tt>replace</tt> - generic replace function - - <tt>string replace(string s, string from, string to); - or - string replace(string s, string *from, string *to); - or - array replace(array a, mixed from, mixed to); - or - mapping replace(mapping a, mixed from, mixed to); - - </tt> - This function can do several kinds replacement operations, the - different syntaxes do different things as follow: - - string replace(string s, string from, string to); - - <dl><group><text>When given strings as second and third argument, a copy of - s with every occurance of 'from' return 'to' is returned. - </text></group></dl> - - string replace(string s, string *from, string *to); - - <dl><group><text>When given arrays of strings as second and third argument, - every occurance of from[0] in s is replaced by to[0], - from[1] is replaced by to[1] and so on... - </text></group></dl> - - <matrix> - <r><c> array replace(array a, mixed from, mixed to); </c><c> </c></r> - <r><c> mapping replace(mapping a, mixed from, mixed to); </c></r> - </matrix> - - - <dl><group><text>When the first argument is an array or mapping, the values in - a are searched for values equal to from, which are replaced by - to destructively. - </text></group></dl> - - string, array and mapping</text> - - </doc> - </docgroup> - <docgroup homogen-name='return' homogen-type='method'> - <method name='return'/><doc placeholder='true'> - <text> - <tt>return</tt> - return from a function - - <tt>return - or - return expression - - </tt> - Return jumps directly out of a function returning the given value to - the calling function. If no expression is given, 0 is returned. - - control</text> - - </doc> - </docgroup> - <docgroup homogen-name='reverse' homogen-type='method'> - <method name='reverse'/><doc placeholder='true'> - <text> - <tt>reverse</tt> - reverse a string, array or int - - <tt>string reverse(string s); - or - array reverse(arary a); - or - int reverse(int i); - - </tt> - This function reverseses a string, char by char, an array, value - by value or an int, bit by bit and returns the result. Reversing - strings can be particularly useful for parsing difficult syntaxes - which require scanning backwards. - - string, array and int</text> - - <group><seealso/><text> - <ref resolved='predef::sscanf' to='sscanf'>sscanf</ref> - </text></group> - - </doc> - </docgroup> + <docgroup homogen-name='rm' homogen-type='method'> <method name='rm'/><doc placeholder='true'> <text>
6800: </doc> </docgroup> - <docgroup homogen-name='rows' homogen-type='method'> - <method name='rows'/><doc placeholder='true'> - <text> - <tt>rows</tt> - select a set of rows from an array - - <tt>array rows(mixed data, mixed *index) - - </tt> - This function is exactly equivialent to: - - map_array(index,lambda(mixed x,mixed y) { return y[x]; },data) - - Except of course it is a lot shorter and faster. - That is, it indexes data on every index in the array index and - returns an array with the results. - - array</text> - - <group><seealso/><text> - <ref resolved='predef::column' to='column'>column</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='rusage' homogen-type='method'> - <method name='rusage'/><doc placeholder='true'> - <text> - <tt>rusage</tt> - return resource usage - - <tt>int *rusage(); - - </tt> - This function returns an array of ints describing how much resources - the intepreter process has used so far. This array will have at least - 29 elements, of which those values not available on this system will - be zero. The elements are as follows: - - 0: user time - 1: system time - 2: maxrss - 3: idrss - 4: isrss - 5: minflt - 6: minor pagefaults - 7: major pagefaults - 8: swaps - 9: block input op. - 10: block output op. - 11: messages sent - 12: messages received - 13: signals received - 14: voluntary context switches - 15: involuntary context switches - 16: sysc - 17: ioch - 18: rtime - 19: ttime - 20: tftime - 21: dftime - 22: kftime - 23: ltime - 24: slptime - 25: wtime - 26: stoptime - 27: brksize - 28: stksize - - Don't ask me to explain these values, read your system manuals for - more information. (Note that all values may not be present though) - </text> - - <group><seealso/><text> - <ref resolved='predef::time' to='time'>time</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='search' homogen-type='method'> - <method name='search'/><doc placeholder='true'> - <text> - <tt>search</tt> - search for a value in a string or array - - <tt>int search(string haystack, string needle, [ int start ]); - or - int search(mixed *haystack, mixed needle, [ int start ]); - or - mixed search(mapping haystack, mixed needle, [ mixed start ]); - - </tt> - Search for needle in haystack. Return the position of needle in - haystack or -1 if not found. If the optional argument start is present - search is started at this position. Note that when haystack is a string - needle must be a string, and the first occurance of this string is - returned. However, when haystack is an array, needle is compared only - to one value at a time in haystack. - - When the haystack is a mapping, search tries to find the index - connected to the data needle. That is, it tries to lookup the mapping - backwards. If needle isn't present in the mapping, zero is returned, - and zero_type() will return 1 for this zero. - </text> - - <group><note/><text> - This function replaces strstr and member_array from Pike4. - - string, array and mapping</text></group> - - <group><seealso/><text> - <ref resolved='predef::indices' to='indices'>indices</ref>, <ref resolved='predef::values' to='values'>values</ref> and <ref resolved='predef::zero_type' to='zero_type'>zero_type</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='search_array' homogen-type='method'> - <method name='search_array'/><doc placeholder='true'> - <text> - <tt>search_array</tt> - search for something in an array - - <tt>#include <array.h> - - - int search_array(mixed *arr,function fun,mixed arg, ...); - or - int search_array(object *arr,string fun,mixed arg, ...); - or - int search_array(function *arr,-1,mixed arg, ...); - - </tt> - search_array works like map_array, only it returns the index of the - first call that returned true instead or returning an array of the - returned values. If no call returns true, -1 is returned. - - array</text> - - <group><seealso/><text> - <ref resolved='predef::sum_arrays' to='sum_arrays'>sum_arrays</ref>, <ref resolved='predef::filter_array' to='filter_array'>filter_array</ref> and <ref resolved='predef::member_array' to='member_array'>member_array</ref> - </text></group> - - </doc> - </docgroup> + <docgroup homogen-name='setegid' homogen-type='method'> <method name='setegid'/><doc placeholder='true'> <text>
6953: Usersecurity</text> <group><seealso/><text> - <ref resolved='predef::system' to='system/setuid'>system/setuid</ref>, <ref resolved='predef::system' to='system/getuid'>system/getuid</ref>, <ref resolved='predef::system' to='system/setgid'>system/setgid</ref>, <ref resolved='predef::system' to='system/getgid'>system/getgid</ref>, <ref resolved='predef::system' to='system/seteuid'>system/seteuid</ref>, <ref resolved='predef::system' to='system/geteuid'>system/geteuid</ref> and <ref resolved='predef::system' to='system/getegid'>system/getegid</ref> + <ref to='system/setuid'>system/setuid</ref>, <ref to='system/getuid'>system/getuid</ref>, <ref to='system/setgid'>system/setgid</ref>, <ref to='system/getgid'>system/getgid</ref>, <ref to='system/seteuid'>system/seteuid</ref>, <ref to='system/geteuid'>system/geteuid</ref> and <ref to='system/getegid'>system/getegid</ref> </text></group> </doc>
6971: Usersecurity</text> <group><seealso/><text> - <ref resolved='predef::system' to='system/setuid'>system/setuid</ref>, <ref resolved='predef::system' to='system/getuid'>system/getuid</ref>, <ref resolved='predef::system' to='system/setgid'>system/setgid</ref>, <ref resolved='predef::system' to='system/getgid'>system/getgid</ref>, <ref resolved='predef::system' to='system/geteuid'>system/geteuid</ref>, <ref resolved='predef::system' to='system/setegid'>system/setegid</ref> and <ref resolved='predef::system' to='system/getegid'>system/getegid</ref> + <ref to='system/setuid'>system/setuid</ref>, <ref to='system/getuid'>system/getuid</ref>, <ref to='system/setgid'>system/setgid</ref>, <ref to='system/getgid'>system/getgid</ref>, <ref to='system/geteuid'>system/geteuid</ref>, <ref to='system/setegid'>system/setegid</ref> and <ref to='system/getegid'>system/getegid</ref> </text></group> </doc>
6989: Usersecurity</text> <group><seealso/><text> - <ref resolved='predef::system' to='system/setuid'>system/setuid</ref>, <ref resolved='predef::system' to='system/getuid'>system/getuid</ref>, <ref resolved='predef::system' to='system/getgid'>system/getgid</ref>, <ref resolved='predef::system' to='system/seteuid'>system/seteuid</ref>, <ref resolved='predef::system' to='system/geteuid'>system/geteuid</ref>, <ref resolved='predef::system' to='system/setegid'>system/setegid</ref> and <ref resolved='predef::system' to='system/getegid'>system/getegid</ref> + <ref to='system/setuid'>system/setuid</ref>, <ref to='system/getuid'>system/getuid</ref>, <ref to='system/getgid'>system/getgid</ref>, <ref to='system/seteuid'>system/seteuid</ref>, <ref to='system/geteuid'>system/geteuid</ref>, <ref to='system/setegid'>system/setegid</ref> and <ref to='system/getegid'>system/getegid</ref> </text></group> </doc>
7007: Usersecurity</text> <group><seealso/><text> - <ref resolved='predef::system' to='system/getuid'>system/getuid</ref>, <ref resolved='predef::system' to='system/setgid'>system/setgid</ref>, <ref resolved='predef::system' to='system/getgid'>system/getgid</ref>, <ref resolved='predef::system' to='system/seteuid'>system/seteuid</ref>, <ref resolved='predef::system' to='system/geteuid'>system/geteuid</ref>, <ref resolved='predef::system' to='system/setegid'>system/setegid</ref> and <ref resolved='predef::system' to='system/getegid'>system/getegid</ref> + <ref to='system/getuid'>system/getuid</ref>, <ref to='system/setgid'>system/setgid</ref>, <ref to='system/getgid'>system/getgid</ref>, <ref to='system/seteuid'>system/seteuid</ref>, <ref to='system/geteuid'>system/geteuid</ref>, <ref to='system/setegid'>system/setegid</ref> and <ref to='system/getegid'>system/getegid</ref> </text></group> </doc> </docgroup> - <docgroup homogen-name='signal' homogen-type='method'> - <method name='signal'/><doc placeholder='true'> - <text> - <tt>signal</tt> - trap signals - - <tt>void signal(int sig, function(int:void) callback); - or - void signal(int sig); - - </tt> - This function allows you to trap a signal and have a function called - when the process receives a signal. Although it IS possible to trap - SIGBUS, SIGSEGV etc. I advice you not to. Pike should not receive any - such signals and if it does it is because of bugs in the Pike - interperter. And all bugs should be reported, no matter how trifle. - - The callback will receive the signal number as the only argument. - See the document for the function 'kill' for a list of signals. - - If no second argument is given, the signal handler for that signal - is restored to the default handler. - - If the second argument is zero, the signal will be completely ignored. - </text> - - <group><seealso/><text> - <ref resolved='predef::kill' to='kill'>kill</ref>, <ref resolved='predef::signame' to='signame'>signame</ref> and <ref resolved='predef::signum' to='signum'>signum</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='signame' homogen-type='method'> - <method name='signame'/><doc placeholder='true'> - <text> - <tt>signame</tt> - get the name of a signal - - <tt>string signame(int sig); - - </tt> - Return a string describing the signal. - </text> - - <group><example/><text> - <tt>> signame(9); - Result: SIGKILL - - </tt></text></group> - - <group><seealso/><text> - <ref resolved='predef::kill' to='kill'>kill</ref>, <ref resolved='predef::signum' to='signum'>signum</ref> and <ref resolved='predef::signal' to='signal'>signal</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='signum' homogen-type='method'> - <method name='signum'/><doc placeholder='true'> - <text> - <tt>signum</tt> - get a signal number given a desctiptive string - - <tt>int signum(string sig); - - </tt> - This function is the opposite of signame. - </text> - - <group><example/><text> - <tt>> signum("SIGKILL"); - Result: 9 - - </tt></text></group> - - <group><seealso/><text> - <ref resolved='predef::signame' to='signame'>signame</ref>, <ref resolved='predef::kill' to='kill'>kill</ref> and <ref resolved='predef::signal' to='signal'>signal</ref> - </text></group> - - </doc> - </docgroup> + <docgroup homogen-name='sin' homogen-type='method'> <method name='sin'/><doc placeholder='true'> <text>
7107: </doc> </docgroup> - <docgroup homogen-name='sizeof' homogen-type='method'> - <method name='sizeof'/><doc placeholder='true'> - <text> - <tt>sizeof</tt> - return the size of an array, string, multiset or mapping - - <tt>int sizeof(string|multiset|mapping|array|object a); - - </tt> - This function returns the number of indexes available in the argument - given to it. It replaces older functions like strlen, m_sizeof and - size. - - string, multiset, mapping and array</text> - - </doc> - </docgroup> - <docgroup homogen-name='sleep' homogen-type='method'> - <method name='sleep'/><doc placeholder='true'> - <text> - <tt>sleep</tt> - let interpreter doze of for a while - - <tt>void sleep(int s); - - </tt> - This function makes the program stop for s seconds. Only signal - handlers can interrupt the sleep. Other callbacks are not called - during sleep. - </text> - - <group><seealso/><text> - <ref resolved='predef::signal' to='signal'>signal</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='sort' homogen-type='method'> - <method name='sort'/><doc placeholder='true'> - <text> - <tt>sort</tt> - sort an array destructively - - <tt>mixed *sort(array(mixed) index, array(mixed) ... data); - - </tt> - 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. Each of these arrays will be modified in the same way as - 'index'. Ie. if index 3 is moved to position 0 in 'index' index 3 - will be moved to position 0 in all the other arrays as well. - - Sort can sort strings, integers and floats in ascending order. - Arrays will be sorted first on the first element of each array. - - Sort returns it's first argument. - - array</text> - - <group><seealso/><text> - <ref resolved='predef::reverse' to='reverse'>reverse</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='sort_array' homogen-type='method'> - <method name='sort_array'/><doc placeholder='true'> - <text> - <tt>sort_array</tt> - sort an array - - <tt>#include <array.h> - - - mixed *sort_array(mixed *arr,function fun,mixed ... args); - - </tt> - This function sorts an array after a compare-function 'fun' - which takes two arguments and should return 1 if the first argument - is larger then the second. The rest of the arguments 'args' will be - sent as 3rd, 4th etc. argument to fun. If fun is omitted, `< is unsed - instead. - - array</text> - - <group><seealso/><text> - <ref resolved='predef::map_array' to='map_array'>map_array</ref> and <ref resolved='predef::filter_array' to='filter_array'>filter_array</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='spawn' homogen-type='method'> - <method name='spawn'/><doc placeholder='true'> - <text> - <tt>spawn</tt> - spawn a process - - <tt>#include <process.h> - - - int spawn(string cmd); - or - int spawn(string cmd, object stdin); - or - int spawn(string cmd, object stdin, object stdout); - or - int spawn(string cmd, object stdin, object stdout, object stderr); - - </tt> - This function spawns a process but does not wait for it to finish. - Optionally, clones of Stdio.File can be sent to it to - specify where stdin, stdout and stderr of the spawned processes - should go. - </text> - - <group><seealso/><text> - <ref resolved='predef::popen' to='popen'>popen</ref>, <ref resolved='predef::fork' to='predef::fork'>files/fork</ref>, <ref resolved='predef::exec' to='predef::exec'>files/exec</ref>, <ref to='predef::file->pipe'>files/file->pipe</ref> and <ref to='predef::file->dup2'>files/file->dup2</ref> - </text></group> - - </doc> - </docgroup> + <docgroup homogen-name='sprintf' homogen-type='method'> <method name='sprintf'/><doc placeholder='true'> <text>
7411: string</text></group> <group><seealso/><text> - <ref resolved='predef::sscanf' to='sscanf'>sscanf</ref> + <ref to='sscanf'>sscanf</ref> </text></group> </doc>
7437: </doc> </docgroup> - <docgroup homogen-name='sscanf' homogen-type='method'> - <method name='sscanf'/><doc placeholder='true'> - <text> - <tt>sscanf</tt> - scan a string using a format string - - <tt>int sscanf(string str, string fmt, mixed var1, mixed var2 ...); - - </tt> - Parse a string str using the format fmt. fmt can contain strings - separated by "%d,%s,%c and %f. Every % corresponds to one of var1, - var2... - - <matrix> - <r><c> %d </c><c> gives an integer </c></r> - <r><c> %o </c><c> gives an octal integer </c></r> - <r><c> %x </c><c> gives a hexadecimal integer </c></r> - <r><c> %D </c><c> gives an integer that is either octal (leading zero), hexadecimal (leading 0x) or decimal. </c></r> - <r><c> %f </c><c> gives a float </c></r> - <r><c> %c </c><c> matches one char and returns it as an integer </c></r> - <r><c> %2c </c><c> matches two chars and returns them as an integer (short) </c></r> - <r><c> %s </c><c> gives a string </c></r> - <r><c> %5s </c><c> gives a string of 5 characters (5 can be any number) </c></r> - <r><c> %[set] </c><c> matches a string containing a given set of characters. (thos given inside the brackets) %[^set] means any character ecept those inside brackets. %[0-9H] means any number or 'H'. </c></r> - </matrix> - - - If a * is put between the percent and the operator, the operator - will not only match it's argument, not assign any variables. - - Number of matched arguments is returned. - - string</text> - - <group><seealso/><text> - <ref resolved='predef::explode' to='explode'>explode</ref> and <ref resolved='predef::sprintf' to='sprintf'>sprintf</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='stderr' homogen-type='method'> - <method name='stderr'/><doc placeholder='true'> - <text> - <tt>stderr</tt> - Standard error stream - - <tt>#include <stdio.h> - - - stderr->gets() - - </tt> - Stderr is a clone of Stdio.File connected to the standard - error stream. - </text> - - <group><seealso/><text> - <ref resolved='predef::Stdio.File' to='Stdio.File'>Stdio.File</ref> and <ref resolved='predef::werror' to='werror'>werror</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='stdin' homogen-type='method'> - <method name='stdin'/><doc placeholder='true'> - <text> - <tt>stdin</tt> - Standard input - - <tt>#include <stdio.h> - - - stdin->gets() - - </tt> - Stdin is a clone of Stdio.FILE connected to the standard input. - </text> - - <group><seealso/><text> - <ref resolved='predef::Stdio.FILE' to='Stdio.FILE'>Stdio.FILE</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='stdout' homogen-type='method'> - <method name='stdout'/><doc placeholder='true'> - <text> - <tt>stdout</tt> - Standard output - - <tt>#include <stdio.h> - - - stdout->gets() - - </tt> - Stdout is a clone of Stdio.File connected to the standard output. - </text> - - <group><seealso/><text> - <ref resolved='predef::Stdio.File' to='Stdio.File'>Stdio.File</ref> and <ref resolved='predef::write' to='write'>write</ref> - </text></group> - - </doc> - </docgroup> + <docgroup homogen-name='strerror' homogen-type='method'> <method name='strerror'/><doc placeholder='true'> <text>
7557: </doc> </docgroup> - <docgroup homogen-name='string' homogen-type='method'> - <method name='string'/><doc placeholder='true'> - <text> - <tt>string</tt> - a string of characters - - <tt>"foo" - - </tt> - This type can contan text. ie. a word, a sentence, or a book. Note - that this is not simply the letters A to Z, special characters, - null characters, newlines can all be stored in a string. Any 8-bit - character in fact. Strings are a basic - type in Pike, as opposed to C where strings are represented by an - array of char. This means that you cannot set individual characters - in a string with the index operator for instance. In fact, there are - no functions that alters strings destructively. Also, all strings - are 'shared', that means that if the same string is used in several - places, only one will be stored in memory. - - When writing a string in a program, you enclose it in doublequotes. - To write special characters you need to use one of the following - syntaxes: - - <matrix> - <r><c> \n </c><c> newline </c></r> - <r><c> \r </c><c> carriage return </c></r> - <r><c> \t </c><c> tab </c></r> - <r><c> \b </c><c> backspace </c></r> - <r><c> \" </c><c> " </c></r> - <r><c> \\ </c><c> \ </c></r> - </matrix> - - - A list of operators that applies to strings follow: - In this list a and b is used to represent a string expression: - - <matrix> - <r><c> a + b </c><c> summation ( "a"+"b" returns "ab") </c></r> - <r><c> a - b </c><c> subtraction ( same as replace(a,b,"") ) </c></r> - <r><c> a / b </c><c> division ( same thing as explode(a,b) ) </c></r> - <r><c> ! a </c><c> boolean not, returns 0 </c></r> - </matrix> - - - The following operators compare two string alphabetically: - - <matrix> - <r><c> a == b </c><c> return 1 if a is equal to b, 0 otherwise </c></r> - <r><c> a != b </c><c> return 0 if a is equal to b, 1 otherwise </c></r> - <r><c> a <c> returns 1 if a is lesser than b, 0 otherwise </c></r> - <r><c> a <= b </c><c> returns 1 if a is lesser or equal to b, 0 otherwise </c></r> - <r><c> a > b </c><c> returns 1 if a is greater than b, 0 otherwise </c></r> - <r><c> a >= b </c><c> returns 1 if a is greater or equal to b, 0 otherwise </c></r> - </matrix> - - - types</text> - - <group><seealso/><text> - <ref resolved='predef::indices' to='predef::indices'>builtin/indices</ref>, <ref resolved='predef::values' to='predef::values'>builtin/values</ref>, <ref resolved='predef::sscanf' to='predef::sscanf'>builtin/sscanf</ref>, <ref resolved='predef::sprintf' to='predef::sprintf'>builtin/sprintf</ref> and <ref resolved='predef::sizeof' to='predef::sizeof'>builtin/sizeof</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='stringp' homogen-type='method'> - <method name='stringp'/><doc placeholder='true'> - <text> - <tt>stringp</tt> - is the argument an string? - - <tt>int stringp(mixed arg); - - </tt> - Returns 1 if arg is a string, zero otherwise. - - string</text> - - <group><seealso/><text> - <ref resolved='predef::intp' to='intp'>intp</ref>, <ref resolved='predef::multisetp' to='multisetp'>multisetp</ref>, <ref resolved='predef::arrayp' to='arrayp'>arrayp</ref>, <ref resolved='predef::programp' to='programp'>programp</ref>, <ref resolved='predef::objectp' to='objectp'>objectp</ref>, <ref resolved='predef::mappingp' to='mappingp'>mappingp</ref>, <ref resolved='predef::floatp' to='floatp'>floatp</ref> and <ref resolved='predef::functionp' to='functionp'>functionp</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='strlen' homogen-type='method'> - <method name='strlen'/><doc placeholder='true'> - <text> - <tt>strlen</tt> - Return the length of a string - - <tt>#include <simulate.h> - - - int strlen(string s); - - </tt> - This function is equal to sizeof. - - string</text> - - <group><seealso/><text> - <ref resolved='predef::sizeof' to='predef::sizeof'>builtin/sizeof</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='strmult' homogen-type='method'> - <method name='strmult'/><doc placeholder='true'> - <text> - <tt>strmult</tt> - multiply strings - - <tt>#include <string.h> - - - string strmult(string s, int num); - - </tt> - This function multplies 's' by 'num'. The return value is the same - as appending 's' to an empty string 'num' times. - - </text> - - </doc> - </docgroup> - <docgroup homogen-name='strstr' homogen-type='method'> - <method name='strstr'/><doc placeholder='true'> - <text> - <tt>strstr</tt> - find a string inside a string - - <tt>#include <simulate.h> - - - int strstr(string str1,string str2); - - </tt> - Return the position of str2 in str1, if str2 can't be found in str1 - -1 is returned. - - string</text> - - <group><seealso/><text> - <ref resolved='predef::sscanf' to='predef::sscanf'>builtin/sscanf</ref> and <ref resolved='predef::explode' to='predef::explode'>builtin/explode</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='sum' homogen-type='method'> - <method name='sum'/><doc placeholder='true'> - <text> - <tt>sum</tt> - add values together - - <tt>#include <simulate.h> - - - int sum(int ... i); - or - float sum(float ... f); - or - string sum(string|float|int ... p); - or - array sum(array ... a); - or - mapping sum(mapping ... m); - or - list sum(multiset ... l); - - </tt> - This function does exactly the same thing as adding all the arguments - together with +. It's just here so you can get a function-pointer to - the summation operator. - - int, float, string, array, mapping and multiset</text> - - </doc> - </docgroup> - <docgroup homogen-name='sum_arrays' homogen-type='method'> - <method name='sum_arrays'/><doc placeholder='true'> - <text> - <tt>sum_arrays</tt> - map any number of arrays over a function. - - <tt>#include <array.h> - - - mixed *sum_arrays(function fun,mixed *arr1,...); - - </tt> - Works like this: - - mixed *sum_arrays(function fun,mixed *arr1,...) - { - <dl><group><text>int e; - mixed *res=allocate(sizeof(arr1)); - for(e=0;e<sizeof(arr1);e++) - { - <dl><group><text>res[e]=fun(arr1[e],arr2[e],...); - </text></group></dl>} - return res; - </text></group></dl>} - - - Simple ehh? - - array</text> - - <group><seealso/><text> - <ref resolved='predef::map_array' to='map_array'>map_array</ref>, <ref resolved='predef::filter_array' to='filter_array'>filter_array</ref> and <ref resolved='predef::search_array' to='search_array'>search_array</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='switch' homogen-type='method'> - <method name='switch'/><doc placeholder='true'> - <text> - <tt>switch</tt> - Complicated conditional statement - - <tt>switch( expression ) - { - <dl><group><text>case constant1: - <dl><group><text>statement1 - </text></group></dl></text></group></dl> - <dl><group><text>case constant2: - <dl><group><text>statement2 - break; - </text></group></dl></text></group></dl> - <dl><group><text>case constant3..constant4: - <dl><group><text>statement4 - break; - </text></group></dl></text></group></dl> - <dl><group><text>default: - <dl><group><text>statement3 - </text></group></dl></text></group></dl>} - - </tt> - Switch evaluates the expression give and then executes one or more - statement accordingly to the result. If the result is equal to - constant1 then statement1 will be executed, please observe that - the second case-statement dos _not_ abort the execution in any way - instead statement2 will also be executed. After that break will - cause execution to continue after the after the last } in the - switch statement. If the result is equal to constant2 only - statement2 will be executed. If expression <= consant3 and - expression >= constant4, statement4 will be executed. In all other - cases statement3 is executed because it is 'default'. Please note - that the expression and constants can be any type that can be - written as a constant. Arrays, mappings and multisets have little or - no use though. - - control</text> - - <group><seealso/><text> - <ref to='if-else'>if-else</ref> and <ref resolved='predef::break' to='break'>break</ref> - </text></group> - - </doc> - </docgroup> + <docgroup homogen-name='symlink' homogen-type='method'> <method name='symlink'/><doc placeholder='true'> <text>
7822: file</text> <group><seealso/><text> - <ref resolved='predef::system' to='system/hardlink'>system/hardlink</ref>, <ref resolved='predef::system' to='system/readlink'>system/readlink</ref>, <ref resolved='predef::mv' to='predef::mv'>files/mv</ref> and <ref resolved='predef::rm' to='predef::rm'>files/rm</ref> + <ref to='system/hardlink'>system/hardlink</ref>, <ref to='system/readlink'>system/readlink</ref>, <ref resolved='predef::mv' to='predef::mv'>files/mv</ref> and <ref resolved='predef::rm' to='predef::rm'>files/rm</ref> </text></group> </doc> </docgroup> - <docgroup homogen-name='system' homogen-type='method'> - <method name='system'/><doc placeholder='true'> - <text> - <tt>system</tt> - run an external program - - <tt>#include <process.h> - - - void system(string cmd); - - </tt> - This function runs the external program cmd and waits until it - is finished. Standard /bin/sh completions/redirectoins/etc. can - be used. - </text> - - <group><seealso/><text> - <ref resolved='predef::popen' to='popen'>popen</ref>, <ref resolved='predef::exec' to='exec'>exec</ref> and <ref resolved='predef::spawn' to='spawn'>spawn</ref> - </text></group> - - </doc> - </docgroup> + <docgroup homogen-name='tan' homogen-type='method'> <method name='tan'/><doc placeholder='true'> <text>
7867: </doc> </docgroup> - <docgroup homogen-name='this_function' homogen-type='method'> - <method name='this_function'/><doc placeholder='true'> - <text> - <tt>this_function</tt> - return a functionpointer to the current function - - <tt>#include <simulate.h> - - - function this_function(); - - </tt> - Returns a functionpointer to the current function, useful for - making recursive lambda-functions. - - function</text> - - <group><seealso/><text> - <ref resolved='predef::get_function' to='predef::get_function'>builtin/get_function</ref>, <ref resolved='predef::function_name' to='predef::function_name'>builtin/function_name</ref>, <ref resolved='predef::function_object' to='predef::function_object'>builtin/function_object</ref> and <ref resolved='predef::backtrace' to='predef::backtrace'>builtin/backtrace</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='this_object' homogen-type='method'> - <method name='this_object'/><doc placeholder='true'> - <text> - <tt>this_object</tt> - return the object we are evaluating in currently - - <tt>object this_object(); - - </tt> - This function returns the object we are curently evaluating in. - - object</text> - - </doc> - </docgroup> - <docgroup homogen-name='this_thread' homogen-type='method'> - <method name='this_thread'/><doc placeholder='true'> - <text> - <tt>this_thread</tt> - return thread id - - <tt>object thread_id(); - - </tt> - This function returns the object that identifies this thread. - </text> - - <group><seealso/><text> - <ref resolved='predef::thread_create' to='thread_create'>thread_create</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='thread_create' homogen-type='method'> - <method name='thread_create'/><doc placeholder='true'> - <text> - <tt>thread_create</tt> - create a thread - - <tt>object thread_create(function f, mixed ... args); - - </tt> - This function creates a new thread which will run simultaneously - to the rest of the program. The new thread will call the function - f with the arguments args. When f returns the thread will cease - to exist. All Pike functions are 'thread safe' meanting that running - a function at the same time from different threads will not corrupt - any internal data in the Pike process. The returned value will be - the same as the return value of this_thread() for the new thread. - </text> - - <group><note/><text> - This function is only available on systems with POSIX threads support. - </text></group> - - <group><seealso/><text> - <ref resolved='predef::Thread.Mutex' to='Thread.Mutex'>Thread.Mutex</ref>, <ref resolved='predef::Thread.Condition' to='Thread.Condition'>Thread.Condition</ref> and <ref resolved='predef::this_thread' to='this_thread'>this_thread</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='throw' homogen-type='method'> - <method name='throw'/><doc placeholder='true'> - <text> - <tt>throw</tt> - throw a value to catch or global error handling - - <tt>void throw(mixed value); - - </tt> - This function throws a value to a waiting catch. If no catch is - waiting global error handling will send the value to handle_error - in the master object. If you throw an array with where the first - index contains an error message and the second index is a backtrace, - (the output from backtrace() that is) then it will be treated exactly - like a real error by overlying functions. - </text> - - <group><seealso/><text> - <ref resolved='predef::catch' to='catch'>catch</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='time' homogen-type='method'> - <method name='time'/><doc placeholder='true'> - <text> - <tt>time</tt> - return the current time - - <tt>int time(); - or - int time(1); - - </tt> - This function returns the number of secons since 1 Jan 1970. - The function ctime() converts this integer to a readable string. - - 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) - </text> - - <group><seealso/><text> - <ref resolved='predef::time' to='time'>time</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='trace' homogen-type='method'> - <method name='trace'/><doc placeholder='true'> - <text> - <tt>trace</tt> - change debug trace level - - <tt>int trace(int t); - - </tt> - This function affects the debug trace level. (also set by the -t - command line option) The old level is returned. Trace level 1 or - higher means that calls to pike functions are printed to stderr, - level 2 or higer means calls to builtin functions are printed, 3 - means every opcode interpreted is printed, 4 means arguments to - these opcodes are printed as well. See the command lines options - for more information - - </text> - - </doc> - </docgroup> - <docgroup homogen-name='typeof' homogen-type='method'> - <method name='typeof'/><doc placeholder='true'> - <text> - <tt>typeof</tt> - check return type of expression - - <tt>typeof ( expression ) - - </tt> - This is a not really a function even if it looks like it, it returns - a human readable (almost) representation of the type that the - expression would return without actually evaluating it. - The representation is in the form of a string. - </text> - - <group><example/><text> - <tt>> typeof(`sizeof); - Result: function(object | mapping | array | multiset | string : int) - > typeof(sizeof(({}))); - Result: int - > - - </tt> - pike</text></group> - - </doc> - </docgroup> - <docgroup homogen-name='ualarm' homogen-type='method'> - <method name='ualarm'/><doc placeholder='true'> - <text> - <tt>ualarm</tt> - set an alarm clock for delivery of a signal - - <tt>int ualarm(int useconds); - - </tt> - ualarm arranges for a SIGALRM signal to be delivered to the - process in useconds micro seconds. - - If useconds is zero, no new alarm is scheduled. - - In any event any previously set alarm is cancelled. - </text> - - <group><returns/><text> - ualarm returns the number of microseconds seconds remaining - <dl><group><text>until any previously scheduled alarm was due to be delivered, or - </text></group></dl>zero if there was no previously scheduled alarm. - - </text></group> - - <group><seealso/><text> - <ref resolved='predef::signal' to='signal'>signal</ref> - </text></group> - - </doc> - </docgroup> + <docgroup homogen-name='uname' homogen-type='method'> <method name='uname'/><doc placeholder='true'> <text>
8095: </doc> </docgroup> - <docgroup homogen-name='uniq' homogen-type='method'> - <method name='uniq'/><doc placeholder='true'> - <text> - <tt>uniq</tt> - return one of each element - - <tt>#include <array.h> - - - array uniq(array a); - - </tt> - This function returns an copy of the array a with all duplicate - values removed. The order of the values in the result is undefined. - - array</text> - - </doc> - </docgroup> - <docgroup homogen-name='upper_case' homogen-type='method'> - <method name='upper_case'/><doc placeholder='true'> - <text> - <tt>upper_case</tt> - convert a string to upper case - - <tt>string upper_case(string s); - - </tt> - Return a copy of the string s with all lower case character converted - to upper case character. - - string</text> - - <group><seealso/><text> - <ref resolved='predef::lower_case' to='lower_case'>lower_case</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='values' homogen-type='method'> - <method name='values'/><doc placeholder='true'> - <text> - <tt>values</tt> - return an array of all possible values from indexing - - <tt>mixed *values(string|multiset|mapping|array|object foo); - - </tt> - Values return an array of all values you can get when indexing the - value foo. For strings, an array of int with the ascii values of the - characters in the string is returned. For a multiset, an array filled with - ones is return. For mappings, objects and arrays, the returned array - may contain any kind of value. - - mapping</text> - - <group><seealso/><text> - <ref resolved='predef::indices' to='indices'>indices</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='variables' homogen-type='method'> - <method name='variables'/><doc placeholder='true'> - <text> - <tt>variables</tt> - how to declare a variable - - <tt>modifier type variable_name_list; - - </tt> - This is how you declare a global variable. Local variables are defined - in the same way, but you may not use any modifiers for local variables. - The variable_name_list is a comma separated list of the variables - to declare as the type 'type'. Note that '*' binds to the variable - names, not the type. This means that: - - <matrix> - <r><c> </c><c> int * i,j; </c></r> - <r><c> </c></r> - </matrix> - - - Declares i as an array of int, but j will be declared as int. To - declare both i and j as arrays of int you have to write. - - <matrix> - <r><c> </c><c> int * i, * j; </c></r> - <r><c> </c></r> - </matrix> - - - or - - <matrix> - <r><c> </c><c> array(int) i,j; </c></r> - <r><c> </c></r> - </matrix> - - - Modifiers can be zero or more of: static, no_mask and private. - Private means that the variable can not be accessed from programs - that inherit this program. Static means that it can not be accessed - from other objects with the index operator. No_mask means that it - can not be redefined in inheriting programs. - - pike</text> - - <group><seealso/><text> - <ref resolved='predef::functions' to='functions'>functions</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='version' homogen-type='method'> - <method name='version'/><doc placeholder='true'> - <text> - <tt>version</tt> - return version info - - <tt>string version(); - - </tt> - This function returns a brief information about the Pike version. - </text> - - <group><example/><text> - <tt>> version(); - Result: Pike v1.0E-13 - - - </tt></text></group> - - </doc> - </docgroup> + <docgroup homogen-name='werror' homogen-type='method'> <method name='werror'/><doc placeholder='true'> <text>
8240: </doc> </docgroup> - <docgroup homogen-name='while' homogen-type='method'> - <method name='while'/><doc placeholder='true'> - <text> - <tt>while</tt> - execute a statement while an expression is true - - <tt>while( expression ) statement - - </tt> - While runns the statement until the expression is false. The - expression is evaluated once for every loop. If the expression is - false the first time the statement is never executed. - - control</text> - - <group><seealso/><text> - <ref resolved='predef::for' to='for'>for</ref> and <ref to='do-while'>do-while</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='write' homogen-type='method'> - <method name='write'/><doc placeholder='true'> - <text> - <tt>write</tt> - write text to stdout - - <tt>int write(string text); - - </tt> - Added by the master, it directly calls write in a clone of - Stdio.File - </text> - - <group><seealso/><text> - <ref to='Builtin.werror'>Builtin.werror</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='write_file' homogen-type='method'> - <method name='write_file'/><doc placeholder='true'> - <text> - <tt>write_file</tt> - append a string to a file - - <tt>#include <stdio.h> - - - int write_file(string file, string str) - - </tt> - Append the string str onto the file file. Returns number of bytes written. - - file</text> - - <group><seealso/><text> - <ref resolved='predef::read_bytes' to='read_bytes'>read_bytes</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='zero_type' homogen-type='method'> - <method name='zero_type'/><doc placeholder='true'> - <text> - <tt>zero_type</tt> - return the type of zero - - <tt>int zero_type(mixed a); - - </tt> - 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. - When doing a find_call_out or mapping lookup, zero_type on this value - will return 1 if there was no such thing present in the mappping, or - no such call_out could be found. If the argument to zero type is a - destructed object or a function in a destructed object, 2 will be - returned. Otherwize zero_type will return zero. - - If the argument is not an int, zero will be returned. - - int and mapping</text> - - <group><seealso/><text> - <ref resolved='predef::find_call_out' to='find_call_out'>find_call_out</ref> - </text></group> - - </doc> - </docgroup> - <docgroup homogen-name='||' homogen-type='method'> - <method name='||'/><doc placeholder='true'> - <text> - <tt>||</tt> - logical or - - <tt>a || b - - </tt> - This operator does logical 'or' between expressions. It first - evaluates a and returns that if a is non-zero. Otherwise it - returns b. Note that b is not evaluated at all if a is non-zero. - - operators</text> - - <group><seealso/><text> - <ref resolved='predef::`|' to='`|'>`|</ref> and <ref resolved='predef::||' to='&&'>&&</ref> - </text></group> - - </doc> - </docgroup> + <module name='Calendar'> <doc> <text>
8426: <docgroup homogen-name='parse' homogen-type='method'> <method name='parse'> <returntype> - <object resolved='predef::object'>object </object></returntype> + <object>object </object></returntype> <arguments><argument name='fmt'><type><string/></type></argument> <argument name='arg'><type><string/></type></argument>
8474: <docgroup homogen-type='method'> <method name='next'> <returntype> - <object resolved='predef::object'>object </object></returntype> + <object>object </object></returntype> <arguments> </arguments> </method><method name='prev'> <returntype> - <object resolved='predef::object'>object </object></returntype> + <object>object </object></returntype> <arguments> </arguments> </method><method name='`+'> <returntype> - <object resolved='predef::object'>object </object></returntype> + <object>object </object></returntype> <arguments><argument name='n'><type><int/></type></argument> </arguments> </method><method name='`-'> <returntype> - <object resolved='predef::object'>object </object></returntype> + <object>object </object></returntype> <arguments><argument name='n'><type><int/></type></argument> </arguments> </method><method name='`-'> <returntype> - <object resolved='predef::object'>object </object></returntype> + <object>object </object></returntype> <arguments><argument name='x'><type><object resolved='predef::Calendar.time_unit.next'/></type></argument> </arguments>
9188: <docgroup homogen-name='__decode' homogen-type='method'> <method name='__decode'> <returntype> - <object resolved='predef::array'>array </object></returntype> + <object>array </object></returntype> <arguments> </arguments> </method><doc>
9243: <docgroup homogen-name='_decode' homogen-type='method'> <method name='_decode'> <returntype> - <object resolved='predef::array'>array </object></returntype> + <object>array </object></returntype> <arguments><argument name='gifdata'><type><string/></type></argument> </arguments> </method><method name='_decode'> <returntype> - <object resolved='predef::array'>array </object></returntype> + <object>array </object></returntype> <arguments><argument name='__decoded'><type><array/></type></argument> </arguments>
9337: <docgroup homogen-name='_encode' homogen-type='method'> <method name='_encode'> <returntype> - <object resolved='predef::string'>string </object></returntype> + <object>string </object></returntype> <arguments><argument name='data'><type><array/></type></argument> </arguments>
9360: <docgroup homogen-name='_gce_block' homogen-type='method'> <method name='_gce_block'> <returntype> - <object resolved='predef::string'>string </object></returntype> + <object>string </object></returntype> <arguments><argument name='transparency'><type><int/></type></argument> <argument name='transparency_index'><type><int/></type></argument> <argument name='delay'><type><int/></type></argument>
9417: <docgroup homogen-name='_render_block' homogen-type='method'> <method name='_render_block'> <returntype> - <object resolved='predef::string'>string </object></returntype> + <object>string </object></returntype> <arguments><argument name='x'><type><int/></type></argument> <argument name='y'><type><int/></type></argument> <argument name='xsize'><type><int/></type></argument>
9475: <docgroup homogen-name='decode' homogen-type='method'> <method name='decode'> <returntype> - <object resolved='predef::object'>object </object></returntype> + <object>object </object></returntype> <arguments><argument name='data'><type><string/></type></argument> </arguments> </method><method name='decode'> <returntype> - <object resolved='predef::object'>object </object></returntype> + <object>object </object></returntype> <arguments><argument name='_decoded'><type><array/></type></argument> </arguments> </method><method name='decode'> <returntype> - <object resolved='predef::object'>object </object></returntype> + <object>object </object></returntype> <arguments><argument name='__decoded'><type><array/></type></argument> </arguments>
9515: <docgroup homogen-type='method'> <method name='encode'> <returntype> - <object resolved='predef::string'>string </object></returntype> + <object>string </object></returntype> <arguments><argument name='img'><type><object resolved='predef::Image.GIF.encode'/></type></argument> </arguments> </method><method name='encode'> <returntype> - <object resolved='predef::string'>string </object></returntype> + <object>string </object></returntype> <arguments><argument name='img'><type><object resolved='predef::Image.GIF.encode'/></type></argument> <argument name='colors'><type><int/></type></argument> </arguments> </method><method name='encode'> <returntype> - <object resolved='predef::string'>string </object></returntype> + <object>string </object></returntype> <arguments><argument name='img'><type><object resolved='predef::Image.GIF.encode'/></type></argument> <argument name='colortable'><type><object resolved='predef::Image.GIF.encode'/></type></argument> </arguments> </method><method name='encode_trans'> <returntype> - <object resolved='predef::string'>string </object></returntype> + <object>string </object></returntype> <arguments><argument name='img'><type><object resolved='predef::Image.GIF.encode'/></type></argument> <argument name='alpha'><type><object resolved='predef::Image.GIF.encode'/></type></argument> </arguments> </method><method name='encode_trans'> <returntype> - <object resolved='predef::string'>string </object></returntype> + <object>string </object></returntype> <arguments><argument name='img'><type><object resolved='predef::Image.GIF.encode'/></type></argument> <argument name='tr_r'><type><int/></type></argument> <argument name='tr_g'><type><int/></type></argument>
9551: </arguments> </method><method name='encode_trans'> <returntype> - <object resolved='predef::string'>string </object></returntype> + <object>string </object></returntype> <arguments><argument name='img'><type><object resolved='predef::Image.GIF.encode'/></type></argument> <argument name='colors'><type><int/></type></argument> <argument name='alpha'><type><object resolved='predef::Image.GIF.encode'/></type></argument>
9559: </arguments> </method><method name='encode_trans'> <returntype> - <object resolved='predef::string'>string </object></returntype> + <object>string </object></returntype> <arguments><argument name='img'><type><object resolved='predef::Image.GIF.encode'/></type></argument> <argument name='colors'><type><int/></type></argument> <argument name='tr_r'><type><int/></type></argument>
9569: </arguments> </method><method name='encode_trans'> <returntype> - <object resolved='predef::string'>string </object></returntype> + <object>string </object></returntype> <arguments><argument name='img'><type><object resolved='predef::Image.GIF.encode'/></type></argument> <argument name='colors'><type><int/></type></argument> <argument name='alpha'><type><object resolved='predef::Image.GIF.encode'/></type></argument>
9580: </arguments> </method><method name='encode_trans'> <returntype> - <object resolved='predef::string'>string </object></returntype> + <object>string </object></returntype> <arguments><argument name='img'><type><object resolved='predef::Image.GIF.encode'/></type></argument> <argument name='colortable'><type><object resolved='predef::Image.GIF.encode'/></type></argument> <argument name='alpha'><type><object resolved='predef::Image.GIF.encode'/></type></argument>
9588: </arguments> </method><method name='encode_trans'> <returntype> - <object resolved='predef::string'>string </object></returntype> + <object>string </object></returntype> <arguments><argument name='img'><type><object resolved='predef::Image.GIF.encode'/></type></argument> <argument name='colortable'><type><object resolved='predef::Image.GIF.encode'/></type></argument> <argument name='tr_r'><type><int/></type></argument>
9598: </arguments> </method><method name='encode_trans'> <returntype> - <object resolved='predef::string'>string </object></returntype> + <object>string </object></returntype> <arguments><argument name='img'><type><object resolved='predef::Image.GIF.encode'/></type></argument> <argument name='colortable'><type><object resolved='predef::Image.GIF.encode'/></type></argument> <argument name='alpha'><type><object resolved='predef::Image.GIF.encode'/></type></argument>
9609: </arguments> </method><method name='encode_trans'> <returntype> - <object resolved='predef::string'>string </object></returntype> + <object>string </object></returntype> <arguments><argument name='img'><type><object resolved='predef::Image.GIF.encode'/></type></argument> <argument name='colortable'><type><object resolved='predef::Image.GIF.encode'/></type></argument> <argument name='transp_index'><type><int/></type></argument>
9680: <docgroup homogen-name='end_block' homogen-type='method'> <method name='end_block'> <returntype> - <object resolved='predef::string'>string </object></returntype> + <object>string </object></returntype> <arguments> </arguments> </method><doc>
9707: <docgroup homogen-name='header_block' homogen-type='method'> <method name='header_block'> <returntype> - <object resolved='predef::string'>string </object></returntype> + <object>string </object></returntype> <arguments><argument name='xsize'><type><int/></type></argument> <argument name='ysize'><type><int/></type></argument> <argument name='numcolors'><type><int/></type></argument>
9715: </arguments> </method><method name='header_block'> <returntype> - <object resolved='predef::string'>string </object></returntype> + <object>string </object></returntype> <arguments><argument name='xsize'><type><int/></type></argument> <argument name='ysize'><type><int/></type></argument> <argument name='colortable'><type><object resolved='predef::Image.GIF.header_block'/></type></argument>
9723: </arguments> </method><method name='header_block'> <returntype> - <object resolved='predef::string'>string </object></returntype> + <object>string </object></returntype> <arguments><argument name='xsize'><type><int/></type></argument> <argument name='ysize'><type><int/></type></argument> <argument name='colortable'><type><object resolved='predef::Image.GIF.header_block'/></type></argument>
9735: </arguments> </method><method name='header_block'> <returntype> - <object resolved='predef::string'>string </object></returntype> + <object>string </object></returntype> <arguments><argument name='xsize'><type><int/></type></argument> <argument name='ysize'><type><int/></type></argument> <argument name='colortable'><type><object resolved='predef::Image.GIF.header_block'/></type></argument>
9806: <docgroup homogen-name='netscape_loop_block' homogen-type='method'> <method name='netscape_loop_block'> <returntype> - <object resolved='predef::string'>string </object></returntype> + <object>string </object></returntype> <arguments> </arguments> </method><method name='netscape_loop_block'> <returntype> - <object resolved='predef::string'>string </object></returntype> + <object>string </object></returntype> <arguments><argument name='number_of_loops'><type><int/></type></argument> </arguments>
9830: <docgroup homogen-name='render_block' homogen-type='method'> <method name='render_block'> <returntype> - <object resolved='predef::string'>string </object></returntype> + <object>string </object></returntype> <arguments><argument name='img'><type><object resolved='predef::Image.GIF.render_block'/></type></argument> <argument name='colortable'><type><object resolved='predef::Image.GIF.render_block'/></type></argument> <argument name='x'><type><int/></type></argument>
9840: </arguments> </method><method name='render_block'> <returntype> - <object resolved='predef::string'>string </object></returntype> + <object>string </object></returntype> <arguments><argument name='img'><type><object resolved='predef::Image.GIF.render_block'/></type></argument> <argument name='colortable'><type><object resolved='predef::Image.GIF.render_block'/></type></argument> <argument name='x'><type><int/></type></argument>
9851: </arguments> </method><method name='render_block'> <returntype> - <object resolved='predef::string'>string </object></returntype> + <object>string </object></returntype> <arguments><argument name='img'><type><object resolved='predef::Image.GIF.render_block'/></type></argument> <argument name='colortable'><type><object resolved='predef::Image.GIF.render_block'/></type></argument> <argument name='x'><type><int/></type></argument>
9865: </arguments> </method><method name='render_block'> <returntype> - <object resolved='predef::string'>string </object></returntype> + <object>string </object></returntype> <arguments><argument name='img'><type><object resolved='predef::Image.GIF.render_block'/></type></argument> <argument name='colortable'><type><object resolved='predef::Image.GIF.render_block'/></type></argument> <argument name='x'><type><int/></type></argument>
9880: </arguments> </method><method name='render_block'> <returntype> - <object resolved='predef::string'>string </object></returntype> + <object>string </object></returntype> <arguments><argument name='img'><type><object resolved='predef::Image.GIF.render_block'/></type></argument> <argument name='colortable'><type><object resolved='predef::Image.GIF.render_block'/></type></argument> <argument name='x'><type><int/></type></argument>
10020: <docgroup homogen-name='decode' homogen-type='method'> <method name='decode'> <returntype> - <object resolved='predef::object'>object </object></returntype> + <object>object </object></returntype> <arguments><argument name='data'><type><string/></type></argument> </arguments> </method><method name='decode'> <returntype> - <object resolved='predef::object'>object </object></returntype> + <object>object </object></returntype> <arguments><argument name='data'><type><string/></type></argument> <argument name='mappingoptions'><type> <object resolved='predef::Image.JPEG.decode'/></type></argument>
10070: <docgroup homogen-name='decode_header' homogen-type='method'> <method name='decode_header'> <returntype> - <object resolved='predef::object'>object </object></returntype> + <object>object </object></returntype> <arguments><argument name='data'><type><string/></type></argument> </arguments> </method><method name='decode_header'> <returntype> - <object resolved='predef::object'>object </object></returntype> + <object>object </object></returntype> <arguments><argument name='data'><type><string/></type></argument> <argument name='mappingoptions'><type> <object resolved='predef::Image.JPEG.decode_header'/></type></argument>
10119: <docgroup homogen-name='encode' homogen-type='method'> <method name='encode'> <returntype> - <object resolved='predef::string'>string </object></returntype> + <object>string </object></returntype> <arguments><argument name='image'><type><object resolved='predef::Image.JPEG.encode'/></type></argument> </arguments> </method><method name='encode'> <returntype> - <object resolved='predef::string'>string </object></returntype> + <object>string </object></returntype> <arguments><argument name='image'><type><object resolved='predef::Image.JPEG.encode'/></type></argument> <argument name='mappingoptions'><type> <object resolved='predef::Image.JPEG.encode'/></type></argument>
10189: <docgroup homogen-name='__decode' homogen-type='method'> <method name='__decode'> <returntype> - <object resolved='predef::array'>array </object></returntype> + <object>array </object></returntype> <arguments><argument name='data'><type><string/></type></argument> </arguments> </method><method name='__decode'> <returntype> - <object resolved='predef::array'>array </object></returntype> + <object>array </object></returntype> <arguments><argument name='data'><type><string/></type></argument> <argument name='intdontcheckcrc'><type> <object resolved='predef::Image.PNG.__decode'/></type></argument>
10229: <docgroup homogen-name='_chunk' homogen-type='method'> <method name='_chunk'> <returntype> - <object resolved='predef::string'>string </object></returntype> + <object>string </object></returntype> <arguments><argument name='type'><type><string/></type></argument> <argument name='data'><type><string/></type></argument>
10248: <docgroup homogen-name='_decode' homogen-type='method'> <method name='_decode'> <returntype> - <object resolved='predef::array'>array </object></returntype> + <object>array </object></returntype> <arguments><argument name='data'><type> <or><string/><array/></or></type></argument> </arguments> </method><method name='_decode'> <returntype> - <object resolved='predef::array'>array </object></returntype> + <object>array </object></returntype> <arguments><argument name='data'><type> <or><string/><array/></or></type></argument> <argument name='options'><type><mapping/></type></argument>
10360: <docgroup homogen-name='decode' homogen-type='method'> <method name='decode'> <returntype> - <object resolved='predef::object'>object </object></returntype> + <object>object </object></returntype> <arguments><argument name='data'><type><string/></type></argument> </arguments> </method><method name='decode'> <returntype> - <object resolved='predef::object'>object </object></returntype> + <object>object </object></returntype> <arguments><argument name='data'><type><string/></type></argument> <argument name='mappingoptions'><type> <object resolved='predef::Image.PNG.decode'/></type></argument>
10392: <docgroup homogen-name='encode' homogen-type='method'> <method name='encode'> <returntype> - <object resolved='predef::string'>string </object></returntype> + <object>string </object></returntype> <arguments><argument name='image'><type><object resolved='predef::Image.PNG.encode'/></type></argument> </arguments> </method><method name='encode'> <returntype> - <object resolved='predef::string'>string </object></returntype> + <object>string </object></returntype> <arguments><argument name='image'><type><object resolved='predef::Image.PNG.encode'/></type></argument> <argument name='mappingoptions'><type> <object resolved='predef::Image.PNG.encode'/></type></argument>
10479: <docgroup homogen-name='decode' homogen-type='method'> <method name='decode'> <returntype> - <object resolved='predef::object'>object </object></returntype> + <object>object </object></returntype> <arguments><argument name='data'><type><string/></type></argument> </arguments>
10504: <docgroup homogen-type='method'> <method name='encode'> <returntype> - <object resolved='predef::string'>string </object></returntype> + <object>string </object></returntype> <arguments><argument name='image'><type><object resolved='predef::Image.PNM.encode'/></type></argument> </arguments> </method><method name='encode_binary'> <returntype> - <object resolved='predef::string'>string </object></returntype> + <object>string </object></returntype> <arguments><argument name='image'><type><object resolved='predef::Image.PNM.encode'/></type></argument> </arguments> </method><method name='encode_ascii'> <returntype> - <object resolved='predef::string'>string </object></returntype> + <object>string </object></returntype> <arguments><argument name='image'><type><object resolved='predef::Image.PNM.encode'/></type></argument> </arguments> </method><method name='encode_P1'> <returntype> - <object resolved='predef::string'>string </object></returntype> + <object>string </object></returntype> <arguments><argument name='image'><type><object resolved='predef::Image.PNM.encode'/></type></argument> </arguments> </method><method name='encode_P2'> <returntype> - <object resolved='predef::string'>string </object></returntype> + <object>string </object></returntype> <arguments><argument name='image'><type><object resolved='predef::Image.PNM.encode'/></type></argument> </arguments> </method><method name='encode_P3'> <returntype> - <object resolved='predef::string'>string </object></returntype> + <object>string </object></returntype> <arguments><argument name='image'><type><object resolved='predef::Image.PNM.encode'/></type></argument> </arguments> </method><method name='encode_P4'> <returntype> - <object resolved='predef::string'>string </object></returntype> + <object>string </object></returntype> <arguments><argument name='image'><type><object resolved='predef::Image.PNM.encode'/></type></argument> </arguments> </method><method name='encode_P5'> <returntype> - <object resolved='predef::string'>string </object></returntype> + <object>string </object></returntype> <arguments><argument name='image'><type><object resolved='predef::Image.PNM.encode'/></type></argument> </arguments> </method><method name='encode_P6'> <returntype> - <object resolved='predef::string'>string </object></returntype> + <object>string </object></returntype> <arguments><argument name='image'><type><object resolved='predef::Image.PNM.encode'/></type></argument> </arguments>
10605: <docgroup homogen-name='`()' homogen-type='method'> <method name='`()'> <returntype> - <object resolved='predef::object'>object </object></returntype> + <object>object </object></returntype> <arguments><argument name='filename'><type><string/></type></argument> </arguments> </method><method name='`()'> <returntype> - <object resolved='predef::object'>object </object></returntype> + <object>object </object></returntype> <arguments><argument name='filename'><type><string/></type></argument> <argument name='options'><type><mapping/></type></argument>
10652: <docgroup homogen-type='method'> <method name='names'> <returntype> - <object resolved='predef::mapping'>mapping </object></returntype> + <object>mapping </object></returntype> <arguments> </arguments> </method><method name='_names'>
10704: <docgroup homogen-name='`()' homogen-type='method'> <method name='`()'> <returntype> - <object resolved='predef::object'>object </object></returntype> + <object>object </object></returntype> <arguments> </arguments> </method><doc>
10722: <docgroup homogen-name='flush' homogen-type='method'> <method name='flush'> <returntype> - <object resolved='predef::object'>object </object></returntype> + <object>object </object></returntype> <arguments> </arguments> </method><doc>
10741: <docgroup homogen-name='properties' homogen-type='method'> <method name='properties'> <returntype> - <object resolved='predef::mapping'>mapping </object></returntype> + <object>mapping </object></returntype> <arguments> </arguments> </method><doc>
10802: <docgroup homogen-name='decode_pseudocolor' homogen-type='method'> <method name='decode_pseudocolor'> <returntype> - <object resolved='predef::object'>object </object></returntype> + <object>object </object></returntype> <arguments><argument name='data'><type><string/></type></argument> <argument name='width'><type><int/></type></argument> <argument name='height'><type><int/></type></argument>
10826: <docgroup homogen-type='method'> <method name='decode_truecolor'> <returntype> - <object resolved='predef::object'>object </object></returntype> + <object>object </object></returntype> <arguments><argument name='data'><type><string/></type></argument> <argument name='width'><type><int/></type></argument> <argument name='height'><type><int/></type></argument>
10843: </arguments> </method><method name='decode_truecolor_masks'> <returntype> - <object resolved='predef::object'>object </object></returntype> + <object>object </object></returntype> <arguments><argument name='data'><type><string/></type></argument> <argument name='width'><type><int/></type></argument> <argument name='height'><type><int/></type></argument>
10869: <docgroup homogen-name='encode_pseudocolor' homogen-type='method'> <method name='encode_pseudocolor'> <returntype> - <object resolved='predef::string'>string </object></returntype> + <object>string </object></returntype> <arguments><argument name='image'><type><object resolved='predef::Image.X.encode_pseudocolor'/></type></argument> <argument name='bpp'><type><int/></type></argument> <argument name='alignbits'><type><int/></type></argument>
10879: </arguments> </method><method name='encode_pseudocolor'> <returntype> - <object resolved='predef::string'>string </object></returntype> + <object>string </object></returntype> <arguments><argument name='image'><type><object resolved='predef::Image.X.encode_pseudocolor'/></type></argument> <argument name='bpp'><type><int/></type></argument> <argument name='alignbits'><type><int/></type></argument>
10919: <docgroup homogen-type='method'> <method name='encode_truecolor'> <returntype> - <object resolved='predef::string'>string </object></returntype> + <object>string </object></returntype> <arguments><argument name='image'><type><object resolved='predef::Image.X.encode_truecolor'/></type></argument> <argument name='bpp'><type><int/></type></argument> <argument name='alignbits'><type><int/></type></argument>
10934: </arguments> </method><method name='encode_truecolor_masks'> <returntype> - <object resolved='predef::string'>string </object></returntype> + <object>string </object></returntype> <arguments><argument name='image'><type><object resolved='predef::Image.X.encode_truecolor'/></type></argument> <argument name='bpp'><type><int/></type></argument> <argument name='alignbits'><type><int/></type></argument>
10946: </arguments> </method><method name='encode_truecolor'> <returntype> - <object resolved='predef::string'>string </object></returntype> + <object>string </object></returntype> <arguments><argument name='image'><type><object resolved='predef::Image.X.encode_truecolor'/></type></argument> <argument name='bpp'><type><int/></type></argument> <argument name='alignbits'><type><int/></type></argument>
10962: </arguments> </method><method name='encode_truecolor_masks'> <returntype> - <object resolved='predef::string'>string </object></returntype> + <object>string </object></returntype> <arguments><argument name='image'><type><object resolved='predef::Image.X.encode_truecolor'/></type></argument> <argument name='bpp'><type><int/></type></argument> <argument name='alignbits'><type><int/></type></argument>
11048: <docgroup homogen-name='decode' homogen-type='method'> <method name='decode'> <returntype> - <object resolved='predef::object'>object </object></returntype> + <object>object </object></returntype> <arguments><argument name='data'><type><string/></type></argument> </arguments> </method><method name='decode'> <returntype> - <object resolved='predef::object'>object </object></returntype> + <object>object </object></returntype> <arguments><argument name='data'><type><string/></type></argument> <argument name='mappingoptions'><type> <object resolved='predef::Image.XFace.decode'/></type></argument>
11074: <docgroup homogen-name='decode_header' homogen-type='method'> <method name='decode_header'> <returntype> - <object resolved='predef::object'>object </object></returntype> + <object>object </object></returntype> <arguments><argument name='data'><type><string/></type></argument> </arguments> </method><method name='decode_header'> <returntype> - <object resolved='predef::object'>object </object></returntype> + <object>object </object></returntype> <arguments><argument name='data'><type><string/></type></argument> <argument name='mappingoptions'><type> <object resolved='predef::Image.XFace.decode_header'/></type></argument>
11113: <docgroup homogen-name='encode' homogen-type='method'> <method name='encode'> <returntype> - <object resolved='predef::string'>string </object></returntype> + <object>string </object></returntype> <arguments><argument name='img'><type><object resolved='predef::Image.XFace.encode'/></type></argument> </arguments> </method><method name='encode'> <returntype> - <object resolved='predef::string'>string </object></returntype> + <object>string </object></returntype> <arguments><argument name='img'><type><object resolved='predef::Image.XFace.encode'/></type></argument> <argument name='mappingoptions'><type> <object resolved='predef::Image.XFace.encode'/></type></argument>
11163: <docgroup homogen-name='_decode' homogen-type='method'> <method name='_decode'> <returntype> - <object resolved='predef::mapping'>mapping </object></returntype> + <object>mapping </object></returntype> <arguments><argument name='data'><type><string/></type></argument> </arguments>
11215: <docgroup homogen-type='method'> <method name='map'> <returntype> - <object resolved='predef::object'>object </object></returntype> + <object>object </object></returntype> <arguments><argument name='image'><type><object resolved='predef::Image.colortable.map'/></type></argument> </arguments> </method><method name='`*'> <returntype> - <object resolved='predef::object'>object </object></returntype> + <object>object </object></returntype> <arguments><argument name='image'><type><object resolved='predef::Image.colortable.map'/></type></argument> </arguments> </method><method name='``*'> <returntype> - <object resolved='predef::object'>object </object></returntype> + <object>object </object></returntype> <arguments><argument name='image'><type><object resolved='predef::Image.colortable.map'/></type></argument> </arguments>
11297: <docgroup homogen-name='`+' homogen-type='method'> <method name='`+'> <returntype> - <object resolved='predef::object'>object </object></returntype> + <object>object </object></returntype> <arguments><argument name='with'><type><object resolved='predef::Image.colortable.`+'/></type></argument> <argument><value>...</value></argument> </arguments>
11317: <docgroup homogen-name='`-' homogen-type='method'> <method name='`-'> <returntype> - <object resolved='predef::object'>object </object></returntype> + <object>object </object></returntype> <arguments><argument name='with'><type><object resolved='predef::Image.colortable.`-'/></type></argument> <argument><value>...</value></argument> </arguments>
11387: </arguments> </method><method name='add'> <returntype> - <object resolved='predef::object'>object </object></returntype> + <object>object </object></returntype> <arguments><argument name='colors'><type> <array><valuetype> <array><valuetype><int/></valuetype></array></valuetype></array></type></argument>
11395: </arguments> </method><method name='add'> <returntype> - <object resolved='predef::object'>object </object></returntype> + <object>object </object></returntype> <arguments><argument name='image'><type> <object resolved='predef::Image.image'>Image.image</object></type></argument> <argument name='number'><type><int/></type></argument>
11403: </arguments> </method><method name='add'> <returntype> - <object resolved='predef::object'>object </object></returntype> + <object>object </object></returntype> <arguments><argument name='image'><type> <object resolved='predef::Image.image'>Image.image</object></type></argument> <argument name='number'><type><int/></type></argument>
11414: </arguments> </method><method name='add'> <returntype> - <object resolved='predef::object'>object </object></returntype> + <object>object </object></returntype> <arguments><argument name='r'><type><int/></type></argument> <argument name='g'><type><int/></type></argument> <argument name='b'><type><int/></type></argument>
11422: </arguments> </method><method name='add'> <returntype> - <object resolved='predef::object'>object </object></returntype> + <object>object </object></returntype> <arguments><argument name='r'><type><int/></type></argument> <argument name='g'><type><int/></type></argument> <argument name='b'><type><int/></type></argument>
11510: <docgroup homogen-name='cast' homogen-type='method'> <method name='cast'> <returntype> - <object resolved='predef::object'>object </object></returntype> + <object>object </object></returntype> <arguments><argument name='to'><type><string/></type></argument> </arguments>
11536: <docgroup homogen-name='cubicles' homogen-type='method'> <method name='cubicles'> <returntype> - <object resolved='predef::object'>object </object></returntype> + <object>object </object></returntype> <arguments> </arguments> </method><method name='cubicles'> <returntype> - <object resolved='predef::object'>object </object></returntype> + <object>object </object></returntype> <arguments><argument name='r'><type><int/></type></argument> <argument name='g'><type><int/></type></argument> <argument name='b'><type><int/></type></argument>
11549: </arguments> </method><method name='cubicles'> <returntype> - <object resolved='predef::object'>object </object></returntype> + <object>object </object></returntype> <arguments><argument name='r'><type><int/></type></argument> <argument name='g'><type><int/></type></argument> <argument name='b'><type><int/></type></argument>
11638: <docgroup homogen-name='floyd_steinberg' homogen-type='method'> <method name='floyd_steinberg'> <returntype> - <object resolved='predef::object'>object </object></returntype> + <object>object </object></returntype> <arguments> </arguments> </method><method name='floyd_steinberg'> <returntype> - <object resolved='predef::object'>object </object></returntype> + <object>object </object></returntype> <arguments><argument name='dir'><type><int/></type></argument> <argument name='forward'><type> <or><int/><float/></or></type></argument>
11702: <docgroup homogen-name='full' homogen-type='method'> <method name='full'> <returntype> - <object resolved='predef::object'>object </object></returntype> + <object>object </object></returntype> <arguments> </arguments> </method><doc>
11729: <docgroup homogen-name='image' homogen-type='method'> <method name='image'> <returntype> - <object resolved='predef::object'>object </object></returntype> + <object>object </object></returntype> <arguments> </arguments> </method><doc>
11748: <docgroup homogen-name='nodither' homogen-type='method'> <method name='nodither'> <returntype> - <object resolved='predef::object'>object </object></returntype> + <object>object </object></returntype> <arguments> </arguments> </method><doc>
11765: <docgroup homogen-name='ordered' homogen-type='method'> <method name='ordered'> <returntype> - <object resolved='predef::object'>object </object></returntype> + <object>object </object></returntype> <arguments> </arguments> </method><method name='ordered'> <returntype> - <object resolved='predef::object'>object </object></returntype> + <object>object </object></returntype> <arguments><argument name='r'><type><int/></type></argument> <argument name='g'><type><int/></type></argument> <argument name='b'><type><int/></type></argument>
11778: </arguments> </method><method name='ordered'> <returntype> - <object resolved='predef::object'>object </object></returntype> + <object>object </object></returntype> <arguments><argument name='r'><type><int/></type></argument> <argument name='g'><type><int/></type></argument> <argument name='b'><type><int/></type></argument>
11788: </arguments> </method><method name='ordered'> <returntype> - <object resolved='predef::object'>object </object></returntype> + <object>object </object></returntype> <arguments><argument name='r'><type><int/></type></argument> <argument name='g'><type><int/></type></argument> <argument name='b'><type><int/></type></argument>
11800: </arguments> </method><method name='ordered'> <returntype> - <object resolved='predef::object'>object </object></returntype> + <object>object </object></returntype> <arguments><argument name='r'><type><int/></type></argument> <argument name='g'><type><int/></type></argument> <argument name='b'><type><int/></type></argument>
11876: <docgroup homogen-type='method'> <method name='randomcube'> <returntype> -</

autodoc.git/ autodoc.xml

1999-01-01

1999-01-01 00:00:00 by Fredrik Hübinette (Hubbe) <hubbe@hubbe.net>