def test_invalid_bytecode(self):
lexer = LexerStateMachine('int x = 5; if(x==5){x=6;}else{x=7;}', self.context)
parser = Parser(lexer, self.manager)
self.manager.setParser(parser)
token = parser.parseStatements(0)
bytecodes = self.generator.generateCode(token)
vm = VirtualMachine()
vm.VMLoad(bytecodes)
lexer = LexerStateMachine('x = x +5;', self.context)
parser.lexer = lexer
token = parser.parseStatements(0)
bytecodes = self.generator.generateCode(token)
cbytecodes = vm.convertToCArray(bytecodes)
vm.dumpBytecodes(cbytecodes)
def test_parse_will_build_an_AST_for_longer_expression_in_the_brace(self):
"""
{
|
+
/ \
2 /
/ \
* 9
/ \
3 8
:return:
"""
lexer = LexerStateMachine(' { 2 + 3 * 8 / 9 ; }', self.context)
parser = Parser(lexer, self.manager)
self.manager.setParser(parser)
token = parser.parseStatements(0)
self.assertEqual('{', token[0].id)
self.assertEqual('+', token[0].data[0].id)
self.assertEqual(2, token[0].data[0].data[0].data[0])
self.assertEqual('/', token[0].data[0].data[1].id)
self.assertEqual('*', token[0].data[0].data[1].data[0].id)
self.assertEqual(3, token[0].data[0].data[1].data[0].data[0].data[0])
self.assertEqual(8, token[0].data[0].data[1].data[0].data[1].data[0])
self.assertEqual(9, token[0].data[0].data[1].data[1].data[0])
def test_parse_will_build_an_ast_for_expressions_in_the_brace(self):
"""
{----------------------
| | |
+ * /
/ \ / \ / \
2 3 3 4 5 9
:return:
"""
lexer = LexerStateMachine('{ 2 + 3 ; \
3 * 4 ; \
5 / 9 ; \
}', self.context)
parser = Parser(lexer, self.manager)
self.manager.setParser(parser)
token = parser.parseStatements(0)
self.assertEqual('{', token[0].id)
self.assertEqual('+', token[0].data[0].id)
self.assertEqual(2, token[0].data[0].data[0].data[0])
self.assertEqual(3, token[0].data[0].data[1].data[0])
self.assertEqual('*', token[0].data[1].id)
self.assertEqual(3, token[0].data[1].data[0].data[0])
self.assertEqual(4, token[0].data[1].data[1].data[0])
self.assertEqual('/', token[0].data[2].id)
self.assertEqual(5, token[0].data[2].data[0].data[0])
self.assertEqual(9, token[0].data[2].data[1].data[0])
def test_isDefined_return_True_when_x_is_defined(self):
lexer = LexerStateMachine('int x; x = 0;', self.context)
parser = Parser(lexer, self.contextManager)
self.contextManager.setParser(parser)
semanticChecker = SemanticChecker(parser.scopeBuilder)
try:
token = parser.parseStatements(0)
semanticChecker.checkIfIdentifierIsDefined(token[1].data[0])
except SyntaxError as e:
self.fail(e.msg)
def test_parseStatement_should_return_open_brace_token_with_empty_data_for_3_empty_statements(self):
"""
{ ; ; ; }
:return:
"""
lexer = LexerStateMachine('{ ;; ; }', self.context)
parser = Parser(lexer, self.manager)
self.manager.setParser(parser)
token = parser.parseStatements(0)
self.assertEqual('{', token[0].id)
self.assertEqual([], token[0].data)
def test123(self):
lexer = LexerStateMachine("""int x = 2;
while(x ==2){
x = 2;
x = 100;
}
""", self.context)
parser = Parser(lexer, self.manager)
self.manager.setParser(parser)
token = parser.parseStatements(0)
byteCodes = self.generator.generateCode(token)
byteCodes = self.byteCodeGenerator.injectPrologue(byteCodes)
def test_parseStatements_should_call_buildScope_properly(self):
lexer = LexerStateMachine('int x; { int y;};', self.context)
parser = Parser(lexer, self.contextManager)
self.contextManager.setParser(parser)
mockScopeBuilder = MagicMock(wraps=ScopeBuilder())
scopeBuilder = ScopeBuilder()
parser.scopeBuilder = mockScopeBuilder
token = parser.parseStatements(0)
calls = [call(token[0]), call(token[1]), call(token[1].data[0])]
mockScopeBuilder.buildScope.assert_has_calls(calls, any_order=False)
calls = [call()]
mockScopeBuilder.destroyCurrentScope.assert_has_calls(calls)
self.assertEqual(1, mockScopeBuilder.destroyCurrentScope.call_count)
def test_VMStep_while_loop(self):
lexer = LexerStateMachine('int x, y, z; while( x == 2) {x = 100;\n y = 1000;\n z=2000;} ', self.context)
parser = Parser(lexer, self.manager)
self.manager.setParser(parser)
token = parser.parseStatements(0)
bytecodes = self.generator.generateCode(token)
vm = VirtualMachine()
vm.VMLoad(bytecodes)
vm.VMStep()
vm.VMStep()
vm.VMStep()
vm.VMStep()
vm.VMStep()
vm.VMStep()
vm.VMStep()
def test_parseStatements_complex_nested_brace_should_call_buildScope_properly(self):
lexer = LexerStateMachine('int x; {int y; {int z; {int a;} int b; }};', self.context)
parser = Parser(lexer, self.contextManager)
self.contextManager.setParser(parser)
mockScopeBuilder = MagicMock(wraps=ScopeBuilder())
scopeBuilder = ScopeBuilder()
parser.scopeBuilder = mockScopeBuilder
token = parser.parseStatements(0)
calls = [call(token[0]), call(token[1]), call(token[1].data[0]), call(token[1].data[1]), call(token[1].data[1].data[0])]
calls2 = [call(token[1].data[1].data[1]), call(token[1].data[1].data[1].data[0])]
calls3 = [call(token[1].data[1].data[2])]
calls.extend(calls2)
calls.extend(calls3)
mockScopeBuilder.buildScope.assert_has_calls(calls, any_order=False)
calls = [call(), call(), call()]
mockScopeBuilder.destroyCurrentScope.assert_has_calls(calls, any_order=False)
self.assertEqual(3, mockScopeBuilder.destroyCurrentScope.call_count)
def test_parseStatement_should_build_ast_for_double_layers_of_braces(self):
"""
{
|
{
|
+
/ \
2 3
:return:
"""
lexer = LexerStateMachine('{ { 2 + 3 ; } }', self.context)
parser = Parser(lexer, self.manager)
self.manager.setParser(parser)
token = parser.parseStatements(0)
self.assertEqual('{', token[0].id)
self.assertEqual('{', token[0].data[0].id)
self.assertEqual('+', token[0].data[0].data[0].id)
self.assertEqual(2, token[0].data[0].data[0].data[0].data[0])
self.assertEqual(3, token[0].data[0].data[0].data[1].data[0])
def test_generaByteCode_will_generate_byte_code_for_a_list_of_tokens(self):
lexer = LexerStateMachine('x = 3;\
y = 4;\
z=10;', self.context)
parser = Parser(lexer, self.manager)
self.manager.setParser(parser)
token = parser.parseStatements(0)
self.byteCodeGenerator.variablesInThisAST['x'] = 4
self.byteCodeGenerator.variablesInThisAST['y'] = 8
self.byteCodeGenerator.variablesInThisAST['z'] = 12
byteCodes = self.generatorAPI.generateCode(token)
self.assertEqual(self.byteCodeGenerator.loadRegister([0, 7, 4]), byteCodes[0])
self.assertEqual(self.byteCodeGenerator.loadValue([5, 3]), byteCodes[1])
self.assertEqual(self.byteCodeGenerator.storeRegister([5, 7, 4]), byteCodes[2])
self.assertEqual(self.byteCodeGenerator.loadRegister([0, 7, 8]), byteCodes[3])
self.assertEqual(self.byteCodeGenerator.loadValue([5, 4]), byteCodes[4])
self.assertEqual(self.byteCodeGenerator.storeRegister([5, 7, 8]), byteCodes[5])
self.assertEqual(self.byteCodeGenerator.loadRegister([0, 7, 12]), byteCodes[6])
self.assertEqual(self.byteCodeGenerator.loadValue([5, 10]), byteCodes[7])
self.assertEqual(self.byteCodeGenerator.storeRegister([5, 7, 12]), byteCodes[8])
generator = GeneratorAPI(context, contextManager)
byteCodeGenerator = ByteCodeGenerator(context, contextManager)
informationInjector = InformationInjector()
vm = VirtualMachine()
parser = Parser(None, contextManager)
contextManager.setParser(parser)
print('Imba the Cinterpreter')
while(1):
stopSymbol = ' '
StringCode = ''
print('> ', end="")
for statement in iter(input, stopSymbol):
StringCode = StringCode + '\n' +statement
print('> ', end="")
StringList = StringCode.split('\n')
lexer = LexerStateMachine(StringCode, context)
parser.lexer = lexer
tokenList = []
try:
token = parser.parseStatements(0)
byteCodes = generator.generateCode(token)
# to halt the VM
cbytecode = vm.convertToCArray(byteCodes)
vm.dumpBytecodes(cbytecode)
vm.VMRun(cbytecode)
except SyntaxError as e:
print(e.msg)
