CorbaScript

CorbaScript is an object-oriented scripting language designed to support interaction with Common Object Request Broker Architecture (CORBA) objects. It was developed to provide a flexible scripting environment for both client- and server-side CORBA application development, leveraging dynamic invocation and interface reflection capabilities.

CorbaScript is a dynamic, interpreted language whose syntax resembles that of C++ and Java. However, it integrates several design elements from dynamic languages such as Python and Smalltalk. Like those languages, CorbaScript treats all values as objects and supports dynamic type checking at runtime. Source code is translated into pseudocode executed by a dedicated Virtual Object-Oriented Machine that includes a simple reference-counting garbage collector.^[1]

Features

Basic scripting

CorbaScript includes typical scripting features:

Interpreted execution, suitable for both interactive mode and batch modes.
Runtime type checking.
Basic types including long, double, boolean, char, string, array, and dictionary.
Control structures such as if-else, while, do-while, and for-in.
Exception handling using throw, try-catch-finally.
User-defined procedures and modules (reusable script files).
Object-oriented programming constructs, including classes, multiple inheritance, and polymorphism.

The runtime includes a simple garbage collector based on reference counting.

CORBA integration

CorbaScript is tightly integrated with CORBA middleware and provides full access to both the Dynamic Invocation Interface (DII) and Dynamic Skeleton Interface (DSI):

Invocation of any CORBA object via DII, enabling scripting of CORBA clients.
Implementation of CORBA objects via DSI, allowing servers to be written in CorbaScript.
Full support for OMG Interface Definition Language (IDL)-defined data types, including complex types such as struct, union, sequence and array.
Access to in, out, and inout parameters using the CORBA DynAny API.
Type checking supported via the Interface Repository, with optional caching to improve performance.
Scripting access to the structure of IDL interfaces for dynamic discovery and reflection.

Advanced integration

CorbaScript also includes additional capabilities beyond basic scripting:

Dynamic loading of C libraries for native code integration.
Experimental support for interaction with a Java Virtual Machine.
Extensible runtime that allows embedding new functionality in C++.

Modules

CorbaScript allows any script to function as an importable module. Some standard modules include:

LIBC: dynamic access to standard C library functions.
IO: support for reading/writing binary and text files.
math: standard math operations.
POSIX: POSIX system calls like system() and fork().
socket: TCP/IP networking support.
IOR: simplified storage/retrieval of CORBA object references (IORs).
NSTools and CosNamingImpl: tools and implementation for managing the CORBA Naming service.
shell: base class for creating shell programs.
SMTP: a basic SMTP implementation.
time: date and time utilities.

Demonstrations

A number of example applications and tools are included in the CorbaScript distribution:

hello: a basic CORBA client/server "Hello World" application.
calc: a simple calculator service.
chat: a chat system implementing factory and observer design patterns.
component: client callback components using implicit connections.
computer: a distributed prime number service.
event: event channel implementation using the OMG Event Service.
grid: factory pattern for grid objects.
ir: navigation through the CORBA Interface Repository.
linked: demonstration of recursive object invocation.
naming: integration with the CORBA Naming Service.
test: argument type and passing mode demonstrations.
worker: client-server example using deferred (asynchronous) invocations.
remote_cssh: scripting engine interface using OMG IDL and shell-based remote invocation.
process: CORBA object access and factory pattern using URLs.

Examples

Hello Example

The following illustrates how CorbaScript can be used to interact with a CORBA object defined by the following OMG IDL interface:

interface Hello {
  void hello ();
  void display (in string message);
};

Using CorbaScript, you can invoke operations on a CORBA object implementing this interface:

>>> # the `hello` variable refers to a CORBA `Hello` object.
>>> hello = Hello("IOR:....")
>>> # invoking the 'hello' operation
>>> hello.hello()
>>> # invoking the 'display' operation
>>> hello.display("Hello World!")

>>> # obtain the CORBA Naming Service
>>> NS = CORBA.ORB.resolve_initial_references ("NameService")
>>> # resolve a name in the CORBA Naming Service
>>> object = NS.resolve(CosNaming.Name(CosNaming.NameComponent("anHelloObject","")))

>>> # easier syntax with automatic sequence conversion
>>> object = NS.resolve ([["anHelloObject",""]])

>>> # invoke operations on the resolved object
>>> object.display("Hello World!")

CorbaScript allows for easy and intuitive invocation of CORBA objects.

Implementing CORBA objects in CorbaScript

The following example demonstrates implementing the `Hello` interface in CorbaScript:

    # define a script class implementing the Hello interface
    class HelloImpl
    {
      # constructor
      proc __HelloImpl__(self) {}

      # implementation of the `hello` operation
      proc hello (self) {
        println ("The OMG IDL `hello` operation is invoked.")
      }

      # implementation of the `display` operation
      proc display (self, message) {
        println (message)
      }
    }

>>> # create an instance
>>> hello = HelloImpl()

>>> # local invocation
>>> hello.hello()
The OMG IDL `hello` operation is invoked.

>>> hello.display("Hello World!")
Hello World!

>>> # connect to CORBA and specify implemented interface
>>> CORBA.ORB.connect(hello, Hello)

>>> # register the object in the CORBA Naming Service
>>> NS = CORBA.ORB.resolve_initial_references ("NameService")
>>> NS.bind ([["anHelloObject",""]], hello._this)

This example demonstrates how CorbaScript simplifies both the invocation and implementation of CORBA objects. Additional examples, such as a CORBA Naming Service shell and a CORBA CosNaming implementation, are provided in the CorbaScript distribution.