Objectives.

1. Support multiline comments.

2. Supportadditional tokens (reserved words, operators, and separators).

3. Support long and double

In this project, you will only be updating the hand-crafted scanner, which means that the only program files you will be modifying under $j/j–/src/jminusminus are TokenInfo.java and Scanner.java.

Run the following command inside the $j directory to compile the j– compiler with your changes.

$ ant clean com pile jar

Run the following command to compile (just scan for now) a j– program P.java using the j– compiler.

$ sh $j /j - -/ bin /j - - -t P . java

which only scans P.java and prints the tokens in the program along with the line number where each token appears.

Problem 1. (Multiline Comment ) Add support for multiline comment, where all the text from the ASCII characters /* to the ASCII characters */ is ignored.

  $j /j - -/ bin /j - -   -t   tests / M ultiL ineC om m ent . java

5 : public = public

5 : class = class

5 :   < IDENTIFIER >   =   M ultiL ineC om m ent 5 : { = {

9 :  public  = public

9 : static =  static

9 : void = void

9 :   < IDENTIFIER >   =   main

9 : ( = (

9 :   < IDENTIFIER >   =   S tring

9 :  [  = [

9 :  ]  = ]

9 :   < IDENTIFIER >   =   args

9 :  )  = )

9 :  {   = {

13 :  }  = }

14 :  }  = }

15 : < EOF > = < EOF >

Problem 2. (Reserved Words) Add support for the following reserved words.

 $j /j - -/ bin /j - - -t tests / R eserved W ords . java

1 : break = break

1 : case = case

1: catch =catch

2: continue =continue

2 : default = default

2: do =do

3: double =double

3 : final = final

3: finally =finally

4: for =for

4 :   im plem ents   =   im plem ents

4 : interface = interface

Problem 3. (Operators) Add support for the following operators.

$ $j /j - -/ bin /j - - -t tests / O perators . java 1 : ? = ?

1 :  ~   = ~

1 : != = !=

1 : / = /

1 :   /=   =   /=

2 :  -=  = -=

2 :  -- =  --

2 :  *=  = *=

2 : =

2 : =  = =

3 :  >>  = >>

3 : > >=  =  > >=

3 : > > >  =  > > >

3 : > > >= = > > >=

3 :  >=  = >=

4 :  <<  = <<

4 : < <= = < <=

4 :  <   = <

4 :  ^   = ^

4 : ^= = ^=

5 : | = |

5 :   |=   =   |=

5 :  || = ||

5 : & = &

5 : &= = &=

6 : < EOF > = < EOF >

Problem 4. (Separators) Add support for the separator : (colon).

$ $j /j - -/ bin /j - - -t tests / S eparators . java 1 : ; = ;

2 :  :  = :

3 :  , = ,

4 : . =   .

5 :  [  = [

5 :  {   = {

5 :  (  = (

5 :  )  = )

5 :  }   = }

5 :  ]  = ]

6 : < EOF > = < EOF >

Problem 5. (Literals) Add support for (just decimal for now) long and double literals.

< int_literal >   =   0   |   (1 -9)   {0 -9}   //   decim al

< long_literal > = < int_literal > ( l | L )




< digits > = (0 -9) {0 -9}




< exponent > = ( e | E ) [(+ | -)] < digits >




< suffix > = d | D




< double_literal > = < digits > . [< digits >] [< exponent >] [< suffix >]

| . < digits > [< exponent >] [< suffix >]

| < digits > < exponent > [< suffix >]

| < digits > [< exponent >] < suffix >

$ $j /j - -/ bin /j - - -t tests / L iterals . java

1 :   < IN T _LIT E R A L >   =   0

1 :   < IN T _LIT E R A L >   =   2

1: < IN T _LIT E R A L >   =   372

2:< L O N G _L IT E R A L > = 1996 l

2 : < L O N G _L IT E R A L > = 777 L

2:< D O U B L E _L IT E R A L > = .3 D

3:< D O U B L E _L IT E R A L > = 14

3 : < D O U B L E _L IT E R A L > = 6.022137 e +23

3:< D O U B L E _L IT E R A L > = 1e -9 d

4: < EOF > = < EOF>

Files to Submit

1. j–.tar.gz(j– source tree as a single gzip file)
2. txt (projectreport)

