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: AnyRef): Boolean

final def !=(arg0: Any): Boolean

Test two objects for inequality.

final def ##(): Int

Equivalent to x.hashCode except for boxed numeric types and null.

def +(other: String): String

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

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

Test two objects for equality.

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

final def asInstanceOf[T0]: T0

Cast the receiver object to be of type 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.

def ch_returning_nextch: Char

def checkPubID(s: String): Boolean

def checkSysID(s: String): Boolean

def clone(): AnyRef

Create a copy of the receiver object.

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 ensuring(cond: (MarkupParser) ⇒ Boolean, msg: ⇒ Any): MarkupParser

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

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

def ensuring(cond: Boolean): MarkupParser

def entityDecl(): Unit

<! element := ELEMENT

def eof: Boolean

final def eq(arg0: AnyRef): Boolean

Tests whether the argument (arg0) is a reference to the receiver object (this).

def equals(arg0: Any): Boolean

The equality method for reference types.

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 finalize(): Unit

Called by the garbage collector on the receiver object when there are no more references to the object.

def formatted(fmtstr: String): String

Returns string formatted according to given format string.

final def getClass(): Class[_]

A representation that corresponds to the dynamic class of the receiver object.

def hashCode(): Int

The hashCode method for reference types.

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

Test whether the dynamic type of the receiver object is T0.

def isName(s: String): Boolean

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

def isNameChar(c: Char): Boolean

def isNameStart(c: Char): Boolean

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): (MetaData, NamespaceBinding)

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

final def ne(arg0: AnyRef): Boolean

Equivalent to !(this eq that).

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

Wakes up a single thread that is waiting on the receiver object's monitor.

final def notifyAll(): Unit

Wakes up all threads that are waiting on the receiver object's monitor.

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

Creates a String representation of this object.

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

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'.

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, (MetaData, NamespaceBinding))

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 →[B](y: B): (MarkupParser, B)

val self: Any

val self: Any

def x: MarkupParser

def x: MarkupParser