ideal • runtime • texts • markup

The grammar for a subset of XML. Used https://cs.lmu.edu/~ray/notes/xmlgrammar/ as a reference.

class markup grammar

implicit import ideal • library • patterns

implicit import ideal • runtime • patterns

character handler the character handler

dictionary[string, element id] element ids

dictionary[string, attribute id] attribute ids

dictionary[string, special text] entities

var matcher[character, text element] document matcher

var matcher[character, special text] entity ref

var matcher[character, string] quot attr value

var matcher[character, string] apos attr value

var matcher[character, attribute fragment] attribute value in quot

var matcher[character, attribute fragment] attribute value in apos

var matcher[character, attribute state] attribute

var option matcher[character, text element] element

var matcher[character, text element] empty element

var matcher[character, text fragment] content

var markup parser parser

markup grammar(character handler the character handler)

this • the character handler = the character handler

element ids = hash dictionary[string, element id] • new()

attribute ids = hash dictionary[string, attribute id] • new()

entities = hash dictionary[string, special text] • new()

private boolean is completed => document matcher is_not null

public void add elements(readonly collection[element id] new element ids)

assert !is completed()

for (the element id : new element ids • elements)

assert !element ids • contains key(the element id • short name)

element ids • put(the element id • short name, the element id)

public void add attributes(readonly collection[attribute id] new attribute ids)

assert !is completed()

for (the attribute id : new attribute ids • elements)

assert !attribute ids • contains key(the attribute id • short name)

attribute ids • put(the attribute id • short name, the attribute id)

public void add entities(readonly collection[special text] new entities)

assert !is completed()

for (the entity : new entities • elements)

assert !entities • contains key(the entity • name)

entities • put(the entity • name, the entity)

public void complete()

assert !is completed()

document matcher = document()

protected boolean name start(character c) pure

return the character handler • is letter(c) || c == '_' || c == ':'

protected boolean name char(character c) pure

return the character handler • is letter(c) || c == '.' || c == '-' || c == '_' || c == ':'

protected boolean content char(character c) pure

return c != '<' && c != '&'

protected boolean content not apos(character c) pure

return c != '<' && c != '&' && c != '\''

protected boolean content not quot(character c) pure

return c != '<' && c != '&' && c != '"'

pattern[character] one(function[boolean, character] the predicate) pure

return predicate pattern[character] • new(the predicate)

pattern[character] one character(character the character) pure

return singleton pattern[character] • new(the character)

pattern[character] zero or more(function[boolean, character] the predicate) pure

return repeat element[character] • new(the predicate, true)

pattern[character] one or more(function[boolean, character] the predicate) pure

return repeat element[character] • new(the predicate, false)

pattern[character] repeat or none(pattern[character] the pattern) pure

return repeat pattern[character] • new(the pattern, true)

pattern[character] sequence(readonly list[pattern[character]] patterns list) pure

return sequence pattern[character] • new(patterns list)

option pattern[character] option(readonly list[pattern[character]] patterns list) pure

return option pattern[character] • new(patterns list)

option matcher[character, attribute fragment] option fragment list(readonly list[matcher[character, attribute fragment]] matchers) pure

return option matcher[character, attribute fragment] • new(matchers)

option matcher[character, text fragment] option text fragment(readonly list[matcher[character, text fragment]] matchers) pure

return option matcher[character, text fragment] • new(matchers)

option matcher[character, text element] option text element(readonly list[matcher[character, text element]] matchers) pure

return option matcher[character, text element] • new(matchers)

option matcher[character, attribute fragment] option fragment(matcher[character, string] attr value, matcher[character, special text] entity ref) pure

return option fragment list([entity ref !> matcher[character, attribute fragment], attr value !> matcher[character, attribute fragment]])

attribute fragment join fragments(readonly list[attribute fragment] fragments) pure

return text utilities • join attributes(fragments)

matcher[character, attribute fragment] repeat or none fragment(matcher[character, attribute fragment] the matcher) pure

return repeat matcher[character, attribute fragment, attribute fragment] • new(the matcher, true, join fragments)

text fragment join fragments text(readonly list[text fragment] fragments) pure

return text utilities • join(fragments)

matcher[character, text fragment] repeat or none text(matcher[character, text fragment] the matcher) pure

return repeat matcher[character, text fragment, text fragment] • new(the matcher, true, join fragments text)

immutable list[attribute state] cast attributes(readonly list[attribute state] attributes) pure

return attributes • elements !> immutable list[attribute state]

matcher[character, immutable list[attribute state]] repeat or none attribute(matcher[character, attribute state] the matcher) pure

return repeat matcher[character, immutable list[attribute state], attribute state] • new(the matcher, true, cast attributes)

