MarkupParserCommon

abstract def ch: Char

The library and compiler parsers had the interesting distinction of different behavior for nextch (a function for which there are a total of two plausible behaviors, so we know the design space was fully explored.

abstract def ch_returning_nextch: Char

abstract def eof: Boolean

abstract def errorNoEnd(tag: String): Nothing

abstract def lookahead(): BufferedIterator[Char]

Create a lookahead reader which does not influence the input

abstract def mkAttributes(name: String, pscope: NamespaceType): AttributesType

abstract def mkProcInstr(position: PositionType, name: String, text: String): ElementType

abstract def nextch(): Unit

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

abstract def reportSyntaxError(str: String): Unit

abstract val tmppos: PositionType

abstract def truncatedError(msg: String): Nothing

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

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

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

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

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

Apply a function and return the passed value

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

Execute body with a variable saved and restored after execution

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

def toString(): String

def unreachable: Nothing

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def xAttributeValue(endCh: Char): String

attribute value, terminated by either ' or ".

def xCharRef: String

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

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

CharRef ::= "&#" '0'.

def xEQ(): Unit

scan [S] '=' [S]

def xEndTag(startName: String): Unit

[42] '<' xmlEndTag ::= '<' '/' Name S? '>'

def xName: String

actually, Name ::= (Letter | '_' | ':') (NameChar)* but starting with ':' cannot happen Name ::= (Letter | '_') (NameChar)*

def xProcInstr: ElementType

'<?' ProcInstr ::= Name [S ({Char} - ({Char}'>?' {Char})]'?>'

def xSpace(): Unit

scan [3] S ::= (#x20 | #x9 | #xD | #xA)+

def xSpaceOpt(): Unit

skip optional space S?

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

parse a start or empty tag.

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

Take characters from input stream until given String "until" is seen.

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

def xToken(that: Char): Unit