public IntPtrTypeMap(TypedefNameDecl td, BindingContext ctx, TypeMapDatabase dataBase)
{
Type = td.Type;
Context = ctx;
TypeMapDatabase = dataBase;
InjectedType = new CILType(typeof(IntPtr));
}
bool HandleSpecialCILType(CILType cilType)
{
var type = cilType.Type;
if (type == typeof(string))
{
var argId = CGenerator.GenId(Context.ArgName);
var contextId = CGenerator.GenId("mono_context");
var stringText = Context.ArgName;
var param = Context.Parameter;
var isByRef = param != null && (param.IsOut || param.IsInOut);
if (isByRef)
{
stringText = string.Format("({0}->len != 0) ? {0}->str : \"\"",
Context.ArgName);
Context.SupportAfter.WriteLine("g_string_truncate({0}, 0);", Context.ArgName);
Context.SupportAfter.WriteLine("g_string_append({0}, mono_string_to_utf8(" +
"(MonoString*) {1}));", Context.ArgName, argId);
}
Context.SupportBefore.WriteLine("MonoString* {0} = mono_string_new({1}.domain, {2});",
argId, contextId, stringText);
Context.Return.Write("{0}{1}", isByRef ? "&" : string.Empty, argId);
return(true);
}
return(false);
}
public static CILTypeSpecification GetValue(ParseTreeNode node)
{
CILClassName className = null;
CILType type = null;
var classNameParseTreeNode = node.GetFirstChildWithGrammarName(GrammarNames.className);
if (classNameParseTreeNode != null)
{
className = ClassNameParseTreeNodeHelper.GetClassName(classNameParseTreeNode);
}
var typeParseTreeNode = node.GetFirstChildWithGrammarName(GrammarNames.type);
if (typeParseTreeNode != null)
{
type = TypeParseTreeNodeHelper.GetType(typeParseTreeNode);
}
return(new CILTypeSpecification
{
ClassName = className,
Type = type
});
}
internal CILFieldImpl(
CILReflectionContextImpl ctx,
Int32 anID,
CILType declaringType,
String name,
CILTypeBase fieldType,
FieldAttributes attrs
)
: this(
ctx,
anID,
new LazyWithLock <ListProxy <CILCustomAttribute> >(() => ctx.CollectionsFactory.NewListProxy <CILCustomAttribute>()),
new SettableValueForEnums <FieldAttributes>(attrs),
new SettableValueForClasses <String>(name),
() => declaringType,
() => fieldType,
new SettableLazy <Object>(() => null),
new SettableValueForClasses <Byte[]>(null),
new LazyWithLock <ListProxy <CILCustomModifier> >(() => ctx.CollectionsFactory.NewListProxy <CILCustomModifier>()),
new SettableLazy <Int32>(() => NO_OFFSET),
new SettableLazy <MarshalingInfo>(() => null),
true
)
{
}
public override int GetHashCode()
{
int hash = CILType.GetHashCode();
if (!IsUnconstrained)
{
foreach (object arg in TypeParams)
{
if (arg != null)
{
hash ^= arg.GetHashCode();
}
hash *= 3;
}
}
TypeDescriptor[] deps = GetDependentTypes();
foreach (TypeDescriptor dep in deps)
{
hash ^= dep.GetHashCode();
hash *= 3;
}
return(hash);
}
internal CILCustomAttributeTypedArgumentImpl(CILType argumentType, Object value)
{
ArgumentValidator.ValidateNotNull("Argument type", argumentType);
this.argumentType = argumentType;
this.value = value;
}
public CILVariableDecl CreateStaticGlobal(SourceInfo si, CILType type, int pointerDepth, string name)
{
var global = new CILVariableDecl(si, type, pointerDepth, name, true);
AddGlobal(global);
return(global);
}
public Boolean RemoveType(CILType type)
{
lock (this.types.Lock)
{
// ((CILTypeInternal)type).RemoveModule(); // TODO
return(this.types.Value.Remove(type));
}
}
public virtual bool VisitCILType(CILType type, TypeQualifiers quals)
{
if (!VisitType(type, quals))
{
return(false);
}
return(true);
}
public override bool VisitCILType(CILType type, TypeQualifiers quals)
{
if (HandleSpecialCILType(type))
{
return(true);
}
return(base.VisitCILType(type, quals));
}
public override TypePrinterResult VisitCILType(CILType type, TypeQualifiers quals)
{
var result = type.Type.FullName.Replace(".", "::");
if (!type.Type.IsValueType)
{
result += "^";
}
return(result);
}
public CILCustomModifier AddCustomModifier(CILType type, CILCustomModifierOptionality optionality)
{
var result = new CILCustomModifierImpl(optionality, type);
lock (this.customModifiers.Lock)
{
this.customModifiers.Value.Add(result);
}
return(result);
}
public CILField ChangeDeclaringType(params CILTypeBase[] args)
{
LogicalUtils.ThrowIfDeclaringTypeNotGeneric(this, args);
CILField fieldToGive = this;
CILType dt = this.declaringType.Value;
if (dt.GenericDefinition != null)
{
fieldToGive = dt.GenericDefinition.DeclaredFields[dt.DeclaredFields.IndexOf(this)];
}
return(this.context.Cache.MakeFieldWithGenericDeclaringType(fieldToGive, args));
}
public CILEvent ChangeDeclaringType(params CILTypeBase[] args)
{
LogicalUtils.ThrowIfDeclaringTypeNotGeneric(this, args);
CILEvent evtToGive = this;
CILType dt = this.declaringType.Value;
if (dt.GenericDefinition != null)
{
evtToGive = dt.GenericDefinition.DeclaredEvents[dt.DeclaredEvents.IndexOf(this)];
}
return(this.context.Cache.MakeEventWithGenericType(evtToGive, args));
}
public CILProperty ChangeDeclaringType(params CILTypeBase[] args)
{
LogicalUtils.ThrowIfDeclaringTypeNotGeneric(this, args);
CILProperty propToGive = this;
CILType dt = this.declaringType.Value;
if (dt.GenericDefinition != null)
{
propToGive = dt.GenericDefinition.DeclaredProperties[dt.DeclaredProperties.IndexOf(this)];
}
return(this.context.Cache.MakePropertyWithGenericType(propToGive, args));
}
private void ComputeDependentTypes()
{
if (!CILType.IsPrimitive)
{
var fields = CILType.GetFields(
BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
foreach (FieldInfo field in fields)
{
bool consider = (CILType.IsValueType && !HasIntrinsicTypeOverride) ||
field.HasCustomOrInjectedAttribute <DependentType>();
if (!consider)
{
continue;
}
object fieldVal = _sample == null ? null : field.GetValue(_sample);
if (fieldVal == null)
{
_memberTypes[field] = new TypeDescriptor(field.FieldType);
}
else
{
_memberTypes[field] = new TypeDescriptor(fieldVal);
}
}
var properties = CILType.GetProperties(
BindingFlags.Instance | BindingFlags.Public);
foreach (PropertyInfo prop in properties)
{
bool consider = prop.HasCustomOrInjectedAttribute <DependentType>();
if (!consider)
{
continue;
}
object propVal = _sample == null ? null : prop.GetValue(_sample, new object[0]);
if (propVal == null)
{
_memberTypes[prop] = new TypeDescriptor(prop.PropertyType);
}
else
{
_memberTypes[prop] = new TypeDescriptor(propVal);
}
}
}
}
public override TypePrinterResult VisitCILType(CILType type, TypeQualifiers quals)
{
switch (System.Type.GetTypeCode(type.Type))
{
case TypeCode.Boolean:
return("bool");
case TypeCode.Char:
return("char");
case TypeCode.SByte:
return("sbyte");
case TypeCode.Byte:
return("byte");
case TypeCode.Int16:
return("short");
case TypeCode.UInt16:
return("ushort");
case TypeCode.Int32:
return("int");
case TypeCode.UInt32:
return("uint");
case TypeCode.Int64:
return("long");
case TypeCode.UInt64:
return("ulong");
case TypeCode.Single:
return("float");
case TypeCode.Double:
return("double");
case TypeCode.Decimal:
return("decimal");
case TypeCode.String:
return("string");
}
return(QualifiedType(type.Type.FullName));
}
public override string VisitCILType(CILType type, TypeQualifiers quals)
{
if (type.Type == typeof(string))
{
if (param != null && (param.IsOut || param.IsInOut))
{
return("GString*");
}
return(quals.IsConst ? "const char*" : "char*");
}
throw new System.NotImplementedException(
string.Format("Unhandled .NET type: {0}", type.Type));
}
public SecurityInformation AddDeclarativeSecurity(SecurityAction action, CILType securityAttributeType)
{
lock (this.securityInfo.Value)
{
ListProxy <SecurityInformation> list;
if (!this.securityInfo.Value.CQ.TryGetValue(action, out list))
{
list = this.context.CollectionsFactory.NewListProxy <SecurityInformation>();
this.securityInfo.Value.Add(action, list);
}
var result = new SecurityInformation(action, securityAttributeType);
list.Add(result);
return(result);
}
}
internal CILPropertyImpl(CILReflectionContextImpl ctx, Int32 anID, CILType declaringType, String aName, PropertyAttributes aPropertyAttributes)
: this(
ctx,
anID,
new LazyWithLock <ListProxy <CILCustomAttribute> >(() => ctx.CollectionsFactory.NewListProxy <CILCustomAttribute>()),
new SettableValueForClasses <String>(aName),
new SettableValueForEnums <PropertyAttributes>(aPropertyAttributes),
() => null,
() => null,
() => declaringType,
new SettableLazy <Object>(() => null),
new LazyWithLock <ListProxy <CILCustomModifier> >(() => ctx.CollectionsFactory.NewListProxy <CILCustomModifier>()),
true
)
{
}
bool HandleSpecialCILType(CILType cilType)
{
var type = cilType.Type;
if (type == typeof(string))
{
var stringId = CGenerator.GenId("string");
Context.SupportBefore.WriteLine("char* {0} = mono_string_to_utf8(" +
"(MonoString*) {1});", stringId, Context.ArgName);
Context.Return.Write("{0}", stringId);
return(true);
}
return(false);
}
internal CILEventImpl(CILReflectionContextImpl ctx, Int32 anID, CILType declaringType, String aName, EventAttributes anEventAttributes, CILTypeBase anEventType)
: this(
ctx,
anID,
new LazyWithLock <ListProxy <CILCustomAttribute> >(() => ctx.CollectionsFactory.NewListProxy <CILCustomAttribute>()),
new SettableValueForClasses <String>(aName),
new SettableValueForEnums <EventAttributes>(anEventAttributes),
() => anEventType,
() => null,
() => null,
() => null,
() => ctx.CollectionsFactory.NewListProxy <CILMethod>(),
() => declaringType,
true)
{
}
public override TypePrinterResult VisitCILType(CILType type, TypeQualifiers quals)
{
if (type.Type == typeof(string))
{
return(quals.IsConst ? "const char*" : "char*");
}
switch (System.Type.GetTypeCode(type.Type))
{
case TypeCode.Boolean:
return(VisitBuiltinType(new BuiltinType(PrimitiveType.Bool), quals));
case TypeCode.Char:
case TypeCode.SByte:
case TypeCode.Byte:
return(VisitBuiltinType(new BuiltinType(PrimitiveType.Char), quals));
case TypeCode.Int16:
return(VisitBuiltinType(new BuiltinType(PrimitiveType.Short), quals));
case TypeCode.UInt16:
return(VisitBuiltinType(new BuiltinType(PrimitiveType.UShort), quals));
case TypeCode.Int32:
return(VisitBuiltinType(new BuiltinType(PrimitiveType.Int), quals));
case TypeCode.UInt32:
return(VisitBuiltinType(new BuiltinType(PrimitiveType.UInt), quals));
case TypeCode.Int64:
return(VisitBuiltinType(new BuiltinType(PrimitiveType.Long), quals));
case TypeCode.UInt64:
return(VisitBuiltinType(new BuiltinType(PrimitiveType.ULong), quals));
case TypeCode.Single:
return(VisitBuiltinType(new BuiltinType(PrimitiveType.Float), quals));
case TypeCode.Double:
return(VisitBuiltinType(new BuiltinType(PrimitiveType.Double), quals));
case TypeCode.String:
return(quals.IsConst ? "const char*" : "char*");
}
return("void*");
}
/// <summary>
/// Constructs a type descriptor.
/// </summary>
/// <param name="sample">sample value from which to extract the type information</param>
/// <param name="asPointer">whether to construct a pointer type</param>
/// <param name="asReference">whether to construct a reference type</param>
public TypeDescriptor(object sample, bool asPointer = false, bool asReference = false)
{
_sample = sample;
CILType = sample.GetType();
if (asReference)
{
CILType = CILType.MakeByRefType();
}
if (asPointer)
{
CILType = CILType.MakePointerType();
}
InitTypeParams();
ComputeDependentTypes();
Owner = RootTypeLibrary.Instance;
}
internal CILConstructorImpl(
CILReflectionContextImpl ctx,
Int32 anID,
CILType declaringType,
MethodAttributes attrs
)
: this(
ctx,
anID,
new LazyWithLock <ListProxy <CILCustomAttribute> >(() => ctx.CollectionsFactory.NewListProxy <CILCustomAttribute>()),
new SettableValueForEnums <CallingConventions>(CallingConventions.Standard),
new SettableValueForEnums <MethodAttributes>(attrs | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName),
() => declaringType,
() => ctx.CollectionsFactory.NewListProxy <CILParameter>(),
() => new MethodILImpl(declaringType.Module),
new SettableLazy <MethodImplAttributes>(() => MethodImplAttributes.IL),
null,
true
)
{
}
/// <summary>
/// Represents the described multi-dimensional array as array of arrays. Only applicable to array types.
/// </summary>
public TypeDescriptor[] MakeRank1Types()
{
if (Rank == 0)
{
throw new InvalidOperationException("This operation is possible for types with Rank >= 1");
}
if (Rank == 1)
{
return new TypeDescriptor[] { this }
}
;
if (!CILType.IsArray)
{
throw new InvalidOperationException("This operation is possible for arrays");
}
TypeDescriptor[] result = new TypeDescriptor[Rank];
Type innerType = CILType.GetElementType();
TypeDescriptor tdElem = Element0Type;
for (int i = result.Length - 1; i >= 0; i--)
{
innerType = innerType.MakeArrayType();
result[i] = new TypeDescriptor()
{
_sample = this._sample,
CILType = innerType,
HasIntrinsicTypeOverride = false,
TypeParams = new object[] { TypeParams[i] },
Constraints = this.Constraints == null ? null : new Range[] { Constraints[i] },
IsArtificial = true,
IsUnconstrained = false,
Element0Type = tdElem
};
tdElem = result[i];
}
return(result);
}
/// <summary>
/// Creates a sample instance of the described type.
/// </summary>
/// <param name="options">creation options</param>
public object GetSampleInstance(ETypeCreationOptions options = ETypeCreationOptions.AnyObject)
{
Contract.Requires(
!(options.HasFlag(ETypeCreationOptions.AdditiveNeutral) && options.HasFlag(ETypeCreationOptions.MultiplicativeNeutral)) &&
!(options.HasFlag(ETypeCreationOptions.AdditiveNeutral) && options.HasFlag(ETypeCreationOptions.NonZero)) &&
!(options.HasFlag(ETypeCreationOptions.MultiplicativeNeutral) && options.HasFlag(ETypeCreationOptions.NonZero)));
if (IsArtificial)
{
throw new InvalidOperationException("Cannot construct a sample instance from an artificial type");
}
if (options.HasFlag(ETypeCreationOptions.AdditiveNeutral) ||
options.HasFlag(ETypeCreationOptions.MultiplicativeNeutral) ||
options.HasFlag(ETypeCreationOptions.NonZero))
{
var atf = CILType.GetCustomOrInjectedAttribute <IAlgebraicTypeFactory>();
return(atf.CreateInstance(options, _sample));
}
if (_sample != null)
{
return(_sample);
}
if (options.HasFlag(ETypeCreationOptions.ReturnNullIfUnavailable))
{
return(null);
}
if (!options.HasFlag(ETypeCreationOptions.ForceCreation) && (IsConstrained || !IsStatic))
{
throw new InvalidOperationException("Cannot construct sample instance from constrained incomplete or non-static type");
}
object inst = Activator.CreateInstance(CILType);
return(inst);
}
internal static String CreateTypeString(CILType type, CILModule moduleBeingEmitted, Boolean appendGArgs)
{
if (moduleBeingEmitted == null)
{
moduleBeingEmitted = type.Module;
}
String typeString;
if (type == null)
{
typeString = null;
}
else
{
// TODO probably should forbid whitespace characters to be within type and assembly names?
var builder = new StringBuilder();
CreateTypeString(type, moduleBeingEmitted, builder, appendGArgs, false);
typeString = builder.ToString();
}
return(typeString);
}
internal CILMethodImpl(CILReflectionContextImpl ctx, Int32 anID, CILType declaringType, String name, MethodAttributes attrs, CallingConventions callingConventions)
: this(
ctx,
anID,
new LazyWithLock <ListProxy <CILCustomAttribute> >(() => ctx.CollectionsFactory.NewListProxy <CILCustomAttribute>()),
new SettableValueForEnums <CallingConventions>(callingConventions),
new SettableValueForEnums <MethodAttributes>(attrs),
() => declaringType,
() => ctx.CollectionsFactory.NewListProxy <CILParameter>(),
() => new MethodILImpl(declaringType.Module),
new SettableLazy <MethodImplAttributes>(() => MethodImplAttributes.IL),
null,
new SettableValueForClasses <String>(name),
() => ctx.Cache.NewBlankParameter(ctx.Cache.ResolveMethodBaseID(anID), E_CIL.RETURN_PARAMETER_POSITION, null, ParameterAttributes.None, declaringType.Module.AssociatedMSCorLibModule.GetTypeByName(Consts.VOID)),
() => ctx.CollectionsFactory.NewListProxy <CILTypeBase>(),
() => null,
() => ctx.CollectionsFactory.NewListProxy <CILMethod>(),
null,
null,
null,
true)
{
}
public string VisitCILType(CILType type, TypeQualifiers quals)
{
return(string.Empty);
}
public override bool VisitClassDecl(Class @class)
{
// FIXME: Add a better way to hook the event
if (!isHooked)
{
Driver.Generator.OnUnitGenerated += OnUnitGenerated;
isHooked = true;
}
if (!VisitDeclaration(@class))
return false;
// We can't handle value types yet
// The generated code assumes that a NativePtr is available
if (@class.IsValueType)
return false;
foreach (var method in @class.Methods)
{
if (!IsInsertionOperator(method))
continue;
// Create the ToString method
var stringType = GetType("std::string");
if (stringType == null)
stringType = new CILType(typeof(string));
var toStringMethod = new Method()
{
Name = "ToString",
Namespace = @class,
ReturnType = new QualifiedType(stringType),
IsSynthetized = true,
IsOverride = true,
IsProxy = true
};
@class.Methods.Add(toStringMethod);
Driver.Diagnostics.Debug("Function converted to ToString: {0}::{1}",
@class.Name, method.Name);
break;
}
var methodEqualsParam = new Parameter
{
Name = "object",
QualifiedType = new QualifiedType(new CILType(typeof(Object))),
};
var methodEquals = new Method
{
Name = "Equals",
Namespace = @class,
ReturnType = new QualifiedType(new BuiltinType(PrimitiveType.Bool)),
Parameters = new List<Parameter> { methodEqualsParam },
IsSynthetized = true,
IsOverride = true,
IsProxy = true
};
@class.Methods.Add(methodEquals);
var methodHashCode = new Method
{
Name = "GetHashCode",
Namespace = @class,
ReturnType = new QualifiedType(new BuiltinType(PrimitiveType.Int)),
IsSynthetized = true,
IsOverride = true,
IsProxy = true
};
@class.Methods.Add(methodHashCode);
return true;
}
