path: root/src/xml/mod.rs

use std::char;

mod parsers;

/// [1]   	NSAttName	   ::=   	PrefixedAttName | DefaultAttName
#[derive(Clone, Debug)]
pub enum NSAttName<'s> {
    PrefixedAttName(PrefixedAttName<'s>),
    DefaultAttName,
}

/// [2]   	PrefixedAttName	   ::=   	'xmlns:' NCName
#[derive(Clone, Debug)]
pub struct PrefixedAttName<'s>(NCName<'s>);

/// [3]   	DefaultAttName	   ::=   	'xmlns';
#[derive(Clone, Debug)]
pub struct DefaultAttName;

/// [4]   	NCName	   ::=   	Name - (Char* ':' Char*)
#[derive(Clone, Debug)]
pub struct NCName<'s>(&'s str);

/// [7]   	QName	   ::=   	PrefixedName | UnprefixedName
#[derive(Clone, Debug)]
pub enum QName<'s> {
    PrefixedName(PrefixedName<'s>),
    UnprefixedName(UnprefixedName<'s>),
}

/// [8]   	PrefixedName	   ::=   	Prefix ':' LocalPart
#[derive(Clone, Debug)]
pub struct PrefixedName<'s> {
    prefix: Prefix<'s>,
    local_part: LocalPart<'s>,
}

/// [9]   	UnprefixedName	   ::=   	LocalPart
#[derive(Clone, Debug)]
pub struct UnprefixedName<'s>(LocalPart<'s>);

/// [10]   	Prefix	   ::=   	NCName
#[derive(Clone, Debug)]
pub struct Prefix<'s>(NCName<'s>);

/// [11]   	LocalPart	   ::=   	NCName
#[derive(Clone, Debug)]
pub struct LocalPart<'s>(NCName<'s>);

// xml spec

/// [1]   	document	   ::=   	prolog element Misc*
pub type Document<'s> = (Prolog<'s>, Element<'s>, Vec<Misc<'s>>);

/// [2]   	Char	   ::=   	#x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF]	/* any Unicode character, excluding the surrogate blocks, FFFE, and FFFF. */
#[repr(transparent)]
pub struct Char(char);

/// [3]   	S	   ::=   	(#x20 | #x9 | #xD | #xA)+
#[repr(transparent)]
pub struct S<'s>(&'s str);

/// [4]   	NameStartChar	   ::=   	":" | [A-Z] | "_" | [a-z] | [#xC0-#xD6] | [#xD8-#xF6] | [#xF8-#x2FF] | [#x370-#x37D] | [#x37F-#x1FFF] | [#x200C-#x200D] | [#x2070-#x218F] | [#x2C00-#x2FEF] | [#x3001-#xD7FF] | [#xF900-#xFDCF] | [#xFDF0-#xFFFD] | [#x10000-#xEFFFF]
#[repr(transparent)]
pub struct NameStartChar(char);

/// [4a]   	NameChar	   ::=   	NameStartChar | "-" | "." | [0-9] | #xB7 | [#x0300-#x036F] | [#x203F-#x2040]
#[repr(transparent)]
pub struct NameChar(char);

/// [5]   	Name	   ::=   	NameStartChar (NameChar)*
#[derive(Debug, Clone, PartialEq, Eq)]
#[repr(transparent)]
pub struct Name<'s>(&'s str);

/// [6]   	Names	   ::=   	Name (#x20 Name)*
#[repr(transparent)]
// TODO: turn into vec
pub struct Names<'s>(&'s str);

/// [7]   	Nmtoken	   ::=   	(NameChar)+
#[derive(Debug, Clone)]
#[repr(transparent)]
pub struct Nmtoken<'s>(&'s str);

/// [8]   	Nmtokens	   ::=   	Nmtoken (#x20 Nmtoken)*
#[repr(transparent)]
// TODO: turn into vec
pub struct Nmtokens<'s>(&'s str);

