def gotoCommand(script='', location=''):
line = -1
# if SCRIPT is essl command:
if isinstance(location, list):
interpreter.execute([location])
for tag in script:
# if TAG starts with sharp and TAG value is SCRIPT:
if tag[0] == '#' and tag[1] == getVar('ret').value:
# execute SCRIPT starting at LINE:
return script[line:]
# increase LINE by 1:
line += 1
#evaluatedScript.remove(code)
# if SCRIPT is not essl command:
else:
for tag in script:
# if TAG starts with sharp and TAG value is SCRIPT:
if tag[0] == '#' and tag[1] == location:
# execute SCRIPT starting at LINE:
return script[line:]
# increase LINE by 1:
line += 1
def inCommand(stream=''):
if stream:
# if STREAM is essl command:
if isinstance(stream, list):
interpreter.execute([stream])
getVar('ret').value = open(getVar('ret'), 'r+').read()
# if STREAM is not essl command:
else:
# if STREAM is var:
if stream[0] == '%':
# set STDIN to value of STREAM given as file:
getVar('ret').value = open(getVar(stream[1:]).value, 'r+').read()
# if STREAM is not var:
else:
# set STDIN to INFILE:
getVar('ret').value = open(value[1], 'r+').read()
# if STREAM is not specified:
else:
# set STDIN to INPUT:
getVar('ret').value = input()
def execute(code, code_input=None):
''' Method for execute code onde
:param code: raw code to be executed
'''
try:
interpreter.execute(code, code_input)
except FinishExecution:
pass
def outCommand(value='', value2=''):
# if STREAM is not supplied:
if value and not value2:
# if VALUE is var:
if value[0] == '%':
# print variable value:
print(getVar(value[1:]).value)
# if VALUE is not var:
else:
# return VALUE:
print(value)
# if VALUE2 is specified:
elif value and value2:
# if VALUE2 is essl command:
if isinstance(value2, list):
# if VALUE is var:
if value[0] == '%':
interpreter.execute([value2])
getVar(value[1:]).value = getVar('ret').value
# print error:
else:
print('Error: Value must be variable.')
sys.exit(1)
# if VALUE2 is not essl command:
else:
#if VALUE is var:
if value[0] == '%':
# if VALUE and VALUE2 is var:
if value2[0] == '%':
getVar(value[1:]).value = getVar(value2[1:]).value
# if VALUE is var and VALUE2 is not var:
else:
# set VALUE value to VALUE2:
getVar(value[1:]).value = value2
def interp_enum(self, clauses, target, max_depth=1):
# Given a good candidate of a partial program, exploit the clauses
program = self.clauses2prog(clauses) # Time consuming
state = execute(
self.interpreter, program,
is_uncertain=cmd_args.prob_dataset) # Not using execute function
prog = synthesize(self.interpreter,
target,
state,
is_uncertain=False,
max_depth=max_depth)
if type(prog) == type(None):
return
new_prog = []
for clause in prog.clauses:
new_clause = clause.to_tuple()
if len(new_clause) == 2:
op = get_attr_operation(new_clause[0], self.config)
new_clause = [op, new_clause[0], new_clause[1]]
new_prog.append(new_clause)
return new_prog
def fast_query(self, clauses):
program = self.clauses2prog(clauses) # Time consuming
state = execute(
self.interpreter, program,
is_uncertain=cmd_args.prob_dataset) # Not using execute function
bindings = self.interpreter.get_marginal_bindings(
state, is_uncertain=cmd_args.prob_dataset)
binding_dict = self.process_binding_to_dict(bindings.marginal_binding)
# print(bindings.marginal_binding)
return binding_dict
def _run(self, cls, instance, args, context, *, call):
variables = {param: arg
for arg, (param, _) in zip(args, self.parameters)}
generic_classes = dict(Generic.fill_generic(
[pt for _, pt in self.parameters], [arg.type for arg in args]))
scope = instance.scope
description = self.description
context = interpreter.Scope(description, scope,
generic_classes, variables)
context.stack.enter(interpreter.Frame(description, call))
if cls.base:
if self._super_arguments:
arguments = [interpreter.evaluate(argument, scope)
for argument in self._super_arguments]
cls.base.run_constructor(instance, arguments,
context, call=call)
else:
cls.base.run_constructor(instance, (), scope, call=call)
try:
interpreter.execute(self._statements, context)
except Return:
pass
scope.stack.exit()
def root():
context = {
'dados': interpreter.get_dados(),
'registradores': interpreter.get_registradores(),
'cache': interpreter.get_cache(),
'cache_dec': interpreter.get_cache_decimal(),
'cache_size': interpreter.cache_size,
'original_instruction': None
}
if request.method == 'POST':
if 'instruction' in request.form:
command = {
'instruction': request.form['instruction'],
'register_1': request.form['register_1'],
'register_2': request.form['register_2']
}
interpreter.execute(**command)
context['original_instruction'] = command
context['cache_dec'] = interpreter.get_cache_decimal()
elif 'load' in request.form:
interpreter.update_dados([
request.form['D0'], request.form['D1'], request.form['D2'],
request.form['D3'], request.form['D4'], request.form['D5'],
request.form['D6'], request.form['D7']
])
context['dados'] = interpreter.get_dados()
elif 'save' in request.form:
interpreter.save_dados()
else:
print('Invalid post request')
return render_template('page.html', **context)
else:
return render_template('page.html', **context)
def multipledraw(data: List) -> Expr:
"""
Args:
data: List<List<Vect>>>
"""
if data == nil:
return nil
data_list_form = interpreter.execute(data.display())
print(data_list_form)
print('-' * 60)
for dots in data_list_form[0]:
draw(dots)
print('-' * 60)
return data
def _execute_file(code_file, env, print_results=False):
"""Execute some lisp.
Args:
code_file: An iterator over lines of Lisp text.
env: The base environment.
print_results: Whether to print the value of each top-level expression.
"""
tokens = lexer.TokenSupply(lexer.lisp_tokens(code_file))
# Are there useful ways to clean up a parse tree before we start
# calling it an AST?
# TODO(jasonpr): Investigate.
for ast in parser.parse_trees(tokens):
evaluation = interpreter.execute(ast, env)
if print_results and evaluation is not None:
print formatter.lisp_format(evaluation)
def _execute_file(code_file, env, print_results=False):
"""Execute some lisp.
Args:
code_file: An iterator over lines of Lisp text.
env: The base environment.
print_results: Whether to print the value of each top-level expression.
"""
tokens = lexer.TokenSupply(lexer.lisp_tokens(code_file))
# Are there useful ways to clean up a parse tree before we start
# calling it an AST?
# TODO(jasonpr): Investigate.
for ast in parser.parse_trees(tokens):
evaluation = interpreter.execute(ast, env)
if print_results and evaluation is not None:
print formatter.lisp_format(evaluation)
def interpreter(input_path: str):
print_tokens = False
print_nodes = False
with open(input_path, "r") as f:
tokens = lexer(f.read())
if print_tokens:
for token in tokens:
print(token)
nodes = parse(tokens)
if print_nodes:
for node in nodes:
print(node)
memory, mp = execute(nodes)
def _run(self, cls, instance, args, context, *, call):
variables = {param: arg
for arg, (param, _) in zip(args, self.parameters)}
types = dict(Generic.fill_generic(
[pt for _, pt in self.parameters], [arg.type for arg in args]))
if instance:
scope = instance.scope
else:
scope = cls.scope
description = self.description
context = interpreter.Scope(description, scope, types, variables,
stack=scope.stack)
context.stack.enter(interpreter.Frame(description, call))
try:
value = interpreter.execute(self._statements, context)
except Return as e:
value = e.value
scope.stack.exit()
return value
def SEND_TO_ALIEN_PROXY(data):
url = server_url + '/aliens/send'
print(f"url: {url}")
print(f"data: {data}")
print(data.display())
modulated_data = interpreter.execute("ap mod " + data.display())
modulated_data_str = "".join([str(bit) for bit in modulated_data])
res = requests.post(url, data=modulated_data_str)
if res.status_code != 200:
print('Unexpected server response:')
print('HTTP code:', res.status_code)
print('Response body:', res.text)
exit(1)
print('Server response:', res.text)
return res.text
# return [Atom(0)]
return [Atom(1), Atom(67425)]
from config import keywords, literals, primitives
from interpreter import execute, stdin
from lexer import *
from parser import *
from ply.lex import lex
from ply.yacc import yacc
tokens = keywords + primitives
tokenizer = lex(debug=0)
compiler = yacc()
compiler.error = 0
print("oply >>>")
program = compiler.parse(stdin(), debug=0)
print
execute(program)
print
raw_input("exit")
def lex(code):
code = code.strip().split("\n")
for x in range(code.count("")):
code.remove("")
code.append("")
execute(parse(code))
from config import keywords, literals, primitives from interpreter import execute, stdin from lexer import * from parser import * from ply.lex import lex from ply.yacc import yacc tokens = keywords + primitives tokenizer = lex( debug=0 ) compiler = yacc() compiler.error = 0 print( "oply >>>" ) program = compiler.parse( stdin(), debug=0 ) print execute( program ) print raw_input( "exit" )
def test_numeric_expression(self):
for expression, result in calculator_test_cases:
self.assertAlmostEqual(execute(expression), result)
variable = commands.Variable(str(i))
variable.value = arg
args.append(variable)
i += 1
# if argument count is greater than 1:
if len(sys.argv) > 2:
# if 2nd argument is 'run':
if sys.argv[1] == 'run':
# if ESSLFILE should be read from STDIN:
if sys.argv[2][0] == '-':
# parse and execute 3rd argument:
interpreter.execute(parser.parse(sys.argv[2][1:]), args)
# if ESSLFILE should not be read from STDIN:
else:
# set ESSLFILE to file given in 3rd argument:
esslFile = open(sys.argv[2], 'r+')
# parse and execute ESSLFILE:
interpreter.execute(parser.parse(esslFile.read()), args)
# if 2nd argument is not a recognized action:
else:
# print error:
print('Action ' + sys.argv[1] + ' not found.')