SQLLexical

Instance Constructors

new SQLLexical()

Type Members

case class DecimalLit(chars: String) extends Token with Product with Serializable

Definition Classes
SQLTokens
case class Delimiter(chars: String) extends Token with Product with Serializable

Definition Classes
SQLTokens
type Elem = Char

Definition Classes
Scanners → Parsers
case class Error extends NoSuccess with Product with Serializable

Definition Classes
Parsers
case class ErrorToken extends Token with Product with Serializable

Definition Classes
Tokens
case class Failure extends NoSuccess with Product with Serializable

Definition Classes
Parsers
case class Identifier(chars: String) extends Token with Product with Serializable

Definition Classes
SQLTokens
type Input = Reader[Elem]

Definition Classes
Parsers
case class IntegerLit(chars: String) extends Token with Product with Serializable

Definition Classes
SQLTokens
case class Keyword(chars: String) extends Token with Product with Serializable

Definition Classes
SQLTokens
sealed abstract class NoSuccess extends ParseResult[Nothing]

Definition Classes
Parsers
trait OnceParser[+T] extends Parser[T]

Definition Classes
Parsers
sealed abstract class ParseResult[+T] extends AnyRef

Definition Classes
Parsers
abstract class Parser[+T] extends (Input) ⇒ ParseResult[T]

Definition Classes
Parsers
class Scanner extends Reader[scala.util.parsing.combinator.lexical.Scanners.Token]

Definition Classes
Scanners
case class StringLit(chars: String) extends Token with Product with Serializable

Definition Classes
SQLTokens
case class Success[+T] extends ParseResult[T] with Product with Serializable

Definition Classes
Parsers
abstract class Token extends AnyRef

Definition Classes
Tokens
case class ~[+a, +b] extends Product with Serializable

Definition Classes
Parsers

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
object EOF extends Token with Product with Serializable

Definition Classes
Tokens
object NoSuccess

Definition Classes
Parsers
def OnceParser[T](f: (Input) ⇒ ParseResult[T]): Parser[T] with OnceParser[T]

Definition Classes
Parsers
def Parser[T](f: (Input) ⇒ ParseResult[T]): Parser[T]

Definition Classes
Parsers
def accept[U](expected: String, f: PartialFunction[Elem, U]): Parser[U]

Definition Classes
Parsers
def accept[ES](es: ES)(implicit arg0: (ES) ⇒ List[Elem]): Parser[List[Elem]]

Definition Classes
Parsers
implicit def accept(e: Elem): Parser[Elem]

Definition Classes
Parsers
def acceptIf(p: (Elem) ⇒ Boolean)(err: (Elem) ⇒ String): Parser[Elem]

Definition Classes
Parsers
def acceptMatch[U](expected: String, f: PartialFunction[Elem, U]): Parser[U]

Definition Classes
Parsers
def acceptSeq[ES](es: ES)(implicit arg0: (ES) ⇒ Iterable[Elem]): Parser[List[Elem]]

Definition Classes
Parsers
final def asInstanceOf[T0]: T0

Definition Classes
Any
lazy val blockComment: Parser[~[~[~[~[Elem, Elem], List[Any]], Elem], Elem]]
def chainl1[T, U](first: ⇒ Parser[T], p: ⇒ Parser[U], q: ⇒ Parser[(T, U) ⇒ T]): Parser[T]

Definition Classes
Parsers
def chainl1[T](p: ⇒ Parser[T], q: ⇒ Parser[(T, T) ⇒ T]): Parser[T]

Definition Classes
Parsers
def chainr1[T, U](p: ⇒ Parser[T], q: ⇒ Parser[(T, U) ⇒ U], combine: (T, U) ⇒ U, first: U): Parser[U]

Definition Classes
Parsers
def chrExcept(cs: Char*): Parser[Elem]

Definition Classes
Lexical
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def commit[T](p: ⇒ Parser[T]): Parser[T]

Definition Classes
Parsers
def customToken: Parser[Token]
lazy val delimiter: Parser[Token]
val delimiters: Set[String]
def digit: Parser[Elem]

Definition Classes
Lexical
def elem(e: Elem): Parser[Elem]

Definition Classes
Parsers
def elem(kind: String, p: (Elem) ⇒ Boolean): Parser[Elem]

Definition Classes
Parsers
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def err(msg: String): Parser[Nothing]

Definition Classes
Parsers
def errorToken(msg: String): Token

Definition Classes
Tokens
lazy val exp: Parser[String]
def failure(msg: String): Parser[Nothing]

Definition Classes
Parsers
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def guard[T](p: ⇒ Parser[T]): Parser[T]

Definition Classes
Parsers
def hashCode(): Int

Definition Classes
AnyRef → Any
lazy val identifierOrKeyword: Parser[Product with Serializable with Token]
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
val keywords: Set[String]
lazy val letter: Parser[Elem]

Definition Classes
SQLLexical → Lexical
lazy val lineComment: Parser[~[~[Elem, Elem], List[Char]]]
def log[T](p: ⇒ Parser[T])(name: String): Parser[T]

Definition Classes
Parsers
def mkList[T]: (~[T, List[T]]) ⇒ List[T]

Definition Classes
Parsers
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def not[T](p: ⇒ Parser[T]): Parser[Unit]

Definition Classes
Parsers
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def opt[T](p: ⇒ Parser[T]): Parser[Option[T]]

Definition Classes
Parsers
def phrase[T](p: Parser[T]): Parser[T]

Definition Classes
Parsers
def positioned[T <: Positional](p: ⇒ Parser[T]): Parser[T]

Definition Classes
Parsers
def quoted(delimiter: Char): Parser[List[Char]]
def rep[T](p: ⇒ Parser[T]): Parser[List[T]]

