def _convert_function(function): result = list() if (converter_helper.lower_name(function.name) == 'main'): return_type = 'int' else: return_type = converter_helper.convert_type(c_lib._type_switcher, function.return_type) #parameter_declaration = '' #parameters = _convert_variable_list(function.parameters, areParams=True) #count = len(function.parameters) #parameter_declaration += '(' #for parameter in parameters: # parameter_declaration += parameter # count -= 1 # if (count > 1 ): # parameter_declaration += ',' #parameter_declaration += ')' #result.append(return_type + ' ' + converter_helper.lower_name(function.name) + parameter_declaration) result.append('{') if (converter_helper.lower_name(function.name) == 'main'): result.append('load_default_colors();') if (function.isFunction): result.append( converter_helper.convert_type(c_lib._type_switcher, function.return_type) + 'result;') result.extend(_convert_block( function.block, function.isFunction)) # return result will be added if isFunction result.append('}') return result
def _convert_function(function): result = list() if (converter_helper.lower_name(function.name) == 'main'): return_type = 'int' else: return_type = converter_helper.convert_type(c_lib._type_switcher, function.return_type) #parameter_declaration = '' #parameters = _convert_variable_list(function.parameters, areParams=True) #count = len(function.parameters) #parameter_declaration += '(' #for parameter in parameters: # parameter_declaration += parameter # count -= 1 # if (count > 1 ): # parameter_declaration += ',' #parameter_declaration += ')' #result.append(return_type + ' ' + converter_helper.lower_name(function.name) + parameter_declaration) result.append('{') if (converter_helper.lower_name(function.name) == 'main'): result.append('load_default_colors();') if (function.isFunction) : result.append(converter_helper.convert_type(c_lib._type_switcher, function.return_type) + 'result;') result.extend(_convert_block(function.block, function.isFunction)) # return result will be added if isFunction result.append('}') return result
def to_code(self): ''' This method creates the code to declare all it's variables for each of the modules ''' import converter_helper for param in self._vars: param.to_code() my_data = dict() # seperators need to be set for every new package # these could go in the __init__ for each library? my_data['c_lib_seperator'] = ',' my_data['pas_lib_seperator'] = ';' for (name, module) in converter_helper.converters.items(): parameters = "" for index in range(len(self._vars)): if self._vars[index].type.kind is 'array': parameters += module.convert_array_declaration( self._vars[index], is_parameter=True) else: var_data = dict() var_data['identifier'] = self._vars[index].code[ name + '_reference'] var_data['type'] = converter_helper.convert_type( module._type_switcher, self._vars[index].type, self._vars[index]._modifier) parameters += module.parameter_template % (var_data) if index < (len(self._vars) - 1): parameters += my_data[name + '_seperator'] self._code[name] = parameters
def to_code(self): ''' This method creates the code to declare all it's variables for each of the modules ''' import converter_helper for param in self._vars: param.to_code() my_data = dict() # seperators need to be set for every new package # these could go in the __init__ for each library? my_data['c_lib_seperator'] = ',' my_data['pas_lib_seperator'] = ';' for (name, module) in converter_helper.converters.items(): parameters = "" for index in range(len(self._vars)): if self._vars[index].type.kind is 'array': parameters += module.convert_array_declaration(self._vars[index], is_parameter=True) else: var_data = dict() var_data['identifier'] = self._vars[index].code[name + '_reference'] var_data['type'] = converter_helper.convert_type(module._type_switcher, self._vars[index].type, self._vars[index]._modifier) parameters += module.parameter_template % (var_data) if index < (len(self._vars)-1): parameters += my_data[name + '_seperator'] self._code[name] = parameters
def to_code(self): import converter_helper my_data = dict() my_data['pas_lib_identifier'] = self._name my_data['c_lib_identifier'] = converter_helper.lower_name(self._name) self._code['pas_lib_reference'] = "%s" % (self._name ) self._code['c_lib_reference'] = "%s" % ( converter_helper.lower_name(self._name )) for (name, module) in converter_helper.converters.items(): my_data[name + '_type'] = converter_helper.convert_type(module._type_switcher, self._type, None) self._code[name] = module.record_field_template % my_data
def convert_array_declaration(array, is_parameter): """ converts an array to a string describing the array """ from converter_helper import lower_name, convert_type var_name = lower_name(array.name) type_name = convert_type(_type_switcher, array.type.nested_type, None) if is_parameter: return type_name + ' *' + var_name else: result = type_name + var_name for dimension in array.type.dimensions: result += '[%s]' % dimension[1] return result + ';\n'
def convert_array_declaration(array, is_parameter): """ converts an array to a string describing the array """ from converter_helper import lower_name, convert_type var_name = array.name type_name = convert_type(_type_switcher, array.type.nested_type, None) if is_parameter: return '%s : array of %s' % (var_name, type_name ) else: str_dimensions = '[' for dimension in array.type.dimensions: str_dimensions += '%s..%s' % (dimension[0], dimension[1]) str_dimensions += ']' return '%s : array %s of %s;\n' % (var_name, str_dimensions, type_name )
def convert_array_declaration(array, is_parameter): """ converts an array to a string describing the array """ from converter_helper import lower_name, convert_type var_name = array.name type_name = convert_type(_type_switcher, array.type.nested_type, None) if is_parameter: return '%s : array of %s' % (var_name, type_name) else: str_dimensions = '[' for dimension in array.type.dimensions: str_dimensions += '%s..%s' % (dimension[0], dimension[1]) str_dimensions += ']' return '%s : array %s of %s;\n' % (var_name, str_dimensions, type_name)
def to_code(self): ''' Creates a _code entry for each of the converter modules ''' import converter_helper my_data = dict() my_data['pas_lib_identifier'] = self._name my_data['c_lib_identifier'] = converter_helper.lower_name(self._name) for (name, module) in converter_helper.converters.items(): # types need to be evaluated in the loop because they are module specific if self._type.kind is 'array': self._code[name] = module.convert_array_declaration( self, self._is_parameter) else: my_data[name + '_type'] = converter_helper.convert_type( module._type_switcher, self._type, self._modifier) self._code[name] = module.variable_template % my_data self._code[name + "_reference"] = my_data[name + "_identifier"]
def to_code(self, indentation): ''' This method creates the code to declare all it's variables for each of the modules ''' import converter_helper my_data = dict() my_data['pas_lib_identifier'] = self._name if (self._isFunction): my_data['pas_lib_type'] = self._return_type.name my_data['c_lib_identifier'] = converter_helper.lower_name(self._name) self._parameters.to_code() self._block.to_code(indentation) for (name, module) in converter_helper.converters.items(): # types need to be evaluated in the loop because they are module specific comments = '' code = """""" for current_line in self._comments: comments += module.comment_template % {"comment": current_line} my_data[name + '_comments'] = comments my_data[name + '_parameters'] = self._parameters.code[name] # if the function isn't a forward declaration then it doesn't have a block if (not self._is_forward): my_data[name + '_block'] = self._block.code[name] else: my_data[name + '_block'] = '' if (self._isFunction): my_data[name + '_type'] = converter_helper.convert_type( module._type_switcher, self._return_type) code = module.function_declaration_template % my_data else: code = module.procedure_declaration_template % my_data self._code[name] = converter_helper.apply_indents( code, indentation)
def to_code(self, indentation): ''' This method creates the code to declare all it's variables for each of the modules ''' import converter_helper my_data = dict() my_data['pas_lib_identifier'] = self._name if (self._isFunction): my_data['pas_lib_type'] = self._return_type.name my_data['c_lib_identifier'] = converter_helper.lower_name(self._name) self._parameters.to_code() self._block.to_code(indentation) for (name, module) in converter_helper.converters.items(): # types need to be evaluated in the loop because they are module specific comments = '' code = """""" for current_line in self._comments: comments += module.comment_template % { "comment" : current_line} my_data[name + '_comments'] = comments my_data[name + '_parameters'] = self._parameters.code[name] # if the function isn't a forward declaration then it doesn't have a block if (not self._is_forward): my_data[name + '_block'] = self._block.code[name] else: my_data[name + '_block'] = '' if (self._isFunction): my_data[name + '_type'] = converter_helper.convert_type(module._type_switcher, self._return_type) code = module.function_declaration_template % my_data else: code = module.procedure_declaration_template % my_data self._code[name] = converter_helper.apply_indents(code, indentation)