Merge pull request #17 from ConnorGBrewster/add_quiescent

Added quiescent for parser interrupting

Author: Ygg01

src/tokenizer/mod.rs

@@ -315,8 +315,8 @@ impl <Sink:TokenSink> XmlTokenizer<Sink> {
         }
     }
 
-    // Run the state machine for as long as we can.
-    fn run(&mut self) {
+    /// Run the state machine for as long as we can.
+    pub fn run(&mut self) {
         if self.opts.profile {
             loop {
                 let state = self.state;
@@ -437,11 +437,9 @@ impl <Sink:TokenSink> XmlTokenizer<Sink> {
         self.process_token(token);
 
 
-        if self.current_tag_kind == StartTag {
-            match self.sink.query_state_change() {
-                None => (),
-                Some(s) => self.state = s,
-            }
+        match self.sink.query_state_change() {
+            None => (),
+            Some(s) => self.state = s,
         }
     }
 
@@ -661,6 +659,10 @@ impl<Sink: TokenSink> XmlTokenizer<Sink> {
 
         debug!("processing in state {:?}", self.state);
         match self.state {
+            XmlState::Quiescent => {
+                self.state = XmlState::Data;
+                return false;
+            },
             //§ data-state
             XmlState::Data => loop {
                 match pop_except_from!(self, small_char_set!('\r' '&' '<')) {
@@ -1054,6 +1056,7 @@ impl<Sink: TokenSink> XmlTokenizer<Sink> {
         debug!("processing EOF in state {:?}", self.state);
         match self.state {
             XmlState::Data
+            | XmlState::Quiescent
                 => go!(self: eof),
             XmlState::TagState
                 => go!(self: error_eof; emit '<'; to Data),

src/tokenizer/states.rs

@@ -63,6 +63,7 @@ pub enum XmlState {
     BetweenDoctypePublicAndSystemIdentifiers,
     BogusDoctype,
     BogusComment,
+    Quiescent,
 }
 
 #[derive(PartialEq, Eq, PartialOrd, Ord, Copy, Clone, Hash, Debug)]

src/tree_builder/actions.rs

@@ -10,7 +10,8 @@
 use std::borrow::Cow::Borrowed;
 use tendril::{StrTendril, Tendril};
 use tokenizer::{Tag, Pi, QName, Doctype};
-use tree_builder::interface::{NodeOrText, TreeSink, AppendNode, AppendText};
+use tokenizer::states::Quiescent;
+use tree_builder::interface::{NextParserState, NodeOrText, TreeSink, AppendNode, AppendText};
 use tree_builder::types::{XmlProcessResult, Done};
 
 /// Trait that encapsulates common XML tree actions.
@@ -73,6 +74,9 @@ pub trait XmlTreeBuilderActions<Handle> {
 
     /// Stops parsing of XML file.
     fn stop_parsing(&mut self) -> XmlProcessResult;
+
+    /// Indicated a `script` element is complete and can be prepared
+    fn complete_script(&mut self);
 }
 
 #[doc(hidden)]
@@ -225,4 +229,11 @@ impl<Handle, Sink> XmlTreeBuilderActions<Handle>
         warn!("stop_parsing for XML5 not implemented, full speed ahead!");
         Done
     }
+
+    fn complete_script(&mut self) {
+        let current = self.pop();
+        if self.sink.complete_script(current) == NextParserState::Suspend {
+            self.next_tokenizer_state = Some(Quiescent);
+        }
+    }
 }

src/tree_builder/interface.rs

@@ -81,6 +81,14 @@ pub trait TreeSink {
                                   name: StrTendril,
                                   public_id: StrTendril,
                                   system_id: StrTendril);
+
+    /// Mark a HTML `<script>` as "already started".
+    fn mark_script_already_started(&mut self, _node: Self::Handle) {}
+
+    /// Indicate that a `script` element is complete.
+    fn complete_script(&mut self, _node: Self::Handle) -> NextParserState {
+        NextParserState::Continue
+    }
 }
 
 /// Trace hooks for a garbage-collected DOM.

src/tree_builder/rules.rs

@@ -116,18 +116,27 @@ impl<Handle, Sink> XmlTreeBuilderStep
                         self.process_namespaces(&mut tag);
                         tag
                     };
-                    self.append_tag(tag)
+                    if tag.name.local == atom!("script") {
+                        self.insert_tag(tag.clone());
+                        self.complete_script();
+                        self.close_tag(tag)
+                    } else {
+                        self.append_tag(tag)
+                    }
                 },
                 TagToken(Tag{kind: EndTag, name, attrs}) => {
                     let tag = {
-			let mut tag = Tag {
+                        let mut tag = Tag {
                             kind: EndTag,
                             name: name,
                             attrs: attrs,
-			};
-			self.process_namespaces(&mut tag);
-			tag
+                        };
+                        self.process_namespaces(&mut tag);
+                        tag
                     };
+                    if tag.name.local == atom!("script") {
+                        self.complete_script();
+                    }
                     let retval = self.close_tag(tag);
                     if self.no_open_elems() {
                         self.phase = EndPhase;