Пример #1
0
        protected static void CollectInformations(MethodEntity methodEntity, ref bool needStorage, ref bool varargs)
        {
            int outParameters   = 0;
            int refParameters   = 0;
            int blockParameters = 0;

            varargs = false;

            foreach (MethodParameterEntity methodParameterEntity in methodEntity.Parameters.Where(p => p.Generate))
            {
                if (methodParameterEntity.IsOut)
                {
                    outParameters++;
                }
                if (methodParameterEntity.IsByRef)
                {
                    refParameters++;
                }
                if (methodParameterEntity.IsBlock)
                {
                    blockParameters++;
                }
                if (!varargs && methodParameterEntity.Type.StartsWith("params"))
                {
                    varargs = true;
                }
            }

            needStorage = (outParameters + refParameters + blockParameters) > 0;
        }
Пример #2
0
        private static List <MethodEntity> SheetRangeToEntityList(IList <IList <object> > sheetRange)
        {
            List <MethodEntity> methodList = new List <MethodEntity>();

            if (sheetRange != null && sheetRange.Count > 0)
            {
                foreach (var row in sheetRange)
                {
                    var methodEntity = new MethodEntity
                    {
                        Repository  = row[0].ToString().Trim(),
                        Project     = row[1].ToString().Trim(),
                        Class       = row[2].ToString().Trim(),
                        Method      = row[3].ToString().Trim(),
                        Coverage    = int.Parse(row[4].ToString()),
                        Team        = row[6].ToString().Trim(),
                        UpdatedDate = row.Count < 10 ? string.Empty : row[9].ToString().Trim(),
                        RawData     = row,
                    };

                    if (string.IsNullOrWhiteSpace(methodEntity.Method) == false)
                    {
                        methodList.Add(methodEntity);
                    }
                }
            }

            return(methodList);
        }
Пример #3
0
        public override void ProcessClosures(Context ctx)
        {
            if (MustInferArgTypes)
            {
                var name = Arguments.First(a => a.Type == typeof(UnspecifiedType)).Name;
                Error(CompilerMessages.LambdaArgTypeUnknown, name);
            }

            // get evaluated return type
            var retType = _inferredReturnType ?? Body.Resolve(ctx);

            if (retType == typeof(NullType))
            {
                Error(CompilerMessages.LambdaReturnTypeUnknown);
            }
            if (retType.IsVoid())
            {
                retType = typeof(void);
            }

            _method      = ctx.Scope.CreateClosureMethod(ctx, Arguments, retType);
            _method.Body = Body;

            var outerMethod = ctx.CurrentMethod;

            ctx.CurrentMethod = _method;

            _method.Body.ProcessClosures(ctx);

            ctx.CurrentMethod = outerMethod;
        }
Пример #4
0
        protected void AppendDocumentation(MethodEntity methodEntity, bool extensionParameter = false, bool opaqueParameter = false)
        {
            // Append method comments
            this.Writer.WriteLineFormat(2, "/// <summary>");
            foreach (String line in methodEntity.Summary)
            {
                this.Writer.WriteLineFormat(2, "/// <para>{0}</para>", line.EscapeAll());
            }
            this.Writer.WriteLineFormat(2, "/// <para>Original signature is '{0}'</para>", methodEntity.Signature.EscapeAll());
            this.AppendAvailability(2, methodEntity);
            this.Writer.WriteLineFormat(2, "/// </summary>");

            // Add extra parameter
            if (extensionParameter)
            {
                this.Writer.WriteLineFormat(2, "/// <param name=\"__target\">The target instance.</param>");
            }

            // Append parameters' comments
            foreach (MethodParameterEntity methodParameterEntity in methodEntity.Parameters.Where(p => p.Generate))
            {
                this.Writer.WriteLineFormat(2, "/// <param name=\"{0}\">{1}</param>", methodParameterEntity.Name.Trim('@'), methodParameterEntity.Summary.Count > 0 ? methodParameterEntity.Summary [0].EscapeAll() : "MISSING");
            }

            // Append returns' comments
            if (!String.Equals(methodEntity.ReturnType, "void"))
            {
                this.Writer.WriteLineFormat(2, "/// <returns>{0}</returns>", methodEntity.ReturnsDocumentation.EscapeAll());
            }
        }
Пример #5
0
        private PropertyEntity ExtractProperty(PropertyDeclaration propertyDeclaration)
        {
            PropertyEntity propertyEntity = new PropertyEntity();

            propertyEntity.Name   = propertyDeclaration.Name;
            propertyEntity.Static = (propertyDeclaration.Modifier & Modifiers.Static) == Modifiers.Static;

            // Get the method's comment
            IEnumerable <Comment> comments = this.GetDocumentationCommentsBefore(propertyDeclaration);

            AppendComment(propertyEntity, comments);

            // Extract getter
            MethodEntity getterEntity = new MethodEntity();

            propertyEntity.Getter = getterEntity;

            // Extract signature from comments
            Comment signatureComment = comments.FirstOrDefault(c => CommentHelper.IsSignature(c.CommentText.Trim()));

            if (signatureComment != null)
            {
                getterEntity.Signature = signatureComment.Trim("Original signature is", "'", ";", "private");
            }

            // Extract selector
            MethodSelectorExtractor extractor = new MethodSelectorExtractor(getterEntity.Signature);

            getterEntity.Selector = extractor.Extract();

            // Parse the signature for return type
            MethodSignatureEnumerator signatureEnumerator = new MethodSignatureEnumerator(getterEntity.Signature);

            if (signatureEnumerator.MoveNext())
            {
                bool isOut, isByRef, isBlock;
                propertyEntity.Type = this.TypeManager.ConvertType(signatureEnumerator.Current.TrimAll(), out isOut, out isByRef, out isBlock, this.Logger);
            }
            else
            {
                propertyEntity.Type = "Id";
            }

            if (propertyDeclaration.HasSetRegion)
            {
                MethodEntity setterEntity = new MethodEntity();
                setterEntity.Selector = "MISSING";

                MethodParameterEntity methodParameterEntity = new MethodParameterEntity();
                methodParameterEntity.Name = "value";
                methodParameterEntity.Type = propertyEntity.Type;
                setterEntity.Parameters.Add(methodParameterEntity);
                setterEntity.ReturnType = "void";

                propertyEntity.Setter = setterEntity;
            }

            return(propertyEntity);
        }
Пример #6
0
 private static string GetExtraParameter(ClassEntity classEntity, MethodEntity methodEntity, bool extension)
 {
     if (extension && !methodEntity.Static)
     {
         return(String.Format("this {0} __target", classEntity.Name));
     }
     return(String.Empty);
 }
Пример #7
0
 /// <summary>
 ///   Gets the name of the method.
 /// </summary>
 /// <param name = "methodEntity">The method entity.</param>
 /// <returns></returns>
 internal static String GetMethodName(MethodEntity methodEntity)
 {
     String[] parts = methodEntity.Selector.Split (new[] {':'}, StringSplitOptions.RemoveEmptyEntries);
     StringBuilder builder = new StringBuilder ();
     foreach (String part in parts) {
         String token = part.UpperCaseFirstLetter ();
         builder.Append (token);
     }
     return builder.ToString ();
 }
Пример #8
0
        public GlobalPropertyInfo(int id, Type propType, bool hasGetter, bool hasSetter, MethodEntity getterMethod, MethodEntity setterMethod)
        {
            PropertyId   = id;
            PropertyType = propType;
            HasGetter    = hasGetter;
            HasSetter    = hasSetter;

            GetterMethod = getterMethod;
            SetterMethod = setterMethod;
        }
Пример #9
0
        private MethodEntity DeriveMethodEntity(MethodEntity methodEntity, bool is64Bits)
        {
            MethodEntity result = new MethodEntity(methodEntity);

            result.ReturnType = this.GetRealType(result.ReturnType, is64Bits);
            foreach (MethodParameterEntity parameter in result.Parameters)
            {
                parameter.Type = this.GetRealType(parameter.Type, is64Bits);
            }

            return(result);
        }
Пример #10
0
        protected void ExtractDelegateMethods(ClassEntity classEntity, XElement root)
        {
            IEnumerable <XElement> methods = from el in root.Descendants("div")
                                             where (String)el.Attribute("class") == "api delegateMethod"
                                             select el;

            foreach (XElement methodElement in methods)
            {
                MethodEntity methodEntity = this.MethodParser.Parse(classEntity, methodElement);
                classEntity.DelegateMethods.Add(methodEntity);
            }
        }
Пример #11
0
        /// <summary>
        ///   Gets the name of the method.
        /// </summary>
        /// <param name = "methodEntity">The method entity.</param>
        /// <returns></returns>
        internal static String GetMethodName(MethodEntity methodEntity)
        {
            String[]      parts   = methodEntity.Selector.Split(new[] { ':' }, StringSplitOptions.RemoveEmptyEntries);
            StringBuilder builder = new StringBuilder();

            foreach (String part in parts)
            {
                String token = part.UpperCaseFirstLetter();
                builder.Append(token);
            }
            return(builder.ToString());
        }
Пример #12
0
        private void GenerateConstructorBody(int indent, string target, MethodEntity methodEntity, MethodEntity innerMethodEntity, bool needStorage, bool varargs)
        {
            //bool hasReturn = !String.Equals (methodEntity.ReturnType, "void");
            //bool mixed = (innerMethodEntity != null);

            this.GenerateLocalsAllocation(indent, methodEntity, innerMethodEntity);
            this.GenerateLocalsMarshalling(indent, methodEntity, innerMethodEntity);

            String invocation = GetMethodInvocation(target, methodEntity, innerMethodEntity, true, false);

            this.Writer.WriteLineFormat(indent, "this.NativePointer = {0}", invocation);

            this.GenerateLocalsUnmarshalling(indent, methodEntity, innerMethodEntity);
            this.GenerateLocalsDeallocation(indent, methodEntity, innerMethodEntity);
        }
