CSE 401/M501 24au 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 and described on the MiniJava web site. MiniJava is (almost exactly) a subset of Java and the meaning of a MiniJava program is given by its meaning as a Java program.

The MiniJava subset of Java has the following characteristics:

• A MiniJava program consists of a single class containing a static main method followed by zero or more other classes. There are no other static methods or variables.
• All classes in a MiniJava program are included in a single source file.
• The main class is only intended as a location to hold a single main method that is used to start program execution. This class cannot be instantiated or extended. Similarly, the String[] parameter to method main is included to provide syntactic compatibility with a main method in full Java, but since MiniJava does not include type String, this parameter cannot be accessed or used by a MiniJava program.
• Classes may extend other classes (except for the main class) and method overriding is included, but method overloading is not.
• There is no predefined Object class, and classes defined without an extends clause do not implicitly extend Object.
• The only types available are int, boolean, int[] and reference types (classes).
• "System.out.println(...);" is a statement and can only print integers - it is not a normal method call, and does not refer to a static method of a class.
• All methods are value-returning and must end with a single return statement.
• A method may be restricted to have at most 5 parameters in its argument list.
• The only other available statements are if, while, and assignment.
• MiniJava treats certain lexical strings like "true", "false", "main", "String" and others as reserved keywords to simplify scanning and parsing.
• There are other simplifications to keep the project size reasonable.

The full MiniJava grammar is given on the project web site and in the Appendix of Appel's Modern Compiler Implementation in Java (2nd ed). Look at the grammar carefully to see what is and is not included in the language subset. One difference from full Java is that any string in double quotes appearing in the grammar, like "true", should be treated as a reserved word for our MiniJava project, even if it can be used or redeclared as an identifier or has other possible uses in full Java. You should implement full MiniJava as described in the Grammar and on the MiniJava web site, except that, for our project, /* comments */ are not nested, i.e., you need to implement /* */ comments, but the first */ terminates any open comment regardless of how many /* sequences have appeared before it, as in standard Java. You also need to implement // comments.

There are two symbols in the grammar that are not otherwise specified. An <IDENTIFIER> is a sequence of letters, digits, and underscores, starting with a letter. Uppercase letters are distinguished from lowercase. An <INTEGER_LITERAL> is a sequence of decimal digits not starting with 0, or the number 0 by itself, denoting a decimal integer value.

Implementation

The implementation platform for the project is Java 21 with the JFlex/CUP scanner/parser tools. You are free to use any development environment you wish, but your resulting project should build (using ant and the basic javac/java tools) and run on the lab linux machines, attu, and/or the current lab Linux VM. It also should be possible to develop the project on a system with more recent versions of Java installed, but be sure that your code does not use any language features or extensions not present in Java 21, which is the version currently installed on the lab machines and that will be used to build and test your compiler.

If you use IntelliJ or Eclipse, you can create a suitable project by following the instructions in the starter code README files. Follow those instructions carefully. It will save you time, even if you are the impatient sort, and failing to follow instructions may produce a project that is misconfigured or that fails to work properly. In recent quarters, most groups have used IntelliJ, and the staff has more experience and can offer better support for that IDE. Some groups have successfully used VSCode in recent quarters, but the course staff has limited experience with this setup and you may be a bit more on your own if you encounter unexpected behavior with VSCode.

Extensions

The basic project requirements are small enough to be tractable for a one-quarter course project, but include enough to cover the core ideas of compiling object-oriented (as well as procedural) languages. If you are feeling ambitious and have the time, you are invited to add additional features of full Java to the language implemented by your compiler. Here are a few suggestions.

Some Simple Ideas

• Add additional arithmetic and relational operators for integers that are not included in the basic MiniJava specification.
• 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.
• Support methods with more than the required maximum of 5 parameters.
• 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 that do not return a value, 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.
• Add a top-level Object class that is implicitly the superclass of any class that does not explicitly extend another class.
• Add String literals, extend System.out.println to support Strings, and overload the + operator for String values.
• Add double as a numeric type, overload System.out.println to print doubles, and implement arithmetic operations for double, possibly including mixed-mode integer and floating-point arithmetic where integer values are automatically converted to double as needed.

More Sophisticated, but very interesting

• Support instanceof and type casts (which can require a runtime instanceof check). (This actually is surprisingly easy to do.)
• Support super. as a prefix in method calls.
• Add constructor declarations with optional parameters. To make this useful, you probably want to also include the use of super(...) at the beginning of the body of a constructor.
• 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 small amount of extra credit will be awarded for projects that go beyond the basic requirements.

Students in M 501 (the 5th-year Master's version of the course) will be required to implement one significant extension beyond the ones outlined above if they are using extra work on the project as their additional M 501 work. Suggested extensions and details will be provided later, and it will be possible to propose different choices. Students taking 401 can attempt these extensions for extra credit if desired. Students in M 501 can add additional extra credit features beyond the required extension if desired.