PA4.jj

/*
 * This is PA4.jj file.
 * It will build a tree we can traverse using the Visitor pattern!
 * The language is MiniC, which is the subset of MiniJava
 * consisting of only MethodDecls (i.e. no classes or instance variables)
 * and the only types are int and boolean
 * and the only statments are Assign, If, and Print
 * all of the expressions are available except for && 
 * that is <, +,-,*  integerLiterals and IdentifierExpressions
 */


 /*
Video 1: https://brandeis.zoom.us/rec/share/tXjiXi99E29EppXPXkjg-_GbBS2bEX1hIlfQmzDHubxsfvU4SRZtAtfzJrr9qr6D.hJiFx2GHakf4fQIB?startTime=1710909695000
Video 2https://brandeis.zoom.us/rec/share/tXjiXi99E29EppXPXkjg-_GbBS2bEX1hIlfQmzDHubxsfvU4SRZtAtfzJrr9qr6D.hJiFx2GHakf4fQIB?startTime=1710910230000

Team: Xin Chen
 */

options {
  IGNORE_CASE=false;
}

PARSER_BEGIN(PA4)
import syntaxtree.*;
import java.io.*;

public class PA4 {

  /** Main entry point. */
  public static void main(String args[]) {
    
    try {
        
        PA4 t = new PA4(new FileInputStream(args[0]));
        Program n = t.Start();

      /*
      System.out.println("\n\nPretty Printing the Abstract Syntax Tree");
      Visitor v1 = new AST_Visitor();  // pretty prints the Abstract Syntax Tree
      n.accept(v1, 0);
      */
      

/* uncomment this only for PA4b  
      System.out.println("\n\nPretty Print the Program");
      Visitor v2 = new PP_Visitor();  // pretty prints the MiniC program
      String s = (String) n.accept(v2, 0);
      //System.out.println("#include <stdio.h>\n#include <stdbool.h>\nvoid print(int n){printf(\"%10d\\n\",n);}");
      System.out.println(s);
    */

 


/* uncomment this only for MiniC2Pascal translator 
      //System.out.println("\n\nPretty Print the Program");
      Visitor v2 = new Pascal_Visitor();  // pretty prints the MiniC program
      String s = (String) n.accept(v2, 0);
      System.out.println("PROGRAM Demo;\n");
      System.out.println(s);
      System.out.println("BEGIN\n main(1);\nEND.");
*/

/* uncomment this only for PA4c and PA4d 
      System.out.println("\n\nGenerating Symbol Table");
      SymbolTableVisitor v3 = new SymbolTableVisitor(); // generates a SymbolTable
      SymbolTable st = v3.symbolTable;
      n.accept(v3,"");
      System.out.println(st);
      */

      /* uncomment this only for PA4c and PA4d */
      System.out.println("\n\nGenerating Symbol Table");
      SymbolTableVisitorModified v3 = new SymbolTableVisitorModified(); // generates a SymbolTable
      SymbolTableModified st = v3.symbolTable;
      n.accept(v3,"");
      System.out.println(st);
      


/* uncomment this only for PA4d */
      System.out.println("\n\nType Checking");
      TypeCheckingVisitor v4 = new TypeCheckingVisitor(st);
      n.accept(v4,"");
      System.out.println(v4.num_errors+" type errors found");

      //System.out.println("\n\nDone!");
      

      /* Only for C2Python_Visitor 
      System.out.println("\n\nPython Print the Program");
      Visitor v2 = new C2Python_Visitor();  // pretty prints the MiniC program
      String s = (String) n.accept(v2, 0);
      System.out.println(s);
      */

    } catch (Exception e) {
      System.out.println("Oops.");
      System.out.println(e.getMessage());
      e.printStackTrace();
    }
  }


}

PARSER_END(PA4)

SKIP: /* Whitespace */
{
  "\t"
| "\n"
| "\r"
| " "
}

