Grammaire.jjt

options {
	JAVA_UNICODE_ESCAPE=true;
	STATIC=false;					// 1 seul parseur actif a la fois (+ rapide)
	MULTI=true;						// type noeud = f(nom noeud)
	VISITOR=true;					// Cree une methode accept(visiteur)
}

//
// PARSER DEFINITION
//

PARSER_BEGIN(Parser)

package analyzer.ast;

public class Parser
{
	public static ASTProgram ParseTree(java.io.InputStream input) throws ParseException
	{
		Parser c = new Parser(input);
		return c.Program();
	}
}

PARSER_END(Parser)

//
// LEXICAL ANALYSIS
//

// White space

SKIP :
{
	< ( " " | "\t" | "\n" | "\r" )+	>
}

// Comments

MORE :
{
  "//" : IN_SINGLE_LINE_COMMENT
|
  <"/**" ~["/"]> { input_stream.backup(1); } : IN_FORMAL_COMMENT
|
  "/*" : IN_MULTI_LINE_COMMENT
}

<IN_SINGLE_LINE_COMMENT>
SPECIAL_TOKEN :
{
  <SINGLE_LINE_COMMENT: "\n" | "\r" | "\r\n" > : DEFAULT
}

<IN_FORMAL_COMMENT>
SPECIAL_TOKEN :
{
  <FORMAL_COMMENT: "*/" > : DEFAULT
}

<IN_MULTI_LINE_COMMENT>
SPECIAL_TOKEN :
{
  <MULTI_LINE_COMMENT: "*/" > : DEFAULT
}

<IN_SINGLE_LINE_COMMENT,IN_FORMAL_COMMENT,IN_MULTI_LINE_COMMENT>
MORE :
{
  < ~[] >
}




// Keywords
TOKEN :
{
	< IF: "if"	> |
	< ELSE: "else" > |
	< STRING: "string"> |
	< INT: "int"> |
	< FLOAT: "float" > |
	< BOOL: "bool"> |
	< PRINT: "print" > |
	< INPUT: "input" > |
	< IN: "in" > |
	< DO: "do" > |
	< WHILE: "while" > |
	< SWITCH: "switch" > |
	< CASE: "case" > |
    < DEF: "default">|
    < FOR: "for"> |
    < FUNC: "func"> |
    < RET: "return"> |
    < ENUM: "enum"> |
    < BREAK: "break"> |
    < #E: ("E" | "e") >
	// À compléter au besoin
}

// Operators
TOKEN :
{
	< ASSIGN: < EQUAL >  > |
	< COMPARE: < LESS > | < LESSEQUAL > | < GREAT > | <GREATEQUAL > | < DIFF > | < EQUALEQUAL > > |
    < LOGIC: < AND > | < OR > > |
	< #LESS: "<" > |
	< #LESSEQUAL: "<=" > |
	< #GREAT: ">" > |
	< #GREATEQUAL: ">=" > |
	< #DIFF: "!=" > |
	< #EQUALEQUAL: "==" > |

	< PLUS: "+" > |
	< MINUS: "-" > |
	< FOIS: "*" > |
	< DIV: "/" > |
    < NOT: "!" > |

	< #EQUAL: "=" > |
	< LPAREN: "(" > |
	< RPAREN: ")" > |
	< LACC: "{" > |
	< RACC: "}" > |
	< LBRA: "[" > |
	< RBRA: "]" > |
	< COLON: ":" > |
	< SEMICOLON: ";" > |
	< COMMA: "," > |
	< #AND: "&&" > |
	< #OR: "||" > |
	< POINT: "." >
	// À compléter au besoin
}


// Identifiers and numbers
TOKEN :
{
	< IDENTIFIER: <LETTER> ( <LETTER> | <DIGIT> )* > |
	< #LETTER: ["a"-"z","A"-"Z","_"] > |
	< #DIGIT: ["0"-"9"] > |
	< INTEGER: ["1"-"9"] (["0"-"9"])* | "0" > |
	< REAL: (<INTEGER>)? <POINT> (<INTEGER>)? (<E><PLUS><INTEGER>)?>
}




