Lines Matching refs:self
52 def __repr__(self):
59 def __repr__(self):
66 def __repr__(self):
311 def __init__(self):
315 self.declarations = []
319 self.initializers = []
323 self.modifications = []
327 self.keywords = []
331 self.format_units = []
334 self.parse_arguments = []
337 self.impl_parameters = []
340 self.impl_arguments = []
344 self.return_value = "return_value"
350 self.return_conversion = []
356 self.post_parsing = []
359 self.cleanup = []
371 def __init__(self):
372 self.counts = collections.Counter()
374 def get_value(self, key, args, kwargs):
375 self.counts[key] += 1
385 def __init__(self, filename):
389 def render(self, clinic, signatures):
392 def parse_line(self, line):
395 def validate(self):
398 Ensures that the string found at getattr(self, attr)
404 self.fmt = "{dsl_name} {a} {b}"
407 self.assert_only_one('fmt', 'a', 'b')
410 self.assert_only_one('fmt', 'a')
413 self.assert_only_one('fmt', 'a', 'b', 'c')
417 self.fmt2 = '{dsl_name} {a} {a}'
418 self.assert_only_one('fmt2', 'a')
423 line = getattr(self, attr)
429 self.__class__.__name__, attr, name))
432 self.__class__.__name__, attr, name))
447 field = "arguments" if "{arguments}" in self.checksum_line else "checksum"
606 def __init__(self, filename):
608 self.cpp = cpp.Monitor(filename)
609 self.cpp.fail = fail
611 def parse_line(self, line):
612 self.cpp.writeline(line)
614 def render(self, clinic, signatures):
621 return self.render_function(clinic, function)
623 def docstring_for_c_string(self, f):
643 def output_templates(self, f):
1026 "parameter (after self)")
1159 conditional = self.cpp.condition()
1217 def render_option_group_parsing(self, f, template_dict):
1288 lines = [self.group_to_variable_name(g) + " = 1;" for g in group_ids]
1310 def render_function(self, clinic, f):
1317 assert f.parameters, "We should always have a 'self' at this point!"
1321 templates = self.output_templates(f)
1325 assert isinstance(f_self.converter, self_converter), "No self parameter in " + repr(f.full_name) + "!"
1335 # offset i by -1 because first_optional needs to ignore self
1350 group_name = self.group_to_variable_name(group)
1398 template_dict['docstring'] = self.docstring_for_c_string(f)
1432 self.render_option_group_parsing(f, template_dict)
1542 def __init__(self, input, dsl_name=None, signatures=None, output=None, indent='', preindent=''):
1544 self.input = input
1545 self.dsl_name = dsl_name
1546 self.signatures = signatures or []
1547 self.output = output
1548 self.indent = indent
1549 self.preindent = preindent
1551 def __repr__(self):
1552 dsl_name = self.dsl_name or "text"
1559 "<Block ", dsl_name, " input=", summarize(self.input), " output=", summarize(self.output), ">"))
1568 def __init__(self, input, language, *, verify=True):
1577 self.input = collections.deque(reversed(input.splitlines(keepends=True)))
1578 self.block_start_line_number = self.line_number = 0
1580 self.language = language
1583 self.find_start_re = create_regex(before, after, whole_line=False)
1584 self.start_re = create_regex(before, after)
1585 self.verify = verify
1586 self.last_checksum_re = None
1587 self.last_dsl_name = None
1588 self.dsl_name = None
1589 self.first_block = True
1591 def __iter__(self):
1592 return self
1594 def __next__(self):
1596 if not self.input:
1599 if self.dsl_name:
1600 return_value = self.parse_clinic_block(self.dsl_name)
1601 self.dsl_name = None
1602 self.first_block = False
1604 block = self.parse_verbatim_block()
1605 if self.first_block and not block.input:
1607 self.first_block = False
1611 def is_start_line(self, line):
1612 match = self.start_re.match(line.lstrip())
1615 def _line(self, lookahead=False):
1616 self.line_number += 1
1617 line = self.input.pop()
1619 self.language.parse_line(line)
1622 def parse_verbatim_block(self):
1624 self.block_start_line_number = self.line_number
1626 while self.input:
1627 line = self._line()
1628 dsl_name = self.is_start_line(line)
1630 self.dsl_name = dsl_name
1636 def parse_clinic_block(self, dsl_name):
1638 self.block_start_line_number = self.line_number + 1
1639 stop_line = self.language.stop_line.format(dsl_name=dsl_name)
1640 body_prefix = self.language.body_prefix.format(dsl_name=dsl_name)
1657 while self.input:
1658 line = self._line()
1659 if is_stop_line(line) or self.is_start_line(line):
1668 if self.last_dsl_name == dsl_name:
1669 checksum_re = self.last_checksum_re
1671 before, _, after = self.language.checksum_line.format(dsl_name=dsl_name, arguments='{arguments}').partition('{arguments}')
1674 self.last_dsl_name = dsl_name
1675 self.last_checksum_re = checksum_re
1680 while self.input:
1681 line = self._line(lookahead=True)
1687 if self.is_start_line(line):
1699 if self.verify:
1717 self.line_number -= len(output_lines)
1718 self.input.extend(reversed(output_lines))
1726 def __init__(self, language, f=None):
1727 self.language = language
1728 self.f = f or io.StringIO()
1730 def print_block(self, block):
1734 write = self.f.write
1742 write(self.language.start_line.format(dsl_name=dsl_name))
1745 body_prefix = self.language.body_prefix.format(dsl_name=dsl_name)
1754 write(self.language.stop_line.format(dsl_name=dsl_name))
1765 write(self.language.checksum_line.format(dsl_name=dsl_name, arguments=arguments))
1768 def write(self, text):
1769 self.f.write(text)
1783 def __init__(self):
1784 self._start = 0
1785 self._array = []
1786 self._constructor = _text_accumulator
1788 def __getitem__(self, i):
1789 i -= self._start
1791 self._start += i
1792 prefix = [self._constructor() for x in range(-i)]
1793 self._array = prefix + self._array
1795 while i >= len(self._array):
1796 self._array.append(self._constructor())
1797 return self._array[i]
1799 def clear(self):
1800 for ta in self._array:
1803 def dump(self):
1804 texts = [ta.output() for ta in self._array]
1809 def __init__(self, name, type, clinic, *args):
1810 self.name = name
1811 self.type = type
1812 self.clinic = clinic
1831 self.filename = args[0].format_map(d)
1833 self.buffers = BufferSeries()
1835 def __repr__(self):
1836 if self.type == 'file':
1837 file_repr = " " + repr(self.filename)
1840 return "".join(("<Destination ", self.name, " ", self.type, file_repr, ">"))
1842 def clear(self):
1843 if self.type != 'buffer':
1844 fail("Can't clear destination" + self.name + " , it's not of type buffer")
1845 self.buffers.clear()
1847 def dump(self):
1848 return self.buffers.dump()
1951 def __init__(self, language, printer=None, *, verify=True, filename=None):
1954 self.parsers = {}
1955 self.language = language
1958 self.printer = printer or BlockPrinter(language)
1959 self.verify = verify
1960 self.filename = filename
1961 self.modules = collections.OrderedDict()
1962 self.classes = collections.OrderedDict()
1963 self.functions = []
1965 self.line_prefix = self.line_suffix = ''
1967 self.destinations = {}
1968 self.add_destination("block", "buffer")
1969 self.add_destination("suppress", "suppress")
1970 self.add_destination("buffer", "buffer")
1972 self.add_destination("file", "file", "{dirname}/clinic/{basename}.h")
1974 d = self.get_destination_buffer
1975 self.destination_buffers = collections.OrderedDict((
1988 self.destination_buffers_stack = []
1989 self.ifndef_symbols = set()
1991 self.presets = {}
1993 for line in self.presets_text.strip().split('\n'):
1999 self.presets[value] = preset = collections.OrderedDict()
2006 buffer = self.get_destination_buffer(value, index)
2009 for name in self.destination_buffers:
2013 assert name in self.destination_buffers
2017 clinic = self
2019 def add_destination(self, name, type, *args):
2020 if name in self.destinations:
2022 self.destinations[name] = Destination(name, type, self, *args)
2024 def get_destination(self, name):
2025 d = self.destinations.get(name)
2030 def get_destination_buffer(self, name, item=0):
2031 d = self.get_destination(name)
2034 def parse(self, input):
2035 printer = self.printer
2036 self.block_parser = BlockParser(input, self.language, verify=self.verify)
2037 for block in self.block_parser:
2040 if dsl_name not in self.parsers:
2042 self.parsers[dsl_name] = parsers[dsl_name](self)
2043 parser = self.parsers[dsl_name]
2054 for name, destination in self.destinations.items():
2080 if self.verify:
2082 parser_2 = BlockParser(f.read(), language=self.language)
2090 printer_2 = BlockPrinter(self.language)
2097 printer_2 = BlockPrinter(self.language)
2098 parser_2 = BlockParser(text, self.language)
2113 def _module_and_class(self, fields):
2117 the module object could actually be self (a clinic object).
2122 parent = module = self
2182 def __init__(self, clinic):
2185 def parse(self, block):
2193 def __init__(self, name, module=None):
2194 self.name = name
2195 self.module = self.parent = module
2197 self.modules = collections.OrderedDict()
2198 self.classes = collections.OrderedDict()
2199 self.functions = []
2201 def __repr__(self):
2202 return "<clinic.Module " + repr(self.name) + " at " + str(id(self)) + ">"
2205 def __init__(self, name, module=None, cls=None, typedef=None, type_object=None):
2206 self.name = name
2207 self.module = module
2208 self.cls = cls
2209 self.typedef = typedef
2210 self.type_object = type_object
2211 self.parent = cls or module
2213 self.classes = collections.OrderedDict()
2214 self.functions = []
2216 def __repr__(self):
2217 return "<clinic.Class " + repr(self.name) + " at " + str(id(self)) + ">"
2307 def __init__(self, parameters=None, *, name,
2313 self.parameters = parameters or collections.OrderedDict()
2314 self.return_annotation = return_annotation
2315 self.name = name
2316 self.full_name = full_name
2317 self.module = module
2318 self.cls = cls
2319 self.parent = cls or module
2320 self.c_basename = c_basename
2321 self.return_converter = return_converter
2322 self.docstring = docstring or ''
2323 self.kind = kind
2324 self.coexist = coexist
2325 self.self_converter = None
2330 self.docstring_only = docstring_only
2332 self.rendered_parameters = None
2336 def render_parameters(self):
2337 if not self.__render_parameters__:
2338 self.__render_parameters__ = l = []
2339 for p in self.parameters.values():
2343 return self.__render_parameters__
2346 def methoddef_flags(self):
2347 if self.kind in (METHOD_INIT, METHOD_NEW):
2350 if self.kind == CLASS_METHOD:
2352 elif self.kind == STATIC_METHOD:
2355 assert self.kind == CALLABLE, "unknown kind: " + repr(self.kind)
2356 if self.coexist:
2360 def __repr__(self):
2361 return '<clinic.Function ' + self.name + '>'
2363 def copy(self, **overrides):
2365 'name': self.name, 'module': self.module, 'parameters': self.parameters,
2366 'cls': self.cls, 'c_basename': self.c_basename,
2367 'full_name': self.full_name,
2368 'return_converter': self.return_converter, 'return_annotation': self.return_annotation,
2369 'docstring': self.docstring, 'kind': self.kind, 'coexist': self.coexist,
2370 'docstring_only': self.docstring_only,
2388 def __init__(self, name, kind, *, default=inspect.Parameter.empty,
2391 self.name = name
2392 self.kind = kind
2393 self.default = default
2394 self.function = function
2395 self.converter = converter
2396 self.annotation = annotation
2397 self.docstring = docstring or ''
2398 self.group = group
2400 def __repr__(self):
2401 return '<clinic.Parameter ' + self.name + '>'
2403 def is_keyword_only(self):
2404 return self.kind == inspect.Parameter.KEYWORD_ONLY
2406 def is_positional_only(self):
2407 return self.kind == inspect.Parameter.POSITIONAL_ONLY
2409 def is_vararg(self):
2410 return self.kind == inspect.Parameter.VAR_POSITIONAL
2412 def is_optional(self):
2413 return not self.is_vararg() and (self.default is not unspecified)
2415 def copy(self, **overrides):
2417 'name': self.name, 'kind': self.kind, 'default':self.default,
2418 'function': self.function, 'converter': self.converter, 'annotation': self.annotation,
2419 'docstring': self.docstring, 'group': self.group,
2423 converter = copy.copy(self.converter)
2428 def get_displayname(self, i):
2431 if not self.is_positional_only():
2432 return '''"argument '{}'"'''.format(self.name)
2439 def __init__(self, message):
2440 self.__message__ = message
2442 def __repr__(self):
2443 return '<LandMine ' + repr(self.__message__) + ">"
2445 def __getattribute__(self, name):
2449 fail("Stepped on a land mine, trying to access attribute " + repr(name) + ":\n" + self.__message__)
2491 For the init function, self, name, function, and default
2582 # The name used for a "self" parameter must be one of
2583 # self, type, or module; however users can set their own.
2590 def __init__(self, name, py_name, function, default=unspecified, *, c_default=None, py_default=None, annotation=unspecified, **kwargs):
2591 self.name = ensure_legal_c_identifier(name)
2592 self.py_name = py_name
2595 if self.default_type and not isinstance(default, (self.default_type, Unknown)):
2596 if isinstance(self.default_type, type):
2597 types_str = self.default_type.__name__
2599 types_str = ', '.join((cls.__name__ for cls in self.default_type))
2601 self.__class__.__name__, default, name, types_str))
2602 self.default = default
2605 self.c_default = c_default
2607 self.py_default = py_default
2616 self.function = LandMine("Don't access members of self.function inside converter_init!")
2617 self.converter_init(**kwargs)
2618 self.function = function
2620 def converter_init(self):
2623 def is_optional(self):
2624 return (self.default is not unspecified)
2626 def _render_self(self, parameter, data):
2627 self.parameter = parameter
2628 name = self.parser_name
2631 s = ("&" if self.impl_by_reference else "") + name
2633 if self.length:
2634 data.impl_arguments.append(self.length_name())
2637 data.impl_parameters.append(self.simple_declaration(by_reference=self.impl_by_reference))
2638 if self.length:
2639 data.impl_parameters.append("Py_ssize_t " + self.length_name())
2641 def _render_non_self(self, parameter, data):
2642 self.parameter = parameter
2643 name = self.name
2646 d = self.declaration(in_parser=True)
2650 initializers = self.initialize()
2655 modifications = self.modify()
2668 if self.is_optional() and '|' not in data.format_units:
2672 data.format_units.append(self.format_unit)
2675 self.parse_argument(data.parse_arguments)
2678 if post_parsing := self.post_parsing():
2682 cleanup = self.cleanup()
2686 def render(self, parameter, data):
2691 self._render_self(parameter, data)
2692 self._render_non_self(parameter, data)
2694 def length_name(self):
2696 if not self.length:
2698 return self.parser_name + "_length"
2703 def parse_argument(self, list):
2704 assert not (self.converter and self.encoding)
2705 if self.format_unit == 'O&':
2706 assert self.converter
2707 list.append(self.converter)
2709 if self.encoding:
2710 list.append(c_repr(self.encoding))
2711 elif self.subclass_of:
2712 list.append(self.subclass_of)
2714 s = ("&" if self.parse_by_reference else "") + self.name
2717 if self.length:
2718 list.append("&" + self.length_name())
2724 def simple_declaration(self, by_reference=False, *, in_parser=False):
2730 prototype = [self.type]
2731 if by_reference or not self.type.endswith('*'):
2736 name = self.parser_name
2738 name = self.name
2742 def declaration(self, *, in_parser=False):
2746 declaration = [self.simple_declaration(in_parser=True)]
2747 default = self.c_default
2748 if not default and self.parameter.group:
2749 default = self.c_ignored_default
2754 if self.length:
2756 declaration.append(self.length_name())
2760 def initialize(self):
2768 def modify(self):
2776 def post_parsing(self):
2784 def cleanup(self):
2792 def pre_render(self):
2796 You are permitted to examine self.function here.
2800 def parse_arg(self, argname, displayname):
2801 if self.format_unit == 'O&':
2806 """.format(argname=argname, paramname=self.parser_name,
2807 converter=self.converter)
2808 if self.format_unit == 'O!':
2809 cast = '(%s)' % self.type if self.type != 'PyObject *' else ''
2810 if self.subclass_of in type_checks:
2811 typecheck, typename = type_checks[self.subclass_of]
2818 """.format(argname=argname, paramname=self.parser_name,
2827 """.format(argname=argname, paramname=self.parser_name,
2828 subclass_of=self.subclass_of, cast=cast,
2830 if self.format_unit == 'O':
2831 cast = '(%s)' % self.type if self.type != 'PyObject *' else ''
2834 """.format(argname=argname, paramname=self.parser_name, cast=cast)
2837 def set_template_dict(self, template_dict):
2841 def parser_name(self):
2842 if self.name in CLINIC_PREFIXED_ARGS: # bpo-39741
2843 return CLINIC_PREFIX + self.name
2845 return self.name
2866 def converter_init(self, *, accept={object}):
2868 self.format_unit = 'i'
2871 if self.default is not unspecified:
2872 self.default = bool(self.default)
2873 self.c_default = str(int(self.default))
2875 def parse_arg(self, argname, displayname):
2876 if self.format_unit == 'i':
2882 """.format(argname=argname, paramname=self.parser_name)
2883 elif self.format_unit == 'p':
2889 """.format(argname=argname, paramname=self.parser_name)
2901 def converter_init(self, *, type=None):
2902 self.specified_type = type
2904 def render(self, parameter, data):
2905 self._render_self(parameter, data)
2907 def set_template_dict(self, template_dict):
2908 template_dict['defining_class_name'] = self.name
2917 def converter_init(self):
2918 if isinstance(self.default, self.default_type):
2919 if len(self.default) != 1:
2920 fail("char_converter: illegal default value " + repr(self.default))
2922 self.c_default = repr(bytes(self.default))[1:]
2923 if self.c_default == '"\'"':
2924 self.c_default = r"'\''"
2926 def parse_arg(self, argname, displayname):
2927 if self.format_unit == 'c':
2939 """.format(argname=argname, paramname=self.parser_name,
2951 def converter_init(self, *, bitwise=False):
2953 self.format_unit = 'B'
2955 def parse_arg(self, argname, displayname):
2956 if self.format_unit == 'b':
2977 """.format(argname=argname, paramname=self.parser_name)
2978 elif self.format_unit == 'B':
2989 """.format(argname=argname, paramname=self.parser_name)
3000 def parse_arg(self, argname, displayname):
3001 if self.format_unit == 'h':
3022 """.format(argname=argname, paramname=self.parser_name)
3030 def converter_init(self, *, bitwise=False):
3032 self.format_unit = 'H'
3034 self.converter = '_PyLong_UnsignedShort_Converter'
3036 def parse_arg(self, argname, displayname):
3037 if self.format_unit == 'H':
3043 """.format(argname=argname, paramname=self.parser_name)
3053 def converter_init(self, *, accept={int}, type=None):
3055 self.format_unit = 'C'
3059 self.type = type
3061 def parse_arg(self, argname, displayname):
3062 if self.format_unit == 'i':
3068 """.format(argname=argname, paramname=self.parser_name)
3069 elif self.format_unit == 'C':
3083 """.format(argname=argname, paramname=self.parser_name,
3092 def converter_init(self, *, bitwise=False):
3094 self.format_unit = 'I'
3096 self.converter = '_PyLong_UnsignedInt_Converter'
3098 def parse_arg(self, argname, displayname):
3099 if self.format_unit == 'I':
3105 """.format(argname=argname, paramname=self.parser_name)
3114 def parse_arg(self, argname, displayname):
3115 if self.format_unit == 'l':
3121 """.format(argname=argname, paramname=self.parser_name)
3129 def converter_init(self, *, bitwise=False):
3131 self.format_unit = 'k'
3133 self.converter = '_PyLong_UnsignedLong_Converter'
3135 def parse_arg(self, argname, displayname):
3136 if self.format_unit == 'k':
3143 """.format(argname=argname, paramname=self.parser_name,
3153 def parse_arg(self, argname, displayname):
3154 if self.format_unit == 'L':
3160 """.format(argname=argname, paramname=self.parser_name)
3168 def converter_init(self, *, bitwise=False):
3170 self.format_unit = 'K'
3172 self.converter = '_PyLong_UnsignedLongLong_Converter'
3174 def parse_arg(self, argname, displayname):
3175 if self.format_unit == 'K':
3182 """.format(argname=argname, paramname=self.parser_name,
3190 def converter_init(self, *, accept={int}):
3192 self.format_unit = 'n'
3193 self.default_type = int
3195 self.converter = '_Py_convert_optional_to_ssize_t'
3199 def parse_arg(self, argname, displayname):
3200 if self.format_unit == 'n':
3214 """.format(argname=argname, paramname=self.parser_name)
3221 def converter_init(self, *, accept={int, NoneType}):
3223 self.converter = '_PyEval_SliceIndexNotNone'
3225 self.converter = '_PyEval_SliceIndex'
3234 def parse_arg(self, argname, displayname):
3235 if self.format_unit == 'n':
3241 """.format(argname=argname, paramname=self.parser_name)
3249 def _parse_arg(self, argname, displayname):
3255 """.format(argname=argname, paramname=self.name)
3264 def parse_arg(self, argname, displayname):
3265 if self.format_unit == 'f':
3277 """.format(argname=argname, paramname=self.parser_name)
3286 def parse_arg(self, argname, displayname):
3287 if self.format_unit == 'd':
3299 """.format(argname=argname, paramname=self.parser_name)
3309 def parse_arg(self, argname, displayname):
3310 if self.format_unit == 'D':
3316 """.format(argname=argname, paramname=self.parser_name)
3324 def converter_init(self, *, converter=None, type=None, subclass_of=None):
3328 self.format_unit = 'O&'
3329 self.converter = converter
3331 self.format_unit = 'O!'
3332 self.subclass_of = subclass_of
3335 self.type = type
3360 def converter_init(self, *, accept={str}, encoding=None, zeroes=False):
3367 self.format_unit = format_unit
3368 self.length = bool(zeroes)
3370 if self.default not in (Null, None, unspecified):
3372 self.encoding = encoding
3373 self.type = 'char *'
3376 self.c_default = "NULL"
3377 if NoneType in accept and self.c_default == "Py_None":
3378 self.c_default = "NULL"
3380 def post_parsing(self):
3381 if self.encoding:
3382 name = self.name
3385 def parse_arg(self, argname, displayname):
3386 if self.format_unit == 's':
3401 """.format(argname=argname, paramname=self.parser_name,
3403 if self.format_unit == 'z':
3423 """.format(argname=argname, paramname=self.parser_name,
3480 def parse_arg(self, argname, displayname):
3481 if self.format_unit == 'S':
3488 """.format(argname=argname, paramname=self.parser_name,
3489 type=self.type, displayname=displayname)
3497 def parse_arg(self, argname, displayname):
3498 if self.format_unit == 'Y':
3505 """.format(argname=argname, paramname=self.parser_name,
3506 type=self.type, displayname=displayname)
3514 def parse_arg(self, argname, displayname):
3515 if self.format_unit == 'U':
3525 """.format(argname=argname, paramname=self.parser_name,
3537 def converter_init(self, *, accept={str}, zeroes=False):
3541 self.length = True
3542 self.format_unit = format_unit
3544 self.accept = accept
3546 self.converter = '_PyUnicode_WideCharString_Converter'
3548 self.converter = '_PyUnicode_WideCharString_Opt_Converter'
3551 self.c_default = "NULL"
3553 def cleanup(self):
3554 if not self.length:
3559 """.format(name=self.name)
3561 def parse_arg(self, argname, argnum):
3562 if not self.length:
3563 if self.accept == {str}:
3577 """.format(argname=argname, paramname=self.name, argnum=argnum)
3578 elif self.accept == {str, NoneType}:
3597 """.format(argname=argname, paramname=self.name, argnum=argnum)
3609 def converter_init(self, *, accept={buffer}):
3610 if self.default not in (unspecified, None):
3613 self.c_default = self.c_ignored_default
3626 self.format_unit = format_unit
3628 def cleanup(self):
3629 name = self.name
3632 def parse_arg(self, argname, displayname):
3633 if self.format_unit == 'y*':
3642 """.format(argname=argname, paramname=self.parser_name,
3644 elif self.format_unit == 's*':
3663 """.format(argname=argname, paramname=self.parser_name,
3665 elif self.format_unit == 'w*':
3676 """.format(argname=argname, paramname=self.parser_name,
3684 return "PyObject *", "self"
3702 this is the default converter used for "self".
3707 def converter_init(self, *, type=None):
3708 self.specified_type = type
3710 def pre_render(self):
3711 f = self.function
3713 self.signature_name = default_name
3714 self.type = self.specified_type or self.type or default_type
3716 kind = self.function.kind
3720 self.show_in_signature = False
3739 # be self.name.
3741 # * The type of the first parameter to the impl will always be of self.type.
3744 # * The type of the first parameter to the parsing function is also self.type.
3745 # This means that if you step into the parsing function, your "self" parameter
3751 # * If self.type != "PyTypeObject *", we cast the first parameter to self.type
3757 # * If self.type != "PyObject *", we cast the first parameter to self.type
3761 def parser_type(self):
3762 return required_type_for_self_for_parser(self.function) or self.type
3764 def render(self, parameter, data):
3769 if self.function.kind == STATIC_METHOD:
3772 self._render_self(parameter, data)
3774 if self.type != self.parser_type:
3775 # insert cast to impl_argument[0], aka self.
3777 # because we render parameters in order, and self is always first.
3779 assert data.impl_arguments[0] == self.name
3780 data.impl_arguments[0] = '(' + self.type + ")" + data.impl_arguments[0]
3782 def set_template_dict(self, template_dict):
3783 template_dict['self_name'] = self.name
3784 template_dict['self_type'] = self.parser_type
3785 kind = self.function.kind
3786 cls = self.function.cls
3789 type_object = self.function.cls.type_object
3795 ).format(self.name, type_object, prefix)
3799 ).format(self.name, type_object, prefix)
3831 def __init__(self, *, py_default=None, **kwargs):
3832 self.py_default = py_default
3834 self.return_converter_init(**kwargs)
3837 sys.exit(self.__class__.__name__ + '(' + s + ')\n' + str(e))
3839 def return_converter_init(self):
3842 def declare(self, data, name="_return_value"):
3845 add(self.type)
3846 if not self.type.endswith('*'):
3852 def err_occurred_if(self, expr, data):
3855 def err_occurred_if_null_pointer(self, variable, data):
3858 def render(self, function, data):
3868 def render(self, function, data):
3869 self.declare(data)
3881 def render(self, function, data):
3882 self.declare(data)
3883 self.err_occurred_if("_return_value == -1", data)
3892 def render(self, function, data):
3893 self.declare(data)
3894 self.err_occurred_if("_return_value == {}-1".format(self.unsigned_cast), data)
3896 ''.join(('return_value = ', self.conversion_fn, '(', self.cast, '_return_value);\n')))
3909 def render(self, function, data):
3936 def render(self, function, data):
3937 self.declare(data)
3938 self.err_occurred_if("_return_value == -1.0", data)
3940 'return_value = PyFloat_FromDouble(' + self.cast + '_return_value);\n')
3966 def __init__(self):
3967 self.indents = []
3968 self.margin = None
3970 def _ensure(self):
3971 if not self.indents:
3974 def measure(self, line):
3984 self._ensure()
3985 return self.indents[-1]
3988 def infer(self, line):
3996 indent = self.measure(line)
3998 if not self.indents:
3999 self.indents.append(indent)
4000 self.margin = margin
4002 current = self.indents[-1]
4006 self.indents.append(indent)
4007 self.margin = margin
4010 if indent not in self.indents:
4014 self.indents.pop()
4015 current = self.indents[-1]
4017 self.margin = margin
4021 def depth(self):
4025 return len(self.indents)
4027 def indent(self, line):
4031 return self.margin + line
4033 def dedent(self, line):
4038 margin = self.margin
4039 indent = self.indents[-1]
4046 def __init__(self, clinic):
4047 self.clinic = clinic
4049 self.directives = {}
4050 for name in dir(self):
4054 self.directives[key] = getattr(self, name)
4059 self.directives['@' + key] = getattr(self, name)
4061 self.reset()
4063 def reset(self):
4064 self.function = None
4065 self.state = self.state_dsl_start
4066 self.parameter_indent = None
4067 self.keyword_only = False
4068 self.positional_only = False
4069 self.group = 0
4070 self.parameter_state = self.ps_start
4071 self.seen_positional_with_default = False
4072 self.indent = IndentStack()
4073 self.kind = CALLABLE
4074 self.coexist = False
4075 self.parameter_continuation = ''
4076 self.preserve_output = False
4078 def directive_version(self, required):
4083 def directive_module(self, name):
4086 module, cls = self.clinic._module_and_class(fields)
4095 self.block.signatures.append(m)
4097 def directive_class(self, name, typedef, type_object):
4100 parent = self
4103 module, cls = self.clinic._module_and_class(fields)
4111 self.block.signatures.append(c)
4113 def directive_set(self, name, value):
4122 self.clinic.__dict__[name] = value
4124 def directive_destination(self, name, command, *args):
4126 self.clinic.add_destination(name, *args)
4130 self.clinic.get_destination(name).clear()
4134 def directive_output(self, command_or_name, destination=''):
4135 fd = self.clinic.destination_buffers
4138 preset = self.clinic.presets.get(destination)
4145 self.clinic.destination_buffers_stack.append(fd.copy())
4149 if not self.clinic.destination_buffers_stack:
4151 previous_fd = self.clinic.destination_buffers_stack.pop()
4157 self.block.output.append(pprint.pformat(fd))
4158 self.block.output.append('\n')
4161 d = self.clinic.get_destination_buffer(destination)
4172 def directive_dump(self, name):
4173 self.block.output.append(self.clinic.get_destination(name).dump())
4175 def directive_printout(self, *args):
4176 self.block.output.append(' '.join(args))
4177 self.block.output.append('\n')
4179 def directive_preserve(self):
4180 if self.preserve_output:
4182 self.preserve_output = True
4184 def at_classmethod(self):
4185 if self.kind is not CALLABLE:
4187 self.kind = CLASS_METHOD
4189 def at_staticmethod(self):
4190 if self.kind is not CALLABLE:
4192 self.kind = STATIC_METHOD
4194 def at_coexist(self):
4195 if self.coexist:
4197 self.coexist = True
4199 def parse(self, block):
4200 self.reset()
4201 self.block = block
4202 self.saved_output = self.block.output
4204 block_start = self.clinic.block_parser.line_number
4206 for line_number, line in enumerate(lines, self.clinic.block_parser.block_start_line_number):
4209 self.state(line)
4211 self.next(self.state_terminal)
4212 self.state(None)
4214 block.output.extend(self.clinic.language.render(clinic, block.signatures))
4216 if self.preserve_output:
4219 block.output = self.saved_output
4238 def next(self, state, line=None):
4239 # real_print(self.state.__name__, "->", state.__name__, ", line=", line)
4240 self.state = state
4242 self.state(line)
4244 def state_dsl_start(self, line):
4245 # self.block = self.ClinicOutputBlock(self)
4246 if self.ignore_line(line):
4252 directive = self.directives.get(directive_name, None)
4260 self.next(self.state_modulename_name, line)
4262 def state_modulename_name(self, line):
4282 self.indent.infer(line)
4297 module, cls = self.clinic._module_and_class(fields)
4311 module, cls = self.clinic._module_and_class(fields)
4313 if not (existing_function.kind == self.kind and existing_function.coexist == self.coexist):
4315 self.function = existing_function.copy(name=function_name, full_name=full_name, module=module, cls=cls, c_basename=c_basename, docstring='')
4317 self.block.signatures.append(self.function)
4318 (cls or module).functions.append(self.function)
4319 self.next(self.state_function_docstring)
4344 name, legacy, kwargs = self.parse_converter(module.body[0].returns)
4356 module, cls = self.clinic._module_and_class(fields)
4363 if (self.kind != CLASS_METHOD) or (not cls):
4365 self.kind = METHOD_NEW
4367 if (self.kind != CALLABLE) or (not cls):
4369 self.kind = METHOD_INIT
4378 self.function = Function(name=function_name, full_name=full_name, module=module, cls=cls, c_basename=c_basename,
4379 return_converter=return_converter, kind=self.kind, coexist=self.coexist)
4380 self.block.signatures.append(self.function)
4382 # insert a self converter automatically
4383 type, name = correct_name_for_self(self.function)
4387 sc = self.function.self_converter = self_converter(name, name, self.function, **kwargs)
4388 p_self = Parameter(sc.name, inspect.Parameter.POSITIONAL_ONLY, function=self.function, converter=sc)
4389 self.function.parameters[sc.name] = p_self
4391 (cls or module).functions.append(self.function)
4392 self.next(self.state_parameters_start)
4463 def state_parameters_start(self, line):
4464 if self.ignore_line(line):
4468 if not self.indent.infer(line):
4469 return self.next(self.state_function_docstring, line)
4471 self.parameter_continuation = ''
4472 return self.next(self.state_parameter, line)
4475 def to_required(self):
4479 if self.parameter_state != self.ps_required:
4480 self.parameter_state = self.ps_required
4481 for p in self.function.parameters.values():
4484 def state_parameter(self, line):
4485 if self.parameter_continuation:
4486 line = self.parameter_continuation + ' ' + line.lstrip()
4487 self.parameter_continuation = ''
4489 if self.ignore_line(line):
4492 assert self.indent.depth == 2
4493 indent = self.indent.infer(line)
4496 return self.next(self.state_function_docstring, line)
4500 return self.next(self.state_parameter_docstring_start, line)
4504 self.parameter_continuation = line[:-1]
4510 self.parse_special_symbol(line)
4513 if self.parameter_state in (self.ps_start, self.ps_required):
4514 self.to_required()
4515 elif self.parameter_state == self.ps_left_square_before:
4516 self.parameter_state = self.ps_group_before
4517 elif self.parameter_state == self.ps_group_before:
4518 if not self.group:
4519 self.to_required()
4520 elif self.parameter_state in (self.ps_group_after, self.ps_optional):
4523 fail("Function " + self.function.name + " has an unsupported group configuration. (Unexpected state " + str(self.parameter_state) + ".a)")
4561 fail("Function " + self.function.name + " has an invalid parameter declaration:\n\t" + line)
4566 fail("Function " + self.function.name + " has an invalid parameter declaration (comma?):\n\t" + line)
4568 fail("Function " + self.function.name + " has an invalid parameter declaration (default value?):\n\t" + line)
4570 fail("Function " + self.function.name + " has an invalid parameter declaration (**kwargs?):\n\t" + line)
4580 name, legacy, kwargs = self.parse_converter(parameter.annotation)
4583 if self.parameter_state == self.ps_optional:
4596 if self.parameter_state == self.ps_required:
4597 self.parameter_state = self.ps_optional
4611 def bad_node(self, node):
4612 self.bad = True
4713 converter = dict[name](c_name or parameter_name, parameter_name, self.function, value, **kwargs)
4717 elif self.keyword_only:
4723 if len(self.function.parameters) == 1:
4724 if (self.parameter_state != self.ps_required):
4725 fail("A 'self' parameter cannot be marked optional.")
4727 fail("A 'self' parameter cannot have a default value.")
4728 if self.group:
4729 fail("A 'self' parameter cannot be in an optional group.")
4731 self.parameter_state = self.ps_start
4732 self.function.parameters.clear()
4734 fail("A 'self' parameter, if specified, must be the very first thing in the parameter block.")
4737 _lp = len(self.function.parameters)
4739 if (self.parameter_state != self.ps_required):
4743 if self.group:
4746 fail("A 'defining_class' parameter, if specified, must either be the first thing in the parameter block, or come just after 'self'.")
4749 p = Parameter(parameter_name, kind, function=self.function, converter=converter, default=value, group=self.group)
4751 names = [k.name for k in self.function.parameters.values()]
4758 self.function.parameters[key] = p
4760 def parse_converter(self, annotation):
4781 def parse_special_symbol(self, symbol):
4783 if self.keyword_only:
4784 fail("Function " + self.function.name + " uses '*' more than once.")
4785 self.keyword_only = True
4787 if self.parameter_state in (self.ps_start, self.ps_left_square_before):
4788 self.parameter_state = self.ps_left_square_before
4789 elif self.parameter_state in (self.ps_required, self.ps_group_after):
4790 self.parameter_state = self.ps_group_after
4792 fail("Function " + self.function.name + " has an unsupported group configuration. (Unexpected state " + str(self.parameter_state) + ".b)")
4793 self.group += 1
4794 self.function.docstring_only = True
4796 if not self.group:
4797 fail("Function " + self.function.name + " has a ] without a matching [.")
4798 if not any(p.group == self.group for p in self.function.parameters.values()):
4799 fail("Function " + self.function.name + " has an empty group.\nAll groups must contain at least one parameter.")
4800 self.group -= 1
4801 if self.parameter_state in (self.ps_left_square_before, self.ps_group_before):
4802 self.parameter_state = self.ps_group_before
4803 elif self.parameter_state in (self.ps_group_after, self.ps_right_square_after):
4804 self.parameter_state = self.ps_right_square_after
4806 fail("Function " + self.function.name + " has an unsupported group configuration. (Unexpected state " + str(self.parameter_state) + ".c)")
4808 if self.positional_only:
4809 fail("Function " + self.function.name + " uses '/' more than once.")
4810 self.positional_only = True
4813 if (self.parameter_state not in (self.ps_required, self.ps_optional, self.ps_right_square_after, self.ps_group_before)) or self.group:
4814 fail("Function " + self.function.name + " has an unsupported group configuration. (Unexpected state " + str(self.parameter_state) + ".d)")
4815 if self.keyword_only:
4816 fail("Function " + self.function.name + " mixes keyword-only and positional-only parameters, which is unsupported.")
4818 for p in self.function.parameters.values():
4822 fail("Function " + self.function.name + " mixes keyword-only and positional-only parameters, which is unsupported.")
4825 def state_parameter_docstring_start(self, line):
4826 self.parameter_docstring_indent = len(self.indent.margin)
4827 assert self.indent.depth == 3
4828 return self.next(self.state_parameter_docstring, line)
4833 def state_parameter_docstring(self, line):
4838 indent = self.indent.measure(line)
4839 if indent < self.parameter_docstring_indent:
4840 self.indent.infer(line)
4841 assert self.indent.depth < 3
4842 if self.indent.depth == 2:
4844 return self.next(self.state_parameter, line)
4845 assert self.indent.depth == 1
4846 return self.next(self.state_function_docstring, line)
4848 assert self.function.parameters
4849 last_parameter = next(reversed(list(self.function.parameters.values())))
4856 new_docstring += self.indent.dedent(line)
4861 def state_function_docstring(self, line):
4862 if self.group:
4863 fail("Function " + self.function.name + " has a ] without a matching [.")
4869 new_docstring = self.function.docstring
4873 line = self.indent.dedent(line).rstrip()
4877 self.function.docstring = new_docstring
4879 def format_docstring(self):
4880 f = self.function
4904 assert parameters, "We should always have a self parameter. " + repr(f)
4906 # self is always positional-only.
4981 # so let's not print the "self" parameter
4998 # annotate first parameter as being a "self".
5001 # and it's already bound, the self parameter
5007 # note: we don't print "self" for __init__,
5128 def state_terminal(self, line):
5134 if not self.function:
5137 if self.keyword_only:
5138 values = self.function.parameters.values()
5145 fail("Function " + self.function.name + " specifies '*' without any parameters afterwards.")
5148 for name, value in self.function.parameters.items():
5153 self.function.docstring = self.format_docstring()