public void AddArgument(bool isField, out NamedArgumentTypeEncoder typeEncoder, out NameEncoder name, out LiteralEncoder literal)
{
Builder.WriteByte(isField ? (byte)0x53 : (byte)0x54);
typeEncoder = new NamedArgumentTypeEncoder(Builder);
name = new NameEncoder(Builder);
literal = new LiteralEncoder(Builder);
}
public static void TypedConstant(this LiteralEncoder encoder, TypedConstant constant)
{
switch (constant.Kind)
{
case TypedConstantKind.Primitive:
encoder.Scalar().Constant(constant.Value);
break;
case TypedConstantKind.Enum:
encoder.Scalar().Constant(constant.Value);
break;
// This looks more correct, but the code above matches what the C# compiler produces
// encoder.TaggedScalar(
// type => type.Enum(constant.Type.ToString()),
// scalar => scalar.Constant(constant.Value)
//);
case TypedConstantKind.Type:
encoder.Scalar().SystemType(constant.Type.ToString());
break;
case TypedConstantKind.Array:
{
LiteralsEncoder arrayEncoder = encoder.Vector().Count(constant.Values.Length);
foreach (var arrayConstant in constant.Values)
{
arrayEncoder.AddLiteral().TypedConstant(arrayConstant);
}
break;
}
}
}
static void EncodeLiteral(LiteralEncoder litEnc, CustomAttributeTypedArgument arg)
{
if (arg.Value is Type type)
{
// Type reference
litEnc.Scalar().SystemType(type.FullName);
}
else if (arg.Value is ReadOnlyCollection <CustomAttributeTypedArgument> array)
{
// Array of values
var subLitEnc = litEnc.Vector().Count(array.Count);
foreach (var el in array)
{
EncodeLiteral(subLitEnc.AddLiteral(), el);
}
}
else if (arg.Value is null)
{
if (arg.ArgumentType.IsArray)
{
litEnc.Scalar().NullArray();
}
else
{
litEnc.Scalar().Constant(null);
}
}
else
{
// Check argument type supported (ie: simple scalar values)
PrimitiveTypeCodeFromSystemTypeCode(arg.Value.GetType());
litEnc.Scalar().Constant(arg.Value);
}
}
public void LiteralEncoder_Scalar()
{
var b = new BlobBuilder();
var e = new LiteralEncoder(b);
Assert.Same(b, e.Builder);
var s = e.Scalar();
AssertEx.Equal(new byte[0], b.ToArray());
Assert.Same(b, s.Builder);
}
public void LiteralEncoder_TaggedScalar()
{
var b = new BlobBuilder();
var e = new LiteralEncoder(b);
Assert.Same(b, e.Builder);
var parts = e.TaggedScalar();
AssertEx.Equal(new byte[0], b.ToArray());
Assert.Same(b, parts.Item1.Builder);
Assert.Same(b, parts.Item2.Builder);
b.Clear();
e.TaggedScalar(
part => Assert.Same(b, part.Builder),
part => Assert.Same(b, part.Builder));
Assert.Throws <ArgumentNullException>(() => e.TaggedScalar(null, _ => { }));
Assert.Throws <ArgumentNullException>(() => e.TaggedScalar(_ => { }, null));
}
public void LiteralEncoder_TaggedScalar()
{
var b = new BlobBuilder();
var e = new LiteralEncoder(b);
Assert.Same(b, e.Builder);
CustomAttributeElementTypeEncoder elementType;
ScalarEncoder scalar;
e.TaggedScalar(out elementType, out scalar);
AssertEx.Equal(new byte[0], b.ToArray());
Assert.Same(b, elementType.Builder);
Assert.Same(b, scalar.Builder);
b.Clear();
e.TaggedScalar(
et => Assert.Same(b, et.Builder),
s => Assert.Same(b, s.Builder));
Assert.Throws <ArgumentNullException>(() => e.TaggedScalar(null, s => { }));
Assert.Throws <ArgumentNullException>(() => e.TaggedScalar(et => { }, null));
}
public void LiteralEncoder_TaggedVector()
{
var b = new BlobBuilder();
var e = new LiteralEncoder(b);
Assert.Same(b, e.Builder);
CustomAttributeArrayTypeEncoder arrayType;
VectorEncoder vector;
e.TaggedVector(out arrayType, out vector);
AssertEx.Equal(new byte[0], b.ToArray());
Assert.Same(b, arrayType.Builder);
Assert.Same(b, vector.Builder);
b.Clear();
e.TaggedVector(
at => Assert.Same(b, at.Builder),
v => Assert.Same(b, v.Builder));
Assert.Throws <ArgumentNullException>(() => e.TaggedVector(null, v => { }));
Assert.Throws <ArgumentNullException>(() => e.TaggedVector(at => { }, null));
}
public static void EncodeConstant(this LiteralEncoder encoder, object constant)
{
encoder.Scalar().Constant(constant);
}
public void AddArgument(bool isField, out NamedArgumentTypeEncoder typeEncoder, out NameEncoder name, out LiteralEncoder literal)
{
Builder.WriteByte(isField ? (byte)0x53 : (byte)0x54);
typeEncoder = new NamedArgumentTypeEncoder(Builder);
name = new NameEncoder(Builder);
literal = new LiteralEncoder(Builder);
}
public Encoder()
{
int num;
this._state = new Base.State();
this._repDistances = new uint[4];
this._optimum = new Optimal[0x1000];
this._matchFinder = null;
this._rangeEncoder = new SharpCompress.Compressor.LZMA.RangeCoder.Encoder();
this._isMatch = new BitEncoder[0xc0];
this._isRep = new BitEncoder[12];
this._isRepG0 = new BitEncoder[12];
this._isRepG1 = new BitEncoder[12];
this._isRepG2 = new BitEncoder[12];
this._isRep0Long = new BitEncoder[0xc0];
this._posSlotEncoder = new BitTreeEncoder[4];
this._posEncoders = new BitEncoder[0x72];
this._posAlignEncoder = new BitTreeEncoder(4);
this._lenEncoder = new LenPriceTableEncoder();
this._repMatchLenEncoder = new LenPriceTableEncoder();
this._literalEncoder = new LiteralEncoder();
this._matchDistances = new uint[0x224];
this._numFastBytes = 0x20;
this._posSlotPrices = new uint[0x100];
this._distancesPrices = new uint[0x200];
this._alignPrices = new uint[0x10];
this._distTableSize = 0x2c;
this._posStateBits = 2;
this._posStateMask = 3;
this._numLiteralPosStateBits = 0;
this._numLiteralContextBits = 3;
this._dictionarySize = 0x400000;
this._dictionarySizePrev = uint.MaxValue;
this._numFastBytesPrev = uint.MaxValue;
this._matchFinderType = EMatchFinderType.BT4;
this._writeEndMark = false;
this.reps = new uint[4];
this.repLens = new uint[4];
this.properties = new byte[5];
this.tempPrices = new uint[0x80];
this._trainSize = 0;
for (num = 0; num < 0x1000L; num++)
{
this._optimum[num] = new Optimal();
}
for (num = 0; num < 4L; num++)
{
this._posSlotEncoder[num] = new BitTreeEncoder(6);
}
}
public void LiteralEncoder_TaggedScalar()
{
var b = new BlobBuilder();
var e = new LiteralEncoder(b);
Assert.Same(b, e.Builder);
CustomAttributeElementTypeEncoder elementType;
ScalarEncoder scalar;
e.TaggedScalar(out elementType, out scalar);
AssertEx.Equal(new byte[0], b.ToArray());
Assert.Same(b, elementType.Builder);
Assert.Same(b, scalar.Builder);
b.Clear();
e.TaggedScalar(
et => Assert.Same(b, et.Builder),
s => Assert.Same(b, s.Builder));
Assert.Throws<ArgumentNullException>(() => e.TaggedScalar(null, s => { }));
Assert.Throws<ArgumentNullException>(() => e.TaggedScalar(et => { }, null));
}
public void LiteralEncoder_Scalar()
{
var b = new BlobBuilder();
var e = new LiteralEncoder(b);
Assert.Same(b, e.Builder);
var s = e.Scalar();
AssertEx.Equal(new byte[0], b.ToArray());
Assert.Same(b, s.Builder);
}
public void LiteralEncoder_TaggedVector()
{
var b = new BlobBuilder();
var e = new LiteralEncoder(b);
Assert.Same(b, e.Builder);
CustomAttributeArrayTypeEncoder arrayType;
VectorEncoder vector;
e.TaggedVector(out arrayType, out vector);
AssertEx.Equal(new byte[0], b.ToArray());
Assert.Same(b, arrayType.Builder);
Assert.Same(b, vector.Builder);
b.Clear();
e.TaggedVector(
at => Assert.Same(b, at.Builder),
v => Assert.Same(b, v.Builder));
Assert.Throws<ArgumentNullException>(() => e.TaggedVector(null, v => { }));
Assert.Throws<ArgumentNullException>(() => e.TaggedVector(at => { }, null));
}
public void LiteralEncoder_TaggedScalar()
{
var b = new BlobBuilder();
var e = new LiteralEncoder(b);
Assert.Same(b, e.Builder);
var parts = e.TaggedScalar();
AssertEx.Equal(new byte[0], b.ToArray());
Assert.Same(b, parts.Item1.Builder);
Assert.Same(b, parts.Item2.Builder);
b.Clear();
e.TaggedScalar(
part => Assert.Same(b, part.Builder),
part => Assert.Same(b, part.Builder));
Assert.Throws<ArgumentNullException>(() => e.TaggedScalar(null, _ => { }));
Assert.Throws<ArgumentNullException>(() => e.TaggedScalar(_ => { }, null));
}
