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 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 _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))