lecture in color

Perl's Guts

compilation
internals and externals.

Compilation life-cycle

Compilation: create a parse tree for the program.
Execution (Interpretation): execute the parse tree as a program.

Pre-compiled Perl?

Compilation: create a parse tree.
Code generation: encode the parse tree as byte codes (store program, ready for running).
Parse-tree reconstruction : input byte codes, translate back into equivalent parse tree.
Execution (Interpretation) : run the program on the parse tree.

Compilation

Read code.
Interpret use, BEGIN when found (by calling the interpreter)
Optimize.

Special blocks

BEGIN: executed even before compilation is finished, when encountered.
CHECK: executed when compilation is finished, before running the program.
INIT: executed just before your program starts.
END: executed after program is done.

Multiple special blocks

Special blocks are not regular functions.
Convention: ALL-CAPS for functions that are called automatically, e.g., AUTOLOAD, DESTROY, etc.
One can have any number of BEGIN, CHECK, INIT, END blocks.
multiple BEGIN and INIT blocks are executed in occurrence order (FIFO).
multiple CHECK and END blocks are executed in the opposite of occurrence order (LIFO).

For example, consider

contents of perl_int/special.pl...
#! /var/local/couch/bin/perl 

BEGIN { print "begin01\n"; } 
BEGIN { print "begin02\n"; } 
CHECK { print "check01\n"; } 
CHECK { print "check02\n"; } 
INIT { print "init01\n"; } 
INIT { print "init02\n"; } 
END { print "end01\n"; } 
END { print "end02\n"; } 

print "hello!\n"; 
...end of perl_int/special.pl

This prints

contents of perl_int/special.pl.out...
begin01
begin02
check02
check01
init01
init02
hello!
end02
end01
...end of perl_int/special.pl.out

Callbacks

Compiler generates initial code (calls interpreter through BEGIN blocks)
Interpreter released to execute code (calls compiler through eval blocks).
Interpreter ends; compiler directives cause execution of END blocks.
At all times, compiler and interpreter run in synergy.
- Only one can run at a time.
- They "call each other" when needed.

Optimization during compilation

First pass: bottom-up compilation
- create parse tree
- immediately fold constant expressions into constants.
- mark entry points.
- generate execution order for nodes in parse tree.
Second pass: top-down optimization
- context propogation: mark nodes as to the context in which they're executed (void, scalar, list, reference, or lvalue) and null out opcodes generated to handle other contexts.
- In general, context is defined by parent nodes and interpreted by children (in the parse tree).
Third pass: peephole optimization
- traverse code in execution order.
- skip over nulled-out codes (created in second pass)
- combine adjacent codes into more efficient forms (e.g., rewrite $a=$a+1 as $a+=1).
Fourth pass: code generation (optional)
- traverse parse tree nodes in execution order.
- represent the parse tree as bytecodes.
- store the representation for later reuse.

Internals and Externals (Chapter 21)

"here be dragons".
So far, we've found how easy it is to think in Perl.
We're about to find out how difficult it is to understand how Perl thinks.

Internal data types (C typedefs)

SV: scalar value.
AV: array value.
HV: hash value.
IV: integer value (see also I32, I16, UV, U32, U16)
RV: reference value (special kind of SV).
GV: glob value.

Manipulating data types in C

Creating scalar values
- from integer
```
  SV*  newSViv(IV); 
```
- from double
```
  SV*  newSVnv(double);
```
- from string (with \0 delimiter)
```
  SV*  newSVpv(const char*, int);
```
- from string of given length (without \0 delimiter)
```
  SV*  newSVpvn(const char*, int);
```
- from format string (similar to sprintf)
```
  SV*  newSVpvf(const char*, ...);
```
- from existing scalar value (copying)
```
  SV*  newSVsv(SV*);
```

Updating values of scalar values:

from integer
```
  void  sv_setiv(SV*, IV);
```
from unsigned int
```
  void  sv_setuv(SV*, UV);
```
from double
```
  void  sv_setnv(SV*, double);
```
from string (terminated with \0)
```
  void  sv_setpv(SV*, const char*);
```

from prefix of string (not \0 terminated)

  void  sv_setpvn(SV*, const char*, int)

from sprintf format

  void  sv_setpvf(SV*, const char*, ...)

from prefix of sprintf output (STRLEN determines length)

  void  sv_setpvfn(SV*, const char*, STRLEN, va_list *, SV **, I32, bool);

from other value
```
  void  sv_setsv(SV*, SV*);
```