#[derive(Clone, Debug)]
pub enum LiteralData<'s> {
    String(&'s str),
    PEReference(PEReference<'s>),
    Reference(Reference<'s>),
}
/// [9]   	EntityValue	   ::=   	'"' ([^%&"] | PEReference | Reference)* '"'
///			|  "'" ([^%&'] | PEReference | Reference)* "'"
#[derive(Debug)]
#[repr(transparent)]
pub struct EntityValue<'s>(Vec<LiteralData<'s>>);

/// [10]   	AttValue	   ::=   	'"' ([^<&"] | Reference)* '"'
/// 			|  "'" ([^<&'] | Reference)* "'"
#[derive(Clone, Debug)]
#[repr(transparent)]
pub struct AttValue<'s>(Vec<LiteralData<'s>>);

/// [11]   	SystemLiteral	   ::=   	('"' [^"]* '"') | ("'" [^']* "'")
#[derive(Debug)]
#[repr(transparent)]
pub struct SystemLiteral<'s>(&'s str);

/// [12]   	PubidLiteral	   ::=   	'"' PubidChar* '"' | "'" (PubidChar - "'")* "'"
#[derive(Debug)]
#[repr(transparent)]
pub struct PubidLiteral<'s>(&'s str);

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

/// [14]   	CharData	   ::=   	[^<&]* - ([^<&]* ']]>' [^<&]*)
#[derive(Clone, Debug, PartialEq, Eq)]
#[repr(transparent)]
pub struct CharData<'s>(&'s str);

/// [15]    Comment	   ::=   	'<!--' ((Char - '-') | ('-' (Char - '-')))* '-->'
#[derive(Clone, Debug, PartialEq, Eq)]
#[repr(transparent)]
pub struct Comment<'s>(&'s str);

/// [16]   	PI	   ::=   	'<?' PITarget (S (Char* - (Char* '?>' Char*)))? '?>'
#[derive(Clone, Debug)]
pub struct PI<'s> {
    target: PITarget<'s>,
    instruction: Option<&'s str>,
}

/// [17]   	PITarget	   ::=   	Name - (('X' | 'x') ('M' | 'm') ('L' | 'l'))
#[derive(Clone, Debug, PartialEq, Eq)]
#[repr(transparent)]
pub struct PITarget<'s>(Name<'s>);

/// [18]   	CDSect	   ::=   	CDStart CData CDEnd
#[derive(Clone, Debug, PartialEq, Eq)]
#[repr(transparent)]
pub struct CDSect<'s>(CData<'s>);

/// [19]   	CDStart	   ::=   	'<![CDATA['
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct CDStart;

/// [20]   	CData	   ::=   	(Char* - (Char* ']]>' Char*))
#[derive(Clone, Debug, PartialEq, Eq)]
#[repr(transparent)]
pub struct CData<'s>(&'s str);

/// [21]   	CDEnd	   ::=   	']]>'
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct CDEnd;

/// [22]   	prolog	   ::=   	XMLDecl? Misc* (doctypedecl Misc*)?
pub type Prolog<'s> = (
    Option<XMLDecl<'s>>,
    Vec<Misc<'s>>,
    Option<(DoctypeDecl<'s>, Vec<Misc<'s>>)>,
);

/// [23]   	XMLDecl	   ::=   	'<?xml' VersionInfo EncodingDecl? SDDecl? S? '?>'
#[derive(Debug)]
pub struct XMLDecl<'s> {
    version_info: VersionInfo,
    encoding_decl: Option<EncodingDecl<'s>>,
    sd_decl: Option<SDDecl>,
}

/// [24]   	VersionInfo	   ::=   	S 'version' Eq ("'" VersionNum "'" | '"' VersionNum '"')
#[derive(Debug)]
pub struct VersionInfo(VersionNum);

/// [25]   	Eq	   ::=   	S? '=' S?
#[derive(Clone)]
pub struct Eq;

/// [26]   	VersionNum	   ::=   	'1.' [0-9]+
#[derive(Clone, Debug)]
pub enum VersionNum {
    One,
    OneDotOne,
}

