def _generate_task_cfg_source(self, dest_dir, header_file, file_name = 'os_task_cfg.c'):
source = C.cfile(os.path.join(dest_dir, file_name))
code = source.code
code.extend(_genCommentHeader('INCLUDES'))
code.append(C.include(header_file))
code.append(C.include('os_event_cfg.h'))
code.append('')
code.extend(_genCommentHeader('PRIVATE VARIABLES'))
for static_var in sorted(self.static_vars.values(), key=lambda x: x.name):
code.append(C.statement(static_var))
code.append('')
for alarm_var in self.alarm_vars:
code.append(C.line(str(alarm_var.decl)+' ='))
code.append(C.statement(alarm_var.body))
code.append(C.line(str(self.os_task_var.decl)+' ='))
code.append(C.statement(self.os_task_var.body))
code.append('')
code.extend(_genCommentHeader('PUBLIC VARIABLES'))
code.append(C.line('os_cfg_t g_os_cfg ='))
body = C.block(innerIndent = innerIndentDefault)
body.append(C.line('&os_task_cfg[0],'))
body.append(C.line('OS_NUM_TASKS,'))
body.append(C.line('0,'))
body.append(C.line('0'))
code.append(C.statement(body))
code.append('')
code.extend(_genCommentHeader('PUBLIC FUNCTIONS'))
for elem in self.cfg.partition.mode_switch_functions.values():
for callback_name in sorted(elem.calls.keys()):
code.extend(self._generate_mode_switch_func(callback_name, elem.calls[callback_name]))
code.append('')
with io.open(source.path, 'w', newline='\n') as fp:
for line in source.lines():
fp.write(line+'\n')
def _init_body(self, event):
self.body.append(
C.statement('%s %s = %s' %
(self.typename, 'previousMode', self.static_var.name)))
self.body.append(
C.statement('%s = %s' %
(self.static_var.name, self.proto.args[0].name)))
def __init__(self, prefix, component, port, data_element, var_name):
data_type = data_element.dataType
func_name = '%s_SetReadData_%s_%s_%s' % (prefix, component.name,
port.name, data_element.name)
shortname = '%s_SetReadData_%s_%s' % (prefix, port.name,
data_element.name)
proto = C.function(func_name, 'void')
proto.add_arg(
C.variable('data', data_type.name,
pointer=data_type.isComplexType))
self.shortname = shortname
self.data_element = data_element
self.proto = proto
body = C.block(innerIndent=innerIndentDefault)
if isinstance(data_type, autosar.datatype.ArrayDataType):
body.append(
C.statement('memcpy(&%s[0], %s, sizeof(%s)' %
(var_name, proto.args[0].name, var_name)))
elif isinstance(data_type, autosar.datatype.RecordDataType):
body.append(
C.statement('memcpy(&%s, %s, sizeof(%s)' %
(var_name, proto.args[0].name, var_name)))
else:
body.append(C.statement('%s = %s' %
(var_name, proto.args[0].name)))
self.body = body
def _write_header_public_func(self, code):
code.append('')
code.extend(_genCommentHeader2("PUBLIC FUNCTION PROTOTYPES"))
code.append(C.statement(C.function('Rte_Start', 'void')))
if self.mode_switch_enable and len(
self.partition.mode_switch_functions) > 0:
for func in [
self.partition.mode_switch_functions[key] for key in
sorted(self.partition.mode_switch_functions.keys())
]:
code.append(C.statement(func.proto))
def _genWrite(self, fp, prototypes):
for proto in prototypes:
hasComSignal = False
body = C.block(innerIndent=3)
if proto.data_element.name in self.com_access['send']:
func = self.com_access['send'][proto.data_element.name]
body.code.append(C.statement('return '+str(C.fcall(func.name, params=[proto.func.args[0].name]))))
else:
body.code.append(C.statement('return RTE_E_OK'))
fp.write(str(proto.func)+'\n')
fp.write('\n'.join(body.lines())+'\n\n')
def _write_local_vars(self, fp):
fp.write('\n'.join(_genCommentHeader('Local Variables')) + '\n')
code = C.sequence()
for data_element in sorted(self.partition.data_element_map.values(),
key=lambda x: x.symbol):
var = C.variable(data_element.symbol, data_element.dataType.name,
True)
code.append(C.statement(var))
for key in sorted(self.extra_static_vars.keys()):
code.append(C.statement(self.extra_static_vars[key]))
fp.write('\n'.join(code.lines()) + '\n\n')
def _rand():
print("Generate rand function...")
body = C.block(innerIndent=3)
body.append(
C.statement(f"{C.variable('var0', 'int')} = {C.fcall('rand')}"))
body.append(C.statement('return var0'))
head = C.function('f_rand', 'int')
func = C.sequence()
func.append(head)
func.append(body)
print(str(func))
return func
def _genRead(self, fp, prototypes):
"""Generates all Rte_Read functions"""
for proto in prototypes:
body = C.block(innerIndent=3)
#body.code.append(C.statement('*%s = %s'%(proto.func.args[0].name, proto.rte_var.name)))
#print(proto.rte_var.typename)
if proto.data_element.name in self.com_access['receive']:
func = self.com_access['receive'][proto.data_element.name]
body.code.append(C.statement('return '+str(C.fcall(func.name, params=[proto.func.args[0].name]))))
else:
body.code.append(C.statement('return RTE_E_OK'))
fp.write(str(proto.func)+'\n')
fp.write('\n'.join(body.lines())+'\n\n')
def _createMockServerCallFunction(self, proto, var_name):
body = C.block(innerIndent=innerIndentDefault)
body.append(C.line('if (%s != 0)' % (var_name)))
inner = C.block(innerIndent=innerIndentDefault)
fcall = C.fcall(var_name)
for arg in proto.args:
fcall.add_param(arg.name)
if proto.typename != 'void':
inner.append(C.statement('return %s' % str(fcall)))
else:
inner.append(C.statement(fcall))
body.append(inner)
if proto.typename != 'void':
body.append(C.statement('return RTE_E_OK'))
return body
def _create_operation_setter(self, component, port, operation,
port_access):
func_name = '%s_SetCallHandler_%s_%s_%s' % (
self.prefix, component.name, port.name, operation.name)
short_name = '%s_SetCallHandler_%s_%s' % (self.prefix, port.name,
operation.name)
type_name = '%s_%s_ServerCallHandler_t' % (port.name, operation.name)
var_name = 'm_ServerCallHandler_%s_%s_%s' % (component.name, port.name,
operation.name)
port_func = port.portAPI['Rte_Call_%s_%s' %
(port.name, operation.name)]
tmp_proto = C.fptr.from_func(port_func.proto, type_name)
self.typedefs[type_name] = 'typedef %s' % str(tmp_proto)
proto = C.function(
func_name,
'void',
args=[C.variable('handler_func', type_name, pointer=True)])
func = autosar.rte.base.SetCallHandlerFunction(short_name, proto,
operation, var_name)
self.extra_public_functions[short_name] = func
static_var = C.variable(var_name, type_name, static=True, pointer=True)
self.extra_static_vars[var_name] = static_var
self.extra_rte_start.append(
C.statement('%s = (%s*) 0' % (var_name, type_name)))
body = self._createMockServerCallFunction(port_func.proto, var_name)
self.extra_public_functions[
port_func.proto.name] = autosar.rte.base.ServerCallFunction(
port_func.proto, body)
def _scanf_no_pointer():
print("Generate scanf function...")
body = C.block(innerIndent=3)
body.append(C.statement(C.variable('var0', 'int')))
body.append(
C.statement(C.fcall('scanf').add_arg('\"%d\"').add_arg('&var0')))
body.append(C.statement("return var0"))
head = C.function(
'f_scanf_nop',
'int',
)
func = C.sequence()
func.append(head)
func.append(body)
print(str(func))
return func
def _writeRunnableProto(self, runnable):
lines = []
lines.extend([
C.line(x) for x in _genCommentHeader('Runnable %s' % runnable.name)
])
lines.append(C.statement(runnable.prototype))
lines.append(C.blank())
return lines
def __init__(self, prefix, component, port, data_element, var_name):
data_type = data_element.dataType
func_name='%s_SetReadData_%s_%s_%s'%(prefix, component.name, port.name, data_element.name)
shortname='%s_SetReadData_%s_%s'%(prefix, port.name, data_element.name)
proto=C.function(func_name, 'void')
proto.add_arg(C.variable('data', data_type.name, pointer=data_type.isComplexType))
self.shortname = shortname
self.data_element = data_element
self.proto=proto
body = C.block(innerIndent=innerIndentDefault)
if isinstance(data_type, autosar.datatype.ArrayDataType):
body.append(C.statement('memcpy(&%s[0], %s, sizeof(%s)'%(var_name, proto.args[0].name, var_name)))
elif isinstance(data_type, autosar.datatype.RecordDataType):
body.append(C.statement('memcpy(&%s, %s, sizeof(%s)'%(var_name, proto.args[0].name, var_name)))
else:
body.append(C.statement('%s = %s'%(var_name, proto.args[0].name)))
self.body=body
def _write_init_values(self, body):
for data_element in sorted(self.partition.data_element_map.values(),
key=lambda x: x.symbol):
if data_element.initValue is not None:
init_str = autosar.constant.initializer_string(
data_element.initValue)
body.code.append(
C.statement('%s = %s' % (data_element.symbol, init_str)))
def _initDefaultType(self):
self.defaultTypes['Boolean'] = C.sequence().extend(
[C.statement(C.typedef('boolean', 'Boolean'))])
self.defaultTypes['UInt8'] = C.sequence().extend([
C.statement(C.typedef('uint8', 'UInt8')),
C.define('UInt8_LowerLimit', '((UInt8)0u)'),
C.define('UInt8_UpperLimit', '((UInt8)255u)')
])
self.defaultTypes['UInt16'] = C.sequence().extend([
C.statement(C.typedef('uint16', 'UInt16')),
C.define('UInt16_LowerLimit', '((UInt16)0u)'),
C.define('UInt16_UpperLimit', '((UInt16)65535u)')
])
self.defaultTypes['UInt32'] = C.sequence().extend([
C.statement(C.typedef('uint32', 'UInt32')),
C.define('UInt32_LowerLimit', '((UInt32)0u)'),
C.define('UInt32_UpperLimit', '((UInt32)4294967295u)')
])
self.defaultTypes['SInt8'] = C.sequence().extend([
C.statement(C.typedef('sint8', 'SInt8')),
C.define('SInt8_LowerLimit', '((SInt8)-128)'),
C.define('SInt8_UpperLimit', '((SInt8)127)')
])
self.defaultTypes['SInt16'] = C.sequence().extend([
C.statement(C.typedef('sint16', 'SInt16')),
C.define('SInt16_LowerLimit', '((SInt16)-32768)'),
C.define('SInt16_UpperLimit', '((SInt16)32767)')
])
self.defaultTypes['SInt32'] = C.sequence().extend([
C.statement(C.typedef('sint32', 'SInt32')),
C.define('SInt32_LowerLimit', '((SInt32)-2147483648)'),
C.define('SInt32_UpperLimit', '((SInt32)2147483647)')
])
def generate_on_exit_code(self, event, callback_name):
code = C.sequence()
else_str = 'else ' if len(self.calls) > 0 else ''
code.append(C.line(else_str+'if ( (previousMode == RTE_MODE_{0}) && (newMode != RTE_MODE_{0}) )'.format(event.mode+'_'+event.modeDeclaration)))
block = C.block(innerIndent = innerIndentDefault)
block.append(C.statement(C.fcall(callback_name)))
code.append(block)
self.add_event_to_call(event, callback_name)
self.body.extend(code)
def _genComponentHeader(self, fp, component):
ws = component.swc.rootWS()
assert(ws is not None)
hfile=C.hfile(None, guard='RTE_%s_H'%(component.swc.name.upper()))
hfile.code.append(C.include('Rte.h'))
hfile.code.append(C.include('Rte_Type.h'))
lines = self._genInitValues(ws, component.swc.requirePorts+component.swc.providePorts)
if len(lines)>0:
hfile.code.extend([C.line(x) for x in _genCommentHeader('Init Values')])
hfile.code.extend(lines)
#Write API
hfile.code.append(C.blank())
hfile.code.extend([C.line(x) for x in _genCommentHeader('API Prototypes')])
for proto in component.clientAPI.get_all():
hfile.code.append(C.statement(proto.func))
if len(component.clientAPI.final['read'])>0:
hfile.code.append(C.blank())
hfile.code.extend([C.line(x) for x in _genCommentHeader('Rte_Read_<p>_<d>')])
hfile.code.extend([C.define(proto.shortname, proto.func.name) for proto in component.clientAPI.final['read']])
if len(component.clientAPI.final['write'])>0:
hfile.code.append(C.blank())
hfile.code.extend([C.line(x) for x in _genCommentHeader('Rte_Write_<p>_<d>')])
hfile.code.extend([C.define(proto.shortname, proto.func.name) for proto in component.clientAPI.final['write']])
if len(component.clientAPI.final['receive'])>0:
hfile.code.append(C.blank())
hfile.code.extend([C.line(x) for x in _genCommentHeader('Rte_Receive_<p>_<d>')])
hfile.code.extend([C.define(proto.shortname, proto.func.name) for proto in component.clientAPI.final['receive']])
if len(component.clientAPI.final['send'])>0:
hfile.code.append(C.blank())
hfile.code.extend([C.line(x) for x in _genCommentHeader('Rte_Send_<p>_<d>')])
hfile.code.extend([C.define(proto.shortname, proto.func.name) for proto in component.clientAPI.final['send']])
if len(component.clientAPI.final['mode'])>0:
hfile.code.append(C.blank())
hfile.code.extend([C.line(x) for x in _genCommentHeader('Rte_Mode_<p>_<d>')])
hfile.code.extend([C.define(proto.shortname, proto.func.name) for proto in component.clientAPI.final['mode']])
if len(component.clientAPI.final['mode'])>0:
hfile.code.append(C.blank())
hfile.code.extend([C.line(x) for x in _genCommentHeader('Rte_Mode_<mode>')])
hfile.code.extend([C.define(proto.shortname, proto.func.name) for proto in component.clientAPI.final['mode']])
if len(component.clientAPI.final['calprm'])>0:
hfile.code.append(C.blank())
hfile.code.extend([C.line(x) for x in _genCommentHeader('Rte_Calprm_<name>')])
hfile.code.extend([C.define(proto.shortname, proto.func.name) for proto in component.clientAPI.final['calprm']])
if len(component.clientAPI.final['call'])>0:
hfile.code.append(C.blank())
hfile.code.extend([C.line(x) for x in _genCommentHeader('Rte_Call_<p>_<o> ')])
hfile.code.extend([C.define(proto.shortname, proto.func.name) for proto in component.clientAPI.final['call']])
if len(component.rte_runnables)>0:
for name in sorted(component.rte_runnables):
runnable = component.rte_runnables[name]
tmp = self._writeRunnableProto(runnable)
hfile.code.extend(tmp)
fp.write('\n'.join(hfile.lines()))
fp.write('\n')
def _generate_task_cfg_source(self,
dest_dir,
header_file,
file_name='os_task_cfg.c'):
source = C.cfile(os.path.join(dest_dir, file_name))
code = source.code
code.extend(_genCommentHeader('INCLUDES'))
code.append(C.include(header_file))
code.append(C.include('os_event_cfg.h'))
code.append('')
code.extend(_genCommentHeader('PRIVATE VARIABLES'))
for static_var in sorted(self.static_vars.values(),
key=lambda x: x.name):
code.append(C.statement(static_var))
code.append('')
for alarm_var in self.alarm_vars:
code.append(C.line(str(alarm_var.decl) + ' ='))
code.append(C.statement(alarm_var.body))
code.append(C.line(str(self.os_task_var.decl) + ' ='))
code.append(C.statement(self.os_task_var.body))
code.append('')
code.extend(_genCommentHeader('PUBLIC VARIABLES'))
code.append(C.line('os_cfg_t g_os_cfg ='))
body = C.block(innerIndent=innerIndentDefault)
body.append(C.line('&os_task_cfg[0],'))
body.append(C.line('OS_NUM_TASKS,'))
body.append(C.line('0,'))
body.append(C.line('0'))
code.append(C.statement(body))
code.append('')
code.extend(_genCommentHeader('PUBLIC FUNCTIONS'))
for elem in self.cfg.partition.mode_switch_functions.values():
for callback_name in sorted(elem.calls.keys()):
code.extend(
self._generate_mode_switch_func(callback_name,
elem.calls[callback_name]))
code.append('')
with io.open(source.path, 'w', newline='\n') as fp:
for line in source.lines():
fp.write(line + '\n')
def _generate_runnable_calls(self, code, matching_runnables):
events = matching_runnables[0].event_triggers
if len(events) == 1:
event = events[0]
if not isinstance(event, autosar.rte.base.OperationInvokedEvent):
code.append(C.line('if (eventMask & %s)' % event.symbol))
block = C.block(innerIndent=innerIndentDefault)
for runnable in matching_runnables:
block.append(C.statement(C.fcall(runnable.symbol)))
code.append(block)
elif len(events) > 1:
raise NotImplementedError('multiple events')
def _genGet(self, fp, prototypes):
for port_func in prototypes:
body = C.block(innerIndent=innerIndentDefault)
prefix = '&' if port_func.data_element.dataType.isComplexType else ''
suffix = '[0]' if isinstance(
port_func.data_element.dataType,
autosar.datatype.ArrayDataType) else ''
body.code.append(
C.statement('return %s%s%s' %
(prefix, port_func.data_element.symbol, suffix)))
fp.write(str(port_func.proto) + '\n')
fp.write('\n'.join(body.lines()) + '\n\n')
def _func(funcname):
print(f"Generate {funcname}...")
para_count = random.randint(0, 3)
local_count = 3
local_const = 2
body = C.block(innerIndent=3)
for i in range(local_count):
body.append(
C.statement(
f"{C.variable(f'var{i}', 'int')} = {C.fcall(random.choice(['f_rand', 'f_scanf_nop']))}"
))
for i in range(local_const):
body.append(
C.statement(
f"{C.variable(f'var{i+local_count}', 'int')} = {random.randint(-1000, 1000)}"
))
all_vars = [f'var{i}' for i in range(local_const + local_count)
] + [f'p{i}' for i in range(para_count)]
op_seq = ['+', '-', '*', '/', '<<', '>>']
# print(all_vars)
max_iter = 5
targets = []
for i in range(4):
trg = random.choice(all_vars)
expr = _expression(all_vars, op_seq, trg)
body.append(C.statement(f"{trg} = {expr}"))
targets.append(trg)
ret_var = random.choice(all_vars)
ret_expr = _expression(targets, op_seq, ret_var)
body.append(C.statement(f"{ret_var} = {ret_expr}"))
body.append(C.statement(f'return {ret_var}'))
head = C.function(funcname, 'int')
for i in range(para_count):
head.add_param(C.variable(f'p{i}', 'int'))
func = C.sequence()
func.append(head)
func.append(body)
print(str(func))
return func
def _main():
print("Generate main function...")
func = C.sequence()
head = C.function(
'main',
'int',
)
body = C.block(innerIndent=3)
body.append(C.statement('return 0'))
func.append(head)
func.append(body)
print(str(func))
return func
def _printf():
print("Generate printf function...")
body = C.block(innerIndent=3)
body.append(C.statement(C.fcall('printf').add_arg('\"%d\"').add_arg('p0')))
head = C.function(
'f_printf',
'void',
).add_param(C.variable('p0', 'int'))
func = C.sequence()
func.append(head)
func.append(body)
print(str(func))
return func
def _generate_task_cfg_header(self, dest_dir, file_name = 'os_task_cfg.h'):
header = C.hfile(os.path.join(dest_dir, file_name))
code = header.code
code.extend(_genCommentHeader('INCLUDES'))
code.append(C.include('os_types.h'))
code.append(C.include('os_task.h'))
code.append('')
code.extend(_genCommentHeader('PUBLIC CONSTANTS AND DATA TYPES'))
code.append(C.define('OS_NUM_TASKS',str(len(self.cfg.tasks))+'u'))
code.append('')
code.extend(_genCommentHeader('PUBLIC VARIABLES'))
code.append(C.statement('extern os_cfg_t g_os_cfg'))
code.append('')
code.extend(_genCommentHeader('PUBLIC FUNCTION PROTOTYPES'))
for task in self.cfg.tasks:
code.append(C.statement('OS_TASK_HANDLER(%s, arg)'%task.name))
for function_name in self.cfg.mode_switch_calls:
code.append(C.statement(C.function(function_name, 'void')))
with io.open(header.path, 'w', newline='\n') as fp:
for line in header.lines():
fp.write(line+'\n')
return file_name
def _generate_task_cfg_header(self, dest_dir, file_name='os_task_cfg.h'):
header = C.hfile(os.path.join(dest_dir, file_name))
code = header.code
code.extend(_genCommentHeader('INCLUDES'))
code.append(C.include('os_types.h'))
code.append(C.include('os_task.h'))
code.append('')
code.extend(_genCommentHeader('PUBLIC CONSTANTS AND DATA TYPES'))
code.append(C.define('OS_NUM_TASKS', str(len(self.cfg.tasks)) + 'u'))
code.append('')
code.extend(_genCommentHeader('PUBLIC VARIABLES'))
code.append(C.statement('extern os_cfg_t g_os_cfg'))
code.append('')
code.extend(_genCommentHeader('PUBLIC FUNCTION PROTOTYPES'))
for task in self.cfg.tasks:
code.append(C.statement('OS_TASK_HANDLER(%s, arg)' % task.name))
for function_name in self.cfg.mode_switch_calls:
code.append(C.statement(C.function(function_name, 'void')))
with io.open(header.path, 'w', newline='\n') as fp:
for line in header.lines():
fp.write(line + '\n')
return file_name
def _generate_mode_switch_func(self, callback_name, events):
code = C.sequence()
generated=set()
code.append(C.function(callback_name, 'void'))
block = C.block(innerIndent = innerIndentDefault)
for event in events:
task = self.cfg.find_os_task_by_runnable(event.runnable)
if task is not None:
if (task.name, event.name) not in generated:
block.append(C.statement(C.fcall('os_task_setEvent', params=['&m_os_task_%s'%task.name, 'EVENT_MASK_%s_%s'%(task.name, event.name)])))
generated.add((task.name, event.name))
code.append(block)
return code
def __init__(self, prefix, component, port, data_element):
func_name='%s_SetReadResult_%s_%s_%s'%(prefix, component.name, port.name, data_element.name)
shortname='%s_SetReadResult_%s_%s'%(prefix, port.name, data_element.name)
proto=C.function(func_name, 'void')
proto.add_arg(C.variable('value', 'Std_ReturnType'))
self.shortname = shortname
self.proto=proto
self.data_element = data_element
data_element.result_var = C.variable('m_ReadResult_%s_%s_%s'%(component.name, port.name, data_element.name), 'Std_ReturnType', static=True)
self.static_var = data_element.result_var
body = C.block(innerIndent=innerIndentDefault)
body.append(C.statement('%s = %s'%(self.static_var.name, proto.args[0].name)))
self.body=body
def _genRead(self, fp, prototypes):
"""Generates all Rte_Read functions"""
for port_func in prototypes:
body = C.block(innerIndent=innerIndentDefault)
if port_func.data_element.com_access['Receive'] is not None:
com_func = port_func.data_element.com_access['Receive']
body.code.append(
C.statement('return ' + str(
C.fcall(com_func.name,
params=[port_func.proto.args[0].name]))))
else:
body.code.append(
C.statement('*%s = %s' % (port_func.proto.args[0].name,
port_func.data_element.symbol)))
if port_func.data_element.result_var is not None:
body.code.append(
C.statement('return %s' %
port_func.data_element.result_var.name))
else:
body.code.append(C.statement('return RTE_E_OK'))
fp.write(str(port_func.proto) + '\n')
fp.write('\n'.join(body.lines()) + '\n\n')
def _genWrite(self, fp, prototypes):
for port_func in prototypes:
hasComSignal = False
body = C.block(innerIndent=innerIndentDefault)
if port_func.data_element.symbol is not None:
body.code.append(
C.statement('%s = %s' % (port_func.data_element.symbol,
port_func.proto.args[0].name)))
if port_func.data_element.com_access['Send'] is not None:
com_func = port_func.data_element.com_access['Send']
body.code.append(
C.statement('return ' + str(
C.fcall(com_func.name,
params=[port_func.proto.args[0].name]))))
else:
if port_func.data_element.result_var is not None:
body.code.append(
C.statement('return %s' %
port_func.data_element.result_var.name))
else:
body.code.append(C.statement('return RTE_E_OK'))
fp.write(str(port_func.proto) + '\n')
fp.write('\n'.join(body.lines()) + '\n\n')
def _create_data_element_setter(self, component, port, data_element):
var_name = self._createDataElementVariable(component, port,
data_element)
port_func = autosar.rte.base.SetReadDataFunction(
self.prefix, component, port, data_element, var_name)
self.partition.upperLayerAPI.setReadData[
port_func.shortname] = port_func
port_func = autosar.rte.base.SetReadResultFunction(
self.prefix, component, port, data_element)
self.partition.upperLayerAPI.setReadResult[
port_func.shortname] = port_func
self.extra_static_vars[
port_func.static_var.name] = port_func.static_var
self.extra_rte_start.append(
C.statement('%s = RTE_E_OK' % (data_element.result_var.name)))
def _generate_task_body(self, task):
code = C.block(innerIndent=innerIndentDefault)
isRunning = C.variable('isRunning', 'boolean')
code.append(C.statement('{0} = TRUE'.format(str(isRunning))))
code.append(C.statement('os_task_t *self = (os_task_t*)arg'))
code.append('')
code.append(C.line('if (self == 0)'))
body = C.block(innerIndent=innerIndentDefault)
body.append(C.statement('THREAD_RETURN(1)'))
code.append(body)
code.append('')
code.append(C.line('while (isRunning == TRUE)'))
while_block = C.block(innerIndent=innerIndentDefault)
while_block.append(C.statement('uint32 eventMask'))
while_block.append(
C.statement('int8_t result = os_task_waitEvent(self, &eventMask)'))
while_block.append(C.line('if (result == 0)'))
if_block = C.block(innerIndent=innerIndentDefault)
if_block.extend(self._generate_event_mask_triggers(task))
while_block.append(if_block)
while_block.append(C.line('else if(result > 0)'))
if_block = C.block(innerIndent=innerIndentDefault)
if_block.append(C.statement('printf("%s_QuitEvent\\n")' % task.name))
if_block.append(C.statement('isRunning = false'))
while_block.append(if_block)
while_block.append(C.line('else'))
if_block = C.block(innerIndent=innerIndentDefault)
if_block.append(
C.statement(r'fprintf(stderr, "os_task_waitEvent failed\n")'))
while_block.append(if_block)
code.append(while_block)
code.append('')
code.append(C.statement('THREAD_RETURN(0)'))
return code
def _generate_mode_switch_func(self, callback_name, events):
code = C.sequence()
generated = set()
code.append(C.function(callback_name, 'void'))
block = C.block(innerIndent=innerIndentDefault)
for event in events:
task = self.cfg.find_os_task_by_runnable(event.runnable)
if task is not None:
if (task.name, event.name) not in generated:
block.append(
C.statement(
C.fcall('os_task_setEvent',
params=[
'&m_os_task_%s' % task.name,
'EVENT_MASK_%s_%s' %
(task.name, event.name)
])))
generated.add((task.name, event.name))
code.append(block)
return code
def _createHeaderLines(self, filepath):
hfile = C.hfile(filepath)
code = hfile.code
code.extend([C.line(x) for x in _genCommentHeader('Includes')])
code.append(C.include("Std_Types.h"))
code.append(C.include("Rte_Type.h"))
code.append(C.include("Rte.h"))
code.append(C.blank())
code.extend(_genCommentHeader('Constants and Types'))
for key in sorted(self.typedefs.keys()):
code.append(C.statement(self.typedefs[key]))
code.append(C.blank())
code.extend([
C.line(x)
for x in _genCommentHeader('Public Function Declarations')
])
code.append(C.blank())
code.append(
C.statement(C.function('%s_Start' % self.api_prefix, 'void')))
for func in sorted(self.partition.upperLayerAPI.final['get'],
key=lambda x: x.shortname):
assert func.proto is not None
hfile.code.append(C.statement(func.proto))
for func in sorted(self.partition.upperLayerAPI.final['setReadData'],
key=lambda x: x.shortname):
assert func.proto is not None
hfile.code.append(C.statement(func.proto))
for func in sorted(self.partition.upperLayerAPI.final['setReadResult'],
key=lambda x: x.shortname):
assert func.proto is not None
hfile.code.append(C.statement(func.proto))
for func in sorted(self.extra_public_functions.values(),
key=lambda x: x.shortname):
assert func.proto is not None
hfile.code.append(C.statement(func.proto))
hfile.code.append(C.blank())
return hfile.lines()
def _create_body(self, proto):
body = C.block(innerIndent=3)
body.append(C.statement('%s = %s'%(self.varname, proto.args[0].name)))
return body
def _init_body(self, event):
self.body.append(C.statement('%s %s = %s'%(self.typename, 'previousMode', self.static_var.name)))
self.body.append(C.statement('%s = %s'%(self.static_var.name, self.proto.args[0].name)))
def _genCall(self, fp, prototypes):
for proto in prototypes:
body = C.block(innerIndent=innerIndentDefault)
body.code.append(C.statement('return RTE_E_OK'))
fp.write(str(proto.func) + '\n')
fp.write('\n'.join(body.lines()) + '\n\n')
