1PERLINTERP(1)          Perl Programmers Reference Guide          PERLINTERP(1)
2
3
4

NAME

6       perlinterp - An overview of the Perl interpreter
7

DESCRIPTION

9       This document provides an overview of how the Perl interpreter works at
10       the level of C code, along with pointers to the relevant C source code
11       files.
12

ELEMENTS OF THE INTERPRETER

14       The work of the interpreter has two main stages: compiling the code
15       into the internal representation, or bytecode, and then executing it.
16       "Compiled code" in perlguts explains exactly how the compilation stage
17       happens.
18
19       Here is a short breakdown of perl's operation:
20
21   Startup
22       The action begins in perlmain.c. (or miniperlmain.c for miniperl) This
23       is very high-level code, enough to fit on a single screen, and it
24       resembles the code found in perlembed; most of the real action takes
25       place in perl.c
26
27       perlmain.c is generated by "ExtUtils::Miniperl" from miniperlmain.c at
28       make time, so you should make perl to follow this along.
29
30       First, perlmain.c allocates some memory and constructs a Perl
31       interpreter, along these lines:
32
33           1 PERL_SYS_INIT3(&argc,&argv,&env);
34           2
35           3 if (!PL_do_undump) {
36           4     my_perl = perl_alloc();
37           5     if (!my_perl)
38           6         exit(1);
39           7     perl_construct(my_perl);
40           8     PL_perl_destruct_level = 0;
41           9 }
42
43       Line 1 is a macro, and its definition is dependent on your operating
44       system. Line 3 references "PL_do_undump", a global variable - all
45       global variables in Perl start with "PL_". This tells you whether the
46       current running program was created with the "-u" flag to perl and then
47       undump, which means it's going to be false in any sane context.
48
49       Line 4 calls a function in perl.c to allocate memory for a Perl
50       interpreter. It's quite a simple function, and the guts of it looks
51       like this:
52
53        my_perl = (PerlInterpreter*)PerlMem_malloc(sizeof(PerlInterpreter));
54
55       Here you see an example of Perl's system abstraction, which we'll see
56       later: "PerlMem_malloc" is either your system's "malloc", or Perl's own
57       "malloc" as defined in malloc.c if you selected that option at
58       configure time.
59
60       Next, in line 7, we construct the interpreter using perl_construct,
61       also in perl.c; this sets up all the special variables that Perl needs,
62       the stacks, and so on.
63
64       Now we pass Perl the command line options, and tell it to go:
65
66        exitstatus = perl_parse(my_perl, xs_init, argc, argv, (char **)NULL);
67        if (!exitstatus)
68            perl_run(my_perl);
69
70        exitstatus = perl_destruct(my_perl);
71
72        perl_free(my_perl);
73
74       "perl_parse" is actually a wrapper around "S_parse_body", as defined in
75       perl.c, which processes the command line options, sets up any
76       statically linked XS modules, opens the program and calls "yyparse" to
77       parse it.
78
79   Parsing
80       The aim of this stage is to take the Perl source, and turn it into an
81       op tree. We'll see what one of those looks like later. Strictly
82       speaking, there's three things going on here.
83
84       "yyparse", the parser, lives in perly.c, although you're better off
85       reading the original YACC input in perly.y. (Yes, Virginia, there is a
86       YACC grammar for Perl!) The job of the parser is to take your code and
87       "understand" it, splitting it into sentences, deciding which operands
88       go with which operators and so on.
89
90       The parser is nobly assisted by the lexer, which chunks up your input
91       into tokens, and decides what type of thing each token is: a variable
92       name, an operator, a bareword, a subroutine, a core function, and so
93       on. The main point of entry to the lexer is "yylex", and that and its
94       associated routines can be found in toke.c. Perl isn't much like other
95       computer languages; it's highly context sensitive at times, it can be
96       tricky to work out what sort of token something is, or where a token
97       ends. As such, there's a lot of interplay between the tokeniser and the
98       parser, which can get pretty frightening if you're not used to it.
99
100       As the parser understands a Perl program, it builds up a tree of
101       operations for the interpreter to perform during execution. The
102       routines which construct and link together the various operations are
103       to be found in op.c, and will be examined later.
104
105   Optimization
106       Now the parsing stage is complete, and the finished tree represents the
107       operations that the Perl interpreter needs to perform to execute our
108       program. Next, Perl does a dry run over the tree looking for
109       optimisations: constant expressions such as "3 + 4" will be computed
110       now, and the optimizer will also see if any multiple operations can be
111       replaced with a single one. For instance, to fetch the variable $foo,
112       instead of grabbing the glob *foo and looking at the scalar component,
113       the optimizer fiddles the op tree to use a function which directly
114       looks up the scalar in question. The main optimizer is "peep" in op.c,
115       and many ops have their own optimizing functions.
116
117   Running
118       Now we're finally ready to go: we have compiled Perl byte code, and all
119       that's left to do is run it. The actual execution is done by the
120       "runops_standard" function in run.c; more specifically, it's done by
121       these three innocent looking lines:
122
123           while ((PL_op = PL_op->op_ppaddr(aTHX))) {
124               PERL_ASYNC_CHECK();
125           }
126
127       You may be more comfortable with the Perl version of that:
128
129           PERL_ASYNC_CHECK() while $Perl::op = &{$Perl::op->{function}};
130
131       Well, maybe not. Anyway, each op contains a function pointer, which
132       stipulates the function which will actually carry out the operation.
133       This function will return the next op in the sequence - this allows for
134       things like "if" which choose the next op dynamically at run time. The
135       "PERL_ASYNC_CHECK" makes sure that things like signals interrupt
136       execution if required.
137
138       The actual functions called are known as PP code, and they're spread
139       between four files: pp_hot.c contains the "hot" code, which is most
140       often used and highly optimized, pp_sys.c contains all the system-
141       specific functions, pp_ctl.c contains the functions which implement
142       control structures ("if", "while" and the like) and pp.c contains
143       everything else. These are, if you like, the C code for Perl's built-in
144       functions and operators.
145
146       Note that each "pp_" function is expected to return a pointer to the
147       next op. Calls to perl subs (and eval blocks) are handled within the
148       same runops loop, and do not consume extra space on the C stack. For
149       example, "pp_entersub" and "pp_entertry" just push a "CxSUB" or
150       "CxEVAL" block struct onto the context stack which contain the address
151       of the op following the sub call or eval. They then return the first op
152       of that sub or eval block, and so execution continues of that sub or
153       block. Later, a "pp_leavesub" or "pp_leavetry" op pops the "CxSUB" or
154       "CxEVAL", retrieves the return op from it, and returns it.
155
156   Exception handing
157       Perl's exception handing (i.e. "die" etc.) is built on top of the low-
158       level "setjmp()"/"longjmp()" C-library functions. These basically
159       provide a way to capture the current PC and SP registers and later
160       restore them; i.e. a "longjmp()" continues at the point in code where a
161       previous "setjmp()" was done, with anything further up on the C stack
162       being lost. This is why code should always save values using "SAVE_FOO"
163       rather than in auto variables.
164
165       The perl core wraps "setjmp()" etc in the macros "JMPENV_PUSH" and
166       "JMPENV_JUMP". The basic rule of perl exceptions is that "exit", and
167       "die" (in the absence of "eval") perform a JMPENV_JUMP(2), while "die"
168       within "eval" does a JMPENV_JUMP(3).
169
170       At entry points to perl, such as "perl_parse()", "perl_run()" and
171       "call_sv(cv, G_EVAL)" each does a "JMPENV_PUSH", then enter a runops
172       loop or whatever, and handle possible exception returns. For a 2
173       return, final cleanup is performed, such as popping stacks and calling
174       "CHECK" or "END" blocks. Amongst other things, this is how scope
175       cleanup still occurs during an "exit".
176
177       If a "die" can find a "CxEVAL" block on the context stack, then the
178       stack is popped to that level and the return op in that block is
179       assigned to "PL_restartop"; then a JMPENV_JUMP(3) is performed.  This
180       normally passes control back to the guard. In the case of "perl_run"
181       and "call_sv", a non-null "PL_restartop" triggers re-entry to the
182       runops loop. The is the normal way that "die" or "croak" is handled
183       within an "eval".
184
185       Sometimes ops are executed within an inner runops loop, such as tie,
186       sort or overload code. In this case, something like
187
188           sub FETCH { eval { die } }
189
190       would cause a longjmp right back to the guard in "perl_run", popping
191       both runops loops, which is clearly incorrect. One way to avoid this is
192       for the tie code to do a "JMPENV_PUSH" before executing "FETCH" in the
193       inner runops loop, but for efficiency reasons, perl in fact just sets a
194       flag, using "CATCH_SET(TRUE)". The "pp_require", "pp_entereval" and
195       "pp_entertry" ops check this flag, and if true, they call "docatch",
196       which does a "JMPENV_PUSH" and starts a new runops level to execute the
197       code, rather than doing it on the current loop.
198
199       As a further optimisation, on exit from the eval block in the "FETCH",
200       execution of the code following the block is still carried on in the
201       inner loop. When an exception is raised, "docatch" compares the
202       "JMPENV" level of the "CxEVAL" with "PL_top_env" and if they differ,
203       just re-throws the exception. In this way any inner loops get popped.
204
205       Here's an example.
206
207           1: eval { tie @a, 'A' };
208           2: sub A::TIEARRAY {
209           3:     eval { die };
210           4:     die;
211           5: }
212
213       To run this code, "perl_run" is called, which does a "JMPENV_PUSH" then
214       enters a runops loop. This loop executes the eval and tie ops on line
215       1, with the eval pushing a "CxEVAL" onto the context stack.
216
217       The "pp_tie" does a "CATCH_SET(TRUE)", then starts a second runops loop
218       to execute the body of "TIEARRAY". When it executes the entertry op on
219       line 3, "CATCH_GET" is true, so "pp_entertry" calls "docatch" which
220       does a "JMPENV_PUSH" and starts a third runops loop, which then
221       executes the die op. At this point the C call stack looks like this:
222
223           Perl_pp_die
224           Perl_runops      # third loop
225           S_docatch_body
226           S_docatch
227           Perl_pp_entertry
228           Perl_runops      # second loop
229           S_call_body
230           Perl_call_sv
231           Perl_pp_tie
232           Perl_runops      # first loop
233           S_run_body
234           perl_run
235           main
236
237       and the context and data stacks, as shown by "-Dstv", look like:
238
239           STACK 0: MAIN
240             CX 0: BLOCK  =>
241             CX 1: EVAL   => AV()  PV("A"\0)
242             retop=leave
243           STACK 1: MAGIC
244             CX 0: SUB    =>
245             retop=(null)
246             CX 1: EVAL   => *
247           retop=nextstate
248
249       The die pops the first "CxEVAL" off the context stack, sets
250       "PL_restartop" from it, does a JMPENV_JUMP(3), and control returns to
251       the top "docatch". This then starts another third-level runops level,
252       which executes the nextstate, pushmark and die ops on line 4. At the
253       point that the second "pp_die" is called, the C call stack looks
254       exactly like that above, even though we are no longer within an inner
255       eval; this is because of the optimization mentioned earlier. However,
256       the context stack now looks like this, ie with the top CxEVAL popped:
257
258           STACK 0: MAIN
259             CX 0: BLOCK  =>
260             CX 1: EVAL   => AV()  PV("A"\0)
261             retop=leave
262           STACK 1: MAGIC
263             CX 0: SUB    =>
264             retop=(null)
265
266       The die on line 4 pops the context stack back down to the CxEVAL,
267       leaving it as:
268
269           STACK 0: MAIN
270             CX 0: BLOCK  =>
271
272       As usual, "PL_restartop" is extracted from the "CxEVAL", and a
273       JMPENV_JUMP(3) done, which pops the C stack back to the docatch:
274
275           S_docatch
276           Perl_pp_entertry
277           Perl_runops      # second loop
278           S_call_body
279           Perl_call_sv
280           Perl_pp_tie
281           Perl_runops      # first loop
282           S_run_body
283           perl_run
284           main
285
286       In  this case, because the "JMPENV" level recorded in the "CxEVAL"
287       differs from the current one, "docatch" just does a JMPENV_JUMP(3) and
288       the C stack unwinds to:
289
290           perl_run
291           main
292
293       Because "PL_restartop" is non-null, "run_body" starts a new runops loop
294       and execution continues.
295
296   INTERNAL VARIABLE TYPES
297       You should by now have had a look at perlguts, which tells you about
298       Perl's internal variable types: SVs, HVs, AVs and the rest. If not, do
299       that now.
300
301       These variables are used not only to represent Perl-space variables,
302       but also any constants in the code, as well as some structures
303       completely internal to Perl. The symbol table, for instance, is an
304       ordinary Perl hash. Your code is represented by an SV as it's read into
305       the parser; any program files you call are opened via ordinary Perl
306       filehandles, and so on.
307
308       The core Devel::Peek module lets us examine SVs from a Perl program.
309       Let's see, for instance, how Perl treats the constant "hello".
310
311             % perl -MDevel::Peek -e 'Dump("hello")'
312           1 SV = PV(0xa041450) at 0xa04ecbc
313           2   REFCNT = 1
314           3   FLAGS = (POK,READONLY,pPOK)
315           4   PV = 0xa0484e0 "hello"\0
316           5   CUR = 5
317           6   LEN = 6
318
319       Reading "Devel::Peek" output takes a bit of practise, so let's go
320       through it line by line.
321
322       Line 1 tells us we're looking at an SV which lives at 0xa04ecbc in
323       memory. SVs themselves are very simple structures, but they contain a
324       pointer to a more complex structure. In this case, it's a PV, a
325       structure which holds a string value, at location 0xa041450. Line 2 is
326       the reference count; there are no other references to this data, so
327       it's 1.
328
329       Line 3 are the flags for this SV - it's OK to use it as a PV, it's a
330       read-only SV (because it's a constant) and the data is a PV internally.
331       Next we've got the contents of the string, starting at location
332       0xa0484e0.
333
334       Line 5 gives us the current length of the string - note that this does
335       not include the null terminator. Line 6 is not the length of the
336       string, but the length of the currently allocated buffer; as the string
337       grows, Perl automatically extends the available storage via a routine
338       called "SvGROW".
339
340       You can get at any of these quantities from C very easily; just add
341       "Sv" to the name of the field shown in the snippet, and you've got a
342       macro which will return the value: "SvCUR(sv)" returns the current
343       length of the string, "SvREFCOUNT(sv)" returns the reference count,
344       "SvPV(sv, len)" returns the string itself with its length, and so on.
345       More macros to manipulate these properties can be found in perlguts.
346
347       Let's take an example of manipulating a PV, from "sv_catpvn", in sv.c
348
349            1  void
350            2  Perl_sv_catpvn(pTHX_ SV *sv, const char *ptr, STRLEN len)
351            3  {
352            4      STRLEN tlen;
353            5      char *junk;
354
355            6      junk = SvPV_force(sv, tlen);
356            7      SvGROW(sv, tlen + len + 1);
357            8      if (ptr == junk)
358            9          ptr = SvPVX(sv);
359           10      Move(ptr,SvPVX(sv)+tlen,len,char);
360           11      SvCUR(sv) += len;
361           12      *SvEND(sv) = '\0';
362           13      (void)SvPOK_only_UTF8(sv);          /* validate pointer */
363           14      SvTAINT(sv);
364           15  }
365
366       This is a function which adds a string, "ptr", of length "len" onto the
367       end of the PV stored in "sv". The first thing we do in line 6 is make
368       sure that the SV has a valid PV, by calling the "SvPV_force" macro to
369       force a PV. As a side effect, "tlen" gets set to the current value of
370       the PV, and the PV itself is returned to "junk".
371
372       In line 7, we make sure that the SV will have enough room to
373       accommodate the old string, the new string and the null terminator. If
374       "LEN" isn't big enough, "SvGROW" will reallocate space for us.
375
376       Now, if "junk" is the same as the string we're trying to add, we can
377       grab the string directly from the SV; "SvPVX" is the address of the PV
378       in the SV.
379
380       Line 10 does the actual catenation: the "Move" macro moves a chunk of
381       memory around: we move the string "ptr" to the end of the PV - that's
382       the start of the PV plus its current length. We're moving "len" bytes
383       of type "char". After doing so, we need to tell Perl we've extended the
384       string, by altering "CUR" to reflect the new length. "SvEND" is a macro
385       which gives us the end of the string, so that needs to be a "\0".
386
387       Line 13 manipulates the flags; since we've changed the PV, any IV or NV
388       values will no longer be valid: if we have "$a=10; $a.="6";" we don't
389       want to use the old IV of 10. "SvPOK_only_utf8" is a special
390       UTF-8-aware version of "SvPOK_only", a macro which turns off the IOK
391       and NOK flags and turns on POK. The final "SvTAINT" is a macro which
392       launders tainted data if taint mode is turned on.
393
394       AVs and HVs are more complicated, but SVs are by far the most common
395       variable type being thrown around. Having seen something of how we
396       manipulate these, let's go on and look at how the op tree is
397       constructed.
398

OP TREES

400       First, what is the op tree, anyway? The op tree is the parsed
401       representation of your program, as we saw in our section on parsing,
402       and it's the sequence of operations that Perl goes through to execute
403       your program, as we saw in "Running".
404
405       An op is a fundamental operation that Perl can perform: all the built-
406       in functions and operators are ops, and there are a series of ops which
407       deal with concepts the interpreter needs internally - entering and
408       leaving a block, ending a statement, fetching a variable, and so on.
409
410       The op tree is connected in two ways: you can imagine that there are
411       two "routes" through it, two orders in which you can traverse the tree.
412       First, parse order reflects how the parser understood the code, and
413       secondly, execution order tells perl what order to perform the
414       operations in.
415
416       The easiest way to examine the op tree is to stop Perl after it has
417       finished parsing, and get it to dump out the tree. This is exactly what
418       the compiler backends B::Terse, B::Concise and B::Debug do.
419
420       Let's have a look at how Perl sees "$a = $b + $c":
421
422            % perl -MO=Terse -e '$a=$b+$c'
423            1  LISTOP (0x8179888) leave
424            2      OP (0x81798b0) enter
425            3      COP (0x8179850) nextstate
426            4      BINOP (0x8179828) sassign
427            5          BINOP (0x8179800) add [1]
428            6              UNOP (0x81796e0) null [15]
429            7                  SVOP (0x80fafe0) gvsv  GV (0x80fa4cc) *b
430            8              UNOP (0x81797e0) null [15]
431            9                  SVOP (0x8179700) gvsv  GV (0x80efeb0) *c
432           10          UNOP (0x816b4f0) null [15]
433           11              SVOP (0x816dcf0) gvsv  GV (0x80fa460) *a
434
435       Let's start in the middle, at line 4. This is a BINOP, a binary
436       operator, which is at location 0x8179828. The specific operator in
437       question is "sassign" - scalar assignment - and you can find the code
438       which implements it in the function "pp_sassign" in pp_hot.c. As a
439       binary operator, it has two children: the add operator, providing the
440       result of "$b+$c", is uppermost on line 5, and the left hand side is on
441       line 10.
442
443       Line 10 is the null op: this does exactly nothing. What is that doing
444       there? If you see the null op, it's a sign that something has been
445       optimized away after parsing. As we mentioned in "Optimization", the
446       optimization stage sometimes converts two operations into one, for
447       example when fetching a scalar variable. When this happens, instead of
448       rewriting the op tree and cleaning up the dangling pointers, it's
449       easier just to replace the redundant operation with the null op.
450       Originally, the tree would have looked like this:
451
452           10          SVOP (0x816b4f0) rv2sv [15]
453           11              SVOP (0x816dcf0) gv  GV (0x80fa460) *a
454
455       That is, fetch the "a" entry from the main symbol table, and then look
456       at the scalar component of it: "gvsv" ("pp_gvsv" in pp_hot.c) happens
457       to do both these things.
458
459       The right hand side, starting at line 5 is similar to what we've just
460       seen: we have the "add" op ("pp_add", also in pp_hot.c) add together
461       two "gvsv"s.
462
463       Now, what's this about?
464
465            1  LISTOP (0x8179888) leave
466            2      OP (0x81798b0) enter
467            3      COP (0x8179850) nextstate
468
469       "enter" and "leave" are scoping ops, and their job is to perform any
470       housekeeping every time you enter and leave a block: lexical variables
471       are tidied up, unreferenced variables are destroyed, and so on. Every
472       program will have those first three lines: "leave" is a list, and its
473       children are all the statements in the block. Statements are delimited
474       by "nextstate", so a block is a collection of "nextstate" ops, with the
475       ops to be performed for each statement being the children of
476       "nextstate". "enter" is a single op which functions as a marker.
477
478       That's how Perl parsed the program, from top to bottom:
479
480                               Program
481                                  |
482                              Statement
483                                  |
484                                  =
485                                 / \
486                                /   \
487                               $a   +
488                                   / \
489                                 $b   $c
490
491       However, it's impossible to perform the operations in this order: you
492       have to find the values of $b and $c before you add them together, for
493       instance. So, the other thread that runs through the op tree is the
494       execution order: each op has a field "op_next" which points to the next
495       op to be run, so following these pointers tells us how perl executes
496       the code. We can traverse the tree in this order using the "exec"
497       option to "B::Terse":
498
499            % perl -MO=Terse,exec -e '$a=$b+$c'
500            1  OP (0x8179928) enter
501            2  COP (0x81798c8) nextstate
502            3  SVOP (0x81796c8) gvsv  GV (0x80fa4d4) *b
503            4  SVOP (0x8179798) gvsv  GV (0x80efeb0) *c
504            5  BINOP (0x8179878) add [1]
505            6  SVOP (0x816dd38) gvsv  GV (0x80fa468) *a
506            7  BINOP (0x81798a0) sassign
507            8  LISTOP (0x8179900) leave
508
509       This probably makes more sense for a human: enter a block, start a
510       statement. Get the values of $b and $c, and add them together.  Find
511       $a, and assign one to the other. Then leave.
512
513       The way Perl builds up these op trees in the parsing process can be
514       unravelled by examining toke.c, the lexer, and perly.y, the YACC
515       grammar. Let's look at the code that constructs the tree for "$a = $b +
516       $c".
517
518       First, we'll look at the "Perl_yylex" function in the lexer. We want to
519       look for "case 'x'", where x is the first character of the operator.
520       (Incidentally, when looking for the code that handles a keyword, you'll
521       want to search for "KEY_foo" where "foo" is the keyword.) Here is the
522       code that handles assignment (there are quite a few operators beginning
523       with "=", so most of it is omitted for brevity):
524
525            1    case '=':
526            2        s++;
527                     ... code that handles == => etc. and pod ...
528            3        pl_yylval.ival = 0;
529            4        OPERATOR(ASSIGNOP);
530
531       We can see on line 4 that our token type is "ASSIGNOP" ("OPERATOR" is a
532       macro, defined in toke.c, that returns the token type, among other
533       things). And "+":
534
535            1     case '+':
536            2         {
537            3             const char tmp = *s++;
538                          ... code for ++ ...
539            4             if (PL_expect == XOPERATOR) {
540                              ...
541            5                 Aop(OP_ADD);
542            6             }
543                          ...
544            7         }
545
546       Line 4 checks what type of token we are expecting. "Aop" returns a
547       token.  If you search for "Aop" elsewhere in toke.c, you will see that
548       it returns an "ADDOP" token.
549
550       Now that we know the two token types we want to look for in the parser,
551       let's take the piece of perly.y we need to construct the tree for "$a =
552       $b + $c"
553
554           1 term    :   term ASSIGNOP term
555           2                { $$ = newASSIGNOP(OPf_STACKED, $1, $2, $3); }
556           3         |   term ADDOP term
557           4                { $$ = newBINOP($2, 0, scalar($1), scalar($3)); }
558
559       If you're not used to reading BNF grammars, this is how it works:
560       You're fed certain things by the tokeniser, which generally end up in
561       upper case. "ADDOP" and "ASSIGNOP" are examples of "terminal symbols",
562       because you can't get any simpler than them.
563
564       The grammar, lines one and three of the snippet above, tells you how to
565       build up more complex forms. These complex forms, "non-terminal
566       symbols" are generally placed in lower case. "term" here is a non-
567       terminal symbol, representing a single expression.
568
569       The grammar gives you the following rule: you can make the thing on the
570       left of the colon if you see all the things on the right in sequence.
571       This is called a "reduction", and the aim of parsing is to completely
572       reduce the input. There are several different ways you can perform a
573       reduction, separated by vertical bars: so, "term" followed by "="
574       followed by "term" makes a "term", and "term" followed by "+" followed
575       by "term" can also make a "term".
576
577       So, if you see two terms with an "=" or "+", between them, you can turn
578       them into a single expression. When you do this, you execute the code
579       in the block on the next line: if you see "=", you'll do the code in
580       line 2. If you see "+", you'll do the code in line 4. It's this code
581       which contributes to the op tree.
582
583                   |   term ADDOP term
584                   { $$ = newBINOP($2, 0, scalar($1), scalar($3)); }
585
586       What this does is creates a new binary op, and feeds it a number of
587       variables. The variables refer to the tokens: $1 is the first token in
588       the input, $2 the second, and so on - think regular expression
589       backreferences. $$ is the op returned from this reduction. So, we call
590       "newBINOP" to create a new binary operator. The first parameter to
591       "newBINOP", a function in op.c, is the op type. It's an addition
592       operator, so we want the type to be "ADDOP". We could specify this
593       directly, but it's right there as the second token in the input, so we
594       use $2. The second parameter is the op's flags: 0 means "nothing
595       special". Then the things to add: the left and right hand side of our
596       expression, in scalar context.
597
598       The functions that create ops, which have names like "newUNOP" and
599       "newBINOP", call a "check" function associated with each op type,
600       before returning the op. The check functions can mangle the op as they
601       see fit, and even replace it with an entirely new one. These functions
602       are defined in op.c, and have a "Perl_ck_" prefix. You can find out
603       which check function is used for a particular op type by looking in
604       regen/opcodes.  Take "OP_ADD", for example. ("OP_ADD" is the token
605       value from the "Aop(OP_ADD)" in toke.c which the parser passes to
606       "newBINOP" as its first argument.) Here is the relevant line:
607
608           add             addition (+)            ck_null         IfsT2   S S
609
610       The check function in this case is "Perl_ck_null", which does nothing.
611       Let's look at a more interesting case:
612
613           readline        <HANDLE>                ck_readline     t%      F?
614
615       And here is the function from op.c:
616
617            1 OP *
618            2 Perl_ck_readline(pTHX_ OP *o)
619            3 {
620            4     PERL_ARGS_ASSERT_CK_READLINE;
621            5
622            6     if (o->op_flags & OPf_KIDS) {
623            7          OP *kid = cLISTOPo->op_first;
624            8          if (kid->op_type == OP_RV2GV)
625            9              kid->op_private |= OPpALLOW_FAKE;
626           10     }
627           11     else {
628           12         OP * const newop
629           13             = newUNOP(OP_READLINE, 0, newGVOP(OP_GV, 0,
630           14                                               PL_argvgv));
631           15         op_free(o);
632           16         return newop;
633           17     }
634           18     return o;
635           19 }
636
637       One particularly interesting aspect is that if the op has no kids
638       (i.e., "readline()" or "<>") the op is freed and replaced with an
639       entirely new one that references *ARGV (lines 12-16).
640

STACKS

642       When perl executes something like "addop", how does it pass on its
643       results to the next op? The answer is, through the use of stacks. Perl
644       has a number of stacks to store things it's currently working on, and
645       we'll look at the three most important ones here.
646
647   Argument stack
648       Arguments are passed to PP code and returned from PP code using the
649       argument stack, "ST". The typical way to handle arguments is to pop
650       them off the stack, deal with them how you wish, and then push the
651       result back onto the stack. This is how, for instance, the cosine
652       operator works:
653
654             NV value;
655             value = POPn;
656             value = Perl_cos(value);
657             XPUSHn(value);
658
659       We'll see a more tricky example of this when we consider Perl's macros
660       below. "POPn" gives you the NV (floating point value) of the top SV on
661       the stack: the $x in "cos($x)". Then we compute the cosine, and push
662       the result back as an NV. The "X" in "XPUSHn" means that the stack
663       should be extended if necessary - it can't be necessary here, because
664       we know there's room for one more item on the stack, since we've just
665       removed one! The "XPUSH*" macros at least guarantee safety.
666
667       Alternatively, you can fiddle with the stack directly: "SP" gives you
668       the first element in your portion of the stack, and "TOP*" gives you
669       the top SV/IV/NV/etc. on the stack. So, for instance, to do unary
670       negation of an integer:
671
672            SETi(-TOPi);
673
674       Just set the integer value of the top stack entry to its negation.
675
676       Argument stack manipulation in the core is exactly the same as it is in
677       XSUBs - see perlxstut, perlxs and perlguts for a longer description of
678       the macros used in stack manipulation.
679
680   Mark stack
681       I say "your portion of the stack" above because PP code doesn't
682       necessarily get the whole stack to itself: if your function calls
683       another function, you'll only want to expose the arguments aimed for
684       the called function, and not (necessarily) let it get at your own data.
685       The way we do this is to have a "virtual" bottom-of-stack, exposed to
686       each function. The mark stack keeps bookmarks to locations in the
687       argument stack usable by each function. For instance, when dealing with
688       a tied variable, (internally, something with "P" magic) Perl has to
689       call methods for accesses to the tied variables. However, we need to
690       separate the arguments exposed to the method to the argument exposed to
691       the original function - the store or fetch or whatever it may be.
692       Here's roughly how the tied "push" is implemented; see "av_push" in
693       av.c:
694
695            1  PUSHMARK(SP);
696            2  EXTEND(SP,2);
697            3  PUSHs(SvTIED_obj((SV*)av, mg));
698            4  PUSHs(val);
699            5  PUTBACK;
700            6  ENTER;
701            7  call_method("PUSH", G_SCALAR|G_DISCARD);
702            8  LEAVE;
703
704       Let's examine the whole implementation, for practice:
705
706            1  PUSHMARK(SP);
707
708       Push the current state of the stack pointer onto the mark stack. This
709       is so that when we've finished adding items to the argument stack, Perl
710       knows how many things we've added recently.
711
712            2  EXTEND(SP,2);
713            3  PUSHs(SvTIED_obj((SV*)av, mg));
714            4  PUSHs(val);
715
716       We're going to add two more items onto the argument stack: when you
717       have a tied array, the "PUSH" subroutine receives the object and the
718       value to be pushed, and that's exactly what we have here - the tied
719       object, retrieved with "SvTIED_obj", and the value, the SV "val".
720
721            5  PUTBACK;
722
723       Next we tell Perl to update the global stack pointer from our internal
724       variable: "dSP" only gave us a local copy, not a reference to the
725       global.
726
727            6  ENTER;
728            7  call_method("PUSH", G_SCALAR|G_DISCARD);
729            8  LEAVE;
730
731       "ENTER" and "LEAVE" localise a block of code - they make sure that all
732       variables are tidied up, everything that has been localised gets its
733       previous value returned, and so on. Think of them as the "{" and "}" of
734       a Perl block.
735
736       To actually do the magic method call, we have to call a subroutine in
737       Perl space: "call_method" takes care of that, and it's described in
738       perlcall. We call the "PUSH" method in scalar context, and we're going
739       to discard its return value. The call_method() function removes the top
740       element of the mark stack, so there is nothing for the caller to clean
741       up.
742
743   Save stack
744       C doesn't have a concept of local scope, so perl provides one. We've
745       seen that "ENTER" and "LEAVE" are used as scoping braces; the save
746       stack implements the C equivalent of, for example:
747
748           {
749               local $foo = 42;
750               ...
751           }
752
753       See "Localizing changes" in perlguts for how to use the save stack.
754

MILLIONS OF MACROS

756       One thing you'll notice about the Perl source is that it's full of
757       macros. Some have called the pervasive use of macros the hardest thing
758       to understand, others find it adds to clarity. Let's take an example,
759       the code which implements the addition operator:
760
761          1  PP(pp_add)
762          2  {
763          3      dSP; dATARGET; tryAMAGICbin(add,opASSIGN);
764          4      {
765          5        dPOPTOPnnrl_ul;
766          6        SETn( left + right );
767          7        RETURN;
768          8      }
769          9  }
770
771       Every line here (apart from the braces, of course) contains a macro.
772       The first line sets up the function declaration as Perl expects for PP
773       code; line 3 sets up variable declarations for the argument stack and
774       the target, the return value of the operation. Finally, it tries to see
775       if the addition operation is overloaded; if so, the appropriate
776       subroutine is called.
777
778       Line 5 is another variable declaration - all variable declarations
779       start with "d" - which pops from the top of the argument stack two NVs
780       (hence "nn") and puts them into the variables "right" and "left", hence
781       the "rl". These are the two operands to the addition operator.  Next,
782       we call "SETn" to set the NV of the return value to the result of
783       adding the two values. This done, we return - the "RETURN" macro makes
784       sure that our return value is properly handled, and we pass the next
785       operator to run back to the main run loop.
786
787       Most of these macros are explained in perlapi, and some of the more
788       important ones are explained in perlxs as well. Pay special attention
789       to "Background and PERL_IMPLICIT_CONTEXT" in perlguts for information
790       on the "[pad]THX_?" macros.
791

FURTHER READING

793       For more information on the Perl internals, please see the documents
794       listed at "Internals and C Language Interface" in perl.
795
796
797
798perl v5.26.3                      2018-03-23                     PERLINTERP(1)
Impressum