//
// SYNTAX ANALYSIS
//

ASTProgram Program() : {}
{
	Block() <EOF> { return jjtThis;  }
}

void Block() #void : {}
{
	 ( Stmt() )*
}

// ---------- STATEMENTS BEGIN ----------

void Stmt() #void : {}
{
	AssignStmt() <SEMICOLON> | ForStmt() | IfStmt() | WhileStmt() | DoWhileStmt() <SEMICOLON> | EnumStmt() | SwitchStmt()
}

void AssignStmt() : {}
{
	Identifier() <ASSIGN> Expr()
}

// TODO: Ajouter tous vos statements ici (Voir énoncé)

void ForStmt() : {}
{
    <FOR> <LPAREN> (AssignStmt())? <SEMICOLON> (Expr())? <SEMICOLON> (AssignStmt())? <RPAREN> (<LACC> Block() <RACC> | Stmt())
}

void IfStmt() : {}
{
IfCond() IfBlock() [LOOKAHEAD(2) <ELSE> ElseBlock()]
}

void IfBlock() : {}
{
<LACC> Block() <RACC> | Stmt()
}

void ElseBlock() : {}
{
LOOKAHEAD(3) IfStmt() | <LACC> Block() <RACC> | Stmt()
}

void IfCond() : {}
{
<IF> <LPAREN> Expr() <RPAREN>
}

void WhileStmt() : {}
{
WhileCond() WhileBlock()
}

void WhileCond() : {}
{
<WHILE> <LPAREN> Expr() <RPAREN>
}

void WhileBlock() : {}
{
<LACC> Block() <RACC> | Stmt()
}

void DoWhileStmt() : {}
{
<DO> WhileBlock() WhileCond()
}

void EnumStmt() : {}
{
<ENUM> Identifier() <LACC> Identifier() (<COMMA> Identifier())* <RACC>
}

void SwitchStmt() : {}
{
<SWITCH> <LPAREN> Identifier() <RPAREN> <LACC> (CaseStmt())+ [DefaultStmt()] <RACC>
}

void CaseStmt() : {}
{
<CASE> (Identifier() | IntValue())<COLON> CaseBlock()
}

void DefaultStmt() : {}
{
<DEF> <COLON> CaseBlock()
}

void CaseBlock() #void : {}
{
(Block() [BreakStmt()]) #CaseBlock(>0)
}

void BreakStmt() : {}
{
<BREAK> <SEMICOLON>
}

// ---------- STATEMENTS END ----------

// ---------- EXPRESSIONS BEGIN ----------

void Expr() #void : {}
{
    LOOKAHEAD(1) EntryPoint() | ArrayExpr()
}

void BasicExpr() #void : {}
{
	LOOKAHEAD(1) Identifier() |
	IntValue() | RealValue()
}

void ArrayExpr() : {}
{
    <LBRA>(Expr()(<COMMA> Expr())*)?<RBRA>
}

void Parentheses() #void : {}
{
  <LPAREN> Expr() <RPAREN> | BasicExpr()
}

void Not() #void : {}
{
    <NOT> Not() #Not | Parentheses()
}

void Minus() #void : {}
{
 (<MINUS> Minus()) #Minus | Not()
}

void Multi() #void : {}
{
  ((Minus()) ((<FOIS> | <DIV>) (Minus()))*) #Multi(>1)
}

void Addition() #void : {}
{
   ((Multi()) ((<PLUS> | <MINUS>) (Multi()))*) #Addition(>1)
}

void Compare() #void : {}
{
   (Addition()  (<COMPARE> Addition() )*) #Compare(>1)
}

void Logic() #void : {}
{
   (Compare() (<LOGIC> Compare())*) #Logic(>1)
}

void EntryPoint() #void : {}
{
Logic()
}



// Expressions de base (Ne pas modifier):

void Identifier() : {}
{
	<IDENTIFIER>
}

void IntValue() : {}
{
	<INTEGER>
}

void RealValue() : {}
{
	<REAL>
}

// ---------- EXPRESSIONS END ----------