Author: leo
Date: Thu Apr 28 08:41:47 2005
New Revision: 7937
Modified:
trunk/build_tools/jit2h.pl
trunk/classes/bigint.pmc
trunk/classes/complex.pmc
trunk/classes/float.pmc
trunk/classes/integer.pmc
trunk/classes/perlundef.pmc
trunk/classes/scalar.pmc
trunk/classes/string.pmc
trunk/dynclasses/pyboolean.pmc
trunk/dynclasses/pyint.pmc
trunk/dynclasses/pyobject.pmc
trunk/ops/bit.ops
trunk/ops/cmp.ops
trunk/ops/math.ops
trunk/ops/ops.num
trunk/vtable.tbl
Log:
unary operations
see note on p6i
Modified: trunk/build_tools/jit2h.pl
==============================================================================
--- trunk/build_tools/jit2h.pl (original)
+++ trunk/build_tools/jit2h.pl Thu Apr 28 08:41:47 2005
@@ -258,6 +258,7 @@
#define Parrot_jit_vtable_2231_op Parrot_jit_normal_op
#define Parrot_jit_vtable_1r223_op Parrot_jit_normal_op
#define Parrot_jit_vtable_1r332_op Parrot_jit_normal_op
+#define Parrot_jit_vtable_1r221_op Parrot_jit_normal_op
#define Parrot_jit_vtable_ifp_op Parrot_jit_cpcf_op
#define Parrot_jit_vtable_unlessp_op Parrot_jit_cpcf_op
Modified: trunk/classes/bigint.pmc
==============================================================================
--- trunk/classes/bigint.pmc (original)
+++ trunk/classes/bigint.pmc Thu Apr 28 08:41:47 2005
@@ -918,7 +918,9 @@
/*
-=item C<void absolute()>
+=item C<PMC* absolute(PMC* dest)>
+
+=item C<void i_absolute()>
Sets C<dest> to the absolute value of SELF.
@@ -926,13 +928,23 @@
*/
- void absolute(PMC *dest) {
+ PMC* absolute(PMC *dest) {
+ if (!dest)
+ dest = pmc_new(INTERP, SELF->vtable->base_type);
bigint_abs(INTERP, SELF, dest);
+ return dest;
+ }
+
+ void i_absolute() {
+ bigint_abs(INTERP, SELF, SELF);
}
+
/*
-=item C<void neg(PMC *dest)>
+=item C<PMC* neg(PMC *dest)>
+
+=item C<void i_neg()>
Set C<dest> to the negated value of C<SELF>.
@@ -940,8 +952,15 @@
*/
- void neg (PMC* dest) {
+ PMC* neg (PMC* dest) {
+ if (!dest)
+ dest = pmc_new(INTERP, SELF->vtable->base_type);
bigint_neg(INTERP, SELF, dest);
+ return dest;
+ }
+
+ void i_neg () {
+ bigint_neg(INTERP, SELF, SELF);
}
}
Modified: trunk/classes/complex.pmc
==============================================================================
--- trunk/classes/complex.pmc (original)
+++ trunk/classes/complex.pmc Thu Apr 28 08:41:47 2005
@@ -931,7 +931,9 @@
/*
-=item C<void neg(PMC *dest)>
+=item C<PMC* neg(PMC *dest)>
+
+=item C<void neg()>
Set C<dest> to the negated value of C<SELF>.
@@ -939,10 +941,19 @@
*/
- void neg (PMC* dest) {
- VTABLE_morph(INTERP, dest, SELF->vtable->base_type);
+ PMC* neg (PMC* dest) {
+ if (!dest)
+ dest = pmc_new(INTERP, SELF->vtable->base_type);
+ else
+ VTABLE_morph(INTERP, dest, SELF->vtable->base_type);
RE(dest) = - RE(SELF);
IM(dest) = - IM(SELF);
+ return dest;
+ }
+
+ void i_neg () {
+ RE(SELF) = - RE(SELF);
+ IM(SELF) = - IM(SELF);
}
/*
@@ -975,7 +986,9 @@
/*
-=item C<void absolute()>
+=item C<PMC* absolute(PMC* dest)>
+
+=item C<void i_absolute()>
Sets C<dest> to the absolute value of SELF that is the distance from (0.0).
@@ -995,9 +1008,18 @@
*/
- void absolute(PMC *dest) {
+ PMC* absolute(PMC *dest) {
FLOATVAL d = sqrt(RE(SELF)*RE(SELF) + IM(SELF)*IM(SELF));
+ if (!dest)
+ dest = pmc_new(INTERP, enum_class_Float); /* XXX */
VTABLE_set_number_native(INTERP, dest, d);
+ return dest;
+ }
+
+ void i_absolute() {
+ FLOATVAL d = sqrt(RE(SELF)*RE(SELF) + IM(SELF)*IM(SELF));
+ VTABLE_morph(INTERP, SELF, enum_class_Float); /* XXX */
+ VTABLE_set_number_native(INTERP, SELF, d);
}
}
Modified: trunk/classes/float.pmc
==============================================================================
--- trunk/classes/float.pmc (original)
+++ trunk/classes/float.pmc Thu Apr 28 08:41:47 2005
@@ -220,7 +220,9 @@
/*
-=item C<void neg(PMC *dest)>
+=item C<PMC* neg(PMC *dest)>
+
+=item C<void i_neg()>
Set C<dest> to the negated value of C<SELF>.
@@ -228,11 +230,17 @@
*/
- void neg (PMC * dest) {
- if (dest == SELF)
- PMC_num_val(SELF) = -PMC_num_val(SELF);
- else
- VTABLE_set_number_native(INTERP, dest, -PMC_num_val(SELF));
+ PMC* neg (PMC * dest) {
+ FLOATVAL a = - DYNSELF.get_number();
+ if (!dest)
+ dest = pmc_new(INTERP, SELF->vtable->base_type);
+ VTABLE_set_number_native(INTERP, dest, a);
+ return dest;
+ }
+
+ void i_neg() {
+ FLOATVAL a = - DYNSELF.get_number();
+ VTABLE_set_number_native(INTERP, SELF, a);
}
/*
@@ -338,7 +346,9 @@
}
/*
-=item C<void absolute()>
+=item C<PMC* absolute(PMC *dest)>
+
+=item C<void i_absolute()>
Sets C<dest> to the absolute value of SELF.
@@ -346,8 +356,17 @@
*/
- void absolute(PMC *dest) {
- VTABLE_set_number_native(INTERP, dest, fabs(PMC_num_val(SELF)));
+ PMC* absolute(PMC *dest) {
+ FLOATVAL a = fabs(DYNSELF.get_number());
+ if (!dest)
+ dest = pmc_new(INTERP, SELF->vtable->base_type);
+ VTABLE_set_number_native(INTERP, dest, a);
+ return dest;
+ }
+
+ void i_absolute() {
+ FLOATVAL a = fabs(DYNSELF.get_number());
+ VTABLE_set_number_native(INTERP, SELF, a);
}
/*
Modified: trunk/classes/integer.pmc
==============================================================================
--- trunk/classes/integer.pmc (original)
+++ trunk/classes/integer.pmc Thu Apr 28 08:41:47 2005
@@ -1073,37 +1073,6 @@
/*
-=item C<void neg(PMC *dest)>
-
-Set C<dest> to the negated value of C<SELF>.
-
-=cut
-
-*/
- void neg (PMC* dest) {
- if (dest == SELF)
- PMC_int_val(SELF) = -PMC_int_val(SELF);
- else
- VTABLE_set_integer_native(INTERP, dest, -PMC_int_val(SELF));
- }
-
-
-/*
-
-=item C<void bitwise_not(PMC *dest)>
-
-Calculates the bitwise C<NOT> of the integer and returns the result in
-C<*dest>.
-
-=cut
-
-*/
- void bitwise_not (PMC* dest) {
- VTABLE_set_integer_native(INTERP, dest, ~PMC_int_val(SELF));
- }
-
-/*
-
=item C<INTVAL is_equal (PMC* value)>
The C<==> operation.
@@ -1222,6 +1191,8 @@
}
/*
+=item C<PMC* absolute(PMC* dest)>
+
=item C<void absolute()>
Sets C<dest> to the absolute value of SELF.
@@ -1230,8 +1201,19 @@
*/
- void absolute(PMC *dest) {
- VTABLE_set_integer_native(INTERP, dest, abs(PMC_int_val(SELF)));
+ PMC* absolute(PMC *dest) {
+ INTVAL a = abs(DYNSELF.get_integer());
+ /* XXX overlflow for -maxint */
+ if (!dest)
+ dest = pmc_new(INTERP, SELF->vtable->base_type);
+ VTABLE_set_integer_native(INTERP, dest, a);
+ return dest;
+
+ }
+
+ void i_absolute() {
+ INTVAL a = abs(DYNSELF.get_integer());
+ VTABLE_set_integer_native(INTERP, SELF, a);
}
/*
Modified: trunk/classes/perlundef.pmc
==============================================================================
--- trunk/classes/perlundef.pmc (original)
+++ trunk/classes/perlundef.pmc Thu Apr 28 08:41:47 2005
@@ -494,7 +494,9 @@
}
/*
-=item C<void logical_not(PMC *dest)>
+=item C<PMC logical_not(PMC *dest)>
+
+=item C<void i_logical_not()>
Since we know that we're false, the logical ops are particularly
simple, and there's no need to use the versions in C<PerlScalar>.
@@ -505,8 +507,14 @@
*/
- void logical_not (PMC* dest) {
+ PMC* logical_not (PMC* dest) {
+ if (!dest)
+ dest = pmc_new(INTERP, enum_class_PerlInt);
VTABLE_set_integer_native(INTERP, dest, 1);
+ return dest;
+ }
+ void i_logical_not () {
+ VTABLE_set_integer_native(INTERP, SELF, 1);
}
/*
Modified: trunk/classes/scalar.pmc
==============================================================================
--- trunk/classes/scalar.pmc (original)
+++ trunk/classes/scalar.pmc Thu Apr 28 08:41:47 2005
@@ -748,7 +748,9 @@
/*
-=item C<void neg(PMC *dest)>
+=item C<PMC* neg(PMC *dest)>
+
+=item C<void i_neg()>
Set C<dest> to the negated value of C<SELF>.
@@ -756,8 +758,16 @@
*/
- void neg (PMC* dest) {
- VTABLE_set_number_native(INTERP, dest, -DYNSELF.get_number());
+ PMC* neg (PMC* dest) {
+ INTVAL a = -DYNSELF.get_integer();
+ if (!dest)
+ dest = pmc_new(INTERP, SELF->vtable->base_type);
+ VTABLE_set_integer_native(INTERP, dest, a);
+ return dest;
+ }
+
+ void i_neg () {
+ VTABLE_set_integer_native(INTERP, SELF, -DYNSELF.get_integer());
}
/*
@@ -927,7 +937,9 @@
/*
-=item C<void bitwise_not(PMC *dest)>
+=item C<PMC* bitwise_not(PMC *dest)>
+
+=item C<void i_bitwise_not()>
Returns in C<*dest> the bitwise negation of the scalar and C<value>.
@@ -935,8 +947,16 @@
*/
- void bitwise_not (PMC* dest) {
- VTABLE_set_integer_native(INTERP, dest, ~DYNSELF.get_integer());
+ PMC* bitwise_not (PMC* dest) {
+ INTVAL a = ~DYNSELF.get_integer();
+ if (!dest)
+ dest = pmc_new(INTERP, SELF->vtable->base_type);
+ VTABLE_set_integer_native(INTERP, dest, a);
+ return dest;
+ }
+
+ void i_bitwise_not () {
+ VTABLE_set_integer_native(INTERP, SELF, ~DYNSELF.get_integer());
}
@@ -1379,7 +1399,9 @@
}
/*
-=item C<void logical_not(PMC *dest)>
+=item C<PMC* logical_not(PMC *dest)>
+
+=item C<void i_logical_not()>
Returns in C<*dest> the result of the logical negation of the scalar and
C<*value>.
@@ -1388,10 +1410,17 @@
*/
- void logical_not (PMC* dest) {
- VTABLE_set_bool(INTERP, dest, ! DYNSELF.get_bool());
+ PMC* logical_not (PMC* dest) {
+ INTVAL a = ! DYNSELF.get_bool();
+ if (!dest)
+ dest = pmc_new(INTERP, SELF->vtable->base_type);
+ VTABLE_set_bool(INTERP, dest, a);
+ return dest;
}
+ void i_logical_not () {
+ VTABLE_set_bool(INTERP, SELF, ! DYNSELF.get_bool());
+ }
/*
Modified: trunk/classes/string.pmc
==============================================================================
--- trunk/classes/string.pmc (original)
+++ trunk/classes/string.pmc Thu Apr 28 08:41:47 2005
@@ -292,7 +292,7 @@
=item C<void i_bitwise_xors_str(PMC* value)>
-=item C<void bitwise_nots(PMC* value)>
+=item C<void i_bitwise_nots(PMC* value)>
These functions perform bitwise operations on entire
strings in place.
@@ -391,10 +391,19 @@
DYNSELF.set_string_native(string_bitwise_xor(INTERP, s, value, &s));
}
- void bitwise_nots (PMC* dest) {
+ PMC* bitwise_nots (PMC* dest) {
STRING *s = PMC_str_val(SELF);
+ if (!dest)
+ dest = pmc_new(INTERP, SELF->vtable->base_type);
VTABLE_set_string_native(
INTERP, dest, string_bitwise_not(INTERP, s, NULL));
+ return dest;
+ }
+
+ void i_bitwise_nots () {
+ STRING *s = PMC_str_val(SELF);
+ VTABLE_set_string_native(
+ INTERP, SELF, string_bitwise_not(INTERP, s, &s));
}
/*
Modified: trunk/dynclasses/pyboolean.pmc
==============================================================================
--- trunk/dynclasses/pyboolean.pmc (original)
+++ trunk/dynclasses/pyboolean.pmc Thu Apr 28 08:41:47 2005
@@ -133,6 +133,8 @@
/*
+=item C<PMC* logical_not(PMC* dest)>
+
=item C<void logical_not()>
Returns the negated value of the boolean.
@@ -141,11 +143,20 @@
*/
- void logical_not (PMC *dest) {
- VTABLE_morph(INTERP, dest, PyBuiltin_PyBoolean);
+ PMC* logical_not (PMC *dest) {
+ if (!dest)
+ dest = pmc_new(INTERP, PyBuiltin_PyBoolean);
+ else
+ VTABLE_morph(INTERP, dest, PyBuiltin_PyBoolean);
VTABLE_set_integer_native(INTERP, dest, PMC_int_val(SELF) == 0);
+ return dest;
+ }
+
+ void i_logical_not () {
+ VTABLE_set_integer_native(INTERP, SELF, PMC_int_val(SELF) == 0);
}
+
/*
=item C<void set_integer_native (INTVAL value)>
Modified: trunk/dynclasses/pyint.pmc
==============================================================================
--- trunk/dynclasses/pyint.pmc (original)
+++ trunk/dynclasses/pyint.pmc Thu Apr 28 08:41:47 2005
@@ -180,19 +180,6 @@
return ret;
}
-/*
-
-=item C<void absolute(dest)>
-
-Sets C<dest> to the absolute value of SELF.
-
-=cut
-
-*/
-
- void absolute(PMC *dest) {
- VTABLE_set_integer_native(INTERP, dest, abs(PMC_int_val(SELF)));
- }
/*
@@ -397,40 +384,6 @@
}
/*
-
-=item C<void logical_not(PMC *value)>
-
-Calculates the logical negation of the integer and returns the result in
-C<*value>.
-
-=cut
-
-*/
-
- void logical_not (PMC* value) {
- VTABLE_set_integer_native(INTERP, value, !PMC_int_val(SELF));
- }
-
-
-
-/*
-
-=item C<void neg(PMC *dest)>
-
-Set C<dest> to the negated value of C<SELF>.
-
-=cut
-
-*/
-
- void neg (PMC* dest) {
- if (dest == SELF)
- PMC_int_val(SELF) = -PMC_int_val(SELF);
- else
- VTABLE_set_integer_native(INTERP, dest, -PMC_int_val(SELF));
- }
-
-/*
=item C<void set_integer_native(INTVAL value)>
Modified: trunk/dynclasses/pyobject.pmc
==============================================================================
--- trunk/dynclasses/pyobject.pmc (original)
+++ trunk/dynclasses/pyobject.pmc Thu Apr 28 08:41:47 2005
@@ -669,7 +669,10 @@
/*
-=item C<void logical_not(PMC *dest)>
+=item C<PMC logical_not(PMC *dest)>
+
+=item C<void i_logical_not()>
+
Returns in C<*dest> the result of the logical not of the scalar.
@@ -677,10 +680,19 @@
*/
- void logical_not (PMC* dest) {
- VTABLE_set_integer_native(INTERP, dest, !DYNSELF.get_bool());
+ PMC* logical_not (PMC* dest) {
+ INTVAL a = ! DYNSELF.get_bool();
+ if (!dest)
+ dest = pmc_new(INTERP, SELF->vtable->base_type);
+ VTABLE_set_bool(INTERP, dest, a);
+ return dest;
}
+ void i_logical_not () {
+ VTABLE_set_bool(INTERP, SELF, ! DYNSELF.get_bool());
+ }
+
+
/*
=item C<PMC* logical_or(PMC *value, PMC *dest)>
Modified: trunk/ops/bit.ops
==============================================================================
--- trunk/ops/bit.ops (original)
+++ trunk/ops/bit.ops Thu Apr 28 08:41:47 2005
@@ -79,39 +79,83 @@
########################################
+=item B<bnot>(inout INT)
+
+=item B<bnot>(in PMC)
+
+Sets $1 to C<bitwise not> $1 inplace.
+
=item B<bnot>(out INT, in INT)
-=item B<bnot>(in PMC, in PMC)
+=item B<bnot>(out PMC, in PMC)
+
+=item B<n_bnot>(out PMC, in PMC)
Set the bits of $1 to the B<not> of the corresponding bits from $2.
=cut
+inline op bnot(inout INT) :base_core {
+ $1 = ~ $1;
+ goto NEXT();
+}
+
inline op bnot(out INT, in INT) :base_core {
$1 = ~ $2;
goto NEXT();
}
-inline op bnot(in PMC, in PMC) :base_core {
- $2->vtable->bitwise_not(interpreter, $2, $1);
+inline op bnot(in PMC) :base_core {
+ $1->vtable->i_bitwise_not(interpreter, $1);
+ goto NEXT();
+}
+
+inline op bnot(out PMC, in PMC) :base_core {
+ $1 = $2->vtable->bitwise_not(interpreter, $2, $1);
+ goto NEXT();
+}
+
+inline op n_bnot(out PMC, in PMC) :base_core {
+ $1 = $2->vtable->bitwise_not(interpreter, $2, NULL);
goto NEXT();
}
+=item B<bnots>(inout STR)
+
+=item B<bnots>(in PMC)
+
=item B<bnots>(out STR, in STR)
-=item B<bnots>(in PMC, in PMC)
+=item B<bnots>(out PMC, in PMC)
+
+=item B<n_bnots>(out PMC, in PMC)
Set the bits of $1 to the B<not> of the corresponding bits from $2.
=cut
+inline op bnots(inout STR) :base_core {
+ string_bitwise_not(interpreter, $1, &$1);
+ goto NEXT();
+}
+
inline op bnots(out STR, in STR) :base_core {
string_bitwise_not(interpreter, $2, &$1);
goto NEXT();
}
+inline op bnots(in PMC) :base_core {
+ $1->vtable->i_bitwise_nots(interpreter, $1);
+ goto NEXT();
+}
+
inline op bnots(in PMC, in PMC) :base_core {
- $2->vtable->bitwise_nots(interpreter, $2, $1);
+ $1 = $2->vtable->bitwise_nots(interpreter, $2, $1);
+ goto NEXT();
+}
+
+inline op n_bnots(in PMC, in PMC) :base_core {
+ $1 = $2->vtable->bitwise_nots(interpreter, $2, NULL);
goto NEXT();
}
Modified: trunk/ops/cmp.ops
==============================================================================
--- trunk/ops/cmp.ops (original)
+++ trunk/ops/cmp.ops Thu Apr 28 08:41:47 2005
@@ -699,21 +699,44 @@
########################################
+=item B<not>(out INT)
+
+=item B<not>(in PMC)
+
+Set the boolean state of $1 to the opposite of the boolean state from $1.
+
=item B<not>(out INT, in INT)
-=item B<not>(in PMC, in PMC)
+=item B<not>(out PMC, in PMC)
+
+=item B<n_not>(out PMC, in PMC)
Set the boolean state of $1 to the opposite of the boolean state from $2.
=cut
+inline op not(inout INT) :base_core {
+ $1 = ! $1;
+ goto NEXT();
+}
+
inline op not(out INT, in INT) :base_core {
$1 = ! $2;
goto NEXT();
}
-inline op not(in PMC, in PMC) :base_core {
- $2->vtable->logical_not(interpreter, $2, $1);
+inline op not(in PMC) :base_core {
+ $2->vtable->i_logical_not(interpreter, $1);
+ goto NEXT();
+}
+
+inline op not(out PMC, in PMC) :base_core {
+ $1 = $2->vtable->logical_not(interpreter, $2, $1);
+ goto NEXT();
+}
+
+inline op n_not(out PMC, in PMC) :base_core {
+ $1 = $2->vtable->logical_not(interpreter, $2, NULL);
goto NEXT();
}
Modified: trunk/ops/math.ops
==============================================================================
--- trunk/ops/math.ops (original)
+++ trunk/ops/math.ops Thu Apr 28 08:41:47 2005
@@ -151,10 +151,14 @@
=item B<abs>(out NUM, in NUM)
-=item B<abs>(in PMC, in PMC)
+=item B<abs>(out PMC, in PMC)
Set $1 to absolute value of $2.
+=item B<n_abs>(out PMC, in PMC)
+
+Create new $1 as the absolute of $2.
+
=cut
inline op abs( inout INT) :base_core {
@@ -188,12 +192,17 @@
}
inline op abs(in PMC) :base_core {
- $1->vtable->absolute(interpreter, $1, $1);
+ $1->vtable->i_absolute(interpreter, $1);
+ goto NEXT();
+}
+
+inline op abs(out PMC, in PMC) :base_core {
+ $1 = $2->vtable->absolute(interpreter, $2, $1);
goto NEXT();
}
-inline op abs(in PMC, in PMC) :base_core {
- $2->vtable->absolute(interpreter, $2, $1);
+inline op n_abs(out PMC, in PMC) :base_core {
+ $1 = $2->vtable->absolute(interpreter, $2, NULL);
goto NEXT();
}
@@ -695,10 +704,14 @@
=item B<neg>(out NUM, in NUM)
-=item B<neg>(in PMC, in PMC)
+=item B<neg>(out PMC, in PMC)
Set $1 to the negative of $2.
+=item B<n_neg>(out PMC, in PMC)
+
+Create $1 as the negative of $2.
+
=cut
inline op neg(inout INT) :base_core {
@@ -712,7 +725,7 @@
}
inline op neg(in PMC) :base_core {
- $1->vtable->neg(interpreter, $1, $1);
+ $1->vtable->i_neg(interpreter, $1);
goto NEXT();
}
@@ -726,8 +739,13 @@
goto NEXT();
}
-inline op neg(in PMC, in PMC) :base_core {
- $2->vtable->neg(interpreter, $2, $1);
+inline op neg(out PMC, in PMC) :base_core {
+ $1 = $2->vtable->neg(interpreter, $2, $1);
+ goto NEXT();
+}
+
+inline op n_neg(out PMC, in PMC) :base_core {
+ $1 = $2->vtable->neg(interpreter, $2, NULL);
goto NEXT();
}
Modified: trunk/ops/ops.num
==============================================================================
--- trunk/ops/ops.num (original)
+++ trunk/ops/ops.num Thu Apr 28 08:41:47 2005
@@ -1330,3 +1330,14 @@
backtrace 1300
pic_infix___ic_p_p 1301
pic_inline_sub___ic_p_p 1302
+n_abs_p_p 1303
+n_neg_p_p 1304
+bnot_i 1305
+bnot_p 1306
+n_bnot_p_p 1307
+bnots_s 1308
+bnots_p 1309
+n_bnots_p_p 1310
+not_i 1311
+not_p 1312
+n_not_p_p 1313
Modified: trunk/vtable.tbl
==============================================================================
--- trunk/vtable.tbl (original)
+++ trunk/vtable.tbl Thu Apr 28 08:41:47 2005
@@ -203,8 +203,12 @@
void increment()
void decrement()
-void absolute(PMC* dest)
-void neg(PMC* dest)
+
+PMC* absolute(PMC* dest)
+void i_absolute()
+
+PMC* neg(PMC* dest)
+void i_neg()
[BITWISE]
PMC* bitwise_or(PMC* value, PMC* dest) MMD_BOR
@@ -243,9 +247,11 @@
void i_bitwise_xors(PMC* value) MMD_I_SXOR
void i_bitwise_xors_str(STRING* value) MMD_I_SXOR_STR
-void bitwise_not(PMC* dest)
+PMC* bitwise_not(PMC* dest)
+void i_bitwise_not()
-void bitwise_nots(PMC* dest)
+PMC* bitwise_nots(PMC* dest)
+void i_bitwise_nots()
PMC* bitwise_shl(PMC* value, PMC* dest) MMD_BSL
PMC* bitwise_shl_int(INTVAL value, PMC* dest) MMD_BSL_INT
@@ -285,7 +291,9 @@
PMC* logical_xor(PMC* value, PMC* dest) MMD_LXOR
void i_logical_xor(PMC* value) MMD_I_LXOR
-void logical_not(PMC* dest)
+PMC* logical_not(PMC* dest)
+void i_logical_not()
+
[STRING]
PMC* concatenate(PMC* value, PMC* dest) MMD_CONCAT
