def setUp(self):
self.add = SignatureParser("add(real, vector) => vector")
self.int_var = IntVariable("myint", 5)
self.real_var1 = RealVariable("Rev", "myreal1", 0.5)
self.real_var2 = RealVariable("Rev", "myreal2", 0.5)
self.matrix_var = MatrixVariable("Rev", "mymatrix", "matrix", 2, 0.5)
self.cg = CodeGenerator()
def main():
inpt = Path(sys.argv[1])
if inpt.is_dir():
input_paths = inpt.glob("*.jack")
for src in OS_LIB.glob("*.vm"):
dst = inpt.joinpath(src.name)
shutil.copy(src, dst)
for src in EXTRA_OS_LIBS:
dst = inpt.joinpath(src.name)
shutil.copy(src, dst)
else:
input_paths = [inpt]
for input_path in input_paths:
output_path = input_path.parent.joinpath(f"{input_path.stem}.vm")
lines = (line for line in input_path.read_text().split("\n"))
# lines = print_gen(lines)
tokens = gen_tokens_for_lines(lines=lines)
parser = Parser(tokens)
cls = parser.parse_class()
code_generator = CodeGenerator()
code = code_generator.generate(cls)
output_path.write_text("\n".join(code))
def test_function_calls(vm):
g = CodeGenerator()
code = g.translate(commands=[
(0, 'call', 'main', 0),
(1, 'goto', 'end'),
(2, 'function', 'main', 0),
(3, 'push', 'constant', 10),
(4, 'push', 'constant', 20),
(5, 'call', 'double-sum', 2),
(6, 'return'),
(7, 'function', 'double-sum', 1),
(8, 'push', 'argument', 0),
(9, 'push', 'argument', 1),
(10, 'add'),
(11, 'pop', 'local', 0),
(12, 'push', 'local', 0),
(13, 'push', 'local', 0),
(14, 'add'),
(15, 'return'),
(16, 'label', 'end'),
],
filename='<input>',
)
vm.execute(code, 500)
assert vm.ram[vm.symbols['SP']] == vm.stack_offset + 1
assert vm.ram[vm.stack_offset] == 2 * (10 + 20)
def save_point_to_tmp(self, sql, rdd, once_size=1000):
'''
批量数据库操作
:param sql:要批量执行的语句
:param rdd:数据源RDD，经过Map操作得到的tuple列表[(a,b,c),(d,e,f),(d.f.g)]
:param once_size:每次执行的条数，默认每次一千条
:return:
'''
cg = CodeGenerator()
current_args = list()
args = rdd.collect()
for i in range(len(args)):
if len(args) != 0:
full_arg = [
cg.get_sequence('point'),
]
full_arg.extend(args.pop())
current_args.append(full_arg)
# 但前参数长度达到批量值 或者 剩余参数已为0
if len(current_args) >= once_size or len(args) == 0:
if len(current_args) > 0:
try:
self.executemany_without_commit(sql, current_args)
except Exception as e:
return e, current_args
current_args.clear()
self.cnn.commit()
def main(filename, execute):
try:
print "filename=", filename
prefix= filename.split(".")[0]
output_file_name = prefix + ".py"
output = open(output_file_name, 'w')
f = open(filename, "r")
data = simplejson.load(f)
data = byteify(data)
codegen = CodeGenerator()
#name the testcase
codegen = identify_imports(data, codegen)
codegen += ""
codegen += ""
codegen += "class Test7777777(%s):" % (IdentifyParentClasses(data))
codegen.indent()
codegen += "test_id = 7777777"
codegen = identify_resources(data, codegen)
codegen = createSetupMethod(data, codegen)
codegen = createRunMethod(data, codegen)
output.write(str(codegen))
return str(codegen)
except:
raise
def __init__(self, file_name):
self.file_name = file_name
self.stack = Stack()
self.stack.push("EOF")
self.stack.push("Source")
self.parser_table = PARSER_TABLE
self.symbol_table = OOPSymbolTable()
self.semantic_stack = Stack()
self.memory_manager = MemoryManager(1000, 2000)
self.scanner = Scanner(file_name, self.symbol_table)
self.next_token = self.scanner.get_next_token()
self.top_stack = self.stack.top()
self.rule_number = None
self.rule = ""
self.grammar = GRAMMAR
self.error_handler = ErrorHandler(self.scanner)
self.symbol_table.set_error_handler(self.error_handler)
self.semantic_analyzer = SemanticAnalyzer(self.symbol_table,
self.memory_manager,
self.semantic_stack,
self.error_handler)
self.code_generator = CodeGenerator(self.symbol_table,
self.semantic_stack,
self.memory_manager)
self.current_identifier = None
self.follow = FOLLOW
self.non_terminal = 0
self.must_get = False
def test_return_statement(vm):
n_args = 3
frame_offset = 512
current_sp = frame_offset + 100
arg1 = 111
arg2 = 222
arg3 = 333
caller_arg = 254
caller_lcl = caller_arg + 5
caller_this = 1234
caller_that = 2345
return_addr = 6000
return_value = 42
vm.ram[frame_offset + 0] = arg1
vm.ram[frame_offset + 1] = arg2
vm.ram[frame_offset + 2] = arg3
vm.ram[frame_offset + 3] = return_addr
vm.ram[frame_offset + 4] = caller_lcl
vm.ram[frame_offset + 5] = caller_arg
vm.ram[frame_offset + 6] = caller_this
vm.ram[frame_offset + 7] = caller_that
vm.ram[current_sp - 1] = return_value
vm.ram[vm.symbols['LCL']] = frame_offset + n_args + 5
vm.ram[vm.symbols['ARG']] = frame_offset
vm.ram[vm.symbols['THIS']] = 5555
vm.ram[vm.symbols['THAT']] = 6666
vm.ram[vm.symbols['SP']] = current_sp
g = CodeGenerator()
g.translate(commands=[
(0, 'function', 'fn', 0),
],
filename='<input>',
)
code = g.translate(commands=[
(0, 'return'),
],
filename='<input>',
)
vm.execute(code, 100)
assert vm.ram == {
vm.symbols['SP']: frame_offset + 1,
vm.symbols['LCL']: caller_lcl,
vm.symbols['ARG']: caller_arg,
vm.symbols['THIS']: caller_this,
vm.symbols['THAT']: caller_that,
frame_offset + 0: return_value,
frame_offset + 1: arg2,
frame_offset + 2: arg3,
frame_offset + 3: return_addr,
frame_offset + 4: caller_lcl,
frame_offset + 5: caller_arg,
frame_offset + 6: caller_this,
frame_offset + 7: caller_that,
current_sp - 1: return_value,
}
def take_action(self, parsed_args):
config_parser = ConfigurationParser()
config = config_parser.parse(parsed_args.config_file)
code_generator = CodeGenerator(config)
code_generator.generate()
setup_script_generator = SetupScriptGenerator()
setup_script_generator.generate(config)
def take_action(self, parsed_args):
config_parser = ConfigurationParser()
config = config_parser.parse(parsed_args.config_file)
code_generator = CodeGenerator(config)
code_generator.generate()
setup_script_generator = SetupScriptGenerator()
setup_script_generator.generate(config)
class Translator:
def __init__(self):
self.__parser = None
self.__generator = None
@contextlib.contextmanager
def __init_resorces(self):
self.__parser = Parser()
self.__generator = CodeGenerator()
yield
self.__parser = None
self.__generator = None
def translate(self, path, dry_run=False):
with self.__init_resorces():
blocks = self.__translate(path)
if dry_run:
for _ in blocks:
pass
else:
output = self.__make_output_name(path)
with open(output, 'w') as f:
for block in blocks:
f.write(block)
f.write('\n')
def __translate(self, path):
if os.path.isdir(path):
yield from self.__translate_project(path)
else:
yield from self.__translate_file(path)
def __translate_project(self, path):
yield self.__generator.gen_initializer()
for fname in glob.iglob(os.path.join(path, '*.vm')):
yield from self.__translate_file(fname)
def __translate_file(self, path):
filename = os.path.splitext(os.path.basename(path))[0]
commands = self.__parser.parse_file(path)
yield from self.__generator.itranslate(filename, commands)
def __make_output_name(self, input_name):
if os.path.isdir(input_name):
dirname = os.path.basename(os.path.abspath(input_name))
fname = os.path.join(input_name, dirname)
else:
fname, _ = os.path.splitext(input_name)
return fname + '.asm'
def __init__(self, tree: Program, symbol_table: SymbolTable,
source_file: str) -> None:
llvm.initialize()
llvm.initialize_all_targets()
llvm.initialize_all_asmprinters()
self.tree = tree
self.codegen = CodeGenerator(symbol_table)
self.source_file = source_file
self.target = llvm.Target.from_triple(llvm.get_default_triple())
def test_expression_with_ops():
toks = gen_tokens_for_lines(lines=["1 * 2 + 3;"])
parsed = Parser(toks).parse_expression()
code_gen = CodeGenerator()
code = code_gen.generate_expression(parsed)
assert code == [
"push constant 1",
"push constant 2",
"push constant 3",
"add",
"call Math.multiply 2",
]
def test_label(vm):
g = CodeGenerator()
code = g.translate(commands=[
(0, 'label', 'name1'),
(1, 'label', 'name2'),
],
filename='<input>',
)
vm.execute(code, 100)
assert vm.symbols['<input>$name1'] == 0
assert vm.symbols['<input>$name2'] == 1
def __init__(self, functionDefinitionTable, classTable):
self.localSymbolTable = SymbolTable()
self.functionTable: SymbolTable() = functionDefinitionTable
self.preemptiveFunctionCallTable = SymbolTable()
self.semanticsChecker = SemanticsChecker()
self.codeGenerator = CodeGenerator()
self.expressionStack = deque()
self.currentFunctionId = ''
self.currentFunction = None
self.classTable = classTable
self.checkClassDefinitionsSemantics()
self.currentClass = None
self.currentFunctionReturn = False
self.functionCallStack = list()
def test_goto(vm):
g = CodeGenerator()
code = g.translate(commands=[
(0, 'push', 'constant', 10),
(1, 'goto', 'end'),
(2, 'push', 'constant', 20),
(3, 'label', 'end'),
],
filename='<input>',
)
vm.execute(code, 100)
assert vm.ram == {
vm.symbols['SP']: vm.stack_offset + 1,
vm.stack_offset + 0: 10,
}
def main():
prog = '''
int g = 1 - 2 - 3;
bool axx = true;
int[] aaa = new int[10];
aaa[0] = 10;
string g3 = "kek";
int t = 4 + 5;
double wow = g + t;
t = 10 * 12 - (g + g);
double s = 90;
for (int i = 0, j = 8; ((i <= 5)); i = i + 1)
for(; t < g;)
if (t > 7 + g) {
t = t + g * (2 - 1) + 0; // comment 2
g3 = "98\tура";
}
for(;;);
string[] arr = new string[10];
int[] kek = new int[]{ 1, 2, 3, 4, 5 };
public int[] what(int a, int b)
{
int[] c = new int[]{5, 4, 6, 5, 1};
string fff = "asd";
return c;
}
public static void whatElse(int a, int b)
{
int[] c = what(a, b);
c[a + b] = 0;
int e = c[3];
while (true)
{
a = a + b;
do
{
b = a - b * b;
}
while (g + t > t)
}
return;
}
'''
prog = mel_parser.parse(prog)
# print(*prog.tree, sep=os.linesep)
a = Analyzer()
the_prog, _ = a.analyze(prog)
gen = CodeGenerator(the_prog, '')
# try:
# a.analyze(prog)
# except ValueError as e:
# print(e)
print(*the_prog.tree, sep=os.linesep)
def test_not(vm):
vm.ram[vm.stack_offset + 0] = 22
vm.ram[vm.symbols['SP']] += 1
g = CodeGenerator()
code = g.translate(commands=[
(0, 'not'),
],
filename='<input>',
)
vm.execute(code, max_steps=100)
assert vm.ram == {
vm.symbols['SP']: vm.stack_offset + 1,
vm.stack_offset + 0: ~22,
}
def run(self):
self._state = CompilationState.Downloading
# Get the app metadata
appstore_uuid = self._parameters["app"]["id"] # Passed from JS-land
appstore_uuid = re.sub(r"[^a-f0-9]", "", appstore_uuid)
assert len(appstore_uuid) == 24, "Bad app UUID specified"
self.app_metadata = app_metadata = requests.get("https://api2.getpebble.com/v2/apps/id/%s" % appstore_uuid).json()["data"][0]
# Fetch the app itself, if we need to
cached_pbw_name = "%s-%s.pbw" % (appstore_uuid, app_metadata["latest_release"]["id"])
cached_pbw_path = os.path.join(self._pbw_cache_dir, cached_pbw_name)
# (this has a race condition if you start a bunch of jobs at once)
if not os.path.exists(self._pbw_cache_dir):
os.makedirs(self._pbw_cache_dir)
# Also a race condition here if two jobs were using the same PBW at once
if not os.path.exists(cached_pbw_path):
pbw_data = requests.get(app_metadata["latest_release"]["pbw_file"]).content
with open(cached_pbw_path, "wb") as pbwhnd:
pbwhnd.write(pbw_data)
else:
os.utime(cached_pbw_path, None) # So I can invalidate the cache by file metadata
self._state = CompilationState.GeneratingCode
# Generate the required C code
modules_dir = os.path.join(os.path.dirname(__file__), "modules")
c_code = CodeGenerator.generate_c_code(modules_dir, self._parameters["configuration"])
# Set up our scratch space (same race condition as earlier...)
scratch_dir = os.path.join(self._scratch_dir, self.uuid)
if not os.path.exists(scratch_dir):
os.makedirs(scratch_dir)
# Write out config for later perusal
json.dump(self._parameters, open(os.path.join(scratch_dir, "parameters.json"), "w"))
c_code_path = os.path.join(scratch_dir, "mods.c")
open(c_code_path, "w").write(c_code)
# We swap out the UUID so the app store doesn't auto-update it away
# We use a hard-to-guess prefix so people can't upload remixed apps in the PAS - only we should be doing that
sha1 = hashlib.sha1()
sha1.update(app_metadata["uuid"].encode("ascii"))
sha1.update(os.environ.get("REMIXED_UUID_KEY", "").encode("ascii"))
new_uuid = uuid.UUID("5a4d" + sha1.hexdigest()[:4] + app_metadata["uuid"][8:])
self.output_pbw_uuid = new_uuid
# Create the patched PBW
self._state = CompilationState.Patching
pbw_output_name = re.sub("[^a-zA-Z0-9]", "", unidecode(app_metadata["title"])) + "-remixed.pbw"
pbw_output_path = os.path.join(scratch_dir, pbw_output_name)
# Create a one-off logger to record the carnage
patch_logger = logging.getLogger("rockgarden")
patch_logger.setLevel(logging.DEBUG)
fh = logging.FileHandler(os.path.join(scratch_dir, "patch.log"))
patch_logger.addHandler(fh)
Patcher(scratch_dir=os.path.join(scratch_dir, "patcher")).patch_pbw(cached_pbw_path, pbw_output_path, c_sources=[c_code_path], new_uuid=new_uuid, cflags=["-I%s" % modules_dir], ensure_platforms=["aplite", "basalt"])
patch_logger.removeHandler(fh)
fh.close()
self._state = CompilationState.Done
self._output_pbw = pbw_output_path
def test_call_statement(vm):
caller_arg = 254
caller_lcl = caller_arg + 5
caller_this = 1234
caller_that = 2345
caller_sp = 512
n_args = 3
arg1 = 111
arg2 = 222
arg3 = 333
vm.symbols['fn'] = 8192
vm.ram[vm.symbols['SP']] = caller_sp
vm.ram[vm.symbols['LCL']] = caller_lcl
vm.ram[vm.symbols['ARG']] = caller_arg
vm.ram[vm.symbols['THIS']] = caller_this
vm.ram[vm.symbols['THAT']] = caller_that
vm.ram[caller_sp - 3] = arg1
vm.ram[caller_sp - 2] = arg2
vm.ram[caller_sp - 1] = arg3
g = CodeGenerator()
code = g.translate(commands=[
(0, 'call', 'fn', n_args),
],
filename='<input>',
)
vm.execute(code, 100)
assert vm.ram == {
vm.symbols['SP']: caller_sp + 5,
vm.symbols['LCL']: caller_sp + 5,
vm.symbols['ARG']: caller_sp - n_args,
vm.symbols['THIS']: caller_this,
vm.symbols['THAT']: caller_that,
caller_sp - 3: arg1,
caller_sp - 2: arg2,
caller_sp - 1: arg3,
caller_sp + 0: vm.symbols['fn$ret.1'],
caller_sp + 1: caller_lcl,
caller_sp + 2: caller_arg,
caller_sp + 3: caller_this,
caller_sp + 4: caller_that,
}
def test_push_constant(vm):
g = CodeGenerator()
code = g.translate(commands=[
(0, 'push', 'constant', 1),
(1, 'push', 'constant', 10),
(2, 'push', 'constant', 100),
],
filename='<input>',
)
vm.execute(code, max_steps=100)
assert vm.ram == {
vm.symbols['SP']: vm.stack_offset + 3,
vm.stack_offset + 0: 1,
vm.stack_offset + 1: 10,
vm.stack_offset + 2: 100,
}
def test_initialization(self):
language = "python"
cg = CodeGenerator(language)
t = cg._env.get_template('examples_header.jinja')
with open('./' + language + '/templates/examples_header.jinja',
'r') as myfile:
t2 = myfile.read().replace('\n', '')
self.assertEqual(str(t.render()).replace('\n', ''), t2)
def test_program(vm):
g = CodeGenerator()
code = g.gen_initializer()
code += '\n' + g.translate(commands=[
(0, 'goto', 'end'),
(1, 'function', 'Sys.init', 0),
(2, 'push', 'constant', 0),
(3, 'return'),
(4, 'label', 'end')
],
filename='<input>',
)
vm.execute(code, 500)
assert vm.ram[vm.symbols['SP']] == vm.stack_offset + 1
def test_eq(vm, a, b, expected):
vm.ram[vm.stack_offset + 0] = a
vm.ram[vm.stack_offset + 1] = b
vm.ram[vm.symbols['SP']] += 2
g = CodeGenerator()
code = g.translate(commands=[
(0, 'eq'),
],
filename='<input>',
)
vm.execute(code, max_steps=100)
assert vm.ram == {
vm.symbols['SP']: vm.stack_offset + 1,
vm.stack_offset + 0: expected,
vm.stack_offset + 1: b,
}
def test_or(vm):
vm.ram[vm.stack_offset + 0] = 22
vm.ram[vm.stack_offset + 1] = 21
vm.ram[vm.symbols['SP']] += 2
g = CodeGenerator()
code = g.translate(commands=[
(0, 'or'),
],
filename='<input>',
)
vm.execute(code, max_steps=100)
assert vm.ram == {
vm.symbols['SP']: vm.stack_offset + 1,
vm.stack_offset + 0: 22|21,
vm.stack_offset + 1: 21,
}
def test_expression_with_ops_and_fn_call():
toks = gen_tokens_for_lines(lines=["x + Klass.g(2, y, -z) * 5;"])
parsed = Parser(toks).parse_expression()
code_gen = CodeGenerator()
code_gen._symbol_tables.push_new()
code_gen._symbol_tables.add("x", TypeInt(), Kind.ARGUMENT)
code_gen._symbol_tables.add("y", TypeInt(), Kind.ARGUMENT)
code_gen._symbol_tables.add("z", TypeInt(), Kind.ARGUMENT)
code = code_gen.generate_expression(parsed)
assert code == [
"push argument 0",
"push constant 2",
"push argument 1",
"push argument 2",
"neg",
"call Klass.g 3",
"push constant 5",
"call Math.multiply 2",
"add",
]
def test_push_temp(vm):
vm.ram[vm.symbols['R5'] + 1] = 33
vm.ram[vm.symbols['R5'] + 3] = 22
g = CodeGenerator()
code = g.translate(commands=[
(0, 'push', 'temp', 1),
(1, 'push', 'temp', 3),
],
filename='<input>',
)
vm.execute(code, max_steps=100)
assert vm.ram == {
vm.symbols['SP']: vm.stack_offset + 2,
vm.symbols['R5'] + 1: 33,
vm.symbols['R5'] + 3: 22,
vm.stack_offset + 0: 33,
vm.stack_offset + 1: 22,
}
def test_push_pointer(vm):
vm.ram[vm.symbols['R3']] = 33
vm.ram[vm.symbols['R4']] = 22
g = CodeGenerator()
code = g.translate(commands=[
(0, 'push', 'pointer', 0),
(1, 'push', 'pointer', 1),
],
filename='<input>',
)
vm.execute(code, max_steps=100)
assert vm.ram == {
vm.symbols['SP']: vm.stack_offset + 2,
vm.symbols['R3']: 33,
vm.symbols['R4']: 22,
vm.stack_offset + 0: 33,
vm.stack_offset + 1: 22,
}
def test_push_static(vm):
static_offset = vm.symbols['R15'] + 1
vm.ram[static_offset + 0] = 33
vm.ram[static_offset + 1] = 22
g = CodeGenerator()
code = g.translate(commands=[
(0, 'push', 'static', 1),
(1, 'push', 'static', 10),
],
filename='<input>',
)
vm.execute(code, max_steps=100)
assert vm.ram == {
vm.symbols['SP']: vm.stack_offset + 2,
static_offset + 0: 33,
static_offset + 1: 22,
vm.stack_offset + 0: 33,
vm.stack_offset + 1: 22,
}
def test_function_statement(vm):
local_segment_size = 2
initial_sp = 512
vm.ram[vm.symbols['SP']] = initial_sp
vm.ram[vm.symbols['LCL']] = vm.ram[vm.symbols['SP']]
g = CodeGenerator()
code = g.translate(commands=[
(0, 'function', 'fn', local_segment_size),
],
filename='<input>',
)
vm.execute(code, 100)
assert vm.symbols['fn'] == 0
assert vm.ram == {
vm.symbols['SP']: initial_sp + local_segment_size,
vm.symbols['LCL']: initial_sp,
initial_sp + 0: 0,
initial_sp + 1: 0,
}
def from_data(floc, fl):
if not floc.endswith("/"):
floc += "/"
config_location = floc + "config"
predict_references = False
if "p" in fl:
predict_references = True
try:
os.mkdir(config_location)
except OSError as e:
if e.errno != 17:
print e
sys.exit(-1)
cdm_gen = CDMGenerator(floc, config_location, predict_references=predict_references)
cdm_gen.generate()
code_gen = CodeGenerator(config_location)
code_gen.generate()
def test_label_within_function(vm):
g = CodeGenerator()
code = g.translate(commands=[
(0, 'call', 'fn', 0),
(1, 'goto', 'end'),
(2, 'function', 'fn', 0),
(5, 'push', 'constant', 0),
(3, 'goto', 'end'),
(4, 'label', 'label1'),
(6, 'return'),
(4, 'label', 'end'),
(6, 'return'),
(7, 'label', 'end'),
],
filename='<input>',
)
vm.execute(code, 500)
assert '<input>$end' in vm.symbols
assert '<input>$fn$label1' in vm.symbols
assert '<input>$fn$end' in vm.symbols
def test_pop_temp(vm):
temp_offset = vm.symbols[kw.special_segmnets['temp']]
vm.ram[vm.stack_offset + 0] = 33
vm.ram[vm.stack_offset + 1] = 22
vm.ram[vm.symbols['SP']] += 2
g = CodeGenerator()
code = g.translate(commands=[
(0, 'pop', 'temp', 1),
(1, 'pop', 'temp', 3),
],
filename='<input>',
)
vm.execute(code, max_steps=100)
assert vm.ram == {
vm.symbols['SP']: vm.stack_offset,
temp_offset + 1: 22,
temp_offset + 3: 33,
vm.stack_offset + 0: 33,
vm.stack_offset + 1: 22,
}
def __init__(self):
self._subdirs = ['lib', 'include', 'python', 'swig',
'grc'] # List subdirs where stuff happens
self._has_subdirs = {}
self._skip_subdirs = {}
self._info = {}
for subdir in self._subdirs:
self._has_subdirs[subdir] = False
self._skip_subdirs[subdir] = False
self.parser = self.setup_parser()
self.tpl = CodeGenerator()
self.args = None
self.options = None
self._dir = None
def from_data(floc, fl):
if not floc.endswith("/"):
floc += "/"
config_location = floc + "config"
predict_references = False
if "p" in fl:
predict_references = True
try:
os.mkdir(config_location)
except OSError as e:
if e.errno != 17:
print e
sys.exit(-1)
cdm_gen = CDMGenerator(floc,
config_location,
predict_references=predict_references)
cdm_gen.generate()
code_gen = CodeGenerator(config_location)
code_gen.generate()
from code_generator import CodeGenerator
from environment import Environment
from scanner import join_tokens, scan
from analyzer import Parser
#from environment import environment
import os
expr = raw_input('expression: ')
tokens = join_tokens(scan(expr))
print("STEP 1")
print("Generated token list: ")
print(tokens)
parser = Parser(tokens)
tree = parser.parse()
print("STEP 2")
print("Parsing token list to binary tree")
print (tree)
code_generator = CodeGenerator(orders_list=[])
code_generator.postorder(tree)
code_generator.orders_list.append('end')
print("STEP 3")
print("Postorder")
print(code_generator.orders_list)
environment = Environment(code_generator.orders_list)
result = environment.count()
print("RESULT: ")
print(result)
def from_config(floc, fl):
code_gen = CodeGenerator(floc)
code_gen.generate()
from code_parser import CodeParser from code_generator import CodeGenerator code_directory = "include/" output_file = "data.conf" codeParser = CodeParser() ecosystem = codeParser.generate_data_structure(code_directory, output_file) codeGenerator = CodeGenerator() codeGenerator.generate_deserializers(ecosystem)
def generate_unit_test(self):
"""
Generate the CPP unit test for this function
"""
utg = CodeGenerator()
# Generate definition, rng setup, etc.
self._unit_test_signature(utg)
self._init_rng(utg)
utg.add_line()
self._find_default_impl(utg)
utg.add_line()
self._init_arguments(utg)
utg.add_line()
self._begin_implementation_loop(utg)
self._begin_argument_loops(utg)
self._argument_loop_body(utg)
utg.add_line("for (YepSize length = 1024; length < 1088; length++) {").indent()
self._argument_loop_body(utg)
utg.dedent()
indent_depth = len([ arg for arg in self.arguments if arg.is_pointer ])
for i in range(indent_depth):
utg.add_line("}").dedent()
self._passed_or_skipped(utg)
utg.add_line("next_descriptor:")
utg.add_line("continue;")
utg.dedent().add_line("}")
utg.add_line("return -failedTests;")
utg.dedent().add_line("}")
return utg.get_code()
