Andreas Wundsam | 2730346 | 2013-07-16 12:52:35 -0700 | [diff] [blame] | 1 | import os |
| 2 | import errno |
| 3 | import re |
| 4 | import subprocess |
| 5 | import time |
| 6 | |
| 7 | def name_c_to_camel(name): |
| 8 | """ 'of_stats_reply' -> 'ofStatsReply' """ |
| 9 | name = re.sub(r'^_','', name) |
| 10 | tokens = name.split('_') |
| 11 | for i in range(1, len(tokens)): |
| 12 | tokens[i] = tokens[i].title() |
| 13 | return "".join(tokens) |
| 14 | |
| 15 | def name_c_to_caps_camel(name): |
| 16 | """ 'of_stats_reply' to 'OFStatsReply' """ |
| 17 | camel = name_c_to_camel(name.title()) |
| 18 | if camel.startswith('Of'): |
| 19 | return camel.replace('Of','OF',1) |
| 20 | else: |
| 21 | return camel |
| 22 | |
| 23 | |
Andreas Wundsam | e916d6f | 2013-07-30 11:33:58 -0700 | [diff] [blame] | 24 | java_primitive_types = set("byte char short int long".split(" ")) |
Yotam Harchol | d7b8420 | 2013-07-26 16:08:10 -0700 | [diff] [blame] | 25 | |
Andreas Wundsam | e916d6f | 2013-07-30 11:33:58 -0700 | [diff] [blame] | 26 | ANY = 0xFFFFFFFFFFFFFFFF |
Yotam Harchol | d7b8420 | 2013-07-26 16:08:10 -0700 | [diff] [blame] | 27 | |
| 28 | class VersionOp: |
| 29 | def __init__(self, version=ANY, read=None, write=None): |
| 30 | self.version = version |
| 31 | self.read = read |
| 32 | self.write = write |
Andreas Wundsam | e916d6f | 2013-07-30 11:33:58 -0700 | [diff] [blame] | 33 | |
Yotam Harchol | d7b8420 | 2013-07-26 16:08:10 -0700 | [diff] [blame] | 34 | def __str__(self): |
| 35 | return "[Version: %d, Read: '%s', Write: '%s']" % (self.version, self.read, self.write) |
| 36 | |
Andreas Wundsam | 2730346 | 2013-07-16 12:52:35 -0700 | [diff] [blame] | 37 | class JType(object): |
| 38 | """ Wrapper class to hold C to Java type conversion information """ |
| 39 | def __init__(self, pub_type, priv_type=None, size=None, read_op=None, write_op=None): |
| 40 | self.pub_type = pub_type # the type we expose externally, e.g. 'U8' |
| 41 | if priv_type is None: |
| 42 | priv_type = pub_type |
| 43 | self.priv_type = priv_type # the internal storage type |
| 44 | self.size = size # bytes on the wire; None == variable length or hard to calc |
Yotam Harchol | d7b8420 | 2013-07-26 16:08:10 -0700 | [diff] [blame] | 45 | self.ops = {} |
| 46 | # if read_op is None: |
Andreas Wundsam | 951ada3 | 2013-08-01 22:05:38 -0700 | [diff] [blame] | 47 | # read_op = 'ChannelUtilsVer$version.read%s(bb)' % self.pub_type |
Yotam Harchol | d7b8420 | 2013-07-26 16:08:10 -0700 | [diff] [blame] | 48 | # if write_op is None: |
Andreas Wundsam | 951ada3 | 2013-08-01 22:05:38 -0700 | [diff] [blame] | 49 | # write_op = 'ChannelUtilsVer$version.write%s(bb, $name)' % self.pub_type |
Yotam Harchol | d7b8420 | 2013-07-26 16:08:10 -0700 | [diff] [blame] | 50 | # self._read_op = read_op |
| 51 | # self._write_op = write_op |
| 52 | |
| 53 | def op(self, version=ANY, read=None, write=None): |
| 54 | self.ops[version] = VersionOp(version, read, write) |
| 55 | return self |
Andreas Wundsam | 2730346 | 2013-07-16 12:52:35 -0700 | [diff] [blame] | 56 | |
Andreas Wundsam | bf1dbbd | 2013-07-30 11:07:59 -0700 | [diff] [blame] | 57 | def cast(self, min): |
| 58 | """ declares that the value has to be cast to itself for values >= min. |
| 59 | This is to deal with Java signedness """ |
| 60 | def format_cast_value(value): |
| 61 | if value >= min: |
| 62 | return "(%s) 0x%x" % (self.pub_type, value) |
| 63 | else: |
| 64 | return "0x%x" % (value) |
| 65 | |
| 66 | self.format_value = format_cast_value |
| 67 | return self |
| 68 | |
| 69 | def format_value(self, value): |
| 70 | return value |
| 71 | |
Andreas Wundsam | 2730346 | 2013-07-16 12:52:35 -0700 | [diff] [blame] | 72 | @property |
| 73 | def public_type(self): |
| 74 | """ return the public type """ |
| 75 | return self.pub_type |
| 76 | |
| 77 | def priv(self): |
| 78 | """ return the public type """ |
| 79 | return self.priv_type |
| 80 | |
| 81 | def has_priv(self): |
| 82 | """ Is the private type different from the public one?""" |
| 83 | return self.pub_type != self.priv_type |
| 84 | |
| 85 | def read_op(self, version=None, length=None): |
| 86 | if length is None: |
| 87 | length = "length - bb.readerIndex()"; |
| 88 | |
Yotam Harchol | d7b8420 | 2013-07-26 16:08:10 -0700 | [diff] [blame] | 89 | ver = ANY if version is None else version.int_version |
| 90 | _read_op = None |
| 91 | if ver in self.ops: |
Andreas Wundsam | 951ada3 | 2013-08-01 22:05:38 -0700 | [diff] [blame] | 92 | _read_op = self.ops[ver].read or self.ops[ANY].read |
Yotam Harchol | d7b8420 | 2013-07-26 16:08:10 -0700 | [diff] [blame] | 93 | elif ANY in self.ops: |
| 94 | _read_op = self.ops[ANY].read |
| 95 | if _read_op is None: |
Andreas Wundsam | 951ada3 | 2013-08-01 22:05:38 -0700 | [diff] [blame] | 96 | _read_op = 'ChannelUtilsVer$version.read%s(bb)' % self.pub_type |
Yotam Harchol | d7b8420 | 2013-07-26 16:08:10 -0700 | [diff] [blame] | 97 | if callable(_read_op): |
| 98 | return _read_op(version) |
Andreas Wundsam | 2730346 | 2013-07-16 12:52:35 -0700 | [diff] [blame] | 99 | else: |
Yotam Harchol | d7b8420 | 2013-07-26 16:08:10 -0700 | [diff] [blame] | 100 | return _read_op.replace("$length", str(length)).replace("$version", version.of_version) |
Andreas Wundsam | 2730346 | 2013-07-16 12:52:35 -0700 | [diff] [blame] | 101 | |
| 102 | def write_op(self, version=None, name=None): |
Yotam Harchol | d7b8420 | 2013-07-26 16:08:10 -0700 | [diff] [blame] | 103 | ver = ANY if version is None else version.int_version |
| 104 | _write_op = None |
| 105 | if ver in self.ops: |
| 106 | _write_op = self.ops[ver].write or self.ops[ANY].write |
| 107 | elif ANY in self.ops: |
| 108 | _write_op = self.ops[ANY].write |
| 109 | if _write_op is None: |
Andreas Wundsam | 951ada3 | 2013-08-01 22:05:38 -0700 | [diff] [blame] | 110 | _write_op = 'ChannelUtilsVer$version.write%s(bb, $name)' % self.pub_type |
Yotam Harchol | d7b8420 | 2013-07-26 16:08:10 -0700 | [diff] [blame] | 111 | if callable(_write_op): |
| 112 | return _write_op(version, name) |
Andreas Wundsam | 2730346 | 2013-07-16 12:52:35 -0700 | [diff] [blame] | 113 | else: |
Yotam Harchol | d7b8420 | 2013-07-26 16:08:10 -0700 | [diff] [blame] | 114 | return _write_op.replace("$name", str(name)).replace("$version", version.of_version) |
Andreas Wundsam | 2730346 | 2013-07-16 12:52:35 -0700 | [diff] [blame] | 115 | |
Andreas Wundsam | e916d6f | 2013-07-30 11:33:58 -0700 | [diff] [blame] | 116 | @property |
| 117 | def is_primitive(self): |
| 118 | return self.pub_type in java_primitive_types |
| 119 | |
| 120 | @property |
| 121 | def is_array(self): |
| 122 | return self.pub_type.endswith("[]") |
| 123 | |
| 124 | |
Yotam Harchol | d7b8420 | 2013-07-26 16:08:10 -0700 | [diff] [blame] | 125 | u8 = JType('byte', size=1) \ |
| 126 | .op(read='bb.readByte()', write='bb.writeByte($name)') |
| 127 | u8_list = JType('List<U8>', size=1) \ |
| 128 | .op(read='bb.readByte()', write='bb.writeByte($name)') |
| 129 | u16 = JType('int', 'int', size=2) \ |
| 130 | .op(read='U16.f(bb.readShort())', write='bb.writeShort(U16.t($name))') |
| 131 | u32 = JType('int', 'int', size=4) \ |
| 132 | .op(read='bb.readInt()', write='bb.writeInt($name)') |
| 133 | u32_list = JType('List<U32>', 'int[]', size=4) \ |
| 134 | .op(read='bb.readInt()', write='bb.writeInt($name)') |
| 135 | u64 = JType('U64', 'U64', size=8) \ |
| 136 | .op(read='U64.of(bb.readLong())', write='bb.writeLong($name.getValue())') |
| 137 | of_port = JType("OFPort") \ |
| 138 | .op(version=1, read="OFPort.read2Bytes(bb)", write="$name.write2Bytes(bb)") \ |
| 139 | .op(version=ANY, read="OFPort.read4Bytes(bb)", write="$name.write4Bytes(bb)") |
| 140 | one_byte_array = JType('byte[]', size=1) \ |
Andreas Wundsam | 951ada3 | 2013-08-01 22:05:38 -0700 | [diff] [blame] | 141 | .op(read='ChannelUtilsVer$version.readBytes(bb, 1)', write='ChannelUtilsVer$version.writeBytes(bb, $name)') |
Yotam Harchol | d7b8420 | 2013-07-26 16:08:10 -0700 | [diff] [blame] | 142 | two_byte_array = JType('byte[]', size=2) \ |
Andreas Wundsam | 951ada3 | 2013-08-01 22:05:38 -0700 | [diff] [blame] | 143 | .op(read='ChannelUtilsVer$version.readBytes(bb, 2)', write='ChannelUtilsVer$version.writeBytes(bb, $name)') |
Yotam Harchol | d7b8420 | 2013-07-26 16:08:10 -0700 | [diff] [blame] | 144 | three_byte_array = JType('byte[]', size=3) \ |
Andreas Wundsam | 951ada3 | 2013-08-01 22:05:38 -0700 | [diff] [blame] | 145 | .op(read='ChannelUtilsVer$version.readBytes(bb, 3)', write='ChannelUtilsVer$version.writeBytes(bb, $name)') |
Yotam Harchol | d7b8420 | 2013-07-26 16:08:10 -0700 | [diff] [blame] | 146 | four_byte_array = JType('byte[]', size=4) \ |
Andreas Wundsam | 951ada3 | 2013-08-01 22:05:38 -0700 | [diff] [blame] | 147 | .op(read='ChannelUtilsVer$version.readBytes(bb, 4)', write='ChannelUtilsVer$version.writeBytes(bb, $name)') |
Yotam Harchol | d7b8420 | 2013-07-26 16:08:10 -0700 | [diff] [blame] | 148 | five_byte_array = JType('byte[]', size=5) \ |
Andreas Wundsam | 951ada3 | 2013-08-01 22:05:38 -0700 | [diff] [blame] | 149 | .op(read='ChannelUtilsVer$version.readBytes(bb, 5)', write='ChannelUtilsVer$version.writeBytes(bb, $name)') |
Yotam Harchol | d7b8420 | 2013-07-26 16:08:10 -0700 | [diff] [blame] | 150 | six_byte_array = JType('byte[]', size=6) \ |
Andreas Wundsam | 951ada3 | 2013-08-01 22:05:38 -0700 | [diff] [blame] | 151 | .op(read='ChannelUtilsVer$version.readBytes(bb, 6)', write='ChannelUtilsVer$version.writeBytes(bb, $name)') |
Yotam Harchol | d7b8420 | 2013-07-26 16:08:10 -0700 | [diff] [blame] | 152 | seven_byte_array = JType('byte[]', size=7) \ |
Andreas Wundsam | 951ada3 | 2013-08-01 22:05:38 -0700 | [diff] [blame] | 153 | .op(read='ChannelUtilsVer$version.readBytes(bb, 7)', write='ChannelUtilsVer$version.writeBytes(bb, $name)') |
| 154 | actions_list = JType('List<OFAction>', size='ChannelUtilsVer$version.calcListSize($name)') \ |
| 155 | .op(read='ChannelUtilsVer$version.readActionsList(bb, $length)', write='ChannelUtilsVer$version.writeActionsList(bb, $name);') |
| 156 | instructions_list = JType('List<OFInstruction>', size='ChannelUtilsVer$version.calcListSize($name)') \ |
| 157 | .op(read='ChannelUtilsVer$version.readInstructionsList(bb, $length)', \ |
| 158 | write='ChannelUtilsVer$version.writeList(bb, $name)') |
| 159 | buckets_list = JType('List<OFBucket>', size='ChannelUtilsVer$version.calcListSize($name)') \ |
| 160 | .op(read='ChannelUtilsVer$version.readBucketList(bb, $length)', \ |
| 161 | write='ChannelUtilsVer$version.writeList(bb, $name)') |
| 162 | port_desc_list = JType('List<OFPhysicalPort>', size='ChannelUtilsVer$version.calcListSize($name)') \ |
| 163 | .op(read='ChannelUtilsVer$version.readPhysicalPortList(bb, $length)', \ |
| 164 | write='ChannelUtilsVer$version.writePhysicalPortList(bb, $name)') |
Yotam Harchol | d7b8420 | 2013-07-26 16:08:10 -0700 | [diff] [blame] | 165 | port_desc = JType('OFPortDesc', size='$name.getLength()') \ |
| 166 | .op(read='null; // TODO OFPortDescVer$version.READER.read(bb)', \ |
| 167 | write='$name.writeTo(bb)') |
Andreas Wundsam | 951ada3 | 2013-08-01 22:05:38 -0700 | [diff] [blame] | 168 | packet_queue_list = JType('List<OFPacketQueue>', size='ChannelUtilsVer$version.calcListSize($name)') \ |
| 169 | .op(read='ChannelUtilsVer$version.readPacketQueueList(bb, $length)', \ |
| 170 | write='ChannelUtilsVer$version.writeList(bb, $name)') |
Yotam Harchol | d7b8420 | 2013-07-26 16:08:10 -0700 | [diff] [blame] | 171 | octets = JType('byte[]', size="$length") \ |
Andreas Wundsam | 951ada3 | 2013-08-01 22:05:38 -0700 | [diff] [blame] | 172 | .op(read='ChannelUtilsVer$version.readBytes(bb, $length)', \ |
Yotam Harchol | d7b8420 | 2013-07-26 16:08:10 -0700 | [diff] [blame] | 173 | write='bb.writeBytes($name)') |
| 174 | of_match = JType('Match', size="$name.getLength()") \ |
Andreas Wundsam | 951ada3 | 2013-08-01 22:05:38 -0700 | [diff] [blame] | 175 | .op(read='ChannelUtilsVer$version.readOFMatch(bb)', \ |
| 176 | write='ChannelUtilsVer$version.writeOFMatch(bb, $name)') |
Yotam Harchol | d7b8420 | 2013-07-26 16:08:10 -0700 | [diff] [blame] | 177 | flow_mod_cmd = JType('OFFlowModCommand', 'short', size="$name.getLength()") \ |
| 178 | .op(version=1, read="bb.readShort()", write="bb.writeShort($name)") \ |
| 179 | .op(version=ANY, read="bb.readByte()", write="bb.writeByte($name)") |
| 180 | mac_addr = JType('MacAddress', 'byte[]', size=6) \ |
| 181 | .op(read="MacAddress.read6Bytes(bb)", \ |
| 182 | write="$name.write6Bytes(bb)") |
| 183 | port_name = JType('String', size=16) \ |
Andreas Wundsam | 951ada3 | 2013-08-01 22:05:38 -0700 | [diff] [blame] | 184 | .op(read='ChannelUtilsVer$version.readFixedLengthString(bb, 16)', \ |
| 185 | write='ChannelUtilsVer$version.writeFixedLengthString(bb, $name, 16)') |
Yotam Harchol | d7b8420 | 2013-07-26 16:08:10 -0700 | [diff] [blame] | 186 | desc_str = JType('String', size=256) \ |
Andreas Wundsam | 951ada3 | 2013-08-01 22:05:38 -0700 | [diff] [blame] | 187 | .op(read='ChannelUtilsVer$version.readFixedLengthString(bb, 256)', \ |
| 188 | write='ChannelUtilsVer$version.writeFixedLengthString(bb, $name, 256)') |
Yotam Harchol | d7b8420 | 2013-07-26 16:08:10 -0700 | [diff] [blame] | 189 | serial_num = JType('String', size=32) \ |
Andreas Wundsam | 951ada3 | 2013-08-01 22:05:38 -0700 | [diff] [blame] | 190 | .op(read='ChannelUtilsVer$version.readFixedLengthString(bb, 32)', \ |
| 191 | write='ChannelUtilsVer$version.writeFixedLengthString(bb, $name, 32)') |
Yotam Harchol | d7b8420 | 2013-07-26 16:08:10 -0700 | [diff] [blame] | 192 | table_name = JType('String', size=32) \ |
Andreas Wundsam | 951ada3 | 2013-08-01 22:05:38 -0700 | [diff] [blame] | 193 | .op(read='ChannelUtilsVer$version.readFixedLengthString(bb, 32)', \ |
| 194 | write='ChannelUtilsVer$version.writeFixedLengthString(bb, $name, 32)') |
Yotam Harchol | d7b8420 | 2013-07-26 16:08:10 -0700 | [diff] [blame] | 195 | ipv4 = JType("IPv4") \ |
| 196 | .op(read="IPv4.read4Bytes(bb)", \ |
| 197 | write="$name.write4Bytes(bb)") |
| 198 | ipv6 = JType("IPv6") \ |
| 199 | .op(read="IPv6.read16Bytes(bb)", \ |
| 200 | write="$name.write16Bytes(bb)") |
Andreas Wundsam | bf1dbbd | 2013-07-30 11:07:59 -0700 | [diff] [blame] | 201 | packetin_reason = JType("OFPacketInReason")\ |
| 202 | .op(read="OFPacketInReasonSerializerVer$version.readFrom(bb)", write="OFPacketInReasonSerializerVer$version.writeTo(bb, $name)") |
Andreas Wundsam | 2730346 | 2013-07-16 12:52:35 -0700 | [diff] [blame] | 203 | |
| 204 | default_mtype_to_jtype_convert_map = { |
| 205 | 'uint8_t' : u8, |
| 206 | 'uint16_t' : u16, |
| 207 | 'uint32_t' : u32, |
| 208 | 'uint64_t' : u64, |
| 209 | 'uint8_t[1]' : one_byte_array, |
| 210 | 'uint8_t[2]' : two_byte_array, |
| 211 | 'uint8_t[3]' : three_byte_array, |
| 212 | 'uint8_t[4]' : four_byte_array, |
| 213 | 'uint8_t[5]' : five_byte_array, |
| 214 | 'uint8_t[6]' : six_byte_array, |
| 215 | 'uint8_t[7]' : seven_byte_array, |
| 216 | 'of_port_no_t' : of_port, |
| 217 | 'list(of_action_t)' : actions_list, |
| 218 | 'list(of_instruction_t)' : instructions_list, |
| 219 | 'list(of_bucket_t)': buckets_list, |
| 220 | 'list(of_port_desc_t)' : port_desc_list, |
| 221 | 'list(of_packet_queue_t)' : packet_queue_list, |
| 222 | 'list(of_uint32_t)' : u32_list, |
| 223 | 'list(of_uint8_t)' : u8_list, |
| 224 | 'of_octets_t' : octets, |
| 225 | 'of_match_t': of_match, |
| 226 | 'of_fm_cmd_t': flow_mod_cmd, |
| 227 | 'of_mac_addr_t': mac_addr, |
| 228 | 'of_port_desc_t': port_desc, |
| 229 | 'of_desc_str_t': desc_str, |
| 230 | 'of_serial_num_t': serial_num, |
| 231 | 'of_port_name_t': port_name, |
| 232 | 'of_table_name_t': table_name, |
| 233 | 'of_ipv4_t': ipv4, |
| 234 | 'of_ipv6_t': ipv6, |
| 235 | 'of_wc_bmap_t': JType("Wildcards") |
| 236 | } |
| 237 | |
| 238 | ## This is where we drop in special case handling for certain types |
| 239 | exceptions = { |
Andreas Wundsam | bf1dbbd | 2013-07-30 11:07:59 -0700 | [diff] [blame] | 240 | 'of_packet_in': { |
| 241 | 'data' : octets, |
| 242 | 'reason': packetin_reason |
Andreas Wundsam | 2730346 | 2013-07-16 12:52:35 -0700 | [diff] [blame] | 243 | }, |
| 244 | } |
| 245 | |
| 246 | |
Andreas Wundsam | bf1dbbd | 2013-07-30 11:07:59 -0700 | [diff] [blame] | 247 | enum_wire_types = { |
| 248 | "uint8_t": JType("byte").op(read="bb.readByte()", write="bb.writeByte($name)").cast(min=1<<7), |
| 249 | "uint16_t": JType("short").op(read="bb.readShort()", write="bb.writeShort($name)").cast(min=1<<15), |
| 250 | "uint32_t": JType("int").op(read="bb.readInt()", write="bb.writeInt($name)").cast(min=1<<31), |
| 251 | "uint64_t": JType("long").op(read="bb.readLong()", write="bb.writeLong($name)").cast(min=1<<31) |
| 252 | } |
| 253 | |
| 254 | def convert_enum_wire_type_to_jtype(wire_type): |
| 255 | return enum_wire_types[wire_type] |
| 256 | |
Andreas Wundsam | 2730346 | 2013-07-16 12:52:35 -0700 | [diff] [blame] | 257 | def make_standard_list_jtype(c_type): |
| 258 | m = re.match(r'list\(of_([a-zA-Z_]+)_t\)', c_type) |
| 259 | if not m: |
| 260 | raise Exception("Not a recgonized standard list type declaration: %s" % c_type) |
| 261 | base_name = m.group(1) |
| 262 | java_base_name = name_c_to_caps_camel(base_name) |
Yotam Harchol | d7b8420 | 2013-07-26 16:08:10 -0700 | [diff] [blame] | 263 | return JType("List<OF%s>" % java_base_name) \ |
Andreas Wundsam | 951ada3 | 2013-08-01 22:05:38 -0700 | [diff] [blame] | 264 | .op(read='ChannelUtilsVer$version.read%sList(bb, $length)' % java_base_name, \ |
| 265 | write='ChannelUtilsVer$version.write%sList(bb, $name)' % java_base_name) |
Andreas Wundsam | 2730346 | 2013-07-16 12:52:35 -0700 | [diff] [blame] | 266 | |
| 267 | def convert_to_jtype(obj_name, field_name, c_type): |
| 268 | """ Convert from a C type ("uint_32") to a java type ("U32") |
| 269 | and return a JType object with the size, internal type, and marshalling functions""" |
| 270 | if obj_name in exceptions and field_name in exceptions[obj_name]: |
| 271 | return exceptions[obj_name][field_name] |
| 272 | elif field_name == "type" and c_type == "uint8_t": |
Yotam Harchol | d7b8420 | 2013-07-26 16:08:10 -0700 | [diff] [blame] | 273 | return JType("OFType", 'byte', size=1) \ |
| 274 | .op(read='bb.readByte()', write='bb.writeByte($name)') |
Andreas Wundsam | 2730346 | 2013-07-16 12:52:35 -0700 | [diff] [blame] | 275 | elif field_name == "type" and re.match(r'of_action.*', obj_name): |
Yotam Harchol | d7b8420 | 2013-07-26 16:08:10 -0700 | [diff] [blame] | 276 | return JType("OFActionType", 'short', size=2) \ |
| 277 | .op(read='bb.readShort()', write='bb.writeShort($name)') |
Andreas Wundsam | 2730346 | 2013-07-16 12:52:35 -0700 | [diff] [blame] | 278 | elif field_name == "version" and c_type == "uint8_t": |
Yotam Harchol | d7b8420 | 2013-07-26 16:08:10 -0700 | [diff] [blame] | 279 | return JType("OFVersion", 'byte', size=1) \ |
| 280 | .op(read='bb.readByte()', write='bb.writeByte($name)') |
Andreas Wundsam | 2730346 | 2013-07-16 12:52:35 -0700 | [diff] [blame] | 281 | elif c_type in default_mtype_to_jtype_convert_map: |
| 282 | return default_mtype_to_jtype_convert_map[c_type] |
| 283 | elif re.match(r'list\(of_([a-zA-Z_]+)_t\)', c_type): |
| 284 | return make_standard_list_jtype(c_type) |
| 285 | else: |
| 286 | print "WARN: Couldn't find java type conversion for '%s' in %s:%s" % (c_type, obj_name, field_name) |
| 287 | jtype = name_c_to_caps_camel(re.sub(r'_t$', "", c_type)) |
| 288 | return JType(jtype) |