The language represented by these files is BetaJava, as described in
the paper "Super and Inner - Together at Last!" [1] available at
http://www.cs.utah.edu/plt/publications/ . It is an extension of
ClassicJava [2]. The work of making a version of ClassicJava for the
PLT reduction semantics tool [3] was done by Richard Cobbe.

The language here is slightly different from that in Section 4 of the
paper. The main difference is that inner does not take a method name,
but rather acts like inner in BETA - it calls the next version of the
method it is in. Also, instead of tagging methods with java or beta,
java behavior is the default and the beta keyword is added to give a
method beta-like behavior.

Here is the language provided:

reserved ::= class | new-v | new | null | super | this | cast | true |
             | false | if | int | bool | Object | <binary-prim> |
             | <unary-prim> | beta | inner

binary-prim ::= + | - | * | == | and | or

unary-prim ::= zero? | null? | not

id ::= any symbol except a <reserved>

defn-name ::= <id>

class-name ::= <defn-name> | Object

type-name ::= <class-name> | int | bool

field-name ::= <id>

method-name ::= <id>

arg-name ::= <id>

program ::= ( ( <defn>* ) <expr> )

defn ::= ( class <defn-name> <class-name> ( <field>* ) ( <method>* ) )

field ::= ( <type-name> <field-name> )

method ::= ( <type-name> [beta] <method-name> ( <arg>* ) <expr> )

  ;;  arg ::= ( <type-name> <arg-name> )

  ;;  expr ::= ( new <class-name> <expr>* )
  ;;         | <id>
  ;;         | this
  ;;         | null
  ;;         | ( ivar <expr> <field-name> )
  ;;         | ( send <expr> <method-name> <expr>* )
  ;;         | ( super <method-name> <expr>* )
  ;;         | ( inner <expr> <expr>* )
  ;;               Note that the first expr of inner is the else expression
  ;;         | ( cast <class-name> <expr> )
  ;;         | <integer literal>
  ;;         | true
  ;;         | false
  ;;         | ( <binary-prim> <expr> <expr> )
  ;;         | ( <unary-prim> <expr> )
  ;;         | ( if <expr> <expr> <expr> )

There are eight scheme files included here. The most important is
betajava.ss which contains the language and reductions needed for use
with the PLT reducer. betajava.ss is a module that provides 3
things (so you will need to (require "betajava.ss") to use them). The
first, betajava-syntax is the betajava language. The next
two are functions that return the reductions for the BetaJava
language. The reason that they are functions is that BetaJava
programs (like ClassicJava ones) are in two parts: definitions, and
an expression to execute. The reduction rules depend on the program
definitions, thus the functions that provide the BetaJava reductions
need a program. The first, betajava-reductions/program takes a
BetaJava program (as an S-expression) and returns the list of
reduction rules based on that program. The second,
betajava-reductions-expr/program returns two values. The first value
is the list of reductions. The second is the final expression part of
the program. This lets you immediately feed it into traces, for
example:
(let ([(reds expr) (betajava-reductions-expr/program program)])
     (traces betajava-syntax reds expr))

Here is a listing of the other files included and a brief description
of what they do:

ast.ss
Defines the AST types used for the BetaJava system.

elaboration.ss
Code that type-checks and elaborates the program.

environment.ss
Functions for a standard environment data type.

examples.ss
Some example programs to try

parser.ss
Parser for the S-expression based syntax of BetaJava

program.ss
Defines program type and functions that act upon it.

reduction.ss
Contains language and reductions for BetaJava

---------------------------------

[1] D. S. Goldberg, R. B. Findler, M. Flatt. Super and Inner -
    Together at Last! In Proc. ACM Conference on Object-Oriented
    Programming, Systems, Languages and Applications, Oct 2004.

[2] M. Flatt, S. Krishnamurthi, and M. Felleisen. Classes and
    mixins. In Proc. ACM Symposium on Principles of Programming
    Languages, pages 171-183, Jan. 1998.

[3] J. Matthews, R. B. Findler, M. Flatt, and M. Felleisen. A visual
    environment for developing context-sensitive term rewriting
    systems. In Proc. International Conference on Rewriting
    Techniques and Applications, June 2004.