Interoperability

To wrap a Parrot class so that it can be used seamlessly from Amber, use an external parrot declaration.

If the external class is a built-in Parrot PMC class, you may optionally indicate this by using an external pmc declaration, which may enable Amber to generate more efficient code.

For example, the Amber kernel class INTEGER wraps the built-in Parrot PMC class Integer:

class INTEGER external pmc @@Integer ... end

A Parrot class that has been wrapped can be extended by adding one or more routines.

For example, the Amber kernel class INTEGER wraps and extends the built-in Parrot PMC class Integer:

class INTEGER external parrot @@Integer public -- queries abs -- Absolute value ... public -- iterators times(proc) -- proc: AGENT -- Execute 'proc' the same number of times as the value of 'current', -- or zero times if 'current' is negative. -- Example usage: 5.times(do print_line("Hello") end) ... end

To inherit from a Parrot class, first wrap it with an Amber class.

For example, the Amber kernel class CHARACTER inherits from the Amber class INTEGER which wraps the built-in Parrot PMC class Integer:

class CHARACTER inherit INTEGER ... end

You can write an Amber routine in PIR (Parrot Intermediate Representation), perhaps to gain access to low-level Parrot facilities. You can even add Amber preconditions and postconditions to a PIR routine.

Use the external keyword in the feature definition, as in this example from class INTEGER:

abs -- Absolute value external pir ".check_args(0, 'Integer.abs')" "result = new Undef" "result = abs self" end

If your routine has formal arguments, Amber inserts the appropriate '.param' declarations before your PIR code. Amber also encloses your PIR code between the following lines:

.local pmc result ... .return(result)

You can call a built-in Parrot routine with an Amber object as the call target, by preceding it with '@'.

The following Amber instructions both print "9". The first instruction calls the Amber infix "+" operator. The second instruction calls the built-in Parrot addition routine "__add":

print_line(5 + 4) print_line(5.@__add(4))

You can assign any Parrot object to an Amber entity, regardless of the language in which the Parrot object is implemented.

To create a Parrot object, precede the classname with '@@'. Then, assign it to an Amber object using the standard Assignment_instruction.

The following example creates an instance of the standard Parrot class Random and assigns it to a local variable 'r':

local r do r := @@Random ... end

You can optionally indicate a built-in Parrot PMC type by adding a dot before the classname, which may enable Amber to generate more efficient code.

At the time of writing (July 2005) it is not possible to pass arguments to the constructor of the Parrot object, but this restriction may be lifted in a future release of Amber.

You can assign any Amber object to a PIR (Parrot Intermediate Representation) variable.

Enclose the Amber classname in single-quotes or double-quotes, then use the PIR 'new' instruction with a local PIR variable of type pmc:

.local pmc x x = new 'MY_CLASS'

From PIR, you can call an Amber routine on an Amber object. You can also call an Amber routine on a Parrot object that has been extended using Amber.

Suround the Amber routine name by single-quotes or double-quotes. You can pass arguments to the routine (surrounded by parentheses). You need to include the parentheses even if there are no arguments:

.local pmc x .local pmc result x = new 'MY_CLASS' # 'MY_CLASS' is a user-written Amber class result = x.'my_routine'()