Пример #13
0
        protected void GenerateLocalsMarshalling(int indent, MethodEntity methodEntity, MethodEntity innerMethodEntity)
        {
            int index = 1;

            for (int i = 0; i < methodEntity.Parameters.Count; i++)
            {
                MethodParameterEntity methodParameterEntity      = methodEntity.Parameters [i];
                MethodParameterEntity innerMethodParameterEntity = innerMethodEntity != null ? innerMethodEntity.Parameters [i] : methodParameterEntity;

                if (methodParameterEntity.IsOut)
                {
                    if ("bool,char,byte,short,ushort,int,uint,long,ulong".Contains(methodParameterEntity.Type))                        // Boolean
                    // TODO: Add zeroing
                    {
                        index++;
                    }
                    else if ("float,double".Contains(methodParameterEntity.Type))
                    {
                        // TODO: Add zeroing
                        index++;
                    }
                    else if (IsMixedType(methodParameterEntity.Type))
                    {
                        // TODO: Add zeroing
                        index++;
                    }
                    else
                    {
                        this.Writer.WriteLineFormat(indent, "Marshal.WriteIntPtr(__local{0}, IntPtr.Zero);", index++);
                    }
                }
                else if (methodParameterEntity.IsByRef)
                {
                    if (IsMixedType(methodParameterEntity.Type))
                    {
                        this.Writer.WriteLineFormat(indent, "Marshal.StructureToPtr(({0}) {1}, __local{2}, false);", innerMethodParameterEntity.Type, methodParameterEntity.Name, index++);
                    }
                    else
                    {
                        this.Writer.WriteLineFormat(indent, "Marshal.StructureToPtr({0}, __local{1}, false);", methodParameterEntity.Name, index++);
                    }
                }
                else if (methodParameterEntity.IsBlock)
                {
                    index++;
                }
            }
        }
Пример #14
0
        protected static String GetMessageParameterList(MethodEntity methodEntity, MethodEntity innerMethodEntity, bool withColonFirst)
        {
            StringBuilder builder = new StringBuilder();

            int index = 1;

            for (int i = 0; i < methodEntity.Parameters.Count; i++)
            {
                MethodParameterEntity methodParameterEntity      = methodEntity.Parameters [i];
                MethodParameterEntity innerMethodParameterEntity = innerMethodEntity != null ? innerMethodEntity.Parameters [i] : methodParameterEntity;

                if (!innerMethodParameterEntity.Generate)
                {
                    continue;
                }

                if (i > 0 || withColonFirst)
                {
                    builder.Append(", ");
                }

                if (innerMethodParameterEntity.IsOut)
                {
                    builder.AppendFormat("__local{0}", index++);
                }
                else if (innerMethodParameterEntity.IsByRef)
                {
                    builder.AppendFormat("__local{0}", index++);
                }
                else if (innerMethodParameterEntity.IsBlock)
                {
                    builder.AppendFormat("__local{0}", index++);
                }
                else
                {
                    if (String.Equals(methodParameterEntity.Type, innerMethodParameterEntity.Type))
                    {
                        builder.AppendFormat("{0}", innerMethodParameterEntity.Name);
                    }
                    else
                    {
                        builder.AppendFormat("({0}) {1}", innerMethodParameterEntity.Type, innerMethodParameterEntity.Name);
                    }
                }
            }

            return(builder.ToString());
        }
Пример #15
0
 private static String GetTarget(ClassEntity classEntity, MethodEntity methodEntity, bool extension)
 {
     if (methodEntity.Static)
     {
         if (extension)
         {
             return(String.Format("{0}.{0}Class", classEntity.Name));
         }
         return(String.Format("{0}Class", classEntity.Name));
     }
     if (extension)
     {
         return("__target");
     }
     return("this");
 }
Пример #16
0
        public override MethodEntity ParseMethod()
        {
            if (this.RetVar != null)
            {
                this.StatementProcessor.RegisterNewExpressionAssignment(RetVar,
                                                                        new TypeDescriptor(RetVar.Type, false));
            }

            var descriptor   = new MethodEntityDescriptor(this.MethodDescriptor); //EntityFactory.Create(this.MethodDescriptor, this.Dispatcher);
            var methodEntity = new MethodEntity(this.MethodDescriptor,
                                                this.MethodInterfaceData,
                                                this.PropGraph, descriptor,
                                                this.InstantiatedTypes,
                                                false);

            return(methodEntity);
        }
Пример #17
0
        protected static bool AreMethodTypesEqual(MethodEntity methodEntity1, MethodEntity methodEntity2)
        {
            if (!String.Equals(methodEntity1.ReturnType, methodEntity2.ReturnType))
            {
                return(false);
            }

            for (int i = 0; i < methodEntity1.Parameters.Count; i++)
            {
                if (!String.Equals(methodEntity1.Parameters [i].Type, methodEntity2.Parameters [i].Type))
                {
                    return(false);
                }
            }

            return(true);
        }
Пример #18
0
        /// <summary>
        /// Creates a wrapper from a method entity.
        /// </summary>
        private MethodWrapper WrapMethod(MethodEntity method, bool isPartial = false)
        {
            return(new MethodWrapper
            {
                Name = method.Name,
                Type = method.ContainerType.TypeInfo,

                IsStatic = method.IsStatic,
                IsVirtual = method.IsVirtual,
                IsPartiallyApplied = isPartial,
                IsVariadic = method.IsVariadic,

                MethodInfo = method.MethodInfo,
                ArgumentTypes = method.GetArgumentTypes(this),
                ReturnType = method.ReturnType
            });
        }
Пример #19
0
        /// <summary>
        /// 尋找 Kind = Method 的各階層的項目
        /// </summary>
        /// <param name="result">回傳值</param>
        /// <param name="source">目前的階層</param>
        private void FindMethod(List <MethodEntity> result, string assembly, string parentName, List <DotCoverReportChild> source)
        {
            if (source == null)
            {
                return;
            }

            foreach (var item in source)
            {
                var iName = parentName;
                if (item.Kind == Kind.Method)
                {
                    var covearge = new MethodEntity
                    {
                        Project  = assembly,
                        Class    = iName.Remove(iName.Length - 1, 1),
                        Method   = item.Name,
                        Coverage = (int)item.CoveragePercent,
                    };
                    result.Add(covearge);
                }
                else if (item.Kind == Kind.Type)
                {
                    var coverage = new MethodEntity
                    {
                        Project  = assembly,
                        Class    = iName + item.Name,
                        Method   = "*",
                        Coverage = (int)item.CoveragePercent,
                    };
                    result.Add(coverage);
                    iName += $"{item.Name}.";
                    FindMethod(result, assembly, iName, item.Children);
                }
                else if (item.Kind == Kind.Assembly)
                {
                    assembly = item.Name;
                    FindMethod(result, assembly, iName, item.Children);
                }
                else
                {
                    iName += $"{item.Name}.";
                    FindMethod(result, assembly, iName, item.Children);
                }
            }
        }
Пример #20
0
        protected void GenerateLocalsDeallocation(int indent, MethodEntity methodEntity, MethodEntity innerMethodEntity)
        {
            int index = 1;

            for (int i = 0; i < methodEntity.Parameters.Count; i++)
            {
                MethodParameterEntity methodParameterEntity = methodEntity.Parameters [i];
                //MethodParameterEntity innerMethodParameterEntity = innerMethodEntity != null ? innerMethodEntity.Parameters [i] : methodParameterEntity;

                if (methodParameterEntity.IsOut || methodParameterEntity.IsByRef)
                {
                    this.Writer.WriteLineFormat(indent, "Marshal.FreeHGlobal(__local{0});", index++);
                }
                else if (methodParameterEntity.IsBlock)
                {
                    this.Writer.WriteLineFormat(indent, "__local{0}.Dispose();", index++);
                }
            }
        }
Пример #21
0
        protected void GenerateMethodBody(int indent, string target, MethodEntity methodEntity, MethodEntity innerMethodEntity, bool needStorage, bool varargs)
        {
            bool hasReturn       = !String.Equals(methodEntity.ReturnType, "void");
            bool mixed           = (innerMethodEntity != null);
            bool mixedReturnType = mixed && !String.Equals(methodEntity.ReturnType, innerMethodEntity.ReturnType);

            this.GenerateLocalsAllocation(indent, methodEntity, innerMethodEntity);
            this.GenerateLocalsMarshalling(indent, methodEntity, innerMethodEntity);

            String invocation = GetMethodInvocation(target, methodEntity, innerMethodEntity, hasReturn, varargs);

            if (hasReturn)
            {
                if (needStorage)
                {
                    String prefix = methodEntity.ReturnType + " __result = ";
                    if (mixedReturnType)
                    {
                        prefix += "(" + methodEntity.ReturnType + ") ";
                    }
                    invocation = prefix + invocation;
                }
                else
                {
                    String prefix = "return ";
                    if (mixedReturnType)
                    {
                        prefix += "(" + methodEntity.ReturnType + ") ";
                    }
                    invocation = prefix + invocation;
                }
            }
            this.Writer.WriteLineFormat(indent, invocation);

            this.GenerateLocalsUnmarshalling(indent, methodEntity, innerMethodEntity);
            this.GenerateLocalsDeallocation(indent, methodEntity, innerMethodEntity);

            if (hasReturn && needStorage)
            {
                this.Writer.WriteLineFormat(indent, "return __result;");
            }
        }
