def get_c_function(self):
template1A = r"""// Callback function for {function_name_comment} callback
"""
template1B = r"""{override_comment}
"""
template2 = r"""void cb_{function_name_under}({parameters}void *user_data) {{
{unuseds}
{printfs}{extra_message}
}}
"""
override_comment = self.get_formatted_override_comment(
'// {0}', None, '\n// ')
if override_comment == None:
template1 = template1A
else:
template1 = template1B
parameters = []
unuseds = []
printfs = []
for parameter in self.get_parameters():
parameters.append(parameter.get_c_source())
unuseds += parameter.get_c_unuseds()
printfs += parameter.get_c_printfs()
while None in unuseds:
unuseds.remove(None)
unuseds.append('(void)user_data;')
unuseds = common.wrap_non_empty('', '<BP>'.join(unuseds),
' // avoid unused parameter warning')
unuseds = common.break_string(unuseds, '').replace('\n', '\n\t')
while None in printfs:
printfs.remove(None)
if len(printfs) > 1:
printfs.append('\tprintf("\\n");')
extra_message = self.get_formatted_extra_message(
'\tprintf("{0}\\n");').replace('%', '%%')
if len(extra_message) > 0 and len(printfs) > 0:
extra_message = '\n' + extra_message
result = template1.format(function_name_comment=self.get_comment_name(),
override_comment=override_comment) + \
template2.format(function_name_under=self.get_name().under,
parameters=common.wrap_non_empty('', ',<BP>'.join(parameters), ',<BP>'),
unuseds=unuseds,
printfs='\n'.join(printfs).replace('\r\n\r', '\n\n').strip('\r').replace('\r', '\n'),
extra_message=extra_message)
return common.break_string(result,
'cb_{}('.format(self.get_name().under))
def get_c_source(self):
template = r"""{global_line_prefix} // Get current {packet_comment}
{global_line_prefix}{variable_declarations};
{global_line_prefix} check(tf_{device_under}_{packet_under}(&{device_initial}{arguments}{variable_references}), "get {packet_comment}");
{printfs}
"""
variable_declarations = []
variable_references = []
printfs = []
for result in self.get_results():
variable_declarations.append(result.get_c_variable_declaration())
variable_references.append(result.get_c_variable_reference())
printfs += result.get_c_printfs()
arg_declarations, arguments = self.get_c_arguments()
variable_declarations += arg_declarations
merged_variable_declarations = []
for variable_declaration in variable_declarations:
merged = False
for merged_variable_declaration in merged_variable_declarations:
if merged_variable_declaration[0] == variable_declaration[0]:
merged_variable_declaration[1].append(variable_declaration[1])
merged = True
break
if not merged:
merged_variable_declarations.append([variable_declaration[0], [variable_declaration[1]]])
variable_declarations = []
for merged_variable_declaration in merged_variable_declarations:
variable_declarations.append('{0} {1}'.format(merged_variable_declaration[0],
',<BP>'.join(merged_variable_declaration[1])))
variable_declarations = common.break_string('\t' + ';<BP>'.join(variable_declarations),
merged_variable_declarations[0][0] + ' ')
variable_declarations = re.sub(';\n\t([ ]+)', ';\n\t', variable_declarations, flags=re.MULTILINE)
while None in printfs:
printfs.remove(None)
result = format(template, self.get_device(), self,
global_line_prefix=global_line_prefix,
variable_declarations=variable_declarations,
variable_references=',<BP>' + ',<BP>'.join(variable_references),
printfs='\n'.join(printfs).replace('\r\n\r', '\n\n').strip('\r').replace('\r', '\n'),
arguments=common.wrap_non_empty(',<BP>', ',<BP>'.join(arguments), ''))
return common.break_string(result, '_{}('.format(self.get_name().under))
def get_vbnet_source(self):
template1 = r""" ' Register {function_name_comment}<BP>callback<BP>to<BP>subroutine<BP>{function_name_camel}CB
"""
template2 = r""" AddHandler {device_name}.{function_name_camel}Callback,<BP>AddressOf {function_name_camel}CB
"""
result1 = template1.format(
function_name_camel=self.get_name().camel,
function_name_comment=self.get_comment_name())
result2 = template2.format(
device_name=self.get_device().get_initial_name(),
function_name_camel=self.get_name().camel)
return common.break_string(result1, "' ", indent_tail="' ") + \
common.break_string(result2, 'AddHandler ', continuation=' _')
def get_rust_source(self):
template = '{comment1}{global_line_prefix}\t\t{device_name_initials}.{function_name}({arguments}){propagate_errors};{comment2}\n'
has_high_level = [
packet
for packet in self.get_device().get_packets(type_='function')
if (packet.get_name().under == self.get_name().under) or
(len(packet.get_name().under.split("_")) > 2 and packet.get_name(
skip=-2).under == self.get_name().under)
][0].has_high_level()
result = template.format(
global_line_prefix=global_line_prefix,
device_name_under=self.get_device().get_name().under,
device_name_initials=self.get_device().get_initial_name(),
device_category_under=self.get_device().get_category().under,
function_name=self.get_name().under,
arguments=',<BP>'.join(self.get_rust_arguments()),
propagate_errors='?' if has_high_level else '.recv()?',
comment1=self.get_formatted_comment1(
global_line_prefix + '\t\t// {0}\n', '\r',
'\n' + global_line_prefix + '\t\t// '),
comment2=self.get_formatted_comment2(' // {0}', ''))
return common.break_string(result,
'{}('.format(self.get_name().camel_abbrv))
def get_perl_source(self):
template = r"""{global_line_prefix}# Get current {function_name_comment}
{global_line_prefix}{variables} = ${device_name}->{function_name_under}({arguments});
{prints}
"""
variables = []
prints = []
for result in self.get_results():
variables.append(result.get_perl_variable())
prints += result.get_perl_prints()
if len(variables) > 1:
variables = common.break_string(
'my (' + ',<BP>'.join(variables) + ')', 'my (')
else:
variables = 'my ' + variables[0]
while None in prints:
prints.remove(None)
if len(prints) > 1:
prints.insert(0, '\b')
return template.format(
global_line_prefix=global_line_prefix,
device_name=self.get_device().get_initial_name(),
function_name_under=self.get_name().under,
function_name_comment=self.get_comment_name(),
variables=variables,
prints='\n'.join(prints).replace('\b\n\r', '\n').replace(
'\b', '').replace('\r\n\r',
'\n\n').rstrip('\r').replace('\r', '\n'),
arguments=', '.join(self.get_perl_arguments()))
def get_c_source(self):
template = '{comment1}{declarations}{global_line_prefix}\tcheck(tf_{device_under}_{packet_under}(&{device_initial}{arguments}), "call {packet_under}");{comment2}\n'
arg_declarations, arguments = self.get_c_arguments()
declarations = common.wrap_non_empty(
'', '\n'.join([
'{global_line_prefix}\t{decl}'.format(
global_line_prefix=global_line_prefix, decl=decl)
for decl in arg_declarations
]), '\n')
result = format(template,
self.get_device(),
self,
global_line_prefix=global_line_prefix,
declarations=declarations,
arguments=common.wrap_non_empty(
',<BP>', ',<BP>'.join(arguments), ''),
comment1=self.get_formatted_comment1(
global_line_prefix + '\t// {0}\n', '\r',
'\n' + global_line_prefix + '\t// '),
comment2=self.get_formatted_comment2(' // {0}', ''))
return common.break_string(result,
'_{}('.format(self.get_name().under))
def get_go_source(self):
template = r"""{global_line_prefix} // Get current {function_name_comment}.
{global_line_prefix}{result_name}, _ := {device_name_initials}.{function_name_camel}({arguments})
{write_lines}
"""
result_name = self.get_go_result_prefix()
write_lines = []
for result in self.get_results():
write_lines += result.get_go_write_lines()
while None in write_lines:
write_lines.remove(None)
if len(write_lines) > 1:
write_lines.insert(0, '\b')
arguments = self.get_go_arguments()
result = template.format(
device_name_under=self.get_device().get_name().camel,
device_name_initials=self.get_device().get_initial_name(),
device_category_under=self.get_device().get_category().camel,
result_name=result_name,
function_name_camel=self.get_name().camel,
function_name_comment=self.get_comment_name(),
write_lines='\n'.join(write_lines).replace('\b\n\r', '\n').replace(
'\b', '').replace('\r\n\r',
'\n\n').rstrip('\r').replace('\r', '\n'),
arguments=',<BP>'.join(arguments),
global_line_prefix=global_line_prefix)
return common.break_string(result, '{}('.format(self.get_name().camel))
def get_go_source(self):
template = r"""{device_name_initials}.Register{function_name_camel}Callback(func({params}) {{
{write_lines}{extra_message}
}})
"""
write_lines = []
params = []
packet = [packet for packet in self.get_device().get_packets(type_='callback') if (packet.get_name().under == self.get_name().under) or (len(packet.get_name().under.split("_")) > 2 and packet.get_name(skip=-2).under == self.get_name().under)][0]
for parameter in self.get_parameters():
params.append(parameter.get_go_source())
write_lines += parameter.get_go_write_lines()
while None in write_lines:
write_lines.remove(None)
if len(write_lines) > 1:
write_lines.append('\t\tfmt.Println();')
extra_message = self.get_formatted_extra_message('\t\tfmt.Println("{0}");')
if len(extra_message) > 0 and len(write_lines) > 0:
extra_message = '\n' + extra_message
result = template.format(device_name_initials=self.get_device().get_initial_name(),
params=", ".join(params),
function_name_camel=self.get_name().camel,
function_name_comment=self.get_comment_name(),
write_lines='\n'.join(write_lines).replace('\r\n\r', '\n\n').strip('\r').replace('\r', '\n'),
extra_message=extra_message)
return common.break_string(result, '// ', indent_tail='// ')
def get_python_source(self):
template = r"""{global_line_prefix} # Get current {function_name_comment}
{global_line_prefix} {variables} = {device_name}.{function_name_under}({arguments})
{prints}
"""
variables = []
prints = []
for result in self.get_results():
variables.append(result.get_python_variable())
prints += result.get_python_prints()
while None in prints:
prints.remove(None)
if len(prints) > 1:
prints.insert(0, '\b')
result = template.format(
global_line_prefix=global_line_prefix,
device_name=self.get_device().get_initial_name(),
function_name_under=self.get_name().under,
function_name_comment=self.get_comment_name(),
variables=',<BP>'.join(variables),
prints='\n'.join(prints).replace('\b\n\r', '\n').replace(
'\b', '').replace('\r\n\r',
'\n\n').rstrip('\r').replace('\r', '\n'),
arguments=', '.join(self.get_python_arguments()))
return common.break_string(result,
' ',
continuation=' \\',
indent_suffix=' ')
def get_python_source(self):
template1 = r""" # Register {function_name_comment}<BP>callback<BP>to<BP>function<BP>cb_{function_name_under}
"""
template2 = r""" {device_name}.register_callback({device_name}.CALLBACK_{function_name_upper},<BP>cb_{function_name_under})
"""
result1 = template1.format(
function_name_under=self.get_name().under,
function_name_comment=self.get_comment_name())
result2 = template2.format(
device_name=self.get_device().get_initial_name(),
function_name_under=self.get_name().under,
function_name_upper=self.get_name().upper)
return common.break_string(result1, '# ', indent_tail='# ') + \
common.break_string(result2, 'register_callback(')
def get_javascript_function(self):
template1 = r"""// Register {function_name_comment} callback
{device_name_initial}.on(Tinkerforge.{device_category}{device_name_camel}.CALLBACK_{function_name_upper},
"""
template2A = r""" // Callback function for {function_name_comment} callback
"""
template2B = r"""{override_comment}
"""
template3 = r""" function ({parameters}) {{
{outputs}{extra_message}{global_callback_output_suffix}
}}
);
"""
override_comment = self.get_formatted_override_comment(
' // {0}', None, '\n // ')
if override_comment == None:
template2 = template2A
else:
template2 = template2B
parameters = []
outputs = []
for parameter in self.get_parameters():
parameters.append(parameter.get_javascript_source())
outputs += parameter.get_javascript_outputs()
while None in outputs:
outputs.remove(None)
if len(outputs) > 1:
outputs.append(
" {global_output_prefix}'\xFE'{global_output_suffix};".
format(global_output_prefix=global_output_prefix,
global_output_suffix=global_output_suffix))
extra_message = self.get_formatted_extra_message(
" {global_output_prefix}'{{0}}\xFE'{global_output_suffix};".
format(global_output_prefix=global_output_prefix,
global_output_suffix=global_output_suffix))
if len(extra_message) > 0 and len(outputs) > 0:
extra_message = '\n' + extra_message
result = template1.format(device_category=self.get_device().get_category().camel,
device_name_camel=self.get_device().get_name().camel,
device_name_initial=self.get_device().get_initial_name(),
function_name_upper=self.get_name().upper,
function_name_comment=self.get_comment_name()) + \
template2.format(function_name_comment=self.get_comment_name(),
override_comment=override_comment) + \
template3.format(global_callback_output_suffix=global_callback_output_suffix,
parameters=',<BP>'.join(parameters),
outputs='\n'.join(outputs).replace('\r\n\r', '\n\n').strip('\r').replace('\r', '\n'),
extra_message=extra_message).replace("\xFE' + '", '').replace("\xFE", '')
return common.break_string(result, 'function (')
def get_php_source(self):
template1 = r"""// Register {function_name_comment}<BP>callback<BP>to<BP>function<BP>cb_{function_name_headless}
"""
template2 = r"""${device_name_initial}->registerCallback({device_category}{device_name_camel}::CALLBACK_{function_name_upper},<BP>'cb_{function_name_headless}');
"""
result1 = template1.format(
function_name_headless=self.get_name().headless,
function_name_comment=self.get_comment_name())
result2 = template2.format(
device_category=self.get_device().get_category().camel,
device_name_camel=self.get_device().get_name().camel,
device_name_initial=self.get_device().get_initial_name(),
function_name_headless=self.get_name().headless,
function_name_upper=self.get_name().upper)
return common.break_string(result1, '// ', indent_tail='// ') + \
common.break_string(result2, '->registerCallback(')
def get_csharp_source(self):
template = r""" // Register {function_name_comment}<BP>callback<BP>to<BP>function<BP>{function_name_camel}CB
{device_name}.{function_name_camel}Callback += {function_name_camel}CB;
"""
result = template.format(device_name=self.get_device().get_initial_name(),
function_name_camel=self.get_name().camel,
function_name_comment=self.get_comment_name())
return common.break_string(result, '// ', indent_tail='// ')
def get_c_source(self):
template = r""" // Register {packet_comment}<BP>callback<BP>to<BP>function<BP>{packet_under}_handler
tf_{device_under}_register_{packet_under}_callback(&{device_initial},
{spaces}{packet_under}_handler,
{spaces}NULL);
"""
result = format(template, self.get_device(), self,
spaces=' ' * (len(self.get_device().get_name().under) + len(self.get_name().under) + 23))
return common.break_string(result, '// ', indent_tail='// ')
def get_csharp_source(self):
template = '{comment1}{global_line_prefix}\t\t{device_name}.{function_name}({arguments});{comment2}\n'
result = template.format(global_line_prefix=global_line_prefix,
device_name=self.get_device().get_initial_name(),
function_name=self.get_name().camel,
arguments=',<BP>'.join(self.get_csharp_arguments()),
comment1=self.get_formatted_comment1(global_line_prefix + '\t\t// {0}\n', '\r', '\n' + global_line_prefix + '\t\t// '),
comment2=self.get_formatted_comment2(' // {0}', ''))
return common.break_string(result, '{}('.format(self.get_name().camel))
def get_matlab_source(self):
template = '{comment1}{global_line_prefix} {device_name}.{function_name}({arguments});{comment2}\n'
result = template.format(global_line_prefix=global_line_prefix,
device_name=self.get_device().get_initial_name(),
function_name=self.get_name().headless,
arguments=',<BP>'.join(self.get_matlab_arguments()),
comment1=self.get_formatted_comment1(global_line_prefix + ' % {0}\n', '\r', '\n' + global_line_prefix + ' % '),
comment2=self.get_formatted_comment2(' % {0}', ''))
return common.break_string(result, '.{}('.format(self.get_name().headless), continuation=' ...')
def get_delphi_source(self):
template = r""" {{ Register {function_name_comment}<BP>callback<BP>to<BP>procedure<BP>{function_name_camel}CB }}
{device_name}.On{function_name_camel} := {{$ifdef FPC}}@{{$endif}}{function_name_camel}CB;
"""
result = template.format(
device_name=self.get_device().get_initial_name(),
function_name_camel=self.get_name().camel,
function_name_comment=self.get_comment_name())
return common.break_string(result, '{ ')
def get_matlab_source(self):
template1 = r""" % Register {function_name_comment}<BP>callback<BP>to<BP>function<BP>cb_{function_name_under}
"""
template2A = r""" set({device_name}, '{function_name_camel}Callback',<BP>@(h, e) cb_{function_name_under}(e));
"""
template2B = r""" {device_name}.add{function_name_camel}Callback(@cb_{function_name_under});
"""
if not global_is_octave:
template2 = template2A
else:
template2 = template2B
result1 = template1.format(function_name_under=self.get_name().under,
function_name_comment=self.get_comment_name())
result2 = template2.format(device_name=self.get_device().get_initial_name(),
function_name_under=self.get_name().under,
function_name_camel=self.get_name().camel)
return common.break_string(result1, '% ', indent_tail='% ') + \
common.break_string(result2, 'set(',)
def get_java_source(self):
template1A = r""" // Add {function_name_comment} listener
"""
template1B = r"""{override_comment}
"""
template2 = r""" {device_name_initial}.add{function_name_camel}Listener(new {device_category}{device_name_camel}.{function_name_camel}Listener() {{
public void {function_name_headless}({parameters}) {{
{printlns}{extra_message}
}}
}});
"""
override_comment = self.get_formatted_override_comment(
'\t\t// {0}', None, '\n\t\t// ')
if override_comment == None:
template1 = template1A
else:
template1 = template1B
parameters = []
printlns = []
for parameter in self.get_parameters():
parameters.append(parameter.get_java_source())
printlns += parameter.get_java_printlns()
while None in printlns:
printlns.remove(None)
if len(printlns) > 1:
printlns.append('\t\t\t\tSystem.out.println("");')
extra_message = self.get_formatted_extra_message(
'\t\t\t\tSystem.out.println("{0}");')
if len(extra_message) > 0 and len(printlns) > 0:
extra_message = '\n' + extra_message
result = template1.format(function_name_comment=self.get_comment_name(),
override_comment=override_comment) + \
template2.format(device_category=self.get_device().get_category().camel,
device_name_camel=self.get_device().get_name().camel,
device_name_initial=self.get_device().get_initial_name(),
function_name_camel=self.get_name().camel,
function_name_headless=self.get_name().headless,
parameters=',<BP>'.join(parameters),
printlns='\n'.join(printlns).replace('\r\n\r', '\n\n').strip('\r').replace('\r', '\n'),
extra_message=extra_message)
return common.break_string(result,
'{}('.format(self.get_name().headless))
def get_ruby_source(self):
template = r"""{global_line_prefix}# Get current {function_name_comment}{array_content}
{global_line_prefix}{variables} = {device_name}.{function_name_under}{arguments}
{puts}
"""
comments = []
variables = []
puts = []
for result in self.get_results():
variables.append(result.get_ruby_variable())
puts += result.get_ruby_puts()
if len(variables) > 1:
array_content = ' as [{0}]'.format(',<BP>'.join(
[variable.rstrip('_') for variable in variables]))
variables = [self.get_name(skip=1).under]
else:
array_content = ''
while None in puts:
puts.remove(None)
if len(puts) > 1:
puts.insert(0, '\b')
arguments = common.wrap_non_empty(' ',
', '.join(self.get_ruby_arguments()),
'')
if arguments.strip().startswith('('):
arguments = '({0})'.format(arguments.strip())
result = template.format(
global_line_prefix=global_line_prefix,
device_name=self.get_device().get_initial_name(),
function_name_under=self.get_name().under,
function_name_comment=self.get_comment_name(),
array_content=array_content,
variables=', '.join(variables),
puts='\n'.join(puts).replace('\b\n\r', '\n').replace(
'\b', '').replace('\r\n\r',
'\n\n').rstrip('\r').replace('\r', '\n'),
arguments=arguments)
return common.break_string(result,
'# Get current {0} as ['.format(
self.get_comment_name()),
indent_head='#')
def get_delphi_source(self):
template = '{comment1}{global_line_prefix} {device_name}.{function_name}{arguments};{comment2}\n'
result = template.format(
global_line_prefix=global_line_prefix,
device_name=self.get_device().get_initial_name(),
function_name=self.get_name().camel,
arguments=common.wrap_non_empty(
'(', ',<BP>'.join(self.get_delphi_arguments()), ')'),
comment1=self.get_formatted_comment1(
global_line_prefix + ' {{ {0} }}\n', '\r',
'\n' + global_line_prefix + ' '),
comment2=self.get_formatted_comment2(' {{ {0} }}', ''))
return common.break_string(result, '{}('.format(self.get_name().camel))
def get_python_source(self):
template = '{comment1}{global_line_prefix} {device_name}.{function_name}({arguments}){comment2}\n'
result = template.format(
global_line_prefix=global_line_prefix,
device_name=self.get_device().get_initial_name(),
function_name=self.get_name().under,
arguments=',<BP>'.join(self.get_python_arguments()),
comment1=self.get_formatted_comment1(
global_line_prefix + ' # {0}\n', '\r',
'\n' + global_line_prefix + ' # '),
comment2=self.get_formatted_comment2(' # {0}', ''))
return common.break_string(result,
'.{0}('.format(self.get_name().under))
def get_vbnet_subroutine(self):
template1A = r""" ' Callback subroutine for {function_name_comment} callback
"""
template1B = r"""{override_comment}
"""
template2 = r""" Sub {function_name_camel}CB(ByVal sender As {device_category}{device_name}{parameters})
{write_lines}{extra_message}
End Sub
"""
override_comment = self.get_formatted_override_comment(
" ' {0}", None, "\n ' ")
if override_comment == None:
template1 = template1A
else:
template1 = template1B
parameters = []
write_lines = []
for parameter in self.get_parameters():
parameters.append(parameter.get_vbnet_source())
write_lines += parameter.get_vbnet_write_lines()
while None in write_lines:
write_lines.remove(None)
if len(write_lines) > 1:
write_lines.append(' Console.WriteLine("")')
extra_message = self.get_formatted_extra_message(
' Console.WriteLine("{0}")')
if len(extra_message) > 0 and len(write_lines) > 0:
extra_message = '\n' + extra_message
result = template1.format(function_name_comment=self.get_comment_name(),
override_comment=override_comment) + \
template2.format(device_category=self.get_device().get_category().camel,
device_name=self.get_device().get_name().camel,
function_name_camel=self.get_name().camel,
parameters=common.wrap_non_empty(',<BP>', ',<BP>'.join(parameters), ''),
write_lines='\n'.join(write_lines).replace('\r\n\r', '\n\n').strip('\r').replace('\r', '\n'),
extra_message=extra_message)
return common.break_string(result,
'{}CB('.format(self.get_name().camel),
continuation=' _')
def get_csharp_function(self):
template1A = r""" // Callback function for {function_name_comment} callback
"""
template1B = r"""{override_comment}
"""
template2 = r""" static void {function_name_camel}CB({device_category}{device_name} sender{parameters})
{{
{write_lines}{extra_message}
}}
"""
override_comment = self.get_formatted_override_comment(
'\t// {0}', None, '\n\t// ')
if override_comment == None:
template1 = template1A
else:
template1 = template1B
parameters = []
write_lines = []
for parameter in self.get_parameters():
parameters.append(parameter.get_csharp_source())
write_lines += parameter.get_csharp_write_lines()
while None in write_lines:
write_lines.remove(None)
if len(write_lines) > 1:
write_lines.append('\t\tConsole.WriteLine("");')
extra_message = self.get_formatted_extra_message(
'\t\tConsole.WriteLine("{0}");')
if len(extra_message) > 0 and len(write_lines) > 0:
extra_message = '\n' + extra_message
result = template1.format(function_name_comment=self.get_comment_name(),
override_comment=override_comment) + \
template2.format(device_category=self.get_device().get_category().camel,
device_name=self.get_device().get_name().camel,
function_name_camel=self.get_name().camel,
parameters=common.wrap_non_empty(',<BP>', ',<BP>'.join(parameters), ''),
write_lines='\n'.join(write_lines).replace('\r\n\r', '\n\n').strip('\r').replace('\r', '\n'),
extra_message=extra_message)
return common.break_string(result,
'{}CB('.format(self.get_name().camel))
def get_vbnet_source(self):
template = '{comment1}{global_line_prefix} {device_name}.{function_name}({arguments}){comment2}\n'
result = template.format(
global_line_prefix=global_line_prefix,
device_name=self.get_device().get_initial_name(),
function_name=self.get_name().camel,
arguments=',<BP>'.join(self.get_vbnet_arguments()),
comment1=self.get_formatted_comment1(
global_line_prefix + " ' {0}\n", '\r',
"\n" + global_line_prefix + " ' "),
comment2=self.get_formatted_comment2(" ' {0}", ''))
return common.break_string(result,
'.{}('.format(self.get_name().camel),
continuation=' _')
def get_delphi_prototype(self):
template = ' procedure {function_name}CB(sender: T{device_category}{device_name}{parameters});'
parameters = []
for parameter in self.get_parameters():
parameters.append(parameter.get_delphi_source())
result = template.format(
device_category=self.get_device().get_category().camel,
device_name=self.get_device().get_name().camel,
function_name=self.get_name().camel,
parameters=common.wrap_non_empty(';<BP>', ';<BP>'.join(parameters),
''))
return common.break_string(result,
'{}CB('.format(self.get_name().camel))
def get_ruby_source(self):
template1A = r"""# Register {function_name_comment} callback
"""
template1B = r"""{override_comment}
"""
template2 = r"""{device_name_initial}.register_callback({device_category}{device_name_camel}::CALLBACK_{function_name_upper}) do{parameters}
{puts}{extra_message}
end
"""
override_comment = self.get_formatted_override_comment(
'# {0}', None, '\n# ')
if override_comment == None:
template1 = template1A
else:
template1 = template1B
parameters = []
puts = []
for parameter in self.get_parameters():
parameters.append(parameter.get_ruby_source())
puts += parameter.get_ruby_puts()
while None in puts:
puts.remove(None)
if len(puts) > 1:
puts.append(" puts ''")
extra_message = self.get_formatted_extra_message(" puts '{0}'")
if len(extra_message) > 0 and len(puts) > 0:
extra_message = '\n' + extra_message
result = template1.format(function_name_comment=self.get_comment_name(),
override_comment=override_comment) + \
template2.format(device_category=self.get_device().get_category().camel,
device_name_camel=self.get_device().get_name().camel,
device_name_initial=self.get_device().get_initial_name(),
function_name_under=self.get_name().under,
function_name_upper=self.get_name().upper,
parameters=common.wrap_non_empty(' |', ',<BP>'.join(parameters), '|'),
puts='\n'.join(puts).replace('\r\n\r', '\n\n').strip('\r').replace('\r', '\n'),
extra_message=extra_message)
return common.break_string(result, ') do |')
def get_delphi_procedure(self):
template1A = r"""{{ Callback procedure for {function_name_comment} callback }}
"""
template1B = r"""{override_comment}
"""
template2 = r"""procedure TExample.{function_name_camel}CB(sender: T{device_category}{device_name}{parameters});
begin
{write_lns}{extra_message}
end;
"""
override_comment = self.get_formatted_override_comment(
'{{ {0} }}', None, '\n ')
if override_comment == None:
template1 = template1A
else:
template1 = template1B
parameters = []
write_lns = []
for parameter in self.get_parameters():
parameters.append(parameter.get_delphi_source())
write_lns += parameter.get_delphi_write_lns()
while None in write_lns:
write_lns.remove(None)
if len(write_lns) > 1:
write_lns.append(" WriteLn('');")
extra_message = self.get_formatted_extra_message(" WriteLn('{0}');")
if len(extra_message) > 0 and len(write_lns) > 0:
extra_message = '\n' + extra_message
result = template1.format(function_name_comment=self.get_comment_name(),
override_comment=override_comment) + \
template2.format(device_category=self.get_device().get_category().camel,
device_name=self.get_device().get_name().camel,
function_name_camel=self.get_name().camel,
parameters=common.wrap_non_empty(';<BP>', ';<BP>'.join(parameters), ''),
write_lns='\n'.join(write_lns).replace('\r\n\r', '\n\n').strip('\r').replace('\r', '\n'),
extra_message=extra_message)
return common.break_string(result,
'{}CB('.format(self.get_name().camel))
def get_ruby_source(self):
template = '{comment1}{global_line_prefix}{device_name}.{function_name}{arguments}{comment2}\n'
arguments = common.wrap_non_empty(' ', ',<BP>'.join(self.get_ruby_arguments()), '')
indent_marker = '.{} '
if arguments.strip().startswith('('):
arguments = '({0})'.format(arguments.strip())
indent_marker = '.{}('
result = template.format(global_line_prefix=global_line_prefix,
device_name=self.get_device().get_initial_name(),
function_name=self.get_name().under,
arguments=arguments,
comment1=self.get_formatted_comment1(global_line_prefix + '# {0}\n', '\r', '\n' + global_line_prefix + '# '),
comment2=self.get_formatted_comment2(' # {0}', ''))
return common.break_string(result, indent_marker.format(self.get_name().under), continuation=' \\')
def get_delphi_source(self):
templateA = r"""{global_line_prefix} {{ Get current {function_name_comment} }}
{global_line_prefix} {variable_names} := {device_name}.{function_name_camel}{arguments};
{write_lns}
"""
templateB = r"""{global_line_prefix} {{ Get current {function_name_comment} }}
{global_line_prefix} {device_name}.{function_name_camel}{arguments};
{write_lns}
"""
variable_names = []
write_lns = []
for result in self.get_results():
variable_names.append(result.get_delphi_variable_name())
write_lns += result.get_delphi_write_lns()
if len(variable_names) == 1:
template = templateA
else:
template = templateB
while None in write_lns:
write_lns.remove(None)
if len(write_lns) > 1:
write_lns.insert(0, '\b')
arguments = self.get_delphi_arguments()
if len(variable_names) > 1:
arguments += variable_names
variable_names = []
result = template.format(
global_line_prefix=global_line_prefix,
device_name=self.get_device().get_initial_name(),
function_name_camel=self.get_name().camel,
function_name_comment=self.get_comment_name(),
variable_names=''.join(variable_names),
write_lns='\n'.join(write_lns).replace('\b\n\r', '\n').replace(
'\b', '').replace('\r\n\r',
'\n\n').rstrip('\r').replace('\r', '\n'),
arguments=common.wrap_non_empty('(', ',<BP>'.join(arguments), ')'))
return common.break_string(result,
'.{0}('.format(self.get_name().camel))
