text = []

def output():

s = ''.join(text)

text.clear()

return s

"""

text, append, output = _text_accumulator()

joined = " ".join([str(a) for a in args])

add, output = text_accumulator()

if fail:

add("Error")

else:

add("Warning")

if clinic:

if filename is None:

filename = clinic.filename

if getattr(clinic, 'block_parser', None) and (line_number is None):

line_number = clinic.block_parser.line_number

if filename is not None:

add(' in file "' + filename + '"')

if line_number is not None:

add(" on line " + str(line_number))

add(':\n')

add(joined)

print(output())

if fail:

for old, new in (

('\\', '\\\\'), # must be first!

('"', '\\"'),

("'", "\\'"),

):

s = s.replace(old, new)

# for now, just complain if what we're given isn't legal

if not is_legal_c_identifier(s):

fail("Illegal C identifier: {}".format(s))

# but if we picked a C keyword, pick something else

if s in c_keywords:

return s + "_value"

text, add, output = _text_accumulator()

for line in s.split('\n'):

add(line.rstrip())

add('\n')

text.pop()

# double up curly-braces, this string will be used

# as part of a format_map() template later

s = s.replace('{', '{{')

s = s.replace('}', '}}')

"""

add, output = text_accumulator()

for line in s.split('\n'):

indent, curly, trailing = line.partition('{')

if not curly:

add(line)

add('\n')

continue

name, curly, trailing = trailing.partition('}')

if not curly or name not in kwargs:

add(line)

add('\n')

continue

if trailing:

fail("Text found after {" + name + "} block marker! It must be on a line by itself.")

if indent.strip():

fail("Non-whitespace characters found before {" + name + "} block marker! It must be on a line by itself.")

value = kwargs[name]

if not value:

continue

value = textwrap.indent(rstrip_lines(value), indent)

add(value)

add('\n')

"""

split = s.split('\n')

last = split.pop()

final = []

for line in split:

final.append(prefix)

final.append(line)

final.append('\n')

if last:

final.append(prefix)

final.append(last)

"""

split = s.split('\n')

last = split.pop()

final = []

for line in split:

final.append(line)

final.append(suffix)

final.append('\n')

if last:

final.append(last)

final.append(suffix)

"""Splits a version string into a tuple of integers.

version = []

accumulator = []

def flush():

if not accumulator:

raise ValueError('Unsupported version string: ' + repr(s))

version.append(int(''.join(accumulator)))

accumulator.clear()

for c in s:

if c.isdigit():

accumulator.append(c)

elif c == '.':

flush()

elif c in 'abc':

flush()

version.append('abc'.index(c) - 3)

else:

raise ValueError('Illegal character ' + repr(c) + ' in version string ' + repr(s))

flush()

iterator = itertools.zip_longest(version_splitter(version1), version_splitter(version2), fillvalue=0)

for i, (a, b) in enumerate(iterator):

if a < b:

return -1

if a > b:

return 1

def __init__(self):

# The C statements to declare variables.

# Should be full lines with \n eol characters.

self.declarations = []

# The C statements required to initialize the variables before the parse call.

# Should be full lines with \n eol characters.

self.initializers = []

# The C statements needed to dynamically modify the values

# parsed by the parse call, before calling the impl.

self.modifications = []

# The entries for the "keywords" array for PyArg_ParseTuple.

# Should be individual strings representing the names.

self.keywords = []

# The "format units" for PyArg_ParseTuple.

# Should be individual strings that will get

self.format_units = []

# The varargs arguments for PyArg_ParseTuple.

self.parse_arguments = []

# The parameter declarations for the impl function.

self.impl_parameters = []

# The arguments to the impl function at the time it's called.

self.impl_arguments = []

# For return converters: the name of the variable that

# should receive the value returned by the impl.

self.return_value = "return_value"

# For return converters: the code to convert the return

# value from the parse function. This is also where

# you should check the _return_value for errors, and

# "goto exit" if there are any.

self.return_conversion = []

# The C statements required to clean up after the impl call.

"""

def __init__(self):

self.counts = collections.Counter()

def get_value(self, key, args, kwargs):

self.counts[key] += 1

start_line = ""

body_prefix = ""

stop_line = ""

checksum_line = ""

