cmp.ops

/*
** cmp.ops
*/

VERSION = PARROT_VERSION;

=head1 NAME

cmp.ops - Register Comparison Ops

=cut

=head1 DESCRIPTION

Operations that compare two registers against each other.
Some of these operations affect control flow directly; others
do not.

The variants with a prepended B<n_> like <n_not> generate a new target PMC.
If possible, they use the appropriate language type, specified with C<.HLL>.

=cut

###############################################################################

=head2 Flow control comparison operators

These operators branch based on the relationship between
their operands.

=over 4

=cut

########################################

=item B<eq>(in INT, in INT, labelconst INT)

=item B<eq>(in NUM, in NUM, labelconst INT)

=item B<eq>(in STR, in STR, labelconst INT)

=item B<eq>(in PMC, in PMC, labelconst INT)

=item B<eq>(in PMC, in INT, labelconst INT)

=item B<eq>(in PMC, in NUM, labelconst INT)

=item B<eq>(in PMC, in STR, labelconst INT)

=item B<eq_str>(in PMC, in PMC, labelconst INT)

=item B<eq_num>(in PMC, in PMC, labelconst INT)

=item B<eq_addr>(in STR, in STR, labelconst INT)

=item B<eq_addr>(in PMC, in PMC, labelconst INT)

Branch if $1 is equal to $2. For PMCs this does a generic comparison,
whatever that is for the involved PMCs. Mixed PMC number/string
operands do a numeric or string comparison respectively.

B<eq_str> and B<eq_num> enforce string or number comparisons.

B<eq_addr> compares the address of the objects or strings.

=cut

inline op eq(in INT, in INT, labelconst INT) :base_core {
  if ($1 == $2) {
    goto OFFSET($3);
  }
  goto NEXT();
}

inline op eq(in NUM, in NUM, labelconst INT) :base_core {
  if ($1 == $2) {
    goto OFFSET($3);
  }
  goto NEXT();
}

op eq(in STR, in STR, labelconst INT) :base_core {
  if (string_equal(interpreter, $1, $2) == 0) {
    goto OFFSET($3);
  }
  goto NEXT();
}

op eq (in PMC, in PMC, labelconst INT) :base_core {
  if (mmd_dispatch_i_pp(interpreter, $1, $2, MMD_EQ)) {
    goto OFFSET($3);
  }
  goto NEXT();
}

op eq (in PMC, in INT, labelconst INT) :base_core {
  if ($1->vtable->get_integer(interpreter, $1) == $2) {
    goto OFFSET($3);
  }
  goto NEXT();
}

op eq (in PMC, in NUM, labelconst INT) :base_core {
  if ($1->vtable->get_number(interpreter, $1) == $2) {
    goto OFFSET($3);
  }
  goto NEXT();
}

op eq (in PMC, in STR, labelconst INT) :base_core {
  if (0 == string_equal(interpreter,
      $1->vtable->get_string(interpreter, $1), $2)) {
    goto OFFSET($3);
  }
  goto NEXT();
}

op eq_str (in PMC, in PMC, labelconst INT) :base_core {
  if (mmd_dispatch_i_pp(interpreter, $1, $2, MMD_STREQ)) {
    goto OFFSET($3);
  }
  goto NEXT();
}

op eq_num (in PMC, in PMC, labelconst INT) :base_core {
  if (mmd_dispatch_i_pp(interpreter, $1, $2, MMD_NUMEQ)) {
    goto OFFSET($3);
  }
  goto NEXT();
}

op eq_addr(in STR, in STR, labelconst INT) :base_core {
  if ($1 == $2) {
    goto OFFSET($3);
  }
  goto NEXT();
}

op eq_addr(in PMC, in PMC, labelconst INT) :base_core {
  if ($1 == $2) {
    goto OFFSET($3);
  }
  goto NEXT();
}

########################################

=item B<ne>(in INT, in INT, labelconst INT)