TOKEN:
{
   <PUBLIC:     "public">
|  <PREFACE:    "#include <stdio.h>\n#include <stdbool.h>\nvoid print(int n){printf(\"%10d\\n\",n);}">
|  <CLASS:      "class">
|  <STATIC:     "static">
|  <VOID:       "void">
|  <STRING:     "String">
|  <EXTENDS:    "extends">
|  <RETURN:     "return">
|  <INT:        "int">
|  <BOOLEAN:    "boolean">
|  <TRUE:       "true">
|  <FALSE:      "false">
|  <IF:         "if">
|  <ELSE:       "else">
|  <WHILE:      "while">
|  <PRINTLN:    "System.out.println">
|  <LENGTH:     "length">
|  <THIS:       "this">
|  <MAIN:       "main">
|  <NEW:        "new">
|  <BANG:       "!">
|  <COLON:      ":">
|  <SEMICOLON:  ";">
|  <COMMA:      ",">
|  <DOT:        ".">
|  <EQUALS:     "=">
|  <AND:        "&&">
|  <LT:         "<">
|  <GT:         ">">
|   <LPAREN:    "(" >
|   <RPAREN:    ")" >
|   <LBRACKET:    "[" >
|   <RBRACKET:    "]" >
|   <LCURLY:    "{" >
|   <RCURLY:    "}" >
|  <PLUS_OP:    "+" >
|  <MINUS_OP:   "-" >
|  <TIMES_OP:    "*" >
|  <NUMBER:    (["0"-"9"])+ >
|  <ID:        (["a"-"z"]|"_"|["A"-"Z"])(["a"-"z"]|"_"|["A"-"Z"]|["0"-"9"])* >
}

/* Program Syntax */




Program Start():
{
  MainClass mc;
  ClassDeclList cl;

}
{

    mc = MainClass() 
    
    cl = ClassDecls() 

    <EOF>
    
    
    {return new Program(mc , cl);}
}

MainClass MainClass():
{
  Statement s;
  Token t;}
{

    <CLASS> 
    t = <ID> 
    

    <LCURLY> <PUBLIC> <STATIC> <VOID> <MAIN>
    <LPAREN> <STRING> <LBRACKET> 
    <RBRACKET> 
    <ID> 
    <RPAREN> <LCURLY> 

    s = Statement()
    
    <RCURLY> <RCURLY>
        
    {return new MainClass(new Identifier(t.image), s);}

}

ClassDeclList ClassDecls() : 
{
  ClassDeclList clist = null;
  ClassDecl c;
}
{ 
  (
    (  c=ClassDecl() 
       {clist = new ClassDeclList(c,clist);}
    )*
  ) 
  {return clist;}
}


ClassDecl ClassDecl():
{
  Token t;
  VarDeclList vlist;
  MethodDeclList mlist;
}
{

  <CLASS> 
  t = <ID>
  <LCURLY> 
  vlist = VarDecls()
  mlist = MethodDecls()
  <RCURLY>

  {return new ClassDecl(new Identifier(t.image), vlist, mlist);}
}


MethodDeclList MethodDecls() : 
{
  MethodDeclList mlist = null;
  MethodDecl m;
}
{ 
  (
    (  m=MethodDecl() 
       {mlist = new MethodDeclList(m,mlist);}
    )*
  ) 
  {return mlist;}
}



MethodDecl MethodDecl()  :
{
  Type ty;
  Token t;
  FormalList flist = null;
  VarDeclList vlist;
  StatementList slist;
  Exp e;
}
{
  <PUBLIC> ty=Type() t=<ID> <LPAREN> (flist=FormalList())? <RPAREN>

      <LCURLY>
           vlist = VarDecls() 
           slist = Statements()
           <RETURN> e = Exp() <SEMICOLON>
      <RCURLY>
  {return new MethodDecl(ty,new Identifier(t.image),flist,vlist,slist,e);}

}


VarDeclList VarDecls() : 
{
  VarDeclList vlist = null;
  VarDecl v;
}
{ 
  
    (  LOOKAHEAD(2)  
       v= VarDecl() 
       {vlist = new VarDeclList(v,vlist);}
    )*

    {return(vlist);}
  
}


VarDecl VarDecl() :
{
  Type ty;
  Token t;
}
{ 
  ty=Type() t=<ID> <SEMICOLON>
  {return(new VarDecl(ty,new Identifier(t.image)));}
}

Type Type():
{
  Token t;
}
{ 
  
  
  
  <BOOLEAN> 
  {return new BooleanType();}
  |
  LOOKAHEAD(2)
  <INT> <LBRACKET> <RBRACKET>
  {return new IntArrayType();}

  |

  <INT> 
  {return new IntegerType();}
  |
  
  t = <ID>
  {return new IdentifierType(t.image);}


}