/// [27]   	Misc	   ::=   	Comment | PI | S
#[derive(Clone, Debug)]
pub enum Misc<'s> {
    Comment(Comment<'s>),
    PI(PI<'s>),
    // TODO: how to deal with whitespace
    S,
}

/// [16]   	doctypedecl	   ::=   	'<!DOCTYPE' S QName (S ExternalID)? S? ('[' (markupdecl | PEReference | S)* ']' S?)? '>'
/// [28]   	doctypedecl	   ::=   	'<!DOCTYPE' S Name (S ExternalID)? S? ('[' intSubset ']' S?)? '>'
#[derive(Debug)]
pub struct DoctypeDecl<'s> {
    name: QName<'s>,
    external_id: Option<ExternalID<'s>>,
    int_subset: Option<IntSubset<'s>>,
}

/// [28a]   	DeclSep	   ::=   	PEReference | S
#[derive(Clone, Debug)]
pub enum DeclSep<'s> {
    PEReference(PEReference<'s>),
    // TODO: tackle whitespace
    S,
}

#[derive(Debug)]
pub enum IntSubsetDeclaration<'s> {
    MarkupDecl(MarkupDecl<'s>),
    DeclSep(DeclSep<'s>),
}
/// [28b]   	intSubset	   ::=   	(markupdecl | DeclSep)*
pub type IntSubset<'s> = Vec<IntSubsetDeclaration<'s>>;

/// [29]   	markupdecl	   ::=   	elementdecl | AttlistDecl | EntityDecl | NotationDecl | PI | Comment
#[derive(Debug)]
pub enum MarkupDecl<'s> {
    Elementdecl(Elementdecl<'s>),
    AttlistDecl(AttlistDecl<'s>),
    EntityDecl(EntityDecl<'s>),
    NotationDecl(NotationDecl<'s>),
    PI(PI<'s>),
    Comment(Comment<'s>),
}

/// [30]   	extSubset	   ::=   	TextDecl? extSubsetDecl
pub struct ExtSubset<'s> {
    text_decl: Option<TextDecl<'s>>,
    ext_subset_decl: ExtSubsetDecl<'s>,
}

pub enum ExtSubsetDeclaration<'s> {
    MarkupDecl(MarkupDecl<'s>),
    ConditionalSect(ConditionalSect<'s>),
    DeclSep(DeclSep<'s>),
}
/// [31]   	extSubsetDecl	   ::=   	( markupdecl | conditionalSect | DeclSep)*
type ExtSubsetDecl<'s> = Vec<ExtSubsetDeclaration<'s>>;

/// [32]   	SDDecl	   ::=   	S 'standalone' Eq (("'" ('yes' | 'no') "'") | ('"' ('yes' | 'no') '"'))
pub type SDDecl = bool;

// (Productions 33 through 38 have been removed.)

/// [39]   	element	   ::=   	EmptyElemTag | STag content ETag
#[derive(Debug, Clone)]
pub enum Element<'s> {
    Empty(EmptyElemTag<'s>),
    NotEmpty(STag<'s>, Content<'s>, ETag<'s>),
}

/// [12]   	STag	   ::=   	'<' QName (S Attribute)* S? '>'
/// [40]   	STag	   ::=   	'<' Name (S Attribute)* S? '>'
#[derive(Debug, Clone)]
pub struct STag<'s> {
    name: QName<'s>,
    attributes: Vec<Attribute<'s>>,
}

/// [15]   	Attribute	   ::=   	NSAttName Eq AttValue | QName Eq AttValue
// pub type Attribute<'s> = (Name<'s>, AttValue<'s>);
/// [41]   	Attribute	   ::=   	Name Eq AttValue
#[derive(Debug, Clone)]
pub enum Attribute<'s> {
    NamespaceDeclaration {
        ns_name: NSAttName<'s>,
        value: AttValue<'s>,
    },
    Attribute {
        name: QName<'s>,
        value: AttValue<'s>,
    },
}

/// [13]   	ETag	   ::=   	'</' QName S? '>'
/// [42]   	ETag	   ::=   	'</' Name S? '>'
#[derive(Debug, Clone)]
pub struct ETag<'s> {
    name: QName<'s>,
}

#[derive(Debug, Clone)]
pub enum ContentItem<'s> {
    // CharData(&'s str),
    Element(Element<'s>),
    Reference(Reference<'s>),
    CDSect(CDSect<'s>),
    PI(PI<'s>),
    Comment(Comment<'s>),
}
/// [43]   	content	   ::=   	CharData? ((element | Reference | CDSect | PI | Comment) CharData?)*
#[derive(Debug, Clone)]
pub struct Content<'s> {
    char_data: Option<CharData<'s>>,
    content: Vec<(ContentItem<'s>, Option<CharData<'s>>)>,
}

/// [14]   	EmptyElemTag	   ::=   	'<' QName (S Attribute)* S? '/>'
/// [44]   	EmptyElemTag	   ::=   	'<' Name (S Attribute)* S? '/>'	[WFC: Unique Att Spec]
#[derive(Debug, Clone)]
pub struct EmptyElemTag<'s> {
    name: QName<'s>,
    attributes: Vec<Attribute<'s>>,
}

/// [17]   	elementdecl	   ::=   	'<!ELEMENT' S QName S contentspec S? '>'
/// [45]   	elementdecl	   ::=   	'<!ELEMENT' S Name S contentspec S? '>'
#[derive(Debug)]
pub struct Elementdecl<'s> {
    name: QName<'s>,
    contentspec: Contentspec<'s>,
}

// TODO: casings???
/// [46]   	contentspec	   ::=   	'EMPTY' | 'ANY' | Mixed | children
#[derive(Clone, Debug)]
pub enum Contentspec<'s> {
    Empty,
    Any,
    Mixed(Mixed<'s>),
    Children(Children<'s>),
}

/// Occurence ::= ('?' | '*' | '+')?
#[derive(Clone, Debug)]
pub enum Occurence {
    Once,
    Optional,
    Many0,
    Many1,
}

#[derive(Clone, Debug)]
pub enum ChildrenKind<'s> {
    Choice(Choice<'s>),
    Seq(Seq<'s>),
}
/// [47]   	children	   ::=   	(choice | seq) ('?' | '*' | '+')?
#[derive(Clone, Debug)]
pub struct Children<'s> {
    kind: ChildrenKind<'s>,
    occurence: Occurence,
}

#[derive(Clone, Debug)]
pub enum CpKind<'s> {
    Name(QName<'s>),
    Choice(Choice<'s>),
    Seq(Seq<'s>),
}
/// [18]   	cp	   ::=   	(QName | choice | seq) ('?' | '*' | '+')?
/// [48]   	cp	   ::=   	(Name | choice | seq) ('?' | '*' | '+')?
#[derive(Clone, Debug)]
pub struct Cp<'s> {
    kind: CpKind<'s>,
    occurence: Occurence,
}

/// [49]   	choice	   ::=   	'(' S? cp ( S? '|' S? cp )+ S? ')'
#[derive(Clone, Debug)]
pub struct Choice<'s>(Vec<Cp<'s>>);

/// [50]   	seq	   ::=   	'(' S? cp ( S? ',' S? cp )* S? ')'
#[derive(Clone, Debug)]
pub struct Seq<'s>(Vec<Cp<'s>>);

// always contains #PCDATA
/// [19]   	Mixed	   ::=   	'(' S? '#PCDATA' (S? '|' S? QName)* S? ')*' | '(' S? '#PCDATA' S? ')'
/// [51]   	Mixed	   ::=   	'(' S? '#PCDATA' (S? '|' S? Name)* S? ')*' | '(' S? '#PCDATA' S? ')'
#[derive(Clone, Debug)]
pub struct Mixed<'s>(Vec<QName<'s>>);

/// [20]   	AttlistDecl	   ::=   	'<!ATTLIST' S QName AttDef* S? '>'
/// [52]   	AttlistDecl	   ::=   	'<!ATTLIST' S Name AttDef* S? '>'
#[derive(Debug)]
pub struct AttlistDecl<'s> {
    element_type: QName<'s>,
    att_defs: Vec<AttDef<'s>>,
}

#[derive(Debug)]
pub enum AttDefName<'s> {
    QName(QName<'s>),
    NSAttName(NSAttName<'s>),
}
/// [21]   	AttDef	   ::=   	S (QName | NSAttName) S AttType S DefaultDecl
/// [53]   	AttDef	   ::=   	S Name S AttType S DefaultDecl
#[derive(Debug)]
pub struct AttDef<'s> {
    name: AttDefName<'s>,
    att_type: AttType<'s>,
    default_decl: DefaultDecl<'s>,
}

/// [54]   	AttType	   ::=   	StringType | TokenizedType | EnumeratedType
#[derive(Clone, Debug)]
pub enum AttType<'s> {
    StringType,
    TokenizedType(TokenizedType),
    EnumeratedType(EnumeratedType<'s>),
}

/// [55]   	StringType	   ::=   	'CDATA'
#[derive(Clone)]
pub struct StringType;

/// [56]   	TokenizedType	   ::=   	'ID' | 'IDREF' | 'IDREFS' | 'ENTITY' | 'ENTITIES' | 'NMTOKEN' | 'NMTOKENS'
#[derive(Clone, Debug)]
pub enum TokenizedType {
    ID,
    IDRef,
    IDRefs,
    Entity,
    Entities,
    NMToken,
    NMTokens,
}

/// [57]   	EnumeratedType	   ::=   	NotationType | Enumeration
#[derive(Debug, Clone)]
pub enum EnumeratedType<'s> {
    NotationType(NotationType<'s>),
    Enumeration(Enumeration<'s>),
}

/// [58]   	NotationType	   ::=   	'NOTATION' S '(' S? Name (S? '|' S? Name)* S? ')'
#[derive(Debug, Clone)]
pub struct NotationType<'s>(Vec<Name<'s>>);

/// [59]   	Enumeration	   ::=   	'(' S? Nmtoken (S? '|' S? Nmtoken)* S? ')'
#[derive(Debug, Clone)]
pub struct Enumeration<'s>(Vec<Nmtoken<'s>>);

/// [60]   	DefaultDecl	   ::=   	'#REQUIRED' | '#IMPLIED' | (('#FIXED' S)? AttValue)
#[derive(Debug, Clone)]
pub enum DefaultDecl<'s> {
    Required,
    Implied,
    Fixed(AttValue<'s>),
}

/// [61]   	conditionalSect	   ::=   	includeSect | ignoreSect
pub enum ConditionalSect<'s> {
    IncludeSect(IncludeSect<'s>),
    IgnoreSect(IgnoreSect<'s>),
}

/// [62]   	includeSect	   ::=   	'<![' S? 'INCLUDE' S? '[' extSubsetDecl ']]>'
pub struct IncludeSect<'s>(ExtSubsetDecl<'s>);

/// [63]   	ignoreSect	   ::=   	'<![' S? 'IGNORE' S? '[' ignoreSectContents* ']]>'
pub struct IgnoreSect<'s>(Vec<IgnoreSectContents<'s>>);

/// [64]   	ignoreSectContents	   ::=   	Ignore ('<![' ignoreSectContents ']]>' Ignore)*
pub struct IgnoreSectContents<'s> {
    // TODO: what the fuck does this mean
    ignore: Ignore<'s>,
    ignore_list: Vec<(IgnoreSectContents<'s>, Ignore<'s>)>,
}

/// [65]   	Ignore	   ::=   	Char* - (Char* ('<![' | ']]>') Char*)
pub struct Ignore<'s>(&'s str);

