Special BETA Constructs for JVM/CLR Support

Special Prefix Patterns

1. ExternalClass
   The pattern ExternalClass is used to declare classes originating from outside BETA, e.g. Java or C# in BETA syntax. This is currently needed to allow the BETA compiler to support type-safe use of non-BETA classes. As this can be quite tedious to do by hand, a tool has been made, that will read the binary external classes and emit BETA declarations corresponding to them. In a future version of the BETA compiler, this may be automated.
   See ExternalClass below for specific usage of ExternalClass.
2. class
   The pattern class is used to restrict a pattern to class usage only. As a BETA pattern can be used as both a class/type and as a method, normally code will be generated for both usages. Using class as prefix for a pattern will make the compiler not generate code for the usage of the pattern as a method.
   class is only used for patterns implementing functionality in BETA, i.e. not for classes in Java/.NET.
3. proc
   The pattern proc is used to restrict a pattern to method usage only. As a BETA pattern can be used as both a class/type and as a method, normally code will be generated for both usages. Using proc as prefix for a pattern will make the compiler not generate code for the usage of the pattern as a class.
   proc is used both for patterns implementing methods in BETA and for methods in external classes.
4. cons
   Using cons as a prefix of a pattern tells the compiler to generate special code for the pattern to be used as a constructor. These methods have special internal names and calling conventions in the generated byte codes. Specifying cons implies proc, i.e. the pattern cannot be used as a class.
   There may be specified more than one constructor, as long as they differ in enter lists (corresponding to signatures in the byte code).
   cons can be used both in a BETA pattern implementing functionality to be used from BETA and/or external languages, and in ExternalClass declarations.
   However, there is a problem in the current implementation: If the constructor is to be called from BETA code, it should include a local variable of the same type as the class it is creating, and the constructor should return this value, e.g.:

   Foo: 
     (# ...
        create: cons
          (# result: ^Foo;
          exit result[]
          #);
     #)
   

   On the other hand, if the constructor is to be called from outside BETA, you should not declare the variable and the exit part, since this will lead to illegal byte code.
   See Constructors below for further information on how to specify and use constructors in BETA patterns.
5. static_proc
   Using static_proc as a prefix for a method in an ExternalClass specification (as opposed to just proc) tells the BETA compiler that this is a static method, which has a special calling convention in the byte code, and which is invoked on the external class itself and not on an object.
   Notice that specifying static_proc as a prefix of a pattern implementing functionality in BETA is not supported; the compiler will currently not complain, but generate non-functional (illegal) byte code.
6. static_cons
   Using static_cons as a prefix for a method in an ExternalClass specification (as opposed to just cons) tells the BETA compiler that this is a static constructor which has a special calling convention in the byte code, and which is invoked on the external class itself and not on an object.
   Notice that specifying static_cons as a prefix of a pattern implementing functionality in BETA is not supported; the compiler will currently not complain, but generate non-functional (illegal) byte code.

Specifying JVM Packages

PACKAGE 'org.foo.bar';

External Class Declarations

String: ExternalClass
  (#
     _init: cons (* constructor *)
       (# result: ^String;
       exit result[]
       #);
     ...
     _init_ArrayOfC: cons (* constructor *)
       (# result: ^String;
          arg1: [0]@char;
       enter (arg1[])
       exit result[]
       #);
     ...
     compareTo_String: proc (* overloaded compareTo *)
       (# result: @int32;
          arg1: ^String;
       enter (arg1[])
       do 'compareTo' -> procname;
       exit result
       #);
     compareTo_Object: proc (* overloaded compareTo *)
       (# result: @int32;
          arg1: ^Object;
       enter (arg1[])
       do 'compareTo' -> procname;
       exit result
       #);
     ...
  do 'java/lang/String' -> className;
#)

String: ExternalClass
  (# ...
     _init_ArrayOfChar: cons (* constructor *)
       (# result: ^String;
          arg1: [0]@char;
       enter (arg1[])
       exit result[]
       #);
     _init_char_int32: cons (* constructor *)
       (# result: ^String;
          arg1: @char;
          arg2: @int32;
       enter (arg1, arg2)
       exit result[]
       #);
     ...
     CompareTo_Object: proc (* overloaded CompareTo *)
       (# result: @int32;
          arg1: ^Object;
       enter (arg1[])
       do 'CompareTo' -> procname;
       exit result
       #);
     CompareTo_String: proc (* overloaded CompareTo *)
       (# result: @int32;
          arg1: ^String;
       enter (arg1[])
       do 'CompareTo' -> procname;
       exit result
       #);
     ...
  do '[mscorlib]System.String' -> className
#)

Specializations of ExternalClasses

• If you specify the do-part of an ExternalClass or specialization thereof (typically specifying the className), the class is considered external, and the compiler will not generate code for the class.
  If you specify an empty do-part, a default className is assumed.
  For an external class Foo:

  Foo: ExternalClass
    (# ...
    do (* empty do part *)
    #)
  

  the default className will be:
  • For Java: Foo, i.e. a class Foo in the default (empty) Java package
  • For .NET: [Foo]Foo, i.e. a class Foo in assembly Foo (typically file Foo.dll).
• If no do-part is specified, the pattern is considered a BETA specialization of the external class, and the compiler will generate code for the class and its methods.

JVM Interfaces

do '|.....' -> className;

CLR value types

do '@...' -> className

Constructors

• _init
  Specifying a pattern with the special pattern name _init (one underscore) is a rudimentary way of declaring one constructor in a BETA pattern. It is now deprecated, as it only allows for the declaration of one constructor. Use the cons prefix instead.
• cons The special prefix cons was described above, and is the recommended way to specify an instance constructor in a BETA pattern or ExternalClass.
• static_cons The special prefix static_cons was described above, and is the recommended way to specify an static constructor in an ExternalClass declaration.
• __init Specifying a pattern with the special pattern name __init (two underscores) is a way of declaring one constructor, which does not require a surrounding object as argument, when called from outside BETA. Normal constructors have a hidden (synthetic) first argument being the surrounding BETA object. This must be supplied when the constructor is invoked.
  The surrounding object is still needed, though, and to set up this, a special low-level primitive is suplied, that must be called inside the do-part of the __init pattern, preferably as the first thing done:
  • %setup 'betaenv'
  This special statement will make the BETA compiler do two things:
  1. Create a betaenv object
  2. Set up the surrounding object reference of the object being created to be this betaenv object.
  There are a number of problems and limitations with the current implementation of parameterless constructors:
  • The name __init does not very well signal that this is a special pattern. Should probably be changed to, e.g. a prefix default_cons.
  • The compiler ought to set up the betaenv object automatically
  • You should only specify an __init in a BETA library to be called from Java/.NET, not as part of an ExternalClass declaration
  • If you specify an __init you should not specify any _init and/or cons patterns. If you do so, currently the parameterles constructor will not be generated. As a side effect, a pattern containing an __init cannot be instantiated using standard BETA syntax &Foo[] -> .... See Instantiation below.
  • You should only specify __init in an outer-most pattern, i.e. one that is declared in LIB:attributes. For inner classes, the surrounding object is automatically set up. If you specify an __init for an inner pattern, illegal bytecode will result.
  • Using multiple BETA patterns each with an __init constructor may lead to multiple betaenv instances. This should not be a problem.
  • You should not specify an __init constructor for a BETA pattern, that has another BETA pattern as prefix. This will currently cause illegal byte code to be generated. Instead, make a dynamic part object containing an instantiation of the pattern, you would have liked to use a prefix, and delegate calls for the prefix into this local object.
  • You should not declare any static references ("static" here being in the BETA meaning, e.g. X: @P, not to be confused with static variables in Java/.NET) in a pattern having an __init constructor. The problem is that the compiler will currently try to instantiate the static references before the betaenv is set up. This only pertains to non-simple patterns; basic types like integer, char, etc. can be specified statically.

Instantiation

• Use &Foo[] -> ...
  This is the normal BETA instantiation mechanism. For a BETA pattern, this creates the object, and sets up the surrounding object in the usual BETA way. This means that the normal BETA constructor (either implicit or a declared _init (one underscore) or cons without declared arguments) is called.
  If Foo is a specialization of an ExternalClass, this instantiation will lead to a call of a parameterless constructor in the external class.
• Use (arg1, arg2, ..., argN) -> &Foo -> ... This is an extension of the normal BETA instantiation mechanism. The effect is like the one described above, except that a constructor with declared arguments (arg1, arg2, ..., argN) is called. If Foo is a normal BETA pattern, it must have a declared _init (one underscore) or cons with the specified parameter list for this to work.
• Call method declared as cons on object
  This is the prefered method for instantiating objects via an instance constructor in an ExternalClass. However, it can be used internally in BETA too, see cons above.
• Call method declared as static_cons on ExternalClass This is the prefered method for instantiating objects via a static constructor in an ExternalClass. It can not be used internally in BETA, see static_cons above.

Overloaded Methods

foo: ExternalClass
  (# bar_I: proc
       (# i: @integer
       enter i	
       do 'bar' -> procname;
       #);
     bar_C: proc
       (# c: @char
       enter c
       do 'bar' -> procname;
       #);
  #);

Not Yet Specifiable

• Static fields
• .NET enumerations