Lines Matching refs:self
27 def visit(self, node: Any, *args: Any, **kwargs: Any) -> Any:
30 visitor = getattr(self, method, self.generic_visit)
33 def generic_visit(self, node: Iterable[Any], *args: Any, **kwargs: Any) -> Any:
38 self.visit(item, *args, **kwargs)
40 self.visit(value, *args, **kwargs)
44 def __init__(self, rules: Iterable[Rule], metas: Iterable[Tuple[str, Optional[str]]]):
45 self.rules = {rule.name: rule for rule in rules}
46 self.metas = dict(metas)
48 def __str__(self) -> str:
49 return "\n".join(str(rule) for name, rule in self.rules.items())
51 def __repr__(self) -> str:
54 for rule in self.rules.values():
57 lines.append(" {repr(list(self.metas.items()))}")
61 def __iter__(self) -> Iterator[Rule]:
62 yield from self.rules.values()
70 def __init__(self, name: str, type: Optional[str], rhs: Rhs, memo: Optional[object] = None):
71 self.name = name
72 self.type = type
73 self.rhs = rhs
74 self.memo = bool(memo)
75 self.left_recursive = False
76 self.leader = False
78 def is_loop(self) -> bool:
79 return self.name.startswith("_loop")
81 def is_gather(self) -> bool:
82 return self.name.startswith("_gather")
84 def __str__(self) -> str:
85 if SIMPLE_STR or self.type is None:
86 res = f"{self.name}: {self.rhs}"
88 res = f"{self.name}[{self.type}]: {self.rhs}"
92 lines += [f" | {alt}" for alt in self.rhs.alts]
95 def __repr__(self) -> str:
96 return f"Rule({self.name!r}, {self.type!r}, {self.rhs!r})"
98 def __iter__(self) -> Iterator[Rhs]:
99 yield self.rhs
101 def flatten(self) -> Rhs:
103 rhs = self.rhs
105 not self.is_loop()
115 def __init__(self, value: str):
116 self.value = value
118 def __str__(self) -> str:
119 return self.value
121 def __iter__(self) -> Iterable[str]:
129 def __str__(self) -> str:
130 if self.value == "ENDMARKER":
134 def __repr__(self) -> str:
135 return f"NameLeaf({self.value!r})"
141 def __repr__(self) -> str:
142 return f"StringLeaf({self.value!r})"
146 def __init__(self, alts: List[Alt]):
147 self.alts = alts
148 self.memo: Optional[Tuple[Optional[str], str]] = None
150 def __str__(self) -> str:
151 return " | ".join(str(alt) for alt in self.alts)
153 def __repr__(self) -> str:
154 return f"Rhs({self.alts!r})"
156 def __iter__(self) -> Iterator[List[Alt]]:
157 yield self.alts
160 def can_be_inlined(self) -> bool:
161 if len(self.alts) != 1 or len(self.alts[0].items) != 1:
164 if getattr(self.alts[0], "action", None) is not None:
170 def __init__(self, items: List[NamedItem], *, icut: int = -1, action: Optional[str] = None):
171 self.items = items
172 self.icut = icut
173 self.action = action
175 def __str__(self) -> str:
176 core = " ".join(str(item) for item in self.items)
177 if not SIMPLE_STR and self.action:
178 return f"{core} {{ {self.action} }}"
182 def __repr__(self) -> str:
183 args = [repr(self.items)]
184 if self.icut >= 0:
185 args.append(f"icut={self.icut}")
186 if self.action:
187 args.append(f"action={self.action!r}")
190 def __iter__(self) -> Iterator[List[NamedItem]]:
191 yield self.items
195 def __init__(self, name: Optional[str], item: Item, type: Optional[str] = None):
196 self.name = name
197 self.item = item
198 self.type = type
200 def __str__(self) -> str:
201 if not SIMPLE_STR and self.name:
202 return f"{self.name}={self.item}"
204 return str(self.item)
206 def __repr__(self) -> str:
207 return f"NamedItem({self.name!r}, {self.item!r})"
209 def __iter__(self) -> Iterator[Item]:
210 yield self.item
214 def __init__(self, node: Plain):
215 self.node = node
217 def __str__(self) -> str:
218 return f"&&{self.node}"
220 def __iter__(self) -> Iterator[Plain]:
221 yield self.node
225 def __init__(self, node: Plain, sign: str):
226 self.node = node
227 self.sign = sign
229 def __str__(self) -> str:
230 return f"{self.sign}{self.node}"
232 def __iter__(self) -> Iterator[Plain]:
233 yield self.node
237 def __init__(self, node: Plain):
240 def __repr__(self) -> str:
241 return f"PositiveLookahead({self.node!r})"
245 def __init__(self, node: Plain):
248 def __repr__(self) -> str:
249 return f"NegativeLookahead({self.node!r})"
253 def __init__(self, node: Item):
254 self.node = node
256 def __str__(self) -> str:
257 s = str(self.node)
264 def __repr__(self) -> str:
265 return f"Opt({self.node!r})"
267 def __iter__(self) -> Iterator[Item]:
268 yield self.node
274 def __init__(self, node: Plain):
275 self.node = node
276 self.memo: Optional[Tuple[Optional[str], str]] = None
278 def __iter__(self) -> Iterator[Plain]:
279 yield self.node
283 def __str__(self) -> str:
284 s = str(self.node)
291 def __repr__(self) -> str:
292 return f"Repeat0({self.node!r})"
296 def __str__(self) -> str:
297 s = str(self.node)
304 def __repr__(self) -> str:
305 return f"Repeat1({self.node!r})"
309 def __init__(self, separator: Plain, node: Plain):
310 self.separator = separator
311 self.node = node
313 def __str__(self) -> str:
314 return f"{self.separator!s}.{self.node!s}+"
316 def __repr__(self) -> str:
317 return f"Gather({self.separator!r}, {self.node!r})"
321 def __init__(self, rhs: Rhs):
322 self.rhs = rhs
324 def __str__(self) -> str:
325 return f"({self.rhs})"
327 def __repr__(self) -> str:
328 return f"Group({self.rhs!r})"
330 def __iter__(self) -> Iterator[Rhs]:
331 yield self.rhs
335 def __init__(self) -> None:
338 def __repr__(self) -> str:
341 def __str__(self) -> str:
344 def __iter__(self) -> Iterator[Tuple[str, str]]:
348 def __eq__(self, other: object) -> bool:
353 def initial_names(self) -> AbstractSet[str]: