Converted fourcc! to loadable syntax extension

mk/crates.mk

@@ -50,7 +50,7 @@
 ################################################################################
 
 TARGET_CRATES := std extra green rustuv native flate arena glob term semver \
-                 uuid serialize sync getopts collections
+                 uuid serialize sync getopts collections fourcc
 HOST_CRATES := syntax rustc rustdoc
 CRATES := $(TARGET_CRATES) $(HOST_CRATES)
 TOOLS := compiletest rustdoc rustc
@@ -74,6 +74,7 @@ DEPS_uuid := std serialize
 DEPS_sync := std
 DEPS_getopts := std
 DEPS_collections := std serialize
+DEPS_fourcc := syntax std
 
 TOOL_DEPS_compiletest := extra green rustuv getopts
 TOOL_DEPS_rustdoc := rustdoc green rustuv

src/libfourcc/lib.rs

@@ -0,0 +1,158 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+/*!
+Syntax extension to generate FourCCs.
+
+Once loaded, fourcc!() is called with a single 4-character string,
+and an optional ident that is either `big`, `little`, or `target`.
+The ident represents endianness, and specifies in which direction
+the characters should be read. If the ident is omitted, it is assumed
+to be `big`, i.e. left-to-right order. It returns a u32.
+
+# Examples
+
+To load the extension and use it:
+
+```rust,ignore
+#[phase(syntax)]
+extern mod fourcc;
+
+fn main() {
+    let val = fourcc!("\xC0\xFF\xEE!")
+    // val is 0xC0FFEE21
+    let big_val = fourcc!("foo ", big);
+    // big_val is 0x21EEFFC0
+}
+ ```
+
+# References
+
+* [Wikipedia: FourCC](http://en.wikipedia.org/wiki/FourCC)
+
+*/
+
+#[crate_id = "fourcc#0.10-pre"];
+#[crate_type = "rlib"];
+#[crate_type = "dylib"];
+#[license = "MIT/ASL2"];
+
+#[feature(macro_registrar, managed_boxes)];
+
+extern mod syntax;
+
+use syntax::ast;
+use syntax::ast::Name;
+use syntax::attr::contains;
+use syntax::codemap::{Span, mk_sp};
+use syntax::ext::base;
+use syntax::ext::base::{SyntaxExtension, BasicMacroExpander, NormalTT, ExtCtxt, MRExpr};
+use syntax::ext::build::AstBuilder;
+use syntax::parse;
+use syntax::parse::token;
+use syntax::parse::token::InternedString;
+
+#[macro_registrar]
+#[cfg(not(test))]
+pub fn macro_registrar(register: |Name, SyntaxExtension|) {
+    register(token::intern("fourcc"),
+        NormalTT(~BasicMacroExpander {
+            expander: expand_syntax_ext,
+            span: None,
+        },
+        None));
+}
+
+use std::ascii::AsciiCast;
+
+pub fn expand_syntax_ext(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree]) -> base::MacResult {
+    let (expr, endian) = parse_tts(cx, tts);
+
+    let little = match endian {
+        None => target_endian_little(cx, sp),
+        Some(Ident{ident, span}) => match token::get_ident(ident.name).get() {
+            "little" => true,
+            "big" => false,
+            _ => {
+                cx.span_err(span, "invalid endian directive in fourcc!");
+                target_endian_little(cx, sp)
+            }
+        }
+    };
+
+    let s = match expr.node {
+        // expression is a literal
+        ast::ExprLit(lit) => match lit.node {
+            // string literal
+            ast::LitStr(ref s, _) => {
+                if !s.get().is_ascii() {
+                    cx.span_err(expr.span, "non-ascii string literal in fourcc!");
+                } else if s.get().len() != 4 {
+                    cx.span_err(expr.span, "string literal with len != 4 in fourcc!");
+                }
+                s
+            }
+            _ => {
+                cx.span_err(expr.span, "unsupported literal in fourcc!");
+                return MRExpr(cx.expr_lit(sp, ast::LitUint(0u64, ast::TyU32)));
+            }
+        },
+        _ => {
+            cx.span_err(expr.span, "non-literal in fourcc!");
+            return MRExpr(cx.expr_lit(sp, ast::LitUint(0u64, ast::TyU32)));
+        }
+    };
+
+    let mut val = 0u32;
+    if little {
+        for byte in s.get().bytes_rev().take(4) {
+            val = (val << 8) | (byte as u32);
+        }
+    } else {
+        for byte in s.get().bytes().take(4) {
+            val = (val << 8) | (byte as u32);
+        }
+    }
+    let e = cx.expr_lit(sp, ast::LitUint(val as u64, ast::TyU32));
+    MRExpr(e)
+}
+
+struct Ident {
+    ident: ast::Ident,
+    span: Span
+}
+
+fn parse_tts(cx: &ExtCtxt, tts: &[ast::TokenTree]) -> (@ast::Expr, Option<Ident>) {
+    let p = &mut parse::new_parser_from_tts(cx.parse_sess(), cx.cfg(), tts.to_owned());
+    let ex = p.parse_expr();
+    let id = if p.token == token::EOF {
+        None
+    } else {
+        p.expect(&token::COMMA);
+        let lo = p.span.lo;
+        let ident = p.parse_ident();
+        let hi = p.last_span.hi;
+        Some(Ident{ident: ident, span: mk_sp(lo, hi)})
+    };
+    if p.token != token::EOF {
+        p.unexpected();
+    }
+    (ex, id)
+}
+
+fn target_endian_little(cx: &ExtCtxt, sp: Span) -> bool {
+    let meta = cx.meta_name_value(sp, InternedString::new("target_endian"),
+        ast::LitStr(InternedString::new("little"), ast::CookedStr));
+    contains(cx.cfg(), meta)
+}
+
+// Fixes LLVM assert on Windows
+#[test]
+fn dummy_test() { }

