---

yaml
---
r: 118495
b: refs/heads/master
c: bb06790
h: refs/heads/master
i:
  118493: 8207ebc
  118491: 631ca72
  118487: 08e4137
  118479: f20fb98
  118463: 0a92d60
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 4eb5d7baf928a922b30d71e64f7be258d1a82f2f
+refs/heads/master: bb06790c37e839c98427b966cd079da712268415
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: d6736a1440d42f6af967a8a20ab8d73522112b72
 refs/heads/try: 04eced750e78770e16354c07fddf7ecaaab6ef43

trunk/src/compiler-rt

@@ -1 +1 @@
-Subproject commit 7b97b8468f0614072cf3299fa8c51e85f609316f
+Subproject commit 62a4ca6055ad6fda8faf767b93b5736dcdfb7013

trunk/src/compiletest/runtest.rs

@@ -1269,7 +1269,7 @@ fn make_out_name(config: &Config, testfile: &Path, extension: &str) -> Path {
 
 fn aux_output_dir_name(config: &Config, testfile: &Path) -> Path {
     let mut f = output_base_name(config, testfile);
-    match f.filename().map(|s| Vec::from_slice(s).append(bytes!(".libaux"))) {
+    match f.filename().map(|s| Vec::from_slice(s).append(b".libaux")) {
         Some(v) => f.set_filename(v),
         None => ()
     }
@@ -1490,7 +1490,7 @@ fn append_suffix_to_stem(p: &Path, suffix: &str) -> Path {
         (*p).clone()
     } else {
         let stem = p.filestem().unwrap();
-        p.with_filename(Vec::from_slice(stem).append(bytes!("-")).append(suffix.as_bytes()))
+        p.with_filename(Vec::from_slice(stem).append(b"-").append(suffix.as_bytes()))
     }
 }
 

trunk/src/doc/complement-cheatsheet.md

@@ -76,7 +76,7 @@ character.
 ~~~
 use std::str;
 
-let x = bytes!(72u8,"ello ",0xF0,0x90,0x80,"World!");
+let x = b"Hello \xF0\x90\x80World!";
 let y = str::from_utf8_lossy(x);
 ~~~
 

trunk/src/doc/rust.md

@@ -234,7 +234,7 @@ rule. A literal is a form of constant expression, so is evaluated (primarily)
 at compile time.
 
 ~~~~ {.ebnf .gram}
-literal : string_lit | char_lit | num_lit ;
+literal : string_lit | char_lit | byte_string_lit | byte_lit | num_lit ;
 ~~~~
 
 #### Character and string literals
@@ -244,17 +244,17 @@ char_lit : '\x27' char_body '\x27' ;
 string_lit : '"' string_body * '"' | 'r' raw_string ;
 
 char_body : non_single_quote
-          | '\x5c' [ '\x27' | common_escape ] ;
+          | '\x5c' [ '\x27' | common_escape | unicode_escape ] ;
 
 string_body : non_double_quote
-            | '\x5c' [ '\x22' | common_escape ] ;
+            | '\x5c' [ '\x22' | common_escape | unicode_escape ] ;
 raw_string : '"' raw_string_body '"' | '#' raw_string '#' ;
 
 common_escape : '\x5c'
               | 'n' | 'r' | 't' | '0'
               | 'x' hex_digit 2
-              | 'u' hex_digit 4
-              | 'U' hex_digit 8 ;
+unicode_escape : 'u' hex_digit 4
+               | 'U' hex_digit 8 ;
 
 hex_digit : 'a' | 'b' | 'c' | 'd' | 'e' | 'f'
           | 'A' | 'B' | 'C' | 'D' | 'E' | 'F'
@@ -294,7 +294,7 @@ the following forms:
     escaped in order to denote *itself*.
 
 Raw string literals do not process any escapes. They start with the character
-`U+0072` (`r`), followed zero or more of the character `U+0023` (`#`) and a
+`U+0072` (`r`), followed by zero or more of the character `U+0023` (`#`) and a
 `U+0022` (double-quote) character. The _raw string body_ is not defined in the
 EBNF grammar above: it can contain any sequence of Unicode characters and is
 terminated only by another `U+0022` (double-quote) character, followed by the
@@ -319,6 +319,78 @@ r##"foo #"# bar"##;                // foo #"# bar
 "\\x52"; r"\x52";                  // \x52
 ~~~~
 
+#### Byte and byte string literals
+
+~~~~ {.ebnf .gram}
+byte_lit : 'b' '\x27' byte_body '\x27' ;
+byte_string_lit : 'b' '"' string_body * '"' | 'b' 'r' raw_byte_string ;
+
+byte_body : ascii_non_single_quote
+          | '\x5c' [ '\x27' | common_escape ] ;
+
+byte_string_body : ascii_non_double_quote
+            | '\x5c' [ '\x22' | common_escape ] ;
+raw_byte_string : '"' raw_byte_string_body '"' | '#' raw_byte_string '#' ;
+
+~~~~
+
+A _byte literal_ is a single ASCII character (in the `U+0000` to `U+007F` range)
+enclosed within two `U+0027` (single-quote) characters,
+with the exception of `U+0027` itself,
+which must be _escaped_ by a preceding U+005C character (`\`),
+or a single _escape_.
+It is equivalent to a `u8` unsigned 8-bit integer _number literal_.
+
+A _byte string literal_ is a sequence of ASCII characters and _escapes_
+enclosed within two `U+0022` (double-quote) characters,
+with the exception of `U+0022` itself,
+which must be _escaped_ by a preceding `U+005C` character (`\`),
+or a _raw byte string literal_.
+It is equivalent to a `&'static [u8]` borrowed vectior unsigned 8-bit integers.
+
+Some additional _escapes_ are available in either byte or non-raw byte string
+literals. An escape starts with a `U+005C` (`\`) and continues with one of
+the following forms:
+
+  * An _byte escape_ escape starts with `U+0078` (`x`) and is
+    followed by exactly two _hex digits_. It denotes the byte
+    equal to the provided hex value.
+  * A _whitespace escape_ is one of the characters `U+006E` (`n`), `U+0072`
+    (`r`), or `U+0074` (`t`), denoting the bytes values `0x0A` (ASCII LF),
+    `0x0D` (ASCII CR) or `0x09` (ASCII HT) respectively.
+  * The _backslash escape_ is the character `U+005C` (`\`) which must be
+    escaped in order to denote its ASCII encoding `0x5C`.
+
+Raw byte string literals do not process any escapes.
+They start with the character `U+0072` (`r`),
+followed by `U+0062` (`b`),
+followed by zero or more of the character `U+0023` (`#`),
+and a `U+0022` (double-quote) character.
+The _raw string body_ is not defined in the EBNF grammar above:
+it can contain any sequence of ASCII characters and is
+terminated only by another `U+0022` (double-quote) character, followed by the
+same number of `U+0023` (`#`) characters that preceded the opening `U+0022`
+(double-quote) character.
+A raw byte string literal can not contain any non-ASCII byte.
+
+All characters contained in the raw string body represent their ASCII encoding,
+the characters `U+0022` (double-quote) (except when followed by at least as
+many `U+0023` (`#`) characters as were used to start the raw string literal) or
+`U+005C` (`\`) do not have any special meaning.
+
+Examples for byte string literals:
+
+~~~~
+b"foo"; br"foo";                     // foo
+b"\"foo\""; br#""foo""#;             // "foo"
+
+b"foo #\"# bar";
+br##"foo #"# bar"##;                 // foo #"# bar
+
+b"\x52"; b"R"; br"R";                // R
+b"\\x52"; br"\x52";                  // \x52
+~~~~
+
 #### Number literals
 
 ~~~~ {.ebnf .gram}

trunk/src/etc/2014-06-rewrite-bytes-macros.py

@@ -0,0 +1,138 @@
+#!/bin/env python
+#
+# 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.
+
+import sys
+import subprocess
+import re
+
+
+def main():
+    if len(sys.argv) <= 1:
+        print('Usage: %s [ --apply ] filename1.rs filename2.rs ...'
+              % sys.argv[0])
+    elif sys.argv[1] == '--apply':
+        for filename in sys.argv[2:]:
+            patch(filename)
+    else:
+        for filename in sys.argv[1:]:
+            diff(filename)
+
+
+def patch(filename):
+    source = read(filename)
+    rewritten = rewrite_bytes_macros(source)
+    if rewritten is not None and rewritten != source:
+        write(filename, rewritten)
+
+
+def diff(filename):
+    rewritten = rewrite_bytes_macros(read(filename))
+    if rewritten is not None:
+        p = subprocess.Popen(['diff', '-u', filename, '-'],
+                             stdin=subprocess.PIPE)
+        p.stdin.write(rewritten)
+        p.stdin.close()
+        p.wait()
+
+
+def read(filename):
+    with open(filename, 'rb') as f:
+        return f.read()
+
+
+def write(filename, content):
+    with open(filename, 'wb') as f:
+        f.write(content)
+
+
+def rewrite_bytes_macros(source):
+    rewritten, num_occurrences = BYTES_MACRO_RE.subn(rewrite_one_macro, source)
+    if num_occurrences > 0:
+        return rewritten
+
+
+BYTES_MACRO_RE = re.compile(br'bytes!\(  (?P<args>  [^)]*  )  \)', re.VERBOSE)
+
+
+def rewrite_one_macro(match):
+    try:
+        bytes = parse_bytes(split_args(match.group('args')))
+        return b'b"' + b''.join(map(escape, bytes)) + b'"'
+    except SkipThisRewrite:
+        print('Skipped: %s' % match.group(0).decode('utf8', 'replace'))
+        return match.group(0)
+
+
+class SkipThisRewrite(Exception):
+    pass
+
+
+def split_args(args):
+    previous = b''
+    for arg in args.split(b','):
+        if previous:
+            arg = previous + b',' + arg
+        if arg.count(b'"') % 2 == 0:
+            yield arg
+            previous = b''
+        else:
+            previous = arg
+    if previous:
+        yield previous
+
+
+def parse_bytes(args):
+    for arg in args:
+        arg = arg.strip()
+        if (arg.startswith(b'"') and arg.endswith(b'"')) or (
+                arg.startswith(b"'") and arg.endswith(b"'")):
+            # Escaped newline means something different in Rust and Python.
+            if b'\\\n' in arg:
+                raise SkipThisRewrite
+            for byte in eval(b'u' + arg).encode('utf8'):
+                yield ord(byte)
+        else:
+            if arg.endswith(b'u8'):
+                arg = arg[:-2]
+            # Assume that all Rust integer literals
+            # are valid Python integer literals
+            value = int(eval(arg))
+            assert value <= 0xFF
+            yield value
+
+
+def escape(byte):
+    c = chr(byte)
+    escaped = {
+        b'\0': br'\0',
+        b'\t': br'\t',
+        b'\n': br'\n',
+        b'\r': br'\r',
+        b'\'': b'\\\'',
+        b'\\': br'\\',
+    }.get(c)
+    if escaped is not None:
+        return escaped
+    elif b' ' <= c <= b'~':
+        return chr(byte)
+    else:
+        return ('\\x%02X' % byte).encode('ascii')
+
+
+if str is not bytes:
+    # Python 3.x
+    ord = lambda x: x
+    chr = lambda x: bytes([x])
+
+
+if __name__ == '__main__':
+    main()

trunk/src/etc/emacs/run_rust_emacs_tests.sh

@@ -1,3 +1,4 @@
+#!/bin/sh
 # 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.