p = new Perl('Sys::Hostname', 'Test::Harness')+In addition to creating an interpreter, this will also include the libraries +you pass to the Perl constructor, which is equivalent to use +Sys::Hostname; use Test::Harness. You can always include libraries +explicitly by using p.eval('use Sys::Hostname; use Test::Harness'). +There is also another way to do this: p.use('Sys::Hostname', 'Test::Harness'). +As you can see, TMTOWTDI. Natura lly, you will want to +look at the result of your function calls and eval statements. +Suppose, you do something like this: +
line = p.eval("'-' x 80")+Perl's eval returns the last statement evaluated, unless you explicitly +say return. So now line contains 80 dashes. You can do +similar things with non-scalar data types: +
p.use('Time::gmtime'); ++assigns a Perl array to t. You can print t, use the for/in +syntax to walk through it, compute its lenght, etc. You can read and assign +to individual elements using the standard syntax. However, PerlValues, +that is, the value we get from Perl, don't support all the standard operations, +for isntance, don't expect t.reverse() to work. Hashes can also +be returned from Perl: +
t = p.eval('Time::gmtime::gmtime') // returns +[49,0,4,24,6,98,5,204,0]
info=p.eval("{ver=>$], pid=>$$}")+Now you can look at individual hash keys like this: +
info["ver"] or info.pid+Suppose you want to use Perl to perform pattern-based string replacement. +Here's how you can do it from JavaScript: +
p.eval("\ ++and now +
sub perl_replace(){\ +
my($string, $find, $replace) += @_;\ +
eval(\"\\$string =~ +s/$find/$replace/g;\");\ +
return $string;\ +
}" +
);
p.perl_replace('Quick brown fox jumped over a lazy dog', +'dog', 'rhino')+produces what you'd expect. + +
You can use the same syntax to call procedures defined in modules other +than main. The example with gmtime can be rewritten like +this: +
p.use('Time::gmtime'); ++ You can reference variables exported by modules others than main +like this: +
t = p.Time.gmtime.gmtime() // returns [49,0,4,24,6,98,5,204,0]
a=p.Foo.$bar or a=p.Foo["$bar"] or ++Each of the stetements above returns a either an immediate JS value, for +scalar types, or a PerlValue for compound types. a.type contains +the type of the PerlValue in a. This may change because we +may end up separating Perl hashes and arrays into separate classes. +
a=p.Foo["@bar"]or a=p.Foo["%bar"]
use JS; ++and now you can do something like this: +
$js = new JS();
$js->eval(q/ ++//TODO: more features and examples +Object o = {}; ++/);
o.a = 'p'; +
o.b = 'q'; +
return o;
| Object | + +What it does | +
| Perl | + +Perl Interpreter Object. It's prototype type +is PerlModule, it corresponds to main::. Supports eval, +call, use. | +
| PerlModule | + +Implements JS-like syntax for Perl modules. Doesn't +export provide any methods. path property shown the name of the +Perl module the object represents. | +
| PerlValue | + +Represents a value returned from eval, +call, or obtained by using the subscript notation (p.Foo["@bar"]). +Its Perl type is stored in the type property. | +
| Package | + +What it contains | +
| JS | + +Doesn't not do anything in particular at this +point except defining a constuctor. So one can say $js = new +JS(), which will create a new runtime, add a context to it and return +that Context. JS also defines a bunch of private functions called from +C by PerlConnect. They are not exposed by default, but pushed onto @EXPORT_OK +array instead. | +
| JS::Runtime | + +Corresponds to JSRuntime* struct. Provides +a constructor and destructor. The destructor is invoked automatically, +so you don't have to worry about Runtime deallocation. Constructor syntax +is the following: $rt = new JS::Runtime(10_000), where +the parameter is the same number you pass to JS_NewRuntime. There +are many private functions created in JS.xs that are not exported +by default. | +
| JS::Context | + +Corresponds to JSContext* struct. Provides +a constructor and destructor. The destructor is invoked automatically, +so you don't have to worry about Context deallocation. Constructor syntax +is the following: $rt = new JS::Context($rt, 1_000), where +the parameter is the same number you pass to JS_NewContext. There +are many private functions created in JS.xs that are not exported +by default. | +
| JS::Object | + +Corresponds to JSObject* struct. There is not that much here +yet. This object is intended as a wrapper around the JSObject* stuct. +Support for tying hashes and possibly arrays with JS::Objects +is coming. | +
| [JS::Array] | + +I am not quite sure if this is needed. One might probably get away +with just JS::Object defined. If it's implemented, it will be +very much similar to JS::Object above. | +
All the modules above follow the convention of storing the variable +they return in the $this variable of the current class. So $JS::Context::this +will always be the last context created. Currently, this is where JS +API function that require contexts get it. +