Skip to content
体验新版
项目
组织
正在加载...
登录
切换导航
打开侧边栏
int
Rust
提交
4cf2e510
R
Rust
项目概览
int
/
Rust
大约 1 年 前同步成功
通知
1
Star
0
Fork
0
代码
文件
提交
分支
Tags
贡献者
分支图
Diff
Issue
0
列表
看板
标记
里程碑
合并请求
0
DevOps
流水线
流水线任务
计划
Wiki
0
Wiki
分析
仓库
DevOps
项目成员
Pages
R
Rust
项目概览
项目概览
详情
发布
仓库
仓库
文件
提交
分支
标签
贡献者
分支图
比较
Issue
0
Issue
0
列表
看板
标记
里程碑
合并请求
0
合并请求
0
Pages
DevOps
DevOps
流水线
流水线任务
计划
分析
分析
仓库分析
DevOps
Wiki
0
Wiki
成员
成员
收起侧边栏
关闭侧边栏
动态
分支图
创建新Issue
流水线任务
提交
Issue看板
体验新版 GitCode,发现更多精彩内容 >>
提交
4cf2e510
编写于
8月 24, 2011
作者:
B
Brian Anderson
浏览文件
操作
浏览文件
下载
电子邮件补丁
差异文件
Convert std::getopts to istrs. Issue #855
上级
3a5f4e7a
变更
7
隐藏空白更改
内联
并排
Showing
7 changed file
with
287 addition
and
259 deletion
+287
-259
src/comp/driver/rustc.rs
src/comp/driver/rustc.rs
+61
-55
src/lib/getopts.rs
src/lib/getopts.rs
+59
-57
src/lib/istr.rs
src/lib/istr.rs
+18
-2
src/lib/test.rs
src/lib/test.rs
+7
-5
src/test/bench/shootout-pfib.rs
src/test/bench/shootout-pfib.rs
+3
-2
src/test/compiletest/compiletest.rs
src/test/compiletest/compiletest.rs
+27
-27
src/test/stdtest/getopts.rs
src/test/stdtest/getopts.rs
+112
-111
未找到文件。
src/comp/driver/rustc.rs
浏览文件 @
4cf2e510
...
...
@@ -330,45 +330,47 @@ fn build_target_config() -> @session::config {
ret
target_cfg
;
}
fn
build_session_options
(
binary
:
str
,
match
:
getopts
::
match
,
binary_dir
:
str
)
fn
build_session_options
(
binary
:
str
,
match
:
&
getopts
::
match
,
binary_dir
:
str
)
->
@
session
::
options
{
let
library
=
opt_present
(
match
,
"lib"
);
let
static
=
opt_present
(
match
,
"static"
);
let
library
=
opt_present
(
match
,
~
"lib"
);
let
static
=
opt_present
(
match
,
~
"static"
);
let
library_search_paths
=
[
binary_dir
+
"/lib"
];
let
lsp_vec
=
getopts
::
opt_strs
(
match
,
"L"
);
for
lsp
:
str
in
lsp_vec
{
library_search_paths
+=
[
lsp
];
}
let
lsp_vec
=
getopts
::
opt_strs
(
match
,
~
"L"
);
for
lsp
:
istr
in
lsp_vec
{
library_search_paths
+=
[
istr
::
to_estr
(
lsp
)];
}
let
parse_only
=
opt_present
(
match
,
"parse-only"
);
let
no_trans
=
opt_present
(
match
,
"no-trans"
);
let
parse_only
=
opt_present
(
match
,
~
"parse-only"
);
let
no_trans
=
opt_present
(
match
,
~
"no-trans"
);
let
output_type
=
if
parse_only
||
no_trans
{
link
::
output_type_none
}
else
if
opt_present
(
match
,
"S"
)
{
}
else
if
opt_present
(
match
,
~
"S"
)
{
link
::
output_type_assembly
}
else
if
opt_present
(
match
,
"c"
)
{
}
else
if
opt_present
(
match
,
~
"c"
)
{
link
::
output_type_object
}
else
if
opt_present
(
match
,
"emit-llvm"
)
{
}
else
if
opt_present
(
match
,
~
"emit-llvm"
)
{
link
::
output_type_bitcode
}
else
{
link
::
output_type_exe
};
let
verify
=
!
opt_present
(
match
,
"noverify"
);
let
save_temps
=
opt_present
(
match
,
"save-temps"
);
let
debuginfo
=
opt_present
(
match
,
"g"
);
let
stats
=
opt_present
(
match
,
"stats"
);
let
time_passes
=
opt_present
(
match
,
"time-passes"
);
let
time_llvm_passes
=
opt_present
(
match
,
"time-llvm-passes"
);
let
run_typestate
=
!
opt_present
(
match
,
"no-typestate"
);
let
sysroot_opt
=
getopts
::
opt_maybe_str
(
match
,
"sysroot"
);
let
verify
=
!
opt_present
(
match
,
~
"noverify"
);
let
save_temps
=
opt_present
(
match
,
~
"save-temps"
);
let
debuginfo
=
opt_present
(
match
,
~
"g"
);
let
stats
=
opt_present
(
match
,
~
"stats"
);
let
time_passes
=
opt_present
(
match
,
~
"time-passes"
);
let
time_llvm_passes
=
opt_present
(
match
,
~
"time-llvm-passes"
);
let
run_typestate
=
!
opt_present
(
match
,
~
"no-typestate"
);
let
sysroot_opt
=
getopts
::
opt_maybe_str
(
match
,
~
"sysroot"
);
let
opt_level
:
uint
=
if
opt_present
(
match
,
"O"
)
{
if
opt_present
(
match
,
"OptLevel"
)
{
if
opt_present
(
match
,
~
"O"
)
{
if
opt_present
(
match
,
~
"OptLevel"
)
{
log_err
"error: -O and --OptLevel both provided"
;
fail
;
}
2u
}
else
if
opt_present
(
match
,
"OptLevel"
)
{
alt
getopts
::
opt_str
(
match
,
"OptLevel"
)
{
}
else
if
opt_present
(
match
,
~
"OptLevel"
)
{
alt
istr
::
to_estr
(
getopts
::
opt_str
(
match
,
~
"OptLevel"
)
)
{
"0"
{
0u
}
"1"
{
1u
}
"2"
{
2u
}
...
...
@@ -383,11 +385,12 @@ fn build_session_options(binary: str, match: getopts::match, binary_dir: str)
let
sysroot
=
alt
sysroot_opt
{
none
.
{
get_default_sysroot
(
binary
)
}
some
(
s
)
{
s
}
some
(
s
)
{
istr
::
to_estr
(
s
)
}
};
let
cfg
=
parse_cfgspecs
(
getopts
::
opt_strs
(
match
,
"cfg"
));
let
test
=
opt_present
(
match
,
"test"
);
let
do_gc
=
opt_present
(
match
,
"gc"
);
let
cfg
=
parse_cfgspecs
(
istr
::
to_estrs
(
getopts
::
opt_strs
(
match
,
~
"cfg"
)));
let
test
=
opt_present
(
match
,
~
"test"
);
let
do_gc
=
opt_present
(
match
,
~
"gc"
);
let
sopts
:
@
session
::
options
=
@
{
library
:
library
,
static
:
static
,
...
...
@@ -418,28 +421,29 @@ fn build_session(sopts: @session::options) -> session::session {
none
,
0u
);
}
fn
parse_pretty
(
sess
:
session
::
session
,
name
:
&
str
)
->
pp_mode
{
if
str
::
eq
(
name
,
"normal"
)
{
fn
parse_pretty
(
sess
:
session
::
session
,
name
:
&
i
str
)
->
pp_mode
{
if
istr
::
eq
(
name
,
~
"normal"
)
{
ret
ppm_normal
;
}
else
if
str
::
eq
(
name
,
"expanded"
)
{
}
else
if
istr
::
eq
(
name
,
~
"expanded"
)
{
ret
ppm_expanded
;
}
else
if
str
::
eq
(
name
,
"typed"
)
{
}
else
if
istr
::
eq
(
name
,
~
"typed"
)
{
ret
ppm_typed
;
}
else
if
str
::
eq
(
name
,
"identified"
)
{
ret
ppm_identified
;
}
}
else
if
istr
::
eq
(
name
,
~
"identified"
)
{
ret
ppm_identified
;
}
sess
.fatal
(
"argument to `pretty` must be one of `normal`, `typed`, or "
+
"`identified`"
);
}
fn
opts
()
->
[
getopts
::
opt
]
{
ret
[
optflag
(
"h"
),
optflag
(
"help"
),
optflag
(
"v"
),
optflag
(
"version"
),
optflag
(
"glue"
),
optflag
(
"emit-llvm"
),
optflagopt
(
"pretty"
),
optflag
(
"ls"
),
optflag
(
"parse-only"
),
optflag
(
"no-trans"
),
optflag
(
"O"
),
optopt
(
"OptLevel"
),
optmulti
(
"L"
),
optflag
(
"S"
),
optflag
(
"c"
),
optopt
(
"o"
),
optflag
(
"g"
),
optflag
(
"save-temps"
),
optopt
(
"sysroot"
),
optflag
(
"stats"
),
optflag
(
"time-passes"
),
optflag
(
"time-llvm-passes"
),
optflag
(
"no-typestate"
),
optflag
(
"noverify"
),
optmulti
(
"cfg"
),
optflag
(
"test"
),
optflag
(
"lib"
),
optflag
(
"static"
),
optflag
(
"gc"
)];
ret
[
optflag
(
~
"h"
),
optflag
(
~
"help"
),
optflag
(
~
"v"
),
optflag
(
~
"version"
),
optflag
(
~
"glue"
),
optflag
(
~
"emit-llvm"
),
optflagopt
(
~
"pretty"
),
optflag
(
~
"ls"
),
optflag
(
~
"parse-only"
),
optflag
(
~
"no-trans"
),
optflag
(
~
"O"
),
optopt
(
~
"OptLevel"
),
optmulti
(
~
"L"
),
optflag
(
~
"S"
),
optflag
(
~
"c"
),
optopt
(
~
"o"
),
optflag
(
~
"g"
),
optflag
(
~
"save-temps"
),
optopt
(
~
"sysroot"
),
optflag
(
~
"stats"
),
optflag
(
~
"time-passes"
),
optflag
(
~
"time-llvm-passes"
),
optflag
(
~
"no-typestate"
),
optflag
(
~
"noverify"
),
optmulti
(
~
"cfg"
),
optflag
(
~
"test"
),
optflag
(
~
"lib"
),
optflag
(
~
"static"
),
optflag
(
~
"gc"
)];
}
fn
main
(
args
:
[
str
])
{
...
...
@@ -447,31 +451,32 @@ fn main(args: [str]) {
let
binary_dir
=
istr
::
to_estr
(
fs
::
dirname
(
istr
::
from_estr
(
binary
)));
let
match
=
alt
getopts
::
getopts
(
args
,
opts
())
{
alt
getopts
::
getopts
(
istr
::
from_estrs
(
args
)
,
opts
())
{
getopts
::
success
(
m
)
{
m
}
getopts
::
failure
(
f
)
{
log_err
#
fmt
[
"error: %s"
,
getopts
::
fail_str
(
f
)];
log_err
#
fmt
[
"error: %s"
,
istr
::
to_estr
(
getopts
::
fail_str
(
f
)
)];
fail
}
};
if
opt_present
(
match
,
"h"
)
||
opt_present
(
match
,
"help"
)
{
if
opt_present
(
match
,
~
"h"
)
||
opt_present
(
match
,
~
"help"
)
{
usage
(
binary
);
ret
;
}
if
opt_present
(
match
,
"v"
)
||
opt_present
(
match
,
"version"
)
{
if
opt_present
(
match
,
~
"v"
)
||
opt_present
(
match
,
~
"version"
)
{
version
(
binary
);
ret
;
}
let
sopts
=
build_session_options
(
binary
,
match
,
binary_dir
);
let
sess
=
build_session
(
sopts
);
let
n_inputs
=
vec
::
len
::
<
str
>
(
match
.free
);
let
output_file
=
getopts
::
opt_maybe_str
(
match
,
"o"
);
let
glue
=
opt_present
(
match
,
"glue"
);
let
n_inputs
=
vec
::
len
::
<
i
str
>
(
match
.free
);
let
output_file
=
getopts
::
opt_maybe_str
(
match
,
~
"o"
);
let
glue
=
opt_present
(
match
,
~
"glue"
);
if
glue
{
if
n_inputs
>
0u
{
sess
.fatal
(
"No input files allowed with --glue."
);
}
let
out
=
option
::
from_maybe
::
<
str
>
(
"glue.bc"
,
output_file
);
let
out
=
option
::
from_maybe
::
<
istr
>
(
~
"glue.bc"
,
output_file
);
let
out
=
istr
::
to_estr
(
out
);
middle
::
trans
::
make_common_glue
(
sess
,
out
);
ret
;
}
...
...
@@ -480,14 +485,14 @@ fn main(args: [str]) {
}
else
if
n_inputs
>
1u
{
sess
.fatal
(
"Multiple input filenames provided."
);
}
let
ifile
=
match
.free
[
0
]
;
let
ifile
=
istr
::
to_estr
(
match
.free
[
0
])
;
let
saved_out_filename
:
str
=
""
;
let
cfg
=
build_configuration
(
sess
,
binary
,
ifile
);
let
pretty
=
option
::
map
::
<
str
,
option
::
map
::
<
i
str
,
pp_mode
>
(
bind
parse_pretty
(
sess
,
_
),
getopts
::
opt_default
(
match
,
"pretty"
,
"normal"
));
getopts
::
opt_default
(
match
,
~
"pretty"
,
~
"normal"
));
alt
pretty
{
some
::
<
pp_mode
>
(
ppm
)
{
pretty_print_input
(
sess
,
cfg
,
ifile
,
ppm
);
...
...
@@ -495,7 +500,7 @@ fn main(args: [str]) {
}
none
::
<
pp_mode
>
.
{
/* continue */
}
}
let
ls
=
opt_present
(
match
,
"ls"
);
let
ls
=
opt_present
(
match
,
~
"ls"
);
if
ls
{
metadata
::
creader
::
list_file_metadata
(
ifile
,
io
::
stdout
());
ret
;
}
let
stop_after_codegen
=
...
...
@@ -528,6 +533,7 @@ fn main(args: [str]) {
compile_input
(
sess
,
cfg
,
ifile
,
ofile
);
}
some
(
ofile
)
{
let
ofile
=
istr
::
to_estr
(
ofile
);
// FIXME: what about windows? This will create a foo.exe.o.
saved_out_filename
=
ofile
;
let
temp_filename
=
...
...
@@ -634,7 +640,7 @@ mod test {
#[test]
fn
test_switch_implies_cfg_test
()
{
let
match
=
alt
getopts
::
getopts
([
"--test"
],
opts
())
{
alt
getopts
::
getopts
([
~
"--test"
],
opts
())
{
getopts
::
success
(
m
)
{
m
}
};
let
sessopts
=
build_session_options
(
"whatever"
,
match
,
"whatever"
);
...
...
@@ -648,7 +654,7 @@ fn test_switch_implies_cfg_test() {
#[test]
fn
test_switch_implies_cfg_test_unless_cfg_test
()
{
let
match
=
alt
getopts
::
getopts
([
"--test"
,
"--cfg=test"
],
opts
())
{
alt
getopts
::
getopts
([
~
"--test"
,
~
"--cfg=test"
],
opts
())
{
getopts
::
success
(
m
)
{
m
}
};
let
sessopts
=
build_session_options
(
"whatever"
,
match
,
"whatever"
);
...
...
src/lib/getopts.rs
浏览文件 @
4cf2e510
...
...
@@ -29,7 +29,7 @@
export
opt_maybe_str
;
export
opt_default
;
tag
name
{
long
(
str
);
short
(
char
);
}
tag
name
{
long
(
i
str
);
short
(
char
);
}
tag
hasarg
{
yes
;
no
;
maybe
;
}
...
...
@@ -37,45 +37,45 @@
type
opt
=
{
name
:
name
,
hasarg
:
hasarg
,
occur
:
occur
};
fn
mkname
(
nm
:
str
)
->
name
{
ret
if
str
::
char_len
(
nm
)
==
1u
{
short
(
str
::
char_at
(
nm
,
0u
))
fn
mkname
(
nm
:
&
i
str
)
->
name
{
ret
if
i
str
::
char_len
(
nm
)
==
1u
{
short
(
i
str
::
char_at
(
nm
,
0u
))
}
else
{
long
(
nm
)
};
}
fn
reqopt
(
name
:
str
)
->
opt
{
fn
reqopt
(
name
:
&
i
str
)
->
opt
{
ret
{
name
:
mkname
(
name
),
hasarg
:
yes
,
occur
:
req
};
}
fn
optopt
(
name
:
str
)
->
opt
{
fn
optopt
(
name
:
&
i
str
)
->
opt
{
ret
{
name
:
mkname
(
name
),
hasarg
:
yes
,
occur
:
optional
};
}
fn
optflag
(
name
:
str
)
->
opt
{
fn
optflag
(
name
:
&
i
str
)
->
opt
{
ret
{
name
:
mkname
(
name
),
hasarg
:
no
,
occur
:
optional
};
}
fn
optflagopt
(
name
:
str
)
->
opt
{
fn
optflagopt
(
name
:
&
i
str
)
->
opt
{
ret
{
name
:
mkname
(
name
),
hasarg
:
maybe
,
occur
:
optional
};
}
fn
optmulti
(
name
:
str
)
->
opt
{
fn
optmulti
(
name
:
&
i
str
)
->
opt
{
ret
{
name
:
mkname
(
name
),
hasarg
:
yes
,
occur
:
multi
};
}
tag
optval
{
val
(
str
);
given
;
}
tag
optval
{
val
(
i
str
);
given
;
}
type
match
=
{
opts
:
[
opt
],
vals
:
[
mutable
[
optval
]],
free
:
[
str
]};
type
match
=
{
opts
:
[
opt
],
vals
:
[
mutable
[
optval
]],
free
:
[
i
str
]};
fn
is_arg
(
arg
:
str
)
->
bool
{
ret
str
::
byte_len
(
arg
)
>
1u
&&
arg
[
0
]
==
'-'
as
u8
;
fn
is_arg
(
arg
:
&
i
str
)
->
bool
{
ret
i
str
::
byte_len
(
arg
)
>
1u
&&
arg
[
0
]
==
'-'
as
u8
;
}
fn
name_str
(
nm
:
name
)
->
str
{
ret
alt
nm
{
short
(
ch
)
{
str
::
from_char
(
ch
)
}
long
(
s
)
{
s
}
};
fn
name_str
(
nm
:
&
name
)
->
i
str
{
ret
alt
nm
{
short
(
ch
)
{
i
str
::
from_char
(
ch
)
}
long
(
s
)
{
s
}
};
}
fn
find_opt
(
opts
:
&
[
opt
],
nm
:
name
)
->
option
::
t
<
uint
>
{
fn
find_opt
(
opts
:
&
[
opt
],
nm
:
&
name
)
->
option
::
t
<
uint
>
{
let
i
=
0u
;
let
l
=
vec
::
len
::
<
opt
>
(
opts
);
while
i
<
l
{
if
opts
[
i
]
.name
==
nm
{
ret
some
::
<
uint
>
(
i
);
}
i
+=
1u
;
}
...
...
@@ -83,65 +83,67 @@ fn find_opt(opts: &[opt], nm: name) -> option::t<uint> {
}
tag
fail_
{
argument_missing
(
str
);
unrecognized_option
(
str
);
option_missing
(
str
);
option_duplicated
(
str
);
unexpected_argument
(
str
);
argument_missing
(
i
str
);
unrecognized_option
(
i
str
);
option_missing
(
i
str
);
option_duplicated
(
i
str
);
unexpected_argument
(
i
str
);
}
fn
fail_str
(
f
:
fail_
)
->
str
{
fn
fail_str
(
f
:
&
fail_
)
->
i
str
{
ret
alt
f
{
argument_missing
(
nm
)
{
"Argument to option '"
+
nm
+
"' missing."
}
unrecognized_option
(
nm
)
{
"Unrecognized option: '"
+
nm
+
"'."
}
option_missing
(
nm
)
{
"Required option '"
+
nm
+
"' missing."
}
argument_missing
(
nm
)
{
~
"Argument to option '"
+
nm
+
~
"' missing."
}
unrecognized_option
(
nm
)
{
~
"Unrecognized option: '"
+
nm
+
~
"'."
}
option_missing
(
nm
)
{
~
"Required option '"
+
nm
+
~
"' missing."
}
option_duplicated
(
nm
)
{
"Option '"
+
nm
+
"' given more than once."
~
"Option '"
+
nm
+
~
"' given more than once."
}
unexpected_argument
(
nm
)
{
"Option "
+
nm
+
" does not take an argument."
~
"Option "
+
nm
+
~
" does not take an argument."
}
};
}
tag
result
{
success
(
match
);
failure
(
fail_
);
}
fn
getopts
(
args
:
&
[
str
],
opts
:
&
[
opt
])
->
result
{
fn
getopts
(
args
:
&
[
i
str
],
opts
:
&
[
opt
])
->
result
{
let
n_opts
=
vec
::
len
::
<
opt
>
(
opts
);
fn
f
(
_
x
:
uint
)
->
[
optval
]
{
ret
[];
}
let
vals
=
vec
::
init_fn_mut
::
<
[
optval
]
>
(
f
,
n_opts
);
let
free
:
[
str
]
=
[];
let
l
=
vec
::
len
::
<
str
>
(
args
);
let
free
:
[
i
str
]
=
[];
let
l
=
vec
::
len
(
args
);
let
i
=
0u
;
while
i
<
l
{
let
cur
=
args
[
i
];
let
curlen
=
str
::
byte_len
(
cur
);
let
curlen
=
i
str
::
byte_len
(
cur
);
if
!
is_arg
(
cur
)
{
free
+=
[
cur
];
}
else
if
str
::
eq
(
cur
,
"--"
)
{
}
else
if
istr
::
eq
(
cur
,
~
"--"
)
{
let
j
=
i
+
1u
;
while
j
<
l
{
free
+=
[
args
[
j
]];
j
+=
1u
;
}
break
;
}
else
{
let
names
;
let
i_arg
=
option
::
none
::
<
str
>
;
let
i_arg
=
option
::
none
::
<
i
str
>
;
if
cur
[
1
]
==
'-'
as
u8
{
let
tail
=
str
::
slice
(
cur
,
2u
,
curlen
);
let
eq
=
str
::
index
(
tail
,
'='
as
u8
);
let
tail
=
i
str
::
slice
(
cur
,
2u
,
curlen
);
let
eq
=
i
str
::
index
(
tail
,
'='
as
u8
);
if
eq
==
-
1
{
names
=
[
long
(
tail
)];
}
else
{
names
=
[
long
(
str
::
slice
(
tail
,
0u
,
eq
as
uint
))];
names
=
[
long
(
i
str
::
slice
(
tail
,
0u
,
eq
as
uint
))];
i_arg
=
option
::
some
::
<
str
>
(
str
::
slice
(
tail
,
(
eq
as
uint
)
+
1u
,
curlen
-
2u
));
option
::
some
::
<
istr
>
(
i
str
::
slice
(
tail
,
(
eq
as
uint
)
+
1u
,
curlen
-
2u
));
}
}
else
{
let
j
=
1u
;
names
=
[];
while
j
<
curlen
{
let
range
=
str
::
char_range_at
(
cur
,
j
);
let
range
=
i
str
::
char_range_at
(
cur
,
j
);
names
+=
[
short
(
range
.ch
)];
j
=
range
.next
;
}
...
...
@@ -156,13 +158,13 @@ fn getopts(args: &[str], opts: &[opt]) -> result {
}
alt
opts
[
optid
]
.hasarg
{
no
.
{
if
!
option
::
is_none
::
<
str
>
(
i_arg
)
{
if
!
option
::
is_none
::
<
i
str
>
(
i_arg
)
{
ret
failure
(
unexpected_argument
(
name_str
(
nm
)));
}
vals
[
optid
]
+=
[
given
];
}
maybe
.
{
if
!
option
::
is_none
::
<
str
>
(
i_arg
)
{
if
!
option
::
is_none
::
<
i
str
>
(
i_arg
)
{
vals
[
optid
]
+=
[
val
(
option
::
get
(
i_arg
))];
}
else
if
name_pos
<
vec
::
len
::
<
name
>
(
names
)
||
i
+
1u
==
l
||
is_arg
(
args
[
i
+
1u
])
{
...
...
@@ -170,8 +172,8 @@ fn getopts(args: &[str], opts: &[opt]) -> result {
}
else
{
i
+=
1u
;
vals
[
optid
]
+=
[
val
(
args
[
i
])];
}
}
yes
.
{
if
!
option
::
is_none
::
<
str
>
(
i_arg
)
{
vals
[
optid
]
+=
[
val
(
option
::
get
::
<
str
>
(
i_arg
))];
if
!
option
::
is_none
::
<
i
str
>
(
i_arg
)
{
vals
[
optid
]
+=
[
val
(
option
::
get
::
<
i
str
>
(
i_arg
))];
}
else
if
i
+
1u
==
l
{
ret
failure
(
argument_missing
(
name_str
(
nm
)));
}
else
{
i
+=
1u
;
vals
[
optid
]
+=
[
val
(
args
[
i
])];
}
...
...
@@ -200,45 +202,45 @@ fn getopts(args: &[str], opts: &[opt]) -> result {
ret
success
({
opts
:
opts
,
vals
:
vals
,
free
:
free
});
}
fn
opt_vals
(
m
:
&
match
,
nm
:
str
)
->
[
optval
]
{
fn
opt_vals
(
m
:
&
match
,
nm
:
&
i
str
)
->
[
optval
]
{
ret
alt
find_opt
(
m
.opts
,
mkname
(
nm
))
{
some
(
id
)
{
m
.vals
[
id
]
}
none
.
{
log_err
"No option '"
+
nm
+
"' defined."
;
fail
}
none
.
{
log_err
~
"No option '"
+
nm
+
~
"' defined."
;
fail
}
};
}
fn
opt_val
(
m
:
&
match
,
nm
:
str
)
->
optval
{
ret
opt_vals
(
m
,
nm
)[
0
];
}
fn
opt_val
(
m
:
&
match
,
nm
:
&
i
str
)
->
optval
{
ret
opt_vals
(
m
,
nm
)[
0
];
}
fn
opt_present
(
m
:
&
match
,
nm
:
str
)
->
bool
{
fn
opt_present
(
m
:
&
match
,
nm
:
&
i
str
)
->
bool
{
ret
vec
::
len
::
<
optval
>
(
opt_vals
(
m
,
nm
))
>
0u
;
}
fn
opt_str
(
m
:
&
match
,
nm
:
str
)
->
str
{
fn
opt_str
(
m
:
&
match
,
nm
:
&
istr
)
->
i
str
{
ret
alt
opt_val
(
m
,
nm
)
{
val
(
s
)
{
s
}
_
{
fail
}
};
}
fn
opt_strs
(
m
:
&
match
,
nm
:
str
)
->
[
str
]
{
let
acc
:
[
str
]
=
[];
fn
opt_strs
(
m
:
&
match
,
nm
:
&
istr
)
->
[
i
str
]
{
let
acc
:
[
i
str
]
=
[];
for
v
:
optval
in
opt_vals
(
m
,
nm
)
{
alt
v
{
val
(
s
)
{
acc
+=
[
s
];
}
_
{
}
}
}
ret
acc
;
}
fn
opt_maybe_str
(
m
:
&
match
,
nm
:
str
)
->
option
::
t
<
str
>
{
fn
opt_maybe_str
(
m
:
&
match
,
nm
:
&
istr
)
->
option
::
t
<
i
str
>
{
let
vals
=
opt_vals
(
m
,
nm
);
if
vec
::
len
::
<
optval
>
(
vals
)
==
0u
{
ret
none
::
<
str
>
;
}
ret
alt
vals
[
0
]
{
val
(
s
)
{
some
::
<
str
>
(
s
)
}
_
{
none
::
<
str
>
}
};
if
vec
::
len
::
<
optval
>
(
vals
)
==
0u
{
ret
none
::
<
i
str
>
;
}
ret
alt
vals
[
0
]
{
val
(
s
)
{
some
::
<
istr
>
(
s
)
}
_
{
none
::
<
i
str
>
}
};
}
/// Returns none if the option was not present, `def` if the option was
/// present but no argument was provided, and the argument if the option was
/// present and an argument was provided.
fn
opt_default
(
m
:
&
match
,
nm
:
str
,
def
:
str
)
->
option
::
t
<
str
>
{
fn
opt_default
(
m
:
&
match
,
nm
:
&
istr
,
def
:
&
istr
)
->
option
::
t
<
i
str
>
{
let
vals
=
opt_vals
(
m
,
nm
);
if
vec
::
len
::
<
optval
>
(
vals
)
==
0u
{
ret
none
::
<
str
>
;
}
ret
alt
vals
[
0
]
{
val
(
s
)
{
some
::
<
str
>
(
s
)
}
_
{
some
::
<
str
>
(
def
)
}
}
if
vec
::
len
::
<
optval
>
(
vals
)
==
0u
{
ret
none
::
<
i
str
>
;
}
ret
alt
vals
[
0
]
{
val
(
s
)
{
some
::
<
istr
>
(
s
)
}
_
{
some
::
<
i
str
>
(
def
)
}
}
}
// Local Variables:
// mode: rust;
...
...
src/lib/istr.rs
浏览文件 @
4cf2e510
...
...
@@ -3,9 +3,9 @@
concat
,
connect
,
to_upper
,
replace
,
char_slice
,
trim_left
,
trim_right
,
trim
,
unshift_char
,
shift_char
,
pop_char
,
push_char
,
is_utf8
,
from_chars
,
to_chars
,
char_len
,
char_at
,
bytes
,
is_ascii
,
shift_byte
,
pop_byte
,
unsafe_from_byte
,
unsafe_from_bytes
,
from_char
;
unsafe_from_bytes
,
from_char
,
char_range_at
;
export
from_estr
,
to_estr
;
export
from_estr
,
to_estr
,
from_estrs
,
to_estrs
;
fn
from_estr
(
s
:
&
str
)
->
istr
{
let
s2
=
~
""
;
...
...
@@ -23,6 +23,22 @@ fn to_estr(s: &istr) -> str {
ret
s2
;
}
fn
from_estrs
(
ss
:
&
[
str
])
->
[
istr
]
{
let
ss2
=
[];
for
s
in
ss
{
ss2
+=
[
from_estr
(
s
)];
}
ret
ss2
;
}
fn
to_estrs
(
ss
:
&
[
istr
])
->
[
str
]
{
let
ss2
=
[];
for
s
in
ss
{
ss2
+=
[
to_estr
(
s
)];
}
ret
ss2
;
}
fn
eq
(
a
:
&
istr
,
b
:
&
istr
)
->
bool
{
a
==
b
}
fn
lteq
(
a
:
&
istr
,
b
:
&
istr
)
->
bool
{
a
<=
b
}
...
...
src/lib/test.rs
浏览文件 @
4cf2e510
...
...
@@ -66,20 +66,22 @@ fn test_main(args: &[str], tests: &[test_desc]) {
// Parses command line arguments into test options
fn
parse_opts
(
args
:
&
[
str
])
:
vec
::
is_not_empty
(
args
)
->
opt_res
{
let
args_
=
vec
::
tail
(
args
);
let
opts
=
[
getopts
::
optflag
(
"ignored"
)];
let
args_
=
istr
::
from_estrs
(
vec
::
tail
(
args
)
);
let
opts
=
[
getopts
::
optflag
(
~
"ignored"
)];
let
match
=
alt
getopts
::
getopts
(
args_
,
opts
)
{
getopts
::
success
(
m
)
{
m
}
getopts
::
failure
(
f
)
{
ret
either
::
right
(
getopts
::
fail_str
(
f
))
}
getopts
::
failure
(
f
)
{
ret
either
::
right
(
istr
::
to_estr
(
getopts
::
fail_str
(
f
)))
}
};
let
filter
=
if
vec
::
len
(
match
.free
)
>
0u
{
option
::
some
(
match
.free
[
0
]
)
option
::
some
(
istr
::
to_estr
(
match
.free
[
0
])
)
}
else
{
option
::
none
};
let
run_ignored
=
getopts
::
opt_present
(
match
,
"ignored"
);
let
run_ignored
=
getopts
::
opt_present
(
match
,
~
"ignored"
);
let
test_opts
=
{
filter
:
filter
,
run_ignored
:
run_ignored
};
...
...
src/test/bench/shootout-pfib.rs
浏览文件 @
4cf2e510
...
...
@@ -51,13 +51,14 @@ fn pfib(c: chan<int>, n: int) {
type
config
=
{
stress
:
bool
};
fn
parse_opts
(
argv
:
[
str
])
->
config
{
let
opts
=
[
getopts
::
optflag
(
"stress"
)];
let
argv
=
istr
::
from_estrs
(
argv
);
let
opts
=
[
getopts
::
optflag
(
~
"stress"
)];
let
opt_args
=
vec
::
slice
(
argv
,
1u
,
vec
::
len
(
argv
));
alt
getopts
::
getopts
(
opt_args
,
opts
)
{
getopts
::
success
(
m
)
{
ret
{
stress
:
getopts
::
opt_present
(
m
,
"stress"
)}
}
getopts
::
success
(
m
)
{
ret
{
stress
:
getopts
::
opt_present
(
m
,
~
"stress"
)}
}
getopts
::
failure
(
_
)
{
fail
;
}
}
}
...
...
src/test/compiletest/compiletest.rs
浏览文件 @
4cf2e510
...
...
@@ -30,45 +30,45 @@ fn main(args: [str]) {
}
fn
parse_config
(
args
:
&
[
str
])
->
config
{
let
args
=
istr
::
from_estrs
(
args
);
let
opts
=
[
getopts
::
reqopt
(
"compile-lib-path"
),
getopts
::
reqopt
(
"run-lib-path"
),
getopts
::
reqopt
(
"rustc-path"
),
getopts
::
reqopt
(
"src-base"
),
getopts
::
reqopt
(
"build-base"
),
getopts
::
reqopt
(
"stage-id"
),
getopts
::
reqopt
(
"mode"
),
getopts
::
optflag
(
"ignored"
),
getopts
::
optopt
(
"runtool"
),
getopts
::
optopt
(
"rustcflags"
),
getopts
::
optflag
(
"verbose"
)];
[
getopts
::
reqopt
(
~
"compile-lib-path"
),
getopts
::
reqopt
(
~
"run-lib-path"
),
getopts
::
reqopt
(
~
"rustc-path"
),
getopts
::
reqopt
(
~
"src-base"
),
getopts
::
reqopt
(
~
"build-base"
),
getopts
::
reqopt
(
~
"stage-id"
),
getopts
::
reqopt
(
~
"mode"
),
getopts
::
optflag
(
~
"ignored"
),
getopts
::
optopt
(
~
"runtool"
),
getopts
::
optopt
(
~
"rustcflags"
),
getopts
::
optflag
(
~
"verbose"
)];
check
(
vec
::
is_not_empty
(
args
));
let
args_
=
vec
::
tail
(
args
);
let
match
=
alt
getopts
::
getopts
(
args_
,
opts
)
{
getopts
::
success
(
m
)
{
m
}
getopts
::
failure
(
f
)
{
fail
getopts
::
fail_str
(
f
)
}
getopts
::
failure
(
f
)
{
fail
istr
::
to_estr
(
getopts
::
fail_str
(
f
))
}
};
let
cnv
=
istr
::
from_estr
;
let
cnvo
=
fn
(
o
:
&
option
::
t
<
str
>
)
->
option
::
t
<
istr
>
{
alt
o
{
option
::
some
(
s
)
{
option
::
some
(
istr
::
from_estr
(
s
))
}
option
::
none
.
{
option
::
none
}
}
};
ret
{
compile_lib_path
:
cnv
(
getopts
::
opt_str
(
match
,
"compile-lib-path"
)),
run_lib_path
:
cnv
(
getopts
::
opt_str
(
match
,
"run-lib-path"
)),
rustc_path
:
cnv
(
getopts
::
opt_str
(
match
,
"rustc-path"
)),
src_base
:
cnv
(
getopts
::
opt_str
(
match
,
"src-base"
)),
build_base
:
cnv
(
getopts
::
opt_str
(
match
,
"build-base"
)),
stage_id
:
cnv
(
getopts
::
opt_str
(
match
,
"stage-id"
)),
mode
:
str_mode
(
getopts
::
opt_str
(
match
,
"mode"
)),
run_ignored
:
getopts
::
opt_present
(
match
,
"ignored"
),
ret
{
compile_lib_path
:
getopts
::
opt_str
(
match
,
~
"compile-lib-path"
),
run_lib_path
:
getopts
::
opt_str
(
match
,
~
"run-lib-path"
),
rustc_path
:
getopts
::
opt_str
(
match
,
~
"rustc-path"
),
src_base
:
getopts
::
opt_str
(
match
,
~
"src-base"
),
build_base
:
getopts
::
opt_str
(
match
,
~
"build-base"
),
stage_id
:
getopts
::
opt_str
(
match
,
~
"stage-id"
),
mode
:
str_mode
(
istr
::
to_estr
(
getopts
::
opt_str
(
match
,
~
"mode"
))),
run_ignored
:
getopts
::
opt_present
(
match
,
~
"ignored"
),
filter
:
if
vec
::
len
(
match
.free
)
>
0u
{
option
::
some
(
cnv
(
match
.free
[
0
])
)
option
::
some
(
match
.free
[
0
]
)
}
else
{
option
::
none
},
runtool
:
cnvo
(
getopts
::
opt_maybe_str
(
match
,
"runtool"
)
),
rustcflags
:
cnvo
(
getopts
::
opt_maybe_str
(
match
,
"rustcflags"
)
),
verbose
:
getopts
::
opt_present
(
match
,
"verbose"
)};
runtool
:
getopts
::
opt_maybe_str
(
match
,
~
"runtool"
),
rustcflags
:
getopts
::
opt_maybe_str
(
match
,
~
"rustcflags"
),
verbose
:
getopts
::
opt_present
(
match
,
~
"verbose"
)};
}
fn
log_config
(
config
:
&
config
)
{
...
...
src/test/stdtest/getopts.rs
浏览文件 @
4cf2e510
...
...
@@ -27,13 +27,13 @@ fn check_fail_type(f: opt::fail_, ft: fail_type) {
// Tests for reqopt
#[test]
fn
test_reqopt_long
()
{
let
args
=
[
"--test=20"
];
let
opts
=
[
opt
::
reqopt
(
"test"
)];
let
args
=
[
~
"--test=20"
];
let
opts
=
[
opt
::
reqopt
(
~
"test"
)];
let
rs
=
opt
::
getopts
(
args
,
opts
);
alt
rs
{
opt
::
success
(
m
)
{
assert
(
opt
::
opt_present
(
m
,
"test"
));
assert
(
opt
::
opt_str
(
m
,
"test"
)
==
"20"
);
assert
(
opt
::
opt_present
(
m
,
~
"test"
));
assert
(
opt
::
opt_str
(
m
,
~
"test"
)
==
~
"20"
);
}
_
{
fail
;
}
}
...
...
@@ -41,8 +41,8 @@ fn test_reqopt_long() {
#[test]
fn
test_reqopt_long_missing
()
{
let
args
=
[
"blah"
];
let
opts
=
[
opt
::
reqopt
(
"test"
)];
let
args
=
[
~
"blah"
];
let
opts
=
[
opt
::
reqopt
(
~
"test"
)];
let
rs
=
opt
::
getopts
(
args
,
opts
);
alt
rs
{
opt
::
failure
(
f
)
{
check_fail_type
(
f
,
option_missing
);
}
...
...
@@ -52,8 +52,8 @@ fn test_reqopt_long_missing() {
#[test]
fn
test_reqopt_long_no_arg
()
{
let
args
=
[
"--test"
];
let
opts
=
[
opt
::
reqopt
(
"test"
)];
let
args
=
[
~
"--test"
];
let
opts
=
[
opt
::
reqopt
(
~
"test"
)];
let
rs
=
opt
::
getopts
(
args
,
opts
);
alt
rs
{
opt
::
failure
(
f
)
{
check_fail_type
(
f
,
argument_missing
);
}
...
...
@@ -63,8 +63,8 @@ fn test_reqopt_long_no_arg() {
#[test]
fn
test_reqopt_long_multi
()
{
let
args
=
[
"--test=20"
,
"--test=30"
];
let
opts
=
[
opt
::
reqopt
(
"test"
)];
let
args
=
[
~
"--test=20"
,
~
"--test=30"
];
let
opts
=
[
opt
::
reqopt
(
~
"test"
)];
let
rs
=
opt
::
getopts
(
args
,
opts
);
alt
rs
{
opt
::
failure
(
f
)
{
check_fail_type
(
f
,
option_duplicated
);
}
...
...
@@ -74,13 +74,13 @@ fn test_reqopt_long_multi() {
#[test]
fn
test_reqopt_short
()
{
let
args
=
[
"-t"
,
"20"
];
let
opts
=
[
opt
::
reqopt
(
"t"
)];
let
args
=
[
~
"-t"
,
~
"20"
];
let
opts
=
[
opt
::
reqopt
(
~
"t"
)];
let
rs
=
opt
::
getopts
(
args
,
opts
);
alt
rs
{
opt
::
success
(
m
)
{
assert
(
opt
::
opt_present
(
m
,
"t"
));
assert
(
opt
::
opt_str
(
m
,
"t"
)
==
"20"
);
assert
(
opt
::
opt_present
(
m
,
~
"t"
));
assert
(
opt
::
opt_str
(
m
,
~
"t"
)
==
~
"20"
);
}
_
{
fail
;
}
}
...
...
@@ -88,8 +88,8 @@ fn test_reqopt_short() {
#[test]
fn
test_reqopt_short_missing
()
{
let
args
=
[
"blah"
];
let
opts
=
[
opt
::
reqopt
(
"t"
)];
let
args
=
[
~
"blah"
];
let
opts
=
[
opt
::
reqopt
(
~
"t"
)];
let
rs
=
opt
::
getopts
(
args
,
opts
);
alt
rs
{
opt
::
failure
(
f
)
{
check_fail_type
(
f
,
option_missing
);
}
...
...
@@ -99,8 +99,8 @@ fn test_reqopt_short_missing() {
#[test]
fn
test_reqopt_short_no_arg
()
{
let
args
=
[
"-t"
];
let
opts
=
[
opt
::
reqopt
(
"t"
)];
let
args
=
[
~
"-t"
];
let
opts
=
[
opt
::
reqopt
(
~
"t"
)];
let
rs
=
opt
::
getopts
(
args
,
opts
);
alt
rs
{
opt
::
failure
(
f
)
{
check_fail_type
(
f
,
argument_missing
);
}
...
...
@@ -110,8 +110,8 @@ fn test_reqopt_short_no_arg() {
#[test]
fn
test_reqopt_short_multi
()
{
let
args
=
[
"-t"
,
"20"
,
"-t"
,
"30"
];
let
opts
=
[
opt
::
reqopt
(
"t"
)];
let
args
=
[
~
"-t"
,
~
"20"
,
~
"-t"
,
~
"30"
];
let
opts
=
[
opt
::
reqopt
(
~
"t"
)];
let
rs
=
opt
::
getopts
(
args
,
opts
);
alt
rs
{
opt
::
failure
(
f
)
{
check_fail_type
(
f
,
option_duplicated
);
}
...
...
@@ -123,13 +123,13 @@ fn test_reqopt_short_multi() {
// Tests for optopt
#[test]
fn
test_optopt_long
()
{
let
args
=
[
"--test=20"
];
let
opts
=
[
opt
::
optopt
(
"test"
)];
let
args
=
[
~
"--test=20"
];
let
opts
=
[
opt
::
optopt
(
~
"test"
)];
let
rs
=
opt
::
getopts
(
args
,
opts
);
alt
rs
{
opt
::
success
(
m
)
{
assert
(
opt
::
opt_present
(
m
,
"test"
));
assert
(
opt
::
opt_str
(
m
,
"test"
)
==
"20"
);
assert
(
opt
::
opt_present
(
m
,
~
"test"
));
assert
(
opt
::
opt_str
(
m
,
~
"test"
)
==
~
"20"
);
}
_
{
fail
;
}
}
...
...
@@ -137,19 +137,19 @@ fn test_optopt_long() {
#[test]
fn
test_optopt_long_missing
()
{
let
args
=
[
"blah"
];
let
opts
=
[
opt
::
optopt
(
"test"
)];
let
args
=
[
~
"blah"
];
let
opts
=
[
opt
::
optopt
(
~
"test"
)];
let
rs
=
opt
::
getopts
(
args
,
opts
);
alt
rs
{
opt
::
success
(
m
)
{
assert
(
!
opt
::
opt_present
(
m
,
"test"
));
}
opt
::
success
(
m
)
{
assert
(
!
opt
::
opt_present
(
m
,
~
"test"
));
}
_
{
fail
;
}
}
}
#[test]
fn
test_optopt_long_no_arg
()
{
let
args
=
[
"--test"
];
let
opts
=
[
opt
::
optopt
(
"test"
)];
let
args
=
[
~
"--test"
];
let
opts
=
[
opt
::
optopt
(
~
"test"
)];
let
rs
=
opt
::
getopts
(
args
,
opts
);
alt
rs
{
opt
::
failure
(
f
)
{
check_fail_type
(
f
,
argument_missing
);
}
...
...
@@ -159,8 +159,8 @@ fn test_optopt_long_no_arg() {
#[test]
fn
test_optopt_long_multi
()
{
let
args
=
[
"--test=20"
,
"--test=30"
];
let
opts
=
[
opt
::
optopt
(
"test"
)];
let
args
=
[
~
"--test=20"
,
~
"--test=30"
];
let
opts
=
[
opt
::
optopt
(
~
"test"
)];
let
rs
=
opt
::
getopts
(
args
,
opts
);
alt
rs
{
opt
::
failure
(
f
)
{
check_fail_type
(
f
,
option_duplicated
);
}
...
...
@@ -170,13 +170,13 @@ fn test_optopt_long_multi() {
#[test]
fn
test_optopt_short
()
{
let
args
=
[
"-t"
,
"20"
];
let
opts
=
[
opt
::
optopt
(
"t"
)];
let
args
=
[
~
"-t"
,
~
"20"
];
let
opts
=
[
opt
::
optopt
(
~
"t"
)];
let
rs
=
opt
::
getopts
(
args
,
opts
);
alt
rs
{
opt
::
success
(
m
)
{
assert
(
opt
::
opt_present
(
m
,
"t"
));
assert
(
opt
::
opt_str
(
m
,
"t"
)
==
"20"
);
assert
(
opt
::
opt_present
(
m
,
~
"t"
));
assert
(
opt
::
opt_str
(
m
,
~
"t"
)
==
~
"20"
);
}
_
{
fail
;
}
}
...
...
@@ -184,19 +184,19 @@ fn test_optopt_short() {
#[test]
fn
test_optopt_short_missing
()
{
let
args
=
[
"blah"
];
let
opts
=
[
opt
::
optopt
(
"t"
)];
let
args
=
[
~
"blah"
];
let
opts
=
[
opt
::
optopt
(
~
"t"
)];
let
rs
=
opt
::
getopts
(
args
,
opts
);
alt
rs
{
opt
::
success
(
m
)
{
assert
(
!
opt
::
opt_present
(
m
,
"t"
));
}
opt
::
success
(
m
)
{
assert
(
!
opt
::
opt_present
(
m
,
~
"t"
));
}
_
{
fail
;
}
}
}
#[test]
fn
test_optopt_short_no_arg
()
{
let
args
=
[
"-t"
];
let
opts
=
[
opt
::
optopt
(
"t"
)];
let
args
=
[
~
"-t"
];
let
opts
=
[
opt
::
optopt
(
~
"t"
)];
let
rs
=
opt
::
getopts
(
args
,
opts
);
alt
rs
{
opt
::
failure
(
f
)
{
check_fail_type
(
f
,
argument_missing
);
}
...
...
@@ -206,8 +206,8 @@ fn test_optopt_short_no_arg() {
#[test]
fn
test_optopt_short_multi
()
{
let
args
=
[
"-t"
,
"20"
,
"-t"
,
"30"
];
let
opts
=
[
opt
::
optopt
(
"t"
)];
let
args
=
[
~
"-t"
,
~
"20"
,
~
"-t"
,
~
"30"
];
let
opts
=
[
opt
::
optopt
(
~
"t"
)];
let
rs
=
opt
::
getopts
(
args
,
opts
);
alt
rs
{
opt
::
failure
(
f
)
{
check_fail_type
(
f
,
option_duplicated
);
}
...
...
@@ -219,30 +219,30 @@ fn test_optopt_short_multi() {
// Tests for optflag
#[test]
fn
test_optflag_long
()
{
let
args
=
[
"--test"
];
let
opts
=
[
opt
::
optflag
(
"test"
)];
let
args
=
[
~
"--test"
];
let
opts
=
[
opt
::
optflag
(
~
"test"
)];
let
rs
=
opt
::
getopts
(
args
,
opts
);
alt
rs
{
opt
::
success
(
m
)
{
assert
(
opt
::
opt_present
(
m
,
"test"
));
}
opt
::
success
(
m
)
{
assert
(
opt
::
opt_present
(
m
,
~
"test"
));
}
_
{
fail
;
}
}
}
#[test]
fn
test_optflag_long_missing
()
{
let
args
=
[
"blah"
];
let
opts
=
[
opt
::
optflag
(
"test"
)];
let
args
=
[
~
"blah"
];
let
opts
=
[
opt
::
optflag
(
~
"test"
)];
let
rs
=
opt
::
getopts
(
args
,
opts
);
alt
rs
{
opt
::
success
(
m
)
{
assert
(
!
opt
::
opt_present
(
m
,
"test"
));
}
opt
::
success
(
m
)
{
assert
(
!
opt
::
opt_present
(
m
,
~
"test"
));
}
_
{
fail
;
}
}
}
#[test]
fn
test_optflag_long_arg
()
{
let
args
=
[
"--test=20"
];
let
opts
=
[
opt
::
optflag
(
"test"
)];
let
args
=
[
~
"--test=20"
];
let
opts
=
[
opt
::
optflag
(
~
"test"
)];
let
rs
=
opt
::
getopts
(
args
,
opts
);
alt
rs
{
opt
::
failure
(
f
)
{
...
...
@@ -255,8 +255,8 @@ fn test_optflag_long_arg() {
#[test]
fn
test_optflag_long_multi
()
{
let
args
=
[
"--test"
,
"--test"
];
let
opts
=
[
opt
::
optflag
(
"test"
)];
let
args
=
[
~
"--test"
,
~
"--test"
];
let
opts
=
[
opt
::
optflag
(
~
"test"
)];
let
rs
=
opt
::
getopts
(
args
,
opts
);
alt
rs
{
opt
::
failure
(
f
)
{
check_fail_type
(
f
,
option_duplicated
);
}
...
...
@@ -266,36 +266,36 @@ fn test_optflag_long_multi() {
#[test]
fn
test_optflag_short
()
{
let
args
=
[
"-t"
];
let
opts
=
[
opt
::
optflag
(
"t"
)];
let
args
=
[
~
"-t"
];
let
opts
=
[
opt
::
optflag
(
~
"t"
)];
let
rs
=
opt
::
getopts
(
args
,
opts
);
alt
rs
{
opt
::
success
(
m
)
{
assert
(
opt
::
opt_present
(
m
,
"t"
));
}
opt
::
success
(
m
)
{
assert
(
opt
::
opt_present
(
m
,
~
"t"
));
}
_
{
fail
;
}
}
}
#[test]
fn
test_optflag_short_missing
()
{
let
args
=
[
"blah"
];
let
opts
=
[
opt
::
optflag
(
"t"
)];
let
args
=
[
~
"blah"
];
let
opts
=
[
opt
::
optflag
(
~
"t"
)];
let
rs
=
opt
::
getopts
(
args
,
opts
);
alt
rs
{
opt
::
success
(
m
)
{
assert
(
!
opt
::
opt_present
(
m
,
"t"
));
}
opt
::
success
(
m
)
{
assert
(
!
opt
::
opt_present
(
m
,
~
"t"
));
}
_
{
fail
;
}
}
}
#[test]
fn
test_optflag_short_arg
()
{
let
args
=
[
"-t"
,
"20"
];
let
opts
=
[
opt
::
optflag
(
"t"
)];
let
args
=
[
~
"-t"
,
~
"20"
];
let
opts
=
[
opt
::
optflag
(
~
"t"
)];
let
rs
=
opt
::
getopts
(
args
,
opts
);
alt
rs
{
opt
::
success
(
m
)
{
// The next variable after the flag is just a free argument
assert
(
m
.free
[
0
]
==
"20"
);
assert
(
m
.free
[
0
]
==
~
"20"
);
}
_
{
fail
;
}
}
...
...
@@ -303,8 +303,8 @@ fn test_optflag_short_arg() {
#[test]
fn
test_optflag_short_multi
()
{
let
args
=
[
"-t"
,
"-t"
];
let
opts
=
[
opt
::
optflag
(
"t"
)];
let
args
=
[
~
"-t"
,
~
"-t"
];
let
opts
=
[
opt
::
optflag
(
~
"t"
)];
let
rs
=
opt
::
getopts
(
args
,
opts
);
alt
rs
{
opt
::
failure
(
f
)
{
check_fail_type
(
f
,
option_duplicated
);
}
...
...
@@ -316,13 +316,13 @@ fn test_optflag_short_multi() {
// Tests for optmulti
#[test]
fn
test_optmulti_long
()
{
let
args
=
[
"--test=20"
];
let
opts
=
[
opt
::
optmulti
(
"test"
)];
let
args
=
[
~
"--test=20"
];
let
opts
=
[
opt
::
optmulti
(
~
"test"
)];
let
rs
=
opt
::
getopts
(
args
,
opts
);
alt
rs
{
opt
::
success
(
m
)
{
assert
(
opt
::
opt_present
(
m
,
"test"
));
assert
(
opt
::
opt_str
(
m
,
"test"
)
==
"20"
);
assert
(
opt
::
opt_present
(
m
,
~
"test"
));
assert
(
opt
::
opt_str
(
m
,
~
"test"
)
==
~
"20"
);
}
_
{
fail
;
}
}
...
...
@@ -330,19 +330,19 @@ fn test_optmulti_long() {
#[test]
fn
test_optmulti_long_missing
()
{
let
args
=
[
"blah"
];
let
opts
=
[
opt
::
optmulti
(
"test"
)];
let
args
=
[
~
"blah"
];
let
opts
=
[
opt
::
optmulti
(
~
"test"
)];
let
rs
=
opt
::
getopts
(
args
,
opts
);
alt
rs
{
opt
::
success
(
m
)
{
assert
(
!
opt
::
opt_present
(
m
,
"test"
));
}
opt
::
success
(
m
)
{
assert
(
!
opt
::
opt_present
(
m
,
~
"test"
));
}
_
{
fail
;
}
}
}
#[test]
fn
test_optmulti_long_no_arg
()
{
let
args
=
[
"--test"
];
let
opts
=
[
opt
::
optmulti
(
"test"
)];
let
args
=
[
~
"--test"
];
let
opts
=
[
opt
::
optmulti
(
~
"test"
)];
let
rs
=
opt
::
getopts
(
args
,
opts
);
alt
rs
{
opt
::
failure
(
f
)
{
check_fail_type
(
f
,
argument_missing
);
}
...
...
@@ -352,15 +352,15 @@ fn test_optmulti_long_no_arg() {
#[test]
fn
test_optmulti_long_multi
()
{
let
args
=
[
"--test=20"
,
"--test=30"
];
let
opts
=
[
opt
::
optmulti
(
"test"
)];
let
args
=
[
~
"--test=20"
,
~
"--test=30"
];
let
opts
=
[
opt
::
optmulti
(
~
"test"
)];
let
rs
=
opt
::
getopts
(
args
,
opts
);
alt
rs
{
opt
::
success
(
m
)
{
assert
(
opt
::
opt_present
(
m
,
"test"
));
assert
(
opt
::
opt_str
(
m
,
"test"
)
==
"20"
);
assert
(
opt
::
opt_strs
(
m
,
"test"
)[
0
]
==
"20"
);
assert
(
opt
::
opt_strs
(
m
,
"test"
)[
1
]
==
"30"
);
assert
(
opt
::
opt_present
(
m
,
~
"test"
));
assert
(
opt
::
opt_str
(
m
,
~
"test"
)
==
~
"20"
);
assert
(
opt
::
opt_strs
(
m
,
~
"test"
)[
0
]
==
~
"20"
);
assert
(
opt
::
opt_strs
(
m
,
~
"test"
)[
1
]
==
~
"30"
);
}
_
{
fail
;
}
}
...
...
@@ -368,13 +368,13 @@ fn test_optmulti_long_multi() {
#[test]
fn
test_optmulti_short
()
{
let
args
=
[
"-t"
,
"20"
];
let
opts
=
[
opt
::
optmulti
(
"t"
)];
let
args
=
[
~
"-t"
,
~
"20"
];
let
opts
=
[
opt
::
optmulti
(
~
"t"
)];
let
rs
=
opt
::
getopts
(
args
,
opts
);
alt
rs
{
opt
::
success
(
m
)
{
assert
(
opt
::
opt_present
(
m
,
"t"
));
assert
(
opt
::
opt_str
(
m
,
"t"
)
==
"20"
);
assert
(
opt
::
opt_present
(
m
,
~
"t"
));
assert
(
opt
::
opt_str
(
m
,
~
"t"
)
==
~
"20"
);
}
_
{
fail
;
}
}
...
...
@@ -382,19 +382,19 @@ fn test_optmulti_short() {
#[test]
fn
test_optmulti_short_missing
()
{
let
args
=
[
"blah"
];
let
opts
=
[
opt
::
optmulti
(
"t"
)];
let
args
=
[
~
"blah"
];
let
opts
=
[
opt
::
optmulti
(
~
"t"
)];
let
rs
=
opt
::
getopts
(
args
,
opts
);
alt
rs
{
opt
::
success
(
m
)
{
assert
(
!
opt
::
opt_present
(
m
,
"t"
));
}
opt
::
success
(
m
)
{
assert
(
!
opt
::
opt_present
(
m
,
~
"t"
));
}
_
{
fail
;
}
}
}
#[test]
fn
test_optmulti_short_no_arg
()
{
let
args
=
[
"-t"
];
let
opts
=
[
opt
::
optmulti
(
"t"
)];
let
args
=
[
~
"-t"
];
let
opts
=
[
opt
::
optmulti
(
~
"t"
)];
let
rs
=
opt
::
getopts
(
args
,
opts
);
alt
rs
{
opt
::
failure
(
f
)
{
check_fail_type
(
f
,
argument_missing
);
}
...
...
@@ -404,15 +404,15 @@ fn test_optmulti_short_no_arg() {
#[test]
fn
test_optmulti_short_multi
()
{
let
args
=
[
"-t"
,
"20"
,
"-t"
,
"30"
];
let
opts
=
[
opt
::
optmulti
(
"t"
)];
let
args
=
[
~
"-t"
,
~
"20"
,
~
"-t"
,
~
"30"
];
let
opts
=
[
opt
::
optmulti
(
~
"t"
)];
let
rs
=
opt
::
getopts
(
args
,
opts
);
alt
rs
{
opt
::
success
(
m
)
{
assert
(
opt
::
opt_present
(
m
,
"t"
));
assert
(
opt
::
opt_str
(
m
,
"t"
)
==
"20"
);
assert
(
opt
::
opt_strs
(
m
,
"t"
)[
0
]
==
"20"
);
assert
(
opt
::
opt_strs
(
m
,
"t"
)[
1
]
==
"30"
);
assert
(
opt
::
opt_present
(
m
,
~
"t"
));
assert
(
opt
::
opt_str
(
m
,
~
"t"
)
==
~
"20"
);
assert
(
opt
::
opt_strs
(
m
,
~
"t"
)[
0
]
==
~
"20"
);
assert
(
opt
::
opt_strs
(
m
,
~
"t"
)[
1
]
==
~
"30"
);
}
_
{
fail
;
}
}
...
...
@@ -420,8 +420,8 @@ fn test_optmulti_short_multi() {
#[test]
fn
test_unrecognized_option_long
()
{
let
args
=
[
"--untest"
];
let
opts
=
[
opt
::
optmulti
(
"t"
)];
let
args
=
[
~
"--untest"
];
let
opts
=
[
opt
::
optmulti
(
~
"t"
)];
let
rs
=
opt
::
getopts
(
args
,
opts
);
alt
rs
{
opt
::
failure
(
f
)
{
check_fail_type
(
f
,
unrecognized_option
);
}
...
...
@@ -431,8 +431,8 @@ fn test_unrecognized_option_long() {
#[test]
fn
test_unrecognized_option_short
()
{
let
args
=
[
"-t"
];
let
opts
=
[
opt
::
optmulti
(
"test"
)];
let
args
=
[
~
"-t"
];
let
opts
=
[
opt
::
optmulti
(
~
"test"
)];
let
rs
=
opt
::
getopts
(
args
,
opts
);
alt
rs
{
opt
::
failure
(
f
)
{
check_fail_type
(
f
,
unrecognized_option
);
}
...
...
@@ -443,24 +443,25 @@ fn test_unrecognized_option_short() {
#[test]
fn
test_combined
()
{
let
args
=
[
"prog"
,
"free1"
,
"-s"
,
"20"
,
"free2"
,
"--flag"
,
"--long=30"
,
"-f
"
,
"-m"
,
"40"
,
"-m"
,
"50"
];
[
~
"prog"
,
~
"free1"
,
~
"-s"
,
~
"20"
,
~
"free2"
,
~
"--flag
"
,
~
"--long=30"
,
~
"-f"
,
~
"-m"
,
~
"40"
,
~
"-m"
,
~
"50"
];
let
opts
=
[
opt
::
optopt
(
"s"
),
opt
::
optflag
(
"flag"
),
opt
::
reqopt
(
"long"
),
opt
::
optflag
(
"f"
),
opt
::
optmulti
(
"m"
),
opt
::
optopt
(
"notpresent"
)];
[
opt
::
optopt
(
~
"s"
),
opt
::
optflag
(
~
"flag"
),
opt
::
reqopt
(
~
"long"
),
opt
::
optflag
(
~
"f"
),
opt
::
optmulti
(
~
"m"
),
opt
::
optopt
(
~
"notpresent"
)];
let
rs
=
opt
::
getopts
(
args
,
opts
);
alt
rs
{
opt
::
success
(
m
)
{
assert
(
m
.free
[
0
]
==
"prog"
);
assert
(
m
.free
[
1
]
==
"free1"
);
assert
(
opt
::
opt_str
(
m
,
"s"
)
==
"20"
);
assert
(
m
.free
[
2
]
==
"free2"
);
assert
(
opt
::
opt_present
(
m
,
"flag"
));
assert
(
opt
::
opt_str
(
m
,
"long"
)
==
"30"
);
assert
(
opt
::
opt_present
(
m
,
"f"
));
assert
(
opt
::
opt_strs
(
m
,
"m"
)[
0
]
==
"40"
);
assert
(
opt
::
opt_strs
(
m
,
"m"
)[
1
]
==
"50"
);
assert
(
!
opt
::
opt_present
(
m
,
"notpresent"
));
assert
(
m
.free
[
0
]
==
~
"prog"
);
assert
(
m
.free
[
1
]
==
~
"free1"
);
assert
(
opt
::
opt_str
(
m
,
~
"s"
)
==
~
"20"
);
assert
(
m
.free
[
2
]
==
~
"free2"
);
assert
(
opt
::
opt_present
(
m
,
~
"flag"
));
assert
(
opt
::
opt_str
(
m
,
~
"long"
)
==
~
"30"
);
assert
(
opt
::
opt_present
(
m
,
~
"f"
));
assert
(
opt
::
opt_strs
(
m
,
~
"m"
)[
0
]
==
~
"40"
);
assert
(
opt
::
opt_strs
(
m
,
~
"m"
)[
1
]
==
~
"50"
);
assert
(
!
opt
::
opt_present
(
m
,
~
"notpresent"
));
}
_
{
fail
;
}
}
...
...
编辑
预览
Markdown
is supported
0%
请重试
或
添加新附件
.
添加附件
取消
You are about to add
0
people
to the discussion. Proceed with caution.
先完成此消息的编辑!
取消
想要评论请
注册
或
登录