//--------------------------------------------------------------------------------------------------
//
//  @ CopyRight Roberti & Parau Enterprises, Inc.  2021-2023
//
//  This work is licensed under the Creative Commons Attribution-NoDerivatives 4.0 International License.
//  To view a copy of this license, visit http://creativecommons.org/licenses/by-nd/4.0/
//   or send a letter to Creative Commons, PO Box 1866, Mountain View, CA 94042, USA.
//
//--------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//
//  Javacc parser for DVASM
//
//------------------------------------------------------------------------------

options {
    STATIC= false;
    SUPPORT_CLASS_VISIBILITY_PUBLIC= true;
    FORCE_LA_CHECK= true;
    LOOKAHEAD= 1;
    DEBUG_TOKEN_MANAGER= false;
}

PARSER_BEGIN(DVInputParser)

package			framework;

import          java.io.IOException;
import          java.util.LinkedList;
import          java.util.HashMap;
import          javax.script.ScriptException;


public      class   DVInputParser {

    //
    //  Class fields
    //
    private     DVStatements                        statements;
    private     DVMacroJSApi                        jSApi;
    private     DVMacros                            macros;

    private		DVStatements.Statement				currStatement;
    						
    private     Token                               currLabel= null;
    private     DVOpCodeParm                        opCodeParm= null;

    private     Token                               currKey= null;
    private     boolean                             subParmState= false;
    private     boolean                             subParmEnd= false;
    private     DVExpression                        currExpression= null;

    private     DVMacros.Macro                      currMacro= null;

    private     int                                 macroPosParmNo;
    private		int									macroParmListNo;
    private     String                              macroEvalParm;
    LinkedList<Character>                           macroNestStack= new LinkedList<Character>();
    HashMap<String, DVMacroParm>                    macroKeyParm;

    //
    //  Get current state in string form
    //
    protected   String  getState() {
        return DVInputParserTokenManager.lexStateNames[token_source.curLexState];
    }
}

PARSER_END(DVInputParser)

//
//  Token manager declarations
//
TOKEN_MGR_DECLS : {

  	protected		DVStatements          		        statements= null;
    protected       DVMacros            		        macros;
    protected		DVMacroJSApi				        jSApi= null;

    protected       int                 		        lexNest;

    protected       DVMacros.Macro      		        currMacro= null;
    protected       int                                 macroNestCount;

    private     String  getState() {
        return lexStateNames[curLexState];
    }

    void        switchFromUnaryState() {

        switch(curLexState) {

            case    PARM_EXPR_START_STATE       :
            case    PARM_EXPR_UNARY_STATE       :   SwitchTo(PARM_EXPR_VALUE_STATE);
                                                    return;
            case    PARM_EXPR_UNARY_NEST_STATE  :   SwitchTo(PARM_EXPR_VALUE_NEST_STATE);
                                                    return;
            case    KEYP_EXPR_START_STATE       :
            case    KEYP_EXPR_UNARY_STATE       :   SwitchTo(KEYP_EXPR_VALUE_STATE);
                                                    return;
            case    KEYP_EXPR_UNARY_NEST_STATE  :   SwitchTo(KEYP_EXPR_VALUE_NEST_STATE);
                                                    return;
            case    SUBP_EXPR_UNARY_STATE       :   SwitchTo(SUBP_EXPR_VALUE_STATE);
                                                    return;
            case    SUBP_EXPR_UNARY_NEST_STATE  :   SwitchTo(SUBP_EXPR_VALUE_NEST_STATE);
                                                    return;

            default                             :   return;
        }
    }

    void        switchFromValueState() {

        switch(curLexState) {

            case    PARM_EXPR_START_STATE       :
            case    PARM_EXPR_UNARY_STATE       :
            case    PARM_EXPR_VALUE_STATE       :   SwitchTo(PARM_EXPR_BINARY_STATE);
                                                    return;
            case    PARM_EXPR_UNARY_NEST_STATE  :
            case    PARM_EXPR_VALUE_NEST_STATE  :   SwitchTo(PARM_EXPR_BINARY_NEST_STATE);
                                                    return;
            case    KEYP_EXPR_START_STATE       :
            case    KEYP_EXPR_UNARY_STATE       :
            case    KEYP_EXPR_VALUE_STATE       :   SwitchTo(KEYP_EXPR_BINARY_STATE);
                                                    return;
            case    KEYP_EXPR_UNARY_NEST_STATE  :
            case    KEYP_EXPR_VALUE_NEST_STATE  :   SwitchTo(KEYP_EXPR_BINARY_NEST_STATE);
                                                    return;
            case    SUBP_EXPR_UNARY_STATE       :
            case    SUBP_EXPR_VALUE_STATE       :   SwitchTo(SUBP_EXPR_BINARY_STATE);
                                                    return;
            case    SUBP_EXPR_UNARY_NEST_STATE  :
            case    SUBP_EXPR_VALUE_NEST_STATE  :   SwitchTo(SUBP_EXPR_BINARY_NEST_STATE);
                                                    return;

            default                             :   return;
        }
    }

    void        switchFromBinaryState() {

        switch(curLexState) {

            case    PARM_EXPR_BINARY_STATE      :   SwitchTo(PARM_EXPR_VALUE_STATE);
                                                    return;
            case    PARM_EXPR_BINARY_NEST_STATE :   SwitchTo(PARM_EXPR_VALUE_NEST_STATE);
                                                    return;
            case    SUBP_EXPR_BINARY_STATE      :   SwitchTo(SUBP_EXPR_VALUE_STATE);
                                                    return;
            case    SUBP_EXPR_BINARY_NEST_STATE :   SwitchTo(SUBP_EXPR_VALUE_NEST_STATE);
                                                    return;
            case    KEYP_EXPR_BINARY_STATE      :   SwitchTo(KEYP_EXPR_VALUE_STATE);
                                                    return;
            case    KEYP_EXPR_BINARY_NEST_STATE :   SwitchTo(KEYP_EXPR_VALUE_NEST_STATE);
                                                    return;

            default                             :   return;
        }
    }

    void        switchToNestedState() {

        switch(curLexState) {

            case    PARM_EXPR_START_STATE       :
            case    PARM_EXPR_UNARY_STATE       :
            case    PARM_EXPR_VALUE_STATE       :   SwitchTo(PARM_EXPR_UNARY_NEST_STATE);
                                                    return;
            case    KEYP_EXPR_START_STATE       :
            case    KEYP_EXPR_UNARY_STATE       :
            case    KEYP_EXPR_VALUE_STATE       :   SwitchTo(KEYP_EXPR_UNARY_NEST_STATE);
                                                    return;
            case    SUBP_EXPR_UNARY_STATE       :
            case    SUBP_EXPR_VALUE_STATE       :   SwitchTo(SUBP_EXPR_UNARY_NEST_STATE);
                                                    return;

            default                             :   return;
        }
    }

    void        switchFromNestedState() {

        switch(curLexState) {

            case    PARM_EXPR_BINARY_NEST_STATE :   SwitchTo(PARM_EXPR_BINARY_STATE);
                                                    return;
            case    KEYP_EXPR_BINARY_NEST_STATE :   SwitchTo(KEYP_EXPR_BINARY_STATE);
                                                    return;
            case    SUBP_EXPR_BINARY_NEST_STATE :   SwitchTo(SUBP_EXPR_BINARY_STATE);
                                                    return;

            default                             :   return;
        }
    }

    void        switchAferComma() {

        switch(curLexState) {

            case    PARM_EXPR_START_STATE       :
            case    PARM_EXPR_END_STATE         :
            case    PARM_EXPR_UNARY_STATE       :
            case    PARM_EXPR_BINARY_STATE      :
            case    KEYP_EXPR_START_STATE       :
            case    KEYP_EXPR_UNARY_STATE       :
            case    KEYP_EXPR_BINARY_STATE      :   SwitchTo(PARM_EXPR_START_STATE);
                                                    return;
            case    SUBP_EXPR_UNARY_STATE       :
            case    SUBP_EXPR_BINARY_STATE      :   SwitchTo(SUBP_EXPR_UNARY_STATE);
                                                    return;

            default                             :   return;
        }
    }
}

