MarkupParser

abstract def externalSource(systemLiteral: String): io.Source

abstract val input: io.Source

abstract val preserveWS: Boolean

if true, does not remove surplus whitespace

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def appendText(pos: Int, ts: NodeBuffer, txt: String): Unit

final def asInstanceOf[T0]: T0

def attrDecl(): Unit

<! attlist := ATTLIST

val cbuf: collection.mutable.StringBuilder

character buffer, for names

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.) One of them returned the value of nextch before the increment and one of them the new value.

def ch_returning_nextch: Char

def checkPubID(s: String): Boolean

def checkSysID(s: String): Boolean

def clone(): AnyRef

def content(pscope: NamespaceBinding): NodeSeq

content1 ::=  '<' content1 | '&' charref ...

def content1(pscope: NamespaceBinding, ts: NodeBuffer): Unit

'<' content1 ::=  ...

var curInput: io.Source

var doc: Document

def document(): Document

[22]     prolog      ::= XMLDecl? Misc* (doctypedecl Misc*)?
[23]     XMLDecl     ::= ' VersionInfo EncodingDecl? SDDecl? S? '?>'
[24]     VersionInfo ::= S 'version' Eq ("'" VersionNum "'" | '"' VersionNum '"')
[25]     Eq          ::= S? '=' S?
[26]     VersionNum  ::= '1.0'
[27]     Misc        ::= Comment | PI | S

var dtd: DTD

def element(pscope: NamespaceBinding): NodeSeq

def element1(pscope: NamespaceBinding): NodeSeq

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

def elementDecl(): Unit

<! element := ELEMENT

def entityDecl(): Unit

<! element := ELEMENT

def 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

var extIndex: Int

def extSubset(): Unit

def externalID(): ExternalID

externalID ::= SYSTEM S syslit
               PUBLIC S pubid S syslit

final def getClass(): Class[_]

def hashCode(): Int

def initialize: MarkupParser.this

As the current code requires you to call nextch once manually after construction, this method formalizes that suboptimal reality.

var inpStack: List[io.Source]

stack of inputs

def intSubset(): Unit

"rec-xml/#ExtSubset" pe references may not occur within markup declarations

def isAlpha(c: Char): Boolean

These are 99% sure to be redundant but refactoring on the safe side.

def isAlphaDigit(c: Char): Boolean

final def isInstanceOf[T0]: Boolean

def isName(s: String): Boolean

Name ::= ( Letter | '_' ) (NameChar)*

def isNameChar(ch: Char): Boolean

NameChar ::= Letter | Digit | '.' | '-' | '_' | ':'
           | CombiningChar | Extender

def isNameStart(ch: Char): Boolean

NameStart ::= ( Letter | '_' )

def isPubIDChar(ch: Char): Boolean

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

(#x20 | #x9 | #xD | #xA)+

final def isSpace(ch: Char): Boolean

(#x20 | #x9 | #xD | #xA)

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

Returns true if the encoding name is a valid IANA encoding.

var lastChRead: Char

def lookahead(): BufferedIterator[Char]

Create a lookahead reader which does not influence the input

def markupDecl(): Unit

def markupDecl1(): Any

def mkAttributes(name: String, pscope: NamespaceBinding): (MarkupParser.this)#AttributesType

def mkProcInstr(position: Int, name: String, text: String): (MarkupParser.this)#ElementType

final def ne(arg0: AnyRef): Boolean

var nextChNeeded: Boolean

holds the next character

def nextch(): Unit

this method tells ch to get the next character when next called

def notationDecl(): Unit

'N' notationDecl ::= "OTATION"

final def notify(): Unit

final def notifyAll(): Unit

def parseDTD(): Unit

parses document type declaration and assigns it to instance variable dtd.

<! parseDTD ::= DOCTYPE name ... >

def pop(): Unit

var pos: Int

holds the position in the source file

def prolog(): (Option[String], Option[String], Option[Boolean])

<? prolog ::= xml S?
// this is a bit more lenient than necessary...

def pubidLiteral(): String

[12]       PubidLiteral ::=        '"' PubidChar* '"' | "'" (PubidChar - "'")* "'"

def push(entityName: String): Unit

def pushExternal(systemId: String): Unit

def putChar(c: Char): collection.mutable.StringBuilder

append Unicode character to name buffer

var reachedEof: Boolean

def reportSyntaxError(str: String): Unit

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

def reportValidationError(pos: Int, str: String): 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 systemLiteral(): String

attribute value, terminated by either ' or ".

AttValue     ::= `'` { _ } `'`
               | `"` { _ } `"`

def textDecl(): (Option[String], Option[String])

prolog, but without standalone

var tmppos: Int

holds temporary values of pos

def toString(): String

def truncatedError(msg: String): Nothing

def unreachable: Nothing

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

final def wait(arg0: Long): Unit

final def wait(): Unit

def xAttributeValue(): String

def xAttributeValue(endCh: Char): String

attribute value, terminated by either ' or ".

def xAttributes(pscope: NamespaceBinding): (MetaData, NamespaceBinding)

parse attribute and create namespace scope, metadata

[41] Attributes    ::= { S Name Eq AttValue }

def xCharData: NodeSeq

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

see [15]

def xCharRef: String

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

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

CharRef ::= "&#" '0'..'9' {'0'..'9'} ";" | "&#x" '0'..'9'|'A'..'F'|'a'..'f' { hexdigit } ";"

def xComment: NodeSeq

 Comment ::= ''

see [15]

def xEQ(): Unit

scan [S] '=' [S]

def xEndTag(startName: String): Unit

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

def xEntityValue(): String

entity value, terminated by either ' or ".

AttValue     ::= `'` { _  } `'`
               | `"` { _ } `"`

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

def xName: String

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

def xProcInstr: (MarkupParser.this)#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: (MarkupParser.this)#NamespaceType): (String, (MarkupParser.this)#AttributesType)

parse a start or empty tag.

def xTakeUntil[T](handler: ((MarkupParser.this)#PositionType, String) ⇒ T, positioner: () ⇒ (MarkupParser.this)#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

def xmlProcInstr(): MetaData

<? prolog ::= xml S ... ?>

def finalize(): Unit