SQFParser.jj

options {
	IGNORE_CASE = true;
	ERROR_REPORTING = true;
	DEBUG_PARSER = false;
	STATIC = false;
}

PARSER_BEGIN(SQFParser)

package cz.zipek.sqflint.parser;

import cz.zipek.sqflint.sqf.*;
import cz.zipek.sqflint.linter.*;

public class SQFParser {
	protected SQFContext context;
	protected void pushContext(boolean newThread) {}

	protected Linter getLinter() {
		return null;
	}

	protected void popContext() {
		context = context.getPrevious();
	}

	public void setTabSize(int size) {
		jj_input_stream.setTabSize(size);
	}

	protected void handleName() throws ParseException {}
	protected void handleParams(SQFArray contents) throws ParseException {}

	protected int recover(ParseException ex, int target) throws ParseException {
		return recover(ex, target, false);
	}

	protected int recover(ParseException ex, int target, boolean skip) throws ParseException {
		return target;
	}
}

PARSER_END(SQFParser)

SKIP :
{
  " "
| "\t"
| "\n"
| "\r"
| "\f"
}

<PREPROCESSOR_OUTPUT> SKIP:
{
     "\n" : DEFAULT
}

<PREPROCESSOR_OUTPUT> MORE:
{
	"\\\n" |
	"\\\r\n" |
	< ~[] >
}


/* 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 :
{
  < ~[] >
}

/* OPERATORS */

TOKEN :
{
	< ASSIGN: "=" >    |
	< GT: ">" >        |
	< LT: "<" >        |
	< GTEQ: ">=" > |
	< LTEQ: "<=" > |
	< BANG: "!" >      |
	< BANG2: "not " >  |
	< EQ: "==" >       |
	< SC_OR: "||" >    |
	< SC_AND: "&&" >   |
	< PLUS: "+" >      |
	< MINUS: "-" >     |
	< STAR: "*" >      |
	< SLASH: "/" >     |
	< POWER: "^" >     |
	< REM: "%" >       |
	< REM2: "mod" > |
	< CSEL: ">>" > |
	< SELECT: "#" >
}

/* SQF Operators */

/* RESERVED */

TOKEN :
{
	< CASE: "case" > |
	< _DEFAULT: "default" > |
	< DO: "do" > |
	< FOR: "for" > |
	< FROM: "from" > |
	< TO: "to" > |
	< STEP: "step" > |
	< GOTO: "goto" > |
	< SWITCH: "switch" > |
	< WHILE: "while" > |
	< TRUE: "true" > |
	< FALSE: "false" > |
	< TRY: "try" > |
	< CATCH: "catch" > |
	< WITH: "with" > |
	< THEN: "then" > |
	< EXITWITH: "exitWith" > |
	< THROW: "throw" > |
	< ELSE: "else" > |
	< IF: "if" > |
	< WAITUNTIL: "waitUntil" > |
	< FINDIF: "findIf" > |
	< APPLY: "apply" > |
	< SELECT2: "select" > |
	< AND: "and" > |
	< OR: "or" >
}

/* LITERALS */

TOKEN :
{
  < INTEGER_LITERAL:
        <DECIMAL_LITERAL>
      | <HEX_LITERAL>
      | <OCTAL_LITERAL>
  > |
  < #DECIMAL_LITERAL: ["1"-"9"] (["0"-"9"])* > |
  < #HEX_LITERAL: "0" ["x","X"] (["0"-"9","a"-"f","A"-"F"])+ > |
  < #OCTAL_LITERAL: "0" (["0"-"7"])* > |
  < FLOATING_POINT_LITERAL:
        (["0"-"9"])+ "." (["0"-"9"])* (<EXPONENT>)?
      | "." (["0"-"9"])+ (<EXPONENT>)? 
      | (["0"-"9"])+ <EXPONENT>
      | (["0"-"9"])+ (<EXPONENT>)?
  > |
  < #EXPONENT: ["e","E"] (["+","-"])? (["0"-"9"])+ > |
  < STRING_LITERAL:
      "\""
      ( "\"\"" | (~["\""]) )*
      "\""
  > |
  < STRING_LITERAL_OTHER:
      "'"
      ( "''" | (~["'"]) )*
      "'"
  >
}

/* IDENTIFIERS */

TOKEN :
{
	< IDENTIFIER: <LETTER> (<LETTER>|<DIGIT>)* > |
	<#LETTER: ["A"-"Z","_","a"-"z"]> |
	<#DIGIT: ["0"-"9"]>
}