//
//	List of all states used
//
//  MACRO_STATE      
//	OPCODE_PARM_STATE
//	SUBP_EXPR_BINARY_NEST_STATE
//	SUBP_EXPR_VALUE_NEST_STATE
//	SUBP_EXPR_UNARY_NEST_STATE
//	SUBP_EXPR_BINARY_STATE
//	SUBP_EXPR_VALUE_STATE
//	SUBP_EXPR_UNARY_STATE
//  SUBP_EXPR_START_STATE
//	KEYP_EXPR_BINARY_NEST_STATE
//	KEYP_EXPR_VALUE_NEST_STATE
//	KEYP_EXPR_UNARY_NEST_STATE
//	KEYP_EXPR_BINARY_STATE
//	KEYP_EXPR_VALUE_STATE
//	KEYP_EXPR_UNARY_STATE
//	KEYP_EXPR_START_STATE
//	PARM_EXPR_BINARY_NEST_STATE
//	PARM_EXPR_VALUE_NEST_STATE
//	PARM_EXPR_UNARY_NEST_STATE
//	PARM_EXPR_BINARY_STATE
//	PARM_EXPR_VALUE_STATE
//	PARM_EXPR_UNARY_STATE
//	PARM_EXPR_END_STATE
//	PARM_EXPR_START_STATE
//	OPCODE_STATE
//	DEFAULT

//
//  Start of statement token
//
<DEFAULT>                           TOKEN : {
        <LABEL:                     (((<LETTER> (<LETTER> | <DIGIT>)*)".")*
                                        (<LETTER> (<LETTER> | <DIGIT>)*))>      : OPCODE_STATE
}

<DEFAULT,
 OPCODE_STATE>						TOKEN : { 
	<LABEL_SPACES:					((" ") | ("\t"))+ >							: OPCODE_STATE
}

//
//  Identifiers
//
<OPCODE_STATE>                      TOKEN:  {

        <OPCODE:                    (((<LETTER> (<LETTER> | <DIGIT>)*)".")*
                                        (<LETTER> (<LETTER> | <DIGIT>)*))>
                                    {
                                        if ((currMacro= macros.get(jSApi, image.toString())) != null)
                                            SwitchTo(MACRO_STATE);
                                        else
                                            SwitchTo(OPCODE_PARM_STATE);
                                        lexNest= 0;
                                    }
}

//
//  Switch to expression after blank for opCode parms
// 
<OPCODE_PARM_STATE>                 TOKEN:  {
    <OPCODE_SPACES:                 ((" ") | ("\t"))+>                 		: PARM_EXPR_START_STATE
}

//
//  Expression operators - UNARY state
//
<PARM_EXPR_START_STATE,
 KEYP_EXPR_START_STATE,
 PARM_EXPR_UNARY_STATE,
 PARM_EXPR_UNARY_NEST_STATE,
 KEYP_EXPR_UNARY_STATE,
 KEYP_EXPR_UNARY_NEST_STATE,
 SUBP_EXPR_UNARY_STATE,
 SUBP_EXPR_UNARY_NEST_STATE>        TOKEN:  {

        <UPLUS:                     ("+")>
    |   <UMINUS:                    ("-")>
    |   <BNOT:                      ("~")>  { switchFromUnaryState(); }
    |   <LNOT:                      ("!")>  { switchFromUnaryState(); }
}

