---

yaml
---
r: 6964
b: refs/heads/master
c: 36c55b2
h: refs/heads/master
v: v3

Author: graydon

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: d07c6e8a0ede3114ebfd8c3ea6cc161cf009f072
+refs/heads/master: 36c55b20a89d45f394fceb5e83dd3a032e37810a

trunk/doc/rust.texi

@@ -595,9 +595,10 @@ otherwise defined as keywords or reserved
 tokens. @xref{Ref.Lex.Key}. @xref{Ref.Lex.Res}.
 
 That is: an identifier starts with any character having derived property
-@code{XID_Start} and continues with zero or more characters having derived
-property @code{XID_Continue}; and such an identifier is NFKC-normalized during
-lexing, such that all subsequent comparison of identifiers is performed on the
+@code{XID_Start}, or the character U+005F (underscore, @code{_}), and
+continues with zero or more characters having derived property
+@code{XID_Continue}. An identifier is NFKC-normalized during lexing, such
+that all subsequent comparison of identifiers is performed on the
 NFKC-normalized forms.
 
 @emph{TODO: define relationship between Unicode and Rust versions}.

trunk/src/comp/middle/last_use.rs

@@ -1,7 +1,7 @@
 import syntax::{visit, ast_util};
 import syntax::ast::*;
 import syntax::codemap::span;
-import std::list::{is_not_empty, list, nil, cons, tail};
+import std::list::{list, nil, cons, tail};
 import core::{vec, option};
 import std::list;
 
@@ -177,9 +177,7 @@ fn visit_block(tp: block_type, cx: ctx, visit: block()) {
     visit();
     local.second = true;
     visit();
-    let cx_blocks = cx.blocks;
-    check is_not_empty(cx_blocks);
-    cx.blocks = tail(cx_blocks);
+    cx.blocks = tail(cx.blocks);
     cx.current = join_branches(local.exits);
 }
 

trunk/src/comp/middle/resolve.rs

