def arrayAccessor(field):
# if we've got floating point conversion, don't do an array accessor
if "Offset" in field or "Scale" in field:
return ""
# if we're not an array, don't do an array accessor
if MsgParser.fieldCount(field) == 1:
return ""
# if we're not contiguous, don't do an array accessor
if MsgParser.fieldSize(field) != MsgParser.fieldArrayElementOffset(field):
return ""
# if we don't have natural alignment, don't do an array accessor
if MsgParser.fieldLocation(field) % MsgParser.fieldSize(field) != 0:
return ""
loc = str(MsgParser.fieldLocation(field))
access = "(%s*)&m_data[%s]" % (fieldType(field), loc)
ret = '''\
%s
%s* %s(%s)
{
return %s;
}''' % (fnHdr(field), functionPrefix+fieldType(field), namespace+field["Name"], firstParamDecl, access)
if MsgParser.fieldSize(field) != 1:
if MsgParser.big_endian:
ret = "#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ \n" + ret + "\n#endif\n"
else:
ret = "#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ \n" + ret + "\n#endif\n"
return ret
def setFn(msg, field):
valueString = setMath("value", field, fieldType(field))
loc = str(1+MsgParser.fieldLocation(field))
end_loc = str(1+MsgParser.fieldLocation(field) + MsgParser.fieldSize(field)*MsgParser.fieldCount(field)-1)
asInt = ""
if "Enum" in field:
asInt = "AsInt"
ret = '''\
%s
function obj = set.%s%s(obj, value)
''' % (fnHdr(field), matlabFieldName(msg,field), asInt)
if MsgParser.big_endian:
swap = "swapbytes"
else:
swap = ""
ret += '''\
obj.m_data(%s:%s) = typecast(%s(%s(%s)), 'uint8');
end
''' % (loc, end_loc, swap, fieldType(field), valueString)
if "Enum" in field:
ret += '''\
%s
function obj = set.%s(obj, value)
''' % (fnHdr(field), matlabFieldName(msg,field))
ret += " if isKey(obj.Reverse"+field["Enum"]+"Enum, value)\n"
ret += " value = obj.Reverse"+field["Enum"]+"Enum(value);\n"
ret += " end\n"
ret += " obj."+matlabFieldName(msg,field)+"AsInt = value;\n"
ret += "end\n"
# Need to handle arrays of structs, where elements of array are not contiguous!
if MsgParser.fieldSize(field) != MsgParser.fieldArrayElementOffset(field):
ret = "ERROR! Need to handle arrays of structs, where elements of array are not contiguous!\n" + ret
return ret
def setFn(msg, field):
valueString = setMath("value", field, fieldType(field))
loc = str(1 + MsgParser.fieldLocation(field))
end_loc = str(1 + MsgParser.fieldLocation(field) +
MsgParser.fieldSize(field) * MsgParser.fieldCount(field) - 1)
asInt = ""
if "Enum" in field:
asInt = "AsInt"
ret = '''\
%s
function obj = set.%s%s(obj, value)
''' % (fnHdr(field), matlabFieldName(msg, field), asInt)
if MsgParser.big_endian:
swap = "swapbytes"
else:
swap = ""
ret += '''\
obj.m_data(%s:%s) = typecast(%s(%s(%s)), 'uint8');
end
''' % (loc, end_loc, swap, fieldType(field), valueString)
if "Enum" in field:
ret += '''\
%s
function obj = set.%s(obj, value)
''' % (fnHdr(field), matlabFieldName(msg, field))
ret += " if isKey(obj.Reverse" + field["Enum"] + "Enum, value)\n"
ret += " value = obj.Reverse" + field["Enum"] + "Enum(value);\n"
ret += " end\n"
ret += " obj." + matlabFieldName(msg, field) + "AsInt = value;\n"
ret += "end\n"
# Need to handle arrays of structs, where elements of array are not contiguous!
if MsgParser.fieldSize(field) != MsgParser.fieldArrayElementOffset(field):
ret = "ERROR! Need to handle arrays of structs, where elements of array are not contiguous!\n" + ret
return ret
def arrayAccessor(field):
# if we've got floating point conversion, don't do an array accessor
if "Offset" in field or "Scale" in field:
return ""
# if we're not an array, don't do an array accessor
if MsgParser.fieldCount(field) == 1:
return ""
# if we're not contiguous, don't do an array accessor
if MsgParser.fieldSize(field) != MsgParser.fieldArrayElementOffset(field):
return ""
# if we don't have natural alignment, don't do an array accessor
if MsgParser.fieldLocation(field) % MsgParser.fieldSize(field) != 0:
return ""
loc = str(MsgParser.fieldLocation(field))
access = "(%s*)&m_data[%s]" % (fieldType(field), loc)
ret = '''\
%s
%s* %s(%s)
{
return %s;
}''' % (fnHdr(field), functionPrefix + fieldType(field),
namespace + field["Name"], firstParamDecl, access)
if MsgParser.fieldSize(field) != 1:
if MsgParser.big_endian:
ret = "#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ \n" + ret + "\n#endif\n"
else:
ret = "#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ \n" + ret + "\n#endif\n"
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 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 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 = str(1+MsgParser.fieldLocation(field))
end_loc = str(1+MsgParser.fieldLocation(field) + MsgParser.fieldSize(field)*MsgParser.fieldCount(field)-1)
param = "obj"
access = "typecast(obj.m_data(%s:%s), '%s')" % (loc, end_loc, fieldType(field))
if MsgParser.big_endian:
access = "swapbytes(%s)" % access
access = getMath(access, field, typeForScaledInt(field))
retType = fieldType(field)
if "Offset" in field or "Scale" in field:
retType = typeForScaledInt(field)
asInt = ""
if "Enum" in field:
asInt = "AsInt"
ret = '''\
%s
function ret = get.%s%s(%s)
ret = %s;
end
''' % (fnHdr(field), matlabFieldName(msg,field), asInt, param, access)
if "Enum" in field:
ret += '''\
%s
function ret = get.%s(%s)
ret = obj.%sAsInt;
''' % (fnHdr(field), matlabFieldName(msg,field), param, matlabFieldName(msg,field))
ret += " if isKey(obj."+field["Enum"]+"Enum, ret)\n"
ret += " ret = obj."+field["Enum"]+"Enum(ret);\n"
ret += " end\n"
ret += "end\n"
# Need to handle arrays of structs, where elements of array are not contiguous!
if MsgParser.fieldSize(field) != MsgParser.fieldArrayElementOffset(field):
ret = "ERROR! Need to handle arrays of structs, where elements of array are not contiguous!\n" + ret
return ret
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(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 setFn(field):
paramType = returnType(field, None)
valueString = setMath("value", field)
#if "Enum" in field:
# valueString = paramType + "(" + valueString + ")"
# paramType = field["Enum"]
param = paramType + " value"
loc = str(MsgParser.fieldLocation(field))
if MsgParser.fieldCount(field) > 1:
loc += "+idx*" + str(MsgParser.fieldArrayElementOffset(field))
param += ", int idx"
ret = '''\
%s
void Set%s(%s)
{
_data.set%s(%s, %s%s);
}''' % (fnHdr(field), field["Name"], param, fieldType(field), loc, valueString,
endian_string())
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 fieldBitsInfo(field, bits, bitOffset, numBits):
params = genericInfo(bits, MsgParser.BitfieldName(field, bits),
str(MsgParser.fieldLocation(field)),
returnType(field, bits))
params += 'static const int ' + MsgParser.BitfieldName(
field, bits) + '_BitOffset = ' + str(bitOffset) + ';\n'
params += 'static const int ' + MsgParser.BitfieldName(
field, bits) + '_NumBits = ' + str(numBits) + ';\n'
return params
def fieldInfo(field):
ret = ""
if "Default" in field:
ret += '#define <MSGNAME>_'+field["Name"]+'_DEFAULT ' + str(fieldDefault(field)) + "\n"
if MsgParser.fieldCount(field) > 1:
ret += '#define <MSGNAME>_'+field["Name"]+'_COUNT ' + str(MsgParser.fieldCount(field)) + "\n"
ret += '#define <MSGNAME>_'+field["Name"]+'_OFFSET ' + str(MsgParser.fieldLocation(field)) + "\n"
ret += '#define <MSGNAME>_'+field["Name"]+'_SIZE ' + str(MsgParser.fieldSize(field)) + "\n"
return ret
def fieldInfo(field):
retType = fieldType(field)
if "Offset" in field or "Scale" in field:
retType = typeForScaledInt(field)
params = 'class ' + field["Name"] + 'FieldInfo {\n'
params += genericInfo(field, str(MsgParser.fieldLocation(field)), retType)
params += '};\n'
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 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 fieldBitsInfo(field, bits, bitOffset, numBits):
retType = fieldType(field)
if "Offset" in bits or "Scale" in bits:
retType = typeForScaledInt(bits)
params = 'class ' + bits["Name"] + 'FieldInfo {\n'
params += genericInfo(bits, str(MsgParser.fieldLocation(field)), retType)
params += ' static final int bitOffset = ' + str(bitOffset) + ';\n'
params += ' static final int numBits = ' + str(numBits) + ';\n'
params += '};\n'
return params
def fieldBitsInfo(field, bits, bitOffset, numBits):
retType = fieldType(field)
if "Offset" in bits or "Scale" in bits:
retType = typeForScaledInt(bits)
params = 'object ' + bits["Name"] + 'FieldInfo {\n'
params += genericInfo(bits, str(MsgParser.fieldLocation(field)), retType)
params += ' const val bitOffset = ' + str(bitOffset) + '\n'
params += ' const val numBits = ' + str(numBits) + '\n'
params += '}\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 fieldInfo(field):
ret = ""
if "Default" in field:
ret += '#define <MSGNAME>_' + field["Name"] + '_DEFAULT ' + str(
fieldDefault(field)) + "\n"
if MsgParser.fieldCount(field) > 1:
ret += '#define <MSGNAME>_' + field["Name"] + '_COUNT ' + str(
MsgParser.fieldCount(field)) + "\n"
ret += '#define <MSGNAME>_' + field["Name"] + '_OFFSET ' + str(
MsgParser.fieldLocation(field)) + "\n"
ret += '#define <MSGNAME>_' + field["Name"] + '_SIZE ' + str(
MsgParser.fieldSize(field)) + "\n"
return ret
def setBitsFn(msg, field, bits, bitOffset, numBits):
lookup = ""
if "Enum" in bits:
# find index that corresponds to string input param
lookup = enumLookup(msg, bits)
math = "min(max(%s, %s), %s)" % (MsgParser.setMath("value", bits, "int"), 0, str(2**numBits-1))
math = lookup + "tmp = " + math
ret = '''\
%s
%s
self.Set%s((self.Get%s() & ~(%s << %s)) | ((%s & %s) << %s))
''' % (fnHdr(bits,MsgParser.fieldLocation(field),1,"Set"+MsgParser.BitfieldName(field, bits)), math, field["Name"], field["Name"], MsgParser.Mask(numBits), str(bitOffset), "tmp", MsgParser.Mask(numBits), str(bitOffset))
return ret
def getBitsFn(msg, field, bits, bitOffset, numBits):
access = "(self.Get%s() >> %s) & %s" % (field["Name"], str(bitOffset), MsgParser.Mask(numBits))
access = MsgParser.getMath(access, bits, "float")
cleanup = ""
if "Enum" in bits:
# find index that corresponds to string input param
cleanup = reverseEnumLookup(msg, bits)
ret = '''\
%s
value = %s
%sreturn value
''' % (fnHdr(bits,MsgParser.fieldLocation(field),1,"Get"+MsgParser.BitfieldName(field, bits)), access, cleanup)
return ret
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(msg, field):
loc = str(1 + MsgParser.fieldLocation(field))
end_loc = str(1 + MsgParser.fieldLocation(field) +
MsgParser.fieldSize(field) * MsgParser.fieldCount(field) - 1)
param = "obj"
access = "typecast(obj.m_data(%s:%s), '%s')" % (loc, end_loc,
fieldType(field))
if MsgParser.big_endian:
access = "swapbytes(%s)" % access
access = getMath(access, field, typeForScaledInt(field))
retType = fieldType(field)
if "Offset" in field or "Scale" in field:
retType = typeForScaledInt(field)
asInt = ""
if "Enum" in field:
asInt = "AsInt"
ret = '''\
%s
function ret = get.%s%s(%s)
ret = %s;
end
''' % (fnHdr(field), matlabFieldName(msg, field), asInt, param, access)
if "Enum" in field:
ret += '''\
%s
function ret = get.%s(%s)
ret = obj.%sAsInt;
''' % (fnHdr(field), matlabFieldName(
msg, field), param, matlabFieldName(msg, field))
ret += " if isKey(obj." + field["Enum"] + "Enum, ret)\n"
ret += " ret = obj." + field["Enum"] + "Enum(ret);\n"
ret += " end\n"
ret += "end\n"
# Need to handle arrays of structs, where elements of array are not contiguous!
if MsgParser.fieldSize(field) != MsgParser.fieldArrayElementOffset(field):
ret = "ERROR! Need to handle arrays of structs, where elements of array are not contiguous!\n" + ret
return ret
def getFn(field):
loc = str(MsgParser.fieldLocation(field))
param = ""
if MsgParser.fieldCount(field) > 1:
loc += "+idx*" + str(MsgParser.fieldArrayElementOffset(field))
param += "int idx"
access = "_data.get%s(%s%s)" % (fieldType(field), loc, endian_string())
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)),
str(MsgParser.fieldLocation(field)), field["Name"])
return ret
def getBitsFn(msg, field, bits, bitOffset, numBits):
access = "(self.Get%s() >> %s) & %s" % (field["Name"], str(bitOffset),
MsgParser.Mask(numBits))
access = MsgParser.getMath(access, bits, "float")
cleanup = ""
if "Enum" in bits:
# find index that corresponds to string input param
cleanup = reverseEnumLookup(msg, bits)
ret = '''\
%s
value = %s
%sreturn value
''' % (fnHdr(bits, MsgParser.fieldLocation(field), 1,
"Get" + MsgParser.BitfieldName(field, bits)), access, cleanup)
return ret
def setBitsFn(msg, field, bits, bitOffset, numBits):
lookup = ""
if "Enum" in bits:
# find index that corresponds to string input param
lookup = enumLookup(msg, bits)
math = "min(max(%s, %s), %s)" % (MsgParser.setMath(
"value", bits, "int"), 0, str(2**numBits - 1))
math = lookup + "tmp = " + math
ret = '''\
%s
%s
self.Set%s((self.Get%s() & ~(%s << %s)) | ((%s & %s) << %s))
''' % (fnHdr(bits, MsgParser.fieldLocation(field), 1,
"Set" + MsgParser.BitfieldName(field, bits)), math, field["Name"],
field["Name"], MsgParser.Mask(numBits), str(bitOffset), "tmp",
MsgParser.Mask(numBits), str(bitOffset))
return ret
def setFn(field):
paramType = fieldType(field)
if "Offset" in field or "Scale" in field:
paramType = typeForScaledInt(field)
valueString = setMath("value", field, fieldType(field))
param = "value: " + paramType
loc = str(MsgParser.fieldLocation(field))
if MsgParser.fieldCount(field) > 1:
loc += " + index*" + str(MsgParser.fieldArrayElementOffset(field))
param += ", index: Int"
ret = '''\
%s
fun set%s(%s) {
data.put%s(%s, %s%s)
}''' % (fnHdr(field), field["Name"], param, fieldType(field), loc, valueString,
endian_string())
return ret
def setFn(field):
paramType = fieldType(field)
valueString = setMath("value", field, '('+fieldType(field)+')', 'f')
if "Offset" in field or "Scale" in field:
paramType = typeForScaledInt(field)
#elif "Enum" in field:
# valueString = valueString + ".intValue()"
# paramType = field["Enum"]
param = paramType + " value"
loc = str(MsgParser.fieldLocation(field))
if MsgParser.fieldCount(field) > 1:
loc += "+idx*" + str(MsgParser.fieldArrayElementOffset(field))
param += ", int idx"
ret = '''\
%s
public void Set%s(%s)
{
m_data.put%s(%s, (%s)%s);
}''' % (fnHdr(field), field["Name"], param, fieldAccessorType(field), loc, fieldCastType(field).lower(), valueString)
return ret
def setFn(field):
paramType = fieldType(field)
valueString = setMath("value", field, '(' + fieldType(field) + ')', 'f')
if "Offset" in field or "Scale" in field:
paramType = typeForScaledInt(field)
#elif "Enum" in field:
# valueString = valueString + ".intValue()"
# paramType = field["Enum"]
param = paramType + " value"
loc = str(MsgParser.fieldLocation(field))
if MsgParser.fieldCount(field) > 1:
loc += "+idx*" + str(MsgParser.fieldArrayElementOffset(field))
param += ", int idx"
ret = '''\
%s
public void Set%s(%s)
{
m_data.put%s(%s, (%s)%s);
}''' % (fnHdr(field), field["Name"], param, fieldAccessorType(field), loc,
fieldCastType(field).lower(), valueString)
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 setFn(field):
paramType = fieldType(field)
valueString = setMath("value", field, "("+fieldType(field)+")", 'f')
if "Offset" in field or "Scale" in field:
paramType = typeForScaledInt(field)
elif "Enum" in field and namespace == "":
valueString = "("+paramType+")" + "(" + valueString + ")"
paramType = namespace+field["Enum"]
param = paramType + " value"
loc = str(MsgParser.fieldLocation(field))
if MsgParser.fieldCount(field) > 1:
loc += "+idx*" + str(MsgParser.fieldArrayElementOffset(field))
param += ", int idx"
ret = '''\
%s
%s %s(%s)
{
Set_%s(&m_data[%s], %s);
}''' % (fnHdr(field), functionPrefix+"void", namespace+"Set"+field["Name"], params(firstParamDecl, param), fieldType(field), loc, valueString)
if "float" in paramType or "double" in paramType:
ret = "#ifndef DISABLE_FLOAT_ACCESSORS\n" + ret + "\n#endif\n"
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 getFn(field):
loc = str(MsgParser.fieldLocation(field))
param = ""
if MsgParser.fieldCount(field) > 1:
loc += "+idx*" + str(MsgParser.fieldArrayElementOffset(field))
param += "int idx"
access = "Get_%s(&m_data[%s])" % (fieldType(field), loc)
access = getMath(access, field, castForScaledInt(field), 'f')
retType = fieldType(field)
if "Offset" in field or "Scale" in field:
retType = typeForScaledInt(field)
elif "Enum" in field and namespace == "":
retType = namespace+field["Enum"]
access = retType + "(" + access + ")"
ret = '''\
%s
%s %s(%s)%s
{
return %s;
}''' % (fnHdr(field), functionPrefix+retType, namespace+"Get"+field["Name"], params(firstParamDecl, param), const, access)
if "float" in retType or "double" in retType:
ret = "#ifndef DISABLE_FLOAT_ACCESSORS\n" + ret + "\n#endif\n"
return ret
def setFn(field):
paramType = fieldType(field)
valueString = setMath("value", field, "(" + fieldType(field) + ")", 'f')
if "Offset" in field or "Scale" in field:
paramType = typeForScaledInt(field)
elif "Enum" in field and namespace == "":
valueString = "(" + paramType + ")" + "(" + valueString + ")"
paramType = namespace + field["Enum"]
param = paramType + " value"
loc = str(MsgParser.fieldLocation(field))
if MsgParser.fieldCount(field) > 1:
loc += "+idx*" + str(MsgParser.fieldArrayElementOffset(field))
param += ", int idx"
ret = '''\
%s
%s %s(%s)
{
Set_%s(&m_data[%s], %s);
}''' % (fnHdr(field), functionPrefix + "void",
namespace + "Set" + field["Name"], params(
firstParamDecl, param), fieldType(field), loc, valueString)
if "float" in paramType or "double" in paramType:
ret = "#ifndef DISABLE_FLOAT_ACCESSORS\n" + ret + "\n#endif\n"
return ret
def getFn(field):
loc = str(MsgParser.fieldLocation(field))
param = ""
if MsgParser.fieldCount(field) > 1:
loc += "+idx*" + str(MsgParser.fieldArrayElementOffset(field))
param += "int idx"
access = "Get_%s(&m_data[%s])" % (fieldType(field), loc)
access = getMath(access, field, castForScaledInt(field), 'f')
retType = fieldType(field)
if "Offset" in field or "Scale" in field:
retType = typeForScaledInt(field)
elif "Enum" in field and namespace == "":
retType = namespace + field["Enum"]
access = retType + "(" + access + ")"
ret = '''\
%s
%s %s(%s)%s
{
return %s;
}''' % (fnHdr(field), functionPrefix + retType, namespace + "Get" +
field["Name"], params(firstParamDecl, param), const, access)
if "float" in retType or "double" in retType:
ret = "#ifndef DISABLE_FLOAT_ACCESSORS\n" + ret + "\n#endif\n"
return ret
def getFn(field):
loc = str(MsgParser.fieldLocation(field))
param = ""
if MsgParser.fieldCount(field) > 1:
loc += "+idx*" + str(MsgParser.fieldArrayElementOffset(field))
param += "int idx"
access = "m_data.get%s(%s)" % (fieldAccessorType(field), loc)
if field["Type"].startswith("u"):
access = fieldPromotionFn(field)+"("+access+")"
access = "("+fieldType(field)+")"+access
access = getMath(access, field, "("+typeForScaledInt(field)+")", 'f')
retType = fieldType(field)
if "Offset" in field or "Scale" in field:
retType = typeForScaledInt(field)
#elif "Enum" in field:
# retType = field["Enum"]
# access = retType + ".construct(" + access + ")"
ret = '''\
%s
public %s Get%s(%s)
{
return %s;
}''' % (fnHdr(field), retType, field["Name"], param, access)
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, 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 getFn(field):
loc = str(MsgParser.fieldLocation(field))
param = ""
if MsgParser.fieldCount(field) > 1:
loc += "+idx*" + str(MsgParser.fieldArrayElementOffset(field))
param += "int idx"
access = "m_data.get%s(%s)" % (fieldAccessorType(field), loc)
if field["Type"].startswith("u"):
access = fieldPromotionFn(field) + "(" + access + ")"
access = "(" + fieldType(field) + ")" + access
access = getMath(access, field, "(" + typeForScaledInt(field) + ")", 'f')
retType = fieldType(field)
if "Offset" in field or "Scale" in field:
retType = typeForScaledInt(field)
#elif "Enum" in field:
# retType = field["Enum"]
# access = retType + ".construct(" + access + ")"
ret = '''\
%s
public %s Get%s(%s)
{
return %s;
}''' % (fnHdr(field), retType, field["Name"], param, access)
return ret
def fieldInfo(field):
params = genericInfo(field, field["Name"],
str(MsgParser.fieldLocation(field)),
returnType(field, None))
return params