//
//  Expression operators - VALUE state - not NESTED
//
<PARM_EXPR_START_STATE>             TOKEN:  {

        <BASESYMBOL:                (<SYMBOL> (":") <SYMBOL>)>                  : PARM_EXPR_BINARY_STATE
}

//
//  Expression operators - VALUE and UNARY state
//
<PARM_EXPR_START_STATE,
 KEYP_EXPR_START_STATE,
 PARM_EXPR_UNARY_STATE,
 PARM_EXPR_UNARY_NEST_STATE,
 KEYP_EXPR_UNARY_STATE,
 KEYP_EXPR_UNARY_NEST_STATE,
 SUBP_EXPR_UNARY_STATE,
 SUBP_EXPR_UNARY_NEST_STATE,
 PARM_EXPR_VALUE_STATE,
 PARM_EXPR_VALUE_NEST_STATE,
 KEYP_EXPR_VALUE_STATE,
 KEYP_EXPR_VALUE_NEST_STATE,
 SUBP_EXPR_VALUE_STATE,
 SUBP_EXPR_VALUE_NEST_STATE>        TOKEN:  {

        <QSYMBOL:                   ((((<LETTER> (<LETTER> | <DIGIT>)*)".")*
                                        (<LETTER> (<LETTER> | <DIGIT>)*))
                                        ((("@") (< LETTER > (< LETTER > | < DIGIT >)*))
                                        ((".@") (< LETTER > (< LETTER > | < DIGIT >)*))*))+>
                                        { switchFromValueState(); }

    |   <SYMBOL:                    (((<LETTER> (<LETTER> | <DIGIT>)*)".")*
                                        (<LETTER> (<LETTER> | <DIGIT>)*))>
                                        { switchFromValueState(); }

    |   <LENGTH:                    (<SYMBOL> (".$") (["l","L"]["e","E"]["n","N"]["g","G"]["t","T"]["h","H"]))>
                                        { switchFromValueState(); }

    |   <REPL:                      (<SYMBOL> (".$") (["r","R"]["e","E"]["p","P"]["l","L"]))>
                                        { switchFromValueState(); }

    |   <SIZE:                      (<SYMBOL> (".$") (["s","S"]["i","I"]["z","Z"]["e","E"]))>
                                        { switchFromValueState(); }

    |   <COUNTER:                   (["$"]["p","P"]["c","C"])>
                                        { switchFromValueState(); }

    |   <FLOAT:                     (   (((<DIGIT>)+ ["."] (<DIGIT>)*) (["E","e"] (["+","-"])? (<DIGIT>)+)?)
                                    |   (((<DIGIT>)* ["."] (<DIGIT>)+) (["E","e"] (["+","-"])? (<DIGIT>)+)?)
                                    |   ( (<DIGIT>)+                    ["E","e"] (["+","-"])? (<DIGIT>)+))>
                                        { switchFromValueState(); }

    |   <INTEGER:                   ((<DIGIT>)+)>
                                        { switchFromValueState(); }

    |   <BIN:                       ( (("0b") | ("0B")) ((<BINDIGIT>)+) ((("_") (<BINDIGIT>)+)*))>
                                        { switchFromValueState(); }

    |   <HEX:                       ( (("0x") | ("0X")) ((<HEXDIGIT>)+) ((("_") (<HEXDIGIT>)+)*))>
                                        { switchFromValueState(); }

    |   <CHAR:                      ("'") <SINGLECHARSQ> ("'")>
                                        { switchFromValueState(); }

    |   <STRING:                    (["\""] (<SINGLECHARDQ>)* ["\""])>
                                        { switchFromValueState(); }

    |   <LPAREN:                    ("(")>
                                    {
                                        switchToNestedState();
                                        lexNest++;
                                    }

    |   <#LETTER:                   ["a"-"z","A"-"Z","_"]>

	|	<#BINDIGIT:					["0"-"1"]>   

    |   <#DIGIT:                    ["0"-"9"]>

    |   <#HEXDIGIT:                 ["0"-"9","A"-"F","a"-"f"]>

    |   <#SINGLECHARDQ:             ([" "-"!","#"-"~"]) | ("\\0") | ("\\b") | ("\\t") | ("\\n") |
                                        ("\\v") | ("\\f") | ("\\r") | (("\\x") <HEXDIGIT> <HEXDIGIT>) |
                                        ("\\\"") | ("\\\'") | ("\\\\")>

    |   <#SINGLECHARSQ:             ([" "-"&","("-"~"]) | ("\\0") | ("\\b") | ("\\t") | ("\\n") |
                                        ("\\v") | ("\\f") | ("\\r") | (("\\x") <HEXDIGIT> <HEXDIGIT>) |
                                        ("\\\"") | ("\\\'") | ("\\\\")>
}

//
//  Keyword tokens - PARM START state
//
<PARM_EXPR_START_STATE> 			TOKEN:  {

        <KEY:                       ((<LETTER> (<LETTER> | <DIGIT>)*) ("="))>   : KEYP_EXPR_START_STATE
}