/// [66]   	CharRef	   ::=   	'&#' [0-9]+ ';' | '&#x' [0-9a-fA-F]+ ';'
#[derive(Clone, Debug)]
pub enum CharRef<'s> {
    Decimal(&'s str),
    Hexadecimal(&'s str),
}

/// [67]   	Reference	   ::=   	EntityRef | CharRef
#[derive(Clone, Debug)]
pub enum Reference<'s> {
    EntityRef(EntityRef<'s>),
    CharRef(CharRef<'s>),
}

/// [68]   	EntityRef	   ::=   	'&' Name ';'
#[derive(Clone, Debug)]
pub struct EntityRef<'s>(Name<'s>);

/// [69]   	PEReference	   ::=   	'%' Name ';'
#[derive(Clone, Debug)]
#[repr(transparent)]
pub struct PEReference<'s>(Name<'s>);

/// [70]   	EntityDecl	   ::=   	GEDecl | PEDecl
#[derive(Debug)]
pub enum EntityDecl<'s> {
    GEDecl(GEDecl<'s>),
    PEDecl(PEDecl<'s>),
}

/// [71]   	GEDecl	   ::=   	'<!ENTITY' S Name S EntityDef S? '>'
#[derive(Debug)]
pub struct GEDecl<'s> {
    name: Name<'s>,
    entity_def: EntityDef<'s>,
}

