CSE P 501 Su04 - MiniJava

Overview

The course project is to implement the MiniJava language specified in the Appendix of Appel's Modern Compiler Implementation in Java, 2nd edition. MiniJava is a subset of Java and the meaning of a MiniJava program is given by its meaning as a Java program.

We will make one additional simplification: arrays do not need to be implemented. That means that the basic project requirements do not include the following productions from the MiniJava grammar:

Type ::= int [ ]
Statement ::= id [ Exp ] = Exp ;
Exp ::= Exp [ Exp ] | Exp . length | new int [ Exp ]

The array parameter syntax is still included in the main method declaration, but the parameter and its declaration are ignored. All other features of MiniJava, including inheritance (extends) are included.

Extensions

The basic project requirements are small enough to be tractable in a course project, but include enough to cover the core ideas of compiling an object-oriented (as well as procedural) language. If you are feeling ambitous and have the time, you are invited to add additional parts of Java to the language. Here are a few suggestions.

Some Simple Ideas

• Add comments for source programs. Comments that begin with // and continue to the end of the line should be simple. Handling /* ... */ comments that can span multiple lines is more difficult, but not too hard.
• Add additional binary arithmetic and relational operators for integers.
• Add null as a constant expression and support == and != for object reference types.
• Allow return statements anywhere in a method.
• Allow calls of local methods without the explicit use of this.
• Relax the ordering of declarations so that variables can be declared anywhere in a method body.
• Allow initialization of variables in declarations.
• Add void methods, a return statement with no expression, and appropriate type checking rules.
• Support public and private declarations on both methods and instance variables, and check to ensure that access restrictions are not violated.

Adding an additional numeric type like double would not be particularly interesting, since there is practically no difference in how the compiler handles ints and doubles. However, adding String literals and the concatenation (+) operator would be interesting.

More Sophisticated, but very interesting

• Support instanceof and type casts (which can require a runtime instanceof check).
• Support super. as a prefix in ordinary method calls.
• Add constructor declarations with optional parameters. To make this useful, you probably want to include the use of super(...) at the beginning of the body of a constructor.
• Support arrays of ints.
• Support arrays of objects (no harder to implement than arrays of ints, except the type checking rules are more interesting).

Of the suggested extensions, adding instanceof, type casts, and super. are particularly instructive.

Some extra credit will be available for projects that go beyond the basic requirements.