internal static void RemoveTypeModifier(ref string type, out TypeModifier typeModifier, out bool isRefType)
{
isRefType = false;
typeModifier = TypeModifier.None;
var match = _typeParser.Match(type);
if (match.Success)
{
type = match.Groups["typeName"].Value;
switch (match.Groups["modifier"].Value)
{
case "Collection":
typeModifier = TypeModifier.Array;
return;
case "Ref":
isRefType = true;
return;
default:
Debug.Assert(false, "Unexpected modifier: " + match.Groups["modifier"].Value);
break;
}
}
}
internal static void RemoveTypeModifier(
ref string type,
out TypeModifier typeModifier,
out bool isRefType)
{
isRefType = false;
typeModifier = TypeModifier.None;
Match match = Function._typeParser.Match(type);
if (!match.Success)
{
return;
}
type = match.Groups["typeName"].Value;
switch (match.Groups["modifier"].Value)
{
case "Collection":
typeModifier = TypeModifier.Array;
break;
case "Ref":
isRefType = true;
break;
}
}
public void EmitType(TypeKind kind,
string name,
Action <TypeBuilder> @type,
AccessModifier accessModifier = AccessModifier.Internal,
IEnumerable <string> baseTypes = null,
TypeModifier modifiers = TypeModifier.None,
IEnumerable <string> summary = null,
Action <DocBuilder> docs = null,
IEnumerable <string> attributes = null)
{
this.EmitTypePreamble(summary, docs, attributes);
this.writer.WriteLine($"{accessModifier.Emit()} {RenderTypeModifiers(modifiers)}{kind.ToString().ToLowerInvariant()} {name}");
if (baseTypes != null && baseTypes.Any())
{
this.writer.IncreaseIndent();
this.writer.WriteLine($": {string.Join(", ", baseTypes)}");
this.writer.DecreaseIndent();
}
using (var builder = new TypeBuilder(this.writer.GetSubWriter(), name))
{
@type(builder);
}
}
/// <summary>
/// Creates a new FuncParamSig object.
/// </summary>
/// <param name="name">The name of the param.</param>
/// <param name="modifier">How the param is passed.</param>
/// <param name="typeName">The type name of the param.</param>
public FuncParamSig(string name, TypeModifier modifier, string typeName)
{
if (string.IsNullOrEmpty(name))
{
throw new ArgumentException(nameof(name));
}
if (string.IsNullOrEmpty(typeName))
{
throw new ArgumentException(nameof(typeName));
}
var id = new Identifier(name);
base.AddChild(id);
var type = new TypeName(typeName);
if (modifier == TypeModifier.ByReference)
{
base.AddChild(UnaryOpSequence.Generate(UnaryOperatorType.Star, type));
}
else
{
base.AddChild(type);
}
}
/// <summary>
/// Creates a new FuncReturnSig object.
/// </summary>
/// <param name="name">The optional variable name. Pass null if there is no name.</param>
/// <param name="modifier">How the return value is passed.</param>
/// <param name="typeName">The type name of the param.</param>
public FuncReturnSig(string name, TypeModifier modifier, string typeName)
{
if (name != null && string.IsNullOrWhiteSpace(name))
{
throw new ArgumentException("pass null for name when there is no variable name");
}
if (string.IsNullOrEmpty(typeName))
{
throw new ArgumentException(nameof(TypeName));
}
if (name != null)
{
var id = new Identifier(name);
base.AddChild(id);
IsNamed = true;
}
var type = new TypeName(typeName);
if (modifier == TypeModifier.ByReference)
{
base.AddChild(UnaryOpSequence.Generate(UnaryOperatorType.Star, type));
}
else
{
base.AddChild(type);
}
}
public Parameter(Name name, Rfl.Type type, bool is_const, TypeModifier modifier, int array_rank, int array_length_0, int array_length_1)
{
Name = name;
Type = type;
IsConst = is_const;
Modifier = modifier;
ArrayRank = array_rank;
ArrayLength0 = array_length_0;
ArrayLength1 = array_length_1;
}
public TypeModifier XsdTypeModifierToTypeModifier(SegmentationCodesCategoryTypeModifier xsdTypeModifier)
{
var typeModifier = new TypeModifier
{
CodeMeaning = xsdTypeModifier.codeMeaning,
CodeValue = xsdTypeModifier.codeValue,
CodingSchemeDesignator = xsdTypeModifier.codingScheme
};
return(typeModifier);
}
private string RenderTypeModifiers(TypeModifier modifiers)
{
var builder = new StringBuilder();
foreach (TypeModifier value in Enum.GetValues(typeof(TypeModifier)))
{
if (value != TypeModifier.None && modifiers.HasFlag(value))
{
builder.Append(value.ToString().ToLowerInvariant() + " ");
}
}
return(builder.ToString());
}
public override TypeModifier VisitTypeModifier(TypeModifier typeModifier)
{
if (this._string == null)
{
this._string = new StringBuilder();
}
this._string.Append(typeModifier.TypeCode.ToString());
this._string.Append("(");
this.Visit(typeModifier.Modifier);
this._string.Append(",");
this.Visit(typeModifier.ModifiedType);
this._string.Append(")");
return(typeModifier); // base.VisitTypeModifier (typeModifier);
}
public static bool IsVoid(TypeNode type)
{
TypeModifier mtype = type as TypeModifier;
if (mtype != null)
{
return(IsVoid(mtype.ModifiedType));
}
if (type != null && type.Equals(Cci.SystemTypes.Void))
{
return(true);
}
return(false);
}
private static string ConvertModifierToString(TypeModifier modifier)
{
switch (modifier)
{
case TypeModifier.Value: return(string.Empty);
case TypeModifier.Pointer: return("*");
case TypeModifier.LVReference: return("&");
case TypeModifier.RVReference: return("&&");
}
return(string.Empty);
}
public void EmitDelegate(string type,
string name,
AccessModifier accessModifier = AccessModifier.Internal,
TypeModifier modifiers = TypeModifier.None,
Action <ParameterBuilder> parameters = null,
IEnumerable <string> summary = null,
Action <DocBuilder> docs = null,
IEnumerable <string> attributes = null)
{
this.EmitTypePreamble(summary, docs, attributes);
string parameterList = parameters != null
? ParameterBuilder.Apply(parameters)
: "";
this.writer.WriteLine($"{accessModifier.Emit()} {RenderTypeModifiers(modifiers)}delegate {type} {name}({parameterList});");
}
public ParameterHelper(ParameterInfo tp)
{
Name = tp.ParameterType.AssemblyQualifiedName;
Modifier = TypeModifier.None;
if (tp.IsIn)
{
Modifier = TypeModifier.In;
}
else if (tp.IsOut)
{
Modifier = TypeModifier.Out;
}
else if (tp.ParameterType.IsByRef)
{
Modifier = TypeModifier.Ref;
}
}
private TypeModifier GetTypeModifier(ref IDiaSymbol type)
{
TypeModifier modifier = TypeModifier.Value;
if (type.symTag == (uint)SymTagEnum.SymTagPointerType)
{
if (type.reference != 0)
{
modifier = TypeModifier.Reference;
}
else
{
modifier = TypeModifier.Pointer;
}
// Dereference pointer type
type = type.type;
}
return(modifier);
}
/// <summary>
/// </summary>
/// <param name="type"> </param>
/// <returns> </returns>
internal static void RemoveTypeModifier(ref string type, out TypeModifier typeModifier, out bool isRefType)
{
isRefType = false;
typeModifier = TypeModifier.None;
var match = _typeParser.Match(type);
if (match.Success)
{
type = match.Groups["typeName"].Value;
switch (match.Groups["modifier"].Value)
{
case "Collection":
typeModifier = TypeModifier.Array;
return;
case "Ref":
isRefType = true;
return;
default:
Debug.Assert(false, "Unexpected modifier: " + match.Groups["modifier"].Value);
break;
}
}
}
public Type XsdTypeToType(SegmentationCodesCategoryType xsdType)
{
var type = new Type
{
CodeMeaning = xsdType.codeMeaning,
CodeValue = xsdType.codeValue,
CodingSchemeDesignator = xsdType.codingScheme
};
if (xsdType.Modifier != null)
{
foreach (SegmentationCodesCategoryTypeModifier xsdModifier in xsdType.Modifier)
{
if (xsdModifier != null)
{
TypeModifier typeModifier = XsdTypeModifierToTypeModifier(xsdModifier);
type.TypeModifiers.Add(typeModifier);
}
}
}
return(type);
}
private static IReadOnlyList <FuncCallParam> GenerateApiCallParams(MethodGo mg, string unmarshalVar)
{
// use mg.LocalParameters instead of Parameters so that the
// subscription ID and API version params (and possibly others)
// are omitted as they are part of the client.
if (!mg.LocalParameters.Any())
{
return(null);
}
var funcCallParams = new List <FuncCallParam>();
// the go generator places parameters that aren't required at the end
// TODO: expose this in the generator so we don't have to duplicate the logic
var paramsList = mg.LocalParameters.OrderBy(p => !p.IsRequired).ToList();
foreach (var param in paramsList)
{
TypeModifier typeMod = TypeModifier.ByReference;
if (param.IsRequired || param.ModelType.CanBeEmpty())
{
typeMod = TypeModifier.ByValue;
}
funcCallParams.Add(new FuncCallParam(new Identifier($"{unmarshalVar}.{param.Name.ToString().Capitalize()}"), typeMod));
}
// if this is a long-running operation there will be an optional channel
// parameter at the end of the parameter list, pass nil for this one.
if (mg.IsLongRunningOperation())
{
funcCallParams.Add(new FuncCallParam(new Nil(), TypeModifier.ByValue));
}
return(funcCallParams);
}
public virtual TypeModifier VisitTypeModifier(TypeModifier typeModifier){
if (typeModifier == null) return null;
typeModifier.Modifier = this.VisitTypeReference(typeModifier.Modifier);
typeModifier.ModifiedType = this.VisitTypeReference(typeModifier.ModifiedType);
return typeModifier;
}
void UpdateContent (IType cls)
{
Name = cls.Name;
ctype = cls.ClassType;
modifiers = cls.Modifiers;
typeModifier = cls.TypeModifier;
this.typeParameterCount = cls.TypeParameters.Count;
flags = (ContentFlags) 0;
if (this.typeParameterCount > 0)
flags |= ContentFlags.HasGenericParams;
if (cls.Attributes.Count () > 0)
flags |= ContentFlags.HasAttributes;
if ((cls.BaseType != null && !cls.BaseType.ToInvariantString ().Equals (DomReturnType.Object.ToInvariantString ())) || cls.ImplementedInterfaces.Count () > 0)
flags |= ContentFlags.HasBaseTypes;
if (cls.CompilationUnit != null)
flags |= ContentFlags.HasCompilationUnit;
if (cls.Documentation != null && cls.Documentation.Length > 0)
flags |= ContentFlags.HasDocumentation;
if (cls.EventCount > 0)
flags |= ContentFlags.HasEvents;
if (cls.FieldCount > 0)
flags |= ContentFlags.HasFields;
if (cls.IndexerCount > 0)
flags |= ContentFlags.HasIndexers;
if (cls.InnerTypeCount > 0)
flags |= ContentFlags.HasInnerClasses;
if (cls.MethodCount > 0)
flags |= ContentFlags.HasMethods;
if (cls.PropertyCount > 0)
flags |= ContentFlags.HasProperties;
if (cls.HasParts)
flags |= ContentFlags.HasParts;
if (cls.Location != DomLocation.Empty)
flags |= ContentFlags.HasRegion;
if (cls.BodyRegion != DomRegion.Empty)
flags |= ContentFlags.HasBodyRegion;
if (cls.ConstructorCount > 0)
flags |= ContentFlags.HasConstructors;
if (cls.IsObsolete)
flags |= ContentFlags.IsObsolete;
if (cls.HasExtensionMethods)
flags |= ContentFlags.HasExtensionMethods;
}
public override TypeNode VisitTypeReference(TypeNode type)
{
if (type == null)
{
return(null);
}
Class cl = type as Class;
if (cl != null)
{
this.VisitTypeReference(cl.BaseClass);
}
if (this.MembersToFind[type.UniqueKey] != null)
{
this.FoundMembers[type.UniqueKey] = type;
if (!this.insideMethodBody)
{
this.AllReferencesAreConfinedToMethodBodies = false;
}
return(type);
}
switch (type.NodeType)
{
case NodeType.ArrayType:
ArrayType arrType = (ArrayType)type;
this.VisitTypeReference(arrType.ElementType);
return(type);
case NodeType.DelegateNode: {
FunctionType ftype = type as FunctionType;
if (ftype == null)
{
goto default;
}
this.VisitTypeReference(ftype.ReturnType);
this.VisitParameterList(ftype.Parameters);
return(type);
}
case NodeType.Pointer:
Pointer pType = (Pointer)type;
this.VisitTypeReference(pType.ElementType);
return(type);
case NodeType.Reference:
Reference rType = (Reference)type;
this.VisitTypeReference(rType.ElementType);
return(type);
case NodeType.TupleType: {
TupleType tType = (TupleType)type;
MemberList members = tType.Members;
int n = members == null ? 0 : members.Count;
for (int i = 0; i < n; i++)
{
Field f = members[i] as Field;
if (f == null)
{
continue;
}
this.VisitTypeReference(f.Type);
}
return(type);
}
case NodeType.TypeIntersection:
TypeIntersection tIntersect = (TypeIntersection)type;
this.VisitTypeReferenceList(tIntersect.Types);
return(type);
case NodeType.TypeUnion:
TypeUnion tUnion = (TypeUnion)type;
this.VisitTypeReferenceList(tUnion.Types);
return(type);
case NodeType.ArrayTypeExpression:
ArrayTypeExpression aExpr = (ArrayTypeExpression)type;
this.VisitTypeReference(aExpr.ElementType);
return(type);
case NodeType.BoxedTypeExpression:
BoxedTypeExpression bExpr = (BoxedTypeExpression)type;
this.VisitTypeReference(bExpr.ElementType);
return(type);
case NodeType.ClassExpression:
ClassExpression cExpr = (ClassExpression)type;
this.VisitExpression(cExpr.Expression);
this.VisitTypeReferenceList(cExpr.TemplateArguments);
return(type);
case NodeType.ClassParameter:
case NodeType.TypeParameter:
return(type);
case NodeType.ConstrainedType:
ConstrainedType conType = (ConstrainedType)type;
this.VisitTypeReference(conType.UnderlyingType);
this.VisitExpression(conType.Constraint);
return(type);
case NodeType.FlexArrayTypeExpression:
FlexArrayTypeExpression flExpr = (FlexArrayTypeExpression)type;
this.VisitTypeReference(flExpr.ElementType);
return(type);
case NodeType.FunctionTypeExpression:
FunctionTypeExpression ftExpr = (FunctionTypeExpression)type;
this.VisitParameterList(ftExpr.Parameters);
this.VisitTypeReference(ftExpr.ReturnType);
return(type);
case NodeType.InvariantTypeExpression:
InvariantTypeExpression invExpr = (InvariantTypeExpression)type;
this.VisitTypeReference(invExpr.ElementType);
return(type);
case NodeType.InterfaceExpression:
InterfaceExpression iExpr = (InterfaceExpression)type;
this.VisitExpression(iExpr.Expression);
this.VisitTypeReferenceList(iExpr.TemplateArguments);
return(type);
case NodeType.NonEmptyStreamTypeExpression:
NonEmptyStreamTypeExpression neExpr = (NonEmptyStreamTypeExpression)type;
this.VisitTypeReference(neExpr.ElementType);
return(type);
case NodeType.NonNullTypeExpression:
NonNullTypeExpression nnExpr = (NonNullTypeExpression)type;
this.VisitTypeReference(nnExpr.ElementType);
return(type);
case NodeType.NonNullableTypeExpression:
NonNullableTypeExpression nbExpr = (NonNullableTypeExpression)type;
this.VisitTypeReference(nbExpr.ElementType);
return(type);
case NodeType.NullableTypeExpression:
NullableTypeExpression nuExpr = (NullableTypeExpression)type;
this.VisitTypeReference(nuExpr.ElementType);
return(type);
case NodeType.OptionalModifier:
case NodeType.RequiredModifier:
TypeModifier modType = (TypeModifier)type;
this.VisitTypeReference(modType.ModifiedType);
this.VisitTypeReference(modType.Modifier);
return(type);
case NodeType.PointerTypeExpression:
PointerTypeExpression pExpr = (PointerTypeExpression)type;
this.VisitTypeReference(pExpr.ElementType);
return(type);
case NodeType.ReferenceTypeExpression:
ReferenceTypeExpression rExpr = (ReferenceTypeExpression)type;
this.VisitTypeReference(rExpr.ElementType);
return(type);
case NodeType.StreamTypeExpression:
StreamTypeExpression sExpr = (StreamTypeExpression)type;
this.VisitTypeReference(sExpr.ElementType);
return(type);
case NodeType.TupleTypeExpression:
TupleTypeExpression tuExpr = (TupleTypeExpression)type;
this.VisitFieldList(tuExpr.Domains);
return(type);
case NodeType.TypeExpression:
TypeExpression tExpr = (TypeExpression)type;
this.VisitExpression(tExpr.Expression);
this.VisitTypeReferenceList(tExpr.TemplateArguments);
return(type);
case NodeType.TypeIntersectionExpression:
TypeIntersectionExpression tiExpr = (TypeIntersectionExpression)type;
this.VisitTypeReferenceList(tiExpr.Types);
return(type);
case NodeType.TypeUnionExpression:
TypeUnionExpression tyuExpr = (TypeUnionExpression)type;
this.VisitTypeReferenceList(tyuExpr.Types);
return(type);
default:
if (type.Template != null && type.TemplateArguments != null)
{
this.VisitTypeReference(type.Template);
this.VisitTypeReferenceList(type.TemplateArguments);
}
return(type);
}
}
public override TypeModifier VisitTypeModifier(TypeModifier typeModifier){
if (typeModifier == null) return null;
this.VisitResolvedTypeReference(typeModifier.ModifiedType, typeModifier.ModifiedTypeExpression);
this.VisitResolvedTypeReference(typeModifier.Modifier, typeModifier.ModifierExpression);
return base.VisitTypeModifier(typeModifier);
}
void UpdateContent(IType cls)
{
Name = cls.Name;
ctype = cls.ClassType;
modifiers = cls.Modifiers;
typeModifier = cls.TypeModifier;
this.typeParameterCount = cls.TypeParameters.Count;
flags = (ContentFlags)0;
if (this.typeParameterCount > 0)
{
flags |= ContentFlags.HasGenericParams;
}
if (cls.Attributes.Count() > 0)
{
flags |= ContentFlags.HasAttributes;
}
if ((cls.BaseType != null && !cls.BaseType.ToInvariantString().Equals(DomReturnType.Object.ToInvariantString())) || cls.ImplementedInterfaces.Count() > 0)
{
flags |= ContentFlags.HasBaseTypes;
}
if (cls.CompilationUnit != null)
{
flags |= ContentFlags.HasCompilationUnit;
}
if (cls.Documentation != null && cls.Documentation.Length > 0)
{
flags |= ContentFlags.HasDocumentation;
}
if (cls.EventCount > 0)
{
flags |= ContentFlags.HasEvents;
}
if (cls.FieldCount > 0)
{
flags |= ContentFlags.HasFields;
}
if (cls.IndexerCount > 0)
{
flags |= ContentFlags.HasIndexers;
}
if (cls.InnerTypeCount > 0)
{
flags |= ContentFlags.HasInnerClasses;
}
if (cls.MethodCount > 0)
{
flags |= ContentFlags.HasMethods;
}
if (cls.PropertyCount > 0)
{
flags |= ContentFlags.HasProperties;
}
if (cls.HasParts)
{
flags |= ContentFlags.HasParts;
}
if (cls.Location != DomLocation.Empty)
{
flags |= ContentFlags.HasRegion;
}
if (cls.BodyRegion != DomRegion.Empty)
{
flags |= ContentFlags.HasBodyRegion;
}
if (cls.ConstructorCount > 0)
{
flags |= ContentFlags.HasConstructors;
}
if (cls.IsObsolete)
{
flags |= ContentFlags.IsObsolete;
}
if (cls.HasExtensionMethods)
{
flags |= ContentFlags.HasExtensionMethods;
}
}
private static void WriteType(TypeNode type, TextWriter writer)
{
switch (type.NodeType)
{
case NodeType.ArrayType:
ArrayType array = type as ArrayType;
WriteType(array.ElementType, writer);
writer.Write("[");
if (array.Rank > 1)
{
for (int i = 0; i < array.Rank; i++)
{
if (i > 0)
{
writer.Write(",");
}
writer.Write("0:");
}
}
writer.Write("]");
break;
case NodeType.Reference:
Reference reference = type as Reference;
TypeNode referencedType = reference.ElementType;
WriteType(referencedType, writer);
writer.Write("@");
break;
case NodeType.Pointer:
Pointer pointer = type as Pointer;
WriteType(pointer.ElementType, writer);
writer.Write("*");
break;
case NodeType.OptionalModifier:
TypeModifier optionalModifierClause = type as TypeModifier;
WriteType(optionalModifierClause.ModifiedType, writer);
writer.Write("!");
WriteType(optionalModifierClause.Modifier, writer);
break;
case NodeType.RequiredModifier:
TypeModifier requiredModifierClause = type as TypeModifier;
WriteType(requiredModifierClause.ModifiedType, writer);
writer.Write("|");
WriteType(requiredModifierClause.Modifier, writer);
break;
default:
if (type.IsTemplateParameter)
{
ITypeParameter gtp = (ITypeParameter)type;
if (gtp.DeclaringMember is TypeNode)
{
writer.Write("`");
}
else if (gtp.DeclaringMember is Method)
{
writer.Write("``");
}
else
{
throw new InvalidOperationException("Generic parameter not on type or method.");
}
writer.Write(gtp.ParameterListIndex);
}
else
{
// namespace
TypeNode declaringType = type.DeclaringType;
if (declaringType != null)
{
// names of nested types begin with outer type name
WriteType(declaringType, writer);
writer.Write(".");
}
else
{
// otherwise just prepend the namespace
Identifier space = type.Namespace;
if ((space != null) && !String.IsNullOrEmpty(space.Name))
{
//string space = type.Namespace.Name;
//if (space != null && space.Length > 0) {
writer.Write(space.Name);
writer.Write(".");
}
}
// name
writer.Write(type.GetUnmangledNameWithoutTypeParameters());
// generic parameters
if (type.IsGeneric)
{
// number of parameters
TypeNodeList parameters = type.TemplateParameters;
if (parameters != null)
{
writer.Write("`{0}", parameters.Count);
}
// arguments
TypeNodeList arguments = type.TemplateArguments;
if ((arguments != null) && (arguments.Count > 0))
{
writer.Write("{");
for (int i = 0; i < arguments.Count; i++)
{
TypeNode argument = arguments[i];
if (i > 0)
{
writer.Write(",");
}
WriteType(arguments[i], writer);
}
writer.Write("}");
}
}
}
break;
}
}
public virtual void VisitTypeModifier(TypeModifier typeModifier)
{
if (typeModifier == null) return;
this.VisitTypeReference(typeModifier.Modifier);
this.VisitTypeReference(typeModifier.ModifiedType);
}
Parameter ReflectParameter(IDiaSymbol dia_param)
{
// Decode array information
IDiaSymbol type = dia_param.type;
int array_length_0 = 1, array_length_1 = 1;
int array_rank = GetArrayRank(ref type, ref array_length_0, ref array_length_1);
// Check rank and size
if (array_rank > 2 || array_length_0 > (1 << 15) || array_length_1 > (1 << 15))
{
// NOTE: No reason is given here for the failure
return(null);
}
// Decode the DIA type modifier and name
TypeModifier modifier = GetTypeModifier(ref type);
string type_name = GetTypeName(type);
// Is this a template type?
int template_index = type_name.IndexOf('<');
if (template_index != -1)
{
// Has the template been reflected?
string template_name = type_name.Remove(template_index);
Rfl.Type template_type = null;
if (m_TypeMap.TryGetValue(template_name, out template_type) && template_type is Rfl.Template)
{
// Get the template instance parameters
string[] template_params = Rfl.Template.ParseInstance(type_name, template_index);
Rfl.Type type0;
m_TypeMap.TryGetValue(template_params[0], out type0);
Rfl.Type type1;
m_TypeMap.TryGetValue(template_params[1], out type1);
// If the first type can't be determined, this isn't a valid template instance
if (type0 == null)
{
return(null);
}
// If the template instance doesn't exist, create it
Rfl.Type instance;
if (!m_TypeMap.TryGetValue(type_name, out instance))
{
// Strip scope from instance name
string parent_scope = template_type.ParentScope.FullName.String;
string instance_name = type_name.Substring(parent_scope.Length + 2);
//
// Assign the virtual address for the type-of function. Note that if the template parameter
// list is not fully matched (e.g. std::vector<int, std::allocator<int> > where the second parameter
// doesn't get matched), this will only record the address for the first instance that is parsed.
// This may or may not be a problem and will require a little more thought if a proper solution
// is required (e.g. a list of virtual addresses for all combinations).
//
instance = new Rfl.TemplateInstance(
template_type.ParentScope,
instance_name,
(uint)type.length,
TypeOfVirtualAddress(type_name),
template_type as Rfl.Template,
type0,
type1);
m_TypeMap.Add(type_name, instance);
m_DiaSymbolMap.Add(instance, type);
instance.ParentScope.TemplateInstances.Add(instance as Rfl.TemplateInstance);
m_Logger.WriteSection("Reflecting TemplateInstance - {" + instance.FullName.String + "}");
// Reflect the constructors, etc - minimal reflection is set to true for template instances
ReflectClassMethods(instance);
m_Logger.EndSection();
}
}
}
// Has this type been reflected?
Rfl.Type rfl_type = null;
if (m_TypeMap.TryGetValue(type_name, out rfl_type))
{
// Some parameters won't have a name (e.g. return parameter)
Name name = null;
if (dia_param.name != null)
{
name = new Name(dia_param.name);
}
return(new Parameter(
name,
rfl_type,
type.constType != 0,
modifier,
array_rank,
array_length_0,
array_length_1));
}
return(null);
}
public virtual Differences VisitTypeModifier(TypeModifier typeModifier1, TypeModifier typeModifier2){
Differences differences = new Differences(typeModifier1, typeModifier2);
if (typeModifier1 == null || typeModifier2 == null){
if (typeModifier1 != typeModifier2) differences.NumberOfDifferences++; else differences.NumberOfSimilarities++;
return differences;
}
TypeModifier changes = (TypeModifier)typeModifier2.Clone();
TypeModifier deletions = (TypeModifier)typeModifier2.Clone();
TypeModifier insertions = (TypeModifier)typeModifier2.Clone();
Differences diff = this.VisitTypeNode(typeModifier1.ModifiedType, typeModifier2.ModifiedType);
if (diff == null){Debug.Assert(false); return differences;}
changes.ModifiedType = diff.Changes as TypeNode;
deletions.ModifiedType = diff.Deletions as TypeNode;
insertions.ModifiedType = diff.Insertions as TypeNode;
//Debug.Assert(diff.Changes == changes.ModifiedType && diff.Deletions == deletions.ModifiedType && diff.Insertions == insertions.ModifiedType);
differences.NumberOfDifferences += diff.NumberOfDifferences;
differences.NumberOfSimilarities += diff.NumberOfSimilarities;
diff = this.VisitTypeNode(typeModifier1.Modifier, typeModifier2.Modifier);
if (diff == null){Debug.Assert(false); return differences;}
changes.Modifier = diff.Changes as TypeNode;
deletions.Modifier = diff.Deletions as TypeNode;
insertions.Modifier = diff.Insertions as TypeNode;
//Debug.Assert(diff.Changes == changes.Modifier && diff.Deletions == deletions.Modifier && diff.Insertions == insertions.Modifier);
differences.NumberOfDifferences += diff.NumberOfDifferences;
differences.NumberOfSimilarities += diff.NumberOfSimilarities;
if (differences.NumberOfDifferences == 0){
differences.Changes = null;
differences.Deletions = null;
differences.Insertions = null;
}else{
differences.Changes = changes;
differences.Deletions = deletions;
differences.Insertions = insertions;
}
return differences;
}
public override TypeModifier VisitTypeModifier(TypeModifier typeModifier) {
if (this._string == null){ this._string = new StringBuilder(); }
this._string.Append(typeModifier.TypeCode.ToString());
this._string.Append("(");
this.Visit(typeModifier.Modifier);
this._string.Append(",");
this.Visit(typeModifier.ModifiedType);
this._string.Append(")");
return typeModifier; // base.VisitTypeModifier (typeModifier);
}
/// <summary>
/// Initializes FuncCallParam with the specified values.
/// </summary>
/// <param name="param">The paramater to pass.</param>
/// <param name="pass">How the parameter should be passed.</param>
public FuncCallParam(Node param, TypeModifier pass)
{
Param = param;
Pass = pass;
}
public virtual TypeModifier VisitTypeModifier(TypeModifier typeModifier, TypeModifier changes, TypeModifier deletions, TypeModifier insertions){
this.UpdateSourceContext(typeModifier, changes);
if (typeModifier == null) return changes;
if (changes != null){
if (deletions == null || insertions == null)
Debug.Assert(false);
else{
}
}else if (deletions != null)
return null;
return typeModifier;
}
//=====================================================================
/// <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);
// !EFW - Skip writing out the modifier if it's an InAttribute. Not sure if this is the best
// way to handle this so we'll have to wait and see.
if (requiredModifierClause.Modifier.Name.Name != "InAttribute")
{
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;
}
}
public TypeModifier XsdTypeModifierToTypeModifier(SegmentationCodesCategoryTypeModifier xsdTypeModifier)
{
var typeModifier = new TypeModifier
{
CodeMeaning = xsdTypeModifier.codeMeaning,
CodeValue = xsdTypeModifier.codeValue,
CodingSchemeDesignator = xsdTypeModifier.codingScheme
};
return typeModifier;
}
public override TypeModifier VisitTypeModifier(TypeModifier typeModifier)
{
throw new ApplicationException("unimplemented");
}
public override TypeModifier VisitTypeModifier(TypeModifier typeModifier)
{
throw new ApplicationException("unimplemented");
}
public virtual TypeModifier VisitTypeModifier(TypeModifier typeModifier1, TypeModifier typeModifier2)
{
if (typeModifier1 == null) return null;
if (typeModifier2 == null)
{
typeModifier1.Modifier = this.VisitTypeReference(typeModifier1.Modifier, null);
typeModifier1.ModifiedType = this.VisitTypeReference(typeModifier1.ModifiedType, null);
}
else
{
typeModifier1.Modifier = this.VisitTypeReference(typeModifier1.Modifier, typeModifier2.Modifier);
typeModifier1.ModifiedType = this.VisitTypeReference(typeModifier1.ModifiedType, typeModifier2.ModifiedType);
}
return typeModifier1;
}
//=====================================================================
/// <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());
RenameTypeIfNecessary(sb);
// 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;
}
}
public override TypeNode VisitTypeReference(TypeNode type)
{ //TODO: break up this method
if (type == null)
{
return(null);
}
TypeNodeList pars = this.pars;
TypeNodeList args = this.args;
switch (type.NodeType)
{
case NodeType.ArrayType:
ArrayType arrType = (ArrayType)type;
TypeNode elemType = this.VisitTypeReference(arrType.ElementType);
if (elemType == arrType.ElementType || elemType == null)
{
return(arrType);
}
if (arrType.IsSzArray())
{
return(elemType.GetArrayType(1));
}
return(elemType.GetArrayType(arrType.Rank, arrType.Sizes, arrType.LowerBounds));
case NodeType.DelegateNode:
{
FunctionType ftype = type as FunctionType;
if (ftype == null)
{
goto default;
}
TypeNode referringType = ftype.DeclaringType == null ? this.CurrentType : this.VisitTypeReference(ftype.DeclaringType);
return(FunctionType.For(this.VisitTypeReference(ftype.ReturnType), this.VisitParameterList(ftype.Parameters), referringType));
}
case NodeType.Pointer:
Pointer pType = (Pointer)type;
elemType = this.VisitTypeReference(pType.ElementType);
if (elemType == pType.ElementType || elemType == null)
{
return(pType);
}
return(elemType.GetPointerType());
case NodeType.Reference:
Reference rType = (Reference)type;
elemType = this.VisitTypeReference(rType.ElementType);
if (elemType == rType.ElementType || elemType == null)
{
return(rType);
}
return(elemType.GetReferenceType());
case NodeType.ArrayTypeExpression:
ArrayTypeExpression aExpr = (ArrayTypeExpression)type;
aExpr.ElementType = this.VisitTypeReference(aExpr.ElementType);
return(aExpr);
case NodeType.BoxedTypeExpression:
BoxedTypeExpression bExpr = (BoxedTypeExpression)type;
bExpr.ElementType = this.VisitTypeReference(bExpr.ElementType);
return(bExpr);
case NodeType.ClassExpression:
{
ClassExpression cExpr = (ClassExpression)type;
cExpr.Expression = this.VisitTypeExpression(cExpr.Expression);
//Could happen if the expression is a template parameter
if (cExpr.Expression is Literal lit)
{
return(lit.Value as TypeNode);
}
cExpr.TemplateArguments = this.VisitTypeReferenceList(cExpr.TemplateArguments);
return(cExpr);
}
case NodeType.ClassParameter:
case NodeType.TypeParameter:
int key = type.UniqueKey;
for (int i = 0, n = pars == null ? 0 : pars.Count, m = args == null ? 0 : args.Count; i < n && i < m; i++)
{
//^ assert pars != null && args != null;
TypeNode tp = pars[i];
if (tp == null)
{
continue;
}
if (tp.UniqueKey == key)
{
return(args[i]);
}
if (tp.Name.UniqueIdKey == type.Name.UniqueIdKey && (tp is ClassParameter && type is TypeParameter))
{
//This shouldn't really happen, but in practice it does. Hack past it.
return(args[i]);
}
}
return(type);
case NodeType.FlexArrayTypeExpression:
FlexArrayTypeExpression flExpr = (FlexArrayTypeExpression)type;
flExpr.ElementType = this.VisitTypeReference(flExpr.ElementType);
return(flExpr);
case NodeType.FunctionTypeExpression:
FunctionTypeExpression ftExpr = (FunctionTypeExpression)type;
ftExpr.Parameters = this.VisitParameterList(ftExpr.Parameters);
ftExpr.ReturnType = this.VisitTypeReference(ftExpr.ReturnType);
return(ftExpr);
case NodeType.InvariantTypeExpression:
InvariantTypeExpression invExpr = (InvariantTypeExpression)type;
invExpr.ElementType = this.VisitTypeReference(invExpr.ElementType);
return(invExpr);
case NodeType.InterfaceExpression:
InterfaceExpression iExpr = (InterfaceExpression)type;
if (iExpr.Expression == null)
{
goto default;
}
iExpr.Expression = this.VisitTypeExpression(iExpr.Expression);
iExpr.TemplateArguments = this.VisitTypeReferenceList(iExpr.TemplateArguments);
return(iExpr);
case NodeType.NonEmptyStreamTypeExpression:
NonEmptyStreamTypeExpression neExpr = (NonEmptyStreamTypeExpression)type;
neExpr.ElementType = this.VisitTypeReference(neExpr.ElementType);
return(neExpr);
case NodeType.NonNullTypeExpression:
NonNullTypeExpression nnExpr = (NonNullTypeExpression)type;
nnExpr.ElementType = this.VisitTypeReference(nnExpr.ElementType);
return(nnExpr);
case NodeType.NonNullableTypeExpression:
NonNullableTypeExpression nbExpr = (NonNullableTypeExpression)type;
nbExpr.ElementType = this.VisitTypeReference(nbExpr.ElementType);
return(nbExpr);
case NodeType.NullableTypeExpression:
NullableTypeExpression nuExpr = (NullableTypeExpression)type;
nuExpr.ElementType = this.VisitTypeReference(nuExpr.ElementType);
return(nuExpr);
case NodeType.OptionalModifier:
{
TypeModifier modType = (TypeModifier)type;
TypeNode modifiedType = this.VisitTypeReference(modType.ModifiedType);
TypeNode modifierType = this.VisitTypeReference(modType.Modifier);
if (modifiedType == null || modifierType == null)
{
return(type);
}
return(OptionalModifier.For(modifierType, modifiedType));
}
case NodeType.RequiredModifier:
{
TypeModifier modType = (TypeModifier)type;
TypeNode modifiedType = this.VisitTypeReference(modType.ModifiedType);
TypeNode modifierType = this.VisitTypeReference(modType.Modifier);
if (modifiedType == null || modifierType == null)
{
Debug.Fail(""); return(type);
}
return(RequiredModifier.For(modifierType, modifiedType));
}
case NodeType.OptionalModifierTypeExpression:
OptionalModifierTypeExpression optmodType = (OptionalModifierTypeExpression)type;
optmodType.ModifiedType = this.VisitTypeReference(optmodType.ModifiedType);
optmodType.Modifier = this.VisitTypeReference(optmodType.Modifier);
return(optmodType);
case NodeType.RequiredModifierTypeExpression:
RequiredModifierTypeExpression reqmodType = (RequiredModifierTypeExpression)type;
reqmodType.ModifiedType = this.VisitTypeReference(reqmodType.ModifiedType);
reqmodType.Modifier = this.VisitTypeReference(reqmodType.Modifier);
return(reqmodType);
case NodeType.PointerTypeExpression:
PointerTypeExpression pExpr = (PointerTypeExpression)type;
pExpr.ElementType = this.VisitTypeReference(pExpr.ElementType);
return(pExpr);
case NodeType.ReferenceTypeExpression:
ReferenceTypeExpression rExpr = (ReferenceTypeExpression)type;
rExpr.ElementType = this.VisitTypeReference(rExpr.ElementType);
return(rExpr);
case NodeType.StreamTypeExpression:
StreamTypeExpression sExpr = (StreamTypeExpression)type;
sExpr.ElementType = this.VisitTypeReference(sExpr.ElementType);
return(sExpr);
case NodeType.TupleTypeExpression:
TupleTypeExpression tuExpr = (TupleTypeExpression)type;
tuExpr.Domains = this.VisitFieldList(tuExpr.Domains);
return(tuExpr);
case NodeType.TypeExpression:
{
TypeExpression tExpr = (TypeExpression)type;
tExpr.Expression = this.VisitTypeExpression(tExpr.Expression);
if (tExpr.Expression is Literal)
{
return(type);
}
tExpr.TemplateArguments = this.VisitTypeReferenceList(tExpr.TemplateArguments);
return(tExpr);
}
case NodeType.TypeIntersectionExpression:
TypeIntersectionExpression tiExpr = (TypeIntersectionExpression)type;
tiExpr.Types = this.VisitTypeReferenceList(tiExpr.Types);
return(tiExpr);
case NodeType.TypeUnionExpression:
TypeUnionExpression tyuExpr = (TypeUnionExpression)type;
tyuExpr.Types = this.VisitTypeReferenceList(tyuExpr.Types);
return(tyuExpr);
default:
TypeNode declaringType = this.VisitTypeReference(type.DeclaringType);
if (declaringType != null)
{
Identifier tname = type.Name;
if (type.Template != null && type.IsGeneric)
{
tname = type.Template.Name;
}
TypeNode nt = declaringType.GetNestedType(tname);
if (nt != null)
{
TypeNodeList arguments = type.TemplateArguments;
type = nt;
if (TargetPlatform.UseGenerics)
{
if (arguments != null && arguments.Count > 0 && nt.ConsolidatedTemplateParameters != null && nt.ConsolidatedTemplateParameters.Count > 0)
{
type = nt.GetTemplateInstance(this.TargetModule, this.CurrentType, declaringType, arguments);
}
}
}
}
if (type.Template != null && (type.ConsolidatedTemplateParameters == null || type.ConsolidatedTemplateParameters.Count == 0))
{
if (!type.IsNotFullySpecialized && (!type.IsNormalized ||
(this.CurrentType != null && type.DeclaringModule == this.CurrentType.DeclaringModule)))
{
return(type);
}
// Type is a template instance, but some of its arguments were themselves parameters.
// See if any of these parameters are to be specialized by this specializer.
bool mustSpecializeFurther = false;
TypeNodeList targs = type.TemplateArguments;
int numArgs = targs == null ? 0 : targs.Count;
if (targs != null)
{
targs = new TypeNodeList(targs);
for (int i = 0; i < numArgs; i++)
{
TypeNode targ = targs[i];
if (targ is ITypeParameter tparg)
{
for (int j = 0, np = pars == null ? 0 : pars.Count, m = args == null ? 0 : args.Count; j < np && j < m; j++)
{
//^ assert pars != null && args != null;
if (TargetPlatform.UseGenerics)
{
if (!(pars[j] is ITypeParameter par))
{
continue;
}
if (tparg == par || (tparg.ParameterListIndex == par.ParameterListIndex && tparg.DeclaringMember == par.DeclaringMember))
{
targ = this.args[j];
break;
}
}
else
{
if (targ == pars[j])
{
targ = this.args[j];
break;
}
}
}
}
else
{
if (targ != type)
{
targ = this.VisitTypeReference(targ);
}
if (targ == type)
{
continue;
}
}
mustSpecializeFurther |= targs[i] != targ;
targs[i] = targ;
}
}
if (targs == null || !mustSpecializeFurther)
{
return(type);
}
return(type.Template.GetTemplateInstance(this.TargetModule, this.CurrentType, declaringType, targs));
}
TypeNodeList tPars = type.TemplateParameters;
if (tPars == null || tPars.Count == 0)
{
return(type); //Not a parameterized type. No need to get an instance.
}
TypeNodeList tArgs = new TypeNodeList();
for (int i = 0, n = tPars.Count; i < n; i++)
{
TypeNode tPar = tPars[i];
tArgs.Add(tPar); //Leave parameter in place if there is no match
if (tPar == null || tPar.Name == null)
{
continue;
}
int idKey = tPar.Name.UniqueIdKey;
for (int j = 0, m = pars == null ? 0 : pars.Count, k = args == null ? 0 : args.Count; j < m && j < k; j++)
{
//^ assert pars != null && args != null;
TypeNode par = pars[j];
if (par == null || par.Name == null)
{
continue;
}
if (par.Name.UniqueIdKey == idKey)
{
tArgs[i] = args[j];
break;
}
}
}
return(type.GetTemplateInstance(this.TargetModule, this.CurrentType, this.VisitTypeReference(type.DeclaringType), tArgs));
}
}
public override TypeModifier VisitTypeModifier(TypeModifier typeModifier)
{
if (typeModifier == null) return null;
return base.VisitTypeModifier((TypeModifier)typeModifier.Clone());
}
