//--------------------------------------------------------------------------------------------------
//
//  @ 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 use to parse macro's header line
//
//------------------------------------------------------------------------------

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

PARSER_BEGIN(DVMacroHeaderParser)

package			framework;

import          java.util.LinkedList;
import          java.util.ArrayList;
import          java.util.HashMap;
import          javax.script.ScriptException;

public          class   DVMacroHeaderParser {

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

    DVMacros.Macro                  macro;

    LinkedList<Character>           nestStack= new LinkedList<Character>();
}

PARSER_END(DVMacroHeaderParser)

//
//  Token manager declarations
//
TOKEN_MGR_DECLS : {
    protected		int     							nestCount= 0;
}

//
//  Tokens
//
<PARM_STATE,
 PVALUE_STATE>                      SKIP : {
    	<                           (("/>") ((~["\n"])*) ("\n//") ([" ","\t"])*)>
}

<PARM_STATE,
 PVALUE_STATE>                      TOKEN : {
    	<EOH:                       ((("//") ((~["\n"])*) ("\n")) | ("\n"))>
}

<DEFAULT>                           TOKEN : {
        <START:                     ("//MACRO")>
}

<DEFAULT>                           TOKEN [IGNORE_CASE] : {
   	   	<START_SPACES:              (([" ","\t"])+)>
    |   <START_NAME:                (((["a"-"z","_"]) (["a"-"z","_","0"-"9"])*)
                                        ((["."]["a"-"z","_"]) (["a"-"z","_","0"-"9"])*)*)>
                                                                : PARM_STATE
}

<PARM_STATE>                        TOKEN [IGNORE_CASE] : {
        <PARM_INT:                  ("{integer}")>
    |   <PARM_BOOL:                 ("{boolean}")>
    |   <PARM_OPT:                  ("{optional}") (([" ","\t"])*) ([","])>
}

<PARM_STATE>                        TOKEN : {
        <PARM_NAME:                 ((["a"-"z","A"-"Z","_"]) (["a"-"z","A"-"Z","_","0"-"9"])*)>
    |   <PARM_SPACES:               (([" ","\t"])+)>
    |   <PARM_LIST:                	("[") ("]")>
	|   <PARM_NLIST:               	("[") <LISTN> ("]")>
	|   <PARM_NLISTN:              	("[") <LISTN> (("-")?) <LISTN> ("]")>
    |   <PARM_KEY:                  ("=")>                      : PVALUE_STATE
    |   <PARM_COMMA:                (",")>

	|	<#LISTN:					(["1"-"9"]) ((["0"-"9"])?)> 
}

<PVALUE_STATE>                      TOKEN [IGNORE_CASE] : {
        <VALUE_BOOL:                (("true") | ("yes") | ("false") | ("no"))>
}

<PVALUE_STATE>                      TOKEN : {
        <VALUE_SPACES:              (([" ","\t"])+)>
    |   <VALUE_INT:                 ((["-","+"])?(["0"-"9"])+)>
    |   <VALUE_DQNDL:               ((["!"]["\""] ((~["\"","\n"]) | ("\\\""))* ["\""])+)>
    |   <VALUE_SQSTR:               ((["\'"] ((~["\'","\n"]) | ("\\\'"))* ["\'"])+)>
    |   <VALUE_DQSTR:               ((["\""] ((~["\"","\n"]) | ("\\\""))* ["\""])+)>
    |   <VALUE_OR:                  ("(")>                      { this.nestCount++; }
    |   <VALUE_CR:                  (")")>                      { this.nestCount--; }
    |   <VALUE_OS:                  ("[")>                      { this.nestCount++; }
    |   <VALUE_CS:                  ("]")>                      { this.nestCount--; }
    |   <VALUE_OC:                  ("{")>                      { this.nestCount++; }
    |   <VALUE_CC:                  ("}")>                      { this.nestCount--; }
    |   <VALUE_COMMA:               (",")>                      {
                                                                    if (this.nestCount <= 0)
                                                                        SwitchTo(PARM_STATE);
                                                                }
    |   <VALUE_DATA:                ((~[" ","\t",",","(",")","[","]","{","}","\"","'"]))>
}

