public IDictionary <string, ITypeReference> GetTypeReferenceListing() { Dictionary <string, ITypeReference> result = new Dictionary <string, ITypeReference>(); ITypeParameterMembers tParams = this; IDeclarationTarget target = this.TargetDeclaration; while (target != null) { foreach (ITypeParameterMember arg in tParams.Values) { result.Add(arg.Name, arg.GetTypeReference()); } if (target.ParentTarget != null) { target = target.ParentTarget; } if (target is IParameteredDeclaredType) { tParams = ((IParameteredDeclaredType)target).TypeParameters; } else { target = null; } } return(result); }
public BreakStatement(IStatementBlock sourceBlock) : base(sourceBlock) { IStatementBlockLocalMember local = null; IBreakTargetExitPoint exitPoint = null; IDeclarationTarget parent = sourceBlock; //Search up for the block that needs the break. while (parent != null && local == null) { if (parent is IBreakTargetStatement) { local = ((IBreakTargetStatement)parent).BreakLocal; exitPoint = ((IBreakTargetStatement)parent).ExitLabel; ((IBreakTargetStatement)parent).UtilizeBreakMeasures = true; break; } parent = parent.ParentTarget; } if (local == null && !(sourceBlock.Parent is ISwitchStatementCase)) { throw new InvalidOperationException("Cannot insert a break into a non-terminable block."); } this.terminalVariable = local; this.exitSymbol = exitPoint; }
public IIntermediateProject AddNew(IDeclarationTarget parentTarget) { IIntermediateProject iip = new IntermediateProject(this.RootDeclaration); iip.ParentTarget = parentTarget; lock (this.baseList) this.baseList.Add(iip); return(iip); }
private string Obfuscate(string p, IDeclarationTarget target) { string result; string oP = p; p += target.ToString(); if (!obfuscations.TryGetValue(p, out result)) { int l = (int)r.Next(1, oP.Length); StringBuilder sb = new StringBuilder(); for (int i = 0; i < l; i++) { char current = p[r.Next(0, p.Length)]; switch (current) { case '[': case ']': current = 'Ø'; break; case ':': case '.': case ',': case ' ': case '+': current = '_'; break; case '(': case ')': current = 'µ'; break; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': if (i == 0) { current = (char)('ⅰ' + (current - '0')); } break; } sb.Append(current); } result = sb.ToString(); obfuscations.Add(p, result); } return(result); }
internal static bool ImplementsNameCollideCheck(IDeclarationTarget source, string interfaceName, ICodeTranslationOptions options) { IDeclarationTarget idt = source; string shortInterfaceName = interfaceName; if (shortInterfaceName.Contains(".")) { shortInterfaceName = shortInterfaceName.Substring(shortInterfaceName.LastIndexOf('.') + 1); } int hitCount = 0; bool autoResolve = options.AutoResolveReferences; if (autoResolve) { options.AutoResolveReferences = false; } List <string> names = new List <string>(); while (idt != null) { if (idt is IInterfaceImplementableType) { IInterfaceImplementableType parent = (IInterfaceImplementableType)idt; foreach (ITypeReference itr in parent.ImplementsList) { string shortCurrentName; string currentName = itr.TypeInstance.GetTypeName(options); if (currentName.Contains(".")) { shortCurrentName = currentName.Substring(currentName.LastIndexOf('.') + 1); } else { shortCurrentName = currentName; } //Increment the hit count if the short name of the current //interface equals that of the one requested. And if the exact //name hasn't been encountered yet. If it hasn't then it's a valid match //otherwise it's just the same exact one. if (shortCurrentName == shortInterfaceName && !names.Contains(currentName)) { hitCount++; } names.Add(currentName); } } idt = idt.ParentTarget; } if (autoResolve) { options.AutoResolveReferences = autoResolve; } return(hitCount > 1); }
/// <summary> /// Returns the number of members in the declarations that target what's provided. /// </summary> /// <param name="target">The member to check which target.</param> /// <returns>An integer containing the number of members that are children of the <paramref name="target"/>.</returns> public int GetCountForTarget(IDeclarationTarget target) { int count = 0; foreach (TItem member in this.Values) { if (member.ParentTarget.Equals(target)) { count++; } } return(count); }
/// <summary> /// Determines whether the <paramref name="declaration"/> is a candidate for a module in /// the Visual Basic.NET language. /// </summary> /// <param name="declaration">The <see cref="IDeclarationTarget"/> to check to see if it /// is a vb module candidate.</param> /// <returns>true if the <paramref name="declaration"/> is a valid candidate.</returns> /// <remarks>If the <paramref name="declaration"/> is a valid candidate, the translator /// will flatten the partial hierarchy using the options' <see cref="ICodeTranslationOptions.AllowPartials"/> property.</remarks> internal static bool DeclarationIsVBModuleCandidate(IDeclarationTarget declaration) { if (!(declaration is IClassType)) { return(false); } IClassType @class = (IClassType)declaration; if ((@class.TypeParameters == null || @class.TypeParameters.Count == 0) && @class.IsStatic) { return(@class.ParentTarget is INameSpaceDeclaration && @class.Partials.Count == 0); } return(false); }
private void InitializeNameSpaceDependencies() { if (!this.initialized) { Begin(); } List <string> result = new List <string>(); foreach (ITypeReference itr in this.sourceData) { IType it = itr.TypeInstance; if (it is IDeclaredType) { IDeclarationTarget idt = (IDeclarationTarget)it; while (idt != null && (!(idt is INameSpaceDeclaration))) { idt = idt.ParentTarget; } if (idt is INameSpaceDeclaration) { if (!result.Contains(((INameSpaceDeclaration)(idt)).FullName)) { result.Add(((INameSpaceDeclaration)(idt)).FullName); } } else { continue; } } else if (it is IExternType) { if (((IExternType)(it)).Type.IsGenericParameter) { continue; } if ((!(result.Contains(((IExternType)(it)).Type.Namespace)))) { result.Add(((IExternType)(it)).Type.Namespace); } } else { continue; } } result.Sort(nsSorter); this.nameSpaceDependencies = result; }
public INameSpaceDeclaration GetNamespace() { IDeclarationTarget current = this; while (!((current is INameSpaceDeclaration) || (current == null))) { current = current.ParentTarget; } /* * * The condition of the iteration determines whether this is null. * If the parent item is null, or a namespace, it should be valued * accordingly. * */ return((INameSpaceDeclaration)current); }
internal static void GetDeclaredHierarchy(IDeclaredTypeReference typeReference, ITypeReferenceCollection typeParameters, out List <IDeclaredType> hierarchy, out Stack <ITypeReference> typeParamsStack) { IDeclaredType type = typeReference.TypeInstance; hierarchy = new List <IDeclaredType>(); List <ITypeReference> typeParams = new List <ITypeReference>(typeParameters); typeParams.Reverse(); typeParamsStack = new Stack <ITypeReference>(typeParams); for (IDeclarationTarget iDecTar = type; iDecTar != null && iDecTar is IDeclaredType; iDecTar = iDecTar.ParentTarget) { hierarchy.Add((IDeclaredType)iDecTar); } hierarchy.Reverse(); }
private static IList <IDeclarationTarget> GetDeclarationHierarchy(IDeclarationTarget source) { Stack <IDeclarationTarget> stack = new Stack <IDeclarationTarget>(); List <IDeclarationTarget> result = new List <IDeclarationTarget>(); IDeclarationTarget current = source; while (!((current is INameSpaceDeclaration) || (current == null))) { stack.Push(current); current = current.ParentTarget; } while (stack.Count > 0) { result.Add(stack.Pop()); } return(result); }
protected virtual ITypeReferenceCollection FillInTypeParameters(ITypeReferenceCollection originalSet) { List <IDeclarationTarget> parents = new List <IDeclarationTarget>(); ITypeReferenceCollection resultSet; if (originalSet == null) { resultSet = new TypeReferenceCollection(); } else { resultSet = new TypeReferenceCollection(originalSet.ToArray()); } for (IDeclarationTarget parent = this; ((parent != null) && (!(parent is INameSpaceDeclaration))); parent = parent.ParentTarget) { parents.Add(parent); } parents.Reverse(); int skip = 0; for (IDeclarationTarget parent = parents[0]; parents.Count > 0; parents.RemoveAt(0), parent = parents.Count > 0 ? parents[0] : null) { if (parent is IParameteredDeclaredType) { if (((IParameteredDeclaredType)parent).TypeParameters == null) { continue; } foreach (ITypeParameterMember itpm in ((IParameteredDeclaredType)parent).TypeParameters.Values) { if (skip++ >= resultSet.Count) { resultSet.Add(itpm); } } } } return(resultSet); }
public string WriteResources() { IDeclarationTarget idt = null; if (this.IsPartial) { return(null); } for (idt = this; idt != null && (!(idt is INameSpaceDeclaration)); idt = idt.ParentTarget) { ; } if ((idt == null) || (!(idt is INameSpaceDeclaration))) { throw new InvalidOperationException("Object in an invalid state."); } INameSpaceDeclaration insd = (INameSpaceDeclaration)idt; TemporaryFile tf; if (this == this.Project.Resources) { tf = TemporaryFileHelper.GetTemporaryDirectory("", true).Files.GetTemporaryFile(string.Format("Resources.resources", insd.FullName, this.Name)); } else { tf = TemporaryFileHelper.GetTemporaryDirectory("", true).Files.GetTemporaryFile(string.Format("{0}.{1}.resources", insd.FullName, this.Name)); } tf.OpenStream(FileMode.Create); ResourceWriter rw = new ResourceWriter(tf.FileStream); foreach (IDeclarationResourcesStringTableEntry idrste in this.StringTable.Values) { rw.AddResource(idrste.Name, idrste.Value); } rw.Close(); tf.CloseStream(); return(tf.FileName); }
internal static bool DeclarationIsVBModule(IDeclarationTarget declaration, IIntermediateCodeTranslatorOptions options) { if (!(declaration is IClassType)) { return(false); } IClassType @class = (IClassType)declaration; if (@class.TypeParameters == null || @class.TypeParameters.Count == 0) { if (@class.ParentTarget is INameSpaceDeclaration && @class.IsStatic) { if (options.AllowPartials) { //Basically if all other partials have no members, //Then it means that it is still a module. foreach (IClassType ict in @class.GetRootDeclaration().Partials) { if (ict == @class) { continue; } else if (ict.GetMemberCount(false) > 0 || ict.GetTypeCount(false) > 0) { return(false); } } if (@class != @class.GetRootDeclaration() && @class.GetRootDeclaration().GetMemberCount(false) > 0) { return(false); } } return(true); } } return(false); }
TItem ISegmentableDeclarationTargetPartials <TItem> .AddNew(IDeclarationTarget parentTarget) { return(this.AddNew((ITypeParent)parentTarget)); }
public static string BuildMemberReferenceComment(ICodeTranslationOptions options, IMember member) { if (options == null) { throw new ArgumentNullException("options"); } string parentCref = ((IType)member.ParentTarget).GetTypeName(options, true); //If there is a build trail to go by, check to see what kind of scope //is available. If the parent of the field is available, then referencing //field should be easier. if (options.BuildTrail != null) { IDeclarationTarget idt = member.ParentTarget; while (idt != null && !(idt is INameSpaceDeclaration)) { idt = idt.ParentTarget; } INameSpaceDeclaration currentNameSpace = null; bool importsContainsNameSpace = false; if (idt != null && options.ImportList != null) { importsContainsNameSpace = options.ImportList.Contains(((INameSpaceDeclaration)(idt)).FullName); } if (!importsContainsNameSpace) { for (int i = 0; i < options.BuildTrail.Count; i++) { if (Special.GetThisAt(options.BuildTrail, i) is INameSpaceDeclaration) { currentNameSpace = (INameSpaceDeclaration)Special.GetThisAt(options.BuildTrail, i); } else { break; } } } if (currentNameSpace != null && idt != null && (currentNameSpace.FullName == ((INameSpaceDeclaration)idt).FullName || currentNameSpace.FullName.Contains(((INameSpaceDeclaration)idt).FullName + "."))) { /* * * The build trail's current namespace contains the full name of the * parent namespace. * */ parentCref = parentCref.Substring(currentNameSpace.FullName.Length + 1); } else if (importsContainsNameSpace) { /* * * The import list contains the namespace * */ parentCref = parentCref.Substring(((INameSpaceDeclaration)idt).FullName.Length + 1); } else { goto _verbose; } } return(string.Format(_CommentConstants.SeeCrefTag, string.Format("{0}.{1}", parentCref, member.Name))); _verbose: return(string.Format(_CommentConstants.SeeCrefTag, string.Format("{0}.{1}", parentCref, member.Name))); }
ISegmentableDeclarationTarget ISegmentableDeclarationTargetPartials.AddNew(IDeclarationTarget parentTarget) { return(this.AddNew((INameSpaceParent)parentTarget)); }
/// <summary> /// Creates a new <see cref="BlockedStatement{TDom}"/> with the <paramref name="sourceBlock"/> /// provided. /// </summary> /// <param name="sourceBlock">The target point which the <see cref="BlockedStatement{TDom}"/> is /// created in.</param> protected BlockedStatement(IStatementBlock sourceBlock) : base(sourceBlock) { this.parentTarget = sourceBlock; }