def number(self, value, buffer_):
# value = (tag, left, right, taglist)
if value[3][0][0] == 'int':
return int(getString(value, buffer_))
elif value[3][0][0] == 'float':
return float(getString(value, buffer_))
else:
return getString(value, buffer_)
def comment_entry(self, tuple4, buffer):
"""Process the given production and it's children"""
(tag, start, stop, subtags) = tuple4
the_type = getString(subtags[0], buffer)
lineno = spdp.lines(0, start, buffer) + 1
if the_type.upper() != 'COMMENT':
bibfile_logger.warning("""Entry at line %d has comment syntax
but entry_type is %s:
Details: %s""" % (lineno, the_type, getString(subtags[1], buffer)))
else:
bibfile_logger.info("Comment entry on line %d:" % lineno + " " +
getString(subtags[1], buffer))
def define_stmt(self, token, buffer):
tag, left, right, sublist = token
name_tup, value_tup = sublist
value_tag = value_tup[0]
name = getString(name_tup, buffer)
value = getString(value_tup, buffer)
if value_tag == 'regex':
value = self._regex(value_tup, buffer)
elif value_tag == 'varname':
if value not in self.context.lexicon:
_error(buffer, value_tup[1], 'no such variable')
value = self.context.lexicon[value]
else:
raise Exception('BUG: invalid token %s' % value_tag)
self.context.lexicon[name] = value
def define_stmt(self, token, buffer):
tag, left, right, sublist = token
name_tup, value_tup = sublist
value_tag = value_tup[0]
name = getString(name_tup, buffer)
value = getString(value_tup, buffer)
if value_tag == 'regex':
value = self._regex(value_tup, buffer)
elif value_tag == 'varname':
if value not in self.context.lexicon:
_error(buffer, value_tup[1], 'no such variable')
value = self.context.lexicon[value]
else:
raise Exception('BUG: invalid token %s' % value_tag)
self.context.lexicon[name] = value
def alphanums(self, tags, buffer):
"""
>>> input = "foo"
>>> proc = ProcessessExpression()
>>> proc(parse('alphanums', input), input)
'foo'
"""
return getString(tags, buffer)
def alphanums(self, tags, buffer):
"""
>>> input = "foo"
>>> proc = ProcessessExpression()
>>> proc(parse('alphanums', input), input)
'foo'
"""
return getString(tags, buffer)
def grammar_stmt(self, token, buffer):
tag, left, right, sublist = token
map = singleMap(sublist)
grammar = Grammar()
grammar.name = getString(map['varname'], buffer)
grammar.statements = self._suite(map['suite'], buffer)
if 'inherit' in map:
grammar.inherit = self._inherit(map['inherit'], buffer)
self.context.grammars[grammar.name] = grammar
def grammar_stmt(self, token, buffer):
tag, left, right, sublist = token
map = singleMap(sublist)
grammar = Grammar()
grammar.name = getString(map['varname'], buffer)
grammar.statements = self._suite(map['suite'], buffer)
if 'inherit' in map:
grammar.inherit = self._inherit(map['inherit'], buffer)
self.context.grammars[grammar.name] = grammar
def _function(self, token, buffer):
tag, left, right, sublist = token
function = Function()
function.name = getString(sublist[0], buffer)
if len(sublist) == 1:
return function
for arg in sublist[1][3]:
expression = self._expression(arg, buffer)
function.args.append(expression)
return function
def _function(self, token, buffer):
tag, left, right, sublist = token
function = Function()
function.name = getString(sublist[0], buffer)
if len(sublist) == 1:
return function
for arg in sublist[1][3]:
expression = self._expression(arg, buffer)
function.args.append(expression)
return function
def preamble(self, tuple4, buffer):
"""Process the given production and it's children"""
(tag, start, stop, subtags) = tuple4
the_type = getString(subtags[0], buffer)
lineno = lines(0, start, buffer) + 1
if the_type.upper() != 'PREAMBLE':
bibfile_logger.warning(
"Entry at line %d has preamble syntax but entry_type is %s" %
(lineno, the_type))
else:
bibfile_logger.warning("Preamble entry on line %d:" % lineno +
"\n" + buffer[start:stop])
def inline_parameter_value(self, value, buffer_):
# value = (tag, left, right, taglist)
if value[3][0][0] == "qstring":
return getString(value, buffer_).strip(' \t\n\r\f"')
_av = dispatchList(self, value[3], buffer_)
# if list of attribute values contains only one entry reduce it
# to scalar value. Otherwise # insert the string "<!?c?!>" which
# will be used by the # AmiraHeader._load_parameters function to
# distinguisch between a list of constant parameter values and a
# list of sub parameters
if len(_av) == 1:
return _av[0]
return ['<!?c?!>'] + _av
class SyntaxCompiler(DispatchProcessor):
"""
Processor sub-class defining processing functions for the productions.
"""
def __init__(self):
self.context = None
def reset(self):
self.context = Context()
def _regex(self, (tag, left, right, sublist), buffer):
regex = Regex()
regex.data = getString(sublist[0], buffer)
return regex
class Part21Processor(dp.DispatchProcessor):
"""
Processing object for postprocessing the Part 21 grammar definitions into a
new generator.
"""
def __init__(self, res):
self.res = res
# TODO: set this up as a sqlite database
# contents: maps entity inst nbr (n) to unparsed content
# insttype: maps entity inst nbr (n) to KEYWORD (i.e. type)
# insttype: maps KEYWORD (i.e. type) (n) to entity inst nbr
self.res['contents'] = {}
self.res['insttype'] = {}
self.res['typeinst'] = defaultdict(list)
def ENTITY_INSTANCE_NAME(self, (tag, start, stop, subtags), buffer):
"""
Process C{ENTITY_INSTANCE_NAME} production.
"""
return dp.getString((tag, start, stop, subtags), buffer)[1:]
def filetype(self, value, buffer_):
# value = (tag, left, right, taglist)
return getString(value, buffer_)
def infoString(self, tup, buffer):
subTree = multiMap(tup[-1], buffer=buffer)
jahr = dispatchList(self, subTree['semester'], buffer)[0]
infoString = str(getString(tup, buffer))
return (infoString, jahr)
def gruppenKuerzel(self, tup, buffer):
return str(getString(tup, buffer))
def dozent(self, tup, buffer):
return str(getString(tup, buffer))
def raum(self, tup, buffer):
return str(getString(tup, buffer))
def amount(self, *a, **kw):
return int(disp.getString(*a, **kw))
def fach(self, tup, buffer):
subTree = multiMap(tup[-1], buffer=buffer)
gruppenKuerzel = dispatchList(self, subTree['gruppe'], buffer)[0]
fach = str(getString(tup, buffer))
return gruppenKuerzel, fach
def alphanumGruppe(self, tup, buffer):
return getString(tup, buffer)
def oe2(self, tup, buffer):
return getString(tup, buffer)
def no(self, tup, buffer):
return getString(tup, buffer)
def gruppe(self, tup, buffer):
return str(int(getString(tup, buffer)))
def nummer(self, tup, buffer):
return getString(tup, buffer)
def fachKuerzel(self, tup, buffer):
return getString(tup, buffer)
def prakKuerzel(self, tup, buffer):
return getString(tup, buffer)
def semesterkuerzel(self, tup, buffer):
return getString(tup, buffer)
def verbKuerzel(self, tup, buffer):
return getString(tup, buffer)
class Processor(disp.DispatchProcessor):
def armorclassStat(self, (t,s1,s2,sub), buffer):
self.armorclass = ArmorClass()
disp.dispatchList(self, sub, buffer)
return self.armorclass
def splat(self, *a, **kw):
if self.armorclass.qualifier is None:
self.armorclass.qualifier = ''
self.armorclass.qualifier += '*'
def qualifier(self, (t,s1,s2,sub), buffer):
if self.armorclass.qualifier is None:
self.armorclass.qualifier = ''
self.armorclass.qualifier += disp.getString((t,s1+1, s2-1, sub),
buffer)
def total(self, *a, **kw):
self.armorclass.value = int(disp.getString(*a, **kw))
def size(self, (t,s1,s2,sub), buffer):
self.armorclass.size = disp.dispatchList(self, sub, buffer)[0]
def dex(self, (t,s1,s2,sub), buffer):
self.armorclass.dexBonus = disp.dispatchList(self, sub, buffer)[0]
def flatFooted(self, (t,s1,s2,sub), buffer):
s = disp.getString((t,s1,s2,sub), buffer)
self.armorclass.flatFooted = int(s.split()[-1])
def touch(self, (t,s1,s2,sub), buffer):
def _regex(self, token, buffer):
tag, left, right, sublist = token
regex = Regex()
regex.data = getString(sublist[0], buffer)
return regex
def total(self, *a, **kw):
self.armorclass.value = int(disp.getString(*a, **kw))
def _varname(self, token, buffer):
varname = getString(token, buffer)
return self.context.lexicon[varname]
def gruppe(self, tup, buffer):
return getString(tup, buffer)
"""PRODUCTION FUNCTIONS: for parsing, must provide a function for each production name. """ def string(self, (tag,start,stop,subtags), buffer ): """Return a string, stripping leading and trailing markers""" return buffer[start+1:stop-1] def number(self, (tag,start,stop,subtags), buffer ): """return a number as a string""" return buffer[start:stop] def entry_type( self, (tag,start,stop,subtags), buffer ): """Return the entry type""" return getString((tag,start,stop,subtags), buffer) def key( self, (tag,start,stop,subtags), buffer ): """Return the entry key""" return getString((tag,start,stop,subtags), buffer) # macro name def name(self, (tag,start,stop,subtags), buffer ): """Return lookup on name or name if not in map.""" return self._macroMap.get(buffer[start:stop],buffer[start:stop]) def field(self, (tag,start,stop,subtags), buffer ): """Process a bibentry field and return tuple of name, value.""" str = '' for t in subtags[1][3]: if(t) :
def gebaeude(self, tup, buffer):
return str(getString(tup, buffer))
def extra_format(self, value, buffer_):
# value = (tag, left, right, taglist)
return getString(value, buffer_)
def wochentag(self, tup, buffer):
return str(getString(tup, buffer))
def version(self, value, buffer_):
# value = (tag, left, right, taglist)
return getString(value, buffer_)
def jahr(self, tup, buffer):
return str(getString(tup, buffer))
def counters(self, tup, prsbuf): return repr(dispatchprocessor.getString(tup, prsbuf))
# insttype: maps KEYWORD (i.e. type) (n) to entity inst nbr
self.res["contents"] = {}
self.res["insttype"] = {}
self.res["typeinst"] = defaultdict(list)
def ENTITY_INSTANCE_NAME(self, (tag, start, stop, subtags), buffer):
"""
Process C{ENTITY_INSTANCE_NAME} production.
"""
return dp.getString((tag, start, stop, subtags), buffer)[1:]
def KEYWORD(self, (tag, start, stop, subtags), buffer):
"""
Process C{KEYWORD} production.
"""
return dp.getString((tag, start, stop, subtags), buffer)
def parameter_list(self, (tag, start, stop, subtags), buffer):
"""
Process C{simple_content} production.
"""
return dp.getString((tag, start, stop, subtags), buffer)
def instance_list(self, (tag, start, stop, subtags), buffer):
"""
Process C{complex_content} production.
@return: a 2-tuple of (keywords, parameter lists), where keywords is
the list of KEYWORD occurrences and parameter lists is a list of
strings (each of which is an unparsed parameter list).
"""
def opt(self, tup, prsbuf): return repr(dispatchprocessor.getString(tup, prsbuf))
def _inherit(self, token, buffer):
tag, left, right, sublist = token
return getString(sublist[0], buffer)
def array_name(self, value, buffer_):
# value = (tag, left, right, taglist)
return getString(value, buffer_)
class Processor(disp.DispatchProcessor):
def alignmentStat(self, (t,s1,s2,sub), buffer):
self.alignments = []
self.qualifiers = None
self.currentAtom = None
disp.dispatchList(self, sub, buffer)
return [x.simplify() for x in self.alignments]
def oneAlignment(self, (t,s1,s2,sub), buffer):
self.qualifiers = []
disp.dispatchList(self, sub, buffer)
def atom(self, (t,s1,s2,sub), buffer):
atom = disp.getString((t,s1,s2,sub),buffer).lower().strip()
self.currentAtom = atomMap[ atom ]
def any(self, (t,s1,s2,sub), buffer):
if self.qualifiers is None:
self.qualifiers = []
disp.dispatchList(self, sub, buffer)
array = atomCross[self.currentAtom]
for id in array:
self.gotCompleteAlignment(id)
def gotCompleteAlignment(self, id):
"""
We have identified a complete alignment. add it to self.alignments
"""
part = AlignmentPart(id)
def defaultpolicy(self, tup, prsbuf): return repr(dispatchprocessor.getString(tup, prsbuf))
def _string(self, token, buffer):
tag, left, right, sublist = token
string = getString(sublist[0], buffer)
return String(self.context, string)
"""PRODUCTION FUNCTIONS: for parsing, must provide a function for each production name. """ def string(self, (tag,start,stop,subtags), buffer ): """Return a string, stripping leading and trailing markers""" return buffer[start+1:stop-1] def number(self, (tag,start,stop,subtags), buffer ): """return a number as a string""" return buffer[start:stop] def entry_type( self, (tag,start,stop,subtags), buffer ): """Return the entry type""" return getString((tag,start,stop,subtags), buffer) def citekey( self, (tag,start,stop,subtags), buffer ): """Return the entry's citekey""" return getString((tag,start,stop,subtags), buffer) # macro name def name(self, (tag,start,stop,subtags), buffer ): """Return lookup on name or name if not in map.""" return self._macroMap.get(buffer[start:stop],buffer[start:stop]) def field(self, (tag,start,stop,subtags), buffer ): """Process a bibentry field and return tuple of name, value.""" str = '' for t in subtags[1][3]: if(t) :
def _number(self, token, buffer):
number = getString(token, buffer)
return Number(int(number))
def chainline(self, tup, prsbuf): print repr(dispatchprocessor.getString(tup, prsbuf))
"""PRODUCTION FUNCTIONS:
for parsing, must provide a function for each production name.
"""
def string(self, (tag, start, stop, subtags), buffer):
"""Return a string, stripping leading and trailing markers"""
return buffer[start + 1:stop - 1]
def number(self, (tag, start, stop, subtags), buffer):
"""return a number as a string"""
return buffer[start:stop]
def entry_type(self, (tag, start, stop, subtags), buffer):
"""Return the entry type"""
return getString((tag, start, stop, subtags), buffer)
def citekey(self, (tag, start, stop, subtags), buffer):
"""Return the entry's citekey"""
return getString((tag, start, stop, subtags), buffer)
# macro name
def name(self, (tag, start, stop, subtags), buffer):
"""Return lookup on name or name if not in map."""
return self._macroMap.get(buffer[start:stop], buffer[start:stop])
def field(self, (tag, start, stop, subtags), buffer):
"""Process a bibentry field and return tuple of name, value."""
str = ''
for t in subtags[1][3]:
if (t):
def chainname(self, tup, prsbuf): return repr(dispatchprocessor.getString(tup, prsbuf))
