text: #!/usr/bin/env python3
  # -*- coding: utf-8 -*-
  # ---------------------------------------------------------------------
  #  Modifications from Merchise Autrement.  Original notice:
  #
  #  Copyright (c) 1998-2016 John Aycock
  #
  #  Permission is hereby granted, free of charge, to any person obtaining
  #  a copy of this software and associated documentation files (the
  #  "Software"), to deal in the Software without restriction, including
  #  without limitation the rights to use, copy, modify, merge, publish,
  #  distribute, sublicense, and/or sell copies of the Software, and to
  #  permit persons to whom the Software is furnished to do so, subject to
  #  the following conditions:
  #
  #  The above copyright notice and this permission notice shall be
  #  included in all copies or substantial portions of the Software.
  #
  #  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  #  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  #  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  #  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
  #  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  #  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  #  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  
  
  __version__ = 'SPARK-0.7 (pre-alpha-7) xotl.ql.revenge - 0.3.0'
  
  
  from xoutil.eight import range
  
  
  def _namelist(instance):
      namelist, namedict, classlist = [], {}, [instance.__class__]
      for c in classlist:
          for b in c.__bases__:
              classlist.append(b)
          for name in c.__dict__.keys():
              if name not in namedict:
                  namelist.append(name)
                  namedict[name] = 1
      return namelist
  
  
  #
  #  Extracted from GenericParser and made global so that [un]picking works.
  #
  class _State:
      def __init__(self, stateno, items):
          self.T, self.complete, self.items = [], [], items
          self.stateno = stateno
  
  
  class GenericParser:
      #
      #  An Earley parser, as per J. Earley, "An Efficient Context-Free Parsing
      #  Algorithm", CACM 13(2), pp. 94-102.  Also J. C. Earley, "An Efficient
      #  Context-Free Parsing Algorithm", Ph.D. thesis, Carnegie-Mellon
      #  University, August 1968.  New formulation of the parser according to
      #  J. Aycock, "Practical Earley Parsing and the SPARK Toolkit",
      #  Ph.D. thesis, University of Victoria, 2001, and J. Aycock and
      #  R. N. Horspool, "Practical Earley Parsing", unpublished paper, 2001.
      #
  
      def __init__(self, start):
          self.rules = {}
          self.rule2func = {}
          self.rule2name = {}
          self.collectRules()
          self.augment(start)
          self.ruleschanged = 1
  
      _NULLABLE = '\e_'
      _START = 'START'
      _BOF = '|-'
  
      #
      #  When pickling, take the time to generate the full state machine; some
      #  information is then extraneous, too.  Unfortunately we can't save the
      #  rule2func map.
      #
      def __getstate__(self):
          if self.ruleschanged:
              #
              #  XXX - duplicated from parse()
              #
              self.computeNull()
              self.newrules = {}
              self.new2old = {}
              self.makeNewRules()
              self.ruleschanged = 0
              self.edges, self.cores = {}, {}
              self.states = {0: self.makeState0()}
              self.makeState(0, self._BOF)
          #
          #  XXX - should find a better way to do this..
          #
          changes = 1
          while changes:
              changes = 0
              for k, v in self.edges.items():
                  if v is None:
                      state, sym = k
                      if state in self.states:
                          self.goto(state, sym)
                          changes = 1
          rv = self.__dict__.copy()
          for s in self.states.values():
              del s.items
          del rv['rule2func']
          del rv['nullable']
          del rv['cores']
          return rv
  
      def __setstate__(self, D):
          self.rules = {}
          self.rule2func = {}
          self.rule2name = {}
          self.collectRules()
          start = D['rules'][self._START][0][1][1]  # Blech.
          self.augment(start)
          D['rule2func'] = self.rule2func
          D['makeSet'] = self.makeSet_fast
          self.__dict__ = D
  
      #
      #  A hook for GenericASTBuilder and GenericASTMatcher.  Mess thee not with
      #  this; nor shall thee toucheth the _preprocess argument to addRule.
      #
      def preprocess(self, rule, func):
          return rule, func
  
      @staticmethod
      def strip_comments(doc):
          result = []
          for line in doc.split(str('\n')):
              line = line.strip()
              if not (line.startswith(str('#')) or line.startswith(str('.. '))):
                  result.append(line)
          return str('\n').join(result)
  
      def addRule(self, doc, func, _preprocess=1):
          doc = self.strip_comments(doc)
          fn = func
          rules = doc.split()
  
          # First, detect all lines where a new production is given.
          index = []
          for i in range(len(rules)):
              if rules[i] == '::=':
                  index.append(i-1)
          index.append(len(rules))
  
          # Now process each rule add it the rules.  We take care of making of
          # splitting right hand sides with vertical bars into several rules.
          for i in range(len(index)-1):
              lhs = rules[index[i]]
              rhss = rules[index[i]+2:index[i+1]]
              lhs_rules = self.rules.setdefault(lhs, [])
              for rhs in iter_rhss(rhss):
                  rule = (lhs, tuple(rhs))
                  if _preprocess:
                      rule, fn = self.preprocess(rule, func)
                  lhs_rules.append(rule)
                  self.rule2func[rule] = fn
                  self.rule2name[rule] = func.__name__[2:]
          self.ruleschanged = 1
  
      @classmethod
      def find_rules(cls, docstring):
          '''Find the rules in the docstring.
  
          Allows the docstring to be more verbose without the need of comments
          by searching for a marker::
  
            .. _rules:
  
          Everything before the marker is considered documentation.  After the
          marker go the rules.  The marker is excluded from both.
  
          If the marker is not present.  The entire docstring is considered the
          rules part except for the first lines that does not contain ``::=`` a
          production.
  
          If you need documentation inside the rules, use comments.
  
          Rules may contain verticals bars to express alternatives.  This is
          just syntactic sugar to avoid writing several rules.  The rule
          ``nonterminal ::= A B | C D`` is actually converted to the following
          two rules together::
  
            nonterminal ::= A B
            nonterminal ::= B D
  
          No grouping or escaping is allowed.
  
          '''
          import re
          marker = re.compile(r'^\s*\.\.\s+_rules:\s*$', re.M)
          found = marker.search(docstring)
          if found:
              start, end = found.span()
              doc, rules = docstring[:start], docstring[end:]
          else:
              doclines, rulelines = [], []
              accumulating_rules = False
              for line in docstring.splitlines():
                  if not accumulating_rules:
                      accumulating_rules = '::=' in line
                  if accumulating_rules:
                      rulelines.append(line)
                  else:
                      doclines.append(line)
              doc = '\n'.join(doclines)
              rules = '\n'.join(rulelines)
          return doc, rules
  
      def collectRules(self):
          for name in _namelist(self):
              if name[:2] == 'p_':
                  func = getattr(self, name)
                  doc = func.__doc__
                  _intro, rules = self.find_rules(doc)
                  self.addRule(rules, func)
  
      def augment(self, start):
          rule = '%s ::= %s %s' % (self._START, self._BOF, start)
          self.addRule(rule, lambda args: args[1], 0)
  
      def computeNull(self):
          self.nullable = {}
          tbd = []
          for rulelist in self.rules.values():
              lhs = rulelist[0][0]
              self.nullable[lhs] = 0
              for rule in rulelist:
                  rhs = rule[1]
                  if len(rhs) == 0:
                      self.nullable[lhs] = 1
                      continue
                  #
                  #  We only need to consider rules which consist entirely of
                  #  nonterminal symbols.  This should be a savings on typical
                  #  grammars.
                  #
                  for sym in rhs:
                      if sym not in self.rules:
                          break
                  else:
                      tbd.append(rule)
          changes = 1
          while changes:
              changes = 0
              for lhs, rhs in tbd:
                  if self.nullable[lhs]:
                      continue
                  for sym in rhs:
                      if not self.nullable[sym]:
                          break
                  else:
                      self.nullable[lhs] = 1
                      changes = 1
  
      def makeState0(self):
          s0 = _State(0, [])
          for rule in self.newrules[self._START]:
              s0.items.append((rule, 0))
          return s0
  
      def finalState(self, tokens):
          #
          #  Yuck.
          #
          if len(self.newrules[self._START]) == 2 and len(tokens) == 0:
              return 1
          start = self.rules[self._START][0][1][1]
          return self.goto(1, start)
  
      def makeNewRules(self):
          worklist = []
          for rulelist in self.rules.values():
              for rule in rulelist:
                  worklist.append((rule, 0, 1, rule))
  
          for rule, i, candidate, oldrule in worklist:
              lhs, rhs = rule
              n = len(rhs)
              while i < n:
                  sym = rhs[i]
                  if sym not in self.rules or \
                     not self.nullable[sym]:
                      candidate = 0
                      i = i + 1
                      continue
                  newrhs = list(rhs)
                  newrhs[i] = self._NULLABLE+sym
                  newrule = (lhs, tuple(newrhs))
                  worklist.append((newrule, i+1,
                                   candidate, oldrule))
                  candidate = 0
                  i = i + 1
              else:
                  if candidate:
                      lhs = self._NULLABLE+lhs
                      rule = (lhs, rhs)
                  if lhs in self.newrules:
                      self.newrules[lhs].append(rule)
                  else:
                      self.newrules[lhs] = [rule]
                  self.new2old[rule] = oldrule
  
      def typestring(self, token):
          return None
  
      def error(self, token):
          # XXX: Should we make this a SyntaxError?
          raise RuntimeError("Syntax error at or near `%s' token" % token)
  
      def parse(self, tokens):
          sets = [[(1, 0), (2, 0)]]
          self.links = {}
          if self.ruleschanged:
              self.computeNull()
              self.newrules = {}
              self.new2old = {}
              self.makeNewRules()
              self.ruleschanged = 0
              self.edges, self.cores = {}, {}
              self.states = {0: self.makeState0()}
              self.makeState(0, self._BOF)
          for i in range(len(tokens)):
              sets.append([])
              if sets[i] == []:
                  break
              self.makeSet(tokens[i], sets, i)
          else:
              sets.append([])
              self.makeSet(None, sets, len(tokens))
          finalitem = (self.finalState(tokens), 0)
          if finalitem not in sets[-2]:
              if len(tokens) > 0:
                  self.error(tokens[i-1])
              else:
                  self.error(None)
          return self.buildTree(self._START, finalitem,
                                tokens, len(sets)-2)
  
      def isnullable(self, sym):
          #  For symbols in G_e only.
          return sym.startswith(self._NULLABLE)
  
      def skip(self, lhs_rhs, pos=0):
          (lhs, rhs) = lhs_rhs
          n = len(rhs)
          while pos < n:
              if not self.isnullable(rhs[pos]):
                  break
              pos = pos + 1
          return pos
  
      def makeState(self, state, sym):
          assert sym is not None
          #
          #  Compute \epsilon-kernel state's core and see if
          #  it exists already.
          #
          kitems = []
          for rule, pos in self.states[state].items:
              lhs, rhs = rule
              if rhs[pos:pos+1] == (sym,):
                  kitems.append((rule, self.skip(rule, pos+1)))
  
          tcore = tuple(sorted(kitems))
          if tcore in self.cores:
              return self.cores[tcore]
          #
          #  Nope, doesn't exist.  Compute it and the associated
          #  \epsilon-nonkernel state together; we'll need it right away.
          #
          k = self.cores[tcore] = len(self.states)
          K, NK = _State(k, kitems), _State(k+1, [])
          self.states[k] = K
          predicted = {}
  
          edges = self.edges
          rules = self.newrules
          for X in K, NK:
              worklist = X.items
              for item in worklist:
                  rule, pos = item
                  lhs, rhs = rule
                  if pos == len(rhs):
                      X.complete.append(rule)
                      continue
  
                  nextSym = rhs[pos]
                  key = (X.stateno, nextSym)
                  if nextSym not in rules:
                      if key not in edges:
                          edges[key] = None
                          X.T.append(nextSym)
                  else:
                      edges[key] = None
                      if nextSym not in predicted:
                          predicted[nextSym] = 1
                          for prule in rules[nextSym]:
                              ppos = self.skip(prule)
                              new = (prule, ppos)
                              NK.items.append(new)
              #
              #  Problem: we know K needs generating, but we don't yet know
              #  about NK.  Can't commit anything regarding NK to self.edges
              #  until we're sure.  Should we delay committing on both K and NK
              #  to avoid this hacky code?  This creates other problems..
              #
              if X is K:
                  edges = {}
  
          if NK.items == []:
              return k
  
          #
          #  Check for \epsilon-nonkernel's core.  Unfortunately we need to know
          #  the entire set of predicted nonterminals to do this without
          #  accidentally duplicating states.
          #
          tcore = tuple(sorted(predicted.keys()))
          if tcore in self.cores:
              self.edges[(k, None)] = self.cores[tcore]
              return k
  
          nk = self.cores[tcore] = self.edges[(k, None)] = NK.stateno
          self.edges.update(edges)
          self.states[nk] = NK
          return k
  
      def goto(self, state, sym):
          key = (state, sym)
          if key not in self.edges:
              #
              #  No transitions from state on sym.
              #
              return None
  
          rv = self.edges[key]
          if rv is None:
              #
              #  Target state isn't generated yet.  Remedy this.
              #
              rv = self.makeState(state, sym)
              self.edges[key] = rv
          return rv
  
      def gotoT(self, state, t):
          return [self.goto(state, t)]
  
      def gotoST(self, state, st):
          rv = []
          for t in self.states[state].T:
              if st == t:
                  rv.append(self.goto(state, t))
          return rv
  
      def add(self, set, item, i=None, predecessor=None, causal=None):
          if predecessor is None:
              if item not in set:
                  set.append(item)
          else:
              key = (item, i)
              if item not in set:
                  self.links[key] = []
                  set.append(item)
              self.links[key].append((predecessor, causal))
  
      def makeSet(self, token, sets, i):
          cur, next = sets[i], sets[i+1]
  
          ttype = token is not None and self.typestring(token) or None
          if ttype is not None:
              fn, arg = self.gotoT, ttype
          else:
              fn, arg = self.gotoST, token
  
          for item in cur:
              ptr = (item, i)
              state, parent = item
              add = fn(state, arg)
              for k in add:
                  if k is not None:
                      self.add(next, (k, parent), i+1, ptr)
                      nk = self.goto(k, None)
                      if nk is not None:
                          self.add(next, (nk, i+1))
  
              if parent == i:
                  continue
  
              for rule in self.states[state].complete:
                  lhs, rhs = rule
                  for pitem in sets[parent]:
                      pstate, pparent = pitem
                      k = self.goto(pstate, lhs)
                      if k is not None:
                          why = (item, i, rule)
                          pptr = (pitem, parent)
                          self.add(cur, (k, pparent),
                                   i, pptr, why)
                          nk = self.goto(k, None)
                          if nk is not None:
                              self.add(cur, (nk, i))
  
      def makeSet_fast(self, token, sets, i):
          #
          #  Call *only* when the entire state machine has been built!
          #  It relies on self.edges being filled in completely, and
          #  then duplicates and inlines code to boost speed at the
          #  cost of extreme ugliness.
          #
          cur, next = sets[i], sets[i+1]
          ttype = token is not None and self.typestring(token) or None
  
          for item in cur:
              ptr = (item, i)
              state, parent = item
              if ttype is not None:
                  k = self.edges.get((state, ttype), None)
                  if k is not None:
                      # self.add(next, (k, parent), i+1, ptr)
                      # INLINED --v
                      new = (k, parent)
                      key = (new, i+1)
                      if new not in next:
                          self.links[key] = []
                          next.append(new)
                      self.links[key].append((ptr, None))
                      # INLINED --^
                      # nk = self.goto(k, None)
                      nk = self.edges.get((k, None), None)
                      if nk is not None:
                          # self.add(next, (nk, i+1))
                          # INLINED --v
                          new = (nk, i+1)
                          if new not in next:
                              next.append(new)
                          # INLINED --^
              else:
                  add = self.gotoST(state, token)
                  for k in add:
                      if k is not None:
                          self.add(next, (k, parent), i+1, ptr)
                          # nk = self.goto(k, None)
                          nk = self.edges.get((k, None), None)
                          if nk is not None:
                              self.add(next, (nk, i+1))
  
              if parent == i:
                  continue
  
              for rule in self.states[state].complete:
                  lhs, rhs = rule
                  for pitem in sets[parent]:
                      pstate, pparent = pitem
                      # k = self.goto(pstate, lhs)
                      k = self.edges.get((pstate, lhs), None)
                      if k is not None:
                          why = (item, i, rule)
                          pptr = (pitem, parent)
                          # self.add(cur, (k, pparent),
                          #        i, pptr, why)
                          # INLINED --v
                          new = (k, pparent)
                          key = (new, i)
                          if new not in cur:
                              self.links[key] = []
                              cur.append(new)
                          self.links[key].append((pptr, why))
                          # INLINED --^
                          # nk = self.goto(k, None)
                          nk = self.edges.get((k, None), None)
                          if nk is not None:
                              # self.add(cur, (nk, i))
                              # INLINED --v
                              new = (nk, i)
                              if new not in cur:
                                  cur.append(new)
                              # INLINED --^
  
      def predecessor(self, key, causal):
          for p, c in self.links[key]:
              if c == causal:
                  return p
          assert 0
  
      def causal(self, key):
          links = self.links[key]
          if len(links) == 1:
              return links[0][1]
          choices = []
          rule2cause = {}
          for p, c in links:
              rule = c[2]
              choices.append(rule)
              rule2cause[rule] = c
          return rule2cause[self.ambiguity(choices)]
  
      def deriveEpsilon(self, nt):
          if len(self.newrules[nt]) > 1:
              rule = self.ambiguity(self.newrules[nt])
          else:
              rule = self.newrules[nt][0]
  
          rhs = rule[1]
          attr = [None] * len(rhs)
  
          for i in range(len(rhs)-1, -1, -1):
              attr[i] = self.deriveEpsilon(rhs[i])
          return self.rule2func[self.new2old[rule]](attr)
  
      def buildTree(self, nt, item, tokens, k):
          state, parent = item
  
          choices = []
          for rule in self.states[state].complete:
              if rule[0] == nt:
                  choices.append(rule)
          rule = choices[0]
          if len(choices) > 1:
              rule = self.ambiguity(choices)
  
          rhs = rule[1]
          attr = [None] * len(rhs)
  
          for i in range(len(rhs)-1, -1, -1):
              sym = rhs[i]
              if sym not in self.newrules:
                  if sym != self._BOF:
                      attr[i] = tokens[k-1]
                      key = (item, k)
                      item, k = self.predecessor(key, None)
              elif self._NULLABLE == sym[0:len(self._NULLABLE)]:
                  attr[i] = self.deriveEpsilon(sym)
              else:
                  key = (item, k)
                  why = self.causal(key)
                  attr[i] = self.buildTree(sym, why[0],
                                           tokens, why[1])
                  item, k = self.predecessor(key, why)
          return self.rule2func[self.new2old[rule]](attr)
  
      def ambiguity(self, rules):
          #
          #  XXX - problem here and in collectRules() if the same rule
          #        appears in >1 method.  Also undefined results if rules
          #        causing the ambiguity appear in the same method.
          #
  
          sortlist = []
          name2index = {}
          for i in range(len(rules)):
              lhs, rhs = rule = rules[i]
              name = self.rule2name[self.new2old[rule]]
              sortlist.append((len(rhs), name))
              name2index[name] = i
          sortlist.sort()
          list = [a_b[1] for a_b in sortlist]
          return rules[name2index[self.resolve(list)]]
  
      def resolve(self, list):
          #
          #  Resolve ambiguity in favor of the shortest RHS.
          #  Since we walk the tree from the top down, this
          #  should effectively resolve in favor of a "shift".
          #
          return list[0]
  
  
  #
  #  GenericASTBuilder automagically constructs a concrete/abstract syntax tree
  #  for a given input.  The extra argument is a class (not an instance!)
  #  which supports the "__setslice__" and "__len__" methods.
  #
  #  XXX - silently overrides any user code in methods.
  #
  class GenericASTBuilder(GenericParser):
      def __init__(self, AST, start):
          super().__init__(start)
          self.AST = AST
  
      def preprocess(self, rule, func):
          def rebind(lhs, self=self):
              return lambda args, lhs=lhs, self=self: self.buildASTNode(args, lhs)
          lhs, rhs = rule
          return rule, rebind(lhs)
  
      def buildASTNode(self, args, lhs):
          children = []
          for arg in args:
              if isinstance(arg, self.AST):
                  children.append(arg)
              else:
                  children.append(arg)
          return self.nonterminal(lhs, children)
  
      def nonterminal(self, type, args):
          rv = self.AST(type)
          rv[:len(args)] = args
          return rv
  
  
  #
  #  GenericASTTraversal is a Visitor pattern according to Design Patterns.  For
  #  each node it attempts to invoke the method n_<node type>, falling back onto
  #  the default() method if the n_* can't be found.  The preorder traversal
  #  also looks for an exit hook named n_<node type>_exit (no default routine is
  #  called if it's not found).  To prematurely halt traversal of a subtree,
  #  call the prune() method -- this only makes sense for a preorder traversal.
  #  Node type is determined via the typestring() method.
  #
  class GenericASTTraversalPruningException(Exception):
      pass
  
  
  class GenericASTTraversal:
      def __init__(self, ast):
          self.ast = ast
  
      def typestring(self, node):
          return node.type
  
      def prune(self):
          raise GenericASTTraversalPruningException
  
      def preorder(self, node=None):
          if node is None:
              node = self.ast
          try:
              result = self.dispatch(node)
          except GenericASTTraversalPruningException:
              return
          children = []
          for kid in node:
              children.append(self.preorder(kid))
          r = self.dispatch_exit(node, children=children)
          if r:
              result = r
          return result
  
      def dispatch(self, node, default=None):
          if default is None:
              default = self.default
          name = 'n_' + self.typestring(node)
          func = getattr(self, name, default)
          return func(node)
  
      def dispatch_exit(self, node, children=None):
          name = 'n_' + self.typestring(node) + '_exit'
          func = getattr(self, name, None)
          if func:
              return func(node, children=children)
  
      def default(self, node):
          pass
  
  
  def get_grammar_arrows(p, start):
      '''Get the links between grammar nodes.
  
      Yield pairs (2-tuples).  Each tuple ``(head, tail)`` means that tail is in
      the right side of some production ``head ::= ... tail ...``.
  
      '''
      rules = list(p.rules[start])
      seen = set()
      while rules:
          head, prod = rules.pop(0)
          seen.add(head)
          new = set()
          for which in prod:
              if which not in new and which not in seen:
                  new.add(which)
                  yield head, which
                  rules.extend(p.rules.get(which, []))
  
  
  def get_closure(p, *starts):
      '''Get all the nodes reachable from start.'''
      return {
          head
          for start in starts
          for head, _ in get_grammar_arrows(p, start)
      }
  
  
  def get_graphivz_script(p, *starts):
      lines = ['digraph G {']
      for start in starts:
          for head, tail in get_grammar_arrows(p, start):
              lines.append('{head} -> {tail};'.format(head=head, tail=tail))
      lines.append('}')
      return '\n'.join(lines)
  
  
  def call_graphivz_script(script):
      '''Shows a graph using dot and eog.'''
      from tempfile import NamedTemporaryFile
      from subprocess import Popen, PIPE
      dotcmd = ['dot', '-Tpng']
      dotproc = Popen(dotcmd, stdin=PIPE, stdout=PIPE)
      out, err = dotproc.communicate(script)
      if out:
          with NamedTemporaryFile(suffix='.png') as tmpf:
              tmpf.write(out)
              tmpf.flush()
              Popen(['eog', tmpf.name]).wait()
  
  
  def find(l, what):
      try:
          return l.index(what)
      except ValueError:
          return None
  
  
  def iter_rhss(rhss):
      last = 0
      pos = find(rhss, '|')
      while pos is not None:
          assert pos < (len(rhss) - 1), 'rhss must not end with |'
          yield rhss[last:last+pos]
          last += pos + 1
          pos = find(rhss[last:], '|')
      res = rhss[last:]
      yield res
  