public void ReadStateFrom(IConstantProvider item)
{
if (item.HasConstant)
{
if (item.Constant == null)
{
if (ConstantTypes.Items.Count > 1)
ConstantTypes.SelectedItem = ConstantTypes.Items[1];
}
else
{
foreach (IOperandEditor editor in ConstantTypes.Items)
{
if (editor.IsOperandHandled(item.Constant))
{
ConstantTypes.SelectedItem = editor;
editor.SelectedOperand = item.Constant;
return;
}
}
}
}
else
{
if (ConstantTypes.Items.Count > 0)
{
ConstantTypes.SelectedItem = ConstantTypes.Items[0];
}
}
}
public static void ResolveConstant(
this IConstantProvider self,
/*Telerik Authorship*/ ref ConstantValue constant,
ModuleDefinition module)
{
if (module == null)
{
constant = Mixin.NoValue;
return;
}
lock (module.SyncRoot) {
if (constant != Mixin.NotResolved)
{
return;
}
if (module.HasImage())
{
constant = module.Read(self, (provider, reader) => reader.ReadConstant(provider));
}
else
{
constant = Mixin.NoValue;
}
}
}
public void ReadStateFrom(IConstantProvider item)
{
if (item.HasConstant)
{
if (item.Constant == null)
{
if (ConstantTypes.Items.Count > 1)
{
ConstantTypes.SelectedItem = ConstantTypes.Items[1];
}
}
else
{
foreach (IOperandEditor editor in ConstantTypes.Items)
{
if (editor.IsOperandHandled(item.Constant))
{
ConstantTypes.SelectedItem = editor;
editor.SelectedOperand = item.Constant;
}
}
}
}
else
{
if (ConstantTypes.Items.Count > 0)
{
ConstantTypes.SelectedItem = ConstantTypes.Items[0];
}
}
}
public static void ResolveConstant(
this IConstantProvider self,
ref object constant,
ModuleDefinition module)
{
if (module == null)
{
constant = Root.Code.Libs.Mono.Cecil.Mixin.NoValue;
return;
}
lock (module.SyncRoot) {
if (constant != Root.Code.Libs.Mono.Cecil.Mixin.NotResolved)
{
return;
}
if (module.HasImage())
{
constant = module.Read(self, (provider, reader) => reader.ReadConstant(provider));
}
else
{
constant = Root.Code.Libs.Mono.Cecil.Mixin.NoValue;
}
}
}
public static void ResolveConstant(this IConstantProvider self, ref object constant, ModuleDefinition module)
{
if (module == null)
{
constant = Mixin.NoValue;
return;
}
object syncRoot;
Monitor.Enter(syncRoot = module.SyncRoot);
try
{
if (constant == Mixin.NotResolved)
{
if (module.HasImage())
{
constant = module.Read <IConstantProvider, object>(self, (IConstantProvider provider, MetadataReader reader) => reader.ReadConstant(provider));
}
else
{
constant = Mixin.NoValue;
}
}
}
finally
{
Monitor.Exit(syncRoot);
}
}
public static void ResolveConstant(
this IConstantProvider self,
ref object constant,
ModuleDefinition module)
{
constant = module.HasImage()
? module.Read(self, (provider, reader) => reader.ReadConstant(provider))
: Mixin.NoValue;
}
public void CopyStateTo(IConstantProvider item)
{
if (ConstantTypes.SelectedItem != null)
{
var editor = (IOperandEditor) ConstantTypes.SelectedItem;
item.Constant = editor.SelectedOperand;
item.HasConstant = !(editor is NoneOperandEditor);
}
else
{
item.Constant = null;
item.HasConstant = false;
}
}
public void CopyStateTo(IConstantProvider item)
{
if (ConstantTypes.SelectedItem != null)
{
IOperandEditor editor = (IOperandEditor)ConstantTypes.SelectedItem;
item.Constant = editor.SelectedOperand;
item.HasConstant = !(editor is NoneOperandEditor);
}
else
{
item.Constant = null;
item.HasConstant = false;
}
}
public static void ResolveConstant (
IConstantProvider self,
ref object constant,
ModuleDefinition module)
{
lock (module.SyncRoot) {
if (constant != Mixin.NotResolved)
return;
if (Mixin.HasImage (module))
constant = module.Read (self, (provider, reader) => reader.ReadConstant (provider));
else
constant = Mixin.NoValue;
}
}
private void WriteParameterAttributes(int index, IConstantProvider cp, ICustomAttributeProvider cap)
{
if (!cp.HasConstant && !cap.HasCustomAttributes)
{
return;
}
_output.Write(".param [{0}]", index);
if (cp.HasConstant)
{
_output.Write(" = ");
WriteConstant(cp.Constant);
}
_output.WriteLine();
WriteAttributes(cap.CustomAttributes);
}
public static void ResolveConstant(
IConstantProvider self,
ref object constant,
ModuleDefinition module)
{
lock (module.SyncRoot) {
if (constant != Mixin.NotResolved)
{
return;
}
if (Mixin.HasImage(module))
{
constant = module.Read(self, (provider, reader) => reader.ReadConstant(provider));
}
else
{
constant = Mixin.NoValue;
}
}
}
public static void ResolveConstant(this IConstantProvider self, ref object constant, ModuleDefinition module)
{
if (module == null)
{
constant = NoValue;
}
else
{
lock (module.SyncRoot)
{
if (constant == NotResolved)
{
if (!module.HasImage())
{
constant = NoValue;
}
else
{
constant = module.Read <IConstantProvider, object>(self, (provider, reader) => reader.ReadConstant(provider));
}
}
}
}
}
internal static byte[] ConstantDataFor(IConstantProvider constantProvider, TypeReference declaredParameterOrFieldType, string name)
{
GenericInstanceType type = declaredParameterOrFieldType as GenericInstanceType;
if ((type != null) && Unity.IL2CPP.Common.TypeReferenceEqualityComparer.AreEqual(declaredParameterOrFieldType.Resolve(), TypeProvider.SystemNullable, TypeComparisonMode.Exact))
{
return ConstantDataFor(constantProvider, type.GenericArguments[0], name);
}
if (Extensions.IsEnum(declaredParameterOrFieldType))
{
declaredParameterOrFieldType = Extensions.GetUnderlyingEnumType(declaredParameterOrFieldType);
}
object constant = constantProvider.Constant;
if (DetermineMetadataTypeForDefaultValueBasedOnTypeOfConstant(declaredParameterOrFieldType.MetadataType, constant) != declaredParameterOrFieldType.MetadataType)
{
constant = ChangePrimitiveType(constant, declaredParameterOrFieldType);
}
switch (declaredParameterOrFieldType.MetadataType)
{
case MetadataType.Boolean:
return new byte[] { (!((bool) constant) ? ((byte) 0) : ((byte) 1)) };
case MetadataType.Char:
return BitConverter.GetBytes((ushort) ((char) constant));
case MetadataType.SByte:
return new byte[] { ((byte) ((sbyte) constant)) };
case MetadataType.Byte:
return new byte[] { ((byte) constant) };
case MetadataType.Int16:
return BitConverter.GetBytes((short) constant);
case MetadataType.UInt16:
return BitConverter.GetBytes((ushort) constant);
case MetadataType.Int32:
return BitConverter.GetBytes((int) constant);
case MetadataType.UInt32:
return BitConverter.GetBytes((uint) constant);
case MetadataType.Int64:
return BitConverter.GetBytes((long) constant);
case MetadataType.UInt64:
return BitConverter.GetBytes((ulong) constant);
case MetadataType.Single:
return BitConverter.GetBytes((float) constant);
case MetadataType.Double:
return BitConverter.GetBytes((double) constant);
case MetadataType.String:
{
string s = (string) constant;
int byteCount = Encoding.UTF8.GetByteCount(s);
byte[] destinationArray = new byte[4 + byteCount];
Array.Copy(BitConverter.GetBytes(s.Length), destinationArray, 4);
Array.Copy(Encoding.UTF8.GetBytes(s), 0, destinationArray, 4, byteCount);
return destinationArray;
}
case MetadataType.Array:
case MetadataType.Object:
if (constant != null)
{
throw new InvalidOperationException(string.Format("Default value for field {0} must be null.", name));
}
return null;
}
throw new ArgumentOutOfRangeException();
}
public UnitService(IConstantProvider <S, T> constantProvider)
{
ConstantProvider = constantProvider;
}
static object FormatParameterConstant(IConstantProvider parameter)
{
return parameter.Constant is string ? string.Format(CultureInfo.InvariantCulture, "\"{0}\"", parameter.Constant) : (parameter.Constant ?? "null");
}
internal static byte[] ConstantDataFor(IConstantProvider constantProvider, TypeReference declaredParameterOrFieldType, string name)
{
GenericInstanceType type = declaredParameterOrFieldType as GenericInstanceType;
if ((type != null) && Unity.IL2CPP.Common.TypeReferenceEqualityComparer.AreEqual(declaredParameterOrFieldType.Resolve(), TypeProvider.SystemNullable, TypeComparisonMode.Exact))
{
return(ConstantDataFor(constantProvider, type.GenericArguments[0], name));
}
if (declaredParameterOrFieldType.IsEnum())
{
declaredParameterOrFieldType = declaredParameterOrFieldType.GetUnderlyingEnumType();
}
object constant = constantProvider.Constant;
if (DetermineMetadataTypeForDefaultValueBasedOnTypeOfConstant(declaredParameterOrFieldType.MetadataType, constant) != declaredParameterOrFieldType.MetadataType)
{
constant = ChangePrimitiveType(constant, declaredParameterOrFieldType);
}
switch (declaredParameterOrFieldType.MetadataType)
{
case MetadataType.Boolean:
return(new byte[] { (!((bool)constant) ? ((byte)0) : ((byte)1)) });
case MetadataType.Char:
return(BitConverter.GetBytes((ushort)((char)constant)));
case MetadataType.SByte:
return(new byte[] { ((byte)((sbyte)constant)) });
case MetadataType.Byte:
return(new byte[] { ((byte)constant) });
case MetadataType.Int16:
return(BitConverter.GetBytes((short)constant));
case MetadataType.UInt16:
return(BitConverter.GetBytes((ushort)constant));
case MetadataType.Int32:
return(BitConverter.GetBytes((int)constant));
case MetadataType.UInt32:
return(BitConverter.GetBytes((uint)constant));
case MetadataType.Int64:
return(BitConverter.GetBytes((long)constant));
case MetadataType.UInt64:
return(BitConverter.GetBytes((ulong)constant));
case MetadataType.Single:
return(BitConverter.GetBytes((float)constant));
case MetadataType.Double:
return(BitConverter.GetBytes((double)constant));
case MetadataType.String:
{
string s = (string)constant;
int byteCount = Encoding.UTF8.GetByteCount(s);
byte[] destinationArray = new byte[4 + byteCount];
Array.Copy(BitConverter.GetBytes(s.Length), destinationArray, 4);
Array.Copy(Encoding.UTF8.GetBytes(s), 0, destinationArray, 4, byteCount);
return(destinationArray);
}
case MetadataType.Array:
case MetadataType.Object:
if (constant != null)
{
throw new InvalidOperationException($"Default value for field {name} must be null.");
}
return(null);
}
throw new ArgumentOutOfRangeException();
}
static object FormatParameterConstant(IConstantProvider parameter)
{
return(parameter.Constant is string?string.Format("\"{0}\"", parameter.Constant) : (parameter.Constant ?? "null"));
}
private static object FormatParameterConstant(IConstantProvider parameter)
{
return parameter.Constant is string ? string.Format("\"{0}\"", parameter.Constant) : (parameter.Constant ?? "null");
}
static object FormatParameterConstant(IConstantProvider parameter)
{
return(parameter.Constant is string?string.Format(CultureInfo.InvariantCulture, "\"{0}\"", parameter.Constant) : (parameter.Constant ?? "null"));
}
public void SetUp()
{
ConstantProvider = new ConstantProvider <S, T>();
}
