def make_typedefs():
    typedef = """
typedef void (*{0}CallbackFunction)({1});
"""

    typedefs = '\n'
    for packet in device.get_packets('callback'):
        name = packet.get_camel_case_name()
        c_type_list = []
        for element in packet.get_elements():
            if element[2] > 1:
                c_type_list.append('{0}[{1}]'.format(c_common.get_c_type(element[1], 'out', True), element[2]))
            else:
                c_type_list.append(c_common.get_c_type(element[1], 'out', True))

        typedefs += typedef.format(name, ', '.join(c_type_list + ['void *']))

    return typedefs
 def make_struct_list(packet):
     struct_list = ''
     needs_i = False
     for element in packet.get_elements('in'):
         sf = 'request'
         if element[1] == 'string':
             temp = '\n\tstrncpy({0}.{1}, {1}, {2});\n'
             struct_list += temp.format(sf, element[0], element[2])
         elif element[2] > 1:
             if common.get_type_size(element[1]) > 1:
                 needs_i = True
                 struct_list += '\n\tfor (i = 0; i < {3}; i++) {0}.{1}[i] = leconvert_{2}_to({1}[i]);' \
                                .format(sf, element[0], element[1], element[2])
             else:
                 temp = '\n\tmemcpy({0}.{1}, {1}, {2} * sizeof({3}));'
                 struct_list += temp.format(sf,
                                            element[0],
                                            element[2],
                                            c_common.get_c_type(element[1], 'in', False))
         elif common.get_type_size(element[1]) > 1:
             struct_list += '\n\t{0}.{1} = leconvert_{2}_to({1});'.format(sf, element[0], element[1])
         else:
             struct_list += '\n\t{0}.{1} = {1};'.format(sf, element[0])
     return struct_list, needs_i
 def make_return_list(packet):
     return_list = ''
     needs_i = False
     for element in packet.get_elements('out'):
         sf = 'response'
         if element[1] == 'string':
             temp = '\tstrncpy(ret_{0}, {1}.{0}, {2});\n'
             return_list += temp.format(element[0], sf, element[2])
         elif element[2] > 1:
             if common.get_type_size(element[1]) > 1:
                 needs_i = True
                 return_list += '\tfor (i = 0; i < {3}; i++) ret_{0}[i] = leconvert_{2}_from({1}.{0}[i]);\n' \
                                .format(element[0], sf, element[1], element[2])
             else:
                 temp = '\tmemcpy(ret_{0}, {1}.{0}, {2} * sizeof({3}));\n'
                 return_list += temp.format(element[0],
                                            sf,
                                            element[2],
                                            c_common.get_c_type(element[1], 'out', False))
         elif common.get_type_size(element[1]) > 1:
             return_list += '\t*ret_{0} = leconvert_{2}_from({1}.{0});\n'.format(element[0], sf, element[1])
         else:
             return_list += '\t*ret_{0} = {1}.{0};\n'.format(element[0], sf)
     return return_list, needs_i
def make_structs():
    structs = """
#if defined _MSC_VER || defined __BORLANDC__
\t#pragma pack(push)
\t#pragma pack(1)
\t#define ATTRIBUTE_PACKED
#elif defined __GNUC__
\t#define ATTRIBUTE_PACKED __attribute__((packed))
#else
\t#error unknown compiler, do not know how to enable struct packing
#endif
"""

    struct_temp = """
typedef struct {{
\tPacketHeader header;
{0}}} ATTRIBUTE_PACKED {1}{2}_;
"""

    for packet in device.get_packets():
        if packet.get_type() == 'callback':
            cb = "Callback"
            struct_body = ''
            for element in packet.get_elements():
                c_type = c_common.get_c_type(element[1], 'out', False)
                if element[2] > 1:
                    struct_body += '\t{0} {1}[{2}];\n'.format(c_type,
                                                              element[0],
                                                              element[2]);
                else:
                    struct_body += '\t{0} {1};\n'.format(c_type, element[0])

            structs += struct_temp.format(struct_body, packet.get_camel_case_name(), cb)
            continue

        struct_body = ''
        for element in packet.get_elements('in'):
            c_type = c_common.get_c_type(element[1], 'in', False)
            if element[2] > 1:
                struct_body += '\t{0} {1}[{2}];\n'.format(c_type,
                                                          element[0],
                                                          element[2]);
            else:
                struct_body += '\t{0} {1};\n'.format(c_type, element[0])

        structs += struct_temp.format(struct_body, packet.get_camel_case_name(), '')

        if len(packet.get_elements('out')) == 0:
            continue

        struct_body = ''
        for element in packet.get_elements('out'):
            c_type = c_common.get_c_type(element[1], 'out', False)
            if element[2] > 1:
                struct_body += '\t{0} {1}[{2}];\n'.format(c_type,
                                                          element[0],
                                                          element[2]);
            else:
                struct_body += '\t{0} {1};\n'.format(c_type, element[0])

        structs += struct_temp.format(struct_body, packet.get_camel_case_name(), 'Response')

    structs += """
#if defined _MSC_VER || defined __BORLANDC__
\t#pragma pack(pop)
#endif
#undef ATTRIBUTE_PACKED
"""
    return structs