=item B<ne>(in NUM, in NUM, labelconst INT)

=item B<ne>(in STR, in STR, labelconst INT)

=item B<ne>(in PMC, in PMC, labelconst INT)

=item B<ne>(in PMC, in INT, labelconst INT)

=item B<ne>(in PMC, in NUM, labelconst INT)

=item B<ne>(in PMC, in STR, labelconst INT)

=item B<ne_str>(in PMC, in PMC, labelconst INT)

=item B<ne_num>(in PMC, in PMC, labelconst INT)

=item B<ne_addr>(in STR, in STR, labelconst INT)

=item B<ne_addr>(in PMC, in PMC, labelconst INT)

Branch if $1 is not equal to $2.

=cut

inline op ne(in INT, in INT, labelconst INT) :base_core {
  if ($1 != $2) {
    goto OFFSET($3);
  }
  goto NEXT();
}

inline op ne(in NUM, in NUM, labelconst INT) :base_core {
  if ($1 != $2) {
    goto OFFSET($3);
  }
  goto NEXT();
}

op ne(in STR, in STR, labelconst INT) :base_core {
  if (string_equal(interpreter, $1, $2) != 0) {
    goto OFFSET($3);
  }
  goto NEXT();
}

op ne(in PMC, in PMC, labelconst INT) :base_core {
  if (! mmd_dispatch_i_pp(interpreter, $1, $2, MMD_EQ)) {
    goto OFFSET($3);
  }
  goto NEXT();
}

op ne (in PMC, in INT, labelconst INT) :base_core {
  if ($1->vtable->get_integer(interpreter, $1) != $2) {
    goto OFFSET($3);
  }
  goto NEXT();
}

op ne (in PMC, in NUM, labelconst INT) :base_core {
  if ($1->vtable->get_number(interpreter, $1) != $2) {
    goto OFFSET($3);
  }
  goto NEXT();
}

op ne (in PMC, in STR, labelconst INT) :base_core {
  if (0 != string_equal(interpreter,
      $1->vtable->get_string(interpreter, $1), $2)) {
    goto OFFSET($3);
  }
  goto NEXT();
}

op ne_str (in PMC, in PMC, labelconst INT) :base_core {
  if (mmd_dispatch_i_pp(interpreter, $1, $2, MMD_STRCMP) != 0) {
    goto OFFSET($3);
  }
  goto NEXT();
}

op ne_num (in PMC, in PMC, labelconst INT) :base_core {
  if (mmd_dispatch_i_pp(interpreter, $1, $2, MMD_NUMCMP) != 0) {
    goto OFFSET($3);
  }
  goto NEXT();
}

op ne_addr(in STR, in STR, labelconst INT) :base_core {
  if ($1 != $2) {
    goto OFFSET($3);
  }
  goto NEXT();
}

op ne_addr(in PMC, in PMC, labelconst INT) :base_core {
  if ($1 != $2) {
    goto OFFSET($3);
  }
  goto NEXT();
}

########################################

=item B<lt>(in INT, in INT, labelconst INT)

=item B<lt>(in NUM, in NUM, labelconst INT)

=item B<lt>(in STR, in STR, labelconst INT)

=item B<lt>(in PMC, in PMC, labelconst INT)

=item B<lt>(in PMC, in INT, labelconst INT)

=item B<lt>(in PMC, in NUM, labelconst INT)

=item B<lt>(in PMC, in STR, labelconst INT)

=item B<lt_str>(in PMC, in PMC, labelconst INT)

=item B<lt_num>(in PMC, in PMC, labelconst INT)

Branch if $1 is less than $2.

=cut

inline op lt(in INT, in INT, labelconst INT) :base_core {
  if ($1 < $2) {
    goto OFFSET($3);
  }
  goto NEXT();
}

inline op lt(in NUM, in NUM, labelconst INT) :base_core {
  if ($1 < $2) {
    goto OFFSET($3);
  }
  goto NEXT();
}

