about summary refs log tree commit diff
path: root/src/librustsyntax
diff options
context:
space:
mode:
Diffstat (limited to 'src/librustsyntax')
-rw-r--r--src/librustsyntax/ext/base.rs10
-rw-r--r--src/librustsyntax/ext/expand.rs4
-rw-r--r--src/librustsyntax/ext/qquote.rs2
-rw-r--r--src/librustsyntax/parse.rs166
-rw-r--r--src/librustsyntax/parse/eval.rs4
-rw-r--r--src/librustsyntax/parse/parser.rs170
6 files changed, 185 insertions, 171 deletions
diff --git a/src/librustsyntax/ext/base.rs b/src/librustsyntax/ext/base.rs
index bd1f9ccd17b..125fb99b8df 100644
--- a/src/librustsyntax/ext/base.rs
+++ b/src/librustsyntax/ext/base.rs
@@ -46,7 +46,7 @@ fn syntax_expander_table() -> hashmap<str, syntax_extension> {
 
 iface ext_ctxt {
     fn codemap() -> codemap;
-    fn parse_sess() -> parser::parse_sess;
+    fn parse_sess() -> parse::parse_sess;
     fn cfg() -> ast::crate_cfg;
     fn print_backtrace();
     fn backtrace() -> expn_info;
@@ -60,14 +60,14 @@ iface ext_ctxt {
     fn next_id() -> ast::node_id;
 }
 
-fn mk_ctxt(parse_sess: parser::parse_sess,
+fn mk_ctxt(parse_sess: parse::parse_sess,
            cfg: ast::crate_cfg) -> ext_ctxt {
-    type ctxt_repr = {parse_sess: parser::parse_sess,
+    type ctxt_repr = {parse_sess: parse::parse_sess,
                       cfg: ast::crate_cfg,
                       mut backtrace: expn_info};
     impl of ext_ctxt for ctxt_repr {
         fn codemap() -> codemap { self.parse_sess.cm }
-        fn parse_sess() -> parser::parse_sess { self.parse_sess }
+        fn parse_sess() -> parse::parse_sess { self.parse_sess }
         fn cfg() -> ast::crate_cfg { self.cfg }
         fn print_backtrace() { }
         fn backtrace() -> expn_info { self.backtrace }
@@ -111,7 +111,7 @@ fn mk_ctxt(parse_sess: parser::parse_sess,
             self.parse_sess.span_diagnostic.handler().bug(msg);
         }
         fn next_id() -> ast::node_id {
-            ret parser::next_node_id(self.parse_sess);
+            ret parse::next_node_id(self.parse_sess);
         }
     }
     let imp : ctxt_repr = {
diff --git a/src/librustsyntax/ext/expand.rs b/src/librustsyntax/ext/expand.rs
index a4386c50275..65f593c5250 100644
--- a/src/librustsyntax/ext/expand.rs
+++ b/src/librustsyntax/ext/expand.rs
@@ -5,7 +5,7 @@ import fold::*;
 import ext::base::*;
 import ext::qquote::{qq_helper};
 import parse::parser;
-import parse::parser::parse_expr_from_source_str;
+import parse::parse_expr_from_source_str;
 
 
 import codemap::{span, expanded_from};
@@ -110,7 +110,7 @@ fn core_macros() -> str {
 }";
 }
 
-fn expand_crate(parse_sess: parser::parse_sess,
+fn expand_crate(parse_sess: parse::parse_sess,
                 cfg: ast::crate_cfg, c: @crate) -> @crate {
     let exts = syntax_expander_table();
     let afp = default_ast_fold();
diff --git a/src/librustsyntax/ext/qquote.rs b/src/librustsyntax/ext/qquote.rs
index d307e11ca04..f95c902cb6d 100644
--- a/src/librustsyntax/ext/qquote.rs
+++ b/src/librustsyntax/ext/qquote.rs
@@ -5,7 +5,7 @@ import visit::*;
 import ext::base::*;
 import ext::build::*;
 import parse::parser;
-import parse::parser::{parser, parse_from_source_str};
+import parse::parser::parse_from_source_str;
 
 import print::*;
 import io::*;
diff --git a/src/librustsyntax/parse.rs b/src/librustsyntax/parse.rs
new file mode 100644
index 00000000000..747775ebaa6
--- /dev/null
+++ b/src/librustsyntax/parse.rs
@@ -0,0 +1,166 @@
+export parse_sess;
+export next_node_id;
+export new_parser_from_file;
+export new_parser_from_source_str;
+export parse_crate_from_file;
+export parse_crate_from_crate_file;
+export parse_crate_from_source_str;
+export parse_expr_from_source_str;
+export parse_from_source_str;
+
+import parser::parser;
+import ast::node_id;
+import util::interner;
+import lexer::reader;
+
+type parse_sess = @{
+    cm: codemap::codemap,
+    mut next_id: node_id,
+    span_diagnostic: diagnostic::span_handler,
+    // these two must be kept up to date
+    mut chpos: uint,
+    mut byte_pos: uint
+};
+
+fn next_node_id(sess: parse_sess) -> node_id {
+    let rv = sess.next_id;
+    sess.next_id += 1;
+    // ID 0 is reserved for the crate and doesn't actually exist in the AST
+    assert rv != 0;
+    ret rv;
+}
+
+fn new_parser_from_file(sess: parse_sess, cfg: ast::crate_cfg, path: str,
+                        ftype: parser::file_type) ->
+   parser {
+    let src = alt io::read_whole_file_str(path) {
+      result::ok(src) {
+        // FIXME: This copy is unfortunate
+        @src
+      }
+      result::err(e) {
+        sess.span_diagnostic.handler().fatal(e)
+      }
+    };
+    let filemap = codemap::new_filemap(path, src,
+                                       sess.chpos, sess.byte_pos);
+    sess.cm.files += [filemap];
+    let itr = @interner::mk(str::hash, str::eq);
+    let rdr = lexer::new_reader(sess.span_diagnostic, filemap, itr);
+    ret new_parser(sess, cfg, rdr, ftype);
+}
+
+fn new_parser_from_source_str(sess: parse_sess, cfg: ast::crate_cfg,
+                              name: str, ss: codemap::file_substr,
+                              source: @str) -> parser {
+    let ftype = parser::SOURCE_FILE;
+    let filemap = codemap::new_filemap_w_substr
+        (name, ss, source, sess.chpos, sess.byte_pos);
+    sess.cm.files += [filemap];
+    let itr = @interner::mk(str::hash, str::eq);
+    let rdr = lexer::new_reader(sess.span_diagnostic,
+                                filemap, itr);
+    ret new_parser(sess, cfg, rdr, ftype);
+}
+
+fn new_parser(sess: parse_sess, cfg: ast::crate_cfg, rdr: lexer::reader,
+              ftype: parser::file_type) -> parser {
+    let tok0 = lexer::next_token(rdr);
+    let span0 = ast_util::mk_sp(tok0.chpos, rdr.chpos);
+    @{sess: sess,
+      cfg: cfg,
+      file_type: ftype,
+      mut token: tok0.tok,
+      mut span: span0,
+      mut last_span: span0,
+      mut buffer: [],
+      mut restriction: parser::UNRESTRICTED,
+      reader: rdr,
+      binop_precs: prec::binop_prec_table(),
+      bad_expr_words: token::bad_expr_word_table()}
+}
+
+fn parse_crate_from_crate_file(input: str, cfg: ast::crate_cfg,
+                               sess: parse_sess) -> @ast::crate {
+    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 = parser::parse_inner_attrs_and_next(p);
+    let crate_attrs = leading_attrs.inner;
+    let first_cdir_attr = leading_attrs.next;
+    let cdirs = parser::parse_crate_directives(
+        p, token::EOF, first_cdir_attr);
+    sess.chpos = p.reader.chpos;
+    sess.byte_pos = sess.byte_pos + p.reader.pos;
+    let cx =
+        @{p: p,
+          sess: sess,
+          cfg: p.cfg};
+    let (companionmod, _) = path::splitext(path::basename(input));
+    let (m, attrs) = eval::eval_crate_directives_to_mod(
+        cx, cdirs, prefix, option::some(companionmod));
+    let mut hi = p.span.hi;
+    parser::expect(p, token::EOF);
+    ret @ast_util::respan(ast_util::mk_sp(lo, hi),
+                          {directives: cdirs,
+                           module: m,
+                           attrs: crate_attrs + attrs,
+                           config: p.cfg});
+}
+
+fn parse_crate_from_file(input: str, cfg: ast::crate_cfg, sess: parse_sess) ->
+   @ast::crate {
+    if str::ends_with(input, ".rc") {
+        parse_crate_from_crate_file(input, cfg, sess)
+    } else if str::ends_with(input, ".rs") {
+        parse_crate_from_source_file(input, cfg, sess)
+    } else {
+        sess.span_diagnostic.handler().fatal("unknown input file type: " +
+                                             input)
+    }
+}
+
+fn parse_crate_from_source_file(input: str, cfg: ast::crate_cfg,
+                                sess: parse_sess) -> @ast::crate {
+    let p = new_parser_from_file(sess, cfg, input, parser::SOURCE_FILE);
+    let r = parser::parse_crate_mod(p, cfg);
+    sess.chpos = p.reader.chpos;
+    sess.byte_pos = sess.byte_pos + p.reader.pos;
+    ret r;
+}
+
+fn parse_expr_from_source_str(name: str, source: @str, cfg: ast::crate_cfg,
+                              sess: parse_sess) -> @ast::expr {
+    let p = new_parser_from_source_str(
+        sess, cfg, name, codemap::fss_none, source);
+    let r = parser::parse_expr(p);
+    sess.chpos = p.reader.chpos;
+    sess.byte_pos = sess.byte_pos + p.reader.pos;
+    ret r;
+}
+
+fn parse_crate_from_source_str(name: str, source: @str, cfg: ast::crate_cfg,
+                               sess: parse_sess) -> @ast::crate {
+    let p = new_parser_from_source_str(
+        sess, cfg, name, codemap::fss_none, source);
+    let r = parser::parse_crate_mod(p, cfg);
+    sess.chpos = p.reader.chpos;
+    sess.byte_pos = sess.byte_pos + p.reader.pos;
+    ret r;
+}
+
+fn parse_from_source_str<T>(f: fn (p: parser) -> T,
+                            name: str, ss: codemap::file_substr,
+                            source: @str, cfg: ast::crate_cfg,
+                            sess: parse_sess)
+    -> T
+{
+    let p = new_parser_from_source_str(sess, cfg, name, ss, source);
+    let r = f(p);
+    if !p.reader.is_eof() {
+        p.reader.fatal("expected end-of-string");
+    }
+    sess.chpos = p.reader.chpos;
+    sess.byte_pos = sess.byte_pos + p.reader.pos;
+    ret r;
+}
diff --git a/src/librustsyntax/parse/eval.rs b/src/librustsyntax/parse/eval.rs
index 75824152f5d..d518c93a8ba 100644
--- a/src/librustsyntax/parse/eval.rs
+++ b/src/librustsyntax/parse/eval.rs
@@ -1,5 +1,5 @@
 import attr;
-import parser::{parser, new_parser_from_file,
+import parser::{parser,
                 parse_inner_attrs_and_next,
                 parse_mod_items, SOURCE_FILE};
 
@@ -7,7 +7,7 @@ export eval_crate_directives_to_mod;
 
 type ctx =
     @{p: parser,
-      sess: parser::parse_sess,
+      sess: parse::parse_sess,
       cfg: ast::crate_cfg};
 
 fn eval_crate_directives(cx: ctx, cdirs: [@ast::crate_directive], prefix: str,
diff --git a/src/librustsyntax/parse/parser.rs b/src/librustsyntax/parse/parser.rs
index 798afc70e05..73ec8236fa5 100644
--- a/src/librustsyntax/parse/parser.rs
+++ b/src/librustsyntax/parse/parser.rs
@@ -4,33 +4,31 @@ import std::map::{hashmap, str_hash};
 import token::{can_begin_expr, is_ident, is_plain_ident};
 import codemap::{span,fss_none};
 import util::interner;
-import ast::{node_id, spanned};
+import ast::spanned;
 import ast_util::{mk_sp, ident_to_path};
 import lexer::reader;
-import prec::{op_spec, binop_prec_table, as_prec};
+import prec::{op_spec, as_prec};
 
+export expect;
 export file_type;
 export mk_item;
-export next_node_id;
-export new_parser_from_file;
-export new_parser_from_source_str;
+export restriction;
 export parser;
-export parse_crate_from_file;
-export parse_crate_from_crate_file;
-export parse_crate_from_source_str;
+export parse_crate_directives;
 export parse_crate_mod;
 export parse_expr;
-export parse_expr_from_source_str;
-export parse_from_source_str;
 export parse_inner_attrs_and_next;
 export parse_item;
 export parse_mod_items;
 export parse_outer_attributes;
 export parse_pat;
-export parse_sess;
 export parse_stmt;
 export parse_ty;
 
+// FIXME: #ast expects to find this here but it's actually defined in `parse`
+import parse_from_source_str;
+export parse_from_source_str;
+
 enum restriction {
     UNRESTRICTED,
     RESTRICT_STMT_EXPR,
@@ -40,23 +38,6 @@ enum restriction {
 
 enum file_type { CRATE_FILE, SOURCE_FILE, }
 
-type parse_sess = @{
-    cm: codemap::codemap,
-    mut next_id: node_id,
-    span_diagnostic: diagnostic::span_handler,
-    // these two must be kept up to date
-    mut chpos: uint,
-    mut byte_pos: uint
-};
-
-fn next_node_id(sess: parse_sess) -> node_id {
-    let rv = sess.next_id;
-    sess.next_id += 1;
-    // ID 0 is reserved for the crate and doesn't actually exist in the AST
-    assert rv != 0;
-    ret rv;
-}
-
 type parser = @{
     sess: parse_sess,
     cfg: ast::crate_cfg,
@@ -111,56 +92,6 @@ impl parser for parser {
     fn get_id() -> node_id { next_node_id(self.sess) }
 }
 
-fn new_parser_from_file(sess: parse_sess, cfg: ast::crate_cfg, path: str,
-                        ftype: file_type) ->
-   parser {
-    let src = alt io::read_whole_file_str(path) {
-      result::ok(src) {
-        // FIXME: This copy is unfortunate
-        @src
-      }
-      result::err(e) {
-        sess.span_diagnostic.handler().fatal(e)
-      }
-    };
-    let filemap = codemap::new_filemap(path, src,
-                                       sess.chpos, sess.byte_pos);
-    sess.cm.files += [filemap];
-    let itr = @interner::mk(str::hash, str::eq);
-    let rdr = lexer::new_reader(sess.span_diagnostic, filemap, itr);
-    ret new_parser(sess, cfg, rdr, ftype);
-}
-
-fn new_parser_from_source_str(sess: parse_sess, cfg: ast::crate_cfg,
-                              name: str, ss: codemap::file_substr,
-                              source: @str) -> parser {
-    let ftype = SOURCE_FILE;
-    let filemap = codemap::new_filemap_w_substr
-        (name, ss, source, sess.chpos, sess.byte_pos);
-    sess.cm.files += [filemap];
-    let itr = @interner::mk(str::hash, str::eq);
-    let rdr = lexer::new_reader(sess.span_diagnostic,
-                                filemap, itr);
-    ret new_parser(sess, cfg, rdr, ftype);
-}
-
-fn new_parser(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader,
-              ftype: file_type) -> parser {
-    let tok0 = lexer::next_token(rdr);
-    let span0 = ast_util::mk_sp(tok0.chpos, rdr.chpos);
-    @{sess: sess,
-      cfg: cfg,
-      file_type: ftype,
-      mut token: tok0.tok,
-      mut span: span0,
-      mut last_span: span0,
-      mut buffer: [],
-      mut restriction: UNRESTRICTED,
-      reader: rdr,
-      binop_precs: binop_prec_table(),
-      bad_expr_words: token::bad_expr_word_table()}
-}
-
 fn token_to_str(reader: reader, token: token::token) -> str {
     token::to_str(*reader.interner, token)
 }
@@ -2690,50 +2621,6 @@ fn parse_native_view(p: parser) -> [@ast::view_item] {
     maybe_parse_view_while(p, [], is_view_item)
 }
 
-fn parse_crate_from_source_file(input: str, cfg: ast::crate_cfg,
-                                sess: parse_sess) -> @ast::crate {
-    let p = new_parser_from_file(sess, cfg, input, SOURCE_FILE);
-    let r = parse_crate_mod(p, cfg);
-    sess.chpos = p.reader.chpos;
-    sess.byte_pos = sess.byte_pos + p.reader.pos;
-    ret r;
-}
-
-
-fn parse_expr_from_source_str(name: str, source: @str, cfg: ast::crate_cfg,
-                              sess: parse_sess) -> @ast::expr {
-    let p = new_parser_from_source_str(sess, cfg, name, fss_none, source);
-    let r = parse_expr(p);
-    sess.chpos = p.reader.chpos;
-    sess.byte_pos = sess.byte_pos + p.reader.pos;
-    ret r;
-}
-
-fn parse_from_source_str<T>(f: fn (p: parser) -> T,
-                            name: str, ss: codemap::file_substr,
-                            source: @str, cfg: ast::crate_cfg,
-                            sess: parse_sess)
-    -> T
-{
-    let p = new_parser_from_source_str(sess, cfg, name, ss, source);
-    let r = f(p);
-    if !p.reader.is_eof() {
-        p.reader.fatal("expected end-of-string");
-    }
-    sess.chpos = p.reader.chpos;
-    sess.byte_pos = sess.byte_pos + p.reader.pos;
-    ret r;
-}
-
-fn parse_crate_from_source_str(name: str, source: @str, cfg: ast::crate_cfg,
-                               sess: parse_sess) -> @ast::crate {
-    let p = new_parser_from_source_str(sess, cfg, name, fss_none, source);
-    let r = parse_crate_mod(p, cfg);
-    sess.chpos = p.reader.chpos;
-    sess.byte_pos = sess.byte_pos + p.reader.pos;
-    ret r;
-}
-
 // Parses a source module as a crate
 fn parse_crate_mod(p: parser, _cfg: ast::crate_cfg) -> @ast::crate {
     let lo = p.span.lo;
@@ -2822,45 +2709,6 @@ fn parse_crate_directives(p: parser, term: token::token,
     ret cdirs;
 }
 
-fn parse_crate_from_crate_file(input: str, cfg: ast::crate_cfg,
-                               sess: parse_sess) -> @ast::crate {
-    let p = new_parser_from_file(sess, cfg, input, CRATE_FILE);
-    let lo = p.span.lo;
-    let prefix = path::dirname(p.reader.filemap.name);
-    let leading_attrs = parse_inner_attrs_and_next(p);
-    let crate_attrs = leading_attrs.inner;
-    let first_cdir_attr = leading_attrs.next;
-    let cdirs = parse_crate_directives(p, token::EOF, first_cdir_attr);
-    sess.chpos = p.reader.chpos;
-    sess.byte_pos = sess.byte_pos + p.reader.pos;
-    let cx =
-        @{p: p,
-          sess: sess,
-          cfg: p.cfg};
-    let (companionmod, _) = path::splitext(path::basename(input));
-    let (m, attrs) = eval::eval_crate_directives_to_mod(
-        cx, cdirs, prefix, option::some(companionmod));
-    let mut hi = p.span.hi;
-    expect(p, token::EOF);
-    ret @spanned(lo, hi,
-                 {directives: cdirs,
-                  module: m,
-                  attrs: crate_attrs + attrs,
-                  config: p.cfg});
-}
-
-fn parse_crate_from_file(input: str, cfg: ast::crate_cfg, sess: parse_sess) ->
-   @ast::crate {
-    if str::ends_with(input, ".rc") {
-        parse_crate_from_crate_file(input, cfg, sess)
-    } else if str::ends_with(input, ".rs") {
-        parse_crate_from_source_file(input, cfg, sess)
-    } else {
-        sess.span_diagnostic.handler().fatal("unknown input file type: " +
-                                             input)
-    }
-}
-
 //
 // Local Variables:
 // mode: rust
generated by cgit-pink 1.4.1-3-g733a5 (git 2.37.1) at 2025-11-02 02:23:06 +0000