@@ -266,7 +266,6 @@ fn map_crate(e: @env, c: @ast::crate) {
             let imp = follow_import(*e, sc, *path, vi.span);
             if option::is_some(imp) {
                 let glob = {def: option::get(imp), item: vi};
-                check list::is_not_empty(sc);
                 alt list::head(sc) {
                   scope_item(i) {
                     e.mod_map.get(i.id).glob_imports += [glob];
@@ -456,7 +455,6 @@ fn visit_block_with_scope(b: ast::blk, sc: scopes, v: vt<scopes>) {
 }
 
 fn visit_decl_with_scope(d: @decl, sc: scopes, v: vt<scopes>) {
-    check list::is_not_empty(sc);
     let loc_pos = alt list::head(sc) {
       scope_block(_, _, pos) { pos }
       _ { @mutable 0u }

trunk/src/comp/syntax/parse/lexer.rs

@@ -309,14 +309,16 @@ fn next_token(rdr: reader) -> {tok: token::token, chpos: uint, bpos: uint} {
 fn next_token_inner(rdr: reader) -> token::token {
     let accum_str = "";
     let c = rdr.curr();
-    if is_alpha(c) || c == '_' {
-        while is_alnum(c) || c == '_' {
+    if char::is_XID_start(c) || c == '_' {
+        while char::is_XID_continue(c) {
             str::push_char(accum_str, c);
             rdr.bump();
             c = rdr.curr();
         }
         if str::eq(accum_str, "_") { ret token::UNDERSCORE; }
         let is_mod_name = c == ':' && rdr.next() == ':';
+
+        // FIXME: perform NFKC normalization here.
         ret token::IDENT(interner::intern::<str>(*rdr.get_interner(),
                                                  accum_str), is_mod_name);
     }

trunk/src/libcore/char.rs

@@ -37,6 +37,12 @@ Utilities for manipulating the char type
     Cn  Unassigned  a reserved unassigned code point or a noncharacter
 */
 
+export is_alphabetic,
+       is_XID_start, is_XID_continue,
+       is_lowercase, is_uppercase,
+       is_whitespace, is_alphanumeric,
+       to_digit, maybe_digit, cmp;
+
 import is_alphabetic = unicode::derived_property::Alphabetic;
 import is_XID_start = unicode::derived_property::XID_Start;
 import is_XID_continue = unicode::derived_property::XID_Continue;

trunk/src/libstd/list.rs

@@ -97,27 +97,6 @@ fn has<copy T>(ls: list<T>, elt: T) -> bool {
     ret false;
 }
 
-/*
-Function: is_empty
-
-Returns true if the list is empty.
-*/
-pure fn is_empty<copy T>(ls: list<T>) -> bool {
-    alt ls {
-        nil. { true }
-        _ { false }
-    }
-}
-
-/*
-Function: is_not_empty
-
-Returns true if the list is not empty.
-*/
-pure fn is_not_empty<copy T>(ls: list<T>) -> bool {
-    ret !is_empty(ls);
-}
-
 /*
 Function: len
 
@@ -133,23 +112,17 @@ Function: tail
 
 Returns all but the first element of a list
 */
-pure fn tail<copy T>(ls: list<T>) : is_not_empty(ls) -> list<T> {
-    alt ls {
-        cons(_, tl) { ret *tl; }
-        nil. { fail "list empty" }
-    }
+pure fn tail<copy T>(ls: list<T>) -> list<T> {
+    alt ls { cons(_, tl) { ret *tl; } nil. { fail "list empty" } }
 }
 
 /*
 Function: head
 
 Returns the first element of a list
 */
-pure fn head<copy T>(ls: list<T>) : is_not_empty(ls) -> T {
-    alt ls {
-        cons(hd, _) { ret hd; }
-        nil. { fail "list empty" }
-    }
+pure fn head<copy T>(ls: list<T>) -> T {
+    alt ls { cons(hd, _) { ret hd; } nil. { fail "list empty" } }
 }
 
 /*

trunk/src/rt/arch/i386/morestack.S

@@ -150,6 +150,9 @@ MORESTACK:
 	movl %ecx, 16(%esp)
 	movl %edx, 12(%esp)
 
+	// FIXME (1388): it's possible we also need to save/restore some
+	// SSE2 registers here, if floats-go-in-regs on x86+SSE2. Unclear.
+
 	// FIXME (1226): main is compiled with the split-stack prologue,
 	// causing it to call __morestack, so we have to jump back out
 	calll RUST_GET_TASK
@@ -201,9 +204,6 @@ MORESTACK:
 	// Save the return value of the function we allocated space for
 	movl %eax, (%esp)
 
-	// Now that we're on the return path we want to avoid
-	// stomping on %eax. FIXME: Need to save and restore %eax to
-	// actually preserve it across the call to delete the stack
 	call UPCALL_DEL_STACK
 
 	// And restore it

trunk/src/rt/arch/x86_64/morestack.S

@@ -61,6 +61,19 @@ MORESTACK:
 	pushq	%r8
 	pushq	%r9
 
+	pushq $0 // Alignment
+	pushq $0 // Alignment
+
+	subq $128, %rsp
+	movdqa %xmm0,	 (%rsp)
+	movdqa %xmm1,  16(%rsp)
+	movdqa %xmm2,  32(%rsp)
+	movdqa %xmm3,  48(%rsp)
+	movdqa %xmm4,  64(%rsp)
+	movdqa %xmm5,  80(%rsp)
+	movdqa %xmm6,  96(%rsp)
+	movdqa %xmm7, 112(%rsp)
+
 	// Calculate the address of the stack arguments.
 	// We have the base pointer, __morestack's return address,
 	// and __morestack's caller's return address to skip
@@ -72,7 +85,7 @@ MORESTACK:
 	movq %r11, %rdx // Size of stack arguments
 	movq %rax, %rsi // Address of stack arguments
 	movq %r10, %rdi // The amount of stack needed
-
+        
 #ifdef __APPLE__
 	call UPCALL_NEW_STACK
 #endif
@@ -81,6 +94,19 @@ MORESTACK:
 #endif
 
 	// Pop the saved arguments
+	movdqa    (%rsp), %xmm0
+	movdqa  16(%rsp), %xmm1
+	movdqa  32(%rsp), %xmm2
+	movdqa  48(%rsp), %xmm3
+	movdqa  64(%rsp), %xmm4
+	movdqa  80(%rsp), %xmm5
+	movdqa  96(%rsp), %xmm6
+	movdqa 112(%rsp), %xmm7
+	addq $128, %rsp
+
+	popq %r9 // Alignment
+	popq %r9 // Alignment
+
 	popq %r9
 	popq %r8
 	popq %rcx
@@ -103,7 +129,6 @@ MORESTACK:
 	// Save the return value
 	pushq %rax
 
-	// FIXME: Should preserve %rax here
 #ifdef __APPLE__
 	call UPCALL_DEL_STACK
 #endif

trunk/src/test/run-pass/non-boolean-pure-fns.rs

@@ -14,10 +14,7 @@ pure fn nonempty_list<copy T>(ls: list<T>) -> bool { pure_length(ls) > 0u }
 // knowledge that ls is a cons node. Future work.
 // Also, this is pretty contrived since nonempty_list
 // could be a "tag refinement", if we implement those.
-fn safe_head<copy T>(ls: list<T>) : nonempty_list(ls) -> T {
-    check is_not_empty(ls);
-    ret head(ls);
-}
+fn safe_head<copy T>(ls: list<T>) : nonempty_list(ls) -> T { head(ls) }
 
 fn main() {
     let mylist = cons(@1u, @nil);

trunk/src/test/run-pass/unchecked-predicates.rs

@@ -1,17 +1,12 @@
 // Uses foldl to exhibit the unchecked block syntax.
-// TODO: since list's head/tail require the predicate "is_not_empty" now and
-// we have unit tests for list, this test might me not necessary anymore?
 use std;
 
 import std::list::*;
 
 // Can't easily be written as a "pure fn" because there's
 // no syntax for specifying that f is pure.
 fn pure_foldl<copy T, copy U>(ls: list<T>, u: U, f: block(T, U) -> U) -> U {
-    alt ls {
-        nil. { u }
-        cons(hd, tl) { f(hd, pure_foldl(*tl, f(hd, u), f)) }
-    }
+    alt ls { nil. { u } cons(hd, tl) { f(hd, pure_foldl(*tl, f(hd, u), f)) } }
 }
 
 // Shows how to use an "unchecked" block to call a general
@@ -27,10 +22,7 @@ pure fn nonempty_list<copy T>(ls: list<T>) -> bool { pure_length(ls) > 0u }
 // knowledge that ls is a cons node. Future work.
 // Also, this is pretty contrived since nonempty_list
 // could be a "tag refinement", if we implement those.
-fn safe_head<copy T>(ls: list<T>) : nonempty_list(ls) -> T {
-    check is_not_empty(ls);
-    ret head(ls)
-}
+fn safe_head<copy T>(ls: list<T>) : nonempty_list(ls) -> T { head(ls) }
 
 fn main() {
     let mylist = cons(@1u, @nil);

trunk/src/test/run-pass/utf8_idents.rs

@@ -0,0 +1,34 @@
+fn main() {
+    let Π = 3.14;
+    let लंच = Π * Π + 1.54;
+    assert लंच - 1.54 == Π * Π;
+    assert საჭმელად_გემრიელი_სადილი() == 0;
+}
+
+fn საჭმელად_გემრიელი_სადილი() -> int {
+
+    // Lunch in several languages.
+
+    let ランチ = 10;
+    let 午餐 = 10;
+
+    let ארוחת_צהריי = 10;
+    let غداء = 10;
+    let լանչ = 10;
+    let обед = 10;
+    let абед = 10;
+    let μεσημεριανό = 10;
+    let hádegismatur = 10;
+    let ручек = 10;
+
+    let ăn_trưa = 10;
+    let อาหารกลางวัน = 10;
+
+    // Lunchy arithmetic, mm.
+
+    assert hádegismatur * ручек * обед == 1000;
+    assert 10 ==  ארוחת_צהריי;
+    assert ランチ + 午餐 + μεσημεριανό == 30;
+    assert ăn_trưa + อาหารกลางวัน == 20;
+    ret (абед + լանչ) >> غداء;
+}

trunk/src/test/stdtest/list.rs

@@ -2,23 +2,17 @@ import core::*;
 
 use std;
 import std::list;
-import std::list::{from_vec, head, is_not_empty, tail};
+import std::list::head;
+import std::list::tail;
+import std::list::from_vec;
 import option;
 
 #[test]
 fn test_from_vec() {
     let l = from_vec([0, 1, 2]);
-
-    check is_not_empty(l);
     assert (head(l) == 0);
-
-    let tail_l = tail(l);
-    check is_not_empty(tail_l);
-    assert (head(tail_l) == 1);
-
-    let tail_tail_l = tail(tail_l);
-    check is_not_empty(tail_tail_l);
-    assert (head(tail_tail_l) == 2);
+    assert (head(tail(l)) == 1);
+    assert (head(tail(tail(l))) == 2);
 }
 
 #[test]
@@ -30,17 +24,9 @@ fn test_from_vec_empty() {
 #[test]
 fn test_from_vec_mut() {
     let l = from_vec([mutable 0, 1, 2]);
-
-    check is_not_empty(l);
     assert (head(l) == 0);
-
-    let tail_l = tail(l);
-    check is_not_empty(tail_l);
-    assert (head(tail_l) == 1);
-
-    let tail_tail_l = tail(tail_l);
-    check is_not_empty(tail_tail_l);
-    assert (head(tail_tail_l) == 2);
+    assert (head(tail(l)) == 1);
+    assert (head(tail(tail(l))) == 2);
 }
 
 #[test]