ConstructingParser

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 attListDecl(name: String, attList: List[AttrDecl]): Unit

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 comment(pos: Int, txt: String): Comment

callback method invoked by MarkupParser after parsing comment.

def content(pscope: NamespaceBinding): NodeSeq

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

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

'<' content1 ::=  ...

var curInput: Source

var decls: List[Decl]

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 elem(pos: Int, pre: String, label: String, attrs: MetaData, pscope: NamespaceBinding, empty: Boolean, nodes: NodeSeq): NodeSeq

callback method invoked by MarkupParser after parsing an element, between the elemStart and elemEnd callbacks

def elemDecl(n: String, cmstr: String): Unit

def elemEnd(pos: Int, pre: String, label: String): Unit

callback method invoked by MarkupParser after end-tag of element.

def elemStart(pos: Int, pre: String, label: String, attrs: MetaData, scope: NamespaceBinding): Unit

callback method invoked by MarkupParser after start-tag of element.

def element(pscope: NamespaceBinding): NodeSeq

def element1(pscope: NamespaceBinding): NodeSeq

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

def elementDecl(): Unit

<! element := ELEMENT

def endDTD(n: String): Unit

var ent: Map[String, EntityDecl]

def entityDecl(): Unit

<! element := ELEMENT

def entityRef(pos: Int, n: String): EntityRef

callback method invoked by MarkupParser after parsing entity ref.

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

def externalSource(systemId: String): Source

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

def initialize: ConstructingParser.this.type

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

var inpStack: List[Source]

stack of inputs

val input: Source

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.

val isValidating: Boolean

returns true is this markup handler is validating

var lastChRead: Char

def lookahead(): BufferedIterator[Char]

Create a lookahead reader which does not influence the input

def lookupElemDecl(Label: String): ElemDecl

def markupDecl(): Unit

def markupDecl1(): Any

def mkAttributes(name: String, pscope: NamespaceBinding): AttributesType

def mkProcInstr(position: Int, name: String, text: String): 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"

def notationDecl(notat: String, extID: ExternalID): Unit

final def notify(): Unit

final def notifyAll(): Unit

def parameterEntityDecl(name: String, edef: EntityDef): Unit

def parseDTD(): Unit

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

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

def parsedEntityDecl(name: String, edef: EntityDef): Unit

def peReference(name: String): Unit

def pop(): Unit

var pos: Int

holds the position in the source file

val preserveWS: Boolean

if true, does not remove surplus whitespace

def procInstr(pos: Int, target: String, txt: String): ProcInstr

callback method invoked by MarkupParser after parsing PI.

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 replacementText(entityName: String): Source

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 text(pos: Int, txt: String): Text

callback method invoked by MarkupParser after parsing text.

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 unparsedEntityDecl(name: String, extID: ExternalID, notat: String): Unit

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

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: 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

def xmlProcInstr(): MetaData

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

def log(msg: String): Unit