/// [72]   	PEDecl	   ::=   	'<!ENTITY' S '%' S Name S PEDef S? '>'
#[derive(Debug)]
pub struct PEDecl<'s> {
    name: Name<'s>,
    pe_def: PEDef<'s>,
}

/// [73]   	EntityDef	   ::=   	EntityValue | (ExternalID NDataDecl?)
#[derive(Debug)]
pub enum EntityDef<'s> {
    EntityValue(EntityValue<'s>),
    ExternalID {
        external_id: ExternalID<'s>,
        ndata_decl: Option<NDataDecl<'s>>,
    },
}

/// [74]   	PEDef	   ::=   	EntityValue | ExternalID
#[derive(Debug)]
pub enum PEDef<'s> {
    EntityValue(EntityValue<'s>),
    ExternalID(ExternalID<'s>),
}

/// [75]   	ExternalID	   ::=   	'SYSTEM' S SystemLiteral | 'PUBLIC' S PubidLiteral S SystemLiteral
#[derive(Debug)]
pub enum ExternalID<'s> {
    SYSTEM {
        system_identifier: SystemLiteral<'s>,
    },
    PUBLIC {
        public_identifier: PubidLiteral<'s>,
        system_identifier: SystemLiteral<'s>,
    },
}

/// [76]   	NDataDecl	   ::=   	S 'NDATA' S Name
#[derive(Debug)]
pub struct NDataDecl<'s>(Name<'s>);

