class Alternatives(modgrammar.Grammar):
grammar_whitespace_mode = 'explicit'
grammar = (modgrammar.OPTIONAL(AlternativeWeight),
AlternativeRuleExpansion,
modgrammar.ONE_OR_MORE(AlternativeSeparator,
modgrammar.OPTIONAL(AlternativeWeight),
AlternativeRuleExpansion
))
def grammar_elem_init(self, session_data):
self.model = model.Alternatives()
element = self[1].model
if self[0] is not None:
element.weight = self[0].value
self.model.add_element(element)
for i in range(0, len(self[2].elements)):
element = self[2][i][2].model
if self[2][i][1] is not None:
element.weight = self[2][i][1].value
self.model.add_element(element)
class Time(mg.Grammar):
grammar_whitespace_mode = 'explicit'
unit_lookup = {
's': 'sec',
'sec': 'sec',
'm': 'min',
'min': 'min',
'h': 'hour',
'hour': 'hour',
}
grammar = (
mg.OPTIONAL(QUANTITY_RANGE_APPROX_FLAG),
PosNumber,
mg.OPTIONAL(mg.GRAMMAR(
QUANTITY_RANGE_SEPARATOR,
PosNumber,
), ),
mg.OPTIONAL(QUANTITY_RANGE_APPROX_FLAG),
mg.WHITESPACE,
mg.OR(*unit_lookup.keys()),
)
def value(self):
return {
'less_ok': True if self[0] else False,
'base': self[1].value().numerator,
'base_den': self[1].value().denominator,
'range': self[2][1].value().numerator if self[2] else 0,
'range_den': self[2][1].value().denominator if self[2] else 1,
'units': self.unit_lookup[self[5].string],
}
class OptionalGroup(modgrammar.Grammar):
grammar_whitespace_mode = 'explicit'
grammar = (modgrammar.L('['), modgrammar.OPTIONAL(modgrammar.WHITESPACE),
modgrammar.REF("RuleExpansion", module=sys.modules[__name__]),
modgrammar.OPTIONAL(modgrammar.WHITESPACE), modgrammar.L(']'))
def grammar_elem_init(self, session_data):
self.model = model.OptionalGroup(self[2].model)
class Paragraph(modgrammar.Grammar):
"""Defines the grammar for a paragraph."""
grammar = (modgrammar.OPTIONAL(EmptyLine), Text,
modgrammar.OPTIONAL(EmptyLine))
def grammar_elem_init(self, sessiondata):
"""Saves the text for later use."""
self.tag = "p"
self.options = {"onlyOuterLinebreaks": True}
class PreBlock(modgrammar.Grammar):
"""Defines the grammar for a pre block."""
grammar = (modgrammar.OPTIONAL(EmptyLine), CodeBlock,
modgrammar.OPTIONAL(EmptyLine))
def grammar_elem_init(self, sessiondata):
"""Saves the text for later use."""
self.tag = "pre"
self.options = {"indentation": False}
class Edition(mg.Grammar):
'''Parse an edition comment.'''
grammar = (mg.OPTIONAL(WhiteSpace),
mg.OR(Digit, TwoDigit),
mg.OR(mg.L('nd'), mg.L('rd'), mg.L('st'), mg.L('th')),
mg.OPTIONAL(mg.OR(mg.L('facsimile'), mg.L('revised'))), mg.L('edition'),
mg.L(';'))
def grammar_elem_init(self, sessiondata):
'''initialize the element.'''
self.edition_num = self[1].string
class AlternativeRuleExpansion(modgrammar.Grammar):
grammar_whitespace_mode = 'explicit'
grammar = (Token |
QuotedToken |
RuleReference |
Sequence |
Group |
OptionalGroup,
modgrammar.OPTIONAL(UnaryOperator))
def grammar_elem_init(self, session_data):
self.model = self[0].model
if self[1] is not None:
min_repeat = 1
max_repeat = 1
if self[1].is_kleene_star:
min_repeat = 0
max_repeat = model.Element.INFINITY_REPEAT
elif self[1].is_plus:
min_repeat = 1
max_repeat = model.Element.INFINITY_REPEAT
self.model.set_repeat(min_repeat, max_repeat)
for tag in self[1].tags:
self.model.add_tag(tag)
class Grammar(modgrammar.Grammar):
grammar_whitespace_mode = 'optional'
grammar = (Header, modgrammar.ZERO_OR_MORE(Rule), modgrammar.OPTIONAL(modgrammar.WHITESPACE), modgrammar.EOI)
def grammar_elem_init(self, session_data):
self.model = model.Grammar(name=self[0].name, language=self[0].locale, encoding=self[0].encoding)
for i in range(len(self[1].elements)):
rule = self[1][i].model
self.model.add_rule(rule)
class SlotFilterCustom(mg.Grammar):
grammar = (mg.OPTIONAL(VARIANT_SLOT_INVERT_SIGIL), SlotIndices)
def value(self):
if self[0]:
sf_gen = sf.make_black_list
else:
sf_gen = sf.make_white_list
return sf_gen(*self[1].yield_value())
class SelfIdentifyingHeader(modgrammar.Grammar):
grammar_whitespace_mode = 'explicit'
grammar = (modgrammar.LITERAL("#JSGF"), modgrammar.WHITESPACE,
modgrammar.WORD("A-Za-z0-9._\-"),
modgrammar.OPTIONAL(modgrammar.WHITESPACE, modgrammar.WORD("A-Za-z0-9._\-")),
modgrammar.OPTIONAL(modgrammar.WHITESPACE, modgrammar.WORD("A-Za-z0-9._\-")),
modgrammar.LITERAL(";"), modgrammar.LITERAL('\n'))
def grammar_elem_init(self, session_data):
self.version = self[2].string
if self[3] is not None:
self.encoding = self[3][1].string
else:
self.encoding = None
if self[4] is not None:
self.locale = self[4][1].string
else:
self.locale = None
class QuotedToken(modgrammar.Grammar):
grammar_whitespace_mode = 'explicit'
grammar = (modgrammar.LITERAL('"'), modgrammar.OPTIONAL(Token), modgrammar.ONE_OR_MORE(modgrammar.WHITESPACE, Token),
modgrammar.LITERAL('"'))
def grammar_elem_init(self, session_data):
if self[1] is not None:
value = self[1].string + self[2].string
else:
value = self[2].string
self.model = model.Token(value=value)
class ImportStatement(modgrammar.Grammar):
grammar_whitespace_mode = 'explicit'
grammar = (
modgrammar.LITERAL("import"), modgrammar.WHITESPACE, modgrammar.LITERAL("<"),
Package,
modgrammar.LITERAL('.'),
JavaIdentifier | modgrammar.LITERAL('*'),
modgrammar.LITERAL(">"),
modgrammar.LITERAL(";"), modgrammar.OPTIONAL(modgrammar.WHITESPACE))
def grammar_elem_init(self, session_data):
self.package = self[3].value
self.rule = self[5].string
class NameDeclaration(modgrammar.Grammar):
grammar_whitespace_mode = 'explicit'
grammar = (modgrammar.LITERAL("grammar"), modgrammar.WHITESPACE,
modgrammar.OPTIONAL(Package, modgrammar.LITERAL('.')),
JavaIdentifier,
modgrammar.LITERAL(";"))
def grammar_elem_init(self, session_data):
self.name = self[3].value
if self[2] is None:
self.package = None
else:
self.package = self[2][0].value
class RuleReference(modgrammar.Grammar):
grammar_whitespace_mode = 'explicit'
grammar = (modgrammar.L('<'),
modgrammar.OPTIONAL(Package, modgrammar.L('.')),
JavaIdentifier,
modgrammar.L('>'))
def grammar_elem_init(self, session_data):
if self[1] is not None:
value = self[1].string + self[2].string
else:
value = self[2].string
self.model = model.RuleReference(value)
class Rule(modgrammar.Grammar):
grammar_whitespace_mode = 'optional'
grammar = (modgrammar.OPTIONAL(PublicModifier),
modgrammar.LITERAL("<"),
JavaIdentifier,
modgrammar.LITERAL(">"),
modgrammar.LITERAL("="),
RuleExpansion,
modgrammar.LITERAL(";"))
def grammar_elem_init(self, session_data):
scope = model.Rule.SCOPE_PRIVATE
if self[0] is not None:
scope = model.Rule.SCOPE_PUBLIC
self.model = model.Rule(name=self[2].value, value=self[5].model, scope=scope)
class Link(modgrammar.Grammar):
"""Defines the grammar for a link."""
grammar = (modgrammar.L("["),
modgrammar.WORD(startchars="^]`*" + modgrammar.util.EOL_CHARS,
fullmatch=True), modgrammar.L("]("),
modgrammar.WORD(startchars="^\s)", escapes=True,
fullmatch=True),
modgrammar.OPTIONAL(modgrammar.L(' "'), LinkTitle,
modgrammar.L('"')), modgrammar.L(")"))
def grammar_elem_init(self, sessiondata):
"""Saves the text for later use."""
self.text = self[1].string
self.attributes = {"href": self[3].string}
link_title = self.find(LinkTitle)
if link_title is not None:
self.attributes["title"] = link_title.text
self.tag = "a"
class UnaryOperator(modgrammar.Grammar):
grammar_whitespace_mode = 'explicit'
grammar = (modgrammar.OPTIONAL(modgrammar.WHITESPACE),
modgrammar.L('*') |
modgrammar.L('+') |
modgrammar.LIST_OF(Tag, sep=" ", min=1))
def grammar_elem_init(self, session_data):
self.is_kleene_star = False
self.is_plus = False
self.tags = []
if self[1].string == '*':
self.is_kleene_star = True
elif self[1].string == '+':
self.is_plus = True
else:
for i in range(0, len(self[1].elements), 2):
self.tags.append(self[1][i].model)
class EmptyLine(modgrammar.Grammar):
"""Defines the grammar for an empty line."""
grammar = (modgrammar.BOL, modgrammar.OPTIONAL(modgrammar.SPACE),
modgrammar.EOL)
class Name(mg.Grammar):
'''Parse a name from a comment.'''
# accept hypenated first initial and hyphenated last name
grammar = (mg.OPTIONAL(Initial, mg.OPTIONAL(mg.L('-'), Initial)),
mg.OPTIONAL(mg.REPEAT(Initial, mg.OPTIONAL(mg.L('-'), Initial))),
Words)
class AlternativeSeparator(modgrammar.Grammar):
grammar_whitespace_mode = 'explicit'
grammar = (modgrammar.OPTIONAL(modgrammar.WHITESPACE),
modgrammar.LITERAL("|"),
modgrammar.OPTIONAL(modgrammar.WHITESPACE))
class Publishers(mg.Grammar):
'''Parse a publisher comment.'''
grammar = (mg.OPTIONAL(WhiteSpace),
mg.L('also published'), PublisherList,
mg.L(';'))
class Reference(mg.Grammar):
'''Parse a reference comment.'''
grammar = (mg.OPTIONAL(WhiteSpace),
mg.L('reference'), AJBNum,
mg.L(';'))
class Editors(mg.Grammar):
'''Parse an editors comment.'''
grammar = (mg.OPTIONAL(WhiteSpace),
mg.L('edited by'), NameList,
mg.L(';'))
class Word3(mg.Grammar):
'''A word with & and - included.'''
# hyphenated word or abbreviations
grammar = (Word2, mg.OPTIONAL(mg.WORD("&-"), Word2))
class Other(mg.Grammar):
'''Parse an 'other' commment.'''
grammar = (mg.OPTIONAL(WhiteSpace),
mg.L('other'), Words,
mg.L(';'))
class Compilers(mg.Grammar):
'''Parse a compilers comment.'''
grammar = (mg.OPTIONAL(WhiteSpace),
mg.L('compiled by'), NameList,
mg.L(';'))
class Contributors(mg.Grammar):
'''Parse a contributors comment.'''
grammar = (mg.OPTIONAL(WhiteSpace),
mg.L('contributors'), NameList,
mg.L(';'))
class Translation(mg.Grammar):
'''Parse a translation comment.'''
grammar = (mg.OPTIONAL(WhiteSpace),
mg.L('translated'), mg.OPTIONAL(FromLanguage),
mg.OPTIONAL(ToLanguage), mg.OPTIONAL(mg.L('by'), NameList),
mg.L(';'))
class Language(mg.Grammar):
'''Parse a language comment'''
grammar = (mg.OPTIONAL(WhiteSpace),
mg.L('in'), LanguageList,
mg.OPTIONAL(mg.L('with'), Words, mg.L('references')),
mg.L(';'))
class Reprint(mg.Grammar):
'''Parse a reprint comment.'''
grammar = (mg.OPTIONAL(WhiteSpace),
mg.L('reprint of'), mg.OR(AJBNum, Year),
mg.L(';'))
