public static ArrayType GetStringType(ResolutionContext ctxt, LiteralSubformat fmt = LiteralSubformat.Utf8)
{
ArrayType _t = null;
if (ctxt != null && ctxt.ScopedBlock != null)
{
var obj = ctxt.ParseCache.LookupModuleName(ctxt.ScopedBlock.NodeRoot as DModule, "object").FirstOrDefault();
if (obj != null)
{
string strType = fmt == LiteralSubformat.Utf32 ? "dstring" :
fmt == LiteralSubformat.Utf16 ? "wstring" :
"string";
var strNode = obj[strType];
if (strNode != null)
foreach (var n in strNode) {
_t = TypeDeclarationResolver.HandleNodeMatch(n, ctxt) as ArrayType;
if (_t != null)
break;
}
}
}
if (_t == null)
{
var ch = fmt == LiteralSubformat.Utf32 ? DTokens.Dchar :
fmt == LiteralSubformat.Utf16 ? DTokens.Wchar : DTokens.Char;
_t = new ArrayType(new PrimitiveType(ch, DTokens.Immutable));
}
return _t;
}
public override bool VisitArrayType(ArrayType array, TypeQualifiers quals)
{
TypeMap typeMap;
if (TypeMapDatabase.FindTypeMap(array, out typeMap) && typeMap.IsIgnored)
{
Ignore();
return false;
}
if (array.SizeType != ArrayType.ArraySize.Constant)
return true;
var arrayElemType = array.Type.Desugar();
Class @class;
if (arrayElemType.TryGetClass(out @class) && @class.IsRefType)
return true;
PrimitiveType primitive;
if ((arrayElemType.IsPrimitiveType(out primitive) && primitive != PrimitiveType.LongDouble) ||
arrayElemType.IsPointerToPrimitiveType())
return true;
Ignore();
return false;
}
public void Execute()
{
var assemblyContainsAttribute = ModuleDefinition.Assembly.CustomAttributes.ContainsAttribute("LogMinimalMessageAttribute");
var moduleContainsAttribute = ModuleDefinition.CustomAttributes.ContainsAttribute("LogMinimalMessageAttribute");
if (assemblyContainsAttribute || moduleContainsAttribute)
{
LogMinimalMessage = true;
}
FindReference();
Init();
var stringType = ModuleDefinition.TypeSystem.String.Resolve();
ConcatMethod = ModuleDefinition.Import(stringType.FindMethod("Concat", "String", "String"));
FormatMethod = ModuleDefinition.Import(stringType.FindMethod("Format", "String", "Object[]"));
ObjectArray = new ArrayType(ModuleDefinition.TypeSystem.Object);
FindExceptionType();
foreach (var type in ModuleDefinition
.GetTypes()
.Where(x => (x.BaseType != null) && !x.IsEnum && !x.IsInterface))
{
ProcessType(type);
}
//TODO: ensure attributes dont exist on interfaces
RemoveReference();
}
public static ArrayType GetStringType(ResolverContextStack ctxt, LiteralSubformat fmt = LiteralSubformat.Utf8)
{
ArrayType _t = null;
if (ctxt != null)
{
var obj = ctxt.ParseCache.LookupModuleName("object").First();
string strType = fmt == LiteralSubformat.Utf32 ? "dstring" :
fmt == LiteralSubformat.Utf16 ? "wstring" :
"string";
var strNode = obj[strType];
if(strNode!=null && strNode.Count != 0)
_t = DResolver.StripAliasSymbol(TypeDeclarationResolver.HandleNodeMatch(strNode[0], ctxt)) as ArrayType;
}
if (_t == null)
{
var ch = fmt == LiteralSubformat.Utf32 ? DTokens.Dchar :
fmt == LiteralSubformat.Utf16 ? DTokens.Wchar : DTokens.Char;
_t = new ArrayType(new PrimitiveType(ch, DTokens.Immutable),
new ArrayDecl
{
ValueType = new MemberFunctionAttributeDecl(DTokens.Immutable)
{
InnerType = new DTokenDeclaration(ch)
}
});
}
return _t;
}
public void TyfoArray()
{
ArrayType arr = new ArrayType(PrimitiveType.Int32, 10);
tyreffo.WriteDeclaration(arr, "a");
string sExp = "int32 a[10]";
Assert.AreEqual(sExp, sw.ToString());
}
public static void Tabularize(ArrayType a, string tasName)
{
((ICDType)a.m_type).Tabularize(tasName);
if (a.m_type.Constructed)
{
TypeAssigment newTas = ((ICDModule)a.m_module).CreateNewTypeAssigment(tasName, a.m_type, new List<string>());
a.m_type = ReferenceType.CreateByName(newTas);
}
}
public void VisitArray(ArrayType at)
{
var addrEnd = rdr.Address + cbSize;
for (int i = 0; at.IsUnbounded || i < at.Length; ++i)
{
if (!rdr.IsValid || addrEnd <= rdr.Address)
return;
at.ElementType.Accept(this);
}
}
/// <summary>
/// Инициализирует новый экземпляр класса <see cref="ScalarArray"/> с указанием его типа
/// </summary>
/// <param name="arrayType">Значение перечисления <see cref="ArrayType"/>, определяющая тип скалярного массива</param>
private ScalarArray(ArrayType arrayType)
: base(true)
{
if (arrayType < ArrayType.Scalar || arrayType > ArrayType.Double)
{
throw new ArgumentOutOfRangeException("arrayType");
}
Type = arrayType;
}
public void VisitArray(ArrayType at)
{
if (at.Length == 0)
{
scanner.Warn(Address, "User-specified arrays must have a non-zero size.");
return;
}
for (int i = 0; i < at.Length; ++i)
{
at.ElementType.Accept(this);
}
}
public static ArrayType MakeArrayType(this TypeReference self, int rank)
{
if (rank == 0)
throw new ArgumentOutOfRangeException ("rank");
var array = new ArrayType (self);
for (int i = 1; i < rank; i++)
array.Dimensions.Add (new ArrayDimension ());
return array;
}
public override void CheckSemantic(Scope scope, List<Error> errors)
{
//es añadido al scope en el CheckSemantic del TypeDeclarationSecuence si no esta redefinido incorrectamente
TigerType elementsType = scope.GetType(ElementsTypeName);
if (elementsType == null)
{
errors.Add(new Error(GetChild(1), "El tipo '{0}' no está definido en el ámbito actual", ElementsTypeName));
HasError = true;
RelatedType = new ArrayType(UndefinedType.UndefinedInstance, ElementsTypeName);
}
else
RelatedType = new ArrayType(elementsType, ElementsTypeName);
}
public void StructureContainingArray()
{
ArrayType a = new ArrayType(PrimitiveType.Int32, 4);
StructureType s = new StructureType(null, 0) { Fields = { { 8, a } } };
TypeVariable tv = store.CreateTypeVariable(factory);
tv.Class.DataType = s;
Assert.AreEqual(1, store.UsedEquivalenceClasses.Count);
DataType dt = tv.Class.DataType.Accept(nct);
Assert.AreEqual(1, store.UsedEquivalenceClasses.Count);
Assert.AreEqual("(struct (8 (arr int32 4) a0008))", store.UsedEquivalenceClasses[0].DataType.ToString());
}
public override DataType VisitArray(ArrayType at)
{
if (insideComplexType)
{
var nctr = new NestedComplexTypeExtractor(factory, store);
at.Accept(nctr);
return at;
}
else
{
insideComplexType = true;
return base.VisitArray(at);
}
}
public void CEB_BuildByteArrayFetch()
{
var i = new Identifier("i", PrimitiveType.Word32, null);
DataType arrayOfBytes = new ArrayType(PrimitiveType.Byte, 0);
StructureType str = Struct(
Fld(0x01000, arrayOfBytes));
CreateTv(globals, Ptr32(str), Ptr32(PrimitiveType.Byte));
CreateTv(i, PrimitiveType.Int32, PrimitiveType.Word32);
var ceb = new ComplexExpressionBuilder(
PrimitiveType.Byte,
globals.TypeVariable.DataType,
globals.TypeVariable.OriginalDataType,
null,
globals, i, 0x1000);
ceb.Dereferenced = true;
Assert.AreEqual("globals->a1000[i]", ceb.BuildComplex().ToString());
}
public void ArrayOfStructures()
{
StructureType s = new StructureType();
s.Fields.Add(0, PrimitiveType.Word32);
s.Fields.Add(4, PrimitiveType.Real64);
ArrayType a = new ArrayType(s, 0);
TypeVariable tv = store.CreateTypeVariable(factory);
tv.Class.DataType = a;
Assert.AreEqual(1, store.UsedEquivalenceClasses.Count);
tv.Class.DataType.Accept(nct);
Assert.AreEqual(2, store.UsedEquivalenceClasses.Count);
Assert.AreEqual("(arr Eq_2)", store.UsedEquivalenceClasses[0].DataType.ToString());
Assert.AreEqual("(struct (0 word32 dw0000) (4 real64 r0004))", store.UsedEquivalenceClasses[1].DataType.ToString());
}
public void Execute()
{
FindReference();
Init();
var stringType = ModuleDefinition.TypeSystem.String.Resolve();
ConcatMethod = ModuleDefinition.Import(stringType.FindMethod("Concat", "String", "String"));
FormatMethod = ModuleDefinition.Import(stringType.FindMethod("Format", "String", "Object[]"));
ObjectArray = new ArrayType(ModuleDefinition.TypeSystem.Object);
FindExceptionType();
foreach (var type in ModuleDefinition
.GetTypes()
.Where(x => (x.BaseType != null) && !x.IsEnum && !x.IsInterface))
{
ProcessType(type);
}
//TODO: ensure attributes don't exist on interfaces
RemoveReference();
}
public static void PrintCInitialize(ArrayType pThis, PEREffectiveConstraint cns,
Asn1Value defauleVal, StreamWriterLevel c, string typeName, string varName, int lev, int arrayDepth)
{
long min = pThis.minItems(cns);
long max = pThis.maxItems(cns);
string i = "i" + arrayDepth.ToString();
string prefix = "";
bool topLevel = !varName.Contains("->");
if (topLevel)
prefix = varName + "->";
else
{
prefix = varName + ".";
}
ArrayValue arVal = defauleVal as ArrayValue;
if (arVal == null)
{
c.P(lev);
c.WriteLine("{0}nCount = 0;", prefix);
c.P(lev); c.WriteLine("for({0}=0;{0}<{1};{0}++)", i, pThis.maxItems(cns));
c.P(lev); c.WriteLine("{");
((ISCCType)pThis.m_type).PrintCInitialize(pThis.m_type.PEREffectiveConstraint, pThis.m_type.GetOneValidValue(), c,
typeName + "_arr", prefix + "arr[" + i + "]", lev + 1, arrayDepth + 1);
c.P(lev); c.WriteLine("}");
}
else
{
c.P(lev);
c.WriteLine("{0}nCount = {1};", prefix, arVal.m_children.Count);
for (int k = 0; k < arVal.m_children.Count; k++)
{
c.P(lev); c.WriteLine("{");
((ISCCType)pThis.m_type).PrintCInitialize(pThis.m_type.PEREffectiveConstraint, arVal.m_children[k], c,
typeName + "_arr", prefix + "arr[" + k.ToString() + "]", lev + 1, arrayDepth + 1);
c.P(lev); c.WriteLine("}");
}
}
}
public void TestIsValue()
{
object[][] values = new object[][]
{
new object[] {new int[4], true, "int[4]" },
new object[] {new bool[4], false , "bool[4]"},
new object[] {new int[2,2] {{1, 2},{3,4}}, false, "int[2,2] {{1, 2},{3,4}}"},
new object[] {new int[][] {new int[] {1,2},new int[] {3,4}}, false, "int[] {1,2},new int[] {3,4}}"},
new object[] {new object[] {1,2}, true, "object[] {1,2}"},
new object[] {new object[] {1,true}, false, "object[] {1,true}"},
new object[] {new object[] {1,null}, true, "object[] {1,null}"},
new object[] {new object[,] {{1,2},{3,4}}, false, "object[,] {{1,2},{3,4}}"},
};
ArrayType type = new ArrayType(1, SimpleType.Integer);
for (int i = 0; i < values.Length; i++)
{
object value = values[i][0];
bool result = (bool)values[i][1];
string descr = (string) values[i][2];
Assert.AreEqual(result, type.IsValue(value), descr);
}
}
public void LoadSystemTypes()
{
var mscorlib = AssemblyResolver.Resolve("mscorlib");
var typeType = mscorlib.MainModule.Types.FirstOrDefault(x => x.Name == "Type");
if (typeType == null)
{
var runtime = AssemblyResolver.Resolve("System.Runtime");
typeType = runtime.MainModule.Types.First(x => x.Name == "Type");
}
var funcDefinition = typeType.Module.Types.First(x => x.Name == "Func`1");
var genericInstanceType = new GenericInstanceType(funcDefinition);
genericInstanceType.GenericArguments.Add(ModuleDefinition.TypeSystem.String);
GenericFunc = ModuleDefinition.ImportReference(genericInstanceType);
var methodReference = new MethodReference("Invoke", funcDefinition.FindMethod("Invoke").ReturnType, genericInstanceType) { HasThis = true };
FuncInvokeMethod = ModuleDefinition.ImportReference(methodReference);
GetTypeFromHandle = typeType.Methods
.First(x => x.Name == "GetTypeFromHandle" &&
x.Parameters.Count == 1 &&
x.Parameters[0].ParameterType.Name == "RuntimeTypeHandle");
GetTypeFromHandle = ModuleDefinition.ImportReference(GetTypeFromHandle);
var stringType = ModuleDefinition.TypeSystem.String.Resolve();
ConcatMethod = ModuleDefinition.ImportReference(stringType.FindMethod("Concat", "String", "String"));
FormatMethod = ModuleDefinition.ImportReference(stringType.FindMethod("Format", "String", "Object[]"));
ObjectArray = new ArrayType(ModuleDefinition.TypeSystem.Object);
var exceptionType = mscorlib.MainModule.Types.FirstOrDefault(x => x.Name == "Exception");
if (exceptionType == null)
{
var runtime = AssemblyResolver.Resolve("System.Runtime");
exceptionType = runtime.MainModule.Types.First(x => x.Name == "Exception");
}
ExceptionType = ModuleDefinition.ImportReference(exceptionType);
}
public override bool VisitArrayType(ArrayType array, TypeQualifiers quals)
{
if (!VisitType(array, quals))
return false;
switch (array.SizeType)
{
case ArrayType.ArraySize.Constant:
var supportBefore = Context.SupportBefore;
supportBefore.WriteLine("if ({0} != nullptr)", Context.ArgName);
supportBefore.WriteStartBraceIndent();
supportBefore.WriteLine("for (int i = 0; i < {0}; i++)", array.Size);
supportBefore.WriteLineIndent("{0}[i] = {1}[i]{2};",
Context.ReturnVarName, Context.ArgName,
array.Type.IsPointerToPrimitiveType(PrimitiveType.Void) ? ".ToPointer()" : string.Empty);
supportBefore.WriteCloseBraceIndent();
break;
default:
Context.Return.Write("null");
break;
}
return true;
}
public void Execute()
{
var assemblyContainsAttribute = ModuleDefinition.Assembly.CustomAttributes.ContainsAttribute("Anotar.Catel.LogMinimalMessageAttribute");
var moduleContainsAttribute = ModuleDefinition.CustomAttributes.ContainsAttribute("Anotar.Catel.LogMinimalMessageAttribute");
if (assemblyContainsAttribute || moduleContainsAttribute)
{
LogMinimalMessage = true;
}
FindReference();
Init();
var stringType = ModuleDefinition.TypeSystem.String.Resolve();
ConcatMethod = ModuleDefinition.Import(stringType.FindMethod("Concat", "String", "String"));
FormatMethod = ModuleDefinition.Import(stringType.FindMethod("Format", "String", "Object[]"));
ObjectArray = new ArrayType(ModuleDefinition.TypeSystem.Object);
var mscorlib = AssemblyResolver.Resolve("mscorlib");
var mscorlibTypes = mscorlib.MainModule.Types;
var typeType = mscorlibTypes.First(x => x.Name == "Type");
getTypeFromHandle = typeType.Methods
.First(x => x.Name == "GetTypeFromHandle" &&
x.Parameters.Count == 1 &&
x.Parameters[0].ParameterType.Name == "RuntimeTypeHandle");
getTypeFromHandle = ModuleDefinition.Import(getTypeFromHandle);
var msCoreLibDefinition = AssemblyResolver.Resolve("mscorlib");
ExceptionType = ModuleDefinition.Import(msCoreLibDefinition.MainModule.Types.First(x => x.Name == "Exception"));
foreach (var type in ModuleDefinition
.GetTypes()
.Where(x => (x.BaseType != null) && !x.IsEnum && !x.IsInterface))
{
ProcessType(type);
}
RemoveReference();
}
protected ArrayType(ArrayType.Internal* native, bool skipVTables = false)
: base((CppSharp.Parser.AST.Type.Internal*) null)
{
__PointerAdjustment = 0;
if (native == null)
return;
__Instance = new global::System.IntPtr(native);
}
public static ArrayType __CreateInstance(ArrayType.Internal native, bool skipVTables = false)
{
return new ArrayType(native, skipVTables);
}
public override TypePrinterResult VisitArrayType(ArrayType array,
TypeQualifiers quals)
{
return(string.Format("{0}[]", array.Type.Visit(this)));
}
public virtual TypePrinterResult VisitArrayType(ArrayType array,
TypeQualifiers quals)
{
throw new NotImplementedException();
}
protected virtual void Visit(ArrayType arrayType, Context context)
{
VisitTypeReference(arrayType.ElementType, context.ElementType(arrayType));
}
/// <summary>
/// CoreCLR has no Array`1 type to hang the various generic interfaces off.
/// Return nothing at compile time so the runtime figures it out.
/// </summary>
protected override RuntimeInterfacesAlgorithm GetRuntimeInterfacesAlgorithmForNonPointerArrayType(ArrayType type)
{
return(BaseTypeRuntimeInterfacesAlgorithm.Instance);
}
public override MethodIL EmitIL()
{
ILEmitter emitter = new ILEmitter();
ILCodeStream codeStream = emitter.NewCodeStream();
ArrayType invocationListArrayType = SystemDelegateType.MakeArrayType();
ILLocalVariable delegateArrayLocal = emitter.NewLocal(invocationListArrayType);
ILLocalVariable invocationCountLocal = emitter.NewLocal(Context.GetWellKnownType(WellKnownType.Int32));
ILLocalVariable iteratorLocal = emitter.NewLocal(Context.GetWellKnownType(WellKnownType.Int32));
ILLocalVariable delegateToCallLocal = emitter.NewLocal(SystemDelegateType);
ILLocalVariable returnValueLocal = 0;
if (!Signature.ReturnType.IsVoid)
{
returnValueLocal = emitter.NewLocal(Signature.ReturnType);
}
// Fill in delegateArrayLocal
// Delegate[] delegateArrayLocal = (Delegate[])this.m_helperObject
// ldarg.0 (this pointer)
// ldfld Delegate.HelperObjectField
// castclass Delegate[]
// stloc delegateArrayLocal
codeStream.EmitLdArg(0);
codeStream.Emit(ILOpcode.ldfld, emitter.NewToken(HelperObjectField));
codeStream.Emit(ILOpcode.castclass, emitter.NewToken(invocationListArrayType));
codeStream.EmitStLoc(delegateArrayLocal);
// Fill in invocationCountLocal
// int invocationCountLocal = this.m_extraFunctionPointerOrData
// ldarg.0 (this pointer)
// ldfld Delegate.m_extraFunctionPointerOrData
// stloc invocationCountLocal
codeStream.EmitLdArg(0);
codeStream.Emit(ILOpcode.ldfld, emitter.NewToken(ExtraFunctionPointerOrDataField));
codeStream.EmitStLoc(invocationCountLocal);
// Fill in iteratorLocal
// int iteratorLocal = 0;
// ldc.0
// stloc iteratorLocal
codeStream.EmitLdc(0);
codeStream.EmitStLoc(iteratorLocal);
// Loop across every element of the array.
ILCodeLabel startOfLoopLabel = emitter.NewCodeLabel();
codeStream.EmitLabel(startOfLoopLabel);
// Implement as do/while loop. We only have this stub in play if we're in the multicast situation
// Find the delegate to call
// Delegate = delegateToCallLocal = delegateArrayLocal[iteratorLocal];
// ldloc delegateArrayLocal
// ldloc iteratorLocal
// ldelem System.Delegate
// stloc delegateToCallLocal
codeStream.EmitLdLoc(delegateArrayLocal);
codeStream.EmitLdLoc(iteratorLocal);
codeStream.Emit(ILOpcode.ldelem, emitter.NewToken(SystemDelegateType));
codeStream.EmitStLoc(delegateToCallLocal);
// Call the delegate
// returnValueLocal = delegateToCallLocal(...);
// ldloc delegateToCallLocal
// ldfld System.Delegate.m_firstParameter
// ldarg 1, n
// ldloc delegateToCallLocal
// ldfld System.Delegate.m_functionPointer
// calli returnValueType thiscall (all the params)
// IF there is a return value
// stloc returnValueLocal
codeStream.EmitLdLoc(delegateToCallLocal);
codeStream.Emit(ILOpcode.ldfld, emitter.NewToken(FirstParameterField));
for (int i = 0; i < Signature.Length; i++)
{
codeStream.EmitLdArg(i + 1);
}
codeStream.EmitLdLoc(delegateToCallLocal);
codeStream.Emit(ILOpcode.ldfld, emitter.NewToken(FunctionPointerField));
CalliIntrinsic.EmitTransformedCalli(emitter, codeStream, Signature);
//codeStream.Emit(ILOpcode.calli, emitter.NewToken(Signature));
if (returnValueLocal != 0)
{
codeStream.EmitStLoc(returnValueLocal);
}
// Increment iteratorLocal
// ++iteratorLocal;
// ldloc iteratorLocal
// ldc.i4.1
// add
// stloc iteratorLocal
codeStream.EmitLdLoc(iteratorLocal);
codeStream.EmitLdc(1);
codeStream.Emit(ILOpcode.add);
codeStream.EmitStLoc(iteratorLocal);
// Check to see if the loop is done
codeStream.EmitLdLoc(invocationCountLocal);
codeStream.EmitLdLoc(iteratorLocal);
codeStream.Emit(ILOpcode.bne_un, startOfLoopLabel);
// Return to caller. If the delegate has a return value, be certain to return that.
// return returnValueLocal;
// ldloc returnValueLocal
// ret
if (returnValueLocal != 0)
{
codeStream.EmitLdLoc(returnValueLocal);
}
codeStream.Emit(ILOpcode.ret);
return(emitter.Link(this));
}
public override void BeginArray(int size, ArrayType arrayType)
{
_stack.push(new ArrayWriter(size, arrayType));
}
internal static TypeReference ResolveType(TypeReference original, Mono.Collections.Generic.Collection <GenericParameter> parameters, Mono.Collections.Generic.Collection <TypeReference> arguments)
{
TypeSpecification spec = original as TypeSpecification;
ArrayType array = original as ArrayType;
ByReferenceType reference = original as ByReferenceType;
GenericInstanceType genericType = original as GenericInstanceType;
if (parameters.Count != arguments.Count)
{
throw new System.ArgumentException("Parameters and Arguments must have the same number of elements.");
}
if (spec != null)
{
TypeReference resolved = ResolveType(spec.ElementType, parameters, arguments);
if (genericType != null)
{
GenericInstanceType result = new GenericInstanceType(genericType.ElementType);
bool found;
for (int i = 0; i < genericType.ElementType.GenericParameters.Count; i++)
{
found = false;
for (int k = 0; k < parameters.Count; k++)
{
if (genericType.ElementType.GenericParameters [i].Name == parameters [k].Name)
{
found = true;
result.GenericArguments.Add(arguments [k]);
break;
}
}
if (!found)
{
result.GenericArguments.Add(genericType.ElementType.GenericParameters [i]);
}
}
return(result);
}
if (resolved == spec.ElementType)
{
return(spec);
}
if (array != null)
{
return(new ArrayType(resolved, array.Dimensions.Count));
}
else if (reference != null)
{
return(new ByReferenceType(resolved));
}
else
{
throw new System.NotImplementedException();
}
}
else
{
for (int i = 0; i < parameters.Count; i++)
{
if (parameters [i] == original)
{
return(arguments [i]);
}
}
return(original);
}
}
// todo: fix all the VarEnum/int casting nonsense
private static CppType Factory(CppType arrayItem, ArrayType array, TypeStyle style, bool optional, wsdlParser.qname xmlType)
{
return(new CppTypeArray((int)VarEnum.VT_ARRAY, arrayItem, array, style, optional, xmlType));
}
public ManagedArrayType(ArrayType array, TypedefType typedef)
{
Decayed = new QualifiedType(array);
Original = new QualifiedType(typedef);
}
static void AppendTypeName(StringBuilder b, IType type, bool explicitInterfaceImpl)
{
switch (type.Kind)
{
case TypeKind.Dynamic:
b.Append(explicitInterfaceImpl ? "System#Object" : "System.Object");
break;
case TypeKind.TypeParameter:
ITypeParameter tp = (ITypeParameter)type;
if (explicitInterfaceImpl)
{
b.Append(tp.Name);
}
else
{
b.Append('`');
if (tp.OwnerType == SymbolKind.Method)
{
b.Append('`');
}
b.Append(tp.Index);
}
break;
case TypeKind.Array:
ArrayType array = (ArrayType)type;
AppendTypeName(b, array.ElementType, explicitInterfaceImpl);
b.Append('[');
if (array.Dimensions > 1)
{
for (int i = 0; i < array.Dimensions; i++)
{
if (i > 0)
{
b.Append(explicitInterfaceImpl ? '@' : ',');
}
if (!explicitInterfaceImpl)
{
b.Append("0:");
}
}
}
b.Append(']');
break;
case TypeKind.Pointer:
AppendTypeName(b, ((PointerType)type).ElementType, explicitInterfaceImpl);
b.Append('*');
break;
case TypeKind.ByReference:
AppendTypeName(b, ((ByReferenceType)type).ElementType, explicitInterfaceImpl);
b.Append('@');
break;
default:
IType declType = type.DeclaringType;
if (declType != null)
{
AppendTypeName(b, declType, explicitInterfaceImpl);
b.Append(explicitInterfaceImpl ? '#' : '.');
b.Append(type.Name);
AppendTypeParameters(b, type, declType.TypeParameterCount, explicitInterfaceImpl);
}
else
{
if (explicitInterfaceImpl)
{
b.Append(type.FullName.Replace('.', '#'));
}
else
{
b.Append(type.FullName);
}
AppendTypeParameters(b, type, 0, explicitInterfaceImpl);
}
break;
}
}
public ArrayTypeParameterDataProvider(int startOffset, CSharpCompletionTextEditorExtension ext, ArrayType arrayType) : base(ext, startOffset)
{
this.arrayType = arrayType;
}
/// <summary>
/// String constructor.
/// Used for generating string results 'internally'.
/// </summary>
public ArrayValue(ArrayType stringTypeResult, string content) : base(stringTypeResult)
{
StringFormat = LiteralSubformat.Utf8;
StringValue = content;
}
public ArrayValue(ArrayType resolvedArrayType, params ISymbolValue[] elements) : base(resolvedArrayType)
{
Elements = elements;
}
public static CppType Create(int vt, string name, ArrayType array, TypeStyle style, bool optional, wsdlParser.qname xmlType)
{
return(Factory(vt, name, array, style, optional, xmlType));
}
private static TypeSpecifier ParseType(ITypeSymbol type)
{
var tType = type as ITypeParameterSymbol;
var namedType = type as INamedTypeSymbol;
var arrayType = type as IArrayTypeSymbol;
var pointerType = type as IPointerTypeSymbol;
var isGeneric = namedType != null && namedType.IsGenericType;
if (isGeneric)
{
var ret = new GenericType();
var name_ = type.Name;
var namespace_ = Utils.ToStr(type.ContainingNamespace);
ret.OuterType = new SimpleType
{
Namespace = namespace_,
TypeName = name_,
};
ret.InnerType = namedType.TypeArguments.Select(_ => ParseType(_)).Where(_ => _ != null).ToList();
if (ret.InnerType.Count() != namedType.TypeArguments.Count())
{
throw new Exception();
}
return(ret);
}
else if (type.TypeKind == TypeKind.Array)
{
var ret = new ArrayType();
var name_ = arrayType.ElementType.Name;
var namespace_ = Utils.ToStr(arrayType.ElementType.ContainingNamespace);
ret.BaseType = new SimpleType
{
Namespace = namespace_,
TypeName = name_,
};
return(ret);
}
else if (type.TypeKind == TypeKind.Pointer)
{
// ポインタは配列にする。
var ret = new ArrayType();
var name_ = pointerType.PointedAtType.Name;
var namespace_ = Utils.ToStr(pointerType.PointedAtType.ContainingNamespace);
ret.BaseType = new SimpleType
{
Namespace = namespace_,
TypeName = name_,
};
return(ret);
}
else if (type.TypeKind == TypeKind.TypeParameter)
{
var name_ = type.Name;
var ret = new GenericTypenameType
{
Name = name_,
};
return(ret);
}
else
{
var name_ = type.Name;
var namespace_ = Utils.ToStr(type.ContainingNamespace);
var ret = new SimpleType
{
Namespace = namespace_,
TypeName = name_,
};
switch (type.TypeKind)
{
case TypeKind.Class:
ret.TypeKind = SimpleTypeKind.Class;
break;
case TypeKind.Enum:
ret.TypeKind = SimpleTypeKind.Enum;
break;
case TypeKind.Error:
ret.TypeKind = SimpleTypeKind.Error;
break;
case TypeKind.Interface:
ret.TypeKind = SimpleTypeKind.Interface;
break;
case TypeKind.Struct:
ret.TypeKind = SimpleTypeKind.Struct;
break;
case TypeKind.TypeParameter:
ret.TypeKind = SimpleTypeKind.TypeParameter;
// 基本的にGenericsの型なのでNamespaceは必要ない
ret.Namespace = string.Empty;
break;
default:
ret.TypeKind = SimpleTypeKind.Other;
break;
}
return(ret);
}
}
public QueuedArrayType(ArrayType arrayType)
{
ArrayType = arrayType;
}
public static ArrayType __CreateInstance(ArrayType.Internal native)
{
return new ArrayType(native);
}
public bool ReplaceAll(DecompilerEventListener eventListener)
{
changed = false;
classesVisited = new HashSet <EquivalenceClass>();
// Replace the DataType of all the equivalence classes
foreach (TypeVariable tv in store.TypeVariables)
{
if (eventListener.IsCanceled())
{
return(false);
}
EquivalenceClass eq = tv.Class;
if (!classesVisited.Contains(eq))
{
classesVisited.Add(eq);
var dt = Replace(eq.DataType);
eq.DataType = dt;
}
}
// Replace the DataType of all the TypeVariables
foreach (TypeVariable tv in store.TypeVariables)
{
if (eventListener.IsCanceled())
{
return(false);
}
tv.DataType = Replace(tv.DataType);
}
foreach (EquivalenceClass eq in classesVisited)
{
if (eventListener.IsCanceled())
{
return(false);
}
if (eq != program.Globals.TypeVariable.Class &&
(eq.DataType is PrimitiveType ||
eq.DataType is VoidType ||
eq.DataType is EquivalenceClass ||
eq.DataType is CodeType))
{
eq.DataType = null;
changed = true;
continue;
}
Pointer ptr = eq.DataType as Pointer;
if (ptr != null)
{
eq.DataType = ptr.Pointee;
changed = true;
continue;
}
MemberPointer mp = eq.DataType as MemberPointer;
if (mp != null)
{
eq.DataType = mp.Pointee;
changed = true;
}
ArrayType array = eq.DataType as ArrayType;
if (array != null)
{
eq.DataType = array.ElementType;
changed = true;
}
}
return(changed);
}
private ArrayType(ArrayType.Internal native)
: this(__CopyValue(native))
{
__ownsNativeInstance = true;
NativeToManagedMap[__Instance] = this;
}
QualifiedType VisitType(IKVM.Reflection.Type managedType)
{
var isString = managedType.HasElementType && IKVM.Reflection.Type.GetTypeCode(
managedType.GetElementType()) == TypeCode.String;
if (managedType.IsByRef && isString)
{
managedType = managedType.GetElementType();
}
// If true type is an array, a pointer, or is passed by reference.
if (managedType.HasElementType)
{
var managedElementType = managedType.GetElementType();
var elementType = VisitType(managedElementType);
if (managedType.IsByRef || managedType.IsPointer)
{
var ptrType = new PointerType(elementType)
{
Modifier = (Options.GeneratorKind == GeneratorKind.CPlusPlus) ?
PointerType.TypeModifier.LVReference :
PointerType.TypeModifier.Pointer
};
return(new QualifiedType(ptrType));
}
else if (managedType.IsArray)
{
if (Options.GeneratorKind == GeneratorKind.Java)
{
return(new QualifiedType(new UnsupportedType {
Description = managedType.FullName
}));
}
var array = new ArrayType
{
SizeType = ArrayType.ArraySize.Variable,
QualifiedType = elementType
};
return(new QualifiedType(array));
}
throw new NotImplementedException();
}
if (managedType.IsEnum)
{
var @enum = Visit(managedType.GetTypeInfo());
return(new QualifiedType(new TagType(@enum)));
}
CppSharp.AST.Type type = null;
TypeQualifiers qualifiers = new TypeQualifiers();
switch (IKVM.Reflection.Type.GetTypeCode(managedType))
{
case TypeCode.Empty:
type = new BuiltinType(PrimitiveType.Null);
break;
case TypeCode.Object:
case TypeCode.DateTime:
if (managedType.FullName == "System.Void")
{
type = new BuiltinType(PrimitiveType.Void);
break;
}
var currentUnit = GetTranslationUnit(CurrentAssembly);
if (managedType.Assembly != ManagedAssemblies[currentUnit] ||
managedType.IsGenericType)
{
type = new UnsupportedType {
Description = managedType.FullName
};
break;
}
var decl = Visit(managedType.GetTypeInfo());
type = new TagType(decl);
break;
case TypeCode.DBNull:
type = new UnsupportedType()
{
Description = "DBNull"
};
break;
case TypeCode.Boolean:
type = new BuiltinType(PrimitiveType.Bool);
break;
case TypeCode.Char:
type = new BuiltinType(PrimitiveType.Char);
break;
case TypeCode.SByte:
type = new BuiltinType(PrimitiveType.SChar);
break;
case TypeCode.Byte:
type = new BuiltinType(PrimitiveType.UChar);
break;
case TypeCode.Int16:
type = new BuiltinType(PrimitiveType.Short);
break;
case TypeCode.UInt16:
type = new BuiltinType(PrimitiveType.UShort);
break;
case TypeCode.Int32:
type = new BuiltinType(PrimitiveType.Int);
break;
case TypeCode.UInt32:
type = new BuiltinType(PrimitiveType.UInt);
break;
case TypeCode.Int64:
type = new BuiltinType(PrimitiveType.Long);
break;
case TypeCode.UInt64:
type = new BuiltinType(PrimitiveType.ULong);
break;
case TypeCode.Single:
type = new BuiltinType(PrimitiveType.Float);
break;
case TypeCode.Double:
type = new BuiltinType(PrimitiveType.Double);
break;
case TypeCode.String:
type = new BuiltinType(PrimitiveType.String);
break;
case TypeCode.Decimal:
type = new BuiltinType(PrimitiveType.Decimal);
break;
}
return(new QualifiedType(type, qualifiers));
}
public override bool VisitArrayType(ArrayType array, TypeQualifiers quals)
{
if (!VisitType(array, quals))
{
return(false);
}
switch (array.SizeType)
{
case ArrayType.ArraySize.Constant:
if (Context.MarshalKind != MarshalKind.NativeField &&
Context.MarshalKind != MarshalKind.ReturnVariableArray)
{
goto case ArrayType.ArraySize.Incomplete;
}
var supportBefore = Context.Before;
string value = Generator.GeneratedIdentifier("value");
var arrayType = array.Type.Desugar();
supportBefore.WriteLine($"{arrayType}[] {value} = null;");
supportBefore.WriteLine($"if ({Context.ReturnVarName} != null)");
supportBefore.WriteOpenBraceAndIndent();
supportBefore.WriteLine($"{value} = new {arrayType}[{array.Size}];");
supportBefore.WriteLine($"for (int i = 0; i < {array.Size}; i++)");
if (array.Type.IsPointerToPrimitiveType(PrimitiveType.Void))
{
supportBefore.WriteLineIndent($@"{value}[i] = new global::System.IntPtr({
Context.ReturnVarName}[i]);");
}
else
{
var finalArrayType = arrayType.GetPointee() ?? arrayType;
Class @class;
if ((finalArrayType.TryGetClass(out @class)) && @class.IsRefType)
{
if (arrayType == finalArrayType)
{
supportBefore.WriteLineIndent(
"{0}[i] = {1}.{2}(*(({1}.{3}*)&({4}[i * sizeof({1}.{3})])));",
value, array.Type, Helpers.CreateInstanceIdentifier,
Helpers.InternalStruct, Context.ReturnVarName);
}
else
{
supportBefore.WriteLineIndent(
$@"{value}[i] = {finalArrayType}.{Helpers.CreateInstanceIdentifier}(({
typePrinter.IntPtrType}) {Context.ReturnVarName}[i]);");
}
}
else
{
if (arrayType.IsPrimitiveType(PrimitiveType.Bool))
{
supportBefore.WriteLineIndent($@"{value}[i] = {
Context.ReturnVarName}[i] != 0;");
}
else if (arrayType.IsPrimitiveType(PrimitiveType.Char) &&
Context.Context.Options.MarshalCharAsManagedChar)
{
supportBefore.WriteLineIndent($@"{value}[i] = global::System.Convert.ToChar({
Context.ReturnVarName}[i]);");
}
else
{
supportBefore.WriteLineIndent($@"{value}[i] = {
Context.ReturnVarName}[i];");
}
}
}
supportBefore.UnindentAndWriteCloseBrace();
Context.Return.Write(value);
break;
case ArrayType.ArraySize.Incomplete:
// const char* and const char[] are the same so we can use a string
if (array.Type.Desugar().IsPrimitiveType(PrimitiveType.Char) &&
array.QualifiedType.Qualifiers.IsConst)
{
var pointer = new PointerType {
QualifiedPointee = array.QualifiedType
};
Context.ReturnType = new QualifiedType(pointer);
return(this.VisitPointerType(pointer, quals));
}
MarshalArray(array);
break;
case ArrayType.ArraySize.Variable:
Context.Return.Write(Context.ReturnVarName);
break;
}
return(true);
}
public override bool VisitArrayType(ArrayType array, TypeQualifiers quals)
{
if (!VisitType(array, quals))
{
return(false);
}
var arrayType = array.Type.Desugar();
switch (array.SizeType)
{
case ArrayType.ArraySize.Constant:
if (string.IsNullOrEmpty(Context.ReturnVarName))
{
goto case ArrayType.ArraySize.Incomplete;
}
else
{
var supportBefore = Context.Before;
supportBefore.WriteLine("if ({0} != null)", Context.ArgName);
supportBefore.WriteStartBraceIndent();
Class @class;
if (arrayType.TryGetClass(out @class) && @class.IsRefType)
{
supportBefore.WriteLine("if (value.Length != {0})", array.Size);
ThrowArgumentOutOfRangeException();
}
supportBefore.WriteLine("for (int i = 0; i < {0}; i++)", array.Size);
if (@class != null && @class.IsRefType)
{
supportBefore.WriteLineIndent(
"*({1}.{2}*) &{0}[i * sizeof({1}.{2})] = *({1}.{2}*){3}[i].{4};",
Context.ReturnVarName, arrayType, Helpers.InternalStruct,
Context.ArgName, Helpers.InstanceIdentifier);
}
else
{
if (arrayType.IsPrimitiveType(PrimitiveType.Char) &&
Context.Context.Options.MarshalCharAsManagedChar)
{
supportBefore.WriteLineIndent(
"{0}[i] = global::System.Convert.ToSByte({1}[i]);",
Context.ReturnVarName, Context.ArgName);
}
else
{
supportBefore.WriteLineIndent("{0}[i] = {1}[i]{2};",
Context.ReturnVarName,
Context.ArgName,
arrayType.IsPointerToPrimitiveType(PrimitiveType.Void)
? ".ToPointer()"
: string.Empty);
}
}
supportBefore.WriteCloseBraceIndent();
}
break;
case ArrayType.ArraySize.Incomplete:
MarshalArray(array);
break;
default:
Context.Return.Write("null");
break;
}
return(true);
}
public override bool VisitArrayType(ArrayType array, TypeQualifiers quals)
{
if (!VisitType(array, quals))
{
return(false);
}
switch (array.SizeType)
{
case ArrayType.ArraySize.Constant:
if (Context.MarshalKind == MarshalKind.NativeField ||
Context.MarshalKind == MarshalKind.ReturnVariableArray)
{
var supportBefore = Context.Before;
string value = Generator.GeneratedIdentifier("value");
supportBefore.WriteLine("{0}[] {1} = null;", array.Type, value, array.Size);
supportBefore.WriteLine("if ({0} != null)", Context.ReturnVarName);
supportBefore.WriteStartBraceIndent();
supportBefore.WriteLine("{0} = new {1}[{2}];", value, array.Type, array.Size);
supportBefore.WriteLine("for (int i = 0; i < {0}; i++)", array.Size);
if (array.Type.IsPointerToPrimitiveType(PrimitiveType.Void))
{
supportBefore.WriteLineIndent("{0}[i] = new global::System.IntPtr({1}[i]);",
value, Context.ReturnVarName);
}
else
{
var arrayType = array.Type.Desugar();
Class @class;
if (arrayType.TryGetClass(out @class) && @class.IsRefType)
{
supportBefore.WriteLineIndent(
"{0}[i] = {1}.{2}(*(({1}.{3}*)&({4}[i * sizeof({1}.{3})])));",
value, array.Type, Helpers.CreateInstanceIdentifier,
Helpers.InternalStruct, Context.ReturnVarName);
}
else
{
if (arrayType.IsPrimitiveType(PrimitiveType.Char) &&
Context.Context.Options.MarshalCharAsManagedChar)
{
supportBefore.WriteLineIndent(
"{0}[i] = global::System.Convert.ToChar({1}[i]);",
value, Context.ReturnVarName);
}
else
{
supportBefore.WriteLineIndent("{0}[i] = {1}[i];",
value, Context.ReturnVarName);
}
}
}
supportBefore.WriteCloseBraceIndent();
Context.Return.Write(value);
}
else
{
goto case ArrayType.ArraySize.Incomplete;
}
break;
case ArrayType.ArraySize.Incomplete:
// const char* and const char[] are the same so we can use a string
if (array.Type.Desugar().IsPrimitiveType(PrimitiveType.Char) &&
array.QualifiedType.Qualifiers.IsConst)
{
return(VisitPointerType(new PointerType
{
QualifiedPointee = array.QualifiedType
}, quals));
}
MarshalArray(array);
break;
case ArrayType.ArraySize.Variable:
Context.Return.Write(Context.ReturnVarName);
break;
}
return(true);
}
protected override RuntimeInterfacesAlgorithm GetRuntimeInterfacesAlgorithmForNonPointerArrayType(ArrayType type)
{
if (_arrayOfTRuntimeInterfacesAlgorithm == null)
{
_arrayOfTRuntimeInterfacesAlgorithm = new ArrayOfTRuntimeInterfacesAlgorithm(SystemModule.GetKnownType("System", "Array`1"));
}
return(_arrayOfTRuntimeInterfacesAlgorithm);
}
public override TypePrinterResult VisitArrayType(ArrayType array,
TypeQualifiers quals)
{
Type arrayType = array.Type.Desugar();
if (ContextKind == TypePrinterContextKind.Native &&
array.SizeType == ArrayType.ArraySize.Constant)
{
PrimitiveType primitiveType;
if ((arrayType.IsPointerToPrimitiveType(out primitiveType) &&
!(arrayType is FunctionType)) ||
(arrayType.IsPrimitiveType() && MarshalKind != MarshalKind.NativeField))
{
if (primitiveType == PrimitiveType.Void)
{
return("void*");
}
return(string.Format("{0}", array.Type.Visit(this, quals)));
}
if (Parameter != null)
{
return(string.Format("global::System.IntPtr"));
}
Enumeration @enum;
if (arrayType.TryGetEnum(out @enum))
{
return(new TypePrinterResult
{
Type = string.Format("fixed {0}", @enum.BuiltinType),
NameSuffix = string.Format("[{0}]", array.Size)
});
}
Class @class;
if (arrayType.TryGetClass(out @class))
{
return(new TypePrinterResult
{
Type = "fixed byte",
NameSuffix = string.Format("[{0}]", array.Size * @class.Layout.Size)
});
}
var arrayElemType = array.Type.Visit(this, quals).ToString();
// C# does not support fixed arrays of machine pointer type (void* or IntPtr).
// In that case, replace it by a pointer to an integer type of the same size.
if (arrayElemType == IntPtrType)
{
arrayElemType = Context.TargetInfo.PointerWidth == 64 ? "long" : "int";
}
// Do not write the fixed keyword multiple times for nested array types
var fixedKeyword = array.Type is ArrayType ? string.Empty : "fixed ";
return(new TypePrinterResult
{
Type = string.Format("{0}{1}", fixedKeyword, arrayElemType),
NameSuffix = string.Format("[{0}]", array.Size)
});
}
// const char* and const char[] are the same so we can use a string
if (array.SizeType == ArrayType.ArraySize.Incomplete &&
arrayType.IsPrimitiveType(PrimitiveType.Char) &&
array.QualifiedType.Qualifiers.IsConst)
{
return("string");
}
if (arrayType.IsPointerToPrimitiveType(PrimitiveType.Char))
{
return("char**");
}
return(string.Format("{0}{1}", array.Type.Visit(this),
array.SizeType == ArrayType.ArraySize.Constant ? "[]" :
(ContextKind == TypePrinterContextKind.Managed ? "*" : string.Empty)));
// C# only supports fixed arrays in unsafe sections
// and they are constrained to a set of built-in types.
}
protected ArrayHeader DefineArray(uint array, ArrayType type, int dim2, int dim1)
{
// Debug.WriteLine("DefineArray: {0} {1} {2} {3}", array, type, dim2, dim1);
Debug.Assert(0 <= type && (int)type <= 5);
NukeArray(array);
var id = FindFreeArrayId();
int size;
if (Game.Version == 8)
{
if ((array & 0x80000000) != 0)
{
throw new InvalidOperationException("Can't define bit variable as array pointer");
}
size = (type == ArrayType.IntArray) ? 4 : 1;
}
else
{
if ((array & 0x8000) != 0)
{
throw new InvalidOperationException("Can't define bit variable as array pointer");
}
size = (type == ArrayType.IntArray) ? 2 : 1;
}
WriteVariable(array, id);
size *= dim2 + 1;
size *= dim1 + 1;
_strings[id] = new byte[size + 6 /*sizeof(ArrayHeader)*/];
var ah = new ArrayHeader(_strings[id]);
ah.Type = type;
ah.Dim1 = dim1 + 1;
ah.Dim2 = dim2 + 1;
return ah;
}
private void GetXmlDocParameterPathRecursive(
TypeReference tpType,
bool ExplicitMode,
StringBuilder CurrPath)
{
if (tpType == null)
{
return;
}
if (tpType.GenericParameters.Count > 0)
{
CurrPath.Append(
tpType.Namespace +
((CanAppendSpecialExplicitChar() && ExplicitMode) ? "#" : ".") +
StripGenericName(tpType.Name));
// list parameters or types
bool firstAppend = true;
CurrPath.Append("{");
foreach (GenericParameter TempType in tpType.GenericParameters)
{
if (!firstAppend)
{
CurrPath.Append(",");
}
CurrPath.Append(GetXmlDocParameterPath(TempType, ExplicitMode));
firstAppend = false;
}
CurrPath.Append("}");
}
else if (tpType is GenericInstanceType)
{
GenericInstanceType thisGenericType = tpType as GenericInstanceType;
// if nested, scan enclosing type
if (tpType.DeclaringType != null)
{
CurrPath.Append(GetXmlDocParameterPath(tpType.DeclaringType, ExplicitMode));
}
// determine namespace
string strNamespace = string.Empty;
if ((tpType.Namespace != null && tpType.Namespace.Length > 0) || tpType.DeclaringType != null)
{
strNamespace = tpType.Namespace +
((CanAppendSpecialExplicitChar() && ExplicitMode) ? "#" : ".");
}
CurrPath.Append(strNamespace + StripGenericName(thisGenericType.Name));
// list parameters or types
bool firstAppend = true;
CurrPath.Append("{");
foreach (TypeReference tempTypeRef in thisGenericType.GenericArguments)
{
if (!firstAppend)
{
CurrPath.Append(",");
}
CurrPath.Append(GetXmlDocParameterPath(tempTypeRef, ExplicitMode));
firstAppend = false;
}
CurrPath.Append("}");
}
else if (tpType is GenericParameter)
{
GenericParameter thisGenParam = tpType as GenericParameter;
if (ExplicitMode)
{
// in explicit mode we print parameter name
CurrPath.Append(thisGenParam.Name);
}
else
{
// in non-explicit mode we print parameter order
int paramOrder = 0;
// find
for (int i = 0; i < thisGenParam.Owner.GenericParameters.Count; i++)
{
if (thisGenParam.Owner.GenericParameters[i].Name == tpType.Name)
{
paramOrder = i;
break;
}
}
if (thisGenParam.Owner is MethodReference)
{
CurrPath.Append("``" + paramOrder);
}
else
{
CurrPath.Append("`" + paramOrder);
}
}
}
else if (tpType is PointerType)
{
// parameter is pointer type
CurrPath.Append(GetXmlDocParameterPath((tpType as PointerType).ElementType, ExplicitMode));
CurrPath.Append("*");
}
else if (tpType is ArrayType)
{
ArrayType thisArrayType = tpType as ArrayType;
if (thisArrayType.ElementType != null)
{
CurrPath.Append(GetXmlDocParameterPath(thisArrayType.ElementType, ExplicitMode));
}
int iRank = thisArrayType.Rank;
if (iRank == 1)
{
CurrPath.Append("[]");
}
else
{
bool firstAppend = true;
CurrPath.Append("[");
for (int i = 0; i < (ExplicitMode ? iRank - 1 : iRank); i++)
{
// in explicit mode for .NET3.5/VS2008,
// there is no separator char "," used for multi-dimensional array,
// so there are three cases when comma shall be added:
// firstAppend = false; ExplicitMode = false; CanAppendSpecialExplicitChar() = true;
// firstAppend = false; ExplicitMode = false; CanAppendSpecialExplicitChar() = false;
// firstAppend = false; ExplicitMode = true; CanAppendSpecialExplicitChar() = false;
// below this is stored in decent manner
if (!firstAppend && (!ExplicitMode || !CanAppendSpecialExplicitChar()))
{
CurrPath.Append(",");
}
CurrPath.Append(((CanAppendSpecialExplicitChar() && ExplicitMode) ? "@" : "0:"));
if (thisArrayType.Dimensions[i].UpperBound > 0)
{
CurrPath.Append(thisArrayType.Dimensions[i].UpperBound.ToString());
}
firstAppend = false;
}
CurrPath.Append("]");
}
}
// else if (!tpType.IsValueType)
// {
// // parameter is passed by reference
// CurrPath.Append(GetXmlDocParameterPath((tpType as ReferenceType).ElementType, false));
// CurrPath.Append("@");
// }
// else if (tpType is ModifierOptional)
// {
// // parameter has optional modifier
// ModifierOptional thisModOpt = tpType as ModifierOptional;
//
// CurrPath.Append(GetXmlDocParameterPath(thisModOpt.ElementType, ExplicitMode));
// CurrPath.Append("!");
// CurrPath.Append(GetXmlDocParameterPath(thisModOpt.ModifierType, ExplicitMode));
// }
// else if (tpType is ModifierRequired)
// {
// // parameter has required modifier
// ModifierRequired thisModReq = tpType as ModifierRequired;
//
// CurrPath.Append(GetXmlDocParameterPath(thisModReq.ElementType, ExplicitMode));
// CurrPath.Append("|");
// CurrPath.Append(GetXmlDocParameterPath(thisModReq.ModifierType, ExplicitMode));
// }
else if (tpType is FunctionPointerType)
{
// type is function pointer
FunctionPointerType thisFuncPtr = tpType as FunctionPointerType;
// string tempString = string.Empty;
// return type
CurrPath.Append("=FUNC:");
CurrPath.Append(GetXmlDocParameterPath(thisFuncPtr.ReturnType, ExplicitMode));
// method's parameters
if (thisFuncPtr.Parameters.Count > 0)
{
bool firstAppend = true;
CurrPath.Append("(");
foreach (ParameterDefinition tempParam in thisFuncPtr.Parameters)
{
if (!firstAppend)
{
CurrPath.Append(",");
}
CurrPath.Append(GetXmlDocParameterPath(tempParam.ParameterType, ExplicitMode));
firstAppend = false;
}
CurrPath.Append(")");
}
else
{
CurrPath.Append("(System.Void)");
}
}
else if (tpType is PinnedType)
{
// type is pinned type
CurrPath.Append(GetXmlDocParameterPath((tpType as PinnedType).ElementType, ExplicitMode));
CurrPath.Append("^");
}
else if (tpType is TypeReference)
{
// if nested, scan enclosing type
if (tpType.DeclaringType != null)
{
CurrPath.Append(GetXmlDocParameterPath(tpType.DeclaringType, ExplicitMode));
}
// determine namespace
string strNamespace = string.Empty;
if ((tpType.Namespace != null && tpType.Namespace.Length > 0) || tpType.DeclaringType != null)
{
strNamespace = tpType.Namespace +
((CanAppendSpecialExplicitChar() && ExplicitMode) ? "#" : ".");
}
// concrete type
CurrPath.Append(
strNamespace +
((CanAppendSpecialExplicitChar() && ExplicitMode) ? tpType.Name.Replace(".", "#") : tpType.Name));
}
}
private static void* __CopyValue(ArrayType.__Internal native)
{
var ret = Marshal.AllocHGlobal(28);
global::CppSharp.Parser.AST.ArrayType.__Internal.cctor_2(ret, new global::System.IntPtr(&native));
return ret.ToPointer();
}
protected string GetNameOfType(ArrayType type)
{
return(GetNameOfType(type.ElementType as dynamic) + "[]");
}
private ArrayType(ArrayType.Internal native, bool skipVTables = false)
: this(__CopyValue(native), skipVTables)
{
__ownsNativeInstance = true;
NativeToManagedMap[__Instance] = this;
}
public override bool VisitArrayType(ArrayType array, TypeQualifiers quals)
{
if (!VisitType(array, quals))
{
return(false);
}
switch (array.SizeType)
{
case ArrayType.ArraySize.Constant:
if (string.IsNullOrEmpty(Context.ReturnVarName))
{
goto case ArrayType.ArraySize.Incomplete;
}
var supportBefore = Context.Before;
supportBefore.WriteLine($"if ({Context.ArgName} != null)");
supportBefore.WriteOpenBraceAndIndent();
Class @class;
var arrayType = array.Type.Desugar();
var finalArrayType = arrayType.GetPointee() ?? arrayType;
if (finalArrayType.TryGetClass(out @class) && @class.IsRefType)
{
supportBefore.WriteLine($"if (value.Length != {array.Size})");
ThrowArgumentOutOfRangeException();
}
supportBefore.WriteLine($"for (int i = 0; i < {array.Size}; i++)");
if (@class != null && @class.IsRefType)
{
if (finalArrayType == arrayType)
{
supportBefore.WriteLineIndent(
"*({1}.{2}*) &{0}[i * sizeof({1}.{2})] = *({1}.{2}*){3}[i].{4};",
Context.ReturnVarName, arrayType, Helpers.InternalStruct,
Context.ArgName, Helpers.InstanceIdentifier);
}
else
{
supportBefore.WriteLineIndent($@"{Context.ReturnVarName}[i] = ({
(Context.Context.TargetInfo.PointerWidth == 64 ? "long" : "int")}) {
Context.ArgName}[i].{Helpers.InstanceIdentifier};");
}
}
else
{
if (arrayType.IsPrimitiveType(PrimitiveType.Bool))
{
supportBefore.WriteLineIndent($@"{
Context.ReturnVarName}[i] = (byte)({
Context.ArgName}[i] ? 1 : 0);");
}
else if (arrayType.IsPrimitiveType(PrimitiveType.Char) &&
Context.Context.Options.MarshalCharAsManagedChar)
{
supportBefore.WriteLineIndent($@"{
Context.ReturnVarName}[i] = global::System.Convert.ToSByte({
Context.ArgName}[i]);");
}
else
{
supportBefore.WriteLineIndent($@"{Context.ReturnVarName}[i] = {
Context.ArgName}[i]{
(arrayType.IsPointerToPrimitiveType(PrimitiveType.Void) ?
".ToPointer()" : string.Empty)};");
}
}
supportBefore.UnindentAndWriteCloseBrace();
break;
case ArrayType.ArraySize.Incomplete:
MarshalArray(array);
break;
default:
Context.Return.Write("null");
break;
}
return(true);
}
public static CppType CreateArray(CppType arrayItem, ArrayType array, bool optional, wsdlParser.qname xmlType)
{
return(Factory(arrayItem, array, TypeStyle.Primative, optional, xmlType));
}
internal static TypeDesc GetNativeTypeFromMarshallerKind(TypeDesc type,
MarshallerKind kind,
MarshallerKind elementMarshallerKind,
#if !READYTORUN
InteropStateManager interopStateManager,
#endif
MarshalAsDescriptor marshalAs,
bool isArrayElement = false)
{
TypeSystemContext context = type.Context;
NativeTypeKind nativeType = NativeTypeKind.Default;
if (marshalAs != null)
{
nativeType = isArrayElement ? marshalAs.ArraySubType : marshalAs.Type;
}
switch (kind)
{
case MarshallerKind.BlittableValue:
{
switch (nativeType)
{
case NativeTypeKind.I1:
return(context.GetWellKnownType(WellKnownType.SByte));
case NativeTypeKind.U1:
return(context.GetWellKnownType(WellKnownType.Byte));
case NativeTypeKind.I2:
return(context.GetWellKnownType(WellKnownType.Int16));
case NativeTypeKind.U2:
return(context.GetWellKnownType(WellKnownType.UInt16));
case NativeTypeKind.I4:
return(context.GetWellKnownType(WellKnownType.Int32));
case NativeTypeKind.U4:
return(context.GetWellKnownType(WellKnownType.UInt32));
case NativeTypeKind.I8:
return(context.GetWellKnownType(WellKnownType.Int64));
case NativeTypeKind.U8:
return(context.GetWellKnownType(WellKnownType.UInt64));
case NativeTypeKind.R4:
return(context.GetWellKnownType(WellKnownType.Single));
case NativeTypeKind.R8:
return(context.GetWellKnownType(WellKnownType.Double));
default:
return(type.UnderlyingType);
}
}
case MarshallerKind.Bool:
return(context.GetWellKnownType(WellKnownType.Int32));
case MarshallerKind.CBool:
return(context.GetWellKnownType(WellKnownType.Byte));
case MarshallerKind.Enum:
case MarshallerKind.BlittableStruct:
case MarshallerKind.Decimal:
case MarshallerKind.VoidReturn:
return(type);
#if !READYTORUN
case MarshallerKind.Struct:
case MarshallerKind.LayoutClass:
return(interopStateManager.GetStructMarshallingNativeType((MetadataType)type));
#endif
case MarshallerKind.BlittableStructPtr:
return(type.MakePointerType());
case MarshallerKind.HandleRef:
return(context.GetWellKnownType(WellKnownType.IntPtr));
case MarshallerKind.UnicodeChar:
if (nativeType == NativeTypeKind.U2)
{
return(context.GetWellKnownType(WellKnownType.UInt16));
}
else
{
return(context.GetWellKnownType(WellKnownType.Int16));
}
case MarshallerKind.OleDateTime:
return(context.GetWellKnownType(WellKnownType.Double));
case MarshallerKind.SafeHandle:
case MarshallerKind.CriticalHandle:
return(context.GetWellKnownType(WellKnownType.IntPtr));
case MarshallerKind.UnicodeString:
case MarshallerKind.UnicodeStringBuilder:
return(context.GetWellKnownType(WellKnownType.Char).MakePointerType());
case MarshallerKind.AnsiString:
case MarshallerKind.AnsiStringBuilder:
case MarshallerKind.UTF8String:
return(context.GetWellKnownType(WellKnownType.Byte).MakePointerType());
case MarshallerKind.BlittableArray:
case MarshallerKind.Array:
case MarshallerKind.AnsiCharArray:
{
ArrayType arrayType = type as ArrayType;
Debug.Assert(arrayType != null, "Expecting array");
//
// We need to construct the unsafe array from the right unsafe array element type
//
TypeDesc elementNativeType = GetNativeTypeFromMarshallerKind(
arrayType.ElementType,
elementMarshallerKind,
MarshallerKind.Unknown,
#if !READYTORUN
interopStateManager,
#endif
marshalAs,
isArrayElement: true);
return(elementNativeType.MakePointerType());
}
case MarshallerKind.AnsiChar:
return(context.GetWellKnownType(WellKnownType.Byte));
case MarshallerKind.FunctionPointer:
return(context.GetWellKnownType(WellKnownType.IntPtr));
#if !READYTORUN
case MarshallerKind.ByValUnicodeString:
case MarshallerKind.ByValAnsiString:
{
var inlineArrayCandidate = GetInlineArrayCandidate(context.GetWellKnownType(WellKnownType.Char), elementMarshallerKind, interopStateManager, marshalAs);
return(interopStateManager.GetInlineArrayType(inlineArrayCandidate));
}
case MarshallerKind.ByValAnsiCharArray:
case MarshallerKind.ByValArray:
{
ArrayType arrayType = type as ArrayType;
Debug.Assert(arrayType != null, "Expecting array");
var inlineArrayCandidate = GetInlineArrayCandidate(arrayType.ElementType, elementMarshallerKind, interopStateManager, marshalAs);
return(interopStateManager.GetInlineArrayType(inlineArrayCandidate));
}
#endif
case MarshallerKind.LayoutClassPtr:
case MarshallerKind.AsAnyA:
case MarshallerKind.AsAnyW:
return(context.GetWellKnownType(WellKnownType.IntPtr));
case MarshallerKind.Unknown:
default:
throw new NotSupportedException();
}
}
private static ArrayType.Internal* __CopyValue(ArrayType.Internal native)
{
var ret = Marshal.AllocHGlobal(48);
CppSharp.Parser.AST.ArrayType.Internal.cctor_2(ret, new global::System.IntPtr(&native));
return (ArrayType.Internal*) ret;
}
//=====================================================================
/// <summary>
/// Write out a type name
/// </summary>
/// <param name="type">The type for which to write out the name</param>
/// <param name="sb">The string builder to which the name is written</param>
private static void WriteType(TypeNode type, StringBuilder sb)
{
switch (type.NodeType)
{
case NodeType.ArrayType:
ArrayType array = (ArrayType)type;
WriteType(array.ElementType, sb);
sb.Append("[");
if (array.Rank > 1)
{
for (int i = 0; i < array.Rank; i++)
{
if (i > 0)
{
sb.Append(",");
}
sb.Append("0:");
}
}
sb.Append("]");
break;
case NodeType.Reference:
Reference reference = (Reference)type;
WriteType(reference.ElementType, sb);
sb.Append("@");
break;
case NodeType.Pointer:
Pointer pointer = (Pointer)type;
WriteType(pointer.ElementType, sb);
sb.Append("*");
break;
case NodeType.OptionalModifier:
TypeModifier optionalModifierClause = (TypeModifier)type;
WriteType(optionalModifierClause.ModifiedType, sb);
sb.Append("!");
WriteType(optionalModifierClause.Modifier, sb);
break;
case NodeType.RequiredModifier:
TypeModifier requiredModifierClause = (TypeModifier)type;
WriteType(requiredModifierClause.ModifiedType, sb);
sb.Append("|");
WriteType(requiredModifierClause.Modifier, sb);
break;
default:
if (type.IsTemplateParameter)
{
ITypeParameter gtp = (ITypeParameter)type;
if (gtp.DeclaringMember is TypeNode)
{
sb.Append("`");
}
else
if (gtp.DeclaringMember is Method)
{
sb.Append("``");
}
else
{
throw new InvalidOperationException("Generic parameter not on type or method");
}
sb.Append(gtp.ParameterListIndex);
}
else
{
// Namespace
TypeNode declaringType = type.DeclaringType;
if (declaringType != null)
{
// Names of nested types begin with outer type name
WriteType(declaringType, sb);
sb.Append(".");
}
else
{
// Otherwise just prefix with the namespace
Identifier space = type.Namespace;
if (space != null && !String.IsNullOrEmpty(space.Name))
{
sb.Append(space.Name);
sb.Append(".");
}
}
// Name
sb.Append(type.GetUnmangledNameWithoutTypeParameters());
// Generic parameters
if (type.IsGeneric)
{
// Number of parameters
TypeNodeList parameters = type.TemplateParameters;
if (parameters != null)
{
sb.Append('`');
sb.Append(parameters.Count);
}
// Arguments
TypeNodeList arguments = type.TemplateArguments;
if (arguments != null && arguments.Count > 0)
{
sb.Append("{");
for (int i = 0; i < arguments.Count; i++)
{
if (i > 0)
{
sb.Append(",");
}
WriteType(arguments[i], sb);
}
sb.Append("}");
}
}
}
break;
}
}
protected ArrayType(ArrayType.Internal* native, bool isInternalImpl = false)
: base((CppSharp.Parser.AST.Type.Internal*) native)
{
}
protected override DependencyList ComputeNonRelocationBasedDependencies(NodeFactory factory)
{
DependencyList dependencyList = base.ComputeNonRelocationBasedDependencies(factory);
// Ensure that we track the necessary type symbol if we are working with a constructed type symbol.
// The emitter will ensure we don't emit both, but this allows us assert that we only generate
// relocs to nodes we emit.
dependencyList.Add(factory.NecessaryTypeSymbol(_type), "NecessaryType for constructed type");
DefType closestDefType = _type.GetClosestDefType();
if (_type.RuntimeInterfaces.Length > 0)
{
dependencyList.Add(factory.InterfaceDispatchMap(_type), "Interface dispatch map");
}
if (_type.IsArray)
{
// Array EEType depends on System.Array's virtuals. Array EETypes don't point to
// their base type (i.e. there's no reloc based dependency making this "just work").
dependencyList.Add(factory.ConstructedTypeSymbol(_type.BaseType), "Array base type");
ArrayType arrayType = (ArrayType)_type;
if (arrayType.IsMdArray && arrayType.Rank == 1)
{
// Allocating an MDArray of Rank 1 with zero lower bounds results in allocating
// an SzArray instead. Make sure the type loader can find the SzArray type.
dependencyList.Add(factory.ConstructedTypeSymbol(arrayType.ElementType.MakeArrayType()), "Rank 1 array");
}
}
dependencyList.Add(factory.VTable(closestDefType), "VTable");
if (closestDefType.HasInstantiation)
{
TypeDesc canonType = _type.ConvertToCanonForm(CanonicalFormKind.Specific);
TypeDesc canonClosestDefType = closestDefType.ConvertToCanonForm(CanonicalFormKind.Specific);
// Add a dependency on the template for this type, if the canonical type should be generated into this binary.
// If the type is an array type, the check should be on its underlying Array<T> type. This is because a copy of
// an array type gets placed into each module but the Array<T> type only exists in the defining module and only
// one template is needed for the Array<T> type by the dynamic type loader.
if (canonType.IsCanonicalSubtype(CanonicalFormKind.Any) && !factory.NecessaryTypeSymbol(canonClosestDefType).RepresentsIndirectionCell)
{
dependencyList.Add(factory.NativeLayout.TemplateTypeLayout(canonType), "Template Type Layout");
}
}
// Generated type contains generic virtual methods that will get added to the GVM tables
if (TypeGVMEntriesNode.TypeNeedsGVMTableEntries(_type))
{
dependencyList.Add(new DependencyListEntry(factory.TypeGVMEntries(_type), "Type with generic virtual methods"));
}
if (factory.TypeSystemContext.HasLazyStaticConstructor(_type))
{
// The fact that we generated an EEType means that someone can call RuntimeHelpers.RunClassConstructor.
// We need to make sure this is possible.
dependencyList.Add(new DependencyListEntry(factory.TypeNonGCStaticsSymbol((MetadataType)_type), "Class constructor"));
}
// Ask the metadata manager if we have any dependencies due to reflectability.
factory.MetadataManager.GetDependenciesDueToReflectability(ref dependencyList, factory, _type);
factory.InteropStubManager.AddInterestingInteropConstructedTypeDependencies(ref dependencyList, factory, _type);
return(dependencyList);
}