def __init__(self, filename):

pass

@abc.abstractmethod

def render(self, clinic, signatures):

pass

def parse_line(self, line):

pass

def validate(self):

def assert_only_one(attr, *additional_fields):

"""

fields = ['dsl_name']

fields.extend(additional_fields)

line = getattr(self, attr)

fcf = FormatCounterFormatter()

fcf.format(line)

def local_fail(should_be_there_but_isnt):

if should_be_there_but_isnt:

fail("{} {} must contain {{{}}} exactly once!".format(

self.__class__.__name__, attr, name))

else:

fail("{} {} must not contain {{{}}}!".format(

self.__class__.__name__, attr, name))

for name, count in fcf.counts.items():

if name in fields:

if count > 1:

local_fail(True)

else:

local_fail(False)

for name in fields:

if fcf.counts.get(name) != 1:

local_fail(True)

assert_only_one('start_line')

assert_only_one('stop_line')

field = "arguments" if "{arguments}" in self.checksum_line else "checksum"

language = 'Python'

start_line = "#/*[{dsl_name} input]"

body_prefix = "#"

stop_line = "#[{dsl_name} start generated code]*/"

"""

yield tuple()

accumulator = []

for group in reversed(l):

accumulator = list(group) + accumulator

"""

yield tuple()

accumulator = []

for group in l:

accumulator.extend(group)

"""

required = tuple(required)

result = []

if not required:

assert not left

accumulator = []

counts = set()

for r in permute_right_option_groups(right):

for l in permute_left_option_groups(left):

t = l + required + r

if len(t) in counts:

continue

counts.add(len(t))

accumulator.append(t)

accumulator.sort(key=len)

lines = s.rstrip().split('\n')

while lines:

line = lines[0]

if line.strip():

break

del lines[0]

"""

s = strip_leading_and_trailing_blank_lines(s)

s = textwrap.dedent(s)

if indent:

s = textwrap.indent(s, ' ' * indent)

"""

lines = []

for line in text.split('\n'):

prefix, _, after_l_paren = line.partition('(')

if not after_l_paren:

lines.append(line)

continue

parameters, _, after_r_paren = after_l_paren.partition(')')

if not _:

lines.append(line)

continue

if ',' not in parameters:

lines.append(line)

continue

parameters = [x.strip() + ", " for x in parameters.split(',')]

prefix += "("

if len(prefix) < length:

spaces = " " * len(prefix)

else:

spaces = " " * 4

while parameters:

line = prefix

first = True

while parameters:

if (not first and

(len(line) + len(parameters[0]) > length)):

break

line += parameters.pop(0)

first = False

if not parameters:

line = line.rstrip(", ") + ")" + after_r_paren

lines.append(line.rstrip())

prefix = spaces

body_prefix = "#"

language = 'C'

start_line = "/*[{dsl_name} input]"

body_prefix = ""

stop_line = "[{dsl_name} start generated code]*/"

checksum_line = "/*[{dsl_name} end generated code: {arguments}]*/"

def __init__(self, filename):

super().__init__(filename)

self.cpp = cpp.Monitor(filename)

self.cpp.fail = fail

def parse_line(self, line):

self.cpp.writeline(line)

def render(self, clinic, signatures):

function = None

for o in signatures:

if isinstance(o, Function):

if function:

fail("You may specify at most one function per block.\nFound a block containing at least two:\n\t" + repr(function) + " and " + repr(o))

function = o

return self.render_function(clinic, function)

def docstring_for_c_string(self, f):

if re.search(r'[^\x00-\x7F]', f.docstring):

warn("Non-ascii character appear in docstring.")

text, add, output = _text_accumulator()

# turn docstring into a properly quoted C string

for line in f.docstring.split('\n'):

add('"')

add(quoted_for_c_string(line))

add('\\n"\n')

if text[-2] == sig_end_marker:

# If we only have a signature, add the blank line that the

# __text_signature__ getter expects to be there.

add('"\\n"')

else:

text.pop()

add('"')

return ''.join(text)

def output_templates(self, f):

parameters = list(f.parameters.values())

assert parameters

assert isinstance(parameters[0].converter, self_converter)

del parameters[0]

requires_defining_class = False

