2011-07-05 04:48:19 -05:00
|
|
|
import util::interner;
|
2012-04-15 05:44:32 -05:00
|
|
|
import util::interner::interner;
|
2012-04-17 23:14:40 -05:00
|
|
|
import std::map::{hashmap, str_hash};
|
2012-05-21 12:45:56 -05:00
|
|
|
import std::serialization::{serializer,
|
|
|
|
deserializer,
|
|
|
|
serialize_uint,
|
|
|
|
deserialize_uint,
|
|
|
|
serialize_i64,
|
|
|
|
deserialize_i64,
|
|
|
|
serialize_u64,
|
|
|
|
deserialize_u64,
|
|
|
|
serialize_bool,
|
|
|
|
deserialize_bool};
|
2010-08-18 13:35:12 -05:00
|
|
|
|
2012-05-21 12:45:56 -05:00
|
|
|
#[auto_serialize]
|
2011-05-09 16:17:28 -05:00
|
|
|
type str_num = uint;
|
|
|
|
|
2012-05-21 12:45:56 -05:00
|
|
|
#[auto_serialize]
|
2012-01-19 16:24:03 -06:00
|
|
|
enum binop {
|
2012-01-19 19:56:05 -06:00
|
|
|
PLUS,
|
|
|
|
MINUS,
|
|
|
|
STAR,
|
|
|
|
SLASH,
|
|
|
|
PERCENT,
|
|
|
|
CARET,
|
|
|
|
AND,
|
|
|
|
OR,
|
2012-05-22 16:59:15 -05:00
|
|
|
SHL,
|
|
|
|
SHR,
|
2010-09-09 17:59:29 -05:00
|
|
|
}
|
|
|
|
|
2012-05-21 12:45:56 -05:00
|
|
|
#[auto_serialize]
|
2012-01-19 16:24:03 -06:00
|
|
|
enum token {
|
2010-09-09 17:59:29 -05:00
|
|
|
/* Expression-operator symbols. */
|
2012-01-19 19:56:05 -06:00
|
|
|
EQ,
|
|
|
|
LT,
|
|
|
|
LE,
|
|
|
|
EQEQ,
|
|
|
|
NE,
|
|
|
|
GE,
|
|
|
|
GT,
|
|
|
|
ANDAND,
|
|
|
|
OROR,
|
|
|
|
NOT,
|
|
|
|
TILDE,
|
|
|
|
BINOP(binop),
|
|
|
|
BINOPEQ(binop),
|
2010-09-09 17:59:29 -05:00
|
|
|
|
|
|
|
/* Structural symbols */
|
2012-01-19 19:56:05 -06:00
|
|
|
AT,
|
|
|
|
DOT,
|
2012-08-03 20:01:30 -05:00
|
|
|
DOTDOT,
|
2012-01-19 19:56:05 -06:00
|
|
|
ELLIPSIS,
|
|
|
|
COMMA,
|
|
|
|
SEMI,
|
|
|
|
COLON,
|
|
|
|
MOD_SEP,
|
|
|
|
RARROW,
|
|
|
|
LARROW,
|
|
|
|
DARROW,
|
2012-06-04 20:34:10 -05:00
|
|
|
FAT_ARROW,
|
2012-01-19 19:56:05 -06:00
|
|
|
LPAREN,
|
|
|
|
RPAREN,
|
|
|
|
LBRACKET,
|
|
|
|
RBRACKET,
|
|
|
|
LBRACE,
|
|
|
|
RBRACE,
|
|
|
|
POUND,
|
2012-04-22 18:58:04 -05:00
|
|
|
DOLLAR,
|
2012-01-25 17:38:09 -06:00
|
|
|
|
2010-09-09 17:59:29 -05:00
|
|
|
/* Literals */
|
2012-01-19 19:56:05 -06:00
|
|
|
LIT_INT(i64, ast::int_ty),
|
|
|
|
LIT_UINT(u64, ast::uint_ty),
|
2012-06-14 21:41:40 -05:00
|
|
|
LIT_INT_UNSUFFIXED(i64),
|
2012-01-19 19:56:05 -06:00
|
|
|
LIT_FLOAT(str_num, ast::float_ty),
|
|
|
|
LIT_STR(str_num),
|
2010-09-09 17:59:29 -05:00
|
|
|
|
|
|
|
/* Name components */
|
2012-01-19 19:56:05 -06:00
|
|
|
IDENT(str_num, bool),
|
|
|
|
UNDERSCORE,
|
2012-06-12 12:50:17 -05:00
|
|
|
|
2012-06-29 20:26:34 -05:00
|
|
|
/* For interpolation */
|
2012-07-27 21:14:46 -05:00
|
|
|
INTERPOLATED(nonterminal),
|
2012-06-12 12:50:17 -05:00
|
|
|
|
2012-06-30 05:54:54 -05:00
|
|
|
DOC_COMMENT(str_num),
|
2012-01-19 19:56:05 -06:00
|
|
|
EOF,
|
2010-09-09 17:59:29 -05:00
|
|
|
}
|
2010-08-18 13:35:12 -05:00
|
|
|
|
2012-06-12 12:50:17 -05:00
|
|
|
#[auto_serialize]
|
2012-07-04 16:53:12 -05:00
|
|
|
/// For interpolation during macro expansion.
|
2012-07-27 21:14:46 -05:00
|
|
|
enum nonterminal {
|
|
|
|
nt_item(@ast::item),
|
|
|
|
nt_block(ast::blk),
|
|
|
|
nt_stmt(@ast::stmt),
|
|
|
|
nt_pat( @ast::pat),
|
|
|
|
nt_expr(@ast::expr),
|
|
|
|
nt_ty( @ast::ty),
|
|
|
|
nt_ident(str_num, bool),
|
|
|
|
nt_path(@ast::path),
|
|
|
|
nt_tt( @ast::token_tree), //needs @ed to break a circularity
|
|
|
|
nt_matchers(~[ast::matcher])
|
2012-06-12 12:50:17 -05:00
|
|
|
}
|
|
|
|
|
2012-07-14 00:57:48 -05:00
|
|
|
fn binop_to_str(o: binop) -> ~str {
|
2011-07-27 07:19:39 -05:00
|
|
|
alt o {
|
2012-07-14 00:57:48 -05:00
|
|
|
PLUS { ~"+" }
|
|
|
|
MINUS { ~"-" }
|
|
|
|
STAR { ~"*" }
|
|
|
|
SLASH { ~"/" }
|
|
|
|
PERCENT { ~"%" }
|
|
|
|
CARET { ~"^" }
|
|
|
|
AND { ~"&" }
|
|
|
|
OR { ~"|" }
|
|
|
|
SHL { ~"<<" }
|
|
|
|
SHR { ~">>" }
|
2010-08-20 17:57:59 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-07-14 00:57:48 -05:00
|
|
|
fn to_str(in: interner<@~str>, t: token) -> ~str {
|
2011-07-27 07:19:39 -05:00
|
|
|
alt t {
|
2012-07-14 00:57:48 -05:00
|
|
|
EQ { ~"=" }
|
|
|
|
LT { ~"<" }
|
|
|
|
LE { ~"<=" }
|
|
|
|
EQEQ { ~"==" }
|
|
|
|
NE { ~"!=" }
|
|
|
|
GE { ~">=" }
|
|
|
|
GT { ~">" }
|
|
|
|
NOT { ~"!" }
|
|
|
|
TILDE { ~"~" }
|
|
|
|
OROR { ~"||" }
|
|
|
|
ANDAND { ~"&&" }
|
2012-06-11 18:49:35 -05:00
|
|
|
BINOP(op) { binop_to_str(op) }
|
2012-07-14 00:57:48 -05:00
|
|
|
BINOPEQ(op) { binop_to_str(op) + ~"=" }
|
2011-09-02 17:34:58 -05:00
|
|
|
|
2011-07-27 07:19:39 -05:00
|
|
|
/* Structural symbols */
|
2012-07-14 00:57:48 -05:00
|
|
|
AT { ~"@" }
|
|
|
|
DOT { ~"." }
|
2012-08-03 20:01:30 -05:00
|
|
|
DOTDOT { ~".." }
|
2012-07-14 00:57:48 -05:00
|
|
|
ELLIPSIS { ~"..." }
|
|
|
|
COMMA { ~"," }
|
2012-07-30 18:09:42 -05:00
|
|
|
SEMI { ~";" }
|
2012-07-14 00:57:48 -05:00
|
|
|
COLON { ~":" }
|
|
|
|
MOD_SEP { ~"::" }
|
|
|
|
RARROW { ~"->" }
|
|
|
|
LARROW { ~"<-" }
|
|
|
|
DARROW { ~"<->" }
|
|
|
|
FAT_ARROW { ~"=>" }
|
|
|
|
LPAREN { ~"(" }
|
|
|
|
RPAREN { ~")" }
|
|
|
|
LBRACKET { ~"[" }
|
|
|
|
RBRACKET { ~"]" }
|
|
|
|
LBRACE { ~"{" }
|
|
|
|
RBRACE { ~"}" }
|
|
|
|
POUND { ~"#" }
|
|
|
|
DOLLAR { ~"$" }
|
2012-01-25 17:38:09 -06:00
|
|
|
|
2011-07-27 07:19:39 -05:00
|
|
|
/* Literals */
|
2012-01-19 00:37:22 -06:00
|
|
|
LIT_INT(c, ast::ty_char) {
|
2012-07-14 00:57:48 -05:00
|
|
|
~"'" + char::escape_default(c as char) + ~"'"
|
2011-12-07 14:06:12 -06:00
|
|
|
}
|
|
|
|
LIT_INT(i, t) {
|
2012-06-11 18:49:35 -05:00
|
|
|
int::to_str(i as int, 10u) + ast_util::int_ty_to_str(t)
|
2011-07-27 07:19:39 -05:00
|
|
|
}
|
2011-12-07 14:06:12 -06:00
|
|
|
LIT_UINT(u, t) {
|
2012-06-11 18:49:35 -05:00
|
|
|
uint::to_str(u as uint, 10u) + ast_util::uint_ty_to_str(t)
|
2011-07-27 07:19:39 -05:00
|
|
|
}
|
2012-06-14 21:41:40 -05:00
|
|
|
LIT_INT_UNSUFFIXED(i) {
|
|
|
|
int::to_str(i as int, 10u)
|
2012-06-11 18:31:03 -05:00
|
|
|
}
|
2012-07-31 13:49:20 -05:00
|
|
|
LIT_FLOAT(s, t) {
|
|
|
|
let mut body = *in.get(s);
|
2012-08-03 13:22:35 -05:00
|
|
|
if body.ends_with(~".") {
|
|
|
|
body = body + ~"0"; // `10.f` is not a float literal
|
2012-07-31 13:49:20 -05:00
|
|
|
}
|
|
|
|
body + ast_util::float_ty_to_str(t)
|
|
|
|
}
|
2012-07-17 13:22:11 -05:00
|
|
|
LIT_STR(s) { ~"\"" + str::escape_default( *in.get(s)) + ~"\"" }
|
2012-06-30 05:54:54 -05:00
|
|
|
|
2011-07-27 07:19:39 -05:00
|
|
|
/* Name components */
|
2012-07-17 13:22:11 -05:00
|
|
|
IDENT(s, _) { *in.get(s) }
|
|
|
|
|
2012-07-14 00:57:48 -05:00
|
|
|
UNDERSCORE { ~"_" }
|
2012-06-30 05:54:54 -05:00
|
|
|
|
|
|
|
/* Other */
|
2012-07-17 13:22:11 -05:00
|
|
|
DOC_COMMENT(s) { *in.get(s) }
|
2012-07-14 00:57:48 -05:00
|
|
|
EOF { ~"<eof>" }
|
2012-07-27 21:14:46 -05:00
|
|
|
INTERPOLATED(nt) {
|
2012-07-14 00:57:48 -05:00
|
|
|
~"an interpolated " +
|
2012-07-27 21:14:46 -05:00
|
|
|
alt nt {
|
|
|
|
nt_item(*) { ~"item" } nt_block(*) { ~"block" }
|
|
|
|
nt_stmt(*) { ~"statement" } nt_pat(*) { ~"pattern" }
|
|
|
|
nt_expr(*) { ~"expression" } nt_ty(*) { ~"type" }
|
|
|
|
nt_ident(*) { ~"identifier" } nt_path(*) { ~"path" }
|
|
|
|
nt_tt(*) { ~"tt" } nt_matchers(*) { ~"matcher sequence" }
|
2012-07-06 16:48:01 -05:00
|
|
|
}
|
2012-06-29 20:26:34 -05:00
|
|
|
}
|
2010-08-20 13:41:34 -05:00
|
|
|
}
|
|
|
|
}
|
2011-07-03 13:48:14 -05:00
|
|
|
|
2011-08-24 15:41:50 -05:00
|
|
|
pure fn can_begin_expr(t: token) -> bool {
|
2011-07-27 07:19:39 -05:00
|
|
|
alt t {
|
2012-01-19 00:37:22 -06:00
|
|
|
LPAREN { true }
|
|
|
|
LBRACE { true }
|
|
|
|
LBRACKET { true }
|
2011-07-27 07:19:39 -05:00
|
|
|
IDENT(_, _) { true }
|
2012-01-19 00:37:22 -06:00
|
|
|
UNDERSCORE { true }
|
|
|
|
TILDE { true }
|
2011-12-07 14:06:12 -06:00
|
|
|
LIT_INT(_, _) { true }
|
|
|
|
LIT_UINT(_, _) { true }
|
2012-06-14 21:41:40 -05:00
|
|
|
LIT_INT_UNSUFFIXED(_) { true }
|
2011-12-07 14:06:12 -06:00
|
|
|
LIT_FLOAT(_, _) { true }
|
2011-07-27 07:19:39 -05:00
|
|
|
LIT_STR(_) { true }
|
2012-01-19 00:37:22 -06:00
|
|
|
POUND { true }
|
|
|
|
AT { true }
|
|
|
|
NOT { true }
|
|
|
|
BINOP(MINUS) { true }
|
|
|
|
BINOP(STAR) { true }
|
2012-03-23 18:15:58 -05:00
|
|
|
BINOP(AND) { true }
|
2012-06-30 23:20:36 -05:00
|
|
|
BINOP(OR) { true } // in lambda syntax
|
|
|
|
OROR { true } // in lambda syntax
|
2012-01-19 00:37:22 -06:00
|
|
|
MOD_SEP { true }
|
2012-07-27 21:14:46 -05:00
|
|
|
INTERPOLATED(nt_expr(*))
|
|
|
|
| INTERPOLATED(nt_ident(*))
|
|
|
|
| INTERPOLATED(nt_block(*))
|
|
|
|
| INTERPOLATED(nt_path(*)) { true }
|
2011-07-27 07:19:39 -05:00
|
|
|
_ { false }
|
2011-07-03 13:48:14 -05:00
|
|
|
}
|
|
|
|
}
|
2011-10-07 09:22:53 -05:00
|
|
|
|
2012-07-31 15:53:00 -05:00
|
|
|
/// what's the opposite delimiter?
|
|
|
|
fn flip_delimiter(&t: token::token) -> token::token {
|
|
|
|
alt t {
|
|
|
|
token::LPAREN { token::RPAREN }
|
|
|
|
token::LBRACE { token::RBRACE }
|
|
|
|
token::LBRACKET { token::RBRACKET }
|
|
|
|
token::RPAREN { token::LPAREN }
|
|
|
|
token::RBRACE { token::LBRACE }
|
|
|
|
token::RBRACKET { token::LBRACKET }
|
|
|
|
_ { fail }
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2012-06-11 18:49:35 -05:00
|
|
|
fn is_lit(t: token) -> bool {
|
|
|
|
alt t {
|
|
|
|
LIT_INT(_, _) { true }
|
|
|
|
LIT_UINT(_, _) { true }
|
2012-06-14 21:41:40 -05:00
|
|
|
LIT_INT_UNSUFFIXED(_) { true }
|
2012-06-11 18:49:35 -05:00
|
|
|
LIT_FLOAT(_, _) { true }
|
|
|
|
LIT_STR(_) { true }
|
|
|
|
_ { false }
|
|
|
|
}
|
2012-04-22 16:59:04 -05:00
|
|
|
}
|
|
|
|
|
2012-06-11 18:49:35 -05:00
|
|
|
pure fn is_ident(t: token) -> bool {
|
|
|
|
alt t { IDENT(_, _) { true } _ { false } }
|
2012-04-17 23:14:40 -05:00
|
|
|
}
|
|
|
|
|
2012-06-11 18:49:35 -05:00
|
|
|
pure fn is_plain_ident(t: token) -> bool {
|
|
|
|
alt t { IDENT(_, false) { true } _ { false } }
|
2012-04-17 23:14:40 -05:00
|
|
|
}
|
|
|
|
|
2012-06-11 18:49:35 -05:00
|
|
|
pure fn is_bar(t: token) -> bool {
|
|
|
|
alt t { BINOP(OR) | OROR { true } _ { false } }
|
2012-04-17 23:14:40 -05:00
|
|
|
}
|
|
|
|
|
2012-07-04 16:53:12 -05:00
|
|
|
/**
|
|
|
|
* All the valid words that have meaning in the Rust language.
|
|
|
|
*
|
|
|
|
* Rust keywords are either 'contextual' or 'restricted'. Contextual
|
|
|
|
* keywords may be used as identifiers because their appearance in
|
|
|
|
* the grammar is unambiguous. Restricted keywords may not appear
|
|
|
|
* in positions that might otherwise contain _value identifiers_.
|
|
|
|
*/
|
2012-07-14 00:57:48 -05:00
|
|
|
fn keyword_table() -> hashmap<~str, ()> {
|
2012-04-19 18:44:24 -05:00
|
|
|
let keywords = str_hash();
|
2012-06-30 18:19:07 -05:00
|
|
|
for contextual_keyword_table().each_key |word| {
|
2012-04-25 00:33:49 -05:00
|
|
|
keywords.insert(word, ());
|
|
|
|
}
|
2012-06-30 18:19:07 -05:00
|
|
|
for restricted_keyword_table().each_key |word| {
|
2012-04-19 18:44:24 -05:00
|
|
|
keywords.insert(word, ());
|
|
|
|
}
|
2012-06-11 18:49:35 -05:00
|
|
|
keywords
|
2012-04-25 00:33:49 -05:00
|
|
|
}
|
|
|
|
|
2012-07-04 16:53:12 -05:00
|
|
|
/// Keywords that may be used as identifiers
|
2012-07-14 00:57:48 -05:00
|
|
|
fn contextual_keyword_table() -> hashmap<~str, ()> {
|
2012-04-25 00:33:49 -05:00
|
|
|
let words = str_hash();
|
2012-06-29 18:26:56 -05:00
|
|
|
let keys = ~[
|
2012-07-14 00:57:48 -05:00
|
|
|
~"as",
|
|
|
|
~"else",
|
|
|
|
~"move",
|
|
|
|
~"of",
|
|
|
|
~"priv", ~"pub",
|
|
|
|
~"self", ~"send", ~"static",
|
|
|
|
~"to",
|
|
|
|
~"use",
|
|
|
|
~"with"
|
2012-06-29 18:26:56 -05:00
|
|
|
];
|
2012-06-30 18:19:07 -05:00
|
|
|
for keys.each |word| {
|
2012-04-25 00:33:49 -05:00
|
|
|
words.insert(word, ());
|
2012-04-19 18:44:24 -05:00
|
|
|
}
|
2012-04-25 00:33:49 -05:00
|
|
|
words
|
2012-04-19 18:44:24 -05:00
|
|
|
}
|
|
|
|
|
2012-07-04 16:53:12 -05:00
|
|
|
/**
|
|
|
|
* Keywords that may not appear in any position that might otherwise contain a
|
|
|
|
* _value identifier_. Restricted keywords may still be used as other types of
|
|
|
|
* identifiers.
|
|
|
|
*
|
|
|
|
* Reasons:
|
|
|
|
*
|
|
|
|
* * For some (most?), if used at the start of a line, they will cause the
|
|
|
|
* line to be interpreted as a specific kind of statement, which would be
|
|
|
|
* confusing.
|
|
|
|
*
|
|
|
|
* * `true` or `false` as identifiers would always be shadowed by
|
|
|
|
* the boolean constants
|
|
|
|
*/
|
2012-07-14 00:57:48 -05:00
|
|
|
fn restricted_keyword_table() -> hashmap<~str, ()> {
|
2012-04-17 23:14:40 -05:00
|
|
|
let words = str_hash();
|
2012-06-29 18:26:56 -05:00
|
|
|
let keys = ~[
|
2012-07-14 00:57:48 -05:00
|
|
|
~"alt", ~"again", ~"assert",
|
|
|
|
~"break",
|
2012-07-13 20:43:52 -05:00
|
|
|
~"check", ~"class", ~"const", ~"copy",
|
2012-07-14 00:57:48 -05:00
|
|
|
~"do", ~"drop",
|
|
|
|
~"else", ~"enum", ~"export", ~"extern",
|
|
|
|
~"fail", ~"false", ~"fn", ~"for",
|
2012-08-02 20:41:18 -05:00
|
|
|
~"if", ~"iface", ~"impl", ~"import",
|
2012-07-14 00:57:48 -05:00
|
|
|
~"let", ~"log", ~"loop",
|
2012-07-31 19:31:24 -05:00
|
|
|
~"match", ~"mod", ~"module", ~"move", ~"mut",
|
2012-07-11 17:00:40 -05:00
|
|
|
~"new",
|
|
|
|
~"owned",
|
|
|
|
~"pure",
|
2012-08-01 19:30:05 -05:00
|
|
|
~"ref", ~"return",
|
2012-07-11 17:00:40 -05:00
|
|
|
~"struct",
|
2012-07-14 00:57:48 -05:00
|
|
|
~"true", ~"trait", ~"type",
|
|
|
|
~"unchecked", ~"unsafe",
|
|
|
|
~"while"
|
2012-06-29 18:26:56 -05:00
|
|
|
];
|
2012-06-30 18:19:07 -05:00
|
|
|
for keys.each |word| {
|
2012-04-17 23:14:40 -05:00
|
|
|
words.insert(word, ());
|
|
|
|
}
|
|
|
|
words
|
|
|
|
}
|
|
|
|
|
2010-08-18 13:35:12 -05:00
|
|
|
// Local Variables:
|
|
|
|
// fill-column: 78;
|
|
|
|
// indent-tabs-mode: nil
|
|
|
|
// c-basic-offset: 4
|
|
|
|
// buffer-file-coding-system: utf-8-unix
|
|
|
|
// End:
|