tactus 0.31.2__py3-none-any.whl

tactus/validation/generated/LuaParser.tokens

@@ -0,0 +1,124 @@
+SEMI=1
+EQ=2
+BREAK=3
+GOTO=4
+DO=5
+END=6
+WHILE=7
+REPEAT=8
+UNTIL=9
+IF=10
+THEN=11
+ELSEIF=12
+ELSE=13
+FOR=14
+COMMA=15
+IN=16
+FUNCTION=17
+LOCAL=18
+LT=19
+GT=20
+RETURN=21
+CONTINUE=22
+CC=23
+NIL=24
+FALSE=25
+TRUE=26
+DOT=27
+SQUIG=28
+MINUS=29
+POUND=30
+OP=31
+CP=32
+NOT=33
+LL=34
+GG=35
+AMP=36
+SS=37
+PER=38
+COL=39
+LE=40
+GE=41
+AND=42
+OR=43
+PLUS=44
+STAR=45
+OCU=46
+CCU=47
+OB=48
+CB=49
+EE=50
+DD=51
+PIPE=52
+CARET=53
+SLASH=54
+DDD=55
+SQEQ=56
+NAME=57
+NORMALSTRING=58
+CHARSTRING=59
+LONGSTRING=60
+INT=61
+HEX=62
+FLOAT=63
+HEX_FLOAT=64
+COMMENT=65
+WS=66
+NL=67
+SHEBANG=68
+';'=1
+'='=2
+'break'=3
+'goto'=4
+'do'=5
+'end'=6
+'while'=7
+'repeat'=8
+'until'=9
+'if'=10
+'then'=11
+'elseif'=12
+'else'=13
+'for'=14
+','=15
+'in'=16
+'function'=17
+'local'=18
+'<'=19
+'>'=20
+'return'=21
+'continue'=22
+'::'=23
+'nil'=24
+'false'=25
+'true'=26
+'.'=27
+'~'=28
+'-'=29
+'#'=30
+'('=31
+')'=32
+'not'=33
+'<<'=34
+'>>'=35
+'&'=36
+'//'=37
+'%'=38
+':'=39
+'<='=40
+'>='=41
+'and'=42
+'or'=43
+'+'=44
+'*'=45
+'{'=46
+'}'=47
+'['=48
+']'=49
+'=='=50
+'..'=51
+'|'=52
+'^'=53
+'/'=54
+'...'=55
+'~='=56

tactus/validation/generated/LuaParserBase.py

@@ -0,0 +1,23 @@
+import sys
+from antlr4 import *
+
+if sys.version_info[1] > 5:
+    from typing import TextIO
+else:
+    from typing.io import TextIO
+
+
+class LuaParserBase(Parser):
+    debug = False
+
+    def __init__(self, input: TokenStream, output: TextIO = sys.stdout):
+        super().__init__(input, output)
+
+    def IsFunctionCall(self) -> bool:
+        la = self._input.LT(1)
+        if la.type != self.NAME:
+            return False
+        la = self._input.LT(2)
+        if la.type == self.OP:
+            return False
+        return True

tactus/validation/generated/LuaParserVisitor.py

