Allow building the library without libstd at all

Author: kmcallister

macros/src/lib.rs

@@ -22,9 +22,6 @@ use rustc::plugin::Registry;
 // Internal macros for use in defining other macros.
 mod internal;
 
-// Exported non-procedural macros.
-pub mod exported;
-
 // Make these public so that rustdoc will generate documentation for them.
 pub mod named_entities;
 pub mod atom;

src/lib.rs

@@ -17,13 +17,19 @@
 // This helps us make a C-friendly library.
 #![no_std]
 
-extern crate core;
 extern crate alloc;
-extern crate collections;
 
+#[phase(plugin, link)]
+extern crate core;
+
+#[cfg(not(for_c))]
 #[phase(plugin, link)]
 extern crate std;
 
+#[phase(plugin, link)]
+extern crate collections;
+
+#[cfg(not(for_c))]
 #[phase(plugin, link)]
 extern crate log;
 
@@ -47,8 +53,12 @@ pub use util::atom::Atom;
 pub use util::namespace::Namespace;
 
 pub use driver::{one_input, ParseOpts, parse_to, parse};
+
+#[cfg(not(for_c))]
 pub use serialize::serialize;
 
+mod macros;
+
 mod util {
     #![macro_escape]
 
@@ -60,13 +70,24 @@ mod util {
 
 pub mod tokenizer;
 pub mod tree_builder;
+
+#[cfg(not(for_c))]
 pub mod serialize;
 
 /// Consumers of the parser API.
+#[cfg(not(for_c))]
 pub mod sink {
     pub mod common;
     pub mod rcdom;
     pub mod owned_dom;
 }
 
 pub mod driver;
+
+/// A fake `std` module so that `deriving` and other macros will work.
+/// See rust-lang/rust#16803.
+#[cfg(for_c)]
+mod std {
+    pub use core::{clone, cmp, default, fmt, option, str};
+    pub use collections::hash;
+}

macros/src/exported.rs renamed to src/macros.rs

@@ -7,17 +7,15 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! Exported non-procedural macros.
+#![macro_escape]
 
-#[macro_export]
 macro_rules! unwrap_or_return ( ($opt:expr, $retval:expr) => (
     match $opt {
         None => return $retval,
         Some(x) => x,
     }
 ))
 
-#[macro_export]
 macro_rules! test_eq ( ($name:ident, $left:expr, $right:expr) => (
     #[test]
     fn $name() {
@@ -26,7 +24,6 @@ macro_rules! test_eq ( ($name:ident, $left:expr, $right:expr) => (
 ))
 
 /// Make a tuple of the addresses of some of a struct's fields.
-#[macro_export]
 macro_rules! addrs_of ( ($obj:expr : $($field:ident),+) => (
     ( // make a tuple
         $(
@@ -37,7 +34,13 @@ macro_rules! addrs_of ( ($obj:expr : $($field:ident),+) => (
     )
 ))
 
-#[macro_export]
+// No format!() without libstd... just use the static message.
+#[cfg(for_c)]
+macro_rules! format_if ( ($pred:expr, $msg_static:expr, $msg_fmt:expr, $($arg:expr),*) => (
+    ::collections::str::Slice($msg_static)
+))
+
+#[cfg(not(for_c))]
 macro_rules! format_if ( ($pred:expr, $msg_static:expr, $msg_fmt:expr, $($arg:expr),*) => (
     if $pred {
         ::collections::str::Owned(format!($msg_fmt, $($arg),*))
@@ -46,10 +49,42 @@ macro_rules! format_if ( ($pred:expr, $msg_static:expr, $msg_fmt:expr, $($arg:ex
     }
 ))
 
-#[macro_export]
 macro_rules! time ( ($e:expr) => ({
     let t0 = ::time::precise_time_ns();
     let result = $e;
     let dt = ::time::precise_time_ns() - t0;
     (result, dt)
 }))
+
+/// FIXME(rust-lang/rust#16806): copied from libcollections/macros.rs
+#[cfg(for_c)]
+macro_rules! vec(
+    ($($e:expr),*) => ({
+        // leading _ to allow empty construction without a warning.
+        let mut _temp = ::collections::vec::Vec::new();
+        $(_temp.push($e);)*
+        _temp
+    });
+    ($($e:expr),+,) => (vec!($($e),+))
+)
+
+// Disable logging when building without the runtime.
+#[cfg(for_c)]
+mod log {
+    #![macro_escape]
+    macro_rules! h5e_log   (($($x:tt)*) => (()))
+    macro_rules! h5e_debug (($($x:tt)*) => (()))
+    macro_rules! h5e_info  (($($x:tt)*) => (()))
+    macro_rules! h5e_warn  (($($x:tt)*) => (()))
+    macro_rules! h5e_error (($($x:tt)*) => (()))
+}
+
+#[cfg(not(for_c))]
+mod log {
+    #![macro_escape]
+    macro_rules! h5e_log   (($($x:tt)*) => (log!($($x)*)))
+    macro_rules! h5e_debug (($($x:tt)*) => (debug!($($x)*)))
+    macro_rules! h5e_info  (($($x:tt)*) => (info!($($x)*)))
+    macro_rules! h5e_warn  (($($x:tt)*) => (warn!($($x)*)))
+    macro_rules! h5e_error (($($x:tt)*) => (error!($($x)*)))
+}

src/tokenizer/char_ref/mod.rs

@@ -115,7 +115,7 @@ impl<'sink, Sink: TokenSink> CharRefTokenizer {
             return Done;
         }
 
-        debug!("char ref tokenizer stepping in state {:?}", self.state);
+        h5e_debug!("char ref tokenizer stepping in state {:?}", self.state);
         match self.state {
             Begin => self.do_begin(tokenizer),
             Octothorpe => self.do_octothorpe(tokenizer),

src/tokenizer/mod.rs

@@ -31,13 +31,12 @@ use util::atom::Atom;
 use util::smallcharset::SmallCharSet;
 
 use core::mem::replace;
-use core::iter::AdditiveIterator;
 use core::default::Default;
 use alloc::boxed::Box;
 use collections::{MutableSeq, MutableMap};
 use collections::vec::Vec;
 use collections::string::String;
-use collections::str::{MaybeOwned, Slice, Owned};
+use collections::str::{MaybeOwned, Slice};
 use collections::treemap::TreeMap;
 
 pub mod states;
@@ -176,6 +175,10 @@ pub struct Tokenizer<'sink, Sink> {
 impl<'sink, Sink: TokenSink> Tokenizer<'sink, Sink> {
     /// Create a new tokenizer which feeds tokens to a particular `TokenSink`.
     pub fn new(sink: &'sink mut Sink, mut opts: TokenizerOpts) -> Tokenizer<'sink, Sink> {
+        if opts.profile && cfg!(for_c) {
+            fail!("Can't profile tokenizer when built as a C library");
+        }
+
         let start_tag_name = opts.last_start_tag_name.take().map(|s| Atom::from_buf(s));
         let state = *opts.initial_state.as_ref().unwrap_or(&states::Data);
         let discard_bom = opts.discard_bom;
@@ -253,11 +256,13 @@ impl<'sink, Sink: TokenSink> Tokenizer<'sink, Sink> {
             n if (n & 0xFFFE) == 0xFFFE => true,
             _ => false,
         } {
-            let msg = Owned(format!("Bad character {:?}", c));
+            // format_if!(true) will still use the static error when built for C.
+            let msg = format_if!(true, "Bad character",
+                "Bad character {:?}", c);
             self.emit_error(msg);
         }
 
-        debug!("got character {:?}", c);
+        h5e_debug!("got character {:?}", c);
         self.current_char = c;
         Some(c)
     }
@@ -284,7 +289,7 @@ impl<'sink, Sink: TokenSink> Tokenizer<'sink, Sink> {
         }
 
         let d = self.input_buffers.pop_except_from(set);
-        debug!("got characters {}", d);
+        h5e_debug!("got characters {}", d);
         match d {
             Some(FromSet(c)) => self.get_preprocessed_char(c).map(|x| FromSet(x)),
 
@@ -306,21 +311,21 @@ impl<'sink, Sink: TokenSink> Tokenizer<'sink, Sink> {
     fn lookahead_and_consume(&mut self, n: uint, p: |&str| -> bool) -> Option<bool> {
         match self.input_buffers.pop_front(n) {
             None if self.at_eof => {
-                debug!("lookahead: requested {:u} characters not available and never will be", n);
+                h5e_debug!("lookahead: requested {:u} characters not available and never will be", n);
                 Some(false)
             }
             None => {
-                debug!("lookahead: requested {:u} characters not available", n);
+                h5e_debug!("lookahead: requested {:u} characters not available", n);
                 self.wait_for = Some(n);
                 None
             }
             Some(s) => {
                 if p(s.as_slice()) {
-                    debug!("lookahead: condition satisfied by {:?}", s);
+                    h5e_debug!("lookahead: condition satisfied by {:?}", s);
                     // FIXME: set current input character?
                     Some(true)
                 } else {
-                    debug!("lookahead: condition not satisfied by {:?}", s);
+                    h5e_debug!("lookahead: condition not satisfied by {:?}", s);
                     self.unconsume(s);
                     Some(false)
                 }
@@ -569,7 +574,7 @@ macro_rules! shorthand (
 // so it's behind a cfg flag.
 #[cfg(trace_tokenizer)]
 macro_rules! sh_trace ( ( $me:expr : $($cmds:tt)* ) => ({
-    debug!("  {:s}", stringify!($($cmds)*));
+    h5e_debug!("  {:s}", stringify!($($cmds)*));
     shorthand!($me:expr : $($cmds)*);
 }))
 
@@ -654,17 +659,17 @@ impl<'sink, Sink: TokenSink> Tokenizer<'sink, Sink> {
 
         match self.wait_for {
             Some(n) if !self.input_buffers.has(n) => {
-                debug!("lookahead: requested {:u} characters still not available", n);
+                h5e_debug!("lookahead: requested {:u} characters still not available", n);
                 return false;
             }
-            Some(n) => {
-                debug!("lookahead: requested {:u} characters become available", n);
+            Some(_n) => {
+                h5e_debug!("lookahead: requested {:u} characters become available", _n);
                 self.wait_for = None;
             }
             None => (),
         }
 
-        debug!("processing in state {:?}", self.state);
+        h5e_debug!("processing in state {:?}", self.state);
         match self.state {
             //§ data-state
             states::Data => loop {
@@ -1255,24 +1260,36 @@ impl<'sink, Sink: TokenSink> Tokenizer<'sink, Sink> {
         }
 
         if self.opts.profile {
-            let mut results: Vec<(states::State, u64)>
-                = self.state_profile.iter().map(|(s, t)| (*s, *t)).collect();
-            results.sort_by(|&(_, x), &(_, y)| y.cmp(&x));
-
-            let total = results.iter().map(|&(_, t)| t).sum();
-            println!("\nTokenizer profile, in nanoseconds");
-            println!("\n{:12u}         total in token sink", self.time_in_sink);
-            println!("\n{:12u}         total in tokenizer", total);
-
-            for (k, v) in results.move_iter() {
-                let pct = 100.0 * (v as f64) / (total as f64);
-                println!("{:12u}  {:4.1f}%  {:?}", v, pct, k);
-            }
+            self.dump_profile();
+        }
+    }
+
+    #[cfg(for_c)]
+    fn dump_profile(&self) {
+        unreachable!();
+    }
+
+    #[cfg(not(for_c))]
+    fn dump_profile(&self) {
+        use core::iter::AdditiveIterator;
+
+        let mut results: Vec<(states::State, u64)>
+            = self.state_profile.iter().map(|(s, t)| (*s, *t)).collect();
+        results.sort_by(|&(_, x), &(_, y)| y.cmp(&x));
+
+        let total = results.iter().map(|&(_, t)| t).sum();
+        println!("\nTokenizer profile, in nanoseconds");
+        println!("\n{:12u}         total in token sink", self.time_in_sink);
+        println!("\n{:12u}         total in tokenizer", total);
+
+        for (k, v) in results.move_iter() {
+            let pct = 100.0 * (v as f64) / (total as f64);
+            println!("{:12u}  {:4.1f}%  {:?}", v, pct, k);
         }
     }
 
     fn eof_step(&mut self) -> bool {
-        debug!("processing EOF in state {:?}", self.state);
+        h5e_debug!("processing EOF in state {:?}", self.state);
         match self.state {
             states::Data | states::RawData(Rcdata) | states::RawData(Rawtext)
             | states::RawData(ScriptData) | states::Plaintext

src/tree_builder/actions.rs

@@ -24,7 +24,10 @@ use tokenizer::states::{RawData, RawKind};
 
 use util::atom::Atom;
 use util::namespace::{Namespace, HTML};
-use util::str::{to_escaped_string, AsciiExt};
+use util::str::AsciiExt;
+
+#[cfg(not(for_c))]
+use util::str::to_escaped_string;
 
 use core::mem::replace;
 use core::iter::{Rev, Enumerate};
@@ -108,11 +111,11 @@ pub trait TreeBuilderActions<Handle> {
 impl<'sink, Handle: Clone, Sink: TreeSink<Handle>>
     TreeBuilderActions<Handle> for super::TreeBuilder<'sink, Handle, Sink> {
 
-    fn unexpected<T: Show>(&mut self, thing: &T) -> ProcessResult {
+    fn unexpected<T: Show>(&mut self, _thing: &T) -> ProcessResult {
         self.sink.parse_error(format_if!(
             self.opts.exact_errors,
             "Unexpected token",
-            "Unexpected token {} in insertion mode {}", to_escaped_string(thing), self.mode));
+            "Unexpected token {} in insertion mode {}", to_escaped_string(_thing), self.mode));
         Done
     }
 
@@ -134,7 +137,7 @@ impl<'sink, Handle: Clone, Sink: TreeSink<Handle>>
     }
 
     fn stop_parsing(&mut self) -> ProcessResult {
-        warn!("stop_parsing not implemented, full speed ahead!");
+        h5e_warn!("stop_parsing not implemented, full speed ahead!");
         Done
     }
 
@@ -377,7 +380,7 @@ impl<'sink, Handle: Clone, Sink: TreeSink<Handle>>
     }
 
     fn foster_parent_in_body(&mut self, token: Token) -> ProcessResult {
-        warn!("foster parenting not implemented");
+        h5e_warn!("foster parenting not implemented");
         self.foster_parenting = true;
         let res = self.step(InBody, token);
         // FIXME: what if res is Reprocess?