private static Func <ParsingContext, List <IParsingResult> > ZeroOrMore(CxxDemangler.ParsingFunction parser)
{
return((ParsingContext context) =>
{
return CxxDemangler.ParseList(parser, context);
});
}
internal ParsingContext CreateContext(string input)
{
ParsingContext context = CxxDemangler.CreateContext(input);
foreach (IParsingResult substitution in SubstitutionTableList())
{
context.SubstitutionTable.Add(substitution);
}
return(context);
}
public static BareFunctionType Parse(ParsingContext context)
{
List <IParsingResult> types = CxxDemangler.ParseList(Type.Parse, context);
if (types.Count > 0)
{
return(new BareFunctionType(types));
}
return(null);
}
public static IParsingResult Parse(ParsingContext context)
{
if (context.Parser.VerifyString("v"))
{
return(new LambdaSig(new IParsingResult[0]));
}
List <IParsingResult> argumentTypes = CxxDemangler.ParseList(Type.Parse, context);
if (argumentTypes.Count > 0)
{
return(new LambdaSig(argumentTypes));
}
return(null);
}
public static TemplateArgs Parse(ParsingContext context)
{
RewindState rewind = context.RewindState;
if (context.Parser.VerifyString("I"))
{
List <IParsingResult> args = CxxDemangler.ParseList(TemplateArg.Parse, context);
if (args.Count > 0 && context.Parser.VerifyString("E"))
{
return(new TemplateArgs(args));
}
context.Rewind(rewind);
}
return(null);
}
static void Main(string[] args)
{
if (args.Length == 0)
{
System.Console.WriteLine("Example demangling:");
System.Console.WriteLine(CxxDemangler.Demangle("_ZTVSt15_Sp_counted_ptrIPiLN9__gnu_cxx12_Lock_policyE2EE"));
System.Console.WriteLine(CxxDemangler.Demangle("_ZTVSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE"));
System.Console.WriteLine(CxxDemangler.Demangle("_ZTVSt23_Sp_counted_ptr_inplaceIiSaIiELN9__gnu_cxx12_Lock_policyE2EE"));
}
else
{
for (int i = 0; i < args.Length; i++)
{
System.Console.WriteLine(CxxDemangler.Demangle(args[i]));
}
}
}
public static IParsingResult Parse(ParsingContext context)
{
RewindState rewind = context.RewindState;
if (!context.Parser.VerifyString("pi"))
{
return(null);
}
List <IParsingResult> expressions = CxxDemangler.ParseList(Expression.Parse, context);
if (context.Parser.VerifyString("E"))
{
return(new Initializer(expressions));
}
context.Rewind(rewind);
return(null);
}
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);
}
public static IParsingResult Parse(ParsingContext context)
{
RewindState rewind = context.RewindState;
IParsingResult name, type;
List <IParsingResult> levels;
if (context.Parser.VerifyString("gs"))
{
name = BaseUnresolvedName.Parse(context);
if (name != null)
{
return(new Global(name));
}
if (context.Parser.VerifyString("sr"))
{
levels = CxxDemangler.ParseList(UnresolvedQualifierLevel.Parse, context);
if (levels.Count > 0 && context.Parser.VerifyString("E"))
{
name = BaseUnresolvedName.Parse(context);
if (name != null)
{
return(new GlobalNested2(levels, name));
}
}
}
context.Rewind(rewind);
return(null);
}
name = BaseUnresolvedName.Parse(context);
if (name != null)
{
return(name);
}
if (!context.Parser.VerifyString("sr"))
{
return(null);
}
if (context.Parser.VerifyString("N"))
{
type = UnresolvedType.Parse(context);
if (type != null)
{
levels = CxxDemangler.ParseList(UnresolvedQualifierLevel.Parse, context);
if (levels.Count > 0 && context.Parser.VerifyString("E"))
{
name = BaseUnresolvedName.Parse(context);
if (name != null)
{
return(new Nested1(type, levels, name));
}
}
}
context.Rewind(rewind);
return(null);
}
type = UnresolvedType.Parse(context);
if (type != null)
{
name = BaseUnresolvedName.Parse(context);
if (name != null)
{
return(new Nested1(type, new List <IParsingResult>(), name));
}
context.Rewind(rewind);
return(null);
}
levels = CxxDemangler.ParseList(UnresolvedQualifierLevel.Parse, context);
if (levels.Count > 0 && context.Parser.VerifyString("E"))
{
name = BaseUnresolvedName.Parse(context);
if (name != null)
{
return(new Nested2(levels, name));
}
}
context.Rewind(rewind);
return(null);
}
private void Verify(string input, string expectedOutput)
{
string actualOutput = CxxDemangler.Demangle(input);
Assert.AreEqual(expectedOutput, actualOutput);
}
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);
}
private static IParsingResult CanBeGlobal(RewindState rewind, ParsingContext context, bool isGlobal)
{
if (context.Parser.VerifyString("nw"))
{
List <IParsingResult> expressions = CxxDemangler.ParseList(Expression.Parse, context);
if (context.Parser.VerifyString("_"))
{
IParsingResult type = Type.Parse(context);
if (type != null)
{
if (context.Parser.VerifyString("E"))
{
if (isGlobal)
{
return(new GlobalNew(expressions, type));
}
else
{
return(new New(expressions, type));
}
}
else
{
IParsingResult initializer = Initializer.Parse(context);
if (initializer != null)
{
if (isGlobal)
{
return(new GlobalNew(expressions, type, initializer));
}
else
{
return(new New(expressions, type, initializer));
}
}
}
}
}
}
else if (context.Parser.VerifyString("na"))
{
List <IParsingResult> expressions = CxxDemangler.ParseList(Expression.Parse, context);
if (context.Parser.VerifyString("_"))
{
IParsingResult type = Type.Parse(context);
if (type != null)
{
if (context.Parser.VerifyString("E"))
{
if (isGlobal)
{
return(new GlobalNewArray(expressions, type));
}
else
{
return(new NewArray(expressions, type));
}
}
else
{
IParsingResult initializer = Initializer.Parse(context);
if (initializer != null)
{
if (isGlobal)
{
return(new GlobalNewArray(expressions, type, initializer));
}
else
{
return(new NewArray(expressions, type, initializer));
}
}
}
}
}
}
else if (context.Parser.VerifyString("dl"))
{
IParsingResult expression = Expression.Parse(context);
if (expression != null)
{
if (isGlobal)
{
return(new GlobalDelete(expression));
}
else
{
return(new Delete(expression));
}
}
}
else if (context.Parser.VerifyString("da"))
{
IParsingResult expression = Expression.Parse(context);
if (expression != null)
{
if (isGlobal)
{
return(new GlobalDeleteArray(expression));
}
else
{
return(new DeleteArray(expression));
}
}
}
context.Rewind(rewind);
return(null);
}