Accessing values (macros)
- integer
```
  SvIV(SV*)
```
- unsigned
```
  SvUV(SV*)
```
- double
```
  SvNV(SV*)
```
- string (with length specification)
```
  SvPV(SV*, STRLEN len)
```
- all of string
```
  SvPV_nolen(SV*)
```
- is this scalar value TRUE?
```
  SvTRUE(SV*) 
```
- is this scalar value an integer?
```
  SvIOK(SV*)
```
- is this scalar value a number?
```
  SvNOK(SV*)
```
- is this scalar value a string?
```
  SvPOK(SV*)
```

concatenating input onto strings

adding a string
```
  void  sv_catpv(SV*, const char*);
```

adding a number

  void  sv_catpvn(SV*, const char*, STRLEN);

adding the output of an sprintf

  void  sv_catpvf(SV*, const char*, ...);

adding a prefix of the output of an sprintf (length limit STRLEN)

  void  sv_catpvfn(SV*, const char*, STRLEN, va_list *, SV **, I32, bool);

adding another scalar value (.= operator)
```
  void  sv_catsv(SV*, SV*);
```

Gaining access to a perl variable (by name)

  SV*  get_sv("package::varname", FALSE);

Determining if a variable is defined
```
  SvOK(SV*)
```
Freeing an SV:
```
  SvREFCNT_dec(SV*); 
```

Watch out:

Whenever you assign something an SV, the SV's reference count is updated.
But some operations don't update the reference count, specifically, for arrays.

Working with Arrays in C

Creating an array
```
  AV*  newAV();
```
Creating an array and initializing it to SV's
```
  AV*  av_make(I32 num, SV **ptr);
```

push, pop, shift, unshift

  void  av_push(AV*, SV*);
  SV*   av_pop(AV*);
  SV*   av_shift(AV*);
  void  av_unshift(AV*, I32 num);

length
```
  I32   av_len(AV*);
```
fetching a value
```
  SV**  av_fetch(AV*, I32 key, I32 lval);
```
(lval != 0 means to store an undef at key as well)

storing a value in an array

  SV**  av_store(AV*, I32 key, SV* val);

clearing all values
```
  void  av_clear(AV*);
```
delete the whole array
```
  void  av_undef(AV*);
```
resize (extend) an array.
```
  void  av_extend(AV*, I32 key);
```

Instant memory leak

Important mess: The "av_store" function stores the value "val" at index "key", and does not increment the reference count of "val".
Thus the caller is responsible for taking care of that, and if "av_store" returns NULL, the caller will have to decrement the reference count to avoid a memory leak.

Hashes

create a hash:
```
  HV*  newHV();
```
store a value in a hash.
```
  SV**  hv_store(HV*, const char* key, U32 klen, SV* val, U32 hash);
```
- key is a string, and you must specify its length klen.
- hash is a precomputed hash value for the key (0 to make hv_store calculate it).
fetch a value from a hash
```
  SV**  hv_fetch(HV*, const char* key, U32 klen, I32 lval);
```
- lval!=0 means initialize value to undef even if it doesn't exist.

does a value exist?

  bool  hv_exists(HV*, const char* key, U32 klen);

delete a key

  SV*   hv_delete(HV*, const char* key, U32 klen, I32 flags);

clear a hash
```
  void   hv_clear(HV*);
```
delete and free whole hash
```
  void   hv_undef(HV*);
```
abstract iteration (each)
- Prepares starting point to traverse hash table
```
  I32    hv_iterinit(HV*);
```
- Get the next entry, and return a pointer to a structure that has both the key and value.
```
  HE*    hv_iternext(HV*);
```
- Get the key from an HE structure and also return the length of the key string.
```
  char*  hv_iterkey(HE* entry, I32* retlen);
```
- Return a SV pointer to the value of the HE structure
```
  SV*    hv_iterval(HV*, HE* entry);
```
- This convenience routine combines hv_iternext, hv_iterkey, and hv_iterval. The key and retlen arguments are return values for the key and its length. The value is returned in the SV* argument
```
  SV*    hv_iternextsv(HV*, char* key, I32* retlen);
```
So, to iterate over a hash h, one would write in C:
```
 char key[1024]; int keylen; SV* v; 
 hv_iterinit(h);
 while ((v=hv_iternextsv(h,key,&keylen))!=0) { 
    # do something with v
 } 
```
(note: this code may be in error; checking on it)

lecture in color

downloaded on Nov-23-2009 05:34:19 AM,
was last modified on Dec-31-1969 07:00:00 PM.
All lecture note content is copyright 2003 by
Alva L. Couch, Computer Science, Tufts University
(couch at cs dot tufts dot edu)