OpenE2K
/
rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Converted fourcc! to loadable syntax extension

This commit is contained in:
Derek Guenther 2014-01-30 19:05:04 -06:00
parent c1cc7e5f16
commit 97078d43b2
12 changed files with 225 additions and 118 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
mk/crates.mk
View File

@ -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

158
src/libfourcc/lib.rs Normal file
View File

@ -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() { }

5
src/librustc/front/feature_gate.rs
View File

@ -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);

5
src/libsyntax/ext/base.rs
View File

@ -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));

106
src/libsyntax/ext/fourcc.rs
View File

@ -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)
}

1
src/libsyntax/lib.rs
View File

@ -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;

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

@ -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!

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

@ -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!
}

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

@ -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!
}

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

@ -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!
}

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

@ -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!
}

12
src/test/run-pass/syntax-extension-fourcc.rs → src/test/run-pass-fulldeps/syntax-extension-fourcc.rs
View File

@ -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);