From: Stephen McCamant Date: Fri, 25 Jun 1999 13:38:44 +0000 (-0500) Subject: Eliminate CONDOPs X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=commitdiff_plain;h=1a67a97c0300941ac67bfb1dd421467b8c59e21c;p=p5sagit%2Fp5-mst-13.2.git Eliminate CONDOPs Message-ID: <14193.25034.113373.245377@alias-2.pr.mcs.net> p4raw-id: //depot/perl@3637 --- diff --git a/bytecode.pl b/bytecode.pl index 4d318ff..dfd16aa 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 12d318d..450ab86 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 cdbd3b2..b39659d 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 (corresponding to the C function C). =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 1777b21..79610c3 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 df2a642..ae47cf9 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 42b9199..1bf4368 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 0385452..3f8260e 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 b909d44..98c9318 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 d10db9c..7563626 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 854db71..16f25ff 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 183d541..e0cb8ff 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 3531c49..948fdcd 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 d9e78f7..81df30e 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 8c6f336..4de4647 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 5f4acf5..ab279be 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 cd0c7eb..56d8342 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 9def948..22aa413 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 ca5b055..df44b38 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 21d0335..1a15a01 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 f5ba85a..f4ed171 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)