Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-07-23 07:13:52 +01:00
Code Issues Projects Releases Packages Wiki Activity

Introduce trait Castable

Browse source 
This trait is used to hold onto the downcast and upcast functions of all
castable IDL interfaces. A castable IDL interface is one which either derives
from or is derived by other interfaces.

The deriving relation is represented by implementations of marker trait
DerivedFrom<T: Castable> generated in InheritTypes.

/^[ ]*use dom::bindings::codegen::InheritTypes::.*(Base|Cast|Derived)/ {
    /::[a-zA-Z]+(Base|Cast|Derived);/d
    s/([{ ])[a-zA-Z]+(Base|Cast|Derived), /\1/g
    s/([{ ])[a-zA-Z]+(Base|Cast|Derived), /\1/g
    s/, [a-zA-Z]+(Base|Cast|Derived)([},])/\2/g
    s/, [a-zA-Z]+(Base|Cast|Derived)([},])/\2/g
    /\{([a-zA-Z]+(Base|Cast|Derived))?\};$/d
    s/\{([a-zA-Z_]+)\};$/\1;/
}

s/([a-zA-Z]+)Cast::from_ref\(\&?\**([a-zA-Z_]+)(\.r\(\))?\)/\2.upcast::<\1>()/g
s/([a-zA-Z]+)Cast::from_ref\(\&?\**([a-zA-Z_]+)(\.[a-zA-Z_]+\(\))?\)/\2\3.upcast::<\1>()/g
s/\(([a-zA-Z]+)Cast::from_ref\)/\(Castable::upcast::<\1>\)/g

s/([a-zA-Z]+)Cast::from_root/Root::upcast::<\1>/g

s/([a-zA-Z]+)Cast::from_layout_js\(\&([a-zA-Z_.]+)\)/\2.upcast::<\1>()/g

s/([a-zA-Z]+)Cast::to_ref\(\&?\**([a-zA-Z_]+)(\.r\(\))?\)/\2.downcast::<\1>()/g
s/([a-zA-Z]+)Cast::to_ref\(\&?\**([a-zA-Z_]+)(\.[a-zA-Z_]+\(\))?\)/\2\3.downcast::<\1>()/g
s/\(([a-zA-Z]+)Cast::to_ref\)/\(Castable::downcast::<\1>\)/g

s/([a-zA-Z]+)Cast::to_root/Root::downcast::<\1>/g

s/([a-zA-Z]+)Cast::to_layout_js\(&?([a-zA-Z_.]+(\(\))?)\)/\2.downcast::<\1>()/g

s/\.is_document\(\)/.is::<Document>()/g
s/\.is_htmlanchorelement\(\)/.is::<HTMLAnchorElement>()/g
s/\.is_htmlappletelement\(\)/.is::<HTMLAppletElement>()/g
s/\.is_htmlareaelement\(\)/.is::<HTMLAreaElement>()/g
s/\.is_htmlbodyelement\(\)/.is::<HTMLBodyElement>()/g
s/\.is_htmlembedelement\(\)/.is::<HTMLEmbedElement>()/g
s/\.is_htmlfieldsetelement\(\)/.is::<HTMLFieldSetElement>()/g
s/\.is_htmlformelement\(\)/.is::<HTMLFormElement>()/g
s/\.is_htmlframesetelement\(\)/.is::<HTMLFrameSetElement>()/g
s/\.is_htmlhtmlelement\(\)/.is::<HTMLHtmlElement>()/g
s/\.is_htmlimageelement\(\)/.is::<HTMLImageElement>()/g
s/\.is_htmllegendelement\(\)/.is::<HTMLLegendElement>()/g
s/\.is_htmloptgroupelement\(\)/.is::<HTMLOptGroupElement>()/g
s/\.is_htmloptionelement\(\)/.is::<HTMLOptionElement>()/g
s/\.is_htmlscriptelement\(\)/.is::<HTMLScriptElement>()/g
s/\.is_htmltabledatacellelement\(\)/.is::<HTMLTableDataCellElement>()/g
s/\.is_htmltableheadercellelement\(\)/.is::<HTMLTableHeaderCellElement>()/g
s/\.is_htmltablerowelement\(\)/.is::<HTMLTableRowElement>()/g
s/\.is_htmltablesectionelement\(\)/.is::<HTMLTableSectionElement>()/g
s/\.is_htmltitleelement\(\)/.is::<HTMLTitleElement>()/g
This commit is contained in:
Anthony Ramine 2015-10-06 17:21:44 +02:00
parent bd363b009d
commit 13ea3ac413
82 changed files with 1124 additions and 1148 deletions
Download patch file Download diff file Expand all files Collapse all files