op lt(in STR, in STR, labelconst INT) :base_core {
  if (string_compare(interpreter, $1, $2) < 0) {
    goto OFFSET($3);
  }
  goto NEXT();
}

op lt (in PMC, in PMC, labelconst INT) :base_core {
  if (mmd_dispatch_i_pp(interpreter, $1, $2, MMD_CMP) < 0) {
    goto OFFSET($3);
  }
  goto NEXT();
}

op lt (in PMC, in INT, labelconst INT) :base_core {
  if ($1->vtable->get_integer(interpreter, $1) < $2) {
    goto OFFSET($3);
  }
  goto NEXT();
}

op lt (in PMC, in NUM, labelconst INT) :base_core {
  if ($1->vtable->get_number(interpreter, $1) < $2) {
    goto OFFSET($3);
  }
  goto NEXT();
}

op lt (in PMC, in STR, labelconst INT) :base_core {
  if (string_compare(interpreter,
      $1->vtable->get_string(interpreter, $1), $2) < 0) {
    goto OFFSET($3);
  }
  goto NEXT();
}

op lt_str (in PMC, in PMC, labelconst INT) :base_core {
  if (mmd_dispatch_i_pp(interpreter, $1, $2, MMD_STRCMP) < 0) {
    goto OFFSET($3);
  }
  goto NEXT();
}

op lt_num (in PMC, in PMC, labelconst INT) :base_core {
  if (mmd_dispatch_i_pp(interpreter, $1, $2, MMD_NUMCMP) < 0) {
    goto OFFSET($3);
  }
  goto NEXT();
}

########################################

=item B<le>(in INT, in INT, labelconst INT)

=item B<le>(in NUM, in NUM, labelconst INT)

=item B<le>(in STR, in STR, labelconst INT)

=item B<le>(in PMC, in PMC, labelconst INT)

=item B<le>(in PMC, in INT, labelconst INT)

=item B<le>(in PMC, in NUM, labelconst INT)

=item B<le>(in PMC, in STR, labelconst INT)

=item B<le_str>(in PMC, in PMC, labelconst INT)

=item B<le_num>(in PMC, in PMC, labelconst INT)

Branch if $1 is less than or equal to $2.

=cut

inline op le(in INT, in INT, labelconst INT) :base_core {
  if ($1 <= $2) {
    goto OFFSET($3);
  }
  goto NEXT();
}

inline op le(in NUM, in NUM, labelconst INT) :base_core {
  if ($1 <= $2) {
    goto OFFSET($3);
  }
  goto NEXT();
}

op le(in STR, in STR, labelconst INT) :base_core {
  if (string_compare(interpreter, $1, $2) <= 0) {
    goto OFFSET($3);
  }
  goto NEXT();
}

op le(in PMC, in PMC, labelconst INT) :base_core {
  if (mmd_dispatch_i_pp(interpreter, $1, $2, MMD_CMP) <= 0) {
    goto OFFSET($3);
  }
  goto NEXT();
}

op le(in PMC, in INT, labelconst INT) :base_core {
  if ($1->vtable->get_integer(interpreter, $1) <= $2) {
    goto OFFSET($3);
  }
  goto NEXT();
}

op le (in PMC, in NUM, labelconst INT) :base_core {
  if ($1->vtable->get_number(interpreter, $1) <= $2) {
    goto OFFSET($3);
  }
  goto NEXT();
}

op le (in PMC, in STR, labelconst INT) :base_core {
  if (string_compare(interpreter,
      $1->vtable->get_string(interpreter, $1), $2) <= 0) {
    goto OFFSET($3);
  }
  goto NEXT();
}

op le_str (in PMC, in PMC, labelconst INT) :base_core {
  if (mmd_dispatch_i_pp(interpreter, $1, $2, MMD_STRCMP) <= 0) {
    goto OFFSET($3);
  }
  goto NEXT();
}

