def tout_faire(text):
lexer = Lexer(text)
tokens = tuple(lexer.generate_tokens)
parser = Parser(tokens)
tree = parser.parse()
interpreter = Interpreter()
return interpreter.visit(tree)
def main():
with open("test.py", "r") as fin:
text = fin.read()
lex = Lexer(text)
par = Parser(lex)
root = par.parse()
return Run(root)
def _run(self, source: str):
token_sc = Scanner(source)
tokens = token_sc.scan_tokens()
parser = Parser(tokens)
expression = parser.parse()
if self.had_error: #if syntax error stop interpreting
return
print(AstPrinter().print(expression))
def main():
while True:
text = input("calc> ")
lexer = Lexer(text)
tokens = list(lexer.generate_tokens())
parser = Parser(tokens)
tree = parser.parse()
if not tree: continue
interpreter = Interpreter()
result = interpreter.visit(tree)
print(result)
def main():
with open('/home/aiyane/code/python/Bytecode/test2.py', "r", encoding="utf8") as f:
text = f.read()
lex = Lexer(text)
parser = Parser(lex)
root = parser.parse()
res = VisitNode(root).result()
with open('res.dot', 'w', encoding="utf8") as f:
f.write(res)
return res
def main():
parser = argparse.ArgumentParser(
description=
'Run a "Ultimate Programming Language to Take Over a Prison, Then He World" program!'
)
parser.add_argument(
'source',
metavar='src',
type=str,
help=
'The "Ultimate Programming Language to Take Over a Prison, Then He World" program to run'
)
args = parser.parse_args()
t = Tokenizer()
prog = Program()
tokens = t.tokenize(args.source)
days = Parser.parse(tokens)
prog.run(days)
# =======================================================
# = Lexer =
# =======================================================
# msgs_log.print_title("Doing Lexer")
# start = time.time()
contents = f.read()
tokens = lexer.run(contents)
# end = time.time()
# print("Execution time: " + str(end - start) + "ms")
# =======================================================
# = Parser =
# =======================================================
# msgs_log.print_title("Doing Parser")
# start = time.time()
parser = Parser(tokens)
ast = parser.parse()
# end = time.time()
# print("Execution time: " + str(end - start) + "ms")
# =======================================================
# = CSharp Code Generation =
# =======================================================
# if not parser.error:
# # msgs_log.print_title("Doing Code Generator (C#)")
# # start = time.time()
# code_generator = CSharp(ast, parser.current_symb_tbl)
# res = code_generator.gen_base_structure(ast.stmts)
# if not os.path.exists('obj'):
# os.makedirs('obj')
# if args.dst:
# f_name = f"{args.dst}.cs"
from interpreter import Interpreter
from lexer import Lexer
from parser_ import Parser
from interpreter import Interpreter
while True:
try:
text = input("clac >")
lexer = Lexer(text)
tokens = lexer.generate_tokens()
parser = Parser(tokens)
tree = parser.parse()
if not tree: continue
interpreter = Interpreter()
value = interpreter.visit(tree)
print(value)
except Exception as e:
print(e)
return ("x\u2228¬x", "x\u2228¬x") if table[0][0] == 1 else ("False",
"False")
knf_result = []
dnf_result = []
for item in table:
if item[0] == 0:
sequence = "(" + '\u2228'.join([
literals[i] if item[1][i] == 0 else "¬" + literals[i]
for i in range(len(literals))
]) + ")"
knf_result.append(sequence)
else:
sequence = "(" + ''.join([
literals[i] if item[1][i] == 1 else "¬" + literals[i]
for i in range(len(literals))
]) + ")"
dnf_result.append(sequence)
return '\u2227'.join(knf_result), '\u2228'.join(dnf_result)
while True:
t = input("> ")
lexer = Lexer(t)
tokens = lexer.generate_tokens()
parser = Parser(tokens)
result = parser.parse()
print(result)
calculate_result(result, sorted(parser.literals))
class Application:
setting_file_path = './settings'
main_root = None
tool_root = None
timer_root = None
main_frame = None
tool_frame = None
timer_frame = None
is_centering = None
chr_num = 0
parser = None
manager = None
token = None
indexes = None
lap_time = None
def __init__(self):
def empty2None(d: dict):
for k in d:
if isinstance(d[k], dict):
empty2None(d[k])
elif d[k] == '':
d[k] = None
self.lap_time = []
self.indexes = [[0, 0]]
self.chr_num = 0
ruby = ["《", "》"]
for_printer1 = ["[", "]"]
for_printer2 = ["［", "］"]
self.parser = Parser()
try:
self.parser.add_ignore(ruby)
self.parser.add_ignore(for_printer1)
self.parser.add_ignore(for_printer2)
except Exception as e:
print(e)
sys.exit(1)
self.main_root = tk.Tk()
self.tool_root = tk.Toplevel()
self.main_frame = ttk.Frame(self.main_root)
self.tool_frame = ttk.Frame(self.tool_root)
self.timer_root = tk.Toplevel()
self.timer_frame = ttk.Frame(self.timer_root)
if os.path.isfile(self.setting_file_path):
with open(self.setting_file_path) as f:
s = f.read()
d = json.loads(s)
empty2None(d)
self.manager = LayoutManager(self.main_frame, self.tool_frame,
self.timer_frame, d)
else:
self.manager = LayoutManager(self.main_frame, self.tool_frame)
self.manager.layout([
x for x in range(self.manager.settings['structure']['nest'] *
self.manager.settings['structure']['row'] *
self.manager.settings['structure']['column'])
], Layout.STRIPE)
self.key_binding(self.main_root)
self.main_frame.focus_set()
def key_binding(self, target):
target.bind("<Return>", self.on_pressed_return)
target.bind("<Control-v>", self.on_paste)
target.bind("<space>", self.on_pressed_space)
target.bind("<Key-t>", self.on_pressed_t)
def on_pressed_return(self, e):
#print('{} {}'.format(self.indexes[-1],len(self.token.clause_index)))
if self.indexes[-1][0] < len(self.token.clause_index):
index = copy.copy(self.indexes[-1])
new_index = self.manager.layout([
''.join(list(map(lambda i: self.token.words[i],
clause))).strip()
for clause in self.token.clause_index[index[0]:]
], Layout.STRIPE)
index[0] += new_index[0]
index[1] += new_index[1]
if len(self.lap_time) > 0:
s = ''.join(self.manager.now_clause_list)
self.lap_time.append((s, time.time()))
self.indexes.append(index)
print(self.indexes)
self.manager.progress.configure(value=index[0])
def on_paste(self, e):
self.indexes = [[0, 0]]
cb = self.main_root.clipboard_get().strip()
self.token = self.parser.parse(cb, sys.maxsize)
self.indexes.append(
self.manager.layout([
''.join(list(map(lambda i: self.token.words[i],
clause))).strip()
for clause in self.token.clause_index
], Layout.STRIPE))
self.manager.progress.configure(value=self.indexes[-1][0],
maximum=len(self.token.clause_index),
mode='determinate')
def on_pressed_space(self, e):
if len(self.indexes) > 2:
self.indexes.pop(-1)
self.indexes.pop(-1)
index = copy.copy(self.indexes[-1])
print(self.indexes)
new_index = self.manager.layout([
''.join(list(map(lambda i: self.token.words[i],
clause))).strip()
for clause in self.token.clause_index[index[0]:]
], Layout.STRIPE)
index[0] += new_index[0]
index[1] += new_index[1]
self.indexes.append(index)
self.manager.progress.configure(value=index[0])
def on_pressed_t(self, e):
if len(self.lap_time) == 0:
self.lap_time.append(('', time.time()))
else:
for i in range(len(self.lap_time)):
if i != 0:
print('Read {} chars in {} sec.'.format(
len(self.lap_time[i][0]),
self.lap_time[i][1] - self.lap_time[i - 1][1]))
self.lap_time.clear()
print('>>>', end=' ', flush=True)
scanner = Scanner()
tokens = []
parser = Parser()
while True:
f = io.StringIO(sys.stdin.readline())
try:
tokens.extend(eval_lexemes(scanner.scan('<stdin>', f)))
except LispError as error:
print(error.fullstr())
break
if scanner.state == scanner.scan_whitespace:
try:
parser.parse(tokens)
except LispError as error:
print(error.fullstr())
break
if len(parser.expr_stack) == 1:
try:
print(machine.exec_(compile_(parser.end())))
except LispError as error:
print(error.fullstr())
break
print('...', end=' ', flush=True)
