def fieldReflection(msg, field):
fieldFnName = field["Name"]
fieldCount = MsgParser.fieldCount(field)
if MsgParser.fieldCount(field) != 1 and MsgParser.fieldUnits(field) == "ASCII" and (field["Type"] == "uint8" or field["Type"] == "int8"):
fieldFnName = field["Name"]+"String"
fieldCount = 1
fieldInfo = "["+\
'"name":"'+field["Name"] + '",'+\
'"type":"'+reflectionInterfaceType(field) + '",'+\
'"units":"'+MsgParser.fieldUnits(field) + '",'+\
'"minVal":"'+str(MsgParser.fieldMin(field)) + '",'+\
'"maxVal":"'+str(MsgParser.fieldMax(field)) + '",'+\
'"description":"'+MsgParser.fieldDescription(field) + '",'+\
'"get":"Get' + fieldFnName + '",'+\
'"set":"Set' + fieldFnName + '",'+\
'"count":'+str(fieldCount) + ', '
if "Bitfields" in field:
bitfieldInfo = []
for bits in field["Bitfields"]:
bitfieldInfo.append(" " + bitfieldReflection(msg, field, bits))
fieldInfo += '"bitfieldInfo" : [\n' + ",\n".join(bitfieldInfo) + "], "
else:
fieldInfo += '"bitfieldInfo" : [], '
if "Enum" in field:
fieldInfo += '"enumLookup" : [' + field["Enum"]+"Enum, " + "Reverse" + field["Enum"]+"Enum]]"
else:
fieldInfo += '"enumLookup" : []]'
return fieldInfo
def fnHdr(field, offset, count, name):
param = "self"
if str.find(name, "Set") == 0:
param += ", value"
if count > 1:
param += ", idx"
if str.find(name, "Set") != 0:
if "Enum" in field:
param += ", enumAsInt=0"
min = MsgParser.fieldMin(field)
max = MsgParser.fieldMax(field)
try:
fieldSize = MsgParser.fieldSize(field)
if MsgParser.fieldUnits(field) == "ASCII" and (
field["Type"] == "uint8" or field["Type"] == "int8"):
count = MsgParser.fieldCount(field)
except KeyError:
fieldSize = 0
ret = '''\
@msg.units('%s')
@msg.default('%s')
@msg.minVal('%s')
@msg.maxVal('%s')
@msg.offset('%s')
@msg.size('%s')
@msg.count(%s)
def %s(%s):
"""%s"""''' % (MsgParser.fieldUnits(field),
str(MsgParser.fieldDefault(field)), str(min), str(max),
str(offset), str(fieldSize), str(count), name, param,
MsgParser.fieldDescription(field))
return ret
def fnHdr(field, offset, count, name):
param = "self"
if str.find(name, "Set") == 0:
param += ", value"
if count > 1:
param += ", idx"
if str.find(name, "Set") != 0:
if "Enum" in field:
param += ", enumAsInt=0"
min = MsgParser.fieldMin(field)
max = MsgParser.fieldMax(field)
try:
fieldSize = MsgParser.fieldSize(field)
if MsgParser.fieldUnits(field) == "ASCII" and (field["Type"] == "uint8" or field["Type"] == "int8"):
count = MsgParser.fieldCount(field)
except KeyError:
fieldSize = 0
ret = '''\
@msg.units('%s')
@msg.default('%s')
@msg.minVal('%s')
@msg.maxVal('%s')
@msg.offset('%s')
@msg.size('%s')
@msg.count(%s)
def %s(%s):
"""%s"""''' % (MsgParser.fieldUnits(field), str(MsgParser.fieldDefault(field)), str(min), str(max), str(offset), str(fieldSize), str(count), name, param, MsgParser.fieldDescription(field))
return ret
def fieldReflection(msg, field):
fieldFnName = field["Name"]
fieldCount = MsgParser.fieldCount(field)
if MsgParser.fieldCount(field) != 1 and MsgParser.fieldUnits(field) == "ASCII" and (field["Type"] == "uint8" or field["Type"] == "int8"):
fieldFnName = field["Name"]+"String"
fieldCount = 1
fieldInfo = "{"+\
'name:"'+field["Name"] + '",'+\
'type:"'+reflectionInterfaceType(field) + '",'+\
'units:"'+MsgParser.fieldUnits(field) + '",'+\
'minVal:"'+str(MsgParser.fieldMin(field)) + '",'+\
'maxVal:"'+str(MsgParser.fieldMax(field)) + '",'+\
'description:"'+MsgParser.fieldDescription(field) + '",'+\
'get:"Get' + fieldFnName + '",'+\
'set:"Set' + fieldFnName + '",'+\
'count:'+str(fieldCount) + ', '
if "Bitfields" in field:
bitfieldInfo = []
for bits in field["Bitfields"]:
bitfieldInfo.append(" " + bitfieldReflection(msg, field, bits))
fieldInfo += "bitfieldInfo : [\n" + ",\n".join(bitfieldInfo) + "], "
else:
fieldInfo += "bitfieldInfo : [], "
if "Enum" in field:
fieldInfo += "enumLookup : [<MSGSHORTNAME>." + field["Enum"]+", " + "<MSGSHORTNAME>.Reverse" + field["Enum"]+"]}"
else:
fieldInfo += "enumLookup : []}"
return fieldInfo
def setFn(field, offset):
paramType = returnType(field, None)
valueString = setMath("value", field)
#if "Enum" in field:
# valueString = paramType + "(" + valueString + ")"
# paramType = field["Enum"]
param = paramType + " value"
loc = str(offset)
if MsgParser.fieldCount(field) > 1:
loc += "+idx*" + str(MsgParser.fieldSize(field))
param += ", int idx"
ret = '''\
%s
void Set%s(%s)
{
_data.set%s(%s, %s);
}''' % (fnHdr(field), field["Name"], param, fieldType(field), loc, valueString)
if MsgParser.fieldUnits(field) == "ASCII" and (field["Type"] == "uint8"
or field["Type"] == "int8"):
ret += '''
%s
void Set%sString(String value)
{
for(int i=0; i<%s && i<value.length; i++)
{
Set%s(value.codeUnitAt(i), i);
}
}''' % (fnHdr(field), field["Name"], str(
MsgParser.fieldCount(field)), field["Name"])
return ret
def structUnpacking(msg):
ret = []
if "Fields" in msg:
for field in msg["Fields"]:
if "Bitfields" in field:
for bits in field["Bitfields"]:
ret.append('try { ret["' + bits["Name"] + '"] = Get' +
bits["Name"] + "(); } catch (err) {}")
else:
if MsgParser.fieldCount(field) == 1:
ret.append('try { ret["' + field["Name"] + '"] = Get' +
field["Name"] + "(); } catch (err) {}")
else:
if MsgParser.fieldUnits(field) == "ASCII" and (
field["Type"] == "uint8"
or field["Type"] == "int8"):
ret.append('try { ret["' + field["Name"] + '"] = Get' +
field["Name"] +
"String(); } catch (err) {}")
else:
ret.append('try { ret["' + field["Name"] +
'"] = []; } catch (err) {}')
ret.append('try { ')
ret.append(" for i in 0 ..< " +
str(MsgParser.fieldCount(field)))
ret.append(' {')
ret.append(' ret["' + field["Name"] +
'"][i] = Get' + field["Name"] + "(i);")
ret.append(' }')
ret.append('} catch (err) {}')
return "\n".join(ret)
def setFn(field):
valueString = setMath("value", field, fieldType(field))
param = "_ value: " + paramType(field)
loc = str(MsgParser.fieldLocation(field))
if MsgParser.fieldCount(field) > 1:
loc += "+idx*" + str(MsgParser.fieldArrayElementOffset(field))
param += ", _ idx: Int"
ret = '''\
%s
public func Set%s(%s)
{
m_data.SetField(offset: %s, value: %s);
};''' % (fnHdr(field), field["Name"], param, loc, valueString)
if MsgParser.fieldUnits(field) == "ASCII" and (field["Type"] == "uint8" or field["Type"] == "int8"):
ret += '''
%s
public func Set%sString(value: String)
{
let stringArray = Array(value.utf8);
for i in 0 ..< min(%s, stringArray.count)
{
Set%s(stringArray[i], i);
}
};''' % (fnHdr(field), field["Name"], str(MsgParser.fieldCount(field)), field["Name"])
return ret
def fieldReflection(msg, field):
fieldInfo = "FieldInfo("+\
'name="'+field["Name"] + '",'+\
'type="'+reflectionInterfaceType(field) + '",'+\
'units="'+MsgParser.fieldUnits(field) + '",'+\
'minVal="'+str(MsgParser.fieldMin(field)) + '",'+\
'maxVal="'+str(MsgParser.fieldMax(field)) + '",'+\
'description="'+MsgParser.fieldDescription(field) + '",'+\
'get='+"Get" + field["Name"] + ','+\
'set='+"Set" + field["Name"] + ','+\
'count='+str(pythonFieldCount(field)) + ', '
if "IDBits" in field:
fieldInfo += "idbits="+str(field["IDBits"])+","
if "Bitfields" in field:
bitfieldInfo = []
for bits in field["Bitfields"]:
bitfieldInfo.append(" " + bitfieldReflection(msg, field, bits))
fieldInfo += "bitfieldInfo = [\n" + ",\n".join(bitfieldInfo) + "], "
else:
fieldInfo += "bitfieldInfo = [], "
if "Enum" in field:
fieldInfo += "enum = [" + field["Enum"]+", " + "Reverse" + field["Enum"]+"])"
else:
fieldInfo += "enum = [])"
return fieldInfo
def getFn(msg, field):
loc = msgName(msg) + ".MSG_OFFSET + " + str(MsgParser.fieldLocation(field))
type = "'"+fieldType(field)+"'"
count = MsgParser.fieldCount(field)
cleanup = ""
preface = ""
if "Enum" in field:
# find index that corresponds to string input param
cleanup = reverseEnumLookup(msg, field)
if count > 1:
if MsgParser.fieldUnits(field) == "ASCII" and (field["Type"] == "uint8" or field["Type"] == "int8"):
preface += "\n count = " + str(count)+"\n"
preface += " if count > len(self.rawBuffer())-("+loc+"):\n"
preface += " count = len(self.rawBuffer())-("+loc+")\n"
type = "str(count)+'s'"
count = 1
cleanup = '''ascii_len = str(value).find("\\\\x00")
value = str(value)[2:ascii_len]
'''
else:
loc += "+idx*" + str(MsgParser.fieldArrayElementOffset(field))
if "Offset" in field or "Scale" in field:
cleanup = "value = " + MsgParser.getMath("value", field, "")+"\n "
ret = '''\
%s%s
value = struct.unpack_from(%s, self.rawBuffer(), %s)[0]
%sreturn value
''' % (fnHdr(field,MsgParser.fieldLocation(field),count, "Get"+field["Name"]), preface, type, loc, cleanup)
return ret
def setFn(msg, field):
loc = msgName(msg) + ".MSG_OFFSET + " + str(MsgParser.fieldLocation(field))
count = MsgParser.fieldCount(field)
type = fieldType(field)
lookup = ""
if "Enum" in field:
# find index that corresponds to string input param
lookup = enumLookup(msg, field)
math = MsgParser.setMath("value", field, "int")
storageType = field["Type"]
if "int" in storageType:
math = "min(max(%s, %s), %s)" % (
math, MsgParser.fieldStorageMin(storageType),
MsgParser.fieldStorageMax(storageType))
math = lookup + "tmp = " + math
if count > 1:
if MsgParser.fieldUnits(field) == "ASCII" and (
field["Type"] == "uint8" or field["Type"] == "int8"):
type = str(count) + "s"
count = 1
math = "tmp = value.encode('utf-8')"
else:
loc += "+idx*" + str(MsgParser.fieldArrayElementOffset(field))
ret = '''\
%s
%s
struct.pack_into('%s', self.rawBuffer(), %s, tmp)
''' % (fnHdr(field, MsgParser.fieldLocation(field), count,
"Set" + field["Name"]), math, type, loc)
return ret
def fieldReflection(msg, field):
fieldInfo = "FieldInfo("+\
'name="'+field["Name"] + '",'+\
'type="'+reflectionInterfaceType(field) + '",'+\
'units="'+MsgParser.fieldUnits(field) + '",'+\
'minVal="'+str(MsgParser.fieldMin(field)) + '",'+\
'maxVal="'+str(MsgParser.fieldMax(field)) + '",'+\
'description="'+MsgParser.fieldDescription(field) + '",'+\
'get='+"Get" + field["Name"] + ','+\
'set='+"Set" + field["Name"] + ','+\
'count='+str(pythonFieldCount(field)) + ', '
if "IDBits" in field:
fieldInfo += "idbits=" + str(field["IDBits"]) + ","
if "Bitfields" in field:
bitfieldInfo = []
for bits in field["Bitfields"]:
bitfieldInfo.append(" " + bitfieldReflection(msg, field, bits))
fieldInfo += "bitfieldInfo = [\n" + ",\n".join(bitfieldInfo) + "], "
else:
fieldInfo += "bitfieldInfo = [], "
if "Enum" in field:
fieldInfo += "enum = [" + field["Enum"] + ", " + "Reverse" + field[
"Enum"] + "])"
else:
fieldInfo += "enum = [])"
return fieldInfo
def setFn(field):
valueString = setMath("value", field, "")
lookup = ""
if "Enum" in field:
# find index that corresponds to string input param
lookup = enumLookup(field)
param = "value"
loc = str(MsgParser.fieldLocation(field))
if MsgParser.fieldCount(field) > 1:
loc += "+idx*" + str(MsgParser.fieldArrayElementOffset(field))
param += ", idx"
ret = '''\
%s
<MSGSHORTNAME>.prototype.Set%s = function(%s)
{
%sthis.m_data.set%s(%s, %s%s);
};''' % (fnHdr(field), field["Name"], param, lookup, fieldType(field), loc, valueString, endian_string())
if MsgParser.fieldUnits(field) == "ASCII" and (field["Type"] == "uint8" or field["Type"] == "int8"):
ret += '''
%s
<MSGSHORTNAME>.prototype.Set%sString = function(value)
{
for(i=0; i<%s && i<value.length; i++)
{
this.Set%s(value[i].charCodeAt(0), i);
}
};''' % (fnHdr(field), field["Name"], str(MsgParser.fieldCount(field)), field["Name"])
return ret
def setFn(msg, field):
loc = msgName(msg) + ".MSG_OFFSET + " + str(MsgParser.fieldLocation(field))
count = MsgParser.fieldCount(field)
type = fieldType(field)
lookup = ""
if "Enum" in field:
# find index that corresponds to string input param
lookup = enumLookup(msg, field)
math = MsgParser.setMath("value", field, "int")
storageType = field["Type"]
if "int" in storageType:
math = "min(max(%s, %s), %s)" % (math, MsgParser.fieldStorageMin(storageType), MsgParser.fieldStorageMax(storageType))
math = lookup + "tmp = " + math
if count > 1:
if MsgParser.fieldUnits(field) == "ASCII" and (field["Type"] == "uint8" or field["Type"] == "int8"):
type = str(count) + "s"
count = 1
math = "tmp = value.encode('utf-8')"
else:
loc += "+idx*" + str(MsgParser.fieldArrayElementOffset(field))
ret = '''\
%s
%s
struct.pack_into('%s', self.rawBuffer(), %s, tmp)
''' % (fnHdr(field,MsgParser.fieldLocation(field),count, "Set"+field["Name"]), math, type, loc)
return ret
def getFn(msg, field):
loc = msgName(msg) + ".MSG_OFFSET + " + str(MsgParser.fieldLocation(field))
type = "'" + fieldType(field) + "'"
count = MsgParser.fieldCount(field)
cleanup = ""
preface = ""
if "Enum" in field:
# find index that corresponds to string input param
cleanup = reverseEnumLookup(msg, field)
if count > 1:
if MsgParser.fieldUnits(field) == "ASCII" and (
field["Type"] == "uint8" or field["Type"] == "int8"):
preface += "\n count = " + str(count) + "\n"
preface += " if count > len(self.rawBuffer())-(" + loc + "):\n"
preface += " count = len(self.rawBuffer())-(" + loc + ")\n"
type = "str(count)+'s'"
count = 1
cleanup = '''ascii_len = str(value).find("\\\\x00")
value = str(value)[2:ascii_len]
'''
else:
loc += "+idx*" + str(MsgParser.fieldArrayElementOffset(field))
if "Offset" in field or "Scale" in field:
cleanup = "value = " + MsgParser.getMath("value", field, "") + "\n "
ret = '''\
%s%s
value = struct.unpack_from(%s, self.rawBuffer(), %s)[0]
%sreturn value
''' % (fnHdr(field, MsgParser.fieldLocation(field), count,
"Get" + field["Name"]), preface, type, loc, cleanup)
return ret
def fieldReflection(field):
loc = str(MsgParser.fieldLocation(field))
params = "FieldInfo";
params += "("
params += '"'+field["Name"] + '"'
params += ', "' + MsgParser.fieldDescription(field) + '"'
params += ', "' + MsgParser.fieldUnits(field) + '"'
params += ", " + str(MsgParser.fieldCount(field))
params += ")"
return params
def fieldBitsReflection(field, bits, bitOffset, numBits):
loc = str(MsgParser.fieldLocation(field))
params = "FieldInfo";
params += "("
params += '"'+bits["Name"] + '"'
params += ', "' + MsgParser.fieldDescription(bits) + '"'
params += ', "' + MsgParser.fieldUnits(bits) + '"'
params += ", " + str(MsgParser.fieldCount(bits))
params += ")"
return params
def fieldReflection(field):
loc = str(MsgParser.fieldLocation(field))
params = "FieldInfo"
params += "("
params += '"' + field["Name"] + '"'
params += ', "' + MsgParser.fieldDescription(field) + '"'
params += ', "' + MsgParser.fieldUnits(field) + '"'
params += ", " + str(MsgParser.fieldCount(field))
params += ")"
return params
def fieldBitsReflection(field, bits, bitOffset, numBits):
loc = str(MsgParser.fieldLocation(field))
params = "FieldInfo"
params += "("
params += '"' + bits["Name"] + '"'
params += ', "' + MsgParser.fieldDescription(bits) + '"'
params += ', "' + MsgParser.fieldUnits(bits) + '"'
params += ", " + str(MsgParser.fieldCount(bits))
params += ")"
return params
def bitsReflectionInterfaceType(field):
type = "int"
if "Offset" in field or "Scale" in field:
type = "float"
elif MsgParser.fieldUnits(field) == "ASCII":
type = "string"
elif "Enum" in field:
type = "enumeration"
else:
type = "int"
return type
def genericInfo(field, loc, type):
params = ' public static final int loc = ' + loc + ';\n'
params += ' public static final %s max = (%s)%s;\n' % (type, type, fieldMax(field))
params += ' public static final %s min = (%s)%s;\n' % (type, type, fieldMin(field))
params += ' public static final String units = "' + str(MsgParser.fieldUnits(field)) + '"' + ';\n'
params += ' public static final int count = ' + str(MsgParser.fieldCount(field)) + ';\n'
if "Default" in field:
params += ' public static final %s defaultValue = (%s)%s;\n' % (type, type, languageConst(field["Default"]))
if "Scale" in field:
params += ' public static final float scale = (float)' + str(field["Scale"]) + ';\n'
if "Offset" in field:
params += ' public static final float offset = (float)' + str(field["Offset"]) + ';\n'
return params
def genericInfo(field, loc, type):
params = ' int static constexpr loc = ' + loc + ';\n'
params += ' '+type+' static constexpr max = ' + fieldMax(field) + ';\n'
params += ' '+type+' static constexpr min = ' + fieldMin(field) + ';\n'
params += ' char static constexpr units[] = "' + str(MsgParser.fieldUnits(field)) + '"' + ';\n'
params += ' int static constexpr count = ' + str(MsgParser.fieldCount(field)) + ';\n'
if "Default" in field:
params += ' '+type+' static constexpr defaultValue = ' + str(fieldDefault(field)) + ";\n"
if "Scale" in field:
params += ' auto static constexpr scale = ' + str(field["Scale"]) + ';\n'
if "Offset" in field:
params += ' auto static constexpr offset = ' + str(field["Offset"]) + ';\n'
return params
def genericInfo(field, loc, type):
params = ' static final int loc = ' + loc + ';\n'
params += ' static final '+type+' max = ' + fieldMax(field) + ';\n'
params += ' static final '+type+' min = ' + fieldMin(field) + ';\n'
params += ' static final String units = "' + str(MsgParser.fieldUnits(field)) + '"' + ';\n'
params += ' static final int count = ' + str(MsgParser.fieldCount(field)) + ';\n'
if "Default" in field:
params += ' static final '+type+' defaultValue = ' + str(field["Default"]) + ";\n"
if "Scale" in field:
params += ' static final int scale = ' + str(field["Scale"]) + ';\n'
if "Offset" in field:
params += ' static final int offset = ' + str(field["Offset"]) + ';\n'
return params
def genericInfo(field, loc, type):
params = ' const val loc = ' + loc + '\n'
params += ' val max = ' + str(fieldMax(field)) + '\n'
params += ' val min = ' + str(fieldMin(field)) + '\n'
params += ' const val units = "' + str(
MsgParser.fieldUnits(field)) + '"' + '\n'
params += ' const val count = ' + str(
MsgParser.fieldCount(field)) + '\n'
if "Default" in field:
params += ' const val ' + type + ' defaultValue = ' + str(
field["Default"]) + "\n"
if "Scale" in field:
params += ' const val scale = ' + str(field["Scale"]) + '\n'
if "Offset" in field:
params += ' const val offset = ' + str(field["Offset"]) + '\n'
return params
def bitfieldReflection(msg, field, bits):
name = bits["Name"]
ret = "{"+\
'name:"'+name + '",'+\
'type:"'+bitsReflectionInterfaceType(bits) + '",'+\
'units:"'+MsgParser.fieldUnits(bits) + '",'+\
'minVal:"'+str(MsgParser.fieldMin(bits)) + '",'+\
'maxVal:"'+str(MsgParser.fieldMax(bits)) + '",'+\
'description:"'+MsgParser.fieldDescription(bits) + '",'+\
'get:"Get' + name + '",'+\
'set:"Set' + name + '", '
if "Enum" in bits:
ret += "enumLookup : [<MSGSHORTNAME>."+ bits["Enum"]+", " + "<MSGSHORTNAME>.Reverse" + bits["Enum"]+"]}"
else:
ret += "enumLookup : []}"
return ret
def bitfieldReflection(msg, field, bits):
name = bits["Name"]
ret = "["+\
'"name":"'+name + '",'+\
'"type":"'+bitsReflectionInterfaceType(bits) + '",'+\
'"units":"'+MsgParser.fieldUnits(bits) + '",'+\
'"minVal":"'+str(MsgParser.fieldMin(bits)) + '",'+\
'"maxVal":"'+str(MsgParser.fieldMax(bits)) + '",'+\
'"description":"'+MsgParser.fieldDescription(bits) + '",'+\
'"get":"Get' + name + '",'+\
'"set":"Set' + name + '", '
if "Enum" in bits:
ret += '"enumLookup" : ['+ bits["Enum"]+"Enum, " + "Reverse" + bits["Enum"]+"Enum]]"
else:
ret += '"enumLookup" : []]'
return ret
def bitfieldReflection(msg, field, bits):
name = bits["Name"]
ret = "BitFieldInfo("+\
'name="'+name + '",'+\
'type="'+bitsReflectionInterfaceType(bits) + '",'+\
'units="'+MsgParser.fieldUnits(bits) + '",'+\
'minVal="'+str(MsgParser.fieldMin(bits)) + '",'+\
'maxVal="'+str(MsgParser.fieldMax(bits)) + '",'+\
'description="'+MsgParser.fieldDescription(bits) + '",'+\
'get='+"Get" + name + ','+\
'set='+"Set" + name + ', '
if "Enum" in bits:
ret += "enum = ["+ bits["Enum"]+", " + "Reverse" + bits["Enum"]+"])"
else:
ret += "enum = [])"
return ret
def bitfieldReflection(msg, field, bits):
name = bits["Name"]
ret = "BitFieldInfo("+\
'name="'+name + '",'+\
'type="'+bitsReflectionInterfaceType(bits) + '",'+\
'units="'+MsgParser.fieldUnits(bits) + '",'+\
'minVal="'+str(MsgParser.fieldMin(bits)) + '",'+\
'maxVal="'+str(MsgParser.fieldMax(bits)) + '",'+\
'description="'+MsgParser.fieldDescription(bits) + '",'+\
'get='+"Get" + name + ','+\
'set='+"Set" + name + ', '
if "IDBits" in bits:
ret += "idbits="+str(bits["IDBits"])+","
if "Enum" in bits:
ret += "enum = ["+ bits["Enum"]+", " + "Reverse" + bits["Enum"]+"])"
else:
ret += "enum = [])"
return ret
def genericInfo(field, loc, type):
params = ' public static final int loc = ' + loc + ';\n'
params += ' public static final %s max = (%s)%s;\n' % (type, type,
fieldMax(field))
params += ' public static final %s min = (%s)%s;\n' % (type, type,
fieldMin(field))
params += ' public static final String units = "' + str(
MsgParser.fieldUnits(field)) + '"' + ';\n'
params += ' public static final int count = ' + str(
MsgParser.fieldCount(field)) + ';\n'
if "Default" in field:
params += ' public static final %s defaultValue = (%s)%s;\n' % (
type, type, languageConst(field["Default"]))
if "Scale" in field:
params += ' public static final float scale = (float)' + str(
field["Scale"]) + ';\n'
if "Offset" in field:
params += ' public static final float offset = (float)' + str(
field["Offset"]) + ';\n'
return params
def genericInfo(field, loc, type):
params = ' int static constexpr loc = ' + loc + ';\n'
params += ' ' + type + ' static constexpr max = ' + fieldMax(
field) + ';\n'
params += ' ' + type + ' static constexpr min = ' + fieldMin(
field) + ';\n'
params += ' char static constexpr units[] = "' + str(
MsgParser.fieldUnits(field)) + '"' + ';\n'
params += ' int static constexpr count = ' + str(
MsgParser.fieldCount(field)) + ';\n'
if "Default" in field:
params += ' ' + type + ' static constexpr defaultValue = ' + str(
fieldDefault(field)) + ";\n"
if "Scale" in field:
params += ' auto static constexpr scale = ' + str(
field["Scale"]) + ';\n'
if "Offset" in field:
params += ' auto static constexpr offset = ' + str(
field["Offset"]) + ';\n'
return params
def genericInfo(field, fieldName, loc, fieldType):
params = 'static const int ' + fieldName + '_Loc = ' + loc + ';\n'
params += 'static const ' + fieldType + " " + fieldName + '_Max = ' + fieldMax(
field) + ';\n'
params += 'static const ' + fieldType + " " + fieldName + '_Min = ' + fieldMin(
field) + ';\n'
params += 'static const String ' + fieldName + "_Units = '" + str(
MsgParser.fieldUnits(field)) + "'" + ';\n'
params += 'static const int ' + fieldName + '_Count = ' + str(
MsgParser.fieldCount(field)) + ';\n'
if "Default" in field:
params += 'static const ' + fieldType + " " + fieldName + '_DefaultValue = ' + str(
fieldDefault(field)) + ";\n"
if "Scale" in field:
params += 'static const double ' + fieldName + '_Scale = ' + str(
field["Scale"]) + ';\n'
if "Offset" in field:
params += 'static const double ' + fieldName + '_Offset = ' + str(
field["Offset"]) + ';\n'
return params
def getFn(field):
loc = str(MsgParser.fieldLocation(field))
param = ""
if MsgParser.fieldCount(field) > 1:
loc += " + index*" + str(MsgParser.fieldArrayElementOffset(field))
param += "index: Int"
retType = fieldType(field)
if "Offset" in field or "Scale" in field:
retType = typeForScaledInt(field)
ret = '''\
%s
fun get%s(%s): %s {
''' % (fnHdr(field), field["Name"], param, retType)
access = "data.get%s(%s%s)" % (fieldType(field), loc, endian_string())
if ("Offset" in field or "Scale" in field):
ret += ' val valI : ' + fieldType(field) + ' = ' + access + '\n'
access = getMath("valI", field, "Double")
ret += ' val valD = ' + access + '\n'
ret += ' return valD\n'
else:
ret += ' return %s\n' % (access)
ret += '}'
if MsgParser.fieldUnits(field) == "ASCII" and MsgParser.fieldCount(
field) > 1 and (field["Type"] == "uint8"
or field["Type"] == "int8"):
ret += '''
%s
fun get%sString(): String {
var value = ""
for (i in 0 until minOf(%s, header.getDataLength().toInt() - %s)) {
val nextChar = get%s(i)
if (nextChar == 0.toUByte()) {
break
}
value += nextChar.toByte().toChar()
}
return value
}''' % (fnHdr(field), field["Name"], str(MsgParser.fieldCount(field)),
str(MsgParser.fieldLocation(field)), field["Name"])
return ret
def getFn(field, offset):
loc = str(offset)
param = ""
if MsgParser.fieldCount(field) > 1:
loc += "+idx*" + str(MsgParser.fieldSize(field))
param += "_ idx: Int"
ret = '''\
%s
public func Get%s(%s) -> %s
{
''' % (fnHdr(field), field["Name"], param, paramType(field))
access = "m_data.GetField(offset: %s)" % (loc)
if ("Offset" in field or "Scale" in field):
ret += ' let valI : ' + fieldType(field) + ' = ' + access + ';\n'
access = getMath("valI", field, "Double")
ret += ' let valD = ' + access + ';\n'
ret += ' return valD;\n'
else:
ret += ' return %s;\n' % (access)
ret += '};'
if MsgParser.fieldUnits(field) == "ASCII" and (field["Type"] == "uint8"
or field["Type"] == "int8"):
ret += '''
%s
public func Get%sString() -> String
{
var value = "";
for i in 0 ..< min(%s, hdr.GetDataLength()-%s)
{
let nextChar = Get%s(Int(i));
if(nextChar == 0)
{
break;
}
value += String(nextChar);
}
return value;
};''' % (fnHdr(field), field["Name"], str(
MsgParser.fieldCount(field)), offset, field["Name"])
return ret
def fieldReflection(field):
loc = str(MsgParser.fieldLocation(field))
type = fieldReflectionType(field)
params = type;
params += "("
params += '"'+field["Name"] + '"'
params += ', "' + MsgParser.fieldDescription(field) + '"'
params += ', "' + MsgParser.fieldUnits(field) + '"'
params += ", " + loc
params += ", " + str(MsgParser.fieldSize(field))
params += ", " + str(MsgParser.fieldCount(field))
if "Offset" in field or "Scale" in field:
if "Scale" in field:
params += ", " + str(field["Scale"])
else:
params += ", 1.0"
if "Offset" in field:
params += ", " + str(field["Offset"])
else:
params += ", 0.0"
params += ")"
return params
def structUnpacking(msg):
ret = []
if "Fields" in msg:
for field in msg["Fields"]:
if "Bitfields" in field:
for bits in field["Bitfields"]:
ret.append('try { ret["'+bits["Name"] + '"] = this.Get' + bits["Name"] + "(); } catch (err) {}")
else:
if MsgParser.fieldCount(field) == 1:
ret.append('try { ret["'+field["Name"] + '"] = this.Get' + field["Name"] + "(); } catch (err) {}")
else:
if MsgParser.fieldUnits(field) == "ASCII" and (field["Type"] == "uint8" or field["Type"] == "int8"):
ret.append('try { ret["'+field["Name"] + '"] = this.Get' + field["Name"] + "String(); } catch (err) {}")
else:
ret.append('try { ret["'+field["Name"] + '"] = []; } catch (err) {}')
ret.append('try { ')
ret.append(" for(i=0; i<"+str(MsgParser.fieldCount(field))+"; i++)")
ret.append(' ret["'+field["Name"] + '"][i] = this.Get' + field["Name"] + "(i);")
ret.append('} catch (err) {}')
return "\n".join(ret)
def fieldReflection(field, offset):
loc = str(offset)
type = fieldReflectionType(field)
params = type
params += "("
params += '"' + field["Name"] + '"'
params += ', "' + MsgParser.fieldDescription(field) + '"'
params += ', "' + MsgParser.fieldUnits(field) + '"'
params += ", " + loc
params += ", " + str(MsgParser.fieldSize(field))
params += ", " + str(MsgParser.fieldCount(field))
if "Offset" in field or "Scale" in field:
if "Scale" in field:
params += ", " + str(field["Scale"])
else:
params += ", 1.0"
if "Offset" in field:
params += ", " + str(field["Offset"])
else:
params += ", 0.0"
params += ")"
return params
def getFn(field):
loc = str(MsgParser.fieldLocation(field))
param = ""
if MsgParser.fieldCount(field) > 1:
loc += "+idx*" + str(MsgParser.fieldArrayElementOffset(field))
param += "_ idx: Int"
ret = '''\
%s
public func Get%s(%s) -> %s
{
''' % (fnHdr(field), field["Name"], param, paramType(field))
access = "m_data.GetField(offset: %s)" % (loc)
if ("Offset" in field or "Scale" in field):
ret += ' let valI : '+fieldType(field)+' = '+access+';\n'
access = getMath("valI", field, "Double")
ret += ' let valD = '+access+';\n'
ret += ' return valD;\n'
else:
ret += ' return %s;\n' % (access)
ret += '};'
if MsgParser.fieldUnits(field) == "ASCII" and (field["Type"] == "uint8" or field["Type"] == "int8"):
ret += '''
%s
public func Get%sString() -> String
{
var value = "";
for i in 0 ..< min(%s, hdr.GetDataLength()-%s)
{
let nextChar = Get%s(Int(i));
if(nextChar == 0)
{
break;
}
value += String(nextChar);
}
return value;
};''' % (fnHdr(field), field["Name"], str(MsgParser.fieldCount(field)), str(MsgParser.fieldLocation(field)), field["Name"])
return ret
def getFn(field):
loc = str(MsgParser.fieldLocation(field))
param = ""
if MsgParser.fieldCount(field) > 1:
loc += "+idx*" + str(MsgParser.fieldArrayElementOffset(field))
param += "idx"
if "Enum" in field:
if param != "":
param += ", "
param += "enumAsInt=false"
access = "(this.m_data.get%s(%s%s))" % (fieldType(field), loc, endian_string())
access = getMath(access, field, "")
cleanup = ""
if "Enum" in field:
cleanup = reverseEnumLookup(field)
ret = '''\
%s
<MSGSHORTNAME>.prototype.Get%s = function(%s)
{
var value = %s;
%sreturn value;
};''' % (fnHdr(field), field["Name"], param, access, cleanup)
if MsgParser.fieldUnits(field) == "ASCII" and (field["Type"] == "uint8" or field["Type"] == "int8"):
ret += '''
%s
<MSGSHORTNAME>.prototype.Get%sString = function()
{
var value = '';
for(i=0; i<%s && i<this.hdr.GetDataLength()-%s; i++)
{
nextChar = String.fromCharCode(this.Get%s(i));
if(nextChar == '\\0')
break;
value += nextChar;
}
return value;
};''' % (fnHdr(field), field["Name"], str(MsgParser.fieldCount(field)), str(MsgParser.fieldLocation(field)), field["Name"])
return ret
def getFn(field, offset):
loc = str(offset)
param = ""
if MsgParser.fieldCount(field) > 1:
loc += "+idx*" + str(MsgParser.fieldSize(field))
param += "int idx"
access = "_data.get%s(%s)" % (fieldType(field), loc)
access = getMath(access, field)
retType = returnType(field, None)
#elif "Enum" in field:
# retType = field["Enum"]
# access = retType + "(" + access + ")"
ret = '''\
%s
%s Get%s(%s)
{
return %s;
}''' % (fnHdr(field), retType, field["Name"], param, access)
if MsgParser.fieldUnits(field) == "ASCII" and (field["Type"] == "uint8"
or field["Type"] == "int8"):
ret += '''
%s
String Get%sString()
{
final StringBuffer ret = new StringBuffer();
for(int i=0; i<%s && i<_hdr.GetDataLength()-%s; i++)
{
final String nextChar = new String.fromCharCode(Get%s(i));
if(nextChar == '\\0')
break;
ret.write(nextChar);
}
return ret.toString();
}''' % (fnHdr(field), field["Name"], str(
MsgParser.fieldCount(field)), offset, field["Name"])
return ret
def fieldBitsReflection(field, bits, bitOffset, numBits):
loc = str(MsgParser.fieldLocation(field))
type = fieldReflectionBitsType(field, bits)
params = type;
params += "("
params += '"'+bits["Name"] + '"'
params += ', "' + MsgParser.fieldDescription(bits) + '"'
params += ', "' + MsgParser.fieldUnits(bits) + '"'
params += ", " + loc
params += ", " + str(MsgParser.fieldSize(field))
params += ", " + str(MsgParser.fieldCount(bits))
if "Offset" in bits or "Scale" in bits:
if "Scale" in bits:
params += ", " + str(bits["Scale"])
else:
params += ", 1.0"
if "Offset" in bits:
params += ", " + str(bits["Offset"])
else:
params += ", 0.0"
params += ", " + str(bitOffset)
params += ", " + str(numBits)
params += ")"
return params
def fieldBitsReflection(field, bits, offset, bitOffset, numBits):
loc = str(offset)
type = fieldReflectionBitsType(field, bits)
params = type
params += "("
params += '"' + bits["Name"] + '"'
params += ', "' + MsgParser.fieldDescription(bits) + '"'
params += ', "' + MsgParser.fieldUnits(bits) + '"'
params += ", " + loc
params += ", " + str(MsgParser.fieldSize(field))
params += ", " + str(MsgParser.fieldCount(bits))
if "Offset" in bits or "Scale" in bits:
if "Scale" in bits:
params += ", " + str(bits["Scale"])
else:
params += ", 1.0"
if "Offset" in bits:
params += ", " + str(bits["Offset"])
else:
params += ", 0.0"
params += ", " + str(bitOffset)
params += ", " + str(numBits)
params += ")"
return params
def fnHdr(field):
ret = "// %s %s, (%s to %s)" % (MsgParser.fieldDescription(field), MsgParser.fieldUnits(field), MsgParser.fieldMin(field), MsgParser.fieldMax(field))
return ret
def pythonFieldCount(field):
count = MsgParser.fieldCount(field)
if MsgParser.fieldUnits(field) == "ASCII" and (field["Type"] == "uint8"
or field["Type"] == "int8"):
count = 1
return count
def pythonFieldCount(field):
count = MsgParser.fieldCount(field)
if MsgParser.fieldUnits(field) == "ASCII" and (field["Type"] == "uint8" or field["Type"] == "int8"):
count = 1
return count
