Move library crates under 'lib/'.

Give these crates each a more standard directory layout with sources in
a 'src' sub-sirectory and Cargo.toml in the top lib/foo directory.

Add license and description fields to each.

The build script for the cretonne crate now lives in
'lib/cretonne/build.rs' separating it from the normal library sources
under 'lib/cretonne/src'.

lib/reader/src/testcommand.rs

@@ -0,0 +1,88 @@
+//! Test commands.
+//!
+//! A `.cton` file can begin with one or more *test commands* which specify what is to be tested.
+//! The general syntax is:
+//!
+//! <pre>
+//! test <i>&lt;command&gt;</i> </i>[options]</i>...
+//! </pre>
+//!
+//! The options are either a single identifier flag, or setting values like `identifier=value`.
+//!
+//! The parser does not understand the test commands or which options are alid. It simply parses
+//! the general format into a `TestCommand` data structure.
+
+use std::fmt::{self, Display, Formatter};
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct TestCommand<'a> {
+    pub command: &'a str,
+    pub options: Vec<TestOption<'a>>,
+}
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub enum TestOption<'a> {
+    Flag(&'a str),
+    Value(&'a str, &'a str),
+}
+
+impl<'a> TestCommand<'a> {
+    pub fn new(s: &'a str) -> TestCommand<'a> {
+        let mut parts = s.split_whitespace();
+        let cmd = parts.next().unwrap_or("");
+        TestCommand {
+            command: cmd,
+            options: parts.filter(|s| !s.is_empty()).map(TestOption::new).collect(),
+        }
+    }
+}
+
+impl<'a> Display for TestCommand<'a> {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        try!(write!(f, "{}", self.command));
+        for opt in &self.options {
+            try!(write!(f, " {}", opt));
+        }
+        writeln!(f, "")
+    }
+}
+
+impl<'a> TestOption<'a> {
+    pub fn new(s: &'a str) -> TestOption<'a> {
+        match s.find('=') {
+            None => TestOption::Flag(s),
+            Some(p) => TestOption::Value(&s[0..p], &s[p + 1..]),
+        }
+    }
+}
+
+impl<'a> Display for TestOption<'a> {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        match *self {
+            TestOption::Flag(s) => write!(f, "{}", s),
+            TestOption::Value(s, v) => write!(f, "{}={}", s, v),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parse_option() {
+        assert_eq!(TestOption::new(""), TestOption::Flag(""));
+        assert_eq!(TestOption::new("foo"), TestOption::Flag("foo"));
+        assert_eq!(TestOption::new("foo=bar"), TestOption::Value("foo", "bar"));
+    }
+
+    #[test]
+    fn parse_command() {
+        assert_eq!(&TestCommand::new("").to_string(), "\n");
+        assert_eq!(&TestCommand::new("cat").to_string(), "cat\n");
+        assert_eq!(&TestCommand::new("cat  ").to_string(), "cat\n");
+        assert_eq!(&TestCommand::new("cat  1  ").to_string(), "cat 1\n");
+        assert_eq!(&TestCommand::new("cat  one=4   two t").to_string(),
+                   "cat one=4 two t\n");
+    }
+}