Пример #22
0
        public void Test涵蓋率未下降則不發通知()
        {
            //// Arrange
            var coverageEntity = new CoverageEntity
            {
                Repository = "Phanerozoic"
            };

            var methodUnchange = new MethodEntity
            {
                Class    = "AClass",
                Method   = "AMethod",
                Status   = CoverageStatus.Unchange,
                Coverage = 23,
            };
            var methodUp = new MethodEntity
            {
                Class    = "AClass",
                Method   = "AMethod",
                Status   = CoverageStatus.Up,
                Coverage = 23,
            };
            var methodList = new List <MethodEntity>
            {
                methodUnchange,
                methodUp,
            };

            var stringBuilder = new StringBuilder();

            stringBuilder.AppendLine(methodUnchange.ToString());
            var expectedMessage = stringBuilder.ToString();

            //// Act
            var target = GetTarget();

            target.Notify(coverageEntity, methodList);

            //// Assert
            this._stubSlackService.DidNotReceiveWithAnyArgs().SendAsync(string.Empty, Arg.Any <string>());
        }
        protected void ExtractMethods(ClassEntity classEntity, XElement root)
        {
            // Extract name
            String compoundname = (from el in root.Descendants("compoundname")
                                   select el.TrimAll()).FirstOrDefault();

            IEnumerable <XElement> memberDefs = (from el in root.Descendants("memberdef")
                                                 where el.Attribute("kind").Value == "function"
                                                 select el);

            foreach (XElement memberDef in memberDefs)
            {
                String definition = memberDef.Element("definition").TrimAll();
                if (!definition.Contains(compoundname + "::"))
                {
                    continue;
                }
                MethodEntity methodEntity = this.MethodParser.Parse(classEntity, memberDef);
                classEntity.Methods.Add(methodEntity);
            }
        }
        public override MethodEntity ParseMethod()
        {
            Contract.Assert(this.methodNode != null);

            var propGraphGenerator = new MethodSyntaxVisitor(this.model, this.RoslynMethod, this, this.containingTypeNode, this.methodNode);

            propGraphGenerator.Visit(this.methodNode);

            var descriptor      = new MethodEntityDescriptor(propGraphGenerator.MethodDescriptor); //EntityFactory.Create(this.MethodDescriptor, this.Dispatcher);
            var declarationInfo = CodeGraphHelper.GetMethodDeclarationInfo(this.methodNode, this.RoslynMethod);
            var referenceInfo   = CodeGraphHelper.GetMethodReferenceInfo(this.methodNode);

            var methodEntity = new MethodEntity(propGraphGenerator.MethodDescriptor,
                                                propGraphGenerator.MethodInterfaceData,
                                                propGraphGenerator.PropGraph, descriptor,
                                                propGraphGenerator.InstantiatedTypes,
                                                propGraphGenerator.StatementProcessor.AnonymousMethods,
                                                declarationInfo, referenceInfo);

            return(methodEntity);
        }
Пример #25
0
        protected void ExtractMethods(ClassEntity classEntity, XElement root)
        {
            XElement listMarker = (from el in root.Descendants("h2")
                                   where el.Value == "Methods"
                                   select el).FirstOrDefault();
            XElement list = listMarker != null?listMarker.ElementsAfterSelf("dl").FirstOrDefault() : null;

            if (list != null)
            {
                // Collect names
                List <String> names = new List <string> ();
                foreach (XElement term in list.Descendants("dt"))
                {
                    String name = term.Value.TrimAll();
                    names.Add(name.Trim('-', '+'));
                }

                // Search for a table with preceding by an anchor containing the name
                foreach (String name in names)
                {
                    XElement marker = (from el in list.ElementsAfterSelf("a")
                                       where el.Attribute("name") != null &&
                                       el.Attribute("name").Value.EndsWith("/" + name)
                                       select el).FirstOrDefault();
                    if (marker != null)
                    {
                        //XElement startElement = marker.ElementsAfterSelf ("table").FirstOrDefault ();
                        IEnumerable <XElement> elements = marker.ElementsAfterSelf().TakeWhile(el => el.Name != "a");

                        MethodEntity methodEntity = this.MethodParser.Parse(classEntity, name, elements);
                        classEntity.Methods.Add(methodEntity);
                    }
                    else
                    {
                        this.Logger.WriteLine("MISSING marker for method " + name);
                    }
                }
            }
        }
Пример #26
0
        private List <MethodEntity> GetCurrentMethodList()
        {
            var now        = this._dateTimeHelper.Now;
            var startIndex = 1;
            var maxRow     = string.Empty;
            List <MethodEntity>     methodLogList = new List <MethodEntity>();
            IList <IList <object> > values        = this._googleSheetsService.GetValues(this._sheetsId, $"{now.Year}!A{startIndex + 1}:I{maxRow}");

            var index = startIndex;

            if (values != null && values.Count > 0)
            {
                foreach (var row in values)
                {
                    if (row.Count < 4)
                    {
                        continue;
                    }

                    index++;
                    var methodEntity = new MethodEntity
                    {
                        Repository = row[0].ToString().Trim(),
                        Project    = row[1].ToString().Trim(),
                        Class      = row[2].ToString().Trim(),
                        Method     = row[3].ToString().Trim(),
                        RawIndex   = index,
                        RawData    = row,
                    };

                    if (string.IsNullOrWhiteSpace(methodEntity.Method) == false)
                    {
                        methodLogList.Add(methodEntity);
                    }
                }
            }
            return(methodLogList);
        }
Пример #27
0
        protected void GenerateLocalsAllocation(int indent, MethodEntity methodEntity, MethodEntity innerMethodEntity)
        {
            int index = 1;

            for (int i = 0; i < methodEntity.Parameters.Count; i++)
            {
                MethodParameterEntity methodParameterEntity      = methodEntity.Parameters [i];
                MethodParameterEntity innerMethodParameterEntity = innerMethodEntity != null ? innerMethodEntity.Parameters [i] : methodParameterEntity;

                if (methodParameterEntity.IsOut || methodParameterEntity.IsByRef)
                {
                    if ("bool,char,byte,short,ushort,int,uint,long,ulong".Contains(methodParameterEntity.Type))
                    {
                        this.Writer.WriteLineFormat(indent, "IntPtr __local{0} = Marshal.AllocHGlobal(Marshal.SizeOf(typeof ({1})));", index++, methodParameterEntity.Type);
                    }
                    else if ("IntPtr".Contains(methodParameterEntity.Type))
                    {
                        this.Writer.WriteLineFormat(indent, "IntPtr __local{0} = Marshal.AllocHGlobal(IntPtr.Size);", index++);
                    }
                    else if ("float,double".Contains(methodParameterEntity.Type))
                    {
                        this.Writer.WriteLineFormat(indent, "IntPtr __local{0} = Marshal.AllocHGlobal(Marshal.SizeOf(typeof ({1})));", index++, methodParameterEntity.Type);
                    }
                    else if (IsMixedType(methodParameterEntity.Type))
                    {
                        this.Writer.WriteLineFormat(indent, "IntPtr __local{0} = Marshal.AllocHGlobal(Marshal.SizeOf(typeof ({1})));", index++, innerMethodParameterEntity.Type);
                    }
                    else
                    {
                        this.Writer.WriteLineFormat(indent, "IntPtr __local{0} = Marshal.AllocHGlobal(Marshal.SizeOf(typeof (IntPtr)));", index++);
                    }
                }
                else if (methodParameterEntity.IsBlock)
                {
                    this.Writer.WriteLineFormat(indent, "Block __local{0} = ObjectiveCRuntime.CreateBlock({1});", index++, methodParameterEntity.Name);
                }
            }
        }
Пример #28
0
        protected static String GetKeywords(MethodEntity methodEntity, bool implementation, bool extension, bool markedAsNew)
        {
            String keywords = String.Empty;

            if (!implementation)
            {
                return(keywords);
            }
            keywords = "public ";
            if (markedAsNew)
            {
                keywords += "new ";
            }
            if (methodEntity.Static || extension)
            {
                keywords += "static ";
            }
            else if (!markedAsNew)
            {
                keywords += "virtual ";
            }
            return(keywords);
        }
Пример #29
0
        public void Test涵蓋率下降的方法發出通知()
        {
            //// Arrange
            var coverageEntity = new CoverageEntity
            {
                Repository = "Phanerozoic"
            };

            var method = new MethodEntity
            {
                Class    = "AClass",
                Method   = "AMethod",
                Status   = CoverageStatus.Down,
                Coverage = 23,
            };
            var methodList = new List <MethodEntity>
            {
                method,
            };

            var stringBuilder = new StringBuilder();

            stringBuilder.AppendLine(method.ToString());
            var expectedMessage = stringBuilder.ToString();

            var webHookUrl = "http://abc.com";

            this._stubConfiguration["Slack:WebHookUrl"].Returns(webHookUrl);

            //// Act
            var target = GetTarget();

            target.Notify(coverageEntity, methodList);

            //// Assert
            this._stubSlackService.Received(1).SendAsync(webHookUrl, Arg.Any <string>());
        }
Пример #30
0
        private static string GetMethodInvocation(string target, MethodEntity methodEntity, MethodEntity innerMethodEntity, bool hasReturn, bool varargs)
        {
            StringBuilder builder = new StringBuilder();

            String suffix = varargs ? "VarArgs" : String.Empty;

            if (hasReturn)
            {
                String returnType = innerMethodEntity != null ? innerMethodEntity.ReturnType : methodEntity.ReturnType;
                builder.AppendFormat("ObjectiveCRuntime.SendMessage{0}<{1}>", suffix, returnType);
            }
            else
            {
                builder.AppendFormat("ObjectiveCRuntime.SendMessage{0}", suffix);
            }

            String selector = innerMethodEntity != null ? innerMethodEntity.Selector : methodEntity.Selector;

            builder.AppendFormat("({0}, \"{1}\"", target, selector);
            builder.Append(GetMessageParameterList(methodEntity, innerMethodEntity, true));
            builder.Append(");");

            return(builder.ToString());
        }
Пример #31
0
        /// <summary>
        ///   Appends the documentation.
        /// </summary>
        private void AppendDocumentation(int indent, MethodEntity methodEntity)
        {
            // Append method comments
            this.Writer.WriteLineFormat(indent, "/// <summary>");
            foreach (String line in methodEntity.Summary)
            {
                this.Writer.WriteLineFormat(indent, "/// <para>{0}</para>", line.EscapeAll());
            }
            this.Writer.WriteLineFormat(indent, "/// <para>Original signature is '{0}'</para>", methodEntity.Signature.EscapeAll());
            this.AppendAvailability(indent, methodEntity);
            this.Writer.WriteLineFormat(indent, "/// </summary>");

            // Append parameters' comments
            foreach (MethodParameterEntity methodParameterEntity in methodEntity.Parameters.Where(p => p.Generate))
            {
                this.Writer.WriteLineFormat(indent, "/// <param name=\"{0}\">{1}</param>", methodParameterEntity.Name.Trim('@'), methodParameterEntity.Summary.Count > 0 ? methodParameterEntity.Summary [0].EscapeAll() : "MISSING");
            }

            // Append returns' comments
            if (!String.Equals(methodEntity.ReturnType, "void"))
            {
                this.Writer.WriteLineFormat(indent, "/// <returns>{0}</returns>", methodEntity.ReturnsDocumentation.EscapeAll());
            }
        }