src/librustc/front/feature_gate.rs

@@ -210,10 +210,13 @@ impl Visitor<()> for Context {
             self.gate_feature("log_syntax", path.span, "`log_syntax!` is not \
                 stable enough for use and is subject to change");
         }
+
         else if id == self.sess.ident_of("trace_macros") {
             self.gate_feature("trace_macros", path.span, "`trace_macros` is not \
                 stable enough for use and is subject to change");
-        } else {
+        }
+
+        else {
             for &quote in quotes.iter() {
                 if id == self.sess.ident_of(quote) {
                   self.gate_feature("quote", path.span, quote + msg);

src/libsyntax/ext/base.rs

@@ -1,4 +1,4 @@
-// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -194,9 +194,6 @@ pub fn syntax_expander_table() -> SyntaxEnv {
     syntax_expanders.insert(intern("bytes"),
                             builtin_normal_expander(
                                     ext::bytes::expand_syntax_ext));
-    syntax_expanders.insert(intern("fourcc"),
-                            builtin_normal_tt_no_ctxt(
-                                    ext::fourcc::expand_syntax_ext));
     syntax_expanders.insert(intern("concat_idents"),
                             builtin_normal_expander(
                                     ext::concat_idents::expand_syntax_ext));

src/libsyntax/ext/fourcc.rs

@@ -1,106 +0,0 @@
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-/* The compiler code necessary to support the fourcc! extension. */
-
-// fourcc!() is called with a single 4-character string, and an optional ident
-// that is either `big` or `little`. If the ident is omitted it is assumed to
-// be the platform-native value. It returns a u32.
-
-use ast;
-use attr::contains;
-use codemap::{Span, mk_sp};
-use ext::base::*;
-use ext::base;
-use ext::build::AstBuilder;
-use parse;
-use parse::token;
-
-use std::ascii::AsciiCast;
-
-pub fn expand_syntax_ext(cx: @ExtCtxt, sp: Span, tts: &[ast::token_tree]) -> base::MacResult {
-    let (expr, endian) = parse_tts(cx, tts);
-
-    let little = match endian {
-        None => target_endian_little(cx, sp),
-        Some(Ident{ident, span}) => match cx.str_of(ident).as_slice() {
-            "little" => true,
-            "big" => false,
-            _ => {
-                cx.span_err(span, "invalid endian directive in fourcc!");
-                target_endian_little(cx, sp)
-            }
-        }
-    };
-
-    let s = match expr.node {
-        // expression is a literal
-        ast::ExprLit(lit) => match lit.node {
-            // string literal
-            ast::lit_str(s) => {
-                if !s.is_ascii() {
-                    cx.span_err(expr.span, "non-ascii string literal in fourcc!");
-                } else if s.len() != 4 {
-                    cx.span_err(expr.span, "string literal with len != 4 in fourcc!");
-                }
-                s
-            }
-            _ => {
-                cx.span_err(expr.span, "unsupported literal in fourcc!");
-                return MRExpr(cx.expr_lit(sp, ast::lit_uint(0u64, ast::ty_u32)));
-            }
-        },
-        _ => {
-            cx.span_err(expr.span, "non-literal in fourcc!");
-            return MRExpr(cx.expr_lit(sp, ast::lit_uint(0u64, ast::ty_u32)));
-        }
-    };
-
-    let mut val = 0u32;
-    if little {
-        for byte in s.byte_rev_iter().take(4) {
-            val = (val << 8) | (byte as u32);
-        }
-    } else {
-        for byte in s.byte_iter().take(4) {
-            val = (val << 8) | (byte as u32);
-        }
-    }
-    let e = cx.expr_lit(sp, ast::lit_uint(val as u64, ast::ty_u32));
-    MRExpr(e)
-}
-
-struct Ident {
-    ident: ast::Ident,
-    span: Span
-}
-
-fn parse_tts(cx: @ExtCtxt, tts: &[ast::token_tree]) -> (@ast::Expr, Option<Ident>) {
-    let p = parse::new_parser_from_tts(cx.parse_sess(), cx.cfg(), tts.to_owned());
-    let ex = p.parse_expr();
-    let id = if *p.token == token::EOF {
-        None
-    } else {
-        p.expect(&token::COMMA);
-        let lo = p.span.lo;
-        let ident = p.parse_ident();
-        let hi = p.last_span.hi;
-        Some(Ident{ident: ident, span: mk_sp(lo, hi)})
-    };
-    if *p.token != token::EOF {
-        p.unexpected();
-    }
-    (ex, id)
-}
-
-fn target_endian_little(cx: @ExtCtxt, sp: Span) -> bool {
-    let meta = cx.meta_name_value(sp, @"target_endian", ast::lit_str(@"little"));
-    contains(cx.cfg(), meta)
-}

src/libsyntax/lib.rs

@@ -95,7 +95,6 @@ pub mod ext {
     pub mod bytes;
     pub mod concat;
     pub mod concat_idents;
-    pub mod fourcc;
     pub mod log_syntax;
     pub mod source_util;
 

src/test/compile-fail/syntax-extension-fourcc-bad-len.rs

@@ -8,6 +8,15 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+// xfail-stage1
+// xfail-pretty
+// xfail-android
+
+#[feature(phase)];
+
+#[phase(syntax)]
+extern mod fourcc;
+
 fn main() {
     let val = fourcc!("foo"); //~ ERROR string literal with len != 4 in fourcc!
     let val2 = fourcc!("fooba"); //~ ERROR string literal with len != 4 in fourcc!

src/test/compile-fail/syntax-extension-fourcc-invalid-endian.rs

@@ -8,6 +8,15 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+// xfail-stage1
+// xfail-pretty
+// xfail-android
+
+#[feature(phase)];
+
+#[phase(syntax)]
+extern mod fourcc;
+
 fn main() {
     let val = fourcc!("foo ", bork); //~ ERROR invalid endian directive in fourcc!
 }

src/test/compile-fail/syntax-extension-fourcc-non-ascii-str.rs

@@ -1,4 +1,4 @@
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -8,6 +8,15 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+// xfail-stage1
+// xfail-pretty
+// xfail-android
+
+#[feature(phase)];
+
+#[phase(syntax)]
+extern mod fourcc;
+
 fn main() {
     let v = fourcc!("fooλ"); //~ ERROR non-ascii string literal in fourcc!
 }

src/test/compile-fail/syntax-extension-fourcc-non-literal.rs

@@ -1,4 +1,4 @@
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -8,6 +8,15 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+// xfail-stage1
+// xfail-pretty
+// xfail-android
+
+#[feature(phase)];
+
+#[phase(syntax)]
+extern mod fourcc;
+
 fn main() {
     let val = fourcc!(foo); //~ ERROR non-literal in fourcc!
 }

src/test/compile-fail/syntax-extension-fourcc-unsupported-literal.rs

@@ -1,4 +1,4 @@
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -8,6 +8,15 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+// xfail-stage1
+// xfail-pretty
+// xfail-android
+
+#[feature(phase)];
+
+#[phase(syntax)]
+extern mod fourcc;
+
 fn main() {
-    let val = fourcc!(45f); //~ ERROR unsupported literal in fourcc!
+    let val = fourcc!(45f32); //~ ERROR unsupported literal in fourcc!
 }

src/test/run-pass-fulldeps/syntax-extension-fourcc.rs

@@ -1,4 +1,4 @@
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -8,6 +8,16 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+// xfail-fast Feature gating doesn't work
+// xfail-stage1
+// xfail-pretty
+// xfail-android
+
+#[feature(phase)];
+
+#[phase(syntax)]
+extern mod fourcc;
+
 static static_val: u32 = fourcc!("foo ");
 static static_val_le: u32 = fourcc!("foo ", little);
 static static_val_be: u32 = fourcc!("foo ", big);