signature
stringlengths 8
3.44k
| body
stringlengths 0
1.41M
| docstring
stringlengths 1
122k
| id
stringlengths 5
17
|
|---|---|---|---|
def init_config(self, app):
|
for k in dir(config):<EOL><INDENT>if k.startswith('<STR_LIT>'):<EOL><INDENT>app.config.setdefault(k, getattr(config, k))<EOL><DEDENT><DEDENT>
|
Initialize configuration.
|
f11242:c0:m2
|
def cached_unless_authenticated(timeout=<NUM_LIT:50>, key_prefix='<STR_LIT:default>'):
|
def caching(f):<EOL><INDENT>@wraps(f)<EOL>def wrapper(*args, **kwargs):<EOL><INDENT>cache_fun = current_cache.cached(<EOL>timeout=timeout, key_prefix=key_prefix,<EOL>unless=lambda: current_cache_ext.is_authenticated_callback())<EOL>return cache_fun(f)(*args, **kwargs)<EOL><DEDENT>return wrapper<EOL><DEDENT>return caching<EOL>
|
Cache anonymous traffic.
|
f11246:m0
|
def is_hashable(obj):
|
try:<EOL><INDENT>hash(obj)<EOL><DEDENT>except Exception:<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>return True<EOL><DEDENT>
|
Determine if obj is hashable.
|
f11249:m0
|
def assert_hashable_or_dict(name, obj):
|
if isinstance(obj, dict):<EOL><INDENT>for val in obj.values():<EOL><INDENT>assert_hashable_or_dict(name, val)<EOL><DEDENT><DEDENT>else:<EOL><INDENT>assert is_hashable(obj), "<STR_LIT>" + name + "<STR_LIT>"<EOL><DEDENT>
|
Assert obj is hashable, or for dicts apply recursively to values.
|
f11249:m1
|
def is_importable(name):
|
try:<EOL><INDENT>import_module(name)<EOL><DEDENT>except ImportError:<EOL><INDENT>return False<EOL><DEDENT>else:<EOL><INDENT>return True<EOL><DEDENT>
|
Determine if name can be imported.
|
f11249:m2
|
def main(args=None):
|
if args is None:<EOL><INDENT>args = sys.argv[<NUM_LIT:1>:]<EOL><DEDENT>print("<STR_LIT>" % args)<EOL>comp_all(args, expect_retcode=<NUM_LIT:0> if "<STR_LIT>" not in args else None)<EOL>
|
Compile everything with given arguments.
|
f11250:m0
|
def escape(inputstring):
|
if WINDOWS:<EOL><INDENT>return inputstring.replace("<STR_LIT:<>", "<STR_LIT>").replace("<STR_LIT:>>", "<STR_LIT>")<EOL><DEDENT>else:<EOL><INDENT>return '<STR_LIT:">' + inputstring.replace("<STR_LIT:$>", "<STR_LIT>").replace("<STR_LIT>", "<STR_LIT>") + '<STR_LIT:">'<EOL><DEDENT>
|
Performs basic shell escaping.
Not by any means complete, should only be used on coconut_snip.
|
f11251:m0
|
def call(cmd, assert_output=False, check_mypy=False, check_errors=True, stderr_first=False, expect_retcode=<NUM_LIT:0>, **kwargs):
|
print("<STR_LIT>", (cmd if isinstance(cmd, str) else "<STR_LIT:U+0020>".join(cmd)))<EOL>if assert_output is False:<EOL><INDENT>assert_output = ("<STR_LIT>",)<EOL><DEDENT>elif assert_output is True:<EOL><INDENT>assert_output = ("<STR_LIT>",)<EOL><DEDENT>elif isinstance(assert_output, str):<EOL><INDENT>assert_output = (assert_output,)<EOL><DEDENT>else:<EOL><INDENT>assert_output = tuple(x if x is not True else "<STR_LIT>" for x in assert_output)<EOL><DEDENT>stdout, stderr, retcode = call_output(cmd, **kwargs)<EOL>if stderr_first:<EOL><INDENT>out = stderr + stdout<EOL><DEDENT>else:<EOL><INDENT>out = stdout + stderr<EOL><DEDENT>out = "<STR_LIT>".join(out)<EOL>lines = out.splitlines()<EOL>if expect_retcode is not None:<EOL><INDENT>assert retcode == expect_retcode, "<STR_LIT>".format(<EOL>retcode,<EOL>expect_retcode,<EOL>cmd,<EOL>)<EOL><DEDENT>for line in lines:<EOL><INDENT>assert "<STR_LIT>" not in line, "<STR_LIT>" + repr(line)<EOL>assert "<STR_LIT>" not in line, "<STR_LIT>" + repr(line)<EOL>assert "<STR_LIT>" not in line, "<STR_LIT>" + repr(line)<EOL>if check_errors:<EOL><INDENT>assert "<STR_LIT>" not in line, "<STR_LIT>" + repr(line)<EOL>assert "<STR_LIT>" not in line, "<STR_LIT>" + repr(line)<EOL>assert "<STR_LIT>" not in line, "<STR_LIT>" + repr(line)<EOL><DEDENT>if check_mypy and all(test not in line for test in ignore_mypy_errs_with):<EOL><INDENT>assert "<STR_LIT>" not in line, "<STR_LIT>" + repr(line)<EOL>assert "<STR_LIT>" not in line, "<STR_LIT>" + repr(line)<EOL><DEDENT><DEDENT>last_line = lines[-<NUM_LIT:1>] if lines else "<STR_LIT>"<EOL>if assert_output is None:<EOL><INDENT>assert not last_line, "<STR_LIT>" + repr(last_line)<EOL><DEDENT>else:<EOL><INDENT>assert any(x in last_line for x in assert_output), "<STR_LIT>" + "<STR_LIT:U+002CU+0020>".join(assert_output) + "<STR_LIT>" + repr(last_line)<EOL><DEDENT>
|
Executes a shell command.
|
f11251:m1
|
def call_coconut(args, **kwargs):
|
if "<STR_LIT>" not in args and not PYPY and not PY26:<EOL><INDENT>args = ["<STR_LIT>", "<STR_LIT>"] + args<EOL><DEDENT>if "<STR_LIT>" in args and "<STR_LIT>" not in kwargs:<EOL><INDENT>kwargs["<STR_LIT>"] = True<EOL><DEDENT>call(["<STR_LIT>"] + args, **kwargs)<EOL>
|
Calls Coconut.
|
f11251:m2
|
def comp(path=None, folder=None, file=None, args=[], **kwargs):
|
paths = []<EOL>if path is not None:<EOL><INDENT>paths.append(path)<EOL><DEDENT>compdest = os.path.join(dest, *paths)<EOL>if folder is not None:<EOL><INDENT>paths.append(folder)<EOL><DEDENT>if file is not None:<EOL><INDENT>paths.append(file)<EOL><DEDENT>source = os.path.join(src, *paths)<EOL>call_coconut([source, compdest] + args, **kwargs)<EOL>
|
Compiles a test file or directory.
|
f11251:m3
|
@contextmanager<EOL>def remove_when_done(path):
|
try:<EOL><INDENT>yield<EOL><DEDENT>finally:<EOL><INDENT>try:<EOL><INDENT>if os.path.isdir(path):<EOL><INDENT>shutil.rmtree(path)<EOL><DEDENT>elif os.path.isfile(path):<EOL><INDENT>os.remove(path)<EOL><DEDENT><DEDENT>except OSError as err:<EOL><INDENT>logger.display_exc()<EOL><DEDENT><DEDENT>
|
Removes a path when done.
|
f11251:m4
|
@contextmanager<EOL>def using_dest():
|
try:<EOL><INDENT>os.mkdir(dest)<EOL><DEDENT>except Exception:<EOL><INDENT>shutil.rmtree(dest)<EOL>os.mkdir(dest)<EOL><DEDENT>with remove_when_done(dest):<EOL><INDENT>yield<EOL><DEDENT>
|
Makes and removes the dest folder.
|
f11251:m5
|
@contextmanager<EOL>def using_logger():
|
saved_logger = Logger(logger)<EOL>try:<EOL><INDENT>yield<EOL><DEDENT>finally:<EOL><INDENT>logger.copy_from(saved_logger)<EOL><DEDENT>
|
Use a temporary logger, then restore the old logger.
|
f11251:m6
|
def comp_extras(args=[], **kwargs):
|
comp(file="<STR_LIT>", args=args, **kwargs)<EOL>
|
Compiles extras.coco.
|
f11251:m7
|
def comp_runner(args=[], **kwargs):
|
comp(file="<STR_LIT>", args=args, **kwargs)<EOL>
|
Compiles runner.coco.
|
f11251:m8
|
def comp_agnostic(args=[], **kwargs):
|
comp(path="<STR_LIT>", folder="<STR_LIT>", args=args, **kwargs)<EOL>
|
Compiles agnostic.
|
f11251:m9
|
def comp_2(args=[], **kwargs):
|
comp(path="<STR_LIT>", folder="<STR_LIT>", args=["<STR_LIT>", "<STR_LIT:2>"] + args, **kwargs)<EOL>
|
Compiles target_2.
|
f11251:m10
|
def comp_3(args=[], **kwargs):
|
comp(path="<STR_LIT>", folder="<STR_LIT>", args=["<STR_LIT>", "<STR_LIT:3>"] + args, **kwargs)<EOL>
|
Compiles target_3.
|
f11251:m11
|
def comp_35(args=[], **kwargs):
|
comp(path="<STR_LIT>", folder="<STR_LIT>", args=["<STR_LIT>", "<STR_LIT>"] + args, **kwargs)<EOL>
|
Compiles target_35.
|
f11251:m12
|
def comp_sys(args=[], **kwargs):
|
comp(path="<STR_LIT>", folder="<STR_LIT>", args=["<STR_LIT>", "<STR_LIT>"] + args, **kwargs)<EOL>
|
Compiles target_sys.
|
f11251:m13
|
def run_src(**kwargs):
|
call(["<STR_LIT>", os.path.join(dest, "<STR_LIT>")], assert_output=True, **kwargs)<EOL>
|
Runs runner.py.
|
f11251:m14
|
def run_extras(**kwargs):
|
call(["<STR_LIT>", os.path.join(dest, "<STR_LIT>")], assert_output=True, check_errors=False, stderr_first=True, **kwargs)<EOL>
|
Runs extras.py.
|
f11251:m15
|
def run(args=[], agnostic_target=None, use_run_arg=False, expect_retcode=<NUM_LIT:0>):
|
if agnostic_target is None:<EOL><INDENT>agnostic_args = args<EOL><DEDENT>else:<EOL><INDENT>agnostic_args = ["<STR_LIT>", str(agnostic_target)] + args<EOL><DEDENT>with using_dest():<EOL><INDENT>if PY2:<EOL><INDENT>comp_2(args)<EOL><DEDENT>else:<EOL><INDENT>comp_3(args)<EOL>if sys.version_info >= (<NUM_LIT:3>, <NUM_LIT:5>):<EOL><INDENT>comp_35(args)<EOL><DEDENT><DEDENT>comp_agnostic(agnostic_args, expect_retcode=expect_retcode)<EOL>comp_sys(args)<EOL>if use_run_arg:<EOL><INDENT>comp_runner(["<STR_LIT>"] + agnostic_args, expect_retcode=expect_retcode, assert_output=True)<EOL><DEDENT>else:<EOL><INDENT>comp_runner(agnostic_args, expect_retcode=expect_retcode)<EOL>run_src()<EOL><DEDENT>if use_run_arg:<EOL><INDENT>comp_extras(["<STR_LIT>"] + agnostic_args, assert_output=True, check_errors=False, stderr_first=True)<EOL><DEDENT>else:<EOL><INDENT>comp_extras(agnostic_args)<EOL>run_extras()<EOL><DEDENT><DEDENT>
|
Compiles and runs tests.
|
f11251:m16
|
def comp_pyston(args=[], **kwargs):
|
call(["<STR_LIT>", "<STR_LIT>", pyston_git])<EOL>call_coconut(["<STR_LIT>"] + args, **kwargs)<EOL>
|
Compiles evhub/pyston.
|
f11251:m17
|
def run_pyston(**kwargs):
|
call(["<STR_LIT>", os.path.join(pyston, "<STR_LIT>")], assert_output=True, **kwargs)<EOL>
|
Runs pyston.
|
f11251:m18
|
def comp_pyprover(args=[], **kwargs):
|
call(["<STR_LIT>", "<STR_LIT>", pyprover_git])<EOL>call_coconut([os.path.join(pyprover, "<STR_LIT>"), "<STR_LIT>"] + args, **kwargs)<EOL>call_coconut([os.path.join(pyprover, "<STR_LIT>"), os.path.join(pyprover, "<STR_LIT>"), "<STR_LIT>"] + args, **kwargs)<EOL>
|
Compiles evhub/pyprover.
|
f11251:m19
|
def run_pyprover(**kwargs):
|
call(["<STR_LIT>", "<STR_LIT>", "<STR_LIT>", pyprover])<EOL>call(["<STR_LIT>", os.path.join(pyprover, "<STR_LIT>", "<STR_LIT>")], assert_output=True, **kwargs)<EOL>
|
Runs pyprover.
|
f11251:m20
|
def comp_prelude(args=[], **kwargs):
|
call(["<STR_LIT>", "<STR_LIT>", prelude_git])<EOL>call_coconut([os.path.join(prelude, "<STR_LIT>"), "<STR_LIT>"] + args, **kwargs)<EOL>if MYPY:<EOL><INDENT>args.append("<STR_LIT>")<EOL><DEDENT>call_coconut([os.path.join(prelude, "<STR_LIT>"), os.path.join(prelude, "<STR_LIT>"), "<STR_LIT>"] + args, **kwargs)<EOL>
|
Compiles evhub/coconut-prelude.
|
f11251:m21
|
def run_prelude(**kwargs):
|
call(["<STR_LIT>", "<STR_LIT>", "<STR_LIT>", prelude])<EOL>call(["<STR_LIT>", os.path.join(prelude, "<STR_LIT>", "<STR_LIT>")], assert_output=True, **kwargs)<EOL>
|
Runs coconut-prelude.
|
f11251:m22
|
def comp_all(args=[], **kwargs):
|
try:<EOL><INDENT>os.mkdir(dest)<EOL><DEDENT>except Exception:<EOL><INDENT>pass<EOL><DEDENT>comp_2(args, **kwargs)<EOL>comp_3(args, **kwargs)<EOL>comp_35(args, **kwargs)<EOL>comp_agnostic(args, **kwargs)<EOL>comp_sys(args, **kwargs)<EOL>comp_runner(args, **kwargs)<EOL>comp_extras(args, **kwargs)<EOL>
|
Compile Coconut tests.
|
f11251:m23
|
def run_runnable(args=[]):
|
call(["<STR_LIT>"] + args + [runnable_coco, "<STR_LIT>"], assert_output=True)<EOL>
|
Call coconut-run on runnable_coco.
|
f11251:m24
|
def printerr(*args):
|
print(*args, file=sys.stderr)<EOL>
|
Prints to standard error.
|
f11253:m0
|
def format_error(err_type, err_value, err_trace=None):
|
if err_trace is None:<EOL><INDENT>err_parts = "<STR_LIT>".join(traceback.format_exception_only(err_type, err_value)).strip().split("<STR_LIT>", <NUM_LIT:1>)<EOL>if len(err_parts) == <NUM_LIT:1>:<EOL><INDENT>err_name, err_msg = err_parts[<NUM_LIT:0>], "<STR_LIT>"<EOL><DEDENT>else:<EOL><INDENT>err_name, err_msg = err_parts<EOL><DEDENT>err_name = err_name.split("<STR_LIT:.>")[-<NUM_LIT:1>]<EOL>return err_name + "<STR_LIT>" + err_msg<EOL><DEDENT>else:<EOL><INDENT>return "<STR_LIT>".join(traceback.format_exception(err_type, err_value, err_trace)).strip()<EOL><DEDENT>
|
Properly formats the specified error.
|
f11253:m1
|
def complain(error):
|
if callable(error):<EOL><INDENT>if DEVELOP:<EOL><INDENT>raise error()<EOL><DEDENT><DEDENT>elif DEVELOP:<EOL><INDENT>raise error<EOL><DEDENT>else:<EOL><INDENT>logger.warn_err(error)<EOL><DEDENT>
|
Raises in develop; warns in release.
|
f11253:m2
|
def __init__(self, other=None):
|
if other is not None:<EOL><INDENT>self.copy_from(other)<EOL><DEDENT>self.patch_logging()<EOL>
|
Create a logger, optionally from another logger.
|
f11253:c0:m0
|
def copy_from(self, other):
|
self.verbose, self.quiet, self.path, self.name, self.tracing = other.verbose, other.quiet, other.path, other.name, other.tracing<EOL>
|
Copy other onto self.
|
f11253:c0:m1
|
def display(self, messages, sig="<STR_LIT>", debug=False):
|
full_message = "<STR_LIT>".join(<EOL>sig + line for line in "<STR_LIT:U+0020>".join(<EOL>str(msg) for msg in messages<EOL>).splitlines(True)<EOL>)<EOL>if not full_message:<EOL><INDENT>full_message = sig.rstrip()<EOL><DEDENT>if debug:<EOL><INDENT>printerr(full_message)<EOL><DEDENT>else:<EOL><INDENT>print(full_message)<EOL><DEDENT>
|
Prints an iterator of messages.
|
f11253:c0:m2
|
def show(self, *messages):
|
if not self.quiet:<EOL><INDENT>self.display(messages)<EOL><DEDENT>
|
Prints messages if not --quiet.
|
f11253:c0:m3
|
def show_sig(self, *messages):
|
if not self.quiet:<EOL><INDENT>self.display(messages, main_sig)<EOL><DEDENT>
|
Prints messages with main signature if not --quiet.
|
f11253:c0:m4
|
def show_error(self, *messages):
|
if not self.quiet:<EOL><INDENT>self.display(messages, main_sig, debug=True)<EOL><DEDENT>
|
Prints error messages with main signature if not --quiet.
|
f11253:c0:m5
|
def log(self, *messages):
|
if self.verbose:<EOL><INDENT>printerr(*messages)<EOL><DEDENT>
|
Logs debug messages if --verbose.
|
f11253:c0:m6
|
def log_prefix(self, prefix, *messages):
|
if self.verbose:<EOL><INDENT>self.display(messages, prefix, debug=True)<EOL><DEDENT>
|
Logs debug messages with the given signature if --verbose.
|
f11253:c0:m7
|
def log_sig(self, *messages):
|
self.log_prefix(main_sig, *messages)<EOL>
|
Logs debug messages with the main signature if --verbose.
|
f11253:c0:m8
|
def log_vars(self, message, variables, rem_vars=("<STR_LIT>",)):
|
if self.verbose:<EOL><INDENT>new_vars = dict(variables)<EOL>for v in rem_vars:<EOL><INDENT>del new_vars[v]<EOL><DEDENT>printerr(message, new_vars)<EOL><DEDENT>
|
Logs variables with given message if --verbose.
|
f11253:c0:m9
|
def get_error(self):
|
exc_info = sys.exc_info()<EOL>if exc_info[<NUM_LIT:0>] is None:<EOL><INDENT>return None<EOL><DEDENT>else:<EOL><INDENT>err_type, err_value, err_trace = exc_info[<NUM_LIT:0>], exc_info[<NUM_LIT:1>], None<EOL>if self.verbose and len(exc_info) > <NUM_LIT:2>:<EOL><INDENT>err_trace = exc_info[<NUM_LIT:2>]<EOL><DEDENT>return format_error(err_type, err_value, err_trace)<EOL><DEDENT>
|
Properly formats the current error.
|
f11253:c0:m10
|
@contextmanager<EOL><INDENT>def in_path(self, new_path, old_path=None):<DEDENT>
|
self.path = new_path<EOL>try:<EOL><INDENT>yield<EOL><DEDENT>finally:<EOL><INDENT>self.path = old_path<EOL><DEDENT>
|
Temporarily enters a path.
|
f11253:c0:m11
|
def warn(self, *args, **kwargs):
|
return self.warn_err(CoconutWarning(*args, **kwargs))<EOL>
|
Creates and displays a warning.
|
f11253:c0:m12
|
def warn_err(self, warning):
|
try:<EOL><INDENT>raise warning<EOL><DEDENT>except Exception:<EOL><INDENT>if not self.quiet:<EOL><INDENT>self.display_exc()<EOL><DEDENT><DEDENT>
|
Displays a warning.
|
f11253:c0:m13
|
def display_exc(self):
|
errmsg = self.get_error()<EOL>if errmsg is not None:<EOL><INDENT>if self.path is not None:<EOL><INDENT>errmsg_lines = ["<STR_LIT>" + self.path + "<STR_LIT::>"]<EOL>for line in errmsg.splitlines():<EOL><INDENT>if line:<EOL><INDENT>line = "<STR_LIT:U+0020>" * taberrfmt + line<EOL><DEDENT>errmsg_lines.append(line)<EOL><DEDENT>errmsg = "<STR_LIT:\n>".join(errmsg_lines)<EOL><DEDENT>printerr(errmsg)<EOL><DEDENT>
|
Properly prints an exception in the exception context.
|
f11253:c0:m14
|
def log_exc(self):
|
if self.verbose:<EOL><INDENT>self.display_exc()<EOL><DEDENT>
|
Display an exception only if --verbose.
|
f11253:c0:m15
|
def log_cmd(self, args):
|
self.log("<STR_LIT>" + "<STR_LIT:U+0020>".join(args))<EOL>
|
Logs a console command if --verbose.
|
f11253:c0:m16
|
def show_tabulated(self, begin, middle, end):
|
internal_assert(len(begin) < info_tabulation, "<STR_LIT>", begin)<EOL>self.show(begin + "<STR_LIT:U+0020>" * (info_tabulation - len(begin)) + middle + "<STR_LIT:U+0020>" + end)<EOL>
|
Shows a tabulated message.
|
f11253:c0:m17
|
def log_tag(self, tag, code, multiline=False):
|
if self.tracing:<EOL><INDENT>if callable(code):<EOL><INDENT>code = code()<EOL><DEDENT>tagstr = "<STR_LIT:[>" + str(tag) + "<STR_LIT:]>"<EOL>if multiline:<EOL><INDENT>printerr(tagstr + "<STR_LIT:\n>" + displayable(code))<EOL><DEDENT>else:<EOL><INDENT>printerr(tagstr, ascii(code))<EOL><DEDENT><DEDENT>
|
Logs a tagged message if tracing.
|
f11253:c0:m18
|
def log_trace(self, tag, original, loc, tokens=None, extra=None):
|
if self.tracing:<EOL><INDENT>tag, original, loc = displayable(tag), displayable(original), int(loc)<EOL>if "<STR_LIT:{>" not in tag:<EOL><INDENT>out = ["<STR_LIT:[>" + tag + "<STR_LIT:]>"]<EOL>add_line_col = True<EOL>if tokens is not None:<EOL><INDENT>if isinstance(tokens, Exception):<EOL><INDENT>msg = displayable(str(tokens))<EOL>if "<STR_LIT:{>" in msg:<EOL><INDENT>head, middle = msg.split("<STR_LIT:{>", <NUM_LIT:1>)<EOL>middle, tail = middle.rsplit("<STR_LIT:}>", <NUM_LIT:1>)<EOL>msg = head + "<STR_LIT>" + tail<EOL><DEDENT>out.append(msg)<EOL>add_line_col = False<EOL><DEDENT>elif len(tokens) == <NUM_LIT:1> and isinstance(tokens[<NUM_LIT:0>], str):<EOL><INDENT>out.append(ascii(tokens[<NUM_LIT:0>]))<EOL><DEDENT>else:<EOL><INDENT>out.append(ascii(tokens))<EOL><DEDENT><DEDENT>if add_line_col:<EOL><INDENT>out.append("<STR_LIT>" + str(lineno(loc, original)) + "<STR_LIT>" + str(col(loc, original)) + "<STR_LIT:)>")<EOL><DEDENT>if extra is not None:<EOL><INDENT>out.append("<STR_LIT>" + ascii(extra))<EOL><DEDENT>printerr(*out)<EOL><DEDENT><DEDENT>
|
Formats and displays a trace if tracing.
|
f11253:c0:m19
|
def trace(self, item):
|
if DEVELOP:<EOL><INDENT>item.debugActions = (<EOL>None, <EOL>self._trace_success_action,<EOL>self._trace_exc_action,<EOL>)<EOL>item.debug = True<EOL><DEDENT>return item<EOL>
|
Traces a parse element (only enabled in develop).
|
f11253:c0:m22
|
@contextmanager<EOL><INDENT>def gather_parsing_stats(self):<DEDENT>
|
if self.verbose:<EOL><INDENT>start_time = time.clock()<EOL>try:<EOL><INDENT>yield<EOL><DEDENT>finally:<EOL><INDENT>elapsed_time = time.clock() - start_time<EOL>printerr("<STR_LIT>", elapsed_time, "<STR_LIT>")<EOL>if packrat_cache:<EOL><INDENT>hits, misses = ParserElement.packrat_cache_stats<EOL>printerr("<STR_LIT>", hits, "<STR_LIT>", misses, "<STR_LIT>")<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>yield<EOL><DEDENT>
|
Times parsing if --verbose.
|
f11253:c0:m23
|
def patch_logging(self):
|
if not hasattr(logging, "<STR_LIT>"):<EOL><INDENT>def getLogger(name=None):<EOL><INDENT>other = Logger(self)<EOL>if name is not None:<EOL><INDENT>other.name = name<EOL><DEDENT>return other<EOL><DEDENT>logging.getLogger = getLogger<EOL><DEDENT>
|
Patches built-in Python logging if necessary.
|
f11253:c0:m24
|
def pylog(self, *args, **kwargs):
|
printerr(self.name, args, kwargs, traceback.format_exc())<EOL>
|
Display all available logging information.
|
f11253:c0:m25
|
def fixpath(path):
|
return os.path.normpath(os.path.realpath(os.path.expanduser(path)))<EOL>
|
Uniformly format a path.
|
f11254:m0
|
def get_target_info(target):
|
return tuple(int(x) for x in target)<EOL>
|
Return target information as a version tuple.
|
f11254:m1
|
def ver_tuple_to_str(req_ver):
|
return "<STR_LIT:.>".join(str(x) for x in req_ver)<EOL>
|
Converts a requirement version tuple into a version string.
|
f11254:m2
|
def ver_str_to_tuple(ver_str):
|
out = []<EOL>for x in ver_str.split("<STR_LIT:.>"):<EOL><INDENT>try:<EOL><INDENT>x = int(x)<EOL><DEDENT>except ValueError:<EOL><INDENT>pass<EOL><DEDENT>out.append(x)<EOL><DEDENT>return tuple(out)<EOL>
|
Convert a version string into a version tuple.
|
f11254:m3
|
def checksum(data):
|
return crc32(data) & <NUM_LIT><EOL>
|
Compute a checksum of the given data.
Used for computing __coconut_hash__.
|
f11254:m4
|
def set_to_tuple(tokens):
|
internal_assert(len(tokens) == <NUM_LIT:1>, "<STR_LIT>", tokens)<EOL>if "<STR_LIT>" in tokens or "<STR_LIT:list>" in tokens:<EOL><INDENT>return "<STR_LIT:(>" + tokens[<NUM_LIT:0>] + "<STR_LIT:)>"<EOL><DEDENT>elif "<STR_LIT:test>" in tokens:<EOL><INDENT>return "<STR_LIT:(>" + tokens[<NUM_LIT:0>] + "<STR_LIT>"<EOL><DEDENT>else:<EOL><INDENT>raise CoconutInternalException("<STR_LIT>", tokens[<NUM_LIT:0>])<EOL><DEDENT>
|
Converts set literal tokens to tuples.
|
f11255:m0
|
def import_stmt(imp_from, imp, imp_as):
|
return (<EOL>("<STR_LIT>" + imp_from + "<STR_LIT:U+0020>" if imp_from is not None else "<STR_LIT>")<EOL>+ "<STR_LIT>" + imp<EOL>+ ("<STR_LIT>" + imp_as if imp_as is not None else "<STR_LIT>")<EOL>)<EOL>
|
Generate an import statement.
|
f11255:m1
|
def single_import(path, imp_as):
|
out = []<EOL>parts = path.split("<STR_LIT>") <EOL>if len(parts) == <NUM_LIT:1>:<EOL><INDENT>imp_from, imp = None, parts[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>imp_from, imp = parts<EOL><DEDENT>if imp == imp_as:<EOL><INDENT>imp_as = None<EOL><DEDENT>elif imp.endswith("<STR_LIT:.>" + imp_as):<EOL><INDENT>if imp_from is None:<EOL><INDENT>imp_from = "<STR_LIT>"<EOL><DEDENT>imp_from += imp.rsplit("<STR_LIT:.>" + imp_as, <NUM_LIT:1>)[<NUM_LIT:0>]<EOL>imp, imp_as = imp_as, None<EOL><DEDENT>if imp_from is None and imp == "<STR_LIT>":<EOL><INDENT>out.append((imp_as if imp_as is not None else imp) + "<STR_LIT>")<EOL><DEDENT>elif imp_as is not None and "<STR_LIT:.>" in imp_as:<EOL><INDENT>fake_mods = imp_as.split("<STR_LIT:.>")<EOL>out.append(import_stmt(imp_from, imp, import_as_var))<EOL>for i in range(<NUM_LIT:1>, len(fake_mods)):<EOL><INDENT>mod_name = "<STR_LIT:.>".join(fake_mods[:i])<EOL>out.extend((<EOL>"<STR_LIT>",<EOL>openindent + mod_name,<EOL>closeindent + "<STR_LIT>",<EOL>openindent + mod_name + '<STR_LIT>' + mod_name + '<STR_LIT>',<EOL>closeindent + "<STR_LIT>",<EOL>openindent + "<STR_LIT>" + mod_name + "<STR_LIT>",<EOL>openindent + mod_name + '<STR_LIT>' + mod_name + '<STR_LIT>' + closeindent * <NUM_LIT:2>,<EOL>))<EOL><DEDENT>out.append("<STR_LIT:.>".join(fake_mods) + "<STR_LIT>" + import_as_var)<EOL><DEDENT>else:<EOL><INDENT>out.append(import_stmt(imp_from, imp, imp_as))<EOL><DEDENT>return out<EOL>
|
Generate import statements from a fully qualified import and the name to bind it to.
|
f11255:m2
|
def universal_import(imports, imp_from=None, target="<STR_LIT>"):
|
importmap = [] <EOL>for imps in imports:<EOL><INDENT>if len(imps) == <NUM_LIT:1>:<EOL><INDENT>imp, imp_as = imps[<NUM_LIT:0>], imps[<NUM_LIT:0>]<EOL><DEDENT>else:<EOL><INDENT>imp, imp_as = imps<EOL><DEDENT>if imp_from is not None:<EOL><INDENT>imp = imp_from + "<STR_LIT>" + imp <EOL><DEDENT>old_imp = None<EOL>path = imp.split("<STR_LIT:.>")<EOL>for i in reversed(range(<NUM_LIT:1>, len(path) + <NUM_LIT:1>)):<EOL><INDENT>base, exts = "<STR_LIT:.>".join(path[:i]), path[i:]<EOL>clean_base = base.replace("<STR_LIT:/>", "<STR_LIT>")<EOL>if clean_base in py3_to_py2_stdlib:<EOL><INDENT>old_imp, version_check = py3_to_py2_stdlib[clean_base]<EOL>if exts:<EOL><INDENT>old_imp += "<STR_LIT:.>"<EOL>if "<STR_LIT:/>" in base and "<STR_LIT:/>" not in old_imp:<EOL><INDENT>old_imp += "<STR_LIT:/>" <EOL><DEDENT>old_imp += "<STR_LIT:.>".join(exts)<EOL><DEDENT>break<EOL><DEDENT><DEDENT>if old_imp is None:<EOL><INDENT>paths = (imp,)<EOL><DEDENT>elif not target: <EOL><INDENT>paths = (old_imp, imp, version_check)<EOL><DEDENT>elif get_target_info_len2(target) >= version_check: <EOL><INDENT>paths = (imp,)<EOL><DEDENT>elif target.startswith("<STR_LIT:2>"): <EOL><INDENT>paths = (old_imp,)<EOL><DEDENT>elif get_target_info(target) < version_check: <EOL><INDENT>paths = (old_imp, imp, version_check)<EOL><DEDENT>else: <EOL><INDENT>paths = (imp,)<EOL><DEDENT>importmap.append((paths, imp_as))<EOL><DEDENT>stmts = []<EOL>for paths, imp_as in importmap:<EOL><INDENT>if len(paths) == <NUM_LIT:1>:<EOL><INDENT>more_stmts = single_import(paths[<NUM_LIT:0>], imp_as)<EOL>stmts.extend(more_stmts)<EOL><DEDENT>else:<EOL><INDENT>first, second, version_check = paths<EOL>stmts.append("<STR_LIT>" + str(version_check) + "<STR_LIT::>")<EOL>first_stmts = single_import(first, imp_as)<EOL>first_stmts[<NUM_LIT:0>] = openindent + first_stmts[<NUM_LIT:0>]<EOL>first_stmts[-<NUM_LIT:1>] += closeindent<EOL>stmts.extend(first_stmts)<EOL>stmts.append("<STR_LIT>")<EOL>second_stmts = single_import(second, imp_as)<EOL>second_stmts[<NUM_LIT:0>] = openindent + second_stmts[<NUM_LIT:0>]<EOL>second_stmts[-<NUM_LIT:1>] += closeindent<EOL>stmts.extend(second_stmts)<EOL><DEDENT><DEDENT>return "<STR_LIT:\n>".join(stmts)<EOL>
|
Generate code for a universal import of imports from imp_from on target.
imports = [[imp1], [imp2, as], ...]
|
f11255:m3
|
def imported_names(imports):
|
for imp in imports:<EOL><INDENT>yield imp[-<NUM_LIT:1>].split("<STR_LIT:.>", <NUM_LIT:1>)[<NUM_LIT:0>]<EOL><DEDENT>
|
Yields all the names imported by imports = [[imp1], [imp2, as], ...].
|
f11255:m4
|
def split_args_list(tokens, loc):
|
req_args, def_args, star_arg, kwd_args, dubstar_arg = [], [], None, [], None<EOL>pos = <NUM_LIT:0><EOL>for arg in tokens:<EOL><INDENT>if len(arg) == <NUM_LIT:1>:<EOL><INDENT>if arg[<NUM_LIT:0>] == "<STR_LIT:*>":<EOL><INDENT>if pos >= <NUM_LIT:3>:<EOL><INDENT>raise CoconutDeferredSyntaxError("<STR_LIT>", loc)<EOL><DEDENT>pos = <NUM_LIT:3><EOL><DEDENT>else:<EOL><INDENT>if pos > <NUM_LIT:0>:<EOL><INDENT>raise CoconutDeferredSyntaxError("<STR_LIT>", loc)<EOL><DEDENT>req_args.append(arg[<NUM_LIT:0>])<EOL><DEDENT><DEDENT>elif len(arg) == <NUM_LIT:2>:<EOL><INDENT>if arg[<NUM_LIT:0>] == "<STR_LIT:*>":<EOL><INDENT>if pos >= <NUM_LIT:2>:<EOL><INDENT>raise CoconutDeferredSyntaxError("<STR_LIT>", loc)<EOL><DEDENT>pos = <NUM_LIT:2><EOL>star_arg = arg[<NUM_LIT:1>]<EOL><DEDENT>elif arg[<NUM_LIT:0>] == "<STR_LIT>":<EOL><INDENT>if pos == <NUM_LIT:4>:<EOL><INDENT>raise CoconutDeferredSyntaxError("<STR_LIT>", loc)<EOL><DEDENT>pos = <NUM_LIT:4><EOL>dubstar_arg = arg[<NUM_LIT:1>]<EOL><DEDENT>else:<EOL><INDENT>if pos <= <NUM_LIT:1>:<EOL><INDENT>pos = <NUM_LIT:1><EOL>def_args.append((arg[<NUM_LIT:0>], arg[<NUM_LIT:1>]))<EOL><DEDENT>elif pos <= <NUM_LIT:3>:<EOL><INDENT>pos = <NUM_LIT:3><EOL>kwd_args.append((arg[<NUM_LIT:0>], arg[<NUM_LIT:1>]))<EOL><DEDENT>else:<EOL><INDENT>raise CoconutDeferredSyntaxError("<STR_LIT>", loc)<EOL><DEDENT><DEDENT><DEDENT>else:<EOL><INDENT>raise CoconutInternalException("<STR_LIT>", arg)<EOL><DEDENT><DEDENT>return req_args, def_args, star_arg, kwd_args, dubstar_arg<EOL>
|
Splits function definition arguments.
|
f11255:m5
|
def match_case_tokens(loc, tokens, check_var, top):
|
if len(tokens) == <NUM_LIT:2>:<EOL><INDENT>matches, stmts = tokens<EOL>cond = None<EOL><DEDENT>elif len(tokens) == <NUM_LIT:3>:<EOL><INDENT>matches, cond, stmts = tokens<EOL><DEDENT>else:<EOL><INDENT>raise CoconutInternalException("<STR_LIT>", tokens)<EOL><DEDENT>matching = Matcher(loc, check_var)<EOL>matching.match(matches, match_to_var)<EOL>if cond:<EOL><INDENT>matching.add_guard(cond)<EOL><DEDENT>return matching.build(stmts, set_check_var=top)<EOL>
|
Build code for matching the given case.
|
f11255:m6
|
def __init__(self, *args, **kwargs):
|
self.setup(*args, **kwargs)<EOL>
|
Creates a new compiler with the given parsing parameters.
|
f11255:c0:m0
|
def setup(self, target=None, strict=False, minify=False, line_numbers=False, keep_lines=False, no_tco=False):
|
if target is None:<EOL><INDENT>target = "<STR_LIT>"<EOL><DEDENT>else:<EOL><INDENT>target = str(target).replace("<STR_LIT:.>", "<STR_LIT>")<EOL><DEDENT>if target in pseudo_targets:<EOL><INDENT>target = pseudo_targets[target]<EOL><DEDENT>if target not in targets:<EOL><INDENT>raise CoconutException(<EOL>"<STR_LIT>" + ascii(target),<EOL>extra="<STR_LIT>" + '<STR_LIT:U+002CU+0020>'.join(ascii(t) for t in specific_targets) + "<STR_LIT>",<EOL>)<EOL><DEDENT>logger.log_vars("<STR_LIT>", locals())<EOL>self.target, self.strict, self.minify, self.line_numbers, self.keep_lines, self.no_tco = (<EOL>target, strict, minify, line_numbers, keep_lines, no_tco,<EOL>)<EOL>
|
Initializes parsing parameters.
|
f11255:c0:m1
|
def __reduce__(self):
|
return (Compiler, (self.target, self.strict, self.minify, self.line_numbers, self.keep_lines, self.no_tco))<EOL>
|
Return pickling information.
|
f11255:c0:m2
|
def genhash(self, package, code):
|
return hex(checksum(<EOL>hash_sep.join(<EOL>str(item) for item in (VERSION_STR,)<EOL>+ self.__reduce__()[<NUM_LIT:1>]<EOL>+ (package, code)<EOL>).encode(default_encoding),<EOL>))<EOL>
|
Generate a hash from code.
|
f11255:c0:m3
|
def reset(self):
|
self.indchar = None<EOL>self.comments = {}<EOL>self.refs = []<EOL>self.set_skips([])<EOL>self.docstring = "<STR_LIT>"<EOL>self.ichain_count = <NUM_LIT:0><EOL>self.tre_store_count = <NUM_LIT:0><EOL>self.case_check_count = <NUM_LIT:0><EOL>self.stmt_lambdas = []<EOL>if self.strict:<EOL><INDENT>self.unused_imports = set()<EOL><DEDENT>self.bind()<EOL>
|
Resets references.
|
f11255:c0:m4
|
def bind(self):
|
self.endline <<= attach(self.endline_ref, self.endline_handle)<EOL>self.moduledoc_item <<= trace(attach(self.moduledoc, self.set_docstring))<EOL>self.name <<= trace(attach(self.base_name, self.name_check))<EOL>self.comment <<= trace(attach(self.comment_ref, self.comment_handle, greedy=True))<EOL>self.set_literal <<= trace(attach(self.set_literal_ref, self.set_literal_handle))<EOL>self.set_letter_literal <<= trace(attach(self.set_letter_literal_ref, self.set_letter_literal_handle))<EOL>self.classlist <<= trace(attach(self.classlist_ref, self.classlist_handle))<EOL>self.import_stmt <<= trace(attach(self.import_stmt_ref, self.import_handle))<EOL>self.complex_raise_stmt <<= trace(attach(self.complex_raise_stmt_ref, self.complex_raise_stmt_handle))<EOL>self.augassign_stmt <<= trace(attach(self.augassign_stmt_ref, self.augassign_handle))<EOL>self.dict_comp <<= trace(attach(self.dict_comp_ref, self.dict_comp_handle))<EOL>self.destructuring_stmt <<= trace(attach(self.destructuring_stmt_ref, self.destructuring_stmt_handle))<EOL>self.name_match_funcdef <<= trace(attach(self.name_match_funcdef_ref, self.name_match_funcdef_handle))<EOL>self.op_match_funcdef <<= trace(attach(self.op_match_funcdef_ref, self.op_match_funcdef_handle))<EOL>self.yield_from <<= trace(attach(self.yield_from_ref, self.yield_from_handle))<EOL>self.exec_stmt <<= trace(attach(self.exec_stmt_ref, self.exec_stmt_handle))<EOL>self.stmt_lambdef <<= trace(attach(self.stmt_lambdef_ref, self.stmt_lambdef_handle))<EOL>self.typedef <<= trace(attach(self.typedef_ref, self.typedef_handle))<EOL>self.typedef_default <<= trace(attach(self.typedef_default_ref, self.typedef_handle))<EOL>self.unsafe_typedef_default <<= trace(attach(self.unsafe_typedef_default_ref, self.unsafe_typedef_handle))<EOL>self.return_typedef <<= trace(attach(self.return_typedef_ref, self.typedef_handle))<EOL>self.typed_assign_stmt <<= trace(attach(self.typed_assign_stmt_ref, self.typed_assign_stmt_handle))<EOL>self.datadef <<= trace(attach(self.datadef_ref, self.data_handle))<EOL>self.with_stmt <<= trace(attach(self.with_stmt_ref, self.with_stmt_handle))<EOL>self.await_item <<= trace(attach(self.await_item_ref, self.await_item_handle))<EOL>self.ellipsis <<= trace(attach(self.ellipsis_ref, self.ellipsis_handle))<EOL>self.case_stmt <<= trace(attach(self.case_stmt_ref, self.case_stmt_handle))<EOL>self.decoratable_normal_funcdef_stmt <<= trace(attach(<EOL>self.decoratable_normal_funcdef_stmt_ref,<EOL>self.decoratable_funcdef_stmt_handle,<EOL>))<EOL>self.decoratable_async_funcdef_stmt <<= trace(attach(<EOL>self.decoratable_async_funcdef_stmt_ref,<EOL>partial(self.decoratable_funcdef_stmt_handle, is_async=True),<EOL>))<EOL>self.u_string <<= attach(self.u_string_ref, self.u_string_check)<EOL>self.matrix_at <<= attach(self.matrix_at_ref, self.matrix_at_check)<EOL>self.nonlocal_stmt <<= attach(self.nonlocal_stmt_ref, self.nonlocal_check)<EOL>self.star_assign_item <<= attach(self.star_assign_item_ref, self.star_assign_item_check)<EOL>self.classic_lambdef <<= attach(self.classic_lambdef_ref, self.lambdef_check)<EOL>self.star_expr <<= attach(self.star_expr_ref, self.star_expr_check)<EOL>self.dubstar_expr <<= attach(self.dubstar_expr_ref, self.star_expr_check)<EOL>self.star_sep_arg <<= attach(self.star_sep_arg_ref, self.star_sep_check)<EOL>self.star_sep_vararg <<= attach(self.star_sep_vararg_ref, self.star_sep_check)<EOL>self.endline_semicolon <<= attach(self.endline_semicolon_ref, self.endline_semicolon_check)<EOL>self.async_stmt <<= attach(self.async_stmt_ref, self.async_stmt_check)<EOL>self.async_comp_for <<= attach(self.async_comp_for_ref, self.async_comp_check)<EOL>self.f_string <<= attach(self.f_string_ref, self.f_string_check)<EOL>
|
Binds reference objects to the proper parse actions.
|
f11255:c0:m5
|
def copy_skips(self):
|
return self.skips[:]<EOL>
|
Copy the line skips.
|
f11255:c0:m6
|
def set_skips(self, skips):
|
skips.sort()<EOL>internal_assert(lambda: len(set(skips)) == len(skips), "<STR_LIT>", skips)<EOL>self.skips = skips<EOL>
|
Set the line skips.
|
f11255:c0:m7
|
def adjust(self, ln):
|
adj_ln = ln<EOL>need_unskipped = <NUM_LIT:0><EOL>for i in self.skips:<EOL><INDENT>if i <= ln:<EOL><INDENT>need_unskipped += <NUM_LIT:1><EOL><DEDENT>elif adj_ln + need_unskipped < i:<EOL><INDENT>break<EOL><DEDENT>else:<EOL><INDENT>need_unskipped -= i - adj_ln - <NUM_LIT:1><EOL>adj_ln = i<EOL><DEDENT><DEDENT>return adj_ln + need_unskipped<EOL>
|
Converts a parsing line number into an original line number.
|
f11255:c0:m8
|
def reformat(self, snip, index=None):
|
if index is not None:<EOL><INDENT>return self.reformat(snip), len(self.reformat(snip[:index]))<EOL><DEDENT>else:<EOL><INDENT>return self.repl_proc(snip, reformatting=True, log=False)<EOL><DEDENT>
|
Post process a preprocessed snippet.
|
f11255:c0:m9
|
def eval_now(self, code):
|
result = eval(self.reformat(code))<EOL>if result is None or isinstance(result, (bool, int, float, complex)):<EOL><INDENT>return repr(result)<EOL><DEDENT>elif isinstance(result, bytes):<EOL><INDENT>return "<STR_LIT:b>" + self.wrap_str_of(result)<EOL><DEDENT>elif isinstance(result, str):<EOL><INDENT>return self.wrap_str_of(result)<EOL><DEDENT>else:<EOL><INDENT>return None<EOL><DEDENT>
|
Reformat and evaluate a code snippet and return code for the result.
|
f11255:c0:m10
|
def make_err(self, errtype, message, original, loc, ln=None, reformat=True, *args, **kwargs):
|
if ln is None:<EOL><INDENT>ln = self.adjust(lineno(loc, original))<EOL><DEDENT>errstr, index = getline(loc, original), col(loc, original) - <NUM_LIT:1><EOL>if reformat:<EOL><INDENT>errstr, index = self.reformat(errstr, index)<EOL><DEDENT>return errtype(message, errstr, index, ln, *args, **kwargs)<EOL>
|
Generate an error of the specified type.
|
f11255:c0:m11
|
def strict_err_or_warn(self, *args, **kwargs):
|
if self.strict:<EOL><INDENT>raise self.make_err(CoconutStyleError, *args, **kwargs)<EOL><DEDENT>else:<EOL><INDENT>logger.warn_err(self.make_err(CoconutSyntaxWarning, *args, **kwargs))<EOL><DEDENT>
|
Raises an error if in strict mode, otherwise raises a warning.
|
f11255:c0:m12
|
def add_ref(self, reftype, data):
|
ref = (reftype, data)<EOL>try:<EOL><INDENT>index = self.refs.index(ref)<EOL><DEDENT>except ValueError:<EOL><INDENT>self.refs.append(ref)<EOL>index = len(self.refs) - <NUM_LIT:1><EOL><DEDENT>return str(index)<EOL>
|
Add a reference and returns the identifier.
|
f11255:c0:m13
|
def get_ref(self, reftype, index):
|
try:<EOL><INDENT>got_reftype, data = self.refs[int(index)]<EOL><DEDENT>except (IndexError, ValueError):<EOL><INDENT>raise CoconutInternalException("<STR_LIT>", index)<EOL><DEDENT>internal_assert(got_reftype == reftype, "<STR_LIT>" + reftype + "<STR_LIT>" + got_reftype + "<STR_LIT>")<EOL>return data<EOL>
|
Retrieve a reference.
|
f11255:c0:m14
|
def wrap_str(self, text, strchar, multiline=False):
|
if multiline:<EOL><INDENT>strchar *= <NUM_LIT:3><EOL><DEDENT>return strwrapper + self.add_ref("<STR_LIT:str>", (text, strchar)) + unwrapper<EOL>
|
Wrap a string.
|
f11255:c0:m15
|
def wrap_str_of(self, text):
|
text_repr = ascii(text)<EOL>internal_assert(text_repr[<NUM_LIT:0>] == text_repr[-<NUM_LIT:1>] and text_repr[<NUM_LIT:0>] in ("<STR_LIT:'>", '<STR_LIT:">'), "<STR_LIT>", text)<EOL>return self.wrap_str(text_repr[<NUM_LIT:1>:-<NUM_LIT:1>], text_repr[-<NUM_LIT:1>])<EOL>
|
Wrap a string of a string.
|
f11255:c0:m16
|
def wrap_passthrough(self, text, multiline=True):
|
if not multiline:<EOL><INDENT>text = text.lstrip()<EOL><DEDENT>if multiline:<EOL><INDENT>out = "<STR_LIT:\\>"<EOL><DEDENT>else:<EOL><INDENT>out = "<STR_LIT>"<EOL><DEDENT>out += self.add_ref("<STR_LIT>", text) + unwrapper<EOL>if not multiline:<EOL><INDENT>out += "<STR_LIT:\n>"<EOL><DEDENT>return out<EOL>
|
Wrap a passthrough.
|
f11255:c0:m17
|
def wrap_comment(self, text, reformat=True):
|
if reformat:<EOL><INDENT>text = self.reformat(text)<EOL><DEDENT>return "<STR_LIT:#>" + self.add_ref("<STR_LIT>", text) + unwrapper<EOL>
|
Wrap a comment.
|
f11255:c0:m18
|
def wrap_line_number(self, ln):
|
return "<STR_LIT:#>" + self.add_ref("<STR_LIT>", ln) + lnwrapper<EOL>
|
Wrap a line number.
|
f11255:c0:m19
|
def apply_procs(self, procs, kwargs, inputstring, log=True):
|
for get_proc in procs:<EOL><INDENT>proc = get_proc(self)<EOL>inputstring = proc(inputstring, **kwargs)<EOL>if log:<EOL><INDENT>logger.log_tag(proc.__name__, inputstring, multiline=True)<EOL><DEDENT><DEDENT>return inputstring<EOL>
|
Apply processors to inputstring.
|
f11255:c0:m20
|
def pre(self, inputstring, **kwargs):
|
out = self.apply_procs(self.preprocs, kwargs, str(inputstring))<EOL>logger.log_tag("<STR_LIT>", self.skips)<EOL>return out<EOL>
|
Perform pre-processing.
|
f11255:c0:m21
|
def post(self, result, **kwargs):
|
internal_assert(isinstance(result, str), "<STR_LIT>", result)<EOL>return self.apply_procs(self.postprocs, kwargs, result)<EOL>
|
Perform post-processing.
|
f11255:c0:m22
|
def getheader(self, which, use_hash=None, polish=True):
|
header = getheader(<EOL>which,<EOL>use_hash=use_hash,<EOL>target=self.target,<EOL>no_tco=self.no_tco,<EOL>strict=self.strict,<EOL>)<EOL>if polish:<EOL><INDENT>header = self.polish(header)<EOL><DEDENT>return header<EOL>
|
Get a formatted header.
|
f11255:c0:m23
|
@property<EOL><INDENT>def target_info(self):<DEDENT>
|
return get_target_info(self.target)<EOL>
|
Return information on the current target as a version tuple.
|
f11255:c0:m24
|
def make_syntax_err(self, err, original):
|
msg, loc = err.args<EOL>return self.make_err(CoconutSyntaxError, msg, original, loc)<EOL>
|
Make a CoconutSyntaxError from a CoconutDeferredSyntaxError.
|
f11255:c0:m25
|
def make_parse_err(self, err, reformat=True, include_ln=True):
|
err_line = err.line<EOL>err_index = err.col - <NUM_LIT:1><EOL>err_lineno = err.lineno if include_ln else None<EOL>if reformat:<EOL><INDENT>err_line, err_index = self.reformat(err_line, err_index)<EOL>if err_lineno is not None:<EOL><INDENT>err_lineno = self.adjust(err_lineno)<EOL><DEDENT><DEDENT>return CoconutParseError(None, err_line, err_index, err_lineno)<EOL>
|
Make a CoconutParseError from a ParseBaseException.
|
f11255:c0:m26
|
def parse(self, inputstring, parser, preargs, postargs):
|
self.reset()<EOL>pre_procd = None<EOL>with logger.gather_parsing_stats():<EOL><INDENT>try:<EOL><INDENT>pre_procd = self.pre(inputstring, **preargs)<EOL>parsed = parse(parser, pre_procd)<EOL>out = self.post(parsed, **postargs)<EOL><DEDENT>except ParseBaseException as err:<EOL><INDENT>raise self.make_parse_err(err)<EOL><DEDENT>except CoconutDeferredSyntaxError as err:<EOL><INDENT>internal_assert(pre_procd is not None, "<STR_LIT>", err)<EOL>raise self.make_syntax_err(err, pre_procd)<EOL><DEDENT>except RuntimeError as err:<EOL><INDENT>raise CoconutException(<EOL>str(err), extra="<STR_LIT>"<EOL>+ str(sys.getrecursionlimit()),<EOL>)<EOL><DEDENT><DEDENT>if self.strict:<EOL><INDENT>for name in self.unused_imports:<EOL><INDENT>if name != "<STR_LIT:*>":<EOL><INDENT>logger.warn("<STR_LIT>", name, extra="<STR_LIT>")<EOL><DEDENT><DEDENT><DEDENT>return out<EOL>
|
Use the parser to parse the inputstring with appropriate setup and teardown.
|
f11255:c0:m27
|
def prepare(self, inputstring, strip=False, nl_at_eof_check=False, **kwargs):
|
if self.strict and nl_at_eof_check and inputstring and not inputstring.endswith("<STR_LIT:\n>"):<EOL><INDENT>end_index = len(inputstring) - <NUM_LIT:1> if inputstring else <NUM_LIT:0><EOL>raise self.make_err(CoconutStyleError, "<STR_LIT>", inputstring, end_index)<EOL><DEDENT>original_lines = inputstring.splitlines()<EOL>if self.keep_lines:<EOL><INDENT>self.original_lines = original_lines<EOL><DEDENT>inputstring = "<STR_LIT:\n>".join(original_lines)<EOL>if strip:<EOL><INDENT>inputstring = inputstring.strip()<EOL><DEDENT>return inputstring<EOL>
|
Prepare a string for processing.
|
f11255:c0:m28
|
def str_proc(self, inputstring, **kwargs):
|
out = []<EOL>found = None <EOL>hold = None<EOL>_comment = <NUM_LIT:0> <EOL>_contents = <NUM_LIT:0> <EOL>_start = <NUM_LIT:1> <EOL>_stop = <NUM_LIT:2> <EOL>skips = self.copy_skips()<EOL>x = <NUM_LIT:0><EOL>while x <= len(inputstring):<EOL><INDENT>try:<EOL><INDENT>c = inputstring[x]<EOL><DEDENT>except IndexError:<EOL><INDENT>internal_assert(x == len(inputstring), "<STR_LIT>", x)<EOL>c = "<STR_LIT:\n>"<EOL><DEDENT>if hold is not None:<EOL><INDENT>if len(hold) == <NUM_LIT:1>: <EOL><INDENT>if c == "<STR_LIT:\n>":<EOL><INDENT>if self.minify:<EOL><INDENT>if out:<EOL><INDENT>lines = "<STR_LIT>".join(out).splitlines()<EOL>lines[-<NUM_LIT:1>] = lines[-<NUM_LIT:1>].rstrip()<EOL>out = ["<STR_LIT:\n>".join(lines)]<EOL><DEDENT>out.append(c)<EOL><DEDENT>else:<EOL><INDENT>out.append(self.wrap_comment(hold[_comment], reformat=False) + c)<EOL><DEDENT>hold = None<EOL><DEDENT>else:<EOL><INDENT>hold[_comment] += c<EOL><DEDENT><DEDENT>elif hold[_stop] is not None:<EOL><INDENT>if c == "<STR_LIT:\\>":<EOL><INDENT>hold[_contents] += hold[_stop] + c<EOL>hold[_stop] = None<EOL><DEDENT>elif c == hold[_start][<NUM_LIT:0>]:<EOL><INDENT>hold[_stop] += c<EOL><DEDENT>elif len(hold[_stop]) > len(hold[_start]):<EOL><INDENT>raise self.make_err(CoconutSyntaxError, "<STR_LIT>", inputstring, x, reformat=False)<EOL><DEDENT>elif hold[_stop] == hold[_start]:<EOL><INDENT>out.append(self.wrap_str(hold[_contents], hold[_start][<NUM_LIT:0>], True))<EOL>hold = None<EOL>x -= <NUM_LIT:1><EOL><DEDENT>else:<EOL><INDENT>if c == "<STR_LIT:\n>":<EOL><INDENT>if len(hold[_start]) == <NUM_LIT:1>:<EOL><INDENT>raise self.make_err(CoconutSyntaxError, "<STR_LIT>", inputstring, x, reformat=False)<EOL><DEDENT>else:<EOL><INDENT>skips = addskip(skips, self.adjust(lineno(x, inputstring)))<EOL><DEDENT><DEDENT>hold[_contents] += hold[_stop] + c<EOL>hold[_stop] = None<EOL><DEDENT><DEDENT>elif count_end(hold[_contents], "<STR_LIT:\\>") % <NUM_LIT:2> == <NUM_LIT:1>:<EOL><INDENT>if c == "<STR_LIT:\n>":<EOL><INDENT>skips = addskip(skips, self.adjust(lineno(x, inputstring)))<EOL><DEDENT>hold[_contents] += c<EOL><DEDENT>elif c == hold[_start]:<EOL><INDENT>out.append(self.wrap_str(hold[_contents], hold[_start], False))<EOL>hold = None<EOL><DEDENT>elif c == hold[_start][<NUM_LIT:0>]:<EOL><INDENT>hold[_stop] = c<EOL><DEDENT>else:<EOL><INDENT>if c == "<STR_LIT:\n>":<EOL><INDENT>if len(hold[_start]) == <NUM_LIT:1>:<EOL><INDENT>raise self.make_err(CoconutSyntaxError, "<STR_LIT>", inputstring, x, reformat=False)<EOL><DEDENT>else:<EOL><INDENT>skips = addskip(skips, self.adjust(lineno(x, inputstring)))<EOL><DEDENT><DEDENT>hold[_contents] += c<EOL><DEDENT><DEDENT>elif found is not None:<EOL><INDENT>if c == found[<NUM_LIT:0>]:<EOL><INDENT>found += c<EOL><DEDENT>elif len(found) == <NUM_LIT:1>: <EOL><INDENT>if c == "<STR_LIT:\n>":<EOL><INDENT>raise self.make_err(CoconutSyntaxError, "<STR_LIT>", inputstring, x, reformat=False)<EOL><DEDENT>else:<EOL><INDENT>hold = [c, found, None] <EOL>found = None<EOL><DEDENT><DEDENT>elif len(found) == <NUM_LIT:2>: <EOL><INDENT>out.append(self.wrap_str("<STR_LIT>", found[<NUM_LIT:0>], False))<EOL>found = None<EOL>x -= <NUM_LIT:1><EOL><DEDENT>elif len(found) == <NUM_LIT:3>: <EOL><INDENT>if c == "<STR_LIT:\n>":<EOL><INDENT>skips = addskip(skips, self.adjust(lineno(x, inputstring)))<EOL><DEDENT>hold = [c, found, None] <EOL>found = None<EOL><DEDENT>else:<EOL><INDENT>raise self.make_err(CoconutSyntaxError, "<STR_LIT>", inputstring, x, reformat=False)<EOL><DEDENT><DEDENT>elif c == "<STR_LIT:#>":<EOL><INDENT>hold = ["<STR_LIT>"] <EOL><DEDENT>elif c in holds:<EOL><INDENT>found = c<EOL><DEDENT>else:<EOL><INDENT>out.append(c)<EOL><DEDENT>x += <NUM_LIT:1><EOL><DEDENT>if hold is not None or found is not None:<EOL><INDENT>raise self.make_err(CoconutSyntaxError, "<STR_LIT>", inputstring, x, reformat=False)<EOL><DEDENT>else:<EOL><INDENT>self.set_skips(skips)<EOL>return "<STR_LIT>".join(out)<EOL><DEDENT>
|
Process strings and comments.
|
f11255:c0:m29
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.