if parameters and isinstance(parameters[0].converter, defining_class_converter):

requires_defining_class = True

del parameters[0]

converters = [p.converter for p in parameters]

has_option_groups = parameters and (parameters[0].group or parameters[-1].group)

default_return_converter = (not f.return_converter or

f.return_converter.type == 'PyObject *')

new_or_init = f.kind in (METHOD_NEW, METHOD_INIT)

vararg = NO_VARARG

pos_only = min_pos = max_pos = min_kw_only = pseudo_args = 0

for i, p in enumerate(parameters, 1):

if p.is_keyword_only() or vararg != NO_VARARG:

assert not p.is_positional_only()

if not p.is_optional():

min_kw_only = i - max_pos

elif p.is_vararg():

if vararg != NO_VARARG:

fail("Too many var args")

pseudo_args += 1

vararg = i - 1

else:

if vararg == NO_VARARG:

max_pos = i

if p.is_positional_only():

pos_only = i

if not p.is_optional():

min_pos = i

meth_o = (len(parameters) == 1 and

parameters[0].is_positional_only() and

not converters[0].is_optional() and

not requires_defining_class and

not new_or_init)

# we have to set these things before we're done:

#

# docstring_prototype

# docstring_definition

# impl_prototype

# methoddef_define

# parser_prototype

# parser_definition

# impl_definition

# cpp_if

# cpp_endif

# methoddef_ifndef

return_value_declaration = "PyObject *return_value = NULL;"

methoddef_define = normalize_snippet("""

""")

if new_or_init and not f.docstring:

docstring_prototype = docstring_definition = ''

else:

docstring_prototype = normalize_snippet("""

""")

docstring_definition = normalize_snippet("""

""")

impl_definition = normalize_snippet("""

""")

impl_prototype = parser_prototype = parser_definition = None

parser_prototype_keyword = normalize_snippet("""

""")

parser_prototype_varargs = normalize_snippet("""

""")

parser_prototype_fastcall = normalize_snippet("""

""")

parser_prototype_fastcall_keywords = normalize_snippet("""

""")

parser_prototype_def_class = normalize_snippet("""

""")

# parser_body_fields remembers the fields passed in to the

# previous call to parser_body. this is used for an awful hack.

parser_body_fields = ()

parser_body_declarations = ''

def parser_body(prototype, *fields, declarations=''):

nonlocal parser_body_fields, parser_body_declarations

add, output = text_accumulator()

add(prototype)

parser_body_fields = fields

parser_body_declarations = declarations

fields = list(fields)

fields.insert(0, normalize_snippet("""

""") + "\n")

# just imagine--your code is here in the middle

fields.append(normalize_snippet("""

"""))

for field in fields:

add('\n')

add(field)

return linear_format(output(), parser_declarations=declarations)

if not parameters:

if not requires_defining_class:

# no parameters, METH_NOARGS

flags = "METH_NOARGS"

parser_prototype = normalize_snippet("""

""")

parser_code = []

else:

assert not new_or_init

flags = "METH_METHOD|METH_FASTCALL|METH_KEYWORDS"

parser_prototype = parser_prototype_def_class

return_error = ('return NULL;' if default_return_converter

else 'goto exit;')

parser_code = [normalize_snippet("""

""" % return_error, indent=4)]

if default_return_converter:

parser_definition = '\n'.join([

parser_prototype,

'{{',

*parser_code,

' return {c_basename}_impl({impl_arguments});',

'}}'])

else:

parser_definition = parser_body(parser_prototype, *parser_code)

elif meth_o:

flags = "METH_O"

if (isinstance(converters[0], object_converter) and

converters[0].format_unit == 'O'):

meth_o_prototype = normalize_snippet("""

""")

if default_return_converter:

# maps perfectly to METH_O, doesn't need a return converter.

# so we skip making a parse function

# and call directly into the impl function.

impl_prototype = parser_prototype = parser_definition = ''

impl_definition = meth_o_prototype

else:

# SLIGHT HACK

# use impl_parameters for the parser here!

parser_prototype = meth_o_prototype

parser_definition = parser_body(parser_prototype)

else:

argname = 'arg'

if parameters[0].name == argname:

argname += '_'

parser_prototype = normalize_snippet("""

""" % argname)

