NetRexx User's Guide, version 2.05 Copyright (c) IBM Corporation, 2005. All rights reserved. © | Draft of 14 Jan 2005
[previous | contents | next]

## Using the NetRexxA API

As described elsewhere, the simplest way to use the NetRexx interpreter is to use the command interface (NetRexxC) with the `-exec` or `-arg` flags. There is a also a more direct way to use the interpreter when calling it from another NetRexx (or Java) program, as described here. This way is called the NetRexxA Application Programming Interface (API).

The `NetRexxA` class is in the same package as the translator (that is, `COM.ibm.netrexx.process`), and comprises a constructor and two methods. To interpret a NetRexx program (or, in general, call arbitrary methods on interpreted classes), the following steps are necessary:

1. Construct the interpreter object by invoking the constructor `NetRexxA()`. At this point, the environment’s classpath is inspected and known compiled packages and extensions are identified.
2. Decide on the program(s) which are to be interpreted, and invoke the NetRexxA `parse` method to parse the programs. This parsing carries out syntax and other static checks on the programs specified, and prepares them for interpretation. A ‘stub’ class is created and loaded for each class parsed, which allows access to the classes through the JVM reflection mechanisms.
3. At this point, the classes in the programs are ready for use. To invoke a method on one, or construct an instance of a class, or array, etc., the Java reflection API (in `java.lang` and `java.lang.reflect`) is used in the usual way, working on the `Class` objects created by the interpreter. To locate these `Class` objects, the API’s `getClassObject` method must be used.

Once step 2 has been completed, any combination or repetition of using the classes is allowed. At any time (provided that all methods invoked in step 3 have returned) a new or edited set of source files can be parsed as described in step 2, and after that, the new set of class objects can be located and used. Note that operation is undefined if any attempt is made to use a class object that was located before the most recent call to the `parse` method.

Here’s a simple example, a program that invokes the `main` method of the `hello.nrx` program’s class:

      -- Try the NetRexxA interface
      options binary
      import COM.ibm.netrexx.process.NetRexxA

      interpreter=NetRexxA()             -- make interpreter

      files=[’hello.nrx’]                -- a file to interpret
      flags=[’nocrossref’, ’verbose0’]   -- flags, for example
      interpreter.parse(files, flags)    -- parse the file(s), using the flags

      helloClass=interpreter.getClassObject(null, ’hello’) -- find the hello Class

      -- find the ’main’ method; it takes an array of Strings as its argument
      classes=[interpreter.getClassObject(’java.lang’, ’String’, 1)]
      mainMethod=helloClass.getMethod(’main’, classes)

      -- now invoke it, with a null instance (it’s static) and an empty String array
      values=[Object String[0]]

      loop for 10    -- let’s call it ten times, for fun...
        mainMethod.invoke(null, values)
      end

Compiling and running (or interpreting!) this example program will illustrate some important points, especially if a trace all instruction is added near the top. First, the performance of the interpreter (or indeed the compiler) is dominated by JVM and other start-up costs; constructing the interpreter is expensive as the classpath has to be searched for duplicate classes, etc. Similarly, the first call to the parse method is slow because of the time taken to load, verify, and JIT-compile the classes that comprise the interpreter. After that point, however, only newly-referenced classes require loading, and execution will be very much faster.

The remainder of this section describes the constructor and the two methods of the NetRexxA class in more detail.

#### The NetRexxA constructor

Syntax:

      NetRexxA()

This constructor takes no arguments and builds an interpeter object. This process includes checking the classpath and other libraries known to the JVM and identifying classes and packages which are available.

#### The parse method

Syntax:

      parse(files=String[], flags=String[]) returns boolean

The parse method takes two arrays of Strings. The first array contains a list of one or more file specifications, one in each element of the array; these specify the files that are to be parsed and made ready for interpretation.

The second array is a list of zero or more option words; these may be any option words understood by the interpreter (but excluding those known only to the NetRexxC command interface, such as `time`).[1] The parse method prefixes the `nojava` flag automatically, to prevent `.java` files being created inadvertently. In the example, `nocrossref` is supplied to stop a cross-reference file being written, and `verbose0` is added to prevent the logo and other progress displays appearing.

The `parse` method returns a boolean value; this will be 1 (true) if the parsing completed without errors, or 0 (false) otherwise. Normally a program using the API should test this result an take appropriate action; it will not be possible to interpret a program or class whose parsing failed with an error.

#### The getClassObject method

Syntax:

      getClassObject(package=String, name=String [,dimension=int]) returns Class

This method lets you obtain a Class object (an object of type `java.lang.Class`) representing a class (or array) known to the interpreter, including those newly parsed by a parse instruction.

The first argument, `package`, specifies the package name (for example, ‘`com.ibm.math`’). For a class which is not in a package, `null` should be used (not the empty string, `’’`).

The second argument, `name`, specifies the class name (for example, ‘`BigDecimal`’). For a minor (inner) class, this may have more than one part, separated by dots.

The third, optional, argument, specifies the number of dimensions of the requested class object. If greater than zero, the returned class object will describe an array with the specified number of dimensions. This argument defaults to the value 0.

An example of using the `dimension` argument is shown above where the `java.lang.String[]` array Class object is requested.

Once a Class object has been retrieved from the interpreter it may be used with the Java reflection API as usual. The Class objects returned are only valid until the parse method is next invoked.

Footnotes:

[1] | Note that the option words are not prefixed with a ‘`-`’.

[previous | contents | next]