File: `ebnf-dtd.el.html`

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

This is part of ebnf2ps package.

This package defines a parser for DTD (Data Type Description for XML).

See ebnf2ps.el for documentation.

DTD Syntax
----------

See the URLs: https://www.w3.org/TR/2004/REC-xml-20040204/
(Extensible Markup Language (XML) 1.0 (Third Edition))
https://www.w3.org/TR/html40/
(HTML 4.01 Specification)
https://www.w3.org/TR/NOTE-html-970421
(HTML DTD with support for Style Sheets)

/* Document */

document ::= prolog element Misc*
/* Note that *only* the prolog will be parsed */

/* Characters */

Char ::= #x9 | #xA | #xD
| [#x20-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF]
/* any Unicode character, excluding the surrogate blocks, FFFE, and FFFF. */

/* NOTE:

   Document authors are encouraged to avoid "compatibility characters", as
   defined in section 6.8 of [Unicode] (see also D21 in section 3.6 of
   [Unicode3]). The characters defined in the following ranges are also
   discouraged. They are either control characters or permanently undefined
   Unicode characters:

   [#x7F-#x84], [#x86-#x9F], [#xFDD0-#xFDDF],
   [#1FFFE-#x1FFFF], [#2FFFE-#x2FFFF], [#3FFFE-#x3FFFF],
   [#4FFFE-#x4FFFF], [#5FFFE-#x5FFFF], [#6FFFE-#x6FFFF],
   [#7FFFE-#x7FFFF], [#8FFFE-#x8FFFF], [#9FFFE-#x9FFFF],
   [#AFFFE-#xAFFFF], [#BFFFE-#xBFFFF], [#CFFFE-#xCFFFF],
   [#DFFFE-#xDFFFF], [#EFFFE-#xEFFFF], [#FFFFE-#xFFFFF],
   [#10FFFE-#x10FFFF]. */

/* White Space */

S ::= (#x20 | #x9 | #xD | #xA)+

/* Names and Tokens */

NameChar ::= Letter | Digit | '.' | '-' | '_' | ':'
| CombiningChar | Extender

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

Names ::= Name (#x20 Name)*

Nmtoken ::= (NameChar)+

Nmtokens ::= Nmtoken (#x20 Nmtoken)*

/* Literals */

AttValue ::= '"' ([^<&"] | Reference)* '"'
| "'" ([^<&'] | Reference)* "'"

SystemLiteral ::= ('"' [^"]* '"')
| ("'" [^']* "'")

PubidLiteral ::= '"' PubidChar* '"'
| "'" (PubidChar - "'")* "'"

PubidChar ::= #x20 | #xD | #xA | [a-zA-Z0-9] | [-'()+,./:=?;!*#@$_%]

/* NOTE:

   Although the EntityValue production allows the definition of a general
   entity consisting of a single explicit < in the literal (e.g., <!ENTITY
   mylt "<">), it is strongly advised to avoid this practice since any
   reference to that entity will cause a well-formedness error. */

/* Character Data */

CharData ::= [^<&]* - ([^<&]* ']]>' [^<&]*)

/* Comments */

Comment ::= ''

/* Processing Instructions */

PI ::= '<?' PITarget (S (Char* - (Char* '?>' Char*)))? '?>'

PITarget ::= Name - (('X' | 'x') ('M' | 'm') ('L' | 'l'))

/* CDATA Sections */

CDSect ::= CDStart CData CDEnd

CDStart ::= '<![CDATA['

CData ::= (Char* - (Char* ']]>' Char*))

CDEnd ::= ']]>'

/* Prolog */

prolog ::= XMLDecl? Misc* (doctypedecl Misc*)?

XMLDecl ::= '<?xml' VersionInfo EncodingDecl? SDDecl? S? '?>'

VersionInfo ::= S 'version' Eq ("'" VersionNum "'" | '"' VersionNum '"')

Eq ::= S? '=' S?

VersionNum ::= '1.0'

Misc ::= Comment | PI | S

/* Document Type Definition */

doctypedecl ::= '<!DOCTYPE' S Name (S ExternalID)? S?
                ('[' intSubset ']' S?)? '>'
              [VC: Root Element Type]
              [WFC: External Subset]

DeclSep ::= PEReference | S
[WFC: PE Between Declarations]

intSubset ::= (markupdecl | DeclSep)*

/* External Subset */

extSubset ::= TextDecl? extSubsetDecl

extSubsetDecl ::= ( markupdecl | conditionalSect | DeclSep)*

/* Standalone Document Declaration */

SDDecl ::= S 'standalone' Eq
(("'" ('yes' | 'no') "'") | ('"' ('yes' | 'no') '"'))
[VC: Standalone Document Declaration]

/* Element */

element ::= EmptyElemTag | STag content ETag
[WFC: Element Type Match]
[VC: Element Valid]

/* Start-tag */

STag ::= '<' Name (S Attribute)* S? '>'
[WFC: Unique Att Spec]

Attribute ::= Name Eq AttValue
            [VC: Attribute Value Type]
            [WFC: No External Entity References]
            [WFC: No < in Attribute Values]

/* End-tag */

ETag ::= '</' Name S? '>'

/* Content of Elements */

content ::= CharData?
((element | Reference | CDSect | PI | Comment) CharData?)*

/* Tags for Empty Elements */

EmptyElemTag ::= '<' Name (S Attribute)* S? '/>'
[WFC: Unique Att Spec]

/* Element Type Declaration */

elementdecl ::= '<!ELEMENT' S Name S contentspec S? '>'
[VC: Unique Element Type Declaration]

contentspec ::= 'EMPTY' | 'ANY' | Mixed | children

/* Element-content Models */

children ::= (choice | seq) ('?' | '*' | '+')?

cp ::= (Name | choice | seq) ('?' | '*' | '+')?

choice ::= '(' S? cp ( S? '|' S? cp )+ S? ')'
[VC: Proper Group/PE Nesting]

seq ::= '(' S? cp ( S? ',' S? cp )* S? ')'
[VC: Proper Group/PE Nesting]

/* Mixed-content Declaration */

Mixed ::= '(' S? '#PCDATA' (S? '|' S? Name)* S? ')*'
        | '(' S? '#PCDATA' S? ')'
        [VC: Proper Group/PE Nesting]
        [VC: No Duplicate Types]

/* Attribute-list Declaration */

AttlistDecl ::= '<!ATTLIST' S Name AttDef* S? '>'

AttDef ::= S Name S AttType S DefaultDecl

/* Attribute Types */

AttType ::= StringType | TokenizedType | EnumeratedType

StringType ::= 'CDATA'

TokenizedType ::= 'ID' [VC: ID]
                             [VC: One ID per Element Type]
                             [VC: ID Attribute Default]
                | 'IDREF' [VC: IDREF]
                | 'IDREFS' [VC: IDREF]
                | 'ENTITY' [VC: Entity Name]
                | 'ENTITIES' [VC: Entity Name]
                | 'NMTOKEN' [VC: Name Token]
                | 'NMTOKENS' [VC: Name Token]

/* Enumerated Attribute Types */

EnumeratedType ::= NotationType | Enumeration

NotationType ::= 'NOTATION' S '(' S? Name (S? '|' S? Name)* S? ')'
               [VC: Notation Attributes]
               [VC: One Notation Per Element Type]
               [VC: No Notation on Empty Element]
               [VC: No Duplicate Tokens]

Enumeration ::= '(' S? Nmtoken (S? '|' S? Nmtoken)* S? ')'
[VC: Enumeration]
[VC: No Duplicate Tokens]

/* Attribute Defaults */

DefaultDecl ::= '#REQUIRED' | '#IMPLIED'
              | (('#FIXED' S)? AttValue)
              [VC: Required Attribute]
              [VC: Attribute Default Value Syntactically Correct]
              [WFC: No < in Attribute Values]
              [VC: Fixed Attribute Default]

/* Conditional Section */

conditionalSect ::= includeSect | ignoreSect

includeSect ::= '<![' S? 'INCLUDE' S? '[' extSubsetDecl ']]>'
[VC: Proper Conditional Section/PE Nesting]

ignoreSect ::= '<![' S? 'IGNORE' S? '[' ignoreSectContents* ']]>'
[VC: Proper Conditional Section/PE Nesting]

ignoreSectContents ::= Ignore ('<![' ignoreSectContents ']]>' Ignore)*

Ignore ::= Char* - (Char* ('<![' | ']]>') Char*)

/* Character Reference */

CharRef ::= '&#' [0-9]+ ';'
| '&#x' [[:xdigit:]]+ ';'
[WFC: Legal Character]

/* Entity Reference */

Reference ::= EntityRef | CharRef

EntityRef ::= '&' Name ';'
            [WFC: Entity Declared]
            [VC: Entity Declared]
            [WFC: Parsed Entity]
            [WFC: No Recursion]

PEReference ::= '%' Name ';'
              [VC: Entity Declared]
              [WFC: No Recursion]
              [WFC: In DTD]

/* Entity Declaration */

EntityDecl ::= GEDecl | PEDecl

GEDecl ::= '<!ENTITY' S Name S EntityDef S? '>'

PEDecl ::= '<!ENTITY' S '%' S Name S PEDef S? '>'

EntityDef ::= EntityValue | (ExternalID NDataDecl?)

PEDef ::= EntityValue | ExternalID

/* External Entity Declaration */

ExternalID ::= 'SYSTEM' S SystemLiteral
| 'PUBLIC' S PubidLiteral S SystemLiteral

NDataDecl ::= S 'NDATA' S Name
[VC: Notation Declared]

/* Text Declaration */

TextDecl ::= '<?xml' VersionInfo? EncodingDecl S? '?>'

/* Well-Formed External Parsed Entity */

extParsedEnt ::= TextDecl? content

/* Encoding Declaration */

EncodingDecl ::= S 'encoding' Eq ('"' EncName '"' | "'" EncName "'" )

EncName ::= [A-Za-z] ([A-Za-z0-9._] | '-')*
/* Encoding name contains only Latin characters */

/* Notation Declarations */

NotationDecl ::= '<!NOTATION' S Name S (ExternalID | PublicID) S? '>'
[VC: Unique Notation Name]

PublicID ::= 'PUBLIC' S PubidLiteral

/* Characters */

Letter ::= BaseChar | Ideographic

Ideographic ::= [#x4E00-#x9FA5] | #x3007 | [#x3021-#x3029]

Extender ::= #x00B7 | #x02D0 | #x02D1 | #x0387 | #x0640 | #x0E46 | #x0EC6
| #x3005 | [#x3031-#x3035] | [#x309D-#x309E] | [#x30FC-#x30FE]

NOTES
-----

At moment, only the `<!ELEMENT' generates a syntactic chart. The
`<!ATTLIST', `<!NOTATION' and `<!ENTITY' are syntactically checked but they
don't generate a syntactic chart.

Besides the syntax above, ebnf-dtd also accepts a `pure' dtd file. An example of a `pure' dtd file is:

<?xml version="1.0" encoding="UTF-8"?>
   
   <!ELEMENT workflow (registers?, trigger-functions?, initial-actions,
                       steps, splits?, joins?)>
   
   <!ELEMENT action (restrict-to, validators?, pre-functions?, results,
                     post-functions?)>
   <!ATTLIST action
        id CDATA #REQUIRED
        name CDATA #REQUIRED
   >

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Defined variables (2)

`ebnf-dtd-lex`	Value returned by ‘ebnf-dtd-lex’ function.
`ebnf-dtd-token-table`	Vector used to map characters to a lexical token.

Defined functions (17)

`ebnf-dtd-attribute`	(TOKEN ATTR MATCH ATTR-NAME)
`ebnf-dtd-attribute-optional`	(TOKEN ATTR MATCH ATTR-NAME)
`ebnf-dtd-char-ref`	(START CHARS)
`ebnf-dtd-children`	(TOKEN)
`ebnf-dtd-choice-seq`	(TOKEN)
`ebnf-dtd-cp`	(TOKEN)
`ebnf-dtd-externalid`	(&optional TOKEN)
`ebnf-dtd-initialize`	()
`ebnf-dtd-intsubset`	(TOKEN)
`ebnf-dtd-lex`	()
`ebnf-dtd-name-ref`	(START)
`ebnf-dtd-namelist`	(TYPE NAME-LIST)
`ebnf-dtd-operators`	(ELM)
`ebnf-dtd-parser`	(START)
`ebnf-dtd-pi`	(TOKEN)
`ebnf-dtd-prolog`	(TOKEN)
`ebnf-dtd-string`	(DELIM)

File: ebnf-dtd.el.html

Defined variables (2)

Defined functions (17)

Defined faces (0)

File: `ebnf-dtd.el.html`