53
components/script/parse/html.rs
View file

@ -8,21 +8,22 @@ use document_loader::DocumentLoader;
use dom::bindings::codegen::Bindings::DocumentBinding::DocumentMethods;
use dom::bindings::codegen::Bindings::HTMLTemplateElementBinding::HTMLTemplateElementMethods;
use dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
use dom::bindings::codegen::InheritTypes::{CharacterDataCast, CharacterDataTypeId};
use dom::bindings::codegen::InheritTypes::{DocumentTypeCast, ElementCast};
use dom::bindings::codegen::InheritTypes::{HTMLFormElementDerived, HTMLScriptElementCast};
use dom::bindings::codegen::InheritTypes::{HTMLTemplateElementCast, NodeCast};
use dom::bindings::codegen::InheritTypes::{NodeTypeId, ProcessingInstructionCast};
use dom::bindings::codegen::InheritTypes::{CharacterDataTypeId, NodeTypeId};
use dom::bindings::conversions::Castable;
use dom::bindings::js::{JS, Root};
use dom::bindings::js::{RootedReference};
use dom::characterdata::CharacterData;
use dom::comment::Comment;
use dom::document::Document;
use dom::document::{DocumentSource, IsHTMLDocument};
use dom::documenttype::DocumentType;
use dom::element::{Element, ElementCreator};
use dom::htmlformelement::HTMLFormElement;
use dom::htmlscriptelement::HTMLScriptElement;
use dom::htmltemplateelement::HTMLTemplateElement;
use dom::node::Node;
use dom::node::{document_from_node, window_from_node};
use dom::processinginstruction::ProcessingInstruction;
use dom::servohtmlparser;
use dom::servohtmlparser::{FragmentContext, ServoHTMLParser};
use encoding::types::Encoding;
@ -45,15 +46,15 @@ impl<'a> TreeSink for servohtmlparser::Sink {
fn get_document(&mut self) -> JS<Node> {
let doc = self.document.root();
let node = NodeCast::from_ref(doc.r());
let node = doc.upcast::<Node>();
JS::from_ref(node)
}
fn get_template_contents(&self, target: JS<Node>) -> JS<Node> {
let target = target.root();
let template = HTMLTemplateElementCast::to_ref(&*target)
let template = target.downcast::<HTMLTemplateElement>()
.expect("tried to get template contents of non-HTMLTemplateElement in HTML parsing");
JS::from_ref(NodeCast::from_ref(&*template.Content()))
JS::from_ref(template.Content().upcast::<Node>())
}
fn same_node(&self, x: JS<Node>, y: JS<Node>) -> bool {
@ -62,7 +63,7 @@ impl<'a> TreeSink for servohtmlparser::Sink {
fn elem_name(&self, target: JS<Node>) -> QualName {
let node: Root<Node> = target.root();
let elem = ElementCast::to_ref(node.r())
let elem = node.downcast::<Element>()
.expect("tried to get name of non-Element in HTML parsing");
QualName {
ns: elem.namespace().clone(),
@ -80,14 +81,14 @@ impl<'a> TreeSink for servohtmlparser::Sink {
elem.r().set_attribute_from_parser(attr.name, attr.value.into(), None);
}
let node = NodeCast::from_ref(elem.r());
let node = elem.upcast::<Node>();
JS::from_ref(node)
}
fn create_comment(&mut self, text: StrTendril) -> JS<Node> {
let doc = self.document.root();
let comment = Comment::new(text.into(), doc.r());
let node = NodeCast::from_root(comment);
let node = Root::upcast::<Node>(comment);
JS::from_rooted(&node)
}
@ -126,17 +127,17 @@ impl<'a> TreeSink for servohtmlparser::Sink {
fn append_doctype_to_document(&mut self, name: StrTendril, public_id: StrTendril,
system_id: StrTendril) {
let doc = self.document.root();
let doc_node = NodeCast::from_ref(doc.r());
let doc_node = doc.upcast::<Node>();
let doctype = DocumentType::new(
name.into(), Some(public_id.into()), Some(system_id.into()), doc.r());
let node: Root<Node> = NodeCast::from_root(doctype);
let node: Root<Node> = Root::upcast::<Node>(doctype);
assert!(doc_node.AppendChild(node.r()).is_ok());
}
fn add_attrs_if_missing(&mut self, target: JS<Node>, attrs: Vec<Attribute>) {
let node: Root<Node> = target.root();
let elem = ElementCast::to_ref(node.r())
let elem = node.downcast::<Element>()
.expect("tried to set attrs on non-Element in HTML parsing");
for attr in attrs {
elem.set_attribute_from_parser(attr.name, attr.value.into(), None);
@ -152,13 +153,13 @@ impl<'a> TreeSink for servohtmlparser::Sink {
fn mark_script_already_started(&mut self, node: JS<Node>) {
let node: Root<Node> = node.root();
let script: Option<&HTMLScriptElement> = HTMLScriptElementCast::to_ref(node.r());
let script: Option<&HTMLScriptElement> = node.downcast::<HTMLScriptElement>();
script.map(|script| script.mark_already_started());
}
fn complete_script(&mut self, node: JS<Node>) -> NextParserState {
let node: Root<Node> = node.root();
let script: Option<&HTMLScriptElement> = HTMLScriptElementCast::to_ref(node.r());
let script: Option<&HTMLScriptElement> = node.downcast::<HTMLScriptElement>();
if let Some(script) = script {
return script.prepare();
}
@ -183,7 +184,7 @@ impl<'a> Serializable for &'a Node {
let node = *self;
match (traversal_scope, node.type_id()) {
(_, NodeTypeId::Element(..)) => {
let elem = ElementCast::to_ref(node).unwrap();
let elem = node.downcast::<Element>().unwrap();
let name = QualName::new(elem.namespace().clone(),
elem.local_name().clone());
if traversal_scope == IncludeNode {
@ -201,9 +202,9 @@ impl<'a> Serializable for &'a Node {
try!(serializer.start_elem(name.clone(), attr_refs));
}
let children = if let Some(tpl) = HTMLTemplateElementCast::to_ref(node) {
let children = if let Some(tpl) = node.downcast::<HTMLTemplateElement>() {
// https://github.com/w3c/DOM-Parsing/issues/1
NodeCast::from_ref(&*tpl.Content()).children()
tpl.Content().upcast::<Node>().children()
} else {
node.children()
};
@ -228,23 +229,23 @@ impl<'a> Serializable for &'a Node {
(ChildrenOnly, _) => Ok(()),
(IncludeNode, NodeTypeId::DocumentType) => {
let doctype = DocumentTypeCast::to_ref(node).unwrap();
let doctype = node.downcast::<DocumentType>().unwrap();
serializer.write_doctype(&doctype.name())
},
(IncludeNode, NodeTypeId::CharacterData(CharacterDataTypeId::Text)) => {
let cdata = CharacterDataCast::to_ref(node).unwrap();
let cdata = node.downcast::<CharacterData>().unwrap();
serializer.write_text(&cdata.data())
},
(IncludeNode, NodeTypeId::CharacterData(CharacterDataTypeId::Comment)) => {
let cdata = CharacterDataCast::to_ref(node).unwrap();
let cdata = node.downcast::<CharacterData>().unwrap();
serializer.write_comment(&cdata.data())
},
(IncludeNode, NodeTypeId::CharacterData(CharacterDataTypeId::ProcessingInstruction)) => {
let pi = ProcessingInstructionCast::to_ref(node).unwrap();
let data = CharacterDataCast::from_ref(pi).data();
let pi = node.downcast::<ProcessingInstruction>().unwrap();
let data = pi.upcast::<CharacterData>().data();
serializer.write_processing_instruction(&pi.target(), &data)
},
@ -295,7 +296,7 @@ pub fn parse_html_fragment(context_node: &Node,
// Step 11.
let form = context_node.inclusive_ancestors()
.find(|element| element.r().is_htmlformelement());
.find(|element| element.r().is::<HTMLFormElement>());
let fragment_context = FragmentContext {
context_elem: context_node,
form_elem: form.r(),
@ -304,7 +305,7 @@ pub fn parse_html_fragment(context_node: &Node,
// Step 14.
let root_element = document.r().GetDocumentElement().expect("no document element");
let root_node = NodeCast::from_ref(root_element.r());
let root_node = root_element.upcast::<Node>();
for child in root_node.children() {
output.AppendChild(child.r()).unwrap();
}