FormalList FormalList() : 
{
  FormalList flist=null;
  Formal f1,f2;
}
{ 
   f1=Formal()  {flist = new FormalList(f1,null);}
  ( 
    <COMMA> f2=Formal() 
    {flist = new FormalList(f2,flist);}
  )*
  {return flist;}
}

Formal Formal() :
{
  Type ty;
  Token t;
}
{
  ty=Type() t=<ID> 
  {return new Formal(ty,new Identifier(t.image));}
}



StatementList Statements() :
{
  StatementList s_list = null;
  Statement s;
}
{
   (s=Statement() 
    {s_list = new StatementList(s,s_list);}
   ) * 
   {return s_list;}
}

Statement Statement() :
{
  Token t;
  StatementList s_list;
  Exp e1,e2;
  Statement s1,s2;
}
{
  <LCURLY> s_list = Statements() <RCURLY> 
  {return(new Block(s_list));}

  |
  <IF> <LPAREN> e1=Exp()<RPAREN> s1=Statement() <ELSE> s2=Statement()
  {return(new If(e1,s1,s2));}

  |
  <PRINTLN> <LPAREN> e1=Exp() <RPAREN> <SEMICOLON> 
  {return(new Print(e1));}

  |
  LOOKAHEAD(2) t=<ID> <EQUALS> e1=Exp() <SEMICOLON> 
  {return(new Assign(new Identifier(t.image),e1));}

  |
   <WHILE> <LPAREN> e1 = Exp() <RPAREN> s1 = Statement()

   {return(new While(e1, s1)); }
  |

  t = <ID> <LBRACKET> e1 = Exp() <RBRACKET> <EQUALS> e2 = Exp() <SEMICOLON>
  {return (new ArrayAssign(new Identifier(t.image),e1,e2));}

}


Exp Exp():
{Exp a,b;}
{ 
   a=Exp4() 
  (LOOKAHEAD(2) <AND> b=Exp4() {a = new And(a,b);})* 
  {return(a);}



}

Exp Exp4():
{Exp a,b;}
{
  a=Exp9() 
  (LOOKAHEAD(2) <LT> b=Exp9() {a = new LessThan(a,b);})* 
  {return(a);}

}

Exp Exp9():
{Exp a,b;}
{ 
  a=Exp11() 
    (LOOKAHEAD(2) 
      (
        "+" b=Exp11() {a = new Plus(a,b);}
       |
        "-" b=Exp11() {a = new Minus(a,b);}
      )
    )* 
  {return(a);}
}

Exp Exp11():
{Exp a,b;}
{ 
  a=Exp12() 
  ( 
    LOOKAHEAD(2) 
    "*" b=Exp12() 
    {a = new Times(a,b);}
   )* 
  {return(a);}
}



Exp Exp12():
{Exp a,b; 
 ExpList c = null;
 Token t;}
{ 
  a=Exp14() 

  (
    LOOKAHEAD(2)
      <DOT> <LENGTH> 
      {a = new ArrayLength(a);} 
    |         
      <DOT> t = <ID> <LPAREN> (c = ExpList())? <RPAREN> 
      {a = new Call(a,new Identifier(t.image),c);} 
    |
      <LBRACKET> b = Exp() <RBRACKET>   
      {a = new ArrayLookup(a,b);}      

  )*

  {return(a);}
}

Exp Exp14():
{Exp a,b;}
{
   
  <BANG> a = Exp16() 
  {return(new Not(a));}
  | 
  a = Exp16()
  {return(a);}
}


Exp Exp16() :
{Exp a;
 Token t;
 ExpList c;
 }
{ 
  t=<NUMBER> {return new IntegerLiteral(Integer.parseInt(t.image));}
  |
  <TRUE> {return new True();}
  |
  <FALSE>  {return new False();}
  |
    <LPAREN> a=Exp() <RPAREN>
  {return(new ExpGroup(a));}
  |
  t=<ID>  {return new IdentifierExp(t.image);}
  |
  <THIS>
  {return new This();}
  |
  LOOKAHEAD(2)
  <NEW> <INT> <LBRACKET> a = Exp() <RBRACKET>
  {return new NewArray(a);}
  |
  <NEW> t = <ID> <LPAREN> <RPAREN>
  {return new NewObject(new Identifier(t.image));}

}



ExpList ExpList() :
{ExpList a;
 Exp b;}
{
  b=Exp() {a = new ExpList(null,b);}
  (<COMMA> b=Exp() {a=new ExpList(a,b);})*
  {return a;}
}