/* SEPARATORS */

TOKEN :
{
	< LPAREN: "(" >    |
	< RPAREN: ")" >    |
	< LBRACE: "{" >    |
	< RBRACE: "}" >    |
	< LBRACKET: "[" >  |
	< RBRACKET: "]" >  |
	< COMMA: "," >     |
	< DOT: "." > |
	< SEMICOLON: ";" >
}


/*

============ END OF TOKENS =============
============ START OF LANG =============

*/


SQFBlock CompilationUnit() :
{
	SQFBlock result = new SQFBlock(getLinter());
	pushContext(true);
	result.setInnerContext(context);
}
{
	try {
		result = BlockContents(true)
		<EOF> |
		<EOF>
	} catch (ParseException ex) {
		if (recover(ex, SEMICOLON, true) != EOF) {
			result = CompilationUnit();
		}
	} finally {
		return result;
	}
}


SQFLiteral Literal() :
{
	Token contents = null;
}
{
	contents = <INTEGER_LITERAL> { return new SQFLiteral(getLinter(), contents); } |
	contents = <FLOATING_POINT_LITERAL> { return new SQFLiteral(getLinter(), contents); } |
	contents = <STRING_LITERAL> { return new SQFString(getLinter(), contents); } |
	contents = <STRING_LITERAL_OTHER> { return new SQFString(getLinter(), contents); } |
	contents = BooleanLiteral() { return new SQFLiteral(getLinter(), contents); }/* |
	contents = "throw" { return new SQFLiteral(getLinter(), contents); }*/
}

Token BooleanLiteral() :
{
	Token result = null;
}
{
	result = "true" { return result; }  |
	result = "false" { return result; }
}

Token Operator() :
{ Token result = null; }
{
	result = ">>" { return result; } |
	result = "=" { return result; } |
	result = "==" { return result; } |
	result = "!=" { return result; } |
	result = ">" { return result; } |
	result = "<" { return result; } |
	result = "+" { return result; } |
	result = "-" { return result; } |
	result = "*" { return result; } |
	result = "%" { return result; } |
	result = "mod" { return result; } |
	result = "^" { return result; } |
	result = ">=" { return result; } |
	result = "<=" { return result; } |
	result = "/" { return result; } |
	result = "#" { return result; }
}

SQFIdentifier Name() :
{
	Token token = null;
}
{
	token = <IDENTIFIER>
	{ return new SQFIdentifier(getLinter(), token); }
}

SQFExpression Expression(SQFExpression left, boolean newThread) :
{
	SQFExpression result = new SQFExpression(getLinter(), getToken(0));
	Token main = null;
	SQFExpression right = null;
	SQFExpression next = null;
	SQFExpression cond = null;

	result.setLeft(left);
}
{
	main = InlineFunctionInvoker() right = Expression(result, false) {
		return result.setMain(new SQFIdentifier(getLinter(), main)).setRight(right).finish();
	} |
	ExpressionOperator(result) right = Expression(result, newThread) { return result.setRight(right).finish(); } |
	PrimaryExpression(left, result, newThread) [ right = Expression(result, newThread) ] { return result.setRight(right).finish(); }
}

Token InlineFunctionInvoker():
{
	Token main = null;
}
{
	main = "if" { return main; } |
	main = "exitWith" { return main; } |
	main = "then" { return main; } |
	main = "throw" { return main; } |
	main = "else" { return main; } |
	main = "waitUntil" { return main; } |
	main = "select" { return main; } |
	main = "findIf" { return main; } |
	main = "apply" { return main; } |
	main = "&&" { return main; } |
	main = "and" { return main; } |
	main = "or" { return main; } |
	main = "||" { return main; }
}

void ExpressionOperator(SQFExpression main) :
{
	Token result = null;
}
{
	(result = "!" | result = "not " | result = Operator()) { main.setMain(new SQFOperator(getLinter(), result)); }
}

void PrimaryExpression(SQFExpression left, SQFExpression main, boolean newThread) :
{
	SQFUnit result = null;
}
{
	result = TryStatement() { main.setMain(result); } |
	result = SwitchStatement() { main.setMain(result); } |
	result = Literal() { main.setMain(result); }  |
	"(" result = Expression(null, newThread) ")" { main.setMain(result); } |
	result = Name() { main.setMain(result); } |
	result = Block(newThread) { main.setMain(result); } |
	result = Array() { main.setMain(result); } |
	result = WithStatement() { main.setMain(result); }
}

