def validate_array_indexes(self): last_index = 0 index_var = { index.variable: index.range for index in self.context.index_variables } for index in self.indices: if isinstance(index, LiteralExpression): yield Diagnostic(Diagnostic.Messages.ARRAY_INDEX_NOT_VALID, index.value, parseinfo=self.ast.parseinfo) else: idx = 0 try: idx = list(index_var).index(index.variable) except ValueError: yield Diagnostic(Diagnostic.Messages.ARRAY_INDEX_NOT_VALID, index.variable_name, parseinfo=self.ast.parseinfo) if idx < last_index: yield Diagnostic( Diagnostic.Messages.ARRAY_INDEX_WRONG_ORDER, self.variable_name, parseinfo=self.ast.parseinfo) last_index = idx
def validate(self): if self.return_type is not None and not isinstance( self.return_type, ScalarType): yield Diagnostic( Diagnostic.Messages.RETURN_TYPE_MUST_BE_SCALAR, parseinfo=self.ast.declarator.return_type.parseinfo, )
def assert_error(text, error, *args): i = InterfaceDefinition.compile(text) error = Diagnostic.build_message(error, *args) for m in i.validate(): print(m) if m.message == error: return raise AssertionError
def validate(self, lvalue=False): if not self.variable: yield Diagnostic(Diagnostic.Messages.VARIABLE_NOT_DECLARED, self.variable_name, parseinfo=self.ast.parseinfo) elif self.variable not in self.context.initialized_variables and not lvalue: yield Diagnostic(Diagnostic.Messages.VARIABLE_NOT_INITIALIZED, self.variable.name, parseinfo=self.ast.parseinfo) elif isinstance(self.variable.value_type, ArrayType): if self.variable not in self.context.allocated_variables_mapping: yield Diagnostic(Diagnostic.Messages.VARIABLE_NOT_ALLOCATED, self.variable.name, parseinfo=self.ast.parseinfo) for index in self.indices: yield from index.validate() if lvalue: yield from self.validate_array_indexes()
def validate(self): yield from super().validate() new_context = self.context_after for var in self.context.global_variables: if var not in new_context.initialized_variables: yield Diagnostic( Diagnostic.Messages.GLOBAL_VARIABLE_NOT_INITIALIZED, var.name, parseinfo=self.ast.parseinfo)
def validate_parameters(self): fun = self.function if len(self.parameters) != len(fun.parameters): yield Diagnostic( Diagnostic.Messages.CALL_WRONG_ARGS_NUMBER, fun.name, len(fun.parameters), len(self.parameters), parseinfo=self.ast.parseinfo, ) for parameter, expression in zip(fun.parameters, self.parameters): expr_value_type = expression.value_type if expr_value_type != parameter.value_type: yield Diagnostic( Diagnostic.Messages.CALL_WRONG_ARGS_TYPE, parameter.name, fun.name, parameter.value_type, expr_value_type, parseinfo=expression.ast.parseinfo, ) yield from expression.validate()
def validate(self): if not self.body.context_after.has_flushed_output: for statement in self.body.statements: if isinstance(statement, FlushStatement): break if isinstance(statement, ReadStatement): yield Diagnostic( "missing flush between write and read instructions", parseinfo=self.ast.parseinfo) yield from self.body.validate()
def validate(self): yield from super().validate() invalid_parameter = next( (a for p, a in zip(self.parameters, self.ast.declarator.parameters) if not isinstance(p.value_type, ScalarType)), None) if invalid_parameter is not None: yield Diagnostic( Diagnostic.Messages.CALLBACK_PARAMETERS_MUST_BE_SCALARS, parseinfo=invalid_parameter.parseinfo, )
def validate_return_value(self): fun = self.function return_type = fun.return_type if self.return_value is not None: yield from self.return_value.validate(lvalue=True) if return_type is not None and self.return_value is None: yield Diagnostic( Diagnostic.Messages.CALL_NO_RETURN_EXPRESSION, fun.name, return_type, parseinfo=self.ast.parseinfo, ) if return_type is None and self.return_value is not None: yield Diagnostic( Diagnostic.Messages.FUNCTION_DOES_NOT_RETURN_VALUE, fun.name, parseinfo=self.ast.return_value.parseinfo, ) return_expression_type = self.return_value and self.return_value.value_type if self.return_value is not None and return_expression_type != return_type: yield Diagnostic( Diagnostic.Messages.CALL_WRONG_RETURN_EXPRESSION, fun.name, return_type, return_expression_type, parseinfo=self.ast.return_value.parseinfo, )
def validate(self): if self.global_variables and not self.init_body: yield Diagnostic(Diagnostic.Messages.INIT_BLOCK_MISSING, parseinfo=self.body.ast.parseinfo) yield from self.body.validate()
def validate(self): if not self.function: yield Diagnostic(Diagnostic.Messages.FUNCTION_NOT_DECLARED, self.function_name, parseinfo=self.ast.parseinfo) else: yield from self.validate_parameters() yield from self.validate_return_value()
def validate(self): for var in self.variables: if var.name in self.context.variable_mapping.keys(): yield Diagnostic(Diagnostic.Messages.VARIABLE_REDECLARED, var.name, parseinfo=self.ast.parseinfo)
def validate(self): if not self.context.has_flushed_output: yield Diagnostic(Diagnostic.Messages.MISSING_FLUSH, parseinfo=self.ast.parseinfo) for exp in self.arguments: yield from exp.validate(lvalue=True)