Eliminate CONDOPs

	Message-ID: <14193.25034.113373.245377@alias-2.pr.mcs.net>

p4raw-id: //depot/perl@3637

20 files changed, 333 insertions, 443 deletions

diff --git a/bytecode.pl b/bytecode.pl
index 4d318ff4fa..dfd16aa249 100644
--- a/bytecode.pl
+++ b/bytecode.pl
@@ -9,7 +9,7 @@ my %alias_to = (
     U8 => [qw(char)],
 );
 
-my @optype= qw(OP UNOP BINOP LOGOP CONDOP LISTOP PMOP SVOP GVOP PVOP LOOP COP);
+my @optype= qw(OP UNOP BINOP LOGOP LISTOP PMOP SVOP GVOP PVOP LOOP COP);
 
 # Nullsv *must* come first in the following so that the condition
 # ($$sv == 0) can continue to be used to test (sv == Nullsv).
@@ -383,8 +383,6 @@ op_private	PL_op->op_private			U8
 op_first	cUNOP->op_first				opindex
 op_last		cBINOP->op_last				opindex
 op_other	cLOGOP->op_other			opindex
-op_true		cCONDOP->op_true			opindex
-op_false	cCONDOP->op_false			opindex
 op_children	cLISTOP->op_children			U32
 op_pmreplroot	cPMOP->op_pmreplroot			opindex
 op_pmreplrootgv	*(SV**)&cPMOP->op_pmreplroot		svindex
diff --git a/dump.c b/dump.c
index 12d318d5f1..450ab86a3c 100644
--- a/dump.c
+++ b/dump.c
@@ -544,17 +544,7 @@ Perl_do_op_dump(pTHX_ I32 level, PerlIO *file, OP *o)
 	    PerlIO_printf(file, "DONE\n");
 	break;
     case OP_COND_EXPR:
-	Perl_dump_indent(aTHX_ level, file, "TRUE ===> ");
-	if (cCONDOPo->op_true)
-	    PerlIO_printf(file, "%d\n", cCONDOPo->op_true->op_seq);
-	else
-	    PerlIO_printf(file, "DONE\n");
-	Perl_dump_indent(aTHX_ level, file, "FALSE ===> ");
-	if (cCONDOPo->op_false)
-	    PerlIO_printf(file, "%d\n", cCONDOPo->op_false->op_seq);
-	else
-	    PerlIO_printf(file, "DONE\n");
-	break;
+    case OP_RANGE:
     case OP_MAPWHILE:
     case OP_GREPWHILE:
     case OP_OR:
diff --git a/ext/B/B.pm b/ext/B/B.pm
index cdbd3b297e..b39659d1c9 100644
--- a/ext/B/B.pm
+++ b/ext/B/B.pm
@@ -38,7 +38,6 @@ use strict;
 @B::UNOP::ISA = 'B::OP';
 @B::BINOP::ISA = 'B::UNOP';
 @B::LOGOP::ISA = 'B::UNOP';
-@B::CONDOP::ISA = 'B::UNOP';
 @B::LISTOP::ISA = 'B::BINOP';
 @B::SVOP::ISA = 'B::OP';
 @B::GVOP::ISA = 'B::OP';
