From 4ce9cf7a02d2f2e5478e07b829a8c7475030c638 Mon Sep 17 00:00:00 2001 From: "Michael R. Crusoe" Date: Wed, 2 Dec 2020 10:17:33 +0100 Subject: [PATCH 1/2] wip --- requirements.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/requirements.txt b/requirements.txt index a6055c1a..642c04f6 100644 --- a/requirements.txt +++ b/requirements.txt @@ -4,3 +4,4 @@ rdflib requests CacheControl schema-salad >= 8.3.20220825114525, < 9 +antlr4-python3-runtime From 00f5a96b90fc49591925199f1710b351d7a3b294 Mon Sep 17 00:00:00 2001 From: "Michael R. Crusoe" Date: Thu, 17 Dec 2020 10:59:39 +0100 Subject: [PATCH 2/2] wip2 --- antlr4/CwlEcmaStringLexer.g4 | 41 ++ antlr4/CwlEcmaStringParser.g4 | 45 ++ antlr4/CwlParameterReferenceLexer.g4 | 67 ++ antlr4/CwlParameterReferenceParser.g4 | 44 ++ cwl_utils/parser/v1_2EcmaStringLexer.py | 131 ++++ cwl_utils/parser/v1_2EcmaStringParser.py | 616 ++++++++++++++++++ .../parser/v1_2EcmaStringParserListener.py | 82 +++ .../parser/v1_2ParameterReferenceLexer.py | 161 +++++ .../parser/v1_2ParameterReferenceParser.py | 603 +++++++++++++++++ .../v1_2ParameterReferenceParserListener.py | 82 +++ cwl_utils/parser/v1_2expr.py | 15 + 11 files changed, 1887 insertions(+) create mode 100644 antlr4/CwlEcmaStringLexer.g4 create mode 100644 antlr4/CwlEcmaStringParser.g4 create mode 100644 antlr4/CwlParameterReferenceLexer.g4 create mode 100644 antlr4/CwlParameterReferenceParser.g4 create mode 100644 cwl_utils/parser/v1_2EcmaStringLexer.py create mode 100644 cwl_utils/parser/v1_2EcmaStringParser.py create mode 100644 cwl_utils/parser/v1_2EcmaStringParserListener.py create mode 100644 cwl_utils/parser/v1_2ParameterReferenceLexer.py create mode 100644 cwl_utils/parser/v1_2ParameterReferenceParser.py create mode 100644 cwl_utils/parser/v1_2ParameterReferenceParserListener.py create mode 100644 cwl_utils/parser/v1_2expr.py diff --git a/antlr4/CwlEcmaStringLexer.g4 b/antlr4/CwlEcmaStringLexer.g4 new file mode 100644 index 00000000..d8a86c21 --- /dev/null +++ b/antlr4/CwlEcmaStringLexer.g4 @@ -0,0 +1,41 @@ +lexer grammar CwlEcmaStringLexer; + +ANYCHAR: .; +DOLLARPAREN: '$(' -> pushMode(ParenExpr); +LPAREN: '('; +RPAREN: ')'; +DOLLARBRACE: '${' -> pushMode(BraceExpr); +LBRACE: '{'; +RBRACE: '}'; +DOLLARPARENESC: '\\$('; +DOLLARBRACEESC: '\\${'; +BACKSLASH: '\\'; +BACKSLASHESC: '\\\\'; + +mode ParenExpr; + +EscPart: BACKSLASH ANYCHAR; +SubExprStart: LPAREN -> pushMode(SubExpr); +ExprEnd: RPAREN -> popMode; +ExprPart: ~[)]; + +mode SubExpr; + +SubEscPart: BACKSLASH ANYCHAR -> type(SubExprPart); +SubSubExprStart: LPAREN -> pushMode(SubExpr); +SubExprEnd: RPAREN -> popMode; +SubExprPart: ~[)]; + +mode BraceExpr; + +BraceEscPart: BACKSLASH ANYCHAR -> type(EscPart); +BraceSubExprStart: LBRACE -> pushMode(BraceSubExpr), type(SubExprStart); +BraceExprEnd: RBRACE -> popMode, type(ExprEnd); +BraceExprPart: ~[}] -> type(ExprPart); + +mode BraceSubExpr; + +BraceSubEscPart: BACKSLASH ANYCHAR -> type(SubExprPart); +BraceSubSubExprStart: LBRACE -> pushMode(BraceSubExpr), type(SubSubExprStart); +BraceSubExprEnd: RBRACE -> popMode, type(SubExprEnd); +BraceSubExprPart: ~[}] -> type(SubExprPart); \ No newline at end of file diff --git a/antlr4/CwlEcmaStringParser.g4 b/antlr4/CwlEcmaStringParser.g4 new file mode 100644 index 00000000..53fbb49c --- /dev/null +++ b/antlr4/CwlEcmaStringParser.g4 @@ -0,0 +1,45 @@ +parser grammar CwlEcmaStringParser; + +options { + tokenVocab=CwlEcmaStringLexer; +} + +sub_sub_expr + : SubSubExprStart sub_expr_part* SubExprEnd + ; + +sub_expr_part + : SubExprPart + | sub_sub_expr + ; + +sub_expr + : SubExprStart sub_expr_part* SubExprEnd + ; + +expr_part + : ExprPart + | EscPart + | sub_expr + ; + +paren_expr + : DOLLARPAREN expr_part+ ExprEnd + ; + +brace_expr + : DOLLARBRACE expr_part+ ExprEnd + ; + +interpolated_string_part + : BACKSLASHESC + | DOLLARPARENESC + | DOLLARBRACEESC + | paren_expr + | brace_expr + | ANYCHAR + ; + +interpolated_string + : interpolated_string_part+ + ; \ No newline at end of file diff --git a/antlr4/CwlParameterReferenceLexer.g4 b/antlr4/CwlParameterReferenceLexer.g4 new file mode 100644 index 00000000..a1dfb44d --- /dev/null +++ b/antlr4/CwlParameterReferenceLexer.g4 @@ -0,0 +1,67 @@ +lexer grammar CwlParameterReferenceLexer; + +DOT: '.'; +LBRACKET: '['; +RBRACKET: ']'; +DOLLARPAREN: '$(' -> pushMode(ParenExpr); +RPAREN: ')'; +DOLLARPARENESC: '\\$('; +BACKSLASH: '\\'; +BACKSLASHESC: '\\\\'; +ANYCHAR: .; +LBRACKETSINGLEQ: '[\''; +LBRACKETDOUBLEQ: '["'; +SINGLEQRBRACKET: '\']'; +DOUBLEQRBRACKET: '"]'; + +mode ParenExpr; + +ExprDot: DOT; +ExprSymbol: CompleteSymbol; +ExprSingleQ: LBRACKETSINGLEQ -> pushMode(SingleQString); +ExprDoubleQ: LBRACKETDOUBLEQ -> pushMode(DoubleQString); +ExprIntIndex: LBRACKET -> pushMode(IntIndex); +EndParenExpr: RPAREN -> popMode; + +mode SingleQString; + +StringIndexEscPart: BACKSLASH ANYCHAR; +EndSingleQ: SINGLEQRBRACKET -> popMode, type(ExprSingleQ); +StringIndexPart: ~[\\']+; +LiteralBackslash: BACKSLASH -> type(StringIndexPart); + +mode DoubleQString; + +DoubleQEscapedChar: BACKSLASH ANYCHAR -> type(StringIndexEscPart); +EndDoubleQ: DOUBLEQRBRACKET -> popMode, type(ExprDoubleQ); +DoubleQStringIndexPart: ~[\\"]+ -> type(StringIndexPart); +DoubleQLiteralBackslash: BACKSLASH -> type(StringIndexPart); + +mode IntIndex; + +EndIndex: RBRACKET -> popMode, type(ExprIntIndex); +IntIndexPart: DecimalNumber; + +fragment CompleteSymbol + : SymbolStart SymbolFollow* + ; + +fragment SymbolStart + : [a-zA-Z] + ; + +fragment SymbolFollow + : [a-zA-Z0-9_]+ + ; + +fragment DecimalNumber + : DecimalDigit+ + ; + +fragment DecimalDigit + : [0-9] + ; + +fragment HexDigit + : [0-9a-fA-F] + ; diff --git a/antlr4/CwlParameterReferenceParser.g4 b/antlr4/CwlParameterReferenceParser.g4 new file mode 100644 index 00000000..9466946c --- /dev/null +++ b/antlr4/CwlParameterReferenceParser.g4 @@ -0,0 +1,44 @@ +parser grammar CwlParameterReferenceParser; + +options { + tokenVocab=CwlParameterReferenceLexer; +} + +expr_dot_symbol + : ExprDot ExprSymbol + ; + +int_index + : ExprIntIndex IntIndexPart ExprIntIndex + ; + +string_index_part + : StringIndexPart + | StringIndexEscPart + ; + +string_index + : ExprSingleQ string_index_part+ ExprSingleQ + | ExprDoubleQ string_index_part+ ExprDoubleQ + ; + +expr_segment + : expr_dot_symbol + | int_index + | string_index + ; + +paren_expr + : DOLLARPAREN ExprSymbol expr_segment* EndParenExpr + ; + +interpolated_string_part + : BACKSLASHESC + | DOLLARPARENESC + | paren_expr + | ANYCHAR + ; + +interpolated_string + : interpolated_string_part+ + ; \ No newline at end of file diff --git a/cwl_utils/parser/v1_2EcmaStringLexer.py b/cwl_utils/parser/v1_2EcmaStringLexer.py new file mode 100644 index 00000000..cc8621a9 --- /dev/null +++ b/cwl_utils/parser/v1_2EcmaStringLexer.py @@ -0,0 +1,131 @@ +# Generated from antlr4/CwlEcmaStringLexer.g4 by ANTLR 4.7.2 +from antlr4 import * +from io import StringIO +from typing.io import TextIO +import sys + + +def serializedATN(): + with StringIO() as buf: + buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\24") + buf.write("\u00a0\b\1\b\1\b\1\b\1\b\1\4\2\t\2\4\3\t\3\4\4\t\4\4\5") + buf.write("\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13") + buf.write("\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t") + buf.write("\21\4\22\t\22\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26") + buf.write("\4\27\t\27\4\30\t\30\4\31\t\31\4\32\t\32\4\33\t\33\4\34") + buf.write("\t\34\3\2\3\2\3\3\3\3\3\3\3\3\3\3\3\4\3\4\3\5\3\5\3\6") + buf.write("\3\6\3\6\3\6\3\6\3\7\3\7\3\b\3\b\3\t\3\t\3\t\3\t\3\n\3") + buf.write("\n\3\n\3\n\3\13\3\13\3\f\3\f\3\f\3\r\3\r\3\r\3\16\3\16") + buf.write("\3\16\3\16\3\17\3\17\3\17\3\17\3\20\3\20\3\21\3\21\3\21") + buf.write("\3\21\3\21\3\22\3\22\3\22\3\22\3\23\3\23\3\23\3\23\3\24") + buf.write("\3\24\3\25\3\25\3\25\3\25\3\25\3\26\3\26\3\26\3\26\3\26") + buf.write("\3\27\3\27\3\27\3\27\3\27\3\30\3\30\3\30\3\30\3\31\3\31") + buf.write("\3\31\3\31\3\31\3\32\3\32\3\32\3\32\3\32\3\33\3\33\3\33") + buf.write("\3\33\3\33\3\34\3\34\3\34\3\34\2\2\35\7\3\t\4\13\5\r\6") + buf.write("\17\7\21\b\23\t\25\n\27\13\31\f\33\r\35\16\37\17!\20#") + buf.write("\21%\2\'\22)\23+\24-\2/\2\61\2\63\2\65\2\67\29\2;\2\7") + buf.write("\2\3\4\5\6\4\3\2++\3\2\177\177\2\u009b\2\7\3\2\2\2\2\t") + buf.write("\3\2\2\2\2\13\3\2\2\2\2\r\3\2\2\2\2\17\3\2\2\2\2\21\3") + buf.write("\2\2\2\2\23\3\2\2\2\2\25\3\2\2\2\2\27\3\2\2\2\2\31\3\2") + buf.write("\2\2\2\33\3\2\2\2\3\35\3\2\2\2\3\37\3\2\2\2\3!\3\2\2\2") + buf.write("\3#\3\2\2\2\4%\3\2\2\2\4\'\3\2\2\2\4)\3\2\2\2\4+\3\2\2") + buf.write("\2\5-\3\2\2\2\5/\3\2\2\2\5\61\3\2\2\2\5\63\3\2\2\2\6\65") + buf.write("\3\2\2\2\6\67\3\2\2\2\69\3\2\2\2\6;\3\2\2\2\7=\3\2\2\2") + buf.write("\t?\3\2\2\2\13D\3\2\2\2\rF\3\2\2\2\17H\3\2\2\2\21M\3\2") + buf.write("\2\2\23O\3\2\2\2\25Q\3\2\2\2\27U\3\2\2\2\31Y\3\2\2\2\33") + buf.write("[\3\2\2\2\35^\3\2\2\2\37a\3\2\2\2!e\3\2\2\2#i\3\2\2\2") + buf.write("%k\3\2\2\2\'p\3\2\2\2)t\3\2\2\2+x\3\2\2\2-z\3\2\2\2/\177") + buf.write("\3\2\2\2\61\u0084\3\2\2\2\63\u0089\3\2\2\2\65\u008d\3") + buf.write("\2\2\2\67\u0092\3\2\2\29\u0097\3\2\2\2;\u009c\3\2\2\2") + buf.write("=>\13\2\2\2>\b\3\2\2\2?@\7&\2\2@A\7*\2\2AB\3\2\2\2BC\b") + buf.write("\3\2\2C\n\3\2\2\2DE\7*\2\2E\f\3\2\2\2FG\7+\2\2G\16\3\2") + buf.write("\2\2HI\7&\2\2IJ\7}\2\2JK\3\2\2\2KL\b\6\3\2L\20\3\2\2\2") + buf.write("MN\7}\2\2N\22\3\2\2\2OP\7\177\2\2P\24\3\2\2\2QR\7^\2\2") + buf.write("RS\7&\2\2ST\7*\2\2T\26\3\2\2\2UV\7^\2\2VW\7&\2\2WX\7}") + buf.write("\2\2X\30\3\2\2\2YZ\7^\2\2Z\32\3\2\2\2[\\\7^\2\2\\]\7^") + buf.write("\2\2]\34\3\2\2\2^_\5\31\13\2_`\5\7\2\2`\36\3\2\2\2ab\5") + buf.write("\13\4\2bc\3\2\2\2cd\b\16\4\2d \3\2\2\2ef\5\r\5\2fg\3\2") + buf.write("\2\2gh\b\17\5\2h\"\3\2\2\2ij\n\2\2\2j$\3\2\2\2kl\5\31") + buf.write("\13\2lm\5\7\2\2mn\3\2\2\2no\b\21\6\2o&\3\2\2\2pq\5\13") + buf.write("\4\2qr\3\2\2\2rs\b\22\4\2s(\3\2\2\2tu\5\r\5\2uv\3\2\2") + buf.write("\2vw\b\23\5\2w*\3\2\2\2xy\n\2\2\2y,\3\2\2\2z{\5\31\13") + buf.write("\2{|\5\7\2\2|}\3\2\2\2}~\b\25\7\2~.\3\2\2\2\177\u0080") + buf.write("\5\21\7\2\u0080\u0081\3\2\2\2\u0081\u0082\b\26\b\2\u0082") + buf.write("\u0083\b\26\t\2\u0083\60\3\2\2\2\u0084\u0085\5\23\b\2") + buf.write("\u0085\u0086\3\2\2\2\u0086\u0087\b\27\5\2\u0087\u0088") + buf.write("\b\27\n\2\u0088\62\3\2\2\2\u0089\u008a\n\3\2\2\u008a\u008b") + buf.write("\3\2\2\2\u008b\u008c\b\30\13\2\u008c\64\3\2\2\2\u008d") + buf.write("\u008e\5\31\13\2\u008e\u008f\5\7\2\2\u008f\u0090\3\2\2") + buf.write("\2\u0090\u0091\b\31\6\2\u0091\66\3\2\2\2\u0092\u0093\5") + buf.write("\21\7\2\u0093\u0094\3\2\2\2\u0094\u0095\b\32\b\2\u0095") + buf.write("\u0096\b\32\f\2\u00968\3\2\2\2\u0097\u0098\5\23\b\2\u0098") + buf.write("\u0099\3\2\2\2\u0099\u009a\b\33\5\2\u009a\u009b\b\33\r") + buf.write("\2\u009b:\3\2\2\2\u009c\u009d\n\3\2\2\u009d\u009e\3\2") + buf.write("\2\2\u009e\u009f\b\34\6\2\u009f<\3\2\2\2\7\2\3\4\5\6\16") + buf.write("\7\3\2\7\5\2\7\4\2\6\2\2\t\24\2\t\16\2\7\6\2\t\17\2\t") + buf.write("\20\2\t\21\2\t\22\2\t\23\2") + return buf.getvalue() + + +class CwlEcmaStringLexer(Lexer): + + atn = ATNDeserializer().deserialize(serializedATN()) + + decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ] + + ParenExpr = 1 + SubExpr = 2 + BraceExpr = 3 + BraceSubExpr = 4 + + ANYCHAR = 1 + DOLLARPAREN = 2 + LPAREN = 3 + RPAREN = 4 + DOLLARBRACE = 5 + LBRACE = 6 + RBRACE = 7 + DOLLARPARENESC = 8 + DOLLARBRACEESC = 9 + BACKSLASH = 10 + BACKSLASHESC = 11 + EscPart = 12 + SubExprStart = 13 + ExprEnd = 14 + ExprPart = 15 + SubSubExprStart = 16 + SubExprEnd = 17 + SubExprPart = 18 + + channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ] + + modeNames = [ "DEFAULT_MODE", "ParenExpr", "SubExpr", "BraceExpr", "BraceSubExpr" ] + + literalNames = [ "", + "'$('", "'('", "')'", "'${'", "'{'", "'}'", "'\\$('", "'\\${'", + "'\\'", "'\\\\'" ] + + symbolicNames = [ "", + "ANYCHAR", "DOLLARPAREN", "LPAREN", "RPAREN", "DOLLARBRACE", + "LBRACE", "RBRACE", "DOLLARPARENESC", "DOLLARBRACEESC", "BACKSLASH", + "BACKSLASHESC", "EscPart", "SubExprStart", "ExprEnd", "ExprPart", + "SubSubExprStart", "SubExprEnd", "SubExprPart" ] + + ruleNames = [ "ANYCHAR", "DOLLARPAREN", "LPAREN", "RPAREN", "DOLLARBRACE", + "LBRACE", "RBRACE", "DOLLARPARENESC", "DOLLARBRACEESC", + "BACKSLASH", "BACKSLASHESC", "EscPart", "SubExprStart", + "ExprEnd", "ExprPart", "SubEscPart", "SubSubExprStart", + "SubExprEnd", "SubExprPart", "BraceEscPart", "BraceSubExprStart", + "BraceExprEnd", "BraceExprPart", "BraceSubEscPart", "BraceSubSubExprStart", + "BraceSubExprEnd", "BraceSubExprPart" ] + + grammarFileName = "CwlEcmaStringLexer.g4" + + def __init__(self, input=None, output:TextIO = sys.stdout): + super().__init__(input, output) + self.checkVersion("4.7.2") + self._interp = LexerATNSimulator(self, self.atn, self.decisionsToDFA, PredictionContextCache()) + self._actions = None + self._predicates = None + + diff --git a/cwl_utils/parser/v1_2EcmaStringParser.py b/cwl_utils/parser/v1_2EcmaStringParser.py new file mode 100644 index 00000000..28c0d3dd --- /dev/null +++ b/cwl_utils/parser/v1_2EcmaStringParser.py @@ -0,0 +1,616 @@ +# Generated from antlr4/CwlEcmaStringParser.g4 by ANTLR 4.7.2 +# encoding: utf-8 +from antlr4 import * +from io import StringIO +from typing.io import TextIO +import sys + +def serializedATN(): + with StringIO() as buf: + buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\24") + buf.write("K\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b") + buf.write("\t\b\4\t\t\t\3\2\3\2\7\2\25\n\2\f\2\16\2\30\13\2\3\2\3") + buf.write("\2\3\3\3\3\5\3\36\n\3\3\4\3\4\7\4\"\n\4\f\4\16\4%\13\4") + buf.write("\3\4\3\4\3\5\3\5\3\5\5\5,\n\5\3\6\3\6\6\6\60\n\6\r\6\16") + buf.write("\6\61\3\6\3\6\3\7\3\7\6\78\n\7\r\7\16\79\3\7\3\7\3\b\3") + buf.write("\b\3\b\3\b\3\b\3\b\5\bD\n\b\3\t\6\tG\n\t\r\t\16\tH\3\t") + buf.write("\2\2\n\2\4\6\b\n\f\16\20\2\2\2O\2\22\3\2\2\2\4\35\3\2") + buf.write("\2\2\6\37\3\2\2\2\b+\3\2\2\2\n-\3\2\2\2\f\65\3\2\2\2\16") + buf.write("C\3\2\2\2\20F\3\2\2\2\22\26\7\22\2\2\23\25\5\4\3\2\24") + buf.write("\23\3\2\2\2\25\30\3\2\2\2\26\24\3\2\2\2\26\27\3\2\2\2") + buf.write("\27\31\3\2\2\2\30\26\3\2\2\2\31\32\7\23\2\2\32\3\3\2\2") + buf.write("\2\33\36\7\24\2\2\34\36\5\2\2\2\35\33\3\2\2\2\35\34\3") + buf.write("\2\2\2\36\5\3\2\2\2\37#\7\17\2\2 \"\5\4\3\2! \3\2\2\2") + buf.write("\"%\3\2\2\2#!\3\2\2\2#$\3\2\2\2$&\3\2\2\2%#\3\2\2\2&\'") + buf.write("\7\23\2\2\'\7\3\2\2\2(,\7\21\2\2),\7\16\2\2*,\5\6\4\2") + buf.write("+(\3\2\2\2+)\3\2\2\2+*\3\2\2\2,\t\3\2\2\2-/\7\4\2\2.\60") + buf.write("\5\b\5\2/.\3\2\2\2\60\61\3\2\2\2\61/\3\2\2\2\61\62\3\2") + buf.write("\2\2\62\63\3\2\2\2\63\64\7\20\2\2\64\13\3\2\2\2\65\67") + buf.write("\7\7\2\2\668\5\b\5\2\67\66\3\2\2\289\3\2\2\29\67\3\2\2") + buf.write("\29:\3\2\2\2:;\3\2\2\2;<\7\20\2\2<\r\3\2\2\2=D\7\r\2\2") + buf.write(">D\7\n\2\2?D\7\13\2\2@D\5\n\6\2AD\5\f\7\2BD\7\3\2\2C=") + buf.write("\3\2\2\2C>\3\2\2\2C?\3\2\2\2C@\3\2\2\2CA\3\2\2\2CB\3\2") + buf.write("\2\2D\17\3\2\2\2EG\5\16\b\2FE\3\2\2\2GH\3\2\2\2HF\3\2") + buf.write("\2\2HI\3\2\2\2I\21\3\2\2\2\n\26\35#+\619CH") + return buf.getvalue() + + +class CwlEcmaStringParser ( Parser ): + + grammarFileName = "CwlEcmaStringParser.g4" + + atn = ATNDeserializer().deserialize(serializedATN()) + + decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ] + + sharedContextCache = PredictionContextCache() + + literalNames = [ "", "", "'$('", "'('", "')'", "'${'", + "'{'", "'}'", "'\\$('", "'\\${'", "'\\'", "'\\\\'" ] + + symbolicNames = [ "", "ANYCHAR", "DOLLARPAREN", "LPAREN", "RPAREN", + "DOLLARBRACE", "LBRACE", "RBRACE", "DOLLARPARENESC", + "DOLLARBRACEESC", "BACKSLASH", "BACKSLASHESC", "EscPart", + "SubExprStart", "ExprEnd", "ExprPart", "SubSubExprStart", + "SubExprEnd", "SubExprPart" ] + + RULE_sub_sub_expr = 0 + RULE_sub_expr_part = 1 + RULE_sub_expr = 2 + RULE_expr_part = 3 + RULE_paren_expr = 4 + RULE_brace_expr = 5 + RULE_interpolated_string_part = 6 + RULE_interpolated_string = 7 + + ruleNames = [ "sub_sub_expr", "sub_expr_part", "sub_expr", "expr_part", + "paren_expr", "brace_expr", "interpolated_string_part", + "interpolated_string" ] + + EOF = Token.EOF + ANYCHAR=1 + DOLLARPAREN=2 + LPAREN=3 + RPAREN=4 + DOLLARBRACE=5 + LBRACE=6 + RBRACE=7 + DOLLARPARENESC=8 + DOLLARBRACEESC=9 + BACKSLASH=10 + BACKSLASHESC=11 + EscPart=12 + SubExprStart=13 + ExprEnd=14 + ExprPart=15 + SubSubExprStart=16 + SubExprEnd=17 + SubExprPart=18 + + def __init__(self, input:TokenStream, output:TextIO = sys.stdout): + super().__init__(input, output) + self.checkVersion("4.7.2") + self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache) + self._predicates = None + + + + class Sub_sub_exprContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def SubSubExprStart(self): + return self.getToken(CwlEcmaStringParser.SubSubExprStart, 0) + + def SubExprEnd(self): + return self.getToken(CwlEcmaStringParser.SubExprEnd, 0) + + def sub_expr_part(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(CwlEcmaStringParser.Sub_expr_partContext) + else: + return self.getTypedRuleContext(CwlEcmaStringParser.Sub_expr_partContext,i) + + + def getRuleIndex(self): + return CwlEcmaStringParser.RULE_sub_sub_expr + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSub_sub_expr" ): + listener.enterSub_sub_expr(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSub_sub_expr" ): + listener.exitSub_sub_expr(self) + + + + + def sub_sub_expr(self): + + localctx = CwlEcmaStringParser.Sub_sub_exprContext(self, self._ctx, self.state) + self.enterRule(localctx, 0, self.RULE_sub_sub_expr) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 16 + self.match(CwlEcmaStringParser.SubSubExprStart) + self.state = 20 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==CwlEcmaStringParser.SubSubExprStart or _la==CwlEcmaStringParser.SubExprPart: + self.state = 17 + self.sub_expr_part() + self.state = 22 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 23 + self.match(CwlEcmaStringParser.SubExprEnd) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class Sub_expr_partContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def SubExprPart(self): + return self.getToken(CwlEcmaStringParser.SubExprPart, 0) + + def sub_sub_expr(self): + return self.getTypedRuleContext(CwlEcmaStringParser.Sub_sub_exprContext,0) + + + def getRuleIndex(self): + return CwlEcmaStringParser.RULE_sub_expr_part + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSub_expr_part" ): + listener.enterSub_expr_part(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSub_expr_part" ): + listener.exitSub_expr_part(self) + + + + + def sub_expr_part(self): + + localctx = CwlEcmaStringParser.Sub_expr_partContext(self, self._ctx, self.state) + self.enterRule(localctx, 2, self.RULE_sub_expr_part) + try: + self.state = 27 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [CwlEcmaStringParser.SubExprPart]: + self.enterOuterAlt(localctx, 1) + self.state = 25 + self.match(CwlEcmaStringParser.SubExprPart) + pass + elif token in [CwlEcmaStringParser.SubSubExprStart]: + self.enterOuterAlt(localctx, 2) + self.state = 26 + self.sub_sub_expr() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class Sub_exprContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def SubExprStart(self): + return self.getToken(CwlEcmaStringParser.SubExprStart, 0) + + def SubExprEnd(self): + return self.getToken(CwlEcmaStringParser.SubExprEnd, 0) + + def sub_expr_part(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(CwlEcmaStringParser.Sub_expr_partContext) + else: + return self.getTypedRuleContext(CwlEcmaStringParser.Sub_expr_partContext,i) + + + def getRuleIndex(self): + return CwlEcmaStringParser.RULE_sub_expr + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterSub_expr" ): + listener.enterSub_expr(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitSub_expr" ): + listener.exitSub_expr(self) + + + + + def sub_expr(self): + + localctx = CwlEcmaStringParser.Sub_exprContext(self, self._ctx, self.state) + self.enterRule(localctx, 4, self.RULE_sub_expr) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 29 + self.match(CwlEcmaStringParser.SubExprStart) + self.state = 33 + self._errHandler.sync(self) + _la = self._input.LA(1) + while _la==CwlEcmaStringParser.SubSubExprStart or _la==CwlEcmaStringParser.SubExprPart: + self.state = 30 + self.sub_expr_part() + self.state = 35 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 36 + self.match(CwlEcmaStringParser.SubExprEnd) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class Expr_partContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ExprPart(self): + return self.getToken(CwlEcmaStringParser.ExprPart, 0) + + def EscPart(self): + return self.getToken(CwlEcmaStringParser.EscPart, 0) + + def sub_expr(self): + return self.getTypedRuleContext(CwlEcmaStringParser.Sub_exprContext,0) + + + def getRuleIndex(self): + return CwlEcmaStringParser.RULE_expr_part + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterExpr_part" ): + listener.enterExpr_part(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitExpr_part" ): + listener.exitExpr_part(self) + + + + + def expr_part(self): + + localctx = CwlEcmaStringParser.Expr_partContext(self, self._ctx, self.state) + self.enterRule(localctx, 6, self.RULE_expr_part) + try: + self.state = 41 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [CwlEcmaStringParser.ExprPart]: + self.enterOuterAlt(localctx, 1) + self.state = 38 + self.match(CwlEcmaStringParser.ExprPart) + pass + elif token in [CwlEcmaStringParser.EscPart]: + self.enterOuterAlt(localctx, 2) + self.state = 39 + self.match(CwlEcmaStringParser.EscPart) + pass + elif token in [CwlEcmaStringParser.SubExprStart]: + self.enterOuterAlt(localctx, 3) + self.state = 40 + self.sub_expr() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class Paren_exprContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DOLLARPAREN(self): + return self.getToken(CwlEcmaStringParser.DOLLARPAREN, 0) + + def ExprEnd(self): + return self.getToken(CwlEcmaStringParser.ExprEnd, 0) + + def expr_part(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(CwlEcmaStringParser.Expr_partContext) + else: + return self.getTypedRuleContext(CwlEcmaStringParser.Expr_partContext,i) + + + def getRuleIndex(self): + return CwlEcmaStringParser.RULE_paren_expr + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterParen_expr" ): + listener.enterParen_expr(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitParen_expr" ): + listener.exitParen_expr(self) + + + + + def paren_expr(self): + + localctx = CwlEcmaStringParser.Paren_exprContext(self, self._ctx, self.state) + self.enterRule(localctx, 8, self.RULE_paren_expr) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 43 + self.match(CwlEcmaStringParser.DOLLARPAREN) + self.state = 45 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 44 + self.expr_part() + self.state = 47 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CwlEcmaStringParser.EscPart) | (1 << CwlEcmaStringParser.SubExprStart) | (1 << CwlEcmaStringParser.ExprPart))) != 0)): + break + + self.state = 49 + self.match(CwlEcmaStringParser.ExprEnd) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class Brace_exprContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DOLLARBRACE(self): + return self.getToken(CwlEcmaStringParser.DOLLARBRACE, 0) + + def ExprEnd(self): + return self.getToken(CwlEcmaStringParser.ExprEnd, 0) + + def expr_part(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(CwlEcmaStringParser.Expr_partContext) + else: + return self.getTypedRuleContext(CwlEcmaStringParser.Expr_partContext,i) + + + def getRuleIndex(self): + return CwlEcmaStringParser.RULE_brace_expr + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterBrace_expr" ): + listener.enterBrace_expr(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitBrace_expr" ): + listener.exitBrace_expr(self) + + + + + def brace_expr(self): + + localctx = CwlEcmaStringParser.Brace_exprContext(self, self._ctx, self.state) + self.enterRule(localctx, 10, self.RULE_brace_expr) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 51 + self.match(CwlEcmaStringParser.DOLLARBRACE) + self.state = 53 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 52 + self.expr_part() + self.state = 55 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CwlEcmaStringParser.EscPart) | (1 << CwlEcmaStringParser.SubExprStart) | (1 << CwlEcmaStringParser.ExprPart))) != 0)): + break + + self.state = 57 + self.match(CwlEcmaStringParser.ExprEnd) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class Interpolated_string_partContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def BACKSLASHESC(self): + return self.getToken(CwlEcmaStringParser.BACKSLASHESC, 0) + + def DOLLARPARENESC(self): + return self.getToken(CwlEcmaStringParser.DOLLARPARENESC, 0) + + def DOLLARBRACEESC(self): + return self.getToken(CwlEcmaStringParser.DOLLARBRACEESC, 0) + + def paren_expr(self): + return self.getTypedRuleContext(CwlEcmaStringParser.Paren_exprContext,0) + + + def brace_expr(self): + return self.getTypedRuleContext(CwlEcmaStringParser.Brace_exprContext,0) + + + def ANYCHAR(self): + return self.getToken(CwlEcmaStringParser.ANYCHAR, 0) + + def getRuleIndex(self): + return CwlEcmaStringParser.RULE_interpolated_string_part + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInterpolated_string_part" ): + listener.enterInterpolated_string_part(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInterpolated_string_part" ): + listener.exitInterpolated_string_part(self) + + + + + def interpolated_string_part(self): + + localctx = CwlEcmaStringParser.Interpolated_string_partContext(self, self._ctx, self.state) + self.enterRule(localctx, 12, self.RULE_interpolated_string_part) + try: + self.state = 65 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [CwlEcmaStringParser.BACKSLASHESC]: + self.enterOuterAlt(localctx, 1) + self.state = 59 + self.match(CwlEcmaStringParser.BACKSLASHESC) + pass + elif token in [CwlEcmaStringParser.DOLLARPARENESC]: + self.enterOuterAlt(localctx, 2) + self.state = 60 + self.match(CwlEcmaStringParser.DOLLARPARENESC) + pass + elif token in [CwlEcmaStringParser.DOLLARBRACEESC]: + self.enterOuterAlt(localctx, 3) + self.state = 61 + self.match(CwlEcmaStringParser.DOLLARBRACEESC) + pass + elif token in [CwlEcmaStringParser.DOLLARPAREN]: + self.enterOuterAlt(localctx, 4) + self.state = 62 + self.paren_expr() + pass + elif token in [CwlEcmaStringParser.DOLLARBRACE]: + self.enterOuterAlt(localctx, 5) + self.state = 63 + self.brace_expr() + pass + elif token in [CwlEcmaStringParser.ANYCHAR]: + self.enterOuterAlt(localctx, 6) + self.state = 64 + self.match(CwlEcmaStringParser.ANYCHAR) + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class Interpolated_stringContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def interpolated_string_part(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(CwlEcmaStringParser.Interpolated_string_partContext) + else: + return self.getTypedRuleContext(CwlEcmaStringParser.Interpolated_string_partContext,i) + + + def getRuleIndex(self): + return CwlEcmaStringParser.RULE_interpolated_string + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInterpolated_string" ): + listener.enterInterpolated_string(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInterpolated_string" ): + listener.exitInterpolated_string(self) + + + + + def interpolated_string(self): + + localctx = CwlEcmaStringParser.Interpolated_stringContext(self, self._ctx, self.state) + self.enterRule(localctx, 14, self.RULE_interpolated_string) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 68 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 67 + self.interpolated_string_part() + self.state = 70 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CwlEcmaStringParser.ANYCHAR) | (1 << CwlEcmaStringParser.DOLLARPAREN) | (1 << CwlEcmaStringParser.DOLLARBRACE) | (1 << CwlEcmaStringParser.DOLLARPARENESC) | (1 << CwlEcmaStringParser.DOLLARBRACEESC) | (1 << CwlEcmaStringParser.BACKSLASHESC))) != 0)): + break + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + + + diff --git a/cwl_utils/parser/v1_2EcmaStringParserListener.py b/cwl_utils/parser/v1_2EcmaStringParserListener.py new file mode 100644 index 00000000..989d1331 --- /dev/null +++ b/cwl_utils/parser/v1_2EcmaStringParserListener.py @@ -0,0 +1,82 @@ +# Generated from antlr4/CwlEcmaStringParser.g4 by ANTLR 4.7.2 +from antlr4 import * +if __name__ is not None and "." in __name__: + from .CwlEcmaStringParser import CwlEcmaStringParser +else: + from CwlEcmaStringParser import CwlEcmaStringParser + +# This class defines a complete listener for a parse tree produced by CwlEcmaStringParser. +class CwlEcmaStringParserListener(ParseTreeListener): + + # Enter a parse tree produced by CwlEcmaStringParser#sub_sub_expr. + def enterSub_sub_expr(self, ctx:CwlEcmaStringParser.Sub_sub_exprContext): + pass + + # Exit a parse tree produced by CwlEcmaStringParser#sub_sub_expr. + def exitSub_sub_expr(self, ctx:CwlEcmaStringParser.Sub_sub_exprContext): + pass + + + # Enter a parse tree produced by CwlEcmaStringParser#sub_expr_part. + def enterSub_expr_part(self, ctx:CwlEcmaStringParser.Sub_expr_partContext): + pass + + # Exit a parse tree produced by CwlEcmaStringParser#sub_expr_part. + def exitSub_expr_part(self, ctx:CwlEcmaStringParser.Sub_expr_partContext): + pass + + + # Enter a parse tree produced by CwlEcmaStringParser#sub_expr. + def enterSub_expr(self, ctx:CwlEcmaStringParser.Sub_exprContext): + pass + + # Exit a parse tree produced by CwlEcmaStringParser#sub_expr. + def exitSub_expr(self, ctx:CwlEcmaStringParser.Sub_exprContext): + pass + + + # Enter a parse tree produced by CwlEcmaStringParser#expr_part. + def enterExpr_part(self, ctx:CwlEcmaStringParser.Expr_partContext): + pass + + # Exit a parse tree produced by CwlEcmaStringParser#expr_part. + def exitExpr_part(self, ctx:CwlEcmaStringParser.Expr_partContext): + pass + + + # Enter a parse tree produced by CwlEcmaStringParser#paren_expr. + def enterParen_expr(self, ctx:CwlEcmaStringParser.Paren_exprContext): + pass + + # Exit a parse tree produced by CwlEcmaStringParser#paren_expr. + def exitParen_expr(self, ctx:CwlEcmaStringParser.Paren_exprContext): + pass + + + # Enter a parse tree produced by CwlEcmaStringParser#brace_expr. + def enterBrace_expr(self, ctx:CwlEcmaStringParser.Brace_exprContext): + pass + + # Exit a parse tree produced by CwlEcmaStringParser#brace_expr. + def exitBrace_expr(self, ctx:CwlEcmaStringParser.Brace_exprContext): + pass + + + # Enter a parse tree produced by CwlEcmaStringParser#interpolated_string_part. + def enterInterpolated_string_part(self, ctx:CwlEcmaStringParser.Interpolated_string_partContext): + pass + + # Exit a parse tree produced by CwlEcmaStringParser#interpolated_string_part. + def exitInterpolated_string_part(self, ctx:CwlEcmaStringParser.Interpolated_string_partContext): + pass + + + # Enter a parse tree produced by CwlEcmaStringParser#interpolated_string. + def enterInterpolated_string(self, ctx:CwlEcmaStringParser.Interpolated_stringContext): + pass + + # Exit a parse tree produced by CwlEcmaStringParser#interpolated_string. + def exitInterpolated_string(self, ctx:CwlEcmaStringParser.Interpolated_stringContext): + pass + + diff --git a/cwl_utils/parser/v1_2ParameterReferenceLexer.py b/cwl_utils/parser/v1_2ParameterReferenceLexer.py new file mode 100644 index 00000000..ccd2e202 --- /dev/null +++ b/cwl_utils/parser/v1_2ParameterReferenceLexer.py @@ -0,0 +1,161 @@ +# Generated from antlr4/CwlParameterReferenceLexer.g4 by ANTLR 4.7.2 +from antlr4 import * +from io import StringIO +from typing.io import TextIO +import sys + + +def serializedATN(): + with StringIO() as buf: + buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\30") + buf.write("\u00c9\b\1\b\1\b\1\b\1\b\1\4\2\t\2\4\3\t\3\4\4\t\4\4\5") + buf.write("\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13") + buf.write("\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t") + buf.write("\21\4\22\t\22\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26") + buf.write("\4\27\t\27\4\30\t\30\4\31\t\31\4\32\t\32\4\33\t\33\4\34") + buf.write("\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!\t!\4\"\t") + buf.write("\"\4#\t#\4$\t$\3\2\3\2\3\3\3\3\3\4\3\4\3\5\3\5\3\5\3\5") + buf.write("\3\5\3\6\3\6\3\7\3\7\3\7\3\7\3\b\3\b\3\t\3\t\3\t\3\n\3") + buf.write("\n\3\13\3\13\3\13\3\f\3\f\3\f\3\r\3\r\3\r\3\16\3\16\3") + buf.write("\16\3\17\3\17\3\20\3\20\3\21\3\21\3\21\3\21\3\22\3\22") + buf.write("\3\22\3\22\3\23\3\23\3\23\3\23\3\24\3\24\3\24\3\24\3\25") + buf.write("\3\25\3\25\3\26\3\26\3\26\3\26\3\26\3\27\6\27\u008f\n") + buf.write("\27\r\27\16\27\u0090\3\30\3\30\3\30\3\30\3\31\3\31\3\31") + buf.write("\3\31\3\31\3\32\3\32\3\32\3\32\3\32\3\33\6\33\u00a2\n") + buf.write("\33\r\33\16\33\u00a3\3\33\3\33\3\34\3\34\3\34\3\34\3\35") + buf.write("\3\35\3\35\3\35\3\35\3\36\3\36\3\37\3\37\7\37\u00b5\n") + buf.write("\37\f\37\16\37\u00b8\13\37\3 \3 \3!\6!\u00bd\n!\r!\16") + buf.write("!\u00be\3\"\6\"\u00c2\n\"\r\"\16\"\u00c3\3#\3#\3$\3$\2") + buf.write("\2%\7\3\t\4\13\5\r\6\17\7\21\b\23\t\25\n\27\13\31\f\33") + buf.write("\r\35\16\37\17!\20#\21%\22\'\23)\24+\25-\26/\2\61\27\63") + buf.write("\2\65\2\67\29\2;\2=\2?\30A\2C\2E\2G\2I\2K\2\7\2\3\4\5") + buf.write("\6\b\4\2))^^\4\2$$^^\4\2C\\c|\6\2\62;C\\aac|\3\2\62;\5") + buf.write("\2\62;CHch\2\u00c3\2\7\3\2\2\2\2\t\3\2\2\2\2\13\3\2\2") + buf.write("\2\2\r\3\2\2\2\2\17\3\2\2\2\2\21\3\2\2\2\2\23\3\2\2\2") + buf.write("\2\25\3\2\2\2\2\27\3\2\2\2\2\31\3\2\2\2\2\33\3\2\2\2\2") + buf.write("\35\3\2\2\2\2\37\3\2\2\2\3!\3\2\2\2\3#\3\2\2\2\3%\3\2") + buf.write("\2\2\3\'\3\2\2\2\3)\3\2\2\2\3+\3\2\2\2\4-\3\2\2\2\4/\3") + buf.write("\2\2\2\4\61\3\2\2\2\4\63\3\2\2\2\5\65\3\2\2\2\5\67\3\2") + buf.write("\2\2\59\3\2\2\2\5;\3\2\2\2\6=\3\2\2\2\6?\3\2\2\2\7M\3") + buf.write("\2\2\2\tO\3\2\2\2\13Q\3\2\2\2\rS\3\2\2\2\17X\3\2\2\2\21") + buf.write("Z\3\2\2\2\23^\3\2\2\2\25`\3\2\2\2\27c\3\2\2\2\31e\3\2") + buf.write("\2\2\33h\3\2\2\2\35k\3\2\2\2\37n\3\2\2\2!q\3\2\2\2#s\3") + buf.write("\2\2\2%u\3\2\2\2\'y\3\2\2\2)}\3\2\2\2+\u0081\3\2\2\2-") + buf.write("\u0085\3\2\2\2/\u0088\3\2\2\2\61\u008e\3\2\2\2\63\u0092") + buf.write("\3\2\2\2\65\u0096\3\2\2\2\67\u009b\3\2\2\29\u00a1\3\2") + buf.write("\2\2;\u00a7\3\2\2\2=\u00ab\3\2\2\2?\u00b0\3\2\2\2A\u00b2") + buf.write("\3\2\2\2C\u00b9\3\2\2\2E\u00bc\3\2\2\2G\u00c1\3\2\2\2") + buf.write("I\u00c5\3\2\2\2K\u00c7\3\2\2\2MN\7\60\2\2N\b\3\2\2\2O") + buf.write("P\7]\2\2P\n\3\2\2\2QR\7_\2\2R\f\3\2\2\2ST\7&\2\2TU\7*") + buf.write("\2\2UV\3\2\2\2VW\b\5\2\2W\16\3\2\2\2XY\7+\2\2Y\20\3\2") + buf.write("\2\2Z[\7^\2\2[\\\7&\2\2\\]\7*\2\2]\22\3\2\2\2^_\7^\2\2") + buf.write("_\24\3\2\2\2`a\7^\2\2ab\7^\2\2b\26\3\2\2\2cd\13\2\2\2") + buf.write("d\30\3\2\2\2ef\7]\2\2fg\7)\2\2g\32\3\2\2\2hi\7]\2\2ij") + buf.write("\7$\2\2j\34\3\2\2\2kl\7)\2\2lm\7_\2\2m\36\3\2\2\2no\7") + buf.write("$\2\2op\7_\2\2p \3\2\2\2qr\5\7\2\2r\"\3\2\2\2st\5A\37") + buf.write("\2t$\3\2\2\2uv\5\31\13\2vw\3\2\2\2wx\b\21\3\2x&\3\2\2") + buf.write("\2yz\5\33\f\2z{\3\2\2\2{|\b\22\4\2|(\3\2\2\2}~\5\t\3\2") + buf.write("~\177\3\2\2\2\177\u0080\b\23\5\2\u0080*\3\2\2\2\u0081") + buf.write("\u0082\5\17\6\2\u0082\u0083\3\2\2\2\u0083\u0084\b\24\6") + buf.write("\2\u0084,\3\2\2\2\u0085\u0086\5\23\b\2\u0086\u0087\5\27") + buf.write("\n\2\u0087.\3\2\2\2\u0088\u0089\5\35\r\2\u0089\u008a\3") + buf.write("\2\2\2\u008a\u008b\b\26\6\2\u008b\u008c\b\26\7\2\u008c") + buf.write("\60\3\2\2\2\u008d\u008f\n\2\2\2\u008e\u008d\3\2\2\2\u008f") + buf.write("\u0090\3\2\2\2\u0090\u008e\3\2\2\2\u0090\u0091\3\2\2\2") + buf.write("\u0091\62\3\2\2\2\u0092\u0093\5\23\b\2\u0093\u0094\3\2") + buf.write("\2\2\u0094\u0095\b\30\b\2\u0095\64\3\2\2\2\u0096\u0097") + buf.write("\5\23\b\2\u0097\u0098\5\27\n\2\u0098\u0099\3\2\2\2\u0099") + buf.write("\u009a\b\31\t\2\u009a\66\3\2\2\2\u009b\u009c\5\37\16\2") + buf.write("\u009c\u009d\3\2\2\2\u009d\u009e\b\32\6\2\u009e\u009f") + buf.write("\b\32\n\2\u009f8\3\2\2\2\u00a0\u00a2\n\3\2\2\u00a1\u00a0") + buf.write("\3\2\2\2\u00a2\u00a3\3\2\2\2\u00a3\u00a1\3\2\2\2\u00a3") + buf.write("\u00a4\3\2\2\2\u00a4\u00a5\3\2\2\2\u00a5\u00a6\b\33\b") + buf.write("\2\u00a6:\3\2\2\2\u00a7\u00a8\5\23\b\2\u00a8\u00a9\3\2") + buf.write("\2\2\u00a9\u00aa\b\34\b\2\u00aa<\3\2\2\2\u00ab\u00ac\5") + buf.write("\13\4\2\u00ac\u00ad\3\2\2\2\u00ad\u00ae\b\35\6\2\u00ae") + buf.write("\u00af\b\35\13\2\u00af>\3\2\2\2\u00b0\u00b1\5G\"\2\u00b1") + buf.write("@\3\2\2\2\u00b2\u00b6\5C \2\u00b3\u00b5\5E!\2\u00b4\u00b3") + buf.write("\3\2\2\2\u00b5\u00b8\3\2\2\2\u00b6\u00b4\3\2\2\2\u00b6") + buf.write("\u00b7\3\2\2\2\u00b7B\3\2\2\2\u00b8\u00b6\3\2\2\2\u00b9") + buf.write("\u00ba\t\4\2\2\u00baD\3\2\2\2\u00bb\u00bd\t\5\2\2\u00bc") + buf.write("\u00bb\3\2\2\2\u00bd\u00be\3\2\2\2\u00be\u00bc\3\2\2\2") + buf.write("\u00be\u00bf\3\2\2\2\u00bfF\3\2\2\2\u00c0\u00c2\5I#\2") + buf.write("\u00c1\u00c0\3\2\2\2\u00c2\u00c3\3\2\2\2\u00c3\u00c1\3") + buf.write("\2\2\2\u00c3\u00c4\3\2\2\2\u00c4H\3\2\2\2\u00c5\u00c6") + buf.write("\t\6\2\2\u00c6J\3\2\2\2\u00c7\u00c8\t\7\2\2\u00c8L\3\2") + buf.write("\2\2\f\2\3\4\5\6\u0090\u00a3\u00b6\u00be\u00c3\f\7\3\2") + buf.write("\7\4\2\7\5\2\7\6\2\6\2\2\t\22\2\t\27\2\t\26\2\t\23\2\t") + buf.write("\24\2") + return buf.getvalue() + + +class CwlParameterReferenceLexer(Lexer): + + atn = ATNDeserializer().deserialize(serializedATN()) + + decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ] + + ParenExpr = 1 + SingleQString = 2 + DoubleQString = 3 + IntIndex = 4 + + DOT = 1 + LBRACKET = 2 + RBRACKET = 3 + DOLLARPAREN = 4 + RPAREN = 5 + DOLLARPARENESC = 6 + BACKSLASH = 7 + BACKSLASHESC = 8 + ANYCHAR = 9 + LBRACKETSINGLEQ = 10 + LBRACKETDOUBLEQ = 11 + SINGLEQRBRACKET = 12 + DOUBLEQRBRACKET = 13 + ExprDot = 14 + ExprSymbol = 15 + ExprSingleQ = 16 + ExprDoubleQ = 17 + ExprIntIndex = 18 + EndParenExpr = 19 + StringIndexEscPart = 20 + StringIndexPart = 21 + IntIndexPart = 22 + + channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ] + + modeNames = [ "DEFAULT_MODE", "ParenExpr", "SingleQString", "DoubleQString", + "IntIndex" ] + + literalNames = [ "", + "'.'", "'['", "']'", "'$('", "')'", "'\\$('", "'\\'", "'\\\\'", + "'[''", "'[\"'", "'']'", "'\"]'" ] + + symbolicNames = [ "", + "DOT", "LBRACKET", "RBRACKET", "DOLLARPAREN", "RPAREN", "DOLLARPARENESC", + "BACKSLASH", "BACKSLASHESC", "ANYCHAR", "LBRACKETSINGLEQ", "LBRACKETDOUBLEQ", + "SINGLEQRBRACKET", "DOUBLEQRBRACKET", "ExprDot", "ExprSymbol", + "ExprSingleQ", "ExprDoubleQ", "ExprIntIndex", "EndParenExpr", + "StringIndexEscPart", "StringIndexPart", "IntIndexPart" ] + + ruleNames = [ "DOT", "LBRACKET", "RBRACKET", "DOLLARPAREN", "RPAREN", + "DOLLARPARENESC", "BACKSLASH", "BACKSLASHESC", "ANYCHAR", + "LBRACKETSINGLEQ", "LBRACKETDOUBLEQ", "SINGLEQRBRACKET", + "DOUBLEQRBRACKET", "ExprDot", "ExprSymbol", "ExprSingleQ", + "ExprDoubleQ", "ExprIntIndex", "EndParenExpr", "StringIndexEscPart", + "EndSingleQ", "StringIndexPart", "LiteralBackslash", "DoubleQEscapedChar", + "EndDoubleQ", "DoubleQStringIndexPart", "DoubleQLiteralBackslash", + "EndIndex", "IntIndexPart", "CompleteSymbol", "SymbolStart", + "SymbolFollow", "DecimalNumber", "DecimalDigit", "HexDigit" ] + + grammarFileName = "CwlParameterReferenceLexer.g4" + + def __init__(self, input=None, output:TextIO = sys.stdout): + super().__init__(input, output) + self.checkVersion("4.7.2") + self._interp = LexerATNSimulator(self, self.atn, self.decisionsToDFA, PredictionContextCache()) + self._actions = None + self._predicates = None + + diff --git a/cwl_utils/parser/v1_2ParameterReferenceParser.py b/cwl_utils/parser/v1_2ParameterReferenceParser.py new file mode 100644 index 00000000..73beb010 --- /dev/null +++ b/cwl_utils/parser/v1_2ParameterReferenceParser.py @@ -0,0 +1,603 @@ +# Generated from antlr4/CwlParameterReferenceParser.g4 by ANTLR 4.7.2 +# encoding: utf-8 +from antlr4 import * +from io import StringIO +from typing.io import TextIO +import sys + +def serializedATN(): + with StringIO() as buf: + buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\30") + buf.write("H\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b") + buf.write("\t\b\4\t\t\t\3\2\3\2\3\2\3\3\3\3\3\3\3\3\3\4\3\4\3\5\3") + buf.write("\5\6\5\36\n\5\r\5\16\5\37\3\5\3\5\3\5\3\5\6\5&\n\5\r\5") + buf.write("\16\5\'\3\5\3\5\5\5,\n\5\3\6\3\6\3\6\5\6\61\n\6\3\7\3") + buf.write("\7\3\7\7\7\66\n\7\f\7\16\79\13\7\3\7\3\7\3\b\3\b\3\b\3") + buf.write("\b\5\bA\n\b\3\t\6\tD\n\t\r\t\16\tE\3\t\2\2\n\2\4\6\b\n") + buf.write("\f\16\20\2\3\3\2\26\27\2I\2\22\3\2\2\2\4\25\3\2\2\2\6") + buf.write("\31\3\2\2\2\b+\3\2\2\2\n\60\3\2\2\2\f\62\3\2\2\2\16@\3") + buf.write("\2\2\2\20C\3\2\2\2\22\23\7\20\2\2\23\24\7\21\2\2\24\3") + buf.write("\3\2\2\2\25\26\7\24\2\2\26\27\7\30\2\2\27\30\7\24\2\2") + buf.write("\30\5\3\2\2\2\31\32\t\2\2\2\32\7\3\2\2\2\33\35\7\22\2") + buf.write("\2\34\36\5\6\4\2\35\34\3\2\2\2\36\37\3\2\2\2\37\35\3\2") + buf.write("\2\2\37 \3\2\2\2 !\3\2\2\2!\"\7\22\2\2\",\3\2\2\2#%\7") + buf.write("\23\2\2$&\5\6\4\2%$\3\2\2\2&\'\3\2\2\2\'%\3\2\2\2\'(\3") + buf.write("\2\2\2()\3\2\2\2)*\7\23\2\2*,\3\2\2\2+\33\3\2\2\2+#\3") + buf.write("\2\2\2,\t\3\2\2\2-\61\5\2\2\2.\61\5\4\3\2/\61\5\b\5\2") + buf.write("\60-\3\2\2\2\60.\3\2\2\2\60/\3\2\2\2\61\13\3\2\2\2\62") + buf.write("\63\7\6\2\2\63\67\7\21\2\2\64\66\5\n\6\2\65\64\3\2\2\2") + buf.write("\669\3\2\2\2\67\65\3\2\2\2\678\3\2\2\28:\3\2\2\29\67\3") + buf.write("\2\2\2:;\7\25\2\2;\r\3\2\2\2A\5\f") + buf.write("\7\2?A\7\13\2\2@<\3\2\2\2@=\3\2\2\2@>\3\2\2\2@?\3\2\2") + buf.write("\2A\17\3\2\2\2BD\5\16\b\2CB\3\2\2\2DE\3\2\2\2EC\3\2\2") + buf.write("\2EF\3\2\2\2F\21\3\2\2\2\t\37\'+\60\67@E") + return buf.getvalue() + + +class CwlParameterReferenceParser ( Parser ): + + grammarFileName = "CwlParameterReferenceParser.g4" + + atn = ATNDeserializer().deserialize(serializedATN()) + + decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ] + + sharedContextCache = PredictionContextCache() + + literalNames = [ "", "'.'", "'['", "']'", "'$('", "')'", "'\\$('", + "'\\'", "'\\\\'", "", "'[''", "'[\"'", "'']'", + "'\"]'" ] + + symbolicNames = [ "", "DOT", "LBRACKET", "RBRACKET", "DOLLARPAREN", + "RPAREN", "DOLLARPARENESC", "BACKSLASH", "BACKSLASHESC", + "ANYCHAR", "LBRACKETSINGLEQ", "LBRACKETDOUBLEQ", "SINGLEQRBRACKET", + "DOUBLEQRBRACKET", "ExprDot", "ExprSymbol", "ExprSingleQ", + "ExprDoubleQ", "ExprIntIndex", "EndParenExpr", "StringIndexEscPart", + "StringIndexPart", "IntIndexPart" ] + + RULE_expr_dot_symbol = 0 + RULE_int_index = 1 + RULE_string_index_part = 2 + RULE_string_index = 3 + RULE_expr_segment = 4 + RULE_paren_expr = 5 + RULE_interpolated_string_part = 6 + RULE_interpolated_string = 7 + + ruleNames = [ "expr_dot_symbol", "int_index", "string_index_part", + "string_index", "expr_segment", "paren_expr", "interpolated_string_part", + "interpolated_string" ] + + EOF = Token.EOF + DOT=1 + LBRACKET=2 + RBRACKET=3 + DOLLARPAREN=4 + RPAREN=5 + DOLLARPARENESC=6 + BACKSLASH=7 + BACKSLASHESC=8 + ANYCHAR=9 + LBRACKETSINGLEQ=10 + LBRACKETDOUBLEQ=11 + SINGLEQRBRACKET=12 + DOUBLEQRBRACKET=13 + ExprDot=14 + ExprSymbol=15 + ExprSingleQ=16 + ExprDoubleQ=17 + ExprIntIndex=18 + EndParenExpr=19 + StringIndexEscPart=20 + StringIndexPart=21 + IntIndexPart=22 + + def __init__(self, input:TokenStream, output:TextIO = sys.stdout): + super().__init__(input, output) + self.checkVersion("4.7.2") + self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache) + self._predicates = None + + + + class Expr_dot_symbolContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ExprDot(self): + return self.getToken(CwlParameterReferenceParser.ExprDot, 0) + + def ExprSymbol(self): + return self.getToken(CwlParameterReferenceParser.ExprSymbol, 0) + + def getRuleIndex(self): + return CwlParameterReferenceParser.RULE_expr_dot_symbol + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterExpr_dot_symbol" ): + listener.enterExpr_dot_symbol(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitExpr_dot_symbol" ): + listener.exitExpr_dot_symbol(self) + + + + + def expr_dot_symbol(self): + + localctx = CwlParameterReferenceParser.Expr_dot_symbolContext(self, self._ctx, self.state) + self.enterRule(localctx, 0, self.RULE_expr_dot_symbol) + try: + self.enterOuterAlt(localctx, 1) + self.state = 16 + self.match(CwlParameterReferenceParser.ExprDot) + self.state = 17 + self.match(CwlParameterReferenceParser.ExprSymbol) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class Int_indexContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ExprIntIndex(self, i:int=None): + if i is None: + return self.getTokens(CwlParameterReferenceParser.ExprIntIndex) + else: + return self.getToken(CwlParameterReferenceParser.ExprIntIndex, i) + + def IntIndexPart(self): + return self.getToken(CwlParameterReferenceParser.IntIndexPart, 0) + + def getRuleIndex(self): + return CwlParameterReferenceParser.RULE_int_index + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInt_index" ): + listener.enterInt_index(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInt_index" ): + listener.exitInt_index(self) + + + + + def int_index(self): + + localctx = CwlParameterReferenceParser.Int_indexContext(self, self._ctx, self.state) + self.enterRule(localctx, 2, self.RULE_int_index) + try: + self.enterOuterAlt(localctx, 1) + self.state = 19 + self.match(CwlParameterReferenceParser.ExprIntIndex) + self.state = 20 + self.match(CwlParameterReferenceParser.IntIndexPart) + self.state = 21 + self.match(CwlParameterReferenceParser.ExprIntIndex) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class String_index_partContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def StringIndexPart(self): + return self.getToken(CwlParameterReferenceParser.StringIndexPart, 0) + + def StringIndexEscPart(self): + return self.getToken(CwlParameterReferenceParser.StringIndexEscPart, 0) + + def getRuleIndex(self): + return CwlParameterReferenceParser.RULE_string_index_part + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterString_index_part" ): + listener.enterString_index_part(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitString_index_part" ): + listener.exitString_index_part(self) + + + + + def string_index_part(self): + + localctx = CwlParameterReferenceParser.String_index_partContext(self, self._ctx, self.state) + self.enterRule(localctx, 4, self.RULE_string_index_part) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 23 + _la = self._input.LA(1) + if not(_la==CwlParameterReferenceParser.StringIndexEscPart or _la==CwlParameterReferenceParser.StringIndexPart): + self._errHandler.recoverInline(self) + else: + self._errHandler.reportMatch(self) + self.consume() + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class String_indexContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def ExprSingleQ(self, i:int=None): + if i is None: + return self.getTokens(CwlParameterReferenceParser.ExprSingleQ) + else: + return self.getToken(CwlParameterReferenceParser.ExprSingleQ, i) + + def string_index_part(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(CwlParameterReferenceParser.String_index_partContext) + else: + return self.getTypedRuleContext(CwlParameterReferenceParser.String_index_partContext,i) + + + def ExprDoubleQ(self, i:int=None): + if i is None: + return self.getTokens(CwlParameterReferenceParser.ExprDoubleQ) + else: + return self.getToken(CwlParameterReferenceParser.ExprDoubleQ, i) + + def getRuleIndex(self): + return CwlParameterReferenceParser.RULE_string_index + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterString_index" ): + listener.enterString_index(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitString_index" ): + listener.exitString_index(self) + + + + + def string_index(self): + + localctx = CwlParameterReferenceParser.String_indexContext(self, self._ctx, self.state) + self.enterRule(localctx, 6, self.RULE_string_index) + self._la = 0 # Token type + try: + self.state = 41 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [CwlParameterReferenceParser.ExprSingleQ]: + self.enterOuterAlt(localctx, 1) + self.state = 25 + self.match(CwlParameterReferenceParser.ExprSingleQ) + self.state = 27 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 26 + self.string_index_part() + self.state = 29 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not (_la==CwlParameterReferenceParser.StringIndexEscPart or _la==CwlParameterReferenceParser.StringIndexPart): + break + + self.state = 31 + self.match(CwlParameterReferenceParser.ExprSingleQ) + pass + elif token in [CwlParameterReferenceParser.ExprDoubleQ]: + self.enterOuterAlt(localctx, 2) + self.state = 33 + self.match(CwlParameterReferenceParser.ExprDoubleQ) + self.state = 35 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 34 + self.string_index_part() + self.state = 37 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not (_la==CwlParameterReferenceParser.StringIndexEscPart or _la==CwlParameterReferenceParser.StringIndexPart): + break + + self.state = 39 + self.match(CwlParameterReferenceParser.ExprDoubleQ) + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class Expr_segmentContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def expr_dot_symbol(self): + return self.getTypedRuleContext(CwlParameterReferenceParser.Expr_dot_symbolContext,0) + + + def int_index(self): + return self.getTypedRuleContext(CwlParameterReferenceParser.Int_indexContext,0) + + + def string_index(self): + return self.getTypedRuleContext(CwlParameterReferenceParser.String_indexContext,0) + + + def getRuleIndex(self): + return CwlParameterReferenceParser.RULE_expr_segment + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterExpr_segment" ): + listener.enterExpr_segment(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitExpr_segment" ): + listener.exitExpr_segment(self) + + + + + def expr_segment(self): + + localctx = CwlParameterReferenceParser.Expr_segmentContext(self, self._ctx, self.state) + self.enterRule(localctx, 8, self.RULE_expr_segment) + try: + self.state = 46 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [CwlParameterReferenceParser.ExprDot]: + self.enterOuterAlt(localctx, 1) + self.state = 43 + self.expr_dot_symbol() + pass + elif token in [CwlParameterReferenceParser.ExprIntIndex]: + self.enterOuterAlt(localctx, 2) + self.state = 44 + self.int_index() + pass + elif token in [CwlParameterReferenceParser.ExprSingleQ, CwlParameterReferenceParser.ExprDoubleQ]: + self.enterOuterAlt(localctx, 3) + self.state = 45 + self.string_index() + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class Paren_exprContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def DOLLARPAREN(self): + return self.getToken(CwlParameterReferenceParser.DOLLARPAREN, 0) + + def ExprSymbol(self): + return self.getToken(CwlParameterReferenceParser.ExprSymbol, 0) + + def EndParenExpr(self): + return self.getToken(CwlParameterReferenceParser.EndParenExpr, 0) + + def expr_segment(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(CwlParameterReferenceParser.Expr_segmentContext) + else: + return self.getTypedRuleContext(CwlParameterReferenceParser.Expr_segmentContext,i) + + + def getRuleIndex(self): + return CwlParameterReferenceParser.RULE_paren_expr + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterParen_expr" ): + listener.enterParen_expr(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitParen_expr" ): + listener.exitParen_expr(self) + + + + + def paren_expr(self): + + localctx = CwlParameterReferenceParser.Paren_exprContext(self, self._ctx, self.state) + self.enterRule(localctx, 10, self.RULE_paren_expr) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 48 + self.match(CwlParameterReferenceParser.DOLLARPAREN) + self.state = 49 + self.match(CwlParameterReferenceParser.ExprSymbol) + self.state = 53 + self._errHandler.sync(self) + _la = self._input.LA(1) + while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CwlParameterReferenceParser.ExprDot) | (1 << CwlParameterReferenceParser.ExprSingleQ) | (1 << CwlParameterReferenceParser.ExprDoubleQ) | (1 << CwlParameterReferenceParser.ExprIntIndex))) != 0): + self.state = 50 + self.expr_segment() + self.state = 55 + self._errHandler.sync(self) + _la = self._input.LA(1) + + self.state = 56 + self.match(CwlParameterReferenceParser.EndParenExpr) + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class Interpolated_string_partContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def BACKSLASHESC(self): + return self.getToken(CwlParameterReferenceParser.BACKSLASHESC, 0) + + def DOLLARPARENESC(self): + return self.getToken(CwlParameterReferenceParser.DOLLARPARENESC, 0) + + def paren_expr(self): + return self.getTypedRuleContext(CwlParameterReferenceParser.Paren_exprContext,0) + + + def ANYCHAR(self): + return self.getToken(CwlParameterReferenceParser.ANYCHAR, 0) + + def getRuleIndex(self): + return CwlParameterReferenceParser.RULE_interpolated_string_part + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInterpolated_string_part" ): + listener.enterInterpolated_string_part(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInterpolated_string_part" ): + listener.exitInterpolated_string_part(self) + + + + + def interpolated_string_part(self): + + localctx = CwlParameterReferenceParser.Interpolated_string_partContext(self, self._ctx, self.state) + self.enterRule(localctx, 12, self.RULE_interpolated_string_part) + try: + self.state = 62 + self._errHandler.sync(self) + token = self._input.LA(1) + if token in [CwlParameterReferenceParser.BACKSLASHESC]: + self.enterOuterAlt(localctx, 1) + self.state = 58 + self.match(CwlParameterReferenceParser.BACKSLASHESC) + pass + elif token in [CwlParameterReferenceParser.DOLLARPARENESC]: + self.enterOuterAlt(localctx, 2) + self.state = 59 + self.match(CwlParameterReferenceParser.DOLLARPARENESC) + pass + elif token in [CwlParameterReferenceParser.DOLLARPAREN]: + self.enterOuterAlt(localctx, 3) + self.state = 60 + self.paren_expr() + pass + elif token in [CwlParameterReferenceParser.ANYCHAR]: + self.enterOuterAlt(localctx, 4) + self.state = 61 + self.match(CwlParameterReferenceParser.ANYCHAR) + pass + else: + raise NoViableAltException(self) + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + class Interpolated_stringContext(ParserRuleContext): + + def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): + super().__init__(parent, invokingState) + self.parser = parser + + def interpolated_string_part(self, i:int=None): + if i is None: + return self.getTypedRuleContexts(CwlParameterReferenceParser.Interpolated_string_partContext) + else: + return self.getTypedRuleContext(CwlParameterReferenceParser.Interpolated_string_partContext,i) + + + def getRuleIndex(self): + return CwlParameterReferenceParser.RULE_interpolated_string + + def enterRule(self, listener:ParseTreeListener): + if hasattr( listener, "enterInterpolated_string" ): + listener.enterInterpolated_string(self) + + def exitRule(self, listener:ParseTreeListener): + if hasattr( listener, "exitInterpolated_string" ): + listener.exitInterpolated_string(self) + + + + + def interpolated_string(self): + + localctx = CwlParameterReferenceParser.Interpolated_stringContext(self, self._ctx, self.state) + self.enterRule(localctx, 14, self.RULE_interpolated_string) + self._la = 0 # Token type + try: + self.enterOuterAlt(localctx, 1) + self.state = 65 + self._errHandler.sync(self) + _la = self._input.LA(1) + while True: + self.state = 64 + self.interpolated_string_part() + self.state = 67 + self._errHandler.sync(self) + _la = self._input.LA(1) + if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CwlParameterReferenceParser.DOLLARPAREN) | (1 << CwlParameterReferenceParser.DOLLARPARENESC) | (1 << CwlParameterReferenceParser.BACKSLASHESC) | (1 << CwlParameterReferenceParser.ANYCHAR))) != 0)): + break + + except RecognitionException as re: + localctx.exception = re + self._errHandler.reportError(self, re) + self._errHandler.recover(self, re) + finally: + self.exitRule() + return localctx + + + + + diff --git a/cwl_utils/parser/v1_2ParameterReferenceParserListener.py b/cwl_utils/parser/v1_2ParameterReferenceParserListener.py new file mode 100644 index 00000000..cf753efb --- /dev/null +++ b/cwl_utils/parser/v1_2ParameterReferenceParserListener.py @@ -0,0 +1,82 @@ +# Generated from antlr4/CwlParameterReferenceParser.g4 by ANTLR 4.7.2 +from antlr4 import * +if __name__ is not None and "." in __name__: + from .CwlParameterReferenceParser import CwlParameterReferenceParser +else: + from CwlParameterReferenceParser import CwlParameterReferenceParser + +# This class defines a complete listener for a parse tree produced by CwlParameterReferenceParser. +class CwlParameterReferenceParserListener(ParseTreeListener): + + # Enter a parse tree produced by CwlParameterReferenceParser#expr_dot_symbol. + def enterExpr_dot_symbol(self, ctx:CwlParameterReferenceParser.Expr_dot_symbolContext): + pass + + # Exit a parse tree produced by CwlParameterReferenceParser#expr_dot_symbol. + def exitExpr_dot_symbol(self, ctx:CwlParameterReferenceParser.Expr_dot_symbolContext): + pass + + + # Enter a parse tree produced by CwlParameterReferenceParser#int_index. + def enterInt_index(self, ctx:CwlParameterReferenceParser.Int_indexContext): + pass + + # Exit a parse tree produced by CwlParameterReferenceParser#int_index. + def exitInt_index(self, ctx:CwlParameterReferenceParser.Int_indexContext): + pass + + + # Enter a parse tree produced by CwlParameterReferenceParser#string_index_part. + def enterString_index_part(self, ctx:CwlParameterReferenceParser.String_index_partContext): + pass + + # Exit a parse tree produced by CwlParameterReferenceParser#string_index_part. + def exitString_index_part(self, ctx:CwlParameterReferenceParser.String_index_partContext): + pass + + + # Enter a parse tree produced by CwlParameterReferenceParser#string_index. + def enterString_index(self, ctx:CwlParameterReferenceParser.String_indexContext): + pass + + # Exit a parse tree produced by CwlParameterReferenceParser#string_index. + def exitString_index(self, ctx:CwlParameterReferenceParser.String_indexContext): + pass + + + # Enter a parse tree produced by CwlParameterReferenceParser#expr_segment. + def enterExpr_segment(self, ctx:CwlParameterReferenceParser.Expr_segmentContext): + pass + + # Exit a parse tree produced by CwlParameterReferenceParser#expr_segment. + def exitExpr_segment(self, ctx:CwlParameterReferenceParser.Expr_segmentContext): + pass + + + # Enter a parse tree produced by CwlParameterReferenceParser#paren_expr. + def enterParen_expr(self, ctx:CwlParameterReferenceParser.Paren_exprContext): + pass + + # Exit a parse tree produced by CwlParameterReferenceParser#paren_expr. + def exitParen_expr(self, ctx:CwlParameterReferenceParser.Paren_exprContext): + pass + + + # Enter a parse tree produced by CwlParameterReferenceParser#interpolated_string_part. + def enterInterpolated_string_part(self, ctx:CwlParameterReferenceParser.Interpolated_string_partContext): + pass + + # Exit a parse tree produced by CwlParameterReferenceParser#interpolated_string_part. + def exitInterpolated_string_part(self, ctx:CwlParameterReferenceParser.Interpolated_string_partContext): + pass + + + # Enter a parse tree produced by CwlParameterReferenceParser#interpolated_string. + def enterInterpolated_string(self, ctx:CwlParameterReferenceParser.Interpolated_stringContext): + pass + + # Exit a parse tree produced by CwlParameterReferenceParser#interpolated_string. + def exitInterpolated_string(self, ctx:CwlParameterReferenceParser.Interpolated_stringContext): + pass + + diff --git a/cwl_utils/parser/v1_2expr.py b/cwl_utils/parser/v1_2expr.py new file mode 100644 index 00000000..9116e7bb --- /dev/null +++ b/cwl_utils/parser/v1_2expr.py @@ -0,0 +1,15 @@ +import sys +from antlr4 import * +from v1_2EcmaStringLexer import CwlEcmaStringLexer +from v1_2EcmaStringParser import CwlEcmaStringParser + +def main(argv): + inp = FileStream(argv[1]) + lexer = CwlEcmaStringLexer(inp) + stream = CommonTokenStream(lexer) + parser = CwlEcmaStringParser(stream) + tree = parser.interpolated_string() + +if __name__ == '__main__': + main(sys.argv) +