ConstructingParser

type InputType = Source

type PositionType = Int

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

def attListDecl(name: String, attList: List[AttrDecl]): Unit

def attrDecl(): Unit

<! attlist := ATTLIST

var ch: Char

holds the next character

def checkPubID(s: String): Boolean

def checkSysID(s: String): Boolean

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]

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

callback method invoked by MarkupParser after parsing an elementm, 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

var eof: Boolean

def equals(arg0: Any): Boolean

This method is used to compare the receiver object (this) with the argument object (arg0) for equivalence

var extIndex: Int

def extSubset(): Unit

def externalID(): ExternalID

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

def externalSource(systemId: String): Source

def hashCode(): Int

Returns a hash code value for the object

def initialize: MarkupParser with MarkupHandler

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

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

def log(msg: String): Unit

This method should log the message given as argument somewhere as a side-effect

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

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

def normalizeAttributeValue(attval: String): String

for the moment, replace only character references see spec 3

def notationDecl(): Unit

'N' notationDecl ::= "OTATION"

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

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

def parseDTD(): Unit

parses document type declaration and assigns it to instance variable dtd

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

def push(entityName: String): Unit

def pushExternal(systemId: String): Unit

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

def systemLiteral(): String

attribute value, terminated by either ' or "

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

Returns a string representation of the object

def unparsedEntityDecl(name: String, extID: ExternalID, notat: String): Unit

def xAttributeValue(): 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(ch: () ⇒ Char, nextch: () ⇒ Unit): String

CharRef ::= "&#" '0'

def xComment: NodeSeq

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

def xEQ: Unit

scan [S] '=' [S]

def xEndTag(n: 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

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

def xProcInstr: NodeSeq

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

def xSpace: Unit

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

def xSpaceOpt: Unit

skip optional space S?

def xText: String

parse character data

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

def xToken(that: Char): Unit

def xmlProcInstr(): MetaData

<? prolog ::= xml S

new ConstructingParser(input: Source, preserveWS: Boolean)

new ConstructingParser()