op le_num (in PMC, in PMC, labelconst INT) :base_core {
  if (mmd_dispatch_i_pp(interpreter, $1, $2, MMD_NUMCMP) <= 0) {
    goto OFFSET($3);
  }
  goto NEXT();
}

########################################

=item B<gt>(in PMC, in PMC, labelconst INT)

=item B<gt>(in PMC, in INT, labelconst INT)

=item B<gt>(in PMC, in NUM, labelconst INT)

=item B<gt>(in PMC, in STR, labelconst INT)

=item B<gt_str>(in PMC, in PMC, labelconst INT)

=item B<gt_num>(in PMC, in PMC, labelconst INT)

Branch if $1 is greater than $2.

=cut

op gt(in PMC, in PMC, labelconst INT) :base_core {
  if (mmd_dispatch_i_pp(interpreter, $1, $2, MMD_CMP) > 0) {
    goto OFFSET($3);
  }
  goto NEXT();
}

op gt(in PMC, in INT, labelconst INT) :base_core {
  if ($1->vtable->get_integer(interpreter, $1) > $2) {
    goto OFFSET($3);
  }
  goto NEXT();
}

op gt (in PMC, in NUM, labelconst INT) :base_core {
  if ($1->vtable->get_number(interpreter, $1) > $2) {
    goto OFFSET($3);
  }
  goto NEXT();
}

op gt (in PMC, in STR, labelconst INT) :base_core {
  if (string_compare(interpreter,
      $1->vtable->get_string(interpreter, $1), $2) > 0) {
    goto OFFSET($3);
  }
  goto NEXT();
}

op gt_str (in PMC, in PMC, labelconst INT) :base_core {
  if (mmd_dispatch_i_pp(interpreter, $1, $2, MMD_STRCMP) > 0) {
    goto OFFSET($3);
  }
  goto NEXT();
}

op gt_num (in PMC, in PMC, labelconst INT) :base_core {
  if (mmd_dispatch_i_pp(interpreter, $1, $2, MMD_NUMCMP) > 0) {
    goto OFFSET($3);
  }
  goto NEXT();
}

########################################

=item B<ge>(in PMC, in PMC, labelconst INT)

=item B<ge>(in PMC, in INT, labelconst INT)

=item B<ge>(in PMC, in NUM, labelconst INT)

=item B<ge>(in PMC, in STR, labelconst INT)

=item B<ge_str>(in PMC, in PMC, labelconst INT)

=item B<ge_num>(in PMC, in PMC, labelconst INT)

Branch if $1 is greater than or equal to $2.

=cut

op ge(in PMC, in PMC, labelconst INT) :base_core {
  if (mmd_dispatch_i_pp(interpreter, $1, $2, MMD_CMP) >= 0) {
    goto OFFSET($3);
  }
  goto NEXT();
}

op ge(in PMC, in INT, labelconst INT) :base_core {
  if ($1->vtable->get_integer(interpreter, $1) >= $2) {
    goto OFFSET($3);
  }
  goto NEXT();
}

op ge (in PMC, in NUM, labelconst INT) :base_core {
  if ($1->vtable->get_number(interpreter, $1) >= $2) {
    goto OFFSET($3);
  }
  goto NEXT();
}

op ge (in PMC, in STR, labelconst INT) :base_core {
  if (string_compare(interpreter,
      $1->vtable->get_string(interpreter, $1), $2) >= 0) {
    goto OFFSET($3);
  }
  goto NEXT();
}

op ge_str (in PMC, in PMC, labelconst INT) :base_core {
  if (mmd_dispatch_i_pp(interpreter, $1, $2, MMD_STRCMP) >= 0) {
    goto OFFSET($3);
  }
  goto NEXT();
}

op ge_num (in PMC, in PMC, labelconst INT) :base_core {
  if (mmd_dispatch_i_pp(interpreter, $1, $2, MMD_NUMCMP) >= 0) {
    goto OFFSET($3);
  }
  goto NEXT();
}

