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)