---

yaml
---
r: 60447
b: refs/heads/auto
c: 7a2afb7
h: refs/heads/master
i:
  60445: e59e142
  60443: 1650782
  60439: 16e9f37
  60431: 685ef65
  60415: 3e4adb0
v: v3

Author: Kimundi

[refs]

@@ -14,6 +14,6 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 916942d006ce3a551505b7b0328a82b382249b7c
+refs/heads/auto: 7a2afb72884774f8e7865c625efc806fd09e693b
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c

branches/auto/src/libsyntax/ext/bytes.rs

@@ -16,13 +16,58 @@ use ext::base::*;
 use ext::base;
 use ext::build::{mk_u8, mk_slice_vec_e};
 
-pub fn expand_syntax_ext(cx: @ext_ctxt, sp: span, tts: &[ast::token_tree])
-    -> base::MacResult {
-    let var = get_single_str_from_tts(cx, sp, tts, "bytes!");
+pub fn expand_syntax_ext(cx: @ext_ctxt, sp: span, tts: &[ast::token_tree]) -> base::MacResult {
+    // Gather all argument expressions
+    let exprs = get_exprs_from_tts(cx, tts);
     let mut bytes = ~[];
-    for var.each |byte| {
-        bytes.push(mk_u8(cx, sp, byte));
+
+    for exprs.each |expr| {
+        match expr.node {
+            // expression is a literal
+            ast::expr_lit(lit) => match lit.node {
+                // string literal, push each byte to vector expression
+                ast::lit_str(s) => {
+                    for s.each |byte| {
+                        bytes.push(mk_u8(cx, sp, byte));
+                    }
+                }
+
+                // u8 literal, push to vector expression
+                ast::lit_uint(v, ast::ty_u8) => {
+                    if v > 0xFF {
+                        cx.span_err(sp, "Too large u8 literal in bytes!")
+                    } else {
+                        bytes.push(mk_u8(cx, sp, v as u8));
+                    }
+                }
+
+                // integer literal, push to vector expression
+                ast::lit_int_unsuffixed(v) => {
+                    if v > 0xFF {
+                        cx.span_err(sp, "Too large integer literal in bytes!")
+                    } else if v < 0 {
+                        cx.span_err(sp, "Negative integer literal in bytes!")
+                    } else {
+                        bytes.push(mk_u8(cx, sp, v as u8));
+                    }
+                }
+
+                // char literal, push to vector expression
+                ast::lit_int(v, ast::ty_char) => {
+                    if (v as char).is_ascii() {
+                        bytes.push(mk_u8(cx, sp, v as u8));
+                    } else {
+                        cx.span_err(sp, "Non-ascii char literal in bytes!")
+                    }
+                }
+
+                _ => cx.span_err(sp, "Unsupported literal in bytes!")
+            },
+
+            _ => cx.span_err(sp, "Non-literal in bytes!")
+        }
     }
+
     let e = mk_slice_vec_e(cx, sp, bytes);
     MRExpr(e)
 }

branches/auto/src/test/compile-fail/syntax-extension-bytes-non-ascii-char-literal.rs

@@ -0,0 +1,13 @@
+// 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.
+
+fn main() {
+    let vec = bytes!('λ'); //~ ERROR Non-ascii char literal in bytes!
+}

branches/auto/src/test/compile-fail/syntax-extension-bytes-non-literal.rs

@@ -0,0 +1,13 @@
+// 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.
+
+fn main() {
+    let vec = bytes!(foo); //~ ERROR Non-literal in bytes!
+}

branches/auto/src/test/compile-fail/syntax-extension-bytes-too-large-integer-literal.rs

@@ -0,0 +1,13 @@
+// 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.
+
+fn main() {
+    let vec = bytes!(1024); //~ ERROR Too large integer literal in bytes!
+}

branches/auto/src/test/compile-fail/syntax-extension-bytes-too-large-u8-literal.rs

@@ -0,0 +1,13 @@
+// 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.
+
+fn main() {
+    let vec = bytes!(1024u8); //~ ERROR Too large u8 literal in bytes!
+}

branches/auto/src/test/compile-fail/syntax-extension-bytes-too-small-integer-literal.rs

@@ -0,0 +1,13 @@
+// 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.
+
+fn main() {
+    let vec = bytes!(-1024); //~ ERROR Non-literal in bytes
+}

branches/auto/src/test/compile-fail/syntax-extension-bytes-too-small-u8-literal.rs

@@ -0,0 +1,13 @@
+// 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.
+
+fn main() {
+    let vec = bytes!(-1024u8); //~ ERROR Non-literal in bytes
+}

branches/auto/src/test/compile-fail/syntax-extension-bytes-unsupported-literal.rs

@@ -0,0 +1,13 @@
+// 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.
+
+fn main() {
+    let vec = bytes!(45f); //~ ERROR Unsupported literal in bytes!
+}

branches/auto/src/test/run-pass/syntax-extension-bytes.rs

@@ -8,9 +8,17 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+static static_vec: &'static [u8] = bytes!("abc", 0xFF, '!');
+
 fn main() {
     let vec = bytes!("abc");
-    assert_eq!(vec[0], 97);
-    assert_eq!(vec[1], 98);
-    assert_eq!(vec[2], 99);
+    assert_eq!(vec, &[97_u8, 98_u8, 99_u8]);
+
+    let vec = bytes!("null", 0);
+    assert_eq!(vec, &[110_u8, 117_u8, 108_u8, 108_u8, 0_u8]);
+
+    let vec = bytes!(' ', " ", 32, 32u8);
+    assert_eq!(vec, &[32_u8, 32_u8, 32_u8, 32_u8]);
+
+    assert_eq!(static_vec, &[97_u8, 98_u8, 99_u8, 255_u8, 33_u8]);
 }