public static object GetDefaultValue(SvgElement element, string attributename) { string text1; DomType type1 = DomTypeFunc.GetTypeOfAttributeName(attributename); if ((text1 = attributename) != null) { text1 = string.IsInterned(text1); if (((text1 == "fill-opacity") || (text1 == "opacity")) || (((text1 == "stroke-opacity") || (text1 == "stroke-width")) || (text1 == "stop-opacity"))) { return(1f); } } switch (type1) { case DomType.SvgNumber: { return(0f); } case DomType.SvgString: { return(string.Empty); } case DomType.SvgColor: { return(string.Empty); } } return(string.Empty); }
/// <summary> /// Create an IMember from a LanguageItem, /// using the source document to locate declaration bounds. /// </summary> /// <param name="pi"> /// A <see cref="ProjectInformation"/> for the current project. /// </param> /// <param name="item"> /// A <see cref="LanguageItem"/>: The item to convert. /// </param> /// <param name="contentLines"> /// A <see cref="System.String[]"/>: The document in which item is defined. /// </param> static IMember LanguageItemToIMember(ProjectInformation pi, LanguageItem item, string[] contentLines) { if (item is Class || item is Structure) { DomType klass = new DomType(new CompilationUnit(item.File), ClassType.Class, item.Name, new DomLocation((int)item.Line, 1), string.Empty, new DomRegion((int)item.Line + 1, FindFunctionEnd(contentLines, (int)item.Line - 1) + 2), new List <IMember> ()); foreach (LanguageItem li in pi.AllItems()) { if (klass.Equals(li.Parent) && FilePath.Equals(li.File, item.File)) { klass.Add(LanguageItemToIMember(pi, li, contentLines)); } } return(klass); } if (item is Enumeration) { return(new DomType(new CompilationUnit(item.File), ClassType.Enum, item.Name, new DomLocation((int)item.Line, 1), string.Empty, new DomRegion((int)item.Line + 1, (int)item.Line + 1), new List <IMember> ())); } if (item is Function) { return(new DomMethod(item.Name, Modifiers.None, MethodModifier.None, new DomLocation((int)item.Line, 1), new DomRegion((int)item.Line + 1, FindFunctionEnd(contentLines, (int)item.Line - 1) + 2), new DomReturnType())); } if (item is Member) { return(new DomField(item.Name, Modifiers.None, new DomLocation((int)item.Line, 1), new DomReturnType())); } return(null); }
internal static int ResolveTypes(ProjectDom db, ICompilationUnit unit, IList <IType> types, out List <IType> result) { TypeResolverVisitor tr = new TypeResolverVisitor(db, unit); int unresolvedCount = 0; result = new List <IType> (); foreach (IType c in types) { tr.UnresolvedCount = 0; DomType rc = (DomType)c.AcceptVisitor(tr, null); rc.Resolved = true; if (tr.UnresolvedCount == 0 && c.FullName != "System.Object") { // If the class has no base classes, make sure it subclasses System.Object if (rc.BaseType == null) { rc.BaseType = new DomReturnType("System.Object"); } } result.Add(rc); unresolvedCount += tr.UnresolvedCount; } return(unresolvedCount); }
IEnumerable <IType> BuildClasses(IEnumerable <PythonClass> classes) { foreach (PythonClass pyClass in classes) { var domType = new DomType() { Name = pyClass.Name, Documentation = pyClass.Documentation, ClassType = ClassType.Class, BodyRegion = pyClass.Region, Location = new DomLocation(pyClass.Region.Start.Line - 1, 0), }; m_AllWrapped.Add(domType); // class functions foreach (IMethod method in BuildFunctions(pyClass.Functions)) { domType.Add(method); } // class attributes foreach (IField field in BuildAttributes(pyClass.Attributes)) { domType.Add(field); } yield return(domType); } }
public IType GetArrayType(IReturnType elementType, MonoDevelop.Projects.Dom.Output.Ambience ambience) { // Create a fake class which sublcasses System.Array and implements IList<T> DomType t = new DomType(ambience.GetString(elementType, MonoDevelop.Projects.Dom.Output.OutputFlags.UseFullName) + "[]"); // set the compilation unit of the array type to that of the element type - it's required for jumping to the declaration of the type. IType eType = GetType(elementType); if (eType != null) { t.CompilationUnit = eType.CompilationUnit; } t.Resolved = true; t.BaseType = new DomReturnType("System.Array"); t.ClassType = ClassType.Class; t.Modifiers = Modifiers.Public; t.SourceProjectDom = this; DomProperty indexer = new DomProperty(); indexer.Name = "Item"; indexer.SetterModifier = indexer.GetterModifier = Modifiers.Public; indexer.PropertyModifier |= PropertyModifier.IsIndexer; indexer.Add(new DomParameter(indexer, "index", DomReturnType.Int32)); indexer.ReturnType = elementType; t.Add(indexer); DomReturnType listType = new DomReturnType("System.Collections.Generic.IList", false, new IReturnType [] { elementType }); t.AddInterfaceImplementation(listType); return(t); }
public void TestDomReadWriteResourceCreateWithPersonResource() { // Arrange var serviceModel = ClrSampleData.ServiceModelWithBlogResourceTypes; var personResourceType = serviceModel.GetResourceType <Person>(); var personResourceIdentity = personResourceType.ResourceIdentityInfo; var personFirstNameAttribute = personResourceType.GetClrAttributeInfo(StaticReflection.GetMemberName <Person>(x => x.FirstName)); var personLastNameAttribute = personResourceType.GetClrAttributeInfo(StaticReflection.GetMemberName <Person>(x => x.LastName)); var personTwitterAttribute = personResourceType.GetClrAttributeInfo(StaticReflection.GetMemberName <Person>(x => x.Twitter)); var expected = ApiSampleData.PersonResource; // Act var actual = DomReadWriteResource.Create( DomType.CreateFromResourceType(personResourceType), DomId.CreateFromApiResourceIdentity(personResourceType, expected), DomAttributes.Create( DomAttribute.CreateFromApiResource(personFirstNameAttribute, expected), DomAttribute.CreateFromApiResource(personLastNameAttribute, expected), DomAttribute.CreateFromApiResource(personTwitterAttribute, expected)), DomReadWriteRelationships.Create( DomReadWriteRelationship.Create(ApiSampleData.PersonToCommentsRel, DomReadWriteLinks.Create( DomReadWriteLink.Create(Keywords.Self, DomHRef.Create(ApiSampleData.PersonToRelationshipsToCommentsHRef)), DomReadWriteLink.Create(Keywords.Related, DomHRef.Create(ApiSampleData.PersonToCommentsHRef))))), DomReadWriteLinks.Create( DomReadWriteLink.Create(Keywords.Self, DomHRef.Create(ApiSampleData.PersonHRef))), DomReadOnlyMeta.Create(ApiSampleData.ResourceMeta)); this.OutputDomTree(actual); // Assert DomReadWriteResourceAssert.Equal(expected, actual); }
// PRIVATE METHODS ////////////////////////////////////////////////// #region Methods private void CreateAndAddDomReadWriteResourceIdentifierCollectionIfNeeded(int count) { Contract.Requires(count > 0); if (this.DomReadWriteResourceIdentifierCollection != null) { return; } var clrResourceType = typeof(TResource); var resourceType = this.ServiceModel.GetResourceType(clrResourceType); this.ResourceType = resourceType; var domContainerNode = this.DomContainerNode; var domReadWriteResourceIdentifierCollection = new List <DomReadWriteResourceIdentifier>(count); for (var i = 0; i < count; ++i) { var domResourceType = DomType.CreateFromResourceType(resourceType); var domReadWriteResourceIdentifier = DomReadWriteResourceIdentifier.Create(domResourceType); domContainerNode.Add(domReadWriteResourceIdentifier); domReadWriteResourceIdentifierCollection.Add(domReadWriteResourceIdentifier); } this.DomReadWriteResourceIdentifierCollection = domReadWriteResourceIdentifierCollection; }
public void TestDomReadWriteResourceCreateWithCommentResource() { // Arrange var serviceModel = ClrSampleData.ServiceModelWithBlogResourceTypes; var commentResourceType = serviceModel.GetResourceType <Comment>(); var commentResourceIdentity = commentResourceType.ResourceIdentityInfo; var commentBodyAttribute = commentResourceType.GetClrAttributeInfo(StaticReflection.GetMemberName <Comment>(x => x.Body)); var expected = ApiSampleData.CommentResource; // Act var actual = DomReadWriteResource.Create( DomType.CreateFromResourceType(commentResourceType), DomId.CreateFromApiResourceIdentity(commentResourceType, expected), DomAttributes.Create( DomAttribute.CreateFromApiResource(commentBodyAttribute, expected)), DomReadWriteRelationships.Create( DomReadWriteRelationship.Create(ApiSampleData.CommentToAuthorRel, DomReadWriteLinks.Create( DomReadWriteLink.Create(Keywords.Self, DomHRef.Create(ApiSampleData.CommentToRelationshipsToAuthorHRef)), DomReadWriteLink.Create(Keywords.Related, DomHRef.Create(ApiSampleData.CommentToAuthorHRef))))), DomReadWriteLinks.Create( DomReadWriteLink.Create(Keywords.Self, DomHRef.Create(ApiSampleData.CommentHRef))), DomReadOnlyMeta.Create(ApiSampleData.ResourceMeta)); this.OutputDomTree(actual); // Assert DomReadWriteResourceAssert.Equal(expected, actual); }
public void TestDomReadWriteResourceCreateWithBlogResource() { // Arrange var serviceModel = ClrSampleData.ServiceModelWithBlogResourceTypes; var blogResourceType = serviceModel.GetResourceType <Blog>(); var blogResourceIdentity = blogResourceType.ResourceIdentityInfo; var blogNameAttribute = blogResourceType.GetClrAttributeInfo(StaticReflection.GetMemberName <Blog>(x => x.Name)); var expectedBlog = ApiSampleData.BlogResource; // Act var actual = DomReadWriteResource.Create( DomType.CreateFromResourceType(blogResourceType), DomId.CreateFromApiResourceIdentity(blogResourceType, expectedBlog), DomAttributes.Create( DomAttribute.CreateFromApiResource(blogNameAttribute, expectedBlog)), DomReadWriteRelationships.Create( DomReadWriteRelationship.Create(ApiSampleData.BlogToArticlesRel, DomReadWriteLinks.Create( DomReadWriteLink.Create(Keywords.Self, DomHRef.Create(ApiSampleData.BlogToRelationshipsToArticlesHRef)), DomReadWriteLink.Create(Keywords.Related, DomHRef.Create(ApiSampleData.BlogToArticlesHRef))))), DomReadWriteLinks.Create( DomReadWriteLink.Create(Keywords.Self, DomHRef.Create(ApiSampleData.BlogHRef))), DomReadOnlyMeta.Create(ApiSampleData.ResourceMeta)); this.OutputDomTree(actual); // Assert DomReadWriteResourceAssert.Equal(expectedBlog, actual); }
public void ReadWriteTypeTestComplex() { DomType input = new DomType(); input.Name = "Test"; input.ClassType = ClassType.Struct; input.BaseType = new DomReturnType("BaseClass"); input.AddInterfaceImplementation(new DomReturnType("Interface1")); input.AddInterfaceImplementation(new DomReturnType("Interface2")); input.Add(new DomMethod("TestMethod", Modifiers.None, MethodModifier.None, DomLocation.Empty, DomRegion.Empty)); input.Add(new DomMethod(".ctor", Modifiers.None, MethodModifier.IsConstructor, DomLocation.Empty, DomRegion.Empty)); input.Add(new DomField("TestField", Modifiers.None, DomLocation.Empty, DomReturnType.Void)); input.Add(new DomProperty("TestProperty", Modifiers.None, DomLocation.Empty, DomRegion.Empty, DomReturnType.Void)); input.Add(new DomEvent("TestEvent", Modifiers.None, DomLocation.Empty, DomReturnType.Void)); MemoryStream ms = new MemoryStream(); BinaryWriter writer = new BinaryWriter(ms); DomPersistence.Write(writer, DefaultNameEncoder, input); byte[] bytes = ms.ToArray(); DomType result = DomPersistence.ReadType(CreateReader(bytes), DefaultNameDecoder, null); Assert.AreEqual("Test", result.Name); Assert.AreEqual(ClassType.Struct, result.ClassType); Assert.AreEqual("BaseClass", result.BaseType.Name); Assert.AreEqual(1, result.MethodCount); Assert.AreEqual(1, result.ConstructorCount); Assert.AreEqual(1, result.FieldCount); Assert.AreEqual(1, result.PropertyCount); Assert.AreEqual(1, result.EventCount); }
public void ExtensionMethodPreserveParameterTest() { // build "T MyMethod<T, S> (T a, S b)" DomMethod method = new DomMethod(); method.Name = "MyMethod"; method.ReturnType = new DomReturnType("T"); method.AddTypeParameter(new TypeParameter("T")); method.AddTypeParameter(new TypeParameter("S")); method.Add(new DomParameter(method, "a", new DomReturnType("T"))); method.Add(new DomParameter(method, "b", new DomReturnType("S"))); // extend method List <IReturnType> genArgs = new List <IReturnType> (); List <IReturnType> args = new List <IReturnType> (); DomType extType = new DomType("MyType"); ExtensionMethod extMethod = new ExtensionMethod(extType, method, genArgs, args); // check for MyType MyMethod<S> (S b) Assert.AreEqual("MyType", extMethod.ReturnType.FullName); Assert.AreEqual("S", extMethod.Parameters[0].ReturnType.FullName); Assert.AreEqual(1, extMethod.TypeParameters.Count); Assert.AreEqual("S", extMethod.TypeParameters[0].Name); }
public string GetComponentTypeOf(Func <string, string> callback, string varName) { if (callback == null) { return("var"); } string var = callback(varName); ITextEditorResolver textEditorResolver = CurrentContext.Document.GetContent <ITextEditorResolver> (); if (textEditorResolver != null) { ResolveResult result = textEditorResolver.GetLanguageItem(CurrentContext.Document.TextEditor.CursorPosition, var); if (result != null) { IReturnType componentType = DomType.GetComponentType(CurrentContext.ProjectDom, result.ResolvedType); if (componentType != null) { Ambience ambience = AmbienceService.GetAmbience(CurrentContext.Template.MimeType); return(ambience != null?ambience.GetString(componentType, OutputFlags.IncludeGenerics) : componentType.ToInvariantString()); } } } return("var"); }
public virtual IEnumerable <IType> GetInheritanceTree(IType type) { if (type == null) { throw new ArgumentNullException("type"); } type = ResolveType(type); if (type == null) { yield break; } HashSet <string> alreadyTaken = new HashSet <string> (); Stack <IType> types = new Stack <IType> (); types.Push(type); while (types.Count > 0) { IType cur = types.Pop(); if (cur == null) { continue; } string fullName = DomType.GetNetFullName(cur); if (!alreadyTaken.Add(fullName)) { continue; } yield return(cur); foreach (IReturnType baseType in cur.BaseTypes) { // There is no need to resolve baseType here, since 'cur' is an already resolved // type, so all types it references are already resolved too IType resolvedType = GetType(baseType); if (resolvedType != null) { types.Push(resolvedType); } } if (cur.BaseType == null && cur.FullName != "System.Object") { if (cur.ClassType == ClassType.Enum) { types.Push(this.GetType(DomReturnType.Enum)); } else if (cur.ClassType == ClassType.Struct) { types.Push(this.GetType(DomReturnType.ValueType)); } else { types.Push(this.GetType(DomReturnType.Object)); } } } }
public static List <string> GetResolveableNamespaces(RefactoringOptions options, out bool resolveDirect) { IReturnType returnType = null; INRefactoryASTProvider astProvider = RefactoringService.GetASTProvider(DesktopService.GetMimeTypeForUri(options.Document.FileName)); if (options.ResolveResult != null && options.ResolveResult.ResolvedExpression != null) { if (astProvider != null) { returnType = astProvider.ParseTypeReference(options.ResolveResult.ResolvedExpression.Expression).ConvertToReturnType(); } if (returnType == null) { returnType = DomReturnType.GetSharedReturnType(options.ResolveResult.ResolvedExpression.Expression); } } List <string> namespaces; if (options.ResolveResult is UnresolvedMemberResolveResult) { namespaces = new List <string> (); UnresolvedMemberResolveResult unresolvedMemberResolveResult = options.ResolveResult as UnresolvedMemberResolveResult; IType type = unresolvedMemberResolveResult.TargetResolveResult != null?options.Dom.GetType(unresolvedMemberResolveResult.TargetResolveResult.ResolvedType) : null; if (type != null) { List <IType> allExtTypes = DomType.GetAccessibleExtensionTypes(options.Dom, null); foreach (ExtensionMethod method in type.GetExtensionMethods(allExtTypes, unresolvedMemberResolveResult.MemberName)) { string ns = method.OriginalMethod.DeclaringType.Namespace; if (!namespaces.Contains(ns) && !options.Document.CompilationUnit.Usings.Any(u => u.Namespaces.Contains(ns))) { namespaces.Add(ns); } } } resolveDirect = false; } else { namespaces = new List <string> (options.Dom.ResolvePossibleNamespaces(returnType)); resolveDirect = true; } for (int i = 0; i < namespaces.Count; i++) { for (int j = i + 1; j < namespaces.Count; j++) { if (namespaces[j] == namespaces[i]) { namespaces.RemoveAt(j); j--; } } } return(namespaces); }
void AddContentsFromClassAndMembers(ExpressionContext context, CSharpTextEditorCompletion.CompletionDataCollector col) { IMethod method = callingMember as IMethod; if (method != null && method.Parameters != null) { AddParameterList(col, method.Parameters); } IProperty property = callingMember as IProperty; if (property != null && property.Parameters != null) { AddParameterList(col, property.Parameters); } if (CallingType == null) { return; } AddContentsFromOuterClass(CallingType, context, col); IType callingType = CallingType is InstantiatedType ? ((InstantiatedType)CallingType).UninstantiatedType : CallingType; //bool isInStatic = CallingMember != null ? CallingMember.IsStatic : false; if (CallingMember == null || !CallingMember.IsStatic) { foreach (TypeParameter parameter in callingType.TypeParameters) { col.Add(parameter.Name, "md-literal"); } } if (context != ExpressionContext.TypeDeclaration && CallingMember != null) { bool includeProtected = DomType.IncludeProtected(dom, CallingType, CallingMember.DeclaringType); foreach (IType type in dom.GetInheritanceTree(CallingType)) { foreach (IMember member in type.Members) { if (!(member is IType) && CallingMember.IsStatic && !(member.IsStatic || member.IsConst)) { continue; } if (member.IsAccessibleFrom(dom, CallingType, CallingMember, includeProtected)) { if (context.FilterEntry(member)) { continue; } col.Add(member); } } } } }
public virtual object GetAnimateResult(float time, DomType domtype) { if (time < this.Begin) { return(string.Empty); } object obj1 = this.FFT(time, domtype); this.pretime = (int)time; return(obj1); }
public override object VisitEventDeclaration(ICSharpCode.OldNRefactory.Ast.EventDeclaration eventDeclaration, object data) { Debug.Assert(currentType.Count > 0); DomType type = currentType.Peek(); type.Add(new DomEvent(eventDeclaration.Name, (Modifiers)eventDeclaration.Modifier, new DomLocation(eventDeclaration.StartLocation.Line, eventDeclaration.StartLocation.Column), TranslateTypeReference(eventDeclaration.TypeReference))); return(null); }
// used for constructor completion public NRefactoryParameterDataProvider(MonoDevelop.Ide.Gui.TextEditor editor, NRefactoryResolver resolver, IType type) { this.editor = editor; if (type != null) { if (type.ClassType == ClassType.Delegate) { IMethod invokeMethod = ExtractInvokeMethod(type); if (type is InstantiatedType) { this.delegateName = ((InstantiatedType)type).UninstantiatedType.Name; } else { this.delegateName = type.Name; } if (invokeMethod != null) { methods.Add(invokeMethod); } else { // no invoke method -> tried to create an abstract delegate } return; } bool includeProtected = DomType.IncludeProtected(resolver.Dom, type, resolver.CallingType); bool constructorFound = false; HashSet <string> alreadyAdded = new HashSet <string> (); foreach (IMethod method in type.Methods) { constructorFound |= method.IsConstructor; string str = ambience.GetString(method, OutputFlags.IncludeParameters); if (alreadyAdded.Contains(str)) { continue; } alreadyAdded.Add(str); if ((method.IsConstructor && method.IsAccessibleFrom(resolver.Dom, type, resolver.CallingMember, includeProtected))) { methods.Add(method); } } // No constructor - generating default if (!constructorFound && (type.TypeModifier & TypeModifier.HasOnlyHiddenConstructors) != TypeModifier.HasOnlyHiddenConstructors) { DomMethod defaultConstructor = new DomMethod(); defaultConstructor.MethodModifier = MethodModifier.IsConstructor; defaultConstructor.DeclaringType = type; methods.Add(defaultConstructor); } } }
private object FFT(float time, DomType domtype) { if (time <= (this.Begin + this.RealDur)) { return(this.FCumT(time, domtype)); } if (this.GetAttribute("fill").Trim() == "freeze") { return(this.FCumT(this.Begin + this.RealDur, domtype)); } return(null); }
public override object VisitConstructorDeclaration(ICSharpCode.OldNRefactory.Ast.ConstructorDeclaration constructorDeclaration, object data) { Debug.Assert(currentType.Count > 0); DomType type = currentType.Peek(); type.Add(new DomMethod(constructorDeclaration.Name, (Modifiers)constructorDeclaration.Modifier, MethodModifier.IsConstructor, new DomLocation(constructorDeclaration.StartLocation.Line, constructorDeclaration.StartLocation.Column), constructorDeclaration.Body != null ? TranslateRegion(constructorDeclaration.Body.StartLocation, constructorDeclaration.Body.EndLocation) : DomRegion.Empty)); return(null); }
public override object VisitPropertyDeclaration(ICSharpCode.NRefactory.Ast.PropertyDeclaration propertyDeclaration, object data) { Debug.Assert(currentType.Count > 0); DomType type = currentType.Peek(); type.Add(new DomProperty(propertyDeclaration.Name, (MonoDevelop.Projects.Dom.Modifiers)propertyDeclaration.Modifier, new DomLocation(propertyDeclaration.StartLocation.Line, propertyDeclaration.StartLocation.Column), TranslateRegion(propertyDeclaration.BodyStart, propertyDeclaration.BodyEnd), TranslateTypeReference(propertyDeclaration.TypeReference))); return(null); }
public override object VisitMethodDeclaration(ICSharpCode.NRefactory.Ast.MethodDeclaration methodDeclaration, object data) { Debug.Assert(currentType.Count > 0); DomType type = currentType.Peek(); type.Add(new DomMethod(methodDeclaration.Name, (MonoDevelop.Projects.Dom.Modifiers)methodDeclaration.Modifier, false, // isConstructor new DomLocation(methodDeclaration.StartLocation.Line, methodDeclaration.StartLocation.Column), methodDeclaration.Body != null ? TranslateRegion(methodDeclaration.Body.StartLocation, methodDeclaration.Body.EndLocation) : DomRegion.Empty)); return(null); }
public void TestDomReadWriteResourceCreateWithArticleResourceWithResourceLinkage() { // Arrange var serviceModel = ClrSampleData.ServiceModelWithBlogResourceTypes; var articleResourceType = serviceModel.GetResourceType <Article>(); var articleTitleAttribute = articleResourceType.GetClrAttributeInfo(StaticReflection.GetMemberName <Article>(x => x.Title)); var commentResourceType = serviceModel.GetResourceType <Comment>(); var personResourceType = serviceModel.GetResourceType <Person>(); var expectedArticle = ApiSampleData.ArticleResourceWithResourceLinkage; var expectedAuthor = ApiSampleData.PersonResource; var expectedComment1 = ApiSampleData.CommentResource1; var expectedComment2 = ApiSampleData.CommentResource2; // Act var actual = DomReadWriteResource.Create( DomType.CreateFromResourceType(articleResourceType), DomId.CreateFromApiResourceIdentity(articleResourceType, expectedArticle), DomAttributes.Create( DomAttribute.CreateFromApiResource(articleTitleAttribute, expectedArticle)), DomReadWriteRelationships.Create( DomReadWriteRelationship.Create(ApiSampleData.ArticleToAuthorRel, DomReadWriteLinks.Create( DomReadWriteLink.Create(Keywords.Self, DomHRef.Create(ApiSampleData.ArticleToRelationshipsToAuthorHRef)), DomReadWriteLink.Create(Keywords.Related, DomHRef.Create(ApiSampleData.ArticleToAuthorHRef))), DomData.CreateFromResourceIdentifier( DomReadWriteResourceIdentifier.Create( DomType.CreateFromResourceType(personResourceType), DomId.CreateFromApiResourceIdentity(personResourceType, expectedAuthor)))), DomReadWriteRelationship.Create(ApiSampleData.ArticleToCommentsRel, DomReadWriteLinks.Create( DomReadWriteLink.Create(Keywords.Self, DomHRef.Create(ApiSampleData.ArticleToRelationshipsToCommentsHRef)), DomReadWriteLink.Create(Keywords.Related, DomHRef.Create(ApiSampleData.ArticleToCommentsHRef))), DomDataCollection.CreateFromResourceIdentifiers( DomReadWriteResourceIdentifier.Create( DomType.CreateFromResourceType(commentResourceType), DomId.CreateFromApiResourceIdentity(commentResourceType, expectedComment1)), DomReadWriteResourceIdentifier.Create( DomType.CreateFromResourceType(commentResourceType), DomId.CreateFromApiResourceIdentity(commentResourceType, expectedComment2))))), DomReadWriteLinks.Create( DomReadWriteLink.Create(Keywords.Canonical, DomHRef.Create(ApiSampleData.ArticleHRef)), DomReadWriteLink.Create(Keywords.Self, DomHRef.Create(ApiSampleData.ArticleHRef))), DomReadOnlyMeta.Create(ApiSampleData.ResourceMeta)); this.OutputDomTree(actual); // Assert DomReadWriteResourceAssert.Equal(expectedArticle, actual); }
// PUBLIC METHODS /////////////////////////////////////////////////// #region Assert Methods public static void Equal(string expected, DomType actual) { if (String.IsNullOrWhiteSpace(expected)) { Assert.Null(actual); return; } Assert.NotNull(actual); var actualApiType = actual.ApiType; Assert.Equal(expected, actualApiType); }
/// <summary> /// Create an IMember from a LanguageItem, /// using the source document to locate declaration bounds. /// </summary> /// <param name="pi"> /// A <see cref="ProjectInformation"/> for the current project. /// </param> /// <param name="item"> /// A <see cref="LanguageItem"/>: The item to convert. /// </param> /// <param name="contentLines"> /// A <see cref="System.String[]"/>: The document in which item is defined. /// </param> static IMember LanguageItemToIMember(ProjectInformation pi, LanguageItem item, string[] contentLines) { if (item is Class || item is Structure) { DomType klass = new DomType(new CompilationUnit(item.File), ClassType.Class, item.Name, new DomLocation((int)item.Line, 1), string.Empty, new DomRegion((int)item.Line + 1, FindFunctionEnd(contentLines, (int)item.Line - 1) + 2), new List <IMember> ()); foreach (LanguageItem li in pi.AllItems()) { if (klass.Equals(li.Parent) && FilePath.Equals(li.File, item.File)) { klass.Add(LanguageItemToIMember(pi, li, contentLines)); } } return(klass); } if (item is Enumeration) { return(new DomType(new CompilationUnit(item.File), ClassType.Enum, item.Name, new DomLocation((int)item.Line, 1), string.Empty, new DomRegion((int)item.Line + 1, (int)item.Line + 1), new List <IMember> ())); } if (item is Function) { DomMethod method = new DomMethod(item.Name, Modifiers.None, MethodModifier.None, new DomLocation((int)item.Line, 1), new DomRegion((int)item.Line + 1, FindFunctionEnd(contentLines, (int)item.Line - 1) + 2), new DomReturnType()); Function function = (Function)item; Match match; bool abort = false; List <IParameter> parameters = new List <IParameter> (); foreach (string parameter in function.Parameters) { match = paramExpression.Match(parameter); if (null == match) { abort = true; break; } DomParameter p = (new DomParameter(method, match.Groups["name"].Value, new DomReturnType(string.Format("{0}{1}{2}", match.Groups["type"].Value, match.Groups["subtype"].Value, match.Groups["array"].Value)))); parameters.Add(p); } if (!abort) { method.Add(parameters); } return(method); } if (item is Member) { return(new DomField(item.Name, Modifiers.None, new DomLocation((int)item.Line, 1), new DomReturnType())); } return(null); }
public override object VisitFieldDeclaration(ICSharpCode.OldNRefactory.Ast.FieldDeclaration fieldDeclaration, object data) { Debug.Assert(currentType.Count > 0); DomType type = currentType.Peek(); foreach (ICSharpCode.OldNRefactory.Ast.VariableDeclaration field in fieldDeclaration.Fields) { type.Add(new DomField(field.Name, (Modifiers)fieldDeclaration.Modifier, new DomLocation(fieldDeclaration.StartLocation.Line, fieldDeclaration.StartLocation.Column), TranslateTypeReference(fieldDeclaration.TypeReference))); } return(null); }
bool HasAnyOverloadWithParameters(IMethod method) { var type = method.DeclaringType; List <IType> accessibleExtTypes = DomType.GetAccessibleExtensionTypes(editorCompletion.Dom, editorCompletion.GetDocument().CompilationUnit); foreach (var t in type.SourceProjectDom.GetInheritanceTree(type)) { if (t.Methods.Concat(t.GetExtensionMethods(accessibleExtTypes, method.Name)).Any(m => m.Parameters.Count > 0)) { return(true); } } return(false); }
} // CanParse public override ParsedDocument Parse(ProjectDom dom, string fileName, string content) { ParsedDocument doc = new ParsedDocument(fileName); doc.Flags |= ParsedDocumentFlags.NonSerializable; Project p = (null == dom || null == dom.Project)? IdeApp.Workspace.GetProjectContainingFile(fileName): dom.Project; ProjectInformation pi = ProjectInformationManager.Instance.Get(p); CompilationUnit cu; doc.CompilationUnit = cu = new CompilationUnit(fileName); IType tmp; IMember member; string[] contentLines = content.Split(new string[] { Environment.NewLine }, StringSplitOptions.None); DomType globals = new DomType(cu, ClassType.Unknown, GettextCatalog.GetString("(Global Scope)"), new DomLocation(1, 1), string.Empty, new DomRegion(1, int.MaxValue), new List <IMember> ()); lock (pi) { // Add containers to type list foreach (LanguageItem li in pi.Containers()) { if (null == li.Parent && FilePath.Equals(li.File, fileName)) { tmp = LanguageItemToIMember(pi, li, contentLines) as IType; if (null != tmp) { cu.Add(tmp); } } } // Add global category for unscoped symbols foreach (LanguageItem li in pi.InstanceMembers()) { if (null == li.Parent && FilePath.Equals(li.File, fileName)) { member = LanguageItemToIMember(pi, li, contentLines); if (null != member) { globals.Add(member); } } } } cu.Add(globals); return(doc); }
public void ReadWriteDelegateTest() { DomType input = DomType.CreateDelegate(null, "TestDelegate", new DomLocation(10, 10), DomReturnType.Void, new List <IParameter> ()); MemoryStream ms = new MemoryStream(); BinaryWriter writer = new BinaryWriter(ms); DomPersistence.Write(writer, DefaultNameEncoder, input); byte[] bytes = ms.ToArray(); DomType result = DomPersistence.ReadType(CreateReader(bytes), DefaultNameDecoder, null); Assert.AreEqual("TestDelegate", result.Name); Assert.AreEqual(ClassType.Delegate, result.ClassType); }
// PRIVATE METHODS ////////////////////////////////////////////////// #region Methods private void CreateAndAddDomReadWriteResourceIdentifierIfNeeded() { if (this.DomReadWriteResourceIdentifier != null) { return; } var domResourceType = DomType.CreateFromResourceType(this.ResourceType); var domReadWriteResourceIdentifier = DomReadWriteResourceIdentifier.Create(domResourceType); var domContainerNode = this.DomContainerNode; domContainerNode.Add(domReadWriteResourceIdentifier); this.DomReadWriteResourceIdentifier = domReadWriteResourceIdentifier; }
void TestCreateInterface (string interfacecode, string outputString) { var dom = new SimpleProjectDom (); var parser = new McsParser (); var unit = parser.Parse (dom, "Interface.cs", interfacecode); DomType stubType = new DomType ("Stub"); stubType.SourceProjectDom = dom; stubType.CompilationUnit = new CompilationUnit ("Stub.cs"); var iface = unit.CompilationUnit.Types[0]; var gen = new CSharpCodeGenerator (); gen.EolMarker = "\n"; string generated = gen.CreateInterfaceImplementation (stubType, iface, false); // crop #region generated = generated.Substring (generated.IndexOf ("implementation") + "implementation".Length); generated = generated.Substring (0, generated.LastIndexOf ("#")); generated = generated.Trim (); System.Console.WriteLine (generated); Assert.AreEqual (outputString, generated); }
public override object FT(float time, DomType domtype) { if (time < base.Begin) { return null; } if ((time < base.Begin) || (time > (base.Begin + base.Duration))) { return null; } string text1 = base.ToWhat; switch (domtype) { case DomType.SvgMatrix: { return new Transf(this.Type + "(" + text1.Trim() + ")").Matrix; } case DomType.SvgNumber: { return ItopVector.Core.Func.Number.parseToFloat(text1.Trim(), (SvgElement) this.ParentNode, ItopVector.Core.Func.SvgLengthDirection.Horizontal); } case DomType.SvgString: { return text1.Trim(); } case DomType.SvgColor: { return text1.Trim(); } case DomType.SvgPath: { return PathFunc.PathDataParse(text1); } case DomType.SvgPoints: { return PointsFunc.PointsParse(text1); } } return base.ToWhat; }
public override ParsedDocument Parse (ProjectDom dom, string fileName, string content) { ParsedDocument doc = new ParsedDocument (fileName); doc.Flags |= ParsedDocumentFlags.NonSerializable; Project p = (null == dom || null == dom.Project)? IdeApp.Workspace.GetProjectContainingFile (fileName): dom.Project; ProjectInformation pi = ProjectInformationManager.Instance.Get (p); CompilationUnit cu; doc.CompilationUnit = cu = new CompilationUnit (fileName); IType tmp; IMember member; string[] contentLines = content.Split (new string[]{Environment.NewLine}, StringSplitOptions.None); DomType globals = new DomType (cu, ClassType.Unknown, GettextCatalog.GetString ("(Global Scope)"), new DomLocation (1, 1), string.Empty, new DomRegion (1, int.MaxValue), new List<IMember> ()); lock (pi) { // Add containers to type list foreach (LanguageItem li in pi.Containers ()) { if (null == li.Parent && FilePath.Equals (li.File, fileName)) { tmp = LanguageItemToIMember (pi, li, contentLines) as IType; if (null != tmp){ cu.Add (tmp); } } } // Add global category for unscoped symbols foreach (LanguageItem li in pi.InstanceMembers ()) { if (null == li.Parent && FilePath.Equals (li.File, fileName)) { member = LanguageItemToIMember (pi, li, contentLines); if (null != member) { globals.Add (member); } } } } cu.Add (globals); return doc; }
static void GenerateCU (XmlParsedDocument doc) { if (doc.XDocument == null || doc.XDocument.RootElement == null) { doc.Add (new Error (ErrorType.Error, 1, 1, "No root node found.")); return; } XAttribute rootClass = doc.XDocument.RootElement.Attributes [new XName ("x", "Class")]; if (rootClass == null) { doc.Add (new Error (ErrorType.Error, 1, 1, "Root node does not contain an x:Class attribute.")); return; } bool isApplication = doc.XDocument.RootElement.Name.Name == "Application"; string rootNamespace, rootType, rootAssembly; XamlG.ParseXmlns (rootClass.Value, out rootType, out rootNamespace, out rootAssembly); CompilationUnit cu = new CompilationUnit (doc.FileName); doc.CompilationUnit = cu; DomRegion rootRegion = doc.XDocument.RootElement.Region; if (doc.XDocument.RootElement.IsClosed) rootRegion.End = doc.XDocument.RootElement.ClosingTag.Region.End; DomType declType = new DomType (cu, ClassType.Class, Modifiers.Partial | Modifiers.Public, rootType, doc.XDocument.RootElement.Region.Start, rootNamespace, rootRegion); cu.Add (declType); DomMethod initcomp = new DomMethod (); initcomp.Name = "InitializeComponent"; initcomp.Modifiers = Modifiers.Public; initcomp.ReturnType = DomReturnType.Void; declType.Add (initcomp); DomField _contentLoaded = new DomField ("_contentLoaded"); _contentLoaded.ReturnType = new DomReturnType ("System.Boolean"); if (isApplication) return; cu.Add (new DomUsing (DomRegion.Empty, "System")); cu.Add (new DomUsing (DomRegion.Empty, "System.Windows")); cu.Add (new DomUsing (DomRegion.Empty, "System.Windows.Controls")); cu.Add (new DomUsing (DomRegion.Empty, "System.Windows.Documents")); cu.Add (new DomUsing (DomRegion.Empty, "System.Windows.Input")); cu.Add (new DomUsing (DomRegion.Empty, "System.Windows.Media")); cu.Add (new DomUsing (DomRegion.Empty, "System.Windows.Media.Animation")); cu.Add (new DomUsing (DomRegion.Empty, "System.Windows.Shapes")); cu.Add (new DomUsing (DomRegion.Empty, "System.Windows.Controls.Primitives")); // Dictionary<string,string> namespaceMap = new Dictionary<string, string> (); // namespaceMap["x"] = "http://schemas.microsoft.com/winfx/2006/xaml"; XName nameAtt = new XName ("x", "Name"); foreach (XElement el in doc.XDocument.RootElement.AllDescendentElements) { XAttribute name = el.Attributes [nameAtt]; if (name != null && name.IsComplete) { string type = ResolveType (el); if (type == null || type.Length == 0) doc.Add (new Error (ErrorType.Error, el.Region.Start, "Could not find namespace for '" + el.Name.FullName + "'.")); else declType.Add (new DomField (name.Value, Modifiers.Internal, el.Region.Start, new DomReturnType (type))); } } }
private object FRT(float time, DomType domtype) { float single1 = this.Remainder(time, (float) this.Duration); return this.FT(single1, domtype); }
private object FFT(float time, DomType domtype) { if (time <= (this.Begin + this.RealDur)) { return this.FCumT(time, domtype); } if (this.GetAttribute("fill").Trim() == "freeze") { return this.FCumT(this.Begin + this.RealDur, domtype); } return null; }
public override ParsedDocument Parse (ProjectDom dom, string fileName, string content) { ParsedDocument doc = new ParsedDocument (fileName); if(null == doc.CompilationUnit) doc.CompilationUnit = new CompilationUnit (fileName); CompilationUnit cu = (CompilationUnit)doc.CompilationUnit; DomType currentFile = null; DomProperty currentRegion = null; string eol = Environment.NewLine; Match eolMatch = eolExpression.Match (content); if (eolMatch != null && eolMatch.Success) eol = eolMatch.Groups["eol"].Value; string[] lines = content.Split (new string[]{eol}, StringSplitOptions.None); int linenum = 1; Match lineMatch; foreach (string line in lines) { lineMatch = fileHeaderExpression.Match (line.Trim()); if (lineMatch != null && lineMatch.Success) { if (currentFile != null) // Close out previous file region currentFile.BodyRegion = new DomRegion (currentFile.BodyRegion.Start.Line, currentFile.BodyRegion.Start.Column, linenum-1, int.MaxValue); if (currentRegion != null) // Close out previous chunk region currentRegion.BodyRegion = new DomRegion (currentRegion.BodyRegion.Start.Line, currentRegion.BodyRegion.Start.Column, linenum-1, int.MaxValue); // Create new file region currentFile = new DomType (cu, ClassType.Unknown, Modifiers.None, lastToken (lineMatch.Groups["filepath"].Value), new DomLocation (linenum, 1), string.Empty, new DomRegion (linenum, line.Length+1, linenum, int.MaxValue)); cu.Add (currentFile); } else { lineMatch = chunkExpression.Match (line); if (lineMatch != null && lineMatch.Success) { if (currentRegion != null) // Close out previous chunk region currentRegion.BodyRegion = new DomRegion (currentRegion.BodyRegion.Start.Line, currentRegion.BodyRegion.Start.Column, linenum-1, int.MaxValue); // Create new chunk region currentRegion = new DomProperty (lineMatch.Groups["chunk"].Value, Modifiers.None, new DomLocation (linenum, 1), new DomRegion (linenum, line.Length+1, linenum, int.MaxValue), null); currentFile.Add (currentRegion); } } ++linenum; } // Close out trailing regions if (currentFile != null) currentFile.BodyRegion = new DomRegion (currentFile.BodyRegion.Start.Line, currentFile.BodyRegion.Start.Column, Math.Max (1, linenum-2), int.MaxValue); if (currentRegion != null) currentRegion.BodyRegion = new DomRegion (currentRegion.BodyRegion.Start.Line, currentRegion.BodyRegion.Start.Column, Math.Max (1, linenum-2), int.MaxValue); return doc; }
static DomType ReadTypeInternal (BinaryReader reader, INameDecoder nameTable, IDomObjectTable objectTable) { uint typeCount = ReadUInt (reader, 1000); if (typeCount > 1) { CompoundType compoundResult = new CompoundType (); while (typeCount-- > 0) { compoundResult.AddPart (ReadTypeInternal (reader, nameTable, objectTable)); } return compoundResult; } DomType result = new DomType (); ReadMemberInformation (reader, nameTable, objectTable, result); // bool verbose = result.Name == "CopyDelegate"; // if (verbose) System.Console.WriteLine("read type:" + result.Name); result.TypeModifier = (TypeModifier)reader.ReadUInt32 (); result.BodyRegion = ReadRegion (reader, nameTable); string compilationUnitFileName = ReadString (reader, nameTable); result.CompilationUnit = new CompilationUnit (compilationUnitFileName); result.Namespace = ReadString (reader, nameTable); result.ClassType = (ClassType)reader.ReadUInt32 (); result.BaseType = ReadReturnType (reader, nameTable, objectTable); // implemented interfaces long count = ReadUInt (reader, 5000); // if (verbose) System.Console.WriteLine("impl. interfaces:" + count); while (count-- > 0) { result.AddInterfaceImplementation (ReadReturnType (reader, nameTable, objectTable)); } // innerTypes // if (verbose) System.Console.WriteLine("pos:" + reader.BaseStream.Position); count = ReadUInt (reader, 10000); // if (verbose) System.Console.WriteLine("inner types:" + count); while (count-- > 0) { DomType innerType = ReadTypeInternal (reader, nameTable, objectTable); innerType.DeclaringType = result; result.Add (innerType); } // fields // if (verbose) System.Console.WriteLine("pos:" + reader.BaseStream.Position); count = ReadUInt (reader, 10000); // if (verbose) System.Console.WriteLine("fields:" + count); while (count-- > 0) { DomField field = ReadField (reader, nameTable, objectTable); field.DeclaringType = result; result.Add (field); } // methods // if (verbose) System.Console.WriteLine("pos:" + reader.BaseStream.Position); count = ReadUInt (reader, 10000); // if (verbose) System.Console.WriteLine("methods:" + count); while (count-- > 0) { DomMethod method = ReadMethod (reader, nameTable, objectTable); method.DeclaringType = result; result.Add (method); } // properties // if (verbose) System.Console.WriteLine("pos:" + reader.BaseStream.Position); count = ReadUInt (reader, 10000); // if (verbose) System.Console.WriteLine("properties:" + count); while (count-- > 0) { DomProperty property = ReadProperty (reader, nameTable, objectTable); property.DeclaringType = result; result.Add (property); } // events // if (verbose) System.Console.WriteLine("pos:" + reader.BaseStream.Position); count = ReadUInt (reader, 10000); // if (verbose) System.Console.WriteLine("events:" + count); while (count-- > 0) { DomEvent evt = ReadEvent (reader, nameTable, objectTable); evt.DeclaringType = result; result.Add (evt); } // type parameters count = ReadUInt (reader, 500); while (count-- > 0) { TypeParameter tp = ReadTypeParameter (reader, nameTable, objectTable); result.AddTypeParameter (tp); } return result; }
protected virtual void OnButtonOkClicked(object sender, System.EventArgs e) { if (String.IsNullOrEmpty (typeName.Text)) { typeName.GrabFocus (); return; } if (newFileName.Sensitive && String.IsNullOrEmpty (newFileName.Text)) { newFileName.GrabFocus (); return; } else if (existingFileName.Sensitive && String.IsNullOrEmpty (existingFileName.Text)) { existingFileName.GrabFocus (); return; } var item = new DomType (typeName.Text); item.ClassType = type; if (accessModifier.ActiveText == "public") item.Modifiers = Modifiers.Public; //if (isAbstract) // type.Modifiers &= Modifiers.Abstract; var figure = designer.Diagram.CreateTypeFigure (item); if (figure == null) { typeName.GrabFocus (); return; } figure.MoveTo (point.X, point.Y); designer.View.Add (figure); Destroy (); }
public void ReadWriteTypeTestComplex () { DomType input = new DomType (); input.Name = "Test"; input.ClassType = ClassType.Struct; input.BaseType = new DomReturnType ("BaseClass"); input.AddInterfaceImplementation (new DomReturnType ("Interface1")); input.AddInterfaceImplementation (new DomReturnType ("Interface2")); input.Add (new DomMethod ("TestMethod", Modifiers.None, MethodModifier.None, DomLocation.Empty, DomRegion.Empty)); input.Add (new DomMethod (".ctor", Modifiers.None, MethodModifier.IsConstructor, DomLocation.Empty, DomRegion.Empty)); input.Add (new DomField ("TestField", Modifiers.None, DomLocation.Empty, DomReturnType.Void)); input.Add (new DomProperty ("TestProperty", Modifiers.None, DomLocation.Empty, DomRegion.Empty, DomReturnType.Void)); input.Add (new DomEvent ("TestEvent", Modifiers.None, DomLocation.Empty, DomReturnType.Void)); MemoryStream ms = new MemoryStream (); BinaryWriter writer = new BinaryWriter (ms); DomPersistence.Write (writer, DefaultNameEncoder, input); byte[] bytes = ms.ToArray (); DomType result = DomPersistence.ReadType (CreateReader (bytes), DefaultNameDecoder); Assert.AreEqual ("Test", result.Name); Assert.AreEqual (ClassType.Struct, result.ClassType); Assert.AreEqual ("BaseClass", result.BaseType.Name); Assert.AreEqual (1, result.MethodCount); Assert.AreEqual (1, result.ConstructorCount); Assert.AreEqual (1, result.FieldCount); Assert.AreEqual (1, result.PropertyCount); Assert.AreEqual (1, result.EventCount); }
public void ExtensionMethodPreserveParameterTest () { // build "T MyMethod<T, S> (T a, S b)" DomMethod method = new DomMethod (); method.Name = "MyMethod"; method.ReturnType = new DomReturnType ("T"); method.AddTypeParameter (new TypeParameter ("T")); method.AddTypeParameter (new TypeParameter ("S")); method.Add (new DomParameter (method, "a", new DomReturnType ("T"))); method.Add (new DomParameter (method, "b", new DomReturnType ("S"))); // extend method List<IReturnType> genArgs = new List<IReturnType> (); List<IReturnType> args = new List<IReturnType> (); DomType extType = new DomType ("MyType"); ExtensionMethod extMethod = new ExtensionMethod (extType, method, genArgs, args); // check for MyType MyMethod<S> (S b) Assert.AreEqual ("MyType", extMethod.ReturnType.FullName); Assert.AreEqual ("S", extMethod.Parameters[0].ReturnType.FullName); Assert.AreEqual (1, extMethod.TypeParameters.Count); Assert.AreEqual ("S", extMethod.TypeParameters[0].Name); }
void VisitType (TypeContainer c, ClassType classType) { DomType newType = new DomType (); newType.SourceProjectDom = Dom; newType.CompilationUnit = Unit; if (typeStack.Count == 0 && !string.IsNullOrEmpty (currentNamespaceName)) newType.Namespace = currentNamespaceName; newType.Name = ConvertQuoted (c.MemberName.Name); newType.Location = Convert (c.MemberName.Location); newType.ClassType = classType; var location = LocationsBag.GetMemberLocation (c); if (location != null && location.Count > 1) { var region = ConvertRegion (c.MemberName.Location, location[location.Count - 1]); region.Start = new DomLocation (region.Start.Line, region.Start.Column + c.MemberName.Name.Length); newType.BodyRegion = region; } else { var region = ConvertRegion (c.MemberName.Location, c.MemberName.Location); region.Start = new DomLocation (region.Start.Line, region.Start.Column + c.MemberName.Name.Length); region.End = new DomLocation (int.MaxValue, int.MaxValue); newType.BodyRegion = region; } newType.Modifiers = ConvertModifiers (c.ModFlags); AddAttributes (newType, c.OptAttributes, c); AddTypeParameter (newType, c); if (c.TypeBaseExpressions != null) { foreach (var type in c.TypeBaseExpressions) { var baseType = ConvertReturnType (type); // Console.WriteLine (newType.Name + " -- " + baseType); if (newType.BaseType == null) { newType.BaseType = baseType; } else { newType.AddInterfaceImplementation (baseType); } } } AddType (newType); // visit members typeStack.Push (newType); foreach (MemberCore member in c.OrderedAllMembers) { member.Accept (this); } typeStack.Pop (); }
public override object VisitTypeDeclaration (ICSharpCode.NRefactory.Ast.TypeDeclaration typeDeclaration, object data) { DomType newType = new DomType (); newType.SourceProjectDom = dom; newType.Name = typeDeclaration.Name; newType.Documentation = RetrieveDocumentation (typeDeclaration.StartLocation.Line); newType.Location = ConvertLocation (typeDeclaration.StartLocation); newType.ClassType = ConvertClassType (typeDeclaration.Type); DomRegion region = ConvertRegion (typeDeclaration.BodyStartLocation, typeDeclaration.EndLocation); region.End = new DomLocation (region.End.Line, region.End.Column); newType.BodyRegion = region; newType.Modifiers = ConvertModifiers (typeDeclaration.Modifier); AddAttributes (newType, typeDeclaration.Attributes); foreach (ICSharpCode.NRefactory.Ast.TemplateDefinition template in typeDeclaration.Templates) { TypeParameter parameter = ConvertTemplateDefinition (template); newType.AddTypeParameter (parameter); } if (typeDeclaration.BaseTypes != null) { foreach (ICSharpCode.NRefactory.Ast.TypeReference type in typeDeclaration.BaseTypes) { if (type == typeDeclaration.BaseTypes[0]) { newType.BaseType = ConvertReturnType (type); } else { newType.AddInterfaceImplementation (ConvertReturnType (type)); } } } AddType (newType); // visit members typeStack.Push (newType); typeDeclaration.AcceptChildren (this, data); typeStack.Pop (); return null; }
public virtual object GetAnimateResult(float time, DomType domtype) { if (time < this.Begin) { return string.Empty; } object obj1 = this.FFT(time, domtype); this.pretime = (int) time; return obj1; }
public static object GetAnimateValue(SvgElement element, string attributename, DomType domtype, object orivalue) { PointF[] tfArray6; PointF[] tfArray7; PointF[] tfArray8; int num8; Matrix matrix1 = new Matrix(); string text1 = string.Empty; GraphicsPath path1 = null; string text2 = string.Empty; PointF[] tfArray1 = null; bool flag1 = true; if (element.AnimateNameValues.ContainsKey(attributename)) { AnimateInfo info1 = (AnimateInfo) element.AnimateNameValues[attributename]; object[] objArray1 = info1.AnimateValues; bool[] flagArray1 = info1.ValueAdds; int num1 = 0; if ((domtype == DomType.SvgString) || (domtype == DomType.SvgLink)) { for (int num2 = objArray1.Length - 1; num2 >= 0; num2--) { if ((objArray1[num2] is string) && (objArray1[num2].ToString() != string.Empty)) { if (element is ItopVector.Core.Figure.Image) { ((ItopVector.Core.Figure.Image) element).RefImage = ImageFunc.GetImageForURL(objArray1[num2].ToString(), element); } return objArray1[num2].ToString(); } } return orivalue; } object[] objArray2 = objArray1; for (int num10 = 0; num10 < objArray2.Length; num10++) { PointF[] tfArray2; float single3; GraphicsPath path2; PointF[] tfArray3; PointF[] tfArray4; PointF[] tfArray5; object obj1 = objArray2[num10]; bool flag2 = flagArray1[num1]; switch (domtype) { case DomType.SvgMatrix: { Matrix matrix2 = new Matrix(); if ((obj1 != null) && (obj1.ToString() != string.Empty)) { matrix2 = ((Matrix) obj1).Clone(); } if (flag2) { matrix1.Multiply(matrix2); goto Label_046F; } matrix1 = matrix2; goto Label_046F; } case DomType.SvgNumber: { single3 = 0f; if ((obj1 != null) && (obj1.ToString() != string.Empty)) { single3 = (float) obj1; if (!flag2 || (text1 == string.Empty)) { goto Label_0246; } float single9 = float.Parse(text1) + single3; text1 = single9.ToString(); } goto Label_046F; } case DomType.SvgString: { goto Label_046F; } case DomType.SvgColor: { string text3 = string.Empty; if ((obj1 != null) && (obj1.ToString() != string.Empty)) { text3 = (string) obj1; } if (text3 != string.Empty) { if ((flag2 && (text2 != string.Empty)) && (!text2.Trim().StartsWith("url") && !text3.Trim().StartsWith("url"))) { Color color1 = ColorFunc.ParseColor(text3); Color color2 = ColorFunc.ParseColor(text2); int num4 = (color1.R + color2.R) / 2; int num5 = (color1.G + color2.G) / 2; int num6 = (color1.B + color2.B) / 2; string[] textArray1 = new string[7] { "rgb(", num4.ToString(), ",", num5.ToString(), ",", num6.ToString(), ")" } ; text2 = string.Concat(textArray1); goto Label_046F; } text2 = text3; } goto Label_046F; } case DomType.SvgPath: { if ((obj1 != null) && (obj1.ToString() != string.Empty)) { path2 = (GraphicsPath) obj1; if (!flag2 || (path1 == null)) { goto Label_0460; } tfArray3 = path2.PathPoints; tfArray4 = path1.PathPoints; if (tfArray3.Length == tfArray4.Length) { goto Label_03B5; } } goto Label_046F; } case DomType.SvgPoints: { tfArray2 = new PointF[0]; if (obj1 is PointF[]) { tfArray2 = (PointF[]) obj1; } if (!flag2) { break; } if (tfArray1.Length == tfArray2.Length) { for (int num3 = 0; num3 < tfArray2.Length; num3++) { PointF tf1 = tfArray1[num3]; PointF tf2 = tfArray2[num3]; float single1 = (tf1.X + tf2.X) / 2f; float single2 = (tf1.Y + tf2.Y) / 2f; tfArray1[num3] = new PointF(single1, single2); } } goto Label_046F; } default: { goto Label_046F; } } tfArray1 = (PointF[]) tfArray2.Clone(); goto Label_046F; Label_0246: text1 = single3.ToString(); goto Label_046F; Label_03B5: tfArray5 = new PointF[tfArray4.Length]; Array.Copy(tfArray3, tfArray1, tfArray5.Length); byte[] buffer1 = path2.PathTypes; byte[] buffer2 = path1.PathTypes; for (int num7 = 0; num7 < Math.Min(tfArray3.Length, tfArray4.Length); num7++) { PointF tf3 = tfArray3[num7]; PointF tf4 = tfArray4[num7]; float single4 = tf3.X + tf4.X; float single5 = tf3.Y + tf4.Y; tfArray5[num7] = new PointF(single4, single5); } path1 = new GraphicsPath(tfArray5, path2.PathTypes); goto Label_046D; Label_0460: path1 = (GraphicsPath) path2.Clone(); Label_046D:; Label_046F:; } if (flagArray1.Length > 0) { flag1 = flagArray1[flagArray1.Length - 1]; } } switch (domtype) { case DomType.SvgMatrix: { Matrix matrix3 = new Matrix(); if (orivalue != null) { matrix3 = ((Matrix) orivalue).Clone(); } if (flag1) { matrix3.Multiply(matrix1); } else { matrix3 = matrix1.Clone(); } return matrix3.Clone(); } case DomType.SvgNumber: { if ((flag1 && (orivalue != null)) && (orivalue.ToString() != string.Empty)) { float single6 = (float) orivalue; if (text1 == string.Empty) { text1 = single6.ToString(); break; } float single10 = float.Parse(text1) + single6; text1 = single10.ToString(); } break; } case DomType.SvgString: { return orivalue; } case DomType.SvgColor: { if (text2 == string.Empty) { return orivalue; } if ((flag1 && (orivalue != null)) && (!text2.Trim().StartsWith("url") && !((string) orivalue).Trim().StartsWith("url"))) { Color color3 = ColorFunc.ParseColor((string) orivalue); Color color4 = ColorFunc.ParseColor(text2); string[] textArray2 = new string[7]; textArray2[0] = "rgb("; int num11 = (color3.R + color4.R) / 2; textArray2[1] = num11.ToString(); textArray2[2] = ","; int num12 = (color3.G + color4.G) / 2; textArray2[3] = num12.ToString(); textArray2[4] = ","; int num13 = (color3.B + color4.B) / 2; textArray2[5] = num13.ToString(); textArray2[6] = ")"; text2 = string.Concat(textArray2); } return text2; } case DomType.SvgPath: { if (path1 == null) { return orivalue; } if (!flag1 || (orivalue == null)) { return path1; } tfArray6 = ((GraphicsPath) orivalue).PathPoints; tfArray7 = path1.PathPoints; tfArray8 = new PointF[tfArray6.Length]; Array.Copy(tfArray6, tfArray1, tfArray8.Length); num8 = 0; goto Label_0738; } case DomType.SvgPoints: { if (tfArray1.Length > 0) { PointF[] tfArray9 = new PointF[0]; if (!(orivalue is PointF[]) || !flag1) { return tfArray1; } tfArray9 = (PointF[]) orivalue; if (tfArray9.Length != tfArray1.Length) { return tfArray1; } for (int num9 = 0; num9 < tfArray1.Length; num9++) { tfArray1[num9] = new PointF((tfArray1[num9].X + tfArray9[num9].X) / 2f, (tfArray1[num9].Y + tfArray9[num9].Y) / 2f); } } return tfArray1; } default: { return string.Empty; } } if (text1 != string.Empty) { return float.Parse(text1); } if ((orivalue.ToString() == string.Empty) || (orivalue == null)) { return (float) AttributeFunc.GetDefaultValue(element, attributename); } return (float) orivalue; Label_0738: if (num8 >= Math.Min(tfArray6.Length, tfArray7.Length)) { return new GraphicsPath(tfArray8, path1.PathTypes); } PointF tf5 = tfArray6[num8]; PointF tf6 = tfArray7[num8]; float single7 = tf5.X + tf6.X; float single8 = tf5.Y + tf6.Y; tfArray8[num8] = new PointF(single7, single8); num8++; goto Label_0738; }
void BuildClass (XmlElement element, StringReader content) { var compUnit = this.CompilationUnit as PythonCompilationUnit; Console.WriteLine ("Class({0})", element.GetAttribute ("name")); var name = element.GetAttribute ("name"); var start = GetDomLocation (element); var region = GetDomRegion (element); var fullName = PythonHelper.ModuleFromFilename (FileName); var klass = new DomType (fullName) { Name = name, Location = start, BodyRegion = region, Modifiers = Modifiers.Public, CompilationUnit = compUnit }; compUnit.Add (klass); }
public static string[] Linear(string startvalue, float starttime, string endvalue, float endtime, DomType domtype, int time) { int num2; int num5; char[] chArray1 = new char[2] { ' ', ',' } ; string[] textArray1 = startvalue.Split(chArray1); char[] chArray2 = new char[2] { ' ', ',' } ; string[] textArray2 = endvalue.Split(chArray2); string[] textArray3 = new string[Math.Min(textArray1.Length, textArray2.Length)]; switch (domtype) { case DomType.SvgMatrix: case DomType.SvgNumber: { num2 = 0; goto Label_0217; } case DomType.SvgString: { goto Label_0762; } case DomType.SvgColor: { if ((!startvalue.Trim().StartsWith("url") && !endvalue.Trim().StartsWith("url")) && ((endvalue != "none") && (startvalue != "none"))) { Color color1 = ColorFunc.ParseColor(startvalue.Trim()); Color color2 = ColorFunc.ParseColor(endvalue.Trim()); float single5 = (float) Math.Round((double) AnimFunc.Linear((float) color1.R, starttime, (float) color2.R, endtime, (float) time), 2); float single6 = (float) Math.Round((double) AnimFunc.Linear((float) color1.G, starttime, (float) color2.G, endtime, (float) time), 2); float single7 = (float) Math.Round((double) AnimFunc.Linear((float) color1.B, starttime, (float) color2.B, endtime, (float) time), 2); string[] textArray11 = new string[1]; string[] textArray12 = new string[7] { "rgb(", single5.ToString(), ",", single6.ToString(), ",", single7.ToString(), ")" } ; textArray11[0] = string.Concat(textArray12); return textArray11; } if (time < ((starttime / 2f) + (endtime / 2f))) { return new string[1] { startvalue } ; } return new string[1] { endvalue } ; } case DomType.SvgPath: { PointInfoCollection collection1 = new PointInfoCollection(); PointInfoCollection collection2 = new PointInfoCollection(); GraphicsPath path1 = PathFunc.PathDataParse(startvalue, collection1); GraphicsPath path2 = PathFunc.PathDataParse(endvalue, collection2); if (collection1.Count == collection2.Count) { string text4 = string.Empty; for (int num3 = 0; num3 < collection1.Count; num3++) { PointInfo info1 = collection1[num3]; PointInfo info2 = collection2[num3]; if (((info1.Command.Trim().ToLower() != info2.Command.Trim().ToLower()) || (info1.IsStart != info2.IsStart)) || (info1.IsEnd != info2.IsEnd)) { if ((time > ((starttime + endtime) / 2f)) && (time <= endtime)) { return new string[1] { endvalue } ; } if ((time <= ((starttime + endtime) / 2f)) && (time >= starttime)) { return new string[1] { startvalue } ; } return new string[1] { string.Empty } ; } text4 = text4 + info1.Command.Trim().ToUpper(); string text5 = info1.Command.Trim().ToUpper(); if (((text5 == "C") || (text5 == "Q")) || (((text5 == "A") || (text5 == "T")) || (text5 == "S"))) { float single8 = AnimFunc.Linear(info1.FirstControl.X, starttime, info2.FirstControl.X, endtime, (float) time); float single9 = AnimFunc.Linear(info1.FirstControl.Y, starttime, info2.FirstControl.Y, endtime, (float) time); string text8 = text4; string[] textArray19 = new string[5] { text8, single8.ToString(), " ", single9.ToString(), " " } ; text4 = string.Concat(textArray19); single8 = AnimFunc.Linear(info1.SecondControl.X, starttime, info2.SecondControl.X, endtime, (float) time); single9 = AnimFunc.Linear(info1.SecondControl.Y, starttime, info2.SecondControl.Y, endtime, (float) time); string text9 = text4; string[] textArray20 = new string[5] { text9, single8.ToString(), " ", single9.ToString(), " " } ; text4 = string.Concat(textArray20); } float single10 = AnimFunc.Linear(info1.MiddlePoint.X, starttime, info2.MiddlePoint.X, endtime, (float) time); float single11 = AnimFunc.Linear(info1.MiddlePoint.Y, starttime, info2.MiddlePoint.Y, endtime, (float) time); string text10 = text4; string[] textArray21 = new string[5] { text10, single10.ToString(), " ", single11.ToString(), " " } ; text4 = string.Concat(textArray21); if (info1.IsEnd) { text4 = text4 + "Z"; } } return new string[1] { text4 } ; } if ((time > ((starttime + endtime) / 2f)) && (time <= endtime)) { return new string[1] { endvalue } ; } if ((time <= ((starttime + endtime) / 2f)) && (time >= starttime)) { return new string[1] { startvalue } ; } return new string[1] { string.Empty } ; } case DomType.SvgPoints: { PointF[] tfArray1 = PointsFunc.PointsParse(startvalue); PointF[] tfArray2 = PointsFunc.PointsParse(endvalue); if (tfArray1.Length == tfArray2.Length) { string text1 = string.Empty; for (int num1 = 0; num1 < tfArray1.Length; num1++) { PointF tf1 = tfArray1[num1]; PointF tf2 = tfArray2[num1]; float single1 = AnimFunc.Linear(tf1.X, starttime, tf2.X, endtime, (float) time); float single2 = AnimFunc.Linear(tf1.Y, starttime, tf2.Y, endtime, (float) time); text1 = text1 + single1.ToString() + " " + single2.ToString(); if (num1 < (tfArray1.Length - 1)) { text1 = text1 + ","; } } return new string[1] { text1 } ; } if ((time > ((starttime + endtime) / 2f)) && (time <= endtime)) { return new string[1] { endvalue } ; } if ((time <= ((starttime + endtime) / 2f)) && (time >= starttime)) { return new string[1] { startvalue } ; } return new string[1] { string.Empty } ; } default: { goto Label_0762; } } Label_0217: if (num2 >= textArray3.Length) { return textArray3; } string text2 = textArray1[num2]; string text3 = textArray2[num2]; float single3 = 0f; float single4 = 0f; try { single3 = ItopVector.Core.Func.Number.ParseFloatStr(text2); single4 = ItopVector.Core.Func.Number.ParseFloatStr(text3); double num6 = Math.Round((double) AnimFunc.Linear(single3, starttime, single4, endtime, (float) time), 2); textArray3[num2] = num6.ToString(); } catch (Exception) { } num2++; goto Label_0217; Label_0762: num5 = 0; while (num5 < textArray3.Length) { string text6 = textArray1[num5]; string text7 = textArray2[num5]; if (time >= ((endtime / 2f) + (starttime / 2f))) { textArray3[num5] = text7; } else if (time >= starttime) { textArray3[num5] = text6; } else { textArray3[num5] = string.Empty; } num5++; } return textArray3; }
IEnumerable<IType> BuildClasses(IEnumerable<PythonClass> classes) { foreach (PythonClass pyClass in classes) { var domType = new DomType () { Name = pyClass.Name, Documentation = pyClass.Documentation, ClassType = ClassType.Class, BodyRegion = pyClass.Region, Location = new DomLocation (pyClass.Region.Start.Line - 1, 0), }; m_AllWrapped.Add (domType); // class functions foreach (IMethod method in BuildFunctions (pyClass.Functions)) domType.Add (method); // class attributes foreach (IField field in BuildAttributes (pyClass.Attributes)) domType.Add (field); yield return domType; } }
public static MonoDevelop.Projects.Dom.INode ConvertDParserToDomNode(D_Parser.Dom.INode n, ParsedDocument doc) { //TODO: DDoc comments! if (n is DMethod) { var dm = n as DMethod; var domMethod = new DomMethod( n.Name, GetNodeModifiers(dm), dm.SpecialType == DMethod.MethodType.Constructor ? MethodModifier.IsConstructor : MethodModifier.None, FromCodeLocation(n.StartLocation), GetBlockBodyRegion(dm), GetReturnType(n)); foreach (var pn in dm.Parameters) domMethod.Add(new DomParameter(domMethod, pn.Name, GetReturnType(pn))); domMethod.AddTypeParameter(GetTypeParameters(dm)); foreach (var subNode in dm) domMethod.AddChild(ConvertDParserToDomNode(subNode, doc)); return domMethod; } else if (n is DEnum) { var de = n as DEnum; var domType = new DomType( doc.CompilationUnit, ClassType.Enum, GetNodeModifiers(de), n.Name, FromCodeLocation(n.StartLocation), BuildTypeNamespace(n), GetBlockBodyRegion(de)); foreach (var subNode in de) domType.Add(ConvertDParserToDomNode(subNode, doc) as IMember); return domType; } else if (n is DClassLike) { var dc = n as DClassLike; ClassType ct = ClassType.Unknown; switch (dc.ClassType) { case DTokens.Template: case DTokens.Class: ct = ClassType.Class; break; case DTokens.Interface: ct = ClassType.Interface; break; case DTokens.Union: case DTokens.Struct: ct = ClassType.Struct; break; } var domType = new DomType( doc.CompilationUnit, ct, GetNodeModifiers(dc), n.Name, FromCodeLocation(n.StartLocation), BuildTypeNamespace(n), GetBlockBodyRegion(dc)); domType.AddTypeParameter(GetTypeParameters(dc)); foreach (var subNode in dc) domType.Add(ConvertDParserToDomNode(subNode, doc) as IMember); return domType; } else if (n is DVariable) { var dv = n as DVariable; return new DomField(n.Name, GetNodeModifiers(dv), FromCodeLocation(n.StartLocation), GetReturnType(n)); } return null; }
public void ReadWriteTypeTest () { DomType input = new DomType (); input.Name = "Test"; input.ClassType = ClassType.Struct; input.BaseType = new DomReturnType ("BaseClass"); MemoryStream ms = new MemoryStream (); BinaryWriter writer = new BinaryWriter (ms); DomPersistence.Write (writer, DefaultNameEncoder, input); byte[] bytes = ms.ToArray (); DomType result = DomPersistence.ReadType (CreateReader (bytes), DefaultNameDecoder); Assert.AreEqual ("Test", result.Name); Assert.AreEqual (ClassType.Struct, result.ClassType); Assert.AreEqual ("BaseClass", result.BaseType.Name); }
public override object GetAnimateResult(float time, DomType domtype) { if (this.FileName != string.Empty) { if ((time < base.Begin) || (time > (base.Begin + base.Duration))) { if (this.m_CurrentStatus == MediaStatus.Running) { this.m_objMediaControl.Stop(); this.m_objMediaPosition.CurrentPosition = 0; this.m_CurrentStatus = MediaStatus.Stopped; this.timer.Stop(); } } else if (time != this.oldtime) { if (this.m_CurrentStatus == MediaStatus.None) { this.m_objMediaControl.Run(); this.m_objMediaPosition.CurrentPosition = (time - base.Begin) * 1.2f; this.timer.Start(); } else if (this.m_CurrentStatus == MediaStatus.Stopped) { this.m_objMediaPosition.CurrentPosition = (time - base.Begin) * 1.2f; this.m_objMediaControl.Run(); this.timer.Start(); } this.m_CurrentStatus = MediaStatus.Running; } else if (this.m_CurrentStatus == MediaStatus.Running) { this.m_objMediaControl.Stop(); this.m_objMediaPosition.CurrentPosition = 0; this.m_CurrentStatus = MediaStatus.Stopped; this.timer.Stop(); } } this.oldtime = time; return null; }
private object FCumT(float time, DomType domtype) { if (time <= (this.Begin + this.Duration)) { return this.FT(time, domtype); } int num1 = (int) Math.Floor((double) ((time - this.Begin) / ((float) this.Duration))); float single1 = (time - (num1 * this.Duration)) - this.Begin; string text1 = string.Empty; if (this.GetAttribute("accumulate").Trim() == "sum") { return this.FT(this.Begin + single1, domtype); } return this.FT(this.Begin + single1, domtype); }
void AddType (DomType type) { // add type to compilation unit or outer type if (typeStack.Count > 0) { // Nested types are private by default if ((type.Modifiers & Modifiers.VisibilityMask) == 0) type.Modifiers |= Modifiers.Private; DomType outerType = typeStack.Peek (); type.DeclaringType = outerType; outerType.Add (type); } else { // Types are internal by default if ((type.Modifiers & Modifiers.VisibilityMask) == 0) type.Modifiers |= Modifiers.Internal; if (namespaceStack.Count > 0) type.Namespace = namespaceStack.Peek (); ((CompilationUnit)result.CompilationUnit).Add (type); } }
public virtual object FT(float time, DomType domtype) { if ((time < this.Begin) || (time > (this.Begin + this.Duration))) { return null; } ArrayList list1 = (ArrayList) this.Values.Clone(); ArrayList list2 = (ArrayList) this.KeyTimes.Clone(); float single1 = 0f; float single2 = 1f; float single3 = this.Begin; float single4 = this.Duration; if (single4 == 0f) { single4 = 0.1f; } if (list1.Count == 0) { list1.Add(this.FromWhat); list2.Add(single3.ToString()); list1.Add(this.ToWhat); float single7 = single3 + single4; list2.Add(single7.ToString()); } int num1 = -1; float single5 = 0f; float single6 = 0f; for (int num2 = 1; num2 < list2.Count; num2++) { single5 = float.Parse(((string) list2[num2 - 1]).Trim()); single6 = float.Parse(((string) list2[num2]).Trim()); if ((time >= single5) && (time <= single6)) { num1 = num2 - 1; break; } } string text1 = (string) list1[num1]; string text2 = (string) list1[num1 + 1]; if (list2[num1] != null) { single1 = float.Parse((string) list2[num1]); } if (list2[num1 + 1] != null) { single2 = float.Parse((string) list2[num1 + 1]); } string text3 = string.Empty; string[] textArray1 = AnimFunc.Linear(text1.Trim(), single1, text2.Trim(), single2, domtype, (int) time); string[] textArray2 = textArray1; for (int num3 = 0; num3 < textArray2.Length; num3++) { string text4 = textArray2[num3]; text3 = text3 + text4 + " "; } switch (domtype) { case DomType.SvgMatrix: { return new Transf(this.Type + "(" + text3.Trim() + ")").Matrix; } case DomType.SvgNumber: { return ItopVector.Core.Func.Number.parseToFloat(text3.Trim(), (SvgElement) this.ParentNode, ItopVector.Core.Func.SvgLengthDirection.Horizontal); } case DomType.SvgColor: { return text3.Trim(); } case DomType.SvgPath: { SvgElement element1 = this.RefElement; if (element1 is IPath) { return PathFunc.PathDataParse(text3, ((IPath) element1).PointsInfo); } return PathFunc.PathDataParse(text3); } case DomType.SvgPoints: { return PointsFunc.PointsParse(text3); } } return text3.Trim(); }
public override object VisitTypeDeclaration(ICSharpCode.NRefactory.Ast.TypeDeclaration typeDeclaration, object data) { DomType type = new DomType (cu, TranslateClassType (typeDeclaration.Type), (MonoDevelop.Projects.Dom.Modifiers)typeDeclaration.Modifier, typeDeclaration.Name, new DomLocation (typeDeclaration.StartLocation.Line, typeDeclaration.StartLocation.Column), currentNamespace.Count > 0 ? currentNamespace.Peek() : "", TranslateRegion (typeDeclaration.StartLocation, typeDeclaration.EndLocation)); if (currentType.Count > 0) { currentType.Peek().Add (type); } else { cu.Add (type); } if (typeDeclaration.BaseTypes != null) { foreach (ICSharpCode.NRefactory.Ast.TypeReference baseType in typeDeclaration.BaseTypes) { if (type.BaseType == null) { type.BaseType = TranslateTypeReference (baseType); } else { type.AddInterfaceImplementation (TranslateTypeReference (baseType)); } } } currentType.Push (type); typeDeclaration.AcceptChildren (this, data); currentType.Pop(); return null; }
public override object FT(float time, DomType domtype) { string text2; string text1 = string.Empty; Matrix matrix1 = new Matrix(); float single1 = 0f; float single2 = 0f; float single3 = 0f; GraphicsPath path1 = this.GPath; bool flag1 = true; if (path1 == null) { flag1 = false; } else if (path1.PointCount <= 0) { flag1 = false; } if (flag1) { PointF[] tfArray1; GraphicsPath path2 = (GraphicsPath) this.motionPath.Clone(); path2.Flatten(new Matrix(), 0.01f); if (path2.PathTypes[path2.PathTypes.Length - 1] >= 0x80) { tfArray1 = new PointF[path2.PathPoints.Length + 1]; path2.PathPoints.CopyTo(tfArray1, 0); tfArray1[tfArray1.Length - 1] = path2.PathPoints[0]; } else { tfArray1 = path2.PathPoints; } int num1 = tfArray1.Length; int num2 = base.Begin; float single4 = base.Duration; float single5 = single4 / ((float) (num1 - 1)); int num3 = (int) ((time - num2) / single5); if ((num3 + 1) >= num1) { single1 = tfArray1[num3].X; single2 = tfArray1[num3].Y; if ((num3 - 1) >= 0) { PointF tf1 = tfArray1[num3 - 1]; if (tf1.X == single1) { single3 = 0f; } else { single3 = (float) ((Math.Atan((double) ((tf1.Y - single2) / (tf1.X - single1))) / 3.1415926535897931) * 180); } } goto Label_02C5; } PointF tf2 = tfArray1[num3]; PointF tf3 = tfArray1[num3 + 1]; float single6 = base.Begin + (num3 * single5); float single7 = base.Begin + ((num3 + 1) * single5); if (tf3.X == tf2.X) { single3 = 0f; } else { single3 = (float) ((Math.Atan((double) ((tf3.Y - tf2.Y) / (tf3.X - tf2.X))) / 3.1415926535897931) * 180); } switch (this.CalcMode) { case CalcMode.linear: { single1 = AnimFunc.Linear(tf2.X, single6, tf3.X, single7, time); single2 = AnimFunc.Linear(tf2.Y, single6, tf3.Y, single7, time); goto Label_02C5; } case CalcMode.paced: { goto Label_02C5; } case CalcMode.spline: { goto Label_02C5; } case CalcMode.discrete: { text1 = tfArray1[num3].X.ToString() + " " + tfArray1[num3].Y.ToString(); goto Label_02C5; } } goto Label_02C5; } matrix1 = (Matrix) base.FT(time, DomType.SvgMatrix); Label_02C5: text2 = this.GetAttribute("rotate").Trim(); if ((text2 == null) || (text2 == string.Empty)) { text2 = "0"; } if (text2 == "auto") { matrix1.Rotate(single3, MatrixOrder.Append); matrix1.Translate(single1, single2, MatrixOrder.Append); return matrix1; } if (text2 == "auto-reverse") { single3 -= 180f; matrix1.Rotate(single3, MatrixOrder.Append); matrix1.Translate(single1, single2, MatrixOrder.Append); return matrix1; } try { single3 = float.Parse(text2); matrix1.Rotate(single3); } catch (Exception) { } matrix1.Translate(single1, single2, MatrixOrder.Append); return matrix1; }
/// <summary> /// Create an IMember from a LanguageItem, /// using the source document to locate declaration bounds. /// </summary> /// <param name="pi"> /// A <see cref="ProjectInformation"/> for the current project. /// </param> /// <param name="item"> /// A <see cref="LanguageItem"/>: The item to convert. /// </param> /// <param name="contentLines"> /// A <see cref="System.String[]"/>: The document in which item is defined. /// </param> static IMember LanguageItemToIMember (ProjectInformation pi, LanguageItem item, string[] contentLines) { if (item is Class || item is Structure) { DomType klass = new DomType (new CompilationUnit (item.File), ClassType.Class, item.Name, new DomLocation ((int)item.Line, 1), string.Empty, new DomRegion ((int)item.Line+1, FindFunctionEnd (contentLines, (int)item.Line-1)+2), new List<IMember> ()); foreach (LanguageItem li in pi.AllItems ()) { if (klass.Equals (li.Parent) && FilePath.Equals (li.File, item.File)) { klass.Add (LanguageItemToIMember (pi, li, contentLines)); } } return klass; } if (item is Enumeration) { return new DomType (new CompilationUnit (item.File), ClassType.Enum, item.Name, new DomLocation ((int)item.Line, 1), string.Empty, new DomRegion ((int)item.Line+1, (int)item.Line+1), new List<IMember> ()); } if (item is Function) { return new DomMethod (item.Name, Modifiers.None, MethodModifier.None, new DomLocation ((int)item.Line, 1), new DomRegion ((int)item.Line+1, FindFunctionEnd (contentLines, (int)item.Line-1)+2), new DomReturnType ()); } if (item is Member) { return new DomField (item.Name, Modifiers.None, new DomLocation ((int)item.Line, 1), new DomReturnType ()); } return null; }
public void ExtensionMethodTest () { // build "T MyMethod<T, S> (this KeyValuePair<T, S> a, S b)" DomMethod method = new DomMethod (); method.Name = "MyMethod"; method.ReturnType = new DomReturnType ("T"); method.AddTypeParameter (new TypeParameter ("T")); method.AddTypeParameter (new TypeParameter ("S")); DomReturnType returnType = new DomReturnType ("KeyValuePair"); returnType.AddTypeParameter (new DomReturnType ("T")); returnType.AddTypeParameter (new DomReturnType ("S")); method.Add (new DomParameter (method, "a", returnType)); method.Add (new DomParameter (method, "b", new DomReturnType ("S"))); // Build extendet type KeyValuePair<int, object> DomType type = new DomType ("KeyValuePair"); type.AddTypeParameter (new TypeParameter ("T")); type.AddTypeParameter (new TypeParameter ("S")); IType extType = DomType.CreateInstantiatedGenericTypeInternal (type, new IReturnType[] { DomReturnType.Int32, DomReturnType.Object }); Console.WriteLine (extType); // extend method List<IReturnType> genArgs = new List<IReturnType> (); List<IReturnType> args = new List<IReturnType> (); ExtensionMethod extMethod = new ExtensionMethod (extType, method, genArgs, args); Console.WriteLine (extMethod); // check Assert.AreEqual (DomReturnType.Int32.FullName, extMethod.ReturnType.FullName); Assert.AreEqual (DomReturnType.Object.FullName, extMethod.Parameters[0].ReturnType.FullName); }
public IType GetArrayType (IReturnType elementType, MonoDevelop.Projects.Dom.Output.Ambience ambience) { // Create a fake class which sublcasses System.Array and implements IList<T> DomType t = new DomType (ambience.GetString (elementType, MonoDevelop.Projects.Dom.Output.OutputFlags.UseFullName) + "[]"); // set the compilation unit of the array type to that of the element type - it's required for jumping to the declaration of the type. IType eType = GetType (elementType); if (eType != null) t.CompilationUnit = eType.CompilationUnit; t.Resolved = true; t.BaseType = new DomReturnType ("System.Array"); t.ClassType = ClassType.Class; t.Modifiers = Modifiers.Public; t.SourceProjectDom = this; DomProperty indexer = new DomProperty (); indexer.Name = "Item"; indexer.SetterModifier = indexer.GetterModifier = Modifiers.Public; indexer.PropertyModifier |= PropertyModifier.IsIndexer; indexer.Add (new DomParameter(indexer, "index", DomReturnType.Int32)); indexer.ReturnType = elementType; t.Add (indexer); DomReturnType listType = new DomReturnType ("System.Collections.Generic.IList", false, new IReturnType [] { elementType }); t.AddInterfaceImplementation (listType); return t; }
public override ParsedDocument Parse(MonoDevelop.Projects.Dom.Parser.ProjectDom dom, string fileName, string content) { string basepath = (null == dom || null == dom.Project)? Path.GetDirectoryName (fileName): (string)dom.Project.BaseDirectory.FullPath; List<Error> errors = RubyCompletion.CheckForErrors (basepath, content); if (null != errors && 0 < errors.Count) { ParsedDocument doc = successfulParses.ContainsKey (fileName)? successfulParses[fileName]: new ParsedDocument (fileName); doc.Errors.Clear (); foreach (Error err in errors) { doc.Add (err); } return doc; }// Got parse errors - flag and return with last successful parse result lock (this) { string[] lines = content.Split (new string[]{Environment.NewLine}, StringSplitOptions.None); methods = new Dictionary<int, RubyDeclaration> (); classes = new Dictionary<int, RubyDeclaration> (); modules = new Dictionary<int, RubyDeclaration> (); if (!RunStack (lines)) { return successfulParses.ContainsKey (fileName)? successfulParses[fileName]: new ParsedDocument (fileName); } ParsedDocument doc = new ParsedDocument (fileName); if(null == doc.CompilationUnit){ doc.CompilationUnit = new CompilationUnit (fileName); } CompilationUnit cu = (CompilationUnit)doc.CompilationUnit; PopulateModules (cu); PopulateClasses (cu); if (0 < methods.Count) { DomType glob = new DomType (cu, ClassType.Unknown, GettextCatalog.GetString ("(Global Methods)"), new DomLocation (1, 1), string.Empty, new DomRegion (1, lines.Length), new List<IMember> ()); PopulateMethods (glob); cu.Add (glob); }// Add global methods return successfulParses[fileName] = doc; }// Populate dom/cu for quickfinder }