internal TypeMapping GetDefaultMapping(TypeFlags flags) {
PrimitiveMapping mapping = new PrimitiveMapping();
mapping.TypeDesc = Scope.GetTypeDesc("string", XmlSchema.Namespace, flags);
mapping.TypeName = mapping.TypeDesc.DataType.Name;
mapping.Namespace = XmlSchema.Namespace;
return mapping;
}
internal TypeDesc(string name, string fullName, XmlSchemaType dataType, TypeKind kind, TypeDesc baseTypeDesc, TypeFlags flags, string formatterName)
{
this.name = name.Replace('+', '.');
this.fullName = fullName.Replace('+', '.');
this.kind = kind;
this.baseTypeDesc = baseTypeDesc;
this.flags = flags;
this.isXsdType = kind == TypeKind.Primitive;
if (this.isXsdType)
{
this.weight = 1;
}
else if (kind == TypeKind.Enum)
{
this.weight = 2;
}
else if (this.kind == TypeKind.Root)
{
this.weight = -1;
}
else
{
this.weight = (baseTypeDesc == null) ? 0 : (baseTypeDesc.Weight + 1);
}
this.dataType = dataType;
this.formatterName = formatterName;
}
protected override TypeFlags ComputeTypeFlags(TypeFlags mask)
{
// We might be able to compute the type flags for some masks, but for some this will always throw (e.g.
// Category and GenericVariance should always throw). If you hit an exception, it means you need a
// special case for IsSignatureVariable.
throw new NotImplementedException();
}
protected override TypeFlags ComputeTypeFlags(TypeFlags mask)
{
return TypeFlags.Class |
TypeFlags.ContainsGenericVariablesComputed |
TypeFlags.HasGenericVarianceComputed |
TypeFlags.HasStaticConstructorComputed;
}
public void Init(string fullName, int flags, JsTypeFunction thisType, JsTypeFunction baseType, JsTypeFunction[] interfaces, JsTypeFunction[] typeArguments, FieldInfo[] fields, MethodInfo[] methods, ConstructorInfo[] constructors, PropertyInfo[] properties, EventInfo[] events, JsTypeFunction elementType, JsTypeFunction unconstructedType)
{
FullName = fullName;
typeFlags = (TypeFlags)flags;
// this.typeAttributes = typeAttributes;
this.thisType = thisType;
this.baseType = baseType;
this.interfaces = interfaces;
this.typeArguments = typeArguments;
this.fields = fields ?? new FieldInfo[0];
this.methods = methods ?? new MethodInfo[0];
this.properties = properties ?? new PropertyInfo[0];
this.constructors = constructors ?? new ConstructorInfo[0];
this.events = events ?? new EventInfo[0];
this.elementType = elementType;
this.unconstructedType = unconstructedType;
foreach (var field in this.fields)
field.declaringType = this;
foreach (var method in this.methods)
method.declaringType = this;
foreach (var property in this.properties)
{
property.declaringType = this;
if (property.GetMethod != null)
property.GetMethod.declaringType = this;
if (property.SetMethod != null)
property.SetMethod.declaringType = this;
}
foreach (var constructor in this.constructors)
constructor.declaringType = this;
}
protected override TypeFlags ComputeTypeFlags(TypeFlags mask)
{
TypeFlags flags = TypeFlags.FunctionPointer;
if ((mask & TypeFlags.ContainsGenericVariablesComputed) != 0)
{
flags |= TypeFlags.ContainsGenericVariablesComputed;
if (_signature.ReturnType.ContainsGenericVariables)
flags |= TypeFlags.ContainsGenericVariables;
else
{
for (int i = 0; i < _signature.Length; i++)
{
if (_signature[i].ContainsGenericVariables)
{
flags |= TypeFlags.ContainsGenericVariables;
break;
}
}
}
}
flags |= TypeFlags.HasGenericVarianceComputed;
return flags;
}
internal void CheckNeedConstructor()
{
if ((!this.IsValueType && !this.IsAbstract) && !this.HasDefaultConstructor)
{
this.flags |= TypeFlags.Unsupported;
this.exception = new InvalidOperationException(Res.GetString("XmlConstructorInaccessible", new object[] { this.FullName }));
}
}
public TypeDesc(string name, string fullName, TypeKind kind, TypeDesc baseTypeDesc, TypeFlags flags) {
this.name = name.Replace('+', '.');
this.fullName = fullName.Replace('+', '.');
this.kind = kind;
if (baseTypeDesc != null) {
this.baseTypeDesc = baseTypeDesc;
}
this.flags = flags;
this.isXsdType = kind == TypeKind.Primitive;
}
protected override TypeFlags ComputeTypeFlags(TypeFlags mask)
{
TypeFlags flags = 0;
flags |= TypeFlags.ContainsGenericVariablesComputed | TypeFlags.ContainsGenericVariables;
flags |= TypeFlags.GenericParameter;
return flags;
}
protected override TypeFlags ComputeTypeFlags(TypeFlags mask)
{
TypeFlags flags = 0;
if ((mask & TypeFlags.CategoryMask) != 0)
{
flags |= TypeFlags.SignatureTypeVariable;
}
return flags;
}
protected override TypeFlags ComputeTypeFlags(TypeFlags mask)
{
TypeFlags flags = 0;
flags |= TypeFlags.ContainsGenericVariablesComputed | TypeFlags.ContainsGenericVariables;
flags |= TypeFlags.GenericParameter;
flags |= TypeFlags.HasGenericVarianceComputed;
Debug.Assert((flags & mask) != 0);
return flags;
}
protected override TypeFlags ComputeTypeFlags(TypeFlags mask)
{
TypeFlags flags = TypeFlags.ByRef;
if ((mask & TypeFlags.ContainsGenericVariablesComputed) != 0)
{
flags |= TypeFlags.ContainsGenericVariablesComputed;
if (this.ParameterType.ContainsGenericVariables)
flags |= TypeFlags.ContainsGenericVariables;
}
return flags;
}
private static void AddPrimitive(Type type, string dataTypeName, string formatterName, TypeFlags flags)
{
XmlSchemaSimpleType dataType = new XmlSchemaSimpleType {
Name = dataTypeName
};
TypeDesc desc = new TypeDesc(type, true, dataType, formatterName, flags);
if (primitiveTypes[type] == null)
{
primitiveTypes.Add(type, desc);
}
primitiveDataTypes.Add(dataType, desc);
primitiveNames.Add(dataTypeName, "http://www.w3.org/2001/XMLSchema", desc);
}
protected override TypeFlags ComputeTypeFlags(TypeFlags mask)
{
TypeFlags flags = 0;
if ((mask & TypeFlags.CategoryMask) != 0)
{
flags |= TypeFlags.SignatureTypeVariable;
}
// Not all masks are valid to ask on signature variables. If you hit this assert, you might
// need to special case, or you have a bug.
Debug.Assert((flags & mask) != 0);
return flags;
}
private static void AddNonXsdPrimitive(Type type, string dataTypeName, string ns, string formatterName, XmlQualifiedName baseTypeName, XmlSchemaFacet[] facets, TypeFlags flags)
{
XmlSchemaSimpleType dataType = new XmlSchemaSimpleType {
Name = dataTypeName
};
XmlSchemaSimpleTypeRestriction restriction = new XmlSchemaSimpleTypeRestriction {
BaseTypeName = baseTypeName
};
foreach (XmlSchemaFacet facet in facets)
{
restriction.Facets.Add(facet);
}
dataType.Content = restriction;
TypeDesc desc = new TypeDesc(type, false, dataType, formatterName, flags);
if (primitiveTypes[type] == null)
{
primitiveTypes.Add(type, desc);
}
primitiveDataTypes.Add(dataType, desc);
primitiveNames.Add(dataTypeName, ns, desc);
}
protected override TypeFlags ComputeTypeFlags(TypeFlags mask)
{
TypeFlags flags = 0;
if ((mask & TypeFlags.CategoryMask) != 0)
{
flags |= TypeFlags.Class;
}
if ((mask & TypeFlags.HasGenericVarianceComputed) != 0)
{
flags |= TypeFlags.HasGenericVarianceComputed;
}
return flags;
}
protected void MarkEnumOrValueType(string typeNamespace, string typeName)
{
// we don't assume that mscorlib won't have nested types with these names,
// so we don't check that we're not a nested type
if (typeNamespace == "System"
&& (typeName == "Enum" || typeName == "ValueType")
&& this.Assembly.GetName().Name.Equals("mscorlib", StringComparison.OrdinalIgnoreCase))
{
typeFlags |= TypeFlags.EnumOrValueType;
}
}
public static bool IsArray(this TypeFlags flags)
{
return((flags & TypeFlags.kArray) != 0);
}
protected override TypeFlags ComputeTypeFlags(TypeFlags mask)
{
TypeFlags flags = 0;
if ((mask & TypeFlags.CategoryMask) != 0)
{
unsafe
{
EEType *eetype = _genericTypeDefinition.ToEETypePtr();
if (eetype->IsValueType)
{
if (eetype->CorElementType == 0)
{
flags |= TypeFlags.ValueType;
}
else
{
if (eetype->BaseType == typeof(System.Enum).TypeHandle.ToEETypePtr())
{
flags |= TypeFlags.Enum;
}
else
{
// Primitive type.
if (eetype->CorElementType <= CorElementType.ELEMENT_TYPE_U8)
{
flags |= (TypeFlags)eetype->CorElementType;
}
else
{
switch (eetype->CorElementType)
{
case CorElementType.ELEMENT_TYPE_I:
flags |= TypeFlags.IntPtr;
break;
case CorElementType.ELEMENT_TYPE_U:
flags |= TypeFlags.UIntPtr;
break;
case CorElementType.ELEMENT_TYPE_R4:
flags |= TypeFlags.Single;
break;
case CorElementType.ELEMENT_TYPE_R8:
flags |= TypeFlags.Double;
break;
default:
throw new BadImageFormatException();
}
}
}
}
}
else if (eetype->IsInterface)
{
flags |= TypeFlags.Interface;
}
else
{
flags |= TypeFlags.Class;
}
}
}
if ((mask & TypeFlags.IsByRefLikeComputed) != 0)
{
flags |= TypeFlags.IsByRefLikeComputed;
unsafe
{
EEType *eetype = _genericTypeDefinition.ToEETypePtr();
if (eetype->IsByRefLike)
{
flags |= TypeFlags.IsByRefLike;
}
}
}
return(flags);
}
protected override TypeFlags ComputeTypeFlags(TypeFlags mask)
{
TypeFlags flags = 0;
if ((mask & TypeFlags.ContainsGenericVariablesComputed) != 0)
{
flags |= TypeFlags.ContainsGenericVariablesComputed;
// TODO: Do we really want to get the instantiation to figure out whether the type is generic?
if (this.HasInstantiation)
{
flags |= TypeFlags.ContainsGenericVariables;
}
}
if ((mask & TypeFlags.CategoryMask) != 0 && (flags & TypeFlags.CategoryMask) == 0)
{
TypeDesc baseType = this.BaseType;
if (baseType != null && baseType.IsWellKnownType(WellKnownType.ValueType) &&
!this.IsWellKnownType(WellKnownType.Enum))
{
TypeFlags categoryFlags;
if (!TryGetCategoryFlagsForPrimitiveType(out categoryFlags))
{
categoryFlags = TypeFlags.ValueType;
}
flags |= categoryFlags;
}
else
if (baseType != null && baseType.IsWellKnownType(WellKnownType.Enum))
{
flags |= TypeFlags.Enum;
}
else
{
if ((_typeDefinition.Flags & TypeAttributes.Interface) != 0)
{
flags |= TypeFlags.Interface;
}
else
{
flags |= TypeFlags.Class;
}
}
// All other cases are handled during TypeSystemContext intitialization
}
if ((mask & TypeFlags.HasGenericVarianceComputed) != 0 &&
(flags & TypeFlags.HasGenericVarianceComputed) == 0)
{
flags |= TypeFlags.HasGenericVarianceComputed;
foreach (GenericParameterDesc genericParam in Instantiation)
{
if (genericParam.Variance != GenericVariance.None)
{
flags |= TypeFlags.HasGenericVariance;
break;
}
}
}
return(flags);
}
public TypeFilter(TypeFlags typeFlags, Func <IType, bool> predicate)
{
this.TypeFlags = typeFlags;
this.Predicate = predicate;
}
public bool IsAdaptive()
{
return(TypeFlags.Test((uint)(NetConnectionTypeFlags.ConnectionAdaptive | NetConnectionTypeFlags.ConnectionRemoteAdaptive)));
}
public static bool IsValueType(this TypeFlags flags)
{
return((flags & TypeFlags.kValueType) != 0);
}
public bool IsConnectionToClient()
{
return(TypeFlags.Test((uint)NetConnectionTypeFlags.ConnectionToClient));
}
public void SetIsAdaptive()
{
TypeFlags.Set((uint)NetConnectionTypeFlags.ConnectionAdaptive);
LocalRateChanged = true;
}
public void SetIsConnectionToClient()
{
TypeFlags.Set((uint)NetConnectionTypeFlags.ConnectionToClient);
}
public bool IsConnectionToServer()
{
return(TypeFlags.Test((uint)NetConnectionTypeFlags.ConnectionToServer));
}
private bool ComputeCanCompareValueTypeBits(MetadataType type)
{
Debug.Assert(type.IsValueType);
if (type.ContainsGCPointers)
{
return(false);
}
if (type.IsGenericDefinition)
{
return(false);
}
OverlappingFieldTracker overlappingFieldTracker = new OverlappingFieldTracker(type);
bool result = true;
foreach (var field in type.GetFields())
{
if (field.IsStatic)
{
continue;
}
if (!overlappingFieldTracker.TrackField(field))
{
// This field overlaps with another field - can't compare memory
result = false;
break;
}
TypeDesc fieldType = field.FieldType;
if (fieldType.IsPrimitive || fieldType.IsEnum || fieldType.IsPointer || fieldType.IsFunctionPointer)
{
TypeFlags category = fieldType.UnderlyingType.Category;
if (category == TypeFlags.Single || category == TypeFlags.Double)
{
// Double/Single have weird behaviors around negative/positive zero
result = false;
break;
}
}
else
{
// Would be a suprise if this wasn't a valuetype. We checked ContainsGCPointers above.
Debug.Assert(fieldType.IsValueType);
MethodDesc objectEqualsMethod = ((CompilerTypeSystemContext)fieldType.Context)._objectEqualsMethod;
// If the field overrides Equals, we can't use the fast helper because we need to call the method.
if (fieldType.FindVirtualFunctionTargetMethodOnObjectType(objectEqualsMethod).OwningType == fieldType)
{
result = false;
break;
}
if (!_hashtable.GetOrCreateValue((MetadataType)fieldType).CanCompareValueTypeBits)
{
result = false;
break;
}
}
}
// If there are gaps, we can't memcompare
if (result && overlappingFieldTracker.HasGaps)
{
result = false;
}
return(result);
}
public static bool CanBuildDispatcher(this TypeFlags flags)
{
return((flags & (TypeFlags.CanSerialize | TypeFlags.Remotable)) == (TypeFlags.CanSerialize | TypeFlags.Remotable));
}
static void AddSoapEncodedPrimitive(Type type, string dataTypeName, string ns, string formatterName, XmlQualifiedName baseTypeName, TypeFlags flags) {
AddNonXsdPrimitive(type, dataTypeName, ns, formatterName, baseTypeName, new XmlSchemaFacet[0], flags);
}
protected abstract TypeFlags ComputeTypeFlags(TypeFlags mask);
public static bool CanBuildProxy(this TypeFlags flags)
{
return((flags & (TypeFlags.CanDeserialize | TypeFlags.Remotable)) == (TypeFlags.CanDeserialize | TypeFlags.Remotable));
}
public TypeFilter(TypeFlags typeFlags)
{
this.TypeFlags = typeFlags;
}
public static bool CanDeserialize(this TypeFlags flags)
{
return((flags & TypeFlags.CanDeserialize) == TypeFlags.CanDeserialize);
}
protected override TypeFlags ComputeTypeFlags(TypeFlags mask)
{
TypeFlags flags = 0;
if ((mask & TypeFlags.CategoryMask) != 0 && (flags & TypeFlags.CategoryMask) == 0)
{
TypeDesc baseType = this.BaseType;
if (baseType != null && baseType.IsWellKnownType(WellKnownType.ValueType) &&
!this.IsWellKnownType(WellKnownType.Enum))
{
TypeFlags categoryFlags;
if (!TryGetCategoryFlagsForPrimitiveType(out categoryFlags))
{
categoryFlags = TypeFlags.ValueType;
}
flags |= categoryFlags;
}
else
if (baseType != null && baseType.IsWellKnownType(WellKnownType.Enum))
{
flags |= TypeFlags.Enum;
}
else
{
if ((_typeDefinition.Flags & TypeAttributes.Interface) != 0)
{
flags |= TypeFlags.Interface;
}
else
{
flags |= TypeFlags.Class;
}
}
// All other cases are handled during TypeSystemContext intitialization
}
if ((mask & TypeFlags.HasGenericVarianceComputed) != 0 &&
(flags & TypeFlags.HasGenericVarianceComputed) == 0)
{
flags |= TypeFlags.HasGenericVarianceComputed;
foreach (GenericParameterDesc genericParam in Instantiation)
{
if (genericParam.Variance != GenericVariance.None)
{
flags |= TypeFlags.HasGenericVariance;
break;
}
}
}
if ((mask & TypeFlags.HasFinalizerComputed) != 0)
{
flags |= TypeFlags.HasFinalizerComputed;
if (GetFinalizer() != null)
{
flags |= TypeFlags.HasFinalizer;
}
}
if ((mask & TypeFlags.AttributeCacheComputed) != 0)
{
flags |= TypeFlags.AttributeCacheComputed;
if (IsValueType && HasCustomAttribute("System.Runtime.CompilerServices", "IsByRefLikeAttribute"))
{
flags |= TypeFlags.IsByRefLike;
}
}
return(flags);
}
/// <summary>
/// Deflate the token
/// </summary>
/// <param name="destination">Stream to deflate token to</param>
public override void Deflate(Stream destination)
{
// Calculate total length by adding strings
uint totalPacketLength = (uint)(FixedPacketLength
+ (uint)(string.IsNullOrEmpty(HostName) ? 0 : HostName.Length * 2) // HostName
+ (uint)(string.IsNullOrEmpty(UserID) ? 0 : UserID.Length * 2) // UserID
+ (uint)(string.IsNullOrEmpty(Password) ? 0 : Password.Length * 2) // Password
+ (uint)(string.IsNullOrEmpty(ApplicationName) ? 0 : ApplicationName.Length * 2) // ApplicationName
+ (uint)(string.IsNullOrEmpty(ServerName) ? 0 : ServerName.Length * 2) // ServerName
+ (uint)(string.IsNullOrEmpty(LibraryName) ? 0 : LibraryName.Length * 2) // LibraryName
+ (uint)(string.IsNullOrEmpty(Language) ? 0 : Language.Length * 2) // Language
+ (uint)(string.IsNullOrEmpty(Database) ? 0 : Database.Length * 2) // Database
+ (uint)(string.IsNullOrEmpty(AttachDatabaseFile) ? 0 : AttachDatabaseFile.Length * 2) // AttachDatabaseFile
+ (uint)(string.IsNullOrEmpty(ChangePassword) ? 0 : ChangePassword.Length * 2) // ChangePassword
+ (uint)(SSPI == null ? 0 : SSPI.Length) // SSPI
+ 0); // Feature extension
MemoryStream featureExtension = null;
// Check if we have a feature extension
if (FeatureExt != null)
{
// Allocate feature extension block
featureExtension = new MemoryStream();
// Serialize feature extension
FeatureExt.Deflate(featureExtension);
// Update total lentgh
totalPacketLength += (uint)(sizeof(uint) /* Offset of feature extension data */ + featureExtension.Length /* feature extension itself*/);
}
// Write packet length
TDSUtilities.WriteUInt(destination, totalPacketLength);
// Compile TDS version
uint tdsVersion = Convert.ToUInt32(string.Format("{0:X}", Math.Max(TDSVersion.Major, 0)) + string.Format("{0:X}", Math.Max(TDSVersion.Minor, 0)) + string.Format("{0:X2}", Math.Max(TDSVersion.Build, 0)) + string.Format("{0:X4}", Math.Max(TDSVersion.Revision, 0)), 16);
// Write TDS version
TDSUtilities.WriteUInt(destination, tdsVersion);
// Write packet length
TDSUtilities.WriteUInt(destination, PacketSize);
// Write client program version
TDSUtilities.WriteUInt(destination, ClientProgramVersion);
// Write client program identifier
TDSUtilities.WriteUInt(destination, ClientPID);
// Write connection identifier
TDSUtilities.WriteUInt(destination, ConnectionID);
// Write the first optional flags
destination.WriteByte(OptionalFlags1.ToByte());
// Write the second optional flags
destination.WriteByte(OptionalFlags2.ToByte());
// Instantiate type flags
destination.WriteByte(TypeFlags.ToByte());
// Write the third optional flags
destination.WriteByte(OptionalFlags3.ToByte());
// Write client time zone
TDSUtilities.WriteInt(destination, ClientTimeZone);
// Write client locale identifier
TDSUtilities.WriteUInt(destination, ClientLCID);
// Prepare a collection of property values that will be set later
IList <TDSLogin7TokenOffsetProperty> variableProperties = new List <TDSLogin7TokenOffsetProperty>();
// Write client host name
variableProperties.Add(new TDSLogin7TokenOffsetProperty(GetType().GetProperty("HostName"), FixedPacketLength, (ushort)(string.IsNullOrEmpty(HostName) ? 0 : HostName.Length)));
TDSUtilities.WriteUShort(destination, (ushort)variableProperties.Last().Position);
TDSUtilities.WriteUShort(destination, (ushort)variableProperties.Last().Length);
// Write user name and password
variableProperties.Add(new TDSLogin7TokenOffsetProperty(GetType().GetProperty("UserID"), (ushort)(variableProperties.Last().Position + variableProperties.Last().Length * 2), (ushort)(string.IsNullOrEmpty(UserID) ? 0 : UserID.Length)));
TDSUtilities.WriteUShort(destination, (ushort)variableProperties.Last().Position);
TDSUtilities.WriteUShort(destination, (ushort)variableProperties.Last().Length);
variableProperties.Add(new TDSLogin7TokenOffsetProperty(GetType().GetProperty("Password"), (ushort)(variableProperties.Last().Position + variableProperties.Last().Length * 2), (ushort)(string.IsNullOrEmpty(Password) ? 0 : Password.Length)));
TDSUtilities.WriteUShort(destination, (ushort)variableProperties.Last().Position);
TDSUtilities.WriteUShort(destination, (ushort)variableProperties.Last().Length);
// Write application name
variableProperties.Add(new TDSLogin7TokenOffsetProperty(GetType().GetProperty("ApplicationName"), (ushort)(variableProperties.Last().Position + variableProperties.Last().Length * 2), (ushort)(string.IsNullOrEmpty(ApplicationName) ? 0 : ApplicationName.Length)));
TDSUtilities.WriteUShort(destination, (ushort)variableProperties.Last().Position);
TDSUtilities.WriteUShort(destination, (ushort)variableProperties.Last().Length);
// Write server name
variableProperties.Add(new TDSLogin7TokenOffsetProperty(GetType().GetProperty("ServerName"), (ushort)(variableProperties.Last().Position + variableProperties.Last().Length * 2), (ushort)(string.IsNullOrEmpty(ServerName) ? 0 : ServerName.Length)));
TDSUtilities.WriteUShort(destination, (ushort)variableProperties.Last().Position);
TDSUtilities.WriteUShort(destination, (ushort)variableProperties.Last().Length);
// Check if we have a feature extension block
if (FeatureExt != null)
{
// Write the offset of the feature extension offset (pointer to pointer)
variableProperties.Add(new TDSLogin7TokenOffsetProperty(GetType().GetProperty("FeatureExt"), (ushort)(variableProperties.Last().Position + variableProperties.Last().Length * 2), sizeof(uint) / 2, true)); // Should be 4 bytes, devided by 2 because the next guy multiplies by 2
TDSUtilities.WriteUShort(destination, (ushort)variableProperties.Last().Position);
TDSUtilities.WriteUShort(destination, (ushort)(variableProperties.Last().Length * 2)); // Compensate for division by 2 above
}
else
{
// Skip unused
TDSUtilities.WriteUShort(destination, 0);
TDSUtilities.WriteUShort(destination, 0);
}
// Write client library name
// We do not need to account for skipped unused bytes here because they're already accounted in fixedPacketLength
variableProperties.Add(new TDSLogin7TokenOffsetProperty(GetType().GetProperty("LibraryName"), (ushort)(variableProperties.Last().Position + variableProperties.Last().Length * 2), (ushort)(string.IsNullOrEmpty(LibraryName) ? 0 : LibraryName.Length)));
TDSUtilities.WriteUShort(destination, (ushort)variableProperties.Last().Position);
TDSUtilities.WriteUShort(destination, (ushort)variableProperties.Last().Length);
// Write language
variableProperties.Add(new TDSLogin7TokenOffsetProperty(GetType().GetProperty("Language"), (ushort)(variableProperties.Last().Position + variableProperties.Last().Length * 2), (ushort)(string.IsNullOrEmpty(Language) ? 0 : Language.Length)));
TDSUtilities.WriteUShort(destination, (ushort)variableProperties.Last().Position);
TDSUtilities.WriteUShort(destination, (ushort)variableProperties.Last().Length);
// Write database
variableProperties.Add(new TDSLogin7TokenOffsetProperty(GetType().GetProperty("Database"), (ushort)(variableProperties.Last().Position + variableProperties.Last().Length * 2), (ushort)(string.IsNullOrEmpty(Database) ? 0 : Database.Length)));
TDSUtilities.WriteUShort(destination, (ushort)variableProperties.Last().Position);
TDSUtilities.WriteUShort(destination, (ushort)variableProperties.Last().Length);
// Check if client is defined
if (ClientID == null)
{
// Allocate empty identifier
ClientID = new byte[6];
}
// Write unique client identifier
destination.Write(ClientID, 0, 6);
// Write SSPI
variableProperties.Add(new TDSLogin7TokenOffsetProperty(GetType().GetProperty("SSPI"), (ushort)(variableProperties.Last().Position + variableProperties.Last().Length * 2), (ushort)(SSPI == null ? 0 : SSPI.Length)));
TDSUtilities.WriteUShort(destination, (ushort)variableProperties.Last().Position);
TDSUtilities.WriteUShort(destination, (ushort)variableProperties.Last().Length);
// Write database file to be attached. NOTE, "variableProperties.Last().Length" without " * 2" because the preceeding buffer isn't string
variableProperties.Add(new TDSLogin7TokenOffsetProperty(GetType().GetProperty("AttachDatabaseFile"), (ushort)(variableProperties.Last().Position + variableProperties.Last().Length), (ushort)(string.IsNullOrEmpty(AttachDatabaseFile) ? 0 : AttachDatabaseFile.Length)));
TDSUtilities.WriteUShort(destination, (ushort)variableProperties.Last().Position);
TDSUtilities.WriteUShort(destination, (ushort)variableProperties.Last().Length);
// Write password change
variableProperties.Add(new TDSLogin7TokenOffsetProperty(GetType().GetProperty("ChangePassword"), (ushort)(variableProperties.Last().Position + variableProperties.Last().Length * 2), (ushort)(string.IsNullOrEmpty(ChangePassword) ? 0 : ChangePassword.Length)));
TDSUtilities.WriteUShort(destination, (ushort)variableProperties.Last().Position);
TDSUtilities.WriteUShort(destination, (ushort)variableProperties.Last().Length);
// Skip long SSPI
TDSUtilities.WriteUInt(destination, 0);
// We will be changing collection as we go and serialize everything. As such we can't use foreach and iterator.
int iCurrentProperty = 0;
// Iterate through the collection
while (iCurrentProperty < variableProperties.Count)
{
// Get current property by index
TDSLogin7TokenOffsetProperty property = variableProperties[iCurrentProperty];
// Check if length is positive
if (property.Length == 0)
{
// Move to the next property
iCurrentProperty++;
continue;
}
// Check special properties
if (property.Property.Name == "Password" || property.Property.Name == "ChangePassword")
{
// Write encrypted string value
TDSUtilities.WritePasswordString(destination, (string)property.Property.GetValue(this, null));
}
else if (property.Property.Name == "FeatureExt")
{
// Check if we are to serialize the offset or the actual data
if (property.IsOffsetOffset)
{
// Property will be written at the offset immediately following all variable length data
property.Position = variableProperties.Last().Position + variableProperties.Last().Length;
// Write the position at which we'll be serializing the feature extension block
TDSUtilities.WriteUInt(destination, property.Position);
// Order strings in ascending order by offset
variableProperties = variableProperties.OrderBy(p => p.Position).ToList();
// Compensate increment to the next position in order to stay on the same
iCurrentProperty--;
// No longer offset, actual data is going to follow
property.IsOffsetOffset = false;
}
else
{
// Transfer deflated feature extension into the login stream
featureExtension.WriteTo(destination);
}
}
else if (property.Property.Name == "SSPI")
{
// Write SSPI
destination.Write(SSPI, 0, SSPI.Length);
}
else
{
// Write the string value
TDSUtilities.WriteString(destination, (string)property.Property.GetValue(this, null));
}
// Move to the next property
iCurrentProperty++;
}
}
internal TypeDesc(Type type, bool isXsdType, XmlSchemaType dataType, string formatterName, TypeFlags flags)
: this(type.Name, type.FullName, dataType, TypeKind.Primitive, (TypeDesc)null, flags, formatterName)
{
_isXsdType = isXsdType;
_type = type;
}
public bool HasFlag(int arrayIndex, TypeFlags flag)
{
return((flags[arrayIndex] & flag) == flag);
}
internal void CheckNeedConstructor()
{
if (!IsValueType && !IsAbstract && !HasDefaultConstructor)
{
_flags |= TypeFlags.Unsupported;
_exception = new InvalidOperationException(SR.Format(SR.XmlConstructorInaccessible, FullName));
}
}
private static void AddNonXsdPrimitive(Type type, string dataTypeName, string ns, string formatterName, XmlQualifiedName baseTypeName, XmlSchemaFacet[] facets, TypeFlags flags)
{
XmlSchemaSimpleType dataType = new XmlSchemaSimpleType();
dataType.Name = dataTypeName;
TypeDesc typeDesc = new TypeDesc(type, false, dataType, formatterName, flags);
if (s_primitiveTypes[type] == null)
s_primitiveTypes.Add(type, typeDesc);
s_primitiveDataTypes.Add(dataType, typeDesc);
s_primitiveNames.Add(dataTypeName, ns, typeDesc);
}
public RoslynNamedType(INamedTypeSymbol namedTypeSymbol, ParseContext context)
: base(
// For unbound generics, we need to use the type it is constructed from to actuall get information about it
namedTypeSymbol.IsUnboundGenericType ? namedTypeSymbol.ConstructedFrom : namedTypeSymbol,
context
)
{
Comments = context.DocumentationProvider.GetDocumentationForSymbol(NamedTypeSymbol).Summary;
FullName = NamedTypeSymbol.GetNormalizedMetadataName(); // TODO May need to rethink
FilePath = namedTypeSymbol.DeclaringSyntaxReferences.FirstOrDefault()?.SyntaxTree?.FilePath; // TODO get rid of this
_constructedFrom = new Lazy <INamedType>(() => new RoslynNamedType(NamedTypeSymbol.ConstructedFrom, context));
_typeArguments = new Lazy <IReadOnlyList <IType> >(() =>
{
List <IType> typeArgs = new List <IType>();
foreach (ITypeSymbol typeParam in NamedTypeSymbol.TypeArguments)
{
typeArgs.Add(CreateType(typeParam, context));
}
return(typeArgs);
});
// Properties
_properties = new Lazy <IReadOnlyList <IProperty> >(() =>
{
List <IProperty> props = new List <IProperty>();
IEnumerable <IPropertySymbol> properties = NamedTypeSymbol.GetMembers().OfType <IPropertySymbol>();
foreach (IPropertySymbol propSymb in properties)
{
if (propSymb.GetMethod.DeclaredAccessibility == Accessibility.Public)
{
RoslynProperty clientProp = new RoslynProperty(propSymb, context);
props.Add(clientProp);
}
}
return(props);
});
// fields
_fields = new Lazy <IReadOnlyList <IField> >(() =>
{
List <IField> fields = new List <IField>();
foreach (IFieldSymbol fieldSymb in NamedTypeSymbol.GetMembers().OfType <IFieldSymbol>())
{
if (fieldSymb.DeclaredAccessibility == Accessibility.Public)
{
RoslynField field = new RoslynField(fieldSymb, context);
fields.Add(field);
}
}
return(fields);
});
// methods
_methods = new Lazy <IReadOnlyList <IMethod> >(() =>
{
List <IMethod> methods = new List <IMethod>();
foreach (IMethodSymbol methodSymb in NamedTypeSymbol.GetMembers().OfType <IMethodSymbol>())
{
if (methodSymb.DeclaredAccessibility == Accessibility.Public)
{
RoslynMethod clientProp = new RoslynMethod(methodSymb, context);
methods.Add(clientProp);
}
}
return(methods);
});
// Attributes
_attrs = new Lazy <IReadOnlyList <IAttributeData> >(() =>
{
return(RoslynAttributeData.FromSymbol(NamedTypeSymbol, context));
});
// Interfaces
_interfaces = new Lazy <IReadOnlyList <INamedType> >(() =>
{
List <INamedType> interfaces = new List <INamedType>();
foreach (INamedTypeSymbol interfaceSym in NamedTypeSymbol.Interfaces)
{
interfaces.Add(CreateNamedType(interfaceSym, context));
}
return(interfaces);
});
Flags = new TypeFlags(
isEnum: namedTypeSymbol.TypeKind == TypeKind.Enum,
isNullable: IsNullableType(),
isArray: namedTypeSymbol.TypeKind == TypeKind.Array,
isList: IsListType(),
isDictionary: IsDictionaryType(),
isAnonymous: TypeSymbol.IsAnonymousType,
isInterface: TypeSymbol.TypeKind == TypeKind.Interface
);
}
internal TypeDesc(string name, string fullName, XmlSchemaType dataType, TypeKind kind, TypeDesc baseTypeDesc, TypeFlags flags, string formatterName)
{
_name = name.Replace('+', '.');
_fullName = fullName.Replace('+', '.');
_kind = kind;
_baseTypeDesc = baseTypeDesc;
_flags = flags;
_isXsdType = kind == TypeKind.Primitive;
if (_isXsdType)
_weight = 1;
else if (kind == TypeKind.Enum)
_weight = 2;
else if (_kind == TypeKind.Root)
_weight = -1;
else
_weight = baseTypeDesc == null ? 0 : baseTypeDesc.Weight + 1;
_dataType = dataType;
_formatterName = formatterName;
}
public void SetIsConnectionToServer()
{
TypeFlags.Set((uint)NetConnectionTypeFlags.ConnectionToServer);
}
public static int ArrayRank(this TypeFlags flags)
{
return((int)(flags & TypeFlags.kArrayRankMask) >> 16);
}
internal void CheckNeedConstructor() {
if (!IsValueType && !IsAbstract && !HasDefaultConstructor) {
flags |= TypeFlags.Unsupported;
this.exception = new InvalidOperationException(Res.GetString(Res.XmlConstructorInaccessible, FullName));
}
}
public TypeDescription(string name, string assembly, FieldDescription[] fields, byte[] staticFieldBytes, int baseOrElementTypeIndes, int size, UInt64 typeInfoAddress, int typeIndex, TypeFlags flags)
{
m_Name = name;
m_Assembly = assembly;
m_Fields = fields;
m_StaticFieldBytes = staticFieldBytes;
m_BaseOrElementTypeIndex = baseOrElementTypeIndes;
m_Size = size;
m_TypeInfoAddress = typeInfoAddress;
m_TypeIndex = typeIndex;
m_Flags = flags;
}
private static Type GetEnumeratorElementType(Type type, ref TypeFlags flags)
{
if (typeof(IEnumerable).IsAssignableFrom(type))
{
MethodInfo enumerator = type.GetMethod("GetEnumerator", Array.Empty<Type>());
if (enumerator == null || !typeof(IEnumerator).IsAssignableFrom(enumerator.ReturnType))
{
// try generic implementation
enumerator = null;
foreach (MemberInfo member in type.GetMember("System.Collections.Generic.IEnumerable<*", BindingFlags.Public | BindingFlags.Instance | BindingFlags.NonPublic))
{
enumerator = member as MethodInfo;
if (enumerator != null && typeof(IEnumerator).IsAssignableFrom(enumerator.ReturnType))
{
// use the first one we find
flags |= TypeFlags.GenericInterface;
break;
}
else
{
enumerator = null;
}
}
if (enumerator == null)
{
// and finally private interface implementation
flags |= TypeFlags.UsePrivateImplementation;
enumerator = type.GetMethod("System.Collections.IEnumerable.GetEnumerator", BindingFlags.Public | BindingFlags.Instance | BindingFlags.NonPublic, Array.Empty<Type>());
}
}
if (enumerator == null || !typeof(IEnumerator).IsAssignableFrom(enumerator.ReturnType))
{
return null;
}
XmlAttributes methodAttrs = new XmlAttributes(enumerator);
if (methodAttrs.XmlIgnore) return null;
PropertyInfo p = enumerator.ReturnType.GetProperty("Current");
Type currentType = (p == null ? typeof(object) : p.PropertyType);
MethodInfo addMethod = type.GetMethod("Add", new Type[] { currentType });
if (addMethod == null && currentType != typeof(object))
{
currentType = typeof(object);
addMethod = type.GetMethod("Add", new Type[] { currentType });
}
if (addMethod == null)
{
throw new InvalidOperationException(SR.Format(SR.XmlNoAddMethod, type.FullName, currentType, "IEnumerable"));
}
return currentType;
}
else
{
return null;
}
}
protected override TypeFlags ComputeTypeFlags(TypeFlags mask)
{
TypeFlags flags = 0;
if ((mask & TypeFlags.CategoryMask) != 0)
{
TypeDesc baseType = this.BaseType;
if (baseType != null && baseType.IsWellKnownType(WellKnownType.ValueType))
{
flags |= TypeFlags.ValueType;
}
else
if (baseType != null && baseType.IsWellKnownType(WellKnownType.Enum))
{
flags |= TypeFlags.Enum;
}
else
{
if ((_typeDefinition.Attributes & TypeAttributes.Interface) != 0)
{
flags |= TypeFlags.Interface;
}
else
{
flags |= TypeFlags.Class;
}
}
// All other cases are handled during TypeSystemContext intitialization
}
if ((mask & TypeFlags.HasGenericVarianceComputed) != 0)
{
flags |= TypeFlags.HasGenericVarianceComputed;
foreach (GenericParameterDesc genericParam in Instantiation)
{
if (genericParam.Variance != GenericVariance.None)
{
flags |= TypeFlags.HasGenericVariance;
break;
}
}
}
if ((mask & TypeFlags.HasFinalizerComputed) != 0)
{
flags |= TypeFlags.HasFinalizerComputed;
if (GetFinalizer() != null)
{
flags |= TypeFlags.HasFinalizer;
}
}
if ((mask & TypeFlags.AttributeCacheComputed) != 0)
{
MetadataReader reader = MetadataReader;
MetadataStringComparer stringComparer = reader.StringComparer;
bool isValueType = IsValueType;
flags |= TypeFlags.AttributeCacheComputed;
foreach (CustomAttributeHandle attributeHandle in _typeDefinition.GetCustomAttributes())
{
if (MetadataReader.GetAttributeNamespaceAndName(attributeHandle, out StringHandle namespaceHandle, out StringHandle nameHandle))
{
if (isValueType &&
stringComparer.Equals(nameHandle, "IsByRefLikeAttribute") &&
stringComparer.Equals(namespaceHandle, "System.Runtime.CompilerServices"))
{
flags |= TypeFlags.IsByRefLike;
}
if (stringComparer.Equals(nameHandle, "IntrinsicAttribute") &&
stringComparer.Equals(namespaceHandle, "System.Runtime.CompilerServices"))
{
flags |= TypeFlags.IsIntrinsic;
}
}
}
}
return(flags);
}
internal TypeDesc(Type type, string name, string fullName, TypeKind kind, TypeDesc baseTypeDesc, TypeFlags flags, TypeDesc arrayElementTypeDesc)
: this(name, fullName, null, kind, baseTypeDesc, flags, null)
{
_arrayElementTypeDesc = arrayElementTypeDesc;
_type = type;
}
void Write(DmdType type, TypeFlags flags)
{
if ((object)type == null)
{
writer.Append("???");
return;
}
if (!IncrementRecursionCounter())
{
writer.Append("???");
return;
}
switch (type.TypeSignatureKind)
{
case DmdTypeSignatureKind.Type:
if ((flags & TypeFlags.NoDeclaringTypeNames) == 0 && type.DeclaringType is DmdType declType && !type.IsGenericParameter)
{
Write(declType, flags | (IsGenericTypeDefinition(type) ? TypeFlags.NoGenericDefParams : 0));
writer.Append('+');
}
if (!type.IsNested && type.MetadataNamespace is string ns && ns.Length > 0)
{
if ((globalFlags & GlobalFlags.Serializable) != 0 ||
((flags & TypeFlags.MethodGenericArgumentType) == 0 && ((flags & TypeFlags.ShortSpecialNames) == 0 || !IsShortNameType(type))))
{
WriteIdentifier(ns);
writer.Append('.');
}
}
WriteIdentifier(type.MetadataName);
if ((flags & TypeFlags.NoGenericDefParams) == 0 && (globalFlags & GlobalFlags.Serializable) == 0)
{
WriteTypeGenericArguments(GetGenericArguments(type), flags & ~TypeFlags.NoGenericDefParams);
}
break;
case DmdTypeSignatureKind.Pointer:
Write(type.GetElementType(), flags);
writer.Append('*');
break;
case DmdTypeSignatureKind.ByRef:
Write(type.GetElementType(), flags);
writer.Append('&');
break;
case DmdTypeSignatureKind.TypeGenericParameter:
case DmdTypeSignatureKind.MethodGenericParameter:
WriteIdentifier(type.MetadataName);
break;
case DmdTypeSignatureKind.SZArray:
Write(type.GetElementType(), flags);
writer.Append("[]");
break;
case DmdTypeSignatureKind.MDArray:
Write(type.GetElementType(), flags);
writer.Append('[');
var rank = type.GetArrayRank();
if (rank <= 0)
{
writer.Append("???");
}
else if (rank == 1)
{
writer.Append('*');
}
else
{
writer.Append(',', rank - 1);
}
writer.Append(']');
break;
case DmdTypeSignatureKind.GenericInstance:
Write(GetGenericTypeDefinition(type), flags | TypeFlags.NoGenericDefParams);
if ((flags & TypeFlags.MethodGenericArgumentType) == 0)
{
WriteTypeGenericArguments(GetGenericArguments(type), flags);
}
break;
case DmdTypeSignatureKind.FunctionPointer:
if ((flags & TypeFlags.FnPtrIsIntPtr) != 0)
{
Write(type.AppDomain.System_IntPtr, flags);
}
else
{
writer.Append("(fnptr)");
}
break;
default: throw new InvalidOperationException();
}
DecrementRecursionCounter();
}
private static void AddPrimitive(Type type, string dataTypeName, string formatterName, TypeFlags flags)
{
XmlSchemaSimpleType dataType = new XmlSchemaSimpleType();
dataType.Name = dataTypeName;
TypeDesc typeDesc = new TypeDesc(type, true, dataType, formatterName, flags);
if (s_primitiveTypes[type] == null)
s_primitiveTypes.Add(type, typeDesc);
s_primitiveDataTypes.Add(dataType, typeDesc);
s_primitiveNames.Add(dataTypeName, XmlSchema.Namespace, typeDesc);
}
void WriteTypeGenericArguments(IList <DmdType> genericArguments, TypeFlags flags) => WriteGenericArguments(genericArguments, flags & ~(TypeFlags.ShortSpecialNames | TypeFlags.NoDeclaringTypeNames));
internal TypeDesc GetTypeDesc(string name, string ns, TypeFlags flags)
{
TypeDesc typeDesc = (TypeDesc)s_primitiveNames[name, ns];
if (typeDesc != null)
{
if ((typeDesc.Flags & flags) != 0)
{
return typeDesc;
}
}
return null;
}
void WriteMethodGenericArguments(IList <DmdType> genericArguments, TypeFlags flags) => WriteGenericArguments(genericArguments, flags | TypeFlags.MethodGenericArgumentType);
internal Type MarkValueType()
{
typeFlags |= TypeFlags.ValueType;
return this;
}
void WriteName(DmdType type, TypeFlags flags)
{
if ((object)type == null)
{
writer.Append("???");
return;
}
if (!IncrementRecursionCounter())
{
writer.Append("???");
return;
}
switch (type.TypeSignatureKind)
{
case DmdTypeSignatureKind.Type:
WriteIdentifier(type.MetadataName);
break;
case DmdTypeSignatureKind.Pointer:
WriteName(type.GetElementType(), flags);
writer.Append('*');
break;
case DmdTypeSignatureKind.ByRef:
WriteName(type.GetElementType(), flags);
writer.Append('&');
break;
case DmdTypeSignatureKind.TypeGenericParameter:
case DmdTypeSignatureKind.MethodGenericParameter:
WriteIdentifier(type.MetadataName);
break;
case DmdTypeSignatureKind.SZArray:
WriteName(type.GetElementType(), flags);
writer.Append("[]");
break;
case DmdTypeSignatureKind.MDArray:
WriteName(type.GetElementType(), flags);
writer.Append('[');
var rank = type.GetArrayRank();
if (rank <= 0)
{
writer.Append("???");
}
else if (rank == 1)
{
writer.Append('*');
}
else
{
writer.Append(',', rank - 1);
}
writer.Append(']');
break;
case DmdTypeSignatureKind.GenericInstance:
WriteName(GetGenericTypeDefinition(type), flags);
break;
case DmdTypeSignatureKind.FunctionPointer:
if ((flags & TypeFlags.FnPtrIsIntPtr) != 0)
{
WriteName(type.AppDomain.System_IntPtr, flags);
}
else
{
writer.Append("(fnptr)");
}
break;
default: throw new InvalidOperationException();
}
DecrementRecursionCounter();
}
internal Type(Type underlyingType)
{
System.Diagnostics.Debug.Assert(underlyingType.underlyingType == underlyingType);
this.underlyingType = underlyingType;
this.typeFlags = underlyingType.typeFlags;
}
protected override TypeFlags ComputeTypeFlags(TypeFlags mask)
{
return(TypeFlags.Class |
TypeFlags.HasGenericVarianceComputed |
TypeFlags.HasStaticConstructorComputed);
}
protected override TypeFlags ComputeTypeFlags(TypeFlags mask)
{
TypeFlags flags = 0;
if ((mask & TypeFlags.CategoryMask) != 0)
{
// Universally canonical type is reported as a variable-sized struct.
// It's the closest logical thing and avoids special casing around it.
flags |= TypeFlags.ValueType;
}
return flags;
}
StructMapping ImportStructType(XmlSchemaComplexType type, string typeNs, bool excludeFromImport)
{
if (type.Name == null)
{
XmlSchemaElement element = (XmlSchemaElement)type.Parent;
XmlQualifiedName parentType = XmlSchemas.GetParentName(element);
throw new InvalidOperationException(Res.GetString(Res.XmlInvalidSchemaElementType, parentType.Name, parentType.Namespace, element.Name));
}
TypeDesc baseTypeDesc = null;
Mapping baseMapping = null;
if (!type.DerivedFrom.IsEmpty)
{
baseMapping = ImportType(type.DerivedFrom, excludeFromImport);
if (baseMapping is StructMapping)
{
baseTypeDesc = ((StructMapping)baseMapping).TypeDesc;
}
else
{
baseMapping = null;
}
}
if (baseMapping == null)
{
baseMapping = GetRootMapping();
}
Mapping previousMapping = (Mapping)ImportedMappings[type];
if (previousMapping != null)
{
return((StructMapping)previousMapping);
}
string typeName = GenerateUniqueTypeName(Accessor.UnescapeName(type.Name));
StructMapping structMapping = new StructMapping();
structMapping.IsReference = Schemas.IsReference(type);
TypeFlags flags = TypeFlags.Reference;
if (type.IsAbstract)
{
flags |= TypeFlags.Abstract;
}
structMapping.TypeDesc = new TypeDesc(typeName, typeName, TypeKind.Struct, baseTypeDesc, flags);
structMapping.Namespace = typeNs;
structMapping.TypeName = type.Name;
structMapping.BaseMapping = (StructMapping)baseMapping;
ImportedMappings.Add(type, structMapping);
if (excludeFromImport)
{
structMapping.IncludeInSchema = false;
}
CodeIdentifiers members = new CodeIdentifiers();
members.AddReserved(typeName);
AddReservedIdentifiersForDataBinding(members);
structMapping.Members = ImportTypeMembers(type, typeNs, members);
Scope.AddTypeMapping(structMapping);
ImportDerivedTypes(new XmlQualifiedName(type.Name, typeNs));
return(structMapping);
}
