def test_nested_alias(self): st = SymbolTable() integer = IntegerType() real = RealType() boolean = BooleanType() character = CharacterType() st.registerAlias('a', integer) # call in scope self.assertEqual(type(st.getAlias('a').basetype), type(IntegerType())) # call in nested scope st.openScope() self.assertEqual(type(st.getAlias('a').basetype), type(IntegerType())) # define in nested scope st.registerAlias('a', character) # call in nested scope self.assertEqual(type(st.getAlias('a').basetype), type(CharacterType())) # call original in main scope st.closeScope() self.assertEqual(type(st.getAlias('a').basetype), type(IntegerType()))
def buildIncludeStatement(self, tree): """Build Include Statement""" # must have 2 children if (tree.getChildCount() != 2): raise RuntimeError("Invalid include statement: '" + tree.getText() + "'") path = tree.getChild(1).getText() # check if correct format if ((path.startswith('"') and path.endswith('"')) or (path.startswith('<') and path.endswith('>'))): path = path[1:-1] # Let's add some definitions to the symbol table if (path == "stdio.h"): #printf argumentsList = ArgumentsList() argumentsList.add( Argument("string", AddressType(ArrayType(CharacterType(), -1)))) argumentsList.makeUnlimited() self.sym.registerFunction('printf', IntegerType(), argumentsList, True) self.sym.registerFunction('scanf', IntegerType(), argumentsList, True) return IncludeStatement(path) else: raise RuntimeError("Invalid include statement: '" + tree.getText() + "'")
def test_register_symbols_nested(self): st = SymbolTable() integer = IntegerType() real = RealType() boolean = BooleanType() character = CharacterType() st.registerSymbol('a', integer) st.openScope() st.registerSymbol('a', real) st.openScope() st.registerSymbol('a', boolean) st.openScope() st.registerSymbol('a', character) # Check self.assertEqual(type(st.getSymbol('a').basetype), CharacterType) st.closeScope() self.assertEqual(type(st.getSymbol('a').basetype), BooleanType) st.closeScope() self.assertEqual(type(st.getSymbol('a').basetype), RealType) st.closeScope() self.assertEqual(type(st.getSymbol('a').basetype), IntegerType)
def test_function_register_with_unlimited_arguments(self): st = SymbolTable() integer = IntegerType() real = RealType() boolean = BooleanType() character = CharacterType() # Create arguments argumentsList = ArgumentsList() argumentsList.add(Argument('a', integer)) argumentsList.makeUnlimited() # Create parameters parametersList = ParametersList() parametersList.add(Parameter(ConstantExpression(1, 'int'))) parametersList.add(Parameter(ConstantExpression(3.14, 'float'))) parametersList.add(Parameter(ConstantExpression(True, 'bool'))) parametersList.add(Parameter(ConstantExpression(False, 'bool'))) # Register basic function, arguments st.registerFunction('printer', integer, argumentsList, True) # get basic function self.assertEqual(type(st.getFunction('printer', parametersList)), Function)
def test_function_label(self): st = SymbolTable() integer = IntegerType() real = RealType() boolean = BooleanType() character = CharacterType() # Create arguments argumentsList = ArgumentsList() argumentsList.add(Argument('a', integer)) argumentsList.add(Argument('b', real)) # Create parameters parametersList = ParametersList() parametersList.add(Parameter(ConstantExpression(1, 'int'))) parametersList.add(Parameter(ConstantExpression(3.14, 'float'))) # Register basic function, no arguments st.registerFunction('add', integer, argumentsList, True) # Check for label self.assertEqual(st.getFunction('add', parametersList).label, 'add0') # Check for label in scope st.openScope() st.registerFunction('add', integer, argumentsList, True) self.assertEqual(st.getFunction('add', parametersList).label, 'add1') st.closeScope()
def test_function_register_and_get_no_arguments(self): st = SymbolTable() integer = IntegerType() real = RealType() boolean = BooleanType() character = CharacterType() # Register basic function, no arguments st.registerFunction('hello', integer, ArgumentsList(), True) # register function again, shouldn't work self.assertRaises( FunctionAlreadyRegisteredError, lambda: st.registerFunction( 'hello', integer, ArgumentsList(), True)) # register function again with other return type, shouldn't work self.assertRaises( FunctionAlreadyRegisteredError, lambda: st.registerFunction( 'hello', boolean, ArgumentsList(), True)) # get basic function self.assertEqual(type(st.getFunction('hello', ParametersList())), Function) # get not known function, should not work self.assertRaises(FunctionNotRegisteredError, lambda: st.getFunction('add', ParametersList()))
def test_function_scoped(self): st = SymbolTable() integer = IntegerType() real = RealType() boolean = BooleanType() character = CharacterType() # Create arguments argumentsList = ArgumentsList() argumentsList.add(Argument('a', integer)) argumentsList.add(Argument('b', real)) # Create parameters parametersList = ParametersList() parametersList.add(Parameter(ConstantExpression(1, 'int'))) parametersList.add(Parameter(ConstantExpression(3.14, 'float'))) # Register basic function, no arguments st.registerFunction('add', integer, argumentsList, True) # Call function in main scope self.assertEqual(type(st.getFunction('add', parametersList)), Function) # open scope and get function again st.openScope() self.assertEqual(type(st.getFunction('add', parametersList)), Function) # register function in scope st.registerFunction('divide', integer, argumentsList, True) # call new function in scope self.assertEqual(type(st.getFunction('add', parametersList)), Function) # close scope and call new created function, shouldn't work st.closeScope() self.assertRaises(FunctionNotRegisteredError, lambda: st.getFunction('divide', parametersList)) # open scope and register add again st.openScope() st.registerFunction('add', integer, argumentsList, True) self.assertEqual(type(st.getFunction('add', parametersList)), Function) self.assertRaises( FunctionAlreadyRegisteredError, lambda: st.registerFunction('add', integer, argumentsList, True)) st.closeScope() # register function in higher scope and call in lower scope st.registerFunction('multiply', integer, argumentsList, True) st.openScope() self.assertEqual(type(st.getFunction('multiply', parametersList)), Function) self.assertRaises( FunctionNotRegisteredError, lambda: st.getFunction('multiplynotexisting', parametersList)) st.closeScope
def __init__(self, value, basetype): Expression.__init__(self, None) if(basetype == "bool"): self.basetype = BooleanType() self.value = BooleanData(value) elif(basetype == "char"): self.basetype = CharacterType() self.value = CharacterData(value) elif(basetype == "int"): self.basetype = IntegerType() self.value = IntegerData(value) elif(basetype == "float"): self.basetype = RealType() self.value = RealData(value) elif(basetype == "string"): self.basetype = AddressType(ArrayType(CharacterType(), len(value))) self.value = StringData(value + "\0") else: raise RuntimeError("Trying to create constantexpession with unkown type")
def buildType(self, tree): """Build Type""" token = None basetype = None if (tree.getChildCount() == 1): token = tree.getChild(0).getPayload() if (not isinstance(token, Token)): raise RuntimeError("Invalid type identifier: '" + tree.getText() + "'") if (token.type == CLexer.VOID): return VoidType() elif (token.type == CLexer.IDENTIFIER): if (tree.getChild(0).getText() == "bool"): return BooleanType() elif (tree.getChild(0).getText() == "char"): return CharacterType() elif (tree.getChild(0).getText() == "int"): return IntegerType() elif (tree.getChild(0).getText() == "float"): return RealType() elif (tree.getChild(0).getText() == "double"): return RealType() else: # Alias, check the symbol Table return self.sym.getAlias( tree.getChild(0).getText()).basetype else: raise RuntimeError("Invalid type identifier: '" + tree.getText() + "'") elif (tree.getChildCount() == 2): token = tree.getChild(0).getPayload() # Const Type if (isinstance(token, Token) and token.type == CLexer.CONST): return self.buildType(tree.getChild(1)).setConst(True) token = tree.getChild(1).getPayload() if (not isinstance(token, Token)): raise RuntimeError("Invalid type identifier: '" + tree.getText() + "'") if (token.type == CLexer.STAR): return AddressType(self.buildType(tree.getChild(0))) elif (token.type == CLexer.CONST): return self.buildType(tree.getChild(0)).setConst(True) else: raise RuntimeError("Invalid type identifier: '" + tree.getText() + "'") else: raise RuntimeError("Invalid type identifier: '" + tree.getText() + "'")
def test_function_register_and_get_with_arguments(self): st = SymbolTable() integer = IntegerType() real = RealType() boolean = BooleanType() character = CharacterType() # Create arguments argumentsList = ArgumentsList() argumentsList.add(Argument('a', integer)) argumentsList.add(Argument('b', real)) # Create parameters parametersList = ParametersList() parametersList.add(Parameter(ConstantExpression(1, 'int'))) parametersList.add(Parameter(ConstantExpression(3.14, 'float'))) # fake ParametersList, has one parameters less fakeParametersList = ParametersList() fakeParametersList.add(Parameter(ConstantExpression(1, 'int'))) # Register basic function, arguments st.registerFunction('add', integer, argumentsList, True) # register function again, shouldn't work self.assertRaises( FunctionAlreadyRegisteredError, lambda: st.registerFunction('add', integer, argumentsList, True)) # register function again with other return type, shouldn't work self.assertRaises( FunctionAlreadyRegisteredError, lambda: st.registerFunction('add', boolean, argumentsList, True)) # get basic function self.assertEqual(type(st.getFunction('add', parametersList)), Function) # get not known function, should not work self.assertRaises(FunctionNotRegisteredError, lambda: st.getFunction('hello', parametersList)) # get the function with no arguments, shouldn't work self.assertRaises(FunctionNotRegisteredError, lambda: st.getFunction('add', ParametersList())) # get the function with wrong arguments, shouldn't work self.assertRaises(FunctionNotRegisteredError, lambda: st.getFunction('add', fakeParametersList))
def test_register_symbols(self): st = SymbolTable() integer = IntegerType() real = RealType() boolean = BooleanType() address = AddressType(integer) character = CharacterType() array = ArrayType(integer, 10) st.registerSymbol('int', integer) st.registerSymbol('float', real) st.registerSymbol('bool', boolean) st.registerSymbol('char', character) st.registerSymbol('ptr', address) st.registerSymbol('array', array)
def test_scope_allocated(self): st = SymbolTable() integer = IntegerType() real = RealType() boolean = BooleanType() character = CharacterType() address = AddressType(integer) array = ArrayType(integer, 10) st.registerSymbol('a', integer) st.registerSymbol('b', real) st.registerSymbol('c', boolean) st.registerSymbol('d', character) st.registerSymbol('e', address) self.assertEqual(st.scope.allocated, 5) self.assertEqual(st.scope.getTotalAllocated(), 5) st.openScope() st.registerSymbol('a', integer) st.registerSymbol('b', real) st.registerSymbol('c', boolean) st.registerSymbol('d', character) st.registerSymbol('e', address) self.assertEqual(st.scope.allocated, 5) self.assertEqual(st.scope.getTotalAllocated(), 5) st.closeScope() self.assertEqual(st.scope.allocated, 5) self.assertEqual(st.scope.getTotalAllocated(), 10) st.registerSymbol('f', array) self.assertEqual(st.scope.allocated, 15) self.assertEqual(st.scope.getTotalAllocated(), 20)