summaryrefslogtreecommitdiff
path: root/sphinx/pycode/nodes.py
diff options
context:
space:
mode:
Diffstat (limited to 'sphinx/pycode/nodes.py')
-rw-r--r--sphinx/pycode/nodes.py212
1 files changed, 0 insertions, 212 deletions
diff --git a/sphinx/pycode/nodes.py b/sphinx/pycode/nodes.py
deleted file mode 100644
index cecde9bd0..000000000
--- a/sphinx/pycode/nodes.py
+++ /dev/null
@@ -1,212 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
- sphinx.pycode.nodes
- ~~~~~~~~~~~~~~~~~~~
-
- Parse tree node implementations.
-
- :copyright: Copyright 2007-2017 by the Sphinx team, see AUTHORS.
- :license: BSD, see LICENSE for details.
-"""
-
-if False:
- # For type annotation
- from typing import Callable # NOQA
-
-
-class BaseNode(object):
- """
- Node superclass for both terminal and nonterminal nodes.
- """
- parent = None # type: BaseNode
-
- def _eq(self, other):
- raise NotImplementedError
-
- def __eq__(self, other):
- if self.__class__ is not other.__class__:
- return NotImplemented
- return self._eq(other)
-
- def __ne__(self, other):
- if self.__class__ is not other.__class__:
- return NotImplemented
- return not self._eq(other)
-
- __hash__ = None # type: Callable[[object], int]
-
- def get_prev_sibling(self):
- """Return previous child in parent's children, or None."""
- if self.parent is None:
- return None
- for i, child in enumerate(self.parent.children):
- if child is self:
- if i == 0:
- return None
- return self.parent.children[i - 1]
-
- def get_next_sibling(self):
- """Return next child in parent's children, or None."""
- if self.parent is None:
- return None
- for i, child in enumerate(self.parent.children):
- if child is self:
- try:
- return self.parent.children[i + 1]
- except IndexError:
- return None
-
- def get_prev_leaf(self):
- """Return the leaf node that precedes this node in the parse tree."""
- def last_child(node):
- if isinstance(node, Leaf):
- return node
- elif not node.children:
- return None
- else:
- return last_child(node.children[-1])
- if self.parent is None:
- return None
- prev = self.get_prev_sibling()
- if isinstance(prev, Leaf):
- return prev
- elif prev is not None:
- return last_child(prev)
- return self.parent.get_prev_leaf()
-
- def get_next_leaf(self):
- """Return self if leaf, otherwise the leaf node that succeeds this
- node in the parse tree.
- """
- node = self
- while not isinstance(node, Leaf):
- assert node.children
- node = node.children[0]
- return node
-
- def get_lineno(self):
- """Return the line number which generated the invocant node."""
- return self.get_next_leaf().lineno
-
- def get_prefix(self):
- """Return the prefix of the next leaf node."""
- # only leaves carry a prefix
- return self.get_next_leaf().prefix
-
-
-class Node(BaseNode):
- """
- Node implementation for nonterminals.
- """
-
- def __init__(self, type, children, context=None):
- # type of nonterminals is >= 256
- # assert type >= 256, type
- self.type = type
- self.children = list(children)
- for ch in self.children:
- # assert ch.parent is None, repr(ch)
- ch.parent = self
-
- def __repr__(self):
- return '%s(%s, %r)' % (self.__class__.__name__,
- self.type, self.children)
-
- def __str__(self):
- """This reproduces the input source exactly."""
- return ''.join(map(str, self.children))
-
- def _eq(self, other):
- return (self.type, self.children) == (other.type, other.children)
-
- # support indexing the node directly instead of .children
-
- def __getitem__(self, index):
- return self.children[index]
-
- def __iter__(self):
- return iter(self.children)
-
- def __len__(self):
- return len(self.children)
-
-
-class Leaf(BaseNode):
- """
- Node implementation for leaf nodes (terminals).
- """
- prefix = '' # Whitespace and comments preceding this token in the input
- lineno = 0 # Line where this token starts in the input
- column = 0 # Column where this token tarts in the input
-
- def __init__(self, type, value, context=None):
- # type of terminals is below 256
- # assert 0 <= type < 256, type
- self.type = type
- self.value = value
- if context is not None:
- self.prefix, (self.lineno, self.column) = context
-
- def __repr__(self):
- return '%s(%r, %r, %r)' % (self.__class__.__name__,
- self.type, self.value, self.prefix)
-
- def __str__(self):
- """This reproduces the input source exactly."""
- return self.prefix + str(self.value)
-
- def _eq(self, other):
- """Compares two nodes for equality."""
- return (self.type, self.value) == (other.type, other.value)
-
-
-def convert(grammar, raw_node):
- """Convert raw node to a Node or Leaf instance."""
- type, value, context, children = raw_node
- if children or type in grammar.number2symbol:
- # If there's exactly one child, return that child instead of
- # creating a new node.
- if len(children) == 1:
- return children[0]
- return Node(type, children, context=context)
- else:
- return Leaf(type, value, context=context)
-
-
-def nice_repr(node, number2name, prefix=False):
- def _repr(node):
- if isinstance(node, Leaf):
- return "%s(%r)" % (number2name[node.type], node.value)
- else:
- return "%s(%s)" % (number2name[node.type],
- ', '.join(map(_repr, node.children)))
-
- def _prepr(node):
- if isinstance(node, Leaf):
- return "%s(%r, %r)" % (number2name[node.type],
- node.prefix, node.value)
- else:
- return "%s(%s)" % (number2name[node.type],
- ', '.join(map(_prepr, node.children)))
- return (prefix and _prepr or _repr)(node)
-
-
-class NodeVisitor(object):
- def __init__(self, number2name, *args):
- self.number2name = number2name
- self.init(*args)
-
- def init(self, *args):
- pass
-
- def visit(self, node):
- """Visit a node."""
- method = 'visit_' + self.number2name[node.type]
- visitor = getattr(self, method, self.generic_visit)
- return visitor(node)
-
- def generic_visit(self, node):
- """Called if no explicit visitor function exists for a node."""
- if isinstance(node, Node):
- for child in node: # type: ignore
- self.visit(child)