MarkupParser

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (Parsers.MarkupParser, B)

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def appendText(pos: Global.Position, ts: Buffer[Global.Tree], txt: String): Unit

final def asInstanceOf[T0]: T0

def ch: Char

def ch_returning_nextch: Char

def checkPubID(s: String): Boolean

def checkSysID(s: String): Boolean

def clone(): AnyRef

def content: Buffer[Global.Tree]

def content_AMP(ts: ArrayBuffer[Global.Tree]): Unit

adds entity/character to ts as side-effect

def content_BRACE(p: Global.Position, ts: ArrayBuffer[Global.Tree]): Unit

def curOffset: Int

def element: Global.Tree

'<' element ::= xmlTag1 '>' { xmlExpr | '{' simpleExpr '}' } ETag | xmlTag1 '/' '>'

def ensuring(cond: (Parsers.MarkupParser) ⇒ Boolean, msg: ⇒ Any): Parsers.MarkupParser

def ensuring(cond: (Parsers.MarkupParser) ⇒ Boolean): Parsers.MarkupParser

def ensuring(cond: Boolean, msg: ⇒ Any): Parsers.MarkupParser

def ensuring(cond: Boolean): Parsers.MarkupParser

val eof: Boolean

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def errorAndResult[T](msg: String, x: T): T

def errorNoEnd(tag: String): Nothing

def escapeToScala[A](op: ⇒ A, kind: String): A

def finalize(): Unit

def formatted(fmtstr: String): String

final def getClass(): Class[_]

def hashCode(): Int

var input: CharArrayReader

def isAlpha(c: Char): Boolean

def isAlphaDigit(c: Char): Boolean

final def isInstanceOf[T0]: Boolean

def isName(s: String): Boolean

def isNameChar(ch: Char): Boolean

def isNameStart(ch: Char): Boolean

def isPubIDChar(ch: Char): Boolean

final def isSpace(cs: Seq[Char]): Boolean

final def isSpace(ch: Char): Boolean

def isValidIANAEncoding(ianaEncoding: Seq[Char]): Boolean

def lookahead(): BufferedIterator[Char]

def mkAttributes(name: String, other: NamespaceType): AttributesType

def mkProcInstr(position: Global.Position, name: String, text: String): ElementType

final def ne(arg0: AnyRef): Boolean

def nextch(): Unit

this method assign the next character to ch and advances in input

final def notify(): Unit

final def notifyAll(): Unit

final val preserveWS: Boolean

def reportSyntaxError(str: String): Unit

def reportSyntaxError(pos: Int, str: String): Unit

def returning[T](x: T)(f: (T) ⇒ Unit): T

def saving[A, B](getter: A, setter: (A) ⇒ Unit)(body: ⇒ B): B

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

var tmppos: Global.Position

def toString(): String

def truncatedError(msg: String): Nothing

def unreachable: Nothing

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def xAttributeValue(): String

def xAttributeValue(endCh: Char): String

def xAttributes: LinkedHashMap[String, Global.Tree]

parse attribute and add it to listmap [41] Attributes ::= { S Name Eq AttValue } AttValue ::= ' { _ } ' | " { _ } " | { scalablock }

def xCharData: Global.Tree

'<! CharData ::= [CDATA[ ( {char} - {char}"]]>"{char} ) ']]>'

def xCharRef: String

def xCharRef(it: Iterator[Char]): String

def xCharRef(ch: () ⇒ Char, nextch: () ⇒ Unit): String

def xCheckEmbeddedBlock: Boolean

checks whether next character starts a Scala block, if yes, skip it.

def xComment: Global.Tree

Comment ::=

def xEQ(): Unit

var xEmbeddedBlock: Boolean

def xEmbeddedExpr: Global.Tree

def xEndTag(startName: String): Unit

def xHandleError(that: Char, msg: String): Unit

def xLiteral: Global.Tree

xLiteral = element { element }

def xLiteralPattern: Global.Tree

def xName: String

def xPattern: Global.Tree

'<' xPattern ::= Name [S] { xmlPattern | '{' pattern3 '}' } ETag | Name [S] '/' '>'

def xProcInstr: ElementType

def xScalaPatterns: List[Global.Tree]

xScalaPatterns ::= patterns

def xSpace(): Unit

def xSpaceOpt(): Unit

def xTag(pscope: NamespaceType): (String, AttributesType)

def xTakeUntil[T](handler: (PositionType, String) ⇒ T, positioner: () ⇒ PositionType, until: String): T

def xToken(that: Seq[Char]): Unit

def xToken(that: Char): Unit

def xUnparsed: Global.Tree

def →[B](y: B): (Parsers.MarkupParser, B)

val self: Any

val self: Any

def x: Parsers.MarkupParser

def x: Parsers.MarkupParser