Before you submit:

• Make sure you create the gzip file j–.tar.gzsuch that it only includes the source files and not the binaries, which

• $  cd $j /j --
  
  $  ant clean
  
  $ cd ..
  
  $ tar - cvf j - -. tar j - -/*
  
  $ gzip j - -. tar

• Makesure your report isn’t too verbose, doesn’t contain lines that exceed 80 characters, and doesn’t contain

1. Hours to complete the project: 24 hours

2. Provide a short description of how you approached each problem, issues you
encountered, and how you resolved those issues.

Report text：

1. Hours to complete the project: 24 hours

2. Provide a short description of how you approached each problem, issues you 
encountered, and how you resolved those issues.

Part I (Additions to JavaCC Scanner)

Problem 1 (Multiline Comment): 
Problem 1 just add a skip comment as single-line skip comment to skip the 
multiline comment in j--.jj.
(SKIP: {<MULTI_LINE_COMMENT: "/*" (~["*"])* "*" ("*" | (~["*","/"] 
(~["*"])* "*"))* "/">})

Problem 2 (Reserved Words): 
Problem 2 just add some reserved words in the Token at j--.jj. Please pay 
attention to the "default", you can just use DEFAULT to identify it, 
because lexical token name "DEFAULT" is the same as that of a lexical 
state. So I just change "DEFAULT" to "DEFAULt" (lower-case T).

Problem 3 (Operators):
In Problem 3, I define the operators in Token first, then define them in
different expression method, for instance, "/=" should be define in 
assignment expression, and "||" should be define in Conditional-Or-
Expression. Just like what we did in Parser.

Problem 4 (Separators): 
In Problem 4, I define the colon separator in Token at j--.jj first, and 
then define it in conditionalExpression method.

Problem 5 (Literals):
In Problem 5, I define the double and long literals in Token at j--.jj 
according to the format that problem 5 provided.

Part II (Additions to JavaCC Parser)

Problem 6 (Long and Double Basic Types):
For problem 6, I wrote the java code for double and long literals. Then,
I defined their types in basictype().

Problem 7 (Operators):
In j--.jj, I defined the operators in different expression method. For 
instance, "/=" should be define in assignment expression, and "||" should 
be define in ConditionalOrExpression. Just like what we did in Parser.

Problem 8 (Conditional Expression): 
In j--.jj, I created a new method called conditionalExpression and 
defined them in this method. In conditionalExpression method, assignment-
Expression() will be called and check the colon token is there, then call
conditionalExpression to get the conditional expression and return JCon-
ditionalExpression object.

Problem 9 (Switch Statement):
In j--.jj, I created a JSwitchBlockStatement J-class to represent the 
switch block, and also created the J-class JSwitchStatement for the switch
statement. I defined the "switch" in the statement(). Then I created the 
switchBlockStatementGroup() for JSwitchBlockStatement and switchLabel() to
check the expression.

Problem 10 (Do-While Statement):
In problem 10, I added a do statement with while statement in statement() 
at j--.jj.

Problem 11 (For Statement): 
In problem 11, I followed what I did in parser to added the for statement
in statement(). Please be careful that you should update the statement 
expression so that an expression can be an instanceOf a pre-decrement or 
post-increment object.

Problem 12 (Exception Handlers): 
I wrote some J-class. JThrowStatement is for the throw statement. JCatch is
for the try statement and JCatch is for the catch statement. And in the 
statement(), they all represent exception handlers so I do not separated
them. Moreover, I also defined throw in member declaration and interface-
member-declaration.

Problem 13 (Interface Type Declaration): 
In j--.jj, I defined the interface in typeDeclaration method. Then I 
created the interfaceDeclaration() and interfaceBody() method as what
I did in parser. And I also defined the implement in class declaration
and interface declaration.

3. Did you receive help from anyone? List their names, status (classmate, 
CS451/651 grad, TA, other), and the nature of help received.

Name Status Help Received
---- ------ -------------

... ... ...

4. List any other comments here. Feel free to provide any feedback on how
much you learned from doing the assignment, and whether you enjoyed
doing it.

The homework 4 is tough for me. It is based on the completed homework 3,
and do the same things in j--.jj as what you did in parser. However,
I did not finish the homework 3 very well so I spent a lot of time to do
this assignment and fixed the works.