def render(self, sexps):
# mapping = {}
# if len(self.args) > 0 and isinstance(self.args[-1], bach_ast.Many):
# if len(self.args) >= len(sexps) - 1:
# for arg, sexp in zip(self.args[:-1], self.sexps[:len(self.args) - 1]):
# mapping[arg.label] = sexp
# mapping[self.args[-1].label] = sexps[len(self.args) - 1:]
# else:
# raise MacroMatchError("No enough args for %s" % self.label)
# else:
# if len(self.args) == len(sexps):
# for arg, sexp in zip(self.args, sexps):
# mapping[arg.label] = sexp
# else:
# raise MacroMatchError("Expected %d args got %d for %s" % (len(self.args), len(sexps), self.label))
# value =
if not self.args:
args = []
elif isinstance(self.args[-1], bach_ast.Many):
args = self.args[:-1] + [bach_ast.Label(self.args[-1].label)]
else:
args = self.args
sexps = [bach_ast.Quote(sexp) for sexp in sexps]
sexp = bach_ast.Program([[bach_ast.Lambda(args, self.body)] + sexps])
result = compiler.Compiler().compile_and_eval(sexp,
stl=bach_stl.load_stl(),
return_value=True)
return self.normal_sexp(result)
def __init__(self,
source,
log_function=default_logfunction,
sessionid=None,
default_datamodel="python",
setup_session=True):
'''
@param source: the scxml document to parse. source may be either:
uri : similar to what you'd write to the open() function. The
difference is, StateMachine looks in the PYSCXMLPATH environment variable
for documents if none can be found at ".". As such, it's similar to the PYTHONPATH
environment variable. Set the PYSCXMLPATH variable to exert more fine-grained control
over the src attribute of <invoke>. self.filename and self.filedir are set as a result.
xml string: if source is an xml string, it's executed as is.
self.filedir and self.filename aren't filled.
file-like object: if source has the .read() method,
the result of that method will be executed.
@param log_function: the function to execute on a <log /> element.
signature is f(label, msg), where label is a string and msg a string.
@param sessionid: is stored in the _session variable. Will be automatically
generated if not provided.
@param default_datamodel: if omitted, any document started by this instance will have
its datamodel expressions evaluated as Python expressions. Set to 'ecmascript' to assume
EMCAScript expressions.
@param setup_session: for internal use.
@raise IOError
@raise xml.parsers.expat.ExpatError
'''
self.is_finished = False
self.filedir = None
self.filename = None
self.compiler = compiler.Compiler()
self.compiler.default_datamodel = default_datamodel
self.compiler.log_function = log_function
self.sessionid = sessionid or "pyscxml_session_" + str(id(self))
self.interpreter = Interpreter()
dispatcher.connect(self.on_exit, "signal_exit", self.interpreter)
self.logger = logging.getLogger("pyscxml.%s" % self.sessionid)
self.interpreter.logger = logging.getLogger("pyscxml.%s.interpreter" %
self.sessionid)
self.compiler.logger = logging.getLogger("pyscxml.%s.compiler" %
self.sessionid)
self.doc = self.compiler.parseXML(self._open_document(source),
self.interpreter)
self.interpreter.dm = self.doc.datamodel
self.datamodel = self.doc.datamodel
self.doc.datamodel["_x"] = {"self": self}
self.doc.datamodel.self = self
self.doc.datamodel["_sessionid"] = self.sessionid
self.doc.datamodel.sessionid = self.sessionid
self.name = self.doc.name
self.is_response = self.compiler.is_response
if setup_session:
MultiSession().make_session(self.sessionid, self)
def get_compiler():
import compiler
cmp = compiler.Compiler()
cmp.misc.changed_images = {}
cmp.add_tag("{{Meta(?:|\|([^}]*))}}", "<head><meta charset='utf-8'><title>{0}</title></head><body>", default_arg=("No title","Foo","Bar"))
cmp.add_tag("{{img\|([^}]+)}}", handle_image)
cmp.add_tag("{{avatar\|([a-zA-Z0-9_-]+)}}", get_avatar)
return cmp
def main(args): if len(args) < 3: print "[ERROR] Usage: %s <project_dir> <deploytype>" % os.path.basename(args[0]) sys.exit(1) project_dir = os.path.expanduser(args[1]) deploytype = args[2] compiler.Compiler(project_dir,deploytype)
def run(self, text):
l2c = compiler.Compiler(self.view)
sublime.status_message("Compiling .less files...")
resp = l2c.convertAll()
if resp != "":
MessageWindow(resp)
else:
sublime.message_dialog("All .less files compiled successfully")
def test_compile_file(self):
file_path = "D:\\longTimeProgram1.py"
file = open(file_path)
content = file.read()
comp = compiler.Compiler()
result = comp.compile_file(content)
self.assertEqual(1, result)
def extract_text():
outputFile = (outputsDir / 'wikitext_anarchism.txt').open(encoding="utf8",
mode="w")
with (ROOT /
'examples/data/wikitext_anarchism.txt').open(encoding="utf8") as f:
w_compiler = c.Compiler()
text = f.read()
try:
text = w_compiler.compile(text)
outputFile.write(text)
except Exception as e:
traceback.print_exc()
outputFile.close()
def test_bare_sequence(self):
s = Sequence()
c = compiler.Compiler()
c.TRUNCATE = False
c.load(s)
compiled_sequence = c.compile(variant=0)
print(c.instruction_list.human)
#compiler.prettyprint(compiled_sequence)
i = ipu.IPU()
i.showBuffer = False
i._RAM = compiled_sequence
s.shots = 2
i.nRepeats = s.shots
i.idleState = s.hardware.idle_state ^ s.hardware.polarity_mask
i.run()
def test_minimal_sequence(self):
s = Sequence.from_file(
"./compiler/test_sequences/minimal_sequence.xml")
c = compiler.Compiler()
c.TRUNCATE = False
c.load(s)
compiled_sequence = c.compile(variant=0)
print(c.instruction_list.human)
i = ipu.IPU()
i.showBuffer = False
i._RAM = compiled_sequence
i.nRepeats = 10
i._spcMemoryRange[0] = (8000, 12000)
i.idleState = s.HWConfig.idle_state ^ s.HWConfig.polarity_mask
i.run()
def find_password_for_username(self):
x = self.find_username()
file = open(self.passwords_file)
lines = file.readlines()
try:
i = compiler.Compiler(self.password)
compile_password = i.compile()
if compile_password in lines:
compiled_password = lines[x]
return compiled_password
else:
return 'Invalid password.'
except Exception:
return 'Invalid password.'
def extract_links():
outputFile = (outputsDir / 'wikitext_link_extraction.txt').open(
encoding="utf8", mode="w")
with (ROOT / 'examples/data/wikitext_link_extraction.txt').open(
encoding="utf8") as f:
w_compiler = c.Compiler()
listener = w_compiler.on(lambda node: parse_link(node),
c.ParseTypes.LINK)
text = f.read()
try:
w_compiler.compile(text)
outputFile.write(
f'\n\n* Links\n\n {reverse_graph} \n\n* Categories\n {categories}'
),
except Exception as e:
traceback.print_exc()
finally:
listener() # free listener
def rodarFilaArquivos(every_minute):
print("Rodando Fila de Arquivos a cada " + str(every_minute) +
" minuto(s)")
rodou = False
minute = datetime.datetime.now().strftime('%M')
while (True):
if minute != datetime.datetime.now().strftime('%M'):
minute = datetime.datetime.now().strftime('%M')
rodou = False
if not (int(datetime.datetime.now().strftime('%M')) %
every_minute) and not rodou:
print("Verificando..")
rodou = True
with Database.Database('rubik_platform.db') as db:
envios = db.query('SELECT * FROM envios WHERE env_status = 0')
if envios:
for envio in envios:
print(envio)
with Database.Database('rubik_platform.db') as db:
estados = db.query(
'SELECT * FROM estados_cubo ORDER BY cub_robo DESC LIMIT 5',
())
if estados:
comp = compiler.Compiler(envio['env_filename'])
success = comp.Compile(estados)
if success:
print("sucesso")
with Database.Database('rubik_platform.db') as db:
db.execute(
"UPDATE envios SET env_status = ? WHERE env_id = ?",
(1, envio['env_id']))
else:
print("erro")
with Database.Database('rubik_platform.db') as db:
db.execute(
"UPDATE envios SET env_status = ? WHERE env_id = ?",
(2, envio['env_id']))
else:
print("Não há estados disponiveis")
print("fim")
def rodarFilaArquivos(every_minute):
print("Rodando Fila para envio do robô a cada " + str(every_minute) +
" minuto(s)")
rodou = False
minute = datetime.datetime.now().strftime('%M')
while (True):
if minute != datetime.datetime.now().strftime('%M'):
minute = datetime.datetime.now().strftime('%M')
rodou = False
if not (int(datetime.datetime.now().strftime('%M')) %
every_minute) and not rodou:
print("Verificando..")
rodou = True
with Database.Database('rubik_platform.db') as db:
fila_robo = db.query(
'SELECT * FROM fila_robo JOIN envios ON env_id = rob_idenvio WHERE rob_status = 0 AND env_status = 1'
)
if fila_robo:
for row in fila_robo:
print(row)
with Database.Database('rubik_platform.db') as db:
estados = db.query(
'SELECT * FROM estados_cubo ORDER BY cub_robo DESC LIMIT 5',
())
if estados:
comp = compiler.Compiler(row['env_filename'])
movements = comp.Compile(estados, True)
print(movements)
if movements:
ser = serial.Serial('/dev/ttyUSB0')
ser.write(movements.encode())
with Database.Database('rubik_platform.db') as db:
db.execute(
"UPDATE fila_robo SET rob_status = ? WHERE rob_id = ?",
(1, row['rob_id']))
ser.close()
print("Fim")
def repl():
"""
This function defines the debugging monkelang REPL environment. It runs
code with the VM class's run_once method.
"""
machine = vm.VM([])
duck_compiler = compiler.Compiler([], machine)
print("DuckLang REPL :D")
while True:
command = input("duck> ")
ast = duck_parser.DuckParser(command).parse()
duck_compiler.ast = ast
code, constant_table = duck_compiler.compile()
machine.constant_table = constant_table
machine.code = code
machine.run_once(code)
def job_compile(kwargs):
if not kwargs.has_key(u'task_id'):
return
task_id = kwargs[u'task_id']
tasks = models.CovTask.objects.filter(id=task_id)
if 0 >= len(tasks):
return
task = tasks[0]
module = task.module
task.pack_state = u'doing'
task.save()
cmpler = compiler.Compiler(module.name, module.repos_type.name,
module.repos_addr)
cmpler.init_work_space(conf.FMT_TASK_DIR % (task.id, task.name))
ret = cmpler.download_code(task.version)
if 0 != ret:
task.pack_state = u'failed'
task.save()
return
ret = cmpler.compile()
if 0 != ret:
task.pack_state = u'failed'
task.save()
return
task.pack_state = u'success'
task.bgjob_id = u''
task.save()
return
def main():
parser = argparse.ArgumentParser()
parser.add_argument('-c',
'--compiler',
required=True,
help='Path to compiler')
parser.add_argument('-s',
'--sources',
nargs='*',
default=[],
help='List of js source files')
parser.add_argument('-o',
'--output',
required=False,
help='Compile to output')
parser.add_argument('--chunks',
action='store_true',
help='Compile each source to its own chunk')
parser.add_argument(
'--chunk_suffix',
required=False,
help='String appended to the source when naming a chunk')
parser.add_argument('-d',
'--deps',
nargs='*',
default=[],
help='List of js_libarary dependencies')
parser.add_argument('-b',
'--bootstrap',
help='A file to include before all others')
parser.add_argument('-cf',
'--config',
nargs='*',
default=[],
help='A list of files to include after bootstrap and '
'before all others')
parser.add_argument('-f',
'--flags',
nargs='*',
default=[],
help='A list of custom flags to pass to the compiler. '
'Do not include leading dashes')
parser.add_argument('-e',
'--externs',
nargs='*',
default=[],
help='A list of extern files to pass to the compiler')
parser.add_argument('-co',
'--checks-only',
action='store_true',
help='Only performs checks and writes an empty output')
args = parser.parse_args()
# If --chunks is used, args.sources will be added later
sources, externs = CrawlRootDepsTree(args.deps,
[] if args.chunks else args.sources,
args.externs)
compiler_args = ['--%s' % flag for flag in args.flags]
compiler_args += ['--externs=%s' % e for e in externs]
if not args.chunks:
compiler_args += [
'--js_output_file',
args.output,
]
compiler_args += [
'--js',
]
if args.bootstrap:
compiler_args += [args.bootstrap]
compiler_args += args.config
compiler_args += sources
if args.chunks:
chunk_suffix = args.chunk_suffix
common_chunk_name = 'common' + chunk_suffix
compiler_args += [
'--chunk_output_path_prefix {}'.format(args.output),
'--chunk {}:auto'.format(common_chunk_name)
]
for s in args.sources:
# '//path/to/target.js' becomes 'target'
chunk_name = '{}{}'.format(
s.split('/')[-1].split('.')[0], chunk_suffix)
compiler_args += [
'--chunk {}:1:{}: {}'.format(chunk_name, common_chunk_name, s)
]
if args.checks_only:
compiler_args += ['--checks-only']
open(args.output, 'w').close()
returncode, errors = compiler.Compiler().run_jar(args.compiler,
compiler_args)
if returncode != 0:
print(args.compiler, ' '.join(compiler_args))
print(errors)
return returncode
def setUp(self):
self.compiler = compiler.Compiler()
def __init__(self):
self.t = tokenizer.Tokenizer()
self.p = parser.Parser()
self.c = compiler.Compiler()
def run(self, text):
l2c = compiler.Compiler(self.view)
resp = l2c.convertOne()
MessageWindow(resp)
def main():
compiler = cp.Compiler(True)
ret = compiler(thisyear, 1, 1)
print(ret)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('-c',
'--compiler',
required=True,
help='Path to compiler')
parser.add_argument('-s',
'--sources',
nargs='*',
default=[],
help='List of js source files')
parser.add_argument('-o',
'--output',
required=True,
help='Compile to output')
parser.add_argument('-d',
'--deps',
nargs='*',
default=[],
help='List of js_libarary dependencies')
parser.add_argument('-b',
'--bootstrap',
help='A file to include before all others')
parser.add_argument('-cf',
'--config',
nargs='*',
default=[],
help='A list of files to include after bootstrap and '
'before all others')
parser.add_argument('-f',
'--flags',
nargs='*',
default=[],
help='A list of custom flags to pass to the compiler. '
'Do not include leading dashes')
parser.add_argument('-e',
'--externs',
nargs='*',
default=[],
help='A list of extern files to pass to the compiler')
parser.add_argument('-co',
'--checks-only',
action='store_true',
help='Only performs checks and writes an empty output')
args = parser.parse_args()
sources, externs = CrawlRootDepsTree(args.deps, args.sources, args.externs)
compiler_args = ['--%s' % flag for flag in args.flags]
compiler_args += ['--externs=%s' % e for e in externs]
compiler_args += [
'--js_output_file',
args.output,
'--js',
]
if args.bootstrap:
compiler_args += [args.bootstrap]
compiler_args += args.config
compiler_args += sources
if args.checks_only:
compiler_args += ['--checks-only']
open(args.output, 'w').close()
returncode, errors = compiler.Compiler().run_jar(args.compiler,
compiler_args)
if returncode != 0:
print errors
return returncode
def run(self, text):
l2c = compiler.Compiler(self.view)
resp = l2c.convertOne(is_auto_save=True)
MessageWindow(resp)
global_logger = SimpleLogger("Current run")
files = args.files if not args.dir else [os.path.join(args.files[0], x) for x in os.listdir(args.files[0]) if x.endswith(".cpp")]
for source in files:
assert os.path.exists(source)
# extract student name (we have this agreement, that cpp file name
# will be name of the student)
name = os.path.basename(source).split('.')[0]
builds_num = 0
logger = SimpleLogger(str(source))
global_logger.print(f"Student {logger.name}", logonly=True)
c = compiler.Compiler(source, identificator=logger.name, folder=SimpleLogger.FOLDER)
# Compile for all configs
errors, warnings = 0, 0
for platform_ in compiler.Platform:
logger.print(f"Compiling platform {platform_.name}")
executable = c.compile(platform_)
errors += len(executable.errors)
warnings += len(executable.warnings)
logger.print(str(executable))
if executable and not executable.warnings:
builds_num += 1
else:
logger.print(executable.get_log(), logonly=True)
import rule
import elements
import compiler
import core
l = core.GrammarList("somelist")
element = elements.Seq((
elements.Lit("good morning"),
elements.Lst(l),
))
r = rule.Rule("test_rule", element, exported=True)
c = compiler.Compiler()
r.compile(c)
output = c.compile()
print "Compiler state:"
print c.debug_state_string()
print "Output:"
binary = "".join(["%02x" % ord(c) for c in output])
for index in xrange(0, len(binary), 4):
if index and not index % (8 * 4): print
print binary[index:index + 4],
help='The format of the generated output.')
parser.add_argument(
'-o',
'--output',
dest='output',
metavar='FILE',
default=None,
help='Output will be written to this file path. Default is stdout.')
parser.add_argument(
'-p',
'--prg',
dest='prg',
default=False,
action='store_true',
help=
'Start the output with a two byte location header. Has no effect for the output type \'print\'.'
)
parser.add_argument('file', help='File path of source to compile.')
args = parser.parse_args()
fmt = formatter.Format.create(args.fmt, args.output, args.prg)
cmp = compiler.Compiler()
cmp.compile(args.file, args.org, args.rt, fmt)
if len(cmp.errors) > 0:
for error in cmp.errors:
sys.stderr.write(error)
sys.stderr.write('\n')
sys.exit(-1)
if o == "-v":
verbose = True
if o == "-o":
output = a
if o == "-s":
if a in ["c", "hex", "bin"]:
style = a
if output == None:
print "Output file not specified."
usage()
if style == None:
print "Output style not specified."
usage()
if len(args) == 0:
print "Source file not specified."
usage()
input = args[0]
c = compiler.Compiler(myis.instructions, myis.registers, verbose)
c.parseFile(input)
c.compile()
c.link()
program = c.getProgram()
writeCode(output, program, style)
if __name__ == "__main__":
main()
def main(args):
if args["help"]:
print __doc__.rstrip()
return None
do_log = not args["run"] or args["--verbose"]
if do_log:
if args["--verbose"]:
shell.COMMAND_DEFAULTS["mvn"] = "mvn"
logging.basicConfig(level=logging.DEBUG)
log = logging.getLogger("quark")
log.propagate = False
hnd = ProgressHandler(verbose=args["--verbose"])
log.addHandler(hnd)
hnd.setFormatter(logging.Formatter("%(message)s"))
version = "Quark %s run at %s" % (_metadata.__version__,
datetime.datetime.now())
helpers.Code.identifier = version
java = args["--java"]
ruby = args["--ruby"]
python = args["--python"]
python3 = args["--python3"]
javascript = args["--javascript"]
all = args["--all"] or not (java or python or javascript or ruby
or python3)
output = args["--output"]
offline = not args["--online"]
try:
shell.command_log.info("Checking environment")
backends = []
if java or all:
if args["install"]: shell.check("mvn")
backends.append(backend.Java)
if ruby or all:
if args["install"]: shell.check("gem")
backends.append(backend.Ruby)
if python or all:
if args["install"]:
shell.check("python2")
shell.check("pip2")
backends.append(backend.Python)
if python3 or all:
if args["install"]:
shell.check("python3")
shell.check("pip3")
backends.append(backend.Python3)
if javascript or all:
if args["install"]: shell.check("npm")
backends.append(backend.JavaScript)
filenames = args["<file>"] or [
compiler.join(None, compiler.BUILTIN_FILE)
]
for url in filenames:
c = compiler.Compiler(args["--include-stdlib"])
c.version_warning = args["--version-warning"]
if args["install"]:
compiler.install(c, url, offline, *backends)
elif args["compile"]:
compiler.compile(c, url, output, *backends)
elif args["run"]:
compiler.run(c, url, args["<args>"], *backends)
elif args["docs"]:
compiler.make_docs(c, url, output, args["--include-private"])
else:
assert False
except (KeyboardInterrupt, QuarkError) as err:
if not args["run"]:
shell.command_log.error("")
if args["install"] and offline and isinstance(err, shell.ShellError):
err = str(err) + "\n\n"
err += "Please retry the command with the --online switch\n\n"
err += " quark install --online "
for opt in "--verbose --java --javascript --ruby --python --python3".split(
):
if args[opt]: err += opt + " "
err += " ".join(shell.quote(f) for f in args["<file>"])
err += "\n"
return err
except: # pylint: disable=bare-except
if do_log:
import inspect
ast_stack = helpers.format_ast_stack(inspect.trace())
shell.command_log.error(
"\n -- snip --\nInternal compiler error, %s\n\n" % version,
exc_info=True)
if ast_stack:
shell.command_log.error("\nCompiler was looking at:\n%s\n" %
ast_stack)
instructions = textwrap.dedent("""\
Your code triggered an internal compiler error.
Please report the issue at https://github.com/datawire/quark/issues
""")
if do_log:
instructions += textwrap.dedent("""\
Please attach the above report up until the -- snip -- line with the issue.
If at all possible also attach the quark file that caused the error.
""")
else:
instructions += textwrap.dedent("""\
Please re-run the quark command with --verbose flag to get the full report.
""")
return instructions
shell.command_log.warn("Done")