SQFWithStatement WithStatement () :
{
	SQFBlock block = null;
	SQFExpression with = null;
}
{
	"with" with = Expression(null, false) "do" block = Block(false)
	{ return new SQFWithStatement(getLinter(), with, block); }
}

SQFArray Array() :
{
	SQFArray array = new SQFArray(getLinter());
	SQFExpression item = null;
}
{
	LOOKAHEAD(2) "[" item = Expression(null, true) { array.add(item); } ( "," item = Expression(null, true) { array.add(item); } )* "]" { return array; } |
	"[" "]" 	{ return array; }
}

SQFBlock Block(boolean newThread) :
{
	SQFBlock result = new SQFBlock(getLinter());
}
{
	LOOKAHEAD(2)
	"{" result = BlockContents(newThread) "}" { return result; } |
	"{" "}" { return result; }
}

SQFBlock BlockContents(boolean newThread):
{
	SQFBlock result = new SQFBlock(getLinter());
	SQFUnit statement = null;
	pushContext(newThread);
	result.setInnerContext(context);
}
{
	statement = Statement() { result.add(statement); }
	( ";" [ statement = Statement() { result.add(statement); }  ] )*
	{ popContext(); return result; } |
	LOOKAHEAD(2)
	";" statement = Statement() { result.add(statement); }
	( ";" [ statement = Statement() { result.add(statement); }  ] )*
	{ popContext(); return result; } |
	";" { popContext(); return result; }
}

SQFUnit Statement() :
{
	SQFUnit result = null;
}
{
	try {
		LOOKAHEAD(3)
		result = WhileStatement() { return result; } |
		result = ForStatement() { return result; } |
		result = Expression(null, true) { return result; }
	} catch(ParseException ex) {
		recover(ex, SEMICOLON);
	} finally {
		return result;
	}
}

SQFTryStatement TryStatement() :
{
	SQFBlock tryBlock = null;
	SQFBlock catchBlock = null;
}
{
	"try" tryBlock = Block(false) "catch" catchBlock = Block(false)
	{ return new SQFTryStatement(getLinter(), tryBlock, catchBlock); }
}

SQFSwitchStatement SwitchStatement() :
{
	SQFSwitchStatement result = new SQFSwitchStatement(getLinter());
	SQFExpression exp = null;
	SQFCaseStatement cs = null;
	SQFBlock def = null;
}
{
	"switch" exp = Expression(null, false) { result.setExpression(exp); } "do" "{"
		( cs = SwitchCase() { result.add(cs); } )*
		[ def = SwitchDefault() { result.setDefault(def); } ]
	"}" { return result; }
}

SQFCaseStatement SwitchCase() :
{
	SQFExpression exp = null;
	SQFBlock block = null;
}
{
	exp = SwitchLabel() ( ( ":" block = Block(false) ";" ) | ";" )
	{ return new SQFCaseStatement(getLinter(), exp, block); }
}

SQFBlock SwitchDefault() :
{ SQFBlock result = null; }
{
	"default" result = Block(false) ";" { return result; }
}

SQFExpression SwitchLabel() :
{ SQFExpression result = null; }
{
	"case" result = Expression(null, false) { return result; }
}

SQFWhileStatement WhileStatement() :
{
	SQFBlock cond = null;
	SQFBlock block = null;
}
{
	"while" cond = Block(false) "do" block = Block(false)
	{ return new SQFWhileStatement(getLinter(), cond, block); }
}

SQFForStatement ForStatement() :
{
	SQFBlock init = null, cond = null, stepBlock = null, block = null;
	SQFExpression variable = null, from = null, to = null, step = null;
}
{
	LOOKAHEAD(2) ( "for" "[" init = Block(false) "," cond = Block(false) "," stepBlock = Block(false) "]" "do" block = Block(false) ) {
		return new SQFForArrayStatement(getLinter(), init, cond, stepBlock, block);
	} |
	LOOKAHEAD(2) ( "for" variable = Expression(null, false) "from" from = Expression(null, false) "to" to = Expression(null, false) [ "step" step = Expression(null, false) ] "do" block = Block(false) ) {
		return new SQFForExpressionStatement(getLinter(), variable, from, to, step, block);
	}
}