Пример #1
0
        public override IMatched <Unit> ParseStatement(ParseState state, Token[] tokens)
        {
            var className = tokens[3].Text;

            state.Colorize(tokens, Color.Keyword, Color.Whitespace, Color.Class, Color.Whitespace);

            var parameters = Parameters.Empty;

            var parentClassName = "";
            var arguments       = new Expression[0];

            Module.Global.ForwardReference(className);

            var builder = new ClassBuilder(className, parameters, parentClassName, arguments, false, new Block(), new List <Mixin>());

            if (builder.Register().ValueOrOriginal(out _, out var registerOriginal))
            {
                var cls = new Class(builder);
                state.AddStatement(cls);

                if (getBlock(state).ValueOrCast <Unit>(out var block, out var asUnit))
                {
                    var metaClassName    = $"__$meta{className}";
                    var metaClassBuilder = new ClassBuilder(metaClassName, Parameters.Empty, "", new Expression[0], false, block,
                                                            new List <Mixin>());
                    if (metaClassBuilder.Register().ValueOrOriginal(out _, out registerOriginal))
                    {
                        var metaClass = new MetaClass(className, metaClassBuilder);
                        state.AddStatement(metaClass);

                        return(Unit.Matched());
                    }
                    else
                    {
                        return(registerOriginal);
                    }
                }
                else
                {
                    return(asUnit);
                }
            }
Пример #2
0
        public override IMatched <Unit> ParseStatement(ParseState state, Token[] tokens)
        {
            var className = tokens[3].Text;

            state.Colorize(tokens, Color.Keyword, Color.Whitespace, Color.Class, Color.OpenParenthesis);

            if (getParameters(state).ValueOrCast <Unit>(out var parameters, out var asUnit))
            {
                var parentClassParser = new ParentClassParser();

                var parentClassName = "";
                var arguments       = new Expression[0];
                if (parentClassParser.Scan(state).If(out _, out var anyException))
                {
                    (parentClassName, _, arguments) = parentClassParser.Parent;
                }
                else if (anyException.If(out var exception))
                {
                    return(failedMatch <Unit>(exception));
                }

                Module.Global.ForwardReference(className);

                var builder = new ClassBuilder(className, parameters, parentClassName, arguments, false, new Block(), new List <Mixin>());
                if (builder.Register().ValueOrOriginal(out _, out var original))
                {
                    var cls = new Class(builder);
                    state.AddStatement(cls);

                    return(Unit.Matched());
                }
                else
                {
                    return(original);
                }
            }