//
//  Expression operators - BINARY state
//
<PARM_EXPR_BINARY_STATE,
 PARM_EXPR_BINARY_NEST_STATE,
 KEYP_EXPR_BINARY_STATE,
 KEYP_EXPR_BINARY_NEST_STATE,
 SUBP_EXPR_BINARY_STATE,
 SUBP_EXPR_BINARY_NEST_STATE>       TOKEN:  {

        <POWER:                     ("**")> { switchFromBinaryState(); }
    |   <MULTIPLY:                  ("*")>  { switchFromBinaryState(); }
    |   <DIVIDE:                    ("/")>  { switchFromBinaryState(); }
    |   <REMINDER:                  ("%")>  { switchFromBinaryState(); }
    |   <PLUS:                      ("+")>  { switchFromBinaryState(); }
    |   <MINUS:                     ("-")>  { switchFromBinaryState(); }
    |   <SHIFTLEFT:                 ("<<")> { switchFromBinaryState(); }
    |   <SHIFTRIGHT:                (">>")> { switchFromBinaryState(); }
    |   <GT:                        (">")>  { switchFromBinaryState(); }
    |   <LT:                        ("<")>  { switchFromBinaryState(); }
    |   <GE:                        (">=")> { switchFromBinaryState(); }
    |   <LE:                        ("<=")> { switchFromBinaryState(); }
    |   <EQ:                        ("==")> { switchFromBinaryState(); }
    |   <NE:                        ("!=")> { switchFromBinaryState(); }
    |   <BAND:                      ("&")>  { switchFromBinaryState(); }
    |   <BXOR:                      ("^")>  { switchFromBinaryState(); }
    |   <BOR:                       ("|")>  { switchFromBinaryState(); }
    |   <LAND:                      ("&&")> { switchFromBinaryState(); }
    |   <LOR:                       ("||")> { switchFromBinaryState(); }
}

//
//  Expression operators - BINARY state - not NESTED
//
<PARM_EXPR_START_STATE,				// Positional parameters without expression allowed
 PARM_EXPR_BINARY_STATE>            TOKEN:  {

        <LSQUARE:                   ("[")>                                      : SUBP_EXPR_UNARY_STATE
}

//
//  Expression operators - BINARY state - not NESTED
//
<SUBP_EXPR_START_STATE,				// Sub-parameters without expression allowed
 SUBP_EXPR_BINARY_STATE>            TOKEN:  {

        <RSQUARE:                   ("]")>                                      : PARM_EXPR_END_STATE
}

//
//  Expression operators - BINARY state - not NESTED
//
<PARM_EXPR_START_STATE,				// Positional parameters without expression allowed
 PARM_EXPR_END_STATE,
 PARM_EXPR_UNARY_STATE,
 PARM_EXPR_BINARY_STATE,
 //		KEYP_EXPR_START_STATE,		No keyword parameters allowed without an expression
 KEYP_EXPR_UNARY_STATE,
 KEYP_EXPR_BINARY_STATE,
 SUBP_EXPR_START_STATE,				// Sub-parameters without an expression allowed
 SUBP_EXPR_UNARY_STATE,
 SUBP_EXPR_BINARY_STATE>            TOKEN:  {

        <COMMA:                     (",")>                                      { switchAferComma(); }
}

//
//  Expression operators - BINARY state - NESTED only
//
<PARM_EXPR_BINARY_NEST_STATE,
 KEYP_EXPR_BINARY_NEST_STATE,
 SUBP_EXPR_BINARY_NEST_STATE>       TOKEN:  {

        <RPAREN:                    (")")>
                                    {
                                        lexNest--;
                                        if (lexNest <= 0)
                                            switchFromNestedState();
                                    }
}

//
//  Macro tokens
//
<MACRO_STATE>               TOKEN [IGNORE_CASE]:    {
        <MACRO_KEYWORD:             ((["a"-"z","_"])(["a"-"z","_","0"-"9"])*(["="]))>
    |   <MACRO_BOOL:                (("true") | ("yes") | ("false") | ("no"))>
}

<MACRO_STATE>               TOKEN:  {
        <MACRO_INT:                 ((["-","+"])?(["0"-"9"])+)>
    |   <MACRO_DQNDL:               ((["!"]["\""] ((~["\"","\n"]) | ("\\\""))* ["\""])+)>
    |   <MACRO_SQSTR:               ((["\'"] ((~["\'","\n"]) | ("\\\'"))* ["\'"])+)>
    |   <MACRO_DQSTR:               ((["\""] ((~["\"","\n"]) | ("\\\""))* ["\""])+)>
    |   <MACRO_OR:                  ("(")>                      { this.macroNestCount++; }
    |   <MACRO_CR:                  (")")>                      { this.macroNestCount--; }
    |   <MACRO_OS:                  ("[")>                      { this.macroNestCount++; }
    |   <MACRO_CS:                  ("]")>                      { this.macroNestCount--; }
    |   <MACRO_OC:                  ("{")>                      { this.macroNestCount++; }
    |   <MACRO_CC:                  ("}")>                      { this.macroNestCount--; }
    |   <MACRO_COMMA:               (",")> 
    |   <MACRO_DATA:                ((~[" ","\t",",","(",")","[","]","{","}","\"","'","\n"]))>
	| 	<MACRO_SPACES:				(((" ") | ("\t"))+)>
}

//
//	Blanks skip
//
// MACRO_STATE      ,				Need to capture blanks
// OPCODE_PARM_STATE,               After OpCode need to verify blanks before parms
// DEFAULT,							Before OpCode to check if label is there	
<SUBP_EXPR_BINARY_NEST_STATE,
 SUBP_EXPR_VALUE_NEST_STATE,
 SUBP_EXPR_UNARY_NEST_STATE,
 SUBP_EXPR_BINARY_STATE,
 SUBP_EXPR_VALUE_STATE,
 SUBP_EXPR_UNARY_STATE,
 SUBP_EXPR_START_STATE,
 KEYP_EXPR_BINARY_NEST_STATE,
 KEYP_EXPR_VALUE_NEST_STATE,
 KEYP_EXPR_UNARY_NEST_STATE,
 KEYP_EXPR_BINARY_STATE,
 KEYP_EXPR_VALUE_STATE,
 KEYP_EXPR_UNARY_STATE,
 KEYP_EXPR_START_STATE,
 PARM_EXPR_BINARY_NEST_STATE,
 PARM_EXPR_VALUE_NEST_STATE,
 PARM_EXPR_UNARY_NEST_STATE,
 PARM_EXPR_BINARY_STATE,
 PARM_EXPR_VALUE_STATE,
 PARM_EXPR_UNARY_STATE,
 PARM_EXPR_END_STATE,
 PARM_EXPR_START_STATE,
 OPCODE_STATE >                     SKIP : {

        <                           ((" ") | ("\t"))>
}

