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/filecheck/src/error.rs

@@ -0,0 +1,69 @@
+use std::result;
+use std::convert::From;
+use std::error::Error as StdError;
+use std::fmt;
+use regex;
+
+/// A result from the filecheck library.
+pub type Result<T> = result::Result<T, Error>;
+
+/// A filecheck error.
+#[derive(Debug)]
+pub enum Error {
+    /// A syntax error in a check line.
+    Syntax(String),
+    /// A check refers to an undefined variable.
+    ///
+    /// The pattern contains `$foo` where the `foo` variable has not yet been defined.
+    /// Use `$$` to match a literal dollar sign.
+    UndefVariable(String),
+    /// A pattern contains a back-reference to a variable that was defined in the same pattern.
+    ///
+    /// For example, `check: Hello $(world=.*) $world`. Backreferences are not support. Often the
+    /// desired effect can be achieved with the `sameln` check:
+    ///
+    /// ```text
+    /// check: Hello $(world=[^ ]*)
+    /// sameln: $world
+    /// ```
+    Backref(String),
+    /// A pattern contains multiple definitions of the same variable.
+    DuplicateDef(String),
+    /// An error in a regular expression.
+    ///
+    /// Use `cause()` to get the underlying `Regex` library error.
+    Regex(regex::Error),
+}
+
+impl StdError for Error {
+    fn description(&self) -> &str {
+        use Error::*;
+        match *self {
+            Syntax(ref s) => s,
+            UndefVariable(ref s) => s,
+            Backref(ref s) => s,
+            DuplicateDef(ref s) => s,
+            Regex(ref err) => err.description(),
+        }
+    }
+
+    fn cause(&self) -> Option<&StdError> {
+        use Error::*;
+        match *self {
+            Regex(ref err) => Some(err),
+            _ => None,
+        }
+    }
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        write!(fmt, "{}", self.description())
+    }
+}
+
+impl From<regex::Error> for Error {
+    fn from(e: regex::Error) -> Error {
+        Error::Regex(e)
+    }
+}