You should extend MiniJava's syntax to allow the following (all of which are legal in full Java too):
double is a legal (base) type.
You should follow the precedence and associativity rules of regular Java for these extensions. It's OK to use CUP's precedence declarations to achieve this.
It's OK to have one shift/reduce conflict in your CUP grammar, for the "dangling else" problem. Add the "-expect 1" option before the minijava.cup argument in the Makefile to build Parser/parser.java if you decide to accept this shift/reduce conflict. (FYI, in making the sample solution, it was not possible to find a way to revise the CUP grammar specification to avoid this conflict.)
You should add new AST classes and/or modify existing AST classes so that you can represent the new MiniJava constructs. You should define the appropriate toString operations on these classes so that they can be pretty-printed in a form that is syntactically legal and produces the same AST if it is parsed in again. (Note: Pay attention to this requirement, as it will be used during grading to check the correctness of your parse.) The other operations required of AST nodes, e.g. typechecking, evaluating, and lowering, you should implement by throwing UnimplementedError exceptions.
You only need to get the parser to work (and keep the extended scanner working). You do not need to do anything to enforce typechecking rules or other semantic-analysis constraints on the input program.
Do the following:
1. Extend the specification of MiniJava's syntactic structure to describe the extended language, in the same style. (You can assume precedence and associativity is specified separately, and it is OK to define a grammar that is ambiguous with respect to the "dangling else" problem.)
2. Add and/or modify classes in the AST subdirectory to represent the extended language.
3. Extend Parser/minijava.cup to parse the extended language and construct the abstract syntax tree representing the parsed program.
4. Develop test cases that demonstrate that your extended parser and AST classes work, both in cases that should now be syntactically legal and in cases that should still be syntactically illegal. (Since the parser quits at the first error, you'll likely need several illegal test case files to test the different illegal cases.) You do not need to check for lexical errors, just syntactic errors. The SamplePrograms directory contains some files that should parse after you make your changes; some of the files should parse successfully with the initial version of the MiniJava compiler.
Recently Asked Questions
- Can you explain recursion to be able to solve any leetcode hard problem. Thanks
- Define,discussand give examples of: A. Input Stream (c++) B. Output Stream(c++)
- Suppose you have a swarm where 80% of all nodes are behind NATs for which no traversal techniques work. Your client wishes to maintain open connections to at