Пример #1
0
            public void Demangle(DemanglingContext context)
            {
                SimpleOperatorName question = OperatorName as SimpleOperatorName;

                if (question.Value == SimpleOperatorName.Values.Question)
                {
                    FirstExpression.Demangle(context);
                    context.Writer.Append(" ? ");
                    SecondExpression.Demangle(context);
                    context.Writer.Append(" : ");
                    ThirdExpression.Demangle(context);
                }
                else
                {
                    // Nonsensical ternary operator? Just print it like a function call,
                    // I suppose...
                    //
                    // TODO: should we detect and reject this during parsing?
                    OperatorName.Demangle(context);
                    context.Writer.Append("(");
                    FirstExpression.Demangle(context);
                    context.Writer.Append(", ");
                    SecondExpression.Demangle(context);
                    context.Writer.Append(", ");
                    ThirdExpression.Demangle(context);
                    context.Writer.Append(")");
                }
            }
Пример #2
0
 public void Demangle(DemanglingContext context)
 {
     context.Writer.Append("(");
     FirstExpression.Demangle(context);
     context.Writer.Append(")");
     OperatorName.Demangle(context);
     context.Writer.Append("(");
     SecondExpression.Demangle(context);
     context.Writer.Append(")");
 }
Пример #3
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);
        }
Пример #4
0
 public void Demangle(DemanglingContext context)
 {
     OperatorName.Demangle(context);
     context.Writer.Append(" ");
     Expression.Demangle(context);
 }