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 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()); }