MarkupParser

def externalSource (systemLiteral: String): Source

val input : Source

val preserveWS : Boolean

if true, does not remove surplus whitespace

def != (arg0: AnyRef): Boolean

def != (arg0: Any): Boolean

Test two objects for inequality.

def ## (): Int

Equivalent to x.hashCode except for boxed numeric types.

def == (arg0: AnyRef): Boolean

def == (arg0: Any): Boolean

Test two objects for equality.

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

def asInstanceOf [T0] : T0

Cast the receiver object to be of type T0.

def attrDecl (): Unit

<! attlist := ATTLIST

val cbuf : StringBuilder

character buffer, for names

var ch : Char

holds the next character

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

var doc : Document

def document (): Document

[22] prolog ::= XMLDecl? Misc* (doctypedecl Misc*)? [23] XMLDecl ::= '<?xml' VersionInfo EncodingDecl? SDDecl? S? '?>' [24] VersionInfo ::= S 'version' Eq ("'" VersionNum "'" | '"' VersionNum '"') [25] Eq ::= S? '=' S? [26] VersionNum ::= '1.

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

var eof : Boolean

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 getClass (): java.lang.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.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

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

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 (ch: Char): Boolean

NameChar ::= Letter | Digit | '.

def isNameStart (ch: Char): Boolean

NameStart ::= ( Letter | '_' ) where Letter means in one of the Unicode general categories { Ll, Lu, Lo, Lt, Nl }

def isPubIDChar (ch: Char): Boolean

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

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

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.

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

def mkProcInstr (position: Int, name: String, text: String): NodeSeq

def ne (arg0: AnyRef): Boolean

Equivalent to !(this eq that).

def nextch : Char

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

def notationDecl (): Unit

'N' notationDecl ::= "OTATION"

def notify (): Unit

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

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.

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

def push (entityName: String): Unit

def pushExternal (systemId: String): Unit

def putChar (c: Char): StringBuilder

append Unicode character to name buffer

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

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

def systemLiteral (): String

attribute value, terminated by either ' or ".

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

def wait (): Unit

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

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} ) ']]>'

def xCharRef : String

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

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

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

def xComment : NodeSeq

Comment ::= '<!--' ((Char - '-') | ('-' (Char - '-')))* '-->'

def xEQ (): Unit

scan [S] '=' [S]

def xEndTag (startName: String): Unit

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

def xEntityValue (): String

entity value, terminated by either ' or ".

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

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

parse character data.

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

def xToken (that: Char): Unit

def xmlProcInstr (): MetaData

<? prolog ::= xml S .