class BibTeXGrammar(Grammar):
r"""Parser for a BibTeX source file.
"""
text = Forward()
source_hash__ = "f070f9a8eaff76cdd1669dcb63d8b8f3"
disposable__ = re.compile('..(?<=^)')
static_analysis_pending__ = [] # type: List[bool]
parser_initialization__ = ["upon instantiation"]
COMMENT__ = r'(?i)%[^\n]*\n'
comment_rx__ = re.compile(COMMENT__)
WHITESPACE__ = r'\s*'
WSP_RE__ = mixin_comment(whitespace=WHITESPACE__, comment=COMMENT__)
wsp__ = Whitespace(WSP_RE__)
EOF = NegativeLookahead(RegExp('(?i).'))
WS = Alternative(Series(Lookahead(RegExp('(?i)[ \\t]*%')), wsp__), RegExp('(?i)[ \\t]+'))
ESC = Series(Lookbehind(RegExp('(?i)\\\\')), RegExp('(?i)[%&_]'))
CONTENT_STRING = OneOrMore(Alternative(RegExp('(?i)[^{}%&_ \\t]+'), ESC, WS))
COMMA_TERMINATED_STRING = ZeroOrMore(Alternative(RegExp('(?i)[^,%&_ \\t]+'), ESC, WS))
NO_BLANK_STRING = Series(OneOrMore(Alternative(RegExp('(?i)[^ \\t\\n,%&_]+'), ESC)), wsp__)
WORD = Series(RegExp('(?i)\\w+'), wsp__)
text.set(ZeroOrMore(Alternative(CONTENT_STRING, Series(Series(Text("{"), wsp__), text, Series(Text("}"), wsp__)))))
plain_content = Synonym(COMMA_TERMINATED_STRING)
content = Alternative(Series(Series(Text("{"), wsp__), text, Series(Text("}"), wsp__)), plain_content)
field = Synonym(WORD)
key = Synonym(NO_BLANK_STRING)
type = Synonym(WORD)
entry = Series(RegExp('(?i)@'), type, Series(Text("{"), wsp__), key, ZeroOrMore(Series(Series(Text(","), wsp__), field, Series(Text("="), wsp__), content, mandatory=2)), Option(Series(Text(","), wsp__)), Series(Text("}"), wsp__), mandatory=6)
comment = Series(Series(Text("@Comment{"), wsp__), text, Series(Text("}"), wsp__), mandatory=2)
pre_code = ZeroOrMore(Alternative(RegExp('(?i)[^"%]+'), RegExp('(?i)%.*\\n')))
preamble = Series(Series(Text("@Preamble{"), wsp__), RegExp('(?i)"'), pre_code, RegExp('(?i)"'), wsp__, Series(Text("}"), wsp__), mandatory=5)
bibliography = Series(ZeroOrMore(Alternative(preamble, comment, entry)), wsp__, EOF)
root__ = bibliography
class FixedEBNFGrammar(Grammar):
r"""Parser for a FixedEBNF source file.
"""
countable = Forward()
element = Forward()
expression = Forward()
source_hash__ = "8dbc09df6de2f2758e43fc351a3671c7"
disposable__ = re.compile(
'component$|pure_elem$|countable$|FOLLOW_UP$|SYM_REGEX$|ANY_SUFFIX$|EOF$'
)
static_analysis_pending__ = [] # type: List[bool]
parser_initialization__ = ["upon instantiation"]
error_messages__ = {
'definition':
[(re.compile(r','),
'Delimiter "," not expected in definition!\\nEither this was meant to be a directive and the directive symbol @ is missing\\nor the error is due to inconsistent use of the comma as a delimiter\\nfor the elements of a sequence.'
)]
}
resume_rules__ = {
'definition': [re.compile(r'\n\s*(?=@|\w+\w*\s*=)')],
'directive': [re.compile(r'\n\s*(?=@|\w+\w*\s*=)')]
}
COMMENT__ = r'(?!#x[A-Fa-f0-9])#.*(?:\n|$)|\/\*(?:.|\n)*?\*\/|\(\*(?:.|\n)*?\*\)'
comment_rx__ = re.compile(COMMENT__)
WHITESPACE__ = r'\s*'
WSP_RE__ = mixin_comment(whitespace=WHITESPACE__, comment=COMMENT__)
wsp__ = Whitespace(WSP_RE__)
dwsp__ = Drop(Whitespace(WSP_RE__))
HEXCODE = RegExp('[A-Fa-f0-9]{1,8}')
SYM_REGEX = RegExp('(?!\\d)\\w+')
RE_CORE = RegExp('(?:(?<!\\\\)\\\\(?:/)|[^/])*')
regex_heuristics = Alternative(RegExp('[^ ]'),
RegExp('[^/\\n*?+\\\\]*[*?+\\\\][^/\\n]/'))
literal_heuristics = Alternative(
RegExp('~?\\s*"(?:[\\\\]\\]|[^\\]]|[^\\\\]\\[[^"]*)*"'),
RegExp("~?\\s*'(?:[\\\\]\\]|[^\\]]|[^\\\\]\\[[^']*)*'"),
RegExp('~?\\s*`(?:[\\\\]\\]|[^\\]]|[^\\\\]\\[[^`]*)*`'),
RegExp('~?\\s*´(?:[\\\\]\\]|[^\\]]|[^\\\\]\\[[^´]*)*´'),
RegExp('~?\\s*/(?:[\\\\]\\]|[^\\]]|[^\\\\]\\[[^/]*)*/'))
char_range_heuristics = NegativeLookahead(
Alternative(
RegExp('[\\n\\t ]'), Series(dwsp__, literal_heuristics),
Series(Option(Alternative(Text("::"), Text(":?"), Text(":"))),
SYM_REGEX, RegExp('\\s*\\]'))))
CH_LEADIN = Text("0x")
RE_LEADOUT = Text("/")
RE_LEADIN = Text("/")
TIMES = Text("*")
RNG_DELIM = Text(",")
RNG_CLOSE = Text("}")
RNG_OPEN = Text("{")
ENDL = Text("")
AND = Text("")
OR = Text("|")
DEF = Text("=")
EOF = Drop(NegativeLookahead(RegExp('.')))
whitespace = Series(RegExp('~'), dwsp__)
any_char = Series(Text("."), dwsp__)
free_char = Alternative(RegExp('[^\\n\\[\\]\\\\]'),
RegExp('\\\\[nrt`´\'"(){}\\[\\]/\\\\]'))
character = Series(CH_LEADIN, HEXCODE)
char_range = Series(
Text("["), Lookahead(char_range_heuristics), Option(Text("^")),
Alternative(character, free_char),
ZeroOrMore(Alternative(Series(Option(Text("-")), character),
free_char)), Series(Text("]"), dwsp__))
regexp = Series(RE_LEADIN, RE_CORE, RE_LEADOUT, dwsp__)
plaintext = Alternative(
Series(RegExp('`(?:(?<!\\\\)\\\\`|[^`])*?`'), dwsp__),
Series(RegExp('´(?:(?<!\\\\)\\\\´|[^´])*?´'), dwsp__))
literal = Alternative(
Series(RegExp('"(?:(?<!\\\\)\\\\"|[^"])*?"'), dwsp__),
Series(RegExp("'(?:(?<!\\\\)\\\\'|[^'])*?'"), dwsp__))
symbol = Series(SYM_REGEX, dwsp__)
multiplier = Series(RegExp('[1-9]\\d*'), dwsp__)
no_range = Alternative(NegativeLookahead(multiplier),
Series(Lookahead(multiplier), TIMES))
range = Series(RNG_OPEN, dwsp__, multiplier,
Option(Series(RNG_DELIM, dwsp__, multiplier)), RNG_CLOSE,
dwsp__)
counted = Alternative(
Series(countable, range), Series(countable, TIMES, dwsp__, multiplier),
Series(multiplier, TIMES, dwsp__, countable, mandatory=3))
option = Alternative(
Series(Series(Text("["), dwsp__),
expression,
Series(Text("]"), dwsp__),
mandatory=1), Series(element, Series(Text("?"), dwsp__)))
repetition = Alternative(
Series(Series(Text("{"), dwsp__),
no_range,
expression,
Series(Text("}"), dwsp__),
mandatory=2),
Series(element, Series(Text("*"), dwsp__), no_range))
oneormore = Alternative(
Series(Series(Text("{"), dwsp__), no_range, expression,
Series(Text("}+"), dwsp__)),
Series(element, Series(Text("+"), dwsp__)))
group = Series(Series(Text("("), dwsp__),
no_range,
expression,
Series(Text(")"), dwsp__),
mandatory=2)
retrieveop = Alternative(Series(Text("::"), dwsp__),
Series(Text(":?"), dwsp__),
Series(Text(":"), dwsp__))
flowmarker = Alternative(Series(Text("!"), dwsp__),
Series(Text("&"), dwsp__),
Series(Text("<-!"), dwsp__),
Series(Text("<-&"), dwsp__))
ANY_SUFFIX = RegExp('[?*+]')
literals = OneOrMore(literal)
pure_elem = Series(element, NegativeLookahead(ANY_SUFFIX), mandatory=1)
procedure = Series(SYM_REGEX, Series(Text("()"), dwsp__))
term = Alternative(oneormore, counted, repetition, option, pure_elem)
difference = Series(
term,
Option(
Series(Series(Text("-"), dwsp__),
Alternative(oneormore, pure_elem),
mandatory=1)))
lookaround = Series(flowmarker,
Alternative(oneormore, pure_elem),
mandatory=1)
interleave = Series(
difference,
ZeroOrMore(
Series(Series(Text("°"), dwsp__),
Option(Series(Text("§"), dwsp__)), difference)))
sequence = Series(
Option(Series(Text("§"), dwsp__)), Alternative(interleave, lookaround),
ZeroOrMore(
Series(AND, dwsp__, Option(Series(Text("§"), dwsp__)),
Alternative(interleave, lookaround))))
FOLLOW_UP = Alternative(Text("@"), symbol, EOF)
definition = Series(symbol,
DEF,
dwsp__,
Option(Series(OR, dwsp__)),
expression,
ENDL,
dwsp__,
Lookahead(FOLLOW_UP),
mandatory=1)
component = Alternative(regexp, literals, procedure,
Series(symbol, NegativeLookahead(DEF)))
directive = Series(Series(Text("@"), dwsp__),
symbol,
Series(Text("="), dwsp__),
component,
ZeroOrMore(Series(Series(Text(","), dwsp__),
component)),
Lookahead(FOLLOW_UP),
mandatory=1)
element.set(
Alternative(Series(Option(retrieveop), symbol,
NegativeLookahead(DEF)), literal, plaintext, regexp,
Series(character, dwsp__), any_char, whitespace, group))
countable.set(Alternative(option, oneormore, element))
expression.set(Series(sequence, ZeroOrMore(Series(OR, dwsp__, sequence))))
syntax = Series(dwsp__, ZeroOrMore(Alternative(definition, directive)),
EOF)
root__ = syntax
class LaTeXGrammar(Grammar):
r"""Parser for a LaTeX source file.
"""
_block_environment = Forward()
_text_element = Forward()
block = Forward()
paragraph = Forward()
param_block = Forward()
tabular_config = Forward()
source_hash__ = "d443c74c1540aca5ee7ed767a0da896e"
disposable__ = re.compile('_\\w+')
static_analysis_pending__ = [] # type: List[bool]
parser_initialization__ = ["upon instantiation"]
error_messages__ = {
'end_generic_block':
[(re.compile(r'(?=)'),
"A block environment must be followed by a linefeed, not by: {1}")],
'item':
[(re.compile(r'(?=)'), '\\item without proper content, found: {1}')]
}
COMMENT__ = r'%.*'
comment_rx__ = re.compile(COMMENT__)
comment__ = RegExp(comment_rx__)
WHITESPACE__ = r'[ \t]*(?:\n(?![ \t]*\n)[ \t]*)?'
whitespace__ = Whitespace(WHITESPACE__)
WSP_RE__ = mixin_comment(whitespace=WHITESPACE__, comment=COMMENT__)
wsp__ = Whitespace(WSP_RE__)
dwsp__ = Drop(Whitespace(WSP_RE__))
EOF = RegExp('(?!.)')
_BACKSLASH = Drop(RegExp('[\\\\]'))
_LB = Drop(RegExp('\\s*?\\n|$'))
NEW_LINE = Series(Drop(RegExp('[ \\t]*')), Option(comment__),
Drop(RegExp('\\n')))
_GAP = Drop(Series(RegExp('[ \\t]*(?:\\n[ \\t]*)+\\n'), dwsp__))
_WSPC = Drop(OneOrMore(Drop(Alternative(comment__, Drop(RegExp('\\s+'))))))
_PARSEP = Drop(
Series(Drop(ZeroOrMore(Drop(Series(whitespace__, comment__)))), _GAP,
Drop(Option(_WSPC))))
S = Series(Lookahead(Drop(RegExp('[% \\t\\n]'))), NegativeLookahead(_GAP),
wsp__)
LFF = Alternative(Series(NEW_LINE, Option(_WSPC)), EOF)
_LETTERS = RegExp('\\w+')
CHARS = RegExp('[^\\\\%$&\\{\\}\\[\\]\\s\\n\'`"]+')
_TEXT_NOPAR = RegExp(
'(?:[^\\\\%$&\\{\\}\\[\\]\\(\\)\\n]+(?:\\n(?![ \\t]*\\n))?)+')
_TEXT = RegExp('(?:[^\\\\%$&\\{\\}\\[\\]\\n\'`"]+(?:\\n(?![ \\t]*\\n))?)+')
_TAG = RegExp('[\\w=?.:\\-%&\\[\\] /]+')
_COLON = Text(":")
_HASH = Text("#")
_PATHSEP = RegExp('/(?!\\*)')
_PATH = RegExp('[\\w=~?.,%&\\[\\]-]+')
UNIT = RegExp('(?!\\d)\\w+')
_FRAC = RegExp('\\.[0-9]+')
_INTEGER = RegExp('-?(?:(?:[1-9][0-9]+)|[0-9])')
_NAME = RegExp('(?!\\d)\\w+\\*?')
NAME = Capture(Synonym(_NAME))
IDENTIFIER = Synonym(_NAME)
_QUALIFIED = Series(
IDENTIFIER,
ZeroOrMore(
Series(NegativeLookbehind(_BACKSLASH), Drop(RegExp('[:.-]')),
IDENTIFIER)))
LINEFEED = RegExp('[\\\\][\\\\]')
BRACKETS = RegExp('[\\[\\]]')
SPECIAL = RegExp('[$&_/\\\\\\\\]')
QUOTEMARK = RegExp('"[`\']?|``?|\'\'?')
UMLAUT = RegExp(
'\\\\(?:(?:"[AOUaou])|(?:\'[aeiou])|(?:`[aeiou])|(?:[\\^][aeiou]))')
ESCAPED = RegExp('\\\\(?:(?:[#%$&_/{} \\n])|(?:~\\{\\s*\\}))')
TXTCOMMAND = RegExp('\\\\text\\w+')
CMDNAME = Series(RegExp('\\\\@?(?:(?![\\d_])\\w)+'), dwsp__)
WARN_Komma = Series(Text(","), dwsp__)
esc_char = Text(",")
number = Series(_INTEGER, Option(_FRAC))
magnitude = Series(number, Option(UNIT))
info_value = Series(_TEXT_NOPAR, ZeroOrMore(Series(S, _TEXT_NOPAR)))
info_key = Series(Drop(Text("/")), _NAME)
info_assoc = Series(
info_key, dwsp__,
Option(
Series(Series(Drop(Text("(")), dwsp__),
info_value,
Series(Drop(Text(")")), dwsp__),
mandatory=1)))
_info_block = Series(Series(Drop(Text("{")), dwsp__),
ZeroOrMore(info_assoc),
Series(Drop(Text("}")), dwsp__),
mandatory=1)
value = Alternative(magnitude, _LETTERS, CMDNAME, param_block, block)
key = Synonym(_QUALIFIED)
flag = Alternative(_QUALIFIED, magnitude)
association = Series(key, dwsp__, Series(Drop(Text("=")), dwsp__), value,
dwsp__)
parameters = Series(
Alternative(association, flag),
ZeroOrMore(
Series(NegativeLookbehind(_BACKSLASH),
Series(Drop(Text(",")), dwsp__),
Alternative(association, flag))), Option(WARN_Komma))
sequence = Series(
Option(_WSPC),
OneOrMore(
Series(Alternative(paragraph, _block_environment),
Option(Alternative(_PARSEP, S)))))
block_of_paragraphs = Series(Series(Drop(Text("{")), dwsp__),
Option(sequence),
Series(Drop(Text("}")), dwsp__),
mandatory=2)
special = Alternative(Drop(Text("\\-")),
Series(Drop(RegExp('\\\\')), esc_char), UMLAUT,
QUOTEMARK)
_structure_name = Drop(
Alternative(Drop(Text("subsection")), Drop(Text("section")),
Drop(Text("chapter")), Drop(Text("subsubsection")),
Drop(Text("paragraph")), Drop(Text("subparagraph")),
Drop(Text("item"))))
_env_name = Drop(
Alternative(
Drop(Text("enumerate")), Drop(Text("itemize")),
Drop(Text("description")),
Drop(Text("figure")), Drop(Text("quote")), Drop(Text("quotation")),
Drop(Text("tabular")),
Drop(
Series(Drop(Text("displaymath")),
Drop(Option(Drop(Text("*")))))),
Drop(Series(Drop(Text("equation")),
Drop(Option(Drop(Text("*")))))),
Drop(Series(Drop(Text("eqnarray")),
Drop(Option(Drop(Text("*"))))))))
blockcmd = Series(
_BACKSLASH,
Alternative(
Series(
Alternative(Series(Drop(Text("begin{")), dwsp__),
Series(Drop(Text("end{")), dwsp__)), _env_name,
Series(Drop(Text("}")), dwsp__)),
Series(_structure_name, Lookahead(Drop(Text("{")))),
Drop(Text("[")), Drop(Text("]"))))
no_command = Alternative(
Series(Drop(Text("\\begin{")), dwsp__),
Series(Drop(Text("\\end{")), dwsp__),
Series(_BACKSLASH, _structure_name, Lookahead(Drop(Text("{")))))
text = Series(
OneOrMore(Alternative(_TEXT, special)),
ZeroOrMore(Series(S, OneOrMore(Alternative(_TEXT, special)))))
cfg_text = ZeroOrMore(
Alternative(Series(dwsp__, text), CMDNAME, SPECIAL, block))
config = Series(Series(Drop(Text("[")), dwsp__),
Alternative(
Series(parameters,
Lookahead(Series(Drop(Text("]")), dwsp__))),
cfg_text),
Series(Drop(Text("]")), dwsp__),
mandatory=1)
item = Series(Series(Drop(Text("\\item")), dwsp__),
Option(config),
sequence,
mandatory=2)
_block_content = Series(
Option(Alternative(_PARSEP, S)),
ZeroOrMore(
Series(Alternative(_block_environment, _text_element, paragraph),
Option(Alternative(_PARSEP, S)))))
heading = Synonym(block)
_pth = OneOrMore(Alternative(_PATH, ESCAPED))
target = Series(
_pth,
ZeroOrMore(
Series(NegativeLookbehind(Drop(RegExp('s?ptth'))), _COLON, _pth)),
Option(
Series(
Alternative(
Series(Option(_BACKSLASH), _HASH),
Series(NegativeLookbehind(Drop(RegExp('s?ptth'))),
_COLON)), _TAG)))
path = Series(_pth, _PATHSEP)
protocol = RegExp('\\w+://(?!\\*)')
urlstring = Series(Option(protocol), ZeroOrMore(path), Option(target))
href = Series(Series(Drop(Text("\\href{")), dwsp__), urlstring,
Series(Drop(Text("}")), dwsp__), block)
url = Series(Series(Drop(Text("\\url{")), dwsp__), urlstring,
Series(Drop(Text("}")), dwsp__))
ref = Series(
Alternative(Series(Drop(Text("\\ref{")), dwsp__),
Series(Drop(Text("\\pageref{")), dwsp__)), CHARS,
Series(Drop(Text("}")), dwsp__))
label = Series(Series(Drop(Text("\\label{")), dwsp__), CHARS,
Series(Drop(Text("}")), dwsp__))
hypersetup = Series(Series(Drop(Text("\\hypersetup")), dwsp__),
param_block)
pdfinfo = Series(Series(Drop(Text("\\pdfinfo")), dwsp__), _info_block)
documentclass = Series(Series(Drop(Text("\\documentclass")), dwsp__),
Option(config), block)
column_nr = Synonym(_INTEGER)
cline = Series(Series(Drop(Text("\\cline{")), dwsp__), column_nr,
Series(Drop(Text("-")), dwsp__), column_nr,
Series(Drop(Text("}")), dwsp__))
hline = Series(Text("\\hline"), dwsp__)
multicolumn = Series(Series(Drop(Text("\\multicolumn")), dwsp__),
Series(Drop(Text("{")), dwsp__), column_nr,
Series(Drop(Text("}")), dwsp__), tabular_config,
block_of_paragraphs)
caption = Series(Series(Drop(Text("\\caption")), dwsp__), block)
includegraphics = Series(Series(Drop(Text("\\includegraphics")), dwsp__),
Option(config), block)
footnote = Series(Series(Drop(Text("\\footnote")), dwsp__),
block_of_paragraphs)
citep = Series(
Alternative(Series(Drop(Text("\\citep")), dwsp__),
Series(Drop(Text("\\cite")), dwsp__)), Option(config),
block)
citet = Series(Series(Drop(Text("\\citet")), dwsp__), Option(config),
block)
generic_command = Alternative(
Series(NegativeLookahead(no_command), CMDNAME,
ZeroOrMore(Series(dwsp__, Alternative(config, block)))),
Series(Drop(Text("{")),
CMDNAME,
_block_content,
Drop(Text("}")),
mandatory=3))
assignment = Series(
NegativeLookahead(no_command), CMDNAME, Series(Drop(Text("=")),
dwsp__),
Alternative(Series(number, Option(UNIT)), block, CHARS))
text_command = Alternative(TXTCOMMAND, ESCAPED, BRACKETS)
_known_command = Alternative(citet, citep, footnote, includegraphics,
caption, multicolumn, hline, cline,
documentclass, pdfinfo, hypersetup, label,
ref, href, url, item)
_command = Alternative(_known_command, text_command, assignment,
generic_command)
_inline_math_text = RegExp('[^$]*')
_im_bracket = Series(Drop(Text("\\(")),
_inline_math_text,
Drop(Text("\\)")),
mandatory=1)
_im_dollar = Series(Drop(Text("$")),
_inline_math_text,
Drop(Text("$")),
mandatory=1)
inline_math = Alternative(_im_dollar, _im_bracket)
end_environment = Series(Drop(RegExp('\\\\end{')),
Pop(NAME),
Drop(RegExp('}')),
mandatory=1)
begin_environment = Series(Drop(RegExp('\\\\begin{')),
NAME,
Drop(RegExp('}')),
mandatory=1)
_end_inline_env = Synonym(end_environment)
_begin_inline_env = Alternative(
Series(NegativeLookbehind(_LB), begin_environment),
Series(begin_environment, NegativeLookahead(LFF)))
generic_inline_env = Series(_begin_inline_env,
dwsp__,
paragraph,
NegativeLookahead(_PARSEP),
_end_inline_env,
mandatory=4)
_known_inline_env = Synonym(inline_math)
_inline_environment = Alternative(_known_inline_env, generic_inline_env)
_line_element = Alternative(text, _inline_environment, _command, block)
SubParagraph = Series(Series(Drop(Text("\\subparagraph")), dwsp__),
heading, Option(sequence))
hide_from_toc = Series(Text("*"), dwsp__)
SubParagraphs = OneOrMore(Series(Option(_WSPC), SubParagraph))
Paragraph = Series(Series(Drop(Text("\\paragraph")), dwsp__), heading,
ZeroOrMore(Alternative(sequence, SubParagraphs)))
cfg_separator = Alternative(Drop(Text("|")),
Series(Drop(Text("!")), block))
cfg_unit = Series(Drop(Text("{")), number, UNIT, Drop(Text("}")))
cfg_celltype = RegExp('[lcrp]')
frontpages = Synonym(sequence)
rb_down = Series(Series(Drop(Text("[")), dwsp__), number, UNIT, dwsp__,
Series(Drop(Text("]")), dwsp__))
rb_up = Series(Series(Drop(Text("[")), dwsp__), number, UNIT, dwsp__,
Series(Drop(Text("]")), dwsp__))
rb_offset = Series(Series(Drop(Text("{")), dwsp__), number, UNIT, dwsp__,
Series(Drop(Text("}")), dwsp__))
raisebox = Series(Series(Drop(Text("\\raisebox")), dwsp__), rb_offset,
Option(rb_up), Option(rb_down), block)
tabular_cell = Alternative(
Series(raisebox, Option(Alternative(S, _PARSEP))),
ZeroOrMore(Series(_line_element, Option(Alternative(S, _PARSEP)))))
tabular_row = Series(
Alternative(multicolumn, tabular_cell),
ZeroOrMore(
Series(Series(Drop(Text("&")), dwsp__),
Alternative(multicolumn, tabular_cell))),
Alternative(
Series(Series(Drop(Text("\\\\")), dwsp__),
Alternative(hline, ZeroOrMore(cline)), Option(_PARSEP)),
Lookahead(Drop(Text("\\end{tabular}")))))
tabular = Series(Series(Drop(Text("\\begin{tabular}")), dwsp__),
tabular_config,
ZeroOrMore(Alternative(tabular_row, _WSPC)),
Series(Drop(Text("\\end{tabular}")), dwsp__),
mandatory=3)
no_numbering = Text("*")
_block_math = RegExp(
'(?:[^\\\\]*[\\\\]?(?!end\\{(?:eqnarray|equation|displaymath)\\*?\\}|\\])\\s*)*'
)
eqnarray = Series(Drop(Text("\\begin{eqnarray")),
Option(no_numbering),
Series(Drop(Text("}")), dwsp__),
_block_math,
Drop(Text("\\end{eqnarray")),
Option(Drop(Text("*"))),
Series(Drop(Text("}")), dwsp__),
mandatory=3)
equation = Series(Drop(Text("\\begin{equation")),
Option(no_numbering),
Series(Drop(Text("}")), dwsp__),
_block_math,
Drop(Text("\\end{equation")),
Option(Drop(Text("*"))),
Series(Drop(Text("}")), dwsp__),
mandatory=3)
_dmath_short_form = Series(Series(Drop(Text("\\[")), dwsp__),
_block_math,
Series(Drop(Text("\\]")), dwsp__),
mandatory=1)
_dmath_long_form = Series(Drop(Text("\\begin{displaymath")),
Option(no_numbering),
Series(Drop(Text("}")), dwsp__),
_block_math,
Drop(Text("\\end{displaymath")),
Option(Drop(Text("*"))),
Series(Drop(Text("}")), dwsp__),
mandatory=3)
displaymath = Alternative(_dmath_long_form, _dmath_short_form)
verbatim_text = RegExp('(?:(?!\\\\end{verbatim})[\\\\]?[^\\\\]*)*')
verbatim = Series(Series(Drop(Text("\\begin{verbatim}")), dwsp__),
verbatim_text,
Series(Drop(Text("\\end{verbatim}")), dwsp__),
mandatory=2)
quotation = Alternative(
Series(Series(Drop(Text("\\begin{quotation}")), dwsp__),
sequence,
Series(Drop(Text("\\end{quotation}")), dwsp__),
mandatory=2),
Series(Series(Drop(Text("\\begin{quote}")), dwsp__),
sequence,
Series(Drop(Text("\\end{quote}")), dwsp__),
mandatory=2))
figure = Series(Series(Drop(Text("\\begin{figure}")), dwsp__),
sequence,
Series(Drop(Text("\\end{figure}")), dwsp__),
mandatory=2)
Paragraphs = OneOrMore(Series(Option(_WSPC), Paragraph))
_itemsequence = Series(
Option(_WSPC),
ZeroOrMore(Series(Alternative(item, _command), Option(_WSPC))))
description = Series(Series(Drop(Text("\\begin{description}")), dwsp__),
_itemsequence,
Series(Drop(Text("\\end{description}")), dwsp__),
mandatory=2)
enumerate = Series(Series(Drop(Text("\\begin{enumerate}")), dwsp__),
_itemsequence,
Series(Drop(Text("\\end{enumerate}")), dwsp__),
mandatory=2)
itemize = Series(Series(Drop(Text("\\begin{itemize}")), dwsp__),
_itemsequence,
Series(Drop(Text("\\end{itemize}")), dwsp__),
mandatory=2)
end_generic_block = Series(end_environment,
Alternative(
LFF,
Series(dwsp__, Lookahead(Drop(Text("}"))))),
mandatory=1)
begin_generic_block = Series(Lookbehind(_LB), begin_environment)
generic_block = Series(begin_generic_block,
ZeroOrMore(Alternative(sequence, item)),
end_generic_block,
mandatory=2)
math_block = Alternative(equation, eqnarray, displaymath)
_known_environment = Alternative(itemize, enumerate, description, figure,
tabular, quotation, verbatim, math_block)
_has_block_start = Drop(
Alternative(Drop(Text("\\begin{")), Drop(Text("\\["))))
preamble = OneOrMore(Series(Option(_WSPC), _command))
SubSubSection = Series(Drop(Text("\\subsubsection")),
Option(hide_from_toc), heading,
ZeroOrMore(Alternative(sequence, Paragraphs)))
Index = Series(Option(_WSPC), Series(Drop(Text("\\printindex")), dwsp__))
Bibliography = Series(Option(_WSPC),
Series(Drop(Text("\\bibliography")), dwsp__),
heading)
SubSubSections = OneOrMore(Series(Option(_WSPC), SubSubSection))
SubSection = Series(
Drop(Text("\\subsection")), Option(hide_from_toc), heading,
ZeroOrMore(Alternative(sequence, SubSubSections, Paragraphs)))
SubSections = OneOrMore(Series(Option(_WSPC), SubSection))
Section = Series(
Drop(Text("\\section")), Option(hide_from_toc), heading,
ZeroOrMore(Alternative(sequence, SubSections, Paragraphs)))
Sections = OneOrMore(Series(Option(_WSPC), Section))
Chapter = Series(Drop(Text("\\chapter")), Option(hide_from_toc), heading,
ZeroOrMore(Alternative(sequence, Sections, Paragraphs)))
Chapters = OneOrMore(Series(Option(_WSPC), Chapter))
document = Series(Option(_WSPC),
Series(Drop(Text("\\begin{document}")), dwsp__),
frontpages,
Alternative(Chapters, Sections),
Option(Bibliography),
Option(Index),
Option(_WSPC),
Series(Drop(Text("\\end{document}")), dwsp__),
Option(_WSPC),
EOF,
mandatory=2)
param_block.set(
Series(Series(Drop(Text("{")), dwsp__), Option(parameters),
Series(Drop(Text("}")), dwsp__)))
block.set(
Series(Series(Drop(Text("{")), dwsp__),
_block_content,
Drop(Text("}")),
mandatory=2))
_text_element.set(Alternative(_line_element, LINEFEED))
paragraph.set(
OneOrMore(Series(NegativeLookahead(blockcmd), _text_element,
Option(S))))
tabular_config.set(
Series(Series(Drop(Text("{")), dwsp__),
OneOrMore(
Alternative(Series(cfg_celltype, Option(cfg_unit)),
cfg_separator, Drop(RegExp(' +')))),
Series(Drop(Text("}")), dwsp__),
mandatory=2))
_block_environment.set(
Alternative(Series(Lookahead(_has_block_start), _known_environment),
generic_block))
latexdoc = Series(preamble, document, mandatory=1)
root__ = TreeReduction(latexdoc, CombinedParser.MERGE_TREETOPS)
class json_fail_tolerantGrammar(Grammar):
r"""Parser for a json_fail_tolerant source file.
"""
_element = Forward()
source_hash__ = "42cb00a4f8192986733859d4709c5b37"
disposable__ = re.compile('..(?<=^)')
static_analysis_pending__ = [] # type: List[bool]
parser_initialization__ = ["upon instantiation"]
error_messages__ = {
'member':
[(re.compile(r'[\'`´]'),
'String values must be enclosed by double-quotation marks: "..."!')],
'string':
[(re.compile(r'\\'),
'Illegal escape sequence "{1}" Allowed values are \\\\/, \\\\\\\\, \\\\b, \\\\n, \\\\r, \\\\t, or \\\\u.'
), (re.compile(r'(?=)'), 'Illegal character "{1}" in string.')],
'_OBJECT_SEPARATOR': [(re.compile(r'(?!,)'), 'Missing separator ","')],
'_ARRAY_SEPARATOR': [(re.compile(r'(?!,)'), 'Missing separator ","')]
}
skip_rules__ = {'string': [re.compile(r'(?=")')]}
resume_rules__ = {
'object': [re.compile(r'(?:[^{}]|(?:\{.*\}))*\}\s*')],
'array': [re.compile(r'(?:[^\[\]]|(?:\[.*\]))*\]\s*')],
'member': [re.compile(r'(?=(?:"[^"\n]+"\s*:)|\}|,)')],
'_OBJECT_SEPARATOR': [re.compile(r'(?=)')],
'_ARRAY_SEPARATOR': [re.compile(r'(?=)')]
}
COMMENT__ = r'(?:\/\/|#).*'
comment_rx__ = re.compile(COMMENT__)
WHITESPACE__ = r'\s*'
WSP_RE__ = mixin_comment(whitespace=WHITESPACE__, comment=COMMENT__)
wsp__ = Whitespace(WSP_RE__)
dwsp__ = Drop(Whitespace(WSP_RE__))
_ARRAY_SEPARATOR = Series(NegativeLookahead(Text("]")),
Lookahead(Text(",")),
Option(Series(Drop(Text(",")), dwsp__)),
mandatory=1)
_OBJECT_SEPARATOR = Series(NegativeLookahead(Text("}")),
Lookahead(Text(",")),
Option(Series(Drop(Text(",")), dwsp__)),
mandatory=1)
_EOF = NegativeLookahead(RegExp('.'))
EXP = Option(
Series(Alternative(Text("E"), Text("e")),
Option(Alternative(Text("+"), Text("-"))), RegExp('[0-9]+')))
DOT = Text(".")
FRAC = Option(Series(DOT, RegExp('[0-9]+')))
NEG = Text("-")
INT = Series(Option(NEG),
Alternative(RegExp('[0-9]'), RegExp('[1-9][0-9]+')))
HEX = RegExp('[0-9a-fA-F][0-9a-fA-F]')
UNICODE = Series(Series(Drop(Text("\\u")), dwsp__), HEX, HEX)
ESCAPE = Alternative(RegExp('\\\\[/bnrt\\\\]'), UNICODE)
PLAIN = RegExp('[^"\\\\]+')
_CHARACTERS = ZeroOrMore(Alternative(PLAIN, ESCAPE))
null = Series(Text("null"), dwsp__)
bool = Alternative(Series(RegExp('true'), dwsp__),
Series(RegExp('false'), dwsp__))
number = Series(INT, FRAC, EXP, dwsp__)
string = Series(Text('"'), _CHARACTERS, Text('"'), dwsp__, mandatory=1)
array = Series(
Series(Drop(Text("[")), dwsp__),
Option(
Series(_element,
ZeroOrMore(Series(_ARRAY_SEPARATOR, _element,
mandatory=1)))),
Series(Drop(Text("]")), dwsp__))
member = Series(string,
Series(Drop(Text(":")), dwsp__),
_element,
mandatory=1)
object = Series(Series(Drop(Text("{")), dwsp__),
member,
ZeroOrMore(Series(_OBJECT_SEPARATOR, member, mandatory=1)),
Series(Drop(Text("}")), dwsp__),
mandatory=3)
_element.set(Alternative(object, array, string, number, bool, null))
json = Series(dwsp__, _element, _EOF)
root__ = json