Example #1
0
        public IKeyword Parse(ActionScriptReader acr)
        {
            InstanceName = acr.ReadString().Split(',')[1].Split('"')[1];
            if (acr.PeekString().Contains("extends"))
            {
                Extends = acr.ReadString().Split(',')[1].Split('"')[1];
            }

            // Skip everything until method traits
            // TODO: Implement loading all other information later
DoCycle:
            while (!acr.PeekString().Contains("trait method") && !acr.PeekString().Contains("end ; instance"))
            {
                string xa;
                xa = acr.ReadString();
            }

            if (acr.PeekString().Contains("end ; instance"))
            {
                return(this);
            }

            QName method = new QName(acr.ReadString());

            MethodKeyword mk = new MethodKeyword(acr);

            Methods.Add(mk);

            goto DoCycle;
        }
        public void 方法关键字转换属性关键字()
        {
            MethodKeyword   methodKeyword   = MethodKeyword.Abstract;
            PropertyKeyword propertyKeyword = EnumCache.ToPropertyKeyword(methodKeyword);

            Assert.Equal(PropertyKeyword.Abstract, propertyKeyword);
        }
        public void 方法关键字()
        {
            MethodKeyword methodKeyword = MethodKeyword.Abstract;
            var           output        = EnumCache.GetMethodKeyword(methodKeyword);

            Assert.Equal("abstract", output);

            output = EnumCache.GetValue(methodKeyword);
            Assert.Equal("abstract", output);
        }
Example #4
0
        public static PropertyKeyword ToPropertyKeyword(this MethodKeyword keyword)
        {
            switch (keyword)
            {
            case MethodKeyword.Default: return(PropertyKeyword.Default);

            case MethodKeyword.Static: return(PropertyKeyword.Static);

            case MethodKeyword.Abstract: return(PropertyKeyword.Abstract);

            case MethodKeyword.Virtual: return(PropertyKeyword.Virtual);

            case MethodKeyword.Override: return(PropertyKeyword.Override);

            case MethodKeyword.SealedOverride: return(PropertyKeyword.SealedOverride);

            case MethodKeyword.NewVirtual: return(PropertyKeyword.NewVirtual);

            case MethodKeyword.NewStatic: return(PropertyKeyword.NewStatic);
            }
            throw new NotSupportedException("不支持此转换!");
        }
Example #5
0
 /// <summary>
 /// 设置方法的关键字修饰符,如 static,virtual、override
 /// </summary>
 /// <param name="keyword">关键字</param>
 /// <returns></returns>
 public TBuilder WithKeyword(MethodKeyword keyword = MethodKeyword.Default)
 {
     _method.Keyword = EnumCache.GetValue(keyword);
     return(_TBuilder);
 }
Example #6
0
 /// <summary>
 /// 获取 <see cref="MethodKeyword"/> 枚举代表的信息
 /// </summary>
 /// <param name="value">枚举</param>
 /// <returns>方法修饰符</returns>
 public static string GetMethodKeyword(MethodKeyword value)
 {
     return(_MethodKeyword.Value[value]);
 }
Example #7
0
        /// <summary>
        /// 判断方法的访问修饰符
        /// <para>暂不支持 new static</para>
        /// </summary>
        /// <param name="info">字段</param>
        /// <returns><see cref="MethodKeyword"/></returns>
        public static MethodKeyword GetMethodKeyword(MethodInfo info)
        {
            if (info is null)
            {
                throw new ArgumentNullException(nameof(info));
            }

            MethodAttributes attributes    = info.Attributes;
            MethodKeyword    methodKeyword = MethodKeyword.Default;

            // extern 方法
            if ((attributes | MethodAttributes.PinvokeImpl) == attributes)
            {
                return(MethodKeyword.StaticExtern);
            }

            // 函数是否在本类型中 实现
            bool isLocalDefinition = info.IsNew();

            // 是否使用了 new
            bool isHasNewSlot = (info.Attributes & MethodAttributes.VtableLayoutMask) == MethodAttributes.NewSlot;

            // abstract
            if ((attributes | MethodAttributes.Abstract) == attributes)
            {
                return(MethodKeyword.Abstract);
            }


            if (info.IsStatic)
            {
                // static
                methodKeyword = methodKeyword | MethodKeyword.Static;
                // new static
                if (isHasNewSlot)
                {
                    methodKeyword = methodKeyword | MethodKeyword.New;
                }
                return(methodKeyword);
            }

            // 继承接口的实现、virtual、new virtual
            if ((attributes | MethodAttributes.VtableLayoutMask) == attributes)
            {
                // 继承的接口实现
                if ((attributes | MethodAttributes.Final) == attributes)
                {
                    return(MethodKeyword.Default);
                }

                if (isLocalDefinition)
                {
                    return(MethodKeyword.NewVirtual);
                }

                return(MethodKeyword.Virtual);
            }

            // override、sealed override
            if (info.IsVirtual)
            {
                // override
                if (info.IsFinal)
                {
                    return(MethodKeyword.Override);
                }
                // new override
                else
                {
                    return(MethodKeyword.SealedOverride);
                }
            }

            if (isLocalDefinition)
            {
                return(MethodKeyword.New);
            }

            return(MethodKeyword.Default);
        }
 /// <summary>
 /// 设置方法的关键字修饰符,如 static,virtual、override
 /// </summary>
 /// <param name="keyword">关键字</param>
 /// <returns></returns>
 public TBuilder WithKeyword(MethodKeyword keyword = MethodKeyword.Default)
 {
     _method.Keyword = RoslynHelper.GetName(keyword);
     return(_TBuilder);
 }