Definition Classes
Parsers
def rep1[T](first: ⇒ Parser[T], p0: ⇒ Parser[T]): Parser[List[T]]

Definition Classes
Parsers
Annotations
@migration
Migration
(Changed in version 2.9.0) The p0 call-by-name arguments is evaluated at most once per constructed Parser object, instead of on every need that arises during parsing.
def rep1[T](p: ⇒ Parser[T]): Parser[List[T]]

Definition Classes
Parsers
def rep1sep[T](p: ⇒ Parser[T], q: ⇒ Parser[Any]): Parser[List[T]]

Definition Classes
Parsers
def repN[T](num: Int, p: ⇒ Parser[T]): Parser[List[T]]

Definition Classes
Parsers
def repsep[T](p: ⇒ Parser[T], q: ⇒ Parser[Any]): Parser[List[T]]

Definition Classes
Parsers
def success[T](v: T): Parser[T]

Definition Classes
Parsers
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
lazy val token: Parser[Token]

Definition Classes
SQLLexical → Scanners
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
lazy val whitespace: Parser[List[Any]]

Definition Classes
SQLLexical → Scanners
def whitespaceChar: Parser[Elem]

Definition Classes
Lexical

Related Doc: package SQL99Parser

class SQLLexical extends Lexical with SQLTokens

Instance Constructors

new SQLLexical()

Type Members

case class DecimalLit(chars: String) extends Token with Product with Serializable

case class Delimiter(chars: String) extends Token with Product with Serializable

type Elem = Char

case class Error extends NoSuccess with Product with Serializable

case class ErrorToken extends Token with Product with Serializable

case class Failure extends NoSuccess with Product with Serializable

case class Identifier(chars: String) extends Token with Product with Serializable

type Input = Reader[Elem]

case class IntegerLit(chars: String) extends Token with Product with Serializable

case class Keyword(chars: String) extends Token with Product with Serializable

sealed abstract class NoSuccess extends ParseResult[Nothing]

trait OnceParser[+T] extends Parser[T]

sealed abstract class ParseResult[+T] extends AnyRef

abstract class Parser[+T] extends (Input) ⇒ ParseResult[T]

class Scanner extends Reader[scala.util.parsing.combinator.lexical.Scanners.Token]

case class StringLit(chars: String) extends Token with Product with Serializable

case class Success[+T] extends ParseResult[T] with Product with Serializable

abstract class Token extends AnyRef

case class ~[+a, +b] extends Product with Serializable

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

object EOF extends Token with Product with Serializable

object NoSuccess

def OnceParser[T](f: (Input) ⇒ ParseResult[T]): Parser[T] with OnceParser[T]

def Parser[T](f: (Input) ⇒ ParseResult[T]): Parser[T]

def accept[U](expected: String, f: PartialFunction[Elem, U]): Parser[U]

def accept[ES](es: ES)(implicit arg0: (ES) ⇒ List[Elem]): Parser[List[Elem]]

implicit def accept(e: Elem): Parser[Elem]

def acceptIf(p: (Elem) ⇒ Boolean)(err: (Elem) ⇒ String): Parser[Elem]

def acceptMatch[U](expected: String, f: PartialFunction[Elem, U]): Parser[U]

def acceptSeq[ES](es: ES)(implicit arg0: (ES) ⇒ Iterable[Elem]): Parser[List[Elem]]

final def asInstanceOf[T0]: T0

lazy val blockComment: Parser[~[~[~[~[Elem, Elem], List[Any]], Elem], Elem]]

def chainl1[T, U](first: ⇒ Parser[T], p: ⇒ Parser[U], q: ⇒ Parser[(T, U) ⇒ T]): Parser[T]

def chainl1[T](p: ⇒ Parser[T], q: ⇒ Parser[(T, T) ⇒ T]): Parser[T]

def chainr1[T, U](p: ⇒ Parser[T], q: ⇒ Parser[(T, U) ⇒ U], combine: (T, U) ⇒ U, first: U): Parser[U]

def chrExcept(cs: Char*): Parser[Elem]

def clone(): AnyRef

def commit[T](p: ⇒ Parser[T]): Parser[T]

def customToken: Parser[Token]

lazy val delimiter: Parser[Token]

val delimiters: Set[String]

def digit: Parser[Elem]

def elem(e: Elem): Parser[Elem]

def elem(kind: String, p: (Elem) ⇒ Boolean): Parser[Elem]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def err(msg: String): Parser[Nothing]

def errorToken(msg: String): Token

lazy val exp: Parser[String]

def failure(msg: String): Parser[Nothing]

def finalize(): Unit

final def getClass(): Class[_]

def guard[T](p: ⇒ Parser[T]): Parser[T]

def hashCode(): Int

lazy val identifierOrKeyword: Parser[Product with Serializable with Token]

final def isInstanceOf[T0]: Boolean

val keywords: Set[String]

lazy val letter: Parser[Elem]

lazy val lineComment: Parser[~[~[Elem, Elem], List[Char]]]

def log[T](p: ⇒ Parser[T])(name: String): Parser[T]

def mkList[T]: (~[T, List[T]]) ⇒ List[T]

final def ne(arg0: AnyRef): Boolean

def not[T](p: ⇒ Parser[T]): Parser[Unit]

final def notify(): Unit

final def notifyAll(): Unit

def opt[T](p: ⇒ Parser[T]): Parser[Option[T]]

def phrase[T](p: Parser[T]): Parser[T]

def positioned[T <: Positional](p: ⇒ Parser[T]): Parser[T]

def quoted(delimiter: Char): Parser[List[Char]]

def rep[T](p: ⇒ Parser[T]): Parser[List[T]]

def rep1[T](first: ⇒ Parser[T], p0: ⇒ Parser[T]): Parser[List[T]]