def _type2arg(typeObj, pointer=False):
if (isinstance(typeObj, autosar.datatype.IntegerDataType)
or isinstance(typeObj, autosar.datatype.BooleanDataType)):
return C.variable('data', typeObj.name, pointer=pointer)
else:
pointer = True
return C.variable('data', typeObj.name, pointer=pointer)
def __init__(self, event):
self.body = C.block(innerIndent = innerIndentDefault)
self.calls = {}
self.typename = 'Rte_ModeType_'+event.mode
self.proto = C.function('Rte_SetMode_'+event.mode, 'void', args = [C.variable('newMode', self.typename)])
self.static_var = C.variable('m_'+event.mode, self.typename, static=True)
self._init_body(event)
def _generate_com_access(self):
if self.com_config is not None:
for element_name in self.partition.data_elements:
if element_name in self.com_config.send:
data_element = self.partition.data_elements[element_name][
'element']
isPointer = True if data_element.dataType.isComplexType else False
self.com_access['send'][element_name] = C.function(
"%s_Send_%s" % (self.com_config.prefix, element_name),
'Std_ReturnType',
args=[
C.variable('value',
data_element.dataType.name,
pointer=isPointer)
])
elif element_name in self.com_config.receive:
data_element = self.partition.data_elements[element_name][
'element']
isPointer = True if data_element.dataType.isComplexType else False
self.com_access['receive'][element_name] = C.function(
"%s_Receive_%s" %
(self.com_config.prefix, element_name),
'Std_ReturnType',
args=[
C.variable('value',
data_element.dataType.name,
pointer=isPointer)
])
else:
self.local_elements.push(element_name)
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 __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 __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 _createDefaultFunction(self, component, port, operation):
ws = component.swc.rootWS()
assert (ws is not None)
func_name = '_'.join([
self.prefix, 'Call', component.swc.name, port.name, operation.name
])
func = C.function(func_name, 'Std_ReturnType')
portInterface = ws.find(port.portInterfaceRef)
if portInterface is None:
raise ValueError("Error: invalid port interface reference: " +
port.portInterfaceRef)
for argument in operation.arguments:
dataType = ws.find(argument.typeRef)
if dataType is None:
raise ValueError('Error: Invalid type reference: ' +
argument.typeRef)
self.types.processType(ws, dataType)
isPointer = False
if dataType.isComplexType or (argument.direction
== 'OUT') or (argument.direction
== 'INOUT'):
isPointer = True
func.add_arg(
C.variable(argument.name, dataType.name, pointer=isPointer))
return func
def OperationInvokedRunnable(cls, name, symbol, ws, port, operation):
assert (ws is not None)
returnType = 'void'
if len(operation.errorRefs) > 0:
returnType = 'Std_ReturnType'
prototype = C.function(symbol, returnType)
for argument in operation.arguments:
dataType = ws.find(argument.typeRef)
if dataType is None:
raise ValueError('invalid type reference: ' + argument.typeRef)
isPointer = False
if isinstance(dataType,
autosar.datatype.RecordDataType) or isinstance(
dataType,
autosar.datatype.ArrayDataType) or isinstance(
dataType, autosar.datatype.ArrayDataType):
isPointer = True
if (isPointer == False) and (argument.direction == 'OUT') or (
argument.direction == 'INOUT'):
isPointer = True
prototype.add_arg(
C.variable(argument.name, dataType.name, pointer=isPointer))
self = cls(name, symbol, prototype)
self.isServerRunnable = True
self.serverPortInterface = ws.find(port.portInterfaceRef)
self.serverOperation = operation
return self
def __init__(self, task):
init_delay=0 #FIXME: allow users to select this at a later time
self.decl = C.variable('os_alarm_cfg_%s'%task.name, 'os_alarm_cfg_t', static=True, const=True, array='OS_NUM_ALARMS_%s'%task.name)
self.body = C.block(innerIndent=innerIndentDefault)
self.body.append(C.linecomment('OS Task, Event ID, Init Delay (ms), Period (ms)'))
for event in task.timer_events:
self.body.append(C.line('{'+'{0: >10},{1: >50},{2: >5},{3: >5}'.format(
'&m_os_task_'+task.name, 'EVENT_MASK_%s_%s'%(task.name,event.name), init_delay, event.inner.period)+'},'))
def _create_static_vars(self):
for os_task in self.cfg.tasks:
static_var = C.variable('m_os_task_' + os_task.name,
'os_task_t',
static=True)
self.static_vars[static_var.name] = static_var
if len(os_task.timer_events) > 0:
self.alarm_vars.append(AlarmVariable(os_task))
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 __init__(self, tasks):
self.decl = C.variable('os_task_cfg', 'os_task_elem_t', static=True, const=True, array='OS_NUM_TASKS')
self.body = C.block(innerIndent=innerIndentDefault)
for task in tasks:
fmt='{0: >25},{1: >15},{2: >30},{3: >30}'
if len(task.timer_events)>0:
self.body.append(C.line('{'+fmt.format(
'&m_os_task_'+task.name, task.name, '&os_alarm_cfg_%s[0]'%task.name, 'OS_NUM_ALARMS_%s'%task.name)+'},'))
else:
self.body.append(C.line('{'+fmt.format(
'&m_os_task_'+task.name, task.name, '(os_alarm_cfg_t*) 0', '0')+'},'))
def _generate_com_access(self):
for component in self.components:
if isinstance(component.inner, autosar.bsw.com.ComComponent):
for port in component.requirePorts:
for remote_port in port.connectors:
for data_element in remote_port.data_elements:
isPointer = True if data_element.dataType.isComplexType else False
proto = C.function(
"%s_Send_%s_%s" %
(component.inner.name, remote_port.name,
data_element.name),
'Std_ReturnType',
args=[
C.variable('value',
data_element.dataType.name,
pointer=isPointer)
])
data_element.com_access['Send'] = proto
component.inner.addSendInterface(
proto, port, data_element)
for port in component.providePorts:
for data_element in port.data_elements:
isPointer = True
proto = C.function(
"%s_Receive_%s_%s" %
(component.inner.name, remote_port.name,
data_element.name),
'Std_ReturnType',
args=[
C.variable('value',
data_element.dataType.name,
pointer=isPointer)
])
data_element.com_access['Receive'] = proto
component.inner.addReceiveInterface(
proto, port, data_element)
#remove from internal RTE variables
symbol = data_element.symbol
data_element.symbol = None
if symbol in self.data_element_map:
del self.data_element_map[symbol]
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 _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 __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 __init__(self, ws, ar_port, parent):
self.ws = ws
self.name = ar_port.name
self.ar_port = ar_port
self.parent = parent
self.connectors=[] #list of connected ports
self.portAPI={}
self.data_elements = []
self.operations = []
self.mode_groups = []
port_interface = ws.find(ar_port.portInterfaceRef)
if port_interface is None:
raise ValueError("Error: invalid port interface reference: "+ar_port.portInterfaceRef)
if isinstance(port_interface, autosar.portinterface.SenderReceiverInterface):
for data_element in port_interface.dataElements:
data_type=ws.find(data_element.typeRef)
if data_type is None:
raise ValueError('Error: Invalid data type reference: %s'%data_element.typeRef)
initValue = None
queueLength = None
if len(ar_port.comspec)>0:
for comspec in ar_port.comspec:
if (comspec.name == data_element.name) and (comspec.initValueRef is not None):
initValue = ws.find(comspec.initValueRef)
self.data_elements.append(DataElement(data_element.name, self, data_type, initValue, data_element.isQueued))
if port_interface.modeGroups is not None:
for group in port_interface.modeGroups:
data_type=ws.find(group.typeRef)
if data_type is None:
raise ValueError('Error: Invalid data type reference: %s'%group.typeRef)
self.mode_groups.append(ModeGroup(group.name, self, data_type))
elif isinstance(port_interface, autosar.portinterface.ClientServerInterface):
for operation in port_interface.operations:
arguments = []
for argument in operation.arguments:
dataType = ws.find(argument.typeRef)
if dataType is None:
raise ValueError('Error: Invalid type reference: '+argument.typeRef)
isPointer = False
if dataType.isComplexType or (argument.direction == 'OUT') or (argument.direction == 'INOUT'):
isPointer = True
arguments.append(C.variable(argument.name, dataType.name, pointer=isPointer))
self.operations.append(Operation(operation.name, self, arguments, operation))
def __init__(self, task):
init_delay = 0 #FIXME: allow users to select this at a later time
self.decl = C.variable('os_alarm_cfg_%s' % task.name,
'os_alarm_cfg_t',
static=True,
const=True,
array='OS_NUM_ALARMS_%s' % task.name)
self.body = C.block(innerIndent=innerIndentDefault)
self.body.append(
C.linecomment(
'OS Task, Event ID, Init Delay (ms), Period (ms)'
))
for event in task.timer_events:
self.body.append(
C.line('{' + '{0: >10},{1: >50},{2: >5},{3: >5}'.format(
'&m_os_task_' + task.name, 'EVENT_MASK_%s_%s' %
(task.name, event.name), init_delay, event.inner.period) +
'},'))
def __init__(self, tasks):
self.decl = C.variable('os_task_cfg',
'os_task_elem_t',
static=True,
const=True,
array='OS_NUM_TASKS')
self.body = C.block(innerIndent=innerIndentDefault)
for task in tasks:
fmt = '{0: >25},{1: >15},{2: >30},{3: >30}'
if len(task.timer_events) > 0:
self.body.append(
C.line('{' + fmt.format('&m_os_task_' + task.name,
task.name, '&os_alarm_cfg_%s[0]' %
task.name, 'OS_NUM_ALARMS_%s' %
task.name) + '},'))
else:
self.body.append(
C.line('{' +
fmt.format('&m_os_task_' + task.name, task.name,
'(os_alarm_cfg_t*) 0', '0') + '},'))
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 _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 create_server_call_point(self, ws, port, operation):
shortname = '_'.join(
[self.rte_prefix, 'Call', port.name, operation.name])
func = C.function(shortname, 'Std_ReturnType')
portInterface = ws.find(port.portInterfaceRef)
if portInterface is None:
raise ValueError("Error: invalid port interface reference: " +
port.portInterfaceRef)
for argument in operation.arguments:
dataType = ws.find(argument.typeRef)
if dataType is None:
raise ValueError('Error: Invalid type reference: ' +
argument.typeRef)
isPointer = False
if dataType.isComplexType or (argument.direction
== 'OUT') or (argument.direction
== 'INOUT'):
isPointer = True
func.add_arg(
C.variable(argument.name, dataType.name, pointer=isPointer))
rte_port_func = CallPortFunction(shortname, func, portInterface,
operation)
self.clientAPI.call[shortname] = rte_port_func
import cfile as C
hello = C.cfile('hello.c')
hello.code.append(C.sysinclude('stdio.h'))
hello.code.append(C.blank())
hello.code.append(
C.function(
'main',
'int',
).add_param(C.variable('argc', 'int')).add_param(
C.variable('argv', 'char', pointer=2)))
body = C.block(innerIndent=3)
body.append(C.statement(C.fcall('printf').add_arg(r'"Hello World!\n"')))
body.append(C.statement('return 0'))
hello.code.append(body)
print(str(hello))
def _create_static_vars(self):
for os_task in self.cfg.tasks:
static_var = C.variable('m_os_task_'+os_task.name, 'os_task_t', static=True)
self.static_vars[static_var.name]=static_var
if len(os_task.timer_events)>0:
self.alarm_vars.append(AlarmVariable(os_task))
def type2arg(typeObj, pointer=False, name='data'): return C.variable(name,typeObj.name,pointer=pointer)
def generate(self, dest_dir='.', file_name='Rte_Type.h'):
"""
Generates Rte_Type.h
Note: The last argument has been deprecated and is no longer in use
"""
if self.partition.isFinalized == False:
self.partition.finalize()
file_path = os.path.join(dest_dir, file_name)
with io.open(file_path, 'w', newline='\n') as fp:
hfile = C.hfile(file_name)
hfile.code.extend(
[C.line(x) for x in _genCommentHeader('Includes')])
hfile.code.append(C.include("Std_Types.h"))
hfile.code.append(C.blank())
(basicTypes, complexTypes,
modeTypes) = self.partition.types.getTypes()
hfile.code.extend([
C.line(x) for x in _genCommentHeader('Data Type Definitions')
])
hfile.code.append(C.blank())
ws = self.partition.ws
unusedDefaultTypes = self._findUnusedDefaultTypes(ws, basicTypes)
first = True
for ref in sorted(basicTypes) + sorted(complexTypes):
dataType = ws.find(ref)
if dataType is not None:
typedef = None
if first:
first = False
else:
hfile.code.append(C.blank())
hfile.code.append('#define Rte_TypeDef_%s' % dataType.name)
if isinstance(dataType, autosar.datatype.BooleanDataType):
typedef = C.typedef('boolean', dataType.name)
hfile.code.append(C.statement(typedef))
elif isinstance(dataType,
autosar.datatype.IntegerDataType):
valrange = dataType.maxVal - dataType.minVal
bitcount = valrange.bit_length()
typename = dataType.name
basetype = self._typename(bitcount, dataType.minVal)
typedef = C.typedef(basetype, typename)
hfile.code.append(C.statement(typedef))
isUnsigned = True if basetype in ('uint8', 'uint16',
'uint32') else False
if isUnsigned:
minval = str(dataType.minVal) + 'u'
maxval = str(dataType.maxVal) + 'u'
else:
minval = str(dataType.minVal)
maxval = str(dataType.maxVal)
hfile.code.append('#define %s_LowerLimit ((%s)%s)' %
(typename, typename, minval))
hfile.code.append('#define %s_UpperLimit ((%s)%s)' %
(typename, typename, maxval))
if dataType.compuMethodRef is not None:
compuMethod = ws.find(dataType.compuMethodRef)
if compuMethod is not None:
lines1 = []
lines2 = []
if isinstance(
compuMethod,
autosar.datatype.CompuMethodConst):
for elem in compuMethod.elements:
if isUnsigned:
value = str(elem.upperLimit) + 'u'
else:
value = str(elem.upperLimit)
lines1.append(
'#define RTE_CONST_%s (%s)' %
(elem.textValue, value))
lines2.append(
'#define %s ((%s)%s)' %
(elem.textValue, typename, value))
if len(lines2) > 0:
tmp = lines1 + [C.blank()] + lines2
else:
tmp = lines1
for line in tmp:
hfile.code.append(line)
else:
raise ValueError(dataType.compuMethodRef)
elif isinstance(dataType, autosar.datatype.RecordDataType):
body = C.block(innerIndent=innerIndentDefault)
for elem in dataType.elements:
childType = ws.find(elem.typeRef, role='DataType')
body.append(
C.statement(
C.variable(elem.name, childType.name)))
struct = C.struct(None, body, typedef=dataType.name)
hfile.code.append(C.statement(struct))
elif isinstance(dataType, autosar.datatype.StringDataType):
hfile.code.append('typedef uint8 %s[%d];' %
(dataType.name, dataType.length + 1))
elif isinstance(dataType, autosar.datatype.ArrayDataType):
childType = ws.find(dataType.typeRef, role='DataType')
if childType is None:
raise ValueError('invalid type reference: ' +
dataType.typeRef)
hfile.code.append(
'typedef %s %s[%d];' %
(childType.name, dataType.name, dataType.length))
elif isinstance(dataType, autosar.datatype.RealDataType):
if dataType.encoding == 'DOUBLE':
platform_typename = 'float64'
else:
platform_typename = 'float32'
hfile.code.append('typedef %s %s;' %
(platform_typename, dataType.name))
else:
raise NotImplementedError(type(dataType))
#sys.stderr.write('not implemented: %s\n'%str(type(dataType)))
else:
raise ValueError(ref)
if len(modeTypes) > 0:
lines = _genCommentHeader('Mode Types')
tmp = []
hfile.code.extend(lines)
first = True
for ref in modeTypes:
if first:
first = False
else:
tmp.append(C.blank())
modeType = ws.find(ref)
hfile.code.append(
C.statement(
C.typedef('uint8',
'Rte_ModeType_' + modeType.name)))
for i, elem in enumerate(modeType.modeDeclarations):
# define RTE_MODE_EcuM_Mode_POST_RUN ((Rte_ModeType_EcuM_Mode)0)
tmp.append(
C.define(
'RTE_MODE_%s_%s' % (modeType.name, elem.name),
'((Rte_ModeType_EcuM_Mode)%d)' % i))
hfile.code.append(C.blank())
hfile.code.extend(tmp)
if len(unusedDefaultTypes) > 0:
hfile.code.append(C.blank(2))
hfile.code.append(
C.line('#ifndef RTE_SUPPRESS_UNUSED_DATATYPES'))
for name in sorted(unusedDefaultTypes):
hfile.code.append(C.blank())
hfile.code.extend(self.defaultTypes[name])
hfile.code.append(C.blank())
hfile.code.append(C.line('#endif'))
fp.write('\n'.join(hfile.lines()))
fp.write('\n')
def type2arg(typeObj, pointer=False, name='data'):
return C.variable(name, typeObj.name, pointer=pointer)
