示例#1
0
        public static IParsingResult Parse(ParsingContext context)
        {
            RewindState    rewind = context.RewindState;
            IParsingResult expression;

            if (context.Parser.VerifyString("X"))
            {
                expression = Expression.Parse(context);
                if (expression != null && context.Parser.VerifyString("E"))
                {
                    return(expression);
                }
                context.Rewind(rewind);
                return(null);
            }

            expression = ExprPrimary.Parse(context);
            if (expression != null)
            {
                return(expression);
            }

            IParsingResult type = Type.Parse(context);

            if (type != null)
            {
                return(type);
            }

            if (context.Parser.VerifyString("J"))
            {
                List <IParsingResult> arguments = CxxDemangler.ParseList(TemplateArg.Parse, context);

                if (context.Parser.VerifyString("E"))
                {
                    return(new ArgPack(arguments));
                }
                context.Rewind(rewind);
                return(null);
            }
            return(null);
        }
示例#2
0
        public static IParsingResult Parse(ParsingContext context)
        {
            RewindState rewind = context.RewindState;

            if (context.Parser.VerifyString("pp_"))
            {
                return(Parse <PrefixInc>(rewind, context, Expression.Parse));
            }
            if (context.Parser.VerifyString("mm_"))
            {
                return(Parse <PrefixDec>(rewind, context, Expression.Parse));
            }
            if (context.Parser.VerifyString("cl"))
            {
                return(Parse <Call>(rewind, context, Expression.Parse, ZeroOrMore(Expression.Parse)));
            }
            if (context.Parser.VerifyString("cv"))
            {
                IParsingResult type = Type.Parse(context);

                if (type != null)
                {
                    if (context.Parser.VerifyString("_"))
                    {
                        List <IParsingResult> expressions = CxxDemangler.ParseList(Expression.Parse, context);

                        if (context.Parser.VerifyString("E"))
                        {
                            return(new ConversionMany(type, expressions));
                        }
                    }
                    else
                    {
                        IParsingResult expression = Expression.Parse(context);

                        if (expression != null)
                        {
                            return(new ConversionOne(type, expression));
                        }
                    }
                }
                context.Rewind(rewind);
                return(null);
            }
            if (context.Parser.VerifyString("tl"))
            {
                return(ParseWithEnd <ConversionBraced>(rewind, context, Type.Parse, ZeroOrMore(Expression.Parse)));
            }
            if (context.Parser.VerifyString("il"))
            {
                return(ParseWithEnd <BracedInitList>(rewind, context, Expression.Parse));
            }
            if (context.Parser.VerifyString("dc"))
            {
                return(Parse <DynamicCast>(rewind, context, Type.Parse, Expression.Parse));
            }
            if (context.Parser.VerifyString("sc"))
            {
                return(Parse <StaticCast>(rewind, context, Type.Parse, Expression.Parse));
            }
            if (context.Parser.VerifyString("cc"))
            {
                return(Parse <ConstCast>(rewind, context, Type.Parse, Expression.Parse));
            }
            if (context.Parser.VerifyString("rc"))
            {
                return(Parse <ReinterpretCast>(rewind, context, Type.Parse, Expression.Parse));
            }
            if (context.Parser.VerifyString("ti"))
            {
                return(Parse <TypeIdType>(rewind, context, Type.Parse));
            }
            if (context.Parser.VerifyString("te"))
            {
                return(Parse <TypeIdExpression>(rewind, context, Expression.Parse));
            }
            if (context.Parser.VerifyString("st"))
            {
                return(Parse <SizeOfType>(rewind, context, Type.Parse));
            }
            if (context.Parser.VerifyString("sz"))
            {
                return(Parse <SizeOfExpression>(rewind, context, Expression.Parse));
            }
            if (context.Parser.VerifyString("at"))
            {
                return(Parse <AlignOfType>(rewind, context, Type.Parse));
            }
            if (context.Parser.VerifyString("az"))
            {
                return(Parse <AlignOfExpression>(rewind, context, Expression.Parse));
            }
            if (context.Parser.VerifyString("nx"))
            {
                return(Parse <Noexcept>(rewind, context, Expression.Parse));
            }
            if (context.Parser.VerifyString("dt"))
            {
                return(Parse <Member>(rewind, context, Expression.Parse, UnresolvedName.Parse));
            }
            if (context.Parser.VerifyString("pt"))
            {
                return(Parse <DeferMember>(rewind, context, Expression.Parse, UnresolvedName.Parse));
            }
            if (context.Parser.VerifyString("ds"))
            {
                return(Parse <PointerToMember>(rewind, context, Expression.Parse, Expression.Parse));
            }
            if (context.Parser.VerifyString("sZ"))
            {
                IParsingResult param = TemplateParam.Parse(context);

                if (param != null)
                {
                    return(new SizeOfTemplatepack(param));
                }
                param = FunctionParam.Parse(context);
                if (param != null)
                {
                    return(new SizeOfFunctionPack(param));
                }
                context.Rewind(rewind);
                return(null);
            }
            if (context.Parser.VerifyString("sP"))
            {
                return(ParseWithEnd <SizeofCapturedTemplatePack>(rewind, context, ZeroOrMore(TemplateArg.Parse)));
            }
            if (context.Parser.VerifyString("sp"))
            {
                return(Parse <PackExpansion>(rewind, context, Expression.Parse));
            }
            if (context.Parser.VerifyString("tw"))
            {
                return(Parse <Throw>(rewind, context, Expression.Parse));
            }
            if (context.Parser.VerifyString("tr"))
            {
                return(new Retrow());
            }
            if (context.Parser.VerifyString("gs"))
            {
                return(CanBeGlobal(rewind, context, true));
            }

            IParsingResult result = CanBeGlobal(rewind, context, false) ?? TemplateParam.Parse(context) ?? FunctionParam.Parse(context)
                                    ?? UnresolvedName.Parse(context) ?? ExprPrimary.Parse(context);

            if (result != null)
            {
                return(result);
            }

            IParsingResult operatorName = OperatorName.Parse(context);

            if (operatorName != null)
            {
                IParsingResult first = Expression.Parse(context);

                if (first != null)
                {
                    IParsingResult second = Expression.Parse(context);

                    if (second != null)
                    {
                        IParsingResult third = Expression.Parse(context);

                        if (third != null)
                        {
                            return(new Ternary(operatorName, first, second, third));
                        }
                        else
                        {
                            return(new Binary(operatorName, first, second));
                        }
                    }
                    else
                    {
                        return(new Unary(operatorName, first));
                    }
                }
                context.Rewind(rewind);
                return(null);
            }
            return(null);
        }