//--------------------------------------------------------------------------------------------------
//
//  @ 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 for inline code lines in macros
//
//------------------------------------------------------------------------------

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

PARSER_BEGIN(DVMacroInlineParser)

package			framework;

public          class   DVMacroInlineParser {

    //
    //  Class fields
    //
    protected       String[]        retString= { "", "", "", "" };
    protected       String          error= "";
    private         int             ndx= 0;
}

PARSER_END(DVMacroInlineParser)

//
//  Token manager declarations
//
TOKEN_MGR_DECLS : {
    private         int             outerState= -1;
}

//
//  Tokens
//
<DEFAULT,
 OPCODE_STATE,
 PARMS_STATE>                       TOKEN : {
        <START_COMM:                (("//") | ("/>"))>          : COMM_STATE
 }

<DEFAULT,
 OPCODE_STATE,
 PARMS_STATE,
 COMM_STATE,
 DQ_STATE,
 SQ_STATE>                          TOKEN : {
        <VAR:                       ((["#"]["a"-"z","A"-"Z","_"])(["a"-"z","A"-"Z","_","0"-"9"])*(["."])?)>
    |   <SQ:                        ["'"]>                      {
                                                                    if (this.outerState == -1) {
                                                                        this.outerState= curLexState;
                                                                        SwitchTo(SQ_STATE);
                                                                    }
                                                                    else {
                                                                        if (curLexState == SQ_STATE) {
                                                                            SwitchTo(this.outerState);
                                                                            this.outerState= -1;
                                                                        }
                                                                    }
                                                                }
    |   <DQ:                        ["\""]>                     {
                                                                    if (this.outerState == -1) {
                                                                        this.outerState= curLexState;
                                                                        SwitchTo(DQ_STATE);
                                                                    }
                                                                    else {
                                                                        if (curLexState == DQ_STATE) {
                                                                            SwitchTo(this.outerState);
                                                                            this.outerState= -1;
                                                                        }
                                                                    }
                                                                }
    |   <ESC:                       ((["\\"]["\""]) | (["\\"]["\'"]) | (["\\"]["\\"]) | (["\\"]["#"]))>
    |   <BSL:                       ["\\"]>
}

<COMM_STATE,
 SQ_STATE,
 DQ_STATE>                          TOKEN : {
    <DANY:                          ((~["\\","\"","'","#"])+)>
}

<DEFAULT>                           TOKEN : {
        <LABEL_BLANKS:              (([" ","\t"])+)>            : OPCODE_STATE
    |   <LABEL:                     ((~[" ","\t","\\","\"","'","#"]))>
}

<OPCODE_STATE>                      TOKEN : {
        <OPCODE_BLANKS:             (([" ","\t"])+)>            : PARMS_STATE
    |   <OPCODE:                    ((~[" ","\t","\\","\"","'","#"]))>
}

<PARMS_STATE>                       TOKEN : {
        <PARMS:                     ((~["\\","\"","'","#"]))>
}

<ERROR_STATE>                       TOKEN : {
        <EANY:                       ((~[]))>
}

//
//  Start grammar here
//
void start():
{
    Token           		t;
}
{
    (
        t= <LABEL>                      { this.retString[0]+= t.image; }
    |   <LABEL_BLANKS>                  { this.ndx= 1; }
    |   t= <OPCODE>                     { this.retString[1]+= t.image; }
    |   <OPCODE_BLANKS>                 { this.ndx= 2; }
    |   t= <PARMS>                      { this.retString[2]+= t.image; }
    |   t= <START_COMM>                 {
                                            this.ndx= 3;
                                            if (retString[0].equals("") && retString[1].equals("") &&
                                                retString[2].equals("")) {
                                                if (t.beginColumn == 1)
                                                    this.ndx= 0;
                                                else if (t.beginColumn <= 12)
                                                    this.ndx= 1;
                                            }
                                            this.retString[this.ndx]+= t.image;
                                        }
    |   t= <VAR>                        { processVar(t); }
    |   t= <DANY>                       { this.retString[ndx]+= t.image; }
    |   t= <SQ>                         { processSQ(t); }
    |   t= <DQ>                         { processDQ(t); }
    |   t= <ESC>                        { processEsc(t); }
    |   t= <BSL>                        { this.retString[this.ndx]+= "\\\\"; }
    |   <EOF>                           { return; }
    ) +
}

void    processVar(Token t):
{
    String  var= t.image.substring(1);
}
{
    {
        if (var.charAt(var.length()-1) == '.')
            var= var.substring(0, var.length()-1);
        this.retString[this.ndx]+= "\" + " + var + " + \"";
    }
}

void    processSQ(Token t):
{
    int     start= t.beginColumn;
}
{
    {
        retString[this.ndx]+= "\\\'";
    }

    (
        t= <VAR>                        { processVar(t); }
    |   t= <ESC>                        { processEsc(t); }
    |   t= <SQ>                         {
                                            this.retString[this.ndx]+= "\\\'";
                                            return;
                                        }
    |   t= <DQ>                         { this.retString[this.ndx]+= "\\\""; }
    |   t= <BSL>                        { this.retString[this.ndx]+= "\\\\"; }
    |   t= <DANY>                       { this.retString[this.ndx]+= t.image; }
    |   <EOF>                           {
      										if (this.ndx < 3)
                                            	this.error= String.format("Single quote at position [%d] is unmatched", start+1);
                                            return;
                                        }
    ) +
}

void    processDQ(Token t):
{
    int     start= t.beginColumn;
}
{
    {
        retString[this.ndx]+= "\\\"";
    }

    (
        t= <VAR>                        { processVar(t); }
    |   t= <ESC>                        { processEsc(t); }
    |   t= <SQ>                         { this.retString[this.ndx]+= "\\\'"; }
    |   t= <DQ>                         {
                                            this.retString[this.ndx]+= "\\\"";
                                            return;
                                        }
    |   t= <BSL>                        { this.retString[this.ndx]+= "\\\\"; }
    |   t= <DANY>                       { this.retString[this.ndx]+= t.image; }
    |   <EOF>                           {
      										if (this.ndx < 3)
                                            	this.error= String.format("Double quote at position [%d] is unmatched", start+1);
                                            return;
                                        }
    ) +
}

void    processEsc(Token t): {
    char    ec= t.image.charAt(1);
}
{
    {
        if (ec == '#')
            this.retString[this.ndx]+= ec;
        else
            this.retString[this.ndx]+= "\\\\\\" + ec;
    }
}