From 15e2220abbb116f4bc4d79ec9d26b4e9b301efa2 Mon Sep 17 00:00:00 2001 From: Simon Sapin Date: Thu, 27 Oct 2016 16:32:03 +0200 Subject: [PATCH 1/8] Element names and attributes from https://api.csswg.org/shepherd/ --- .gitignore | 1 + atoms/local_names.txt | 687 ++++++++++++++++++++++++++++++++++++ atoms/update_local_names.py | 47 +++ 3 files changed, 735 insertions(+) create mode 100644 atoms/local_names.txt create mode 100755 atoms/update_local_names.py diff --git a/.gitignore b/.gitignore index d7bea00a..a6d5e291 100644 --- a/.gitignore +++ b/.gitignore @@ -2,3 +2,4 @@ target Cargo.lock *.racertmp +/atoms/anchors.json diff --git a/atoms/local_names.txt b/atoms/local_names.txt new file mode 100644 index 00000000..6e2bda78 --- /dev/null +++ b/atoms/local_names.txt @@ -0,0 +1,687 @@ +a +abbr +accent-height +accept +accept-charset +accumulate +action +additional-name +additive +address +address-level1 +address-level2 +address-level3 +address-level4 +address-line1 +address-line2 +address-line3 +align +alink +allow-forms +allow-modals +allow-orientation-lock +allow-pointer-lock +allow-popups +allow-popups-to-escape-sandbox +allow-presentation +allow-same-origin +allow-scripts +allow-top-navigation +allowfullscreen +allowtransparency +allowusermedia +alphabetic +alt +altGlyph +altGlyphDef +alternate +amplitude +animate +animateColor +animateMotion +animateTransform +any +applet +application/x-www-form-urlencoded +arabic-form +archive +area +aria-* +aria-describedby +aria-disabled +aria-label +article +as +ascent +aside +async +attributeName +attributeType +audio +auto +autocomplete +autofocus +autoplay +axis +azimuth +b +background +base +baseFrequency +baseProfile +bbox +bday +bday-day +bday-month +bday-year +bdi +bdo +begin +behavior +bgcolor +bias +billing +blockquote +body +border +bordercolor +bottommargin +br +button +by +calcMode +canvas +cap-height +caption +captions +cc-additional-name +cc-csc +cc-exp +cc-exp-month +cc-exp-year +cc-family-name +cc-given-name +cc-name +cc-number +cc-type +cellpadding +cellspacing +challenge +chapters +char +character height +character width +charoff +charset +checkbox +checked +circ +circle +circle state +cite +class +classid +clear +clipPath +clipPathUnits +code +codebase +codetype +col +colgroup +color +color-profile +cols +colspan +command +compact +content +contentScriptType +contentStyleType +contenteditable +context +contextmenu +controls +coords +copy +country +country-name +crossorigin +current-password +cursor +cx +cy +d +data +data- +datafld +dataformatas +datalist +datapagesize +datasrc +datetime +dd +decimal +declare +default +default state +defer +defs +del +desc +descent +descriptions +details +dfn +dialog +diffuseConstant +direction +dirname +disabled +div +divisor +dl +down +download +dt +dur +dx +dy +edgeMode +elevation +ellipse +em +email +embed +enctype +end +event +exponent +externalResourcesRequired +family-name +fax +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 +fieldset +figcaption +figure +fill +filter +filter-primitive +filterRes +filterUnits +font +font-face +font-face-name +font-face-src +font-face-uri +font-family +font-size +font-stretch +font-style +font-variant +font-weight +footer +for +foreignObject +form +form control maxlength attribute +form control minlength attribute +formaction +format +formenctype +formmethod +formnovalidate +formtarget +fr +frame +frameborder +frameset +framespacing +from +full-width-latin +fx +fy +g +g1 +g2 +generator-unable-to-provide-required-alt +given-name +glyph +glyph-name +glyphRef +gradientTransform +gradientUnits +hanging +hard +hatch +hatchContentUnits +hatchUnits +hatchpath +head +header +headers +height +hgroup +high +hkern +home +honorific-prefix +honorific-suffix +horiz-adv-x +horiz-origin-x +horiz-origin-y +hr +href +hreflang +hspace +html +http-equiv +i +icon +id +ideographic +iframe +image +img +impp +in +in2 +input +inputmode +ins +intercept +is +ismap +itemid +itemref +itemscope +itemtype +k +k1 +k2 +k3 +k4 +kana +kana-name +katakana +kbd +kernelMatrix +kernelUnitLength +keyPoints +keySplines +keyTimes +keygen +keytype +kind +label +lang +language +latin +latin-name +latin-prose +left +leftmargin +legend +lengthAdjust +li +limitingConeAngle +line +linearGradient +link +list +local +longdesc +loop +low +lower-alpha +lower-roman +lowsrc +ltr +main +manifest +map +marginheight +margintop +marginwidth +mark +marker +markerHeight +markerUnits +markerWidth +marquee +mask +maskContentUnits +maskUnits +mathematical +max +maxlength +media +menu +menuitem +mesh +meshgradient +meshpatch +meshrow +meta +metadata +meter +method +methods +min +minlength +missing-glyph +mobile +mode +move +multipart/form-data +multiple +muted +name +nav +new-password +nickname +no-composite +nohref +nonce +none +noscript +noshade +novalidate +nowrap +numOctaves +numeric +object +off +offset +ol +on +onabort +onactivate +onbegin +onclick +onend +onerror +onfocusin +onfocusout +onload +onmousedown +onmousemove +onmouseout +onmouseover +onmouseup +onrepeat +onresize +onscroll +onunload +onzoom +open +operator +optgroup +optimum +option +order +organization +organization-title +orient +orientation +origin +output +overline-position +overline-thickness +p +pager +panose-1 +param +path +pathLength +pattern +patternContentUnits +patternTransform +patternUnits +photo +picture +ping +pitch +placeholder +playsinline +points +pointsAtX +pointsAtY +pointsAtZ +poly +polygon +polygon state +polyline +postal-code +poster +pre +preload +presentation +preserveAlpha +preserveAspectRatio +primitiveUnits +profile +progress +q +r +radialGradient +radio +radiogroup +radius +readonly +rect +rectangle +rectangle state +refX +refY +referrerpolicy +rel +rendering-intent +repeatCount +repeatDur +required +requiredExtensions +requiredFeatures +reset +restart +result +rev +reversed +right +rightmargin +role +rotate +row +rowgroup +rows +rowspan +rp +rt +rtl +ruby +rules +rx +ry +s +samp +sandbox +scale +scheme +scope +script +scroll +scrolling +section +section- +seed +select +selected +set +sex +shape +shipping +side +size +sizes +slide +slope +slot +small +soft +solidcolor +source +spacing +span +specularConstant +specularExponent +spellcheck +spreadMethod +src +srcdoc +srclang +srcset +standby +start +startOffset +stdDeviation +stemh +stemv +step +stitchTiles +stop +street-address +strikethrough-position +strikethrough-thickness +string +strong +style +submit +subtitles +summary +surfaceScale +svg +svg:transform +switch +symbol +tabindex +table +tableValues +target +targetX +targetY +tbody +td +tel +tel-area-code +tel-country-code +tel-extension +tel-local +tel-local-prefix +tel-local-suffix +tel-national +template +text +text/plain +textLength +textPath +textarea +tfoot +th +thead +time +title +to +toolbar +tr +track +transaction-amount +transaction-currency +transform +translate +tref +truespeed +tspan +type +typemustmatch +u +u1 +u2 +ul +underline-position +underline-thickness +unicode +unicode-range +units-per-em +unknown +up +upper-alpha +upper-roman +url +urn +use +usemap +username +v-alphabetic +v-hanging +v-ideographic +v-mathematical +valign +value +values +valuetype +var +verbatim +version +vert-adv-y +vert-origin-x +vert-origin-y +video +view +viewTarget +vlink +vspace +wbr +width +widths +work +wrap +x +x-height +x1 +x2 +xChannelSelector +xlink:actuate +xlink:href +xml:base +xml:lang +xml:space +y +y1 +y2 +yChannelSelector +z +zoomAndPan \ No newline at end of file diff --git a/atoms/update_local_names.py b/atoms/update_local_names.py new file mode 100755 index 00000000..f4388533 --- /dev/null +++ b/atoms/update_local_names.py @@ -0,0 +1,47 @@ +#!/usr/bin/python + +import os.path +import json +from urllib2 import Request, urlopen + + +def update(atoms_dir): + anchors_json = os.path.join(atoms_dir, "anchors.json") + if os.path.exists(anchors_json): + print("Using cached anchors.json, remove it to re-download.") + else: + # API docs: https://api.csswg.org/shepherd/ + request = Request("https://test.csswg.org/shepherd/api/spec/?anchors&drafts") + request.add_header("Accept", "application/vnd.csswg.shepherd.v1+json") + open(anchors_json, "wb").write(urlopen(request).read()) + specs = json.load(open(anchors_json, "rb")) + + local_names = set() + + def traverse(anchors): + for anchor in anchors: + traverse(anchor.get("children", [])) + if anchor.get("type") in ("element", "element-attr"): + linking_text = anchor.get("linking_text") + if linking_text: + identifier = linking_text[0] + else: + identifier = anchor["title"] + + # The data seems to contain some incorrect "element-attr" entries, + # where `identifier` is a section title rather than an attribute name. + # "Starts with a lower-case letter" seems to be a good heuristic to filter them out: + if identifier[0].islower(): + local_names.add(identifier) + + for spec in specs.itervalues(): + traverse(spec.get("anchors", [])) + traverse(spec.get("draft_anchors", [])) + + to_write = "\n".join(sorted(local_names)).encode("utf8") + open(os.path.join(atoms_dir, "local_names.txt"), "wb").write(to_write) + print("local_names.txt written.") + + +if __name__ == "__main__": + update(os.path.dirname(__file__)) From ad20b52be6eb892fb956b387f2e3ee971078f91b Mon Sep 17 00:00:00 2001 From: Simon Sapin Date: Thu, 27 Oct 2016 17:11:51 +0200 Subject: [PATCH 2/8] Use static local names list from Gecko. Extracted from commit e23b523ceb7fd32cb226f713d416ce15a831ff00. Give up on Shephred, it contains both false positives and false negatives. --- .gitignore | 1 - atoms/local_names.txt | 656 +++++++++++++++++++++++++----------- atoms/update_local_names.py | 47 --- 3 files changed, 458 insertions(+), 246 deletions(-) delete mode 100755 atoms/update_local_names.py diff --git a/.gitignore b/.gitignore index a6d5e291..d7bea00a 100644 --- a/.gitignore +++ b/.gitignore @@ -2,4 +2,3 @@ target Cargo.lock *.racertmp -/atoms/anchors.json diff --git a/atoms/local_names.txt b/atoms/local_names.txt index 6e2bda78..58e400a0 100644 --- a/atoms/local_names.txt +++ b/atoms/local_names.txt @@ -1,67 +1,107 @@ a abbr +abs +accent accent-height +accentunder accept accept-charset +accesskey accumulate +acronym action -additional-name +actiontype +active +actuate additive address -address-level1 -address-level2 -address-level3 -address-level4 -address-line1 -address-line2 -address-line3 align +alignment-baseline +alignmentscope alink -allow-forms -allow-modals -allow-orientation-lock -allow-pointer-lock -allow-popups -allow-popups-to-escape-sandbox -allow-presentation -allow-same-origin -allow-scripts -allow-top-navigation -allowfullscreen -allowtransparency -allowusermedia alphabetic alt altGlyph altGlyphDef -alternate +altGlyphItem +altimg +alttext amplitude +and animate animateColor animateMotion animateTransform -any +animation +annotation +annotation-xml applet -application/x-www-form-urlencoded +apply +approx arabic-form +arccos +arccosh +arccot +arccoth +arccsc +arccsch archive +arcrole +arcsec +arcsech +arcsin +arcsinh +arctan +arctanh area -aria-* +arg +aria-activedescendant +aria-atomic +aria-autocomplete +aria-busy +aria-channel +aria-checked +aria-controls +aria-datatype aria-describedby aria-disabled -aria-label +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 -as ascent aside async attributeName attributeType audio -auto autocomplete autofocus autoplay +autosubmit axis azimuth b @@ -69,137 +109,162 @@ background base baseFrequency baseProfile +basefont +baseline +baseline-shift bbox -bday -bday-day -bday-month -bday-year -bdi bdo begin -behavior +bevelled bgcolor +bgsound bias -billing +big blockquote body border -bordercolor -bottommargin br button +bvar by calcMode canvas cap-height caption -captions -cc-additional-name -cc-csc -cc-exp -cc-exp-month -cc-exp-year -cc-family-name -cc-given-name -cc-name -cc-number -cc-type +card +cartesianproduct +ceiling cellpadding cellspacing -challenge -chapters +center char -character height -character width charoff charset -checkbox checked -circ +ci circle -circle state 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 -command +columnalign +columnlines +columnspacing +columnspan +columnwidth compact +complexes +compose +condition +conjugate content contentScriptType contentStyleType contenteditable -context contextmenu controls coords -copy -country -country-name +cos +cosh +cot +coth crossorigin -current-password +csc +csch +csymbol +curl cursor cx cy d data -data- datafld dataformatas -datalist -datapagesize datasrc +datatemplate datetime dd -decimal declare default -default state defer +definition-src +definitionURL defs +degree del +depth desc descent -descriptions details +determinant dfn -dialog +diff diffuseConstant +dir direction -dirname disabled +discard +display +displaystyle div +divergence +divide divisor dl -down -download +domain +domainofapplication +dominant-baseline +draggable dt dur dx dy +edge edgeMode elevation ellipse em -email embed +emptyset +enable-background +encoding enctype end -event +eq +equalcolumns +equalrows +equivalent +eulergamma +exists +exp exponent +exponentiale externalResourcesRequired -family-name -fax +face +factorial +factorof +false feBlend feColorMatrix feComponentTransfer @@ -208,7 +273,6 @@ feConvolveMatrix feDiffuseLighting feDisplacementMap feDistantLight -feDropShadow feFlood feFuncA feFuncB @@ -225,72 +289,82 @@ feSpecularLighting feSpotLight feTile feTurbulence +fence fieldset figcaption figure fill +fill-opacity +fill-rule filter -filter-primitive 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 -form control maxlength attribute -form control minlength attribute -formaction format -formenctype -formmethod -formnovalidate -formtarget -fr frame frameborder frameset framespacing from -full-width-latin fx fy g g1 g2 -generator-unable-to-provide-required-alt -given-name +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 -hard -hatch -hatchContentUnits -hatchUnits -hatchpath head header headers height hgroup +hidden +hidefocus high hkern -home -honorific-prefix -honorific-suffix horiz-adv-x horiz-origin-x horiz-origin-y @@ -303,72 +377,93 @@ http-equiv i icon id +ident ideographic iframe image +image-rendering +imaginary +imaginaryi img -impp +implies in in2 +index +infinity input inputmode ins +int +integers intercept -is +intersect +interval +inverse +irrelevant +isindex ismap -itemid -itemref -itemscope -itemtype k k1 k2 k3 k4 -kana -kana-name -katakana kbd kernelMatrix kernelUnitLength +kerning keyPoints keySplines keyTimes keygen -keytype -kind label +lambda lang language -latin -latin-name -latin-prose -left -leftmargin +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 -lower-alpha -lower-roman +lowlimit lowsrc -ltr +lquote +lspace +lt +macros +maction main +maligngroup +malignmark manifest map marginheight -margintop marginwidth mark marker +marker-end +marker-mid +marker-start markerHeight markerUnits markerWidth @@ -376,194 +471,328 @@ marquee mask maskContentUnits maskUnits +math +mathbackground +mathcolor mathematical +mathsize +mathvariant +matrix +matrixrow max maxlength +maxsize +mean media +median +mediummathspace +menclose menu menuitem -mesh -meshgradient -meshpatch -meshrow +merror meta metadata meter method -methods +mfenced +mfrac +mglyph +mi min -minlength +minsize +minus missing-glyph -mobile +mlabeledtr +mmultiscripts +mn +mo mode -move -multipart/form-data +moment +momentabout +movablelimits +mover +mpadded +mpath +mphantom +mprescripts +mroot +mrow +ms +mspace +msqrt +mstyle +msub +msubsup +msup +mtable +mtd +mtext +mtr multiple -muted +munder +munderover name +nargs +naturalnumbers nav -new-password -nickname -no-composite +neq +nest +nobr +noembed +noframes nohref -nonce none +noresize noscript noshade -novalidate +not +notanumber +notation +notin +notprsubset +notsubset nowrap numOctaves -numeric object -off +occurrence offset ol -on 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 +onhelp +oninput +oninvalid +onkeydown +onkeypress +onkeyup onload +onlosecapture +onmessage onmousedown +onmouseenter +onmouseleave onmousemove onmouseout onmouseover onmouseup +onmousewheel +onmove +onmoveend +onmovestart +onpaste +onpropertychange +onreadystatechange onrepeat +onreset onresize +onrowenter +onrowexit +onrowsdelete +onrowsinserted onscroll +onselect +onselectstart +onstart +onstop +onsubmit onunload onzoom +opacity open operator optgroup optimum option +or order -organization -organization-title orient orientation origin +other +otherwise +outerproduct output +overflow overline-position overline-thickness p -pager panose-1 param +partialdiff path pathLength pattern patternContentUnits patternTransform patternUnits -photo -picture +pi +piece +piecewise ping -pitch -placeholder -playsinline +plaintext +plus +pointer-events points pointsAtX pointsAtY pointsAtZ -poly polygon -polygon state polyline -postal-code poster +power pre -preload -presentation +prefetch preserveAlpha preserveAspectRatio +primes primitiveUnits +product profile progress +prompt +prsubset q +quotient r radialGradient -radio radiogroup radius +rationals readonly +real +reals rect -rectangle -rectangle state refX refY -referrerpolicy rel +reln +rem rendering-intent +repeat +repeat-max +repeat-min +repeat-start +repeat-template repeatCount repeatDur +replace required requiredExtensions requiredFeatures -reset restart result rev -reversed -right -rightmargin role +root rotate -row -rowgroup +rowalign +rowlines rows +rowspacing rowspan rp +rquote +rspace rt -rtl ruby +rule rules rx ry s samp sandbox +scalarproduct scale scheme scope +scoped script -scroll +scriptlevel +scriptminsize +scriptsizemultiplier +scrolldelay scrolling +sdev +seamless +sec +sech section -section- seed select selected +selection +selector +semantics +sep +separator +separators set -sex +setdiff shape -shipping -side +shape-rendering +show +sin +sinh size -sizes -slide slope -slot small -soft solidcolor source +space spacing span +specification specularConstant specularExponent -spellcheck +speed spreadMethod src srcdoc -srclang -srcset standby start startOffset @@ -573,60 +802,74 @@ stemv step stitchTiles stop -street-address +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 -submit -subtitles +sub +subscriptshift +subset +sum summary +sup +superscriptshift surfaceScale svg -svg:transform switch symbol +symmetric +systemLanguage tabindex table tableValues +tan +tanh target targetX targetY tbody +tbreak td -tel -tel-area-code -tel-country-code -tel-extension -tel-local -tel-local-prefix -tel-local-suffix -tel-national template +tendsto text -text/plain +text-anchor +text-decoration +text-rendering textLength textPath textarea tfoot th thead +thickmathspace +thinmathspace time +times title to -toolbar tr track -transaction-amount -transaction-currency transform -translate +transpose tref -truespeed +true tspan +tt type -typemustmatch u u1 u2 @@ -634,17 +877,14 @@ ul underline-position underline-thickness unicode +unicode-bidi unicode-range +union units-per-em -unknown -up -upper-alpha -upper-roman -url -urn +unselectable +uplimit use usemap -username v-alphabetic v-hanging v-ideographic @@ -654,31 +894,51 @@ value values valuetype var -verbatim +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 -work +word-spacing wrap +writing-mode x x-height x1 x2 xChannelSelector xlink:actuate +xlink:arcrole xlink:href +xlink:role +xlink:show +xlink:type xml:base xml:lang xml:space +xmlns +xmlns:xlink +xmp +xor +xref y y1 y2 diff --git a/atoms/update_local_names.py b/atoms/update_local_names.py deleted file mode 100755 index f4388533..00000000 --- a/atoms/update_local_names.py +++ /dev/null @@ -1,47 +0,0 @@ -#!/usr/bin/python - -import os.path -import json -from urllib2 import Request, urlopen - - -def update(atoms_dir): - anchors_json = os.path.join(atoms_dir, "anchors.json") - if os.path.exists(anchors_json): - print("Using cached anchors.json, remove it to re-download.") - else: - # API docs: https://api.csswg.org/shepherd/ - request = Request("https://test.csswg.org/shepherd/api/spec/?anchors&drafts") - request.add_header("Accept", "application/vnd.csswg.shepherd.v1+json") - open(anchors_json, "wb").write(urlopen(request).read()) - specs = json.load(open(anchors_json, "rb")) - - local_names = set() - - def traverse(anchors): - for anchor in anchors: - traverse(anchor.get("children", [])) - if anchor.get("type") in ("element", "element-attr"): - linking_text = anchor.get("linking_text") - if linking_text: - identifier = linking_text[0] - else: - identifier = anchor["title"] - - # The data seems to contain some incorrect "element-attr" entries, - # where `identifier` is a section title rather than an attribute name. - # "Starts with a lower-case letter" seems to be a good heuristic to filter them out: - if identifier[0].islower(): - local_names.add(identifier) - - for spec in specs.itervalues(): - traverse(spec.get("anchors", [])) - traverse(spec.get("draft_anchors", [])) - - to_write = "\n".join(sorted(local_names)).encode("utf8") - open(os.path.join(atoms_dir, "local_names.txt"), "wb").write(to_write) - print("local_names.txt written.") - - -if __name__ == "__main__": - update(os.path.dirname(__file__)) From 7f45b6a7c8c8d154c89592a7a40c98f4660fa21b Mon Sep 17 00:00:00 2001 From: Simon Sapin Date: Fri, 28 Oct 2016 17:29:51 +0200 Subject: [PATCH 3/8] html5ever-atoms crate --- atoms/Cargo.toml | 18 +++++++++++ atoms/build.rs | 51 +++++++++++++++++++++++++++++++ atoms/lib.rs | 78 ++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 147 insertions(+) create mode 100644 atoms/Cargo.toml create mode 100644 atoms/build.rs create mode 100644 atoms/lib.rs diff --git a/atoms/Cargo.toml b/atoms/Cargo.toml new file mode 100644 index 00000000..90d81ab8 --- /dev/null +++ b/atoms/Cargo.toml @@ -0,0 +1,18 @@ +[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" + +[dependencies] +string_cache = "0.3" + +[build-dependencies] +string_cache_codegen = "0.3" diff --git a/atoms/build.rs b/atoms/build.rs new file mode 100644 index 00000000..491cda78 --- /dev/null +++ b/atoms/build.rs @@ -0,0 +1,51 @@ +// 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("Namespace", "namespace_url!") + .atoms(NAMESPACES.iter().map(|&(_prefix, url)| url)) + .write_to(&mut generated) + .unwrap(); + + writeln!(generated, "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..c197a1a8 --- /dev/null +++ b/atoms/lib.rs @@ -0,0 +1,78 @@ +// 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; + +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") }); + } +} From 39010ed52972603e8b49f0bf514a32da9035e3cf Mon Sep 17 00:00:00 2001 From: Simon Sapin Date: Wed, 26 Oct 2016 15:22:21 +0200 Subject: [PATCH 4/8] Update to string_cache 0.3 The `atom!` macro is now defined in this crate, with the same static atoms as before. The `Atom`, `Namespace`, and `QualName` types are also here. `string_cache::Atom` now takes a type parameter, `html5ever::Atom` is a type alias with the parameter set. --- Cargo.toml | 8 +++--- atoms/build.rs | 2 +- atoms/local_names.txt | 8 +++++- examples/noop-tree-builder.rs | 7 ++--- examples/print-rcdom.rs | 4 +-- examples/print-tree-actions.rs | 7 ++--- src/driver.rs | 2 +- src/lib.rs | 3 +- src/macros.rs | 5 ++++ src/rcdom.rs | 2 +- src/serialize/mod.rs | 10 +++---- src/tokenizer/interface.rs | 4 +-- src/tokenizer/mod.rs | 10 +++---- src/tree_builder/actions.rs | 50 +++++++++++++++++----------------- src/tree_builder/interface.rs | 2 +- src/tree_builder/mod.rs | 4 +-- src/tree_builder/rules.rs | 5 ++-- src/tree_builder/tag_sets.rs | 6 ++-- tests/serializer.rs | 2 +- tests/tokenizer.rs | 12 ++++---- tests/tree_builder.rs | 11 ++++---- 21 files changed, 85 insertions(+), 79 deletions(-) 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/build.rs b/atoms/build.rs index 491cda78..7b7c5eac 100644 --- a/atoms/build.rs +++ b/atoms/build.rs @@ -43,7 +43,7 @@ fn main() { .write_to(&mut generated) .unwrap(); - writeln!(generated, "macro_rules! ns {{").unwrap(); + writeln!(generated, "#[macro_export] macro_rules! ns {{").unwrap(); for &(prefix, url) in NAMESPACES { writeln!(generated, "({}) => {{ namespace_url!({:?}) }};", prefix, url).unwrap(); } diff --git a/atoms/local_names.txt b/atoms/local_names.txt index 58e400a0..9d7f8211 100644 --- a/atoms/local_names.txt +++ b/atoms/local_names.txt @@ -219,6 +219,7 @@ descent details determinant dfn +dialog diff diffuseConstant dir @@ -273,6 +274,7 @@ feConvolveMatrix feDiffuseLighting feDisplacementMap feDistantLight +feDropShadow feFlood feFuncA feFuncB @@ -702,6 +704,7 @@ radialGradient radiogroup radius rationals +rb readonly real reals @@ -738,6 +741,7 @@ rp rquote rspace rt +rtc ruby rule rules @@ -925,11 +929,13 @@ x-height x1 x2 xChannelSelector +xlink xlink:actuate xlink:arcrole xlink:href xlink:role xlink:show +xlink:title xlink:type xml:base xml:lang @@ -944,4 +950,4 @@ y1 y2 yChannelSelector z -zoomAndPan \ No newline at end of file +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/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/macros.rs b/src/macros.rs index 82815191..d6012469 100644 --- a/src/macros.rs +++ b/src/macros.rs @@ -7,6 +7,11 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +// FIXME: remove this +macro_rules! atom { + ($string: tt) => { local_name!($string) } +} + macro_rules! unwrap_or_else { ($opt:expr, $else_block:block) => { match $opt { 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..007361a8 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); } } @@ -141,7 +141,7 @@ impl<'wr, Wr: Write> Serializer<'wr, Wr> { 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:")); } } 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..987aa831 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)); } @@ -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() { @@ -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", @@ -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 @@ -984,7 +984,7 @@ impl TreeBuilderActions } 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()) { 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..3ed0cb28 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; @@ -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..f20dd481 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; @@ -402,7 +403,7 @@ impl 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 { + let can_close: fn(QualName) -> bool = match tag.name { atom!("li") => close_list, atom!("dd") | atom!("dt") => close_defn, _ => unreachable!(), @@ -511,7 +512,7 @@ impl TreeBuilderStep } tag @ => { - let scope: fn(::string_cache::QualName) -> bool = match tag.name { + let scope: fn(QualName) -> bool = match tag.name { atom!("li") => list_item_scope, _ => default_scope, }; 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>(mut lines: It) -> Vec> { @@ -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)) } } From e911eba597e083a216d0a91c5eab29923e09bbfc Mon Sep 17 00:00:00 2001 From: Simon Sapin Date: Sat, 29 Oct 2016 14:14:55 +0200 Subject: [PATCH 5/8] Use local_name! macro instead of atom! --- macros/match_token.rs | 10 +- src/macros.rs | 5 - src/serialize/mod.rs | 20 +-- src/tree_builder/actions.rs | 264 ++++++++++++++++++------------------ src/tree_builder/mod.rs | 12 +- src/tree_builder/rules.rs | 146 ++++++++++---------- 6 files changed, 226 insertions(+), 231 deletions(-) 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/macros.rs b/src/macros.rs index d6012469..82815191 100644 --- a/src/macros.rs +++ b/src/macros.rs @@ -7,11 +7,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// FIXME: remove this -macro_rules! atom { - ($string: tt) => { local_name!($string) } -} - macro_rules! unwrap_or_else { ($opt:expr, $else_block:block) => { match $opt { diff --git a/src/serialize/mod.rs b/src/serialize/mod.rs index 007361a8..88736fce 100644 --- a/src/serialize/mod.rs +++ b/src/serialize/mod.rs @@ -134,7 +134,7 @@ 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:")); } } @@ -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/tree_builder/actions.rs b/src/tree_builder/actions.rs index 987aa831..6a2e0893 100644 --- a/src/tree_builder/actions.rs +++ b/src/tree_builder/actions.rs @@ -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. @@ -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 @@ -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, }, @@ -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,43 +942,43 @@ 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"), _ => (), } } @@ -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/mod.rs b/src/tree_builder/mod.rs index 3ed0cb28..cb036b3e 100644 --- a/src/tree_builder/mod.rs +++ b/src/tree_builder/mod.rs @@ -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 } diff --git a/src/tree_builder/rules.rs b/src/tree_builder/rules.rs index f20dd481..daab070b 100644 --- a/src/tree_builder/rules.rs +++ b/src/tree_builder/rules.rs @@ -103,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) } }), @@ -128,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 { @@ -166,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(); @@ -256,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) } }), @@ -277,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); } @@ -293,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) }, @@ -331,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 { @@ -341,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 { @@ -360,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); @@ -387,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); } } @@ -404,8 +404,8 @@ impl<Handle, Sink> TreeBuilderStep declare_tag_set!(close_defn = "dd" "dt"); declare_tag_set!(extra_special = [special_tag] - "address" "div" "p"); let can_close: fn(QualName) -> bool = match tag.name { - atom!("li") => close_list, - atom!("dd") | atom!("dt") => close_defn, + local_name!("li") => close_list, + local_name!("dd") | local_name!("dt") => close_defn, _ => unreachable!(), }; @@ -444,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); @@ -469,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 => { @@ -489,23 +489,23 @@ 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 @@ -513,7 +513,7 @@ impl<Handle, Sink> TreeBuilderStep tag @ </li> </dd> </dt> => { let scope: fn(QualName) -> bool = match tag.name { - atom!("li") => list_item_scope, + local_name!("li") => list_item_scope, _ => default_scope, }; if self.in_scope_named(|x| scope(x), tag.name.clone()) { @@ -553,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); @@ -608,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(); @@ -626,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); @@ -637,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 })) } @@ -685,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(); @@ -694,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(); @@ -703,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); @@ -714,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); @@ -735,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(); @@ -760,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); } @@ -770,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); @@ -811,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) } @@ -824,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 @@ -839,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); @@ -867,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 @@ -922,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 } @@ -959,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 { @@ -975,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 { @@ -996,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) } @@ -1039,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); @@ -1051,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) @@ -1063,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 @@ -1129,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); @@ -1137,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); @@ -1149,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); @@ -1163,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); @@ -1172,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 @@ -1187,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 @@ -1206,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 @@ -1258,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(); @@ -1322,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; } } From 981eb7d10876c9aa46be13a4cc0534fe2be87305 Mon Sep 17 00:00:00 2001 From: Simon Sapin <simon.sapin@exyr.org> Date: Sun, 30 Oct 2016 19:51:02 +0100 Subject: [PATCH 6/8] Add a Prefix atom --- atoms/build.rs | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/atoms/build.rs b/atoms/build.rs index 7b7c5eac..7c292ded 100644 --- a/atoms/build.rs +++ b/atoms/build.rs @@ -38,6 +38,11 @@ fn main() { } 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) From d5f581eab0f225951e6259f128eec173fdd2e961 Mon Sep 17 00:00:00 2001 From: Simon Sapin <simon.sapin@exyr.org> Date: Sun, 30 Oct 2016 19:51:07 +0100 Subject: [PATCH 7/8] Add static atoms used by Servo --- atoms/build.rs | 1 + atoms/local_names.txt | 28 ++++++++++++++++++++++++++++ 2 files changed, 29 insertions(+) diff --git a/atoms/build.rs b/atoms/build.rs index 7c292ded..c8df8e2d 100644 --- a/atoms/build.rs +++ b/atoms/build.rs @@ -17,6 +17,7 @@ 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/"), diff --git a/atoms/local_names.txt b/atoms/local_names.txt index 9d7f8211..45b6ef4b 100644 --- a/atoms/local_names.txt +++ b/atoms/local_names.txt @@ -1,3 +1,4 @@ +* a abbr abs @@ -113,6 +114,7 @@ basefont baseline baseline-shift bbox +bdi bdo begin bevelled @@ -120,6 +122,7 @@ bgcolor bgsound bias big +blink blockquote body border @@ -201,6 +204,7 @@ d data datafld dataformatas +datalist datasrc datatemplate datetime @@ -224,6 +228,7 @@ diff diffuseConstant dir direction +dirname disabled discard display @@ -257,6 +262,7 @@ equalcolumns equalrows equivalent eulergamma +event exists exp exponent @@ -327,7 +333,12 @@ for forall foreignObject form +formaction format +formenctype +formmethod +formnovalidate +formtarget frame frameborder frameset @@ -501,6 +512,7 @@ mfrac mglyph mi min +minlength minsize minus missing-glyph @@ -513,6 +525,7 @@ moment momentabout movablelimits mover +mozbrowser mpadded mpath mphantom @@ -530,6 +543,7 @@ mtable mtd mtext mtr +multicol multiple munder munderover @@ -539,6 +553,7 @@ naturalnumbers nav neq nest +nextid nobr noembed noframes @@ -553,6 +568,7 @@ notation notin notprsubset notsubset +novalidate nowrap numOctaves object @@ -605,12 +621,14 @@ onfocusin onfocusout onformchange onforminput +onhashchange onhelp oninput oninvalid onkeydown onkeypress onkeyup +onlanguagechange onload onlosecapture onmessage @@ -625,7 +643,12 @@ onmousewheel onmove onmoveend onmovestart +onoffline +ononline +onpagehide +onpageshow onpaste +onpopstate onpropertychange onreadystatechange onrepeat @@ -640,6 +663,7 @@ onselect onselectstart onstart onstop +onstorage onsubmit onunload onzoom @@ -675,6 +699,7 @@ pi piece piecewise ping +placeholder plaintext plus pointer-events @@ -688,6 +713,7 @@ poster power pre prefetch +preload preserveAlpha preserveAspectRatio primes @@ -783,11 +809,13 @@ show sin sinh size +sizes slope small solidcolor source space +spacer spacing span specification From 4f768641c0e0eab792bf67d34cd835deb26486da Mon Sep 17 00:00:00 2001 From: Simon Sapin <simon.sapin@exyr.org> Date: Sun, 30 Oct 2016 22:39:02 +0100 Subject: [PATCH 8/8] HeapSizeOf for QualName --- atoms/Cargo.toml | 5 +++++ atoms/lib.rs | 3 +++ 2 files changed, 8 insertions(+) diff --git a/atoms/Cargo.toml b/atoms/Cargo.toml index 90d81ab8..3478201d 100644 --- a/atoms/Cargo.toml +++ b/atoms/Cargo.toml @@ -11,8 +11,13 @@ 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/lib.rs b/atoms/lib.rs index c197a1a8..08975a0f 100644 --- a/atoms/lib.rs +++ b/atoms/lib.rs @@ -7,6 +7,9 @@ // 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"));