string as string procedure(readonly list[character] the character list) pure

return the character list • frozen copy() !> string

matcher[character, string] as string(pattern[character] the pattern) pure

return procedure matcher[character, string] • new(the pattern, as string procedure)

text element match start element(readonly list[any value] the list) pure

element name : the list[1] !> string

attributes : the list[2] !> immutable list[attribute state]

element id : element ids • get(element name)

if element id is null

parser • report error("Unrecognized element name: " ++ element name)

return base element • new(text library • ERROR ELEMENT)

dictionary[attribute id, attribute fragment] attributes dictionary : list dictionary[attribute id, attribute fragment] • new()

for (attribute : attributes)

attributes dictionary • put(attribute • id, attribute • value)

return base element • new(element id, attributes dictionary, missing • instance)

text element match text element(readonly list[any value] the list) pure

start tag : the list[0] !> text element

text content : the list[1] !> text fragment

end tag name : the list[2] !> string

start tag name : start tag • get id • short name

if start tag • get id != text library • ERROR ELEMENT && start tag name != end tag name

parser • report error("Mismatched element name: start " ++ start tag name ++ ", end " ++ end tag name)

return base element • new(start tag • get id, start tag • attributes, text content)

special text make entity 2nd(readonly list[any value] the list) pure

string entity name : the list[1] !> string

entity : entities • get(entity name)

if entity is null

parser • report error("Unrecognized entity: " ++ entity name)

return text library • ERROR ENTITY

return entity

attribute state make attribute(readonly list[any value] the list) pure

string attribute name : the list[0] !> string

attribute fragment value : the list[2] !> attribute fragment

id : attribute ids • get(attribute name)

if id is null

parser • report error("Unrecognized attribute name: " ++ attribute name)

return attribute state • new(text library • ERROR ATTRIBUTE, value)

return attribute state • new(id, value)

string select end tag(readonly list[any value] the list) pure => the list[2] !> string

attribute fragment select 2nd attribute fragment(readonly list[any value] the list) pure => the list[1] !> attribute fragment

attribute state select 2nd attribute state(readonly list[any value] the list) pure => the list[1] !> attribute state

text element select 2nd text element(readonly list[any value] the list) pure => the list[1] !> text element

text fragment join2(readonly list[any value] the list) pure

assert the list • size == 2

return text utilities • join(the list[0] !> text fragment, the list[1] !> text fragment)

protected matcher[character, text element] document()

lt : one character('<')

gt : one character('>')

slash : one character('/')

amp : one character('&')

semicolon : one character(';')

quot : one character('"')

apos : one character('\'')

eq : one character('=')

space opt : zero or more(the character handler • is whitespace)

name : as string(sequence pattern[character] • new([one(name start), zero or more(name char)]))

entity ref = sequence matcher[character, special text] • new([amp, name, semicolon], make entity 2nd)

equals : sequence([space opt, eq, space opt])

quot attr value = as string(one or more(content not quot))

attribute value in quot = sequence matcher[character, attribute fragment] • new([quot, repeat or none fragment(option fragment(quot attr value, entity ref)), quot], select 2nd attribute fragment)

apos attr value = as string(one or more(content not apos))

attribute value in apos = sequence matcher[character, attribute fragment] • new([apos, repeat or none fragment(option fragment(apos attr value, entity ref)), apos], select 2nd attribute fragment)

attribute value : option fragment list([attribute value in quot, attribute value in apos])

attribute = sequence matcher[character, attribute state] • new([name, equals, attribute value], make attribute)

attributes : repeat or none attribute(sequence matcher[character, attribute state] • new([space opt, attribute], select 2nd attribute state))

empty element = sequence matcher[character, text element] • new([lt, name, attributes, space opt, slash, gt], match start element)

element = option text element([empty element .> matcher[character, text element]])

element fragment : element !> matcher[character, text fragment]

content element : option text fragment([element fragment, entity ref !> matcher[character, text fragment]])

char data opt : as string(zero or more(content char))

content tail : repeat or none text(sequence matcher[character, text fragment] • new([content element .> pattern[character], char data opt], join2))

content = sequence matcher[character, text fragment] • new([char data opt, content tail .> pattern[character]], join2)

pattern[character] start tag : sequence matcher[character, text element] • new([lt, name, attributes, space opt, gt], match start element)

end tag : sequence matcher[character, string] • new([lt, slash, name, space opt, gt], select end tag)

element • add option(sequence matcher[character, text element] • new([start tag, content, end tag], match text element))

result : sequence matcher[character, text element] • new([space opt, element, space opt], select 2nd text element)

update matchers()

result • validate()

return result

void update matchers()

pass

text element parse(string text, markup parser parser)

this • parser = parser

return document matcher • parse(text)