diff --git a/Cargo.toml b/Cargo.toml index 33eefc03..6b649557 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,12 +1,12 @@ [package] name = "html5ever" -version = "0.8.0" +version = "0.9.0" authors = [ "The html5ever Project Developers" ] license = "MIT / Apache-2.0" repository = "https://github.com/servo/html5ever" description = "High-performance browser-grade HTML5 parser" -documentation = "https://kmcallister.github.io/docs/html5ever/html5ever/index.html" +documentation = "https://docs.rs/html5ever" build = "build.rs" [lib] @@ -31,17 +31,17 @@ name = "tokenizer" harness = false [features] -unstable = ["tendril/unstable", "string_cache/unstable"] +unstable = ["tendril/unstable"] heap_size = ["heapsize", "heapsize_plugin"] [dependencies] log = "0" phf = "0.7" -string_cache = "0.2.0" mac = "0" tendril = "0.2.2" heapsize = { version = "0.3", optional = true } heapsize_plugin = { version = "0.1.0", optional = true } +html5ever-atoms = { version = "0.1", path = "./atoms" } [dev-dependencies] rustc-serialize = "0.3.15" diff --git a/atoms/Cargo.toml b/atoms/Cargo.toml new file mode 100644 index 00000000..3478201d --- /dev/null +++ b/atoms/Cargo.toml @@ -0,0 +1,23 @@ +[package] +name = "html5ever-atoms" +version = "0.1.0" +authors = [ "The html5ever Project Developers" ] +license = "MIT / Apache-2.0" +repository = "https://github.com/servo/html5ever" +description = "Static strings for html5ever" +documentation = "https://docs.rs/html5ever-atoms" +build = "build.rs" + +[lib] +path = "lib.rs" + +[features] +heap_size = ["heapsize", "heapsize_plugin"] + +[dependencies] +string_cache = "0.3" +heapsize = { version = "0.3", optional = true } +heapsize_plugin = { version = "0.1.0", optional = true } + +[build-dependencies] +string_cache_codegen = "0.3" diff --git a/atoms/build.rs b/atoms/build.rs new file mode 100644 index 00000000..c8df8e2d --- /dev/null +++ b/atoms/build.rs @@ -0,0 +1,57 @@ +// Copyright 2016 The html5ever Project Developers. See the +// COPYRIGHT file at the top-level directory of this distribution. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +extern crate string_cache_codegen; + +use std::ascii::AsciiExt; +use std::env; +use std::fs::File; +use std::io::{Write, BufWriter, BufReader, BufRead}; +use std::path::Path; + +static NAMESPACES: &'static [(&'static str, &'static str)] = &[ + ("", ""), + ("*", "*"), + ("html", "http://www.w3.org/1999/xhtml"), + ("xml", "http://www.w3.org/XML/1998/namespace"), + ("xmlns", "http://www.w3.org/2000/xmlns/"), + ("xlink", "http://www.w3.org/1999/xlink"), + ("svg", "http://www.w3.org/2000/svg"), + ("mathml", "http://www.w3.org/1998/Math/MathML"), +]; + +fn main() { + let generated = Path::new(&env::var("OUT_DIR").unwrap()).join("generated.rs"); + let mut generated = BufWriter::new(File::create(&generated).unwrap()); + + let local_names = Path::new(&env::var("CARGO_MANIFEST_DIR").unwrap()).join("local_names.txt"); + let mut local_names_atom = string_cache_codegen::AtomType::new("LocalName", "local_name!"); + for line in BufReader::new(File::open(&local_names).unwrap()).lines() { + let local_name = line.unwrap(); + local_names_atom.atom(&local_name); + local_names_atom.atom(&local_name.to_ascii_lowercase()); + } + local_names_atom.write_to(&mut generated).unwrap(); + + string_cache_codegen::AtomType::new("Prefix", "namespace_prefix!") + .atoms(NAMESPACES.iter().map(|&(prefix, _url)| prefix)) + .write_to(&mut generated) + .unwrap(); + + string_cache_codegen::AtomType::new("Namespace", "namespace_url!") + .atoms(NAMESPACES.iter().map(|&(_prefix, url)| url)) + .write_to(&mut generated) + .unwrap(); + + writeln!(generated, "#[macro_export] macro_rules! ns {{").unwrap(); + for &(prefix, url) in NAMESPACES { + writeln!(generated, "({}) => {{ namespace_url!({:?}) }};", prefix, url).unwrap(); + } + writeln!(generated, "}}").unwrap(); +} diff --git a/atoms/lib.rs b/atoms/lib.rs new file mode 100644 index 00000000..08975a0f --- /dev/null +++ b/atoms/lib.rs @@ -0,0 +1,81 @@ +// Copyright 2016 The html5ever Project Developers. See the +// COPYRIGHT file at the top-level directory of this distribution. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#![cfg_attr(feature = "heap_size", feature(plugin, custom_derive))] +#![cfg_attr(feature = "heap_size", plugin(heapsize_plugin))] +#[cfg(feature = "heap_size")] extern crate heapsize; +extern crate string_cache; + +include!(concat!(env!("OUT_DIR"), "/generated.rs")); + +#[macro_export] +macro_rules! qualname { + ("", $local:tt) => { + $crate::QualName { + ns: ns!(), + local: local_name!($local), + } + }; + ($ns:tt, $local:tt) => { + $crate::QualName { + ns: ns!($ns), + local: local_name!($local), + } + } +} + +/// A name with a namespace. +#[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Clone)] +#[cfg_attr(feature = "heap_size", derive(HeapSizeOf))] +pub struct QualName { + pub ns: Namespace, + pub local: LocalName, +} + +impl QualName { + #[inline] + pub fn new(ns: Namespace, local: LocalName) -> QualName { + QualName { + ns: ns, + local: local, + } + } +} + +#[cfg(test)] +mod tests { + use super::{Namespace, QualName}; + use LocalName; + + #[test] + fn ns_macro() { + assert_eq!(ns!(), Namespace::from("")); + + assert_eq!(ns!(html), Namespace::from("http://www.w3.org/1999/xhtml")); + assert_eq!(ns!(xml), Namespace::from("http://www.w3.org/XML/1998/namespace")); + assert_eq!(ns!(xmlns), Namespace::from("http://www.w3.org/2000/xmlns/")); + assert_eq!(ns!(xlink), Namespace::from("http://www.w3.org/1999/xlink")); + assert_eq!(ns!(svg), Namespace::from("http://www.w3.org/2000/svg")); + assert_eq!(ns!(mathml), Namespace::from("http://www.w3.org/1998/Math/MathML")); + } + + #[test] + fn qualname() { + assert_eq!(QualName::new(ns!(), local_name!("")), + QualName { ns: ns!(), local: LocalName::from("") }); + assert_eq!(QualName::new(ns!(xml), local_name!("base")), + QualName { ns: ns!(xml), local: local_name!("base") }); + } + + #[test] + fn qualname_macro() { + assert_eq!(qualname!("", ""), QualName { ns: ns!(), local: local_name!("") }); + assert_eq!(qualname!(xml, "base"), QualName { ns: ns!(xml), local: local_name!("base") }); + } +} diff --git a/atoms/local_names.txt b/atoms/local_names.txt new file mode 100644 index 00000000..45b6ef4b --- /dev/null +++ b/atoms/local_names.txt @@ -0,0 +1,981 @@ +* +a +abbr +abs +accent +accent-height +accentunder +accept +accept-charset +accesskey +accumulate +acronym +action +actiontype +active +actuate +additive +address +align +alignment-baseline +alignmentscope +alink +alphabetic +alt +altGlyph +altGlyphDef +altGlyphItem +altimg +alttext +amplitude +and +animate +animateColor +animateMotion +animateTransform +animation +annotation +annotation-xml +applet +apply +approx +arabic-form +arccos +arccosh +arccot +arccoth +arccsc +arccsch +archive +arcrole +arcsec +arcsech +arcsin +arcsinh +arctan +arctanh +area +arg +aria-activedescendant +aria-atomic +aria-autocomplete +aria-busy +aria-channel +aria-checked +aria-controls +aria-datatype +aria-describedby +aria-disabled +aria-dropeffect +aria-expanded +aria-flowto +aria-grab +aria-haspopup +aria-hidden +aria-invalid +aria-labelledby +aria-level +aria-live +aria-multiline +aria-multiselectable +aria-owns +aria-posinset +aria-pressed +aria-readonly +aria-relevant +aria-required +aria-secret +aria-selected +aria-setsize +aria-sort +aria-templateid +aria-valuemax +aria-valuemin +aria-valuenow +article +ascent +aside +async +attributeName +attributeType +audio +autocomplete +autofocus +autoplay +autosubmit +axis +azimuth +b +background +base +baseFrequency +baseProfile +basefont +baseline +baseline-shift +bbox +bdi +bdo +begin +bevelled +bgcolor +bgsound +bias +big +blink +blockquote +body +border +br +button +bvar +by +calcMode +canvas +cap-height +caption +card +cartesianproduct +ceiling +cellpadding +cellspacing +center +char +charoff +charset +checked +ci +circle +cite +class +classid +clear +clip +clip-path +clip-rule +clipPath +clipPathUnits +close +closure +cn +code +codebase +codetype +codomain +col +colgroup +color +color-interpolation +color-interpolation-filters +color-profile +color-rendering +cols +colspan +columnalign +columnlines +columnspacing +columnspan +columnwidth +compact +complexes +compose +condition +conjugate +content +contentScriptType +contentStyleType +contenteditable +contextmenu +controls +coords +cos +cosh +cot +coth +crossorigin +csc +csch +csymbol +curl +cursor +cx +cy +d +data +datafld +dataformatas +datalist +datasrc +datatemplate +datetime +dd +declare +default +defer +definition-src +definitionURL +defs +degree +del +depth +desc +descent +details +determinant +dfn +dialog +diff +diffuseConstant +dir +direction +dirname +disabled +discard +display +displaystyle +div +divergence +divide +divisor +dl +domain +domainofapplication +dominant-baseline +draggable +dt +dur +dx +dy +edge +edgeMode +elevation +ellipse +em +embed +emptyset +enable-background +encoding +enctype +end +eq +equalcolumns +equalrows +equivalent +eulergamma +event +exists +exp +exponent +exponentiale +externalResourcesRequired +face +factorial +factorof +false +feBlend +feColorMatrix +feComponentTransfer +feComposite +feConvolveMatrix +feDiffuseLighting +feDisplacementMap +feDistantLight +feDropShadow +feFlood +feFuncA +feFuncB +feFuncG +feFuncR +feGaussianBlur +feImage +feMerge +feMergeNode +feMorphology +feOffset +fePointLight +feSpecularLighting +feSpotLight +feTile +feTurbulence +fence +fieldset +figcaption +figure +fill +fill-opacity +fill-rule +filter +filterRes +filterUnits +flood-color +flood-opacity +floor +fn +font +font-face +font-face-format +font-face-name +font-face-src +font-face-uri +font-family +font-size +font-size-adjust +font-stretch +font-style +font-variant +font-weight +fontfamily +fontsize +fontstyle +fontweight +footer +for +forall +foreignObject +form +formaction +format +formenctype +formmethod +formnovalidate +formtarget +frame +frameborder +frameset +framespacing +from +fx +fy +g +g1 +g2 +gcd +geq +glyph +glyph-name +glyph-orientation-horizontal +glyph-orientation-vertical +glyphRef +grad +gradientTransform +gradientUnits +groupalign +gt +h1 +h2 +h3 +h4 +h5 +h6 +handler +hanging +head +header +headers +height +hgroup +hidden +hidefocus +high +hkern +horiz-adv-x +horiz-origin-x +horiz-origin-y +hr +href +hreflang +hspace +html +http-equiv +i +icon +id +ident +ideographic +iframe +image +image-rendering +imaginary +imaginaryi +img +implies +in +in2 +index +infinity +input +inputmode +ins +int +integers +intercept +intersect +interval +inverse +irrelevant +isindex +ismap +k +k1 +k2 +k3 +k4 +kbd +kernelMatrix +kernelUnitLength +kerning +keyPoints +keySplines +keyTimes +keygen +label +lambda +lang +language +laplacian +largeop +lcm +legend +lengthAdjust +leq +letter-spacing +li +lighting-color +limit +limitingConeAngle +line +linearGradient +linebreak +linethickness +link +list +listener +listing +ln +local +log +logbase +longdesc +loop +low +lowlimit +lowsrc +lquote +lspace +lt +macros +maction +main +maligngroup +malignmark +manifest +map +marginheight +marginwidth +mark +marker +marker-end +marker-mid +marker-start +markerHeight +markerUnits +markerWidth +marquee +mask +maskContentUnits +maskUnits +math +mathbackground +mathcolor +mathematical +mathsize +mathvariant +matrix +matrixrow +max +maxlength +maxsize +mean +media +median +mediummathspace +menclose +menu +menuitem +merror +meta +metadata +meter +method +mfenced +mfrac +mglyph +mi +min +minlength +minsize +minus +missing-glyph +mlabeledtr +mmultiscripts +mn +mo +mode +moment +momentabout +movablelimits +mover +mozbrowser +mpadded +mpath +mphantom +mprescripts +mroot +mrow +ms +mspace +msqrt +mstyle +msub +msubsup +msup +mtable +mtd +mtext +mtr +multicol +multiple +munder +munderover +name +nargs +naturalnumbers +nav +neq +nest +nextid +nobr +noembed +noframes +nohref +none +noresize +noscript +noshade +not +notanumber +notation +notin +notprsubset +notsubset +novalidate +nowrap +numOctaves +object +occurrence +offset +ol +onabort +onactivate +onafterprint +onafterupdate +onbefordeactivate +onbeforeactivate +onbeforecopy +onbeforecut +onbeforeeditfocus +onbeforepaste +onbeforeprint +onbeforeunload +onbeforeupdate +onbegin +onblur +onbounce +oncellchange +onchange +onclick +oncontextmenu +oncontrolselect +oncopy +oncut +ondataavailable +ondatasetchanged +ondatasetcomplete +ondblclick +ondeactivate +ondrag +ondragdrop +ondragend +ondragenter +ondragleave +ondragover +ondragstart +ondrop +onend +onerror +onerrorupdate +onfilterchange +onfinish +onfocus +onfocusin +onfocusout +onformchange +onforminput +onhashchange +onhelp +oninput +oninvalid +onkeydown +onkeypress +onkeyup +onlanguagechange +onload +onlosecapture +onmessage +onmousedown +onmouseenter +onmouseleave +onmousemove +onmouseout +onmouseover +onmouseup +onmousewheel +onmove +onmoveend +onmovestart +onoffline +ononline +onpagehide +onpageshow +onpaste +onpopstate +onpropertychange +onreadystatechange +onrepeat +onreset +onresize +onrowenter +onrowexit +onrowsdelete +onrowsinserted +onscroll +onselect +onselectstart +onstart +onstop +onstorage +onsubmit +onunload +onzoom +opacity +open +operator +optgroup +optimum +option +or +order +orient +orientation +origin +other +otherwise +outerproduct +output +overflow +overline-position +overline-thickness +p +panose-1 +param +partialdiff +path +pathLength +pattern +patternContentUnits +patternTransform +patternUnits +pi +piece +piecewise +ping +placeholder +plaintext +plus +pointer-events +points +pointsAtX +pointsAtY +pointsAtZ +polygon +polyline +poster +power +pre +prefetch +preload +preserveAlpha +preserveAspectRatio +primes +primitiveUnits +product +profile +progress +prompt +prsubset +q +quotient +r +radialGradient +radiogroup +radius +rationals +rb +readonly +real +reals +rect +refX +refY +rel +reln +rem +rendering-intent +repeat +repeat-max +repeat-min +repeat-start +repeat-template +repeatCount +repeatDur +replace +required +requiredExtensions +requiredFeatures +restart +result +rev +role +root +rotate +rowalign +rowlines +rows +rowspacing +rowspan +rp +rquote +rspace +rt +rtc +ruby +rule +rules +rx +ry +s +samp +sandbox +scalarproduct +scale +scheme +scope +scoped +script +scriptlevel +scriptminsize +scriptsizemultiplier +scrolldelay +scrolling +sdev +seamless +sec +sech +section +seed +select +selected +selection +selector +semantics +sep +separator +separators +set +setdiff +shape +shape-rendering +show +sin +sinh +size +sizes +slope +small +solidcolor +source +space +spacer +spacing +span +specification +specularConstant +specularExponent +speed +spreadMethod +src +srcdoc +standby +start +startOffset +stdDeviation +stemh +stemv +step +stitchTiles +stop +stop-color +stop-opacity +stretchy +strike +strikethrough-position +strikethrough-thickness +string +stroke +stroke-dasharray +stroke-dashoffset +stroke-linecap +stroke-linejoin +stroke-miterlimit +stroke-opacity +stroke-width +strong +style +sub +subscriptshift +subset +sum +summary +sup +superscriptshift +surfaceScale +svg +switch +symbol +symmetric +systemLanguage +tabindex +table +tableValues +tan +tanh +target +targetX +targetY +tbody +tbreak +td +template +tendsto +text +text-anchor +text-decoration +text-rendering +textLength +textPath +textarea +tfoot +th +thead +thickmathspace +thinmathspace +time +times +title +to +tr +track +transform +transpose +tref +true +tspan +tt +type +u +u1 +u2 +ul +underline-position +underline-thickness +unicode +unicode-bidi +unicode-range +union +units-per-em +unselectable +uplimit +use +usemap +v-alphabetic +v-hanging +v-ideographic +v-mathematical +valign +value +values +valuetype +var +variance +vector +vectorproduct +version +vert-adv-y +vert-origin-x +vert-origin-y +verythickmathspace +verythinmathspace +veryverythickmathspace +veryverythinmathspace +video +view +viewBox +viewTarget +visibility +vkern +vlink +vspace +wbr +when +width +widths +word-spacing +wrap +writing-mode +x +x-height +x1 +x2 +xChannelSelector +xlink +xlink:actuate +xlink:arcrole +xlink:href +xlink:role +xlink:show +xlink:title +xlink:type +xml:base +xml:lang +xml:space +xmlns +xmlns:xlink +xmp +xor +xref +y +y1 +y2 +yChannelSelector +z +zoomAndPan diff --git a/examples/noop-tree-builder.rs b/examples/noop-tree-builder.rs index 006ed1a0..0860cb92 100644 --- a/examples/noop-tree-builder.rs +++ b/examples/noop-tree-builder.rs @@ -7,19 +7,18 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#[macro_use] -extern crate string_cache; -extern crate tendril; +#[macro_use] extern crate html5ever_atoms; extern crate html5ever; +extern crate tendril; use std::io; use std::default::Default; use std::collections::HashMap; use std::borrow::Cow; -use string_cache::QualName; use tendril::{StrTendril, TendrilSink}; +use html5ever::QualName; use html5ever::parse_document; use html5ever::tokenizer::Attribute; use html5ever::tree_builder::{TreeSink, QuirksMode, NodeOrText}; diff --git a/examples/print-rcdom.rs b/examples/print-rcdom.rs index 7b9a8738..e56872be 100644 --- a/examples/print-rcdom.rs +++ b/examples/print-rcdom.rs @@ -7,10 +7,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#[macro_use] extern crate html5ever_atoms; extern crate html5ever; - -#[macro_use] -extern crate string_cache; extern crate tendril; use std::io; diff --git a/examples/print-tree-actions.rs b/examples/print-tree-actions.rs index 19c37159..84d51d60 100644 --- a/examples/print-tree-actions.rs +++ b/examples/print-tree-actions.rs @@ -7,19 +7,18 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#[macro_use] -extern crate string_cache; -extern crate tendril; +#[macro_use] extern crate html5ever_atoms; extern crate html5ever; +extern crate tendril; use std::io; use std::default::Default; use std::collections::HashMap; use std::borrow::Cow; -use string_cache::QualName; use tendril::{StrTendril, TendrilSink}; +use html5ever::QualName; use html5ever::tokenizer::Attribute; use html5ever::tree_builder::{TreeSink, QuirksMode, NodeOrText, AppendNode, AppendText}; use html5ever::parse_document; diff --git a/macros/match_token.rs b/macros/match_token.rs index f72a1c1a..293e04c6 100644 --- a/macros/match_token.rs +++ b/macros/match_token.rs @@ -71,8 +71,8 @@ tag @ => ... expands to something like ```rust -TagToken(tag @ Tag { name: atom!("html"), kind: StartTag }) -| TagToken(tag @ Tag { name: atom!("head"), kind: StartTag }) => ... +TagToken(tag @ Tag { name: local_name!("html"), kind: StartTag }) +| TagToken(tag @ Tag { name: local_name!("head"), kind: StartTag }) => ... ``` A wildcard tag matches any tag of the appropriate kind, *unless* it was @@ -416,8 +416,8 @@ fn expand_match_token_macro(to_be_matched: &syn::Ident, mut arms: Vec) -> T // // last_arm_token => { // let enable_wildcards = match last_arm_token { - // TagToken(Tag { kind: EndTag, name: atom!("body"), .. }) => false, - // TagToken(Tag { kind: EndTag, name: atom!("html"), .. }) => false, + // TagToken(Tag { kind: EndTag, name: local_name!("body"), .. }) => false, + // TagToken(Tag { kind: EndTag, name: local_name!("html"), .. }) => false, // // ... // _ => true, // }; @@ -472,7 +472,7 @@ fn make_tag_pattern(binding: &Tokens, tag: Tag) -> Tokens { }; let name_field = if let Some(name) = tag.name { let name = name.to_string(); - quote!(name: atom!(#name),) + quote!(name: local_name!(#name),) } else { quote!() }; diff --git a/src/driver.rs b/src/driver.rs index 981b70bd..ba80d233 100644 --- a/src/driver.rs +++ b/src/driver.rs @@ -17,7 +17,7 @@ use std::borrow::Cow; use std::mem; use encoding::{self, EncodingRef}; -use string_cache::QualName; +use QualName; use tendril; use tendril::{StrTendril, ByteTendril}; use tendril::stream::{TendrilSink, Utf8LossyDecoder, LossyDecoder}; diff --git a/src/lib.rs b/src/lib.rs index bbf3041f..5d641969 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -22,13 +22,14 @@ extern crate heapsize; extern crate log; #[macro_use] -extern crate string_cache; +extern crate html5ever_atoms; #[macro_use] extern crate mac; extern crate phf; +pub use html5ever_atoms::{Namespace, LocalName, QualName}; pub use tokenizer::Attribute; pub use driver::{ParseOpts, parse_document, parse_fragment, Parser}; diff --git a/src/rcdom.rs b/src/rcdom.rs index 5ba8faf3..82dedec0 100644 --- a/src/rcdom.rs +++ b/src/rcdom.rs @@ -22,9 +22,9 @@ use std::mem; use std::ops::{Deref, DerefMut}; use std::rc::{Rc, Weak}; -use string_cache::QualName; use tendril::StrTendril; +use QualName; use tokenizer::Attribute; use tree_builder::{TreeSink, QuirksMode, NodeOrText, AppendNode, AppendText}; use tree_builder; diff --git a/src/serialize/mod.rs b/src/serialize/mod.rs index 0a76fba9..88736fce 100644 --- a/src/serialize/mod.rs +++ b/src/serialize/mod.rs @@ -10,7 +10,7 @@ use std::io::{self, Write}; use std::default::Default; -use string_cache::{Atom, QualName}; +use {LocalName, QualName}; //§ serializing-html-fragments #[derive(Copy, Clone, PartialEq)] @@ -50,7 +50,7 @@ impl Default for SerializeOpts { } struct ElemInfo { - html_name: Option, + html_name: Option, ignore_children: bool, processed_first_child: bool, } @@ -63,12 +63,12 @@ pub struct Serializer<'wr, Wr:'wr> { stack: Vec, } -fn tagname(name: &QualName) -> Atom { +fn tagname(name: &QualName) -> LocalName { match name.ns { ns!(html) | ns!(mathml) | ns!(svg) => (), ref ns => { // FIXME(#122) - warn!("node with weird namespace {:?}", &*ns.0); + warn!("node with weird namespace {:?}", ns); } } @@ -134,14 +134,14 @@ impl<'wr, Wr: Write> Serializer<'wr, Wr> { ns!() => (), ns!(xml) => try!(self.writer.write_all(b"xml:")), ns!(xmlns) => { - if name.local != atom!("xmlns") { + if name.local != local_name!("xmlns") { try!(self.writer.write_all(b"xmlns:")); } } ns!(xlink) => try!(self.writer.write_all(b"xlink:")), ref ns => { // FIXME(#122) - warn!("attr with weird namespace {:?}", &*ns.0); + warn!("attr with weird namespace {:?}", ns); try!(self.writer.write_all(b"unknown_namespace:")); } } @@ -154,10 +154,10 @@ impl<'wr, Wr: Write> Serializer<'wr, Wr> { try!(self.writer.write_all(b">")); let ignore_children = name.ns == ns!(html) && match name.local { - atom!("area") | atom!("base") | atom!("basefont") | atom!("bgsound") | atom!("br") - | atom!("col") | atom!("embed") | atom!("frame") | atom!("hr") | atom!("img") - | atom!("input") | atom!("keygen") | atom!("link") | atom!("menuitem") - | atom!("meta") | atom!("param") | atom!("source") | atom!("track") | atom!("wbr") + local_name!("area") | local_name!("base") | local_name!("basefont") | local_name!("bgsound") | local_name!("br") + | local_name!("col") | local_name!("embed") | local_name!("frame") | local_name!("hr") | local_name!("img") + | local_name!("input") | local_name!("keygen") | local_name!("link") | local_name!("menuitem") + | local_name!("meta") | local_name!("param") | local_name!("source") | local_name!("track") | local_name!("wbr") => true, _ => false, }; @@ -188,7 +188,7 @@ impl<'wr, Wr: Write> Serializer<'wr, Wr> { let prepend_lf = text.starts_with("\n") && { let parent = self.parent(); !parent.processed_first_child && match parent.html_name { - Some(atom!("pre")) | Some(atom!("textarea")) | Some(atom!("listing")) => true, + Some(local_name!("pre")) | Some(local_name!("textarea")) | Some(local_name!("listing")) => true, _ => false, } }; @@ -198,11 +198,11 @@ impl<'wr, Wr: Write> Serializer<'wr, Wr> { } let escape = match self.parent().html_name { - Some(atom!("style")) | Some(atom!("script")) | Some(atom!("xmp")) - | Some(atom!("iframe")) | Some(atom!("noembed")) | Some(atom!("noframes")) - | Some(atom!("plaintext")) => false, + Some(local_name!("style")) | Some(local_name!("script")) | Some(local_name!("xmp")) + | Some(local_name!("iframe")) | Some(local_name!("noembed")) | Some(local_name!("noframes")) + | Some(local_name!("plaintext")) => false, - Some(atom!("noscript")) => !self.opts.scripting_enabled, + Some(local_name!("noscript")) => !self.opts.scripting_enabled, _ => true, }; diff --git a/src/tokenizer/interface.rs b/src/tokenizer/interface.rs index ebb37b93..5b5084b0 100644 --- a/src/tokenizer/interface.rs +++ b/src/tokenizer/interface.rs @@ -11,7 +11,7 @@ use tokenizer::states; use std::borrow::Cow; -use string_cache::{Atom, QualName}; +use {LocalName, QualName}; use tendril::StrTendril; pub use self::TagKind::{StartTag, EndTag}; @@ -61,7 +61,7 @@ pub enum TagKind { #[derive(PartialEq, Eq, Clone, Debug)] pub struct Tag { pub kind: TagKind, - pub name: Atom, + pub name: LocalName, pub self_closing: bool, pub attrs: Vec, } diff --git a/src/tokenizer/mod.rs b/src/tokenizer/mod.rs index fdb7e267..5ad037f3 100644 --- a/src/tokenizer/mod.rs +++ b/src/tokenizer/mod.rs @@ -35,7 +35,7 @@ use std::default::Default; use std::borrow::Cow::{self, Borrowed}; use std::collections::BTreeMap; -use string_cache::{Atom, QualName}; +use {LocalName, QualName}; use tendril::StrTendril; pub mod buffer_queue; @@ -147,7 +147,7 @@ pub struct Tokenizer { current_doctype: Doctype, /// Last start tag name, for use in checking "appropriate end tag". - last_start_tag_name: Option, + last_start_tag_name: Option, /// The "temporary buffer" mentioned in the spec. temp_buf: StrTendril, @@ -163,7 +163,7 @@ impl Tokenizer { /// Create a new tokenizer which feeds tokens to a particular `TokenSink`. pub fn new(sink: Sink, mut opts: TokenizerOpts) -> Tokenizer { let start_tag_name = opts.last_start_tag_name.take() - .map(|s| Atom::from(&*s)); + .map(|s| LocalName::from(&*s)); let state = opts.initial_state.unwrap_or(states::Data); let discard_bom = opts.discard_bom; Tokenizer { @@ -382,7 +382,7 @@ impl Tokenizer { fn emit_current_tag(&mut self) -> bool { self.finish_attribute(); - let name = Atom::from(&*self.current_tag_name); + let name = LocalName::from(&*self.current_tag_name); self.current_tag_name.clear(); match self.current_tag_kind { @@ -484,7 +484,7 @@ impl Tokenizer { self.current_attr_name.clear(); self.current_attr_value.clear(); } else { - let name = Atom::from(&*self.current_attr_name); + let name = LocalName::from(&*self.current_attr_name); self.current_attr_name.clear(); self.current_tag_attrs.push(Attribute { // The tree builder will adjust the namespace if necessary. diff --git a/src/tree_builder/actions.rs b/src/tree_builder/actions.rs index edf49d49..6a2e0893 100644 --- a/src/tree_builder/actions.rs +++ b/src/tree_builder/actions.rs @@ -28,7 +28,7 @@ use std::mem::replace; use std::iter::{Rev, Enumerate}; use std::borrow::Cow::Borrowed; -use string_cache::{Atom, Namespace, QualName}; +use {LocalName, Namespace, QualName}; use tendril::StrTendril; pub use self::PushFlag::*; @@ -60,7 +60,7 @@ enum Bookmark { // These go in a trait so that we can control visibility. pub trait TreeBuilderActions { fn unexpected(&mut self, thing: &T) -> ProcessResult; - fn assert_named(&mut self, node: Handle, name: Atom); + fn assert_named(&mut self, node: Handle, name: LocalName); fn clear_active_formatting_to_marker(&mut self); fn create_formatting_element_for(&mut self, tag: Tag) -> Handle; fn append_text(&mut self, text: StrTendril) -> ProcessResult; @@ -68,10 +68,10 @@ pub trait TreeBuilderActions { fn append_comment_to_doc(&mut self, text: StrTendril) -> ProcessResult; fn append_comment_to_html(&mut self, text: StrTendril) -> ProcessResult; fn insert_appropriately(&mut self, child: NodeOrText, override_target: Option); - fn insert_phantom(&mut self, name: Atom) -> Handle; + fn insert_phantom(&mut self, name: LocalName) -> Handle; fn insert_and_pop_element_for(&mut self, tag: Tag) -> Handle; fn insert_element_for(&mut self, tag: Tag) -> Handle; - fn insert_element(&mut self, push: PushFlag, ns: Namespace, name: Atom, attrs: Vec) -> Handle; + fn insert_element(&mut self, push: PushFlag, ns: Namespace, name: LocalName, attrs: Vec) -> Handle; fn create_root(&mut self, attrs: Vec); fn close_the_cell(&mut self); fn reset_insertion_mode(&mut self) -> InsertionMode; @@ -80,16 +80,16 @@ pub trait TreeBuilderActions { fn is_type_hidden(&self, tag: &Tag) -> bool; fn close_p_element_in_button_scope(&mut self); fn close_p_element(&mut self); - fn expect_to_close(&mut self, name: Atom); - fn pop_until_named(&mut self, name: Atom) -> usize; + fn expect_to_close(&mut self, name: LocalName); + fn pop_until_named(&mut self, name: LocalName) -> usize; fn pop_until(&mut self, pred: TagSet) -> usize where TagSet: Fn(QualName) -> bool; fn pop_until_current(&mut self, pred: TagSet) where TagSet: Fn(QualName) -> bool; - fn generate_implied_end_except(&mut self, except: Atom); + fn generate_implied_end_except(&mut self, except: LocalName); fn generate_implied_end(&mut self, set: TagSet) where TagSet: Fn(QualName) -> bool; - fn in_scope_named(&self, scope: TagSet, name: Atom) -> bool where TagSet: Fn(QualName) -> bool; - fn current_node_named(&self, name: Atom) -> bool; - fn html_elem_named(&self, elem: Handle, name: Atom) -> bool; - fn in_html_elem_named(&self, name: Atom) -> bool; + fn in_scope_named(&self, scope: TagSet, name: LocalName) -> bool where TagSet: Fn(QualName) -> bool; + fn current_node_named(&self, name: LocalName) -> bool; + fn html_elem_named(&self, elem: Handle, name: LocalName) -> bool; + fn in_html_elem_named(&self, name: LocalName) -> bool; fn elem_in(&self, elem: Handle, set: TagSet) -> bool where TagSet: Fn(QualName) -> bool; fn in_scope(&self, scope: TagSet, pred: Pred) -> bool where TagSet: Fn(QualName) -> bool, Pred: Fn(Handle) -> bool; fn check_body_end(&mut self); @@ -99,7 +99,7 @@ pub trait TreeBuilderActions { fn remove_from_stack(&mut self, elem: &Handle); fn pop(&mut self) -> Handle; fn push(&mut self, elem: &Handle); - fn adoption_agency(&mut self, subject: Atom); + fn adoption_agency(&mut self, subject: LocalName); fn current_node_in(&self, set: TagSet) -> bool where TagSet: Fn(QualName) -> bool; fn current_node(&self) -> Handle; fn adjusted_current_node(&self) -> Handle; @@ -115,7 +115,7 @@ pub trait TreeBuilderActions { fn is_foreign(&mut self, token: &Token) -> bool; fn enter_foreign(&mut self, tag: Tag, ns: Namespace) -> ProcessResult; fn adjust_attributes(&mut self, tag: &mut Tag, mut map: F) - where F: FnMut(Atom) -> Option; + where F: FnMut(LocalName) -> Option; fn adjust_svg_tag_name(&mut self, tag: &mut Tag); fn adjust_svg_attributes(&mut self, tag: &mut Tag); fn adjust_mathml_attributes(&mut self, tag: &mut Tag); @@ -138,7 +138,7 @@ impl TreeBuilderActions Done } - fn assert_named(&mut self, node: Handle, name: Atom) { + fn assert_named(&mut self, node: Handle, name: LocalName) { assert!(self.html_elem_named(node, name)); } @@ -214,7 +214,7 @@ impl TreeBuilderActions declare_tag_set!(foster_target = "table" "tbody" "tfoot" "thead" "tr"); let target = override_target.unwrap_or_else(|| self.current_node()); if !(self.foster_parenting && self.elem_in(target.clone(), foster_target)) { - if self.html_elem_named(target.clone(), atom!("template")) { + if self.html_elem_named(target.clone(), local_name!("template")) { // No foster parenting (inside template). let contents = self.sink.get_template_contents(target); self.sink.append(contents, child); @@ -228,11 +228,11 @@ impl TreeBuilderActions // Foster parenting let mut iter = self.open_elems.iter().rev().peekable(); while let Some(elem) = iter.next() { - if self.html_elem_named(elem.clone(), atom!("template")) { + if self.html_elem_named(elem.clone(), local_name!("template")) { let contents = self.sink.get_template_contents(elem.clone()); self.sink.append(contents, child); return; - } else if self.html_elem_named(elem.clone(), atom!("table")) { + } else if self.html_elem_named(elem.clone(), local_name!("table")) { // Try inserting "inside last table's parent node, immediately before last table" if let Err(child) = self.sink.append_before_sibling(elem.clone(), child) { // If last_table has no parent, we regain ownership of the child. @@ -247,7 +247,7 @@ impl TreeBuilderActions self.sink.append(html_elem, child); } - fn adoption_agency(&mut self, subject: Atom) { + fn adoption_agency(&mut self, subject: LocalName) { // 1. if self.current_node_named(subject.clone()) { if self.position_in_active_formatting(&self.current_node()).is_none() { @@ -511,7 +511,7 @@ impl TreeBuilderActions } let node = self.open_elems[1].clone(); - if self.html_elem_named(node.clone(), atom!("body")) { + if self.html_elem_named(node.clone(), local_name!("body")) { Some(node) } else { None @@ -561,19 +561,19 @@ impl TreeBuilderActions set(self.sink.elem_name(elem)) } - fn html_elem_named(&self, elem: Handle, name: Atom) -> bool { + fn html_elem_named(&self, elem: Handle, name: LocalName) -> bool { self.sink.elem_name(elem) == QualName::new(ns!(html), name) } - fn in_html_elem_named(&self, name: Atom) -> bool { + fn in_html_elem_named(&self, name: LocalName) -> bool { self.open_elems.iter().any(|elem| self.html_elem_named(elem.clone(), name.clone())) } - fn current_node_named(&self, name: Atom) -> bool { + fn current_node_named(&self, name: LocalName) -> bool { self.html_elem_named(self.current_node(), name) } - fn in_scope_named(&self, scope: TagSet, name: Atom) -> bool + fn in_scope_named(&self, scope: TagSet, name: LocalName) -> bool where TagSet: Fn(QualName) -> bool { self.in_scope(scope, |elem| @@ -592,7 +592,7 @@ impl TreeBuilderActions } } - fn generate_implied_end_except(&mut self, except: Atom) { + fn generate_implied_end_except(&mut self, except: LocalName) { self.generate_implied_end(|p| match p { QualName { ns: ns!(html), ref local } if *local == except => false, _ => cursory_implied_end(p), @@ -628,13 +628,13 @@ impl TreeBuilderActions n } - fn pop_until_named(&mut self, name: Atom) -> usize { + fn pop_until_named(&mut self, name: LocalName) -> usize { self.pop_until(|p| p == QualName::new(ns!(html), name.clone())) } // Pop elements until one with the specified name has been popped. // Signal an error if it was not the first one. - fn expect_to_close(&mut self, name: Atom) { + fn expect_to_close(&mut self, name: LocalName) { if self.pop_until_named(name.clone()) != 1 { self.sink.parse_error(format_if!(self.opts.exact_errors, "Unexpected open element", @@ -645,11 +645,11 @@ impl TreeBuilderActions fn close_p_element(&mut self) { declare_tag_set!(implied = [cursory_implied_end] - "p"); self.generate_implied_end(implied); - self.expect_to_close(atom!("p")); + self.expect_to_close(local_name!("p")); } fn close_p_element_in_button_scope(&mut self) { - if self.in_scope_named(button_scope, atom!("p")) { + if self.in_scope_named(button_scope, local_name!("p")) { self.close_p_element(); } } @@ -697,27 +697,27 @@ impl TreeBuilderActions _ => continue, }; match name { - atom!("select") => { + local_name!("select") => { for ancestor in self.open_elems[0..i].iter().rev() { - if self.html_elem_named(ancestor.clone(), atom!("template")) { + if self.html_elem_named(ancestor.clone(), local_name!("template")) { return InSelect; - } else if self.html_elem_named(ancestor.clone(), atom!("table")) { + } else if self.html_elem_named(ancestor.clone(), local_name!("table")) { return InSelectInTable; } } return InSelect; }, - atom!("td") | atom!("th") => if !last { return InCell; }, - atom!("tr") => return InRow, - atom!("tbody") | atom!("thead") | atom!("tfoot") => return InTableBody, - atom!("caption") => return InCaption, - atom!("colgroup") => return InColumnGroup, - atom!("table") => return InTable, - atom!("template") => return *self.template_modes.last().unwrap(), - atom!("head") => if !last { return InHead }, - atom!("body") => return InBody, - atom!("frameset") => return InFrameset, - atom!("html") => match self.head_elem { + local_name!("td") | local_name!("th") => if !last { return InCell; }, + local_name!("tr") => return InRow, + local_name!("tbody") | local_name!("thead") | local_name!("tfoot") => return InTableBody, + local_name!("caption") => return InCaption, + local_name!("colgroup") => return InColumnGroup, + local_name!("table") => return InTable, + local_name!("template") => return *self.template_modes.last().unwrap(), + local_name!("head") => if !last { return InHead }, + local_name!("body") => return InBody, + local_name!("frameset") => return InFrameset, + local_name!("html") => match self.head_elem { None => return BeforeHead, Some(_) => return AfterHead, }, @@ -769,7 +769,7 @@ impl TreeBuilderActions // FIXME: application cache selection algorithm } - fn insert_element(&mut self, push: PushFlag, ns: Namespace, name: Atom, attrs: Vec) + fn insert_element(&mut self, push: PushFlag, ns: Namespace, name: LocalName, attrs: Vec) -> Handle { let elem = self.sink.create_element(QualName::new(ns, name), attrs); self.insert_appropriately(AppendNode(elem.clone()), None); @@ -789,7 +789,7 @@ impl TreeBuilderActions self.insert_element(NoPush, ns!(html), tag.name, tag.attrs) } - fn insert_phantom(&mut self, name: Atom) -> Handle { + fn insert_phantom(&mut self, name: LocalName) -> Handle { self.insert_element(Push, ns!(html), name, vec!()) } //§ END @@ -861,7 +861,7 @@ impl TreeBuilderActions fn handle_misnested_a_tags(&mut self, tag: &Tag) { let node = unwrap_or_return!( self.active_formatting_end_to_marker() - .filter(|&(_, n, _)| self.html_elem_named(n.clone(), atom!("a"))) + .filter(|&(_, n, _)| self.html_elem_named(n.clone(), local_name!("a"))) .next() .map(|(_, n, _)| n.clone()), @@ -869,7 +869,7 @@ impl TreeBuilderActions ); self.unexpected(tag); - self.adoption_agency(atom!("a")); + self.adoption_agency(local_name!("a")); self.position_in_active_formatting(&node) .map(|index| self.active_formatting.remove(index)); self.remove_from_stack(&node); @@ -894,7 +894,7 @@ impl TreeBuilderActions match *token { CharacterTokens(..) | NullCharacterToken => return false, TagToken(Tag { kind: StartTag, ref name, .. }) - if !matches!(*name, atom!("mglyph") | atom!("malignmark")) => return false, + if !matches!(*name, local_name!("mglyph") | local_name!("malignmark")) => return false, _ => (), } } @@ -909,7 +909,7 @@ impl TreeBuilderActions if let qualname!(mathml, "annotation-xml") = name { match *token { - TagToken(Tag { kind: StartTag, name: atom!("svg"), .. }) => return false, + TagToken(Tag { kind: StartTag, name: local_name!("svg"), .. }) => return false, CharacterTokens(..) | NullCharacterToken | TagToken(Tag { kind: StartTag, .. }) => { return !self.sink.is_mathml_annotation_xml_integration_point(self.adjusted_current_node()) @@ -942,49 +942,49 @@ impl TreeBuilderActions fn adjust_svg_tag_name(&mut self, tag: &mut Tag) { let Tag { ref mut name, .. } = *tag; match *name { - atom!("altglyph") => *name = atom!("altGlyph"), - atom!("altglyphdef") => *name = atom!("altGlyphDef"), - atom!("altglyphitem") => *name = atom!("altGlyphItem"), - atom!("animatecolor") => *name = atom!("animateColor"), - atom!("animatemotion") => *name = atom!("animateMotion"), - atom!("animatetransform") => *name = atom!("animateTransform"), - atom!("clippath") => *name = atom!("clipPath"), - atom!("feblend") => *name = atom!("feBlend"), - atom!("fecolormatrix") => *name = atom!("feColorMatrix"), - atom!("fecomponenttransfer") => *name = atom!("feComponentTransfer"), - atom!("fecomposite") => *name = atom!("feComposite"), - atom!("feconvolvematrix") => *name = atom!("feConvolveMatrix"), - atom!("fediffuselighting") => *name = atom!("feDiffuseLighting"), - atom!("fedisplacementmap") => *name = atom!("feDisplacementMap"), - atom!("fedistantlight") => *name = atom!("feDistantLight"), - atom!("fedropshadow") => *name = atom!("feDropShadow"), - atom!("feflood") => *name = atom!("feFlood"), - atom!("fefunca") => *name = atom!("feFuncA"), - atom!("fefuncb") => *name = atom!("feFuncB"), - atom!("fefuncg") => *name = atom!("feFuncG"), - atom!("fefuncr") => *name = atom!("feFuncR"), - atom!("fegaussianblur") => *name = atom!("feGaussianBlur"), - atom!("feimage") => *name = atom!("feImage"), - atom!("femerge") => *name = atom!("feMerge"), - atom!("femergenode") => *name = atom!("feMergeNode"), - atom!("femorphology") => *name = atom!("feMorphology"), - atom!("feoffset") => *name = atom!("feOffset"), - atom!("fepointlight") => *name = atom!("fePointLight"), - atom!("fespecularlighting") => *name = atom!("feSpecularLighting"), - atom!("fespotlight") => *name = atom!("feSpotLight"), - atom!("fetile") => *name = atom!("feTile"), - atom!("feturbulence") => *name = atom!("feTurbulence"), - atom!("foreignobject") => *name = atom!("foreignObject"), - atom!("glyphref") => *name = atom!("glyphRef"), - atom!("lineargradient") => *name = atom!("linearGradient"), - atom!("radialgradient") => *name = atom!("radialGradient"), - atom!("textpath") => *name = atom!("textPath"), + local_name!("altglyph") => *name = local_name!("altGlyph"), + local_name!("altglyphdef") => *name = local_name!("altGlyphDef"), + local_name!("altglyphitem") => *name = local_name!("altGlyphItem"), + local_name!("animatecolor") => *name = local_name!("animateColor"), + local_name!("animatemotion") => *name = local_name!("animateMotion"), + local_name!("animatetransform") => *name = local_name!("animateTransform"), + local_name!("clippath") => *name = local_name!("clipPath"), + local_name!("feblend") => *name = local_name!("feBlend"), + local_name!("fecolormatrix") => *name = local_name!("feColorMatrix"), + local_name!("fecomponenttransfer") => *name = local_name!("feComponentTransfer"), + local_name!("fecomposite") => *name = local_name!("feComposite"), + local_name!("feconvolvematrix") => *name = local_name!("feConvolveMatrix"), + local_name!("fediffuselighting") => *name = local_name!("feDiffuseLighting"), + local_name!("fedisplacementmap") => *name = local_name!("feDisplacementMap"), + local_name!("fedistantlight") => *name = local_name!("feDistantLight"), + local_name!("fedropshadow") => *name = local_name!("feDropShadow"), + local_name!("feflood") => *name = local_name!("feFlood"), + local_name!("fefunca") => *name = local_name!("feFuncA"), + local_name!("fefuncb") => *name = local_name!("feFuncB"), + local_name!("fefuncg") => *name = local_name!("feFuncG"), + local_name!("fefuncr") => *name = local_name!("feFuncR"), + local_name!("fegaussianblur") => *name = local_name!("feGaussianBlur"), + local_name!("feimage") => *name = local_name!("feImage"), + local_name!("femerge") => *name = local_name!("feMerge"), + local_name!("femergenode") => *name = local_name!("feMergeNode"), + local_name!("femorphology") => *name = local_name!("feMorphology"), + local_name!("feoffset") => *name = local_name!("feOffset"), + local_name!("fepointlight") => *name = local_name!("fePointLight"), + local_name!("fespecularlighting") => *name = local_name!("feSpecularLighting"), + local_name!("fespotlight") => *name = local_name!("feSpotLight"), + local_name!("fetile") => *name = local_name!("feTile"), + local_name!("feturbulence") => *name = local_name!("feTurbulence"), + local_name!("foreignobject") => *name = local_name!("foreignObject"), + local_name!("glyphref") => *name = local_name!("glyphRef"), + local_name!("lineargradient") => *name = local_name!("linearGradient"), + local_name!("radialgradient") => *name = local_name!("radialGradient"), + local_name!("textpath") => *name = local_name!("textPath"), _ => (), } } fn adjust_attributes(&mut self, tag: &mut Tag, mut map: F) - where F: FnMut(Atom) -> Option, + where F: FnMut(LocalName) -> Option, { for &mut Attribute { ref mut name, .. } in &mut tag.attrs { if let Some(replacement) = map(name.local.clone()) { @@ -995,89 +995,89 @@ impl TreeBuilderActions fn adjust_svg_attributes(&mut self, tag: &mut Tag) { self.adjust_attributes(tag, |k| match k { - atom!("attributename") => Some(qualname!("", "attributeName")), - atom!("attributetype") => Some(qualname!("", "attributeType")), - atom!("basefrequency") => Some(qualname!("", "baseFrequency")), - atom!("baseprofile") => Some(qualname!("", "baseProfile")), - atom!("calcmode") => Some(qualname!("", "calcMode")), - atom!("clippathunits") => Some(qualname!("", "clipPathUnits")), - atom!("diffuseconstant") => Some(qualname!("", "diffuseConstant")), - atom!("edgemode") => Some(qualname!("", "edgeMode")), - atom!("filterunits") => Some(qualname!("", "filterUnits")), - atom!("glyphref") => Some(qualname!("", "glyphRef")), - atom!("gradienttransform") => Some(qualname!("", "gradientTransform")), - atom!("gradientunits") => Some(qualname!("", "gradientUnits")), - atom!("kernelmatrix") => Some(qualname!("", "kernelMatrix")), - atom!("kernelunitlength") => Some(qualname!("", "kernelUnitLength")), - atom!("keypoints") => Some(qualname!("", "keyPoints")), - atom!("keysplines") => Some(qualname!("", "keySplines")), - atom!("keytimes") => Some(qualname!("", "keyTimes")), - atom!("lengthadjust") => Some(qualname!("", "lengthAdjust")), - atom!("limitingconeangle") => Some(qualname!("", "limitingConeAngle")), - atom!("markerheight") => Some(qualname!("", "markerHeight")), - atom!("markerunits") => Some(qualname!("", "markerUnits")), - atom!("markerwidth") => Some(qualname!("", "markerWidth")), - atom!("maskcontentunits") => Some(qualname!("", "maskContentUnits")), - atom!("maskunits") => Some(qualname!("", "maskUnits")), - atom!("numoctaves") => Some(qualname!("", "numOctaves")), - atom!("pathlength") => Some(qualname!("", "pathLength")), - atom!("patterncontentunits") => Some(qualname!("", "patternContentUnits")), - atom!("patterntransform") => Some(qualname!("", "patternTransform")), - atom!("patternunits") => Some(qualname!("", "patternUnits")), - atom!("pointsatx") => Some(qualname!("", "pointsAtX")), - atom!("pointsaty") => Some(qualname!("", "pointsAtY")), - atom!("pointsatz") => Some(qualname!("", "pointsAtZ")), - atom!("preservealpha") => Some(qualname!("", "preserveAlpha")), - atom!("preserveaspectratio") => Some(qualname!("", "preserveAspectRatio")), - atom!("primitiveunits") => Some(qualname!("", "primitiveUnits")), - atom!("refx") => Some(qualname!("", "refX")), - atom!("refy") => Some(qualname!("", "refY")), - atom!("repeatcount") => Some(qualname!("", "repeatCount")), - atom!("repeatdur") => Some(qualname!("", "repeatDur")), - atom!("requiredextensions") => Some(qualname!("", "requiredExtensions")), - atom!("requiredfeatures") => Some(qualname!("", "requiredFeatures")), - atom!("specularconstant") => Some(qualname!("", "specularConstant")), - atom!("specularexponent") => Some(qualname!("", "specularExponent")), - atom!("spreadmethod") => Some(qualname!("", "spreadMethod")), - atom!("startoffset") => Some(qualname!("", "startOffset")), - atom!("stddeviation") => Some(qualname!("", "stdDeviation")), - atom!("stitchtiles") => Some(qualname!("", "stitchTiles")), - atom!("surfacescale") => Some(qualname!("", "surfaceScale")), - atom!("systemlanguage") => Some(qualname!("", "systemLanguage")), - atom!("tablevalues") => Some(qualname!("", "tableValues")), - atom!("targetx") => Some(qualname!("", "targetX")), - atom!("targety") => Some(qualname!("", "targetY")), - atom!("textlength") => Some(qualname!("", "textLength")), - atom!("viewbox") => Some(qualname!("", "viewBox")), - atom!("viewtarget") => Some(qualname!("", "viewTarget")), - atom!("xchannelselector") => Some(qualname!("", "xChannelSelector")), - atom!("ychannelselector") => Some(qualname!("", "yChannelSelector")), - atom!("zoomandpan") => Some(qualname!("", "zoomAndPan")), + local_name!("attributename") => Some(qualname!("", "attributeName")), + local_name!("attributetype") => Some(qualname!("", "attributeType")), + local_name!("basefrequency") => Some(qualname!("", "baseFrequency")), + local_name!("baseprofile") => Some(qualname!("", "baseProfile")), + local_name!("calcmode") => Some(qualname!("", "calcMode")), + local_name!("clippathunits") => Some(qualname!("", "clipPathUnits")), + local_name!("diffuseconstant") => Some(qualname!("", "diffuseConstant")), + local_name!("edgemode") => Some(qualname!("", "edgeMode")), + local_name!("filterunits") => Some(qualname!("", "filterUnits")), + local_name!("glyphref") => Some(qualname!("", "glyphRef")), + local_name!("gradienttransform") => Some(qualname!("", "gradientTransform")), + local_name!("gradientunits") => Some(qualname!("", "gradientUnits")), + local_name!("kernelmatrix") => Some(qualname!("", "kernelMatrix")), + local_name!("kernelunitlength") => Some(qualname!("", "kernelUnitLength")), + local_name!("keypoints") => Some(qualname!("", "keyPoints")), + local_name!("keysplines") => Some(qualname!("", "keySplines")), + local_name!("keytimes") => Some(qualname!("", "keyTimes")), + local_name!("lengthadjust") => Some(qualname!("", "lengthAdjust")), + local_name!("limitingconeangle") => Some(qualname!("", "limitingConeAngle")), + local_name!("markerheight") => Some(qualname!("", "markerHeight")), + local_name!("markerunits") => Some(qualname!("", "markerUnits")), + local_name!("markerwidth") => Some(qualname!("", "markerWidth")), + local_name!("maskcontentunits") => Some(qualname!("", "maskContentUnits")), + local_name!("maskunits") => Some(qualname!("", "maskUnits")), + local_name!("numoctaves") => Some(qualname!("", "numOctaves")), + local_name!("pathlength") => Some(qualname!("", "pathLength")), + local_name!("patterncontentunits") => Some(qualname!("", "patternContentUnits")), + local_name!("patterntransform") => Some(qualname!("", "patternTransform")), + local_name!("patternunits") => Some(qualname!("", "patternUnits")), + local_name!("pointsatx") => Some(qualname!("", "pointsAtX")), + local_name!("pointsaty") => Some(qualname!("", "pointsAtY")), + local_name!("pointsatz") => Some(qualname!("", "pointsAtZ")), + local_name!("preservealpha") => Some(qualname!("", "preserveAlpha")), + local_name!("preserveaspectratio") => Some(qualname!("", "preserveAspectRatio")), + local_name!("primitiveunits") => Some(qualname!("", "primitiveUnits")), + local_name!("refx") => Some(qualname!("", "refX")), + local_name!("refy") => Some(qualname!("", "refY")), + local_name!("repeatcount") => Some(qualname!("", "repeatCount")), + local_name!("repeatdur") => Some(qualname!("", "repeatDur")), + local_name!("requiredextensions") => Some(qualname!("", "requiredExtensions")), + local_name!("requiredfeatures") => Some(qualname!("", "requiredFeatures")), + local_name!("specularconstant") => Some(qualname!("", "specularConstant")), + local_name!("specularexponent") => Some(qualname!("", "specularExponent")), + local_name!("spreadmethod") => Some(qualname!("", "spreadMethod")), + local_name!("startoffset") => Some(qualname!("", "startOffset")), + local_name!("stddeviation") => Some(qualname!("", "stdDeviation")), + local_name!("stitchtiles") => Some(qualname!("", "stitchTiles")), + local_name!("surfacescale") => Some(qualname!("", "surfaceScale")), + local_name!("systemlanguage") => Some(qualname!("", "systemLanguage")), + local_name!("tablevalues") => Some(qualname!("", "tableValues")), + local_name!("targetx") => Some(qualname!("", "targetX")), + local_name!("targety") => Some(qualname!("", "targetY")), + local_name!("textlength") => Some(qualname!("", "textLength")), + local_name!("viewbox") => Some(qualname!("", "viewBox")), + local_name!("viewtarget") => Some(qualname!("", "viewTarget")), + local_name!("xchannelselector") => Some(qualname!("", "xChannelSelector")), + local_name!("ychannelselector") => Some(qualname!("", "yChannelSelector")), + local_name!("zoomandpan") => Some(qualname!("", "zoomAndPan")), _ => None, }); } fn adjust_mathml_attributes(&mut self, tag: &mut Tag) { self.adjust_attributes(tag, |k| match k { - atom!("definitionurl") => Some(qualname!("", "definitionURL")), + local_name!("definitionurl") => Some(qualname!("", "definitionURL")), _ => None, }); } fn adjust_foreign_attributes(&mut self, tag: &mut Tag) { self.adjust_attributes(tag, |k| match k { - atom!("xlink:actuate") => Some(qualname!(xlink, "actuate")), - atom!("xlink:arcrole") => Some(qualname!(xlink, "arcrole")), - atom!("xlink:href") => Some(qualname!(xlink, "href")), - atom!("xlink:role") => Some(qualname!(xlink, "role")), - atom!("xlink:show") => Some(qualname!(xlink, "show")), - atom!("xlink:title") => Some(qualname!(xlink, "title")), - atom!("xlink:type") => Some(qualname!(xlink, "type")), - atom!("xml:base") => Some(qualname!(xml, "base")), - atom!("xml:lang") => Some(qualname!(xml, "lang")), - atom!("xml:space") => Some(qualname!(xml, "space")), - atom!("xmlns") => Some(qualname!(xmlns, "xmlns")), - atom!("xmlns:xlink") => Some(qualname!(xmlns, "xlink")), + local_name!("xlink:actuate") => Some(qualname!(xlink, "actuate")), + local_name!("xlink:arcrole") => Some(qualname!(xlink, "arcrole")), + local_name!("xlink:href") => Some(qualname!(xlink, "href")), + local_name!("xlink:role") => Some(qualname!(xlink, "role")), + local_name!("xlink:show") => Some(qualname!(xlink, "show")), + local_name!("xlink:title") => Some(qualname!(xlink, "title")), + local_name!("xlink:type") => Some(qualname!(xlink, "type")), + local_name!("xml:base") => Some(qualname!(xml, "base")), + local_name!("xml:lang") => Some(qualname!(xml, "lang")), + local_name!("xml:space") => Some(qualname!(xml, "space")), + local_name!("xmlns") => Some(qualname!(xmlns, "xmlns")), + local_name!("xmlns:xlink") => Some(qualname!(xmlns, "xlink")), _ => None, }); } diff --git a/src/tree_builder/interface.rs b/src/tree_builder/interface.rs index 735d7adf..0a729a2f 100644 --- a/src/tree_builder/interface.rs +++ b/src/tree_builder/interface.rs @@ -14,7 +14,7 @@ use tokenizer::Attribute; use std::borrow::Cow; -use string_cache::QualName; +use QualName; use tendril::StrTendril; pub use self::QuirksMode::{Quirks, LimitedQuirks, NoQuirks}; diff --git a/src/tree_builder/mod.rs b/src/tree_builder/mod.rs index 0272ba16..cb036b3e 100644 --- a/src/tree_builder/mod.rs +++ b/src/tree_builder/mod.rs @@ -19,7 +19,7 @@ use self::types::*; use self::actions::TreeBuilderActions; use self::rules::TreeBuilderStep; -use string_cache::QualName; +use QualName; use tendril::StrTendril; use tokenizer; @@ -226,20 +226,20 @@ impl TreeBuilder _ => return tok_state::Data }; match name { - atom!("title") | atom!("textarea") => tok_state::RawData(tok_state::Rcdata), + local_name!("title") | local_name!("textarea") => tok_state::RawData(tok_state::Rcdata), - atom!("style") | atom!("xmp") | atom!("iframe") - | atom!("noembed") | atom!("noframes") => tok_state::RawData(tok_state::Rawtext), + local_name!("style") | local_name!("xmp") | local_name!("iframe") + | local_name!("noembed") | local_name!("noframes") => tok_state::RawData(tok_state::Rawtext), - atom!("script") => tok_state::RawData(tok_state::ScriptData), + local_name!("script") => tok_state::RawData(tok_state::ScriptData), - atom!("noscript") => if self.opts.scripting_enabled { + local_name!("noscript") => if self.opts.scripting_enabled { tok_state::RawData(tok_state::Rawtext) } else { tok_state::Data }, - atom!("plaintext") => tok_state::Plaintext, + local_name!("plaintext") => tok_state::Plaintext, _ => tok_state::Data } @@ -277,8 +277,6 @@ impl TreeBuilder #[allow(dead_code)] fn dump_state(&self, label: String) { - use string_cache::QualName; - println!("dump_state on {}", label); print!(" open_elems:"); for node in self.open_elems.iter() { diff --git a/src/tree_builder/rules.rs b/src/tree_builder/rules.rs index acfa2a2a..daab070b 100644 --- a/src/tree_builder/rules.rs +++ b/src/tree_builder/rules.rs @@ -17,6 +17,7 @@ use tree_builder::interface::{TreeSink, Quirks, AppendNode, NextParserState}; use tokenizer::{Attribute, EndTag, StartTag, StateChangeQuery, Tag}; use tokenizer::states::{Rcdata, Rawtext, ScriptData, Plaintext}; +use QualName; use util::str::is_ascii_whitespace; use std::ascii::AsciiExt; @@ -102,7 +103,7 @@ impl TreeBuilderStep tag @ => self.unexpected(&tag), token => { - self.head_elem = Some(self.insert_phantom(atom!("head"))); + self.head_elem = Some(self.insert_phantom(local_name!("head"))); Reprocess(InHead, token) } }), @@ -127,7 +128,7 @@ impl TreeBuilderStep } tag @ <style> <noscript> => { - if (!self.opts.scripting_enabled) && (tag.name == atom!("noscript")) { + if (!self.opts.scripting_enabled) && (tag.name == local_name!("noscript")) { self.insert_element_for(tag); self.mode = InHeadNoscript; } else { @@ -165,11 +166,11 @@ impl<Handle, Sink> TreeBuilderStep } tag @ </template> => { - if !self.in_html_elem_named(atom!("template")) { + if !self.in_html_elem_named(local_name!("template")) { self.unexpected(&tag); } else { self.generate_implied_end(thorough_implied_end); - self.expect_to_close(atom!("template")); + self.expect_to_close(local_name!("template")); self.clear_active_formatting_to_marker(); self.template_modes.pop(); self.mode = self.reset_insertion_mode(); @@ -255,7 +256,7 @@ impl<Handle, Sink> TreeBuilderStep tag @ </_> => self.unexpected(&tag), token => { - self.insert_phantom(atom!("body")); + self.insert_phantom(local_name!("body")); Reprocess(InBody, token) } }), @@ -276,7 +277,7 @@ impl<Handle, Sink> TreeBuilderStep tag @ <html> => { self.unexpected(&tag); - if !self.in_html_elem_named(atom!("template")) { + if !self.in_html_elem_named(local_name!("template")) { let top = self.html_elem(); self.sink.add_attrs_if_missing(top, tag.attrs); } @@ -292,7 +293,7 @@ impl<Handle, Sink> TreeBuilderStep self.unexpected(&tag); match self.body_elem() { Some(ref node) if self.open_elems.len() != 1 && - !self.in_html_elem_named(atom!("template")) => { + !self.in_html_elem_named(local_name!("template")) => { self.frameset_ok = false; self.sink.add_attrs_if_missing(node.clone(), tag.attrs) }, @@ -330,7 +331,7 @@ impl<Handle, Sink> TreeBuilderStep } </body> => { - if self.in_scope_named(default_scope, atom!("body")) { + if self.in_scope_named(default_scope, local_name!("body")) { self.check_body_end(); self.mode = AfterBody; } else { @@ -340,7 +341,7 @@ impl<Handle, Sink> TreeBuilderStep } </html> => { - if self.in_scope_named(default_scope, atom!("body")) { + if self.in_scope_named(default_scope, local_name!("body")) { self.check_body_end(); Reprocess(AfterBody, token) } else { @@ -359,7 +360,7 @@ impl<Handle, Sink> TreeBuilderStep tag @ <menu> => { self.close_p_element_in_button_scope(); - if self.current_node_named(atom!("menuitem")) { + if self.current_node_named(local_name!("menuitem")) { self.pop(); } self.insert_element_for(tag); @@ -386,12 +387,12 @@ impl<Handle, Sink> TreeBuilderStep tag @ <form> => { if self.form_elem.is_some() && - !self.in_html_elem_named(atom!("template")) { + !self.in_html_elem_named(local_name!("template")) { self.sink.parse_error(Borrowed("nested forms")); } else { self.close_p_element_in_button_scope(); let elem = self.insert_element_for(tag); - if !self.in_html_elem_named(atom!("template")) { + if !self.in_html_elem_named(local_name!("template")) { self.form_elem = Some(elem); } } @@ -402,9 +403,9 @@ impl<Handle, Sink> TreeBuilderStep declare_tag_set!(close_list = "li"); declare_tag_set!(close_defn = "dd" "dt"); declare_tag_set!(extra_special = [special_tag] - "address" "div" "p"); - let can_close: fn(::string_cache::QualName) -> bool = match tag.name { - atom!("li") => close_list, - atom!("dd") | atom!("dt") => close_defn, + let can_close: fn(QualName) -> bool = match tag.name { + local_name!("li") => close_list, + local_name!("dd") | local_name!("dt") => close_defn, _ => unreachable!(), }; @@ -443,10 +444,10 @@ impl<Handle, Sink> TreeBuilderStep } tag @ <button> => { - if self.in_scope_named(default_scope, atom!("button")) { + if self.in_scope_named(default_scope, local_name!("button")) { self.sink.parse_error(Borrowed("nested buttons")); self.generate_implied_end(cursory_implied_end); - self.pop_until_named(atom!("button")); + self.pop_until_named(local_name!("button")); } self.reconstruct_formatting(); self.insert_element_for(tag); @@ -468,7 +469,7 @@ impl<Handle, Sink> TreeBuilderStep } </form> => { - if !self.in_html_elem_named(atom!("template")) { + if !self.in_html_elem_named(local_name!("template")) { // Can't use unwrap_or_return!() due to rust-lang/rust#16617. let node = match self.form_elem.take() { None => { @@ -488,31 +489,31 @@ impl<Handle, Sink> TreeBuilderStep self.sink.parse_error(Borrowed("Bad open element on </form>")); } } else { - if !self.in_scope_named(default_scope, atom!("form")) { + if !self.in_scope_named(default_scope, local_name!("form")) { self.sink.parse_error(Borrowed("Form element not in scope on </form>")); return Done; } self.generate_implied_end(cursory_implied_end); - if !self.current_node_named(atom!("form")) { + if !self.current_node_named(local_name!("form")) { self.sink.parse_error(Borrowed("Bad open element on </form>")); } - self.pop_until_named(atom!("form")); + self.pop_until_named(local_name!("form")); } Done } </p> => { - if !self.in_scope_named(button_scope, atom!("p")) { + if !self.in_scope_named(button_scope, local_name!("p")) { self.sink.parse_error(Borrowed("No <p> tag to close")); - self.insert_phantom(atom!("p")); + self.insert_phantom(local_name!("p")); } self.close_p_element(); Done } tag @ </li> </dd> </dt> => { - let scope: fn(::string_cache::QualName) -> bool = match tag.name { - atom!("li") => list_item_scope, + let scope: fn(QualName) -> bool = match tag.name { + local_name!("li") => list_item_scope, _ => default_scope, }; if self.in_scope_named(|x| scope(x), tag.name.clone()) { @@ -552,9 +553,9 @@ impl<Handle, Sink> TreeBuilderStep tag @ <nobr> => { self.reconstruct_formatting(); - if self.in_scope_named(default_scope, atom!("nobr")) { + if self.in_scope_named(default_scope, local_name!("nobr")) { self.sink.parse_error(Borrowed("Nested <nobr>")); - self.adoption_agency(atom!("nobr")); + self.adoption_agency(local_name!("nobr")); self.reconstruct_formatting(); } self.create_formatting_element_for(tag); @@ -607,7 +608,7 @@ impl<Handle, Sink> TreeBuilderStep tag @ <area> <br> <embed> <img> <keygen> <wbr> <input> => { let keep_frameset_ok = match tag.name { - atom!("input") => self.is_type_hidden(&tag), + local_name!("input") => self.is_type_hidden(&tag), _ => false, }; self.reconstruct_formatting(); @@ -625,7 +626,7 @@ impl<Handle, Sink> TreeBuilderStep tag @ <hr> => { self.close_p_element_in_button_scope(); - if self.current_node_named(atom!("menuitem")) { + if self.current_node_named(local_name!("menuitem")) { self.pop(); } self.insert_and_pop_element_for(tag); @@ -636,7 +637,7 @@ impl<Handle, Sink> TreeBuilderStep tag @ <image> => { self.unexpected(&tag); self.step(InBody, TagToken(Tag { - name: atom!("img"), + name: local_name!("img"), ..tag })) } @@ -684,7 +685,7 @@ impl<Handle, Sink> TreeBuilderStep } tag @ <optgroup> <option> => { - if self.current_node_named(atom!("option")) { + if self.current_node_named(local_name!("option")) { self.pop(); } self.reconstruct_formatting(); @@ -693,7 +694,7 @@ impl<Handle, Sink> TreeBuilderStep } tag @ <menuitem> => { - if self.current_node_named(atom!("menuitem")) { + if self.current_node_named(local_name!("menuitem")) { self.pop(); } self.reconstruct_formatting(); @@ -702,10 +703,10 @@ impl<Handle, Sink> TreeBuilderStep } tag @ <rb> <rtc> => { - if self.in_scope_named(default_scope, atom!("ruby")) { + if self.in_scope_named(default_scope, local_name!("ruby")) { self.generate_implied_end(cursory_implied_end); } - if !self.current_node_named(atom!("ruby")) { + if !self.current_node_named(local_name!("ruby")) { self.unexpected(&tag); } self.insert_element_for(tag); @@ -713,10 +714,10 @@ impl<Handle, Sink> TreeBuilderStep } tag @ <rp> <rt> => { - if self.in_scope_named(default_scope, atom!("ruby")) { - self.generate_implied_end_except(atom!("rtc")); + if self.in_scope_named(default_scope, local_name!("ruby")) { + self.generate_implied_end_except(local_name!("rtc")); } - if !self.current_node_named(atom!("rtc")) && !self.current_node_named(atom!("ruby")) { + if !self.current_node_named(local_name!("rtc")) && !self.current_node_named(local_name!("ruby")) { self.unexpected(&tag); } self.insert_element_for(tag); @@ -734,7 +735,7 @@ impl<Handle, Sink> TreeBuilderStep } tag @ <_> => { - if self.opts.scripting_enabled && tag.name == atom!("noscript") { + if self.opts.scripting_enabled && tag.name == local_name!("noscript") { self.parse_raw_data(tag, Rawtext); } else { self.reconstruct_formatting(); @@ -759,7 +760,7 @@ impl<Handle, Sink> TreeBuilderStep EOFToken => { self.unexpected(&token); - if self.current_node_named(atom!("script")) { + if self.current_node_named(local_name!("script")) { let current = self.current_node(); self.sink.mark_script_already_started(current); } @@ -769,7 +770,7 @@ impl<Handle, Sink> TreeBuilderStep tag @ </_> => { let node = self.pop(); - if tag.name == atom!("script") { + if tag.name == local_name!("script") { warn!("FIXME: </script> not fully implemented"); if self.sink.complete_script(node) == NextParserState::Suspend { self.next_tokenizer_state = Some(StateChangeQuery::Quiescent); @@ -810,7 +811,7 @@ impl<Handle, Sink> TreeBuilderStep <col> => { self.pop_until_current(table_scope); - self.insert_phantom(atom!("colgroup")); + self.insert_phantom(local_name!("colgroup")); Reprocess(InColumnGroup, token) } @@ -823,14 +824,14 @@ impl<Handle, Sink> TreeBuilderStep <td> <th> <tr> => { self.pop_until_current(table_scope); - self.insert_phantom(atom!("tbody")); + self.insert_phantom(local_name!("tbody")); Reprocess(InTableBody, token) } <table> => { self.unexpected(&token); - if self.in_scope_named(table_scope, atom!("table")) { - self.pop_until_named(atom!("table")); + if self.in_scope_named(table_scope, local_name!("table")) { + self.pop_until_named(local_name!("table")); Reprocess(self.reset_insertion_mode(), token) } else { Done @@ -838,8 +839,8 @@ impl<Handle, Sink> TreeBuilderStep } </table> => { - if self.in_scope_named(table_scope, atom!("table")) { - self.pop_until_named(atom!("table")); + if self.in_scope_named(table_scope, local_name!("table")) { + self.pop_until_named(local_name!("table")); self.mode = self.reset_insertion_mode(); } else { self.unexpected(&token); @@ -866,7 +867,7 @@ impl<Handle, Sink> TreeBuilderStep tag @ <form> => { self.unexpected(&tag); - if !self.in_html_elem_named(atom!("template")) && self.form_elem.is_none() { + if !self.in_html_elem_named(local_name!("template")) && self.form_elem.is_none() { self.form_elem = Some(self.insert_and_pop_element_for(tag)); } Done @@ -921,12 +922,12 @@ impl<Handle, Sink> TreeBuilderStep InCaption => match_token!(token { tag @ <caption> <col> <colgroup> <tbody> <td> <tfoot> <th> <thead> <tr> </table> </caption> => { - if self.in_scope_named(table_scope, atom!("caption")) { + if self.in_scope_named(table_scope, local_name!("caption")) { self.generate_implied_end(cursory_implied_end); - self.expect_to_close(atom!("caption")); + self.expect_to_close(local_name!("caption")); self.clear_active_formatting_to_marker(); match tag { - Tag { kind: EndTag, name: atom!("caption"), .. } => { + Tag { kind: EndTag, name: local_name!("caption"), .. } => { self.mode = InTable; Done } @@ -958,7 +959,7 @@ impl<Handle, Sink> TreeBuilderStep } </colgroup> => { - if self.current_node_named(atom!("colgroup")) { + if self.current_node_named(local_name!("colgroup")) { self.pop(); self.mode = InTable; } else { @@ -974,7 +975,7 @@ impl<Handle, Sink> TreeBuilderStep EOFToken => self.step(InBody, token), token => { - if self.current_node_named(atom!("colgroup")) { + if self.current_node_named(local_name!("colgroup")) { self.pop(); Reprocess(InTable, token) } else { @@ -995,7 +996,7 @@ impl<Handle, Sink> TreeBuilderStep <th> <td> => { self.unexpected(&token); self.pop_until_current(table_body_context); - self.insert_phantom(atom!("tr")); + self.insert_phantom(local_name!("tr")); Reprocess(InRow, token) } @@ -1038,10 +1039,10 @@ impl<Handle, Sink> TreeBuilderStep } </tr> => { - if self.in_scope_named(table_scope, atom!("tr")) { + if self.in_scope_named(table_scope, local_name!("tr")) { self.pop_until_current(table_row_context); let node = self.pop(); - self.assert_named(node, atom!("tr")); + self.assert_named(node, local_name!("tr")); self.mode = InTableBody; } else { self.unexpected(&token); @@ -1050,10 +1051,10 @@ impl<Handle, Sink> TreeBuilderStep } <caption> <col> <colgroup> <tbody> <tfoot> <thead> <tr> </table> => { - if self.in_scope_named(table_scope, atom!("tr")) { + if self.in_scope_named(table_scope, local_name!("tr")) { self.pop_until_current(table_row_context); let node = self.pop(); - self.assert_named(node, atom!("tr")); + self.assert_named(node, local_name!("tr")); Reprocess(InTableBody, token) } else { self.unexpected(&token) @@ -1062,10 +1063,10 @@ impl<Handle, Sink> TreeBuilderStep tag @ </tbody> </tfoot> </thead> => { if self.in_scope_named(table_scope, tag.name.clone()) { - if self.in_scope_named(table_scope, atom!("tr")) { + if self.in_scope_named(table_scope, local_name!("tr")) { self.pop_until_current(table_row_context); let node = self.pop(); - self.assert_named(node, atom!("tr")); + self.assert_named(node, local_name!("tr")); Reprocess(InTableBody, TagToken(tag)) } else { Done @@ -1128,7 +1129,7 @@ impl<Handle, Sink> TreeBuilderStep <html> => self.step(InBody, token), tag @ <option> => { - if self.current_node_named(atom!("option")) { + if self.current_node_named(local_name!("option")) { self.pop(); } self.insert_element_for(tag); @@ -1136,10 +1137,10 @@ impl<Handle, Sink> TreeBuilderStep } tag @ <optgroup> => { - if self.current_node_named(atom!("option")) { + if self.current_node_named(local_name!("option")) { self.pop(); } - if self.current_node_named(atom!("optgroup")) { + if self.current_node_named(local_name!("optgroup")) { self.pop(); } self.insert_element_for(tag); @@ -1148,12 +1149,12 @@ impl<Handle, Sink> TreeBuilderStep </optgroup> => { if self.open_elems.len() >= 2 - && self.current_node_named(atom!("option")) + && self.current_node_named(local_name!("option")) && self.html_elem_named(self.open_elems[self.open_elems.len() - 2].clone(), - atom!("optgroup")) { + local_name!("optgroup")) { self.pop(); } - if self.current_node_named(atom!("optgroup")) { + if self.current_node_named(local_name!("optgroup")) { self.pop(); } else { self.unexpected(&token); @@ -1162,7 +1163,7 @@ impl<Handle, Sink> TreeBuilderStep } </option> => { - if self.current_node_named(atom!("option")) { + if self.current_node_named(local_name!("option")) { self.pop(); } else { self.unexpected(&token); @@ -1171,14 +1172,14 @@ impl<Handle, Sink> TreeBuilderStep } tag @ <select> </select> => { - let in_scope = self.in_scope_named(select_scope, atom!("select")); + let in_scope = self.in_scope_named(select_scope, local_name!("select")); if !in_scope || tag.kind == StartTag { self.unexpected(&tag); } if in_scope { - self.pop_until_named(atom!("select")); + self.pop_until_named(local_name!("select")); self.mode = self.reset_insertion_mode(); } Done @@ -1186,8 +1187,8 @@ impl<Handle, Sink> TreeBuilderStep <input> <keygen> <textarea> => { self.unexpected(&token); - if self.in_scope_named(select_scope, atom!("select")) { - self.pop_until_named(atom!("select")); + if self.in_scope_named(select_scope, local_name!("select")) { + self.pop_until_named(local_name!("select")); Reprocess(self.reset_insertion_mode(), token) } else { Done @@ -1205,14 +1206,14 @@ impl<Handle, Sink> TreeBuilderStep InSelectInTable => match_token!(token { <caption> <table> <tbody> <tfoot> <thead> <tr> <td> <th> => { self.unexpected(&token); - self.pop_until_named(atom!("select")); + self.pop_until_named(local_name!("select")); Reprocess(self.reset_insertion_mode(), token) } tag @ </caption> </table> </tbody> </tfoot> </thead> </tr> </td> </th> => { self.unexpected(&tag); if self.in_scope_named(table_scope, tag.name.clone()) { - self.pop_until_named(atom!("select")); + self.pop_until_named(local_name!("select")); Reprocess(self.reset_insertion_mode(), TagToken(tag)) } else { Done @@ -1257,11 +1258,11 @@ impl<Handle, Sink> TreeBuilderStep } EOFToken => { - if !self.in_html_elem_named(atom!("template")) { + if !self.in_html_elem_named(local_name!("template")) { self.stop_parsing() } else { self.unexpected(&token); - self.pop_until_named(atom!("template")); + self.pop_until_named(local_name!("template")); self.clear_active_formatting_to_marker(); self.template_modes.pop(); self.mode = self.reset_insertion_mode(); @@ -1321,7 +1322,7 @@ impl<Handle, Sink> TreeBuilderStep self.unexpected(&token); } else { self.pop(); - if !self.is_fragment() && !self.current_node_named(atom!("frameset")) { + if !self.is_fragment() && !self.current_node_named(local_name!("frameset")) { self.mode = AfterFrameset; } } diff --git a/src/tree_builder/tag_sets.rs b/src/tree_builder/tag_sets.rs index 755287e8..f994827b 100644 --- a/src/tree_builder/tag_sets.rs +++ b/src/tree_builder/tag_sets.rs @@ -9,7 +9,7 @@ //! Various sets of HTML tag names, and macros for declaring them. -use string_cache::QualName; +use QualName; macro_rules! declare_tag_set_impl ( ($param:ident, $b:ident, $supr:ident, $($tag:tt)+) => ( match $param { @@ -31,13 +31,13 @@ macro_rules! declare_tag_set_body ( macro_rules! declare_tag_set ( (pub $name:ident = $($toks:tt)+) => ( - pub fn $name(p: ::string_cache::QualName) -> bool { + pub fn $name(p: ::QualName) -> bool { declare_tag_set_body!(p = $($toks)+) } ); ($name:ident = $($toks:tt)+) => ( - fn $name(p: ::string_cache::QualName) -> bool { + fn $name(p: ::QualName) -> bool { declare_tag_set_body!(p = $($toks)+) } ); diff --git a/tests/serializer.rs b/tests/serializer.rs index 4df6b45e..57494759 100644 --- a/tests/serializer.rs +++ b/tests/serializer.rs @@ -7,9 +7,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#[macro_use] extern crate string_cache; extern crate tendril; extern crate html5ever; +#[macro_use] extern crate html5ever_atoms; use std::default::Default; diff --git a/tests/tokenizer.rs b/tests/tokenizer.rs index 93f48549..db36a81a 100644 --- a/tests/tokenizer.rs +++ b/tests/tokenizer.rs @@ -8,11 +8,11 @@ // except according to those terms. extern crate rustc_serialize; -#[macro_use] extern crate string_cache; extern crate tendril; extern crate test; - extern crate html5ever; +#[macro_use] extern crate html5ever_atoms; + mod foreach_html5lib_test; use foreach_html5lib_test::foreach_html5lib_test; @@ -28,6 +28,7 @@ use rustc_serialize::json::Json; use std::collections::BTreeMap; use std::borrow::Cow::Borrowed; +use html5ever::{LocalName, QualName}; use html5ever::tokenizer::{Doctype, Attribute, StartTag, EndTag, Tag}; use html5ever::tokenizer::{Token, DoctypeToken, TagToken, CommentToken}; use html5ever::tokenizer::{CharacterTokens, NullCharacterToken, EOFToken, ParseError}; @@ -35,7 +36,6 @@ use html5ever::tokenizer::{TokenSink, Tokenizer, TokenizerOpts}; use html5ever::tokenizer::buffer_queue::BufferQueue; use html5ever::tokenizer::states::{Plaintext, RawData, Rcdata, Rawtext}; -use string_cache::{Atom, QualName}; use tendril::{StrTendril, SliceExt}; // Return all ways of splitting the string into at most n @@ -219,10 +219,10 @@ fn json_to_token(js: &Json) -> Token { "StartTag" => TagToken(Tag { kind: StartTag, - name: Atom::from(&*args[0].get_str()), + name: LocalName::from(&*args[0].get_str()), attrs: args[1].get_obj().iter().map(|(k,v)| { Attribute { - name: QualName::new(ns!(), Atom::from(&**k)), + name: QualName::new(ns!(), LocalName::from(&**k)), value: v.get_tendril() } }).collect(), @@ -234,7 +234,7 @@ fn json_to_token(js: &Json) -> Token { "EndTag" => TagToken(Tag { kind: EndTag, - name: Atom::from(&*args[0].get_str()), + name: LocalName::from(&*args[0].get_str()), attrs: vec!(), self_closing: false }), diff --git a/tests/tree_builder.rs b/tests/tree_builder.rs index 527512c0..e6d2fbaa 100644 --- a/tests/tree_builder.rs +++ b/tests/tree_builder.rs @@ -8,10 +8,9 @@ // except according to those terms. extern crate test; -#[macro_use] extern crate string_cache; extern crate tendril; - extern crate html5ever; +#[macro_use] extern crate html5ever_atoms; mod foreach_html5lib_test; use foreach_html5lib_test::foreach_html5lib_test; @@ -27,11 +26,11 @@ use std::collections::{HashSet, HashMap}; use test::{TestDesc, TestDescAndFn, DynTestName, TestFn}; use test::ShouldPanic::No; +use html5ever::{LocalName, QualName}; use html5ever::{ParseOpts, parse_document, parse_fragment}; use html5ever::rcdom::{Comment, Document, Doctype, Element, Handle, RcDom}; use html5ever::rcdom::{Template, Text}; -use string_cache::{Atom, QualName}; use tendril::{StrTendril, TendrilSink}; fn parse_tests<It: Iterator<Item=String>>(mut lines: It) -> Vec<HashMap<String, String>> { @@ -241,11 +240,11 @@ fn make_test_desc_with_scripting_flag( fn context_name(context: &str) -> QualName { if context.starts_with("svg ") { - QualName::new(ns!(svg), Atom::from(&context[4..])) + QualName::new(ns!(svg), LocalName::from(&context[4..])) } else if context.starts_with("math ") { - QualName::new(ns!(mathml), Atom::from(&context[5..])) + QualName::new(ns!(mathml), LocalName::from(&context[5..])) } else { - QualName::new(ns!(html), Atom::from(context)) + QualName::new(ns!(html), LocalName::from(context)) } }