| | using Nemerle.Builtins;
using Nemerle.Collections;
using Nemerle.Core;
using Nemerle.Parser;
using Nemerle.Parser.Internal;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Runtime.CompilerServices;
public abstract class CalcParser
{
public sealed class GrammarImpl : CalcParser, IGrammar
{
public sealed class GrammarDescriptorImpl : GrammarDescriptor
{
public class _#postfix#_add_ : RuleDescriptor
{
public static readonly TokenDescriptor _token_literal_"+"_;
private static readonly CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_add_ _staticDescriptor;
public override string Name
{
get
{
return "add";
}
}
public override GrammarDescriptor Grammar
{
get
{
return CalcParser.GrammarImpl.StaticDescriptor;
}
}
public static RuleDescriptor StaticDescriptor
{
get
{
return CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_add_._staticDescriptor;
}
}
static _#postfix#_add_()
{
CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_add_._staticDescriptor = new CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_add_();
CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_add_._token_literal_"+"_ = new TokenDescriptor(CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_add_._staticDescriptor, "+", true);
}
public CalcParser.Add ResultType()
{
return null;
}
private _#postfix#_add_()
{
}
}
public class _#regular#_any_ : RuleDescriptor
{
private static readonly CalcParser.GrammarImpl.GrammarDescriptorImpl._#regular#_any_ _staticDescriptor;
public override string Name
{
get
{
return "any";
}
}
public override GrammarDescriptor Grammar
{
get
{
return CalcParser.GrammarImpl.StaticDescriptor;
}
}
public static RuleDescriptor StaticDescriptor
{
get
{
return CalcParser.GrammarImpl.GrammarDescriptorImpl._#regular#_any_._staticDescriptor;
}
}
static _#regular#_any_()
{
CalcParser.GrammarImpl.GrammarDescriptorImpl._#regular#_any_._staticDescriptor = new CalcParser.GrammarImpl.GrammarDescriptorImpl._#regular#_any_();
}
private _#regular#_any_()
{
}
}
public class _#postfix#_cond_ : RuleDescriptor
{
public static readonly TokenDescriptor _token_literal_"?"_;
public static readonly TokenDescriptor _token_literal_":"_;
private static readonly CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_cond_ _staticDescriptor;
public override string Name
{
get
{
return "cond";
}
}
public override GrammarDescriptor Grammar
{
get
{
return CalcParser.GrammarImpl.StaticDescriptor;
}
}
public static RuleDescriptor StaticDescriptor
{
get
{
return CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_cond_._staticDescriptor;
}
}
static _#postfix#_cond_()
{
CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_cond_._staticDescriptor = new CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_cond_();
CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_cond_._token_literal_":"_ = new TokenDescriptor(CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_cond_._staticDescriptor, ":", true);
CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_cond_._token_literal_"?"_ = new TokenDescriptor(CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_cond_._staticDescriptor, "?", true);
}
public CalcParser.Cond ResultType()
{
return null;
}
private _#postfix#_cond_()
{
}
}
public class _#postfix#_div_ : RuleDescriptor
{
public static readonly TokenDescriptor _token_literal_"/"_;
private static readonly CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_div_ _staticDescriptor;
public override string Name
{
get
{
return "div";
}
}
public override GrammarDescriptor Grammar
{
get
{
return CalcParser.GrammarImpl.StaticDescriptor;
}
}
public static RuleDescriptor StaticDescriptor
{
get
{
return CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_div_._staticDescriptor;
}
}
static _#postfix#_div_()
{
CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_div_._staticDescriptor = new CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_div_();
CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_div_._token_literal_"/"_ = new TokenDescriptor(CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_div_._staticDescriptor, "/", true);
}
public CalcParser.Div ResultType()
{
return null;
}
private _#postfix#_div_()
{
}
}
public class _#point#___expr_ : RuleDescriptor
{
private static readonly CalcParser.GrammarImpl.GrammarDescriptorImpl._#point#___expr_ _staticDescriptor;
public override string Name
{
get
{
return "expr";
}
}
public override GrammarDescriptor Grammar
{
get
{
return CalcParser.GrammarImpl.StaticDescriptor;
}
}
public static RuleDescriptor StaticDescriptor
{
get
{
return CalcParser.GrammarImpl.GrammarDescriptorImpl._#point#___expr_._staticDescriptor;
}
}
static _#point#___expr_()
{
CalcParser.GrammarImpl.GrammarDescriptorImpl._#point#___expr_._staticDescriptor = new CalcParser.GrammarImpl.GrammarDescriptorImpl._#point#___expr_();
}
public CalcParser.Expr ResultType()
{
return null;
}
private _#point#___expr_()
{
}
}
public class _#postfix#_mod_ : RuleDescriptor
{
public static readonly TokenDescriptor _token_literal_"%"_;
private static readonly CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_mod_ _staticDescriptor;
public override string Name
{
get
{
return "mod";
}
}
public override GrammarDescriptor Grammar
{
get
{
return CalcParser.GrammarImpl.StaticDescriptor;
}
}
public static RuleDescriptor StaticDescriptor
{
get
{
return CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_mod_._staticDescriptor;
}
}
static _#postfix#_mod_()
{
CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_mod_._staticDescriptor = new CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_mod_();
CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_mod_._token_literal_"%"_ = new TokenDescriptor(CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_mod_._staticDescriptor, "%", true);
}
public CalcParser.Mod ResultType()
{
return null;
}
private _#postfix#_mod_()
{
}
}
public class _#postfix#_mul_ : RuleDescriptor
{
public static readonly TokenDescriptor _token_literal_"*"_;
private static readonly CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_mul_ _staticDescriptor;
public override string Name
{
get
{
return "mul";
}
}
public override GrammarDescriptor Grammar
{
get
{
return CalcParser.GrammarImpl.StaticDescriptor;
}
}
public static RuleDescriptor StaticDescriptor
{
get
{
return CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_mul_._staticDescriptor;
}
}
static _#postfix#_mul_()
{
CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_mul_._staticDescriptor = new CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_mul_();
CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_mul_._token_literal_"*"_ = new TokenDescriptor(CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_mul_._staticDescriptor, "*", true);
}
public CalcParser.Mul ResultType()
{
return null;
}
private _#postfix#_mul_()
{
}
}
public class _#prefix#__neg_ : RuleDescriptor
{
public static readonly TokenDescriptor _token_literal_"-"_;
private static readonly CalcParser.GrammarImpl.GrammarDescriptorImpl._#prefix#__neg_ _staticDescriptor;
public override string Name
{
get
{
return "neg";
}
}
public override GrammarDescriptor Grammar
{
get
{
return CalcParser.GrammarImpl.StaticDescriptor;
}
}
public static RuleDescriptor StaticDescriptor
{
get
{
return CalcParser.GrammarImpl.GrammarDescriptorImpl._#prefix#__neg_._staticDescriptor;
}
}
static _#prefix#__neg_()
{
CalcParser.GrammarImpl.GrammarDescriptorImpl._#prefix#__neg_._staticDescriptor = new CalcParser.GrammarImpl.GrammarDescriptorImpl._#prefix#__neg_();
CalcParser.GrammarImpl.GrammarDescriptorImpl._#prefix#__neg_._token_literal_"-"_ = new TokenDescriptor(CalcParser.GrammarImpl.GrammarDescriptorImpl._#prefix#__neg_._staticDescriptor, "-", true);
}
public CalcParser.Neg ResultType()
{
return null;
}
private _#prefix#__neg_()
{
}
}
public class _#prefix#__num_ : RuleDescriptor
{
private static readonly CalcParser.GrammarImpl.GrammarDescriptorImpl._#prefix#__num_ _staticDescriptor;
public override string Name
{
get
{
return "num";
}
}
public override GrammarDescriptor Grammar
{
get
{
return CalcParser.GrammarImpl.StaticDescriptor;
}
}
public static RuleDescriptor StaticDescriptor
{
get
{
return CalcParser.GrammarImpl.GrammarDescriptorImpl._#prefix#__num_._staticDescriptor;
}
}
static _#prefix#__num_()
{
CalcParser.GrammarImpl.GrammarDescriptorImpl._#prefix#__num_._staticDescriptor = new CalcParser.GrammarImpl.GrammarDescriptorImpl._#prefix#__num_();
}
public CalcParser.Num ResultType()
{
return null;
}
private _#prefix#__num_()
{
}
}
public class _#postfix#_postfixDec_ : RuleDescriptor
{
public static readonly TokenDescriptor _token_literal_"--"_;
private static readonly CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_postfixDec_ _staticDescriptor;
public override string Name
{
get
{
return "postfixDec";
}
}
public override GrammarDescriptor Grammar
{
get
{
return CalcParser.GrammarImpl.StaticDescriptor;
}
}
public static RuleDescriptor StaticDescriptor
{
get
{
return CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_postfixDec_._staticDescriptor;
}
}
static _#postfix#_postfixDec_()
{
CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_postfixDec_._staticDescriptor = new CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_postfixDec_();
CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_postfixDec_._token_literal_"--"_ = new TokenDescriptor(CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_postfixDec_._staticDescriptor, "--", true);
}
public CalcParser.PostfixDec ResultType()
{
return null;
}
private _#postfix#_postfixDec_()
{
}
}
public class _#postfix#_pow_ : RuleDescriptor
{
public static readonly TokenDescriptor _token_literal_"^"_;
private static readonly CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_pow_ _staticDescriptor;
public override string Name
{
get
{
return "pow";
}
}
public override GrammarDescriptor Grammar
{
get
{
return CalcParser.GrammarImpl.StaticDescriptor;
}
}
public static RuleDescriptor StaticDescriptor
{
get
{
return CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_pow_._staticDescriptor;
}
}
static _#postfix#_pow_()
{
CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_pow_._staticDescriptor = new CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_pow_();
CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_pow_._token_literal_"^"_ = new TokenDescriptor(CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_pow_._staticDescriptor, "^", true);
}
public CalcParser.Pow ResultType()
{
return null;
}
private _#postfix#_pow_()
{
}
}
public class _#prefix#__prefixDec_ : RuleDescriptor
{
public static readonly TokenDescriptor _token_literal_"--"_;
private static readonly CalcParser.GrammarImpl.GrammarDescriptorImpl._#prefix#__prefixDec_ _staticDescriptor;
public override string Name
{
get
{
return "prefixDec";
}
}
public override GrammarDescriptor Grammar
{
get
{
return CalcParser.GrammarImpl.StaticDescriptor;
}
}
public static RuleDescriptor StaticDescriptor
{
get
{
return CalcParser.GrammarImpl.GrammarDescriptorImpl._#prefix#__prefixDec_._staticDescriptor;
}
}
static _#prefix#__prefixDec_()
{
CalcParser.GrammarImpl.GrammarDescriptorImpl._#prefix#__prefixDec_._staticDescriptor = new CalcParser.GrammarImpl.GrammarDescriptorImpl._#prefix#__prefixDec_();
CalcParser.GrammarImpl.GrammarDescriptorImpl._#prefix#__prefixDec_._token_literal_"--"_ = new TokenDescriptor(CalcParser.GrammarImpl.GrammarDescriptorImpl._#prefix#__prefixDec_._staticDescriptor, "--", true);
}
public CalcParser.PrefixDec ResultType()
{
return null;
}
private _#prefix#__prefixDec_()
{
}
}
public class _#prefix#__rounds_ : RuleDescriptor
{
public static readonly TokenDescriptor _token_literal_"("_;
public static readonly TokenDescriptor _token_literal_")"_;
private static readonly CalcParser.GrammarImpl.GrammarDescriptorImpl._#prefix#__rounds_ _staticDescriptor;
public override string Name
{
get
{
return "rounds";
}
}
public override GrammarDescriptor Grammar
{
get
{
return CalcParser.GrammarImpl.StaticDescriptor;
}
}
public static RuleDescriptor StaticDescriptor
{
get
{
return CalcParser.GrammarImpl.GrammarDescriptorImpl._#prefix#__rounds_._staticDescriptor;
}
}
static _#prefix#__rounds_()
{
CalcParser.GrammarImpl.GrammarDescriptorImpl._#prefix#__rounds_._staticDescriptor = new CalcParser.GrammarImpl.GrammarDescriptorImpl._#prefix#__rounds_();
CalcParser.GrammarImpl.GrammarDescriptorImpl._#prefix#__rounds_._token_literal_")"_ = new TokenDescriptor(CalcParser.GrammarImpl.GrammarDescriptorImpl._#prefix#__rounds_._staticDescriptor, ")", true);
CalcParser.GrammarImpl.GrammarDescriptorImpl._#prefix#__rounds_._token_literal_"("_ = new TokenDescriptor(CalcParser.GrammarImpl.GrammarDescriptorImpl._#prefix#__rounds_._staticDescriptor, "(", true);
}
public CalcParser.Rounds ResultType()
{
return null;
}
private _#prefix#__rounds_()
{
}
}
public class _#simple#__s_ : RuleDescriptor
{
public static readonly TokenDescriptor _token_literal_" "_;
private static readonly CalcParser.GrammarImpl.GrammarDescriptorImpl._#simple#__s_ _staticDescriptor;
public override string Name
{
get
{
return "s";
}
}
public override GrammarDescriptor Grammar
{
get
{
return CalcParser.GrammarImpl.StaticDescriptor;
}
}
public static RuleDescriptor StaticDescriptor
{
get
{
return CalcParser.GrammarImpl.GrammarDescriptorImpl._#simple#__s_._staticDescriptor;
}
}
static _#simple#__s_()
{
CalcParser.GrammarImpl.GrammarDescriptorImpl._#simple#__s_._staticDescriptor = new CalcParser.GrammarImpl.GrammarDescriptorImpl._#simple#__s_();
CalcParser.GrammarImpl.GrammarDescriptorImpl._#simple#__s_._token_literal_" "_ = new TokenDescriptor(CalcParser.GrammarImpl.GrammarDescriptorImpl._#simple#__s_._staticDescriptor, " ", true);
}
public void ResultType()
{
}
private _#simple#__s_()
{
}
}
public class _#prefix#__seq_ : RuleDescriptor
{
public static readonly TokenDescriptor _token_literal_"{"_;
public static readonly TokenDescriptor _token_literal_"}"_;
private static readonly CalcParser.GrammarImpl.GrammarDescriptorImpl._#prefix#__seq_ _staticDescriptor;
public override string Name
{
get
{
return "seq";
}
}
public override GrammarDescriptor Grammar
{
get
{
return CalcParser.GrammarImpl.StaticDescriptor;
}
}
public static RuleDescriptor StaticDescriptor
{
get
{
return CalcParser.GrammarImpl.GrammarDescriptorImpl._#prefix#__seq_._staticDescriptor;
}
}
static _#prefix#__seq_()
{
CalcParser.GrammarImpl.GrammarDescriptorImpl._#prefix#__seq_._staticDescriptor = new CalcParser.GrammarImpl.GrammarDescriptorImpl._#prefix#__seq_();
CalcParser.GrammarImpl.GrammarDescriptorImpl._#prefix#__seq_._token_literal_"}"_ = new TokenDescriptor(CalcParser.GrammarImpl.GrammarDescriptorImpl._#prefix#__seq_._staticDescriptor, "}", true);
CalcParser.GrammarImpl.GrammarDescriptorImpl._#prefix#__seq_._token_literal_"{"_ = new TokenDescriptor(CalcParser.GrammarImpl.GrammarDescriptorImpl._#prefix#__seq_._staticDescriptor, "{", true);
}
public CalcParser.Seq ResultType()
{
return null;
}
private _#prefix#__seq_()
{
}
}
public class _#simple#__start_ : RuleDescriptor
{
public static readonly TokenDescriptor _token_rule_"any"_;
private static readonly CalcParser.GrammarImpl.GrammarDescriptorImpl._#simple#__start_ _staticDescriptor;
public override string Name
{
get
{
return "start";
}
}
public override GrammarDescriptor Grammar
{
get
{
return CalcParser.GrammarImpl.StaticDescriptor;
}
}
public static RuleDescriptor StaticDescriptor
{
get
{
return CalcParser.GrammarImpl.GrammarDescriptorImpl._#simple#__start_._staticDescriptor;
}
}
static _#simple#__start_()
{
CalcParser.GrammarImpl.GrammarDescriptorImpl._#simple#__start_._staticDescriptor = new CalcParser.GrammarImpl.GrammarDescriptorImpl._#simple#__start_();
CalcParser.GrammarImpl.GrammarDescriptorImpl._#simple#__start_._token_rule_"any"_ = new TokenDescriptor(CalcParser.GrammarImpl.GrammarDescriptorImpl._#simple#__start_._staticDescriptor, "any", false);
}
public CalcParser.Start ResultType()
{
return null;
}
private _#simple#__start_()
{
}
}
public class _#postfix#_sub_ : RuleDescriptor
{
public static readonly TokenDescriptor _token_literal_"-"_;
private static readonly CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_sub_ _staticDescriptor;
public override string Name
{
get
{
return "sub";
}
}
public override GrammarDescriptor Grammar
{
get
{
return CalcParser.GrammarImpl.StaticDescriptor;
}
}
public static RuleDescriptor StaticDescriptor
{
get
{
return CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_sub_._staticDescriptor;
}
}
static _#postfix#_sub_()
{
CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_sub_._staticDescriptor = new CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_sub_();
CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_sub_._token_literal_"-"_ = new TokenDescriptor(CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_sub_._staticDescriptor, "-", true);
}
public CalcParser.Sub ResultType()
{
return null;
}
private _#postfix#_sub_()
{
}
}
public override GrammarDescriptor[] Dependencies
{
get
{
return new GrammarDescriptor[]
{
NumParser.GrammarImpl.get_StaticDescriptor(),
IncParser.GrammarImpl.StaticDescriptor
};
}
}
public override string Name
{
get
{
return "CalcParser";
}
}
public override string FullName
{
get
{
return "CalcParser";
}
}
public override IGrammar NewGrammar(Parser parser)
{
return new CalcParser.GrammarImpl(parser);
}
public override ParsingErrors NewParsingErrors()
{
return new CalcParser.GrammarImpl.ParsingErrorsImpl();
}
}
private sealed class ParsingErrorsImpl : ParsingErrors
{
public int _token_sub_literal_"-"_;
public int _token_start_rule_"any"_;
public int _token_seq_literal_"{"_;
public int _token_seq_literal_"}"_;
public int _token_s_literal_" "_;
public int _token_rounds_literal_"("_;
public int _token_rounds_literal_")"_;
public int _token_prefixDec_literal_"--"_;
public int _token_pow_literal_"^"_;
public int _token_postfixDec_literal_"--"_;
public int _token_neg_literal_"-"_;
public int _token_mul_literal_"*"_;
public int _token_mod_literal_"%"_;
public int _token_div_literal_"/"_;
public int _token_cond_literal_"?"_;
public int _token_cond_literal_":"_;
public int _token_add_literal_"+"_;
public override void Clear()
{
this._token_add_literal_"+"_ = -2;
this._token_cond_literal_":"_ = -2;
this._token_cond_literal_"?"_ = -2;
this._token_div_literal_"/"_ = -2;
this._token_mod_literal_"%"_ = -2;
this._token_mul_literal_"*"_ = -2;
this._token_neg_literal_"-"_ = -2;
this._token_postfixDec_literal_"--"_ = -2;
this._token_pow_literal_"^"_ = -2;
this._token_prefixDec_literal_"--"_ = -2;
this._token_rounds_literal_")"_ = -2;
this._token_rounds_literal_"("_ = -2;
this._token_s_literal_" "_ = -2;
this._token_seq_literal_"}"_ = -2;
this._token_seq_literal_"{"_ = -2;
this._token_start_rule_"any"_ = -2;
this._token_sub_literal_"-"_ = -2;
}
public override void GetErrors(ref int pos, List<TokenDescriptor> descriptors)
{
int arg_04_0 = pos;
if (pos < this._token_add_literal_"+"_)
{
pos = this._token_add_literal_"+"_;
descriptors.Clear();
}
if (pos == this._token_add_literal_"+"_)
{
descriptors.Add(CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_add_._token_literal_"+"_);
}
if (pos < this._token_cond_literal_":"_)
{
pos = this._token_cond_literal_":"_;
descriptors.Clear();
}
if (pos == this._token_cond_literal_":"_)
{
descriptors.Add(CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_cond_._token_literal_":"_);
}
if (pos < this._token_cond_literal_"?"_)
{
pos = this._token_cond_literal_"?"_;
descriptors.Clear();
}
if (pos == this._token_cond_literal_"?"_)
{
descriptors.Add(CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_cond_._token_literal_"?"_);
}
if (pos < this._token_div_literal_"/"_)
{
pos = this._token_div_literal_"/"_;
descriptors.Clear();
}
if (pos == this._token_div_literal_"/"_)
{
descriptors.Add(CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_div_._token_literal_"/"_);
}
if (pos < this._token_mod_literal_"%"_)
{
pos = this._token_mod_literal_"%"_;
descriptors.Clear();
}
if (pos == this._token_mod_literal_"%"_)
{
descriptors.Add(CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_mod_._token_literal_"%"_);
}
if (pos < this._token_mul_literal_"*"_)
{
pos = this._token_mul_literal_"*"_;
descriptors.Clear();
}
if (pos == this._token_mul_literal_"*"_)
{
descriptors.Add(CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_mul_._token_literal_"*"_);
}
if (pos < this._token_neg_literal_"-"_)
{
pos = this._token_neg_literal_"-"_;
descriptors.Clear();
}
if (pos == this._token_neg_literal_"-"_)
{
descriptors.Add(CalcParser.GrammarImpl.GrammarDescriptorImpl._#prefix#__neg_._token_literal_"-"_);
}
if (pos < this._token_postfixDec_literal_"--"_)
{
pos = this._token_postfixDec_literal_"--"_;
descriptors.Clear();
}
if (pos == this._token_postfixDec_literal_"--"_)
{
descriptors.Add(CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_postfixDec_._token_literal_"--"_);
}
if (pos < this._token_pow_literal_"^"_)
{
pos = this._token_pow_literal_"^"_;
descriptors.Clear();
}
if (pos == this._token_pow_literal_"^"_)
{
descriptors.Add(CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_pow_._token_literal_"^"_);
}
if (pos < this._token_prefixDec_literal_"--"_)
{
pos = this._token_prefixDec_literal_"--"_;
descriptors.Clear();
}
if (pos == this._token_prefixDec_literal_"--"_)
{
descriptors.Add(CalcParser.GrammarImpl.GrammarDescriptorImpl._#prefix#__prefixDec_._token_literal_"--"_);
}
if (pos < this._token_rounds_literal_")"_)
{
pos = this._token_rounds_literal_")"_;
descriptors.Clear();
}
if (pos == this._token_rounds_literal_")"_)
{
descriptors.Add(CalcParser.GrammarImpl.GrammarDescriptorImpl._#prefix#__rounds_._token_literal_")"_);
}
if (pos < this._token_rounds_literal_"("_)
{
pos = this._token_rounds_literal_"("_;
descriptors.Clear();
}
if (pos == this._token_rounds_literal_"("_)
{
descriptors.Add(CalcParser.GrammarImpl.GrammarDescriptorImpl._#prefix#__rounds_._token_literal_"("_);
}
if (pos < this._token_s_literal_" "_)
{
pos = this._token_s_literal_" "_;
descriptors.Clear();
}
if (pos == this._token_s_literal_" "_)
{
descriptors.Add(CalcParser.GrammarImpl.GrammarDescriptorImpl._#simple#__s_._token_literal_" "_);
}
if (pos < this._token_seq_literal_"}"_)
{
pos = this._token_seq_literal_"}"_;
descriptors.Clear();
}
if (pos == this._token_seq_literal_"}"_)
{
descriptors.Add(CalcParser.GrammarImpl.GrammarDescriptorImpl._#prefix#__seq_._token_literal_"}"_);
}
if (pos < this._token_seq_literal_"{"_)
{
pos = this._token_seq_literal_"{"_;
descriptors.Clear();
}
if (pos == this._token_seq_literal_"{"_)
{
descriptors.Add(CalcParser.GrammarImpl.GrammarDescriptorImpl._#prefix#__seq_._token_literal_"{"_);
}
if (pos < this._token_start_rule_"any"_)
{
pos = this._token_start_rule_"any"_;
descriptors.Clear();
}
if (pos == this._token_start_rule_"any"_)
{
descriptors.Add(CalcParser.GrammarImpl.GrammarDescriptorImpl._#simple#__start_._token_rule_"any"_);
}
if (pos < this._token_sub_literal_"-"_)
{
pos = this._token_sub_literal_"-"_;
descriptors.Clear();
}
if (pos == this._token_sub_literal_"-"_)
{
descriptors.Add(CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_sub_._token_literal_"-"_);
}
}
public ParsingErrorsImpl()
{
this.Clear();
}
}
private sealed class GrammarStateImpl : IGrammarState
{
private readonly ExtensionPostfixBase<CalcParser.Expr>[] _#_expr_PostfixRules_;
private readonly ExtensionPrefixBase<CalcParser.Expr>[] _#_expr_PrefixRules__;
[DebuggerBrowsable(DebuggerBrowsableState.Never), CompilerGenerated]
private readonly CalcParser.GrammarImpl _N_Grammar_4228;
public CalcParser.GrammarImpl Grammar
{
[CompilerGenerated]
get
{
return this._N_Grammar_4228;
}
}
public void LoadThisState()
{
this.Grammar._#_expr_PrefixRules__ = this._#_expr_PrefixRules__;
this.Grammar._#_expr_PostfixRules_ = this._#_expr_PostfixRules_;
}
public GrammarStateImpl(CalcParser.GrammarImpl grammar)
{
this._N_Grammar_4228 = grammar;
this._#_expr_PrefixRules__ = this._N_Grammar_4228._#_expr_PrefixRules__;
this._#_expr_PostfixRules_ = this._N_Grammar_4228._#_expr_PostfixRules_;
}
public GrammarStateImpl()
{
}
IGrammar IGrammarState.get_Grammar()
{
return this.Grammar;
}
}
public class _#postfix#_add_ : ExtensionPostfixBase<CalcParser.Expr>
{
private readonly CalcParser.GrammarImpl _grammar;
public override RuleDescriptor Descriptor
{
get
{
return CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_add_.StaticDescriptor;
}
}
public override int Parse(int startPos, int pos, string text, int[] bestOffsets, ref CalcParser.Expr result)
{
bool isBest = false;
NToken token_2 = default(NToken);
CalcParser.Expr token_3 = null;
CalcParser.Expr prefixResult = result;
int seqResult = 0;
CalcParser.Expr token_4 = prefixResult;
bool _N_cache_12268 = pos >= 0;
bool arg_AE_0;
if (_N_cache_12268)
{
if (true)
{
if (isBest)
{
arg_AE_0 = true;
}
else
{
isBest = (bestOffsets[0] < pos);
arg_AE_0 = (isBest || bestOffsets[0] == pos);
}
goto IL_A3;
}
}
arg_AE_0 = false;
IL_A3:
bool flag = arg_AE_0;
if (!flag)
{
seqResult = -1;
}
else
{
int arg_146_0;
if (pos < text.Length && text[pos] == '+')
{
arg_146_0 = pos + 1;
}
else
{
if (this._grammar._parsingErrors._token_add_literal_"+"_ < pos)
{
this._grammar._parsingErrors._token_add_literal_"+"_ = pos;
}
arg_146_0 = -1;
}
int newPos = arg_146_0;
if (newPos >= 0)
{
token_2 = new NToken(pos, newPos);
}
int pos2 = newPos;
bool _N_cache_12269 = pos2 >= 0;
bool arg_1D5_0;
if (_N_cache_12269)
{
if (true)
{
if (isBest)
{
arg_1D5_0 = true;
}
else
{
isBest = (bestOffsets[1] < pos2);
arg_1D5_0 = (isBest || bestOffsets[1] == pos2);
}
goto IL_1CA;
}
}
arg_1D5_0 = false;
IL_1CA:
bool flag2 = arg_1D5_0;
if (!flag2)
{
seqResult = -1;
}
else
{
int ofs = pos2;
int pos3 = this._grammar._#_s_(pos2, text);
bool _N_cache_12270 = pos3 >= 0;
bool arg_26E_0;
if (_N_cache_12270)
{
if (true)
{
if (isBest)
{
arg_26E_0 = true;
}
else
{
isBest = (bestOffsets[2] < pos3);
arg_26E_0 = (isBest || bestOffsets[2] == pos3);
}
goto IL_263;
}
}
arg_26E_0 = false;
IL_263:
bool flag3 = arg_26E_0;
if (!flag3)
{
seqResult = -1;
}
else
{
int ofs2 = pos3;
int pos4 = this._grammar._#_expr_(pos3, text, 10, ref token_3);
bool _N_cache_12271 = pos4 >= 0;
bool arg_30B_0;
if (_N_cache_12271)
{
if (true)
{
if (isBest)
{
arg_30B_0 = true;
}
else
{
isBest = (bestOffsets[3] < pos4);
arg_30B_0 = (isBest || bestOffsets[3] == pos4);
}
goto IL_300;
}
}
arg_30B_0 = false;
IL_300:
bool flag4 = arg_30B_0;
if (!flag4)
{
seqResult = -1;
}
else
{
int ofs3 = pos4;
int arg_3A2_0;
if (isBest)
{
bestOffsets[0] = pos;
bestOffsets[1] = ofs;
bestOffsets[2] = ofs2;
bestOffsets[3] = ofs3;
int i = 4;
while (i < bestOffsets.Length && bestOffsets[i] >= 0)
{
bestOffsets[i] = -1;
i++;
}
arg_3A2_0 = pos4;
}
else
{
arg_3A2_0 = -1;
}
seqResult = arg_3A2_0;
}
}
}
}
int newPos2 = seqResult;
if (newPos2 >= 0)
{
result = new CalcParser.Add.Ast(new Location(this._grammar._parsingSource, token_4.get_Location().get_StartPos(), token_3.get_Location().get_EndPos()), list<ErrorInfo>.Nil._N_constant_object, token_4, token_2, token_3);
}
return newPos2;
}
public _#postfix#_add_(IGrammar grammar) : base(10, '\0', '?')
{
this._grammar = (CalcParser.GrammarImpl)grammar;
}
}
public class _#postfix#_cond_ : ExtensionPostfixBase<CalcParser.Expr>
{
private readonly CalcParser.GrammarImpl _grammar;
public override RuleDescriptor Descriptor
{
get
{
return CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_cond_.StaticDescriptor;
}
}
public override int Parse(int startPos, int pos, string text, int[] bestOffsets, ref CalcParser.Expr result)
{
bool isBest = false;
NToken token_2 = default(NToken);
CalcParser.Expr token_3 = null;
NToken token_4 = default(NToken);
CalcParser.Expr token_5 = null;
CalcParser.Expr prefixResult = result;
int seqResult = 0;
CalcParser.Expr token_6 = prefixResult;
bool _N_cache_12561 = pos >= 0;
bool arg_BF_0;
if (_N_cache_12561)
{
if (true)
{
if (isBest)
{
arg_BF_0 = true;
}
else
{
isBest = (bestOffsets[0] < pos);
arg_BF_0 = (isBest || bestOffsets[0] == pos);
}
goto IL_B4;
}
}
arg_BF_0 = false;
IL_B4:
bool flag = arg_BF_0;
if (!flag)
{
seqResult = -1;
}
else
{
int arg_157_0;
if (pos < text.Length && text[pos] == '?')
{
arg_157_0 = pos + 1;
}
else
{
if (this._grammar._parsingErrors._token_cond_literal_"?"_ < pos)
{
this._grammar._parsingErrors._token_cond_literal_"?"_ = pos;
}
arg_157_0 = -1;
}
int newPos = arg_157_0;
if (newPos >= 0)
{
token_2 = new NToken(pos, newPos);
}
int pos2 = newPos;
bool _N_cache_12562 = pos2 >= 0;
bool arg_1E6_0;
if (_N_cache_12562)
{
if (true)
{
if (isBest)
{
arg_1E6_0 = true;
}
else
{
isBest = (bestOffsets[1] < pos2);
arg_1E6_0 = (isBest || bestOffsets[1] == pos2);
}
goto IL_1DB;
}
}
arg_1E6_0 = false;
IL_1DB:
bool flag2 = arg_1E6_0;
if (!flag2)
{
seqResult = -1;
}
else
{
int ofs = pos2;
int pos3 = this._grammar._#_s_(pos2, text);
bool _N_cache_12563 = pos3 >= 0;
bool arg_27F_0;
if (_N_cache_12563)
{
if (true)
{
if (isBest)
{
arg_27F_0 = true;
}
else
{
isBest = (bestOffsets[2] < pos3);
arg_27F_0 = (isBest || bestOffsets[2] == pos3);
}
goto IL_274;
}
}
arg_27F_0 = false;
IL_274:
bool flag3 = arg_27F_0;
if (!flag3)
{
seqResult = -1;
}
else
{
int ofs2 = pos3;
int pos4 = this._grammar._#_expr_(pos3, text, 0, ref token_3);
bool _N_cache_12564 = pos4 >= 0;
bool arg_31B_0;
if (_N_cache_12564)
{
if (true)
{
if (isBest)
{
arg_31B_0 = true;
}
else
{
isBest = (bestOffsets[3] < pos4);
arg_31B_0 = (isBest || bestOffsets[3] == pos4);
}
goto IL_310;
}
}
arg_31B_0 = false;
IL_310:
bool flag4 = arg_31B_0;
if (!flag4)
{
seqResult = -1;
}
else
{
int ofs3 = pos4;
int arg_3B3_0;
if (pos4 < text.Length && text[pos4] == ':')
{
arg_3B3_0 = pos4 + 1;
}
else
{
if (this._grammar._parsingErrors._token_cond_literal_":"_ < pos4)
{
this._grammar._parsingErrors._token_cond_literal_":"_ = pos4;
}
arg_3B3_0 = -1;
}
int newPos2 = arg_3B3_0;
if (newPos2 >= 0)
{
token_4 = new NToken(pos4, newPos2);
}
int pos5 = newPos2;
bool _N_cache_12565 = pos5 >= 0;
bool arg_442_0;
if (_N_cache_12565)
{
if (true)
{
if (isBest)
{
arg_442_0 = true;
}
else
{
isBest = (bestOffsets[4] < pos5);
arg_442_0 = (isBest || bestOffsets[4] == pos5);
}
goto IL_437;
}
}
arg_442_0 = false;
IL_437:
bool flag5 = arg_442_0;
if (!flag5)
{
seqResult = -1;
}
else
{
int ofs4 = pos5;
int pos6 = this._grammar._#_s_(pos5, text);
bool _N_cache_12566 = pos6 >= 0;
bool arg_4DB_0;
if (_N_cache_12566)
{
if (true)
{
if (isBest)
{
arg_4DB_0 = true;
}
else
{
isBest = (bestOffsets[5] < pos6);
arg_4DB_0 = (isBest || bestOffsets[5] == pos6);
}
goto IL_4D0;
}
}
arg_4DB_0 = false;
IL_4D0:
bool flag6 = arg_4DB_0;
if (!flag6)
{
seqResult = -1;
}
else
{
int ofs5 = pos6;
int pos7 = this._grammar._#_expr_(pos6, text, 0, ref token_5);
bool _N_cache_12567 = pos7 >= 0;
bool arg_577_0;
if (_N_cache_12567)
{
if (true)
{
if (isBest)
{
arg_577_0 = true;
}
else
{
isBest = (bestOffsets[6] < pos7);
arg_577_0 = (isBest || bestOffsets[6] == pos7);
}
goto IL_56C;
}
}
arg_577_0 = false;
IL_56C:
bool flag7 = arg_577_0;
if (!flag7)
{
seqResult = -1;
}
else
{
int ofs6 = pos7;
int arg_623_0;
if (isBest)
{
bestOffsets[0] = pos;
bestOffsets[1] = ofs;
bestOffsets[2] = ofs2;
bestOffsets[3] = ofs3;
bestOffsets[4] = ofs4;
bestOffsets[5] = ofs5;
bestOffsets[6] = ofs6;
int i = 7;
while (i < bestOffsets.Length && bestOffsets[i] >= 0)
{
bestOffsets[i] = -1;
i++;
}
arg_623_0 = pos7;
}
else
{
arg_623_0 = -1;
}
seqResult = arg_623_0;
}
}
}
}
}
}
}
int newPos3 = seqResult;
if (newPos3 >= 0)
{
result = new CalcParser.Cond.Ast(new Location(this._grammar._parsingSource, token_6.get_Location().get_StartPos(), token_5.get_Location().get_EndPos()), list<ErrorInfo>.Nil._N_constant_object, token_6, token_2, token_3, token_4, token_5);
}
return newPos3;
}
public _#postfix#_cond_(IGrammar grammar) : base(301, '\0', '?')
{
this._grammar = (CalcParser.GrammarImpl)grammar;
}
}
public class _#postfix#_div_ : ExtensionPostfixBase<CalcParser.Expr>
{
private readonly CalcParser.GrammarImpl _grammar;
public override RuleDescriptor Descriptor
{
get
{
return CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_div_.StaticDescriptor;
}
}
public override int Parse(int startPos, int pos, string text, int[] bestOffsets, ref CalcParser.Expr result)
{
bool isBest = false;
NToken token_2 = default(NToken);
CalcParser.Expr token_3 = null;
CalcParser.Expr prefixResult = result;
int seqResult = 0;
CalcParser.Expr token_4 = prefixResult;
bool _N_cache_12741 = pos >= 0;
bool arg_AE_0;
if (_N_cache_12741)
{
if (true)
{
if (isBest)
{
arg_AE_0 = true;
}
else
{
isBest = (bestOffsets[0] < pos);
arg_AE_0 = (isBest || bestOffsets[0] == pos);
}
goto IL_A3;
}
}
arg_AE_0 = false;
IL_A3:
bool flag = arg_AE_0;
if (!flag)
{
seqResult = -1;
}
else
{
int arg_146_0;
if (pos < text.Length && text[pos] == '/')
{
arg_146_0 = pos + 1;
}
else
{
if (this._grammar._parsingErrors._token_div_literal_"/"_ < pos)
{
this._grammar._parsingErrors._token_div_literal_"/"_ = pos;
}
arg_146_0 = -1;
}
int newPos = arg_146_0;
if (newPos >= 0)
{
token_2 = new NToken(pos, newPos);
}
int pos2 = newPos;
bool _N_cache_12742 = pos2 >= 0;
bool arg_1D5_0;
if (_N_cache_12742)
{
if (true)
{
if (isBest)
{
arg_1D5_0 = true;
}
else
{
isBest = (bestOffsets[1] < pos2);
arg_1D5_0 = (isBest || bestOffsets[1] == pos2);
}
goto IL_1CA;
}
}
arg_1D5_0 = false;
IL_1CA:
bool flag2 = arg_1D5_0;
if (!flag2)
{
seqResult = -1;
}
else
{
int ofs = pos2;
int pos3 = this._grammar._#_s_(pos2, text);
bool _N_cache_12743 = pos3 >= 0;
bool arg_26E_0;
if (_N_cache_12743)
{
if (true)
{
if (isBest)
{
arg_26E_0 = true;
}
else
{
isBest = (bestOffsets[2] < pos3);
arg_26E_0 = (isBest || bestOffsets[2] == pos3);
}
goto IL_263;
}
}
arg_26E_0 = false;
IL_263:
bool flag3 = arg_26E_0;
if (!flag3)
{
seqResult = -1;
}
else
{
int ofs2 = pos3;
int pos4 = this._grammar._#_expr_(pos3, text, 20, ref token_3);
bool _N_cache_12744 = pos4 >= 0;
bool arg_30B_0;
if (_N_cache_12744)
{
if (true)
{
if (isBest)
{
arg_30B_0 = true;
}
else
{
isBest = (bestOffsets[3] < pos4);
arg_30B_0 = (isBest || bestOffsets[3] == pos4);
}
goto IL_300;
}
}
arg_30B_0 = false;
IL_300:
bool flag4 = arg_30B_0;
if (!flag4)
{
seqResult = -1;
}
else
{
int ofs3 = pos4;
int arg_3A2_0;
if (isBest)
{
bestOffsets[0] = pos;
bestOffsets[1] = ofs;
bestOffsets[2] = ofs2;
bestOffsets[3] = ofs3;
int i = 4;
while (i < bestOffsets.Length && bestOffsets[i] >= 0)
{
bestOffsets[i] = -1;
i++;
}
arg_3A2_0 = pos4;
}
else
{
arg_3A2_0 = -1;
}
seqResult = arg_3A2_0;
}
}
}
}
int newPos2 = seqResult;
if (newPos2 >= 0)
{
result = new CalcParser.Div.Ast(new Location(this._grammar._parsingSource, token_4.get_Location().get_StartPos(), token_3.get_Location().get_EndPos()), list<ErrorInfo>.Nil._N_constant_object, token_4, token_2, token_3);
}
return newPos2;
}
public _#postfix#_div_(IGrammar grammar) : base(20, '\0', '?')
{
this._grammar = (CalcParser.GrammarImpl)grammar;
}
}
public class _#postfix#_mod_ : ExtensionPostfixBase<CalcParser.Expr>
{
private readonly CalcParser.GrammarImpl _grammar;
public override RuleDescriptor Descriptor
{
get
{
return CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_mod_.StaticDescriptor;
}
}
public override int Parse(int startPos, int pos, string text, int[] bestOffsets, ref CalcParser.Expr result)
{
bool isBest = false;
NToken token_2 = default(NToken);
CalcParser.Expr token_3 = null;
CalcParser.Expr prefixResult = result;
int seqResult = 0;
CalcParser.Expr token_4 = prefixResult;
bool _N_cache_12867 = pos >= 0;
bool arg_AE_0;
if (_N_cache_12867)
{
if (true)
{
if (isBest)
{
arg_AE_0 = true;
}
else
{
isBest = (bestOffsets[0] < pos);
arg_AE_0 = (isBest || bestOffsets[0] == pos);
}
goto IL_A3;
}
}
arg_AE_0 = false;
IL_A3:
bool flag = arg_AE_0;
if (!flag)
{
seqResult = -1;
}
else
{
int arg_146_0;
if (pos < text.Length && text[pos] == '%')
{
arg_146_0 = pos + 1;
}
else
{
if (this._grammar._parsingErrors._token_mod_literal_"%"_ < pos)
{
this._grammar._parsingErrors._token_mod_literal_"%"_ = pos;
}
arg_146_0 = -1;
}
int newPos = arg_146_0;
if (newPos >= 0)
{
token_2 = new NToken(pos, newPos);
}
int pos2 = newPos;
bool _N_cache_12868 = pos2 >= 0;
bool arg_1D5_0;
if (_N_cache_12868)
{
if (true)
{
if (isBest)
{
arg_1D5_0 = true;
}
else
{
isBest = (bestOffsets[1] < pos2);
arg_1D5_0 = (isBest || bestOffsets[1] == pos2);
}
goto IL_1CA;
}
}
arg_1D5_0 = false;
IL_1CA:
bool flag2 = arg_1D5_0;
if (!flag2)
{
seqResult = -1;
}
else
{
int ofs = pos2;
int pos3 = this._grammar._#_s_(pos2, text);
bool _N_cache_12869 = pos3 >= 0;
bool arg_26E_0;
if (_N_cache_12869)
{
if (true)
{
if (isBest)
{
arg_26E_0 = true;
}
else
{
isBest = (bestOffsets[2] < pos3);
arg_26E_0 = (isBest || bestOffsets[2] == pos3);
}
goto IL_263;
}
}
arg_26E_0 = false;
IL_263:
bool flag3 = arg_26E_0;
if (!flag3)
{
seqResult = -1;
}
else
{
int ofs2 = pos3;
int pos4 = this._grammar._#_expr_(pos3, text, 20, ref token_3);
bool _N_cache_12870 = pos4 >= 0;
bool arg_30B_0;
if (_N_cache_12870)
{
if (true)
{
if (isBest)
{
arg_30B_0 = true;
}
else
{
isBest = (bestOffsets[3] < pos4);
arg_30B_0 = (isBest || bestOffsets[3] == pos4);
}
goto IL_300;
}
}
arg_30B_0 = false;
IL_300:
bool flag4 = arg_30B_0;
if (!flag4)
{
seqResult = -1;
}
else
{
int ofs3 = pos4;
int arg_3A2_0;
if (isBest)
{
bestOffsets[0] = pos;
bestOffsets[1] = ofs;
bestOffsets[2] = ofs2;
bestOffsets[3] = ofs3;
int i = 4;
while (i < bestOffsets.Length && bestOffsets[i] >= 0)
{
bestOffsets[i] = -1;
i++;
}
arg_3A2_0 = pos4;
}
else
{
arg_3A2_0 = -1;
}
seqResult = arg_3A2_0;
}
}
}
}
int newPos2 = seqResult;
if (newPos2 >= 0)
{
result = new CalcParser.Mod.Ast(new Location(this._grammar._parsingSource, token_4.get_Location().get_StartPos(), token_3.get_Location().get_EndPos()), list<ErrorInfo>.Nil._N_constant_object, token_4, token_2, token_3);
}
return newPos2;
}
public _#postfix#_mod_(IGrammar grammar) : base(20, '\0', '?')
{
this._grammar = (CalcParser.GrammarImpl)grammar;
}
}
public class _#postfix#_mul_ : ExtensionPostfixBase<CalcParser.Expr>
{
private readonly CalcParser.GrammarImpl _grammar;
public override RuleDescriptor Descriptor
{
get
{
return CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_mul_.StaticDescriptor;
}
}
public override int Parse(int startPos, int pos, string text, int[] bestOffsets, ref CalcParser.Expr result)
{
bool isBest = false;
NToken token_2 = default(NToken);
CalcParser.Expr token_3 = null;
CalcParser.Expr prefixResult = result;
int seqResult = 0;
CalcParser.Expr token_4 = prefixResult;
bool _N_cache_12993 = pos >= 0;
bool arg_AE_0;
if (_N_cache_12993)
{
if (true)
{
if (isBest)
{
arg_AE_0 = true;
}
else
{
isBest = (bestOffsets[0] < pos);
arg_AE_0 = (isBest || bestOffsets[0] == pos);
}
goto IL_A3;
}
}
arg_AE_0 = false;
IL_A3:
bool flag = arg_AE_0;
if (!flag)
{
seqResult = -1;
}
else
{
int arg_146_0;
if (pos < text.Length && text[pos] == '*')
{
arg_146_0 = pos + 1;
}
else
{
if (this._grammar._parsingErrors._token_mul_literal_"*"_ < pos)
{
this._grammar._parsingErrors._token_mul_literal_"*"_ = pos;
}
arg_146_0 = -1;
}
int newPos = arg_146_0;
if (newPos >= 0)
{
token_2 = new NToken(pos, newPos);
}
int pos2 = newPos;
bool _N_cache_12994 = pos2 >= 0;
bool arg_1D5_0;
if (_N_cache_12994)
{
if (true)
{
if (isBest)
{
arg_1D5_0 = true;
}
else
{
isBest = (bestOffsets[1] < pos2);
arg_1D5_0 = (isBest || bestOffsets[1] == pos2);
}
goto IL_1CA;
}
}
arg_1D5_0 = false;
IL_1CA:
bool flag2 = arg_1D5_0;
if (!flag2)
{
seqResult = -1;
}
else
{
int ofs = pos2;
int pos3 = this._grammar._#_s_(pos2, text);
bool _N_cache_12995 = pos3 >= 0;
bool arg_26E_0;
if (_N_cache_12995)
{
if (true)
{
if (isBest)
{
arg_26E_0 = true;
}
else
{
isBest = (bestOffsets[2] < pos3);
arg_26E_0 = (isBest || bestOffsets[2] == pos3);
}
goto IL_263;
}
}
arg_26E_0 = false;
IL_263:
bool flag3 = arg_26E_0;
if (!flag3)
{
seqResult = -1;
}
else
{
int ofs2 = pos3;
int pos4 = this._grammar._#_expr_(pos3, text, 20, ref token_3);
bool _N_cache_12996 = pos4 >= 0;
bool arg_30B_0;
if (_N_cache_12996)
{
if (true)
{
if (isBest)
{
arg_30B_0 = true;
}
else
{
isBest = (bestOffsets[3] < pos4);
arg_30B_0 = (isBest || bestOffsets[3] == pos4);
}
goto IL_300;
}
}
arg_30B_0 = false;
IL_300:
bool flag4 = arg_30B_0;
if (!flag4)
{
seqResult = -1;
}
else
{
int ofs3 = pos4;
int arg_3A2_0;
if (isBest)
{
bestOffsets[0] = pos;
bestOffsets[1] = ofs;
bestOffsets[2] = ofs2;
bestOffsets[3] = ofs3;
int i = 4;
while (i < bestOffsets.Length && bestOffsets[i] >= 0)
{
bestOffsets[i] = -1;
i++;
}
arg_3A2_0 = pos4;
}
else
{
arg_3A2_0 = -1;
}
seqResult = arg_3A2_0;
}
}
}
}
int newPos2 = seqResult;
if (newPos2 >= 0)
{
result = new CalcParser.Mul.Ast(new Location(this._grammar._parsingSource, token_4.get_Location().get_StartPos(), token_3.get_Location().get_EndPos()), list<ErrorInfo>.Nil._N_constant_object, token_4, token_2, token_3);
}
return newPos2;
}
public _#postfix#_mul_(IGrammar grammar) : base(20, '\0', '?')
{
this._grammar = (CalcParser.GrammarImpl)grammar;
}
}
public class _#prefix#__neg_ : ExtensionPrefixBase<CalcParser.Expr>
{
private readonly CalcParser.GrammarImpl _grammar;
public override RuleDescriptor Descriptor
{
get
{
return CalcParser.GrammarImpl.GrammarDescriptorImpl._#prefix#__neg_.StaticDescriptor;
}
}
public override int Parse(int pos, string text, int[] bestOffsets, ref CalcParser.Expr result)
{
bool isBest = false;
NToken token_ = default(NToken);
CalcParser.Expr token_2 = null;
int seqResult = 0;
int arg_A1_0;
if (pos < text.Length && text[pos] == '-')
{
arg_A1_0 = pos + 1;
}
else
{
if (this._grammar._parsingErrors._token_neg_literal_"-"_ < pos)
{
this._grammar._parsingErrors._token_neg_literal_"-"_ = pos;
}
arg_A1_0 = -1;
}
int newPos = arg_A1_0;
if (newPos >= 0)
{
token_ = new NToken(pos, newPos);
}
int pos2 = newPos;
bool _N_cache_13124 = pos2 >= 0;
bool arg_12C_0;
if (_N_cache_13124)
{
if (true)
{
if (isBest)
{
arg_12C_0 = true;
}
else
{
isBest = (bestOffsets[0] < pos2);
arg_12C_0 = (isBest || bestOffsets[0] == pos2);
}
goto IL_121;
}
}
arg_12C_0 = false;
IL_121:
bool flag = arg_12C_0;
if (!flag)
{
seqResult = -1;
}
else
{
int ofs0 = pos2;
int pos3 = this._grammar._#_s_(pos2, text);
bool _N_cache_13125 = pos3 >= 0;
bool arg_1C3_0;
if (_N_cache_13125)
{
if (true)
{
if (isBest)
{
arg_1C3_0 = true;
}
else
{
isBest = (bestOffsets[1] < pos3);
arg_1C3_0 = (isBest || bestOffsets[1] == pos3);
}
goto IL_1B8;
}
}
arg_1C3_0 = false;
IL_1B8:
bool flag2 = arg_1C3_0;
if (!flag2)
{
seqResult = -1;
}
else
{
int ofs = pos3;
int pos4 = this._grammar._#_expr_(pos3, text, 100, ref token_2);
bool _N_cache_13126 = pos4 >= 0;
bool arg_25E_0;
if (_N_cache_13126)
{
if (true)
{
if (isBest)
{
arg_25E_0 = true;
}
else
{
isBest = (bestOffsets[2] < pos4);
arg_25E_0 = (isBest || bestOffsets[2] == pos4);
}
goto IL_253;
}
}
arg_25E_0 = false;
IL_253:
bool flag3 = arg_25E_0;
if (!flag3)
{
seqResult = -1;
}
else
{
int ofs2 = pos4;
int arg_2E8_0;
if (isBest)
{
bestOffsets[0] = ofs0;
bestOffsets[1] = ofs;
bestOffsets[2] = ofs2;
int i = 3;
while (i < bestOffsets.Length && bestOffsets[i] >= 0)
{
bestOffsets[i] = -1;
i++;
}
arg_2E8_0 = pos4;
}
else
{
arg_2E8_0 = -1;
}
seqResult = arg_2E8_0;
}
}
}
int newPos2 = seqResult;
if (newPos2 >= 0)
{
result = new CalcParser.Neg.Ast(new Location(this._grammar._parsingSource, token_.get_StartPos(), token_2.get_Location().get_EndPos()), list<ErrorInfo>.Nil._N_constant_object, token_, token_2);
}
return newPos2;
}
public _#prefix#__neg_(IGrammar grammar) : base('\0', '?')
{
this._grammar = (CalcParser.GrammarImpl)grammar;
}
}
public class _#prefix#__num_ : ExtensionPrefixBase<CalcParser.Expr>
{
private readonly CalcParser.GrammarImpl _grammar;
public override RuleDescriptor Descriptor
{
get
{
return CalcParser.GrammarImpl.GrammarDescriptorImpl._#prefix#__num_.StaticDescriptor;
}
}
public override int Parse(int pos, string text, int[] bestOffsets, ref CalcParser.Expr result)
{
bool isBest = false;
NumParser.Number token_ = null;
int seqResult = 0;
int pos2 = this._grammar._#grammar#1._#_number_(pos, text, ref token_);
bool _N_cache_13212 = pos2 >= 0;
bool arg_9E_0;
if (_N_cache_13212)
{
if (true)
{
if (isBest)
{
arg_9E_0 = true;
}
else
{
isBest = (bestOffsets[0] < pos2);
arg_9E_0 = (isBest || bestOffsets[0] == pos2);
}
goto IL_93;
}
}
arg_9E_0 = false;
IL_93:
bool flag = arg_9E_0;
if (!flag)
{
seqResult = -1;
}
else
{
int ofs0 = pos2;
int pos3 = this._grammar._#_s_(pos2, text);
bool _N_cache_13213 = pos3 >= 0;
bool arg_134_0;
if (_N_cache_13213)
{
if (true)
{
if (isBest)
{
arg_134_0 = true;
}
else
{
isBest = (bestOffsets[1] < pos3);
arg_134_0 = (isBest || bestOffsets[1] == pos3);
}
goto IL_129;
}
}
arg_134_0 = false;
IL_129:
bool flag2 = arg_134_0;
if (!flag2)
{
seqResult = -1;
}
else
{
int ofs = pos3;
int arg_1B7_0;
if (isBest)
{
bestOffsets[0] = ofs0;
bestOffsets[1] = ofs;
int i = 2;
while (i < bestOffsets.Length && bestOffsets[i] >= 0)
{
bestOffsets[i] = -1;
i++;
}
arg_1B7_0 = pos3;
}
else
{
arg_1B7_0 = -1;
}
seqResult = arg_1B7_0;
}
}
int newPos = seqResult;
if (newPos >= 0)
{
result = new CalcParser.Num.Ast(new Location(this._grammar._parsingSource, token_.get_Location().get_StartPos(), token_.get_Location().get_EndPos()), list<ErrorInfo>.Nil._N_constant_object, token_);
}
return newPos;
}
public _#prefix#__num_(IGrammar grammar) : base('\0', '?')
{
this._grammar = (CalcParser.GrammarImpl)grammar;
}
}
public class _#postfix#_postfixDec_ : ExtensionPostfixBase<CalcParser.Expr>
{
private readonly CalcParser.GrammarImpl _grammar;
public override RuleDescriptor Descriptor
{
get
{
return CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_postfixDec_.StaticDescriptor;
}
}
public override int Parse(int startPos, int pos, string text, int[] bestOffsets, ref CalcParser.Expr result)
{
bool isBest = false;
NToken token_2 = default(NToken);
CalcParser.Expr prefixResult = result;
int seqResult = 0;
CalcParser.Expr token_3 = prefixResult;
bool _N_cache_13294 = pos >= 0;
bool arg_AA_0;
if (_N_cache_13294)
{
if (true)
{
if (isBest)
{
arg_AA_0 = true;
}
else
{
isBest = (bestOffsets[0] < pos);
arg_AA_0 = (isBest || bestOffsets[0] == pos);
}
goto IL_9F;
}
}
arg_AA_0 = false;
IL_9F:
bool flag = arg_AA_0;
if (!flag)
{
seqResult = -1;
}
else
{
int arg_15F_0;
if (pos + 1 < text.Length && text[pos] == '-' && text[pos + 1] == '-')
{
arg_15F_0 = pos + 2;
}
else
{
if (this._grammar._parsingErrors._token_postfixDec_literal_"--"_ < pos)
{
this._grammar._parsingErrors._token_postfixDec_literal_"--"_ = pos;
}
arg_15F_0 = -1;
}
int newPos = arg_15F_0;
if (newPos >= 0)
{
token_2 = new NToken(pos, newPos);
}
int pos2 = newPos;
bool _N_cache_13295 = pos2 >= 0;
bool arg_1EE_0;
if (_N_cache_13295)
{
if (true)
{
if (isBest)
{
arg_1EE_0 = true;
}
else
{
isBest = (bestOffsets[1] < pos2);
arg_1EE_0 = (isBest || bestOffsets[1] == pos2);
}
goto IL_1E3;
}
}
arg_1EE_0 = false;
IL_1E3:
bool flag2 = arg_1EE_0;
if (!flag2)
{
seqResult = -1;
}
else
{
int ofs = pos2;
int pos3 = this._grammar._#_s_(pos2, text);
bool _N_cache_13296 = pos3 >= 0;
bool arg_287_0;
if (_N_cache_13296)
{
if (true)
{
if (isBest)
{
arg_287_0 = true;
}
else
{
isBest = (bestOffsets[2] < pos3);
arg_287_0 = (isBest || bestOffsets[2] == pos3);
}
goto IL_27C;
}
}
arg_287_0 = false;
IL_27C:
bool flag3 = arg_287_0;
if (!flag3)
{
seqResult = -1;
}
else
{
int ofs2 = pos3;
int arg_317_0;
if (isBest)
{
bestOffsets[0] = pos;
bestOffsets[1] = ofs;
bestOffsets[2] = ofs2;
int i = 3;
while (i < bestOffsets.Length && bestOffsets[i] >= 0)
{
bestOffsets[i] = -1;
i++;
}
arg_317_0 = pos3;
}
else
{
arg_317_0 = -1;
}
seqResult = arg_317_0;
}
}
}
int newPos2 = seqResult;
if (newPos2 >= 0)
{
result = new CalcParser.PostfixDec.Ast(new Location(this._grammar._parsingSource, token_3.get_Location().get_StartPos(), token_2.get_EndPos()), list<ErrorInfo>.Nil._N_constant_object, token_3, token_2);
}
return newPos2;
}
public _#postfix#_postfixDec_(IGrammar grammar) : base(200, '\0', '?')
{
this._grammar = (CalcParser.GrammarImpl)grammar;
}
}
public class _#postfix#_pow_ : ExtensionPostfixBase<CalcParser.Expr>
{
private readonly CalcParser.GrammarImpl _grammar;
public override RuleDescriptor Descriptor
{
get
{
return CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_pow_.StaticDescriptor;
}
}
public override int Parse(int startPos, int pos, string text, int[] bestOffsets, ref CalcParser.Expr result)
{
bool isBest = false;
NToken token_2 = default(NToken);
CalcParser.Expr token_3 = null;
CalcParser.Expr prefixResult = result;
int seqResult = 0;
CalcParser.Expr token_4 = prefixResult;
bool _N_cache_13409 = pos >= 0;
bool arg_AE_0;
if (_N_cache_13409)
{
if (true)
{
if (isBest)
{
arg_AE_0 = true;
}
else
{
isBest = (bestOffsets[0] < pos);
arg_AE_0 = (isBest || bestOffsets[0] == pos);
}
goto IL_A3;
}
}
arg_AE_0 = false;
IL_A3:
bool flag = arg_AE_0;
if (!flag)
{
seqResult = -1;
}
else
{
int arg_146_0;
if (pos < text.Length && text[pos] == '^')
{
arg_146_0 = pos + 1;
}
else
{
if (this._grammar._parsingErrors._token_pow_literal_"^"_ < pos)
{
this._grammar._parsingErrors._token_pow_literal_"^"_ = pos;
}
arg_146_0 = -1;
}
int newPos = arg_146_0;
if (newPos >= 0)
{
token_2 = new NToken(pos, newPos);
}
int pos2 = newPos;
bool _N_cache_13410 = pos2 >= 0;
bool arg_1D5_0;
if (_N_cache_13410)
{
if (true)
{
if (isBest)
{
arg_1D5_0 = true;
}
else
{
isBest = (bestOffsets[1] < pos2);
arg_1D5_0 = (isBest || bestOffsets[1] == pos2);
}
goto IL_1CA;
}
}
arg_1D5_0 = false;
IL_1CA:
bool flag2 = arg_1D5_0;
if (!flag2)
{
seqResult = -1;
}
else
{
int ofs = pos2;
int pos3 = this._grammar._#_s_(pos2, text);
bool _N_cache_13411 = pos3 >= 0;
bool arg_26E_0;
if (_N_cache_13411)
{
if (true)
{
if (isBest)
{
arg_26E_0 = true;
}
else
{
isBest = (bestOffsets[2] < pos3);
arg_26E_0 = (isBest || bestOffsets[2] == pos3);
}
goto IL_263;
}
}
arg_26E_0 = false;
IL_263:
bool flag3 = arg_26E_0;
if (!flag3)
{
seqResult = -1;
}
else
{
int ofs2 = pos3;
int pos4 = this._grammar._#_expr_(pos3, text, 30, ref token_3);
bool _N_cache_13412 = pos4 >= 0;
bool arg_30B_0;
if (_N_cache_13412)
{
if (true)
{
if (isBest)
{
arg_30B_0 = true;
}
else
{
isBest = (bestOffsets[3] < pos4);
arg_30B_0 = (isBest || bestOffsets[3] == pos4);
}
goto IL_300;
}
}
arg_30B_0 = false;
IL_300:
bool flag4 = arg_30B_0;
if (!flag4)
{
seqResult = -1;
}
else
{
int ofs3 = pos4;
int arg_3A2_0;
if (isBest)
{
bestOffsets[0] = pos;
bestOffsets[1] = ofs;
bestOffsets[2] = ofs2;
bestOffsets[3] = ofs3;
int i = 4;
while (i < bestOffsets.Length && bestOffsets[i] >= 0)
{
bestOffsets[i] = -1;
i++;
}
arg_3A2_0 = pos4;
}
else
{
arg_3A2_0 = -1;
}
seqResult = arg_3A2_0;
}
}
}
}
int newPos2 = seqResult;
if (newPos2 >= 0)
{
result = new CalcParser.Pow.Ast(new Location(this._grammar._parsingSource, token_4.get_Location().get_StartPos(), token_3.get_Location().get_EndPos()), list<ErrorInfo>.Nil._N_constant_object, token_4, token_2, token_3);
}
return newPos2;
}
public _#postfix#_pow_(IGrammar grammar) : base(31, '\0', '?')
{
this._grammar = (CalcParser.GrammarImpl)grammar;
}
}
public class _#prefix#__prefixDec_ : ExtensionPrefixBase<CalcParser.Expr>
{
private readonly CalcParser.GrammarImpl _grammar;
public override RuleDescriptor Descriptor
{
get
{
return CalcParser.GrammarImpl.GrammarDescriptorImpl._#prefix#__prefixDec_.StaticDescriptor;
}
}
public override int Parse(int pos, string text, int[] bestOffsets, ref CalcParser.Expr result)
{
bool isBest = false;
NToken token_ = default(NToken);
CalcParser.Expr token_2 = null;
int seqResult = 0;
int arg_BD_0;
if (pos + 1 < text.Length && text[pos] == '-' && text[pos + 1] == '-')
{
arg_BD_0 = pos + 2;
}
else
{
if (this._grammar._parsingErrors._token_prefixDec_literal_"--"_ < pos)
{
this._grammar._parsingErrors._token_prefixDec_literal_"--"_ = pos;
}
arg_BD_0 = -1;
}
int newPos = arg_BD_0;
if (newPos >= 0)
{
token_ = new NToken(pos, newPos);
}
int pos2 = newPos;
bool _N_cache_13543 = pos2 >= 0;
bool arg_148_0;
if (_N_cache_13543)
{
if (true)
{
if (isBest)
{
arg_148_0 = true;
}
else
{
isBest = (bestOffsets[0] < pos2);
arg_148_0 = (isBest || bestOffsets[0] == pos2);
}
goto IL_13D;
}
}
arg_148_0 = false;
IL_13D:
bool flag = arg_148_0;
if (!flag)
{
seqResult = -1;
}
else
{
int ofs0 = pos2;
int pos3 = this._grammar._#_s_(pos2, text);
bool _N_cache_13544 = pos3 >= 0;
bool arg_1DF_0;
if (_N_cache_13544)
{
if (true)
{
if (isBest)
{
arg_1DF_0 = true;
}
else
{
isBest = (bestOffsets[1] < pos3);
arg_1DF_0 = (isBest || bestOffsets[1] == pos3);
}
goto IL_1D4;
}
}
arg_1DF_0 = false;
IL_1D4:
bool flag2 = arg_1DF_0;
if (!flag2)
{
seqResult = -1;
}
else
{
int ofs = pos3;
int pos4 = this._grammar._#_expr_(pos3, text, 200, ref token_2);
bool _N_cache_13545 = pos4 >= 0;
bool arg_27D_0;
if (_N_cache_13545)
{
if (true)
{
if (isBest)
{
arg_27D_0 = true;
}
else
{
isBest = (bestOffsets[2] < pos4);
arg_27D_0 = (isBest || bestOffsets[2] == pos4);
}
goto IL_272;
}
}
arg_27D_0 = false;
IL_272:
bool flag3 = arg_27D_0;
if (!flag3)
{
seqResult = -1;
}
else
{
int ofs2 = pos4;
int arg_307_0;
if (isBest)
{
bestOffsets[0] = ofs0;
bestOffsets[1] = ofs;
bestOffsets[2] = ofs2;
int i = 3;
while (i < bestOffsets.Length && bestOffsets[i] >= 0)
{
bestOffsets[i] = -1;
i++;
}
arg_307_0 = pos4;
}
else
{
arg_307_0 = -1;
}
seqResult = arg_307_0;
}
}
}
int newPos2 = seqResult;
if (newPos2 >= 0)
{
result = new CalcParser.PrefixDec.Ast(new Location(this._grammar._parsingSource, token_.get_StartPos(), token_2.get_Location().get_EndPos()), list<ErrorInfo>.Nil._N_constant_object, token_, token_2);
}
return newPos2;
}
public _#prefix#__prefixDec_(IGrammar grammar) : base('\0', '?')
{
this._grammar = (CalcParser.GrammarImpl)grammar;
}
}
public class _#prefix#__rounds_ : ExtensionPrefixBase<CalcParser.Expr>
{
private readonly CalcParser.GrammarImpl _grammar;
public override RuleDescriptor Descriptor
{
get
{
return CalcParser.GrammarImpl.GrammarDescriptorImpl._#prefix#__rounds_.StaticDescriptor;
}
}
public override int Parse(int pos, string text, int[] bestOffsets, ref CalcParser.Expr result)
{
bool isBest = false;
NToken token_ = default(NToken);
CalcParser.Expr token_2 = null;
NToken token_3 = default(NToken);
int seqResult = 0;
int arg_AE_0;
if (pos < text.Length && text[pos] == '(')
{
arg_AE_0 = pos + 1;
}
else
{
if (this._grammar._parsingErrors._token_rounds_literal_"("_ < pos)
{
this._grammar._parsingErrors._token_rounds_literal_"("_ = pos;
}
arg_AE_0 = -1;
}
int newPos = arg_AE_0;
if (newPos >= 0)
{
token_ = new NToken(pos, newPos);
}
int pos2 = newPos;
bool _N_cache_13656 = pos2 >= 0;
bool arg_139_0;
if (_N_cache_13656)
{
if (true)
{
if (isBest)
{
arg_139_0 = true;
}
else
{
isBest = (bestOffsets[0] < pos2);
arg_139_0 = (isBest || bestOffsets[0] == pos2);
}
goto IL_12E;
}
}
arg_139_0 = false;
IL_12E:
bool flag = arg_139_0;
if (!flag)
{
seqResult = -1;
}
else
{
int ofs0 = pos2;
int pos3 = this._grammar._#_s_(pos2, text);
bool _N_cache_13657 = pos3 >= 0;
bool arg_1D0_0;
if (_N_cache_13657)
{
if (true)
{
if (isBest)
{
arg_1D0_0 = true;
}
else
{
isBest = (bestOffsets[1] < pos3);
arg_1D0_0 = (isBest || bestOffsets[1] == pos3);
}
goto IL_1C5;
}
}
arg_1D0_0 = false;
IL_1C5:
bool flag2 = arg_1D0_0;
if (!flag2)
{
seqResult = -1;
}
else
{
int ofs = pos3;
int pos4 = this._grammar._#_expr_(pos3, text, 0, ref token_2);
bool _N_cache_13658 = pos4 >= 0;
bool arg_26A_0;
if (_N_cache_13658)
{
if (true)
{
if (isBest)
{
arg_26A_0 = true;
}
else
{
isBest = (bestOffsets[2] < pos4);
arg_26A_0 = (isBest || bestOffsets[2] == pos4);
}
goto IL_25F;
}
}
arg_26A_0 = false;
IL_25F:
bool flag3 = arg_26A_0;
if (!flag3)
{
seqResult = -1;
}
else
{
int ofs2 = pos4;
int arg_302_0;
if (pos4 < text.Length && text[pos4] == ')')
{
arg_302_0 = pos4 + 1;
}
else
{
if (this._grammar._parsingErrors._token_rounds_literal_")"_ < pos4)
{
this._grammar._parsingErrors._token_rounds_literal_")"_ = pos4;
}
arg_302_0 = -1;
}
int newPos2 = arg_302_0;
if (newPos2 >= 0)
{
token_3 = new NToken(pos4, newPos2);
}
int pos5 = newPos2;
bool _N_cache_13659 = pos5 >= 0;
bool arg_38F_0;
if (_N_cache_13659)
{
if (true)
{
if (isBest)
{
arg_38F_0 = true;
}
else
{
isBest = (bestOffsets[3] < pos5);
arg_38F_0 = (isBest || bestOffsets[3] == pos5);
}
goto IL_384;
}
}
arg_38F_0 = false;
IL_384:
bool flag4 = arg_38F_0;
if (!flag4)
{
seqResult = -1;
}
else
{
int ofs3 = pos5;
int pos6 = this._grammar._#_s_(pos5, text);
bool _N_cache_13660 = pos6 >= 0;
bool arg_426_0;
if (_N_cache_13660)
{
if (true)
{
if (isBest)
{
arg_426_0 = true;
}
else
{
isBest = (bestOffsets[4] < pos6);
arg_426_0 = (isBest || bestOffsets[4] == pos6);
}
goto IL_41B;
}
}
arg_426_0 = false;
IL_41B:
bool flag5 = arg_426_0;
if (!flag5)
{
seqResult = -1;
}
else
{
int ofs4 = pos6;
int arg_4BC_0;
if (isBest)
{
bestOffsets[0] = ofs0;
bestOffsets[1] = ofs;
bestOffsets[2] = ofs2;
bestOffsets[3] = ofs3;
bestOffsets[4] = ofs4;
int i = 5;
while (i < bestOffsets.Length && bestOffsets[i] >= 0)
{
bestOffsets[i] = -1;
i++;
}
arg_4BC_0 = pos6;
}
else
{
arg_4BC_0 = -1;
}
seqResult = arg_4BC_0;
}
}
}
}
}
int newPos3 = seqResult;
if (newPos3 >= 0)
{
result = new CalcParser.Rounds.Ast(new Location(this._grammar._parsingSource, token_.get_StartPos(), token_3.get_EndPos()), list<ErrorInfo>.Nil._N_constant_object, token_, token_2, token_3);
}
return newPos3;
}
public _#prefix#__rounds_(IGrammar grammar) : base('\0', '?')
{
this._grammar = (CalcParser.GrammarImpl)grammar;
}
}
public class _#prefix#__seq_ : ExtensionPrefixBase<CalcParser.Expr>
{
private readonly CalcParser.GrammarImpl _grammar;
public override RuleDescriptor Descriptor
{
get
{
return CalcParser.GrammarImpl.GrammarDescriptorImpl._#prefix#__seq_.StaticDescriptor;
}
}
public override int Parse(int pos, string text, int[] bestOffsets, ref CalcParser.Expr result)
{
bool isBest = false;
NToken token_ = default(NToken);
list<CalcParser.Expr> token_2 = null;
NToken token_3 = default(NToken);
int seqResult = 0;
int arg_AE_0;
if (pos < text.Length && text[pos] == '{')
{
arg_AE_0 = pos + 1;
}
else
{
if (this._grammar._parsingErrors._token_seq_literal_"{"_ < pos)
{
this._grammar._parsingErrors._token_seq_literal_"{"_ = pos;
}
arg_AE_0 = -1;
}
int newPos = arg_AE_0;
if (newPos >= 0)
{
token_ = new NToken(pos, newPos);
}
int pos2 = newPos;
bool _N_cache_13819 = pos2 >= 0;
bool arg_139_0;
if (_N_cache_13819)
{
if (true)
{
if (isBest)
{
arg_139_0 = true;
}
else
{
isBest = (bestOffsets[0] < pos2);
arg_139_0 = (isBest || bestOffsets[0] == pos2);
}
goto IL_12E;
}
}
arg_139_0 = false;
IL_12E:
bool flag = arg_139_0;
if (!flag)
{
seqResult = -1;
}
else
{
int ofs0 = pos2;
int pos3 = this._grammar._#_s_(pos2, text);
bool _N_cache_13820 = pos3 >= 0;
bool arg_1D0_0;
if (_N_cache_13820)
{
if (true)
{
if (isBest)
{
arg_1D0_0 = true;
}
else
{
isBest = (bestOffsets[1] < pos3);
arg_1D0_0 = (isBest || bestOffsets[1] == pos3);
}
goto IL_1C5;
}
}
arg_1D0_0 = false;
IL_1C5:
bool flag2 = arg_1D0_0;
if (!flag2)
{
seqResult = -1;
}
else
{
int ofs = pos3;
List<CalcParser.Expr> tmpList = new List<CalcParser.Expr>();
CalcParser.Expr token_4 = null;
int num = pos3;
while (true)
{
int newPos2 = this._grammar._#_expr_(num, text, 0, ref token_4);
if (newPos2 < 0)
{
break;
}
tmpList.Add(token_4);
num = newPos2;
}
int newPos3 = num;
token_2 = NCollectionsExtensions.NToList<CalcParser.Expr>(tmpList);
int pos4 = newPos3;
bool _N_cache_13821 = pos4 >= 0;
bool arg_2C8_0;
if (_N_cache_13821)
{
if (true)
{
if (isBest)
{
arg_2C8_0 = true;
}
else
{
isBest = (bestOffsets[2] < pos4);
arg_2C8_0 = (isBest || bestOffsets[2] == pos4);
}
goto IL_2BD;
}
}
arg_2C8_0 = false;
IL_2BD:
bool flag3 = arg_2C8_0;
if (!flag3)
{
seqResult = -1;
}
else
{
int ofs2 = pos4;
int arg_360_0;
if (pos4 < text.Length && text[pos4] == '}')
{
arg_360_0 = pos4 + 1;
}
else
{
if (this._grammar._parsingErrors._token_seq_literal_"}"_ < pos4)
{
this._grammar._parsingErrors._token_seq_literal_"}"_ = pos4;
}
arg_360_0 = -1;
}
int newPos4 = arg_360_0;
if (newPos4 >= 0)
{
token_3 = new NToken(pos4, newPos4);
}
int pos5 = newPos4;
bool _N_cache_13822 = pos5 >= 0;
bool arg_3ED_0;
if (_N_cache_13822)
{
if (true)
{
if (isBest)
{
arg_3ED_0 = true;
}
else
{
isBest = (bestOffsets[3] < pos5);
arg_3ED_0 = (isBest || bestOffsets[3] == pos5);
}
goto IL_3E2;
}
}
arg_3ED_0 = false;
IL_3E2:
bool flag4 = arg_3ED_0;
if (!flag4)
{
seqResult = -1;
}
else
{
int ofs3 = pos5;
int pos6 = this._grammar._#_s_(pos5, text);
bool _N_cache_13823 = pos6 >= 0;
bool arg_484_0;
if (_N_cache_13823)
{
if (true)
{
if (isBest)
{
arg_484_0 = true;
}
else
{
isBest = (bestOffsets[4] < pos6);
arg_484_0 = (isBest || bestOffsets[4] == pos6);
}
goto IL_479;
}
}
arg_484_0 = false;
IL_479:
bool flag5 = arg_484_0;
if (!flag5)
{
seqResult = -1;
}
else
{
int ofs4 = pos6;
int arg_51A_0;
if (isBest)
{
bestOffsets[0] = ofs0;
bestOffsets[1] = ofs;
bestOffsets[2] = ofs2;
bestOffsets[3] = ofs3;
bestOffsets[4] = ofs4;
int i = 5;
while (i < bestOffsets.Length && bestOffsets[i] >= 0)
{
bestOffsets[i] = -1;
i++;
}
arg_51A_0 = pos6;
}
else
{
arg_51A_0 = -1;
}
seqResult = arg_51A_0;
}
}
}
}
}
int newPos5 = seqResult;
if (newPos5 >= 0)
{
result = new CalcParser.Seq.Ast(new Location(this._grammar._parsingSource, token_.get_StartPos(), token_3.get_EndPos()), list<ErrorInfo>.Nil._N_constant_object, token_, token_2, token_3);
}
return newPos5;
}
public _#prefix#__seq_(IGrammar grammar) : base('\0', '?')
{
this._grammar = (CalcParser.GrammarImpl)grammar;
}
}
public class _#postfix#_sub_ : ExtensionPostfixBase<CalcParser.Expr>
{
private readonly CalcParser.GrammarImpl _grammar;
public override RuleDescriptor Descriptor
{
get
{
return CalcParser.GrammarImpl.GrammarDescriptorImpl._#postfix#_sub_.StaticDescriptor;
}
}
public override int Parse(int startPos, int pos, string text, int[] bestOffsets, ref CalcParser.Expr result)
{
bool isBest = false;
NToken token_2 = default(NToken);
CalcParser.Expr token_3 = null;
CalcParser.Expr prefixResult = result;
int seqResult = 0;
CalcParser.Expr token_4 = prefixResult;
bool _N_cache_13963 = pos >= 0;
bool arg_AE_0;
if (_N_cache_13963)
{
if (true)
{
if (isBest)
{
arg_AE_0 = true;
}
else
{
isBest = (bestOffsets[0] < pos);
arg_AE_0 = (isBest || bestOffsets[0] == pos);
}
goto IL_A3;
}
}
arg_AE_0 = false;
IL_A3:
bool flag = arg_AE_0;
if (!flag)
{
seqResult = -1;
}
else
{
int arg_146_0;
if (pos < text.Length && text[pos] == '-')
{
arg_146_0 = pos + 1;
}
else
{
if (this._grammar._parsingErrors._token_sub_literal_"-"_ < pos)
{
this._grammar._parsingErrors._token_sub_literal_"-"_ = pos;
}
arg_146_0 = -1;
}
int newPos = arg_146_0;
if (newPos >= 0)
{
token_2 = new NToken(pos, newPos);
}
int pos2 = newPos;
bool _N_cache_13964 = pos2 >= 0;
bool arg_1D5_0;
if (_N_cache_13964)
{
if (true)
{
if (isBest)
{
arg_1D5_0 = true;
}
else
{
isBest = (bestOffsets[1] < pos2);
arg_1D5_0 = (isBest || bestOffsets[1] == pos2);
}
goto IL_1CA;
}
}
arg_1D5_0 = false;
IL_1CA:
bool flag2 = arg_1D5_0;
if (!flag2)
{
seqResult = -1;
}
else
{
int ofs = pos2;
int pos3 = this._grammar._#_s_(pos2, text);
bool _N_cache_13965 = pos3 >= 0;
bool arg_26E_0;
if (_N_cache_13965)
{
if (true)
{
if (isBest)
{
arg_26E_0 = true;
}
else
{
isBest = (bestOffsets[2] < pos3);
arg_26E_0 = (isBest || bestOffsets[2] == pos3);
}
goto IL_263;
}
}
arg_26E_0 = false;
IL_263:
bool flag3 = arg_26E_0;
if (!flag3)
{
seqResult = -1;
}
else
{
int ofs2 = pos3;
int pos4 = this._grammar._#_expr_(pos3, text, 10, ref token_3);
bool _N_cache_13966 = pos4 >= 0;
bool arg_30B_0;
if (_N_cache_13966)
{
if (true)
{
if (isBest)
{
arg_30B_0 = true;
}
else
{
isBest = (bestOffsets[3] < pos4);
arg_30B_0 = (isBest || bestOffsets[3] == pos4);
}
goto IL_300;
}
}
arg_30B_0 = false;
IL_300:
bool flag4 = arg_30B_0;
if (!flag4)
{
seqResult = -1;
}
else
{
int ofs3 = pos4;
int arg_3A2_0;
if (isBest)
{
bestOffsets[0] = pos;
bestOffsets[1] = ofs;
bestOffsets[2] = ofs2;
bestOffsets[3] = ofs3;
int i = 4;
while (i < bestOffsets.Length && bestOffsets[i] >= 0)
{
bestOffsets[i] = -1;
i++;
}
arg_3A2_0 = pos4;
}
else
{
arg_3A2_0 = -1;
}
seqResult = arg_3A2_0;
}
}
}
}
int newPos2 = seqResult;
if (newPos2 >= 0)
{
result = new CalcParser.Sub.Ast(new Location(this._grammar._parsingSource, token_4.get_Location().get_StartPos(), token_3.get_Location().get_EndPos()), list<ErrorInfo>.Nil._N_constant_object, token_4, token_2, token_3);
}
return newPos2;
}
public _#postfix#_sub_(IGrammar grammar) : base(10, '\0', '?')
{
this._grammar = (CalcParser.GrammarImpl)grammar;
}
}
private IncParser.GrammarImpl _#grammar#0;
private NumParser.GrammarImpl _#grammar#1;
private int _#_start_EndPos______ = -1;
private CalcParser.Start _#_start_Result______;
private int _#_start_StartPos____ = -1;
public ExtensionPostfixBase<CalcParser.Expr>[] _#_expr_PostfixRules_ = new ExtensionPostfixBase<CalcParser.Expr>[0];
public ExtensionPrefixBase<CalcParser.Expr>[] _#_expr_PrefixRules__ = new ExtensionPrefixBase<CalcParser.Expr>[0];
private int _#_expr_PrefixEndPos_ = -1;
private CalcParser.Expr _#_expr_PrefixResult_;
private int _#_expr_EndPos_______ = -1;
private CalcParser.Expr _#_expr_Result_______;
private int _#_expr_BindingPower_ = -1;
private int _#_expr_StartPos_____ = -1;
[CompilerGenerated, DebuggerBrowsable(DebuggerBrowsableState.Never)]
private Parser _N_Parser_4162;
private CalcParser.GrammarImpl.ParsingErrorsImpl _parsingErrors;
private static readonly GrammarDescriptor _descriptor;
public override Parser Parser
{
get;
private set;
}
public static GrammarDescriptor StaticDescriptor
{
get
{
return CalcParser.GrammarImpl._descriptor;
}
}
public GrammarDescriptor Descriptor
{
get
{
return CalcParser.GrammarImpl._descriptor;
}
}
public new SourceSnapshot get_ParsingSource()
{
return base.ParsingSource;
}
public void Init()
{
this._parsingSource = this.Parser.get_ParsingSource();
this._parsingErrors = (CalcParser.GrammarImpl.ParsingErrorsImpl)this.Parser.GetParsingErrorsForGrammar(CalcParser.GrammarImpl.StaticDescriptor);
this._#grammar#1 = (NumParser.GrammarImpl)this.Parser.GetGrammar(NumParser.GrammarImpl.get_StaticDescriptor()).get_Value();
this._#grammar#0 = (IncParser.GrammarImpl)this.Parser.GetGrammar(IncParser.GrammarImpl.StaticDescriptor).get_Value();
this.LoadExtensionRules();
}
public IGrammarState SaveState()
{
return new CalcParser.GrammarImpl.GrammarStateImpl(this);
}
private void LoadExtensionRules()
{
checked
{
ExtensionPrefixBase<CalcParser.Expr>[] e = this._#_expr_PrefixRules__;
int result = 0;
if (e != null)
{
result = e.Length;
}
int prevLength = result;
Array.Resize<ExtensionPrefixBase<CalcParser.Expr>>(ref this._#_expr_PrefixRules__, prevLength + 5);
this._#_expr_PrefixRules__[prevLength + 0] = new CalcParser.GrammarImpl._#prefix#__neg_(this);
this._#_expr_PrefixRules__[prevLength + 1] = new CalcParser.GrammarImpl._#prefix#__num_(this);
this._#_expr_PrefixRules__[prevLength + 2] = new CalcParser.GrammarImpl._#prefix#__prefixDec_(this);
this._#_expr_PrefixRules__[prevLength + 3] = new CalcParser.GrammarImpl._#prefix#__rounds_(this);
this._#_expr_PrefixRules__[prevLength + 4] = new CalcParser.GrammarImpl._#prefix#__seq_(this);
ExtensionPostfixBase<CalcParser.Expr>[] e2 = this._#_expr_PostfixRules_;
int result2 = 0;
if (e2 != null)
{
result2 = e2.Length;
}
prevLength = result2;
Array.Resize<ExtensionPostfixBase<CalcParser.Expr>>(ref this._#_expr_PostfixRules_, prevLength + 8);
this._#_expr_PostfixRules_[prevLength + 0] = new CalcParser.GrammarImpl._#postfix#_add_(this);
this._#_expr_PostfixRules_[prevLength + 1] = new CalcParser.GrammarImpl._#postfix#_cond_(this);
this._#_expr_PostfixRules_[prevLength + 2] = new CalcParser.GrammarImpl._#postfix#_div_(this);
this._#_expr_PostfixRules_[prevLength + 3] = new CalcParser.GrammarImpl._#postfix#_mod_(this);
this._#_expr_PostfixRules_[prevLength + 4] = new CalcParser.GrammarImpl._#postfix#_mul_(this);
this._#_expr_PostfixRules_[prevLength + 5] = new CalcParser.GrammarImpl._#postfix#_postfixDec_(this);
this._#_expr_PostfixRules_[prevLength + 6] = new CalcParser.GrammarImpl._#postfix#_pow_(this);
this._#_expr_PostfixRules_[prevLength + 7] = new CalcParser.GrammarImpl._#postfix#_sub_(this);
}
}
private void ResetMemoization()
{
this._#_start_StartPos____ = -1;
this._#_start_Result______ = null;
this._#_start_EndPos______ = -1;
this._#_expr_StartPos_____ = -1;
this._#_expr_BindingPower_ = -1;
this._#_expr_Result_______ = null;
this._#_expr_EndPos_______ = -1;
this._#_expr_PrefixResult_ = null;
this._#_expr_PrefixEndPos_ = -1;
}
public int _#_start_(int pos, string text, ref CalcParser.Start result)
{
CalcParser.Expr token_ = null;
int arg_1D5_0;
if (this._#_start_StartPos____ == pos)
{
if (this._#_start_EndPos______ >= 0)
{
result = this._#_start_Result______;
}
arg_1D5_0 = this._#_start_EndPos______;
}
else
{
int seqResult = 0;
int pos2 = this._#_s_(pos, text);
if (pos2 < 0)
{
seqResult = -1;
}
else
{
int pos3 = this._#_expr_(pos2, text, 0, ref token_);
if (pos3 < 0)
{
seqResult = -1;
}
else
{
int newPos = this._#_any_(pos3, text);
if (newPos < 0)
{
if (this._parsingErrors._token_start_rule_"any"_ < pos3)
{
this._parsingErrors._token_start_rule_"any"_ = pos3;
}
}
int newPos2 = newPos;
int pos4 = (newPos2 >= 0) ? -1 : pos3;
if (pos4 < 0)
{
seqResult = -1;
}
else
{
seqResult = pos4;
}
}
}
int newPos3 = seqResult;
this._#_start_StartPos____ = pos;
this._#_start_EndPos______ = newPos3;
if (newPos3 >= 0)
{
result = new CalcParser.Start.Ast(new Location(this._parsingSource, token_.get_Location().get_StartPos(), token_.get_Location().get_EndPos()), list<ErrorInfo>.Nil._N_constant_object, token_);
this._#_start_Result______ = result;
}
arg_1D5_0 = newPos3;
}
return arg_1D5_0;
}
public int _#_start_(int pos, string text)
{
int seqResult = 0;
int pos2 = this._#_s_(pos, text);
if (pos2 < 0)
{
seqResult = -1;
}
else
{
int pos3 = this._#_expr_(pos2, text, 0);
if (pos3 < 0)
{
seqResult = -1;
}
else
{
int newPos = this._#_any_(pos3, text);
if (newPos < 0)
{
if (this._parsingErrors._token_start_rule_"any"_ < pos3)
{
this._parsingErrors._token_start_rule_"any"_ = pos3;
}
}
int newPos2 = newPos;
int pos4 = (newPos2 >= 0) ? -1 : pos3;
if (pos4 < 0)
{
seqResult = -1;
}
else
{
seqResult = pos4;
}
}
}
return seqResult;
}
public int _#_s_(int pos, string text)
{
int seqResult = 0;
int num = pos;
while (true)
{
int arg_8E_0;
if (num < text.Length && text[num] == ' ')
{
arg_8E_0 = num + 1;
}
else
{
if (this._parsingErrors._token_s_literal_" "_ < num)
{
this._parsingErrors._token_s_literal_" "_ = num;
}
arg_8E_0 = -1;
}
int newPos = arg_8E_0;
if (newPos < 0)
{
break;
}
num = newPos;
}
int pos2 = num;
if (pos2 < 0)
{
seqResult = -1;
}
else
{
seqResult = pos2;
}
return seqResult;
}
public int _#_expr_(int pos, string text, int bindingPower)
{
CalcParser.Expr result = null;
return this._#_expr_(pos, text, bindingPower, ref result);
}
public int _#_expr_(int pos, string text, int bindingPower, ref CalcParser.Expr curResult)
{
int _N_return = 0;
int[] bestOffsets = new int[32];
int curEndPos = -1;
CalcParser.Expr newResult = null;
if (this._#_expr_StartPos_____ == pos)
{
if (this._#_expr_EndPos_______ < 0)
{
_N_return = -1;
return _N_return;
}
if (this._#_expr_BindingPower_ == bindingPower)
{
curResult = this._#_expr_Result_______;
_N_return = this._#_expr_EndPos_______;
return _N_return;
}
this._#_expr_BindingPower_ = bindingPower;
this._#_expr_EndPos_______ = -1;
curResult = this._#_expr_PrefixResult_;
curEndPos = this._#_expr_PrefixEndPos_;
}
else
{
this._#_expr_BindingPower_ = bindingPower;
this._#_expr_StartPos_____ = pos;
this._#_expr_PrefixEndPos_ = -1;
this._#_expr_EndPos_______ = -1;
int i = 0;
while (i < bestOffsets.Length && bestOffsets[i] >= 0)
{
bestOffsets[i] = -1;
i++;
}
if (pos < text.Length)
{
char c = text[pos];
ExtensionPrefixBase<CalcParser.Expr>[] #_expr_PrefixRules__ = this._#_expr_PrefixRules__;
for (int k = 0; k < #_expr_PrefixRules__.Length; k++)
{
ExtensionPrefixBase<CalcParser.Expr> extensionPrefixBase = #_expr_PrefixRules__[k];
ExtensionPrefixBase<CalcParser.Expr> prefixRule = (ExtensionPrefixBase<CalcParser.Expr>)extensionPrefixBase;
if (prefixRule.get_LowerBound() <= c && c <= prefixRule.get_UpperBound())
{
int newEndPos = prefixRule.Parse(pos, text, bestOffsets, ref newResult);
if (newEndPos > 0)
{
curResult = newResult;
curEndPos = newEndPos;
}
}
}
}
else
{
ExtensionPrefixBase<CalcParser.Expr>[] #_expr_PrefixRules__2 = this._#_expr_PrefixRules__;
for (int l = 0; l < #_expr_PrefixRules__2.Length; l++)
{
ExtensionPrefixBase<CalcParser.Expr> extensionPrefixBase2 = #_expr_PrefixRules__2[l];
ExtensionPrefixBase<CalcParser.Expr> prefixRule2 = (ExtensionPrefixBase<CalcParser.Expr>)extensionPrefixBase2;
int newEndPos = prefixRule2.Parse(pos, text, bestOffsets, ref newResult);
if (newEndPos > 0)
{
curResult = newResult;
curEndPos = newEndPos;
}
}
}
}
if (curEndPos >= 0)
{
CalcParser.Expr prefixResult = curResult;
int prefixEndPos = curEndPos;
CalcParser.Expr bestResult = curResult;
int bestEndPos = curEndPos;
while (curEndPos < text.Length)
{
int j = 0;
while (j < bestOffsets.Length && bestOffsets[j] >= 0)
{
bestOffsets[j] = -1;
j++;
}
char c = text[curEndPos];
ExtensionPostfixBase<CalcParser.Expr>[] #_expr_PostfixRules_ = this._#_expr_PostfixRules_;
for (int m = 0; m < #_expr_PostfixRules_.Length; m++)
{
ExtensionPostfixBase<CalcParser.Expr> extensionPostfixBase = #_expr_PostfixRules_[m];
ExtensionPostfixBase<CalcParser.Expr> postfixRule = (ExtensionPostfixBase<CalcParser.Expr>)extensionPostfixBase;
if (postfixRule.get_LowerBound() <= c && c <= postfixRule.get_UpperBound() && bindingPower < postfixRule.get_BindingPower())
{
newResult = curResult;
int newEndPos = postfixRule.Parse(pos, curEndPos, text, bestOffsets, ref newResult);
if (newEndPos > 0)
{
bestEndPos = newEndPos;
bestResult = newResult;
}
}
}
if (bestEndPos == curEndPos)
{
IL_3A6:
this._#_expr_BindingPower_ = bindingPower;
this._#_expr_StartPos_____ = pos;
this._#_expr_PrefixResult_ = prefixResult;
this._#_expr_PrefixEndPos_ = prefixEndPos;
this._#_expr_Result_______ = curResult;
this._#_expr_EndPos_______ = curEndPos;
_N_return = curEndPos;
return _N_return;
}
curResult = bestResult;
curEndPos = bestEndPos;
}
goto IL_3A6;
}
_N_return = -1;
return _N_return;
}
public int _#_any_(int pos, string text)
{
int okPos = -1;
if (pos < text.Length)
{
int curPos = pos + 1;
okPos = curPos;
}
return okPos;
}
static GrammarImpl()
{
CalcParser.GrammarImpl._descriptor = new CalcParser.GrammarImpl.GrammarDescriptorImpl();
}
public GrammarImpl()
{
}
public GrammarImpl(Parser parser)
{
if (parser == null)
{
throw new ArgumentNullException("parser", "The ``NotNull'' contract of parameter ``parser'' has been violated. See Main.n:13:2:47:2: .");
}
this.Parser = parser;
}
public override Tuple<int, CalcParser.Expr> TryParseExpr(SourceSnapshot source)
{
checked
{
if (source == null)
{
throw new ArgumentNullException("source", "The ``NotNull'' contract of parameter ``source'' has been violated. See Main.n:13:2:47:2: .");
}
this.ResetMemoization();
this.Parser = new Parser(this, source);
GrammarDescriptor[] dependencies = this.Descriptor.get_Dependencies();
for (int i = 0; i < dependencies.Length; i++)
{
GrammarDescriptor grammarDescriptor = dependencies[i];
GrammarDescriptor descriptor = grammarDescriptor;
this.Parser.AddGrammar(descriptor);
}
this.Init();
CalcParser.Expr result = null;
int pos = this._#_expr_(0, this._parsingSource.get_Text(), 0, ref result);
return new Tuple<int, CalcParser.Expr>(pos, result);
}
}
public override Tuple<int, CalcParser.Start> TryParseStart(SourceSnapshot source)
{
checked
{
if (source == null)
{
throw new ArgumentNullException("source", "The ``NotNull'' contract of parameter ``source'' has been violated. See Main.n:13:2:47:2: .");
}
this.ResetMemoization();
this.Parser = new Parser(this, source);
GrammarDescriptor[] dependencies = this.Descriptor.get_Dependencies();
for (int i = 0; i < dependencies.Length; i++)
{
GrammarDescriptor grammarDescriptor = dependencies[i];
GrammarDescriptor descriptor = grammarDescriptor;
this.Parser.AddGrammar(descriptor);
}
this.Init();
CalcParser.Start result = null;
int pos = this._#_start_(0, this._parsingSource.get_Text(), ref result);
return new Tuple<int, CalcParser.Start>(pos, result);
}
}
}
public class Expr : Ast
{
public class Error : CalcParser.Expr
{
public Error(Location location, list<ErrorInfo> errors) : base(location, errors)
{
}
}
public class Splice : CalcParser.Expr
{
public Splice(Location location, list<ErrorInfo> errors) : base(location, errors)
{
}
}
public Expr(Location location, list<ErrorInfo> errors) : base(location, errors)
{
}
}
public class Add : CalcParser.Expr
{
public new class Error : CalcParser.Add
{
public Error(Location location, list<ErrorInfo> errors) : base(location, errors)
{
}
}
public new class Splice : CalcParser.Add
{
public Splice(Location location, list<ErrorInfo> errors) : base(location, errors)
{
}
}
public class Ast : CalcParser.Add
{
public readonly CalcParser.Expr l;
public readonly NToken op;
public readonly CalcParser.Expr r;
public Ast(Location location, list<ErrorInfo> error, CalcParser.Expr l, NToken op, CalcParser.Expr r) : base(location, error)
{
this.l = l;
this.op = op;
this.r = r;
}
public override void GetErrors(List<ErrorInfo> errors)
{
base.GetErrors(errors);
this.l.GetErrors(errors);
this.r.GetErrors(errors);
}
}
public Add(Location location, list<ErrorInfo> errors) : base(location, errors)
{
}
}
public class Cond : CalcParser.Expr
{
public new class Error : CalcParser.Cond
{
public Error(Location location, list<ErrorInfo> errors) : base(location, errors)
{
}
}
public new class Splice : CalcParser.Cond
{
public Splice(Location location, list<ErrorInfo> errors) : base(location, errors)
{
}
}
public class Ast : CalcParser.Cond
{
public readonly CalcParser.Expr cond;
public readonly NToken q;
public readonly CalcParser.Expr l;
public readonly NToken colon;
public readonly CalcParser.Expr r;
public Ast(Location location, list<ErrorInfo> error, CalcParser.Expr cond, NToken q, CalcParser.Expr l, NToken colon, CalcParser.Expr r) : base(location, error)
{
this.cond = cond;
this.q = q;
this.l = l;
this.colon = colon;
this.r = r;
}
public override void GetErrors(List<ErrorInfo> errors)
{
base.GetErrors(errors);
this.cond.GetErrors(errors);
this.l.GetErrors(errors);
this.r.GetErrors(errors);
}
}
public Cond(Location location, list<ErrorInfo> errors) : base(location, errors)
{
}
}
public class Div : CalcParser.Expr
{
public new class Error : CalcParser.Div
{
public Error(Location location, list<ErrorInfo> errors) : base(location, errors)
{
}
}
public new class Splice : CalcParser.Div
{
public Splice(Location location, list<ErrorInfo> errors) : base(location, errors)
{
}
}
public class Ast : CalcParser.Div
{
public readonly CalcParser.Expr l;
public readonly NToken op;
public readonly CalcParser.Expr r;
public Ast(Location location, list<ErrorInfo> error, CalcParser.Expr l, NToken op, CalcParser.Expr r) : base(location, error)
{
this.l = l;
this.op = op;
this.r = r;
}
public override void GetErrors(List<ErrorInfo> errors)
{
base.GetErrors(errors);
this.l.GetErrors(errors);
this.r.GetErrors(errors);
}
}
public Div(Location location, list<ErrorInfo> errors) : base(location, errors)
{
}
}
public class Mod : CalcParser.Expr
{
public new class Error : CalcParser.Mod
{
public Error(Location location, list<ErrorInfo> errors) : base(location, errors)
{
}
}
public new class Splice : CalcParser.Mod
{
public Splice(Location location, list<ErrorInfo> errors) : base(location, errors)
{
}
}
public class Ast : CalcParser.Mod
{
public readonly CalcParser.Expr l;
public readonly NToken op;
public readonly CalcParser.Expr r;
public Ast(Location location, list<ErrorInfo> error, CalcParser.Expr l, NToken op, CalcParser.Expr r) : base(location, error)
{
this.l = l;
this.op = op;
this.r = r;
}
public override void GetErrors(List<ErrorInfo> errors)
{
base.GetErrors(errors);
this.l.GetErrors(errors);
this.r.GetErrors(errors);
}
}
public Mod(Location location, list<ErrorInfo> errors) : base(location, errors)
{
}
}
public class Mul : CalcParser.Expr
{
public new class Error : CalcParser.Mul
{
public Error(Location location, list<ErrorInfo> errors) : base(location, errors)
{
}
}
public new class Splice : CalcParser.Mul
{
public Splice(Location location, list<ErrorInfo> errors) : base(location, errors)
{
}
}
public class Ast : CalcParser.Mul
{
public readonly CalcParser.Expr l;
public readonly NToken op;
public readonly CalcParser.Expr r;
public Ast(Location location, list<ErrorInfo> error, CalcParser.Expr l, NToken op, CalcParser.Expr r) : base(location, error)
{
this.l = l;
this.op = op;
this.r = r;
}
public override void GetErrors(List<ErrorInfo> errors)
{
base.GetErrors(errors);
this.l.GetErrors(errors);
this.r.GetErrors(errors);
}
}
public Mul(Location location, list<ErrorInfo> errors) : base(location, errors)
{
}
}
public class Neg : CalcParser.Expr
{
public new class Error : CalcParser.Neg
{
public Error(Location location, list<ErrorInfo> errors) : base(location, errors)
{
}
}
public new class Splice : CalcParser.Neg
{
public Splice(Location location, list<ErrorInfo> errors) : base(location, errors)
{
}
}
public class Ast : CalcParser.Neg
{
public readonly NToken op;
public readonly CalcParser.Expr expr;
public Ast(Location location, list<ErrorInfo> error, NToken op, CalcParser.Expr expr) : base(location, error)
{
this.op = op;
this.expr = expr;
}
public override void GetErrors(List<ErrorInfo> errors)
{
base.GetErrors(errors);
this.expr.GetErrors(errors);
}
}
public Neg(Location location, list<ErrorInfo> errors) : base(location, errors)
{
}
}
public class Num : CalcParser.Expr
{
public new class Error : CalcParser.Num
{
public Error(Location location, list<ErrorInfo> errors) : base(location, errors)
{
}
}
public new class Splice : CalcParser.Num
{
public Splice(Location location, list<ErrorInfo> errors) : base(location, errors)
{
}
}
public class Ast : CalcParser.Num
{
public readonly NumParser.Number num;
public Ast(Location location, list<ErrorInfo> error, NumParser.Number num) : base(location, error)
{
this.num = num;
}
public override void GetErrors(List<ErrorInfo> errors)
{
base.GetErrors(errors);
this.num.GetErrors(errors);
}
}
public Num(Location location, list<ErrorInfo> errors) : base(location, errors)
{
}
}
public class PostfixDec : CalcParser.Expr
{
public new class Error : CalcParser.PostfixDec
{
public Error(Location location, list<ErrorInfo> errors) : base(location, errors)
{
}
}
public new class Splice : CalcParser.PostfixDec
{
public Splice(Location location, list<ErrorInfo> errors) : base(location, errors)
{
}
}
public class Ast : CalcParser.PostfixDec
{
public readonly CalcParser.Expr expr;
public readonly NToken op;
public Ast(Location location, list<ErrorInfo> error, CalcParser.Expr expr, NToken op) : base(location, error)
{
this.expr = expr;
this.op = op;
}
public override void GetErrors(List<ErrorInfo> errors)
{
base.GetErrors(errors);
this.expr.GetErrors(errors);
}
}
public PostfixDec(Location location, list<ErrorInfo> errors) : base(location, errors)
{
}
}
public class Pow : CalcParser.Expr
{
public new class Error : CalcParser.Pow
{
public Error(Location location, list<ErrorInfo> errors) : base(location, errors)
{
}
}
public new class Splice : CalcParser.Pow
{
public Splice(Location location, list<ErrorInfo> errors) : base(location, errors)
{
}
}
public class Ast : CalcParser.Pow
{
public readonly CalcParser.Expr l;
public readonly NToken op;
public readonly CalcParser.Expr r;
public Ast(Location location, list<ErrorInfo> error, CalcParser.Expr l, NToken op, CalcParser.Expr r) : base(location, error)
{
this.l = l;
this.op = op;
this.r = r;
}
public override void GetErrors(List<ErrorInfo> errors)
{
base.GetErrors(errors);
this.l.GetErrors(errors);
this.r.GetErrors(errors);
}
}
public Pow(Location location, list<ErrorInfo> errors) : base(location, errors)
{
}
}
public class PrefixDec : CalcParser.Expr
{
public new class Error : CalcParser.PrefixDec
{
public Error(Location location, list<ErrorInfo> errors) : base(location, errors)
{
}
}
public new class Splice : CalcParser.PrefixDec
{
public Splice(Location location, list<ErrorInfo> errors) : base(location, errors)
{
}
}
public class Ast : CalcParser.PrefixDec
{
public readonly NToken op;
public readonly CalcParser.Expr expr;
public Ast(Location location, list<ErrorInfo> error, NToken op, CalcParser.Expr expr) : base(location, error)
{
this.op = op;
this.expr = expr;
}
public override void GetErrors(List<ErrorInfo> errors)
{
base.GetErrors(errors);
this.expr.GetErrors(errors);
}
}
public PrefixDec(Location location, list<ErrorInfo> errors) : base(location, errors)
{
}
}
public class Rounds : CalcParser.Expr
{
public new class Error : CalcParser.Rounds
{
public Error(Location location, list<ErrorInfo> errors) : base(location, errors)
{
}
}
public new class Splice : CalcParser.Rounds
{
public Splice(Location location, list<ErrorInfo> errors) : base(location, errors)
{
}
}
public class Ast : CalcParser.Rounds
{
public readonly NToken l;
public readonly CalcParser.Expr expr;
public readonly NToken r;
public Ast(Location location, list<ErrorInfo> error, NToken l, CalcParser.Expr expr, NToken r) : base(location, error)
{
this.l = l;
this.expr = expr;
this.r = r;
}
public override void GetErrors(List<ErrorInfo> errors)
{
base.GetErrors(errors);
this.expr.GetErrors(errors);
}
}
public Rounds(Location location, list<ErrorInfo> errors) : base(location, errors)
{
}
}
public class Seq : CalcParser.Expr
{
public new class Error : CalcParser.Seq
{
public Error(Location location, list<ErrorInfo> errors) : base(location, errors)
{
}
}
public new class Splice : CalcParser.Seq
{
public Splice(Location location, list<ErrorInfo> errors) : base(location, errors)
{
}
}
public class Ast : CalcParser.Seq
{
public readonly NToken l;
public readonly list<CalcParser.Expr> expr;
public readonly NToken r;
public Ast(Location location, list<ErrorInfo> error, NToken l, list<CalcParser.Expr> expr, NToken r) : base(location, error)
{
this.l = l;
this.expr = expr;
this.r = r;
}
public override void GetErrors(List<ErrorInfo> errors)
{
base.GetErrors(errors);
list<CalcParser.Expr> list = this.expr;
while (list is list<CalcParser.Expr>.Cons)
{
CalcParser.Expr hd = ((list<CalcParser.Expr>.Cons)list).hd;
list<CalcParser.Expr> list2 = (list<CalcParser.Expr>)((list<CalcParser.Expr>.Cons)list).tl;
CalcParser.Expr _item = hd;
_item.GetErrors(errors);
list = (list<CalcParser.Expr>)list2;
}
}
}
public Seq(Location location, list<ErrorInfo> errors) : base(location, errors)
{
}
}
public class Start : Nemerle.Parser.Ast
{
public class Error : CalcParser.Start
{
public Error(Location location, list<ErrorInfo> errors) : base(location, errors)
{
}
}
public class Splice : CalcParser.Start
{
public Splice(Location location, list<ErrorInfo> errors) : base(location, errors)
{
}
}
public class Ast : CalcParser.Start
{
public readonly CalcParser.Expr expr;
public Ast(Location location, list<ErrorInfo> error, CalcParser.Expr expr) : base(location, error)
{
this.expr = expr;
}
public override void GetErrors(List<ErrorInfo> errors)
{
base.GetErrors(errors);
this.expr.GetErrors(errors);
}
}
public Start(Location location, list<ErrorInfo> errors) : base(location, errors)
{
}
}
public class Sub : CalcParser.Expr
{
public new class Error : CalcParser.Sub
{
public Error(Location location, list<ErrorInfo> errors) : base(location, errors)
{
}
}
public new class Splice : CalcParser.Sub
{
public Splice(Location location, list<ErrorInfo> errors) : base(location, errors)
{
}
}
public class Ast : CalcParser.Sub
{
public readonly CalcParser.Expr l;
public readonly NToken op;
public readonly CalcParser.Expr r;
public Ast(Location location, list<ErrorInfo> error, CalcParser.Expr l, NToken op, CalcParser.Expr r) : base(location, error)
{
this.l = l;
this.op = op;
this.r = r;
}
public override void GetErrors(List<ErrorInfo> errors)
{
base.GetErrors(errors);
this.l.GetErrors(errors);
this.r.GetErrors(errors);
}
}
public Sub(Location location, list<ErrorInfo> errors) : base(location, errors)
{
}
}
private SourceSnapshot _parsingSource;
public abstract override Parser Parser
{
get;
}
public SourceSnapshot ParsingSource
{
get
{
return this._parsingSource;
}
}
public string GetText(NToken tok)
{
return this._parsingSource.get_OriginalText().Substring(tok.get_StartPos(), checked(tok.get_EndPos() - tok.get_StartPos()));
}
public Location GetLocation(NToken tok)
{
return new Location(this._parsingSource, tok.get_StartPos(), tok.get_EndPos());
}
public option<CalcParser.Expr> ParseExpr(string text)
{
Tuple<int, CalcParser.Expr> _N_cache_5924 = this.TryParseExpr(text);
int pos = _N_cache_5924.Field0;
CalcParser.Expr res = _N_cache_5924.Field1;
return (pos >= 0) ? new option<CalcParser.Expr>.Some(res) : option<CalcParser.Expr>.None._N_constant_object;
}
public option<CalcParser.Expr> ParseExpr(SourceSnapshot source)
{
Tuple<int, CalcParser.Expr> _N_cache_5937 = this.TryParseExpr(source);
int pos = _N_cache_5937.Field0;
CalcParser.Expr res = _N_cache_5937.Field1;
return (pos >= 0) ? new option<CalcParser.Expr>.Some(res) : option<CalcParser.Expr>.None._N_constant_object;
}
public Tuple<int, CalcParser.Expr> TryParseExpr(string text)
{
return this.TryParseExpr(new SourceSnapshot(text, 0, ""));
}
public abstract override Tuple<int, CalcParser.Expr> TryParseExpr(SourceSnapshot source);
public option<CalcParser.Start> ParseStart(string text)
{
Tuple<int, CalcParser.Start> _N_cache_5954 = this.TryParseStart(text);
int pos = _N_cache_5954.Field0;
CalcParser.Start res = _N_cache_5954.Field1;
return (pos >= 0) ? new option<CalcParser.Start>.Some(res) : option<CalcParser.Start>.None._N_constant_object;
}
public option<CalcParser.Start> ParseStart(SourceSnapshot source)
{
Tuple<int, CalcParser.Start> _N_cache_5967 = this.TryParseStart(source);
int pos = _N_cache_5967.Field0;
CalcParser.Start res = _N_cache_5967.Field1;
return (pos >= 0) ? new option<CalcParser.Start>.Some(res) : option<CalcParser.Start>.None._N_constant_object;
}
public Tuple<int, CalcParser.Start> TryParseStart(string text)
{
return this.TryParseStart(new SourceSnapshot(text, 0, ""));
}
public abstract override Tuple<int, CalcParser.Start> TryParseStart(SourceSnapshot source);
}
|
