Debian Codegraph @

Tools/clinic/libclinic/app.py

raw
1 from __future__ import annotations
2 import os
3
4 from collections.abc import Callable, Sequence
5 from typing import Any, TYPE_CHECKING
6
7
8 import libclinic
9 from libclinic import fail, warn
10 from libclinic.function import Class
11 from libclinic.block_parser import Block, BlockParser
12 from libclinic.codegen import BlockPrinter, Destination, CodeGen
13 from libclinic.parser import Parser, PythonParser
14 from libclinic.dsl_parser import DSLParser
15 if TYPE_CHECKING:
16 from libclinic.clanguage import CLanguage
17 from libclinic.function import (
18 Module, Function, ClassDict, ModuleDict)
19 from libclinic.codegen import DestinationDict
20
21
22 # maps strings to callables.
23 # the callable should return an object
24 # that implements the clinic parser
25 # interface (__init__ and parse).
26 #
27 # example parsers:
28 # "clinic", handles the Clinic DSL
29 # "python", handles running Python code
30 #
31 parsers: dict[str, Callable[[Clinic], Parser]] = {
32 'clinic': DSLParser,
33 'python': PythonParser,
34 }
35
36
37 class Clinic:
38
39 presets_text = """
40 preset block
41 everything block
42 methoddef_ifndef buffer 1
43 docstring_prototype suppress
44 parser_prototype suppress
45 cpp_if suppress
46 cpp_endif suppress
47
48 preset original
49 everything block
50 methoddef_ifndef buffer 1
51 docstring_prototype suppress
52 parser_prototype suppress
53 cpp_if suppress
54 cpp_endif suppress
55
56 preset file
57 everything file
58 methoddef_ifndef file 1
59 docstring_prototype suppress
60 parser_prototype suppress
61 impl_definition block
62
63 preset buffer
64 everything buffer
65 methoddef_ifndef buffer 1
66 impl_definition block
67 docstring_prototype suppress
68 impl_prototype suppress
69 parser_prototype suppress
70
71 preset partial-buffer
72 everything buffer
73 methoddef_ifndef buffer 1
74 docstring_prototype block
75 impl_prototype suppress
76 methoddef_define block
77 parser_prototype block
78 impl_definition block
79
80 """
81
82 def __init__(
83 self,
84 language: CLanguage,
85 printer: BlockPrinter | None = None,
86 *,
87 filename: str,
88 limited_capi: bool,
89 verify: bool = True,
90 ) -> None:
91 # maps strings to Parser objects.
92 # (instantiated from the "parsers" global.)
93 self.parsers: dict[str, Parser] = {}
94 self.language: CLanguage = language
95 if printer:
96 fail("Custom printers are broken right now")
97 self.printer = printer or BlockPrinter(language)
98 self.verify = verify
99 self.limited_capi = limited_capi
100 self.filename = filename
101 self.modules: ModuleDict = {}
102 self.classes: ClassDict = {}
103 self.functions: list[Function] = []
104 self.codegen = CodeGen(self.limited_capi)
105
106 self.line_prefix = self.line_suffix = ''
107
108 self.destinations: DestinationDict = {}
109 self.add_destination("block", "buffer")
110 self.add_destination("suppress", "suppress")
111 self.add_destination("buffer", "buffer")
112 if filename:
113 self.add_destination("file", "file", "{dirname}/clinic/{basename}.h")
114
115 d = self.get_destination_buffer
116 self.destination_buffers = {
117 'cpp_if': d('file'),
118 'docstring_prototype': d('suppress'),
119 'docstring_definition': d('file'),
120 'methoddef_define': d('file'),
121 'impl_prototype': d('file'),
122 'parser_prototype': d('suppress'),
123 'parser_definition': d('file'),
124 'cpp_endif': d('file'),
125 'methoddef_ifndef': d('file', 1),
126 'impl_definition': d('block'),
127 }
128
129 DestBufferType = dict[str, list[str]]
130 DestBufferList = list[DestBufferType]
131
132 self.destination_buffers_stack: DestBufferList = []
133
134 self.presets: dict[str, dict[Any, Any]] = {}
135 preset = None
136 for line in self.presets_text.strip().split('\n'):
137 line = line.strip()
138 if not line:
139 continue
140 name, value, *options = line.split()
141 if name == 'preset':
142 self.presets[value] = preset = {}
143 continue
144
145 if len(options):
146 index = int(options[0])
147 else:
148 index = 0
149 buffer = self.get_destination_buffer(value, index)
150
151 if name == 'everything':
152 for name in self.destination_buffers:
153 preset[name] = buffer
154 continue
155
156 assert name in self.destination_buffers
157 preset[name] = buffer
158
159 def add_destination(
160 self,
161 name: str,
162 type: str,
163 *args: str
164 ) -> None:
165 if name in self.destinations:
166 fail(f"Destination already exists: {name!r}")
167 self.destinations[name] = Destination(name, type, self, args)
168
169 def get_destination(self, name: str) -> Destination:
170 d = self.destinations.get(name)
171 if not d:
172 fail(f"Destination does not exist: {name!r}")
173 return d
174
175 def get_destination_buffer(
176 self,
177 name: str,
178 item: int = 0
179 ) -> list[str]:
180 d = self.get_destination(name)
181 return d.buffers[item]
182
183 def parse(self, input: str) -> str:
184 printer = self.printer
185 self.block_parser = BlockParser(input, self.language, verify=self.verify)
186 for block in self.block_parser:
187 dsl_name = block.dsl_name
188 if dsl_name:
189 if dsl_name not in self.parsers:
190 assert dsl_name in parsers, f"No parser to handle {dsl_name!r} block."
191 self.parsers[dsl_name] = parsers[dsl_name](self)
192 parser = self.parsers[dsl_name]
193 parser.parse(block)
194 printer.print_block(block)
195
196 # these are destinations not buffers
197 for name, destination in self.destinations.items():
198 if destination.type == 'suppress':
199 continue
200 output = destination.dump()
201
202 if output:
203 block = Block("", dsl_name="clinic", output=output)
204
205 if destination.type == 'buffer':
206 block.input = "dump " + name + "\n"
207 warn("Destination buffer " + repr(name) + " not empty at end of file, emptying.")
208 printer.write("\n")
209 printer.print_block(block)
210 continue
211
212 if destination.type == 'file':
213 try:
214 dirname = os.path.dirname(destination.filename)
215 try:
216 os.makedirs(dirname)
217 except FileExistsError:
218 if not os.path.isdir(dirname):
219 fail(f"Can't write to destination "
220 f"{destination.filename!r}; "
221 f"can't make directory {dirname!r}!")
222 if self.verify:
223 with open(destination.filename) as f:
224 parser_2 = BlockParser(f.read(), language=self.language)
225 blocks = list(parser_2)
226 if (len(blocks) != 1) or (blocks[0].input != 'preserve\n'):
227 fail(f"Modified destination file "
228 f"{destination.filename!r}; not overwriting!")
229 except FileNotFoundError:
230 pass
231
232 block.input = 'preserve\n'
233 includes = self.codegen.get_includes()
234
235 printer_2 = BlockPrinter(self.language)
236 printer_2.print_block(block, header_includes=includes)
237 libclinic.write_file(destination.filename,
238 printer_2.f.getvalue())
239 continue
240
241 return printer.f.getvalue()
242
243 def _module_and_class(
244 self, fields: Sequence[str]
245 ) -> tuple[Module | Clinic, Class | None]:
246 """
247 fields should be an iterable of field names.
248 returns a tuple of (module, class).
249 the module object could actually be self (a clinic object).
250 this function is only ever used to find the parent of where
251 a new class/module should go.
252 """
253 parent: Clinic | Module | Class = self
254 module: Clinic | Module = self
255 cls: Class | None = None
256
257 for idx, field in enumerate(fields):
258 if not isinstance(parent, Class):
259 if field in parent.modules:
260 parent = module = parent.modules[field]
261 continue
262 if field in parent.classes:
263 parent = cls = parent.classes[field]
264 else:
265 fullname = ".".join(fields[idx:])
266 fail(f"Parent class or module {fullname!r} does not exist.")
267
268 return module, cls
269
270 def __repr__(self) -> str:
271 return "<clinic.Clinic object>"