ExpressionParser

abstract def input: ParserInput

final def !=(arg0: Any): Boolean

final def ##(): Int

def &(r: Rule[_, _]): Rule0

final def ==(arg0: Any): Boolean

def AND: Rule[HNil, HNil]

def ANY: Rule0

def ASTERISK: Rule[HNil, HNil]

def CLOSE_BRACE: Rule[HNil, HNil]

def CLOSE_CURLY_BRACE: Rule[HNil, HNil]

def CLOSE_SQUARE_BRACE: Rule[HNil, HNil]

def COMMA: Rule[HNil, HNil]

def COMMENT: Rule[HNil, HNil]

def ChWS(s: Char): Rule[HNil, HNil]

def DECIMAL: Rule[HNil, ::[Double, HNil]]

def DECIMAL_NEGATIVE: Rule[HNil, ::[Double, HNil]]

def DECIMAL_UNSIGNED: Rule[HNil, ::[Double, HNil]]

Is in fact double as it is easier to go this way

def DIVIDE: Rule[HNil, HNil]

def DOT: Rule[HNil, HNil]

def EOI: Char

def EOL: Rule[HNil, HNil]

def EQUAL: Rule[HNil, HNil]

def EXPONENT: Rule[HNil, HNil]

def FALSE: Rule[HNil, ::[Boolean, HNil]]

def GREATER: Rule[HNil, HNil]

def GREATER_EQUAL: Rule[HNil, HNil]

def INTEGER: Rule[HNil, ::[Int, HNil]]

def INTEGER_NEGATIVE: Rule[HNil, ::[Int, HNil]]

def INTEGER_UNSIGNED: Rule1[Int]

def LESS: Rule[HNil, HNil]

def LESS_EQUAL: Rule[HNil, HNil]

def LESS_NO_COMMENT: Rule[HNil, HNil]

def MATCH: Rule0

def MINUS: Rule[HNil, HNil]

def MISMATCH[I <: HList, O <: HList]: Rule[I, O]

def MISMATCH0: Rule0

def NOT: Rule[HNil, HNil]

def NOT_EQUAL: Rule[HNil, HNil]

def OPEN_BRACE: Rule[HNil, HNil]

def OPEN_CURLY_BRACE: Rule[HNil, HNil]

def OPEN_SQUARE_BRACE: Rule[HNil, HNil]

def OR: Rule[HNil, HNil]

def PLUS: Rule[HNil, HNil]

def SEMICOLON: Rule[HNil, HNil]

def StringWS(string: String): Rule[HNil, HNil]

def TRUE: Rule[HNil, ::[Boolean, HNil]]

def WS: Rule[HNil, HNil]

def WS_NO_COMMENT: Rule[HNil, HNil]

def __advance(): Boolean

def __collectingErrors: Boolean

def __enterNotPredicate: Int

def __exitNotPredicate(saved: Int): Unit

final def __matchAnyOf(string: String, ix: Int): Boolean

final def __matchIgnoreCaseString(string: String, ix: Int): Boolean

final def __matchIgnoreCaseStringWrapped(string: String, ruleName: String, ix: Int): Boolean

def __matchMap(m: Map[String, Any]): Boolean

def __matchMapWrapped(m: Map[String, Any], ruleName: String): Boolean

final def __matchNoneOf(string: String, ix: Int): Boolean

final def __matchString(string: String, ix: Int): Boolean

final def __matchStringWrapped(string: String, ruleName: String, ix: Int): Boolean

def __push(value: Any): Boolean

def __registerMismatch(): Boolean

def __restoreState(mark: Mark): Unit

def __run[L <: HList](rule: ⇒ RuleN[L])(implicit scheme: DeliveryScheme[L]): Result

def __saveState: Mark

def __updateMaxCursor(): Boolean

def anyOf(chars: String): Rule0

final def asInstanceOf[T0]: T0

def capture[I <: HList, O <: HList](r: Rule[I, O])(implicit p: Prepend[O, ::[String, HNil]]): Rule[I, Out]

implicit def ch(c: Char): Rule0

def charAt(offset: Int): Char

def charAtRC(offset: Int): Char

def clone(): AnyRef

def copyStateFrom(other: Parser, offset: Int): Unit

def cursor: Int

def cursorChar: Char

def drop[T](implicit h: HListable[T]): PopRule[Out]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def formatError(error: ParseError, showExpected: Boolean, showPosition: Boolean, showLine: Boolean, showTraces: Boolean): String

def formatErrorLine(error: ParseError): String

def formatErrorProblem(error: ParseError): String

final def getClass(): Class[_]

def hashCode(): Int

def ignoreCase(s: String): Rule0

def ignoreCase(c: Char): Rule0

def ignoreCaseWS(string: String): Rule[HNil, HNil]

implicit def int2NTimes(i: Int): NTimes

final def isInstanceOf[T0]: Boolean

def lastChar: Char

macro def namedRule[I <: HList, O <: HList](name: String)(r: Rule[I, O]): Rule[I, O]

final def ne(arg0: AnyRef): Boolean

def noneOf(chars: String): Rule0

final def notify(): Unit

final def notifyAll(): Unit

def oneOrMore[I <: HList, O <: HList](r: Rule[I, O])(implicit s: Lifter[Seq, I, O]): Rule[In, Out] with Repeated

def optional[I <: HList, O <: HList](r: Rule[I, O])(implicit o: Lifter[Option, I, O]): Rule[In, Out]

implicit def predicate(p: CharPredicate): Rule0

def push[T](value: T)(implicit h: HListable[T]): RuleN[Out]

implicit def range2NTimes(range: Range): NTimes

macro def rule[I <: HList, O <: HList](r: Rule[I, O]): Rule[I, O]

implicit def rule2ActionOperator[I <: HList, O <: HList](r: Rule[I, O])(implicit ops: ActionOps[I, O]): ActionOperator[I, O, Out]

implicit def rule2WithSeparatedBy[I <: HList, O <: HList](r: Rule[I, O] with Repeated): WithSeparatedBy[I, O]

def run[T](arg: T)(implicit rr: RunResult[T]): Out

def runSubParser[I <: HList, O <: HList](f: (ParserInput) ⇒ Rule[I, O]): Rule[I, O]

implicit def str(s: String): Rule0

implicit def str2CharRangeSupport(s: String): CharRangeSupport

final def synchronized[T0](arg0: ⇒ T0): T0

def test(condition: Boolean): Rule0

def toString(): String

implicit def valueMap[T](m: Map[String, T])(implicit h: HListable[T]): RuleN[Out]

def valueStack: ValueStack

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def zeroOrMore[I <: HList, O <: HList](r: Rule[I, O])(implicit s: Lifter[Seq, I, O]): Rule[In, Out] with Repeated