<DEFAULT,
 PARM_STATE,
 PVALUE_STATE>                      TOKEN : {
    <INVALID:                       (~[])>
}

//
//  Start grammar here
//
void start(DVMacros.Macro macro) throws ScriptException:
{
    this.macro= macro;
    Token           		t;
}
{
  	(
        <START>
        <START_SPACES>
        t= <START_NAME>                 	{
                                                if (! this.macro.macroName.equalsIgnoreCase(t.image))
                                                    error("Header macro name [%s] does not match external macro name [%s]",
                                                        t.image, macro.macroName);
                                                getParm();
                                                if (macro.minPosParmSize == null)
                                                    macro.minPosParmSize= macro.posParm.size();
                                                return;
                                            }
    )
}

void 	getParm() throws ScriptException:
{
    Token       t;

    String      nameList= "";
    int			x= 0;

    DVMacroParm		parm= null;
}
{
    (
        ( <PARM_SPACES> ) ?
        (
            t= <PARM_OPT>                       {
                                                    if (macro.minPosParmSize == null) {
                                                        macro.minPosParmSize= macro.posParm.size();
														getParm();
														return;
                                                    }
                                                    error("Dupliate optional directive at position [%d]", t.beginColumn);
                                                }
        |
            t= <PARM_NAME>                      {
                                                    if (t.image.equals("Label"))
                                                        error("Parameter name [Label] encountered in position[%d] is reserved and cannot be used",
                                                            t.beginColumn);
                                                    if (nameList.indexOf(" " + t.image + " ") >= 0)
                                                        error("Duplicate parameter name [%s] at position [%d]",
                                                            t.image, t.beginColumn);
                                                    nameList+= " " + t.image + " ";
                                                    parm= new DVMacroParm(t.image);
                                                }
        |
            <EOH>                               { return; }
        )
        (
            <PARM_INT>                          { parm.isInt= true; }
        |
            <PARM_BOOL>                         { parm.isBool= true; }
        ) ?
        (
            t= <PARM_LIST>                      { parm.isList= true; }
        |
            t= <PARM_NLIST>                     {
                                                	parm.isList= true;
                                                    parm.minListSize= Integer.valueOf(t.image.substring(1, t.image.length()-1));
                                                }
        |
            t= <PARM_NLISTN>                    {
                                                	parm.isList= true;
                                                    x= t.image.indexOf('-');
                                                    parm.minListSize= Integer.valueOf(t.image.substring(1, x));
                                                    parm.maxListSize= Integer.valueOf(t.image.substring(x+1, t.image.length()-1));
                                                }
        ) ?
        (
            <PARM_KEY>                          {
                                                    parm.isKeyWord= true;
                                                    macro.keyParm.put(parm.name.toUpperCase(), parm);
                                                    parm.defaultValue= parm.name + "=";
                                                    if (parm.isList)
                                                        getValueList(parm);
                                                    else if (parm.isBool || parm.isInt)
                                                        getValueType(parm);
                                                    else
                                                        getValueStr(parm);
                                                    return;
                                                }
      	) ?
      	(	<PARM_SPACES> ) ?
      	(
            <PARM_COMMA>                        {
                                                    macro.posParm.add(parm);
              										getParm();
                                                    return;
                                                }
        |
            <EOH>                               {
                                                    macro.posParm.add(parm);
                                                    return;
                                                }
        )
    )
}

void getValueList(DVMacroParm parm) throws ScriptException:
{
    Token       t;
}
{
    (   <VALUE_SPACES>  ) ?
    (
        <VALUE_OS>
    )
    {
        parm.defaultValue+= "[";
        if (parm.isBool || parm.isInt)
            getValueType(parm);
        else {
            this.nestStack.push('[');
            getValueStr(parm);
        }
    }
}

