class GENERATOR(SectionedGenerator):
META = DSLMetadata(
officialLibraryRepo=masterBranchURI + "/examples",
grammarExtensions=("Laja",),
)
escaper = charClassEscaper
assignmentOperator = " = "
endStatementOperator = ";"
singleLineCommentStart = "//"
DEFAULT_ORDER = ("firstRule", "prods", "fragmented", "keywords", "chars", "tokens")
charClassEscaper = pythonRegexEscaper
class CHAR_CLASS_PROCESSOR(CharClassKeepProcessor):
@classmethod
def encloseCharClass(cls, s: str, obj: _CharClass, grammar: Grammar) -> str:
raise NotImplementedError()
@classmethod
def wrapLiteralString(cls, s: str) -> str:
raise NotImplementedError()
@classmethod
def Ref(cls, obj, grammar: typing.Optional[Grammar], ctx: typing.Any = None) -> str:
raise NotImplementedError()
@classmethod
def _Name(cls, k: str, v: str, ctx: typing.Any = None) -> str:
raise NotImplementedError()
class CanopyGenerator(PackratGenerator): META = DSLMetadata( officialLibraryRepo=None, grammarExtensions=None ) assignmentOperator = " = " singleLineCommentStart = "#"
class GENERATOR(SectionedGenerator):
META = DSLMetadata(
officialLibraryRepo=masterBranchURI + "/examples",
grammarExtensions=("Nearley", ),
)
escaper = charClassEscaper
assignmentOperator = " = "
endStatementOperator = ""
singleLineCommentStart = "//"
DEFAULT_ORDER = ("firstRule", "prods", "fragmented", "keywords",
"chars", "tokens")
charClassEscaper = pythonRegexEscaper
class CHAR_CLASS_PROCESSOR(CharClassMergeProcessor):
charClassSetStart = "["
charClassSetEnd = "]"
@classmethod
def encloseCharClass(cls, s: str, obj: _CharClass,
grammar: Grammar) -> str:
return "/" + cls.charClassSetStart + s.replace(
"/", r"\/") + cls.charClassSetEnd + "/"
class SECTIONER(SectionedGenerator.SECTIONER):
@classmethod
def firstRule(cls,
backend: SectionedGenerator,
gr: Grammar,
ctx: typing.Any = None):
if gr.meta:
yield backend.resolve(
Name("start",
gr.prods.findFirstRule().name), gr, ctx)
@classmethod
def wrapLiteralString(cls, s: str) -> str:
return '"' + doubleTickEscaper(s) + '"'
@classmethod
def Ref(cls,
obj,
grammar: typing.Optional[Grammar],
ctx: typing.Any = None) -> str:
return transformNameForNearley(obj.name)
@classmethod
def _Name(cls, k: str, v: str, ctx: typing.Any = None) -> str:
return super()._Name(transformNameForNearley(k), v, ctx)
class WaxeyeGenerator(SectionedGenerator):
META = DSLMetadata(
officialLibraryRepo=masterBranchURI + "/grammars",
grammarExtensions=("waxeye", ),
)
escaper = charClassEscaper
assignmentOperator = " <- "
endStatementOperator = ""
singleLineCommentStart = "#"
DEFAULT_ORDER = ("prods", "fragmented", "keywords", "chars", "tokens")
class CHAR_CLASS_PROCESSOR(CharClassMergeProcessor):
charClassSetStart = "["
charClassSetEnd = "]"
@classmethod
def wrapNegativeOuter(cls, obj: typing.Union[CharClassUnion,
CharClass], s) -> str:
return ("!" if obj.negative else "") + s
@classmethod
def wrapNegativeInner(cls, obj: typing.Union[CharClassUnion,
CharClass], s) -> str:
return s
@classmethod
def wrapZeroOrMore(cls,
res: str,
grammar: Grammar,
ctx: typing.Any = None) -> str:
return "*" + res
@classmethod
def wrapOneOrMore(cls,
res: str,
grammar: Grammar,
ctx: typing.Any = None) -> str:
return "+" + res
@classmethod
def wrapZeroOrOne(cls,
res: str,
grammar: Grammar,
ctx: typing.Any = None) -> str:
return "?" + res
class GENERATOR(PythonicGenerator):
META = DSLMetadata(
officialLibraryRepo=masterBranchURI + "/examples",
grammarExtensions=("lark", ),
)
escaper = charClassEscaper
assignmentOperator = ": "
endStatementOperator = ""
singleLineCommentStart = "//"
DEFAULT_ORDER = ("firstRule", "prods", "fragmented", "keywords",
"chars", "tokens")
class SECTIONER(PythonicGenerator.SECTIONER):
@classmethod
def firstRule(cls,
backend: SectionedGenerator,
gr: Grammar,
ctx: typing.Any = None):
if gr.meta:
yield backend.resolve(
Name("start",
gr.prods.findFirstRule().name), gr, ctx)
@classmethod
def wrapLiteralString(cls, s: str) -> str:
return '"' + doubleTickEscaper(s) + '"'
@classmethod
def Ref(cls,
obj,
grammar: typing.Optional[Grammar],
ctx: typing.Any = None) -> str:
return transformNameForLark(obj.name)
@classmethod
def _Name(cls, k: str, v: str, ctx: typing.Any = None) -> str:
return super()._Name(transformNameForLark(k), v, ctx)
class GENERATOR(SectionedGenerator):
META = DSLMetadata(
officialLibraryRepo=None,
grammarExtensions=("atg", ),
)
charClassEscaper = ourStringEscaper
stringEscaper = ourStringEscaper
assignmentOperator = " = "
endStatementOperator = "."
singleLineCommentStart = "//"
multiLineCommentStart = "/*"
multiLineCommentEnd = "*/"
DEFAULT_ORDER = ("chars", "keywordsAndCharsTokens", "tokens",
"productionsKeyword", "keywords", "fragmented",
"firstRule", "prods")
@classmethod
def initContext(cls, grammar):
return CoCoRGeneratorContext(None)
class SECTIONER(Sectioner):
@classmethod
def START(cls,
backend: SectionedGenerator,
gr: Grammar,
ctx: typing.Any = None):
yield from super(cls, cls).START(backend, gr)
yield "COMPILER " + gr.meta.id
yield backend.resolve(Spacer(), gr)
class chars(SectionDumper):
__slots__ = ()
@classmethod
def dumpSection(self,
backend: SectionedGenerator,
gr: Grammar,
content: typing.Iterable[str],
ctx: typing.Any = None):
if content:
yield "CHARACTERS"
yield from content
yield backend.resolve(Spacer(2), gr, ctx)
@classmethod
def dumpContent(
cls,
backend: SectionedGenerator,
gr: Grammar,
ctx: typing.Any = None) -> typing.Iterable[str]:
charsReferencedInTokens = getReferenced(gr.tokens)
for charSymbol in gr.chars.children:
if isinstance(charSymbol, Name):
tokenName = charSymbol.name
if tokenName not in charsReferencedInTokens:
ctx.charClassesToTokensNameRemap[
tokenName] = charSymbol.name = charSymbol.name + "C"
rewriteReferences(gr.chars,
ctx.charClassesToTokensNameRemap)
yield from Sectioner.chars.dumpContent(backend, gr, ctx)
class keywordsAndCharsTokens(SectionDumper):
__slots__ = ()
@classmethod
def dumpSection(self,
backend: SectionedGenerator,
gr: Grammar,
content: typing.Iterable[str],
ctx: typing.Any = None):
if content:
yield "TOKENS"
yield backend.resolve(Comment("character tokens"), gr,
ctx)
yield from content
yield backend.resolve(Spacer(2), gr, ctx)
@classmethod
def dumpContent(
cls,
backend: SectionedGenerator,
gr: Grammar,
ctx: typing.Any = None) -> typing.Iterable[str]:
for tokenName, charName in ctx.charClassesToTokensNameRemap.items(
):
yield backend.resolve(Name(tokenName, Ref(charName)),
gr, ctx)
@classmethod
def productionsKeyword(cls,
backend: SectionedGenerator,
gr: Grammar,
ctx: typing.Any = None):
yield "PRODUCTIONS"
@classmethod
def firstRule(cls,
backend: SectionedGenerator,
gr: Grammar,
ctx: typing.Any = None):
if gr.meta:
yield backend.resolve(
Name(gr.meta.id,
gr.prods.findFirstRule().name), gr, ctx)
@classmethod
def END(cls,
backend: SectionedGenerator,
gr: Grammar,
ctx: typing.Any = None):
yield "END " + gr.meta.id + " " + backend.endStatementOperator
class CHAR_CLASS_PROCESSOR(CharClassKeepProcessor):
charClassNegativeJoiner = "-"
charClassPositiveJoiner = "+"
charClassSetStart = '"'
charClassSetEnd = '"'
@classmethod
def wrapNegativeOuter(cls, obj: typing.Union[CharClassUnion,
CharClass], s) -> str:
return "ANY" + cls.charClassNegativeJoiner if obj.negative else "" + s
@classmethod
def wrapNegativeInner(cls, obj: typing.Union[CharClassUnion,
CharClass], s) -> str:
return s
@classmethod
def wrapOneOrMore(cls, *args, **kwargs):
return cls.wrapNOrMore(1, *args, **kwargs)
@classmethod
def wrapZeroOrMore(cls,
res: str,
grammar: Grammar,
ctx: typing.Any = None) -> str:
return "{" + res + "}"
@classmethod
def wrapZeroOrOne(cls,
res: str,
grammar: Grammar,
ctx: typing.Any = None) -> str:
return "[" + res + "]"