def visit_simple_expression(self, node):
"""
Visits a single function call as stored in a simple expression and derives the correct type of all its
parameters. :param node: a simple expression :type node: ASTSimpleExpression :rtype void
"""
assert isinstance(node, ASTSimpleExpression), \
'(PyNestML.Visitor.FunctionCallVisitor) No or wrong type of simple expression provided (%s)!' % tuple(node)
assert (node.get_scope() is not None), \
"(PyNestML.Visitor.FunctionCallVisitor) No scope found, run symboltable creator!"
scope = node.get_scope()
function_name = node.get_function_call().get_name()
method_symbol = scope.resolve_to_symbol(function_name,
SymbolKind.FUNCTION)
# check if this function exists
if method_symbol is None:
code, message = Messages.get_could_not_resolve(function_name)
Logger.log_message(code=code,
message=message,
error_position=node.get_source_position(),
log_level=LoggingLevel.ERROR)
node.type = ErrorTypeSymbol()
return
return_type = method_symbol.get_return_type()
return_type.referenced_object = node
# convolve symbol does not have a return type set.
# returns whatever type the second parameter is.
if function_name == PredefinedFunctions.CONVOLVE:
# Deviations from the assumptions made here are handled in the convolveCoco
buffer_parameter = node.get_function_call().get_args()[1]
if buffer_parameter.getVariable() is not None:
buffer_name = buffer_parameter.getVariable().getName()
buffer_symbol_resolve = scope.resolve_to_symbol(
buffer_name, SymbolKind.VARIABLE)
if buffer_symbol_resolve is not None:
node.type = buffer_symbol_resolve.getTypeSymbol()
return
# getting here means there is an error with the parameters to convolve
code, message = Messages.get_convolve_needs_buffer_parameter()
Logger.log_message(code=code,
message=message,
error_position=node.get_source_position(),
log_level=LoggingLevel.ERROR)
node.type = ErrorTypeSymbol()
return
if isinstance(method_symbol.get_return_type(), VoidTypeSymbol):
# todo by KP: the error message is not used here, @ptraeder fix this
# error_msg = ErrorStrings.message_void_function_on_rhs(self, function_name, node.get_source_position())
node.type = ErrorTypeSymbol()
return
# if nothing special is handled, just get the expression type from the return type of the function
node.type = return_type
def visit_simple_expression(self, node):
"""
Visits a single function call as stored in a simple expression and derives the correct type of all its
parameters. :param node: a simple expression :type node: ASTSimpleExpression :rtype void
"""
assert isinstance(node, ASTSimpleExpression), \
'(PyNestML.Visitor.FunctionCallVisitor) No or wrong type of simple expression provided (%s)!' % tuple(node)
assert (node.get_scope() is not None), \
"(PyNestML.Visitor.FunctionCallVisitor) No scope found, run symboltable creator!"
scope = node.get_scope()
function_name = node.get_function_call().get_name()
method_symbol = scope.resolve_to_symbol(function_name, SymbolKind.FUNCTION)
# check if this function exists
if method_symbol is None:
code, message = Messages.get_could_not_resolve(function_name)
Logger.log_message(code=code, message=message, error_position=node.get_source_position(),
log_level=LoggingLevel.ERROR)
node.type = ErrorTypeSymbol()
return
return_type = method_symbol.get_return_type()
return_type.referenced_object = node
# convolve symbol does not have a return type set.
# returns whatever type the second parameter is.
if function_name == PredefinedFunctions.CONVOLVE:
# Deviations from the assumptions made here are handled in the convolveCoco
buffer_parameter = node.get_function_call().get_args()[1]
if buffer_parameter.get_variable() is not None:
buffer_name = buffer_parameter.get_variable().get_name()
buffer_symbol_resolve = scope.resolve_to_symbol(buffer_name, SymbolKind.VARIABLE)
if buffer_symbol_resolve is not None:
node.type = buffer_symbol_resolve.get_type_symbol()
return
# getting here means there is an error with the parameters to convolve
code, message = Messages.get_convolve_needs_buffer_parameter()
Logger.log_message(code=code, message=message, error_position=node.get_source_position(),
log_level=LoggingLevel.ERROR)
node.type = ErrorTypeSymbol()
return
if isinstance(method_symbol.get_return_type(), VoidTypeSymbol):
# todo by KP: the error message is not used here, @ptraeder fix this
# error_msg = ErrorStrings.message_void_function_on_rhs(self, function_name, node.get_source_position())
node.type = ErrorTypeSymbol()
return
# if nothing special is handled, just get the expression type from the return type of the function
node.type = return_type
def visit_simple_expression(self, node):
"""
Visits a single function call as stored in a simple expression and derives the correct type of all its
parameters. :param node: a simple expression :type node: ASTSimpleExpression :rtype void
"""
assert isinstance(node, ASTSimpleExpression), \
'(PyNestML.Visitor.FunctionCallVisitor) No or wrong type of simple expression provided (%s)!' % tuple(node)
assert (node.get_scope() is not None), \
"(PyNestML.Visitor.FunctionCallVisitor) No scope found, run symboltable creator!"
scope = node.get_scope()
function_name = node.get_function_call().get_name()
method_symbol = scope.resolve_to_symbol(function_name, SymbolKind.FUNCTION)
# check if this function exists
if method_symbol is None:
code, message = Messages.get_could_not_resolve(function_name)
Logger.log_message(code=code, message=message, error_position=node.get_source_position(),
log_level=LoggingLevel.ERROR)
node.type = ErrorTypeSymbol()
return
return_type = method_symbol.get_return_type()
if isinstance(return_type, TemplateTypeSymbol):
for i, arg_type in enumerate(method_symbol.param_types):
if arg_type == return_type:
return_type = node.get_function_call().get_args()[i].type
break
if isinstance(return_type, TemplateTypeSymbol):
# error: return type template not found among parameter type templates
assert(False)
# check for consistency among actual derived types for template parameters
from pynestml.cocos.co_co_function_argument_template_types_consistent import CorrectTemplatedArgumentTypesVisitor
correctTemplatedArgumentTypesVisitor = CorrectTemplatedArgumentTypesVisitor()
correctTemplatedArgumentTypesVisitor._failure_occurred = False
node.accept(correctTemplatedArgumentTypesVisitor)
if correctTemplatedArgumentTypesVisitor._failure_occurred:
return_type = ErrorTypeSymbol()
return_type.referenced_object = node
# convolve symbol does not have a return type set.
# returns whatever type the second parameter is.
if function_name == PredefinedFunctions.CONVOLVE:
# Deviations from the assumptions made here are handled in the convolveCoco
buffer_parameter = node.get_function_call().get_args()[1]
if buffer_parameter.get_variable() is not None:
buffer_name = buffer_parameter.get_variable().get_name()
buffer_symbol_resolve = scope.resolve_to_symbol(buffer_name, SymbolKind.VARIABLE)
if buffer_symbol_resolve is not None:
node.type = buffer_symbol_resolve.get_type_symbol()
return
# getting here means there is an error with the parameters to convolve
code, message = Messages.get_convolve_needs_buffer_parameter()
Logger.log_message(code=code, message=message, error_position=node.get_source_position(),
log_level=LoggingLevel.ERROR)
node.type = ErrorTypeSymbol()
return
if isinstance(method_symbol.get_return_type(), VoidTypeSymbol):
# todo: the error message is not used here, fix this
# error_msg = ErrorStrings.message_void_function_on_rhs(self, function_name, node.get_source_position())
node.type = ErrorTypeSymbol()
return
# if nothing special is handled, just get the expression type from the return type of the function
node.type = return_type
