public bool Match(Conversion c)
{
if (!(c.Expression is Conversion cc))
{
return(false);
}
this.origExp = cc.Expression;
this.ptC = c.DataType as PrimitiveType;
this.ptCc = cc.DataType as PrimitiveType;
this.ptExp = origExp.DataType as PrimitiveType;
if (ptC == null || ptCc == null || ptExp == null)
{
return(false);
}
// If the cast is identical, we don't have to do it twice.
if (ptC == ptCc)
{
this.origExp = cc;
return(true);
}
// Only match widening / narrowing.
if (ptC.Domain != ptCc.Domain || ptC.Domain != ptExp.Domain)
{
return(false);
}
//$TODO: for now, only eliminate the casts if the
// original size == new size.
return(ptC.Size == ptExp.Size && ptC.Size <= ptCc.Size);
}
private void RewriteCompressedAdd(PrimitiveType?dtDst = null)
{
var src1 = RewriteOp(instr.Operands[1]);
var dst = RewriteOp(instr.Operands[0]);
RewriteAdd(dst, dst, src1, dtDst);
}
public ContainedType(TypeReference innerType)
{
switch (innerType.ValueTypeSelector)
{
case ValueType.Enum:
category = ValueType.Enum;
FqnType = CommonDetailsUtils.GetCapitalisedFqnTypename(innerType.Enum);
primitiveType = null;
break;
case ValueType.Primitive:
category = ValueType.Primitive;
FqnType = UnityTypeMappings.SchemaTypeToUnityType[innerType.Primitive];
primitiveType = innerType.Primitive;
break;
case ValueType.Type:
category = ValueType.Type;
FqnType = CommonDetailsUtils.GetCapitalisedFqnTypename(innerType.Type);
primitiveType = null;
break;
default:
throw new ArgumentOutOfRangeException("Malformed inner type.");
}
}
private void SetSize(PrimitiveType?size)
{
if (size != null)
{
this.opSize = size;
}
}
private Vector3 GetRandomScale(PrimitiveType?primitiveType = null)
{
if (primitiveType == PrimitiveType.Cube)
{
float minSquareSide = (minScale / Mathf.Sqrt(2f));
float maxSquareSide = (maxScale / Mathf.Sqrt(2f));
return(new Vector3(
Random.Range(minSquareSide, maxSquareSide),
Random.Range(minSquareSide, maxSquareSide),
Random.Range(minSquareSide, maxSquareSide)
));
}
else if (primitiveType == PrimitiveType.Capsule)
{
float diameter = Random.Range(minScale, maxScale);
return(new Vector3(
diameter / 2,
diameter / 2,
diameter / 2
));
}
else
{
float equalScale = Random.Range(minScale, maxScale);
return(new Vector3(
equalScale,
equalScale,
equalScale
));
}
}
/// <summary>
/// Combine a set of array elements to form a multi-draw compatible element.
/// </summary>
/// <param name="multiElements">
/// A <see cref="IEnumerable{IElement}"/> that specifies all elements to be drawn using multi-draw
/// primitive.
/// </param>
/// <returns>
/// It returns a <see cref="IElement"/> that allow drawing <paramref name="multiElements"/> at once
/// using the multi-draw primitive.
/// </returns>
public IElement CombineArrayElements(IEnumerable <IElement> multiElements)
{
if (multiElements == null)
{
throw new ArgumentNullException("multiElements");
}
List <int> multiOffsets = new List <int>();
List <int> multiCounts = new List <int>();
PrimitiveType?multiPrimitive = null;
foreach (IElement element in multiElements)
{
ArrayElement arrayElement = (ArrayElement)element;
if (multiPrimitive.HasValue && (multiPrimitive.Value != arrayElement.ElementsMode))
{
throw new ArgumentException("multi-draw with multiple element modes", "multiElements");
}
multiPrimitive = arrayElement.ElementsMode;
multiOffsets.Add((int)arrayElement.ElementOffset);
multiCounts.Add((int)arrayElement.ElementCount);
}
if (multiPrimitive.HasValue == false)
{
throw new ArgumentException("no items", "multiElements");
}
return(new MultiArrayElement(this, multiPrimitive.Value, multiOffsets.ToArray(), multiCounts.ToArray()));
}
/// <summary>
/// Rewrites a machine word constant depending on its data type.
/// </summary>
/// <param name="c"></param>
/// <param name="dereferenced"></param>
/// <returns></returns>
public Expression Rewrite(Constant c, Expression?basePtr, bool dereferenced)
{
this.c = c;
this.basePtr = basePtr;
DataType dtInferred = c.DataType;
if (dtInferred == null)
{
eventListener.Warn(new NullCodeLocation(""),
$"The equivalence class {c.TypeVariable!.Name} has a null data type");
dtInferred = c.TypeVariable.DataType;
}
else
{
this.pOrig = (c.DataType as PrimitiveType) !;
if (c.TypeVariable != null)
{
dtInferred = c.TypeVariable.DataType;
this.pOrig = (c.TypeVariable.OriginalDataType as PrimitiveType) !;
}
}
var dt = dtInferred.ResolveAs <DataType>() !;
this.dereferenced = dereferenced;
return(dt.Accept(this));
}
public bool Match(Conversion c)
{
if (c.Expression is not Conversion innerC)
{
return(false);
}
this.origExp = innerC.Expression;
this.innerConv = innerC;
this.ptC = c.DataType as PrimitiveType;
this.ptInner = innerC.DataType as PrimitiveType;
this.ptExp = origExp.DataType as PrimitiveType;
if (ptC == null || ptInner == null || ptExp == null)
{
return(false);
}
// If the cast is identical, we don't have to do it twice.
if (ptC == ptInner)
{
this.origExp = innerC;
return(true);
}
// Only match widening / narrowing.
return(ptC.IsWord || ptInner.IsWord ||
(ptC.Domain == ptInner.Domain && ptC.Domain == ptExp.Domain));
}
public static int?ToOffset(Constant?offset)
{
if (offset == null)
{
return(0);
}
PrimitiveType?pt = offset.DataType.ResolveAs <PrimitiveType>();
if (pt is null)
{
return(null);
}
if (pt.Domain == Domain.SignedInt)
{
return((int)offset.ToInt32());
}
else if (pt.Domain == Domain.Real)
{
return(null);
}
else
{
return((int)offset.ToUInt32());
}
}
public override Tlcs90Instruction?DisassembleInstruction()
{
this.addr = rdr.Address;
if (!rdr.TryReadByte(out byte b))
{
return(null);
}
this.dataWidth = null;
this.byteReg = null;
this.wordReg = null;
this.backPatchOp = -1;
this.ops.Clear();
var instr = Decoders[b].Decode(b, this);
if (instr == null)
{
instr = CreateInvalidInstruction();
}
var len = rdr.Address - addr;
instr.Address = addr;
instr.Length = (int)len;
return(instr);
}
private string DataSizeSuffix(PrimitiveType?dataWidth)
{
if (dataWidth == null)
{
return("");
}
if (dataWidth.Domain == Domain.Real)
{
switch (dataWidth.BitSize)
{
case 32: return("s");
case 64: return("d");
case 80: return("x"); //$REVIEW: not quite true?
case 96: return("x");
}
}
else
{
switch (dataWidth.BitSize)
{
case 8: return("b");
case 16: return("w");
case 32: return("l");
case 64: return("q");
}
}
throw new InvalidOperationException(string.Format("Unsupported data width {0}.", dataWidth.BitSize));
}
private static Mutator <Tlcs900Disassembler> R(PrimitiveType?size)
{
return((b, dasm) => {
dasm.ops.Add(new RegisterOperand(dasm.Reg(size, (int)b & 0x7)));
dasm.SetSize(size);
return true;
});
}
private void RewriteBinOp(Func <Expression, Expression, Expression> op, PrimitiveType?dtDst = null)
{
var src1 = RewriteOp(instr.Operands[1]);
var src2 = RewriteOp(instr.Operands[2]);
var dst = RewriteOp(instr.Operands[0]);
MaybeSignExtend(dst, op(src1, src2), dtDst);
}
// Immediate encoded in low 3 bits, with 8 encoded as 0
private static Mutator <Tlcs900Disassembler> q3(PrimitiveType?size)
{
return((b, dasm) => {
var c = Constant.Create(dasm.Size(size), imm3Const8[b & 7]);
dasm.SetSize(size);
dasm.ops.Add(new ImmediateOperand(c));
return true;
});
}
private Expression RewriteOp(MachineOperand op, PrimitiveType?dt = null)
{
dt ??= op.Width ?? instr.dataWidth !;
switch (op)
{
case RegisterOperand rop:
return(binder.EnsureRegister(rop.Register));
case MemoryOperand mop:
Expression ea;
if (mop.Base != null)
{
ea = binder.EnsureRegister(mop.Base);
if (mop.PostIncrement)
{
var tmp = binder.CreateTemporary(dt);
m.Assign(tmp, m.Mem(op.Width !, ea));
m.Assign(ea, m.IAdd(ea, m.Int16((short)dt.Size)));
return(tmp);
}
else if (mop.Base == Registers.pc)
{
ea = instr.Address + mop.Offset;
var tmp = binder.CreateTemporary(dt);
m.Assign(tmp, m.Mem(dt, ea));
return(tmp);
}
else if (mop.Offset != 0)
{
var tmp = binder.CreateTemporary(dt);
m.Assign(tmp, m.Mem(dt, m.IAdd(ea, m.Int16(mop.Offset))));
return(tmp);
}
else
{
var tmp = binder.CreateTemporary(dt);
m.Assign(tmp, m.Mem(dt, ea));
return(tmp);
}
}
else
{
var tmp = binder.CreateTemporary(dt);
ea = Address.Ptr16((ushort)mop.Offset);
m.Assign(tmp, m.Mem(dt, ea));
return(tmp);
}
case ImmediateOperand iop:
return(iop.Value);
case AddressOperand aop:
return(aop.Address);
}
throw new NotImplementedException(op.ToString());
}
private void addPlanObject(string _type, string _name, PrimitiveType?_primitive)
{
Tuple <string, string, PrimitiveType?> obj = new Tuple <string, string, PrimitiveType?>(_type, _name, _primitive);
if (!objTuples.ContainsKey(_type))
{
objTuples[_type] = new List <Tuple <string, string, PrimitiveType?> >();
}
objTuples[_type].Add(obj);
}
private static Mutator <Tlcs900Disassembler> M(PrimitiveType?size)
{
return((b, dasm) =>
{
// Register indirect
dasm.ops.Add(MemoryOperand.Indirect(dasm.Size(size), dasm.Reg(PrimitiveType.Word32, (int)b & 7)));
dasm.SetSize(size);
return true;
});
}
/// <summary>
/// Gets the primitive type corresponding to this type, if possible.
/// </summary>
/// <param name="t">The resulting primitive type, or null.</param>
/// <returns>True if this type is a primitive type.</returns>
public bool TryGetPrimitiveType([NotNullWhen(true)] out PrimitiveType?t)
{
if (TryGetPrimitiveTypeCode(out var code))
{
t = Cx.Create(code);
return(true);
}
t = null;
return(false);
}
public Expression Rewrite(Address addr, Expression?basePtr, bool dereferenced)
{
if (addr.Selector.HasValue)
{
if (!mpSelectorToSegId.TryGetValue(addr.Selector.Value, out Identifier segId))
{
eventListener.Warn(
new NullCodeLocation(""),
"Selector {0:X4} has no known segment.",
addr.Selector.Value);
return(addr);
}
var ptrSeg = segId.TypeVariable !.DataType.ResolveAs <Pointer>();
if (ptrSeg == null)
{
//$TODO: what should the warning be?
//$BUG: create a fake field for now.
var field = new StructureField((int)addr.Offset, new UnknownType());
Expression x = new FieldAccess(new UnknownType(), new Dereference(segId.DataType, segId), field);
if (!dereferenced)
{
x = new UnaryExpression(Operator.AddrOf, addr.DataType, x);
}
return(x);
}
var baseType = ptrSeg.Pointee.ResolveAs <StructureType>() !;
var dt = addr.TypeVariable !.DataType.ResolveAs <Pointer>() !;
this.c = Constant.Create(
PrimitiveType.CreateWord(addr.DataType.BitSize - ptrSeg.BitSize),
addr.Offset);
var f = EnsureFieldAtOffset(baseType, dt.Pointee, c.ToInt32());
Expression ex = new FieldAccess(dt, new Dereference(ptrSeg, segId), f);
if (dereferenced || dt.Pointee is ArrayType)
{
return(ex);
}
else
{
var un = new UnaryExpression(Operator.AddrOf, dt, ex);
return(un);
}
}
else
{
this.c = addr.ToConstant();
this.c.TypeVariable = addr.TypeVariable;
var dtInferred = addr.TypeVariable !.DataType.ResolveAs <DataType>() !;
this.pOrig = addr.TypeVariable.OriginalDataType as PrimitiveType;
this.dereferenced = dereferenced;
return(dtInferred.Accept(this));
}
}
private static Mutator <Tlcs900Disassembler> O(PrimitiveType?size)
{
return((b, dasm) => {
var abs = dasm.Absolute(1, size);
if (abs is null)
{
return false;
}
dasm.ops.Add(abs);
return true;
});
}
// indexed (8-bit offset)
private static Mutator <Tlcs900Disassembler> N(PrimitiveType?size)
{
return((b, dasm) => {
if (!dasm.rdr.TryReadByte(out byte o8))
{
return false;
}
dasm.ops.Add(MemoryOperand.Indexed8(dasm.Size(size), dasm.Reg(PrimitiveType.Word32, (int)b & 7), (sbyte)o8));
dasm.SetSize(size);
return true;
});
}
/// <summary>
/// Resets the indices to the beginning of the buffers.
/// </summary>
/// <remarks>
/// This method does not automatically flush the last batch.
/// </remarks>
public void Reset()
{
// Start from beginning.
_startVertex = 0;
_nextVertex = 0;
_startIndex = 0;
_nextIndex = 0;
// Tell the graphics driver that we overwrite the old data.
_setDataOptions = SetDataOptions.Discard;
_primitiveType = null;
}
public TypeReference
(
string fullyQualifiedName = null,
PrimitiveType?primitive = null,
CollectionTypeReference collection = null,
UnionTypeReference union = null
)
{
FullyQualifiedName = fullyQualifiedName;
Primitive = primitive;
Collection = collection;
Union = union;
}
public void render(PrimitiveType?type = null)
{
//_transform = _transform * Matrix4.CreateRotationX(MathHelper.DegreesToRadians(0.05f));
//GL.LineWidth(2f);
_type = PrimitiveType.Lines;
_shader.Use();
_shader.SetMatrix4("transform", _transform);
//_shader.SetMatrix4("transform", _transform);
GL.BindVertexArray(_vertexArrayObject);
//perlu diganti di parameter 2
GL.DrawElements(PrimitiveType.Triangles,
vertexIndices.Count,
DrawElementsType.UnsignedInt, 0);
}
public override H8Instruction?DisassembleInstruction()
{
this.addr = rdr.Address;
if (!rdr.TryReadBeUInt16(out ushort uInstr))
{
return(null);
}
ops.Clear();
dataSize = null;
var instr = rootDecoder.Decode(uInstr, this);
instr.Address = addr;
instr.Length = (int)(rdr.Address - this.addr);
return(instr);
}
// various mem formats
private static Mutator <Tlcs900Disassembler> m(PrimitiveType?size)
{
return((b, dasm) =>
{
if (!dasm.rdr.TryReadByte(out byte m))
{
return false;
}
switch (m & 3)
{
case 0: // Register indirect
dasm.ops.Add(MemoryOperand.Indirect(dasm.Size(size), dasm.Reg(PrimitiveType.Word32, (m >> 2) & 0x3F)));
dasm.SetSize(size);
return true;
case 1: // indexed (16-bit offset)
if (!dasm.rdr.TryReadLeInt16(out short o16))
{
return false;
}
dasm.ops.Add(MemoryOperand.Indexed16(dasm.Size(size), dasm.Reg(PrimitiveType.Word32, (m >> 2) & 0x3F), o16));
dasm.SetSize(size);
return true;
case 3:
if (m != 3 && m != 7)
{
return false;
}
if (!dasm.rdr.TryReadByte(out byte rBase))
{
return false;
}
if (!dasm.rdr.TryReadByte(out byte rIdx))
{
return false;
}
var regBase = dasm.Reg(PrimitiveType.Word32, rBase);
var regIdx = dasm.Reg(m == 3 ? PrimitiveType.Byte : PrimitiveType.Word16, rIdx);
dasm.ops.Add(MemoryOperand.RegisterIndexed(dasm.Size(size), regBase, regIdx));
dasm.SetSize(size);
return true;
default:
return false;
}
});
}
public override Msp430Instruction?DisassembleInstruction()
{
this.addr = rdr.Address;
if (!rdr.TryReadLeUInt16(out ushort uInstr))
{
return(null);
}
uExtension = 0;
ops.Clear();
dataWidth = null;
var instr = s_decoders[uInstr >> 12].Decode(uInstr, this);
instr.Address = addr;
instr.Length = (int)(rdr.Address - addr);
return(instr);
}
private void RewriteLoad(MipsInstruction instr, PrimitiveType dtSmall, PrimitiveType?dtSmall64 = null)
{
var opSrc = RewriteOperand(instr.Operands[1]);
var opDst = RewriteOperand(instr.Operands[0]);
opSrc.DataType = (arch.WordWidth.BitSize == 64)
? dtSmall64 ?? dtSmall
: dtSmall;
if (opDst.DataType.Size != opSrc.DataType.Size)
{
// If the source is smaller than the destination register,
// perform a sign/zero extension/conversion.
opSrc = m.Convert(opSrc, opSrc.DataType, arch.WordWidth);
}
m.Assign(opDst, opSrc);
}
/// <summary>Adds or adjusts a primitive collider on the mesh.</summary>
/// <remarks>
/// Type of the primitive collider is chosen basing on the primitive type.
/// </remarks>
/// <param name="primitive">Primitive game object to adjust.</param>
/// <param name="meshSize">Size of the collider in local units.</param>
/// <param name="colliderType">Determines how a collider type should be selected.</param>
/// <param name="shapeType">
/// Type of the primitive when <paramref name="colliderType"/> is
/// <see cref="PrimitiveCollider.Shape"/>. It will determine the type of the collider. Only
/// <see cref="PrimitiveType.Cylinder"/>, <see cref="PrimitiveType.Sphere"/>, and
/// <see cref="PrimitiveType.Cube"/> are supported.
/// </param>
public static void AdjustCollider(
GameObject primitive, Vector3 meshSize, PrimitiveCollider colliderType,
PrimitiveType?shapeType = null)
{
UnityEngine.Object.Destroy(primitive.GetComponent <Collider>());
if (colliderType == PrimitiveCollider.Mesh)
{
var collider = primitive.AddComponent <MeshCollider>();
collider.convex = true;
}
else if (colliderType == PrimitiveCollider.Shape)
{
// FIXME: non tirival scales does't fit simple colliders. Fix it.
if (shapeType.Value == PrimitiveType.Cylinder)
{
// TODO(ihsoft): Choose direction so what the volume is minimized.
var collider = primitive.AddComponent <CapsuleCollider>();
collider.direction = 2; // Z axis
collider.height = meshSize.z; // It's now length.
collider.radius = meshSize.x;
}
else if (shapeType.Value == PrimitiveType.Sphere)
{
var collider = primitive.AddComponent <SphereCollider>();
collider.radius = meshSize.x;
}
else if (shapeType.Value == PrimitiveType.Cube)
{
var collider = primitive.AddComponent <BoxCollider>();
collider.size = meshSize;
}
else
{
DebugEx.Warning("Unknown primitive type {0}. Droppping collider.", shapeType.Value);
}
}
else if (colliderType == PrimitiveCollider.Bounds)
{
SetSimpleCollider(primitive, PrimitiveType.Cube, inscribeBoundaryIntoCollider: true);
}
else if (colliderType != PrimitiveCollider.None)
{
DebugEx.Warning(
"Unsupported collider type {0}. Droppping whatever collider part had", colliderType);
}
}
protected override void DeserializeProperty(string jsonPropertyName, JsonReader reader)
{
switch (jsonPropertyName)
{
case "attributes": DeserializePropertyDictionary <Int32>(reader, _attributes); break;
case "indices": _indices = DeserializePropertyValue <Int32?>(reader); break;
case "material": _material = DeserializePropertyValue <Int32?>(reader); break;
case "mode": _mode = DeserializePropertyValue <PrimitiveType>(reader); break;
case "targets": DeserializePropertyList <Dictionary <String, Int32> >(reader, _targets); break;
default: base.DeserializeProperty(jsonPropertyName, reader); break;
}
}
public AddAction(PrimitiveType primitiveType, Vector3 position)
{
this.primitiveType = primitiveType;
this.position = position;
}