Пример #32
0
        protected void GenerateLocalsUnmarshalling(int indent, MethodEntity methodEntity, MethodEntity innerMethodEntity)
        {
            int index = 1;
            for (int i = 0; i < methodEntity.Parameters.Count; i++) {
                MethodParameterEntity methodParameterEntity = methodEntity.Parameters [i];
                MethodParameterEntity innerMethodParameterEntity = innerMethodEntity != null ? innerMethodEntity.Parameters [i] : methodParameterEntity;

                if (methodParameterEntity.IsOut || methodParameterEntity.IsByRef) {
                    switch (methodParameterEntity.Type) {
                    case "bool":
                    case "byte":
                        this.Writer.WriteLineFormat (indent, "{0} = (Marshal.ReadByte(__local{1}) != 0);", methodParameterEntity.Name, index++);
                        break;
                    case "short":
                        this.Writer.WriteLineFormat (indent, "{0} = Marshal.ReadInt16(__local{1});", methodParameterEntity.Name, index++);
                        break;
                    case "ushort":
                        this.Writer.WriteLineFormat (indent, "{0} = (ushort) Marshal.ReadInt16(__local{1});", methodParameterEntity.Name, index++);
                        break;
                    case "int":
                        this.Writer.WriteLineFormat (indent, "{0} = Marshal.ReadInt32(__local{1});", methodParameterEntity.Name, index++);
                        break;
                    case "uint":
                        this.Writer.WriteLineFormat (indent, "{0} = (uint) Marshal.ReadInt32(__local{1});", methodParameterEntity.Name, index++);
                        break;
                    case "long":
                        this.Writer.WriteLineFormat (indent, "{0} = Marshal.ReadInt64(__local{1});", methodParameterEntity.Name, index++);
                        break;
                    case "ulong":
                        this.Writer.WriteLineFormat (indent, "{0} = (ulong) Marshal.ReadInt64(__local{1});", methodParameterEntity.Name, index++);
                        break;
                    case "IntPtr":
                        this.Writer.WriteLineFormat (indent, "{0} = Marshal.ReadIntPtr(__local{1});", methodParameterEntity.Name, index++);
                        break;
                    case "float":
                    case "double":
                        this.Writer.WriteLineFormat (indent, "{0} = ({1}) Marshal.PtrToStructure(__local{2}, typeof({1}));", methodParameterEntity.Name, methodParameterEntity.Type, index++);
                        break;
                    default:
                        if (IsMixedType (methodParameterEntity.Type) || methodParameterEntity.IsStruct) {
                            if (methodParameterEntity.Type.Equals (innerMethodParameterEntity.Type)) {
                                this.Writer.WriteLineFormat (indent, "{0} = ({1}) Marshal.PtrToStructure(__local{2}, typeof({1}));", methodParameterEntity.Name, methodParameterEntity.Type, index++, innerMethodParameterEntity.Type);
                            } else {
                                this.Writer.WriteLineFormat (indent, "{0} = ({1}) ({3}) Marshal.PtrToStructure(__local{2}, typeof({3}));", methodParameterEntity.Name, methodParameterEntity.Type, index++, innerMethodParameterEntity.Type);
                            }
                        } else {
                            this.Writer.WriteLineFormat (indent, "{0} = ObjectiveCRuntime.GetInstance<{1}>(Marshal.ReadIntPtr(__local{2}));", methodParameterEntity.Name, methodParameterEntity.Type, index++);
                        }
                        break;
                    }
                } else if (methodParameterEntity.IsBlock) {
                    index++;
                }
            }
        }
        /// <summary>
        ///   Appends the documentation.
        /// </summary>
        private void AppendDocumentation(int indent, MethodEntity methodEntity)
        {
            // Append method comments
            this.Writer.WriteLineFormat (indent, "/// <summary>");
            foreach (String line in methodEntity.Summary) {
                this.Writer.WriteLineFormat (indent, "/// <para>{0}</para>", line.EscapeAll ());
            }
            this.Writer.WriteLineFormat (indent, "/// <para>Original signature is '{0}'</para>", methodEntity.Signature.EscapeAll());
            this.AppendAvailability (indent, methodEntity);
            this.Writer.WriteLineFormat (indent, "/// </summary>");

            // Append parameters' comments
            foreach (MethodParameterEntity methodParameterEntity in methodEntity.Parameters.Where(p => p.Generate)) {
                this.Writer.WriteLineFormat (indent, "/// <param name=\"{0}\">{1}</param>", methodParameterEntity.Name.Trim ('@'), methodParameterEntity.Summary.Count > 0 ? methodParameterEntity.Summary [0].EscapeAll () : "MISSING");
            }

            // Append returns' comments
            if (!String.Equals (methodEntity.ReturnType, "void")) {
                this.Writer.WriteLineFormat (indent, "/// <returns>{0}</returns>", methodEntity.ReturnsDocumentation.EscapeAll ());
            }
        }
Пример #34
0
        private PropertyEntity ExtractProperty(PropertyDeclaration propertyDeclaration)
        {
            PropertyEntity propertyEntity = new PropertyEntity ();
            propertyEntity.Name = propertyDeclaration.Name;
            propertyEntity.Static = (propertyDeclaration.Modifier & Modifiers.Static) == Modifiers.Static;

            // Get the method's comment
            IEnumerable<Comment> comments = this.GetDocumentationCommentsBefore (propertyDeclaration);
            AppendComment (propertyEntity, comments);

            // Extract getter
            MethodEntity getterEntity = new MethodEntity ();
            propertyEntity.Getter = getterEntity;

            // Extract signature from comments
            Comment signatureComment = comments.FirstOrDefault (c => CommentHelper.IsSignature (c.CommentText.Trim ()));
            if (signatureComment != null) {
                getterEntity.Signature = signatureComment.Trim ("Original signature is", "'", ";", "private");
            }

            // Extract selector
            MethodSelectorExtractor extractor = new MethodSelectorExtractor (getterEntity.Signature);
            getterEntity.Selector = extractor.Extract ();

            // Parse the signature for return type
            MethodSignatureEnumerator signatureEnumerator = new MethodSignatureEnumerator (getterEntity.Signature);
            if (signatureEnumerator.MoveNext ()) {
                bool isOut, isByRef, isBlock;
                propertyEntity.Type = this.TypeManager.ConvertType (signatureEnumerator.Current.TrimAll (), out isOut, out isByRef, out isBlock, this.Logger);
            } else {
                propertyEntity.Type = "Id";
            }

            if (propertyDeclaration.HasSetRegion) {
                MethodEntity setterEntity = new MethodEntity ();
                setterEntity.Selector = "MISSING";

                MethodParameterEntity methodParameterEntity = new MethodParameterEntity ();
                methodParameterEntity.Name = "value";
                methodParameterEntity.Type = propertyEntity.Type;
                setterEntity.Parameters.Add (methodParameterEntity);
                setterEntity.ReturnType = "void";

                propertyEntity.Setter = setterEntity;
            }

            return propertyEntity;
        }
Пример #35
0
        private MethodEntity ExtractMethod(MethodDeclaration methodDeclaration)
        {
            MethodEntity methodEntity = new MethodEntity ();
            methodEntity.Name = methodDeclaration.Name;

            // Get the method's comment
            IEnumerable<Comment> comments = this.GetDocumentationCommentsBefore (methodDeclaration);

            // Extract signature from comments
            Comment signatureComment = comments.FirstOrDefault (c => CommentHelper.IsSignature (c.CommentText.Trim ()));
            if (signatureComment != null) {
                methodEntity.Signature = signatureComment.Trim ("Original signature is", "'", ";", "private");
            }
            AppendComment (methodEntity, comments);

            methodEntity.Static = (methodDeclaration.Modifier & Modifiers.Static) == Modifiers.Static;

            // Extract selector
            MethodSelectorExtractor extractor = new MethodSelectorExtractor (methodEntity.Signature);
            methodEntity.Selector = extractor.Extract ();

            // Parse the signature for return type
            MethodSignatureEnumerator signatureEnumerator = new MethodSignatureEnumerator (methodEntity.Signature);
            if (signatureEnumerator.MoveNext ()) {
                bool isOut, isByRef, isBlock;
                methodEntity.ReturnType = this.TypeManager.ConvertType (signatureEnumerator.Current.TrimAll (), out isOut, out isByRef, out isBlock, this.Logger);
            } else {
                methodEntity.ReturnType = "Id";
            }

            // Parse signature for parameter names and types
            MethodParametersEnumerator parameterTypesEnumerator = new MethodParametersEnumerator (methodEntity.Signature, false);
            MethodParametersEnumerator parameterNamesEnumerator = new MethodParametersEnumerator (methodEntity.Signature, true);
            while (parameterTypesEnumerator.MoveNext() && parameterNamesEnumerator.MoveNext()) {
                MethodParameterEntity parameterEntity = new MethodParameterEntity ();
                bool isOut, isByRef, isBlock;
                parameterEntity.Type = this.TypeManager.ConvertType (parameterTypesEnumerator.Current, out isOut, out isByRef, out isBlock, this.Logger);
                parameterEntity.IsOut = isOut;
                parameterEntity.IsByRef = isByRef;
                parameterEntity.IsBlock = isBlock;
                parameterEntity.Name = parameterNamesEnumerator.Current.Trim ();
                methodEntity.Parameters.Add (parameterEntity);
            }

            // Extract the corresponding comments
            foreach (MethodParameterEntity methodParameterEntity in methodEntity.Parameters) {
                String s = comments.GetParameterDescription (methodParameterEntity.Name);
                methodParameterEntity.Summary.Add (s);
            }
            return methodEntity;
        }