<*>									SKIP : {
  		< 							("\n") >
}							

//
//	Invalid characters to avoid Token Manager error
//
<*>									TOKEN : {
  		< INVALID_CHAR:				(~[]) >
}

//
//  Start grammar here
//
void 		start(DVStatements statements):
{
    this.statements= statements;
    this.currStatement= statements.currStatement;
    this.jSApi= statements.jSApi;
    this.macros= jSApi.macros;
    
    this.token_source.statements= statements;
    this.token_source.jSApi= jSApi;
    this.token_source.macros= jSApi.macros;

    Token           		t;
    String					macroCode;
}
{
    (
        (
            t= <LABEL>                  { currLabel= t; }
            ( <LABEL_SPACES> ) *
            t= <OPCODE>             	{ processMacroOpcode(t); }
        )

    |   (
      		(
            	( <LABEL_SPACES> ) +    { currLabel= null; }
       		) ?
            (
            	t= <OPCODE>             { processMacroOpcode(t); }
       		|	<EOF>
       		)
        )
    )
}

//
//  Process macro opcode
//
void 		processMacroOpcode(Token t):
{
	String                      permError;
	int							saveEndStmt;
}
{
    {
        if (token_source.currMacro == null ||
            ! token_source.currMacro.macroName.equals(t.image.toUpperCase()))
            currMacro= macros.get(jSApi, t.image);
        else
            currMacro= token_source.currMacro;

        //
        //  Process opCode if no macro found
        //
        if (currMacro == null) {
            getOpCodeParms(t);
            return;
        }

        //
        //  Read macro in if not already done
        //
        currMacro.read();
        if (currMacro.permError != null)
          	throwParseException(currMacro.permError);

        //
        //  Initialize macro with DVMacroJSApi
        //
        currStatement.initializeMacro(currLabel, t);

        //
        //  Get parameters
        //
        getMacroParms();
        this.macroEvalParm+= ";";
        if (this.currMacro.minPosParmSize > this.macroPosParmNo)
            this.throwParseException("Number of positional parameters [%d] is too small, [%d] expected",
                this.macroPosParmNo, this.currMacro.minPosParmSize);

		for (int i= this.macroPosParmNo; i < this.currMacro.posParm.size(); i++) {
		  	DVMacroParm parm= this.currMacro.posParm.get(i);
		  	this.macroEvalParm+= "var " + parm.name + "=null;";
		} 
       	for (DVMacroParm parm : this.macroKeyParm.values()) {
       	  	if (parm.isList && parm.defaultValueEmpty && parm.minListSize != null)
       	  		throwParseException(
       	  		  	"Key-word parameter [%s] not defined and default is empty list - minimum list size is [%d]",
       	  		  	parm.name, parm.minListSize);
            this.macroEvalParm+= "var " + parm.defaultValue;
      	}

        //
        //  Execute macro
        //
        try {
            currMacro.execute(currStatement, jSApi, this.macroEvalParm);
        }
        catch(ScriptException e) {
          	throwParseException("JavaScript Error while executing macro [%s]\n%s",
                currMacro.macroName, e.getMessage());
        }
    }               
}

void 		getMacroParms() :
{
    this.macroEvalParm= "var Label=\"" + (this.currLabel == null ? "" : this.currLabel) + "\"";
    this.macroPosParmNo= 0;
    this.macroKeyParm= (HashMap<String, DVMacroParm>) this.currMacro.keyParm.clone();
    this.macroNestStack.clear();
}
{
	{ getMacroParm(); }
}

void 		getMacroParm() :
{
    Token       	t= null;
    DVMacroParm		parm= null;
}
{
  	( <MACRO_SPACES> ) *
  	  
  	(
        <EOF> 							{ return; }
 	) ?
 	
	{ this.macroEvalParm+= ";"; }
	
    (
        t= <MACRO_KEYWORD>
  	) ?

  	{
		if (t != null) { 
            parm= (DVMacroParm)
                this.macroKeyParm.remove(t.image.substring(0, t.image.length()-1).toUpperCase());
            if (parm == null)
                throwParseException(
                    "Invalid or duplicate keyword parameter [%s] encountered at position [%d]",
                    t.image, t.beginColumn);
      	}
        else {
            if (this.macroPosParmNo >= this.currMacro.posParm.size()) {
              	if (token == null) 
                	throwParseException("Extra positional parameter encountered");
            	else 
                	throwParseException("Extra positional parameter encountered at line %s position %d",
                		currStatement.lines[token.beginLine-1].lineNo, token.beginColumn);
          }
            parm= this.currMacro.posParm.get(this.macroPosParmNo);
            this.macroPosParmNo++;
      	}

        this.macroEvalParm+= "var " + parm.name + "=";
        if (parm.isList) {
            this.macroEvalParm+= "[";
            this.macroParmListNo= 0;
           	getMacroParmList(parm);
        }
        else if (parm.isBool || parm.isInt)
            getMacroParmBoolInt(parm);
        else
        	getMacroParmString(parm);
    }
}

void 		getMacroParmList(DVMacroParm parm) :
{
    Token       t;
}
{
  	(
  	  	<MACRO_SPACES>
  	) ?
  	
    (
		<EOF>    						{
  											if (parm.isList)
  												this.throwParseException(
  												  	"End of statement encountered before completion of list parameter value");
  											return;
										}
	) ?
	
    (
        <MACRO_OS>
    )
    
    {
        if (parm.isBool || parm.isInt)
            getMacroParmBoolInt(parm);
		else { 
        	this.macroNestStack.push('[');
       		getMacroParmString(parm);
       	}
    }
}

