XML DTD and DOCTYPE — DTD Syntax, Element/Attribute Declarations, Entities, Validation, Limitations

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE bookstore SYSTEM "bookstore.dtd">
<bookstore>
    <book category="fiction">
        <title lang="en">DTD Guide</title>
        <author>Alice Smith</author>
        <price>29.99</price>
    </book>
</bookstore>

<!-- Internal DTD — declarations in the same file -->
<?xml version="1.0"?>
<!DOCTYPE bookstore [
    <!ELEMENT bookstore (book+)>
    <!ELEMENT book (title, author, price)>
    <!ATTLIST book category CDATA #REQUIRED>
    <!ELEMENT title (#PCDATA)>
    <!ATTLIST title lang CDATA "en">
    <!ELEMENT author (#PCDATA)>
    <!ELEMENT price (#PCDATA)>
]>
<bookstore>
    <book category="fiction">
        <title>DTD Guide</title>
        <author>Alice</author>
        <price>29.99</price>
    </book>
</bookstore>

<!-- External DTD — declarations in a separate .dtd file -->
<!DOCTYPE bookstore SYSTEM "bookstore.dtd">

<!ELEMENT element-name content-model>

<!-- bookstore.dtd -->
<!ELEMENT bookstore (book+)>
<!ELEMENT book (title, subtitle?, author+, editor*, price, chapters)>
<!ELEMENT title (#PCDATA)>
<!ELEMENT subtitle (#PCDATA)>
<!ELEMENT author (#PCDATA)>
<!ELEMENT editor (#PCDATA)>
<!ELEMENT price (#PCDATA)>
<!ELEMENT chapters (chapter+)>
<!ELEMENT chapter (title, content)>
<!ELEMENT content (#PCDATA)>

<!ATTLIST element-name
    attr-name attr-type default-decl
    attr-name attr-type default-decl
    ...>

<!ATTLIST book
    category (fiction|non-fiction|reference) "fiction"
    id ID #REQUIRED
    isbn CDATA #REQUIRED
    lang NMTOKEN "en"
    edition CDATA #IMPLIED
>

<!ATTLIST chapter
    id ID #REQUIRED
    parent IDREF #IMPLIED
>

<!-- Internal entity -->
<!ENTITY author "Alice Smith">
<!ENTITY copyright "Copyright 2026 DodaTech">

<!-- External entity -->
<!ENTITY intro SYSTEM "intro.xml">
<!ENTITY legal SYSTEM "legal.txt">

<!-- Usage in XML -->
<book>
    <author>&author;</author>
    <intro>&intro;</intro>
    <legal>&legal;</legal>
</book>

<!-- Parameter entity declaration -->
<!ENTITY % inline "(b | i | u)">
<!ENTITY % common-attrs
    "id ID #IMPLIED
     class CDATA #IMPLIED
     style CDATA #IMPLIED">

<!-- Usage in DTD -->
<!ELEMENT paragraph (#PCDATA | %inline;)*>
<!ATTLIST paragraph %common-attrs;>

import javax.xml.parsers.*;
import org.xml.sax.*;

public class DtdValidator {
    public static void main(String[] args) throws Exception {
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        factory.setValidating(true);  // Enable DTD validation
        factory.setNamespaceAware(true);

        DocumentBuilder builder = factory.newDocumentBuilder();

        // Set error handler to capture validation errors
        builder.setErrorHandler(new ErrorHandler() {
            @Override
            public void warning(SAXParseException e) {
                System.out.println("WARNING: " + e.getMessage());
            }

            @Override
            public void error(SAXParseException e) {
                System.out.println("ERROR: " + e.getMessage());
            }

            @Override
            public void fatalError(SAXParseException e) {
                System.out.println("FATAL: " + e.getMessage());
            }
        });

        try {
            builder.parse("books.xml");
            System.out.println("Document is valid.");
        } catch (SAXException e) {
            System.out.println("Validation failed: " + e.getMessage());
        }
    }
}

from lxml import etree

def validate_with_dtd(xml_file, dtd_file=None):
    """Validate XML against DTD"""
    try:
        if dtd_file:
            # External DTD
            dtd = etree.DTD(open(dtd_file))
            tree = etree.parse(xml_file)
            if dtd.validate(tree):
                print("Document is valid.")
            else:
                print(f"Validation error: {dtd.error_log.last_error}")
        else:
            # Internal DTD (DOCTYPE in file)
            tree = etree.parse(xml_file)
            # If DTD is embedded, it's validated automatically
            print("Document parsed (internal DTD checked).")
    except etree.XMLSyntaxError as e:
        print(f"Parse error: {e}")

# Usage
validate_with_dtd('books.xml', 'bookstore.dtd')

<!ENTITY lol "lol">
<!ENTITY lol2 "&lol;&lol;&lol;">
<!ENTITY lol3 "&lol2;&lol2;&lol2;">

from lxml import etree
from collections import defaultdict

class DtdGenerator:
    """Generate a DTD from sample XML documents"""

    def __init__(self):
        self.elements = defaultdict(lambda: {
            'children': set(),
            'attributes': {},
            'has_text': False,
            'min_occur': defaultdict(int),
            'max_occur': defaultdict(int)
        })

    def analyze(self, xml_file):
        tree = etree.parse(xml_file)
        self._analyze_element(tree.getroot())
        return self

    def _analyze_element(self, element, path=''):
        name = etree.QName(element).localname
        info = self.elements[name]

        # Check for text content
        if element.text and element.text.strip():
            info['has_text'] = True

        # Analyze attributes
        for attr_name in element.attrib:
            attr_type = 'CDATA'
            # Simple type detection
            if element.get(attr_name) in ('true', 'false'):
                attr_type = '(true|false)'
            elif element.get(attr_name).isdigit():
                attr_type = 'CDATA'  # DTD has no numeric types
            info['attributes'][attr_name] = attr_type

        # Analyze children
        child_counts = defaultdict(int)
        for child in element:
            child_name = etree.QName(child).localname
            info['children'].add(child_name)
            child_counts[child_name] += 1

        for child_name, count in child_counts.items():
            if info['min_occur'][child_name] == 0 or \
               count < info['min_occur'][child_name]:
                info['min_occur'][child_name] = count
            if count > info['max_occur'][child_name]:
                info['max_occur'][child_name] = count

        # Recurse
        for child in element:
            self._analyze_element(child)

    def generate(self, root_name='root'):
        lines = ['<!-- Generated DTD -->']
        lines.append(f'<!ELEMENT {root_name} ('
                     f'{" | ".join(self.elements.keys())})>\n')

        for elem_name, info in sorted(self.elements.items()):
            # Content model
            if info['has_text'] and info['children']:
                children = ' | '.join(
                    sorted(info['children']))
                model = f'(#PCDATA | {children})*'
            elif info['has_text']:
                model = '(#PCDATA)'
            elif info['children']:
                children = ', '.join(
                    sorted(info['children']))
                model = f'({children})'
            else:
                model = 'EMPTY'

            lines.append(f'<!ELEMENT {elem_name} {model}>')

            # Attributes
            for attr_name, attr_type in sorted(
                info['attributes'].items()
            ):
                if attr_type.startswith('('):
                    default = '#IMPLIED'
                else:
                    default = '#IMPLIED'
                lines.append(
                    f'<!ATTLIST {elem_name} '
                    f'{attr_name} {attr_type} {default}>')

            lines.append('')  # blank line

        return '\n'.join(lines)


# Usage
generator = DtdGenerator()
generator.analyze('sample.xml')
print(generator.generate('bookstore'))