Пример #36
0
        protected static bool AreMethodTypesEqual(MethodEntity methodEntity1, MethodEntity methodEntity2)
        {
            if (!String.Equals (methodEntity1.ReturnType, methodEntity2.ReturnType)) {
                return false;
            }

            for (int i = 0; i < methodEntity1.Parameters.Count; i++) {
                if (!String.Equals (methodEntity1.Parameters [i].Type, methodEntity2.Parameters [i].Type)) {
                    return false;
                }
            }

            return true;
        }
Пример #37
0
        protected void GenerateMethodBody(int indent, string target, MethodEntity methodEntity, MethodEntity innerMethodEntity, bool needStorage, bool varargs)
        {
            bool hasReturn = !String.Equals (methodEntity.ReturnType, "void");
            bool mixed = (innerMethodEntity != null);
            bool mixedReturnType = mixed && !String.Equals (methodEntity.ReturnType, innerMethodEntity.ReturnType);

            this.GenerateLocalsAllocation (indent, methodEntity, innerMethodEntity);
            this.GenerateLocalsMarshalling (indent, methodEntity, innerMethodEntity);

            String invocation = GetMethodInvocation (target, methodEntity, innerMethodEntity, hasReturn, varargs);
            if (hasReturn) {
                if (needStorage) {
                    String prefix = methodEntity.ReturnType + " __result = ";
                    if (mixedReturnType) {
                        prefix += "(" + methodEntity.ReturnType + ") ";
                    }
                    invocation = prefix + invocation;
                } else {
                    String prefix = "return ";
                    if (mixedReturnType) {
                        prefix += "(" + methodEntity.ReturnType + ") ";
                    }
                    invocation = prefix + invocation;
                }
            }
            this.Writer.WriteLineFormat (indent, invocation);

            this.GenerateLocalsUnmarshalling (indent, methodEntity, innerMethodEntity);
            this.GenerateLocalsDeallocation (indent, methodEntity, innerMethodEntity);

            if (hasReturn && needStorage) {
                this.Writer.WriteLineFormat (indent, "return __result;");
            }
        }
Пример #38
0
 protected static String GetKeywords(MethodEntity methodEntity, bool implementation, bool extension, bool markedAsNew)
 {
     String keywords = String.Empty;
     if (!implementation) {
         return keywords;
     }
     keywords = "public ";
     if (markedAsNew) {
         keywords += "new ";
     }
     if (methodEntity.Static || extension) {
         keywords += "static ";
     } else if (!markedAsNew) {
         keywords += "virtual ";
     }
     return keywords;
 }
Пример #39
0
        private MethodEntity DeriveMethodEntity(MethodEntity methodEntity, bool is64Bits)
        {
            MethodEntity result = new MethodEntity (methodEntity);

            result.ReturnType = this.GetRealType (result.ReturnType, is64Bits);
            foreach (MethodParameterEntity parameter in result.Parameters) {
                parameter.Type = this.GetRealType (parameter.Type, is64Bits);
            }

            return result;
        }
