Ejemplo n.º 1
0
        private static string ConstructorDestructorMatcher(Match m)
        {
            string extras = StringConvertUtils.ConvertArgsToString(m.Groups[2].ToString());
            string front  = m.Groups[0].ToString().StartsWith("~") ? "dtor" : "ctor";

            return(String.Concat(front, extras));
        }
Ejemplo n.º 2
0
        internal static void InitRegexList(out RegexMatcher[] regexList)
        {
            regexList = new[]
            {
                new RegexMatcher(ImplOperatorMarker,
                                 m =>
                {
                    string ret    = m.Groups[1].ToString();
                    string extras = StringConvertUtils.ConvertArgsToString(m.Groups[2].ToString());
                    return(String.Concat("implop_", ret, extras));
                }, "IMPLICIT OPERATOR"),

                new RegexMatcher(IndexerMarker,
                                 m =>
                {
                    string extras = StringConvertUtils.ConvertArgsToString(m.Groups[2].ToString());
                    return(String.Concat("this", extras));
                }, "INDEXER",
                                 m => "this"),
                new RegexMatcher(MethodMarker,
                                 m =>
                {
                    string extras = StringConvertUtils.ConvertArgsToString(m.Groups[5].ToString());
                    if (m.Groups[4].ToString() != "")
                    {
                        extras = StringConvertUtils.ConvertArgsToString(m.Groups[4].ToString(), '<', '>') + extras;
                    }
                    return(String.Concat(m.Groups[2].ToString(), extras));
                }, "METHOD",
                                 m => m.Groups[2].ToString()),
                new RegexMatcher(OperatorMarker,
                                 m =>
                {
                    string name   = StringConvertUtils.ConvertOperator(m.Groups[2].ToString());
                    string extras = StringConvertUtils.ConvertArgsToString(m.Groups[3].ToString());
                    return(String.Concat(name, extras));
                }, "OPERATOR",
                                 m => "op_" + StringConvertUtils.ConvertOperator(m.Groups[2].ToString())),
                new RegexMatcher(FieldAssignmentMarker, DefaultMatcher, "FIELD ASSIGNMENT"),
                new RegexMatcher(FieldMarker, DefaultMatcher, "FIELD"),

                new RegexMatcher(ConstMarker, DefaultMatcher, "CONST"),
                new RegexMatcher(ConstructorMarker, ConstructorDestructorMatcher, "CONSTRUCTOR", ConstructorDestructorMatcherSimplified),

                new RegexMatcher(DestructorMarker, ConstructorDestructorMatcher, "DESTRUCTOR", ConstructorDestructorMatcherSimplified),
                new RegexMatcher(EnumEntryAssignmentMarker,
                                 m => m.Groups[1].ToString(), "ENUM_ENTRY"),
                new RegexMatcher(EnumEntryNoAssignment,
                                 m => m.Groups[1].ToString(), "ENUM_ENTRY_NOASS"),
            };
        }
Ejemplo n.º 3
0
        internal static void InitRegexList(out RegexMatcher[] regexList)
        {
            regexList = new[]
            {
                new RegexMatcher(ImplOperatorMarker,
                                 m =>
                {
                    string ret    = m.Groups[1].ToString();
                    string extras = StringConvertUtils.ConvertArgsToString(m.Groups[2].ToString());
                    return(String.Concat("implop_", ret, extras));
                }, "IMPLICIT OPERATOR"),

                new RegexMatcher(ImplOperatorFromAssembly,
                                 m =>
                {
                    string ret    = m.Groups[1].ToString();
                    string extras = StringConvertUtils.ConvertArgsToString(m.Groups[2].ToString());
                    return(String.Concat("implop_", ret, extras));
                }, "IMPLICIT OPERATOR"),
                new RegexMatcher(OperatorFromAssembly,
                                 m =>
                {
                    string name   = StringConvertUtils.ConvertOperatorFromAssembly(m.Groups[2].ToString());
                    string extras = StringConvertUtils.ConvertArgsToString(m.Groups[3].ToString());
                    return(String.Concat(name, extras));
                }, "OPERATOR"),
                new RegexMatcher(IndexerMarker,
                                 m =>
                {
                    string extras = StringConvertUtils.ConvertArgsToString(m.Groups[2].ToString());
                    return(String.Concat("this", extras));
                }, "INDEXER"),
                new RegexMatcher(MethodMarker,
                                 m =>
                {
                    string extras = StringConvertUtils.ConvertArgsToString(m.Groups[3].ToString());
                    return(String.Concat(m.Groups[2].ToString(), extras));
                }, "METHOD",
                                 m => m.Groups[2].ToString()),
                new RegexMatcher(OperatorMarker,
                                 m =>
                {
                    string name   = StringConvertUtils.ConvertOperator(m.Groups[2].ToString());
                    string extras = StringConvertUtils.ConvertArgsToString(m.Groups[3].ToString());
                    return(String.Concat(name, extras));
                }, "OPERATOR"),
                new RegexMatcher(FieldAssignmentMarker, DefaultMatcher, "FIELD ASSIGNMENT"),
                new RegexMatcher(FieldMarker, DefaultMatcher, "FIELD"),

                new RegexMatcher(ConstMarker, DefaultMatcher, "CONST"),
                new RegexMatcher(ConstructorMarker, ConstructorDestructorMatcher,
                                 "CONSTRUCTOR",
                                 m => "ctor"),

                new RegexMatcher(DestructorMarker, ConstructorDestructorMatcher, "DESTRUCTOR"),
                new RegexMatcher(ConstructorFromAssemblyMarker,
                                 m =>
                {
                    var sb = new StringBuilder(m.Groups[0].ToString());
                    sb.Replace("Void .ctor(", "");
                    sb.Replace(")", "");

                    string args = StringConvertUtils.ConvertArgsToString(sb.ToString());
                    return(String.Concat("ctor", args));
                },
                                 "CONSTRUCTOR_ASSEMBLY"),
                new RegexMatcher(EnumEntryAssignmentMarker,
                                 m => m.Groups[1].ToString(), "ENUM_ENTRY"),
                new RegexMatcher(EnumEntryNoAssignment,
                                 m => m.Groups[1].ToString(), "ENUM_ENTRY_NOASS"),
            };
        }