import abc

import collections

class Language(metaclass=abc.ABCMeta):

start_line = ""

body_prefix = ""

stop_line = ""

checksum_line = ""

def __init__(self, filename: str) -> None:

self.filename = filename

@abc.abstractmethod

def render(

self,

clinic: Clinic,

signatures: Iterable[Module | Class | Function]

) -> str:

...

def parse_line(self, line: str) -> None:

...

def validate(self) -> None:

def assert_only_one(

attr: str,

*additional_fields: str

) -> None:

"""

fields = ['dsl_name']

fields.extend(additional_fields)

line: str = getattr(self, attr)

fcf = libclinic.FormatCounterFormatter()

fcf.format(line)

def local_fail(should_be_there_but_isnt: bool) -> None:

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"

assert_only_one('checksum_line', field)

class PythonLanguage(Language):

language = 'Python'

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

body_prefix = "#"

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

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

class Block:

r"""

input: str

dsl_name: str | None = None

signatures: list[Module | Class | Function] = dc.field(default_factory=list)

output: Any = None # TODO: Very dynamic; probably untypeable in its current form?

indent: str = ''

def __repr__(self) -> str:

dsl_name = self.dsl_name or "text"

def summarize(s: object) -> str:

s = repr(s)

if len(s) > 30:

return s[:26] + "..." + s[0]

return s

parts = (

repr(dsl_name),

f"input={summarize(self.input)}",

f"output={summarize(self.output)}"

)

return f"<clinic.Block {' '.join(parts)}>"

class BlockParser:

"""

def __init__(

self,

input: str,

language: Language,

*,

verify: bool = True

) -> None:

"""

language.validate()

self.input = collections.deque(reversed(input.splitlines(keepends=True)))

self.block_start_line_number = self.line_number = 0

self.language = language

before, _, after = language.start_line.partition('{dsl_name}')

assert _ == '{dsl_name}'

self.find_start_re = libclinic.create_regex(before, after,

whole_line=False)

self.start_re = libclinic.create_regex(before, after)

self.verify = verify

self.last_checksum_re: re.Pattern[str] | None = None

self.last_dsl_name: str | None = None

self.dsl_name: str | None = None

self.first_block = True

def __iter__(self) -> BlockParser:

return self

def __next__(self) -> Block:

while True:

if not self.input:

raise StopIteration

if self.dsl_name:

try:

return_value = self.parse_clinic_block(self.dsl_name)

except ClinicError as exc:

exc.filename = self.language.filename

exc.lineno = self.line_number

raise

self.dsl_name = None

self.first_block = False

return return_value

block = self.parse_verbatim_block()

if self.first_block and not block.input:

continue

self.first_block = False

return block

def is_start_line(self, line: str) -> str | None:

match = self.start_re.match(line.lstrip())

return match.group(1) if match else None

def _line(self, lookahead: bool = False) -> str:

self.line_number += 1

line = self.input.pop()

if not lookahead:

self.language.parse_line(line)

return line

def parse_verbatim_block(self) -> Block:

lines = []

self.block_start_line_number = self.line_number

while self.input:

line = self._line()

dsl_name = self.is_start_line(line)

if dsl_name:

self.dsl_name = dsl_name

break

lines.append(line)

return Block("".join(lines))

def parse_clinic_block(self, dsl_name: str) -> Block:

in_lines = []

self.block_start_line_number = self.line_number + 1

stop_line = self.language.stop_line.format(dsl_name=dsl_name)

body_prefix = self.language.body_prefix.format(dsl_name=dsl_name)

def is_stop_line(line: str) -> bool:

# make sure to recognize stop line even if it

# doesn't end with EOL (it could be the very end of the file)

if line.startswith(stop_line):

remainder = line.removeprefix(stop_line)

if remainder and not remainder.isspace():

fail(f"Garbage after stop line: {remainder!r}")

return True

else:

# gh-92256: don't allow incorrectly formatted stop lines

if line.lstrip().startswith(stop_line):

fail(f"Whitespace is not allowed before the stop line: {line!r}")

return False

# consume body of program

while self.input:

line = self._line()

if is_stop_line(line) or self.is_start_line(line):

break

if body_prefix:

line = line.lstrip()

assert line.startswith(body_prefix)

line = line.removeprefix(body_prefix)

in_lines.append(line)

# consume output and checksum line, if present.

if self.last_dsl_name == dsl_name:

checksum_re = self.last_checksum_re

else:

before, _, after = self.language.checksum_line.format(dsl_name=dsl_name, arguments='{arguments}').partition('{arguments}')

assert _ == '{arguments}'

checksum_re = libclinic.create_regex(before, after, word=False)

self.last_dsl_name = dsl_name

self.last_checksum_re = checksum_re

assert checksum_re is not None

# scan forward for checksum line

out_lines = []

arguments = None

while self.input:

line = self._line(lookahead=True)

match = checksum_re.match(line.lstrip())

arguments = match.group(1) if match else None

if arguments:

break

out_lines.append(line)

if self.is_start_line(line):

break

output: str | None

output = "".join(out_lines)

if arguments:

d = {}

for field in shlex.split(arguments):

name, equals, value = field.partition('=')

if not equals:

fail(f"Mangled Argument Clinic marker line: {line!r}")

d[name.strip()] = value.strip()

if self.verify:

if 'input' in d:

checksum = d['output']

else:

checksum = d['checksum']

computed = libclinic.compute_checksum(output, len(checksum))

if checksum != computed:

fail("Checksum mismatch! "

f"Expected {checksum!r}, computed {computed!r}. "

"Suggested fix: remove all generated code including "

"the end marker, or use the '-f' option.")

else:

# put back output

output_lines = output.splitlines(keepends=True)

self.line_number -= len(output_lines)

self.input.extend(reversed(output_lines))

output = None

return Block("".join(in_lines), dsl_name, output=output)