Пример #40
0
        private static string GetMethodInvocation(string target, MethodEntity methodEntity, MethodEntity innerMethodEntity, bool hasReturn, bool varargs)
        {
            StringBuilder builder = new StringBuilder ();

            String suffix = varargs ? "VarArgs" : String.Empty;
            if (hasReturn) {
                String returnType = innerMethodEntity != null ? innerMethodEntity.ReturnType : methodEntity.ReturnType;
                builder.AppendFormat ("ObjectiveCRuntime.SendMessage{0}<{1}>", suffix, returnType);
            } else {
                builder.AppendFormat ("ObjectiveCRuntime.SendMessage{0}", suffix);
            }

            String selector = innerMethodEntity != null ? innerMethodEntity.Selector : methodEntity.Selector;
            builder.AppendFormat ("({0}, \"{1}\"", target, selector);
            builder.Append (GetMessageParameterList (methodEntity, innerMethodEntity, true));
            builder.Append (");");

            return builder.ToString ();
        }
        /// <summary>
        ///   Parses the specified method element.
        /// </summary>
        /// <param name = "methodElement">The method element.</param>
        /// <returns></returns>
        public MethodEntity Parse(TypedEntity typedEntity, XElement methodElement)
        {
            MethodEntity methodEntity = new MethodEntity();

            XElement selectorElement = methodElement.Element("h3");
            methodEntity.Selector = selectorElement.TrimAll();
            methodEntity.Name = GetMethodName(methodEntity);

            this.Logger.WriteLine("  Method '" + methodEntity.Selector + "'");

            // Extract signature
            XElement signatureElement = (from el in methodElement.Elements("div")
                                         where (String) el.Attribute("class") == "declaration"
                                         select el).FirstOrDefault();
            methodEntity.Signature = signatureElement.TrimAll();
            methodEntity.Signature = methodEntity.Signature.TrimEnd(';');
            methodEntity.Signature = methodEntity.Signature.Replace(", ...", ",..."); // MethodParametersEnumerator needs this format

            methodEntity.Static = methodEntity.Signature.StartsWith("+");

            // Extract abstract
            XElement abstractElement = (from el in methodElement.Elements("p")
                                        where (String) el.Attribute("class") == "abstract"
                                        select el).FirstOrDefault();
            methodEntity.Summary.Add(abstractElement.TrimAll());

            //// Extract discussion
            //IEnumerable<XElement> paragraphs = (from el in methodElement.Elements("p").Elements("p")
            //                                    where (String) el.Parent.Attribute("class") == "api discussion"
            //                                    select el);
            //foreach (XElement paragraph in paragraphs)
            //{
            //    methodEntity.Summary.Add(paragraph.TrimAll());
            //}

            // Extract return type
            MethodSignatureEnumerator signatureEnumerator = new MethodSignatureEnumerator(methodEntity.Signature);
            if (signatureEnumerator.MoveNext())
            {
                methodEntity.ReturnType = this.TypeManager.ConvertType(signatureEnumerator.Current.TrimAll(), this.Logger);
            }
            else
            {
                methodEntity.ReturnType = "Id";
            }

            // Extract parameter type and name
            MethodParametersEnumerator parameterTypesEnumerator = new MethodParametersEnumerator(methodEntity.Signature, false);
            MethodParametersEnumerator parameterNamesEnumerator = new MethodParametersEnumerator(methodEntity.Signature, true);
            while (parameterTypesEnumerator.MoveNext() && parameterNamesEnumerator.MoveNext())
            {
                MethodParameterEntity parameterEntity = new MethodParameterEntity();
                bool isOut, isByRef, isBlock;
                parameterEntity.Type = this.TypeManager.ConvertType(parameterTypesEnumerator.Current, out isOut, out isByRef, out isBlock, this.Logger);
                parameterEntity.IsOut = isOut;
                parameterEntity.IsByRef = isByRef;
                parameterEntity.IsBlock = isBlock;
                parameterEntity.Name = parameterNamesEnumerator.Current.Trim();
                methodEntity.Parameters.Add(parameterEntity);

                // Correct names that end in a single period
                if (parameterEntity.Name.EndsWith(".") && !parameterEntity.Name.EndsWith("..")) {
                    parameterEntity.Name = parameterEntity.Name.Substring(0, parameterEntity.Name.Length - 1);
                }

                // Handle variadic parameters
                Match r = VARARG_PARAMETER_REGEX.Match (parameterEntity.Name);
                if (r.Success)
                {
                    // Fix the last parameter name by removing "..."
                    parameterEntity.Name = r.Groups [1].Value.Trim ();

                    // Add a new variadic parameter
                    parameterEntity = new MethodParameterEntity();
                    parameterEntity.Type = "params Object[]";
                    parameterEntity.Name = "values";
                    parameterEntity.Summary.Add("Variable argument values");
                    methodEntity.Parameters.Add(parameterEntity);
                }
            }

            // Extract parameter documentation
            if (methodEntity.Parameters.Count > 0)
            {
                XElement termList = (from el in methodElement.Elements("div").Elements("dl")
                                     where (String) el.Parent.Attribute("class") == "api parameters"
                                           && (String) el.Attribute("class") == "termdef"
                                     select el).FirstOrDefault();
                if (termList != null)
                {
                    IEnumerable<XElement> dtList = from el in termList.Elements("dt") select el;
                    IEnumerable<XElement> ddList = from el in termList.Elements("dd") select el;

                    if (dtList.Count() == ddList.Count())
                    {
                        // Iterate over definitions
                        for (int i = 0; i < dtList.Count(); i++)
                        {
                            String term = dtList.ElementAt(i).TrimAll();
                            //String summary = ddList.ElementAt(i).TrimAll();
                            IEnumerable<String> summaries = ddList.ElementAt(i).Elements("p").Select(p => p.Value.TrimAll());

                            // Find the parameter
                            MethodParameterEntity parameterEntity = methodEntity.Parameters.Find(p => String.Equals(p.Name, term) || (VARARG_PARAMETER_REGEX.Match(term).Success && term.StartsWith(p.Name)));
                            if (parameterEntity != null)
                            {
                                //parameterEntity.Summary.Add(summary);
                                foreach (string sum in summaries)
                                {
                                    parameterEntity.Summary.Add(sum);
                                }
                            }
                        }
                    }
                }
            }

            // Fix the name only after looking for the documentation
            for (int i = 0; i < methodEntity.Parameters.Count; i++)
            {
                methodEntity.Parameters[i].Name = this.TypeManager.ConvertName(methodEntity.Parameters[i].Name);
            }

            // Get the summary for return type
            if (!String.Equals(methodEntity.ReturnType, "void", StringComparison.OrdinalIgnoreCase))
            {
                IEnumerable<String> documentations = (from el in methodElement.Elements("div").Elements("p")
                                                      where (String) el.Parent.Attribute("class") == "return_value"
                                                      select el.Value.TrimAll());
                methodEntity.ReturnsDocumentation = String.Join(" ", documentations.ToArray());
            }

            // Get the availability
            String minAvailability = (from el in methodElement.Elements("div").Elements("ul").Elements("li")
                                      where (String) el.Parent.Parent.Attribute("class") == "api availability"
                                      select el.Value).FirstOrDefault();
            methodEntity.MinAvailability = CommentHelper.ExtractAvailability(minAvailability.TrimAll());

            return methodEntity;
        }
        public MethodEntity Parse(TypedEntity typedEntity, XElement methodElement)
        {
            MethodEntity methodEntity = new MethodEntity ();

            bool isStatic = (methodElement.Attribute ("static").Value == "yes");
            String selector = methodElement.Element ("name").TrimAll ();
            String returnType = methodElement.Element ("type").TrimAll ();

            // Elements for brief description
            IEnumerable<XElement> abstractElements = methodElement.Element ("briefdescription").Elements ("para");

            // Extract for detailed description
            IEnumerable<XElement> detailsElements = (from el in methodElement.Element ("detaileddescription").Elements ("para")
                                                     where !el.Elements ("simplesect").Any ()
                && el.Elements ("parameterlist").Any ()
                && el.Elements ("xrefsect").Any ()
                                                     select el);

            // Element for parameters
            IEnumerable<XElement> parameterElements = methodElement.Elements ("param");

            // Element for detailed description
            XElement detailedDescriptionElement = methodElement.Element ("detaileddescription");

            // Sets some data
            methodEntity.Selector = selector;
            methodEntity.Name = GetMethodName (methodEntity);
            methodEntity.Static = isStatic;

            // Add brief description
            foreach (XElement paragraph in abstractElements) {
                methodEntity.Summary.Add (paragraph.TrimAll ());
            }
            foreach (XElement paragraph in detailsElements) {
                methodEntity.Summary.Add (paragraph.TrimAll ());
            }

            // Recreate the signature
            StringBuilder signature = new StringBuilder ();
            signature.Append (isStatic ? "+ " : "- ");
            signature.AppendFormat ("({0})", returnType);
            if (selector.IndexOf (":") != -1) {
                String[] parts = selector.Split (':');
                for (int i = 0; i < parameterElements.Count(); i++) {
                    XElement parameterElement = parameterElements.ElementAt (i);
                    String parameterType = parameterElement.Element ("type").TrimAll ();

                    String parameterName;
                    if (parameterType.Equals ("...")) {
                        parameterName = String.Empty;
                    } else {
                        parameterName = parameterElement.Element ("declname").TrimAll ();
                        if (parameterElement.Element ("defname") != null) {
                            parameterName = parameterElement.Element ("defname").TrimAll ();
                        }
                    }

                    signature.Append (parts [i]);
                    signature.AppendFormat (":({0}){1} ", parameterType, parameterName);
                }
            } else {
                signature.Append (selector);
            }
            methodEntity.Signature = signature.ToString ().Trim () + ";";

            // Set the return type
            methodEntity.ReturnType = this.TypeManager.ConvertType (returnType, this.Logger);

            // Extract documentation for return type
            if (!String.Equals (returnType, "void", StringComparison.OrdinalIgnoreCase)) {
                XElement returnTypeSectionElement = (from el in detailedDescriptionElement.Descendants ("simplesect")
                                                     where el.Attribute ("kind") != null
                    && el.Attribute ("kind").Value == "return"
                                                     select el).FirstOrDefault ();
                if (returnTypeSectionElement != null) {
                    IEnumerable<String> documentations = (from el in returnTypeSectionElement.Elements ("para")
                                                          select el.TrimAll ());
                    methodEntity.ReturnsDocumentation = String.Join (" ", documentations.ToArray ());
                }
            }

            // Create the parameters
            for (int i = 0; i < parameterElements.Count(); i++) {
                XElement parameterElement = parameterElements.ElementAt (i);
                String parameterType = parameterElement.Element ("type").TrimAll ();

                String parameterName;
                if (parameterType.Equals ("...")) {
                    parameterType = "params Object[]";
                    parameterName = "values";
                } else {
                    parameterName = parameterElement.Element ("declname").TrimAll ();
                    if (parameterElement.Element ("defname") != null) {
                        parameterName = parameterElement.Element ("defname").TrimAll ();
                    }
                }

                MethodParameterEntity parameterEntity = new MethodParameterEntity ();
                bool isOut, isByRef, isBlock;
                parameterEntity.Type = this.TypeManager.ConvertType (parameterType, out isOut, out isByRef, out isBlock, this.Logger);
                parameterEntity.IsOut = isOut;
                parameterEntity.IsByRef = isByRef;
                parameterEntity.IsBlock = isBlock;
                parameterEntity.Name = parameterName;
                methodEntity.Parameters.Add (parameterEntity);
            }

            // Extract documentation for parameters
            XElement parameterSectionElement = (from el in detailedDescriptionElement.Descendants ("parameterlist")
                                                where el.Attribute ("kind") != null
                && el.Attribute ("kind").Value == "param"
                                                select el).FirstOrDefault ();
            if (parameterSectionElement != null) {
                IEnumerable<XElement> parameterItemElements = parameterSectionElement.Elements ("parameteritem");
                for (int i = 0; i < parameterElements.Count(); i++) {
                    XElement parameterElement = parameterElements.ElementAt (i);
                    String parameterType = parameterElement.Element ("type").TrimAll ();
                    String parameterName;
                    if (parameterType.Equals ("...")) {
                        continue;
                    } else {
                        parameterName = parameterElement.Element ("declname").TrimAll ();
                        if (parameterElement.Element ("defname") != null) {
                            parameterName = parameterElement.Element ("defname").TrimAll ();
                        }
                    }

                    MethodParameterEntity parameterEntity = methodEntity.Parameters.Find (p => String.Equals (p.Name, parameterName));

                    IEnumerable<XElement> documentations = (from el in parameterItemElements
                                                            let filter = el.Element ("parameternamelist").Value.TrimAll ()
                                                            where String.Equals (filter, parameterName)
                                                            select el);
                    if (documentations.Count () > 0) {
                        XElement documentation = documentations.Elements ("parameterdescription").First ();
                        foreach (XElement element in documentation.Elements("para")) {
                            parameterEntity.Summary.Add (element.TrimAll ());
                        }
                    }
                }
            }

            // Fix the name only after looking for the documentation
            for (int i = 0; i < methodEntity.Parameters.Count; i++) {
                methodEntity.Parameters [i].Name = this.TypeManager.ConvertName (methodEntity.Parameters [i].Name);
            }

            /*
             *
            // Get the availability
            if (availabilityElement != null)
            {
                methodEntity.MinAvailability = CommentHelper.ExtractAvailability(availabilityElement.TrimAll());
            }
             */

            return methodEntity;
        }
Пример #43
0
        protected static String GetMessageParameterList(MethodEntity methodEntity, MethodEntity innerMethodEntity, bool withColonFirst)
        {
            StringBuilder builder = new StringBuilder ();

            int index = 1;
            for (int i = 0; i < methodEntity.Parameters.Count; i++) {
                MethodParameterEntity methodParameterEntity = methodEntity.Parameters [i];
                MethodParameterEntity innerMethodParameterEntity = innerMethodEntity != null ? innerMethodEntity.Parameters [i] : methodParameterEntity;

                if (!innerMethodParameterEntity.Generate) {
                    continue;
                }

                if (i > 0 || withColonFirst) {
                    builder.Append (", ");
                }

                if (innerMethodParameterEntity.IsOut) {
                    builder.AppendFormat ("__local{0}", index++);
                } else if (innerMethodParameterEntity.IsByRef) {
                    builder.AppendFormat ("__local{0}", index++);
                } else if (innerMethodParameterEntity.IsBlock) {
                    builder.AppendFormat ("__local{0}", index++);
                } else {
                    if (String.Equals (methodParameterEntity.Type, innerMethodParameterEntity.Type)) {
                        builder.AppendFormat ("{0}", innerMethodParameterEntity.Name);
                    } else {
                        builder.AppendFormat ("({0}) {1}", innerMethodParameterEntity.Type, innerMethodParameterEntity.Name);
                    }
                }
            }

            return builder.ToString ();
        }
Пример #44
0
        protected static void CollectInformations(MethodEntity methodEntity, ref bool needStorage, ref bool varargs)
        {
            int outParameters = 0;
            int refParameters = 0;
            int blockParameters = 0;
            varargs = false;

            foreach (MethodParameterEntity methodParameterEntity in methodEntity.Parameters.Where(p => p.Generate)) {
                if (methodParameterEntity.IsOut) {
                    outParameters++;
                }
                if (methodParameterEntity.IsByRef) {
                    refParameters++;
                }
                if (methodParameterEntity.IsBlock) {
                    blockParameters++;
                }
                if (!varargs && methodParameterEntity.Type.StartsWith ("params")) {
                    varargs = true;
                }
            }

            needStorage = (outParameters + refParameters + blockParameters) > 0;
        }
Пример #45
0
        protected void GenerateLocalsDeallocation(int indent, MethodEntity methodEntity, MethodEntity innerMethodEntity)
        {
            int index = 1;
            for (int i = 0; i < methodEntity.Parameters.Count; i++) {
                MethodParameterEntity methodParameterEntity = methodEntity.Parameters [i];
                //MethodParameterEntity innerMethodParameterEntity = innerMethodEntity != null ? innerMethodEntity.Parameters [i] : methodParameterEntity;

                if (methodParameterEntity.IsOut || methodParameterEntity.IsByRef) {
                    this.Writer.WriteLineFormat (indent, "Marshal.FreeHGlobal(__local{0});", index++);
                } else if (methodParameterEntity.IsBlock) {
                    this.Writer.WriteLineFormat (indent, "__local{0}.Dispose();", index++);
                }
            }
        }