/// [77]   	TextDecl	   ::=   	'<?xml' VersionInfo? EncodingDecl S? '?>'
pub struct TextDecl<'s> {
    version_info: Option<VersionInfo>,
    encoding_decl: EncodingDecl<'s>,
}

/// [78]   	extParsedEnt	   ::=   	TextDecl? content
pub struct ExtParsedEnt<'s> {
    text_decl: Option<TextDecl<'s>>,
    content: Content<'s>,
}

/// [80]   	EncodingDecl	   ::=   	S 'encoding' Eq ('"' EncName '"' | "'" EncName
#[derive(Debug)]
pub struct EncodingDecl<'s>(EncName<'s>);

/// [81]   	EncName	   ::=   	[A-Za-z] ([A-Za-z0-9._] | '-')*
#[derive(Debug)]
pub struct EncName<'s>(&'s str);

#[derive(Debug)]
pub enum NotationDeclID<'s> {
    External(ExternalID<'s>),
    Public(PublicID<'s>),
}
/// [82]   	NotationDecl	   ::=   	'<!NOTATION' S Name S (ExternalID | PublicID) S? '>'
#[derive(Debug)]
pub struct NotationDecl<'s> {
    name: Name<'s>,
    id: NotationDeclID<'s>,
}

/// [83]   	PublicID	   ::=   	'PUBLIC' S PubidLiteral
#[derive(Debug)]
pub struct PublicID<'s>(PubidLiteral<'s>);