CPS710	Assignment 4
	Syntax Error Management	Due: December 14
UNDER CONSTRUCTION!

Preliminaries

• Add the file ParseAbortException.java to your interpreter. It gives you two exceptions that can be used to abort parsing. They are meant to be thrown by the parser and caught by TestHL. Note that this file contains a constant MAXERRORS which describes the maximum number of attempted error recoveries. You can modify this constant to test your work.

• Replace your TestHL.java file by this one which will catch exceptions, print them out, and recover from them. You will need to modify this file to add code to reset your scope and activation stacks.

Assignment

Runtime errors

Parsing errors

• Define 3 methods in your parser to be used to count parser errors and abort parsing when ParseAbortException.MAXERRORS are reached:

      // ResetErrors resets error count to 0 when parsing is restarted
      public static void ResetErrors() 
  
      // AnyErrors returns true iff. the parser encountered any errors
      public static boolean AnyErrors() 
  
      // IncreaseErrors increments error counter 
      // and throws a ParseAbortException if too many errors are encountered.
      public static void IncreaseErrors() throws ParseAbortException
  

• Define 2 error recovery productions to use inside your parser productions:

      // ErrorReplace production called when string received was interpreted as expected string.
      void ErrorReplace(String received, String expected) throws ParseAbortException
      
      // ErrorMissing production called when the token  was missing
      void ErrorMissing(String skipped) throws ParseAbortException
  

  and one error recovery method to be used in catch clauses:

      // ErrorSkipto called to consume all tokens up to the first one of kind 
      // The error message in e is also printed.
      void ErrorSkipto(int stoptoken, Exception e) throws ParseAbortException
      void ErrorSkipto(int stoptoken, Error e) throws ParseAbortException
  

  (The 2 separate definitions are needed to handle lexical errors which are errors and parse errors which are exceptions).

• Use ErrorReplace and ErrorMissing at least 3 times each in your parser to perform some shallow error recovery.

• Use ErrorSkipto at least 4 times in your parser to perform some deep error recovery. Don't forget to catch all errors and exceptions, including scanning errors, in the start production to make sure that only ParseAbortExceptions escape the parser.

• You will be asked to submit test files to demonstrate your error recovery strategies. This will be described in the Submit assignment section.

References

• JavaCC [tm]: Error Reporting and Recovery describes the infrastructure provided by JavaCC to support error handling.

• JavaCC [tm]: API Routines contains a comprehensive list of all classes, methods, and variables available for use by a JavaCC user.

Supporting Files

• Java files.

• Miscellaneous scripts

• Test files

Testing information

• For part 1, we will run the tests in the Test directory in the order shown in the scripts and in the A4 marking sheet. Note that:
  1. You do not have to have exactly the same error messages as in the results but you should catch the same errors and output approriate messages.
  2. The test files show the worth of each error in a comment. Altogether these tests add up to 71 marks, but part1 is only worth 50 marks, so you can get full marks for part 1 without catching all errors in the tests.

• For part2, we will
  1. Run the test file you submit and grade it along with your directions on your marking sheet.
  2. Change MAXERRORS to a different smaller value and rerun your file to make sure that your parser stops when it reaches MAXERRORS.

How to submit the assignment

• Prepare a test file called testerror.hl which contains 2 statements or expressions (i.e the start production should be called twice). Each of these 2 statements (or expressions) should contain 5 of the 10 errors for which you have implemented some error recovery. Altogether this should demonstrate your 10 error recoveries as described in the Parsing Errors section of this assignment.

• Zip up together all your source files and makefile and testerror.hl into A4.zip. Be sure to preserve the correct hierarchical structure of files when you zip everything up. Our makefile uses the default: everything in one directory except that all jjtree-generated files are in the AST subdirectory.

• Submit electronically A4.zip

• Print, fill out, and hand in the marking sheet ( word format or pdf format ).
  Note that this marking sheet asks you to list the error recovery strategies that you implemented. We cannot grade this assignment without it.

• If, while doing this assignment, you ended up improving your interpreter in ways that would improve your assignment 3 grade and you would like to have your 3rd assignment regraded using the interpreter that you are submitting for this assignment, print attach the following assignment 3 regrading sheet ( word format or pdf format ) to your assignment 4 marking sheet and we will regrade your 3rd assignment.