=back

=cut

###############################################################################

=head2 Flow control comparison operators

These operators branch based on the relationship between
their operands.

=over 4

=cut

########################################

=item B<cmp>(out INT, in INT, in INT)

=item B<cmp>(out INT, in NUM, in NUM)

=item B<cmp>(out INT, in STR, in STR)

=item B<cmp>(out INT, in PMC, in PMC)

=item B<cmp>(out INT, in PMC, in INT)

=item B<cmp>(out INT, in PMC, in NUM)

=item B<cmp>(out INT, in PMC, in STR)

=item B<cmp_str>(out INT, in PMC, in PMC)

=item B<cmp_num>(out INT, in PMC, in PMC)


Sets $1 to -1 if $2 < $3, +1 if $2 > $3, and 0 otherwise.

=cut

inline op cmp(out INT, in INT, in INT) :base_core {
  $1 = $2 < $3 ? -1 :
       $2 > $3 ? +1 :
       0;
  goto NEXT();
}

inline op cmp(out INT, in NUM, in NUM) :base_core {
  $1 = $2 < $3 ? -1 :
       $2 > $3 ? +1 :
       0;
  goto NEXT();
}

inline op cmp(out INT, in STR, in STR) :base_core {
  $1 = string_compare(interpreter, $2, $3);
  goto NEXT();
}

inline op cmp(out INT, in PMC, in PMC) :base_core {
  $1 = mmd_dispatch_i_pp(interpreter, $2, $3, MMD_CMP);
  goto NEXT();
}

inline op cmp(out INT, in PMC, in INT) :base_core {
  INTVAL l = VTABLE_get_integer(interpreter, $2);
  $1 = l < $3 ? -1 :
       l > $3 ? +1 :
       0;
  goto NEXT();
}

inline op cmp(out INT, in PMC, in NUM) :base_core {
  FLOATVAL l = VTABLE_get_number(interpreter, $2);
  $1 = l < $3 ? -1 :
       l > $3 ? +1 :
       0;
  goto NEXT();
}

inline op cmp(out INT, in PMC, in STR) :base_core {
  STRING* l = VTABLE_get_string(interpreter, $2);
  $1 = string_compare(interpreter, l, $3);
  goto NEXT();
}

inline op cmp_str(out INT, in PMC, in PMC) :base_core {
  $1 = mmd_dispatch_i_pp(interpreter, $2, $3, MMD_STRCMP);
  goto NEXT();
}

inline op cmp_num(out INT, in PMC, in PMC) :base_core {
  $1 = mmd_dispatch_i_pp(interpreter, $2, $3, MMD_NUMCMP);
  goto NEXT();
}

=back

=cut

###############################################################################

=head2 Logical operations

These operations apply logical functions to their arguments.

=over 4

=cut

########################################

=item B<and>(out INT, in INT, in INT)

Short-circuiting logical and.  Returns $2 if it's false, else returns $3.

=cut

inline op and(out INT, in INT, in INT) :base_core {
  $1 = $2 ? $3 : $2;
  goto NEXT();
}

########################################

=item B<not>(inout 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>(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) :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();
}

########################################

=item B<or>(out INT, in INT, in INT)

Short-circuiting logical or.  Returns $2 if it's true, else returns $3.

=cut

inline op or(out INT, in INT, in INT) :base_core {
  $1 = $2 ? $2 : $3;
  goto NEXT();
}

########################################

=item B<xor>(out INT, in INT, in INT)

Logical xor.  Returns $2 if it's true and $3 isn't,
returns $3 if it's true and $2 isn't, else returns false.

=cut

inline op xor(out INT, in INT, in INT) :base_core {
  $1 = ($2 && ! $3) ? $2 : ($3 && ! $2) ? $3 : 0;
  goto NEXT();
}

=back

=cut


###############################################################################

