///<summary>
///Returns a <see cref="T:System.String"/> that represents the current <see cref="UsbInterfaceInfo"/>.
///</summary>
///
///<param name="prefixSeperator">The field prefix string.</param>
///<param name="entitySperator">The field/value seperator string.</param>
///<param name="suffixSeperator">The value suffix string.</param>
///<returns>A formatted representation of the <see cref="UsbInterfaceInfo"/>.</returns>
public string ToString(string prefixSeperator, string entitySperator, string suffixSeperator)
{
string[] names = { "ManufacturerString", "ProductString", "SerialString" };
Object[] values = { ManufacturerString, ProductString, SerialString };
return(Descriptor.ToString(prefixSeperator, entitySperator, suffixSeperator) +
LHelper.ToString(prefixSeperator, names, entitySperator, values, suffixSeperator));
}
public void Fneg_ParseCheck()
{
LFneg fneg = new LFneg(_op1, _result);
Assert.AreEqual($"{_result.Identifier} = fneg {_result.ParseType()} {_op1.ValueOrIdentifier}",
LHelper.Trim(fneg.ParseInstruction()));
}
public void SimpleAshr_ParseCheck()
{
LAshr ashr = new LAshr(_valueResult, _valueOp1, _valueOp2);
Assert.AreEqual($"{_valueResult.Identifier} = ashr {_valueResult.ParseType()} {_valueOp1.ValueOrIdentifier}, {_valueOp2.ValueOrIdentifier}",
LHelper.Trim(ashr.ParseInstruction()));
}
public void SimpleLshr_ParseCheck()
{
LShl shl = new LShl(_valueResult, _valueOp1, _valueOp2);
Assert.AreEqual($"{_valueResult.Identifier} = shl {_valueResult.ParseType()} {_valueOp1.ValueOrIdentifier}, {_valueOp2.ValueOrIdentifier}",
LHelper.Trim(shl.ParseInstruction()));
}
public void Ret_ParseCheck_i32_Value_Ok()
{
LValueRef valueRef = new LValueRef(LType.Int32Type(), "12");
LRet ret = new LRet(valueRef);
Assert.AreEqual($"{LKeywords.Ret} i32 12", LHelper.Trim(ret.ParseInstruction()));
}
public void SimpleXor_ParseCheck()
{
LXor xor = new LXor(_valueResult, _valueOp1, _valueOp2);
Assert.AreEqual($"{_valueResult.Identifier} = xor {_valueResult.ParseType()} {_valueOp1.ValueOrIdentifier}, {_valueOp2.ValueOrIdentifier}",
LHelper.Trim(xor.ParseInstruction()));
}
/// <summary>
/// String representation of the UsbDescriptor class.
/// </summary>
public override string ToString()
{
Object[] values = { Length, DescriptorType };
string[] names = { "Length", "DescriptorType" };
return(LHelper.ToString("", names, ToStringParamValueSeperator, values, ToStringFieldSeperator));
}
public void SimpleAnd_ParseCheck()
{
LAnd and = new LAnd(_valueResult, _valueOp1, _valueOp2);
Assert.AreEqual($"{_valueResult.Identifier} = and {_valueResult.ParseType()} {_valueOp1.ValueOrIdentifier}, {_valueOp2.ValueOrIdentifier}",
LHelper.Trim(and.ParseInstruction()));
}
///<summary>
///Returns a <see cref="T:System.String"/> that represents the current <see cref="UsbConfigDescriptor"/>.
///</summary>
///
///<param name="prefixSeperator">The field prefix string.</param>
///<param name="entitySperator">The field/value seperator string.</param>
///<param name="suffixSeperator">The value suffix string.</param>
///<returns>A formatted representation of the <see cref="UsbConfigDescriptor"/>.</returns>
public string ToString(string prefixSeperator, string entitySperator, string suffixSeperator)
{
Object[] values = { Length, DescriptorType, TotalLength, InterfaceCount, ConfigID, StringIndex, "0x" + Attributes.ToString("X2"), MaxPower };
string[] names = { "Length", "DescriptorType", "TotalLength", "InterfaceCount", "ConfigID", "StringIndex", "Attributes", "MaxPower" };
return(LHelper.ToString(prefixSeperator, names, entitySperator, values, suffixSeperator));
}
public void Ret_ParseCheck_i32_Identifier_Ok()
{
LValueRef valueRef = new LValueRef(LType.Int32Type(), _function.GetValueRefIdentifier());
LRet ret = new LRet(valueRef);
Assert.AreEqual($"{LKeywords.Ret} i32 {valueRef.ValueOrIdentifier}", LHelper.Trim(ret.ParseInstruction()));
}
///<summary>
///Returns a <see cref="T:System.String"/> that represents the current <see cref="UsbConfigInfo"/>.
///</summary>
///
///<param name="prefixSeperator">The field prefix string.</param>
///<param name="entitySperator">The field/value seperator string.</param>
///<param name="suffixSeperator">The value suffix string.</param>
///<returns>A formatted representation of the <see cref="UsbConfigInfo"/>.</returns>
public string ToString(string prefixSeperator, string entitySperator, string suffixSeperator)
{
Object[] values = { ConfigString };
string[] names = { "ConfigString" };
return(Descriptor.ToString(prefixSeperator, entitySperator, suffixSeperator) +
LHelper.ToString(prefixSeperator, names, entitySperator, values, suffixSeperator));
}
public void SimpleAllocaParse_Expected_True()
{
LAlloca alloca = new LAlloca(_function, LType.Int32Type());
Assert.AreEqual($"{alloca.PointerRef.Identifier} = {LKeywords.Alloca} {LType.Int32Type().Parse()}",
LHelper.Trim(alloca.ParseInstruction()));
}
public void UnconditionalBr_ParseCheck()
{
LUnconditionalBr unconditionalBr = new LUnconditionalBr(_ifTrueLabel);
Assert.AreEqual(
$"{LKeywords.Br} {LKeywords.Label} {_ifTrueLabel.Identifier}",
LHelper.Trim(unconditionalBr.ParseInstruction()));
}
public void Fneg_ParseCheck_FastMathFlags()
{
LFneg fneg = new LFneg(_op1, _result);
fneg.Flags.Add(LFastMathFlags.fast);
Assert.AreEqual($"{_result.Identifier} = fneg {LFastMathFlags.fast.Parse()} {_result.ParseType()} {_op1.ValueOrIdentifier}",
LHelper.Trim(fneg.ParseInstruction()));
}
public void AllocaLiteralStruct_Expected_Ok()
{
var @struct = new LLiteralStruct(new LValueRef(LType.Int128Type(), ""), new LValueRef(LType.Int16Type(), ""));
LAlloca alloca = new LAlloca(_function, @struct);
Assert.AreEqual($"{alloca.PointerRef.Identifier} = {LKeywords.Alloca} {{ i128, i16 }}", LHelper.Trim(alloca.ParseInstruction()));
Assert.AreEqual("{ i128, i16 }*", LHelper.Trim(alloca.PointerRef.ParseType()));
}
public void SimpleLshr_WithConstant_ParseCheck()
{
LValueRef op2 = new LValueRef(LType.Int32Type(), "12");
LShl shl = new LShl(_valueResult, _valueOp1, op2);
Assert.AreEqual($"{_valueResult.Identifier} = shl {_valueResult.ParseType()} {_valueOp1.ValueOrIdentifier}, {op2.ValueOrIdentifier}",
LHelper.Trim(shl.ParseInstruction()));
}
public void SimpleLoadParse_Expected_True()
{
LLoad load = new LLoad(_function, _alloca.PointerRef);
Assert.AreEqual(
$"{load.ValueRef.Identifier} = {LKeywords.Load} {LType.Int32Type().Parse()}, {load.PointerRef.ParseType()} {load.PointerRef.Identifier}",
LHelper.Trim(load.ParseInstruction()));
}
public void SimpleAnd_WithConstant_ParseCheck()
{
LValueRef op2 = new LValueRef(LType.Int32Type(), "12");
LAnd and = new LAnd(_valueResult, _valueOp1, op2);
Assert.AreEqual($"{_valueResult.Identifier} = and {_valueResult.ParseType()} {_valueOp1.ValueOrIdentifier}, {op2.ValueOrIdentifier}",
LHelper.Trim(and.ParseInstruction()));
}
public void AllocaTriplePointerType_Expected_Equal()
{
LPointerRef singlePointer = new LPointerRef(new LValueRef(LType.Int32Type(), ""), _function.GetPointerRefIdentifier());
LPointerRef doublePointer = new LPointerRef(singlePointer, _function.GetPointerRefIdentifier());
LAlloca alloca = new LAlloca(_function, doublePointer);
Assert.AreEqual($"{alloca.PointerRef.Identifier} = {LKeywords.Alloca} {LType.Int32Type().Parse()}**", LHelper.Trim(alloca.ParseInstruction()));
Assert.AreEqual($"{LType.Int32Type().Parse()}***", LHelper.Trim(alloca.PointerRef.ParseType()));
}
internal static List <UsbConfigInfo> GetDeviceConfigs(UsbDevice usbDevice)
{
List <UsbConfigInfo> rtnConfigs = new List <UsbConfigInfo>();
byte[] cfgBuffer = new byte[UsbConstants.MAX_CONFIG_SIZE];
int iConfigs = usbDevice.Info.Descriptor.ConfigurationCount;
for (int iConfig = 0; iConfig < iConfigs; iConfig++)
{
int iBytesTransmitted;
bool bSuccess = usbDevice.GetDescriptor((byte)DescriptorType.Configuration, 0, 0, cfgBuffer, cfgBuffer.Length, out iBytesTransmitted);
if (bSuccess)
{
if (iBytesTransmitted >= UsbConfigDescriptor.Size && cfgBuffer[1] == (byte)DescriptorType.Configuration)
{
UsbConfigDescriptor configDescriptor = new UsbConfigDescriptor();
LHelper.BytesToObject(cfgBuffer, 0, Math.Min(UsbConfigDescriptor.Size, cfgBuffer[0]), configDescriptor);
if (configDescriptor.TotalLength == iBytesTransmitted)
{
List <byte[]> rawDescriptorList = new List <byte[]>();
int iRawLengthPosition = configDescriptor.Length;
while (iRawLengthPosition < configDescriptor.TotalLength)
{
byte[] rawDescriptor = new byte[cfgBuffer[iRawLengthPosition]];
if (iRawLengthPosition + rawDescriptor.Length > iBytesTransmitted)
{
throw new UsbException(usbDevice, "Descriptor length is out of range.");
}
Array.Copy(cfgBuffer, iRawLengthPosition, rawDescriptor, 0, rawDescriptor.Length);
rawDescriptorList.Add(rawDescriptor);
iRawLengthPosition += rawDescriptor.Length;
}
rtnConfigs.Add(new UsbConfigInfo(usbDevice, configDescriptor, ref rawDescriptorList));
}
else
{
UsbError.Error(ErrorCode.InvalidConfig,
0,
"GetDeviceConfigs: USB config descriptor length doesn't match the length received.",
usbDevice);
}
}
else
{
UsbError.Error(ErrorCode.InvalidConfig, 0, "GetDeviceConfigs: USB config descriptor is invalid.", usbDevice);
}
}
else
{
UsbError.Error(ErrorCode.InvalidConfig, 0, "GetDeviceConfigs", usbDevice);
}
}
return(rtnConfigs);
}
public void Switch_Unconditional_ParseCheck()
{
LValueRef valueRef = new LValueRef(LType.Int32Type(), "%1");
LLabelType defaultLabel = new LLabelType("%default");
LSwitch @switch = new LSwitch(valueRef, defaultLabel);
Assert.AreEqual("switch i32 %1, label %default [ ]",
LHelper.Trim(@switch.ParseInstruction()));
}
public void AllocaIdentifiedStruct_Expected_Ok()
{
string structIdentifier = "abcTestStruct";
var @struct = new LIdentifiedStruct(structIdentifier, new LValueRef(LType.Int128Type(), ""), new LValueRef(LType.Int16Type(), ""));
LAlloca alloca = new LAlloca(_function, @struct);
Assert.AreEqual($"{alloca.PointerRef.Identifier} = {LKeywords.Alloca} {structIdentifier}", LHelper.Trim(alloca.ParseInstruction()));
Assert.AreEqual($"{structIdentifier}*", LHelper.Trim(alloca.PointerRef.ParseType()));
}
public void SimpleLshr_Exact_ParseCheck()
{
LLshr lshr = new LLshr(_valueResult, _valueOp1, _valueOp2)
{
Exact = true
};
Assert.AreEqual($"{_valueResult.Identifier} = lshr exact {_valueResult.ParseType()} {_valueOp1.ValueOrIdentifier}, {_valueOp2.ValueOrIdentifier}",
LHelper.Trim(lshr.ParseInstruction()));
}
public void ConditionalBr_ParseCheck()
{
LValueRef condition = new LValueRef(LType.BoolType(), _function.GetValueRefIdentifier());
LConditionalBr conditionalBr = new LConditionalBr(
condition, _ifTrueLabel, _ifFalseLabel);
Assert.AreEqual(
$"{LKeywords.Br} i1 {condition.ValueOrIdentifier}, {LKeywords.Label} {_ifTrueLabel.Identifier}, {LKeywords.Label} {_ifFalseLabel.Identifier}",
LHelper.Trim(conditionalBr.ParseInstruction()));
}
public void StoreIsAtomic_Expected_Ok()
{
LStore store = new LStore(_src, _dst)
{
IsAtomic = true
};
Assert.AreEqual(
$"{LKeywords.Store} {LKeywords.Atomic} {_src.ParseType()} {_src.ValueOrIdentifier}, {_dst.ParseType()} {_dst.Identifier}",
LHelper.Trim(store.ParseInstruction()));
}
public void AllocaParseNumOfElements_Expected_True()
{
LAlloca alloca = new LAlloca(_function, LType.Int32Type())
{
NumOfElements = 5
};
Assert.AreEqual(
$"{alloca.PointerRef.Identifier} = {LKeywords.Alloca} {LType.Int32Type().Parse()}, {LType.Int32Type().Parse()} 5",
LHelper.Trim(alloca.ParseInstruction()));
}
public void AllocaParseAddrspace_Expected_True()
{
LAlloca alloca = new LAlloca(_function, LType.Int32Type())
{
Addrspace = 4
};
Assert.AreEqual(
$"{alloca.PointerRef.Identifier} = {LKeywords.Alloca} {LType.Int32Type().Parse()}, {LKeywords.Addrspace}(4)",
LHelper.Trim(alloca.ParseInstruction()));
}
///<summary>
///Returns a <see cref="T:System.String"/> that represents the current <see cref="UsbEndpointDescriptor"/>.
///</summary>
///
///<param name="prefixSeperator">The field prefix string.</param>
///<param name="entitySperator">The field/value seperator string.</param>
///<param name="suffixSeperator">The value suffix string.</param>
///<returns>A formatted representation of the <see cref="UsbEndpointDescriptor"/>.</returns>
public string ToString(string prefixSeperator, string entitySperator, string suffixSeperator)
{
Object[] values =
{
Length, DescriptorType, "0x" + EndpointID.ToString("X2"), "0x" + Attributes.ToString("X2"), MaxPacketSize, Interval,
Refresh, "0x" + SynchAddress.ToString("X2")
};
string[] names = { "Length", "DescriptorType", "EndpointID", "Attributes", "MaxPacketSize", "Interval", "Refresh", "SynchAddress" };
return(LHelper.ToString(prefixSeperator, names, entitySperator, values, suffixSeperator));
}
public void StoreAlignment_Expected_Ok()
{
LStore store = new LStore(_src, _dst)
{
Alignment = 5012
};
Assert.AreEqual(
$"{LKeywords.Store} {_src.ParseType()} {_src.ValueOrIdentifier}, {_dst.ParseType()} {_dst.Identifier}, {LKeywords.Align} 5012",
LHelper.Trim(store.ParseInstruction()));
}
public void SimpleLshr_NuwNsw_ParseCheck()
{
LShl shl = new LShl(_valueResult, _valueOp1, _valueOp2)
{
NoUnsignedWrap = true,
NoSignedWrap = true,
};
Assert.AreEqual($"{_valueResult.Identifier} = shl nuw nsw {_valueResult.ParseType()} {_valueOp1.ValueOrIdentifier}, {_valueOp2.ValueOrIdentifier}",
LHelper.Trim(shl.ParseInstruction()));
}