Пример #46
0
        protected void GenerateLocalsMarshalling(int indent, MethodEntity methodEntity, MethodEntity innerMethodEntity)
        {
            int index = 1;
            for (int i = 0; i < methodEntity.Parameters.Count; i++) {
                MethodParameterEntity methodParameterEntity = methodEntity.Parameters [i];
                MethodParameterEntity innerMethodParameterEntity = innerMethodEntity != null ? innerMethodEntity.Parameters [i] : methodParameterEntity;

                if (methodParameterEntity.IsOut) {
                    if ("bool,char,byte,short,ushort,int,uint,long,ulong".Contains (methodParameterEntity.Type)) { // Boolean
                        // TODO: Add zeroing
                        index++;
                    } else if ("float,double".Contains (methodParameterEntity.Type)) {
                        // TODO: Add zeroing
                        index++;
                    } else if (IsMixedType (methodParameterEntity.Type)) {
                        // TODO: Add zeroing
                        index++;
                    } else {
                        this.Writer.WriteLineFormat (indent, "Marshal.WriteIntPtr(__local{0}, IntPtr.Zero);", index++);
                    }
                } else if (methodParameterEntity.IsByRef) {
                    if (IsMixedType (methodParameterEntity.Type)) {
                        this.Writer.WriteLineFormat (indent, "Marshal.StructureToPtr(({0}) {1}, __local{2}, false);", innerMethodParameterEntity.Type, methodParameterEntity.Name, index++);
                    } else {
                        this.Writer.WriteLineFormat (indent, "Marshal.StructureToPtr({0}, __local{1}, false);", methodParameterEntity.Name, index++);
                    }
                } else if (methodParameterEntity.IsBlock) {
                    index++;
                }
            }
        }
Пример #47
0
 private static String GetTarget(ClassEntity classEntity, MethodEntity methodEntity, bool extension)
 {
     if (methodEntity.Static) {
         if (extension) {
             return String.Format ("{0}.{0}Class", classEntity.Name);
         }
         return String.Format ("{0}Class", classEntity.Name);
     }
     if (extension) {
         return "__target";
     }
     return "this";
 }
Пример #48
0
        private void GenerateConstructorBody(int indent, string target, MethodEntity methodEntity, MethodEntity innerMethodEntity, bool needStorage, bool varargs)
        {
            //bool hasReturn = !String.Equals (methodEntity.ReturnType, "void");
            //bool mixed = (innerMethodEntity != null);

            this.GenerateLocalsAllocation (indent, methodEntity, innerMethodEntity);
            this.GenerateLocalsMarshalling (indent, methodEntity, innerMethodEntity);

            String invocation = GetMethodInvocation (target, methodEntity, innerMethodEntity, true, false);
            this.Writer.WriteLineFormat (indent, "this.NativePointer = {0}", invocation);

            this.GenerateLocalsUnmarshalling (indent, methodEntity, innerMethodEntity);
            this.GenerateLocalsDeallocation (indent, methodEntity, innerMethodEntity);
        }
Пример #49
0
        protected void GenerateLocalsAllocation(int indent, MethodEntity methodEntity, MethodEntity innerMethodEntity)
        {
            int index = 1;
            for (int i = 0; i < methodEntity.Parameters.Count; i++) {
                MethodParameterEntity methodParameterEntity = methodEntity.Parameters [i];
                MethodParameterEntity innerMethodParameterEntity = innerMethodEntity != null ? innerMethodEntity.Parameters [i] : methodParameterEntity;

                if (methodParameterEntity.IsOut || methodParameterEntity.IsByRef) {
                    if ("bool,char,byte,short,ushort,int,uint,long,ulong".Contains (methodParameterEntity.Type)) {
                        this.Writer.WriteLineFormat (indent, "IntPtr __local{0} = Marshal.AllocHGlobal(Marshal.SizeOf(typeof ({1})));", index++, methodParameterEntity.Type);
                    } else if ("IntPtr".Contains (methodParameterEntity.Type)) {
                        this.Writer.WriteLineFormat (indent, "IntPtr __local{0} = Marshal.AllocHGlobal(IntPtr.Size);", index++);
                    } else if ("float,double".Contains (methodParameterEntity.Type)) {
                        this.Writer.WriteLineFormat (indent, "IntPtr __local{0} = Marshal.AllocHGlobal(Marshal.SizeOf(typeof ({1})));", index++, methodParameterEntity.Type);
                    } else if (IsMixedType (methodParameterEntity.Type)) {
                        this.Writer.WriteLineFormat (indent, "IntPtr __local{0} = Marshal.AllocHGlobal(Marshal.SizeOf(typeof ({1})));", index++, innerMethodParameterEntity.Type);
                    } else {
                        this.Writer.WriteLineFormat (indent, "IntPtr __local{0} = Marshal.AllocHGlobal(Marshal.SizeOf(typeof (IntPtr)));", index++);
                    }
                } else if (methodParameterEntity.IsBlock) {
                    this.Writer.WriteLineFormat (indent, "Block __local{0} = ObjectiveCRuntime.CreateBlock({1});", index++, methodParameterEntity.Name);
                }
            }
        }
Пример #50
0
        protected void AppendDocumentation(MethodEntity methodEntity, bool extensionParameter = false, bool opaqueParameter = false)
        {
            // Append method comments
            this.Writer.WriteLineFormat (2, "/// <summary>");
            foreach (String line in methodEntity.Summary) {
                this.Writer.WriteLineFormat (2, "/// <para>{0}</para>", line.EscapeAll ());
            }
            this.Writer.WriteLineFormat (2, "/// <para>Original signature is '{0}'</para>", methodEntity.Signature.EscapeAll ());
            this.AppendAvailability (2, methodEntity);
            this.Writer.WriteLineFormat (2, "/// </summary>");

            // Add extra parameter
            if (extensionParameter) {
                this.Writer.WriteLineFormat (2, "/// <param name=\"__target\">The target instance.</param>");
            }

            // Append parameters' comments
            foreach (MethodParameterEntity methodParameterEntity in methodEntity.Parameters.Where(p => p.Generate)) {
                this.Writer.WriteLineFormat (2, "/// <param name=\"{0}\">{1}</param>", methodParameterEntity.Name.Trim ('@'), methodParameterEntity.Summary.Count > 0 ? methodParameterEntity.Summary [0].EscapeAll () : "MISSING");
            }

            // Append returns' comments
            if (!String.Equals (methodEntity.ReturnType, "void")) {
                this.Writer.WriteLineFormat (2, "/// <returns>{0}</returns>", methodEntity.ReturnsDocumentation.EscapeAll ());
            }
        }
Пример #51
0
 private static string GetExtraParameter(ClassEntity classEntity, MethodEntity methodEntity, bool extension)
 {
     if (extension && !methodEntity.Static) {
         return String.Format ("this {0} __target", classEntity.Name);
     }
     return String.Empty;
 }