=head2 Non-flow control comparison ops

These ops do comparisons and truth testing without doing flow control.

=over 4

=cut

########################################

=item B<issame>(out INT, in PMC, in PMC)

=item B<issame>(out INT, in STR, in STR)

Sets $1 to 1 or 0, depending on the identity of the 2 objects.
The identity is the PMCs memory address.

=item B<isntsame>(out INT, in PMC, in PMC)

=item B<isntsame>(out INT, in STR, in STR)

Sets $1 to 0 or 1, depending on the identity of the 2 objects.

=item B<istrue>(out INT, in PMC)

Sets $1 to 1 or 0, depending on whether $2 is true or not.

=item B<isfalse>(out INT, in PMC)

Sets $1 to 1 or 0, depending on whether $2 is false or not.

=cut

inline op issame(out INT, in PMC, in PMC) {
    if ($2 == $3)
        $1 = 1;
    else
        $1 = VTABLE_is_same(interpreter, $2, $3);
    goto NEXT();
}

inline op issame(out INT, in STR, in STR) {
    $1 = $2 == $3;
    goto NEXT();
}

inline op isntsame(out INT, in PMC, in PMC) {
    if ($2 == $3)
        $1 = 0;
    else
        $1 = !VTABLE_is_same(interpreter, $2, $3);
    goto NEXT();
}

inline op isntsame(out INT, in STR, in STR) {
    $1 = $2 != $3;
    goto NEXT();
}

inline op istrue(out INT, in PMC) {
    $1 = VTABLE_get_bool(interpreter, $2);
    goto NEXT();
}

inline op isfalse(out INT, in PMC) {
    $1 = !VTABLE_get_bool(interpreter, $2);
    goto NEXT();
}

=item B<isgt>(out INT, in INT, in INT)

=item B<isgt>(out INT, in NUM, in NUM)

=item B<isgt>(out INT, in STR, in STR)

These 3 opcodes are valid, but create as their reverse.

=item B<isgt>(out INT, in PMC, in PMC)

Sets $1 to 1 if $2 is greater than $3.

=cut

inline op isgt(out INT, in PMC, in PMC) {
  $1 = (mmd_dispatch_i_pp(interpreter, $2, $3, MMD_CMP) > 0);
  goto NEXT();
}

=item B<isge>(out INT, in INT, in INT)

=item B<isge>(out INT, in NUM, in NUM)

=item B<isge>(out INT, in STR, in STR)

These 3 opcodes are valid, but create as their reverse.

=item B<isge>(out INT, in PMC, in PMC)

Sets $1 to 1 if $2 is greater than or equal to $3.

=cut

inline op isge(out INT, in PMC, in PMC) {
  $1 = (mmd_dispatch_i_pp(interpreter, $2, $3, MMD_CMP) >= 0);
  goto NEXT();
}

=item B<isle>(out INT, in INT, in INT)

=item B<isle>(out INT, in NUM, in NUM)

=item B<isle>(out INT, in STR, in STR)

=item B<isle>(out INT, in PMC, in PMC)

Sets $1 to 1 if $2 is less than or equal to $3.

=cut

inline op isle(out INT, in INT, in INT) {
  $1 = $2 <= $3;
  goto NEXT();
}

inline op isle(out INT, in NUM, in NUM) {
  $1 = $2 <= $3;
  goto NEXT();
}

inline op isle(out INT, in STR, in STR) {
  $1 = string_compare(interpreter, $2, $3) <= 0;
  goto NEXT();
}

inline op isle(out INT, in PMC, in PMC) {
  $1 = (mmd_dispatch_i_pp(interpreter, $2, $3, MMD_CMP) <= 0);
  goto NEXT();
}

=item B<islt>(out INT, in INT, in INT)

=item B<islt>(out INT, in NUM, in NUM)

=item B<islt>(out INT, in STR, in STR)

=item B<islt>(out INT, in PMC, in PMC)