displayname = parameters[0].get_displayname(0)

parsearg = converters[0].parse_arg(argname, displayname)

if parsearg is None:

parsearg = """

""" % argname

parser_definition = parser_body(parser_prototype,

normalize_snippet(parsearg, indent=4))

elif has_option_groups:

# positional parameters with option groups

# (we have to generate lots of PyArg_ParseTuple calls

# in a big switch statement)

flags = "METH_VARARGS"

parser_prototype = parser_prototype_varargs

parser_definition = parser_body(parser_prototype, ' {option_group_parsing}')

elif not requires_defining_class and pos_only == len(parameters) - pseudo_args:

if not new_or_init:

# positional-only, but no option groups

# we only need one call to _PyArg_ParseStack

flags = "METH_FASTCALL"

parser_prototype = parser_prototype_fastcall

nargs = 'nargs'

argname_fmt = 'args[%d]'

else:

# positional-only, but no option groups

# we only need one call to PyArg_ParseTuple

flags = "METH_VARARGS"

parser_prototype = parser_prototype_varargs

nargs = 'PyTuple_GET_SIZE(args)'

argname_fmt = 'PyTuple_GET_ITEM(args, %d)'

left_args = "{} - {}".format(nargs, max_pos)

max_args = NO_VARARG if (vararg != NO_VARARG) else max_pos

parser_code = [normalize_snippet("""

""" % (nargs, min_pos, max_args), indent=4)]

has_optional = False

for i, p in enumerate(parameters):

displayname = p.get_displayname(i+1)

argname = argname_fmt % i

if p.is_vararg():

if not new_or_init:

parser_code.append(normalize_snippet("""

""" % (

p.converter.parser_name,

left_args,

left_args,

p.converter.parser_name,

max_pos

), indent=4))

else:

parser_code.append(normalize_snippet("""

""" % (

p.converter.parser_name,

max_pos

), indent=4))

continue

parsearg = p.converter.parse_arg(argname, displayname)

if parsearg is None:

#print('Cannot convert %s %r for %s' % (p.converter.__class__.__name__, p.converter.format_unit, p.converter.name), file=sys.stderr)

parser_code = None

break

if has_optional or p.is_optional():

has_optional = True

parser_code.append(normalize_snippet("""

""", indent=4) % (nargs, i + 1))

parser_code.append(normalize_snippet(parsearg, indent=4))

if parser_code is not None:

if has_optional:

parser_code.append("skip_optional:")

else:

if not new_or_init:

parser_code = [normalize_snippet("""

""", indent=4)]

else:

parser_code = [normalize_snippet("""

""", indent=4)]

parser_definition = parser_body(parser_prototype, *parser_code)

else:

has_optional_kw = (max(pos_only, min_pos) + min_kw_only < len(converters))

if vararg == NO_VARARG:

args_declaration = "_PyArg_UnpackKeywords", "%s, %s, %s" % (

min_pos,

max_pos,

min_kw_only

)

else:

args_declaration = "_PyArg_UnpackKeywordsWithVararg", "%s, %s, %s, %s" % (

min_pos,

max_pos,

min_kw_only,

vararg

)

if not new_or_init:

flags = "METH_FASTCALL|METH_KEYWORDS"

parser_prototype = parser_prototype_fastcall_keywords

argname_fmt = 'args[%d]'

declarations = normalize_snippet("""

""" % len(converters))

if has_optional_kw:

pre_buffer = "0" if vararg != NO_VARARG else "nargs"

declarations += "\nPy_ssize_t noptargs = %s + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - %d;" % (pre_buffer, min_pos + min_kw_only)

parser_code = [normalize_snippet("""

""" % args_declaration, indent=4)]

else:

# positional-or-keyword arguments

flags = "METH_VARARGS|METH_KEYWORDS"

parser_prototype = parser_prototype_keyword

argname_fmt = 'fastargs[%d]'

declarations = normalize_snippet("""

""" % len(converters))

if has_optional_kw:

declarations += "\nPy_ssize_t noptargs = nargs + (kwargs ? PyDict_GET_SIZE(kwargs) : 0) - %d;" % (min_pos + min_kw_only)

parser_code = [normalize_snippet("""