void 		getMacroParmBoolInt(DVMacroParm parm) :
{
    Token       t;
}
{
    (
      	<MACRO_SPACES>
  	) ?
  	
  	( 
        t= <MACRO_BOOL>                 {
                                            if (! parm.isBool)
												throwParseException("<MACRO_BOOLEAN> token encountered when <MACRO_INTEGER> expected " +
													"at line %s column %d", currStatement.lines[t.beginLine-1], t.beginColumn);
                                            String tmp= t.image.toLowerCase();
                                            if (tmp.equals("yes"))
                                                this.macroEvalParm+= "true";
                                            else if (tmp.equals("no"))
                                                this.macroEvalParm+= "false";
                                            else
                                                this.macroEvalParm+= tmp;
                                        }
    |
        t= <MACRO_INT>                  {
                                            if (! parm.isInt)
												throwParseException("<MACRO_INTEGER> token encountered when <MACRO_BOOLEAN> expected " +
													"at line %s column %d", currStatement.lines[t.beginLine-1], t.beginColumn);
                                            this.macroEvalParm+= t.image;
                                        }
    )

    (
      	<MACRO_SPACES>
  	) ?
      
    (
        t= <MACRO_CS>                   {
                                            if (parm.isList) { 
                                              	this.macroEvalParm+= "]";
  												this.macroParmListNo++;
                                              	endMacroParmList(parm);
                                              	return;
                                         	}
											throwParseException("Invalib character ']' encountered when expecting %s token " +
												"at line %s column %d", (parm.isInt ? "<MACRO_INTEGER>" : "<MACRO_BOOLEAN>"),
												currStatement.lines[t.beginLine-1], t.beginColumn);
                                        }
    |
        <MACRO_COMMA>                   {
  											if (parm.isList) { 
  												this.macroEvalParm+= ",";
  												this.macroParmListNo++;
  												getMacroParmBoolInt(parm);
  											}
											getMacroParm();
										}
  	| 
        <EOF>                           {
                                            if (parm.isList)
                                                throwParseException(
                                                    "End of statement encountered with an uncompleted boolean/integer list");
                                            return;
                                        }
    ) 
}

void		getMacroParmString(DVMacroParm parm) :
{
    Token       t;
    char        c, d;
    int         i;
    String      value= "";
    boolean		stringDefined= false;
    boolean		expFlag= true;
}
{  	 
    (
        <EOF>                           {
                                            if (this.macroNestStack.size() > 0)
                                                throwParseException("Missing bracket '%s' at end of macro header",
                                                    "0]}".charAt("([{".indexOf(this.macroNestStack.pop())));
                                            if (parm.isList)
                                                 throwParseException("End of statement encountered before and of string list");
                                                
                                            this.macroEvalParm+= "\"" + value.strip().replace("\\", "\\\\")
                                            	.replace("\"", "\\\"").replace("\'", "\\\'") + "\"";
                                            return;
                                        }
    |
    	(	t= <MACRO_KEYWORD>
   		|   t= <MACRO_SPACES> 
      	|   t= <MACRO_BOOL>
        |   t= <MACRO_INT>
        |   t= <MACRO_DATA>
        )                               { value+= t.image; }
    |
        (   t= <MACRO_OR>
        |   t= <MACRO_OS>
        |   t= <MACRO_OC>
        )                               {
                                            value+= t.image;
                                            this.macroNestStack.push(t.image.charAt(0));
                                        }
    |
        (   t= <MACRO_CR>
        |   t= <MACRO_CC>
        )                               {
                                            value+= t.image;
                                            if (this.macroNestStack.isEmpty())
                                                throwParseException("Extra bracket '%s' found at position %d",
                                                    t.image, t.beginColumn);
                                            c= this.macroNestStack.pop();
                                            d= t.image.charAt(0);
                                            if (! (c == '(' && d == ')' || c == '{' && d == '}'))
                                                throwParseException("Bracket mismatch - bracket '%c' at position [%d] does not match" +
                                                    " bracket '%c'", d, t.beginColumn, c);
                                        }
    |
        (   t= <MACRO_SQSTR>
        |   t= <MACRO_DQSTR>
        )                               { value+= t.image; }
    |
        t= <MACRO_DQNDL>                {
                                            value+= t.image.substring(2, t.image.length()-1);
                                            stringDefined= true;
                                            expFlag= false;
                                        }
    |
        t= <MACRO_CS>                   {
                                            if (this.macroNestStack.isEmpty())
                                                throwParseException(String.format(
                                                    "Unmatched square bracket ']' found at position[%d]", t.beginColumn));
                                            c= this.macroNestStack.pop();
                                            if (c != '[')
                                            	throwParseException("Bracket mismatch - square bracket ']' at position [%d] does not match" +
                                                	" bracket '%c'", t.beginColumn, c);
                                                	
                                            if (parm.isList && this.macroNestStack.isEmpty()) {
                                              	if (expFlag) {
                                              	  	String ts[]= DVUtil.expandList(value.strip().replace("\\", "\\\\")
                                            			.replace("\"", "\\\"").replace("\'", "\\\'"));
                                              	  	for (i= 0; i < ts.length-1; i++)
                                              	  		macroEvalParm+= "\"" + ts[i] + "\",";
                                          	  		macroEvalParm+= "\"" + ts[i] + "\"]";
                                          	  		this.macroParmListNo+= ts.length; 	  		
                                              	}
                                              	else { 
	                                                this.macroEvalParm+= "\"" + value.strip().replace("\\", "\\\\")
	                                            		.replace("\"", "\\\"").replace("\'", "\\\'") + "\"]";
  													this.macroParmListNo++;
												}

											  	int l= this.macroEvalParm.length();
											  	if (this.macroEvalParm.substring(l-4).equals("[\"\"]") && ! stringDefined)
											  		this.macroEvalParm= this.macroEvalParm.substring(0, l-4) + "[]";
                                        		endMacroParmList(parm);
                                        		return;
                                            }
                                            value+= t.image;
                                        }
    |
        t= <MACRO_COMMA>                {
                                            if (parm.isList && this.macroNestStack.size() > 1 || ! parm.isList && this.macroNestStack.size() > 0)
                                                throwParseException("Missing bracket '%s' at position [%d]", "0]}"
                                                    .charAt("([{".indexOf(this.macroNestStack.pop())), t.beginColumn);
                                                    
                                            if ((parm.isList && this.macroNestStack.size() == 1)) {
                                                if (expFlag) { 
                                              	  	String ts[]= DVUtil.expandList(value.strip().replace("\\", "\\\\")
                                            			.replace("\"", "\\\"").replace("\'", "\\\'"));
                                              	  	for (i= 0; i < ts.length; i++) 
                                              	  		macroEvalParm+= "\"" + ts[i] + "\",";
                                          	  		this.macroParmListNo+= ts.length;             	  		
                                              	}
                                              	else { 
	                                                this.macroEvalParm+= "\"" + value.strip().replace("\\", "\\\\")
	                                            		.replace("\"", "\\\"").replace("\'", "\\\'") + "\",";
                                          	  		this.macroParmListNo++;
  													expFlag= true;
                                          	  	} 
                                        		getMacroParmString(parm);
                                        		return;
                                    		}
                                    		
                                            if (! parm.isList && this.macroNestStack.isEmpty()) {  
                                                this.macroEvalParm+= "\"" + value.strip().replace("\\", "\\\\")
                                            		.replace("\"", "\\\"").replace("\'", "\\\'") + "\"";
                                                getMacroParm();
                                                return;
                                            }

                                            value+= t.image;
                                        }
    ) +
}