void		getValueType(DVMacroParm parm) throws ScriptException:
{
    Token       t;
    int			parmListNo= 0;
}
{
  	(
	    ( <VALUE_SPACES> ) ?                        // Clear leading spaces
	    (
        	t= <VALUE_BOOL>                     {
                                                    if (! parm.isBool)
                                                        processInvalid(t);
                                                    String tmp= t.image.toLowerCase();
                                                    if (tmp.equals("yes"))
                                                        parm.defaultValue+= "true";
                                                    else if (tmp.equals("no"))
                                                        parm.defaultValue+= "false";
                                                    else
                                                        parm.defaultValue+= tmp;
                                                }
	    |
	        t= <VALUE_INT>                      {
                                                    if (! parm.isInt)
                                                        processInvalid(t);
                                                    parm.defaultValue+= t.image;
                                                }
    )
    ( <VALUE_SPACES> ) ?
    (
        t= <VALUE_CS>                           {
                                                    if (parm.isList) {
                                                    	parm.defaultValue+= "]";
                                                    	parmListNo++;
                                                      	if (parm.minListSize != null) { 
											        	  	if (parm.maxListSize != null &&
											        	  		(parmListNo < parm.minListSize || parmListNo > parm.maxListSize))
											        	  		error("List size [%d] for parameter [%s] in macro header is out of range - range is [%d-%d]",
											        	  			parmListNo, parm.name, parm.minListSize, parm.maxListSize); 
											        	  	if (parm.maxListSize == null && parmListNo != parm.minListSize)
											        	  		error("List size [%d] for parameter [%s] in macro header is incorrect - correct size is [%d]",
											        	  			parmListNo, parm.name, parm.minListSize);   
													 	}
                                                        endList(parm);
                                                        return;
                                                    }
                                                    processInvalid(t);
                                                }
	    |
	        <VALUE_COMMA>                       {
	          										if (parm.isList) { 
                                                    	parm.defaultValue+= ",";
														parmListNo++;
													}
													else {
                                                    	parm.defaultValue+= ";";
													  	getParm(); 
	          											return;
	          										}
          										}
	    |
	       <EOH>                         		{
                                                    if (parm.isList)
                                                        error("End of header encountered with an uncompleted boolean/integer list");
                                                    parm.defaultValue+= ";";
                                                    return;
                                                }
      	)
    ) +
}

