---

paulstansifer · paulstansifer · commit 75c74c2facbd · 2012-05-24T14:39:22.000-07:00
yaml --- r: 13021 b: refs/heads/master c: 5b72e52 h: refs/heads/master i: 13019: c4ae3ca v: v3
diff --git a/[refs] b/[refs]
@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 09652c8f5f0f12913396898afd4fb382ae90a448
+refs/heads/master: 5b72e52e472ca06f42700a322dc2cac4c38e05f1
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
 refs/heads/try: 2898dcc5d97da9427ac367542382b6239d9c0bbf
diff --git a/trunk/src/librustsyntax/parse.rs b/trunk/src/librustsyntax/parse.rs
@@ -13,6 +13,7 @@ export parse_item_from_source_str;
 export parse_from_source_str;
 
 import parser::parser;
+import attr::parser_attr;
 import common::parser_common;
 import ast::node_id;
 import util::interner;
@@ -44,7 +45,7 @@ fn parse_crate_from_crate_file(input: str, cfg: ast::crate_cfg,
     let p = new_parser_from_file(sess, cfg, input, parser::CRATE_FILE);
     let lo = p.span.lo;
     let prefix = path::dirname(p.reader.filemap.name);
-    let leading_attrs = attr::parse_inner_attrs_and_next(p);
+    let leading_attrs = p.parse_inner_attrs_and_next();
     let crate_attrs = leading_attrs.inner;
     let first_cdir_attr = leading_attrs.next;
     let cdirs = p.parse_crate_directives(token::EOF, first_cdir_attr);
diff --git a/trunk/src/librustsyntax/parse/attr.rs b/trunk/src/librustsyntax/parse/attr.rs
@@ -3,116 +3,130 @@ import ast_util::spanned;
 import common::{parser_common, seq_sep};
 
 export attr_or_ext;
-export parse_outer_attributes;
-export parse_outer_attrs_or_ext;
-export parse_inner_attrs_and_next;
-export parse_optional_meta;
+export parser_attr;
 
 // A type to distingush between the parsing of item attributes or syntax
 // extensions, which both begin with token.POUND
 type attr_or_ext = option<either<[ast::attribute], @ast::expr>>;
 
-fn parse_outer_attrs_or_ext(
-    p: parser,
-    first_item_attrs: [ast::attribute]) -> attr_or_ext {
-    let expect_item_next = vec::is_not_empty(first_item_attrs);
-    if p.token == token::POUND {
-        let lo = p.span.lo;
-        if p.look_ahead(1u) == token::LBRACKET {
-            p.bump();
-            let first_attr = parse_attribute_naked(p, ast::attr_outer, lo);
-            ret some(left([first_attr] + parse_outer_attributes(p)));
-        } else if !(p.look_ahead(1u) == token::LT
-                    || p.look_ahead(1u) == token::LBRACKET
-                    || expect_item_next) {
-            p.bump();
-            ret some(right(p.parse_syntax_ext_naked(lo)));
+impl parser_attr for parser {
+
+    fn parse_outer_attrs_or_ext(first_item_attrs: [ast::attribute])
+        -> attr_or_ext
+    {
+        let expect_item_next = vec::is_not_empty(first_item_attrs);
+        if self.token == token::POUND {
+            let lo = self.span.lo;
+            if self.look_ahead(1u) == token::LBRACKET {
+                self.bump();
+                let first_attr =
+                    self.parse_attribute_naked(ast::attr_outer, lo);
+                ret some(left([first_attr] + self.parse_outer_attributes()));
+            } else if !(self.look_ahead(1u) == token::LT
+                        || self.look_ahead(1u) == token::LBRACKET
+                        || expect_item_next) {
+                self.bump();
+                ret some(right(self.parse_syntax_ext_naked(lo)));
+            } else { ret none; }
         } else { ret none; }
-    } else { ret none; }
-}
+    }
 
-// Parse attributes that appear before an item
-fn parse_outer_attributes(p: parser) -> [ast::attribute] {
-    let mut attrs: [ast::attribute] = [];
-    while p.token == token::POUND && p.look_ahead(1u) == token::LBRACKET {
-        attrs += [parse_attribute(p, ast::attr_outer)];
+    // Parse attributes that appear before an item
+    fn parse_outer_attributes() -> [ast::attribute] {
+        let mut attrs: [ast::attribute] = [];
+        while self.token == token::POUND
+            && self.look_ahead(1u) == token::LBRACKET {
+            attrs += [self.parse_attribute(ast::attr_outer)];
+        }
+        ret attrs;
     }
-    ret attrs;
-}
 
-fn parse_attribute(p: parser, style: ast::attr_style) -> ast::attribute {
-    let lo = p.span.lo;
-    p.expect(token::POUND);
-    ret parse_attribute_naked(p, style, lo);
-}
+    fn parse_attribute(style: ast::attr_style) -> ast::attribute {
+        let lo = self.span.lo;
+        self.expect(token::POUND);
+        ret self.parse_attribute_naked(style, lo);
+    }
 
-fn parse_attribute_naked(p: parser, style: ast::attr_style, lo: uint) ->
-   ast::attribute {
-    p.expect(token::LBRACKET);
-    let meta_item = parse_meta_item(p);
-    p.expect(token::RBRACKET);
-    let mut hi = p.span.hi;
-    ret spanned(lo, hi, {style: style, value: *meta_item});
-}
+    fn parse_attribute_naked(style: ast::attr_style, lo: uint) ->
+        ast::attribute {
+        self.expect(token::LBRACKET);
+        let meta_item = self.parse_meta_item();
+        self.expect(token::RBRACKET);
+        let mut hi = self.span.hi;
+        ret spanned(lo, hi, {style: style, value: *meta_item});
+    }
 
-// Parse attributes that appear after the opening of an item, each terminated
-// by a semicolon. In addition to a vector of inner attributes, this function
-// also returns a vector that may contain the first outer attribute of the
-// next item (since we can't know whether the attribute is an inner attribute
-// of the containing item or an outer attribute of the first contained item
-// until we see the semi).
-fn parse_inner_attrs_and_next(p: parser) ->
-   {inner: [ast::attribute], next: [ast::attribute]} {
-    let mut inner_attrs: [ast::attribute] = [];
-    let mut next_outer_attrs: [ast::attribute] = [];
-    while p.token == token::POUND {
-        if p.look_ahead(1u) != token::LBRACKET {
-            // This is an extension
-            break;
+    // Parse attributes that appear after the opening of an item, each
+    // terminated by a semicolon. In addition to a vector of inner attributes,
+    // this function also returns a vector that may contain the first outer
+    // attribute of the next item (since we can't know whether the attribute
+    // is an inner attribute of the containing item or an outer attribute of
+    // the first contained item until we see the semi).
+    fn parse_inner_attrs_and_next() ->
+        {inner: [ast::attribute], next: [ast::attribute]} {
+        let mut inner_attrs: [ast::attribute] = [];
+        let mut next_outer_attrs: [ast::attribute] = [];
+        while self.token == token::POUND {
+            if self.look_ahead(1u) != token::LBRACKET {
+                // This is an extension
+                break;
+            }
+            let attr = self.parse_attribute(ast::attr_inner);
+            if self.token == token::SEMI {
+                self.bump();
+                inner_attrs += [attr];
+            } else {
+                // It's not really an inner attribute
+                let outer_attr =
+                    spanned(attr.span.lo, attr.span.hi,
+                            {style: ast::attr_outer, value: attr.node.value});
+                next_outer_attrs += [outer_attr];
+                break;
+            }
         }
-        let attr = parse_attribute(p, ast::attr_inner);
-        if p.token == token::SEMI {
-            p.bump();
-            inner_attrs += [attr];
-        } else {
-            // It's not really an inner attribute
-            let outer_attr =
-                spanned(attr.span.lo, attr.span.hi,
-                        {style: ast::attr_outer, value: attr.node.value});
-            next_outer_attrs += [outer_attr];
-            break;
+        ret {inner: inner_attrs, next: next_outer_attrs};
+    }
+
+    fn parse_meta_item() -> @ast::meta_item {
+        let lo = self.span.lo;
+        let ident = self.parse_ident();
+        alt self.token {
+          token::EQ {
+            self.bump();
+            let lit = self.parse_lit();
+            let mut hi = self.span.hi;
+            ret @spanned(lo, hi, ast::meta_name_value(ident, lit));
+          }
+          token::LPAREN {
+            let inner_items = self.parse_meta_seq();
+            let mut hi = self.span.hi;
+            ret @spanned(lo, hi, ast::meta_list(ident, inner_items));
+          }
+          _ {
+            let mut hi = self.span.hi;
+            ret @spanned(lo, hi, ast::meta_word(ident));
+          }
         }
     }
-    ret {inner: inner_attrs, next: next_outer_attrs};
-}
 
-fn parse_meta_item(p: parser) -> @ast::meta_item {
-    let lo = p.span.lo;
-    let ident = p.parse_ident();
-    alt p.token {
-      token::EQ {
-        p.bump();
-        let lit = p.parse_lit();
-        let mut hi = p.span.hi;
-        ret @spanned(lo, hi, ast::meta_name_value(ident, lit));
-      }
-      token::LPAREN {
-        let inner_items = parse_meta_seq(p);
-        let mut hi = p.span.hi;
-        ret @spanned(lo, hi, ast::meta_list(ident, inner_items));
-      }
-      _ {
-        let mut hi = p.span.hi;
-        ret @spanned(lo, hi, ast::meta_word(ident));
-      }
+    fn parse_meta_seq() -> [@ast::meta_item] {
+        ret self.parse_seq(token::LPAREN, token::RPAREN,
+                           seq_sep(token::COMMA),
+                           {|p| p.parse_meta_item()}).node;
     }
-}
 
-fn parse_meta_seq(p: parser) -> [@ast::meta_item] {
-    ret p.parse_seq(token::LPAREN, token::RPAREN, seq_sep(token::COMMA),
-                    {|p| parse_meta_item(p)}).node;
+    fn parse_optional_meta() -> [@ast::meta_item] {
+        alt self.token { token::LPAREN { ret self.parse_meta_seq(); }
+                         _ { ret []; } }
+    }
 }
 
-fn parse_optional_meta(p: parser) -> [@ast::meta_item] {
-    alt p.token { token::LPAREN { ret parse_meta_seq(p); } _ { ret []; } }
-}
+//
+// Local Variables:
+// mode: rust
+// fill-column: 78;
+// indent-tabs-mode: nil
+// c-basic-offset: 4
+// buffer-file-coding-system: utf-8-unix
+// End:
+//
diff --git a/trunk/src/librustsyntax/parse/eval.rs b/trunk/src/librustsyntax/parse/eval.rs
@@ -1,5 +1,5 @@
 import parser::{parser, SOURCE_FILE};
-import attr::parse_inner_attrs_and_next;
+import attr::parser_attr;
 
 export eval_crate_directives_to_mod;
 
@@ -65,7 +65,7 @@ fn parse_companion_mod(cx: ctx, prefix: str, suffix: option<str>)
     if file_exists(modpath) {
         #debug("found companion mod");
         let p0 = new_parser_from_file(cx.sess, cx.cfg, modpath, SOURCE_FILE);
-        let inner_attrs = parse_inner_attrs_and_next(p0);
+        let inner_attrs = p0.parse_inner_attrs_and_next();
         let first_item_outer_attrs = inner_attrs.next;
         let m0 = p0.parse_mod_items(token::EOF, first_item_outer_attrs);
         cx.sess.chpos = p0.reader.chpos;
@@ -97,7 +97,7 @@ fn eval_crate_directive(cx: ctx, cdir: @ast::crate_directive, prefix: str,
             } else { prefix + path::path_sep() + file_path };
         let p0 =
             new_parser_from_file(cx.sess, cx.cfg, full_path, SOURCE_FILE);
-        let inner_attrs = parse_inner_attrs_and_next(p0);
+        let inner_attrs = p0.parse_inner_attrs_and_next();
         let mod_attrs = attrs + inner_attrs.inner;
         let first_item_outer_attrs = inner_attrs.next;
         let m0 = p0.parse_mod_items(token::EOF, first_item_outer_attrs);
diff --git a/trunk/src/librustsyntax/parse/parser.rs b/trunk/src/librustsyntax/parse/parser.rs
diff --git a/trunk/src/rustdoc/attr_parser.rs b/trunk/src/rustdoc/attr_parser.rs
