def getBitsFn(msg, field, bits, offset, bitOffset, numBits):
access = "bitand(bitshift(obj.%s, -%s), %s)" % (matlabFieldName(
msg, field), str(bitOffset), Mask(numBits))
access = getMath(access, bits, typeForScaledInt(bits))
retType = fieldType(field)
if "Offset" in bits or "Scale" in bits:
retType = typeForScaledInt(bits)
asInt = ""
if "Enum" in bits:
asInt = "AsInt"
ret = '''\
%s
function ret = get.%s%s(obj)
ret = %s;
end
''' % (fnHdr(bits), MsgParser.BitfieldName(field, bits), asInt, access)
if "Enum" in bits:
ret += '''\
%s
function ret = get.%s(obj)
ret = obj.%sAsInt;
''' % (fnHdr(bits), MsgParser.BitfieldName(
field, bits), MsgParser.BitfieldName(field, bits))
ret += " if isKey(obj." + bits["Enum"] + "Enum, ret)\n"
ret += " ret = obj." + bits["Enum"] + "Enum(ret);\n"
ret += " end\n"
ret += "end\n"
return ret
def setBitsFn(msg, field, bits, offset, bitOffset, numBits):
paramType = fieldType(field)
valueString = setMath("value", bits, fieldType(field))
if "Offset" in bits or "Scale" in bits:
paramType = typeForScaledInt(bits)
asInt = ""
if "Enum" in bits:
asInt = "AsInt"
ret = '''\
%s
function obj = set.%s%s(obj, value)
''' % (fnHdr(bits), MsgParser.BitfieldName(field, bits), asInt)
ret += '''\
obj.%s = bitor(bitand(obj.%s, bitcmp(bitshift(%s(%s),%s))), (bitshift((bitand(%s, %s)), %s)));
end''' % (matlabFieldName(msg, field), matlabFieldName(
msg, field), fieldType(field), Mask(numBits), str(bitOffset),
valueString, Mask(numBits), str(bitOffset))
if "Enum" in bits:
ret += '''\
%s
function obj = set.%s(obj, value)
''' % (fnHdr(bits), MsgParser.BitfieldName(field, bits))
ret += " if isKey(obj.Reverse" + bits["Enum"] + "Enum, value)\n"
ret += " value = obj.Reverse" + bits["Enum"] + "Enum(value);\n"
ret += " end\n"
ret += " obj." + MsgParser.BitfieldName(field,
bits) + "AsInt = value;\n"
ret += "end\n"
return ret
def fieldBitsInfo(field, bits, offset, bitOffset, numBits):
params = genericInfo(bits, offset, MsgParser.BitfieldName(field, bits),
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 initBitfield(field, bits):
paramType = fieldType(field)
if "Offset" in bits or "Scale" in bits:
paramType = typeForScaledInt(bits)
defaultValue = paramType + "(" + fieldDefault(bits) + ")"
return "obj." + MsgParser.BitfieldName(field,
bits) + " = " + defaultValue + ";"
def setBitsFn(field, bits, bitOffset, numBits):
valueString = setMath("value", bits, "")
lookup = ""
if "Enum" in bits:
# find index that corresponds to string input param
lookup = enumLookup(bits)
ret = '''\
%s
<MSGSHORTNAME>.prototype.Set%s = function(value)
{
%sthis.Set%s((this.Get%s() & ~(%s * 2**%s)) | ((%s & %s) * 2**%s));
};''' % (fnHdr(bits), MsgParser.BitfieldName(field, bits), lookup, field["Name"], field["Name"], MsgParser.Mask(numBits), str(bitOffset), valueString, MsgParser.Mask(numBits), str(bitOffset))
return ret
def getBitsFn(msg, field, bits, offset, 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,offset,1,"Get"+MsgParser.BitfieldName(field, bits)), access, cleanup)
return ret
def setBitsFn(msg, field, bits, offset, 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,offset,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(field, bits, offset, bitOffset, numBits):
access = "(Get%s() >> %s) & %s" % (field["Name"], str(bitOffset),
MsgParser.Mask(numBits))
access = getMath(access, bits)
retType = returnType(field, bits)
#if "Enum" in bits:
# retType = bits["Enum"]
# access = retType + "(" + access + ")"
ret = '''\
%s
%s Get%s()
{
return %s;
}''' % (fnHdr(bits), retType, MsgParser.BitfieldName(field, bits), access)
return ret
def setBitsFn(field, bits, bitOffset, numBits):
param = "_ value: " + bitParamType(field, bits)
ret = '''\
%s
public func Set%s(%s)
{
''' % (fnHdr(bits), MsgParser.BitfieldName(field, bits), param)
valueString = setMath("value", bits, fieldType(field))
ret += '''\
var valI = Get%s(); // read
valI = valI & ~(%s << %s); // clear our bits
valI = valI | ((%s & %s) << %s); // set our bits
Set%s(valI); // write
''' % (field["Name"], MsgParser.Mask(numBits), str(bitOffset), valueString, MsgParser.Mask(numBits), str(bitOffset), field["Name"])
ret += '};'
return ret
def getBitsFn(field, bits, bitOffset, numBits):
access = "(this.Get%s() / 2**%s) & %s" % (field["Name"], str(bitOffset), MsgParser.Mask(numBits))
access = getMath(access, bits, "")
param = ""
if "Enum" in bits:
param += "enumAsInt=false"
cleanup = ""
if "Enum" in bits:
cleanup = reverseEnumLookup(bits)
ret = '''\
%s
<MSGSHORTNAME>.prototype.Get%s = function(%s)
{
var value = %s;
%sreturn value;
};''' % (fnHdr(bits), MsgParser.BitfieldName(field, bits), param, access, cleanup)
return ret
def getBitsFn(field, bits, bitOffset, numBits):
access = "(Get%s() >> %s) & %s" % (field["Name"], str(bitOffset), MsgParser.Mask(numBits))
param = ""
ret = '''\
%s
public func Get%s(%s) -> %s
{
''' % (fnHdr(bits), MsgParser.BitfieldName(field, bits), param, bitParamType(field, bits))
if ("Offset" in bits or "Scale" in bits):
ret += ' let valI = '+access+';\n'
access = getMath("valI", bits, "Double")
ret += ' let valD = '+access+';\n'
ret += ' return valD;\n'
else:
ret += ' return %s;\n' % (access)
ret += '};'
return ret
def setBitsFn(field, bits, bitOffset, numBits):
paramType = fieldType(field)
intType = paramType
valueString = setMath("value", bits, '(' + fieldType(field) + ')', 'f')
if "Offset" in bits or "Scale" in bits:
paramType = typeForScaledInt(bits)
#elif "Enum" in bits:
# valueString = valueString + ".intValue()"
# paramType = bits["Enum"]
ret = '''\
%s
public void Set%s(%s value)
{
Set%s((%s)((Get%s() & ~(%s << %s)) | ((%s & %s) << %s)));
}''' % (fnHdr(bits), MsgParser.BitfieldName(field, bits), paramType,
field["Name"], intType, field["Name"], MsgParser.Mask(numBits),
str(bitOffset), valueString, MsgParser.Mask(numBits), str(bitOffset))
return ret
def setBitsFn(field, bits, offset, bitOffset, numBits):
paramType = returnType(field, bits)
valueString = setMath("value", bits)
#if "Enum" in bits:
# valueString = paramType + "(" + valueString + ")"
# paramType = bits["Enum"]
oldVal = '''%s() & ~(%s << %s)''' % (
"Get" + field["Name"], MsgParser.Mask(numBits), str(bitOffset))
newVal = '''(%s) | ((%s & %s) << %s)''' % (
oldVal, valueString, MsgParser.Mask(numBits), str(bitOffset))
ret = '''\
%s
void Set%s(%s value)
{
%s(%s);
}''' % (fnHdr(bits), MsgParser.BitfieldName(
field, bits), paramType, "Set" + field["Name"], newVal)
return ret
def getBitsFn(field, bits, offset, bitOffset, numBits):
access = "(%sGet%s(%s) >> %s) & %s" % (namespace, field["Name"],
firstParam, str(bitOffset),
MsgParser.Mask(numBits))
access = getMath(access, bits, castForScaledInt(bits), 'f')
retType = fieldType(field)
if "Offset" in bits or "Scale" in bits:
retType = typeForScaledInt(bits)
elif "Enum" in bits and namespace == "":
retType = namespace + bits["Enum"]
access = retType + "(" + access + ")"
ret = '''\
%s
%s %s(%s)%s
{
return %s;
}''' % (fnHdr(bits), functionPrefix + retType, namespace + "Get" +
MsgParser.BitfieldName(field, bits), firstParamDecl, const, access)
return ret
def getBitsFn(field, bits, bitOffset, numBits):
access = "(Get%s() >> %s) & %s" % (field["Name"], str(bitOffset),
MsgParser.Mask(numBits))
access = getMath(access, bits, "(" + typeForScaledInt(bits) + ")", 'f')
retType = fieldType(field)
if "Offset" in bits or "Scale" in bits:
retType = typeForScaledInt(bits)
#elif "Enum" in bits:
# retType = bits["Enum"]
# access = retType + ".construct(" + access + ")"
else:
access = "(" + retType + ")" + "(" + access + ")"
ret = '''\
%s
public %s Get%s()
{
return %s;
}''' % (fnHdr(bits), retType, MsgParser.BitfieldName(field, bits), access)
return ret
def setBitsFn(field, bits, bitOffset, numBits):
param = "value: " + bitParamType(field, bits)
ret = '''\
%s
fun set%s(%s) {
''' % (fnHdr(bits), MsgParser.BitfieldName(field, bits), param)
valueString = setMath("value", bits)
# Kotlin currently only supports bitwise operators for Int, so we are gonna convert the inputs to Int first,
# apply the bit operators, and then convert the final result to the actual type
ret += '''\
var valI = get%s().toInt() // read
valI = valI and (%s shl %s).inv() // clear our bits
valI = valI or ((%s.toInt() and %s) shl %s) // set our bits
set%s(valI.to%s()) // write
''' % (field["Name"], MsgParser.Mask(numBits), str(bitOffset), valueString,
MsgParser.Mask(numBits), str(bitOffset), field["Name"],
paramType(field))
ret += '}'
return ret
def setBitsFn(field, bits, offset, bitOffset, numBits):
paramType = fieldType(field)
valueString = setMath("value", bits, "(" + fieldType(field) + ")", 'f')
if "Offset" in bits or "Scale" in bits:
paramType = typeForScaledInt(bits)
elif "Enum" in bits and namespace == "":
valueString = "(" + paramType + ")" + "(" + valueString + ")"
paramType = namespace + bits["Enum"]
oldVal = '''%s(%s) & ~(%s << %s)''' % (namespace + "Get" + field["Name"],
firstParam, MsgParser.Mask(numBits),
str(bitOffset))
newVal = '''(%s) | ((%s & %s) << %s)''' % (
oldVal, valueString, MsgParser.Mask(numBits), str(bitOffset))
ret = '''\
%s
%s %s(%s value)
{
%s(%s);
}''' % (fnHdr(bits), functionPrefix + "void", namespace + "Set" +
MsgParser.BitfieldName(field, bits), params(firstParamDecl, paramType),
namespace + "Set" + field["Name"], params(firstParam, newVal))
return ret
def getBitsFn(field, bits, bitOffset, numBits):
# Kotlin currently only supports bitwise operators for Int, so we are gonna convert the inputs to Int first,
# apply the bit operators, and then convert the final result to the actual type
access = "((get%s().toInt() ushr %s) and %s).to%s()" % (
field["Name"], str(bitOffset), MsgParser.Mask(numBits),
bitParamType(field, bits))
param = ""
ret = '''\
%s
fun get%s(%s): %s {
''' % (fnHdr(bits), MsgParser.BitfieldName(
field, bits), param, bitParamType(field, bits))
if ("Offset" in bits or "Scale" in bits):
ret += ' val valI = ' + access + '\n'
access = getMath("valI", bits, "Double")
ret += ' val valD = ' + access + '\n'
ret += ' return valD\n'
else:
ret += ' return %s\n' % (access)
ret += '}'
return ret
def initBitfield(field, bits):
if "Default" in bits:
return "Set" + MsgParser.BitfieldName(field, bits) + "(" +str(bits["Default"]) + ");"
return ""
def initBitfield(field, bits):
if "Default" in bits:
return namespace + "Set" + MsgParser.BitfieldName(
field, bits) + "(" + params(firstParam, str(
bits["Default"])) + ");"
return ""
def initBitfield(field, bits, messageName):
ret = []
if "Default" in bits:
ret.append("self.Set" + MsgParser.BitfieldName(field, bits) + "(" +
str(bits["Default"]) + ")")
return ret
def initBitfield(field, bits):
type = fieldType(field)
if "Default" in bits:
return "Set%s((%s)%s);" % (MsgParser.BitfieldName(
field, bits), type, str(bits["Default"]))
return ""
def initBitfield(field, bits):
if "Default" in bits:
return "set" + MsgParser.BitfieldName(field, bits) + "(" + str(
bits["Default"]) + literalSuffixForBitfield(field, bits) + ")"
return ""