Пример #52
0
        /// <summary>
        ///   Generates the specified entity.
        /// </summary>
        /// <param name = "classEntity">The class entity.</param>
        /// <param name = "methodEntity">The method entity.</param>
        /// <param name = "implementation">if set to <c>true</c> generate the implementation.</param>
        /// <param name = "extension">if set to <c>true</c> this method is an extension method.</param>
        public void Generate(ClassEntity classEntity, MethodEntity methodEntity, bool implementation = true, bool extension = false, bool markedAsNew = false)
        {
            // Don't generate if required
            if (!methodEntity.Generate) {
                return;
            }

            // Append static condition if needed
            this.AppendStartCondition (methodEntity);

            // Append documentation
            this.AppendDocumentation (methodEntity, extension && !methodEntity.Static);

            // Append method selector
            if (!implementation) {
                this.Writer.WriteLineFormat (2, "[ObjectiveCMessage(\"{0}\")]", methodEntity.Selector);
            }

            // Append Obsolete attribute
            this.AppendObsoleteAttribute (methodEntity);

            // Create Method signature
            StringBuilder signature = new StringBuilder ();

            // Append keywords
            String keywords = GetKeywords (methodEntity, implementation, extension, markedAsNew);
            signature.Append (keywords);

            // Append return type and name
            signature.AppendFormat ("{0} {1}", methodEntity.ReturnType, methodEntity.Name);
            signature.Append ("(");

            // Append parameters
            List<String> parameters = new List<String> ();
            String extraParameter = GetExtraParameter (classEntity, methodEntity, extension);
            if (!String.IsNullOrEmpty (extraParameter)) {
                parameters.Add (extraParameter);
            }
            foreach (MethodParameterEntity methodParameterEntity in methodEntity.Parameters.Where(p => p.Generate)) {
                parameters.Add (GetTypeSignature (methodParameterEntity));
            }
            signature.Append (String.Join (", ", parameters.ToArray ()));
            signature.Append (")");
            signature.Append (implementation ? String.Empty : ";");

            this.Writer.WriteLineFormat (2, signature.ToString ());

            // Write implementation
            if (implementation) {
                // Collect information
                bool needStorage = false;
                bool varargs = false;
                CollectInformations (methodEntity, ref needStorage, ref varargs);

                // Collect information on 32/64 bits invocations to check if they differ
                MethodEntity methodEntity32 = DeriveMethodEntity (methodEntity, false);
                MethodEntity methodEntity64 = DeriveMethodEntity (methodEntity, true);
                bool useMixedInvocation = !AreMethodTypesEqual (methodEntity32, methodEntity64);

                this.Writer.WriteLineFormat (2, "{{");

                String target = GetTarget (classEntity, methodEntity, extension);

                if (useMixedInvocation && needStorage) {
            #if MIXED_MODE
                    this.Writer.WriteLineFormat(3, "if (ObjectiveCRuntime.Is64Bits)");
                    this.Writer.WriteLineFormat(3, "{{");

                    this.GenerateMethodBody(4, target, methodEntity, methodEntity64, needStorage, varargs);

                    this.Writer.WriteLineFormat(3, "}}");
                    this.Writer.WriteLineFormat(3, "else");
                    this.Writer.WriteLineFormat(3, "{{");
            #endif
                    this.GenerateMethodBody (4, target, methodEntity, methodEntity32, needStorage, varargs);
            #if MIXED_MODE
                    this.Writer.WriteLineFormat(3, "}}");
            #endif
                } else {
                    this.GenerateMethodBody (3, target, methodEntity, null, needStorage, varargs);
                }

                this.Writer.WriteLineFormat (2, "}}");
            }

            // Append static condition if needed
            this.AppendEndCondition(methodEntity);

            // Update statistics
            this.Statistics.Methods++;
        }
        public MethodEntity Parse(TypedEntity typedEntity, String selector, IEnumerable<XElement> elements)
        {
            MethodEntity methodEntity = new MethodEntity();

            XElement declarationElement = (from el in elements
                                           where el.Name == "div" &&
                                                 el.Attribute("class") != null &&
                                                 el.Attribute("class").Value == "declaration_indent"
                                           select el).FirstOrDefault();

            XElement parameterElement = (from el in elements
                                         where el.Name == "div" &&
                                               el.Attribute("class") != null &&
                                               el.Attribute("class").Value == "param_indent"
                                         select el).FirstOrDefault();

            XElement returnValueElement = (from el in elements
                                           where el.Name == "h5" && el.Value.Trim() == "Return Value"
                                           select el).FirstOrDefault();

            //XElement discussionElement = (from el in elements
            //                              where el.Name == "h5" && el.Value.Trim() == "Discussion"
            //                              select el).FirstOrDefault();

            XElement availabilityElement = (from el in elements
                                            let term = el.Descendants("dt").FirstOrDefault()
                                            let definition = el.Descendants("dd").FirstOrDefault()
                                            where el.Name == "dl" &&
                                                  term != null &&
                                                  term.Value.Trim() == "Availability"
                                            select definition).FirstOrDefault();

            methodEntity.Selector = selector;
            methodEntity.Name = GetMethodName(methodEntity);

            methodEntity.Signature = declarationElement.TrimAll();
            methodEntity.Signature = methodEntity.Signature.TrimEnd(';');

            methodEntity.Static = methodEntity.Signature.StartsWith("+");

            // Extract abstract
            IEnumerable<XElement> abstractElements = elements.SkipWhile(el => el.Name != "p").TakeWhile(el => el.Name == "p");
            foreach (XElement element in abstractElements)
            {
                String line = element.TrimAll();
                if (!String.IsNullOrEmpty(line))
                {
                    methodEntity.Summary.Add(line);
                }
            }

            //// Extract discussion
            //if (discussionElement != null)
            //{
            //    IEnumerable<XElement> discussionElements = discussionElement.ElementsAfterSelf().TakeWhile(el => el.Name == "p");
            //    foreach (XElement element in discussionElements)
            //    {
            //        String line = element.TrimAll();
            //        if (!String.IsNullOrEmpty(line))
            //        {
            //            methodEntity.Summary.Add(line);
            //        }
            //    }
            //}

            // Extract return type
            MethodSignatureEnumerator signatureEnumerator = new MethodSignatureEnumerator(methodEntity.Signature);
            if (signatureEnumerator.MoveNext())
            {
                methodEntity.ReturnType = this.TypeManager.ConvertType(signatureEnumerator.Current.TrimAll(), this.Logger);
            }
            else
            {
                methodEntity.ReturnType = "Id";
            }

            // Extract parameter type and name
            MethodParametersEnumerator parameterTypesEnumerator = new MethodParametersEnumerator(methodEntity.Signature, false);
            MethodParametersEnumerator parameterNamesEnumerator = new MethodParametersEnumerator(methodEntity.Signature, true);
            while (parameterTypesEnumerator.MoveNext() && parameterNamesEnumerator.MoveNext())
            {
                MethodParameterEntity parameterEntity = new MethodParameterEntity();
                bool isOut, isByRef, isBlock;
                parameterEntity.Type = this.TypeManager.ConvertType(parameterTypesEnumerator.Current, out isOut, out isByRef, out isBlock, this.Logger);
                parameterEntity.IsOut = isOut;
                parameterEntity.IsByRef = isByRef;
                parameterEntity.IsBlock = isBlock;
                parameterEntity.Name = parameterNamesEnumerator.Current.Trim();
                methodEntity.Parameters.Add(parameterEntity);
            }

            if (methodEntity.Parameters.Count > 0 && parameterElement != null)
            {
                XElement termList = parameterElement.Descendants("dl").FirstOrDefault();
                if (termList != null)
                {
                    IEnumerable<XElement> dtList = from el in termList.Elements("dt") select el;
                    IEnumerable<XElement> ddList = from el in termList.Elements("dd") select el;

                    if (dtList.Count() == ddList.Count())
                    {
                        // Iterate over definitions
                        for (int i = 0; i < dtList.Count(); i++)
                        {
                            String term = dtList.ElementAt(i).TrimAll();
                            //String summary = ddList.ElementAt(i).TrimAll();
                            IEnumerable<String> summaries = ddList.ElementAt(i).Elements("p").Select(p => p.Value.TrimAll());

                            // Find the parameter
                            MethodParameterEntity parameterEntity = methodEntity.Parameters.Find(p => String.Equals(p.Name, term));
                            if (parameterEntity != null)
                            {
                                //parameterEntity.Summary.Add(summary);
                                foreach (string sum in summaries)
                                {
                                    parameterEntity.Summary.Add(sum);
                                }
                            }
                        }
                    }
                }
            }

            // Fix the name only after looking for the documentation
            for (int i = 0; i < methodEntity.Parameters.Count; i++)
            {
                methodEntity.Parameters[i].Name = this.TypeManager.ConvertName(methodEntity.Parameters[i].Name);
            }

            // Get the summary for return type
            if (!String.Equals(methodEntity.ReturnType, "void", StringComparison.OrdinalIgnoreCase) && returnValueElement != null)
            {
                IEnumerable<XElement> returnTypeElements = returnValueElement.ElementsAfterSelf().TakeWhile(el => el.Name == "p");
                methodEntity.ReturnsDocumentation = String.Empty;
                foreach (XElement element in returnTypeElements)
                {
                    String line = element.TrimAll();
                    if (!String.IsNullOrEmpty(line))
                    {
                        methodEntity.ReturnsDocumentation += line;
                    }
                }
            }

            // Get the availability
            if (availabilityElement != null)
            {
                methodEntity.MinAvailability = CommentHelper.ExtractAvailability(availabilityElement.TrimAll());
            }

            return methodEntity;
        }
Пример #54
0
        public void GenerateConstructor(ClassEntity classEntity, MethodEntity methodEntity)
        {
            // Don't generate if required
            if (!methodEntity.Generate) {
                return;
            }

            // Clone the method and change the return type
            methodEntity = new MethodEntity (methodEntity);
            methodEntity.ReturnType = "IntPtr";

            // Collect information
            bool needStorage = false;
            bool varargs = false;
            CollectInformations (methodEntity, ref needStorage, ref varargs);

            // Don't generate if varargs
            if (varargs) {
                return;
            }

            // Collect information about the return type and the parameters
            bool hasReturn = !String.Equals (methodEntity.ReturnType, "void");
            bool hasReturnParameters = hasReturn && needStorage;

            // Collect information on 32/64 bits invocations to check if they differ
            MethodEntity methodEntity32 = DeriveMethodEntity (methodEntity, false);
            MethodEntity methodEntity64 = DeriveMethodEntity (methodEntity, true);
            bool useMixedInvocation = false; // !AreMethodTypesEqual(methodEntity32, methodEntity64);

            // Append static condition if needed
            this.AppendStartCondition (methodEntity);

            // Append documentation
            this.AppendDocumentation (methodEntity);

            // Append Method signature
            StringBuilder signature = new StringBuilder ();
            signature.AppendFormat ("public {0}(", classEntity.Name);

            // Append parameters
            List<String> parameters = new List<String> ();
            foreach (MethodParameterEntity methodParameterEntity in methodEntity.Parameters.Where(p => p.Generate)) {
                parameters.Add (GetTypeSignature (methodParameterEntity));
            }
            signature.Append (String.Join (", ", parameters.ToArray ()));
            signature.Append (")");

            this.Writer.WriteLineFormat (2, signature.ToString ());

            // Write base call
            StringBuilder baseCall = new StringBuilder ();
            if (useMixedInvocation || hasReturnParameters) {
                baseCall.AppendFormat (" : this(ObjectiveCRuntime.SendMessage<IntPtr>({0}Class, \"alloc\"))", classEntity.Name);
            } else {
                baseCall.AppendFormat (" : base(\"{0}\"", methodEntity.Selector);
                foreach (MethodParameterEntity methodParameterEntity in methodEntity.Parameters.Where(p => p.Generate)) {
                    baseCall.AppendFormat (", {0}", methodParameterEntity.Name);
                }
                baseCall.Append (")");
            }
            this.Writer.WriteLineFormat (3, baseCall.ToString ());

            // Write implementation
            this.Writer.WriteLineFormat (2, "{{");

            String target = "this";
            if (useMixedInvocation) {
            #if MIXED_MODE
                this.Writer.WriteLineFormat(3, "if (ObjectiveCRuntime.Is64Bits)");
                this.Writer.WriteLineFormat(3, "{{");

                this.GenerateConstructorBody(4, target, methodEntity, methodEntity64, needStorage, varargs);

                this.Writer.WriteLineFormat(3, "}}");
                this.Writer.WriteLineFormat(3, "else");
                this.Writer.WriteLineFormat(3, "{{");
            #endif
                this.GenerateConstructorBody (4, target, methodEntity, methodEntity32, needStorage, varargs);
            #if MIXED_MODE
                this.Writer.WriteLineFormat(3, "}}");
            #endif
            } else if (hasReturnParameters) {
                this.GenerateConstructorBody (4, target, methodEntity, null, needStorage, varargs);
            }

            this.Writer.WriteLineFormat (2, "}}");

            // Append static condition if needed
            this.AppendEndCondition (methodEntity);

            // Update statistics
            this.Statistics.Methods++;
        }