void 		endMacroParmList(DVMacroParm parm) :
{
  	Token				t;

	if (parm.minListSize != null) {
	  	if (parm.maxListSize != null &&
	  		(this.macroParmListNo < parm.minListSize || this.macroParmListNo > parm.maxListSize))
	  		throwParseException("List size [%d] for parameter [%s] is out of range - range is [%d-%d]",
	  			this.macroParmListNo, parm.name, parm.minListSize, parm.maxListSize);
	  	if (parm.maxListSize == null && this.macroParmListNo != parm.minListSize)
	  		throwParseException("List size [%d] for parameter [%s] is incorrect - correct size is [%d]",
	  			this.macroParmListNo, parm.name, parm.minListSize);
	}  		
}
{
    (
      	<MACRO_SPACES>
  	) ?
  	
	(
	  	<MACRO_COMMA>					{ getMacroParm(); }
	|
		<EOF>
	)   
}

//
//  Get opCode parms
//
void	getOpCodeParms(Token opCode): {
    Token                   t;
    DVStatements.Statement  stmt= currStatement;

    opCodeParm= new DVOpCodeParm();
}
{
    	<EOF>                          	{ stmt.processOpCode(currLabel, opCode, opCodeParm); }

    |   (
            ( <OPCODE_SPACES> ) +
            (
                <EOF>                   { 
											stmt.processOpCode(currLabel, opCode, opCodeParm);
											return;
										}
            )?

            { 
                getOpCodeParm();
                stmt.processOpCode(currLabel, opCode, opCodeParm);
            }
        )
}

//
//  Get one opCode parameter
//
void		getOpCodeParm(): {
    Token       t;

    DVStatements.Statement  stmt= currStatement;
    subParmState= false;
    currKey= null;
    
}
{
    (
        t= <KEY>                        {
                                            currKey= t;
                                            String v= t.image.substring(0, t.image.length()-1).toUpperCase();
                                            for (DVOpCodeParm.KeyWordParm k : opCodeParm.keyWordParmList) {
                                                if (v.equals(k.keyValue))
                                                    throwParseException(
                                                        "Duplicate keyword <%s> at line %s column %d",
                                                        t.image, currStatement.lines[t.beginLine-1].lineNo, t.beginColumn);
                                            }
                                        }
    )? 									{   currExpression= new DVExpression(currStatement); }
    (
		<COMMA> 						{
		    								addOpCodeExpression();
		    								getOpCodeParm();
		    								return;
		    							}
	|	<LSQUARE> 						{ 
                                            addOpCodeExpression();
                                            subParmState= true;
                                            getOpCodeSubParm();
                                            return;
                                        }
	|   <EOF>    						{
	    									addOpCodeExpression();
                                            return;	    									
                                    	}
    )?
    
    									{ getOpCodeUnaryOperator(); }
}

//
//  Get one opCode sub-parameter
//
void	getOpCodeSubParm(): { }
{
 	{ currExpression= new DVExpression(currStatement); }
 	
	(
		<COMMA> 						{
											getOpCodeSubParm();
											return;
										}
	)?
	
    { getOpCodeUnaryOperator(); }
}


//
//  Get a unary operator if any
//
void		getOpCodeUnaryOperator(): {
    Token       t;
}
{
    (
        t= <UPLUS>                      { currExpression.addOperatorToken(t, DVExpression.OperType.UPLUS); }
    |   t= <UMINUS>                     { currExpression.addOperatorToken(t, DVExpression.OperType.UMINUS); }
    |   t= <BNOT>                       { currExpression.addOperatorToken(t, DVExpression.OperType.BNOT); }
    |   t= <LNOT>                       { currExpression.addOperatorToken(t, DVExpression.OperType.LNOT); }
    )?

    									{ getOpCodeValue(); }
}