@@ -132,7 +131,9 @@ sub walkoptree_exec {
 	savesym($op, sprintf("%s (0x%lx)", class($op), $$op));
 	$op->$method($level);
 	$ppname = $op->ppaddr;
-	if ($ppname =~ /^pp_(or|and|mapwhile|grepwhile|entertry)$/) {
+	if ($ppname =~
+	    /^pp_(or|and|mapwhile|grepwhile|entertry|range|cond_expr)$/)
+	{
 	    print $prefix, uc($1), " => {\n";
 	    walkoptree_exec($op->other, $method, $level + 1);
 	    print $prefix, "}\n";
@@ -148,19 +149,6 @@ sub walkoptree_exec {
 	    walkoptree_exec($op->other->pmreplstart, $method, $level + 1);
 	    print $prefix, "}\n";
 	    $op = $op->other;
-	} elsif ($ppname eq "pp_cond_expr") {
-	    # pp_cond_expr never returns op_next
-	    print $prefix, "TRUE => {\n";
-	    walkoptree_exec($op->true, $method, $level + 1);
-	    print $prefix, "}\n";
-	    $op = $op->false;
-	    redo;
-	} elsif ($ppname eq "pp_range") {
-	    print $prefix, "TRUE => {\n";
-	    walkoptree_exec($op->true, $method, $level + 1);
-	    print $prefix, "}\n", $prefix, "FALSE => {\n";
-	    walkoptree_exec($op->false, $method, $level + 1);
-	    print $prefix, "}\n";
 	} elsif ($ppname eq "pp_enterloop") {
 	    print $prefix, "REDO => {\n";
 	    walkoptree_exec($op->redoop, $method, $level + 1);
@@ -555,7 +543,7 @@ C<REFCNT> (corresponding to the C function C<SvREFCNT>).
 
 =head2 OP-RELATED CLASSES
 
-B::OP, B::UNOP, B::BINOP, B::LOGOP, B::CONDOP, B::LISTOP, B::PMOP,
+B::OP, B::UNOP, B::BINOP, B::LOGOP, B::LISTOP, B::PMOP,
 B::SVOP, B::GVOP, B::PVOP, B::CVOP, B::LOOP, B::COP.
 These classes correspond in
 the obvious way to the underlying C structures of similar names. The
@@ -616,16 +604,6 @@ This returns the op description from the global C PL_op_desc array
 
 =back
 
-=head2 B::CONDOP METHODS
-
-=over 4
-
-=item true
-
-=item false
-
-=back
-
 =head2 B::LISTOP METHOD
 
 =over 4
diff --git a/ext/B/B.xs b/ext/B/B.xs
index 1777b21254..79610c373e 100644
--- a/ext/B/B.xs
+++ b/ext/B/B.xs
@@ -52,15 +52,14 @@ typedef enum {
     OPc_UNOP,	/* 2 */
     OPc_BINOP,	/* 3 */
     OPc_LOGOP,	/* 4 */
-    OPc_CONDOP,	/* 5 */
-    OPc_LISTOP,	/* 6 */
-    OPc_PMOP,	/* 7 */
-    OPc_SVOP,	/* 8 */
-    OPc_GVOP,	/* 9 */
-    OPc_PVOP,	/* 10 */
-    OPc_CVOP,	/* 11 */
-    OPc_LOOP,	/* 12 */
-    OPc_COP	/* 13 */
+    OPc_LISTOP,	/* 5 */
+    OPc_PMOP,	/* 6 */
+    OPc_SVOP,	/* 7 */
+    OPc_GVOP,	/* 8 */
+    OPc_PVOP,	/* 9 */
+    OPc_CVOP,	/* 10 */
+    OPc_LOOP,	/* 11 */
+    OPc_COP	/* 12 */
 } opclass;
 
 static char *opclassnames[] = {
@@ -69,7 +68,6 @@ static char *opclassnames[] = {
     "B::UNOP",
     "B::BINOP",
     "B::LOGOP",
-    "B::CONDOP",
     "B::LISTOP",
     "B::PMOP",
     "B::SVOP",
@@ -109,9 +107,6 @@ cc_opclass(pTHX_ OP *o)
     case OA_LOGOP:
 	return OPc_LOGOP;
 
-    case OA_CONDOP:
-	return OPc_CONDOP;
-
     case OA_LISTOP:
 	return OPc_LISTOP;
 
@@ -346,7 +341,6 @@ typedef OP	*B__OP;
 typedef UNOP	*B__UNOP;
 typedef BINOP	*B__BINOP;
 typedef LOGOP	*B__LOGOP;
-typedef CONDOP	*B__CONDOP;
 typedef LISTOP	*B__LISTOP;
 typedef PMOP	*B__PMOP;
 typedef SVOP	*B__SVOP;
@@ -616,19 +610,6 @@ B::OP
 LOGOP_other(o)
 	B::LOGOP	o
 
-#define CONDOP_true(o)	o->op_true
-#define CONDOP_false(o)	o->op_false
-
-MODULE = B	PACKAGE = B::CONDOP		PREFIX = CONDOP_
-
-B::OP
-CONDOP_true(o)
-	B::CONDOP	o
-
-B::OP
-CONDOP_false(o)
-	B::CONDOP	o
-
 #define LISTOP_children(o)	o->op_children
 
 MODULE = B	PACKAGE = B::LISTOP		PREFIX = LISTOP_
diff --git a/ext/B/B/Bblock.pm b/ext/B/B/Bblock.pm
index df2a64214e..ae47cf9e04 100644
--- a/ext/B/B/Bblock.pm
+++ b/ext/B/B/Bblock.pm
@@ -99,14 +99,6 @@ sub B::LOGOP::mark_if_leader {
     }
 }
 
-sub B::CONDOP::mark_if_leader {
-    my $op = shift;
-    mark_leader($op->next);
-    mark_leader($op->true);
-    mark_leader($op->false);
-}
-
-
 sub B::LISTOP::mark_if_leader {
     my $op = shift;
     my $first=$op->first;
@@ -158,7 +150,6 @@ sub compile {
 #     The ops pointed at by nextop, redoop and lastop->op_next of a LOOP
 #     The ops pointed at by op_next and op_other of a LOGOP, except
 #     for pp_entertry which has op_next and op_other->op_next
-#     The ops pointed at by op_true and op_false of a CONDOP
 #     The op pointed at by op_pmreplstart of a PMOP
 #     The op pointed at by op_other->op_pmreplstart of pp_substcont?
 #     [The op after a pp_return] Omit
diff --git a/ext/B/B/Bytecode.pm b/ext/B/B/Bytecode.pm
index 42b91998b0..1bf436871b 100644
--- a/ext/B/B/Bytecode.pm
+++ b/ext/B/B/Bytecode.pm
@@ -260,14 +260,6 @@ sub B::BINOP::bytecode {
     }
 }
 
-sub B::CONDOP::bytecode {
-    my $op = shift;
-    my $trueix = $op->true->objix;
-    my $falseix = $op->false->objix;
-    $op->B::UNOP::bytecode;
-    print "op_true $trueix\nop_false $falseix\n";
-}
-
 sub B::LISTOP::bytecode {
     my $op = shift;
     my $children = $op->children;
diff --git a/ext/B/B/C.pm b/ext/B/B/C.pm
index 0385452ffc..3f8260e7ab 100644
--- a/ext/B/B/C.pm
+++ b/ext/B/B/C.pm
@@ -233,18 +233,6 @@ sub B::LOGOP::save {
     savesym($op, sprintf("(OP*)&logop_list[%d]", $logopsect->index));
 }
 
-sub B::CONDOP::save {
-    my ($op, $level) = @_;
-    my $sym = objsym($op);
-    return $sym if defined $sym;
-    $condopsect->add(sprintf("s\\_%x, s\\_%x, %s, %u, %u, %u, 0x%x, 0x%x, s\\_%x, s\\_%x, s\\_%x",
-			     ${$op->next}, ${$op->sibling}, $op->ppaddr,
-			     $op->targ, $op->type, $op_seq, $op->flags,
-			     $op->private, ${$op->first}, ${$op->true},
-			     ${$op->false}));
-    savesym($op, sprintf("(OP*)&condop_list[%d]", $condopsect->index));
-}
-
 sub B::LOOP::save {
     my ($op, $level) = @_;
     my $sym = objsym($op);
diff --git a/ext/B/B/CC.pm b/ext/B/B/CC.pm
index b909d44851..98c9318055 100644
--- a/ext/B/B/CC.pm
+++ b/ext/B/B/CC.pm
@@ -524,13 +524,13 @@ sub pp_or {
 	    
 sub pp_cond_expr {
     my $op = shift;
-    my $false = $op->false;
+    my $false = $op->next;
     unshift(@bblock_todo, $false);
     reload_lexicals();
     my $bool = pop_bool();
     write_back_stack();
     runtime(sprintf("if (!$bool) goto %s;", label($false)));
-    return $op->true;
+    return $op->other;
 }
 
 sub pp_padsv {
@@ -1238,10 +1238,10 @@ sub pp_range {
 	# it to find and adjust out targ. We don't need it ourselves.
 	$op->save;
 	runtime sprintf("if (SvTRUE(PL_curpad[%d])) goto %s;",
-			$op->targ, label($op->false));
-	unshift(@bblock_todo, $op->false);
+			$op->targ, label($op->other));
+	unshift(@bblock_todo, $op->other);
     }
-    return $op->true;
+    return $op->next;
 }
 
 sub pp_flip {
@@ -1251,7 +1251,7 @@ sub pp_flip {
 	error("context of flip unknown at compile-time");
     }
     if (($flags & OPf_WANT)==OPf_WANT_LIST) {
-	return $op->first->false;
+	return $op->first->other;
     }
     write_back_lexicals();
     write_back_stack();
@@ -1269,7 +1269,7 @@ sub pp_flip {
     } else {
 	runtime("\tsv_setiv(PL_curpad[$ix], 0);",
 		"\tsp--;",
-		sprintf("\tgoto %s;", label($op->first->false)));
+		sprintf("\tgoto %s;", label($op->first->other)));
     }
     runtime("}",
 	  qq{sv_setpv(PL_curpad[$ix], "");},
diff --git a/ext/B/B/Debug.pm b/ext/B/B/Debug.pm
index d10db9cb1a..75636265e6 100644
--- a/ext/B/B/Debug.pm
+++ b/ext/B/B/Debug.pm
@@ -39,13 +39,6 @@ sub B::LOGOP::debug {
     printf "\top_other\t0x%x\n", ${$op->other};
 }
 
-sub B::CONDOP::debug {
-    my ($op) = @_;
-    $op->B::UNOP::debug();
-    printf "\top_true\t0x%x\n", ${$op->true};
-    printf "\top_false\t0x%x\n", ${$op->false};
-}
-
 sub B::LISTOP::debug {
     my ($op) = @_;
     $op->B::BINOP::debug();
diff --git a/ext/B/B/Xref.pm b/ext/B/B/Xref.pm
index 854db71189..16f25ff032 100644
--- a/ext/B/B/Xref.pm
+++ b/ext/B/B/Xref.pm
@@ -154,7 +154,7 @@ sub xref {
 	warn sprintf("top = [%s, %s, %s]\n", @$top) if $debug_top;
 	warn peekop($op), "\n" if $debug_op;
 	my $ppname = $op->ppaddr;
-	if ($ppname =~ /^pp_(or|and|mapwhile|grepwhile)$/) {
+	if ($ppname =~ /^pp_(or|and|mapwhile|grepwhile|range|cond_expr)$/) {
 	    xref($op->other);
 	} elsif ($ppname eq "pp_match" || $ppname eq "pp_subst") {
 	    xref($op->pmreplstart);
@@ -162,11 +162,6 @@ sub xref {
 	    xref($op->other->pmreplstart);
 	    $op = $op->other;
 	    redo;
-	} elsif ($ppname eq "pp_cond_expr") {
-	    # pp_cond_expr never returns op_next
-	    xref($op->true);
-	    $op = $op->false;
-	    redo;
 	} elsif ($ppname eq "pp_enterloop") {
 	    xref($op->redoop);
 	    xref($op->nextop);
diff --git a/ext/B/ramblings/flip-flop b/ext/B/ramblings/flip-flop
index 183d541b98..e0cb8ff620 100644
--- a/ext/B/ramblings/flip-flop
+++ b/ext/B/ramblings/flip-flop
@@ -1,21 +1,24 @@
 PP(pp_range)
 {
     if (GIMME == G_ARRAY)
-        return cCONDOP->op_true;
-    return SvTRUEx(PAD_SV(op->op_targ)) ? cCONDOP->op_false : cCONDOP->op_true;
+        return NORMAL;
+    if (SvTRUEx(PAD_SV(PL_op->op_targ)))
+	return cLOGOP->op_other;
+    else
+	return NORMAL;
 }
 
-pp_range is a CONDOP.
-In array context, it just returns op_true.
+pp_range is a LOGOP.
+In array context, it just returns op_next.
 In scalar context it checks the truth of targ and returns
-op_false if true, op_true if false.
+op_other if true, op_next if false.
 
 flip is an UNOP.
-It "looks after" its child which is always a pp_range CONDOP.
-In array context, it just returns the child's op_false.
+It "looks after" its child which is always a pp_range LOGOP.
+In array context, it just returns the child's op_other.
 In scalar context, there are three possible outcomes:
   (1) set child's targ to 1, our targ to 1 and return op_next.
-  (2) set child's targ to 1, our targ to 0, sp-- and return child's op_false.
+  (2) set child's targ to 1, our targ to 0, sp-- and return child's op_other.
   (3) Blank targ and  TOPs and return op_next.
 Case 1 happens for a "..." with a matching lineno... or true TOPs.
 Case 2 happens for a ".." with a matching lineno... or true TOPs.
@@ -37,14 +40,14 @@ Case 3 happens for a non-matching lineno or false TOPs.
 
 /* range */
 if (SvTRUE(curpad[op->op_targ]))
-    goto label(op_false);
-/* op_true */
+    goto label(op_other);
+/* op_next */
 ...
 /* flip */
-/* For "..." returns op_next. For ".." returns op_next or op_first->op_false */
+/* For "..." returns op_next. For ".." returns op_next or op_first->op_other */
 /* end of basic block */
 goto out;
-label(range op_false):
+label(range op_other):
 ...
 /* flop */
 out:
diff --git a/ext/B/typemap b/ext/B/typemap
index 3531c49fb2..948fdcd977 100644
--- a/ext/B/typemap
+++ b/ext/B/typemap
@@ -4,7 +4,6 @@ B::OP		T_OP_OBJ
 B::UNOP		T_OP_OBJ
 B::BINOP	T_OP_OBJ
 B::LOGOP	T_OP_OBJ
-B::CONDOP	T_OP_OBJ
 B::LISTOP	T_OP_OBJ
 B::PMOP		T_OP_OBJ
 B::SVOP		T_OP_OBJ
diff --git a/op.c b/op.c
index d9e78f7aba..81df30e207 100644
--- a/op.c
+++ b/op.c
@@ -2871,8 +2871,8 @@ S_list_assignment(pTHX_ register OP *o)
 	o = cUNOPo->op_first;
 
     if (o->op_type == OP_COND_EXPR) {
-	I32 t = list_assignment(cCONDOPo->op_first->op_sibling);
-	I32 f = list_assignment(cCONDOPo->op_first->op_sibling->op_sibling);
+	I32 t = list_assignment(cLOGOPo->op_first->op_sibling);
+	I32 f = list_assignment(cLOGOPo->op_first->op_sibling->op_sibling);
 
 	if (t && f)
 	    return TRUE;
@@ -3230,7 +3230,8 @@ OP *
 Perl_newCONDOP(pTHX_ I32 flags, OP *first, OP *trueop, OP *falseop)
 {
     dTHR;
-    CONDOP *condop;
+    LOGOP *logop;
+    OP *start;
     OP *o;
 
     if (!falseop)
@@ -3255,27 +3256,27 @@ Perl_newCONDOP(pTHX_ I32 flags, OP *first, OP *trueop, OP *falseop)
 	list(trueop);
 	scalar(falseop);
     }
-    NewOp(1101, condop, 1, CONDOP);
+    NewOp(1101, logop, 1, LOGOP);
+    logop->op_type = OP_COND_EXPR;
+    logop->op_ppaddr = PL_ppaddr[OP_COND_EXPR];
+    logop->op_first = first;
+    logop->op_flags = flags | OPf_KIDS;
+    logop->op_private = 1 | (flags >> 8);
+    logop->op_other = LINKLIST(trueop);
+    logop->op_next = LINKLIST(falseop);
 
-    condop->op_type = OP_COND_EXPR;
-    condop->op_ppaddr = PL_ppaddr[OP_COND_EXPR];
-    condop->op_first = first;
-    condop->op_flags = flags | OPf_KIDS;
-    condop->op_true = LINKLIST(trueop);
-    condop->op_false = LINKLIST(falseop);
-    condop->op_private = 1 | (flags >> 8);
 
     /* establish postfix order */
-    condop->op_next = LINKLIST(first);
-    first->op_next = (OP*)condop;
+    start = LINKLIST(first);
+    first->op_next = (OP*)logop;
 
     first->op_sibling = trueop;
     trueop->op_sibling = falseop;
-    o = newUNOP(OP_NULL, 0, (OP*)condop);
+    o = newUNOP(OP_NULL, 0, (OP*)logop);
 
-    trueop->op_next = o;
-    falseop->op_next = o;
+    trueop->op_next = falseop->op_next = o;
 
+    o->op_next = start;
     return o;
 }
 
@@ -3283,34 +3284,36 @@ OP *
 Perl_newRANGE(pTHX_ I32 flags, OP *left, OP *right)
 {
     dTHR;
-    CONDOP *condop;
+    LOGOP *range;
     OP *flip;
     OP *flop;
+    OP *leftstart;
     OP *o;
 
-    NewOp(1101, condop, 1, CONDOP);
+    NewOp(1101, range, 1, LOGOP);
 
-    condop->op_type = OP_RANGE;
-    condop->op_ppaddr = PL_ppaddr[OP_RANGE];
-    condop->op_first = left;
-    condop->op_flags = OPf_KIDS;
-    condop->op_true = LINKLIST(left);
-    condop->op_false = LINKLIST(right);
-    condop->op_private = 1 | (flags >> 8);
+    range->op_type = OP_RANGE;
+    range->op_ppaddr = PL_ppaddr[OP_RANGE];
+    range->op_first = left;
+    range->op_flags = OPf_KIDS;
+    leftstart = LINKLIST(left);
+    range->op_other = LINKLIST(right);
+    range->op_private = 1 | (flags >> 8);
 
     left->op_sibling = right;
 
-    condop->op_next = (OP*)condop;
-    flip = newUNOP(OP_FLIP, flags, (OP*)condop);
+    range->op_next = (OP*)range;
+    flip = newUNOP(OP_FLIP, flags, (OP*)range);
     flop = newUNOP(OP_FLOP, 0, flip);
     o = newUNOP(OP_NULL, 0, flop);
     linklist(flop);
+    range->op_next = leftstart;
 
     left->op_next = flip;
     right->op_next = flop;
 
-    condop->op_targ = pad_alloc(OP_RANGE, SVs_PADMY);
-    sv_upgrade(PAD_SV(condop->op_targ), SVt_PVNV);
+    range->op_targ = pad_alloc(OP_RANGE, SVs_PADMY);
+    sv_upgrade(PAD_SV(range->op_targ), SVt_PVNV);
     flip->op_targ = pad_alloc(OP_RANGE, SVs_PADMY);
     sv_upgrade(PAD_SV(flip->op_targ), SVt_PVNV);
 
@@ -3520,7 +3523,7 @@ Perl_newFOROP(pTHX_ I32 flags,char *label,line_t forline,OP *sv,OP *expr,OP *blo
 	 * treated as min/max values by 'pp_iterinit'.
 	 */
 	UNOP* flip = (UNOP*)((UNOP*)((BINOP*)expr)->op_first)->op_first;
-	CONDOP* range = (CONDOP*) flip->op_first;
+	LOGOP* range = (LOGOP*) flip->op_first;
 	OP* left  = range->op_first;
 	OP* right = left->op_sibling;
 	LISTOP* listop;
@@ -3529,8 +3532,8 @@ Perl_newFOROP(pTHX_ I32 flags,char *label,line_t forline,OP *sv,OP *expr,OP *blo
 	range->op_first = Nullop;
 
 	listop = (LISTOP*)newLISTOP(OP_LIST, 0, left, right);
-	listop->op_first->op_next = range->op_true;
-	left->op_next = range->op_false;
+	listop->op_first->op_next = range->op_next;
+	left->op_next = range->op_other;
 	right->op_next = (OP*)listop;
 	listop->op_next = listop->op_first;
 
@@ -5728,18 +5731,14 @@ Perl_peep(pTHX_ register OP *o)
 	case OP_GREPWHILE:
 	case OP_AND:
 	case OP_OR:
+	case OP_COND_EXPR:
+	case OP_RANGE:
 	    o->op_seq = PL_op_seqmax++;
 	    while (cLOGOP->op_other->op_type == OP_NULL)
 		cLOGOP->op_other = cLOGOP->op_other->op_next;
 	    peep(cLOGOP->op_other);
 	    break;
 
-	case OP_COND_EXPR:
-	    o->op_seq = PL_op_seqmax++;
-	    peep(cCONDOP->op_true);
-	    peep(cCONDOP->op_false);
-	    break;
-
 	case OP_ENTERLOOP:
 	    o->op_seq = PL_op_seqmax++;
 	    peep(cLOOP->op_redoop);
diff --git a/op.h b/op.h
index 8c6f336ca2..4de46478d3 100644
--- a/op.h
+++ b/op.h
@@ -182,13 +182,6 @@ struct logop {
     OP *	op_other;
 };
 
-struct condop {
-    BASEOP
-    OP *	op_first;
-    OP *	op_true;
-    OP *	op_false;
-};
-
 struct listop {
     BASEOP
     OP *	op_first;
@@ -262,7 +255,6 @@ struct loop {
 #define cBINOP ((BINOP*)PL_op)
 #define cLISTOP ((LISTOP*)PL_op)
 #define cLOGOP ((LOGOP*)PL_op)
-#define cCONDOP ((CONDOP*)PL_op)
 #define cPMOP ((PMOP*)PL_op)
 #define cSVOP ((SVOP*)PL_op)
 #define cGVOP ((GVOP*)PL_op)
@@ -274,7 +266,6 @@ struct loop {
 #define cBINOPo ((BINOP*)o)
 #define cLISTOPo ((LISTOP*)o)
 #define cLOGOPo ((LOGOP*)o)
-#define cCONDOPo ((CONDOP*)o)
 #define cPMOPo ((PMOP*)o)
 #define cSVOPo ((SVOP*)o)
 #define cGVOPo ((GVOP*)o)
@@ -287,7 +278,6 @@ struct loop {
 #define kBINOP ((BINOP*)kid)
 #define kLISTOP ((LISTOP*)kid)
 #define kLOGOP ((LOGOP*)kid)
-#define kCONDOP ((CONDOP*)kid)
 #define kPMOP ((PMOP*)kid)
 #define kSVOP ((SVOP*)kid)
 #define kGVOP ((GVOP*)kid)
@@ -317,17 +307,16 @@ struct loop {
 #define OA_UNOP (1 << OCSHIFT)
 #define OA_BINOP (2 << OCSHIFT)
 #define OA_LOGOP (3 << OCSHIFT)
-#define OA_CONDOP (4 << OCSHIFT)
-#define OA_LISTOP (5 << OCSHIFT)
-#define OA_PMOP (6 << OCSHIFT)
-#define OA_SVOP (7 << OCSHIFT)
-#define OA_GVOP (8 << OCSHIFT)
-#define OA_PVOP_OR_SVOP (9 << OCSHIFT)
-#define OA_LOOP (10 << OCSHIFT)
-#define OA_COP (11 << OCSHIFT)
-#define OA_BASEOP_OR_UNOP (12 << OCSHIFT)
-#define OA_FILESTATOP (13 << OCSHIFT)
-#define OA_LOOPEXOP (14 << OCSHIFT)
+#define OA_LISTOP (4 << OCSHIFT)
+#define OA_PMOP (5 << OCSHIFT)
+#define OA_SVOP (6 << OCSHIFT)
+#define OA_GVOP (7 << OCSHIFT)
+#define OA_PVOP_OR_SVOP (8 << OCSHIFT)
+#define OA_LOOP (9 << OCSHIFT)
+#define OA_COP (10 << OCSHIFT)
+#define OA_BASEOP_OR_UNOP (11 << OCSHIFT)
+#define OA_FILESTATOP (12 << OCSHIFT)
+#define OA_LOOPEXOP (13 << OCSHIFT)
 
 #define OASHIFT 13
 
diff --git a/opcode.h b/opcode.h
index 5f4acf5517..ab279becb2 100644
--- a/opcode.h
+++ b/opcode.h
@@ -1796,50 +1796,50 @@ EXT U32 PL_opargs[];
 EXT U32 PL_opargs[] = {
 	0x00000000,	/* null */
 	0x00000000,	/* stub */
-	0x00003804,	/* scalar */
+	0x00003604,	/* scalar */
 	0x00000004,	/* pushmark */
 	0x00000014,	/* wantarray */
-	0x00000e04,	/* const */
-	0x00001044,	/* gvsv */
-	0x00001044,	/* gv */
+	0x00000c04,	/* const */
+	0x00000e44,	/* gvsv */
+	0x00000e44,	/* gv */
 	0x00022440,	/* gelem */
 	0x00000044,	/* padsv */
 	0x00000040,	/* padav */
 	0x00000040,	/* padhv */
 	0x00000040,	/* padany */
-	0x00000c40,	/* pushre */
+	0x00000a40,	/* pushre */
 	0x00000244,	/* rv2gv */
 	0x00000244,	/* rv2sv */
 	0x00000214,	/* av2arylen */
 	0x00000240,	/* rv2cv */
-	0x00000e00,	/* anoncode */
-	0x00003804,	/* prototype */
+	0x00000c00,	/* anoncode */
+	0x00003604,	/* prototype */
 	0x00004201,	/* refgen */
 	0x00002206,	/* srefgen */
-	0x0001388c,	/* ref */
-	0x00122a04,	/* bless */
-	0x00001808,	/* backtick */
-	0x00132a08,	/* glob */
-	0x00001808,	/* readline */
-	0x00001808,	/* rcatline */
+	0x0001368c,	/* ref */
+	0x00122804,	/* bless */
+	0x00001608,	/* backtick */
+	0x00132808,	/* glob */
+	0x00001608,	/* readline */
+	0x00001608,	/* rcatline */
 	0x00002204,	/* regcmaybe */
 	0x00002204,	/* regcreset */
 	0x00002604,	/* regcomp */
-	0x00000c40,	/* match */
-	0x00000c04,	/* qr */
-	0x00002c54,	/* subst */
+	0x00000a40,	/* match */
+	0x00000a04,	/* qr */
+	0x00002a54,	/* subst */
 	0x00000654,	/* substcont */
-	0x00003214,	/* trans */
+	0x00003014,	/* trans */
 	0x00000004,	/* sassign */
 	0x00044408,	/* aassign */
-	0x0000590d,	/* chop */
-	0x0001398c,	/* schop */
-	0x0000590d,	/* chomp */
-	0x0001398c,	/* schomp */
-	0x00013894,	/* defined */
-	0x00013804,	/* undef */
-	0x00013884,	/* study */
-	0x0001388c,	/* pos */
+	0x0000570d,	/* chop */
+	0x0001378c,	/* schop */
+	0x0000570d,	/* chomp */
+	0x0001378c,	/* schomp */
+	0x00013694,	/* defined */
+	0x00013604,	/* undef */
+	0x00013684,	/* study */
+	0x0001368c,	/* pos */
 	0x00002264,	/* preinc */
 	0x00002254,	/* i_preinc */
 	0x00002264,	/* predec */
@@ -1861,7 +1861,7 @@ EXT U32 PL_opargs[] = {
 	0x0002252e,	/* subtract */
 	0x0002251e,	/* i_subtract */
 	0x0002250e,	/* concat */
-	0x00002b0e,	/* stringify */
+	0x0000290e,	/* stringify */
 	0x0002250e,	/* left_shift */
 	0x0002250e,	/* right_shift */
 	0x00022436,	/* lt */
@@ -1892,255 +1892,255 @@ EXT U32 PL_opargs[] = {
 	0x0000231e,	/* i_negate */
 	0x00002216,	/* not */
 	0x0000230e,	/* complement */
-	0x00022b0e,	/* atan2 */
-	0x0001398e,	/* sin */
-	0x0001398e,	/* cos */
-	0x0001390c,	/* rand */
-	0x00013804,	/* srand */
-	0x0001398e,	/* exp */
-	0x0001398e,	/* log */
-	0x0001398e,	/* sqrt */
-	0x0001398e,	/* int */
-	0x0001398e,	/* hex */
-	0x0001398e,	/* oct */
-	0x0001398e,	/* abs */
-	0x0001399c,	/* length */
-	0x13222a0c,	/* substr */
-	0x00222a1c,	/* vec */
-	0x01222b1c,	/* index */
-	0x01222b1c,	/* rindex */
-	0x00042b0f,	/* sprintf */
-	0x00042a05,	/* formline */
-	0x0001399e,	/* ord */
-	0x0001398e,	/* chr */
-	0x00022b0e,	/* crypt */
-	0x0001388e,	/* ucfirst */
-	0x0001388e,	/* lcfirst */
-	0x0001388e,	/* uc */
-	0x0001388e,	/* lc */
-	0x0001398e,	/* quotemeta */
+	0x0002290e,	/* atan2 */
+	0x0001378e,	/* sin */
+	0x0001378e,	/* cos */
+	0x0001370c,	/* rand */
+	0x00013604,	/* srand */
+	0x0001378e,	/* exp */
+	0x0001378e,	/* log */
+	0x0001378e,	/* sqrt */
+	0x0001378e,	/* int */
+	0x0001378e,	/* hex */
+	0x0001378e,	/* oct */
+	0x0001378e,	/* abs */
+	0x0001379c,	/* length */
+	0x1322280c,	/* substr */
+	0x0022281c,	/* vec */
+	0x0122291c,	/* index */
+	0x0122291c,	/* rindex */
+	0x0004290f,	/* sprintf */
+	0x00042805,	/* formline */
+	0x0001379e,	/* ord */
+	0x0001378e,	/* chr */
+	0x0002290e,	/* crypt */
+	0x0001368e,	/* ucfirst */
+	0x0001368e,	/* lcfirst */
+	0x0001368e,	/* uc */
+	0x0001368e,	/* lc */
+	0x0001378e,	/* quotemeta */
 	0x00000248,	/* rv2av */
-	0x00027004,	/* aelemfast */
+	0x00026e04,	/* aelemfast */
 	0x00026404,	/* aelem */
-	0x00046a01,	/* aslice */
-	0x00009808,	/* each */
-	0x00009808,	/* values */
-	0x00009808,	/* keys */
-	0x00003800,	/* delete */
-	0x00003814,	/* exists */
+	0x00046801,	/* aslice */
+	0x00009608,	/* each */
+	0x00009608,	/* values */
+	0x00009608,	/* keys */
+	0x00003600,	/* delete */
+	0x00003614,	/* exists */
 	0x00000248,	/* rv2hv */
 	0x00028404,	/* helem */
-	0x00048a01,	/* hslice */
-	0x00022a00,	/* unpack */
-	0x00042a0d,	/* pack */
-	0x00222a08,	/* split */
-	0x00042b0d,	/* join */
-	0x00004a01,	/* list */
+	0x00048801,	/* hslice */
+	0x00022800,	/* unpack */
+	0x0004280d,	/* pack */
+	0x00222808,	/* split */
+	0x0004290d,	/* join */
+	0x00004801,	/* list */
 	0x00448400,	/* lslice */
-	0x00004a05,	/* anonlist */
-	0x00004a05,	/* anonhash */
-	0x05326a01,	/* splice */
-	0x00046b1d,	/* push */
-	0x00007804,	/* pop */
-	0x00007804,	/* shift */
-	0x00046b1d,	/* unshift */
-	0x0005aa01,	/* sort */
-	0x00004a09,	/* reverse */
-	0x0004aa41,	/* grepstart */
+	0x00004805,	/* anonlist */
+	0x00004805,	/* anonhash */
+	0x05326801,	/* splice */
+	0x0004691d,	/* push */
+	0x00007604,	/* pop */
+	0x00007604,	/* shift */
+	0x0004691d,	/* unshift */
+	0x0005a801,	/* sort */
+	0x00004809,	/* reverse */
+	0x0004a841,	/* grepstart */
 	0x00000648,	/* grepwhile */
-	0x0004aa41,	/* mapstart */
+	0x0004a841,	/* mapstart */
 	0x00000648,	/* mapwhile */
-	0x00022800,	/* range */
+	0x00022600,	/* range */
 	0x00022200,	/* flip */
 	0x00000200,	/* flop */
 	0x00000600,	/* and */
 	0x00000600,	/* or */
 	0x00022606,	/* xor */
-	0x00000840,	/* cond_expr */
+	0x00000640,	/* cond_expr */
 	0x00000604,	/* andassign */
 	0x00000604,	/* orassign */
 	0x00000240,	/* method */
 	0x00004249,	/* entersub */
 	0x00000200,	/* leavesub */
-	0x00013808,	/* caller */
-	0x00004a1d,	/* warn */
-	0x00004a5d,	/* die */
-	0x00013814,	/* reset */
-	0x00000a00,	/* lineseq */
-	0x00001604,	/* nextstate */
-	0x00001604,	/* dbstate */
+	0x00013608,	/* caller */
+	0x0000481d,	/* warn */
+	0x0000485d,	/* die */
+	0x00013614,	/* reset */
+	0x00000800,	/* lineseq */
+	0x00001404,	/* nextstate */
+	0x00001404,	/* dbstate */
 	0x00000004,	/* unstack */
 	0x00000000,	/* enter */
-	0x00000a00,	/* leave */
-	0x00000a00,	/* scope */
-	0x00001440,	/* enteriter */
+	0x00000800,	/* leave */
+	0x00000800,	/* scope */
+	0x00001240,	/* enteriter */
 	0x00000000,	/* iter */
-	0x00001440,	/* enterloop */
+	0x00001240,	/* enterloop */
 	0x00000400,	/* leaveloop */
-	0x00004a41,	/* return */
-	0x00001c44,	/* last */
-	0x00001c44,	/* next */
-	0x00001c44,	/* redo */
-	0x00001c44,	/* dump */
-	0x00001c44,	/* goto */
-	0x00013844,	/* exit */
-	0x0012ca1c,	/* open */
-	0x0001d814,	/* close */
-	0x000cca14,	/* pipe_op */
-	0x0000d81c,	/* fileno */
-	0x0001381c,	/* umask */
-	0x0000d804,	/* binmode */
-	0x0042ea55,	/* tie */
-	0x0000f814,	/* untie */
-	0x0000f804,	/* tied */
-	0x00228a14,	/* dbmopen */
-	0x00009814,	/* dbmclose */
-	0x02222a08,	/* sselect */
-	0x0001ca0c,	/* select */
-	0x0001d80c,	/* getc */
-	0x122eca1d,	/* read */
-	0x0001d854,	/* enterwrite */
+	0x00004841,	/* return */
+	0x00001a44,	/* last */
+	0x00001a44,	/* next */
+	0x00001a44,	/* redo */
+	0x00001a44,	/* dump */
+	0x00001a44,	/* goto */
+	0x00013644,	/* exit */
+	0x0012c81c,	/* open */
+	0x0001d614,	/* close */
+	0x000cc814,	/* pipe_op */
+	0x0000d61c,	/* fileno */
+	0x0001361c,	/* umask */
+	0x0000d604,	/* binmode */
+	0x0042e855,	/* tie */
+	0x0000f614,	/* untie */
+	0x0000f604,	/* tied */
+	0x00228814,	/* dbmopen */
+	0x00009614,	/* dbmclose */
+	0x02222808,	/* sselect */
+	0x0001c80c,	/* select */
+	0x0001d60c,	/* getc */
+	0x122ec81d,	/* read */
+	0x0001d654,	/* enterwrite */
 	0x00000200,	/* leavewrite */
-	0x0005ca15,	/* prtf */
-	0x0005ca15,	/* print */
-	0x1222ca04,	/* sysopen */
-	0x0022ca04,	/* sysseek */
-	0x122eca1d,	/* sysread */
-	0x1322ca1d,	/* syswrite */
-	0x1222ca1d,	/* send */
-	0x022eca1d,	/* recv */
-	0x0001d814,	/* eof */
-	0x0001d80c,	/* tell */
-	0x0022ca04,	/* seek */
-	0x00022a14,	/* truncate */
-	0x0022ca0c,	/* fcntl */
-	0x0022ca0c,	/* ioctl */
-	0x0002cb1c,	/* flock */
-	0x0222ca14,	/* socket */
-	0x222cca14,	/* sockpair */
-	0x0002ca14,	/* bind */
-	0x0002ca14,	/* connect */
-	0x0002ca14,	/* listen */
-	0x000cca1c,	/* accept */
-	0x0002ca1c,	/* shutdown */
-	0x0022ca14,	/* gsockopt */
-	0x0222ca14,	/* ssockopt */
-	0x0000d814,	/* getsockname */
-	0x0000d814,	/* getpeername */
-	0x0000da80,	/* lstat */
-	0x0000da80,	/* stat */
-	0x0000da94,	/* ftrread */
-	0x0000da94,	/* ftrwrite */
-	0x0000da94,	/* ftrexec */
-	0x0000da94,	/* fteread */
-	0x0000da94,	/* ftewrite */
-	0x0000da94,	/* fteexec */
-	0x0000da94,	/* ftis */
-	0x0000da94,	/* fteowned */
-	0x0000da94,	/* ftrowned */
-	0x0000da94,	/* ftzero */
-	0x0000da9c,	/* ftsize */
-	0x0000da8c,	/* ftmtime */
-	0x0000da8c,	/* ftatime */
-	0x0000da8c,	/* ftctime */
-	0x0000da94,	/* ftsock */
-	0x0000da94,	/* ftchr */
-	0x0000da94,	/* ftblk */
-	0x0000da94,	/* ftfile */
-	0x0000da94,	/* ftdir */
-	0x0000da94,	/* ftpipe */
-	0x0000da94,	/* ftlink */
-	0x0000da94,	/* ftsuid */
-	0x0000da94,	/* ftsgid */
-	0x0000da94,	/* ftsvtx */
-	0x0000da14,	/* fttty */
-	0x0000da94,	/* fttext */
-	0x0000da94,	/* ftbinary */
-	0x0001391c,	/* chdir */
-	0x00004b1d,	/* chown */
-	0x0001399c,	/* chroot */
-	0x00004b9d,	/* unlink */
-	0x00004b1d,	/* chmod */
-	0x00004b1d,	/* utime */
-	0x00022b1c,	/* rename */
-	0x00022b1c,	/* link */
-	0x00022b1c,	/* symlink */
-	0x0001388c,	/* readlink */
-	0x00022b1c,	/* mkdir */
-	0x0001399c,	/* rmdir */
-	0x0002ca14,	/* open_dir */
-	0x0000d800,	/* readdir */
-	0x0000d80c,	/* telldir */
-	0x0002ca04,	/* seekdir */
-	0x0000d804,	/* rewinddir */
-	0x0000d814,	/* closedir */
+	0x0005c815,	/* prtf */
+	0x0005c815,	/* print */
+	0x1222c804,	/* sysopen */
+	0x0022c804,	/* sysseek */
+	0x122ec81d,	/* sysread */
+	0x1322c81d,	/* syswrite */
+	0x1222c81d,	/* send */
+	0x022ec81d,	/* recv */
+	0x0001d614,	/* eof */
+	0x0001d60c,	/* tell */
+	0x0022c804,	/* seek */
+	0x00022814,	/* truncate */
+	0x0022c80c,	/* fcntl */
+	0x0022c80c,	/* ioctl */
+	0x0002c91c,	/* flock */
+	0x0222c814,	/* socket */
+	0x222cc814,	/* sockpair */
+	0x0002c814,	/* bind */
+	0x0002c814,	/* connect */
+	0x0002c814,	/* listen */
+	0x000cc81c,	/* accept */
+	0x0002c81c,	/* shutdown */
+	0x0022c814,	/* gsockopt */
+	0x0222c814,	/* ssockopt */
+	0x0000d614,	/* getsockname */
+	0x0000d614,	/* getpeername */
+	0x0000d880,	/* lstat */
+	0x0000d880,	/* stat */
+	0x0000d894,	/* ftrread */
+	0x0000d894,	/* ftrwrite */
+	0x0000d894,	/* ftrexec */
+	0x0000d894,	/* fteread */
+	0x0000d894,	/* ftewrite */
+	0x0000d894,	/* fteexec */
+	0x0000d894,	/* ftis */
+	0x0000d894,	/* fteowned */
+	0x0000d894,	/* ftrowned */
+	0x0000d894,	/* ftzero */
+	0x0000d89c,	/* ftsize */
+	0x0000d88c,	/* ftmtime */
+	0x0000d88c,	/* ftatime */
+	0x0000d88c,	/* ftctime */
+	0x0000d894,	/* ftsock */
+	0x0000d894,	/* ftchr */
+	0x0000d894,	/* ftblk */
+	0x0000d894,	/* ftfile */
+	0x0000d894,	/* ftdir */
+	0x0000d894,	/* ftpipe */
+	0x0000d894,	/* ftlink */
+	0x0000d894,	/* ftsuid */
+	0x0000d894,	/* ftsgid */
+	0x0000d894,	/* ftsvtx */
+	0x0000d814,	/* fttty */
+	0x0000d894,	/* fttext */
+	0x0000d894,	/* ftbinary */
+	0x0001371c,	/* chdir */
+	0x0000491d,	/* chown */
+	0x0001379c,	/* chroot */
+	0x0000499d,	/* unlink */
+	0x0000491d,	/* chmod */
+	0x0000491d,	/* utime */
+	0x0002291c,	/* rename */
+	0x0002291c,	/* link */
+	0x0002291c,	/* symlink */
+	0x0001368c,	/* readlink */
+	0x0002291c,	/* mkdir */
+	0x0001379c,	/* rmdir */
+	0x0002c814,	/* open_dir */
+	0x0000d600,	/* readdir */
+	0x0000d60c,	/* telldir */
+	0x0002c804,	/* seekdir */
+	0x0000d604,	/* rewinddir */
+	0x0000d614,	/* closedir */
 	0x0000001c,	/* fork */
 	0x0000011c,	/* wait */
-	0x00022b1c,	/* waitpid */
-	0x00052b1d,	/* system */
-	0x00052b5d,	/* exec */
-	0x00004b5d,	/* kill */
+	0x0002291c,	/* waitpid */
+	0x0005291d,	/* system */
+	0x0005295d,	/* exec */
+	0x0000495d,	/* kill */
 	0x0000011c,	/* getppid */
-	0x0001391c,	/* getpgrp */
-	0x00132b1c,	/* setpgrp */
-	0x00022b1c,	/* getpriority */
-	0x00222b1c,	/* setpriority */
+	0x0001371c,	/* getpgrp */
+	0x0013291c,	/* setpgrp */
+	0x0002291c,	/* getpriority */
+	0x0022291c,	/* setpriority */
 	0x0000011c,	/* time */
 	0x00000000,	/* tms */
-	0x00013808,	/* localtime */
-	0x00013808,	/* gmtime */
-	0x0001389c,	/* alarm */
-	0x0001391c,	/* sleep */
-	0x00222a1d,	/* shmget */
-	0x00222a1d,	/* shmctl */
-	0x02222a1d,	/* shmread */
-	0x02222a1d,	/* shmwrite */
-	0x00022a1d,	/* msgget */
-	0x00222a1d,	/* msgctl */
-	0x00222a1d,	/* msgsnd */
-	0x22222a1d,	/* msgrcv */
-	0x00222a1d,	/* semget */
-	0x02222a1d,	/* semctl */
-	0x00022a1d,	/* semop */
-	0x000138c0,	/* require */
+	0x00013608,	/* localtime */
+	0x00013608,	/* gmtime */
+	0x0001369c,	/* alarm */
+	0x0001371c,	/* sleep */
+	0x0022281d,	/* shmget */
+	0x0022281d,	/* shmctl */
+	0x0222281d,	/* shmread */
+	0x0222281d,	/* shmwrite */
+	0x0002281d,	/* msgget */
+	0x0022281d,	/* msgctl */
+	0x0022281d,	/* msgsnd */
+	0x2222281d,	/* msgrcv */
+	0x0022281d,	/* semget */
+	0x0222281d,	/* semctl */
+	0x0002281d,	/* semop */
+	0x000136c0,	/* require */
 	0x00002240,	/* dofile */
-	0x00003840,	/* entereval */
+	0x00003640,	/* entereval */
 	0x00002200,	/* leaveeval */
 	0x00000600,	/* entertry */
-	0x00000a00,	/* leavetry */
-	0x00003800,	/* ghbyname */
-	0x00022a00,	/* ghbyaddr */
+	0x00000800,	/* leavetry */
+	0x00003600,	/* ghbyname */
+	0x00022800,	/* ghbyaddr */
 	0x00000000,	/* ghostent */
-	0x00003800,	/* gnbyname */
-	0x00022a00,	/* gnbyaddr */
+	0x00003600,	/* gnbyname */
+	0x00022800,	/* gnbyaddr */
 	0x00000000,	/* gnetent */
-	0x00003800,	/* gpbyname */
-	0x00002a00,	/* gpbynumber */
+	0x00003600,	/* gpbyname */
+	0x00002800,	/* gpbynumber */
 	0x00000000,	/* gprotoent */
-	0x00022a00,	/* gsbyname */
-	0x00022a00,	/* gsbyport */
+	0x00022800,	/* gsbyname */
+	0x00022800,	/* gsbyport */
 	0x00000000,	/* gservent */
-	0x00003814,	/* shostent */
-	0x00003814,	/* snetent */
-	0x00003814,	/* sprotoent */
-	0x00003814,	/* sservent */
+	0x00003614,	/* shostent */
+	0x00003614,	/* snetent */
+	0x00003614,	/* sprotoent */
+	0x00003614,	/* sservent */
 	0x00000014,	/* ehostent */
 	0x00000014,	/* enetent */
 	0x00000014,	/* eprotoent */
 	0x00000014,	/* eservent */
-	0x00003800,	/* gpwnam */
-	0x00003800,	/* gpwuid */
+	0x00003600,	/* gpwnam */
+	0x00003600,	/* gpwuid */
 	0x00000000,	/* gpwent */
 	0x00000014,	/* spwent */
 	0x00000014,	/* epwent */
-	0x00003800,	/* ggrnam */
-	0x00003800,	/* ggrgid */
+	0x00003600,	/* ggrnam */
+	0x00003600,	/* ggrgid */
 	0x00000000,	/* ggrent */
 	0x00000014,	/* sgrent */
 	0x00000014,	/* egrent */
 	0x0000000c,	/* getlogin */
-	0x00042a1d,	/* syscall */
-	0x00003804,	/* lock */
+	0x0004281d,	/* syscall */
+	0x00003604,	/* lock */
 	0x00000044,	/* threadsv */
 };
 #endif
diff --git a/opcode.pl b/opcode.pl
index cd0c7ebcb2..56d8342a16 100755
--- a/opcode.pl
+++ b/opcode.pl
@@ -166,17 +166,16 @@ END
     '1',  1,		# unop
     '2',  2,		# binop
     '|',  3,		# logop
-    '?',  4,		# condop
-    '@',  5,		# listop
-    '/',  6,		# pmop
-    '$',  7,		# svop
-    '*',  8,		# gvop
-    '"',  9,		# pvop_or_svop
-    '{',  10,		# loop
-    ';',  11,		# cop
-    '%',  12,		# baseop_or_unop
-    '-',  13,		# filestatop
-    '}',  14,		# loopexop
+    '@',  4,		# listop
+    '/',  5,		# pmop
+    '$',  6,		# svop
+    '*',  7,		# gvop
+    '"',  8,		# pvop_or_svop
+    '{',  9,		# loop
+    ';',  10,		# cop
+    '%',  11,		# baseop_or_unop
+    '-',  12,		# filestatop
+    '}',  13,		# loopexop
 );
 
 for (@ops) {
@@ -521,7 +520,7 @@ mapwhile	map iterator		ck_null		dt|
 
 # Range stuff.
 
-range		flipflop		ck_null		?	S S
+range		flipflop		ck_null		|	S S
 flip		range (or flip)		ck_null		1	S S
 flop		range (or flop)		ck_null		1
 
@@ -530,7 +529,7 @@ flop		range (or flop)		ck_null		1
 and		logical and		ck_null		|	
 or		logical or		ck_null		|	
 xor		logical xor		ck_null		fs|	S S	
-cond_expr	conditional expression	ck_null		d?	
+cond_expr	conditional expression	ck_null		d|	
 andassign	logical and assignment	ck_null		s|	
 orassign	logical or assignment	ck_null		s|	
 
diff --git a/perl.h b/perl.h
index 9def948bca..22aa4139bb 100644
--- a/perl.h
+++ b/perl.h
@@ -1238,7 +1238,6 @@ typedef struct unop UNOP;
 typedef struct binop BINOP;
 typedef struct listop LISTOP;
 typedef struct logop LOGOP;
-typedef struct condop CONDOP;
 typedef struct pmop PMOP;
 typedef struct svop SVOP;
 typedef struct gvop GVOP;
diff --git a/pod/perltoc.pod b/pod/perltoc.pod
index ca5b0557f8..df44b38ffe 100644
--- a/pod/perltoc.pod
+++ b/pod/perltoc.pod
@@ -3643,10 +3643,6 @@ last
 
 other
 
-=item B::CONDOP METHODS
-
-true, false
-
 =item B::LISTOP METHOD
 
 children
diff --git a/pp_ctl.c b/pp_ctl.c
index 21d03351ef..1a15a01507 100644
--- a/pp_ctl.c
+++ b/pp_ctl.c
@@ -1022,11 +1022,11 @@ PP(pp_sort)
 PP(pp_range)
 {
     if (GIMME == G_ARRAY)
-	return cCONDOP->op_true;
+	return NORMAL;
     if (SvTRUEx(PAD_SV(PL_op->op_targ)))
-	return cCONDOP->op_false;
+	return cLOGOP->op_other;
     else
-	return cCONDOP->op_true;
+	return NORMAL;
 }
 
 PP(pp_flip)
@@ -1034,7 +1034,7 @@ PP(pp_flip)
     djSP;
 
     if (GIMME == G_ARRAY) {
-	RETURNOP(((CONDOP*)cUNOP->op_first)->op_false);
+	RETURNOP(((LOGOP*)cUNOP->op_first)->op_other);
     }
     else {
 	dTOPss;
@@ -1052,7 +1052,7 @@ PP(pp_flip)
 	    else {
 		sv_setiv(targ, 0);
 		SP--;
-		RETURNOP(((CONDOP*)cUNOP->op_first)->op_false);
+		RETURNOP(((LOGOP*)cUNOP->op_first)->op_other);
 	    }
 	}
 	sv_setpv(TARG, "");
diff --git a/pp_hot.c b/pp_hot.c
index f5ba85aa6e..f4ed17129c 100644
--- a/pp_hot.c
+++ b/pp_hot.c
@@ -142,9 +142,9 @@ PP(pp_cond_expr)
 {
     djSP;
     if (SvTRUEx(POPs))
-	RETURNOP(cCONDOP->op_true);
+	RETURNOP(cLOGOP->op_other);
     else
-	RETURNOP(cCONDOP->op_false);
+	RETURNOP(cLOGOP->op_next);
 }
 
 PP(pp_unstack)