EXp |void |op_clear |NN OP* o
Ap |void |op_refcnt_lock
Ap |void |op_refcnt_unlock
-Apd |OP* |op_sibling_splice|NN OP *parent|NULLOK OP *start \
+Apdn |OP* |op_sibling_splice|NN OP *parent|NULLOK OP *start \
|int del_count|NULLOK OP* insert
-Apd |OP* |op_parent|NN OP *o
+Apdn |OP* |op_parent|NN OP *o
#if defined(PERL_IN_OP_C)
s |OP* |listkids |NULLOK OP* o
#endif
#define op_free(a) Perl_op_free(aTHX_ a)
#define op_linklist(a) Perl_op_linklist(aTHX_ a)
#define op_null(a) Perl_op_null(aTHX_ a)
-#define op_parent(a) Perl_op_parent(aTHX_ a)
+#define op_parent Perl_op_parent
#define op_prepend_elem(a,b,c) Perl_op_prepend_elem(aTHX_ a,b,c)
#define op_refcnt_lock() Perl_op_refcnt_lock(aTHX)
#define op_refcnt_unlock() Perl_op_refcnt_unlock(aTHX)
#define op_scope(a) Perl_op_scope(aTHX_ a)
-#define op_sibling_splice(a,b,c,d) Perl_op_sibling_splice(aTHX_ a,b,c,d)
+#define op_sibling_splice Perl_op_sibling_splice
#define pack_cat(a,b,c,d,e,f,g) Perl_pack_cat(aTHX_ a,b,c,d,e,f,g)
#define packlist(a,b,c,d,e) Perl_packlist(aTHX_ a,b,c,d,e)
#define pad_add_anon(a,b) Perl_pad_add_anon(aTHX_ a,b)
you to delete zero or more sequential nodes, replacing them with zero or
more different nodes. Performs the necessary op_first/op_last
housekeeping on the parent node and op_sibling manipulation on the
-children. The op_sibling field of the last deleted node will be set to
-NULL.
+children. The last deleted node will be marked as as the last node by
+updating the op_sibling or op_lastsib field as appropriate.
Note that op_next is not manipulated, and nodes are not freed; that is the
-responsibility of the caller. It also won't create new a list op for an empty
-list etc; use higher-level functions like op_append_elem() for that.
+responsibility of the caller. It also won't create a new list op for an
+empty list etc; use higher-level functions like op_append_elem() for that.
parent is the parent node of the sibling chain.
insert is the first of a chain of nodes to be inserted in place of the nodes.
If NULL, no nodes are inserted.
-The head of the chain of deleted op is returned, or NULL uif no ops were
+The head of the chain of deleted ops is returned, or NULL if no ops were
deleted.
For example:
------ ----- ----- -------
P P
- splice(P, A, 2, X-Y) | | B-C
- A-B-C-D A-X-Y-D
+ splice(P, A, 2, X-Y-Z) | | B-C
+ A-B-C-D A-X-Y-Z-D
P P
splice(P, NULL, 1, X-Y) | | A
A-B-C-D X-Y-B-C-D
P P
- splice(P, NULL, 1, NULL) | | A
- A-B-C-D B-C-D
+ splice(P, NULL, 3, NULL) | | A-B-C
+ A-B-C-D D
P P
splice(P, B, 0, X-Y) | | NULL
*/
OP *
-Perl_op_sibling_splice(pTHX_ OP *parent, OP *start, int del_count, OP* insert)
+Perl_op_sibling_splice(OP *parent, OP *start, int del_count, OP* insert)
{
dVAR;
OP *first = start ? OP_SIBLING(start) : cLISTOPx(parent)->op_first;
*/
OP *
-Perl_op_parent(pTHX_ OP *o)
+Perl_op_parent(OP *o)
{
PERL_ARGS_ASSERT_OP_PARENT;
#ifdef PERL_OP_PARENT
LOGOP *logop;
OP *kid = first;
NewOp(1101, logop, 1, LOGOP);
- logop->op_type = type;
+ logop->op_type = (OPCODE)type;
logop->op_first = first;
logop->op_other = other;
logop->op_flags = OPf_KIDS;
#define PERL_ARGS_ASSERT_OP_NULL \
assert(o)
-PERL_CALLCONV OP* Perl_op_parent(pTHX_ OP *o)
- __attribute__nonnull__(pTHX_1);
+PERL_CALLCONV OP* Perl_op_parent(OP *o)
+ __attribute__nonnull__(1);
#define PERL_ARGS_ASSERT_OP_PARENT \
assert(o)
PERL_CALLCONV void Perl_op_refcnt_lock(pTHX);
PERL_CALLCONV void Perl_op_refcnt_unlock(pTHX);
PERL_CALLCONV OP* Perl_op_scope(pTHX_ OP* o);
-PERL_CALLCONV OP* Perl_op_sibling_splice(pTHX_ OP *parent, OP *start, int del_count, OP* insert)
- __attribute__nonnull__(pTHX_1);
+PERL_CALLCONV OP* Perl_op_sibling_splice(OP *parent, OP *start, int del_count, OP* insert)
+ __attribute__nonnull__(1);
#define PERL_ARGS_ASSERT_OP_SIBLING_SPLICE \
assert(parent)