Python predefined_types.PredefinedTypes类代码示例

 def endvisit_function(self, node):
     symbol = self.symbol_stack.pop()
     scope = self.scope_stack.pop()
     assert isinstance(symbol, FunctionSymbol), 'Not a function symbol'
     for arg in node.get_parameters():
         # given the fact that the name is not directly equivalent to the one as stated in the model,
         # we have to get it by the sub-visitor
         data_type_visitor = ASTDataTypeVisitor()
         arg.get_data_type().accept(data_type_visitor)
         type_name = data_type_visitor.result
         # first collect the types for the parameters of the function symbol
         symbol.add_parameter_type(PredefinedTypes.get_type(type_name))
         # update the scope of the arg
         arg.update_scope(scope)
         # create the corresponding variable symbol representing the parameter
         var_symbol = VariableSymbol(element_reference=arg, scope=scope, name=arg.get_name(),
                                     block_type=BlockType.LOCAL, is_predefined=False, is_function=False,
                                     is_recordable=False,
                                     type_symbol=PredefinedTypes.get_type(type_name),
                                     variable_type=VariableType.VARIABLE)
         assert isinstance(scope, Scope)
         scope.add_symbol(var_symbol)
     if node.has_return_type():
         data_type_visitor = ASTDataTypeVisitor()
         node.get_return_type().accept(data_type_visitor)
         symbol.set_return_type(PredefinedTypes.get_type(data_type_visitor.result))
     else:
         symbol.set_return_type(PredefinedTypes.get_void_type())
     self.block_type_stack.pop()  # before leaving update the type

    def visit_simple_expression(self, node):
        """
        Visit a simple rhs and update the type of a numeric literal.
        :param node: a single meta_model node
        :type node: ast_node
        :return: no value returned, the type is updated in-place
        :rtype: void
        """
        assert node.get_scope() is not None, "Run symboltable creator."
        # if variable is also set in this rhs, the var type overrides the literal
        if node.get_variable() is not None:
            scope = node.get_scope()
            var_name = node.get_variable().get_name()
            variable_symbol_resolve = scope.resolve_to_symbol(var_name, SymbolKind.VARIABLE)
            if not variable_symbol_resolve is None:
                node.type = variable_symbol_resolve.get_type_symbol()
            else:
                node.type = scope.resolve_to_symbol(var_name, SymbolKind.TYPE)
            node.type.referenced_object = node
            return

        if node.get_numeric_literal() is not None and isinstance(node.get_numeric_literal(), float):
            node.type = PredefinedTypes.get_real_type()
            node.type.referenced_object = node
            return

        elif node.get_numeric_literal() is not None and isinstance(node.get_numeric_literal(), int):
            node.type = PredefinedTypes.get_integer_type()
            node.type.referenced_object = node
            return

 def __register_print_function(cls):
     """
     Registers the print function.
     """
     params = list()
     params.append(PredefinedTypes.get_string_type())
     symbol = FunctionSymbol(name=cls.PRINT, param_types=params,
                             return_type=PredefinedTypes.get_void_type(),
                             element_reference=None, is_predefined=True)
     cls.name2function[cls.PRINT] = symbol

 def __register_logger_info_function(cls):
     """
     Registers the logger info method into the scope.
     """
     params = list()
     params.append(PredefinedTypes.get_string_type())  # the argument
     symbol = FunctionSymbol(name=cls.LOGGER_INFO, param_types=params,
                             return_type=PredefinedTypes.get_void_type(),
                             element_reference=None, is_predefined=True)
     cls.name2function[cls.LOGGER_INFO] = symbol

    def setUp(self):
        PredefinedUnits.register_units()
        PredefinedTypes.register_types()
        PredefinedFunctions.register_functions()
        PredefinedVariables.register_variables()
        SymbolTable.initialize_symbol_table(ASTSourceLocation(start_line=0, start_column=0, end_line=0, end_column=0))
        Logger.init_logger(LoggingLevel.INFO)

        self.target_path = str(os.path.realpath(os.path.join(os.path.dirname(__file__), os.path.join(
            os.pardir, 'target'))))

 def __register_logger_warning_function(cls):
     """
     Registers the logger warning method.
     """
     params = list()
     params.append(PredefinedTypes.get_string_type())  # the argument
     symbol = FunctionSymbol(name=cls.LOGGER_WARNING, param_types=params,
                             return_type=PredefinedTypes.get_void_type(),
                             element_reference=None, is_predefined=True)
     cls.name2function[cls.LOGGER_WARNING] = symbol

 def __register_exp1_function(cls):
     """
     Registers the alternative version of the exponent function, exp1.
     """
     params = list()
     params.append(PredefinedTypes.get_real_type())  # the argument
     symbol = FunctionSymbol(name=cls.EXPM1, param_types=params,
                             return_type=PredefinedTypes.get_real_type(),
                             element_reference=None, is_predefined=True)
     cls.name2function[cls.EXPM1] = symbol

 def __register_log_function(cls):
     """
     Registers the logarithm function (to base 10).
     """
     params = list()
     params.append(PredefinedTypes.get_real_type())  # the argument
     symbol = FunctionSymbol(name=cls.LOG, param_types=params,
                             return_type=PredefinedTypes.get_real_type(),
                             element_reference=None, is_predefined=True)
     cls.name2function[cls.LOG] = symbol

 def __register_time_steps_function(cls):
     """
     Registers the time-resolution.
     """
     params = list()
     params.append(PredefinedTypes.get_type('ms'))
     symbol = FunctionSymbol(name=cls.TIME_STEPS, param_types=params,
                             return_type=PredefinedTypes.get_integer_type(),
                             element_reference=None, is_predefined=True)
     cls.name2function[cls.TIME_STEPS] = symbol
     return

 def __register_power_function(cls):
     """
     Registers the power function.
     """
     params = list()
     params.append(PredefinedTypes.get_real_type())  # the base type
     params.append(PredefinedTypes.get_real_type())  # the exponent type
     symbol = FunctionSymbol(name=cls.POW, param_types=params,
                             return_type=PredefinedTypes.get_real_type(),
                             element_reference=None, is_predefined=True)
     cls.name2function[cls.POW] = symbol

 def __register_convolve(cls):
     """
     Registers the convolve function into the system.
     """
     params = list()
     params.append(PredefinedTypes.get_real_type())
     params.append(PredefinedTypes.get_real_type())
     symbol = FunctionSymbol(name=cls.CONVOLVE, param_types=params,
                             return_type=PredefinedTypes.get_real_type(),
                             element_reference=None, is_predefined=True)
     cls.name2function[cls.CONVOLVE] = symbol

 def __register_predefined_type_variables(cls):
     """
     Registers all predefined type variables, e.g., mV and integer.
     """
     for name in PredefinedTypes.get_types().keys():
         symbol = VariableSymbol(name=name, block_type=BlockType.PREDEFINED,
                                 is_predefined=True,
                                 type_symbol=PredefinedTypes.get_type(name),
                                 variable_type=VariableType.TYPE)
         cls.name2variable[name] = symbol
     return

 def __register_max_function(cls):
     """
     Registers the maximum function.
     """
     params = list()
     params.append(PredefinedTypes.get_real_type())
     params.append(PredefinedTypes.get_real_type())
     symbol = FunctionSymbol(name=cls.MAX, param_types=params,
                             return_type=PredefinedTypes.get_real_type(),
                             element_reference=None, is_predefined=True)
     cls.name2function[cls.MAX] = symbol

 def __register_cond_sum_function(cls):
     """
     Registers the cond_sum function into scope.
     """
     params = list()
     params.append(PredefinedTypes.get_type('nS'))
     params.append(PredefinedTypes.get_real_type())
     symbol = FunctionSymbol(name=cls.COND_SUM, param_types=params,
                             return_type=PredefinedTypes.get_type('nS'),
                             element_reference=None, is_predefined=True)
     cls.name2function[cls.COND_SUM] = symbol

 def __register_min_bounded_function(cls):
     """
     Registers the minimum (bounded) function.
     """
     params = list()
     params.append(PredefinedTypes.get_real_type())
     params.append(PredefinedTypes.get_real_type())
     symbol = FunctionSymbol(name=cls.BOUNDED_MIN, param_types=params,
                             return_type=PredefinedTypes.get_real_type(),
                             element_reference=None, is_predefined=True)
     cls.name2function[cls.BOUNDED_MIN] = symbol