---

yaml
---
r: 7362
b: refs/heads/master
c: b8840cb
h: refs/heads/master
v: v3

Author: brson

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 315e3ff8dd73418b6730451d91e0032c8abe2f49
+refs/heads/master: b8840cbee603786107aa627eed4edcfc1c644b93

trunk/configure

@@ -363,6 +363,16 @@ then
     err "either clang or gcc is required"
 fi
 
+if [ ! -z "$CFG_PERF" ]
+then
+    HAVE_PERF_LOGFD=`$CFG_PERF stat --log-fd 2>&1 | grep 'unknown option'`
+    if [ -z "$HAVE_PERF_LOGFD" ];
+    then
+        CFG_PERF_WITH_LOGFD=1
+        putvar CFG_PERF_WITH_LOGFD
+    fi
+fi
+
 step_msg "making directories"
 
 for i in \

trunk/mk/platform.mk

@@ -58,7 +58,11 @@ ifneq ($(findstring linux,$(CFG_OSTYPE)),)
   CFG_LDENV := LD_LIBRARY_PATH
   CFG_DEF_SUFFIX := .linux.def
   ifdef CFG_PERF
-	CFG_PERF_TOOL := $(CFG_PERF) stat -r 3
+    ifneq ($(CFG_PERF_WITH_LOGFD),)
+        CFG_PERF_TOOL := $(CFG_PERF) stat -r 3 --log-fd 2
+    else
+        CFG_PERF_TOOL := $(CFG_PERF) stat -r 3
+    endif
   else
     ifdef CFG_VALGRIND
       CFG_PERF_TOOL :=\

trunk/src/comp/front/attr.rs

@@ -20,6 +20,9 @@ export get_meta_item_name;
 export get_meta_item_value_str;
 export get_meta_item_value_str_by_name;
 export get_meta_item_list;
+export meta_item_value_from_list;
+export meta_item_list_from_list;
+export name_value_str_pair;
 export mk_name_value_item_str;
 export mk_name_value_item;
 export mk_list_item;
@@ -217,6 +220,53 @@ fn native_abi(attrs: [ast::attribute]) -> either::t<str, ast::native_abi> {
     };
 }
 
+fn meta_item_from_list(
+    items: [@ast::meta_item],
+    name: str
+) -> option<@ast::meta_item> {
+    let items = attr::find_meta_items_by_name(items, name);
+    vec::last(items)
+}
+
+fn meta_item_value_from_list(
+    items: [@ast::meta_item],
+    name: str
+) -> option<str> {
+    alt meta_item_from_list(items, name) {
+      some(item) {
+        alt attr::get_meta_item_value_str(item) {
+          some(value) { some(value) }
+          none. { none }
+        }
+      }
+      none. { none }
+    }
+}
+
+fn meta_item_list_from_list(
+    items: [@ast::meta_item],
+    name: str
+) -> option<[@ast::meta_item]> {
+    alt meta_item_from_list(items, name) {
+      some(item) {
+        attr::get_meta_item_list(item)
+      }
+      none. { none }
+    }
+}
+
+fn name_value_str_pair(
+    item: @ast::meta_item
+) -> option<(str, str)> {
+    alt attr::get_meta_item_value_str(item) {
+      some(value) {
+        let name = attr::get_meta_item_name(item);
+        some((name, value))
+      }
+      none. { none }
+    }
+}
+
 fn span<T: copy>(item: T) -> ast::spanned<T> {
     ret {node: item, span: ast_util::dummy_sp()};
 }

trunk/src/libcore/box.rs

@@ -1,8 +1,15 @@
+/*
+Module: box
+*/
+
+
 export ptr_eq;
 
-#[doc(
-  brief = "Determine if two shared boxes point to the same object"
-)]
+/*
+Function: ptr_eq
+
+Determine if two shared boxes point to the same object
+*/
 pure fn ptr_eq<T>(a: @T, b: @T) -> bool {
     // FIXME: ptr::addr_of
     unsafe {

trunk/src/libcore/char.rs

@@ -1,4 +1,8 @@
-#[doc = "Utilities for manipulating the char type"];
+/*
+Module: char
+
+Utilities for manipulating the char type
+*/
 
 /*
     Lu  Uppercase_Letter    an uppercase letter
@@ -43,40 +47,50 @@ 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;
 
+/*
+Function: is_lowercase
 
-#[doc(
-  brief = "Indicates whether a character is in lower case, defined \
-           in terms of the Unicode General Category 'Ll'."
-)]
+Indicates whether a character is in lower case, defined in terms of the
+Unicode General Category 'Ll'.
+*/
 pure fn is_lowercase(c: char) -> bool {
     ret unicode::general_category::Ll(c);
 }
 
-#[doc(
-  brief = "Indicates whether a character is in upper case, defined \
-           in terms of the Unicode General Category 'Lu'."
-)]
+/*
+Function: is_uppercase
+
+Indicates whether a character is in upper case, defined in terms of the
+Unicode General Category 'Lu'.
+*/
 pure fn is_uppercase(c: char) -> bool {
     ret unicode::general_category::Lu(c);
 }
 
