Lines Matching defs:name
152 # of the name in C.
207 name, curly, trailing = trailing.partition('}')
208 if not curly or name not in kwargs:
214 fail("Text found after {" + name + "} block marker! It must be on a line by itself.")
216 fail("Non-whitespace characters found before {" + name + "} block marker! It must be on a line by itself.")
218 value = kwargs[name]
342 # For return converters: the name of the variable that
429 self.__class__.__name__, attr, name))
432 self.__class__.__name__, attr, name))
434 for name, count in fcf.counts.items():
435 if name in fields:
440 for name in fields:
441 if fcf.counts.get(name) != 1:
703 {{"{name}", {methoddef_cast}{c_basename}{methoddef_cast_end}, {methoddef_flags}, {c_basename}__doc__}},
803 PyErr_SetString(PyExc_TypeError, "{name}() takes no arguments");
842 if parameters[0].name == argname:
853 if (!PyArg_Parse(%s, "{format_units}:{name}", {parse_arguments})) {{
892 if (!_PyArg_CheckPositional("{name}", %s, %d, %s)) {{
931 #print('Cannot convert %s %r for %s' % (p.converter.__class__.__name__, p.converter.format_unit, p.converter.name), file=sys.stderr)
949 if (!_PyArg_ParseStack(args, nargs, "{format_units}:{name}",
956 if (!PyArg_ParseTuple(args, "{format_units}:{name}",
986 static _PyArg_Parser _parser = {{NULL, _keywords, "{name}", 0}};
1004 static _PyArg_Parser _parser = {{NULL, _keywords, "{name}", 0}};
1030 #print('Cannot convert %s %r for %s' % (p.converter.__class__.__name__, p.converter.format_unit, p.converter.name), file=sys.stderr)
1087 'static _PyArg_Parser _parser = {{"{format_units}:{name}", _keywords, 0}};')
1129 if ({self_type_check}!_PyArg_NoKeywords("{name}", kwargs)) {{
1135 if ({self_type_check}!_PyArg_NoPositional("{name}", args)) {{
1205 for name, value in d.items():
1206 assert value is not None, "got a None value for template " + repr(name)
1209 d2[name] = value
1279 d['name'] = f.name
1293 if (!PyArg_ParseTuple(args, "{format_units}:{name}", {parse_arguments})) {{
1379 name = f.cls.name
1381 name = f.name
1383 template_dict['name'] = name
1435 for name, destination in clinic.destination_buffers.items():
1436 template = templates[name]
1460 if name in {"impl_prototype", "impl_definition"}:
1694 name, equals, value = field.partition('=')
1697 d[name.strip()] = value.strip()
1809 def __init__(self, name, type, clinic, *args):
1810 self.name = name
1815 fail("Invalid destination type " + repr(type) + " for " + name + " , must be " + ', '.join(valid_types))
1818 fail("Not enough arguments for destination " + name + " new " + type)
1820 fail("Too many arguments for destination " + name + " new " + type)
1840 return "".join(("<Destination ", self.name, " ", self.type, file_repr, ">"))
1844 fail("Can't clear destination" + self.name + " , it's not of type buffer")
1852 # "languages" maps the name of the language ("C", "Python").
1855 extensions = { name: CLanguage for name in "c cc cpp cxx h hh hpp hxx".split() }
1861 # def foo(name, default, *, ...)
1997 name, value, *options = line.split()
1998 if name == 'preset':
2008 if name == 'everything':
2009 for name in self.destination_buffers:
2010 preset[name] = buffer
2013 assert name in self.destination_buffers
2014 preset[name] = buffer
2019 def add_destination(self, name, type, *args):
2020 if name in self.destinations:
2021 fail("Destination already exists: " + repr(name))
2022 self.destinations[name] = Destination(name, type, self, *args)
2024 def get_destination(self, name):
2025 d = self.destinations.get(name)
2027 fail("Destination does not exist: " + repr(name))
2030 def get_destination_buffer(self, name, item=0):
2031 d = self.get_destination(name)
2054 for name, destination in self.destinations.items():
2064 block.input = "dump " + name + "\n"
2065 warn("Destination buffer " + repr(name) + " not empty at end of file, emptying.")
2193 def __init__(self, name, module=None):
2194 self.name = name
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
2217 return "<clinic.Class " + repr(self.name) + " at " + str(id(self)) + ">"
2307 def __init__(self, parameters=None, *, name,
2315 self.name = name
2361 return '<clinic.Function ' + self.name + '>'
2365 'name': self.name, 'module': self.module, 'parameters': self.parameters,
2376 for name, value in f.parameters.items():
2378 parameters[name] = value
2388 def __init__(self, name, kind, *, default=inspect.Parameter.empty,
2391 self.name = name
2401 return '<clinic.Parameter ' + self.name + '>'
2417 'name': self.name, 'kind': self.kind, 'default':self.default,
2432 return '''"argument '{}'"'''.format(self.name)
2445 def __getattribute__(self, name):
2446 if name in ('__repr__', '__message__'):
2447 return super().__getattribute__(name)
2448 # raise RuntimeError(repr(name))
2449 fail("Stepped on a land mine, trying to access attribute " + repr(name) + ":\n" + self.__message__)
2452 def add_c_converter(f, name=None):
2453 if not name:
2454 name = f.__name__
2455 if not name.endswith('_converter'):
2457 name = name[:-len('_converter')]
2458 converters[name] = f
2485 def __init__(cls, name, bases, classdict):
2491 For the init function, self, name, function, and default
2496 # The C name to use for this variable.
2497 name = None
2499 # The Python name to use for this variable.
2542 # Should Argument Clinic add a '&' before the name of
2546 # Should Argument Clinic add a '&' before the name of
2581 # Overrides the name used in a text signature.
2582 # The name used for a "self" parameter must be one of
2585 # name, *just* for the text signature.
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)
2601 self.__class__.__name__, default, name, types_str))
2628 name = self.parser_name
2631 s = ("&" if self.impl_by_reference else "") + name
2643 name = self.name
2652 data.initializers.append('/* initializers for ' + name + ' */\n' + initializers.rstrip())
2657 data.modifications.append('/* modifications for ' + name + ' */\n' + modifications.rstrip())
2665 data.keywords.append(parameter.name)
2679 data.post_parsing.append('/* Post parse cleanup for ' + name + ' */\n' + post_parsing.rstrip() + '\n')
2684 data.cleanup.append('/* Cleanup for ' + name + ' */\n' + cleanup.rstrip() + "\n")
2695 """Computes the name of the associated "length" variable."""
2714 s = ("&" if self.parse_by_reference else "") + self.name
2736 name = self.parser_name
2738 name = self.name
2739 prototype.append(name)
2814 _PyArg_BadArgument("{{name}}", {displayname}, "{typename}", {argname});
2823 _PyArg_BadArgument("{{name}}", {displayname}, ({subclass_of})->tp_name, {argname});
2842 if self.name in CLINIC_PREFIXED_ARGS: # bpo-39741
2843 return CLINIC_PREFIX + self.name
2845 return self.name
2908 template_dict['defining_class_name'] = self.name
2936 _PyArg_BadArgument("{{name}}", {displayname}, "a byte string of length 1", {argname});
3072 _PyArg_BadArgument("{{name}}", {displayname}, "a unicode character", {argname});
3079 _PyArg_BadArgument("{{name}}", {displayname}, "a unicode character", {argname});
3139 _PyArg_BadArgument("{{name}}", {displayname}, "int", {argname});
3178 _PyArg_BadArgument("{{name}}", {displayname}, "int", {argname});
3255 """.format(argname=argname, paramname=self.name)
3382 name = self.name
3383 return f"PyMem_FREE({name});\n"
3389 _PyArg_BadArgument("{{name}}", {displayname}, "str", {argname});
3420 _PyArg_BadArgument("{{name}}", {displayname}, "str or None", {argname});
3484 _PyArg_BadArgument("{{name}}", {displayname}, "bytes", {argname});
3501 _PyArg_BadArgument("{{name}}", {displayname}, "bytearray", {argname});
3518 _PyArg_BadArgument("{{name}}", {displayname}, "str", {argname});
3557 PyMem_Free((void *){name});
3559 """.format(name=self.name)
3566 _PyArg_BadArgument("{{name}}", {argnum}, "str", {argname});
3577 """.format(argname=argname, paramname=self.name, argnum=argnum)
3594 _PyArg_BadArgument("{{name}}", {argnum}, "str or None", {argname});
3597 """.format(argname=argname, paramname=self.name, argnum=argnum)
3629 name = self.name
3630 return "".join(["if (", name, ".obj) {\n PyBuffer_Release(&", name, ");\n}\n"])
3639 _PyArg_BadArgument("{{name}}", {displayname}, "contiguous buffer", {argname});
3659 _PyArg_BadArgument("{{name}}", {displayname}, "contiguous buffer", {argname});
3669 _PyArg_BadArgument("{{name}}", {displayname}, "read-write bytes-like object", {argname});
3673 _PyArg_BadArgument("{{name}}", {displayname}, "contiguous buffer", {argname});
3738 # * The name of the first parameter to the impl and the parsing function will always
3739 # be self.name.
3779 assert data.impl_arguments[0] == self.name
3783 template_dict['self_name'] = self.name
3795 ).format(self.name, type_object, prefix)
3799 ).format(self.name, type_object, prefix)
3806 def add_c_return_converter(f, name=None):
3807 if not name:
3808 name = f.__name__
3809 if not name.endswith('_return_converter'):
3811 name = name[:-len('_return_converter')]
3812 return_converters[name] = f
3817 def __init__(cls, name, bases, classdict):
3836 s = ', '.join(name + '=' + repr(value) for name, value in kwargs.items())
3842 def declare(self, data, name="_return_value"):
3848 add(name + ';')
3850 data.return_value = name
4050 for name in dir(self):
4052 _, s, key = name.partition("directive_")
4054 self.directives[key] = getattr(self, name)
4057 _, s, key = name.partition("at_")
4059 self.directives['@' + key] = getattr(self, name)
4083 def directive_module(self, name):
4084 fields = name.split('.')
4090 if name in module.classes:
4091 fail("Already defined module " + repr(name) + "!")
4093 m = Module(name, module)
4094 module.modules[name] = m
4097 def directive_class(self, name, typedef, type_object):
4098 fields = name.split('.')
4101 name = fields.pop()
4106 if name in parent.classes:
4107 fail("Already defined class " + repr(name) + "!")
4109 c = Class(name, module, cls, typedef, type_object)
4110 parent.classes[name] = c
4113 def directive_set(self, name, value):
4114 if name not in ("line_prefix", "line_suffix"):
4115 fail("unknown variable", repr(name))
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()
4164 for name in list(fd):
4165 fd[name] = d
4169 fail("Invalid command / destination name " + repr(command_or_name) + ", must be one of:\n preset push pop print everything " + " ".join(fd))
4172 def directive_dump(self, name):
4173 self.block.output.append(self.clinic.get_destination(name).dump())
4300 if existing_function.name == function_name:
4315 self.function = existing_function.copy(name=function_name, full_name=full_name, module=module, cls=cls, c_basename=c_basename, docstring='')
4329 fail("Illegal function name: {}".format(full_name))
4344 name, legacy, kwargs = self.parse_converter(module.body[0].returns)
4347 .format(name))
4348 if name not in return_converters:
4349 fail("No available return converter called " + repr(name))
4350 return_converter = return_converters[name](**kwargs)
4378 self.function = Function(name=function_name, full_name=full_name, module=module, cls=cls, c_basename=c_basename,
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
4523 fail("Function " + self.function.name + " has an unsupported group configuration. (Unexpected state " + str(self.parameter_state) + ".a)")
4527 name, have_as_token, trailing = line.partition(' as ')
4529 name = name.strip()
4530 if ' ' not in name:
4536 name += ':'
4538 fields[0] = name
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)
4709 if name not in dict:
4710 fail('{} is not a valid {}converter'.format(name, legacy_str))
4711 # if you use a c_name for the parameter, we just give that name to the converter
4712 # but the parameter object gets the python name
4713 converter = dict[name](c_name or parameter_name, parameter_name, self.function, value, **kwargs)
4751 names = [k.name for k in self.function.parameters.values()]
4755 fail(f"Parameter '{parameter_name}' requires a custom C name")
4773 fail("Annotations must be either a name, a function call, or a string.")
4775 name = annotation.func.id
4779 return name, False, kwargs
4784 fail("Function " + self.function.name + " uses '*' more than once.")
4792 fail("Function " + self.function.name + " has an unsupported group configuration. (Unexpected state " + str(self.parameter_state) + ".b)")
4797 fail("Function " + self.function.name + " has a ] without a matching [.")
4799 fail("Function " + self.function.name + " has an empty group.\nAll groups must contain at least one parameter.")
4806 fail("Function " + self.function.name + " has an unsupported group configuration. (Unexpected state " + str(self.parameter_state) + ".c)")
4809 fail("Function " + self.function.name + " uses '/' more than once.")
4814 fail("Function " + self.function.name + " has an unsupported group configuration. (Unexpected state " + str(self.parameter_state) + ".d)")
4816 fail("Function " + self.function.name + " mixes keyword-only and positional-only parameters, which is unsupported.")
4822 fail("Function " + self.function.name + " mixes keyword-only and positional-only parameters, which is unsupported.")
4863 fail("Function " + self.function.name + " has a ] without a matching [.")
4895 # classes get *just* the name of the class
4898 add(f.cls.name)
4900 add(f.name)
4976 assert p.name
5018 name = p.converter.signature_name or p.name
5019 p_add(name)
5070 add(p.name)
5145 fail("Function " + self.function.name + " specifies '*' without any parameters afterwards.")
5148 for name, value in self.function.parameters.items():
5214 for name in module:
5219 if name in ignored:
5221 if name.endswith(suffix):
5222 ids.append((name, name[:-len(suffix)]))
5238 for name, short_name in ids:
5240 for name, short_name in sorted(ids, key=lambda x: x[1].lower()):
5241 cls = module[name]