def adapter_type_visitor(the_type, modifier = None):
'''switch types for the python SwinGame adapter (links to DLL)'''
name = None if the_type is None else the_type.name.lower()
if name not in _adapter_type_switcher[modifier]:
logger.error('CREATE : Error changing adapter type %s - %s', modifier, the_type)
return _adapter_type_switcher[modifier][name]
def std_type_visitor(the_dict,
the_type,
modifier=None,
dict_name='_type_switcher'):
'''
switch types for the SwinGame library.
Params:
- the_dict: The dictionary with the type changes with modifier keys
- the_type: The type being checked
- modifier: The modifier for the type
- dict_name: The name of the dictionary for error reporting
'''
key = the_type.name.lower() if the_type != None else None
if modifier == 'result': modifier = 'return'
if key not in the_dict[modifier]:
logger.error('HELPER : Error changing model type %s - %s', modifier,
the_type)
logger.error(' : Add \'%s[%s]\': \'%s\': \'????\',',
dict_name, modifier, the_type.name.lower())
global _hasError, _dieOnError
_hasError = True
if _dieOnError:
assert False
else:
the_dict[modifier][key] = "UNKNOWN"
return the_dict[modifier][key]
def map_data_value(the_dict, key, the_type, result):
'''
Returns the code needed to map the swingame (Pascal) data in result to
the type used by language X
Params:
- the_dict: The dictionary with the type changes with modifier keys
- key: The key to search for in the_dict
- the_type: The type being checked
- modifier: The modifier for the type
'''
if the_type.name.lower() in the_dict[key]:
# print the_type.name.lower(), ' -> ', the_dict[key][the_type.name.lower()]
return the_dict[key][the_type.name.lower()] % result
#If this is a
if the_type.pointer_wrapper and key == 'return_val':
logger.error(
'HELPER : Error pointer wrapper without return data mapping - %s',
the_type)
global _hasError, _dieOnError
_hasError = True
if _dieOnError:
assert False
else:
the_dict[key][the_type.name.lower()] = "UNKNOWN"
return result
def map_data_value(the_dict, key, the_type, result):
'''
Returns the code needed to map the swingame (Pascal) data in result to
the type used by language X
Params:
- the_dict: The dictionary with the type changes with modifier keys
- key: The key to search for in the_dict
- the_type: The type being checked
- modifier: The modifier for the type
'''
if the_type.name.lower() in the_dict[key]:
# print the_type.name.lower(), ' -> ', the_dict[key][the_type.name.lower()]
return the_dict[key][the_type.name.lower()] % result
#If this is a
if the_type.pointer_wrapper and key == 'return_val':
logger.error('HELPER : Error pointer wrapper without return data mapping - %s', the_type)
global _hasError, _dieOnError
_hasError = True
if _dieOnError:
assert False
else:
the_dict[key][the_type.name.lower()] = "UNKNOWN"
return result
def create_property_for_field(in_class, field):
'''Creates a property to access the '''
if field.data_type.wraps_array:
logger.error(
'HELPER : Error structure with array fields must be set to via_pointer'
)
global _hasError, _dieOnError
_hasError = True
if _dieOnError:
assert False
prop = SGProperty(field.name)
prop.in_class = in_class
prop.data_type = field.data_type
getter = SGMethod('get' + field.pascalName)
getter.return_type = field.data_type
getter.in_class = in_class
getter.field_name = field.name
getter.is_getter = True
setter = SGMethod('set' + field.pascalName)
setter.params.append(SGParameter('value'))
setter.params[0].data_type = field.data_type
setter.in_class = in_class
setter.field_name = field.name
setter.is_setter = True
prop.set_getter(getter)
prop.set_setter(setter)
return prop
def std_type_visitor(the_dict, the_type, modifier = None, dict_name = '_type_switcher'):
'''
switch types for the SwinGame library.
Params:
- the_dict: The dictionary with the type changes with modifier keys
- the_type: The type being checked
- modifier: The modifier for the type
- dict_name: The name of the dictionary for error reporting
'''
key = the_type.name.lower() if the_type != None else None
if modifier == 'result': modifier = 'return'
if key not in the_dict[modifier]:
logger.error('HELPER : Error changing model type %s - %s', modifier, the_type)
logger.error(' : Add \'%s[%s]\': \'%s\': \'????\',', dict_name, modifier, the_type.name.lower())
global _hasError, _dieOnError
_hasError = True
if _dieOnError:
assert False
else:
the_dict[modifier][key] = "UNKNOWN"
return the_dict[modifier][key]
def create_property_for_field(in_class, field):
'''Creates a property to access the '''
if field.data_type.wraps_array:
logger.error('HELPER : Error structure with array fields must be set to via_pointer')
global _hasError, _dieOnError
_hasError = True
if _dieOnError:
assert False
prop = SGProperty(field.name)
prop.in_class = in_class
prop.data_type = field.data_type
getter = SGMethod('get' + field.pascalName)
getter.return_type = field.data_type
getter.in_class = in_class
getter.field_name = field.name
getter.is_getter = True
setter = SGMethod('set' + field.pascalName)
setter.params.append(SGParameter('value'))
setter.params[0].data_type = field.data_type
setter.in_class = in_class
setter.field_name = field.name
setter.is_setter = True
prop.set_getter(getter)
prop.set_setter(setter)
return prop
def type_visitor(the_type, modifier = None):
'''switch types for the c SwinGame library'''
name = None if the_type is None else the_type.name.lower()
if name not in _type_switcher[modifier]:
logger.error('CREATE : Error changing model type %s - %s', modifier, the_type)
assert False
return _type_switcher[modifier][name]
def adapter_param_visitor(the_param, last):
name = the_param.name.lower()
if name not in _adapter_type_switcher[the_param.modifier]:
logger.error('CREATE : Error visiting adapter parameter %s - %s', the_param.modifier, the_param.data_type.name)
return 'XXX'
#assert False
return '%s%s' % (
_adapter_type_switcher[the_param.modifier][name] % the_param.name,
', ' if not last else '')
def _do_create_type_code(member):
'''Create the c code for the type member'''
assert member.is_class or member.is_struct or member.is_enum or member.is_type
member_data = member.lang_data['c']
if member.is_class or member.is_type or (member.is_struct
and member.wraps_array):
if member.is_pointer_wrapper: # convert to resource pointer
the_type = member.data_type
member_data.signature = 'typedef %s;\n' % c_code_for_adapter_type(
the_type, member.lower_name, 'ptr-decl')
elif member.is_data_wrapper: # alias of another type
assert len(member.fields) == 1
the_type = member.fields['data'].data_type
member_data.signature = 'typedef %s;\n' % c_code_for_adapter_type(
the_type, member.lower_name)
elif member.wraps_array:
assert len(member.fields) == 1
the_type = member.fields['data'].data_type
member_data.signature = 'typedef %s;\n' % c_code_for_adapter_type(
the_type, member.lower_name)
elif member.data_type.is_procedure:
assert member.data_type.method != None
#typedef float(*pt2Func)(float, float);
m = member.data_type.method
member_data.signature = 'typedef %s;\n' % c_code_for_adapter_type(
member.data_type, m.lower_name)
else:
logger.error('CREATE C : Unknown class type for %s', member.uname)
assert False
elif member.is_struct:
if member.same_as:
member_data.signature = 'typedef %s %s;\n' % (
member.same_as.lower_name, member.lower_name)
else:
#typedef struct %s_struct { } struct;
member_data.signature = 'typedef struct _%s { \n' % member.lower_name
#write the fields
for field in member.field_list:
member_data.signature += ' %s;\n' % c_code_for_adapter_type(
field.data_type, field.lower_name)
member_data.signature += '} %s;\n' % member.lower_name
elif member.is_enum:
#enum id { list }
member_data.signature = 'typedef enum { \n '
member_data.signature += ',\n '.join(
[wrapper_helper.upper_name(v) for v in member.values])
member_data.signature += '\n} %s;\n' % member.lower_name
def write_type_for(member, other):
'''Write out a type (class, struct, enum, typedef)'''
assert member.is_class or member.is_struct or member.is_enum or member.is_type
writer = other['writer']
# CLASS, TYPE, STRUCT(ARRAY)
if member.is_class or member.is_type or (member.is_struct and member.wraps_array):
#convert to resource pointer
if member.is_pointer_wrapper:
# assert len(member.fields) == 1
the_type = member.data_type
writer.writeln('typedef %s;\n' % adapter_type_visitor(the_type, None) % member.name)
elif member.is_data_wrapper:
assert len(member.fields) == 1
the_type = member.fields['data'].data_type
writer.writeln('typedef %s;\n' % adapter_type_visitor(the_type) % member.name)
elif member.wraps_array:
assert len(member.fields) == 1
the_type = member.fields['data'].data_type
writer.writeln('typedef %s;\n' % adapter_type_visitor(the_type) % member.name)
else:
logger.error('CREATE PYTHON : Unknown class type for %s', member.uname)
assert False
# PURE STRUCT
elif member.is_struct:
#class Point2D(Structure): # record/struct;
# _fields_ = [('x', c_float), (), ... ]
writer.writeln('class %s(Structure):' % member.name)
writer.writeln(" '''%s\n '''" % '\n '.join(member.doc.splitlines()))
writer.writeln(' _fields_ = [')
for field in member.field_list:
writer.writeln(' %s,' % adapter_type_visitor(field.data_type) % field.name)
writer.writeln(' ]\n')
# PURE ENUM
elif member.is_enum:
#enum id { list }
# basic -> (...) = map(c_int, range(length(...))
# class object FontAlignment.Left etc
#other['writer'].write(str(member) + str(dir(member)))
writer.writeln('class %s(object): # enum' % member.name)
writer.writeln(" '''%s\n '''" % '\n '.join(member.doc.splitlines()))
for i, v in enumerate(member.values):
if '=' in v:
v = v.replace(' = ', ' = c_int(') + ')' # use provided indicies
else:
v = v + ' = c_int(%d)' % i # need to add indicies
writer.writeln(' %s' % v)
writer.writeln('')
def _do_create_type_code(member):
'''Create the c code for the type member'''
assert member.is_class or member.is_struct or member.is_enum or member.is_type
member_data = member.lang_data['c']
if member.is_class or member.is_type or (member.is_struct and member.wraps_array):
if member.is_pointer_wrapper: # convert to resource pointer
the_type = member.data_type
member_data.signature = 'typedef %s;\n' % c_code_for_adapter_type(the_type, member.lower_name, 'ptr-decl')
elif member.is_data_wrapper: # alias of another type
assert len(member.fields) == 1
the_type = member.fields['data'].data_type
member_data.signature = 'typedef %s;\n' % c_code_for_adapter_type(the_type, member.lower_name)
elif member.wraps_array:
assert len(member.fields) == 1
the_type = member.fields['data'].data_type
member_data.signature = 'typedef %s;\n' % c_code_for_adapter_type(the_type, member.lower_name)
elif member.data_type.is_procedure:
assert member.data_type.method != None
#typedef float(*pt2Func)(float, float);
m = member.data_type.method
member_data.signature = 'typedef %s;\n' % c_code_for_adapter_type(member.data_type, m.lower_name)
else:
logger.error('CREATE C : Unknown class type for %s', member.uname)
assert False
elif member.is_struct:
if member.same_as:
member_data.signature = 'typedef %s %s;\n' % (member.same_as.lower_name, member.lower_name)
else:
#typedef struct %s_struct { } struct;
member_data.signature = 'typedef struct _%s { \n' % member.lower_name
#write the fields
for field in member.field_list:
member_data.signature += ' %s;\n' % c_code_for_adapter_type(field.data_type, field.lower_name)
member_data.signature += '} %s;\n' % member.lower_name
elif member.is_enum:
#enum id { list }
member_data.signature = 'typedef enum { \n '
member_data.signature += ',\n '.join([wrapper_helper.upper_name(v) for v in member.values])
member_data.signature += '\n} %s;\n' % member.lower_name
def _do_create_pas_library_code(method):
method_alias = method.alias('pas')
data = method_alias.to_keyed_dict(pas_library_param_visitor,
lang_key='pas')
if method_alias.was_function:
# Method returned a array of some kind... get the result params and change the 'return_type' in data
result_param = method_alias.params[-1]
if not result_param.maps_result: #in case of returning var length array
result_param = method_alias.params[-2]
if not result_param.maps_result or result_param.data_type.name.lower(
) not in [
'string', 'triangle', 'linesarray', 'matrix2d', 'point2darray',
'longintarray', 'stringarray', 'bitmaparray', 'trianglearray',
'fingerarray'
]:
logger.error('CREATE LIB: Unknown parameter return type in %s.',
method_alias.name)
assert False
lines = pas_lib.function_as_procedure_txt
#? is this needed: data['return_type'] = result_param.data_type.name
elif method_alias.return_type == None:
lines = pas_lib.procedure_txt
else:
lines = pas_lib.function_txt
if len(method_alias.local_vars) > 0:
var_dec = '\n var\n'
temp_process_result = ''
temp_process_params = ''
for local_var in method_alias.local_vars:
# Add declaration of variable
var_dec += ' %s: %s;\n' % (local_var.name, local_var.data_type)
# Add variable processing code...
type_name = local_var.data_type.name.lower()
if type_name == 'string':
# Copy strings out - they are passed through using Pascal implicit casting from PChar to String
temp_process_result += '\n StrCopy(%s, PChar(%s));' % (
local_var.local_for.name, local_var.name)
#? elif type_name == 'color':
# temp_process_result += '\n %s := %s;' % (local_var.name[:-5], local_var.name)
# elif type_name in _array_copy_fixed_data: #needed for mapped result parameters
# if local_var.modifier in [None, 'var', 'const'] and not local_var.maps_result:
# temp_process_params += '\n %sCopyFromPtr(%s, %s);' % (_array_copy_fixed_data[type_name], local_var.name, local_var.name[:-5])
# if local_var.modifier in [None, 'var', 'out'] or local_var.maps_result:
# temp_process_result += '\n %sCopyToPtr(%s, %s);' % (_array_copy_fixed_data[type_name], local_var.name[:-5], local_var.name)
elif type_name in _array_copy_data:
if local_var.modifier in [None, 'var', 'const'
] and not local_var.maps_result:
temp_process_params += '\n %sCopyFromPtr(%s, %s_len, %s);' % (
_array_copy_data[type_name], local_var.name[:-5],
local_var.name[:-5], local_var.name)
if local_var.modifier in [None, 'var', 'out'
] or local_var.maps_result:
temp_process_result += '\n %sCopyToPtr(%s, %s_len, %s);' % (
_array_copy_data[type_name], local_var.name,
local_var.name[:-5], local_var.name[:-5])
else:
logger.error('CREATE LIB: Unknow local variable type in %s',
method_alias.name)
assert False
data['vars'] = var_dec[:-1]
data['process_result'] = temp_process_result
data['process_params'] = temp_process_params
else:
data['vars'] = ''
data['process_result'] = ''
data['process_params'] = ''
_names.append(method_alias.name)
method_alias.code = (''.join(lines) + '\n') % data
def _do_create_pas_library_code(method):
method_alias = method.alias('pas')
data = method_alias.to_keyed_dict(pas_library_param_visitor, lang_key='pas')
if method_alias.was_function:
# Method returned a array of some kind... get the result params and change the 'return_type' in data
result_param = method_alias.params[-1]
if not result_param.maps_result: #in case of returning var length array
result_param = method_alias.params[-2]
if not result_param.maps_result or result_param.data_type.name.lower() not in ['string', 'triangle', 'linesarray', 'matrix2d', 'point2darray', 'longintarray','stringarray','bitmaparray','trianglearray','fingerarray']:
logger.error('CREATE LIB: Unknown parameter return type in %s.', method_alias.name)
assert False
lines = pas_lib.function_as_procedure_txt
#? is this needed: data['return_type'] = result_param.data_type.name
elif method_alias.return_type == None:
lines = pas_lib.procedure_txt
else:
lines = pas_lib.function_txt
if len(method_alias.local_vars) > 0:
var_dec = '\n var\n'
temp_process_result = ''
temp_process_params = ''
for local_var in method_alias.local_vars:
# Add declaration of variable
var_dec += ' %s: %s;\n' % (local_var.name, local_var.data_type)
# Add variable processing code...
type_name = local_var.data_type.name.lower()
if type_name == 'string':
# Copy strings out - they are passed through using Pascal implicit casting from PChar to String
temp_process_result += '\n StrCopy(%s, PChar(%s));' % (local_var.local_for.name, local_var.name)
#? elif type_name == 'color':
# temp_process_result += '\n %s := %s;' % (local_var.name[:-5], local_var.name)
# elif type_name in _array_copy_fixed_data: #needed for mapped result parameters
# if local_var.modifier in [None, 'var', 'const'] and not local_var.maps_result:
# temp_process_params += '\n %sCopyFromPtr(%s, %s);' % (_array_copy_fixed_data[type_name], local_var.name, local_var.name[:-5])
# if local_var.modifier in [None, 'var', 'out'] or local_var.maps_result:
# temp_process_result += '\n %sCopyToPtr(%s, %s);' % (_array_copy_fixed_data[type_name], local_var.name[:-5], local_var.name)
elif type_name in _array_copy_data:
if local_var.modifier in [None, 'var', 'const'] and not local_var.maps_result:
temp_process_params += '\n %sCopyFromPtr(%s, %s_len, %s);' % (_array_copy_data[type_name], local_var.name[:-5], local_var.name[:-5],local_var.name)
if local_var.modifier in [None, 'var', 'out'] or local_var.maps_result:
temp_process_result += '\n %sCopyToPtr(%s, %s_len, %s);' % (_array_copy_data[type_name],local_var.name, local_var.name[:-5], local_var.name[:-5])
else:
logger.error('CREATE LIB: Unknow local variable type in %s', method_alias.name)
assert False
data['vars'] = var_dec[:-1]
data['process_result'] = temp_process_result
data['process_params'] = temp_process_params
else:
data['vars'] = ''
data['process_result'] = ''
data['process_params'] = ''
_names.append(method_alias.name)
method_alias.code = (''.join(lines) + '\n') % data
