MiniJava is a subset of the programming language Java as described in the Appendix of the Tiger book. Extended MiniJava (eMiniJava) is an extension to MiniJava that we use in this course. Each group of students will gradually develop a compiler for eMiniJava by implementing different stages of the compiler step-by-step.
int
, boolean
, String
, int array
and reference types (classes).The syntax of eMiniJava is given by the following BNF grammar:
Program | ::= | MainClass ( ClassDeclaration )* <EOF> |
MainClass | ::= | class Identifier { public static void main ( String [ ] Identifier ) { Statement } } |
ClassDeclaration | ::= | class Identifier ( extends Identifier )? { ( VarDeclaration )* ( MethodDeclaration )* } |
VarDeclaration | ::= | Type Identifier ; |
MethodDeclaration | ::= | public Type Identifier ( ( Type Identifier ( , Type Identifier )* )? ) { ( VarDeclaration )* ( Statement )* return Expression ; } |
Type | ::= | int |
boolean | ||
String | ||
int [ ] | ||
Identifier | ||
Statement | ::= | { ( Statement )* } |
if ( Expression ) Statement ( else Statement )? | ||
while ( Expression ) Statement | ||
System.out.println ( Expression ) ; | ||
Identifier = Expression ; | ||
Identifier [ Expression ] = Expression ; | ||
sidef ( Expression ) ; | ||
Expression | ::= | Expression ( && | || | == | < | + | - | * | / ) Expression |
Expression [ Expression ] | ||
Expression . length | ||
Expression . Identifier ( ( Expression ( , Expression )* )? ) | ||
<INTEGER_LITERAL> | ||
"<STRING_LITERAL>" | ||
true | ||
false | ||
Identifier | ||
this | ||
new int [ Expression ] | ||
new Identifier ( ) | ||
! Expression | ||
( Expression ) | ||
Identifier | ::= | <IDENTIFIER> |
The precise way to describe the semantics of a programming language is by using mathematical description, for example operational semantics (see e.g. Lecture 3 of PLC course). Since studying semantics is not officially part of the Compiler Construction course and some students may not have the background knowledge for mathematical semantics, we give an informal description of the language constructs.
The +
operator can be applied to both int
and String
operands.
When +
is applied to integers, the result is always integer.
When at least one operand is String
, the result is the concatenation of operands.
For concatenation of an int
to String
the string representation of the integer operand is considered.
5 + 5 => 10 "comp" + "iler" => "compiler" "comp" + 5 => "comp5" 5 + "comp" => "5comp"
These are the usual arithmetic operators and are applied to int
operands only.
Equality works on all pairs of operands that
int
, String
, boolean
, int[]
).The semantics of equality is
int
, boolean
and string
10 == 10 => true new A() == new A() => false new A() == new B() => false "comp" == 10 => // Type Error... "c" + "omp" == "co" + "mp" => true
System.out.println
can be used on int
, Strings
and Booleans
.
The sidef
keyword is used to call an expression (usually a method call) just for its side-effect, and to discard the result.
For example, if in a class we define
public int hi() { System.out.println("Hello World!"); return 0; }
then
sidef(this.hi());
will print Hello World!
on the standard output and will discard the result sidef(true);
will do nothing.
Similar to Java &&
and ||
are short-circuit boolean operators.
public static boolean printHi() { System.out.println("Hi"); return false; } public static boolean printBye() { System.out.println("Bye"); return true; }
printHi() && printBye() // "Hi" printBye() || printHi() // "Bye"
!
is the boolean negation.
new int[size]
, where size: int
returns a new array of size size
.
a[i]
, where a: int[]
and i: int
, returns the value stored in the i
th position of a
.
a.length
, where a: int[]
, returns the length of a
.
a[i] = j
, where a: int[]
, i: int
and j: int
, sets the value in the i
th position of a
to j
.
+
operator, which can be used with integers, strings, and between the two types."foobar".method()
are legal, they have no meaning in eMiniJava (they would result in a type error). The only operations allowed are: concatenating strings with other strings or with integers, printing strings, passing strings as argument and returning strings.new
binds tighter than .
(method call or .length
), which binds tighter than []
(array read), which binds tighter than any operator. So 1 + new Foo().bar().baz()[42]
means 1 + ( ( ( (new Foo()).bar()).baz())[42])
.1-2+3
means (1-2)+3
and not 1-(2+3)
. (Of course this does not matter for operators of different precedence).There are a set of MiniJava programs on the MiniJava webpage. Since eMiniJava is a superset of MiniJava, they are eMiniJava programs as well.