-#[doc(
-  brief = "Indicates whether a character is whitespace, defined in \
-           terms of the Unicode General Categories 'Zs', 'Zl', 'Zp' \
-           additional 'Cc'-category control codes in the range [0x09, 0x0d]"
-)]
+/*
+Function: is_whitespace
+
+Indicates whether a character is whitespace, defined in terms of
+the Unicode General Categories 'Zs', 'Zl', 'Zp' and the additional
+'Cc'-category control codes in the range [0x09, 0x0d].
+
+*/
 pure fn is_whitespace(c: char) -> bool {
     ret ('\x09' <= c && c <= '\x0d')
         || unicode::general_category::Zs(c)
         || unicode::general_category::Zl(c)
         || unicode::general_category::Zp(c);
 }
 
-#[doc(
-  brief = "Indicates whether a character is alphanumeric, defined \
-            in terms of the Unicode General Categories 'Nd', \
-            'Nl', 'No' and the Derived Core Property 'Alphabetic'."
-)]
+/*
+Function: is_alphanumeric
+
+Indicates whether a character is alphanumeric, defined in terms of
+the Unicode General Categories 'Nd', 'Nl', 'No' and the Derived
+Core Property 'Alphabetic'.
+
+*/
+
 pure fn is_alphanumeric(c: char) -> bool {
     ret unicode::derived_property::Alphabetic(c) ||
         unicode::general_category::Nd(c) ||
@@ -85,24 +99,34 @@ pure fn is_alphanumeric(c: char) -> bool {
 }
 
 
-#[doc(
-  brief = "Convert a char to the corresponding digit. \
-           Safety note: This function fails if `c` is not a valid char",
-  return = "If `c` is between '0' and '9', the corresponding value \
-            between 0 and 9. If `c` is 'a' or 'A', 10. If `c` is \
-            'b' or 'B', 11, etc."
-)]
+/*
+ Function: to_digit
+
+ Convert a char to the corresponding digit.
+
+ Parameters:
+   c - a char, either '0' to '9', 'a' to 'z' or 'A' to 'Z'
+
+ Returns:
+   If `c` is between '0' and '9', the corresponding value between 0 and 9.
+ If `c` is 'a' or 'A', 10. If `c` is 'b' or 'B', 11, etc.
+
+ Safety note:
+   This function fails if `c` is not a valid char
+*/
 pure fn to_digit(c: char) -> u8 unsafe {
     alt maybe_digit(c) {
       option::some(x) { x }
       option::none. { fail; }
     }
 }
 
-#[doc(
-  brief = "Convert a char to the corresponding digit. Returns none when \
-           character is not a valid hexadecimal digit."
-)]
+/*
+ Function: maybe_digit
+
+ Convert a char to the corresponding digit. Returns none when the
+ character is not a valid hexadecimal digit.
+*/
 pure fn maybe_digit(c: char) -> option::t<u8> {
     alt c {
       '0' to '9' { option::some(c as u8 - ('0' as u8)) }
@@ -113,11 +137,12 @@ pure fn maybe_digit(c: char) -> option::t<u8> {
 }
 
 /*
+ Function: to_lower
+
+ Convert a char to the corresponding lower case.
+
  FIXME: works only on ASCII
 */
-#[doc(
-  brief = "Convert a char to the corresponding lower case."
-)]
 pure fn to_lower(c: char) -> char {
     alt c {
       'A' to 'Z' { ((c as u8) + 32u8) as char }
@@ -126,22 +151,31 @@ pure fn to_lower(c: char) -> char {
 }
 
 /*
+ Function: to_upper
+
+ Convert a char to the corresponding upper case.
+
  FIXME: works only on ASCII
 */
-#[doc(
-  brief = "Convert a char to the corresponding upper case."
-)]
 pure fn to_upper(c: char) -> char {
     alt c {
       'a' to 'z' { ((c as u8) - 32u8) as char }
       _ { c }
     }
 }
 
-#[doc(
-  brief =  "Compare two chars.",
-  return = "-1 if a&lt;b, 0 if a==b, +1 if a>b"
-)]
+/*
+ Function: cmp
+
+ Compare two chars.
+
+ Parameters:
+  a - a char
+  b - a char
+
+ Returns:
+  -1 if a<b, 0 if a==b, +1 if a>b
+*/
 pure fn cmp(a: char, b: char) -> int {
     ret  if b > a { -1 }
     else if b < a { 1 }