Sets $1 to 1 if $2 is less than $3.

=cut

inline op islt(out INT, in INT, in INT) {
  $1 = ($2 < $3) ? 1 : 0;
  goto NEXT();
}

inline op islt(out INT, in NUM, in NUM) {
  $1 = $2 < $3;
  goto NEXT();
}

inline op islt(out INT, in STR, in STR) {
  $1 = string_compare(interpreter, $2, $3) < 0;
  goto NEXT();
}

inline op islt(out INT, in PMC, in PMC) {
  $1 = (mmd_dispatch_i_pp(interpreter, $2, $3, MMD_CMP) < 0);
  goto NEXT();
}

=item B<iseq>(out INT, in INT, in INT)

=item B<iseq>(out INT, in NUM, in NUM)

=item B<iseq>(out INT, in STR, in STR)

=item B<iseq>(out INT, in PMC, in PMC)

Sets $1 to 1 if $2 is equal to $3.

=cut

inline op iseq(out INT, in INT, in INT) {
  $1 = ($2 == $3) ? 1 : 0;
  goto NEXT();
}

inline op iseq(out INT, in NUM, in NUM) {
  $1 = $2 == $3;
  goto NEXT();
}

inline op iseq(out INT, in STR, in STR) {
  $1 = string_equal(interpreter, $2, $3) == 0;
  goto NEXT();
}

inline op iseq(out INT, in PMC, in PMC) {
  if (&$2 == &$3)
    $1 = 1;
  else
    $1 = mmd_dispatch_i_pp(interpreter, $2, $3, MMD_EQ);
  goto NEXT();
}

=item B<isne>(out INT, in INT, in INT)

=item B<isne>(out INT, in NUM, in NUM)

=item B<isne>(out INT, in STR, in STR)

=item B<isne>(out INT, in PMC, in PMC)

Sets $1 to 1 if $2 is not equal to $3.

=cut

inline op isne(out INT, in INT, in INT) {
  $1 = ($2 == $3) ? 0 : 1;
  goto NEXT();
}

inline op isne(out INT, in NUM, in NUM) {
  $1 = $2 != $3;
  goto NEXT();
}

inline op isne(out INT, in STR, in STR) {
  $1 = string_equal(interpreter, $2, $3) != 0;
  goto NEXT();
}

inline op isne(out INT, in PMC, in PMC) {
  if (&$2 == &$3)
    $1 = 0;
  else
    $1 = !mmd_dispatch_i_pp(interpreter, $2, $3, MMD_EQ);
  goto NEXT();
}

########################################

=item B<if_null>(in PMC, labelconst INT)

Branch to $2 if $1 is a NULL PMC.

=item B<if_null>(invar STR, labelconst INT)

Branch to $2 if $1 is a NULL STRING.

=cut

op if_null(in PMC, labelconst INT) {
  if (PMC_IS_NULL($1)) {
    goto OFFSET($2);
  }
  goto NEXT();
}

op if_null(invar STR, labelconst INT) {
  if (!$1) {
    goto OFFSET($2);
  }
  goto NEXT();
}

########################################

=item B<unless_null>(in PMC, labelconst INT)

Branch to $2 if $1 is I<not> a NULL PMC.

=item B<unless_null>(invar STR, labelconst INT)

Branch to $2 if $1 is I<not> a NULL STRING.

=cut

op unless_null(in PMC, labelconst INT) {
  if (!PMC_IS_NULL($1)) {
    goto OFFSET($2);
  }
  goto NEXT();
}

op unless_null(invar STR, labelconst INT) {
  if ($1) {
    goto OFFSET($2);
  }
  goto NEXT();
}

=back

=cut

###############################################################################

=head1 COPYRIGHT

Copyright (C) 2001-2004 The Perl Foundation.  All rights reserved.

=head1 LICENSE

This program is free software. It is subject to the same license
as the Parrot interpreter itself.

=cut