def repl(): """Start the interactive Read-Eval-Print-Loop """ print print " " + grey(" ^__^ ") print " welcome to " + grey(" (oo)\_______ ") print " the MOO-lisp " + grey(" (__)\ )\/\ ") print " REPL " + grey(" ||----w | ") print " " + grey(" || || ") print env = copy.deepcopy(default_environment) try: while True: try: source = read_expression() if source.strip() == "(help)": with open('moolisp/usage.txt', 'r') as f: print "".join(f.readlines()) else: result = interpret(source, env) if result is not None: print to_string(result) except LispError, e: print colored("! ", "red") + str(e) except (EOFError, KeyboardInterrupt): print colored("\nBye! o/", "grey")
def basic_parse(self): print(bold(blue("[To]")), (":").rjust(11), self.eml["To"]) print(bold(green("[From]")), (":").rjust(9), self.eml["From"]) print(bold(yellow("[Sender]")), (":").rjust(7), self.eml["Sender"]) print(bold(orange("[Delivered To]")), ":", self.eml["Delivered-To"]) print(bold(red("[Subject]")), (":").rjust(6), self.eml["Subject"]) print(bold(purple("[Date]")), (":").rjust(9), self.eml["Date"]) print(bold(grey("[Content-Type]")), (":").rjust(1), self.eml["Content-Type"])
def run_mimic_core(data, debug=False, filename=None): id, f, timeout, metric, cleanup = data fn = "%s/result-%d.js" % (out, id) if filename is not None: fn = filename t = time.time() col = "--colors 0" if debug: col = "--verbose" command = '%s %s --metric %d --cleanup %d --out "%s" %s' % ( base_command, col, metric, cleanup, fn, f.get_command_args(), ) if debug: print colors.grey("Command to run") print command print colors.grey("Handing control to a single instance of mimic-core, which may or may not succeed") print colors.grey(line) sys.exit(os.system(command)) exitstatus, output = common.execute(command, timeout) elapsed_time = time.time() - t if exitstatus == 0: iters = int([m.group(1) for m in re.finditer("Found in ([0-9]+) iterations", output)][-1]) core_time = float([m.group(1) for m in re.finditer("and ([0-9.]+) seconds", output)][-1]) loop_index = -1 if "loop-free" not in output: loop_index = int(re.search("using the loop template with index: ([0-9]+)", output).group(1)) # res = "%s: success after %.2f seconds and %d iterations [%.1f iterations/second]" % (f.shortname, elapsed_time, iters, float(iters)/elapsed_time) res = CoreSuccess(output, metric, fn, iters, core_time, loop_index) else: res = CoreFailure(output, metric, exitstatus) send_result(id, res) send_done(id)
def main(): parser = argparse.ArgumentParser( description="Run Mimic to compute models for opaque code", formatter_class=argparse.ArgumentDefaultsHelpFormatter, ) parser.add_argument( "-t", "--threads", metavar="<n>", type=int, help="Number of threads (-1 = number of cores available)", default=-1, ) parser.add_argument( "--function", type=str, metavar="<body>", help="The function body of the opaque code (as JavaScript source code)", required=True, ) parser.add_argument( "--arguments", nargs="+", type=str, help="One (or more) initial inputs to the opaque code as a comma-separated list", metavar="<arglist>", required=True, ) parser.add_argument( "--argnames", type=str, help="The name of the arguments", metavar="<names>", default="arg0, arg1, arg2, arg3, arg4, arg5, arg6", ) parser.add_argument("--args", metavar="<args>", type=str, help="Arguments to be passed to mimic-core", default="") parser.add_argument( "--metric", metavar="<m>", type=int, help="The metric to use (0 for default, 1 for naive metric)", default=0 ) parser.add_argument( "--out", type=str, help="Location where the resulting function should be written to", default="result.js" ) parser.add_argument("--nocolor", help="Don't use any color in the output", action="store_true") parser.add_argument( "--debug", help="Output debug information, and only do a single run of mimic-core", action="store_true" ) parser.add_argument( "--parallel_t0", metavar="<t0>", type=int, help="The timeout to be used in the first phase", default=parallel_t0_default, ) parser.add_argument( "--parallel_f", metavar="<f>", type=float, help="The factor with which to increase the timeout (based on a single thread, and scaled appropriately for more threads)", default=parallel_f_default, ) global argv argv = parser.parse_args() global base_command if argv.args != "": base_command = base_command + " " + argv.args if argv.nocolor: colors.no_color = True out_file = argv.out # the function to run f = common.Function.make(argv.argnames, argv.arguments, argv.function) # header print "mimic - computing models for opaque code" print colors.grey(line) print colors.grey("Configuration:") print colors.grey(" Number of threads: %d" % (argv.threads if argv.threads > 0 else get_default_threads())) print line if argv.debug: print colors.grey("Running in debug mode") print colors.grey(line) run_mimic_core((0, f, 1200, argv.metric, 1000), debug=True, filename=argv.out) return result = mimic(f, argv.metric, argv.threads, False, argv.parallel_t0, argv.parallel_f) print colors.grey(line) print "Successfully found a model" print result.get_status(" ") print "" print "Model (also stored in '%s'):" % out_file print colors.green(result.result_code) shutil.move(result.result_file, out_file)
def mimic( f, metric=0, threads=-1, silent=True, parallel_t0=parallel_t0_default, parallel_f=parallel_f_default, cleanup=1000 ): if threads < 0: threads = get_default_threads() t0 = parallel_t0 factor = pow(parallel_f, threads) # create a directory to store information global out out = tempfile.mkdtemp() success = False rep = 0 total_attempts = 0 total_crashes = 0 start = time.time() error_count = 0 error_out = "" while success == False: timeout = round(t0 * pow(factor, rep)) if not silent: print colors.grey("Starting phase %d with a timeout of %d seconds..." % (rep + 1, timeout)) tasks = [] total_attempts += threads for i in range(threads): tasks.append((i, f, timeout, metric, cleanup)) global q q = Queue() pool = Pool(processes=threads, maxtasksperchild=1) pool.map_async(run_mimic_core, tasks) done_count = 0 while True: data = q.get() if data[0] == 0 and data[2] == "done": done_count += 1 if done_count == len(tasks): break continue if data[0] == 1: # process result id = data[1] core_result = data[2] if core_result.success: success = True # kill all other tasks pool.close() pool.terminate() pool.join() # return result code = "" with open(core_result.code) as fl: code = "".join(fl.readlines()) result = common.MimicResult( f, core_result.metric, time.time() - start, core_result.iterations, core_result.core_time, total_attempts, total_crashes, core_result.loop_index, core_result.code, code, ) return result else: if not core_result.timeout: total_crashes += 1 if core_result.status == 2: # definitely a user error print colors.red("Error in mimic-core:") print core_result.output pool.close() pool.terminate() pool.join() exit(1) if not core_result.timeout: error_count += 1 error_out = core_result.output else: print data print "unexpected message format" assert False if total_attempts > 5 and float(error_count) / float(total_attempts) >= 0.5: print colors.red("Found too many errors recently. Output from mimic-core:") print error_out sys.exit(1) if not success: pool.close() pool.join() rep += 1
# ------------------------------------------------------------------------------ import os import time import argparse import re import colors import multiprocessing from multiprocessing import Pool from multiprocessing import Queue import tempfile import common import sys import shutil line = colors.grey("-" * 80) q = None # the queue used for communication argv = None # the arguments out = None # the output folder base_command = os.path.abspath(os.path.dirname(__file__) + "/../mimic-core") + " synth --iterations 100000000" parallel_t0_default = 8 parallel_f_default = 1.025 # ------------------------------------------ # main entry point # ------------------------------------------ def main(): parser = argparse.ArgumentParser( description="Run Mimic to compute models for opaque code",
def info(self, msg): self.writeln(colors.grey(msg))
def remove_extra_images(): plt.close() try: pimg.__del__() climg.__del__() canvas.delete(q1) except(NameError): pass try: canvas.delete(q2) except(NameError): pass try: mimg.__del__() mlimg.__del__() canvas.delete(q3) except(NameError): pass class Area: def __init__(self,color,location): self.color = color self.shape = canvas.create_polygon(location, fill=self.color, outline='black', width = 2) map = Standaard_Kaart(c.grey(), "white") def mainLoop(): canvas.grid() canvas.grid(row=0, column=6,rowspan = 800) tk.mainloop() mainLoop()