//
//  Get expression value
//
void		getOpCodeValue(): {
    Token       t;
}
{
    (
        (
            t= <BASESYMBOL>             { currExpression.addBaseSymbolToken(t); }
    	|   t= <QSYMBOL> 				{ currExpression.addQualifiedSymbolToken(t); }
        |   t= <SYMBOL>                 { currExpression.addSymbolToken(t, DVSymbols.SymbolComponent.VALUE); }
        |   t= <LENGTH>                 { currExpression.addSymbolToken(t, DVSymbols.SymbolComponent.LENGTH); }
        |   t= <REPL>                   { currExpression.addSymbolToken(t, DVSymbols.SymbolComponent.REPL); }
        | 	t= <SIZE> 					{ currExpression.addSymbolToken(t, DVSymbols.SymbolComponent.SIZE); }
        |   t= <COUNTER>                { currExpression.addCounterToken(t); }
        |   t= <FLOAT>                  { currExpression.addFloatToken(t); }
        |   t= <INTEGER>                { currExpression.addIntegerToken(t); }
        |   t= <BIN>                    { currExpression.addBinToken(t); }
        |   t= <HEX>                    { currExpression.addHexToken(t); }
        |   t= <CHAR>                   { currExpression.addCharToken(t); }
        |   t= <STRING>                 {
            								String err= currExpression.addStringToken(t);
            								if (err != null)
            								     throwParseException(
            										"Parse string error for string on line %s column %d\n" +
            										"Parse error message is: %s",
            										currStatement.lines[t.beginLine-1].lineNo, t.beginColumn, err);
            							}
        )                               { 
											getOpCodeBinaryOperator();
											return;
										}
    )

    |   t= <LPAREN>                     { 
                                            currExpression.addOperatorToken(t, DVExpression.OperType.LPAREN);
                                            getOpCodeUnaryOperator();
                                        }
}

//
//  Get expression binary operator
//
void	getOpCodeBinaryOperator(): {
    Token       t;
}
{
    (
        (
            t= <POWER>                  { currExpression.addOperatorToken(t, DVExpression.OperType.POWER); }
        |   t= <MULTIPLY>               { currExpression.addOperatorToken(t, DVExpression.OperType.MULTIPLY); }
        |   t= <DIVIDE>                 { currExpression.addOperatorToken(t, DVExpression.OperType.DIVIDE); }
        |   t= <REMINDER>               { currExpression.addOperatorToken(t, DVExpression.OperType.REMINDER); }
        |   t= <PLUS>                   { currExpression.addOperatorToken(t, DVExpression.OperType.PLUS); }
        |   t= <MINUS>                  { currExpression.addOperatorToken(t, DVExpression.OperType.MINUS); }
        |   t= <SHIFTLEFT>              { currExpression.addOperatorToken(t, DVExpression.OperType.SHIFTLEFT); }
        |   t= <SHIFTRIGHT>             { currExpression.addOperatorToken(t, DVExpression.OperType.SHIFTRIGHT); }
        |   t= <GT>                     { currExpression.addOperatorToken(t, DVExpression.OperType.GT); }
        |   t= <GE>                     { currExpression.addOperatorToken(t, DVExpression.OperType.GE); }
        |   t= <LT>                     { currExpression.addOperatorToken(t, DVExpression.OperType.LT); }
        |   t= <LE>                     { currExpression.addOperatorToken(t, DVExpression.OperType.LE); }
        |   t= <EQ>                     { currExpression.addOperatorToken(t, DVExpression.OperType.EQ); }
        |   t= <NE>                     { currExpression.addOperatorToken(t, DVExpression.OperType.NE); }
        |   t= <BAND>                   { currExpression.addOperatorToken(t, DVExpression.OperType.BAND); }
        |   t= <BXOR>                   { currExpression.addOperatorToken(t, DVExpression.OperType.BXOR); }
        |   t= <BOR>                    { currExpression.addOperatorToken(t, DVExpression.OperType.BOR); }
        |   t= <LAND>                   { currExpression.addOperatorToken(t, DVExpression.OperType.LAND); }
        |   t= <LOR>                    { currExpression.addOperatorToken(t, DVExpression.OperType.LOR); }
        )                               {
          									getOpCodeValue();
          									return;
      									}
    )
    |   t= <RPAREN>                     { 
                                            currExpression.addOperatorToken(t, DVExpression.OperType.RPAREN);
                                            getOpCodeBinaryOperator();
                                            return;
                                        }
    |   <LSQUARE>                       { 
                                            addOpCodeExpression();
                                            subParmState= true;
                                            getOpCodeSubParm();
                                            return;
                                        }
    |   <RSQUARE>
        (
            <COMMA>                     {
                                            addOpCodeExpression();
                                            subParmState= false;
                                            getOpCodeParm();
                                            return;
                                        }
        |   <EOF>                       {
                                            addOpCodeExpression();
                                            subParmState= false;
                                            return;
                                        }
        )
    |   <COMMA>                         {
                                            addOpCodeExpression();
                                            if (subParmState)
                                                getOpCodeSubParm();
                                            else
                                                getOpCodeParm();
                                            return;
                                        }
    |   t= <EOF>                        {
                                            addOpCodeExpression();
                                            if (subParmState)
                                                throwParseException("Umatched square bracket");
                                            return;
                                        }
}

//
//  End expression and add it to opCode parameter
//
void        addOpCodeExpression():
{
    currExpression.expressionEnd();

    if (subParmState) {
        DVOpCodeParm.PositionalParm posParm= opCodeParm.posParmList.get(opCodeParm.posParmList.size()-1);
        posParm.addSubParameter(currExpression);
    }
    else {
        if (currKey != null)            { opCodeParm.new KeyWordParm(currKey, currExpression); }
        else                            { opCodeParm.new PositionalParm(currExpression); }
    }
    return;
}
{ { } }

//
//  Issue ParseException due to parsing error
//
void	throwParseException(String fmt, Object... args): { }
{
    { throw new ParseException(String.format(fmt, args)); }
}