@@ -0,0 +1,118 @@
+# Generated from /work/tactus/validation/grammar/LuaParser.g4 by ANTLR 4.13.1
+from antlr4 import *
+
+if "." in __name__:
+    from .LuaParser import LuaParser
+else:
+    from LuaParser import LuaParser
+
+# This class defines a complete generic visitor for a parse tree produced by LuaParser.
+
+
+class LuaParserVisitor(ParseTreeVisitor):
+    # Visit a parse tree produced by LuaParser#start_.
+    def visitStart_(self, ctx: LuaParser.Start_Context):
+        return self.visitChildren(ctx)
+
+    # Visit a parse tree produced by LuaParser#chunk.
+    def visitChunk(self, ctx: LuaParser.ChunkContext):
+        return self.visitChildren(ctx)
+
+    # Visit a parse tree produced by LuaParser#block.
+    def visitBlock(self, ctx: LuaParser.BlockContext):
+        return self.visitChildren(ctx)
+
+    # Visit a parse tree produced by LuaParser#stat.
+    def visitStat(self, ctx: LuaParser.StatContext):
+        return self.visitChildren(ctx)
+
+    # Visit a parse tree produced by LuaParser#attnamelist.
+    def visitAttnamelist(self, ctx: LuaParser.AttnamelistContext):
+        return self.visitChildren(ctx)
+
+    # Visit a parse tree produced by LuaParser#attrib.
+    def visitAttrib(self, ctx: LuaParser.AttribContext):
+        return self.visitChildren(ctx)
+
+    # Visit a parse tree produced by LuaParser#retstat.
+    def visitRetstat(self, ctx: LuaParser.RetstatContext):
+        return self.visitChildren(ctx)
+
+    # Visit a parse tree produced by LuaParser#label.
+    def visitLabel(self, ctx: LuaParser.LabelContext):
+        return self.visitChildren(ctx)
+
+    # Visit a parse tree produced by LuaParser#funcname.
+    def visitFuncname(self, ctx: LuaParser.FuncnameContext):
+        return self.visitChildren(ctx)
+
+    # Visit a parse tree produced by LuaParser#varlist.
+    def visitVarlist(self, ctx: LuaParser.VarlistContext):
+        return self.visitChildren(ctx)
+
+    # Visit a parse tree produced by LuaParser#namelist.
+    def visitNamelist(self, ctx: LuaParser.NamelistContext):
+        return self.visitChildren(ctx)
+
+    # Visit a parse tree produced by LuaParser#explist.
+    def visitExplist(self, ctx: LuaParser.ExplistContext):
+        return self.visitChildren(ctx)
+
+    # Visit a parse tree produced by LuaParser#exp.
+    def visitExp(self, ctx: LuaParser.ExpContext):
+        return self.visitChildren(ctx)
+
+    # Visit a parse tree produced by LuaParser#var.
+    def visitVar(self, ctx: LuaParser.VarContext):
+        return self.visitChildren(ctx)
+
+    # Visit a parse tree produced by LuaParser#prefixexp.
+    def visitPrefixexp(self, ctx: LuaParser.PrefixexpContext):
+        return self.visitChildren(ctx)
+
+    # Visit a parse tree produced by LuaParser#functioncall.
+    def visitFunctioncall(self, ctx: LuaParser.FunctioncallContext):
+        return self.visitChildren(ctx)
+
+    # Visit a parse tree produced by LuaParser#args.
+    def visitArgs(self, ctx: LuaParser.ArgsContext):
+        return self.visitChildren(ctx)
+
+    # Visit a parse tree produced by LuaParser#functiondef.
+    def visitFunctiondef(self, ctx: LuaParser.FunctiondefContext):
+        return self.visitChildren(ctx)
+
+    # Visit a parse tree produced by LuaParser#funcbody.
+    def visitFuncbody(self, ctx: LuaParser.FuncbodyContext):
+        return self.visitChildren(ctx)
+
+    # Visit a parse tree produced by LuaParser#parlist.
+    def visitParlist(self, ctx: LuaParser.ParlistContext):
+        return self.visitChildren(ctx)
+
+    # Visit a parse tree produced by LuaParser#tableconstructor.
+    def visitTableconstructor(self, ctx: LuaParser.TableconstructorContext):
+        return self.visitChildren(ctx)
+
+    # Visit a parse tree produced by LuaParser#fieldlist.
+    def visitFieldlist(self, ctx: LuaParser.FieldlistContext):
+        return self.visitChildren(ctx)
+
+    # Visit a parse tree produced by LuaParser#field.
+    def visitField(self, ctx: LuaParser.FieldContext):
+        return self.visitChildren(ctx)
+
+    # Visit a parse tree produced by LuaParser#fieldsep.
+    def visitFieldsep(self, ctx: LuaParser.FieldsepContext):
+        return self.visitChildren(ctx)
+
+    # Visit a parse tree produced by LuaParser#number.
+    def visitNumber(self, ctx: LuaParser.NumberContext):
+        return self.visitChildren(ctx)
+
+    # Visit a parse tree produced by LuaParser#string.
+    def visitString(self, ctx: LuaParser.StringContext):
+        return self.visitChildren(ctx)
+
+
+del LuaParser

tactus/validation/generated/__init__.py

@@ -0,0 +1,7 @@
+"""
+Generated ANTLR parsers for Lua DSL.
+
+These files are generated from LuaLexer.g4 and LuaParser.g4 grammars using ANTLR4.
+Do not edit manually - regenerate using:
+    make generate-parsers
+"""

tactus/validation/grammar/LuaLexer.g4