void		getValueStr(DVMacroParm parm) throws ScriptException:
{
    Token       t;
    char        c, d;
    int         i;
    String      value= "";
    boolean		expFlag= true;
    int			parmListNo= 0;
}
{
    (
        (   t= <VALUE_SPACES>
        |   t= <VALUE_BOOL>
        |   t= <VALUE_INT>
        |   t= <VALUE_DATA>
        )                                       { value+= t.image; }
    |
        (   t= <VALUE_OR>
        |   t= <VALUE_OS>
        |   t= <VALUE_OC>
        )                                       {
                                                    value+= t.image;
                                                    this.nestStack.push(t.image.charAt(0));
                                                }
    |
        (   t= <VALUE_CR>
        |   t= <VALUE_CC>
        )                                       {
                                                    value+= t.image;
                                                    if (this.nestStack.isEmpty())
                                                        error("Extra bracket '%s' found at position %d",
                                                            t.image, t.beginColumn);
                                                    c= this.nestStack.pop();
                                                    d= t.image.charAt(0);
                                                    if (! (c == '(' && d == ')' || c == '{' && d == '}'))
                                                        error("Bracket mismatch - bracket '%c' at position [%d] does not match" +
                                                            " bracket '%c'", d, t.beginColumn, c);
                                                }
    |
        (   t= <VALUE_SQSTR>
        |   t= <VALUE_DQSTR>
        )                                       { value+= t.image.replace("\\", "\"")
                                                    .replace("\\\"", "\"").replace("\\\'", "'"); }
    |
        t= <VALUE_DQNDL>                        {
                                                    value+= t.image.substring(2, t.image.length()-1)
                                                        .replace("\\", "\"").replace("\\\"", "\"").replace("\\\'", "'");
                                                    expFlag= false;
                                                }
    |
        t= <VALUE_CS>                           {
                                                    if (this.nestStack.isEmpty())
                                                        error("Unmatched square bracket ']' found at position[%d]", t.beginColumn);
                                                    this.nestStack.pop();
                                                    if (parm.isList && this.nestStack.size() == 0) {
                                                        if (expFlag) {
		                                              	  	String ts[]= DVUtil.expandList(value.strip().replace("\\", "\\\\")
		                                            			.replace("\"", "\\\"").replace("\'", "\\\'"));
		                                              	  	for (i= 0; i < ts.length-1; i++)
		                                              	  		parm.defaultValue+= "\"" + ts[i] + "\",";
		                                          	  		parm.defaultValue+= "\"" + ts[i] + "\"]";
		                                          	  		parmListNo+= ts.length;   
                                                        }
                                                        else { 
                                                        	parm.defaultValue+= "\"" + value.strip().replace("\\", "\\\\")
	                                            				.replace("\"", "\\\"").replace("\'", "\\\'") + "\"]";
  															parmListNo++;
														}

														int l= parm.defaultValue.length();
													  	if (parm.defaultValue.substring(l-4).equals("[\"\"]") && expFlag) { 
													  		parm.defaultValue= parm.defaultValue.substring(0, l-4) + "[]";
													  		parm.defaultValueEmpty= true;
													  	}
													  	else if (parm.minListSize != null) { 
											        	  	if (parm.maxListSize != null &&
											        	  		(parmListNo < parm.minListSize || parmListNo > parm.maxListSize))
											        	  		error("List size [%d] for parameter [%s] in macro header is out of range - range is [%d-%d]",
											        	  			parmListNo, parm.name, parm.minListSize, parm.maxListSize); 
											        	  	if (parm.maxListSize == null && parmListNo != parm.minListSize)
											        	  		error("List size [%d] for parameter [%s] in macro header is incorrect - correct size is [%d]",
											        	  			parmListNo, parm.name, parm.minListSize);   
													 	}
													 	endList(parm);
                                                        return;
                                                    }
                                                    value+= t.image;
                                                }
    |
        t= <VALUE_COMMA>                        {
                                                    if (this.nestStack.size() == 0 || (parm.isList && this.nestStack.size() == 1)) {
                                                        if (expFlag) {
		                                              	  	String ts[]= DVUtil.expandList(value.strip().replace("\\", "\\\\")
		                                            			.replace("\"", "\\\"").replace("\'", "\\\'"));
		                                              	  	for (i= 0; i < ts.length-1; i++)
		                                              	  		parm.defaultValue+= "\"" + ts[i] + "\",";
	                                              	  		parm.defaultValue+= "\"" + ts[i] + "\"";
		                                          	  		parmListNo+= ts.length;   
                                                        }
                                                        else { 
                                                        	parm.defaultValue+= "\"" + value.strip().replace("\\", "\\\\")
	                                            				.replace("\"", "\\\"").replace("\'", "\\\'") + "\"";
  															parmListNo++;
														}
                                                    }

                                                    if (this.nestStack.size() == 0) {
          												parm.defaultValue+= ";";
                                                      	getParm();
                                                      	return;
                                                  	}
      												parm.defaultValue+= ",";
      												value= "";
                                                }
    |
        <EOH>                                   {
                                                    if (this.nestStack.size() > 0)
                                                        error("Missing bracket '%s' at end of macro header",
                                                            "0]}".charAt("([{".indexOf(this.nestStack.pop())));
                                                    parm.defaultValue+= "\"" + value.strip().replace("\\", "\\\\")
                                        				.replace("\"", "\\\"").replace("\'", "\\\'") + "\";";
                                                    return;
                                                }
    ) +
}

void 		endList(DVMacroParm parm) throws ScriptException:
{ }
{
    (
        <VALUE_COMMA> 							{
          											parm.defaultValue+= ";";
          											getParm();
          											return;
  												}
    |   <EOH>
    )
}

void 		processInvalid(Token t) throws ScriptException: { }
{
    {
        error(String.format("Invalid character '%s' found at position [%d]",
            t.image, t.beginColumn));
    }
}

void 		error(String fmt, Object... args) throws ScriptException:
{}
{
    {
        if (macro.permError == null)
            macro.permError= String.format(fmt, args);
        throw new ScriptException(macro.permError);
     }
}