Lines Matching refs:self
54 def __eq__(self, other):
60 if self.__class__ is not other.__class__:
62 return self._eq(other)
66 def _eq(self, other):
77 def clone(self):
79 Return a cloned (deep) copy of self.
85 def post_order(self):
93 def pre_order(self):
101 def replace(self, new):
103 assert self.parent is not None, str(self)
109 for ch in self.parent.children:
110 if ch is self:
111 assert not found, (self.parent.children, self, new)
117 assert found, (self.children, self, new)
118 self.parent.changed()
119 self.parent.children = l_children
121 x.parent = self.parent
122 self.parent = None
124 def get_lineno(self):
126 node = self
133 def changed(self):
134 if self.parent:
135 self.parent.changed()
136 self.was_changed = True
138 def remove(self):
143 if self.parent:
144 for i, node in enumerate(self.parent.children):
145 if node is self:
146 self.parent.changed()
147 del self.parent.children[i]
148 self.parent = None
152 def next_sibling(self):
157 if self.parent is None:
161 for i, child in enumerate(self.parent.children):
162 if child is self:
164 return self.parent.children[i+1]
169 def prev_sibling(self):
174 if self.parent is None:
178 for i, child in enumerate(self.parent.children):
179 if child is self:
182 return self.parent.children[i-1]
184 def leaves(self):
185 for child in self.children:
188 def depth(self):
189 if self.parent is None:
191 return 1 + self.parent.depth()
193 def get_suffix(self):
198 next_sib = self.next_sibling
204 def __str__(self):
205 return str(self).encode("ascii")
211 def __init__(self,type, children,
224 self.type = type
225 self.children = list(children)
226 for ch in self.children:
228 ch.parent = self
230 self.prefix = prefix
232 self.fixers_applied = fixers_applied[:]
234 self.fixers_applied = None
236 def __repr__(self):
238 return "%s(%s, %r)" % (self.__class__.__name__,
239 type_repr(self.type),
240 self.children)
242 def __unicode__(self):
248 return "".join(map(str, self.children))
253 def _eq(self, other):
255 return (self.type, self.children) == (other.type, other.children)
257 def clone(self):
258 """Return a cloned (deep) copy of self."""
259 return Node(self.type, [ch.clone() for ch in self.children],
260 fixers_applied=self.fixers_applied)
262 def post_order(self):
264 for child in self.children:
266 yield self
268 def pre_order(self):
270 yield self
271 for child in self.children:
275 def prefix(self):
279 if not self.children:
281 return self.children[0].prefix
284 def prefix(self, prefix):
285 if self.children:
286 self.children[0].prefix = prefix
288 def set_child(self, i, child):
293 child.parent = self
294 self.children[i].parent = None
295 self.children[i] = child
296 self.changed()
298 def insert_child(self, i, child):
303 child.parent = self
304 self.children.insert(i, child)
305 self.changed()
307 def append_child(self, child):
312 child.parent = self
313 self.children.append(child)
314 self.changed()
326 def __init__(self, type, value,
338 self._prefix, (self.lineno, self.column) = context
339 self.type = type
340 self.value = value
342 self._prefix = prefix
343 self.fixers_applied = fixers_applied[:]
345 def __repr__(self):
347 return "%s(%r, %r)" % (self.__class__.__name__,
348 self.type,
349 self.value)
351 def __unicode__(self):
357 return self.prefix + str(self.value)
362 def _eq(self, other):
364 return (self.type, self.value) == (other.type, other.value)
366 def clone(self):
367 """Return a cloned (deep) copy of self."""
368 return Leaf(self.type, self.value,
369 (self.prefix, (self.lineno, self.column)),
370 fixers_applied=self.fixers_applied)
372 def leaves(self):
373 yield self
375 def post_order(self):
377 yield self
379 def pre_order(self):
381 yield self
384 def prefix(self):
388 return self._prefix
391 def prefix(self, prefix):
392 self.changed()
393 self._prefix = prefix
440 def __repr__(self):
441 args = [type_repr(self.type), self.content, self.name]
444 return "%s(%s)" % (self.__class__.__name__, ", ".join(map(repr, args)))
446 def optimize(self):
450 Returns either self or another node with the same effect.
452 return self
454 def match(self, node, results=None):
465 if self.type is not None and node.type != self.type:
467 if self.content is not None:
471 if not self._submatch(node, r):
475 if results is not None and self.name:
476 results[self.name] = node
479 def match_seq(self, nodes, results=None):
487 return self.match(nodes[0], results)
489 def generate_matches(self, nodes):
496 if nodes and self.match(nodes[0], r):
502 def __init__(self, type=None, content=None, name=None):
518 self.type = type
519 self.content = content
520 self.name = name
522 def match(self, node, results=None):
526 return BasePattern.match(self, node, results)
528 def _submatch(self, node, results=None):
532 This assumes the node type matches and self.content is not None.
541 return self.content == node.value
548 def __init__(self, type=None, content=None, name=None):
572 self.wildcards = True
573 self.type = type
574 self.content = content
575 self.name = name
577 def _submatch(self, node, results=None):
581 This assumes the node type matches and self.content is not None.
590 if self.wildcards:
591 for c, r in generate_matches(self.content, node.children):
597 if len(self.content) != len(node.children):
599 for subpattern, child in zip(self.content, node.children):
619 def __init__(self, content=None, min=0, max=HUGE, name=None):
649 self.content = content
650 self.min = min
651 self.max = max
652 self.name = name
654 def optimize(self):
657 if (self.content is not None and
658 len(self.content) == 1 and len(self.content[0]) == 1):
659 subpattern = self.content[0][0]
660 if self.min == 1 and self.max == 1:
661 if self.content is None:
662 return NodePattern(name=self.name)
663 if subpattern is not None and self.name == subpattern.name:
665 if (self.min <= 1 and isinstance(subpattern, WildcardPattern) and
666 subpattern.min <= 1 and self.name == subpattern.name):
668 self.min*subpattern.min,
669 self.max*subpattern.max,
671 return self
673 def match(self, node, results=None):
675 return self.match_seq([node], results)
677 def match_seq(self, nodes, results=None):
679 for c, r in self.generate_matches(nodes):
683 if self.name:
684 results[self.name] = list(nodes)
688 def generate_matches(self, nodes):
700 if self.content is None:
702 for count in range(self.min, 1 + min(len(nodes), self.max)):
704 if self.name:
705 r[self.name] = nodes[:count]
707 elif self.name == "bare_name":
708 yield self._bare_name_matches(nodes)
718 for count, r in self._recursive_matches(nodes, 0):
719 if self.name:
720 r[self.name] = nodes[:count]
725 for count, r in self._iterative_matches(nodes):
726 if self.name:
727 r[self.name] = nodes[:count]
733 def _iterative_matches(self, nodes):
736 if 0 >= self.min:
740 # generate matches that use just one alt from self.content
741 for alt in self.content:
751 if c0 < nodelen and c0 <= self.max:
752 for alt in self.content:
762 def _bare_name_matches(self, nodes):
770 for leaf in self.content:
775 r[self.name] = nodes[:count]
778 def _recursive_matches(self, nodes, count):
780 assert self.content is not None
781 if count >= self.min:
783 if count < self.max:
784 for alt in self.content:
786 for c1, r1 in self._recursive_matches(nodes[c0:], count+1):
795 def __init__(self, content=None):
806 self.content = content
808 def match(self, node):
812 def match_seq(self, nodes):
816 def generate_matches(self, nodes):
817 if self.content is None:
823 for c, r in self.content.generate_matches(nodes):