public static IParsingResult Parse(ParsingContext context)
{
RewindState rewind = context.RewindState;
if (!context.Parser.VerifyString("f"))
{
return(null);
}
int scope = 0;
if (context.Parser.VerifyString("L"))
{
if (!context.Parser.ParseNumber(out scope))
{
context.Rewind(rewind);
return(null);
}
}
if (context.Parser.VerifyString("p"))
{
CvQualifiers qualifiers = CvQualifiers.Parse(context);
int? param = context.Parser.ParseNumber();
if (context.Parser.VerifyString("_"))
{
return(new FunctionParam(qualifiers, scope, param));
}
}
context.Rewind(rewind);
return(null);
}
public static IParsingResultExtended Parse(ParsingContext context)
{
RewindState rewind = context.RewindState;
if (!context.Parser.VerifyString("N"))
{
return(null);
}
CvQualifiers cvQualifiers = CvQualifiers.Parse(context);
RefQualifier refQualifier = RefQualifier.Parse(context);
IParsingResultExtended prefix = Parsers.Prefix.Parse(context);
if (prefix == null)
{
context.Rewind(rewind);
return(null);
}
if (!(prefix is Parsers.Prefix.NestedName) && !(prefix is Parsers.Prefix.Template))
{
context.Rewind(rewind);
return(null);
}
if (!context.Parser.VerifyString("E"))
{
context.Rewind(rewind);
return(null);
}
return(new NestedName(prefix, cvQualifiers, refQualifier));
}
public static IParsingResult Parse(ParsingContext context)
{
RewindState rewind = context.RewindState;
if (context.Parser.VerifyString("h"))
{
int offset;
if (!context.Parser.ParseNumber(out offset) || !context.Parser.VerifyString("_"))
{
context.Rewind(rewind);
return(null);
}
return(new NonVirtual(offset));
}
else if (context.Parser.VerifyString("v"))
{
int offset, virtualOffset;
if (!context.Parser.ParseNumber(out offset) || !context.Parser.VerifyString("_") ||
!context.Parser.ParseNumber(out virtualOffset) || !context.Parser.VerifyString("_"))
{
context.Rewind(rewind);
return(null);
}
return(new Virtual(offset, virtualOffset));
}
return(null);
}
public static IParsingResultExtended Parse(ParsingContext context)
{
RewindState rewind = context.RewindState;
CvQualifiers cvQualifiers = CvQualifiers.Parse(context);
bool transactionSafe = context.Parser.VerifyString("Dx");
if (context.Parser.VerifyString("F"))
{
bool externC = context.Parser.VerifyString("Y");
BareFunctionType bareType = BareFunctionType.Parse(context);
if (bareType != null)
{
RefQualifier refQualifier = RefQualifier.Parse(context);
if (context.Parser.VerifyString("E"))
{
return(new FunctionType(bareType, cvQualifiers, refQualifier, transactionSafe, externC));
}
}
}
context.Rewind(rewind);
return(null);
}
public static IParsingResultExtended Parse(ParsingContext context)
{
IParsingResultExtended simple = SimpleOperatorName.Parse(context);
if (simple != null)
{
return(simple);
}
RewindState rewind = context.RewindState;
if (context.Parser.VerifyString("cv"))
{
IParsingResultExtended type = Type.Parse(context);
if (type == null)
{
context.Rewind(rewind);
return(null);
}
return(new Cast(type));
}
if (context.Parser.VerifyString("li"))
{
IParsingResultExtended name = SourceName.Parse(context);
if (name == null)
{
context.Rewind(rewind);
return(null);
}
return(new Literal(name));
}
if (context.Parser.VerifyString("v"))
{
if (!char.IsDigit(context.Parser.Peek))
{
context.Rewind(rewind);
return(null);
}
int arity = context.Parser.Peek - '0';
context.Parser.Position++;
IParsingResultExtended name = SourceName.Parse(context);
if (name == null)
{
context.Rewind(rewind);
return(null);
}
return(new VendorExtension(arity, name));
}
return(null);
}
public static IParsingResultExtended Parse(ParsingContext context)
{
RewindState rewind = context.RewindState;
if (!context.Parser.VerifyString("Ul"))
{
return(null);
}
IParsingResult signature = LambdaSig.Parse(context);
if (signature == null || !context.Parser.VerifyString("E"))
{
context.Rewind(rewind);
return(null);
}
int?number = context.Parser.ParseNumber();
if (!context.Parser.VerifyString("_"))
{
context.Rewind(rewind);
return(null);
}
return(new ClosureTypeName(signature, number));
}
public static IParsingResult Parse(ParsingContext context)
{
RewindState rewind = context.RewindState;
IParsingResult name = SimpleId.Parse(context);
if (name != null)
{
return(name);
}
if (context.Parser.VerifyString("on"))
{
IParsingResult operatorName = OperatorName.Parse(context);
if (operatorName != null)
{
IParsingResult arguments = TemplateArgs.Parse(context);
return(new Operator(operatorName, arguments));
}
context.Rewind(rewind);
return(null);
}
if (context.Parser.VerifyString("dn"))
{
return(DestructorName.Parse(context));
}
return(null);
}
public static IParsingResult Parse(ParsingContext context)
{
RewindState rewind = context.RewindState;
if (!context.Parser.VerifyString("L"))
{
return(null);
}
IParsingResult type = Type.Parse(context);
if (type != null)
{
string literal = context.Parser.ParseUntil('E');
if (context.Parser.VerifyString("E"))
{
return(new Literal(type, literal));
}
context.Rewind(rewind);
return(null);
}
IParsingResult name = MangledName.Parse(context);
if (name != null && context.Parser.VerifyString("E"))
{
return(new External(name));
}
context.Rewind(rewind);
return(null);
}
/// <inheritdoc />
public override Task <RewindState> RewindAsync()
{
var state = new RewindState()
{
BlockHash = this.UtxoSet.Rewind()
};
return(Task.FromResult(state));
}
public static IParsingResultExtended Parse(ParsingContext context)
{
RewindState rewind = context.RewindState;
if (!context.Parser.VerifyString("A"))
{
return(null);
}
int number;
IParsingResult type;
if (context.Parser.ParseNumber(out number))
{
Debug.Assert(number >= 0);
if (context.Parser.VerifyString("_"))
{
type = Parsers.Type.Parse(context);
if (type != null)
{
return(new DimensionNumber(number, type));
}
}
context.Rewind(rewind);
return(null);
}
IParsingResult expression = Expression.Parse(context);
if (expression != null)
{
if (context.Parser.VerifyString("_"))
{
type = Parsers.Type.Parse(context);
if (type != null)
{
return(new DimensionExpression(expression, type));
}
}
context.Rewind(rewind);
return(null);
}
if (context.Parser.VerifyString("_"))
{
type = Parsers.Type.Parse(context);
if (type != null)
{
return(new NoDimension(type));
}
}
context.Rewind(rewind);
return(null);
}
static public object Initial(SCode expression, Environment environment)
{
object answer;
Thread.CurrentThread.Priority = ThreadPriority.AboveNormal;
#if DEBUG
Timer tosProbe = new Timer(SCode.TopOfStackProbe, null, 5, 3);
SCode.topOfStackTimer = tosProbe;
#endif
Control residual = expression.PartialEval(PartialEnvironment.Make((ITopLevelEnvironment)environment)).Residual;
while (true)
{
answer = null;
while (residual.EvalStep(out answer, ref residual, ref environment))
{
}
;
if (answer == Interpreter.UnwindStack)
{
// What are we doing here? Someone unwound the stack!
// There are three possibilities to consider:
// 1) A cwcc has just performed a destructive read of the stack.
// In this case, we convert the newly captured frame list
// into a control point and reload it.
//
// 2) A within-continuation has blown away the stack in order
// to install a different control point. In this case we
// reload the control point that was stored in the UnwinderState.
//
// 3) The stack was unwound in order to exit the interpreter.
// In this case, we return from the initial continuation.
if (((UnwinderState)environment).IsExit)
{
answer = ((UnwinderState)environment).ExitValue;
break;
}
else
{
ControlPoint stateToRestore = ((UnwinderState)environment).ToControlPoint();
// the receiver gets control when the stack is put back.
Control receiver = ((UnwinderState)environment).Receiver;
// the rewind state goes in the closureEnvironment
environment = new RewindState(stateToRestore, receiver);
// Start reloading by returning control to the lowest
// frame.
residual = ((RewindState)environment).PopFrame();
}
}
}
Debug.WriteLine("Interpreter exited with value " + answer.ToString());
return(answer);
}
public static IParsingResult Parse(ParsingContext context)
{
RewindState rewind = context.RewindState;
IParsingResult name = SourceName.Parse(context);
if (name != null && context.Parser.VerifyString("M"))
{
return(name);
}
context.Rewind(rewind);
return(null);
}
private static IParsingResult ParseWithEnd <T>(RewindState rewind, ParsingContext context, params Func <ParsingContext, object>[] paramsParse)
where T : IParsingResult
{
IParsingResult result = Parse <T>(rewind, context, paramsParse);
if (result != null && context.Parser.VerifyString("E"))
{
return(result);
}
context.Rewind(rewind);
return(null);
}
public static IParsingResultExtended Parse(ParsingContext context)
{
RewindState rewind = context.RewindState;
if (!context.Parser.VerifyString("Z"))
{
return(null);
}
IParsingResult encoding = Encoding.Parse(context);
IParsingResultExtended name;
Discriminator discriminator;
if (encoding == null || !context.Parser.VerifyString("E"))
{
context.Rewind(rewind);
return(null);
}
if (context.Parser.VerifyString("s"))
{
discriminator = Discriminator.Parse(context);
return(new Relative(encoding, null, discriminator));
}
if (context.Parser.VerifyString("d"))
{
int?param = context.Parser.ParseNumber();
if (context.Parser.VerifyString("_"))
{
name = Name.Parse(context);
if (name != null)
{
return(new Default(encoding, param, name));
}
}
context.Rewind(rewind);
return(null);
}
name = Name.Parse(context);
if (name != null)
{
discriminator = Discriminator.Parse(context);
return(new Relative(encoding, name, discriminator));
}
context.Rewind(rewind);
return(null);
}
public static IParsingResultExtended Parse(ParsingContext context)
{
RewindState rewind = context.RewindState;
IParsingResultExtended name = NestedName.Parse(context);
if (name != null)
{
return(name);
}
name = UnscopedName.Parse(context);
if (name != null)
{
if (context.Parser.Peek == 'I')
{
context.SubstitutionTable.Add(name);
TemplateArgs args = TemplateArgs.Parse(context);
if (args == null)
{
context.Rewind(rewind);
return(null);
}
return(new UnscopedTemplate(name, args));
}
else
{
return(name);
}
}
name = UnscopedTemplateName.Parse(context);
if (name != null)
{
TemplateArgs args = TemplateArgs.Parse(context);
if (args == null)
{
context.Rewind(rewind);
return(null);
}
return(new UnscopedTemplate(name, args));
}
return(LocalName.Parse(context));
}
private static IParsingResult Parse <T>(RewindState rewind, ParsingContext context, params Func <ParsingContext, object>[] paramsParse)
where T : IParsingResult
{
object[] paramsValue = new object[paramsParse.Length];
for (int i = 0; i < paramsParse.Length; i++)
{
paramsValue[i] = paramsParse[i](context);
if (paramsValue[i] == null)
{
context.Rewind(rewind);
return(null);
}
}
return((T)Activator.CreateInstance(typeof(T), paramsValue));
}
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);
}
public static IParsingResultExtended Parse(ParsingContext context)
{
RewindState rewind = context.RewindState;
if (context.Parser.VerifyString("Ut"))
{
int?number = context.Parser.ParseNumber();
if (context.Parser.VerifyString("_"))
{
return(new UnnamedTypeName(number));
}
context.Rewind(rewind);
}
return(ClosureTypeName.Parse(context));
}
public static IParsingResultExtended Parse(ParsingContext context)
{
RewindState rewind = context.RewindState;
int nameLength;
if (!context.Parser.ParseNumber(out nameLength))
{
return(null);
}
if (nameLength <= 0)
{
context.Rewind(rewind);
return(null);
}
if (context.Parser.Position + nameLength <= context.Parser.Input.Length)
{
string identifier = context.Parser.Input.Substring(context.Parser.Position, nameLength);
// Verify that identifier is correct
bool correct = true;
foreach (char c in identifier)
{
if (c != '_' && c != '.' && !char.IsLetterOrDigit(c))
{
correct = false;
break;
}
}
if (!correct)
{
context.Rewind(rewind);
return(null);
}
context.Parser.Position += nameLength;
return(new Identifier(identifier));
}
return(null);
}
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 IParsingResultExtended Parse(ParsingContext context)
{
RewindState rewind = context.RewindState;
if (context.Parser.VerifyString("St"))
{
IParsingResultExtended name = UnqualifiedName.Parse(context);
if (name == null)
{
context.Rewind(rewind);
return(null);
}
return(new Std(name));
}
return(UnqualifiedName.Parse(context));
}
public static IParsingResultExtended Parse(ParsingContext context)
{
IParsingResultExtended name = Name.Parse(context);
if (name != null)
{
return(name);
}
RewindState rewind = context.RewindState;
if (context.Parser.VerifyString("T"))
{
if (context.Parser.VerifyString("s"))
{
name = Name.Parse(context);
if (name != null)
{
return(new ElaboratedStruct(name));
}
}
else if (context.Parser.VerifyString("u"))
{
name = Name.Parse(context);
if (name != null)
{
return(new ElaboratedUnion(name));
}
}
else if (context.Parser.VerifyString("e"))
{
name = Name.Parse(context);
if (name != null)
{
return(new ElaboratedEnum(name));
}
}
}
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 IParsingResultExtended Parse(ParsingContext context)
{
IParsingResultExtended type = StandardBuiltinType.Parse(context);
if (type != null)
{
return(type);
}
RewindState rewind = context.RewindState;
if (context.Parser.VerifyString("u"))
{
IParsingResultExtended name = SourceName.Parse(context);
return(new Extension(name));
}
context.Rewind(rewind);
return(null);
}
public static IParsingResultExtended Parse(ParsingContext context)
{
RewindState rewind = context.RewindState;
if (context.Parser.VerifyString("M"))
{
IParsingResult type = Parsers.Type.Parse(context);
if (type != null)
{
IParsingResult member = Parsers.Type.Parse(context);
if (member != null)
{
return(new PointerToMemberType(type, member));
}
}
context.Rewind(rewind);
}
return(null);
}
public static IParsingResultExtended Parse(ParsingContext context)
{
RewindState rewind = context.RewindState;
if (context.Parser.VerifyString("T"))
{
int number;
if (!context.Parser.ParseNumber(out number))
{
number = -1;
}
number++;
if (context.Parser.VerifyString("_"))
{
return(new TemplateParam(number));
}
context.Rewind(rewind);
}
return(null);
}
public static IParsingResultExtended Parse(ParsingContext context)
{
RewindState rewind = context.RewindState;
if (!context.Parser.VerifyString("D"))
{
return(null);
}
if (context.Parser.VerifyString("t"))
{
IParsingResult expression = Parsers.Expression.Parse(context);
if (expression == null || !context.Parser.VerifyString("E"))
{
context.Rewind(rewind);
return(null);
}
return(new Decltype(expression, idExpression: true));
}
if (context.Parser.VerifyString("T"))
{
IParsingResult expression = Parsers.Expression.Parse(context);
if (expression == null || !context.Parser.VerifyString("E"))
{
context.Rewind(rewind);
return(null);
}
return(new Decltype(expression, idExpression: false));
}
context.Rewind(rewind);
return(null);
}
public static Discriminator Parse(ParsingContext context)
{
RewindState rewind = context.RewindState;
if (!context.Parser.VerifyString("_"))
{
return(null);
}
if (context.Parser.VerifyString("_"))
{
int number;
if (context.Parser.ParseNumber(out number))
{
Debug.Assert(number >= 0);
if (number >= 10 && context.Parser.VerifyString("_"))
{
return(new Discriminator(number));
}
}
context.Rewind(rewind);
return(null);
}
if (char.IsDigit(context.Parser.Peek))
{
int number = context.Parser.Peek - '0';
context.Parser.Position++;
return(new Discriminator(number));
}
context.Rewind(rewind);
return(null);
}
public static IParsingResultExtended Parse(ParsingContext context)
{
IParsingResultExtended wellKnown = WellKnownComponent.Parse(context);
if (wellKnown != null)
{
return(wellKnown);
}
RewindState rewind = context.RewindState;
if (!context.Parser.VerifyString("S"))
{
return(null);
}
int number;
if (!context.Parser.ParseNumberBase36(out number))
{
number = -1;
}
number++;
if (!context.Parser.VerifyString("_") || !context.SubstitutionTable.Contains(number))
{
context.Rewind(rewind);
return(null);
}
Substitution substitution = new Substitution(number);
substitution.resolvedReference = context.SubstitutionTable.Substitutions[number];
return(substitution);
}
public static IParsingResultExtended Parse(ParsingContext context)
{
RewindState rewind = context.RewindState;
IParsingResultExtended result = null;
bool isResultTemplatePrefix = false;
while (!context.Parser.IsEnd)
{
bool isResultTemplatePrefixNext = false;
switch (context.Parser.Peek)
{
case 'S':
{
IParsingResultExtended substitution = Substitution.Parse(context);
if (substitution == null)
{
context.Rewind(rewind);
return(null);
}
result = substitution;
}
break;
case 'T':
{
IParsingResultExtended param = TemplateParam.Parse(context);
if (param == null)
{
context.Rewind(rewind);
return(null);
}
result = AddToSubstitutionTable(context, param);
isResultTemplatePrefixNext = true;
}
break;
case 'D':
{
IParsingResultExtended decltype = Decltype.Parse(context);
if (decltype != null)
{
result = AddToSubstitutionTable(context, decltype);
}
else
{
IParsingResultExtended name = UnqualifiedName.Parse(context);
if (name == null)
{
context.Rewind(rewind);
return(null);
}
if (result != null)
{
result = AddToSubstitutionTable(context, new NestedName(result, name));
}
else
{
result = AddToSubstitutionTable(context, name);
}
isResultTemplatePrefixNext = true;
}
}
break;
default:
if (context.Parser.Peek == 'I' && result != null && isResultTemplatePrefix)
{
TemplateArgs arguments = TemplateArgs.Parse(context);
if (arguments == null)
{
context.Rewind(rewind);
return(null);
}
result = AddToSubstitutionTable(context, new Template(result, arguments));
}
else if (result != null && SourceName.StartsWith(context))
{
Debug.Assert(UnqualifiedName.StartsWith(context));
Debug.Assert(DataMemberPrefix.StartsWith(context));
IParsingResultExtended name = SourceName.Parse(context);
if (name == null)
{
context.Rewind(rewind);
return(null);
}
if (context.Parser.VerifyString("M"))
{
result = AddToSubstitutionTable(context, new DataMember(result, name));
}
else
{
if (result != null)
{
result = AddToSubstitutionTable(context, new NestedName(result, name));
}
else
{
result = AddToSubstitutionTable(context, name);
}
isResultTemplatePrefixNext = true;
}
}
else if (UnqualifiedName.StartsWith(context))
{
IParsingResultExtended name = UnqualifiedName.Parse(context);
if (name == null)
{
context.Rewind(rewind);
return(null);
}
if (result != null)
{
result = AddToSubstitutionTable(context, new NestedName(result, name));
}
else
{
result = AddToSubstitutionTable(context, name);
}
isResultTemplatePrefixNext = true;
}
else
{
if (result != null)
{
return(result);
}
context.Rewind(rewind);
return(null);
}
break;
}
isResultTemplatePrefix = isResultTemplatePrefixNext;
}
return(result);
}
