pike.git / src / operators.c

pike.git/src/operators.c:1:   /*\   ||| This file is part of Pike. For copyright information see COPYRIGHT.   ||| 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.151 2002/05/30 15:36:49 nilsson Exp $"); + RCSID("$Id: operators.c,v 1.152 2002/05/31 13:44:31 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:204:    *! @endmixed    *! @type array    *! The arrays will be concatenated.    *! @type mapping    *! The mappings will be joined.    *! @type multiset    *! The multisets will be added.    *! @endmixed    *!    *! Otherwise if there are more than 2 arguments the result will be: -  *! @expr{`+(`+(@[arg1], @[arg2]), @@@[extras])@} +  *! @code{`+(`+(@[arg1], @[arg2]), @@@[extras])@}    *!    *! @note    *! In Pike 7.0 and earlier the addition order was unspecified.    *!    *! If @[arg1] is @tt{UNDEFINED@} it will behave as the empty    *! array/mapping/multiset if needed. This behaviour was new    *! in Pike 7.0.    *!    *! @seealso    *! @[`-()], @[lfun::`+()], @[lfun::``+()]
pike.git/src/operators.c:1050:    *! @decl float `-(float arg1, int|float arg2)    *! @decl float `-(int arg1, float arg2)    *! @decl int `-(int arg1, int arg2)    *! @decl string `-(string arg1, string arg2)    *! @decl mixed `-(mixed arg1, mixed arg2, mixed ... extras)    *!    *! Negation/subtraction operator.    *!    *! @returns    *! If there's only a single argument, that argument will be returned -  *! negated. If @[arg1] was an object, @code{@[arg1]::`-()@} will be called +  *! negated. If @[arg1] was an object, @expr{@[arg1]::`-()@} will be called    *! without arguments.    *!    *! 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    *! @type mapping    *! @mixed arg2    *! @type array    *! The result will be @[arg1] with all occurrances of    *! @[arg2] removed.    *! @type multiset|mapping    *! The result will be @[arg1] with all occurrences of -  *! @code{@[indices](@[arg2])@} removed. +  *! @expr{@[indices](@[arg2])@} removed.    *! @endmixed    *! @type array|multiset    *! The result will be the elements of @[arg1] that are not in @[arg2].    *! @type float|int -  *! The result will be @code{@[arg1] - @[arg2]@}, and will be a float +  *! The result will be @expr{@[arg1] - @[arg2]@}, and will be a float    *! if either @[arg1] or @[arg2] is a float.    *! @type string    *! Result will be the string @[arg1] with all occurrances of the    *! substring @[arg2] removed.    *! @endmixed    *!    *! @note    *! In Pike 7.0 and earlier the subtraction order was unspecified.    *!    *! @seealso
pike.git/src/operators.c:1860:    *! @mixed arg1    *! @type int    *! The result will be the bitwise xor of @[arg1] and @[arg2].    *! @type mapping|multiset|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|program    *! The result will be the result of -  *! @code{(@[arg1]&~@[arg2])|(~@[arg1]&@[arg2])@}. +  *! @expr{(@[arg1]&~@[arg2])|(~@[arg1]&@[arg2])@}.    *! @endmixed    *!    *! @seealso    *! @[`&()], @[`|()], @[lfun::`^()], @[lfun::``^()]    */   PMOD_EXPORT void f_xor(INT32 args)   {    switch(args)    {    case 0: SIMPLE_TOO_FEW_ARGS_ERROR("`^", 1);
pike.git/src/operators.c:2307:    *!    *! Multiplication operator.    *!    *! @returns    *! If there's only a single argument, that argument will be returned.    *!    *! 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])@}. +  *! @expr{`*(`*(@[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    *! @type array    *! @mixed arg2    *! @type int|float    *! The result will be @[arg1] concatenated @[arg2] times.    *! @type string|array    *! The result will be the elements of @[arg1] concatenated with    *! @[arg2] interspersed.    *! @endmixed    *! @type string    *! The result will be @[arg1] concatenated @[arg2] times.    *! @type int|float -  *! The result will be @code{@[arg1] * @[arg2]@}, and will be a +  *! The result will be @expr{@[arg1] * @[arg2]@}, and will be a    *! float if either @[arg1] or @[arg2] is a float.    *! @endmixed    *!    *! @note    *! In Pike 7.0 and earlier the multiplication order was unspecified.    *!    *! @seealso    *! @[`+()], @[`-()], [`/()], @[lfun::`*()], @[lfun::``*()]    */   PMOD_EXPORT void f_multiply(INT32 args)
pike.git/src/operators.c:2655:    *! @decl array(array) `/(array arg1, array arg2)    *! @decl float `/(float arg1, int|float arg2)    *! @decl float `/(int arg1, float arg2)    *! @decl int `/(int arg1, int arg2)    *! @decl mixed `/(mixed arg1, mixed arg2, mixed ... extras)    *!    *! Division operator.    *!    *! @returns    *! If there are more than two arguments, the result will be -  *! @code{`/(`/(@[arg1], @[arg2]), @@@[extras])@}. +  *! @expr{`/(`/(@[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    *! @type string
pike.git/src/operators.c:2688:    *! @type int|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    *! @type float|int -  *! The result will be @code{@[arg1] / @[arg2]@}. If both arguments +  *! The result will be @expr{@[arg1] / @[arg2]@}. If both arguments    *! are int, the result will be truncated to an int. Otherwise the    *! result will be a float.    *! @endmixed    */   PMOD_EXPORT void f_divide(INT32 args)   {    switch(args)    {    case 0:    case 1: SIMPLE_TOO_FEW_ARGS_ERROR("`/", 2);
pike.git/src/operators.c:2854:    *! 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    *! @type string|array    *! If @[arg2] is positive, the result will be the last -  *! @code{`%(@[sizeof](@[arg1]), @[arg2])@} elements of @[arg1]. +  *! @expr{`%(@[sizeof](@[arg1]), @[arg2])@} elements of @[arg1].    *! If @[arg2] is negative, the result will be the first -  *! @code{`%(@[sizeof](@[arg1]), -@[arg2])@} elements of @[arg1]. +  *! @expr{`%(@[sizeof](@[arg1]), -@[arg2])@} elements of @[arg1].    *! @type int|float    *! The result will be -  *! @code{@[arg1] - @[arg2]*@[floor](@[arg1]/@[arg2])@}. +  *! @expr{@[arg1] - @[arg2]*@[floor](@[arg1]/@[arg2])@}.    *! The result will be a float if either @[arg1] or @[arg2] is    *! a float, and an int otherwise.    *! @endmixed    */   PMOD_EXPORT void f_mod(INT32 args)   {    if(args != 2) {    /* FIXME: Not appropriate when too many args. */    SIMPLE_TOO_FEW_ARGS_ERROR("`%", 2);    }
pike.git/src/operators.c:3042:    *! Complement operator.    *!    *! @returns    *! The result will be as follows:    *! @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]@}. +  *! The result will be @expr{-1.0 - @[arg]@}.    *! @type type|program    *! The type inverse of @[arg] will be returned.    *! @type string    *! If @[arg] only contains characters in the range 0 - 255 (8-bit),    *! a string containing the corresponding 8-bit inverses will be    *! returned.    *! @endmixed    *!    *! @seealso    *! @[`!()], @[lfun::`~()]