@@ -0,0 +1,123 @@
+// $antlr-format alignTrailingComments true, columnLimit 150, maxEmptyLinesToKeep 1, reflowComments false, useTab false
+// $antlr-format allowShortRulesOnASingleLine true, allowShortBlocksOnASingleLine true, minEmptyLines 0, alignSemicolons ownLine
+// $antlr-format alignColons trailing, singleLineOverrulesHangingColon true, alignLexerCommands true, alignLabels true, alignTrailers true
+
+lexer grammar LuaLexer;
+
+options {
+    superClass = LuaLexerBase;
+}
+
+// Insert here @header for lexer.
+
+SEMI : ';';
+EQ   : '=';
+
+BREAK    : 'break';
+GOTO     : 'goto';
+DO       : 'do';
+END      : 'end';
+WHILE    : 'while';
+REPEAT   : 'repeat';
+UNTIL    : 'until';
+IF       : 'if';
+THEN     : 'then';
+ELSEIF   : 'elseif';
+ELSE     : 'else';
+FOR      : 'for';
+COMMA    : ',';
+IN       : 'in';
+FUNCTION : 'function';
+LOCAL    : 'local';
+LT       : '<';
+GT       : '>';
+RETURN   : 'return';
+CONTINUE : 'continue';
+CC       : '::';
+NIL      : 'nil';
+FALSE    : 'false';
+TRUE     : 'true';
+DOT      : '.';
+SQUIG    : '~';
+MINUS    : '-';
+POUND    : '#';
+OP       : '(';
+CP       : ')';
+NOT      : 'not';
+LL       : '<<';
+GG       : '>>';
+AMP      : '&';
+SS       : '//';
+PER      : '%';
+COL      : ':';
+LE       : '<=';
+GE       : '>=';
+AND      : 'and';
+OR       : 'or';
+PLUS     : '+';
+STAR     : '*';
+OCU      : '{';
+CCU      : '}';
+OB       : '[';
+CB       : ']';
+EE       : '==';
+DD       : '..';
+PIPE     : '|';
+CARET    : '^';
+SLASH    : '/';
+DDD      : '...';
+SQEQ     : '~=';
+
+NAME: [a-zA-Z_][a-zA-Z_0-9]*;
+
+NORMALSTRING: '"' ( EscapeSequence | ~('\\' | '"'))* '"';
+
+CHARSTRING: '\'' ( EscapeSequence | ~('\'' | '\\'))* '\'';
+
+LONGSTRING: '[' NESTED_STR ']';
+
+fragment NESTED_STR: '=' NESTED_STR '=' | '[' .*? ']';
+
+INT: Digit+;
+
+HEX: '0' [xX] HexDigit+;
+
+FLOAT: Digit+ '.' Digit* ExponentPart? | '.' Digit+ ExponentPart? | Digit+ ExponentPart;
+
+HEX_FLOAT:
+    '0' [xX] HexDigit+ '.' HexDigit* HexExponentPart?
+    | '0' [xX] '.' HexDigit+ HexExponentPart?
+    | '0' [xX] HexDigit+ HexExponentPart
+;
+
+fragment ExponentPart: [eE] [+-]? Digit+;
+
+fragment HexExponentPart: [pP] [+-]? Digit+;
+
+fragment EscapeSequence:
+    '\\' [abfnrtvz"'|$#\\] // World of Warcraft Lua additionally escapes |$# 
+    | '\\' '\r'? '\n'
+    | DecimalEscape
+    | HexEscape
+    | UtfEscape
+;
+
+fragment DecimalEscape: '\\' Digit | '\\' Digit Digit | '\\' [0-2] Digit Digit;
+
+fragment HexEscape: '\\' 'x' HexDigit HexDigit;
+
+fragment UtfEscape: '\\' 'u{' HexDigit+ '}';
+
+fragment Digit: [0-9];
+
+fragment HexDigit: [0-9a-fA-F];
+
+fragment SingleLineInputCharacter: ~[\r\n\u0085\u2028\u2029];
+
+COMMENT: '--' { this.HandleComment(); } -> channel(HIDDEN);
+
+WS: [ \t\u000C\r]+ -> channel(HIDDEN);
+
+NL: [\n] -> channel(2);
+
+SHEBANG: '#' { this.IsLine1Col0() }? '!'? SingleLineInputCharacter* -> channel(HIDDEN);

tactus/validation/grammar/LuaParser.g4

@@ -0,0 +1,178 @@
+/*
+
+MIT license
+
+Author: Ken Domino, October 2023
+
+Based on previous work of: Kazunori Sakamoto, Alexander Alexeev
+
+*/
+
+// $antlr-format alignTrailingComments true, columnLimit 150, minEmptyLines 1, maxEmptyLinesToKeep 1, reflowComments false, useTab false
+// $antlr-format allowShortRulesOnASingleLine false, allowShortBlocksOnASingleLine true, alignSemicolons hanging, alignColons hanging
+
+parser grammar LuaParser;
+
+options {
+    tokenVocab = LuaLexer;
+    superClass = LuaParserBase;
+}
+
+// Insert here @header for parser.
+
+start_
+    : chunk EOF
+    ;
+
+chunk
+    : block
+    ;
+
+block
+    : stat* retstat?
+    ;
+
+stat
+    : ';'
+    | varlist '=' explist
+    | functioncall
+    | label
+    | 'break'
+    | 'goto' NAME
+    | 'do' block 'end'
+    | 'while' exp 'do' block 'end'
+    | 'repeat' block 'until' exp
+    | 'if' exp 'then' block ('elseif' exp 'then' block)* ('else' block)? 'end'
+    | 'for' NAME '=' exp ',' exp (',' exp)? 'do' block 'end'
+    | 'for' namelist 'in' explist 'do' block 'end'
+    | 'function' funcname funcbody
+    | 'local' 'function' NAME funcbody
+    | 'local' attnamelist ('=' explist)?
+    ;
+
+attnamelist
+    : NAME attrib (',' NAME attrib)*
+    ;
+
+attrib
+    : ('<' NAME '>')?
+    ;
+
+retstat
+    : 'return' explist? ';'?
+    ;
+
+label
+    : '::' NAME '::'
+    ;
+
+funcname
+    : NAME ('.' NAME)* (':' NAME)?
+    ;
+
+varlist
+    : var (',' var)*
+    ;
+
+namelist
+    : NAME (',' NAME)*
+    ;
+
+explist
+    : exp (',' exp)*
+    ;
+
+exp
+    : 'nil'
+    | 'false'
+    | 'true'
+    | number
+    | string
+    | '...'
+    | functiondef
+    | prefixexp
+    | tableconstructor
+    | <assoc = right> exp ('^') exp
+    | ('not' | '#' | '-' | '~') exp
+    | exp ('*' | '/' | '%' | '//') exp
+    | exp ('+' | '-') exp
+    | <assoc = right> exp ('..') exp
+    | exp ('<' | '>' | '<=' | '>=' | '~=' | '==') exp
+    | exp ('and') exp
+    | exp ('or') exp
+    | exp ('&' | '|' | '~' | '<<' | '>>') exp
+    ;
+
+// var ::=  Name | prefixexp '[' exp ']' | prefixexp '.' Name 
+var
+    : NAME
+    | prefixexp ('[' exp ']' | '.' NAME)
+    ;
+
+// prefixexp ::= var | functioncall | '(' exp ')'
+prefixexp
+    : { this.IsFunctionCall() }? NAME ( '[' exp ']' | '.' NAME )*
+    | functioncall ( '[' exp ']' | '.' NAME )*
+    | '(' exp ')' ( '[' exp ']' | '.' NAME )*
+    ;
+
+// functioncall ::=  prefixexp args | prefixexp ':' Name args;
+functioncall
+    :  ( ( NAME | '(' exp ')' ) ( '[' exp ']' | '.' NAME )* ( args | ':' NAME args ) ) ( ( '[' exp ']' | '.' NAME )* ( args | ':' NAME args ) )*
+    ;
+
+args
+    : '(' explist? ')'
+    | tableconstructor
+    | string
+    ;
+
+functiondef
+    : 'function' funcbody
+    ;
+
+funcbody
+    : '(' parlist ')' block 'end'
+    ;
+
+/* lparser.c says "is 'parlist' not empty?"
+ * That code does so by checking la(1) == ')'.
+ * This means that parlist can derive empty.
+ */
+parlist
+    : namelist (',' '...')?
+    | '...'
+    |
+    ;
+
+tableconstructor
+    : '{' fieldlist? '}'
+    ;
+
+fieldlist
+    : field (fieldsep field)* fieldsep?
+    ;
+
+field
+    : '[' exp ']' '=' exp
+    | NAME '=' exp
+    | exp
+    ;
+
+fieldsep
+    : ','
+    | ';'
+    ;
+
+number
+    : INT
+    | HEX
+    | FLOAT
+    | HEX_FLOAT
+    ;
+
+string
+    : NORMALSTRING
+    | CHARSTRING
+    | LONGSTRING
+    ;