Dotty Documentation

0.6.0-bin-SNAPSHOT

trait MarkupParserCommon
extends Object

This is not a public trait - it contains common code shared between the library level XML parser and the compiler's. All members should be accessed through those.

[-] Constructors

[-] Members

[+] type AttributesType =
[+] type ElementType =
[+] type InputType =
[+] type NamespaceType =
[+] type PositionType =
[+] var tmppos : PositionType
[+] private def attr_unescape ( s: String ) : String
[+] 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. So to unify code we have to at least temporarily abstract over the nextchs.

[+] protected def ch_returning_nextch : Char
[+] def eof : Boolean
[+] protected def errorAndResult ( msg: String , x: T ) : T
[+] def errorNoEnd ( tag: String ) : Nothing
[+] def lookahead ( ) : BufferedIterator [ Char ]

Create a lookahead reader which does not influence the input

[+] def mkAttributes ( name: String , pscope: NamespaceType ) : AttributesType
[+] def mkProcInstr ( position: PositionType , name: String , text: String ) : ElementType
[+] def nextch ( ) : Unit
[+] private def normalizeAttributeValue ( attval: String ) : String

Replaces only character references right now. see spec 3.3.3

[+] private def peek ( lookingFor: String ) : Boolean

Create a non-destructive lookahead reader and see if the head of the input would match the given String. If yes, return true and drop the entire String from input; if no, return false and leave input unchanged.

[+] def reportSyntaxError ( str: String ) : Unit
[+] def reportSyntaxError ( pos: Int , str: String ) : Unit
[+] def returning ( x: T ) ( f: T => Unit ) : T

Apply a function and return the passed value

[+] def saving ( getter: A , setter: A => Unit ) ( body: => B ) : B

Execute body with a variable saved and restored after execution

[+] private def takeUntilChar ( it: Iterator [ Char ] , end: Char ) : String
[+] def tmppos_= ( x$1: PositionType ) : Unit
[+] def truncatedError ( msg: String ) : Nothing
[+] protected def unreachable : Nothing
[+] def xAttributeValue ( endCh: Char ) : String

attribute value, terminated by either ' or ". value may not contain <.

[+] def xAttributeValue ( ) : String
[+] def xCharRef ( ch: () => Char , nextch: () => Unit ) : String

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

see [66]

[+] def xCharRef ( it: Iterator [ Char ] ) : String
[+] def xCharRef : String
[+] def xEQ ( ) : Unit

scan [S] '=' [S]

[+] def xEndTag ( startName: String ) : Unit

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

[+] def xHandleError ( that: Char , msg: String ) : Unit
[+] def xName : String

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

see [5] of XML 1.0 specification

pre-condition: ch != ':' // assured by definition of XMLSTART token post-condition: name does neither start, nor end in ':'

[+] def xProcInstr : ElementType

'?' {Char})]'?>'

see [15]

[+] def xSpace ( ) : Unit

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

[+] def xSpaceOpt ( ) : Unit

skip optional space S?

[+] protected def xTag ( pscope: NamespaceType ) : ( String, AttributesType )

parse a start or empty tag. [40] STag ::= '<' Name { S Attribute } [S] [44] EmptyElemTag ::= '<' Name { S Attribute } [S]

[+] protected def xTakeUntil ( handler: (PositionType, String) => T , positioner: () => PositionType , until: String ) : T

Take characters from input stream until given String "until" is seen. Once seen, the accumulated characters are passed along with the current Position to the supplied handler function.

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