public BitGroupCoding(int numBase, Alphabet abc, char paddingChar)
: base(numBase, abc)
{
if (!BitTwiddling.IsPowerOfTwo(numBase))
{
throw new ArgumentOutOfRangeException("numBase", "The '" + typeof(BitGroupCoding) + "' can only be used with a numerical base that is a power of 2.");
}
int v;
if (abc.TryDecode(_paddingChar, out v))
{
throw new ArgumentOutOfRangeException("The padding char cannot be a member of the alphabet.");
}
// Hmm...
var bitCount = (int)Math.Log(numBase, 2);
_bitCount = bitCount;
_bitMask = (1u << bitCount) - 1;
var bitGroupSize = BitTwiddling.LeastCommonMultiple(bitCount, 8);
var bitGroupByteCount = bitGroupSize / 8;
var bitGroupCharCount = bitGroupSize / bitCount;
// Encode
var charCountFromByteCount = new int[1 + bitGroupByteCount];
for (int i = 0; i <= bitGroupByteCount; i++)
{
charCountFromByteCount[i] = (8 * i + (bitCount - 1)) / bitCount;
}
// Decode
var byteCountFromCharCount = new int[1 + bitGroupCharCount];
for (int i = 0; i < byteCountFromCharCount.Length; i++)
{
byteCountFromCharCount[i] = -1;
}
for (int i = 1; i <= bitGroupByteCount; i++)
{
byteCountFromCharCount[charCountFromByteCount[i]] = i;
}
// Save
_bitGroupByteCount = bitGroupByteCount;
_bitGroupCharCount = bitGroupCharCount;
_charCountFromByteCount = charCountFromByteCount;
_byteCountFromCharCount = byteCountFromCharCount;
_paddingChar = paddingChar;
}
private static long CheckLong(int loopCount)
{
long cur = 0;
long i1 = loopCount;
for (long i = 0; i < i1; i++)
{
cur ^= BitTwiddling.QMax(cur, i) ^ BitTwiddling.QMax(cur, i) ^ BitTwiddling.QMax(cur, i) ^ BitTwiddling.QMax(cur, i) ^ BitTwiddling.QMax(cur, i) ^ BitTwiddling.QMax(cur, i) ^ BitTwiddling.QMax(cur, i)
^ BitTwiddling.QMax(cur, i) ^ BitTwiddling.QMax(cur, i) ^ BitTwiddling.QMax(cur, i) ^ BitTwiddling.QMax(cur, i) ^ BitTwiddling.QMax(cur, i) ^ BitTwiddling.QMax(cur, i) ^ BitTwiddling.QMax(cur, i)
^ BitTwiddling.QMax(cur, i) ^ BitTwiddling.QMax(cur, i);
cur++;
}
return(cur);
}
private static int CheckInt(int loopCount)
{
int cur = 0;
int i1 = loopCount;
for (int i = 0; i < i1; i++)
{
cur ^= BitTwiddling.QMax(cur, i) ^ BitTwiddling.QMax(cur, i) ^ BitTwiddling.QMax(cur, i) ^ BitTwiddling.QMax(cur, i) ^ BitTwiddling.QMax(cur, i) ^ BitTwiddling.QMax(cur, i) ^ BitTwiddling.QMax(cur, i)
^ BitTwiddling.QMax(cur, i) ^ BitTwiddling.QMax(cur, i) ^ BitTwiddling.QMax(cur, i) ^ BitTwiddling.QMax(cur, i) ^ BitTwiddling.QMax(cur, i) ^ BitTwiddling.QMax(cur, i) ^ BitTwiddling.QMax(cur, i)
^ BitTwiddling.QMax(cur, i) ^ BitTwiddling.QMax(cur, i);
cur++;
}
return(cur);
}
public static long Next(this IRandomGenerator <ulong> randomGenerator, long lessThan)
{
if (lessThan <= 0L)
{
return(0);
}
ulong num1 = BitTwiddling.PowerOf2Mask((ulong)lessThan);
long num2;
do
{
num2 = (long)randomGenerator.Next() & (long)num1;
}while (num2 >= lessThan);
return(num2);
}
public static int Next(this IRandomGenerator <uint> randomGenerator, int lessThan)
{
if (lessThan <= 0)
{
return(0);
}
uint num1 = BitTwiddling.PowerOf2Mask((uint)lessThan);
int num2;
do
{
num2 = (int)randomGenerator.Next() & (int)num1;
}while (num2 >= lessThan);
return(num2);
}
public static SimpleInstruction StrengthReductionDivision(InstructionNode node)
{
if (!(node.Instruction == IRInstruction.DivUnsigned32 ||
node.Instruction == IRInstruction.DivUnsigned64))
{
return(null);
}
var result = node.Result;
var op1 = node.Operand1;
var op2 = node.Operand2;
if (!op2.IsResolvedConstant)
{
return(null);
}
if (op2.IsConstantZero || op2.IsVirtualRegister)
{
return(null);
}
if ((node.Instruction == IRInstruction.DivUnsigned32 || node.Instruction == IRInstruction.DivUnsigned64) && BitTwiddling.IsPowerOfTwo(op2.ConstantUnsignedLongInteger))
{
int shift = BitTwiddling.GetPowerOfTwo(op2.ConstantUnsignedLongInteger);
if (shift < 32 || (shift < 64 && result.Is64BitInteger))
{
return(new SimpleInstruction()
{
Instruction = Select(result.Is64BitInteger, IRInstruction.ShiftRight32, IRInstruction.ShiftRight64),
Result = result,
Operand1 = op1,
Operand2 = ConstantOperand.Create(result.Type, (uint)shift)
});
}
}
return(null);
}
public static SimpleInstruction StrengthReductionRemUnsignedModulus(InstructionNode node)
{
if (!(node.Instruction == IRInstruction.RemUnsigned32 ||
node.Instruction == IRInstruction.RemUnsigned64))
{
return(null);
}
var result = node.Result;
var op1 = node.Operand1;
var op2 = node.Operand2;
if (!op2.IsResolvedConstant)
{
return(null);
}
if (op2.ConstantUnsignedLongInteger == 0)
{
return(null);
}
if (!BitTwiddling.IsPowerOfTwo(op2.ConstantUnsignedLongInteger))
{
return(null);
}
int power = BitTwiddling.GetPowerOfTwo(op2.ConstantUnsignedLongInteger);
var mask = (1 << power) - 1;
return(new SimpleInstruction()
{
Instruction = Select(result.Is64BitInteger, IRInstruction.LogicalAnd32, IRInstruction.LogicalAnd64),
Result = result,
Operand1 = op1,
Operand2 = ConstantOperand.Create(result.Type, (uint)mask)
});
}
///////////////////////////////////////////////////////////////////////////
// Copyright (C) 2014 Wizardry and Steamworks - License: GNU GPLv3 //
///////////////////////////////////////////////////////////////////////////
/// <summary>
/// Takes as input a CSV data values and sets the corresponding
/// structure's fields or properties from the CSV data.
/// </summary>
/// <typeparam name="T">the type of the structure</typeparam>
/// <param name="kvp">a CSV string</param>
/// <param name="structure">the structure to set the fields and properties for</param>
public static T wasCSVToStructure <T>(this T structure, string kvp, Func <string, string> escape)
{
CSV.ToKeyValue(kvp).ToDictionary(o => escape.Invoke(o.Key), o => escape.Invoke(o.Value)).AsParallel().ForAll(d =>
{
var info = structure.GetFPInfo(d.Key);
if (info == null)
{
return;
}
var data = wasSharpNET.Reflection.wasGetInfoValue(info, structure);
// OpenMetaverse particular flags.
// LL permissions.
if (data is Permissions)
{
wasSharpNET.Reflection.wasSetInfoValue(info, ref structure, Inventory.wasStringToPermissions(d.Value));
}
if (data is ParcelFlags)
{
ParcelFlags parcelFlags;
switch (!Enum.TryParse(d.Value, out parcelFlags))
{
case true:
var allFlags =
typeof(ParcelFlags).GetFields(BindingFlags.Public | BindingFlags.Static)
.ToDictionary(o => o.Name, o => (ParcelFlags)o.GetValue(null));
CSV.ToEnumerable(d.Value).AsParallel().Where(o => !string.IsNullOrEmpty(o)).ForAll(
o =>
{
ParcelFlags parcelFlag;
if (allFlags.TryGetValue(o, out parcelFlag))
{
BitTwiddling.SetMaskFlag(ref parcelFlags, parcelFlag);
}
});
break;
}
wasSharpNET.Reflection.wasSetInfoValue(info, ref structure, parcelFlags);
return;
}
if (data is GroupPowers)
{
GroupPowers groupPowers;
switch (!Enum.TryParse(d.Value, out groupPowers))
{
case true:
var allPowers =
typeof(GroupPowers).GetFields(BindingFlags.Public | BindingFlags.Static)
.ToDictionary(o => o.Name, o => (GroupPowers)o.GetValue(null));
CSV.ToEnumerable(d.Value).AsParallel().Where(o => !string.IsNullOrEmpty(o)).ForAll(
o =>
{
GroupPowers groupPower;
if (allPowers.TryGetValue(o, out groupPower))
{
BitTwiddling.SetMaskFlag(ref groupPowers, groupPower);
}
});
break;
}
wasSharpNET.Reflection.wasSetInfoValue(info, ref structure, groupPowers);
return;
}
if (data is AttachmentPoint)
{
byte attachmentPoint;
switch (!byte.TryParse(d.Value, out attachmentPoint))
{
case true:
var attachmentPointFieldInfo =
typeof(AttachmentPoint).GetFields(BindingFlags.Public | BindingFlags.Static)
.AsParallel()
.FirstOrDefault(p => string.Equals(d.Value, p.Name, StringComparison.Ordinal));
if (attachmentPointFieldInfo == null)
{
break;
}
attachmentPoint = (byte)attachmentPointFieldInfo.GetValue(null);
break;
}
wasSharpNET.Reflection.wasSetInfoValue(info, ref structure, attachmentPoint);
return;
}
if (data is Tree)
{
byte tree;
switch (!byte.TryParse(d.Value, out tree))
{
case true:
var treeFieldInfo = typeof(Tree).GetFields(BindingFlags.Public |
BindingFlags.Static)
.AsParallel()
.FirstOrDefault(p => string.Equals(d.Value, p.Name, StringComparison.Ordinal));
if (treeFieldInfo == null)
{
break;
}
tree = (byte)treeFieldInfo.GetValue(null);
break;
}
wasSharpNET.Reflection.wasSetInfoValue(info, ref structure, tree);
return;
}
if (data is Material)
{
byte material;
switch (!byte.TryParse(d.Value, out material))
{
case true:
var materialFieldInfo = typeof(Material).GetFields(BindingFlags.Public |
BindingFlags.Static)
.AsParallel()
.FirstOrDefault(p => string.Equals(d.Value, p.Name, StringComparison.Ordinal));
if (materialFieldInfo == null)
{
break;
}
material = (byte)materialFieldInfo.GetValue(null);
break;
}
wasSharpNET.Reflection.wasSetInfoValue(info, ref structure, material);
return;
}
if (data is PathCurve)
{
byte pathCurve;
switch (!byte.TryParse(d.Value, out pathCurve))
{
case true:
var pathCurveFieldInfo = typeof(PathCurve).GetFields(BindingFlags.Public |
BindingFlags.Static)
.AsParallel()
.FirstOrDefault(p => string.Equals(d.Value, p.Name, StringComparison.Ordinal));
if (pathCurveFieldInfo == null)
{
break;
}
pathCurve = (byte)pathCurveFieldInfo.GetValue(null);
break;
}
wasSharpNET.Reflection.wasSetInfoValue(info, ref structure, pathCurve);
return;
}
if (data is PCode)
{
byte pCode;
switch (!byte.TryParse(d.Value, out pCode))
{
case true:
var pCodeFieldInfo = typeof(PCode).GetFields(BindingFlags.Public | BindingFlags.Static)
.AsParallel()
.FirstOrDefault(p => string.Equals(d.Value, p.Name, StringComparison.Ordinal));
if (pCodeFieldInfo == null)
{
break;
}
pCode = (byte)pCodeFieldInfo.GetValue(null);
break;
}
wasSharpNET.Reflection.wasSetInfoValue(info, ref structure, pCode);
return;
}
if (data is ProfileCurve)
{
byte profileCurve;
switch (!byte.TryParse(d.Value, out profileCurve))
{
case true:
var profileCurveFieldInfo =
typeof(ProfileCurve).GetFields(BindingFlags.Public | BindingFlags.Static)
.AsParallel()
.FirstOrDefault(p => string.Equals(d.Value, p.Name, StringComparison.Ordinal));
if (profileCurveFieldInfo == null)
{
break;
}
profileCurve = (byte)profileCurveFieldInfo.GetValue(null);
break;
}
wasSharpNET.Reflection.wasSetInfoValue(info, ref structure, profileCurve);
return;
}
if (data is HoleType)
{
byte holeType;
switch (!byte.TryParse(d.Value, out holeType))
{
case true:
var holeTypeFieldInfo = typeof(HoleType).GetFields(BindingFlags.Public |
BindingFlags.Static)
.AsParallel()
.FirstOrDefault(p => string.Equals(d.Value, p.Name, StringComparison.Ordinal));
if (holeTypeFieldInfo == null)
{
break;
}
holeType = (byte)holeTypeFieldInfo.GetValue(null);
break;
}
wasSharpNET.Reflection.wasSetInfoValue(info, ref structure, holeType);
return;
}
if (data is SculptType)
{
byte sculptType;
switch (!byte.TryParse(d.Value, out sculptType))
{
case true:
var sculptTypeFieldInfo = typeof(SculptType).GetFields(BindingFlags.Public |
BindingFlags.Static)
.AsParallel()
.FirstOrDefault(p => string.Equals(d.Value, p.Name, StringComparison.Ordinal));
if (sculptTypeFieldInfo == null)
{
break;
}
sculptType = (byte)sculptTypeFieldInfo.GetValue(null);
break;
}
wasSharpNET.Reflection.wasSetInfoValue(info, ref structure, sculptType);
return;
}
// OpenMetaverse Primitive Types
if (data is UUID)
{
UUID UUIDData;
if (!UUID.TryParse(d.Value, out UUIDData))
{
return;
}
wasSharpNET.Reflection.wasSetInfoValue(info, ref structure, UUIDData);
return;
}
if (data is Vector3)
{
Vector3 vector3Data;
if (Vector3.TryParse(d.Value, out vector3Data))
{
wasSharpNET.Reflection.wasSetInfoValue(info, ref structure, vector3Data);
return;
}
}
if (data is Vector2)
{
Vector3 vector2Data;
if (Vector2.TryParse(d.Value, out vector2Data))
{
wasSharpNET.Reflection.wasSetInfoValue(info, ref structure, vector2Data);
return;
}
}
if (data is Vector3d)
{
Vector3d vector3DData;
if (Vector3d.TryParse(d.Value, out vector3DData))
{
wasSharpNET.Reflection.wasSetInfoValue(info, ref structure, vector3DData);
return;
}
}
if (data is Vector4)
{
Vector4 vector4Data;
if (Vector4.TryParse(d.Value, out vector4Data))
{
wasSharpNET.Reflection.wasSetInfoValue(info, ref structure, vector4Data);
return;
}
}
if (data is Quaternion)
{
Quaternion quaternionData;
if (Quaternion.TryParse(d.Value, out quaternionData))
{
wasSharpNET.Reflection.wasSetInfoValue(info, ref structure, quaternionData);
return;
}
}
// Primitive types.
if (data is bool)
{
bool boolData;
if (bool.TryParse(d.Value, out boolData))
{
wasSharpNET.Reflection.wasSetInfoValue(info, ref structure, boolData);
return;
}
}
if (data is char)
{
char charData;
if (char.TryParse(d.Value, out charData))
{
wasSharpNET.Reflection.wasSetInfoValue(info, ref structure, charData);
return;
}
}
if (data is decimal)
{
decimal decimalData;
if (decimal.TryParse(d.Value, out decimalData))
{
wasSharpNET.Reflection.wasSetInfoValue(info, ref structure, decimalData);
return;
}
}
if (data is byte)
{
byte byteData;
if (byte.TryParse(d.Value, out byteData))
{
wasSharpNET.Reflection.wasSetInfoValue(info, ref structure, byteData);
return;
}
}
if (data is int)
{
int intData;
if (int.TryParse(d.Value, NumberStyles.Integer, Utils.EnUsCulture, out intData))
{
wasSharpNET.Reflection.wasSetInfoValue(info, ref structure, intData);
return;
}
}
if (data is uint)
{
uint uintData;
if (uint.TryParse(d.Value, NumberStyles.Integer, Utils.EnUsCulture, out uintData))
{
wasSharpNET.Reflection.wasSetInfoValue(info, ref structure, uintData);
return;
}
}
if (data is float)
{
float floatData;
if (float.TryParse(d.Value, NumberStyles.Float, Utils.EnUsCulture, out floatData))
{
wasSharpNET.Reflection.wasSetInfoValue(info, ref structure, floatData);
return;
}
}
if (data is long)
{
long longData;
if (long.TryParse(d.Value, NumberStyles.Float, Utils.EnUsCulture, out longData))
{
wasSharpNET.Reflection.wasSetInfoValue(info, ref structure, longData);
return;
}
}
if (data is DateTime)
{
DateTime dateTimeData;
if (DateTime.TryParse(d.Value, out dateTimeData))
{
wasSharpNET.Reflection.wasSetInfoValue(info, ref structure, dateTimeData);
return;
}
}
if (data is string)
{
wasSharpNET.Reflection.wasSetInfoValue(info, ref structure, d.Value);
}
});
return(structure);
}
public static ulong NextPowerOf2(ulong v)
{
v = BitTwiddling.PowerOf2Mask(v);
++v;
return(v);
}
public static uint NextPowerOf2(uint v)
{
v = BitTwiddling.PowerOf2Mask(v);
++v;
return(v);
}
protected static uint GetPowerOfTwo(ulong value)
{
return(BitTwiddling.GetPowerOfTwo(value));
}
protected static ulong GetLowestSetBit(ulong value)
{
return((ulong)BitTwiddling.GetLowestSetBit(value));
}
protected static bool IsPowerOfTwo64(Operand operand)
{
return(BitTwiddling.IsPowerOfTwo(operand.ConstantUnsigned64));
}
