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

Declaration: markup grammar

Announcements: markup grammar

All supertypes: value / entity

implicit import ideal • library • patterns

implicit import ideal • runtime • patterns

character handler the character handler

Declaration: the character handler

Use: the character handler / the character handler / the character handler / the character handler

dictionary[string, element id] element ids

Declaration: element ids

Use: element ids / element ids / element ids / element ids

dictionary[string, attribute id] attribute ids

Declaration: attribute ids

Use: attribute ids / attribute ids / attribute ids / attribute ids

dictionary[string, special text] entities

Declaration: entities

Use: entities / entities / entities / entities

var matcher[character, text element] document matcher

Declaration: document matcher

Use: document matcher / document matcher / document matcher / test markup grammar

var matcher[character, special text] entity ref

Declaration: entity ref

Use: entity ref / entity ref / entity ref / entity ref / test markup grammar

var matcher[character, string] quot attr value

Declaration: quot attr value

Use: quot attr value / quot attr value / test markup grammar

var matcher[character, string] apos attr value

Declaration: apos attr value

Use: apos attr value / apos attr value / test markup grammar

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

Declaration: attribute value in quot

Use: attribute value in quot / attribute value in quot / test markup grammar

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

Declaration: attribute value in apos

Use: attribute value in apos / attribute value in apos / test markup grammar

var matcher[character, attribute state] attribute

Declaration: attribute

Use: attribute / attribute / test markup grammar

var option matcher[character, text element] element

Declaration: element

Use: element / element / element / element

var matcher[character, text element] empty element

Declaration: empty element

Use: empty element / empty element / test markup grammar

var matcher[character, text fragment] content

Declaration: content

Use: content / content / test markup grammar

var markup parser parser

Declaration: parser

Use: parser / parser / parser / parser / parser

markup grammar(character handler the character handler)

Declaration: constructor

private boolean is completed

Declaration: is completed

Use: is completed / is completed / is completed / is completed

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

Declaration: add elements

Use: test markup grammar

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

Declaration: add attributes

Use: test markup grammar

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

Declaration: add entities

Use: test markup grammar

public void complete()

Declaration: complete

Use: test markup grammar

protected boolean name start(character c) pure

Declaration: name start

Use: name start

protected boolean name char(character c) pure

Declaration: name char

Use: name char

protected boolean content char(character c) pure

Declaration: content char

Use: content char

protected boolean content not apos(character c) pure

Declaration: content not apos

Use: content not apos

protected boolean content not quot(character c) pure

Declaration: content not quot

Use: content not quot

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

Declaration: one

Use: one

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

Declaration: one character

Use: one character / one character / one character / one character / one character / one character / one character / one character

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

Declaration: zero or more

Use: zero or more / zero or more / zero or more

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

Declaration: one or more

Use: one or more / one or more

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

Declaration: repeat or none

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

Declaration: sequence

Use: sequence

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

Declaration: option

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

Declaration: option fragment list

Use: option fragment list / option fragment list

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

Declaration: option text fragment

Use: option text fragment

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

Declaration: option text element

Use: option text element

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

Declaration: option fragment

Use: option fragment / option fragment

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

Declaration: join fragments

Use: join fragments

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

Declaration: repeat or none fragment

Use: repeat or none fragment / repeat or none fragment

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

Declaration: join fragments text

Use: join fragments text

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

Declaration: repeat or none text

Use: repeat or none text

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

Declaration: cast attributes

Use: cast attributes

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

Declaration: repeat or none attribute

Use: repeat or none attribute

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

Declaration: as string procedure

Use: as string procedure

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

Declaration: as string

Use: as string / as string / as string / as string

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

Declaration: match start element

Use: match start element / match start element

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

Declaration: match text element

Use: match text element

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

Declaration: make entity 2nd

Use: make entity 2nd

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

Declaration: make attribute

Use: make attribute

string select end tag(readonly list[any value] the list) pure

Declaration: select end tag

Use: select end tag

attribute fragment select 2nd attribute fragment(readonly list[any value] the list) pure

Declaration: select 2nd attribute fragment

Use: select 2nd attribute fragment / select 2nd attribute fragment

attribute state select 2nd attribute state(readonly list[any value] the list) pure

Declaration: select 2nd attribute state

Use: select 2nd attribute state

text element select 2nd text element(readonly list[any value] the list) pure

Declaration: select 2nd text element

Use: select 2nd text element

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

Declaration: join2

Use: join2 / join2

protected matcher[character, text element] document()

Declaration: document

Use: document

void update matchers()

Declaration: update matchers

Use: update matchers

text element parse(string text, markup parser parser)

Declaration: parse

Use: markup parser