StatProperty.lst

// ==========================================================================
//  GPPG error listing for yacc source file <LSLib\LS\Stats\Parser\StatProperty.yy - 16/11/2023 19:11:10>
// ==========================================================================
//  Version:  1.5.2
//  Machine:  DESKTOP-8T9LV7S
//  DateTime: 16/11/2023 19:11:14
//  UserName: Norbyte
// ==========================================================================


%namespace LSLib.LS.Stats.Properties
%partial 
%visibility public
%parsertype StatPropertyParser
%tokentype StatPropertyTokens
%YYSTYPE System.Object

%start Root

/* Trigger Lexemes */
%token EXPR_PROPERTIES
%token EXPR_REQUIREMENTS

/* Requirements */
%token REQUIREMENT_TAG

/* Reserved words */
%token IF

/* Special token for invalid characters */
%token BAD

/* Functor Context */
%token CONTEXT
/* Status/Tag name */
%token NAME
/* Known text keys */
%token TEXT_KEY
/* Integer literal */
%token INTEGER
/* Text-like (unquoted) literal */
%token TEXT

/* Lua binary operator */
%token BINOP
/* Lua unary operator */
%token UNOP
/* Lua binary or unary operator */
%token BIN_OR_UNOP
/* nil, true, false */
%token LUA_RESERVED_VAL
/* quoted strings */
%token LITERAL_STRING

%%
// Warning: NonTerminal symbol "LuaSymbol" is unreachable
// Warning: NonTerminal symbol "LFuncName" is unreachable
// Warning: NonTerminal symbol "LuaExpr" is unreachable
// Warning: NonTerminal symbol "LuaRootX" is unreachable
// Warning: NonTerminal symbol "LuaRootSymbol" is unreachable
// ----------------------------------------------------------

/* A special "trigger word" is prepended to support parsing multiple types from the same lexer/parser */
Root : EXPR_PROPERTIES Properties { $$ = $2; }
     | EXPR_REQUIREMENTS Requirements { $$ = $2; }
     ;


/******************************************************************
 *
 *
 *                        REQUIREMENTS PARSING
 *
 *
 ******************************************************************/
 
Requirements : /* empty */ { $$ = MakeRequirements(); }
             | UnaryRequirement { $$ = AddRequirement(MakeRequirements(), $1); }
             | Requirements ';'
             | Requirements ';' UnaryRequirement { $$ = AddRequirement($1, $3); }
             ;

UnaryRequirement : Requirement
                 | '!' Requirement { $$ = MakeNotRequirement($2); }
                 ;

Requirement : NAME { $$ = MakeRequirement($1); }
            | NAME INTEGER { $$ = MakeIntRequirement($1, $2); }
            | REQUIREMENT_TAG TEXT { $$ = MakeTagRequirement($1, $2); }
            | REQUIREMENT_TAG NAME { $$ = MakeTagRequirement($1, $2); }
            ;


/******************************************************************
 *
 *
 *                        PROPERTY PARSING
 *
 *
 ******************************************************************/
 
Properties : /* empty */ { $$ = MakePropertyList(); }
           | Property { $$ = AddProperty(MakePropertyList(), $1); }
           | Properties ';'
           | Properties ';' Property { $$ = AddProperty($1, $3); }
           ;

TextKeyProperties : TEXT_KEY '[' Properties ']' { $$ = SetTextKey($3, $1); };

Property : PropContexts PropCondition FunctorCall { $$ = MakeProperty($1, $2, $3); }
         | TextKeyProperties
         ;

PropContexts : /* empty */
             | PropContextList { $$ = $1; }
             ;

PropContextList : PropContext { $$ = $1; }
                | PropContextList PropContext { $$ = $1; }
                ;

PropContext : CONTEXT ':' { $$ = $1; };

PropCondition : /* empty */
              | IF '(' LuaRoot ')' ':' { $$ = $3; }
              ;

FunctorCall : NAME '(' OptionalFunctorArgs ')' { $$ = MakeAction($1, $3); };

OptionalFunctorArgs : /* empty */ { $$ = MakeArgumentList(); }
                    | FunctorArgs
                    ;

FunctorArgs : FunctorArg { $$ = AddArgument(MakeArgumentList(), $1); }
           | FunctorArgs ',' FunctorArg { $$ = AddArgument($1, $3); }
           ;

FunctorArg : LuaRoot { $$ = MakeArgument($1); };

LuaRootX : LuaRootSymbol
        | LuaRoot LuaRootSymbol
        | LuaRoot '(' LuaExpr ')'
        | LuaRoot '(' ')'
        | '(' LuaExpr ')'
        ;

LuaExpr : LuaSymbol
        | LuaExpr LuaSymbol
        | LuaExpr '(' LuaExpr ')'
        | '(' LuaExpr ')'
        | LuaExpr '(' ')'
        ;

LuaRootSymbol : NAME
              | INTEGER
              | TEXT
              | CONTEXT
              | ':'
              | '!'
              ;

LuaSymbol : LuaRootSymbol
          | ','
          ;

LuaRoot : LExp;


LFuncName : NAME;
// Ignore x.x.x and x:y {'.' Name} [':' Name]

LVar : NAME 
     | LPrefixExp '[' LExp ']' 
     | LPrefixExp '.' NAME
     ;

LOptionalExpList : /* empty */
                 | LExpList
                 ;

LExpList : LExp 
         | LExpList ',' LExp
         ;

LExp : LExpNoUnOp
     | LUnOp LExp
     ;

LExpNoUnOp : LUA_RESERVED_VAL
     | INTEGER 
     | LITERAL_STRING
     | LPrefixExp 
     | LTableConstructor 
     | LExpNoUnOp LBinOp LExp 
     ;

LPrefixExp : LVar 
           | LFunctionCall 
           | '(' LExp ')'
           ;

LFunctionCall : LPrefixExp LArgs 
               | LPrefixExp ':' NAME LArgs
               ;

LArgs : '(' LOptionalExpList ')' 
      | LTableConstructor 
      | LITERAL_STRING
      ;

LTableConstructor : '{' LOptionalFieldList '}';

LOptionalFieldList : /* empty */
                   | LFieldList
                   ;

LFieldList : LField 
           | LFieldList LFieldSep LField
           ;

LField : '[' LExp ']' '=' LExp 
       | NAME '=' LExp 
       | LExp
       ;

LFieldSep : ',';
// Why was there ';' ?

LBinOp : BINOP
       | BIN_OR_UNOP
       ;

LUnOp : UNOP
      | BIN_OR_UNOP
      ;
// ==========================================================================