pike.git / src / operators.c

pike.git/src/operators.c:1:   /*\   ||| This file a part of Pike, and is copyright by Fredrik Hubinette   ||| Pike is distributed as GPL (General Public License)   ||| See the files COPYING and DISCLAIMER for more information.   \*/   /**/   #include "global.h"   #include <math.h> - RCSID("$Id: operators.c,v 1.138 2001/06/11 21:18:20 grubba Exp $"); + RCSID("$Id: operators.c,v 1.139 2001/07/27 20:40:15 nilsson Exp $");   #include "interpret.h"   #include "svalue.h"   #include "multiset.h"   #include "mapping.h"   #include "array.h"   #include "stralloc.h"   #include "opcodes.h"   #include "operators.h"   #include "language.h"   #include "pike_memory.h"
pike.git/src/operators.c:180:    *! If @[arg1] is an object and it has an @[lfun::`+()],    *! that function will be called with the rest of the arguments,    *! and the result returned.    *!    *! Otherwise if any of the other arguments is an object that has    *! an @[lfun::``+()] the first such function fill be called    *! with the arguments leading up to it, and @[`+()] be called recursively    *! with the result and the rest of the srguments.    *!    *! If there are two arguments the result will be: -  *! @mixed @[arg1] +  *! @mixed arg1    *! @type string    *! @[arg2] will be converted to a string, and the result the    *! strings concatenated.    *! @type int    *! @type float -  *! @mixed @[arg2] +  *! @mixed arg2    *! @type string    *! @[arg1] will be converted to string, and the result the    *! strings concatenated.    *! @type int    *! @type float    *! The result will be @code{@[arg1] + @[arg2]@}, and will    *! be a float if either @[arg1] or @[arg2] is a float.    *! @endmixed    *! @type array    *! The arrays will be concatenated.
pike.git/src/operators.c:1049:    *! If there are more than two arguments the result will be:    *! @code{`-(`-(@[arg1], @[arg2]), @@@[extras])@}.    *!    *! If @[arg1] is an object that overloads @tt{`-()@}, that function will    *! be called with @[arg2] as the single argument.    *!    *! If @[arg2] is an object that overloads @tt{``-()@}, that function will    *! be called with @[arg1] as the single argument.    *!    *! Otherwise the result will be as follows: -  *! @mixed @[arg1] +  *! @mixed arg1    *! @type mapping -  *! @mixed @[arg2] +  *! @mixed arg2    *! @type array    *! The result will be @[arg1] with all occurrances of    *! @[arg2] removed.    *! @type multiset    *! @type mapping    *! The result will be @[arg1] with all occurrences of    *! @code{@[indices](@[arg2])@} removed.    *! @endmixed    *! @type array    *! @type multiset
pike.git/src/operators.c:1409:    *! If there are more than two arguments, the result will be:    *! @code{`&(`&(@[arg1], @[arg2]), @@@[extras])@}.    *!    *! If @[arg1] is an object that has an @[lfun::`&()], that function    *! will be called with @[arg2] as the single argument.    *!    *! If @[arg2] is an object that has an @[lfun::``&()], that function    *! will be called with @[arg1] as the single argument.    *!    *! Otherwise the result will be as follows: -  *! @mixed @[arg1] +  *! @mixed arg1    *! @type int    *! The result will be the bitwise and of @[arg1] and @[arg2].    *! @type array    *! @type multiset    *! @type mapping    *! The result will be the elements of @[arg1] and @[arg2] that    *! occurr in both.    *! @type type    *! @type program    *! The result will be the type intersection of @[arg1] and @[arg2].
pike.git/src/operators.c:1618:    *! If there are more than two arguments, the result will be:    *! @code{`|(`|(@[arg1], @[arg2]), @@@[extras])@}.    *!    *! If @[arg1] is an object that has an @[lfun::`|()], that function    *! will be called with @[arg2] as the single argument.    *!    *! If @[arg2] is an object that has an @[lfun::``|()], that function    *! will be called with @[arg1] as the single argument.    *!    *! Otherwise the result will be as follows: -  *! @mixed @[arg1] +  *! @mixed arg1    *! @type int    *! The result will be the binary or of @[arg1] and @[arg2].    *! @type mapping    *! @type multiset    *! The result will be the join of @[arg1] and @[arg2].    *! @type array    *! The result will be the concatenation of @[arg1] and @[arg2].    *! @type string    *! The result will be the pairwise bitwose or of @[arg1] and @[arg2].    *! @type type
pike.git/src/operators.c:1829:    *! If there are more than two arguments, the result will be:    *! @code{`^(`^(@[arg1], @[arg2]), @@@[extras])@}.    *!    *! If @[arg1] is an object that has an @[lfun::`^()], that function    *! will be called with @[arg2] as the single argument.    *!    *! If @[arg2] is an object that has an @[lfun::``^()], that function    *! will be called with @[arg1] as the single argument.    *!    *! Otherwise the result will be as follows: -  *! @mixed @[arg1] +  *! @mixed arg1    *! @type int    *! The result will be the bitwise xor of @[arg1] and @[arg2].    *! @type mapping    *! @type multiset    *! @type array    *! The result will be the elements of @[arg1] and @[arg2] that    *! only occurr in one of them.    *! @type string    *! The result will be the pairwise bitwise xor of @[arg1] and @[arg2].    *! @type type
pike.git/src/operators.c:2235:    *! If the first argument is an object that implements @[lfun::`*()],    *! that function will be called with the rest of the arguments.    *!    *! If there are more than two arguments, the result will be    *! @code{`*(`*(@[arg1], @[arg2]), @@@[extras])@}.    *!    *! If @[arg2] is an object that implements @[lfun::``*()], that    *! function will be called with @[arg1] as the single argument.    *!    *! Otherwise the result will be as follows: -  *! @mixed @[arg1] +  *! @mixed arg1    *! @type array -  *! @mixed @[arg2] +  *! @mixed arg2    *! @type int    *! @type float    *! The result will be @[arg1] concatenated @[arg2] times.    *! @type string    *! @type array    *! The result will be the elements of @[arg1] concatenated with    *! @[arg2] interspersed.    *! @endmixed    *! @type string    *! The result will be @[arg1] concatenated @[arg2] times.
pike.git/src/operators.c:2589:    *! If there are more than two arguments, the result will be    *! @code{`/(`/(@[arg1], @[arg2]), @@@[extras])@}.    *!    *! If @[arg1] is an object that implements @[lfun::`/()], that    *! function will be called with @[arg2] as the single argument.    *!    *! If @[arg2] is an object that implements @[lfun::``/()], that    *! function will be called with @[arg1] as the single argument.    *!    *! Otherwise the result will be as follows: -  *! @mixed @[arg1] +  *! @mixed arg1    *! @type string -  *! @mixed @[arg2] +  *! @mixed arg2    *! @type int    *! @type float    *! The result will be and array of @[arg1] split in segments    *! of length @[arg2]. If @[arg2] is negative the splitting    *! will start from the end of @[arg1].    *! @type string    *! The result will be an array of @[arg1] split at each    *! occurrence of @[arg2]. Note that the segments that    *! matched against @[arg2] will not be in the result.    *! @endmixed    *! @type array -  *! @mixed @[arg2] +  *! @mixed arg2    *! @type int    *! @type float    *! The result will be and array of @[arg1] split in segments    *! of length @[arg2]. If @[arg2] is negative the splitting    *! will start from the end of @[arg1].    *! @type array    *! The result will be an array of @[arg1] split at each    *! occurrence of @[arg2]. Note that the elements that    *! matched against @[arg2] will not be in the result.    *! @endmixed
pike.git/src/operators.c:2777:    *! Modulo operator.    *!    *! @returns    *! If @[arg1] is an object that implements @[lfun::`%()] then    *! that function will be called with @[arg2] as the single argument.    *!    *! If @[arg2] is an object that implements @[lfun::``%()] then    *! that function will be called with @[arg2] as the single argument.    *!    *! Otherwise the result will be as follows: -  *! @mixed @[arg1] +  *! @mixed arg1    *! @type string    *! @type array    *! If @[arg2] is positive, the result will be the last    *! @code{`%(@[sizeof](@[arg1]), @[arg2])@} elements of @[arg1].    *! If @[arg2] is negative, the result will be the first    *! @code{`%(@[sizeof](@[arg1]), -@[arg2])@} elements of @[arg1].    *! @type int    *! @type float    *! The result will be    *! @code{@[arg1] - @[arg2]*@[floor](@[arg1]/@[arg2])@}.
pike.git/src/operators.c:2964:   /*! @decl mixed `~(object arg)    *! @decl int `~(int arg)    *! @decl float `~(float arg)    *! @decl type `~(type|program arg)    *! @decl string `~(string arg)    *!    *! Complement operator.    *!    *! @returns    *! The result will be as follows: -  *! @mixed @[arg] +  *! @mixed arg    *! @type object    *! If @[arg] implements @[lfun::`~()], that function will be called.    *! @type int    *! The bitwise inverse of @[arg] will be returned.    *! @type float    *! The result will be @code{-1.0 - @[arg]@}.    *! @type type    *! @type program    *! The type inverse of @[arg] will be returned.    *! @type string
pike.git/src/operators.c:3118:    *! @decl string `[](string arg, int start, int end)    *! @decl array `[](array arg, int start, int end)    *!    *! Index and range operator.    *!    *! @returns    *! If @[arg] is an object that implements @[lfun::`[]()], that function    *! will be called with the rest of the arguments.    *!    *! If there are 2 arguments the result will be as follows: -  *! @mixed @[arg] +  *! @mixed arg    *! @type object    *! The non-static (ie public) symbol named @[index] will be looked up    *! in @[arg].    *! @type int    *! The bignum function named @[index] will be looked up in @[arg].    *! @type array    *! If @[index] is an int, index number @[index] of @[arg] will be    *! returned. Otherwise an array of all elements in @[arg] indexed    *! with @[index] will be returned.    *! @type mapping
pike.git/src/operators.c:3142:    *! If @[index] exists in @[arg], @tt{1@} will be returned.    *! Otherwise @tt{UNDEFINED@} will be returned.    *! @type string    *! The character (int) at index @[index] in @[arg] will be returned.    *! @type program    *! The non-static (ie public) constant symbol @[index] will be    *! looked up in @[arg].    *! @endmixed    *!    *! Otherwise if there are 3 arguments the result will be as follows: -  *! @mixed @[arg] +  *! @mixed arg    *! @type string    *! A string with the characters between @[start] and @[end] (inclusive)    *! in @[arg] will be returned.    *! @type array    *! An array with the elements between @[start] and @[end] (inclusive)    *! in @[arg] will be returned.    *! @endmixed    *!    *! @seealso    *! @[`->()], @[lfun::`[]()]
pike.git/src/operators.c:3191:    *! Arrow index operator.    *!    *! This function behaves much like @[`[]()], just that the index is always    *! a string.    *!    *! @returns    *! If @[arg] is an object that implements @[lfun::`->()], that function    *! will be called with @[index] as the single argument.    *!    *! Otherwise the result will be as follows: -  *! @mixed @[arg] +  *! @mixed arg    *! @type object    *! The non-static (ie public) symbol named @[index] will be looked up    *! in @[arg].    *! @type int    *! The bignum function named @[index] will be looked up in @[arg].    *! @type array    *! An array of all elements in @[arg] arrow indexed with @[index]    *! will be returned.    *! @type mapping    *! If @[index] exists in @[arg] the corresponding value will be
pike.git/src/operators.c:3243:    *! @decl mixed `[]=(object arg, string index, mixed val)    *! @decl mixed `[]=(array arg, int index, mixed val)    *! @decl mixed `[]=(mapping arg, mixed index, mixed val)    *! @decl int(0..1) `[]=(multiset arg, mixed index, int(0..1) val)    *!    *! Index assign operator.    *!    *! If @[arg] is an object that implements @[lfun::`[]=()], that function    *! will be called with @[index] and @[val] as the arguments.    *! -  *! @mixed @[arg] +  *! @mixed arg    *! @type object    *! The non-static (ie public) variable named @[index] will be looked up    *! in @[arg], and assigned @[val].    *! @type array    *! @type mapping    *! Index @[index] in @[arg] will be assigned @[val].    *! @type multiset    *! If @[val] is @tt{0@} (zero), one occurrance of @[index] in    *! @[arg] will be removed. Otherwise @[index] will be added    *! to @[arg] if it is not already there.
pike.git/src/operators.c:3293:    *! @decl int(0..1) `->=(multiset arg, string index, int(0..1) val)    *!    *! Arrow assign operator.    *!    *! This function behaves much like @[`[]=()], just that the index is always    *! a string.    *!    *! If @[arg] is an object that implements @[lfun::`->=()], that function    *! will be called with @[index] and @[val] as the arguments.    *! -  *! @mixed @[arg] +  *! @mixed arg    *! @type object    *! The non-static (ie public) variable named @[index] will be looked up    *! in @[arg], and assigned @[val].    *! @type array    *! @type mapping    *! Index @[index] in @[arg] will be assigned @[val].    *! @type multiset    *! If @[val] is @tt{0@} (zero), one occurrance of @[index] in    *! @[arg] will be removed. Otherwise @[index] will be added    *! to @[arg] if it is not already there.
pike.git/src/operators.c:3341:   /*! @decl int sizeof(string arg)    *! @decl int sizeof(array arg)    *! @decl int sizeof(mapping arg)    *! @decl int sizeof(multiset arg)    *! @decl int sizeof(object arg)    *!    *! Sizeof operator.    *!    *! @returns    *! The result will be as follows: -  *! @mixed @[arg] +  *! @mixed arg    *! @type string    *! The number of characters in @[arg] will be returned.    *! @type array    *! @type multiset    *! The number of elements in @[arg] will be returned.    *! @type mapping    *! The number of key-value pairs in @[arg] will be returned.    *! @type object    *! If @[arg] implements @[lfun::_sizeof()], that function will    *! be called. Otherwise the number of non-static (ie public)