user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Convert alt to match. Stop parsing alt

Browse source
This commit is contained in:
Brian Anderson 2012-08-06 12:34:08 -07:00
parent d3a9bb1bd4
commit ecaf9e39c9
359 changed files with 2938 additions and 2915 deletions
Download patch file Download diff file Expand all files Collapse all files

134
src/cargo/cargo.rs
View file

@ -128,7 +128,7 @@ fn is_uuid(id: ~str) -> bool {
return false;
}
alt i {
match i {
0u => {
if str::len(part) == 8u {
correct += 1u;
@ -192,7 +192,7 @@ fn is_archive_url(u: ~str) -> bool {
// FIXME (#2661): this requires the protocol bit - if we had proper
// url parsing, we wouldn't need it
alt str::find_str(u, ~"://") {
match str::find_str(u, ~"://") {
option::some(i) => has_archive_extension(u),
_ => false
}
@ -223,9 +223,9 @@ fn load_link(mis: ~[@ast::meta_item]) -> (option<~str>,
let mut vers = none;
let mut uuid = none;
for mis.each |a| {
alt a.node {
match a.node {
ast::meta_name_value(v, {node: ast::lit_str(s), span: _}) => {
alt *v {
match *v {
~"name" => name = some(*s),
~"vers" => vers = some(*s),
~"uuid" => uuid = some(*s),
@ -250,9 +250,9 @@ fn load_crate(filename: ~str) -> option<crate> {
let mut crate_type = none;
for c.node.attrs.each |a| {
alt a.node.value.node {
match a.node.value.node {
ast::meta_name_value(v, {node: ast::lit_str(s), span: _}) => {
alt *v {
match *v {
~"desc" => desc = some(*v),
~"sigs" => sigs = some(*v),
~"crate_type" => crate_type = some(*v),
@ -279,7 +279,7 @@ fn load_crate(filename: ~str) -> option<crate> {
};
fn goto_view_item(e: env, i: @ast::view_item) {
alt i.node {
match i.node {
ast::view_item_use(ident, metas, id) => {
let name_items =
attr::find_meta_items_by_name(metas, ~"name");
@ -293,11 +293,11 @@ fn load_crate(filename: ~str) -> option<crate> {
let mut attr_from = ~"";
for m.each |item| {
alt attr::get_meta_item_value_str(item) {
match attr::get_meta_item_value_str(item) {
some(value) => {
let name = attr::get_meta_item_name(item);
alt *name {
match *name {
~"vers" => attr_vers = *value,
~"from" => attr_from = *value,
_ => ()
@ -315,7 +315,7 @@ fn load_crate(filename: ~str) -> option<crate> {
} else { *attr_name }
};
alt *attr_name {
match *attr_name {
~"std" | ~"core" => (),
_ => vec::push(e.deps, query)
}
@ -339,7 +339,7 @@ fn load_crate(filename: ~str) -> option<crate> {
let deps = copy e.deps;
alt (name, vers, uuid) {
match (name, vers, uuid) {
(some(name0), some(vers0), some(uuid0)) => {
some({
name: name0,
@ -390,21 +390,21 @@ fn parse_source(name: ~str, j: json::json) -> source {
fail fmt!{"'%s' is an invalid source name", name};
}
alt j {
match j {
json::dict(j) => {
let mut url = alt j.find(~"url") {
let mut url = match j.find(~"url") {
some(json::string(u)) => *u,
_ => fail ~"needed 'url' field in source"
};
let method = alt j.find(~"method") {
let method = match j.find(~"method") {
some(json::string(u)) => *u,
_ => assume_source_method(url)
};
let key = alt j.find(~"key") {
let key = match j.find(~"key") {
some(json::string(u)) => some(*u),
_ => none
};
let keyfp = alt j.find(~"keyfp") {
let keyfp = match j.find(~"keyfp") {
some(json::string(u)) => some(*u),
_ => none
};
@ -426,7 +426,7 @@ fn parse_source(name: ~str, j: json::json) -> source {
fn try_parse_sources(filename: ~str, sources: map::hashmap<~str, source>) {
if !os::path_exists(filename) { return; }
let c = io::read_whole_file_str(filename);
alt json::from_str(result::get(c)) {
match json::from_str(result::get(c)) {
ok(json::dict(j)) => {
for j.each |k, v| {
sources.insert(k, parse_source(k, v));
@ -439,7 +439,7 @@ fn try_parse_sources(filename: ~str, sources: map::hashmap<~str, source>) {
}
fn load_one_source_package(src: source, p: map::hashmap<~str, json::json>) {
let name = alt p.find(~"name") {
let name = match p.find(~"name") {
some(json::string(n)) => {
if !valid_pkg_name(*n) {
warn(~"malformed source json: "
@ -456,7 +456,7 @@ fn load_one_source_package(src: source, p: map::hashmap<~str, json::json>) {
}
};
let uuid = alt p.find(~"uuid") {
let uuid = match p.find(~"uuid") {
some(json::string(n)) => {
if !is_uuid(*n) {
warn(~"malformed source json: "
@ -472,7 +472,7 @@ fn load_one_source_package(src: source, p: map::hashmap<~str, json::json>) {
}
};
let url = alt p.find(~"url") {
let url = match p.find(~"url") {
some(json::string(n)) => *n,
_ => {
warn(~"malformed source json: " + src.name + ~" (missing url)");
@ -480,7 +480,7 @@ fn load_one_source_package(src: source, p: map::hashmap<~str, json::json>) {
}
};
let method = alt p.find(~"method") {
let method = match p.find(~"method") {
some(json::string(n)) => *n,
_ => {
warn(~"malformed source json: "
@ -489,16 +489,16 @@ fn load_one_source_package(src: source, p: map::hashmap<~str, json::json>) {
}
};
let reference = alt p.find(~"ref") {
let reference = match p.find(~"ref") {
some(json::string(n)) => some(*n),
_ => none
};
let mut tags = ~[];
alt p.find(~"tags") {
match p.find(~"tags") {
some(json::list(js)) => {
for (*js).each |j| {
alt j {
match j {
json::string(j) => vec::grow(tags, 1u, *j),
_ => ()
}
@ -507,7 +507,7 @@ fn load_one_source_package(src: source, p: map::hashmap<~str, json::json>) {
_ => ()
}
let description = alt p.find(~"description") {
let description = match p.find(~"description") {
some(json::string(n)) => *n,
_ => {
warn(~"malformed source json: " + src.name
@ -527,7 +527,7 @@ fn load_one_source_package(src: source, p: map::hashmap<~str, json::json>) {
versions: ~[]
};
alt vec::position(src.packages, |pkg| pkg.uuid == uuid) {
match vec::position(src.packages, |pkg| pkg.uuid == uuid) {
some(idx) => {
src.packages[idx] = newpkg;
log(debug, ~" updated package: " + src.name + ~"/" + name);
@ -545,7 +545,7 @@ fn load_source_info(c: cargo, src: source) {
let srcfile = path::connect(dir, ~"source.json");
if !os::path_exists(srcfile) { return; }
let srcstr = io::read_whole_file_str(srcfile);
alt json::from_str(result::get(srcstr)) {
match json::from_str(result::get(srcstr)) {
ok(json::dict(s)) => {
let o = parse_source(src.name, json::dict(s));
@ -567,10 +567,10 @@ fn load_source_packages(c: cargo, src: source) {
let pkgfile = path::connect(dir, ~"packages.json");
if !os::path_exists(pkgfile) { return; }
let pkgstr = io::read_whole_file_str(pkgfile);
alt json::from_str(result::get(pkgstr)) {
match json::from_str(result::get(pkgstr)) {
ok(json::list(js)) => {
for (*js).each |j| {
alt j {
match j {
json::dict(p) => {
load_one_source_package(src, p);
}
@ -592,7 +592,7 @@ fn load_source_packages(c: cargo, src: source) {
}
fn build_cargo_options(argv: ~[~str]) -> options {
let matches = alt getopts::getopts(argv, opts()) {
let matches = match getopts::getopts(argv, opts()) {
result::ok(m) => m,
result::err(f) => {
fail fmt!{"%s", getopts::fail_str(f)};
@ -623,12 +623,12 @@ fn build_cargo_options(argv: ~[~str]) -> options {
}
fn configure(opts: options) -> cargo {
let home = alt get_cargo_root() {
let home = match get_cargo_root() {
ok(home) => home,
err(_err) => result::get(get_cargo_sysroot())
};
let get_cargo_dir = alt opts.mode {
let get_cargo_dir = match opts.mode {
system_mode => get_cargo_sysroot,
user_mode => get_cargo_root,
local_mode => get_cargo_root_nearest
@ -716,7 +716,7 @@ fn run_in_buildpath(what: ~str, path: ~str, subdir: ~str, cf: ~str,
}
fn test_one_crate(_c: cargo, path: ~str, cf: ~str) {
let buildpath = alt run_in_buildpath(~"testing", path, ~"/test", cf,
let buildpath = match run_in_buildpath(~"testing", path, ~"/test", cf,
~[ ~"--test"]) {
none => return,
some(bp) => bp
@ -725,7 +725,7 @@ fn test_one_crate(_c: cargo, path: ~str, cf: ~str) {
}
fn install_one_crate(c: cargo, path: ~str, cf: ~str) {
let buildpath = alt run_in_buildpath(~"installing", path,
let buildpath = match run_in_buildpath(~"installing", path,
~"/build", cf, ~[]) {
none => return,
some(bp) => bp
@ -752,7 +752,7 @@ fn install_one_crate(c: cargo, path: ~str, cf: ~str) {
fn rustc_sysroot() -> ~str {
alt os::self_exe_path() {
match os::self_exe_path() {
some(path) => {
let path = ~[path, ~"..", ~"bin", ~"rustc"];
let rustc = path::normalize(path::connect_many(path));
@ -779,7 +779,7 @@ fn install_source(c: cargo, path: ~str) {
}
for cratefiles.each |cf| {
alt load_crate(cf) {
match load_crate(cf) {
none => again,
some(crate) => {
for crate.deps.each |query| {
@ -788,7 +788,7 @@ fn install_source(c: cargo, path: ~str) {
// condition")
let wd_base = c.workdir + path::path_sep();
let wd = alt tempfile::mkdtemp(wd_base, ~"") {
let wd = match tempfile::mkdtemp(wd_base, ~"") {
some(wd) => wd,
none => fail fmt!{"needed temp dir: %s", wd_base}
};
@ -838,7 +838,7 @@ fn install_file(c: cargo, wd: ~str, path: ~str) {
fn install_package(c: cargo, src: ~str, wd: ~str, pkg: package) {
let url = copy pkg.url;
let method = alt pkg.method {
let method = match pkg.method {
~"git" => ~"git",
~"file" => ~"file",
_ => ~"curl"
@ -846,7 +846,7 @@ fn install_package(c: cargo, src: ~str, wd: ~str, pkg: package) {
info(fmt!{"installing %s/%s via %s...", src, pkg.name, method});
alt method {
match method {
~"git" => install_git(c, wd, url, copy pkg.reference),
~"file" => install_file(c, wd, url),
~"curl" => install_curl(c, wd, copy url),
@ -913,7 +913,7 @@ fn install_named(c: cargo, wd: ~str, name: ~str) {
}
fn install_uuid_specific(c: cargo, wd: ~str, src: ~str, uuid: ~str) {
alt c.sources.find(src) {
match c.sources.find(src) {
some(s) => {
let packages = copy s.packages;
if vec::any(packages, |p| {
@ -929,7 +929,7 @@ fn install_uuid_specific(c: cargo, wd: ~str, src: ~str, uuid: ~str) {
}
fn install_named_specific(c: cargo, wd: ~str, src: ~str, name: ~str) {
alt c.sources.find(src) {
match c.sources.find(src) {
some(s) => {
let packages = copy s.packages;
if vec::any(packages, |p| {
@ -960,7 +960,7 @@ fn cmd_uninstall(c: cargo) {
// name only)
if is_uuid(target) {
for os::list_dir(lib).each |file| {
alt str::find_str(file, ~"-" + target + ~"-") {
match str::find_str(file, ~"-" + target + ~"-") {
some(idx) => {
let full = path::normalize(path::connect(lib, file));
if os::remove_file(full) {
@ -977,7 +977,7 @@ fn cmd_uninstall(c: cargo) {
error(~"can't find package with uuid: " + target);
} else {
for os::list_dir(lib).each |file| {
alt str::find_str(file, ~"lib" + target + ~"-") {
match str::find_str(file, ~"lib" + target + ~"-") {
some(idx) => {
let full = path::normalize(path::connect(lib,
file));
@ -992,7 +992,7 @@ fn cmd_uninstall(c: cargo) {
}
}
for os::list_dir(bin).each |file| {
alt str::find_str(file, target) {
match str::find_str(file, target) {
some(idx) => {
let full = path::normalize(path::connect(bin, file));
if os::remove_file(full) {
@ -1011,7 +1011,7 @@ fn cmd_uninstall(c: cargo) {
}
fn install_query(c: cargo, wd: ~str, target: ~str) {
alt c.dep_cache.find(target) {
match c.dep_cache.find(target) {
some(inst) => {
if inst {
return;
@ -1038,7 +1038,7 @@ fn install_query(c: cargo, wd: ~str, target: ~str) {
} else {
let mut ps = copy target;
alt str::find_char(ps, '/') {
match str::find_char(ps, '/') {
option::some(idx) => {
let source = str::slice(ps, 0u, idx);
ps = str::slice(ps, idx + 1u, str::len(ps));
@ -1072,7 +1072,7 @@ fn install_query(c: cargo, wd: ~str, target: ~str) {
fn cmd_install(c: cargo) unsafe {
let wd_base = c.workdir + path::path_sep();
let wd = alt tempfile::mkdtemp(wd_base, ~"") {
let wd = match tempfile::mkdtemp(wd_base, ~"") {
some(wd) => wd,
none => fail fmt!{"needed temp dir: %s", wd_base}
};
@ -1129,7 +1129,7 @@ fn sync_one_file(c: cargo, dir: ~str, src: source) -> bool {
os::copy_file(path::connect(url, ~"source.json.sig"), srcsigfile);
os::copy_file(path::connect(url, ~"packages.json.sig"), sigfile);
alt copy src.key {
match copy src.key {
some(u) => {
let p = run::program_output(~"curl",
~[~"-f", ~"-s", ~"-o", keyfile, u]);
@ -1141,7 +1141,7 @@ fn sync_one_file(c: cargo, dir: ~str, src: source) -> bool {
}
_ => ()
}
alt (src.key, src.keyfp) {
match (src.key, src.keyfp) {
(some(_), some(f)) => {
let r = pgp::verify(c.root, pkgfile, sigfile, f);
@ -1238,7 +1238,7 @@ fn sync_one_git(c: cargo, dir: ~str, src: source) -> bool {
let has_src_file = os::path_exists(srcfile);
alt copy src.key {
match copy src.key {
some(u) => {
let p = run::program_output(~"curl",
~[~"-f", ~"-s", ~"-o", keyfile, u]);
@ -1251,7 +1251,7 @@ fn sync_one_git(c: cargo, dir: ~str, src: source) -> bool {
}
_ => ()
}
alt (src.key, src.keyfp) {
match (src.key, src.keyfp) {
(some(_), some(f)) => {
let r = pgp::verify(c.root, pkgfile, sigfile, f);
@ -1318,7 +1318,7 @@ fn sync_one_curl(c: cargo, dir: ~str, src: source) -> bool {
}
}
alt copy src.key {
match copy src.key {
some(u) => {
let p = run::program_output(~"curl",
~[~"-f", ~"-s", ~"-o", keyfile, u]);
@ -1330,7 +1330,7 @@ fn sync_one_curl(c: cargo, dir: ~str, src: source) -> bool {
}
_ => ()
}
alt (src.key, src.keyfp) {
match (src.key, src.keyfp) {
(some(_), some(f)) => {
if smart {
url = src.url + ~"/packages.json.sig";
@ -1403,7 +1403,7 @@ fn sync_one(c: cargo, src: source) {
need_dir(dir);
let result = alt src.method {
let result = match src.method {
~"git" => sync_one_git(c, dir, src),
~"file" => sync_one_file(c, dir, src),
_ => sync_one_curl(c, dir, src)
@ -1490,7 +1490,7 @@ fn cmd_list(c: cargo) {
if !valid_pkg_name(name) {
error(fmt!{"'%s' is an invalid source name", name});
} else {
alt c.sources.find(name) {
match c.sources.find(name) {
some(source) => {
print_source(source);
}
@ -1562,7 +1562,7 @@ fn dump_sources(c: cargo) {
copy_warn(out, path::connect(c.root, ~"sources.json.old"));
}
alt io::buffered_file_writer(out) {
match io::buffered_file_writer(out) {
result::ok(writer) => {
let hash = map::str_hash();
let root = json::dict(hash);
@ -1574,13 +1574,13 @@ fn dump_sources(c: cargo) {
chash.insert(~"url", json::string(@v.url));
chash.insert(~"method", json::string(@v.method));
alt copy v.key {
match copy v.key {
some(key) => {
chash.insert(~"key", json::string(@key));
}
_ => ()
}
alt copy v.keyfp {
match copy v.keyfp {
some(keyfp) => {
chash.insert(~"keyfp", json::string(@keyfp));
}
@ -1615,7 +1615,7 @@ fn cmd_sources(c: cargo) {
let action = c.opts.free[2u];
alt action {
match action {
~"clear" => {
for c.sources.each_key |k| {
c.sources.remove(k);
@ -1637,7 +1637,7 @@ fn cmd_sources(c: cargo) {
return;
}
alt c.sources.find(name) {
match c.sources.find(name) {
some(source) => {
error(fmt!{"source already exists: %s", name});
}
@ -1667,7 +1667,7 @@ fn cmd_sources(c: cargo) {
return;
}
alt c.sources.find(name) {
match c.sources.find(name) {
some(source) => {
c.sources.remove(name);
info(fmt!{"removed source: %s", name});
@ -1691,7 +1691,7 @@ fn cmd_sources(c: cargo) {
return;
}
alt c.sources.find(name) {
match c.sources.find(name) {
some(source) => {
let old = copy source.url;
let method = assume_source_method(url);
@ -1722,11 +1722,11 @@ fn cmd_sources(c: cargo) {
return;
}
alt c.sources.find(name) {
match c.sources.find(name) {
some(source) => {
let old = copy source.method;
source.method = alt method {
source.method = match method {
~"git" => ~"git",
~"file" => ~"file",
_ => ~"curl"
@ -1760,7 +1760,7 @@ fn cmd_sources(c: cargo) {
return;
}
alt c.sources.find(name) {
match c.sources.find(name) {
some(source) => {
c.sources.remove(name);
c.sources.insert(newn, source);
@ -1874,7 +1874,7 @@ fn main(argv: ~[~str]) {
return;
}
if o.help {
alt o.free[1] {
match o.free[1] {
~"init" => cmd_usage_init(),
~"install" => cmd_usage_install(),
~"uninstall" => cmd_usage_uninstall(),
@ -1901,7 +1901,7 @@ fn main(argv: ~[~str]) {
c = configure(o);
}
alt o.free[1] {
match o.free[1] {
~"init" => cmd_init(c),
~"install" => cmd_install(c),
~"uninstall" => cmd_uninstall(c),

14
src/compiletest/compiletest.rs
View file

@ -37,7 +37,7 @@ fn parse_config(args: ~[~str]) -> config {
assert (vec::is_not_empty(args));
let args_ = vec::tail(args);
let matches =
alt getopts::getopts(args_, opts) {
match getopts::getopts(args_, opts) {
ok(m) => m,
err(f) => fail getopts::fail_str(f)
};
@ -80,7 +80,7 @@ fn log_config(config: config) {
}
fn opt_str(maybestr: option<~str>) -> ~str {
alt maybestr { option::some(s) => s, option::none => ~"(none)" }
match maybestr { option::some(s) => s, option::none => ~"(none)" }
}
fn str_opt(maybestr: ~str) -> option<~str> {
@ -88,7 +88,7 @@ fn str_opt(maybestr: ~str) -> option<~str> {
}
fn str_mode(s: ~str) -> mode {
alt s {
match s {
~"compile-fail" => mode_compile_fail,
~"run-fail" => mode_run_fail,
~"run-pass" => mode_run_pass,
@ -98,7 +98,7 @@ fn str_mode(s: ~str) -> mode {
}
fn mode_str(mode: mode) -> ~str {
alt mode {
match mode {
mode_compile_fail => ~"compile-fail",
mode_run_fail => ~"run-fail",
mode_run_pass => ~"run-pass",
@ -115,13 +115,13 @@ fn run_tests(config: config) {
fn test_opts(config: config) -> test::test_opts {
{filter:
alt config.filter {
match config.filter {
option::some(s) => option::some(s),
option::none => option::none
},
run_ignored: config.run_ignored,
logfile:
alt config.logfile {
match config.logfile {
option::some(s) => option::some(s),
option::none => option::none
}
@ -144,7 +144,7 @@ fn make_tests(config: config) -> ~[test::test_desc] {
fn is_test(config: config, testfile: ~str) -> bool {
// Pretty-printer does not work with .rc files yet
let valid_extensions =
alt config.mode {
match config.mode {
mode_pretty => ~[~".rs"],
_ => ~[~".rc", ~".rs"]
};

2
src/compiletest/errors.rs
View file

@ -23,7 +23,7 @@ fn load_errors(testfile: ~str) -> ~[expected_error] {
fn parse_expected(line_num: uint, line: ~str) -> ~[expected_error] unsafe {
let error_tag = ~"//~";
let mut idx;
alt str::find_str(line, error_tag) {
match str::find_str(line, error_tag) {
option::none => return ~[],
option::some(nn) => { idx = (nn as uint) + str::len(error_tag); }
}

8
src/compiletest/header.rs
View file

@ -30,7 +30,7 @@ fn load_props(testfile: ~str) -> test_props {
let mut compile_flags = option::none;
let mut pp_exact = option::none;
for iter_header(testfile) |ln| {
alt parse_error_pattern(ln) {
match parse_error_pattern(ln) {
option::some(ep) => vec::push(error_patterns, ep),
option::none => ()
};
@ -107,7 +107,7 @@ fn parse_exec_env(line: ~str) -> option<(~str, ~str)> {
do parse_name_value_directive(line, ~"exec-env").map |nv| {
// nv is either FOO or FOO=BAR
let strs = str::splitn_char(nv, '=', 1u);
alt strs.len() {
match strs.len() {
1u => (strs[0], ~""),
2u => (strs[0], strs[1]),
n => fail fmt!{"Expected 1 or 2 strings, not %u", n}
@ -116,7 +116,7 @@ fn parse_exec_env(line: ~str) -> option<(~str, ~str)> {
}
fn parse_pp_exact(line: ~str, testfile: ~str) -> option<~str> {
alt parse_name_value_directive(line, ~"pp-exact") {
match parse_name_value_directive(line, ~"pp-exact") {
option::some(s) => option::some(s),
option::none => {
if parse_name_directive(line, ~"pp-exact") {
@ -135,7 +135,7 @@ fn parse_name_directive(line: ~str, directive: ~str) -> bool {
fn parse_name_value_directive(line: ~str,
directive: ~str) -> option<~str> unsafe {
let keycolon = directive + ~":";
alt str::find_str(line, keycolon) {
match str::find_str(line, keycolon) {
option::some(colon) => {
let value = str::slice(line, colon + str::len(keycolon),
str::len(line));

2
src/compiletest/procsrv.rs
View file

@ -76,7 +76,7 @@ fn run(lib_path: ~str,
let mut outs = ~"";
let mut count = 2;
while count > 0 {
alt p.recv() {
match p.recv() {
(1, s) => {
outs = s;
}

10
src/compiletest/runtest.rs
View file

@ -18,7 +18,7 @@ fn run(config: config, testfile: ~str) {
}
debug!{"running %s", testfile};
let props = load_props(testfile);
alt config.mode {
match config.mode {
mode_compile_fail => run_cfail_test(config, props, testfile),
mode_run_fail => run_rfail_test(config, props, testfile),
mode_run_pass => run_rpass_test(config, props, testfile),
@ -90,7 +90,7 @@ fn run_pretty_test(config: config, props: test_props, testfile: ~str) {
} else { logv(config, ~"testing for converging pretty-printing"); }
let rounds =
alt props.pp_exact { option::some(_) => 1, option::none => 2 };
match props.pp_exact { option::some(_) => 1, option::none => 2 };
let mut srcs = ~[result::get(io::read_whole_file_str(testfile))];
@ -109,7 +109,7 @@ fn run_pretty_test(config: config, props: test_props, testfile: ~str) {
}
let mut expected =
alt props.pp_exact {
match props.pp_exact {
option::some(file) => {
let filepath = path::connect(path::dirname(testfile), file);
result::get(io::read_whole_file_str(filepath))
@ -383,7 +383,7 @@ fn make_run_args(config: config, _props: test_props, testfile: ~str) ->
// If we've got another tool to run under (valgrind),
// then split apart its command
let runtool =
alt config.runtool {
match config.runtool {
option::some(s) => option::some(s),
option::none => option::none
};
@ -402,7 +402,7 @@ fn split_maybe_args(argstr: option<~str>) -> ~[~str] {
vec::filter_map(v, flt)
}
alt argstr {
match argstr {
option::some(s) => rm_whitespace(str::split_char(s, ' ')),
option::none => ~[]
}

2
src/compiletest/util.rs
View file

@ -7,7 +7,7 @@ fn make_new_path(path: ~str) -> ~str {
// Windows just uses PATH as the library search path, so we have to
// maintain the current value while adding our own
alt getenv(lib_path_env_var()) {
match getenv(lib_path_env_var()) {
option::some(curr) => {
fmt!{"%s%s%s", path, path_div(), curr}
}

18
src/fuzzer/fuzzer.rs
View file

@ -62,9 +62,9 @@ pure fn safe_to_steal_expr(e: @ast::expr, tm: test_mode) -> bool {
}
pure fn safe_to_use_expr(e: ast::expr, tm: test_mode) -> bool {
alt tm {
match tm {
tm_converge => {
alt e.node {
match e.node {
// If the fuzzer moves a block-ending-in-semicolon into callee
// position, the pretty-printer can't preserve this even by
// parenthesizing!! See email to marijn.
@ -139,7 +139,7 @@ fn steal(crate: ast::crate, tm: test_mode) -> stolen_stuff {
fn safe_to_replace_expr(e: ast::expr_, _tm: test_mode) -> bool {
alt e {
match e {
// https://github.com/mozilla/rust/issues/652
ast::expr_if(*) => { false }
ast::expr_block(_) => { false }
@ -152,7 +152,7 @@ fn safe_to_replace_expr(e: ast::expr_, _tm: test_mode) -> bool {
}
fn safe_to_replace_ty(t: ast::ty_, _tm: test_mode) -> bool {
alt t {
match t {
ast::ty_infer => { false } // always implicit, always top level
ast::ty_bot => { false } // in source, can only appear
// as the out type of a function
@ -272,7 +272,7 @@ fn check_variants_T<T: copy>(
io::str_reader(~""), a,
pprust::no_ann(),
false));
alt cx.mode {
match cx.mode {
tm_converge => {
check_roundtrip_convergence(str3, 1u);
}
@ -314,12 +314,12 @@ fn check_whole_compiler(code: ~str, suggested_filename_prefix: ~str,
let compile_result = check_compiling(filename);
let run_result = alt (compile_result, allow_running) {
let run_result = match (compile_result, allow_running) {
(passed, true) => { check_running(suggested_filename_prefix) }
(h, _) => { h }
};
alt run_result {
match run_result {
passed | cleanly_rejected(_) | known_bug(_) => {
removeIfExists(suggested_filename_prefix);
removeIfExists(suggested_filename_prefix + ~".rs");
@ -364,7 +364,7 @@ fn check_running(exe_filename: ~str) -> happiness {
} else if contains(comb, ~"malloc") {
failed(~"Mentioned malloc")
} else {
alt p.status {
match p.status {
0 => { passed }
100 => { cleanly_rejected(~"running: explicit fail") }
101 | 247 => { cleanly_rejected(~"running: timed out") }
@ -441,7 +441,7 @@ fn parse_and_print(code: @~str) -> ~str {
fn has_raw_pointers(c: ast::crate) -> bool {
let has_rp = @mut false;
fn visit_ty(flag: @mut bool, t: @ast::ty) {
alt t.node {
match t.node {
ast::ty_ptr(_) => { *flag = true; }
_ => { }
}

2
src/libcore/bool.rs
View file

@ -39,7 +39,7 @@ pure fn is_false(v: bool) -> bool { !v }
/// Parse logic value from `s`
pure fn from_str(s: ~str) -> option<bool> {
alt check s {
match check s {
~"true" => some(true),
~"false" => some(false),
_ => none

4
src/libcore/char.rs
View file

@ -113,7 +113,7 @@ pure fn is_digit(c: char) -> bool {
* refer to a digit in the given radix.
*/
pure fn to_digit(c: char, radix: uint) -> option<uint> {
let val = alt c {
let val = match c {
'0' to '9' => c as uint - ('0' as uint),
'a' to 'z' => c as uint + 10u - ('a' as uint),
'A' to 'Z' => c as uint + 10u - ('A' as uint),
@ -158,7 +158,7 @@ fn escape_unicode(c: char) -> ~str {
* - Any other chars are given hex unicode escapes; see `escape_unicode`.
*/
fn escape_default(c: char) -> ~str {
alt c {
match c {
'\t' => ~"\\t",
'\r' => ~"\\r",
'\n' => ~"\\n",

2
src/libcore/comm.rs
View file

@ -409,7 +409,7 @@ fn test_select2_stress() {
let mut as = 0;
let mut bs = 0;
for iter::repeat(msgs * times * 2u) {
alt check select2(po_a, po_b) {
match check select2(po_a, po_b) {
either::left(~"a") => as += 1,
either::right(~"b") => bs += 1
}

20
src/libcore/dlist.rs
View file

@ -26,8 +26,8 @@ enum dlist<T> = @{
impl private_methods<T> for dlist_node<T> {
pure fn assert_links() {
alt self.next {
some(neighbour) => alt neighbour.prev {
match self.next {
some(neighbour) => match neighbour.prev {
some(me) => if !box::ptr_eq(*self, *me) {
fail ~"Asymmetric next-link in dlist node."
}
@ -35,8 +35,8 @@ impl private_methods<T> for dlist_node<T> {
}
none => ()
}
alt self.prev {
some(neighbour) => alt neighbour.next {
match self.prev {
some(neighbour) => match neighbour.next {
some(me) => if !box::ptr_eq(*me, *self) {
fail ~"Asymmetric prev-link in dlist node."
}
@ -55,7 +55,7 @@ impl extensions<T> for dlist_node<T> {
}
/// Get the next node in the list, failing if there isn't one.
pure fn next_node() -> dlist_node<T> {
alt self.next_link() {
match self.next_link() {
some(nobe) => nobe,
none => fail ~"This dlist node has no next neighbour."
}
@ -67,7 +67,7 @@ impl extensions<T> for dlist_node<T> {
}
/// Get the previous node in the list, failing if there isn't one.
pure fn prev_node() -> dlist_node<T> {
alt self.prev_link() {
match self.prev_link() {
some(nobe) => nobe,
none => fail ~"This dlist node has no previous neighbour."
}
@ -138,11 +138,11 @@ impl private_methods<T> for dlist<T> {
// the head and/or tail pointers appropriately.
#[inline(always)]
fn link(+before: dlist_link<T>, +after: dlist_link<T>) {
alt before {
match before {
some(neighbour) => neighbour.next = after,
none => self.hd = after
}
alt after {
match after {
some(neighbour) => neighbour.prev = before,
none => self.tl = before
}
@ -286,14 +286,14 @@ impl extensions<T> for dlist<T> {
/// Get the node at the list's head, failing if empty. O(1).
pure fn head_n() -> dlist_node<T> {
alt self.hd {
match self.hd {
some(nobe) => nobe,
none => fail ~"Attempted to get the head of an empty dlist."
}
}
/// Get the node at the list's tail, failing if empty. O(1).
pure fn tail_n() -> dlist_node<T> {
alt self.tl {
match self.tl {
some(nobe) => nobe,
none => fail ~"Attempted to get the tail of an empty dlist."
}

2
src/libcore/dvec.rs
View file

@ -222,7 +222,7 @@ impl extensions<A:copy> for dvec<A> {
*/
fn append_iter<A, I:iter::base_iter<A>>(ts: I) {
do self.swap |v| {
let mut v = alt ts.size_hint() {
let mut v = match ts.size_hint() {
none { v }
some(h) {
let len = v.len() + h;

16
src/libcore/either.rs
View file

@ -18,7 +18,7 @@ fn either<T, U, V>(f_left: fn(T) -> V,
* result is returned.
*/
alt value {
match value {
left(l) => f_left(l),
right(r) => f_right(r)
}
@ -29,7 +29,7 @@ fn lefts<T: copy, U>(eithers: ~[either<T, U>]) -> ~[T] {
let mut result: ~[T] = ~[];
for vec::each(eithers) |elt| {
alt elt {
match elt {
left(l) => vec::push(result, l),
_ => { /* fallthrough */ }
}
@ -42,7 +42,7 @@ fn rights<T, U: copy>(eithers: ~[either<T, U>]) -> ~[U] {
let mut result: ~[U] = ~[];
for vec::each(eithers) |elt| {
alt elt {
match elt {
right(r) => vec::push(result, r),
_ => { /* fallthrough */ }
}
@ -62,7 +62,7 @@ fn partition<T: copy, U: copy>(eithers: ~[either<T, U>])
let mut lefts: ~[T] = ~[];
let mut rights: ~[U] = ~[];
for vec::each(eithers) |elt| {
alt elt {
match elt {
left(l) => vec::push(lefts, l),
right(r) => vec::push(rights, r)
}
@ -73,7 +73,7 @@ fn partition<T: copy, U: copy>(eithers: ~[either<T, U>])
pure fn flip<T: copy, U: copy>(eith: either<T, U>) -> either<U, T> {
//! Flips between left and right of a given either
alt eith {
match eith {
right(r) => left(r),
left(l) => right(l)
}
@ -88,7 +88,7 @@ pure fn to_result<T: copy, U: copy>(
* an ok result, and the "left" choice a fail
*/
alt eith {
match eith {
right(r) => result::ok(r),
left(l) => result::err(l)
}
@ -97,13 +97,13 @@ pure fn to_result<T: copy, U: copy>(
pure fn is_left<T, U>(eith: either<T, U>) -> bool {
//! Checks whether the given value is a left
alt eith { left(_) => true, _ => false }
match eith { left(_) => true, _ => false }
}
pure fn is_right<T, U>(eith: either<T, U>) -> bool {
//! Checks whether the given value is a right
alt eith { right(_) => true, _ => false }
match eith { right(_) => true, _ => false }
}
#[test]

24
src/libcore/extfmt.rs
View file

@ -122,7 +122,7 @@ mod ct {
let c = s[i];
if !('0' as u8 <= c && c <= '9' as u8) { return option::none; }
let n = (c - ('0' as u8)) as uint;
return alt peek_num(s, i + 1u, lim) {
return match peek_num(s, i + 1u, lim) {
none => some({num: n, next: i + 1u}),
some(next) => {
let m = next.num;
@ -150,7 +150,7 @@ mod ct {
{param: option<int>, next: uint} {
if i >= lim { return {param: none, next: i}; }
let num = peek_num(s, i, lim);
return alt num {
return match num {
none => {param: none, next: i},
some(t) => {
let n = t.num;
@ -195,13 +195,13 @@ mod ct {
} else if s[i] == '*' as u8 {
let param = parse_parameter(s, i + 1u, lim);
let j = param.next;
alt param.param {
match param.param {
none => {count: count_is_next_param, next: j},
some(n) => {count: count_is_param(n), next: j}
}
} else {
let num = peek_num(s, i, lim);
alt num {
match num {
none => {count: count_implied, next: i},
some(num) => {
count: count_is(num.num as int),
@ -220,7 +220,7 @@ mod ct {
// If there were no digits specified, i.e. the precision
// was ".", then the precision is 0
alt count.count {
match count.count {
count_implied => {count: count_is(0), next: count.next},
_ => count
}
@ -294,7 +294,7 @@ mod rt {
pure fn conv_uint(cv: conv, u: uint) -> ~str {
let prec = get_int_precision(cv);
let mut rs =
alt cv.ty {
match cv.ty {
ty_default => uint_to_str_prec(u, 10u, prec),
ty_hex_lower => uint_to_str_prec(u, 16u, prec),
ty_hex_upper => str::to_upper(uint_to_str_prec(u, 16u, prec)),
@ -316,7 +316,7 @@ mod rt {
pure fn conv_str(cv: conv, s: &str) -> ~str {
// For strings, precision is the maximum characters
// displayed
let mut unpadded = alt cv.precision {
let mut unpadded = match cv.precision {
count_implied => s.to_unique(),
count_is(max) => if max as uint < str::char_len(s) {
str::substr(s, 0u, max as uint)
@ -327,7 +327,7 @@ mod rt {
return unchecked { pad(cv, unpadded, pad_nozero) };
}
pure fn conv_float(cv: conv, f: float) -> ~str {
let (to_str, digits) = alt cv.precision {
let (to_str, digits) = match cv.precision {
count_is(c) => (float::to_str_exact, c as uint),
count_implied => (float::to_str, 6u)
};
@ -371,14 +371,14 @@ mod rt {
};
}
pure fn get_int_precision(cv: conv) -> uint {
return alt cv.precision {
return match cv.precision {
count_is(c) => c as uint,
count_implied => 1u
};
}
enum pad_mode { pad_signed, pad_unsigned, pad_nozero, pad_float }
fn pad(cv: conv, &s: ~str, mode: pad_mode) -> ~str {
let uwidth : uint = alt cv.width {
let uwidth : uint = match cv.width {
count_implied => return s,
count_is(width) => {
// FIXME: width should probably be uint (see Issue #1996)
@ -393,14 +393,14 @@ mod rt {
let padstr = str::from_chars(vec::from_elem(diff, padchar));
return s + padstr;
}
let {might_zero_pad, signed} = alt mode {
let {might_zero_pad, signed} = match mode {
pad_nozero => {might_zero_pad:false, signed:false},
pad_signed => {might_zero_pad:true, signed:true },
pad_float => {might_zero_pad:true, signed:true},
pad_unsigned => {might_zero_pad:true, signed:false}
};
pure fn have_precision(cv: conv) -> bool {
return alt cv.precision { count_implied => false, _ => true };
return match cv.precision { count_implied => false, _ => true };
}
let zero_padding = {
if might_zero_pad && have_flag(cv.flags, flag_left_zero_pad) &&

14
src/libcore/float.rs
View file

@ -256,14 +256,14 @@ fn from_str(num: ~str) -> option<float> {
let mut c = 'z'; //Latest char.
//The string must start with one of the following characters.
alt str::char_at(num, 0u) {
match str::char_at(num, 0u) {
'-' | '+' | '0' to '9' | '.' => (),
_ => return none
}
//Determine if first char is '-'/'+'. Set [pos] and [neg] accordingly.
let mut neg = false; //Sign of the result
alt str::char_at(num, 0u) {
match str::char_at(num, 0u) {
'-' => {
neg = true;
pos = 1u;
@ -279,7 +279,7 @@ fn from_str(num: ~str) -> option<float> {
let char_range = str::char_range_at(num, pos);
c = char_range.ch;
pos = char_range.next;
alt c {
match c {
'0' to '9' => {
total = total * 10f;
total += ((c as int) - ('0' as int)) as float;
@ -295,7 +295,7 @@ fn from_str(num: ~str) -> option<float> {
let char_range = str::char_range_at(num, pos);
c = char_range.ch;
pos = char_range.next;
alt c {
match c {
'0' | '1' | '2' | '3' | '4' | '5' | '6'| '7' | '8' | '9' => {
decimal /= 10f;
total += (((c as int) - ('0' as int)) as float)*decimal;
@ -312,7 +312,7 @@ fn from_str(num: ~str) -> option<float> {
if(pos < len) {
let char_range = str::char_range_at(num, pos);
c = char_range.ch;
alt c {
match c {
'+' => {
pos = char_range.next;
}
@ -325,7 +325,7 @@ fn from_str(num: ~str) -> option<float> {
while(pos < len) {
let char_range = str::char_range_at(num, pos);
c = char_range.ch;
alt c {
match c {
'0' | '1' | '2' | '3' | '4' | '5' | '6'| '7' | '8' | '9' => {
exponent *= 10u;
exponent += ((c as uint) - ('0' as uint));
@ -447,7 +447,7 @@ fn test_from_str() {
assert from_str(~"inf") == some(infinity);
assert from_str(~"-inf") == some(neg_infinity);
// note: NaN != NaN, hence this slightly complex test
alt from_str(~"NaN") {
match from_str(~"NaN") {
some(f) => assert is_NaN(f),
none => fail
}

4
src/libcore/future.rs
View file

@ -77,7 +77,7 @@ fn from_port<A:send>(-port: future_pipe::client::waiting<A>) -> future<A> {
let mut port_ = none;
port_ <-> *port;
let port = option::unwrap(port_);
alt recv(port) {
match recv(port) {
future_pipe::completed(data) => move_it!{data}
}
}
@ -119,7 +119,7 @@ fn get<A:copy>(future: future<A>) -> A {
fn with<A,B>(future: future<A>, blk: fn(A) -> B) -> B {
//! Work with the value without copying it
let v = alt copy future.v {
let v = match copy future.v {
either::left(v) => v,
either::right(f) => {
let v = @f();

2
src/libcore/int-template.rs
View file

@ -144,7 +144,7 @@ fn parse_buf(buf: ~[u8], radix: uint) -> option<T> {
}
let mut n = 0 as T;
loop {
alt char::to_digit(buf[i] as char, radix) {
match char::to_digit(buf[i] as char, radix) {
some(d) => n += (d as T) * power,
none => return none
}

18
src/libcore/io.rs
View file

@ -196,7 +196,7 @@ impl reader_util for reader {
// Reader implementations
fn convert_whence(whence: seek_style) -> i32 {
return alt whence {
return match whence {
seek_set => 0i32,
seek_cur => 1i32,
seek_end => 2i32
@ -440,7 +440,7 @@ fn mk_file_writer(path: ~str, flags: ~[fileflag])
let mut fflags: c_int = wb();
for vec::each(flags) |f| {
alt f {
match f {
append => fflags |= O_APPEND as c_int,
create => fflags |= O_CREAT as c_int,
truncate => fflags |= O_TRUNC as c_int,
@ -460,7 +460,7 @@ fn mk_file_writer(path: ~str, flags: ~[fileflag])
fn u64_to_le_bytes<T>(n: u64, size: uint, f: fn(v: &[u8]) -> T) -> T {
assert size <= 8u;
alt size {
match size {
1u => f(&[n as u8]),
2u => f(&[n as u8,
(n >> 8) as u8]),
@ -491,7 +491,7 @@ fn u64_to_le_bytes<T>(n: u64, size: uint, f: fn(v: &[u8]) -> T) -> T {
fn u64_to_be_bytes<T>(n: u64, size: uint, f: fn(v: &[u8]) -> T) -> T {
assert size <= 8u;
alt size {
match size {
1u => f(&[n as u8]),
2u => f(&[(n >> 8) as u8,
n as u8]),
@ -717,7 +717,7 @@ fn seek_in_buf(offset: int, pos: uint, len: uint, whence: seek_style) ->
uint {
let mut bpos = pos as int;
let blen = len as int;
alt whence {
match whence {
seek_set => bpos = offset,
seek_cur => bpos += offset,
seek_end => bpos = blen + offset
@ -767,7 +767,7 @@ mod fsync {
let arg: arg<t>;
new(-arg: arg<t>) { self.arg <- arg; }
drop {
alt self.arg.opt_level {
match self.arg.opt_level {
option::none => (),
option::some(level) => {
// fail hard if not succesful
@ -891,7 +891,7 @@ mod tests {
#[test]
fn file_reader_not_exist() {
alt io::file_reader(~"not a file") {
match io::file_reader(~"not a file") {
result::err(e) => {
assert e == ~"error opening not a file";
}
@ -901,7 +901,7 @@ mod tests {
#[test]
fn file_writer_bad_name() {
alt io::file_writer(~"?/?", ~[]) {
match io::file_writer(~"?/?", ~[]) {
result::err(e) => {
assert str::starts_with(e, ~"error opening ?/?");
}
@ -911,7 +911,7 @@ mod tests {
#[test]
fn buffered_file_writer_bad_name() {
alt io::buffered_file_writer(~"?/?") {
match io::buffered_file_writer(~"?/?") {
result::err(e) => {
assert e == ~"error opening ?/?";
}

4
src/libcore/iter-trait/option.rs
View file

@ -1,14 +1,14 @@
type IMPL_T<A> = option<A>;
pure fn EACH<A>(self: IMPL_T<A>, f: fn(A) -> bool) {
alt self {
match self {
none => (),
some(a) => { f(a); }
}
}
fn SIZE_HINT<A>(self: IMPL_T<A>) -> option<uint> {
alt self {
match self {
none => some(0u),
some(_) => some(1u)
}

8
src/libcore/iter.rs
View file

@ -134,8 +134,8 @@ fn repeat(times: uint, blk: fn() -> bool) {
}
fn min<A:copy,IA:base_iter<A>>(self: IA) -> A {
alt do foldl::<A,option<A>,IA>(self, none) |a, b| {
alt a {
match do foldl::<A,option<A>,IA>(self, none) |a, b| {
match a {
some(a_) if a_ < b => {
// FIXME (#2005): Not sure if this is successfully optimized to
// a move
@ -150,8 +150,8 @@ fn min<A:copy,IA:base_iter<A>>(self: IA) -> A {
}
fn max<A:copy,IA:base_iter<A>>(self: IA) -> A {
alt do foldl::<A,option<A>,IA>(self, none) |a, b| {
alt a {
match do foldl::<A,option<A>,IA>(self, none) |a, b| {
match a {
some(a_) if a_ > b => {
// FIXME (#2005): Not sure if this is successfully optimized to
// a move.

18
src/libcore/option.rs
View file

@ -23,7 +23,7 @@ pure fn get<T: copy>(opt: option<T>) -> T {
* Fails if the value equals `none`
*/
alt opt {
match opt {
some(x) => return x,
none => fail ~"option::get none"
}
@ -37,13 +37,13 @@ pure fn expect<T: copy>(opt: option<T>, reason: ~str) -> T {
Fails if the value equals `none`
"];
alt opt { some(x) => x, none => fail reason }
match opt { some(x) => x, none => fail reason }
}
pure fn map<T, U>(opt: option<T>, f: fn(T) -> U) -> option<U> {
//! Maps a `some` value from one type to another
alt opt { some(x) => some(f(x)), none => none }
match opt { some(x) => some(f(x)), none => none }
}
pure fn map_consume<T, U>(-opt: option<T>, f: fn(-T) -> U) -> option<U> {
@ -60,7 +60,7 @@ pure fn chain<T, U>(opt: option<T>, f: fn(T) -> option<U>) -> option<U> {
* function that returns an option.
*/
alt opt { some(x) => f(x), none => none }
match opt { some(x) => f(x), none => none }
}
#[inline(always)]
@ -76,7 +76,7 @@ pure fn while_some<T>(+x: option<T>, blk: fn(+T) -> option<T>) {
pure fn is_none<T>(opt: option<T>) -> bool {
//! Returns true if the option equals `none`
alt opt { none => true, some(_) => false }
match opt { none => true, some(_) => false }
}
pure fn is_some<T>(opt: option<T>) -> bool {
@ -88,19 +88,19 @@ pure fn is_some<T>(opt: option<T>) -> bool {
pure fn get_default<T: copy>(opt: option<T>, def: T) -> T {
//! Returns the contained value or a default
alt opt { some(x) => x, none => def }
match opt { some(x) => x, none => def }
}
pure fn map_default<T, U>(opt: option<T>, +def: U, f: fn(T) -> U) -> U {
//! Applies a function to the contained value or returns a default
alt opt { none => def, some(t) => f(t) }
match opt { none => def, some(t) => f(t) }
}
pure fn iter<T>(opt: option<T>, f: fn(T)) {
//! Performs an operation on the contained value or does nothing
alt opt { none => (), some(t) => f(t) }
match opt { none => (), some(t) => f(t) }
}
#[inline(always)]
@ -113,7 +113,7 @@ pure fn unwrap<T>(-opt: option<T>) -> T {
*/
unsafe {
let addr = alt opt {
let addr = match opt {
some(x) => ptr::addr_of(x),
none => fail ~"option::unwrap none"
};

8
src/libcore/os.rs
View file

@ -178,7 +178,7 @@ mod global_env {
unsafe {
do priv::weaken_task |weak_po| {
loop {
alt comm::select2(msg_po, weak_po) {
match comm::select2(msg_po, weak_po) {
either::left(msg_getenv(n, resp_ch)) => {
comm::send(resp_ch, impl::getenv(n))
}
@ -282,7 +282,7 @@ fn fsync_fd(fd: c_int, _level: io::fsync::level) -> c_int {
#[cfg(target_os = "linux")]
fn fsync_fd(fd: c_int, level: io::fsync::level) -> c_int {
import libc::funcs::posix01::unistd::*;
alt level {
match level {
io::fsync::fsync
| io::fsync::fullfsync => return fsync(fd),
io::fsync::fdatasync => return fdatasync(fd)
@ -294,7 +294,7 @@ fn fsync_fd(fd: c_int, level: io::fsync::level) -> c_int {
import libc::consts::os::extra::*;
import libc::funcs::posix88::fcntl::*;
import libc::funcs::posix01::unistd::*;
alt level {
match level {
io::fsync::fsync => return fsync(fd),
_ => {
// According to man fnctl, the ok retval is only specified to be !=-1
@ -440,7 +440,7 @@ fn self_exe_path() -> option<path> {
* Otherwise, homedir returns option::none.
*/
fn homedir() -> option<path> {
return alt getenv(~"HOME") {
return match getenv(~"HOME") {
some(p) => if !str::is_empty(p) {
some(p)
} else {

2
src/libcore/path.rs
View file

@ -61,7 +61,7 @@ fn path_is_absolute(p: ~str) -> bool {
fn path_sep() -> ~str { return str::from_char(consts::path_sep); }
fn split_dirname_basename (pp: path) -> {dirname: ~str, basename: ~str} {
alt str::rfind(pp, |ch|
match str::rfind(pp, |ch|
ch == consts::path_sep || ch == consts::alt_path_sep
) {
some(i) => {

42
src/libcore/pipes.rs
View file

@ -136,7 +136,7 @@ struct packet_header {
unsafe fn unblock() {
let old_task = swap_task(self.blocked_task, ptr::null());
if !old_task.is_null() { rustrt::rust_task_deref(old_task) }
alt swap_state_acq(self.state, empty) {
match swap_state_acq(self.state, empty) {
empty | blocked => (),
terminated => self.state = terminated,
full => self.state = full
@ -345,7 +345,7 @@ fn send<T: send, Tbuffer: send>(-p: send_packet_buffered<T, Tbuffer>,
assert p.payload == none;
p.payload <- some(payload);
let old_state = swap_state_rel(p.header.state, full);
alt old_state {
match old_state {
empty => {
// Yay, fastpath.
@ -403,7 +403,7 @@ fn try_recv<T: send, Tbuffer: send>(-p: recv_packet_buffered<T, Tbuffer>)
rustrt::task_clear_event_reject(this);
let old_state = swap_state_acq(p.header.state,
blocked);
alt old_state {
match old_state {
empty => {
debug!{"no data available on %?, going to sleep.", p_};
if count == 0 {
@ -451,7 +451,7 @@ fn try_recv<T: send, Tbuffer: send>(-p: recv_packet_buffered<T, Tbuffer>)
/// Returns true if messages are available.
pure fn peek<T: send, Tb: send>(p: recv_packet_buffered<T, Tb>) -> bool {
alt unsafe {(*p.header()).state} {
match unsafe {(*p.header()).state} {
empty => false,
blocked => fail ~"peeking on blocked packet",
full | terminated => true
@ -467,7 +467,7 @@ impl peek<T: send, Tb: send> for recv_packet_buffered<T, Tb> {
#[doc(hidden)]
fn sender_terminate<T: send>(p: *packet<T>) {
let p = unsafe { &*p };
alt swap_state_rel(p.header.state, terminated) {
match swap_state_rel(p.header.state, terminated) {
empty => {
assert p.header.blocked_task.is_null();
// The receiver will eventually clean up.
@ -500,7 +500,7 @@ fn sender_terminate<T: send>(p: *packet<T>) {
fn receiver_terminate<T: send>(p: *packet<T>) {
let p = unsafe { &*p };
assert p.header.blocked_task.is_null();
alt swap_state_rel(p.header.state, terminated) {
match swap_state_rel(p.header.state, terminated) {
empty => {
// the sender will clean up
//unsafe { forget(p) }
@ -534,7 +534,7 @@ fn wait_many(pkts: &[*packet_header]) -> uint {
for pkts.eachi |i, p| unsafe {
let p = unsafe { &*p };
let old = p.mark_blocked(this);
alt old {
match old {
full | terminated => {
data_avail = true;
ready_packet = i;
@ -551,7 +551,7 @@ fn wait_many(pkts: &[*packet_header]) -> uint {
let event = wait_event(this) as *packet_header;
let pos = vec::position(pkts, |p| p == event);
alt pos {
match pos {
some(i) => {
ready_packet = i;
data_avail = true;
@ -611,7 +611,7 @@ fn select2<A: send, Ab: send, B: send, Bb: send>(
let i = wait_many([a.header(), b.header()]/_);
unsafe {
alt i {
match i {
0 => left((try_recv(a), b)),
1 => right((a, try_recv(b))),
_ => fail ~"select2 return an invalid packet"
@ -631,7 +631,7 @@ fn selecti<T: selectable>(endpoints: &[T]) -> uint {
/// Returns 0 or 1 depending on which endpoint is ready to receive
fn select2i<A: selectable, B: selectable>(a: A, b: B) -> either<(), ()> {
alt wait_many([a.header(), b.header()]/_) {
match wait_many([a.header(), b.header()]/_) {
0 => left(()),
1 => right(()),
_ => fail ~"wait returned unexpected index"
@ -704,7 +704,7 @@ struct send_packet_buffered<T: send, Tbuffer: send> {
}
pure fn header() -> *packet_header {
alt self.p {
match self.p {
some(packet) => unsafe {
let packet = &*packet;
let header = ptr::addr_of(packet.header);
@ -765,7 +765,7 @@ struct recv_packet_buffered<T: send, Tbuffer: send> : selectable {
}
pure fn header() -> *packet_header {
alt self.p {
match self.p {
some(packet) => unsafe {
let packet = &*packet;
let header = ptr::addr_of(packet.header);
@ -924,7 +924,7 @@ impl port<T: send> of recv<T> for port<T> {
fn try_recv() -> option<T> {
let mut endp = none;
endp <-> self.endp;
alt move pipes::try_recv(unwrap(endp)) {
match move pipes::try_recv(unwrap(endp)) {
some(streamp::data(x, endp)) => {
self.endp = some(move_it!{endp});
some(move_it!{x})
@ -936,7 +936,7 @@ impl port<T: send> of recv<T> for port<T> {
pure fn peek() -> bool unchecked {
let mut endp = none;
endp <-> self.endp;
let peek = alt endp {
let peek = match endp {
some(endp) => pipes::peek(endp),
none => fail ~"peeking empty stream"
};
@ -969,7 +969,7 @@ struct port_set<T: send> : recv<T> {
ports <-> self.ports;
while result == none && ports.len() > 0 {
let i = wait_many(ports.map(|p| p.header()));
alt move ports[i].try_recv() {
match move ports[i].try_recv() {
some(copy m) => {
result = some(move m);
}
@ -1007,7 +1007,7 @@ struct port_set<T: send> : recv<T> {
impl<T: send> of selectable for port<T> {
pure fn header() -> *packet_header unchecked {
alt self.endp {
match self.endp {
some(endp) => endp.header(),
none => fail ~"peeking empty stream"
}
@ -1045,8 +1045,8 @@ impl<T: send, U: send, Left: selectable recv<T>, Right: selectable recv<U>>
of select2<T, U> for (Left, Right) {
fn select() -> either<T, U> {
alt self {
(lp, rp) => alt select2i(lp, rp) {
match self {
(lp, rp) => match select2i(lp, rp) {
left(()) => left (lp.recv()),
right(()) => right(rp.recv())
}
@ -1054,8 +1054,8 @@ impl<T: send, U: send, Left: selectable recv<T>, Right: selectable recv<U>>
}
fn try_select() -> either<option<T>, option<U>> {
alt self {
(lp, rp) => alt select2i(lp, rp) {
match self {
(lp, rp) => match select2i(lp, rp) {
left(()) => left (lp.try_recv()),
right(()) => right(rp.try_recv())
}
@ -1072,7 +1072,7 @@ mod test {
c1.send(~"abc");
alt (p1, p2).select() {
match (p1, p2).select() {
right(_) => fail,
_ => ()
}

2
src/libcore/priv.rs
View file

@ -49,7 +49,7 @@ unsafe fn chan_from_global_ptr<T: send>(
// Wait to hear if we are the official instance of
// this global task
alt comm::recv::<msg>(setup_po) {
match comm::recv::<msg>(setup_po) {
proceed => f(po),
abort => ()
}

40
src/libcore/result.rs
View file

@ -18,7 +18,7 @@ enum result<T, U> {
* If the result is an error
*/
pure fn get<T: copy, U>(res: result<T, U>) -> T {
alt res {
match res {
ok(t) => t,
err(the_err) => unchecked {
fail fmt!{"get called on error result: %?", the_err}
@ -34,7 +34,7 @@ pure fn get<T: copy, U>(res: result<T, U>) -> T {
* If the result is not an error
*/
pure fn get_err<T, U: copy>(res: result<T, U>) -> U {
alt res {
match res {
err(u) => u,
ok(_) => fail ~"get_error called on ok result"
}
@ -42,7 +42,7 @@ pure fn get_err<T, U: copy>(res: result<T, U>) -> U {
/// Returns true if the result is `ok`
pure fn is_ok<T, U>(res: result<T, U>) -> bool {
alt res {
match res {
ok(_) => true,
err(_) => false
}
@ -60,7 +60,7 @@ pure fn is_err<T, U>(res: result<T, U>) -> bool {
* result variants are converted to `either::left`.
*/
pure fn to_either<T: copy, U: copy>(res: result<U, T>) -> either<T, U> {
alt res {
match res {
ok(res) => either::right(res),
err(fail_) => either::left(fail_)
}
@ -82,7 +82,7 @@ pure fn to_either<T: copy, U: copy>(res: result<U, T>) -> either<T, U> {
*/
fn chain<T, U: copy, V: copy>(res: result<T, V>, op: fn(T) -> result<U, V>)
-> result<U, V> {
alt res {
match res {
ok(t) => op(t),
err(e) => err(e)
}
@ -100,7 +100,7 @@ fn chain_err<T: copy, U: copy, V: copy>(
res: result<T, V>,
op: fn(V) -> result<T, U>)
-> result<T, U> {
alt res {
match res {
ok(t) => ok(t),
err(v) => op(v)
}
@ -121,7 +121,7 @@ fn chain_err<T: copy, U: copy, V: copy>(
* }
*/
fn iter<T, E>(res: result<T, E>, f: fn(T)) {
alt res {
match res {
ok(t) => f(t),
err(_) => ()
}
@ -136,7 +136,7 @@ fn iter<T, E>(res: result<T, E>, f: fn(T)) {
* handling an error.
*/
fn iter_err<T, E>(res: result<T, E>, f: fn(E)) {
alt res {
match res {
ok(_) => (),
err(e) => f(e)
}
@ -158,7 +158,7 @@ fn iter_err<T, E>(res: result<T, E>, f: fn(E)) {
*/
fn map<T, E: copy, U: copy>(res: result<T, E>, op: fn(T) -> U)
-> result<U, E> {
alt res {
match res {
ok(t) => ok(op(t)),
err(e) => err(e)
}
@ -174,7 +174,7 @@ fn map<T, E: copy, U: copy>(res: result<T, E>, op: fn(T) -> U)
*/
fn map_err<T: copy, E, F: copy>(res: result<T, E>, op: fn(E) -> F)
-> result<T, F> {
alt res {
match res {
ok(t) => ok(t),
err(e) => err(op(e))
}
@ -186,14 +186,14 @@ impl extensions<T, E> for result<T, E> {
fn is_err() -> bool { is_err(self) }
fn iter(f: fn(T)) {
alt self {
match self {
ok(t) => f(t),
err(_) => ()
}
}
fn iter_err(f: fn(E)) {
alt self {
match self {
ok(_) => (),
err(e) => f(e)
}
@ -204,7 +204,7 @@ impl extensions<T:copy, E> for result<T, E> {
fn get() -> T { get(self) }
fn map_err<F:copy>(op: fn(E) -> F) -> result<T,F> {
alt self {
match self {
ok(t) => ok(t),
err(e) => err(op(e))
}
@ -215,7 +215,7 @@ impl extensions<T, E:copy> for result<T, E> {
fn get_err() -> E { get_err(self) }
fn map<U:copy>(op: fn(T) -> U) -> result<U,E> {
alt self {
match self {
ok(t) => ok(op(t)),
err(e) => err(e)
}
@ -255,7 +255,7 @@ fn map_vec<T,U:copy,V:copy>(
let mut vs: ~[V] = ~[];
vec::reserve(vs, vec::len(ts));
for vec::each(ts) |t| {
alt op(t) {
match op(t) {
ok(v) => vec::push(vs, v),
err(u) => return err(u)
}
@ -266,9 +266,9 @@ fn map_vec<T,U:copy,V:copy>(
fn map_opt<T,U:copy,V:copy>(
o_t: option<T>, op: fn(T) -> result<V,U>) -> result<option<V>,U> {
alt o_t {
match o_t {
none => ok(none),
some(t) => alt op(t) {
some(t) => match op(t) {
ok(v) => ok(some(v)),
err(e) => err(e)
}
@ -293,7 +293,7 @@ fn map_vec2<S,T,U:copy,V:copy>(ss: ~[S], ts: ~[T],
vec::reserve(vs, n);
let mut i = 0u;
while i < n {
alt op(ss[i],ts[i]) {
match op(ss[i],ts[i]) {
ok(v) => vec::push(vs, v),
err(u) => return err(u)
}
@ -314,7 +314,7 @@ fn iter_vec2<S,T,U:copy>(ss: ~[S], ts: ~[T],
let n = vec::len(ts);
let mut i = 0u;
while i < n {
alt op(ss[i],ts[i]) {
match op(ss[i],ts[i]) {
ok(()) => (),
err(u) => return err(u)
}
@ -326,7 +326,7 @@ fn iter_vec2<S,T,U:copy>(ss: ~[S], ts: ~[T],
/// Unwraps a result, assuming it is an `ok(T)`
fn unwrap<T, U>(-res: result<T, U>) -> T {
unsafe {
let addr = alt res {
let addr = match res {
ok(x) => ptr::addr_of(x),
err(_) => fail ~"error result"
};

8
src/libcore/run.rs
View file

@ -96,7 +96,7 @@ fn with_envp<T>(env: option<~[(~str,~str)]>,
cb: fn(*c_void) -> T) -> T {
// On posixy systems we can pass a char** for envp, which is
// a null-terminated array of "k=v\n" strings.
alt env {
match env {
some(es) if !vec::is_empty(es) => {
let mut tmps = ~[];
let mut ptrs = ~[];
@ -123,7 +123,7 @@ fn with_envp<T>(env: option<~[(~str,~str)]>,
// rather a concatenation of null-terminated k=v\0 sequences, with a final
// \0 to terminate.
unsafe {
alt env {
match env {
some(es) if !vec::is_empty(es) => {
let mut blk : ~[u8] = ~[];
for vec::each(es) |e| {
@ -143,7 +143,7 @@ fn with_envp<T>(env: option<~[(~str,~str)]>,
fn with_dirp<T>(d: option<~str>,
cb: fn(*libc::c_char) -> T) -> T {
alt d {
match d {
some(dir) => str::as_c_str(dir, cb),
none => cb(ptr::null())
}
@ -309,7 +309,7 @@ fn program_output(prog: ~str, args: ~[~str]) ->
let mut count = 2;
while count > 0 {
let stream = comm::recv(p);
alt check stream {
match check stream {
(1, s) => {
outs = s;
}

12
src/libcore/send_map.rs
View file

@ -115,7 +115,7 @@ mod linear {
k: &K) -> search_result {
let _ = for self.bucket_sequence(hash) |i| {
alt buckets[i] {
match buckets[i] {
some(bkt) => if bkt.hash == hash && self.eqfn(k, &bkt.key) {
return found_entry(i);
}
@ -155,7 +155,7 @@ mod linear {
/// Assumes that there will be a bucket.
/// True if there was no previous entry with that key
fn insert_internal(hash: uint, +k: K, +v: V) -> bool {
alt self.bucket_for_key_with_hash(self.buckets, hash,
match self.bucket_for_key_with_hash(self.buckets, hash,
unsafe{borrow(k)}) {
table_full => {fail ~"Internal logic error";}
found_hole(idx) => {
@ -207,7 +207,7 @@ mod linear {
// I found this explanation elucidating:
// http://www.maths.lse.ac.uk/Courses/MA407/del-hash.pdf
let mut idx = alt self.bucket_for_key(self.buckets, k) {
let mut idx = match self.bucket_for_key(self.buckets, k) {
table_full | found_hole(_) => {
return false;
}
@ -246,7 +246,7 @@ mod linear {
}
fn contains_key(k: &K) -> bool {
alt self.bucket_for_key(self.buckets, k) {
match self.bucket_for_key(self.buckets, k) {
found_entry(_) => {true}
table_full | found_hole(_) => {false}
}
@ -255,9 +255,9 @@ mod linear {
impl public_methods<K,V: copy> for &const linear_map<K,V> {
fn find(k: &K) -> option<V> {
alt self.bucket_for_key(self.buckets, k) {
match self.bucket_for_key(self.buckets, k) {
found_entry(idx) => {
alt check self.buckets[idx] {
match check self.buckets[idx] {
some(bkt) => {some(copy bkt.value)}
}
}

16
src/libcore/str.rs
View file

@ -341,7 +341,7 @@ fn unshift_char(&s: ~str, ch: char) { s = from_char(ch) + s; }
/// Returns a string with leading whitespace removed
pure fn trim_left(s: &str) -> ~str {
alt find(s, |c| !char::is_whitespace(c)) {
match find(s, |c| !char::is_whitespace(c)) {
none => ~"",
some(first) => unsafe { unsafe::slice_bytes(s, first, len(s)) }
}
@ -349,7 +349,7 @@ pure fn trim_left(s: &str) -> ~str {
/// Returns a string with trailing whitespace removed
pure fn trim_right(s: &str) -> ~str {
alt rfind(s, |c| !char::is_whitespace(c)) {
match rfind(s, |c| !char::is_whitespace(c)) {
none => ~"",
some(last) => {
let {next, _} = char_range_at(s, last);
@ -2776,7 +2776,7 @@ mod tests {
fn test_chars_iter() {
let mut i = 0;
do chars_iter(~"x\u03c0y") |ch| {
alt check i {
match check i {
0 => assert ch == 'x',
1 => assert ch == '\u03c0',
2 => assert ch == 'y'
@ -2792,7 +2792,7 @@ mod tests {
let mut i = 0;
do bytes_iter(~"xyz") |bb| {
alt check i {
match check i {
0 => assert bb == 'x' as u8,
1 => assert bb == 'y' as u8,
2 => assert bb == 'z' as u8
@ -2810,7 +2810,7 @@ mod tests {
let mut ii = 0;
do split_char_iter(data, ' ') |xx| {
alt ii {
match ii {
0 => assert ~"\nMary" == xx,
1 => assert ~"had" == xx,
2 => assert ~"a" == xx,
@ -2828,7 +2828,7 @@ mod tests {
let mut ii = 0;
do splitn_char_iter(data, ' ', 2u) |xx| {
alt ii {
match ii {
0 => assert ~"\nMary" == xx,
1 => assert ~"had" == xx,
2 => assert ~"a little lamb\nLittle lamb\n" == xx,
@ -2845,7 +2845,7 @@ mod tests {
let mut ii = 0;
do words_iter(data) |ww| {
alt ii {
match ii {
0 => assert ~"Mary" == ww,
1 => assert ~"had" == ww,
2 => assert ~"a" == ww,
@ -2865,7 +2865,7 @@ mod tests {
let mut ii = 0;
do lines_iter(lf) |x| {
alt ii {
match ii {
0 => assert ~"" == x,
1 => assert ~"Mary had a little lamb" == x,
2 => assert ~"Little lamb" == x,

28
src/libcore/task.rs
View file

@ -279,7 +279,7 @@ impl task_builder for task_builder {
let ch = comm::chan(po);
blk(do future::from_fn {
alt comm::recv(po) {
match comm::recv(po) {
exit(_, result) => result
}
});
@ -502,7 +502,7 @@ fn try<T:send>(+f: fn~() -> T) -> result<T,()> {
do task().unlinked().future_result(|-r| { result = some(r); }).spawn {
comm::send(ch, f());
}
alt future::get(option::unwrap(result)) {
match future::get(option::unwrap(result)) {
success => result::ok(comm::recv(po)),
failure => result::err(())
}
@ -991,7 +991,7 @@ fn gen_child_taskgroup(linked: bool, supervised: bool)
/*######################################################################*
* Step 1. Get spawner's taskgroup info.
*######################################################################*/
let spawner_group = alt unsafe { local_get(spawner, taskgroup_key()) } {
let spawner_group = match unsafe { local_get(spawner, taskgroup_key()) } {
none => {
// Main task, doing first spawn ever. Lazily initialise here.
let mut members = new_taskset();
@ -1028,7 +1028,7 @@ fn gen_child_taskgroup(linked: bool, supervised: bool)
// assertion, but initialising it requires locking a mutex. Hence
// it should be enabled only in debug builds.
let new_generation =
alt *old_ancestors {
match *old_ancestors {
some(arc) => access_ancestors(arc, |a| a.generation+1),
none => 0 // the actual value doesn't really matter.
};
@ -1047,7 +1047,7 @@ fn gen_child_taskgroup(linked: bool, supervised: bool)
fn share_ancestors(ancestors: &mut ancestor_list) -> ancestor_list {
// Appease the borrow-checker. Really this wants to be written as:
// alt ancestors
// match ancestors
// some(ancestor_arc) { ancestor_list(some(ancestor_arc.clone())) }
// none { ancestor_list(none) }
let tmp = util::replace(&mut **ancestors, none);
@ -1073,7 +1073,7 @@ fn spawn_raw(opts: task_opts, +f: fn~()) {
// Agh. Get move-mode items into the closure. FIXME (#2829)
let (child_tg, ancestors, f) = option::swap_unwrap(child_data);
// Create child task.
let new_task = alt opts.sched {
let new_task = match opts.sched {
none => rustrt::new_task(),
some(sched_opts) => new_task_in_new_sched(sched_opts)
};
@ -1162,7 +1162,7 @@ fn spawn_raw(opts: task_opts, +f: fn~()) {
fail ~"foreign_stack_size scheduler option unimplemented";
}
let num_threads = alt opts.mode {
let num_threads = match opts.mode {
single_threaded => 1u,
thread_per_core => {
fail ~"thread_per_core scheduling mode unimplemented"
@ -1273,7 +1273,7 @@ unsafe fn local_data_lookup<T: owned>(
let key_value = key_to_key_value(key);
let map_pos = (*map).position(|entry|
alt entry {
match entry {
some((k,_,_)) => k == key_value,
none => false
}
@ -1336,7 +1336,7 @@ unsafe fn local_set<T: owned>(
// Construct new entry to store in the map.
let new_entry = some((keyval, data_ptr, data_box));
// Find a place to put it.
alt local_data_lookup(map, key) {
match local_data_lookup(map, key) {
some((index, _old_data_ptr)) => {
// Key already had a value set, _old_data_ptr, whose reference
// will get dropped when the local_data box is overwritten.
@ -1344,7 +1344,7 @@ unsafe fn local_set<T: owned>(
}
none => {
// Find an empty slot. If not, grow the vector.
alt (*map).position(|x| x == none) {
match (*map).position(|x| x == none) {
some(empty_index) => (*map).set_elt(empty_index, new_entry),
none => (*map).push(new_entry)
}
@ -1694,7 +1694,7 @@ fn test_spawn_listiner_bidi() {
#[test]
fn test_try_success() {
alt do try {
match do try {
~"Success!"
} {
result::ok(~"Success!") => (),
@ -1705,7 +1705,7 @@ fn test_try_success() {
#[test]
#[ignore(cfg(windows))]
fn test_try_fail() {
alt do try {
match do try {
fail
} {
result::err(()) => (),
@ -2052,13 +2052,13 @@ fn test_tls_pop() unsafe {
fn test_tls_modify() unsafe {
fn my_key(+_x: @~str) { }
local_data_modify(my_key, |data| {
alt data {
match data {
some(@val) => fail ~"unwelcome value: " + val,
none => some(@~"first data")
}
});
local_data_modify(my_key, |data| {
alt data {
match data {
some(@~"first data") => some(@~"next data"),
some(@val) => fail ~"wrong value: " + val,
none => fail ~"missing value"

4
src/libcore/uint-template.rs
View file

@ -127,7 +127,7 @@ fn parse_buf(buf: ~[u8], radix: uint) -> option<T> {
let mut power = 1u as T;
let mut n = 0u as T;
loop {
alt char::to_digit(buf[i] as char, radix) {
match char::to_digit(buf[i] as char, radix) {
some(d) => n += d as T * power,
none => return none
}
@ -146,7 +146,7 @@ fn from_str_radix(buf: ~str, radix: u64) -> option<u64> {
let mut i = str::len(buf) - 1u;
let mut power = 1u64, n = 0u64;
loop {
alt char::to_digit(buf[i] as char, radix as uint) {
match char::to_digit(buf[i] as char, radix as uint) {
some(d) => n += d as u64 * power,
none => return none
}

64
src/libcore/unicode.rs
View file

@ -1,6 +1,6 @@
mod general_category {
pure fn Cc(c: char) -> bool {
return alt c {
return match c {
'\x00' to '\x1f'
| '\x7f' to '\x9f' => true,
_ => false
@ -8,7 +8,7 @@ mod general_category {
}
pure fn Cf(c: char) -> bool {
return alt c {
return match c {
'\xad'
| '\u0600' to '\u0603'
| '\u06dd'
@ -27,21 +27,21 @@ mod general_category {
}
pure fn Co(c: char) -> bool {
return alt c {
return match c {
'\ue000' to '\uf8ff' => true,
_ => false
};
}
pure fn Cs(c: char) -> bool {
return alt c {
return match c {
'\ud800' to '\udfff' => true,
_ => false
};
}
pure fn Ll(c: char) -> bool {
return alt c {
return match c {
'\x61' to '\x7a'
| '\xaa'
| '\xb5'
@ -646,7 +646,7 @@ mod general_category {
}
pure fn Lm(c: char) -> bool {
return alt c {
return match c {
'\u02b0' to '\u02c1'
| '\u02c6' to '\u02d1'
| '\u02e0' to '\u02e4'
@ -702,7 +702,7 @@ mod general_category {
}
pure fn Lo(c: char) -> bool {
return alt c {
return match c {
'\u01bb'
| '\u01c0' to '\u01c3'
| '\u0294'
@ -888,7 +888,7 @@ mod general_category {
}
pure fn Lt(c: char) -> bool {
return alt c {
return match c {
'\u01c5'
| '\u01c8'
| '\u01cb'
@ -905,7 +905,7 @@ mod general_category {
}
pure fn Lu(c: char) -> bool {
return alt c {
return match c {
'\x41' to '\x5a'
| '\xc0' to '\xd6'
| '\xd8' to '\xde'
@ -1497,7 +1497,7 @@ mod general_category {
}
pure fn Mc(c: char) -> bool {
return alt c {
return match c {
'\u0903'
| '\u093b'
| '\u093e' to '\u0940'
@ -1608,7 +1608,7 @@ mod general_category {
}
pure fn Me(c: char) -> bool {
return alt c {
return match c {
'\u0488' to '\u0489'
| '\u20dd' to '\u20e0'
| '\u20e2' to '\u20e4'
@ -1619,7 +1619,7 @@ mod general_category {
}
pure fn Mn(c: char) -> bool {
return alt c {
return match c {
'\u0300' to '\u036f'
| '\u0483' to '\u0487'
| '\u0591' to '\u05bd'
@ -1812,7 +1812,7 @@ mod general_category {
}
pure fn Nd(c: char) -> bool {
return alt c {
return match c {
'\x30' to '\x39'
| '\u0660' to '\u0669'
| '\u06f0' to '\u06f9'
@ -1856,7 +1856,7 @@ mod general_category {
}
pure fn Nl(c: char) -> bool {
return alt c {
return match c {
'\u16ee' to '\u16f0'
| '\u2160' to '\u2182'
| '\u2185' to '\u2188'
@ -1875,7 +1875,7 @@ mod general_category {
}
pure fn No(c: char) -> bool {
return alt c {
return match c {
'\xb2' to '\xb3'
| '\xb9'
| '\xbc' to '\xbe'
@ -1923,7 +1923,7 @@ mod general_category {
}
pure fn Pc(c: char) -> bool {
return alt c {
return match c {
'\x5f'
| '\u203f' to '\u2040'
| '\u2054'
@ -1936,7 +1936,7 @@ mod general_category {
}
pure fn Pd(c: char) -> bool {
return alt c {
return match c {
'\x2d'
| '\u058a'
| '\u05be'
@ -1958,7 +1958,7 @@ mod general_category {
}
pure fn Pe(c: char) -> bool {
return alt c {
return match c {
'\x29'
| '\x5d'
| '\x7d'
@ -2035,7 +2035,7 @@ mod general_category {
}
pure fn Pf(c: char) -> bool {
return alt c {
return match c {
'\xbb'
| '\u2019'
| '\u201d'
@ -2052,7 +2052,7 @@ mod general_category {
}
pure fn Pi(c: char) -> bool {
return alt c {
return match c {
'\xab'
| '\u2018'
| '\u201b' to '\u201c'
@ -2070,7 +2070,7 @@ mod general_category {
}
pure fn Po(c: char) -> bool {
return alt c {
return match c {
'\x21' to '\x23'
| '\x25' to '\x27'
| '\x2a'
@ -2203,7 +2203,7 @@ mod general_category {
}
pure fn Ps(c: char) -> bool {
return alt c {
return match c {
'\x28'
| '\x5b'
| '\x7b'
@ -2282,7 +2282,7 @@ mod general_category {
}
pure fn Sc(c: char) -> bool {
return alt c {
return match c {
'\x24'
| '\xa2' to '\xa5'
| '\u060b'
@ -2305,7 +2305,7 @@ mod general_category {
}
pure fn Sk(c: char) -> bool {
return alt c {
return match c {
'\x5e'
| '\x60'
| '\xa8'
@ -2339,7 +2339,7 @@ mod general_category {
}
pure fn Sm(c: char) -> bool {
return alt c {
return match c {
'\x2b'
| '\x3c' to '\x3e'
| '\x7c'
@ -2410,7 +2410,7 @@ mod general_category {
}
pure fn So(c: char) -> bool {
return alt c {
return match c {
'\xa6' to '\xa7'
| '\xa9'
| '\xae'
@ -2529,21 +2529,21 @@ mod general_category {
}
pure fn Zl(c: char) -> bool {
return alt c {
return match c {
'\u2028' => true,
_ => false
};
}
pure fn Zp(c: char) -> bool {
return alt c {
return match c {
'\u2029' => true,
_ => false
};
}
pure fn Zs(c: char) -> bool {
return alt c {
return match c {
'\x20'
| '\xa0'
| '\u1680'
@ -2561,7 +2561,7 @@ mod general_category {
mod derived_property {
/// Check if a character has the alphabetic unicode property
pure fn Alphabetic(c: char) -> bool {
return alt c {
return match c {
'\x41' to '\x5a'
| '\x61' to '\x7a'
| '\xaa'
@ -3299,7 +3299,7 @@ mod derived_property {
}
pure fn XID_Continue(c: char) -> bool {
return alt c {
return match c {
'\x30' to '\x39'
| '\x41' to '\x5a'
| '\x5f'
@ -4170,7 +4170,7 @@ mod derived_property {
}
pure fn XID_Start(c: char) -> bool {
return alt c {
return match c {
'\x41' to '\x5a'
| '\x61' to '\x7a'
| '\xaa'

10
src/libcore/vec.rs
View file

@ -356,7 +356,7 @@ fn split<T: copy>(v: &[T], f: fn(T) -> bool) -> ~[~[T]] {
let mut start = 0u;
let mut result = ~[];
while start < ln {
alt position_between(v, start, ln, f) {
match position_between(v, start, ln, f) {
none => break,
some(i) => {
push(result, slice(v, start, i));
@ -380,7 +380,7 @@ fn splitn<T: copy>(v: &[T], n: uint, f: fn(T) -> bool) -> ~[~[T]] {
let mut count = n;
let mut result = ~[];
while start < ln && count > 0u {
alt position_between(v, start, ln, f) {
match position_between(v, start, ln, f) {
none => break,
some(i) => {
push(result, slice(v, start, i));
@ -405,7 +405,7 @@ fn rsplit<T: copy>(v: &[T], f: fn(T) -> bool) -> ~[~[T]] {
let mut end = ln;
let mut result = ~[];
while end > 0u {
alt rposition_between(v, 0u, end, f) {
match rposition_between(v, 0u, end, f) {
none => break,
some(i) => {
push(result, slice(v, i + 1u, end));
@ -429,7 +429,7 @@ fn rsplitn<T: copy>(v: &[T], n: uint, f: fn(T) -> bool) -> ~[~[T]] {
let mut count = n;
let mut result = ~[];
while end > 0u && count > 0u {
alt rposition_between(v, 0u, end, f) {
match rposition_between(v, 0u, end, f) {
none => break,
some(i) => {
push(result, slice(v, i + 1u, end));
@ -713,7 +713,7 @@ pure fn filter_map<T, U: copy>(v: &[T], f: fn(T) -> option<U>)
-> ~[U] {
let mut result = ~[];
for each(v) |elem| {
alt f(elem) {
match f(elem) {
none => {/* no-op */ }
some(result_elem) => unsafe { push(result, result_elem); }
}

4
src/libstd/base64.rs
View file

@ -30,7 +30,7 @@ impl of to_base64 for ~[u8] {
i += 3u;
}
alt check len % 3u {
match check len % 3u {
0u => (),
1u => {
let n = (self[i] as uint) << 16u;
@ -96,7 +96,7 @@ impl of from_base64 for ~[u8] {
} else if ch == '/' {
n |= 0x3Fu;
} else if ch == '=' {
alt len - i {
match len - i {
1u => {
vec::push(r, ((n >> 16u) & 0xFFu) as u8);
vec::push(r, ((n >> 8u ) & 0xFFu) as u8);

32
src/libstd/bitv.rs
View file

@ -179,9 +179,9 @@ class bitv {
if self.nbits != other.nbits {
self.die();
}
alt self.rep {
small(s) => alt other.rep {
small(s1) => alt op {
match self.rep {
small(s) => match other.rep {
small(s1) => match op {
union => s.union(s1),
intersect => s.intersect(s1),
assign => s.become(s1),
@ -189,9 +189,9 @@ class bitv {
}
big(s1) => self.die()
}
big(s) => alt other.rep {
big(s) => match other.rep {
small(_) => self.die(),
big(s1) => alt op {
big(s1) => match op {
union => s.union(s1),
intersect => s.intersect(s1),
assign => s.become(s1),
@ -232,7 +232,7 @@ class bitv {
/// Makes a copy of a bitvector
#[inline(always)]
fn clone() -> ~bitv {
~alt self.rep {
~match self.rep {
small(b) => {
bitv{nbits: self.nbits, rep: small(~small_bitv{bits: b.bits})}
}
@ -249,7 +249,7 @@ class bitv {
#[inline(always)]
pure fn get(i: uint) -> bool {
assert (i < self.nbits);
alt self.rep {
match self.rep {
big(b) => b.get(i),
small(s) => s.get(i)
}
@ -263,7 +263,7 @@ class bitv {
#[inline(always)]
fn set(i: uint, x: bool) {
assert (i < self.nbits);
alt self.rep {
match self.rep {
big(b) => b.set(i, x),
small(s) => s.set(i, x)
}
@ -278,12 +278,12 @@ class bitv {
#[inline(always)]
fn equal(v1: bitv) -> bool {
if self.nbits != v1.nbits { return false; }
alt self.rep {
small(b) => alt v1.rep {
match self.rep {
small(b) => match v1.rep {
small(b1) => b.equals(b1),
_ => false
}
big(s) => alt v1.rep {
big(s) => match v1.rep {
big(s1) => s.equals(s1),
small(_) => return false
}
@ -293,7 +293,7 @@ class bitv {
/// Set all bits to 0
#[inline(always)]
fn clear() {
alt self.rep {
match self.rep {
small(b) => b.clear(),
big(s) => for s.each_storage() |w| { w = 0u }
}
@ -302,7 +302,7 @@ class bitv {
/// Set all bits to 1
#[inline(always)]
fn set_all() {
alt self.rep {
match self.rep {
small(b) => b.set_all(),
big(s) => for s.each_storage() |w| { w = !0u } }
}
@ -310,7 +310,7 @@ class bitv {
/// Invert all bits
#[inline(always)]
fn invert() {
alt self.rep {
match self.rep {
small(b) => b.invert(),
big(s) => for s.each_storage() |w| { w = !w } }
}
@ -329,7 +329,7 @@ class bitv {
/// Returns true if all bits are 1
#[inline(always)]
fn is_true() -> bool {
alt self.rep {
match self.rep {
small(b) => b.is_true(),
_ => {
for self.each() |i| { if !i { return false; } }
@ -350,7 +350,7 @@ class bitv {
/// Returns true if all bits are 0
fn is_false() -> bool {
alt self.rep {
match self.rep {
small(b) => b.is_false(),
big(_) => {
for self.each() |i| { if i { return false; } }

2
src/libstd/c_vec.rs
View file

@ -46,7 +46,7 @@ class dtor_res {
let dtor: option<fn@()>;
new(dtor: option<fn@()>) { self.dtor = dtor; }
drop {
alt self.dtor {
match self.dtor {
option::none => (),
option::some(f) => f()
}

18
src/libstd/deque.rs
View file

@ -41,7 +41,7 @@ fn create<T: copy>() -> t<T> {
return rv;
}
fn get<T: copy>(elts: dvec<cell<T>>, i: uint) -> T {
alt elts.get_elt(i) { some(t) => t, _ => fail }
match elts.get_elt(i) { some(t) => t, _ => fail }
}
type repr<T> = {mut nelts: uint,
@ -238,32 +238,32 @@ mod tests {
fn inteq(&&a: int, &&b: int) -> bool { return a == b; }
fn intboxeq(&&a: @int, &&b: @int) -> bool { return a == b; }
fn taggyeq(a: taggy, b: taggy) -> bool {
alt a {
one(a1) => alt b {
match a {
one(a1) => match b {
one(b1) => return a1 == b1,
_ => return false
}
two(a1, a2) => alt b {
two(a1, a2) => match b {
two(b1, b2) => return a1 == b1 && a2 == b2,
_ => return false
}
three(a1, a2, a3) => alt b {
three(a1, a2, a3) => match b {
three(b1, b2, b3) => return a1 == b1 && a2 == b2 && a3 == b3,
_ => return false
}
}
}
fn taggypareq<T>(a: taggypar<T>, b: taggypar<T>) -> bool {
alt a {
onepar::<T>(a1) => alt b {
match a {
onepar::<T>(a1) => match b {
onepar::<T>(b1) => return a1 == b1,
_ => return false
}
twopar::<T>(a1, a2) => alt b {
twopar::<T>(a1, a2) => match b {
twopar::<T>(b1, b2) => return a1 == b1 && a2 == b2,
_ => return false
}
threepar::<T>(a1, a2, a3) => alt b {
threepar::<T>(a1, a2, a3) => match b {
threepar::<T>(b1, b2, b3) => {
return a1 == b1 && a2 == b2 && a3 == b3
}

8
src/libstd/ebml.rs
View file

@ -113,7 +113,7 @@ fn maybe_get_doc(d: doc, tg: uint) -> option<doc> {
}
fn get_doc(d: doc, tg: uint) -> doc {
alt maybe_get_doc(d, tg) {
match maybe_get_doc(d, tg) {
some(d) => return d,
none => {
error!{"failed to find block with tag %u", tg};
@ -189,7 +189,7 @@ enum writer {
}
fn write_sized_vuint(w: io::writer, n: uint, size: uint) {
alt size {
match size {
1u => w.write(&[0x80u8 | (n as u8)]),
2u => w.write(&[0x40u8 | ((n >> 8_u) as u8), n as u8]),
3u => w.write(&[0x20u8 | ((n >> 16_u) as u8), (n >> 8_u) as u8,
@ -593,7 +593,7 @@ fn test_option_int() {
fn serialize_0<S: serialization::serializer>(s: S, v: option<int>) {
do s.emit_enum(~"core::option::t") {
alt v {
match v {
none => s.emit_enum_variant(
~"core::option::none", 0u, 0u, || { } ),
some(v0) => {
@ -612,7 +612,7 @@ fn test_option_int() {
fn deserialize_0<S: serialization::deserializer>(s: S) -> option<int> {
do s.read_enum(~"core::option::t") {
do s.read_enum_variant |i| {
alt check i {
match check i {
0u => none,
1u => {
let v0 = do s.read_enum_variant_arg(0u) {

6
src/libstd/fun_treemap.rs
View file

@ -30,7 +30,7 @@ fn init<K, V>() -> treemap<K, V> { @empty }
/// Insert a value into the map
fn insert<K: copy, V: copy>(m: treemap<K, V>, k: K, v: V) -> treemap<K, V> {
@alt m {
@match m {
@empty => node(@k, @v, @empty, @empty),
@node(@kk, vv, left, right) => {
if k < kk {
@ -44,7 +44,7 @@ fn insert<K: copy, V: copy>(m: treemap<K, V>, k: K, v: V) -> treemap<K, V> {
/// Find a value based on the key
fn find<K, V: copy>(m: treemap<K, V>, k: K) -> option<V> {
alt *m {
match *m {
empty => none,
node(@kk, @v, left, right) => {
if k == kk {
@ -56,7 +56,7 @@ fn find<K, V: copy>(m: treemap<K, V>, k: K) -> option<V> {
/// Visit all pairs in the map in order.
fn traverse<K, V: copy>(m: treemap<K, V>, f: fn(K, V)) {
alt *m {
match *m {
empty => (),
/*
Previously, this had what looked like redundant

106
src/libstd/getopts.rs
View file

@ -43,7 +43,7 @@
* optflag("h"),
* optflag("help")
* ];
* let matches = alt getopts(vec::tail(args), opts) {
* let matches = match getopts(vec::tail(args), opts) {
* result::ok(m) { m }
* result::err(f) { fail fail_str(f) }
* };
@ -140,7 +140,7 @@ fn is_arg(arg: ~str) -> bool {
}
fn name_str(nm: name) -> ~str {
return alt nm {
return match nm {
short(ch) => str::from_char(ch),
long(s) => s
};
@ -164,7 +164,7 @@ enum fail_ {
/// Convert a `fail_` enum into an error string
fn fail_str(f: fail_) -> ~str {
return alt f {
return match f {
argument_missing(nm) => ~"Argument to option '" + nm + ~"' missing.",
unrecognized_option(nm) => ~"Unrecognized option: '" + nm + ~"'.",
option_missing(nm) => ~"Required option '" + nm + ~"' missing.",
@ -233,12 +233,14 @@ fn getopts(args: ~[~str], opts: ~[opt]) -> result unsafe {
correctly
*/
alt find_opt(opts, opt) {
match find_opt(opts, opt) {
some(id) => last_valid_opt_id = option::some(id),
none => {
let arg_follows =
option::is_some(last_valid_opt_id) &&
alt opts[option::get(last_valid_opt_id)].hasarg {
match opts[option::get(last_valid_opt_id)]
.hasarg {
yes | maybe => true,
no => false
};
@ -257,11 +259,11 @@ fn getopts(args: ~[~str], opts: ~[opt]) -> result unsafe {
let mut name_pos = 0u;
for vec::each(names) |nm| {
name_pos += 1u;
let optid = alt find_opt(opts, nm) {
let optid = match find_opt(opts, nm) {
some(id) => id,
none => return err(unrecognized_option(name_str(nm)))
};
alt opts[optid].hasarg {
match opts[optid].hasarg {
no => {
if !option::is_none::<~str>(i_arg) {
return err(unexpected_argument(name_str(nm)));
@ -309,7 +311,7 @@ fn getopts(args: ~[~str], opts: ~[opt]) -> result unsafe {
}
fn opt_vals(m: matches, nm: ~str) -> ~[optval] {
return alt find_opt(m.opts, mkname(nm)) {
return match find_opt(m.opts, mkname(nm)) {
some(id) => m.vals[id],
none => {
error!{"No option '%s' defined", nm};
@ -328,7 +330,7 @@ fn opt_present(m: matches, nm: ~str) -> bool {
/// Returns true if any of several options were matched
fn opts_present(m: matches, names: ~[~str]) -> bool {
for vec::each(names) |nm| {
alt find_opt(m.opts, mkname(nm)) {
match find_opt(m.opts, mkname(nm)) {
some(_) => return true,
_ => ()
}
@ -344,7 +346,7 @@ fn opts_present(m: matches, names: ~[~str]) -> bool {
* argument
*/
fn opt_str(m: matches, nm: ~str) -> ~str {
return alt opt_val(m, nm) { val(s) => s, _ => fail };
return match opt_val(m, nm) { val(s) => s, _ => fail };
}
/**
@ -355,7 +357,7 @@ fn opt_str(m: matches, nm: ~str) -> ~str {
*/
fn opts_str(m: matches, names: ~[~str]) -> ~str {
for vec::each(names) |nm| {
alt opt_val(m, nm) {
match opt_val(m, nm) {
val(s) => return s,
_ => ()
}
@ -373,7 +375,7 @@ fn opts_str(m: matches, names: ~[~str]) -> ~str {
fn opt_strs(m: matches, nm: ~str) -> ~[~str] {
let mut acc: ~[~str] = ~[];
for vec::each(opt_vals(m, nm)) |v| {
alt v { val(s) => vec::push(acc, s), _ => () }
match v { val(s) => vec::push(acc, s), _ => () }
}
return acc;
}
@ -382,7 +384,7 @@ fn opt_strs(m: matches, nm: ~str) -> ~[~str] {
fn opt_maybe_str(m: matches, nm: ~str) -> option<~str> {
let vals = opt_vals(m, nm);
if vec::len::<optval>(vals) == 0u { return none::<~str>; }
return alt vals[0] { val(s) => some::<~str>(s), _ => none::<~str> };
return match vals[0] { val(s) => some::<~str>(s), _ => none::<~str> };
}
@ -396,7 +398,7 @@ fn opt_maybe_str(m: matches, nm: ~str) -> option<~str> {
fn opt_default(m: matches, nm: ~str, def: ~str) -> option<~str> {
let vals = opt_vals(m, nm);
if vec::len::<optval>(vals) == 0u { return none::<~str>; }
return alt vals[0] { val(s) => some::<~str>(s), _ => some::<~str>(def) }
return match vals[0] { val(s) => some::<~str>(s), _ => some::<~str>(def) }
}
#[cfg(test)]
@ -413,7 +415,7 @@ mod tests {
}
fn check_fail_type(f: fail_, ft: fail_type) {
alt f {
match f {
argument_missing(_) => assert ft == argument_missing_,
unrecognized_option(_) => assert ft == unrecognized_option_,
option_missing(_) => assert ft == option_missing_,
@ -429,7 +431,7 @@ mod tests {
let args = ~[~"--test=20"];
let opts = ~[reqopt(~"test")];
let rs = getopts(args, opts);
alt check rs {
match check rs {
ok(m) => {
assert (opt_present(m, ~"test"));
assert (opt_str(m, ~"test") == ~"20");
@ -442,7 +444,7 @@ mod tests {
let args = ~[~"blah"];
let opts = ~[reqopt(~"test")];
let rs = getopts(args, opts);
alt rs {
match rs {
err(f) => check_fail_type(f, option_missing_),
_ => fail
}
@ -453,7 +455,7 @@ mod tests {
let args = ~[~"--test"];
let opts = ~[reqopt(~"test")];
let rs = getopts(args, opts);
alt rs {
match rs {
err(f) => check_fail_type(f, argument_missing_),
_ => fail
}
@ -464,7 +466,7 @@ mod tests {
let args = ~[~"--test=20", ~"--test=30"];
let opts = ~[reqopt(~"test")];
let rs = getopts(args, opts);
alt rs {
match rs {
err(f) => check_fail_type(f, option_duplicated_),
_ => fail
}
@ -475,7 +477,7 @@ mod tests {
let args = ~[~"-t", ~"20"];
let opts = ~[reqopt(~"t")];
let rs = getopts(args, opts);
alt rs {
match rs {
ok(m) => {
assert (opt_present(m, ~"t"));
assert (opt_str(m, ~"t") == ~"20");
@ -489,7 +491,7 @@ mod tests {
let args = ~[~"blah"];
let opts = ~[reqopt(~"t")];
let rs = getopts(args, opts);
alt rs {
match rs {
err(f) => check_fail_type(f, option_missing_),
_ => fail
}
@ -500,7 +502,7 @@ mod tests {
let args = ~[~"-t"];
let opts = ~[reqopt(~"t")];
let rs = getopts(args, opts);
alt rs {
match rs {
err(f) => check_fail_type(f, argument_missing_),
_ => fail
}
@ -511,7 +513,7 @@ mod tests {
let args = ~[~"-t", ~"20", ~"-t", ~"30"];
let opts = ~[reqopt(~"t")];
let rs = getopts(args, opts);
alt rs {
match rs {
err(f) => check_fail_type(f, option_duplicated_),
_ => fail
}
@ -524,7 +526,7 @@ mod tests {
let args = ~[~"--test=20"];
let opts = ~[optopt(~"test")];
let rs = getopts(args, opts);
alt rs {
match rs {
ok(m) => {
assert (opt_present(m, ~"test"));
assert (opt_str(m, ~"test") == ~"20");
@ -538,7 +540,7 @@ mod tests {
let args = ~[~"blah"];
let opts = ~[optopt(~"test")];
let rs = getopts(args, opts);
alt rs {
match rs {
ok(m) => assert (!opt_present(m, ~"test")),
_ => fail
}
@ -549,7 +551,7 @@ mod tests {
let args = ~[~"--test"];
let opts = ~[optopt(~"test")];
let rs = getopts(args, opts);
alt rs {
match rs {
err(f) => check_fail_type(f, argument_missing_),
_ => fail
}
@ -560,7 +562,7 @@ mod tests {
let args = ~[~"--test=20", ~"--test=30"];
let opts = ~[optopt(~"test")];
let rs = getopts(args, opts);
alt rs {
match rs {
err(f) => check_fail_type(f, option_duplicated_),
_ => fail
}
@ -571,7 +573,7 @@ mod tests {
let args = ~[~"-t", ~"20"];
let opts = ~[optopt(~"t")];
let rs = getopts(args, opts);
alt rs {
match rs {
ok(m) => {
assert (opt_present(m, ~"t"));
assert (opt_str(m, ~"t") == ~"20");
@ -585,7 +587,7 @@ mod tests {
let args = ~[~"blah"];
let opts = ~[optopt(~"t")];
let rs = getopts(args, opts);
alt rs {
match rs {
ok(m) => assert (!opt_present(m, ~"t")),
_ => fail
}
@ -596,7 +598,7 @@ mod tests {
let args = ~[~"-t"];
let opts = ~[optopt(~"t")];
let rs = getopts(args, opts);
alt rs {
match rs {
err(f) => check_fail_type(f, argument_missing_),
_ => fail
}
@ -607,7 +609,7 @@ mod tests {
let args = ~[~"-t", ~"20", ~"-t", ~"30"];
let opts = ~[optopt(~"t")];
let rs = getopts(args, opts);
alt rs {
match rs {
err(f) => check_fail_type(f, option_duplicated_),
_ => fail
}
@ -620,7 +622,7 @@ mod tests {
let args = ~[~"--test"];
let opts = ~[optflag(~"test")];
let rs = getopts(args, opts);
alt rs {
match rs {
ok(m) => assert (opt_present(m, ~"test")),
_ => fail
}
@ -631,7 +633,7 @@ mod tests {
let args = ~[~"blah"];
let opts = ~[optflag(~"test")];
let rs = getopts(args, opts);
alt rs {
match rs {
ok(m) => assert (!opt_present(m, ~"test")),
_ => fail
}
@ -642,7 +644,7 @@ mod tests {
let args = ~[~"--test=20"];
let opts = ~[optflag(~"test")];
let rs = getopts(args, opts);
alt rs {
match rs {
err(f) => {
log(error, fail_str(f));
check_fail_type(f, unexpected_argument_);
@ -656,7 +658,7 @@ mod tests {
let args = ~[~"--test", ~"--test"];
let opts = ~[optflag(~"test")];
let rs = getopts(args, opts);
alt rs {
match rs {
err(f) => check_fail_type(f, option_duplicated_),
_ => fail
}
@ -667,7 +669,7 @@ mod tests {
let args = ~[~"-t"];
let opts = ~[optflag(~"t")];
let rs = getopts(args, opts);
alt rs {
match rs {
ok(m) => assert (opt_present(m, ~"t")),
_ => fail
}
@ -678,7 +680,7 @@ mod tests {
let args = ~[~"blah"];
let opts = ~[optflag(~"t")];
let rs = getopts(args, opts);
alt rs {
match rs {
ok(m) => assert (!opt_present(m, ~"t")),
_ => fail
}
@ -689,7 +691,7 @@ mod tests {
let args = ~[~"-t", ~"20"];
let opts = ~[optflag(~"t")];
let rs = getopts(args, opts);
alt rs {
match rs {
ok(m) => {
// The next variable after the flag is just a free argument
@ -704,7 +706,7 @@ mod tests {
let args = ~[~"-t", ~"-t"];
let opts = ~[optflag(~"t")];
let rs = getopts(args, opts);
alt rs {
match rs {
err(f) => check_fail_type(f, option_duplicated_),
_ => fail
}
@ -717,7 +719,7 @@ mod tests {
let args = ~[~"--test=20"];
let opts = ~[optmulti(~"test")];
let rs = getopts(args, opts);
alt rs {
match rs {
ok(m) => {
assert (opt_present(m, ~"test"));
assert (opt_str(m, ~"test") == ~"20");
@ -731,7 +733,7 @@ mod tests {
let args = ~[~"blah"];
let opts = ~[optmulti(~"test")];
let rs = getopts(args, opts);
alt rs {
match rs {
ok(m) => assert (!opt_present(m, ~"test")),
_ => fail
}
@ -742,7 +744,7 @@ mod tests {
let args = ~[~"--test"];
let opts = ~[optmulti(~"test")];
let rs = getopts(args, opts);
alt rs {
match rs {
err(f) => check_fail_type(f, argument_missing_),
_ => fail
}
@ -753,7 +755,7 @@ mod tests {
let args = ~[~"--test=20", ~"--test=30"];
let opts = ~[optmulti(~"test")];
let rs = getopts(args, opts);
alt rs {
match rs {
ok(m) => {
assert (opt_present(m, ~"test"));
assert (opt_str(m, ~"test") == ~"20");
@ -769,7 +771,7 @@ mod tests {
let args = ~[~"-t", ~"20"];
let opts = ~[optmulti(~"t")];
let rs = getopts(args, opts);
alt rs {
match rs {
ok(m) => {
assert (opt_present(m, ~"t"));
assert (opt_str(m, ~"t") == ~"20");
@ -783,7 +785,7 @@ mod tests {
let args = ~[~"blah"];
let opts = ~[optmulti(~"t")];
let rs = getopts(args, opts);
alt rs {
match rs {
ok(m) => assert (!opt_present(m, ~"t")),
_ => fail
}
@ -794,7 +796,7 @@ mod tests {
let args = ~[~"-t"];
let opts = ~[optmulti(~"t")];
let rs = getopts(args, opts);
alt rs {
match rs {
err(f) => check_fail_type(f, argument_missing_),
_ => fail
}
@ -805,7 +807,7 @@ mod tests {
let args = ~[~"-t", ~"20", ~"-t", ~"30"];
let opts = ~[optmulti(~"t")];
let rs = getopts(args, opts);
alt rs {
match rs {
ok(m) => {
assert (opt_present(m, ~"t"));
assert (opt_str(m, ~"t") == ~"20");
@ -821,7 +823,7 @@ mod tests {
let args = ~[~"--untest"];
let opts = ~[optmulti(~"t")];
let rs = getopts(args, opts);
alt rs {
match rs {
err(f) => check_fail_type(f, unrecognized_option_),
_ => fail
}
@ -832,7 +834,7 @@ mod tests {
let args = ~[~"-t"];
let opts = ~[optmulti(~"test")];
let rs = getopts(args, opts);
alt rs {
match rs {
err(f) => check_fail_type(f, unrecognized_option_),
_ => fail
}
@ -849,7 +851,7 @@ mod tests {
optflag(~"f"), optmulti(~"m"), optmulti(~"n"),
optopt(~"notpresent")];
let rs = getopts(args, opts);
alt rs {
match rs {
ok(m) => {
assert (m.free[0] == ~"prog");
assert (m.free[1] == ~"free1");
@ -872,7 +874,7 @@ mod tests {
fn test_multi() {
let args = ~[~"-e", ~"foo", ~"--encrypt", ~"foo"];
let opts = ~[optopt(~"e"), optopt(~"encrypt")];
let matches = alt getopts(args, opts) {
let matches = match getopts(args, opts) {
result::ok(m) => m,
result::err(f) => fail
};
@ -893,7 +895,7 @@ mod tests {
fn test_nospace() {
let args = ~[~"-Lfoo"];
let opts = ~[optmulti(~"L")];
let matches = alt getopts(args, opts) {
let matches = match getopts(args, opts) {
result::ok(m) => m,
result::err(f) => fail
};

56
src/libstd/json.rs
View file

@ -45,7 +45,7 @@ type error = {
/// Serializes a json value into a io::writer
fn to_writer(wr: io::writer, j: json) {
alt j {
match j {
num(n) => wr.write_str(float::to_str(n, 6u)),
string(s) => wr.write_str(escape_str(*s)),
boolean(b) => wr.write_str(if b { ~"true" } else { ~"false" }),
@ -87,7 +87,7 @@ fn to_writer(wr: io::writer, j: json) {
fn escape_str(s: ~str) -> ~str {
let mut escaped = ~"\"";
do str::chars_iter(s) |c| {
alt c {
match c {
'"' => escaped += ~"\\\"",
'\\' => escaped += ~"\\\\",
'\x08' => escaped += ~"\\b",
@ -144,7 +144,7 @@ impl parser for parser {
}
fn parse() -> result<json, error> {
alt self.parse_value() {
match self.parse_value() {
ok(value) => {
// Skip trailing whitespaces.
self.parse_whitespace();
@ -164,12 +164,12 @@ impl parser for parser {
if self.eof() { return self.error(~"EOF while parsing value"); }
alt self.ch {
match self.ch {
'n' => self.parse_ident(~"ull", null),
't' => self.parse_ident(~"rue", boolean(true)),
'f' => self.parse_ident(~"alse", boolean(false)),
'0' to '9' | '-' => self.parse_number(),
'"' => alt self.parse_str() {
'"' => match self.parse_str() {
ok(s) => ok(string(s)),
err(e) => err(e)
}
@ -200,20 +200,20 @@ impl parser for parser {
neg = -1f;
}
let mut res = alt self.parse_integer() {
let mut res = match self.parse_integer() {
ok(res) => res,
err(e) => return err(e)
};
if self.ch == '.' {
alt self.parse_decimal(res) {
match self.parse_decimal(res) {
ok(r) => res = r,
err(e) => return err(e)
}
}
if self.ch == 'e' || self.ch == 'E' {
alt self.parse_exponent(res) {
match self.parse_exponent(res) {
ok(r) => res = r,
err(e) => return err(e)
}
@ -225,19 +225,19 @@ impl parser for parser {
fn parse_integer() -> result<float, error> {
let mut res = 0f;
alt self.ch {
match self.ch {
'0' => {
self.bump();
// There can be only one leading '0'.
alt self.ch {
match self.ch {
'0' to '9' => return self.error(~"invalid number"),
_ => ()
}
}
'1' to '9' => {
while !self.eof() {
alt self.ch {
match self.ch {
'0' to '9' => {
res *= 10f;
res += ((self.ch as int) - ('0' as int)) as float;
@ -258,7 +258,7 @@ impl parser for parser {
self.bump();
// Make sure a digit follows the decimal place.
alt self.ch {
match self.ch {
'0' to '9' => (),
_ => return self.error(~"invalid number")
}
@ -266,7 +266,7 @@ impl parser for parser {
let mut res = res;
let mut dec = 1f;
while !self.eof() {
alt self.ch {
match self.ch {
'0' to '9' => {
dec /= 10f;
res += (((self.ch as int) - ('0' as int)) as float) * dec;
@ -287,20 +287,20 @@ impl parser for parser {
let mut exp = 0u;
let mut neg_exp = false;
alt self.ch {
match self.ch {
'+' => self.bump(),
'-' => { self.bump(); neg_exp = true; }
_ => ()
}
// Make sure a digit follows the exponent place.
alt self.ch {
match self.ch {
'0' to '9' => (),
_ => return self.error(~"invalid number")
}
while !self.eof() {
alt self.ch {
match self.ch {
'0' to '9' => {
exp *= 10u;
exp += (self.ch as uint) - ('0' as uint);
@ -329,7 +329,7 @@ impl parser for parser {
self.bump();
if (escape) {
alt self.ch {
match self.ch {
'"' => str::push_char(res, '"'),
'\\' => str::push_char(res, '\\'),
'/' => str::push_char(res, '/'),
@ -343,7 +343,7 @@ impl parser for parser {
let mut i = 0u;
let mut n = 0u;
while i < 4u {
alt self.next_char() {
match self.next_char() {
'0' to '9' => {
n = n * 10u +
(self.ch as uint) - ('0' as uint);
@ -389,7 +389,7 @@ impl parser for parser {
}
loop {
alt self.parse_value() {
match self.parse_value() {
ok(v) => vec::push(values, v),
e => return e
}
@ -399,7 +399,7 @@ impl parser for parser {
return self.error(~"EOF while parsing list");
}
alt self.ch {
match self.ch {
',' => self.bump(),
']' => { self.bump(); return ok(list(@values)); }
_ => return self.error(~"expected `,` or `]`")
@ -425,7 +425,7 @@ impl parser for parser {
return self.error(~"key must be a string");
}
let key = alt self.parse_str() {
let key = match self.parse_str() {
ok(key) => key,
err(e) => return err(e)
};
@ -438,13 +438,13 @@ impl parser for parser {
}
self.bump();
alt self.parse_value() {
match self.parse_value() {
ok(value) => { values.insert(copy *key, value); }
e => return e
}
self.parse_whitespace();
alt self.ch {
match self.ch {
',' => self.bump(),
'}' => { self.bump(); return ok(dict(values)); }
_ => {
@ -477,7 +477,7 @@ fn from_str(s: ~str) -> result<json, error> {
/// Test if two json values are equal
fn eq(value0: json, value1: json) -> bool {
alt (value0, value1) {
match (value0, value1) {
(num(f0), num(f1)) => f0 == f1,
(string(s0), string(s1)) => s0 == s1,
(boolean(b0), boolean(b1)) => b0 == b1,
@ -486,7 +486,7 @@ fn eq(value0: json, value1: json) -> bool {
if d0.size() == d1.size() {
let mut equal = true;
for d0.each |k, v0| {
alt d1.find(k) {
match d1.find(k) {
some(v1) => if !eq(v0, v1) { equal = false },
none => equal = false
}
@ -581,7 +581,7 @@ impl of to_json for @~str {
impl <A: to_json, B: to_json> of to_json for (A, B) {
fn to_json() -> json {
alt self {
match self {
(a, b) => {
list(@~[a.to_json(), b.to_json()])
}
@ -592,7 +592,7 @@ impl <A: to_json, B: to_json> of to_json for (A, B) {
impl <A: to_json, B: to_json, C: to_json>
of to_json for (A, B, C) {
fn to_json() -> json {
alt self {
match self {
(a, b, c) => {
list(@~[a.to_json(), b.to_json(), c.to_json()])
}
@ -616,7 +616,7 @@ impl <A: to_json copy> of to_json for hashmap<~str, A> {
impl <A: to_json> of to_json for option<A> {
fn to_json() -> json {
alt self {
match self {
none => null,
some(value) => value.to_json()
}

14
src/libstd/list.rs
View file

@ -43,7 +43,7 @@ fn foldl<T: copy, U>(z: T, ls: @list<U>, f: fn(T, U) -> T) -> T {
fn find<T: copy>(ls: @list<T>, f: fn(T) -> bool) -> option<T> {
let mut ls = ls;
loop {
ls = alt *ls {
ls = match *ls {
cons(hd, tl) => {
if f(hd) { return some(hd); }
tl
@ -63,7 +63,7 @@ fn has<T: copy>(ls: @list<T>, elt: T) -> bool {
/// Returns true if the list is empty
pure fn is_empty<T: copy>(ls: @list<T>) -> bool {
alt *ls {
match *ls {
nil => true,
_ => false
}
@ -83,7 +83,7 @@ fn len<T>(ls: @list<T>) -> uint {
/// Returns all but the first element of a list
pure fn tail<T: copy>(ls: @list<T>) -> @list<T> {
alt *ls {
match *ls {
cons(_, tl) => return tl,
nil => fail ~"list empty"
}
@ -91,12 +91,12 @@ pure fn tail<T: copy>(ls: @list<T>) -> @list<T> {
/// Returns the first element of a list
pure fn head<T: copy>(ls: @list<T>) -> T {
alt check *ls { cons(hd, _) => hd }
match check *ls { cons(hd, _) => hd }
}
/// Appends one list to another
pure fn append<T: copy>(l: @list<T>, m: @list<T>) -> @list<T> {
alt *l {
match *l {
nil => return m,
cons(x, xs) => {
let rest = append(xs, m);
@ -114,7 +114,7 @@ fn push<T: copy>(&l: list<T>, v: T) {
fn iter<T>(l: @list<T>, f: fn(T)) {
let mut cur = l;
loop {
cur = alt *cur {
cur = match *cur {
cons(hd, tl) => {
f(hd);
tl
@ -128,7 +128,7 @@ fn iter<T>(l: @list<T>, f: fn(T)) {
fn each<T>(l: @list<T>, f: fn(T) -> bool) {
let mut cur = l;
loop {
cur = alt *cur {
cur = match *cur {
cons(hd, tl) => {
if !f(hd) { return; }
tl

16
src/libstd/map.rs
View file

@ -133,7 +133,7 @@ mod chained {
let mut e0 = e_root;
let mut comp = 1u; // for logging
loop {
alt copy e0.next {
match copy e0.next {
none => {
debug!{"search_tbl: absent, comp %u, hash %u, idx %u",
comp, h, idx};
@ -156,7 +156,7 @@ mod chained {
fn search_tbl(k: &K, h: uint) -> search_result<K,V> {
let idx = h % vec::len(self.chains);
alt copy self.chains[idx] {
match copy self.chains[idx] {
none => {
debug!{"search_tbl: none, comp %u, hash %u, idx %u",
0u, h, idx};
@ -193,7 +193,7 @@ mod chained {
while i < n {
let mut chain = self.chains[i];
loop {
chain = alt chain {
chain = match chain {
none => break,
some(entry) => {
let next = entry.next;
@ -216,7 +216,7 @@ mod chained {
fn contains_key_ref(k: &K) -> bool {
let hash = self.hasher(k);
alt self.search_tbl(k, hash) {
match self.search_tbl(k, hash) {
not_found => false,
found_first(*) | found_after(*) => true
}
@ -224,7 +224,7 @@ mod chained {
fn insert(+k: K, +v: V) -> bool {
let hash = self.hasher(&k);
alt self.search_tbl(&k, hash) {
match self.search_tbl(&k, hash) {
not_found => {
self.count += 1u;
let idx = hash % vec::len(self.chains);
@ -265,7 +265,7 @@ mod chained {
}
fn find(+k: K) -> option<V> {
alt self.search_tbl(&k, self.hasher(&k)) {
match self.search_tbl(&k, self.hasher(&k)) {
not_found => none,
found_first(_, entry) => some(entry.value),
found_after(_, entry) => some(entry.value)
@ -281,7 +281,7 @@ mod chained {
}
fn remove(+k: K) -> option<V> {
alt self.search_tbl(&k, self.hasher(&k)) {
match self.search_tbl(&k, self.hasher(&k)) {
not_found => none,
found_first(idx, entry) => {
self.count -= 1u;
@ -638,7 +638,7 @@ mod tests {
i = 0u;
while i < num_to_insert {
let v = hm.remove(i);
alt v {
match v {
option::some(u) => assert (u == i * i),
option::none => fail
}

16
src/libstd/net_ip.rs
View file

@ -47,7 +47,7 @@ type parse_addr_err = {
* * ip - a `std::net::ip::ip_addr`
*/
fn format_addr(ip: ip_addr) -> ~str {
alt ip {
match ip {
ipv4(addr) => unsafe {
let result = uv_ip4_name(&addr);
if result == ~"" {
@ -103,7 +103,7 @@ fn get_addr(++node: ~str, iotask: iotask)
node_ptr,
ptr::null(),
ptr::null());
alt result {
match result {
0i32 => {
set_data_for_req(handle_ptr, handle_data_ptr);
}
@ -134,7 +134,7 @@ mod v4 {
* * an `ip_addr` of the `ipv4` variant
*/
fn parse_addr(ip: ~str) -> ip_addr {
alt try_parse_addr(ip) {
match try_parse_addr(ip) {
result::ok(addr) => copy(addr),
result::err(err_data) => fail err_data.err_msg
}
@ -155,7 +155,7 @@ mod v4 {
}
fn parse_to_ipv4_rep(ip: ~str) -> result::result<ipv4_rep, ~str> {
let parts = vec::map(str::split_char(ip, '.'), |s| {
alt uint::from_str(s) {
match uint::from_str(s) {
some(n) if n <= 255u => n,
_ => 256u
}
@ -220,7 +220,7 @@ mod v6 {
* * an `ip_addr` of the `ipv6` variant
*/
fn parse_addr(ip: ~str) -> ip_addr {
alt try_parse_addr(ip) {
match try_parse_addr(ip) {
result::ok(addr) => copy(addr),
result::err(err_data) => fail err_data.err_msg
}
@ -326,7 +326,7 @@ mod test {
}
#[test]
fn test_ip_ipv4_bad_parse() {
alt v4::try_parse_addr(~"b4df00d") {
match v4::try_parse_addr(~"b4df00d") {
result::err(err_info) => {
log(debug, fmt!{"got error as expected %?", err_info});
assert true;
@ -339,7 +339,7 @@ mod test {
#[test]
#[ignore(target_os="win32")]
fn test_ip_ipv6_bad_parse() {
alt v6::try_parse_addr(~"::,~2234k;") {
match v6::try_parse_addr(~"::,~2234k;") {
result::err(err_info) => {
log(debug, fmt!{"got error as expected %?", err_info});
assert true;
@ -364,7 +364,7 @@ mod test {
log(debug, fmt!{"test_get_addr: Number of results for %s: %?",
localhost_name, vec::len(results)});
for vec::each(results) |r| {
let ipv_prefix = alt r {
let ipv_prefix = match r {
ipv4(_) => ~"IPv4",
ipv6(_) => ~"IPv6"
};

66
src/libstd/net_tcp.rs
View file

@ -151,16 +151,16 @@ fn connect(-input_ip: ip::ip_addr, port: uint,
log(debug, ~"in interact cb for tcp client connect..");
log(debug, fmt!{"stream_handle_ptr in interact %?",
stream_handle_ptr});
alt uv::ll::tcp_init( loop_ptr, stream_handle_ptr) {
match uv::ll::tcp_init( loop_ptr, stream_handle_ptr) {
0i32 => {
log(debug, ~"tcp_init successful");
alt input_ip {
match input_ip {
ipv4 => {
log(debug, ~"dealing w/ ipv4 connection..");
let connect_req_ptr =
ptr::addr_of((*socket_data_ptr).connect_req);
let addr_str = ip::format_addr(input_ip);
let connect_result = alt input_ip {
let connect_result = match input_ip {
ip::ipv4(addr) => {
// have to "recreate" the sockaddr_in/6
// since the ip_addr discards the port
@ -185,7 +185,7 @@ fn connect(-input_ip: ip::ip_addr, port: uint,
tcp_connect_on_connect_cb)
}
};
alt connect_result {
match connect_result {
0i32 => {
log(debug, ~"tcp_connect successful");
// reusable data that we'll have for the
@ -223,7 +223,7 @@ fn connect(-input_ip: ip::ip_addr, port: uint,
}
}
};
alt comm::recv(result_po) {
match comm::recv(result_po) {
conn_success => {
log(debug, ~"tcp::connect - received success on result_po");
result::ok(tcp_socket(socket_data))
@ -234,7 +234,7 @@ fn connect(-input_ip: ip::ip_addr, port: uint,
// still have to free the malloc'd stream handle..
rustrt::rust_uv_current_kernel_free(stream_handle_ptr
as *libc::c_void);
let tcp_conn_err = alt err_data.err_name {
let tcp_conn_err = match err_data.err_name {
~"ECONNREFUSED" => connection_refused,
_ => generic_connect_err(err_data.err_name, err_data.err_msg)
};
@ -445,7 +445,7 @@ fn read_future(sock: tcp_socket, timeout_msecs: uint)
* // do work here
* }
* };
* alt comm::recv(cont_po) {
* match comm::recv(cont_po) {
* // shut down listen()
* some(err_data) { comm::send(kill_chan, some(err_data)) }
* // wait for next connection
@ -469,7 +469,7 @@ fn read_future(sock: tcp_socket, timeout_msecs: uint)
fn accept(new_conn: tcp_new_connection)
-> result::result<tcp_socket, tcp_err_data> unsafe {
alt new_conn{
match new_conn{
new_tcp_conn(server_handle_ptr) => {
let server_data_ptr = uv::ll::get_data_for_uv_handle(
server_handle_ptr) as *tcp_listen_fc_data;
@ -501,10 +501,10 @@ fn accept(new_conn: tcp_new_connection)
log(debug, ~"in interact cb for tcp::accept");
let loop_ptr = uv::ll::get_loop_for_uv_handle(
server_handle_ptr);
alt uv::ll::tcp_init(loop_ptr, client_stream_handle_ptr) {
match uv::ll::tcp_init(loop_ptr, client_stream_handle_ptr) {
0i32 => {
log(debug, ~"uv_tcp_init successful for client stream");
alt uv::ll::accept(
match uv::ll::accept(
server_handle_ptr as *libc::c_void,
client_stream_handle_ptr as *libc::c_void) {
0i32 => {
@ -528,7 +528,7 @@ fn accept(new_conn: tcp_new_connection)
}
}
// UNSAFE LIBUV INTERACTION END
alt comm::recv(result_po) {
match comm::recv(result_po) {
some(err_data) => result::err(err_data),
none => result::ok(tcp_socket(client_socket_data))
}
@ -610,13 +610,13 @@ fn listen_common(-host_ip: ip::ip_addr, port: uint, backlog: uint,
// nested within a comm::listen block)
let loc_ip = copy(host_ip);
do iotask::interact(iotask) |loop_ptr| {
alt uv::ll::tcp_init(loop_ptr, server_stream_ptr) {
match uv::ll::tcp_init(loop_ptr, server_stream_ptr) {
0i32 => {
uv::ll::set_data_for_uv_handle(
server_stream_ptr,
server_data_ptr);
let addr_str = ip::format_addr(loc_ip);
let bind_result = alt loc_ip {
let bind_result = match loc_ip {
ip::ipv4(addr) => {
log(debug, fmt!{"addr: %?", addr});
let in_addr = uv::ll::ip4_addr(addr_str, port as int);
@ -630,9 +630,9 @@ fn listen_common(-host_ip: ip::ip_addr, port: uint, backlog: uint,
ptr::addr_of(in_addr))
}
};
alt bind_result {
match bind_result {
0i32 => {
alt uv::ll::listen(server_stream_ptr,
match uv::ll::listen(server_stream_ptr,
backlog as libc::c_int,
tcp_lfc_on_connection_cb) {
0i32 => comm::send(setup_ch, none),
@ -659,7 +659,7 @@ fn listen_common(-host_ip: ip::ip_addr, port: uint, backlog: uint,
};
setup_ch.recv()
};
alt setup_result {
match setup_result {
some(err_data) => {
do iotask::interact(iotask) |loop_ptr| {
log(debug, fmt!{"tcp::listen post-kill recv hl interact %?",
@ -668,7 +668,7 @@ fn listen_common(-host_ip: ip::ip_addr, port: uint, backlog: uint,
uv::ll::close(server_stream_ptr, tcp_lfc_close_cb);
};
stream_closed_po.recv();
alt err_data.err_name {
match err_data.err_name {
~"EACCES" => {
log(debug, ~"Got EACCES error");
result::err(access_denied)
@ -695,7 +695,7 @@ fn listen_common(-host_ip: ip::ip_addr, port: uint, backlog: uint,
uv::ll::close(server_stream_ptr, tcp_lfc_close_cb);
};
stream_closed_po.recv();
alt kill_result {
match kill_result {
// some failure post bind/listen
some(err_data) => result::err(generic_listen_err(err_data.err_name,
err_data.err_msg)),
@ -878,7 +878,7 @@ fn read_common_impl(socket_data: *tcp_socket_data, timeout_msecs: uint)
some(comm::recv(result::get(rs_result)))
};
log(debug, ~"tcp::read after recv_timeout");
alt read_result {
match read_result {
none => {
log(debug, ~"tcp::read: timed out..");
let err_data = {
@ -905,7 +905,7 @@ fn read_stop_common_impl(socket_data: *tcp_socket_data) ->
let stop_ch = comm::chan(stop_po);
do iotask::interact((*socket_data).iotask) |loop_ptr| {
log(debug, ~"in interact cb for tcp::read_stop");
alt uv::ll::read_stop(stream_handle_ptr as *uv::ll::uv_stream_t) {
match uv::ll::read_stop(stream_handle_ptr as *uv::ll::uv_stream_t) {
0i32 => {
log(debug, ~"successfully called uv_read_stop");
comm::send(stop_ch, none);
@ -917,7 +917,7 @@ fn read_stop_common_impl(socket_data: *tcp_socket_data) ->
}
}
};
alt comm::recv(stop_po) {
match comm::recv(stop_po) {
some(err_data) => result::err(err_data.to_tcp_err()),
none => result::ok(())
}
@ -933,7 +933,7 @@ fn read_start_common_impl(socket_data: *tcp_socket_data)
log(debug, ~"in tcp::read_start before interact loop");
do iotask::interact((*socket_data).iotask) |loop_ptr| {
log(debug, fmt!{"in tcp::read_start interact cb %?", loop_ptr});
alt uv::ll::read_start(stream_handle_ptr as *uv::ll::uv_stream_t,
match uv::ll::read_start(stream_handle_ptr as *uv::ll::uv_stream_t,
on_alloc_cb,
on_tcp_read_cb) {
0i32 => {
@ -947,7 +947,7 @@ fn read_start_common_impl(socket_data: *tcp_socket_data)
}
}
};
alt comm::recv(start_po) {
match comm::recv(start_po) {
some(err_data) => result::err(err_data.to_tcp_err()),
none => result::ok((*socket_data).reader_po)
}
@ -973,7 +973,7 @@ fn write_common_impl(socket_data_ptr: *tcp_socket_data,
let write_data_ptr = ptr::addr_of(write_data);
do iotask::interact((*socket_data_ptr).iotask) |loop_ptr| {
log(debug, fmt!{"in interact cb for tcp::write %?", loop_ptr});
alt uv::ll::write(write_req_ptr,
match uv::ll::write(write_req_ptr,
stream_handle_ptr,
write_buf_vec_ptr,
tcp_write_complete_cb) {
@ -993,7 +993,7 @@ fn write_common_impl(socket_data_ptr: *tcp_socket_data,
// and waiting here for the write to complete, we should transfer
// ownership of everything to the I/O task and let it deal with the
// aftermath, so we don't have to sit here blocking.
alt comm::recv(result_po) {
match comm::recv(result_po) {
tcp_write_success => result::ok(()),
tcp_write_error(err_data) => result::err(err_data.to_tcp_err())
}
@ -1024,7 +1024,7 @@ extern fn tcp_lfc_on_connection_cb(handle: *uv::ll::uv_tcp_t,
as *tcp_listen_fc_data;
let kill_ch = (*server_data_ptr).kill_ch;
if (*server_data_ptr).active {
alt status {
match status {
0i32 => (*server_data_ptr).on_connect_cb(handle),
_ => {
let loop_ptr = uv::ll::get_loop_for_uv_handle(handle);
@ -1081,7 +1081,7 @@ extern fn on_tcp_read_cb(stream: *uv::ll::uv_stream_t,
let loop_ptr = uv::ll::get_loop_for_uv_handle(stream);
let socket_data_ptr = uv::ll::get_data_for_uv_handle(stream)
as *tcp_socket_data;
alt nread as int {
match nread as int {
// incoming err.. probably eof
-1 => {
let err_data = uv::ll::get_last_err_data(loop_ptr).to_tcp_err();
@ -1175,7 +1175,7 @@ extern fn tcp_connect_on_connect_cb(connect_req_ptr: *uv::ll::uv_connect_t,
log(debug, fmt!{"tcp_connect result_ch %?", result_ch});
let tcp_stream_ptr =
uv::ll::get_stream_handle_from_connect_req(connect_req_ptr);
alt status {
match status {
0i32 => {
log(debug, ~"successful tcp connection!");
comm::send(result_ch, conn_success);
@ -1336,7 +1336,7 @@ mod test {
client_ch,
hl_loop)
};
alt actual_resp_result.get_err() {
match actual_resp_result.get_err() {
connection_refused => (),
_ => fail ~"unknown error.. expected connection_refused"
}
@ -1382,7 +1382,7 @@ mod test {
client_ch,
hl_loop)
};
alt listen_err {
match listen_err {
address_in_use => {
assert true;
}
@ -1401,7 +1401,7 @@ mod test {
server_ip,
server_port,
hl_loop);
alt listen_err {
match listen_err {
access_denied => {
assert true;
}
@ -1515,7 +1515,7 @@ mod test {
log(debug, ~"SERVER: successfully accepted"+
~"connection!");
let received_req_bytes = read(sock, 0u);
alt received_req_bytes {
match received_req_bytes {
result::ok(data) => {
log(debug, ~"SERVER: got REQ str::from_bytes..");
log(debug, fmt!{"SERVER: REQ data len: %?",
@ -1544,7 +1544,7 @@ mod test {
});
// err check on listen_result
if result::is_err(listen_result) {
alt result::get_err(listen_result) {
match result::get_err(listen_result) {
generic_listen_err(name, msg) => {
fail fmt!{"SERVER: exited abnormally name %s msg %s",
name, msg};

72
src/libstd/rope.rs
View file

@ -133,10 +133,10 @@ fn prepend_str(rope: rope, str: @~str) -> rope {
/// Concatenate two ropes
fn append_rope(left: rope, right: rope) -> rope {
alt(left) {
match (left) {
node::empty => return right,
node::content(left_content) => {
alt(right) {
match (right) {
node::empty => return left,
node::content(right_content) => {
return node::content(node::concat2(left_content, right_content));
@ -197,9 +197,9 @@ Section: Keeping ropes healthy
* to rebalance your rope at some point, before using it for other purposes.
*/
fn bal(rope:rope) -> rope {
alt(rope) {
match (rope) {
node::empty => return rope,
node::content(x) => alt(node::bal(x)) {
node::content(x) => match (node::bal(x)) {
option::none => rope,
option::some(y) => node::content(y)
}
@ -226,7 +226,7 @@ Section: Transforming ropes
*/
fn sub_chars(rope: rope, char_offset: uint, char_len: uint) -> rope {
if char_len == 0u { return node::empty; }
alt(rope) {
match (rope) {
node::empty => fail,
node::content(node) => if char_len > node::char_len(node) {
fail
@ -251,7 +251,7 @@ fn sub_chars(rope: rope, char_offset: uint, char_len: uint) -> rope {
*/
fn sub_bytes(rope: rope, byte_offset: uint, byte_len: uint) -> rope {
if byte_len == 0u { return node::empty; }
alt(rope) {
match (rope) {
node::empty => fail,
node::content(node) =>if byte_len > node::byte_len(node) {
fail
@ -276,7 +276,7 @@ Section: Comparing ropes
* value if `left > right`
*/
fn cmp(left: rope, right: rope) -> int {
alt((left, right)) {
match ((left, right)) {
(node::empty, node::empty) => return 0,
(node::empty, _) => return -1,
(_, node::empty) => return 1,
@ -379,7 +379,7 @@ Section: Iterating
* that is if `it` returned `false` at any point.
*/
fn loop_chars(rope: rope, it: fn(char) -> bool) -> bool {
alt(rope) {
match (rope) {
node::empty => return true,
node::content(x) => return node::loop_chars(x, it)
}
@ -422,7 +422,7 @@ fn iter_chars(rope: rope, it: fn(char)) {
* that is if `it` returned `false` at any point.
*/
fn loop_leaves(rope: rope, it: fn(node::leaf) -> bool) -> bool{
alt(rope) {
match (rope) {
node::empty => return true,
node::content(x) => return node::loop_leaves(x, it)
}
@ -431,7 +431,7 @@ fn loop_leaves(rope: rope, it: fn(node::leaf) -> bool) -> bool{
mod iterator {
mod leaf {
fn start(rope: rope) -> node::leaf_iterator::t {
alt(rope) {
match (rope) {
node::empty => return node::leaf_iterator::empty(),
node::content(x) => return node::leaf_iterator::start(x)
}
@ -442,7 +442,7 @@ mod iterator {
}
mod char {
fn start(rope: rope) -> node::char_iterator::t {
alt(rope) {
match (rope) {
node::empty => return node::char_iterator::empty(),
node::content(x) => return node::char_iterator::start(x)
}
@ -469,7 +469,7 @@ mod iterator {
* Constant time.
*/
fn height(rope: rope) -> uint {
alt(rope) {
match (rope) {
node::empty => return 0u,
node::content(x) => return node::height(x)
}
@ -485,7 +485,7 @@ fn height(rope: rope) -> uint {
* Constant time.
*/
pure fn char_len(rope: rope) -> uint {
alt(rope) {
match (rope) {
node::empty => return 0u,
node::content(x) => return node::char_len(x)
}
@ -499,7 +499,7 @@ pure fn char_len(rope: rope) -> uint {
* Constant time.
*/
pure fn byte_len(rope: rope) -> uint {
alt(rope) {
match (rope) {
node::empty => return 0u,
node::content(x) => return node::byte_len(x)
}
@ -522,7 +522,7 @@ pure fn byte_len(rope: rope) -> uint {
* rope + the (bounded) length of the largest leaf.
*/
fn char_at(rope: rope, pos: uint) -> char {
alt(rope) {
match (rope) {
node::empty => fail,
node::content(x) => return node::char_at(x, pos)
}
@ -730,14 +730,14 @@ mod node {
pure fn byte_len(node: @node) -> uint {
//FIXME (#2744): Could we do this without the pattern-matching?
alt(*node) {
match (*node) {
leaf(y) => return y.byte_len,
concat(y) => return y.byte_len
}
}
pure fn char_len(node: @node) -> uint {
alt(*node) {
match (*node) {
leaf(y) => return y.char_len,
concat(y) => return y.char_len
}
@ -800,7 +800,7 @@ mod node {
let mut offset = 0u;//Current position in the buffer
let it = leaf_iterator::start(node);
loop {
alt(leaf_iterator::next(it)) {
match (leaf_iterator::next(it)) {
option::none => break,
option::some(x) => {
//FIXME (#2744): Replace with memcpy or something similar
@ -827,7 +827,7 @@ mod node {
* This function executes in linear time.
*/
fn flatten(node: @node) -> @node unsafe {
alt(*node) {
match (*node) {
leaf(_) => return node,
concat(x) => {
return @leaf({
@ -861,7 +861,7 @@ mod node {
let mut forest = ~[mut];
let it = leaf_iterator::start(node);
loop {
alt (leaf_iterator::next(it)) {
match (leaf_iterator::next(it)) {
option::none => break,
option::some(x) => vec::push(forest, @leaf(x))
}
@ -898,7 +898,7 @@ mod node {
if byte_offset == 0u && byte_len == node::byte_len(node) {
return node;
}
alt(*node) {
match (*node) {
node::leaf(x) => {
let char_len =
str::count_chars(*x.content, byte_offset, byte_len);
@ -956,7 +956,7 @@ mod node {
let mut node = node;
let mut char_offset = char_offset;
loop {
alt(*node) {
match (*node) {
node::leaf(x) => {
if char_offset == 0u && char_len == x.char_len {
return node;
@ -1007,7 +1007,7 @@ mod node {
}
fn height(node: @node) -> uint {
alt(*node) {
match (*node) {
leaf(_) => return 0u,
concat(x) => return x.height
}
@ -1018,7 +1018,7 @@ mod node {
let itb = char_iterator::start(b);
let mut result = 0;
while result == 0 {
alt((char_iterator::next(ita), char_iterator::next(itb))) {
match ((char_iterator::next(ita), char_iterator::next(itb))) {
(option::none, option::none) => break,
(option::some(chara), option::some(charb)) => {
result = char::cmp(chara, charb);
@ -1059,7 +1059,7 @@ mod node {
fn loop_leaves(node: @node, it: fn(leaf) -> bool) -> bool{
let mut current = node;
loop {
alt(*current) {
match (*current) {
leaf(x) => return it(x),
concat(x) => if loop_leaves(x.left, it) { //non tail call
current = x.right; //tail call
@ -1091,7 +1091,7 @@ mod node {
let mut node = node;
let mut pos = pos;
loop {
alt *node {
match *node {
leaf(x) => return str::char_at(*x.content, pos),
concat({left, right, _}) => {
let left_len = char_len(left);
@ -1126,7 +1126,7 @@ mod node {
loop {
let current = it.stack[it.stackpos];
it.stackpos -= 1;
alt(*current) {
match (*current) {
concat(x) => {
it.stackpos += 1;
it.stack[it.stackpos] = x.right;
@ -1164,11 +1164,11 @@ mod node {
fn next(it: t) -> option<char> {
loop {
alt(get_current_or_next_leaf(it)) {
match (get_current_or_next_leaf(it)) {
option::none => return option::none,
option::some(_) => {
let next_char = get_next_char_in_leaf(it);
alt(next_char) {
match (next_char) {
option::none => again,
option::some(_) => return next_char
}
@ -1178,11 +1178,11 @@ mod node {
}
fn get_current_or_next_leaf(it: t) -> option<leaf> {
alt(it.leaf) {
match (it.leaf) {
option::some(_) => return it.leaf,
option::none => {
let next = leaf_iterator::next(it.leaf_iterator);
alt(next) {
match (next) {
option::none => return option::none,
option::some(_) => {
it.leaf = next;
@ -1195,7 +1195,7 @@ mod node {
}
fn get_next_char_in_leaf(it: t) -> option<char> {
alt copy it.leaf {
match copy it.leaf {
option::none => return option::none,
option::some(aleaf) => {
if it.leaf_byte_pos >= aleaf.byte_len {
@ -1220,12 +1220,12 @@ mod tests {
//Utility function, used for sanity check
fn rope_to_string(r: rope) -> ~str {
alt(r) {
match (r) {
node::empty => return ~"",
node::content(x) => {
let str = @mut ~"";
fn aux(str: @mut ~str, node: @node::node) unsafe {
alt(*node) {
match (*node) {
node::leaf(x) => {
*str += str::slice(
*x.content, x.byte_offset,
@ -1274,7 +1274,7 @@ mod tests {
let rope_iter = iterator::char::start(r);
let mut equal = true;
while equal {
alt(node::char_iterator::next(rope_iter)) {
match (node::char_iterator::next(rope_iter)) {
option::none => {
if string_iter < string_len {
equal = false;
@ -1301,7 +1301,7 @@ mod tests {
let mut len = 0u;
let it = iterator::char::start(r);
loop {
alt(node::char_iterator::next(it)) {
match (node::char_iterator::next(it)) {
option::none => break,
option::some(_) => len += 1u
}

4
src/libstd/serialization.rs
View file

@ -243,7 +243,7 @@ fn deserialize_bool<D: deserializer>(d: D) -> bool {
fn serialize_option<S: serializer,T>(s: S, v: option<T>, st: fn(T)) {
do s.emit_enum(~"option") {
alt v {
match v {
none => do s.emit_enum_variant(~"none", 0u, 0u) {
}
@ -260,7 +260,7 @@ fn deserialize_option<D: deserializer,T: copy>(d: D, st: fn() -> T)
-> option<T> {
do d.read_enum(~"option") {
do d.read_enum_variant |i| {
alt check i {
match check i {
0u => none,
1u => some(d.read_enum_variant_arg(0u, || st() ))
}

8
src/libstd/smallintmap.rs
View file

@ -48,7 +48,7 @@ pure fn find<T: copy>(self: smallintmap<T>, key: uint) -> option<T> {
* If the key does not exist in the map
*/
pure fn get<T: copy>(self: smallintmap<T>, key: uint) -> T {
alt find(self, key) {
match find(self, key) {
none => {
error!{"smallintmap::get(): key not present"};
fail;
@ -67,7 +67,7 @@ impl <V: copy> of map::map<uint, V> for smallintmap<V> {
fn size() -> uint {
let mut sz = 0u;
for self.v.each |item| {
alt item {
match item {
some(_) => sz += 1u,
_ => ()
}
@ -103,7 +103,7 @@ impl <V: copy> of map::map<uint, V> for smallintmap<V> {
fn each(it: fn(+key: uint, +value: V) -> bool) {
let mut idx = 0u, l = self.v.len();
while idx < l {
alt self.v.get_elt(idx) {
match self.v.get_elt(idx) {
some(elt) => if !it(idx, elt) { break }
none => ()
}
@ -119,7 +119,7 @@ impl <V: copy> of map::map<uint, V> for smallintmap<V> {
fn each_ref(it: fn(key: &uint, value: &V) -> bool) {
let mut idx = 0u, l = self.v.len();
while idx < l {
alt self.v.get_elt(idx) {
match self.v.get_elt(idx) {
some(elt) => if !it(&idx, &elt) { break }
none => ()
}

2
src/libstd/tempfile.rs
View file

@ -21,7 +21,7 @@ fn mkdtemp(prefix: ~str, suffix: ~str) -> option<~str> {
#[test]
fn test_mkdtemp() {
let r = mkdtemp(~"./", ~"foobar");
alt r {
match r {
some(p) => {
os::remove_dir(p);
assert(str::ends_with(p, ~"foobar"));

2
src/libstd/term.rs
View file

@ -35,7 +35,7 @@ fn reset(writer: io::writer) {
fn color_supported() -> bool {
let supported_terms = ~[~"xterm-color", ~"xterm",
~"screen-bce", ~"xterm-256color"];
return alt os::getenv(~"TERM") {
return match os::getenv(~"TERM") {
option::some(env) => {
for vec::each(supported_terms) |term| {
if term == env { return true; }

23
src/libstd/test.rs
View file

@ -52,7 +52,7 @@ type test_desc = {
// arguments and a vector of test_descs (generated at compile time).
fn test_main(args: ~[~str], tests: ~[test_desc]) {
let opts =
alt parse_opts(args) {
match parse_opts(args) {
either::left(o) => o,
either::right(m) => fail m
};
@ -69,7 +69,7 @@ fn parse_opts(args: ~[~str]) -> opt_res {
let args_ = vec::tail(args);
let opts = ~[getopts::optflag(~"ignored"), getopts::optopt(~"logfile")];
let matches =
alt getopts::getopts(args_, opts) {
match getopts::getopts(args_, opts) {
ok(m) => m,
err(f) => return either::right(getopts::fail_str(f))
};
@ -105,7 +105,7 @@ fn run_tests_console(opts: test_opts,
tests: ~[test_desc]) -> bool {
fn callback(event: testevent, st: console_test_state) {
alt event {
match event {
te_filtered(filtered_tests) => {
st.total = vec::len(filtered_tests);
let noun = if st.total != 1u { ~"tests" } else { ~"test" };
@ -113,11 +113,11 @@ fn run_tests_console(opts: test_opts,
}
te_wait(test) => st.out.write_str(fmt!{"test %s ... ", test.name}),
te_result(test, result) => {
alt st.log_out {
match st.log_out {
some(f) => write_log(f, result, test),
none => ()
}
alt result {
match result {
tr_ok => {
st.passed += 1u;
write_ok(st.out, st.use_color);
@ -139,8 +139,9 @@ fn run_tests_console(opts: test_opts,
}
}
let log_out = alt opts.logfile {
some(path) => alt io::file_writer(path, ~[io::create, io::truncate]) {
let log_out = match opts.logfile {
some(path) => match io::file_writer(path,
~[io::create, io::truncate]) {
result::ok(w) => some(w),
result::err(s) => {
fail(fmt!{"can't open output file: %s", s})
@ -180,7 +181,7 @@ fn run_tests_console(opts: test_opts,
fn write_log(out: io::writer, result: test_result, test: test_desc) {
out.write_line(fmt!{"%s %s",
alt result {
match result {
tr_ok => ~"ok",
tr_failed => ~"failed",
tr_ignored => ~"ignored"
@ -334,7 +335,7 @@ fn filter_tests(opts: test_opts,
filtered
} else {
let filter_str =
alt opts.filter {
match opts.filter {
option::some(f) => f,
option::none => ~""
};
@ -479,7 +480,7 @@ mod tests {
#[test]
fn first_free_arg_should_be_a_filter() {
let args = ~[~"progname", ~"filter"];
let opts = alt parse_opts(args) {
let opts = match parse_opts(args) {
either::left(o) => o,
_ => fail ~"Malformed arg in first_free_arg_should_be_a_filter"
};
@ -489,7 +490,7 @@ mod tests {
#[test]
fn parse_ignored_flag() {
let args = ~[~"progname", ~"filter", ~"--ignored"];
let opts = alt parse_opts(args) {
let opts = match parse_opts(args) {
either::left(o) => o,
_ => fail ~"Malformed arg in parse_ignored_flag"
};

74
src/libstd/time.rs
View file

@ -181,7 +181,7 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
let {ch, next} = str::char_range_at(s, pos);
pos = next;
alt ch {
match ch {
'0' to '9' => {
value = value * 10_i32 + (ch as i32 - '0' as i32);
}
@ -208,8 +208,8 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
fn parse_type(s: ~str, pos: uint, ch: char, tm: tm_mut)
-> result<uint, ~str> {
alt ch {
'A' => alt match_strs(s, pos, ~[
match ch {
'A' => match match_strs(s, pos, ~[
(~"Sunday", 0_i32),
(~"Monday", 1_i32),
(~"Tuesday", 2_i32),
@ -221,7 +221,7 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
some(item) => { let (v, pos) = item; tm.tm_wday = v; ok(pos) }
none => err(~"Invalid day")
}
'a' => alt match_strs(s, pos, ~[
'a' => match match_strs(s, pos, ~[
(~"Sun", 0_i32),
(~"Mon", 1_i32),
(~"Tue", 2_i32),
@ -233,7 +233,7 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
some(item) => { let (v, pos) = item; tm.tm_wday = v; ok(pos) }
none => err(~"Invalid day")
}
'B' => alt match_strs(s, pos, ~[
'B' => match match_strs(s, pos, ~[
(~"January", 0_i32),
(~"February", 1_i32),
(~"March", 2_i32),
@ -250,7 +250,7 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
some(item) => { let (v, pos) = item; tm.tm_mon = v; ok(pos) }
none => err(~"Invalid month")
}
'b' | 'h' => alt match_strs(s, pos, ~[
'b' | 'h' => match match_strs(s, pos, ~[
(~"Jan", 0_i32),
(~"Feb", 1_i32),
(~"Mar", 2_i32),
@ -267,7 +267,7 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
some(item) => { let (v, pos) = item; tm.tm_mon = v; ok(pos) }
none => err(~"Invalid month")
}
'C' => alt match_digits(s, pos, 2u, false) {
'C' => match match_digits(s, pos, 2u, false) {
some(item) => {
let (v, pos) = item;
tm.tm_year += (v * 100_i32) - 1900_i32;
@ -293,11 +293,11 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
.chain(|pos| parse_char(s, pos, '/'))
.chain(|pos| parse_type(s, pos, 'y', tm))
}
'd' => alt match_digits(s, pos, 2u, false) {
'd' => match match_digits(s, pos, 2u, false) {
some(item) => { let (v, pos) = item; tm.tm_mday = v; ok(pos) }
none => err(~"Invalid day of the month")
}
'e' => alt match_digits(s, pos, 2u, true) {
'e' => match match_digits(s, pos, 2u, true) {
some(item) => { let (v, pos) = item; tm.tm_mday = v; ok(pos) }
none => err(~"Invalid day of the month")
}
@ -310,14 +310,14 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
}
'H' => {
// FIXME (#2350): range check.
alt match_digits(s, pos, 2u, false) {
match match_digits(s, pos, 2u, false) {
some(item) => { let (v, pos) = item; tm.tm_hour = v; ok(pos) }
none => err(~"Invalid hour")
}
}
'I' => {
// FIXME (#2350): range check.
alt match_digits(s, pos, 2u, false) {
match match_digits(s, pos, 2u, false) {
some(item) => {
let (v, pos) = item;
tm.tm_hour = if v == 12_i32 { 0_i32 } else { v };
@ -328,7 +328,7 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
}
'j' => {
// FIXME (#2350): range check.
alt match_digits(s, pos, 3u, false) {
match match_digits(s, pos, 3u, false) {
some(item) => {
let (v, pos) = item;
tm.tm_yday = v - 1_i32;
@ -339,14 +339,14 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
}
'k' => {
// FIXME (#2350): range check.
alt match_digits(s, pos, 2u, true) {
match match_digits(s, pos, 2u, true) {
some(item) => { let (v, pos) = item; tm.tm_hour = v; ok(pos) }
none => err(~"Invalid hour")
}
}
'l' => {
// FIXME (#2350): range check.
alt match_digits(s, pos, 2u, true) {
match match_digits(s, pos, 2u, true) {
some(item) => {
let (v, pos) = item;
tm.tm_hour = if v == 12_i32 { 0_i32 } else { v };
@ -357,14 +357,14 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
}
'M' => {
// FIXME (#2350): range check.
alt match_digits(s, pos, 2u, false) {
match match_digits(s, pos, 2u, false) {
some(item) => { let (v, pos) = item; tm.tm_min = v; ok(pos) }
none => err(~"Invalid minute")
}
}
'm' => {
// FIXME (#2350): range check.
alt match_digits(s, pos, 2u, false) {
match match_digits(s, pos, 2u, false) {
some(item) => {
let (v, pos) = item;
tm.tm_mon = v - 1_i32;
@ -374,11 +374,15 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
}
}
'n' => parse_char(s, pos, '\n'),
'P' => alt match_strs(s, pos, ~[(~"am", 0_i32), (~"pm", 12_i32)]) {
'P' => match match_strs(s, pos,
~[(~"am", 0_i32), (~"pm", 12_i32)]) {
some(item) => { let (v, pos) = item; tm.tm_hour += v; ok(pos) }
none => err(~"Invalid hour")
}
'p' => alt match_strs(s, pos, ~[(~"AM", 0_i32), (~"PM", 12_i32)]) {
'p' => match match_strs(s, pos,
~[(~"AM", 0_i32), (~"PM", 12_i32)]) {
some(item) => { let (v, pos) = item; tm.tm_hour += v; ok(pos) }
none => err(~"Invalid hour")
}
@ -398,7 +402,7 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
}
'S' => {
// FIXME (#2350): range check.
alt match_digits(s, pos, 2u, false) {
match match_digits(s, pos, 2u, false) {
some(item) => {
let (v, pos) = item;
tm.tm_sec = v;
@ -418,7 +422,7 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
't' => parse_char(s, pos, '\t'),
'u' => {
// FIXME (#2350): range check.
alt match_digits(s, pos, 1u, false) {
match match_digits(s, pos, 1u, false) {
some(item) => {
let (v, pos) = item;
tm.tm_wday = v;
@ -437,7 +441,7 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
//'W' {}
'w' => {
// FIXME (#2350): range check.
alt match_digits(s, pos, 1u, false) {
match match_digits(s, pos, 1u, false) {
some(item) => { let (v, pos) = item; tm.tm_wday = v; ok(pos) }
none => err(~"Invalid weekday")
}
@ -446,7 +450,7 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
//'x' {}
'Y' => {
// FIXME (#2350): range check.
alt match_digits(s, pos, 4u, false) {
match match_digits(s, pos, 4u, false) {
some(item) => {
let (v, pos) = item;
tm.tm_year = v - 1900_i32;
@ -457,7 +461,7 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
}
'y' => {
// FIXME (#2350): range check.
alt match_digits(s, pos, 2u, false) {
match match_digits(s, pos, 2u, false) {
some(item) => {
let (v, pos) = item;
tm.tm_year = v - 1900_i32;
@ -489,7 +493,7 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
let {ch, next} = str::char_range_at(s, pos);
if ch == '+' || ch == '-' {
alt match_digits(s, next, 4u, false) {
match match_digits(s, next, 4u, false) {
some(item) => {
let (v, pos) = item;
if v == 0_i32 {
@ -534,8 +538,8 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
while !rdr.eof() && pos < len {
let {ch, next} = str::char_range_at(s, pos);
alt rdr.read_char() {
'%' => alt parse_type(s, pos, rdr.read_char(), tm) {
match rdr.read_char() {
'%' => match parse_type(s, pos, rdr.read_char(), tm) {
ok(next) => pos = next,
err(e) => { result = err(e); break; }
}
@ -568,8 +572,8 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
fn strftime(format: ~str, tm: tm) -> ~str {
fn parse_type(ch: char, tm: tm) -> ~str {
//FIXME (#2350): Implement missing types.
alt check ch {
'A' => alt check tm.tm_wday as int {
match check ch {
'A' => match check tm.tm_wday as int {
0 => ~"Sunday",
1 => ~"Monday",
2 => ~"Tuesday",
@ -578,7 +582,7 @@ fn strftime(format: ~str, tm: tm) -> ~str {
5 => ~"Friday",
6 => ~"Saturday"
}
'a' => alt check tm.tm_wday as int {
'a' => match check tm.tm_wday as int {
0 => ~"Sun",
1 => ~"Mon",
2 => ~"Tue",
@ -587,7 +591,7 @@ fn strftime(format: ~str, tm: tm) -> ~str {
5 => ~"Fri",
6 => ~"Sat"
}
'B' => alt check tm.tm_mon as int {
'B' => match check tm.tm_mon as int {
0 => ~"January",
1 => ~"February",
2 => ~"March",
@ -601,7 +605,7 @@ fn strftime(format: ~str, tm: tm) -> ~str {
10 => ~"November",
11 => ~"December"
}
'b' | 'h' => alt check tm.tm_mon as int {
'b' | 'h' => match check tm.tm_mon as int {
0 => ~"Jan",
1 => ~"Feb",
2 => ~"Mar",
@ -716,7 +720,7 @@ fn strftime(format: ~str, tm: tm) -> ~str {
do io::with_str_reader(format) |rdr| {
while !rdr.eof() {
alt rdr.read_char() {
match rdr.read_char() {
'%' => buf += parse_type(rdr.read_char(), tm),
ch => str::push_char(buf, ch)
}
@ -932,7 +936,7 @@ mod tests {
os::setenv(~"TZ", ~"America/Los_Angeles");
tzset();
alt strptime(~"", ~"") {
match strptime(~"", ~"") {
ok(tm) => {
assert tm.tm_sec == 0_i32;
assert tm.tm_min == 0_i32;
@ -954,7 +958,7 @@ mod tests {
assert strptime(~"Fri Feb 13 15:31:30", format)
== err(~"Invalid time");
alt strptime(~"Fri Feb 13 15:31:30 2009", format) {
match strptime(~"Fri Feb 13 15:31:30 2009", format) {
err(e) => fail e,
ok(tm) => {
assert tm.tm_sec == 30_i32;
@ -973,7 +977,7 @@ mod tests {
}
fn test(s: ~str, format: ~str) -> bool {
alt strptime(s, format) {
match strptime(s, format) {
ok(tm) => tm.strftime(format) == s,
err(e) => fail e
}

4
src/libstd/timer.rs
View file

@ -215,7 +215,7 @@ mod test {
delayed_send(hl_loop, 1u, test_ch, expected);
};
alt recv_timeout(hl_loop, 10u, test_po) {
match recv_timeout(hl_loop, 10u, test_po) {
some(val) => {
assert val == expected;
successes += 1;
@ -243,7 +243,7 @@ mod test {
delayed_send(hl_loop, 1000u, test_ch, expected);
};
alt recv_timeout(hl_loop, 1u, test_po) {
match recv_timeout(hl_loop, 1u, test_po) {
none => successes += 1,
_ => failures += 1
};

6
src/libstd/treemap.rs
View file

@ -30,7 +30,7 @@ fn treemap<K, V>() -> treemap<K, V> { @mut none }
/// Insert a value into the map
fn insert<K: copy, V: copy>(m: &mut tree_edge<K, V>, k: K, v: V) {
alt copy *m {
match copy *m {
none => {
*m = some(@tree_node({key: k,
mut value: v,
@ -52,7 +52,7 @@ fn insert<K: copy, V: copy>(m: &mut tree_edge<K, V>, k: K, v: V) {
/// Find a value based on the key
fn find<K: copy, V: copy>(m: &const tree_edge<K, V>, k: K) -> option<V> {
alt copy *m {
match copy *m {
none => none,
// FIXME (#2808): was that an optimization?
@ -70,7 +70,7 @@ fn find<K: copy, V: copy>(m: &const tree_edge<K, V>, k: K) -> option<V> {
/// Visit all pairs in the map in order.
fn traverse<K, V: copy>(m: &const tree_edge<K, V>, f: fn(K, V)) {
alt copy *m {
match copy *m {
none => (),
some(node) => {
traverse(&const node.left, f);

2
src/libstd/uv_global_loop.rs
View file

@ -56,7 +56,7 @@ fn get_monitor_task_gl() -> iotask unsafe {
let hl_loop = spawn_loop();
loop {
debug!{"in outer_loop..."};
alt select2(weak_exit_po, msg_po) {
match select2(weak_exit_po, msg_po) {
left(weak_exit) => {
// all normal tasks have ended, tell the
// libuv loop to tear_down, then exit

2
src/libstd/uv_iotask.rs
View file

@ -144,7 +144,7 @@ extern fn wake_up_cb(async_handle: *ll::uv_async_t,
let msg_po = (*data).msg_po;
while msg_po.peek() {
alt msg_po.recv() {
match msg_po.recv() {
interaction(cb) => cb(loop_ptr),
teardown_loop => begin_teardown(data)
}

2
src/libstd/uv_ll.rs
View file

@ -848,7 +848,7 @@ unsafe fn ip6_name(src: &sockaddr_in6) -> ~str {
src_unsafe_ptr, src});
let result = rustrt::rust_uv_ip6_name(src_unsafe_ptr,
dst_buf, size as libc::size_t);
alt result {
match result {
0i32 => str::unsafe::from_buf(dst_buf),
_ => ~""
}

2
src/libsyntax/ast.rs
View file

@ -193,7 +193,7 @@ enum vstore {
}
pure fn is_blockish(p: ast::proto) -> bool {
alt p {
match p {
proto_block => true,
proto_bare | proto_uniq | proto_box => false
}

20
src/libsyntax/ast_map.rs
View file

@ -12,7 +12,7 @@ type path = ~[path_elt];
/* FIXMEs that say "bad" are as per #2543 */
fn path_to_str_with_sep(p: path, sep: ~str) -> ~str {
let strs = do vec::map(p) |e| {
alt e {
match e {
path_mod(s) => /* FIXME (#2543) */ copy *s,
path_name(s) => /* FIXME (#2543) */ copy *s
}
@ -104,7 +104,7 @@ fn map_decoded_item(diag: span_handler,
// methods get added to the AST map when their impl is visited. Since we
// don't decode and instantiate the impl, but just the method, we have to
// add it to the table now:
alt ii {
match ii {
ii_item(*) | ii_ctor(*) | ii_dtor(*) => { /* fallthrough */ }
ii_foreign(i) => {
cx.map.insert(i.id, node_foreign_item(i, foreign_abi_rust_intrinsic,
@ -127,7 +127,7 @@ fn map_fn(fk: visit::fn_kind, decl: fn_decl, body: blk,
copy a, cx.local_id));
cx.local_id += 1u;
}
alt fk {
match fk {
visit::fk_ctor(nm, attrs, tps, self_id, parent_id) => {
let ct = @{node: {id: id,
attrs: attrs,
@ -159,7 +159,7 @@ fn map_block(b: blk, cx: ctx, v: vt) {
fn number_pat(cx: ctx, pat: @pat) {
do ast_util::walk_pat(pat) |p| {
alt p.node {
match p.node {
pat_ident(*) => {
cx.map.insert(p.id, node_local(cx.local_id));
cx.local_id += 1u;
@ -189,7 +189,7 @@ fn map_method(impl_did: def_id, impl_path: @path,
fn map_item(i: @item, cx: ctx, v: vt) {
let item_path = @/* FIXME (#2543) */ copy cx.path;
cx.map.insert(i.id, node_item(i, item_path));
alt i.node {
match i.node {
item_impl(_, opt_ir, _, ms) => {
let impl_did = ast_util::local_def(i.id);
for ms.each |m| {
@ -205,7 +205,7 @@ fn map_item(i: @item, cx: ctx, v: vt) {
}
}
item_foreign_mod(nm) => {
let abi = alt attr::foreign_abi(i.attrs) {
let abi = match attr::foreign_abi(i.attrs) {
either::left(msg) => cx.diag.span_fatal(i.span, msg),
either::right(abi) => abi
};
@ -248,7 +248,7 @@ fn map_item(i: @item, cx: ctx, v: vt) {
}
_ => ()
}
alt i.node {
match i.node {
item_mod(_) | item_foreign_mod(_) => {
vec::push(cx.path, path_mod(i.ident));
}
@ -259,9 +259,9 @@ fn map_item(i: @item, cx: ctx, v: vt) {
}
fn map_view_item(vi: @view_item, cx: ctx, _v: vt) {
alt vi.node {
match vi.node {
view_item_export(vps) => for vps.each |vp| {
let (id, name) = alt vp.node {
let (id, name) = match vp.node {
view_path_simple(nm, _, id) => {
(id, /* FIXME (#2543) */ copy nm)
}
@ -281,7 +281,7 @@ fn map_expr(ex: @expr, cx: ctx, v: vt) {
}
fn node_id_to_str(map: map, id: node_id) -> ~str {
alt map.find(id) {
match map.find(id) {
none => {
fmt!{"unknown node (id=%d)", id}
}

80
src/libsyntax/ast_util.rs
View file

@ -35,7 +35,7 @@ pure fn local_def(id: node_id) -> def_id { {crate: local_crate, node: id} }
pure fn is_local(did: ast::def_id) -> bool { did.crate == local_crate }
pure fn stmt_id(s: stmt) -> node_id {
alt s.node {
match s.node {
stmt_decl(_, id) => id,
stmt_expr(_, id) => id,
stmt_semi(_, id) => id
@ -43,7 +43,7 @@ pure fn stmt_id(s: stmt) -> node_id {
}
fn variant_def_ids(d: def) -> {enm: def_id, var: def_id} {
alt d {
match d {
def_variant(enum_id, var_id) => {
return {enm: enum_id, var: var_id}
}
@ -52,7 +52,7 @@ fn variant_def_ids(d: def) -> {enm: def_id, var: def_id} {
}
pure fn def_id_of_def(d: def) -> def_id {
alt d {
match d {
def_fn(id, _) | def_mod(id) |
def_foreign_mod(id) | def_const(id) |
def_variant(_, id) | def_ty(id) | def_ty_param(id, _) |
@ -70,7 +70,7 @@ pure fn def_id_of_def(d: def) -> def_id {
}
pure fn binop_to_str(op: binop) -> ~str {
alt op {
match op {
add => return ~"+",
subtract => return ~"-",
mul => return ~"*",
@ -93,7 +93,7 @@ pure fn binop_to_str(op: binop) -> ~str {
}
pure fn binop_to_method_name(op: binop) -> option<~str> {
alt op {
match op {
add => return some(~"add"),
subtract => return some(~"sub"),
mul => return some(~"mul"),
@ -109,7 +109,7 @@ pure fn binop_to_method_name(op: binop) -> option<~str> {
}
pure fn lazy_binop(b: binop) -> bool {
alt b {
match b {
and => true,
or => true,
_ => false
@ -117,7 +117,7 @@ pure fn lazy_binop(b: binop) -> bool {
}
pure fn is_shift_binop(b: binop) -> bool {
alt b {
match b {
shl => true,
shr => true,
_ => false
@ -125,7 +125,7 @@ pure fn is_shift_binop(b: binop) -> bool {
}
pure fn unop_to_str(op: unop) -> ~str {
alt op {
match op {
box(mt) => if mt == m_mutbl { ~"@mut " } else { ~"@" },
uniq(mt) => if mt == m_mutbl { ~"~mut " } else { ~"~" },
deref => ~"*",
@ -135,11 +135,11 @@ pure fn unop_to_str(op: unop) -> ~str {
}
pure fn is_path(e: @expr) -> bool {
return alt e.node { expr_path(_) => true, _ => false };
return match e.node { expr_path(_) => true, _ => false };
}
pure fn int_ty_to_str(t: int_ty) -> ~str {
alt t {
match t {
ty_char => ~"u8", // ???
ty_i => ~"",
ty_i8 => ~"i8",
@ -150,7 +150,7 @@ pure fn int_ty_to_str(t: int_ty) -> ~str {
}
pure fn int_ty_max(t: int_ty) -> u64 {
alt t {
match t {
ty_i8 => 0x80u64,
ty_i16 => 0x8000u64,
ty_i | ty_char | ty_i32 => 0x80000000u64, // actually ni about ty_i
@ -159,7 +159,7 @@ pure fn int_ty_max(t: int_ty) -> u64 {
}
pure fn uint_ty_to_str(t: uint_ty) -> ~str {
alt t {
match t {
ty_u => ~"u",
ty_u8 => ~"u8",
ty_u16 => ~"u16",
@ -169,7 +169,7 @@ pure fn uint_ty_to_str(t: uint_ty) -> ~str {
}
pure fn uint_ty_max(t: uint_ty) -> u64 {
alt t {
match t {
ty_u8 => 0xffu64,
ty_u16 => 0xffffu64,
ty_u | ty_u32 => 0xffffffffu64, // actually ni about ty_u
@ -178,7 +178,7 @@ pure fn uint_ty_max(t: uint_ty) -> u64 {
}
pure fn float_ty_to_str(t: float_ty) -> ~str {
alt t { ty_f => ~"f", ty_f32 => ~"f32", ty_f64 => ~"f64" }
match t { ty_f => ~"f", ty_f32 => ~"f32", ty_f64 => ~"f64" }
}
fn is_exported(i: ident, m: _mod) -> bool {
@ -186,7 +186,7 @@ fn is_exported(i: ident, m: _mod) -> bool {
let mut parent_enum : option<ident> = none;
for m.items.each |it| {
if it.ident == i { local = true; }
alt it.node {
match it.node {
item_enum(variants, _) => for variants.each |v| {
if v.node.name == i {
local = true;
@ -199,14 +199,14 @@ fn is_exported(i: ident, m: _mod) -> bool {
}
let mut has_explicit_exports = false;
for m.view_items.each |vi| {
alt vi.node {
match vi.node {
view_item_export(vps) => {
has_explicit_exports = true;
for vps.each |vp| {
alt vp.node {
match vp.node {
ast::view_path_simple(id, _, _) => {
if id == i { return true; }
alt parent_enum {
match parent_enum {
some(parent_enum_id) => {
if id == parent_enum_id { return true; }
}
@ -240,7 +240,7 @@ fn is_exported(i: ident, m: _mod) -> bool {
}
pure fn is_call_expr(e: @expr) -> bool {
alt e.node { expr_call(_, _, _) => true, _ => false }
match e.node { expr_call(_, _, _) => true, _ => false }
}
pure fn eq_ty(a: &@ty, b: &@ty) -> bool { box::ptr_eq(*a, *b) }
@ -284,7 +284,7 @@ fn ident_to_path(s: span, +i: ident) -> @path {
}
pure fn is_unguarded(&&a: arm) -> bool {
alt a.guard {
match a.guard {
none => true,
_ => false
}
@ -295,7 +295,7 @@ pure fn unguarded_pat(a: arm) -> option<~[@pat]> {
}
pure fn class_item_ident(ci: @class_member) -> ident {
alt ci.node {
match ci.node {
instance_var(i,_,_,_,_) => /* FIXME (#2543) */ copy i,
class_method(it) => /* FIXME (#2543) */ copy it.ident
}
@ -306,7 +306,7 @@ type ivar = {ident: ident, ty: @ty, cm: class_mutability,
fn public_methods(ms: ~[@method]) -> ~[@method] {
vec::filter(ms,
|m| alt m.vis {
|m| match m.vis {
public => true,
_ => false
})
@ -315,7 +315,7 @@ fn public_methods(ms: ~[@method]) -> ~[@method] {
fn split_class_items(cs: ~[@class_member]) -> (~[ivar], ~[@method]) {
let mut vs = ~[], ms = ~[];
for cs.each |c| {
alt c.node {
match c.node {
instance_var(i, t, cm, id, vis) => {
vec::push(vs, {ident: /* FIXME (#2543) */ copy i,
ty: t,
@ -332,7 +332,7 @@ fn split_class_items(cs: ~[@class_member]) -> (~[ivar], ~[@method]) {
// extract a ty_method from a trait_method. if the trait_method is
// a default, pull out the useful fields to make a ty_method
fn trait_method_to_ty_method(method: trait_method) -> ty_method {
alt method {
match method {
required(m) => m,
provided(m) => {
{ident: m.ident, attrs: m.attrs,
@ -346,7 +346,7 @@ fn split_trait_methods(trait_methods: ~[trait_method])
-> (~[ty_method], ~[@method]) {
let mut reqd = ~[], provd = ~[];
for trait_methods.each |trt_method| {
alt trt_method {
match trt_method {
required(tm) => vec::push(reqd, tm),
provided(m) => vec::push(provd, m)
}
@ -355,7 +355,7 @@ fn split_trait_methods(trait_methods: ~[trait_method])
}
pure fn class_member_visibility(ci: @class_member) -> visibility {
alt ci.node {
match ci.node {
instance_var(_, _, _, _, vis) => vis,
class_method(m) => m.vis
}
@ -369,7 +369,7 @@ trait inlined_item_utils {
impl inlined_item_methods of inlined_item_utils for inlined_item {
fn ident() -> ident {
alt self {
match self {
ii_item(i) => /* FIXME (#2543) */ copy i.ident,
ii_foreign(i) => /* FIXME (#2543) */ copy i.ident,
ii_method(_, m) => /* FIXME (#2543) */ copy m.ident,
@ -379,7 +379,7 @@ impl inlined_item_methods of inlined_item_utils for inlined_item {
}
fn id() -> ast::node_id {
alt self {
match self {
ii_item(i) => i.id,
ii_foreign(i) => i.id,
ii_method(_, m) => m.id,
@ -389,7 +389,7 @@ impl inlined_item_methods of inlined_item_utils for inlined_item {
}
fn accept<E>(e: E, v: visit::vt<E>) {
alt self {
match self {
ii_item(i) => v.visit_item(i, e, v),
ii_foreign(i) => v.visit_foreign_item(i, e, v),
ii_method(_, m) => visit::visit_method_helper(m, e, v),
@ -406,7 +406,7 @@ impl inlined_item_methods of inlined_item_utils for inlined_item {
/* True if d is either a def_self, or a chain of def_upvars
referring to a def_self */
fn is_self(d: ast::def) -> bool {
alt d {
match d {
def_self(_) => true,
def_upvar(_, d, _) => is_self(*d),
_ => false
@ -415,7 +415,7 @@ fn is_self(d: ast::def) -> bool {
/// Maps a binary operator to its precedence
fn operator_prec(op: ast::binop) -> uint {
alt op {
match op {
mul | div | rem => 12u,
// 'as' sits between here with 11
add | subtract => 10u,
@ -455,11 +455,11 @@ fn id_visitor(vfn: fn@(node_id)) -> visit::vt<()> {
},
visit_view_item: fn@(vi: @view_item) {
alt vi.node {
match vi.node {
view_item_use(_, _, id) => vfn(id),
view_item_import(vps) | view_item_export(vps) => {
do vec::iter(vps) |vp| {
alt vp.node {
match vp.node {
view_path_simple(_, _, id) => vfn(id),
view_path_glob(_, id) => vfn(id),
view_path_list(_, _, id) => vfn(id)
@ -475,7 +475,7 @@ fn id_visitor(vfn: fn@(node_id)) -> visit::vt<()> {
visit_item: fn@(i: @item) {
vfn(i.id);
alt i.node {
match i.node {
item_enum(vs, _) => for vs.each |v| { vfn(v.node.id); }
_ => ()
}
@ -511,7 +511,7 @@ fn id_visitor(vfn: fn@(node_id)) -> visit::vt<()> {
},
visit_ty: fn@(t: @ty) {
alt t.node {
match t.node {
ty_path(_, id) => vfn(id),
_ => { /* fall through */ }
}
@ -525,7 +525,7 @@ fn id_visitor(vfn: fn@(node_id)) -> visit::vt<()> {
_b: ast::blk, _sp: span, id: ast::node_id) {
vfn(id);
alt fk {
match fk {
visit::fk_ctor(nm, _, tps, self_id, parent_id) => {
vec::iter(tps, |tp| vfn(tp.id));
vfn(id);
@ -565,7 +565,7 @@ fn id_visitor(vfn: fn@(node_id)) -> visit::vt<()> {
},
visit_class_item: fn@(c: @class_member) {
alt c.node {
match c.node {
instance_var(_, _, _, id,_) => vfn(id),
class_method(_) => ()
}
@ -592,7 +592,7 @@ fn compute_id_range_for_inlined_item(item: inlined_item) -> id_range {
}
pure fn is_item_impl(item: @ast::item) -> bool {
alt item.node {
match item.node {
item_impl(*) => true,
_ => false
}
@ -600,7 +600,7 @@ pure fn is_item_impl(item: @ast::item) -> bool {
fn walk_pat(pat: @pat, it: fn(@pat)) {
it(pat);
alt pat.node {
match pat.node {
pat_ident(_, pth, some(p)) => walk_pat(p, it),
pat_rec(fields, _) => for fields.each |f| { walk_pat(f.pat, it) }
pat_enum(_, some(s)) | pat_tup(s) => for s.each |p| {
@ -613,7 +613,7 @@ fn walk_pat(pat: @pat, it: fn(@pat)) {
}
fn view_path_id(p: @view_path) -> node_id {
alt p.node {
match p.node {
view_path_simple(_, _, id) | view_path_glob(_, id) |
view_path_list(_, _, id) => id
}

32
src/libsyntax/attr.rs
View file

@ -114,7 +114,7 @@ fn get_attr_name(attr: ast::attribute) -> ast::ident {
// All "bad" FIXME copies are as per #2543
fn get_meta_item_name(meta: @ast::meta_item) -> ast::ident {
alt meta.node {
match meta.node {
ast::meta_word(n) => /* FIXME (#2543) */ copy n,
ast::meta_name_value(n, _) => /* FIXME (#2543) */ copy n,
ast::meta_list(n, _) => /* FIXME (#2543) */ copy n
@ -126,8 +126,8 @@ fn get_meta_item_name(meta: @ast::meta_item) -> ast::ident {
* containing a string, otherwise none
*/
fn get_meta_item_value_str(meta: @ast::meta_item) -> option<@~str> {
alt meta.node {
ast::meta_name_value(_, v) => alt v.node {
match meta.node {
ast::meta_name_value(_, v) => match v.node {
ast::lit_str(s) => option::some(s),
_ => option::none
}
@ -137,7 +137,7 @@ fn get_meta_item_value_str(meta: @ast::meta_item) -> option<@~str> {
/// Gets a list of inner meta items from a list meta_item type
fn get_meta_item_list(meta: @ast::meta_item) -> option<~[@ast::meta_item]> {
alt meta.node {
match meta.node {
ast::meta_list(_, l) => option::some(/* FIXME (#2543) */ copy l),
_ => option::none
}
@ -150,7 +150,7 @@ fn get_meta_item_list(meta: @ast::meta_item) -> option<~[@ast::meta_item]> {
fn get_name_value_str_pair(
item: @ast::meta_item
) -> option<(ast::ident, @~str)> {
alt attr::get_meta_item_value_str(item) {
match attr::get_meta_item_value_str(item) {
some(value) => {
let name = attr::get_meta_item_name(item);
some((name, value))
@ -203,12 +203,12 @@ fn contains(haystack: ~[@ast::meta_item], needle: @ast::meta_item) -> bool {
}
fn eq(a: @ast::meta_item, b: @ast::meta_item) -> bool {
return alt a.node {
ast::meta_word(na) => alt b.node {
return match a.node {
ast::meta_word(na) => match b.node {
ast::meta_word(nb) => na == nb,
_ => false
}
ast::meta_name_value(na, va) => alt b.node {
ast::meta_name_value(na, va) => match b.node {
ast::meta_name_value(nb, vb) => na == nb && va.node == vb.node,
_ => false
}
@ -253,8 +253,8 @@ fn last_meta_item_value_str_by_name(
items: ~[@ast::meta_item],
+name: ~str
) -> option<@~str> {
alt last_meta_item_by_name(items, name) {
some(item) => alt attr::get_meta_item_value_str(item) {
match last_meta_item_by_name(items, name) {
some(item) => match attr::get_meta_item_value_str(item) {
some(value) => some(value),
none => none
}
@ -266,7 +266,7 @@ fn last_meta_item_list_by_name(
items: ~[@ast::meta_item],
+name: ~str
) -> option<~[@ast::meta_item]> {
alt last_meta_item_by_name(items, name) {
match last_meta_item_by_name(items, name) {
some(item) => attr::get_meta_item_list(item),
none => none
}
@ -280,7 +280,7 @@ fn last_meta_item_list_by_name(
fn sort_meta_items(+items: ~[@ast::meta_item]) -> ~[@ast::meta_item] {
pure fn lteq(ma: &@ast::meta_item, mb: &@ast::meta_item) -> bool {
pure fn key(m: &ast::meta_item) -> ast::ident {
alt m.node {
match m.node {
ast::meta_word(name) => /* FIXME (#2543) */ copy name,
ast::meta_name_value(name, _) => /* FIXME (#2543) */ copy name,
ast::meta_list(name, _) => /* FIXME (#2543) */ copy name
@ -310,7 +310,7 @@ fn remove_meta_items_by_name(items: ~[@ast::meta_item], name: ast::ident) ->
fn find_linkage_attrs(attrs: ~[ast::attribute]) -> ~[ast::attribute] {
let mut found = ~[];
for find_attrs_by_name(attrs, ~"link").each |attr| {
alt attr.node.value.node {
match attr.node.value.node {
ast::meta_list(_, _) => vec::push(found, attr),
_ => debug!{"ignoring link attribute that has incorrect type"}
}
@ -324,14 +324,14 @@ fn find_linkage_attrs(attrs: ~[ast::attribute]) -> ~[ast::attribute] {
*/
fn find_linkage_metas(attrs: ~[ast::attribute]) -> ~[@ast::meta_item] {
do find_linkage_attrs(attrs).flat_map |attr| {
alt check attr.node.value.node {
match check attr.node.value.node {
ast::meta_list(_, items) => /* FIXME (#2543) */ copy items
}
}
}
fn foreign_abi(attrs: ~[ast::attribute]) -> either<~str, ast::foreign_abi> {
return alt attr::first_attr_value_str_by_name(attrs, ~"abi") {
return match attr::first_attr_value_str_by_name(attrs, ~"abi") {
option::none => {
either::right(ast::foreign_abi_cdecl)
}
@ -361,7 +361,7 @@ enum inline_attr {
fn find_inline_attr(attrs: ~[ast::attribute]) -> inline_attr {
// FIXME (#2809)---validate the usage of #[inline] and #[inline(always)]
do vec::foldl(ia_none, attrs) |ia,attr| {
alt attr.node.value.node {
match attr.node.value.node {
ast::meta_word(@~"inline") => ia_hint,
ast::meta_list(@~"inline", items) => {
if !vec::is_empty(find_meta_items_by_name(items, ~"always")) {

6
src/libsyntax/codemap.rs
View file

@ -124,7 +124,7 @@ fn lookup_char_pos_adj(map: codemap, pos: uint)
-> {filename: ~str, line: uint, col: uint, file: option<filemap>}
{
let loc = lookup_char_pos(map, pos);
alt (loc.file.substr) {
match (loc.file.substr) {
fss_none => {
{filename: /* FIXME (#2543) */ copy loc.file.name,
line: loc.line,
@ -146,7 +146,7 @@ fn lookup_char_pos_adj(map: codemap, pos: uint)
fn adjust_span(map: codemap, sp: span) -> span {
pure fn lookup(pos: file_pos) -> uint { return pos.ch; }
let line = lookup_line(map, sp.lo, lookup);
alt (line.fm.substr) {
match (line.fm.substr) {
fss_none => sp,
fss_internal(s) => {
adjust_span(map, {lo: s.lo + (sp.lo - line.fm.start_pos.ch),
@ -196,7 +196,7 @@ fn span_to_lines(sp: span, cm: codemap::codemap) -> @file_lines {
fn get_line(fm: filemap, line: int) -> ~str unsafe {
let begin: uint = fm.lines[line].byte - fm.start_pos.byte;
let end = alt str::find_char_from(*fm.src, '\n', begin) {
let end = match str::find_char_from(*fm.src, '\n', begin) {
some(e) => e,
none => str::len(*fm.src)
};

12
src/libsyntax/diagnostic.rs
View file

@ -87,7 +87,7 @@ impl codemap_handler of handler for handler_t {
fn has_errors() -> bool { self.err_count > 0u }
fn abort_if_errors() {
let s;
alt self.err_count {
match self.err_count {
0u => return,
1u => s = ~"aborting due to previous error",
_ => {
@ -122,7 +122,7 @@ fn mk_span_handler(handler: handler, cm: codemap::codemap) -> span_handler {
fn mk_handler(emitter: option<emitter>) -> handler {
let emit = alt emitter {
let emit = match emitter {
some(e) => e,
none => {
let f = fn@(cmsp: option<(codemap::codemap, span)>,
@ -147,7 +147,7 @@ enum level {
}
fn diagnosticstr(lvl: level) -> ~str {
alt lvl {
match lvl {
fatal => ~"error",
error => ~"error",
warning => ~"warning",
@ -156,7 +156,7 @@ fn diagnosticstr(lvl: level) -> ~str {
}
fn diagnosticcolor(lvl: level) -> u8 {
alt lvl {
match lvl {
fatal => term::color_bright_red,
error => term::color_bright_red,
warning => term::color_bright_yellow,
@ -182,7 +182,7 @@ fn print_diagnostic(topic: ~str, lvl: level, msg: ~str) {
fn emit(cmsp: option<(codemap::codemap, span)>,
msg: ~str, lvl: level) {
alt cmsp {
match cmsp {
some((cm, sp)) => {
let sp = codemap::adjust_span(cm,sp);
let ss = codemap::span_to_str(sp, cm);
@ -266,7 +266,7 @@ fn print_macro_backtrace(cm: codemap::codemap, sp: span) {
fn expect<T: copy>(diag: span_handler,
opt: option<T>, msg: fn() -> ~str) -> T {
alt opt {
match opt {
some(t) => t,
none => diag.handler().bug(msg())
}

14
src/libsyntax/ext/auto_serialize.rs
View file

@ -101,7 +101,7 @@ fn expand(cx: ext_ctxt,
}
do vec::flat_map(in_items) |in_item| {
alt in_item.node {
match in_item.node {
ast::item_ty(ty, tps) => {
vec::append(~[filter_attrs(in_item)],
ty_fns(cx, in_item.ident, ty, tps))
@ -375,7 +375,7 @@ fn ser_lambda(cx: ext_ctxt, tps: ser_tps_map, ty: @ast::ty,
}
fn is_vec_or_str(ty: @ast::ty) -> bool {
alt ty.node {
match ty.node {
ast::ty_vec(_) => true,
// This may be wrong if the user has shadowed (!) str
ast::ty_path(@{span: _, global: _, idents: ids,
@ -391,7 +391,7 @@ fn ser_ty(cx: ext_ctxt, tps: ser_tps_map,
let ext_cx = cx; // required for #ast{}
alt ty.node {
match ty.node {
ast::ty_nil => {
~[#ast[stmt]{$(s).emit_nil()}]
}
@ -447,7 +447,7 @@ fn ser_ty(cx: ext_ctxt, tps: ser_tps_map,
ast::ty_tup(tys) => {
// Generate code like
//
// alt v {
// match v {
// (v1, v2, v3) {
// .. serialize v1, v2, v3 ..
// }
@ -483,7 +483,7 @@ fn ser_ty(cx: ext_ctxt, tps: ser_tps_map,
vec::is_empty(path.types) {
let ident = path.idents[0];
alt tps.find(*ident) {
match tps.find(*ident) {
some(f) => f(v),
none => ser_path(cx, tps, path, s, v)
}
@ -634,7 +634,7 @@ fn deser_ty(cx: ext_ctxt, tps: deser_tps_map,
let ext_cx = cx; // required for #ast{}
alt ty.node {
match ty.node {
ast::ty_nil => {
#ast{ $(d).read_nil() }
}
@ -709,7 +709,7 @@ fn deser_ty(cx: ext_ctxt, tps: deser_tps_map,
vec::is_empty(path.types) {
let ident = path.idents[0];
alt tps.find(*ident) {
match tps.find(*ident) {
some(f) => f(),
none => deser_path(cx, tps, path, d)
}

22
src/libsyntax/ext/base.rs
View file

@ -150,7 +150,7 @@ fn mk_ctxt(parse_sess: parse::parse_sess,
fn mod_pop() { vec::pop(self.mod_path); }
fn mod_path() -> ~[ast::ident] { return self.mod_path; }
fn bt_push(ei: codemap::expn_info_) {
alt ei {
match ei {
expanded_from({call_site: cs, callie: callie}) => {
self.backtrace =
some(@expanded_from({
@ -161,7 +161,7 @@ fn mk_ctxt(parse_sess: parse::parse_sess,
}
}
fn bt_pop() {
alt self.backtrace {
match self.backtrace {
some(@expanded_from({call_site: {expn_info: prev, _}, _})) => {
self.backtrace = prev
}
@ -206,8 +206,8 @@ fn mk_ctxt(parse_sess: parse::parse_sess,
}
fn expr_to_str(cx: ext_ctxt, expr: @ast::expr, error: ~str) -> ~str {
alt expr.node {
ast::expr_lit(l) => alt l.node {
match expr.node {
ast::expr_lit(l) => match l.node {
ast::lit_str(s) => return *s,
_ => cx.span_fatal(l.span, error)
}
@ -216,7 +216,7 @@ fn expr_to_str(cx: ext_ctxt, expr: @ast::expr, error: ~str) -> ~str {
}
fn expr_to_ident(cx: ext_ctxt, expr: @ast::expr, error: ~str) -> ast::ident {
alt expr.node {
match expr.node {
ast::expr_path(p) => {
if vec::len(p.types) > 0u || vec::len(p.idents) != 1u {
cx.span_fatal(expr.span, error);
@ -233,11 +233,11 @@ fn get_mac_args_no_max(cx: ext_ctxt, sp: span, arg: ast::mac_arg,
fn get_mac_args(cx: ext_ctxt, sp: span, arg: ast::mac_arg,
min: uint, max: option<uint>, name: ~str) -> ~[@ast::expr] {
alt arg {
some(expr) => alt expr.node {
match arg {
some(expr) => match expr.node {
ast::expr_vec(elts, _) => {
let elts_len = vec::len(elts);
alt max {
match max {
some(max) if ! (min <= elts_len && elts_len <= max) => {
cx.span_fatal(sp,
fmt!{"#%s takes between %u and %u arguments.",
@ -261,7 +261,7 @@ fn get_mac_args(cx: ext_ctxt, sp: span, arg: ast::mac_arg,
fn get_mac_body(cx: ext_ctxt, sp: span, args: ast::mac_body)
-> ast::mac_body_
{
alt (args) {
match (args) {
some(body) => body,
none => cx.span_fatal(sp, ~"missing macro body")
}
@ -289,10 +289,10 @@ fn tt_args_to_original_flavor(cx: ext_ctxt, sp: span, arg: ~[ast::token_tree])
let arg_reader = new_tt_reader(cx.parse_sess().span_diagnostic,
cx.parse_sess().interner, none, arg);
let args =
alt parse_or_else(cx.parse_sess(), cx.cfg(), arg_reader as reader,
match parse_or_else(cx.parse_sess(), cx.cfg(), arg_reader as reader,
argument_gram).get(@~"arg") {
@matched_seq(s, _) => do s.map() |lf| {
alt lf {
match lf {
@matched_nonterminal(parse::token::nt_expr(arg)) => {
arg /* whew! list of exprs, here we come! */
}

2
src/libsyntax/ext/env.rs
View file

@ -16,7 +16,7 @@ fn expand_syntax_ext(cx: ext_ctxt, sp: codemap::span, arg: ast::mac_arg,
// option<str> rather than just an maybe-empty string.
let var = expr_to_str(cx, args[0], ~"#env requires a string");
alt os::getenv(var) {
match os::getenv(var) {
option::none => return mk_uniq_str(cx, sp, ~""),
option::some(s) => return mk_uniq_str(cx, sp, s)
}

26
src/libsyntax/ext/expand.rs
View file

@ -15,18 +15,18 @@ fn expand_expr(exts: hashmap<~str, syntax_extension>, cx: ext_ctxt,
orig: fn@(expr_, span, ast_fold) -> (expr_, span))
-> (expr_, span)
{
return alt e {
return match e {
// expr_mac should really be expr_ext or something; it's the
// entry-point for all syntax extensions.
expr_mac(mac) => {
// Old-style macros, for compatibility, will erase this whole
// block once we've transitioned.
alt mac.node {
match mac.node {
mac_invoc(pth, args, body) => {
assert (vec::len(pth.idents) > 0u);
let extname = pth.idents[0];
alt exts.find(*extname) {
match exts.find(*extname) {
none => {
cx.span_fatal(pth.span,
fmt!{"macro undefined: '%s'", *extname})
@ -69,13 +69,13 @@ fn expand_expr(exts: hashmap<~str, syntax_extension>, cx: ext_ctxt,
mac_invoc_tt(pth, tts) => {
assert (vec::len(pth.idents) == 1u);
let extname = pth.idents[0];
alt exts.find(*extname) {
match exts.find(*extname) {
none => {
cx.span_fatal(pth.span,
fmt!{"macro undefined: '%s'", *extname})
}
some(expr_tt({expander: exp, span: exp_sp})) => {
let expanded = alt exp(cx, mac.span, tts) {
let expanded = match exp(cx, mac.span, tts) {
mr_expr(e) => e,
_ => cx.span_fatal(
pth.span, fmt!{"non-expr macro in expr pos: %s",
@ -141,12 +141,12 @@ fn expand_mod_items(exts: hashmap<~str, syntax_extension>, cx: ext_ctxt,
// the item into a new set of items.
let new_items = do vec::flat_map(module_.items) |item| {
do vec::foldr(item.attrs, ~[item]) |attr, items| {
let mname = alt attr.node.value.node {
let mname = match attr.node.value.node {
ast::meta_word(n) => n,
ast::meta_name_value(n, _) => n,
ast::meta_list(n, _) => n
};
alt exts.find(*mname) {
match exts.find(*mname) {
none | some(normal(_)) | some(macro_defining(_))
| some(expr_tt(_)) | some(item_tt(*)) => items,
some(item_decorator(dec_fn)) => {
@ -166,16 +166,16 @@ fn expand_item(exts: hashmap<~str, syntax_extension>,
orig: fn@(&&@ast::item, ast_fold) -> option<@ast::item>)
-> option<@ast::item>
{
let is_mod = alt it.node {
let is_mod = match it.node {
ast::item_mod(_) | ast::item_foreign_mod(_) => true,
_ => false
};
let maybe_it = alt it.node {
let maybe_it = match it.node {
ast::item_mac(*) => expand_item_mac(exts, cx, it, fld),
_ => some(it)
};
alt maybe_it {
match maybe_it {
some(it) => {
if is_mod { cx.mod_push(it.ident); }
let ret_val = orig(it, fld);
@ -192,10 +192,10 @@ fn expand_item(exts: hashmap<~str, syntax_extension>,
fn expand_item_mac(exts: hashmap<~str, syntax_extension>,
cx: ext_ctxt, &&it: @ast::item,
fld: ast_fold) -> option<@ast::item> {
alt it.node {
match it.node {
item_mac({node: mac_invoc_tt(pth, tts), span}) => {
let extname = pth.idents[0];
alt exts.find(*extname) {
match exts.find(*extname) {
none => {
cx.span_fatal(pth.span,
fmt!{"macro undefined: '%s'", *extname})
@ -205,7 +205,7 @@ fn expand_item_mac(exts: hashmap<~str, syntax_extension>,
cx.bt_push(expanded_from({call_site: it.span,
callie: {name: *extname,
span: expand.span}}));
let maybe_it = alt expanded {
let maybe_it = match expanded {
mr_item(it) => fld.fold_item(it),
mr_expr(e) => cx.span_fatal(pth.span,
~"expr macro in item position: " +

40
src/libsyntax/ext/fmt.rs
View file

@ -52,7 +52,7 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span,
fn make_flags(cx: ext_ctxt, sp: span, flags: ~[flag]) -> @ast::expr {
let mut tmp_expr = make_rt_path_expr(cx, sp, @~"flag_none");
for flags.each |f| {
let fstr = alt f {
let fstr = match f {
flag_left_justify => ~"flag_left_justify",
flag_left_zero_pad => ~"flag_left_zero_pad",
flag_space_for_sign => ~"flag_space_for_sign",
@ -65,7 +65,7 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span,
return tmp_expr;
}
fn make_count(cx: ext_ctxt, sp: span, cnt: count) -> @ast::expr {
alt cnt {
match cnt {
count_implied => {
return make_rt_path_expr(cx, sp, @~"count_implied");
}
@ -80,8 +80,8 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span,
}
fn make_ty(cx: ext_ctxt, sp: span, t: ty) -> @ast::expr {
let mut rt_type;
alt t {
ty_hex(c) => alt c {
match t {
ty_hex(c) => match c {
case_upper => rt_type = ~"ty_hex_upper",
case_lower => rt_type = ~"ty_hex_lower"
}
@ -121,8 +121,8 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span,
// FIXME: Move validation code into core::extfmt (Issue #2249)
fn is_signed_type(cnv: conv) -> bool {
alt cnv.ty {
ty_int(s) => alt s {
match cnv.ty {
ty_int(s) => match s {
signed => return true,
unsigned => return false
}
@ -131,12 +131,12 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span,
}
}
let unsupported = ~"conversion not supported in #fmt string";
alt cnv.param {
match cnv.param {
option::none => (),
_ => cx.span_unimpl(sp, unsupported)
}
for cnv.flags.each |f| {
alt f {
match f {
flag_left_justify => (),
flag_sign_always => {
if !is_signed_type(cnv) {
@ -156,19 +156,19 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span,
_ => cx.span_unimpl(sp, unsupported)
}
}
alt cnv.width {
match cnv.width {
count_implied => (),
count_is(_) => (),
_ => cx.span_unimpl(sp, unsupported)
}
alt cnv.precision {
match cnv.precision {
count_implied => (),
count_is(_) => (),
_ => cx.span_unimpl(sp, unsupported)
}
alt cnv.ty {
match cnv.ty {
ty_str => return make_conv_call(cx, arg.span, ~"str", cnv, arg),
ty_int(sign) => alt sign {
ty_int(sign) => match sign {
signed => return make_conv_call(cx, arg.span, ~"int", cnv, arg),
unsigned => {
return make_conv_call(cx, arg.span, ~"uint", cnv, arg)
@ -188,12 +188,12 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span,
}
}
fn log_conv(c: conv) {
alt c.param {
match c.param {
some(p) => { log(debug, ~"param: " + int::to_str(p, 10u)); }
_ => debug!{"param: none"}
}
for c.flags.each |f| {
alt f {
match f {
flag_left_justify => debug!{"flag: left justify"},
flag_left_zero_pad => debug!{"flag: left zero pad"},
flag_space_for_sign => debug!{"flag: left space pad"},
@ -201,7 +201,7 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span,
flag_alternate => debug!{"flag: alternate"}
}
}
alt c.width {
match c.width {
count_is(i) => log(
debug, ~"width: count is " + int::to_str(i, 10u)),
count_is_param(i) => log(
@ -209,7 +209,7 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span,
count_is_next_param => debug!{"width: count is next param"},
count_implied => debug!{"width: count is implied"}
}
alt c.precision {
match c.precision {
count_is(i) => log(
debug, ~"prec: count is " + int::to_str(i, 10u)),
count_is_param(i) => log(
@ -217,16 +217,16 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span,
count_is_next_param => debug!{"prec: count is next param"},
count_implied => debug!{"prec: count is implied"}
}
alt c.ty {
match c.ty {
ty_bool => debug!{"type: bool"},
ty_str => debug!{"type: str"},
ty_char => debug!{"type: char"},
ty_int(s) => alt s {
ty_int(s) => match s {
signed => debug!{"type: signed"},
unsigned => debug!{"type: unsigned"}
}
ty_bits => debug!{"type: bits"},
ty_hex(cs) => alt cs {
ty_hex(cs) => match cs {
case_upper => debug!{"type: uhex"},
case_lower => debug!{"type: lhex"},
}
@ -240,7 +240,7 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span,
let mut piece_exprs = ~[];
let nargs = args.len();
for pieces.each |pc| {
alt pc {
match pc {
piece_string(s) => {
vec::push(piece_exprs, mk_uniq_str(cx, fmt_sp, s))
}

2
src/libsyntax/ext/pipes/check.rs
View file

@ -44,7 +44,7 @@ impl proto_check of proto::visitor<(), (), ()> for ext_ctxt {
fn visit_message(name: ident, _span: span, _tys: &[@ast::ty],
this: state, next: next_state) {
alt next {
match next {
some({state: next, tys: next_tys}) => {
let proto = this.proto;
if !proto.has_state(next) {

6
src/libsyntax/ext/pipes/parse_proto.rs
View file

@ -25,12 +25,12 @@ impl proto_parser of proto_parser for parser {
fn parse_state(proto: protocol) {
let id = self.parse_ident();
self.expect(token::COLON);
let dir = alt copy self.token {
let dir = match copy self.token {
token::IDENT(n, _) => self.get_str(n),
_ => fail
};
self.bump();
let dir = alt dir {
let dir = match dir {
@~"send" => send,
@~"recv" => recv,
_ => fail
@ -64,7 +64,7 @@ impl proto_parser of proto_parser for parser {
self.expect(token::RARROW);
let next = alt copy self.token {
let next = match copy self.token {
token::IDENT(_, _) => {
let name = self.parse_ident();
let ntys = if self.token == token::LT {

22
src/libsyntax/ext/pipes/pipec.rs
View file

@ -47,7 +47,7 @@ trait gen_init {
impl compile of gen_send for message {
fn gen_send(cx: ext_ctxt) -> @ast::item {
debug!{"pipec: gen_send"};
alt self {
match self {
message(id, span, tys, this,
some({state: next, tys: next_tys})) => {
debug!{"pipec: next state exists"};
@ -71,7 +71,7 @@ impl compile of gen_send for message {
let mut body = ~"{\n";
if this.proto.is_bounded() {
let (sp, rp) = alt (this.dir, next.dir) {
let (sp, rp) = match (this.dir, next.dir) {
(send, send) => (~"c", ~"s"),
(send, recv) => (~"s", ~"c"),
(recv, send) => (~"s", ~"c"),
@ -87,7 +87,7 @@ impl compile of gen_send for message {
rp, *next.name};
}
else {
let pat = alt (this.dir, next.dir) {
let pat = match (this.dir, next.dir) {
(send, send) => ~"(c, s)",
(send, recv) => ~"(s, c)",
(recv, send) => ~"(s, c)",
@ -181,12 +181,12 @@ impl compile of to_type_decls for state {
for self.messages.each |m| {
let message(name, _span, tys, this, next) = m;
let tys = alt next {
let tys = match next {
some({state: next, tys: next_tys}) => {
let next = this.proto.get_state(next);
let next_name = next.data_name();
let dir = alt this.dir {
let dir = match this.dir {
send => @~"server",
recv => @~"client"
};
@ -208,7 +208,7 @@ impl compile of to_type_decls for state {
fn to_endpoint_decls(cx: ext_ctxt, dir: direction) -> ~[@ast::item] {
debug!{"pipec: to_endpoint_decls"};
let dir = alt dir {
let dir = match dir {
send => (*self).dir,
recv => (*self).dir.reverse()
};
@ -255,7 +255,7 @@ impl compile of gen_init for protocol {
let start_state = self.states[0];
let body = if !self.is_bounded() {
alt start_state.dir {
match start_state.dir {
send => #ast { pipes::entangle() },
recv => {
#ast {{
@ -267,7 +267,7 @@ impl compile of gen_init for protocol {
}
else {
let body = self.gen_init_bounded(ext_cx);
alt start_state.dir {
match start_state.dir {
send => body,
recv => {
#ast {{
@ -322,7 +322,7 @@ impl compile of gen_init for protocol {
let mut params: ~[ast::ty_param] = ~[];
for (copy self.states).each |s| {
for s.ty_params.each |tp| {
alt params.find(|tpp| *tp.ident == *tpp.ident) {
match params.find(|tpp| *tp.ident == *tpp.ident) {
none => vec::push(params, tp),
_ => ()
}
@ -338,7 +338,7 @@ impl compile of gen_init for protocol {
let mut params: ~[ast::ty_param] = ~[];
let fields = do (copy self.states).map_to_vec |s| {
for s.ty_params.each |tp| {
alt params.find(|tpp| *tp.ident == *tpp.ident) {
match params.find(|tpp| *tp.ident == *tpp.ident) {
none => vec::push(params, tp),
_ => ()
}
@ -439,7 +439,7 @@ impl parse_utils of ext_ctxt_parse_utils for ext_ctxt {
self.cfg(),
~[],
self.parse_sess());
alt res {
match res {
some(ast) => ast,
none => {
error!{"Parse error with ```\n%s\n```", s};

12
src/libsyntax/ext/pipes/proto.rs
View file

@ -11,7 +11,7 @@ enum direction {
impl of to_str for direction {
fn to_str() -> ~str {
alt self {
match self {
send => ~"send",
recv => ~"recv"
}
@ -20,7 +20,7 @@ impl of to_str for direction {
impl methods for direction {
fn reverse() -> direction {
alt self {
match self {
send => recv,
recv => send
}
@ -36,20 +36,20 @@ enum message {
impl methods for message {
fn name() -> ident {
alt self {
match self {
message(id, _, _, _, _) => id
}
}
fn span() -> span {
alt self {
match self {
message(_, span, _, _, _) => span
}
}
/// Return the type parameters actually used by this message
fn get_params() -> ~[ast::ty_param] {
alt self {
match self {
message(_, _, _, this, _) => this.ty_params
}
}
@ -92,7 +92,7 @@ impl methods for state {
/// from this state.
fn reachable(f: fn(state) -> bool) {
for self.messages.each |m| {
alt m {
match m {
message(_, _, _, _, some({state: id, _})) => {
let state = self.proto.get_state(id);
if !f(state) { break }

24
src/libsyntax/ext/qquote.rs
View file

@ -48,7 +48,7 @@ impl of qq_helper for @ast::expr {
fn span() -> span {self.span}
fn visit(cx: aq_ctxt, v: vt<aq_ctxt>) {visit_expr(self, cx, v);}
fn extract_mac() -> option<ast::mac_> {
alt (self.node) {
match (self.node) {
ast::expr_mac({node: mac, _}) => some(mac),
_ => none
}
@ -63,7 +63,7 @@ impl of qq_helper for @ast::ty {
fn span() -> span {self.span}
fn visit(cx: aq_ctxt, v: vt<aq_ctxt>) {visit_ty(self, cx, v);}
fn extract_mac() -> option<ast::mac_> {
alt (self.node) {
match (self.node) {
ast::ty_mac({node: mac, _}) => some(mac),
_ => none
}
@ -124,7 +124,7 @@ fn gather_anti_quotes<N: qq_helper>(lo: uint, node: N) -> aq_ctxt
fn visit_aq<T:qq_helper>(node: T, constr: ~str, &&cx: aq_ctxt, v: vt<aq_ctxt>)
{
alt (node.extract_mac()) {
match (node.extract_mac()) {
some(mac_aq(sp, e)) => {
cx.gather.push(gather_item {
lo: sp.lo - cx.lo,
@ -147,7 +147,7 @@ fn expand_ast(ecx: ext_ctxt, _sp: span,
let mut what = ~"expr";
do option::iter(arg) |arg| {
let args: ~[@ast::expr] =
alt arg.node {
match arg.node {
ast::expr_vec(elts, _) => elts,
_ => {
ecx.span_fatal
@ -157,7 +157,7 @@ fn expand_ast(ecx: ext_ctxt, _sp: span,
if vec::len::<@ast::expr>(args) != 1u {
ecx.span_fatal(_sp, ~"#ast requires exactly one arg");
}
alt (args[0].node) {
match (args[0].node) {
ast::expr_path(@{idents: id, _}) if vec::len(id) == 1u
=> what = *id[0],
_ => ecx.span_fatal(args[0].span, ~"expected an identifier")
@ -165,7 +165,7 @@ fn expand_ast(ecx: ext_ctxt, _sp: span,
}
let body = get_mac_body(ecx,_sp,body);
return alt what {
return match what {
~"crate" => finish(ecx, body, parse_crate),
~"expr" => finish(ecx, body, parse_expr),
~"ty" => finish(ecx, body, parse_ty),
@ -183,7 +183,7 @@ fn parse_expr(p: parser) -> @ast::expr { p.parse_expr() }
fn parse_pat(p: parser) -> @ast::pat { p.parse_pat(true) }
fn parse_item(p: parser) -> @ast::item {
alt p.parse_item(~[]) {
match p.parse_item(~[]) {
some(item) => item,
none => fail ~"parse_item: parsing an item failed"
}
@ -225,7 +225,7 @@ fn finish<T: qq_helper>
state = skip(str::char_len(repl));
str2 += repl;
}
alt copy state {
match copy state {
active => str::push_char(str2, ch),
skip(1u) => state = blank,
skip(sk) => state = skip (sk-1u),
@ -308,8 +308,8 @@ fn replace_expr(repls: ~[fragment],
orig: fn@(ast::expr_, span, ast_fold)->(ast::expr_, span))
-> (ast::expr_, span)
{
alt e {
ast::expr_mac({node: mac_var(i), _}) => alt (repls[i]) {
match e {
ast::expr_mac({node: mac_var(i), _}) => match (repls[i]) {
from_expr(r) => (r.node, r.span),
_ => fail /* fixme error message */
}
@ -322,8 +322,8 @@ fn replace_ty(repls: ~[fragment],
orig: fn@(ast::ty_, span, ast_fold)->(ast::ty_, span))
-> (ast::ty_, span)
{
alt e {
ast::ty_mac({node: mac_var(i), _}) => alt (repls[i]) {
match e {
ast::ty_mac({node: mac_var(i), _}) => match (repls[i]) {
from_ty(r) => (r.node, r.span),
_ => fail /* fixme error message */
}

112
src/libsyntax/ext/simplext.rs
View file

@ -36,7 +36,7 @@ enum matchable {
/* for when given an incompatible bit of AST */
fn match_error(cx: ext_ctxt, m: matchable, expected: ~str) -> ! {
alt m {
match m {
match_expr(x) => cx.span_fatal(
x.span, ~"this argument is an expr, expected " + expected),
match_path(x) => cx.span_fatal(
@ -65,8 +65,8 @@ fn elts_to_ell(cx: ext_ctxt, elts: ~[@expr]) ->
let mut idx: uint = 0u;
let mut res = none;
for elts.each |elt| {
alt elt.node {
expr_mac(m) => alt m.node {
match elt.node {
expr_mac(m) => match m.node {
ast::mac_ellipsis => {
if res != none {
cx.span_fatal(m.span, ~"only one ellipsis allowed");
@ -82,7 +82,7 @@ fn elts_to_ell(cx: ext_ctxt, elts: ~[@expr]) ->
}
idx += 1u;
}
return alt res {
return match res {
some(val) => val,
none => {pre: elts, rep: none, post: ~[]}
}
@ -92,7 +92,7 @@ fn option_flatten_map<T: copy, U: copy>(f: fn@(T) -> option<U>, v: ~[T]) ->
option<~[U]> {
let mut res = ~[];
for v.each |elem| {
alt f(elem) {
match f(elem) {
none => return none,
some(fv) => vec::push(res, fv)
}
@ -101,9 +101,9 @@ fn option_flatten_map<T: copy, U: copy>(f: fn@(T) -> option<U>, v: ~[T]) ->
}
fn a_d_map(ad: arb_depth<matchable>, f: selector) -> match_result {
alt ad {
match ad {
leaf(x) => return f(x),
seq(ads, span) => alt option_flatten_map(|x| a_d_map(x, f), *ads) {
seq(ads, span) => match option_flatten_map(|x| a_d_map(x, f), *ads) {
none => return none,
some(ts) => return some(seq(@ts, span))
}
@ -112,7 +112,7 @@ fn a_d_map(ad: arb_depth<matchable>, f: selector) -> match_result {
fn compose_sels(s1: selector, s2: selector) -> selector {
fn scomp(s1: selector, s2: selector, m: matchable) -> match_result {
return alt s1(m) {
return match s1(m) {
none => none,
some(matches) => a_d_map(matches, s2)
}
@ -156,11 +156,11 @@ fn use_selectors_to_bind(b: binders, e: @expr) -> option<bindings> {
let res = box_str_hash::<arb_depth<matchable>>();
//need to do this first, to check vec lengths.
for b.literal_ast_matchers.each |sel| {
alt sel(match_expr(e)) { none => return none, _ => () }
match sel(match_expr(e)) { none => return none, _ => () }
}
let mut never_mind: bool = false;
for b.real_binders.each |key, val| {
alt val(match_expr(e)) {
match val(match_expr(e)) {
none => never_mind = true,
some(mtc) => { res.insert(key, mtc); }
}
@ -209,7 +209,7 @@ fn follow(m: arb_depth<matchable>, idx_path: @mut ~[uint]) ->
arb_depth<matchable> {
let mut res: arb_depth<matchable> = m;
for vec::each(*idx_path) |idx| {
res = alt res {
res = match res {
leaf(_) => return res,/* end of the line */
seq(new_ms, _) => new_ms[idx]
}
@ -219,10 +219,10 @@ fn follow(m: arb_depth<matchable>, idx_path: @mut ~[uint]) ->
fn follow_for_trans(cx: ext_ctxt, mmaybe: option<arb_depth<matchable>>,
idx_path: @mut ~[uint]) -> option<matchable> {
alt mmaybe {
match mmaybe {
none => return none,
some(m) => {
return alt follow(m, idx_path) {
return match follow(m, idx_path) {
seq(_, sp) => {
cx.span_fatal(sp,
~"syntax matched under ... but not " +
@ -258,10 +258,10 @@ fn free_vars(b: bindings, e: @expr, it: fn(ident)) {
fn transcribe_exprs(cx: ext_ctxt, b: bindings, idx_path: @mut ~[uint],
recur: fn@(&&@expr) -> @expr,
exprs: ~[@expr]) -> ~[@expr] {
alt elts_to_ell(cx, exprs) {
match elts_to_ell(cx, exprs) {
{pre: pre, rep: repeat_me_maybe, post: post} => {
let mut res = vec::map(pre, recur);
alt repeat_me_maybe {
match repeat_me_maybe {
none => (),
some(repeat_me) => {
let mut repeat: option<{rep_count: uint, name: ident}> = none;
@ -269,10 +269,10 @@ fn transcribe_exprs(cx: ext_ctxt, b: bindings, idx_path: @mut ~[uint],
the leaves, which are just duplicated */
do free_vars(b, repeat_me) |fv| {
let cur_pos = follow(b.get(fv), idx_path);
alt cur_pos {
match cur_pos {
leaf(_) => (),
seq(ms, _) => {
alt repeat {
match repeat {
none => {
repeat = some({rep_count: vec::len(*ms), name: fv});
}
@ -290,7 +290,7 @@ fn transcribe_exprs(cx: ext_ctxt, b: bindings, idx_path: @mut ~[uint],
}
}
};
alt repeat {
match repeat {
none => {
cx.span_fatal(repeat_me.span,
~"'...' surrounds an expression without any" +
@ -320,7 +320,7 @@ fn transcribe_exprs(cx: ext_ctxt, b: bindings, idx_path: @mut ~[uint],
// substitute, in a position that's required to be an ident
fn transcribe_ident(cx: ext_ctxt, b: bindings, idx_path: @mut ~[uint],
&&i: ident, _fld: ast_fold) -> ident {
return alt follow_for_trans(cx, b.find(i), idx_path) {
return match follow_for_trans(cx, b.find(i), idx_path) {
some(match_ident(a_id)) => a_id.node,
some(m) => match_error(cx, m, ~"an identifier"),
none => i
@ -332,7 +332,7 @@ fn transcribe_path(cx: ext_ctxt, b: bindings, idx_path: @mut ~[uint],
p: path, _fld: ast_fold) -> path {
// Don't substitute into qualified names.
if vec::len(p.types) > 0u || vec::len(p.idents) != 1u { return p; }
alt follow_for_trans(cx, b.find(p.idents[0]), idx_path) {
match follow_for_trans(cx, b.find(p.idents[0]), idx_path) {
some(match_ident(id)) => {
{span: id.span, global: false, idents: ~[id.node],
rp: none, types: ~[]}
@ -349,13 +349,13 @@ fn transcribe_expr(cx: ext_ctxt, b: bindings, idx_path: @mut ~[uint],
orig: fn@(ast::expr_, span, ast_fold)->(ast::expr_, span))
-> (ast::expr_, span)
{
return alt e {
return match e {
expr_path(p) => {
// Don't substitute into qualified names.
if vec::len(p.types) > 0u || vec::len(p.idents) != 1u {
(e, s);
}
alt follow_for_trans(cx, b.find(p.idents[0]), idx_path) {
match follow_for_trans(cx, b.find(p.idents[0]), idx_path) {
some(match_ident(id)) => {
(expr_path(@{span: id.span,
global: false,
@ -378,11 +378,11 @@ fn transcribe_type(cx: ext_ctxt, b: bindings, idx_path: @mut ~[uint],
orig: fn@(ast::ty_, span, ast_fold) -> (ast::ty_, span))
-> (ast::ty_, span)
{
return alt t {
return match t {
ast::ty_path(pth, _) => {
alt path_to_ident(pth) {
match path_to_ident(pth) {
some(id) => {
alt follow_for_trans(cx, b.find(id), idx_path) {
match follow_for_trans(cx, b.find(id), idx_path) {
some(match_ty(ty)) => (ty.node, ty.span),
some(m) => match_error(cx, m, ~"a type"),
none => orig(t, s, fld)
@ -404,9 +404,9 @@ fn transcribe_block(cx: ext_ctxt, b: bindings, idx_path: @mut ~[uint],
orig: fn@(blk_, span, ast_fold) -> (blk_, span))
-> (blk_, span)
{
return alt block_to_ident(blk) {
return match block_to_ident(blk) {
some(id) => {
alt follow_for_trans(cx, b.find(id), idx_path) {
match follow_for_trans(cx, b.find(id), idx_path) {
some(match_block(new_blk)) => (new_blk.node, new_blk.span),
// possibly allow promotion of ident/path/expr to blocks?
@ -424,12 +424,12 @@ argument. ps accumulates instructions on navigating the tree.*/
fn p_t_s_rec(cx: ext_ctxt, m: matchable, s: selector, b: binders) {
//it might be possible to traverse only exprs, not matchables
alt m {
match m {
match_expr(e) => {
alt e.node {
match e.node {
expr_path(p_pth) => p_t_s_r_path(cx, p_pth, s, b),
expr_vec(p_elts, _) => {
alt elts_to_ell(cx, p_elts) {
match elts_to_ell(cx, p_elts) {
{pre: pre, rep: some(repeat_me), post: post} => {
p_t_s_r_length(cx, vec::len(pre) + vec::len(post), true, s,
b);
@ -459,7 +459,7 @@ fn p_t_s_rec(cx: ext_ctxt, m: matchable, s: selector, b: binders) {
_ => {
fn select(cx: ext_ctxt, m: matchable, pat: @expr) ->
match_result {
return alt m {
return match m {
match_expr(e) => {
if e == pat { some(leaf(match_exact)) } else { none }
}
@ -477,11 +477,11 @@ fn p_t_s_rec(cx: ext_ctxt, m: matchable, s: selector, b: binders) {
/* make a match more precise */
fn specialize_match(m: matchable) -> matchable {
return alt m {
return match m {
match_expr(e) => {
alt e.node {
match e.node {
expr_path(pth) => {
alt path_to_ident(pth) {
match path_to_ident(pth) {
some(id) => match_ident(respan(pth.span, id)),
none => match_path(pth)
}
@ -495,10 +495,10 @@ fn specialize_match(m: matchable) -> matchable {
/* pattern_to_selectors helper functions */
fn p_t_s_r_path(cx: ext_ctxt, p: @path, s: selector, b: binders) {
alt path_to_ident(p) {
match path_to_ident(p) {
some(p_id) => {
fn select(cx: ext_ctxt, m: matchable) -> match_result {
return alt m {
return match m {
match_expr(e) => some(leaf(specialize_match(m))),
_ => cx.bug(~"broken traversal in p_t_s_r")
}
@ -514,8 +514,8 @@ fn p_t_s_r_path(cx: ext_ctxt, p: @path, s: selector, b: binders) {
fn block_to_ident(blk: blk_) -> option<ident> {
if vec::len(blk.stmts) != 0u { return none; }
return alt blk.expr {
some(expr) => alt expr.node {
return match blk.expr {
some(expr) => match expr.node {
expr_path(pth) => path_to_ident(pth),
_ => none
}
@ -526,8 +526,8 @@ fn block_to_ident(blk: blk_) -> option<ident> {
fn p_t_s_r_mac(cx: ext_ctxt, mac: ast::mac, _s: selector, _b: binders) {
fn select_pt_1(cx: ext_ctxt, m: matchable,
fn_m: fn(ast::mac) -> match_result) -> match_result {
return alt m {
match_expr(e) => alt e.node {
return match m {
match_expr(e) => match e.node {
expr_mac(mac) => fn_m(mac),
_ => none
}
@ -537,7 +537,7 @@ fn p_t_s_r_mac(cx: ext_ctxt, mac: ast::mac, _s: selector, _b: binders) {
fn no_des(cx: ext_ctxt, sp: span, syn: ~str) -> ! {
cx.span_fatal(sp, ~"destructuring " + syn + ~" is not yet supported");
}
alt mac.node {
match mac.node {
ast::mac_ellipsis => cx.span_fatal(mac.span, ~"misused `...`"),
ast::mac_invoc(_, _, _) => no_des(cx, mac.span, ~"macro calls"),
ast::mac_invoc_tt(_, _) => no_des(cx, mac.span, ~"macro calls"),
@ -550,9 +550,9 @@ fn p_t_s_r_ellipses(cx: ext_ctxt, repeat_me: @expr, offset: uint, s: selector,
b: binders) {
fn select(cx: ext_ctxt, repeat_me: @expr, offset: uint, m: matchable) ->
match_result {
return alt m {
return match m {
match_expr(e) => {
alt e.node {
match e.node {
expr_vec(arg_elts, _) => {
let mut elts = ~[];
let mut idx = offset;
@ -580,9 +580,9 @@ fn p_t_s_r_length(cx: ext_ctxt, len: uint, at_least: bool, s: selector,
b: binders) {
fn len_select(_cx: ext_ctxt, m: matchable, at_least: bool, len: uint) ->
match_result {
return alt m {
return match m {
match_expr(e) => {
alt e.node {
match e.node {
expr_vec(arg_elts, _) => {
let actual_len = vec::len(arg_elts);
if at_least && actual_len >= len || actual_len == len {
@ -604,9 +604,9 @@ fn p_t_s_r_actual_vector(cx: ext_ctxt, elts: ~[@expr], _repeat_after: bool,
let mut idx: uint = 0u;
while idx < vec::len(elts) {
fn select(cx: ext_ctxt, m: matchable, idx: uint) -> match_result {
return alt m {
return match m {
match_expr(e) => {
alt e.node {
match e.node {
expr_vec(arg_elts, _) => {
some(leaf(match_expr(arg_elts[idx])))
}
@ -629,7 +629,7 @@ fn add_new_extension(cx: ext_ctxt, sp: span, arg: ast::mac_arg,
let mut macro_name: option<@~str> = none;
let mut clauses: ~[@clause] = ~[];
for args.each |arg| {
alt arg.node {
match arg.node {
expr_vec(elts, mutbl) => {
if vec::len(elts) != 2u {
cx.span_fatal((*arg).span,
@ -638,12 +638,12 @@ fn add_new_extension(cx: ext_ctxt, sp: span, arg: ast::mac_arg,
}
alt elts[0u].node {
match elts[0u].node {
expr_mac(mac) => {
alt mac.node {
match mac.node {
mac_invoc(pth, invoc_arg, body) => {
alt path_to_ident(pth) {
some(id) => alt macro_name {
match path_to_ident(pth) {
some(id) => match macro_name {
none => macro_name = some(id),
some(other_id) => if id != other_id {
cx.span_fatal(pth.span,
@ -654,7 +654,7 @@ fn add_new_extension(cx: ext_ctxt, sp: span, arg: ast::mac_arg,
none => cx.span_fatal(pth.span,
~"macro name must not be a path")
}
let arg = alt invoc_arg {
let arg = match invoc_arg {
some(arg) => arg,
none => cx.span_fatal(mac.span,
~"macro must have arguments")
@ -689,7 +689,7 @@ fn add_new_extension(cx: ext_ctxt, sp: span, arg: ast::mac_arg,
let ext = |a,b,c,d, move clauses| generic_extension(a,b,c,d,clauses);
return {ident:
alt macro_name {
match macro_name {
some(id) => id,
none => cx.span_fatal(sp, ~"macro definition must have " +
~"at least one clause")
@ -699,12 +699,12 @@ fn add_new_extension(cx: ext_ctxt, sp: span, arg: ast::mac_arg,
fn generic_extension(cx: ext_ctxt, sp: span, arg: ast::mac_arg,
_body: ast::mac_body,
clauses: ~[@clause]) -> @expr {
let arg = alt arg {
let arg = match arg {
some(arg) => arg,
none => cx.span_fatal(sp, ~"macro must have arguments")
};
for clauses.each |c| {
alt use_selectors_to_bind(c.params, arg) {
match use_selectors_to_bind(c.params, arg) {
some(bindings) => return transcribe(cx, bindings, c.body),
none => again
}

4
src/libsyntax/ext/source_util.rs
View file

@ -70,7 +70,7 @@ fn expand_include_str(cx: ext_ctxt, sp: codemap::span, arg: ast::mac_arg,
let file = expr_to_str(cx, args[0], ~"#include_str requires a string");
let res = io::read_whole_file_str(res_rel_file(cx, sp, file));
alt res {
match res {
result::ok(_) => { /* Continue. */ }
result::err(e) => {
cx.parse_sess().span_diagnostic.handler().fatal(e);
@ -86,7 +86,7 @@ fn expand_include_bin(cx: ext_ctxt, sp: codemap::span, arg: ast::mac_arg,
let file = expr_to_str(cx, args[0], ~"#include_bin requires a string");
alt io::read_whole_file(res_rel_file(cx, sp, file)) {
match io::read_whole_file(res_rel_file(cx, sp, file)) {
result::ok(src) => {
let u8_exprs = vec::map(src, |char: u8| {
mk_u8(cx, sp, char)

26
src/libsyntax/ext/tt/earley_parser.rs
View file

@ -31,7 +31,7 @@ enum matcher_pos_up { /* to break a circularity */
}
fn is_some(&&mpu: matcher_pos_up) -> bool {
alt mpu {
match mpu {
matcher_pos_up(none) => false,
_ => true
}
@ -48,7 +48,7 @@ type matcher_pos = ~{
};
fn copy_up(&& mpu: matcher_pos_up) -> matcher_pos {
alt mpu {
match mpu {
matcher_pos_up(some(mp)) => copy mp,
_ => fail
}
@ -56,7 +56,7 @@ fn copy_up(&& mpu: matcher_pos_up) -> matcher_pos {
fn count_names(ms: &[matcher]) -> uint {
vec::foldl(0u, ms, |ct, m| {
ct + alt m.node {
ct + match m.node {
match_tok(_) => 0u,
match_seq(more_ms, _, _, _, _) => count_names(more_ms),
match_nonterminal(_,_,_) => 1u
@ -68,7 +68,7 @@ fn initial_matcher_pos(ms: ~[matcher], sep: option<token>, lo: uint)
-> matcher_pos {
let mut match_idx_hi = 0u;
for ms.each() |elt| {
alt elt.node {
match elt.node {
match_tok(_) => (),
match_seq(_,_,_,_,hi) => {
match_idx_hi = hi; // it is monotonic...
@ -113,7 +113,7 @@ fn nameize(p_s: parse_sess, ms: ~[matcher], res: ~[@named_match])
-> hashmap<ident,@named_match> {
fn n_rec(p_s: parse_sess, m: matcher, res: ~[@named_match],
ret_val: hashmap<ident, @named_match>) {
alt m {
match m {
{node: match_tok(_), span: _} => (),
{node: match_seq(more_ms, _, _, _, _), span: _} => {
for more_ms.each() |next_m| { n_rec(p_s, next_m, res, ret_val) };
@ -139,7 +139,7 @@ enum parse_result {
fn parse_or_else(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader,
ms: ~[matcher]) -> hashmap<ident, @named_match> {
alt parse(sess, cfg, rdr, ms) {
match parse(sess, cfg, rdr, ms) {
success(m) => m,
failure(sp, str) => sess.span_diagnostic.span_fatal(sp, str)
}
@ -202,7 +202,7 @@ fn parse(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader, ms: ~[matcher])
// can we go around again?
// the *_t vars are workarounds for the lack of unary move
alt copy ei.sep {
match copy ei.sep {
some(t) if idx == len => { // we need a separator
if tok == t { //pass the separator
let ei_t <- ei;
@ -220,7 +220,7 @@ fn parse(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader, ms: ~[matcher])
vec::push(eof_eis, ei);
}
} else {
alt copy ei.elts[idx].node {
match copy ei.elts[idx].node {
/* need to descend into sequence */
match_seq(matchers, sep, zero_ok,
match_idx_lo, match_idx_hi) => {
@ -270,7 +270,7 @@ fn parse(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader, ms: ~[matcher])
if (bb_eis.len() > 0u && next_eis.len() > 0u)
|| bb_eis.len() > 1u {
let nts = str::connect(vec::map(bb_eis, |ei| {
alt ei.elts[ei.idx].node {
match ei.elts[ei.idx].node {
match_nonterminal(bind,name,_) => {
fmt!{"%s ('%s')", *name, *bind}
}
@ -293,7 +293,7 @@ fn parse(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader, ms: ~[matcher])
let rust_parser = parser(sess, cfg, rdr.dup(), SOURCE_FILE);
let ei = vec::pop(bb_eis);
alt ei.elts[ei.idx].node {
match ei.elts[ei.idx].node {
match_nonterminal(_, name, idx) => {
ei.matches[idx].push(@matched_nonterminal(
parse_nt(rust_parser, *name)));
@ -318,8 +318,8 @@ fn parse(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader, ms: ~[matcher])
}
fn parse_nt(p: parser, name: ~str) -> nonterminal {
alt name {
~"item" => alt p.parse_item(~[]) {
match name {
~"item" => match p.parse_item(~[]) {
some(i) => token::nt_item(i),
none => p.fatal(~"expected an item keyword")
}
@ -329,7 +329,7 @@ fn parse_nt(p: parser, name: ~str) -> nonterminal {
~"expr" => token::nt_expr(p.parse_expr()),
~"ty" => token::nt_ty(p.parse_ty(false /* no need to disambiguate*/)),
// this could be handled like a token, since it is one
~"ident" => alt copy p.token {
~"ident" => match copy p.token {
token::IDENT(sn,b) => { p.bump(); token::nt_ident(sn,b) }
_ => p.fatal(~"expected ident, found "
+ token::to_str(*p.reader.interner(), copy p.token))

11
src/libsyntax/ext/tt/macro_rules.rs
View file

@ -37,11 +37,11 @@ fn add_new_extension(cx: ext_ctxt, sp: span, name: ident,
arg_reader as reader, argument_gram);
// Extract the arguments:
let lhses:~[@named_match] = alt argument_map.get(@~"lhs") {
let lhses:~[@named_match] = match argument_map.get(@~"lhs") {
@matched_seq(s, sp) => s,
_ => cx.span_bug(sp, ~"wrong-structured lhs")
};
let rhses:~[@named_match] = alt argument_map.get(@~"rhs") {
let rhses:~[@named_match] = match argument_map.get(@~"rhs") {
@matched_seq(s, sp) => s,
_ => cx.span_bug(sp, ~"wrong-structured rhs")
};
@ -58,13 +58,14 @@ fn add_new_extension(cx: ext_ctxt, sp: span, name: ident,
let itr = cx.parse_sess().interner;
for lhses.eachi() |i, lhs| { // try each arm's matchers
alt lhs {
match lhs {
@matched_nonterminal(nt_matchers(mtcs)) => {
// `none` is because we're not interpolating
let arg_rdr = new_tt_reader(s_d, itr, none, arg) as reader;
alt parse(cx.parse_sess(), cx.cfg(), arg_rdr, mtcs) {
match parse(cx.parse_sess(), cx.cfg(), arg_rdr, mtcs) {
success(named_matches) => {
let rhs = alt rhses[i] { // okay, what's your transcriber?
let rhs = match rhses[i] {
// okay, what's your transcriber?
@matched_nonterminal(nt_tt(@tt)) => tt,
_ => cx.span_bug(sp, ~"bad thing in rhs")
};

24
src/libsyntax/ext/tt/transcribe.rs
View file

@ -46,7 +46,7 @@ fn new_tt_reader(sp_diag: span_handler, itr: @interner<@~str>,
let r = @{sp_diag: sp_diag, interner: itr,
mut cur: @{readme: src, mut idx: 0u, dotdotdoted: false,
sep: none, up: tt_frame_up(option::none)},
interpolations: alt interp { /* just a convienience */
interpolations: match interp { /* just a convienience */
none => std::map::box_str_hash::<@named_match>(),
some(x) => x
},
@ -61,7 +61,7 @@ fn new_tt_reader(sp_diag: span_handler, itr: @interner<@~str>,
pure fn dup_tt_frame(&&f: tt_frame) -> tt_frame {
@{readme: f.readme, mut idx: f.idx, dotdotdoted: f.dotdotdoted,
sep: f.sep, up: alt f.up {
sep: f.sep, up: match f.up {
tt_frame_up(some(up_frame)) => {
tt_frame_up(some(dup_tt_frame(up_frame)))
}
@ -82,7 +82,7 @@ pure fn dup_tt_reader(&&r: tt_reader) -> tt_reader {
pure fn lookup_cur_matched_by_matched(r: tt_reader,
start: @named_match) -> @named_match {
pure fn red(&&ad: @named_match, &&idx: uint) -> @named_match {
alt *ad {
match *ad {
matched_nonterminal(_) => {
// end of the line; duplicate henceforth
ad
@ -102,10 +102,10 @@ enum lis {
fn lockstep_iter_size(&&t: token_tree, &&r: tt_reader) -> lis {
fn lis_merge(lhs: lis, rhs: lis) -> lis {
alt lhs {
match lhs {
lis_unconstrained => rhs,
lis_contradiction(_) => lhs,
lis_constraint(l_len, l_id) => alt rhs {
lis_constraint(l_len, l_id) => match rhs {
lis_unconstrained => lhs,
lis_contradiction(_) => rhs,
lis_constraint(r_len, _) if l_len == r_len => lhs,
@ -117,13 +117,13 @@ fn lockstep_iter_size(&&t: token_tree, &&r: tt_reader) -> lis {
}
}
}
alt t {
match t {
tt_delim(tts) | tt_seq(_, tts, _, _) => {
vec::foldl(lis_unconstrained, tts, {|lis, tt|
lis_merge(lis, lockstep_iter_size(tt, r)) })
}
tt_tok(*) => lis_unconstrained,
tt_nonterminal(_, name) => alt *lookup_cur_matched(r, name) {
tt_nonterminal(_, name) => match *lookup_cur_matched(r, name) {
matched_nonterminal(_) => lis_unconstrained,
matched_seq(ads, _) => lis_constraint(ads.len(), name)
}
@ -138,7 +138,7 @@ fn tt_next_token(&&r: tt_reader) -> {tok: token, sp: span} {
if ! r.cur.dotdotdoted
|| r.repeat_idx.last() == r.repeat_len.last() - 1 {
alt r.cur.up {
match r.cur.up {
tt_frame_up(none) => {
r.cur_tok = EOF;
return ret_val;
@ -156,7 +156,7 @@ fn tt_next_token(&&r: tt_reader) -> {tok: token, sp: span} {
} else { /* repeat */
r.cur.idx = 0u;
r.repeat_idx[r.repeat_idx.len() - 1u] += 1u;
alt r.cur.sep {
match r.cur.sep {
some(tk) => {
r.cur_tok = tk; /* repeat same span, I guess */
return ret_val;
@ -167,7 +167,7 @@ fn tt_next_token(&&r: tt_reader) -> {tok: token, sp: span} {
}
loop { /* because it's easiest, this handles `tt_delim` not starting
with a `tt_tok`, even though it won't happen */
alt r.cur.readme[r.cur.idx] {
match r.cur.readme[r.cur.idx] {
tt_delim(tts) => {
r.cur = @{readme: tts, mut idx: 0u, dotdotdoted: false,
sep: none, up: tt_frame_up(option::some(r.cur)) };
@ -179,7 +179,7 @@ fn tt_next_token(&&r: tt_reader) -> {tok: token, sp: span} {
return ret_val;
}
tt_seq(sp, tts, sep, zerok) => {
alt lockstep_iter_size(tt_seq(sp, tts, sep, zerok), r) {
match lockstep_iter_size(tt_seq(sp, tts, sep, zerok), r) {
lis_unconstrained => {
r.sp_diag.span_fatal(
sp, /* blame macro writer */
@ -212,7 +212,7 @@ fn tt_next_token(&&r: tt_reader) -> {tok: token, sp: span} {
}
// FIXME #2887: think about span stuff here
tt_nonterminal(sp, ident) => {
alt *lookup_cur_matched(r, ident) {
match *lookup_cur_matched(r, ident) {
/* sidestep the interpolation tricks for ident because
(a) idents can be in lots of places, so it'd be a pain
(b) we actually can, since it's a token. */

34
src/libsyntax/fold.rs
View file

@ -80,7 +80,7 @@ type ast_fold_precursor = @{
//used in noop_fold_item and noop_fold_crate and noop_fold_crate_directive
fn fold_meta_item_(&&mi: @meta_item, fld: ast_fold) -> @meta_item {
return @{node:
alt mi.node {
match mi.node {
meta_word(id) => meta_word(fld.fold_ident(id)),
meta_list(id, mis) => {
let fold_meta_item = |x|fold_meta_item_(x, fld);
@ -112,7 +112,7 @@ fn fold_arg_(a: arg, fld: ast_fold) -> arg {
//used in noop_fold_expr, and possibly elsewhere in the future
fn fold_mac_(m: mac, fld: ast_fold) -> mac {
return {node:
alt m.node {
match m.node {
mac_invoc(pth, arg, body) => {
mac_invoc(fld.fold_path(pth),
option::map(arg, |x| fld.fold_expr(x)), body)
@ -133,7 +133,7 @@ fn fold_fn_decl(decl: ast::fn_decl, fld: ast_fold) -> ast::fn_decl {
}
fn fold_ty_param_bound(tpb: ty_param_bound, fld: ast_fold) -> ty_param_bound {
alt tpb {
match tpb {
bound_copy | bound_send | bound_const | bound_owned => tpb,
bound_trait(ty) => bound_trait(fld.fold_ty(ty))
}
@ -163,7 +163,7 @@ fn noop_fold_crate(c: crate_, fld: ast_fold) -> crate_ {
fn noop_fold_crate_directive(cd: crate_directive_, fld: ast_fold) ->
crate_directive_ {
return alt cd {
return match cd {
cdir_src_mod(id, attrs) => {
cdir_src_mod(fld.fold_ident(id), /* FIXME (#2543) */ copy attrs)
}
@ -190,7 +190,7 @@ fn noop_fold_foreign_item(&&ni: @foreign_item, fld: ast_fold)
return @{ident: fld.fold_ident(ni.ident),
attrs: vec::map(ni.attrs, fold_attribute),
node:
alt ni.node {
match ni.node {
foreign_item_fn(fdec, typms) => {
foreign_item_fn({inputs: vec::map(fdec.inputs, fold_arg),
output: fld.fold_ty(fdec.output),
@ -216,7 +216,7 @@ fn noop_fold_item(&&i: @item, fld: ast_fold) -> option<@item> {
fn noop_fold_class_item(&&ci: @class_member, fld: ast_fold)
-> @class_member {
@{node: alt ci.node {
@{node: match ci.node {
instance_var(ident, t, cm, id, p) => {
instance_var(/* FIXME (#2543) */ copy ident,
fld.fold_ty(t), cm, id, p)
@ -227,7 +227,7 @@ fn noop_fold_class_item(&&ci: @class_member, fld: ast_fold)
}
fn noop_fold_item_underscore(i: item_, fld: ast_fold) -> item_ {
return alt i {
return match i {
item_const(t, e) => item_const(fld.fold_ty(t), fld.fold_expr(e)),
item_fn(decl, typms, body) => {
item_fn(fold_fn_decl(decl, fld),
@ -244,7 +244,7 @@ fn noop_fold_item_underscore(i: item_, fld: ast_fold) -> item_ {
}
item_class(typms, traits, items, m_ctor, m_dtor) => {
let resulting_optional_constructor;
alt m_ctor {
match m_ctor {
none => {
resulting_optional_constructor = none;
}
@ -319,7 +319,7 @@ fn noop_fold_block(b: blk_, fld: ast_fold) -> blk_ {
}
fn noop_fold_stmt(s: stmt_, fld: ast_fold) -> stmt_ {
return alt s {
return match s {
stmt_decl(d, nid) => stmt_decl(fld.fold_decl(d), fld.new_id(nid)),
stmt_expr(e, nid) => stmt_expr(fld.fold_expr(e), fld.new_id(nid)),
stmt_semi(e, nid) => stmt_semi(fld.fold_expr(e), fld.new_id(nid))
@ -333,7 +333,7 @@ fn noop_fold_arm(a: arm, fld: ast_fold) -> arm {
}
fn noop_fold_pat(p: pat_, fld: ast_fold) -> pat_ {
return alt p {
return match p {
pat_wild => pat_wild,
pat_ident(binding_mode, pth, sub) => {
pat_ident(binding_mode,
@ -364,9 +364,9 @@ fn noop_fold_pat(p: pat_, fld: ast_fold) -> pat_ {
}
fn noop_fold_decl(d: decl_, fld: ast_fold) -> decl_ {
alt d {
match d {
decl_local(ls) => decl_local(vec::map(ls, |x| fld.fold_local(x))),
decl_item(it) => alt fld.fold_item(it) {
decl_item(it) => match fld.fold_item(it) {
some(it_folded) => decl_item(it_folded),
none => decl_local(~[])
}
@ -393,7 +393,7 @@ fn noop_fold_expr(e: expr_, fld: ast_fold) -> expr_ {
let fold_mac = |x| fold_mac_(x, fld);
return alt e {
return match e {
expr_vstore(e, v) => {
expr_vstore(fld.fold_expr(e), v)
}
@ -496,7 +496,7 @@ fn noop_fold_ty(t: ty_, fld: ast_fold) -> ty_ {
mt: fold_mt(f.node.mt, fld)},
span: fld.new_span(f.span)}
}
alt t {
match t {
ty_nil | ty_bot | ty_infer => copy t,
ty_box(mt) => ty_box(fold_mt(mt, fld)),
ty_uniq(mt) => ty_uniq(fold_mt(mt, fld)),
@ -533,7 +533,7 @@ fn noop_fold_variant(v: variant_, fld: ast_fold) -> variant_ {
let fold_attribute = |x| fold_attribute_(x, fld);
let attrs = vec::map(v.attrs, fold_attribute);
let de = alt v.disr_expr {
let de = match v.disr_expr {
some(e) => some(fld.fold_expr(e)),
none => none
};
@ -560,7 +560,7 @@ fn noop_fold_local(l: local_, fld: ast_fold) -> local_ {
ty: fld.fold_ty(l.ty),
pat: fld.fold_pat(l.pat),
init:
alt l.init {
match l.init {
option::none::<initializer> => l.init,
option::some::<initializer>(init) => {
option::some::<initializer>({op: init.op,
@ -635,7 +635,7 @@ impl of ast_fold for ast_fold_precursor {
return self.fold_item(i, self as ast_fold);
}
fn fold_class_item(&&ci: @class_member) -> @class_member {
@{node: alt ci.node {
@{node: match ci.node {
instance_var(nm, t, mt, id, p) => {
instance_var(/* FIXME (#2543) */ copy nm,
(self as ast_fold).fold_ty(t), mt, id, p)

2
src/libsyntax/parse.rs
View file

@ -189,7 +189,7 @@ fn new_parser_etc_from_file(sess: parse_sess, cfg: ast::crate_cfg,
+path: ~str, ftype: parser::file_type) ->
(parser, string_reader) {
let res = io::read_whole_file_str(path);
alt res {
match res {
result::ok(_) => { /* Continue. */ }
result::err(e) => sess.span_diagnostic.handler().fatal(e)
}

10
src/libsyntax/parse/attr.rs
View file

@ -29,7 +29,7 @@ impl parser_attr of parser_attr for parser {
-> attr_or_ext
{
let expect_item_next = vec::is_not_empty(first_item_attrs);
alt self.token {
match self.token {
token::POUND => {
let lo = self.span.lo;
if self.look_ahead(1u) == token::LBRACKET {
@ -57,7 +57,7 @@ impl parser_attr of parser_attr for parser {
fn parse_outer_attributes() -> ~[ast::attribute] {
let mut attrs: ~[ast::attribute] = ~[];
loop {
alt copy self.token {
match copy self.token {
token::POUND => {
if self.look_ahead(1u) != token::LBRACKET {
break;
@ -106,7 +106,7 @@ impl parser_attr of parser_attr for parser {
let mut inner_attrs: ~[ast::attribute] = ~[];
let mut next_outer_attrs: ~[ast::attribute] = ~[];
loop {
alt copy self.token {
match copy self.token {
token::POUND => {
if self.look_ahead(1u) != token::LBRACKET {
// This is an extension
@ -146,7 +146,7 @@ impl parser_attr of parser_attr for parser {
fn parse_meta_item() -> @ast::meta_item {
let lo = self.span.lo;
let ident = self.parse_ident();
alt self.token {
match self.token {
token::EQ => {
self.bump();
let lit = self.parse_lit();
@ -172,7 +172,7 @@ impl parser_attr of parser_attr for parser {
}
fn parse_optional_meta() -> ~[@ast::meta_item] {
alt self.token {
match self.token {
token::LPAREN => return self.parse_meta_seq(),
_ => return ~[]
}

14
src/libsyntax/parse/classify.rs
View file

@ -5,7 +5,7 @@
import ast_util::operator_prec;
fn expr_requires_semi_to_be_stmt(e: @ast::expr) -> bool {
alt e.node {
match e.node {
ast::expr_if(_, _, _) | ast::expr_alt(_, _, _) | ast::expr_block(_)
| ast::expr_while(_, _) | ast::expr_loop(_)
| ast::expr_call(_, _, true) => false,
@ -14,9 +14,9 @@ fn expr_requires_semi_to_be_stmt(e: @ast::expr) -> bool {
}
fn stmt_ends_with_semi(stmt: ast::stmt) -> bool {
alt stmt.node {
match stmt.node {
ast::stmt_decl(d, _) => {
return alt d.node {
return match d.node {
ast::decl_local(_) => true,
ast::decl_item(_) => false
}
@ -31,7 +31,7 @@ fn stmt_ends_with_semi(stmt: ast::stmt) -> bool {
}
fn need_parens(expr: @ast::expr, outer_prec: uint) -> bool {
alt expr.node {
match expr.node {
ast::expr_binary(op, _, _) => operator_prec(op) < outer_prec,
ast::expr_cast(_, _) => parse::prec::as_prec < outer_prec,
// This may be too conservative in some cases
@ -47,8 +47,8 @@ fn need_parens(expr: @ast::expr, outer_prec: uint) -> bool {
}
fn ends_in_lit_int(ex: @ast::expr) -> bool {
alt ex.node {
ast::expr_lit(node) => alt node {
match ex.node {
ast::expr_lit(node) => match node {
@{node: ast::lit_int(_, ast::ty_i), _}
| @{node: ast::lit_int_unsuffixed(_), _} => true,
_ => false
@ -60,7 +60,7 @@ fn ends_in_lit_int(ex: @ast::expr) -> bool {
ast::expr_log(_, _, sub) | ast::expr_assert(sub) => {
ends_in_lit_int(sub)
}
ast::expr_fail(osub) | ast::expr_ret(osub) => alt osub {
ast::expr_fail(osub) | ast::expr_ret(osub) => match osub {
some(ex) => ends_in_lit_int(ex),
_ => false
}

14
src/libsyntax/parse/common.rs
View file

@ -84,7 +84,7 @@ impl parser_common of parser_common for parser {
}
fn parse_ident() -> ast::ident {
alt copy self.token {
match copy self.token {
token::IDENT(i, _) => { self.bump(); return self.get_str(i); }
token::INTERPOLATED(token::nt_ident(*)) => { self.bug(
~"ident interpolation not converted to real token"); }
@ -118,7 +118,7 @@ impl parser_common of parser_common for parser {
}
fn token_is_word(word: ~str, ++tok: token::token) -> bool {
alt tok {
match tok {
token::IDENT(sid, false) => { word == *self.get_str(sid) }
_ => { false }
}
@ -134,7 +134,7 @@ impl parser_common of parser_common for parser {
}
fn is_any_keyword(tok: token::token) -> bool {
alt tok {
match tok {
token::IDENT(sid, false) => {
self.keywords.contains_key_ref(self.get_str(sid))
}
@ -146,7 +146,7 @@ impl parser_common of parser_common for parser {
self.require_keyword(word);
let mut bump = false;
let val = alt self.token {
let val = match self.token {
token::IDENT(sid, false) => {
if word == *self.get_str(sid) {
bump = true;
@ -173,7 +173,7 @@ impl parser_common of parser_common for parser {
}
fn check_restricted_keywords() {
alt self.token {
match self.token {
token::IDENT(_, false) => {
let w = token_to_str(self.reader, self.token);
self.check_restricted_keywords_(w);
@ -209,7 +209,7 @@ impl parser_common of parser_common for parser {
let mut v = ~[];
while self.token != token::GT
&& self.token != token::BINOP(token::SHR) {
alt sep {
match sep {
some(t) => {
if first { first = false; }
else { self.expect(t); }
@ -253,7 +253,7 @@ impl parser_common of parser_common for parser {
let mut first: bool = true;
let mut v: ~[T] = ~[];
while self.token != ket {
alt sep.sep {
match sep.sep {
some(t) => {
if first { first = false; }
else { self.expect(t); }

8
src/libsyntax/parse/eval.rs
View file

@ -47,7 +47,7 @@ fn parse_companion_mod(cx: ctx, prefix: ~str, suffix: option<~str>)
-> (~[@ast::view_item], ~[@ast::item], ~[ast::attribute]) {
fn companion_file(+prefix: ~str, suffix: option<~str>) -> ~str {
return alt suffix {
return match suffix {
option::some(s) => path::connect(prefix, s),
option::none => prefix
} + ~".rs";
@ -56,7 +56,7 @@ fn parse_companion_mod(cx: ctx, prefix: ~str, suffix: option<~str>)
fn file_exists(path: ~str) -> bool {
// Crude, but there's no lib function for this and I'm not
// up to writing it just now
alt io::file_reader(path) {
match io::file_reader(path) {
result::ok(_) => true,
result::err(_) => false
}
@ -79,7 +79,7 @@ fn parse_companion_mod(cx: ctx, prefix: ~str, suffix: option<~str>)
}
fn cdir_path_opt(id: ast::ident, attrs: ~[ast::attribute]) -> @~str {
alt ::attr::first_attr_value_str_by_name(attrs, ~"path") {
match ::attr::first_attr_value_str_by_name(attrs, ~"path") {
some(d) => return d,
none => return id
}
@ -88,7 +88,7 @@ fn cdir_path_opt(id: ast::ident, attrs: ~[ast::attribute]) -> @~str {
fn eval_crate_directive(cx: ctx, cdir: @ast::crate_directive, prefix: ~str,
&view_items: ~[@ast::view_item],
&items: ~[@ast::item]) {
alt cdir.node {
match cdir.node {
ast::cdir_src_mod(id, attrs) => {
let file_path = cdir_path_opt(@(*id + ~".rs"), attrs);
let full_path =

24
src/libsyntax/parse/lexer.rs
View file

@ -206,7 +206,7 @@ fn consume_whitespace_and_comments(rdr: string_reader)
fn consume_any_line_comment(rdr: string_reader)
-> option<{tok: token::token, sp: span}> {
if rdr.curr == '/' {
alt nextch(rdr) {
match nextch(rdr) {
'/' => {
bump(rdr);
bump(rdr);
@ -313,7 +313,7 @@ fn scan_digits(rdr: string_reader, radix: uint) -> ~str {
loop {
let c = rdr.curr;
if c == '_' { bump(rdr); again; }
alt char::to_digit(c, radix) {
match char::to_digit(c, radix) {
some(d) => {
str::push_char(rslt, c);
bump(rdr);
@ -371,7 +371,7 @@ fn scan_number(c: char, rdr: string_reader) -> token::token {
rdr.fatal(~"no valid digits found for number");
}
let parsed = option::get(u64::from_str_radix(num_str, base as u64));
alt tp {
match tp {
either::left(t) => return token::LIT_INT(parsed as i64, t),
either::right(t) => return token::LIT_UINT(parsed, t)
}
@ -383,7 +383,7 @@ fn scan_number(c: char, rdr: string_reader) -> token::token {
let dec_part = scan_digits(rdr, 10u);
num_str += ~"." + dec_part;
}
alt scan_exponent(rdr) {
match scan_exponent(rdr) {
some(s) => {
is_float = true;
num_str += s;
@ -472,7 +472,7 @@ fn next_token_inner(rdr: string_reader) -> token::token {
return token::BINOPEQ(op);
} else { return token::BINOP(op); }
}
alt c {
match c {
@ -539,12 +539,12 @@ fn next_token_inner(rdr: string_reader) -> token::token {
}
'<' => {
bump(rdr);
alt rdr.curr {
match rdr.curr {
'=' => { bump(rdr); return token::LE; }
'<' => { return binop(rdr, token::SHL); }
'-' => {
bump(rdr);
alt rdr.curr {
match rdr.curr {
'>' => { bump(rdr); return token::DARROW; }
_ => { return token::LARROW; }
}
@ -554,7 +554,7 @@ fn next_token_inner(rdr: string_reader) -> token::token {
}
'>' => {
bump(rdr);
alt rdr.curr {
match rdr.curr {
'=' => { bump(rdr); return token::GE; }
'>' => { return binop(rdr, token::SHR); }
_ => { return token::GT; }
@ -567,7 +567,7 @@ fn next_token_inner(rdr: string_reader) -> token::token {
if c2 == '\\' {
let escaped = rdr.curr;
bump(rdr);
alt escaped {
match escaped {
'n' => { c2 = '\n'; }
'r' => { c2 = '\r'; }
't' => { c2 = '\t'; }
@ -599,11 +599,11 @@ fn next_token_inner(rdr: string_reader) -> token::token {
let ch = rdr.curr;
bump(rdr);
alt ch {
match ch {
'\\' => {
let escaped = rdr.curr;
bump(rdr);
alt escaped {
match escaped {
'n' => str::push_char(accum_str, '\n'),
'r' => str::push_char(accum_str, '\r'),
't' => str::push_char(accum_str, '\t'),
@ -646,7 +646,7 @@ fn next_token_inner(rdr: string_reader) -> token::token {
} else { return binop(rdr, token::AND); }
}
'|' => {
alt nextch(rdr) {
match nextch(rdr) {
'|' => { bump(rdr); bump(rdr); return token::OROR; }
_ => { return binop(rdr, token::OR); }
}

140
src/libsyntax/parse/parser.rs
View file

@ -107,7 +107,7 @@ type item_info = (ident, item_, option<~[attribute]>);
The important thing is to make sure that lookahead doesn't balk
at INTERPOLATED tokens */
macro_rules! maybe_whole_expr {
{$p:expr} => { alt copy $p.token {
{$p:expr} => { match copy $p.token {
INTERPOLATED(token::nt_expr(e)) => {
$p.bump();
return pexpr(e);
@ -122,19 +122,19 @@ macro_rules! maybe_whole_expr {
}
macro_rules! maybe_whole {
{$p:expr, $constructor:ident} => { alt copy $p.token {
{$p:expr, $constructor:ident} => { match copy $p.token {
INTERPOLATED(token::$constructor(x)) => { $p.bump(); return x; }
_ => ()
}} ;
{deref $p:expr, $constructor:ident} => { alt copy $p.token {
{deref $p:expr, $constructor:ident} => { match copy $p.token {
INTERPOLATED(token::$constructor(x)) => { $p.bump(); return *x; }
_ => ()
}} ;
{some $p:expr, $constructor:ident} => { alt copy $p.token {
{some $p:expr, $constructor:ident} => { match copy $p.token {
INTERPOLATED(token::$constructor(x)) => { $p.bump(); return some(x); }
_ => ()
}} ;
{pair_empty $p:expr, $constructor:ident} => { alt copy $p.token {
{pair_empty $p:expr, $constructor:ident} => { match copy $p.token {
INTERPOLATED(token::$constructor(x)) => { $p.bump(); return (~[], x); }
_ => ()
}}
@ -284,7 +284,7 @@ class parser {
debug!{"parse_trait_methods(): trait method signature ends in \
`%s`",
token_to_str(p.reader, p.token)};
alt p.token {
match p.token {
token::SEMI => {
p.bump();
debug!{"parse_trait_methods(): parsing required method"};
@ -356,7 +356,7 @@ class parser {
}
fn region_from_name(s: option<@~str>) -> @region {
let r = alt s {
let r = match s {
some (string) => re_named(string),
none => re_anon
};
@ -368,7 +368,7 @@ class parser {
fn parse_region() -> @region {
self.expect(token::BINOP(token::AND));
alt copy self.token {
match copy self.token {
token::IDENT(sid, _) => {
self.bump();
let n = self.get_str(sid);
@ -383,7 +383,7 @@ class parser {
// Parses something like "&x/" (note the trailing slash)
fn parse_region_with_sep() -> @region {
let name =
alt copy self.token {
match copy self.token {
token::IDENT(sid, _) => {
if self.look_ahead(1u) == token::BINOP(token::SLASH) {
self.bump(); self.bump();
@ -402,7 +402,7 @@ class parser {
let lo = self.span.lo;
alt self.maybe_parse_dollar_mac() {
match self.maybe_parse_dollar_mac() {
some(e) => {
return @{id: self.get_id(),
node: ty_mac(spanned(lo, self.span.hi, e)),
@ -471,7 +471,7 @@ class parser {
let sp = mk_sp(lo, self.last_span.hi);
return @{id: self.get_id(),
node: alt self.maybe_parse_fixed_vstore() {
node: match self.maybe_parse_fixed_vstore() {
// Consider a fixed vstore suffix (/N or /_)
none => t,
some(v) => {
@ -542,11 +542,11 @@ class parser {
}
fn maybe_parse_dollar_mac() -> option<mac_> {
alt copy self.token {
match copy self.token {
token::DOLLAR => {
let lo = self.span.lo;
self.bump();
alt copy self.token {
match copy self.token {
token::LIT_INT_UNSUFFIXED(num) => {
self.bump();
some(mac_var(num as uint))
@ -570,7 +570,7 @@ class parser {
fn maybe_parse_fixed_vstore() -> option<option<uint>> {
if self.token == token::BINOP(token::SLASH) {
self.bump();
alt copy self.token {
match copy self.token {
token::UNDERSCORE => {
self.bump(); some(none)
}
@ -585,7 +585,7 @@ class parser {
}
fn lit_from_token(tok: token::token) -> lit_ {
alt tok {
match tok {
token::LIT_INT(i, it) => lit_int(i, it),
token::LIT_UINT(u, ut) => lit_uint(u, ut),
token::LIT_INT_UNSUFFIXED(i) => lit_int_unsuffixed(i),
@ -733,7 +733,7 @@ class parser {
}
fn to_expr(e: pexpr) -> @expr {
alt e.node {
match e.node {
expr_tup(es) if vec::len(es) == 1u => es[0u],
_ => *e
}
@ -746,7 +746,7 @@ class parser {
let mut ex: expr_;
alt self.maybe_parse_dollar_mac() {
match self.maybe_parse_dollar_mac() {
some(x) => return pexpr(self.mk_mac_expr(lo, self.span.hi, x)),
_ => ()
}
@ -794,11 +794,11 @@ class parser {
return pexpr(self.parse_while_expr());
} else if self.eat_keyword(~"loop") {
return pexpr(self.parse_loop_expr());
} else if self.eat_keyword(~"alt") || self.eat_keyword(~"match") {
} else if self.eat_keyword(~"match") {
return pexpr(self.parse_alt_expr());
} else if self.eat_keyword(~"fn") {
let proto = self.parse_fn_ty_proto();
alt proto {
match proto {
proto_bare => self.fatal(~"fn expr are deprecated, use fn@"),
_ => { /* fallthrough */ }
}
@ -893,7 +893,7 @@ class parser {
/* `!`, as an operator, is prefix, so we know this isn't that */
if self.token == token::NOT {
self.bump();
let tts = alt self.token {
let tts = match self.token {
token::LPAREN | token::LBRACE | token::LBRACKET => {
let ket = token::flip_delimiter(self.token);
self.parse_unspanned_seq(copy self.token, ket,
@ -948,9 +948,9 @@ class parser {
// Vstore is legal following expr_lit(lit_str(...)) and expr_vec(...)
// only.
alt ex {
match ex {
expr_lit(@{node: lit_str(_), span: _}) |
expr_vec(_, _) => alt self.maybe_parse_fixed_vstore() {
expr_vec(_, _) => match self.maybe_parse_fixed_vstore() {
none => (),
some(v) => {
hi = self.span.hi;
@ -976,7 +976,7 @@ class parser {
}
fn parse_syntax_ext_naked(lo: uint) -> @expr {
alt self.token {
match self.token {
token::IDENT(_, _) => (),
_ => self.fatal(~"expected a syntax expander name")
}
@ -1003,7 +1003,7 @@ class parser {
let lo = self.span.lo;
let mut depth = 1u;
while (depth > 0u) {
alt (self.token) {
match (self.token) {
token::LBRACE => depth += 1u,
token::RBRACE => depth -= 1u,
token::EOF => self.fatal(~"unexpected EOF in macro body"),
@ -1033,7 +1033,7 @@ class parser {
loop {
// expr.f
if self.eat(token::DOT) {
alt copy self.token {
match copy self.token {
token::IDENT(i, _) => {
hi = self.span.hi;
self.bump();
@ -1051,7 +1051,7 @@ class parser {
again;
}
if self.expr_is_complete(e) { break; }
alt copy self.token {
match copy self.token {
// expr(...)
token::LPAREN if self.permits_call() => {
let es = self.parse_unspanned_seq(
@ -1103,7 +1103,7 @@ class parser {
maybe_whole!{deref self, nt_tt};
fn parse_tt_tok(p: parser, delim_ok: bool) -> token_tree {
alt p.token {
match p.token {
token::RPAREN | token::RBRACE | token::RBRACKET
if !delim_ok => {
p.fatal(~"incorrect close delimiter: `"
@ -1134,7 +1134,7 @@ class parser {
return res;
}
return alt self.token {
return match self.token {
token::LPAREN | token::LBRACE | token::LBRACKET => {
let ket = token::flip_delimiter(self.token);
tt_delim(vec::append(
@ -1154,7 +1154,7 @@ class parser {
// the interpolation of matchers
maybe_whole!{self, nt_matchers};
let name_idx = @mut 0u;
return alt self.token {
return match self.token {
token::LBRACE | token::LPAREN | token::LBRACKET => {
self.parse_matcher_subseq(name_idx, copy self.token,
token::flip_delimiter(self.token))
@ -1222,7 +1222,7 @@ class parser {
let mut hi;
let mut ex;
alt copy self.token {
match copy self.token {
token::NOT => {
self.bump();
let e = self.to_expr(self.parse_prefix_expr());
@ -1231,7 +1231,7 @@ class parser {
ex = expr_unary(not, e);
}
token::BINOP(b) => {
alt b {
match b {
token::MINUS => {
self.bump();
let e = self.to_expr(self.parse_prefix_expr());
@ -1251,7 +1251,7 @@ class parser {
let e = self.to_expr(self.parse_prefix_expr());
hi = e.span.hi;
// HACK: turn &[...] into a &-evec
ex = alt e.node {
ex = match e.node {
expr_vec(*) | expr_lit(@{node: lit_str(_), span: _})
if m == m_imm => {
expr_vstore(e, vstore_slice(self.region_from_name(none)))
@ -1268,7 +1268,7 @@ class parser {
let e = self.to_expr(self.parse_prefix_expr());
hi = e.span.hi;
// HACK: turn @[...] into a @-evec
ex = alt e.node {
ex = match e.node {
expr_vec(*) | expr_lit(@{node: lit_str(_), span: _})
if m == m_imm => expr_vstore(e, vstore_box),
_ => expr_unary(box(m), e)
@ -1280,7 +1280,7 @@ class parser {
let e = self.to_expr(self.parse_prefix_expr());
hi = e.span.hi;
// HACK: turn ~[...] into a ~-evec
ex = alt e.node {
ex = match e.node {
expr_vec(*) | expr_lit(@{node: lit_str(_), span: _})
if m == m_imm => expr_vstore(e, vstore_uniq),
_ => expr_unary(uniq(m), e)
@ -1311,7 +1311,7 @@ class parser {
return lhs;
}
let cur_opt = token_to_binop(peeked);
alt cur_opt {
match cur_opt {
some(cur_op) => {
let cur_prec = operator_prec(cur_op);
if cur_prec > min_prec {
@ -1338,7 +1338,7 @@ class parser {
fn parse_assign_expr() -> @expr {
let lo = self.span.lo;
let lhs = self.parse_binops();
alt copy self.token {
match copy self.token {
token::EQ => {
self.bump();
let rhs = self.parse_expr();
@ -1348,7 +1348,7 @@ class parser {
self.bump();
let rhs = self.parse_expr();
let mut aop;
alt op {
match op {
token::PLUS => aop = add,
token::MINUS => aop = subtract,
token::STAR => aop = mul,
@ -1412,7 +1412,7 @@ class parser {
fn parse_lambda_block_expr() -> @expr {
self.parse_lambda_expr_(
|| {
alt self.token {
match self.token {
token::BINOP(token::OR) | token::OROR => {
self.parse_fn_block_decl()
}
@ -1481,7 +1481,7 @@ class parser {
// Turn on the restriction to stop at | or || so we can parse
// them as the lambda arguments
let e = self.parse_expr_res(RESTRICT_NO_BAR_OR_DOUBLEBAR_OP);
alt e.node {
match e.node {
expr_call(f, args, false) => {
let block = self.parse_lambda_block_expr();
let last_arg = self.mk_expr(block.span.lo, block.span.hi,
@ -1608,7 +1608,7 @@ class parser {
}
fn parse_initializer() -> option<initializer> {
alt self.token {
match self.token {
token::EQ => {
self.bump();
return some({op: init_assign, expr: self.parse_expr()});
@ -1645,14 +1645,14 @@ class parser {
let lo = self.span.lo;
let mut hi = self.span.hi;
let mut pat;
alt self.token {
match self.token {
token::UNDERSCORE => { self.bump(); pat = pat_wild; }
token::AT => {
self.bump();
let sub = self.parse_pat(refutable);
hi = sub.span.hi;
// HACK: parse @"..." as a literal of a vstore @str
pat = alt sub.node {
pat = match sub.node {
pat_lit(e@@{
node: expr_lit(@{node: lit_str(_), span: _}), _
}) => {
@ -1669,7 +1669,7 @@ class parser {
let sub = self.parse_pat(refutable);
hi = sub.span.hi;
// HACK: parse ~"..." as a literal of a vstore ~str
pat = alt sub.node {
pat = match sub.node {
pat_lit(e@@{
node: expr_lit(@{node: lit_str(_), span: _}), _
}) => {
@ -1775,7 +1775,7 @@ class parser {
}
if is_plain_ident(self.token) &&
alt self.look_ahead(1) {
match self.look_ahead(1) {
token::LPAREN | token::LBRACKET | token::LT => {
false
}
@ -1794,8 +1794,8 @@ class parser {
hi = enum_path.span.hi;
let mut args: ~[@pat] = ~[];
let mut star_pat = false;
alt self.token {
token::LPAREN => alt self.look_ahead(1u) {
match self.token {
token::LPAREN => match self.look_ahead(1u) {
token::BINOP(token::STAR) => {
// This is a "top constructor only" pat
self.bump(); self.bump();
@ -1890,7 +1890,7 @@ class parser {
return @spanned(lo, decl.span.hi, stmt_decl(decl, self.get_id()));
} else {
let mut item_attrs;
alt self.parse_outer_attrs_or_ext(first_item_attrs) {
match self.parse_outer_attrs_or_ext(first_item_attrs) {
none => item_attrs = ~[],
some(left(attrs)) => item_attrs = attrs,
some(right(ext)) => {
@ -1901,7 +1901,7 @@ class parser {
let item_attrs = vec::append(first_item_attrs, item_attrs);
alt self.parse_item(item_attrs) {
match self.parse_item(item_attrs) {
some(i) => {
let mut hi = i.span.hi;
let decl = @spanned(lo, hi, decl_item(i));
@ -1993,16 +1993,16 @@ class parser {
}
while self.token != token::RBRACE {
alt self.token {
match self.token {
token::SEMI => {
self.bump(); // empty
}
_ => {
let stmt = self.parse_stmt(initial_attrs);
initial_attrs = ~[];
alt stmt.node {
match stmt.node {
stmt_expr(e, stmt_id) => { // Expression without semicolon:
alt self.token {
match self.token {
token::SEMI => {
self.bump();
push(stmts,
@ -2086,7 +2086,7 @@ class parser {
}
fn is_self_ident() -> bool {
alt self.token {
match self.token {
token::IDENT(sid, false) if ~"self" == *self.get_str(sid) => true,
_ => false
}
@ -2111,7 +2111,7 @@ class parser {
// backwards compatible.
let lo = self.span.lo;
let self_ty;
alt copy self.token {
match copy self.token {
token::BINOP(token::AND) => {
// We need to make sure it isn't a mode.
self.bump();
@ -2126,10 +2126,10 @@ class parser {
// Parse an explicit region, if possible.
let region_name;
alt copy self.token {
match copy self.token {
token::BINOP(token::SLASH) => {
self.bump();
alt copy self.token {
match copy self.token {
token::IDENT(sid, false) => {
self.bump();
region_name = some(self.get_str(sid));
@ -2174,7 +2174,7 @@ class parser {
// If we parsed a self type, expect a comma before the argument list.
let args_or_capture_items;
if self_ty != sty_by_ref {
alt copy self.token {
match copy self.token {
token::COMMA => {
self.bump();
let sep = seq_sep_trailing_disallowed(token::COMMA);
@ -2265,7 +2265,7 @@ class parser {
}
fn parse_method_name() -> ident {
alt copy self.token {
match copy self.token {
token::BINOP(op) => { self.bump(); @token::binop_to_str(op) }
token::NOT => { self.bump(); @~"!" }
token::LBRACKET => {
@ -2387,7 +2387,7 @@ class parser {
} else {
traits = ~[];
};
ident = alt ident_old {
ident = match ident_old {
some(name) => name,
none => { self.expect_keyword(~"of"); fail; }
};
@ -2445,7 +2445,7 @@ class parser {
codemap::span)> = none;
let mut the_dtor : option<(blk, ~[attribute], codemap::span)> = none;
while self.token != token::RBRACE {
alt self.parse_class_item(class_path) {
match self.parse_class_item(class_path) {
ctor_decl(a_fn_decl, attrs, blk, s) => {
the_ctor = some((a_fn_decl, attrs, blk, s));
}
@ -2463,7 +2463,7 @@ class parser {
body: d_body},
span: d_s}};
self.bump();
alt the_ctor {
match the_ctor {
some((ct_d, ct_attrs, ct_b, ct_s)) => {
(class_name,
item_class(ty_params, traits, ms, some({
@ -2487,7 +2487,7 @@ class parser {
}
fn token_is_pound_or_doc_comment(++tok: token::token) -> bool {
alt tok {
match tok {
token::POUND | token::DOC_COMMENT(_) => true,
_ => false
}
@ -2582,7 +2582,7 @@ class parser {
first = false;
}
debug!{"parse_mod_items: parse_item(attrs=%?)", attrs};
alt self.parse_item(attrs) {
match self.parse_item(attrs) {
some(i) => vec::push(items, i),
_ => {
self.fatal(~"expected item but found `" +
@ -2764,7 +2764,7 @@ class parser {
}
fn parse_fn_ty_proto() -> proto {
alt self.token {
match self.token {
token::AT => {
self.bump();
proto_box
@ -2784,7 +2784,7 @@ class parser {
}
fn fn_expr_lookahead(tok: token::token) -> bool {
alt tok {
match tok {
token::LPAREN | token::AT | token::TILDE | token::BINOP(_) => true,
_ => false
}
@ -2846,7 +2846,7 @@ class parser {
let pth = self.parse_path_without_tps();
self.expect(token::NOT);
let id = self.parse_ident();
let tts = alt self.token {
let tts = match self.token {
token::LPAREN | token::LBRACE | token::LBRACKET => {
let ket = token::flip_delimiter(self.token);
self.parse_unspanned_seq(copy self.token, ket,
@ -2863,7 +2863,7 @@ class parser {
(id, item_mac(m), none)
} else { return none; };
some(self.mk_item(lo, self.last_span.hi, ident, item_, visibility,
alt extra_attrs {
match extra_attrs {
some(as) => vec::append(attrs, as),
none => attrs
}))
@ -2880,7 +2880,7 @@ class parser {
let first_ident = self.parse_ident();
let mut path = ~[first_ident];
debug!{"parsed view_path: %s", *first_ident};
alt self.token {
match self.token {
token::EQ => {
// x = foo::bar
self.bump();
@ -2901,7 +2901,7 @@ class parser {
while self.token == token::MOD_SEP {
self.bump();
alt copy self.token {
match copy self.token {
token::IDENT(i, _) => {
self.bump();
@ -3004,7 +3004,7 @@ class parser {
}
fn parse_str() -> @~str {
alt copy self.token {
match copy self.token {
token::LIT_STR(s) => { self.bump(); self.get_str(s) }
_ => self.fatal(~"expected string literal")
}
@ -3035,7 +3035,7 @@ class parser {
self.expect_keyword(~"module");
}
let id = self.parse_ident();
alt self.token {
match self.token {
// mod x = "foo.rs";
token::SEMI => {
let mut hi = self.span.hi;

2
src/libsyntax/parse/prec.rs
View file

@ -20,7 +20,7 @@ const as_prec: uint = 11u;
* operator and its precedence
*/
fn token_to_binop(tok: token) -> option<ast::binop> {
alt tok {
match tok {
BINOP(STAR) => some(mul),
BINOP(SLASH) => some(div),
BINOP(PERCENT) => some(rem),

22
src/libsyntax/parse/token.rs
View file

@ -102,7 +102,7 @@ enum nonterminal {
}
fn binop_to_str(o: binop) -> ~str {
alt o {
match o {
PLUS => ~"+",
MINUS => ~"-",
STAR => ~"*",
@ -117,7 +117,7 @@ fn binop_to_str(o: binop) -> ~str {
}
fn to_str(in: interner<@~str>, t: token) -> ~str {
alt t {
match t {
EQ => ~"=",
LT => ~"<",
LE => ~"<=",
@ -186,7 +186,7 @@ fn to_str(in: interner<@~str>, t: token) -> ~str {
EOF => ~"<eof>",
INTERPOLATED(nt) => {
~"an interpolated " +
alt nt {
match nt {
nt_item(*) => ~"item",
nt_block(*) => ~"block",
nt_stmt(*) => ~"statement",
@ -203,7 +203,7 @@ fn to_str(in: interner<@~str>, t: token) -> ~str {
}
pure fn can_begin_expr(t: token) -> bool {
alt t {
match t {
LPAREN => true,
LBRACE => true,
LBRACKET => true,
@ -234,7 +234,7 @@ pure fn can_begin_expr(t: token) -> bool {
/// what's the opposite delimiter?
fn flip_delimiter(&t: token::token) -> token::token {
alt t {
match t {
token::LPAREN => token::RPAREN,
token::LBRACE => token::RBRACE,
token::LBRACKET => token::RBRACKET,
@ -248,7 +248,7 @@ fn flip_delimiter(&t: token::token) -> token::token {
fn is_lit(t: token) -> bool {
alt t {
match t {
LIT_INT(_, _) => true,
LIT_UINT(_, _) => true,
LIT_INT_UNSUFFIXED(_) => true,
@ -259,22 +259,22 @@ fn is_lit(t: token) -> bool {
}
pure fn is_ident(t: token) -> bool {
alt t { IDENT(_, _) => true, _ => false }
match t { IDENT(_, _) => true, _ => false }
}
pure fn is_ident_or_path(t: token) -> bool {
alt t {
match t {
IDENT(_, _) | INTERPOLATED(nt_path(*)) => true,
_ => false
}
}
pure fn is_plain_ident(t: token) -> bool {
alt t { IDENT(_, false) => true, _ => false }
match t { IDENT(_, false) => true, _ => false }
}
pure fn is_bar(t: token) -> bool {
alt t { BINOP(OR) | OROR => true, _ => false }
match t { BINOP(OR) | OROR => true, _ => false }
}
/**
@ -333,7 +333,7 @@ fn contextual_keyword_table() -> hashmap<~str, ()> {
fn restricted_keyword_table() -> hashmap<~str, ()> {
let words = str_hash();
let keys = ~[
~"alt", ~"again", ~"assert",
~"again", ~"assert",
~"break",
~"check", ~"class", ~"const", ~"copy",
~"do", ~"drop",

12
src/libsyntax/print/pp.rs
View file

@ -62,7 +62,7 @@ type begin_t = {offset: int, breaks: breaks};
enum token { STRING(@~str, int), BREAK(break_t), BEGIN(begin_t), END, EOF, }
fn tok_str(++t: token) -> ~str {
alt t {
match t {
STRING(s, len) => return fmt!{"STR(%s,%d)", *s, len},
BREAK(_) => return ~"BREAK",
BEGIN(_) => return ~"BEGIN",
@ -238,7 +238,7 @@ impl printer for printer {
fn replace_last_token(t: token) { self.token[self.right] = t; }
fn pretty_print(t: token) {
debug!{"pp ~[%u,%u]", self.left, self.right};
alt t {
match t {
EOF => {
if !self.scan_stack_empty {
self.check_stack(0);
@ -357,7 +357,7 @@ impl printer for printer {
self.left, L};
if L >= 0 {
self.print(x, L);
alt x {
match x {
BREAK(b) => self.left_total += b.blank_space,
STRING(_, len) => { assert (len == L); self.left_total += len; }
_ => ()
@ -373,7 +373,7 @@ impl printer for printer {
fn check_stack(k: int) {
if !self.scan_stack_empty {
let x = self.scan_top();
alt copy self.token[x] {
match copy self.token[x] {
BEGIN(b) => {
if k > 0 {
self.size[self.scan_pop()] = self.size[x] +
@ -422,7 +422,7 @@ impl printer for printer {
debug!{"print %s %d (remaining line space=%d)", tok_str(x), L,
self.space};
log(debug, buf_str(self.token, self.size, self.left, self.right, 6u));
alt x {
match x {
BEGIN(b) => {
if L > self.space {
let col = self.margin - self.space + b.offset;
@ -442,7 +442,7 @@ impl printer for printer {
}
BREAK(b) => {
let top = self.get_top();
alt top.pbreak {
match top.pbreak {
fits => {
debug!{"print BREAK in fitting block"};
self.space -= b.blank_space;

152
src/libsyntax/print/pprust.rs
View file

@ -222,11 +222,11 @@ fn bclose_(s: ps, span: codemap::span, indented: uint) {
fn bclose(s: ps, span: codemap::span) { bclose_(s, span, indent_unit); }
fn is_begin(s: ps) -> bool {
alt s.s.last_token() { pp::BEGIN(_) => true, _ => false }
match s.s.last_token() { pp::BEGIN(_) => true, _ => false }
}
fn is_end(s: ps) -> bool {
alt s.s.last_token() { pp::END => true, _ => false }
match s.s.last_token() { pp::END => true, _ => false }
}
fn is_bol(s: ps) -> bool {
@ -318,7 +318,7 @@ fn print_foreign_mod(s: ps, nmod: ast::foreign_mod,
}
fn print_region(s: ps, region: @ast::region) {
alt region.node {
match region.node {
ast::re_anon => word_space(s, ~"&"),
ast::re_named(name) => {
word(s.s, ~"&");
@ -334,14 +334,14 @@ fn print_type(s: ps, &&ty: @ast::ty) {
fn print_type_ex(s: ps, &&ty: @ast::ty, print_colons: bool) {
maybe_print_comment(s, ty.span.lo);
ibox(s, 0u);
alt ty.node {
match ty.node {
ast::ty_nil => word(s.s, ~"()"),
ast::ty_bot => word(s.s, ~"!"),
ast::ty_box(mt) => { word(s.s, ~"@"); print_mt(s, mt); }
ast::ty_uniq(mt) => { word(s.s, ~"~"); print_mt(s, mt); }
ast::ty_vec(mt) => {
word(s.s, ~"[");
alt mt.mutbl {
match mt.mutbl {
ast::m_mutbl => word_space(s, ~"mut"),
ast::m_const => word_space(s, ~"const"),
ast::m_imm => ()
@ -351,7 +351,7 @@ fn print_type_ex(s: ps, &&ty: @ast::ty, print_colons: bool) {
}
ast::ty_ptr(mt) => { word(s.s, ~"*"); print_mt(s, mt); }
ast::ty_rptr(region, mt) => {
alt region.node {
match region.node {
ast::re_anon => word(s.s, ~"&"),
_ => { print_region(s, region); word(s.s, ~"/"); }
}
@ -400,7 +400,7 @@ fn print_foreign_item(s: ps, item: @ast::foreign_item) {
hardbreak_if_not_bol(s);
maybe_print_comment(s, item.span.lo);
print_outer_attributes(s, item.attrs);
alt item.node {
match item.node {
ast::foreign_item_fn(decl, typarams) => {
print_fn(s, decl, item.ident, typarams);
end(s); // end head-ibox
@ -416,7 +416,7 @@ fn print_item(s: ps, &&item: @ast::item) {
print_outer_attributes(s, item.attrs);
let ann_node = node_item(s, item);
s.ann.pre(ann_node);
alt item.node {
match item.node {
ast::item_const(ty, expr) => {
head(s, ~"const");
word_space(s, *item.ident + ~":");
@ -538,7 +538,7 @@ fn print_item(s: ps, &&item: @ast::item) {
hardbreak_if_not_bol(s);
maybe_print_comment(s, ci.span.lo);
let pr = ast_util::class_member_visibility(ci);
alt pr {
match pr {
ast::private => {
head(s, ~"priv");
bopen(s);
@ -546,10 +546,10 @@ fn print_item(s: ps, &&item: @ast::item) {
}
_ => ()
}
alt ci.node {
match ci.node {
ast::instance_var(nm, t, mt, _,_) => {
word_nbsp(s, ~"let");
alt mt {
match mt {
ast::class_mutable => word_nbsp(s, ~"mut"),
_ => ()
}
@ -562,7 +562,7 @@ fn print_item(s: ps, &&item: @ast::item) {
print_method(s, m);
}
}
alt pr {
match pr {
ast::private => bclose(s, ci.span),
_ => ()
}
@ -625,10 +625,10 @@ fn print_item(s: ps, &&item: @ast::item) {
/// and then pretty-print the resulting AST nodes (so, e.g., we print
/// expression arguments as expressions). It can be done! I think.
fn print_tt(s: ps, tt: ast::token_tree) {
alt tt {
match tt {
ast::tt_delim(tts) => for tts.each() |tt_elt| { print_tt(s, tt_elt); }
ast::tt_tok(_, tk) => {
alt tk {
match tk {
parse::token::IDENT(*) => { // don't let idents run together
if s.s.token_tree_last_was_ident { word(s.s, ~" ") }
s.s.token_tree_last_was_ident = true;
@ -641,7 +641,7 @@ fn print_tt(s: ps, tt: ast::token_tree) {
word(s.s, ~"$(");
for tts.each() |tt_elt| { print_tt(s, tt_elt); }
word(s.s, ~")");
alt sep {
match sep {
some(tk) => word(s.s, parse::token::to_str(*s.intr, tk)),
none => ()
}
@ -665,7 +665,7 @@ fn print_variant(s: ps, v: ast::variant) {
commasep(s, consistent, v.node.args, print_variant_arg);
pclose(s);
}
alt v.node.disr_expr {
match v.node.disr_expr {
some(d) => {
space(s.s);
word_space(s, ~"=");
@ -684,7 +684,7 @@ fn print_ty_method(s: ps, m: ast::ty_method) {
}
fn print_trait_method(s: ps, m: ast::trait_method) {
alt m {
match m {
required(ty_m) => print_ty_method(s, ty_m),
provided(m) => print_method(s, m)
}
@ -702,7 +702,7 @@ fn print_method(s: ps, meth: @ast::method) {
fn print_outer_attributes(s: ps, attrs: ~[ast::attribute]) {
let mut count = 0;
for attrs.each |attr| {
alt attr.node.style {
match attr.node.style {
ast::attr_outer => { print_attribute(s, attr); count += 1; }
_ => {/* fallthrough */ }
}
@ -713,7 +713,7 @@ fn print_outer_attributes(s: ps, attrs: ~[ast::attribute]) {
fn print_inner_attributes(s: ps, attrs: ~[ast::attribute]) {
let mut count = 0;
for attrs.each |attr| {
alt attr.node.style {
match attr.node.style {
ast::attr_inner => {
print_attribute(s, attr);
if !attr.node.is_sugared_doc {
@ -744,7 +744,7 @@ fn print_attribute(s: ps, attr: ast::attribute) {
fn print_stmt(s: ps, st: ast::stmt) {
maybe_print_comment(s, st.span.lo);
alt st.node {
match st.node {
ast::stmt_decl(decl, _) => {
print_decl(s, decl);
}
@ -780,7 +780,7 @@ fn print_possibly_embedded_block(s: ps, blk: ast::blk, embedded: embed_type,
fn print_possibly_embedded_block_(s: ps, blk: ast::blk, embedded: embed_type,
indented: uint, attrs: ~[ast::attribute]) {
alt blk.node.rules {
match blk.node.rules {
ast::unchecked_blk => word(s.s, ~"unchecked"),
ast::unsafe_blk => word(s.s, ~"unsafe"),
ast::default_blk => ()
@ -788,7 +788,7 @@ fn print_possibly_embedded_block_(s: ps, blk: ast::blk, embedded: embed_type,
maybe_print_comment(s, blk.span.lo);
let ann_node = node_block(s, blk);
s.ann.pre(ann_node);
alt embedded {
match embedded {
block_block_fn => end(s),
block_normal => bopen(s)
}
@ -799,7 +799,7 @@ fn print_possibly_embedded_block_(s: ps, blk: ast::blk, embedded: embed_type,
for blk.node.stmts.each |st| {
print_stmt(s, *st);
}
alt blk.node.expr {
match blk.node.expr {
some(expr) => {
space_if_not_bol(s);
print_expr(s, expr);
@ -814,7 +814,7 @@ fn print_possibly_embedded_block_(s: ps, blk: ast::blk, embedded: embed_type,
// return and fail, without arguments cannot appear is the discriminant of if,
// alt, do, & while unambiguously without being parenthesized
fn print_maybe_parens_discrim(s: ps, e: @ast::expr) {
let disambig = alt e.node {
let disambig = match e.node {
ast::expr_ret(none) | ast::expr_fail(none) => true,
_ => false
};
@ -831,9 +831,9 @@ fn print_if(s: ps, test: @ast::expr, blk: ast::blk,
space(s.s);
print_block(s, blk);
fn do_else(s: ps, els: option<@ast::expr>) {
alt els {
match els {
some(_else) => {
alt _else.node {
match _else.node {
// "another else-if"
ast::expr_if(i, t, e) => {
cbox(s, indent_unit - 1u);
@ -864,11 +864,11 @@ fn print_if(s: ps, test: @ast::expr, blk: ast::blk,
}
fn print_mac(s: ps, m: ast::mac) {
alt m.node {
match m.node {
ast::mac_invoc(path, arg, body) => {
word(s.s, ~"#");
print_path(s, path, false);
alt arg {
match arg {
some(@{node: ast::expr_vec(_, _), _}) => (),
_ => word(s.s, ~" ")
}
@ -888,12 +888,12 @@ fn print_mac(s: ps, m: ast::mac) {
}
fn print_vstore(s: ps, t: ast::vstore) {
alt t {
match t {
ast::vstore_fixed(some(i)) => word(s.s, fmt!{"%u", i}),
ast::vstore_fixed(none) => word(s.s, ~"_"),
ast::vstore_uniq => word(s.s, ~"~"),
ast::vstore_box => word(s.s, ~"@"),
ast::vstore_slice(r) => alt r.node {
ast::vstore_slice(r) => match r.node {
ast::re_anon => word(s.s, ~"&"),
ast::re_named(name) => {
word(s.s, ~"&");
@ -919,8 +919,8 @@ fn print_expr(s: ps, &&expr: @ast::expr) {
ibox(s, indent_unit);
let ann_node = node_expr(s, expr);
s.ann.pre(ann_node);
alt expr.node {
ast::expr_vstore(e, v) => alt v {
match expr.node {
ast::expr_vstore(e, v) => match v {
ast::vstore_fixed(_) => {
print_expr(s, e);
word(s.s, ~"/");
@ -961,7 +961,7 @@ fn print_expr(s: ps, &&expr: @ast::expr) {
ast::expr_rec(fields, wth) => {
word(s.s, ~"{");
commasep_cmnt(s, consistent, fields, print_field, get_span);
alt wth {
match wth {
some(expr) => {
if vec::len(fields) > 0u { space(s.s); }
ibox(s, indent_unit);
@ -977,7 +977,7 @@ fn print_expr(s: ps, &&expr: @ast::expr) {
print_path(s, path, true);
word(s.s, ~"{");
commasep_cmnt(s, consistent, fields, print_field, get_span);
alt wth {
match wth {
some(expr) => {
if vec::len(fields) > 0u { space(s.s); }
ibox(s, indent_unit);
@ -998,7 +998,7 @@ fn print_expr(s: ps, &&expr: @ast::expr) {
let mut base_args = args;
let blk = if has_block {
let blk_arg = vec::pop(base_args);
alt blk_arg.node {
match blk_arg.node {
ast::expr_loop_body(_) => word_nbsp(s, ~"for"),
ast::expr_do_body(_) => word_nbsp(s, ~"do"),
_ => ()
@ -1056,7 +1056,7 @@ fn print_expr(s: ps, &&expr: @ast::expr) {
ast::expr_alt(expr, arms, mode) => {
cbox(s, alt_indent_unit);
ibox(s, 4u);
word_nbsp(s, ~"alt");
word_nbsp(s, ~"match");
if mode == ast::alt_check { word_nbsp(s, ~"check"); }
print_maybe_parens_discrim(s, expr);
space(s.s);
@ -1074,7 +1074,7 @@ fn print_expr(s: ps, &&expr: @ast::expr) {
print_pat(s, p);
}
space(s.s);
alt arm.guard {
match arm.guard {
some(e) => {
word_space(s, ~"if");
print_expr(s, e);
@ -1087,7 +1087,7 @@ fn print_expr(s: ps, &&expr: @ast::expr) {
assert arm.body.node.view_items.is_empty();
assert arm.body.node.stmts.is_empty();
assert arm.body.node.rules == ast::default_blk;
alt arm.body.node.expr {
match arm.body.node.expr {
some(expr) => {
end(s); // close the ibox for the pattern
print_expr(s, expr);
@ -1185,7 +1185,7 @@ fn print_expr(s: ps, &&expr: @ast::expr) {
ast::expr_path(path) => print_path(s, path, true),
ast::expr_fail(maybe_fail_val) => {
word(s.s, ~"fail");
alt maybe_fail_val {
match maybe_fail_val {
some(expr) => { word(s.s, ~" "); print_expr(s, expr); }
_ => ()
}
@ -1194,13 +1194,13 @@ fn print_expr(s: ps, &&expr: @ast::expr) {
ast::expr_again => word(s.s, ~"again"),
ast::expr_ret(result) => {
word(s.s, ~"return");
alt result {
match result {
some(expr) => { word(s.s, ~" "); print_expr(s, expr); }
_ => ()
}
}
ast::expr_log(lvl, lexp, expr) => {
alt check lvl {
match check lvl {
1 => { word_nbsp(s, ~"log"); print_expr(s, expr); }
0 => { word_nbsp(s, ~"log_err"); print_expr(s, expr); }
2 => {
@ -1225,7 +1225,7 @@ fn print_expr(s: ps, &&expr: @ast::expr) {
}
fn print_expr_parens_if_not_bot(s: ps, ex: @ast::expr) {
let parens = alt ex.node {
let parens = match ex.node {
ast::expr_fail(_) | ast::expr_ret(_) |
ast::expr_binary(_, _, _) | ast::expr_unary(_, _) |
ast::expr_move(_, _) | ast::expr_copy(_) |
@ -1243,7 +1243,7 @@ fn print_expr_parens_if_not_bot(s: ps, ex: @ast::expr) {
fn print_local_decl(s: ps, loc: @ast::local) {
print_pat(s, loc.node.pat);
alt loc.node.ty.node {
match loc.node.ty.node {
ast::ty_infer => (),
_ => { word_space(s, ~":"); print_type(s, loc.node.ty); }
}
@ -1251,7 +1251,7 @@ fn print_local_decl(s: ps, loc: @ast::local) {
fn print_decl(s: ps, decl: @ast::decl) {
maybe_print_comment(s, decl.span.lo);
alt decl.node {
match decl.node {
ast::decl_local(locs) => {
space_if_not_bol(s);
ibox(s, indent_unit);
@ -1267,10 +1267,10 @@ fn print_decl(s: ps, decl: @ast::decl) {
ibox(s, indent_unit);
print_local_decl(s, loc);
end(s);
alt loc.node.init {
match loc.node.init {
some(init) => {
nbsp(s);
alt init.op {
match init.op {
ast::init_assign => word_space(s, ~"="),
ast::init_move => word_space(s, ~"<-")
}
@ -1306,7 +1306,7 @@ fn print_path(s: ps, &&path: @ast::path, colons_before_params: bool) {
if path.rp.is_some() || !path.types.is_empty() {
if colons_before_params { word(s.s, ~"::"); }
alt path.rp {
match path.rp {
none => { /* ok */ }
some(r) => {
word(s.s, ~"/");
@ -1328,22 +1328,22 @@ fn print_pat(s: ps, &&pat: @ast::pat) {
s.ann.pre(ann_node);
/* Pat isn't normalized, but the beauty of it
is that it doesn't matter */
alt pat.node {
match pat.node {
ast::pat_wild => word(s.s, ~"_"),
ast::pat_ident(binding_mode, path, sub) => {
alt binding_mode {
match binding_mode {
ast::bind_by_ref => word_space(s, ~"ref"),
ast::bind_by_value => ()
}
print_path(s, path, true);
alt sub {
match sub {
some(p) => { word(s.s, ~"@"); print_pat(s, p); }
none => ()
}
}
ast::pat_enum(path, args_) => {
print_path(s, path, true);
alt args_ {
match args_ {
none => word(s.s, ~"(*)"),
some(args) => {
if vec::len(args) > 0u {
@ -1391,7 +1391,7 @@ fn print_pat(s: ps, &&pat: @ast::pat) {
fn print_fn(s: ps, decl: ast::fn_decl, name: ast::ident,
typarams: ~[ast::ty_param]) {
alt decl.purity {
match decl.purity {
ast::impure_fn => head(s, ~"fn"),
_ => head(s, purity_to_str(decl.purity) + ~" fn")
}
@ -1442,7 +1442,7 @@ fn print_fn_block_args(s: ps, decl: ast::fn_decl,
}
fn mode_to_str(m: ast::mode) -> ~str {
alt m {
match m {
ast::expl(ast::by_mutbl_ref) => ~"&",
ast::expl(ast::by_move) => ~"-",
ast::expl(ast::by_ref) => ~"&&",
@ -1462,7 +1462,7 @@ fn print_bounds(s: ps, bounds: @~[ast::ty_param_bound]) {
word(s.s, ~":");
for vec::each(*bounds) |bound| {
nbsp(s);
alt bound {
match bound {
ast::bound_copy => word(s.s, ~"copy"),
ast::bound_send => word(s.s, ~"send"),
ast::bound_const => word(s.s, ~"const"),
@ -1487,7 +1487,7 @@ fn print_type_params(s: ps, &&params: ~[ast::ty_param]) {
fn print_meta_item(s: ps, &&item: @ast::meta_item) {
ibox(s, indent_unit);
alt item.node {
match item.node {
ast::meta_word(name) => word(s.s, *name),
ast::meta_name_value(name, value) => {
word_space(s, *name);
@ -1505,7 +1505,7 @@ fn print_meta_item(s: ps, &&item: @ast::meta_item) {
}
fn print_view_path(s: ps, &&vp: @ast::view_path) {
alt vp.node {
match vp.node {
ast::view_path_simple(ident, path, _) => {
if path.idents[vec::len(path.idents)-1u] != ident {
word_space(s, *ident);
@ -1538,7 +1538,7 @@ fn print_view_item(s: ps, item: @ast::view_item) {
hardbreak_if_not_bol(s);
maybe_print_comment(s, item.span.lo);
print_outer_attributes(s, item.attrs);
alt item.node {
match item.node {
ast::view_item_use(id, mta, _) => {
head(s, ~"use");
word(s.s, *id);
@ -1572,7 +1572,7 @@ fn print_op_maybe_parens(s: ps, expr: @ast::expr, outer_prec: uint) {
}
fn print_mutability(s: ps, mutbl: ast::mutability) {
alt mutbl {
match mutbl {
ast::m_mutbl => word_nbsp(s, ~"mut"),
ast::m_const => word_nbsp(s, ~"const"),
ast::m_imm => {/* nothing */ }
@ -1587,7 +1587,7 @@ fn print_mt(s: ps, mt: ast::mt) {
fn print_arg(s: ps, input: ast::arg) {
ibox(s, indent_unit);
print_arg_mode(s, input.mode);
alt input.ty.node {
match input.ty.node {
ast::ty_infer => word(s.s, *input.ident),
_ => {
if str::len(*input.ident) > 0u {
@ -1604,8 +1604,8 @@ fn print_ty_fn(s: ps, opt_proto: option<ast::proto>,
tps: option<~[ast::ty_param]>) {
ibox(s, indent_unit);
word(s.s, opt_proto_to_str(opt_proto));
alt id { some(id) => { word(s.s, ~" "); word(s.s, *id); } _ => () }
alt tps { some(tps) => print_type_params(s, tps), _ => () }
match id { some(id) => { word(s.s, ~" "); word(s.s, *id); } _ => () }
match tps { some(tps) => print_type_params(s, tps), _ => () }
zerobreak(s.s);
popen(s);
commasep(s, inconsistent, decl.inputs, print_arg);
@ -1625,14 +1625,14 @@ fn print_ty_fn(s: ps, opt_proto: option<ast::proto>,
fn maybe_print_trailing_comment(s: ps, span: codemap::span,
next_pos: option<uint>) {
let mut cm;
alt s.cm { some(ccm) => cm = ccm, _ => return }
alt next_comment(s) {
match s.cm { some(ccm) => cm = ccm, _ => return }
match next_comment(s) {
some(cmnt) => {
if cmnt.style != comments::trailing { return; }
let span_line = codemap::lookup_char_pos(cm, span.hi);
let comment_line = codemap::lookup_char_pos(cm, cmnt.pos);
let mut next = cmnt.pos + 1u;
alt next_pos { none => (), some(p) => next = p }
match next_pos { none => (), some(p) => next = p }
if span.hi < cmnt.pos && cmnt.pos < next &&
span_line.line == comment_line.line {
print_comment(s, cmnt);
@ -1648,7 +1648,7 @@ fn print_remaining_comments(s: ps) {
// make sure there is a line break at the end.
if option::is_none(next_comment(s)) { hardbreak(s.s); }
loop {
alt next_comment(s) {
match next_comment(s) {
some(cmnt) => { print_comment(s, cmnt); s.cur_cmnt += 1u; }
_ => break
}
@ -1657,14 +1657,14 @@ fn print_remaining_comments(s: ps) {
fn print_literal(s: ps, &&lit: @ast::lit) {
maybe_print_comment(s, lit.span.lo);
alt next_lit(s, lit.span.lo) {
match next_lit(s, lit.span.lo) {
some(ltrl) => {
word(s.s, ltrl.lit);
return;
}
_ => ()
}
alt lit.node {
match lit.node {
ast::lit_str(st) => print_string(s, *st),
ast::lit_int(ch, ast::ty_char) => {
word(s.s, ~"'" + char::escape_default(ch as char) + ~"'");
@ -1705,7 +1705,7 @@ fn print_literal(s: ps, &&lit: @ast::lit) {
fn lit_to_str(l: @ast::lit) -> ~str { return to_str(l, print_literal); }
fn next_lit(s: ps, pos: uint) -> option<comments::lit> {
alt s.literals {
match s.literals {
some(lits) => {
while s.cur_lit < vec::len(lits) {
let ltrl = lits[s.cur_lit];
@ -1721,7 +1721,7 @@ fn next_lit(s: ps, pos: uint) -> option<comments::lit> {
fn maybe_print_comment(s: ps, pos: uint) {
loop {
alt next_comment(s) {
match next_comment(s) {
some(cmnt) => {
if cmnt.pos < pos {
print_comment(s, cmnt);
@ -1734,7 +1734,7 @@ fn maybe_print_comment(s: ps, pos: uint) {
}
fn print_comment(s: ps, cmnt: comments::cmnt) {
alt cmnt.style {
match cmnt.style {
comments::mixed => {
assert (vec::len(cmnt.lines) == 1u);
zerobreak(s.s);
@ -1767,7 +1767,7 @@ fn print_comment(s: ps, cmnt: comments::cmnt) {
comments::blank_line => {
// We need to do at least one, possibly two hardbreaks.
let is_semi =
alt s.s.last_token() {
match s.s.last_token() {
pp::STRING(s, _) => *s == ~";",
_ => false
};
@ -1792,7 +1792,7 @@ fn to_str<T>(t: T, f: fn@(ps, T)) -> ~str {
}
fn next_comment(s: ps) -> option<comments::cmnt> {
alt s.comments {
match s.comments {
some(cmnts) => {
if s.cur_cmnt < vec::len(cmnts) {
return some(cmnts[s.cur_cmnt]);
@ -1803,14 +1803,14 @@ fn next_comment(s: ps) -> option<comments::cmnt> {
}
fn opt_proto_to_str(opt_p: option<ast::proto>) -> ~str {
alt opt_p {
match opt_p {
none => ~"fn",
some(p) => proto_to_str(p)
}
}
pure fn purity_to_str(p: ast::purity) -> ~str {
alt p {
match p {
ast::impure_fn => ~"impure",
ast::unsafe_fn => ~"unsafe",
ast::pure_fn => ~"pure",
@ -1819,14 +1819,14 @@ pure fn purity_to_str(p: ast::purity) -> ~str {
}
fn print_purity(s: ps, p: ast::purity) {
alt p {
match p {
ast::impure_fn => (),
_ => word_nbsp(s, purity_to_str(p))
}
}
fn proto_to_str(p: ast::proto) -> ~str {
return alt p {
return match p {
ast::proto_bare => ~"extern fn",
ast::proto_block => ~"fn&",
ast::proto_uniq => ~"fn~",

2
src/libsyntax/util/interner.rs
View file

@ -27,7 +27,7 @@ trait interner<T: const copy> {
impl <T: const copy> of interner<T> for hash_interner<T> {
fn intern(val: T) -> uint {
alt self.map.find(val) {
match self.map.find(val) {
some(idx) => return idx,
none => {
let new_idx = self.vect.len();

32
src/libsyntax/visit.rs
View file

@ -25,7 +25,7 @@ enum fn_kind {
}
fn name_of_fn(fk: fn_kind) -> ident {
alt fk {
match fk {
fk_item_fn(name, _) | fk_method(name, _, _)
| fk_ctor(name, _, _, _, _) => /* FIXME (#2543) */ copy name,
fk_anon(*) | fk_fn_block(*) => @~"anon",
@ -34,7 +34,7 @@ fn name_of_fn(fk: fn_kind) -> ident {
}
fn tps_of_fn(fk: fn_kind) -> ~[ty_param] {
alt fk {
match fk {
fk_item_fn(_, tps) | fk_method(_, tps, _)
| fk_ctor(_, _, tps, _, _) | fk_dtor(tps, _, _, _) => {
/* FIXME (#2543) */ copy tps
@ -89,7 +89,7 @@ fn visit_crate<E>(c: crate, e: E, v: vt<E>) {
}
fn visit_crate_directive<E>(cd: @crate_directive, e: E, v: vt<E>) {
alt cd.node {
match cd.node {
cdir_src_mod(_, _) => (),
cdir_dir_mod(_, cdirs, _) => for cdirs.each |cdir| {
visit_crate_directive(cdir, e, v);
@ -109,14 +109,14 @@ fn visit_view_item<E>(_vi: @view_item, _e: E, _v: vt<E>) { }
fn visit_local<E>(loc: @local, e: E, v: vt<E>) {
v.visit_pat(loc.node.pat, e, v);
v.visit_ty(loc.node.ty, e, v);
alt loc.node.init {
match loc.node.init {
none => (),
some(i) => v.visit_expr(i.expr, e, v)
}
}
fn visit_item<E>(i: @item, e: E, v: vt<E>) {
alt i.node {
match i.node {
item_const(t, ex) => { v.visit_ty(t, e, v); v.visit_expr(ex, e, v); }
item_fn(decl, tp, body) => {
v.visit_fn(fk_item_fn(/* FIXME (#2543) */ copy i.ident,
@ -175,7 +175,7 @@ fn visit_item<E>(i: @item, e: E, v: vt<E>) {
}
fn visit_class_item<E>(cm: @class_member, e:E, v:vt<E>) {
alt cm.node {
match cm.node {
instance_var(_, t, _, _, _) => v.visit_ty(t, e, v),
class_method(m) => visit_method_helper(m, e, v)
}
@ -184,7 +184,7 @@ fn visit_class_item<E>(cm: @class_member, e:E, v:vt<E>) {
fn skip_ty<E>(_t: @ty, _e: E, _v: vt<E>) {}
fn visit_ty<E>(t: @ty, e: E, v: vt<E>) {
alt t.node {
match t.node {
ty_box(mt) | ty_uniq(mt) |
ty_vec(mt) | ty_ptr(mt) | ty_rptr(_, mt) => {
v.visit_ty(mt.ty, e, v);
@ -213,7 +213,7 @@ fn visit_path<E>(p: @path, e: E, v: vt<E>) {
}
fn visit_pat<E>(p: @pat, e: E, v: vt<E>) {
alt p.node {
match p.node {
pat_enum(path, children) => {
visit_path(path, e, v);
do option::iter(children) |children| {
@ -237,7 +237,7 @@ fn visit_pat<E>(p: @pat, e: E, v: vt<E>) {
}
fn visit_foreign_item<E>(ni: @foreign_item, e: E, v: vt<E>) {
alt ni.node {
match ni.node {
foreign_item_fn(fd, tps) => {
v.visit_ty_params(tps, e, v);
visit_fn_decl(fd, e, v);
@ -248,7 +248,7 @@ fn visit_foreign_item<E>(ni: @foreign_item, e: E, v: vt<E>) {
fn visit_ty_params<E>(tps: ~[ty_param], e: E, v: vt<E>) {
for tps.each |tp| {
for vec::each(*tp.bounds) |bound| {
alt bound {
match bound {
bound_trait(t) => v.visit_ty(t, e, v),
bound_copy | bound_send | bound_const | bound_owned => ()
}
@ -304,7 +304,7 @@ fn visit_ty_method<E>(m: ty_method, e: E, v: vt<E>) {
}
fn visit_trait_method<E>(m: trait_method, e: E, v: vt<E>) {
alt m {
match m {
required(ty_m) => v.visit_ty_method(ty_m, e, v),
provided(m) => visit_method_helper(m, e, v)
}
@ -317,7 +317,7 @@ fn visit_block<E>(b: ast::blk, e: E, v: vt<E>) {
}
fn visit_stmt<E>(s: @stmt, e: E, v: vt<E>) {
alt s.node {
match s.node {
stmt_decl(d, _) => v.visit_decl(d, e, v),
stmt_expr(ex, _) => v.visit_expr(ex, e, v),
stmt_semi(ex, _) => v.visit_expr(ex, e, v)
@ -325,7 +325,7 @@ fn visit_stmt<E>(s: @stmt, e: E, v: vt<E>) {
}
fn visit_decl<E>(d: @decl, e: E, v: vt<E>) {
alt d.node {
match d.node {
decl_local(locs) => for locs.each |loc| {
v.visit_local(loc, e, v)
}
@ -334,7 +334,7 @@ fn visit_decl<E>(d: @decl, e: E, v: vt<E>) {
}
fn visit_expr_opt<E>(eo: option<@expr>, e: E, v: vt<E>) {
alt eo { none => (), some(ex) => v.visit_expr(ex, e, v) }
match eo { none => (), some(ex) => v.visit_expr(ex, e, v) }
}
fn visit_exprs<E>(exprs: ~[@expr], e: E, v: vt<E>) {
@ -342,7 +342,7 @@ fn visit_exprs<E>(exprs: ~[@expr], e: E, v: vt<E>) {
}
fn visit_mac<E>(m: mac, e: E, v: vt<E>) {
alt m.node {
match m.node {
ast::mac_invoc(pth, arg, body) => {
option::map(arg, |arg| v.visit_expr(arg, e, v)); }
ast::mac_invoc_tt(pth, tt) => { /* no user-serviceable parts inside */ }
@ -353,7 +353,7 @@ fn visit_mac<E>(m: mac, e: E, v: vt<E>) {
}
fn visit_expr<E>(ex: @expr, e: E, v: vt<E>) {
alt ex.node {
match ex.node {
expr_vstore(x, _) => v.visit_expr(x, e, v),
expr_vec(es, _) => visit_exprs(es, e, v),
expr_repeat(element, count, _) => {

24
src/rustc/back/link.rs
View file

@ -61,7 +61,7 @@ mod write {
// and the extension to use.
fn mk_intermediate_name(output_path: ~str, extension: ~str) ->
~str unsafe {
let stem = alt str::find_char(output_path, '.') {
let stem = match str::find_char(output_path, '.') {
some(dot_pos) => str::slice(output_path, 0u, dot_pos),
none => output_path
};
@ -82,7 +82,7 @@ mod write {
// specified.
if opts.save_temps {
alt opts.output_type {
match opts.output_type {
output_type_bitcode => {
if opts.optimize != 0u {
let filename = mk_intermediate_name(output, ~"no-opt.bc");
@ -146,7 +146,7 @@ mod write {
let LLVMOptDefault = 2 as c_int; // -O2, -Os
let LLVMOptAggressive = 3 as c_int; // -O3
let mut CodeGenOptLevel = alt check opts.optimize {
let mut CodeGenOptLevel = match check opts.optimize {
0u => LLVMOptNone,
1u => LLVMOptLess,
2u => LLVMOptDefault,
@ -323,12 +323,12 @@ fn build_link_meta(sess: session, c: ast::crate, output: ~str,
attr::require_unique_names(sess.diagnostic(), linkage_metas);
for linkage_metas.each |meta| {
if *attr::get_meta_item_name(meta) == ~"name" {
alt attr::get_meta_item_value_str(meta) {
match attr::get_meta_item_value_str(meta) {
some(v) => { name = some(v); }
none => vec::push(cmh_items, meta)
}
} else if *attr::get_meta_item_name(meta) == ~"vers" {
alt attr::get_meta_item_value_str(meta) {
match attr::get_meta_item_value_str(meta) {
some(v) => { vers = some(v); }
none => vec::push(cmh_items, meta)
}
@ -355,7 +355,7 @@ fn build_link_meta(sess: session, c: ast::crate, output: ~str,
symbol_hasher.reset();
for cmh_items.each |m_| {
let m = m_;
alt m.node {
match m.node {
ast::meta_name_value(key, value) => {
symbol_hasher.write_str(len_and_str(*key));
symbol_hasher.write_str(len_and_str_lit(value));
@ -385,7 +385,7 @@ fn build_link_meta(sess: session, c: ast::crate, output: ~str,
fn crate_meta_name(sess: session, _crate: ast::crate,
output: ~str, metas: provided_metas) -> @~str {
return alt metas.name {
return match metas.name {
some(v) => v,
none => {
let name =
@ -407,7 +407,7 @@ fn build_link_meta(sess: session, c: ast::crate, output: ~str,
fn crate_meta_vers(sess: session, _crate: ast::crate,
metas: provided_metas) -> @~str {
return alt metas.vers {
return match metas.vers {
some(v) => v,
none => {
let vers = ~"0.0";
@ -451,7 +451,7 @@ fn symbol_hash(tcx: ty::ctxt, symbol_hasher: &hash::State, t: ty::t,
}
fn get_symbol_hash(ccx: @crate_ctxt, t: ty::t) -> ~str {
alt ccx.type_hashcodes.find(t) {
match ccx.type_hashcodes.find(t) {
some(h) => return h,
none => {
let hash = symbol_hash(ccx.tcx, ccx.symbol_hasher, t, ccx.link_meta);
@ -467,7 +467,7 @@ fn get_symbol_hash(ccx: @crate_ctxt, t: ty::t) -> ~str {
fn sanitize(s: ~str) -> ~str {
let mut result = ~"";
do str::chars_iter(s) |c| {
alt c {
match c {
'@' => result += ~"_sbox_",
'~' => result += ~"_ubox_",
'*' => result += ~"_ptr_",
@ -503,7 +503,7 @@ fn mangle(ss: path) -> ~str {
let mut n = ~"_ZN"; // Begin name-sequence.
for ss.each |s| {
alt s { path_name(s) | path_mod(s) => {
match s { path_name(s) | path_mod(s) => {
let sani = sanitize(*s);
n += fmt!{"%u%s", str::len(sani), sani};
} }
@ -566,7 +566,7 @@ fn link_binary(sess: session,
vec::pop(parts);
return str::connect(parts, ~".");
}
return alt config.os {
return match config.os {
session::os_macos => rmext(rmlib(filename)),
session::os_linux => rmext(rmlib(filename)),
session::os_freebsd => rmext(rmlib(filename)),

4
src/rustc/back/rpath.rs
View file

@ -7,7 +7,7 @@ import metadata::filesearch;
export get_rpath_flags;
pure fn not_win32(os: session::os) -> bool {
alt os {
match os {
session::os_win32 => false,
_ => true
}
@ -108,7 +108,7 @@ fn get_rpath_relative_to_output(os: session::os,
assert not_win32(os);
// Mac doesn't appear to support $ORIGIN
let prefix = alt os {
let prefix = match os {
session::os_linux => ~"$ORIGIN" + path::path_sep(),
session::os_freebsd => ~"$ORIGIN" + path::path_sep(),
session::os_macos => ~"@executable_path" + path::path_sep(),

4
src/rustc/back/x86.rs
View file

@ -8,7 +8,7 @@ fn get_target_strs(target_os: session::os) -> target_strs::t {
meta_sect_name: meta_section_name(sess_os_to_meta_os(target_os)),
data_layout: alt target_os {
data_layout: match target_os {
session::os_macos => {
~"e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16" +
~"-i32:32:32-i64:32:64" +
@ -29,7 +29,7 @@ fn get_target_strs(target_os: session::os) -> target_strs::t {
}
},
target_triple: alt target_os {
target_triple: match target_os {
session::os_macos => ~"i686-apple-darwin",
session::os_win32 => ~"i686-pc-mingw32",
session::os_linux => ~"i686-unknown-linux-gnu",

4
src/rustc/back/x86_64.rs
View file

@ -8,7 +8,7 @@ fn get_target_strs(target_os: session::os) -> target_strs::t {
meta_sect_name: meta_section_name(sess_os_to_meta_os(target_os)),
data_layout: alt target_os {
data_layout: match target_os {
session::os_macos => {
~"e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-"+
~"f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-"+
@ -35,7 +35,7 @@ fn get_target_strs(target_os: session::os) -> target_strs::t {
}
},
target_triple: alt target_os {
target_triple: match target_os {
session::os_macos => ~"x86_64-apple-darwin",
session::os_win32 => ~"x86_64-pc-mingw32",
session::os_linux => ~"x86_64-unknown-linux-gnu",

50
src/rustc/driver/driver.rs
View file

@ -26,7 +26,7 @@ enum pp_mode {ppm_normal, ppm_expanded, ppm_typed, ppm_identified,
fn anon_src() -> ~str { ~"<anon>" }
fn source_name(input: input) -> ~str {
alt input {
match input {
file_input(ifile) => ifile,
str_input(_) => anon_src()
}
@ -34,7 +34,7 @@ fn source_name(input: input) -> ~str {
fn default_configuration(sess: session, argv0: ~str, input: input) ->
ast::crate_cfg {
let libc = alt sess.targ_cfg.os {
let libc = match sess.targ_cfg.os {
session::os_win32 => ~"msvcrt.dll",
session::os_macos => ~"libc.dylib",
session::os_linux => ~"libc.so.6",
@ -44,7 +44,7 @@ fn default_configuration(sess: session, argv0: ~str, input: input) ->
let mk = attr::mk_name_value_item_str;
let (arch,wordsz) = alt sess.targ_cfg.arch {
let (arch,wordsz) = match sess.targ_cfg.arch {
session::arch_x86 => (~"x86",~"32"),
session::arch_x86_64 => (~"x86_64",~"64"),
session::arch_arm => (~"arm",~"32")
@ -99,7 +99,7 @@ enum input {
fn parse_input(sess: session, cfg: ast::crate_cfg, input: input)
-> @ast::crate {
alt input {
match input {
file_input(file) => {
parse::parse_crate_from_file(file, cfg, sess.parse_sess)
}
@ -270,13 +270,13 @@ fn compile_input(sess: session, cfg: ast::crate_cfg, input: input,
fn pretty_print_input(sess: session, cfg: ast::crate_cfg, input: input,
ppm: pp_mode) {
fn ann_paren_for_expr(node: pprust::ann_node) {
alt node {
match node {
pprust::node_expr(s, expr) => pprust::popen(s),
_ => ()
}
}
fn ann_typed_post(tcx: ty::ctxt, node: pprust::ann_node) {
alt node {
match node {
pprust::node_expr(s, expr) => {
pp::space(s.s);
pp::word(s.s, ~"as");
@ -288,7 +288,7 @@ fn pretty_print_input(sess: session, cfg: ast::crate_cfg, input: input,
}
}
fn ann_identified_post(node: pprust::ann_node) {
alt node {
match node {
pprust::node_item(s, item) => {
pp::space(s.s);
pprust::synth_comment(s, int::to_str(item.id, 10u));
@ -314,14 +314,14 @@ fn pretty_print_input(sess: session, cfg: ast::crate_cfg, input: input,
// to collect comments and literals, and we need to support reading
// from stdin, we're going to just suck the source into a string
// so both the parser and pretty-printer can use it.
let upto = alt ppm {
let upto = match ppm {
ppm_expanded | ppm_expanded_identified => cu_expand,
ppm_typed => cu_typeck,
_ => cu_parse
};
let {crate, tcx} = compile_upto(sess, cfg, input, upto, none);
let ann = alt ppm {
let ann = match ppm {
ppm_typed => {
{pre: ann_paren_for_expr,
post: |a| ann_typed_post(option::get(tcx), a) }
@ -371,21 +371,21 @@ fn get_arch(triple: ~str) -> option<session::arch> {
fn build_target_config(sopts: @session::options,
demitter: diagnostic::emitter) -> @session::config {
let os = alt get_os(sopts.target_triple) {
let os = match get_os(sopts.target_triple) {
some(os) => os,
none => early_error(demitter, ~"unknown operating system")
};
let arch = alt get_arch(sopts.target_triple) {
let arch = match get_arch(sopts.target_triple) {
some(arch) => arch,
none => early_error(demitter,
~"unknown architecture: " + sopts.target_triple)
};
let (int_type, uint_type, float_type) = alt arch {
let (int_type, uint_type, float_type) = match arch {
session::arch_x86 => (ast::ty_i32, ast::ty_u32, ast::ty_f64),
session::arch_x86_64 => (ast::ty_i64, ast::ty_u64, ast::ty_f64),
session::arch_arm => (ast::ty_i32, ast::ty_u32, ast::ty_f64)
};
let target_strs = alt arch {
let target_strs = match arch {
session::arch_x86 => x86::get_target_strs(os),
session::arch_x86_64 => x86_64::get_target_strs(os),
session::arch_arm => x86::get_target_strs(os)
@ -438,7 +438,7 @@ fn build_session_options(matches: getopts::matches,
getopts::opt_strs(matches, level_name));
for flags.each |lint_name| {
let lint_name = str::replace(lint_name, ~"-", ~"_");
alt lint_dict.find(lint_name) {
match lint_dict.find(lint_name) {
none => {
early_error(demitter, fmt!{"unknown %s flag: %s",
level_name, lint_name});
@ -486,7 +486,7 @@ fn build_session_options(matches: getopts::matches,
let sysroot_opt = getopts::opt_maybe_str(matches, ~"sysroot");
let target_opt = getopts::opt_maybe_str(matches, ~"target");
let save_temps = getopts::opt_present(matches, ~"save-temps");
alt output_type {
match output_type {
// unless we're emitting huamn-readable assembly, omit comments.
link::output_type_llvm_assembly | link::output_type_assembly => (),
_ => debugging_opts |= session::no_asm_comments
@ -498,7 +498,7 @@ fn build_session_options(matches: getopts::matches,
}
2u
} else if opt_present(matches, ~"opt-level") {
alt getopts::opt_str(matches, ~"opt-level") {
match getopts::opt_str(matches, ~"opt-level") {
~"0" => 0u,
~"1" => 1u,
~"2" => 2u,
@ -510,7 +510,7 @@ fn build_session_options(matches: getopts::matches,
}
} else { 0u };
let target =
alt target_opt {
match target_opt {
none => host_triple(),
some(s) => s
};
@ -577,7 +577,7 @@ fn build_session_(sopts: @session::options,
}
fn parse_pretty(sess: session, &&name: ~str) -> pp_mode {
alt name {
match name {
~"normal" => ppm_normal,
~"expanded" => ppm_expanded,
~"typed" => ppm_typed,
@ -628,7 +628,7 @@ fn build_output_filenames(input: input,
let obj_suffix =
alt sopts.output_type {
match sopts.output_type {
link::output_type_none => ~"none",
link::output_type_bitcode => ~"bc",
link::output_type_assembly => ~"s",
@ -637,20 +637,20 @@ fn build_output_filenames(input: input,
link::output_type_object | link::output_type_exe => ~"o"
};
alt ofile {
match ofile {
none => {
// "-" as input file will cause the parser to read from stdin so we
// have to make up a name
// We want to toss everything after the final '.'
let dirname = alt odir {
let dirname = match odir {
some(d) => d,
none => alt input {
none => match input {
str_input(_) => os::getcwd(),
file_input(ifile) => path::dirname(ifile)
}
};
let base_filename = alt input {
let base_filename = match input {
file_input(ifile) => {
let (path, _) = path::splitext(ifile);
path::basename(path)
@ -714,7 +714,7 @@ mod test {
#[test]
fn test_switch_implies_cfg_test() {
let matches =
alt getopts::getopts(~[~"--test"], opts()) {
match getopts::getopts(~[~"--test"], opts()) {
ok(m) => m,
err(f) => fail ~"test_switch_implies_cfg_test: " +
getopts::fail_str(f)
@ -730,7 +730,7 @@ mod test {
#[test]
fn test_switch_implies_cfg_test_unless_cfg_test() {
let matches =
alt getopts::getopts(~[~"--test", ~"--cfg=test"], opts()) {
match getopts::getopts(~[~"--test", ~"--cfg=test"], opts()) {
ok(m) => m,
err(f) => {
fail ~"test_switch_implies_cfg_test_unless_cfg_test: " +

12
src/rustc/driver/rustc.rs
View file

@ -95,7 +95,7 @@ fn describe_warnings() {
let k = str::replace(k, ~"_", ~"-");
io::println(fmt!{" %s %7.7s %s",
padded(max_key, k),
alt v.default {
match v.default {
lint::allow => ~"allow",
lint::warn => ~"warn",
lint::deny => ~"deny",
@ -124,7 +124,7 @@ fn run_compiler(args: ~[~str], demitter: diagnostic::emitter) {
if vec::len(args) == 0u { usage(binary); return; }
let matches =
alt getopts::getopts(args, opts()) {
match getopts::getopts(args, opts()) {
ok(m) => m,
err(f) => {
early_error(demitter, getopts::fail_str(f))
@ -152,7 +152,7 @@ fn run_compiler(args: ~[~str], demitter: diagnostic::emitter) {
version(binary);
return;
}
let input = alt vec::len(matches.free) {
let input = match vec::len(matches.free) {
0u => early_error(demitter, ~"no input filename given"),
1u => {
let ifile = matches.free[0];
@ -175,7 +175,7 @@ fn run_compiler(args: ~[~str], demitter: diagnostic::emitter) {
option::map(getopts::opt_default(matches, ~"pretty",
~"normal"),
|a| parse_pretty(sess, a) );
alt pretty {
match pretty {
some::<pp_mode>(ppm) => {
pretty_print_input(sess, cfg, input, ppm);
return;
@ -184,7 +184,7 @@ fn run_compiler(args: ~[~str], demitter: diagnostic::emitter) {
}
let ls = opt_present(matches, ~"ls");
if ls {
alt input {
match input {
file_input(ifile) => {
list_metadata(sess, ifile, io::stdout());
}
@ -219,7 +219,7 @@ fn monitor(+f: fn~(diagnostic::emitter)) {
let p = comm::port();
let ch = comm::chan(p);
alt do task::try {
match do task::try {
// The 'diagnostics emitter'. Every error, warning, etc. should
// go through this function.

8
src/rustc/driver/session.rs
View file

@ -152,7 +152,7 @@ impl session for session {
}
fn span_lint_level(level: lint::level,
sp: span, msg: ~str) {
alt level {
match level {
lint::allow => { },
lint::warn => self.span_warn(sp, msg),
lint::deny | lint::forbid => {
@ -219,14 +219,14 @@ fn expect<T: copy>(sess: session, opt: option<T>, msg: fn() -> ~str) -> T {
fn building_library(req_crate_type: crate_type, crate: @ast::crate,
testing: bool) -> bool {
alt req_crate_type {
match req_crate_type {
bin_crate => false,
lib_crate => true,
unknown_crate => {
if testing {
false
} else {
alt syntax::attr::first_attr_value_str_by_name(
match syntax::attr::first_attr_value_str_by_name(
crate.node.attrs,
~"crate_type") {
option::some(@~"lib") => true,
@ -240,7 +240,7 @@ fn building_library(req_crate_type: crate_type, crate: @ast::crate,
fn sess_os_to_meta_os(os: os) -> metadata::loader::os {
import metadata::loader;
alt os {
match os {
os_win32 => loader::os_win32,
os_linux => loader::os_linux,
os_macos => loader::os_macos,

Some files were not shown because too many files have changed in this diff Show more