def climb_down_from_chair(self):
"Should set has_user to False"
self.room.objects.append(self.chair)
self.chair.has_user = True
action = "climb down from chair"
parse(action, self.room, self.inv)
self.assertFalse(self.chair.has_user)
def turn_on_plaid_lamp(self):
"Should set is_lit to True"
action = "turn on plaid lamp"
self.room.objects.append(self.chair)
self.chair.has_user = True
parse(action, self.room, self.inv)
self.assertTrue(self.ulamp.has_user)
def get_chair_from_dresser(self):
"Should add chair to inventory"
self.dresser.objects.append(self.chair)
self.dresser.is_open = True
action = "get chair from dresser"
parse(action, self.room, self.inv)
self.assertEquals(self.inv, [self.chair])
def climb_down_from_chair(self):
"Should set has_user to False"
self.room.objects.append(self.chair)
self.chair.has_user = True
action = "climb down from chair"
parse(action, self.room, self.inv)
self.assertFalse(self.chair.has_user)
def turn_on_plaid_lamp(self):
"Should set is_lit to True"
action = "turn on plaid lamp"
self.room.objects.append(self.chair)
self.chair.has_user = True
parse(action, self.room, self.inv)
self.assertTrue(self.ulamp.has_user)
def get_chair_from_dresser(self):
"Should add chair to inventory"
self.dresser.objects.append(self.chair)
self.dresser.is_open = True
action = "get chair from dresser"
parse(action, self.room, self.inv)
self.assertEquals(self.inv, [self.chair])
def test_direction(self):
"Direction should return a Room object if the direction is valid, or an error string if it is not valid"
action = "south"
self.assertEquals(parse(action, self.room, self.inv),
self.southern_room)
action = "n"
self.assertEquals(parse(action, self.room, self.inv),
"You cannot go that way.")
def test_invalid_action_with_valid_object(self):
"An invalid action will return an action-related error message"
action = "stand on lamp"
self.assertEquals(parse(action, self.room, self.inv),
"That is not a valid action.")
action = "spit on bed"
self.assertEquals(parse(action, self.room, self.inv),
"That is not a valid action.")
def test_name_differentiation_when_one_is_in_container(self):
"""If there are two lamps but one is inside a container, it should recognise two lamps
when the container is open and one lamp when when the container is closed"""
# dresser is closed
self.dresser.objects.append(self.lamp)
action = "get lamp"
self.assertEquals(parse(action, self.room, self.inv), "That is not a valid action.")
# dresser is open
self.dresser.is_open = True
self.assertEquals(parse(action, self.room, self.inv), "More than one object fits that name.")
def test_name_differentiation_when_one_is_in_container(self):
"""If there are two lamps but one is inside a container, it should recognise two lamps
when the container is open and one lamp when when the container is closed"""
# dresser is closed
self.dresser.objects.append(self.lamp)
action = "get lamp"
self.assertEquals(parse(action, self.room, self.inv),
"That is not a valid action.")
# dresser is open
self.dresser.is_open = True
self.assertEquals(parse(action, self.room, self.inv),
"More than one object fits that name.")
def read_file(self, fname):
"""
Simple generator to parse log files
"""
# Here we try to memory map the file and just use the findall
with open(fname, 'r') as logfile:
#contents = mmap.mmap(logfile.fileno(), os.stat(fname).st_size)
contents = logfile.read()
for match in self.rex.finditer(contents, re.MULTILINE | re.DOTALL):
thread_id = match.group(1)
syscall_number = match.group(2)
syscall_name = match.group(3)
eip = match.group(4)
caller = match.group(5)
caller_offset = match.group(6)
hexargs = match.group(7)
args = match.group(8)
#ret = match.group(12)
ret = ''
hexargs = map(lambda x: x.strip(), hexargs.strip().split(','))
args = parse(args)
yield (thread_id, syscall_number, syscall_name, eip, hexargs,
args, ret, caller_offset)
def compile(src, out):
insts = []
declrs = []
global_env = Scope()
for stmt in map(desugar, parse(builtin_declrs + src)):
typ = type(stmt)
# there are two types of declaration:
# delcaration or struct definition
if typ == ast.Declaration or typ == ast.DeclrAssign:
code = compile_declr(stmt, global_env, declrs)
if type(code) == list:
insts.extend(code)
else: # data
declrs.append(code)
elif typ == ast.Struct:
global_env.add(stmt.name.val, stmt)
out.write('.data\n')
for declr in declrs:
out.write(repr_data(declr) + '\n')
out.write('.text\n')
for inst in insts:
out.write(repr_ir(inst) + '\n')
basedir = os.path.dirname(__file__)
with open(os.path.join(basedir, 'builtin.s')) as builtin_src:
out.write(builtin_src.read())
def test_action_with_adj_when_two_objects_have_same_name(self):
"""When two objects have the same name but a distinguishing adjective is provided,
should perform the action on the correct object"""
brass_lamp = Lamp()
brass_lamp.description = "A brass lamp with a tarnished base."
brass_lamp.on_description = "The light turns on."
brass_lamp.off_description = "The light turns off."
self.room.objects.append(brass_lamp)
# adjective is in object.name
action = "light brass lamp"
self.assertEquals(parse(action, self.room, self.inv), brass_lamp.on_description)
self.assertTrue(brass_lamp.is_lit)
# adjective is in object.description
action = "snuff tarnished lamp"
parse(action, self.room, self.inv)
self.assertFalse(brass_lamp.is_lit)
def compile(src, out):
insts = []
declrs = []
global_env = Scope()
for stmt in map(desugar, parse(builtin_declrs+src)):
typ = type(stmt)
# there are two types of declaration:
# delcaration or struct definition
if typ == ast.Declaration or typ == ast.DeclrAssign:
code = compile_declr(stmt, global_env, declrs)
if type(code) == list:
insts.extend(code)
else: # data
declrs.append(code)
elif typ == ast.Struct:
global_env.add(stmt.name.val, stmt)
out.write('.data\n')
for declr in declrs:
out.write(repr_data(declr)+'\n')
out.write('.text\n')
for inst in insts:
out.write(repr_ir(inst)+'\n')
basedir = os.path.dirname(__file__)
with open(os.path.join(basedir, 'builtin.s')) as builtin_src:
out.write(builtin_src.read())
def go(program):
program = tokenizer.tokenize(program)
program = grammar.parse(program)
program = syntax.AST(program)
#print(program)
program = typeChecker.check(program)
return program
def test_action_with_adj_when_two_objects_have_same_name(self):
"""When two objects have the same name but a distinguishing adjective is provided,
should perform the action on the correct object"""
brass_lamp = Lamp()
brass_lamp.description = "A brass lamp with a tarnished base."
brass_lamp.on_description = "The light turns on."
brass_lamp.off_description = "The light turns off."
self.room.objects.append(brass_lamp)
# adjective is in object.name
action = "light brass lamp"
self.assertEquals(parse(action, self.room, self.inv),
brass_lamp.on_description)
self.assertTrue(brass_lamp.is_lit)
# adjective is in object.description
action = "snuff tarnished lamp"
parse(action, self.room, self.inv)
self.assertFalse(brass_lamp.is_lit)
def index(request, user, language):
logger.debug ('entry point')
# XXX set language on-the-fly
# or pull from db based on users selection on phone
# language = LanguageFactory.create_language('eng')
if request.method == "GET":
logger.debug ('get request')
return request_update (user,language)
raw_text = request.raw_post_data.decode('UTF8')
logger.info ('user: %s text: %s' % (user, raw_text))
# empty request
if not raw_text:
return request_update (user,language)
msg_list = []
tokens = raw_text.split()
parsed_text = grammar.parse(tokens, language)
command = parsed_text['command']
extras = parsed_text['extras']
member = parsed_text['member']
group_name = parsed_text['group']
if command == language.CREATE:
logger.debug('request create group %s' % group_name)
# request, user, language, group_name, slot
return request_create_group(request, user, language, group_name, '')[1]
elif command == language.JOIN:
logger.debug('request join group %s' % group_name)
# request, user, language, group_name, slot
return join_group(request, user, language, group_name)[1]
elif command == language.INVITE:
# (request, user, language, group_name_or_slot, invite_user_phone, smsc = 'mosms')
logger.debug('request invite user %s to group %s' % (user, group_name))
invited_users = ' '.join([member, extras])
return invite_user_to_group(request, user, language, group_name, invited_users)[1]
elif command == language.LEAVE:
logger.debug('request leave group %s' % group_name)
# leave_group (request, user, language, group_or_slot)
return leave_group (request, user, language, group_name)[1]
elif command == language.DELETE:
logger.debug('request delete group %s' % group_name)
# delete_group (request, admin, language, group_name_or_slot)
return delete_group (request, user, language, group_name)[1]
elif command == language.REMOVE:
logger.debug('request remove user %s' % user)
# delete_user_from_group (request, admin, language, group_name_or_slot, del_user_phone)
return delete_user_from_group (request, user, language, group_name, member)[1]
elif command == language.SETNAME:
logger.debug('request set name user %s, username %s' % (user, username))
return set_username(request, user, language, username)[1]
else:
return request_update (user,language)[1]
def make_python(
fargish_code,
file=None, # If None, print to stdout
predefs=predefs,
preamble=preamble,
postamble='',
debug=False # If True, print the raw parsed items to stdout
):
if file is None:
file = sys.stdout
file = Indenting(file)
items = parse(fargish_code, predefs=predefs)
if (debug):
print('\n')
pp(items)
print()
env = Env(items)
print(preamble, file=file)
fixup = Indenting(StringIO())
for item in items:
if hasattr(item, 'gen'):
try:
item.gen(file, fixup, env)
except FARGishCompilerException as exc:
print('FARGish compiler exception when compiling: ', item)
print(exc)
raise
#TODO This really should become a special item in Env, so that .gen code
#can derive things from it.
# 'port_mates' is a global variable. You must pass it explicitly to
# PortGraph's ctor.
print('port_mates = PortMates()', file=file)
for link_defn in (i for i in items if isinstance(i, LinkDefn)):
fl = repr(link_defn.from_label.name)
tl = repr(link_defn.to_label.name)
print(f"port_mates.add({fl}, {tl})", file=file)
#print('port_hierarchy = Hierarchy()', file=file)
for chpa in (i for i in items if isinstance(i, PortLabelParent)):
ch = repr(chpa.child)
pa = repr(chpa.parent)
#print(f'port_hierarchy.declare_parent({pa}, {ch})', file=file)
print(f'port_mates.declare_parent({pa}, {ch})', file=file)
print('\nnodeclasses = {', file=file)
for nodedefn in (i for i in items if isinstance(i, NodeDefn)):
name = nodedefn.name
print(f' {repr(name)}: {name},', file=file)
print('}', file=file)
fixup.seek(0)
for line in fixup:
print(line, file=file, end='')
for pa in (i for i in items if isinstance(i, Postamble)):
pa.print(file)
print(postamble, file=file, end='')
def execute_debug(self, event = None):
self.__sym_table_3d = None
self.c = 0
# create debug player
window = Toplevel()
window['bg'] = 'black'
label_count = Label(window, text="Execute Now:",
borderwidth=0, width=10, bg = "black", fg = "white")
label_count.grid(row=0, column=0, sticky="nsew", padx=1, pady=1)
label_last = Label(window, text="Executed Before:",
borderwidth=0, width=10, bg = "black", fg = "white")
label_last.grid(row=0, column=2, sticky="nsew", padx=1, pady=1)
self.label_last_line = Label(window, text="Line: 1",
borderwidth=0, width=10, bg = "black", fg = "white")
self.label_last_line.grid(row=1, column=0, sticky="nsew", padx=1, pady=1)
execute = Button(window, text='>',
command=self.update_line_debugg)
execute.grid(row=1, column=1, sticky="nsew", padx=1, pady=1)
self.count = Label(window, text="Line: 0",
borderwidth=0, width=10, bg = "black", fg = "white")
self.count.grid(row=1, column=2, sticky="nsew", padx=1, pady=1)
window.grid_columnconfigure(0, weight=1)
window.grid_columnconfigure(1, weight=1)
window.grid_columnconfigure(2, weight=1)
window.resizable(width=True, height=False)
# get all txt from current tab
selectedTab = self.tabs.index("current")
currentTextArea = self.tabs.winfo_children()[selectedTab+1].textarea
input = currentTextArea.get('1.0','end-1c')
# new singleton symbol table
self.__sym_table = table()
# define mode for syntax-tree know how to autoexecute
self.__sym_table.setMode(0)
# start lex and sintactic analysis
ply_left = tenorC.parse()
self.__ast = ply_left(tenorC, input, self.__sym_table)
# TODO sintax error recover
if self.__ast != None:
self.__ast.execute(self.__sym_table)
self.codeGenerated = self.__ast.get3D()
def parse_re(pattern):
"""Parses a regular expression pattern and returns a string in a format
readable by a custom regex compiler.
Parameters:
pattern : a string regex pattern
Returns:
string : a string containing regex pattern converted into string of
functions readable by regex compiler
"""
return convert(parse('RE', pattern, REGRAMMAR)[0])
def play(self, action):
"""Takes an action and attempts to call it on the game instance.
Returns any message that might have been generated."""
location = self.game['location']
inventory = self.game['inv']
message = None
update = parse(action, location, inventory)
if isinstance(update, Room):
self.game['location'] = update
return None
return update
def play(self, action):
"""Takes an action and attempts to call it on the game instance.
Returns any message that might have been generated."""
location = self.game['location']
inventory = self.game['inv']
message = None
update = parse(action, location, inventory)
if isinstance(update, Room):
self.game['location'] = update
return None
return update
def initialize(data_matrix, root, old_structure, new_structure, num_iter=200):
root = root.copy()
if old_structure == new_structure:
return root
node, old_dist, rule = recursive.find_changed_node(root, old_structure, new_structure)
old = root.value()
# if we're replacing the root, pass on the observation model; otherwise, treat
# the node we're factorizing as exact real-valued observations
if node is root:
inner_data_matrix = data_matrix
else:
row_ids = recursive.row_ids_for(data_matrix, node)
col_ids = recursive.col_ids_for(data_matrix, node)
m_orig, n_orig = recursive.orig_shape_for(data_matrix, node)
frv = observations.DataMatrix.from_real_values
inner_data_matrix = frv(node.value(), row_ids=row_ids, col_ids=col_ids,
m_orig=m_orig, n_orig=n_orig)
print 'Initializing %s from %s...' % (grammar.pretty_print(new_structure), grammar.pretty_print(old_structure))
if rule == grammar.parse("gg+g"):
new_node = init_low_rank(inner_data_matrix, num_iter=num_iter)
elif rule == grammar.parse("mg+g"):
isotropic = (node is root)
new_node = init_row_clustering(inner_data_matrix, isotropic, num_iter=num_iter)
elif rule == grammar.parse("gM+g"):
isotropic = (node is root)
new_node = init_col_clustering(inner_data_matrix, isotropic, num_iter=num_iter)
elif rule == grammar.parse("bg+g"):
new_node = init_row_binary(inner_data_matrix, num_iter=num_iter)
elif rule == grammar.parse("gB+g"):
new_node = init_col_binary(inner_data_matrix, num_iter=num_iter)
elif rule == grammar.parse("cg+g"):
new_node = init_row_chain(inner_data_matrix, num_iter=num_iter)
elif rule == grammar.parse("gC+g"):
new_node = init_col_chain(inner_data_matrix, num_iter=num_iter)
elif rule == grammar.parse("s(g)"):
new_node = init_sparsity(inner_data_matrix, node.variance_type, num_iter=num_iter)
else:
raise RuntimeError('Unknown production rule: %s ==> %s' % (grammar.pretty_print(old_dist),
grammar.pretty_print(rule)))
root = recursive.splice(root, node, new_node)
if isinstance(data_matrix.observations, observations.RealObservations):
assert np.allclose(root.value()[data_matrix.observations.mask], old[data_matrix.observations.mask])
return root
def initialize(data_matrix, root, old_structure, new_structure, num_iter=200):
root = root.copy()
if old_structure == new_structure:
return root
node, old_dist, rule = recursive.find_changed_node(root, old_structure, new_structure)
old = root.value()
# if we're replacing the root, pass on the observation model; otherwise, treat
# the node we're factorizing as exact real-valued observations
if node is root:
inner_data_matrix = data_matrix
else:
row_ids = recursive.row_ids_for(data_matrix, node)
col_ids = recursive.col_ids_for(data_matrix, node)
m_orig, n_orig = recursive.orig_shape_for(data_matrix, node)
frv = observations.DataMatrix.from_real_values
inner_data_matrix = frv(node.value(), row_ids=row_ids, col_ids=col_ids,
m_orig=m_orig, n_orig=n_orig)
print('Initializing %s from %s...' % (grammar.pretty_print(new_structure), grammar.pretty_print(old_structure)))
if rule == grammar.parse("gg+g"):
new_node = init_low_rank(inner_data_matrix, num_iter=num_iter)
elif rule == grammar.parse("mg+g"):
isotropic = (node is root)
new_node = init_row_clustering(inner_data_matrix, isotropic, num_iter=num_iter)
elif rule == grammar.parse("gM+g"):
isotropic = (node is root)
new_node = init_col_clustering(inner_data_matrix, isotropic, num_iter=num_iter)
elif rule == grammar.parse("bg+g"):
new_node = init_row_binary(inner_data_matrix, num_iter=num_iter)
elif rule == grammar.parse("gB+g"):
new_node = init_col_binary(inner_data_matrix, num_iter=num_iter)
elif rule == grammar.parse("cg+g"):
new_node = init_row_chain(inner_data_matrix, num_iter=num_iter)
elif rule == grammar.parse("gC+g"):
new_node = init_col_chain(inner_data_matrix, num_iter=num_iter)
elif rule == grammar.parse("s(g)"):
new_node = init_sparsity(inner_data_matrix, node.variance_type, num_iter=num_iter)
else:
raise RuntimeError('Unknown production rule: %s ==> %s' % (grammar.pretty_print(old_dist),
grammar.pretty_print(rule)))
root = recursive.splice(root, node, new_node)
if isinstance(data_matrix.observations, observations.RealObservations):
assert np.allclose(root.value()[data_matrix.observations.mask], old[data_matrix.observations.mask])
return root
def repl_line():
line = input('FORMAT> ')
if line == 'RELOAD':
reload(grammar)
global parse
parse = grammar.parse
elif line == 'EXIT':
sys.exit()
elif line == 'PYTHON':
code.interact(local={**globals(), **locals()})
elif line:
result = parse(line)
print(result)
code.interact(local=locals())
def handle_message(self, message, extra):
try:
int_tree = grammar.parse(message)
tree = grammar.transform(int_tree)
# result = "```%s\n\n%s```" % (int_tree.pretty(), tree)
return self.handle_command(tree[0], tree[1], extra)
except grammar.exceptions.LarkError as error:
print(error)
return {
"error": "```%s```" % error.args[0],
"usage": self.usage("general"),
"edits": extra.get("edits", None)
}
def labelize(rule):
if rule == grammar.parse("gg+g"):
return 0
elif rule == grammar.parse("mg+g"):
return 1
elif rule == grammar.parse("gM+g"):
return 4
elif rule == grammar.parse("bg+g"):
return 2
elif rule == grammar.parse("gB+g"):
return 5
elif rule == grammar.parse("cg+g"):
return 3
elif rule == grammar.parse("gC+g"):
return 6
elif rule == grammar.parse("s(g)"):
return 7
else:
raise Exception("Never should reached here.")
def Parser(stringToParse, doLog):
result = None
if doLog:
print(">>> Parsing")
print(stringToParse)
try:
result = grammar.parse(stringToParse, actions=CanopyActions())
if doLog:
print(">>> Result")
#print (result)
print(json.dumps(result, indent=4, separators=(',', ': ')))
except Exception as e:
print(">>> PARSE ERROR")
print(str(e))
return result
def evalQuery(self):
from grammar import parse
p = parse(self.queryText.toPlainText())
if p:
results = []
for jobId, job in self.miner.data.items():
if p(job):
results.append(job)
#print( job["id"] )
for i, job in enumerate(results):
item = JobEntry(None, job)
self.queryResultsLayout.addWidget(item)
item.show()
if i > 4:
break
else:
print("Invalid query!")
def evalQuery( self ):
from grammar import parse
p = parse( self.queryText.toPlainText() )
if p:
results = []
for jobId, job in self.miner.data.items():
if p( job ):
results.append( job )
#print( job["id"] )
for i, job in enumerate( results ):
item = JobEntry( None, job )
self.queryResultsLayout.addWidget( item )
item.show()
if i > 4:
break
else:
print("Invalid query!")
def read_asm_file(filename):
""" Reads the assembly file at the given filename. If there is invalid syntax in the file, it
will throw an error. This will return a list of parsed instructions in the following format:
[List of Instruction]
Where Instruction is:
[InstructionName [ListOf Argument]]
Where Argument is either Register, Offset, or Immediate
Where Register is: ['$', RegisterNumber]
Where Offset is: [Number, Register or Immediate]
Where Immediate is: [Number] or ['-', Number] or ['0x', HexNumber]
"""
with open(filename, "rb") as f:
data = f.read()
print len(data.split("\n"))
parsed_instructions = grammar.parse(data)
if parsed_instructions is None:
action, rest = grammar.raw_parse(data)
error_char = len(data) - len(rest)
data_up_to_error = data[:error_char]
line_num = data_up_to_error.count("\n")
prev_newline = data_up_to_error.rfind("\n")
next_newline = rest.find("\n")
if prev_newline < 0:
prev_newline = 0
if next_newline < 0:
next_newline = len(rest)
relative_error_char = error_char - prev_newline
print "Syntax error at line %d, character %d" % (line_num + 1, relative_error_char)
print data[prev_newline:error_char] + rest[:next_newline]
print " " * relative_error_char + "^"
return None
return parsed_instructions
def read_asm_file(filename):
""" Reads the assembly file at the given filename. If there is invalid syntax in the file, it
will throw an error. This will return a list of parsed instructions in the following format:
[List of Instruction]
Where Instruction is:
[InstructionName [ListOf Argument]]
Where Argument is either Register, Offset, or Immediate
Where Register is: ['$', RegisterNumber]
Where Offset is: [Number, Register or Immediate]
Where Immediate is: [Number] or ['-', Number] or ['0x', HexNumber]
"""
with open(filename, 'rb') as f:
data = f.read()
print len(data.split('\n'))
parsed_instructions = grammar.parse(data)
if parsed_instructions is None:
action, rest = grammar.raw_parse(data)
error_char = len(data) - len(rest)
data_up_to_error = data[:error_char]
line_num = data_up_to_error.count('\n')
prev_newline = data_up_to_error.rfind('\n')
next_newline = rest.find('\n')
if prev_newline < 0:
prev_newline = 0
if next_newline < 0:
next_newline = len(rest)
relative_error_char = error_char - prev_newline
print "Syntax error at line %d, character %d" % (line_num + 1, relative_error_char)
print data[prev_newline:error_char] + rest[:next_newline]
print ' ' * relative_error_char + '^'
return None
return parsed_instructions
def read_file(self, fname):
"""
Simple generator to parse log files
"""
# Here we try to memory map the file and just use the findall
with open(fname, 'r') as logfile:
#contents = mmap.mmap(logfile.fileno(), os.stat(fname).st_size)
contents = logfile.read()
for match in self.rex.finditer(contents, re.MULTILINE | re.DOTALL):
thread_id = match.group(1)
syscall_number = match.group(2)
syscall_name = match.group(3)
eip = match.group(4)
caller = match.group(5)
caller_offset = match.group(6)
hexargs = match.group(7)
args = match.group(8)
#ret = match.group(12)
ret = ''
hexargs = map(lambda x: x.strip(), hexargs.strip().split(','))
args = parse(args)
yield (thread_id, syscall_number, syscall_name, eip, hexargs, args, ret, caller_offset)
from grammar import parse
from math import *
if __name__ == "__main__":
UDPSock = socket(AF_INET, SOCK_DGRAM)
UDPSock.bind(('', 1964))
f = open("examples.txt", "a")
normalizer = NumeralsNormalizer("numerals.txt")
transformer = NumeralsTransformer(normalizer)
while True:
data, addr = UDPSock.recvfrom(1969)
if not data:
print("Program has exited!")
break
else:
x = data.decode('utf-8')
f.write(x)
f.write("\n")
print(x.ljust(50), addr[0])
try:
result = parse(transformer.replace_with_numbers(x.lower()))
print("result: " + str(eval(result)) + "\n")
except:
pass
UDPSock.close()
self.program.append(Instruction('PLUS', None))
else:
raise ValueError(node.type)
def CALL(self, node):
for arg in node.args[::-1]:
self.eval(arg)
self.eval(node.name)
self.program.append(Instruction('CALL', len(node.args)))
text = 'x:=0; while x < 5 { print(x); x := x+1; }'
from grammar import parse
from interpreter import Intepreter, run
from pprint import pprint
# i = Intepreter()
ast = parse(text)
# pprint(ast)
bcc = ByteCodeCompiler()
bcc.compile(ast)
i = run(bcc.program)
# print i.namespace
def index(request, user, language):
logger.debug('entry point')
# XXX set language on-the-fly
# or pull from db based on users selection on phone
# language = LanguageFactory.create_language('eng')
if request.method == "GET":
logger.debug('get request')
return request_update(user, language)
raw_text = request.raw_post_data.decode('UTF8')
logger.info('user: %s text: %s' % (user, raw_text))
# empty request
if not raw_text:
return request_update(user, language)
msg_list = []
tokens = raw_text.split()
parsed_text = grammar.parse(tokens, language)
command = parsed_text['command']
extras = parsed_text['extras']
member = parsed_text['member']
group_name = parsed_text['group']
if command == language.CREATE:
logger.debug('request create group %s' % group_name)
# request, user, language, group_name, slot
return request_create_group(request, user, language, group_name, '')[1]
elif command == language.JOIN:
logger.debug('request join group %s' % group_name)
# request, user, language, group_name, slot
return join_group(request, user, language, group_name)[1]
elif command == language.INVITE:
# (request, user, language, group_name_or_slot, invite_user_phone, smsc = 'mosms')
logger.debug('request invite user %s to group %s' % (user, group_name))
invited_users = ' '.join([member, extras])
return invite_user_to_group(request, user, language, group_name,
invited_users)[1]
elif command == language.LEAVE:
logger.debug('request leave group %s' % group_name)
# leave_group (request, user, language, group_or_slot)
return leave_group(request, user, language, group_name)[1]
elif command == language.DELETE:
logger.debug('request delete group %s' % group_name)
# delete_group (request, admin, language, group_name_or_slot)
return delete_group(request, user, language, group_name)[1]
elif command == language.REMOVE:
logger.debug('request remove user %s' % user)
# delete_user_from_group (request, admin, language, group_name_or_slot, del_user_phone)
return delete_user_from_group(request, user, language, group_name,
member)[1]
elif command == language.SETNAME:
logger.debug('request set name user %s, username %s' %
(user, username))
return set_username(request, user, language, username)[1]
elif command == language.TEXT:
logger.debug('sending sms to group %s' % group_name)
return send_group_sms(request, user, language, group_name, extras)
else:
return request_update(user, language)[1]
def test_two_word_moving(self):
"Using a direction in two words (e.g. 'go west') should return a new Room object"
action = "go south"
self.assertEquals(parse(action, self.room, self.inv), self.southern_room)
def run(string):
return parse(filter_ascii(string).strip(), actions=Actions())
def test_invalid_verb(self):
"An invalid verb should return an error message"
action = "jump"
self.assertEquals(parse(action, self.room, self.inv), "That is not a valid action.")
def test_action_on_item_in_room(self):
"<action, valid_noun> should perform the appropriate action"
action = "open dresser"
self.assertEquals(parse(action, self.room, self.inv), self.dresser.open_description)
search => xalphas + search | xalphas
login => userpassword hostport | hostport
userpassword => user : password @ | user @
user => alphanum2 user | alphanum2
password => alphanum2 password | password
path => void | segment / path | segment
void => ()
digits => digit digits | digit
digit => [0-9]
alpha => [a-zA-Z]
safe => [-$_@.&+]
extra => [()!*''""]
escape => % hex hex
hex => [0-9a-fA-F]
alphanum => alpha | digit
alphanums => alphanum alphanums | alphanum
alphanum2 => alpha | digit | [-_.+]
ialpha => alpha xalphas | alpha
xalphas => xalpha xalphas | xalpha
xalpha => alpha | digit | safe | extra | escape
""", whitespace = '()')
print "--URL grammar:\n",(URL)
print
verify(URL)
print
print "--parsed http://www.w3.org/Addressing/URL/5_BNF.html:\n",(parse('url', 'http://www.w3.org/Addressing/URL/5_BNF.html', URL))
print "--print_grammar: URL"
print_grammar(URL)
def stand_on_dark_chair(self):
"Should set has_User to True"
self.room.objects.append(self.chair)
action = "stand on dark chair"
parse(action, self.room, self.inv)
self.assertTrue(self.chair.has_user)
def test_valid_action_with_invalid_object(self):
"An action performed on an object that doesn't exist will return an error"
action = "look in chest"
self.assertEquals(parse(action, self.room, self.inv), "That object does not exist.")
def test_action_with_unhelpful_adj(self):
"If adjective is unhelpful but noun does not encounter any conflicts, should call verb on obj"
self.room.objects.append(self.chair)
action = "climb sturdy chair"
self.assertEquals(parse(action, self.room, self.inv), "You clamber onto the object.")
def test_stand_on_object(self):
"'stand on' is called as obj.stand()"
self.room.objects.append(self.chair)
action = "stand on chair"
self.assertEquals(parse(action, self.room, self.inv), "You clamber onto the object.")
import grammar
import pprint
pp = pprint.PrettyPrinter()
#pp.pprint(grammar.parse('goal', 'wtf = 7 + 5 + 4 / (7+2) * 3; RAND(4, 7);'))
#pp.pprint(grammar.parse('goal', 'Q = INBOX[47];'))
#pp.pprint(grammar.parse('goal', 'Q = AREA[47,42];'))
x = grammar.parse('goal', 'x = AREA[-2,-3] * (7/4) + y * 8 + INBOX[5] + RAND % 47; MOVE(-1,0);')
for st in x:
print st.output(2)
parser.add_argument('level', type=int)
add_scheduler_args(parser)
args = parser.parse_args()
init_level(args.name, args.level)
if args.level > 1:
run_jobs(initial_samples_jobs(args.name, args.level), args,
initial_samples_key(args.name, args.level))
elif command == 'init_job':
parser.add_argument('name', type=str)
parser.add_argument('level', type=int)
parser.add_argument('structure', type=str)
parser.add_argument('split_id', type=int)
parser.add_argument('sample_id', type=int)
args = parser.parse_args()
compute_init_samples(args.name, args.level, grammar.parse(args.structure),
args.split_id, args.sample_id)
elif command == 'eval':
parser.add_argument('name', type=str)
parser.add_argument('level', type=int)
add_scheduler_args(parser)
args = parser.parse_args()
run_jobs(evaluation_jobs(args.name, args.level), args, evaluation_key(args.name, args.level))
collect_scores_for_level(args.name, args.level)
elif command == 'eval_job':
parser.add_argument('name', type=str)
parser.add_argument('level', type=int)
parser.add_argument('init_structure', type=str)
parser.add_argument('structure', type=str)
def test_look(self):
"Verb should return current room's description"
action = "look"
self.assertEquals(parse(action, self.room, self.inv), self.room.description)
def json_parse(text):
return parse("value", text, JSON)
import grammar as g
if __name__ == '__main__':
f = open("./entrada.txt", "r")
input = f.read()
print(input)
root = g.parse(input)
print(root)
import grammar as g
if __name__ == '__main__':
f = open("./entrada.txt", "r")
input = f.read()
print(input)
g.parse(input)
print('> Analisis Finalizado')
def analizar(txt):
print("analizando...")
print(txt)
salida_table()
parse(txt)
import grammar
import sys
prefix = """
#include "map.h"
#include <cstdlib>
class Player%s : public Unit {
public:
virtual void RealStep() {"""
suffix = """
}
};
"""
fp = open(sys.argv[1])
data = fp.read()
x = grammar.parse('goal', data)
print prefix % sys.argv[2]
for st in x:
print st.output(4)
print suffix
def test_invalid_action_with_valid_object(self):
"An invalid action will return an action-related error message"
action = "stand on lamp"
self.assertEquals(parse(action, self.room, self.inv), "That is not a valid action.")
action = "spit on bed"
self.assertEquals(parse(action, self.room, self.inv), "That is not a valid action.")
def test_action_when_two_objects_have_same_name(self):
"When two objects have the same name, return an error message"
self.room.objects.append(self.lamp)
action = "snuff lamp"
self.assertEquals(parse(action, self.room, self.inv), "More than one object fits that name.")
def test_direction(self):
"Direction should return a Room object if the direction is valid, or an error string if it is not valid"
action = "south"
self.assertEquals(parse(action, self.room, self.inv), self.southern_room)
action = "n"
self.assertEquals(parse(action, self.room, self.inv), "You cannot go that way.")
def analizar_select(e):
global selected
if my_text.selection_get():
selected = my_text.selection_get()
print(selected)
parse(selected)
def test_action_on_invalid_item(self):
"Calling an action on an item that does not exist should return an error message"
action = "get boot"
self.assertEquals(parse(action, self.room, self.inv), "That object does not exist.")
def execute_current_tab_lef(self):
# get all txt from current tab
selectedTab = self.tabs.index("current")
currentTextArea = self.tabs.winfo_children()[selectedTab+1].textarea
input = currentTextArea.get('1.0','end-1c')
# new singleton symbol table
self.__sym_table = table()
# define mode for syntax-tree know how to autoexecute
self.__sym_table.setMode(0)
# start lex and sintactic analysis
ply_left = tenorC.parse()
self.__ast = ply_left(tenorC, input, self.__sym_table)
# TODO sintax error recover
if self.__ast != None:
self.__ast.execute(self.__sym_table)
self.codeGenerated = self.__ast.get3D()
## start executing
ply_left_3d = titus.parse()
result = ply_left_3d(titus, self.codeGenerated)
if result:
ast_3D = result[0]
ast_3D.setType("LABEL")
ast_3D.setValue("S")
ast_3D.root = True
self.__sym_table_3d = result[1]
# define mode for syntax-tree know how to autoexecute
self.__sym_table_3d.setMode(1)
goto_called = True
start_from = "MAIN"
compute = [None, None]
while goto_called:
goto_called = False
self.__sym_table_3d.terminal = self.terminal
compute = ast_3D.start_execute(self.__sym_table_3d, start_from)
# lookup the last line
index = self.terminal.search(r'\n', "insert", backwards=True, regexp=True)
txt = self.terminal.get(str(index),'end-1c')
if txt == "":
index ="1.0"
else:
index = self.terminal.index("%s+1c" % index)
if compute[0]:
self.terminal.insert(str(float(index)+1), compute[0])
self.__sym_table_3d.cleanLog()
if compute[1]:
goto_called = True
start_from = compute[1]
elif self.__sym_table.error != '':
# lookup the last line
index = self.terminal.search(r'\n', "insert", backwards=True, regexp=True)
txt = self.terminal.get(str(index),'end-1c')
if txt == "":
index ="1.0"
else:
index = self.terminal.index("%s+1c" % index)
self.terminal.insert(str(float(index)+1), "\nTenorC>> Error Report Generated\n")
def test_invalid_action_on_item(self):
"Calling an invalid action on an existing item should return an error message"
action = "kick bed"
self.assertEquals(parse(action, self.room, self.inv), "That is not a valid action.")
