Implement CharIterator as a separate struct, so that it can be .clone()'d. Fix `.char_range_at_reverse` so that it performs better, closer to the forwards version. This makes the reverse iterators and users like `.rfind()` perform better.
Before
test str::bench::char_iterator ... bench: 146 ns/iter (+/- 0)
test str::bench::char_iterator_ascii ... bench: 397 ns/iter (+/- 49)
test str::bench::char_iterator_rev ... bench: 576 ns/iter (+/- 8)
test str::bench::char_offset_iterator ... bench: 128 ns/iter (+/- 2)
test str::bench::char_offset_iterator_rev ... bench: 425 ns/iter (+/- 59)
After
test str::bench::char_iterator ... bench: 130 ns/iter (+/- 1)
test str::bench::char_iterator_ascii ... bench: 307 ns/iter (+/- 5)
test str::bench::char_iterator_rev ... bench: 185 ns/iter (+/- 8)
test str::bench::char_offset_iterator ... bench: 131 ns/iter (+/- 13)
test str::bench::char_offset_iterator_rev ... bench: 183 ns/iter (+/- 2)
To be able to use a string slice to represent the CharIterator, a function `slice_unchecked` is added, that does the same as `slice_bytes` but without any boundary checks.
It would be possible to implement CharIterator with pointer arithmetic to make it *much more efficient*, but since vec iterator is still improving, it's too early to attempt to re-implement it in other places. Hopefully CharIterator can be implemented on top of vec iterator without any unsafe code later.
Additional changes fix the documentation about null termination.
make_dir $h/test/doc-tutorial-ffi
make_dir $h/test/doc-tutorial-macros
make_dir $h/test/doc-tutorial-borrowed-ptr
+ make_dir $h/test/doc-tutorial-container
make_dir $h/test/doc-tutorial-tasks
+ make_dir $h/test/doc-tutorial-conditions
make_dir $h/test/doc-rust
done
Each source file contains a sequence of zero or more `item` definitions,
and may optionally begin with any number of `attributes` that apply to the containing module.
-Atributes on the anonymous crate module define important metadata that influences
+Attributes on the anonymous crate module define important metadata that influences
the behavior of the compiler.
~~~~~~~~
##### Use declarations
~~~~~~~~ {.ebnf .gram}
-use_decl : "pub"? "use" ident [ '=' path
+use_decl : "pub" ? "use" ident [ '=' path
| "::" path_glob ] ;
path_glob : ident [ "::" path_glob ] ?
In type-parameterized functions,
methods of the supertrait may be called on values of subtrait-bound type parameters.
-Refering to the previous example of `trait Circle : Shape`:
+Referring to the previous example of `trait Circle : Shape`:
~~~
# trait Shape { fn area(&self) -> float; }
When the field is mutable, it can be [assigned](#assignment-expressions) to.
When the type of the expression to the left of the dot is a pointer to a record or structure,
-it is automatically derferenced to make the field access possible.
+it is automatically dereferenced to make the field access possible.
### Vector expressions
~~~~~~~~{.ebnf .gram}
-vec_expr : '[' "mut"? vec_elems? ']'
+vec_expr : '[' "mut" ? vec_elems? ']'
vec_elems : [expr [',' expr]*] | [expr ',' ".." expr]
~~~~~~~~
An example of an object type:
~~~~~~~~
-# use std::int;
trait Printable {
- fn to_str(&self) -> ~str;
+ fn to_string(&self) -> ~str;
}
impl Printable for int {
- fn to_str(&self) -> ~str { int::to_str(*self) }
+ fn to_string(&self) -> ~str { self.to_str() }
}
fn print(a: @Printable) {
- println(a.to_str());
+ println(a.to_string());
}
fn main() {
--- /dev/null
+% Rust Condition and Error-handling Tutorial
+
+# Introduction
+
+Rust does not provide exception handling[^why-no-exceptions]
+in the form most commonly seen in other programming languages such as C++ or Java.
+Instead, it provides four mechanisms that work together to handle errors or other rare events.
+The four mechanisms are:
+
+ - Options
+ - Results
+ - Failure
+ - Conditions
+
+This tutorial will lead you through use of these mechanisms
+in order to understand the trade-offs of each and relationships between them.
+
+# Example program
+
+This tutorial will be based around an example program
+that attempts to read lines from a file
+consisting of pairs of numbers,
+and then print them back out with slightly different formatting.
+The input to the program might look like this:
+
+~~~~ {.notrust}
+$ cat numbers.txt
+1 2
+34 56
+789 123
+45 67
+~~~~
+
+For which the intended output looks like this:
+
+~~~~ {.notrust}
+$ ./example numbers.txt
+0001, 0002
+0034, 0056
+0789, 0123
+0045, 0067
+~~~~
+
+An example program that does this task reads like this:
+
+~~~~
+# #[allow(unused_imports)];
+extern mod extra;
+use extra::fileinput::FileInput;
+use std::int;
+# mod FileInput {
+# use std::io::{Reader, BytesReader};
+# static s : &'static [u8] = bytes!("1 2\n\
+# 34 56\n\
+# 789 123\n\
+# 45 67\n\
+# ");
+# pub fn from_args() -> @Reader{
+# @BytesReader {
+# bytes: s,
+# pos: @mut 0
+# } as @Reader
+# }
+# }
+
+fn main() {
+ let pairs = read_int_pairs();
+ for &(a,b) in pairs.iter() {
+ println(fmt!("%4.4d, %4.4d", a, b));
+ }
+}
+
+
+fn read_int_pairs() -> ~[(int,int)] {
+
+ let mut pairs = ~[];
+
+ let fi = FileInput::from_args();
+ while ! fi.eof() {
+
+ // 1. Read a line of input.
+ let line = fi.read_line();
+
+ // 2. Split the line into fields ("words").
+ let fields = line.word_iter().to_owned_vec();
+
+ // 3. Match the vector of fields against a vector pattern.
+ match fields {
+
+ // 4. When the line had two fields:
+ [a, b] => {
+
+ // 5. Try parsing both fields as ints.
+ match (int::from_str(a), int::from_str(b)) {
+
+ // 6. If parsing succeeded for both, push both.
+ (Some(a), Some(b)) => pairs.push((a,b)),
+
+ // 7. Ignore non-int fields.
+ _ => ()
+ }
+ }
+
+ // 8. Ignore lines that don't have 2 fields.
+ _ => ()
+ }
+ }
+
+ pairs
+}
+~~~~
+
+This example shows the use of `Option`,
+along with some other forms of error-handling (and non-handling).
+We will look at these mechanisms
+and then modify parts of the example to perform "better" error handling.
+
+
+# Options
+
+The simplest and most lightweight mechanism in Rust for indicating an error is the type `std::option::Option<T>`.
+This type is a general purpose `enum`
+for conveying a value of type `T`, represented as `Some(T)`
+_or_ the sentinel `None`, to indicate the absence of a `T` value.
+For simple APIs, it may be sufficient to encode errors as `Option<T>`,
+returning `Some(T)` on success and `None` on error.
+In the example program, the call to `int::from_str` returns `Option<int>`
+with the understanding that "all parse errors" result in `None`.
+The resulting `Option<int>` values are matched against the pattern `(Some(a), Some(b))`
+in steps 5 and 6 in the example program,
+to handle the case in which both fields were parsed successfully.
+
+Using `Option` as in this API has some advantages:
+
+ - Simple API, users can read it and guess how it works.
+ - Very efficient, only an extra `enum` tag on return values.
+ - Caller has flexibility in handling or propagating errors.
+ - Caller is forced to acknowledge existence of possible-error before using value.
+
+However, it has serious disadvantages too:
+
+ - Verbose, requires matching results or calling `Option::unwrap` everywhere.
+ - Infects caller: if caller doesn't know how to handle the error, must propagate (or force).
+ - Temptation to do just that: force the `Some(T)` case by blindly calling `unwrap`,
+ which hides the error from the API without providing any way to make the program robust against the error.
+ - Collapses all errors into one:
+ - Caller can't handle different errors differently.
+ - Caller can't even report a very precise error message
+
+Note that in order to keep the example code reasonably compact,
+several unwanted cases are silently ignored:
+lines that do not contain two fields, as well as fields that do not parse as ints.
+To propagate these cases to the caller using `Option` would require even more verbose code.
+
+
+# Results
+
+Before getting into _trapping_ the error,
+we will look at a slight refinement on the `Option` type above.
+This second mechanism for indicating an error is called a `Result`.
+The type `std::result::Result<T,E>` is another simple `enum` type with two forms, `Ok(T)` and `Err(E)`.
+The `Result` type is not substantially different from the `Option` type in terms of its ergonomics.
+Its main advantage is that the error constructor `Err(E)` can convey _more detail_ about the error.
+For example, the `int::from_str` API could be reformed
+to return a `Result` carrying an informative description of a parse error,
+like this:
+
+~~~~ {.ignore}
+enum IntParseErr {
+ EmptyInput,
+ Overflow,
+ BadChar(char)
+}
+
+fn int::from_str(&str) -> Result<int,IntParseErr> {
+ // ...
+}
+~~~~
+
+This would give the caller more information for both handling and reporting the error,
+but would otherwise retain the verbosity problems of using `Option`.
+In particular, it would still be necessary for the caller to return a further `Result` to _its_ caller if it did not want to handle the error.
+Manually propagating result values this way can be attractive in certain circumstances
+-- for example when processing must halt on the very first error, or backtrack --
+but as we will see later, many cases have simpler options available.
+
+# Failure
+
+The third and arguably easiest mechanism for handling errors is called "failure".
+In fact it was hinted at earlier by suggesting that one can choose to propagate `Option` or `Result` types _or "force" them_.
+"Forcing" them, in this case, means calling a method like `Option<T>::unwrap`,
+which contains the following code:
+
+~~~~ {.ignore}
+pub fn unwrap(self) -> T {
+ match self {
+ Some(x) => return x,
+ None => fail!("option::unwrap `None`")
+ }
+}
+~~~~
+
+That is, it returns `T` when `self` is `Some(T)`, and _fails_ when `self` is `None`.
+
+Every Rust task can _fail_, either indirectly due to a kill signal or other asynchronous event,
+or directly by failing an `assert!` or calling the `fail!` macro.
+Failure is an _unrecoverable event_ at the task level:
+it causes the task to halt normal execution and unwind its control stack,
+freeing all task-local resources (the local heap as well as any task-owned values from the global heap)
+and running destructors (the `drop` method of the `Drop` trait)
+as frames are unwound and heap values destroyed.
+A failing task is not permitted to "catch" the unwinding during failure and recover,
+it is only allowed to clean up and exit.
+
+Failure has advantages:
+
+ - Simple and non-verbose. Suitable for programs that can't reasonably continue past an error anyways.
+ - _All_ errors (except memory-safety errors) can be uniformly trapped in a supervisory task outside the failing task.
+ For a large program to be robust against a variety of errors,
+ often some form of task-level partitioning to contain pervasive errors (arithmetic overflow, division by zero,
+ logic bugs) is necessary anyways.
+
+As well as obvious disadvantages:
+
+ - A blunt instrument, terminates the containing task entirely.
+
+Recall that in the first two approaches to error handling,
+the example program was only handling success cases, and ignoring error cases.
+That is, if the input is changed to contain a malformed line:
+
+~~~~ {.notrust}
+$ cat bad.txt
+1 2
+34 56
+ostrich
+789 123
+45 67
+~~~~
+
+Then the program would give the same output as if there was no error:
+
+~~~~ {.notrust}
+$ ./example bad.txt
+0001, 0002
+0034, 0056
+0789, 0123
+0045, 0067
+~~~~
+
+If the example is rewritten to use failure, these error cases can be trapped.
+In this rewriting, failures are trapped by placing the I/O logic in a sub-task,
+and trapping its exit status using `task::try`:
+
+~~~~ {.xfail-test}
+# #[allowed(unused_imports)];
+extern mod extra;
+use extra::fileinput::FileInput;
+use std::int;
+use std::task;
+# mod FileInput {
+# use std::io::{Reader, BytesReader};
+# static s : &'static [u8] = bytes!("1 2\n\
+# 34 56\n\
+# ostrich\n\
+# 789 123\n\
+# 45 67\n\
+# ");
+# pub fn from_args() -> @Reader{
+# @BytesReader {
+# bytes: s,
+# pos: @mut 0
+# } as @Reader
+# }
+# }
+
+fn main() {
+
+ // Isolate failure within a subtask.
+ let result = do task::try {
+
+ // The protected logic.
+ let pairs = read_int_pairs();
+ for &(a,b) in pairs.iter() {
+ println(fmt!("%4.4d, %4.4d", a, b));
+ }
+
+ };
+ if result.is_err() {
+ println("parsing failed");
+ }
+}
+
+fn read_int_pairs() -> ~[(int,int)] {
+ let mut pairs = ~[];
+ let fi = FileInput::from_args();
+ while ! fi.eof() {
+ let line = fi.read_line();
+ let fields = line.word_iter().to_owned_vec();
+ match fields {
+ [a, b] => pairs.push((int::from_str(a).unwrap(),
+ int::from_str(b).unwrap())),
+
+ // Explicitly fail on malformed lines.
+ _ => fail!()
+ }
+ }
+ pairs
+}
+~~~~
+
+With these changes in place, running the program on malformed input gives a different answer:
+
+~~~~ {.notrust}
+$ ./example bad.txt
+rust: task failed at 'explicit failure', ./example.rs:44
+parsing failed
+~~~~
+
+Note that while failure unwinds the sub-task performing I/O in `read_int_pairs`,
+control returns to `main` and can easily continue uninterrupted.
+In this case, control simply prints out `parsing failed` and then exits `main` (successfully).
+Failure of a (sub-)task is analogous to calling `exit(1)` or `abort()` in a unix C program:
+all the state of a sub-task is cleanly discarded on exit,
+and a supervisor task can take appropriate action
+without worrying about its own state having been corrupted.
+
+
+# Conditions
+
+The final mechanism for handling errors is called a "condition".
+Conditions are less blunt than failure, and less cumbersome than the `Option` or `Result` types;
+indeed they are designed to strike just the right balance between the two.
+Conditions require some care to use effectively, but give maximum flexibility with minimum verbosity.
+While conditions use exception-like terminology ("trap", "raise") they are significantly different:
+
+ - Like exceptions and failure, conditions separate the site at which the error is raised from the site where it is trapped.
+ - Unlike exceptions and unlike failure, when a condition is raised and trapped, _no unwinding occurs_.
+ - A successfully trapped condition causes execution to continue _at the site of the error_, as though no error occurred.
+
+Conditions are declared with the `condition!` macro.
+Each condition has a name, an input type and an output type, much like a function.
+In fact, conditions are implemented as dynamically-scoped functions held in task local storage.
+
+The `condition!` macro declares a module with the name of the condition;
+the module contains a single static value called `cond`, of type `std::condition::Condition`.
+The `cond` value within the module is the rendezvous point
+between the site of error and the site that handles the error.
+It has two methods of interest: `raise` and `trap`.
+
+The `raise` method maps a value of the condition's input type to its output type.
+The input type should therefore convey all relevant information to the condition handler.
+The output type should convey all relevant information _for continuing execution at the site of error_.
+When the error site raises a condition handler,
+the `Condition::raise` method searches task-local storage (TLS) for the innermost installed _handler_,
+and if any such handler is found, calls it with the provided input value.
+If no handler is found, `Condition::raise` will fail the task with an appropriate error message.
+
+Rewriting the example to use a condition in place of ignoring malformed lines makes it slightly longer,
+but similarly clear as the version that used `fail!` in the logic where the error occurs:
+
+~~~~ {.xfail-test}
+# #[allow(unused_imports)];
+extern mod extra;
+use extra::fileinput::FileInput;
+use std::int;
+# mod FileInput {
+# use std::io::{Reader, BytesReader};
+# static s : &'static [u8] = bytes!("1 2\n\
+# 34 56\n\
+# ostrich\n\
+# 789 123\n\
+# 45 67\n\
+# ");
+# pub fn from_args() -> @Reader{
+# @BytesReader {
+# bytes: s,
+# pos: @mut 0
+# } as @Reader
+# }
+# }
+
+// Introduce a new condition.
+condition! {
+ pub malformed_line : ~str -> (int,int);
+}
+
+fn main() {
+ let pairs = read_int_pairs();
+ for &(a,b) in pairs.iter() {
+ println(fmt!("%4.4d, %4.4d", a, b));
+ }
+}
+
+fn read_int_pairs() -> ~[(int,int)] {
+ let mut pairs = ~[];
+ let fi = FileInput::from_args();
+ while ! fi.eof() {
+ let line = fi.read_line();
+ let fields = line.word_iter().to_owned_vec();
+ match fields {
+ [a, b] => pairs.push((int::from_str(a).unwrap(),
+ int::from_str(b).unwrap())),
+
+ // On malformed lines, call the condition handler and
+ // push whatever the condition handler returns.
+ _ => pairs.push(malformed_line::cond.raise(line.clone()))
+ }
+ }
+ pairs
+}
+~~~~
+
+When this is run on malformed input, it still fails,
+but with a slightly different failure message than before:
+
+~~~~ {.notrust}
+$ ./example bad.txt
+rust: task failed at 'Unhandled condition: malformed_line: ~"ostrich"', .../libstd/condition.rs:43
+~~~~
+
+While this superficially resembles the trapped `fail!` call before,
+it is only because the example did not install a handler for the condition.
+The different failure message is indicating, among other things,
+that the condition-handling system is being invoked and failing
+only due to the absence of a _handler_ that traps the condition.
+
+# Trapping a condition
+
+To trap a condition, use `Condition::trap` in some caller of the site that calls `Condition::raise`.
+For example, this version of the program traps the `malformed_line` condition
+and replaces bad input lines with the pair `(-1,-1)`:
+
+~~~~
+# #[allow(unused_imports)];
+extern mod extra;
+use extra::fileinput::FileInput;
+use std::int;
+# mod FileInput {
+# use std::io::{Reader, BytesReader};
+# static s : &'static [u8] = bytes!("1 2\n\
+# 34 56\n\
+# ostrich\n\
+# 789 123\n\
+# 45 67\n\
+# ");
+# pub fn from_args() -> @Reader{
+# @BytesReader {
+# bytes: s,
+# pos: @mut 0
+# } as @Reader
+# }
+# }
+
+condition! {
+ pub malformed_line : ~str -> (int,int);
+}
+
+fn main() {
+ // Trap the condition:
+ do malformed_line::cond.trap(|_| (-1,-1)).inside {
+
+ // The protected logic.
+ let pairs = read_int_pairs();
+ for &(a,b) in pairs.iter() {
+ println(fmt!("%4.4d, %4.4d", a, b));
+ }
+
+ }
+}
+
+fn read_int_pairs() -> ~[(int,int)] {
+ let mut pairs = ~[];
+ let fi = FileInput::from_args();
+ while ! fi.eof() {
+ let line = fi.read_line();
+ let fields = line.word_iter().to_owned_vec();
+ match fields {
+ [a, b] => pairs.push((int::from_str(a).unwrap(),
+ int::from_str(b).unwrap())),
+ _ => pairs.push(malformed_line::cond.raise(line.clone()))
+ }
+ }
+ pairs
+}
+~~~~
+
+Note that the remainder of the program is _unchanged_ with this trap in place;
+only the caller that installs the trap changed.
+Yet when the condition-trapping variant runs on the malformed input,
+it continues execution past the malformed line, substituting the handler's return value.
+
+~~~~ {.notrust}
+$ ./example bad.txt
+0001, 0002
+0034, 0056
+-0001, -0001
+0789, 0123
+0045, 0067
+~~~~
+
+# Refining a condition
+
+As you work with a condition, you may find that the original set of options you present for recovery is insufficient.
+This is no different than any other issue of API design:
+a condition handler is an API for recovering from the condition, and sometimes APIs need to be enriched.
+In the example program, the first form of the `malformed_line` API implicitly assumes that recovery involves a substitute value.
+This assumption may not be correct; some callers may wish to skip malformed lines, for example.
+Changing the condition's return type from `(int,int)` to `Option<(int,int)>` will suffice to support this type of recovery:
+
+~~~~
+# #[allow(unused_imports)];
+extern mod extra;
+use extra::fileinput::FileInput;
+use std::int;
+# mod FileInput {
+# use std::io::{Reader, BytesReader};
+# static s : &'static [u8] = bytes!("1 2\n\
+# 34 56\n\
+# ostrich\n\
+# 789 123\n\
+# 45 67\n\
+# ");
+# pub fn from_args() -> @Reader{
+# @BytesReader {
+# bytes: s,
+# pos: @mut 0
+# } as @Reader
+# }
+# }
+
+// Modify the condition signature to return an Option.
+condition! {
+ pub malformed_line : ~str -> Option<(int,int)>;
+}
+
+fn main() {
+ // Trap the condition and return `None`
+ do malformed_line::cond.trap(|_| None).inside {
+
+ // The protected logic.
+ let pairs = read_int_pairs();
+ for &(a,b) in pairs.iter() {
+ println(fmt!("%4.4d, %4.4d", a, b));
+ }
+
+ }
+}
+
+fn read_int_pairs() -> ~[(int,int)] {
+ let mut pairs = ~[];
+ let fi = FileInput::from_args();
+ while ! fi.eof() {
+ let line = fi.read_line();
+ let fields = line.word_iter().to_owned_vec();
+ match fields {
+ [a, b] => pairs.push((int::from_str(a).unwrap(),
+ int::from_str(b).unwrap())),
+
+ // On malformed lines, call the condition handler and
+ // either ignore the line (if the handler returns `None`)
+ // or push any `Some(pair)` value returned instead.
+ _ => {
+ match malformed_line::cond.raise(line.clone()) {
+ Some(pair) => pairs.push(pair),
+ None => ()
+ }
+ }
+ }
+ }
+ pairs
+}
+~~~~
+
+Again, note that the remainder of the program is _unchanged_,
+in particular the signature of `read_int_pairs` is unchanged,
+even though the innermost part of its reading-loop has a new way of handling a malformed line.
+When the example is run with the `None` trap in place,
+the line is ignored as it was in the first example,
+but the choice of whether to ignore or use a substitute value has been moved to some caller,
+possibly a distant caller.
+
+~~~~ {.notrust}
+$ ./example bad.txt
+0001, 0002
+0034, 0056
+0789, 0123
+0045, 0067
+~~~~
+
+# Further refining a condition
+
+Like with any API, the process of refining argument and return types of a condition will continue,
+until all relevant combinations encountered in practice are encoded.
+In the example, suppose a third possible recovery form arose: reusing the previous value read.
+This can be encoded in the handler API by introducing a helper type: `enum MalformedLineFix`.
+
+~~~~
+# #[allow(unused_imports)];
+extern mod extra;
+use extra::fileinput::FileInput;
+use std::int;
+# mod FileInput {
+# use std::io::{Reader, BytesReader};
+# static s : &'static [u8] = bytes!("1 2\n\
+# 34 56\n\
+# ostrich\n\
+# 789 123\n\
+# 45 67\n\
+# ");
+# pub fn from_args() -> @Reader{
+# @BytesReader {
+# bytes: s,
+# pos: @mut 0
+# } as @Reader
+# }
+# }
+
+// Introduce a new enum to convey condition-handling strategy to error site.
+pub enum MalformedLineFix {
+ UsePair(int,int),
+ IgnoreLine,
+ UsePreviousLine
+}
+
+// Modify the condition signature to return the new enum.
+// Note: a condition introduces a new module, so the enum must be
+// named with the `super::` prefix to access it.
+condition! {
+ pub malformed_line : ~str -> super::MalformedLineFix;
+}
+
+fn main() {
+ // Trap the condition and return `UsePreviousLine`
+ do malformed_line::cond.trap(|_| UsePreviousLine).inside {
+
+ // The protected logic.
+ let pairs = read_int_pairs();
+ for &(a,b) in pairs.iter() {
+ println(fmt!("%4.4d, %4.4d", a, b));
+ }
+
+ }
+}
+
+fn read_int_pairs() -> ~[(int,int)] {
+ let mut pairs = ~[];
+ let fi = FileInput::from_args();
+ while ! fi.eof() {
+ let line = fi.read_line();
+ let fields = line.word_iter().to_owned_vec();
+ match fields {
+ [a, b] => pairs.push((int::from_str(a).unwrap(),
+ int::from_str(b).unwrap())),
+
+ // On malformed lines, call the condition handler and
+ // take action appropriate to the enum value returned.
+ _ => {
+ match malformed_line::cond.raise(line.clone()) {
+ UsePair(a,b) => pairs.push((a,b)),
+ IgnoreLine => (),
+ UsePreviousLine => {
+ let prev = pairs[pairs.len() - 1];
+ pairs.push(prev)
+ }
+ }
+ }
+ }
+ }
+ pairs
+}
+~~~~
+
+Running the example with `UsePreviousLine` as the fix code returned from the handler
+gives the expected result:
+
+~~~~ {.notrust}
+$ ./example bad.txt
+0001, 0002
+0034, 0056
+0034, 0056
+0789, 0123
+0045, 0067
+~~~~
+
+At this point the example has a rich variety of recovery options,
+none of which is visible to casual users of the `read_int_pairs` function.
+This is intentional: part of the purpose of using a condition
+is to free intermediate callers from the burden of having to write repetitive error-propagation logic,
+and/or having to change function call and return types as error-handling strategies are refined.
+
+# Multiple conditions, intermediate callers
+
+So far the function trapping the condition and the function raising it have been immediately adjacent in the call stack.
+That is, the caller traps and its immediate callee raises.
+In most programs, the function that traps may be separated by very many function calls from the function that raises.
+Again, this is part of the point of using conditions:
+to support that separation without having to thread multiple error values and recovery strategies all the way through the program's main logic.
+
+Careful readers will notice that there is a remaining failure mode in the example program: the call to `.unwrap()` when parsing each integer.
+For example, when presented with a file that has the correct number of fields on a line,
+but a non-numeric value in one of them, such as this:
+
+~~~~ {.notrust}
+$ cat bad.txt
+1 2
+34 56
+7 marmot
+789 123
+45 67
+~~~~
+
+
+Then the program fails once more:
+
+~~~~ {.notrust}
+$ ./example bad.txt
+task <unnamed> failed at 'called `Option::unwrap()` on a `None` value', .../libstd/option.rs:314
+~~~~
+
+To make the program robust -- or at least flexible -- in the face of this potential failure,
+a second condition and a helper function will suffice:
+
+~~~~
+# #[allow(unused_imports)];
+extern mod extra;
+use extra::fileinput::FileInput;
+use std::int;
+# mod FileInput {
+# use std::io::{Reader, BytesReader};
+# static s : &'static [u8] = bytes!("1 2\n\
+# 34 56\n\
+# 7 marmot\n\
+# 789 123\n\
+# 45 67\n\
+# ");
+# pub fn from_args() -> @Reader{
+# @BytesReader {
+# bytes: s,
+# pos: @mut 0
+# } as @Reader
+# }
+# }
+
+pub enum MalformedLineFix {
+ UsePair(int,int),
+ IgnoreLine,
+ UsePreviousLine
+}
+
+condition! {
+ pub malformed_line : ~str -> ::MalformedLineFix;
+}
+
+// Introduce a second condition.
+condition! {
+ pub malformed_int : ~str -> int;
+}
+
+fn main() {
+ // Trap the `malformed_int` condition and return -1
+ do malformed_int::cond.trap(|_| -1).inside {
+
+ // Trap the `malformed_line` condition and return `UsePreviousLine`
+ do malformed_line::cond.trap(|_| UsePreviousLine).inside {
+
+ // The protected logic.
+ let pairs = read_int_pairs();
+ for &(a,b) in pairs.iter() {
+ println(fmt!("%4.4d, %4.4d", a, b));
+ }
+
+ }
+ }
+}
+
+// Parse an int; if parsing fails, call the condition handler and
+// return whatever it returns.
+fn parse_int(x: &str) -> int {
+ match int::from_str(x) {
+ Some(v) => v,
+ None => malformed_int::cond.raise(x.to_owned())
+ }
+}
+
+fn read_int_pairs() -> ~[(int,int)] {
+ let mut pairs = ~[];
+ let fi = FileInput::from_args();
+ while ! fi.eof() {
+ let line = fi.read_line();
+ let fields = line.word_iter().to_owned_vec();
+ match fields {
+
+ // Delegate parsing ints to helper function that will
+ // handle parse errors by calling `malformed_int`.
+ [a, b] => pairs.push((parse_int(a), parse_int(b))),
+
+ _ => {
+ match malformed_line::cond.raise(line.clone()) {
+ UsePair(a,b) => pairs.push((a,b)),
+ IgnoreLine => (),
+ UsePreviousLine => {
+ let prev = pairs[pairs.len() - 1];
+ pairs.push(prev)
+ }
+ }
+ }
+ }
+ }
+ pairs
+}
+~~~~
+
+Again, note that `read_int_pairs` has not changed signature,
+nor has any of the machinery for trapping or raising `malformed_line`,
+but now the program can handle the "right number of fields, non-integral field" form of bad input:
+
+~~~~ {.notrust}
+$ ./example bad.txt
+0001, 0002
+0034, 0056
+0007, -0001
+0789, 0123
+0045, 0067
+~~~~
+
+There are three other things to note in this variant of the example program:
+
+ - It traps multiple conditions simultaneously,
+ nesting the protected logic of one `trap` call inside the other.
+
+ - There is a function in between the `trap` site and `raise` site for the `malformed_int` condition.
+ There could be any number of calls between them:
+ so long as the `raise` occurs within a callee (of any depth) of the logic protected by the `trap` call,
+ it will invoke the handler.
+
+ - This variant insulates callers from a design choice in the `int` library:
+ the `int::from_str` function was designed to return an `Option<int>`,
+ but this program insulates callers from that choice,
+ routing all `None` values that arise from parsing integers in this file into the condition.
+
+
+# When to use which technique
+
+This tutorial explored several techniques for handling errors.
+Each is appropriate to different circumstances:
+
+ - If an error may be extremely frequent, expected, and very likely dealt with by an immediate caller,
+ then returning an `Option` or `Result` type is best. These types force the caller to handle the error,
+ and incur the lowest speed overhead, usually only returning one extra word to tag the return value.
+ Between `Option` and `Result`: use an `Option` when there is only one kind of error,
+ otherwise make an `enum FooErr` to represent the possible error codes and use `Result<T,FooErr>`.
+
+ - If an error can reasonably be handled at the site it occurs by one of a few strategies -- possibly including failure --
+ and it is not clear which strategy a caller would want to use, a condition is best.
+ For many errors, the only reasonable "non-stop" recovery strategies are to retry some number of times,
+ create or substitute an empty or sentinel value, ignore the error, or fail.
+
+ - If an error cannot reasonably be handled at the site it occurs,
+ and the only reasonable response is to abandon a large set of operations in progress,
+ then directly failing is best.
+
+Note that an unhandled condition will cause failure (along with a more-informative-than-usual message),
+so if there is any possibility that a caller might wish to "ignore and keep going",
+it is usually harmless to use a condition in place of a direct call to `fail!()`.
+
+
+[^why-no-exceptions]: Exceptions in languages like C++ and Java permit unwinding, like Rust's failure system,
+but with the option to halt unwinding partway through the process and continue execution.
+This behavior unfortunately means that the _heap_ may be left in an inconsistent but accessible state,
+if an exception is thrown part way through the process of initializing or modifying memory.
+To compensate for this risk, correct C++ and Java code must program in an extremely elaborate and difficult "exception-safe" style
+-- effectively transactional style against heap structures --
+or else risk introducing silent and very difficult-to-debug errors due to control resuming in a corrupted heap after a caught exception.
+These errors are frequently memory-safety errors, which Rust strives to eliminate,
+and so Rust unwinding is unrecoverable within a single task:
+once unwinding starts, the entire local heap of a task is destroyed and the task is terminated.
\ No newline at end of file
The `for` keyword can be used as sugar for iterating through any iterator:
~~~
-let xs = [2, 3, 5, 7, 11, 13, 17];
+let xs = [2u, 3, 5, 7, 11, 13, 17];
// print out all the elements in the vector
for x in xs.iter() {
implementing the `FromIterator` trait. For example, the implementation for
vectors is as follows:
-~~~
+~~~ {.xfail-test}
impl<A> FromIterator<A> for ~[A] {
pub fn from_iterator<T: Iterator<A>>(iterator: &mut T) -> ~[A] {
let (lower, _) = iterator.size_hint();
The `Iterator` trait provides a `size_hint` default method, returning a lower
bound and optionally on upper bound on the length of the iterator:
-~~~
+~~~ {.xfail-test}
fn size_hint(&self) -> (uint, Option<uint>) { (0, None) }
~~~
}
~~~
+The `reverse_` method is also available for any double-ended iterator yielding
+mutable references. It can be used to reverse a container in-place. Note that
+the trailing underscore is a workaround for issue #5898 and will be removed.
+
+~~~
+let mut ys = [1, 2, 3, 4, 5];
+ys.mut_iter().reverse_();
+assert_eq!(ys, [5, 4, 3, 2, 1]);
+~~~
+
## Random-access iterators
The `RandomAccessIterator` trait represents an iterator offering random access
fn snappy_max_compressed_length(source_length: size_t) -> size_t;
}
+#[fixed_stack_segment]
fn main() {
let x = unsafe { snappy_max_compressed_length(100) };
println(fmt!("max compressed length of a 100 byte buffer: %?", x));
valid for all possible inputs since the pointer could be dangling, and raw pointers fall outside of
Rust's safe memory model.
+Finally, the `#[fixed_stack_segment]` annotation that appears on
+`main()` instructs the Rust compiler that when `main()` executes, it
+should request a "very large" stack segment. More details on
+stack management can be found in the following sections.
+
When declaring the argument types to a foreign function, the Rust compiler will not check if the
declaration is correct, so specifying it correctly is part of keeping the binding correct at
runtime.
the allocated memory. The length is less than or equal to the capacity.
~~~~ {.xfail-test}
+#[fixed_stack_segment]
+#[inline(never)]
pub fn validate_compressed_buffer(src: &[u8]) -> bool {
unsafe {
snappy_validate_compressed_buffer(vec::raw::to_ptr(src), src.len() as size_t) == 0
guarantee that calling it is safe for all inputs by leaving off `unsafe` from the function
signature.
+The `validate_compressed_buffer` wrapper is also annotated with two
+attributes `#[fixed_stack_segment]` and `#[inline(never)]`. The
+purpose of these attributes is to guarantee that there will be
+sufficient stack for the C function to execute. This is necessary
+because Rust, unlike C, does not assume that the stack is allocated in
+one continuous chunk. Instead, we rely on a *segmented stack* scheme,
+in which the stack grows and shrinks as necessary. C code, however,
+expects one large stack, and so callers of C functions must request a
+large stack segment to ensure that the C routine will not run off the
+end of the stack.
+
+The compiler includes a lint mode that will report an error if you
+call a C function without a `#[fixed_stack_segment]` attribute. More
+details on the lint mode are given in a later section.
+
+You may be wondering why we include a `#[inline(never)]` directive.
+This directive informs the compiler never to inline this function.
+While not strictly necessary, it is usually a good idea to use an
+`#[inline(never)]` directive in concert with `#[fixed_stack_segment]`.
+The reason is that if a fn annotated with `fixed_stack_segment` is
+inlined, then its caller also inherits the `fixed_stack_segment`
+annotation. This means that rather than requesting a large stack
+segment only for the duration of the call into C, the large stack
+segment would be used for the entire duration of the caller. This is
+not necessarily *bad* -- it can for example be more efficient,
+particularly if `validate_compressed_buffer()` is called multiple
+times in a row -- but it does work against the purpose of the
+segmented stack scheme, which is to keep stacks small and thus
+conserve address space.
+
The `snappy_compress` and `snappy_uncompress` functions are more complex, since a buffer has to be
allocated to hold the output too.
~~~~ {.xfail-test}
pub fn compress(src: &[u8]) -> ~[u8] {
+ #[fixed_stack_segment]; #[inline(never)];
+
unsafe {
let srclen = src.len() as size_t;
let psrc = vec::raw::to_ptr(src);
~~~~ {.xfail-test}
pub fn uncompress(src: &[u8]) -> Option<~[u8]> {
+ #[fixed_stack_segment]; #[inline(never)];
+
unsafe {
let srclen = src.len() as size_t;
let psrc = vec::raw::to_ptr(src);
For reference, the examples used here are also available as an [library on
GitHub](https://github.com/thestinger/rust-snappy).
+# Automatic wrappers
+
+Sometimes writing Rust wrappers can be quite tedious. For example, if
+function does not take any pointer arguments, often there is no need
+for translating types. In such cases, it is usually still a good idea
+to have a Rust wrapper so as to manage the segmented stacks, but you
+can take advantage of the (standard) `externfn!` macro to remove some
+of the tedium.
+
+In the initial section, we showed an extern block that added a call
+to a specific snappy API:
+
+~~~~ {.xfail-test}
+use std::libc::size_t;
+
+#[link_args = "-lsnappy"]
+extern {
+ fn snappy_max_compressed_length(source_length: size_t) -> size_t;
+}
+
+#[fixed_stack_segment]
+fn main() {
+ let x = unsafe { snappy_max_compressed_length(100) };
+ println(fmt!("max compressed length of a 100 byte buffer: %?", x));
+}
+~~~~
+
+To avoid the need to create a wrapper fn for `snappy_max_compressed_length()`,
+and also to avoid the need to think about `#[fixed_stack_segment]`, we
+could simply use the `externfn!` macro instead, as shown here:
+
+~~~~ {.xfail-test}
+use std::libc::size_t;
+
+externfn!(#[link_args = "-lsnappy"]
+ fn snappy_max_compressed_length(source_length: size_t) -> size_t)
+
+fn main() {
+ let x = unsafe { snappy_max_compressed_length(100) };
+ println(fmt!("max compressed length of a 100 byte buffer: %?", x));
+}
+~~~~
+
+As you can see from the example, `externfn!` replaces the extern block
+entirely. After macro expansion, it will create something like this:
+
+~~~~ {.xfail-test}
+use std::libc::size_t;
+
+// Automatically generated by
+// externfn!(#[link_args = "-lsnappy"]
+// fn snappy_max_compressed_length(source_length: size_t) -> size_t)
+unsafe fn snappy_max_compressed_length(source_length: size_t) -> size_t {
+ #[fixed_stack_segment]; #[inline(never)];
+ return snappy_max_compressed_length(source_length);
+
+ #[link_args = "-lsnappy"]
+ extern {
+ fn snappy_max_compressed_length(source_length: size_t) -> size_t;
+ }
+}
+
+fn main() {
+ let x = unsafe { snappy_max_compressed_length(100) };
+ println(fmt!("max compressed length of a 100 byte buffer: %?", x));
+}
+~~~~
+
+# Segmented stacks and the linter
+
+By default, whenever you invoke a non-Rust fn, the `cstack` lint will
+check that one of the following conditions holds:
+
+1. The call occurs inside of a fn that has been annotated with
+ `#[fixed_stack_segment]`;
+2. The call occurs inside of an `extern fn`;
+3. The call occurs within a stack closure created by some other
+ safe fn.
+
+All of these conditions ensure that you are running on a large stack
+segmented. However, they are sometimes too strict. If your application
+will be making many calls into C, it is often beneficial to promote
+the `#[fixed_stack_segment]` attribute higher up the call chain. For
+example, the Rust compiler actually labels main itself as requiring a
+`#[fixed_stack_segment]`. In such cases, the linter is just an
+annoyance, because all C calls that occur from within the Rust
+compiler are made on a large stack. Another situation where this
+frequently occurs is on a 64-bit architecture, where large stacks are
+the default. In cases, you can disable the linter by including a
+`#[allow(cstack)]` directive somewhere, which permits violations of
+the "cstack" rules given above (you can also use `#[warn(cstack)]` to
+convert the errors into warnings, if you prefer).
+
# Destructors
Foreign libraries often hand off ownership of resources to the calling code,
impl<T: Send> Unique<T> {
pub fn new(value: T) -> Unique<T> {
+ #[fixed_stack_segment];
+ #[inline(never)];
+
unsafe {
let ptr = malloc(std::sys::size_of::<T>() as size_t) as *mut T;
assert!(!ptr::is_null(ptr));
#[unsafe_destructor]
impl<T: Send> Drop for Unique<T> {
fn drop(&self) {
+ #[fixed_stack_segment];
+ #[inline(never)];
+
unsafe {
let x = intrinsics::init(); // dummy value to swap in
// moving the object out is needed to call the destructor
`loop` denotes an infinite loop, and is the preferred way of writing `while true`:
~~~~
-use std::int;
-let mut x = 5;
+let mut x = 5u;
loop {
x += x - 3;
if x % 5 == 0 { break; }
- println(int::to_str(x));
+ println(x.to_str());
}
~~~~
--include-before-body=doc/version_info.html \
--output=$@
+DOCS += doc/tutorial-conditions.html
+doc/tutorial-conditions.html: tutorial-conditions.md doc/version_info.html doc/rust.css
+ @$(call E, pandoc: $@)
+ $(Q)$(CFG_NODE) $(S)doc/prep.js --highlight $< | \
+ $(CFG_PANDOC) --standalone --toc \
+ --section-divs --number-sections \
+ --from=markdown --to=html --css=rust.css \
+ --include-before-body=doc/version_info.html \
+ --output=$@
+
ifeq ($(CFG_PDFLATEX),)
$(info cfg: no pdflatex found, omitting doc/rust.pdf)
else
rt/sync/rust_thread.cpp \
rt/rust_builtin.cpp \
rt/rust_run_program.cpp \
- rt/rust_env.cpp \
rt/rust_rng.cpp \
- rt/rust_stack.cpp \
rt/rust_upcall.cpp \
rt/rust_uv.cpp \
rt/rust_crate_map.cpp \
$$(Q)$(AR_$(1)) rcs $$@ $$<
rt/$(1)/stage$(2)/$(CFG_RUNTIME_$(1)): $$(RUNTIME_OBJS_$(1)_$(2)) $$(MKFILE_DEPS) \
- $$(RUNTIME_DEF_$(1)_$(2)) $$(LIBUV_LIB_$(1)_$(2))
+ $$(RUNTIME_DEF_$(1)_$(2)) $$(LIBUV_LIB_$(1)_$(2)) $$(JEMALLOC_LIB_$(1)_$(2))
@$$(call E, link: $$@)
$$(Q)$$(call CFG_LINK_CXX_$(1),$$@, $$(RUNTIME_OBJS_$(1)_$(2)) \
- $$(CFG_GCCISH_POST_LIB_FLAGS_$(1)) $$(LIBUV_LIB_$(1)_$(2)) \
+ $$(JEMALLOC_LIB_$(1)_$(2)) $$(CFG_GCCISH_POST_LIB_FLAGS_$(1)) $$(LIBUV_LIB_$(1)_$(2)) \
$$(CFG_LIBUV_LINK_FLAGS_$(1)),$$(RUNTIME_DEF_$(1)_$(2)),$$(CFG_RUNTIME_$(1)))
# FIXME: For some reason libuv's makefiles can't figure out the
| $$(TLIB$(1)_T_$(2)_H_$(3))/
@$$(call E, compile_and_link: $$@)
$$(call REMOVE_ALL_OLD_GLOB_MATCHES_EXCEPT,$$(dir $$@),$(LIBSYNTAX_GLOB_$(2)),$$(notdir $$@))
- $$(STAGE$(1)_T_$(2)_H_$(3)) $(BORROWCK) --out-dir $$(@D) $$< && touch $$@
+ $$(STAGE$(1)_T_$(2)_H_$(3)) $$(WFLAGS_ST$(1)) $(BORROWCK) --out-dir $$(@D) $$< && touch $$@
$$(call LIST_ALL_OLD_GLOB_MATCHES_EXCEPT,$$(dir $$@),$(LIBSYNTAX_GLOB_$(2)),$$(notdir $$@))
# Only build the compiler for host triples
| $$(TLIB$(1)_T_$(2)_H_$(3))/
@$$(call E, compile_and_link: $$@)
$$(call REMOVE_ALL_OLD_GLOB_MATCHES_EXCEPT,$$(dir $$@),$(LIBRUSTC_GLOB_$(2)),$$(notdir $$@))
- $$(STAGE$(1)_T_$(2)_H_$(3)) --out-dir $$(@D) $$< && touch $$@
+ $$(STAGE$(1)_T_$(2)_H_$(3)) $$(WFLAGS_ST$(1)) --out-dir $$(@D) $$< && touch $$@
$$(call LIST_ALL_OLD_GLOB_MATCHES_EXCEPT,$$(dir $$@),$(LIBRUSTC_GLOB_$(2)),$$(notdir $$@))
$$(TBIN$(1)_T_$(2)_H_$(3))/rustc$$(X_$(3)): \
TEST_CRATES = $(TEST_TARGET_CRATES) $(TEST_HOST_CRATES)
# Markdown files under doc/ that should have their code extracted and run
-DOC_TEST_NAMES = tutorial tutorial-ffi tutorial-macros tutorial-borrowed-ptr tutorial-tasks rust
+DOC_TEST_NAMES = tutorial tutorial-ffi tutorial-macros tutorial-borrowed-ptr \
+ tutorial-tasks tutorial-conditions tutorial-container rust
######################################################################
# Environment configuration
| $$(TLIB$(1)_T_$(4)_H_$(3))/
@$$(call E, compile_and_link: $$@)
$$(call REMOVE_ALL_OLD_GLOB_MATCHES_EXCEPT,$$(dir $$@),$(LIBRUSTDOC_GLOB_$(4)),$$(notdir $$@))
- $$(STAGE$(1)_T_$(4)_H_$(3)) --out-dir $$(@D) $$< && touch $$@
+ $$(STAGE$(1)_T_$(4)_H_$(3)) $$(WFLAGS_ST$(1)) --out-dir $$(@D) $$< && touch $$@
$$(call LIST_ALL_OLD_GLOB_MATCHES_EXCEPT,$$(dir $$@),$(LIBRUSTDOC_GLOB_$(4)),$$(notdir $$@))
$$(TBIN$(1)_T_$(4)_H_$(3))/rustdoc$$(X_$(4)): \
| $$(TLIB$(1)_T_$(4)_H_$(3))/
@$$(call E, compile_and_link: $$@)
$$(call REMOVE_ALL_OLD_GLOB_MATCHES_EXCEPT,$$(dir $$@),$(LIBRUSTI_GLOB_$(4)),$$(notdir $$@))
- $$(STAGE$(1)_T_$(4)_H_$(3)) --out-dir $$(@D) $$< && touch $$@
+ $$(STAGE$(1)_T_$(4)_H_$(3)) $$(WFLAGS_ST$(1)) --out-dir $$(@D) $$< && touch $$@
$$(call LIST_ALL_OLD_GLOB_MATCHES_EXCEPT,$$(dir $$@),$(LIBRUSTI_GLOB_$(4)),$$(notdir $$@))
$$(TBIN$(1)_T_$(4)_H_$(3))/rusti$$(X_$(4)): \
| $$(TLIB$(1)_T_$(4)_H_$(3))/
@$$(call E, compile_and_link: $$@)
$$(call REMOVE_ALL_OLD_GLOB_MATCHES_EXCEPT,$$(dir $$@),$(LIBRUST_GLOB_$(4)),$$(notdir $$@))
- $$(STAGE$(1)_T_$(4)_H_$(3)) --out-dir $$(@D) $$< && touch $$@
+ $$(STAGE$(1)_T_$(4)_H_$(3)) $$(WFLAGS_ST$(1)) --out-dir $$(@D) $$< && touch $$@
$$(call LIST_ALL_OLD_GLOB_MATCHES_EXCEPT,$$(dir $$@),$(LIBRUST_GLOB_$(4)),$$(notdir $$@))
$$(TBIN$(1)_T_$(4)_H_$(3))/rust$$(X_$(4)): \
use util;
use util::logv;
+use std::cell::Cell;
use std::io;
use std::os;
use std::str;
+use std::task::{spawn_sched, SingleThreaded};
use std::vec;
+use std::unstable::running_on_valgrind;
use extra::test::MetricMap;
pub fn run(config: config, testfile: ~str) {
- let mut _mm = MetricMap::new();
- run_metrics(config, testfile, &mut _mm);
+ let config = Cell::new(config);
+ let testfile = Cell::new(testfile);
+ // FIXME #6436: Creating another thread to run the test because this
+ // is going to call waitpid. The new scheduler has some strange
+ // interaction between the blocking tasks and 'friend' schedulers
+ // that destroys parallelism if we let normal schedulers block.
+ // It should be possible to remove this spawn once std::run is
+ // rewritten to be non-blocking.
+ //
+ // We do _not_ create another thread if we're running on V because
+ // it serializes all threads anyways.
+ if running_on_valgrind() {
+ let config = config.take();
+ let testfile = testfile.take();
+ let mut _mm = MetricMap::new();
+ run_metrics(config, testfile, &mut _mm);
+ } else {
+ do spawn_sched(SingleThreaded) {
+ let config = config.take();
+ let testfile = testfile.take();
+ let mut _mm = MetricMap::new();
+ run_metrics(config, testfile, &mut _mm);
+ }
+ }
}
pub fn run_metrics(config: config, testfile: ~str, mm: &mut MetricMap) {
#include <math.h>
#include <stdio.h>
-// must match core::ctypes
+// must match std::ctypes
#define C_FLT(x) (float)x
#define C_DBL(x) (double)x
"//": "linecomment",
"/*": "openblockcomment",
-"*/": "closeblockcomment"
+"*/": "closeblockcomment",
+"macro_rules": "macro_rules",
+"=>" : "eg",
+".." : "dotdot",
+"," : "comma"
}
lines = []
def load_unicode_data(f):
fetch(f)
gencats = {}
+ combines = []
canon_decomp = {}
compat_decomp = {}
curr_cat = ""
+ curr_combine = ""
c_lo = 0
c_hi = 0
+ com_lo = 0
+ com_hi = 0
for line in fileinput.input(f):
fields = line.split(";")
if len(fields) != 15:
c_lo = code
c_hi = code
- return (canon_decomp, compat_decomp, gencats)
+ if curr_combine == "":
+ curr_combine = combine
+ com_lo = code
+ com_hi = code
+
+ if curr_combine == combine:
+ com_hi = code
+ else:
+ if curr_combine != "0":
+ combines.append((com_lo, com_hi, curr_combine))
+ curr_combine = combine
+ com_lo = code
+ com_hi = code
+
+ return (canon_decomp, compat_decomp, gencats, combines)
def load_derived_core_properties(f):
f.write(" }\n\n")
f.write("}\n")
-def emit_decomp_module(f, canon, compat):
+def format_table_content(f, content, indent):
+ line = " "*indent
+ first = True
+ for chunk in content.split(","):
+ if len(line) + len(chunk) < 98:
+ if first:
+ line += chunk
+ else:
+ line += ", " + chunk
+ first = False
+ else:
+ f.write(line + ",\n")
+ line = " "*indent + chunk
+ f.write(line)
+
+def emit_decomp_module(f, canon, compat, combine):
canon_keys = canon.keys()
canon_keys.sort()
compat_keys = compat.keys()
compat_keys.sort()
- f.write("mod decompose {\n\n");
- f.write(" export canonical, compatibility;\n\n")
- f.write(" fn canonical(c: char, i: block(char)) "
- + "{ d(c, i, false); }\n\n")
- f.write(" fn compatibility(c: char, i: block(char)) "
- +"{ d(c, i, true); }\n\n")
- f.write(" fn d(c: char, i: block(char), k: bool) {\n")
+ f.write("pub mod decompose {\n");
+ f.write(" use option::Option;\n");
+ f.write(" use option::{Some, None};\n");
+ f.write(" use vec::ImmutableVector;\n");
+ f.write("""
+ fn bsearch_table(c: char, r: &'static [(char, &'static [char])]) -> Option<&'static [char]> {
+ use cmp::{Equal, Less, Greater};
+ match r.bsearch(|&(val, _)| {
+ if c == val { Equal }
+ else if val < c { Less }
+ else { Greater }
+ }) {
+ Some(idx) => {
+ let (_, result) = r[idx];
+ Some(result)
+ }
+ None => None
+ }
+ }\n
+""")
- f.write(" if c <= '\\x7f' { i(c); ret; }\n")
+ f.write("""
+ fn bsearch_range_value_table(c: char, r: &'static [(char, char, u8)]) -> u8 {
+ use cmp::{Equal, Less, Greater};
+ match r.bsearch(|&(lo, hi, _)| {
+ if lo <= c && c <= hi { Equal }
+ else if hi < c { Less }
+ else { Greater }
+ }) {
+ Some(idx) => {
+ let (_, _, result) = r[idx];
+ result
+ }
+ None => 0
+ }
+ }\n\n
+""")
- # First check the canonical decompositions
- f.write(" // Canonical decomposition\n")
- f.write(" alt c {\n")
+ f.write(" // Canonical decompositions\n")
+ f.write(" static canonical_table : &'static [(char, &'static [char])] = &[\n")
+ data = ""
+ first = True
for char in canon_keys:
- f.write(" %s {\n" % escape_char(char))
+ if not first:
+ data += ","
+ first = False
+ data += "(%s,&[" % escape_char(char)
+ first2 = True
for d in canon[char]:
- f.write(" d(%s, i, k);\n"
- % escape_char(d))
- f.write(" }\n")
+ if not first2:
+ data += ","
+ first2 = False
+ data += escape_char(d)
+ data += "])"
+ format_table_content(f, data, 8)
+ f.write("\n ];\n\n")
+
+ f.write(" // Compatibility decompositions\n")
+ f.write(" static compatibility_table : &'static [(char, &'static [char])] = &[\n")
+ data = ""
+ first = True
+ for char in compat_keys:
+ if not first:
+ data += ","
+ first = False
+ data += "(%s,&[" % escape_char(char)
+ first2 = True
+ for d in compat[char]:
+ if not first2:
+ data += ","
+ first2 = False
+ data += escape_char(d)
+ data += "])"
+ format_table_content(f, data, 8)
+ f.write("\n ];\n\n")
+
+ f.write(" static combining_class_table : &'static [(char, char, u8)] = &[\n")
+ ix = 0
+ for pair in combine:
+ f.write(ch_prefix(ix))
+ f.write("(%s, %s, %s)" % (escape_char(pair[0]), escape_char(pair[1]), pair[2]))
+ ix += 1
+ f.write("\n ];\n")
+
+ f.write(" pub fn canonical(c: char, i: &fn(char)) "
+ + "{ d(c, i, false); }\n\n")
+ f.write(" pub fn compatibility(c: char, i: &fn(char)) "
+ +"{ d(c, i, true); }\n\n")
+ f.write(" pub fn canonical_combining_class(c: char) -> u8 {\n"
+ + " bsearch_range_value_table(c, combining_class_table)\n"
+ + " }\n\n")
+ f.write(" fn d(c: char, i: &fn(char), k: bool) {\n")
+ f.write(" use iterator::Iterator;\n");
- f.write(" _ { }\n")
- f.write(" }\n\n")
+ f.write(" if c <= '\\x7f' { i(c); return; }\n")
+
+ # First check the canonical decompositions
+ f.write("""
+ match bsearch_table(c, canonical_table) {
+ Some(canon) => {
+ for x in canon.iter() {
+ d(*x, |b| i(b), k);
+ }
+ return;
+ }
+ None => ()
+ }\n\n""")
# Bottom out if we're not doing compat.
- f.write(" if !k { i(c); ret; }\n\n ")
+ f.write(" if !k { i(c); return; }\n")
# Then check the compatibility decompositions
- f.write(" // Compatibility decomposition\n")
- f.write(" alt c {\n")
- for char in compat_keys:
- f.write(" %s {\n" % escape_char(char))
- for d in compat[char]:
- f.write(" d(%s, i, k);\n"
- % escape_char(d))
- f.write(" }\n")
-
- f.write(" _ { }\n")
- f.write(" }\n\n")
+ f.write("""
+ match bsearch_table(c, compatibility_table) {
+ Some(compat) => {
+ for x in compat.iter() {
+ d(*x, |b| i(b), k);
+ }
+ return;
+ }
+ None => ()
+ }\n\n""")
# Finally bottom out.
f.write(" i(c);\n")
os.remove(i);
rf = open(r, "w")
-(canon_decomp, compat_decomp, gencats) = load_unicode_data("UnicodeData.txt")
+(canon_decomp, compat_decomp, gencats, combines) = load_unicode_data("UnicodeData.txt")
# Preamble
rf.write('''// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
emit_property_module(rf, "general_category", gencats)
-#emit_decomp_module(rf, canon_decomp, compat_decomp)
+emit_decomp_module(rf, canon_decomp, compat_decomp, combines)
derived = load_derived_core_properties("DerivedCoreProperties.txt")
emit_property_module(rf, "derived_property", derived)
# xfail-license
# This creates the tables used for distributions implemented using the
-# ziggurat algorithm in `core::rand::distributions;`. They are
+# ziggurat algorithm in `std::rand::distributions;`. They are
# (basically) the tables as used in the ZIGNOR variant (Doornik 2005).
# They are changed rarely, so the generated file should be checked in
# to git.
'path-statement[path statements with no effect]'
'missing-trait-doc[detects missing documentation for traits]'
'missing-struct-doc[detects missing documentation for structs]'
- 'ctypes[proper use of core::libc types in foreign modules]'
+ 'ctypes[proper use of std::libc types in foreign modules]'
"unused-mut[detect mut variables which don't need to be mutable]"
'unused-imports[imports that are never used]'
'heap-memory[use of any (~ type or @ type) heap memory]'
do 10.times {
let tmp = *num;
*num = -1;
- task::yield();
+ task::deschedule();
*num = tmp + 1;
}
c.send(());
do read_mode.read |state| {
// if writer mistakenly got in, make sure it mutates state
// before we assert on it
- do 5.times { task::yield(); }
+ do 5.times { task::deschedule(); }
// make sure writer didn't get in.
assert!(*state);
}
}
#[test]
fn test_rw_write_cond_downgrade_read_race() {
- // Ideally the above test case would have yield statements in it that
+ // Ideally the above test case would have deschedule statements in it that
// helped to expose the race nearly 100% of the time... but adding
- // yields in the intuitively-right locations made it even less likely,
+ // deschedules in the intuitively-right locations made it even less likely,
// and I wasn't sure why :( . This is a mediocre "next best" option.
do 8.times { test_rw_write_cond_downgrade_read_race_helper() }
}
use std::libc;
fn malloc(n: size_t) -> CVec<u8> {
+ #[fixed_stack_segment];
+ #[inline(never)];
+
unsafe {
let mem = libc::malloc(n);
assert!(mem as int != 0);
- c_vec_with_dtor(mem as *mut u8, n as uint, || free(mem))
+ return c_vec_with_dtor(mem as *mut u8, n as uint, || f(mem));
+ }
+
+ fn f(mem: *c_void) {
+ #[fixed_stack_segment]; #[inline(never)];
+ unsafe { libc::free(mem) }
}
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::num::One;
+use std::num::{One, Zero, CheckedAdd};
use std::vec::bytes::{MutableByteVector, copy_memory};
}
}
+/// Write a u32 into a vector, which must be 4 bytes long. The value is written in little-endian
+/// format.
+pub fn write_u32_le(dst: &mut[u8], input: u32) {
+ use std::cast::transmute;
+ use std::unstable::intrinsics::to_le32;
+ assert!(dst.len() == 4);
+ unsafe {
+ let x: *mut i32 = transmute(dst.unsafe_mut_ref(0));
+ *x = to_le32(input as i32);
+ }
+}
+
/// Read a vector of bytes into a vector of u64s. The values are read in big-endian format.
pub fn read_u64v_be(dst: &mut[u64], input: &[u8]) {
use std::cast::transmute;
}
}
+/// Read a vector of bytes into a vector of u32s. The values are read in little-endian format.
+pub fn read_u32v_le(dst: &mut[u32], input: &[u8]) {
+ use std::cast::transmute;
+ use std::unstable::intrinsics::to_le32;
+ assert!(dst.len() * 4 == input.len());
+ unsafe {
+ let mut x: *mut i32 = transmute(dst.unsafe_mut_ref(0));
+ let mut y: *i32 = transmute(input.unsafe_ref(0));
+ do dst.len().times() {
+ *x = to_le32(*y);
+ x = x.offset(1);
+ y = y.offset(1);
+ }
+ }
+}
+
-/// Returns true if adding the two parameters will result in integer overflow
-pub fn will_add_overflow<T: Int + Unsigned>(x: T, y: T) -> bool {
- // This doesn't handle negative values! Don't copy this code elsewhere without considering if
- // negative values are important to you!
- let max: T = Bounded::max_value();
- return x > max - y;
+trait ToBits {
+ /// Convert the value in bytes to the number of bits, a tuple where the 1st item is the
+ /// high-order value and the 2nd item is the low order value.
+ fn to_bits(self) -> (Self, Self);
}
-/// Shifts the second parameter and then adds it to the first. fails!() if there would be unsigned
-/// integer overflow.
-pub fn shift_add_check_overflow<T: Int + Unsigned + Clone>(x: T, mut y: T, shift: T) -> T {
- if y.leading_zeros() < shift {
- fail!("Could not add values - integer overflow.");
+impl ToBits for u64 {
+ fn to_bits(self) -> (u64, u64) {
+ return (self >> 61, self << 3);
}
- y = y << shift;
+}
- if will_add_overflow(x.clone(), y.clone()) {
- fail!("Could not add values - integer overflow.");
- }
+/// Adds the specified number of bytes to the bit count. fail!() if this would cause numeric
+/// overflow.
+pub fn add_bytes_to_bits<T: Int + CheckedAdd + ToBits>(bits: T, bytes: T) -> T {
+ let (new_high_bits, new_low_bits) = bytes.to_bits();
- return x + y;
-}
+ if new_high_bits > Zero::zero() {
+ fail!("Numeric overflow occured.")
+ }
-/// Shifts the second parameter and then adds it to the first, which is a tuple where the first
-/// element is the high order value. fails!() if there would be unsigned integer overflow.
-pub fn shift_add_check_overflow_tuple
- <T: Int + Unsigned + Clone>
- (x: (T, T), mut y: T, shift: T) -> (T, T) {
- if y.leading_zeros() < shift {
- fail!("Could not add values - integer overflow.");
+ match bits.checked_add(&new_low_bits) {
+ Some(x) => return x,
+ None => fail!("Numeric overflow occured.")
}
- y = y << shift;
+}
- match x {
- (hi, low) => {
- let one: T = One::one();
- if will_add_overflow(low.clone(), y.clone()) {
- if will_add_overflow(hi.clone(), one.clone()) {
- fail!("Could not add values - integer overflow.");
- } else {
- return (hi + one, low + y);
- }
+/// Adds the specified number of bytes to the bit count, which is a tuple where the first element is
+/// the high order value. fail!() if this would cause numeric overflow.
+pub fn add_bytes_to_bits_tuple
+ <T: Int + Unsigned + CheckedAdd + ToBits>
+ (bits: (T, T), bytes: T) -> (T, T) {
+ let (new_high_bits, new_low_bits) = bytes.to_bits();
+ let (hi, low) = bits;
+
+ // Add the low order value - if there is no overflow, then add the high order values
+ // If the addition of the low order values causes overflow, add one to the high order values
+ // before adding them.
+ match low.checked_add(&new_low_bits) {
+ Some(x) => {
+ if new_high_bits == Zero::zero() {
+ // This is the fast path - every other alternative will rarely occur in practice
+ // considering how large an input would need to be for those paths to be used.
+ return (hi, x);
} else {
- return (hi, low + y);
+ match hi.checked_add(&new_high_bits) {
+ Some(y) => return (y, x),
+ None => fail!("Numeric overflow occured.")
+ }
+ }
+ },
+ None => {
+ let one: T = One::one();
+ let z = match new_high_bits.checked_add(&one) {
+ Some(w) => w,
+ None => fail!("Numeric overflow occured.")
+ };
+ match hi.checked_add(&z) {
+ // This re-executes the addition that was already performed earlier when overflow
+ // occured, this time allowing the overflow to happen. Technically, this could be
+ // avoided by using the checked add intrinsic directly, but that involves using
+ // unsafe code and is not really worthwhile considering how infrequently code will
+ // run in practice. This is the reason that this function requires that the type T
+ // be Unsigned - overflow is not defined for Signed types. This function could be
+ // implemented for signed types as well if that were needed.
+ Some(y) => return (y, low + new_low_bits),
+ None => fail!("Numeric overflow occured.")
}
}
}
/// method that modifies the buffer directory or provides the caller with bytes that can be modifies
/// results in those bytes being marked as used by the buffer.
pub trait FixedBuffer {
- /// Input a vector of bytes. If the buffer becomes full, proccess it with the provided
+ /// Input a vector of bytes. If the buffer becomes full, process it with the provided
/// function and then clear the buffer.
fn input(&mut self, input: &[u8], func: &fn(&[u8]));
use std::rand::RngUtil;
use std::vec;
+ use cryptoutil::{add_bytes_to_bits, add_bytes_to_bits_tuple};
use digest::Digest;
/// Feed 1,000,000 'a's into the digest with varying input sizes and check that the result is
assert!(expected == result_str);
}
+
+ // A normal addition - no overflow occurs
+ #[test]
+ fn test_add_bytes_to_bits_ok() {
+ assert!(add_bytes_to_bits::<u64>(100, 10) == 180);
+ }
+
+ // A simple failure case - adding 1 to the max value
+ #[test]
+ #[should_fail]
+ fn test_add_bytes_to_bits_overflow() {
+ add_bytes_to_bits::<u64>(Bounded::max_value(), 1);
+ }
+
+ // A normal addition - no overflow occurs (fast path)
+ #[test]
+ fn test_add_bytes_to_bits_tuple_ok() {
+ assert!(add_bytes_to_bits_tuple::<u64>((5, 100), 10) == (5, 180));
+ }
+
+ // The low order value overflows into the high order value
+ #[test]
+ fn test_add_bytes_to_bits_tuple_ok2() {
+ assert!(add_bytes_to_bits_tuple::<u64>((5, Bounded::max_value()), 1) == (6, 7));
+ }
+
+ // The value to add is too large to be converted into bits without overflowing its type
+ #[test]
+ fn test_add_bytes_to_bits_tuple_ok3() {
+ assert!(add_bytes_to_bits_tuple::<u64>((5, 0), 0x4000000000000001) == (7, 8));
+ }
+
+ // A simple failure case - adding 1 to the max value
+ #[test]
+ #[should_fail]
+ fn test_add_bytes_to_bits_tuple_overflow() {
+ add_bytes_to_bits_tuple::<u64>((Bounded::max_value(), Bounded::max_value()), 1);
+ }
+
+ // The value to add is too large to convert to bytes without overflowing its type, but the high
+ // order value from this conversion overflows when added to the existing high order value
+ #[test]
+ #[should_fail]
+ fn test_add_bytes_to_bits_tuple_overflow2() {
+ add_bytes_to_bits_tuple::<u64>((Bounded::max_value::<u64>() - 1, 0), 0x8000000000000000);
+ }
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::uint;
use std::vec;
fn output_bits(&self) -> uint;
/**
- * Convenience functon that feeds a string into a digest
+ * Convenience function that feeds a string into a digest.
*
* # Arguments
*
- * * in The string to feed into the digest
+ * * `input` The string to feed into the digest
*/
fn input_str(&mut self, input: &str) {
self.input(input.as_bytes());
}
/**
- * Convenience functon that retrieves the result of a digest as a
+ * Convenience function that retrieves the result of a digest as a
* ~str in hexadecimal format.
*/
fn result_str(&mut self) -> ~str {
fn to_hex(rr: &[u8]) -> ~str {
let mut s = ~"";
for b in rr.iter() {
- let hex = uint::to_str_radix(*b as uint, 16u);
+ let hex = (*b as uint).to_str_radix(16u);
if hex.len() == 1 {
s.push_char('0');
}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::uint;
+
+use cryptoutil::{write_u32_le, read_u32v_le, FixedBuffer, FixedBuffer64, StandardPadding};
+use digest::Digest;
+
+
+// A structure that represents that state of a digest computation for the MD5 digest function
+struct Md5State {
+ s0: u32,
+ s1: u32,
+ s2: u32,
+ s3: u32
+}
+
+impl Md5State {
+ fn new() -> Md5State {
+ return Md5State {
+ s0: 0x67452301,
+ s1: 0xefcdab89,
+ s2: 0x98badcfe,
+ s3: 0x10325476
+ };
+ }
+
+ fn reset(&mut self) {
+ self.s0 = 0x67452301;
+ self.s1 = 0xefcdab89;
+ self.s2 = 0x98badcfe;
+ self.s3 = 0x10325476;
+ }
+
+ fn process_block(&mut self, input: &[u8]) {
+ fn f(u: u32, v: u32, w: u32) -> u32 {
+ return (u & v) | (!u & w);
+ }
+
+ fn g(u: u32, v: u32, w: u32) -> u32 {
+ return (u & w) | (v & !w);
+ }
+
+ fn h(u: u32, v: u32, w: u32) -> u32 {
+ return u ^ v ^ w;
+ }
+
+ fn i(u: u32, v: u32, w: u32) -> u32 {
+ return v ^ (u | !w);
+ }
+
+ fn rotate_left(x: u32, n: u32) -> u32 {
+ return (x << n) | (x >> (32 - n));
+ }
+
+ fn op_f(w: u32, x: u32, y: u32, z: u32, m: u32, s: u32) -> u32 {
+ return rotate_left(w + f(x, y, z) + m, s) + x;
+ }
+
+ fn op_g(w: u32, x: u32, y: u32, z: u32, m: u32, s: u32) -> u32 {
+ return rotate_left(w + g(x, y, z) + m, s) + x;
+ }
+
+ fn op_h(w: u32, x: u32, y: u32, z: u32, m: u32, s: u32) -> u32 {
+ return rotate_left(w + h(x, y, z) + m, s) + x;
+ }
+
+ fn op_i(w: u32, x: u32, y: u32, z: u32, m: u32, s: u32) -> u32 {
+ return rotate_left(w + i(x, y, z) + m, s) + x;
+ }
+
+ let mut a = self.s0;
+ let mut b = self.s1;
+ let mut c = self.s2;
+ let mut d = self.s3;
+
+ let mut data = [0u32, ..16];
+
+ read_u32v_le(data, input);
+
+ // round 1
+ do uint::range_step(0, 16, 4) |i| {
+ a = op_f(a, b, c, d, data[i] + C1[i], 7);
+ d = op_f(d, a, b, c, data[i + 1] + C1[i + 1], 12);
+ c = op_f(c, d, a, b, data[i + 2] + C1[i + 2], 17);
+ b = op_f(b, c, d, a, data[i + 3] + C1[i + 3], 22);
+ true
+ };
+
+ // round 2
+ let mut t = 1;
+ do uint::range_step(0, 16, 4) |i| {
+ a = op_g(a, b, c, d, data[t & 0x0f] + C2[i], 5);
+ d = op_g(d, a, b, c, data[(t + 5) & 0x0f] + C2[i + 1], 9);
+ c = op_g(c, d, a, b, data[(t + 10) & 0x0f] + C2[i + 2], 14);
+ b = op_g(b, c, d, a, data[(t + 15) & 0x0f] + C2[i + 3], 20);
+ t += 20;
+ true
+ };
+
+ // round 3
+ t = 5;
+ do uint::range_step(0, 16, 4) |i| {
+ a = op_h(a, b, c, d, data[t & 0x0f] + C3[i], 4);
+ d = op_h(d, a, b, c, data[(t + 3) & 0x0f] + C3[i + 1], 11);
+ c = op_h(c, d, a, b, data[(t + 6) & 0x0f] + C3[i + 2], 16);
+ b = op_h(b, c, d, a, data[(t + 9) & 0x0f] + C3[i + 3], 23);
+ t += 12;
+ true
+ };
+
+ // round 4
+ t = 0;
+ do uint::range_step(0, 16, 4) |i| {
+ a = op_i(a, b, c, d, data[t & 0x0f] + C4[i], 6);
+ d = op_i(d, a, b, c, data[(t + 7) & 0x0f] + C4[i + 1], 10);
+ c = op_i(c, d, a, b, data[(t + 14) & 0x0f] + C4[i + 2], 15);
+ b = op_i(b, c, d, a, data[(t + 21) & 0x0f] + C4[i + 3], 21);
+ t += 28;
+ true
+ };
+
+ self.s0 += a;
+ self.s1 += b;
+ self.s2 += c;
+ self.s3 += d;
+ }
+}
+
+// Round 1 constants
+static C1: [u32, ..16] = [
+ 0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee, 0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
+ 0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be, 0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821
+];
+
+// Round 2 constants
+static C2: [u32, ..16] = [
+ 0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa, 0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8,
+ 0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed, 0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a
+];
+
+// Round 3 constants
+static C3: [u32, ..16] = [
+ 0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c, 0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
+ 0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05, 0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665
+];
+
+// Round 4 constants
+static C4: [u32, ..16] = [
+ 0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039, 0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
+ 0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1, 0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391
+];
+
+
+/// The MD5 Digest algorithm
+struct Md5 {
+ priv length_bytes: u64,
+ priv buffer: FixedBuffer64,
+ priv state: Md5State,
+ priv finished: bool,
+}
+
+impl Md5 {
+ /// Construct a new instance of the MD5 Digest.
+ pub fn new() -> Md5 {
+ return Md5 {
+ length_bytes: 0,
+ buffer: FixedBuffer64::new(),
+ state: Md5State::new(),
+ finished: false
+ }
+ }
+}
+
+impl Digest for Md5 {
+ fn input(&mut self, input: &[u8]) {
+ assert!(!self.finished);
+ // Unlike Sha1 and Sha2, the length value in MD5 is defined as the length of the message mod
+ // 2^64 - ie: integer overflow is OK.
+ self.length_bytes += input.len() as u64;
+ self.buffer.input(input, |d: &[u8]| { self.state.process_block(d); });
+ }
+
+ fn reset(&mut self) {
+ self.length_bytes = 0;
+ self.buffer.reset();
+ self.state.reset();
+ self.finished = false;
+ }
+
+ fn result(&mut self, out: &mut [u8]) {
+ if !self.finished {
+ self.buffer.standard_padding(8, |d: &[u8]| { self.state.process_block(d); });
+ write_u32_le(self.buffer.next(4), (self.length_bytes << 3) as u32);
+ write_u32_le(self.buffer.next(4), (self.length_bytes >> 29) as u32);
+ self.state.process_block(self.buffer.full_buffer());
+ self.finished = true;
+ }
+
+ write_u32_le(out.mut_slice(0, 4), self.state.s0);
+ write_u32_le(out.mut_slice(4, 8), self.state.s1);
+ write_u32_le(out.mut_slice(8, 12), self.state.s2);
+ write_u32_le(out.mut_slice(12, 16), self.state.s3);
+ }
+
+ fn output_bits(&self) -> uint { 128 }
+}
+
+
+#[cfg(test)]
+mod tests {
+ use cryptoutil::test::test_digest_1million_random;
+ use digest::Digest;
+ use md5::Md5;
+
+
+ struct Test {
+ input: ~str,
+ output_str: ~str,
+ }
+
+ fn test_hash<D: Digest>(sh: &mut D, tests: &[Test]) {
+ // Test that it works when accepting the message all at once
+ for t in tests.iter() {
+ sh.input_str(t.input);
+
+ let out_str = sh.result_str();
+ assert!(out_str == t.output_str);
+
+ sh.reset();
+ }
+
+ // Test that it works when accepting the message in pieces
+ for t in tests.iter() {
+ let len = t.input.len();
+ let mut left = len;
+ while left > 0u {
+ let take = (left + 1u) / 2u;
+ sh.input_str(t.input.slice(len - left, take + len - left));
+ left = left - take;
+ }
+
+ let out_str = sh.result_str();
+ assert!(out_str == t.output_str);
+
+ sh.reset();
+ }
+ }
+
+ #[test]
+ fn test_md5() {
+ // Examples from wikipedia
+ let wikipedia_tests = ~[
+ Test {
+ input: ~"",
+ output_str: ~"d41d8cd98f00b204e9800998ecf8427e"
+ },
+ Test {
+ input: ~"The quick brown fox jumps over the lazy dog",
+ output_str: ~"9e107d9d372bb6826bd81d3542a419d6"
+ },
+ Test {
+ input: ~"The quick brown fox jumps over the lazy dog.",
+ output_str: ~"e4d909c290d0fb1ca068ffaddf22cbd0"
+ },
+ ];
+
+ let tests = wikipedia_tests;
+
+ let mut sh = Md5::new();
+
+ test_hash(&mut sh, tests);
+ }
+
+ #[test]
+ fn test_1million_random_md5() {
+ let mut sh = Md5::new();
+ test_digest_1million_random(
+ &mut sh,
+ 64,
+ "7707d6ae4e027c70eea2a935c2296f21");
+ }
+}
+
+
+#[cfg(test)]
+mod bench {
+ use extra::test::BenchHarness;
+
+ use md5::Md5;
+
+
+ #[bench]
+ pub fn md5_10(bh: & mut BenchHarness) {
+ let mut sh = Md5::new();
+ let bytes = [1u8, ..10];
+ do bh.iter {
+ sh.input(bytes);
+ }
+ bh.bytes = bytes.len() as u64;
+ }
+
+ #[bench]
+ pub fn md5_1k(bh: & mut BenchHarness) {
+ let mut sh = Md5::new();
+ let bytes = [1u8, ..1024];
+ do bh.iter {
+ sh.input(bytes);
+ }
+ bh.bytes = bytes.len() as u64;
+ }
+
+ #[bench]
+ pub fn md5_64k(bh: & mut BenchHarness) {
+ let mut sh = Md5::new();
+ let bytes = [1u8, ..65536];
+ do bh.iter {
+ sh.input(bytes);
+ }
+ bh.bytes = bytes.len() as u64;
+ }
+}
*/
-use cryptoutil::{write_u32_be, read_u32v_be, shift_add_check_overflow, FixedBuffer, FixedBuffer64,
+use cryptoutil::{write_u32_be, read_u32v_be, add_bytes_to_bits, FixedBuffer, FixedBuffer64,
StandardPadding};
use digest::Digest;
fn add_input(st: &mut Sha1, msg: &[u8]) {
assert!((!st.computed));
// Assumes that msg.len() can be converted to u64 without overflow
- st.length_bits = shift_add_check_overflow(st.length_bits, msg.len() as u64, 3);
+ st.length_bits = add_bytes_to_bits(st.length_bits, msg.len() as u64);
st.buffer.input(msg, |d: &[u8]| { process_msg_block(d, &mut st.h); });
}
use std::uint;
-use cryptoutil::{write_u64_be, write_u32_be, read_u64v_be, read_u32v_be, shift_add_check_overflow,
- shift_add_check_overflow_tuple, FixedBuffer, FixedBuffer128, FixedBuffer64, StandardPadding};
+use cryptoutil::{write_u64_be, write_u32_be, read_u64v_be, read_u32v_be, add_bytes_to_bits,
+ add_bytes_to_bits_tuple, FixedBuffer, FixedBuffer128, FixedBuffer64, StandardPadding};
use digest::Digest;
fn input(&mut self, input: &[u8]) {
assert!(!self.finished)
// Assumes that input.len() can be converted to u64 without overflow
- self.length_bits = shift_add_check_overflow_tuple(self.length_bits, input.len() as u64, 3);
+ self.length_bits = add_bytes_to_bits_tuple(self.length_bits, input.len() as u64);
self.buffer.input(input, |input: &[u8]| { self.state.process_block(input) });
}
fn input(&mut self, input: &[u8]) {
assert!(!self.finished)
// Assumes that input.len() can be converted to u64 without overflow
- self.length_bits = shift_add_check_overflow(self.length_bits, input.len() as u64, 3);
+ self.length_bits = add_bytes_to_bits(self.length_bits, input.len() as u64);
self.buffer.input(input, |input: &[u8]| { self.state.process_block(input) });
}
priv bits: uint
}
-/// An iterface for casting C-like enum to uint and back.
+/// An interface for casting C-like enum to uint and back.
pub trait CLike {
/// Converts C-like enum to uint.
fn to_uint(&self) -> uint;
pub mod container;
pub mod bitv;
-pub mod fun_treemap;
pub mod list;
pub mod ringbuf;
pub mod priority_queue;
mod cryptoutil;
#[path="crypto/digest.rs"]
pub mod digest;
+#[path="crypto/md5.rs"]
+pub mod md5;
#[path="crypto/sha1.rs"]
pub mod sha1;
#[path="crypto/sha2.rs"]
pub mod fileinput;
pub mod flate;
pub mod hex;
+pub mod uuid;
+
#[cfg(unicode)]
mod unicode;
None]` will only take input once unless `io::stdin().seek(0, SeekSet)`
is called between.
-The `pathify` function handles converting a list of file paths as
+The `make_path_option_vec` function handles converting a list of file paths as
strings to the appropriate format, including the (optional) conversion
of `"-"` to `stdin`.
or a program that numbers lines after concatenating two files
- for input_vec_state(pathify([~"a.txt", ~"b.txt"])) |line, state| {
+ for input_vec_state(make_path_option_vec([~"a.txt", ~"b.txt"])) |line, state| {
io::println(fmt!("%u: %s", state.line_num,
line));
}
previous_was_newline: bool
}
-// XXX: remove this when Reader has &mut self. Should be removable via
-// "self.fi." -> "self." and renaming FileInput_. Documentation above
+
+// FIXME #5723: remove this when Reader has &mut self.
+// Removing it would mean giving read_byte in the Reader impl for
+// FileInput &mut self, which in turn means giving most of the
+// io::Reader trait methods &mut self. That can't be done right now
+// because of io::with_bytes_reader and #5723.
+// Should be removable via
+// "self.fi" -> "self." and renaming FileInput_. Documentation above
// will likely have to be updated to use `let mut in = ...`.
pub struct FileInput {
fi: @mut FileInput_
/**
Create a `FileInput` object from a vec of files. An empty
vec means lines are read from `stdin` (use `from_vec_raw` to stop
- this behaviour). Any occurence of `None` represents `stdin`.
+ this behaviour). Any occurrence of `None` represents `stdin`.
*/
pub fn from_vec(files: ~[Option<Path>]) -> FileInput {
FileInput::from_vec_raw(
*/
pub fn from_args() -> FileInput {
let args = os::args();
- let pathed = pathify(args.tail(), true);
+ let pathed = make_path_option_vec(args.tail(), true);
FileInput::from_vec(pathed)
}
instance. `stdin_hyphen` controls whether `-` represents `stdin` or
a literal `-`.
*/
-// XXX: stupid, unclear name
-pub fn pathify(vec: &[~str], stdin_hyphen : bool) -> ~[Option<Path>] {
+pub fn make_path_option_vec(vec: &[~str], stdin_hyphen : bool) -> ~[Option<Path>] {
vec.iter().map(|str| {
if stdin_hyphen && "-" == *str {
None
#[cfg(test)]
mod test {
- use super::{FileInput, pathify, input_vec, input_vec_state};
+ use super::{FileInput, make_path_option_vec, input_vec, input_vec_state};
use std::io;
use std::uint;
}
#[test]
- fn test_pathify() {
+ fn test_make_path_option_vec() {
let strs = [~"some/path",
~"some/other/path"];
let paths = ~[Some(Path("some/path")),
Some(Path("some/other/path"))];
- assert_eq!(pathify(strs, true), paths.clone());
- assert_eq!(pathify(strs, false), paths);
+ assert_eq!(make_path_option_vec(strs, true), paths.clone());
+ assert_eq!(make_path_option_vec(strs, false), paths);
- assert_eq!(pathify([~"-"], true), ~[None]);
- assert_eq!(pathify([~"-"], false), ~[Some(Path("-"))]);
+ assert_eq!(make_path_option_vec([~"-"], true), ~[None]);
+ assert_eq!(make_path_option_vec([~"-"], false), ~[Some(Path("-"))]);
}
#[test]
fn test_fileinput_read_byte() {
- let filenames = pathify(vec::from_fn(
+ let filenames = make_path_option_vec(vec::from_fn(
3,
|i| fmt!("tmp/lib-fileinput-test-fileinput-read-byte-%u.tmp", i)), true);
#[test]
fn test_fileinput_read() {
- let filenames = pathify(vec::from_fn(
+ let filenames = make_path_option_vec(vec::from_fn(
3,
|i| fmt!("tmp/lib-fileinput-test-fileinput-read-%u.tmp", i)), true);
#[test]
fn test_input_vec() {
let mut all_lines = ~[];
- let filenames = pathify(vec::from_fn(
+ let filenames = make_path_option_vec(vec::from_fn(
3,
|i| fmt!("tmp/lib-fileinput-test-input-vec-%u.tmp", i)), true);
#[test]
fn test_input_vec_state() {
- let filenames = pathify(vec::from_fn(
+ let filenames = make_path_option_vec(vec::from_fn(
3,
|i| fmt!("tmp/lib-fileinput-test-input-vec-state-%u.tmp", i)),true);
#[test]
fn test_empty_files() {
- let filenames = pathify(vec::from_fn(
+ let filenames = make_path_option_vec(vec::from_fn(
3,
|i| fmt!("tmp/lib-fileinput-test-empty-files-%u.tmp", i)),true);
#[test]
fn test_next_file() {
- let filenames = pathify(vec::from_fn(
+ let filenames = make_path_option_vec(vec::from_fn(
3,
|i| fmt!("tmp/lib-fileinput-test-next-file-%u.tmp", i)),true);
#[test]
#[should_fail]
fn test_input_vec_missing_file() {
- do input_vec(pathify([~"this/file/doesnt/exist"], true)) |line| {
+ do input_vec(make_path_option_vec([~"this/file/doesnt/exist"], true)) |line| {
println(line);
true
};
static TDEFL_WRITE_ZLIB_HEADER : c_int = 0x01000; // write zlib header and adler32 checksum
fn deflate_bytes_internal(bytes: &[u8], flags: c_int) -> ~[u8] {
+ #[fixed_stack_segment]; #[inline(never)];
+
do bytes.as_imm_buf |b, len| {
unsafe {
let mut outsz : size_t = 0;
}
fn inflate_bytes_internal(bytes: &[u8], flags: c_int) -> ~[u8] {
+ #[fixed_stack_segment]; #[inline(never)];
+
do bytes.as_imm_buf |b, len| {
unsafe {
let mut outsz : size_t = 0;
This module is currently unsafe because it uses `Clone + Send` as a type
parameter bounds meaning POD (plain old data), but `Clone + Send` and
-POD are not equivelant.
+POD are not equivalent.
*/
pub mod pod {
}
}
- // XXX: Remove `@mut` when this module is ported to the new I/O traits,
- // which use `&mut self` properly.
+ // FIXME #6850: Remove `@mut` when this module is ported to the new I/O traits,
+ // which use `&mut self` properly. (For example, util::comm::GenericPort's try_recv
+ // method doesn't use `&mut self`, so the `try_recv` method in the impl of `BytePort`
+ // for `PipeBytePort` can't have `&mut self` either.)
pub struct PipeBytePort {
port: comm::Port<~[u8]>,
buf: @mut ~[u8]
+++ /dev/null
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-/*!
- * A functional key,value store that works on anything.
- *
- * This works using a binary search tree. In the first version, it's a
- * very naive algorithm, but it will probably be updated to be a
- * red-black tree or something else.
- *
- * This is copied and modified from treemap right now. It's missing a lot
- * of features.
- */
-
-
-use std::cmp::{Eq, Ord};
-use std::option::{Some, None};
-
-pub type Treemap<K, V> = @TreeNode<K, V>;
-
-enum TreeNode<K, V> {
- Empty,
- Node(@K, @V, @TreeNode<K, V>, @TreeNode<K, V>)
-}
-
-/// Create a treemap
-pub fn init<K: 'static, V: 'static>() -> Treemap<K, V> {
- @Empty
-}
-
-/// Insert a value into the map
-pub fn insert<K:Eq + Ord + 'static,
- V:'static>(
- m: Treemap<K, V>,
- k: K,
- v: V)
- -> Treemap<K, V> {
- @match m {
- @Empty => Node(@k, @v, @Empty, @Empty),
- @Node(kk, vv, left, right) => cond!(
- (k < *kk) { Node(kk, vv, insert(left, k, v), right) }
- (k == *kk) { Node(kk, @v, left, right) }
- _ { Node(kk, vv, left, insert(right, k, v)) }
- )
- }
-}
-
-/// Find a value based on the key
-pub fn find<K:Eq + Ord + 'static,
- V:Clone + 'static>(
- m: Treemap<K, V>,
- k: K)
- -> Option<V> {
- match *m {
- Empty => None,
- Node(kk, v, left, right) => cond!(
- (k == *kk) { Some((*v).clone()) }
- (k < *kk) { find(left, k) }
- _ { find(right, k) }
- )
- }
-}
-
-/// Visit all pairs in the map in order.
-pub fn traverse<K, V>(m: Treemap<K, V>, f: &fn(&K, &V)) {
- match *m {
- Empty => (),
- // Previously, this had what looked like redundant
- // matches to me, so I changed it. but that may be a
- // de-optimization -- tjc
- Node(@ref k, @ref v, left, right) => {
- traverse(left, |k,v| f(k,v));
- f(k, v);
- traverse(right, |k,v| f(k,v));
- }
- }
-}
}
fn as_bytes_reader<A>(&self, f: &fn(&BytesReader) -> A) -> A {
- // XXX FIXME(#5723)
+ // FIXME(#5723)
let bytes = ::std::util::id::<&[u8]>(self.buf);
let bytes: &'static [u8] = unsafe { cast::transmute(bytes) };
// Recreating the BytesReader state every call since
// except according to those terms.
-use std::uint;
use std::vec;
struct Quad {
if byte <= 16u8 {
result.push_char('0')
}
- result.push_str(uint::to_str_radix(byte as uint, 16u));
+ result.push_str((byte as uint).to_str_radix(16u));
i += 1u32;
}
}
if v.is_empty() { return ~"0" }
let mut s = str::with_capacity(v.len() * l);
for n in v.rev_iter() {
- let ss = uint::to_str_radix(*n as uint, radix);
+ let ss = (*n as uint).to_str_radix(radix);
s.push_str("0".repeat(l - ss.len()));
s.push_str(ss);
}
pub mod rustrt {
use std::libc::{c_char, c_int};
- extern {
- pub fn linenoise(prompt: *c_char) -> *c_char;
- pub fn linenoiseHistoryAdd(line: *c_char) -> c_int;
- pub fn linenoiseHistorySetMaxLen(len: c_int) -> c_int;
- pub fn linenoiseHistorySave(file: *c_char) -> c_int;
- pub fn linenoiseHistoryLoad(file: *c_char) -> c_int;
- pub fn linenoiseSetCompletionCallback(callback: *u8);
- pub fn linenoiseAddCompletion(completions: *(), line: *c_char);
+ #[cfg(stage0)]
+ mod macro_hack {
+ #[macro_escape];
+ macro_rules! externfn(
+ (fn $name:ident ($($arg_name:ident : $arg_ty:ty),*) $(-> $ret_ty:ty),*) => (
+ extern {
+ fn $name($($arg_name : $arg_ty),*) $(-> $ret_ty),*;
+ }
+ )
+ )
}
+
+ externfn!(fn linenoise(prompt: *c_char) -> *c_char)
+ externfn!(fn linenoiseHistoryAdd(line: *c_char) -> c_int)
+ externfn!(fn linenoiseHistorySetMaxLen(len: c_int) -> c_int)
+ externfn!(fn linenoiseHistorySave(file: *c_char) -> c_int)
+ externfn!(fn linenoiseHistoryLoad(file: *c_char) -> c_int)
+ externfn!(fn linenoiseSetCompletionCallback(callback: *u8))
+ externfn!(fn linenoiseAddCompletion(completions: *(), line: *c_char))
}
/// Add a line to history
rustrt::linenoiseAddCompletion(completions, buf);
}
}
-}
+ }
}
}
w.write_str(histr);
}
-/// Returns a HashMap with the number of occurences of every element in the
+/// Returns a HashMap with the number of occurrences of every element in the
/// sequence that the iterator exposes.
pub fn freq_count<T: Iterator<U>, U: Eq+Hash>(mut iter: T) -> hashmap::HashMap<U, uint> {
let mut map = hashmap::HashMap::new::<U, uint>();
}
}
// Uncomment if you wish to test for sem races. Not valgrind-friendly.
- /* do 1000.times { task::yield(); } */
+ /* do 1000.times { task::deschedule(); } */
// Need to wait outside the exclusive.
if waiter_nobe.is_some() {
let _ = waiter_nobe.unwrap().recv();
}
}
- // If yield checks start getting inserted anywhere, we can be
+ // If deschedule checks start getting inserted anywhere, we can be
// killed before or after enqueueing. Deciding whether to
// unkillably reacquire the lock needs to happen atomically
// wrt enqueuing.
let s2 = ~s.clone();
do task::spawn || {
do s2.access {
- do 5.times { task::yield(); }
+ do 5.times { task::deschedule(); }
}
}
do s.access {
- do 5.times { task::yield(); }
+ do 5.times { task::deschedule(); }
}
}
#[test]
s2.acquire();
c.send(());
}
- do 5.times { task::yield(); }
+ do 5.times { task::deschedule(); }
s.release();
let _ = p.recv();
let s = ~Semaphore::new(0);
let s2 = ~s.clone();
do task::spawn || {
- do 5.times { task::yield(); }
+ do 5.times { task::deschedule(); }
s2.release();
let _ = p.recv();
}
c.send(());
}
let _ = p.recv(); // wait for child to come alive
- do 5.times { task::yield(); } // let the child contend
+ do 5.times { task::deschedule(); } // let the child contend
}
let _ = p.recv(); // wait for child to be done
}
do n.times {
do m.lock {
let oldval = *sharedstate;
- task::yield();
+ task::deschedule();
*sharedstate = oldval + 1;
}
}
let (p,c) = comm::stream();
do task::spawn || { // linked
let _ = p.recv(); // wait for sibling to get in the mutex
- task::yield();
+ task::deschedule();
fail!();
}
do m2.lock_cond |cond| {
do n.times {
do lock_rwlock_in_mode(x, mode) {
let oldval = *sharedstate;
- task::yield();
+ task::deschedule();
*sharedstate = oldval + 1;
}
}
/// If the color is a bright color, but the terminal only supports 8 colors,
/// the corresponding normal color will be used instead.
///
- /// Rturns true if the color was set, false otherwise.
+ /// Returns true if the color was set, false otherwise.
pub fn bg(&self, color: color::Color) -> bool {
let color = self.dim_if_necessary(color);
if self.num_colors > color {
}
fn usage(binary: &str, helpstr: &str) -> ! {
+ #[fixed_stack_segment]; #[inline(never)];
+
let message = fmt!("Usage: %s [OPTIONS] [FILTER]", binary);
println(groups::usage(message, optgroups()));
println("");
#[allow(missing_doc)];
-
-use std::int;
use std::io;
use std::num;
use std::str;
}
/// A record specifying a time value in seconds and nanoseconds.
-#[deriving(Eq, Encodable, Decodable)]
+#[deriving(Clone, DeepClone, Eq, Encodable, Decodable)]
pub struct Timespec { sec: i64, nsec: i32 }
/*
* nanoseconds since 1970-01-01T00:00:00Z.
*/
pub fn get_time() -> Timespec {
+ #[fixed_stack_segment]; #[inline(never)];
+
unsafe {
let mut sec = 0i64;
let mut nsec = 0i32;
* in nanoseconds since an unspecified epoch.
*/
pub fn precise_time_ns() -> u64 {
+ #[fixed_stack_segment]; #[inline(never)];
+
unsafe {
let mut ns = 0u64;
rustrt::precise_time_ns(&mut ns);
}
pub fn tzset() {
+ #[fixed_stack_segment]; #[inline(never)];
+
unsafe {
rustrt::rust_tzset();
}
}
-#[deriving(Eq, Encodable, Decodable)]
+#[deriving(Clone, DeepClone, Eq, Encodable, Decodable)]
pub struct Tm {
tm_sec: i32, // seconds after the minute ~[0-60]
tm_min: i32, // minutes after the hour ~[0-59]
/// Returns the specified time in UTC
pub fn at_utc(clock: Timespec) -> Tm {
+ #[fixed_stack_segment]; #[inline(never)];
+
unsafe {
let Timespec { sec, nsec } = clock;
let mut tm = empty_tm();
/// Returns the specified time in the local timezone
pub fn at(clock: Timespec) -> Tm {
+ #[fixed_stack_segment]; #[inline(never)];
+
unsafe {
let Timespec { sec, nsec } = clock;
let mut tm = empty_tm();
impl Tm {
/// Convert time to the seconds from January 1, 1970
pub fn to_timespec(&self) -> Timespec {
+ #[fixed_stack_segment]; #[inline(never)];
+
unsafe {
let sec = match self.tm_gmtoff {
0_i32 => rustrt::rust_timegm(self),
//'U' {}
'u' => {
let i = tm.tm_wday as int;
- int::to_str(if i == 0 { 7 } else { i })
+ (if i == 0 { 7 } else { i }).to_str()
}
//'V' {}
'v' => {
parse_type('Y', tm))
}
//'W' {}
- 'w' => int::to_str(tm.tm_wday as int),
+ 'w' => (tm.tm_wday as int).to_str(),
//'X' {}
//'x' {}
- 'Y' => int::to_str(tm.tm_year as int + 1900),
+ 'Y' => (tm.tm_year as int + 1900).to_str(),
'y' => fmt!("%02d", (tm.tm_year as int + 1900) % 100),
'Z' => tm.tm_zone.clone(),
'z' => {
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+/*!
+Generate and parse UUIDs
+
+Provides support for Universally Unique Identifiers (UUIDs). A UUID is a
+unique 128-bit number, stored as 16 octets. UUIDs are used to assign unique
+identifiers to entities without requiring a central allocating authority.
+
+They are particularly useful in distributed systems, though can be used in
+disparate areas, such as databases and network protocols. Typically a UUID is
+displayed in a readable string form as a sequence of hexadecimals digits,
+separated into groups by hyphens.
+
+The uniqueness property is not strictly guaranteed, however for all practical
+purposes, it can be assumed that an unintentional collision would be extremely
+unlikely.
+
+# Examples
+
+To create a new random (V4) UUID and print it out in hexadecimal form:
+
+~~~ {.rust}
+extern mod extra;
+use extra::uuid::Uuid;
+
+fn main() {
+ let uuid1 = Uuid::new_v4();
+ println(uuid1.to_str());
+}
+~~~
+
+# Strings
+
+Examples of string representations:
+
+* simple: `936DA01F9ABD4d9d80C702AF85C822A8`
+* hyphenated: `550e8400-e29b-41d4-a716-446655440000`
+* urn: `urn:uuid:F9168C5E-CEB2-4faa-B6BF-329BF39FA1E4`
+
+# References
+
+* [Wikipedia: Universally Unique Identifier](
+ http://en.wikipedia.org/wiki/Universally_unique_identifier)
+* [RFC4122: A Universally Unique IDentifier (UUID) URN Namespace](
+ http://tools.ietf.org/html/rfc4122)
+
+*/
+
+use std::str;
+use std::vec;
+use std::num::{FromStrRadix, Zero};
+use std::char::Char;
+use std::container::Container;
+use std::to_str::ToStr;
+use std::rand;
+use std::rand::RngUtil;
+use std::cmp::Eq;
+use std::cast::{transmute,transmute_copy};
+
+/// A 128-bit (16 byte) buffer containing the ID
+pub type UuidBytes = [u8, ..16];
+
+/// The version of the UUID, denoting the generating algorithm
+#[deriving(Eq)]
+pub enum UuidVersion {
+ /// Version 1: MAC address
+ Version1Mac = 1,
+ /// Version 2: DCE Security
+ Version2Dce = 2,
+ /// Version 3: MD5 hash
+ Version3Md5 = 3,
+ /// Version 4: Random
+ Version4Random = 4,
+ /// Version 5: SHA-1 hash
+ Version5Sha1 = 5,
+}
+
+/// The reserved variants of UUIDs
+#[deriving(Eq)]
+pub enum UuidVariant {
+ /// Reserved by the NCS for backward compatability
+ VariantNCS,
+ /// As described in the RFC4122 Specification (default)
+ VariantRFC4122,
+ /// Resreved by Microsoft for backward compatability
+ VariantMicrosoft,
+ /// Reserved for future expansion
+ VariantFuture,
+}
+
+/// A Universally Unique Identifier (UUID)
+pub struct Uuid {
+ /// The 128-bit number stored in 16 bytes
+ bytes: UuidBytes
+}
+
+/// A UUID stored as fields (identical to UUID, used only for conversions)
+struct UuidFields {
+ /// First field, 32-bit word
+ data1: u32,
+ /// Second field, 16-bit short
+ data2: u16,
+ /// Third field, 16-bit short
+ data3: u16,
+ /// Fourth field, 8 bytes
+ data4: [u8, ..8]
+}
+
+/// Error details for string parsing failures
+pub enum ParseError {
+ ErrorInvalidLength(uint),
+ ErrorInvalidCharacter(char, uint),
+ ErrorInvalidGroups(uint),
+ ErrorInvalidGroupLength(uint, uint, uint),
+}
+
+/// Converts a ParseError to a string
+impl ToStr for ParseError {
+ #[inline]
+ fn to_str(&self) -> ~str {
+ match *self {
+ ErrorInvalidLength(found) =>
+ fmt!("Invalid length; expecting 32, 36 or 45 chars, found %u",
+ found),
+ ErrorInvalidCharacter(found, pos) =>
+ fmt!("Invalid character; found `%c` (0x%02x) at offset %u",
+ found, found as uint, pos),
+ ErrorInvalidGroups(found) =>
+ fmt!("Malformed; wrong number of groups: expected 1 or 5, found %u",
+ found),
+ ErrorInvalidGroupLength(group, found, expecting) =>
+ fmt!("Malformed; length of group %u was %u, expecting %u",
+ group, found, expecting),
+ }
+ }
+}
+
+// Length of each hyphenated group in hex digits
+static UuidGroupLens: [uint, ..5] = [8u, 4u, 4u, 4u, 12u];
+
+/// UUID support
+impl Uuid {
+
+ /// Returns a nil or empty UUID (containing all zeroes)
+ pub fn new_nil() -> Uuid {
+ let uuid = Uuid{ bytes: [0, .. 16] };
+ uuid
+ }
+
+ /// Create a new UUID of the specified version
+ pub fn new(v: UuidVersion) -> Option<Uuid> {
+ match v {
+ Version4Random => Some(Uuid::new_v4()),
+ _ => None
+ }
+ }
+
+ /// Creates a new random UUID
+ ///
+ /// Uses the `rand` module's default RNG task as the source
+ /// of random numbers. Use the rand::Rand trait to supply
+ /// a custom generator if required.
+ pub fn new_v4() -> Uuid {
+ let ub = rand::task_rng().gen_bytes(16);
+ let mut uuid = Uuid{ bytes: [0, .. 16] };
+ vec::bytes::copy_memory(uuid.bytes, ub, 16);
+ uuid.set_variant(VariantRFC4122);
+ uuid.set_version(Version4Random);
+ uuid
+ }
+
+ /// Creates a UUID using the supplied field values
+ ///
+ /// # Arguments
+ /// * `d1` A 32-bit word
+ /// * `d2` A 16-bit word
+ /// * `d3` A 16-bit word
+ /// * `d4` Array of 8 octets
+ pub fn from_fields(d1: u32, d2: u16, d3: u16, d4: &[u8]) -> Uuid {
+ use std::unstable::intrinsics::{to_be16, to_be32};
+
+ // First construct a temporary field-based struct
+ let mut fields = UuidFields {
+ data1: 0,
+ data2: 0,
+ data3: 0,
+ data4: [0, ..8]
+ };
+
+ fields.data1 = to_be32(d1 as i32) as u32;
+ fields.data2 = to_be16(d2 as i16) as u16;
+ fields.data3 = to_be16(d3 as i16) as u16;
+ vec::bytes::copy_memory(fields.data4, d4, 8);
+
+ unsafe {
+ transmute(fields)
+ }
+ }
+
+ /// Creates a UUID using the supplied bytes
+ ///
+ /// # Arguments
+ /// * `b` An array or slice of 16 bytes
+ pub fn from_bytes(b: &[u8]) -> Option<Uuid> {
+ if b.len() != 16 {
+ return None
+ }
+
+ let mut uuid = Uuid{ bytes: [0, .. 16] };
+ unsafe {
+ vec::raw::copy_memory(uuid.bytes, b, 16);
+ }
+ Some(uuid)
+ }
+
+ /// Specifies the variant of the UUID structure
+ fn set_variant(&mut self, v: UuidVariant) {
+ // Octet 8 contains the variant in the most significant 3 bits
+ match v {
+ VariantNCS => // b0xx...
+ self.bytes[8] = self.bytes[8] & 0x7f,
+ VariantRFC4122 => // b10x...
+ self.bytes[8] = (self.bytes[8] & 0x3f) | 0x80,
+ VariantMicrosoft => // b110...
+ self.bytes[8] = (self.bytes[8] & 0x1f) | 0xc0,
+ VariantFuture => // b111...
+ self.bytes[8] = (self.bytes[8] & 0x1f) | 0xe0,
+ }
+ }
+
+ /// Returns the variant of the UUID structure
+ ///
+ /// This determines the interpretation of the structure of the UUID.
+ /// Currently only the RFC4122 variant is generated by this module.
+ ///
+ /// * [Variant Reference](http://tools.ietf.org/html/rfc4122#section-4.1.1)
+ pub fn get_variant(&self) -> Option<UuidVariant> {
+ if self.bytes[8] & 0x80 == 0x00 {
+ Some(VariantNCS)
+ } else if self.bytes[8] & 0xc0 == 0x80 {
+ Some(VariantRFC4122)
+ } else if self.bytes[8] & 0xe0 == 0xc0 {
+ Some(VariantMicrosoft)
+ } else if self.bytes[8] & 0xe0 == 0xe0 {
+ Some(VariantFuture)
+ } else {
+ None
+ }
+ }
+
+ /// Specifies the version number of the UUID
+ fn set_version(&mut self, v: UuidVersion) {
+ self.bytes[6] = (self.bytes[6] & 0xF) | ((v as u8) << 4);
+ }
+
+ /// Returns the version number of the UUID
+ ///
+ /// This represents the algorithm used to generate the contents.
+ ///
+ /// Currently only the Random (V4) algorithm is supported by this
+ /// module. There are security and privacy implications for using
+ /// older versions - see [Wikipedia: Universally Unique Identifier](
+ /// http://en.wikipedia.org/wiki/Universally_unique_identifier) for
+ /// details.
+ ///
+ /// * [Version Reference](http://tools.ietf.org/html/rfc4122#section-4.1.3)
+ pub fn get_version_num(&self) -> uint {
+ (self.bytes[6] >> 4) as uint
+ }
+
+ /// Returns the version of the UUID
+ ///
+ /// This represents the algorithm used to generate the contents
+ pub fn get_version(&self) -> Option<UuidVersion> {
+ let v = (self.bytes[6] >> 4);
+ match v {
+ 1 => Some(Version1Mac),
+ 2 => Some(Version2Dce),
+ 3 => Some(Version3Md5),
+ 4 => Some(Version4Random),
+ 5 => Some(Version5Sha1),
+ _ => None
+ }
+ }
+
+ /// Return an array of 16 octets containing the UUID data
+ pub fn to_bytes<'a>(&'a self) -> &'a [u8] {
+ self.bytes.as_slice()
+ }
+
+ /// Returns the UUID as a string of 16 hexadecimal digits
+ ///
+ /// Example: `936DA01F9ABD4d9d80C702AF85C822A8`
+ pub fn to_simple_str(&self) -> ~str {
+ let mut s: ~[u8] = vec::from_elem(32, 0u8);
+ for i in range(0u, 16u) {
+ let digit = fmt!("%02x", self.bytes[i] as uint);
+ s[i*2+0] = digit[0];
+ s[i*2+1] = digit[1];
+ }
+ str::from_bytes(s)
+ }
+
+ /// Returns a string of hexadecimal digits, separated into groups with a hypen
+ ///
+ /// Example: `550e8400-e29b-41d4-a716-446655440000`
+ pub fn to_hyphenated_str(&self) -> ~str {
+ use std::unstable::intrinsics::{to_be16, to_be32};
+ // Convert to field-based struct as it matches groups in output.
+ // Ensure fields are in network byte order, as per RFC.
+ let mut uf: UuidFields;
+ unsafe {
+ uf = transmute_copy(&self.bytes);
+ }
+ uf.data1 = to_be32(uf.data1 as i32) as u32;
+ uf.data2 = to_be16(uf.data2 as i16) as u16;
+ uf.data3 = to_be16(uf.data3 as i16) as u16;
+ let s = fmt!("%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
+ uf.data1 as uint,
+ uf.data2 as uint, uf.data3 as uint,
+ uf.data4[0] as uint, uf.data4[1] as uint,
+ uf.data4[2] as uint, uf.data4[3] as uint, uf.data4[4] as uint,
+ uf.data4[5] as uint, uf.data4[6] as uint, uf.data4[7] as uint);
+ s
+ }
+
+ /// Returns the UUID formatted as a full URN string
+ ///
+ /// This is the same as the hyphenated format, but with the "urn:uuid:" prefix.
+ ///
+ /// Example: `urn:uuid:F9168C5E-CEB2-4faa-B6BF-329BF39FA1E4`
+ pub fn to_urn_str(&self) -> ~str {
+ "urn:uuid:" + self.to_hyphenated_str()
+ }
+
+ /// Parses a UUID from a string of hexadecimal digits with optional hyphens
+ ///
+ /// Any of the formats generated by this module (simple, hyphenated, urn) are
+ /// supported by this parsing function.
+ pub fn parse_string(us: &str) -> Result<Uuid, ParseError> {
+
+ let mut us = us.clone();
+ let orig_len = us.len();
+
+ // Ensure length is valid for any of the supported formats
+ if orig_len != 32 && orig_len != 36 && orig_len != 45 {
+ return Err(ErrorInvalidLength(orig_len));
+ }
+
+ // Strip off URN prefix if present
+ if us.starts_with("urn:uuid:") {
+ us = us.slice(9, orig_len);
+ }
+
+ // Make sure all chars are either hex digits or hyphen
+ for (i, c) in us.iter().enumerate() {
+ match c {
+ '0'..'9' | 'A'..'F' | 'a'..'f' | '-' => {},
+ _ => return Err(ErrorInvalidCharacter(c, i)),
+ }
+ }
+
+ // Split string up by hyphens into groups
+ let hex_groups: ~[&str] = us.split_str_iter("-").collect();
+
+ // Get the length of each group
+ let group_lens: ~[uint] = hex_groups.iter().map(|&v| v.len()).collect();
+
+ // Ensure the group lengths are valid
+ match group_lens.len() {
+ // Single group, no hyphens
+ 1 => {
+ if group_lens[0] != 32 {
+ return Err(ErrorInvalidLength(group_lens[0]));
+ }
+ },
+ // Five groups, hyphens in between each
+ 5 => {
+ // Ensure each group length matches the expected
+ for (i, (&gl, &expected)) in
+ group_lens.iter().zip(UuidGroupLens.iter()).enumerate() {
+ if gl != expected {
+ return Err(ErrorInvalidGroupLength(i, gl, expected))
+ }
+ }
+ },
+ _ => {
+ return Err(ErrorInvalidGroups(group_lens.len()));
+ }
+ }
+
+ // Normalise into one long hex string
+ let vs = hex_groups.concat();
+
+ // At this point, we know we have a valid hex string, without hyphens
+ assert!(vs.len() == 32);
+ assert!(vs.iter().all(|c| c.is_digit_radix(16)));
+
+ // Allocate output UUID buffer
+ let mut ub = [0u8, ..16];
+
+ // Extract each hex digit from the string
+ for i in range(0u, 16u) {
+ ub[i] = FromStrRadix::from_str_radix(vs.slice(i*2, (i+1)*2), 16).unwrap();
+ }
+
+ Ok(Uuid::from_bytes(ub).unwrap())
+ }
+}
+
+impl Zero for Uuid {
+ /// Returns the nil UUID, which is all zeroes
+ fn zero() -> Uuid {
+ Uuid::new_nil()
+ }
+
+ /// Tests if the UUID is nil or all zeroes
+ fn is_zero(&self) -> bool {
+ return self.bytes.iter().all(|&b| b == 0);
+ }
+}
+
+impl Clone for Uuid {
+ /// Returns a copy of the UUID
+ fn clone(&self) -> Uuid {
+ let mut clone = Uuid{ bytes: [0, .. 16] };
+ vec::bytes::copy_memory(clone.bytes, self.bytes, 16);
+ clone
+ }
+}
+
+impl FromStr for Uuid {
+ /// Parse a hex string and interpret as a UUID
+ ///
+ /// Accepted formats are a sequence of 32 hexadecimal characters,
+ /// with or without hypens (grouped as 8, 4, 4, 4, 12).
+ fn from_str(us: &str) -> Option<Uuid> {
+ let result = Uuid::parse_string(us);
+ match result {
+ Ok(u) => Some(u),
+ Err(_) => None
+ }
+ }
+}
+
+/// Convert the UUID to a hexadecimal-based string representation
+impl ToStr for Uuid {
+ fn to_str(&self) -> ~str {
+ self.to_simple_str()
+ }
+}
+
+/// Test two UUIDs for equality
+///
+/// UUIDs are equal only when they are byte-for-byte identical
+impl Eq for Uuid {
+ fn eq(&self, other: &Uuid) -> bool {
+ self.bytes == other.bytes
+ }
+}
+
+/// Test two UUIDs for equality
+///
+/// UUIDs are equal only when they are byte-for-byte identical
+impl TotalEq for Uuid {
+ fn equals(&self, other: &Uuid) -> bool {
+ self.bytes == other.bytes
+ }
+}
+
+/// Generates a random instance of UUID (V4 conformant)
+impl rand::Rand for Uuid {
+ #[inline]
+ fn rand<R: rand::Rng>(rng: &mut R) -> Uuid {
+ let ub = rng.gen_bytes(16);
+ let mut uuid = Uuid{ bytes: [0, .. 16] };
+ vec::bytes::copy_memory(uuid.bytes, ub, 16);
+ uuid.set_variant(VariantRFC4122);
+ uuid.set_version(Version4Random);
+ uuid
+ }
+}
+
+#[cfg(test)]
+mod test {
+ use super::*;
+ use std::str;
+ use std::rand;
+ use std::num::Zero;
+
+ #[test]
+ fn test_new_nil() {
+ let nil = Uuid::new_nil();
+ let nb = nil.to_bytes();
+
+ assert!(nb.iter().all(|&b| b == 0));
+ }
+
+ #[test]
+ fn test_zero() {
+ let uz: Uuid = Zero::zero();
+ let nz = Uuid::new_v4();
+
+ assert!(uz.is_zero());
+ assert!(! nz.is_zero());
+ }
+
+ #[test]
+ fn test_new() {
+ // Supported
+ let uuid1 = Uuid::new(Version4Random).unwrap();
+ let s = uuid1.to_simple_str();
+
+ assert!(s.len() == 32);
+ assert!(uuid1.get_version().unwrap() == Version4Random);
+
+ // Test unsupported versions
+ assert!(Uuid::new(Version1Mac) == None);
+ assert!(Uuid::new(Version2Dce) == None);
+ assert!(Uuid::new(Version3Md5) == None);
+ assert!(Uuid::new(Version5Sha1) == None);
+ }
+
+ #[test]
+ fn test_new_v4() {
+ let uuid1 = Uuid::new_v4();
+
+ assert!(uuid1.get_version().unwrap() == Version4Random);
+ assert!(uuid1.get_variant().unwrap() == VariantRFC4122);
+ }
+
+ #[test]
+ fn test_get_version() {
+ let uuid1 = Uuid::new_v4();
+
+ assert!(uuid1.get_version().unwrap() == Version4Random);
+ assert!(uuid1.get_version_num() == 4);
+ }
+
+ #[test]
+ fn test_get_variant() {
+ let uuid1 = Uuid::new_v4();
+ let uuid2 = Uuid::parse_string("550e8400-e29b-41d4-a716-446655440000").unwrap();
+ let uuid3 = Uuid::parse_string("67e55044-10b1-426f-9247-bb680e5fe0c8").unwrap();
+ let uuid4 = Uuid::parse_string("936DA01F9ABD4d9dC0C702AF85C822A8").unwrap();
+ let uuid5 = Uuid::parse_string("F9168C5E-CEB2-4faa-D6BF-329BF39FA1E4").unwrap();
+ let uuid6 = Uuid::parse_string("f81d4fae-7dec-11d0-7765-00a0c91e6bf6").unwrap();
+
+ assert!(uuid1.get_variant().unwrap() == VariantRFC4122);
+ assert!(uuid2.get_variant().unwrap() == VariantRFC4122);
+ assert!(uuid3.get_variant().unwrap() == VariantRFC4122);
+ assert!(uuid4.get_variant().unwrap() == VariantMicrosoft);
+ assert!(uuid5.get_variant().unwrap() == VariantMicrosoft);
+ assert!(uuid6.get_variant().unwrap() == VariantNCS);
+ }
+
+ #[test]
+ fn test_parse_uuid_v4() {
+
+ // Invalid
+ assert!(Uuid::parse_string("").is_err());
+ assert!(Uuid::parse_string("!").is_err());
+ assert!(Uuid::parse_string("F9168C5E-CEB2-4faa-B6BF-329BF39FA1E45").is_err());
+ assert!(Uuid::parse_string("F9168C5E-CEB2-4faa-BBF-329BF39FA1E4").is_err());
+ assert!(Uuid::parse_string("F9168C5E-CEB2-4faa-BGBF-329BF39FA1E4").is_err());
+ assert!(Uuid::parse_string("F9168C5E-CEB2-4faa-B6BFF329BF39FA1E4").is_err());
+ assert!(Uuid::parse_string("F9168C5E-CEB2-4faa").is_err());
+ assert!(Uuid::parse_string("F9168C5E-CEB2-4faaXB6BFF329BF39FA1E4").is_err());
+ assert!(Uuid::parse_string("F9168C5E-CEB-24fa-eB6BFF32-BF39FA1E4").is_err());
+ assert!(Uuid::parse_string("01020304-1112-2122-3132-41424344").is_err());
+ assert!(Uuid::parse_string("67e5504410b1426f9247bb680e5fe0c").is_err());
+ assert!(Uuid::parse_string("67e5504410b1426f9247bb680e5fe0c88").is_err());
+ assert!(Uuid::parse_string("67e5504410b1426f9247bb680e5fe0cg8").is_err());
+ assert!(Uuid::parse_string("67e5504410b1426%9247bb680e5fe0c8").is_err());
+
+ // Valid
+ assert!(Uuid::parse_string("00000000000000000000000000000000").is_ok());
+ assert!(Uuid::parse_string("67e55044-10b1-426f-9247-bb680e5fe0c8").is_ok());
+ assert!(Uuid::parse_string("67e55044-10b1-426f-9247-bb680e5fe0c8").is_ok());
+ assert!(Uuid::parse_string("F9168C5E-CEB2-4faa-B6BF-329BF39FA1E4").is_ok());
+ assert!(Uuid::parse_string("67e5504410b1426f9247bb680e5fe0c8").is_ok());
+ assert!(Uuid::parse_string("01020304-1112-2122-3132-414243444546").is_ok());
+ assert!(Uuid::parse_string("urn:uuid:67e55044-10b1-426f-9247-bb680e5fe0c8").is_ok());
+
+ // Nil
+ let nil = Uuid::new_nil();
+ assert!(Uuid::parse_string("00000000000000000000000000000000").unwrap() == nil);
+ assert!(Uuid::parse_string("00000000-0000-0000-0000-000000000000").unwrap() == nil);
+
+ // Round-trip
+ let uuid_orig = Uuid::new_v4();
+ let orig_str = uuid_orig.to_str();
+ let uuid_out = Uuid::parse_string(orig_str).unwrap();
+ assert!(uuid_orig == uuid_out);
+
+ // Test error reporting
+ let e = Uuid::parse_string("67e5504410b1426f9247bb680e5fe0c").unwrap_err();
+ assert!(match(e){ ErrorInvalidLength(n) => n==31, _ => false });
+
+ let e = Uuid::parse_string("67e550X410b1426f9247bb680e5fe0cd").unwrap_err();
+ assert!(match(e){ ErrorInvalidCharacter(c, n) => c=='X' && n==6, _ => false });
+
+ let e = Uuid::parse_string("67e550-4105b1426f9247bb680e5fe0c").unwrap_err();
+ assert!(match(e){ ErrorInvalidGroups(n) => n==2, _ => false });
+
+ let e = Uuid::parse_string("F9168C5E-CEB2-4faa-B6BF1-02BF39FA1E4").unwrap_err();
+ assert!(match(e){ ErrorInvalidGroupLength(g, n, e) => g==3 && n==5 && e==4, _ => false });
+ }
+
+ #[test]
+ fn test_to_simple_str() {
+ let uuid1 = Uuid::new_v4();
+ let s = uuid1.to_simple_str();
+
+ assert!(s.len() == 32);
+ assert!(s.iter().all(|c| c.is_digit_radix(16)));
+ }
+
+ #[test]
+ fn test_to_str() {
+ let uuid1 = Uuid::new_v4();
+ let s = uuid1.to_str();
+
+ assert!(s.len() == 32);
+ assert!(s.iter().all(|c| c.is_digit_radix(16)));
+ }
+
+ #[test]
+ fn test_to_hyphenated_str() {
+ let uuid1 = Uuid::new_v4();
+ let s = uuid1.to_hyphenated_str();
+
+ assert!(s.len() == 36);
+ assert!(s.iter().all(|c| c.is_digit_radix(16) || c == '-'));
+ }
+
+ #[test]
+ fn test_to_urn_str() {
+ let uuid1 = Uuid::new_v4();
+ let ss = uuid1.to_urn_str();
+ let s = ss.slice(9, ss.len());
+
+ assert!(ss.starts_with("urn:uuid:"));
+ assert!(s.len() == 36);
+ assert!(s.iter().all(|c| c.is_digit_radix(16) || c == '-'));
+ }
+
+ #[test]
+ fn test_to_str_matching() {
+ let uuid1 = Uuid::new_v4();
+
+ let hs = uuid1.to_hyphenated_str();
+ let ss = uuid1.to_str();
+
+ let hsn = str::from_chars(hs.iter().filter(|&c| c != '-').collect::<~[char]>());
+
+ assert!(hsn == ss);
+ }
+
+ #[test]
+ fn test_string_roundtrip() {
+ let uuid = Uuid::new_v4();
+
+ let hs = uuid.to_hyphenated_str();
+ let uuid_hs = Uuid::parse_string(hs).unwrap();
+ assert!(uuid_hs == uuid);
+
+ let ss = uuid.to_str();
+ let uuid_ss = Uuid::parse_string(ss).unwrap();
+ assert!(uuid_ss == uuid);
+ }
+
+ #[test]
+ fn test_compare() {
+ let uuid1 = Uuid::new_v4();
+ let uuid2 = Uuid::new_v4();
+
+ assert!(uuid1 == uuid1);
+ assert!(uuid2 == uuid2);
+ assert!(uuid1 != uuid2);
+ assert!(uuid2 != uuid1);
+ }
+
+ #[test]
+ fn test_from_fields() {
+ let d1: u32 = 0xa1a2a3a4;
+ let d2: u16 = 0xb1b2;
+ let d3: u16 = 0xc1c2;
+ let d4: ~[u8] = ~[0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8];
+
+ let u = Uuid::from_fields(d1, d2, d3, d4);
+
+ let expected = ~"a1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8";
+ let result = u.to_simple_str();
+ assert!(result == expected);
+ }
+
+ #[test]
+ fn test_from_bytes() {
+ let b = ~[ 0xa1, 0xa2, 0xa3, 0xa4, 0xb1, 0xb2, 0xc1, 0xc2,
+ 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8 ];
+
+ let u = Uuid::from_bytes(b).unwrap();
+ let expected = ~"a1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8";
+
+ assert!(u.to_simple_str() == expected);
+ }
+
+ #[test]
+ fn test_to_bytes() {
+ let u = Uuid::new_v4();
+ let ub = u.to_bytes();
+
+ assert!(ub.len() == 16);
+ assert!(! ub.iter().all(|&b| b == 0));
+ }
+
+ #[test]
+ fn test_bytes_roundtrip() {
+ let b_in: [u8, ..16] = [ 0xa1, 0xa2, 0xa3, 0xa4, 0xb1, 0xb2, 0xc1, 0xc2,
+ 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8 ];
+
+ let u = Uuid::from_bytes(b_in.clone()).unwrap();
+
+ let b_out = u.to_bytes();
+
+ assert!(b_in == b_out);
+ }
+
+ #[test]
+ fn test_operator_eq() {
+ let u1 = Uuid::new_v4();
+ let u2 = u1.clone();
+ let u3 = Uuid::new_v4();
+
+ assert!(u1 == u1);
+ assert!(u1 == u2);
+ assert!(u2 == u1);
+
+ assert!(u1 != u3);
+ assert!(u3 != u1);
+ assert!(u2 != u3);
+ assert!(u3 != u2);
+ }
+
+ #[test]
+ fn test_rand_rand() {
+ let mut rng = rand::rng();
+ let u: ~Uuid = rand::Rand::rand(&mut rng);
+ let ub = u.to_bytes();
+
+ assert!(ub.len() == 16);
+ assert!(! ub.iter().all(|&b| b == 0));
+ }
+}
+
+#[cfg(test)]
+mod bench {
+ use super::*;
+ use test::BenchHarness;
+
+ #[bench]
+ pub fn create_uuids(bh: &mut BenchHarness) {
+ do bh.iter {
+ Uuid::new_v4();
+ }
+ }
+
+ #[bench]
+ pub fn uuid_to_str(bh: &mut BenchHarness) {
+ let u = Uuid::new_v4();
+ do bh.iter {
+ u.to_str();
+ }
+ }
+
+ #[bench]
+ pub fn parse_str(bh: &mut BenchHarness) {
+ let s = "urn:uuid:F9168C5E-CEB2-4faa-B6BF-329BF39FA1E4";
+ do bh.iter {
+ let u = Uuid::parse_string(s);
+ }
+ }
+}
}
pub fn main() {
+ #[fixed_stack_segment]; #[inline(never)];
+
let os_args = os::args();
if (os_args.len() > 1 && (os_args[1] == ~"-v" || os_args[1] == ~"--version")) {
use std::char;
use std::hash::Streaming;
use std::hash;
+use std::io;
use std::libc::{c_int, c_uint};
use std::os::consts::{macos, freebsd, linux, android, win32};
use std::os;
debug!("output: %s", output.to_str());
let cc_args = link_args(sess, obj_filename, out_filename, lm);
debug!("%s link args: %s", cc_prog, cc_args.connect(" "));
+ if (sess.opts.debugging_opts & session::print_link_args) != 0 {
+ io::println(fmt!("%s link args: %s", cc_prog, cc_args.connect(" ")));
+ }
+
// We run 'cc' here
let prog = run::process_output(cc_prog, cc_args);
if 0 != prog.status {
("scalarrepl", "Scalar Replacement of Aggregates (DT)"),
("scalarrepl-ssa", "Scalar Replacement of Aggregates (SSAUp)"),
("sccp", "Sparse Conditional Constant Propagation"),
- ("simplify-libcalls", "Simplify well-known library calls"),
("simplifycfg", "Simplify the CFG"),
("sink", "Code sinking"),
("strip", "Strip all symbols from a module"),
pub struct Upcalls {
trace: ValueRef,
- call_shim_on_c_stack: ValueRef,
- call_shim_on_rust_stack: ValueRef,
rust_personality: ValueRef,
reset_stack_limit: ValueRef
}
@Upcalls {
trace: upcall!(fn trace(opaque_ptr, opaque_ptr, int_ty) -> Type::void()),
- call_shim_on_c_stack: upcall!(fn call_shim_on_c_stack(opaque_ptr, opaque_ptr) -> int_ty),
- call_shim_on_rust_stack:
- upcall!(fn call_shim_on_rust_stack(opaque_ptr, opaque_ptr) -> int_ty),
rust_personality: upcall!(nothrow fn rust_personality -> Type::i32()),
reset_stack_limit: upcall!(nothrow fn reset_stack_limit -> Type::void())
}
use util::ppaux;
use std::hashmap::{HashMap,HashSet};
-use std::int;
use std::io;
use std::os;
use std::vec;
time(time_passes, ~"loop checking", ||
middle::check_loop::check_crate(ty_cx, crate));
+ time(time_passes, ~"stack checking", ||
+ middle::stack_check::stack_check_crate(ty_cx, crate));
+
let middle::moves::MoveMaps {moves_map, moved_variables_set,
capture_map} =
time(time_passes, ~"compute moves", ||
match node {
pprust::node_item(s, item) => {
pp::space(s.s);
- pprust::synth_comment(s, int::to_str(item.id));
+ pprust::synth_comment(s, item.id.to_str());
}
pprust::node_block(s, ref blk) => {
pp::space(s.s);
pprust::synth_comment(
- s, ~"block " + int::to_str(blk.id));
+ s, ~"block " + blk.id.to_str());
}
pprust::node_expr(s, expr) => {
pp::space(s.s);
- pprust::synth_comment(s, int::to_str(expr.id));
+ pprust::synth_comment(s, expr.id.to_str());
pprust::pclose(s);
}
pprust::node_pat(s, pat) => {
pp::space(s.s);
- pprust::synth_comment(s, ~"pat " + int::to_str(pat.id));
+ pprust::synth_comment(s, ~"pat " + pat.id.to_str());
}
}
}
}
debugging_opts |= this_bit;
}
+
if debugging_opts & session::debug_llvm != 0 {
- unsafe {
- llvm::LLVMSetDebug(1);
+ set_llvm_debug();
+
+ fn set_llvm_debug() {
+ #[fixed_stack_segment]; #[inline(never)];
+ unsafe { llvm::LLVMSetDebug(1); }
}
}
let extra_debuginfo = debugging_opts & session::extra_debug_info != 0;
let debuginfo = debugging_opts & session::debug_info != 0 ||
extra_debuginfo;
+
+ // If debugging info is generated, do not collapse monomorphized function instances.
+ // Functions with equivalent llvm code still need separate debugging descriptions because names
+ // might differ.
+ if debuginfo {
+ debugging_opts |= session::no_monomorphic_collapse;
+ }
+
let statik = debugging_opts & session::statik != 0;
let addl_lib_search_paths = getopts::opt_strs(matches, "L").map(|s| Path(*s));
}
}
+#[cfg(stage0)]
fn mk_test_module(cx: &TestCtxt) -> @ast::item {
// Link to extra
return @item;
}
+#[cfg(not(stage0))]
+fn mk_test_module(cx: &TestCtxt) -> @ast::item {
+
+ // Link to extra
+ let view_items = ~[mk_std(cx)];
+
+ // A constant vector of test descriptors.
+ let tests = mk_tests(cx);
+
+ // The synthesized main function which will call the console test runner
+ // with our list of tests
+ let mainfn = (quote_item!(cx.ext_cx,
+ pub fn main() {
+ #[main];
+ extra::test::test_main_static(::std::os::args(), TESTS);
+ }
+ )).unwrap();
+
+ let testmod = ast::_mod {
+ view_items: view_items,
+ items: ~[mainfn, tests],
+ };
+ let item_ = ast::item_mod(testmod);
+
+ // This attribute tells resolve to let us call unexported functions
+ let resolve_unexported_attr =
+ attr::mk_attr(attr::mk_word_item(@"!resolve_unexported"));
+
+ let item = ast::item {
+ ident: cx.sess.ident_of("__test"),
+ attrs: ~[resolve_unexported_attr],
+ id: cx.sess.next_node_id(),
+ node: item_,
+ vis: ast::public,
+ span: dummy_sp(),
+ };
+
+ debug!("Synthetic test module:\n%s\n",
+ pprust::item_to_str(@item.clone(), cx.sess.intr()));
+
+ return @item;
+}
fn nospan<T>(t: T) -> codemap::spanned<T> {
codemap::spanned { node: t, span: dummy_sp() }
types: ~[] }
}
+#[cfg(stage0)]
fn mk_tests(cx: &TestCtxt) -> @ast::item {
let ext_cx = cx.ext_cx;
;
)).unwrap()
}
+#[cfg(not(stage0))]
+fn mk_tests(cx: &TestCtxt) -> @ast::item {
+ // The vector of test_descs for this crate
+ let test_descs = mk_test_descs(cx);
+
+ (quote_item!(cx.ext_cx,
+ pub static TESTS : &'static [self::extra::test::TestDescAndFn] =
+ $test_descs
+ ;
+ )).unwrap()
+}
fn is_extra(cx: &TestCtxt) -> bool {
let items = attr::find_linkage_metas(cx.crate.attrs);
}
}
+#[cfg(stage0)]
fn mk_test_desc_and_fn_rec(cx: &TestCtxt, test: &Test) -> @ast::expr {
let span = test.span;
let path = test.path.clone();
);
e
}
+#[cfg(not(stage0))]
+fn mk_test_desc_and_fn_rec(cx: &TestCtxt, test: &Test) -> @ast::expr {
+ let span = test.span;
+ let path = test.path.clone();
+
+ debug!("encoding %s", ast_util::path_name_i(path));
+
+ let name_lit: ast::lit =
+ nospan(ast::lit_str(ast_util::path_name_i(path).to_managed()));
+
+ let name_expr = @ast::expr {
+ id: cx.sess.next_node_id(),
+ node: ast::expr_lit(@name_lit),
+ span: span
+ };
+
+ let fn_path = path_node_global(path);
+
+ let fn_expr = @ast::expr {
+ id: cx.sess.next_node_id(),
+ node: ast::expr_path(fn_path),
+ span: span,
+ };
+
+ let t_expr = if test.bench {
+ quote_expr!(cx.ext_cx, self::extra::test::StaticBenchFn($fn_expr) )
+ } else {
+ quote_expr!(cx.ext_cx, self::extra::test::StaticTestFn($fn_expr) )
+ };
+
+ let ignore_expr = if test.ignore {
+ quote_expr!(cx.ext_cx, true )
+ } else {
+ quote_expr!(cx.ext_cx, false )
+ };
+
+ let fail_expr = if test.should_fail {
+ quote_expr!(cx.ext_cx, true )
+ } else {
+ quote_expr!(cx.ext_cx, false )
+ };
+
+ let e = quote_expr!(cx.ext_cx,
+ self::extra::test::TestDescAndFn {
+ desc: self::extra::test::TestDesc {
+ name: self::extra::test::StaticTestName($name_expr),
+ ignore: $ignore_expr,
+ should_fail: $fail_expr
+ },
+ testfn: $t_expr,
+ }
+ );
+ e
+}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// LLVM wrappers are intended to be called from trans,
+// which already runs in a #[fixed_stack_segment]
+#[allow(cstack)];
+
use std::c_str::ToCStr;
use std::hashmap::HashMap;
use std::libc::{c_uint, c_ushort};
ReturnsTwiceAttribute = 1 << 29,
UWTableAttribute = 1 << 30,
NonLazyBindAttribute = 1 << 31,
-
- // Not added to LLVM yet, so may need to stay updated if LLVM changes.
- // FIXME(#8199): if this changes, be sure to change the relevant constant
- // down below
- // FixedStackSegment = 1 << 41,
}
// enum for the LLVM IntPredicate type
#[fast_ffi]
pub fn LLVMSetGC(Fn: ValueRef, Name: *c_char);
#[fast_ffi]
- pub fn LLVMAddFunctionAttr(Fn: ValueRef, PA: c_uint, HighPA: c_uint);
+ pub fn LLVMAddFunctionAttr(Fn: ValueRef, PA: c_uint);
+ #[fast_ffi]
+ pub fn LLVMAddFunctionAttrString(Fn: ValueRef, Name: *c_char);
#[fast_ffi]
pub fn LLVMGetFunctionAttr(Fn: ValueRef) -> c_ulonglong;
#[fast_ffi]
#[fast_ffi]
pub fn LLVMSetUnnamedAddr(GlobalVar: ValueRef, UnnamedAddr: Bool);
+
+ #[fast_ffi]
+ pub fn LLVMDIBuilderCreateTemplateTypeParameter(Builder: DIBuilderRef,
+ Scope: ValueRef,
+ Name: *c_char,
+ Ty: ValueRef,
+ File: ValueRef,
+ LineNo: c_uint,
+ ColumnNo: c_uint)
+ -> ValueRef;
}
}
pub fn SetFunctionAttribute(Fn: ValueRef, attr: Attribute) {
unsafe {
- let attr = attr as u64;
- let lower = attr & 0xffffffff;
- let upper = (attr >> 32) & 0xffffffff;
- llvm::LLVMAddFunctionAttr(Fn, lower as c_uint, upper as c_uint);
- }
-}
-
-// FIXME(#8199): this shouldn't require this hackery. On i686
-// (FixedStackSegment as u64) will return 0 instead of 1 << 41.
-// Furthermore, if we use a match of any sort then an LLVM
-// assertion is generated!
-pub fn SetFixedStackSegmentAttribute(Fn: ValueRef) {
- unsafe {
- let attr = 1u64 << 41;
- let lower = attr & 0xffffffff;
- let upper = (attr >> 32) & 0xffffffff;
- llvm::LLVMAddFunctionAttr(Fn, lower as c_uint, upper as c_uint);
+ llvm::LLVMAddFunctionAttr(Fn, attr as c_uint)
}
}
/* Memory-managed object interface to type handles. */
self.type_to_str_depth(ty, 30)
}
+ pub fn types_to_str(&self, tys: &[Type]) -> ~str {
+ let strs = tys.map(|t| self.type_to_str(*t));
+ fmt!("[%s]", strs.connect(","))
+ }
+
pub fn val_to_str(&self, val: ValueRef) -> ~str {
unsafe {
let ty = Type::from_ref(llvm::LLVMTypeOf(val));
let tp_defs = item_ty_param_defs(item_doc, tcx, cdata,
tag_items_data_item_ty_param_bounds);
let rp = item_ty_region_param(item_doc);
+ let mut bounds = ty::EmptyBuiltinBounds();
+ // Collect the builtin bounds from the encoded supertraits.
+ // FIXME(#8559): They should be encoded directly.
+ do reader::tagged_docs(item_doc, tag_item_super_trait_ref) |trait_doc| {
+ // NB. Bypasses real supertraits. See get_supertraits() if you wanted them.
+ let trait_ref = doc_trait_ref(trait_doc, tcx, cdata);
+ do tcx.lang_items.to_builtin_kind(trait_ref.def_id).map_move |bound| {
+ bounds.add(bound);
+ };
+ true
+ };
ty::TraitDef {
generics: ty::Generics {type_param_defs: tp_defs,
region_param: rp},
+ bounds: bounds,
trait_ref: @item_trait_ref(item_doc, tcx, cdata)
}
}
let mut results = ~[];
let item_doc = lookup_item(id, cdata.data);
do reader::tagged_docs(item_doc, tag_item_super_trait_ref) |trait_doc| {
- results.push(@doc_trait_ref(trait_doc, tcx, cdata));
+ // NB. Only reads the ones that *aren't* builtin-bounds. See also
+ // get_trait_def() for collecting the builtin bounds.
+ // FIXME(#8559): The builtin bounds shouldn't be encoded in the first place.
+ let trait_ref = doc_trait_ref(trait_doc, tcx, cdata);
+ if tcx.lang_items.to_builtin_kind(trait_ref.def_id).is_none() {
+ results.push(@trait_ref);
+ }
true
};
return results;
use std::hashmap::{HashMap, HashSet};
use std::io;
use std::str;
-use std::uint;
use std::vec;
use extra::flate;
use extra::serialize::Encodable;
ebml_w.end_tag();
}
-fn encode_discriminant(ecx: &EncodeContext,
- ebml_w: &mut writer::Encoder,
- id: NodeId) {
- ebml_w.start_tag(tag_items_data_item_symbol);
- ebml_w.writer.write(ecx.discrim_symbols.get_copy(&id).as_bytes());
- ebml_w.end_tag();
-}
-
fn encode_disr_val(_: &EncodeContext,
ebml_w: &mut writer::Encoder,
disr_val: uint) {
ebml_w.start_tag(tag_disr_val);
- let s = uint::to_str(disr_val);
+ let s = disr_val.to_str();
ebml_w.writer.write(s.as_bytes());
ebml_w.end_tag();
}
}
ast::tuple_variant_kind(_) | ast::struct_variant_kind(_) => {}
}
- encode_discriminant(ecx, ebml_w, variant.node.id);
if vi[i].disr_val != disr_val {
encode_disr_val(ecx, ebml_w, vi[i].disr_val);
disr_val = vi[i].disr_val;
ebml_w.end_tag();
}
encode_path(ecx, ebml_w, path, ast_map::path_name(item.ident));
+ // FIXME(#8559): This should use the tcx's supertrait cache instead of
+ // reading the AST's list, because the former has already filtered out
+ // the builtin-kinds-as-supertraits. See corresponding fixme in decoder.
for ast_trait_ref in super_traits.iter() {
let trait_ref = ty::node_id_to_trait_ref(ecx.tcx, ast_trait_ref.ref_id);
encode_trait_ref(ebml_w, ecx, trait_ref, tag_item_super_trait_ref);
use std::hashmap::HashMap;
use std::io::WriterUtil;
use std::io;
-use std::uint;
use syntax::abi::AbiSet;
use syntax::ast;
use syntax::ast::*;
w.write_char('p');
w.write_str((cx.ds)(did));
w.write_char('|');
- w.write_str(uint::to_str(id));
+ w.write_str(id.to_str());
}
ty::ty_self(did) => {
w.write_char('s');
}
)
}
- typeck::method_trait(did, m) => {
- typeck::method_trait(did.tr(xcx), m)
+ typeck::method_object(ref mo) => {
+ typeck::method_object(
+ typeck::method_object {
+ trait_id: mo.trait_id.tr(xcx),
+ .. *mo
+ }
+ )
}
}
}
#[test]
fn test_basic() {
- let ext_cx = mk_ctxt();
- roundtrip(quote_item!(
+ let cx = mk_ctxt();
+ roundtrip(quote_item!(cx,
fn foo() {}
));
}
#[test]
fn test_smalltalk() {
- let ext_cx = mk_ctxt();
- roundtrip(quote_item!(
+ let cx = mk_ctxt();
+ roundtrip(quote_item!(cx,
fn foo() -> int { 3 + 4 } // first smalltalk program ever executed.
));
}
#[test]
fn test_more() {
- let ext_cx = mk_ctxt();
- roundtrip(quote_item!(
+ let cx = mk_ctxt();
+ roundtrip(quote_item!(cx,
fn foo(x: uint, y: uint) -> uint {
let z = x + y;
return z;
#[test]
fn test_simplification() {
- let ext_cx = mk_ctxt();
- let item_in = ast::ii_item(quote_item!(
+ let cx = mk_ctxt();
+ let item_in = ast::ii_item(quote_item!(cx,
fn new_int_alist<B>() -> alist<int, B> {
fn eq_int(a: int, b: int) -> bool { a == b }
return alist {eq_fn: eq_int, data: ~[]};
}
).unwrap());
let item_out = simplify_ast(&item_in);
- let item_exp = ast::ii_item(quote_item!(
+ let item_exp = ast::ii_item(quote_item!(cx,
fn new_int_alist<B>() -> alist<int, B> {
return alist {eq_fn: eq_int, data: ~[]};
}
use syntax::ast;
use syntax::ast_util;
use syntax::codemap::span;
-use syntax::oldvisit;
+use syntax::visit;
+use syntax::visit::Visitor;
use util::ppaux::Repr;
#[deriving(Clone)]
reported: @mut HashSet<ast::NodeId>,
}
+struct CheckLoanVisitor;
+
+impl<'self> Visitor<CheckLoanCtxt<'self>> for CheckLoanVisitor {
+ fn visit_expr<'a>(&mut self, ex:@ast::expr, e:CheckLoanCtxt<'a>) {
+ check_loans_in_expr(self, ex, e);
+ }
+ fn visit_local(&mut self, l:@ast::Local, e:CheckLoanCtxt) {
+ check_loans_in_local(self, l, e);
+ }
+ fn visit_block(&mut self, b:&ast::Block, e:CheckLoanCtxt) {
+ check_loans_in_block(self, b, e);
+ }
+ fn visit_pat(&mut self, p:@ast::pat, e:CheckLoanCtxt) {
+ check_loans_in_pat(self, p, e);
+ }
+ fn visit_fn(&mut self, fk:&visit::fn_kind, fd:&ast::fn_decl,
+ b:&ast::Block, s:span, n:ast::NodeId, e:CheckLoanCtxt) {
+ check_loans_in_fn(self, fk, fd, b, s, n, e);
+ }
+}
+
pub fn check_loans(bccx: @BorrowckCtxt,
dfcx_loans: &LoanDataFlow,
move_data: move_data::FlowedMoveData,
reported: @mut HashSet::new(),
};
- let vt = oldvisit::mk_vt(@oldvisit::Visitor {
- visit_expr: check_loans_in_expr,
- visit_local: check_loans_in_local,
- visit_block: check_loans_in_block,
- visit_pat: check_loans_in_pat,
- visit_fn: check_loans_in_fn,
- .. *oldvisit::default_visitor()
- });
- (vt.visit_block)(body, (clcx, vt));
+ let mut vt = CheckLoanVisitor;
+ vt.visit_block(body, clcx);
}
enum MoveError {
}
}
-fn check_loans_in_fn<'a>(fk: &oldvisit::fn_kind,
+fn check_loans_in_fn<'a>(visitor: &mut CheckLoanVisitor,
+ fk: &visit::fn_kind,
decl: &ast::fn_decl,
body: &ast::Block,
sp: span,
id: ast::NodeId,
- (this, visitor): (CheckLoanCtxt<'a>,
- oldvisit::vt<CheckLoanCtxt<'a>>)) {
+ this: CheckLoanCtxt<'a>) {
match *fk {
- oldvisit::fk_item_fn(*) |
- oldvisit::fk_method(*) => {
+ visit::fk_item_fn(*) |
+ visit::fk_method(*) => {
// Don't process nested items.
return;
}
- oldvisit::fk_anon(*) |
- oldvisit::fk_fn_block(*) => {
+ visit::fk_anon(*) |
+ visit::fk_fn_block(*) => {
check_captured_variables(this, id, sp);
}
}
- oldvisit::visit_fn(fk, decl, body, sp, id, (this, visitor));
+ visit::walk_fn(visitor, fk, decl, body, sp, id, this);
fn check_captured_variables(this: CheckLoanCtxt,
closure_id: ast::NodeId,
}
}
-fn check_loans_in_local<'a>(local: @ast::Local,
- (this, vt): (CheckLoanCtxt<'a>,
- oldvisit::vt<CheckLoanCtxt<'a>>)) {
- oldvisit::visit_local(local, (this, vt));
+fn check_loans_in_local<'a>(vt: &mut CheckLoanVisitor,
+ local: @ast::Local,
+ this: CheckLoanCtxt<'a>) {
+ visit::walk_local(vt, local, this);
}
-fn check_loans_in_expr<'a>(expr: @ast::expr,
- (this, vt): (CheckLoanCtxt<'a>,
- oldvisit::vt<CheckLoanCtxt<'a>>)) {
- oldvisit::visit_expr(expr, (this, vt));
+fn check_loans_in_expr<'a>(vt: &mut CheckLoanVisitor,
+ expr: @ast::expr,
+ this: CheckLoanCtxt<'a>) {
+ visit::walk_expr(vt, expr, this);
debug!("check_loans_in_expr(expr=%s)",
expr.repr(this.tcx()));
}
}
-fn check_loans_in_pat<'a>(pat: @ast::pat,
- (this, vt): (CheckLoanCtxt<'a>,
- oldvisit::vt<CheckLoanCtxt<'a>>))
+fn check_loans_in_pat<'a>(vt: &mut CheckLoanVisitor,
+ pat: @ast::pat,
+ this: CheckLoanCtxt<'a>)
{
this.check_for_conflicting_loans(pat.id);
this.check_move_out_from_id(pat.id, pat.span);
- oldvisit::visit_pat(pat, (this, vt));
+ visit::walk_pat(vt, pat, this);
}
-fn check_loans_in_block<'a>(blk: &ast::Block,
- (this, vt): (CheckLoanCtxt<'a>,
- oldvisit::vt<CheckLoanCtxt<'a>>))
+fn check_loans_in_block<'a>(vt: &mut CheckLoanVisitor,
+ blk: &ast::Block,
+ this: CheckLoanCtxt<'a>)
{
- oldvisit::visit_block(blk, (this, vt));
+ visit::walk_block(vt, blk, this);
this.check_for_conflicting_loans(blk.id);
}
use syntax::ast::*;
use syntax::codemap;
-use syntax::{oldvisit, ast_util, ast_map};
+use syntax::{ast_util, ast_map};
+use syntax::visit::Visitor;
+use syntax::visit;
+
+struct CheckCrateVisitor {
+ sess: Session,
+ ast_map: ast_map::map,
+ def_map: resolve::DefMap,
+ method_map: typeck::method_map,
+ tcx: ty::ctxt,
+}
+
+impl Visitor<bool> for CheckCrateVisitor {
+ fn visit_item(&mut self, i:@item, env:bool) {
+ check_item(self, self.sess, self.ast_map, self.def_map, i, env);
+ }
+ fn visit_pat(&mut self, p:@pat, env:bool) {
+ check_pat(self, p, env);
+ }
+ fn visit_expr(&mut self, ex:@expr, env:bool) {
+ check_expr(self, self.sess, self.def_map, self.method_map,
+ self.tcx, ex, env);
+ }
+}
pub fn check_crate(sess: Session,
crate: &Crate,
def_map: resolve::DefMap,
method_map: typeck::method_map,
tcx: ty::ctxt) {
- oldvisit::visit_crate(crate, (false, oldvisit::mk_vt(@oldvisit::Visitor {
- visit_item: |a,b| check_item(sess, ast_map, def_map, a, b),
- visit_pat: check_pat,
- visit_expr: |a,b|
- check_expr(sess, def_map, method_map, tcx, a, b),
- .. *oldvisit::default_visitor()
- })));
+ let mut v = CheckCrateVisitor {
+ sess: sess,
+ ast_map: ast_map,
+ def_map: def_map,
+ method_map: method_map,
+ tcx: tcx,
+ };
+ visit::walk_crate(&mut v, crate, false);
sess.abort_if_errors();
}
-pub fn check_item(sess: Session,
+pub fn check_item(v: &mut CheckCrateVisitor,
+ sess: Session,
ast_map: ast_map::map,
def_map: resolve::DefMap,
it: @item,
- (_is_const, v): (bool,
- oldvisit::vt<bool>)) {
+ _is_const: bool) {
match it.node {
item_static(_, _, ex) => {
- (v.visit_expr)(ex, (true, v));
+ v.visit_expr(ex, true);
check_item_recursion(sess, ast_map, def_map, it);
}
item_enum(ref enum_definition, _) => {
for var in (*enum_definition).variants.iter() {
for ex in var.node.disr_expr.iter() {
- (v.visit_expr)(*ex, (true, v));
+ v.visit_expr(*ex, true);
}
}
}
- _ => oldvisit::visit_item(it, (false, v))
+ _ => visit::walk_item(v, it, false)
}
}
-pub fn check_pat(p: @pat, (_is_const, v): (bool, oldvisit::vt<bool>)) {
+pub fn check_pat(v: &mut CheckCrateVisitor, p: @pat, _is_const: bool) {
fn is_str(e: @expr) -> bool {
match e.node {
expr_vstore(
}
match p.node {
// Let through plain ~-string literals here
- pat_lit(a) => if !is_str(a) { (v.visit_expr)(a, (true, v)); },
+ pat_lit(a) => if !is_str(a) { v.visit_expr(a, true); },
pat_range(a, b) => {
- if !is_str(a) { (v.visit_expr)(a, (true, v)); }
- if !is_str(b) { (v.visit_expr)(b, (true, v)); }
+ if !is_str(a) { v.visit_expr(a, true); }
+ if !is_str(b) { v.visit_expr(b, true); }
}
- _ => oldvisit::visit_pat(p, (false, v))
+ _ => visit::walk_pat(v, p, false)
}
}
-pub fn check_expr(sess: Session,
+pub fn check_expr(v: &mut CheckCrateVisitor,
+ sess: Session,
def_map: resolve::DefMap,
method_map: typeck::method_map,
tcx: ty::ctxt,
e: @expr,
- (is_const, v): (bool,
- oldvisit::vt<bool>)) {
+ is_const: bool) {
if is_const {
match e.node {
expr_unary(_, deref, _) => { }
}
}
}
- expr_paren(e) => { check_expr(sess, def_map, method_map,
- tcx, e, (is_const, v)); }
+ expr_paren(e) => { check_expr(v, sess, def_map, method_map,
+ tcx, e, is_const); }
expr_vstore(_, expr_vstore_slice) |
expr_vec(_, m_imm) |
expr_addr_of(m_imm, _) |
}
_ => ()
}
- oldvisit::visit_expr(e, (is_const, v));
+ visit::walk_expr(v, e, is_const);
}
#[deriving(Clone)]
idstack: @mut ~[NodeId]
}
+struct CheckItemRecursionVisitor;
+
// Make sure a const item doesn't recursively refer to itself
// FIXME: Should use the dependency graph when it's available (#1356)
pub fn check_item_recursion(sess: Session,
idstack: @mut ~[]
};
- let visitor = oldvisit::mk_vt(@oldvisit::Visitor {
- visit_item: visit_item,
- visit_expr: visit_expr,
- .. *oldvisit::default_visitor()
- });
- (visitor.visit_item)(it, (env, visitor));
+ let mut visitor = CheckItemRecursionVisitor;
+ visitor.visit_item(it, env);
+}
- fn visit_item(it: @item, (env, v): (env, oldvisit::vt<env>)) {
+impl Visitor<env> for CheckItemRecursionVisitor {
+ fn visit_item(&mut self, it: @item, env: env) {
if env.idstack.iter().any(|x| x == &(it.id)) {
env.sess.span_fatal(env.root_it.span, "recursive constant");
}
env.idstack.push(it.id);
- oldvisit::visit_item(it, (env, v));
+ visit::walk_item(self, it, env);
env.idstack.pop();
}
- fn visit_expr(e: @expr, (env, v): (env, oldvisit::vt<env>)) {
+ fn visit_expr(&mut self, e: @expr, env: env) {
match e.node {
expr_path(*) => match env.def_map.find(&e.id) {
Some(&def_static(def_id, _)) if ast_util::is_local(def_id) =>
match env.ast_map.get_copy(&def_id.node) {
ast_map::node_item(it, _) => {
- (v.visit_item)(it, (env, v));
+ self.visit_item(it, env);
}
_ => fail!("const not bound to an item")
},
},
_ => ()
}
- oldvisit::visit_expr(e, (env, v));
+ visit::walk_expr(self, e, env);
}
}
use middle::ty;
use syntax::ast::*;
-use syntax::oldvisit;
+use syntax::visit;
+use syntax::visit::Visitor;
#[deriving(Clone)]
pub struct Context {
can_ret: bool
}
+struct CheckLoopVisitor {
+ tcx: ty::ctxt,
+}
+
pub fn check_crate(tcx: ty::ctxt, crate: &Crate) {
- oldvisit::visit_crate(crate,
- (Context { in_loop: false, can_ret: true },
- oldvisit::mk_vt(@oldvisit::Visitor {
- visit_item: |i, (_cx, v)| {
- oldvisit::visit_item(i, (Context {
+ visit::walk_crate(&mut CheckLoopVisitor { tcx: tcx },
+ crate,
+ Context { in_loop: false, can_ret: true });
+}
+
+impl Visitor<Context> for CheckLoopVisitor {
+ fn visit_item(&mut self, i:@item, _cx:Context) {
+ visit::walk_item(self, i, Context {
in_loop: false,
can_ret: true
- }, v));
- },
- visit_expr: |e: @expr, (cx, v): (Context, oldvisit::vt<Context>)| {
+ });
+ }
+
+ fn visit_expr(&mut self, e:@expr, cx:Context) {
+
match e.node {
expr_while(e, ref b) => {
- (v.visit_expr)(e, (cx, v));
- (v.visit_block)(b, (Context { in_loop: true,.. cx }, v));
+ self.visit_expr(e, cx);
+ self.visit_block(b, Context { in_loop: true,.. cx });
}
expr_loop(ref b, _) => {
- (v.visit_block)(b, (Context { in_loop: true,.. cx }, v));
+ self.visit_block(b, Context { in_loop: true,.. cx });
}
expr_fn_block(_, ref b) => {
- (v.visit_block)(b, (Context {
- in_loop: false,
- can_ret: false
- }, v));
+ self.visit_block(b, Context { in_loop: false, can_ret: false });
}
expr_break(_) => {
if !cx.in_loop {
- tcx.sess.span_err(e.span, "`break` outside of loop");
+ self.tcx.sess.span_err(e.span, "`break` outside of loop");
}
}
expr_again(_) => {
if !cx.in_loop {
- tcx.sess.span_err(e.span, "`loop` outside of loop");
+ self.tcx.sess.span_err(e.span, "`loop` outside of loop");
}
}
expr_ret(oe) => {
if !cx.can_ret {
- tcx.sess.span_err(e.span, "`return` in block function");
+ self.tcx.sess.span_err(e.span, "`return` in block function");
}
- oldvisit::visit_expr_opt(oe, (cx, v));
+ visit::walk_expr_opt(self, oe, cx);
}
- _ => oldvisit::visit_expr(e, (cx, v))
+ _ => visit::walk_expr(self, e, cx)
}
- },
- .. *oldvisit::default_visitor()
- })));
+
+ }
}
use syntax::ast::*;
use syntax::ast_util::{unguarded_pat, walk_pat};
use syntax::codemap::{span, dummy_sp, spanned};
-use syntax::oldvisit;
+use syntax::visit;
+use syntax::visit::{Visitor,fn_kind};
pub struct MatchCheckCtxt {
tcx: ty::ctxt,
moves_map: moves::MovesMap
}
+struct CheckMatchVisitor {
+ cx: @MatchCheckCtxt
+}
+
+impl Visitor<()> for CheckMatchVisitor {
+ fn visit_expr(&mut self, ex:@expr, e:()) {
+ check_expr(self, self.cx, ex, e);
+ }
+ fn visit_local(&mut self, l:@Local, e:()) {
+ check_local(self, self.cx, l, e);
+ }
+ fn visit_fn(&mut self, fk:&fn_kind, fd:&fn_decl, b:&Block, s:span, n:NodeId, e:()) {
+ check_fn(self, self.cx, fk, fd, b, s, n, e);
+ }
+}
+
pub fn check_crate(tcx: ty::ctxt,
method_map: method_map,
moves_map: moves::MovesMap,
let cx = @MatchCheckCtxt {tcx: tcx,
method_map: method_map,
moves_map: moves_map};
- oldvisit::visit_crate(crate, ((), oldvisit::mk_vt(@oldvisit::Visitor {
- visit_expr: |a,b| check_expr(cx, a, b),
- visit_local: |a,b| check_local(cx, a, b),
- visit_fn: |kind, decl, body, sp, id, (e, v)|
- check_fn(cx, kind, decl, body, sp, id, (e, v)),
- .. *oldvisit::default_visitor::<()>()
- })));
+ let mut v = CheckMatchVisitor { cx: cx };
+
+ visit::walk_crate(&mut v, crate, ());
+
tcx.sess.abort_if_errors();
}
-pub fn check_expr(cx: @MatchCheckCtxt,
+pub fn check_expr(v: &mut CheckMatchVisitor,
+ cx: @MatchCheckCtxt,
ex: @expr,
- (s, v): ((), oldvisit::vt<()>)) {
- oldvisit::visit_expr(ex, (s, v));
+ s: ()) {
+ visit::walk_expr(v, ex, s);
match ex.node {
expr_match(scrut, ref arms) => {
// First, check legality of move bindings.
else { None }
}
-pub fn check_local(cx: &MatchCheckCtxt,
+pub fn check_local(v: &mut CheckMatchVisitor,
+ cx: &MatchCheckCtxt,
loc: @Local,
- (s, v): ((), oldvisit::vt<()>)) {
- oldvisit::visit_local(loc, (s, v));
+ s: ()) {
+ visit::walk_local(v, loc, s);
if is_refutable(cx, loc.pat) {
cx.tcx.sess.span_err(loc.pat.span,
"refutable pattern in local binding");
check_legality_of_move_bindings(cx, false, [ loc.pat ]);
}
-pub fn check_fn(cx: &MatchCheckCtxt,
- kind: &oldvisit::fn_kind,
+pub fn check_fn(v: &mut CheckMatchVisitor,
+ cx: &MatchCheckCtxt,
+ kind: &visit::fn_kind,
decl: &fn_decl,
body: &Block,
sp: span,
id: NodeId,
- (s, v): ((),
- oldvisit::vt<()>)) {
- oldvisit::visit_fn(kind, decl, body, sp, id, (s, v));
+ s: ()) {
+ visit::walk_fn(v, kind, decl, body, sp, id, s);
for input in decl.inputs.iter() {
if is_refutable(cx, input.pat) {
cx.tcx.sess.span_err(input.pat.span,
use middle::ty;
use middle;
-use syntax::{ast, ast_map, ast_util, oldvisit};
+use syntax::{ast, ast_map, ast_util};
+use syntax::visit;
+use syntax::visit::Visitor;
use syntax::ast::*;
use std::float;
}
}
+struct ConstEvalVisitor { tcx: ty::ctxt }
+
+impl Visitor<()> for ConstEvalVisitor {
+ fn visit_expr_post(&mut self, e:@expr, _:()) {
+ classify(e, self.tcx);
+ }
+}
+
pub fn process_crate(crate: &ast::Crate,
tcx: ty::ctxt) {
- let v = oldvisit::mk_simple_visitor(@oldvisit::SimpleVisitor {
- visit_expr_post: |e| { classify(e, tcx); },
- .. *oldvisit::default_simple_visitor()
- });
- oldvisit::visit_crate(crate, ((), v));
+ let mut v = ConstEvalVisitor { tcx: tcx };
+ visit::walk_crate(&mut v, crate, ());
tcx.sess.abort_if_errors();
}
use syntax::ast::{expr_unary, unsafe_fn, expr_path};
use syntax::ast;
use syntax::codemap::span;
-use syntax::oldvisit::{fk_item_fn, fk_method};
-use syntax::oldvisit;
+use syntax::visit::{fk_item_fn, fk_method};
+use syntax::visit;
+use syntax::visit::{Visitor,fn_kind};
+use syntax::ast::{fn_decl,Block,NodeId,expr};
#[deriving(Eq)]
enum UnsafeContext {
}
}
-pub fn check_crate(tcx: ty::ctxt,
- method_map: method_map,
- crate: &ast::Crate) {
- let context = @mut Context {
- method_map: method_map,
- unsafe_context: SafeContext,
- };
+struct EffectCheckVisitor {
+ tcx: ty::ctxt,
+ context: @mut Context,
+}
- let require_unsafe: @fn(span: span,
- description: &str) = |span, description| {
- match context.unsafe_context {
+impl EffectCheckVisitor {
+ fn require_unsafe(&mut self, span: span, description: &str) {
+ match self.context.unsafe_context {
SafeContext => {
// Report an error.
- tcx.sess.span_err(span,
+ self.tcx.sess.span_err(span,
fmt!("%s requires unsafe function or block",
description))
}
UnsafeBlock(block_id) => {
// OK, but record this.
debug!("effect: recording unsafe block as used: %?", block_id);
- let _ = tcx.used_unsafe.insert(block_id);
+ let _ = self.tcx.used_unsafe.insert(block_id);
}
UnsafeFn => {}
}
- };
+ }
+}
+
+impl Visitor<()> for EffectCheckVisitor {
+ fn visit_fn(&mut self, fn_kind:&fn_kind, fn_decl:&fn_decl,
+ block:&Block, span:span, node_id:NodeId, _:()) {
- let visitor = oldvisit::mk_vt(@oldvisit::Visitor {
- visit_fn: |fn_kind, fn_decl, block, span, node_id, (_, visitor)| {
let (is_item_fn, is_unsafe_fn) = match *fn_kind {
fk_item_fn(_, _, purity, _) => (true, purity == unsafe_fn),
fk_method(_, _, method) => (true, method.purity == unsafe_fn),
_ => (false, false),
};
- let old_unsafe_context = context.unsafe_context;
+ let old_unsafe_context = self.context.unsafe_context;
if is_unsafe_fn {
- context.unsafe_context = UnsafeFn
+ self.context.unsafe_context = UnsafeFn
} else if is_item_fn {
- context.unsafe_context = SafeContext
+ self.context.unsafe_context = SafeContext
}
- oldvisit::visit_fn(fn_kind,
+ visit::walk_fn(self,
+ fn_kind,
fn_decl,
block,
span,
node_id,
- ((),
- visitor));
+ ());
+
+ self.context.unsafe_context = old_unsafe_context
+ }
- context.unsafe_context = old_unsafe_context
- },
+ fn visit_block(&mut self, block:&Block, _:()) {
- visit_block: |block, (_, visitor)| {
- let old_unsafe_context = context.unsafe_context;
+ let old_unsafe_context = self.context.unsafe_context;
if block.rules == ast::UnsafeBlock &&
- context.unsafe_context == SafeContext {
- context.unsafe_context = UnsafeBlock(block.id)
+ self.context.unsafe_context == SafeContext {
+ self.context.unsafe_context = UnsafeBlock(block.id)
}
- oldvisit::visit_block(block, ((), visitor));
+ visit::walk_block(self, block, ());
- context.unsafe_context = old_unsafe_context
- },
+ self.context.unsafe_context = old_unsafe_context
+ }
+
+ fn visit_expr(&mut self, expr:@expr, _:()) {
- visit_expr: |expr, (_, visitor)| {
match expr.node {
expr_method_call(callee_id, _, _, _, _, _) => {
- let base_type = ty::node_id_to_type(tcx, callee_id);
+ let base_type = ty::node_id_to_type(self.tcx, callee_id);
debug!("effect: method call case, base type is %s",
- ppaux::ty_to_str(tcx, base_type));
+ ppaux::ty_to_str(self.tcx, base_type));
if type_is_unsafe_function(base_type) {
- require_unsafe(expr.span,
+ self.require_unsafe(expr.span,
"invocation of unsafe method")
}
}
expr_call(base, _, _) => {
- let base_type = ty::node_id_to_type(tcx, base.id);
+ let base_type = ty::node_id_to_type(self.tcx, base.id);
debug!("effect: call case, base type is %s",
- ppaux::ty_to_str(tcx, base_type));
+ ppaux::ty_to_str(self.tcx, base_type));
if type_is_unsafe_function(base_type) {
- require_unsafe(expr.span, "call to unsafe function")
+ self.require_unsafe(expr.span, "call to unsafe function")
}
}
expr_unary(_, deref, base) => {
- let base_type = ty::node_id_to_type(tcx, base.id);
+ let base_type = ty::node_id_to_type(self.tcx, base.id);
debug!("effect: unary case, base type is %s",
- ppaux::ty_to_str(tcx, base_type));
+ ppaux::ty_to_str(self.tcx, base_type));
match ty::get(base_type).sty {
ty_ptr(_) => {
- require_unsafe(expr.span,
+ self.require_unsafe(expr.span,
"dereference of unsafe pointer")
}
_ => {}
}
}
expr_inline_asm(*) => {
- require_unsafe(expr.span, "use of inline assembly")
+ self.require_unsafe(expr.span, "use of inline assembly")
}
expr_path(*) => {
- match ty::resolve_expr(tcx, expr) {
+ match ty::resolve_expr(self.tcx, expr) {
ast::def_static(_, true) => {
- require_unsafe(expr.span, "use of mutable static")
+ self.require_unsafe(expr.span, "use of mutable static")
}
_ => {}
}
_ => {}
}
- oldvisit::visit_expr(expr, ((), visitor))
- },
+ visit::walk_expr(self, expr, ());
+ }
+}
- .. *oldvisit::default_visitor()
- });
+pub fn check_crate(tcx: ty::ctxt,
+ method_map: method_map,
+ crate: &ast::Crate) {
+ let context = @mut Context {
+ method_map: method_map,
+ unsafe_context: SafeContext,
+ };
+
+ let mut visitor = EffectCheckVisitor {
+ tcx: tcx,
+ context: context,
+ };
- oldvisit::visit_crate(crate, ((), visitor))
+ visit::walk_crate(&mut visitor, crate, ());
}
use syntax::ast_map;
use syntax::attr;
use syntax::codemap::span;
-use syntax::oldvisit::{default_visitor, mk_vt, vt, Visitor, visit_crate};
-use syntax::oldvisit::{visit_item};
use syntax::parse::token::special_idents;
+use syntax::visit;
+use syntax::visit::Visitor;
use std::util;
struct EntryContext {
non_main_fns: ~[(NodeId, span)],
}
-type EntryVisitor = vt<@mut EntryContext>;
+struct EntryVisitor;
+
+impl Visitor<@mut EntryContext> for EntryVisitor {
+ fn visit_item(&mut self, item:@item, ctxt:@mut EntryContext) {
+ find_item(item, ctxt, self);
+ }
+}
pub fn find_entry_point(session: Session, crate: &Crate, ast_map: ast_map::map) {
non_main_fns: ~[],
};
- visit_crate(crate, (ctxt, mk_vt(@Visitor {
- visit_item: |item, (ctxt, visitor)| find_item(item, ctxt, visitor),
- .. *default_visitor()
- })));
+ let mut v = EntryVisitor;
+
+ visit::walk_crate(&mut v, crate, ctxt);
configure_main(ctxt);
}
-fn find_item(item: @item, ctxt: @mut EntryContext, visitor: EntryVisitor) {
+fn find_item(item: @item, ctxt: @mut EntryContext, visitor: &mut EntryVisitor) {
match item.node {
item_fn(*) => {
if item.ident == special_idents::main {
_ => ()
}
- visit_item(item, (ctxt, visitor));
+ visit::walk_item(visitor, item, ctxt);
}
fn configure_main(ctxt: @mut EntryContext) {
use std::hashmap::HashMap;
use syntax::codemap::span;
-use syntax::{ast, ast_util, oldvisit};
+use syntax::{ast, ast_util};
+use syntax::visit;
+use syntax::visit::Visitor;
+use syntax::ast::{item};
// A vector of defs representing the free variables referred to in a function.
// (The def_upvar will already have been stripped).
pub type freevar_info = @~[@freevar_entry];
pub type freevar_map = @mut HashMap<ast::NodeId, freevar_info>;
-// Searches through part of the AST for all references to locals or
-// upvars in this frame and returns the list of definition IDs thus found.
-// Since we want to be able to collect upvars in some arbitrary piece
-// of the AST, we take a walker function that we invoke with a visitor
-// in order to start the search.
-fn collect_freevars(def_map: resolve::DefMap, blk: &ast::Block)
- -> freevar_info {
- let seen = @mut HashMap::new();
- let refs = @mut ~[];
+struct CollectFreevarsVisitor {
+ seen: @mut HashMap<ast::NodeId, ()>,
+ refs: @mut ~[@freevar_entry],
+ def_map: resolve::DefMap,
+}
+
+impl Visitor<int> for CollectFreevarsVisitor {
- fn ignore_item(_i: @ast::item, (_depth, _v): (int, oldvisit::vt<int>)) { }
+ fn visit_item(&mut self, _:@item, _:int) {
+ // ignore_item
+ }
+
+ fn visit_expr(&mut self, expr:@ast::expr, depth:int) {
- let walk_expr: @fn(expr: @ast::expr, (int, oldvisit::vt<int>)) =
- |expr, (depth, v)| {
match expr.node {
ast::expr_fn_block(*) => {
- oldvisit::visit_expr(expr, (depth + 1, v))
+ visit::walk_expr(self, expr, depth + 1)
}
ast::expr_path(*) | ast::expr_self => {
let mut i = 0;
- match def_map.find(&expr.id) {
+ match self.def_map.find(&expr.id) {
None => fail!("path not found"),
Some(&df) => {
let mut def = df;
}
if i == depth { // Made it to end of loop
let dnum = ast_util::def_id_of_def(def).node;
- if !seen.contains_key(&dnum) {
- refs.push(@freevar_entry {
+ if !self.seen.contains_key(&dnum) {
+ self.refs.push(@freevar_entry {
def: def,
span: expr.span,
});
- seen.insert(dnum, ());
+ self.seen.insert(dnum, ());
}
}
}
}
}
- _ => oldvisit::visit_expr(expr, (depth, v))
+ _ => visit::walk_expr(self, expr, depth)
}
- };
+ }
- let v = oldvisit::mk_vt(@oldvisit::Visitor {visit_item: ignore_item,
- visit_expr: walk_expr,
- .. *oldvisit::default_visitor()});
- (v.visit_block)(blk, (1, v));
+
+}
+
+// Searches through part of the AST for all references to locals or
+// upvars in this frame and returns the list of definition IDs thus found.
+// Since we want to be able to collect upvars in some arbitrary piece
+// of the AST, we take a walker function that we invoke with a visitor
+// in order to start the search.
+fn collect_freevars(def_map: resolve::DefMap, blk: &ast::Block)
+ -> freevar_info {
+ let seen = @mut HashMap::new();
+ let refs = @mut ~[];
+
+ let mut v = CollectFreevarsVisitor {
+ seen: seen,
+ refs: refs,
+ def_map: def_map,
+ };
+
+ v.visit_block(blk, 1);
return @(*refs).clone();
}
+struct AnnotateFreevarsVisitor {
+ def_map: resolve::DefMap,
+ freevars: freevar_map,
+}
+
+impl Visitor<()> for AnnotateFreevarsVisitor {
+ fn visit_fn(&mut self, fk:&visit::fn_kind, fd:&ast::fn_decl,
+ blk:&ast::Block, s:span, nid:ast::NodeId, _:()) {
+ let vars = collect_freevars(self.def_map, blk);
+ self.freevars.insert(nid, vars);
+ visit::walk_fn(self, fk, fd, blk, s, nid, ());
+ }
+}
+
// Build a map from every function and for-each body to a set of the
// freevars contained in it. The implementation is not particularly
// efficient as it fully recomputes the free variables at every
freevar_map {
let freevars = @mut HashMap::new();
- let walk_fn: @fn(&oldvisit::fn_kind,
- &ast::fn_decl,
- &ast::Block,
- span,
- ast::NodeId) = |_, _, blk, _, nid| {
- let vars = collect_freevars(def_map, blk);
- freevars.insert(nid, vars);
+ let mut visitor = AnnotateFreevarsVisitor {
+ def_map: def_map,
+ freevars: freevars,
};
-
- let visitor =
- oldvisit::mk_simple_visitor(@oldvisit::SimpleVisitor {
- visit_fn: walk_fn,
- .. *oldvisit::default_simple_visitor()});
- oldvisit::visit_crate(crate, ((), visitor));
+ visit::walk_crate(&mut visitor, crate, ());
return freevars;
}
use syntax::codemap::span;
use syntax::opt_vec;
use syntax::print::pprust::expr_to_str;
-use syntax::{oldvisit, ast_util};
+use syntax::{visit,ast_util};
+use syntax::visit::Visitor;
// Kind analysis pass.
//
// primitives in the stdlib are explicitly annotated to only take sendable
// types.
-pub static try_adding: &'static str = "Try adding a move";
-
#[deriving(Clone)]
pub struct Context {
tcx: ty::ctxt,
current_item: NodeId
}
+struct KindAnalysisVisitor;
+
+impl Visitor<Context> for KindAnalysisVisitor {
+
+ fn visit_expr(&mut self, ex:@expr, e:Context) {
+ check_expr(self, ex, e);
+ }
+
+ fn visit_fn(&mut self, fk:&visit::fn_kind, fd:&fn_decl, b:&Block, s:span, n:NodeId, e:Context) {
+ check_fn(self, fk, fd, b, s, n, e);
+ }
+
+ fn visit_ty(&mut self, t:&Ty, e:Context) {
+ check_ty(self, t, e);
+ }
+ fn visit_item(&mut self, i:@item, e:Context) {
+ check_item(self, i, e);
+ }
+}
+
pub fn check_crate(tcx: ty::ctxt,
method_map: typeck::method_map,
crate: &Crate) {
method_map: method_map,
current_item: -1
};
- let visit = oldvisit::mk_vt(@oldvisit::Visitor {
- visit_expr: check_expr,
- visit_fn: check_fn,
- visit_ty: check_ty,
- visit_item: check_item,
- visit_block: check_block,
- .. *oldvisit::default_visitor()
- });
- oldvisit::visit_crate(crate, (ctx, visit));
+ let mut visit = KindAnalysisVisitor;
+ visit::walk_crate(&mut visit, crate, ctx);
tcx.sess.abort_if_errors();
}
}
}
-fn check_block(block: &Block,
- (cx, visitor): (Context, oldvisit::vt<Context>)) {
- oldvisit::visit_block(block, (cx, visitor));
-}
+fn check_impl_of_trait(cx: Context, it: @item, trait_ref: &trait_ref, self_type: &Ty) {
+ let ast_trait_def = cx.tcx.def_map.find(&trait_ref.ref_id)
+ .expect("trait ref not in def map!");
+ let trait_def_id = ast_util::def_id_of_def(*ast_trait_def);
+ let trait_def = cx.tcx.trait_defs.find(&trait_def_id)
+ .expect("trait def not in trait-defs map!");
+
+ // If this trait has builtin-kind supertraits, meet them.
+ let self_ty: ty::t = ty::node_id_to_type(cx.tcx, it.id);
+ error!("checking impl with self type %?", ty::get(self_ty).sty);
+ do check_builtin_bounds(cx, self_ty, trait_def.bounds) |missing| {
+ cx.tcx.sess.span_err(self_type.span,
+ fmt!("the type `%s', which does not fulfill `%s`, cannot implement this \
+ trait", ty_to_str(cx.tcx, self_ty), missing.user_string(cx.tcx)));
+ cx.tcx.sess.span_note(self_type.span,
+ fmt!("types implementing this trait must fulfill `%s`",
+ trait_def.bounds.user_string(cx.tcx)));
+ }
-fn check_item(item: @item, (cx, visitor): (Context, oldvisit::vt<Context>)) {
// If this is a destructor, check kinds.
+ if cx.tcx.lang_items.drop_trait() == Some(trait_def_id) {
+ match self_type.node {
+ ty_path(_, ref bounds, path_node_id) => {
+ assert!(bounds.is_none());
+ let struct_def = cx.tcx.def_map.get_copy(&path_node_id);
+ let struct_did = ast_util::def_id_of_def(struct_def);
+ check_struct_safe_for_destructor(cx, self_type.span, struct_did);
+ }
+ _ => {
+ cx.tcx.sess.span_bug(self_type.span,
+ "the self type for the Drop trait impl is not a path");
+ }
+ }
+ }
+}
+
+fn check_item(visitor: &mut KindAnalysisVisitor, item: @item, cx: Context) {
if !attr::contains_name(item.attrs, "unsafe_destructor") {
match item.node {
item_impl(_, Some(ref trait_ref), ref self_type, _) => {
- match cx.tcx.def_map.find(&trait_ref.ref_id) {
- None => cx.tcx.sess.bug("trait ref not in def map!"),
- Some(&trait_def) => {
- let trait_def_id = ast_util::def_id_of_def(trait_def);
- if cx.tcx.lang_items.drop_trait() == Some(trait_def_id) {
- // Yes, it's a destructor.
- match self_type.node {
- ty_path(_, ref bounds, path_node_id) => {
- assert!(bounds.is_none());
- let struct_def = cx.tcx.def_map.get_copy(
- &path_node_id);
- let struct_did =
- ast_util::def_id_of_def(struct_def);
- check_struct_safe_for_destructor(
- cx,
- self_type.span,
- struct_did);
- }
- _ => {
- cx.tcx.sess.span_bug(self_type.span,
- "the self type for \
- the Drop trait \
- impl is not a \
- path");
- }
- }
- }
- }
- }
+ check_impl_of_trait(cx, item, trait_ref, self_type);
}
_ => {}
}
}
let cx = Context { current_item: item.id, ..cx };
- oldvisit::visit_item(item, (cx, visitor));
+ visit::walk_item(visitor, item, cx);
}
// Yields the appropriate function to check the kind of closed over
// Check that the free variables used in a shared/sendable closure conform
// to the copy/move kind bounds. Then recursively check the function body.
fn check_fn(
- fk: &oldvisit::fn_kind,
+ v: &mut KindAnalysisVisitor,
+ fk: &visit::fn_kind,
decl: &fn_decl,
body: &Block,
sp: span,
fn_id: NodeId,
- (cx, v): (Context,
- oldvisit::vt<Context>)) {
+ cx: Context) {
// Check kinds on free variables:
do with_appropriate_checker(cx, fn_id) |chk| {
}
}
- oldvisit::visit_fn(fk, decl, body, sp, fn_id, (cx, v));
+ visit::walk_fn(v, fk, decl, body, sp, fn_id, cx);
}
-pub fn check_expr(e: @expr, (cx, v): (Context, oldvisit::vt<Context>)) {
+pub fn check_expr(v: &mut KindAnalysisVisitor, e: @expr, cx: Context) {
debug!("kind::check_expr(%s)", expr_to_str(e, cx.tcx.sess.intr()));
// Handle any kind bounds on type parameters
}
_ => {}
}
- oldvisit::visit_expr(e, (cx, v));
+ visit::walk_expr(v, e, cx);
}
-fn check_ty(aty: &Ty, (cx, v): (Context, oldvisit::vt<Context>)) {
+fn check_ty(v: &mut KindAnalysisVisitor, aty: &Ty, cx: Context) {
match aty.node {
ty_path(_, _, id) => {
let r = cx.tcx.node_type_substs.find(&id);
}
_ => {}
}
- oldvisit::visit_ty(aty, (cx, v));
+ visit::walk_ty(v, aty, cx);
}
// Calls "any_missing" if any bounds were missing.
use driver::session::Session;
use metadata::csearch::each_lang_item;
use metadata::cstore::iter_crate_data;
+use middle::ty::{BuiltinBound, BoundFreeze, BoundSend, BoundSized};
use syntax::ast::{Crate, def_id, MetaItem};
use syntax::ast_util::local_def;
use syntax::attr::AttrMetaMethods;
-use syntax::oldvisit::{default_simple_visitor, mk_simple_visitor};
-use syntax::oldvisit::{SimpleVisitor, visit_crate};
+use syntax::ast::{item};
+use syntax::visit;
+use syntax::visit::Visitor;
use std::hashmap::HashMap;
StrEqFnLangItem, // 19
UniqStrEqFnLangItem, // 20
- AnnihilateFnLangItem, // 21
- LogTypeFnLangItem, // 22
- FailFnLangItem, // 23
- FailBoundsCheckFnLangItem, // 24
- ExchangeMallocFnLangItem, // 25
- ClosureExchangeMallocFnLangItem, // 26
- ExchangeFreeFnLangItem, // 27
- MallocFnLangItem, // 28
- FreeFnLangItem, // 29
- BorrowAsImmFnLangItem, // 30
- BorrowAsMutFnLangItem, // 31
- ReturnToMutFnLangItem, // 32
- CheckNotBorrowedFnLangItem, // 33
- StrDupUniqFnLangItem, // 34
- RecordBorrowFnLangItem, // 35
- UnrecordBorrowFnLangItem, // 36
-
- StartFnLangItem, // 37
-
- TyDescStructLangItem, // 38
- TyVisitorTraitLangItem, // 39
- OpaqueStructLangItem, // 40
+ LogTypeFnLangItem, // 21
+ FailFnLangItem, // 22
+ FailBoundsCheckFnLangItem, // 23
+ ExchangeMallocFnLangItem, // 24
+ ClosureExchangeMallocFnLangItem, // 25
+ ExchangeFreeFnLangItem, // 26
+ MallocFnLangItem, // 27
+ FreeFnLangItem, // 28
+ BorrowAsImmFnLangItem, // 29
+ BorrowAsMutFnLangItem, // 30
+ ReturnToMutFnLangItem, // 31
+ CheckNotBorrowedFnLangItem, // 32
+ StrDupUniqFnLangItem, // 33
+ RecordBorrowFnLangItem, // 34
+ UnrecordBorrowFnLangItem, // 35
+
+ StartFnLangItem, // 36
+
+ TyDescStructLangItem, // 37
+ TyVisitorTraitLangItem, // 38
+ OpaqueStructLangItem, // 39
}
pub struct LanguageItems {
19 => "str_eq",
20 => "uniq_str_eq",
- 21 => "annihilate",
- 22 => "log_type",
- 23 => "fail_",
- 24 => "fail_bounds_check",
- 25 => "exchange_malloc",
- 26 => "closure_exchange_malloc",
- 27 => "exchange_free",
- 28 => "malloc",
- 29 => "free",
- 30 => "borrow_as_imm",
- 31 => "borrow_as_mut",
- 32 => "return_to_mut",
- 33 => "check_not_borrowed",
- 34 => "strdup_uniq",
- 35 => "record_borrow",
- 36 => "unrecord_borrow",
-
- 37 => "start",
-
- 38 => "ty_desc",
- 39 => "ty_visitor",
- 40 => "opaque",
+ 21 => "log_type",
+ 22 => "fail_",
+ 23 => "fail_bounds_check",
+ 24 => "exchange_malloc",
+ 25 => "closure_exchange_malloc",
+ 26 => "exchange_free",
+ 27 => "malloc",
+ 28 => "free",
+ 29 => "borrow_as_imm",
+ 30 => "borrow_as_mut",
+ 31 => "return_to_mut",
+ 32 => "check_not_borrowed",
+ 33 => "strdup_uniq",
+ 34 => "record_borrow",
+ 35 => "unrecord_borrow",
+
+ 36 => "start",
+
+ 37 => "ty_desc",
+ 38 => "ty_visitor",
+ 39 => "opaque",
_ => "???"
}
}
}
+ pub fn to_builtin_kind(&self, id: def_id) -> Option<BuiltinBound> {
+ if Some(id) == self.freeze_trait() {
+ Some(BoundFreeze)
+ } else if Some(id) == self.send_trait() {
+ Some(BoundSend)
+ } else if Some(id) == self.sized_trait() {
+ Some(BoundSized)
+ } else {
+ None
+ }
+ }
+
pub fn freeze_trait(&self) -> Option<def_id> {
self.items[FreezeTraitLangItem as uint]
}
pub fn uniq_str_eq_fn(&self) -> Option<def_id> {
self.items[UniqStrEqFnLangItem as uint]
}
- pub fn annihilate_fn(&self) -> Option<def_id> {
- self.items[AnnihilateFnLangItem as uint]
- }
pub fn log_type_fn(&self) -> Option<def_id> {
self.items[LogTypeFnLangItem as uint]
}
item_refs: HashMap<@str, uint>,
}
+struct LanguageItemVisitor<'self> {
+ this: *mut LanguageItemCollector<'self>,
+}
+
+impl<'self> Visitor<()> for LanguageItemVisitor<'self> {
+
+ fn visit_item(&mut self, item:@item, _:()) {
+
+ for attribute in item.attrs.iter() {
+ unsafe {
+ (*self.this).match_and_collect_meta_item(
+ local_def(item.id),
+ attribute.node.value
+ );
+ }
+ }
+
+ visit::walk_item(self, item, ());
+ }
+}
+
impl<'self> LanguageItemCollector<'self> {
pub fn new<'a>(crate: &'a Crate, session: Session)
-> LanguageItemCollector<'a> {
item_refs.insert(@"str_eq", StrEqFnLangItem as uint);
item_refs.insert(@"uniq_str_eq", UniqStrEqFnLangItem as uint);
- item_refs.insert(@"annihilate", AnnihilateFnLangItem as uint);
item_refs.insert(@"log_type", LogTypeFnLangItem as uint);
item_refs.insert(@"fail_", FailFnLangItem as uint);
item_refs.insert(@"fail_bounds_check",
pub fn collect_local_language_items(&mut self) {
let this: *mut LanguageItemCollector = &mut *self;
- visit_crate(self.crate, ((), mk_simple_visitor(@SimpleVisitor {
- visit_item: |item| {
- for attribute in item.attrs.iter() {
- unsafe {
- (*this).match_and_collect_meta_item(
- local_def(item.id),
- attribute.node.value
- );
- }
- }
- },
- .. *default_simple_visitor()
- })));
+ let mut v = LanguageItemVisitor { this: this };
+ visit::walk_crate(&mut v, self.crate, ());
}
pub fn collect_external_language_items(&mut self) {
use syntax::codemap::span;
use syntax::codemap;
use syntax::parse::token;
-use syntax::{ast, oldvisit, ast_util, visit};
+use syntax::{ast, ast_util, visit};
+use syntax::visit::Visitor;
/**
* A 'lint' check is a kind of miscellaneous constraint that a user _might_
#[deriving(Clone, Eq)]
pub enum lint {
ctypes,
+ cstack,
unused_imports,
unnecessary_qualification,
while_true,
default: warn
}),
+ ("cstack",
+ LintSpec {
+ lint: cstack,
+ desc: "only invoke foreign functions from fixedstacksegment fns",
+ default: deny
+ }),
+
("unused_imports",
LintSpec {
lint: unused_imports,
return map;
}
+trait OuterLint {
+ fn process_item(@mut self, i:@ast::item, e:@mut Context);
+ fn process_fn(@mut self, fk:&visit::fn_kind, fd:&ast::fn_decl,
+ b:&ast::Block, s:span, n:ast::NodeId, e:@mut Context);
+
+ // Returned inner variant will not proceed past subitems.
+ // Supports decomposition of simple lints into subitem-traversing
+ // outer lint visitor and subitem-stopping inner lint visitor.
+ fn inner_variant(@mut self) -> @mut InnerLint;
+}
+
+trait InnerLint {
+ fn descend_item(@mut self, i:&ast::item, e:@mut Context);
+ fn descend_crate(@mut self, crate: &ast::Crate, env: @mut Context);
+ fn descend_fn(@mut self,
+ function_kind: &visit::fn_kind,
+ function_declaration: &ast::fn_decl,
+ function_body: &ast::Block,
+ sp: span,
+ id: ast::NodeId,
+ env: @mut Context);
+}
+
+impl<V:Visitor<@mut Context>> InnerLint for V {
+ fn descend_item(@mut self, i:&ast::item, e:@mut Context) {
+ visit::walk_item(self, i, e);
+ }
+ fn descend_crate(@mut self, crate: &ast::Crate, env: @mut Context) {
+ visit::walk_crate(self, crate, env);
+ }
+ fn descend_fn(@mut self, fk: &visit::fn_kind, fd: &ast::fn_decl, fb: &ast::Block,
+ sp: span, id: ast::NodeId, env: @mut Context) {
+ visit::walk_fn(self, fk, fd, fb, sp, id, env);
+ }
+}
+
enum AnyVisitor {
// This is a pair so every visitor can visit every node. When a lint pass
// is registered, another visitor is created which stops at all items
// first element. This means that when visiting a node, the original
// recursive call can use the original visitor's method, although the
// recursing visitor supplied to the method is the item stopping visitor.
- OldVisitor(oldvisit::vt<@mut Context>, oldvisit::vt<@mut Context>),
+ OldVisitor(@mut OuterLint, @mut InnerLint),
NewVisitor(@mut visit::Visitor<()>),
}
+type VCObj = @mut Visitor<@mut Context>;
+
struct Context {
// All known lint modes (string versions)
dict: @LintDict,
}
}
- fn add_oldvisit_lint(&mut self, v: oldvisit::vt<@mut Context>) {
- self.visitors.push(OldVisitor(v, item_stopping_visitor(v)));
+ fn add_oldvisit_lint(&mut self, v: @mut OuterLint) {
+ self.visitors.push(OldVisitor(v, v.inner_variant()));
}
fn add_lint(&mut self, v: @mut visit::Visitor<()>) {
for visitor in self.visitors.iter() {
match *visitor {
OldVisitor(orig, stopping) => {
- (orig.visit_item)(it, (self, stopping));
+ orig.process_item(it, self);
+ stopping.descend_item(it, self);
}
NewVisitor(new_visitor) => {
- let mut new_visitor = new_visitor;
+ let new_visitor = new_visitor;
new_visitor.visit_item(it, ());
}
}
for visitor in self.visitors.iter() {
match *visitor {
OldVisitor(_, stopping) => {
- oldvisit::visit_crate(c, (self, stopping))
+ stopping.descend_crate(c, self)
}
NewVisitor(new_visitor) => {
let mut new_visitor = new_visitor;
for visitor in self.visitors.iter() {
match *visitor {
OldVisitor(orig, stopping) => {
- let fk = oldvisit::fk_method(m.ident,
- &m.generics,
- m);
- (orig.visit_fn)(&fk,
- &m.decl,
- &m.body,
- m.span,
- m.id,
- (self, stopping));
+ let fk = visit::fk_method(m.ident, &m.generics, m);
+ orig.process_fn(&fk, &m.decl, &m.body, m.span, m.id, self);
+ stopping.descend_fn(&fk, &m.decl, &m.body, m.span, m.id, self);
}
NewVisitor(new_visitor) => {
let fk = visit::fk_method(m.ident,
&m.generics,
m);
- let mut new_visitor = new_visitor;
+ let new_visitor = new_visitor;
new_visitor.visit_fn(&fk,
&m.decl,
&m.body,
true
}
-// Take a visitor, and modify it so that it will not proceed past subitems.
-// This is used to make the simple visitors used for the lint passes
-// not traverse into subitems, since that is handled by the outer
-// lint visitor.
-fn item_stopping_visitor<E>(outer: oldvisit::vt<E>) -> oldvisit::vt<E> {
- oldvisit::mk_vt(@oldvisit::Visitor {
- visit_item: |_i, (_e, _v)| { },
- visit_fn: |fk, fd, b, s, id, (e, v)| {
+trait SubitemStoppableVisitor : Visitor<@mut Context> {
+ fn is_running_on_items(&mut self) -> bool;
+
+ fn visit_item_action(&mut self, _i:@ast::item, _e:@mut Context) {
+ // fill in with particular action without recursion if desired
+ }
+
+ fn visit_fn_action(&mut self, _fk:&visit::fn_kind, _fd:&ast::fn_decl,
+ _b:&ast::Block, _s:span, _n:ast::NodeId, _e:@mut Context) {
+ // fill in with particular action without recursion if desired
+ }
+
+ // The two OVERRIDE methods:
+ //
+ // OVERRIDE_visit_item
+ // OVERRIDE_visit_fn
+ //
+ // *must* be included as initial reimplementations of the standard
+ // default behavior of visit_item and visit_fn for every impl of
+ // Visitor, in order to recreate the effect of having two variant
+ // Outer/Inner behaviors of lint visitors. (See earlier versions
+ // of this module to see what the original encoding was of this
+ // emulated behavior.)
+
+ fn OVERRIDE_visit_item(&mut self, i:@ast::item, e:@mut Context) {
+ if self.is_running_on_items() {
+ self.visit_item_action(i, e);
+ visit::walk_item(self, i, e);
+ }
+ }
+
+ fn OVERRIDE_visit_fn(&mut self, fk:&visit::fn_kind, fd:&ast::fn_decl,
+ b:&ast::Block, s:span, n:ast::NodeId, e:@mut Context) {
+ if self.is_running_on_items() {
+ self.visit_fn_action(fk, fd, b, s, n, e);
+ visit::walk_fn(self, fk, fd, b, s, n, e);
+ } else {
match *fk {
- oldvisit::fk_method(*) => {}
- _ => (outer.visit_fn)(fk, fd, b, s, id, (e, v))
+ visit::fk_method(*) => {}
+ _ => {
+ self.visit_fn_action(fk, fd, b, s, n, e);
+ visit::walk_fn(self, fk, fd, b, s, n, e);
+ }
}
- },
- .. **outer})
+ }
+ }
}
-fn lint_while_true() -> oldvisit::vt<@mut Context> {
- oldvisit::mk_vt(@oldvisit::Visitor {
- visit_expr: |e,
- (cx, vt): (@mut Context, oldvisit::vt<@mut Context>)| {
+struct WhileTrueLintVisitor { stopping_on_items: bool }
+
+
+impl SubitemStoppableVisitor for WhileTrueLintVisitor {
+ fn is_running_on_items(&mut self) -> bool { !self.stopping_on_items }
+}
+
+impl Visitor<@mut Context> for WhileTrueLintVisitor {
+ fn visit_item(&mut self, i:@ast::item, e:@mut Context) {
+ self.OVERRIDE_visit_item(i, e);
+ }
+
+ fn visit_fn(&mut self, fk:&visit::fn_kind, fd:&ast::fn_decl,
+ b:&ast::Block, s:span, n:ast::NodeId, e:@mut Context) {
+ self.OVERRIDE_visit_fn(fk, fd, b, s, n, e);
+ }
+
+ fn visit_expr(&mut self, e:@ast::expr, cx:@mut Context) {
+
match e.node {
ast::expr_while(cond, _) => {
match cond.node {
}
_ => ()
}
- oldvisit::visit_expr(e, (cx, vt));
- },
- .. *oldvisit::default_visitor()
- })
+ visit::walk_expr(self, e, cx);
+ }
}
-fn lint_type_limits() -> oldvisit::vt<@mut Context> {
- fn is_valid<T:cmp::Ord>(binop: ast::binop, v: T,
+macro_rules! outer_lint_boilerplate_impl(
+ ($Visitor:ident) =>
+ (
+ impl OuterLint for $Visitor {
+ fn process_item(@mut self, i:@ast::item, e:@mut Context) {
+ self.visit_item_action(i, e);
+ }
+ fn process_fn(@mut self, fk:&visit::fn_kind, fd:&ast::fn_decl,
+ b:&ast::Block, s:span, n:ast::NodeId, e:@mut Context) {
+ self.visit_fn_action(fk, fd, b, s, n, e);
+ }
+ fn inner_variant(@mut self) -> @mut InnerLint {
+ @mut $Visitor { stopping_on_items: true } as @mut InnerLint
+ }
+ }
+ ))
+
+outer_lint_boilerplate_impl!(WhileTrueLintVisitor)
+
+fn lint_while_true() -> @mut OuterLint {
+ @mut WhileTrueLintVisitor{ stopping_on_items: false } as @mut OuterLint
+}
+
+struct TypeLimitsLintVisitor { stopping_on_items: bool }
+
+impl SubitemStoppableVisitor for TypeLimitsLintVisitor {
+ fn is_running_on_items(&mut self) -> bool { !self.stopping_on_items }
+}
+
+impl TypeLimitsLintVisitor {
+ fn is_valid<T:cmp::Ord>(&mut self, binop: ast::binop, v: T,
min: T, max: T) -> bool {
match binop {
ast::lt => v <= max,
}
}
- fn rev_binop(binop: ast::binop) -> ast::binop {
+ fn rev_binop(&mut self, binop: ast::binop) -> ast::binop {
match binop {
ast::lt => ast::gt,
ast::le => ast::ge,
// for int & uint, be conservative with the warnings, so that the
// warnings are consistent between 32- and 64-bit platforms
- fn int_ty_range(int_ty: ast::int_ty) -> (i64, i64) {
+ fn int_ty_range(&mut self, int_ty: ast::int_ty) -> (i64, i64) {
match int_ty {
ast::ty_i => (i64::min_value, i64::max_value),
ast::ty_char => (u32::min_value as i64, u32::max_value as i64),
}
}
- fn uint_ty_range(uint_ty: ast::uint_ty) -> (u64, u64) {
+ fn uint_ty_range(&mut self, uint_ty: ast::uint_ty) -> (u64, u64) {
match uint_ty {
ast::ty_u => (u64::min_value, u64::max_value),
ast::ty_u8 => (u8::min_value as u64, u8::max_value as u64),
}
}
- fn check_limits(cx: &Context,
+ fn check_limits(&mut self,
+ cx: &Context,
binop: ast::binop,
l: @ast::expr,
r: @ast::expr)
// Normalize the binop so that the literal is always on the RHS in
// the comparison
let norm_binop = if swap {
- rev_binop(binop)
+ self.rev_binop(binop)
} else {
binop
};
match ty::get(ty::expr_ty(cx.tcx, expr)).sty {
ty::ty_int(int_ty) => {
- let (min, max) = int_ty_range(int_ty);
+ let (min, max) = self.int_ty_range(int_ty);
let lit_val: i64 = match lit.node {
ast::expr_lit(@li) => match li.node {
ast::lit_int(v, _) => v,
},
_ => fail!()
};
- is_valid(norm_binop, lit_val, min, max)
+ self.is_valid(norm_binop, lit_val, min, max)
}
ty::ty_uint(uint_ty) => {
- let (min, max): (u64, u64) = uint_ty_range(uint_ty);
+ let (min, max): (u64, u64) = self.uint_ty_range(uint_ty);
let lit_val: u64 = match lit.node {
ast::expr_lit(@li) => match li.node {
ast::lit_int(v, _) => v as u64,
},
_ => fail!()
};
- is_valid(norm_binop, lit_val, min, max)
+ self.is_valid(norm_binop, lit_val, min, max)
}
_ => true
}
}
- fn is_comparison(binop: ast::binop) -> bool {
+ fn is_comparison(&mut self, binop: ast::binop) -> bool {
match binop {
ast::eq | ast::lt | ast::le |
ast::ne | ast::ge | ast::gt => true,
_ => false
}
}
+}
+
+impl Visitor<@mut Context> for TypeLimitsLintVisitor {
+ fn visit_item(&mut self, i:@ast::item, e:@mut Context) {
+ self.OVERRIDE_visit_item(i, e);
+ }
+
+ fn visit_fn(&mut self, fk:&visit::fn_kind, fd:&ast::fn_decl,
+ b:&ast::Block, s:span, n:ast::NodeId, e:@mut Context) {
+ self.OVERRIDE_visit_fn(fk, fd, b, s, n, e);
+ }
+
+ fn visit_expr(&mut self, e:@ast::expr, cx:@mut Context) {
- oldvisit::mk_vt(@oldvisit::Visitor {
- visit_expr: |e,
- (cx, vt): (@mut Context, oldvisit::vt<@mut Context>)| {
match e.node {
ast::expr_binary(_, ref binop, l, r) => {
- if is_comparison(*binop)
- && !check_limits(cx, *binop, l, r) {
+ if self.is_comparison(*binop)
+ && !self.check_limits(cx, *binop, l, r) {
cx.span_lint(type_limits, e.span,
"comparison is useless due to type limits");
}
}
_ => ()
}
- oldvisit::visit_expr(e, (cx, vt));
- },
+ visit::walk_expr(self, e, cx);
+ }
+}
- .. *oldvisit::default_visitor()
- })
+outer_lint_boilerplate_impl!(TypeLimitsLintVisitor)
+
+fn lint_type_limits() -> @mut OuterLint {
+ @mut TypeLimitsLintVisitor{ stopping_on_items: false } as @mut OuterLint
}
fn check_item_ctypes(cx: &Context, it: &ast::item) {
}
}
-fn lint_heap() -> oldvisit::vt<@mut Context> {
- oldvisit::mk_vt(@oldvisit::Visitor {
- visit_expr: |e,
- (cx, vt): (@mut Context, oldvisit::vt<@mut Context>)| {
+struct HeapLintVisitor { stopping_on_items: bool }
+
+impl SubitemStoppableVisitor for HeapLintVisitor {
+ fn is_running_on_items(&mut self) -> bool { !self.stopping_on_items }
+}
+
+impl Visitor<@mut Context> for HeapLintVisitor {
+ fn visit_item(&mut self, i:@ast::item, e:@mut Context) {
+ self.OVERRIDE_visit_item(i, e);
+ }
+
+ fn visit_fn(&mut self, fk:&visit::fn_kind, fd:&ast::fn_decl,
+ b:&ast::Block, s:span, n:ast::NodeId, e:@mut Context) {
+ self.OVERRIDE_visit_fn(fk, fd, b, s, n, e);
+ }
+
+ fn visit_expr(&mut self, e:@ast::expr, cx:@mut Context) {
let ty = ty::expr_ty(cx.tcx, e);
check_type(cx, e.span, ty);
- oldvisit::visit_expr(e, (cx, vt));
- },
- .. *oldvisit::default_visitor()
- })
+ visit::walk_expr(self, e, cx);
+ }
}
-fn lint_path_statement() -> oldvisit::vt<@mut Context> {
- oldvisit::mk_vt(@oldvisit::Visitor {
- visit_stmt: |s,
- (cx, vt): (@mut Context, oldvisit::vt<@mut Context>)| {
+outer_lint_boilerplate_impl!(HeapLintVisitor)
+
+fn lint_heap() -> @mut OuterLint {
+ @mut HeapLintVisitor { stopping_on_items: false } as @mut OuterLint
+}
+
+struct PathStatementLintVisitor {
+ stopping_on_items: bool
+}
+
+impl SubitemStoppableVisitor for PathStatementLintVisitor {
+ fn is_running_on_items(&mut self) -> bool { !self.stopping_on_items }
+}
+
+impl Visitor<@mut Context> for PathStatementLintVisitor {
+ fn visit_item(&mut self, i:@ast::item, e:@mut Context) {
+ self.OVERRIDE_visit_item(i, e);
+ }
+
+ fn visit_fn(&mut self, fk:&visit::fn_kind, fd:&ast::fn_decl,
+ b:&ast::Block, s:span, n:ast::NodeId, e:@mut Context) {
+ self.OVERRIDE_visit_fn(fk, fd, b, s, n, e);
+ }
+
+ fn visit_stmt(&mut self, s:@ast::stmt, cx:@mut Context) {
match s.node {
ast::stmt_semi(
@ast::expr { node: ast::expr_path(_), _ },
}
_ => ()
}
- oldvisit::visit_stmt(s, (cx, vt));
- },
- .. *oldvisit::default_visitor()
- })
+ visit::walk_stmt(self, s, cx);
+
+ }
+}
+
+outer_lint_boilerplate_impl!(PathStatementLintVisitor)
+
+fn lint_path_statement() -> @mut OuterLint {
+ @mut PathStatementLintVisitor{ stopping_on_items: false } as @mut OuterLint
}
fn check_item_non_camel_case_types(cx: &Context, it: &ast::item) {
}
}
-fn lint_unused_unsafe() -> oldvisit::vt<@mut Context> {
- oldvisit::mk_vt(@oldvisit::Visitor {
- visit_expr: |e,
- (cx, vt): (@mut Context, oldvisit::vt<@mut Context>)| {
+struct UnusedUnsafeLintVisitor { stopping_on_items: bool }
+
+impl SubitemStoppableVisitor for UnusedUnsafeLintVisitor {
+ fn is_running_on_items(&mut self) -> bool { !self.stopping_on_items }
+}
+
+impl Visitor<@mut Context> for UnusedUnsafeLintVisitor {
+ fn visit_item(&mut self, i:@ast::item, e:@mut Context) {
+ self.OVERRIDE_visit_item(i, e);
+ }
+
+ fn visit_fn(&mut self, fk:&visit::fn_kind, fd:&ast::fn_decl,
+ b:&ast::Block, s:span, n:ast::NodeId, e:@mut Context) {
+ self.OVERRIDE_visit_fn(fk, fd, b, s, n, e);
+ }
+
+ fn visit_expr(&mut self, e:@ast::expr, cx:@mut Context) {
+
match e.node {
ast::expr_block(ref blk) if blk.rules == ast::UnsafeBlock => {
if !cx.tcx.used_unsafe.contains(&blk.id) {
}
_ => ()
}
- oldvisit::visit_expr(e, (cx, vt));
- },
- .. *oldvisit::default_visitor()
- })
+ visit::walk_expr(self, e, cx);
+ }
+}
+
+outer_lint_boilerplate_impl!(UnusedUnsafeLintVisitor)
+
+fn lint_unused_unsafe() -> @mut OuterLint {
+ @mut UnusedUnsafeLintVisitor{ stopping_on_items: false } as @mut OuterLint
}
-fn lint_unused_mut() -> oldvisit::vt<@mut Context> {
- fn check_pat(cx: &Context, p: @ast::pat) {
+struct UnusedMutLintVisitor { stopping_on_items: bool }
+
+impl UnusedMutLintVisitor {
+ fn check_pat(&mut self, cx: &Context, p: @ast::pat) {
let mut used = false;
let mut bindings = 0;
do pat_util::pat_bindings(cx.tcx.def_map, p) |_, id, _, _| {
}
}
- fn visit_fn_decl(cx: &Context, fd: &ast::fn_decl) {
+ fn visit_fn_decl(&mut self, cx: &Context, fd: &ast::fn_decl) {
for arg in fd.inputs.iter() {
if arg.is_mutbl {
- check_pat(cx, arg.pat);
+ self.check_pat(cx, arg.pat);
}
}
}
+}
+
+impl SubitemStoppableVisitor for UnusedMutLintVisitor {
+ fn is_running_on_items(&mut self) -> bool { !self.stopping_on_items }
+
+ fn visit_fn_action(&mut self, _a:&visit::fn_kind, fd:&ast::fn_decl,
+ _b:&ast::Block, _c:span, _d:ast::NodeId, cx:@mut Context) {
+ self.visit_fn_decl(cx, fd);
+ }
+}
- oldvisit::mk_vt(@oldvisit::Visitor {
- visit_local: |l,
- (cx, vt): (@mut Context, oldvisit::vt<@mut Context>)| {
+impl Visitor<@mut Context> for UnusedMutLintVisitor {
+ fn visit_item(&mut self, i:@ast::item, e:@mut Context) {
+ self.OVERRIDE_visit_item(i, e);
+ }
+
+ fn visit_fn(&mut self, fk:&visit::fn_kind, fd:&ast::fn_decl,
+ b:&ast::Block, s:span, n:ast::NodeId, e:@mut Context) {
+ self.OVERRIDE_visit_fn(fk, fd, b, s, n, e);
+ }
+
+
+ fn visit_local(&mut self, l:@ast::Local, cx:@mut Context) {
if l.is_mutbl {
- check_pat(cx, l.pat);
+ self.check_pat(cx, l.pat);
}
- oldvisit::visit_local(l, (cx, vt));
- },
- visit_fn: |a, fd, b, c, d, (cx, vt)| {
- visit_fn_decl(cx, fd);
- oldvisit::visit_fn(a, fd, b, c, d, (cx, vt));
- },
- visit_ty_method: |tm, (cx, vt)| {
- visit_fn_decl(cx, &tm.decl);
- oldvisit::visit_ty_method(tm, (cx, vt));
- },
- visit_trait_method: |tm, (cx, vt)| {
+ visit::walk_local(self, l, cx);
+ }
+
+ fn visit_ty_method(&mut self, tm:&ast::TypeMethod, cx:@mut Context) {
+ self.visit_fn_decl(cx, &tm.decl);
+ visit::walk_ty_method(self, tm, cx);
+ }
+
+ fn visit_trait_method(&mut self, tm:&ast::trait_method, cx:@mut Context) {
match *tm {
- ast::required(ref tm) => visit_fn_decl(cx, &tm.decl),
- ast::provided(m) => visit_fn_decl(cx, &m.decl)
+ ast::required(ref tm) => self.visit_fn_decl(cx, &tm.decl),
+ ast::provided(m) => self.visit_fn_decl(cx, &m.decl)
}
- oldvisit::visit_trait_method(tm, (cx, vt));
- },
- .. *oldvisit::default_visitor()
- })
+ visit::walk_trait_method(self, tm, cx);
+ }
+}
+
+outer_lint_boilerplate_impl!(UnusedMutLintVisitor)
+
+fn lint_unused_mut() -> @mut OuterLint {
+ @mut UnusedMutLintVisitor{ stopping_on_items: false } as @mut OuterLint
}
fn lint_session(cx: @mut Context) -> @mut visit::Visitor<()> {
}, false)
}
-fn lint_unnecessary_allocations() -> oldvisit::vt<@mut Context> {
+struct UnnecessaryAllocationLintVisitor { stopping_on_items: bool }
+
+impl SubitemStoppableVisitor for UnnecessaryAllocationLintVisitor {
+ fn is_running_on_items(&mut self) -> bool { !self.stopping_on_items }
+}
+
+impl Visitor<@mut Context> for UnnecessaryAllocationLintVisitor {
+ fn visit_item(&mut self, i:@ast::item, e:@mut Context) {
+ self.OVERRIDE_visit_item(i, e);
+ }
+
+ fn visit_fn(&mut self, fk:&visit::fn_kind, fd:&ast::fn_decl,
+ b:&ast::Block, s:span, n:ast::NodeId, e:@mut Context) {
+ self.OVERRIDE_visit_fn(fk, fd, b, s, n, e);
+ }
+
+ fn visit_expr(&mut self, e:@ast::expr, cx:@mut Context) {
+ self.check(cx, e);
+ visit::walk_expr(self, e, cx);
+ }
+}
+
+impl UnnecessaryAllocationLintVisitor {
// Warn if string and vector literals with sigils are immediately borrowed.
// Those can have the sigil removed.
- fn check(cx: &Context, e: &ast::expr) {
+ fn check(&mut self, cx: &Context, e: &ast::expr) {
match e.node {
ast::expr_vstore(e2, ast::expr_vstore_uniq) |
ast::expr_vstore(e2, ast::expr_vstore_box) => {
_ => ()
}
}
+}
- oldvisit::mk_vt(@oldvisit::Visitor {
- visit_expr: |e,
- (cx, vt): (@mut Context, oldvisit::vt<@mut Context>)| {
- check(cx, e);
- oldvisit::visit_expr(e, (cx, vt));
- },
- .. *oldvisit::default_visitor()
- })
+outer_lint_boilerplate_impl!(UnnecessaryAllocationLintVisitor)
+
+fn lint_unnecessary_allocations() -> @mut OuterLint {
+ @mut UnnecessaryAllocationLintVisitor{ stopping_on_items: false } as @mut OuterLint
}
-fn lint_missing_doc() -> oldvisit::vt<@mut Context> {
- fn check_attrs(cx: @mut Context,
+struct MissingDocLintVisitor { stopping_on_items: bool }
+
+impl MissingDocLintVisitor {
+ fn check_attrs(&mut self,
+ cx: @mut Context,
attrs: &[ast::Attribute],
sp: span,
msg: &str) {
// otherwise, warn!
cx.span_lint(missing_doc, sp, msg);
}
+}
- oldvisit::mk_vt(@oldvisit::Visitor {
- visit_ty_method: |m, (cx, vt)| {
+impl Visitor<@mut Context> for MissingDocLintVisitor {
+ fn visit_item(&mut self, i:@ast::item, e:@mut Context) {
+ self.OVERRIDE_visit_item(i, e);
+ }
+
+ fn visit_fn(&mut self, fk:&visit::fn_kind, fd:&ast::fn_decl,
+ b:&ast::Block, s:span, n:ast::NodeId, e:@mut Context) {
+ self.OVERRIDE_visit_fn(fk, fd, b, s, n, e);
+ }
+
+ fn visit_ty_method(&mut self, m:&ast::TypeMethod, cx:@mut Context) {
// All ty_method objects are linted about because they're part of a
// trait (no visibility)
- check_attrs(cx, m.attrs, m.span,
+ self.check_attrs(cx, m.attrs, m.span,
"missing documentation for a method");
- oldvisit::visit_ty_method(m, (cx, vt));
- },
+ visit::walk_ty_method(self, m, cx);
+ }
+}
+
+impl SubitemStoppableVisitor for MissingDocLintVisitor {
+ fn is_running_on_items(&mut self) -> bool { !self.stopping_on_items }
+
+ fn visit_fn_action(&mut self, fk:&visit::fn_kind, _d:&ast::fn_decl,
+ _b:&ast::Block, sp:span, _id:ast::NodeId, cx:@mut Context) {
- visit_fn: |fk, d, b, sp, id, (cx, vt)| {
// Only warn about explicitly public methods. Soon implicit
// public-ness will hopefully be going away.
match *fk {
- oldvisit::fk_method(_, _, m) if m.vis == ast::public => {
+ visit::fk_method(_, _, m) if m.vis == ast::public => {
// If we're in a trait implementation, no need to duplicate
// documentation
if !cx.in_trait_impl {
- check_attrs(cx, m.attrs, sp,
+ self.check_attrs(cx, m.attrs, sp,
"missing documentation for a method");
}
}
_ => {}
}
- oldvisit::visit_fn(fk, d, b, sp, id, (cx, vt));
- },
+ }
+
+ fn visit_item_action(&mut self, it:@ast::item, cx:@mut Context) {
- visit_item: |it, (cx, vt)| {
match it.node {
// Go ahead and match the fields here instead of using
// visit_struct_field while we have access to the enclosing
// struct's visibility
ast::item_struct(sdef, _) if it.vis == ast::public => {
- check_attrs(cx, it.attrs, it.span,
+ self.check_attrs(cx, it.attrs, it.span,
"missing documentation for a struct");
for field in sdef.fields.iter() {
match field.node.kind {
ast::named_field(_, vis) if vis != ast::private => {
- check_attrs(cx, field.node.attrs, field.span,
+ self.check_attrs(cx, field.node.attrs, field.span,
"missing documentation for a field");
}
ast::unnamed_field | ast::named_field(*) => {}
}
ast::item_trait(*) if it.vis == ast::public => {
- check_attrs(cx, it.attrs, it.span,
+ self.check_attrs(cx, it.attrs, it.span,
"missing documentation for a trait");
}
ast::item_fn(*) if it.vis == ast::public => {
- check_attrs(cx, it.attrs, it.span,
+ self.check_attrs(cx, it.attrs, it.span,
"missing documentation for a function");
}
_ => {}
- };
+ }
+ }
+}
- oldvisit::visit_item(it, (cx, vt));
- },
+outer_lint_boilerplate_impl!(MissingDocLintVisitor)
- .. *oldvisit::default_visitor()
- })
+fn lint_missing_doc() -> @mut OuterLint {
+ @mut MissingDocLintVisitor { stopping_on_items: false } as @mut OuterLint
+}
+
+struct LintCheckVisitor;
+
+impl Visitor<@mut Context> for LintCheckVisitor {
+
+ fn visit_item(&mut self, it:@ast::item, cx: @mut Context) {
+
+ do cx.with_lint_attrs(it.attrs) {
+ match it.node {
+ ast::item_impl(_, Some(*), _, _) => {
+ cx.in_trait_impl = true;
+ }
+ _ => {}
+ }
+ check_item_ctypes(cx, it);
+ check_item_non_camel_case_types(cx, it);
+ check_item_non_uppercase_statics(cx, it);
+ check_item_heap(cx, it);
+
+ cx.process(Item(it));
+ visit::walk_item(self, it, cx);
+ cx.in_trait_impl = false;
+ }
+ }
+
+ fn visit_fn(&mut self, fk:&visit::fn_kind, decl:&ast::fn_decl,
+ body:&ast::Block, span:span, id:ast::NodeId, cx:@mut Context) {
+
+ match *fk {
+ visit::fk_method(_, _, m) => {
+ do cx.with_lint_attrs(m.attrs) {
+ cx.process(Method(m));
+ visit::walk_fn(self,
+ fk,
+ decl,
+ body,
+ span,
+ id,
+ cx);
+ }
+ }
+ _ => {
+ visit::walk_fn(self,
+ fk,
+ decl,
+ body,
+ span,
+ id,
+ cx);
+ }
+ }
+ }
}
pub fn check_crate(tcx: ty::ctxt, crate: @ast::Crate) {
do cx.with_lint_attrs(crate.attrs) {
cx.process(Crate(crate));
- oldvisit::visit_crate(crate, (cx, oldvisit::mk_vt(@oldvisit::Visitor {
- visit_item: |it,
- (cx, vt):
- (@mut Context, oldvisit::vt<@mut Context>)| {
- do cx.with_lint_attrs(it.attrs) {
- match it.node {
- ast::item_impl(_, Some(*), _, _) => {
- cx.in_trait_impl = true;
- }
- _ => {}
- }
- check_item_ctypes(cx, it);
- check_item_non_camel_case_types(cx, it);
- check_item_non_uppercase_statics(cx, it);
- check_item_heap(cx, it);
+ let mut visitor = LintCheckVisitor;
- cx.process(Item(it));
- oldvisit::visit_item(it, (cx, vt));
- cx.in_trait_impl = false;
- }
- },
- visit_fn: |fk, decl, body, span, id, (cx, vt)| {
- match *fk {
- oldvisit::fk_method(_, _, m) => {
- do cx.with_lint_attrs(m.attrs) {
- cx.process(Method(m));
- oldvisit::visit_fn(fk,
- decl,
- body,
- span,
- id,
- (cx, vt));
- }
- }
- _ => {
- oldvisit::visit_fn(fk,
- decl,
- body,
- span,
- id,
- (cx, vt));
- }
- }
- },
- .. *oldvisit::default_visitor()
- })));
+ visit::walk_crate(&mut visitor, crate, cx);
}
// If we missed any lints added to the session, then there's a bug somewhere
use syntax::codemap::span;
use syntax::parse::token::special_idents;
use syntax::print::pprust::{expr_to_str, block_to_str};
-use syntax::oldvisit::{fk_anon, fk_fn_block, fk_item_fn, fk_method};
-use syntax::oldvisit::{vt};
-use syntax::{oldvisit, ast_util};
+use syntax::{visit, ast_util};
+use syntax::visit::{Visitor,fn_kind};
#[deriving(Eq)]
struct Variable(uint);
}
}
+struct LivenessVisitor;
+
+impl Visitor<@mut IrMaps> for LivenessVisitor {
+ fn visit_fn(&mut self, fk:&fn_kind, fd:&fn_decl, b:&Block, s:span, n:NodeId, e:@mut IrMaps) {
+ visit_fn(self, fk, fd, b, s, n, e);
+ }
+ fn visit_local(&mut self, l:@Local, e:@mut IrMaps) { visit_local(self, l, e); }
+ fn visit_expr(&mut self, ex:@expr, e:@mut IrMaps) { visit_expr(self, ex, e); }
+ fn visit_arm(&mut self, a:&arm, e:@mut IrMaps) { visit_arm(self, a, e); }
+}
+
pub fn check_crate(tcx: ty::ctxt,
method_map: typeck::method_map,
capture_map: moves::CaptureMap,
crate: &Crate) {
- let visitor = oldvisit::mk_vt(@oldvisit::Visitor {
- visit_fn: visit_fn,
- visit_local: visit_local,
- visit_expr: visit_expr,
- visit_arm: visit_arm,
- .. *oldvisit::default_visitor()
- });
+ let mut visitor = LivenessVisitor;
let initial_maps = @mut IrMaps(tcx,
method_map,
capture_map);
- oldvisit::visit_crate(crate, (initial_maps, visitor));
+ visit::walk_crate(&mut visitor, crate, initial_maps);
tcx.sess.abort_if_errors();
}
}
}
-fn visit_fn(fk: &oldvisit::fn_kind,
+struct ErrorCheckVisitor;
+
+impl Visitor<@Liveness> for ErrorCheckVisitor {
+ fn visit_fn(&mut self, fk:&fn_kind, fd:&fn_decl, b:&Block, s:span, n:NodeId, e:@Liveness) {
+ check_fn(self, fk, fd, b, s, n, e);
+ }
+ fn visit_local(&mut self, l:@Local, e:@Liveness) {
+ check_local(self, l, e);
+ }
+ fn visit_expr(&mut self, ex:@expr, e:@Liveness) {
+ check_expr(self, ex, e);
+ }
+ fn visit_arm(&mut self, a:&arm, e:@Liveness) {
+ check_arm(self, a, e);
+ }
+}
+
+fn visit_fn(v: &mut LivenessVisitor,
+ fk: &visit::fn_kind,
decl: &fn_decl,
body: &Block,
sp: span,
id: NodeId,
- (this, v): (@mut IrMaps,
- vt<@mut IrMaps>)) {
+ this: @mut IrMaps) {
debug!("visit_fn: id=%d", id);
let _i = ::util::common::indenter();
// Add `this`, whether explicit or implicit.
match *fk {
- fk_method(_, _, method) => {
+ visit::fk_method(_, _, method) => {
match method.explicit_self.node {
sty_value | sty_region(*) | sty_box(_) | sty_uniq => {
fn_maps.add_variable(Arg(method.self_id,
sty_static => {}
}
}
- fk_item_fn(*) | fk_anon(*) | fk_fn_block(*) => {}
+ visit::fk_item_fn(*) | visit::fk_anon(*) | visit::fk_fn_block(*) => {}
}
// gather up the various local variables, significant expressions,
// and so forth:
- oldvisit::visit_fn(fk, decl, body, sp, id, (fn_maps, v));
+ visit::walk_fn(v, fk, decl, body, sp, id, fn_maps);
// Special nodes and variables:
// - exit_ln represents the end of the fn, either by return or fail
let entry_ln = (*lsets).compute(decl, body);
// check for various error conditions
- let check_vt = oldvisit::mk_vt(@oldvisit::Visitor {
- visit_fn: check_fn,
- visit_local: check_local,
- visit_expr: check_expr,
- visit_arm: check_arm,
- .. *oldvisit::default_visitor()
- });
- (check_vt.visit_block)(body, (lsets, check_vt));
+ let mut check_vt = ErrorCheckVisitor;
+ check_vt.visit_block(body, lsets);
lsets.check_ret(id, sp, fk, entry_ln);
lsets.warn_about_unused_args(decl, entry_ln);
}
-fn visit_local(local: @Local, (this, vt): (@mut IrMaps, vt<@mut IrMaps>)) {
+fn visit_local(v: &mut LivenessVisitor, local: @Local, this: @mut IrMaps) {
let def_map = this.tcx.def_map;
do pat_util::pat_bindings(def_map, local.pat) |_bm, p_id, sp, path| {
debug!("adding local variable %d", p_id);
kind: kind
}));
}
- oldvisit::visit_local(local, (this, vt));
+ visit::walk_local(v, local, this);
}
-fn visit_arm(arm: &arm, (this, vt): (@mut IrMaps, vt<@mut IrMaps>)) {
+fn visit_arm(v: &mut LivenessVisitor, arm: &arm, this: @mut IrMaps) {
let def_map = this.tcx.def_map;
for pat in arm.pats.iter() {
do pat_util::pat_bindings(def_map, *pat) |bm, p_id, sp, path| {
}));
}
}
- oldvisit::visit_arm(arm, (this, vt));
+ visit::walk_arm(v, arm, this);
}
-fn visit_expr(expr: @expr, (this, vt): (@mut IrMaps, vt<@mut IrMaps>)) {
+fn visit_expr(v: &mut LivenessVisitor, expr: @expr, this: @mut IrMaps) {
match expr.node {
// live nodes required for uses or definitions of variables:
expr_path(_) | expr_self => {
if moves::moved_variable_node_id_from_def(def).is_some() {
this.add_live_node_for_node(expr.id, ExprNode(expr.span));
}
- oldvisit::visit_expr(expr, (this, vt));
+ visit::walk_expr(v, expr, this);
}
expr_fn_block(*) => {
// Interesting control flow (for loops can contain labeled
}
this.set_captures(expr.id, call_caps);
- oldvisit::visit_expr(expr, (this, vt));
+ visit::walk_expr(v, expr, this);
}
// live nodes required for interesting control flow:
expr_if(*) | expr_match(*) | expr_while(*) | expr_loop(*) => {
this.add_live_node_for_node(expr.id, ExprNode(expr.span));
- oldvisit::visit_expr(expr, (this, vt));
+ visit::walk_expr(v, expr, this);
}
expr_for_loop(*) => fail!("non-desugared expr_for_loop"),
expr_binary(_, op, _, _) if ast_util::lazy_binop(op) => {
this.add_live_node_for_node(expr.id, ExprNode(expr.span));
- oldvisit::visit_expr(expr, (this, vt));
+ visit::walk_expr(v, expr, this);
}
// otherwise, live nodes are not required:
expr_assign(*) | expr_assign_op(*) | expr_mac(*) |
expr_struct(*) | expr_repeat(*) | expr_paren(*) |
expr_inline_asm(*) => {
- oldvisit::visit_expr(expr, (this, vt));
+ visit::walk_expr(v, expr, this);
}
}
}
// _______________________________________________________________________
// Checking for error conditions
-fn check_local(local: @Local, (this, vt): (@Liveness, vt<@Liveness>)) {
+fn check_local(vt: &mut ErrorCheckVisitor, local: @Local, this: @Liveness) {
match local.init {
Some(_) => {
this.warn_about_unused_or_dead_vars_in_pat(local.pat);
}
}
- oldvisit::visit_local(local, (this, vt));
+ visit::walk_local(vt, local, this);
}
-fn check_arm(arm: &arm, (this, vt): (@Liveness, vt<@Liveness>)) {
+fn check_arm(vt: &mut ErrorCheckVisitor, arm: &arm, this: @Liveness) {
do this.arm_pats_bindings(arm.pats) |ln, var, sp, id| {
this.warn_about_unused(sp, id, ln, var);
}
- oldvisit::visit_arm(arm, (this, vt));
+ visit::walk_arm(vt, arm, this);
}
-fn check_expr(expr: @expr, (this, vt): (@Liveness, vt<@Liveness>)) {
+fn check_expr(vt: &mut ErrorCheckVisitor, expr: @expr, this: @Liveness) {
match expr.node {
expr_assign(l, r) => {
this.check_lvalue(l, vt);
- (vt.visit_expr)(r, (this, vt));
+ vt.visit_expr(r, this);
- oldvisit::visit_expr(expr, (this, vt));
+ visit::walk_expr(vt, expr, this);
}
expr_assign_op(_, _, l, _) => {
this.check_lvalue(l, vt);
- oldvisit::visit_expr(expr, (this, vt));
+ visit::walk_expr(vt, expr, this);
}
expr_inline_asm(ref ia) => {
for &(_, input) in ia.inputs.iter() {
- (vt.visit_expr)(input, (this, vt));
+ vt.visit_expr(input, this);
}
// Output operands must be lvalues
}
_ => {}
}
- (vt.visit_expr)(out, (this, vt));
+ vt.visit_expr(out, this);
}
- oldvisit::visit_expr(expr, (this, vt));
+ visit::walk_expr(vt, expr, this);
}
// no correctness conditions related to liveness
expr_again(*) | expr_lit(_) | expr_block(*) |
expr_mac(*) | expr_addr_of(*) | expr_struct(*) | expr_repeat(*) |
expr_paren(*) | expr_fn_block(*) | expr_path(*) | expr_self(*) => {
- oldvisit::visit_expr(expr, (this, vt));
+ visit::walk_expr(vt, expr, this);
}
expr_for_loop(*) => fail!("non-desugared expr_for_loop")
}
}
-fn check_fn(_fk: &oldvisit::fn_kind,
+fn check_fn(_v: &mut ErrorCheckVisitor,
+ _fk: &visit::fn_kind,
_decl: &fn_decl,
_body: &Block,
_sp: span,
_id: NodeId,
- (_self, _v): (@Liveness, vt<@Liveness>)) {
+ _self: @Liveness) {
// do not check contents of nested fns
}
pub fn check_ret(&self,
id: NodeId,
sp: span,
- _fk: &oldvisit::fn_kind,
+ _fk: &visit::fn_kind,
entry_ln: LiveNode) {
if self.live_on_entry(entry_ln, self.s.no_ret_var).is_some() {
// if no_ret_var is live, then we fall off the end of the
}
}
- pub fn check_lvalue(@self, expr: @expr, vt: vt<@Liveness>) {
+ pub fn check_lvalue(@self, expr: @expr, vt: &mut ErrorCheckVisitor) {
match expr.node {
expr_path(_) => {
match self.tcx.def_map.get_copy(&expr.id) {
_ => {
// For other kinds of lvalues, no checks are required,
// and any embedded expressions are actually rvalues
- oldvisit::visit_expr(expr, (self, vt));
+ visit::walk_expr(vt, expr, self);
}
}
}
use middle::ty::{ty_struct, ty_enum};
use middle::ty;
use middle::typeck::{method_map, method_origin, method_param};
-use middle::typeck::{method_static, method_trait};
+use middle::typeck::{method_static, method_object};
use std::util::ignore;
use syntax::ast::{decl_item, def, def_fn, def_id, def_static_method};
use syntax::attr;
use syntax::codemap::span;
use syntax::parse::token;
-use syntax::oldvisit;
+use syntax::visit;
+use syntax::visit::Visitor;
+use syntax::ast::{_mod,expr,item,Block,pat};
-pub fn check_crate<'mm>(tcx: ty::ctxt,
- method_map: &'mm method_map,
- crate: &ast::Crate) {
- let privileged_items = @mut ~[];
+struct PrivacyVisitor {
+ tcx: ty::ctxt,
+ privileged_items: @mut ~[NodeId],
+}
+impl PrivacyVisitor {
// Adds an item to its scope.
- let add_privileged_item: @fn(@ast::item, &mut uint) = |item, count| {
+ fn add_privileged_item(&mut self, item: @ast::item, count: &mut uint) {
match item.node {
item_struct(*) | item_trait(*) | item_enum(*) |
item_fn(*) => {
- privileged_items.push(item.id);
+ self.privileged_items.push(item.id);
*count += 1;
}
item_impl(_, _, _, ref methods) => {
for method in methods.iter() {
- privileged_items.push(method.id);
+ self.privileged_items.push(method.id);
*count += 1;
}
- privileged_items.push(item.id);
+ self.privileged_items.push(item.id);
*count += 1;
}
item_foreign_mod(ref foreign_mod) => {
for foreign_item in foreign_mod.items.iter() {
- privileged_items.push(foreign_item.id);
+ self.privileged_items.push(foreign_item.id);
*count += 1;
}
}
_ => {}
}
- };
+ }
// Adds items that are privileged to this scope.
- let add_privileged_items: @fn(&[@ast::item]) -> uint = |items| {
+ fn add_privileged_items(&mut self, items: &[@ast::item]) -> uint {
let mut count = 0;
for &item in items.iter() {
- add_privileged_item(item, &mut count);
+ self.add_privileged_item(item, &mut count);
}
count
- };
+ }
// Checks that an enum variant is in scope
- let check_variant: @fn(span: span, enum_id: ast::def_id) =
- |span, enum_id| {
- let variant_info = ty::enum_variants(tcx, enum_id)[0];
+ fn check_variant(&mut self, span: span, enum_id: ast::def_id) {
+ let variant_info = ty::enum_variants(self.tcx, enum_id)[0];
let parental_privacy = if is_local(enum_id) {
- let parent_vis = ast_map::node_item_query(tcx.items, enum_id.node,
+ let parent_vis = ast_map::node_item_query(self.tcx.items,
+ enum_id.node,
|it| { it.vis },
~"unbound enum parent when checking \
dereference of enum type");
if variant_visibility_to_privacy(variant_info.vis,
parental_privacy == Public)
== Private {
- tcx.sess.span_err(span,
+ self.tcx.sess.span_err(span,
"can only dereference enums \
with a single, public variant");
}
- };
+ }
// Returns true if a crate-local method is private and false otherwise.
- let method_is_private: @fn(span: span, method_id: NodeId) -> bool =
- |span, method_id| {
+ fn method_is_private(&mut self, span: span, method_id: NodeId) -> bool {
let check = |vis: visibility, container_id: def_id| {
let mut is_private = false;
if vis == private {
} else {
// Look up the enclosing impl.
if container_id.crate != LOCAL_CRATE {
- tcx.sess.span_bug(span,
+ self.tcx.sess.span_bug(span,
"local method isn't in local \
impl?!");
}
- match tcx.items.find(&container_id.node) {
+ match self.tcx.items.find(&container_id.node) {
Some(&node_item(item, _)) => {
match item.node {
item_impl(_, None, _, _)
}
}
Some(_) => {
- tcx.sess.span_bug(span, "impl wasn't an item?!");
+ self.tcx.sess.span_bug(span, "impl wasn't an item?!");
}
None => {
- tcx.sess.span_bug(span, "impl wasn't in AST map?!");
+ self.tcx.sess.span_bug(span, "impl wasn't in AST map?!");
}
}
}
is_private
};
- match tcx.items.find(&method_id) {
+ match self.tcx.items.find(&method_id) {
Some(&node_method(method, impl_id, _)) => {
check(method.vis, impl_id)
}
}
}
Some(_) => {
- tcx.sess.span_bug(span,
+ self.tcx.sess.span_bug(span,
fmt!("method_is_private: method was a %s?!",
ast_map::node_id_to_str(
- tcx.items,
+ self.tcx.items,
method_id,
token::get_ident_interner())));
}
None => {
- tcx.sess.span_bug(span, "method not found in \
+ self.tcx.sess.span_bug(span, "method not found in \
AST map?!");
}
}
- };
+ }
// Returns true if the given local item is private and false otherwise.
- let local_item_is_private: @fn(span: span, item_id: NodeId) -> bool =
- |span, item_id| {
+ fn local_item_is_private(&mut self, span: span, item_id: NodeId) -> bool {
let mut f: &fn(NodeId) -> bool = |_| false;
f = |item_id| {
- match tcx.items.find(&item_id) {
+ match self.tcx.items.find(&item_id) {
Some(&node_item(item, _)) => item.vis != public,
Some(&node_foreign_item(*)) => false,
Some(&node_method(method, impl_did, _)) => {
}
Some(&node_trait_method(_, trait_did, _)) => f(trait_did.node),
Some(_) => {
- tcx.sess.span_bug(span,
+ self.tcx.sess.span_bug(span,
fmt!("local_item_is_private: item was \
a %s?!",
ast_map::node_id_to_str(
- tcx.items,
+ self.tcx.items,
item_id,
token::get_ident_interner())));
}
None => {
- tcx.sess.span_bug(span, "item not found in AST map?!");
+ self.tcx.sess.span_bug(span, "item not found in AST map?!");
}
}
};
f(item_id)
- };
+ }
// Checks that a private field is in scope.
- let check_field: @fn(span: span, id: ast::def_id, ident: ast::ident) =
- |span, id, ident| {
- let fields = ty::lookup_struct_fields(tcx, id);
+ fn check_field(&mut self, span: span, id: ast::def_id, ident: ast::ident) {
+ let fields = ty::lookup_struct_fields(self.tcx, id);
for field in fields.iter() {
if field.ident != ident { loop; }
if field.vis == private {
- tcx.sess.span_err(span, fmt!("field `%s` is private",
+ self.tcx.sess.span_err(span, fmt!("field `%s` is private",
token::ident_to_str(&ident)));
}
break;
}
- };
+ }
// Given the ID of a method, checks to ensure it's in scope.
- let check_method_common: @fn(span: span,
- method_id: def_id,
- name: &ident) =
- |span, method_id, name| {
+ fn check_method_common(&mut self, span: span, method_id: def_id, name: &ident) {
// If the method is a default method, we need to use the def_id of
// the default implementation.
// Having to do this this is really unfortunate.
- let method_id = ty::method(tcx, method_id).provided_source
+ let method_id = ty::method(self.tcx, method_id).provided_source
.unwrap_or_default(method_id);
if method_id.crate == LOCAL_CRATE {
- let is_private = method_is_private(span, method_id.node);
- let container_id = ty::method(tcx, method_id).container_id;
+ let is_private = self.method_is_private(span, method_id.node);
+ let container_id = ty::method(self.tcx, method_id).container_id;
if is_private &&
(container_id.crate != LOCAL_CRATE ||
- !privileged_items.iter().any(|x| x == &(container_id.node))) {
- tcx.sess.span_err(span,
+ !self.privileged_items.iter().any(|x| x == &(container_id.node))) {
+ self.tcx.sess.span_err(span,
fmt!("method `%s` is private",
token::ident_to_str(name)));
}
} else {
let visibility =
- csearch::get_item_visibility(tcx.sess.cstore, method_id);
+ csearch::get_item_visibility(self.tcx.sess.cstore, method_id);
if visibility != public {
- tcx.sess.span_err(span,
+ self.tcx.sess.span_err(span,
fmt!("method `%s` is private",
token::ident_to_str(name)));
}
}
- };
+ }
// Checks that a private path is in scope.
- let check_path: @fn(span: span, def: def, path: &Path) =
- |span, def, path| {
+ fn check_path(&mut self, span: span, def: def, path: &Path) {
debug!("checking path");
match def {
def_static_method(method_id, _, _) => {
debug!("found static method def, checking it");
- check_method_common(span, method_id, path.idents.last())
+ self.check_method_common(span, method_id, path.idents.last())
}
def_fn(def_id, _) => {
if def_id.crate == LOCAL_CRATE {
- if local_item_is_private(span, def_id.node) &&
- !privileged_items.iter().any(|x| x == &def_id.node) {
- tcx.sess.span_err(span,
+ if self.local_item_is_private(span, def_id.node) &&
+ !self.privileged_items.iter().any(|x| x == &def_id.node) {
+ self.tcx.sess.span_err(span,
fmt!("function `%s` is private",
token::ident_to_str(path.idents.last())));
}
- } else if csearch::get_item_visibility(tcx.sess.cstore,
+ } else if csearch::get_item_visibility(self.tcx.sess.cstore,
def_id) != public {
- tcx.sess.span_err(span,
+ self.tcx.sess.span_err(span,
fmt!("function `%s` is private",
token::ident_to_str(path.idents.last())));
}
}
_ => {}
}
- };
+ }
// Checks that a private method is in scope.
- let check_method: @fn(span: span,
- origin: &method_origin,
- ident: ast::ident) =
- |span, origin, ident| {
+ fn check_method(&mut self, span: span, origin: &method_origin, ident: ast::ident) {
match *origin {
method_static(method_id) => {
- check_method_common(span, method_id, &ident)
+ self.check_method_common(span, method_id, &ident)
}
method_param(method_param {
trait_id: trait_id,
- method_num: method_num,
+ method_num: method_num,
_
}) |
- method_trait(trait_id, method_num) => {
+ method_object(method_object {
+ trait_id: trait_id,
+ method_num: method_num,
+ _
+ }) => {
if trait_id.crate == LOCAL_CRATE {
- match tcx.items.find(&trait_id.node) {
+ match self.tcx.items.find(&trait_id.node) {
Some(&node_item(item, _)) => {
match item.node {
item_trait(_, _, ref methods) => {
if method_num >= (*methods).len() {
- tcx.sess.span_bug(span, "method number out of range?!");
+ self.tcx.sess.span_bug(span,
+ "method number out of range?!");
}
match (*methods)[method_num] {
provided(method)
if method.vis == private &&
- !privileged_items.iter()
+ !self.privileged_items.iter()
.any(|x| x == &(trait_id.node)) => {
- tcx.sess.span_err(span,
+ self.tcx.sess.span_err(span,
fmt!("method `%s` is private",
token::ident_to_str(&method
.ident)));
}
}
_ => {
- tcx.sess.span_bug(span, "trait wasn't actually a trait?!");
+ self.tcx.sess.span_bug(span, "trait wasn't actually a trait?!");
}
}
}
Some(_) => {
- tcx.sess.span_bug(span, "trait wasn't an item?!");
+ self.tcx.sess.span_bug(span, "trait wasn't an item?!");
}
None => {
- tcx.sess.span_bug(span, "trait item wasn't found in the AST map?!");
+ self.tcx.sess.span_bug(span,
+ "trait item wasn't found in the AST map?!");
}
}
} else {
}
}
}
- };
+ }
+}
- let visitor = oldvisit::mk_vt(@oldvisit::Visitor {
- visit_mod: |the_module, span, node_id, (method_map, visitor)| {
- let n_added = add_privileged_items(the_module.items);
+impl<'self> Visitor<&'self method_map> for PrivacyVisitor {
- oldvisit::visit_mod(the_module,
- span,
- node_id,
- (method_map, visitor));
+ fn visit_mod<'mm>(&mut self, the_module:&_mod, _:span, _:NodeId,
+ method_map:&'mm method_map) {
+
+ let n_added = self.add_privileged_items(the_module.items);
+
+ visit::walk_mod(self, the_module, method_map);
do n_added.times {
- ignore(privileged_items.pop());
+ ignore(self.privileged_items.pop());
}
- },
- visit_item: |item, (method_map, visitor)| {
+ }
+
+ fn visit_item<'mm>(&mut self, item:@item, method_map:&'mm method_map) {
+
// Do not check privacy inside items with the resolve_unexported
// attribute. This is used for the test runner.
if !attr::contains_name(item.attrs, "!resolve_unexported") {
- check_sane_privacy(tcx, item);
- oldvisit::visit_item(item, (method_map, visitor));
+ check_sane_privacy(self.tcx, item);
+ visit::walk_item(self, item, method_map);
}
- },
- visit_block: |block, (method_map, visitor)| {
+ }
+
+ fn visit_block<'mm>(&mut self, block:&Block, method_map:&'mm method_map) {
+
// Gather up all the privileged items.
let mut n_added = 0;
for stmt in block.stmts.iter() {
stmt_decl(decl, _) => {
match decl.node {
decl_item(item) => {
- add_privileged_item(item, &mut n_added);
+ self.add_privileged_item(item, &mut n_added);
}
_ => {}
}
}
}
- oldvisit::visit_block(block, (method_map, visitor));
+ visit::walk_block(self, block, method_map);
do n_added.times {
- ignore(privileged_items.pop());
+ ignore(self.privileged_items.pop());
}
- },
- visit_expr: |expr,
- (method_map, visitor):
- (&'mm method_map, oldvisit::vt<&'mm method_map>)| {
+
+ }
+
+ fn visit_expr<'mm>(&mut self, expr:@expr, method_map:&'mm method_map) {
+
match expr.node {
expr_field(base, ident, _) => {
// Method calls are now a special syntactic form,
// With type_autoderef, make sure we don't
// allow pointers to violate privacy
- match ty::get(ty::type_autoderef(tcx, ty::expr_ty(tcx,
+ match ty::get(ty::type_autoderef(self.tcx, ty::expr_ty(self.tcx,
base))).sty {
ty_struct(id, _)
- if id.crate != LOCAL_CRATE || !privileged_items.iter()
+ if id.crate != LOCAL_CRATE || !self.privileged_items.iter()
.any(|x| x == &(id.node)) => {
debug!("(privacy checking) checking field access");
- check_field(expr.span, id, ident);
+ self.check_field(expr.span, id, ident);
}
_ => {}
}
}
expr_method_call(_, base, ident, _, _, _) => {
// Ditto
- match ty::get(ty::type_autoderef(tcx, ty::expr_ty(tcx,
+ match ty::get(ty::type_autoderef(self.tcx, ty::expr_ty(self.tcx,
base))).sty {
ty_enum(id, _) |
ty_struct(id, _)
if id.crate != LOCAL_CRATE ||
- !privileged_items.iter().any(|x| x == &(id.node)) => {
+ !self.privileged_items.iter().any(|x| x == &(id.node)) => {
match method_map.find(&expr.id) {
None => {
- tcx.sess.span_bug(expr.span,
+ self.tcx.sess.span_bug(expr.span,
"method call not in \
method map");
}
Some(ref entry) => {
debug!("(privacy checking) checking \
impl method");
- check_method(expr.span, &entry.origin, ident);
+ self.check_method(expr.span, &entry.origin, ident);
}
}
}
}
}
expr_path(ref path) => {
- check_path(expr.span, tcx.def_map.get_copy(&expr.id), path);
+ self.check_path(expr.span, self.tcx.def_map.get_copy(&expr.id), path);
}
expr_struct(_, ref fields, _) => {
- match ty::get(ty::expr_ty(tcx, expr)).sty {
+ match ty::get(ty::expr_ty(self.tcx, expr)).sty {
ty_struct(id, _) => {
if id.crate != LOCAL_CRATE ||
- !privileged_items.iter().any(|x| x == &(id.node)) {
+ !self.privileged_items.iter().any(|x| x == &(id.node)) {
for field in (*fields).iter() {
debug!("(privacy checking) checking \
field in struct literal");
- check_field(expr.span, id, field.ident);
+ self.check_field(expr.span, id, field.ident);
}
}
}
ty_enum(id, _) => {
if id.crate != LOCAL_CRATE ||
- !privileged_items.iter().any(|x| x == &(id.node)) {
- match tcx.def_map.get_copy(&expr.id) {
+ !self.privileged_items.iter().any(|x| x == &(id.node)) {
+ match self.tcx.def_map.get_copy(&expr.id) {
def_variant(_, variant_id) => {
for field in (*fields).iter() {
debug!("(privacy checking) \
checking field in \
struct variant \
literal");
- check_field(expr.span, variant_id, field.ident);
+ self.check_field(expr.span, variant_id, field.ident);
}
}
_ => {
- tcx.sess.span_bug(expr.span,
+ self.tcx.sess.span_bug(expr.span,
"resolve didn't \
map enum struct \
constructor to a \
}
}
_ => {
- tcx.sess.span_bug(expr.span, "struct expr \
+ self.tcx.sess.span_bug(expr.span, "struct expr \
didn't have \
struct type?!");
}
// enum type t, then t's first variant is public or
// privileged. (We can assume it has only one variant
// since typeck already happened.)
- match ty::get(ty::expr_ty(tcx, operand)).sty {
+ match ty::get(ty::expr_ty(self.tcx, operand)).sty {
ty_enum(id, _) => {
if id.crate != LOCAL_CRATE ||
- !privileged_items.iter().any(|x| x == &(id.node)) {
- check_variant(expr.span, id);
+ !self.privileged_items.iter().any(|x| x == &(id.node)) {
+ self.check_variant(expr.span, id);
}
}
_ => { /* No check needed */ }
_ => {}
}
- oldvisit::visit_expr(expr, (method_map, visitor));
- },
- visit_pat: |pattern, (method_map, visitor)| {
+ visit::walk_expr(self, expr, method_map);
+
+ }
+
+ fn visit_pat<'mm>(&mut self, pattern:@pat, method_map:&'mm method_map) {
+
match pattern.node {
pat_struct(_, ref fields, _) => {
- match ty::get(ty::pat_ty(tcx, pattern)).sty {
+ match ty::get(ty::pat_ty(self.tcx, pattern)).sty {
ty_struct(id, _) => {
if id.crate != LOCAL_CRATE ||
- !privileged_items.iter().any(|x| x == &(id.node)) {
+ !self.privileged_items.iter().any(|x| x == &(id.node)) {
for field in fields.iter() {
debug!("(privacy checking) checking \
struct pattern");
- check_field(pattern.span, id, field.ident);
+ self.check_field(pattern.span, id, field.ident);
}
}
}
ty_enum(enum_id, _) => {
if enum_id.crate != LOCAL_CRATE ||
- !privileged_items.iter().any(|x| x == &enum_id.node) {
- match tcx.def_map.find(&pattern.id) {
+ !self.privileged_items.iter().any(|x| x == &enum_id.node) {
+ match self.tcx.def_map.find(&pattern.id) {
Some(&def_variant(_, variant_id)) => {
for field in fields.iter() {
debug!("(privacy checking) \
checking field in \
struct variant pattern");
- check_field(pattern.span, variant_id, field.ident);
+ self.check_field(pattern.span, variant_id, field.ident);
}
}
_ => {
- tcx.sess.span_bug(pattern.span,
+ self.tcx.sess.span_bug(pattern.span,
"resolve didn't \
map enum struct \
pattern to a \
}
}
_ => {
- tcx.sess.span_bug(pattern.span,
+ self.tcx.sess.span_bug(pattern.span,
"struct pattern didn't have \
struct type?!");
}
_ => {}
}
- oldvisit::visit_pat(pattern, (method_map, visitor));
- },
- .. *oldvisit::default_visitor()
- });
- oldvisit::visit_crate(crate, (method_map, visitor));
+ visit::walk_pat(self, pattern, method_map);
+ }
+}
+
+pub fn check_crate<'mm>(tcx: ty::ctxt,
+ method_map: &'mm method_map,
+ crate: &ast::Crate) {
+ let privileged_items = @mut ~[];
+
+ let mut visitor = PrivacyVisitor {
+ tcx: tcx,
+ privileged_items: privileged_items,
+ };
+ visit::walk_crate(&mut visitor, crate, method_map);
}
/// Validates all of the visibility qualifers placed on the item given. This
use syntax::ast_util::def_id_of_def;
use syntax::attr;
use syntax::parse::token;
-use syntax::oldvisit::Visitor;
-use syntax::oldvisit;
+use syntax::visit::Visitor;
+use syntax::visit;
// Returns true if the given set of attributes contains the `#[inline]`
// attribute.
worklist: @mut ~[NodeId],
}
-impl ReachableContext {
- // Creates a new reachability computation context.
- fn new(tcx: ty::ctxt, method_map: typeck::method_map)
- -> ReachableContext {
- ReachableContext {
- tcx: tcx,
- method_map: method_map,
- reachable_symbols: @mut HashSet::new(),
- worklist: @mut ~[],
- }
- }
+struct ReachableVisitor {
+ reachable_symbols: @mut HashSet<NodeId>,
+ worklist: @mut ~[NodeId],
+}
+
+impl Visitor<PrivacyContext> for ReachableVisitor {
+
+ fn visit_item(&mut self, item:@item, privacy_context:PrivacyContext) {
- // Step 1: Mark all public symbols, and add all public symbols that might
- // be inlined to a worklist.
- fn mark_public_symbols(&self, crate: @Crate) {
- let reachable_symbols = self.reachable_symbols;
- let worklist = self.worklist;
- let visitor = oldvisit::mk_vt(@Visitor {
- visit_item: |item, (privacy_context, visitor):
- (PrivacyContext, oldvisit::vt<PrivacyContext>)| {
match item.node {
item_fn(*) => {
if privacy_context == PublicContext {
- reachable_symbols.insert(item.id);
+ self.reachable_symbols.insert(item.id);
}
if item_might_be_inlined(item) {
- worklist.push(item.id)
+ self.worklist.push(item.id)
}
}
item_struct(ref struct_def, _) => {
match struct_def.ctor_id {
Some(ctor_id) if
privacy_context == PublicContext => {
- reachable_symbols.insert(ctor_id);
+ self.reachable_symbols.insert(ctor_id);
}
Some(_) | None => {}
}
item_enum(ref enum_def, _) => {
if privacy_context == PublicContext {
for variant in enum_def.variants.iter() {
- reachable_symbols.insert(variant.node.id);
+ self.reachable_symbols.insert(variant.node.id);
}
}
}
// Mark all public methods as reachable.
for &method in methods.iter() {
if should_be_considered_public(method) {
- reachable_symbols.insert(method.id);
+ self.reachable_symbols.insert(method.id);
}
}
// symbols to the worklist.
for &method in methods.iter() {
if should_be_considered_public(method) {
- worklist.push(method.id)
+ self.worklist.push(method.id)
}
}
} else {
if generics_require_inlining(generics) ||
attributes_specify_inlining(*attrs) ||
should_be_considered_public(*method) {
- worklist.push(method.id)
+ self.worklist.push(method.id)
}
}
}
for trait_method in trait_methods.iter() {
match *trait_method {
provided(method) => {
- reachable_symbols.insert(method.id);
- worklist.push(method.id)
+ self.reachable_symbols.insert(method.id);
+ self.worklist.push(method.id)
}
required(_) => {}
}
}
if item.vis == public && privacy_context == PublicContext {
- oldvisit::visit_item(item, (PublicContext, visitor))
+ visit::walk_item(self, item, PublicContext)
} else {
- oldvisit::visit_item(item, (PrivateContext, visitor))
+ visit::walk_item(self, item, PrivateContext)
}
- },
- .. *oldvisit::default_visitor()
- });
+ }
+
+}
+
+struct MarkSymbolVisitor {
+ worklist: @mut ~[NodeId],
+ method_map: typeck::method_map,
+ tcx: ty::ctxt,
+ reachable_symbols: @mut HashSet<NodeId>,
+}
+
+impl Visitor<()> for MarkSymbolVisitor {
- oldvisit::visit_crate(crate, (PublicContext, visitor))
+ fn visit_expr(&mut self, expr:@expr, _:()) {
+
+ match expr.node {
+ expr_path(_) => {
+ let def = match self.tcx.def_map.find(&expr.id) {
+ Some(&def) => def,
+ None => {
+ self.tcx.sess.span_bug(expr.span,
+ "def ID not in def map?!")
+ }
+ };
+
+ let def_id = def_id_of_def(def);
+ if ReachableContext::
+ def_id_represents_local_inlined_item(self.tcx,
+ def_id) {
+ self.worklist.push(def_id.node)
+ }
+ self.reachable_symbols.insert(def_id.node);
+ }
+ expr_method_call(*) => {
+ match self.method_map.find(&expr.id) {
+ Some(&typeck::method_map_entry {
+ origin: typeck::method_static(def_id),
+ _
+ }) => {
+ if ReachableContext::
+ def_id_represents_local_inlined_item(
+ self.tcx,
+ def_id) {
+ self.worklist.push(def_id.node)
+ }
+ self.reachable_symbols.insert(def_id.node);
+ }
+ Some(_) => {}
+ None => {
+ self.tcx.sess.span_bug(expr.span,
+ "method call expression \
+ not in method map?!")
+ }
+ }
+ }
+ _ => {}
+ }
+
+ visit::walk_expr(self, expr, ())
+ }
+}
+
+impl ReachableContext {
+ // Creates a new reachability computation context.
+ fn new(tcx: ty::ctxt, method_map: typeck::method_map)
+ -> ReachableContext {
+ ReachableContext {
+ tcx: tcx,
+ method_map: method_map,
+ reachable_symbols: @mut HashSet::new(),
+ worklist: @mut ~[],
+ }
+ }
+
+ // Step 1: Mark all public symbols, and add all public symbols that might
+ // be inlined to a worklist.
+ fn mark_public_symbols(&self, crate: @Crate) {
+ let reachable_symbols = self.reachable_symbols;
+ let worklist = self.worklist;
+
+ let mut visitor = ReachableVisitor {
+ reachable_symbols: reachable_symbols,
+ worklist: worklist,
+ };
+
+
+ visit::walk_crate(&mut visitor, crate, PublicContext);
}
// Returns true if the given def ID represents a local item that is
}
// Helper function to set up a visitor for `propagate()` below.
- fn init_visitor(&self) -> oldvisit::vt<()> {
+ fn init_visitor(&self) -> MarkSymbolVisitor {
let (worklist, method_map) = (self.worklist, self.method_map);
let (tcx, reachable_symbols) = (self.tcx, self.reachable_symbols);
- oldvisit::mk_vt(@oldvisit::Visitor {
- visit_expr: |expr, (_, visitor)| {
- match expr.node {
- expr_path(_) => {
- let def = match tcx.def_map.find(&expr.id) {
- Some(&def) => def,
- None => {
- tcx.sess.span_bug(expr.span,
- "def ID not in def map?!")
- }
- };
-
- let def_id = def_id_of_def(def);
- if ReachableContext::
- def_id_represents_local_inlined_item(tcx,
- def_id) {
- worklist.push(def_id.node)
- }
- reachable_symbols.insert(def_id.node);
- }
- expr_method_call(*) => {
- match method_map.find(&expr.id) {
- Some(&typeck::method_map_entry {
- origin: typeck::method_static(def_id),
- _
- }) => {
- if ReachableContext::
- def_id_represents_local_inlined_item(
- tcx,
- def_id) {
- worklist.push(def_id.node)
- }
- reachable_symbols.insert(def_id.node);
- }
- Some(_) => {}
- None => {
- tcx.sess.span_bug(expr.span,
- "method call expression \
- not in method map?!")
- }
- }
- }
- _ => {}
- }
- oldvisit::visit_expr(expr, ((), visitor))
- },
- ..*oldvisit::default_visitor()
- })
+ MarkSymbolVisitor {
+ worklist: worklist,
+ method_map: method_map,
+ tcx: tcx,
+ reachable_symbols: reachable_symbols,
+ }
}
// Step 2: Mark all symbols that the symbols on the worklist touch.
fn propagate(&self) {
- let visitor = self.init_visitor();
+ let mut visitor = self.init_visitor();
let mut scanned = HashSet::new();
while self.worklist.len() > 0 {
let search_item = self.worklist.pop();
Some(&ast_map::node_item(item, _)) => {
match item.node {
item_fn(_, _, _, _, ref search_block) => {
- oldvisit::visit_block(search_block, ((), visitor))
+ visit::walk_block(&mut visitor, search_block, ())
}
_ => {
self.tcx.sess.span_bug(item.span,
worklist?!")
}
provided(ref method) => {
- oldvisit::visit_block(&method.body, ((), visitor))
+ visit::walk_block(&mut visitor, &method.body, ())
}
}
}
Some(&ast_map::node_method(ref method, _, _)) => {
- oldvisit::visit_block(&method.body, ((), visitor))
+ visit::walk_block(&mut visitor, &method.body, ())
}
Some(_) => {
let ident_interner = token::get_ident_interner();
use syntax::print::pprust;
use syntax::parse::token;
use syntax::parse::token::special_idents;
-use syntax::{ast, oldvisit};
+use syntax::{ast, visit};
+use syntax::visit::{Visitor,fn_kind};
+use syntax::ast::{Block,item,fn_decl,NodeId,arm,pat,stmt,expr,Local};
+use syntax::ast::{Ty,TypeMethod,struct_field};
/**
The region maps encode information about region relationships.
}
}
-fn resolve_block(blk: &ast::Block,
- (cx, visitor): (Context, oldvisit::vt<Context>)) {
+fn resolve_block(visitor: &mut RegionResolutionVisitor,
+ blk: &ast::Block,
+ cx: Context) {
// Record the parent of this block.
parent_to_expr(cx, blk.id, blk.span);
let new_cx = Context {var_parent: Some(blk.id),
parent: Some(blk.id),
..cx};
- oldvisit::visit_block(blk, (new_cx, visitor));
+ visit::walk_block(visitor, blk, new_cx);
}
-fn resolve_arm(arm: &ast::arm,
- (cx, visitor): (Context, oldvisit::vt<Context>)) {
- oldvisit::visit_arm(arm, (cx, visitor));
+fn resolve_arm(visitor: &mut RegionResolutionVisitor,
+ arm: &ast::arm,
+ cx: Context) {
+ visit::walk_arm(visitor, arm, cx);
}
-fn resolve_pat(pat: @ast::pat,
- (cx, visitor): (Context, oldvisit::vt<Context>)) {
+fn resolve_pat(visitor: &mut RegionResolutionVisitor,
+ pat: @ast::pat,
+ cx: Context) {
assert_eq!(cx.var_parent, cx.parent);
parent_to_expr(cx, pat.id, pat.span);
- oldvisit::visit_pat(pat, (cx, visitor));
+ visit::walk_pat(visitor, pat, cx);
}
-fn resolve_stmt(stmt: @ast::stmt,
- (cx, visitor): (Context, oldvisit::vt<Context>)) {
+fn resolve_stmt(visitor: &mut RegionResolutionVisitor,
+ stmt: @ast::stmt,
+ cx: Context) {
match stmt.node {
ast::stmt_decl(*) => {
- oldvisit::visit_stmt(stmt, (cx, visitor));
+ visit::walk_stmt(visitor, stmt, cx);
}
ast::stmt_expr(_, stmt_id) |
ast::stmt_semi(_, stmt_id) => {
parent_to_expr(cx, stmt_id, stmt.span);
let expr_cx = Context {parent: Some(stmt_id), ..cx};
- oldvisit::visit_stmt(stmt, (expr_cx, visitor));
+ visit::walk_stmt(visitor, stmt, expr_cx);
}
ast::stmt_mac(*) => cx.sess.bug("unexpanded macro")
}
}
-fn resolve_expr(expr: @ast::expr,
- (cx, visitor): (Context, oldvisit::vt<Context>)) {
+fn resolve_expr(visitor: &mut RegionResolutionVisitor,
+ expr: @ast::expr,
+ cx: Context) {
parent_to_expr(cx, expr.id, expr.span);
let mut new_cx = cx;
};
- oldvisit::visit_expr(expr, (new_cx, visitor));
+ visit::walk_expr(visitor, expr, new_cx);
}
-fn resolve_local(local: @ast::Local,
- (cx, visitor): (Context, oldvisit::vt<Context>)) {
+fn resolve_local(visitor: &mut RegionResolutionVisitor,
+ local: @ast::Local,
+ cx: Context) {
assert_eq!(cx.var_parent, cx.parent);
parent_to_expr(cx, local.id, local.span);
- oldvisit::visit_local(local, (cx, visitor));
+ visit::walk_local(visitor, local, cx);
}
-fn resolve_item(item: @ast::item,
- (cx, visitor): (Context, oldvisit::vt<Context>)) {
+fn resolve_item(visitor: &mut RegionResolutionVisitor,
+ item: @ast::item,
+ cx: Context) {
// Items create a new outer block scope as far as we're concerned.
let new_cx = Context {var_parent: None, parent: None, ..cx};
- oldvisit::visit_item(item, (new_cx, visitor));
+ visit::walk_item(visitor, item, new_cx);
}
-fn resolve_fn(fk: &oldvisit::fn_kind,
+fn resolve_fn(visitor: &mut RegionResolutionVisitor,
+ fk: &visit::fn_kind,
decl: &ast::fn_decl,
body: &ast::Block,
sp: span,
id: ast::NodeId,
- (cx, visitor): (Context,
- oldvisit::vt<Context>)) {
+ cx: Context) {
debug!("region::resolve_fn(id=%?, \
span=%?, \
body.id=%?, \
var_parent: Some(body.id),
..cx};
match *fk {
- oldvisit::fk_method(_, _, method) => {
+ visit::fk_method(_, _, method) => {
cx.region_maps.record_parent(method.self_id, body.id);
}
_ => {}
}
- oldvisit::visit_fn_decl(decl, (decl_cx, visitor));
+ visit::walk_fn_decl(visitor, decl, decl_cx);
// The body of the fn itself is either a root scope (top-level fn)
// or it continues with the inherited scope (closures).
let body_cx = match *fk {
- oldvisit::fk_item_fn(*) |
- oldvisit::fk_method(*) => {
+ visit::fk_item_fn(*) |
+ visit::fk_method(*) => {
Context {parent: None, var_parent: None, ..cx}
}
- oldvisit::fk_anon(*) |
- oldvisit::fk_fn_block(*) => {
+ visit::fk_anon(*) |
+ visit::fk_fn_block(*) => {
cx
}
};
- (visitor.visit_block)(body, (body_cx, visitor));
+ visitor.visit_block(body, body_cx);
+}
+
+struct RegionResolutionVisitor;
+
+impl Visitor<Context> for RegionResolutionVisitor {
+
+ fn visit_block(&mut self, b:&Block, cx:Context) {
+ resolve_block(self, b, cx);
+ }
+
+ fn visit_item(&mut self, i:@item, cx:Context) {
+ resolve_item(self, i, cx);
+ }
+
+ fn visit_fn(&mut self, fk:&fn_kind, fd:&fn_decl, b:&Block, s:span, n:NodeId, cx:Context) {
+ resolve_fn(self, fk, fd, b, s, n, cx);
+ }
+ fn visit_arm(&mut self, a:&arm, cx:Context) {
+ resolve_arm(self, a, cx);
+ }
+ fn visit_pat(&mut self, p:@pat, cx:Context) {
+ resolve_pat(self, p, cx);
+ }
+ fn visit_stmt(&mut self, s:@stmt, cx:Context) {
+ resolve_stmt(self, s, cx);
+ }
+ fn visit_expr(&mut self, ex:@expr, cx:Context) {
+ resolve_expr(self, ex, cx);
+ }
+ fn visit_local(&mut self, l:@Local, cx:Context) {
+ resolve_local(self, l, cx);
+ }
}
pub fn resolve_crate(sess: Session,
region_maps: region_maps,
parent: None,
var_parent: None};
- let visitor = oldvisit::mk_vt(@oldvisit::Visitor {
- visit_block: resolve_block,
- visit_item: resolve_item,
- visit_fn: resolve_fn,
- visit_arm: resolve_arm,
- visit_pat: resolve_pat,
- visit_stmt: resolve_stmt,
- visit_expr: resolve_expr,
- visit_local: resolve_local,
- .. *oldvisit::default_visitor()
- });
- oldvisit::visit_crate(crate, (cx, visitor));
+ let mut visitor = RegionResolutionVisitor;
+ visit::walk_crate(&mut visitor, crate, cx);
return region_maps;
}
}
}
-fn determine_rp_in_item(item: @ast::item,
- (cx, visitor): (@mut DetermineRpCtxt,
- oldvisit::vt<@mut DetermineRpCtxt>)) {
+fn determine_rp_in_item(visitor: &mut DetermineRpVisitor,
+ item: @ast::item,
+ cx: @mut DetermineRpCtxt) {
do cx.with(item.id, true) {
- oldvisit::visit_item(item, (cx, visitor));
+ visit::walk_item(visitor, item, cx);
}
}
-fn determine_rp_in_fn(fk: &oldvisit::fn_kind,
+fn determine_rp_in_fn(visitor: &mut DetermineRpVisitor,
+ fk: &visit::fn_kind,
decl: &ast::fn_decl,
body: &ast::Block,
_: span,
_: ast::NodeId,
- (cx, visitor): (@mut DetermineRpCtxt,
- oldvisit::vt<@mut DetermineRpCtxt>)) {
+ cx: @mut DetermineRpCtxt) {
do cx.with(cx.item_id, false) {
do cx.with_ambient_variance(rv_contravariant) {
for a in decl.inputs.iter() {
- (visitor.visit_ty)(&a.ty, (cx, visitor));
+ visitor.visit_ty(&a.ty, cx);
}
}
- (visitor.visit_ty)(&decl.output, (cx, visitor));
- let generics = oldvisit::generics_of_fn(fk);
- (visitor.visit_generics)(&generics, (cx, visitor));
- (visitor.visit_block)(body, (cx, visitor));
+ visitor.visit_ty(&decl.output, cx);
+ let generics = visit::generics_of_fn(fk);
+ visitor.visit_generics(&generics, cx);
+ visitor.visit_block(body, cx);
}
}
-fn determine_rp_in_ty_method(ty_m: &ast::TypeMethod,
- (cx, visitor):
- (@mut DetermineRpCtxt,
- oldvisit::vt<@mut DetermineRpCtxt>)) {
+fn determine_rp_in_ty_method(visitor: &mut DetermineRpVisitor,
+ ty_m: &ast::TypeMethod,
+ cx: @mut DetermineRpCtxt) {
do cx.with(cx.item_id, false) {
- oldvisit::visit_ty_method(ty_m, (cx, visitor));
+ visit::walk_ty_method(visitor, ty_m, cx);
}
}
-fn determine_rp_in_ty(ty: &ast::Ty,
- (cx, visitor): (@mut DetermineRpCtxt,
- oldvisit::vt<@mut DetermineRpCtxt>)) {
+fn determine_rp_in_ty(visitor: &mut DetermineRpVisitor,
+ ty: &ast::Ty,
+ cx: @mut DetermineRpCtxt) {
// we are only interested in types that will require an item to
// be region-parameterized. if cx.item_id is zero, then this type
// is not a member of a type defn nor is it a constitutent of an
match ty.node {
ast::ty_box(ref mt) | ast::ty_uniq(ref mt) | ast::ty_vec(ref mt) |
ast::ty_rptr(_, ref mt) | ast::ty_ptr(ref mt) => {
- visit_mt(mt, (cx, visitor));
+ visit_mt(visitor, mt, cx);
}
ast::ty_path(ref path, _, _) => {
// type parameters are---for now, anyway---always invariant
do cx.with_ambient_variance(rv_invariant) {
for tp in path.types.iter() {
- (visitor.visit_ty)(tp, (cx, visitor));
+ visitor.visit_ty(tp, cx);
}
}
}
// parameters are contravariant
do cx.with_ambient_variance(rv_contravariant) {
for a in decl.inputs.iter() {
- (visitor.visit_ty)(&a.ty, (cx, visitor));
+ visitor.visit_ty(&a.ty, cx);
}
}
- (visitor.visit_ty)(&decl.output, (cx, visitor));
+ visitor.visit_ty(&decl.output, cx);
}
}
_ => {
- oldvisit::visit_ty(ty, (cx, visitor));
+ visit::walk_ty(visitor, ty, cx);
}
}
- fn visit_mt(mt: &ast::mt,
- (cx, visitor): (@mut DetermineRpCtxt,
- oldvisit::vt<@mut DetermineRpCtxt>)) {
+ fn visit_mt(visitor: &mut DetermineRpVisitor,
+ mt: &ast::mt,
+ cx: @mut DetermineRpCtxt) {
// mutability is invariant
if mt.mutbl == ast::m_mutbl {
do cx.with_ambient_variance(rv_invariant) {
- (visitor.visit_ty)(mt.ty, (cx, visitor));
+ visitor.visit_ty(mt.ty, cx);
}
} else {
- (visitor.visit_ty)(mt.ty, (cx, visitor));
+ visitor.visit_ty(mt.ty, cx);
}
}
}
-fn determine_rp_in_struct_field(
- cm: @ast::struct_field,
- (cx, visitor): (@mut DetermineRpCtxt,
- oldvisit::vt<@mut DetermineRpCtxt>)) {
- oldvisit::visit_struct_field(cm, (cx, visitor));
+fn determine_rp_in_struct_field(visitor: &mut DetermineRpVisitor,
+ cm: @ast::struct_field,
+ cx: @mut DetermineRpCtxt) {
+ visit::walk_struct_field(visitor, cm, cx);
+}
+
+struct DetermineRpVisitor;
+
+impl Visitor<@mut DetermineRpCtxt> for DetermineRpVisitor {
+
+ fn visit_fn(&mut self, fk:&fn_kind, fd:&fn_decl,
+ b:&Block, s:span, n:NodeId, e:@mut DetermineRpCtxt) {
+ determine_rp_in_fn(self, fk, fd, b, s, n, e);
+ }
+ fn visit_item(&mut self, i:@item, e:@mut DetermineRpCtxt) {
+ determine_rp_in_item(self, i, e);
+ }
+ fn visit_ty(&mut self, t:&Ty, e:@mut DetermineRpCtxt) {
+ determine_rp_in_ty(self, t, e);
+ }
+ fn visit_ty_method(&mut self, t:&TypeMethod, e:@mut DetermineRpCtxt) {
+ determine_rp_in_ty_method(self, t, e);
+ }
+ fn visit_struct_field(&mut self, s:@struct_field, e:@mut DetermineRpCtxt) {
+ determine_rp_in_struct_field(self, s, e);
+ }
+
}
pub fn determine_rp_in_crate(sess: Session,
};
// Gather up the base set, worklist and dep_map
- let visitor = oldvisit::mk_vt(@oldvisit::Visitor {
- visit_fn: determine_rp_in_fn,
- visit_item: determine_rp_in_item,
- visit_ty: determine_rp_in_ty,
- visit_ty_method: determine_rp_in_ty_method,
- visit_struct_field: determine_rp_in_struct_field,
- .. *oldvisit::default_visitor()
- });
- oldvisit::visit_crate(crate, (cx, visitor));
+ let mut visitor = DetermineRpVisitor;
+ visit::walk_crate(&mut visitor, crate, cx);
// Propagate indirect dependencies
//
use syntax::ast_util::{Privacy, Public, Private};
use syntax::ast_util::{variant_visibility_to_privacy, visibility_to_privacy};
use syntax::attr;
-use syntax::oldvisit::{mk_simple_visitor, default_simple_visitor};
-use syntax::oldvisit::{default_visitor, mk_vt, Visitor, visit_block};
-use syntax::oldvisit::{visit_crate, visit_expr, visit_expr_opt};
-use syntax::oldvisit::{visit_foreign_item, visit_item};
-use syntax::oldvisit::{visit_mod, visit_ty, vt, SimpleVisitor};
use syntax::parse::token;
use syntax::parse::token::ident_interner;
use syntax::parse::token::special_idents;
use syntax::print::pprust::path_to_str;
use syntax::codemap::{span, dummy_sp, BytePos};
use syntax::opt_vec::OptVec;
+use syntax::visit;
+use syntax::visit::Visitor;
use std::str;
use std::uint;
HasSelfBinding(NodeId, bool /* is implicit */)
}
-pub type ResolveVisitor = vt<()>;
+struct ResolveVisitor {
+ resolver: @mut Resolver,
+}
+
+impl Visitor<()> for ResolveVisitor {
+ fn visit_item(&mut self, item:@item, _:()) {
+ self.resolver.resolve_item(item, self);
+ }
+ fn visit_arm(&mut self, arm:&arm, _:()) {
+ self.resolver.resolve_arm(arm, self);
+ }
+ fn visit_block(&mut self, block:&Block, _:()) {
+ self.resolver.resolve_block(block, self);
+ }
+ fn visit_expr(&mut self, expr:@expr, _:()) {
+ self.resolver.resolve_expr(expr, self);
+ }
+ fn visit_local(&mut self, local:@Local, _:()) {
+ self.resolver.resolve_local(local, self);
+ }
+ fn visit_ty(&mut self, ty:&Ty, _:()) {
+ self.resolver.resolve_type(ty, self);
+ }
+}
/// Contains data for specific types of import directives.
pub enum ImportDirectiveSubclass {
trait_map: HashMap::new(),
used_imports: HashSet::new(),
+ emit_errors: true,
intr: session.intr()
};
export_map2: ExportMap2,
trait_map: TraitMap,
+ // Whether or not to print error messages. Can be set to true
+ // when getting additional info for error message suggestions,
+ // so as to avoid printing duplicate errors
+ emit_errors: bool,
+
used_imports: HashSet<NodeId>,
}
+struct BuildReducedGraphVisitor {
+ resolver: @mut Resolver,
+}
+
+impl Visitor<ReducedGraphParent> for BuildReducedGraphVisitor {
+
+ fn visit_item(&mut self, item:@item, context:ReducedGraphParent) {
+ self.resolver.build_reduced_graph_for_item(item, (context, self));
+ }
+
+ fn visit_foreign_item(&mut self, foreign_item:@foreign_item, context:ReducedGraphParent) {
+ self.resolver.build_reduced_graph_for_foreign_item(foreign_item,
+ (context,
+ self));
+ }
+
+ fn visit_view_item(&mut self, view_item:&view_item, context:ReducedGraphParent) {
+ self.resolver.build_reduced_graph_for_view_item(view_item,
+ (context,
+ self));
+ }
+
+ fn visit_block(&mut self, block:&Block, context:ReducedGraphParent) {
+ self.resolver.build_reduced_graph_for_block(block,
+ (context,
+ self));
+ }
+
+}
+
+struct UnusedImportCheckVisitor { resolver: @mut Resolver }
+
+impl Visitor<()> for UnusedImportCheckVisitor {
+ fn visit_view_item(&mut self, vi:&view_item, _:()) {
+ self.resolver.check_for_item_unused_imports(vi);
+ visit::walk_view_item(self, vi, ());
+ }
+}
+
impl Resolver {
/// The main name resolution procedure.
pub fn resolve(@mut self) {
pub fn build_reduced_graph(@mut self) {
let initial_parent =
ModuleReducedGraphParent(self.graph_root.get_module());
- visit_crate(self.crate, (initial_parent, mk_vt(@Visitor {
- visit_item: |item, (context, visitor)|
- self.build_reduced_graph_for_item(item, (context, visitor)),
-
- visit_foreign_item: |foreign_item, (context, visitor)|
- self.build_reduced_graph_for_foreign_item(foreign_item,
- (context,
- visitor)),
-
- visit_view_item: |view_item, (context, visitor)|
- self.build_reduced_graph_for_view_item(view_item,
- (context,
- visitor)),
-
- visit_block: |block, (context, visitor)|
- self.build_reduced_graph_for_block(block,
- (context,
- visitor)),
- .. *default_visitor()
- })));
+ let mut visitor = BuildReducedGraphVisitor { resolver: self, };
+ visit::walk_crate(&mut visitor, self.crate, initial_parent);
}
/// Returns the current module tracked by the reduced graph parent.
// Return an error here by looking up the namespace that
// had the duplicate.
let ns = ns.unwrap();
- self.session.span_err(sp,
+ self.resolve_error(sp,
fmt!("duplicate definition of %s `%s`",
namespace_error_to_str(duplicate_type),
self.session.str_of(name)));
pub fn build_reduced_graph_for_item(@mut self,
item: @item,
(parent, visitor): (ReducedGraphParent,
- vt<ReducedGraphParent>)) {
+ &mut BuildReducedGraphVisitor)) {
let ident = item.ident;
let sp = item.span;
let privacy = visibility_to_privacy(item.vis);
let new_parent =
ModuleReducedGraphParent(name_bindings.get_module());
- visit_mod(module_, sp, item.id, (new_parent, visitor));
+ visit::walk_mod(visitor, module_, new_parent);
}
item_foreign_mod(ref fm) => {
anonymous => parent
};
- visit_item(item, (new_parent, visitor));
+ visit::walk_item(visitor, item, new_parent);
}
// These items live in the value namespace.
let def = def_fn(local_def(item.id), purity);
name_bindings.define_value(privacy, def, sp);
- visit_item(item, (new_parent, visitor));
+ visit::walk_item(visitor, item, new_parent);
}
// These items live in the type namespace.
// inherited => privacy of the enum item
variant_visibility_to_privacy(variant.node.vis,
privacy == Public),
- (new_parent, visitor));
+ new_parent, visitor);
}
}
// Record the def ID of this struct.
self.structs.insert(local_def(item.id));
- visit_item(item, (new_parent, visitor));
+ visit::walk_item(visitor, item, new_parent);
}
item_impl(_, None, ref ty, ref methods) => {
_ => {}
}
- visit_item(item, (parent, visitor));
+ visit::walk_item(visitor, item, parent);
}
item_impl(_, Some(_), _, _) => {
- visit_item(item, (parent, visitor));
+ visit::walk_item(visitor, item, parent);
}
item_trait(_, _, ref methods) => {
}
name_bindings.define_type(privacy, def_trait(def_id), sp);
- visit_item(item, (new_parent, visitor));
+ visit::walk_item(visitor, item, new_parent);
}
item_mac(*) => {
variant: &variant,
item_id: def_id,
parent_privacy: Privacy,
- (parent, _visitor):
- (ReducedGraphParent,
- vt<ReducedGraphParent>)) {
+ parent: ReducedGraphParent,
+ _: &mut BuildReducedGraphVisitor) {
let ident = variant.node.name;
let privacy =
view_item: &view_item,
(parent, _):
(ReducedGraphParent,
- vt<ReducedGraphParent>)) {
+ &mut BuildReducedGraphVisitor)) {
let privacy = visibility_to_privacy(view_item.vis);
match view_item.node {
view_item_use(ref view_paths) => {
foreign_item: @foreign_item,
(parent, visitor):
(ReducedGraphParent,
- vt<ReducedGraphParent>)) {
+ &mut BuildReducedGraphVisitor)) {
let name = foreign_item.ident;
let (name_bindings, new_parent) =
self.add_child(name, parent, ForbidDuplicateValues,
HasTypeParameters(
generics, foreign_item.id, 0, NormalRibKind))
{
- visit_foreign_item(foreign_item, (new_parent, visitor));
+ visit::walk_foreign_item(visitor, foreign_item, new_parent);
}
}
foreign_item_static(_, m) => {
let def = def_static(local_def(foreign_item.id), m);
name_bindings.define_value(Public, def, foreign_item.span);
- visit_foreign_item(foreign_item, (new_parent, visitor));
+ visit::walk_foreign_item(visitor, foreign_item, new_parent);
}
}
}
block: &Block,
(parent, visitor):
(ReducedGraphParent,
- vt<ReducedGraphParent>)) {
+ &mut BuildReducedGraphVisitor)) {
let new_parent;
if self.block_needs_anonymous_module(block) {
let block_id = block.id;
new_parent = parent;
}
- visit_block(block, (new_parent, visitor));
+ visit::walk_block(visitor, block, new_parent);
}
pub fn handle_external_def(@mut self,
self.import_path_to_str(
import_directive.module_path,
*import_directive.subclass));
- self.session.span_err(import_directive.span, msg);
+ self.resolve_error(import_directive.span, msg);
}
Indeterminate => {
// Bail out. We'll come around next time.
// We need to resolve both namespaces for this to succeed.
//
- // FIXME #4949: See if there's some way of handling namespaces in
- // a more generic way. We have two of them; it seems worth
- // doing...
let mut value_result = UnknownResult;
let mut type_result = UnknownResult;
let span = directive.span;
if resolve_fail {
- self.session.span_err(span, fmt!("unresolved import: there is no `%s` in `%s`",
+ self.resolve_error(span, fmt!("unresolved import: there is no `%s` in `%s`",
self.session.str_of(source),
self.module_to_str(containing_module)));
return Failed;
} else if priv_fail {
- self.session.span_err(span, fmt!("unresolved import: found `%s` in `%s` but it is \
+ self.resolve_error(span, fmt!("unresolved import: found `%s` in `%s` but it is \
private", self.session.str_of(source),
self.module_to_str(containing_module)));
return Failed;
hi: span.lo + BytePos(segment_name.len()),
expn_info: span.expn_info,
};
- self.session.span_err(span,
+ self.resolve_error(span,
fmt!("unresolved import. maybe \
a missing `extern mod \
%s`?",
segment_name));
return Failed;
}
- self.session.span_err(span, fmt!("unresolved import: could not find `%s` in \
+ self.resolve_error(span, fmt!("unresolved import: could not find `%s` in \
`%s`.", segment_name, module_name));
return Failed;
}
match type_def.module_def {
None => {
// Not a module.
- self.session.span_err(span,
+ self.resolve_error(span,
fmt!("not a \
module `%s`",
self.session.
module_def.kind) {
(ImportSearch, TraitModuleKind) |
(ImportSearch, ImplModuleKind) => {
- self.session.span_err(
+ self.resolve_error(
span,
"cannot import from a trait \
or type implementation");
}
None => {
// There are no type bindings at all.
- self.session.span_err(span,
+ self.resolve_error(span,
fmt!("not a module `%s`",
self.session.str_of(
name)));
let mpath = self.idents_to_str(module_path);
match mpath.rfind(':') {
Some(idx) => {
- self.session.span_err(span, fmt!("unresolved import: could not find `%s` \
+ self.resolve_error(span, fmt!("unresolved import: could not find `%s` \
in `%s`",
// idx +- 1 to account for the colons
// on either side
module_path[0]);
match result {
Failed => {
- self.session.span_err(span,
- "unresolved name");
+ self.resolve_error(span, "unresolved name");
return Failed;
}
Indeterminate => {
if index != import_count {
let sn = self.session.codemap.span_to_snippet(imports[index].span).unwrap();
if sn.contains("::") {
- self.session.span_err(imports[index].span, "unresolved import");
+ self.resolve_error(imports[index].span, "unresolved import");
} else {
let err = fmt!("unresolved import (maybe you meant `%s::*`?)",
sn.slice(0, sn.len()));
- self.session.span_err(imports[index].span, err);
+ self.resolve_error(imports[index].span, err);
}
}
// named function item. This is not allowed, so we
// report an error.
- self.session.span_err(
+ self.resolve_error(
span,
"can't capture dynamic environment in a fn item; \
use the || { ... } closure form instead");
// This was an attempt to use a type parameter outside
// its scope.
- self.session.span_err(span,
+ self.resolve_error(span,
"attempt to use a type \
argument out of scope");
}
// named function item. This is not allowed, so we
// report an error.
- self.session.span_err(
+ self.resolve_error(
span,
"can't capture dynamic environment in a fn item; \
use the || { ... } closure form instead");
// This was an attempt to use a type parameter outside
// its scope.
- self.session.span_err(span,
+ self.resolve_error(span,
"attempt to use a type \
argument out of scope");
}
}
ConstantItemRibKind => {
// Still doesn't deal with upvars
- self.session.span_err(span,
+ self.resolve_error(span,
"attempt to use a non-constant \
value in a constant");
pub fn resolve_crate(@mut self) {
debug!("(resolving crate) starting");
- visit_crate(self.crate, ((), mk_vt(@Visitor {
- visit_item: |item, (_context, visitor)|
- self.resolve_item(item, visitor),
- visit_arm: |arm, (_context, visitor)|
- self.resolve_arm(arm, visitor),
- visit_block: |block, (_context, visitor)|
- self.resolve_block(block, visitor),
- visit_expr: |expr, (_context, visitor)|
- self.resolve_expr(expr, visitor),
- visit_local: |local, (_context, visitor)|
- self.resolve_local(local, visitor),
- visit_ty: |ty, (_context, visitor)|
- self.resolve_type(ty, visitor),
- .. *default_visitor()
- })));
+ let mut visitor = ResolveVisitor{ resolver: self };
+ visit::walk_crate(&mut visitor, self.crate, ());
}
- pub fn resolve_item(@mut self, item: @item, visitor: ResolveVisitor) {
+ pub fn resolve_item(@mut self, item: @item, visitor: &mut ResolveVisitor) {
debug!("(resolving item) resolving %s",
self.session.str_of(item.ident));
do self.with_type_parameter_rib(
HasTypeParameters(
generics, item.id, 0, NormalRibKind)) {
- visit_item(item, ((), visitor));
+ visit::walk_item(visitor, item, ());
}
}
NormalRibKind))
|| {
- visit_item(item, ((), visitor));
+ visit::walk_item(visitor, item, ());
}
}
HasTypeParameters(
generics, foreign_item.id, 0,
NormalRibKind),
- || visit_foreign_item(*foreign_item,
- ((), visitor)));
+ || visit::walk_foreign_item(visitor,
+ *foreign_item,
+ ()));
}
foreign_item_static(*) => {
- visit_foreign_item(*foreign_item,
- ((), visitor));
+ visit::walk_foreign_item(visitor,
+ *foreign_item,
+ ());
}
}
}
item_static(*) => {
self.with_constant_rib(|| {
- visit_item(item, ((), visitor));
+ visit::walk_item(visitor, item, ());
});
}
type_parameters: TypeParameters,
block: &Block,
self_binding: SelfBinding,
- visitor: ResolveVisitor) {
+ visitor: &mut ResolveVisitor) {
// Create a value rib for the function.
let function_value_rib = @Rib(rib_kind);
self.value_ribs.push(function_value_rib);
pub fn resolve_type_parameters(@mut self,
type_parameters: &OptVec<TyParam>,
- visitor: ResolveVisitor) {
+ visitor: &mut ResolveVisitor) {
for type_parameter in type_parameters.iter() {
for bound in type_parameter.bounds.iter() {
self.resolve_type_parameter_bound(type_parameter.id, bound, visitor);
pub fn resolve_type_parameter_bound(@mut self,
id: NodeId,
type_parameter_bound: &TyParamBound,
- visitor: ResolveVisitor) {
+ visitor: &mut ResolveVisitor) {
match *type_parameter_bound {
TraitTyParamBound(ref tref) => {
self.resolve_trait_reference(id, tref, visitor, TraitBoundingTypeParameter)
pub fn resolve_trait_reference(@mut self,
id: NodeId,
trait_reference: &trait_ref,
- visitor: ResolveVisitor,
+ visitor: &mut ResolveVisitor,
reference_type: TraitReferenceType) {
match self.resolve_path(id, &trait_reference.path, TypeNS, true, visitor) {
None => {
};
let msg = fmt!("attempt to %s a nonexistent trait `%s`", usage_str, path_str);
- self.session.span_err(trait_reference.path.span, msg);
+ self.resolve_error(trait_reference.path.span, msg);
}
Some(def) => {
debug!("(resolving trait) found trait def: %?", def);
id: NodeId,
generics: &Generics,
fields: &[@struct_field],
- visitor: ResolveVisitor) {
+ visitor: &mut ResolveVisitor) {
let mut ident_map = HashMap::new::<ast::ident, @struct_field>();
for &field in fields.iter() {
match field.node.kind {
match ident_map.find(&ident) {
Some(&prev_field) => {
let ident_str = self.session.str_of(ident);
- self.session.span_err(field.span,
+ self.resolve_error(field.span,
fmt!("field `%s` is already declared", ident_str));
self.session.span_note(prev_field.span,
"Previously declared here");
rib_kind: RibKind,
method: @method,
outer_type_parameter_count: uint,
- visitor: ResolveVisitor) {
+ visitor: &mut ResolveVisitor) {
let method_generics = &method.generics;
let type_parameters =
HasTypeParameters(method_generics,
opt_trait_reference: &Option<trait_ref>,
self_type: &Ty,
methods: &[@method],
- visitor: ResolveVisitor) {
+ visitor: &mut ResolveVisitor) {
// If applicable, create a rib for the type parameters.
let outer_type_parameter_count = generics.ty_params.len();
do self.with_type_parameter_rib(HasTypeParameters
pub fn resolve_module(@mut self,
module_: &_mod,
- span: span,
+ _span: span,
_name: ident,
id: NodeId,
- visitor: ResolveVisitor) {
+ visitor: &mut ResolveVisitor) {
// Write the implementations in scope into the module metadata.
debug!("(resolving module) resolving module ID %d", id);
- visit_mod(module_, span, id, ((), visitor));
+ visit::walk_mod(visitor, module_, ());
}
- pub fn resolve_local(@mut self, local: @Local, visitor: ResolveVisitor) {
+ pub fn resolve_local(@mut self, local: @Local, visitor: &mut ResolveVisitor) {
let mutability = if local.is_mutbl {Mutable} else {Immutable};
// Resolve the type.
for (&key, &binding_0) in map_0.iter() {
match map_i.find(&key) {
None => {
- self.session.span_err(
+ self.resolve_error(
p.span,
fmt!("variable `%s` from pattern #1 is \
not bound in pattern #%u",
}
Some(binding_i) => {
if binding_0.binding_mode != binding_i.binding_mode {
- self.session.span_err(
+ self.resolve_error(
binding_i.span,
fmt!("variable `%s` is bound with different \
mode in pattern #%u than in pattern #1",
for (&key, &binding) in map_i.iter() {
if !map_0.contains_key(&key) {
- self.session.span_err(
+ self.resolve_error(
binding.span,
fmt!("variable `%s` from pattern #%u is \
not bound in pattern #1",
}
}
- pub fn resolve_arm(@mut self, arm: &arm, visitor: ResolveVisitor) {
+ pub fn resolve_arm(@mut self, arm: &arm, visitor: &mut ResolveVisitor) {
self.value_ribs.push(@Rib(NormalRibKind));
let bindings_list = @mut HashMap::new();
// pat_idents are variants
self.check_consistent_bindings(arm);
- visit_expr_opt(arm.guard, ((), visitor));
+ visit::walk_expr_opt(visitor, arm.guard, ());
self.resolve_block(&arm.body, visitor);
self.value_ribs.pop();
}
- pub fn resolve_block(@mut self, block: &Block, visitor: ResolveVisitor) {
+ pub fn resolve_block(@mut self, block: &Block, visitor: &mut ResolveVisitor) {
debug!("(resolving block) entering block");
self.value_ribs.push(@Rib(NormalRibKind));
}
// Descend into the block.
- visit_block(block, ((), visitor));
+ visit::walk_block(visitor, block, ());
// Move back up.
self.current_module = orig_module;
debug!("(resolving block) leaving block");
}
- pub fn resolve_type(@mut self, ty: &Ty, visitor: ResolveVisitor) {
+ pub fn resolve_type(@mut self, ty: &Ty, visitor: &mut ResolveVisitor) {
match ty.node {
// Like path expressions, the interpretation of path types depends
// on whether the path has multiple elements in it or not.
self.record_def(path_id, def);
}
None => {
- self.session.span_err
+ self.resolve_error
(ty.span, fmt!("use of undeclared type name `%s`",
self.idents_to_str(path.idents)));
}
self.resolve_type_parameter_bound(ty.id, bound, visitor);
}
};
- visit_ty(ty, ((), visitor));
+ visit::walk_ty(visitor, ty, ());
}
_ => {
// Just resolve embedded types.
- visit_ty(ty, ((), visitor));
+ visit::walk_ty(visitor, ty, ());
}
}
}
// Maps idents to the node ID for the (outermost)
// pattern that binds them
bindings_list: Option<@mut HashMap<ident,NodeId>>,
- visitor: ResolveVisitor) {
+ visitor: &mut ResolveVisitor) {
let pat_id = pattern.id;
do walk_pat(pattern) |pattern| {
match pattern.node {
self.record_def(pattern.id, def);
}
FoundStructOrEnumVariant(_) => {
- self.session.span_err(pattern.span,
+ self.resolve_error(pattern.span,
fmt!("declaration of `%s` \
shadows an enum \
variant or unit-like \
self.record_def(pattern.id, def);
}
FoundConst(_) => {
- self.session.span_err(pattern.span,
+ self.resolve_error(pattern.span,
"only refutable patterns \
allowed here");
}
// Then this is a duplicate variable
// in the same disjunct, which is an
// error
- self.session.span_err(pattern.span,
+ self.resolve_error(pattern.span,
fmt!("Identifier `%s` is bound more \
than once in the same pattern",
path_to_str(path, self.session
self.record_def(pattern.id, def);
}
Some(_) => {
- self.session.span_err(
+ self.resolve_error(
path.span,
fmt!("`%s` is not an enum variant or constant",
self.session.str_of(
*path.idents.last())));
}
None => {
- self.session.span_err(path.span,
+ self.resolve_error(path.span,
"unresolved enum variant");
}
}
self.record_def(pattern.id, def);
}
Some(_) => {
- self.session.span_err(
+ self.resolve_error(
path.span,
fmt!("`%s` is not an enum variant, struct or const",
self.session.str_of(
*path.idents.last())));
}
None => {
- self.session.span_err(path.span,
+ self.resolve_error(path.span,
"unresolved enum variant, \
struct or const");
}
result => {
debug!("(resolving pattern) didn't find struct \
def: %?", result);
- self.session.span_err(
+ self.resolve_error(
path.span,
fmt!("`%s` does not name a structure",
self.idents_to_str(path.idents)));
path: &Path,
namespace: Namespace,
check_ribs: bool,
- visitor: ResolveVisitor)
+ visitor: &mut ResolveVisitor)
-> Option<def> {
// First, resolve the types.
for ty in path.types.iter() {
path.span,
PathPublicOnlySearch) {
Failed => {
- self.session.span_err(path.span,
+ self.resolve_error(path.span,
fmt!("use of undeclared module `%s`",
self.idents_to_str(
module_path_idents)));
path.span,
PathPublicOrPrivateSearch) {
Failed => {
- self.session.span_err(path.span,
+ self.resolve_error(path.span,
fmt!("use of undeclared module `::%s`",
self.idents_to_str(
module_path_idents)));
}
}
+ fn with_no_errors<T>(@mut self, f: &fn() -> T) -> T {
+ self.emit_errors = false;
+ let rs = f();
+ self.emit_errors = true;
+ rs
+ }
+
+ fn resolve_error(@mut self, span: span, s: &str) {
+ if self.emit_errors {
+ self.session.span_err(span, s);
+ }
+ }
+
pub fn find_best_match_for_name(@mut self,
name: &str,
max_distance: uint)
return false;
}
- pub fn resolve_expr(@mut self, expr: @expr, visitor: ResolveVisitor) {
+ pub fn resolve_expr(@mut self, expr: @expr, visitor: &mut ResolveVisitor) {
// First, record candidate traits for this expression if it could
// result in the invocation of a method call.
// out here.
match def {
def_method(*) => {
- self.session.span_err(expr.span,
+ self.resolve_error(expr.span,
"first-class methods \
are not supported");
self.session.span_note(expr.span,
let wrong_name = self.idents_to_str(
path.idents);
if self.name_exists_in_scope_struct(wrong_name) {
- self.session.span_err(expr.span,
+ self.resolve_error(expr.span,
fmt!("unresolved name `%s`. \
Did you mean `self.%s`?",
wrong_name,
wrong_name));
}
else {
- // limit search to 5 to reduce the number
- // of stupid suggestions
- match self.find_best_match_for_name(wrong_name, 5) {
- Some(m) => {
- self.session.span_err(expr.span,
- fmt!("unresolved name `%s`. \
- Did you mean `%s`?",
- wrong_name, m));
- }
- None => {
- self.session.span_err(expr.span,
- fmt!("unresolved name `%s`.",
- wrong_name));
+ // Be helpful if the name refers to a struct
+ // (The pattern matching def_tys where the id is in self.structs
+ // matches on regular structs while excluding tuple- and enum-like
+ // structs, which wouldn't result in this error.)
+ match self.with_no_errors(||
+ self.resolve_path(expr.id, path, TypeNS, false, visitor)) {
+ Some(def_ty(struct_id))
+ if self.structs.contains(&struct_id) => {
+ self.resolve_error(expr.span,
+ fmt!("`%s` is a structure name, but this expression \
+ uses it like a function name", wrong_name));
+
+ self.session.span_note(expr.span, fmt!("Did you mean to write: \
+ `%s { /* fields */ }`?", wrong_name));
+
}
+ _ =>
+ // limit search to 5 to reduce the number
+ // of stupid suggestions
+ match self.find_best_match_for_name(wrong_name, 5) {
+ Some(m) => {
+ self.resolve_error(expr.span,
+ fmt!("unresolved name `%s`. \
+ Did you mean `%s`?",
+ wrong_name, m));
+ }
+ None => {
+ self.resolve_error(expr.span,
+ fmt!("unresolved name `%s`.",
+ wrong_name));
+ }
+ }
}
}
}
}
- visit_expr(expr, ((), visitor));
+ visit::walk_expr(visitor, expr, ());
}
expr_fn_block(ref fn_decl, ref block) => {
result => {
debug!("(resolving expression) didn't find struct \
def: %?", result);
- self.session.span_err(
+ self.resolve_error(
path.span,
fmt!("`%s` does not name a structure",
self.idents_to_str(path.idents)));
}
}
- visit_expr(expr, ((), visitor));
+ visit::walk_expr(visitor, expr, ());
}
expr_loop(_, Some(label)) => {
rib.bindings.insert(label, def_like);
}
- visit_expr(expr, ((), visitor));
+ visit::walk_expr(visitor, expr, ());
}
}
match self.search_ribs(self.label_ribs, label, expr.span,
DontAllowCapturingSelf) {
None =>
- self.session.span_err(expr.span,
+ self.resolve_error(expr.span,
fmt!("use of undeclared label \
`%s`",
self.session.str_of(
expr_self => {
match self.resolve_self_value_in_local_ribs(expr.span) {
None => {
- self.session.span_err(expr.span,
+ self.resolve_error(expr.span,
"`self` is not allowed in \
this context")
}
}
_ => {
- visit_expr(expr, ((), visitor));
+ visit::walk_expr(visitor, expr, ());
}
}
}
match pat_binding_mode {
bind_infer => {}
bind_by_ref(*) => {
- self.session.span_err(
+ self.resolve_error(
pat.span,
fmt!("cannot use `ref` binding mode with %s",
descr));
//
pub fn check_for_unused_imports(@mut self) {
- let vt = mk_simple_visitor(@SimpleVisitor {
- visit_view_item: |vi| self.check_for_item_unused_imports(vi),
- .. *default_simple_visitor()
- });
- visit_crate(self.crate, ((), vt));
+ let mut visitor = UnusedImportCheckVisitor{ resolver: self };
+ visit::walk_crate(&mut visitor, self.crate, ());
}
pub fn check_for_item_unused_imports(&mut self, vi: &view_item) {
--- /dev/null
+// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+/*!
+
+Lint mode to detect cases where we call non-Rust fns, which do not
+have a stack growth check, from locations not annotated to request
+large stacks.
+
+*/
+
+use middle::lint;
+use middle::ty;
+use syntax::ast;
+use syntax::ast_map;
+use syntax::attr;
+use syntax::codemap::span;
+use visit = syntax::oldvisit;
+use util::ppaux::Repr;
+
+#[deriving(Clone)]
+struct Context {
+ tcx: ty::ctxt,
+ safe_stack: bool
+}
+
+pub fn stack_check_crate(tcx: ty::ctxt,
+ crate: &ast::Crate) {
+ let new_cx = Context {
+ tcx: tcx,
+ safe_stack: false
+ };
+ let visitor = visit::mk_vt(@visit::Visitor {
+ visit_item: stack_check_item,
+ visit_fn: stack_check_fn,
+ visit_expr: stack_check_expr,
+ ..*visit::default_visitor()
+ });
+ visit::visit_crate(crate, (new_cx, visitor));
+}
+
+fn stack_check_item(item: @ast::item,
+ (in_cx, v): (Context, visit::vt<Context>)) {
+ match item.node {
+ ast::item_fn(_, ast::extern_fn, _, _, _) => {
+ // an extern fn is already being called from C code...
+ let new_cx = Context {safe_stack: true, ..in_cx};
+ visit::visit_item(item, (new_cx, v));
+ }
+ ast::item_fn(*) => {
+ let safe_stack = fixed_stack_segment(item.attrs);
+ let new_cx = Context {safe_stack: safe_stack, ..in_cx};
+ visit::visit_item(item, (new_cx, v));
+ }
+ ast::item_impl(_, _, _, ref methods) => {
+ // visit_method() would make this nicer
+ for &method in methods.iter() {
+ let safe_stack = fixed_stack_segment(method.attrs);
+ let new_cx = Context {safe_stack: safe_stack, ..in_cx};
+ visit::visit_method_helper(method, (new_cx, v));
+ }
+ }
+ _ => {
+ visit::visit_item(item, (in_cx, v));
+ }
+ }
+
+ fn fixed_stack_segment(attrs: &[ast::Attribute]) -> bool {
+ attr::contains_name(attrs, "fixed_stack_segment")
+ }
+}
+
+fn stack_check_fn<'a>(fk: &visit::fn_kind,
+ decl: &ast::fn_decl,
+ body: &ast::Block,
+ sp: span,
+ id: ast::NodeId,
+ (in_cx, v): (Context, visit::vt<Context>)) {
+ let safe_stack = match *fk {
+ visit::fk_method(*) | visit::fk_item_fn(*) => {
+ in_cx.safe_stack // see stack_check_item above
+ }
+ visit::fk_anon(*) | visit::fk_fn_block => {
+ match ty::get(ty::node_id_to_type(in_cx.tcx, id)).sty {
+ ty::ty_bare_fn(*) |
+ ty::ty_closure(ty::ClosureTy {sigil: ast::OwnedSigil, _}) |
+ ty::ty_closure(ty::ClosureTy {sigil: ast::ManagedSigil, _}) => {
+ false
+ }
+ _ => {
+ in_cx.safe_stack
+ }
+ }
+ }
+ };
+ let new_cx = Context {safe_stack: safe_stack, ..in_cx};
+ debug!("stack_check_fn(safe_stack=%b, id=%?)", safe_stack, id);
+ visit::visit_fn(fk, decl, body, sp, id, (new_cx, v));
+}
+
+fn stack_check_expr<'a>(expr: @ast::expr,
+ (cx, v): (Context, visit::vt<Context>)) {
+ debug!("stack_check_expr(safe_stack=%b, expr=%s)",
+ cx.safe_stack, expr.repr(cx.tcx));
+ if !cx.safe_stack {
+ match expr.node {
+ ast::expr_call(callee, _, _) => {
+ let callee_ty = ty::expr_ty(cx.tcx, callee);
+ debug!("callee_ty=%s", callee_ty.repr(cx.tcx));
+ match ty::get(callee_ty).sty {
+ ty::ty_bare_fn(ref fty) => {
+ if !fty.abis.is_rust() && !fty.abis.is_intrinsic() {
+ call_to_extern_fn(cx, callee);
+ }
+ }
+ _ => {}
+ }
+ }
+ _ => {}
+ }
+ }
+ visit::visit_expr(expr, (cx, v));
+}
+
+fn call_to_extern_fn(cx: Context, callee: @ast::expr) {
+ // Permit direct calls to extern fns that are annotated with
+ // #[rust_stack]. This is naturally a horrible pain to achieve.
+ match callee.node {
+ ast::expr_path(*) => {
+ match cx.tcx.def_map.find(&callee.id) {
+ Some(&ast::def_fn(id, _)) if id.crate == ast::LOCAL_CRATE => {
+ match cx.tcx.items.find(&id.node) {
+ Some(&ast_map::node_foreign_item(item, _, _, _)) => {
+ if attr::contains_name(item.attrs, "rust_stack") {
+ return;
+ }
+ }
+ _ => {}
+ }
+ }
+ _ => {}
+ }
+ }
+ _ => {}
+ }
+
+ cx.tcx.sess.add_lint(lint::cstack,
+ callee.id,
+ callee.span,
+ fmt!("invoking non-Rust fn in fn without \
+ #[fixed_stack_segment]"));
+}
bindings_map: @BindingsMap
}
+/**
+ * Info about Match.
+ * If all `pats` are matched then arm `data` will be executed.
+ * As we proceed `bound_ptrs` are filled with pointers to values to be bound,
+ * these pointers are stored in llmatch variables just before executing `data` arm.
+ */
#[deriving(Clone)]
struct Match<'self> {
pats: ~[@ast::pat],
- data: ArmData<'self>
+ data: ArmData<'self>,
+ bound_ptrs: ~[(ident, ValueRef)]
}
impl<'self> Repr for Match<'self> {
br.pats.slice(col + 1u,
br.pats.len())));
- let binding_info =
- br.data.bindings_map.get(&path_to_ident(path));
-
- Store(bcx, val, binding_info.llmatch);
- Match {
+ let mut res = Match {
pats: pats,
- data: br.data.clone()
- }
+ data: br.data.clone(),
+ bound_ptrs: br.bound_ptrs.clone()
+ };
+ res.bound_ptrs.push((path_to_ident(path), val));
+ res
}
_ => (*br).clone(),
}
br.pats.slice(col + 1u, br.pats.len()));
let this = br.pats[col];
+ let mut bound_ptrs = br.bound_ptrs.clone();
match this.node {
ast::pat_ident(_, ref path, None) => {
if pat_is_binding(dm, this) {
- let binding_info =
- br.data.bindings_map.get(
- &path_to_ident(path));
- Store(bcx, val, binding_info.llmatch);
+ bound_ptrs.push((path_to_ident(path), val));
}
}
_ => {}
result.push(Match {
pats: pats,
- data: br.data.clone()
+ data: br.data.clone(),
+ bound_ptrs: bound_ptrs
});
}
None => ()
fn insert_lllocals(bcx: @mut Block,
bindings_map: &BindingsMap,
- binding_mode: IrrefutablePatternBindingMode,
add_cleans: bool) -> @mut Block {
/*!
* For each binding in `data.bindings_map`, adds an appropriate entry into
* the bindings.
*/
- let llmap = match binding_mode {
- BindLocal => bcx.fcx.lllocals,
- BindArgument => bcx.fcx.llargs
- };
+ let llmap = bcx.fcx.lllocals;
for (&ident, &binding_info) in bindings_map.iter() {
let llval = match binding_info.trmode {
bcx = store_non_ref_bindings(bcx,
data.bindings_map,
Some(&mut temp_cleanups));
- bcx = insert_lllocals(bcx, data.bindings_map, BindLocal, false);
+ bcx = insert_lllocals(bcx, data.bindings_map, false);
let val = unpack_result!(bcx, {
do with_scope_result(bcx, guard_expr.info(),
}
if m[0].pats.len() == 0u {
let data = &m[0].data;
+ for &(ref ident, ref value_ptr) in m[0].bound_ptrs.iter() {
+ let llmatch = data.bindings_map.get(ident).llmatch;
+ Store(bcx, *value_ptr, llmatch);
+ }
match data.arm.guard {
Some(guard_expr) => {
bcx = compile_guard(bcx,
matches.push(Match {
pats: ~[*p],
data: arm_data.clone(),
+ bound_ptrs: ~[],
});
}
}
}
// insert bindings into the lllocals map and add cleanups
- bcx = insert_lllocals(bcx, arm_data.bindings_map, BindLocal, true);
+ bcx = insert_lllocals(bcx, arm_data.bindings_map, true);
bcx = controlflow::trans_block(bcx, &arm_data.arm.body, dest);
bcx = trans_block_cleanups(bcx, block_cleanups(arm_data.bodycx));
use std::hashmap::HashMap;
use std::io;
use std::libc::c_uint;
-use std::uint;
use std::vec;
use std::local_data;
use extra::time;
use syntax::parse::token;
use syntax::parse::token::{special_idents};
use syntax::print::pprust::stmt_to_str;
-use syntax::oldvisit;
use syntax::{ast, ast_util, codemap, ast_map};
use syntax::abi::{X86, X86_64, Arm, Mips};
fn fcx_has_nonzero_span(fcx: &FunctionContext) -> bool {
match fcx.span {
- None => true,
+ None => false,
Some(span) => *span.lo != 0 || *span.hi != 0
}
}
return llfn;
}
-pub fn get_extern_fn(externs: &mut ExternMap, llmod: ModuleRef, name: @str,
+pub fn get_extern_fn(externs: &mut ExternMap, llmod: ModuleRef, name: &str,
cc: lib::llvm::CallConv, ty: Type) -> ValueRef {
- match externs.find_copy(&name) {
- Some(n) => return n,
+ match externs.find_equiv(&name) {
+ Some(n) => return *n,
None => ()
}
let f = decl_fn(llmod, name, cc, ty);
- externs.insert(name, f);
+ externs.insert(name.to_owned(), f);
return f;
}
pub fn get_extern_const(externs: &mut ExternMap, llmod: ModuleRef,
- name: @str, ty: Type) -> ValueRef {
- match externs.find_copy(&name) {
- Some(n) => return n,
+ name: &str, ty: Type) -> ValueRef {
+ match externs.find_equiv(&name) {
+ Some(n) => return *n,
None => ()
}
unsafe {
let c = do name.with_c_str |buf| {
llvm::LLVMAddGlobal(llmod, ty.to_ref(), buf)
};
- externs.insert(name, c);
+ externs.insert(name.to_owned(), c);
return c;
}
}
lib::llvm::SetFunctionAttribute(f, lib::llvm::InlineHintAttribute)
}
-pub fn set_inline_hint_if_appr(attrs: &[ast::Attribute],
- llfn: ValueRef) {
+pub fn set_llvm_fn_attrs(attrs: &[ast::Attribute], llfn: ValueRef) {
use syntax::attr::*;
+ // Set the inline hint if there is one
match find_inline_attr(attrs) {
InlineHint => set_inline_hint(llfn),
InlineAlways => set_always_inline(llfn),
InlineNever => set_no_inline(llfn),
InlineNone => { /* fallthrough */ }
}
+
+ // Add the no-split-stack attribute if requested
+ if contains_name(attrs, "no_split_stack") {
+ set_no_split_stack(llfn);
+ }
}
pub fn set_always_inline(f: ValueRef) {
}
pub fn set_fixed_stack_segment(f: ValueRef) {
- lib::llvm::SetFixedStackSegmentAttribute(f);
+ do "fixed-stack-segment".to_c_str().with_ref |buf| {
+ unsafe { llvm::LLVMAddFunctionAttrString(f, buf); }
+ }
+}
+
+pub fn set_no_split_stack(f: ValueRef) {
+ do "no-split-stack".to_c_str().with_ref |buf| {
+ unsafe { llvm::LLVMAddFunctionAttrString(f, buf); }
+ }
}
pub fn set_glue_inlining(f: ValueRef, t: ty::t) {
None,
ty::lookup_item_type(tcx, parent_id).ty);
let llty = type_of_dtor(ccx, class_ty);
- let name = name.to_managed(); // :-(
get_extern_fn(&mut ccx.externs,
ccx.llmod,
name,
for variant in (*variants).iter() {
let variant_cx =
sub_block(cx, ~"enum-iter-variant-" +
- uint::to_str(variant.disr_val));
+ variant.disr_val.to_str());
let variant_cx =
iter_variant(variant_cx, repr, av, *variant,
substs.tps, |x,y,z| f(x,y,z));
}
}
-pub fn null_env_ptr(bcx: @mut Block) -> ValueRef {
- C_null(Type::opaque_box(bcx.ccx()).ptr_to())
+pub fn null_env_ptr(ccx: &CrateContext) -> ValueRef {
+ C_null(Type::opaque_box(ccx).ptr_to())
}
pub fn trans_external_path(ccx: &mut CrateContext, did: ast::def_id, t: ty::t)
-> ValueRef {
- let name = csearch::get_symbol(ccx.sess.cstore, did).to_managed(); // Sad
+ let name = csearch::get_symbol(ccx.sess.cstore, did);
match ty::get(t).sty {
ty::ty_bare_fn(_) | ty::ty_closure(_) => {
let llty = type_of_fn_from_ty(ccx, t);
// slot where the return value of the function must go.
pub fn make_return_pointer(fcx: @mut FunctionContext, output_type: ty::t) -> ValueRef {
unsafe {
- if !ty::type_is_immediate(fcx.ccx.tcx, output_type) {
+ if type_of::return_uses_outptr(fcx.ccx.tcx, output_type) {
llvm::LLVMGetParam(fcx.llfn, 0)
} else {
let lloutputtype = type_of::type_of(fcx.ccx, output_type);
ty::subst_tps(ccx.tcx, substs.tys, substs.self_ty, output_type)
}
};
- let is_immediate = ty::type_is_immediate(ccx.tcx, substd_output_type);
+ let uses_outptr = type_of::return_uses_outptr(ccx.tcx, substd_output_type);
let fcx = @mut FunctionContext {
llfn: llfndecl,
llenv: unsafe {
llreturn: None,
llself: None,
personality: None,
- has_immediate_return_value: is_immediate,
+ caller_expects_out_pointer: uses_outptr,
llargs: @mut HashMap::new(),
lllocals: @mut HashMap::new(),
llupvars: @mut HashMap::new(),
fcx.alloca_insert_pt = Some(llvm::LLVMGetFirstInstruction(entry_bcx.llbb));
}
- if !ty::type_is_nil(substd_output_type) && !(is_immediate && skip_retptr) {
- fcx.llretptr = Some(make_return_pointer(fcx, substd_output_type));
+ if !ty::type_is_voidish(substd_output_type) {
+ // If the function returns nil/bot, there is no real return
+ // value, so do not set `llretptr`.
+ if !skip_retptr || uses_outptr {
+ // Otherwise, we normally allocate the llretptr, unless we
+ // have been instructed to skip it for immediate return
+ // values.
+ fcx.llretptr = Some(make_return_pointer(fcx, substd_output_type));
+ }
}
fcx
}
fcx.llself = Some(ValSelfData {v: self_val, ..slf});
add_clean(bcx, self_val, slf.t);
+
+ if fcx.ccx.sess.opts.extra_debuginfo && fcx_has_nonzero_span(fcx) {
+ debuginfo::create_self_argument_metadata(bcx, slf.t, self_val);
+ }
}
_ => {}
}
// Builds the return block for a function.
pub fn build_return_block(fcx: &FunctionContext, ret_cx: @mut Block) {
// Return the value if this function immediate; otherwise, return void.
- if fcx.llretptr.is_none() || !fcx.has_immediate_return_value {
+ if fcx.llretptr.is_none() || fcx.caller_expects_out_pointer {
return RetVoid(ret_cx);
}
set_fixed_stack_segment(fcx.llfn);
}
+ if ccx.sess.opts.debuginfo && fcx_has_nonzero_span(fcx) {
+ debuginfo::create_function_metadata(fcx);
+ }
+
// Create the first basic block in the function and keep a handle on it to
// pass to finish_fn later.
let bcx_top = fcx.entry_bcx.unwrap();
// translation calls that don't have a return value (trans_crate,
// trans_mod, trans_item, et cetera) and those that do
// (trans_block, trans_expr, et cetera).
- if body.expr.is_none() || ty::type_is_bot(block_ty) ||
- ty::type_is_nil(block_ty)
- {
+ if body.expr.is_none() || ty::type_is_voidish(block_ty) {
bcx = controlflow::trans_block(bcx, body, expr::Ignore);
} else {
let dest = expr::SaveIn(fcx.llretptr.unwrap());
id,
attrs,
output_type,
- |fcx| {
- if ccx.sess.opts.debuginfo
- && fcx_has_nonzero_span(fcx) {
- debuginfo::create_function_metadata(fcx);
- }
- });
+ |_fcx| { });
}
fn insert_synthetic_type_entries(bcx: @mut Block,
ast::item_fn(ref decl, purity, _abis, ref generics, ref body) => {
if purity == ast::extern_fn {
let llfndecl = get_item_val(ccx, item.id);
- foreign::trans_foreign_fn(ccx,
- vec::append((*path).clone(),
- [path_name(item.ident)]),
- decl,
- body,
- llfndecl,
- item.id);
+ foreign::trans_rust_fn_with_foreign_abi(
+ ccx,
+ &vec::append((*path).clone(),
+ [path_name(item.ident)]),
+ decl,
+ body,
+ llfndecl,
+ item.id);
} else if !generics.is_type_parameterized() {
let llfndecl = get_item_val(ccx, item.id);
trans_fn(ccx,
}
},
ast::item_foreign_mod(ref foreign_mod) => {
- foreign::trans_foreign_mod(ccx, path, foreign_mod);
+ foreign::trans_foreign_mod(ccx, foreign_mod);
}
ast::item_struct(struct_def, ref generics) => {
if !generics.is_type_parameterized() {
fn create_main(ccx: @mut CrateContext, main_llfn: ValueRef) -> ValueRef {
let nt = ty::mk_nil();
-
- let llfty = type_of_fn(ccx, [], nt);
+ let llfty = type_of_rust_fn(ccx, [], nt);
let llfdecl = decl_fn(ccx.llmod, "_rust_main",
lib::llvm::CCallConv, llfty);
// the args vector built in create_entry_fn will need
// be updated if this assertion starts to fail.
- assert!(fcx.has_immediate_return_value);
+ assert!(!fcx.caller_expects_out_pointer);
let bcx = fcx.entry_bcx.unwrap();
// Call main.
let llfn = if purity != ast::extern_fn {
register_fn(ccx, i.span, sym, i.id, ty)
} else {
- foreign::register_foreign_fn(ccx, i.span, sym, i.id)
+ foreign::register_rust_fn_with_foreign_abi(ccx,
+ i.span,
+ sym,
+ i.id)
};
- set_inline_hint_if_appr(i.attrs, llfn);
+ set_llvm_fn_attrs(i.attrs, llfn);
llfn
}
register_method(ccx, id, pth, m)
}
- ast_map::node_foreign_item(ni, _, _, pth) => {
+ ast_map::node_foreign_item(ni, abis, _, pth) => {
let ty = ty::node_id_to_type(ccx.tcx, ni.id);
exprt = true;
match ni.node {
ast::foreign_item_fn(*) => {
let path = vec::append((*pth).clone(), [path_name(ni.ident)]);
- let sym = exported_name(ccx, path, ty, ni.attrs);
-
- register_fn(ccx, ni.span, sym, ni.id, ty)
+ foreign::register_foreign_item_fn(ccx, abis, &path, ni)
}
ast::foreign_item_static(*) => {
let ident = token::ident_to_str(&ni.ident);
let sym = exported_name(ccx, path, mty, m.attrs);
let llfn = register_fn(ccx, m.span, sym, id, mty);
- set_inline_hint_if_appr(m.attrs, llfn);
+ set_llvm_fn_attrs(m.attrs, llfn);
llfn
}
-// The constant translation pass.
-pub fn trans_constant(ccx: &mut CrateContext, it: @ast::item) {
- let _icx = push_ctxt("trans_constant");
- match it.node {
- ast::item_enum(ref enum_definition, _) => {
- let vi = ty::enum_variants(ccx.tcx,
- ast::def_id { crate: ast::LOCAL_CRATE,
- node: it.id });
- let mut i = 0;
- let path = item_path(ccx, &it.id);
- for variant in (*enum_definition).variants.iter() {
- let p = vec::append(path.clone(), [
- path_name(variant.node.name),
- path_name(special_idents::descrim)
- ]);
- let s = mangle_exported_name(ccx, p, ty::mk_int()).to_managed();
- let disr_val = vi[i].disr_val;
- note_unique_llvm_symbol(ccx, s);
- let discrim_gvar = do s.with_c_str |buf| {
- unsafe {
- llvm::LLVMAddGlobal(ccx.llmod, ccx.int_type.to_ref(), buf)
- }
- };
- unsafe {
- llvm::LLVMSetInitializer(discrim_gvar, C_uint(ccx, disr_val));
- llvm::LLVMSetGlobalConstant(discrim_gvar, True);
- }
- ccx.discrims.insert(
- local_def(variant.node.id), discrim_gvar);
- ccx.discrim_symbols.insert(variant.node.id, s);
- i += 1;
- }
- }
- _ => ()
- }
-}
-
-pub fn trans_constants(ccx: @mut CrateContext, crate: &ast::Crate) {
- oldvisit::visit_crate(
- crate, ((),
- oldvisit::mk_simple_visitor(@oldvisit::SimpleVisitor {
- visit_item: |a| trans_constant(ccx, a),
- ..*oldvisit::default_simple_visitor()
- })));
-}
-
pub fn vp2i(cx: @mut Block, v: ValueRef) -> ValueRef {
let ccx = cx.ccx();
return PtrToInt(cx, v, ccx.int_type);
}
subcrates.push(C_int(ccx, 0));
- let llannihilatefn = match ccx.tcx.lang_items.annihilate_fn() {
- Some(annihilate_def_id) => {
- if annihilate_def_id.crate == ast::LOCAL_CRATE {
- get_item_val(ccx, annihilate_def_id.node)
- } else {
- let annihilate_fn_type = csearch::get_type(ccx.tcx,
- annihilate_def_id).ty;
- trans_external_path(ccx, annihilate_def_id, annihilate_fn_type)
- }
- }
- None => { C_null(Type::i8p()) }
- };
-
unsafe {
let mod_map = create_module_map(ccx);
llvm::LLVMSetInitializer(map, C_struct(
[C_i32(1),
- lib::llvm::llvm::LLVMConstPointerCast(llannihilatefn, Type::i8p().to_ref()),
+ // FIXME #8431 This used to be the annihilate function, now it's nothing
+ C_null(Type::i8p()),
p2i(ccx, mod_map),
C_array(ccx.int_type, subcrates)]));
}
link_meta,
analysis.reachable);
- {
- let _icx = push_ctxt("data");
- trans_constants(ccx, crate);
- }
-
{
let _icx = push_ctxt("text");
trans_mod(ccx, &crate.module);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use lib::llvm::{llvm, ValueRef, Attribute, Void};
-use middle::trans::base::*;
-use middle::trans::build::*;
-use middle::trans::common::*;
-
-use middle::trans::type_::Type;
-
-use std::libc::c_uint;
+use lib::llvm::Attribute;
use std::option;
-
-pub trait ABIInfo {
- fn compute_info(&self, atys: &[Type], rty: Type, ret_def: bool) -> FnType;
-}
+use middle::trans::context::CrateContext;
+use middle::trans::cabi_x86;
+use middle::trans::cabi_x86_64;
+use middle::trans::cabi_arm;
+use middle::trans::cabi_mips;
+use middle::trans::type_::Type;
+use syntax::abi::{X86, X86_64, Arm, Mips};
#[deriving(Clone)]
pub struct LLVMType {
ty: Type
}
+/// Metadata describing how the arguments to a native function
+/// should be passed in order to respect the native ABI.
+///
+/// I will do my best to describe this structure, but these
+/// comments are reverse-engineered and may be inaccurate. -NDM
pub struct FnType {
+ /// The LLVM types of each argument. If the cast flag is true,
+ /// then the argument should be cast, typically because the
+ /// official argument type will be an int and the rust type is i8
+ /// or something like that.
arg_tys: ~[LLVMType],
- ret_ty: LLVMType,
- attrs: ~[option::Option<Attribute>],
- sret: bool
-}
-
-impl FnType {
- pub fn decl_fn(&self, decl: &fn(fnty: Type) -> ValueRef) -> ValueRef {
- let atys = self.arg_tys.iter().map(|t| t.ty).collect::<~[Type]>();
- let rty = self.ret_ty.ty;
- let fnty = Type::func(atys, &rty);
- let llfn = decl(fnty);
-
- for (i, a) in self.attrs.iter().enumerate() {
- match *a {
- option::Some(attr) => {
- unsafe {
- let llarg = get_param(llfn, i);
- llvm::LLVMAddAttribute(llarg, attr as c_uint);
- }
- }
- _ => ()
- }
- }
- return llfn;
- }
- pub fn build_shim_args(&self, bcx: @mut Block, arg_tys: &[Type], llargbundle: ValueRef)
- -> ~[ValueRef] {
- let mut atys: &[LLVMType] = self.arg_tys;
- let mut attrs: &[option::Option<Attribute>] = self.attrs;
-
- let mut llargvals = ~[];
- let mut i = 0u;
- let n = arg_tys.len();
-
- if self.sret {
- let llretptr = GEPi(bcx, llargbundle, [0u, n]);
- let llretloc = Load(bcx, llretptr);
- llargvals = ~[llretloc];
- atys = atys.tail();
- attrs = attrs.tail();
- }
-
- while i < n {
- let llargval = if atys[i].cast {
- let arg_ptr = GEPi(bcx, llargbundle, [0u, i]);
- let arg_ptr = BitCast(bcx, arg_ptr, atys[i].ty.ptr_to());
- Load(bcx, arg_ptr)
- } else if attrs[i].is_some() {
- GEPi(bcx, llargbundle, [0u, i])
- } else {
- load_inbounds(bcx, llargbundle, [0u, i])
- };
- llargvals.push(llargval);
- i += 1u;
- }
-
- return llargvals;
- }
-
- pub fn build_shim_ret(&self, bcx: @mut Block, arg_tys: &[Type], ret_def: bool,
- llargbundle: ValueRef, llretval: ValueRef) {
- for (i, a) in self.attrs.iter().enumerate() {
- match *a {
- option::Some(attr) => {
- unsafe {
- llvm::LLVMAddInstrAttribute(llretval, (i + 1u) as c_uint, attr as c_uint);
- }
- }
- _ => ()
- }
- }
- if self.sret || !ret_def {
- return;
- }
- let n = arg_tys.len();
- // R** llretptr = &args->r;
- let llretptr = GEPi(bcx, llargbundle, [0u, n]);
- // R* llretloc = *llretptr; /* (args->r) */
- let llretloc = Load(bcx, llretptr);
- if self.ret_ty.cast {
- let tmp_ptr = BitCast(bcx, llretloc, self.ret_ty.ty.ptr_to());
- // *args->r = r;
- Store(bcx, llretval, tmp_ptr);
- } else {
- // *args->r = r;
- Store(bcx, llretval, llretloc);
- };
- }
-
- pub fn build_wrap_args(&self, bcx: @mut Block, ret_ty: Type,
- llwrapfn: ValueRef, llargbundle: ValueRef) {
- let mut atys: &[LLVMType] = self.arg_tys;
- let mut attrs: &[option::Option<Attribute>] = self.attrs;
- let mut j = 0u;
- let llretptr = if self.sret {
- atys = atys.tail();
- attrs = attrs.tail();
- j = 1u;
- get_param(llwrapfn, 0u)
- } else if self.ret_ty.cast {
- let retptr = alloca(bcx, self.ret_ty.ty, "");
- BitCast(bcx, retptr, ret_ty.ptr_to())
- } else {
- alloca(bcx, ret_ty, "")
- };
+ /// A list of attributes to be attached to each argument (parallel
+ /// the `arg_tys` array). If the attribute for a given is Some,
+ /// then the argument should be passed by reference.
+ attrs: ~[option::Option<Attribute>],
- let mut i = 0u;
- let n = atys.len();
- while i < n {
- let mut argval = get_param(llwrapfn, i + j);
- if attrs[i].is_some() {
- argval = Load(bcx, argval);
- store_inbounds(bcx, argval, llargbundle, [0u, i]);
- } else if atys[i].cast {
- let argptr = GEPi(bcx, llargbundle, [0u, i]);
- let argptr = BitCast(bcx, argptr, atys[i].ty.ptr_to());
- Store(bcx, argval, argptr);
- } else {
- store_inbounds(bcx, argval, llargbundle, [0u, i]);
- }
- i += 1u;
- }
- store_inbounds(bcx, llretptr, llargbundle, [0u, n]);
- }
+ /// LLVM return type.
+ ret_ty: LLVMType,
- pub fn build_wrap_ret(&self, bcx: @mut Block, arg_tys: &[Type], llargbundle: ValueRef) {
- if self.ret_ty.ty.kind() == Void {
- return;
- }
+ /// If true, then an implicit pointer should be added for the result.
+ sret: bool
+}
- if bcx.fcx.llretptr.is_some() {
- let llretval = load_inbounds(bcx, llargbundle, [ 0, arg_tys.len() ]);
- let llretval = if self.ret_ty.cast {
- let retptr = BitCast(bcx, llretval, self.ret_ty.ty.ptr_to());
- Load(bcx, retptr)
- } else {
- Load(bcx, llretval)
- };
- let llretptr = BitCast(bcx, bcx.fcx.llretptr.unwrap(), self.ret_ty.ty.ptr_to());
- Store(bcx, llretval, llretptr);
- }
+pub fn compute_abi_info(ccx: &mut CrateContext,
+ atys: &[Type],
+ rty: Type,
+ ret_def: bool) -> FnType {
+ match ccx.sess.targ_cfg.arch {
+ X86 => cabi_x86::compute_abi_info(ccx, atys, rty, ret_def),
+ X86_64 => cabi_x86_64::compute_abi_info(ccx, atys, rty, ret_def),
+ Arm => cabi_arm::compute_abi_info(ccx, atys, rty, ret_def),
+ Mips => cabi_mips::compute_abi_info(ccx, atys, rty, ret_def),
}
}
use lib::llvm::{llvm, Integer, Pointer, Float, Double, Struct, Array};
use lib::llvm::{Attribute, StructRetAttribute};
-use middle::trans::cabi::{ABIInfo, FnType, LLVMType};
+use middle::trans::cabi::{FnType, LLVMType};
+use middle::trans::context::CrateContext;
use middle::trans::type_::Type;
}
}
-enum ARM_ABIInfo { ARM_ABIInfo }
-
-impl ABIInfo for ARM_ABIInfo {
- fn compute_info(&self,
- atys: &[Type],
- rty: Type,
- ret_def: bool) -> FnType {
- let mut arg_tys = ~[];
- let mut attrs = ~[];
- for &aty in atys.iter() {
- let (ty, attr) = classify_arg_ty(aty);
- arg_tys.push(ty);
- attrs.push(attr);
- }
-
- let (ret_ty, ret_attr) = if ret_def {
- classify_ret_ty(rty)
- } else {
- (LLVMType { cast: false, ty: Type::void() }, None)
- };
+pub fn compute_abi_info(_ccx: &mut CrateContext,
+ atys: &[Type],
+ rty: Type,
+ ret_def: bool) -> FnType {
+ let mut arg_tys = ~[];
+ let mut attrs = ~[];
+ for &aty in atys.iter() {
+ let (ty, attr) = classify_arg_ty(aty);
+ arg_tys.push(ty);
+ attrs.push(attr);
+ }
- let mut ret_ty = ret_ty;
+ let (ret_ty, ret_attr) = if ret_def {
+ classify_ret_ty(rty)
+ } else {
+ (LLVMType { cast: false, ty: Type::void() }, None)
+ };
- let sret = ret_attr.is_some();
- if sret {
- arg_tys.unshift(ret_ty);
- attrs.unshift(ret_attr);
- ret_ty = LLVMType { cast: false, ty: Type::void() };
- }
+ let mut ret_ty = ret_ty;
- return FnType {
- arg_tys: arg_tys,
- ret_ty: ret_ty,
- attrs: attrs,
- sret: sret
- };
+ let sret = ret_attr.is_some();
+ if sret {
+ arg_tys.unshift(ret_ty);
+ attrs.unshift(ret_attr);
+ ret_ty = LLVMType { cast: false, ty: Type::void() };
}
-}
-pub fn abi_info() -> @ABIInfo {
- return @ARM_ABIInfo as @ABIInfo;
+ return FnType {
+ arg_tys: arg_tys,
+ ret_ty: ret_ty,
+ attrs: attrs,
+ sret: sret
+ };
}
use std::vec;
use lib::llvm::{llvm, Integer, Pointer, Float, Double, Struct, Array};
use lib::llvm::{Attribute, StructRetAttribute};
+use middle::trans::context::CrateContext;
use middle::trans::context::task_llcx;
use middle::trans::cabi::*;
return Type::struct_(fields, false);
}
-enum MIPS_ABIInfo { MIPS_ABIInfo }
-
-impl ABIInfo for MIPS_ABIInfo {
- fn compute_info(&self,
- atys: &[Type],
- rty: Type,
- ret_def: bool) -> FnType {
- let (ret_ty, ret_attr) = if ret_def {
- classify_ret_ty(rty)
- } else {
- (LLVMType { cast: false, ty: Type::void() }, None)
- };
-
- let mut ret_ty = ret_ty;
-
- let sret = ret_attr.is_some();
- let mut arg_tys = ~[];
- let mut attrs = ~[];
- let mut offset = if sret { 4 } else { 0 };
-
- for aty in atys.iter() {
- let (ty, attr) = classify_arg_ty(*aty, &mut offset);
- arg_tys.push(ty);
- attrs.push(attr);
- };
-
- if sret {
- arg_tys = vec::append(~[ret_ty], arg_tys);
- attrs = vec::append(~[ret_attr], attrs);
- ret_ty = LLVMType { cast: false, ty: Type::void() };
- }
+pub fn compute_abi_info(_ccx: &mut CrateContext,
+ atys: &[Type],
+ rty: Type,
+ ret_def: bool) -> FnType {
+ let (ret_ty, ret_attr) = if ret_def {
+ classify_ret_ty(rty)
+ } else {
+ (LLVMType { cast: false, ty: Type::void() }, None)
+ };
+
+ let mut ret_ty = ret_ty;
+
+ let sret = ret_attr.is_some();
+ let mut arg_tys = ~[];
+ let mut attrs = ~[];
+ let mut offset = if sret { 4 } else { 0 };
- return FnType {
- arg_tys: arg_tys,
- ret_ty: ret_ty,
- attrs: attrs,
- sret: sret
- };
+ for aty in atys.iter() {
+ let (ty, attr) = classify_arg_ty(*aty, &mut offset);
+ arg_tys.push(ty);
+ attrs.push(attr);
+ };
+
+ if sret {
+ arg_tys = vec::append(~[ret_ty], arg_tys);
+ attrs = vec::append(~[ret_attr], attrs);
+ ret_ty = LLVMType { cast: false, ty: Type::void() };
}
-}
-pub fn abi_info() -> @ABIInfo {
- return @MIPS_ABIInfo as @ABIInfo;
+ return FnType {
+ arg_tys: arg_tys,
+ ret_ty: ret_ty,
+ attrs: attrs,
+ sret: sret
+ };
}
use super::cabi::*;
use super::common::*;
use super::machine::*;
-
use middle::trans::type_::Type;
-struct X86_ABIInfo {
- ccx: @mut CrateContext
-}
+pub fn compute_abi_info(ccx: &mut CrateContext,
+ atys: &[Type],
+ rty: Type,
+ ret_def: bool) -> FnType {
+ let mut arg_tys = ~[];
+ let mut attrs = ~[];
-impl ABIInfo for X86_ABIInfo {
- fn compute_info(&self,
- atys: &[Type],
- rty: Type,
- ret_def: bool) -> FnType {
- let mut arg_tys = do atys.map |a| {
- LLVMType { cast: false, ty: *a }
- };
- let mut ret_ty = LLVMType {
+ let ret_ty;
+ let sret;
+ if !ret_def {
+ ret_ty = LLVMType {
cast: false,
- ty: rty
+ ty: Type::void(),
};
- let mut attrs = do atys.map |_| {
- None
- };
-
- // Rules for returning structs taken from
+ sret = false;
+ } else if rty.kind() == Struct {
+ // Returning a structure. Most often, this will use
+ // a hidden first argument. On some platforms, though,
+ // small structs are returned as integers.
+ //
+ // Some links:
// http://www.angelcode.com/dev/callconv/callconv.html
// Clang's ABI handling is in lib/CodeGen/TargetInfo.cpp
- let sret = {
- let returning_a_struct = rty.kind() == Struct && ret_def;
- let big_struct = match self.ccx.sess.targ_cfg.os {
- os_win32 | os_macos => llsize_of_alloc(self.ccx, rty) > 8,
- _ => true
- };
- returning_a_struct && big_struct
+
+ enum Strategy { RetValue(Type), RetPointer }
+ let strategy = match ccx.sess.targ_cfg.os {
+ os_win32 | os_macos => {
+ match llsize_of_alloc(ccx, rty) {
+ 1 => RetValue(Type::i8()),
+ 2 => RetValue(Type::i16()),
+ 4 => RetValue(Type::i32()),
+ 8 => RetValue(Type::i64()),
+ _ => RetPointer
+ }
+ }
+ _ => {
+ RetPointer
+ }
};
- if sret {
- let ret_ptr_ty = LLVMType {
- cast: false,
- ty: ret_ty.ty.ptr_to()
- };
- arg_tys = ~[ret_ptr_ty] + arg_tys;
- attrs = ~[Some(StructRetAttribute)] + attrs;
- ret_ty = LLVMType {
- cast: false,
- ty: Type::void(),
- };
- } else if !ret_def {
- ret_ty = LLVMType {
- cast: false,
- ty: Type::void()
- };
- }
+ match strategy {
+ RetValue(t) => {
+ ret_ty = LLVMType {
+ cast: true,
+ ty: t
+ };
+ sret = false;
+ }
+ RetPointer => {
+ arg_tys.push(LLVMType {
+ cast: false,
+ ty: rty.ptr_to()
+ });
+ attrs.push(Some(StructRetAttribute));
- return FnType {
- arg_tys: arg_tys,
- ret_ty: ret_ty,
- attrs: attrs,
- sret: sret
+ ret_ty = LLVMType {
+ cast: false,
+ ty: Type::void(),
+ };
+ sret = true;
+ }
+ }
+ } else {
+ ret_ty = LLVMType {
+ cast: false,
+ ty: rty
};
+ sret = false;
+ }
+
+ for &a in atys.iter() {
+ arg_tys.push(LLVMType { cast: false, ty: a });
+ attrs.push(None);
}
-}
-pub fn abi_info(ccx: @mut CrateContext) -> @ABIInfo {
- return @X86_ABIInfo {
- ccx: ccx
- } as @ABIInfo;
+ return FnType {
+ arg_tys: arg_tys,
+ ret_ty: ret_ty,
+ attrs: attrs,
+ sret: sret
+ };
}
use lib::llvm::{Struct, Array, Attribute};
use lib::llvm::{StructRetAttribute, ByValAttribute};
use middle::trans::cabi::*;
+use middle::trans::context::CrateContext;
use middle::trans::type_::Type;
return Type::struct_(tys, false);
}
-fn x86_64_tys(atys: &[Type],
- rty: Type,
- ret_def: bool) -> FnType {
-
+pub fn compute_abi_info(_ccx: &mut CrateContext,
+ atys: &[Type],
+ rty: Type,
+ ret_def: bool) -> FnType {
fn x86_64_ty(ty: Type,
is_mem_cls: &fn(cls: &[RegClass]) -> bool,
attr: Attribute) -> (LLVMType, Option<Attribute>) {
sret: sret
};
}
-
-enum X86_64_ABIInfo { X86_64_ABIInfo }
-
-impl ABIInfo for X86_64_ABIInfo {
- fn compute_info(&self,
- atys: &[Type],
- rty: Type,
- ret_def: bool) -> FnType {
- return x86_64_tys(atys, rty, ret_def);
- }
-}
-
-pub fn abi_info() -> @ABIInfo {
- return @X86_64_ABIInfo as @ABIInfo;
-}
use middle::trans::meth;
use middle::trans::monomorphize;
use middle::trans::type_of;
+use middle::trans::foreign;
use middle::ty;
use middle::subst::Subst;
use middle::typeck;
use middle::trans::type_::Type;
use syntax::ast;
+use syntax::abi::AbiSet;
use syntax::ast_map;
-use syntax::oldvisit;
+use syntax::visit;
+use syntax::visit::Visitor;
// Represents a (possibly monomorphized) top-level fn item or method
// item. Note that this is just the fn-ptr and is not a Rust closure
ast::def_struct(def_id) => {
fn_callee(bcx, trans_fn_ref(bcx, def_id, ref_expr.id))
}
+ ast::def_static(*) |
ast::def_arg(*) |
ast::def_local(*) |
ast::def_binding(*) |
datum_callee(bcx, ref_expr)
}
ast::def_mod(*) | ast::def_foreign_mod(*) | ast::def_trait(*) |
- ast::def_static(*) | ast::def_ty(*) | ast::def_prim_ty(*) |
+ ast::def_ty(*) | ast::def_prim_ty(*) |
ast::def_use(*) | ast::def_typaram_binder(*) |
ast::def_region(*) | ast::def_label(*) | ast::def_ty_param(*) |
ast::def_self_ty(*) | ast::def_method(*) => {
type_params: &[ty::t], // values for fn's ty params
vtables: Option<typeck::vtable_res>) // vtables for the call
-> FnData {
- //!
- //
- // Translates a reference to a fn/method item, monomorphizing and
- // inlining as it goes.
- //
- // # Parameters
- //
- // - `bcx`: the current block where the reference to the fn occurs
- // - `def_id`: def id of the fn or method item being referenced
- // - `ref_id`: node id of the reference to the fn/method, if applicable.
- // This parameter may be zero; but, if so, the resulting value may not
- // have the right type, so it must be cast before being used.
- // - `type_params`: values for each of the fn/method's type parameters
- // - `vtables`: values for each bound on each of the type parameters
+ /*!
+ * Translates a reference to a fn/method item, monomorphizing and
+ * inlining as it goes.
+ *
+ * # Parameters
+ *
+ * - `bcx`: the current block where the reference to the fn occurs
+ * - `def_id`: def id of the fn or method item being referenced
+ * - `ref_id`: node id of the reference to the fn/method, if applicable.
+ * This parameter may be zero; but, if so, the resulting value may not
+ * have the right type, so it must be cast before being used.
+ * - `type_params`: values for each of the fn/method's type parameters
+ * - `vtables`: values for each bound on each of the type parameters
+ */
let _icx = push_ctxt("trans_fn_ref_with_vtables");
let ccx = bcx.ccx();
}
// Find the actual function pointer.
- let val = {
+ let mut val = {
if def_id.crate == ast::LOCAL_CRATE {
// Internal reference.
get_item_val(ccx, def_id.node)
}
};
+ // This is subtle and surprising, but sometimes we have to bitcast
+ // the resulting fn pointer. The reason has to do with external
+ // functions. If you have two crates that both bind the same C
+ // library, they may not use precisely the same types: for
+ // example, they will probably each declare their own structs,
+ // which are distinct types from LLVM's point of view (nominal
+ // types).
+ //
+ // Now, if those two crates are linked into an application, and
+ // they contain inlined code, you can wind up with a situation
+ // where both of those functions wind up being loaded into this
+ // application simultaneously. In that case, the same function
+ // (from LLVM's point of view) requires two types. But of course
+ // LLVM won't allow one function to have two types.
+ //
+ // What we currently do, therefore, is declare the function with
+ // one of the two types (whichever happens to come first) and then
+ // bitcast as needed when the function is referenced to make sure
+ // it has the type we expect.
+ //
+ // This can occur on either a crate-local or crate-external
+ // reference. It also occurs when testing libcore and in some
+ // other weird situations. Annoying.
+ let llty = type_of::type_of_fn_from_ty(ccx, fn_tpt.ty);
+ let llptrty = llty.ptr_to();
+ if val_ty(val) != llptrty {
+ val = BitCast(bcx, val, llptrty);
+ }
+
return FnData {llfn: val};
}
ArgVals(args), Some(dest), DontAutorefArg).bcx;
}
-pub fn body_contains_ret(body: &ast::Block) -> bool {
- let cx = @mut false;
- oldvisit::visit_block(body, (cx, oldvisit::mk_vt(@oldvisit::Visitor {
- visit_item: |_i, (_cx, _v)| { },
- visit_expr: |e: @ast::expr,
- (cx, v): (@mut bool, oldvisit::vt<@mut bool>)| {
+
+struct CalleeTranslationVisitor;
+
+impl Visitor<@mut bool> for CalleeTranslationVisitor {
+
+ fn visit_item(&mut self, _:@ast::item, _:@mut bool) { }
+
+ fn visit_expr(&mut self, e:@ast::expr, cx:@mut bool) {
+
if !*cx {
match e.node {
ast::expr_ret(_) => *cx = true,
- _ => oldvisit::visit_expr(e, (cx, v)),
+ _ => visit::walk_expr(self, e, cx),
}
}
- },
- ..*oldvisit::default_visitor()
- })));
+ }
+
+}
+
+pub fn body_contains_ret(body: &ast::Block) -> bool {
+ let cx = @mut false;
+ let mut v = CalleeTranslationVisitor;
+ visit::walk_block(&mut v, body, cx);
*cx
}
-// See [Note-arg-mode]
pub fn trans_call_inner(in_cx: @mut Block,
call_info: Option<NodeInfo>,
- fn_expr_ty: ty::t,
+ callee_ty: ty::t,
ret_ty: ty::t,
get_callee: &fn(@mut Block) -> Callee,
args: CallArgs,
dest: Option<expr::Dest>,
autoref_arg: AutorefArg)
-> Result {
+ /*!
+ * This behemoth of a function translates function calls.
+ * Unfortunately, in order to generate more efficient LLVM
+ * output at -O0, it has quite a complex signature (refactoring
+ * this into two functions seems like a good idea).
+ *
+ * In particular, for lang items, it is invoked with a dest of
+ * None, and
+ */
+
+
do base::with_scope_result(in_cx, call_info, "call") |cx| {
let callee = get_callee(cx);
let mut bcx = callee.bcx;
}
};
- let llretslot = trans_ret_slot(bcx, fn_expr_ty, dest);
+ let abi = match ty::get(callee_ty).sty {
+ ty::ty_bare_fn(ref f) => f.abis,
+ _ => AbiSet::Rust()
+ };
+ let is_rust_fn =
+ abi.is_rust() ||
+ abi.is_intrinsic();
+
+ // Generate a location to store the result. If the user does
+ // not care about the result, just make a stack slot.
+ let opt_llretslot = match dest {
+ None => {
+ assert!(!type_of::return_uses_outptr(in_cx.tcx(), ret_ty));
+ None
+ }
+ Some(expr::SaveIn(dst)) => Some(dst),
+ Some(expr::Ignore) => {
+ if !ty::type_is_voidish(ret_ty) {
+ Some(alloc_ty(bcx, ret_ty, "__llret"))
+ } else {
+ unsafe {
+ Some(llvm::LLVMGetUndef(Type::nil().ptr_to().to_ref()))
+ }
+ }
+ }
+ };
+
+ let mut llresult = unsafe {
+ llvm::LLVMGetUndef(Type::nil().ptr_to().to_ref())
+ };
- let mut llargs = ~[];
+ // The code below invokes the function, using either the Rust
+ // conventions (if it is a rust fn) or the native conventions
+ // (otherwise). The important part is that, when all is sad
+ // and done, either the return value of the function will have been
+ // written in opt_llretslot (if it is Some) or `llresult` will be
+ // set appropriately (otherwise).
+ if is_rust_fn {
+ let mut llargs = ~[];
+
+ // Push the out-pointer if we use an out-pointer for this
+ // return type, otherwise push "undef".
+ if type_of::return_uses_outptr(in_cx.tcx(), ret_ty) {
+ llargs.push(opt_llretslot.unwrap());
+ }
- if !ty::type_is_immediate(bcx.tcx(), ret_ty) {
- llargs.push(llretslot);
- }
+ // Push the environment.
+ llargs.push(llenv);
- llargs.push(llenv);
- bcx = trans_args(bcx, args, fn_expr_ty, autoref_arg, &mut llargs);
+ // Push the arguments.
+ bcx = trans_args(bcx, args, callee_ty,
+ autoref_arg, &mut llargs);
- // Now that the arguments have finished evaluating, we need to revoke
- // the cleanup for the self argument
- match callee.data {
- Method(d) => {
- for &v in d.temp_cleanup.iter() {
- revoke_clean(bcx, v);
+ // Now that the arguments have finished evaluating, we
+ // need to revoke the cleanup for the self argument
+ match callee.data {
+ Method(d) => {
+ for &v in d.temp_cleanup.iter() {
+ revoke_clean(bcx, v);
+ }
}
+ _ => {}
}
- _ => {}
- }
- // Uncomment this to debug calls.
- /*
- printfln!("calling: %s", bcx.val_to_str(llfn));
- for llarg in llargs.iter() {
- printfln!("arg: %s", bcx.val_to_str(*llarg));
+ // Invoke the actual rust fn and update bcx/llresult.
+ let (llret, b) = base::invoke(bcx, llfn, llargs);
+ bcx = b;
+ llresult = llret;
+
+ // If the Rust convention for this type is return via
+ // the return value, copy it into llretslot.
+ match opt_llretslot {
+ Some(llretslot) => {
+ if !type_of::return_uses_outptr(bcx.tcx(), ret_ty) &&
+ !ty::type_is_voidish(ret_ty)
+ {
+ Store(bcx, llret, llretslot);
+ }
+ }
+ None => {}
+ }
+ } else {
+ // Lang items are the only case where dest is None, and
+ // they are always Rust fns.
+ assert!(dest.is_some());
+
+ let mut llargs = ~[];
+ bcx = trans_args(bcx, args, callee_ty,
+ autoref_arg, &mut llargs);
+ bcx = foreign::trans_native_call(bcx, callee_ty,
+ llfn, opt_llretslot.unwrap(), llargs);
}
- io::println("---");
- */
-
- // If the block is terminated, then one or more of the args
- // has type _|_. Since that means it diverges, the code for
- // the call itself is unreachable.
- let (llresult, new_bcx) = base::invoke(bcx, llfn, llargs);
- bcx = new_bcx;
+ // If the caller doesn't care about the result of this fn call,
+ // drop the temporary slot we made.
match dest {
- None => { assert!(ty::type_is_immediate(bcx.tcx(), ret_ty)) }
+ None => {
+ assert!(!type_of::return_uses_outptr(bcx.tcx(), ret_ty));
+ }
Some(expr::Ignore) => {
// drop the value if it is not being saved.
- if ty::type_needs_drop(bcx.tcx(), ret_ty) {
- if ty::type_is_immediate(bcx.tcx(), ret_ty) {
- let llscratchptr = alloc_ty(bcx, ret_ty, "__ret");
- Store(bcx, llresult, llscratchptr);
- bcx = glue::drop_ty(bcx, llscratchptr, ret_ty);
- } else {
- bcx = glue::drop_ty(bcx, llretslot, ret_ty);
- }
- }
- }
- Some(expr::SaveIn(lldest)) => {
- // If this is an immediate, store into the result location.
- // (If this was not an immediate, the result will already be
- // directly written into the output slot.)
- if ty::type_is_immediate(bcx.tcx(), ret_ty) {
- Store(bcx, llresult, lldest);
- }
+ bcx = glue::drop_ty(bcx, opt_llretslot.unwrap(), ret_ty);
}
+ Some(expr::SaveIn(_)) => { }
}
if ty::type_is_bot(ret_ty) {
Unreachable(bcx);
}
+
rslt(bcx, llresult)
}
}
-
pub enum CallArgs<'self> {
ArgExprs(&'self [@ast::expr]),
ArgVals(&'self [ValueRef])
}
-pub fn trans_ret_slot(bcx: @mut Block, fn_ty: ty::t, dest: Option<expr::Dest>)
- -> ValueRef {
- let retty = ty::ty_fn_ret(fn_ty);
-
- match dest {
- Some(expr::SaveIn(dst)) => dst,
- _ => {
- if ty::type_is_immediate(bcx.tcx(), retty) {
- unsafe {
- llvm::LLVMGetUndef(Type::nil().ptr_to().to_ref())
- }
- } else {
- alloc_ty(bcx, retty, "__trans_ret_slot")
- }
- }
- }
-}
-
pub fn trans_args(cx: @mut Block,
args: CallArgs,
fn_ty: ty::t,
if formal_arg_ty != arg_datum.ty {
// this could happen due to e.g. subtyping
- let llformal_arg_ty = type_of::type_of_explicit_arg(ccx, &formal_arg_ty);
+ let llformal_arg_ty = type_of::type_of_explicit_arg(ccx, formal_arg_ty);
debug!("casting actual type (%s) to match formal (%s)",
bcx.val_to_str(val), bcx.llty_str(llformal_arg_ty));
val = PointerCast(bcx, val, llformal_arg_ty);
}
}
-pub type ExternMap = HashMap<@str, ValueRef>;
+pub type ExternMap = HashMap<~str, ValueRef>;
// Types used for llself.
pub struct ValSelfData {
// outputting the resume instruction.
personality: Option<ValueRef>,
- // True if this function has an immediate return value, false otherwise.
- // If this is false, the llretptr will alias the first argument of the
- // function.
- has_immediate_return_value: bool,
+ // True if the caller expects this fn to use the out pointer to
+ // return. Either way, your code should write into llretptr, but if
+ // this value is false, llretptr will be a local alloca.
+ caller_expects_out_pointer: bool,
// Maps arguments to allocas created for them in llallocas.
llargs: @mut HashMap<ast::NodeId, ValueRef>,
impl FunctionContext {
pub fn arg_pos(&self, arg: uint) -> uint {
- if self.has_immediate_return_value {
- arg + 1u
- } else {
+ if self.caller_expects_out_pointer {
arg + 2u
+ } else {
+ arg + 1u
}
}
pub fn out_arg_pos(&self) -> uint {
- assert!(!self.has_immediate_return_value);
+ assert!(self.caller_expects_out_pointer);
0u
}
pub fn env_arg_pos(&self) -> uint {
- if !self.has_immediate_return_value {
+ if self.caller_expects_out_pointer {
1u
} else {
0u
raw_vtables.map_move(|vts| resolve_vtables_in_fn_ctxt(bcx.fcx, *vts))
}
+// Apply the typaram substitutions in the FunctionContext to some
+// vtables. This should eliminate any vtable_params.
pub fn resolve_vtables_in_fn_ctxt(fcx: &FunctionContext, vts: typeck::vtable_res)
-> typeck::vtable_res {
resolve_vtables_under_param_substs(fcx.ccx.tcx,
-// Apply the typaram substitutions in the FunctionContext to a vtable. This should
-// eliminate any vtable_params.
-pub fn resolve_vtable_in_fn_ctxt(fcx: &FunctionContext, vt: &typeck::vtable_origin)
- -> typeck::vtable_origin {
- resolve_vtable_under_param_substs(fcx.ccx.tcx,
- fcx.param_substs,
- vt)
-}
-
pub fn resolve_vtable_under_param_substs(tcx: ty::ctxt,
param_substs: Option<@param_substs>,
vt: &typeck::vtable_origin)
}
_ => {
tcx.sess.bug(fmt!(
- "resolve_vtable_in_fn_ctxt: asked to lookup but \
- no vtables in the fn_ctxt!"))
+ "resolve_vtable_under_param_substs: asked to lookup \
+ but no vtables in the fn_ctxt!"))
}
}
}
// Cache computed type parameter uses (see type_use.rs)
type_use_cache: HashMap<ast::def_id, @~[type_use::type_uses]>,
// Cache generated vtables
- vtables: HashMap<mono_id, ValueRef>,
+ vtables: HashMap<(ty::t, mono_id), ValueRef>,
// Cache of constant strings,
const_cstr_cache: HashMap<@str, ValueRef>,
pub fn appropriate_mode(tcx: ty::ctxt, ty: ty::t) -> DatumMode {
/*!
- *
- * Indicates the "appropriate" mode for this value,
- * which is either by ref or by value, depending
- * on whether type is immediate or not. */
+ * Indicates the "appropriate" mode for this value,
+ * which is either by ref or by value, depending
+ * on whether type is immediate or not.
+ */
- if ty::type_is_nil(ty) || ty::type_is_bot(ty) {
+ if ty::type_is_voidish(ty) {
ByValue
} else if ty::type_is_immediate(tcx, ty) {
ByValue
let _icx = push_ctxt("copy_to");
- if ty::type_is_nil(self.ty) || ty::type_is_bot(self.ty) {
+ if ty::type_is_voidish(self.ty) {
return bcx;
}
debug!("move_to(self=%s, action=%?, dst=%s)",
self.to_str(bcx.ccx()), action, bcx.val_to_str(dst));
- if ty::type_is_nil(self.ty) || ty::type_is_bot(self.ty) {
+ if ty::type_is_voidish(self.ty) {
return bcx;
}
*
* Yields the value itself. */
- if ty::type_is_nil(self.ty) || ty::type_is_bot(self.ty) {
+ if ty::type_is_voidish(self.ty) {
C_nil()
} else {
match self.mode {
match self.mode {
ByRef(_) => self.val,
ByValue => {
- if ty::type_is_nil(self.ty) || ty::type_is_bot(self.ty) {
+ if ty::type_is_voidish(self.ty) {
C_null(type_of::type_of(bcx.ccx(), self.ty).ptr_to())
} else {
let slot = alloc_ty(bcx, self.ty, "");
use driver::session;
use lib::llvm::llvm;
-use lib::llvm::{ModuleRef, ContextRef};
+use lib::llvm::{ModuleRef, ContextRef, ValueRef};
use lib::llvm::debuginfo::*;
use middle::trans::common::*;
use middle::trans::machine;
use std::ptr;
use std::vec;
use syntax::codemap::span;
-use syntax::{ast, codemap, ast_util, ast_map};
+use syntax::{ast, codemap, ast_util, ast_map, opt_vec};
+use syntax::parse::token::special_idents;
static DW_LANG_RUST: int = 0x9000;
priv builder: DIBuilderRef,
priv curr_loc: (uint, uint),
priv created_files: HashMap<~str, DIFile>,
- priv created_functions: HashMap<ast::NodeId, DISubprogram>,
+ priv created_functions: HashMap<FunctionCacheKey, DISubprogram>,
priv created_blocks: HashMap<ast::NodeId, DILexicalBlock>,
priv created_types: HashMap<uint, DIType>
}
}
}
+#[deriving(Eq,IterBytes)]
+struct FunctionCacheKey {
+ // Use the address of the llvm function (FunctionContext::llfn) as key for the cache. This
+ // nicely takes care of monomorphization, where two specializations will have the same
+ // ast::NodeId but different llvm functions (each needing its own debug description).
+ priv llfn: ValueRef
+}
+
+impl FunctionCacheKey {
+ fn for_function_context(fcx: &FunctionContext) -> FunctionCacheKey {
+ FunctionCacheKey { llfn: fcx.llfn }
+ }
+}
pub struct FunctionDebugContext {
priv scope_map: HashMap<ast::NodeId, DIScope>,
priv argument_counter: uint,
}
-impl FunctionDebugContext {
- fn new() -> FunctionDebugContext {
- return FunctionDebugContext {
- scope_map: HashMap::new(),
- argument_counter: 1,
- };
- }
-}
-
/// Create any deferred debug metadata nodes
pub fn finalize(cx: @mut CrateContext) {
debug!("finalize");
}
}
+/// Creates debug information for a local variable introduced in the head of a match-statement arm.
+///
+/// Adds the created metadata nodes directly to the crate's IR.
pub fn create_match_binding_metadata(bcx: @mut Block,
variable_ident: ast::ident,
node_id: ast::NodeId,
declare_local(bcx, variable_ident, node_id, variable_type, span);
}
+/// Creates debug information for the self argument of a method.
+///
+/// Adds the created metadata nodes directly to the crate's IR.
+pub fn create_self_argument_metadata(bcx: @mut Block,
+ variable_type: ty::t,
+ llptr: ValueRef) {
+ assert_fcx_has_span(bcx.fcx);
+ let span = bcx.fcx.span.unwrap();
+
+ let cx = bcx.ccx();
+
+ let filename = span_start(cx, span).file.name;
+ let file_metadata = file_metadata(cx, filename);
+
+ let loc = span_start(cx, span);
+ let type_metadata = type_metadata(cx, variable_type, span);
+ let scope = create_function_metadata(bcx.fcx);
+
+ let var_metadata = do cx.sess.str_of(special_idents::self_).to_c_str().with_ref |name| {
+ unsafe {
+ llvm::LLVMDIBuilderCreateLocalVariable(
+ DIB(cx),
+ DW_TAG_arg_variable,
+ scope,
+ name,
+ file_metadata,
+ loc.line as c_uint,
+ type_metadata,
+ false,
+ 0,
+ 1)
+ }
+ };
+
+ set_debug_location(cx, scope, loc.line, loc.col.to_uint());
+ unsafe {
+ let instr = llvm::LLVMDIBuilderInsertDeclareAtEnd(
+ DIB(cx),
+ llptr,
+ var_metadata,
+ bcx.llbb);
+
+ llvm::LLVMSetInstDebugLocation(trans::build::B(bcx).llbuilder, instr);
+ }
+}
+
/// Creates debug information for the given function argument.
///
/// Adds the created metadata nodes directly to the crate's IR.
}
}
-/// Sets the current debug location at the beginning of the span
+/// Sets the current debug location at the beginning of the span.
///
-/// Maps to a call to llvm::LLVMSetCurrentDebugLocation(...)
+/// Maps to a call to llvm::LLVMSetCurrentDebugLocation(...). The node_id parameter is used to
+/// reliably find the correct visibility scope for the code position.
pub fn update_source_pos(fcx: &FunctionContext,
node_id: ast::NodeId,
span: span) {
/// The return value should be ignored if called from outside of the debuginfo module.
pub fn create_function_metadata(fcx: &mut FunctionContext) -> DISubprogram {
let cx = fcx.ccx;
+ let cache_key = FunctionCacheKey::for_function_context(fcx);
+
+ match dbg_cx(cx).created_functions.find_copy(&cache_key) {
+ Some(fn_metadata) => {
+ assert!(fcx.debug_context.is_some());
+ return fn_metadata;
+ }
+ None => { /* fallthrough */}
+ }
+
+ let empty_generics = ast::Generics { lifetimes: opt_vec::Empty, ty_params: opt_vec::Empty };
let fnitem = cx.tcx.items.get_copy(&fcx.id);
- let (ident, fn_decl, id) = match fnitem {
+ let (ident, fn_decl, generics, span) = match fnitem {
ast_map::node_item(ref item, _) => {
match item.node {
- ast::item_fn(ref fn_decl, _, _, _, _) => {
- (item.ident, fn_decl, item.id)
+ ast::item_fn(ref fn_decl, _, _, ref generics, _) => {
+ (item.ident, fn_decl, generics, item.span)
}
_ => fcx.ccx.sess.span_bug(item.span,
"create_function_metadata: item bound to non-function")
ast_map::node_method(
@ast::method {
decl: ref fn_decl,
- id: id,
ident: ident,
+ generics: ref generics,
+ span: span,
_
},
_,
_) => {
- (ident, fn_decl, id)
+ (ident, fn_decl, generics, span)
}
ast_map::node_expr(ref expr) => {
match expr.node {
ast::expr_fn_block(ref fn_decl, _) => {
let name = gensym_name("fn");
- (name, fn_decl, expr.id)
+ (name, fn_decl,
+ // This is not quite right. It should actually inherit the generics of the
+ // enclosing function.
+ &empty_generics,
+ expr.span)
}
_ => fcx.ccx.sess.span_bug(expr.span,
"create_function_metadata: expected an expr_fn_block here")
@ast::provided(
@ast::method {
decl: ref fn_decl,
- id: id,
ident: ident,
+ generics: ref generics,
+ span: span,
_
}),
_,
_) => {
- (ident, fn_decl, id)
+ (ident, fn_decl, generics, span)
}
_ => fcx.ccx.sess.bug(fmt!("create_function_metadata: unexpected sort of node: %?", fnitem))
};
- match dbg_cx(cx).created_functions.find_copy(&id) {
- Some(fn_metadata) => return fn_metadata,
- None => ()
- }
-
- let span = match fcx.span {
- Some(value) => value,
- None => codemap::dummy_sp()
- };
-
debug!("create_function_metadata: %s, %s",
cx.sess.str_of(ident),
cx.sess.codemap.span_to_str(span));
let loc = span_start(cx, span);
let file_metadata = file_metadata(cx, loc.file.name);
- let return_type_metadata = if cx.sess.opts.extra_debuginfo {
- match fn_decl.output.node {
- ast::ty_nil => ptr::null(),
- _ => type_metadata(cx, ty::node_id_to_type(cx.tcx, id), fn_decl.output.span)
- }
- } else {
- ptr::null()
+ let function_type_metadata = unsafe {
+ let fn_signature = get_function_signature(fcx, fn_decl);
+ llvm::LLVMDIBuilderCreateSubroutineType(DIB(cx), file_metadata, fn_signature)
};
- let fn_ty = unsafe {
- llvm::LLVMDIBuilderCreateSubroutineType(
- DIB(cx),
- file_metadata,
- create_DIArray(DIB(cx), [return_type_metadata]))
+ // get_template_parameters() will append a `<...>` clause to the function name if necessary.
+ let mut function_name = cx.sess.str_of(ident).to_owned();
+ let template_parameters = get_template_parameters(fcx,
+ generics,
+ file_metadata,
+ &mut function_name);
+
+ let fn_metadata = do function_name.to_c_str().with_ref |function_name| {
+ unsafe {
+ llvm::LLVMDIBuilderCreateFunction(
+ DIB(cx),
+ file_metadata,
+ function_name,
+ function_name,
+ file_metadata,
+ loc.line as c_uint,
+ function_type_metadata,
+ false,
+ true,
+ loc.line as c_uint,
+ FlagPrototyped as c_uint,
+ cx.sess.opts.optimize != session::No,
+ fcx.llfn,
+ template_parameters,
+ ptr::null())
+ }
};
- let fn_metadata =
- do cx.sess.str_of(ident).with_c_str |name| {
- do cx.sess.str_of(ident).with_c_str |linkage| {
- unsafe {
- llvm::LLVMDIBuilderCreateFunction(
- DIB(cx),
- file_metadata,
- name,
- linkage,
- file_metadata,
- loc.line as c_uint,
- fn_ty,
- false,
- true,
- loc.line as c_uint,
- FlagPrototyped as c_uint,
- cx.sess.opts.optimize != session::No,
- fcx.llfn,
- ptr::null(),
- ptr::null())
+ dbg_cx(cx).created_functions.insert(cache_key, fn_metadata);
+
+ // Initialize fn debug context (including scope map)
+ {
+ assert!(fcx.debug_context.is_none());
+
+ let mut fn_debug_context = ~FunctionDebugContext {
+ scope_map: HashMap::new(),
+ argument_counter: if fcx.llself.is_some() { 2 } else { 1 }
+ };
+
+ let entry_block_id = fcx.entry_bcx.get_ref().node_info.get_ref().id;
+ let entry_block = cx.tcx.items.get(&entry_block_id);
+
+ match *entry_block {
+ ast_map::node_block(ref block) => {
+ let scope_map = &mut fn_debug_context.scope_map;
+ let arg_pats = do fn_decl.inputs.map |arg_ref| { arg_ref.pat };
+
+ populate_scope_map(cx, arg_pats, block, fn_metadata, scope_map);
}
- }};
+ _ => cx.sess.span_bug(span,
+ fmt!("debuginfo::create_function_metadata() - \
+ FunctionContext::entry_bcx::node_info points to wrong type of ast_map \
+ entry. Expected: ast_map::node_block, actual: %?", *entry_block))
+ }
+
+ fcx.debug_context = Some(fn_debug_context);
+ }
+
+ return fn_metadata;
- assert!(fcx.debug_context.is_none());
+ fn get_function_signature(fcx: &FunctionContext, fn_decl: &ast::fn_decl) -> DIArray {
+ let cx = fcx.ccx;
- let mut fn_debug_context = ~FunctionDebugContext::new();
- let entry_block_id = fcx.entry_bcx.get_ref().node_info.get_ref().id;
- let entry_block = cx.tcx.items.get(&entry_block_id);
+ if !cx.sess.opts.extra_debuginfo {
+ return create_DIArray(DIB(cx), []);
+ }
+
+ let mut signature = vec::with_capacity(fn_decl.inputs.len() + 1);
- match *entry_block {
- ast_map::node_block(ref block) => {
- let scope_map = &mut fn_debug_context.scope_map;
- let arg_pats = do fn_decl.inputs.map |arg_ref| { arg_ref.pat };
+ // Return type -- llvm::DIBuilder wants this at index 0
+ match fn_decl.output.node {
+ ast::ty_nil => {
+ signature.push(ptr::null());
+ }
+ _ => {
+ let return_type = ty::node_id_to_type(cx.tcx, fcx.id);
+ let return_type = match fcx.param_substs {
+ None => return_type,
+ Some(substs) => {
+ ty::subst_tps(cx.tcx, substs.tys, substs.self_ty, return_type)
+ }
+ };
- populate_scope_map(cx, arg_pats, block, fn_metadata, scope_map);
+ signature.push(type_metadata(cx, return_type, codemap::dummy_sp()));
+ }
}
- _ => cx.sess.span_bug(span,
- fmt!("debuginfo::create_function_metadata() - \
- FunctionContext::entry_bcx::node_info points to wrong type of ast_map entry. \
- Expected: ast_map::node_block, actual: %?", *entry_block))
+
+ // arguments types
+ for arg in fn_decl.inputs.iter() {
+ let arg_type = ty::node_id_to_type(cx.tcx, arg.pat.id);
+ let arg_type = match fcx.param_substs {
+ None => arg_type,
+ Some(substs) => {
+ ty::subst_tps(cx.tcx, substs.tys, substs.self_ty, arg_type)
+ }
+ };
+
+ signature.push(type_metadata(cx, arg_type, codemap::dummy_sp()));
+ }
+
+ return create_DIArray(DIB(cx), signature);
}
- fcx.debug_context = Some(fn_debug_context);
+ fn get_template_parameters(fcx: &FunctionContext,
+ generics: &ast::Generics,
+ file_metadata: DIFile,
+ name_to_append_suffix_to: &mut ~str)
+ -> DIArray {
+ let cx = fcx.ccx;
- dbg_cx(cx).created_functions.insert(id, fn_metadata);
- return fn_metadata;
+ let self_type = match fcx.param_substs {
+ Some(@param_substs{ self_ty: self_type, _ }) => self_type,
+ _ => None
+ };
+
+ // Only true for static default methods:
+ let has_self_type = self_type.is_some();
+
+ if !generics.is_type_parameterized() && !has_self_type {
+ return ptr::null();
+ }
+
+ name_to_append_suffix_to.push_char('<');
+
+ // The list to be filled with template parameters:
+ let mut template_params: ~[DIDescriptor] = vec::with_capacity(generics.ty_params.len() + 1);
+
+ // Handle self type
+ if has_self_type {
+ let actual_self_type = self_type.unwrap();
+ let actual_self_type_metadata = type_metadata(cx,
+ actual_self_type,
+ codemap::dummy_sp());
+
+ // Add self type name to <...> clause of function name
+ let actual_self_type_name = ty_to_str(cx.tcx, actual_self_type);
+ name_to_append_suffix_to.push_str(actual_self_type_name);
+ if generics.is_type_parameterized() {
+ name_to_append_suffix_to.push_str(",");
+ }
+
+ let ident = special_idents::type_self;
+
+ let param_metadata = do cx.sess.str_of(ident).to_c_str().with_ref |name| {
+ unsafe {
+ llvm::LLVMDIBuilderCreateTemplateTypeParameter(
+ DIB(cx),
+ file_metadata,
+ name,
+ actual_self_type_metadata,
+ ptr::null(),
+ 0,
+ 0)
+ }
+ };
+
+ template_params.push(param_metadata);
+ }
+
+ // Handle other generic parameters
+ let actual_types = match fcx.param_substs {
+ Some(@param_substs { tys: ref types, _ }) => types,
+ None => {
+ return create_DIArray(DIB(cx), template_params);
+ }
+ };
+
+ for (index, &ast::TyParam{ ident: ident, _ }) in generics.ty_params.iter().enumerate() {
+ let actual_type = actual_types[index];
+ let actual_type_metadata = type_metadata(cx, actual_type, codemap::dummy_sp());
+
+ // Add actual type name to <...> clause of function name
+ let actual_type_name = ty_to_str(cx.tcx, actual_type);
+ name_to_append_suffix_to.push_str(actual_type_name);
+
+ if index != generics.ty_params.len() - 1 {
+ name_to_append_suffix_to.push_str(",");
+ }
+
+ let param_metadata = do cx.sess.str_of(ident).to_c_str().with_ref |name| {
+ unsafe {
+ llvm::LLVMDIBuilderCreateTemplateTypeParameter(
+ DIB(cx),
+ file_metadata,
+ name,
+ actual_type_metadata,
+ ptr::null(),
+ 0,
+ 0)
+ }
+ };
+
+ template_params.push(param_metadata);
+ }
+
+ name_to_append_suffix_to.push_char('>');
+
+ return create_DIArray(DIB(cx), template_params);
+ }
}
let struct_llvm_type = type_of::type_of(cx, struct_type);
let field_llvm_types = do fields.map |field| { type_of::type_of(cx, field.mt.ty) };
- let field_names = do fields.map |field| { cx.sess.str_of(field.ident).to_owned() };
+ let field_names = do fields.map |field| {
+ if field.ident == special_idents::unnamed_field {
+ ~""
+ } else {
+ cx.sess.str_of(field.ident).to_owned()
+ }
+ };
let field_types_metadata = do fields.map |field| {
type_metadata(cx, field.mt.ty, span)
};
cx.dbg_cx.get_ref().builder
}
+fn assert_fcx_has_span(fcx: &FunctionContext) {
+ if fcx.span.is_none() {
+ fcx.ccx.sess.bug(fmt!("debuginfo: Encountered function %s with invalid source span. \
+ This function should have been ignored by debuginfo generation.",
+ ast_map::path_to_str(fcx.path, fcx.ccx.sess.intr())));
+ }
+}
// This procedure builds the *scope map* for a given function, which maps any given ast::NodeId in
// the function's AST to the correct DIScope metadata instance.
assert_eq!(datum.appropriate_mode(tcx), ByValue);
Store(bcx, datum.to_appropriate_llval(bcx), llfn);
let llenv = GEPi(bcx, scratch.val, [0u, abi::fn_field_box]);
- Store(bcx, base::null_env_ptr(bcx), llenv);
+ Store(bcx, base::null_env_ptr(bcx.ccx()), llenv);
DatumBlock {bcx: bcx, datum: scratch}
}
debuginfo::update_source_pos(bcx.fcx, expr.id, expr.span);
let dest = {
- if ty::type_is_nil(ty) || ty::type_is_bot(ty) {
+ if ty::type_is_voidish(ty) {
Ignore
} else {
dest
ty::RvalueDpsExpr => {
let ty = expr_ty(bcx, expr);
- if ty::type_is_nil(ty) || ty::type_is_bot(ty) {
+ if ty::type_is_voidish(ty) {
bcx = trans_rvalue_dps_unadjusted(bcx, expr, Ignore);
return nil(bcx, ty);
} else {
return bcx;
}
}
- ast::def_struct(*) => {
+ ast::def_struct(def_id) => {
let ty = expr_ty(bcx, ref_expr);
match ty::get(ty).sty {
ty::ty_struct(did, _) if ty::has_dtor(ccx.tcx, did) => {
let repr = adt::represent_type(ccx, ty);
adt::trans_start_init(bcx, repr, lldest, 0);
}
- _ => {}
+ ty::ty_bare_fn(*) => {
+ let fn_data = callee::trans_fn_ref(bcx, def_id, ref_expr.id);
+ Store(bcx, fn_data.llfn, lldest);
+ }
+ _ => ()
}
return bcx;
}
// except according to those terms.
-use back::{link, abi};
-use lib::llvm::{Pointer, ValueRef};
+use back::{link};
+use std::libc::c_uint;
+use lib::llvm::{ValueRef, Attribute, CallConv};
+use lib::llvm::llvm;
use lib;
-use middle::trans::base::*;
+use middle::trans::machine;
+use middle::trans::base;
+use middle::trans::base::push_ctxt;
use middle::trans::cabi;
-use middle::trans::cabi_x86;
-use middle::trans::cabi_x86_64;
-use middle::trans::cabi_arm;
-use middle::trans::cabi_mips;
use middle::trans::build::*;
-use middle::trans::callee::*;
+use middle::trans::builder::noname;
use middle::trans::common::*;
-use middle::trans::datum::*;
-use middle::trans::expr::Ignore;
-use middle::trans::machine::llsize_of;
-use middle::trans::glue;
-use middle::trans::machine;
use middle::trans::type_of::*;
use middle::trans::type_of;
use middle::ty;
use middle::ty::FnSig;
-use util::ppaux::ty_to_str;
-use std::cell::Cell;
+use std::uint;
use std::vec;
use syntax::codemap::span;
-use syntax::{ast, ast_util};
+use syntax::{ast};
use syntax::{attr, ast_map};
-use syntax::opt_vec;
use syntax::parse::token::special_idents;
-use syntax::parse::token;
-use syntax::abi::{X86, X86_64, Arm, Mips};
use syntax::abi::{RustIntrinsic, Rust, Stdcall, Fastcall,
- Cdecl, Aapcs, C};
+ Cdecl, Aapcs, C, AbiSet};
+use util::ppaux::{Repr, UserString};
use middle::trans::type_::Type;
-fn abi_info(ccx: @mut CrateContext) -> @cabi::ABIInfo {
- return match ccx.sess.targ_cfg.arch {
- X86 => cabi_x86::abi_info(ccx),
- X86_64 => cabi_x86_64::abi_info(),
- Arm => cabi_arm::abi_info(),
- Mips => cabi_mips::abi_info(),
- }
-}
-
-pub fn link_name(ccx: &CrateContext, i: &ast::foreign_item) -> @str {
- match attr::first_attr_value_str_by_name(i.attrs, "link_name") {
- None => ccx.sess.str_of(i.ident),
- Some(ln) => ln,
- }
-}
+///////////////////////////////////////////////////////////////////////////
+// Type definitions
-struct ShimTypes {
+struct ForeignTypes {
+ /// Rust signature of the function
fn_sig: ty::FnSig,
+ /// Adapter object for handling native ABI rules (trust me, you
+ /// don't want to know)
+ fn_ty: cabi::FnType,
+
/// LLVM types that will appear on the foreign function
llsig: LlvmSignature,
/// True if there is a return value (not bottom, not unit)
ret_def: bool,
-
- /// Type of the struct we will use to shuttle values back and forth.
- /// This is always derived from the llsig.
- bundle_ty: Type,
-
- /// Type of the shim function itself.
- shim_fn_ty: Type,
-
- /// Adapter object for handling native ABI rules (trust me, you
- /// don't want to know).
- fn_ty: cabi::FnType
}
struct LlvmSignature {
+ // LLVM versions of the types of this function's arguments.
llarg_tys: ~[Type],
- llret_ty: Type,
- sret: bool,
-}
-fn foreign_signature(ccx: &mut CrateContext, fn_sig: &ty::FnSig)
- -> LlvmSignature {
- /*!
- * The ForeignSignature is the LLVM types of the arguments/return type
- * of a function. Note that these LLVM types are not quite the same
- * as the LLVM types would be for a native Rust function because foreign
- * functions just plain ignore modes. They also don't pass aggregate
- * values by pointer like we do.
- */
+ // LLVM version of the type that this function returns. Note that
+ // this *may not be* the declared return type of the foreign
+ // function, because the foreign function may opt to return via an
+ // out pointer.
+ llret_ty: Type,
- let llarg_tys = fn_sig.inputs.map(|arg_ty| type_of(ccx, *arg_ty));
- let llret_ty = type_of::type_of(ccx, fn_sig.output);
- LlvmSignature {
- llarg_tys: llarg_tys,
- llret_ty: llret_ty,
- sret: !ty::type_is_immediate(ccx.tcx, fn_sig.output),
- }
+ // True if *Rust* would use an outpointer for this function.
+ sret: bool,
}
-fn shim_types(ccx: @mut CrateContext, id: ast::NodeId) -> ShimTypes {
- let fn_sig = match ty::get(ty::node_id_to_type(ccx.tcx, id)).sty {
- ty::ty_bare_fn(ref fn_ty) => fn_ty.sig.clone(),
- _ => ccx.sess.bug("c_arg_and_ret_lltys called on non-function type")
- };
- let llsig = foreign_signature(ccx, &fn_sig);
- let bundle_ty = Type::struct_(llsig.llarg_tys + &[llsig.llret_ty.ptr_to()], false);
- let ret_def = !ty::type_is_bot(fn_sig.output) &&
- !ty::type_is_nil(fn_sig.output);
- let fn_ty = abi_info(ccx).compute_info(llsig.llarg_tys, llsig.llret_ty, ret_def);
- ShimTypes {
- fn_sig: fn_sig,
- llsig: llsig,
- ret_def: ret_def,
- bundle_ty: bundle_ty,
- shim_fn_ty: Type::func([bundle_ty.ptr_to()], &Type::void()),
- fn_ty: fn_ty
- }
-}
-type shim_arg_builder<'self> =
- &'self fn(bcx: @mut Block, tys: &ShimTypes,
- llargbundle: ValueRef) -> ~[ValueRef];
-
-type shim_ret_builder<'self> =
- &'self fn(bcx: @mut Block, tys: &ShimTypes,
- llargbundle: ValueRef,
- llretval: ValueRef);
-
-fn build_shim_fn_(ccx: @mut CrateContext,
- shim_name: &str,
- llbasefn: ValueRef,
- tys: &ShimTypes,
- cc: lib::llvm::CallConv,
- arg_builder: shim_arg_builder,
- ret_builder: shim_ret_builder)
- -> ValueRef {
- let llshimfn = decl_internal_cdecl_fn(
- ccx.llmod, shim_name, tys.shim_fn_ty);
-
- // Declare the body of the shim function:
- let fcx = new_fn_ctxt(ccx, ~[], llshimfn, tys.fn_sig.output, None);
- let bcx = fcx.entry_bcx.unwrap();
-
- let llargbundle = get_param(llshimfn, 0u);
- let llargvals = arg_builder(bcx, tys, llargbundle);
-
- // Create the call itself and store the return value:
- let llretval = CallWithConv(bcx, llbasefn, llargvals, cc);
-
- ret_builder(bcx, tys, llargbundle, llretval);
-
- // Don't finish up the function in the usual way, because this doesn't
- // follow the normal Rust calling conventions.
- let ret_cx = match fcx.llreturn {
- Some(llreturn) => raw_block(fcx, false, llreturn),
- None => bcx
- };
- RetVoid(ret_cx);
- fcx.cleanup();
+///////////////////////////////////////////////////////////////////////////
+// Calls to external functions
- return llshimfn;
-}
+fn llvm_calling_convention(ccx: @mut CrateContext,
+ abis: AbiSet)
+ -> Option<CallConv> {
+ let arch = ccx.sess.targ_cfg.arch;
+ abis.for_arch(arch).map(|abi| {
+ match *abi {
+ RustIntrinsic => {
+ // Intrinsics are emitted by monomorphic fn
+ ccx.sess.bug(fmt!("Asked to register intrinsic fn"));
+ }
-type wrap_arg_builder<'self> = &'self fn(bcx: @mut Block,
- tys: &ShimTypes,
- llwrapfn: ValueRef,
- llargbundle: ValueRef);
-
-type wrap_ret_builder<'self> = &'self fn(bcx: @mut Block,
- tys: &ShimTypes,
- llargbundle: ValueRef);
-
-fn build_wrap_fn_(ccx: @mut CrateContext,
- tys: &ShimTypes,
- llshimfn: ValueRef,
- llwrapfn: ValueRef,
- shim_upcall: ValueRef,
- needs_c_return: bool,
- arg_builder: wrap_arg_builder,
- ret_builder: wrap_ret_builder) {
- let _icx = push_ctxt("foreign::build_wrap_fn_");
- let fcx = new_fn_ctxt(ccx, ~[], llwrapfn, tys.fn_sig.output, None);
- let bcx = fcx.entry_bcx.unwrap();
-
- // Patch up the return type if it's not immediate and we're returning via
- // the C ABI.
- if needs_c_return && !ty::type_is_immediate(ccx.tcx, tys.fn_sig.output) {
- let lloutputtype = type_of::type_of(fcx.ccx, tys.fn_sig.output);
- fcx.llretptr = Some(alloca(bcx, lloutputtype, ""));
- }
+ Rust => {
+ // FIXME(#3678) Implement linking to foreign fns with Rust ABI
+ ccx.sess.unimpl(
+ fmt!("Foreign functions with Rust ABI"));
+ }
- // Allocate the struct and write the arguments into it.
- let llargbundle = alloca(bcx, tys.bundle_ty, "__llargbundle");
- arg_builder(bcx, tys, llwrapfn, llargbundle);
+ Stdcall => lib::llvm::X86StdcallCallConv,
+ Fastcall => lib::llvm::X86FastcallCallConv,
+ C => lib::llvm::CCallConv,
- // Create call itself.
- let llshimfnptr = PointerCast(bcx, llshimfn, Type::i8p());
- let llrawargbundle = PointerCast(bcx, llargbundle, Type::i8p());
- Call(bcx, shim_upcall, [llrawargbundle, llshimfnptr]);
- ret_builder(bcx, tys, llargbundle);
+ // NOTE These API constants ought to be more specific
+ Cdecl => lib::llvm::CCallConv,
+ Aapcs => lib::llvm::CCallConv,
+ }
+ })
+}
- // Then return according to the C ABI.
- let return_context = match fcx.llreturn {
- Some(llreturn) => raw_block(fcx, false, llreturn),
- None => bcx
- };
- let llfunctiontype = val_ty(llwrapfn);
- let llfunctiontype = llfunctiontype.element_type();
- let return_type = llfunctiontype.return_type();
- if return_type.kind() == ::lib::llvm::Void {
- // XXX: This might be wrong if there are any functions for which
- // the C ABI specifies a void output pointer and the Rust ABI
- // does not.
- RetVoid(return_context);
- } else {
- // Cast if we have to...
- // XXX: This is ugly.
- let llretptr = BitCast(return_context, fcx.llretptr.unwrap(), return_type.ptr_to());
- Ret(return_context, Load(return_context, llretptr));
- }
- fcx.cleanup();
-}
+pub fn register_foreign_item_fn(ccx: @mut CrateContext,
+ abis: AbiSet,
+ path: &ast_map::path,
+ foreign_item: @ast::foreign_item) -> ValueRef {
+ /*!
+ * Registers a foreign function found in a library.
+ * Just adds a LLVM global.
+ */
-// For each foreign function F, we generate a wrapper function W and a shim
-// function S that all work together. The wrapper function W is the function
-// that other rust code actually invokes. Its job is to marshall the
-// arguments into a struct. It then uses a small bit of assembly to switch
-// over to the C stack and invoke the shim function. The shim function S then
-// unpacks the arguments from the struct and invokes the actual function F
-// according to its specified calling convention.
-//
-// Example: Given a foreign c-stack function F(x: X, y: Y) -> Z,
-// we generate a wrapper function W that looks like:
-//
-// void W(Z* dest, void *env, X x, Y y) {
-// struct { X x; Y y; Z *z; } args = { x, y, z };
-// call_on_c_stack_shim(S, &args);
-// }
-//
-// The shim function S then looks something like:
-//
-// void S(struct { X x; Y y; Z *z; } *args) {
-// *args->z = F(args->x, args->y);
-// }
-//
-// However, if the return type of F is dynamically sized or of aggregate type,
-// the shim function looks like:
-//
-// void S(struct { X x; Y y; Z *z; } *args) {
-// F(args->z, args->x, args->y);
-// }
-//
-// Note: on i386, the layout of the args struct is generally the same
-// as the desired layout of the arguments on the C stack. Therefore,
-// we could use upcall_alloc_c_stack() to allocate the `args`
-// structure and switch the stack pointer appropriately to avoid a
-// round of copies. (In fact, the shim function itself is
-// unnecessary). We used to do this, in fact, and will perhaps do so
-// in the future.
-pub fn trans_foreign_mod(ccx: @mut CrateContext,
- path: &ast_map::path,
- foreign_mod: &ast::foreign_mod) {
- let _icx = push_ctxt("foreign::trans_foreign_mod");
+ debug!("register_foreign_item_fn(abis=%s, \
+ path=%s, \
+ foreign_item.id=%?)",
+ abis.repr(ccx.tcx),
+ path.repr(ccx.tcx),
+ foreign_item.id);
- let arch = ccx.sess.targ_cfg.arch;
- let abi = match foreign_mod.abis.for_arch(arch) {
+ let cc = match llvm_calling_convention(ccx, abis) {
+ Some(cc) => cc,
None => {
+ // FIXME(#8357) We really ought to report a span here
ccx.sess.fatal(
- fmt!("No suitable ABI for target architecture \
+ fmt!("ABI `%s` has no suitable ABI \
+ for target architecture \
in module %s",
+ abis.user_string(ccx.tcx),
ast_map::path_to_str(*path,
ccx.sess.intr())));
}
-
- Some(abi) => abi,
};
- for &foreign_item in foreign_mod.items.iter() {
- match foreign_item.node {
- ast::foreign_item_fn(*) => {
- let id = foreign_item.id;
- match abi {
- RustIntrinsic => {
- // Intrinsics are emitted by monomorphic fn
- }
-
- Rust => {
- // FIXME(#3678) Implement linking to foreign fns with Rust ABI
- ccx.sess.unimpl(
- fmt!("Foreign functions with Rust ABI"));
- }
-
- Stdcall => {
- build_foreign_fn(ccx, id, foreign_item,
- lib::llvm::X86StdcallCallConv);
- }
-
- Fastcall => {
- build_foreign_fn(ccx, id, foreign_item,
- lib::llvm::X86FastcallCallConv);
- }
-
- Cdecl => {
- // FIXME(#3678) should really be more specific
- build_foreign_fn(ccx, id, foreign_item,
- lib::llvm::CCallConv);
- }
-
- Aapcs => {
- // FIXME(#3678) should really be more specific
- build_foreign_fn(ccx, id, foreign_item,
- lib::llvm::CCallConv);
- }
-
- C => {
- build_foreign_fn(ccx, id, foreign_item,
- lib::llvm::CCallConv);
- }
- }
- }
- ast::foreign_item_static(*) => {
- let ident = token::ident_to_str(&foreign_item.ident);
- ccx.item_symbols.insert(foreign_item.id, /* bad */ident.to_owned());
- }
- }
- }
+ // Register the function as a C extern fn
+ let lname = link_name(ccx, foreign_item);
+ let tys = foreign_types_for_id(ccx, foreign_item.id);
- fn build_foreign_fn(ccx: @mut CrateContext,
- id: ast::NodeId,
- foreign_item: @ast::foreign_item,
- cc: lib::llvm::CallConv) {
- let llwrapfn = get_item_val(ccx, id);
- let tys = shim_types(ccx, id);
- if attr::contains_name(foreign_item.attrs, "rust_stack") {
- build_direct_fn(ccx, llwrapfn, foreign_item,
- &tys, cc);
- } else if attr::contains_name(foreign_item.attrs, "fast_ffi") {
- build_fast_ffi_fn(ccx, llwrapfn, foreign_item, &tys, cc);
- } else {
- let llshimfn = build_shim_fn(ccx, foreign_item, &tys, cc);
- build_wrap_fn(ccx, &tys, llshimfn, llwrapfn);
- }
- }
+ // Create the LLVM value for the C extern fn
+ let llfn_ty = lltype_for_fn_from_foreign_types(&tys);
+ let llfn = base::get_extern_fn(&mut ccx.externs, ccx.llmod,
+ lname, cc, llfn_ty);
+ add_argument_attributes(&tys, llfn);
- fn build_shim_fn(ccx: @mut CrateContext,
- foreign_item: &ast::foreign_item,
- tys: &ShimTypes,
- cc: lib::llvm::CallConv)
- -> ValueRef {
- /*!
- *
- * Build S, from comment above:
- *
- * void S(struct { X x; Y y; Z *z; } *args) {
- * F(args->z, args->x, args->y);
- * }
- */
-
- let _icx = push_ctxt("foreign::build_shim_fn");
-
- fn build_args(bcx: @mut Block, tys: &ShimTypes, llargbundle: ValueRef)
- -> ~[ValueRef] {
- let _icx = push_ctxt("foreign::shim::build_args");
- tys.fn_ty.build_shim_args(bcx, tys.llsig.llarg_tys, llargbundle)
- }
+ return llfn;
+}
- fn build_ret(bcx: @mut Block,
- tys: &ShimTypes,
- llargbundle: ValueRef,
- llretval: ValueRef) {
- let _icx = push_ctxt("foreign::shim::build_ret");
- tys.fn_ty.build_shim_ret(bcx,
- tys.llsig.llarg_tys,
- tys.ret_def,
- llargbundle,
- llretval);
- }
+pub fn trans_native_call(bcx: @mut Block,
+ callee_ty: ty::t,
+ llfn: ValueRef,
+ llretptr: ValueRef,
+ llargs_rust: &[ValueRef]) -> @mut Block {
+ /*!
+ * Prepares a call to a native function. This requires adapting
+ * from the Rust argument passing rules to the native rules.
+ *
+ * # Parameters
+ *
+ * - `callee_ty`: Rust type for the function we are calling
+ * - `llfn`: the function pointer we are calling
+ * - `llretptr`: where to store the return value of the function
+ * - `llargs_rust`: a list of the argument values, prepared
+ * as they would be if calling a Rust function
+ */
- let lname = link_name(ccx, foreign_item);
- let llbasefn = base_fn(ccx, lname, tys, cc);
- // Name the shim function
- let shim_name = fmt!("%s__c_stack_shim", lname);
- build_shim_fn_(ccx,
- shim_name,
- llbasefn,
- tys,
- cc,
- build_args,
- build_ret)
- }
+ let ccx = bcx.ccx();
+ let tcx = bcx.tcx();
- fn base_fn(ccx: &CrateContext,
- lname: &str,
- tys: &ShimTypes,
- cc: lib::llvm::CallConv)
- -> ValueRef {
- // Declare the "prototype" for the base function F:
- do tys.fn_ty.decl_fn |fnty| {
- decl_fn(ccx.llmod, lname, cc, fnty)
- }
- }
+ debug!("trans_native_call(callee_ty=%s, \
+ llfn=%s, \
+ llretptr=%s)",
+ callee_ty.repr(tcx),
+ ccx.tn.val_to_str(llfn),
+ ccx.tn.val_to_str(llretptr));
- // FIXME (#2535): this is very shaky and probably gets ABIs wrong all
- // over the place
- fn build_direct_fn(ccx: @mut CrateContext,
- decl: ValueRef,
- item: &ast::foreign_item,
- tys: &ShimTypes,
- cc: lib::llvm::CallConv) {
- debug!("build_direct_fn(%s)", link_name(ccx, item));
-
- let fcx = new_fn_ctxt(ccx, ~[], decl, tys.fn_sig.output, None);
- let bcx = fcx.entry_bcx.unwrap();
- let llbasefn = base_fn(ccx, link_name(ccx, item), tys, cc);
- let ty = ty::lookup_item_type(ccx.tcx,
- ast_util::local_def(item.id)).ty;
- let ret_ty = ty::ty_fn_ret(ty);
- let args = vec::from_fn(ty::ty_fn_args(ty).len(), |i| {
- get_param(decl, fcx.arg_pos(i))
- });
- let retval = Call(bcx, llbasefn, args);
- if !ty::type_is_nil(ret_ty) && !ty::type_is_bot(ret_ty) {
- Store(bcx, retval, fcx.llretptr.unwrap());
+ let (fn_abis, fn_sig) = match ty::get(callee_ty).sty {
+ ty::ty_bare_fn(ref fn_ty) => (fn_ty.abis, fn_ty.sig.clone()),
+ _ => ccx.sess.bug("trans_native_call called on non-function type")
+ };
+ let llsig = foreign_signature(ccx, &fn_sig);
+ let ret_def = !ty::type_is_voidish(fn_sig.output);
+ let fn_type = cabi::compute_abi_info(ccx,
+ llsig.llarg_tys,
+ llsig.llret_ty,
+ ret_def);
+
+ let all_arg_tys: &[cabi::LLVMType] = fn_type.arg_tys;
+ let all_attributes: &[Option<Attribute>] = fn_type.attrs;
+
+ let mut llargs_foreign = ~[];
+
+ // If the foreign ABI expects return value by pointer, supply the
+ // pointer that Rust gave us. Sometimes we have to bitcast
+ // because foreign fns return slightly different (but equivalent)
+ // views on the same type (e.g., i64 in place of {i32,i32}).
+ let (arg_tys, attributes) = {
+ if fn_type.sret {
+ if all_arg_tys[0].cast {
+ let llcastedretptr =
+ BitCast(bcx, llretptr, all_arg_tys[0].ty.ptr_to());
+ llargs_foreign.push(llcastedretptr);
+ } else {
+ llargs_foreign.push(llretptr);
+ }
+ (all_arg_tys.tail(), all_attributes.tail())
+ } else {
+ (all_arg_tys, all_attributes)
}
- finish_fn(fcx, bcx);
- }
+ };
- // FIXME (#2535): this is very shaky and probably gets ABIs wrong all
- // over the place
- fn build_fast_ffi_fn(ccx: @mut CrateContext,
- decl: ValueRef,
- item: &ast::foreign_item,
- tys: &ShimTypes,
- cc: lib::llvm::CallConv) {
- debug!("build_fast_ffi_fn(%s)", link_name(ccx, item));
-
- let fcx = new_fn_ctxt(ccx, ~[], decl, tys.fn_sig.output, None);
- let bcx = fcx.entry_bcx.unwrap();
- let llbasefn = base_fn(ccx, link_name(ccx, item), tys, cc);
- set_no_inline(fcx.llfn);
- set_fixed_stack_segment(fcx.llfn);
- let ty = ty::lookup_item_type(ccx.tcx,
- ast_util::local_def(item.id)).ty;
- let ret_ty = ty::ty_fn_ret(ty);
- let args = vec::from_fn(ty::ty_fn_args(ty).len(), |i| {
- get_param(decl, fcx.arg_pos(i))
- });
- let retval = Call(bcx, llbasefn, args);
- if !ty::type_is_nil(ret_ty) && !ty::type_is_bot(ret_ty) {
- Store(bcx, retval, fcx.llretptr.unwrap());
- }
- finish_fn(fcx, bcx);
- }
+ for (i, &llarg_rust) in llargs_rust.iter().enumerate() {
+ let mut llarg_rust = llarg_rust;
- fn build_wrap_fn(ccx: @mut CrateContext,
- tys: &ShimTypes,
- llshimfn: ValueRef,
- llwrapfn: ValueRef) {
- /*!
- *
- * Build W, from comment above:
- *
- * void W(Z* dest, void *env, X x, Y y) {
- * struct { X x; Y y; Z *z; } args = { x, y, z };
- * call_on_c_stack_shim(S, &args);
- * }
- *
- * One thing we have to be very careful of is to
- * account for the Rust modes.
- */
-
- let _icx = push_ctxt("foreign::build_wrap_fn");
-
- build_wrap_fn_(ccx,
- tys,
- llshimfn,
- llwrapfn,
- ccx.upcalls.call_shim_on_c_stack,
- false,
- build_args,
- build_ret);
-
- fn build_args(bcx: @mut Block,
- tys: &ShimTypes,
- llwrapfn: ValueRef,
- llargbundle: ValueRef) {
- let _icx = push_ctxt("foreign::wrap::build_args");
- let ccx = bcx.ccx();
- let n = tys.llsig.llarg_tys.len();
- for i in range(0u, n) {
- let arg_i = bcx.fcx.arg_pos(i);
- let mut llargval = get_param(llwrapfn, arg_i);
-
- // In some cases, Rust will pass a pointer which the
- // native C type doesn't have. In that case, just
- // load the value from the pointer.
- if type_of::arg_is_indirect(ccx, &tys.fn_sig.inputs[i]) {
- llargval = Load(bcx, llargval);
- }
+ // Does Rust pass this argument by pointer?
+ let rust_indirect = type_of::arg_is_indirect(ccx, fn_sig.inputs[i]);
- store_inbounds(bcx, llargval, llargbundle, [0u, i]);
- }
+ debug!("argument %u, llarg_rust=%s, rust_indirect=%b, arg_ty=%s",
+ i,
+ ccx.tn.val_to_str(llarg_rust),
+ rust_indirect,
+ ccx.tn.type_to_str(arg_tys[i].ty));
- for &retptr in bcx.fcx.llretptr.iter() {
- store_inbounds(bcx, retptr, llargbundle, [0u, n]);
- }
+ // Ensure that we always have the Rust value indirectly,
+ // because it makes bitcasting easier.
+ if !rust_indirect {
+ let scratch = base::alloca(bcx, arg_tys[i].ty, "__arg");
+ Store(bcx, llarg_rust, scratch);
+ llarg_rust = scratch;
}
- fn build_ret(bcx: @mut Block,
- shim_types: &ShimTypes,
- llargbundle: ValueRef) {
- let _icx = push_ctxt("foreign::wrap::build_ret");
- let arg_count = shim_types.fn_sig.inputs.len();
- for &retptr in bcx.fcx.llretptr.iter() {
- let llretptr = load_inbounds(bcx, llargbundle, [0, arg_count]);
- Store(bcx, Load(bcx, llretptr), retptr);
- }
- }
- }
-}
+ debug!("llarg_rust=%s (after indirection)",
+ ccx.tn.val_to_str(llarg_rust));
-pub fn trans_intrinsic(ccx: @mut CrateContext,
- decl: ValueRef,
- item: &ast::foreign_item,
- path: ast_map::path,
- substs: @param_substs,
- attributes: &[ast::Attribute],
- ref_id: Option<ast::NodeId>) {
- debug!("trans_intrinsic(item.ident=%s)", ccx.sess.str_of(item.ident));
-
- fn simple_llvm_intrinsic(bcx: @mut Block, name: &'static str, num_args: uint) {
- assert!(num_args <= 4);
- let mut args = [0 as ValueRef, ..4];
- let first_real_arg = bcx.fcx.arg_pos(0u);
- for i in range(0u, num_args) {
- args[i] = get_param(bcx.fcx.llfn, first_real_arg + i);
+ // Check whether we need to do any casting
+ let foreignarg_ty = arg_tys[i].ty;
+ if arg_tys[i].cast {
+ llarg_rust = BitCast(bcx, llarg_rust, foreignarg_ty.ptr_to());
}
- let llfn = bcx.ccx().intrinsics.get_copy(&name);
- Ret(bcx, Call(bcx, llfn, args.slice(0, num_args)));
- }
-
- fn with_overflow_instrinsic(bcx: @mut Block, name: &'static str) {
- let first_real_arg = bcx.fcx.arg_pos(0u);
- let a = get_param(bcx.fcx.llfn, first_real_arg);
- let b = get_param(bcx.fcx.llfn, first_real_arg + 1);
- let llfn = bcx.ccx().intrinsics.get_copy(&name);
-
- // convert `i1` to a `bool`, and write to the out parameter
- let val = Call(bcx, llfn, [a, b]);
- let result = ExtractValue(bcx, val, 0);
- let overflow = ZExt(bcx, ExtractValue(bcx, val, 1), Type::bool());
- let retptr = get_param(bcx.fcx.llfn, bcx.fcx.out_arg_pos());
- let ret = Load(bcx, retptr);
- let ret = InsertValue(bcx, ret, result, 0);
- let ret = InsertValue(bcx, ret, overflow, 1);
- Store(bcx, ret, retptr);
- RetVoid(bcx)
- }
- fn memcpy_intrinsic(bcx: @mut Block, name: &'static str, tp_ty: ty::t, sizebits: u8) {
- let ccx = bcx.ccx();
- let lltp_ty = type_of::type_of(ccx, tp_ty);
- let align = C_i32(machine::llalign_of_min(ccx, lltp_ty) as i32);
- let size = match sizebits {
- 32 => C_i32(machine::llsize_of_real(ccx, lltp_ty) as i32),
- 64 => C_i64(machine::llsize_of_real(ccx, lltp_ty) as i64),
- _ => ccx.sess.fatal("Invalid value for sizebits")
- };
+ debug!("llarg_rust=%s (after casting)",
+ ccx.tn.val_to_str(llarg_rust));
- let decl = bcx.fcx.llfn;
- let first_real_arg = bcx.fcx.arg_pos(0u);
- let dst_ptr = PointerCast(bcx, get_param(decl, first_real_arg), Type::i8p());
- let src_ptr = PointerCast(bcx, get_param(decl, first_real_arg + 1), Type::i8p());
- let count = get_param(decl, first_real_arg + 2);
- let volatile = C_i1(false);
- let llfn = bcx.ccx().intrinsics.get_copy(&name);
- Call(bcx, llfn, [dst_ptr, src_ptr, Mul(bcx, size, count), align, volatile]);
- RetVoid(bcx);
- }
-
- fn memset_intrinsic(bcx: @mut Block, name: &'static str, tp_ty: ty::t, sizebits: u8) {
- let ccx = bcx.ccx();
- let lltp_ty = type_of::type_of(ccx, tp_ty);
- let align = C_i32(machine::llalign_of_min(ccx, lltp_ty) as i32);
- let size = match sizebits {
- 32 => C_i32(machine::llsize_of_real(ccx, lltp_ty) as i32),
- 64 => C_i64(machine::llsize_of_real(ccx, lltp_ty) as i64),
- _ => ccx.sess.fatal("Invalid value for sizebits")
+ // Finally, load the value if needed for the foreign ABI
+ let foreign_indirect = attributes[i].is_some();
+ let llarg_foreign = if foreign_indirect {
+ llarg_rust
+ } else {
+ Load(bcx, llarg_rust)
};
- let decl = bcx.fcx.llfn;
- let first_real_arg = bcx.fcx.arg_pos(0u);
- let dst_ptr = PointerCast(bcx, get_param(decl, first_real_arg), Type::i8p());
- let val = get_param(decl, first_real_arg + 1);
- let count = get_param(decl, first_real_arg + 2);
- let volatile = C_i1(false);
- let llfn = bcx.ccx().intrinsics.get_copy(&name);
- Call(bcx, llfn, [dst_ptr, val, Mul(bcx, size, count), align, volatile]);
- RetVoid(bcx);
- }
+ debug!("argument %u, llarg_foreign=%s",
+ i, ccx.tn.val_to_str(llarg_foreign));
- fn count_zeros_intrinsic(bcx: @mut Block, name: &'static str) {
- let x = get_param(bcx.fcx.llfn, bcx.fcx.arg_pos(0u));
- let y = C_i1(false);
- let llfn = bcx.ccx().intrinsics.get_copy(&name);
- Ret(bcx, Call(bcx, llfn, [x, y]));
+ llargs_foreign.push(llarg_foreign);
}
- let output_type = ty::ty_fn_ret(ty::node_id_to_type(ccx.tcx, item.id));
-
- let fcx = new_fn_ctxt_w_id(ccx,
- path,
- decl,
- item.id,
- output_type,
- true,
- Some(substs),
- None,
- Some(item.span));
-
- set_always_inline(fcx.llfn);
+ let cc = match llvm_calling_convention(ccx, fn_abis) {
+ Some(cc) => cc,
+ None => {
+ // FIXME(#8357) We really ought to report a span here
+ ccx.sess.fatal(
+ fmt!("ABI string `%s` has no suitable ABI \
+ for target architecture",
+ fn_abis.user_string(ccx.tcx)));
+ }
+ };
- // Set the fixed stack segment flag if necessary.
- if attr::contains_name(attributes, "fixed_stack_segment") {
- set_fixed_stack_segment(fcx.llfn);
- }
+ let llforeign_retval = CallWithConv(bcx, llfn, llargs_foreign, cc);
- let mut bcx = fcx.entry_bcx.unwrap();
- let first_real_arg = fcx.arg_pos(0u);
+ // If the function we just called does not use an outpointer,
+ // store the result into the rust outpointer. Cast the outpointer
+ // type to match because some ABIs will use a different type than
+ // the Rust type. e.g., a {u32,u32} struct could be returned as
+ // u64.
+ if ret_def && !fn_type.sret {
+ let llrust_ret_ty = llsig.llret_ty;
+ let llforeign_ret_ty = fn_type.ret_ty.ty;
- let nm = ccx.sess.str_of(item.ident);
- let name = nm.as_slice();
+ debug!("llretptr=%s", ccx.tn.val_to_str(llretptr));
+ debug!("llforeign_retval=%s", ccx.tn.val_to_str(llforeign_retval));
+ debug!("llrust_ret_ty=%s", ccx.tn.type_to_str(llrust_ret_ty));
+ debug!("llforeign_ret_ty=%s", ccx.tn.type_to_str(llforeign_ret_ty));
- // This requires that atomic intrinsics follow a specific naming pattern:
- // "atomic_<operation>[_<ordering>], and no ordering means SeqCst
- if name.starts_with("atomic_") {
- let split : ~[&str] = name.split_iter('_').collect();
- assert!(split.len() >= 2, "Atomic intrinsic not correct format");
- let order = if split.len() == 2 {
- lib::llvm::SequentiallyConsistent
+ if llrust_ret_ty == llforeign_ret_ty {
+ Store(bcx, llforeign_retval, llretptr);
} else {
- match split[2] {
- "relaxed" => lib::llvm::Monotonic,
- "acq" => lib::llvm::Acquire,
- "rel" => lib::llvm::Release,
- "acqrel" => lib::llvm::AcquireRelease,
- _ => ccx.sess.fatal("Unknown ordering in atomic intrinsic")
- }
- };
-
- match split[1] {
- "cxchg" => {
- let old = AtomicCmpXchg(bcx, get_param(decl, first_real_arg),
- get_param(decl, first_real_arg + 1u),
- get_param(decl, first_real_arg + 2u),
- order);
- Ret(bcx, old);
- }
- "load" => {
- let old = AtomicLoad(bcx, get_param(decl, first_real_arg),
- order);
- Ret(bcx, old);
- }
- "store" => {
- AtomicStore(bcx, get_param(decl, first_real_arg + 1u),
- get_param(decl, first_real_arg),
- order);
- RetVoid(bcx);
- }
- "fence" => {
- AtomicFence(bcx, order);
- RetVoid(bcx);
- }
- op => {
- // These are all AtomicRMW ops
- let atom_op = match op {
- "xchg" => lib::llvm::Xchg,
- "xadd" => lib::llvm::Add,
- "xsub" => lib::llvm::Sub,
- "and" => lib::llvm::And,
- "nand" => lib::llvm::Nand,
- "or" => lib::llvm::Or,
- "xor" => lib::llvm::Xor,
- "max" => lib::llvm::Max,
- "min" => lib::llvm::Min,
- "umax" => lib::llvm::UMax,
- "umin" => lib::llvm::UMin,
- _ => ccx.sess.fatal("Unknown atomic operation")
- };
-
- let old = AtomicRMW(bcx, atom_op, get_param(decl, first_real_arg),
- get_param(decl, first_real_arg + 1u),
- order);
- Ret(bcx, old);
- }
+ // The actual return type is a struct, but the ABI
+ // adaptation code has cast it into some scalar type. The
+ // code that follows is the only reliable way I have
+ // found to do a transform like i64 -> {i32,i32}.
+ // Basically we dump the data onto the stack then memcpy it.
+ //
+ // Other approaches I tried:
+ // - Casting rust ret pointer to the foreign type and using Store
+ // is (a) unsafe if size of foreign type > size of rust type and
+ // (b) runs afoul of strict aliasing rules, yielding invalid
+ // assembly under -O (specifically, the store gets removed).
+ // - Truncating foreign type to correct integral type and then
+ // bitcasting to the struct type yields invalid cast errors.
+ let llscratch = base::alloca(bcx, llforeign_ret_ty, "__cast");
+ Store(bcx, llforeign_retval, llscratch);
+ let llscratch_i8 = BitCast(bcx, llscratch, Type::i8().ptr_to());
+ let llretptr_i8 = BitCast(bcx, llretptr, Type::i8().ptr_to());
+ let llrust_size = machine::llsize_of_store(ccx, llrust_ret_ty);
+ let llforeign_align = machine::llalign_of_min(ccx, llforeign_ret_ty);
+ let llrust_align = machine::llalign_of_min(ccx, llrust_ret_ty);
+ let llalign = uint::min(llforeign_align, llrust_align);
+ debug!("llrust_size=%?", llrust_size);
+ base::call_memcpy(bcx, llretptr_i8, llscratch_i8,
+ C_uint(ccx, llrust_size), llalign as u32);
}
-
- fcx.cleanup();
- return;
}
- match name {
- "size_of" => {
- let tp_ty = substs.tys[0];
- let lltp_ty = type_of::type_of(ccx, tp_ty);
- Ret(bcx, C_uint(ccx, machine::llsize_of_real(ccx, lltp_ty)));
- }
- "move_val" => {
- // Create a datum reflecting the value being moved.
- // Use `appropriate_mode` so that the datum is by ref
- // if the value is non-immediate. Note that, with
- // intrinsics, there are no argument cleanups to
- // concern ourselves with.
- let tp_ty = substs.tys[0];
- let mode = appropriate_mode(ccx.tcx, tp_ty);
- let src = Datum {val: get_param(decl, first_real_arg + 1u),
- ty: tp_ty, mode: mode};
- bcx = src.move_to(bcx, DROP_EXISTING,
- get_param(decl, first_real_arg));
- RetVoid(bcx);
- }
- "move_val_init" => {
- // See comments for `"move_val"`.
- let tp_ty = substs.tys[0];
- let mode = appropriate_mode(ccx.tcx, tp_ty);
- let src = Datum {val: get_param(decl, first_real_arg + 1u),
- ty: tp_ty, mode: mode};
- bcx = src.move_to(bcx, INIT, get_param(decl, first_real_arg));
- RetVoid(bcx);
- }
- "min_align_of" => {
- let tp_ty = substs.tys[0];
- let lltp_ty = type_of::type_of(ccx, tp_ty);
- Ret(bcx, C_uint(ccx, machine::llalign_of_min(ccx, lltp_ty)));
- }
- "pref_align_of"=> {
- let tp_ty = substs.tys[0];
- let lltp_ty = type_of::type_of(ccx, tp_ty);
- Ret(bcx, C_uint(ccx, machine::llalign_of_pref(ccx, lltp_ty)));
- }
- "get_tydesc" => {
- let tp_ty = substs.tys[0];
- let static_ti = get_tydesc(ccx, tp_ty);
- glue::lazily_emit_all_tydesc_glue(ccx, static_ti);
-
- // FIXME (#3730): ideally this shouldn't need a cast,
- // but there's a circularity between translating rust types to llvm
- // types and having a tydesc type available. So I can't directly access
- // the llvm type of intrinsic::TyDesc struct.
- let userland_tydesc_ty = type_of::type_of(ccx, output_type);
- let td = PointerCast(bcx, static_ti.tydesc, userland_tydesc_ty);
- Ret(bcx, td);
- }
- "init" => {
- let tp_ty = substs.tys[0];
- let lltp_ty = type_of::type_of(ccx, tp_ty);
- match bcx.fcx.llretptr {
- Some(ptr) => { Store(bcx, C_null(lltp_ty), ptr); RetVoid(bcx); }
- None if ty::type_is_nil(tp_ty) => RetVoid(bcx),
- None => Ret(bcx, C_null(lltp_ty)),
- }
- }
- "uninit" => {
- // Do nothing, this is effectively a no-op
- let retty = substs.tys[0];
- if ty::type_is_immediate(ccx.tcx, retty) && !ty::type_is_nil(retty) {
- unsafe {
- Ret(bcx, lib::llvm::llvm::LLVMGetUndef(type_of(ccx, retty).to_ref()));
- }
- } else {
- RetVoid(bcx)
- }
- }
- "forget" => {
- RetVoid(bcx);
- }
- "transmute" => {
- let (in_type, out_type) = (substs.tys[0], substs.tys[1]);
- let llintype = type_of::type_of(ccx, in_type);
- let llouttype = type_of::type_of(ccx, out_type);
-
- let in_type_size = machine::llbitsize_of_real(ccx, llintype);
- let out_type_size = machine::llbitsize_of_real(ccx, llouttype);
- if in_type_size != out_type_size {
- let sp = match ccx.tcx.items.get_copy(&ref_id.unwrap()) {
- ast_map::node_expr(e) => e.span,
- _ => fail!("transmute has non-expr arg"),
- };
- let pluralize = |n| if 1u == n { "" } else { "s" };
- ccx.sess.span_fatal(sp,
- fmt!("transmute called on types with \
- different sizes: %s (%u bit%s) to \
- %s (%u bit%s)",
- ty_to_str(ccx.tcx, in_type),
- in_type_size,
- pluralize(in_type_size),
- ty_to_str(ccx.tcx, out_type),
- out_type_size,
- pluralize(out_type_size)));
- }
+ return bcx;
+}
- if !ty::type_is_nil(out_type) {
- let llsrcval = get_param(decl, first_real_arg);
- if ty::type_is_immediate(ccx.tcx, in_type) {
- match fcx.llretptr {
- Some(llretptr) => {
- Store(bcx, llsrcval, PointerCast(bcx, llretptr, llintype.ptr_to()));
- RetVoid(bcx);
- }
- None => match (llintype.kind(), llouttype.kind()) {
- (Pointer, other) | (other, Pointer) if other != Pointer => {
- let tmp = Alloca(bcx, llouttype, "");
- Store(bcx, llsrcval, PointerCast(bcx, tmp, llintype.ptr_to()));
- Ret(bcx, Load(bcx, tmp));
- }
- _ => Ret(bcx, BitCast(bcx, llsrcval, llouttype))
- }
- }
- } else if ty::type_is_immediate(ccx.tcx, out_type) {
- let llsrcptr = PointerCast(bcx, llsrcval, llouttype.ptr_to());
- Ret(bcx, Load(bcx, llsrcptr));
- } else {
- // NB: Do not use a Load and Store here. This causes massive
- // code bloat when `transmute` is used on large structural
- // types.
- let lldestptr = fcx.llretptr.unwrap();
- let lldestptr = PointerCast(bcx, lldestptr, Type::i8p());
- let llsrcptr = PointerCast(bcx, llsrcval, Type::i8p());
-
- let llsize = llsize_of(ccx, llintype);
- call_memcpy(bcx, lldestptr, llsrcptr, llsize, 1);
- RetVoid(bcx);
- };
- } else {
- RetVoid(bcx);
- }
- }
- "needs_drop" => {
- let tp_ty = substs.tys[0];
- Ret(bcx, C_bool(ty::type_needs_drop(ccx.tcx, tp_ty)));
- }
- "contains_managed" => {
- let tp_ty = substs.tys[0];
- Ret(bcx, C_bool(ty::type_contents(ccx.tcx, tp_ty).contains_managed()));
- }
- "visit_tydesc" => {
- let td = get_param(decl, first_real_arg);
- let visitor = get_param(decl, first_real_arg + 1u);
- let td = PointerCast(bcx, td, ccx.tydesc_type.ptr_to());
- glue::call_tydesc_glue_full(bcx, visitor, td,
- abi::tydesc_field_visit_glue, None);
- RetVoid(bcx);
- }
- "frame_address" => {
- let frameaddress = ccx.intrinsics.get_copy(& &"llvm.frameaddress");
- let frameaddress_val = Call(bcx, frameaddress, [C_i32(0i32)]);
- let star_u8 = ty::mk_imm_ptr(
- bcx.tcx(),
- ty::mk_mach_uint(ast::ty_u8));
- let fty = ty::mk_closure(bcx.tcx(), ty::ClosureTy {
- purity: ast::impure_fn,
- sigil: ast::BorrowedSigil,
- onceness: ast::Many,
- region: ty::re_bound(ty::br_anon(0)),
- bounds: ty::EmptyBuiltinBounds(),
- sig: FnSig {
- bound_lifetime_names: opt_vec::Empty,
- inputs: ~[ star_u8 ],
- output: ty::mk_nil()
- }
- });
- let datum = Datum {val: get_param(decl, first_real_arg),
- mode: ByRef(ZeroMem), ty: fty};
- let arg_vals = ~[frameaddress_val];
- bcx = trans_call_inner(
- bcx, None, fty, ty::mk_nil(),
- |bcx| Callee {bcx: bcx, data: Closure(datum)},
- ArgVals(arg_vals), Some(Ignore), DontAutorefArg).bcx;
- RetVoid(bcx);
- }
- "morestack_addr" => {
- // XXX This is a hack to grab the address of this particular
- // native function. There should be a general in-language
- // way to do this
- let llfty = type_of_fn(bcx.ccx(), [], ty::mk_nil());
- let morestack_addr = decl_cdecl_fn(
- bcx.ccx().llmod, "__morestack", llfty);
- let morestack_addr = PointerCast(bcx, morestack_addr, Type::nil().ptr_to());
- Ret(bcx, morestack_addr);
- }
- "offset" => {
- let ptr = get_param(decl, first_real_arg);
- let offset = get_param(decl, first_real_arg + 1);
- Ret(bcx, GEP(bcx, ptr, [offset]));
- }
- "offset_inbounds" => {
- let ptr = get_param(decl, first_real_arg);
- let offset = get_param(decl, first_real_arg + 1);
- Ret(bcx, InBoundsGEP(bcx, ptr, [offset]));
- }
- "memcpy32" => memcpy_intrinsic(bcx, "llvm.memcpy.p0i8.p0i8.i32", substs.tys[0], 32),
- "memcpy64" => memcpy_intrinsic(bcx, "llvm.memcpy.p0i8.p0i8.i64", substs.tys[0], 64),
- "memmove32" => memcpy_intrinsic(bcx, "llvm.memmove.p0i8.p0i8.i32", substs.tys[0], 32),
- "memmove64" => memcpy_intrinsic(bcx, "llvm.memmove.p0i8.p0i8.i64", substs.tys[0], 64),
- "memset32" => memset_intrinsic(bcx, "llvm.memset.p0i8.i32", substs.tys[0], 32),
- "memset64" => memset_intrinsic(bcx, "llvm.memset.p0i8.i64", substs.tys[0], 64),
- "sqrtf32" => simple_llvm_intrinsic(bcx, "llvm.sqrt.f32", 1),
- "sqrtf64" => simple_llvm_intrinsic(bcx, "llvm.sqrt.f64", 1),
- "powif32" => simple_llvm_intrinsic(bcx, "llvm.powi.f32", 2),
- "powif64" => simple_llvm_intrinsic(bcx, "llvm.powi.f64", 2),
- "sinf32" => simple_llvm_intrinsic(bcx, "llvm.sin.f32", 1),
- "sinf64" => simple_llvm_intrinsic(bcx, "llvm.sin.f64", 1),
- "cosf32" => simple_llvm_intrinsic(bcx, "llvm.cos.f32", 1),
- "cosf64" => simple_llvm_intrinsic(bcx, "llvm.cos.f64", 1),
- "powf32" => simple_llvm_intrinsic(bcx, "llvm.pow.f32", 2),
- "powf64" => simple_llvm_intrinsic(bcx, "llvm.pow.f64", 2),
- "expf32" => simple_llvm_intrinsic(bcx, "llvm.exp.f32", 1),
- "expf64" => simple_llvm_intrinsic(bcx, "llvm.exp.f64", 1),
- "exp2f32" => simple_llvm_intrinsic(bcx, "llvm.exp2.f32", 1),
- "exp2f64" => simple_llvm_intrinsic(bcx, "llvm.exp2.f64", 1),
- "logf32" => simple_llvm_intrinsic(bcx, "llvm.log.f32", 1),
- "logf64" => simple_llvm_intrinsic(bcx, "llvm.log.f64", 1),
- "log10f32" => simple_llvm_intrinsic(bcx, "llvm.log10.f32", 1),
- "log10f64" => simple_llvm_intrinsic(bcx, "llvm.log10.f64", 1),
- "log2f32" => simple_llvm_intrinsic(bcx, "llvm.log2.f32", 1),
- "log2f64" => simple_llvm_intrinsic(bcx, "llvm.log2.f64", 1),
- "fmaf32" => simple_llvm_intrinsic(bcx, "llvm.fma.f32", 3),
- "fmaf64" => simple_llvm_intrinsic(bcx, "llvm.fma.f64", 3),
- "fabsf32" => simple_llvm_intrinsic(bcx, "llvm.fabs.f32", 1),
- "fabsf64" => simple_llvm_intrinsic(bcx, "llvm.fabs.f64", 1),
- "floorf32" => simple_llvm_intrinsic(bcx, "llvm.floor.f32", 1),
- "floorf64" => simple_llvm_intrinsic(bcx, "llvm.floor.f64", 1),
- "ceilf32" => simple_llvm_intrinsic(bcx, "llvm.ceil.f32", 1),
- "ceilf64" => simple_llvm_intrinsic(bcx, "llvm.ceil.f64", 1),
- "truncf32" => simple_llvm_intrinsic(bcx, "llvm.trunc.f32", 1),
- "truncf64" => simple_llvm_intrinsic(bcx, "llvm.trunc.f64", 1),
- "ctpop8" => simple_llvm_intrinsic(bcx, "llvm.ctpop.i8", 1),
- "ctpop16" => simple_llvm_intrinsic(bcx, "llvm.ctpop.i16", 1),
- "ctpop32" => simple_llvm_intrinsic(bcx, "llvm.ctpop.i32", 1),
- "ctpop64" => simple_llvm_intrinsic(bcx, "llvm.ctpop.i64", 1),
- "ctlz8" => count_zeros_intrinsic(bcx, "llvm.ctlz.i8"),
- "ctlz16" => count_zeros_intrinsic(bcx, "llvm.ctlz.i16"),
- "ctlz32" => count_zeros_intrinsic(bcx, "llvm.ctlz.i32"),
- "ctlz64" => count_zeros_intrinsic(bcx, "llvm.ctlz.i64"),
- "cttz8" => count_zeros_intrinsic(bcx, "llvm.cttz.i8"),
- "cttz16" => count_zeros_intrinsic(bcx, "llvm.cttz.i16"),
- "cttz32" => count_zeros_intrinsic(bcx, "llvm.cttz.i32"),
- "cttz64" => count_zeros_intrinsic(bcx, "llvm.cttz.i64"),
- "bswap16" => simple_llvm_intrinsic(bcx, "llvm.bswap.i16", 1),
- "bswap32" => simple_llvm_intrinsic(bcx, "llvm.bswap.i32", 1),
- "bswap64" => simple_llvm_intrinsic(bcx, "llvm.bswap.i64", 1),
-
- "i8_add_with_overflow" => with_overflow_instrinsic(bcx, "llvm.sadd.with.overflow.i8"),
- "i16_add_with_overflow" => with_overflow_instrinsic(bcx, "llvm.sadd.with.overflow.i16"),
- "i32_add_with_overflow" => with_overflow_instrinsic(bcx, "llvm.sadd.with.overflow.i32"),
- "i64_add_with_overflow" => with_overflow_instrinsic(bcx, "llvm.sadd.with.overflow.i64"),
-
- "u8_add_with_overflow" => with_overflow_instrinsic(bcx, "llvm.uadd.with.overflow.i8"),
- "u16_add_with_overflow" => with_overflow_instrinsic(bcx, "llvm.uadd.with.overflow.i16"),
- "u32_add_with_overflow" => with_overflow_instrinsic(bcx, "llvm.uadd.with.overflow.i32"),
- "u64_add_with_overflow" => with_overflow_instrinsic(bcx, "llvm.uadd.with.overflow.i64"),
-
- "i8_sub_with_overflow" => with_overflow_instrinsic(bcx, "llvm.ssub.with.overflow.i8"),
- "i16_sub_with_overflow" => with_overflow_instrinsic(bcx, "llvm.ssub.with.overflow.i16"),
- "i32_sub_with_overflow" => with_overflow_instrinsic(bcx, "llvm.ssub.with.overflow.i32"),
- "i64_sub_with_overflow" => with_overflow_instrinsic(bcx, "llvm.ssub.with.overflow.i64"),
-
- "u8_sub_with_overflow" => with_overflow_instrinsic(bcx, "llvm.usub.with.overflow.i8"),
- "u16_sub_with_overflow" => with_overflow_instrinsic(bcx, "llvm.usub.with.overflow.i16"),
- "u32_sub_with_overflow" => with_overflow_instrinsic(bcx, "llvm.usub.with.overflow.i32"),
- "u64_sub_with_overflow" => with_overflow_instrinsic(bcx, "llvm.usub.with.overflow.i64"),
-
- "i8_mul_with_overflow" => with_overflow_instrinsic(bcx, "llvm.smul.with.overflow.i8"),
- "i16_mul_with_overflow" => with_overflow_instrinsic(bcx, "llvm.smul.with.overflow.i16"),
- "i32_mul_with_overflow" => with_overflow_instrinsic(bcx, "llvm.smul.with.overflow.i32"),
- "i64_mul_with_overflow" => with_overflow_instrinsic(bcx, "llvm.smul.with.overflow.i64"),
-
- "u8_mul_with_overflow" => with_overflow_instrinsic(bcx, "llvm.umul.with.overflow.i8"),
- "u16_mul_with_overflow" => with_overflow_instrinsic(bcx, "llvm.umul.with.overflow.i16"),
- "u32_mul_with_overflow" => with_overflow_instrinsic(bcx, "llvm.umul.with.overflow.i32"),
- "u64_mul_with_overflow" => with_overflow_instrinsic(bcx, "llvm.umul.with.overflow.i64"),
-
- _ => {
- // Could we make this an enum rather than a string? does it get
- // checked earlier?
- ccx.sess.span_bug(item.span, "unknown intrinsic");
- }
+pub fn trans_foreign_mod(ccx: @mut CrateContext,
+ foreign_mod: &ast::foreign_mod) {
+ let _icx = push_ctxt("foreign::trans_foreign_mod");
+ for &foreign_item in foreign_mod.items.iter() {
+ let lname = link_name(ccx, foreign_item);
+ ccx.item_symbols.insert(foreign_item.id, lname.to_owned());
}
- fcx.cleanup();
}
-/**
- * Translates a "crust" fn, meaning a Rust fn that can be called
- * from C code. In this case, we have to perform some adaptation
- * to (1) switch back to the Rust stack and (2) adapt the C calling
- * convention to our own.
- *
- * Example: Given a crust fn F(x: X, y: Y) -> Z, we generate a
- * Rust function R as normal:
- *
- * void R(Z* dest, void *env, X x, Y y) {...}
- *
- * and then we generate a wrapper function W that looks like:
- *
- * Z W(X x, Y y) {
- * struct { X x; Y y; Z *z; } args = { x, y, z };
- * call_on_c_stack_shim(S, &args);
- * }
- *
- * Note that the wrapper follows the foreign (typically "C") ABI.
- * The wrapper is the actual "value" of the foreign fn. Finally,
- * we generate a shim function S that looks like:
- *
- * void S(struct { X x; Y y; Z *z; } *args) {
- * R(args->z, NULL, args->x, args->y);
- * }
- */
-pub fn trans_foreign_fn(ccx: @mut CrateContext,
- path: ast_map::path,
- decl: &ast::fn_decl,
- body: &ast::Block,
- llwrapfn: ValueRef,
- id: ast::NodeId) {
+///////////////////////////////////////////////////////////////////////////
+// Rust functions with foreign ABIs
+//
+// These are normal Rust functions defined with foreign ABIs. For
+// now, and perhaps forever, we translate these using a "layer of
+// indirection". That is, given a Rust declaration like:
+//
+// extern "C" fn foo(i: u32) -> u32 { ... }
+//
+// we will generate a function like:
+//
+// S foo(T i) {
+// S r;
+// foo0(&r, NULL, i);
+// return r;
+// }
+//
+// #[inline_always]
+// void foo0(uint32_t *r, void *env, uint32_t i) { ... }
+//
+// Here the (internal) `foo0` function follows the Rust ABI as normal,
+// where the `foo` function follows the C ABI. We rely on LLVM to
+// inline the one into the other. Of course we could just generate the
+// correct code in the first place, but this is much simpler.
+
+pub fn register_rust_fn_with_foreign_abi(ccx: @mut CrateContext,
+ sp: span,
+ sym: ~str,
+ node_id: ast::NodeId)
+ -> ValueRef {
+ let _icx = push_ctxt("foreign::register_foreign_fn");
+
+ let tys = foreign_types_for_id(ccx, node_id);
+ let llfn_ty = lltype_for_fn_from_foreign_types(&tys);
+ let llfn = base::register_fn_llvmty(ccx,
+ sp,
+ sym,
+ node_id,
+ lib::llvm::CCallConv,
+ llfn_ty);
+ add_argument_attributes(&tys, llfn);
+ debug!("register_rust_fn_with_foreign_abi(node_id=%?, llfn_ty=%s, llfn=%s)",
+ node_id, ccx.tn.type_to_str(llfn_ty), ccx.tn.val_to_str(llfn));
+ llfn
+}
+
+pub fn trans_rust_fn_with_foreign_abi(ccx: @mut CrateContext,
+ path: &ast_map::path,
+ decl: &ast::fn_decl,
+ body: &ast::Block,
+ llwrapfn: ValueRef,
+ id: ast::NodeId) {
let _icx = push_ctxt("foreign::build_foreign_fn");
+ let tys = foreign_types_for_id(ccx, id);
+
+ unsafe { // unsafe because we call LLVM operations
+ // Build up the Rust function (`foo0` above).
+ let llrustfn = build_rust_fn(ccx, path, decl, body, id);
+
+ // Build up the foreign wrapper (`foo` above).
+ return build_wrap_fn(ccx, llrustfn, llwrapfn, &tys);
+ }
fn build_rust_fn(ccx: @mut CrateContext,
path: &ast_map::path,
decl: &ast::fn_decl,
body: &ast::Block,
id: ast::NodeId)
- -> ValueRef {
+ -> ValueRef {
let _icx = push_ctxt("foreign::foreign::build_rust_fn");
- let t = ty::node_id_to_type(ccx.tcx, id);
- // XXX: Bad copy.
+ let tcx = ccx.tcx;
+ let t = ty::node_id_to_type(tcx, id);
let ps = link::mangle_internal_name_by_path(
- ccx,
- vec::append_one((*path).clone(),
- ast_map::path_name(
- special_idents::clownshoe_abi)));
+ ccx, vec::append_one((*path).clone(), ast_map::path_name(
+ special_idents::clownshoe_abi
+ )));
let llty = type_of_fn_from_ty(ccx, t);
- let llfndecl = decl_internal_cdecl_fn(ccx.llmod, ps, llty);
- trans_fn(ccx,
- (*path).clone(),
- decl,
- body,
- llfndecl,
- no_self,
- None,
- id,
- []);
+ let llfndecl = base::decl_internal_cdecl_fn(ccx.llmod, ps, llty);
+ base::trans_fn(ccx,
+ (*path).clone(),
+ decl,
+ body,
+ llfndecl,
+ base::no_self,
+ None,
+ id,
+ []);
return llfndecl;
}
- fn build_shim_fn(ccx: @mut CrateContext,
- path: ast_map::path,
- llrustfn: ValueRef,
- tys: &ShimTypes)
- -> ValueRef {
- /*!
- *
- * Generate the shim S:
- *
- * void S(struct { X x; Y y; Z *z; } *args) {
- * R(args->z, NULL, &args->x, args->y);
- * }
- *
- * One complication is that we must adapt to the Rust
- * calling convention, which introduces indirection
- * in some cases. To demonstrate this, I wrote one of the
- * entries above as `&args->x`, because presumably `X` is
- * one of those types that is passed by pointer in Rust.
- */
-
- let _icx = push_ctxt("foreign::foreign::build_shim_fn");
-
- fn build_args(bcx: @mut Block, tys: &ShimTypes, llargbundle: ValueRef)
- -> ~[ValueRef] {
- let _icx = push_ctxt("foreign::extern::shim::build_args");
- let ccx = bcx.ccx();
- let mut llargvals = ~[];
- let mut i = 0u;
- let n = tys.fn_sig.inputs.len();
-
- if !ty::type_is_immediate(bcx.tcx(), tys.fn_sig.output) {
- let llretptr = load_inbounds(bcx, llargbundle, [0u, n]);
- llargvals.push(llretptr);
+ unsafe fn build_wrap_fn(ccx: @mut CrateContext,
+ llrustfn: ValueRef,
+ llwrapfn: ValueRef,
+ tys: &ForeignTypes) {
+ let _icx = push_ctxt(
+ "foreign::trans_rust_fn_with_foreign_abi::build_wrap_fn");
+ let tcx = ccx.tcx;
+
+ debug!("build_wrap_fn(llrustfn=%s, llwrapfn=%s)",
+ ccx.tn.val_to_str(llrustfn),
+ ccx.tn.val_to_str(llwrapfn));
+
+ // Avoid all the Rust generation stuff and just generate raw
+ // LLVM here.
+ //
+ // We want to generate code like this:
+ //
+ // S foo(T i) {
+ // S r;
+ // foo0(&r, NULL, i);
+ // return r;
+ // }
+
+ let the_block =
+ "the block".to_c_str().with_ref(
+ |s| llvm::LLVMAppendBasicBlockInContext(ccx.llcx, llwrapfn, s));
+
+ let builder = ccx.builder.B;
+ llvm::LLVMPositionBuilderAtEnd(builder, the_block);
+
+ // Array for the arguments we will pass to the rust function.
+ let mut llrust_args = ~[];
+ let mut next_foreign_arg_counter: c_uint = 0;
+ let next_foreign_arg: &fn() -> c_uint = {
+ || {
+ next_foreign_arg_counter += 1;
+ next_foreign_arg_counter - 1
}
+ };
- let llenvptr = C_null(Type::opaque_box(bcx.ccx()).ptr_to());
- llargvals.push(llenvptr);
- while i < n {
- // Get a pointer to the argument:
- let mut llargval = GEPi(bcx, llargbundle, [0u, i]);
+ // If there is an out pointer on the foreign function
+ let foreign_outptr = {
+ if tys.fn_ty.sret {
+ Some(llvm::LLVMGetParam(llwrapfn, next_foreign_arg()))
+ } else {
+ None
+ }
+ };
- if !type_of::arg_is_indirect(ccx, &tys.fn_sig.inputs[i]) {
- // If Rust would pass this by value, load the value.
- llargval = Load(bcx, llargval);
+ // Push Rust return pointer, using null if it will be unused.
+ let rust_uses_outptr =
+ type_of::return_uses_outptr(tcx, tys.fn_sig.output);
+ let return_alloca: Option<ValueRef>;
+ let llrust_ret_ty = tys.llsig.llret_ty;
+ let llrust_retptr_ty = llrust_ret_ty.ptr_to();
+ if rust_uses_outptr {
+ // Rust expects to use an outpointer. If the foreign fn
+ // also uses an outpointer, we can reuse it, but the types
+ // may vary, so cast first to the Rust type. If the
+ // foriegn fn does NOT use an outpointer, we will have to
+ // alloca some scratch space on the stack.
+ match foreign_outptr {
+ Some(llforeign_outptr) => {
+ debug!("out pointer, foreign=%s",
+ ccx.tn.val_to_str(llforeign_outptr));
+ let llrust_retptr =
+ llvm::LLVMBuildBitCast(builder,
+ llforeign_outptr,
+ llrust_ret_ty.ptr_to().to_ref(),
+ noname());
+ debug!("out pointer, foreign=%s (casted)",
+ ccx.tn.val_to_str(llrust_retptr));
+ llrust_args.push(llrust_retptr);
+ return_alloca = None;
}
- llargvals.push(llargval);
- i += 1u;
+ None => {
+ let slot = {
+ "return_alloca".to_c_str().with_ref(
+ |s| llvm::LLVMBuildAlloca(builder,
+ llrust_ret_ty.to_ref(),
+ s))
+ };
+ debug!("out pointer, \
+ allocad=%s, \
+ llrust_ret_ty=%s, \
+ return_ty=%s",
+ ccx.tn.val_to_str(slot),
+ ccx.tn.type_to_str(llrust_ret_ty),
+ tys.fn_sig.output.repr(tcx));
+ llrust_args.push(slot);
+ return_alloca = Some(slot);
+ }
+ }
+ } else {
+ // Rust does not expect an outpointer. If the foreign fn
+ // does use an outpointer, then we will do a store of the
+ // value that the Rust fn returns.
+ return_alloca = None;
+ };
+
+ // Push an (null) env pointer
+ let env_pointer = base::null_env_ptr(ccx);
+ debug!("env pointer=%s", ccx.tn.val_to_str(env_pointer));
+ llrust_args.push(env_pointer);
+
+ // Build up the arguments to the call to the rust function.
+ // Careful to adapt for cases where the native convention uses
+ // a pointer and Rust does not or vice versa.
+ for i in range(0, tys.fn_sig.inputs.len()) {
+ let rust_ty = tys.fn_sig.inputs[i];
+ let llrust_ty = tys.llsig.llarg_tys[i];
+ let foreign_index = next_foreign_arg();
+ let rust_indirect = type_of::arg_is_indirect(ccx, rust_ty);
+ let foreign_indirect = tys.fn_ty.attrs[foreign_index].is_some();
+ let mut llforeign_arg = llvm::LLVMGetParam(llwrapfn, foreign_index);
+
+ debug!("llforeign_arg #%u: %s",
+ i, ccx.tn.val_to_str(llforeign_arg));
+ debug!("rust_indirect = %b, foreign_indirect = %b",
+ rust_indirect, foreign_indirect);
+
+ // Ensure that the foreign argument is indirect (by
+ // pointer). It makes adapting types easier, since we can
+ // always just bitcast pointers.
+ if !foreign_indirect {
+ let lltemp =
+ llvm::LLVMBuildAlloca(
+ builder, val_ty(llforeign_arg).to_ref(), noname());
+ llvm::LLVMBuildStore(
+ builder, llforeign_arg, lltemp);
+ llforeign_arg = lltemp;
+ }
+
+ // If the types in the ABI and the Rust types don't match,
+ // bitcast the llforeign_arg pointer so it matches the types
+ // Rust expects.
+ if tys.fn_ty.arg_tys[foreign_index].cast {
+ assert!(!foreign_indirect);
+ llforeign_arg = llvm::LLVMBuildBitCast(
+ builder, llforeign_arg,
+ llrust_ty.ptr_to().to_ref(), noname());
}
- return llargvals;
- }
- fn build_ret(bcx: @mut Block,
- shim_types: &ShimTypes,
- llargbundle: ValueRef,
- llretval: ValueRef) {
- if bcx.fcx.llretptr.is_some() &&
- ty::type_is_immediate(bcx.tcx(), shim_types.fn_sig.output) {
- // Write the value into the argument bundle.
- let arg_count = shim_types.fn_sig.inputs.len();
- let llretptr = load_inbounds(bcx,
- llargbundle,
- [0, arg_count]);
- Store(bcx, llretval, llretptr);
+ let llrust_arg = if rust_indirect {
+ llforeign_arg
} else {
- // NB: The return pointer in the Rust ABI function is wired
- // directly into the return slot in the shim struct.
+ llvm::LLVMBuildLoad(builder, llforeign_arg, noname())
+ };
+
+ debug!("llrust_arg #%u: %s",
+ i, ccx.tn.val_to_str(llrust_arg));
+ llrust_args.push(llrust_arg);
+ }
+
+ // Perform the call itself
+ let llrust_ret_val = do llrust_args.as_imm_buf |ptr, len| {
+ debug!("calling llrustfn = %s", ccx.tn.val_to_str(llrustfn));
+ llvm::LLVMBuildCall(builder, llrustfn, ptr,
+ len as c_uint, noname())
+ };
+
+ // Get the return value where the foreign fn expects it.
+ let llforeign_ret_ty = tys.fn_ty.ret_ty.ty;
+ match foreign_outptr {
+ None if !tys.ret_def => {
+ // Function returns `()` or `bot`, which in Rust is the LLVM
+ // type "{}" but in foreign ABIs is "Void".
+ llvm::LLVMBuildRetVoid(builder);
+ }
+
+ None if rust_uses_outptr => {
+ // Rust uses an outpointer, but the foreign ABI does not. Load.
+ let llrust_outptr = return_alloca.unwrap();
+ let llforeign_outptr_casted =
+ llvm::LLVMBuildBitCast(builder,
+ llrust_outptr,
+ llforeign_ret_ty.ptr_to().to_ref(),
+ noname());
+ let llforeign_retval =
+ llvm::LLVMBuildLoad(builder, llforeign_outptr_casted, noname());
+ llvm::LLVMBuildRet(builder, llforeign_retval);
+ }
+
+ None if llforeign_ret_ty != llrust_ret_ty => {
+ // Neither ABI uses an outpointer, but the types don't
+ // quite match. Must cast. Probably we should try and
+ // examine the types and use a concrete llvm cast, but
+ // right now we just use a temp memory location and
+ // bitcast the pointer, which is the same thing the
+ // old wrappers used to do.
+ let lltemp =
+ llvm::LLVMBuildAlloca(
+ builder, llforeign_ret_ty.to_ref(), noname());
+ let lltemp_casted =
+ llvm::LLVMBuildBitCast(builder,
+ lltemp,
+ llrust_ret_ty.ptr_to().to_ref(),
+ noname());
+ llvm::LLVMBuildStore(
+ builder, llrust_ret_val, lltemp_casted);
+ let llforeign_retval =
+ llvm::LLVMBuildLoad(builder, lltemp, noname());
+ llvm::LLVMBuildRet(builder, llforeign_retval);
+ }
+
+ None => {
+ // Neither ABI uses an outpointer, and the types
+ // match. Easy peasy.
+ llvm::LLVMBuildRet(builder, llrust_ret_val);
+ }
+
+ Some(llforeign_outptr) if !rust_uses_outptr => {
+ // Foreign ABI requires an out pointer, but Rust doesn't.
+ // Store Rust return value.
+ let llforeign_outptr_casted =
+ llvm::LLVMBuildBitCast(builder,
+ llforeign_outptr,
+ llrust_retptr_ty.to_ref(),
+ noname());
+ llvm::LLVMBuildStore(
+ builder, llrust_ret_val, llforeign_outptr_casted);
+ llvm::LLVMBuildRetVoid(builder);
+ }
+
+ Some(_) => {
+ // Both ABIs use outpointers. Easy peasy.
+ llvm::LLVMBuildRetVoid(builder);
}
}
+ }
+}
- let shim_name = link::mangle_internal_name_by_path(
- ccx,
- vec::append_one(path, ast_map::path_name(
- special_idents::clownshoe_stack_shim
- )));
- build_shim_fn_(ccx,
- shim_name,
- llrustfn,
- tys,
- lib::llvm::CCallConv,
- build_args,
- build_ret)
+///////////////////////////////////////////////////////////////////////////
+// General ABI Support
+//
+// This code is kind of a confused mess and needs to be reworked given
+// the massive simplifications that have occurred.
+
+pub fn link_name(ccx: &CrateContext, i: @ast::foreign_item) -> @str {
+ match attr::first_attr_value_str_by_name(i.attrs, "link_name") {
+ None => ccx.sess.str_of(i.ident),
+ Some(ln) => ln,
}
+}
- fn build_wrap_fn(ccx: @mut CrateContext,
- llshimfn: ValueRef,
- llwrapfn: ValueRef,
- tys: &ShimTypes) {
- /*!
- *
- * Generate the wrapper W:
- *
- * Z W(X x, Y y) {
- * struct { X x; Y y; Z *z; } args = { x, y, z };
- * call_on_c_stack_shim(S, &args);
- * }
- */
-
- let _icx = push_ctxt("foreign::foreign::build_wrap_fn");
-
- build_wrap_fn_(ccx,
- tys,
- llshimfn,
- llwrapfn,
- ccx.upcalls.call_shim_on_rust_stack,
- true,
- build_args,
- build_ret);
-
- fn build_args(bcx: @mut Block,
- tys: &ShimTypes,
- llwrapfn: ValueRef,
- llargbundle: ValueRef) {
- let _icx = push_ctxt("foreign::foreign::wrap::build_args");
- tys.fn_ty.build_wrap_args(bcx,
- tys.llsig.llret_ty,
- llwrapfn,
- llargbundle);
- }
+fn foreign_signature(ccx: &mut CrateContext, fn_sig: &ty::FnSig)
+ -> LlvmSignature {
+ /*!
+ * The ForeignSignature is the LLVM types of the arguments/return type
+ * of a function. Note that these LLVM types are not quite the same
+ * as the LLVM types would be for a native Rust function because foreign
+ * functions just plain ignore modes. They also don't pass aggregate
+ * values by pointer like we do.
+ */
- fn build_ret(bcx: @mut Block, tys: &ShimTypes, llargbundle: ValueRef) {
- let _icx = push_ctxt("foreign::foreign::wrap::build_ret");
- tys.fn_ty.build_wrap_ret(bcx, tys.llsig.llarg_tys, llargbundle);
- }
+ let llarg_tys = fn_sig.inputs.map(|&arg| type_of(ccx, arg));
+ let llret_ty = type_of::type_of(ccx, fn_sig.output);
+ LlvmSignature {
+ llarg_tys: llarg_tys,
+ llret_ty: llret_ty,
+ sret: type_of::return_uses_outptr(ccx.tcx, fn_sig.output),
}
+}
- let tys = shim_types(ccx, id);
- // The internal Rust ABI function - runs on the Rust stack
- // XXX: Bad copy.
- let llrustfn = build_rust_fn(ccx, &path, decl, body, id);
- // The internal shim function - runs on the Rust stack
- let llshimfn = build_shim_fn(ccx, path, llrustfn, &tys);
- // The foreign C function - runs on the C stack
- build_wrap_fn(ccx, llshimfn, llwrapfn, &tys)
+fn foreign_types_for_id(ccx: &mut CrateContext,
+ id: ast::NodeId) -> ForeignTypes {
+ foreign_types_for_fn_ty(ccx, ty::node_id_to_type(ccx.tcx, id))
}
-pub fn register_foreign_fn(ccx: @mut CrateContext,
- sp: span,
- sym: ~str,
- node_id: ast::NodeId)
- -> ValueRef {
- let _icx = push_ctxt("foreign::register_foreign_fn");
+fn foreign_types_for_fn_ty(ccx: &mut CrateContext,
+ ty: ty::t) -> ForeignTypes {
+ let fn_sig = match ty::get(ty).sty {
+ ty::ty_bare_fn(ref fn_ty) => fn_ty.sig.clone(),
+ _ => ccx.sess.bug("foreign_types_for_fn_ty called on non-function type")
+ };
+ let llsig = foreign_signature(ccx, &fn_sig);
+ let ret_def = !ty::type_is_voidish(fn_sig.output);
+ let fn_ty = cabi::compute_abi_info(ccx,
+ llsig.llarg_tys,
+ llsig.llret_ty,
+ ret_def);
+ debug!("foreign_types_for_fn_ty(\
+ ty=%s, \
+ llsig=%s -> %s, \
+ fn_ty=%s -> %s, \
+ ret_def=%b",
+ ty.repr(ccx.tcx),
+ ccx.tn.types_to_str(llsig.llarg_tys),
+ ccx.tn.type_to_str(llsig.llret_ty),
+ ccx.tn.types_to_str(fn_ty.arg_tys.map(|t| t.ty)),
+ ccx.tn.type_to_str(fn_ty.ret_ty.ty),
+ ret_def);
+
+ ForeignTypes {
+ fn_sig: fn_sig,
+ llsig: llsig,
+ ret_def: ret_def,
+ fn_ty: fn_ty
+ }
+}
- let sym = Cell::new(sym);
+fn lltype_for_fn_from_foreign_types(tys: &ForeignTypes) -> Type {
+ let llargument_tys: ~[Type] =
+ tys.fn_ty.arg_tys.iter().map(|t| t.ty).collect();
+ let llreturn_ty = tys.fn_ty.ret_ty.ty;
+ Type::func(llargument_tys, &llreturn_ty)
+}
+
+pub fn lltype_for_foreign_fn(ccx: &mut CrateContext, ty: ty::t) -> Type {
+ let fn_types = foreign_types_for_fn_ty(ccx, ty);
+ lltype_for_fn_from_foreign_types(&fn_types)
+}
- let tys = shim_types(ccx, node_id);
- do tys.fn_ty.decl_fn |fnty| {
- register_fn_llvmty(ccx, sp, sym.take(), node_id, lib::llvm::CCallConv, fnty)
+fn add_argument_attributes(tys: &ForeignTypes,
+ llfn: ValueRef) {
+ for (i, a) in tys.fn_ty.attrs.iter().enumerate() {
+ match *a {
+ Some(attr) => {
+ let llarg = get_param(llfn, i);
+ unsafe {
+ llvm::LLVMAddAttribute(llarg, attr as c_uint);
+ }
+ }
+ None => ()
+ }
}
}
--- /dev/null
+// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use back::{abi};
+use lib::llvm::{SequentiallyConsistent, Acquire, Release, Xchg};
+use lib::llvm::{ValueRef, Pointer};
+use lib;
+use middle::trans::base::*;
+use middle::trans::build::*;
+use middle::trans::callee::*;
+use middle::trans::common::*;
+use middle::trans::datum::*;
+use middle::trans::type_of::*;
+use middle::trans::type_of;
+use middle::trans::expr::Ignore;
+use middle::trans::machine;
+use middle::trans::glue;
+use middle::ty::FnSig;
+use middle::ty;
+use syntax::ast;
+use syntax::ast_map;
+use syntax::attr;
+use syntax::opt_vec;
+use util::ppaux::{ty_to_str};
+use middle::trans::machine::llsize_of;
+use middle::trans::type_::Type;
+
+pub fn trans_intrinsic(ccx: @mut CrateContext,
+ decl: ValueRef,
+ item: &ast::foreign_item,
+ path: ast_map::path,
+ substs: @param_substs,
+ attributes: &[ast::Attribute],
+ ref_id: Option<ast::NodeId>) {
+ debug!("trans_intrinsic(item.ident=%s)", ccx.sess.str_of(item.ident));
+
+ fn simple_llvm_intrinsic(bcx: @mut Block, name: &'static str, num_args: uint) {
+ assert!(num_args <= 4);
+ let mut args = [0 as ValueRef, ..4];
+ let first_real_arg = bcx.fcx.arg_pos(0u);
+ for i in range(0u, num_args) {
+ args[i] = get_param(bcx.fcx.llfn, first_real_arg + i);
+ }
+ let llfn = bcx.ccx().intrinsics.get_copy(&name);
+ Ret(bcx, Call(bcx, llfn, args.slice(0, num_args)));
+ }
+
+ fn with_overflow_instrinsic(bcx: @mut Block, name: &'static str) {
+ let first_real_arg = bcx.fcx.arg_pos(0u);
+ let a = get_param(bcx.fcx.llfn, first_real_arg);
+ let b = get_param(bcx.fcx.llfn, first_real_arg + 1);
+ let llfn = bcx.ccx().intrinsics.get_copy(&name);
+
+ // convert `i1` to a `bool`, and write to the out parameter
+ let val = Call(bcx, llfn, [a, b]);
+ let result = ExtractValue(bcx, val, 0);
+ let overflow = ZExt(bcx, ExtractValue(bcx, val, 1), Type::bool());
+ let retptr = get_param(bcx.fcx.llfn, bcx.fcx.out_arg_pos());
+ let ret = Load(bcx, retptr);
+ let ret = InsertValue(bcx, ret, result, 0);
+ let ret = InsertValue(bcx, ret, overflow, 1);
+ Store(bcx, ret, retptr);
+ RetVoid(bcx)
+ }
+
+ fn memcpy_intrinsic(bcx: @mut Block, name: &'static str, tp_ty: ty::t, sizebits: u8) {
+ let ccx = bcx.ccx();
+ let lltp_ty = type_of::type_of(ccx, tp_ty);
+ let align = C_i32(machine::llalign_of_min(ccx, lltp_ty) as i32);
+ let size = match sizebits {
+ 32 => C_i32(machine::llsize_of_real(ccx, lltp_ty) as i32),
+ 64 => C_i64(machine::llsize_of_real(ccx, lltp_ty) as i64),
+ _ => ccx.sess.fatal("Invalid value for sizebits")
+ };
+
+ let decl = bcx.fcx.llfn;
+ let first_real_arg = bcx.fcx.arg_pos(0u);
+ let dst_ptr = PointerCast(bcx, get_param(decl, first_real_arg), Type::i8p());
+ let src_ptr = PointerCast(bcx, get_param(decl, first_real_arg + 1), Type::i8p());
+ let count = get_param(decl, first_real_arg + 2);
+ let volatile = C_i1(false);
+ let llfn = bcx.ccx().intrinsics.get_copy(&name);
+ Call(bcx, llfn, [dst_ptr, src_ptr, Mul(bcx, size, count), align, volatile]);
+ RetVoid(bcx);
+ }
+
+ fn memset_intrinsic(bcx: @mut Block, name: &'static str, tp_ty: ty::t, sizebits: u8) {
+ let ccx = bcx.ccx();
+ let lltp_ty = type_of::type_of(ccx, tp_ty);
+ let align = C_i32(machine::llalign_of_min(ccx, lltp_ty) as i32);
+ let size = match sizebits {
+ 32 => C_i32(machine::llsize_of_real(ccx, lltp_ty) as i32),
+ 64 => C_i64(machine::llsize_of_real(ccx, lltp_ty) as i64),
+ _ => ccx.sess.fatal("Invalid value for sizebits")
+ };
+
+ let decl = bcx.fcx.llfn;
+ let first_real_arg = bcx.fcx.arg_pos(0u);
+ let dst_ptr = PointerCast(bcx, get_param(decl, first_real_arg), Type::i8p());
+ let val = get_param(decl, first_real_arg + 1);
+ let count = get_param(decl, first_real_arg + 2);
+ let volatile = C_i1(false);
+ let llfn = bcx.ccx().intrinsics.get_copy(&name);
+ Call(bcx, llfn, [dst_ptr, val, Mul(bcx, size, count), align, volatile]);
+ RetVoid(bcx);
+ }
+
+ fn count_zeros_intrinsic(bcx: @mut Block, name: &'static str) {
+ let x = get_param(bcx.fcx.llfn, bcx.fcx.arg_pos(0u));
+ let y = C_i1(false);
+ let llfn = bcx.ccx().intrinsics.get_copy(&name);
+ Ret(bcx, Call(bcx, llfn, [x, y]));
+ }
+
+ let output_type = ty::ty_fn_ret(ty::node_id_to_type(ccx.tcx, item.id));
+
+ let fcx = new_fn_ctxt_w_id(ccx,
+ path,
+ decl,
+ item.id,
+ output_type,
+ true,
+ Some(substs),
+ None,
+ Some(item.span));
+
+ set_always_inline(fcx.llfn);
+
+ // Set the fixed stack segment flag if necessary.
+ if attr::contains_name(attributes, "fixed_stack_segment") {
+ set_fixed_stack_segment(fcx.llfn);
+ }
+
+ let mut bcx = fcx.entry_bcx.unwrap();
+ let first_real_arg = fcx.arg_pos(0u);
+
+ let nm = ccx.sess.str_of(item.ident);
+ let name = nm.as_slice();
+
+ // This requires that atomic intrinsics follow a specific naming pattern:
+ // "atomic_<operation>[_<ordering>], and no ordering means SeqCst
+ if name.starts_with("atomic_") {
+ let split : ~[&str] = name.split_iter('_').collect();
+ assert!(split.len() >= 2, "Atomic intrinsic not correct format");
+ let order = if split.len() == 2 {
+ lib::llvm::SequentiallyConsistent
+ } else {
+ match split[2] {
+ "relaxed" => lib::llvm::Monotonic,
+ "acq" => lib::llvm::Acquire,
+ "rel" => lib::llvm::Release,
+ "acqrel" => lib::llvm::AcquireRelease,
+ _ => ccx.sess.fatal("Unknown ordering in atomic intrinsic")
+ }
+ };
+
+ match split[1] {
+ "cxchg" => {
+ let old = AtomicCmpXchg(bcx, get_param(decl, first_real_arg),
+ get_param(decl, first_real_arg + 1u),
+ get_param(decl, first_real_arg + 2u),
+ order);
+ Ret(bcx, old);
+ }
+ "load" => {
+ let old = AtomicLoad(bcx, get_param(decl, first_real_arg),
+ order);
+ Ret(bcx, old);
+ }
+ "store" => {
+ AtomicStore(bcx, get_param(decl, first_real_arg + 1u),
+ get_param(decl, first_real_arg),
+ order);
+ RetVoid(bcx);
+ }
+ "fence" => {
+ AtomicFence(bcx, order);
+ RetVoid(bcx);
+ }
+ op => {
+ // These are all AtomicRMW ops
+ let atom_op = match op {
+ "xchg" => lib::llvm::Xchg,
+ "xadd" => lib::llvm::Add,
+ "xsub" => lib::llvm::Sub,
+ "and" => lib::llvm::And,
+ "nand" => lib::llvm::Nand,
+ "or" => lib::llvm::Or,
+ "xor" => lib::llvm::Xor,
+ "max" => lib::llvm::Max,
+ "min" => lib::llvm::Min,
+ "umax" => lib::llvm::UMax,
+ "umin" => lib::llvm::UMin,
+ _ => ccx.sess.fatal("Unknown atomic operation")
+ };
+
+ let old = AtomicRMW(bcx, atom_op, get_param(decl, first_real_arg),
+ get_param(decl, first_real_arg + 1u),
+ order);
+ Ret(bcx, old);
+ }
+ }
+
+ fcx.cleanup();
+ return;
+ }
+
+ match name {
+ "size_of" => {
+ let tp_ty = substs.tys[0];
+ let lltp_ty = type_of::type_of(ccx, tp_ty);
+ Ret(bcx, C_uint(ccx, machine::llsize_of_real(ccx, lltp_ty)));
+ }
+ "move_val" => {
+ // Create a datum reflecting the value being moved.
+ // Use `appropriate_mode` so that the datum is by ref
+ // if the value is non-immediate. Note that, with
+ // intrinsics, there are no argument cleanups to
+ // concern ourselves with.
+ let tp_ty = substs.tys[0];
+ let mode = appropriate_mode(ccx.tcx, tp_ty);
+ let src = Datum {val: get_param(decl, first_real_arg + 1u),
+ ty: tp_ty, mode: mode};
+ bcx = src.move_to(bcx, DROP_EXISTING,
+ get_param(decl, first_real_arg));
+ RetVoid(bcx);
+ }
+ "move_val_init" => {
+ // See comments for `"move_val"`.
+ let tp_ty = substs.tys[0];
+ let mode = appropriate_mode(ccx.tcx, tp_ty);
+ let src = Datum {val: get_param(decl, first_real_arg + 1u),
+ ty: tp_ty, mode: mode};
+ bcx = src.move_to(bcx, INIT, get_param(decl, first_real_arg));
+ RetVoid(bcx);
+ }
+ "min_align_of" => {
+ let tp_ty = substs.tys[0];
+ let lltp_ty = type_of::type_of(ccx, tp_ty);
+ Ret(bcx, C_uint(ccx, machine::llalign_of_min(ccx, lltp_ty)));
+ }
+ "pref_align_of"=> {
+ let tp_ty = substs.tys[0];
+ let lltp_ty = type_of::type_of(ccx, tp_ty);
+ Ret(bcx, C_uint(ccx, machine::llalign_of_pref(ccx, lltp_ty)));
+ }
+ "get_tydesc" => {
+ let tp_ty = substs.tys[0];
+ let static_ti = get_tydesc(ccx, tp_ty);
+ glue::lazily_emit_all_tydesc_glue(ccx, static_ti);
+
+ // FIXME (#3730): ideally this shouldn't need a cast,
+ // but there's a circularity between translating rust types to llvm
+ // types and having a tydesc type available. So I can't directly access
+ // the llvm type of intrinsic::TyDesc struct.
+ let userland_tydesc_ty = type_of::type_of(ccx, output_type);
+ let td = PointerCast(bcx, static_ti.tydesc, userland_tydesc_ty);
+ Ret(bcx, td);
+ }
+ "init" => {
+ let tp_ty = substs.tys[0];
+ let lltp_ty = type_of::type_of(ccx, tp_ty);
+ match bcx.fcx.llretptr {
+ Some(ptr) => { Store(bcx, C_null(lltp_ty), ptr); RetVoid(bcx); }
+ None if ty::type_is_nil(tp_ty) => RetVoid(bcx),
+ None => Ret(bcx, C_null(lltp_ty)),
+ }
+ }
+ "uninit" => {
+ // Do nothing, this is effectively a no-op
+ let retty = substs.tys[0];
+ if ty::type_is_immediate(ccx.tcx, retty) && !ty::type_is_nil(retty) {
+ unsafe {
+ Ret(bcx, lib::llvm::llvm::LLVMGetUndef(type_of(ccx, retty).to_ref()));
+ }
+ } else {
+ RetVoid(bcx)
+ }
+ }
+ "forget" => {
+ RetVoid(bcx);
+ }
+ "transmute" => {
+ let (in_type, out_type) = (substs.tys[0], substs.tys[1]);
+ let llintype = type_of::type_of(ccx, in_type);
+ let llouttype = type_of::type_of(ccx, out_type);
+
+ let in_type_size = machine::llbitsize_of_real(ccx, llintype);
+ let out_type_size = machine::llbitsize_of_real(ccx, llouttype);
+ if in_type_size != out_type_size {
+ let sp = match ccx.tcx.items.get_copy(&ref_id.unwrap()) {
+ ast_map::node_expr(e) => e.span,
+ _ => fail!("transmute has non-expr arg"),
+ };
+ let pluralize = |n| if 1u == n { "" } else { "s" };
+ ccx.sess.span_fatal(sp,
+ fmt!("transmute called on types with \
+ different sizes: %s (%u bit%s) to \
+ %s (%u bit%s)",
+ ty_to_str(ccx.tcx, in_type),
+ in_type_size,
+ pluralize(in_type_size),
+ ty_to_str(ccx.tcx, out_type),
+ out_type_size,
+ pluralize(out_type_size)));
+ }
+
+ if !ty::type_is_voidish(out_type) {
+ let llsrcval = get_param(decl, first_real_arg);
+ if ty::type_is_immediate(ccx.tcx, in_type) {
+ match fcx.llretptr {
+ Some(llretptr) => {
+ Store(bcx, llsrcval, PointerCast(bcx, llretptr, llintype.ptr_to()));
+ RetVoid(bcx);
+ }
+ None => match (llintype.kind(), llouttype.kind()) {
+ (Pointer, other) | (other, Pointer) if other != Pointer => {
+ let tmp = Alloca(bcx, llouttype, "");
+ Store(bcx, llsrcval, PointerCast(bcx, tmp, llintype.ptr_to()));
+ Ret(bcx, Load(bcx, tmp));
+ }
+ _ => Ret(bcx, BitCast(bcx, llsrcval, llouttype))
+ }
+ }
+ } else if ty::type_is_immediate(ccx.tcx, out_type) {
+ let llsrcptr = PointerCast(bcx, llsrcval, llouttype.ptr_to());
+ Ret(bcx, Load(bcx, llsrcptr));
+ } else {
+ // NB: Do not use a Load and Store here. This causes massive
+ // code bloat when `transmute` is used on large structural
+ // types.
+ let lldestptr = fcx.llretptr.unwrap();
+ let lldestptr = PointerCast(bcx, lldestptr, Type::i8p());
+ let llsrcptr = PointerCast(bcx, llsrcval, Type::i8p());
+
+ let llsize = llsize_of(ccx, llintype);
+ call_memcpy(bcx, lldestptr, llsrcptr, llsize, 1);
+ RetVoid(bcx);
+ };
+ } else {
+ RetVoid(bcx);
+ }
+ }
+ "needs_drop" => {
+ let tp_ty = substs.tys[0];
+ Ret(bcx, C_bool(ty::type_needs_drop(ccx.tcx, tp_ty)));
+ }
+ "contains_managed" => {
+ let tp_ty = substs.tys[0];
+ Ret(bcx, C_bool(ty::type_contents(ccx.tcx, tp_ty).contains_managed()));
+ }
+ "visit_tydesc" => {
+ let td = get_param(decl, first_real_arg);
+ let visitor = get_param(decl, first_real_arg + 1u);
+ let td = PointerCast(bcx, td, ccx.tydesc_type.ptr_to());
+ glue::call_tydesc_glue_full(bcx, visitor, td,
+ abi::tydesc_field_visit_glue, None);
+ RetVoid(bcx);
+ }
+ "frame_address" => {
+ let frameaddress = ccx.intrinsics.get_copy(& &"llvm.frameaddress");
+ let frameaddress_val = Call(bcx, frameaddress, [C_i32(0i32)]);
+ let star_u8 = ty::mk_imm_ptr(
+ bcx.tcx(),
+ ty::mk_mach_uint(ast::ty_u8));
+ let fty = ty::mk_closure(bcx.tcx(), ty::ClosureTy {
+ purity: ast::impure_fn,
+ sigil: ast::BorrowedSigil,
+ onceness: ast::Many,
+ region: ty::re_bound(ty::br_anon(0)),
+ bounds: ty::EmptyBuiltinBounds(),
+ sig: FnSig {
+ bound_lifetime_names: opt_vec::Empty,
+ inputs: ~[ star_u8 ],
+ output: ty::mk_nil()
+ }
+ });
+ let datum = Datum {val: get_param(decl, first_real_arg),
+ mode: ByRef(ZeroMem), ty: fty};
+ let arg_vals = ~[frameaddress_val];
+ bcx = trans_call_inner(
+ bcx, None, fty, ty::mk_nil(),
+ |bcx| Callee {bcx: bcx, data: Closure(datum)},
+ ArgVals(arg_vals), Some(Ignore), DontAutorefArg).bcx;
+ RetVoid(bcx);
+ }
+ "morestack_addr" => {
+ // XXX This is a hack to grab the address of this particular
+ // native function. There should be a general in-language
+ // way to do this
+ let llfty = type_of_rust_fn(bcx.ccx(), [], ty::mk_nil());
+ let morestack_addr = decl_cdecl_fn(
+ bcx.ccx().llmod, "__morestack", llfty);
+ let morestack_addr = PointerCast(bcx, morestack_addr, Type::nil().ptr_to());
+ Ret(bcx, morestack_addr);
+ }
+ "offset" => {
+ let ptr = get_param(decl, first_real_arg);
+ let offset = get_param(decl, first_real_arg + 1);
+ Ret(bcx, GEP(bcx, ptr, [offset]));
+ }
+ "offset_inbounds" => {
+ let ptr = get_param(decl, first_real_arg);
+ let offset = get_param(decl, first_real_arg + 1);
+ Ret(bcx, InBoundsGEP(bcx, ptr, [offset]));
+ }
+ "memcpy32" => memcpy_intrinsic(bcx, "llvm.memcpy.p0i8.p0i8.i32", substs.tys[0], 32),
+ "memcpy64" => memcpy_intrinsic(bcx, "llvm.memcpy.p0i8.p0i8.i64", substs.tys[0], 64),
+ "memmove32" => memcpy_intrinsic(bcx, "llvm.memmove.p0i8.p0i8.i32", substs.tys[0], 32),
+ "memmove64" => memcpy_intrinsic(bcx, "llvm.memmove.p0i8.p0i8.i64", substs.tys[0], 64),
+ "memset32" => memset_intrinsic(bcx, "llvm.memset.p0i8.i32", substs.tys[0], 32),
+ "memset64" => memset_intrinsic(bcx, "llvm.memset.p0i8.i64", substs.tys[0], 64),
+ "sqrtf32" => simple_llvm_intrinsic(bcx, "llvm.sqrt.f32", 1),
+ "sqrtf64" => simple_llvm_intrinsic(bcx, "llvm.sqrt.f64", 1),
+ "powif32" => simple_llvm_intrinsic(bcx, "llvm.powi.f32", 2),
+ "powif64" => simple_llvm_intrinsic(bcx, "llvm.powi.f64", 2),
+ "sinf32" => simple_llvm_intrinsic(bcx, "llvm.sin.f32", 1),
+ "sinf64" => simple_llvm_intrinsic(bcx, "llvm.sin.f64", 1),
+ "cosf32" => simple_llvm_intrinsic(bcx, "llvm.cos.f32", 1),
+ "cosf64" => simple_llvm_intrinsic(bcx, "llvm.cos.f64", 1),
+ "powf32" => simple_llvm_intrinsic(bcx, "llvm.pow.f32", 2),
+ "powf64" => simple_llvm_intrinsic(bcx, "llvm.pow.f64", 2),
+ "expf32" => simple_llvm_intrinsic(bcx, "llvm.exp.f32", 1),
+ "expf64" => simple_llvm_intrinsic(bcx, "llvm.exp.f64", 1),
+ "exp2f32" => simple_llvm_intrinsic(bcx, "llvm.exp2.f32", 1),
+ "exp2f64" => simple_llvm_intrinsic(bcx, "llvm.exp2.f64", 1),
+ "logf32" => simple_llvm_intrinsic(bcx, "llvm.log.f32", 1),
+ "logf64" => simple_llvm_intrinsic(bcx, "llvm.log.f64", 1),
+ "log10f32" => simple_llvm_intrinsic(bcx, "llvm.log10.f32", 1),
+ "log10f64" => simple_llvm_intrinsic(bcx, "llvm.log10.f64", 1),
+ "log2f32" => simple_llvm_intrinsic(bcx, "llvm.log2.f32", 1),
+ "log2f64" => simple_llvm_intrinsic(bcx, "llvm.log2.f64", 1),
+ "fmaf32" => simple_llvm_intrinsic(bcx, "llvm.fma.f32", 3),
+ "fmaf64" => simple_llvm_intrinsic(bcx, "llvm.fma.f64", 3),
+ "fabsf32" => simple_llvm_intrinsic(bcx, "llvm.fabs.f32", 1),
+ "fabsf64" => simple_llvm_intrinsic(bcx, "llvm.fabs.f64", 1),
+ "floorf32" => simple_llvm_intrinsic(bcx, "llvm.floor.f32", 1),
+ "floorf64" => simple_llvm_intrinsic(bcx, "llvm.floor.f64", 1),
+ "ceilf32" => simple_llvm_intrinsic(bcx, "llvm.ceil.f32", 1),
+ "ceilf64" => simple_llvm_intrinsic(bcx, "llvm.ceil.f64", 1),
+ "truncf32" => simple_llvm_intrinsic(bcx, "llvm.trunc.f32", 1),
+ "truncf64" => simple_llvm_intrinsic(bcx, "llvm.trunc.f64", 1),
+ "ctpop8" => simple_llvm_intrinsic(bcx, "llvm.ctpop.i8", 1),
+ "ctpop16" => simple_llvm_intrinsic(bcx, "llvm.ctpop.i16", 1),
+ "ctpop32" => simple_llvm_intrinsic(bcx, "llvm.ctpop.i32", 1),
+ "ctpop64" => simple_llvm_intrinsic(bcx, "llvm.ctpop.i64", 1),
+ "ctlz8" => count_zeros_intrinsic(bcx, "llvm.ctlz.i8"),
+ "ctlz16" => count_zeros_intrinsic(bcx, "llvm.ctlz.i16"),
+ "ctlz32" => count_zeros_intrinsic(bcx, "llvm.ctlz.i32"),
+ "ctlz64" => count_zeros_intrinsic(bcx, "llvm.ctlz.i64"),
+ "cttz8" => count_zeros_intrinsic(bcx, "llvm.cttz.i8"),
+ "cttz16" => count_zeros_intrinsic(bcx, "llvm.cttz.i16"),
+ "cttz32" => count_zeros_intrinsic(bcx, "llvm.cttz.i32"),
+ "cttz64" => count_zeros_intrinsic(bcx, "llvm.cttz.i64"),
+ "bswap16" => simple_llvm_intrinsic(bcx, "llvm.bswap.i16", 1),
+ "bswap32" => simple_llvm_intrinsic(bcx, "llvm.bswap.i32", 1),
+ "bswap64" => simple_llvm_intrinsic(bcx, "llvm.bswap.i64", 1),
+
+ "i8_add_with_overflow" => with_overflow_instrinsic(bcx, "llvm.sadd.with.overflow.i8"),
+ "i16_add_with_overflow" => with_overflow_instrinsic(bcx, "llvm.sadd.with.overflow.i16"),
+ "i32_add_with_overflow" => with_overflow_instrinsic(bcx, "llvm.sadd.with.overflow.i32"),
+ "i64_add_with_overflow" => with_overflow_instrinsic(bcx, "llvm.sadd.with.overflow.i64"),
+
+ "u8_add_with_overflow" => with_overflow_instrinsic(bcx, "llvm.uadd.with.overflow.i8"),
+ "u16_add_with_overflow" => with_overflow_instrinsic(bcx, "llvm.uadd.with.overflow.i16"),
+ "u32_add_with_overflow" => with_overflow_instrinsic(bcx, "llvm.uadd.with.overflow.i32"),
+ "u64_add_with_overflow" => with_overflow_instrinsic(bcx, "llvm.uadd.with.overflow.i64"),
+
+ "i8_sub_with_overflow" => with_overflow_instrinsic(bcx, "llvm.ssub.with.overflow.i8"),
+ "i16_sub_with_overflow" => with_overflow_instrinsic(bcx, "llvm.ssub.with.overflow.i16"),
+ "i32_sub_with_overflow" => with_overflow_instrinsic(bcx, "llvm.ssub.with.overflow.i32"),
+ "i64_sub_with_overflow" => with_overflow_instrinsic(bcx, "llvm.ssub.with.overflow.i64"),
+
+ "u8_sub_with_overflow" => with_overflow_instrinsic(bcx, "llvm.usub.with.overflow.i8"),
+ "u16_sub_with_overflow" => with_overflow_instrinsic(bcx, "llvm.usub.with.overflow.i16"),
+ "u32_sub_with_overflow" => with_overflow_instrinsic(bcx, "llvm.usub.with.overflow.i32"),
+ "u64_sub_with_overflow" => with_overflow_instrinsic(bcx, "llvm.usub.with.overflow.i64"),
+
+ "i8_mul_with_overflow" => with_overflow_instrinsic(bcx, "llvm.smul.with.overflow.i8"),
+ "i16_mul_with_overflow" => with_overflow_instrinsic(bcx, "llvm.smul.with.overflow.i16"),
+ "i32_mul_with_overflow" => with_overflow_instrinsic(bcx, "llvm.smul.with.overflow.i32"),
+ "i64_mul_with_overflow" => with_overflow_instrinsic(bcx, "llvm.smul.with.overflow.i64"),
+
+ "u8_mul_with_overflow" => with_overflow_instrinsic(bcx, "llvm.umul.with.overflow.i8"),
+ "u16_mul_with_overflow" => with_overflow_instrinsic(bcx, "llvm.umul.with.overflow.i16"),
+ "u32_mul_with_overflow" => with_overflow_instrinsic(bcx, "llvm.umul.with.overflow.i32"),
+ "u64_mul_with_overflow" => with_overflow_instrinsic(bcx, "llvm.umul.with.overflow.i64"),
+
+ _ => {
+ // Could we make this an enum rather than a string? does it get
+ // checked earlier?
+ ccx.sess.span_bug(item.span, "unknown intrinsic");
+ }
+ }
+ fcx.cleanup();
+}
}
}
- typeck::method_trait(_, off) => {
+ typeck::method_object(ref mt) => {
trans_trait_callee(bcx,
callee_id,
- off,
+ mt.real_index,
this)
}
}
return (ty_substs, vtables);
}
-
pub fn trans_trait_callee(bcx: @mut Block,
callee_id: ast::NodeId,
n_method: uint,
/// This is used only for objects.
pub fn get_vtable(bcx: @mut Block,
self_ty: ty::t,
- origin: typeck::vtable_origin)
+ origins: typeck::vtable_param_res)
-> ValueRef {
- let hash_id = vtable_id(bcx.ccx(), &origin);
- match bcx.ccx().vtables.find(&hash_id) {
- Some(&val) => val,
- None => {
- match origin {
- typeck::vtable_static(id, substs, sub_vtables) => {
- make_impl_vtable(bcx, id, self_ty, substs, sub_vtables)
- }
- _ => fail!("get_vtable: expected a static origin"),
+ let ccx = bcx.ccx();
+ let _icx = push_ctxt("impl::get_vtable");
+
+ // Check the cache.
+ let hash_id = (self_ty, vtable_id(ccx, &origins[0]));
+ match ccx.vtables.find(&hash_id) {
+ Some(&val) => { return val }
+ None => { }
+ }
+
+ // Not in the cache. Actually build it.
+ let methods = do origins.flat_map |origin| {
+ match *origin {
+ typeck::vtable_static(id, ref substs, sub_vtables) => {
+ emit_vtable_methods(bcx, id, *substs, sub_vtables)
}
+ _ => ccx.sess.bug("get_vtable: expected a static origin"),
}
- }
+ };
+
+ // Generate a type descriptor for the vtable.
+ let tydesc = get_tydesc(ccx, self_ty);
+ glue::lazily_emit_all_tydesc_glue(ccx, tydesc);
+
+ let vtable = make_vtable(ccx, tydesc, methods);
+ ccx.vtables.insert(hash_id, vtable);
+ return vtable;
}
/// Helper function to declare and initialize the vtable.
}
}
-/// Generates a dynamic vtable for objects.
-pub fn make_impl_vtable(bcx: @mut Block,
- impl_id: ast::def_id,
- self_ty: ty::t,
- substs: &[ty::t],
- vtables: typeck::vtable_res)
- -> ValueRef {
+fn emit_vtable_methods(bcx: @mut Block,
+ impl_id: ast::def_id,
+ substs: &[ty::t],
+ vtables: typeck::vtable_res)
+ -> ~[ValueRef] {
let ccx = bcx.ccx();
- let _icx = push_ctxt("impl::make_impl_vtable");
let tcx = ccx.tcx;
let trt_id = match ty::impl_trait_ref(tcx, impl_id) {
};
let trait_method_def_ids = ty::trait_method_def_ids(tcx, trt_id);
- let methods = do trait_method_def_ids.map |method_def_id| {
+ do trait_method_def_ids.map |method_def_id| {
let im = ty::method(tcx, *method_def_id);
let fty = ty::subst_tps(tcx,
substs,
trans_fn_ref_with_vtables(bcx, m_id, 0,
substs, Some(vtables)).llfn
}
- };
-
- // Generate a type descriptor for the vtable.
- let tydesc = get_tydesc(ccx, self_ty);
- glue::lazily_emit_all_tydesc_glue(ccx, tydesc);
-
- make_vtable(ccx, tydesc, methods)
+ }
}
pub fn trans_trait_cast(bcx: @mut Block,
bcx = expr::trans_into(bcx, val, SaveIn(llboxdest));
// Store the vtable into the pair or triple.
- let orig = ccx.maps.vtable_map.get(&id)[0][0].clone();
- let orig = resolve_vtable_in_fn_ctxt(bcx.fcx, &orig);
- let vtable = get_vtable(bcx, v_ty, orig);
+ // This is structured a bit funny because of dynamic borrow failures.
+ let origins = {
+ let res = ccx.maps.vtable_map.get(&id);
+ let res = resolve_vtables_in_fn_ctxt(bcx.fcx, *res);
+ res[0]
+ };
+ let vtable = get_vtable(bcx, v_ty, origins);
Store(bcx, vtable, PointerCast(bcx,
GEPi(bcx, lldest, [0u, abi::trt_field_vtable]),
val_ty(vtable).ptr_to()));
pub mod cabi_arm;
pub mod cabi_mips;
pub mod foreign;
+pub mod intrinsic;
pub mod reflect;
pub mod debuginfo;
pub mod type_use;
use back::link::mangle_exported_name;
use driver::session;
use lib::llvm::ValueRef;
-use middle::trans::base::{set_inline_hint_if_appr, set_inline_hint};
+use middle::trans::base::{set_llvm_fn_attrs, set_inline_hint};
use middle::trans::base::{trans_enum_variant,push_ctxt};
use middle::trans::base::{trans_fn, decl_internal_cdecl_fn};
use middle::trans::base::{get_item_val, no_self};
use middle::trans::base;
use middle::trans::common::*;
use middle::trans::datum;
-use middle::trans::foreign;
use middle::trans::machine;
use middle::trans::meth;
use middle::trans::type_of::type_of_fn_from_ty;
use middle::trans::type_of;
use middle::trans::type_use;
+use middle::trans::intrinsic;
use middle::ty;
use middle::ty::{FnSig};
use middle::typeck;
_
}, _) => {
let d = mk_lldecl();
- set_inline_hint_if_appr(i.attrs, d);
+ set_llvm_fn_attrs(i.attrs, d);
trans_fn(ccx,
pt,
decl,
}
ast_map::node_foreign_item(i, _, _, _) => {
let d = mk_lldecl();
- foreign::trans_intrinsic(ccx, d, i, pt, psubsts, i.attrs,
- ref_id);
+ intrinsic::trans_intrinsic(ccx, d, i, pt, psubsts, i.attrs,
+ ref_id);
d
}
ast_map::node_variant(ref v, enum_item, _) => {
ast_map::node_method(mth, _, _) => {
// XXX: What should the self type be here?
let d = mk_lldecl();
- set_inline_hint_if_appr(mth.attrs.clone(), d);
+ set_llvm_fn_attrs(mth.attrs, d);
meth::trans_method(ccx, pt, mth, Some(psubsts), d);
d
}
ast_map::node_trait_method(@ast::provided(mth), _, pt) => {
let d = mk_lldecl();
- set_inline_hint_if_appr(mth.attrs.clone(), d);
+ set_llvm_fn_attrs(mth.attrs, d);
meth::trans_method(ccx, (*pt).clone(), mth, Some(psubsts), d);
d
}
sub_path,
"get_disr");
- let llfty = type_of_fn(ccx, [opaqueptrty], ty::mk_int());
+ let llfty = type_of_rust_fn(ccx, [opaqueptrty], ty::mk_int());
let llfdecl = decl_internal_cdecl_fn(ccx.llmod, sym, llfty);
let fcx = new_fn_ctxt(ccx,
~[],
use middle::trans::adt;
use middle::trans::common::*;
+use middle::trans::foreign;
use middle::ty;
use util::ppaux;
use syntax::ast;
use syntax::opt_vec;
-pub fn arg_is_indirect(ccx: &CrateContext, arg_ty: &ty::t) -> bool {
- !ty::type_is_immediate(ccx.tcx, *arg_ty)
+pub fn arg_is_indirect(ccx: &CrateContext, arg_ty: ty::t) -> bool {
+ !ty::type_is_immediate(ccx.tcx, arg_ty)
}
-pub fn type_of_explicit_arg(ccx: &mut CrateContext, arg_ty: &ty::t) -> Type {
- let llty = type_of(ccx, *arg_ty);
+pub fn return_uses_outptr(tcx: ty::ctxt, ty: ty::t) -> bool {
+ !ty::type_is_immediate(tcx, ty)
+}
+
+pub fn type_of_explicit_arg(ccx: &mut CrateContext, arg_ty: ty::t) -> Type {
+ let llty = type_of(ccx, arg_ty);
if arg_is_indirect(ccx, arg_ty) {
llty.ptr_to()
} else {
pub fn type_of_explicit_args(ccx: &mut CrateContext,
inputs: &[ty::t]) -> ~[Type] {
- inputs.map(|arg_ty| type_of_explicit_arg(ccx, arg_ty))
+ inputs.map(|&arg_ty| type_of_explicit_arg(ccx, arg_ty))
}
-pub fn type_of_fn(cx: &mut CrateContext, inputs: &[ty::t], output: ty::t) -> Type {
+pub fn type_of_rust_fn(cx: &mut CrateContext,
+ inputs: &[ty::t],
+ output: ty::t) -> Type {
let mut atys: ~[Type] = ~[];
// Arg 0: Output pointer.
// (if the output type is non-immediate)
- let output_is_immediate = ty::type_is_immediate(cx.tcx, output);
+ let use_out_pointer = return_uses_outptr(cx.tcx, output);
let lloutputtype = type_of(cx, output);
- if !output_is_immediate {
+ if use_out_pointer {
atys.push(lloutputtype.ptr_to());
}
atys.push_all(type_of_explicit_args(cx, inputs));
// Use the output as the actual return value if it's immediate.
- if output_is_immediate && !ty::type_is_nil(output) {
+ if !use_out_pointer && !ty::type_is_voidish(output) {
Type::func(atys, &lloutputtype)
} else {
Type::func(atys, &Type::void())
// Given a function type and a count of ty params, construct an llvm type
pub fn type_of_fn_from_ty(cx: &mut CrateContext, fty: ty::t) -> Type {
- match ty::get(fty).sty {
- ty::ty_closure(ref f) => type_of_fn(cx, f.sig.inputs, f.sig.output),
- ty::ty_bare_fn(ref f) => type_of_fn(cx, f.sig.inputs, f.sig.output),
+ return match ty::get(fty).sty {
+ ty::ty_closure(ref f) => {
+ type_of_rust_fn(cx, f.sig.inputs, f.sig.output)
+ }
+ ty::ty_bare_fn(ref f) => {
+ if f.abis.is_rust() || f.abis.is_intrinsic() {
+ type_of_rust_fn(cx, f.sig.inputs, f.sig.output)
+ } else {
+ foreign::lltype_for_foreign_fn(cx, fty)
+ }
+ }
_ => {
cx.sess.bug("type_of_fn_from_ty given non-closure, non-bare-fn")
}
- }
+ };
}
// A "sizing type" is an LLVM type, the size and alignment of which are
Type::array(&type_of(cx, mt.ty), n as u64)
}
- ty::ty_bare_fn(_) => type_of_fn_from_ty(cx, t).ptr_to(),
+ ty::ty_bare_fn(_) => {
+ type_of_fn_from_ty(cx, t).ptr_to()
+ }
ty::ty_closure(_) => {
let ty = type_of_fn_from_ty(cx, t);
Type::func_pair(cx, &ty)
use syntax::ast_map;
use syntax::ast_util;
use syntax::parse::token;
-use syntax::oldvisit;
+use syntax::visit;
+use syntax::visit::Visitor;
pub type type_uses = uint; // Bitmask
pub static use_repr: uint = 1; /* Dependency on size/alignment/mode and
pub static use_tydesc: uint = 2; /* Takes the tydesc, or compares */
pub static use_all: uint = use_repr|use_tydesc;
-
+#[deriving(Clone)]
pub struct Context {
ccx: @mut CrateContext,
uses: @mut ~[type_uses]
}
}
-pub fn handle_body(cx: &Context, body: &Block) {
- let v = oldvisit::mk_vt(@oldvisit::Visitor {
- visit_expr: |e, (cx, v)| {
- oldvisit::visit_expr(e, (cx, v));
+struct TypeUseVisitor;
+
+impl<'self> Visitor<&'self Context> for TypeUseVisitor {
+
+ fn visit_expr<'a>(&mut self, e:@expr, cx: &'a Context) {
+ visit::walk_expr(self, e, cx);
mark_for_expr(cx, e);
- },
- visit_local: |l, (cx, v)| {
- oldvisit::visit_local(l, (cx, v));
+ }
+
+ fn visit_local<'a>(&mut self, l:@Local, cx: &'a Context) {
+ visit::walk_local(self, l, cx);
node_type_needs(cx, use_repr, l.id);
- },
- visit_pat: |p, (cx, v)| {
- oldvisit::visit_pat(p, (cx, v));
+ }
+
+ fn visit_pat<'a>(&mut self, p:@pat, cx: &'a Context) {
+ visit::walk_pat(self, p, cx);
node_type_needs(cx, use_repr, p.id);
- },
- visit_block: |b, (cx, v)| {
- oldvisit::visit_block(b, (cx, v));
+ }
+
+ fn visit_block<'a>(&mut self, b:&Block, cx: &'a Context) {
+ visit::walk_block(self, b, cx);
for e in b.expr.iter() {
node_type_needs(cx, use_repr, e.id);
}
- },
- visit_item: |_i, (_cx, _v)| { },
- ..*oldvisit::default_visitor()
- });
- (v.visit_block)(body, (cx, v));
+ }
+
+ fn visit_item<'a>(&mut self, _:@item, _: &'a Context) {
+ // do nothing
+ }
+
+}
+
+pub fn handle_body(cx: &Context, body: &Block) {
+ let mut v = TypeUseVisitor;
+ v.visit_block(body, cx);
}
use std::ptr::to_unsafe_ptr;
use std::to_bytes;
use std::to_str::ToStr;
-use std::u32;
use std::vec;
use syntax::ast::*;
use syntax::ast_util::is_local;
mt: mt
}
+#[deriving(Clone)]
pub struct Method {
ident: ast::ident,
generics: ty::Generics,
/// As `ty_param_bounds_and_ty` but for a trait ref.
pub struct TraitDef {
generics: Generics,
+ bounds: BuiltinBounds,
trait_ref: @ty::TraitRef,
}
// Type utilities
+pub fn type_is_voidish(ty: t) -> bool {
+ //! "nil" and "bot" are void types in that they represent 0 bits of information
+ type_is_nil(ty) || type_is_bot(ty)
+}
+
pub fn type_is_nil(ty: t) -> bool { get(ty).sty == ty_nil }
pub fn type_is_bot(ty: t) -> bool {
impl ToStr for TypeContents {
fn to_str(&self) -> ~str {
- fmt!("TypeContents(%s)", u32::to_str_radix(self.bits, 2))
+ fmt!("TypeContents(%s)", self.bits.to_str_radix(2))
}
}
// def-id.
assert_eq!(p.def_id.crate, ast::LOCAL_CRATE);
- type_param_def_to_contents(
- cx, cx.ty_param_defs.get(&p.def_id.node))
+ let tp_def = cx.ty_param_defs.get(&p.def_id.node);
+ kind_bounds_to_contents(cx, &tp_def.bounds.builtin_bounds,
+ tp_def.bounds.trait_bounds)
}
- ty_self(_) => {
- // Currently, self is not bounded, so we must assume the
- // worst. But in the future we should examine the super
- // traits.
- //
+ ty_self(def_id) => {
// FIXME(#4678)---self should just be a ty param
- TC_ALL
+
+ // Self may be bounded if the associated trait has builtin kinds
+ // for supertraits. If so we can use those bounds.
+ let trait_def = lookup_trait_def(cx, def_id);
+ let traits = [trait_def.trait_ref];
+ kind_bounds_to_contents(cx, &trait_def.bounds, traits)
}
ty_infer(_) => {
st + mt + bt
}
- fn type_param_def_to_contents(cx: ctxt,
- type_param_def: &TypeParameterDef) -> TypeContents
- {
- debug!("type_param_def_to_contents(%s)", type_param_def.repr(cx));
+ fn kind_bounds_to_contents(cx: ctxt, bounds: &BuiltinBounds, traits: &[@TraitRef])
+ -> TypeContents {
let _i = indenter();
let mut tc = TC_ALL;
- for bound in type_param_def.bounds.builtin_bounds.iter() {
+ do each_inherited_builtin_bound(cx, bounds, traits) |bound| {
debug!("tc = %s, bound = %?", tc.to_str(), bound);
tc = tc - match bound {
BoundStatic => TypeContents::nonstatic(cx),
debug!("result = %s", tc.to_str());
return tc;
+
+ // Iterates over all builtin bounds on the type parameter def, including
+ // those inherited from traits with builtin-kind-supertraits.
+ fn each_inherited_builtin_bound(cx: ctxt, bounds: &BuiltinBounds,
+ traits: &[@TraitRef], f: &fn(BuiltinBound)) {
+ for bound in bounds.iter() {
+ f(bound);
+ }
+
+ do each_bound_trait_and_supertraits(cx, traits) |trait_ref| {
+ let trait_def = lookup_trait_def(cx, trait_ref.def_id);
+ for bound in trait_def.bounds.iter() {
+ f(bound);
+ }
+ true
+ };
+ }
}
}
typeck::method_param(typeck::method_param {
trait_id: trt_id,
method_num: n_mth, _}) |
- typeck::method_trait(trt_id, n_mth) => {
+ typeck::method_object(typeck::method_object {
+ trait_id: trt_id,
+ method_num: n_mth, _}) => {
// ...trait methods bounds, in contrast, include only the
// method bounds, so we must preprend the tps from the
// trait itself. This ought to be harmonized.
let trait_type_param_defs =
- ty::lookup_trait_def(tcx, trt_id).generics.type_param_defs;
+ lookup_trait_def(tcx, trt_id).generics.type_param_defs;
@vec::append(
(*trait_type_param_defs).clone(),
*ty::trait_method(tcx,
return ret;
}
+pub fn trait_ref_to_def_id(tcx: ctxt, tr: &ast::trait_ref) -> ast::def_id {
+ let def = tcx.def_map.find(&tr.ref_id).expect("no def-map entry for trait");
+ ast_util::def_id_of_def(*def)
+}
+
+pub fn try_add_builtin_trait(tcx: ctxt,
+ trait_def_id: ast::def_id,
+ builtin_bounds: &mut BuiltinBounds) -> bool {
+ //! Checks whether `trait_ref` refers to one of the builtin
+ //! traits, like `Send`, and adds the corresponding
+ //! bound to the set `builtin_bounds` if so. Returns true if `trait_ref`
+ //! is a builtin trait.
+
+ match tcx.lang_items.to_builtin_kind(trait_def_id) {
+ Some(bound) => { builtin_bounds.add(bound); true }
+ None => false
+ }
+}
+
pub fn ty_to_def_id(ty: t) -> Option<ast::def_id> {
match get(ty).sty {
ty_trait(id, _, _, _, _) | ty_struct(id, _) | ty_enum(id, _) => Some(id),
ast::TraitTyParamBound(ref b) => {
match lookup_def_tcx(tcx, b.path.span, b.ref_id) {
ast::def_trait(trait_did) => {
- if try_add_builtin_trait(tcx,
- trait_did,
- &mut builtin_bounds) {
+ if ty::try_add_builtin_trait(tcx, trait_did,
+ &mut builtin_bounds) {
loop; // success
}
}
(&None, ty::RegionTraitStore(*)) => ty::EmptyBuiltinBounds(),
}
}
-
-pub fn try_add_builtin_trait(tcx: ty::ctxt,
- trait_def_id: ast::def_id,
- builtin_bounds: &mut ty::BuiltinBounds) -> bool {
- //! Checks whether `trait_ref` refers to one of the builtin
- //! traits, like `Send`, and adds the corresponding
- //! bound to the set `builtin_bounds` if so. Returns true if `trait_ref`
- //! is a builtin trait.
-
- let li = &tcx.lang_items;
- if Some(trait_def_id) == li.send_trait() {
- builtin_bounds.add(ty::BoundSend);
- true
- } else if Some(trait_def_id) == li.freeze_trait() {
- builtin_bounds.add(ty::BoundFreeze);
- true
- } else if Some(trait_def_id) == li.sized_trait() {
- builtin_bounds.add(ty::BoundSized);
- true
- } else {
- false
- }
-}
use middle::typeck::check;
use middle::typeck::infer;
use middle::typeck::{method_map_entry, method_origin, method_param};
-use middle::typeck::{method_static, method_trait};
+use middle::typeck::{method_static, method_object};
use middle::typeck::{param_numbered, param_self, param_index};
use middle::typeck::check::regionmanip::replace_bound_regions_in_fn_sig;
use util::common::indenter;
loop {
match get(self_ty).sty {
ty_trait(did, ref substs, _, _, _) => {
- self.push_inherent_candidates_from_trait(did, substs);
+ self.push_inherent_candidates_from_object(did, substs);
self.push_inherent_impl_candidates_for_type(did);
}
ty_enum(did, _) | ty_struct(did, _) => {
}
}
- fn push_inherent_candidates_from_trait(&self,
- did: def_id,
- substs: &ty::substs) {
- debug!("push_inherent_candidates_from_trait(did=%s, substs=%s)",
- self.did_to_str(did),
- substs_to_str(self.tcx(), substs));
- let _indenter = indenter();
-
+ // Determine the index of a method in the list of all methods belonging
+ // to a trait and its supertraits.
+ fn get_method_index(&self,
+ trait_ref: @TraitRef,
+ subtrait_id: ast::def_id,
+ n_method: uint) -> uint {
let tcx = self.tcx();
- let ms = ty::trait_methods(tcx, did);
- let index = match ms.iter().position(|m| m.ident == self.m_name) {
- Some(i) => i,
- None => { return; } // no method with the right name
- };
- let method = ms[index];
- match method.explicit_self {
- ast::sty_static => {
- return; // not a method we can call with dot notation
+ // We need to figure the "real index" of the method in a
+ // listing of all the methods of an object. We do this by
+ // iterating down the supertraits of the object's trait until
+ // we find the trait the method came from, counting up the
+ // methods from them.
+ let mut method_count = 0;
+ do ty::each_bound_trait_and_supertraits(tcx, &[trait_ref])
+ |bound_ref| {
+ if bound_ref.def_id == subtrait_id { false }
+ else {
+ method_count += ty::trait_methods(tcx, bound_ref.def_id).len();
+ true
}
- _ => {}
- }
+ };
+
+ return method_count + n_method;
+ }
+
+
+ fn push_inherent_candidates_from_object(&self,
+ did: def_id,
+ substs: &ty::substs) {
+ debug!("push_inherent_candidates_from_object(did=%s, substs=%s)",
+ self.did_to_str(did),
+ substs_to_str(self.tcx(), substs));
+ let _indenter = indenter();
// It is illegal to invoke a method on a trait instance that
// refers to the `self` type. An error will be reported by
// to the `Self` type. Substituting ty_err here allows
// compiler to soldier on.
//
- // NOTE: `confirm_candidate()` also relies upon this substitution
+ // `confirm_candidate()` also relies upon this substitution
// for Self. (fix)
let rcvr_substs = substs {
self_ty: Some(ty::mk_err()),
..(*substs).clone()
};
-
- self.inherent_candidates.push(Candidate {
- rcvr_match_condition: RcvrMatchesIfObject(did),
- rcvr_substs: rcvr_substs,
- method_ty: method,
- origin: method_trait(did, index)
- });
+ let trait_ref = @TraitRef { def_id: did, substs: rcvr_substs.clone() };
+
+ do self.push_inherent_candidates_from_bounds_inner(&[trait_ref])
+ |trait_ref, m, method_num, _bound_num| {
+ let vtable_index =
+ self.get_method_index(trait_ref, trait_ref.def_id, method_num);
+ // We need to fix up the transformed self type.
+ let transformed_self_ty =
+ self.construct_transformed_self_ty_for_object(
+ did, &rcvr_substs, m);
+ let m = @Method {
+ transformed_self_ty: Some(transformed_self_ty),
+ .. (*m).clone()
+ };
+
+ Candidate {
+ rcvr_match_condition: RcvrMatchesIfObject(did),
+ rcvr_substs: trait_ref.substs.clone(),
+ method_ty: m,
+ origin: method_object(method_object {
+ trait_id: trait_ref.def_id,
+ object_trait_id: did,
+ method_num: method_num,
+ real_index: vtable_index
+ })
+ }
+ };
}
fn push_inherent_candidates_from_param(&self,
- rcvr_ty: ty::t,
- param_ty: param_ty) {
+ rcvr_ty: ty::t,
+ param_ty: param_ty) {
debug!("push_inherent_candidates_from_param(param_ty=%?)",
param_ty);
let _indenter = indenter();
}
fn push_inherent_candidates_from_bounds(&self,
- self_ty: ty::t,
- bounds: &[@TraitRef],
- param: param_index) {
+ self_ty: ty::t,
+ bounds: &[@TraitRef],
+ param: param_index) {
+ do self.push_inherent_candidates_from_bounds_inner(bounds)
+ |trait_ref, m, method_num, bound_num| {
+ Candidate {
+ rcvr_match_condition: RcvrMatchesIfSubtype(self_ty),
+ rcvr_substs: trait_ref.substs.clone(),
+ method_ty: m,
+ origin: method_param(
+ method_param {
+ trait_id: trait_ref.def_id,
+ method_num: method_num,
+ param_num: param,
+ bound_num: bound_num,
+ })
+ }
+ }
+ }
+
+ // Do a search through a list of bounds, using a callback to actually
+ // create the candidates.
+ fn push_inherent_candidates_from_bounds_inner(
+ &self,
+ bounds: &[@TraitRef],
+ mk_cand: &fn(trait_ref: @TraitRef, m: @ty::Method, method_num: uint,
+ bound_num: uint) -> Candidate) {
+
let tcx = self.tcx();
let mut next_bound_idx = 0; // count only trait bounds
Some(pos) => {
let method = trait_methods[pos];
- let cand = Candidate {
- rcvr_match_condition: RcvrMatchesIfSubtype(self_ty),
- rcvr_substs: bound_trait_ref.substs.clone(),
- method_ty: method,
- origin: method_param(
- method_param {
- trait_id: bound_trait_ref.def_id,
- method_num: pos,
- param_num: param,
- bound_num: this_bound_idx,
- })
- };
+ let cand = mk_cand(bound_trait_ref, method,
+ pos, this_bound_idx);
debug!("pushing inherent candidate for param: %?", cand);
self.inherent_candidates.push(cand);
fn confirm_candidate(&self, rcvr_ty: ty::t, candidate: &Candidate)
-> method_map_entry {
let tcx = self.tcx();
- let fty = self.fn_ty_from_origin(&candidate.origin);
+ let fty = ty::mk_bare_fn(tcx, candidate.method_ty.fty.clone());
debug!("confirm_candidate(expr=%s, candidate=%s, fty=%s)",
self.expr.repr(tcx),
// static methods should never have gotten this far:
assert!(candidate.method_ty.explicit_self != sty_static);
-
- let transformed_self_ty = match candidate.origin {
- method_trait(trait_def_id, _) => {
- self.construct_transformed_self_ty_for_object(
- trait_def_id, candidate)
- }
- _ => {
- let t = candidate.method_ty.transformed_self_ty.unwrap();
- ty::subst(tcx, &candidate.rcvr_substs, t)
- }
- };
+ let transformed_self_ty =
+ ty::subst(tcx, &candidate.rcvr_substs,
+ candidate.method_ty.transformed_self_ty.unwrap());
// Determine the values for the type parameters of the method.
// If they were not explicitly supplied, just construct fresh
}
}
- fn construct_transformed_self_ty_for_object(&self,
- trait_def_id: ast::def_id,
- candidate: &Candidate) -> ty::t
+ fn construct_transformed_self_ty_for_object(
+ &self,
+ trait_def_id: ast::def_id,
+ rcvr_substs: &ty::substs,
+ method_ty: &ty::Method) -> ty::t
{
/*!
* This is a bit tricky. We have a match against a trait method
* result to be `&'a Foo`. Assuming that `m_method` is being
* called, we want the result to be `@mut Foo`. Of course,
* this transformation has already been done as part of
- * `candidate.method_ty.transformed_self_ty`, but there the
+ * `method_ty.transformed_self_ty`, but there the
* type is expressed in terms of `Self` (i.e., `&'a Self`, `@mut Self`).
* Because objects are not standalone types, we can't just substitute
* `s/Self/Foo/`, so we must instead perform this kind of hokey
* match below.
*/
- let substs = ty::substs {regions: candidate.rcvr_substs.regions.clone(),
+ let substs = ty::substs {regions: rcvr_substs.regions.clone(),
self_ty: None,
- tps: candidate.rcvr_substs.tps.clone()};
- match candidate.method_ty.explicit_self {
+ tps: rcvr_substs.tps.clone()};
+ match method_ty.explicit_self {
ast::sty_static => {
self.bug(~"static method for object type receiver");
}
}
ast::sty_region(*) | ast::sty_box(*) | ast::sty_uniq(*) => {
let transformed_self_ty =
- candidate.method_ty.transformed_self_ty.clone().unwrap();
+ method_ty.transformed_self_ty.clone().unwrap();
match ty::get(transformed_self_ty).sty {
ty::ty_rptr(r, mt) => { // must be sty_region
ty::mk_trait(self.tcx(), trait_def_id,
method_static(*) | method_param(*) => {
return; // not a call to a trait instance
}
- method_trait(*) => {}
+ method_object(*) => {}
}
match candidate.method_ty.explicit_self {
// XXX: does this properly enforce this on everything now
// that self has been merged in? -sully
method_param(method_param { trait_id: trait_id, _ }) |
- method_trait(trait_id, _) => {
+ method_object(method_object { trait_id: trait_id, _ }) => {
bad = self.tcx().destructor_for_type.contains_key(&trait_id);
}
}
}
}
- fn fn_ty_from_origin(&self, origin: &method_origin) -> ty::t {
- return match *origin {
- method_static(did) => {
- ty::lookup_item_type(self.tcx(), did).ty
- }
- method_param(ref mp) => {
- type_of_trait_method(self.tcx(), mp.trait_id, mp.method_num)
- }
- method_trait(did, idx) => {
- type_of_trait_method(self.tcx(), did, idx)
- }
- };
-
- fn type_of_trait_method(tcx: ty::ctxt,
- trait_did: def_id,
- method_num: uint) -> ty::t {
- let trait_methods = ty::trait_methods(tcx, trait_did);
- ty::mk_bare_fn(tcx, trait_methods[method_num].fty.clone())
- }
- }
-
fn report_candidate(&self, idx: uint, origin: &method_origin) {
match *origin {
method_static(impl_did) => {
method_param(ref mp) => {
self.report_param_candidate(idx, (*mp).trait_id)
}
- method_trait(trait_did, _) => {
- self.report_trait_candidate(idx, trait_did)
+ method_object(ref mo) => {
+ self.report_trait_candidate(idx, mo.trait_id)
}
}
}
use syntax::parse::token;
use syntax::parse::token::special_idents;
use syntax::print::pprust;
-use syntax::oldvisit;
+use syntax::visit;
+use syntax::visit::Visitor;
use syntax;
pub mod _match;
}
}
+struct CheckItemTypesVisitor { ccx: @mut CrateCtxt }
+
+impl Visitor<()> for CheckItemTypesVisitor {
+ fn visit_item(&mut self, i:@ast::item, _:()) {
+ check_item(self.ccx, i);
+ visit::walk_item(self, i, ());
+ }
+}
+
pub fn check_item_types(ccx: @mut CrateCtxt, crate: &ast::Crate) {
- let visit = oldvisit::mk_simple_visitor(@oldvisit::SimpleVisitor {
- visit_item: |a| check_item(ccx, a),
- .. *oldvisit::default_simple_visitor()
- });
- oldvisit::visit_crate(crate, ((), visit));
+ let mut visit = CheckItemTypesVisitor { ccx: ccx };
+ visit::walk_crate(&mut visit, crate, ());
}
pub fn check_bare_fn(ccx: @mut CrateCtxt,
}
}
+struct GatherLocalsVisitor {
+ fcx: @mut FnCtxt,
+ tcx: ty::ctxt,
+}
+
+impl GatherLocalsVisitor {
+ fn assign(&mut self, nid: ast::NodeId, ty_opt: Option<ty::t>) {
+ match ty_opt {
+ None => {
+ // infer the variable's type
+ let var_id = self.fcx.infcx().next_ty_var_id();
+ let var_ty = ty::mk_var(self.fcx.tcx(), var_id);
+ self.fcx.inh.locals.insert(nid, var_ty);
+ }
+ Some(typ) => {
+ // take type that the user specified
+ self.fcx.inh.locals.insert(nid, typ);
+ }
+ }
+ }
+}
+
+impl Visitor<()> for GatherLocalsVisitor {
+ // Add explicitly-declared locals.
+ fn visit_local(&mut self, local:@ast::Local, _:()) {
+ let o_ty = match local.ty.node {
+ ast::ty_infer => None,
+ _ => Some(self.fcx.to_ty(&local.ty))
+ };
+ self.assign(local.id, o_ty);
+ debug!("Local variable %s is assigned type %s",
+ self.fcx.pat_to_str(local.pat),
+ self.fcx.infcx().ty_to_str(
+ self.fcx.inh.locals.get_copy(&local.id)));
+ visit::walk_local(self, local, ());
+
+ }
+ // Add pattern bindings.
+ fn visit_pat(&mut self, p:@ast::pat, _:()) {
+ match p.node {
+ ast::pat_ident(_, ref path, _)
+ if pat_util::pat_is_binding(self.fcx.ccx.tcx.def_map, p) => {
+ self.assign(p.id, None);
+ debug!("Pattern binding %s is assigned to %s",
+ self.tcx.sess.str_of(path.idents[0]),
+ self.fcx.infcx().ty_to_str(
+ self.fcx.inh.locals.get_copy(&p.id)));
+ }
+ _ => {}
+ }
+ visit::walk_pat(self, p, ());
+
+ }
+
+ fn visit_block(&mut self, b:&ast::Block, _:()) {
+ // non-obvious: the `blk` variable maps to region lb, so
+ // we have to keep this up-to-date. This
+ // is... unfortunate. It'd be nice to not need this.
+ do self.fcx.with_region_lb(b.id) {
+ visit::walk_block(self, b, ());
+ }
+ }
+
+ // Don't descend into fns and items
+ fn visit_fn(&mut self, _:&visit::fn_kind, _:&ast::fn_decl,
+ _:&ast::Block, _:span, _:ast::NodeId, _:()) { }
+ fn visit_item(&mut self, _:@ast::item, _:()) { }
+
+}
+
pub fn check_fn(ccx: @mut CrateCtxt,
opt_self_info: Option<SelfInfo>,
purity: ast::purity,
opt_self_info: Option<SelfInfo>) {
let tcx = fcx.ccx.tcx;
- let assign: @fn(ast::NodeId, Option<ty::t>) = |nid, ty_opt| {
- match ty_opt {
- None => {
- // infer the variable's type
- let var_id = fcx.infcx().next_ty_var_id();
- let var_ty = ty::mk_var(fcx.tcx(), var_id);
- fcx.inh.locals.insert(nid, var_ty);
- }
- Some(typ) => {
- // take type that the user specified
- fcx.inh.locals.insert(nid, typ);
- }
- }
- };
+ let mut visit = GatherLocalsVisitor { fcx: fcx, tcx: tcx, };
// Add the self parameter
for self_info in opt_self_info.iter() {
- assign(self_info.self_id, Some(self_info.self_ty));
+ visit.assign(self_info.self_id, Some(self_info.self_ty));
debug!("self is assigned to %s",
fcx.infcx().ty_to_str(
fcx.inh.locals.get_copy(&self_info.self_id)));
// Create type variables for each argument.
do pat_util::pat_bindings(tcx.def_map, input.pat)
|_bm, pat_id, _sp, _path| {
- assign(pat_id, None);
+ visit.assign(pat_id, None);
}
// Check the pattern.
_match::check_pat(&pcx, input.pat, *arg_ty);
}
- // Add explicitly-declared locals.
- let visit_local: @fn(@ast::Local, ((), oldvisit::vt<()>)) =
- |local, (e, v)| {
- let o_ty = match local.ty.node {
- ast::ty_infer => None,
- _ => Some(fcx.to_ty(&local.ty))
- };
- assign(local.id, o_ty);
- debug!("Local variable %s is assigned type %s",
- fcx.pat_to_str(local.pat),
- fcx.infcx().ty_to_str(
- fcx.inh.locals.get_copy(&local.id)));
- oldvisit::visit_local(local, (e, v));
- };
-
- // Add pattern bindings.
- let visit_pat: @fn(@ast::pat, ((), oldvisit::vt<()>)) = |p, (e, v)| {
- match p.node {
- ast::pat_ident(_, ref path, _)
- if pat_util::pat_is_binding(fcx.ccx.tcx.def_map, p) => {
- assign(p.id, None);
- debug!("Pattern binding %s is assigned to %s",
- tcx.sess.str_of(path.idents[0]),
- fcx.infcx().ty_to_str(
- fcx.inh.locals.get_copy(&p.id)));
- }
- _ => {}
- }
- oldvisit::visit_pat(p, (e, v));
- };
-
- let visit_block:
- @fn(&ast::Block, ((), oldvisit::vt<()>)) = |b, (e, v)| {
- // non-obvious: the `blk` variable maps to region lb, so
- // we have to keep this up-to-date. This
- // is... unfortunate. It'd be nice to not need this.
- do fcx.with_region_lb(b.id) {
- oldvisit::visit_block(b, (e, v));
- }
- };
-
- // Don't descend into fns and items
- fn visit_fn(_fk: &oldvisit::fn_kind,
- _decl: &ast::fn_decl,
- _body: &ast::Block,
- _sp: span,
- _id: ast::NodeId,
- (_t,_v): ((), oldvisit::vt<()>)) {
- }
- fn visit_item(_i: @ast::item, (_e,_v): ((), oldvisit::vt<()>)) { }
-
- let visit = oldvisit::mk_vt(
- @oldvisit::Visitor {visit_local: visit_local,
- visit_pat: visit_pat,
- visit_fn: visit_fn,
- visit_item: visit_item,
- visit_block: visit_block,
- ..*oldvisit::default_visitor()});
-
- (visit.visit_block)(body, ((), visit));
+ visit.visit_block(body, ());
}
}
if ty::type_is_error(e) || ty::type_is_error(a) {
return;
}
- match self.fn_kind {
- DoBlock if ty::type_is_bool(e) && ty::type_is_nil(a) =>
- // If we expected bool and got ()...
- self.tcx().sess.span_err(sp, fmt!("Do-block body must \
- return %s, but returns () here. Perhaps you meant \
- to write a `for`-loop?",
- ppaux::ty_to_str(self.tcx(), e))),
- _ => self.infcx().report_mismatched_types(sp, e, a, err)
- }
+ self.infcx().report_mismatched_types(sp, e, a, err)
}
pub fn report_mismatched_types(&self,
use syntax::ast::{def_arg, def_binding, def_local, def_self, def_upvar};
use syntax::ast;
use syntax::codemap::span;
-use syntax::oldvisit;
+use syntax::visit;
+use syntax::visit::Visitor;
pub struct Rcx {
fcx: @mut FnCtxt,
repeating_scope: ast::NodeId,
}
-pub type rvt = oldvisit::vt<@mut Rcx>;
-
fn encl_region_of_def(fcx: @mut FnCtxt, def: ast::def) -> ty::Region {
let tcx = fcx.tcx();
match def {
repeating_scope: e.id };
if fcx.err_count_since_creation() == 0 {
// regionck assumes typeck succeeded
- let v = regionck_visitor();
- (v.visit_expr)(e, (rcx, v));
+ let mut v = regionck_visitor();
+ v.visit_expr(e, rcx);
}
fcx.infcx().resolve_regions();
}
repeating_scope: blk.id };
if fcx.err_count_since_creation() == 0 {
// regionck assumes typeck succeeded
- let v = regionck_visitor();
- (v.visit_block)(blk, (rcx, v));
+ let mut v = regionck_visitor();
+ v.visit_block(blk, rcx);
}
fcx.infcx().resolve_regions();
}
-fn regionck_visitor() -> rvt {
+struct RegionckVisitor;
+
+impl Visitor<@mut Rcx> for RegionckVisitor {
// (*) FIXME(#3238) should use visit_pat, not visit_arm/visit_local,
// However, right now we run into an issue whereby some free
// regions are not properly related if they appear within the
// addressed by deferring the construction of the region
// hierarchy, and in particular the relationships between free
// regions, until regionck, as described in #3238.
- oldvisit::mk_vt(@oldvisit::Visitor {
- visit_item: visit_item,
- visit_expr: visit_expr,
+
+ fn visit_item(&mut self, i:@ast::item, e:@mut Rcx) { visit_item(self, i, e); }
+
+ fn visit_expr(&mut self, ex:@ast::expr, e:@mut Rcx) { visit_expr(self, ex, e); }
//visit_pat: visit_pat, // (*) see above
- visit_arm: visit_arm,
- visit_local: visit_local,
- visit_block: visit_block,
- .. *oldvisit::default_visitor()
- })
+ fn visit_arm(&mut self, a:&ast::arm, e:@mut Rcx) { visit_arm(self, a, e); }
+
+ fn visit_local(&mut self, l:@ast::Local, e:@mut Rcx) { visit_local(self, l, e); }
+
+ fn visit_block(&mut self, b:&ast::Block, e:@mut Rcx) { visit_block(self, b, e); }
+}
+
+fn regionck_visitor() -> RegionckVisitor {
+ RegionckVisitor
}
-fn visit_item(_item: @ast::item, (_rcx, _v): (@mut Rcx, rvt)) {
+fn visit_item(_v: &mut RegionckVisitor, _item: @ast::item, _rcx: @mut Rcx) {
// Ignore items
}
-fn visit_block(b: &ast::Block, (rcx, v): (@mut Rcx, rvt)) {
+fn visit_block(v: &mut RegionckVisitor, b: &ast::Block, rcx: @mut Rcx) {
rcx.fcx.tcx().region_maps.record_cleanup_scope(b.id);
- oldvisit::visit_block(b, (rcx, v));
+ visit::walk_block(v, b, rcx);
}
-fn visit_arm(arm: &ast::arm, (rcx, v): (@mut Rcx, rvt)) {
+fn visit_arm(v: &mut RegionckVisitor, arm: &ast::arm, rcx: @mut Rcx) {
// see above
for &p in arm.pats.iter() {
constrain_bindings_in_pat(p, rcx);
}
- oldvisit::visit_arm(arm, (rcx, v));
+ visit::walk_arm(v, arm, rcx);
}
-fn visit_local(l: @ast::Local, (rcx, v): (@mut Rcx, rvt)) {
+fn visit_local(v: &mut RegionckVisitor, l: @ast::Local, rcx: @mut Rcx) {
// see above
constrain_bindings_in_pat(l.pat, rcx);
- oldvisit::visit_local(l, (rcx, v));
+ visit::walk_local(v, l, rcx);
}
fn constrain_bindings_in_pat(pat: @ast::pat, rcx: @mut Rcx) {
}
}
-fn visit_expr(expr: @ast::expr, (rcx, v): (@mut Rcx, rvt)) {
+fn visit_expr(v: &mut RegionckVisitor, expr: @ast::expr, rcx: @mut Rcx) {
debug!("regionck::visit_expr(e=%s, repeating_scope=%?)",
expr.repr(rcx.fcx.tcx()), rcx.repeating_scope);
constrain_callee(rcx, callee.id, expr, callee);
constrain_call(rcx, callee.id, expr, None, *args, false);
- oldvisit::visit_expr(expr, (rcx, v));
+ visit::walk_expr(v, expr, rcx);
}
ast::expr_method_call(callee_id, arg0, _, _, ref args, _) => {
constrain_call(rcx, callee_id, expr, Some(arg0), *args, false);
- oldvisit::visit_expr(expr, (rcx, v));
+ visit::walk_expr(v,expr, rcx);
}
ast::expr_index(callee_id, lhs, rhs) |
// should be converted to an adjustment!
constrain_call(rcx, callee_id, expr, Some(lhs), [rhs], true);
- oldvisit::visit_expr(expr, (rcx, v));
+ visit::walk_expr(v, expr, rcx);
}
ast::expr_unary(callee_id, _, lhs) if has_method_map => {
// As above.
constrain_call(rcx, callee_id, expr, Some(lhs), [], true);
- oldvisit::visit_expr(expr, (rcx, v));
+ visit::walk_expr(v, expr, rcx);
}
ast::expr_unary(_, ast::deref, base) => {
let base_ty = rcx.resolve_node_type(base.id);
constrain_derefs(rcx, expr, 1, base_ty);
- oldvisit::visit_expr(expr, (rcx, v));
+ visit::walk_expr(v, expr, rcx);
}
ast::expr_index(_, vec_expr, _) => {
let vec_type = rcx.resolve_expr_type_adjusted(vec_expr);
constrain_index(rcx, expr, vec_type);
- oldvisit::visit_expr(expr, (rcx, v));
+ visit::walk_expr(v, expr, rcx);
}
ast::expr_cast(source, _) => {
_ => ()
}
- oldvisit::visit_expr(expr, (rcx, v));
+ visit::walk_expr(v, expr, rcx);
}
ast::expr_addr_of(_, base) => {
let ty0 = rcx.resolve_node_type(expr.id);
constrain_regions_in_type(rcx, ty::re_scope(expr.id),
infer::AddrOf(expr.span), ty0);
- oldvisit::visit_expr(expr, (rcx, v));
+ visit::walk_expr(v, expr, rcx);
}
ast::expr_match(discr, ref arms) => {
guarantor::for_match(rcx, discr, *arms);
- oldvisit::visit_expr(expr, (rcx, v));
+ visit::walk_expr(v, expr, rcx);
}
ast::expr_fn_block(*) => {
ast::expr_loop(ref body, _) => {
let repeating_scope = rcx.set_repeating_scope(body.id);
- oldvisit::visit_expr(expr, (rcx, v));
+ visit::walk_expr(v, expr, rcx);
rcx.set_repeating_scope(repeating_scope);
}
ast::expr_while(cond, ref body) => {
let repeating_scope = rcx.set_repeating_scope(cond.id);
- (v.visit_expr)(cond, (rcx, v));
+ v.visit_expr(cond, rcx);
rcx.set_repeating_scope(body.id);
- (v.visit_block)(body, (rcx, v));
+ v.visit_block(body, rcx);
rcx.set_repeating_scope(repeating_scope);
}
_ => {
- oldvisit::visit_expr(expr, (rcx, v));
+ visit::walk_expr(v, expr, rcx);
}
}
}
fn check_expr_fn_block(rcx: @mut Rcx,
expr: @ast::expr,
- v: rvt) {
+ v: &mut RegionckVisitor) {
let tcx = rcx.fcx.tcx();
match expr.node {
ast::expr_fn_block(_, ref body) => {
}
let repeating_scope = rcx.set_repeating_scope(body.id);
- oldvisit::visit_expr(expr, (rcx, v));
+ visit::walk_expr(v, expr, rcx);
rcx.set_repeating_scope(repeating_scope);
}
self_ty: Some(mt.ty)
}
};
- let vtable_opt =
- lookup_vtable(&vcx,
- location_info,
- mt.ty,
- target_trait_ref,
- is_early);
- match vtable_opt {
- Some(vtable) => {
- // Map this expression to that
- // vtable (that is: "ex has vtable
- // <vtable>")
- if !is_early {
- insert_vtables(fcx, ex.id,
- @~[@~[vtable]]);
- }
- }
- None => {
- fcx.tcx().sess.span_err(
- ex.span,
- fmt!("failed to find an implementation \
- of trait %s for %s",
- fcx.infcx().ty_to_str(target_ty),
- fcx.infcx().ty_to_str(mt.ty)));
- }
+
+ let param_bounds = ty::ParamBounds {
+ builtin_bounds: ty::EmptyBuiltinBounds(),
+ trait_bounds: ~[target_trait_ref]
+ };
+ let vtables =
+ lookup_vtables_for_param(&vcx,
+ location_info,
+ None,
+ ¶m_bounds,
+ mt.ty,
+ is_early);
+
+ if !is_early {
+ insert_vtables(fcx, ex.id, @~[vtables]);
}
// Now, if this is &trait, we need to link the
use syntax::ast_util::{def_id_of_def, local_def};
use syntax::codemap::{span, dummy_sp};
use syntax::opt_vec;
-use syntax::oldvisit::{default_simple_visitor, default_visitor};
-use syntax::oldvisit::{mk_simple_visitor, mk_vt, visit_crate, visit_item};
-use syntax::oldvisit::{Visitor, SimpleVisitor};
-use syntax::oldvisit::{visit_mod};
+use syntax::visit;
use syntax::parse;
use util::ppaux::ty_to_str;
base_type_def_ids: @mut HashMap<def_id,def_id>,
}
-impl CoherenceChecker {
- pub fn check_coherence(self, crate: &Crate) {
- // Check implementations and traits. This populates the tables
- // containing the inherent methods and extension methods. It also
- // builds up the trait inheritance table.
- visit_crate(crate, ((), mk_simple_visitor(@SimpleVisitor {
- visit_item: |item| {
+struct CoherenceCheckVisitor { cc: CoherenceChecker }
+
+impl visit::Visitor<()> for CoherenceCheckVisitor {
+ fn visit_item(&mut self, item:@item, _:()) {
+
// debug!("(checking coherence) item '%s'",
-// self.crate_context.tcx.sess.str_of(item.ident));
+// self.cc.crate_context.tcx.sess.str_of(item.ident));
match item.node {
item_impl(_, ref opt_trait, _, _) => {
opt_trait.iter()
.map(|x| (*x).clone())
.collect();
- self.check_implementation(item, opt_trait);
+ self.cc.check_implementation(item, opt_trait);
}
_ => {
// Nothing to do.
}
};
- },
- .. *default_simple_visitor()
- })));
+
+ visit::walk_item(self, item, ());
+ }
+}
+
+struct PrivilegedScopeVisitor { cc: CoherenceChecker }
+
+impl visit::Visitor<()> for PrivilegedScopeVisitor {
+ fn visit_item(&mut self, item:@item, _:()) {
+
+ match item.node {
+ item_mod(ref module_) => {
+ // Then visit the module items.
+ visit::walk_mod(self, module_, ());
+ }
+ item_impl(_, None, ref ast_ty, _) => {
+ if !self.cc.ast_type_is_defined_in_local_crate(ast_ty) {
+ // This is an error.
+ let session = self.cc.crate_context.tcx.sess;
+ session.span_err(item.span,
+ "cannot associate methods with a type outside the \
+ crate the type is defined in; define and implement \
+ a trait or new type instead");
+ }
+ }
+ item_impl(_, Some(ref trait_ref), _, _) => {
+ // `for_ty` is `Type` in `impl Trait for Type`
+ let for_ty =
+ ty::node_id_to_type(self.cc.crate_context.tcx,
+ item.id);
+ if !type_is_defined_in_local_crate(for_ty) {
+ // This implementation is not in scope of its base
+ // type. This still might be OK if the trait is
+ // defined in the same crate.
+
+ let trait_def_id =
+ self.cc.trait_ref_to_trait_def_id(trait_ref);
+
+ if trait_def_id.crate != LOCAL_CRATE {
+ let session = self.cc.crate_context.tcx.sess;
+ session.span_err(item.span,
+ "cannot provide an extension implementation \
+ for a trait not defined in this crate");
+ }
+ }
+
+ visit::walk_item(self, item, ());
+ }
+ _ => {
+ visit::walk_item(self, item, ());
+ }
+ }
+ }
+}
+
+impl CoherenceChecker {
+ pub fn check_coherence(self, crate: &Crate) {
+ // Check implementations and traits. This populates the tables
+ // containing the inherent methods and extension methods. It also
+ // builds up the trait inheritance table.
+
+ let mut visitor = CoherenceCheckVisitor { cc: self };
+ visit::walk_crate(&mut visitor, crate, ());
// Check that there are no overlapping trait instances
self.check_implementation_coherence();
// Privileged scope checking
pub fn check_privileged_scopes(self, crate: &Crate) {
- visit_crate(crate, ((), mk_vt(@Visitor {
- visit_item: |item, (_context, visitor)| {
- match item.node {
- item_mod(ref module_) => {
- // Then visit the module items.
- visit_mod(module_, item.span, item.id, ((), visitor));
- }
- item_impl(_, None, ref ast_ty, _) => {
- if !self.ast_type_is_defined_in_local_crate(ast_ty) {
- // This is an error.
- let session = self.crate_context.tcx.sess;
- session.span_err(item.span,
- "cannot associate methods with a type outside the \
- crate the type is defined in; define and implement \
- a trait or new type instead");
- }
- }
- item_impl(_, Some(ref trait_ref), _, _) => {
- // `for_ty` is `Type` in `impl Trait for Type`
- let for_ty =
- ty::node_id_to_type(self.crate_context.tcx,
- item.id);
- if !type_is_defined_in_local_crate(for_ty) {
- // This implementation is not in scope of its base
- // type. This still might be OK if the trait is
- // defined in the same crate.
-
- let trait_def_id =
- self.trait_ref_to_trait_def_id(trait_ref);
-
- if trait_def_id.crate != LOCAL_CRATE {
- let session = self.crate_context.tcx.sess;
- session.span_err(item.span,
- "cannot provide an extension implementation \
- for a trait not defined in this crate");
- }
- }
-
- visit_item(item, ((), visitor));
- }
- _ => {
- visit_item(item, ((), visitor));
- }
- }
- },
- .. *default_visitor()
- })));
+ let mut visitor = PrivilegedScopeVisitor{ cc: self };
+ visit::walk_crate(&mut visitor, crate, ());
}
pub fn trait_ref_to_trait_def_id(&self, trait_ref: &trait_ref) -> def_id {
use syntax::codemap::span;
use syntax::codemap;
use syntax::print::pprust::{path_to_str, explicit_self_to_str};
-use syntax::oldvisit;
+use syntax::visit;
use syntax::opt_vec::OptVec;
use syntax::opt_vec;
use syntax::parse::token::special_idents;
+struct CollectItemTypesVisitor {
+ ccx: @mut CrateCtxt
+}
+
+impl visit::Visitor<()> for CollectItemTypesVisitor {
+ fn visit_item(&mut self, i:@ast::item, _:()) {
+ convert(self.ccx, i);
+ visit::walk_item(self, i, ());
+ }
+ fn visit_foreign_item(&mut self, i:@ast::foreign_item, _:()) {
+ convert_foreign(self.ccx, i);
+ visit::walk_foreign_item(self, i, ());
+ }
+}
+
pub fn collect_item_types(ccx: @mut CrateCtxt, crate: &ast::Crate) {
fn collect_intrinsic_type(ccx: &CrateCtxt,
lang_item: ast::def_id) {
Some(id) => { collect_intrinsic_type(ccx, id); } None => {}
}
- oldvisit::visit_crate(
- crate, ((),
- oldvisit::mk_simple_visitor(@oldvisit::SimpleVisitor {
- visit_item: |a| convert(ccx, a),
- visit_foreign_item: |a|convert_foreign(ccx, a),
- .. *oldvisit::default_simple_visitor()
- })));
+ let mut visitor = CollectItemTypesVisitor{ ccx: ccx };
+ visit::walk_crate(&mut visitor, crate, ());
}
pub trait ToTy {
sp: codemap::span,
rp: Option<ty::region_variance>,
ast_trait_refs: &[ast::trait_ref],
- generics: &ast::Generics)
+ generics: &ast::Generics) -> ty::BuiltinBounds
{
let tcx = ccx.tcx;
- if tcx.supertraits.contains_key(&local_def(id)) { return; }
+
+ // Called only the first time trait_def_of_item is called.
+ // Supertraits are ensured at the same time.
+ assert!(!tcx.supertraits.contains_key(&local_def(id)));
let self_ty = ty::mk_self(ccx.tcx, local_def(id));
let mut ty_trait_refs: ~[@ty::TraitRef] = ~[];
+ let mut bounds = ty::EmptyBuiltinBounds();
for ast_trait_ref in ast_trait_refs.iter() {
+ let trait_def_id = ty::trait_ref_to_def_id(ccx.tcx, ast_trait_ref);
+ // FIXME(#8559): Need to instantiate the trait_ref whether or not it's a
+ // builtin trait, so that the trait's node id appears in the tcx trait_ref
+ // map. This is only needed for metadata; see the similar fixme in encoder.rs.
let trait_ref = instantiate_trait_ref(ccx, ast_trait_ref, rp,
generics, self_ty);
-
- // FIXME(#5527) Could have same trait multiple times
- if ty_trait_refs.iter().any(|other_trait| other_trait.def_id == trait_ref.def_id) {
- // This means a trait inherited from the same supertrait more
- // than once.
- tcx.sess.span_err(sp, "Duplicate supertrait in trait declaration");
- break;
- } else {
- ty_trait_refs.push(trait_ref);
+ if !ty::try_add_builtin_trait(ccx.tcx, trait_def_id, &mut bounds) {
+
+ // FIXME(#5527) Could have same trait multiple times
+ if ty_trait_refs.iter().any(|other_trait| other_trait.def_id == trait_ref.def_id) {
+ // This means a trait inherited from the same supertrait more
+ // than once.
+ tcx.sess.span_err(sp, "Duplicate supertrait in trait declaration");
+ break;
+ } else {
+ ty_trait_refs.push(trait_ref);
+ }
}
}
tcx.supertraits.insert(local_def(id), @ty_trait_refs);
+ bounds
}
/**
&i_ty_generics, generics,
parent_visibility);
for t in opt_trait_ref.iter() {
+ // Prevent the builtin kind traits from being manually implemented.
+ let trait_def_id = ty::trait_ref_to_def_id(tcx, t);
+ if tcx.lang_items.to_builtin_kind(trait_def_id).is_some() {
+ tcx.sess.span_err(it.span,
+ "cannot provide an explicit implementation \
+ for a builtin kind");
+ }
+
check_methods_against_trait(ccx, generics, rp, selfty, t, cms);
}
}
- ast::item_trait(ref generics, ref supertraits, ref trait_methods) => {
- let trait_def = trait_def_of_item(ccx, it);
- tcx.trait_defs.insert(local_def(it.id), trait_def);
+ ast::item_trait(ref generics, _, ref trait_methods) => {
+ let _trait_def = trait_def_of_item(ccx, it);
ensure_trait_methods(ccx, it.id);
- ensure_supertraits(ccx, it.id, it.span, rp, *supertraits, generics);
let (_, provided_methods) =
split_trait_methods(*trait_methods);
}
let rp = tcx.region_paramd_items.find(&it.id).map_move(|x| *x);
match it.node {
- ast::item_trait(ref generics, _, _) => {
+ ast::item_trait(ref generics, ref supertraits, _) => {
let self_ty = ty::mk_self(tcx, def_id);
let (ty_generics, substs) = mk_item_substs(ccx, generics, rp,
Some(self_ty));
+ let bounds = ensure_supertraits(ccx, it.id, it.span, rp,
+ *supertraits, generics);
let trait_ref = @ty::TraitRef {def_id: def_id,
substs: substs};
let trait_def = @ty::TraitDef {generics: ty_generics,
+ bounds: bounds,
trait_ref: trait_ref};
tcx.trait_defs.insert(def_id, trait_def);
return trait_def;
TraitTyParamBound(ref b) => {
let ty = ty::mk_param(ccx.tcx, param_ty.idx, param_ty.def_id);
let trait_ref = instantiate_trait_ref(ccx, b, rp, generics, ty);
- if !astconv::try_add_builtin_trait(
+ if !ty::try_add_builtin_trait(
ccx.tcx, trait_ref.def_id,
&mut param_bounds.builtin_bounds)
{
use middle::typeck::infer::unify::{Redirect, Root, VarValue};
use util::ppaux::{mt_to_str, ty_to_str, trait_ref_to_str};
-use std::uint;
use syntax::ast;
pub trait InferStr {
match *self {
Redirect(ref vid) => fmt!("Redirect(%s)", vid.to_str()),
Root(ref pt, rk) => fmt!("Root(%s, %s)", pt.inf_str(cx),
- uint::to_str_radix(rk, 10u))
+ rk.to_str_radix(10u))
}
}
}
method_param(method_param),
// method invoked on a trait instance
- method_trait(ast::def_id, uint),
+ method_object(method_object),
}
bound_num: uint,
}
+// details for a method invoked with a receiver whose type is an object
+#[deriving(Clone, Encodable, Decodable)]
+pub struct method_object {
+ // the (super)trait containing the method to be invoked
+ trait_id: ast::def_id,
+
+ // the actual base trait id of the object
+ object_trait_id: ast::def_id,
+
+ // index of the method to be invoked amongst the trait's methods
+ method_num: uint,
+
+ // index into the actual runtime vtable.
+ // the vtable is formed by concatenating together the method lists of
+ // the base object trait and all supertraits; this is the index into
+ // that vtable
+ real_index: uint,
+}
+
+
#[deriving(Clone)]
pub struct method_map_entry {
// the type of the self parameter, which is not reflected in the fn type
#[license = "MIT/ASL2"];
#[crate_type = "lib"];
+// Rustc tasks always run on a fixed_stack_segment, so code in this
+// module can call C functions (in particular, LLVM functions) with
+// impunity.
+#[allow(cstack)];
+
extern mod extra;
extern mod syntax;
pub mod reachable;
pub mod graph;
pub mod cfg;
+ pub mod stack_check;
}
pub mod front {
use syntax::ast;
use syntax::codemap::{span};
-use syntax::oldvisit;
+use syntax::visit;
+use syntax::visit::Visitor;
use std::hashmap::HashSet;
use extra;
fields.map(|f| f.expr)
}
-// Takes a predicate p, returns true iff p is true for any subexpressions
-// of b -- skipping any inner loops (loop, while, loop_body)
-pub fn loop_query(b: &ast::Block, p: @fn(&ast::expr_) -> bool) -> bool {
- let rs = @mut false;
- let visit_expr: @fn(@ast::expr,
- (@mut bool,
- oldvisit::vt<@mut bool>)) = |e, (flag, v)| {
- *flag |= p(&e.node);
+struct LoopQueryVisitor {
+ p: @fn(&ast::expr_) -> bool
+}
+
+impl Visitor<@mut bool> for LoopQueryVisitor {
+ fn visit_expr(&mut self, e:@ast::expr, flag:@mut bool) {
+ *flag |= (self.p)(&e.node);
match e.node {
// Skip inner loops, since a break in the inner loop isn't a
// break inside the outer loop
ast::expr_loop(*) | ast::expr_while(*) => {}
- _ => oldvisit::visit_expr(e, (flag, v))
+ _ => visit::walk_expr(self, e, flag)
}
- };
- let v = oldvisit::mk_vt(@oldvisit::Visitor {
- visit_expr: visit_expr,
- .. *oldvisit::default_visitor()});
- oldvisit::visit_block(b, (rs, v));
+ }
+}
+
+// Takes a predicate p, returns true iff p is true for any subexpressions
+// of b -- skipping any inner loops (loop, while, loop_body)
+pub fn loop_query(b: &ast::Block, p: @fn(&ast::expr_) -> bool) -> bool {
+ let rs = @mut false;
+ let mut v = LoopQueryVisitor { p: p };
+ visit::walk_block(&mut v, b, rs);
return *rs;
}
+struct BlockQueryVisitor {
+ p: @fn(@ast::expr) -> bool
+}
+
+impl Visitor<@mut bool> for BlockQueryVisitor {
+ fn visit_expr(&mut self, e:@ast::expr, flag:@mut bool) {
+ *flag |= (self.p)(e);
+ visit::walk_expr(self, e, flag)
+ }
+}
+
// Takes a predicate p, returns true iff p is true for any subexpressions
// of b -- skipping any inner loops (loop, while, loop_body)
pub fn block_query(b: &ast::Block, p: @fn(@ast::expr) -> bool) -> bool {
let rs = @mut false;
- let visit_expr: @fn(@ast::expr,
- (@mut bool,
- oldvisit::vt<@mut bool>)) = |e, (flag, v)| {
- *flag |= p(e);
- oldvisit::visit_expr(e, (flag, v))
- };
- let v = oldvisit::mk_vt(@oldvisit::Visitor{
- visit_expr: visit_expr,
- .. *oldvisit::default_visitor()});
- oldvisit::visit_block(b, (rs, v));
+ let mut v = BlockQueryVisitor { p: p };
+ visit::walk_block(&mut v, b, rs);
return *rs;
}
&typeck::method_param(ref p) => {
p.repr(tcx)
}
- &typeck::method_trait(def_id, n) => {
- fmt!("method_trait(%s, %?)", def_id.repr(tcx), n)
+ &typeck::method_object(ref p) => {
+ p.repr(tcx)
}
}
}
}
}
+impl Repr for typeck::method_object {
+ fn repr(&self, tcx: ctxt) -> ~str {
+ fmt!("method_object(%s,%?,%?)",
+ self.trait_id.repr(tcx),
+ self.method_num,
+ self.real_index)
+ }
+}
+
+
impl Repr for ty::RegionVid {
fn repr(&self, _tcx: ctxt) -> ~str {
fmt!("%?", *self)
ty_to_str(tcx, *self)
}
}
+
+impl Repr for AbiSet {
+ fn repr(&self, _tcx: ctxt) -> ~str {
+ self.to_str()
+ }
+}
+
+impl UserString for AbiSet {
+ fn user_string(&self, _tcx: ctxt) -> ~str {
+ self.to_str()
+ }
+}
}
pub fn main() {
+ #[fixed_stack_segment]; #[inline(never)];
+
let args = os::args();
let input = io::stdin();
let out = io::stdout();
use syntax::print::pp;
use syntax::print::pprust;
use syntax::parse::token;
+use syntax::visit;
-pub fn each_binding(l: @ast::Local, f: @fn(&ast::Path, ast::NodeId)) {
- use syntax::oldvisit;
+struct EachBindingVisitor {
+ f: @fn(&ast::Path, ast::NodeId)
+}
- let vt = oldvisit::mk_simple_visitor(
- @oldvisit::SimpleVisitor {
- visit_pat: |pat| {
+impl visit::Visitor<()> for EachBindingVisitor {
+ fn visit_pat(&mut self, pat:@ast::pat, _:()) {
match pat.node {
ast::pat_ident(_, ref path, _) => {
- f(path, pat.id);
+ (self.f)(path, pat.id);
}
_ => {}
}
- },
- .. *oldvisit::default_simple_visitor()
- }
- );
- (vt.visit_pat)(l.pat, ((), vt));
+
+ visit::walk_pat(self, pat, ());
+ }
+}
+
+pub fn each_binding(l: @ast::Local, f: @fn(&ast::Path, ast::NodeId)) {
+ use syntax::visit::Visitor;
+
+ let mut vt = EachBindingVisitor{ f: f };
+
+ vt.visit_pat(l.pat, ());
}
/// A utility function that hands off a pretty printer to a callback.
Some(p) => p.to_str()
}
}
+
+ // Hack so that rustpkg can run either out of a rustc target dir,
+ // or the host dir
+ pub fn sysroot_to_use(&self) -> Option<@Path> {
+ if !in_target(self.sysroot_opt) {
+ self.sysroot_opt
+ }
+ else {
+ self.sysroot_opt.map(|p| { @p.pop().pop().pop() })
+ }
+ }
}
/// We assume that if ../../rustc exists, then we're running
debug!("Pushing onto root: %s | %s", self.id.path.to_str(), self.root.to_str());
let dirs = pkgid_src_in_workspace(&self.id, &self.root);
- debug!("Checking dirs: %?", dirs);
+ debug!("Checking dirs: %?", dirs.map(|s| s.to_str()).connect(":"));
let path = dirs.iter().find(|&d| os::path_exists(d));
let dir = match path {
pub use package_id::PkgId;
pub use target::{OutputType, Main, Lib, Test, Bench, Target, Build, Install};
-pub use version::{Version, NoVersion, split_version_general};
+pub use version::{Version, NoVersion, split_version_general, try_parsing_version};
pub use rustc::metadata::filesearch::rust_path;
use std::libc::consts::os::posix88::{S_IRUSR, S_IWUSR, S_IXUSR};
/// Figure out what the library name for <pkgid> in <workspace>'s build
/// directory is, and if the file exists, return it.
pub fn built_library_in_workspace(pkgid: &PkgId, workspace: &Path) -> Option<Path> {
- library_in_workspace(&pkgid.path, pkgid.short_name, Build, workspace, "build")
+ library_in_workspace(&pkgid.path, pkgid.short_name, Build, workspace, "build", &pkgid.version)
}
/// Does the actual searching stuff
pub fn installed_library_in_workspace(short_name: &str, workspace: &Path) -> Option<Path> {
- library_in_workspace(&Path(short_name), short_name, Install, workspace, "lib")
+ // NOTE: this could break once we're handling multiple versions better... want a test for it
+ library_in_workspace(&Path(short_name), short_name, Install, workspace, "lib", &NoVersion)
}
-
-/// This doesn't take a PkgId, so we can use it for `extern mod` inference, where we
-/// don't know the entire package ID.
/// `workspace` is used to figure out the directory to search.
/// `short_name` is taken as the link name of the library.
pub fn library_in_workspace(path: &Path, short_name: &str, where: Target,
- workspace: &Path, prefix: &str) -> Option<Path> {
+ workspace: &Path, prefix: &str
, version: &Version) -> Option<Path> {
debug!("library_in_workspace: checking whether a library named %s exists",
short_name);
for p_path in libraries {
// Find a filename that matches the pattern: (lib_prefix)-hash-(version)(lib_suffix)
// and remember what the hash was
- let f_name = match p_path.filename() {
+ let mut f_name = match p_path.filestem() {
Some(s) => s, None => loop
};
-
- let mut hash = None;
- let mut which = 0;
- for piece in f_name.split_iter('-') {
- debug!("a piece = %s", piece);
- if which == 0 && piece != lib_prefix {
- break;
- }
- else if which == 0 {
- which += 1;
- }
- else if which == 1 {
- hash = Some(piece.to_owned());
- break;
- }
- else {
- // something went wrong
- hash = None;
- break;
- }
- }
-
- if hash.is_some() {
- result_filename = Some(p_path);
- break;
- }
- }
+ // Already checked the filetype above
+
+ // This is complicated because library names and versions can both contain dashes
+ loop {
+ if f_name.is_empty() { break; }
+ match f_name.rfind('-') {
+ Some(i) => {
+ debug!("Maybe %s is a version", f_name.slice(i + 1, f_name.len()));
+ match try_parsing_version(f_name.slice(i + 1, f_name.len())) {
+ Some(ref found_vers) if version == found_vers => {
+ match f_name.slice(0, i).rfind('-') {
+ Some(j) => {
+ debug!("Maybe %s equals %s", f_name.slice(0, j), lib_prefix);
+ if f_name.slice(0, j) == lib_prefix {
+ result_filename = Some(p_path);
+ }
+ break;
+ }
+ None => break
+ }
+ }
+ _ => { f_name = f_name.slice(0, i).to_owned(); }
+ }
+ }
+ None => break
+ } // match
+ } // loop
+ } // for
if result_filename.is_none() {
warn(fmt!("library_in_workspace didn't find a library in %s for %s",
/// Given the path name for a package script
/// and a package ID, parse the package script into
/// a PkgScript that we can then execute
- fn parse<'a>(script: Path, workspace: &Path, id: &'a PkgId) -> PkgScript<'a> {
+ fn parse<'a>(sysroot: @Path,
+ script: Path,
+ workspace: &Path,
+ id: &'a PkgId) -> PkgScript<'a> {
// Get the executable name that was invoked
let binary = os::args()[0].to_managed();
// Build the rustc session data structures to pass
// to the compiler
- debug!("pkgscript parse: %?", os::self_exe_path());
+ debug!("pkgscript parse: %s", sysroot.to_str());
let options = @session::options {
binary: binary,
- maybe_sysroot: Some(@os::self_exe_path().unwrap().pop()),
+ maybe_sysroot: Some(sysroot),
crate_type: session::bin_crate,
.. (*session::basic_options()).clone()
};
let crate = driver::phase_2_configure_and_expand(sess, cfg.clone(), crate);
let work_dir = build_pkg_id_in_workspace(id, workspace);
- debug!("Returning package script with id %?", id);
+ debug!("Returning package script with id %s", id.to_str());
PkgScript {
id: id,
let crate = util::ready_crate(sess, self.crate);
debug!("Building output filenames with script name %s",
driver::source_name(&self.input));
- let root = filesearch::get_or_default_sysroot().pop().pop(); // :-\
- debug!("Root is %s, calling compile_rest", root.to_str());
let exe = self.build_dir.push(~"pkg" + util::exe_suffix());
util::compile_crate_from_input(&self.input,
&self.build_dir,
sess,
crate);
- debug!("Running program: %s %s %s %s", exe.to_str(),
- sysroot.to_str(), root.to_str(), "install");
+ debug!("Running program: %s %s %s", exe.to_str(),
+ sysroot.to_str(), "install");
// FIXME #7401 should support commands besides `install`
let status = run::process_status(exe.to_str(), [sysroot.to_str(), ~"install"]);
if status != 0 {
}
else {
debug!("Running program (configs): %s %s %s",
- exe.to_str(), root.to_str(), "configs");
- let output = run::process_output(exe.to_str(), [root.to_str(), ~"configs"]);
+ exe.to_str(), sysroot.to_str(), "configs");
+ let output = run::process_output(exe.to_str(), [sysroot.to_str(), ~"configs"]);
// Run the configs() function to get the configs
let cfgs = str::from_bytes_slice(output.output).word_iter()
.map(|w| w.to_owned()).collect();
debug!("Package source directory = %?", pkg_src_dir);
let cfgs = match pkg_src_dir.chain_ref(|p| src.package_script_option(p)) {
Some(package_script_path) => {
- let pscript = PkgScript::parse(package_script_path,
+ let sysroot = self.sysroot_to_use().expect("custom build needs a sysroot");
+ let pscript = PkgScript::parse(sysroot,
+ package_script_path,
workspace,
pkgid);
- let sysroot = self.sysroot_opt.expect("custom build needs a sysroot");
let (cfgs, hook_result) = pscript.run_custom(sysroot);
debug!("Command return code = %?", hook_result);
if hook_result != 0 {
assert!(os::path_is_dir(&*cwd));
let cwd = (*cwd).clone();
let mut prog = run::Process::new(cmd, args, run::ProcessOptions {
- env: env,
+ env: env.map(|e| e + os::env()),
dir: Some(&cwd),
in_fd: None,
out_fd: None,
short_name,
Build,
workspace,
- "build").expect("lib_output_file_name")
+ "build",
+ &NoVersion).expect("lib_output_file_name")
}
fn output_file_name(workspace: &Path, short_name: &str) -> Path {
}
}
-// FIXME(#7249): these tests fail on multi-platform builds, so for now they're
-// only run one x86
-
-#[test] #[ignore(cfg(target_arch = "x86"))]
+#[test]
fn test_make_dir_rwx() {
let temp = &os::tmpdir();
let dir = temp.push("quux");
assert!(os::remove_dir_recursive(&dir));
}
-#[test] #[ignore(cfg(target_arch = "x86"))]
+#[test]
fn test_install_valid() {
use path_util::installed_library_in_workspace;
assert!(!os::path_exists(&bench));
}
-#[test] #[ignore(cfg(target_arch = "x86"))]
+#[test]
fn test_install_invalid() {
use conditions::nonexistent_package::cond;
use cond1 = conditions::missing_pkg_files::cond;
}
// Tests above should (maybe) be converted to shell out to rustpkg, too
-
-// FIXME: #7956: temporarily disabled
-#[ignore(cfg(target_arch = "x86"))]
+#[test]
fn test_install_git() {
let sysroot = test_sysroot();
debug!("sysroot = %s", sysroot.to_str());
let temp_pkg_id = git_repo_pkg();
let repo = init_git_repo(&temp_pkg_id.path);
- let repo_subdir = repo.push("mockgithub.com").push("catamorphism").push("test_pkg");
+ debug!("repo = %s", repo.to_str());
+ let repo_subdir = repo.push("mockgithub.com").push("catamorphism").push("test-pkg");
+ debug!("repo_subdir = %s", repo_subdir.to_str());
+
writeFile(&repo_subdir.push("main.rs"),
"fn main() { let _x = (); }");
writeFile(&repo_subdir.push("lib.rs"),
temp_pkg_id.path.to_str(), repo.to_str());
// should have test, bench, lib, and main
command_line_test([~"install", temp_pkg_id.path.to_str()], &repo);
+ let ws = repo.push(".rust");
// Check that all files exist
- debug!("Checking for files in %s", repo.to_str());
- let exec = target_executable_in_workspace(&temp_pkg_id, &repo);
+ debug!("Checking for files in %s", ws.to_str());
+ let exec = target_executable_in_workspace(&temp_pkg_id, &ws);
debug!("exec = %s", exec.to_str());
assert!(os::path_exists(&exec));
assert!(is_rwx(&exec));
let _built_lib =
built_library_in_workspace(&temp_pkg_id,
- &repo).expect("test_install_git: built lib should exist");
- let lib = target_library_in_workspace(&temp_pkg_id, &repo);
- debug!("lib = %s", lib.to_str());
- assert!(os::path_exists(&lib));
- assert!(is_rwx(&lib));
+ &ws).expect("test_install_git: built lib should exist");
+ assert_lib_exists(&ws, temp_pkg_id.short_name, temp_pkg_id.version.clone());
let built_test = built_test_in_workspace(&temp_pkg_id,
- &repo).expect("test_install_git: built test should exist");
+ &ws).expect("test_install_git: built test should exist");
assert!(os::path_exists(&built_test));
let built_bench = built_bench_in_workspace(&temp_pkg_id,
- &repo).expect("test_install_git: built bench should exist");
+ &ws).expect("test_install_git: built bench should exist");
assert!(os::path_exists(&built_bench));
// And that the test and bench executables aren't installed
- let test = target_test_in_workspace(&temp_pkg_id, &repo);
+ let test = target_test_in_workspace(&temp_pkg_id, &ws);
assert!(!os::path_exists(&test));
debug!("test = %s", test.to_str());
- let bench = target_bench_in_workspace(&temp_pkg_id, &repo);
+ let bench = target_bench_in_workspace(&temp_pkg_id, &ws);
debug!("bench = %s", bench.to_str());
assert!(!os::path_exists(&bench));
}
-#[test] #[ignore(cfg(target_arch = "x86"))]
+#[test]
fn test_package_ids_must_be_relative_path_like() {
use conditions::bad_pkg_id::cond;
}
-// FIXME: #7956: temporarily disabled
-#[ignore(cfg(target_arch = "x86"))]
+#[test]
fn test_package_version() {
let local_path = "mockgithub.com/catamorphism/test_pkg_version";
let repo = init_git_repo(&Path(local_path));
"#[bench] pub fn f() { (); }");
add_git_tag(&repo_subdir, ~"0.4");
+ // It won't pick up the 0.4 version because the dir isn't in the RUST_PATH, but...
let temp_pkg_id = PkgId::new("mockgithub.com/catamorphism/test_pkg_version");
- match temp_pkg_id.version {
- ExactRevision(~"0.4") => (),
- _ => fail!(fmt!("test_package_version: package version was %?, expected Some(0.4)",
- temp_pkg_id.version))
- }
// This should look at the prefix, clone into a workspace, then build.
command_line_test([~"install", ~"mockgithub.com/catamorphism/test_pkg_version"],
&repo);
+ let ws = repo.push(".rust");
+ // we can still match on the filename to make sure it contains the 0.4 version
assert!(match built_library_in_workspace(&temp_pkg_id,
- &repo) {
+ &ws) {
Some(p) => p.to_str().ends_with(fmt!("0.4%s", os::consts::DLL_SUFFIX)),
None => false
});
- assert!(built_executable_in_workspace(&temp_pkg_id, &repo)
- == Some(repo.push("build").
+ assert!(built_executable_in_workspace(&temp_pkg_id, &ws)
+ == Some(ws.push("build").
push("mockgithub.com").
push("catamorphism").
push("test_pkg_version").
push("test_pkg_version")));
}
+#[test]
fn test_package_request_version() {
let local_path = "mockgithub.com/catamorphism/test_pkg_version";
let repo = init_git_repo(&Path(local_path));
&temp_dir);
}
-// FIXME: #7956: temporarily disabled
#[test]
fn rustpkg_library_target() {
let foo_repo = init_git_repo(&Path("foo"));
assert_executable_exists(&dir, "foo");
}
-// FIXME: #7956: temporarily disabled
-// Failing on dist-linux bot
#[test]
-#[ignore]
fn package_script_with_default_build() {
let dir = create_local_package(&PkgId::new("fancy-lib"));
debug!("dir = %s", dir.to_str());
push("testsuite").push("pass").push("src").push("fancy-lib").push("pkg.rs");
debug!("package_script_with_default_build: %s", source.to_str());
if !os::copy_file(&source,
- & dir.push("src").push("fancy_lib-0.1").push("pkg.rs")) {
+ & dir.push("src").push("fancy-lib-0.1").push("pkg.rs")) {
fail!("Couldn't copy file");
}
command_line_test([~"install", ~"fancy-lib"], &dir);
assert_lib_exists(&dir, "fancy-lib", NoVersion);
- assert!(os::path_exists(&dir.push("build").push("fancy_lib").push("generated.rs")));
+ assert!(os::path_exists(&dir.push("build").push("fancy-lib").push("generated.rs")));
}
#[test]
#[test]
fn rustpkg_install_no_arg() {
let tmp = mkdtemp(&os::tmpdir(),
- "rustpkg_install_no_arg").expect("rustpkg_build_no_arg failed");
+ "rustpkg_install_no_arg").expect("rustpkg_install_no_arg failed");
let package_dir = tmp.push("src").push("foo");
assert!(os::mkdir_recursive(&package_dir, U_RWX));
writeFile(&package_dir.push("lib.rs"),
}
#[test]
-#[ignore (reason = "Specifying env doesn't work -- see #8028")]
fn rust_path_test() {
let dir_for_path = mkdtemp(&os::tmpdir(), "more_rust").expect("rust_path_test failed");
let dir = mk_workspace(&dir_for_path, &Path("foo"), &NoVersion);
let cwd = os::getcwd();
debug!("cwd = %s", cwd.to_str());
// use command_line_test_with_env
- let mut prog = run::Process::new("rustpkg",
- [~"install", ~"foo"],
-// This should actually extend the environment; then we can probably
-// un-ignore it
- run::ProcessOptions { env: Some(~[(~"RUST_LOG",
- ~"rustpkg"),
- (~"RUST_PATH",
- dir_for_path.to_str())]),
- dir: Some(&cwd),
- in_fd: None,
- out_fd: None,
- err_fd: None
- });
- prog.finish_with_output();
+ command_line_test_with_env([~"install", ~"foo"],
+ &cwd,
+ Some(~[(~"RUST_PATH", dir_for_path.to_str())]));
assert_executable_exists(&dir_for_path, "foo");
}
assert!(os::path_exists(&exec_file) && is_executable(&exec_file));
}
+#[test]
+fn test_import_rustpkg() {
+ let p_id = PkgId::new("foo");
+ let workspace = create_local_package(&p_id);
+ writeFile(&workspace.push("src").push("foo-0.1").push("pkg.rs"),
+ "extern mod rustpkg; fn main() {}");
+ command_line_test([~"build", ~"foo"], &workspace);
+ debug!("workspace = %s", workspace.to_str());
+ assert!(os::path_exists(&workspace.push("build").push("foo").push(fmt!("pkg%s",
+ os::EXE_SUFFIX))));
+}
+
+#[test]
+fn test_macro_pkg_script() {
+ let p_id = PkgId::new("foo");
+ let workspace = create_local_package(&p_id);
+ writeFile(&workspace.push("src").push("foo-0.1").push("pkg.rs"),
+ "extern mod rustpkg; fn main() { debug!(\"Hi\"); }");
+ command_line_test([~"build", ~"foo"], &workspace);
+ debug!("workspace = %s", workspace.to_str());
+ assert!(os::path_exists(&workspace.push("build").push("foo").push(fmt!("pkg%s",
+ os::EXE_SUFFIX))));
+}
+
/// Returns true if p exists and is executable
fn is_executable(p: &Path) -> bool {
use std::libc::consts::os::posix88::{S_IXUSR};
return;
}
- let out_path = Path("build/fancy_lib");
+ let out_path = Path("build/fancy-lib");
if !os::path_exists(&out_path) {
assert!(os::make_dir(&out_path, (S_IRUSR | S_IWUSR | S_IXUSR) as i32));
}
#[cfg(windows)]
pub fn link_exe(_src: &Path, _dest: &Path) -> bool {
+ #[fixed_stack_segment]; #[inline(never)];
+
/* FIXME (#1768): Investigate how to do this on win32
Node wraps symlinks by having a .bat,
but that won't work with minGW. */
#[cfg(target_os = "freebsd")]
#[cfg(target_os = "macos")]
pub fn link_exe(src: &Path, dest: &Path) -> bool {
+ #[fixed_stack_segment]; #[inline(never)];
+
use std::c_str::ToCStr;
use std::libc;
NoVersion // user didn't specify a version -- prints as 0.1
}
+// Equality on versions is non-symmetric: if self is NoVersion, it's equal to
+// anything; but if self is a precise version, it's not equal to NoVersion.
+// We should probably make equality symmetric, and use less-than and greater-than
+// where we currently use eq
impl Eq for Version {
fn eq(&self, other: &Version) -> bool {
match (self, other) {
SawDot
}
-fn try_parsing_version(s: &str) -> Option<Version> {
+pub fn try_parsing_version(s: &str) -> Option<Version> {
let s = s.trim();
debug!("Attempting to parse: %s", s);
let mut parse_state = Start;
/// number, return the prefix before the # and the version.
/// Otherwise, return None.
pub fn split_version<'a>(s: &'a str) -> Option<(&'a str, Version)> {
- split_version_general(s, '#')
+ // Check for extra '#' characters separately
+ if s.split_iter('#').len() > 2 {
+ None
+ }
+ else {
+ split_version_general(s, '#')
+ }
}
pub fn split_version_general<'a>(s: &'a str, sep: char) -> Option<(&'a str, Version)> {
- // reject strings with multiple '#'s
- for st in s.split_iter(sep) {
- debug!("whole = %s part = %s", s, st);
- }
- if s.split_iter(sep).len() > 2 {
- return None;
- }
match s.rfind(sep) {
Some(i) => {
debug!("in %s, i = %?", s, i);
* Sets the length of a vector
*
* This will explicitly set the size of the vector, without actually
- * modifing its buffers, so it is up to the caller to ensure that
+ * modifying its buffers, so it is up to the caller to ensure that
* the vector is actually the specified size.
*/
#[inline]
if capacity(*v) < n {
let ptr: *mut *mut Box<Vec<()>> = transmute(v);
let ty = intrinsics::get_tydesc::<T>();
- // XXX transmute shouldn't be necessary
- let ty = cast::transmute(ty);
return reserve_raw(ty, ptr, n);
}
}
Also, a few conversion functions: `to_bit` and `to_str`.
-Finally, some inquries into the nature of truth: `is_true` and `is_false`.
+Finally, some inquiries into the nature of truth: `is_true` and `is_false`.
*/
///
/// Fails if the CString is null.
pub fn as_bytes<'a>(&'a self) -> &'a [u8] {
+ #[fixed_stack_segment]; #[inline(never)];
if self.buf.is_null() { fail!("CString is null!"); }
unsafe {
let len = libc::strlen(self.buf) as uint;
impl Drop for CString {
fn drop(&self) {
+ #[fixed_stack_segment]; #[inline(never)];
if self.owns_buffer_ {
unsafe {
libc::free(self.buf as *libc::c_void)
impl<'self> ToCStr for &'self [u8] {
fn to_c_str(&self) -> CString {
+ #[fixed_stack_segment]; #[inline(never)];
let mut cs = unsafe { self.to_c_str_unchecked() };
do cs.with_mut_ref |buf| {
for i in range(0, self.len()) {
}
unsafe fn to_c_str_unchecked(&self) -> CString {
+ #[fixed_stack_segment]; #[inline(never)];
do self.as_imm_buf |self_buf, self_len| {
let buf = libc::malloc(self_len as libc::size_t + 1) as *mut u8;
if buf.is_null() {
#[test]
fn test_unwrap() {
+ #[fixed_stack_segment]; #[inline(never)];
+
let c_str = "hello".to_c_str();
unsafe { libc::free(c_str.unwrap() as *libc::c_void) }
}
#[test]
fn test_with_ref() {
+ #[fixed_stack_segment]; #[inline(never)];
+
let c_str = "hello".to_c_str();
let len = unsafe { c_str.with_ref(|buf| libc::strlen(buf)) };
assert!(!c_str.is_null());
use option::{None, Option, Some};
use int;
use str::StrSlice;
-use unicode::{derived_property, general_category};
+use unicode::{derived_property, general_category, decompose};
#[cfg(test)] use str::OwnedStr;
}
}
+// Constants from Unicode 6.2.0 Section 3.12 Conjoining Jamo Behavior
+static S_BASE: uint = 0xAC00;
+static L_BASE: uint = 0x1100;
+static V_BASE: uint = 0x1161;
+static T_BASE: uint = 0x11A7;
+static L_COUNT: uint = 19;
+static V_COUNT: uint = 21;
+static T_COUNT: uint = 28;
+static N_COUNT: uint = (V_COUNT * T_COUNT);
+static S_COUNT: uint = (L_COUNT * N_COUNT);
+
+// Decompose a precomposed Hangul syllable
+fn decompose_hangul(s: char, f: &fn(char)) {
+ let si = s as uint - S_BASE;
+
+ let li = si / N_COUNT;
+ f((L_BASE + li) as char);
+
+ let vi = (si % N_COUNT) / T_COUNT;
+ f((V_BASE + vi) as char);
+
+ let ti = si % T_COUNT;
+ if ti > 0 {
+ f((T_BASE + ti) as char);
+ }
+}
+
+/// Returns the canonical decompostion of a character
+pub fn decompose_canonical(c: char, f: &fn(char)) {
+ if (c as uint) < S_BASE || (c as uint) >= (S_BASE + S_COUNT) {
+ decompose::canonical(c, f);
+ } else {
+ decompose_hangul(c, f);
+ }
+}
+
+/// Returns the compatibility decompostion of a character
+pub fn decompose_compatible(c: char, f: &fn(char)) {
+ if (c as uint) < S_BASE || (c as uint) >= (S_BASE + S_COUNT) {
+ decompose::compatibility(c, f);
+ } else {
+ decompose_hangul(c, f);
+ }
+}
+
///
/// Return the hexadecimal unicode escape of a char.
///
use io::WriterUtil;
use io;
use libc;
- use rt::borrowck;
use sys;
use managed;
n_bytes_freed: 0
};
- // Quick hack: we need to free this list upon task exit, and this
- // is a convenient place to do it.
- borrowck::clear_task_borrow_list();
-
// Pass 1: Make all boxes immortal.
//
// In this pass, nothing gets freed, so it does not matter whether
fn find<'a>(&'a self, key: &K) -> Option<&'a V>;
/// Return true if the map contains a value for the specified key
+ #[inline]
fn contains_key(&self, key: &K) -> bool {
self.find(key).is_some()
}
## Internationalization
The formatting syntax supported by the `ifmt!` extension supports
-internationalization by providing "methods" which execute various differnet
+internationalization by providing "methods" which execute various different
outputs depending on the input. The syntax and methods provided are similar to
other internationalization systems, so again nothing should seem alien.
Currently two methods are supported by this extension: "select" and "plural".
priv value: &'self util::Void,
}
+/// When a format is not otherwise specified, types are formatted by ascribing
+/// to this trait. There is not an explicit way of selecting this trait to be
+/// used for formatting, it is only if no other format is specified.
+#[allow(missing_doc)]
+pub trait Default { fn fmt(&Self, &mut Formatter); }
+
+/// Format trait for the `b` character
#[allow(missing_doc)]
pub trait Bool { fn fmt(&Self, &mut Formatter); }
+/// Format trait for the `c` character
#[allow(missing_doc)]
pub trait Char { fn fmt(&Self, &mut Formatter); }
+/// Format trait for the `i` and `d` characters
#[allow(missing_doc)]
pub trait Signed { fn fmt(&Self, &mut Formatter); }
+/// Format trait for the `u` character
#[allow(missing_doc)]
pub trait Unsigned { fn fmt(&Self, &mut Formatter); }
+/// Format trait for the `o` character
#[allow(missing_doc)]
pub trait Octal { fn fmt(&Self, &mut Formatter); }
+/// Format trait for the `b` character
#[allow(missing_doc)]
pub trait Binary { fn fmt(&Self, &mut Formatter); }
+/// Format trait for the `x` character
#[allow(missing_doc)]
pub trait LowerHex { fn fmt(&Self, &mut Formatter); }
+/// Format trait for the `X` character
#[allow(missing_doc)]
pub trait UpperHex { fn fmt(&Self, &mut Formatter); }
+/// Format trait for the `s` character
#[allow(missing_doc)]
pub trait String { fn fmt(&Self, &mut Formatter); }
+/// Format trait for the `?` character
#[allow(missing_doc)]
pub trait Poly { fn fmt(&Self, &mut Formatter); }
+/// Format trait for the `p` character
#[allow(missing_doc)]
pub trait Pointer { fn fmt(&Self, &mut Formatter); }
+/// Format trait for the `f` character
#[allow(missing_doc)]
pub trait Float { fn fmt(&Self, &mut Formatter); }
}
}
-impl<'self> String for &'self str {
- fn fmt(s: & &'self str, f: &mut Formatter) {
- f.pad(*s);
+impl<'self, T: str::Str> String for T {
+ fn fmt(s: &T, f: &mut Formatter) {
+ f.pad(s.as_slice());
}
}
}
}
+// Implementation of Default for various core types
+
+macro_rules! delegate(($ty:ty to $other:ident) => {
+ impl<'self> Default for $ty {
+ fn fmt(me: &$ty, f: &mut Formatter) {
+ $other::fmt(me, f)
+ }
+ }
+})
+delegate!(int to Signed)
+delegate!( i8 to Signed)
+delegate!(i16 to Signed)
+delegate!(i32 to Signed)
+delegate!(i64 to Signed)
+delegate!(uint to Unsigned)
+delegate!( u8 to Unsigned)
+delegate!( u16 to Unsigned)
+delegate!( u32 to Unsigned)
+delegate!( u64 to Unsigned)
+delegate!(@str to String)
+delegate!(~str to String)
+delegate!(&'self str to String)
+delegate!(bool to Bool)
+delegate!(char to Char)
+delegate!(float to Float)
+delegate!(f32 to Float)
+delegate!(f64 to Float)
+
+impl<T> Default for *const T {
+ fn fmt(me: &*const T, f: &mut Formatter) { Pointer::fmt(me, f) }
+}
+
// If you expected tests to be here, look instead at the run-pass/ifmt.rs test,
// it's a lot easier than creating all of the rt::Piece structures here.
ArgumentNext, ArgumentIs(uint), ArgumentNamed(&'self str)
}
-/// Enum of alignments which are supoprted.
+/// Enum of alignments which are supported.
#[deriving(Eq)]
pub enum Alignment { AlignLeft, AlignRight, AlignUnknown }
}
}
// Finally the actual format specifier
- spec.ty = self.word();
+ if self.consume('?') {
+ spec.ty = "?";
+ } else {
+ spec.ty = self.word();
+ }
return spec;
}
use rt::io::Writer;
use str::OwnedStr;
use to_bytes::IterBytes;
-use uint;
use vec::ImmutableVector;
+use num::ToStrRadix;
// Alias `SipState` to `State`.
pub use State = hash::SipState;
let r = self.result_bytes();
let mut s = ~"";
for b in r.iter() {
- s.push_str(uint::to_str_radix(*b as uint, 16u));
+ s.push_str((*b as uint).to_str_radix(16u));
}
s
}
use super::*;
use prelude::*;
- use uint;
+ // Hash just the bytes of the slice, without length prefix
+ struct Bytes<'self>(&'self [u8]);
+ impl<'self> IterBytes for Bytes<'self> {
+ fn iter_bytes(&self, _lsb0: bool, f: &fn(&[u8]) -> bool) -> bool {
+ f(**self)
+ }
+ }
#[test]
fn test_siphash() {
fn to_hex_str(r: &[u8, ..8]) -> ~str {
let mut s = ~"";
for b in r.iter() {
- s.push_str(uint::to_str_radix(*b as uint, 16u));
+ s.push_str((*b as uint).to_str_radix(16u));
}
s
}
while t < 64 {
debug!("siphash test %?", t);
let vec = u8to64_le!(vecs[t], 0);
- let out = buf.hash_keyed(k0, k1);
+ let out = Bytes(buf.as_slice()).hash_keyed(k0, k1);
debug!("got %?, expected %?", out, vec);
assert_eq!(vec, out);
fn test_float_hashes_of_zero() {
assert_eq!(0.0.hash(), (-0.0).hash());
}
+
+ #[test]
+ fn test_hash_no_concat_alias() {
+ let s = ("aa", "bb");
+ let t = ("aabb", "");
+ let u = ("a", "abb");
+
+ let v = (&[1u8], &[0u8, 0], &[0u8]);
+ let w = (&[1u8, 0, 0, 0], &[], &[]);
+
+ assert!(v != w);
+ assert!(s.hash() != t.hash() && s.hash() != u.hash());
+ assert!(v.hash() != w.hash());
+ }
}
impl Reader for *libc::FILE {
fn read(&self, bytes: &mut [u8], len: uint) -> uint {
+ #[fixed_stack_segment]; #[inline(never)];
+
unsafe {
do bytes.as_mut_buf |buf_p, buf_len| {
assert!(buf_len >= len);
}
}
fn read_byte(&self) -> int {
+ #[fixed_stack_segment]; #[inline(never)];
+
unsafe {
libc::fgetc(*self) as int
}
}
fn eof(&self) -> bool {
+ #[fixed_stack_segment]; #[inline(never)];
+
unsafe {
return libc::feof(*self) != 0 as c_int;
}
}
fn seek(&self, offset: int, whence: SeekStyle) {
+ #[fixed_stack_segment]; #[inline(never)];
+
unsafe {
assert!(libc::fseek(*self,
offset as c_long,
}
}
fn tell(&self) -> uint {
+ #[fixed_stack_segment]; #[inline(never)];
+
unsafe {
return libc::ftell(*self) as uint;
}
impl Drop for FILERes {
fn drop(&self) {
+ #[fixed_stack_segment]; #[inline(never)];
+
unsafe {
libc::fclose(self.f);
}
* # Example
*
* ~~~ {.rust}
-* let stdin = core::io::stdin();
+* let stdin = std::io::stdin();
* let line = stdin.read_line();
-* core::io::print(line);
+* std::io::print(line);
* ~~~
*/
pub fn stdin() -> @Reader {
+ #[fixed_stack_segment]; #[inline(never)];
+
unsafe {
@rustrt::rust_get_stdin() as @Reader
}
}
pub fn file_reader(path: &Path) -> Result<@Reader, ~str> {
+ #[fixed_stack_segment]; #[inline(never)];
+
let f = do path.with_c_str |pathbuf| {
do "rb".with_c_str |modebuf| {
unsafe { libc::fopen(pathbuf, modebuf as *libc::c_char) }
impl Writer for *libc::FILE {
fn write(&self, v: &[u8]) {
+ #[fixed_stack_segment]; #[inline(never)];
+
unsafe {
do v.as_imm_buf |vbuf, len| {
let nout = libc::fwrite(vbuf as *c_void,
}
}
fn seek(&self, offset: int, whence: SeekStyle) {
+ #[fixed_stack_segment]; #[inline(never)];
+
unsafe {
assert!(libc::fseek(*self,
offset as c_long,
}
}
fn tell(&self) -> uint {
+ #[fixed_stack_segment]; #[inline(never)];
+
unsafe {
libc::ftell(*self) as uint
}
}
fn flush(&self) -> int {
+ #[fixed_stack_segment]; #[inline(never)];
+
unsafe {
libc::fflush(*self) as int
}
}
fn get_type(&self) -> WriterType {
+ #[fixed_stack_segment]; #[inline(never)];
+
unsafe {
let fd = libc::fileno(*self);
if libc::isatty(fd) == 0 { File }
impl Writer for fd_t {
fn write(&self, v: &[u8]) {
+ #[fixed_stack_segment]; #[inline(never)];
+
unsafe {
let mut count = 0u;
do v.as_imm_buf |vbuf, len| {
}
fn flush(&self) -> int { 0 }
fn get_type(&self) -> WriterType {
+ #[fixed_stack_segment]; #[inline(never)];
+
unsafe {
if libc::isatty(*self) == 0 { File } else { Screen }
}
impl Drop for FdRes {
fn drop(&self) {
+ #[fixed_stack_segment]; #[inline(never)];
+
unsafe {
libc::close(self.fd);
}
pub fn mk_file_writer(path: &Path, flags: &[FileFlag])
-> Result<@Writer, ~str> {
+ #[fixed_stack_segment]; #[inline(never)];
+
#[cfg(windows)]
fn wb() -> c_int {
(O_WRONLY | libc::consts::os::extra::O_BINARY) as c_int
/// (8 bytes).
fn write_le_f64(&self, f: f64);
- /// Write a litten-endian IEEE754 single-precision floating-point
+ /// Write a little-endian IEEE754 single-precision floating-point
/// (4 bytes).
fn write_le_f32(&self, f: f32);
// FIXME: fileflags // #2004
pub fn buffered_file_writer(path: &Path) -> Result<@Writer, ~str> {
+ #[fixed_stack_segment]; #[inline(never)];
+
unsafe {
let f = do path.with_c_str |pathbuf| {
do "w".with_c_str |modebuf| {
* # Example
*
* ~~~ {.rust}
-* let stdout = core::io::stdout();
+* let stdout = std::io::stdout();
* stdout.write_str("hello\n");
* ~~~
*/
* # Example
*
* ~~~ {.rust}
-* let stderr = core::io::stderr();
+* let stderr = std::io::stderr();
* stderr.write_str("hello\n");
* ~~~
*/
blk: &fn(v: Res<*libc::FILE>)) {
blk(Res::new(Arg {
val: file.f, opt_level: opt_level,
- fsync_fn: |file, l| {
- unsafe {
- os::fsync_fd(libc::fileno(*file), l) as int
- }
- }
+ fsync_fn: |file, l| fsync_fd(fileno(*file), l)
}));
+
+ fn fileno(stream: *libc::FILE) -> libc::c_int {
+ #[fixed_stack_segment]; #[inline(never)];
+ unsafe { libc::fileno(stream) }
+ }
}
// fsync fd after executing blk
blk: &fn(v: Res<fd_t>)) {
blk(Res::new(Arg {
val: fd.fd, opt_level: opt_level,
- fsync_fn: |fd, l| os::fsync_fd(*fd, l) as int
+ fsync_fn: |fd, l| fsync_fd(*fd, l)
}));
}
+ fn fsync_fd(fd: libc::c_int, level: Level) -> int {
+ #[fixed_stack_segment]; #[inline(never)];
+
+ os::fsync_fd(fd, level) as int
+ }
+
// Type of objects that may want to fsync
pub trait FSyncable { fn fsync(&self, l: Level) -> int; }
*/
use cmp;
-use num::{Zero, One, Integer, Saturating};
+use num::{Zero, One, Integer, CheckedAdd, Saturating};
use option::{Option, Some, None};
use ops::{Add, Mul, Sub};
use cmp::Ord;
use clone::Clone;
use uint;
+use util;
/// Conversion from an `Iterator`
pub trait FromIterator<A> {
i
}
- /// Return the element that gives the maximum value from the specfied function
+ /// Return the element that gives the maximum value from the
+ /// specified function.
///
/// # Example
///
}).map_move(|(x, _)| x)
}
- /// Return the element that gives the minimum value from the specfied function
+ /// Return the element that gives the minimum value from the
+ /// specified function.
///
/// # Example
///
}
}
+/// A double-ended iterator yielding mutable references
+pub trait MutableDoubleEndedIterator {
+ // FIXME: #5898: should be called `reverse`
+ /// Use an iterator to reverse a container in-place
+ fn reverse_(&mut self);
+}
+
+impl<'self, A, T: DoubleEndedIterator<&'self mut A>> MutableDoubleEndedIterator for T {
+ // FIXME: #5898: should be called `reverse`
+ /// Use an iterator to reverse a container in-place
+ fn reverse_(&mut self) {
+ loop {
+ match (self.next(), self.next_back()) {
+ (Some(x), Some(y)) => util::swap(x, y),
+ _ => break
+ }
+ }
+ }
+}
+
/// An object implementing random access indexing by `uint`
///
/// A `RandomAccessIterator` should be either infinite or a `DoubleEndedIterator`.
let lower = a_lower.saturating_add(b_lower);
let upper = match (a_upper, b_upper) {
- (Some(x), Some(y)) => Some(x.saturating_add(y)),
+ (Some(x), Some(y)) => x.checked_add(&y),
_ => None
};
if self.peeked.is_some() { self.peeked.take() }
else { self.iter.next() }
}
+
+ #[inline]
+ fn size_hint(&self) -> (uint, Option<uint>) {
+ let (lo, hi) = self.iter.size_hint();
+ if self.peeked.is_some() {
+ let lo = lo.saturating_add(1);
+ let hi = match hi {
+ Some(x) => x.checked_add(&1),
+ None => None
+ };
+ (lo, hi)
+ } else {
+ (lo, hi)
+ }
+ }
}
impl<'self, A, T: Iterator<A>> Peekable<A, T> {
/// or None if the iterator is exhausted.
#[inline]
pub fn peek(&'self mut self) -> Option<&'self A> {
+ if self.peeked.is_none() {
+ self.peeked = self.iter.next();
+ }
match self.peeked {
Some(ref value) => Some(value),
- None => {
- self.peeked = self.iter.next();
- match self.peeked {
- Some(ref value) => Some(value),
- None => None,
- }
- },
+ None => None,
}
}
}
let (blo, bhi) = self.backiter.map_default((0, Some(0)), |it| it.size_hint());
let lo = flo.saturating_add(blo);
match (self.iter.size_hint(), fhi, bhi) {
- ((0, Some(0)), Some(a), Some(b)) => (lo, Some(a.saturating_add(b))),
+ ((0, Some(0)), Some(a), Some(b)) => (lo, a.checked_add(&b)),
_ => (lo, None)
}
}
fn next(&mut self) -> Option<A> {
(self.f)(&mut self.state)
}
+
+ #[inline]
+ fn size_hint(&self) -> (uint, Option<uint>) {
+ // no possible known bounds at this point
+ (0, None)
+ }
}
/// An infinite iterator starting at `start` and advancing by `step` with each
None
}
}
+
+ // FIXME: #8606 Implement size_hint() on Range
+ // Blocked on #8605 Need numeric trait for converting to `Option<uint>`
}
impl<A: Sub<A, A> + Integer + Ord + Clone> DoubleEndedIterator<A> for Range<A> {
}
}
+/// A range of numbers from [0, N]
+#[deriving(Clone, DeepClone)]
+pub struct RangeInclusive<A> {
+ priv range: Range<A>,
+ priv done: bool
+}
+
+/// Return an iterator over the range [start, stop]
+#[inline]
+pub fn range_inclusive<A: Add<A, A> + Ord + Clone + One>(start: A, stop: A) -> RangeInclusive<A> {
+ RangeInclusive{range: range(start, stop), done: false}
+}
+
+impl<A: Add<A, A> + Ord + Clone> Iterator<A> for RangeInclusive<A> {
+ #[inline]
+ fn next(&mut self) -> Option<A> {
+ match self.range.next() {
+ Some(x) => Some(x),
+ None => {
+ if self.done {
+ None
+ } else {
+ self.done = true;
+ Some(self.range.stop.clone())
+ }
+ }
+ }
+ }
+}
+
+impl<A: Sub<A, A> + Integer + Ord + Clone> DoubleEndedIterator<A> for RangeInclusive<A> {
+ #[inline]
+ fn next_back(&mut self) -> Option<A> {
+ if self.range.stop > self.range.state {
+ let result = self.range.stop.clone();
+ self.range.stop = self.range.stop - self.range.one;
+ Some(result)
+ } else if self.done {
+ None
+ } else {
+ self.done = true;
+ Some(self.range.stop.clone())
+ }
+ }
+}
+
impl<A: Add<A, A> + Clone> Iterator<A> for Counter<A> {
#[inline]
fn next(&mut self) -> Option<A> {
}
impl<A: Clone> Repeat<A> {
- /// Create a new `Repeat` that enlessly repeats the element `elt`.
+ /// Create a new `Repeat` that endlessly repeats the element `elt`.
#[inline]
pub fn new(elt: A) -> Repeat<A> {
Repeat{element: elt}
fail!("unreachable");
}
}
+
+ #[test]
+ fn test_range_inclusive() {
+ assert_eq!(range_inclusive(0i, 5).collect::<~[int]>(), ~[0i, 1, 2, 3, 4, 5]);
+ assert_eq!(range_inclusive(0i, 5).invert().collect::<~[int]>(), ~[5i, 4, 3, 2, 1, 0]);
+ }
+
+ #[test]
+ fn test_reverse() {
+ let mut ys = [1, 2, 3, 4, 5];
+ ys.mut_iter().reverse_();
+ assert_eq!(ys, [5, 4, 3, 2, 1]);
+ }
}
pub use libc::consts::os::posix08::*;
pub use libc::consts::os::bsd44::*;
pub use libc::consts::os::extra::*;
+pub use libc::consts::os::sysconf::*;
pub use libc::funcs::c95::ctype::*;
pub use libc::funcs::c95::stdio::*;
pub static PROCESSOR_ARCHITECTURE_AMD64 : WORD = 9;
pub static PROCESSOR_ARCHITECTURE_UNKNOWN : WORD = 0xffff;
}
+ pub mod sysconf {
+ }
}
pub static MS_INVALIDATE : c_int = 0x0002;
pub static MS_SYNC : c_int = 0x0004;
- pub static _SC_ARG_MAX : c_int = 0;
- pub static _SC_CHILD_MAX : c_int = 1;
- pub static _SC_CLK_TCK : c_int = 2;
- pub static _SC_NGROUPS_MAX : c_int = 3;
- pub static _SC_OPEN_MAX : c_int = 4;
- pub static _SC_STREAM_MAX : c_int = 5;
- pub static _SC_TZNAME_MAX : c_int = 6;
- pub static _SC_JOB_CONTROL : c_int = 7;
- pub static _SC_SAVED_IDS : c_int = 8;
- pub static _SC_REALTIME_SIGNALS : c_int = 9;
- pub static _SC_PRIORITY_SCHEDULING : c_int = 10;
- pub static _SC_TIMERS : c_int = 11;
- pub static _SC_ASYNCHRONOUS_IO : c_int = 12;
- pub static _SC_PRIORITIZED_IO : c_int = 13;
- pub static _SC_SYNCHRONIZED_IO : c_int = 14;
- pub static _SC_FSYNC : c_int = 15;
- pub static _SC_MAPPED_FILES : c_int = 16;
- pub static _SC_MEMLOCK : c_int = 17;
- pub static _SC_MEMLOCK_RANGE : c_int = 18;
- pub static _SC_MEMORY_PROTECTION : c_int = 19;
- pub static _SC_MESSAGE_PASSING : c_int = 20;
- pub static _SC_SEMAPHORES : c_int = 21;
- pub static _SC_SHARED_MEMORY_OBJECTS : c_int = 22;
- pub static _SC_AIO_LISTIO_MAX : c_int = 23;
- pub static _SC_AIO_MAX : c_int = 24;
- pub static _SC_AIO_PRIO_DELTA_MAX : c_int = 25;
- pub static _SC_DELAYTIMER_MAX : c_int = 26;
- pub static _SC_MQ_OPEN_MAX : c_int = 27;
- pub static _SC_VERSION : c_int = 29;
- pub static _SC_PAGESIZE : c_int = 30;
- pub static _SC_RTSIG_MAX : c_int = 31;
- pub static _SC_SEM_NSEMS_MAX : c_int = 32;
- pub static _SC_SEM_VALUE_MAX : c_int = 33;
- pub static _SC_SIGQUEUE_MAX : c_int = 34;
- pub static _SC_TIMER_MAX : c_int = 35;
- pub static _SC_BC_BASE_MAX : c_int = 36;
- pub static _SC_BC_DIM_MAX : c_int = 37;
- pub static _SC_BC_SCALE_MAX : c_int = 38;
- pub static _SC_BC_STRING_MAX : c_int = 39;
- pub static _SC_COLL_WEIGHTS_MAX : c_int = 40;
- pub static _SC_EXPR_NEST_MAX : c_int = 42;
- pub static _SC_LINE_MAX : c_int = 43;
- pub static _SC_RE_DUP_MAX : c_int = 44;
- pub static _SC_2_VERSION : c_int = 46;
- pub static _SC_2_C_BIND : c_int = 47;
- pub static _SC_2_C_DEV : c_int = 48;
- pub static _SC_2_FORT_DEV : c_int = 49;
- pub static _SC_2_FORT_RUN : c_int = 50;
- pub static _SC_2_SW_DEV : c_int = 51;
- pub static _SC_2_LOCALEDEF : c_int = 52;
- pub static _SC_2_CHAR_TERM : c_int = 95;
- pub static _SC_2_C_VERSION : c_int = 96;
- pub static _SC_2_UPE : c_int = 97;
- pub static _SC_XBS5_ILP32_OFF32 : c_int = 125;
- pub static _SC_XBS5_ILP32_OFFBIG : c_int = 126;
- pub static _SC_XBS5_LPBIG_OFFBIG : c_int = 128;
-
pub static EPERM : c_int = 1;
pub static ENOENT : c_int = 2;
pub static ESRCH : c_int = 3;
pub static MS_INVALIDATE : c_int = 0x0002;
pub static MS_SYNC : c_int = 0x0004;
- pub static _SC_ARG_MAX : c_int = 0;
- pub static _SC_CHILD_MAX : c_int = 1;
- pub static _SC_CLK_TCK : c_int = 2;
- pub static _SC_NGROUPS_MAX : c_int = 3;
- pub static _SC_OPEN_MAX : c_int = 4;
- pub static _SC_STREAM_MAX : c_int = 5;
- pub static _SC_TZNAME_MAX : c_int = 6;
- pub static _SC_JOB_CONTROL : c_int = 7;
- pub static _SC_SAVED_IDS : c_int = 8;
- pub static _SC_REALTIME_SIGNALS : c_int = 9;
- pub static _SC_PRIORITY_SCHEDULING : c_int = 10;
- pub static _SC_TIMERS : c_int = 11;
- pub static _SC_ASYNCHRONOUS_IO : c_int = 12;
- pub static _SC_PRIORITIZED_IO : c_int = 13;
- pub static _SC_SYNCHRONIZED_IO : c_int = 14;
- pub static _SC_FSYNC : c_int = 15;
- pub static _SC_MAPPED_FILES : c_int = 16;
- pub static _SC_MEMLOCK : c_int = 17;
- pub static _SC_MEMLOCK_RANGE : c_int = 18;
- pub static _SC_MEMORY_PROTECTION : c_int = 19;
- pub static _SC_MESSAGE_PASSING : c_int = 20;
- pub static _SC_SEMAPHORES : c_int = 21;
- pub static _SC_SHARED_MEMORY_OBJECTS : c_int = 22;
- pub static _SC_AIO_LISTIO_MAX : c_int = 23;
- pub static _SC_AIO_MAX : c_int = 24;
- pub static _SC_AIO_PRIO_DELTA_MAX : c_int = 25;
- pub static _SC_DELAYTIMER_MAX : c_int = 26;
- pub static _SC_MQ_OPEN_MAX : c_int = 27;
- pub static _SC_VERSION : c_int = 29;
- pub static _SC_PAGESIZE : c_int = 30;
- pub static _SC_RTSIG_MAX : c_int = 31;
- pub static _SC_SEM_NSEMS_MAX : c_int = 32;
- pub static _SC_SEM_VALUE_MAX : c_int = 33;
- pub static _SC_SIGQUEUE_MAX : c_int = 34;
- pub static _SC_TIMER_MAX : c_int = 35;
- pub static _SC_BC_BASE_MAX : c_int = 36;
- pub static _SC_BC_DIM_MAX : c_int = 37;
- pub static _SC_BC_SCALE_MAX : c_int = 38;
- pub static _SC_BC_STRING_MAX : c_int = 39;
- pub static _SC_COLL_WEIGHTS_MAX : c_int = 40;
- pub static _SC_EXPR_NEST_MAX : c_int = 42;
- pub static _SC_LINE_MAX : c_int = 43;
- pub static _SC_RE_DUP_MAX : c_int = 44;
- pub static _SC_2_VERSION : c_int = 46;
- pub static _SC_2_C_BIND : c_int = 47;
- pub static _SC_2_C_DEV : c_int = 48;
- pub static _SC_2_FORT_DEV : c_int = 49;
- pub static _SC_2_FORT_RUN : c_int = 50;
- pub static _SC_2_SW_DEV : c_int = 51;
- pub static _SC_2_LOCALEDEF : c_int = 52;
- pub static _SC_2_CHAR_TERM : c_int = 95;
- pub static _SC_2_C_VERSION : c_int = 96;
- pub static _SC_2_UPE : c_int = 97;
- pub static _SC_XBS5_ILP32_OFF32 : c_int = 125;
- pub static _SC_XBS5_ILP32_OFFBIG : c_int = 126;
- pub static _SC_XBS5_LPBIG_OFFBIG : c_int = 128;
-
pub static EPERM : c_int = 1;
pub static ENOENT : c_int = 2;
pub static ESRCH : c_int = 3;
pub static MAP_NONBLOCK : c_int = 0x010000;
pub static MAP_STACK : c_int = 0x020000;
}
+ #[cfg(target_os = "linux")]
+ pub mod sysconf {
+ use libc::types::os::arch::c95::c_int;
+
+ pub static _SC_ARG_MAX : c_int = 0;
+ pub static _SC_CHILD_MAX : c_int = 1;
+ pub static _SC_CLK_TCK : c_int = 2;
+ pub static _SC_NGROUPS_MAX : c_int = 3;
+ pub static _SC_OPEN_MAX : c_int = 4;
+ pub static _SC_STREAM_MAX : c_int = 5;
+ pub static _SC_TZNAME_MAX : c_int = 6;
+ pub static _SC_JOB_CONTROL : c_int = 7;
+ pub static _SC_SAVED_IDS : c_int = 8;
+ pub static _SC_REALTIME_SIGNALS : c_int = 9;
+ pub static _SC_PRIORITY_SCHEDULING : c_int = 10;
+ pub static _SC_TIMERS : c_int = 11;
+ pub static _SC_ASYNCHRONOUS_IO : c_int = 12;
+ pub static _SC_PRIORITIZED_IO : c_int = 13;
+ pub static _SC_SYNCHRONIZED_IO : c_int = 14;
+ pub static _SC_FSYNC : c_int = 15;
+ pub static _SC_MAPPED_FILES : c_int = 16;
+ pub static _SC_MEMLOCK : c_int = 17;
+ pub static _SC_MEMLOCK_RANGE : c_int = 18;
+ pub static _SC_MEMORY_PROTECTION : c_int = 19;
+ pub static _SC_MESSAGE_PASSING : c_int = 20;
+ pub static _SC_SEMAPHORES : c_int = 21;
+ pub static _SC_SHARED_MEMORY_OBJECTS : c_int = 22;
+ pub static _SC_AIO_LISTIO_MAX : c_int = 23;
+ pub static _SC_AIO_MAX : c_int = 24;
+ pub static _SC_AIO_PRIO_DELTA_MAX : c_int = 25;
+ pub static _SC_DELAYTIMER_MAX : c_int = 26;
+ pub static _SC_MQ_OPEN_MAX : c_int = 27;
+ pub static _SC_VERSION : c_int = 29;
+ pub static _SC_PAGESIZE : c_int = 30;
+ pub static _SC_RTSIG_MAX : c_int = 31;
+ pub static _SC_SEM_NSEMS_MAX : c_int = 32;
+ pub static _SC_SEM_VALUE_MAX : c_int = 33;
+ pub static _SC_SIGQUEUE_MAX : c_int = 34;
+ pub static _SC_TIMER_MAX : c_int = 35;
+ pub static _SC_BC_BASE_MAX : c_int = 36;
+ pub static _SC_BC_DIM_MAX : c_int = 37;
+ pub static _SC_BC_SCALE_MAX : c_int = 38;
+ pub static _SC_BC_STRING_MAX : c_int = 39;
+ pub static _SC_COLL_WEIGHTS_MAX : c_int = 40;
+ pub static _SC_EXPR_NEST_MAX : c_int = 42;
+ pub static _SC_LINE_MAX : c_int = 43;
+ pub static _SC_RE_DUP_MAX : c_int = 44;
+ pub static _SC_2_VERSION : c_int = 46;
+ pub static _SC_2_C_BIND : c_int = 47;
+ pub static _SC_2_C_DEV : c_int = 48;
+ pub static _SC_2_FORT_DEV : c_int = 49;
+ pub static _SC_2_FORT_RUN : c_int = 50;
+ pub static _SC_2_SW_DEV : c_int = 51;
+ pub static _SC_2_LOCALEDEF : c_int = 52;
+ pub static _SC_2_CHAR_TERM : c_int = 95;
+ pub static _SC_2_C_VERSION : c_int = 96;
+ pub static _SC_2_UPE : c_int = 97;
+ pub static _SC_XBS5_ILP32_OFF32 : c_int = 125;
+ pub static _SC_XBS5_ILP32_OFFBIG : c_int = 126;
+ pub static _SC_XBS5_LPBIG_OFFBIG : c_int = 128;
+ }
+ #[cfg(target_os = "android")]
+ pub mod sysconf {
+ use libc::types::os::arch::c95::c_int;
+
+ pub static _SC_ARG_MAX : c_int = 0;
+ pub static _SC_BC_BASE_MAX : c_int = 1;
+ pub static _SC_BC_DIM_MAX : c_int = 2;
+ pub static _SC_BC_SCALE_MAX : c_int = 3;
+ pub static _SC_BC_STRING_MAX : c_int = 4;
+ pub static _SC_CHILD_MAX : c_int = 5;
+ pub static _SC_CLK_TCK : c_int = 6;
+ pub static _SC_COLL_WEIGHTS_MAX : c_int = 7;
+ pub static _SC_EXPR_NEST_MAX : c_int = 8;
+ pub static _SC_LINE_MAX : c_int = 9;
+ pub static _SC_NGROUPS_MAX : c_int = 10;
+ pub static _SC_OPEN_MAX : c_int = 11;
+ pub static _SC_2_C_BIND : c_int = 13;
+ pub static _SC_2_C_DEV : c_int = 14;
+ pub static _SC_2_C_VERSION : c_int = 15;
+ pub static _SC_2_CHAR_TERM : c_int = 16;
+ pub static _SC_2_FORT_DEV : c_int = 17;
+ pub static _SC_2_FORT_RUN : c_int = 18;
+ pub static _SC_2_LOCALEDEF : c_int = 19;
+ pub static _SC_2_SW_DEV : c_int = 20;
+ pub static _SC_2_UPE : c_int = 21;
+ pub static _SC_2_VERSION : c_int = 22;
+ pub static _SC_JOB_CONTROL : c_int = 23;
+ pub static _SC_SAVED_IDS : c_int = 24;
+ pub static _SC_VERSION : c_int = 25;
+ pub static _SC_RE_DUP_MAX : c_int = 26;
+ pub static _SC_STREAM_MAX : c_int = 27;
+ pub static _SC_TZNAME_MAX : c_int = 28;
+ pub static _SC_PAGESIZE : c_int = 39;
+ }
}
#[cfg(target_os = "freebsd")]
pub static MS_ASYNC : c_int = 0x0001;
pub static MS_INVALIDATE : c_int = 0x0002;
- pub static _SC_ARG_MAX : c_int = 1;
- pub static _SC_CHILD_MAX : c_int = 2;
- pub static _SC_CLK_TCK : c_int = 3;
- pub static _SC_NGROUPS_MAX : c_int = 4;
- pub static _SC_OPEN_MAX : c_int = 5;
- pub static _SC_JOB_CONTROL : c_int = 6;
- pub static _SC_SAVED_IDS : c_int = 7;
- pub static _SC_VERSION : c_int = 8;
- pub static _SC_BC_BASE_MAX : c_int = 9;
- pub static _SC_BC_DIM_MAX : c_int = 10;
- pub static _SC_BC_SCALE_MAX : c_int = 11;
- pub static _SC_BC_STRING_MAX : c_int = 12;
- pub static _SC_COLL_WEIGHTS_MAX : c_int = 13;
- pub static _SC_EXPR_NEST_MAX : c_int = 14;
- pub static _SC_LINE_MAX : c_int = 15;
- pub static _SC_RE_DUP_MAX : c_int = 16;
- pub static _SC_2_VERSION : c_int = 17;
- pub static _SC_2_C_BIND : c_int = 18;
- pub static _SC_2_C_DEV : c_int = 19;
- pub static _SC_2_CHAR_TERM : c_int = 20;
- pub static _SC_2_FORT_DEV : c_int = 21;
- pub static _SC_2_FORT_RUN : c_int = 22;
- pub static _SC_2_LOCALEDEF : c_int = 23;
- pub static _SC_2_SW_DEV : c_int = 24;
- pub static _SC_2_UPE : c_int = 25;
- pub static _SC_STREAM_MAX : c_int = 26;
- pub static _SC_TZNAME_MAX : c_int = 27;
- pub static _SC_ASYNCHRONOUS_IO : c_int = 28;
- pub static _SC_MAPPED_FILES : c_int = 29;
- pub static _SC_MEMLOCK : c_int = 30;
- pub static _SC_MEMLOCK_RANGE : c_int = 31;
- pub static _SC_MEMORY_PROTECTION : c_int = 32;
- pub static _SC_MESSAGE_PASSING : c_int = 33;
- pub static _SC_PRIORITIZED_IO : c_int = 34;
- pub static _SC_PRIORITY_SCHEDULING : c_int = 35;
- pub static _SC_REALTIME_SIGNALS : c_int = 36;
- pub static _SC_SEMAPHORES : c_int = 37;
- pub static _SC_FSYNC : c_int = 38;
- pub static _SC_SHARED_MEMORY_OBJECTS : c_int = 39;
- pub static _SC_SYNCHRONIZED_IO : c_int = 40;
- pub static _SC_TIMERS : c_int = 41;
- pub static _SC_AIO_LISTIO_MAX : c_int = 42;
- pub static _SC_AIO_MAX : c_int = 43;
- pub static _SC_AIO_PRIO_DELTA_MAX : c_int = 44;
- pub static _SC_DELAYTIMER_MAX : c_int = 45;
- pub static _SC_MQ_OPEN_MAX : c_int = 46;
- pub static _SC_PAGESIZE : c_int = 47;
- pub static _SC_RTSIG_MAX : c_int = 48;
- pub static _SC_SEM_NSEMS_MAX : c_int = 49;
- pub static _SC_SEM_VALUE_MAX : c_int = 50;
- pub static _SC_SIGQUEUE_MAX : c_int = 51;
- pub static _SC_TIMER_MAX : c_int = 52;
-
pub static EPERM : c_int = 1;
pub static ENOENT : c_int = 2;
pub static ESRCH : c_int = 3;
pub static MAP_NOSYNC : c_int = 0x0800;
pub static MAP_NOCORE : c_int = 0x020000;
}
+ pub mod sysconf {
+ use libc::types::os::arch::c95::c_int;
+
+ pub static _SC_ARG_MAX : c_int = 1;
+ pub static _SC_CHILD_MAX : c_int = 2;
+ pub static _SC_CLK_TCK : c_int = 3;
+ pub static _SC_NGROUPS_MAX : c_int = 4;
+ pub static _SC_OPEN_MAX : c_int = 5;
+ pub static _SC_JOB_CONTROL : c_int = 6;
+ pub static _SC_SAVED_IDS : c_int = 7;
+ pub static _SC_VERSION : c_int = 8;
+ pub static _SC_BC_BASE_MAX : c_int = 9;
+ pub static _SC_BC_DIM_MAX : c_int = 10;
+ pub static _SC_BC_SCALE_MAX : c_int = 11;
+ pub static _SC_BC_STRING_MAX : c_int = 12;
+ pub static _SC_COLL_WEIGHTS_MAX : c_int = 13;
+ pub static _SC_EXPR_NEST_MAX : c_int = 14;
+ pub static _SC_LINE_MAX : c_int = 15;
+ pub static _SC_RE_DUP_MAX : c_int = 16;
+ pub static _SC_2_VERSION : c_int = 17;
+ pub static _SC_2_C_BIND : c_int = 18;
+ pub static _SC_2_C_DEV : c_int = 19;
+ pub static _SC_2_CHAR_TERM : c_int = 20;
+ pub static _SC_2_FORT_DEV : c_int = 21;
+ pub static _SC_2_FORT_RUN : c_int = 22;
+ pub static _SC_2_LOCALEDEF : c_int = 23;
+ pub static _SC_2_SW_DEV : c_int = 24;
+ pub static _SC_2_UPE : c_int = 25;
+ pub static _SC_STREAM_MAX : c_int = 26;
+ pub static _SC_TZNAME_MAX : c_int = 27;
+ pub static _SC_ASYNCHRONOUS_IO : c_int = 28;
+ pub static _SC_MAPPED_FILES : c_int = 29;
+ pub static _SC_MEMLOCK : c_int = 30;
+ pub static _SC_MEMLOCK_RANGE : c_int = 31;
+ pub static _SC_MEMORY_PROTECTION : c_int = 32;
+ pub static _SC_MESSAGE_PASSING : c_int = 33;
+ pub static _SC_PRIORITIZED_IO : c_int = 34;
+ pub static _SC_PRIORITY_SCHEDULING : c_int = 35;
+ pub static _SC_REALTIME_SIGNALS : c_int = 36;
+ pub static _SC_SEMAPHORES : c_int = 37;
+ pub static _SC_FSYNC : c_int = 38;
+ pub static _SC_SHARED_MEMORY_OBJECTS : c_int = 39;
+ pub static _SC_SYNCHRONIZED_IO : c_int = 40;
+ pub static _SC_TIMERS : c_int = 41;
+ pub static _SC_AIO_LISTIO_MAX : c_int = 42;
+ pub static _SC_AIO_MAX : c_int = 43;
+ pub static _SC_AIO_PRIO_DELTA_MAX : c_int = 44;
+ pub static _SC_DELAYTIMER_MAX : c_int = 45;
+ pub static _SC_MQ_OPEN_MAX : c_int = 46;
+ pub static _SC_PAGESIZE : c_int = 47;
+ pub static _SC_RTSIG_MAX : c_int = 48;
+ pub static _SC_SEM_NSEMS_MAX : c_int = 49;
+ pub static _SC_SEM_VALUE_MAX : c_int = 50;
+ pub static _SC_SIGQUEUE_MAX : c_int = 51;
+ pub static _SC_TIMER_MAX : c_int = 52;
+ }
}
#[cfg(target_os = "macos")]
pub static MS_KILLPAGES : c_int = 0x0004;
pub static MS_DEACTIVATE : c_int = 0x0008;
- pub static _SC_ARG_MAX : c_int = 1;
- pub static _SC_CHILD_MAX : c_int = 2;
- pub static _SC_CLK_TCK : c_int = 3;
- pub static _SC_NGROUPS_MAX : c_int = 4;
- pub static _SC_OPEN_MAX : c_int = 5;
- pub static _SC_JOB_CONTROL : c_int = 6;
- pub static _SC_SAVED_IDS : c_int = 7;
- pub static _SC_VERSION : c_int = 8;
- pub static _SC_BC_BASE_MAX : c_int = 9;
- pub static _SC_BC_DIM_MAX : c_int = 10;
- pub static _SC_BC_SCALE_MAX : c_int = 11;
- pub static _SC_BC_STRING_MAX : c_int = 12;
- pub static _SC_COLL_WEIGHTS_MAX : c_int = 13;
- pub static _SC_EXPR_NEST_MAX : c_int = 14;
- pub static _SC_LINE_MAX : c_int = 15;
- pub static _SC_RE_DUP_MAX : c_int = 16;
- pub static _SC_2_VERSION : c_int = 17;
- pub static _SC_2_C_BIND : c_int = 18;
- pub static _SC_2_C_DEV : c_int = 19;
- pub static _SC_2_CHAR_TERM : c_int = 20;
- pub static _SC_2_FORT_DEV : c_int = 21;
- pub static _SC_2_FORT_RUN : c_int = 22;
- pub static _SC_2_LOCALEDEF : c_int = 23;
- pub static _SC_2_SW_DEV : c_int = 24;
- pub static _SC_2_UPE : c_int = 25;
- pub static _SC_STREAM_MAX : c_int = 26;
- pub static _SC_TZNAME_MAX : c_int = 27;
- pub static _SC_ASYNCHRONOUS_IO : c_int = 28;
- pub static _SC_PAGESIZE : c_int = 29;
- pub static _SC_MEMLOCK : c_int = 30;
- pub static _SC_MEMLOCK_RANGE : c_int = 31;
- pub static _SC_MEMORY_PROTECTION : c_int = 32;
- pub static _SC_MESSAGE_PASSING : c_int = 33;
- pub static _SC_PRIORITIZED_IO : c_int = 34;
- pub static _SC_PRIORITY_SCHEDULING : c_int = 35;
- pub static _SC_REALTIME_SIGNALS : c_int = 36;
- pub static _SC_SEMAPHORES : c_int = 37;
- pub static _SC_FSYNC : c_int = 38;
- pub static _SC_SHARED_MEMORY_OBJECTS : c_int = 39;
- pub static _SC_SYNCHRONIZED_IO : c_int = 40;
- pub static _SC_TIMERS : c_int = 41;
- pub static _SC_AIO_LISTIO_MAX : c_int = 42;
- pub static _SC_AIO_MAX : c_int = 43;
- pub static _SC_AIO_PRIO_DELTA_MAX : c_int = 44;
- pub static _SC_DELAYTIMER_MAX : c_int = 45;
- pub static _SC_MQ_OPEN_MAX : c_int = 46;
- pub static _SC_MAPPED_FILES : c_int = 47;
- pub static _SC_RTSIG_MAX : c_int = 48;
- pub static _SC_SEM_NSEMS_MAX : c_int = 49;
- pub static _SC_SEM_VALUE_MAX : c_int = 50;
- pub static _SC_SIGQUEUE_MAX : c_int = 51;
- pub static _SC_TIMER_MAX : c_int = 52;
- pub static _SC_XBS5_ILP32_OFF32 : c_int = 122;
- pub static _SC_XBS5_ILP32_OFFBIG : c_int = 123;
- pub static _SC_XBS5_LP64_OFF64 : c_int = 124;
- pub static _SC_XBS5_LPBIG_OFFBIG : c_int = 125;
-
pub static EPERM : c_int = 1;
pub static ENOENT : c_int = 2;
pub static ESRCH : c_int = 3;
pub static MAP_NOCACHE : c_int = 0x0400;
pub static MAP_JIT : c_int = 0x0800;
}
+ pub mod sysconf {
+ use libc::types::os::arch::c95::c_int;
+
+ pub static _SC_ARG_MAX : c_int = 1;
+ pub static _SC_CHILD_MAX : c_int = 2;
+ pub static _SC_CLK_TCK : c_int = 3;
+ pub static _SC_NGROUPS_MAX : c_int = 4;
+ pub static _SC_OPEN_MAX : c_int = 5;
+ pub static _SC_JOB_CONTROL : c_int = 6;
+ pub static _SC_SAVED_IDS : c_int = 7;
+ pub static _SC_VERSION : c_int = 8;
+ pub static _SC_BC_BASE_MAX : c_int = 9;
+ pub static _SC_BC_DIM_MAX : c_int = 10;
+ pub static _SC_BC_SCALE_MAX : c_int = 11;
+ pub static _SC_BC_STRING_MAX : c_int = 12;
+ pub static _SC_COLL_WEIGHTS_MAX : c_int = 13;
+ pub static _SC_EXPR_NEST_MAX : c_int = 14;
+ pub static _SC_LINE_MAX : c_int = 15;
+ pub static _SC_RE_DUP_MAX : c_int = 16;
+ pub static _SC_2_VERSION : c_int = 17;
+ pub static _SC_2_C_BIND : c_int = 18;
+ pub static _SC_2_C_DEV : c_int = 19;
+ pub static _SC_2_CHAR_TERM : c_int = 20;
+ pub static _SC_2_FORT_DEV : c_int = 21;
+ pub static _SC_2_FORT_RUN : c_int = 22;
+ pub static _SC_2_LOCALEDEF : c_int = 23;
+ pub static _SC_2_SW_DEV : c_int = 24;
+ pub static _SC_2_UPE : c_int = 25;
+ pub static _SC_STREAM_MAX : c_int = 26;
+ pub static _SC_TZNAME_MAX : c_int = 27;
+ pub static _SC_ASYNCHRONOUS_IO : c_int = 28;
+ pub static _SC_PAGESIZE : c_int = 29;
+ pub static _SC_MEMLOCK : c_int = 30;
+ pub static _SC_MEMLOCK_RANGE : c_int = 31;
+ pub static _SC_MEMORY_PROTECTION : c_int = 32;
+ pub static _SC_MESSAGE_PASSING : c_int = 33;
+ pub static _SC_PRIORITIZED_IO : c_int = 34;
+ pub static _SC_PRIORITY_SCHEDULING : c_int = 35;
+ pub static _SC_REALTIME_SIGNALS : c_int = 36;
+ pub static _SC_SEMAPHORES : c_int = 37;
+ pub static _SC_FSYNC : c_int = 38;
+ pub static _SC_SHARED_MEMORY_OBJECTS : c_int = 39;
+ pub static _SC_SYNCHRONIZED_IO : c_int = 40;
+ pub static _SC_TIMERS : c_int = 41;
+ pub static _SC_AIO_LISTIO_MAX : c_int = 42;
+ pub static _SC_AIO_MAX : c_int = 43;
+ pub static _SC_AIO_PRIO_DELTA_MAX : c_int = 44;
+ pub static _SC_DELAYTIMER_MAX : c_int = 45;
+ pub static _SC_MQ_OPEN_MAX : c_int = 46;
+ pub static _SC_MAPPED_FILES : c_int = 47;
+ pub static _SC_RTSIG_MAX : c_int = 48;
+ pub static _SC_SEM_NSEMS_MAX : c_int = 49;
+ pub static _SC_SEM_VALUE_MAX : c_int = 50;
+ pub static _SC_SIGQUEUE_MAX : c_int = 51;
+ pub static _SC_TIMER_MAX : c_int = 52;
+ pub static _SC_XBS5_ILP32_OFF32 : c_int = 122;
+ pub static _SC_XBS5_ILP32_OFFBIG : c_int = 123;
+ pub static _SC_XBS5_LP64_OFF64 : c_int = 124;
+ pub static _SC_XBS5_LPBIG_OFFBIG : c_int = 125;
+ }
}
}
// doesn't link it correctly on i686, so we're going
// through a C function that mysteriously does work.
pub unsafe fn opendir(dirname: *c_char) -> *DIR {
+ #[fixed_stack_segment]; #[inline(never)];
rust_opendir(dirname)
}
pub unsafe fn readdir(dirp: *DIR) -> *dirent_t {
+ #[fixed_stack_segment]; #[inline(never)];
rust_readdir(dirp)
}
~~~{.rust}
use std::local_data;
-static key_int: local_data::Key<int> = &local_data::Key;
-static key_vector: local_data::Key<~[int]> = &local_data::Key;
+local_data_key!(key_int: int);
+local_data_key!(key_vector: ~[int]);
local_data::set(key_int, 3);
local_data::get(key_int, |opt| assert_eq!(opt, Some(&3)));
use unstable::intrinsics;
$(
- #[inline]
+ #[inline] #[fixed_stack_segment] #[inline(never)]
pub fn $name($( $arg : $arg_ty ),*) -> $rv {
unsafe {
$bound_name($( $arg ),*)
pub mod consts {
// FIXME (requires Issue #1433 to fix): replace with mathematical
// staticants from cmath.
- /// Archimedes' staticant
+ /// Archimedes' constant
pub static pi: f32 = 3.14159265358979323846264338327950288_f32;
/// pi/2.0
r
}
-///
-/// Converts a float to a string in a given radix
-///
-/// # Arguments
-///
-/// * num - The float value
-/// * radix - The base to use
-///
-/// # Failure
-///
-/// Fails if called on a special value like `inf`, `-inf` or `NaN` due to
-/// possible misinterpretation of the result at higher bases. If those values
-/// are expected, use `to_str_radix_special()` instead.
-///
-#[inline]
-pub fn to_str_radix(num: f32, rdx: uint) -> ~str {
- let (r, special) = strconv::float_to_str_common(
- num, rdx, true, strconv::SignNeg, strconv::DigAll);
- if special { fail!("number has a special value, \
- try to_str_radix_special() if those are expected") }
- r
-}
-
///
/// Converts a float to a string in a given radix, and a flag indicating
/// whether it's a special value
}
impl num::ToStrRadix for f32 {
+ /// Converts a float to a string in a given radix
+ ///
+ /// # Arguments
+ ///
+ /// * num - The float value
+ /// * radix - The base to use
+ ///
+ /// # Failure
+ ///
+ /// Fails if called on a special value like `inf`, `-inf` or `NaN` due to
+ /// possible misinterpretation of the result at higher bases. If those values
+ /// are expected, use `to_str_radix_special()` instead.
#[inline]
fn to_str_radix(&self, rdx: uint) -> ~str {
- to_str_radix(*self, rdx)
+ let (r, special) = strconv::float_to_str_common(
+ *self, rdx, true, strconv::SignNeg, strconv::DigAll);
+ if special { fail!("number has a special value, \
+ try to_str_radix_special() if those are expected") }
+ r
}
}
use unstable::intrinsics;
$(
- #[inline]
+ #[inline] #[fixed_stack_segment] #[inline(never)]
pub fn $name($( $arg : $arg_ty ),*) -> $rv {
unsafe {
$bound_name($( $arg ),*)
r
}
-///
-/// Converts a float to a string in a given radix
-///
-/// # Arguments
-///
-/// * num - The float value
-/// * radix - The base to use
-///
-/// # Failure
-///
-/// Fails if called on a special value like `inf`, `-inf` or `NaN` due to
-/// possible misinterpretation of the result at higher bases. If those values
-/// are expected, use `to_str_radix_special()` instead.
-///
-#[inline]
-pub fn to_str_radix(num: f64, rdx: uint) -> ~str {
- let (r, special) = strconv::float_to_str_common(
- num, rdx, true, strconv::SignNeg, strconv::DigAll);
- if special { fail!("number has a special value, \
- try to_str_radix_special() if those are expected") }
- r
-}
-
///
/// Converts a float to a string in a given radix, and a flag indicating
/// whether it's a special value
}
impl num::ToStrRadix for f64 {
+ /// Converts a float to a string in a given radix
+ ///
+ /// # Arguments
+ ///
+ /// * num - The float value
+ /// * radix - The base to use
+ ///
+ /// # Failure
+ ///
+ /// Fails if called on a special value like `inf`, `-inf` or `NaN` due to
+ /// possible misinterpretation of the result at higher bases. If those values
+ /// are expected, use `to_str_radix_special()` instead.
#[inline]
fn to_str_radix(&self, rdx: uint) -> ~str {
- to_str_radix(*self, rdx)
+ let (r, special) = strconv::float_to_str_common(
+ *self, rdx, true, strconv::SignNeg, strconv::DigAll);
+ if special { fail!("number has a special value, \
+ try to_str_radix_special() if those are expected") }
+ r
}
}
r
}
-///
-/// Converts a float to a string in a given radix
-///
-/// # Arguments
-///
-/// * num - The float value
-/// * radix - The base to use
-///
-/// # Failure
-///
-/// Fails if called on a special value like `inf`, `-inf` or `NaN` due to
-/// possible misinterpretation of the result at higher bases. If those values
-/// are expected, use `to_str_radix_special()` instead.
-///
-#[inline]
-pub fn to_str_radix(num: float, radix: uint) -> ~str {
- let (r, special) = strconv::float_to_str_common(
- num, radix, true, strconv::SignNeg, strconv::DigAll);
- if special { fail!("number has a special value, \
- try to_str_radix_special() if those are expected") }
- r
-}
-
///
/// Converts a float to a string in a given radix, and a flag indicating
/// whether it's a special value
}
impl num::ToStrRadix for float {
+ /// Converts a float to a string in a given radix
+ ///
+ /// # Arguments
+ ///
+ /// * num - The float value
+ /// * radix - The base to use
+ ///
+ /// # Failure
+ ///
+ /// Fails if called on a special value like `inf`, `-inf` or `NaN` due to
+ /// possible misinterpretation of the result at higher bases. If those values
+ /// are expected, use `to_str_radix_special()` instead.
#[inline]
fn to_str_radix(&self, radix: uint) -> ~str {
- to_str_radix(*self, radix)
+ let (r, special) = strconv::float_to_str_common(
+ *self, radix, true, strconv::SignNeg, strconv::DigAll);
+ if special { fail!("number has a special value, \
+ try to_str_radix_special() if those are expected") }
+ r
}
}
#[test]
pub fn test_to_str_radix() {
- assert_eq!(to_str_radix(36., 36u), ~"10");
- assert_eq!(to_str_radix(8.125, 2u), ~"1000.001");
+ assert_eq!(36.0f.to_str_radix(36u), ~"10");
+ assert_eq!(8.125f.to_str_radix(2u), ~"1000.001");
}
#[test]
#[allow(non_uppercase_statics)];
use num::{ToStrRadix, FromStrRadix};
-use num::{Zero, One, strconv};
+use num::{CheckedDiv, Zero, One, strconv};
use prelude::*;
use str;
pub static min_value: $T = (-1 as $T) << (bits - 1);
pub static max_value: $T = min_value - 1 as $T;
+impl CheckedDiv for $T {
+ #[inline]
+ fn checked_div(&self, v: &$T) -> Option<$T> {
+ if *v == 0 || (*self == min_value && *v == -1) {
+ None
+ } else {
+ Some(self / *v)
+ }
+ }
+}
+
enum Range { Closed, HalfOpen }
#[inline]
f(buf.slice(0, cur))
}
-/// Convert to a string in base 10.
-#[inline]
-pub fn to_str(num: $T) -> ~str {
- to_str_radix(num, 10u)
-}
-
-/// Convert to a string in a given base.
-#[inline]
-pub fn to_str_radix(num: $T, radix: uint) -> ~str {
- let mut buf: ~[u8] = ~[];
- do strconv::int_to_str_bytes_common(num, radix, strconv::SignNeg) |i| {
- buf.push(i);
- }
- // We know we generated valid utf-8, so we don't need to go through that
- // check.
- unsafe { str::raw::from_bytes_owned(buf) }
-}
-
impl ToStr for $T {
+ /// Convert to a string in base 10.
#[inline]
fn to_str(&self) -> ~str {
- to_str(*self)
+ self.to_str_radix(10)
}
}
impl ToStrRadix for $T {
+ /// Convert to a string in a given base.
#[inline]
fn to_str_radix(&self, radix: uint) -> ~str {
- to_str_radix(*self, radix)
+ let mut buf: ~[u8] = ~[];
+ do strconv::int_to_str_bytes_common(*self, radix, strconv::SignNeg) |i| {
+ buf.push(i);
+ }
+ // We know we generated valid utf-8, so we don't need to go through that
+ // check.
+ unsafe { str::raw::from_bytes_owned(buf) }
}
}
use super::*;
use prelude::*;
+ use int;
use i16;
use i32;
use i64;
#[test]
fn test_to_str() {
- assert_eq!(to_str_radix(0 as $T, 10u), ~"0");
- assert_eq!(to_str_radix(1 as $T, 10u), ~"1");
- assert_eq!(to_str_radix(-1 as $T, 10u), ~"-1");
- assert_eq!(to_str_radix(127 as $T, 16u), ~"7f");
- assert_eq!(to_str_radix(100 as $T, 10u), ~"100");
+ assert_eq!((0 as $T).to_str_radix(10u), ~"0");
+ assert_eq!((1 as $T).to_str_radix(10u), ~"1");
+ assert_eq!((-1 as $T).to_str_radix(10u), ~"-1");
+ assert_eq!((127 as $T).to_str_radix(16u), ~"7f");
+ assert_eq!((100 as $T).to_str_radix(10u), ~"100");
}
#[test]
fn test_int_to_str_overflow() {
let mut i8_val: i8 = 127_i8;
- assert_eq!(i8::to_str(i8_val), ~"127");
+ assert_eq!(i8_val.to_str(), ~"127");
i8_val += 1 as i8;
- assert_eq!(i8::to_str(i8_val), ~"-128");
+ assert_eq!(i8_val.to_str(), ~"-128");
let mut i16_val: i16 = 32_767_i16;
- assert_eq!(i16::to_str(i16_val), ~"32767");
+ assert_eq!(i16_val.to_str(), ~"32767");
i16_val += 1 as i16;
- assert_eq!(i16::to_str(i16_val), ~"-32768");
+ assert_eq!(i16_val.to_str(), ~"-32768");
let mut i32_val: i32 = 2_147_483_647_i32;
- assert_eq!(i32::to_str(i32_val), ~"2147483647");
+ assert_eq!(i32_val.to_str(), ~"2147483647");
i32_val += 1 as i32;
- assert_eq!(i32::to_str(i32_val), ~"-2147483648");
+ assert_eq!(i32_val.to_str(), ~"-2147483648");
let mut i64_val: i64 = 9_223_372_036_854_775_807_i64;
- assert_eq!(i64::to_str(i64_val), ~"9223372036854775807");
+ assert_eq!(i64_val.to_str(), ~"9223372036854775807");
i64_val += 1 as i64;
- assert_eq!(i64::to_str(i64_val), ~"-9223372036854775808");
+ assert_eq!(i64_val.to_str(), ~"-9223372036854775808");
}
#[test]
fn test_range_step_zero_step() {
do range_step(0,10,0) |_i| { true };
}
+
+ #[test]
+ fn test_signed_checked_div() {
+ assert_eq!(10i.checked_div(&2), Some(5));
+ assert_eq!(5i.checked_div(&0), None);
+ assert_eq!(int::min_value.checked_div(&-1), None);
+ }
}
}))
}
}
+pub trait CheckedDiv: Div<Self, Self> {
+ fn checked_div(&self, v: &Self) -> Option<Self>;
+}
+
/// Helper function for testing numeric operations
#[cfg(test)]
pub fn test_num<T:Num + NumCast>(ten: T, two: T) {
mod bench {
use extra::test::BenchHarness;
use rand::{XorShiftRng,RngUtil};
- use uint;
use float;
+ use to_str::ToStr;
#[bench]
fn uint_to_str_rand(bh: &mut BenchHarness) {
let mut rng = XorShiftRng::new();
do bh.iter {
- uint::to_str(rng.gen());
+ rng.gen::<uint>().to_str();
}
}
use num::BitCount;
use num::{ToStrRadix, FromStrRadix};
-use num::{Zero, One, strconv};
+use num::{CheckedDiv, Zero, One, strconv};
use prelude::*;
use str;
pub static min_value: $T = 0 as $T;
pub static max_value: $T = 0 as $T - 1 as $T;
+impl CheckedDiv for $T {
+ #[inline]
+ fn checked_div(&self, v: &$T) -> Option<$T> {
+ if *v == 0 {
+ None
+ } else {
+ Some(self / *v)
+ }
+ }
+}
+
enum Range { Closed, HalfOpen }
#[inline]
/// Unsigned integer modulo operation. Returns the same result as `rem` (`%`).
#[inline]
- fn mod_floor(&self, other: &$T) -> $T { *self / *other }
+ fn mod_floor(&self, other: &$T) -> $T { *self % *other }
- /// Calculates `div_floor` and `modulo_floor` simultaneously
+ /// Calculates `div_floor` and `mod_floor` simultaneously
#[inline]
fn div_mod_floor(&self, other: &$T) -> ($T,$T) {
(*self / *other, *self % *other)
f(buf.slice(0, cur))
}
-/// Convert to a string in base 10.
-#[inline]
-pub fn to_str(num: $T) -> ~str {
- to_str_radix(num, 10u)
-}
-
-/// Convert to a string in a given base.
-#[inline]
-pub fn to_str_radix(num: $T, radix: uint) -> ~str {
- let mut buf = ~[];
- do strconv::int_to_str_bytes_common(num, radix, strconv::SignNone) |i| {
- buf.push(i);
- }
- // We know we generated valid utf-8, so we don't need to go through that
- // check.
- unsafe { str::raw::from_bytes_owned(buf) }
-}
-
impl ToStr for $T {
+ /// Convert to a string in base 10.
#[inline]
fn to_str(&self) -> ~str {
- to_str(*self)
+ self.to_str_radix(10u)
}
}
impl ToStrRadix for $T {
+ /// Convert to a string in a given base.
#[inline]
fn to_str_radix(&self, radix: uint) -> ~str {
- to_str_radix(*self, radix)
+ let mut buf = ~[];
+ do strconv::int_to_str_bytes_common(*self, radix, strconv::SignNone) |i| {
+ buf.push(i);
+ }
+ // We know we generated valid utf-8, so we don't need to go through that
+ // check.
+ unsafe { str::raw::from_bytes_owned(buf) }
}
}
use u32;
use u64;
use u8;
- use uint;
#[test]
fn test_num() {
assert_eq!((3 as $T).clamp(&(2 as $T), &(4 as $T)), 3 as $T);
}
+ #[test]
+ fn test_div_mod_floor() {
+ assert_eq!((10 as $T).div_floor(&(3 as $T)), 3 as $T);
+ assert_eq!((10 as $T).mod_floor(&(3 as $T)), 1 as $T);
+ assert_eq!((10 as $T).div_mod_floor(&(3 as $T)), (3 as $T, 1 as $T));
+ assert_eq!((5 as $T).div_floor(&(5 as $T)), 1 as $T);
+ assert_eq!((5 as $T).mod_floor(&(5 as $T)), 0 as $T);
+ assert_eq!((5 as $T).div_mod_floor(&(5 as $T)), (1 as $T, 0 as $T));
+ assert_eq!((3 as $T).div_floor(&(7 as $T)), 0 as $T);
+ assert_eq!((3 as $T).mod_floor(&(7 as $T)), 3 as $T);
+ assert_eq!((3 as $T).div_mod_floor(&(7 as $T)), (0 as $T, 3 as $T));
+ }
+
#[test]
fn test_gcd() {
assert_eq!((10 as $T).gcd(&2), 2 as $T);
#[test]
pub fn test_to_str() {
- assert_eq!(to_str_radix(0 as $T, 10u), ~"0");
- assert_eq!(to_str_radix(1 as $T, 10u), ~"1");
- assert_eq!(to_str_radix(2 as $T, 10u), ~"2");
- assert_eq!(to_str_radix(11 as $T, 10u), ~"11");
- assert_eq!(to_str_radix(11 as $T, 16u), ~"b");
- assert_eq!(to_str_radix(255 as $T, 16u), ~"ff");
- assert_eq!(to_str_radix(0xff as $T, 10u), ~"255");
+ assert_eq!((0 as $T).to_str_radix(10u), ~"0");
+ assert_eq!((1 as $T).to_str_radix(10u), ~"1");
+ assert_eq!((2 as $T).to_str_radix(10u), ~"2");
+ assert_eq!((11 as $T).to_str_radix(10u), ~"11");
+ assert_eq!((11 as $T).to_str_radix(16u), ~"b");
+ assert_eq!((255 as $T).to_str_radix(16u), ~"ff");
+ assert_eq!((0xff as $T).to_str_radix(10u), ~"255");
}
#[test]
#[test]
fn test_uint_to_str_overflow() {
let mut u8_val: u8 = 255_u8;
- assert_eq!(u8::to_str(u8_val), ~"255");
+ assert_eq!(u8_val.to_str(), ~"255");
u8_val += 1 as u8;
- assert_eq!(u8::to_str(u8_val), ~"0");
+ assert_eq!(u8_val.to_str(), ~"0");
let mut u16_val: u16 = 65_535_u16;
- assert_eq!(u16::to_str(u16_val), ~"65535");
+ assert_eq!(u16_val.to_str(), ~"65535");
u16_val += 1 as u16;
- assert_eq!(u16::to_str(u16_val), ~"0");
+ assert_eq!(u16_val.to_str(), ~"0");
let mut u32_val: u32 = 4_294_967_295_u32;
- assert_eq!(u32::to_str(u32_val), ~"4294967295");
+ assert_eq!(u32_val.to_str(), ~"4294967295");
u32_val += 1 as u32;
- assert_eq!(u32::to_str(u32_val), ~"0");
+ assert_eq!(u32_val.to_str(), ~"0");
let mut u64_val: u64 = 18_446_744_073_709_551_615_u64;
- assert_eq!(u64::to_str(u64_val), ~"18446744073709551615");
+ assert_eq!(u64_val.to_str(), ~"18446744073709551615");
u64_val += 1 as u64;
- assert_eq!(u64::to_str(u64_val), ~"0");
+ assert_eq!(u64_val.to_str(), ~"0");
}
#[test]
#[should_fail]
#[ignore(cfg(windows))]
pub fn to_str_radix1() {
- uint::to_str_radix(100u, 1u);
+ 100u.to_str_radix(1u);
}
#[test]
#[should_fail]
#[ignore(cfg(windows))]
pub fn to_str_radix37() {
- uint::to_str_radix(100u, 37u);
+ 100u.to_str_radix(37u);
}
#[test]
fn test_range_step_zero_step_down() {
do range_step(0,-10,0) |_i| { true };
}
+
+ #[test]
+ fn test_unsigned_checked_div() {
+ assert_eq!(10u.checked_div(&2), Some(5));
+ assert_eq!(5u.checked_div(&0), None);
+ }
}
}))
}
/// An iterator that yields either one or zero elements
+#[deriving(Clone, DeepClone)]
pub struct OptionIterator<A> {
priv opt: Option<A>
}
/// Delegates to the libc close() function, returning the same return value.
pub fn close(fd: c_int) -> c_int {
+ #[fixed_stack_segment]; #[inline(never)];
unsafe {
libc::close(fd)
}
static BUF_BYTES : uint = 2048u;
pub fn getcwd() -> Path {
+ #[fixed_stack_segment]; #[inline(never)];
let mut buf = [0 as libc::c_char, ..BUF_BYTES];
do buf.as_mut_buf |buf, len| {
unsafe {
pub fn fill_utf16_buf_and_decode(f: &fn(*mut u16, DWORD) -> DWORD)
-> Option<~str> {
+ #[fixed_stack_segment]; #[inline(never)];
+
unsafe {
let mut n = TMPBUF_SZ as DWORD;
let mut res = None;
}
}
+#[cfg(stage0)]
+mod macro_hack {
+#[macro_escape];
+macro_rules! externfn(
+ (fn $name:ident ()) => (
+ extern {
+ fn $name();
+ }
+ )
+)
+}
+
/*
Accessing environment variables is not generally threadsafe.
Serialize access through a global lock.
};
}
- extern {
- #[fast_ffi]
- fn rust_take_env_lock();
- #[fast_ffi]
- fn rust_drop_env_lock();
- }
+ externfn!(fn rust_take_env_lock());
+ externfn!(fn rust_drop_env_lock());
}
/// Returns a vector of (variable, value) pairs for all the environment
unsafe {
#[cfg(windows)]
unsafe fn get_env_pairs() -> ~[~str] {
+ #[fixed_stack_segment]; #[inline(never)];
+
use libc::funcs::extra::kernel32::{
GetEnvironmentStringsA,
FreeEnvironmentStringsA
}
#[cfg(unix)]
unsafe fn get_env_pairs() -> ~[~str] {
+ #[fixed_stack_segment]; #[inline(never)];
+
extern {
fn rust_env_pairs() -> **libc::c_char;
}
/// Fetches the environment variable `n` from the current process, returning
/// None if the variable isn't set.
pub fn getenv(n: &str) -> Option<~str> {
+ #[fixed_stack_segment]; #[inline(never)];
unsafe {
do with_env_lock {
let s = do n.with_c_str |buf| {
/// Fetches the environment variable `n` from the current process, returning
/// None if the variable isn't set.
pub fn getenv(n: &str) -> Option<~str> {
+ #[fixed_stack_segment]; #[inline(never)];
+
unsafe {
do with_env_lock {
use os::win32::{as_utf16_p, fill_utf16_buf_and_decode};
/// Sets the environment variable `n` to the value `v` for the currently running
/// process
pub fn setenv(n: &str, v: &str) {
+ #[fixed_stack_segment]; #[inline(never)];
unsafe {
do with_env_lock {
do n.with_c_str |nbuf| {
/// Sets the environment variable `n` to the value `v` for the currently running
/// process
pub fn setenv(n: &str, v: &str) {
+ #[fixed_stack_segment]; #[inline(never)];
+
unsafe {
do with_env_lock {
use os::win32::as_utf16_p;
pub fn unsetenv(n: &str) {
#[cfg(unix)]
fn _unsetenv(n: &str) {
+ #[fixed_stack_segment]; #[inline(never)];
unsafe {
do with_env_lock {
do n.with_c_str |nbuf| {
}
#[cfg(windows)]
fn _unsetenv(n: &str) {
+ #[fixed_stack_segment]; #[inline(never)];
unsafe {
do with_env_lock {
use os::win32::as_utf16_p;
}
pub fn fdopen(fd: c_int) -> *FILE {
+ #[fixed_stack_segment]; #[inline(never)];
do "r".with_c_str |modebuf| {
unsafe {
libc::fdopen(fd, modebuf)
#[cfg(windows)]
pub fn fsync_fd(fd: c_int, _level: io::fsync::Level) -> c_int {
+ #[fixed_stack_segment]; #[inline(never)];
unsafe {
use libc::funcs::extra::msvcrt::*;
return commit(fd);
#[cfg(target_os = "linux")]
#[cfg(target_os = "android")]
pub fn fsync_fd(fd: c_int, level: io::fsync::Level) -> c_int {
+ #[fixed_stack_segment]; #[inline(never)];
unsafe {
use libc::funcs::posix01::unistd::*;
match level {
#[cfg(target_os = "macos")]
pub fn fsync_fd(fd: c_int, level: io::fsync::Level) -> c_int {
+ #[fixed_stack_segment]; #[inline(never)];
+
unsafe {
use libc::consts::os::extra::*;
use libc::funcs::posix88::fcntl::*;
#[cfg(target_os = "freebsd")]
pub fn fsync_fd(fd: c_int, _l: io::fsync::Level) -> c_int {
+ #[fixed_stack_segment]; #[inline(never)];
+
unsafe {
use libc::funcs::posix01::unistd::*;
return fsync(fd);
#[cfg(unix)]
pub fn pipe() -> Pipe {
+ #[fixed_stack_segment]; #[inline(never)];
unsafe {
let mut fds = Pipe {input: 0 as c_int,
out: 0 as c_int };
#[cfg(windows)]
pub fn pipe() -> Pipe {
+ #[fixed_stack_segment]; #[inline(never)];
unsafe {
// Windows pipes work subtly differently than unix pipes, and their
// inheritance has to be handled in a different way that I do not
// fully understand. Here we explicitly make the pipe non-inheritable,
// which means to pass it to a subprocess they need to be duplicated
- // first, as in core::run.
+ // first, as in std::run.
let mut fds = Pipe {input: 0 as c_int,
out: 0 as c_int };
let res = libc::pipe(&mut fds.input, 1024 as ::libc::c_uint,
}
fn dup2(src: c_int, dst: c_int) -> c_int {
+ #[fixed_stack_segment]; #[inline(never)];
unsafe {
libc::dup2(src, dst)
}
#[cfg(target_os = "freebsd")]
fn load_self() -> Option<~str> {
+ #[fixed_stack_segment]; #[inline(never)];
unsafe {
use libc::funcs::bsd44::*;
use libc::consts::os::extra::*;
#[cfg(target_os = "linux")]
#[cfg(target_os = "android")]
fn load_self() -> Option<~str> {
+ #[fixed_stack_segment]; #[inline(never)];
unsafe {
use libc::funcs::posix01::unistd::readlink;
#[cfg(target_os = "macos")]
fn load_self() -> Option<~str> {
+ #[fixed_stack_segment]; #[inline(never)];
unsafe {
do fill_charp_buf() |buf, sz| {
let mut sz = sz as u32;
#[cfg(windows)]
fn load_self() -> Option<~str> {
+ #[fixed_stack_segment]; #[inline(never)];
unsafe {
use os::win32::fill_utf16_buf_and_decode;
do fill_utf16_buf_and_decode() |buf, sz| {
/// Indicates whether a path represents a directory
pub fn path_is_dir(p: &Path) -> bool {
+ #[fixed_stack_segment]; #[inline(never)];
unsafe {
do p.with_c_str |buf| {
rustrt::rust_path_is_dir(buf) != 0 as c_int
/// Indicates whether a path exists
pub fn path_exists(p: &Path) -> bool {
+ #[fixed_stack_segment]; #[inline(never)];
unsafe {
do p.with_c_str |buf| {
rustrt::rust_path_exists(buf) != 0 as c_int
#[cfg(windows)]
fn mkdir(p: &Path, _mode: c_int) -> bool {
+ #[fixed_stack_segment]; #[inline(never)];
unsafe {
use os::win32::as_utf16_p;
// FIXME: turn mode into something useful? #2623
#[cfg(unix)]
fn mkdir(p: &Path, mode: c_int) -> bool {
+ #[fixed_stack_segment]; #[inline(never)];
do p.with_c_str |buf| {
unsafe {
libc::mkdir(buf, mode as libc::mode_t) == (0 as c_int)
#[cfg(target_os = "freebsd")]
#[cfg(target_os = "macos")]
unsafe fn get_list(p: &Path) -> ~[~str] {
+ #[fixed_stack_segment]; #[inline(never)];
use libc::{dirent_t};
use libc::{opendir, readdir, closedir};
extern {
}
#[cfg(windows)]
unsafe fn get_list(p: &Path) -> ~[~str] {
+ #[fixed_stack_segment]; #[inline(never)];
use libc::consts::os::extra::INVALID_HANDLE_VALUE;
use libc::{wcslen, free};
use libc::funcs::extra::kernel32::{
#[cfg(windows)]
fn rmdir(p: &Path) -> bool {
+ #[fixed_stack_segment]; #[inline(never)];
unsafe {
use os::win32::as_utf16_p;
return do as_utf16_p(p.to_str()) |buf| {
#[cfg(unix)]
fn rmdir(p: &Path) -> bool {
+ #[fixed_stack_segment]; #[inline(never)];
do p.with_c_str |buf| {
unsafe {
libc::rmdir(buf) == (0 as c_int)
#[cfg(windows)]
fn chdir(p: &Path) -> bool {
+ #[fixed_stack_segment]; #[inline(never)];
unsafe {
use os::win32::as_utf16_p;
return do as_utf16_p(p.to_str()) |buf| {
#[cfg(unix)]
fn chdir(p: &Path) -> bool {
+ #[fixed_stack_segment]; #[inline(never)];
do p.with_c_str |buf| {
unsafe {
libc::chdir(buf) == (0 as c_int)
#[cfg(windows)]
fn do_copy_file(from: &Path, to: &Path) -> bool {
+ #[fixed_stack_segment]; #[inline(never)];
unsafe {
use os::win32::as_utf16_p;
return do as_utf16_p(from.to_str()) |fromp| {
#[cfg(unix)]
fn do_copy_file(from: &Path, to: &Path) -> bool {
+ #[fixed_stack_segment]; #[inline(never)];
unsafe {
let istream = do from.with_c_str |fromp| {
do "rb".with_c_str |modebuf| {
#[cfg(windows)]
fn unlink(p: &Path) -> bool {
+ #[fixed_stack_segment]; #[inline(never)];
unsafe {
use os::win32::as_utf16_p;
return do as_utf16_p(p.to_str()) |buf| {
#[cfg(unix)]
fn unlink(p: &Path) -> bool {
+ #[fixed_stack_segment]; #[inline(never)];
unsafe {
do p.with_c_str |buf| {
libc::unlink(buf) == (0 as c_int)
#[cfg(target_os = "macos")]
#[cfg(target_os = "freebsd")]
fn errno_location() -> *c_int {
+ #[fixed_stack_segment]; #[inline(never)];
#[nolink]
extern {
fn __error() -> *c_int;
#[cfg(target_os = "linux")]
#[cfg(target_os = "android")]
fn errno_location() -> *c_int {
+ #[fixed_stack_segment]; #[inline(never)];
#[nolink]
extern {
fn __errno_location() -> *c_int;
#[cfg(windows)]
/// Returns the platform-specific value of errno
pub fn errno() -> uint {
+ #[fixed_stack_segment]; #[inline(never)];
use libc::types::os::arch::extra::DWORD;
#[link_name = "kernel32"]
#[cfg(target_os = "freebsd")]
fn strerror_r(errnum: c_int, buf: *mut c_char, buflen: size_t)
-> c_int {
+ #[fixed_stack_segment]; #[inline(never)];
+
#[nolink]
extern {
fn strerror_r(errnum: c_int, buf: *mut c_char, buflen: size_t)
// So we just use __xpg_strerror_r which is always POSIX compliant
#[cfg(target_os = "linux")]
fn strerror_r(errnum: c_int, buf: *mut c_char, buflen: size_t) -> c_int {
+ #[fixed_stack_segment]; #[inline(never)];
#[nolink]
extern {
fn __xpg_strerror_r(errnum: c_int,
#[cfg(windows)]
fn strerror() -> ~str {
+ #[fixed_stack_segment]; #[inline(never)];
+
use libc::types::os::arch::extra::DWORD;
use libc::types::os::arch::extra::LPSTR;
use libc::types::os::arch::extra::LPVOID;
*/
#[cfg(target_os = "macos")]
pub fn real_args() -> ~[~str] {
+ #[fixed_stack_segment]; #[inline(never)];
+
unsafe {
let (argc, argv) = (*_NSGetArgc() as c_int,
*_NSGetArgv() as **c_char);
#[cfg(windows)]
pub fn real_args() -> ~[~str] {
+ #[fixed_stack_segment]; #[inline(never)];
+
let mut nArgs: c_int = 0;
let lpArgCount: *mut c_int = &mut nArgs;
let lpCmdLine = unsafe { GetCommandLineW() };
#[cfg(target_os = "freebsd")]
#[cfg(target_os = "macos")]
pub fn glob(pattern: &str) -> ~[Path] {
+ #[fixed_stack_segment]; #[inline(never)];
+
#[cfg(target_os = "linux")]
#[cfg(target_os = "android")]
fn default_glob_t () -> libc::glob_t {
#[cfg(unix)]
pub fn page_size() -> uint {
+ #[fixed_stack_segment]; #[inline(never)];
+
unsafe {
libc::sysconf(libc::_SC_PAGESIZE) as uint
}
#[cfg(windows)]
pub fn page_size() -> uint {
+ #[fixed_stack_segment]; #[inline(never)];
+
unsafe {
let mut info = libc::SYSTEM_INFO::new();
libc::GetSystemInfo(&mut info);
#[cfg(unix)]
impl MemoryMap {
pub fn new(min_len: uint, options: ~[MapOption]) -> Result<~MemoryMap, MapError> {
+ #[fixed_stack_segment]; #[inline(never)];
+
use libc::off_t;
let mut addr: *c_void = ptr::null();
#[cfg(unix)]
impl Drop for MemoryMap {
fn drop(&self) {
+ #[fixed_stack_segment]; #[inline(never)];
+
unsafe {
match libc::munmap(self.data as *c_void, self.len) {
0 => (),
#[cfg(windows)]
impl MemoryMap {
pub fn new(min_len: uint, options: ~[MapOption]) -> Result<~MemoryMap, MapError> {
+ #[fixed_stack_segment]; #[inline(never)];
+
use libc::types::os::arch::extra::{LPVOID, DWORD, SIZE_T, HANDLE};
let mut lpAddress: LPVOID = ptr::mut_null();
#[cfg(windows)]
impl Drop for MemoryMap {
fn drop(&self) {
+ #[fixed_stack_segment]; #[inline(never)];
+
use libc::types::os::arch::extra::{LPCVOID, HANDLE};
unsafe {
#[test]
fn copy_file_ok() {
+ #[fixed_stack_segment]; #[inline(never)];
+
unsafe {
let tempdir = getcwd(); // would like to use $TMPDIR,
// doesn't seem to work on Linux
#[test]
fn memory_map_file() {
+ #[fixed_stack_segment]; #[inline(never)];
+
use result::{Ok, Err};
use os::*;
use libc::*;
#[cfg(unix)]
+ #[fixed_stack_segment]
+ #[inline(never)]
fn lseek_(fd: c_int, size: uint) {
unsafe {
assert!(lseek(fd, size as off_t, SEEK_SET) == size as off_t);
}
}
#[cfg(windows)]
+ #[fixed_stack_segment]
+ #[inline(never)]
fn lseek_(fd: c_int, size: uint) {
unsafe {
assert!(lseek(fd, size as c_long, SEEK_SET) == size as c_long);
#[cfg(target_os = "win32")]
impl WindowsPath {
pub fn stat(&self) -> Option<libc::stat> {
+ #[fixed_stack_segment]; #[inline(never)];
do self.with_c_str |buf| {
let mut st = stat::arch::default_stat();
match unsafe { libc::stat(buf, &mut st) } {
#[cfg(not(target_os = "win32"))]
impl PosixPath {
pub fn stat(&self) -> Option<libc::stat> {
+ #[fixed_stack_segment]; #[inline(never)];
do self.with_c_str |buf| {
let mut st = stat::arch::default_stat();
match unsafe { libc::stat(buf as *libc::c_char, &mut st) } {
#[cfg(unix)]
impl PosixPath {
pub fn lstat(&self) -> Option<libc::stat> {
+ #[fixed_stack_segment]; #[inline(never)];
do self.with_c_str |buf| {
let mut st = stat::arch::default_stat();
match unsafe { libc::lstat(buf, &mut st) } {
}
pub fn extract_drive_prefix(s: &str) -> Option<(~str,~str)> {
+ #[fixed_stack_segment]; #[inline(never)];
+
unsafe {
if (s.len() > 1 &&
libc::isalpha(s[0] as libc::c_int) != 0 &&
pub use container::{Container, Mutable, Map, MutableMap, Set, MutableSet};
pub use hash::Hash;
pub use iter::Times;
-pub use iterator::Extendable;
-pub use iterator::{Iterator, DoubleEndedIterator};
-pub use iterator::{ClonableIterator, OrdIterator};
+pub use iterator::{FromIterator, Extendable};
+pub use iterator::{Iterator, DoubleEndedIterator, RandomAccessIterator, ClonableIterator};
+pub use iterator::{OrdIterator, MutableDoubleEndedIterator};
pub use num::{Num, NumCast, CheckedAdd, CheckedSub, CheckedMul};
pub use num::{Orderable, Signed, Unsigned, Round};
pub use num::{Algebraic, Trigonometric, Exponential, Hyperbolic};
pub use num::{Integer, Fractional, Real, RealExt};
pub use num::{Bitwise, BitCount, Bounded};
-pub use num::{Primitive, Int, Float};
+pub use num::{Primitive, Int, Float, ToStrRadix};
pub use path::GenericPath;
pub use path::Path;
pub use path::PosixPath;
passing to the provided callback function
SAFETY NOTE: This will only work with a null-terminated
- pointer array. Barely less-dodgey Pointer Arithmetic.
+ pointer array. Barely less-dodgy Pointer Arithmetic.
Dragons be here.
*/
pub unsafe fn array_each<T>(arr: **T, cb: &fn(*T)) {
one, two, three
];
- do arr.as_imm_buf |arr_ptr, arr_len| {
+ do arr.as_imm_buf |arr_ptr, _| {
let mut ctr = 0;
let mut iteration_count = 0;
do array_each(arr_ptr) |e| {
/// Create a weak random number generator with a default algorithm and seed.
///
-/// It returns the fatest `Rng` algorithm currently available in Rust without
+/// It returns the fastest `Rng` algorithm currently available in Rust without
/// consideration for cryptography or security. If you require a specifically
/// seeded `Rng` for consistency over time you should pick one algorithm and
/// create the `Rng` yourself.
}
impl XorShiftRng {
- /// Create an xor shift random number generator with a default seed.
+ /// Create an xor shift random number generator with a random seed.
pub fn new() -> XorShiftRng {
- // constants taken from http://en.wikipedia.org/wiki/Xorshift
- XorShiftRng::new_seeded(123456789u32,
- 362436069u32,
- 521288629u32,
- 88675123u32)
+ #[fixed_stack_segment]; #[inline(never)];
+
+ // generate seeds the same way as seed(), except we have a spceific size
+ let mut s = [0u8, ..16];
+ loop {
+ do s.as_mut_buf |p, sz| {
+ unsafe {
+ rustrt::rand_gen_seed(p, sz as size_t);
+ }
+ }
+ if !s.iter().all(|x| *x == 0) {
+ break;
+ }
+ }
+ let s: &[u32, ..4] = unsafe { cast::transmute(&s) };
+ XorShiftRng::new_seeded(s[0], s[1], s[2], s[3])
}
/**
/// Create a new random seed.
pub fn seed() -> ~[u8] {
+ #[fixed_stack_segment]; #[inline(never)];
+
unsafe {
let n = rustrt::rand_seed_size() as uint;
let mut s = vec::from_elem(n, 0_u8);
#[test]
fn compare_isaac_implementation() {
+ #[fixed_stack_segment]; #[inline(never)];
+
// This is to verify that the implementation of the ISAAC rng is
// correct (i.e. matches the output of the upstream implementation,
// which is in the runtime)
/// # Example
///
/// ~~~
-/// use core::rand::distributions::StandardNormal;
+/// use std::rand::distributions::StandardNormal;
///
/// fn main() {
/// let normal = 2.0 + (*rand::random::<StandardNormal>()) * 3.0;
let mut x = 1.0f64;
let mut y = 0.0f64;
- // XXX infinities?
+ // FIXME #7755: infinities?
while -2.0 * y < x * x {
x = rng.gen::<f64>().ln() / ziggurat_tables::ZIG_NORM_R;
y = rng.gen::<f64>().ln();
/// # Example
///
/// ~~~
-/// use core::rand::distributions::Exp1;
+/// use std::rand::distributions::Exp1;
///
/// fn main() {
/// let exp2 = (*rand::random::<Exp1>()) * 0.5;
/// `Result` is a type that represents either success (`Ok`) or failure (`Err`).
///
-/// In order to provide informative error messages, `E` is reqired to implement `ToStr`.
+/// In order to provide informative error messages, `E` is required to implement `ToStr`.
/// It is further recommended for `E` to be a descriptive error type, eg a `enum` for
/// all possible errors cases.
#[deriving(Clone, Eq)]
//! Only valid to call on linux. Mac and Windows use syscalls to
//! discover the command line arguments.
//!
-//! XXX: Would be nice for this to not exist.
-//! XXX: This has a lot of C glue for lack of globals.
+//! FIXME #7756: Would be nice for this to not exist.
+//! FIXME #7756: This has a lot of C glue for lack of globals.
use option::Option;
args
}
- extern {
- fn rust_take_global_args_lock();
- fn rust_drop_global_args_lock();
- fn rust_get_global_args_ptr() -> *mut Option<~~[~str]>;
+ #[cfg(stage0)]
+ mod macro_hack {
+ #[macro_escape];
+ macro_rules! externfn(
+ (fn $name:ident () $(-> $ret_ty:ty),*) => (
+ extern {
+ fn $name() $(-> $ret_ty),*;
+ }
+ )
+ )
}
+ externfn!(fn rust_take_global_args_lock())
+ externfn!(fn rust_drop_global_args_lock())
+ externfn!(fn rust_get_global_args_ptr() -> *mut Option<~~[~str]>)
+
#[cfg(test)]
mod tests {
use option::{Some, None};
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+use cell::Cell;
use c_str::ToCStr;
use cast::transmute;
use libc::{c_char, size_t, STDERR_FILENO};
use io::{Writer, WriterUtil};
use option::{Option, None, Some};
use uint;
+use rt::env;
+use rt::local::Local;
+use rt::task::Task;
use str;
use str::{OwnedStr, StrSlice};
use sys;
static ALL_BITS: uint = FROZEN_BIT | MUT_BIT;
#[deriving(Eq)]
-struct BorrowRecord {
+pub struct BorrowRecord {
box: *mut raw::Box<()>,
file: *c_char,
line: size_t
}
fn try_take_task_borrow_list() -> Option<~[BorrowRecord]> {
- // XXX
- None
+ do Local::borrow::<Task, Option<~[BorrowRecord]>> |task| {
+ task.borrow_list.take()
+ }
}
-fn swap_task_borrow_list(_f: &fn(~[BorrowRecord]) -> ~[BorrowRecord]) {
- // XXX
+fn swap_task_borrow_list(f: &fn(~[BorrowRecord]) -> ~[BorrowRecord]) {
+ let borrows = match try_take_task_borrow_list() {
+ Some(l) => l,
+ None => ~[]
+ };
+ let borrows = f(borrows);
+ let borrows = Cell::new(borrows);
+ do Local::borrow::<Task, ()> |task| {
+ task.borrow_list = Some(borrows.take());
+ }
}
-pub unsafe fn clear_task_borrow_list() {
+pub fn clear_task_borrow_list() {
// pub because it is used by the box annihilator.
let _ = try_take_task_borrow_list();
}
//! A useful debugging function that prints a pointer + tag + newline
//! without allocating memory.
- // XXX
- if false {
+ if ENABLE_DEBUG && env::debug_borrow() {
debug_borrow_slow(tag, p, old_bits, new_bits, filename, line);
}
}
unsafe fn write_cstr(&self, p: *c_char) {
+ #[fixed_stack_segment]; #[inline(never)];
use libc::strlen;
use vec;
payload: Option<T>,
}
-/// A one-shot channel.
+// A one-shot channel.
pub struct ChanOne<T> {
void_packet: *mut Void,
suppress_finalize: bool
}
}
-// XXX: Need better name
+// FIXME #7760: Need better name
type MegaPipe<T> = (SharedPort<T>, SharedChan<T>);
pub fn megapipe<T: Send>() -> MegaPipe<T> {
use rt::test::*;
use cell::Cell;
use iter::Times;
+ use rt::util;
#[test]
fn oneshot_single_thread_close_port_first() {
#[test]
fn oneshot_multi_thread_close_stress() {
+ if util::limit_thread_creation_due_to_osx_and_valgrind() { return; }
do stress_factor().times {
do run_in_newsched_task {
let (port, chan) = oneshot::<int>();
#[test]
fn oneshot_multi_thread_send_close_stress() {
+ if util::limit_thread_creation_due_to_osx_and_valgrind() { return; }
do stress_factor().times {
do run_in_newsched_task {
let (port, chan) = oneshot::<int>();
#[test]
fn oneshot_multi_thread_recv_close_stress() {
+ if util::limit_thread_creation_due_to_osx_and_valgrind() { return; }
do stress_factor().times {
do run_in_newsched_task {
let (port, chan) = oneshot::<int>();
#[test]
fn oneshot_multi_thread_send_recv_stress() {
+ if util::limit_thread_creation_due_to_osx_and_valgrind() { return; }
do stress_factor().times {
do run_in_newsched_task {
let (port, chan) = oneshot::<~int>();
#[test]
fn stream_send_recv_stress() {
+ if util::limit_thread_creation_due_to_osx_and_valgrind() { return; }
do stress_factor().times {
do run_in_mt_newsched_task {
let (port, chan) = stream::<~int>();
#[test]
fn shared_chan_stress() {
+ if util::limit_thread_creation_due_to_osx_and_valgrind() { return; }
do run_in_mt_newsched_task {
let (port, chan) = stream();
let chan = SharedChan::new(chan);
#[test]
fn shared_port_stress() {
+ if util::limit_thread_creation_due_to_osx_and_valgrind() { return; }
do run_in_mt_newsched_task {
- // XXX: Removing these type annotations causes an ICE
- let (end_port, end_chan) = stream::<()>();
- let (port, chan) = stream::<()>();
+ let (end_port, end_chan) = stream();
+ let (port, chan) = stream();
let end_chan = SharedChan::new(end_chan);
let port = SharedPort::new(port);
let total = stress_factor() + 100;
use rand;
use rand::RngUtil;
+ if util::limit_thread_creation_due_to_osx_and_valgrind() { return; }
+
do run_in_mt_newsched_task {
let (end_port, end_chan) = stream::<()>();
let end_chan = SharedChan::new(end_chan);
use cast::{transmute, transmute_mut_unsafe,
transmute_region, transmute_mut_region};
-// XXX: Registers is boxed so that it is 16-byte aligned, for storing
+// FIXME #7761: Registers is boxed so that it is 16-byte aligned, for storing
// SSE regs. It would be marginally better not to do this. In C++ we
// use an attribute on a struct.
-// XXX: It would be nice to define regs as `~Option<Registers>` since
+// FIXME #7761: It would be nice to define regs as `~Option<Registers>` since
// the registers are sometimes empty, but the discriminant would
// then misalign the regs again.
pub struct Context {
/// Create a new context that will resume execution by running ~fn()
pub fn new(start: ~fn(), stack: &mut StackSegment) -> Context {
- // XXX: Putting main into a ~ so it's a thin pointer and can
+ // FIXME #7767: Putting main into a ~ so it's a thin pointer and can
// be passed to the spawn function. Another unfortunate
// allocation
let start = ~start;
}
}
-// XXX: ptr::offset is positive ints only
+// ptr::mut_offset is positive ints only
#[inline]
pub fn mut_offset<T>(ptr: *mut T, count: int) -> *mut T {
use std::sys::size_of;
// They are expected to be initialized once then left alone.
static mut MIN_STACK: uint = 2000000;
+static mut DEBUG_BORROW: bool = false;
pub fn init() {
unsafe {
},
None => ()
}
+ match os::getenv("RUST_DEBUG_BORROW") {
+ Some(_) => DEBUG_BORROW = true,
+ None => ()
+ }
}
}
pub fn min_stack() -> uint {
unsafe { MIN_STACK }
}
+
+pub fn debug_borrow() -> bool {
+ unsafe { DEBUG_BORROW }
+}
}
/// A wrapper around libc::malloc, aborting on out-of-memory
-#[inline]
pub unsafe fn malloc_raw(size: uint) -> *c_void {
+ #[fixed_stack_segment]; #[inline(never)];
+
let p = malloc(size as size_t);
if p.is_null() {
// we need a non-allocating way to print an error here
}
/// A wrapper around libc::realloc, aborting on out-of-memory
-#[inline]
pub unsafe fn realloc_raw(ptr: *mut c_void, size: uint) -> *mut c_void {
+ #[fixed_stack_segment]; #[inline(never)];
+
let p = realloc(ptr, size as size_t);
if p.is_null() {
// we need a non-allocating way to print an error here
exchange_free(ptr)
}
-#[inline]
pub unsafe fn exchange_free(ptr: *c_char) {
+ #[fixed_stack_segment]; #[inline(never)];
+
free(ptr as *c_void);
}
fn write_be_i64(&mut self, n: i64);
/// Write a big-endian i32 (4 bytes).
- fn write_be_i32(&mut self, n: i32);
+ fn write_be_i32_(&mut self, n: i32);
/// Write a big-endian i16 (2 bytes).
fn write_be_i16(&mut self, n: i16);
fn write_be_f64(&mut self, f: f64);
/// Write a big-endian IEEE754 single-precision floating-point (4 bytes).
- fn write_be_f32(&mut self, f: f32);
+ fn write_be_f32_(&mut self, f: f32);
/// Write a little-endian u64 (8 bytes).
fn write_le_u64_(&mut self, n: u64);
/// (8 bytes).
fn write_le_f64(&mut self, f: f64);
- /// Write a litten-endian IEEE754 single-precision floating-point
+ /// Write a little-endian IEEE754 single-precision floating-point
/// (4 bytes).
- fn write_le_f32(&mut self, f: f32);
+ fn write_le_f32_(&mut self, f: f32);
/// Write a u8 (1 byte).
fn write_u8(&mut self, n: u8);
u64_to_be_bytes(n as u64, 8u, |v| self.write(v))
}
- fn write_be_i32(&mut self, n: i32) {
+ fn write_be_i32_(&mut self, n: i32) {
u64_to_be_bytes(n as u64, 4u, |v| self.write(v))
}
}
}
- fn write_be_f32(&mut self, f: f32) {
+ fn write_be_f32_(&mut self, f: f32) {
unsafe {
self.write_be_u32(cast::transmute(f))
}
}
}
- fn write_le_f32(&mut self, f: f32) {
+ fn write_le_f32_(&mut self, f: f32) {
unsafe {
self.write_le_u32(cast::transmute(f))
}
use super::ReaderUtil;
use option::{Some, None};
use cell::Cell;
- use rt::io::mem::MemReader;
+ use rt::io::mem::{MemReader, MemWriter};
use rt::io::mock::MockReader;
use rt::io::{read_error, placeholder_error};
assert!(buf == ~[10, 11]);
}
- // XXX: Some problem with resolve here
- /*#[test]
- fn test_read_write_le() {
- let uints = [0, 1, 2, 42, 10_123, 100_123_456, u64::max_value];
+
+ #[test]
+ fn test_read_write_le_mem() {
+ let uints = [0, 1, 2, 42, 10_123, 100_123_456, ::u64::max_value];
let mut writer = MemWriter::new();
- for uints.each |i| {
- writer.write_le_u64(*i);
+ for i in uints.iter() {
+ writer.write_le_u64_(*i);
}
let mut reader = MemReader::new(writer.inner());
- for uints.each |i| {
+ for i in uints.iter() {
assert!(reader.read_le_u64() == *i);
}
}
+
#[test]
fn test_read_write_be() {
- let uints = [0, 1, 2, 42, 10_123, 100_123_456, u64::max_value];
+ let uints = [0, 1, 2, 42, 10_123, 100_123_456, ::u64::max_value];
let mut writer = MemWriter::new();
- for uints.each |i| {
- writer.write_be_u64(*i);
+ for i in uints.iter() {
+ writer.write_be_u64_(*i);
}
let mut reader = MemReader::new(writer.inner());
- for uints.each |i| {
+ for i in uints.iter() {
assert!(reader.read_be_u64() == *i);
}
}
#[test]
fn test_read_be_int_n() {
- let ints = [i32::min_value, -123456, -42, -5, 0, 1, i32::max_value];
+ let ints = [::i32::min_value, -123456, -42, -5, 0, 1, ::i32::max_value];
let mut writer = MemWriter::new();
- for ints.each |i| {
- writer.write_be_i32(*i);
+ for i in ints.iter() {
+ writer.write_be_i32_(*i);
}
let mut reader = MemReader::new(writer.inner());
- for ints.each |i| {
+ for i in ints.iter() {
// this tests that the sign extension is working
// (comparing the values as i32 would not test this)
assert!(reader.read_be_int_n(4) == *i as i64);
let f:f32 = 8.1250;
let mut writer = MemWriter::new();
- writer.write_be_f32(f);
- writer.write_le_f32(f);
+ writer.write_be_f32_(f);
+ writer.write_le_f32_(f);
let mut reader = MemReader::new(writer.inner());
assert!(reader.read_be_f32() == 8.1250);
assert!(reader.read_le_f32() == 8.1250);
- }*/
+ }
}
use super::{Reader, Writer, Seek};
use super::SeekStyle;
-/// # XXX
+/// # FIXME #7785
/// * Ugh, this is ridiculous. What is the best way to represent these options?
enum FileMode {
/// Opens an existing file. IoError if file does not exist.
Readers and Writers may be composed to add capabilities like string
parsing, encoding, and compression.
-This will likely live in core::io, not core::rt::io.
+This will likely live in std::io, not std::rt::io.
# Examples
(continuation-passing) style popularised by node.js. Such systems rely
on all computations being run inside an event loop which maintains a
list of all pending I/O events; when one completes the registered
-callback is run and the code that made the I/O request continiues.
+callback is run and the code that made the I/O request continues.
Such interfaces achieve non-blocking at the expense of being more
difficult to reason about.
while still providing feedback about errors. The basic strategy:
* Errors are fatal by default, resulting in task failure
-* Errors raise the `io_error` conditon which provides an opportunity to inspect
+* Errors raise the `io_error` condition which provides an opportunity to inspect
an IoError object containing details.
* Return values must have a sensible null or zero value which is returned
if a condition is handled successfully. This may be an `Option`, an empty
* XXX: How should we use condition handlers that return values?
* XXX: Should EOF raise default conditions when EOF is not an error?
-# Issues withi/o scheduler affinity, work stealing, task pinning
+# Issues with i/o scheduler affinity, work stealing, task pinning
# Resource management
pub mod ip;
#[cfg(unix)]
pub mod unix;
- pub mod http;
}
/// Readers and Writers for memory buffers and strings.
/// println(reader.read_line());
/// }
///
- /// # Failue
+ /// # Failure
///
/// Returns `true` on failure.
fn eof(&mut self) -> bool;
+++ /dev/null
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! Simple HTTP client and server
-
-// XXX This should not be in core
-
-struct HttpServer;
-
-#[cfg(test)]
-mod test {
- use unstable::run_in_bare_thread;
-
- #[test] #[ignore]
- fn smoke_test() {
- do run_in_bare_thread {
- }
-
- do run_in_bare_thread {
- }
- }
-}
type Port = u16;
-#[deriving(Eq, TotalEq)]
+#[deriving(Eq, TotalEq, Clone)]
pub enum IpAddr {
Ipv4Addr(u8, u8, u8, u8),
Ipv6Addr(u16, u16, u16, u16, u16, u16, u16, u16)
}
}
-#[deriving(Eq, TotalEq)]
+#[deriving(Eq, TotalEq, Clone)]
pub struct SocketAddr {
ip: IpAddr,
port: Port,
fn write(&mut self, buf: &[u8]) {
match (**self).write(buf) {
Ok(_) => (),
- Err(ioerr) => {
- io_error::cond.raise(ioerr);
- }
+ Err(ioerr) => io_error::cond.raise(ioerr),
}
}
impl Listener<TcpStream> for TcpListener {
fn accept(&mut self) -> Option<TcpStream> {
match (**self).accept() {
- Ok(s) => {
- Some(TcpStream::new(s))
- }
+ Ok(s) => Some(TcpStream::new(s)),
Err(ioerr) => {
io_error::cond.raise(ioerr);
return None;
}
impl RtioTimer for Timer {
- fn sleep(&self, msecs: u64) {
+ fn sleep(&mut self, msecs: u64) {
(**self).sleep(msecs);
}
}
mod test {
use super::*;
use rt::test::*;
- use option::{Some, None};
#[test]
fn test_io_timer_sleep_simple() {
do run_in_newsched_task {
let timer = Timer::new();
- match timer {
- Some(t) => t.sleep(1),
- None => assert!(false)
- }
+ do timer.map_move |mut t| { t.sleep(1) };
}
}
-}
\ No newline at end of file
+}
on_exit: Option<~fn(bool)>,
// nesting level counter for task::unkillable calls (0 == killable).
unkillable: int,
- // nesting level counter for unstable::atomically calls (0 == can yield).
+ // nesting level counter for unstable::atomically calls (0 == can deschedule).
wont_sleep: int,
// A "spare" handle to the kill flag inside the kill handle. Used during
// blocking/waking as an optimization to avoid two xadds on the refcount.
}
/// Enter a possibly-nested "atomic" section of code. Just for assertions.
- /// All calls must be paired with a subsequent call to allow_yield.
+ /// All calls must be paired with a subsequent call to allow_deschedule.
#[inline]
- pub fn inhibit_yield(&mut self) {
+ pub fn inhibit_deschedule(&mut self) {
self.wont_sleep += 1;
}
/// Exit a possibly-nested "atomic" section of code. Just for assertions.
- /// All calls must be paired with a preceding call to inhibit_yield.
+ /// All calls must be paired with a preceding call to inhibit_deschedule.
#[inline]
- pub fn allow_yield(&mut self) {
+ pub fn allow_deschedule(&mut self) {
rtassert!(self.wont_sleep != 0);
self.wont_sleep -= 1;
}
}
impl LocalHeap {
+ #[fixed_stack_segment] #[inline(never)]
pub fn new() -> LocalHeap {
unsafe {
// Don't need synchronization for the single-threaded local heap
}
}
+ #[fixed_stack_segment] #[inline(never)]
pub fn alloc(&mut self, td: *TypeDesc, size: uint) -> *OpaqueBox {
unsafe {
return rust_boxed_region_malloc(self.boxed_region, td, size as size_t);
}
}
+ #[fixed_stack_segment] #[inline(never)]
pub fn realloc(&mut self, ptr: *OpaqueBox, size: uint) -> *OpaqueBox {
unsafe {
return rust_boxed_region_realloc(self.boxed_region, ptr, size as size_t);
}
}
+ #[fixed_stack_segment] #[inline(never)]
pub fn free(&mut self, box: *OpaqueBox) {
unsafe {
return rust_boxed_region_free(self.boxed_region, box);
}
impl Drop for LocalHeap {
+ #[fixed_stack_segment] #[inline(never)]
fn drop(&self) {
unsafe {
rust_delete_boxed_region(self.boxed_region);
use tls = rt::thread_local_storage;
/// Initialize the TLS key. Other ops will fail if this isn't executed first.
+#[fixed_stack_segment]
+#[inline(never)]
pub fn init_tls_key() {
unsafe {
rust_initialize_rt_tls_key();
}
}
+#[fixed_stack_segment]
+#[inline(never)]
fn maybe_tls_key() -> Option<tls::Key> {
unsafe {
let key: *mut c_void = rust_get_rt_tls_key();
}
extern {
- #[fast_ffi]
fn rust_get_rt_tls_key() -> *mut c_void;
}
-
}
};
// Truncate the string
- let buf_bytes = 256;
+ let buf_bytes = 2048;
if s.len() > buf_bytes {
let s = s.slice(0, buf_bytes) + "[...]";
print(s);
/// Configure logging by traversing the crate map and setting the
/// per-module global logging flags based on the logging spec
+#[fixed_stack_segment] #[inline(never)]
pub fn init(crate_map: *u8) {
use c_str::ToCStr;
use os;
}
}
+#[fixed_stack_segment] #[inline(never)]
pub fn console_on() { unsafe { rust_log_console_on() } }
+
+#[fixed_stack_segment] #[inline(never)]
pub fn console_off() { unsafe { rust_log_console_off() } }
+
+#[fixed_stack_segment] #[inline(never)]
fn should_log_console() -> bool { unsafe { rust_should_log_console() != 0 } }
extern {
Several modules in `core` are clients of `rt`:
-* `core::task` - The user-facing interface to the Rust task model.
-* `core::task::local_data` - The interface to local data.
-* `core::gc` - The garbage collector.
-* `core::unstable::lang` - Miscellaneous lang items, some of which rely on `core::rt`.
-* `core::condition` - Uses local data.
-* `core::cleanup` - Local heap destruction.
-* `core::io` - In the future `core::io` will use an `rt` implementation.
-* `core::logging`
-* `core::pipes`
-* `core::comm`
-* `core::stackwalk`
+* `std::task` - The user-facing interface to the Rust task model.
+* `std::task::local_data` - The interface to local data.
+* `std::gc` - The garbage collector.
+* `std::unstable::lang` - Miscellaneous lang items, some of which rely on `std::rt`.
+* `std::condition` - Uses local data.
+* `std::cleanup` - Local heap destruction.
+* `std::io` - In the future `std::io` will use an `rt` implementation.
+* `std::logging`
+* `std::pipes`
+* `std::comm`
+* `std::stackwalk`
*/
/// scheduler and task context
pub mod tube;
-/// Simple reimplementation of core::comm
+/// Simple reimplementation of std::comm
pub mod comm;
mod select;
return exit_code;
}
+#[cfg(stage0)]
+mod macro_hack {
+#[macro_escape];
+macro_rules! externfn(
+ (fn $name:ident ($($arg_name:ident : $arg_ty:ty),*) $(-> $ret_ty:ty),*) => (
+ extern {
+ fn $name($($arg_name : $arg_ty),*) $(-> $ret_ty),*;
+ }
+ )
+)
+}
+
/// One-time runtime initialization.
///
/// Initializes global state, including frobbing
rust_update_gc_metadata(crate_map);
}
- extern {
- fn rust_update_gc_metadata(crate_map: *u8);
- }
+ externfn!(fn rust_update_gc_metadata(crate_map: *u8));
}
/// One-time runtime cleanup.
pub type RtioTcpListenerObject = uvio::UvTcpListener;
pub type RtioUdpSocketObject = uvio::UvUdpSocket;
pub type RtioTimerObject = uvio::UvTimer;
+pub type PausibleIdleCallback = uvio::UvPausibleIdleCallback;
pub trait EventLoop {
fn run(&mut self);
fn callback(&mut self, ~fn());
+ fn pausible_idle_callback(&mut self) -> ~PausibleIdleCallback;
fn callback_ms(&mut self, ms: u64, ~fn());
fn remote_callback(&mut self, ~fn()) -> ~RemoteCallbackObject;
/// The asynchronous I/O services. Not all event loops may provide one
}
pub trait RemoteCallback {
- /// Trigger the remote callback. Note that the number of times the callback
- /// is run is not guaranteed. All that is guaranteed is that, after calling 'fire',
- /// the callback will be called at least once, but multiple callbacks may be coalesced
- /// and callbacks may be called more often requested. Destruction also triggers the
- /// callback.
+ /// Trigger the remote callback. Note that the number of times the
+ /// callback is run is not guaranteed. All that is guaranteed is
+ /// that, after calling 'fire', the callback will be called at
+ /// least once, but multiple callbacks may be coalesced and
+ /// callbacks may be called more often requested. Destruction also
+ /// triggers the callback.
fn fire(&mut self);
}
}
pub trait RtioTimer {
- fn sleep(&self, msecs: u64);
+ fn sleep(&mut self, msecs: u64);
}
use rt::kill::BlockedTask;
use rt::local_ptr;
use rt::local::Local;
-use rt::rtio::RemoteCallback;
+use rt::rtio::{RemoteCallback, PausibleIdleCallback};
use rt::metrics::SchedMetrics;
use borrow::{to_uint};
use cell::Cell;
use iterator::{range};
use vec::{OwnedVector};
-/// The Scheduler is responsible for coordinating execution of Coroutines
-/// on a single thread. When the scheduler is running it is owned by
-/// thread local storage and the running task is owned by the
-/// scheduler.
+/// A scheduler is responsible for coordinating the execution of Tasks
+/// on a single thread. The scheduler runs inside a slightly modified
+/// Rust Task. When not running this task is stored in the scheduler
+/// struct. The scheduler struct acts like a baton, all scheduling
+/// actions are transfers of the baton.
///
/// XXX: This creates too many callbacks to run_sched_once, resulting
/// in too much allocation and too many events.
stack_pool: StackPool,
/// The event loop used to drive the scheduler and perform I/O
event_loop: ~EventLoopObject,
- /// The scheduler runs on a special task.
+ /// The scheduler runs on a special task. When it is not running
+ /// it is stored here instead of the work queue.
sched_task: Option<~Task>,
/// An action performed after a context switch on behalf of the
/// code running before the context switch
- priv cleanup_job: Option<CleanupJob>,
+ cleanup_job: Option<CleanupJob>,
metrics: SchedMetrics,
/// Should this scheduler run any task, or only pinned tasks?
run_anything: bool,
/// them to.
friend_handle: Option<SchedHandle>,
/// A fast XorShift rng for scheduler use
- rng: XorShiftRng
-
-}
-
-pub struct SchedHandle {
- priv remote: ~RemoteCallbackObject,
- priv queue: MessageQueue<SchedMessage>,
- sched_id: uint
-}
-
-pub enum SchedMessage {
- Wake,
- Shutdown,
- PinnedTask(~Task),
- TaskFromFriend(~Task)
-}
-
-enum CleanupJob {
- DoNothing,
- GiveTask(~Task, UnsafeTaskReceiver)
+ rng: XorShiftRng,
+ /// A toggleable idle callback
+ idle_callback: Option<~PausibleIdleCallback>
}
impl Scheduler {
- pub fn sched_id(&self) -> uint { to_uint(self) }
+ // * Initialization Functions
pub fn new(event_loop: ~EventLoopObject,
work_queue: WorkQueue<~Task>,
}
- // When you create a scheduler it isn't yet "in" a task, so the
- // task field is None.
pub fn new_special(event_loop: ~EventLoopObject,
work_queue: WorkQueue<~Task>,
work_queues: ~[WorkQueue<~Task>],
metrics: SchedMetrics::new(),
run_anything: run_anything,
friend_handle: friend,
- rng: XorShiftRng::new()
+ rng: XorShiftRng::new(),
+ idle_callback: None
}
}
// scheduler task and bootstrap into it.
pub fn bootstrap(~self, task: ~Task) {
+ let mut this = self;
+
+ // Build an Idle callback.
+ this.idle_callback = Some(this.event_loop.pausible_idle_callback());
+
// Initialize the TLS key.
local_ptr::init_tls_key();
// task, put it in TLS.
Local::put::(sched_task);
+ // Before starting our first task, make sure the idle callback
+ // is active. As we do not start in the sleep state this is
+ // important.
+ this.idle_callback.get_mut_ref().start(Scheduler::run_sched_once);
+
// Now, as far as all the scheduler state is concerned, we are
// inside the "scheduler" context. So we can act like the
// scheduler and resume the provided task.
- self.resume_task_immediately(task);
+ this.resume_task_immediately(task);
// Now we are back in the scheduler context, having
// successfully run the input task. Start by running the
let sched = Local::take::<Scheduler>();
rtdebug!("starting scheduler %u", sched.sched_id());
+ sched.run();
+ // Close the idle callback.
+ let mut sched = Local::take::<Scheduler>();
+ sched.idle_callback.get_mut_ref().close();
+ // Make one go through the loop to run the close callback.
sched.run();
// Now that we are done with the scheduler, clean up the
let mut self_sched = self;
- // Always run through the scheduler loop at least once so that
- // we enter the sleep state and can then be woken up by other
- // schedulers.
- self_sched.event_loop.callback(Scheduler::run_sched_once);
-
// This is unsafe because we need to place the scheduler, with
// the event_loop inside, inside our task. But we still need a
// mutable reference to the event_loop to give it the "run"
}
}
- // One iteration of the scheduler loop, always run at least once.
+ // * Execution Functions - Core Loop Logic
// The model for this function is that you continue through it
// until you either use the scheduler while performing a schedule
- // action, in which case you give it away and do not return, or
+ // action, in which case you give it away and return early, or
// you reach the end and sleep. In the case that a scheduler
// action is performed the loop is evented such that this function
// is called again.
// already have a scheduler stored in our local task, so we
// start off by taking it. This is the only path through the
// scheduler where we get the scheduler this way.
- let sched = Local::take::<Scheduler>();
+ let mut sched = Local::take::<Scheduler>();
- // Our first task is to read mail to see if we have important
- // messages.
-
- // 1) A wake message is easy, mutate sched struct and return
- // it.
- // 2) A shutdown is also easy, shutdown.
- // 3) A pinned task - we resume immediately and do not return
- // here.
- // 4) A message from another scheduler with a non-homed task
- // to run here.
-
- let result = sched.interpret_message_queue();
- let sched = match result {
- Some(sched) => {
- // We did not resume a task, so we returned.
- sched
- }
- None => {
- return;
- }
- };
+ // Assume that we need to continue idling unless we reach the
+ // end of this function without performing an action.
+ sched.idle_callback.get_mut_ref().resume();
- // Second activity is to try resuming a task from the queue.
+ // First we check for scheduler messages, these are higher
+ // priority than regular tasks.
+ let sched = match sched.interpret_message_queue() {
+ Some(sched) => sched,
+ None => return
+ };
- let result = sched.do_work();
- let mut sched = match result {
- Some(sched) => {
- // Failed to dequeue a task, so we return.
- sched
- }
- None => {
- return;
- }
+ // This helper will use a randomized work-stealing algorithm
+ // to find work.
+ let mut sched = match sched.do_work() {
+ Some(sched) => sched,
+ None => return
};
// If we got here then there was no work to do.
sched.sleepy = true;
let handle = sched.make_handle();
sched.sleeper_list.push(handle);
+ // Since we are sleeping, deactivate the idle callback.
+ sched.idle_callback.get_mut_ref().pause();
} else {
rtdebug!("not sleeping, already doing so or no_sleep set");
+ // We may not be sleeping, but we still need to deactivate
+ // the idle callback.
+ sched.idle_callback.get_mut_ref().pause();
}
// Finished a cycle without using the Scheduler. Place it back
Local::put(sched);
}
- pub fn make_handle(&mut self) -> SchedHandle {
- let remote = self.event_loop.remote_callback(Scheduler::run_sched_once);
-
- return SchedHandle {
- remote: remote,
- queue: self.message_queue.clone(),
- sched_id: self.sched_id()
- };
- }
-
- /// Schedule a task to be executed later.
- ///
- /// Pushes the task onto the work stealing queue and tells the
- /// event loop to run it later. Always use this instead of pushing
- /// to the work queue directly.
- pub fn enqueue_task(&mut self, task: ~Task) {
-
- let this = self;
-
- // We push the task onto our local queue clone.
- this.work_queue.push(task);
- this.event_loop.callback(Scheduler::run_sched_once);
-
- // We've made work available. Notify a
- // sleeping scheduler.
-
- // XXX: perf. Check for a sleeper without
- // synchronizing memory. It's not critical
- // that we always find it.
-
- // XXX: perf. If there's a sleeper then we
- // might as well just send it the task
- // directly instead of pushing it to the
- // queue. That is essentially the intent here
- // and it is less work.
- match this.sleeper_list.pop() {
- Some(handle) => {
- let mut handle = handle;
- handle.send(Wake)
- }
- None => { (/* pass */) }
- };
- }
-
- /// As enqueue_task, but with the possibility for the blocked task to
- /// already have been killed.
- pub fn enqueue_blocked_task(&mut self, blocked_task: BlockedTask) {
- do blocked_task.wake().map_move |task| {
- self.enqueue_task(task);
- };
- }
-
- // * Scheduler-context operations
-
// This function returns None if the scheduler is "used", or it
- // returns the still-available scheduler.
+ // returns the still-available scheduler. At this point all
+ // message-handling will count as a turn of work, and as a result
+ // return None.
fn interpret_message_queue(~self) -> Option<~Scheduler> {
let mut this = self;
match this.message_queue.pop() {
Some(PinnedTask(task)) => {
- this.event_loop.callback(Scheduler::run_sched_once);
let mut task = task;
task.give_home(Sched(this.make_handle()));
this.resume_task_immediately(task);
return None;
}
Some(TaskFromFriend(task)) => {
- this.event_loop.callback(Scheduler::run_sched_once);
rtdebug!("got a task from a friend. lovely!");
- return this.sched_schedule_task(task);
+ this.process_task(task,
+ Scheduler::resume_task_immediately_cl).map_move(Local::put);
+ return None;
}
Some(Wake) => {
- this.event_loop.callback(Scheduler::run_sched_once);
this.sleepy = false;
- return Some(this);
+ Local::put(this);
+ return None;
}
Some(Shutdown) => {
- this.event_loop.callback(Scheduler::run_sched_once);
+ rtdebug!("shutting down");
if this.sleepy {
// There may be an outstanding handle on the
// sleeper list. Pop them all to make sure that's
// event loop references we will shut down.
this.no_sleep = true;
this.sleepy = false;
- // YYY: Does a shutdown count as a "use" of the
- // scheduler? This seems to work - so I'm leaving it
- // this way despite not having a solid rational for
- // why I should return the scheduler here.
- return Some(this);
+ Local::put(this);
+ return None;
}
None => {
return Some(this);
}
}
- /// Given an input Coroutine sends it back to its home scheduler.
- fn send_task_home(task: ~Task) {
- let mut task = task;
- let mut home = task.take_unwrap_home();
- match home {
- Sched(ref mut home_handle) => {
- home_handle.send(PinnedTask(task));
- }
- AnySched => {
- rtabort!("error: cannot send anysched task home");
- }
- }
- }
+ fn do_work(~self) -> Option<~Scheduler> {
+ let mut this = self;
- /// Take a non-homed task we aren't allowed to run here and send
- /// it to the designated friend scheduler to execute.
- fn send_to_friend(&mut self, task: ~Task) {
- rtdebug!("sending a task to friend");
- match self.friend_handle {
- Some(ref mut handle) => {
- handle.send(TaskFromFriend(task));
+ rtdebug!("scheduler calling do work");
+ match this.find_work() {
+ Some(task) => {
+ rtdebug!("found some work! processing the task");
+ return this.process_task(task,
+ Scheduler::resume_task_immediately_cl);
}
None => {
- rtabort!("tried to send task to a friend but scheduler has no friends");
+ rtdebug!("no work was found, returning the scheduler struct");
+ return Some(this);
}
}
}
None => {
// Our naive stealing, try kinda hard.
rtdebug!("scheduler trying to steal");
- let _len = self.work_queues.len();
- return self.try_steals(2);
+ let len = self.work_queues.len();
+ return self.try_steals(len/2);
}
}
}
let work_queues = &mut self.work_queues;
match work_queues[index].steal() {
Some(task) => {
- rtdebug!("found task by stealing"); return Some(task)
+ rtdebug!("found task by stealing");
+ return Some(task)
}
None => ()
}
return None;
}
- // Given a task, execute it correctly.
- fn process_task(~self, task: ~Task) -> Option<~Scheduler> {
+ // * Task Routing Functions - Make sure tasks send up in the right
+ // place.
+
+ fn process_task(~self, task: ~Task,
+ schedule_fn: SchedulingFn) -> Option<~Scheduler> {
let mut this = self;
let mut task = task;
} else {
rtdebug!("running task here");
task.give_home(Sched(home_handle));
- this.resume_task_immediately(task);
- return None;
+ return schedule_fn(this, task);
}
}
AnySched if this.run_anything => {
rtdebug!("running anysched task here");
task.give_home(AnySched);
- this.resume_task_immediately(task);
- return None;
+ return schedule_fn(this, task);
}
AnySched => {
rtdebug!("sending task to friend");
}
}
- // Bundle the helpers together.
- fn do_work(~self) -> Option<~Scheduler> {
- let mut this = self;
-
- rtdebug!("scheduler calling do work");
- match this.find_work() {
- Some(task) => {
- rtdebug!("found some work! processing the task");
- return this.process_task(task);
+ fn send_task_home(task: ~Task) {
+ let mut task = task;
+ let mut home = task.take_unwrap_home();
+ match home {
+ Sched(ref mut home_handle) => {
+ home_handle.send(PinnedTask(task));
}
- None => {
- rtdebug!("no work was found, returning the scheduler struct");
- return Some(this);
+ AnySched => {
+ rtabort!("error: cannot send anysched task home");
}
}
}
- /// Called by a running task to end execution, after which it will
- /// be recycled by the scheduler for reuse in a new task.
- pub fn terminate_current_task(~self) {
- // Similar to deschedule running task and then, but cannot go through
- // the task-blocking path. The task is already dying.
- let mut this = self;
- let stask = this.sched_task.take_unwrap();
- do this.change_task_context(stask) |sched, mut dead_task| {
- let coroutine = dead_task.coroutine.take_unwrap();
- coroutine.recycle(&mut sched.stack_pool);
+ /// Take a non-homed task we aren't allowed to run here and send
+ /// it to the designated friend scheduler to execute.
+ fn send_to_friend(&mut self, task: ~Task) {
+ rtdebug!("sending a task to friend");
+ match self.friend_handle {
+ Some(ref mut handle) => {
+ handle.send(TaskFromFriend(task));
+ }
+ None => {
+ rtabort!("tried to send task to a friend but scheduler has no friends");
+ }
}
}
- // Scheduling a task requires a few checks to make sure the task
- // ends up in the appropriate location. The run_anything flag on
- // the scheduler and the home on the task need to be checked. This
- // helper performs that check. It takes a function that specifies
- // how to queue the the provided task if that is the correct
- // action. This is a "core" function that requires handling the
- // returned Option correctly.
-
- pub fn schedule_task(~self, task: ~Task,
- schedule_fn: ~fn(sched: ~Scheduler, task: ~Task))
- -> Option<~Scheduler> {
-
- // is the task home?
- let is_home = task.is_home_no_tls(&self);
+ /// Schedule a task to be executed later.
+ ///
+ /// Pushes the task onto the work stealing queue and tells the
+ /// event loop to run it later. Always use this instead of pushing
+ /// to the work queue directly.
+ pub fn enqueue_task(&mut self, task: ~Task) {
- // does the task have a home?
- let homed = task.homed();
+ let this = self;
- let mut this = self;
+ // We push the task onto our local queue clone.
+ this.work_queue.push(task);
+ this.idle_callback.get_mut_ref().resume();
- if is_home || (!homed && this.run_anything) {
- // here we know we are home, execute now OR we know we
- // aren't homed, and that this sched doesn't care
- rtdebug!("task: %u is on ok sched, executing", to_uint(task));
- schedule_fn(this, task);
- return None;
- } else if !homed && !this.run_anything {
- // the task isn't homed, but it can't be run here
- this.send_to_friend(task);
- return Some(this);
- } else {
- // task isn't home, so don't run it here, send it home
- Scheduler::send_task_home(task);
- return Some(this);
- }
- }
+ // We've made work available. Notify a
+ // sleeping scheduler.
- // There are two contexts in which schedule_task can be called:
- // inside the scheduler, and inside a task. These contexts handle
- // executing the task slightly differently. In the scheduler
- // context case we want to receive the scheduler as an input, and
- // manually deal with the option. In the task context case we want
- // to use TLS to find the scheduler, and deal with the option
- // inside the helper.
-
- pub fn sched_schedule_task(~self, task: ~Task) -> Option<~Scheduler> {
- do self.schedule_task(task) |sched, next_task| {
- sched.resume_task_immediately(next_task);
- }
+ // XXX: perf. Check for a sleeper without
+ // synchronizing memory. It's not critical
+ // that we always find it.
+ match this.sleeper_list.pop() {
+ Some(handle) => {
+ let mut handle = handle;
+ handle.send(Wake)
+ }
+ None => { (/* pass */) }
+ };
}
- // Task context case - use TLS.
- pub fn run_task(task: ~Task) {
- let sched = Local::take::<Scheduler>();
- let opt = do sched.schedule_task(task) |sched, next_task| {
- do sched.switch_running_tasks_and_then(next_task) |sched, last_task| {
- sched.enqueue_blocked_task(last_task);
- }
+ /// As enqueue_task, but with the possibility for the blocked task to
+ /// already have been killed.
+ pub fn enqueue_blocked_task(&mut self, blocked_task: BlockedTask) {
+ do blocked_task.wake().map_move |task| {
+ self.enqueue_task(task);
};
- opt.map_move(Local::put);
}
+ // * Core Context Switching Functions
+
// The primary function for changing contexts. In the current
// design the scheduler is just a slightly modified GreenTask, so
// all context swaps are from Task to Task. The only difference
// The current task is placed inside an enum with the cleanup
// function. This enum is then placed inside the scheduler.
- this.enqueue_cleanup_job(GiveTask(current_task, f_opaque));
+ this.cleanup_job = Some(CleanupJob::new(current_task, f_opaque));
// The scheduler is then placed inside the next task.
let mut next_task = next_task;
transmute_mut_region(*next_task.sched.get_mut_ref());
let current_task: &mut Task = match sched.cleanup_job {
- Some(GiveTask(ref task, _)) => {
+ Some(CleanupJob { task: ref task, _ }) => {
transmute_mut_region(*transmute_mut_unsafe(task))
}
- Some(DoNothing) => {
- rtabort!("no next task");
- }
None => {
rtabort!("no cleanup job");
}
}
}
- // Old API for task manipulation implemented over the new core
- // function.
+ // Returns a mutable reference to both contexts involved in this
+ // swap. This is unsafe - we are getting mutable internal
+ // references to keep even when we don't own the tasks. It looks
+ // kinda safe because we are doing transmutes before passing in
+ // the arguments.
+ pub fn get_contexts<'a>(current_task: &mut Task, next_task: &mut Task) ->
+ (&'a mut Context, &'a mut Context) {
+ let current_task_context =
+ &mut current_task.coroutine.get_mut_ref().saved_context;
+ let next_task_context =
+ &mut next_task.coroutine.get_mut_ref().saved_context;
+ unsafe {
+ (transmute_mut_region(current_task_context),
+ transmute_mut_region(next_task_context))
+ }
+ }
+
+ // * Context Swapping Helpers - Here be ugliness!
- pub fn resume_task_immediately(~self, task: ~Task) {
+ pub fn resume_task_immediately(~self, task: ~Task) -> Option<~Scheduler> {
do self.change_task_context(task) |sched, stask| {
sched.sched_task = Some(stask);
}
+ return None;
}
+ fn resume_task_immediately_cl(sched: ~Scheduler,
+ task: ~Task) -> Option<~Scheduler> {
+ sched.resume_task_immediately(task)
+ }
+
+
pub fn resume_blocked_task_immediately(~self, blocked_task: BlockedTask) {
match blocked_task.wake() {
- Some(task) => self.resume_task_immediately(task),
- None => Local::put(self),
+ Some(task) => { self.resume_task_immediately(task); }
+ None => Local::put(self)
};
}
}
}
- // A helper that looks up the scheduler and runs a task later by
- // enqueuing it.
+ fn switch_task(sched: ~Scheduler, task: ~Task) -> Option<~Scheduler> {
+ do sched.switch_running_tasks_and_then(task) |sched, last_task| {
+ sched.enqueue_blocked_task(last_task);
+ };
+ return None;
+ }
+
+ // * Task Context Helpers
+
+ /// Called by a running task to end execution, after which it will
+ /// be recycled by the scheduler for reuse in a new task.
+ pub fn terminate_current_task(~self) {
+ // Similar to deschedule running task and then, but cannot go through
+ // the task-blocking path. The task is already dying.
+ let mut this = self;
+ let stask = this.sched_task.take_unwrap();
+ do this.change_task_context(stask) |sched, mut dead_task| {
+ let coroutine = dead_task.coroutine.take_unwrap();
+ coroutine.recycle(&mut sched.stack_pool);
+ }
+ }
+
+ pub fn run_task(task: ~Task) {
+ let sched = Local::take::<Scheduler>();
+ sched.process_task(task, Scheduler::switch_task).map_move(Local::put);
+ }
+
pub fn run_task_later(next_task: ~Task) {
- // We aren't performing a scheduler operation, so we want to
- // put the Scheduler back when we finish.
let next_task = Cell::new(next_task);
do Local::borrow::<Scheduler,()> |sched| {
sched.enqueue_task(next_task.take());
};
}
- // Returns a mutable reference to both contexts involved in this
- // swap. This is unsafe - we are getting mutable internal
- // references to keep even when we don't own the tasks. It looks
- // kinda safe because we are doing transmutes before passing in
- // the arguments.
- pub fn get_contexts<'a>(current_task: &mut Task, next_task: &mut Task) ->
- (&'a mut Context, &'a mut Context) {
- let current_task_context =
- &mut current_task.coroutine.get_mut_ref().saved_context;
- let next_task_context =
- &mut next_task.coroutine.get_mut_ref().saved_context;
- unsafe {
- (transmute_mut_region(current_task_context),
- transmute_mut_region(next_task_context))
- }
- }
+ // * Utility Functions
- pub fn enqueue_cleanup_job(&mut self, job: CleanupJob) {
- self.cleanup_job = Some(job);
- }
+ pub fn sched_id(&self) -> uint { to_uint(self) }
pub fn run_cleanup_job(&mut self) {
- rtdebug!("running cleanup job");
let cleanup_job = self.cleanup_job.take_unwrap();
- match cleanup_job {
- DoNothing => { }
- GiveTask(task, f) => f.to_fn()(self, task)
- }
+ cleanup_job.run(self);
+ }
+
+ pub fn make_handle(&mut self) -> SchedHandle {
+ let remote = self.event_loop.remote_callback(Scheduler::run_sched_once);
+
+ return SchedHandle {
+ remote: remote,
+ queue: self.message_queue.clone(),
+ sched_id: self.sched_id()
+ };
}
}
-// The cases for the below function.
-enum ResumeAction {
- SendHome,
- Requeue,
- ResumeNow,
- Homeless
+// Supporting types
+
+type SchedulingFn = ~fn(~Scheduler, ~Task) -> Option<~Scheduler>;
+
+pub enum SchedMessage {
+ Wake,
+ Shutdown,
+ PinnedTask(~Task),
+ TaskFromFriend(~Task)
+}
+
+pub struct SchedHandle {
+ priv remote: ~RemoteCallbackObject,
+ priv queue: MessageQueue<SchedMessage>,
+ sched_id: uint
}
impl SchedHandle {
}
}
+struct CleanupJob {
+ task: ~Task,
+ f: UnsafeTaskReceiver
+}
+
+impl CleanupJob {
+ pub fn new(task: ~Task, f: UnsafeTaskReceiver) -> CleanupJob {
+ CleanupJob {
+ task: task,
+ f: f
+ }
+ }
+
+ pub fn run(self, sched: &mut Scheduler) {
+ let CleanupJob { task: task, f: f } = self;
+ f.to_fn()(sched, task)
+ }
+}
+
// XXX: Some hacks to put a &fn in Scheduler without borrowck
// complaining
type UnsafeTaskReceiver = raw::Closure;
use cell::Cell;
use rt::thread::Thread;
use rt::task::{Task, Sched};
+ use rt::util;
use option::{Some};
#[test]
#[test]
fn test_stress_schedule_task_states() {
+ if util::limit_thread_creation_due_to_osx_and_valgrind() { return; }
let n = stress_factor() * 120;
for _ in range(0, n as int) {
test_schedule_home_states();
}
}
+ // A regression test that the final message is always handled.
+ // Used to deadlock because Shutdown was never recvd.
+ #[test]
+ fn no_missed_messages() {
+ use rt::work_queue::WorkQueue;
+ use rt::sleeper_list::SleeperList;
+ use rt::stack::StackPool;
+ use rt::uv::uvio::UvEventLoop;
+ use rt::sched::{Shutdown, TaskFromFriend};
+ use util;
+
+ do run_in_bare_thread {
+ do stress_factor().times {
+ let sleepers = SleeperList::new();
+ let queue = WorkQueue::new();
+ let queues = ~[queue.clone()];
+
+ let mut sched = ~Scheduler::new(
+ ~UvEventLoop::new(),
+ queue,
+ queues.clone(),
+ sleepers.clone());
+
+ let mut handle = sched.make_handle();
+
+ let sched = Cell::new(sched);
+
+ let thread = do Thread::start {
+ let mut sched = sched.take();
+ let bootstrap_task = ~Task::new_root(&mut sched.stack_pool, None, ||());
+ sched.bootstrap(bootstrap_task);
+ };
+
+ let mut stack_pool = StackPool::new();
+ let task = ~Task::new_root(&mut stack_pool, None, ||());
+ handle.send(TaskFromFriend(task));
+
+ handle.send(Shutdown);
+ util::ignore(handle);
+
+ thread.join();
+ }
+ }
+ }
+
#[test]
fn multithreading() {
use rt::comm::*;
impl StackSegment {
pub fn new(size: uint) -> StackSegment {
+ #[fixed_stack_segment]; #[inline(never)];
+
unsafe {
// Crate a block of uninitialized values
let mut stack = vec::with_capacity(size);
impl Drop for StackSegment {
fn drop(&self) {
+ #[fixed_stack_segment]; #[inline(never)];
+
unsafe {
// XXX: Using the FFI to call a C macro. Slow
rust_valgrind_stack_deregister(self.valgrind_id);
use ptr;
use prelude::*;
use option::{Option, Some, None};
+use rt::borrowck;
+use rt::borrowck::BorrowRecord;
use rt::env;
use rt::kill::Death;
use rt::local::Local;
name: Option<~str>,
coroutine: Option<Coroutine>,
sched: Option<~Scheduler>,
- task_type: TaskType
+ task_type: TaskType,
+ // Dynamic borrowck debugging info
+ borrow_list: Option<~[BorrowRecord]>
}
pub enum TaskType {
saved_context: Context
}
-/// Some tasks have a deciated home scheduler that they must run on.
+/// Some tasks have a dedicated home scheduler that they must run on.
pub enum SchedHome {
AnySched,
Sched(SchedHandle)
coroutine: Some(Coroutine::empty()),
name: None,
sched: None,
- task_type: SchedTask
+ task_type: SchedTask,
+ borrow_list: None
}
}
name: None,
coroutine: Some(Coroutine::new(stack_pool, stack_size, start)),
sched: None,
- task_type: GreenTask(Some(~home))
+ task_type: GreenTask(Some(~home)),
+ borrow_list: None
}
}
name: None,
coroutine: Some(Coroutine::new(stack_pool, stack_size, start)),
sched: None,
- task_type: GreenTask(Some(~home))
+ task_type: GreenTask(Some(~home)),
+ borrow_list: None
}
}
}
}
+ // Cleanup the dynamic borrowck debugging info
+ borrowck::clear_task_borrow_list();
+
// NB. We pass the taskgroup into death so that it can be dropped while
// the unkillable counter is set. This is necessary for when the
// taskgroup destruction code drops references on KillHandles, which
// Again - might work while safe, or it might not.
do Local::borrow::<Scheduler,()> |sched| {
- (sched).run_cleanup_job();
+ sched.run_cleanup_job();
}
// To call the run method on a task we need a direct
}
pub fn begin_unwind(&mut self) -> ! {
+ #[fixed_stack_segment]; #[inline(never)];
+
self.unwinding = true;
unsafe {
rust_begin_unwind(UNWIND_TOKEN);
}
}
}
-
use super::io::net::ip::{SocketAddr, Ipv4Addr, Ipv6Addr};
use vec::{OwnedVector, MutableVector, ImmutableVector};
use rt::sched::Scheduler;
-use unstable::run_in_bare_thread;
+use unstable::{run_in_bare_thread};
use rt::thread::Thread;
use rt::task::Task;
use rt::uv::uvio::UvEventLoop;
static RLIMIT_NOFILE: libc::c_int = 8;
pub unsafe fn raise_fd_limit() {
+ #[fixed_stack_segment]; #[inline(never)];
+
// The strategy here is to fetch the current resource limits, read the kern.maxfilesperproc
// sysctl value, and bump the soft resource limit for maxfiles up to the sysctl value.
use ptr::{to_unsafe_ptr, to_mut_unsafe_ptr, mut_null};
let nthreads = match os::getenv("RUST_RT_TEST_THREADS") {
Some(nstr) => FromStr::from_str(nstr).unwrap(),
None => {
- // Using more threads than cores in test code
- // to force the OS to preempt them frequently.
- // Assuming that this help stress test concurrent types.
- util::num_cpus() * 2
+ if util::limit_thread_creation_due_to_osx_and_valgrind() {
+ 1
+ } else {
+ // Using more threads than cores in test code
+ // to force the OS to preempt them frequently.
+ // Assuming that this help stress test concurrent types.
+ util::num_cpus() * 2
+ }
}
};
}
/// Get a port number, starting at 9600, for use in tests
+#[fixed_stack_segment] #[inline(never)]
pub fn next_test_port() -> u16 {
unsafe {
return rust_dbg_next_port(base_port() as libc::uintptr_t) as u16;
impl Thread {
pub fn start(main: ~fn()) -> Thread {
fn substart(main: &~fn()) -> *raw_thread {
+ #[fixed_stack_segment]; #[inline(never)];
+
unsafe { rust_raw_thread_start(main) }
}
let raw = substart(&main);
}
pub fn join(self) {
+ #[fixed_stack_segment]; #[inline(never)];
+
assert!(!self.joined);
let mut this = self;
unsafe { rust_raw_thread_join(this.raw_thread); }
impl Drop for Thread {
fn drop(&self) {
+ #[fixed_stack_segment]; #[inline(never)];
+
assert!(self.joined);
unsafe { rust_raw_thread_delete(self.raw_thread) }
}
pub type Key = pthread_key_t;
#[cfg(unix)]
+#[fixed_stack_segment]
+#[inline(never)]
pub unsafe fn create(key: &mut Key) {
assert_eq!(0, pthread_key_create(key, null()));
}
#[cfg(unix)]
+#[fixed_stack_segment]
+#[inline(never)]
pub unsafe fn set(key: Key, value: *mut c_void) {
assert_eq!(0, pthread_setspecific(key, value));
}
#[cfg(unix)]
+#[fixed_stack_segment]
+#[inline(never)]
pub unsafe fn get(key: Key) -> *mut c_void {
pthread_getspecific(key)
}
pub type Key = DWORD;
#[cfg(windows)]
+#[fixed_stack_segment]
+#[inline(never)]
pub unsafe fn create(key: &mut Key) {
static TLS_OUT_OF_INDEXES: DWORD = 0xFFFFFFFF;
*key = TlsAlloc();
}
#[cfg(windows)]
+#[fixed_stack_segment]
+#[inline(never)]
pub unsafe fn set(key: Key, value: *mut c_void) {
assert!(0 != TlsSetValue(key, value))
}
#[cfg(windows)]
+#[fixed_stack_segment]
+#[inline(never)]
pub unsafe fn get(key: Key) -> *mut c_void {
TlsGetValue(key)
}
use os;
use str::StrSlice;
+#[cfg(target_os="macos")]
+use unstable::running_on_valgrind;
+
/// Get the number of cores available
pub fn num_cpus() -> uint {
+ #[fixed_stack_segment]; #[inline(never)];
+
unsafe {
return rust_get_num_cpus();
}
}
}
+/// Valgrind has a fixed-sized array (size around 2000) of segment descriptors wired into it; this
+/// is a hard limit and requires rebuilding valgrind if you want to go beyond it. Normally this is
+/// not a problem, but in some tests, we produce a lot of threads casually. Making lots of threads
+/// alone might not be a problem _either_, except on OSX, the segments produced for new threads
+/// _take a while_ to get reclaimed by the OS. Combined with the fact that libuv schedulers fork off
+/// a separate thread for polling fsevents on OSX, we get a perfect storm of creating "too many
+/// mappings" for valgrind to handle when running certain stress tests in the runtime.
+#[cfg(target_os="macos")]
+pub fn limit_thread_creation_due_to_osx_and_valgrind() -> bool {
+ running_on_valgrind()
+}
+
+#[cfg(not(target_os="macos"))]
+pub fn limit_thread_creation_due_to_osx_and_valgrind() -> bool {
+ false
+}
+
/// Get's the number of scheduler threads requested by the environment
/// either `RUST_THREADS` or `num_cpus`.
pub fn default_sched_threads() -> uint {
match os::getenv("RUST_THREADS") {
Some(nstr) => FromStr::from_str(nstr).unwrap(),
- None => num_cpus()
+ None => {
+ if limit_thread_creation_due_to_osx_and_valgrind() {
+ 1
+ } else {
+ num_cpus()
+ }
+ }
}
}
pub fn dumb_println(s: &str) {
use io::WriterUtil;
let dbg = ::libc::STDERR_FILENO as ::io::fd_t;
- dbg.write_str(s);
- dbg.write_str("\n");
+ dbg.write_str(s + "\n");
}
pub fn abort(msg: &str) -> ! {
rterrln!("%s", "");
rterrln!("fatal runtime error: %s", msg);
- unsafe { libc::abort(); }
+ abort();
+
+ fn abort() -> ! {
+ #[fixed_stack_segment]; #[inline(never)];
+ unsafe { libc::abort() }
+ }
}
pub fn set_exit_status(code: int) {
-
+ #[fixed_stack_segment]; #[inline(never)];
unsafe {
return rust_set_exit_status_newrt(code as libc::uintptr_t);
}
}
pub fn get_exit_status() -> int {
-
+ #[fixed_stack_segment]; #[inline(never)];
unsafe {
return rust_get_exit_status_newrt() as int;
}
}
}
+ pub fn restart(&mut self) {
+ unsafe {
+ assert!(0 == uvll::idle_start(self.native_handle(), idle_cb))
+ };
+
+ extern fn idle_cb(handle: *uvll::uv_idle_t, status: c_int) {
+ let mut idle_watcher: IdleWatcher = NativeHandle::from_native_handle(handle);
+ let data = idle_watcher.get_watcher_data();
+ let cb: &IdleCallback = data.idle_cb.get_ref();
+ let status = status_to_maybe_uv_error(idle_watcher, status);
+ (*cb)(idle_watcher, status);
+ }
+ }
+
pub fn stop(&mut self) {
// NB: Not resetting the Rust idle_cb to None here because `stop` is
// likely called from *within* the idle callback, causing a use after
/*!
-Bindings to libuv, along with the default implementation of `core::rt::rtio`.
+Bindings to libuv, along with the default implementation of `std::rt::rtio`.
UV types consist of the event loop (Loop), Watchers, Requests and
Callbacks.
/// Transmute an owned vector to a Buf
pub fn vec_to_uv_buf(v: ~[u8]) -> Buf {
+ #[fixed_stack_segment]; #[inline(never)];
+
unsafe {
let data = malloc(v.len() as size_t) as *u8;
assert!(data.is_not_null());
/// Transmute a Buf that was once a ~[u8] back to ~[u8]
pub fn vec_from_uv_buf(buf: Buf) -> Option<~[u8]> {
+ #[fixed_stack_segment]; #[inline(never)];
+
if !(buf.len == 0 && buf.base.is_null()) {
let v = unsafe { vec::from_buf(buf.base, buf.len as uint) };
unsafe { free(buf.base as *c_void) };
extern fn close_cb(handle: *uvll::uv_stream_t) {
let mut stream_watcher: StreamWatcher = NativeHandle::from_native_handle(handle);
- stream_watcher.get_watcher_data().close_cb.take_unwrap()();
+ let cb = stream_watcher.get_watcher_data().close_cb.take_unwrap();
stream_watcher.drop_watcher_data();
unsafe { free_handle(handle as *c_void) }
+ cb();
}
}
}
extern fn close_cb(handle: *uvll::uv_udp_t) {
let mut udp_watcher: UdpWatcher = NativeHandle::from_native_handle(handle);
- udp_watcher.get_watcher_data().close_cb.take_unwrap()();
+ let cb = udp_watcher.get_watcher_data().close_cb.take_unwrap();
udp_watcher.drop_watcher_data();
unsafe { free_handle(handle as *c_void) }
+ cb();
}
}
}
use rt::io::{standard_error, OtherIoError};
use rt::local::Local;
use rt::rtio::*;
-use rt::sched::Scheduler;
+use rt::sched::{Scheduler, SchedHandle};
use rt::tube::Tube;
use rt::uv::*;
use rt::uv::idle::IdleWatcher;
run_in_newsched_task};
#[cfg(test)] use iterator::{Iterator, range};
+// XXX we should not be calling uvll functions in here.
+
+trait HomingIO {
+ fn home<'r>(&'r mut self) -> &'r mut SchedHandle;
+ /* XXX This will move pinned tasks to do IO on the proper scheduler
+ * and then move them back to their home.
+ */
+ fn home_for_io<A>(&mut self, io: &fn(&mut Self) -> A) -> A {
+ use rt::sched::{PinnedTask, TaskFromFriend};
+ // go home
+ let old_home = Cell::new_empty();
+ let old_home_ptr = &old_home;
+ let scheduler = Local::take::<Scheduler>();
+ do scheduler.deschedule_running_task_and_then |_, task| {
+ // get the old home first
+ do task.wake().map_move |mut task| {
+ old_home_ptr.put_back(task.take_unwrap_home());
+ self.home().send(PinnedTask(task));
+ };
+ }
+
+ // do IO
+ let a = io(self);
+
+ // unhome home
+ let scheduler = Local::take::<Scheduler>();
+ do scheduler.deschedule_running_task_and_then |scheduler, task| {
+ do task.wake().map_move |mut task| {
+ task.give_home(old_home.take());
+ scheduler.make_handle().send(TaskFromFriend(task));
+ };
+ }
+
+ // return the result of the IO
+ a
+ }
+}
+
+// get a handle for the current scheduler
+macro_rules! get_handle_to_current_scheduler(
+ () => (do Local::borrow::<Scheduler, SchedHandle> |sched| { sched.make_handle() })
+)
+
enum SocketNameKind {
TcpPeer,
Tcp,
fn socket_name<T, U: Watcher + NativeHandle<*T>>(sk: SocketNameKind,
handle: U) -> Result<SocketAddr, IoError> {
-
let getsockname = match sk {
- TcpPeer => uvll::rust_uv_tcp_getpeername,
- Tcp => uvll::rust_uv_tcp_getsockname,
- Udp => uvll::rust_uv_udp_getsockname
+ TcpPeer => uvll::tcp_getpeername,
+ Tcp => uvll::tcp_getsockname,
+ Udp => uvll::udp_getsockname,
};
// Allocate a sockaddr_storage
}
+// Obviously an Event Loop is always home.
pub struct UvEventLoop {
uvio: UvIoFactory
}
}
}
+ fn pausible_idle_callback(&mut self) -> ~PausibleIdleCallback {
+ let idle_watcher = IdleWatcher::new(self.uvio.uv_loop());
+ return ~UvPausibleIdleCallback {
+ watcher: idle_watcher,
+ idle_flag: false,
+ closed: false
+ };
+ }
+
fn callback_ms(&mut self, ms: u64, f: ~fn()) {
let mut timer = TimerWatcher::new(self.uvio.uv_loop());
do timer.start(ms, 0) |timer, status| {
}
}
+pub struct UvPausibleIdleCallback {
+ watcher: IdleWatcher,
+ idle_flag: bool,
+ closed: bool
+}
+
+impl UvPausibleIdleCallback {
+ #[inline]
+ pub fn start(&mut self, f: ~fn()) {
+ do self.watcher.start |_idle_watcher, _status| {
+ f();
+ };
+ self.idle_flag = true;
+ }
+ #[inline]
+ pub fn pause(&mut self) {
+ if self.idle_flag == true {
+ self.watcher.stop();
+ self.idle_flag = false;
+ }
+ }
+ #[inline]
+ pub fn resume(&mut self) {
+ if self.idle_flag == false {
+ self.watcher.restart();
+ self.idle_flag = true;
+ }
+ }
+ #[inline]
+ pub fn close(&mut self) {
+ self.pause();
+ if !self.closed {
+ self.closed = true;
+ self.watcher.close(||{});
+ }
+ }
+}
+
#[test]
fn test_callback_run_once() {
do run_in_bare_thread {
}
}
+// The entire point of async is to call into a loop from other threads so it does not need to home.
pub struct UvRemoteCallback {
// The uv async handle for triggering the callback
async: AsyncWatcher,
let exit_flag_clone = exit_flag.clone();
let async = do AsyncWatcher::new(loop_) |watcher, status| {
assert!(status.is_none());
+
+ // The synchronization logic here is subtle. To review,
+ // the uv async handle type promises that, after it is
+ // triggered the remote callback is definitely called at
+ // least once. UvRemoteCallback needs to maintain those
+ // semantics while also shutting down cleanly from the
+ // dtor. In our case that means that, when the
+ // UvRemoteCallback dtor calls `async.send()`, here `f` is
+ // always called later.
+
+ // In the dtor both the exit flag is set and the async
+ // callback fired under a lock. Here, before calling `f`,
+ // we take the lock and check the flag. Because we are
+ // checking the flag before calling `f`, and the flag is
+ // set under the same lock as the send, then if the flag
+ // is set then we're guaranteed to call `f` after the
+ // final send.
+
+ // If the check was done after `f()` then there would be a
+ // period between that call and the check where the dtor
+ // could be called in the other thread, missing the final
+ // callback while still destroying the handle.
+
+ let should_exit = unsafe {
+ exit_flag_clone.with_imm(|&should_exit| should_exit)
+ };
+
f();
- unsafe {
- do exit_flag_clone.with_imm |&should_exit| {
- if should_exit {
- watcher.close(||());
- }
- }
+
+ if should_exit {
+ watcher.close(||());
}
+
};
UvRemoteCallback {
async: async,
let tube_clone = tube_clone.clone();
let tube_clone_cell = Cell::new(tube_clone);
let remote = do sched.event_loop.remote_callback {
- tube_clone_cell.take().send(1);
+ // This could be called multiple times
+ if !tube_clone_cell.is_empty() {
+ tube_clone_cell.take().send(1);
+ }
};
remote_cell.put_back(remote);
}
let result_cell = Cell::new_empty();
let result_cell_ptr: *Cell<Result<~RtioTcpStreamObject, IoError>> = &result_cell;
- let scheduler = Local::take::<Scheduler>();
-
// Block this task and take ownership, switch to scheduler context
+ let scheduler = Local::take::<Scheduler>();
do scheduler.deschedule_running_task_and_then |_, task| {
- rtdebug!("connect: entered scheduler context");
- let mut tcp_watcher = TcpWatcher::new(self.uv_loop());
+ let mut tcp = TcpWatcher::new(self.uv_loop());
let task_cell = Cell::new(task);
// Wait for a connection
- do tcp_watcher.connect(addr) |stream_watcher, status| {
- rtdebug!("connect: in connect callback");
- if status.is_none() {
- rtdebug!("status is none");
- let tcp_watcher =
- NativeHandle::from_native_handle(stream_watcher.native_handle());
- let res = Ok(~UvTcpStream(tcp_watcher));
-
- // Store the stream in the task's stack
- unsafe { (*result_cell_ptr).put_back(res); }
-
- // Context switch
- let scheduler = Local::take::<Scheduler>();
- scheduler.resume_blocked_task_immediately(task_cell.take());
- } else {
- rtdebug!("status is some");
- let task_cell = Cell::new(task_cell.take());
- do stream_watcher.close {
- let res = Err(uv_error_to_io_error(status.unwrap()));
+ do tcp.connect(addr) |stream, status| {
+ match status {
+ None => {
+ let tcp = NativeHandle::from_native_handle(stream.native_handle());
+ let home = get_handle_to_current_scheduler!();
+ let res = Ok(~UvTcpStream { watcher: tcp, home: home });
+
+ // Store the stream in the task's stack
unsafe { (*result_cell_ptr).put_back(res); }
+
+ // Context switch
let scheduler = Local::take::<Scheduler>();
scheduler.resume_blocked_task_immediately(task_cell.take());
}
- };
+ Some(_) => {
+ let task_cell = Cell::new(task_cell.take());
+ do stream.close {
+ let res = Err(uv_error_to_io_error(status.unwrap()));
+ unsafe { (*result_cell_ptr).put_back(res); }
+ let scheduler = Local::take::<Scheduler>();
+ scheduler.resume_blocked_task_immediately(task_cell.take());
+ }
+ }
+ }
}
}
fn tcp_bind(&mut self, addr: SocketAddr) -> Result<~RtioTcpListenerObject, IoError> {
let mut watcher = TcpWatcher::new(self.uv_loop());
match watcher.bind(addr) {
- Ok(_) => Ok(~UvTcpListener::new(watcher)),
+ Ok(_) => {
+ let home = get_handle_to_current_scheduler!();
+ Ok(~UvTcpListener::new(watcher, home))
+ }
Err(uverr) => {
let scheduler = Local::take::<Scheduler>();
do scheduler.deschedule_running_task_and_then |_, task| {
fn udp_bind(&mut self, addr: SocketAddr) -> Result<~RtioUdpSocketObject, IoError> {
let mut watcher = UdpWatcher::new(self.uv_loop());
match watcher.bind(addr) {
- Ok(_) => Ok(~UvUdpSocket(watcher)),
+ Ok(_) => {
+ let home = get_handle_to_current_scheduler!();
+ Ok(~UvUdpSocket { watcher: watcher, home: home })
+ }
Err(uverr) => {
let scheduler = Local::take::<Scheduler>();
do scheduler.deschedule_running_task_and_then |_, task| {
}
fn timer_init(&mut self) -> Result<~RtioTimerObject, IoError> {
- Ok(~UvTimer(TimerWatcher::new(self.uv_loop())))
+ let watcher = TimerWatcher::new(self.uv_loop());
+ let home = get_handle_to_current_scheduler!();
+ Ok(~UvTimer::new(watcher, home))
}
}
pub struct UvTcpListener {
watcher: TcpWatcher,
listening: bool,
- incoming_streams: Tube<Result<~RtioTcpStreamObject, IoError>>
+ incoming_streams: Tube<Result<~RtioTcpStreamObject, IoError>>,
+ home: SchedHandle,
+}
+
+impl HomingIO for UvTcpListener {
+ fn home<'r>(&'r mut self) -> &'r mut SchedHandle { &mut self.home }
}
impl UvTcpListener {
- fn new(watcher: TcpWatcher) -> UvTcpListener {
+ fn new(watcher: TcpWatcher, home: SchedHandle) -> UvTcpListener {
UvTcpListener {
watcher: watcher,
listening: false,
- incoming_streams: Tube::new()
+ incoming_streams: Tube::new(),
+ home: home,
}
}
impl Drop for UvTcpListener {
fn drop(&self) {
- let watcher = self.watcher();
- let scheduler = Local::take::<Scheduler>();
- do scheduler.deschedule_running_task_and_then |_, task| {
- let task_cell = Cell::new(task);
- do watcher.as_stream().close {
- let scheduler = Local::take::<Scheduler>();
- scheduler.resume_blocked_task_immediately(task_cell.take());
+ // XXX need mutable finalizer
+ let self_ = unsafe { transmute::<&UvTcpListener, &mut UvTcpListener>(self) };
+ do self_.home_for_io |self_| {
+ let scheduler = Local::take::<Scheduler>();
+ do scheduler.deschedule_running_task_and_then |_, task| {
+ let task_cell = Cell::new(task);
+ do self_.watcher().as_stream().close {
+ let scheduler = Local::take::<Scheduler>();
+ scheduler.resume_blocked_task_immediately(task_cell.take());
+ }
}
}
}
impl RtioSocket for UvTcpListener {
fn socket_name(&mut self) -> Result<SocketAddr, IoError> {
- socket_name(Tcp, self.watcher)
+ do self.home_for_io |self_| {
+ socket_name(Tcp, self_.watcher)
+ }
}
}
impl RtioTcpListener for UvTcpListener {
fn accept(&mut self) -> Result<~RtioTcpStreamObject, IoError> {
- rtdebug!("entering listen");
-
- if self.listening {
- return self.incoming_streams.recv();
- }
-
- self.listening = true;
-
- let server_tcp_watcher = self.watcher();
- let incoming_streams_cell = Cell::new(self.incoming_streams.clone());
-
- let incoming_streams_cell = Cell::new(incoming_streams_cell.take());
- let mut server_tcp_watcher = server_tcp_watcher;
- do server_tcp_watcher.listen |mut server_stream_watcher, status| {
- let maybe_stream = if status.is_none() {
- let mut loop_ = server_stream_watcher.event_loop();
- let client_tcp_watcher = TcpWatcher::new(&mut loop_);
- // XXX: Need's to be surfaced in interface
- server_stream_watcher.accept(client_tcp_watcher.as_stream());
- Ok(~UvTcpStream(client_tcp_watcher))
- } else {
- Err(standard_error(OtherIoError))
- };
+ do self.home_for_io |self_| {
+
+ if !self_.listening {
+ self_.listening = true;
+
+ let incoming_streams_cell = Cell::new(self_.incoming_streams.clone());
+
+ do self_.watcher().listen |mut server, status| {
+ let stream = match status {
+ Some(_) => Err(standard_error(OtherIoError)),
+ None => {
+ let client = TcpWatcher::new(&server.event_loop());
+ // XXX: needs to be surfaced in interface
+ server.accept(client.as_stream());
+ let home = get_handle_to_current_scheduler!();
+ Ok(~UvTcpStream { watcher: client, home: home })
+ }
+ };
+
+ let mut incoming_streams = incoming_streams_cell.take();
+ incoming_streams.send(stream);
+ incoming_streams_cell.put_back(incoming_streams);
+ }
- let mut incoming_streams = incoming_streams_cell.take();
- incoming_streams.send(maybe_stream);
- incoming_streams_cell.put_back(incoming_streams);
+ }
+ self_.incoming_streams.recv()
}
-
- return self.incoming_streams.recv();
}
fn accept_simultaneously(&mut self) -> Result<(), IoError> {
- let r = unsafe {
- uvll::rust_uv_tcp_simultaneous_accepts(self.watcher.native_handle(), 1 as c_int)
- };
+ do self.home_for_io |self_| {
+ let r = unsafe {
+ uvll::tcp_simultaneous_accepts(self_.watcher().native_handle(), 1 as c_int)
+ };
- match status_to_maybe_uv_error(self.watcher, r) {
- Some(err) => Err(uv_error_to_io_error(err)),
- None => Ok(())
+ match status_to_maybe_uv_error(self_.watcher(), r) {
+ Some(err) => Err(uv_error_to_io_error(err)),
+ None => Ok(())
+ }
}
}
fn dont_accept_simultaneously(&mut self) -> Result<(), IoError> {
- let r = unsafe {
- uvll::rust_uv_tcp_simultaneous_accepts(self.watcher.native_handle(), 0 as c_int)
- };
+ do self.home_for_io |self_| {
+ let r = unsafe {
+ uvll::tcp_simultaneous_accepts(self_.watcher().native_handle(), 0 as c_int)
+ };
- match status_to_maybe_uv_error(self.watcher, r) {
- Some(err) => Err(uv_error_to_io_error(err)),
- None => Ok(())
+ match status_to_maybe_uv_error(self_.watcher(), r) {
+ Some(err) => Err(uv_error_to_io_error(err)),
+ None => Ok(())
+ }
}
}
}
-pub struct UvTcpStream(TcpWatcher);
+pub struct UvTcpStream {
+ watcher: TcpWatcher,
+ home: SchedHandle,
+}
+
+impl HomingIO for UvTcpStream {
+ fn home<'r>(&'r mut self) -> &'r mut SchedHandle { &mut self.home }
+}
impl Drop for UvTcpStream {
fn drop(&self) {
- rtdebug!("closing tcp stream");
- let scheduler = Local::take::<Scheduler>();
- do scheduler.deschedule_running_task_and_then |_, task| {
- let task_cell = Cell::new(task);
- do self.as_stream().close {
- let scheduler = Local::take::<Scheduler>();
- scheduler.resume_blocked_task_immediately(task_cell.take());
+ // XXX need mutable finalizer
+ let this = unsafe { transmute::<&UvTcpStream, &mut UvTcpStream>(self) };
+ do this.home_for_io |self_| {
+ let scheduler = Local::take::<Scheduler>();
+ do scheduler.deschedule_running_task_and_then |_, task| {
+ let task_cell = Cell::new(task);
+ do self_.watcher.as_stream().close {
+ let scheduler = Local::take::<Scheduler>();
+ scheduler.resume_blocked_task_immediately(task_cell.take());
+ }
}
}
}
impl RtioSocket for UvTcpStream {
fn socket_name(&mut self) -> Result<SocketAddr, IoError> {
- socket_name(Tcp, **self)
+ do self.home_for_io |self_| {
+ socket_name(Tcp, self_.watcher)
+ }
}
}
impl RtioTcpStream for UvTcpStream {
fn read(&mut self, buf: &mut [u8]) -> Result<uint, IoError> {
- let result_cell = Cell::new_empty();
- let result_cell_ptr: *Cell<Result<uint, IoError>> = &result_cell;
-
- let scheduler = Local::take::<Scheduler>();
- let buf_ptr: *&mut [u8] = &buf;
- do scheduler.deschedule_running_task_and_then |_sched, task| {
- rtdebug!("read: entered scheduler context");
- let task_cell = Cell::new(task);
- // XXX: We shouldn't reallocate these callbacks every
- // call to read
- let alloc: AllocCallback = |_| unsafe {
- slice_to_uv_buf(*buf_ptr)
- };
- let mut watcher = self.as_stream();
- do watcher.read_start(alloc) |mut watcher, nread, _buf, status| {
-
- // Stop reading so that no read callbacks are
- // triggered before the user calls `read` again.
- // XXX: Is there a performance impact to calling
- // stop here?
- watcher.read_stop();
-
- let result = if status.is_none() {
- assert!(nread >= 0);
- Ok(nread as uint)
- } else {
- Err(uv_error_to_io_error(status.unwrap()))
+ do self.home_for_io |self_| {
+ let result_cell = Cell::new_empty();
+ let result_cell_ptr: *Cell<Result<uint, IoError>> = &result_cell;
+
+ let scheduler = Local::take::<Scheduler>();
+ let buf_ptr: *&mut [u8] = &buf;
+ do scheduler.deschedule_running_task_and_then |_sched, task| {
+ let task_cell = Cell::new(task);
+ // XXX: We shouldn't reallocate these callbacks every
+ // call to read
+ let alloc: AllocCallback = |_| unsafe {
+ slice_to_uv_buf(*buf_ptr)
};
+ let mut watcher = self_.watcher.as_stream();
+ do watcher.read_start(alloc) |mut watcher, nread, _buf, status| {
- unsafe { (*result_cell_ptr).put_back(result); }
+ // Stop reading so that no read callbacks are
+ // triggered before the user calls `read` again.
+ // XXX: Is there a performance impact to calling
+ // stop here?
+ watcher.read_stop();
- let scheduler = Local::take::<Scheduler>();
- scheduler.resume_blocked_task_immediately(task_cell.take());
+ let result = if status.is_none() {
+ assert!(nread >= 0);
+ Ok(nread as uint)
+ } else {
+ Err(uv_error_to_io_error(status.unwrap()))
+ };
+
+ unsafe { (*result_cell_ptr).put_back(result); }
+
+ let scheduler = Local::take::<Scheduler>();
+ scheduler.resume_blocked_task_immediately(task_cell.take());
+ }
}
- }
- assert!(!result_cell.is_empty());
- return result_cell.take();
+ assert!(!result_cell.is_empty());
+ result_cell.take()
+ }
}
fn write(&mut self, buf: &[u8]) -> Result<(), IoError> {
- let result_cell = Cell::new_empty();
- let result_cell_ptr: *Cell<Result<(), IoError>> = &result_cell;
- let scheduler = Local::take::<Scheduler>();
- let buf_ptr: *&[u8] = &buf;
- do scheduler.deschedule_running_task_and_then |_, task| {
- let task_cell = Cell::new(task);
- let buf = unsafe { slice_to_uv_buf(*buf_ptr) };
- let mut watcher = self.as_stream();
- do watcher.write(buf) |_watcher, status| {
- let result = if status.is_none() {
- Ok(())
- } else {
- Err(uv_error_to_io_error(status.unwrap()))
- };
-
- unsafe { (*result_cell_ptr).put_back(result); }
+ do self.home_for_io |self_| {
+ let result_cell = Cell::new_empty();
+ let result_cell_ptr: *Cell<Result<(), IoError>> = &result_cell;
+ let scheduler = Local::take::<Scheduler>();
+ let buf_ptr: *&[u8] = &buf;
+ do scheduler.deschedule_running_task_and_then |_, task| {
+ let task_cell = Cell::new(task);
+ let buf = unsafe { slice_to_uv_buf(*buf_ptr) };
+ let mut watcher = self_.watcher.as_stream();
+ do watcher.write(buf) |_watcher, status| {
+ let result = if status.is_none() {
+ Ok(())
+ } else {
+ Err(uv_error_to_io_error(status.unwrap()))
+ };
+
+ unsafe { (*result_cell_ptr).put_back(result); }
- let scheduler = Local::take::<Scheduler>();
- scheduler.resume_blocked_task_immediately(task_cell.take());
+ let scheduler = Local::take::<Scheduler>();
+ scheduler.resume_blocked_task_immediately(task_cell.take());
+ }
}
- }
- assert!(!result_cell.is_empty());
- return result_cell.take();
+ assert!(!result_cell.is_empty());
+ result_cell.take()
+ }
}
fn peer_name(&mut self) -> Result<SocketAddr, IoError> {
- socket_name(TcpPeer, **self)
+ do self.home_for_io |self_| {
+ socket_name(TcpPeer, self_.watcher)
+ }
}
fn control_congestion(&mut self) -> Result<(), IoError> {
- let r = unsafe {
- uvll::rust_uv_tcp_nodelay(self.native_handle(), 0 as c_int)
- };
+ do self.home_for_io |self_| {
+ let r = unsafe { uvll::tcp_nodelay(self_.watcher.native_handle(), 0 as c_int) };
- match status_to_maybe_uv_error(**self, r) {
- Some(err) => Err(uv_error_to_io_error(err)),
- None => Ok(())
+ match status_to_maybe_uv_error(self_.watcher, r) {
+ Some(err) => Err(uv_error_to_io_error(err)),
+ None => Ok(())
+ }
}
}
fn nodelay(&mut self) -> Result<(), IoError> {
- let r = unsafe {
- uvll::rust_uv_tcp_nodelay(self.native_handle(), 1 as c_int)
- };
+ do self.home_for_io |self_| {
+ let r = unsafe { uvll::tcp_nodelay(self_.watcher.native_handle(), 1 as c_int) };
- match status_to_maybe_uv_error(**self, r) {
- Some(err) => Err(uv_error_to_io_error(err)),
- None => Ok(())
+ match status_to_maybe_uv_error(self_.watcher, r) {
+ Some(err) => Err(uv_error_to_io_error(err)),
+ None => Ok(())
+ }
}
}
fn keepalive(&mut self, delay_in_seconds: uint) -> Result<(), IoError> {
- let r = unsafe {
- uvll::rust_uv_tcp_keepalive(self.native_handle(), 1 as c_int,
- delay_in_seconds as c_uint)
- };
+ do self.home_for_io |self_| {
+ let r = unsafe {
+ uvll::tcp_keepalive(self_.watcher.native_handle(), 1 as c_int,
+ delay_in_seconds as c_uint)
+ };
- match status_to_maybe_uv_error(**self, r) {
- Some(err) => Err(uv_error_to_io_error(err)),
- None => Ok(())
+ match status_to_maybe_uv_error(self_.watcher, r) {
+ Some(err) => Err(uv_error_to_io_error(err)),
+ None => Ok(())
+ }
}
}
fn letdie(&mut self) -> Result<(), IoError> {
- let r = unsafe {
- uvll::rust_uv_tcp_keepalive(self.native_handle(), 0 as c_int, 0 as c_uint)
- };
+ do self.home_for_io |self_| {
+ let r = unsafe {
+ uvll::tcp_keepalive(self_.watcher.native_handle(), 0 as c_int, 0 as c_uint)
+ };
- match status_to_maybe_uv_error(**self, r) {
- Some(err) => Err(uv_error_to_io_error(err)),
- None => Ok(())
+ match status_to_maybe_uv_error(self_.watcher, r) {
+ Some(err) => Err(uv_error_to_io_error(err)),
+ None => Ok(())
+ }
}
}
}
-pub struct UvUdpSocket(UdpWatcher);
+pub struct UvUdpSocket {
+ watcher: UdpWatcher,
+ home: SchedHandle,
+}
+
+impl HomingIO for UvUdpSocket {
+ fn home<'r>(&'r mut self) -> &'r mut SchedHandle { &mut self.home }
+}
impl Drop for UvUdpSocket {
fn drop(&self) {
- rtdebug!("closing udp socket");
- let scheduler = Local::take::<Scheduler>();
- do scheduler.deschedule_running_task_and_then |_, task| {
- let task_cell = Cell::new(task);
- do self.close {
- let scheduler = Local::take::<Scheduler>();
- scheduler.resume_blocked_task_immediately(task_cell.take());
+ // XXX need mutable finalizer
+ let this = unsafe { transmute::<&UvUdpSocket, &mut UvUdpSocket>(self) };
+ do this.home_for_io |_| {
+ let scheduler = Local::take::<Scheduler>();
+ do scheduler.deschedule_running_task_and_then |_, task| {
+ let task_cell = Cell::new(task);
+ do this.watcher.close {
+ let scheduler = Local::take::<Scheduler>();
+ scheduler.resume_blocked_task_immediately(task_cell.take());
+ }
}
}
}
impl RtioSocket for UvUdpSocket {
fn socket_name(&mut self) -> Result<SocketAddr, IoError> {
- socket_name(Udp, **self)
+ do self.home_for_io |self_| {
+ socket_name(Udp, self_.watcher)
+ }
}
}
impl RtioUdpSocket for UvUdpSocket {
fn recvfrom(&mut self, buf: &mut [u8]) -> Result<(uint, SocketAddr), IoError> {
- let result_cell = Cell::new_empty();
- let result_cell_ptr: *Cell<Result<(uint, SocketAddr), IoError>> = &result_cell;
-
- let scheduler = Local::take::<Scheduler>();
- let buf_ptr: *&mut [u8] = &buf;
- do scheduler.deschedule_running_task_and_then |_sched, task| {
- rtdebug!("recvfrom: entered scheduler context");
- let task_cell = Cell::new(task);
- let alloc: AllocCallback = |_| unsafe { slice_to_uv_buf(*buf_ptr) };
- do self.recv_start(alloc) |mut watcher, nread, _buf, addr, flags, status| {
- let _ = flags; // XXX add handling for partials?
-
- watcher.recv_stop();
+ do self.home_for_io |self_| {
+ let result_cell = Cell::new_empty();
+ let result_cell_ptr: *Cell<Result<(uint, SocketAddr), IoError>> = &result_cell;
+
+ let scheduler = Local::take::<Scheduler>();
+ let buf_ptr: *&mut [u8] = &buf;
+ do scheduler.deschedule_running_task_and_then |_, task| {
+ let task_cell = Cell::new(task);
+ let alloc: AllocCallback = |_| unsafe { slice_to_uv_buf(*buf_ptr) };
+ do self_.watcher.recv_start(alloc) |mut watcher, nread, _buf, addr, flags, status| {
+ let _ = flags; // /XXX add handling for partials?
+
+ watcher.recv_stop();
+
+ let result = match status {
+ None => {
+ assert!(nread >= 0);
+ Ok((nread as uint, addr))
+ }
+ Some(err) => Err(uv_error_to_io_error(err)),
+ };
+
+ unsafe { (*result_cell_ptr).put_back(result); }
- let result = match status {
- None => {
- assert!(nread >= 0);
- Ok((nread as uint, addr))
- }
- Some(err) => Err(uv_error_to_io_error(err))
- };
-
- unsafe { (*result_cell_ptr).put_back(result); }
-
- let scheduler = Local::take::<Scheduler>();
- scheduler.resume_blocked_task_immediately(task_cell.take());
+ let scheduler = Local::take::<Scheduler>();
+ scheduler.resume_blocked_task_immediately(task_cell.take());
+ }
}
- }
- assert!(!result_cell.is_empty());
- return result_cell.take();
+ assert!(!result_cell.is_empty());
+ result_cell.take()
+ }
}
fn sendto(&mut self, buf: &[u8], dst: SocketAddr) -> Result<(), IoError> {
- let result_cell = Cell::new_empty();
- let result_cell_ptr: *Cell<Result<(), IoError>> = &result_cell;
- let scheduler = Local::take::<Scheduler>();
- let buf_ptr: *&[u8] = &buf;
- do scheduler.deschedule_running_task_and_then |_, task| {
- let task_cell = Cell::new(task);
- let buf = unsafe { slice_to_uv_buf(*buf_ptr) };
- do self.send(buf, dst) |_watcher, status| {
-
- let result = match status {
- None => Ok(()),
- Some(err) => Err(uv_error_to_io_error(err)),
- };
-
- unsafe { (*result_cell_ptr).put_back(result); }
+ do self.home_for_io |self_| {
+ let result_cell = Cell::new_empty();
+ let result_cell_ptr: *Cell<Result<(), IoError>> = &result_cell;
+ let scheduler = Local::take::<Scheduler>();
+ let buf_ptr: *&[u8] = &buf;
+ do scheduler.deschedule_running_task_and_then |_, task| {
+ let task_cell = Cell::new(task);
+ let buf = unsafe { slice_to_uv_buf(*buf_ptr) };
+ do self_.watcher.send(buf, dst) |_watcher, status| {
+
+ let result = match status {
+ None => Ok(()),
+ Some(err) => Err(uv_error_to_io_error(err)),
+ };
+
+ unsafe { (*result_cell_ptr).put_back(result); }
- let scheduler = Local::take::<Scheduler>();
- scheduler.resume_blocked_task_immediately(task_cell.take());
+ let scheduler = Local::take::<Scheduler>();
+ scheduler.resume_blocked_task_immediately(task_cell.take());
+ }
}
- }
- assert!(!result_cell.is_empty());
- return result_cell.take();
+ assert!(!result_cell.is_empty());
+ result_cell.take()
+ }
}
fn join_multicast(&mut self, multi: IpAddr) -> Result<(), IoError> {
- let r = unsafe {
- do multi.to_str().with_c_str |m_addr| {
- uvll::udp_set_membership(self.native_handle(), m_addr,
- ptr::null(), uvll::UV_JOIN_GROUP)
- }
- };
+ do self.home_for_io |self_| {
+ let r = unsafe {
+ do multi.to_str().with_c_str |m_addr| {
+ uvll::udp_set_membership(self_.watcher.native_handle(), m_addr,
+ ptr::null(), uvll::UV_JOIN_GROUP)
+ }
+ };
- match status_to_maybe_uv_error(**self, r) {
- Some(err) => Err(uv_error_to_io_error(err)),
- None => Ok(())
+ match status_to_maybe_uv_error(self_.watcher, r) {
+ Some(err) => Err(uv_error_to_io_error(err)),
+ None => Ok(())
+ }
}
}
fn leave_multicast(&mut self, multi: IpAddr) -> Result<(), IoError> {
- let r = unsafe {
- do multi.to_str().with_c_str |m_addr| {
- uvll::udp_set_membership(self.native_handle(), m_addr,
- ptr::null(), uvll::UV_LEAVE_GROUP)
- }
- };
+ do self.home_for_io |self_| {
+ let r = unsafe {
+ do multi.to_str().with_c_str |m_addr| {
+ uvll::udp_set_membership(self_.watcher.native_handle(), m_addr,
+ ptr::null(), uvll::UV_LEAVE_GROUP)
+ }
+ };
- match status_to_maybe_uv_error(**self, r) {
- Some(err) => Err(uv_error_to_io_error(err)),
- None => Ok(())
+ match status_to_maybe_uv_error(self_.watcher, r) {
+ Some(err) => Err(uv_error_to_io_error(err)),
+ None => Ok(())
+ }
}
}
fn loop_multicast_locally(&mut self) -> Result<(), IoError> {
- let r = unsafe {
- uvll::udp_set_multicast_loop(self.native_handle(), 1 as c_int)
- };
+ do self.home_for_io |self_| {
+
+ let r = unsafe {
+ uvll::udp_set_multicast_loop(self_.watcher.native_handle(), 1 as c_int)
+ };
- match status_to_maybe_uv_error(**self, r) {
- Some(err) => Err(uv_error_to_io_error(err)),
- None => Ok(())
+ match status_to_maybe_uv_error(self_.watcher, r) {
+ Some(err) => Err(uv_error_to_io_error(err)),
+ None => Ok(())
+ }
}
}
fn dont_loop_multicast_locally(&mut self) -> Result<(), IoError> {
- let r = unsafe {
- uvll::udp_set_multicast_loop(self.native_handle(), 0 as c_int)
- };
+ do self.home_for_io |self_| {
- match status_to_maybe_uv_error(**self, r) {
- Some(err) => Err(uv_error_to_io_error(err)),
- None => Ok(())
+ let r = unsafe {
+ uvll::udp_set_multicast_loop(self_.watcher.native_handle(), 0 as c_int)
+ };
+
+ match status_to_maybe_uv_error(self_.watcher, r) {
+ Some(err) => Err(uv_error_to_io_error(err)),
+ None => Ok(())
+ }
}
}
fn multicast_time_to_live(&mut self, ttl: int) -> Result<(), IoError> {
- let r = unsafe {
- uvll::udp_set_multicast_ttl(self.native_handle(), ttl as c_int)
- };
+ do self.home_for_io |self_| {
- match status_to_maybe_uv_error(**self, r) {
- Some(err) => Err(uv_error_to_io_error(err)),
- None => Ok(())
+ let r = unsafe {
+ uvll::udp_set_multicast_ttl(self_.watcher.native_handle(), ttl as c_int)
+ };
+
+ match status_to_maybe_uv_error(self_.watcher, r) {
+ Some(err) => Err(uv_error_to_io_error(err)),
+ None => Ok(())
+ }
}
}
fn time_to_live(&mut self, ttl: int) -> Result<(), IoError> {
- let r = unsafe {
- uvll::udp_set_ttl(self.native_handle(), ttl as c_int)
- };
+ do self.home_for_io |self_| {
+
+ let r = unsafe {
+ uvll::udp_set_ttl(self_.watcher.native_handle(), ttl as c_int)
+ };
- match status_to_maybe_uv_error(**self, r) {
- Some(err) => Err(uv_error_to_io_error(err)),
- None => Ok(())
+ match status_to_maybe_uv_error(self_.watcher, r) {
+ Some(err) => Err(uv_error_to_io_error(err)),
+ None => Ok(())
+ }
}
}
fn hear_broadcasts(&mut self) -> Result<(), IoError> {
- let r = unsafe {
- uvll::udp_set_broadcast(self.native_handle(), 1 as c_int)
- };
+ do self.home_for_io |self_| {
+
+ let r = unsafe {
+ uvll::udp_set_broadcast(self_.watcher.native_handle(), 1 as c_int)
+ };
- match status_to_maybe_uv_error(**self, r) {
- Some(err) => Err(uv_error_to_io_error(err)),
- None => Ok(())
+ match status_to_maybe_uv_error(self_.watcher, r) {
+ Some(err) => Err(uv_error_to_io_error(err)),
+ None => Ok(())
+ }
}
}
fn ignore_broadcasts(&mut self) -> Result<(), IoError> {
- let r = unsafe {
- uvll::udp_set_broadcast(self.native_handle(), 0 as c_int)
- };
+ do self.home_for_io |self_| {
- match status_to_maybe_uv_error(**self, r) {
- Some(err) => Err(uv_error_to_io_error(err)),
- None => Ok(())
+ let r = unsafe {
+ uvll::udp_set_broadcast(self_.watcher.native_handle(), 0 as c_int)
+ };
+
+ match status_to_maybe_uv_error(self_.watcher, r) {
+ Some(err) => Err(uv_error_to_io_error(err)),
+ None => Ok(())
+ }
}
}
}
-pub struct UvTimer(timer::TimerWatcher);
+pub struct UvTimer {
+ watcher: timer::TimerWatcher,
+ home: SchedHandle,
+}
+
+impl HomingIO for UvTimer {
+ fn home<'r>(&'r mut self) -> &'r mut SchedHandle { &mut self.home }
+}
impl UvTimer {
- fn new(w: timer::TimerWatcher) -> UvTimer {
- UvTimer(w)
+ fn new(w: timer::TimerWatcher, home: SchedHandle) -> UvTimer {
+ UvTimer { watcher: w, home: home }
}
}
impl Drop for UvTimer {
fn drop(&self) {
- rtdebug!("closing UvTimer");
- let scheduler = Local::take::<Scheduler>();
- do scheduler.deschedule_running_task_and_then |_, task| {
- let task_cell = Cell::new(task);
- do self.close {
- let scheduler = Local::take::<Scheduler>();
- scheduler.resume_blocked_task_immediately(task_cell.take());
+ let self_ = unsafe { transmute::<&UvTimer, &mut UvTimer>(self) };
+ do self_.home_for_io |self_| {
+ rtdebug!("closing UvTimer");
+ let scheduler = Local::take::<Scheduler>();
+ do scheduler.deschedule_running_task_and_then |_, task| {
+ let task_cell = Cell::new(task);
+ do self_.watcher.close {
+ let scheduler = Local::take::<Scheduler>();
+ scheduler.resume_blocked_task_immediately(task_cell.take());
+ }
}
}
}
}
impl RtioTimer for UvTimer {
- fn sleep(&self, msecs: u64) {
- let scheduler = Local::take::<Scheduler>();
- do scheduler.deschedule_running_task_and_then |_sched, task| {
- rtdebug!("sleep: entered scheduler context");
- let task_cell = Cell::new(task);
- let mut watcher = **self;
- do watcher.start(msecs, 0) |_, status| {
- assert!(status.is_none());
- let scheduler = Local::take::<Scheduler>();
- scheduler.resume_blocked_task_immediately(task_cell.take());
+ fn sleep(&mut self, msecs: u64) {
+ do self.home_for_io |self_| {
+ let scheduler = Local::take::<Scheduler>();
+ do scheduler.deschedule_running_task_and_then |_sched, task| {
+ rtdebug!("sleep: entered scheduler context");
+ let task_cell = Cell::new(task);
+ do self_.watcher.start(msecs, 0) |_, status| {
+ assert!(status.is_none());
+ let scheduler = Local::take::<Scheduler>();
+ scheduler.resume_blocked_task_immediately(task_cell.take());
+ }
}
+ self_.watcher.stop();
}
- let mut w = **self;
- w.stop();
}
}
}
}
+#[test]
+fn test_simple_homed_udp_io_bind_then_move_task_then_home_and_close() {
+ use rt::sleeper_list::SleeperList;
+ use rt::work_queue::WorkQueue;
+ use rt::thread::Thread;
+ use rt::task::Task;
+ use rt::sched::{Shutdown, TaskFromFriend};
+ do run_in_bare_thread {
+ let sleepers = SleeperList::new();
+ let work_queue1 = WorkQueue::new();
+ let work_queue2 = WorkQueue::new();
+ let queues = ~[work_queue1.clone(), work_queue2.clone()];
+
+ let mut sched1 = ~Scheduler::new(~UvEventLoop::new(), work_queue1, queues.clone(),
+ sleepers.clone());
+ let mut sched2 = ~Scheduler::new(~UvEventLoop::new(), work_queue2, queues.clone(),
+ sleepers.clone());
+
+ let handle1 = Cell::new(sched1.make_handle());
+ let handle2 = Cell::new(sched2.make_handle());
+ let tasksFriendHandle = Cell::new(sched2.make_handle());
+
+ let on_exit: ~fn(bool) = |exit_status| {
+ handle1.take().send(Shutdown);
+ handle2.take().send(Shutdown);
+ rtassert!(exit_status);
+ };
+
+ let test_function: ~fn() = || {
+ let io = unsafe { Local::unsafe_borrow::<IoFactoryObject>() };
+ let addr = next_test_ip4();
+ let maybe_socket = unsafe { (*io).udp_bind(addr) };
+ // this socket is bound to this event loop
+ assert!(maybe_socket.is_ok());
+
+ // block self on sched1
+ let scheduler = Local::take::<Scheduler>();
+ do scheduler.deschedule_running_task_and_then |_, task| {
+ // unblock task
+ do task.wake().map_move |task| {
+ // send self to sched2
+ tasksFriendHandle.take().send(TaskFromFriend(task));
+ };
+ // sched1 should now sleep since it has nothing else to do
+ }
+ // sched2 will wake up and get the task
+ // as we do nothing else, the function ends and the socket goes out of scope
+ // sched2 will start to run the destructor
+ // the destructor will first block the task, set it's home as sched1, then enqueue it
+ // sched2 will dequeue the task, see that it has a home, and send it to sched1
+ // sched1 will wake up, exec the close function on the correct loop, and then we're done
+ };
+
+ let mut main_task = ~Task::new_root(&mut sched1.stack_pool, None, test_function);
+ main_task.death.on_exit = Some(on_exit);
+ let main_task = Cell::new(main_task);
+
+ let null_task = Cell::new(~do Task::new_root(&mut sched2.stack_pool, None) || {});
+
+ let sched1 = Cell::new(sched1);
+ let sched2 = Cell::new(sched2);
+
+ let thread1 = do Thread::start {
+ sched1.take().bootstrap(main_task.take());
+ };
+ let thread2 = do Thread::start {
+ sched2.take().bootstrap(null_task.take());
+ };
+
+ thread1.join();
+ thread2.join();
+ }
+}
+
+#[test]
+fn test_simple_homed_udp_io_bind_then_move_handle_then_home_and_close() {
+ use rt::sleeper_list::SleeperList;
+ use rt::work_queue::WorkQueue;
+ use rt::thread::Thread;
+ use rt::task::Task;
+ use rt::comm::oneshot;
+ use rt::sched::Shutdown;
+ do run_in_bare_thread {
+ let sleepers = SleeperList::new();
+ let work_queue1 = WorkQueue::new();
+ let work_queue2 = WorkQueue::new();
+ let queues = ~[work_queue1.clone(), work_queue2.clone()];
+
+ let mut sched1 = ~Scheduler::new(~UvEventLoop::new(), work_queue1, queues.clone(),
+ sleepers.clone());
+ let mut sched2 = ~Scheduler::new(~UvEventLoop::new(), work_queue2, queues.clone(),
+ sleepers.clone());
+
+ let handle1 = Cell::new(sched1.make_handle());
+ let handle2 = Cell::new(sched2.make_handle());
+
+ let (port, chan) = oneshot();
+ let port = Cell::new(port);
+ let chan = Cell::new(chan);
+
+ let body1: ~fn() = || {
+ let io = unsafe { Local::unsafe_borrow::<IoFactoryObject>() };
+ let addr = next_test_ip4();
+ let socket = unsafe { (*io).udp_bind(addr) };
+ assert!(socket.is_ok());
+ chan.take().send(socket);
+ };
+
+ let body2: ~fn() = || {
+ let socket = port.take().recv();
+ assert!(socket.is_ok());
+ /* The socket goes out of scope and the destructor is called.
+ * The destructor:
+ * - sends itself back to sched1
+ * - frees the socket
+ * - resets the home of the task to whatever it was previously
+ */
+ };
+
+ let on_exit: ~fn(bool) = |exit| {
+ handle1.take().send(Shutdown);
+ handle2.take().send(Shutdown);
+ rtassert!(exit);
+ };
+
+ let task1 = Cell::new(~Task::new_root(&mut sched1.stack_pool, None, body1));
+
+ let mut task2 = ~Task::new_root(&mut sched2.stack_pool, None, body2);
+ task2.death.on_exit = Some(on_exit);
+ let task2 = Cell::new(task2);
+
+ let sched1 = Cell::new(sched1);
+ let sched2 = Cell::new(sched2);
+
+ let thread1 = do Thread::start {
+ sched1.take().bootstrap(task1.take());
+ };
+ let thread2 = do Thread::start {
+ sched2.take().bootstrap(task2.take());
+ };
+
+ thread1.join();
+ thread2.join();
+ }
+}
+
#[test]
fn test_simple_tcp_server_and_client() {
do run_in_newsched_task {
}
}
+#[test]
+fn test_simple_tcp_server_and_client_on_diff_threads() {
+ use rt::sleeper_list::SleeperList;
+ use rt::work_queue::WorkQueue;
+ use rt::thread::Thread;
+ use rt::task::Task;
+ use rt::sched::{Shutdown};
+ do run_in_bare_thread {
+ let sleepers = SleeperList::new();
+
+ let server_addr = next_test_ip4();
+ let client_addr = server_addr.clone();
+
+ let server_work_queue = WorkQueue::new();
+ let client_work_queue = WorkQueue::new();
+ let queues = ~[server_work_queue.clone(), client_work_queue.clone()];
+
+ let mut server_sched = ~Scheduler::new(~UvEventLoop::new(), server_work_queue,
+ queues.clone(), sleepers.clone());
+ let mut client_sched = ~Scheduler::new(~UvEventLoop::new(), client_work_queue,
+ queues.clone(), sleepers.clone());
+
+ let server_handle = Cell::new(server_sched.make_handle());
+ let client_handle = Cell::new(client_sched.make_handle());
+
+ let server_on_exit: ~fn(bool) = |exit_status| {
+ server_handle.take().send(Shutdown);
+ rtassert!(exit_status);
+ };
+
+ let client_on_exit: ~fn(bool) = |exit_status| {
+ client_handle.take().send(Shutdown);
+ rtassert!(exit_status);
+ };
+
+ let server_fn: ~fn() = || {
+ let io = unsafe { Local::unsafe_borrow::<IoFactoryObject>() };
+ let mut listener = unsafe { (*io).tcp_bind(server_addr).unwrap() };
+ let mut stream = listener.accept().unwrap();
+ let mut buf = [0, .. 2048];
+ let nread = stream.read(buf).unwrap();
+ assert_eq!(nread, 8);
+ for i in range(0u, nread) {
+ assert_eq!(buf[i], i as u8);
+ }
+ };
+
+ let client_fn: ~fn() = || {
+ let io = unsafe { Local::unsafe_borrow::<IoFactoryObject>() };
+ let mut stream = unsafe { (*io).tcp_connect(client_addr) };
+ while stream.is_err() {
+ stream = unsafe { (*io).tcp_connect(client_addr) };
+ }
+ stream.unwrap().write([0, 1, 2, 3, 4, 5, 6, 7]);
+ };
+
+ let mut server_task = ~Task::new_root(&mut server_sched.stack_pool, None, server_fn);
+ server_task.death.on_exit = Some(server_on_exit);
+ let server_task = Cell::new(server_task);
+
+ let mut client_task = ~Task::new_root(&mut client_sched.stack_pool, None, client_fn);
+ client_task.death.on_exit = Some(client_on_exit);
+ let client_task = Cell::new(client_task);
+
+ let server_sched = Cell::new(server_sched);
+ let client_sched = Cell::new(client_sched);
+
+ let server_thread = do Thread::start {
+ server_sched.take().bootstrap(server_task.take());
+ };
+ let client_thread = do Thread::start {
+ client_sched.take().bootstrap(client_task.take());
+ };
+
+ server_thread.join();
+ client_thread.join();
+ }
+}
+
#[test]
fn test_simple_udp_server_and_client() {
do run_in_newsched_task {
}
}
-fn test_timer_sleep_simple_impl() {
- unsafe {
- let io = Local::unsafe_borrow::<IoFactoryObject>();
- let timer = (*io).timer_init();
- match timer {
- Ok(t) => t.sleep(1),
- Err(_) => assert!(false)
- }
- }
-}
#[test]
fn test_timer_sleep_simple() {
do run_in_newsched_task {
- test_timer_sleep_simple_impl();
+ unsafe {
+ let io = Local::unsafe_borrow::<IoFactoryObject>();
+ let timer = (*io).timer_init();
+ do timer.map_move |mut t| { t.sleep(1) };
+ }
}
}
* There are also a collection of helper functions to ease interacting
* with the low-level API.
*
- * As new functionality, existant in uv.h, is added to the rust stdlib,
+ * As new functionality, existent in uv.h, is added to the rust stdlib,
* the mappings should be added in this module.
*/
}
pub unsafe fn malloc_handle(handle: uv_handle_type) -> *c_void {
+ #[fixed_stack_segment]; #[inline(never)];
+
assert!(handle != UV_UNKNOWN_HANDLE && handle != UV_HANDLE_TYPE_MAX);
let size = rust_uv_handle_size(handle as uint);
let p = malloc(size);
}
pub unsafe fn free_handle(v: *c_void) {
+ #[fixed_stack_segment]; #[inline(never)];
+
free(v)
}
pub unsafe fn malloc_req(req: uv_req_type) -> *c_void {
+ #[fixed_stack_segment]; #[inline(never)];
+
assert!(req != UV_UNKNOWN_REQ && req != UV_REQ_TYPE_MAX);
let size = rust_uv_req_size(req as uint);
let p = malloc(size);
}
pub unsafe fn free_req(v: *c_void) {
+ #[fixed_stack_segment]; #[inline(never)];
+
free(v)
}
#[test]
fn handle_sanity_check() {
+ #[fixed_stack_segment]; #[inline(never)];
unsafe {
assert_eq!(UV_HANDLE_TYPE_MAX as uint, rust_uv_handle_type_max());
}
}
#[test]
+#[fixed_stack_segment]
+#[inline(never)]
fn request_sanity_check() {
unsafe {
assert_eq!(UV_REQ_TYPE_MAX as uint, rust_uv_req_type_max());
}
}
+// XXX Event loops ignore SIGPIPE by default.
pub unsafe fn loop_new() -> *c_void {
+ #[fixed_stack_segment]; #[inline(never)];
+
return rust_uv_loop_new();
}
pub unsafe fn loop_delete(loop_handle: *c_void) {
+ #[fixed_stack_segment]; #[inline(never)];
+
rust_uv_loop_delete(loop_handle);
}
pub unsafe fn run(loop_handle: *c_void) {
+ #[fixed_stack_segment]; #[inline(never)];
+
rust_uv_run(loop_handle);
}
pub unsafe fn close<T>(handle: *T, cb: *u8) {
+ #[fixed_stack_segment]; #[inline(never)];
+
rust_uv_close(handle as *c_void, cb);
}
pub unsafe fn walk(loop_handle: *c_void, cb: *u8, arg: *c_void) {
+ #[fixed_stack_segment]; #[inline(never)];
+
rust_uv_walk(loop_handle, cb, arg);
}
pub unsafe fn idle_new() -> *uv_idle_t {
+ #[fixed_stack_segment]; #[inline(never)];
+
rust_uv_idle_new()
}
pub unsafe fn idle_delete(handle: *uv_idle_t) {
+ #[fixed_stack_segment]; #[inline(never)];
+
rust_uv_idle_delete(handle)
}
pub unsafe fn idle_init(loop_handle: *uv_loop_t, handle: *uv_idle_t) -> c_int {
+ #[fixed_stack_segment]; #[inline(never)];
+
rust_uv_idle_init(loop_handle, handle)
}
pub unsafe fn idle_start(handle: *uv_idle_t, cb: uv_idle_cb) -> c_int {
+ #[fixed_stack_segment]; #[inline(never)];
+
rust_uv_idle_start(handle, cb)
}
pub unsafe fn idle_stop(handle: *uv_idle_t) -> c_int {
+ #[fixed_stack_segment]; #[inline(never)];
+
rust_uv_idle_stop(handle)
}
pub unsafe fn udp_init(loop_handle: *uv_loop_t, handle: *uv_udp_t) -> c_int {
+ #[fixed_stack_segment]; #[inline(never)];
+
return rust_uv_udp_init(loop_handle, handle);
}
pub unsafe fn udp_bind(server: *uv_udp_t, addr: *sockaddr_in, flags: c_uint) -> c_int {
+ #[fixed_stack_segment]; #[inline(never)];
+
return rust_uv_udp_bind(server, addr, flags);
}
pub unsafe fn udp_bind6(server: *uv_udp_t, addr: *sockaddr_in6, flags: c_uint) -> c_int {
+ #[fixed_stack_segment]; #[inline(never)];
+
return rust_uv_udp_bind6(server, addr, flags);
}
pub unsafe fn udp_send<T>(req: *uv_udp_send_t, handle: *T, buf_in: &[uv_buf_t],
addr: *sockaddr_in, cb: uv_udp_send_cb) -> c_int {
+ #[fixed_stack_segment]; #[inline(never)];
+
let buf_ptr = vec::raw::to_ptr(buf_in);
let buf_cnt = buf_in.len() as i32;
return rust_uv_udp_send(req, handle as *c_void, buf_ptr, buf_cnt, addr, cb);
pub unsafe fn udp_send6<T>(req: *uv_udp_send_t, handle: *T, buf_in: &[uv_buf_t],
addr: *sockaddr_in6, cb: uv_udp_send_cb) -> c_int {
+ #[fixed_stack_segment]; #[inline(never)];
+
let buf_ptr = vec::raw::to_ptr(buf_in);
let buf_cnt = buf_in.len() as i32;
return rust_uv_udp_send6(req, handle as *c_void, buf_ptr, buf_cnt, addr, cb);
pub unsafe fn udp_recv_start(server: *uv_udp_t, on_alloc: uv_alloc_cb,
on_recv: uv_udp_recv_cb) -> c_int {
+ #[fixed_stack_segment]; #[inline(never)];
+
return rust_uv_udp_recv_start(server, on_alloc, on_recv);
}
pub unsafe fn udp_recv_stop(server: *uv_udp_t) -> c_int {
+ #[fixed_stack_segment]; #[inline(never)];
+
return rust_uv_udp_recv_stop(server);
}
pub unsafe fn get_udp_handle_from_send_req(send_req: *uv_udp_send_t) -> *uv_udp_t {
+ #[fixed_stack_segment]; #[inline(never)];
+
return rust_uv_get_udp_handle_from_send_req(send_req);
}
-pub unsafe fn udp_get_sockname(handle: *uv_udp_t, name: *sockaddr_storage) -> c_int {
+pub unsafe fn udp_getsockname(handle: *uv_udp_t, name: *sockaddr_storage) -> c_int {
+ #[fixed_stack_segment]; #[inline(never)];
+
return rust_uv_udp_getsockname(handle, name);
}
pub unsafe fn udp_set_membership(handle: *uv_udp_t, multicast_addr: *c_char,
interface_addr: *c_char, membership: uv_membership) -> c_int {
+ #[fixed_stack_segment]; #[inline(never)];
+
return rust_uv_udp_set_membership(handle, multicast_addr, interface_addr, membership as c_int);
}
pub unsafe fn udp_set_multicast_loop(handle: *uv_udp_t, on: c_int) -> c_int {
+ #[fixed_stack_segment]; #[inline(never)];
+
return rust_uv_udp_set_multicast_loop(handle, on);
}
pub unsafe fn udp_set_multicast_ttl(handle: *uv_udp_t, ttl: c_int) -> c_int {
+ #[fixed_stack_segment]; #[inline(never)];
+
return rust_uv_udp_set_multicast_ttl(handle, ttl);
}
pub unsafe fn udp_set_ttl(handle: *uv_udp_t, ttl: c_int) -> c_int {
+ #[fixed_stack_segment]; #[inline(never)];
+
return rust_uv_udp_set_ttl(handle, ttl);
}
pub unsafe fn udp_set_broadcast(handle: *uv_udp_t, on: c_int) -> c_int {
+ #[fixed_stack_segment]; #[inline(never)];
+
return rust_uv_udp_set_broadcast(handle, on);
}
pub unsafe fn tcp_init(loop_handle: *c_void, handle: *uv_tcp_t) -> c_int {
+ #[fixed_stack_segment]; #[inline(never)];
+
return rust_uv_tcp_init(loop_handle, handle);
}
pub unsafe fn tcp_connect(connect_ptr: *uv_connect_t, tcp_handle_ptr: *uv_tcp_t,
addr_ptr: *sockaddr_in, after_connect_cb: *u8) -> c_int {
+ #[fixed_stack_segment]; #[inline(never)];
+
return rust_uv_tcp_connect(connect_ptr, tcp_handle_ptr, after_connect_cb, addr_ptr);
}
pub unsafe fn tcp_connect6(connect_ptr: *uv_connect_t, tcp_handle_ptr: *uv_tcp_t,
addr_ptr: *sockaddr_in6, after_connect_cb: *u8) -> c_int {
+ #[fixed_stack_segment]; #[inline(never)];
+
return rust_uv_tcp_connect6(connect_ptr, tcp_handle_ptr, after_connect_cb, addr_ptr);
}
pub unsafe fn tcp_bind(tcp_server_ptr: *uv_tcp_t, addr_ptr: *sockaddr_in) -> c_int {
+ #[fixed_stack_segment]; #[inline(never)];
+
return rust_uv_tcp_bind(tcp_server_ptr, addr_ptr);
}
pub unsafe fn tcp_bind6(tcp_server_ptr: *uv_tcp_t, addr_ptr: *sockaddr_in6) -> c_int {
+ #[fixed_stack_segment]; #[inline(never)];
+
return rust_uv_tcp_bind6(tcp_server_ptr, addr_ptr);
}
pub unsafe fn tcp_getpeername(tcp_handle_ptr: *uv_tcp_t, name: *sockaddr_storage) -> c_int {
+ #[fixed_stack_segment]; #[inline(never)];
+
return rust_uv_tcp_getpeername(tcp_handle_ptr, name);
}
pub unsafe fn tcp_getsockname(handle: *uv_tcp_t, name: *sockaddr_storage) -> c_int {
+ #[fixed_stack_segment]; #[inline(never)];
+
return rust_uv_tcp_getsockname(handle, name);
}
pub unsafe fn tcp_nodelay(handle: *uv_tcp_t, enable: c_int) -> c_int {
+ #[fixed_stack_segment]; #[inline(never)];
+
return rust_uv_tcp_nodelay(handle, enable);
}
pub unsafe fn tcp_keepalive(handle: *uv_tcp_t, enable: c_int, delay: c_uint) -> c_int {
+ #[fixed_stack_segment]; #[inline(never)];
+
return rust_uv_tcp_keepalive(handle, enable, delay);
}
pub unsafe fn tcp_simultaneous_accepts(handle: *uv_tcp_t, enable: c_int) -> c_int {
+ #[fixed_stack_segment]; #[inline(never)];
+
return rust_uv_tcp_simultaneous_accepts(handle, enable);
}
pub unsafe fn listen<T>(stream: *T, backlog: c_int, cb: *u8) -> c_int {
+ #[fixed_stack_segment]; #[inline(never)];
+
return rust_uv_listen(stream as *c_void, backlog, cb);
}
pub unsafe fn accept(server: *c_void, client: *c_void) -> c_int {
+ #[fixed_stack_segment]; #[inline(never)];
+
return rust_uv_accept(server as *c_void, client as *c_void);
}
pub unsafe fn write<T>(req: *uv_write_t, stream: *T, buf_in: &[uv_buf_t], cb: *u8) -> c_int {
+ #[fixed_stack_segment]; #[inline(never)];
+
let buf_ptr = vec::raw::to_ptr(buf_in);
let buf_cnt = buf_in.len() as i32;
return rust_uv_write(req as *c_void, stream as *c_void, buf_ptr, buf_cnt, cb);
}
pub unsafe fn read_start(stream: *uv_stream_t, on_alloc: uv_alloc_cb, on_read: *u8) -> c_int {
+ #[fixed_stack_segment]; #[inline(never)];
+
return rust_uv_read_start(stream as *c_void, on_alloc, on_read);
}
pub unsafe fn read_stop(stream: *uv_stream_t) -> c_int {
+ #[fixed_stack_segment]; #[inline(never)];
+
return rust_uv_read_stop(stream as *c_void);
}
pub unsafe fn last_error(loop_handle: *c_void) -> uv_err_t {
+ #[fixed_stack_segment]; #[inline(never)];
+
return rust_uv_last_error(loop_handle);
}
pub unsafe fn strerror(err: *uv_err_t) -> *c_char {
+ #[fixed_stack_segment]; #[inline(never)];
+
return rust_uv_strerror(err);
}
pub unsafe fn err_name(err: *uv_err_t) -> *c_char {
+ #[fixed_stack_segment]; #[inline(never)];
+
return rust_uv_err_name(err);
}
pub unsafe fn async_init(loop_handle: *c_void, async_handle: *uv_async_t, cb: *u8) -> c_int {
+ #[fixed_stack_segment]; #[inline(never)];
+
return rust_uv_async_init(loop_handle, async_handle, cb);
}
pub unsafe fn async_send(async_handle: *uv_async_t) {
+ #[fixed_stack_segment]; #[inline(never)];
+
return rust_uv_async_send(async_handle);
}
pub unsafe fn buf_init(input: *u8, len: uint) -> uv_buf_t {
+ #[fixed_stack_segment]; #[inline(never)];
+
let out_buf = uv_buf_t { base: ptr::null(), len: 0 as size_t };
let out_buf_ptr = ptr::to_unsafe_ptr(&out_buf);
rust_uv_buf_init(out_buf_ptr, input, len as size_t);
}
pub unsafe fn timer_init(loop_ptr: *c_void, timer_ptr: *uv_timer_t) -> c_int {
+ #[fixed_stack_segment]; #[inline(never)];
+
return rust_uv_timer_init(loop_ptr, timer_ptr);
}
pub unsafe fn timer_start(timer_ptr: *uv_timer_t, cb: *u8, timeout: u64,
repeat: u64) -> c_int {
+ #[fixed_stack_segment]; #[inline(never)];
+
return rust_uv_timer_start(timer_ptr, cb, timeout, repeat);
}
pub unsafe fn timer_stop(timer_ptr: *uv_timer_t) -> c_int {
+ #[fixed_stack_segment]; #[inline(never)];
+
return rust_uv_timer_stop(timer_ptr);
}
pub unsafe fn is_ip4_addr(addr: *sockaddr) -> bool {
+ #[fixed_stack_segment]; #[inline(never)];
+
match rust_uv_is_ipv4_sockaddr(addr) { 0 => false, _ => true }
}
pub unsafe fn is_ip6_addr(addr: *sockaddr) -> bool {
+ #[fixed_stack_segment]; #[inline(never)];
+
match rust_uv_is_ipv6_sockaddr(addr) { 0 => false, _ => true }
}
pub unsafe fn malloc_ip4_addr(ip: &str, port: int) -> *sockaddr_in {
+ #[fixed_stack_segment]; #[inline(never)];
do ip.with_c_str |ip_buf| {
rust_uv_ip4_addrp(ip_buf as *u8, port as libc::c_int)
}
}
pub unsafe fn malloc_ip6_addr(ip: &str, port: int) -> *sockaddr_in6 {
+ #[fixed_stack_segment]; #[inline(never)];
do ip.with_c_str |ip_buf| {
rust_uv_ip6_addrp(ip_buf as *u8, port as libc::c_int)
}
}
pub unsafe fn malloc_sockaddr_storage() -> *sockaddr_storage {
+ #[fixed_stack_segment]; #[inline(never)];
+
rust_uv_malloc_sockaddr_storage()
}
pub unsafe fn free_sockaddr_storage(ss: *sockaddr_storage) {
+ #[fixed_stack_segment]; #[inline(never)];
+
rust_uv_free_sockaddr_storage(ss);
}
pub unsafe fn free_ip4_addr(addr: *sockaddr_in) {
+ #[fixed_stack_segment]; #[inline(never)];
+
rust_uv_free_ip4_addr(addr);
}
pub unsafe fn free_ip6_addr(addr: *sockaddr_in6) {
+ #[fixed_stack_segment]; #[inline(never)];
+
rust_uv_free_ip6_addr(addr);
}
pub unsafe fn ip4_name(addr: *sockaddr_in, dst: *u8, size: size_t) -> c_int {
+ #[fixed_stack_segment]; #[inline(never)];
+
return rust_uv_ip4_name(addr, dst, size);
}
pub unsafe fn ip6_name(addr: *sockaddr_in6, dst: *u8, size: size_t) -> c_int {
+ #[fixed_stack_segment]; #[inline(never)];
+
return rust_uv_ip6_name(addr, dst, size);
}
pub unsafe fn ip4_port(addr: *sockaddr_in) -> c_uint {
+ #[fixed_stack_segment]; #[inline(never)];
+
return rust_uv_ip4_port(addr);
}
pub unsafe fn ip6_port(addr: *sockaddr_in6) -> c_uint {
+ #[fixed_stack_segment]; #[inline(never)];
+
return rust_uv_ip6_port(addr);
}
// data access helpers
pub unsafe fn get_loop_for_uv_handle<T>(handle: *T) -> *c_void {
+ #[fixed_stack_segment]; #[inline(never)];
+
return rust_uv_get_loop_for_uv_handle(handle as *c_void);
}
pub unsafe fn get_stream_handle_from_connect_req(connect: *uv_connect_t) -> *uv_stream_t {
+ #[fixed_stack_segment]; #[inline(never)];
+
return rust_uv_get_stream_handle_from_connect_req(connect);
}
pub unsafe fn get_stream_handle_from_write_req(write_req: *uv_write_t) -> *uv_stream_t {
+ #[fixed_stack_segment]; #[inline(never)];
+
return rust_uv_get_stream_handle_from_write_req(write_req);
}
pub unsafe fn get_data_for_uv_loop(loop_ptr: *c_void) -> *c_void {
+ #[fixed_stack_segment]; #[inline(never)];
+
rust_uv_get_data_for_uv_loop(loop_ptr)
}
pub unsafe fn set_data_for_uv_loop(loop_ptr: *c_void, data: *c_void) {
+ #[fixed_stack_segment]; #[inline(never)];
+
rust_uv_set_data_for_uv_loop(loop_ptr, data);
}
pub unsafe fn get_data_for_uv_handle<T>(handle: *T) -> *c_void {
+ #[fixed_stack_segment]; #[inline(never)];
+
return rust_uv_get_data_for_uv_handle(handle as *c_void);
}
pub unsafe fn set_data_for_uv_handle<T, U>(handle: *T, data: *U) {
+ #[fixed_stack_segment]; #[inline(never)];
+
rust_uv_set_data_for_uv_handle(handle as *c_void, data as *c_void);
}
pub unsafe fn get_data_for_req<T>(req: *T) -> *c_void {
+ #[fixed_stack_segment]; #[inline(never)];
+
return rust_uv_get_data_for_req(req as *c_void);
}
pub unsafe fn set_data_for_req<T, U>(req: *T, data: *U) {
+ #[fixed_stack_segment]; #[inline(never)];
+
rust_uv_set_data_for_req(req as *c_void, data as *c_void);
}
pub unsafe fn get_base_from_buf(buf: uv_buf_t) -> *u8 {
+ #[fixed_stack_segment]; #[inline(never)];
+
return rust_uv_get_base_from_buf(buf);
}
pub unsafe fn get_len_from_buf(buf: uv_buf_t) -> size_t {
+ #[fixed_stack_segment]; #[inline(never)];
+
return rust_uv_get_len_from_buf(buf);
}
pub unsafe fn get_last_err_info(uv_loop: *c_void) -> ~str {
in_fd: Option<c_int>,
/**
- * If this is None then a new pipe will be created for the new progam's
+ * If this is None then a new pipe will be created for the new program's
* output and Process.output() will provide a Reader to read from this pipe.
*
* If this is Some(file-descriptor) then the new process will write its output
out_fd: Option<c_int>,
/**
- * If this is None then a new pipe will be created for the new progam's
+ * If this is None then a new pipe will be created for the new program's
* error stream and Process.error() will provide a Reader to read from this pipe.
*
* If this is Some(file-descriptor) then the new process will write its error output
* * options - Options to configure the environment of the process,
* the working directory and the standard IO streams.
*/
- pub fn new(prog: &str, args: &[~str], options: ProcessOptions)
+ pub fn new(prog: &str, args: &[~str],
+ options: ProcessOptions)
-> Process {
+ #[fixed_stack_segment]; #[inline(never)];
+
let (in_pipe, in_fd) = match options.in_fd {
None => {
let pipe = os::pipe();
* method does nothing.
*/
pub fn close_input(&mut self) {
+ #[fixed_stack_segment]; #[inline(never)];
match self.input {
Some(-1) | None => (),
Some(fd) => {
}
fn close_outputs(&mut self) {
+ #[fixed_stack_segment]; #[inline(never)];
fclose_and_null(&mut self.output);
fclose_and_null(&mut self.error);
fn fclose_and_null(f_opt: &mut Option<*libc::FILE>) {
+ #[allow(cstack)]; // fixed_stack_segment declared on enclosing fn
match *f_opt {
Some(f) if !f.is_null() => {
unsafe {
#[cfg(windows)]
fn killpid(pid: pid_t, _force: bool) {
+ #[fixed_stack_segment]; #[inline(never)];
unsafe {
libc::funcs::extra::kernel32::TerminateProcess(
cast::transmute(pid), 1);
#[cfg(unix)]
fn killpid(pid: pid_t, force: bool) {
+ #[fixed_stack_segment]; #[inline(never)];
+
let signal = if force {
libc::consts::os::posix88::SIGKILL
} else {
env: Option<~[(~str, ~str)]>,
dir: Option<&Path>,
in_fd: c_int, out_fd: c_int, err_fd: c_int) -> SpawnProcessResult {
+ #[fixed_stack_segment]; #[inline(never)];
use libc::types::os::arch::extra::{DWORD, HANDLE, STARTUPINFO};
use libc::consts::os::extra::{
env: Option<~[(~str, ~str)]>,
dir: Option<&Path>,
in_fd: c_int, out_fd: c_int, err_fd: c_int) -> SpawnProcessResult {
+ #[fixed_stack_segment]; #[inline(never)];
use libc::funcs::posix88::unistd::{fork, dup2, close, chdir, execvp};
use libc::funcs::bsd44::getdtablesize;
#[cfg(windows)]
fn free_handle(handle: *()) {
+ #[fixed_stack_segment]; #[inline(never)];
unsafe {
libc::funcs::extra::kernel32::CloseHandle(cast::transmute(handle));
}
* Note that this is private to avoid race conditions on unix where if
* a user calls waitpid(some_process.get_id()) then some_process.finish()
* and some_process.destroy() and some_process.finalize() will then either
- * operate on a none-existant process or, even worse, on a newer process
+ * operate on a none-existent process or, even worse, on a newer process
* with the same id.
*/
fn waitpid(pid: pid_t) -> int {
#[cfg(windows)]
fn waitpid_os(pid: pid_t) -> int {
+ #[fixed_stack_segment]; #[inline(never)];
use libc::types::os::arch::extra::DWORD;
use libc::consts::os::extra::{
#[cfg(unix)]
fn waitpid_os(pid: pid_t) -> int {
+ #[fixed_stack_segment]; #[inline(never)];
use libc::funcs::posix01::wait::*;
use path::Path;
use run;
use str;
+ use unstable::running_on_valgrind;
#[test]
#[cfg(windows)]
}
fn readclose(fd: c_int) -> ~str {
+ #[fixed_stack_segment]; #[inline(never)];
+
unsafe {
let file = os::fdopen(fd);
let reader = io::FILE_reader(file, false);
assert!(output.contains("RUN_TEST_NEW_ENV=123"));
}
-
- fn running_on_valgrind() -> bool {
- unsafe { rust_running_on_valgrind() != 0 }
- }
-
- extern {
- fn rust_running_on_valgrind() -> uintptr_t;
- }
}
use rt::local::Local;
use rt::rtio::EventLoop;
use task;
+use unstable::finally::Finally;
use vec::{OwnedVector, MutableVector};
/// Trait for message-passing primitives that can be select()ed on.
let p = Cell::new(p);
let c = Cell::new(c);
- let sched = Local::take::<Scheduler>();
- do sched.deschedule_running_task_and_then |sched, task| {
- let task_handles = task.make_selectable(ports.len());
-
- for (index, (port, task_handle)) in
- ports.mut_iter().zip(task_handles.move_iter()).enumerate() {
- // If one of the ports has data by now, it will wake the handle.
- if port.block_on(sched, task_handle) {
- ready_index = index;
- break;
+ do (|| {
+ let c = Cell::new(c.take());
+ let sched = Local::take::<Scheduler>();
+ do sched.deschedule_running_task_and_then |sched, task| {
+ let task_handles = task.make_selectable(ports.len());
+
+ for (index, (port, task_handle)) in
+ ports.mut_iter().zip(task_handles.move_iter()).enumerate() {
+ // If one of the ports has data by now, it will wake the handle.
+ if port.block_on(sched, task_handle) {
+ ready_index = index;
+ break;
+ }
}
- }
- let c = Cell::new(c.take());
- do sched.event_loop.callback { c.take().send_deferred(()) }
+ let c = Cell::new(c.take());
+ do sched.event_loop.callback { c.take().send_deferred(()) }
+ }
+ }).finally {
+ let p = Cell::new(p.take());
+ // Unkillable is necessary not because getting killed is dangerous here,
+ // but to force the recv not to use the same kill-flag that we used for
+ // selecting. Otherwise a user-sender could spuriously wakeup us here.
+ do task::unkillable { p.take().recv(); }
}
- // Unkillable is necessary not because getting killed is dangerous here,
- // but to force the recv not to use the same kill-flag that we used for
- // selecting. Otherwise a user-sender could spuriously wakeup us here.
- do task::unkillable { p.take().recv(); }
-
// Task resumes. Now unblock ourselves from all the ports we blocked on.
// If the success index wasn't reset, 'take' will just take all of them.
// Iterate in reverse so the 'earliest' index that's ready gets returned.
let (c2, p3, c4) = x.take();
p3.recv(); // handshake parent
c4.send(()); // normal receive
- task::yield();
+ task::deschedule();
c2.send(()); // select receive
}
if send_on_chans.contains(&i) {
let c = Cell::new(c);
do spawntask_random {
- task::yield();
+ task::deschedule();
c.take().send(());
}
}
#[path = "num/cmath.rs"]
mod cmath;
-// XXX: This shouldn't be pub, and it should be reexported under 'unstable'
+// FIXME #7809: This shouldn't be pub, and it should be reexported under 'unstable'
// but name resolution doesn't work without it being pub.
pub mod rt;
pub use fmt;
pub use to_bytes;
}
+
use cast;
use char;
use char::Char;
-use clone::Clone;
+use clone::{Clone, DeepClone};
use container::{Container, Mutable};
use iter::Times;
use iterator::{Iterator, FromIterator, Extendable};
}
}
-/// An iterator over the start and end indicies of the matches of a
+/// An iterator over the start and end indices of the matches of a
/// substring within a larger string
#[deriving(Clone)]
pub struct MatchesIndexIterator<'self> {
}
}
+// Helper functions used for Unicode normalization
+fn canonical_sort(comb: &mut [(char, u8)]) {
+ use iterator::range;
+ use tuple::CopyableTuple;
+
+ let len = comb.len();
+ for i in range(0, len) {
+ let mut swapped = false;
+ for j in range(1, len-i) {
+ let classA = comb[j-1].second();
+ let classB = comb[j].second();
+ if classA != 0 && classB != 0 && classA > classB {
+ comb.swap(j-1, j);
+ swapped = true;
+ }
+ }
+ if !swapped { break; }
+ }
+}
+
+#[deriving(Clone)]
+enum NormalizationForm {
+ NFD,
+ NFKD
+}
+
+/// External iterator for a string's normalization's characters.
+/// Use with the `std::iterator` module.
+#[deriving(Clone)]
+struct NormalizationIterator<'self> {
+ priv kind: NormalizationForm,
+ priv index: uint,
+ priv string: &'self str,
+ priv buffer: ~[(char, u8)],
+ priv sorted: bool
+}
+
+impl<'self> Iterator<char> for NormalizationIterator<'self> {
+ #[inline]
+ fn next(&mut self) -> Option<char> {
+ use unicode::decompose::canonical_combining_class;
+
+ match self.buffer.head_opt() {
+ Some(&(c, 0)) => {
+ self.sorted = false;
+ self.buffer.shift();
+ return Some(c);
+ }
+ Some(&(c, _)) if self.sorted => {
+ self.buffer.shift();
+ return Some(c);
+ }
+ _ => self.sorted = false
+ }
+
+ let decomposer = match self.kind {
+ NFD => char::decompose_canonical,
+ NFKD => char::decompose_compatible
+ };
+
+ while !self.sorted && self.index < self.string.len() {
+ let CharRange {ch, next} = self.string.char_range_at(self.index);
+ self.index = next;
+ do decomposer(ch) |d| {
+ let class = canonical_combining_class(d);
+ if class == 0 && !self.sorted {
+ canonical_sort(self.buffer);
+ self.sorted = true;
+ }
+ self.buffer.push((d, class));
+ }
+ }
+
+ if !self.sorted {
+ canonical_sort(self.buffer);
+ self.sorted = true;
+ }
+
+ match self.buffer.shift_opt() {
+ Some((c, 0)) => {
+ self.sorted = false;
+ Some(c)
+ }
+ Some((c, _)) => Some(c),
+ None => None
+ }
+ }
+
+ fn size_hint(&self) -> (uint, Option<uint>) { (self.string.len(), None) }
+}
+
/// Replace all occurrences of one string with another
///
/// # Arguments
/// Sets the length of a string
///
/// This will explicitly set the size of the string, without actually
- /// modifing its buffers, so it is up to the caller to ensure that
+ /// modifying its buffers, so it is up to the caller to ensure that
/// the string is actually the specified size.
#[inline]
pub unsafe fn set_len(s: &mut ~str, new_len: uint) {
fn line_iter(&self) -> CharSplitIterator<'self, char>;
fn any_line_iter(&self) -> AnyLineIterator<'self>;
fn word_iter(&self) -> WordIterator<'self>;
+ fn nfd_iter(&self) -> NormalizationIterator<'self>;
+ fn nfkd_iter(&self) -> NormalizationIterator<'self>;
fn ends_with(&self, needle: &str) -> bool;
fn is_whitespace(&self) -> bool;
fn is_alphanumeric(&self) -> bool;
self.split_iter(char::is_whitespace).filter(|s| !s.is_empty())
}
+ /// Returns the string in Unicode Normalization Form D (canonical decomposition)
+ fn nfd_iter(&self) -> NormalizationIterator<'self> {
+ NormalizationIterator {
+ index: 0,
+ string: *self,
+ buffer: ~[],
+ sorted: false,
+ kind: NFD
+ }
+ }
+
+ /// Returns the string in Unicode Normalization Form KD (compatibility decomposition)
+ fn nfkd_iter(&self) -> NormalizationIterator<'self> {
+ NormalizationIterator {
+ index: 0,
+ string: *self,
+ buffer: ~[],
+ sorted: false,
+ kind: NFKD
+ }
+ }
+
/// Returns true if the string contains only whitespace
///
/// Whitespace characters are determined by `char::is_whitespace`
}
}
+impl DeepClone for ~str {
+ #[inline]
+ fn deep_clone(&self) -> ~str {
+ self.to_owned()
+ }
+}
+
impl Clone for @str {
#[inline]
fn clone(&self) -> @str {
}
}
+impl DeepClone for @str {
+ #[inline]
+ fn deep_clone(&self) -> @str {
+ *self
+ }
+}
+
impl FromIterator<char> for ~str {
#[inline]
fn from_iterator<T: Iterator<char>>(iterator: &mut T) -> ~str {
#[test]
fn test_map() {
+ #[fixed_stack_segment]; #[inline(never)];
assert_eq!(~"", "".map_chars(|c| unsafe {libc::toupper(c as c_char)} as char));
assert_eq!(~"YMCA", "ymca".map_chars(|c| unsafe {libc::toupper(c as c_char)} as char));
}
assert_eq!(words, ~["Märy", "häd", "ä", "little", "lämb", "Little", "lämb"])
}
+ #[test]
+ fn test_nfd_iter() {
+ assert_eq!("abc".nfd_iter().collect::<~str>(), ~"abc");
+ assert_eq!("\u1e0b\u01c4".nfd_iter().collect::<~str>(), ~"d\u0307\u01c4");
+ assert_eq!("\u2026".nfd_iter().collect::<~str>(), ~"\u2026");
+ assert_eq!("\u2126".nfd_iter().collect::<~str>(), ~"\u03a9");
+ assert_eq!("\u1e0b\u0323".nfd_iter().collect::<~str>(), ~"d\u0323\u0307");
+ assert_eq!("\u1e0d\u0307".nfd_iter().collect::<~str>(), ~"d\u0323\u0307");
+ assert_eq!("a\u0301".nfd_iter().collect::<~str>(), ~"a\u0301");
+ assert_eq!("\u0301a".nfd_iter().collect::<~str>(), ~"\u0301a");
+ assert_eq!("\ud4db".nfd_iter().collect::<~str>(), ~"\u1111\u1171\u11b6");
+ assert_eq!("\uac1c".nfd_iter().collect::<~str>(), ~"\u1100\u1162");
+ }
+
+ #[test]
+ fn test_nfkd_iter() {
+ assert_eq!("abc".nfkd_iter().collect::<~str>(), ~"abc");
+ assert_eq!("\u1e0b\u01c4".nfkd_iter().collect::<~str>(), ~"d\u0307DZ\u030c");
+ assert_eq!("\u2026".nfkd_iter().collect::<~str>(), ~"...");
+ assert_eq!("\u2126".nfkd_iter().collect::<~str>(), ~"\u03a9");
+ assert_eq!("\u1e0b\u0323".nfkd_iter().collect::<~str>(), ~"d\u0323\u0307");
+ assert_eq!("\u1e0d\u0307".nfkd_iter().collect::<~str>(), ~"d\u0323\u0307");
+ assert_eq!("a\u0301".nfkd_iter().collect::<~str>(), ~"a\u0301");
+ assert_eq!("\u0301a".nfkd_iter().collect::<~str>(), ~"\u0301a");
+ assert_eq!("\ud4db".nfkd_iter().collect::<~str>(), ~"\u1111\u1171\u11b6");
+ assert_eq!("\uac1c".nfkd_iter().collect::<~str>(), ~"\u1100\u1162");
+ }
+
#[test]
fn test_line_iter() {
let data = "\nMäry häd ä little lämb\n\nLittle lämb\n";
#[cfg(test)]
mod tests {
use super::*;
- use to_bytes::ToBytes;
use str::from_char;
macro_rules! v2ascii (
#[test]
fn test_ascii_to_bytes() {
- assert_eq!(v2ascii!(~[40, 32, 59]).to_bytes(false), ~[40u8, 32u8, 59u8]);
assert_eq!(v2ascii!(~[40, 32, 59]).into_bytes(), ~[40u8, 32u8, 59u8]);
}
// above.
let data = match util::replace(entry, None) {
Some((_, data, _)) => data,
- None => libc::abort(),
+ None => abort(),
};
// Move `data` into transmute to get out the memory that it
}
}
}
- _ => libc::abort()
+ _ => abort()
}
// n.b. 'data' and 'loans' are both invalid pointers at the point
if return_loan {
match map[i] {
Some((_, _, ref mut loan)) => { *loan = NoLoan; }
- None => { libc::abort(); }
+ None => { abort(); }
}
}
return ret;
}
}
+fn abort() -> ! {
+ #[fixed_stack_segment]; #[inline(never)];
+
+ unsafe { libc::abort() }
+}
+
pub unsafe fn local_set<T: 'static>(handle: Handle,
key: local_data::Key<T>,
data: T) {
spawn::spawn_raw(opts, f);
}
- /// Runs a task, while transfering ownership of one argument to the child.
+ /// Runs a task, while transferring ownership of one argument to the child.
pub fn spawn_with<A:Send>(&mut self, arg: A, f: ~fn(v: A)) {
let arg = Cell::new(arg);
do self.spawn {
pub fn spawn_with<A:Send>(arg: A, f: ~fn(v: A)) {
/*!
- * Runs a task, while transfering ownership of one argument to the
+ * Runs a task, while transferring ownership of one argument to the
* child.
*
- * This is useful for transfering ownership of noncopyables to
+ * This is useful for transferring ownership of noncopyables to
* another task.
*
* This function is equivalent to `task().spawn_with(arg, f)`.
}
}
-pub fn yield() {
+pub fn deschedule() {
//! Yield control to the task scheduler
use rt::local::Local;
use rt::sched::Scheduler;
- // XXX: What does yield really mean in newsched?
+ // FIXME #6842: What does yield really mean in newsched?
// FIXME(#7544): Optimize this, since we know we won't block.
let sched = Local::take::<Scheduler>();
do sched.deschedule_running_task_and_then |sched, task| {
*
* ~~~
* do task::unkillable {
- * // detach / yield / destroy must all be called together
+ * // detach / deschedule / destroy must all be called together
* rustrt::rust_port_detach(po);
* // This must not result in the current task being killed
- * task::yield();
+ * task::deschedule();
* rustrt::rust_port_destroy(po);
* }
* ~~~
let ch = ch.clone();
do spawn_unlinked {
// Give middle task a chance to fail-but-not-kill-us.
- do 16.times { task::yield(); }
+ do 16.times { task::deschedule(); }
ch.send(()); // If killed first, grandparent hangs.
}
fail!(); // Shouldn't kill either (grand)parent or (grand)child.
do run_in_newsched_task {
do spawn_supervised { fail!(); }
// Give child a chance to fail-but-not-kill-us.
- do 16.times { task::yield(); }
+ do 16.times { task::deschedule(); }
}
}
#[ignore(reason = "linked failure")]
do spawn_supervised {
do spawn_supervised { block_forever(); }
}
- do 16.times { task::yield(); }
+ do 16.times { task::deschedule(); }
fail!();
};
assert!(result.is_err());
do spawn_supervised {
do spawn { block_forever(); } // linked
}
- do 16.times { task::yield(); }
+ do 16.times { task::deschedule(); }
fail!();
};
assert!(result.is_err());
do spawn { // linked
do spawn_supervised { block_forever(); }
}
- do 16.times { task::yield(); }
+ do 16.times { task::deschedule(); }
fail!();
};
assert!(result.is_err());
do spawn { // linked
do spawn { block_forever(); } // linked
}
- do 16.times { task::yield(); }
+ do 16.times { task::deschedule(); }
fail!();
};
assert!(result.is_err());
mod testrt {
use libc;
- #[nolink]
- extern {
- pub fn rust_dbg_lock_create() -> *libc::c_void;
- pub fn rust_dbg_lock_destroy(lock: *libc::c_void);
- pub fn rust_dbg_lock_lock(lock: *libc::c_void);
- pub fn rust_dbg_lock_unlock(lock: *libc::c_void);
- pub fn rust_dbg_lock_wait(lock: *libc::c_void);
- pub fn rust_dbg_lock_signal(lock: *libc::c_void);
- }
+ externfn!(fn rust_dbg_lock_create() -> *libc::c_void)
+ externfn!(fn rust_dbg_lock_destroy(lock: *libc::c_void))
+ externfn!(fn rust_dbg_lock_lock(lock: *libc::c_void))
+ externfn!(fn rust_dbg_lock_unlock(lock: *libc::c_void))
+ externfn!(fn rust_dbg_lock_wait(lock: *libc::c_void))
+ externfn!(fn rust_dbg_lock_signal(lock: *libc::c_void))
}
#[test]
// We want to do this after failing
do spawn_unlinked {
- do 10.times { yield() }
+ do 10.times { deschedule() }
ch.send(());
}
do spawn {
- yield();
+ deschedule();
// We want to fail after the unkillable task
// blocks on recv
fail!();
// We want to do this after failing
do spawn_unlinked || {
- do 10.times { yield() }
+ do 10.times { deschedule() }
ch.send(());
}
do spawn {
- yield();
+ deschedule();
// We want to fail after the unkillable task
// blocks on recv
fail!();
t.unlinked();
t.watched();
do t.spawn {
- task::yield();
+ task::deschedule();
fail!();
}
}
t.unwatched();
do t.spawn {
p3.recv();
- task::yield();
+ task::deschedule();
fail!();
}
c3.send(());
*/
use cast;
+use container::Container;
use io;
use io::Writer;
use iterator::Iterator;
use option::{None, Option, Some};
-use str::StrSlice;
-use vec::ImmutableVector;
+use str::{Str, StrSlice};
+use vec::{Vector, ImmutableVector};
pub type Cb<'self> = &'self fn(buf: &[u8]) -> bool;
-/**
- * A trait to implement in order to make a type hashable;
- * This works in combination with the trait `Hash::Hash`, and
- * may in the future be merged with that trait or otherwise
- * modified when default methods and trait inheritence are
- * completed.
- */
+///
+/// A trait to implement in order to make a type hashable;
+/// This works in combination with the trait `std::hash::Hash`, and
+/// may in the future be merged with that trait or otherwise
+/// modified when default methods and trait inheritance are
+/// completed.
+///
+/// IterBytes should be implemented so that the extent of the
+/// produced byte stream can be discovered, given the original
+/// type.
+/// For example, the IterBytes implementation for vectors emits
+/// its length first, and enums should emit their discriminant.
+///
pub trait IterBytes {
- /**
- * Call the provided callback `f` one or more times with
- * byte-slices that should be used when computing a hash
- * value or otherwise "flattening" the structure into
- * a sequence of bytes. The `lsb0` parameter conveys
- * whether the caller is asking for little-endian bytes
- * (`true`) or big-endian (`false`); this should only be
- * relevant in implementations that represent a single
- * multi-byte datum such as a 32 bit integer or 64 bit
- * floating-point value. It can be safely ignored for
- * larger structured types as they are usually processed
- * left-to-right in declaration order, regardless of
- * underlying memory endianness.
- */
+ /// Call the provided callback `f` one or more times with
+ /// byte-slices that should be used when computing a hash
+ /// value or otherwise "flattening" the structure into
+ /// a sequence of bytes. The `lsb0` parameter conveys
+ /// whether the caller is asking for little-endian bytes
+ /// (`true`) or big-endian (`false`); this should only be
+ /// relevant in implementations that represent a single
+ /// multi-byte datum such as a 32 bit integer or 64 bit
+ /// floating-point value. It can be safely ignored for
+ /// larger structured types as they are usually processed
+ /// left-to-right in declaration order, regardless of
+ /// underlying memory endianness.
+ ///
fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool;
}
impl<'self,A:IterBytes> IterBytes for &'self [A] {
#[inline]
fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
+ self.len().iter_bytes(lsb0, |b| f(b)) &&
self.iter().advance(|elt| elt.iter_bytes(lsb0, |b| f(b)))
}
}
-impl<A:IterBytes,B:IterBytes> IterBytes for (A,B) {
- #[inline]
- fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
- match *self {
- (ref a, ref b) => { a.iter_bytes(lsb0, |b| f(b)) &&
- b.iter_bytes(lsb0, |b| f(b)) }
- }
- }
-}
-
-impl<A:IterBytes,B:IterBytes,C:IterBytes> IterBytes for (A,B,C) {
- #[inline]
- fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
- match *self {
- (ref a, ref b, ref c) => {
- a.iter_bytes(lsb0, |b| f(b)) &&
- b.iter_bytes(lsb0, |b| f(b)) &&
- c.iter_bytes(lsb0, |b| f(b))
- }
+impl<A: IterBytes> IterBytes for (A, ) {
+ fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
+ match *self {
+ (ref a, ) => a.iter_bytes(lsb0, |b| f(b))
+ }
}
- }
}
-// Move this to vec, probably.
-fn borrow<'x,A>(a: &'x [A]) -> &'x [A] {
- a
-}
+macro_rules! iter_bytes_tuple(
+ ($($A:ident),+) => (
+ impl<$($A: IterBytes),+> IterBytes for ($($A),+) {
+ fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
+ match *self {
+ ($(ref $A),+) => {
+ $(
+ $A .iter_bytes(lsb0, |b| f(b))
+ )&&+
+ }
+ }
+ }
+ }
+ )
+)
+
+iter_bytes_tuple!(A, B)
+iter_bytes_tuple!(A, B, C)
+iter_bytes_tuple!(A, B, C, D)
+iter_bytes_tuple!(A, B, C, D, E)
+iter_bytes_tuple!(A, B, C, D, E, F)
+iter_bytes_tuple!(A, B, C, D, E, F, G)
+iter_bytes_tuple!(A, B, C, D, E, F, G, H)
impl<A:IterBytes> IterBytes for ~[A] {
#[inline]
fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
- borrow(*self).iter_bytes(lsb0, f)
+ self.as_slice().iter_bytes(lsb0, f)
}
}
impl<A:IterBytes> IterBytes for @[A] {
#[inline]
fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
- borrow(*self).iter_bytes(lsb0, f)
+ self.as_slice().iter_bytes(lsb0, f)
}
}
impl<'self> IterBytes for &'self str {
#[inline]
fn iter_bytes(&self, _lsb0: bool, f: Cb) -> bool {
- f(self.as_bytes())
+ // Terminate the string with a byte that does not appear in UTF-8
+ f(self.as_bytes()) && f([0xFF])
}
}
impl IterBytes for ~str {
#[inline]
- fn iter_bytes(&self, _lsb0: bool, f: Cb) -> bool {
- // this should possibly include the null terminator, but that
- // breaks .find_equiv on hashmaps.
- f(self.as_bytes())
+ fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
+ self.as_slice().iter_bytes(lsb0, f)
}
}
impl IterBytes for @str {
#[inline]
- fn iter_bytes(&self, _lsb0: bool, f: Cb) -> bool {
- // this should possibly include the null terminator, but that
- // breaks .find_equiv on hashmaps.
- f(self.as_bytes())
+ fn iter_bytes(&self, lsb0: bool, f: Cb) -> bool {
+ self.as_slice().iter_bytes(lsb0, f)
}
}
/// Trait for converting a type to a string, consuming it in the process.
pub trait ToStrConsume {
- /// Cosume and convert to a string.
+ /// Consume and convert to a string.
fn into_str(self) -> ~str;
}
}
}
+pub mod decompose {
+ use option::Option;
+ use option::{Some, None};
+ use vec::ImmutableVector;
+
+ fn bsearch_table(c: char, r: &'static [(char, &'static [char])]) -> Option<&'static [char]> {
+ use cmp::{Equal, Less, Greater};
+ match r.bsearch(|&(val, _)| {
+ if c == val { Equal }
+ else if val < c { Less }
+ else { Greater }
+ }) {
+ Some(idx) => {
+ let (_, result) = r[idx];
+ Some(result)
+ }
+ None => None
+ }
+ }
+
+
+ fn bsearch_range_value_table(c: char, r: &'static [(char, char, u8)]) -> u8 {
+ use cmp::{Equal, Less, Greater};
+ match r.bsearch(|&(lo, hi, _)| {
+ if lo <= c && c <= hi { Equal }
+ else if hi < c { Less }
+ else { Greater }
+ }) {
+ Some(idx) => {
+ let (_, _, result) = r[idx];
+ result
+ }
+ None => 0
+ }
+ }
+
+
+ // Canonical decompositions
+ static canonical_table : &'static [(char, &'static [char])] = &[
+ ('\xc0', &['\x41', '\u0300']), ('\xc1', &['\x41', '\u0301']), ('\xc2', &['\x41', '\u0302']),
+ ('\xc3', &['\x41', '\u0303']), ('\xc4', &['\x41', '\u0308']), ('\xc5', &['\x41', '\u030a']),
+ ('\xc7', &['\x43', '\u0327']), ('\xc8', &['\x45', '\u0300']), ('\xc9', &['\x45', '\u0301']),
+ ('\xca', &['\x45', '\u0302']), ('\xcb', &['\x45', '\u0308']), ('\xcc', &['\x49', '\u0300']),
+ ('\xcd', &['\x49', '\u0301']), ('\xce', &['\x49', '\u0302']), ('\xcf', &['\x49', '\u0308']),
+ ('\xd1', &['\x4e', '\u0303']), ('\xd2', &['\x4f', '\u0300']), ('\xd3', &['\x4f', '\u0301']),
+ ('\xd4', &['\x4f', '\u0302']), ('\xd5', &['\x4f', '\u0303']), ('\xd6', &['\x4f', '\u0308']),
+ ('\xd9', &['\x55', '\u0300']), ('\xda', &['\x55', '\u0301']), ('\xdb', &['\x55', '\u0302']),
+ ('\xdc', &['\x55', '\u0308']), ('\xdd', &['\x59', '\u0301']), ('\xe0', &['\x61', '\u0300']),
+ ('\xe1', &['\x61', '\u0301']), ('\xe2', &['\x61', '\u0302']), ('\xe3', &['\x61', '\u0303']),
+ ('\xe4', &['\x61', '\u0308']), ('\xe5', &['\x61', '\u030a']), ('\xe7', &['\x63', '\u0327']),
+ ('\xe8', &['\x65', '\u0300']), ('\xe9', &['\x65', '\u0301']), ('\xea', &['\x65', '\u0302']),
+ ('\xeb', &['\x65', '\u0308']), ('\xec', &['\x69', '\u0300']), ('\xed', &['\x69', '\u0301']),
+ ('\xee', &['\x69', '\u0302']), ('\xef', &['\x69', '\u0308']), ('\xf1', &['\x6e', '\u0303']),
+ ('\xf2', &['\x6f', '\u0300']), ('\xf3', &['\x6f', '\u0301']), ('\xf4', &['\x6f', '\u0302']),
+ ('\xf5', &['\x6f', '\u0303']), ('\xf6', &['\x6f', '\u0308']), ('\xf9', &['\x75', '\u0300']),
+ ('\xfa', &['\x75', '\u0301']), ('\xfb', &['\x75', '\u0302']), ('\xfc', &['\x75', '\u0308']),
+ ('\xfd', &['\x79', '\u0301']), ('\xff', &['\x79', '\u0308']), ('\u0100', &['\x41',
+ '\u0304']), ('\u0101', &['\x61', '\u0304']), ('\u0102', &['\x41', '\u0306']), ('\u0103',
+ &['\x61', '\u0306']), ('\u0104', &['\x41', '\u0328']), ('\u0105', &['\x61', '\u0328']),
+ ('\u0106', &['\x43', '\u0301']), ('\u0107', &['\x63', '\u0301']), ('\u0108', &['\x43',
+ '\u0302']), ('\u0109', &['\x63', '\u0302']), ('\u010a', &['\x43', '\u0307']), ('\u010b',
+ &['\x63', '\u0307']), ('\u010c', &['\x43', '\u030c']), ('\u010d', &['\x63', '\u030c']),
+ ('\u010e', &['\x44', '\u030c']), ('\u010f', &['\x64', '\u030c']), ('\u0112', &['\x45',
+ '\u0304']), ('\u0113', &['\x65', '\u0304']), ('\u0114', &['\x45', '\u0306']), ('\u0115',
+ &['\x65', '\u0306']), ('\u0116', &['\x45', '\u0307']), ('\u0117', &['\x65', '\u0307']),
+ ('\u0118', &['\x45', '\u0328']), ('\u0119', &['\x65', '\u0328']), ('\u011a', &['\x45',
+ '\u030c']), ('\u011b', &['\x65', '\u030c']), ('\u011c', &['\x47', '\u0302']), ('\u011d',
+ &['\x67', '\u0302']), ('\u011e', &['\x47', '\u0306']), ('\u011f', &['\x67', '\u0306']),
+ ('\u0120', &['\x47', '\u0307']), ('\u0121', &['\x67', '\u0307']), ('\u0122', &['\x47',
+ '\u0327']), ('\u0123', &['\x67', '\u0327']), ('\u0124', &['\x48', '\u0302']), ('\u0125',
+ &['\x68', '\u0302']), ('\u0128', &['\x49', '\u0303']), ('\u0129', &['\x69', '\u0303']),
+ ('\u012a', &['\x49', '\u0304']), ('\u012b', &['\x69', '\u0304']), ('\u012c', &['\x49',
+ '\u0306']), ('\u012d', &['\x69', '\u0306']), ('\u012e', &['\x49', '\u0328']), ('\u012f',
+ &['\x69', '\u0328']), ('\u0130', &['\x49', '\u0307']), ('\u0134', &['\x4a', '\u0302']),
+ ('\u0135', &['\x6a', '\u0302']), ('\u0136', &['\x4b', '\u0327']), ('\u0137', &['\x6b',
+ '\u0327']), ('\u0139', &['\x4c', '\u0301']), ('\u013a', &['\x6c', '\u0301']), ('\u013b',
+ &['\x4c', '\u0327']), ('\u013c', &['\x6c', '\u0327']), ('\u013d', &['\x4c', '\u030c']),
+ ('\u013e', &['\x6c', '\u030c']), ('\u0143', &['\x4e', '\u0301']), ('\u0144', &['\x6e',
+ '\u0301']), ('\u0145', &['\x4e', '\u0327']), ('\u0146', &['\x6e', '\u0327']), ('\u0147',
+ &['\x4e', '\u030c']), ('\u0148', &['\x6e', '\u030c']), ('\u014c', &['\x4f', '\u0304']),
+ ('\u014d', &['\x6f', '\u0304']), ('\u014e', &['\x4f', '\u0306']), ('\u014f', &['\x6f',
+ '\u0306']), ('\u0150', &['\x4f', '\u030b']), ('\u0151', &['\x6f', '\u030b']), ('\u0154',
+ &['\x52', '\u0301']), ('\u0155', &['\x72', '\u0301']), ('\u0156', &['\x52', '\u0327']),
+ ('\u0157', &['\x72', '\u0327']), ('\u0158', &['\x52', '\u030c']), ('\u0159', &['\x72',
+ '\u030c']), ('\u015a', &['\x53', '\u0301']), ('\u015b', &['\x73', '\u0301']), ('\u015c',
+ &['\x53', '\u0302']), ('\u015d', &['\x73', '\u0302']), ('\u015e', &['\x53', '\u0327']),
+ ('\u015f', &['\x73', '\u0327']), ('\u0160', &['\x53', '\u030c']), ('\u0161', &['\x73',
+ '\u030c']), ('\u0162', &['\x54', '\u0327']), ('\u0163', &['\x74', '\u0327']), ('\u0164',
+ &['\x54', '\u030c']), ('\u0165', &['\x74', '\u030c']), ('\u0168', &['\x55', '\u0303']),
+ ('\u0169', &['\x75', '\u0303']), ('\u016a', &['\x55', '\u0304']), ('\u016b', &['\x75',
+ '\u0304']), ('\u016c', &['\x55', '\u0306']), ('\u016d', &['\x75', '\u0306']), ('\u016e',
+ &['\x55', '\u030a']), ('\u016f', &['\x75', '\u030a']), ('\u0170', &['\x55', '\u030b']),
+ ('\u0171', &['\x75', '\u030b']), ('\u0172', &['\x55', '\u0328']), ('\u0173', &['\x75',
+ '\u0328']), ('\u0174', &['\x57', '\u0302']), ('\u0175', &['\x77', '\u0302']), ('\u0176',
+ &['\x59', '\u0302']), ('\u0177', &['\x79', '\u0302']), ('\u0178', &['\x59', '\u0308']),
+ ('\u0179', &['\x5a', '\u0301']), ('\u017a', &['\x7a', '\u0301']), ('\u017b', &['\x5a',
+ '\u0307']), ('\u017c', &['\x7a', '\u0307']), ('\u017d', &['\x5a', '\u030c']), ('\u017e',
+ &['\x7a', '\u030c']), ('\u01a0', &['\x4f', '\u031b']), ('\u01a1', &['\x6f', '\u031b']),
+ ('\u01af', &['\x55', '\u031b']), ('\u01b0', &['\x75', '\u031b']), ('\u01cd', &['\x41',
+ '\u030c']), ('\u01ce', &['\x61', '\u030c']), ('\u01cf', &['\x49', '\u030c']), ('\u01d0',
+ &['\x69', '\u030c']), ('\u01d1', &['\x4f', '\u030c']), ('\u01d2', &['\x6f', '\u030c']),
+ ('\u01d3', &['\x55', '\u030c']), ('\u01d4', &['\x75', '\u030c']), ('\u01d5', &['\xdc',
+ '\u0304']), ('\u01d6', &['\xfc', '\u0304']), ('\u01d7', &['\xdc', '\u0301']), ('\u01d8',
+ &['\xfc', '\u0301']), ('\u01d9', &['\xdc', '\u030c']), ('\u01da', &['\xfc', '\u030c']),
+ ('\u01db', &['\xdc', '\u0300']), ('\u01dc', &['\xfc', '\u0300']), ('\u01de', &['\xc4',
+ '\u0304']), ('\u01df', &['\xe4', '\u0304']), ('\u01e0', &['\u0226', '\u0304']), ('\u01e1',
+ &['\u0227', '\u0304']), ('\u01e2', &['\xc6', '\u0304']), ('\u01e3', &['\xe6', '\u0304']),
+ ('\u01e6', &['\x47', '\u030c']), ('\u01e7', &['\x67', '\u030c']), ('\u01e8', &['\x4b',
+ '\u030c']), ('\u01e9', &['\x6b', '\u030c']), ('\u01ea', &['\x4f', '\u0328']), ('\u01eb',
+ &['\x6f', '\u0328']), ('\u01ec', &['\u01ea', '\u0304']), ('\u01ed', &['\u01eb', '\u0304']),
+ ('\u01ee', &['\u01b7', '\u030c']), ('\u01ef', &['\u0292', '\u030c']), ('\u01f0', &['\x6a',
+ '\u030c']), ('\u01f4', &['\x47', '\u0301']), ('\u01f5', &['\x67', '\u0301']), ('\u01f8',
+ &['\x4e', '\u0300']), ('\u01f9', &['\x6e', '\u0300']), ('\u01fa', &['\xc5', '\u0301']),
+ ('\u01fb', &['\xe5', '\u0301']), ('\u01fc', &['\xc6', '\u0301']), ('\u01fd', &['\xe6',
+ '\u0301']), ('\u01fe', &['\xd8', '\u0301']), ('\u01ff', &['\xf8', '\u0301']), ('\u0200',
+ &['\x41', '\u030f']), ('\u0201', &['\x61', '\u030f']), ('\u0202', &['\x41', '\u0311']),
+ ('\u0203', &['\x61', '\u0311']), ('\u0204', &['\x45', '\u030f']), ('\u0205', &['\x65',
+ '\u030f']), ('\u0206', &['\x45', '\u0311']), ('\u0207', &['\x65', '\u0311']), ('\u0208',
+ &['\x49', '\u030f']), ('\u0209', &['\x69', '\u030f']), ('\u020a', &['\x49', '\u0311']),
+ ('\u020b', &['\x69', '\u0311']), ('\u020c', &['\x4f', '\u030f']), ('\u020d', &['\x6f',
+ '\u030f']), ('\u020e', &['\x4f', '\u0311']), ('\u020f', &['\x6f', '\u0311']), ('\u0210',
+ &['\x52', '\u030f']), ('\u0211', &['\x72', '\u030f']), ('\u0212', &['\x52', '\u0311']),
+ ('\u0213', &['\x72', '\u0311']), ('\u0214', &['\x55', '\u030f']), ('\u0215', &['\x75',
+ '\u030f']), ('\u0216', &['\x55', '\u0311']), ('\u0217', &['\x75', '\u0311']), ('\u0218',
+ &['\x53', '\u0326']), ('\u0219', &['\x73', '\u0326']), ('\u021a', &['\x54', '\u0326']),
+ ('\u021b', &['\x74', '\u0326']), ('\u021e', &['\x48', '\u030c']), ('\u021f', &['\x68',
+ '\u030c']), ('\u0226', &['\x41', '\u0307']), ('\u0227', &['\x61', '\u0307']), ('\u0228',
+ &['\x45', '\u0327']), ('\u0229', &['\x65', '\u0327']), ('\u022a', &['\xd6', '\u0304']),
+ ('\u022b', &['\xf6', '\u0304']), ('\u022c', &['\xd5', '\u0304']), ('\u022d', &['\xf5',
+ '\u0304']), ('\u022e', &['\x4f', '\u0307']), ('\u022f', &['\x6f', '\u0307']), ('\u0230',
+ &['\u022e', '\u0304']), ('\u0231', &['\u022f', '\u0304']), ('\u0232', &['\x59', '\u0304']),
+ ('\u0233', &['\x79', '\u0304']), ('\u0340', &['\u0300']), ('\u0341', &['\u0301']),
+ ('\u0343', &['\u0313']), ('\u0344', &['\u0308', '\u0301']), ('\u0374', &['\u02b9']),
+ ('\u037e', &['\x3b']), ('\u0385', &['\xa8', '\u0301']), ('\u0386', &['\u0391', '\u0301']),
+ ('\u0387', &['\xb7']), ('\u0388', &['\u0395', '\u0301']), ('\u0389', &['\u0397', '\u0301']),
+ ('\u038a', &['\u0399', '\u0301']), ('\u038c', &['\u039f', '\u0301']), ('\u038e', &['\u03a5',
+ '\u0301']), ('\u038f', &['\u03a9', '\u0301']), ('\u0390', &['\u03ca', '\u0301']), ('\u03aa',
+ &['\u0399', '\u0308']), ('\u03ab', &['\u03a5', '\u0308']), ('\u03ac', &['\u03b1',
+ '\u0301']), ('\u03ad', &['\u03b5', '\u0301']), ('\u03ae', &['\u03b7', '\u0301']), ('\u03af',
+ &['\u03b9', '\u0301']), ('\u03b0', &['\u03cb', '\u0301']), ('\u03ca', &['\u03b9',
+ '\u0308']), ('\u03cb', &['\u03c5', '\u0308']), ('\u03cc', &['\u03bf', '\u0301']), ('\u03cd',
+ &['\u03c5', '\u0301']), ('\u03ce', &['\u03c9', '\u0301']), ('\u03d3', &['\u03d2',
+ '\u0301']), ('\u03d4', &['\u03d2', '\u0308']), ('\u0400', &['\u0415', '\u0300']), ('\u0401',
+ &['\u0415', '\u0308']), ('\u0403', &['\u0413', '\u0301']), ('\u0407', &['\u0406',
+ '\u0308']), ('\u040c', &['\u041a', '\u0301']), ('\u040d', &['\u0418', '\u0300']), ('\u040e',
+ &['\u0423', '\u0306']), ('\u0419', &['\u0418', '\u0306']), ('\u0439', &['\u0438',
+ '\u0306']), ('\u0450', &['\u0435', '\u0300']), ('\u0451', &['\u0435', '\u0308']), ('\u0453',
+ &['\u0433', '\u0301']), ('\u0457', &['\u0456', '\u0308']), ('\u045c', &['\u043a',
+ '\u0301']), ('\u045d', &['\u0438', '\u0300']), ('\u045e', &['\u0443', '\u0306']), ('\u0476',
+ &['\u0474', '\u030f']), ('\u0477', &['\u0475', '\u030f']), ('\u04c1', &['\u0416',
+ '\u0306']), ('\u04c2', &['\u0436', '\u0306']), ('\u04d0', &['\u0410', '\u0306']), ('\u04d1',
+ &['\u0430', '\u0306']), ('\u04d2', &['\u0410', '\u0308']), ('\u04d3', &['\u0430',
+ '\u0308']), ('\u04d6', &['\u0415', '\u0306']), ('\u04d7', &['\u0435', '\u0306']), ('\u04da',
+ &['\u04d8', '\u0308']), ('\u04db', &['\u04d9', '\u0308']), ('\u04dc', &['\u0416',
+ '\u0308']), ('\u04dd', &['\u0436', '\u0308']), ('\u04de', &['\u0417', '\u0308']), ('\u04df',
+ &['\u0437', '\u0308']), ('\u04e2', &['\u0418', '\u0304']), ('\u04e3', &['\u0438',
+ '\u0304']), ('\u04e4', &['\u0418', '\u0308']), ('\u04e5', &['\u0438', '\u0308']), ('\u04e6',
+ &['\u041e', '\u0308']), ('\u04e7', &['\u043e', '\u0308']), ('\u04ea', &['\u04e8',
+ '\u0308']), ('\u04eb', &['\u04e9', '\u0308']), ('\u04ec', &['\u042d', '\u0308']), ('\u04ed',
+ &['\u044d', '\u0308']), ('\u04ee', &['\u0423', '\u0304']), ('\u04ef', &['\u0443',
+ '\u0304']), ('\u04f0', &['\u0423', '\u0308']), ('\u04f1', &['\u0443', '\u0308']), ('\u04f2',
+ &['\u0423', '\u030b']), ('\u04f3', &['\u0443', '\u030b']), ('\u04f4', &['\u0427',
+ '\u0308']), ('\u04f5', &['\u0447', '\u0308']), ('\u04f8', &['\u042b', '\u0308']), ('\u04f9',
+ &['\u044b', '\u0308']), ('\u0622', &['\u0627', '\u0653']), ('\u0623', &['\u0627',
+ '\u0654']), ('\u0624', &['\u0648', '\u0654']), ('\u0625', &['\u0627', '\u0655']), ('\u0626',
+ &['\u064a', '\u0654']), ('\u06c0', &['\u06d5', '\u0654']), ('\u06c2', &['\u06c1',
+ '\u0654']), ('\u06d3', &['\u06d2', '\u0654']), ('\u0929', &['\u0928', '\u093c']), ('\u0931',
+ &['\u0930', '\u093c']), ('\u0934', &['\u0933', '\u093c']), ('\u0958', &['\u0915',
+ '\u093c']), ('\u0959', &['\u0916', '\u093c']), ('\u095a', &['\u0917', '\u093c']), ('\u095b',
+ &['\u091c', '\u093c']), ('\u095c', &['\u0921', '\u093c']), ('\u095d', &['\u0922',
+ '\u093c']), ('\u095e', &['\u092b', '\u093c']), ('\u095f', &['\u092f', '\u093c']), ('\u09cb',
+ &['\u09c7', '\u09be']), ('\u09cc', &['\u09c7', '\u09d7']), ('\u09dc', &['\u09a1',
+ '\u09bc']), ('\u09dd', &['\u09a2', '\u09bc']), ('\u09df', &['\u09af', '\u09bc']), ('\u0a33',
+ &['\u0a32', '\u0a3c']), ('\u0a36', &['\u0a38', '\u0a3c']), ('\u0a59', &['\u0a16',
+ '\u0a3c']), ('\u0a5a', &['\u0a17', '\u0a3c']), ('\u0a5b', &['\u0a1c', '\u0a3c']), ('\u0a5e',
+ &['\u0a2b', '\u0a3c']), ('\u0b48', &['\u0b47', '\u0b56']), ('\u0b4b', &['\u0b47',
+ '\u0b3e']), ('\u0b4c', &['\u0b47', '\u0b57']), ('\u0b5c', &['\u0b21', '\u0b3c']), ('\u0b5d',
+ &['\u0b22', '\u0b3c']), ('\u0b94', &['\u0b92', '\u0bd7']), ('\u0bca', &['\u0bc6',
+ '\u0bbe']), ('\u0bcb', &['\u0bc7', '\u0bbe']), ('\u0bcc', &['\u0bc6', '\u0bd7']), ('\u0c48',
+ &['\u0c46', '\u0c56']), ('\u0cc0', &['\u0cbf', '\u0cd5']), ('\u0cc7', &['\u0cc6',
+ '\u0cd5']), ('\u0cc8', &['\u0cc6', '\u0cd6']), ('\u0cca', &['\u0cc6', '\u0cc2']), ('\u0ccb',
+ &['\u0cca', '\u0cd5']), ('\u0d4a', &['\u0d46', '\u0d3e']), ('\u0d4b', &['\u0d47',
+ '\u0d3e']), ('\u0d4c', &['\u0d46', '\u0d57']), ('\u0dda', &['\u0dd9', '\u0dca']), ('\u0ddc',
+ &['\u0dd9', '\u0dcf']), ('\u0ddd', &['\u0ddc', '\u0dca']), ('\u0dde', &['\u0dd9',
+ '\u0ddf']), ('\u0f43', &['\u0f42', '\u0fb7']), ('\u0f4d', &['\u0f4c', '\u0fb7']), ('\u0f52',
+ &['\u0f51', '\u0fb7']), ('\u0f57', &['\u0f56', '\u0fb7']), ('\u0f5c', &['\u0f5b',
+ '\u0fb7']), ('\u0f69', &['\u0f40', '\u0fb5']), ('\u0f73', &['\u0f71', '\u0f72']), ('\u0f75',
+ &['\u0f71', '\u0f74']), ('\u0f76', &['\u0fb2', '\u0f80']), ('\u0f78', &['\u0fb3',
+ '\u0f80']), ('\u0f81', &['\u0f71', '\u0f80']), ('\u0f93', &['\u0f92', '\u0fb7']), ('\u0f9d',
+ &['\u0f9c', '\u0fb7']), ('\u0fa2', &['\u0fa1', '\u0fb7']), ('\u0fa7', &['\u0fa6',
+ '\u0fb7']), ('\u0fac', &['\u0fab', '\u0fb7']), ('\u0fb9', &['\u0f90', '\u0fb5']), ('\u1026',
+ &['\u1025', '\u102e']), ('\u1b06', &['\u1b05', '\u1b35']), ('\u1b08', &['\u1b07',
+ '\u1b35']), ('\u1b0a', &['\u1b09', '\u1b35']), ('\u1b0c', &['\u1b0b', '\u1b35']), ('\u1b0e',
+ &['\u1b0d', '\u1b35']), ('\u1b12', &['\u1b11', '\u1b35']), ('\u1b3b', &['\u1b3a',
+ '\u1b35']), ('\u1b3d', &['\u1b3c', '\u1b35']), ('\u1b40', &['\u1b3e', '\u1b35']), ('\u1b41',
+ &['\u1b3f', '\u1b35']), ('\u1b43', &['\u1b42', '\u1b35']), ('\u1e00', &['\x41', '\u0325']),
+ ('\u1e01', &['\x61', '\u0325']), ('\u1e02', &['\x42', '\u0307']), ('\u1e03', &['\x62',
+ '\u0307']), ('\u1e04', &['\x42', '\u0323']), ('\u1e05', &['\x62', '\u0323']), ('\u1e06',
+ &['\x42', '\u0331']), ('\u1e07', &['\x62', '\u0331']), ('\u1e08', &['\xc7', '\u0301']),
+ ('\u1e09', &['\xe7', '\u0301']), ('\u1e0a', &['\x44', '\u0307']), ('\u1e0b', &['\x64',
+ '\u0307']), ('\u1e0c', &['\x44', '\u0323']), ('\u1e0d', &['\x64', '\u0323']), ('\u1e0e',
+ &['\x44', '\u0331']), ('\u1e0f', &['\x64', '\u0331']), ('\u1e10', &['\x44', '\u0327']),
+ ('\u1e11', &['\x64', '\u0327']), ('\u1e12', &['\x44', '\u032d']), ('\u1e13', &['\x64',
+ '\u032d']), ('\u1e14', &['\u0112', '\u0300']), ('\u1e15', &['\u0113', '\u0300']), ('\u1e16',
+ &['\u0112', '\u0301']), ('\u1e17', &['\u0113', '\u0301']), ('\u1e18', &['\x45', '\u032d']),
+ ('\u1e19', &['\x65', '\u032d']), ('\u1e1a', &['\x45', '\u0330']), ('\u1e1b', &['\x65',
+ '\u0330']), ('\u1e1c', &['\u0228', '\u0306']), ('\u1e1d', &['\u0229', '\u0306']), ('\u1e1e',
+ &['\x46', '\u0307']), ('\u1e1f', &['\x66', '\u0307']), ('\u1e20', &['\x47', '\u0304']),
+ ('\u1e21', &['\x67', '\u0304']), ('\u1e22', &['\x48', '\u0307']), ('\u1e23', &['\x68',
+ '\u0307']), ('\u1e24', &['\x48', '\u0323']), ('\u1e25', &['\x68', '\u0323']), ('\u1e26',
+ &['\x48', '\u0308']), ('\u1e27', &['\x68', '\u0308']), ('\u1e28', &['\x48', '\u0327']),
+ ('\u1e29', &['\x68', '\u0327']), ('\u1e2a', &['\x48', '\u032e']), ('\u1e2b', &['\x68',
+ '\u032e']), ('\u1e2c', &['\x49', '\u0330']), ('\u1e2d', &['\x69', '\u0330']), ('\u1e2e',
+ &['\xcf', '\u0301']), ('\u1e2f', &['\xef', '\u0301']), ('\u1e30', &['\x4b', '\u0301']),
+ ('\u1e31', &['\x6b', '\u0301']), ('\u1e32', &['\x4b', '\u0323']), ('\u1e33', &['\x6b',
+ '\u0323']), ('\u1e34', &['\x4b', '\u0331']), ('\u1e35', &['\x6b', '\u0331']), ('\u1e36',
+ &['\x4c', '\u0323']), ('\u1e37', &['\x6c', '\u0323']), ('\u1e38', &['\u1e36', '\u0304']),
+ ('\u1e39', &['\u1e37', '\u0304']), ('\u1e3a', &['\x4c', '\u0331']), ('\u1e3b', &['\x6c',
+ '\u0331']), ('\u1e3c', &['\x4c', '\u032d']), ('\u1e3d', &['\x6c', '\u032d']), ('\u1e3e',
+ &['\x4d', '\u0301']), ('\u1e3f', &['\x6d', '\u0301']), ('\u1e40', &['\x4d', '\u0307']),
+ ('\u1e41', &['\x6d', '\u0307']), ('\u1e42', &['\x4d', '\u0323']), ('\u1e43', &['\x6d',
+ '\u0323']), ('\u1e44', &['\x4e', '\u0307']), ('\u1e45', &['\x6e', '\u0307']), ('\u1e46',
+ &['\x4e', '\u0323']), ('\u1e47', &['\x6e', '\u0323']), ('\u1e48', &['\x4e', '\u0331']),
+ ('\u1e49', &['\x6e', '\u0331']), ('\u1e4a', &['\x4e', '\u032d']), ('\u1e4b', &['\x6e',
+ '\u032d']), ('\u1e4c', &['\xd5', '\u0301']), ('\u1e4d', &['\xf5', '\u0301']), ('\u1e4e',
+ &['\xd5', '\u0308']), ('\u1e4f', &['\xf5', '\u0308']), ('\u1e50', &['\u014c', '\u0300']),
+ ('\u1e51', &['\u014d', '\u0300']), ('\u1e52', &['\u014c', '\u0301']), ('\u1e53', &['\u014d',
+ '\u0301']), ('\u1e54', &['\x50', '\u0301']), ('\u1e55', &['\x70', '\u0301']), ('\u1e56',
+ &['\x50', '\u0307']), ('\u1e57', &['\x70', '\u0307']), ('\u1e58', &['\x52', '\u0307']),
+ ('\u1e59', &['\x72', '\u0307']), ('\u1e5a', &['\x52', '\u0323']), ('\u1e5b', &['\x72',
+ '\u0323']), ('\u1e5c', &['\u1e5a', '\u0304']), ('\u1e5d', &['\u1e5b', '\u0304']), ('\u1e5e',
+ &['\x52', '\u0331']), ('\u1e5f', &['\x72', '\u0331']), ('\u1e60', &['\x53', '\u0307']),
+ ('\u1e61', &['\x73', '\u0307']), ('\u1e62', &['\x53', '\u0323']), ('\u1e63', &['\x73',
+ '\u0323']), ('\u1e64', &['\u015a', '\u0307']), ('\u1e65', &['\u015b', '\u0307']), ('\u1e66',
+ &['\u0160', '\u0307']), ('\u1e67', &['\u0161', '\u0307']), ('\u1e68', &['\u1e62',
+ '\u0307']), ('\u1e69', &['\u1e63', '\u0307']), ('\u1e6a', &['\x54', '\u0307']), ('\u1e6b',
+ &['\x74', '\u0307']), ('\u1e6c', &['\x54', '\u0323']), ('\u1e6d', &['\x74', '\u0323']),
+ ('\u1e6e', &['\x54', '\u0331']), ('\u1e6f', &['\x74', '\u0331']), ('\u1e70', &['\x54',
+ '\u032d']), ('\u1e71', &['\x74', '\u032d']), ('\u1e72', &['\x55', '\u0324']), ('\u1e73',
+ &['\x75', '\u0324']), ('\u1e74', &['\x55', '\u0330']), ('\u1e75', &['\x75', '\u0330']),
+ ('\u1e76', &['\x55', '\u032d']), ('\u1e77', &['\x75', '\u032d']), ('\u1e78', &['\u0168',
+ '\u0301']), ('\u1e79', &['\u0169', '\u0301']), ('\u1e7a', &['\u016a', '\u0308']), ('\u1e7b',
+ &['\u016b', '\u0308']), ('\u1e7c', &['\x56', '\u0303']), ('\u1e7d', &['\x76', '\u0303']),
+ ('\u1e7e', &['\x56', '\u0323']), ('\u1e7f', &['\x76', '\u0323']), ('\u1e80', &['\x57',
+ '\u0300']), ('\u1e81', &['\x77', '\u0300']), ('\u1e82', &['\x57', '\u0301']), ('\u1e83',
+ &['\x77', '\u0301']), ('\u1e84', &['\x57', '\u0308']), ('\u1e85', &['\x77', '\u0308']),
+ ('\u1e86', &['\x57', '\u0307']), ('\u1e87', &['\x77', '\u0307']), ('\u1e88', &['\x57',
+ '\u0323']), ('\u1e89', &['\x77', '\u0323']), ('\u1e8a', &['\x58', '\u0307']), ('\u1e8b',
+ &['\x78', '\u0307']), ('\u1e8c', &['\x58', '\u0308']), ('\u1e8d', &['\x78', '\u0308']),
+ ('\u1e8e', &['\x59', '\u0307']), ('\u1e8f', &['\x79', '\u0307']), ('\u1e90', &['\x5a',
+ '\u0302']), ('\u1e91', &['\x7a', '\u0302']), ('\u1e92', &['\x5a', '\u0323']), ('\u1e93',
+ &['\x7a', '\u0323']), ('\u1e94', &['\x5a', '\u0331']), ('\u1e95', &['\x7a', '\u0331']),
+ ('\u1e96', &['\x68', '\u0331']), ('\u1e97', &['\x74', '\u0308']), ('\u1e98', &['\x77',
+ '\u030a']), ('\u1e99', &['\x79', '\u030a']), ('\u1e9b', &['\u017f', '\u0307']), ('\u1ea0',
+ &['\x41', '\u0323']), ('\u1ea1', &['\x61', '\u0323']), ('\u1ea2', &['\x41', '\u0309']),
+ ('\u1ea3', &['\x61', '\u0309']), ('\u1ea4', &['\xc2', '\u0301']), ('\u1ea5', &['\xe2',
+ '\u0301']), ('\u1ea6', &['\xc2', '\u0300']), ('\u1ea7', &['\xe2', '\u0300']), ('\u1ea8',
+ &['\xc2', '\u0309']), ('\u1ea9', &['\xe2', '\u0309']), ('\u1eaa', &['\xc2', '\u0303']),
+ ('\u1eab', &['\xe2', '\u0303']), ('\u1eac', &['\u1ea0', '\u0302']), ('\u1ead', &['\u1ea1',
+ '\u0302']), ('\u1eae', &['\u0102', '\u0301']), ('\u1eaf', &['\u0103', '\u0301']), ('\u1eb0',
+ &['\u0102', '\u0300']), ('\u1eb1', &['\u0103', '\u0300']), ('\u1eb2', &['\u0102',
+ '\u0309']), ('\u1eb3', &['\u0103', '\u0309']), ('\u1eb4', &['\u0102', '\u0303']), ('\u1eb5',
+ &['\u0103', '\u0303']), ('\u1eb6', &['\u1ea0', '\u0306']), ('\u1eb7', &['\u1ea1',
+ '\u0306']), ('\u1eb8', &['\x45', '\u0323']), ('\u1eb9', &['\x65', '\u0323']), ('\u1eba',
+ &['\x45', '\u0309']), ('\u1ebb', &['\x65', '\u0309']), ('\u1ebc', &['\x45', '\u0303']),
+ ('\u1ebd', &['\x65', '\u0303']), ('\u1ebe', &['\xca', '\u0301']), ('\u1ebf', &['\xea',
+ '\u0301']), ('\u1ec0', &['\xca', '\u0300']), ('\u1ec1', &['\xea', '\u0300']), ('\u1ec2',
+ &['\xca', '\u0309']), ('\u1ec3', &['\xea', '\u0309']), ('\u1ec4', &['\xca', '\u0303']),
+ ('\u1ec5', &['\xea', '\u0303']), ('\u1ec6', &['\u1eb8', '\u0302']), ('\u1ec7', &['\u1eb9',
+ '\u0302']), ('\u1ec8', &['\x49', '\u0309']), ('\u1ec9', &['\x69', '\u0309']), ('\u1eca',
+ &['\x49', '\u0323']), ('\u1ecb', &['\x69', '\u0323']), ('\u1ecc', &['\x4f', '\u0323']),
+ ('\u1ecd', &['\x6f', '\u0323']), ('\u1ece', &['\x4f', '\u0309']), ('\u1ecf', &['\x6f',
+ '\u0309']), ('\u1ed0', &['\xd4', '\u0301']), ('\u1ed1', &['\xf4', '\u0301']), ('\u1ed2',
+ &['\xd4', '\u0300']), ('\u1ed3', &['\xf4', '\u0300']), ('\u1ed4', &['\xd4', '\u0309']),
+ ('\u1ed5', &['\xf4', '\u0309']), ('\u1ed6', &['\xd4', '\u0303']), ('\u1ed7', &['\xf4',
+ '\u0303']), ('\u1ed8', &['\u1ecc', '\u0302']), ('\u1ed9', &['\u1ecd', '\u0302']), ('\u1eda',
+ &['\u01a0', '\u0301']), ('\u1edb', &['\u01a1', '\u0301']), ('\u1edc', &['\u01a0',
+ '\u0300']), ('\u1edd', &['\u01a1', '\u0300']), ('\u1ede', &['\u01a0', '\u0309']), ('\u1edf',
+ &['\u01a1', '\u0309']), ('\u1ee0', &['\u01a0', '\u0303']), ('\u1ee1', &['\u01a1',
+ '\u0303']), ('\u1ee2', &['\u01a0', '\u0323']), ('\u1ee3', &['\u01a1', '\u0323']), ('\u1ee4',
+ &['\x55', '\u0323']), ('\u1ee5', &['\x75', '\u0323']), ('\u1ee6', &['\x55', '\u0309']),
+ ('\u1ee7', &['\x75', '\u0309']), ('\u1ee8', &['\u01af', '\u0301']), ('\u1ee9', &['\u01b0',
+ '\u0301']), ('\u1eea', &['\u01af', '\u0300']), ('\u1eeb', &['\u01b0', '\u0300']), ('\u1eec',
+ &['\u01af', '\u0309']), ('\u1eed', &['\u01b0', '\u0309']), ('\u1eee', &['\u01af',
+ '\u0303']), ('\u1eef', &['\u01b0', '\u0303']), ('\u1ef0', &['\u01af', '\u0323']), ('\u1ef1',
+ &['\u01b0', '\u0323']), ('\u1ef2', &['\x59', '\u0300']), ('\u1ef3', &['\x79', '\u0300']),
+ ('\u1ef4', &['\x59', '\u0323']), ('\u1ef5', &['\x79', '\u0323']), ('\u1ef6', &['\x59',
+ '\u0309']), ('\u1ef7', &['\x79', '\u0309']), ('\u1ef8', &['\x59', '\u0303']), ('\u1ef9',
+ &['\x79', '\u0303']), ('\u1f00', &['\u03b1', '\u0313']), ('\u1f01', &['\u03b1', '\u0314']),
+ ('\u1f02', &['\u1f00', '\u0300']), ('\u1f03', &['\u1f01', '\u0300']), ('\u1f04', &['\u1f00',
+ '\u0301']), ('\u1f05', &['\u1f01', '\u0301']), ('\u1f06', &['\u1f00', '\u0342']), ('\u1f07',
+ &['\u1f01', '\u0342']), ('\u1f08', &['\u0391', '\u0313']), ('\u1f09', &['\u0391',
+ '\u0314']), ('\u1f0a', &['\u1f08', '\u0300']), ('\u1f0b', &['\u1f09', '\u0300']), ('\u1f0c',
+ &['\u1f08', '\u0301']), ('\u1f0d', &['\u1f09', '\u0301']), ('\u1f0e', &['\u1f08',
+ '\u0342']), ('\u1f0f', &['\u1f09', '\u0342']), ('\u1f10', &['\u03b5', '\u0313']), ('\u1f11',
+ &['\u03b5', '\u0314']), ('\u1f12', &['\u1f10', '\u0300']), ('\u1f13', &['\u1f11',
+ '\u0300']), ('\u1f14', &['\u1f10', '\u0301']), ('\u1f15', &['\u1f11', '\u0301']), ('\u1f18',
+ &['\u0395', '\u0313']), ('\u1f19', &['\u0395', '\u0314']), ('\u1f1a', &['\u1f18',
+ '\u0300']), ('\u1f1b', &['\u1f19', '\u0300']), ('\u1f1c', &['\u1f18', '\u0301']), ('\u1f1d',
+ &['\u1f19', '\u0301']), ('\u1f20', &['\u03b7', '\u0313']), ('\u1f21', &['\u03b7',
+ '\u0314']), ('\u1f22', &['\u1f20', '\u0300']), ('\u1f23', &['\u1f21', '\u0300']), ('\u1f24',
+ &['\u1f20', '\u0301']), ('\u1f25', &['\u1f21', '\u0301']), ('\u1f26', &['\u1f20',
+ '\u0342']), ('\u1f27', &['\u1f21', '\u0342']), ('\u1f28', &['\u0397', '\u0313']), ('\u1f29',
+ &['\u0397', '\u0314']), ('\u1f2a', &['\u1f28', '\u0300']), ('\u1f2b', &['\u1f29',
+ '\u0300']), ('\u1f2c', &['\u1f28', '\u0301']), ('\u1f2d', &['\u1f29', '\u0301']), ('\u1f2e',
+ &['\u1f28', '\u0342']), ('\u1f2f', &['\u1f29', '\u0342']), ('\u1f30', &['\u03b9',
+ '\u0313']), ('\u1f31', &['\u03b9', '\u0314']), ('\u1f32', &['\u1f30', '\u0300']), ('\u1f33',
+ &['\u1f31', '\u0300']), ('\u1f34', &['\u1f30', '\u0301']), ('\u1f35', &['\u1f31',
+ '\u0301']), ('\u1f36', &['\u1f30', '\u0342']), ('\u1f37', &['\u1f31', '\u0342']), ('\u1f38',
+ &['\u0399', '\u0313']), ('\u1f39', &['\u0399', '\u0314']), ('\u1f3a', &['\u1f38',
+ '\u0300']), ('\u1f3b', &['\u1f39', '\u0300']), ('\u1f3c', &['\u1f38', '\u0301']), ('\u1f3d',
+ &['\u1f39', '\u0301']), ('\u1f3e', &['\u1f38', '\u0342']), ('\u1f3f', &['\u1f39',
+ '\u0342']), ('\u1f40', &['\u03bf', '\u0313']), ('\u1f41', &['\u03bf', '\u0314']), ('\u1f42',
+ &['\u1f40', '\u0300']), ('\u1f43', &['\u1f41', '\u0300']), ('\u1f44', &['\u1f40',
+ '\u0301']), ('\u1f45', &['\u1f41', '\u0301']), ('\u1f48', &['\u039f', '\u0313']), ('\u1f49',
+ &['\u039f', '\u0314']), ('\u1f4a', &['\u1f48', '\u0300']), ('\u1f4b', &['\u1f49',
+ '\u0300']), ('\u1f4c', &['\u1f48', '\u0301']), ('\u1f4d', &['\u1f49', '\u0301']), ('\u1f50',
+ &['\u03c5', '\u0313']), ('\u1f51', &['\u03c5', '\u0314']), ('\u1f52', &['\u1f50',
+ '\u0300']), ('\u1f53', &['\u1f51', '\u0300']), ('\u1f54', &['\u1f50', '\u0301']), ('\u1f55',
+ &['\u1f51', '\u0301']), ('\u1f56', &['\u1f50', '\u0342']), ('\u1f57', &['\u1f51',
+ '\u0342']), ('\u1f59', &['\u03a5', '\u0314']), ('\u1f5b', &['\u1f59', '\u0300']), ('\u1f5d',
+ &['\u1f59', '\u0301']), ('\u1f5f', &['\u1f59', '\u0342']), ('\u1f60', &['\u03c9',
+ '\u0313']), ('\u1f61', &['\u03c9', '\u0314']), ('\u1f62', &['\u1f60', '\u0300']), ('\u1f63',
+ &['\u1f61', '\u0300']), ('\u1f64', &['\u1f60', '\u0301']), ('\u1f65', &['\u1f61',
+ '\u0301']), ('\u1f66', &['\u1f60', '\u0342']), ('\u1f67', &['\u1f61', '\u0342']), ('\u1f68',
+ &['\u03a9', '\u0313']), ('\u1f69', &['\u03a9', '\u0314']), ('\u1f6a', &['\u1f68',
+ '\u0300']), ('\u1f6b', &['\u1f69', '\u0300']), ('\u1f6c', &['\u1f68', '\u0301']), ('\u1f6d',
+ &['\u1f69', '\u0301']), ('\u1f6e', &['\u1f68', '\u0342']), ('\u1f6f', &['\u1f69',
+ '\u0342']), ('\u1f70', &['\u03b1', '\u0300']), ('\u1f71', &['\u03ac']), ('\u1f72',
+ &['\u03b5', '\u0300']), ('\u1f73', &['\u03ad']), ('\u1f74', &['\u03b7', '\u0300']),
+ ('\u1f75', &['\u03ae']), ('\u1f76', &['\u03b9', '\u0300']), ('\u1f77', &['\u03af']),
+ ('\u1f78', &['\u03bf', '\u0300']), ('\u1f79', &['\u03cc']), ('\u1f7a', &['\u03c5',
+ '\u0300']), ('\u1f7b', &['\u03cd']), ('\u1f7c', &['\u03c9', '\u0300']), ('\u1f7d',
+ &['\u03ce']), ('\u1f80', &['\u1f00', '\u0345']), ('\u1f81', &['\u1f01', '\u0345']),
+ ('\u1f82', &['\u1f02', '\u0345']), ('\u1f83', &['\u1f03', '\u0345']), ('\u1f84', &['\u1f04',
+ '\u0345']), ('\u1f85', &['\u1f05', '\u0345']), ('\u1f86', &['\u1f06', '\u0345']), ('\u1f87',
+ &['\u1f07', '\u0345']), ('\u1f88', &['\u1f08', '\u0345']), ('\u1f89', &['\u1f09',
+ '\u0345']), ('\u1f8a', &['\u1f0a', '\u0345']), ('\u1f8b', &['\u1f0b', '\u0345']), ('\u1f8c',
+ &['\u1f0c', '\u0345']), ('\u1f8d', &['\u1f0d', '\u0345']), ('\u1f8e', &['\u1f0e',
+ '\u0345']), ('\u1f8f', &['\u1f0f', '\u0345']), ('\u1f90', &['\u1f20', '\u0345']), ('\u1f91',
+ &['\u1f21', '\u0345']), ('\u1f92', &['\u1f22', '\u0345']), ('\u1f93', &['\u1f23',
+ '\u0345']), ('\u1f94', &['\u1f24', '\u0345']), ('\u1f95', &['\u1f25', '\u0345']), ('\u1f96',
+ &['\u1f26', '\u0345']), ('\u1f97', &['\u1f27', '\u0345']), ('\u1f98', &['\u1f28',
+ '\u0345']), ('\u1f99', &['\u1f29', '\u0345']), ('\u1f9a', &['\u1f2a', '\u0345']), ('\u1f9b',
+ &['\u1f2b', '\u0345']), ('\u1f9c', &['\u1f2c', '\u0345']), ('\u1f9d', &['\u1f2d',
+ '\u0345']), ('\u1f9e', &['\u1f2e', '\u0345']), ('\u1f9f', &['\u1f2f', '\u0345']), ('\u1fa0',
+ &['\u1f60', '\u0345']), ('\u1fa1', &['\u1f61', '\u0345']), ('\u1fa2', &['\u1f62',
+ '\u0345']), ('\u1fa3', &['\u1f63', '\u0345']), ('\u1fa4', &['\u1f64', '\u0345']), ('\u1fa5',
+ &['\u1f65', '\u0345']), ('\u1fa6', &['\u1f66', '\u0345']), ('\u1fa7', &['\u1f67',
+ '\u0345']), ('\u1fa8', &['\u1f68', '\u0345']), ('\u1fa9', &['\u1f69', '\u0345']), ('\u1faa',
+ &['\u1f6a', '\u0345']), ('\u1fab', &['\u1f6b', '\u0345']), ('\u1fac', &['\u1f6c',
+ '\u0345']), ('\u1fad', &['\u1f6d', '\u0345']), ('\u1fae', &['\u1f6e', '\u0345']), ('\u1faf',
+ &['\u1f6f', '\u0345']), ('\u1fb0', &['\u03b1', '\u0306']), ('\u1fb1', &['\u03b1',
+ '\u0304']), ('\u1fb2', &['\u1f70', '\u0345']), ('\u1fb3', &['\u03b1', '\u0345']), ('\u1fb4',
+ &['\u03ac', '\u0345']), ('\u1fb6', &['\u03b1', '\u0342']), ('\u1fb7', &['\u1fb6',
+ '\u0345']), ('\u1fb8', &['\u0391', '\u0306']), ('\u1fb9', &['\u0391', '\u0304']), ('\u1fba',
+ &['\u0391', '\u0300']), ('\u1fbb', &['\u0386']), ('\u1fbc', &['\u0391', '\u0345']),
+ ('\u1fbe', &['\u03b9']), ('\u1fc1', &['\xa8', '\u0342']), ('\u1fc2', &['\u1f74', '\u0345']),
+ ('\u1fc3', &['\u03b7', '\u0345']), ('\u1fc4', &['\u03ae', '\u0345']), ('\u1fc6', &['\u03b7',
+ '\u0342']), ('\u1fc7', &['\u1fc6', '\u0345']), ('\u1fc8', &['\u0395', '\u0300']), ('\u1fc9',
+ &['\u0388']), ('\u1fca', &['\u0397', '\u0300']), ('\u1fcb', &['\u0389']), ('\u1fcc',
+ &['\u0397', '\u0345']), ('\u1fcd', &['\u1fbf', '\u0300']), ('\u1fce', &['\u1fbf',
+ '\u0301']), ('\u1fcf', &['\u1fbf', '\u0342']), ('\u1fd0', &['\u03b9', '\u0306']), ('\u1fd1',
+ &['\u03b9', '\u0304']), ('\u1fd2', &['\u03ca', '\u0300']), ('\u1fd3', &['\u0390']),
+ ('\u1fd6', &['\u03b9', '\u0342']), ('\u1fd7', &['\u03ca', '\u0342']), ('\u1fd8', &['\u0399',
+ '\u0306']), ('\u1fd9', &['\u0399', '\u0304']), ('\u1fda', &['\u0399', '\u0300']), ('\u1fdb',
+ &['\u038a']), ('\u1fdd', &['\u1ffe', '\u0300']), ('\u1fde', &['\u1ffe', '\u0301']),
+ ('\u1fdf', &['\u1ffe', '\u0342']), ('\u1fe0', &['\u03c5', '\u0306']), ('\u1fe1', &['\u03c5',
+ '\u0304']), ('\u1fe2', &['\u03cb', '\u0300']), ('\u1fe3', &['\u03b0']), ('\u1fe4',
+ &['\u03c1', '\u0313']), ('\u1fe5', &['\u03c1', '\u0314']), ('\u1fe6', &['\u03c5',
+ '\u0342']), ('\u1fe7', &['\u03cb', '\u0342']), ('\u1fe8', &['\u03a5', '\u0306']), ('\u1fe9',
+ &['\u03a5', '\u0304']), ('\u1fea', &['\u03a5', '\u0300']), ('\u1feb', &['\u038e']),
+ ('\u1fec', &['\u03a1', '\u0314']), ('\u1fed', &['\xa8', '\u0300']), ('\u1fee', &['\u0385']),
+ ('\u1fef', &['\x60']), ('\u1ff2', &['\u1f7c', '\u0345']), ('\u1ff3', &['\u03c9', '\u0345']),
+ ('\u1ff4', &['\u03ce', '\u0345']), ('\u1ff6', &['\u03c9', '\u0342']), ('\u1ff7', &['\u1ff6',
+ '\u0345']), ('\u1ff8', &['\u039f', '\u0300']), ('\u1ff9', &['\u038c']), ('\u1ffa',
+ &['\u03a9', '\u0300']), ('\u1ffb', &['\u038f']), ('\u1ffc', &['\u03a9', '\u0345']),
+ ('\u1ffd', &['\xb4']), ('\u2000', &['\u2002']), ('\u2001', &['\u2003']), ('\u2126',
+ &['\u03a9']), ('\u212a', &['\x4b']), ('\u212b', &['\xc5']), ('\u219a', &['\u2190',
+ '\u0338']), ('\u219b', &['\u2192', '\u0338']), ('\u21ae', &['\u2194', '\u0338']), ('\u21cd',
+ &['\u21d0', '\u0338']), ('\u21ce', &['\u21d4', '\u0338']), ('\u21cf', &['\u21d2',
+ '\u0338']), ('\u2204', &['\u2203', '\u0338']), ('\u2209', &['\u2208', '\u0338']), ('\u220c',
+ &['\u220b', '\u0338']), ('\u2224', &['\u2223', '\u0338']), ('\u2226', &['\u2225',
+ '\u0338']), ('\u2241', &['\u223c', '\u0338']), ('\u2244', &['\u2243', '\u0338']), ('\u2247',
+ &['\u2245', '\u0338']), ('\u2249', &['\u2248', '\u0338']), ('\u2260', &['\x3d', '\u0338']),
+ ('\u2262', &['\u2261', '\u0338']), ('\u226d', &['\u224d', '\u0338']), ('\u226e', &['\x3c',
+ '\u0338']), ('\u226f', &['\x3e', '\u0338']), ('\u2270', &['\u2264', '\u0338']), ('\u2271',
+ &['\u2265', '\u0338']), ('\u2274', &['\u2272', '\u0338']), ('\u2275', &['\u2273',
+ '\u0338']), ('\u2278', &['\u2276', '\u0338']), ('\u2279', &['\u2277', '\u0338']), ('\u2280',
+ &['\u227a', '\u0338']), ('\u2281', &['\u227b', '\u0338']), ('\u2284', &['\u2282',
+ '\u0338']), ('\u2285', &['\u2283', '\u0338']), ('\u2288', &['\u2286', '\u0338']), ('\u2289',
+ &['\u2287', '\u0338']), ('\u22ac', &['\u22a2', '\u0338']), ('\u22ad', &['\u22a8',
+ '\u0338']), ('\u22ae', &['\u22a9', '\u0338']), ('\u22af', &['\u22ab', '\u0338']), ('\u22e0',
+ &['\u227c', '\u0338']), ('\u22e1', &['\u227d', '\u0338']), ('\u22e2', &['\u2291',
+ '\u0338']), ('\u22e3', &['\u2292', '\u0338']), ('\u22ea', &['\u22b2', '\u0338']), ('\u22eb',
+ &['\u22b3', '\u0338']), ('\u22ec', &['\u22b4', '\u0338']), ('\u22ed', &['\u22b5',
+ '\u0338']), ('\u2329', &['\u3008']), ('\u232a', &['\u3009']), ('\u2adc', &['\u2add',
+ '\u0338']), ('\u304c', &['\u304b', '\u3099']), ('\u304e', &['\u304d', '\u3099']), ('\u3050',
+ &['\u304f', '\u3099']), ('\u3052', &['\u3051', '\u3099']), ('\u3054', &['\u3053',
+ '\u3099']), ('\u3056', &['\u3055', '\u3099']), ('\u3058', &['\u3057', '\u3099']), ('\u305a',
+ &['\u3059', '\u3099']), ('\u305c', &['\u305b', '\u3099']), ('\u305e', &['\u305d',
+ '\u3099']), ('\u3060', &['\u305f', '\u3099']), ('\u3062', &['\u3061', '\u3099']), ('\u3065',
+ &['\u3064', '\u3099']), ('\u3067', &['\u3066', '\u3099']), ('\u3069', &['\u3068',
+ '\u3099']), ('\u3070', &['\u306f', '\u3099']), ('\u3071', &['\u306f', '\u309a']), ('\u3073',
+ &['\u3072', '\u3099']), ('\u3074', &['\u3072', '\u309a']), ('\u3076', &['\u3075',
+ '\u3099']), ('\u3077', &['\u3075', '\u309a']), ('\u3079', &['\u3078', '\u3099']), ('\u307a',
+ &['\u3078', '\u309a']), ('\u307c', &['\u307b', '\u3099']), ('\u307d', &['\u307b',
+ '\u309a']), ('\u3094', &['\u3046', '\u3099']), ('\u309e', &['\u309d', '\u3099']), ('\u30ac',
+ &['\u30ab', '\u3099']), ('\u30ae', &['\u30ad', '\u3099']), ('\u30b0', &['\u30af',
+ '\u3099']), ('\u30b2', &['\u30b1', '\u3099']), ('\u30b4', &['\u30b3', '\u3099']), ('\u30b6',
+ &['\u30b5', '\u3099']), ('\u30b8', &['\u30b7', '\u3099']), ('\u30ba', &['\u30b9',
+ '\u3099']), ('\u30bc', &['\u30bb', '\u3099']), ('\u30be', &['\u30bd', '\u3099']), ('\u30c0',
+ &['\u30bf', '\u3099']), ('\u30c2', &['\u30c1', '\u3099']), ('\u30c5', &['\u30c4',
+ '\u3099']), ('\u30c7', &['\u30c6', '\u3099']), ('\u30c9', &['\u30c8', '\u3099']), ('\u30d0',
+ &['\u30cf', '\u3099']), ('\u30d1', &['\u30cf', '\u309a']), ('\u30d3', &['\u30d2',
+ '\u3099']), ('\u30d4', &['\u30d2', '\u309a']), ('\u30d6', &['\u30d5', '\u3099']), ('\u30d7',
+ &['\u30d5', '\u309a']), ('\u30d9', &['\u30d8', '\u3099']), ('\u30da', &['\u30d8',
+ '\u309a']), ('\u30dc', &['\u30db', '\u3099']), ('\u30dd', &['\u30db', '\u309a']), ('\u30f4',
+ &['\u30a6', '\u3099']), ('\u30f7', &['\u30ef', '\u3099']), ('\u30f8', &['\u30f0',
+ '\u3099']), ('\u30f9', &['\u30f1', '\u3099']), ('\u30fa', &['\u30f2', '\u3099']), ('\u30fe',
+ &['\u30fd', '\u3099']), ('\uf900', &['\u8c48']), ('\uf901', &['\u66f4']), ('\uf902',
+ &['\u8eca']), ('\uf903', &['\u8cc8']), ('\uf904', &['\u6ed1']), ('\uf905', &['\u4e32']),
+ ('\uf906', &['\u53e5']), ('\uf907', &['\u9f9c']), ('\uf908', &['\u9f9c']), ('\uf909',
+ &['\u5951']), ('\uf90a', &['\u91d1']), ('\uf90b', &['\u5587']), ('\uf90c', &['\u5948']),
+ ('\uf90d', &['\u61f6']), ('\uf90e', &['\u7669']), ('\uf90f', &['\u7f85']), ('\uf910',
+ &['\u863f']), ('\uf911', &['\u87ba']), ('\uf912', &['\u88f8']), ('\uf913', &['\u908f']),
+ ('\uf914', &['\u6a02']), ('\uf915', &['\u6d1b']), ('\uf916', &['\u70d9']), ('\uf917',
+ &['\u73de']), ('\uf918', &['\u843d']), ('\uf919', &['\u916a']), ('\uf91a', &['\u99f1']),
+ ('\uf91b', &['\u4e82']), ('\uf91c', &['\u5375']), ('\uf91d', &['\u6b04']), ('\uf91e',
+ &['\u721b']), ('\uf91f', &['\u862d']), ('\uf920', &['\u9e1e']), ('\uf921', &['\u5d50']),
+ ('\uf922', &['\u6feb']), ('\uf923', &['\u85cd']), ('\uf924', &['\u8964']), ('\uf925',
+ &['\u62c9']), ('\uf926', &['\u81d8']), ('\uf927', &['\u881f']), ('\uf928', &['\u5eca']),
+ ('\uf929', &['\u6717']), ('\uf92a', &['\u6d6a']), ('\uf92b', &['\u72fc']), ('\uf92c',
+ &['\u90ce']), ('\uf92d', &['\u4f86']), ('\uf92e', &['\u51b7']), ('\uf92f', &['\u52de']),
+ ('\uf930', &['\u64c4']), ('\uf931', &['\u6ad3']), ('\uf932', &['\u7210']), ('\uf933',
+ &['\u76e7']), ('\uf934', &['\u8001']), ('\uf935', &['\u8606']), ('\uf936', &['\u865c']),
+ ('\uf937', &['\u8def']), ('\uf938', &['\u9732']), ('\uf939', &['\u9b6f']), ('\uf93a',
+ &['\u9dfa']), ('\uf93b', &['\u788c']), ('\uf93c', &['\u797f']), ('\uf93d', &['\u7da0']),
+ ('\uf93e', &['\u83c9']), ('\uf93f', &['\u9304']), ('\uf940', &['\u9e7f']), ('\uf941',
+ &['\u8ad6']), ('\uf942', &['\u58df']), ('\uf943', &['\u5f04']), ('\uf944', &['\u7c60']),
+ ('\uf945', &['\u807e']), ('\uf946', &['\u7262']), ('\uf947', &['\u78ca']), ('\uf948',
+ &['\u8cc2']), ('\uf949', &['\u96f7']), ('\uf94a', &['\u58d8']), ('\uf94b', &['\u5c62']),
+ ('\uf94c', &['\u6a13']), ('\uf94d', &['\u6dda']), ('\uf94e', &['\u6f0f']), ('\uf94f',
+ &['\u7d2f']), ('\uf950', &['\u7e37']), ('\uf951', &['\u964b']), ('\uf952', &['\u52d2']),
+ ('\uf953', &['\u808b']), ('\uf954', &['\u51dc']), ('\uf955', &['\u51cc']), ('\uf956',
+ &['\u7a1c']), ('\uf957', &['\u7dbe']), ('\uf958', &['\u83f1']), ('\uf959', &['\u9675']),
+ ('\uf95a', &['\u8b80']), ('\uf95b', &['\u62cf']), ('\uf95c', &['\u6a02']), ('\uf95d',
+ &['\u8afe']), ('\uf95e', &['\u4e39']), ('\uf95f', &['\u5be7']), ('\uf960', &['\u6012']),
+ ('\uf961', &['\u7387']), ('\uf962', &['\u7570']), ('\uf963', &['\u5317']), ('\uf964',
+ &['\u78fb']), ('\uf965', &['\u4fbf']), ('\uf966', &['\u5fa9']), ('\uf967', &['\u4e0d']),
+ ('\uf968', &['\u6ccc']), ('\uf969', &['\u6578']), ('\uf96a', &['\u7d22']), ('\uf96b',
+ &['\u53c3']), ('\uf96c', &['\u585e']), ('\uf96d', &['\u7701']), ('\uf96e', &['\u8449']),
+ ('\uf96f', &['\u8aaa']), ('\uf970', &['\u6bba']), ('\uf971', &['\u8fb0']), ('\uf972',
+ &['\u6c88']), ('\uf973', &['\u62fe']), ('\uf974', &['\u82e5']), ('\uf975', &['\u63a0']),
+ ('\uf976', &['\u7565']), ('\uf977', &['\u4eae']), ('\uf978', &['\u5169']), ('\uf979',
+ &['\u51c9']), ('\uf97a', &['\u6881']), ('\uf97b', &['\u7ce7']), ('\uf97c', &['\u826f']),
+ ('\uf97d', &['\u8ad2']), ('\uf97e', &['\u91cf']), ('\uf97f', &['\u52f5']), ('\uf980',
+ &['\u5442']), ('\uf981', &['\u5973']), ('\uf982', &['\u5eec']), ('\uf983', &['\u65c5']),
+ ('\uf984', &['\u6ffe']), ('\uf985', &['\u792a']), ('\uf986', &['\u95ad']), ('\uf987',
+ &['\u9a6a']), ('\uf988', &['\u9e97']), ('\uf989', &['\u9ece']), ('\uf98a', &['\u529b']),
+ ('\uf98b', &['\u66c6']), ('\uf98c', &['\u6b77']), ('\uf98d', &['\u8f62']), ('\uf98e',
+ &['\u5e74']), ('\uf98f', &['\u6190']), ('\uf990', &['\u6200']), ('\uf991', &['\u649a']),
+ ('\uf992', &['\u6f23']), ('\uf993', &['\u7149']), ('\uf994', &['\u7489']), ('\uf995',
+ &['\u79ca']), ('\uf996', &['\u7df4']), ('\uf997', &['\u806f']), ('\uf998', &['\u8f26']),
+ ('\uf999', &['\u84ee']), ('\uf99a', &['\u9023']), ('\uf99b', &['\u934a']), ('\uf99c',
+ &['\u5217']), ('\uf99d', &['\u52a3']), ('\uf99e', &['\u54bd']), ('\uf99f', &['\u70c8']),
+ ('\uf9a0', &['\u88c2']), ('\uf9a1', &['\u8aaa']), ('\uf9a2', &['\u5ec9']), ('\uf9a3',
+ &['\u5ff5']), ('\uf9a4', &['\u637b']), ('\uf9a5', &['\u6bae']), ('\uf9a6', &['\u7c3e']),
+ ('\uf9a7', &['\u7375']), ('\uf9a8', &['\u4ee4']), ('\uf9a9', &['\u56f9']), ('\uf9aa',
+ &['\u5be7']), ('\uf9ab', &['\u5dba']), ('\uf9ac', &['\u601c']), ('\uf9ad', &['\u73b2']),
+ ('\uf9ae', &['\u7469']), ('\uf9af', &['\u7f9a']), ('\uf9b0', &['\u8046']), ('\uf9b1',
+ &['\u9234']), ('\uf9b2', &['\u96f6']), ('\uf9b3', &['\u9748']), ('\uf9b4', &['\u9818']),
+ ('\uf9b5', &['\u4f8b']), ('\uf9b6', &['\u79ae']), ('\uf9b7', &['\u91b4']), ('\uf9b8',
+ &['\u96b8']), ('\uf9b9', &['\u60e1']), ('\uf9ba', &['\u4e86']), ('\uf9bb', &['\u50da']),
+ ('\uf9bc', &['\u5bee']), ('\uf9bd', &['\u5c3f']), ('\uf9be', &['\u6599']), ('\uf9bf',
+ &['\u6a02']), ('\uf9c0', &['\u71ce']), ('\uf9c1', &['\u7642']), ('\uf9c2', &['\u84fc']),
+ ('\uf9c3', &['\u907c']), ('\uf9c4', &['\u9f8d']), ('\uf9c5', &['\u6688']), ('\uf9c6',
+ &['\u962e']), ('\uf9c7', &['\u5289']), ('\uf9c8', &['\u677b']), ('\uf9c9', &['\u67f3']),
+ ('\uf9ca', &['\u6d41']), ('\uf9cb', &['\u6e9c']), ('\uf9cc', &['\u7409']), ('\uf9cd',
+ &['\u7559']), ('\uf9ce', &['\u786b']), ('\uf9cf', &['\u7d10']), ('\uf9d0', &['\u985e']),
+ ('\uf9d1', &['\u516d']), ('\uf9d2', &['\u622e']), ('\uf9d3', &['\u9678']), ('\uf9d4',
+ &['\u502b']), ('\uf9d5', &['\u5d19']), ('\uf9d6', &['\u6dea']), ('\uf9d7', &['\u8f2a']),
+ ('\uf9d8', &['\u5f8b']), ('\uf9d9', &['\u6144']), ('\uf9da', &['\u6817']), ('\uf9db',
+ &['\u7387']), ('\uf9dc', &['\u9686']), ('\uf9dd', &['\u5229']), ('\uf9de', &['\u540f']),
+ ('\uf9df', &['\u5c65']), ('\uf9e0', &['\u6613']), ('\uf9e1', &['\u674e']), ('\uf9e2',
+ &['\u68a8']), ('\uf9e3', &['\u6ce5']), ('\uf9e4', &['\u7406']), ('\uf9e5', &['\u75e2']),
+ ('\uf9e6', &['\u7f79']), ('\uf9e7', &['\u88cf']), ('\uf9e8', &['\u88e1']), ('\uf9e9',
+ &['\u91cc']), ('\uf9ea', &['\u96e2']), ('\uf9eb', &['\u533f']), ('\uf9ec', &['\u6eba']),
+ ('\uf9ed', &['\u541d']), ('\uf9ee', &['\u71d0']), ('\uf9ef', &['\u7498']), ('\uf9f0',
+ &['\u85fa']), ('\uf9f1', &['\u96a3']), ('\uf9f2', &['\u9c57']), ('\uf9f3', &['\u9e9f']),
+ ('\uf9f4', &['\u6797']), ('\uf9f5', &['\u6dcb']), ('\uf9f6', &['\u81e8']), ('\uf9f7',
+ &['\u7acb']), ('\uf9f8', &['\u7b20']), ('\uf9f9', &['\u7c92']), ('\uf9fa', &['\u72c0']),
+ ('\uf9fb', &['\u7099']), ('\uf9fc', &['\u8b58']), ('\uf9fd', &['\u4ec0']), ('\uf9fe',
+ &['\u8336']), ('\uf9ff', &['\u523a']), ('\ufa00', &['\u5207']), ('\ufa01', &['\u5ea6']),
+ ('\ufa02', &['\u62d3']), ('\ufa03', &['\u7cd6']), ('\ufa04', &['\u5b85']), ('\ufa05',
+ &['\u6d1e']), ('\ufa06', &['\u66b4']), ('\ufa07', &['\u8f3b']), ('\ufa08', &['\u884c']),
+ ('\ufa09', &['\u964d']), ('\ufa0a', &['\u898b']), ('\ufa0b', &['\u5ed3']), ('\ufa0c',
+ &['\u5140']), ('\ufa0d', &['\u55c0']), ('\ufa10', &['\u585a']), ('\ufa12', &['\u6674']),
+ ('\ufa15', &['\u51de']), ('\ufa16', &['\u732a']), ('\ufa17', &['\u76ca']), ('\ufa18',
+ &['\u793c']), ('\ufa19', &['\u795e']), ('\ufa1a', &['\u7965']), ('\ufa1b', &['\u798f']),
+ ('\ufa1c', &['\u9756']), ('\ufa1d', &['\u7cbe']), ('\ufa1e', &['\u7fbd']), ('\ufa20',
+ &['\u8612']), ('\ufa22', &['\u8af8']), ('\ufa25', &['\u9038']), ('\ufa26', &['\u90fd']),
+ ('\ufa2a', &['\u98ef']), ('\ufa2b', &['\u98fc']), ('\ufa2c', &['\u9928']), ('\ufa2d',
+ &['\u9db4']), ('\ufa2e', &['\u90de']), ('\ufa2f', &['\u96b7']), ('\ufa30', &['\u4fae']),
+ ('\ufa31', &['\u50e7']), ('\ufa32', &['\u514d']), ('\ufa33', &['\u52c9']), ('\ufa34',
+ &['\u52e4']), ('\ufa35', &['\u5351']), ('\ufa36', &['\u559d']), ('\ufa37', &['\u5606']),
+ ('\ufa38', &['\u5668']), ('\ufa39', &['\u5840']), ('\ufa3a', &['\u58a8']), ('\ufa3b',
+ &['\u5c64']), ('\ufa3c', &['\u5c6e']), ('\ufa3d', &['\u6094']), ('\ufa3e', &['\u6168']),
+ ('\ufa3f', &['\u618e']), ('\ufa40', &['\u61f2']), ('\ufa41', &['\u654f']), ('\ufa42',
+ &['\u65e2']), ('\ufa43', &['\u6691']), ('\ufa44', &['\u6885']), ('\ufa45', &['\u6d77']),
+ ('\ufa46', &['\u6e1a']), ('\ufa47', &['\u6f22']), ('\ufa48', &['\u716e']), ('\ufa49',
+ &['\u722b']), ('\ufa4a', &['\u7422']), ('\ufa4b', &['\u7891']), ('\ufa4c', &['\u793e']),
+ ('\ufa4d', &['\u7949']), ('\ufa4e', &['\u7948']), ('\ufa4f', &['\u7950']), ('\ufa50',
+ &['\u7956']), ('\ufa51', &['\u795d']), ('\ufa52', &['\u798d']), ('\ufa53', &['\u798e']),
+ ('\ufa54', &['\u7a40']), ('\ufa55', &['\u7a81']), ('\ufa56', &['\u7bc0']), ('\ufa57',
+ &['\u7df4']), ('\ufa58', &['\u7e09']), ('\ufa59', &['\u7e41']), ('\ufa5a', &['\u7f72']),
+ ('\ufa5b', &['\u8005']), ('\ufa5c', &['\u81ed']), ('\ufa5d', &['\u8279']), ('\ufa5e',
+ &['\u8279']), ('\ufa5f', &['\u8457']), ('\ufa60', &['\u8910']), ('\ufa61', &['\u8996']),
+ ('\ufa62', &['\u8b01']), ('\ufa63', &['\u8b39']), ('\ufa64', &['\u8cd3']), ('\ufa65',
+ &['\u8d08']), ('\ufa66', &['\u8fb6']), ('\ufa67', &['\u9038']), ('\ufa68', &['\u96e3']),
+ ('\ufa69', &['\u97ff']), ('\ufa6a', &['\u983b']), ('\ufa6b', &['\u6075']), ('\ufa6c',
+ &['\U000242ee']), ('\ufa6d', &['\u8218']), ('\ufa70', &['\u4e26']), ('\ufa71', &['\u51b5']),
+ ('\ufa72', &['\u5168']), ('\ufa73', &['\u4f80']), ('\ufa74', &['\u5145']), ('\ufa75',
+ &['\u5180']), ('\ufa76', &['\u52c7']), ('\ufa77', &['\u52fa']), ('\ufa78', &['\u559d']),
+ ('\ufa79', &['\u5555']), ('\ufa7a', &['\u5599']), ('\ufa7b', &['\u55e2']), ('\ufa7c',
+ &['\u585a']), ('\ufa7d', &['\u58b3']), ('\ufa7e', &['\u5944']), ('\ufa7f', &['\u5954']),
+ ('\ufa80', &['\u5a62']), ('\ufa81', &['\u5b28']), ('\ufa82', &['\u5ed2']), ('\ufa83',
+ &['\u5ed9']), ('\ufa84', &['\u5f69']), ('\ufa85', &['\u5fad']), ('\ufa86', &['\u60d8']),
+ ('\ufa87', &['\u614e']), ('\ufa88', &['\u6108']), ('\ufa89', &['\u618e']), ('\ufa8a',
+ &['\u6160']), ('\ufa8b', &['\u61f2']), ('\ufa8c', &['\u6234']), ('\ufa8d', &['\u63c4']),
+ ('\ufa8e', &['\u641c']), ('\ufa8f', &['\u6452']), ('\ufa90', &['\u6556']), ('\ufa91',
+ &['\u6674']), ('\ufa92', &['\u6717']), ('\ufa93', &['\u671b']), ('\ufa94', &['\u6756']),
+ ('\ufa95', &['\u6b79']), ('\ufa96', &['\u6bba']), ('\ufa97', &['\u6d41']), ('\ufa98',
+ &['\u6edb']), ('\ufa99', &['\u6ecb']), ('\ufa9a', &['\u6f22']), ('\ufa9b', &['\u701e']),
+ ('\ufa9c', &['\u716e']), ('\ufa9d', &['\u77a7']), ('\ufa9e', &['\u7235']), ('\ufa9f',
+ &['\u72af']), ('\ufaa0', &['\u732a']), ('\ufaa1', &['\u7471']), ('\ufaa2', &['\u7506']),
+ ('\ufaa3', &['\u753b']), ('\ufaa4', &['\u761d']), ('\ufaa5', &['\u761f']), ('\ufaa6',
+ &['\u76ca']), ('\ufaa7', &['\u76db']), ('\ufaa8', &['\u76f4']), ('\ufaa9', &['\u774a']),
+ ('\ufaaa', &['\u7740']), ('\ufaab', &['\u78cc']), ('\ufaac', &['\u7ab1']), ('\ufaad',
+ &['\u7bc0']), ('\ufaae', &['\u7c7b']), ('\ufaaf', &['\u7d5b']), ('\ufab0', &['\u7df4']),
+ ('\ufab1', &['\u7f3e']), ('\ufab2', &['\u8005']), ('\ufab3', &['\u8352']), ('\ufab4',
+ &['\u83ef']), ('\ufab5', &['\u8779']), ('\ufab6', &['\u8941']), ('\ufab7', &['\u8986']),
+ ('\ufab8', &['\u8996']), ('\ufab9', &['\u8abf']), ('\ufaba', &['\u8af8']), ('\ufabb',
+ &['\u8acb']), ('\ufabc', &['\u8b01']), ('\ufabd', &['\u8afe']), ('\ufabe', &['\u8aed']),
+ ('\ufabf', &['\u8b39']), ('\ufac0', &['\u8b8a']), ('\ufac1', &['\u8d08']), ('\ufac2',
+ &['\u8f38']), ('\ufac3', &['\u9072']), ('\ufac4', &['\u9199']), ('\ufac5', &['\u9276']),
+ ('\ufac6', &['\u967c']), ('\ufac7', &['\u96e3']), ('\ufac8', &['\u9756']), ('\ufac9',
+ &['\u97db']), ('\ufaca', &['\u97ff']), ('\ufacb', &['\u980b']), ('\ufacc', &['\u983b']),
+ ('\ufacd', &['\u9b12']), ('\uface', &['\u9f9c']), ('\ufacf', &['\U0002284a']), ('\ufad0',
+ &['\U00022844']), ('\ufad1', &['\U000233d5']), ('\ufad2', &['\u3b9d']), ('\ufad3',
+ &['\u4018']), ('\ufad4', &['\u4039']), ('\ufad5', &['\U00025249']), ('\ufad6',
+ &['\U00025cd0']), ('\ufad7', &['\U00027ed3']), ('\ufad8', &['\u9f43']), ('\ufad9',
+ &['\u9f8e']), ('\ufb1d', &['\u05d9', '\u05b4']), ('\ufb1f', &['\u05f2', '\u05b7']),
+ ('\ufb2a', &['\u05e9', '\u05c1']), ('\ufb2b', &['\u05e9', '\u05c2']), ('\ufb2c', &['\ufb49',
+ '\u05c1']), ('\ufb2d', &['\ufb49', '\u05c2']), ('\ufb2e', &['\u05d0', '\u05b7']), ('\ufb2f',
+ &['\u05d0', '\u05b8']), ('\ufb30', &['\u05d0', '\u05bc']), ('\ufb31', &['\u05d1',
+ '\u05bc']), ('\ufb32', &['\u05d2', '\u05bc']), ('\ufb33', &['\u05d3', '\u05bc']), ('\ufb34',
+ &['\u05d4', '\u05bc']), ('\ufb35', &['\u05d5', '\u05bc']), ('\ufb36', &['\u05d6',
+ '\u05bc']), ('\ufb38', &['\u05d8', '\u05bc']), ('\ufb39', &['\u05d9', '\u05bc']), ('\ufb3a',
+ &['\u05da', '\u05bc']), ('\ufb3b', &['\u05db', '\u05bc']), ('\ufb3c', &['\u05dc',
+ '\u05bc']), ('\ufb3e', &['\u05de', '\u05bc']), ('\ufb40', &['\u05e0', '\u05bc']), ('\ufb41',
+ &['\u05e1', '\u05bc']), ('\ufb43', &['\u05e3', '\u05bc']), ('\ufb44', &['\u05e4',
+ '\u05bc']), ('\ufb46', &['\u05e6', '\u05bc']), ('\ufb47', &['\u05e7', '\u05bc']), ('\ufb48',
+ &['\u05e8', '\u05bc']), ('\ufb49', &['\u05e9', '\u05bc']), ('\ufb4a', &['\u05ea',
+ '\u05bc']), ('\ufb4b', &['\u05d5', '\u05b9']), ('\ufb4c', &['\u05d1', '\u05bf']), ('\ufb4d',
+ &['\u05db', '\u05bf']), ('\ufb4e', &['\u05e4', '\u05bf']), ('\U0001109a', &['\U00011099',
+ '\U000110ba']), ('\U0001109c', &['\U0001109b', '\U000110ba']), ('\U000110ab',
+ &['\U000110a5', '\U000110ba']), ('\U0001112e', &['\U00011131', '\U00011127']),
+ ('\U0001112f', &['\U00011132', '\U00011127']), ('\U0001d15e', &['\U0001d157',
+ '\U0001d165']), ('\U0001d15f', &['\U0001d158', '\U0001d165']), ('\U0001d160',
+ &['\U0001d15f', '\U0001d16e']), ('\U0001d161', &['\U0001d15f', '\U0001d16f']),
+ ('\U0001d162', &['\U0001d15f', '\U0001d170']), ('\U0001d163', &['\U0001d15f',
+ '\U0001d171']), ('\U0001d164', &['\U0001d15f', '\U0001d172']), ('\U0001d1bb',
+ &['\U0001d1b9', '\U0001d165']), ('\U0001d1bc', &['\U0001d1ba', '\U0001d165']),
+ ('\U0001d1bd', &['\U0001d1bb', '\U0001d16e']), ('\U0001d1be', &['\U0001d1bc',
+ '\U0001d16e']), ('\U0001d1bf', &['\U0001d1bb', '\U0001d16f']), ('\U0001d1c0',
+ &['\U0001d1bc', '\U0001d16f']), ('\U0002f800', &['\u4e3d']), ('\U0002f801', &['\u4e38']),
+ ('\U0002f802', &['\u4e41']), ('\U0002f803', &['\U00020122']), ('\U0002f804', &['\u4f60']),
+ ('\U0002f805', &['\u4fae']), ('\U0002f806', &['\u4fbb']), ('\U0002f807', &['\u5002']),
+ ('\U0002f808', &['\u507a']), ('\U0002f809', &['\u5099']), ('\U0002f80a', &['\u50e7']),
+ ('\U0002f80b', &['\u50cf']), ('\U0002f80c', &['\u349e']), ('\U0002f80d', &['\U0002063a']),
+ ('\U0002f80e', &['\u514d']), ('\U0002f80f', &['\u5154']), ('\U0002f810', &['\u5164']),
+ ('\U0002f811', &['\u5177']), ('\U0002f812', &['\U0002051c']), ('\U0002f813', &['\u34b9']),
+ ('\U0002f814', &['\u5167']), ('\U0002f815', &['\u518d']), ('\U0002f816', &['\U0002054b']),
+ ('\U0002f817', &['\u5197']), ('\U0002f818', &['\u51a4']), ('\U0002f819', &['\u4ecc']),
+ ('\U0002f81a', &['\u51ac']), ('\U0002f81b', &['\u51b5']), ('\U0002f81c', &['\U000291df']),
+ ('\U0002f81d', &['\u51f5']), ('\U0002f81e', &['\u5203']), ('\U0002f81f', &['\u34df']),
+ ('\U0002f820', &['\u523b']), ('\U0002f821', &['\u5246']), ('\U0002f822', &['\u5272']),
+ ('\U0002f823', &['\u5277']), ('\U0002f824', &['\u3515']), ('\U0002f825', &['\u52c7']),
+ ('\U0002f826', &['\u52c9']), ('\U0002f827', &['\u52e4']), ('\U0002f828', &['\u52fa']),
+ ('\U0002f829', &['\u5305']), ('\U0002f82a', &['\u5306']), ('\U0002f82b', &['\u5317']),
+ ('\U0002f82c', &['\u5349']), ('\U0002f82d', &['\u5351']), ('\U0002f82e', &['\u535a']),
+ ('\U0002f82f', &['\u5373']), ('\U0002f830', &['\u537d']), ('\U0002f831', &['\u537f']),
+ ('\U0002f832', &['\u537f']), ('\U0002f833', &['\u537f']), ('\U0002f834', &['\U00020a2c']),
+ ('\U0002f835', &['\u7070']), ('\U0002f836', &['\u53ca']), ('\U0002f837', &['\u53df']),
+ ('\U0002f838', &['\U00020b63']), ('\U0002f839', &['\u53eb']), ('\U0002f83a', &['\u53f1']),
+ ('\U0002f83b', &['\u5406']), ('\U0002f83c', &['\u549e']), ('\U0002f83d', &['\u5438']),
+ ('\U0002f83e', &['\u5448']), ('\U0002f83f', &['\u5468']), ('\U0002f840', &['\u54a2']),
+ ('\U0002f841', &['\u54f6']), ('\U0002f842', &['\u5510']), ('\U0002f843', &['\u5553']),
+ ('\U0002f844', &['\u5563']), ('\U0002f845', &['\u5584']), ('\U0002f846', &['\u5584']),
+ ('\U0002f847', &['\u5599']), ('\U0002f848', &['\u55ab']), ('\U0002f849', &['\u55b3']),
+ ('\U0002f84a', &['\u55c2']), ('\U0002f84b', &['\u5716']), ('\U0002f84c', &['\u5606']),
+ ('\U0002f84d', &['\u5717']), ('\U0002f84e', &['\u5651']), ('\U0002f84f', &['\u5674']),
+ ('\U0002f850', &['\u5207']), ('\U0002f851', &['\u58ee']), ('\U0002f852', &['\u57ce']),
+ ('\U0002f853', &['\u57f4']), ('\U0002f854', &['\u580d']), ('\U0002f855', &['\u578b']),
+ ('\U0002f856', &['\u5832']), ('\U0002f857', &['\u5831']), ('\U0002f858', &['\u58ac']),
+ ('\U0002f859', &['\U000214e4']), ('\U0002f85a', &['\u58f2']), ('\U0002f85b', &['\u58f7']),
+ ('\U0002f85c', &['\u5906']), ('\U0002f85d', &['\u591a']), ('\U0002f85e', &['\u5922']),
+ ('\U0002f85f', &['\u5962']), ('\U0002f860', &['\U000216a8']), ('\U0002f861',
+ &['\U000216ea']), ('\U0002f862', &['\u59ec']), ('\U0002f863', &['\u5a1b']), ('\U0002f864',
+ &['\u5a27']), ('\U0002f865', &['\u59d8']), ('\U0002f866', &['\u5a66']), ('\U0002f867',
+ &['\u36ee']), ('\U0002f868', &['\u36fc']), ('\U0002f869', &['\u5b08']), ('\U0002f86a',
+ &['\u5b3e']), ('\U0002f86b', &['\u5b3e']), ('\U0002f86c', &['\U000219c8']), ('\U0002f86d',
+ &['\u5bc3']), ('\U0002f86e', &['\u5bd8']), ('\U0002f86f', &['\u5be7']), ('\U0002f870',
+ &['\u5bf3']), ('\U0002f871', &['\U00021b18']), ('\U0002f872', &['\u5bff']), ('\U0002f873',
+ &['\u5c06']), ('\U0002f874', &['\u5f53']), ('\U0002f875', &['\u5c22']), ('\U0002f876',
+ &['\u3781']), ('\U0002f877', &['\u5c60']), ('\U0002f878', &['\u5c6e']), ('\U0002f879',
+ &['\u5cc0']), ('\U0002f87a', &['\u5c8d']), ('\U0002f87b', &['\U00021de4']), ('\U0002f87c',
+ &['\u5d43']), ('\U0002f87d', &['\U00021de6']), ('\U0002f87e', &['\u5d6e']), ('\U0002f87f',
+ &['\u5d6b']), ('\U0002f880', &['\u5d7c']), ('\U0002f881', &['\u5de1']), ('\U0002f882',
+ &['\u5de2']), ('\U0002f883', &['\u382f']), ('\U0002f884', &['\u5dfd']), ('\U0002f885',
+ &['\u5e28']), ('\U0002f886', &['\u5e3d']), ('\U0002f887', &['\u5e69']), ('\U0002f888',
+ &['\u3862']), ('\U0002f889', &['\U00022183']), ('\U0002f88a', &['\u387c']), ('\U0002f88b',
+ &['\u5eb0']), ('\U0002f88c', &['\u5eb3']), ('\U0002f88d', &['\u5eb6']), ('\U0002f88e',
+ &['\u5eca']), ('\U0002f88f', &['\U0002a392']), ('\U0002f890', &['\u5efe']), ('\U0002f891',
+ &['\U00022331']), ('\U0002f892', &['\U00022331']), ('\U0002f893', &['\u8201']),
+ ('\U0002f894', &['\u5f22']), ('\U0002f895', &['\u5f22']), ('\U0002f896', &['\u38c7']),
+ ('\U0002f897', &['\U000232b8']), ('\U0002f898', &['\U000261da']), ('\U0002f899',
+ &['\u5f62']), ('\U0002f89a', &['\u5f6b']), ('\U0002f89b', &['\u38e3']), ('\U0002f89c',
+ &['\u5f9a']), ('\U0002f89d', &['\u5fcd']), ('\U0002f89e', &['\u5fd7']), ('\U0002f89f',
+ &['\u5ff9']), ('\U0002f8a0', &['\u6081']), ('\U0002f8a1', &['\u393a']), ('\U0002f8a2',
+ &['\u391c']), ('\U0002f8a3', &['\u6094']), ('\U0002f8a4', &['\U000226d4']), ('\U0002f8a5',
+ &['\u60c7']), ('\U0002f8a6', &['\u6148']), ('\U0002f8a7', &['\u614c']), ('\U0002f8a8',
+ &['\u614e']), ('\U0002f8a9', &['\u614c']), ('\U0002f8aa', &['\u617a']), ('\U0002f8ab',
+ &['\u618e']), ('\U0002f8ac', &['\u61b2']), ('\U0002f8ad', &['\u61a4']), ('\U0002f8ae',
+ &['\u61af']), ('\U0002f8af', &['\u61de']), ('\U0002f8b0', &['\u61f2']), ('\U0002f8b1',
+ &['\u61f6']), ('\U0002f8b2', &['\u6210']), ('\U0002f8b3', &['\u621b']), ('\U0002f8b4',
+ &['\u625d']), ('\U0002f8b5', &['\u62b1']), ('\U0002f8b6', &['\u62d4']), ('\U0002f8b7',
+ &['\u6350']), ('\U0002f8b8', &['\U00022b0c']), ('\U0002f8b9', &['\u633d']), ('\U0002f8ba',
+ &['\u62fc']), ('\U0002f8bb', &['\u6368']), ('\U0002f8bc', &['\u6383']), ('\U0002f8bd',
+ &['\u63e4']), ('\U0002f8be', &['\U00022bf1']), ('\U0002f8bf', &['\u6422']), ('\U0002f8c0',
+ &['\u63c5']), ('\U0002f8c1', &['\u63a9']), ('\U0002f8c2', &['\u3a2e']), ('\U0002f8c3',
+ &['\u6469']), ('\U0002f8c4', &['\u647e']), ('\U0002f8c5', &['\u649d']), ('\U0002f8c6',
+ &['\u6477']), ('\U0002f8c7', &['\u3a6c']), ('\U0002f8c8', &['\u654f']), ('\U0002f8c9',
+ &['\u656c']), ('\U0002f8ca', &['\U0002300a']), ('\U0002f8cb', &['\u65e3']), ('\U0002f8cc',
+ &['\u66f8']), ('\U0002f8cd', &['\u6649']), ('\U0002f8ce', &['\u3b19']), ('\U0002f8cf',
+ &['\u6691']), ('\U0002f8d0', &['\u3b08']), ('\U0002f8d1', &['\u3ae4']), ('\U0002f8d2',
+ &['\u5192']), ('\U0002f8d3', &['\u5195']), ('\U0002f8d4', &['\u6700']), ('\U0002f8d5',
+ &['\u669c']), ('\U0002f8d6', &['\u80ad']), ('\U0002f8d7', &['\u43d9']), ('\U0002f8d8',
+ &['\u6717']), ('\U0002f8d9', &['\u671b']), ('\U0002f8da', &['\u6721']), ('\U0002f8db',
+ &['\u675e']), ('\U0002f8dc', &['\u6753']), ('\U0002f8dd', &['\U000233c3']), ('\U0002f8de',
+ &['\u3b49']), ('\U0002f8df', &['\u67fa']), ('\U0002f8e0', &['\u6785']), ('\U0002f8e1',
+ &['\u6852']), ('\U0002f8e2', &['\u6885']), ('\U0002f8e3', &['\U0002346d']), ('\U0002f8e4',
+ &['\u688e']), ('\U0002f8e5', &['\u681f']), ('\U0002f8e6', &['\u6914']), ('\U0002f8e7',
+ &['\u3b9d']), ('\U0002f8e8', &['\u6942']), ('\U0002f8e9', &['\u69a3']), ('\U0002f8ea',
+ &['\u69ea']), ('\U0002f8eb', &['\u6aa8']), ('\U0002f8ec', &['\U000236a3']), ('\U0002f8ed',
+ &['\u6adb']), ('\U0002f8ee', &['\u3c18']), ('\U0002f8ef', &['\u6b21']), ('\U0002f8f0',
+ &['\U000238a7']), ('\U0002f8f1', &['\u6b54']), ('\U0002f8f2', &['\u3c4e']), ('\U0002f8f3',
+ &['\u6b72']), ('\U0002f8f4', &['\u6b9f']), ('\U0002f8f5', &['\u6bba']), ('\U0002f8f6',
+ &['\u6bbb']), ('\U0002f8f7', &['\U00023a8d']), ('\U0002f8f8', &['\U00021d0b']),
+ ('\U0002f8f9', &['\U00023afa']), ('\U0002f8fa', &['\u6c4e']), ('\U0002f8fb',
+ &['\U00023cbc']), ('\U0002f8fc', &['\u6cbf']), ('\U0002f8fd', &['\u6ccd']), ('\U0002f8fe',
+ &['\u6c67']), ('\U0002f8ff', &['\u6d16']), ('\U0002f900', &['\u6d3e']), ('\U0002f901',
+ &['\u6d77']), ('\U0002f902', &['\u6d41']), ('\U0002f903', &['\u6d69']), ('\U0002f904',
+ &['\u6d78']), ('\U0002f905', &['\u6d85']), ('\U0002f906', &['\U00023d1e']), ('\U0002f907',
+ &['\u6d34']), ('\U0002f908', &['\u6e2f']), ('\U0002f909', &['\u6e6e']), ('\U0002f90a',
+ &['\u3d33']), ('\U0002f90b', &['\u6ecb']), ('\U0002f90c', &['\u6ec7']), ('\U0002f90d',
+ &['\U00023ed1']), ('\U0002f90e', &['\u6df9']), ('\U0002f90f', &['\u6f6e']), ('\U0002f910',
+ &['\U00023f5e']), ('\U0002f911', &['\U00023f8e']), ('\U0002f912', &['\u6fc6']),
+ ('\U0002f913', &['\u7039']), ('\U0002f914', &['\u701e']), ('\U0002f915', &['\u701b']),
+ ('\U0002f916', &['\u3d96']), ('\U0002f917', &['\u704a']), ('\U0002f918', &['\u707d']),
+ ('\U0002f919', &['\u7077']), ('\U0002f91a', &['\u70ad']), ('\U0002f91b', &['\U00020525']),
+ ('\U0002f91c', &['\u7145']), ('\U0002f91d', &['\U00024263']), ('\U0002f91e', &['\u719c']),
+ ('\U0002f91f', &['\U000243ab']), ('\U0002f920', &['\u7228']), ('\U0002f921', &['\u7235']),
+ ('\U0002f922', &['\u7250']), ('\U0002f923', &['\U00024608']), ('\U0002f924', &['\u7280']),
+ ('\U0002f925', &['\u7295']), ('\U0002f926', &['\U00024735']), ('\U0002f927',
+ &['\U00024814']), ('\U0002f928', &['\u737a']), ('\U0002f929', &['\u738b']), ('\U0002f92a',
+ &['\u3eac']), ('\U0002f92b', &['\u73a5']), ('\U0002f92c', &['\u3eb8']), ('\U0002f92d',
+ &['\u3eb8']), ('\U0002f92e', &['\u7447']), ('\U0002f92f', &['\u745c']), ('\U0002f930',
+ &['\u7471']), ('\U0002f931', &['\u7485']), ('\U0002f932', &['\u74ca']), ('\U0002f933',
+ &['\u3f1b']), ('\U0002f934', &['\u7524']), ('\U0002f935', &['\U00024c36']), ('\U0002f936',
+ &['\u753e']), ('\U0002f937', &['\U00024c92']), ('\U0002f938', &['\u7570']), ('\U0002f939',
+ &['\U0002219f']), ('\U0002f93a', &['\u7610']), ('\U0002f93b', &['\U00024fa1']),
+ ('\U0002f93c', &['\U00024fb8']), ('\U0002f93d', &['\U00025044']), ('\U0002f93e',
+ &['\u3ffc']), ('\U0002f93f', &['\u4008']), ('\U0002f940', &['\u76f4']), ('\U0002f941',
+ &['\U000250f3']), ('\U0002f942', &['\U000250f2']), ('\U0002f943', &['\U00025119']),
+ ('\U0002f944', &['\U00025133']), ('\U0002f945', &['\u771e']), ('\U0002f946', &['\u771f']),
+ ('\U0002f947', &['\u771f']), ('\U0002f948', &['\u774a']), ('\U0002f949', &['\u4039']),
+ ('\U0002f94a', &['\u778b']), ('\U0002f94b', &['\u4046']), ('\U0002f94c', &['\u4096']),
+ ('\U0002f94d', &['\U0002541d']), ('\U0002f94e', &['\u784e']), ('\U0002f94f', &['\u788c']),
+ ('\U0002f950', &['\u78cc']), ('\U0002f951', &['\u40e3']), ('\U0002f952', &['\U00025626']),
+ ('\U0002f953', &['\u7956']), ('\U0002f954', &['\U0002569a']), ('\U0002f955',
+ &['\U000256c5']), ('\U0002f956', &['\u798f']), ('\U0002f957', &['\u79eb']), ('\U0002f958',
+ &['\u412f']), ('\U0002f959', &['\u7a40']), ('\U0002f95a', &['\u7a4a']), ('\U0002f95b',
+ &['\u7a4f']), ('\U0002f95c', &['\U0002597c']), ('\U0002f95d', &['\U00025aa7']),
+ ('\U0002f95e', &['\U00025aa7']), ('\U0002f95f', &['\u7aee']), ('\U0002f960', &['\u4202']),
+ ('\U0002f961', &['\U00025bab']), ('\U0002f962', &['\u7bc6']), ('\U0002f963', &['\u7bc9']),
+ ('\U0002f964', &['\u4227']), ('\U0002f965', &['\U00025c80']), ('\U0002f966', &['\u7cd2']),
+ ('\U0002f967', &['\u42a0']), ('\U0002f968', &['\u7ce8']), ('\U0002f969', &['\u7ce3']),
+ ('\U0002f96a', &['\u7d00']), ('\U0002f96b', &['\U00025f86']), ('\U0002f96c', &['\u7d63']),
+ ('\U0002f96d', &['\u4301']), ('\U0002f96e', &['\u7dc7']), ('\U0002f96f', &['\u7e02']),
+ ('\U0002f970', &['\u7e45']), ('\U0002f971', &['\u4334']), ('\U0002f972', &['\U00026228']),
+ ('\U0002f973', &['\U00026247']), ('\U0002f974', &['\u4359']), ('\U0002f975',
+ &['\U000262d9']), ('\U0002f976', &['\u7f7a']), ('\U0002f977', &['\U0002633e']),
+ ('\U0002f978', &['\u7f95']), ('\U0002f979', &['\u7ffa']), ('\U0002f97a', &['\u8005']),
+ ('\U0002f97b', &['\U000264da']), ('\U0002f97c', &['\U00026523']), ('\U0002f97d',
+ &['\u8060']), ('\U0002f97e', &['\U000265a8']), ('\U0002f97f', &['\u8070']), ('\U0002f980',
+ &['\U0002335f']), ('\U0002f981', &['\u43d5']), ('\U0002f982', &['\u80b2']), ('\U0002f983',
+ &['\u8103']), ('\U0002f984', &['\u440b']), ('\U0002f985', &['\u813e']), ('\U0002f986',
+ &['\u5ab5']), ('\U0002f987', &['\U000267a7']), ('\U0002f988', &['\U000267b5']),
+ ('\U0002f989', &['\U00023393']), ('\U0002f98a', &['\U0002339c']), ('\U0002f98b',
+ &['\u8201']), ('\U0002f98c', &['\u8204']), ('\U0002f98d', &['\u8f9e']), ('\U0002f98e',
+ &['\u446b']), ('\U0002f98f', &['\u8291']), ('\U0002f990', &['\u828b']), ('\U0002f991',
+ &['\u829d']), ('\U0002f992', &['\u52b3']), ('\U0002f993', &['\u82b1']), ('\U0002f994',
+ &['\u82b3']), ('\U0002f995', &['\u82bd']), ('\U0002f996', &['\u82e6']), ('\U0002f997',
+ &['\U00026b3c']), ('\U0002f998', &['\u82e5']), ('\U0002f999', &['\u831d']), ('\U0002f99a',
+ &['\u8363']), ('\U0002f99b', &['\u83ad']), ('\U0002f99c', &['\u8323']), ('\U0002f99d',
+ &['\u83bd']), ('\U0002f99e', &['\u83e7']), ('\U0002f99f', &['\u8457']), ('\U0002f9a0',
+ &['\u8353']), ('\U0002f9a1', &['\u83ca']), ('\U0002f9a2', &['\u83cc']), ('\U0002f9a3',
+ &['\u83dc']), ('\U0002f9a4', &['\U00026c36']), ('\U0002f9a5', &['\U00026d6b']),
+ ('\U0002f9a6', &['\U00026cd5']), ('\U0002f9a7', &['\u452b']), ('\U0002f9a8', &['\u84f1']),
+ ('\U0002f9a9', &['\u84f3']), ('\U0002f9aa', &['\u8516']), ('\U0002f9ab', &['\U000273ca']),
+ ('\U0002f9ac', &['\u8564']), ('\U0002f9ad', &['\U00026f2c']), ('\U0002f9ae', &['\u455d']),
+ ('\U0002f9af', &['\u4561']), ('\U0002f9b0', &['\U00026fb1']), ('\U0002f9b1',
+ &['\U000270d2']), ('\U0002f9b2', &['\u456b']), ('\U0002f9b3', &['\u8650']), ('\U0002f9b4',
+ &['\u865c']), ('\U0002f9b5', &['\u8667']), ('\U0002f9b6', &['\u8669']), ('\U0002f9b7',
+ &['\u86a9']), ('\U0002f9b8', &['\u8688']), ('\U0002f9b9', &['\u870e']), ('\U0002f9ba',
+ &['\u86e2']), ('\U0002f9bb', &['\u8779']), ('\U0002f9bc', &['\u8728']), ('\U0002f9bd',
+ &['\u876b']), ('\U0002f9be', &['\u8786']), ('\U0002f9bf', &['\u45d7']), ('\U0002f9c0',
+ &['\u87e1']), ('\U0002f9c1', &['\u8801']), ('\U0002f9c2', &['\u45f9']), ('\U0002f9c3',
+ &['\u8860']), ('\U0002f9c4', &['\u8863']), ('\U0002f9c5', &['\U00027667']), ('\U0002f9c6',
+ &['\u88d7']), ('\U0002f9c7', &['\u88de']), ('\U0002f9c8', &['\u4635']), ('\U0002f9c9',
+ &['\u88fa']), ('\U0002f9ca', &['\u34bb']), ('\U0002f9cb', &['\U000278ae']), ('\U0002f9cc',
+ &['\U00027966']), ('\U0002f9cd', &['\u46be']), ('\U0002f9ce', &['\u46c7']), ('\U0002f9cf',
+ &['\u8aa0']), ('\U0002f9d0', &['\u8aed']), ('\U0002f9d1', &['\u8b8a']), ('\U0002f9d2',
+ &['\u8c55']), ('\U0002f9d3', &['\U00027ca8']), ('\U0002f9d4', &['\u8cab']), ('\U0002f9d5',
+ &['\u8cc1']), ('\U0002f9d6', &['\u8d1b']), ('\U0002f9d7', &['\u8d77']), ('\U0002f9d8',
+ &['\U00027f2f']), ('\U0002f9d9', &['\U00020804']), ('\U0002f9da', &['\u8dcb']),
+ ('\U0002f9db', &['\u8dbc']), ('\U0002f9dc', &['\u8df0']), ('\U0002f9dd', &['\U000208de']),
+ ('\U0002f9de', &['\u8ed4']), ('\U0002f9df', &['\u8f38']), ('\U0002f9e0', &['\U000285d2']),
+ ('\U0002f9e1', &['\U000285ed']), ('\U0002f9e2', &['\u9094']), ('\U0002f9e3', &['\u90f1']),
+ ('\U0002f9e4', &['\u9111']), ('\U0002f9e5', &['\U0002872e']), ('\U0002f9e6', &['\u911b']),
+ ('\U0002f9e7', &['\u9238']), ('\U0002f9e8', &['\u92d7']), ('\U0002f9e9', &['\u92d8']),
+ ('\U0002f9ea', &['\u927c']), ('\U0002f9eb', &['\u93f9']), ('\U0002f9ec', &['\u9415']),
+ ('\U0002f9ed', &['\U00028bfa']), ('\U0002f9ee', &['\u958b']), ('\U0002f9ef', &['\u4995']),
+ ('\U0002f9f0', &['\u95b7']), ('\U0002f9f1', &['\U00028d77']), ('\U0002f9f2', &['\u49e6']),
+ ('\U0002f9f3', &['\u96c3']), ('\U0002f9f4', &['\u5db2']), ('\U0002f9f5', &['\u9723']),
+ ('\U0002f9f6', &['\U00029145']), ('\U0002f9f7', &['\U0002921a']), ('\U0002f9f8',
+ &['\u4a6e']), ('\U0002f9f9', &['\u4a76']), ('\U0002f9fa', &['\u97e0']), ('\U0002f9fb',
+ &['\U0002940a']), ('\U0002f9fc', &['\u4ab2']), ('\U0002f9fd', &['\U00029496']),
+ ('\U0002f9fe', &['\u980b']), ('\U0002f9ff', &['\u980b']), ('\U0002fa00', &['\u9829']),
+ ('\U0002fa01', &['\U000295b6']), ('\U0002fa02', &['\u98e2']), ('\U0002fa03', &['\u4b33']),
+ ('\U0002fa04', &['\u9929']), ('\U0002fa05', &['\u99a7']), ('\U0002fa06', &['\u99c2']),
+ ('\U0002fa07', &['\u99fe']), ('\U0002fa08', &['\u4bce']), ('\U0002fa09', &['\U00029b30']),
+ ('\U0002fa0a', &['\u9b12']), ('\U0002fa0b', &['\u9c40']), ('\U0002fa0c', &['\u9cfd']),
+ ('\U0002fa0d', &['\u4cce']), ('\U0002fa0e', &['\u4ced']), ('\U0002fa0f', &['\u9d67']),
+ ('\U0002fa10', &['\U0002a0ce']), ('\U0002fa11', &['\u4cf8']), ('\U0002fa12',
+ &['\U0002a105']), ('\U0002fa13', &['\U0002a20e']), ('\U0002fa14', &['\U0002a291']),
+ ('\U0002fa15', &['\u9ebb']), ('\U0002fa16', &['\u4d56']), ('\U0002fa17', &['\u9ef9']),
+ ('\U0002fa18', &['\u9efe']), ('\U0002fa19', &['\u9f05']), ('\U0002fa1a', &['\u9f0f']),
+ ('\U0002fa1b', &['\u9f16']), ('\U0002fa1c', &['\u9f3b']), ('\U0002fa1d', &['\U0002a600'])
+ ];
+
+ // Compatibility decompositions
+ static compatibility_table : &'static [(char, &'static [char])] = &[
+ ('\xa0', &['\x20']), ('\xa8', &['\x20', '\u0308']), ('\xaa', &['\x61']), ('\xaf', &['\x20',
+ '\u0304']), ('\xb2', &['\x32']), ('\xb3', &['\x33']), ('\xb4', &['\x20', '\u0301']),
+ ('\xb5', &['\u03bc']), ('\xb8', &['\x20', '\u0327']), ('\xb9', &['\x31']), ('\xba',
+ &['\x6f']), ('\xbc', &['\x31', '\u2044', '\x34']), ('\xbd', &['\x31', '\u2044', '\x32']),
+ ('\xbe', &['\x33', '\u2044', '\x34']), ('\u0132', &['\x49', '\x4a']), ('\u0133', &['\x69',
+ '\x6a']), ('\u013f', &['\x4c', '\xb7']), ('\u0140', &['\x6c', '\xb7']), ('\u0149',
+ &['\u02bc', '\x6e']), ('\u017f', &['\x73']), ('\u01c4', &['\x44', '\u017d']), ('\u01c5',
+ &['\x44', '\u017e']), ('\u01c6', &['\x64', '\u017e']), ('\u01c7', &['\x4c', '\x4a']),
+ ('\u01c8', &['\x4c', '\x6a']), ('\u01c9', &['\x6c', '\x6a']), ('\u01ca', &['\x4e', '\x4a']),
+ ('\u01cb', &['\x4e', '\x6a']), ('\u01cc', &['\x6e', '\x6a']), ('\u01f1', &['\x44', '\x5a']),
+ ('\u01f2', &['\x44', '\x7a']), ('\u01f3', &['\x64', '\x7a']), ('\u02b0', &['\x68']),
+ ('\u02b1', &['\u0266']), ('\u02b2', &['\x6a']), ('\u02b3', &['\x72']), ('\u02b4',
+ &['\u0279']), ('\u02b5', &['\u027b']), ('\u02b6', &['\u0281']), ('\u02b7', &['\x77']),
+ ('\u02b8', &['\x79']), ('\u02d8', &['\x20', '\u0306']), ('\u02d9', &['\x20', '\u0307']),
+ ('\u02da', &['\x20', '\u030a']), ('\u02db', &['\x20', '\u0328']), ('\u02dc', &['\x20',
+ '\u0303']), ('\u02dd', &['\x20', '\u030b']), ('\u02e0', &['\u0263']), ('\u02e1', &['\x6c']),
+ ('\u02e2', &['\x73']), ('\u02e3', &['\x78']), ('\u02e4', &['\u0295']), ('\u037a', &['\x20',
+ '\u0345']), ('\u0384', &['\x20', '\u0301']), ('\u03d0', &['\u03b2']), ('\u03d1',
+ &['\u03b8']), ('\u03d2', &['\u03a5']), ('\u03d5', &['\u03c6']), ('\u03d6', &['\u03c0']),
+ ('\u03f0', &['\u03ba']), ('\u03f1', &['\u03c1']), ('\u03f2', &['\u03c2']), ('\u03f4',
+ &['\u0398']), ('\u03f5', &['\u03b5']), ('\u03f9', &['\u03a3']), ('\u0587', &['\u0565',
+ '\u0582']), ('\u0675', &['\u0627', '\u0674']), ('\u0676', &['\u0648', '\u0674']), ('\u0677',
+ &['\u06c7', '\u0674']), ('\u0678', &['\u064a', '\u0674']), ('\u0e33', &['\u0e4d',
+ '\u0e32']), ('\u0eb3', &['\u0ecd', '\u0eb2']), ('\u0edc', &['\u0eab', '\u0e99']), ('\u0edd',
+ &['\u0eab', '\u0ea1']), ('\u0f0c', &['\u0f0b']), ('\u0f77', &['\u0fb2', '\u0f81']),
+ ('\u0f79', &['\u0fb3', '\u0f81']), ('\u10fc', &['\u10dc']), ('\u1d2c', &['\x41']),
+ ('\u1d2d', &['\xc6']), ('\u1d2e', &['\x42']), ('\u1d30', &['\x44']), ('\u1d31', &['\x45']),
+ ('\u1d32', &['\u018e']), ('\u1d33', &['\x47']), ('\u1d34', &['\x48']), ('\u1d35',
+ &['\x49']), ('\u1d36', &['\x4a']), ('\u1d37', &['\x4b']), ('\u1d38', &['\x4c']), ('\u1d39',
+ &['\x4d']), ('\u1d3a', &['\x4e']), ('\u1d3c', &['\x4f']), ('\u1d3d', &['\u0222']),
+ ('\u1d3e', &['\x50']), ('\u1d3f', &['\x52']), ('\u1d40', &['\x54']), ('\u1d41', &['\x55']),
+ ('\u1d42', &['\x57']), ('\u1d43', &['\x61']), ('\u1d44', &['\u0250']), ('\u1d45',
+ &['\u0251']), ('\u1d46', &['\u1d02']), ('\u1d47', &['\x62']), ('\u1d48', &['\x64']),
+ ('\u1d49', &['\x65']), ('\u1d4a', &['\u0259']), ('\u1d4b', &['\u025b']), ('\u1d4c',
+ &['\u025c']), ('\u1d4d', &['\x67']), ('\u1d4f', &['\x6b']), ('\u1d50', &['\x6d']),
+ ('\u1d51', &['\u014b']), ('\u1d52', &['\x6f']), ('\u1d53', &['\u0254']), ('\u1d54',
+ &['\u1d16']), ('\u1d55', &['\u1d17']), ('\u1d56', &['\x70']), ('\u1d57', &['\x74']),
+ ('\u1d58', &['\x75']), ('\u1d59', &['\u1d1d']), ('\u1d5a', &['\u026f']), ('\u1d5b',
+ &['\x76']), ('\u1d5c', &['\u1d25']), ('\u1d5d', &['\u03b2']), ('\u1d5e', &['\u03b3']),
+ ('\u1d5f', &['\u03b4']), ('\u1d60', &['\u03c6']), ('\u1d61', &['\u03c7']), ('\u1d62',
+ &['\x69']), ('\u1d63', &['\x72']), ('\u1d64', &['\x75']), ('\u1d65', &['\x76']), ('\u1d66',
+ &['\u03b2']), ('\u1d67', &['\u03b3']), ('\u1d68', &['\u03c1']), ('\u1d69', &['\u03c6']),
+ ('\u1d6a', &['\u03c7']), ('\u1d78', &['\u043d']), ('\u1d9b', &['\u0252']), ('\u1d9c',
+ &['\x63']), ('\u1d9d', &['\u0255']), ('\u1d9e', &['\xf0']), ('\u1d9f', &['\u025c']),
+ ('\u1da0', &['\x66']), ('\u1da1', &['\u025f']), ('\u1da2', &['\u0261']), ('\u1da3',
+ &['\u0265']), ('\u1da4', &['\u0268']), ('\u1da5', &['\u0269']), ('\u1da6', &['\u026a']),
+ ('\u1da7', &['\u1d7b']), ('\u1da8', &['\u029d']), ('\u1da9', &['\u026d']), ('\u1daa',
+ &['\u1d85']), ('\u1dab', &['\u029f']), ('\u1dac', &['\u0271']), ('\u1dad', &['\u0270']),
+ ('\u1dae', &['\u0272']), ('\u1daf', &['\u0273']), ('\u1db0', &['\u0274']), ('\u1db1',
+ &['\u0275']), ('\u1db2', &['\u0278']), ('\u1db3', &['\u0282']), ('\u1db4', &['\u0283']),
+ ('\u1db5', &['\u01ab']), ('\u1db6', &['\u0289']), ('\u1db7', &['\u028a']), ('\u1db8',
+ &['\u1d1c']), ('\u1db9', &['\u028b']), ('\u1dba', &['\u028c']), ('\u1dbb', &['\x7a']),
+ ('\u1dbc', &['\u0290']), ('\u1dbd', &['\u0291']), ('\u1dbe', &['\u0292']), ('\u1dbf',
+ &['\u03b8']), ('\u1e9a', &['\x61', '\u02be']), ('\u1fbd', &['\x20', '\u0313']), ('\u1fbf',
+ &['\x20', '\u0313']), ('\u1fc0', &['\x20', '\u0342']), ('\u1ffe', &['\x20', '\u0314']),
+ ('\u2002', &['\x20']), ('\u2003', &['\x20']), ('\u2004', &['\x20']), ('\u2005', &['\x20']),
+ ('\u2006', &['\x20']), ('\u2007', &['\x20']), ('\u2008', &['\x20']), ('\u2009', &['\x20']),
+ ('\u200a', &['\x20']), ('\u2011', &['\u2010']), ('\u2017', &['\x20', '\u0333']), ('\u2024',
+ &['\x2e']), ('\u2025', &['\x2e', '\x2e']), ('\u2026', &['\x2e', '\x2e', '\x2e']), ('\u202f',
+ &['\x20']), ('\u2033', &['\u2032', '\u2032']), ('\u2034', &['\u2032', '\u2032', '\u2032']),
+ ('\u2036', &['\u2035', '\u2035']), ('\u2037', &['\u2035', '\u2035', '\u2035']), ('\u203c',
+ &['\x21', '\x21']), ('\u203e', &['\x20', '\u0305']), ('\u2047', &['\x3f', '\x3f']),
+ ('\u2048', &['\x3f', '\x21']), ('\u2049', &['\x21', '\x3f']), ('\u2057', &['\u2032',
+ '\u2032', '\u2032', '\u2032']), ('\u205f', &['\x20']), ('\u2070', &['\x30']), ('\u2071',
+ &['\x69']), ('\u2074', &['\x34']), ('\u2075', &['\x35']), ('\u2076', &['\x36']), ('\u2077',
+ &['\x37']), ('\u2078', &['\x38']), ('\u2079', &['\x39']), ('\u207a', &['\x2b']), ('\u207b',
+ &['\u2212']), ('\u207c', &['\x3d']), ('\u207d', &['\x28']), ('\u207e', &['\x29']),
+ ('\u207f', &['\x6e']), ('\u2080', &['\x30']), ('\u2081', &['\x31']), ('\u2082', &['\x32']),
+ ('\u2083', &['\x33']), ('\u2084', &['\x34']), ('\u2085', &['\x35']), ('\u2086', &['\x36']),
+ ('\u2087', &['\x37']), ('\u2088', &['\x38']), ('\u2089', &['\x39']), ('\u208a', &['\x2b']),
+ ('\u208b', &['\u2212']), ('\u208c', &['\x3d']), ('\u208d', &['\x28']), ('\u208e',
+ &['\x29']), ('\u2090', &['\x61']), ('\u2091', &['\x65']), ('\u2092', &['\x6f']), ('\u2093',
+ &['\x78']), ('\u2094', &['\u0259']), ('\u2095', &['\x68']), ('\u2096', &['\x6b']),
+ ('\u2097', &['\x6c']), ('\u2098', &['\x6d']), ('\u2099', &['\x6e']), ('\u209a', &['\x70']),
+ ('\u209b', &['\x73']), ('\u209c', &['\x74']), ('\u20a8', &['\x52', '\x73']), ('\u2100',
+ &['\x61', '\x2f', '\x63']), ('\u2101', &['\x61', '\x2f', '\x73']), ('\u2102', &['\x43']),
+ ('\u2103', &['\xb0', '\x43']), ('\u2105', &['\x63', '\x2f', '\x6f']), ('\u2106', &['\x63',
+ '\x2f', '\x75']), ('\u2107', &['\u0190']), ('\u2109', &['\xb0', '\x46']), ('\u210a',
+ &['\x67']), ('\u210b', &['\x48']), ('\u210c', &['\x48']), ('\u210d', &['\x48']), ('\u210e',
+ &['\x68']), ('\u210f', &['\u0127']), ('\u2110', &['\x49']), ('\u2111', &['\x49']),
+ ('\u2112', &['\x4c']), ('\u2113', &['\x6c']), ('\u2115', &['\x4e']), ('\u2116', &['\x4e',
+ '\x6f']), ('\u2119', &['\x50']), ('\u211a', &['\x51']), ('\u211b', &['\x52']), ('\u211c',
+ &['\x52']), ('\u211d', &['\x52']), ('\u2120', &['\x53', '\x4d']), ('\u2121', &['\x54',
+ '\x45', '\x4c']), ('\u2122', &['\x54', '\x4d']), ('\u2124', &['\x5a']), ('\u2128',
+ &['\x5a']), ('\u212c', &['\x42']), ('\u212d', &['\x43']), ('\u212f', &['\x65']), ('\u2130',
+ &['\x45']), ('\u2131', &['\x46']), ('\u2133', &['\x4d']), ('\u2134', &['\x6f']), ('\u2135',
+ &['\u05d0']), ('\u2136', &['\u05d1']), ('\u2137', &['\u05d2']), ('\u2138', &['\u05d3']),
+ ('\u2139', &['\x69']), ('\u213b', &['\x46', '\x41', '\x58']), ('\u213c', &['\u03c0']),
+ ('\u213d', &['\u03b3']), ('\u213e', &['\u0393']), ('\u213f', &['\u03a0']), ('\u2140',
+ &['\u2211']), ('\u2145', &['\x44']), ('\u2146', &['\x64']), ('\u2147', &['\x65']),
+ ('\u2148', &['\x69']), ('\u2149', &['\x6a']), ('\u2150', &['\x31', '\u2044', '\x37']),
+ ('\u2151', &['\x31', '\u2044', '\x39']), ('\u2152', &['\x31', '\u2044', '\x31', '\x30']),
+ ('\u2153', &['\x31', '\u2044', '\x33']), ('\u2154', &['\x32', '\u2044', '\x33']), ('\u2155',
+ &['\x31', '\u2044', '\x35']), ('\u2156', &['\x32', '\u2044', '\x35']), ('\u2157', &['\x33',
+ '\u2044', '\x35']), ('\u2158', &['\x34', '\u2044', '\x35']), ('\u2159', &['\x31', '\u2044',
+ '\x36']), ('\u215a', &['\x35', '\u2044', '\x36']), ('\u215b', &['\x31', '\u2044', '\x38']),
+ ('\u215c', &['\x33', '\u2044', '\x38']), ('\u215d', &['\x35', '\u2044', '\x38']), ('\u215e',
+ &['\x37', '\u2044', '\x38']), ('\u215f', &['\x31', '\u2044']), ('\u2160', &['\x49']),
+ ('\u2161', &['\x49', '\x49']), ('\u2162', &['\x49', '\x49', '\x49']), ('\u2163', &['\x49',
+ '\x56']), ('\u2164', &['\x56']), ('\u2165', &['\x56', '\x49']), ('\u2166', &['\x56', '\x49',
+ '\x49']), ('\u2167', &['\x56', '\x49', '\x49', '\x49']), ('\u2168', &['\x49', '\x58']),
+ ('\u2169', &['\x58']), ('\u216a', &['\x58', '\x49']), ('\u216b', &['\x58', '\x49', '\x49']),
+ ('\u216c', &['\x4c']), ('\u216d', &['\x43']), ('\u216e', &['\x44']), ('\u216f', &['\x4d']),
+ ('\u2170', &['\x69']), ('\u2171', &['\x69', '\x69']), ('\u2172', &['\x69', '\x69', '\x69']),
+ ('\u2173', &['\x69', '\x76']), ('\u2174', &['\x76']), ('\u2175', &['\x76', '\x69']),
+ ('\u2176', &['\x76', '\x69', '\x69']), ('\u2177', &['\x76', '\x69', '\x69', '\x69']),
+ ('\u2178', &['\x69', '\x78']), ('\u2179', &['\x78']), ('\u217a', &['\x78', '\x69']),
+ ('\u217b', &['\x78', '\x69', '\x69']), ('\u217c', &['\x6c']), ('\u217d', &['\x63']),
+ ('\u217e', &['\x64']), ('\u217f', &['\x6d']), ('\u2189', &['\x30', '\u2044', '\x33']),
+ ('\u222c', &['\u222b', '\u222b']), ('\u222d', &['\u222b', '\u222b', '\u222b']), ('\u222f',
+ &['\u222e', '\u222e']), ('\u2230', &['\u222e', '\u222e', '\u222e']), ('\u2460', &['\x31']),
+ ('\u2461', &['\x32']), ('\u2462', &['\x33']), ('\u2463', &['\x34']), ('\u2464', &['\x35']),
+ ('\u2465', &['\x36']), ('\u2466', &['\x37']), ('\u2467', &['\x38']), ('\u2468', &['\x39']),
+ ('\u2469', &['\x31', '\x30']), ('\u246a', &['\x31', '\x31']), ('\u246b', &['\x31', '\x32']),
+ ('\u246c', &['\x31', '\x33']), ('\u246d', &['\x31', '\x34']), ('\u246e', &['\x31', '\x35']),
+ ('\u246f', &['\x31', '\x36']), ('\u2470', &['\x31', '\x37']), ('\u2471', &['\x31', '\x38']),
+ ('\u2472', &['\x31', '\x39']), ('\u2473', &['\x32', '\x30']), ('\u2474', &['\x28', '\x31',
+ '\x29']), ('\u2475', &['\x28', '\x32', '\x29']), ('\u2476', &['\x28', '\x33', '\x29']),
+ ('\u2477', &['\x28', '\x34', '\x29']), ('\u2478', &['\x28', '\x35', '\x29']), ('\u2479',
+ &['\x28', '\x36', '\x29']), ('\u247a', &['\x28', '\x37', '\x29']), ('\u247b', &['\x28',
+ '\x38', '\x29']), ('\u247c', &['\x28', '\x39', '\x29']), ('\u247d', &['\x28', '\x31',
+ '\x30', '\x29']), ('\u247e', &['\x28', '\x31', '\x31', '\x29']), ('\u247f', &['\x28',
+ '\x31', '\x32', '\x29']), ('\u2480', &['\x28', '\x31', '\x33', '\x29']), ('\u2481',
+ &['\x28', '\x31', '\x34', '\x29']), ('\u2482', &['\x28', '\x31', '\x35', '\x29']),
+ ('\u2483', &['\x28', '\x31', '\x36', '\x29']), ('\u2484', &['\x28', '\x31', '\x37',
+ '\x29']), ('\u2485', &['\x28', '\x31', '\x38', '\x29']), ('\u2486', &['\x28', '\x31',
+ '\x39', '\x29']), ('\u2487', &['\x28', '\x32', '\x30', '\x29']), ('\u2488', &['\x31',
+ '\x2e']), ('\u2489', &['\x32', '\x2e']), ('\u248a', &['\x33', '\x2e']), ('\u248b', &['\x34',
+ '\x2e']), ('\u248c', &['\x35', '\x2e']), ('\u248d', &['\x36', '\x2e']), ('\u248e', &['\x37',
+ '\x2e']), ('\u248f', &['\x38', '\x2e']), ('\u2490', &['\x39', '\x2e']), ('\u2491', &['\x31',
+ '\x30', '\x2e']), ('\u2492', &['\x31', '\x31', '\x2e']), ('\u2493', &['\x31', '\x32',
+ '\x2e']), ('\u2494', &['\x31', '\x33', '\x2e']), ('\u2495', &['\x31', '\x34', '\x2e']),
+ ('\u2496', &['\x31', '\x35', '\x2e']), ('\u2497', &['\x31', '\x36', '\x2e']), ('\u2498',
+ &['\x31', '\x37', '\x2e']), ('\u2499', &['\x31', '\x38', '\x2e']), ('\u249a', &['\x31',
+ '\x39', '\x2e']), ('\u249b', &['\x32', '\x30', '\x2e']), ('\u249c', &['\x28', '\x61',
+ '\x29']), ('\u249d', &['\x28', '\x62', '\x29']), ('\u249e', &['\x28', '\x63', '\x29']),
+ ('\u249f', &['\x28', '\x64', '\x29']), ('\u24a0', &['\x28', '\x65', '\x29']), ('\u24a1',
+ &['\x28', '\x66', '\x29']), ('\u24a2', &['\x28', '\x67', '\x29']), ('\u24a3', &['\x28',
+ '\x68', '\x29']), ('\u24a4', &['\x28', '\x69', '\x29']), ('\u24a5', &['\x28', '\x6a',
+ '\x29']), ('\u24a6', &['\x28', '\x6b', '\x29']), ('\u24a7', &['\x28', '\x6c', '\x29']),
+ ('\u24a8', &['\x28', '\x6d', '\x29']), ('\u24a9', &['\x28', '\x6e', '\x29']), ('\u24aa',
+ &['\x28', '\x6f', '\x29']), ('\u24ab', &['\x28', '\x70', '\x29']), ('\u24ac', &['\x28',
+ '\x71', '\x29']), ('\u24ad', &['\x28', '\x72', '\x29']), ('\u24ae', &['\x28', '\x73',
+ '\x29']), ('\u24af', &['\x28', '\x74', '\x29']), ('\u24b0', &['\x28', '\x75', '\x29']),
+ ('\u24b1', &['\x28', '\x76', '\x29']), ('\u24b2', &['\x28', '\x77', '\x29']), ('\u24b3',
+ &['\x28', '\x78', '\x29']), ('\u24b4', &['\x28', '\x79', '\x29']), ('\u24b5', &['\x28',
+ '\x7a', '\x29']), ('\u24b6', &['\x41']), ('\u24b7', &['\x42']), ('\u24b8', &['\x43']),
+ ('\u24b9', &['\x44']), ('\u24ba', &['\x45']), ('\u24bb', &['\x46']), ('\u24bc', &['\x47']),
+ ('\u24bd', &['\x48']), ('\u24be', &['\x49']), ('\u24bf', &['\x4a']), ('\u24c0', &['\x4b']),
+ ('\u24c1', &['\x4c']), ('\u24c2', &['\x4d']), ('\u24c3', &['\x4e']), ('\u24c4', &['\x4f']),
+ ('\u24c5', &['\x50']), ('\u24c6', &['\x51']), ('\u24c7', &['\x52']), ('\u24c8', &['\x53']),
+ ('\u24c9', &['\x54']), ('\u24ca', &['\x55']), ('\u24cb', &['\x56']), ('\u24cc', &['\x57']),
+ ('\u24cd', &['\x58']), ('\u24ce', &['\x59']), ('\u24cf', &['\x5a']), ('\u24d0', &['\x61']),
+ ('\u24d1', &['\x62']), ('\u24d2', &['\x63']), ('\u24d3', &['\x64']), ('\u24d4', &['\x65']),
+ ('\u24d5', &['\x66']), ('\u24d6', &['\x67']), ('\u24d7', &['\x68']), ('\u24d8', &['\x69']),
+ ('\u24d9', &['\x6a']), ('\u24da', &['\x6b']), ('\u24db', &['\x6c']), ('\u24dc', &['\x6d']),
+ ('\u24dd', &['\x6e']), ('\u24de', &['\x6f']), ('\u24df', &['\x70']), ('\u24e0', &['\x71']),
+ ('\u24e1', &['\x72']), ('\u24e2', &['\x73']), ('\u24e3', &['\x74']), ('\u24e4', &['\x75']),
+ ('\u24e5', &['\x76']), ('\u24e6', &['\x77']), ('\u24e7', &['\x78']), ('\u24e8', &['\x79']),
+ ('\u24e9', &['\x7a']), ('\u24ea', &['\x30']), ('\u2a0c', &['\u222b', '\u222b', '\u222b',
+ '\u222b']), ('\u2a74', &['\x3a', '\x3a', '\x3d']), ('\u2a75', &['\x3d', '\x3d']), ('\u2a76',
+ &['\x3d', '\x3d', '\x3d']), ('\u2c7c', &['\x6a']), ('\u2c7d', &['\x56']), ('\u2d6f',
+ &['\u2d61']), ('\u2e9f', &['\u6bcd']), ('\u2ef3', &['\u9f9f']), ('\u2f00', &['\u4e00']),
+ ('\u2f01', &['\u4e28']), ('\u2f02', &['\u4e36']), ('\u2f03', &['\u4e3f']), ('\u2f04',
+ &['\u4e59']), ('\u2f05', &['\u4e85']), ('\u2f06', &['\u4e8c']), ('\u2f07', &['\u4ea0']),
+ ('\u2f08', &['\u4eba']), ('\u2f09', &['\u513f']), ('\u2f0a', &['\u5165']), ('\u2f0b',
+ &['\u516b']), ('\u2f0c', &['\u5182']), ('\u2f0d', &['\u5196']), ('\u2f0e', &['\u51ab']),
+ ('\u2f0f', &['\u51e0']), ('\u2f10', &['\u51f5']), ('\u2f11', &['\u5200']), ('\u2f12',
+ &['\u529b']), ('\u2f13', &['\u52f9']), ('\u2f14', &['\u5315']), ('\u2f15', &['\u531a']),
+ ('\u2f16', &['\u5338']), ('\u2f17', &['\u5341']), ('\u2f18', &['\u535c']), ('\u2f19',
+ &['\u5369']), ('\u2f1a', &['\u5382']), ('\u2f1b', &['\u53b6']), ('\u2f1c', &['\u53c8']),
+ ('\u2f1d', &['\u53e3']), ('\u2f1e', &['\u56d7']), ('\u2f1f', &['\u571f']), ('\u2f20',
+ &['\u58eb']), ('\u2f21', &['\u5902']), ('\u2f22', &['\u590a']), ('\u2f23', &['\u5915']),
+ ('\u2f24', &['\u5927']), ('\u2f25', &['\u5973']), ('\u2f26', &['\u5b50']), ('\u2f27',
+ &['\u5b80']), ('\u2f28', &['\u5bf8']), ('\u2f29', &['\u5c0f']), ('\u2f2a', &['\u5c22']),
+ ('\u2f2b', &['\u5c38']), ('\u2f2c', &['\u5c6e']), ('\u2f2d', &['\u5c71']), ('\u2f2e',
+ &['\u5ddb']), ('\u2f2f', &['\u5de5']), ('\u2f30', &['\u5df1']), ('\u2f31', &['\u5dfe']),
+ ('\u2f32', &['\u5e72']), ('\u2f33', &['\u5e7a']), ('\u2f34', &['\u5e7f']), ('\u2f35',
+ &['\u5ef4']), ('\u2f36', &['\u5efe']), ('\u2f37', &['\u5f0b']), ('\u2f38', &['\u5f13']),
+ ('\u2f39', &['\u5f50']), ('\u2f3a', &['\u5f61']), ('\u2f3b', &['\u5f73']), ('\u2f3c',
+ &['\u5fc3']), ('\u2f3d', &['\u6208']), ('\u2f3e', &['\u6236']), ('\u2f3f', &['\u624b']),
+ ('\u2f40', &['\u652f']), ('\u2f41', &['\u6534']), ('\u2f42', &['\u6587']), ('\u2f43',
+ &['\u6597']), ('\u2f44', &['\u65a4']), ('\u2f45', &['\u65b9']), ('\u2f46', &['\u65e0']),
+ ('\u2f47', &['\u65e5']), ('\u2f48', &['\u66f0']), ('\u2f49', &['\u6708']), ('\u2f4a',
+ &['\u6728']), ('\u2f4b', &['\u6b20']), ('\u2f4c', &['\u6b62']), ('\u2f4d', &['\u6b79']),
+ ('\u2f4e', &['\u6bb3']), ('\u2f4f', &['\u6bcb']), ('\u2f50', &['\u6bd4']), ('\u2f51',
+ &['\u6bdb']), ('\u2f52', &['\u6c0f']), ('\u2f53', &['\u6c14']), ('\u2f54', &['\u6c34']),
+ ('\u2f55', &['\u706b']), ('\u2f56', &['\u722a']), ('\u2f57', &['\u7236']), ('\u2f58',
+ &['\u723b']), ('\u2f59', &['\u723f']), ('\u2f5a', &['\u7247']), ('\u2f5b', &['\u7259']),
+ ('\u2f5c', &['\u725b']), ('\u2f5d', &['\u72ac']), ('\u2f5e', &['\u7384']), ('\u2f5f',
+ &['\u7389']), ('\u2f60', &['\u74dc']), ('\u2f61', &['\u74e6']), ('\u2f62', &['\u7518']),
+ ('\u2f63', &['\u751f']), ('\u2f64', &['\u7528']), ('\u2f65', &['\u7530']), ('\u2f66',
+ &['\u758b']), ('\u2f67', &['\u7592']), ('\u2f68', &['\u7676']), ('\u2f69', &['\u767d']),
+ ('\u2f6a', &['\u76ae']), ('\u2f6b', &['\u76bf']), ('\u2f6c', &['\u76ee']), ('\u2f6d',
+ &['\u77db']), ('\u2f6e', &['\u77e2']), ('\u2f6f', &['\u77f3']), ('\u2f70', &['\u793a']),
+ ('\u2f71', &['\u79b8']), ('\u2f72', &['\u79be']), ('\u2f73', &['\u7a74']), ('\u2f74',
+ &['\u7acb']), ('\u2f75', &['\u7af9']), ('\u2f76', &['\u7c73']), ('\u2f77', &['\u7cf8']),
+ ('\u2f78', &['\u7f36']), ('\u2f79', &['\u7f51']), ('\u2f7a', &['\u7f8a']), ('\u2f7b',
+ &['\u7fbd']), ('\u2f7c', &['\u8001']), ('\u2f7d', &['\u800c']), ('\u2f7e', &['\u8012']),
+ ('\u2f7f', &['\u8033']), ('\u2f80', &['\u807f']), ('\u2f81', &['\u8089']), ('\u2f82',
+ &['\u81e3']), ('\u2f83', &['\u81ea']), ('\u2f84', &['\u81f3']), ('\u2f85', &['\u81fc']),
+ ('\u2f86', &['\u820c']), ('\u2f87', &['\u821b']), ('\u2f88', &['\u821f']), ('\u2f89',
+ &['\u826e']), ('\u2f8a', &['\u8272']), ('\u2f8b', &['\u8278']), ('\u2f8c', &['\u864d']),
+ ('\u2f8d', &['\u866b']), ('\u2f8e', &['\u8840']), ('\u2f8f', &['\u884c']), ('\u2f90',
+ &['\u8863']), ('\u2f91', &['\u897e']), ('\u2f92', &['\u898b']), ('\u2f93', &['\u89d2']),
+ ('\u2f94', &['\u8a00']), ('\u2f95', &['\u8c37']), ('\u2f96', &['\u8c46']), ('\u2f97',
+ &['\u8c55']), ('\u2f98', &['\u8c78']), ('\u2f99', &['\u8c9d']), ('\u2f9a', &['\u8d64']),
+ ('\u2f9b', &['\u8d70']), ('\u2f9c', &['\u8db3']), ('\u2f9d', &['\u8eab']), ('\u2f9e',
+ &['\u8eca']), ('\u2f9f', &['\u8f9b']), ('\u2fa0', &['\u8fb0']), ('\u2fa1', &['\u8fb5']),
+ ('\u2fa2', &['\u9091']), ('\u2fa3', &['\u9149']), ('\u2fa4', &['\u91c6']), ('\u2fa5',
+ &['\u91cc']), ('\u2fa6', &['\u91d1']), ('\u2fa7', &['\u9577']), ('\u2fa8', &['\u9580']),
+ ('\u2fa9', &['\u961c']), ('\u2faa', &['\u96b6']), ('\u2fab', &['\u96b9']), ('\u2fac',
+ &['\u96e8']), ('\u2fad', &['\u9751']), ('\u2fae', &['\u975e']), ('\u2faf', &['\u9762']),
+ ('\u2fb0', &['\u9769']), ('\u2fb1', &['\u97cb']), ('\u2fb2', &['\u97ed']), ('\u2fb3',
+ &['\u97f3']), ('\u2fb4', &['\u9801']), ('\u2fb5', &['\u98a8']), ('\u2fb6', &['\u98db']),
+ ('\u2fb7', &['\u98df']), ('\u2fb8', &['\u9996']), ('\u2fb9', &['\u9999']), ('\u2fba',
+ &['\u99ac']), ('\u2fbb', &['\u9aa8']), ('\u2fbc', &['\u9ad8']), ('\u2fbd', &['\u9adf']),
+ ('\u2fbe', &['\u9b25']), ('\u2fbf', &['\u9b2f']), ('\u2fc0', &['\u9b32']), ('\u2fc1',
+ &['\u9b3c']), ('\u2fc2', &['\u9b5a']), ('\u2fc3', &['\u9ce5']), ('\u2fc4', &['\u9e75']),
+ ('\u2fc5', &['\u9e7f']), ('\u2fc6', &['\u9ea5']), ('\u2fc7', &['\u9ebb']), ('\u2fc8',
+ &['\u9ec3']), ('\u2fc9', &['\u9ecd']), ('\u2fca', &['\u9ed1']), ('\u2fcb', &['\u9ef9']),
+ ('\u2fcc', &['\u9efd']), ('\u2fcd', &['\u9f0e']), ('\u2fce', &['\u9f13']), ('\u2fcf',
+ &['\u9f20']), ('\u2fd0', &['\u9f3b']), ('\u2fd1', &['\u9f4a']), ('\u2fd2', &['\u9f52']),
+ ('\u2fd3', &['\u9f8d']), ('\u2fd4', &['\u9f9c']), ('\u2fd5', &['\u9fa0']), ('\u3000',
+ &['\x20']), ('\u3036', &['\u3012']), ('\u3038', &['\u5341']), ('\u3039', &['\u5344']),
+ ('\u303a', &['\u5345']), ('\u309b', &['\x20', '\u3099']), ('\u309c', &['\x20', '\u309a']),
+ ('\u309f', &['\u3088', '\u308a']), ('\u30ff', &['\u30b3', '\u30c8']), ('\u3131',
+ &['\u1100']), ('\u3132', &['\u1101']), ('\u3133', &['\u11aa']), ('\u3134', &['\u1102']),
+ ('\u3135', &['\u11ac']), ('\u3136', &['\u11ad']), ('\u3137', &['\u1103']), ('\u3138',
+ &['\u1104']), ('\u3139', &['\u1105']), ('\u313a', &['\u11b0']), ('\u313b', &['\u11b1']),
+ ('\u313c', &['\u11b2']), ('\u313d', &['\u11b3']), ('\u313e', &['\u11b4']), ('\u313f',
+ &['\u11b5']), ('\u3140', &['\u111a']), ('\u3141', &['\u1106']), ('\u3142', &['\u1107']),
+ ('\u3143', &['\u1108']), ('\u3144', &['\u1121']), ('\u3145', &['\u1109']), ('\u3146',
+ &['\u110a']), ('\u3147', &['\u110b']), ('\u3148', &['\u110c']), ('\u3149', &['\u110d']),
+ ('\u314a', &['\u110e']), ('\u314b', &['\u110f']), ('\u314c', &['\u1110']), ('\u314d',
+ &['\u1111']), ('\u314e', &['\u1112']), ('\u314f', &['\u1161']), ('\u3150', &['\u1162']),
+ ('\u3151', &['\u1163']), ('\u3152', &['\u1164']), ('\u3153', &['\u1165']), ('\u3154',
+ &['\u1166']), ('\u3155', &['\u1167']), ('\u3156', &['\u1168']), ('\u3157', &['\u1169']),
+ ('\u3158', &['\u116a']), ('\u3159', &['\u116b']), ('\u315a', &['\u116c']), ('\u315b',
+ &['\u116d']), ('\u315c', &['\u116e']), ('\u315d', &['\u116f']), ('\u315e', &['\u1170']),
+ ('\u315f', &['\u1171']), ('\u3160', &['\u1172']), ('\u3161', &['\u1173']), ('\u3162',
+ &['\u1174']), ('\u3163', &['\u1175']), ('\u3164', &['\u1160']), ('\u3165', &['\u1114']),
+ ('\u3166', &['\u1115']), ('\u3167', &['\u11c7']), ('\u3168', &['\u11c8']), ('\u3169',
+ &['\u11cc']), ('\u316a', &['\u11ce']), ('\u316b', &['\u11d3']), ('\u316c', &['\u11d7']),
+ ('\u316d', &['\u11d9']), ('\u316e', &['\u111c']), ('\u316f', &['\u11dd']), ('\u3170',
+ &['\u11df']), ('\u3171', &['\u111d']), ('\u3172', &['\u111e']), ('\u3173', &['\u1120']),
+ ('\u3174', &['\u1122']), ('\u3175', &['\u1123']), ('\u3176', &['\u1127']), ('\u3177',
+ &['\u1129']), ('\u3178', &['\u112b']), ('\u3179', &['\u112c']), ('\u317a', &['\u112d']),
+ ('\u317b', &['\u112e']), ('\u317c', &['\u112f']), ('\u317d', &['\u1132']), ('\u317e',
+ &['\u1136']), ('\u317f', &['\u1140']), ('\u3180', &['\u1147']), ('\u3181', &['\u114c']),
+ ('\u3182', &['\u11f1']), ('\u3183', &['\u11f2']), ('\u3184', &['\u1157']), ('\u3185',
+ &['\u1158']), ('\u3186', &['\u1159']), ('\u3187', &['\u1184']), ('\u3188', &['\u1185']),
+ ('\u3189', &['\u1188']), ('\u318a', &['\u1191']), ('\u318b', &['\u1192']), ('\u318c',
+ &['\u1194']), ('\u318d', &['\u119e']), ('\u318e', &['\u11a1']), ('\u3192', &['\u4e00']),
+ ('\u3193', &['\u4e8c']), ('\u3194', &['\u4e09']), ('\u3195', &['\u56db']), ('\u3196',
+ &['\u4e0a']), ('\u3197', &['\u4e2d']), ('\u3198', &['\u4e0b']), ('\u3199', &['\u7532']),
+ ('\u319a', &['\u4e59']), ('\u319b', &['\u4e19']), ('\u319c', &['\u4e01']), ('\u319d',
+ &['\u5929']), ('\u319e', &['\u5730']), ('\u319f', &['\u4eba']), ('\u3200', &['\x28',
+ '\u1100', '\x29']), ('\u3201', &['\x28', '\u1102', '\x29']), ('\u3202', &['\x28', '\u1103',
+ '\x29']), ('\u3203', &['\x28', '\u1105', '\x29']), ('\u3204', &['\x28', '\u1106', '\x29']),
+ ('\u3205', &['\x28', '\u1107', '\x29']), ('\u3206', &['\x28', '\u1109', '\x29']), ('\u3207',
+ &['\x28', '\u110b', '\x29']), ('\u3208', &['\x28', '\u110c', '\x29']), ('\u3209', &['\x28',
+ '\u110e', '\x29']), ('\u320a', &['\x28', '\u110f', '\x29']), ('\u320b', &['\x28', '\u1110',
+ '\x29']), ('\u320c', &['\x28', '\u1111', '\x29']), ('\u320d', &['\x28', '\u1112', '\x29']),
+ ('\u320e', &['\x28', '\u1100', '\u1161', '\x29']), ('\u320f', &['\x28', '\u1102', '\u1161',
+ '\x29']), ('\u3210', &['\x28', '\u1103', '\u1161', '\x29']), ('\u3211', &['\x28', '\u1105',
+ '\u1161', '\x29']), ('\u3212', &['\x28', '\u1106', '\u1161', '\x29']), ('\u3213', &['\x28',
+ '\u1107', '\u1161', '\x29']), ('\u3214', &['\x28', '\u1109', '\u1161', '\x29']), ('\u3215',
+ &['\x28', '\u110b', '\u1161', '\x29']), ('\u3216', &['\x28', '\u110c', '\u1161', '\x29']),
+ ('\u3217', &['\x28', '\u110e', '\u1161', '\x29']), ('\u3218', &['\x28', '\u110f', '\u1161',
+ '\x29']), ('\u3219', &['\x28', '\u1110', '\u1161', '\x29']), ('\u321a', &['\x28', '\u1111',
+ '\u1161', '\x29']), ('\u321b', &['\x28', '\u1112', '\u1161', '\x29']), ('\u321c', &['\x28',
+ '\u110c', '\u116e', '\x29']), ('\u321d', &['\x28', '\u110b', '\u1169', '\u110c', '\u1165',
+ '\u11ab', '\x29']), ('\u321e', &['\x28', '\u110b', '\u1169', '\u1112', '\u116e', '\x29']),
+ ('\u3220', &['\x28', '\u4e00', '\x29']), ('\u3221', &['\x28', '\u4e8c', '\x29']), ('\u3222',
+ &['\x28', '\u4e09', '\x29']), ('\u3223', &['\x28', '\u56db', '\x29']), ('\u3224', &['\x28',
+ '\u4e94', '\x29']), ('\u3225', &['\x28', '\u516d', '\x29']), ('\u3226', &['\x28', '\u4e03',
+ '\x29']), ('\u3227', &['\x28', '\u516b', '\x29']), ('\u3228', &['\x28', '\u4e5d', '\x29']),
+ ('\u3229', &['\x28', '\u5341', '\x29']), ('\u322a', &['\x28', '\u6708', '\x29']), ('\u322b',
+ &['\x28', '\u706b', '\x29']), ('\u322c', &['\x28', '\u6c34', '\x29']), ('\u322d', &['\x28',
+ '\u6728', '\x29']), ('\u322e', &['\x28', '\u91d1', '\x29']), ('\u322f', &['\x28', '\u571f',
+ '\x29']), ('\u3230', &['\x28', '\u65e5', '\x29']), ('\u3231', &['\x28', '\u682a', '\x29']),
+ ('\u3232', &['\x28', '\u6709', '\x29']), ('\u3233', &['\x28', '\u793e', '\x29']), ('\u3234',
+ &['\x28', '\u540d', '\x29']), ('\u3235', &['\x28', '\u7279', '\x29']), ('\u3236', &['\x28',
+ '\u8ca1', '\x29']), ('\u3237', &['\x28', '\u795d', '\x29']), ('\u3238', &['\x28', '\u52b4',
+ '\x29']), ('\u3239', &['\x28', '\u4ee3', '\x29']), ('\u323a', &['\x28', '\u547c', '\x29']),
+ ('\u323b', &['\x28', '\u5b66', '\x29']), ('\u323c', &['\x28', '\u76e3', '\x29']), ('\u323d',
+ &['\x28', '\u4f01', '\x29']), ('\u323e', &['\x28', '\u8cc7', '\x29']), ('\u323f', &['\x28',
+ '\u5354', '\x29']), ('\u3240', &['\x28', '\u796d', '\x29']), ('\u3241', &['\x28', '\u4f11',
+ '\x29']), ('\u3242', &['\x28', '\u81ea', '\x29']), ('\u3243', &['\x28', '\u81f3', '\x29']),
+ ('\u3244', &['\u554f']), ('\u3245', &['\u5e7c']), ('\u3246', &['\u6587']), ('\u3247',
+ &['\u7b8f']), ('\u3250', &['\x50', '\x54', '\x45']), ('\u3251', &['\x32', '\x31']),
+ ('\u3252', &['\x32', '\x32']), ('\u3253', &['\x32', '\x33']), ('\u3254', &['\x32', '\x34']),
+ ('\u3255', &['\x32', '\x35']), ('\u3256', &['\x32', '\x36']), ('\u3257', &['\x32', '\x37']),
+ ('\u3258', &['\x32', '\x38']), ('\u3259', &['\x32', '\x39']), ('\u325a', &['\x33', '\x30']),
+ ('\u325b', &['\x33', '\x31']), ('\u325c', &['\x33', '\x32']), ('\u325d', &['\x33', '\x33']),
+ ('\u325e', &['\x33', '\x34']), ('\u325f', &['\x33', '\x35']), ('\u3260', &['\u1100']),
+ ('\u3261', &['\u1102']), ('\u3262', &['\u1103']), ('\u3263', &['\u1105']), ('\u3264',
+ &['\u1106']), ('\u3265', &['\u1107']), ('\u3266', &['\u1109']), ('\u3267', &['\u110b']),
+ ('\u3268', &['\u110c']), ('\u3269', &['\u110e']), ('\u326a', &['\u110f']), ('\u326b',
+ &['\u1110']), ('\u326c', &['\u1111']), ('\u326d', &['\u1112']), ('\u326e', &['\u1100',
+ '\u1161']), ('\u326f', &['\u1102', '\u1161']), ('\u3270', &['\u1103', '\u1161']), ('\u3271',
+ &['\u1105', '\u1161']), ('\u3272', &['\u1106', '\u1161']), ('\u3273', &['\u1107',
+ '\u1161']), ('\u3274', &['\u1109', '\u1161']), ('\u3275', &['\u110b', '\u1161']), ('\u3276',
+ &['\u110c', '\u1161']), ('\u3277', &['\u110e', '\u1161']), ('\u3278', &['\u110f',
+ '\u1161']), ('\u3279', &['\u1110', '\u1161']), ('\u327a', &['\u1111', '\u1161']), ('\u327b',
+ &['\u1112', '\u1161']), ('\u327c', &['\u110e', '\u1161', '\u11b7', '\u1100', '\u1169']),
+ ('\u327d', &['\u110c', '\u116e', '\u110b', '\u1174']), ('\u327e', &['\u110b', '\u116e']),
+ ('\u3280', &['\u4e00']), ('\u3281', &['\u4e8c']), ('\u3282', &['\u4e09']), ('\u3283',
+ &['\u56db']), ('\u3284', &['\u4e94']), ('\u3285', &['\u516d']), ('\u3286', &['\u4e03']),
+ ('\u3287', &['\u516b']), ('\u3288', &['\u4e5d']), ('\u3289', &['\u5341']), ('\u328a',
+ &['\u6708']), ('\u328b', &['\u706b']), ('\u328c', &['\u6c34']), ('\u328d', &['\u6728']),
+ ('\u328e', &['\u91d1']), ('\u328f', &['\u571f']), ('\u3290', &['\u65e5']), ('\u3291',
+ &['\u682a']), ('\u3292', &['\u6709']), ('\u3293', &['\u793e']), ('\u3294', &['\u540d']),
+ ('\u3295', &['\u7279']), ('\u3296', &['\u8ca1']), ('\u3297', &['\u795d']), ('\u3298',
+ &['\u52b4']), ('\u3299', &['\u79d8']), ('\u329a', &['\u7537']), ('\u329b', &['\u5973']),
+ ('\u329c', &['\u9069']), ('\u329d', &['\u512a']), ('\u329e', &['\u5370']), ('\u329f',
+ &['\u6ce8']), ('\u32a0', &['\u9805']), ('\u32a1', &['\u4f11']), ('\u32a2', &['\u5199']),
+ ('\u32a3', &['\u6b63']), ('\u32a4', &['\u4e0a']), ('\u32a5', &['\u4e2d']), ('\u32a6',
+ &['\u4e0b']), ('\u32a7', &['\u5de6']), ('\u32a8', &['\u53f3']), ('\u32a9', &['\u533b']),
+ ('\u32aa', &['\u5b97']), ('\u32ab', &['\u5b66']), ('\u32ac', &['\u76e3']), ('\u32ad',
+ &['\u4f01']), ('\u32ae', &['\u8cc7']), ('\u32af', &['\u5354']), ('\u32b0', &['\u591c']),
+ ('\u32b1', &['\x33', '\x36']), ('\u32b2', &['\x33', '\x37']), ('\u32b3', &['\x33', '\x38']),
+ ('\u32b4', &['\x33', '\x39']), ('\u32b5', &['\x34', '\x30']), ('\u32b6', &['\x34', '\x31']),
+ ('\u32b7', &['\x34', '\x32']), ('\u32b8', &['\x34', '\x33']), ('\u32b9', &['\x34', '\x34']),
+ ('\u32ba', &['\x34', '\x35']), ('\u32bb', &['\x34', '\x36']), ('\u32bc', &['\x34', '\x37']),
+ ('\u32bd', &['\x34', '\x38']), ('\u32be', &['\x34', '\x39']), ('\u32bf', &['\x35', '\x30']),
+ ('\u32c0', &['\x31', '\u6708']), ('\u32c1', &['\x32', '\u6708']), ('\u32c2', &['\x33',
+ '\u6708']), ('\u32c3', &['\x34', '\u6708']), ('\u32c4', &['\x35', '\u6708']), ('\u32c5',
+ &['\x36', '\u6708']), ('\u32c6', &['\x37', '\u6708']), ('\u32c7', &['\x38', '\u6708']),
+ ('\u32c8', &['\x39', '\u6708']), ('\u32c9', &['\x31', '\x30', '\u6708']), ('\u32ca',
+ &['\x31', '\x31', '\u6708']), ('\u32cb', &['\x31', '\x32', '\u6708']), ('\u32cc', &['\x48',
+ '\x67']), ('\u32cd', &['\x65', '\x72', '\x67']), ('\u32ce', &['\x65', '\x56']), ('\u32cf',
+ &['\x4c', '\x54', '\x44']), ('\u32d0', &['\u30a2']), ('\u32d1', &['\u30a4']), ('\u32d2',
+ &['\u30a6']), ('\u32d3', &['\u30a8']), ('\u32d4', &['\u30aa']), ('\u32d5', &['\u30ab']),
+ ('\u32d6', &['\u30ad']), ('\u32d7', &['\u30af']), ('\u32d8', &['\u30b1']), ('\u32d9',
+ &['\u30b3']), ('\u32da', &['\u30b5']), ('\u32db', &['\u30b7']), ('\u32dc', &['\u30b9']),
+ ('\u32dd', &['\u30bb']), ('\u32de', &['\u30bd']), ('\u32df', &['\u30bf']), ('\u32e0',
+ &['\u30c1']), ('\u32e1', &['\u30c4']), ('\u32e2', &['\u30c6']), ('\u32e3', &['\u30c8']),
+ ('\u32e4', &['\u30ca']), ('\u32e5', &['\u30cb']), ('\u32e6', &['\u30cc']), ('\u32e7',
+ &['\u30cd']), ('\u32e8', &['\u30ce']), ('\u32e9', &['\u30cf']), ('\u32ea', &['\u30d2']),
+ ('\u32eb', &['\u30d5']), ('\u32ec', &['\u30d8']), ('\u32ed', &['\u30db']), ('\u32ee',
+ &['\u30de']), ('\u32ef', &['\u30df']), ('\u32f0', &['\u30e0']), ('\u32f1', &['\u30e1']),
+ ('\u32f2', &['\u30e2']), ('\u32f3', &['\u30e4']), ('\u32f4', &['\u30e6']), ('\u32f5',
+ &['\u30e8']), ('\u32f6', &['\u30e9']), ('\u32f7', &['\u30ea']), ('\u32f8', &['\u30eb']),
+ ('\u32f9', &['\u30ec']), ('\u32fa', &['\u30ed']), ('\u32fb', &['\u30ef']), ('\u32fc',
+ &['\u30f0']), ('\u32fd', &['\u30f1']), ('\u32fe', &['\u30f2']), ('\u3300', &['\u30a2',
+ '\u30d1', '\u30fc', '\u30c8']), ('\u3301', &['\u30a2', '\u30eb', '\u30d5', '\u30a1']),
+ ('\u3302', &['\u30a2', '\u30f3', '\u30da', '\u30a2']), ('\u3303', &['\u30a2', '\u30fc',
+ '\u30eb']), ('\u3304', &['\u30a4', '\u30cb', '\u30f3', '\u30b0']), ('\u3305', &['\u30a4',
+ '\u30f3', '\u30c1']), ('\u3306', &['\u30a6', '\u30a9', '\u30f3']), ('\u3307', &['\u30a8',
+ '\u30b9', '\u30af', '\u30fc', '\u30c9']), ('\u3308', &['\u30a8', '\u30fc', '\u30ab',
+ '\u30fc']), ('\u3309', &['\u30aa', '\u30f3', '\u30b9']), ('\u330a', &['\u30aa', '\u30fc',
+ '\u30e0']), ('\u330b', &['\u30ab', '\u30a4', '\u30ea']), ('\u330c', &['\u30ab', '\u30e9',
+ '\u30c3', '\u30c8']), ('\u330d', &['\u30ab', '\u30ed', '\u30ea', '\u30fc']), ('\u330e',
+ &['\u30ac', '\u30ed', '\u30f3']), ('\u330f', &['\u30ac', '\u30f3', '\u30de']), ('\u3310',
+ &['\u30ae', '\u30ac']), ('\u3311', &['\u30ae', '\u30cb', '\u30fc']), ('\u3312', &['\u30ad',
+ '\u30e5', '\u30ea', '\u30fc']), ('\u3313', &['\u30ae', '\u30eb', '\u30c0', '\u30fc']),
+ ('\u3314', &['\u30ad', '\u30ed']), ('\u3315', &['\u30ad', '\u30ed', '\u30b0', '\u30e9',
+ '\u30e0']), ('\u3316', &['\u30ad', '\u30ed', '\u30e1', '\u30fc', '\u30c8', '\u30eb']),
+ ('\u3317', &['\u30ad', '\u30ed', '\u30ef', '\u30c3', '\u30c8']), ('\u3318', &['\u30b0',
+ '\u30e9', '\u30e0']), ('\u3319', &['\u30b0', '\u30e9', '\u30e0', '\u30c8', '\u30f3']),
+ ('\u331a', &['\u30af', '\u30eb', '\u30bc', '\u30a4', '\u30ed']), ('\u331b', &['\u30af',
+ '\u30ed', '\u30fc', '\u30cd']), ('\u331c', &['\u30b1', '\u30fc', '\u30b9']), ('\u331d',
+ &['\u30b3', '\u30eb', '\u30ca']), ('\u331e', &['\u30b3', '\u30fc', '\u30dd']), ('\u331f',
+ &['\u30b5', '\u30a4', '\u30af', '\u30eb']), ('\u3320', &['\u30b5', '\u30f3', '\u30c1',
+ '\u30fc', '\u30e0']), ('\u3321', &['\u30b7', '\u30ea', '\u30f3', '\u30b0']), ('\u3322',
+ &['\u30bb', '\u30f3', '\u30c1']), ('\u3323', &['\u30bb', '\u30f3', '\u30c8']), ('\u3324',
+ &['\u30c0', '\u30fc', '\u30b9']), ('\u3325', &['\u30c7', '\u30b7']), ('\u3326', &['\u30c9',
+ '\u30eb']), ('\u3327', &['\u30c8', '\u30f3']), ('\u3328', &['\u30ca', '\u30ce']), ('\u3329',
+ &['\u30ce', '\u30c3', '\u30c8']), ('\u332a', &['\u30cf', '\u30a4', '\u30c4']), ('\u332b',
+ &['\u30d1', '\u30fc', '\u30bb', '\u30f3', '\u30c8']), ('\u332c', &['\u30d1', '\u30fc',
+ '\u30c4']), ('\u332d', &['\u30d0', '\u30fc', '\u30ec', '\u30eb']), ('\u332e', &['\u30d4',
+ '\u30a2', '\u30b9', '\u30c8', '\u30eb']), ('\u332f', &['\u30d4', '\u30af', '\u30eb']),
+ ('\u3330', &['\u30d4', '\u30b3']), ('\u3331', &['\u30d3', '\u30eb']), ('\u3332', &['\u30d5',
+ '\u30a1', '\u30e9', '\u30c3', '\u30c9']), ('\u3333', &['\u30d5', '\u30a3', '\u30fc',
+ '\u30c8']), ('\u3334', &['\u30d6', '\u30c3', '\u30b7', '\u30a7', '\u30eb']), ('\u3335',
+ &['\u30d5', '\u30e9', '\u30f3']), ('\u3336', &['\u30d8', '\u30af', '\u30bf', '\u30fc',
+ '\u30eb']), ('\u3337', &['\u30da', '\u30bd']), ('\u3338', &['\u30da', '\u30cb', '\u30d2']),
+ ('\u3339', &['\u30d8', '\u30eb', '\u30c4']), ('\u333a', &['\u30da', '\u30f3', '\u30b9']),
+ ('\u333b', &['\u30da', '\u30fc', '\u30b8']), ('\u333c', &['\u30d9', '\u30fc', '\u30bf']),
+ ('\u333d', &['\u30dd', '\u30a4', '\u30f3', '\u30c8']), ('\u333e', &['\u30dc', '\u30eb',
+ '\u30c8']), ('\u333f', &['\u30db', '\u30f3']), ('\u3340', &['\u30dd', '\u30f3', '\u30c9']),
+ ('\u3341', &['\u30db', '\u30fc', '\u30eb']), ('\u3342', &['\u30db', '\u30fc', '\u30f3']),
+ ('\u3343', &['\u30de', '\u30a4', '\u30af', '\u30ed']), ('\u3344', &['\u30de', '\u30a4',
+ '\u30eb']), ('\u3345', &['\u30de', '\u30c3', '\u30cf']), ('\u3346', &['\u30de', '\u30eb',
+ '\u30af']), ('\u3347', &['\u30de', '\u30f3', '\u30b7', '\u30e7', '\u30f3']), ('\u3348',
+ &['\u30df', '\u30af', '\u30ed', '\u30f3']), ('\u3349', &['\u30df', '\u30ea']), ('\u334a',
+ &['\u30df', '\u30ea', '\u30d0', '\u30fc', '\u30eb']), ('\u334b', &['\u30e1', '\u30ac']),
+ ('\u334c', &['\u30e1', '\u30ac', '\u30c8', '\u30f3']), ('\u334d', &['\u30e1', '\u30fc',
+ '\u30c8', '\u30eb']), ('\u334e', &['\u30e4', '\u30fc', '\u30c9']), ('\u334f', &['\u30e4',
+ '\u30fc', '\u30eb']), ('\u3350', &['\u30e6', '\u30a2', '\u30f3']), ('\u3351', &['\u30ea',
+ '\u30c3', '\u30c8', '\u30eb']), ('\u3352', &['\u30ea', '\u30e9']), ('\u3353', &['\u30eb',
+ '\u30d4', '\u30fc']), ('\u3354', &['\u30eb', '\u30fc', '\u30d6', '\u30eb']), ('\u3355',
+ &['\u30ec', '\u30e0']), ('\u3356', &['\u30ec', '\u30f3', '\u30c8', '\u30b2', '\u30f3']),
+ ('\u3357', &['\u30ef', '\u30c3', '\u30c8']), ('\u3358', &['\x30', '\u70b9']), ('\u3359',
+ &['\x31', '\u70b9']), ('\u335a', &['\x32', '\u70b9']), ('\u335b', &['\x33', '\u70b9']),
+ ('\u335c', &['\x34', '\u70b9']), ('\u335d', &['\x35', '\u70b9']), ('\u335e', &['\x36',
+ '\u70b9']), ('\u335f', &['\x37', '\u70b9']), ('\u3360', &['\x38', '\u70b9']), ('\u3361',
+ &['\x39', '\u70b9']), ('\u3362', &['\x31', '\x30', '\u70b9']), ('\u3363', &['\x31', '\x31',
+ '\u70b9']), ('\u3364', &['\x31', '\x32', '\u70b9']), ('\u3365', &['\x31', '\x33',
+ '\u70b9']), ('\u3366', &['\x31', '\x34', '\u70b9']), ('\u3367', &['\x31', '\x35',
+ '\u70b9']), ('\u3368', &['\x31', '\x36', '\u70b9']), ('\u3369', &['\x31', '\x37',
+ '\u70b9']), ('\u336a', &['\x31', '\x38', '\u70b9']), ('\u336b', &['\x31', '\x39',
+ '\u70b9']), ('\u336c', &['\x32', '\x30', '\u70b9']), ('\u336d', &['\x32', '\x31',
+ '\u70b9']), ('\u336e', &['\x32', '\x32', '\u70b9']), ('\u336f', &['\x32', '\x33',
+ '\u70b9']), ('\u3370', &['\x32', '\x34', '\u70b9']), ('\u3371', &['\x68', '\x50', '\x61']),
+ ('\u3372', &['\x64', '\x61']), ('\u3373', &['\x41', '\x55']), ('\u3374', &['\x62', '\x61',
+ '\x72']), ('\u3375', &['\x6f', '\x56']), ('\u3376', &['\x70', '\x63']), ('\u3377', &['\x64',
+ '\x6d']), ('\u3378', &['\x64', '\x6d', '\xb2']), ('\u3379', &['\x64', '\x6d', '\xb3']),
+ ('\u337a', &['\x49', '\x55']), ('\u337b', &['\u5e73', '\u6210']), ('\u337c', &['\u662d',
+ '\u548c']), ('\u337d', &['\u5927', '\u6b63']), ('\u337e', &['\u660e', '\u6cbb']), ('\u337f',
+ &['\u682a', '\u5f0f', '\u4f1a', '\u793e']), ('\u3380', &['\x70', '\x41']), ('\u3381',
+ &['\x6e', '\x41']), ('\u3382', &['\u03bc', '\x41']), ('\u3383', &['\x6d', '\x41']),
+ ('\u3384', &['\x6b', '\x41']), ('\u3385', &['\x4b', '\x42']), ('\u3386', &['\x4d', '\x42']),
+ ('\u3387', &['\x47', '\x42']), ('\u3388', &['\x63', '\x61', '\x6c']), ('\u3389', &['\x6b',
+ '\x63', '\x61', '\x6c']), ('\u338a', &['\x70', '\x46']), ('\u338b', &['\x6e', '\x46']),
+ ('\u338c', &['\u03bc', '\x46']), ('\u338d', &['\u03bc', '\x67']), ('\u338e', &['\x6d',
+ '\x67']), ('\u338f', &['\x6b', '\x67']), ('\u3390', &['\x48', '\x7a']), ('\u3391', &['\x6b',
+ '\x48', '\x7a']), ('\u3392', &['\x4d', '\x48', '\x7a']), ('\u3393', &['\x47', '\x48',
+ '\x7a']), ('\u3394', &['\x54', '\x48', '\x7a']), ('\u3395', &['\u03bc', '\u2113']),
+ ('\u3396', &['\x6d', '\u2113']), ('\u3397', &['\x64', '\u2113']), ('\u3398', &['\x6b',
+ '\u2113']), ('\u3399', &['\x66', '\x6d']), ('\u339a', &['\x6e', '\x6d']), ('\u339b',
+ &['\u03bc', '\x6d']), ('\u339c', &['\x6d', '\x6d']), ('\u339d', &['\x63', '\x6d']),
+ ('\u339e', &['\x6b', '\x6d']), ('\u339f', &['\x6d', '\x6d', '\xb2']), ('\u33a0', &['\x63',
+ '\x6d', '\xb2']), ('\u33a1', &['\x6d', '\xb2']), ('\u33a2', &['\x6b', '\x6d', '\xb2']),
+ ('\u33a3', &['\x6d', '\x6d', '\xb3']), ('\u33a4', &['\x63', '\x6d', '\xb3']), ('\u33a5',
+ &['\x6d', '\xb3']), ('\u33a6', &['\x6b', '\x6d', '\xb3']), ('\u33a7', &['\x6d', '\u2215',
+ '\x73']), ('\u33a8', &['\x6d', '\u2215', '\x73', '\xb2']), ('\u33a9', &['\x50', '\x61']),
+ ('\u33aa', &['\x6b', '\x50', '\x61']), ('\u33ab', &['\x4d', '\x50', '\x61']), ('\u33ac',
+ &['\x47', '\x50', '\x61']), ('\u33ad', &['\x72', '\x61', '\x64']), ('\u33ae', &['\x72',
+ '\x61', '\x64', '\u2215', '\x73']), ('\u33af', &['\x72', '\x61', '\x64', '\u2215', '\x73',
+ '\xb2']), ('\u33b0', &['\x70', '\x73']), ('\u33b1', &['\x6e', '\x73']), ('\u33b2',
+ &['\u03bc', '\x73']), ('\u33b3', &['\x6d', '\x73']), ('\u33b4', &['\x70', '\x56']),
+ ('\u33b5', &['\x6e', '\x56']), ('\u33b6', &['\u03bc', '\x56']), ('\u33b7', &['\x6d',
+ '\x56']), ('\u33b8', &['\x6b', '\x56']), ('\u33b9', &['\x4d', '\x56']), ('\u33ba', &['\x70',
+ '\x57']), ('\u33bb', &['\x6e', '\x57']), ('\u33bc', &['\u03bc', '\x57']), ('\u33bd',
+ &['\x6d', '\x57']), ('\u33be', &['\x6b', '\x57']), ('\u33bf', &['\x4d', '\x57']), ('\u33c0',
+ &['\x6b', '\u03a9']), ('\u33c1', &['\x4d', '\u03a9']), ('\u33c2', &['\x61', '\x2e', '\x6d',
+ '\x2e']), ('\u33c3', &['\x42', '\x71']), ('\u33c4', &['\x63', '\x63']), ('\u33c5', &['\x63',
+ '\x64']), ('\u33c6', &['\x43', '\u2215', '\x6b', '\x67']), ('\u33c7', &['\x43', '\x6f',
+ '\x2e']), ('\u33c8', &['\x64', '\x42']), ('\u33c9', &['\x47', '\x79']), ('\u33ca', &['\x68',
+ '\x61']), ('\u33cb', &['\x48', '\x50']), ('\u33cc', &['\x69', '\x6e']), ('\u33cd', &['\x4b',
+ '\x4b']), ('\u33ce', &['\x4b', '\x4d']), ('\u33cf', &['\x6b', '\x74']), ('\u33d0', &['\x6c',
+ '\x6d']), ('\u33d1', &['\x6c', '\x6e']), ('\u33d2', &['\x6c', '\x6f', '\x67']), ('\u33d3',
+ &['\x6c', '\x78']), ('\u33d4', &['\x6d', '\x62']), ('\u33d5', &['\x6d', '\x69', '\x6c']),
+ ('\u33d6', &['\x6d', '\x6f', '\x6c']), ('\u33d7', &['\x50', '\x48']), ('\u33d8', &['\x70',
+ '\x2e', '\x6d', '\x2e']), ('\u33d9', &['\x50', '\x50', '\x4d']), ('\u33da', &['\x50',
+ '\x52']), ('\u33db', &['\x73', '\x72']), ('\u33dc', &['\x53', '\x76']), ('\u33dd', &['\x57',
+ '\x62']), ('\u33de', &['\x56', '\u2215', '\x6d']), ('\u33df', &['\x41', '\u2215', '\x6d']),
+ ('\u33e0', &['\x31', '\u65e5']), ('\u33e1', &['\x32', '\u65e5']), ('\u33e2', &['\x33',
+ '\u65e5']), ('\u33e3', &['\x34', '\u65e5']), ('\u33e4', &['\x35', '\u65e5']), ('\u33e5',
+ &['\x36', '\u65e5']), ('\u33e6', &['\x37', '\u65e5']), ('\u33e7', &['\x38', '\u65e5']),
+ ('\u33e8', &['\x39', '\u65e5']), ('\u33e9', &['\x31', '\x30', '\u65e5']), ('\u33ea',
+ &['\x31', '\x31', '\u65e5']), ('\u33eb', &['\x31', '\x32', '\u65e5']), ('\u33ec', &['\x31',
+ '\x33', '\u65e5']), ('\u33ed', &['\x31', '\x34', '\u65e5']), ('\u33ee', &['\x31', '\x35',
+ '\u65e5']), ('\u33ef', &['\x31', '\x36', '\u65e5']), ('\u33f0', &['\x31', '\x37',
+ '\u65e5']), ('\u33f1', &['\x31', '\x38', '\u65e5']), ('\u33f2', &['\x31', '\x39',
+ '\u65e5']), ('\u33f3', &['\x32', '\x30', '\u65e5']), ('\u33f4', &['\x32', '\x31',
+ '\u65e5']), ('\u33f5', &['\x32', '\x32', '\u65e5']), ('\u33f6', &['\x32', '\x33',
+ '\u65e5']), ('\u33f7', &['\x32', '\x34', '\u65e5']), ('\u33f8', &['\x32', '\x35',
+ '\u65e5']), ('\u33f9', &['\x32', '\x36', '\u65e5']), ('\u33fa', &['\x32', '\x37',
+ '\u65e5']), ('\u33fb', &['\x32', '\x38', '\u65e5']), ('\u33fc', &['\x32', '\x39',
+ '\u65e5']), ('\u33fd', &['\x33', '\x30', '\u65e5']), ('\u33fe', &['\x33', '\x31',
+ '\u65e5']), ('\u33ff', &['\x67', '\x61', '\x6c']), ('\ua770', &['\ua76f']), ('\ua7f8',
+ &['\u0126']), ('\ua7f9', &['\u0153']), ('\ufb00', &['\x66', '\x66']), ('\ufb01', &['\x66',
+ '\x69']), ('\ufb02', &['\x66', '\x6c']), ('\ufb03', &['\x66', '\x66', '\x69']), ('\ufb04',
+ &['\x66', '\x66', '\x6c']), ('\ufb05', &['\u017f', '\x74']), ('\ufb06', &['\x73', '\x74']),
+ ('\ufb13', &['\u0574', '\u0576']), ('\ufb14', &['\u0574', '\u0565']), ('\ufb15', &['\u0574',
+ '\u056b']), ('\ufb16', &['\u057e', '\u0576']), ('\ufb17', &['\u0574', '\u056d']), ('\ufb20',
+ &['\u05e2']), ('\ufb21', &['\u05d0']), ('\ufb22', &['\u05d3']), ('\ufb23', &['\u05d4']),
+ ('\ufb24', &['\u05db']), ('\ufb25', &['\u05dc']), ('\ufb26', &['\u05dd']), ('\ufb27',
+ &['\u05e8']), ('\ufb28', &['\u05ea']), ('\ufb29', &['\x2b']), ('\ufb4f', &['\u05d0',
+ '\u05dc']), ('\ufb50', &['\u0671']), ('\ufb51', &['\u0671']), ('\ufb52', &['\u067b']),
+ ('\ufb53', &['\u067b']), ('\ufb54', &['\u067b']), ('\ufb55', &['\u067b']), ('\ufb56',
+ &['\u067e']), ('\ufb57', &['\u067e']), ('\ufb58', &['\u067e']), ('\ufb59', &['\u067e']),
+ ('\ufb5a', &['\u0680']), ('\ufb5b', &['\u0680']), ('\ufb5c', &['\u0680']), ('\ufb5d',
+ &['\u0680']), ('\ufb5e', &['\u067a']), ('\ufb5f', &['\u067a']), ('\ufb60', &['\u067a']),
+ ('\ufb61', &['\u067a']), ('\ufb62', &['\u067f']), ('\ufb63', &['\u067f']), ('\ufb64',
+ &['\u067f']), ('\ufb65', &['\u067f']), ('\ufb66', &['\u0679']), ('\ufb67', &['\u0679']),
+ ('\ufb68', &['\u0679']), ('\ufb69', &['\u0679']), ('\ufb6a', &['\u06a4']), ('\ufb6b',
+ &['\u06a4']), ('\ufb6c', &['\u06a4']), ('\ufb6d', &['\u06a4']), ('\ufb6e', &['\u06a6']),
+ ('\ufb6f', &['\u06a6']), ('\ufb70', &['\u06a6']), ('\ufb71', &['\u06a6']), ('\ufb72',
+ &['\u0684']), ('\ufb73', &['\u0684']), ('\ufb74', &['\u0684']), ('\ufb75', &['\u0684']),
+ ('\ufb76', &['\u0683']), ('\ufb77', &['\u0683']), ('\ufb78', &['\u0683']), ('\ufb79',
+ &['\u0683']), ('\ufb7a', &['\u0686']), ('\ufb7b', &['\u0686']), ('\ufb7c', &['\u0686']),
+ ('\ufb7d', &['\u0686']), ('\ufb7e', &['\u0687']), ('\ufb7f', &['\u0687']), ('\ufb80',
+ &['\u0687']), ('\ufb81', &['\u0687']), ('\ufb82', &['\u068d']), ('\ufb83', &['\u068d']),
+ ('\ufb84', &['\u068c']), ('\ufb85', &['\u068c']), ('\ufb86', &['\u068e']), ('\ufb87',
+ &['\u068e']), ('\ufb88', &['\u0688']), ('\ufb89', &['\u0688']), ('\ufb8a', &['\u0698']),
+ ('\ufb8b', &['\u0698']), ('\ufb8c', &['\u0691']), ('\ufb8d', &['\u0691']), ('\ufb8e',
+ &['\u06a9']), ('\ufb8f', &['\u06a9']), ('\ufb90', &['\u06a9']), ('\ufb91', &['\u06a9']),
+ ('\ufb92', &['\u06af']), ('\ufb93', &['\u06af']), ('\ufb94', &['\u06af']), ('\ufb95',
+ &['\u06af']), ('\ufb96', &['\u06b3']), ('\ufb97', &['\u06b3']), ('\ufb98', &['\u06b3']),
+ ('\ufb99', &['\u06b3']), ('\ufb9a', &['\u06b1']), ('\ufb9b', &['\u06b1']), ('\ufb9c',
+ &['\u06b1']), ('\ufb9d', &['\u06b1']), ('\ufb9e', &['\u06ba']), ('\ufb9f', &['\u06ba']),
+ ('\ufba0', &['\u06bb']), ('\ufba1', &['\u06bb']), ('\ufba2', &['\u06bb']), ('\ufba3',
+ &['\u06bb']), ('\ufba4', &['\u06c0']), ('\ufba5', &['\u06c0']), ('\ufba6', &['\u06c1']),
+ ('\ufba7', &['\u06c1']), ('\ufba8', &['\u06c1']), ('\ufba9', &['\u06c1']), ('\ufbaa',
+ &['\u06be']), ('\ufbab', &['\u06be']), ('\ufbac', &['\u06be']), ('\ufbad', &['\u06be']),
+ ('\ufbae', &['\u06d2']), ('\ufbaf', &['\u06d2']), ('\ufbb0', &['\u06d3']), ('\ufbb1',
+ &['\u06d3']), ('\ufbd3', &['\u06ad']), ('\ufbd4', &['\u06ad']), ('\ufbd5', &['\u06ad']),
+ ('\ufbd6', &['\u06ad']), ('\ufbd7', &['\u06c7']), ('\ufbd8', &['\u06c7']), ('\ufbd9',
+ &['\u06c6']), ('\ufbda', &['\u06c6']), ('\ufbdb', &['\u06c8']), ('\ufbdc', &['\u06c8']),
+ ('\ufbdd', &['\u0677']), ('\ufbde', &['\u06cb']), ('\ufbdf', &['\u06cb']), ('\ufbe0',
+ &['\u06c5']), ('\ufbe1', &['\u06c5']), ('\ufbe2', &['\u06c9']), ('\ufbe3', &['\u06c9']),
+ ('\ufbe4', &['\u06d0']), ('\ufbe5', &['\u06d0']), ('\ufbe6', &['\u06d0']), ('\ufbe7',
+ &['\u06d0']), ('\ufbe8', &['\u0649']), ('\ufbe9', &['\u0649']), ('\ufbea', &['\u0626',
+ '\u0627']), ('\ufbeb', &['\u0626', '\u0627']), ('\ufbec', &['\u0626', '\u06d5']), ('\ufbed',
+ &['\u0626', '\u06d5']), ('\ufbee', &['\u0626', '\u0648']), ('\ufbef', &['\u0626',
+ '\u0648']), ('\ufbf0', &['\u0626', '\u06c7']), ('\ufbf1', &['\u0626', '\u06c7']), ('\ufbf2',
+ &['\u0626', '\u06c6']), ('\ufbf3', &['\u0626', '\u06c6']), ('\ufbf4', &['\u0626',
+ '\u06c8']), ('\ufbf5', &['\u0626', '\u06c8']), ('\ufbf6', &['\u0626', '\u06d0']), ('\ufbf7',
+ &['\u0626', '\u06d0']), ('\ufbf8', &['\u0626', '\u06d0']), ('\ufbf9', &['\u0626',
+ '\u0649']), ('\ufbfa', &['\u0626', '\u0649']), ('\ufbfb', &['\u0626', '\u0649']), ('\ufbfc',
+ &['\u06cc']), ('\ufbfd', &['\u06cc']), ('\ufbfe', &['\u06cc']), ('\ufbff', &['\u06cc']),
+ ('\ufc00', &['\u0626', '\u062c']), ('\ufc01', &['\u0626', '\u062d']), ('\ufc02', &['\u0626',
+ '\u0645']), ('\ufc03', &['\u0626', '\u0649']), ('\ufc04', &['\u0626', '\u064a']), ('\ufc05',
+ &['\u0628', '\u062c']), ('\ufc06', &['\u0628', '\u062d']), ('\ufc07', &['\u0628',
+ '\u062e']), ('\ufc08', &['\u0628', '\u0645']), ('\ufc09', &['\u0628', '\u0649']), ('\ufc0a',
+ &['\u0628', '\u064a']), ('\ufc0b', &['\u062a', '\u062c']), ('\ufc0c', &['\u062a',
+ '\u062d']), ('\ufc0d', &['\u062a', '\u062e']), ('\ufc0e', &['\u062a', '\u0645']), ('\ufc0f',
+ &['\u062a', '\u0649']), ('\ufc10', &['\u062a', '\u064a']), ('\ufc11', &['\u062b',
+ '\u062c']), ('\ufc12', &['\u062b', '\u0645']), ('\ufc13', &['\u062b', '\u0649']), ('\ufc14',
+ &['\u062b', '\u064a']), ('\ufc15', &['\u062c', '\u062d']), ('\ufc16', &['\u062c',
+ '\u0645']), ('\ufc17', &['\u062d', '\u062c']), ('\ufc18', &['\u062d', '\u0645']), ('\ufc19',
+ &['\u062e', '\u062c']), ('\ufc1a', &['\u062e', '\u062d']), ('\ufc1b', &['\u062e',
+ '\u0645']), ('\ufc1c', &['\u0633', '\u062c']), ('\ufc1d', &['\u0633', '\u062d']), ('\ufc1e',
+ &['\u0633', '\u062e']), ('\ufc1f', &['\u0633', '\u0645']), ('\ufc20', &['\u0635',
+ '\u062d']), ('\ufc21', &['\u0635', '\u0645']), ('\ufc22', &['\u0636', '\u062c']), ('\ufc23',
+ &['\u0636', '\u062d']), ('\ufc24', &['\u0636', '\u062e']), ('\ufc25', &['\u0636',
+ '\u0645']), ('\ufc26', &['\u0637', '\u062d']), ('\ufc27', &['\u0637', '\u0645']), ('\ufc28',
+ &['\u0638', '\u0645']), ('\ufc29', &['\u0639', '\u062c']), ('\ufc2a', &['\u0639',
+ '\u0645']), ('\ufc2b', &['\u063a', '\u062c']), ('\ufc2c', &['\u063a', '\u0645']), ('\ufc2d',
+ &['\u0641', '\u062c']), ('\ufc2e', &['\u0641', '\u062d']), ('\ufc2f', &['\u0641',
+ '\u062e']), ('\ufc30', &['\u0641', '\u0645']), ('\ufc31', &['\u0641', '\u0649']), ('\ufc32',
+ &['\u0641', '\u064a']), ('\ufc33', &['\u0642', '\u062d']), ('\ufc34', &['\u0642',
+ '\u0645']), ('\ufc35', &['\u0642', '\u0649']), ('\ufc36', &['\u0642', '\u064a']), ('\ufc37',
+ &['\u0643', '\u0627']), ('\ufc38', &['\u0643', '\u062c']), ('\ufc39', &['\u0643',
+ '\u062d']), ('\ufc3a', &['\u0643', '\u062e']), ('\ufc3b', &['\u0643', '\u0644']), ('\ufc3c',
+ &['\u0643', '\u0645']), ('\ufc3d', &['\u0643', '\u0649']), ('\ufc3e', &['\u0643',
+ '\u064a']), ('\ufc3f', &['\u0644', '\u062c']), ('\ufc40', &['\u0644', '\u062d']), ('\ufc41',
+ &['\u0644', '\u062e']), ('\ufc42', &['\u0644', '\u0645']), ('\ufc43', &['\u0644',
+ '\u0649']), ('\ufc44', &['\u0644', '\u064a']), ('\ufc45', &['\u0645', '\u062c']), ('\ufc46',
+ &['\u0645', '\u062d']), ('\ufc47', &['\u0645', '\u062e']), ('\ufc48', &['\u0645',
+ '\u0645']), ('\ufc49', &['\u0645', '\u0649']), ('\ufc4a', &['\u0645', '\u064a']), ('\ufc4b',
+ &['\u0646', '\u062c']), ('\ufc4c', &['\u0646', '\u062d']), ('\ufc4d', &['\u0646',
+ '\u062e']), ('\ufc4e', &['\u0646', '\u0645']), ('\ufc4f', &['\u0646', '\u0649']), ('\ufc50',
+ &['\u0646', '\u064a']), ('\ufc51', &['\u0647', '\u062c']), ('\ufc52', &['\u0647',
+ '\u0645']), ('\ufc53', &['\u0647', '\u0649']), ('\ufc54', &['\u0647', '\u064a']), ('\ufc55',
+ &['\u064a', '\u062c']), ('\ufc56', &['\u064a', '\u062d']), ('\ufc57', &['\u064a',
+ '\u062e']), ('\ufc58', &['\u064a', '\u0645']), ('\ufc59', &['\u064a', '\u0649']), ('\ufc5a',
+ &['\u064a', '\u064a']), ('\ufc5b', &['\u0630', '\u0670']), ('\ufc5c', &['\u0631',
+ '\u0670']), ('\ufc5d', &['\u0649', '\u0670']), ('\ufc5e', &['\x20', '\u064c', '\u0651']),
+ ('\ufc5f', &['\x20', '\u064d', '\u0651']), ('\ufc60', &['\x20', '\u064e', '\u0651']),
+ ('\ufc61', &['\x20', '\u064f', '\u0651']), ('\ufc62', &['\x20', '\u0650', '\u0651']),
+ ('\ufc63', &['\x20', '\u0651', '\u0670']), ('\ufc64', &['\u0626', '\u0631']), ('\ufc65',
+ &['\u0626', '\u0632']), ('\ufc66', &['\u0626', '\u0645']), ('\ufc67', &['\u0626',
+ '\u0646']), ('\ufc68', &['\u0626', '\u0649']), ('\ufc69', &['\u0626', '\u064a']), ('\ufc6a',
+ &['\u0628', '\u0631']), ('\ufc6b', &['\u0628', '\u0632']), ('\ufc6c', &['\u0628',
+ '\u0645']), ('\ufc6d', &['\u0628', '\u0646']), ('\ufc6e', &['\u0628', '\u0649']), ('\ufc6f',
+ &['\u0628', '\u064a']), ('\ufc70', &['\u062a', '\u0631']), ('\ufc71', &['\u062a',
+ '\u0632']), ('\ufc72', &['\u062a', '\u0645']), ('\ufc73', &['\u062a', '\u0646']), ('\ufc74',
+ &['\u062a', '\u0649']), ('\ufc75', &['\u062a', '\u064a']), ('\ufc76', &['\u062b',
+ '\u0631']), ('\ufc77', &['\u062b', '\u0632']), ('\ufc78', &['\u062b', '\u0645']), ('\ufc79',
+ &['\u062b', '\u0646']), ('\ufc7a', &['\u062b', '\u0649']), ('\ufc7b', &['\u062b',
+ '\u064a']), ('\ufc7c', &['\u0641', '\u0649']), ('\ufc7d', &['\u0641', '\u064a']), ('\ufc7e',
+ &['\u0642', '\u0649']), ('\ufc7f', &['\u0642', '\u064a']), ('\ufc80', &['\u0643',
+ '\u0627']), ('\ufc81', &['\u0643', '\u0644']), ('\ufc82', &['\u0643', '\u0645']), ('\ufc83',
+ &['\u0643', '\u0649']), ('\ufc84', &['\u0643', '\u064a']), ('\ufc85', &['\u0644',
+ '\u0645']), ('\ufc86', &['\u0644', '\u0649']), ('\ufc87', &['\u0644', '\u064a']), ('\ufc88',
+ &['\u0645', '\u0627']), ('\ufc89', &['\u0645', '\u0645']), ('\ufc8a', &['\u0646',
+ '\u0631']), ('\ufc8b', &['\u0646', '\u0632']), ('\ufc8c', &['\u0646', '\u0645']), ('\ufc8d',
+ &['\u0646', '\u0646']), ('\ufc8e', &['\u0646', '\u0649']), ('\ufc8f', &['\u0646',
+ '\u064a']), ('\ufc90', &['\u0649', '\u0670']), ('\ufc91', &['\u064a', '\u0631']), ('\ufc92',
+ &['\u064a', '\u0632']), ('\ufc93', &['\u064a', '\u0645']), ('\ufc94', &['\u064a',
+ '\u0646']), ('\ufc95', &['\u064a', '\u0649']), ('\ufc96', &['\u064a', '\u064a']), ('\ufc97',
+ &['\u0626', '\u062c']), ('\ufc98', &['\u0626', '\u062d']), ('\ufc99', &['\u0626',
+ '\u062e']), ('\ufc9a', &['\u0626', '\u0645']), ('\ufc9b', &['\u0626', '\u0647']), ('\ufc9c',
+ &['\u0628', '\u062c']), ('\ufc9d', &['\u0628', '\u062d']), ('\ufc9e', &['\u0628',
+ '\u062e']), ('\ufc9f', &['\u0628', '\u0645']), ('\ufca0', &['\u0628', '\u0647']), ('\ufca1',
+ &['\u062a', '\u062c']), ('\ufca2', &['\u062a', '\u062d']), ('\ufca3', &['\u062a',
+ '\u062e']), ('\ufca4', &['\u062a', '\u0645']), ('\ufca5', &['\u062a', '\u0647']), ('\ufca6',
+ &['\u062b', '\u0645']), ('\ufca7', &['\u062c', '\u062d']), ('\ufca8', &['\u062c',
+ '\u0645']), ('\ufca9', &['\u062d', '\u062c']), ('\ufcaa', &['\u062d', '\u0645']), ('\ufcab',
+ &['\u062e', '\u062c']), ('\ufcac', &['\u062e', '\u0645']), ('\ufcad', &['\u0633',
+ '\u062c']), ('\ufcae', &['\u0633', '\u062d']), ('\ufcaf', &['\u0633', '\u062e']), ('\ufcb0',
+ &['\u0633', '\u0645']), ('\ufcb1', &['\u0635', '\u062d']), ('\ufcb2', &['\u0635',
+ '\u062e']), ('\ufcb3', &['\u0635', '\u0645']), ('\ufcb4', &['\u0636', '\u062c']), ('\ufcb5',
+ &['\u0636', '\u062d']), ('\ufcb6', &['\u0636', '\u062e']), ('\ufcb7', &['\u0636',
+ '\u0645']), ('\ufcb8', &['\u0637', '\u062d']), ('\ufcb9', &['\u0638', '\u0645']), ('\ufcba',
+ &['\u0639', '\u062c']), ('\ufcbb', &['\u0639', '\u0645']), ('\ufcbc', &['\u063a',
+ '\u062c']), ('\ufcbd', &['\u063a', '\u0645']), ('\ufcbe', &['\u0641', '\u062c']), ('\ufcbf',
+ &['\u0641', '\u062d']), ('\ufcc0', &['\u0641', '\u062e']), ('\ufcc1', &['\u0641',
+ '\u0645']), ('\ufcc2', &['\u0642', '\u062d']), ('\ufcc3', &['\u0642', '\u0645']), ('\ufcc4',
+ &['\u0643', '\u062c']), ('\ufcc5', &['\u0643', '\u062d']), ('\ufcc6', &['\u0643',
+ '\u062e']), ('\ufcc7', &['\u0643', '\u0644']), ('\ufcc8', &['\u0643', '\u0645']), ('\ufcc9',
+ &['\u0644', '\u062c']), ('\ufcca', &['\u0644', '\u062d']), ('\ufccb', &['\u0644',
+ '\u062e']), ('\ufccc', &['\u0644', '\u0645']), ('\ufccd', &['\u0644', '\u0647']), ('\ufcce',
+ &['\u0645', '\u062c']), ('\ufccf', &['\u0645', '\u062d']), ('\ufcd0', &['\u0645',
+ '\u062e']), ('\ufcd1', &['\u0645', '\u0645']), ('\ufcd2', &['\u0646', '\u062c']), ('\ufcd3',
+ &['\u0646', '\u062d']), ('\ufcd4', &['\u0646', '\u062e']), ('\ufcd5', &['\u0646',
+ '\u0645']), ('\ufcd6', &['\u0646', '\u0647']), ('\ufcd7', &['\u0647', '\u062c']), ('\ufcd8',
+ &['\u0647', '\u0645']), ('\ufcd9', &['\u0647', '\u0670']), ('\ufcda', &['\u064a',
+ '\u062c']), ('\ufcdb', &['\u064a', '\u062d']), ('\ufcdc', &['\u064a', '\u062e']), ('\ufcdd',
+ &['\u064a', '\u0645']), ('\ufcde', &['\u064a', '\u0647']), ('\ufcdf', &['\u0626',
+ '\u0645']), ('\ufce0', &['\u0626', '\u0647']), ('\ufce1', &['\u0628', '\u0645']), ('\ufce2',
+ &['\u0628', '\u0647']), ('\ufce3', &['\u062a', '\u0645']), ('\ufce4', &['\u062a',
+ '\u0647']), ('\ufce5', &['\u062b', '\u0645']), ('\ufce6', &['\u062b', '\u0647']), ('\ufce7',
+ &['\u0633', '\u0645']), ('\ufce8', &['\u0633', '\u0647']), ('\ufce9', &['\u0634',
+ '\u0645']), ('\ufcea', &['\u0634', '\u0647']), ('\ufceb', &['\u0643', '\u0644']), ('\ufcec',
+ &['\u0643', '\u0645']), ('\ufced', &['\u0644', '\u0645']), ('\ufcee', &['\u0646',
+ '\u0645']), ('\ufcef', &['\u0646', '\u0647']), ('\ufcf0', &['\u064a', '\u0645']), ('\ufcf1',
+ &['\u064a', '\u0647']), ('\ufcf2', &['\u0640', '\u064e', '\u0651']), ('\ufcf3', &['\u0640',
+ '\u064f', '\u0651']), ('\ufcf4', &['\u0640', '\u0650', '\u0651']), ('\ufcf5', &['\u0637',
+ '\u0649']), ('\ufcf6', &['\u0637', '\u064a']), ('\ufcf7', &['\u0639', '\u0649']), ('\ufcf8',
+ &['\u0639', '\u064a']), ('\ufcf9', &['\u063a', '\u0649']), ('\ufcfa', &['\u063a',
+ '\u064a']), ('\ufcfb', &['\u0633', '\u0649']), ('\ufcfc', &['\u0633', '\u064a']), ('\ufcfd',
+ &['\u0634', '\u0649']), ('\ufcfe', &['\u0634', '\u064a']), ('\ufcff', &['\u062d',
+ '\u0649']), ('\ufd00', &['\u062d', '\u064a']), ('\ufd01', &['\u062c', '\u0649']), ('\ufd02',
+ &['\u062c', '\u064a']), ('\ufd03', &['\u062e', '\u0649']), ('\ufd04', &['\u062e',
+ '\u064a']), ('\ufd05', &['\u0635', '\u0649']), ('\ufd06', &['\u0635', '\u064a']), ('\ufd07',
+ &['\u0636', '\u0649']), ('\ufd08', &['\u0636', '\u064a']), ('\ufd09', &['\u0634',
+ '\u062c']), ('\ufd0a', &['\u0634', '\u062d']), ('\ufd0b', &['\u0634', '\u062e']), ('\ufd0c',
+ &['\u0634', '\u0645']), ('\ufd0d', &['\u0634', '\u0631']), ('\ufd0e', &['\u0633',
+ '\u0631']), ('\ufd0f', &['\u0635', '\u0631']), ('\ufd10', &['\u0636', '\u0631']), ('\ufd11',
+ &['\u0637', '\u0649']), ('\ufd12', &['\u0637', '\u064a']), ('\ufd13', &['\u0639',
+ '\u0649']), ('\ufd14', &['\u0639', '\u064a']), ('\ufd15', &['\u063a', '\u0649']), ('\ufd16',
+ &['\u063a', '\u064a']), ('\ufd17', &['\u0633', '\u0649']), ('\ufd18', &['\u0633',
+ '\u064a']), ('\ufd19', &['\u0634', '\u0649']), ('\ufd1a', &['\u0634', '\u064a']), ('\ufd1b',
+ &['\u062d', '\u0649']), ('\ufd1c', &['\u062d', '\u064a']), ('\ufd1d', &['\u062c',
+ '\u0649']), ('\ufd1e', &['\u062c', '\u064a']), ('\ufd1f', &['\u062e', '\u0649']), ('\ufd20',
+ &['\u062e', '\u064a']), ('\ufd21', &['\u0635', '\u0649']), ('\ufd22', &['\u0635',
+ '\u064a']), ('\ufd23', &['\u0636', '\u0649']), ('\ufd24', &['\u0636', '\u064a']), ('\ufd25',
+ &['\u0634', '\u062c']), ('\ufd26', &['\u0634', '\u062d']), ('\ufd27', &['\u0634',
+ '\u062e']), ('\ufd28', &['\u0634', '\u0645']), ('\ufd29', &['\u0634', '\u0631']), ('\ufd2a',
+ &['\u0633', '\u0631']), ('\ufd2b', &['\u0635', '\u0631']), ('\ufd2c', &['\u0636',
+ '\u0631']), ('\ufd2d', &['\u0634', '\u062c']), ('\ufd2e', &['\u0634', '\u062d']), ('\ufd2f',
+ &['\u0634', '\u062e']), ('\ufd30', &['\u0634', '\u0645']), ('\ufd31', &['\u0633',
+ '\u0647']), ('\ufd32', &['\u0634', '\u0647']), ('\ufd33', &['\u0637', '\u0645']), ('\ufd34',
+ &['\u0633', '\u062c']), ('\ufd35', &['\u0633', '\u062d']), ('\ufd36', &['\u0633',
+ '\u062e']), ('\ufd37', &['\u0634', '\u062c']), ('\ufd38', &['\u0634', '\u062d']), ('\ufd39',
+ &['\u0634', '\u062e']), ('\ufd3a', &['\u0637', '\u0645']), ('\ufd3b', &['\u0638',
+ '\u0645']), ('\ufd3c', &['\u0627', '\u064b']), ('\ufd3d', &['\u0627', '\u064b']), ('\ufd50',
+ &['\u062a', '\u062c', '\u0645']), ('\ufd51', &['\u062a', '\u062d', '\u062c']), ('\ufd52',
+ &['\u062a', '\u062d', '\u062c']), ('\ufd53', &['\u062a', '\u062d', '\u0645']), ('\ufd54',
+ &['\u062a', '\u062e', '\u0645']), ('\ufd55', &['\u062a', '\u0645', '\u062c']), ('\ufd56',
+ &['\u062a', '\u0645', '\u062d']), ('\ufd57', &['\u062a', '\u0645', '\u062e']), ('\ufd58',
+ &['\u062c', '\u0645', '\u062d']), ('\ufd59', &['\u062c', '\u0645', '\u062d']), ('\ufd5a',
+ &['\u062d', '\u0645', '\u064a']), ('\ufd5b', &['\u062d', '\u0645', '\u0649']), ('\ufd5c',
+ &['\u0633', '\u062d', '\u062c']), ('\ufd5d', &['\u0633', '\u062c', '\u062d']), ('\ufd5e',
+ &['\u0633', '\u062c', '\u0649']), ('\ufd5f', &['\u0633', '\u0645', '\u062d']), ('\ufd60',
+ &['\u0633', '\u0645', '\u062d']), ('\ufd61', &['\u0633', '\u0645', '\u062c']), ('\ufd62',
+ &['\u0633', '\u0645', '\u0645']), ('\ufd63', &['\u0633', '\u0645', '\u0645']), ('\ufd64',
+ &['\u0635', '\u062d', '\u062d']), ('\ufd65', &['\u0635', '\u062d', '\u062d']), ('\ufd66',
+ &['\u0635', '\u0645', '\u0645']), ('\ufd67', &['\u0634', '\u062d', '\u0645']), ('\ufd68',
+ &['\u0634', '\u062d', '\u0645']), ('\ufd69', &['\u0634', '\u062c', '\u064a']), ('\ufd6a',
+ &['\u0634', '\u0645', '\u062e']), ('\ufd6b', &['\u0634', '\u0645', '\u062e']), ('\ufd6c',
+ &['\u0634', '\u0645', '\u0645']), ('\ufd6d', &['\u0634', '\u0645', '\u0645']), ('\ufd6e',
+ &['\u0636', '\u062d', '\u0649']), ('\ufd6f', &['\u0636', '\u062e', '\u0645']), ('\ufd70',
+ &['\u0636', '\u062e', '\u0645']), ('\ufd71', &['\u0637', '\u0645', '\u062d']), ('\ufd72',
+ &['\u0637', '\u0645', '\u062d']), ('\ufd73', &['\u0637', '\u0645', '\u0645']), ('\ufd74',
+ &['\u0637', '\u0645', '\u064a']), ('\ufd75', &['\u0639', '\u062c', '\u0645']), ('\ufd76',
+ &['\u0639', '\u0645', '\u0645']), ('\ufd77', &['\u0639', '\u0645', '\u0645']), ('\ufd78',
+ &['\u0639', '\u0645', '\u0649']), ('\ufd79', &['\u063a', '\u0645', '\u0645']), ('\ufd7a',
+ &['\u063a', '\u0645', '\u064a']), ('\ufd7b', &['\u063a', '\u0645', '\u0649']), ('\ufd7c',
+ &['\u0641', '\u062e', '\u0645']), ('\ufd7d', &['\u0641', '\u062e', '\u0645']), ('\ufd7e',
+ &['\u0642', '\u0645', '\u062d']), ('\ufd7f', &['\u0642', '\u0645', '\u0645']), ('\ufd80',
+ &['\u0644', '\u062d', '\u0645']), ('\ufd81', &['\u0644', '\u062d', '\u064a']), ('\ufd82',
+ &['\u0644', '\u062d', '\u0649']), ('\ufd83', &['\u0644', '\u062c', '\u062c']), ('\ufd84',
+ &['\u0644', '\u062c', '\u062c']), ('\ufd85', &['\u0644', '\u062e', '\u0645']), ('\ufd86',
+ &['\u0644', '\u062e', '\u0645']), ('\ufd87', &['\u0644', '\u0645', '\u062d']), ('\ufd88',
+ &['\u0644', '\u0645', '\u062d']), ('\ufd89', &['\u0645', '\u062d', '\u062c']), ('\ufd8a',
+ &['\u0645', '\u062d', '\u0645']), ('\ufd8b', &['\u0645', '\u062d', '\u064a']), ('\ufd8c',
+ &['\u0645', '\u062c', '\u062d']), ('\ufd8d', &['\u0645', '\u062c', '\u0645']), ('\ufd8e',
+ &['\u0645', '\u062e', '\u062c']), ('\ufd8f', &['\u0645', '\u062e', '\u0645']), ('\ufd92',
+ &['\u0645', '\u062c', '\u062e']), ('\ufd93', &['\u0647', '\u0645', '\u062c']), ('\ufd94',
+ &['\u0647', '\u0645', '\u0645']), ('\ufd95', &['\u0646', '\u062d', '\u0645']), ('\ufd96',
+ &['\u0646', '\u062d', '\u0649']), ('\ufd97', &['\u0646', '\u062c', '\u0645']), ('\ufd98',
+ &['\u0646', '\u062c', '\u0645']), ('\ufd99', &['\u0646', '\u062c', '\u0649']), ('\ufd9a',
+ &['\u0646', '\u0645', '\u064a']), ('\ufd9b', &['\u0646', '\u0645', '\u0649']), ('\ufd9c',
+ &['\u064a', '\u0645', '\u0645']), ('\ufd9d', &['\u064a', '\u0645', '\u0645']), ('\ufd9e',
+ &['\u0628', '\u062e', '\u064a']), ('\ufd9f', &['\u062a', '\u062c', '\u064a']), ('\ufda0',
+ &['\u062a', '\u062c', '\u0649']), ('\ufda1', &['\u062a', '\u062e', '\u064a']), ('\ufda2',
+ &['\u062a', '\u062e', '\u0649']), ('\ufda3', &['\u062a', '\u0645', '\u064a']), ('\ufda4',
+ &['\u062a', '\u0645', '\u0649']), ('\ufda5', &['\u062c', '\u0645', '\u064a']), ('\ufda6',
+ &['\u062c', '\u062d', '\u0649']), ('\ufda7', &['\u062c', '\u0645', '\u0649']), ('\ufda8',
+ &['\u0633', '\u062e', '\u0649']), ('\ufda9', &['\u0635', '\u062d', '\u064a']), ('\ufdaa',
+ &['\u0634', '\u062d', '\u064a']), ('\ufdab', &['\u0636', '\u062d', '\u064a']), ('\ufdac',
+ &['\u0644', '\u062c', '\u064a']), ('\ufdad', &['\u0644', '\u0645', '\u064a']), ('\ufdae',
+ &['\u064a', '\u062d', '\u064a']), ('\ufdaf', &['\u064a', '\u062c', '\u064a']), ('\ufdb0',
+ &['\u064a', '\u0645', '\u064a']), ('\ufdb1', &['\u0645', '\u0645', '\u064a']), ('\ufdb2',
+ &['\u0642', '\u0645', '\u064a']), ('\ufdb3', &['\u0646', '\u062d', '\u064a']), ('\ufdb4',
+ &['\u0642', '\u0645', '\u062d']), ('\ufdb5', &['\u0644', '\u062d', '\u0645']), ('\ufdb6',
+ &['\u0639', '\u0645', '\u064a']), ('\ufdb7', &['\u0643', '\u0645', '\u064a']), ('\ufdb8',
+ &['\u0646', '\u062c', '\u062d']), ('\ufdb9', &['\u0645', '\u062e', '\u064a']), ('\ufdba',
+ &['\u0644', '\u062c', '\u0645']), ('\ufdbb', &['\u0643', '\u0645', '\u0645']), ('\ufdbc',
+ &['\u0644', '\u062c', '\u0645']), ('\ufdbd', &['\u0646', '\u062c', '\u062d']), ('\ufdbe',
+ &['\u062c', '\u062d', '\u064a']), ('\ufdbf', &['\u062d', '\u062c', '\u064a']), ('\ufdc0',
+ &['\u0645', '\u062c', '\u064a']), ('\ufdc1', &['\u0641', '\u0645', '\u064a']), ('\ufdc2',
+ &['\u0628', '\u062d', '\u064a']), ('\ufdc3', &['\u0643', '\u0645', '\u0645']), ('\ufdc4',
+ &['\u0639', '\u062c', '\u0645']), ('\ufdc5', &['\u0635', '\u0645', '\u0645']), ('\ufdc6',
+ &['\u0633', '\u062e', '\u064a']), ('\ufdc7', &['\u0646', '\u062c', '\u064a']), ('\ufdf0',
+ &['\u0635', '\u0644', '\u06d2']), ('\ufdf1', &['\u0642', '\u0644', '\u06d2']), ('\ufdf2',
+ &['\u0627', '\u0644', '\u0644', '\u0647']), ('\ufdf3', &['\u0627', '\u0643', '\u0628',
+ '\u0631']), ('\ufdf4', &['\u0645', '\u062d', '\u0645', '\u062f']), ('\ufdf5', &['\u0635',
+ '\u0644', '\u0639', '\u0645']), ('\ufdf6', &['\u0631', '\u0633', '\u0648', '\u0644']),
+ ('\ufdf7', &['\u0639', '\u0644', '\u064a', '\u0647']), ('\ufdf8', &['\u0648', '\u0633',
+ '\u0644', '\u0645']), ('\ufdf9', &['\u0635', '\u0644', '\u0649']), ('\ufdfa', &['\u0635',
+ '\u0644', '\u0649', '\x20', '\u0627', '\u0644', '\u0644', '\u0647', '\x20', '\u0639',
+ '\u0644', '\u064a', '\u0647', '\x20', '\u0648', '\u0633', '\u0644', '\u0645']), ('\ufdfb',
+ &['\u062c', '\u0644', '\x20', '\u062c', '\u0644', '\u0627', '\u0644', '\u0647']), ('\ufdfc',
+ &['\u0631', '\u06cc', '\u0627', '\u0644']), ('\ufe10', &['\x2c']), ('\ufe11', &['\u3001']),
+ ('\ufe12', &['\u3002']), ('\ufe13', &['\x3a']), ('\ufe14', &['\x3b']), ('\ufe15',
+ &['\x21']), ('\ufe16', &['\x3f']), ('\ufe17', &['\u3016']), ('\ufe18', &['\u3017']),
+ ('\ufe19', &['\u2026']), ('\ufe30', &['\u2025']), ('\ufe31', &['\u2014']), ('\ufe32',
+ &['\u2013']), ('\ufe33', &['\x5f']), ('\ufe34', &['\x5f']), ('\ufe35', &['\x28']),
+ ('\ufe36', &['\x29']), ('\ufe37', &['\x7b']), ('\ufe38', &['\x7d']), ('\ufe39',
+ &['\u3014']), ('\ufe3a', &['\u3015']), ('\ufe3b', &['\u3010']), ('\ufe3c', &['\u3011']),
+ ('\ufe3d', &['\u300a']), ('\ufe3e', &['\u300b']), ('\ufe3f', &['\u3008']), ('\ufe40',
+ &['\u3009']), ('\ufe41', &['\u300c']), ('\ufe42', &['\u300d']), ('\ufe43', &['\u300e']),
+ ('\ufe44', &['\u300f']), ('\ufe47', &['\x5b']), ('\ufe48', &['\x5d']), ('\ufe49',
+ &['\u203e']), ('\ufe4a', &['\u203e']), ('\ufe4b', &['\u203e']), ('\ufe4c', &['\u203e']),
+ ('\ufe4d', &['\x5f']), ('\ufe4e', &['\x5f']), ('\ufe4f', &['\x5f']), ('\ufe50', &['\x2c']),
+ ('\ufe51', &['\u3001']), ('\ufe52', &['\x2e']), ('\ufe54', &['\x3b']), ('\ufe55',
+ &['\x3a']), ('\ufe56', &['\x3f']), ('\ufe57', &['\x21']), ('\ufe58', &['\u2014']),
+ ('\ufe59', &['\x28']), ('\ufe5a', &['\x29']), ('\ufe5b', &['\x7b']), ('\ufe5c', &['\x7d']),
+ ('\ufe5d', &['\u3014']), ('\ufe5e', &['\u3015']), ('\ufe5f', &['\x23']), ('\ufe60',
+ &['\x26']), ('\ufe61', &['\x2a']), ('\ufe62', &['\x2b']), ('\ufe63', &['\x2d']), ('\ufe64',
+ &['\x3c']), ('\ufe65', &['\x3e']), ('\ufe66', &['\x3d']), ('\ufe68', &['\x5c']), ('\ufe69',
+ &['\x24']), ('\ufe6a', &['\x25']), ('\ufe6b', &['\x40']), ('\ufe70', &['\x20', '\u064b']),
+ ('\ufe71', &['\u0640', '\u064b']), ('\ufe72', &['\x20', '\u064c']), ('\ufe74', &['\x20',
+ '\u064d']), ('\ufe76', &['\x20', '\u064e']), ('\ufe77', &['\u0640', '\u064e']), ('\ufe78',
+ &['\x20', '\u064f']), ('\ufe79', &['\u0640', '\u064f']), ('\ufe7a', &['\x20', '\u0650']),
+ ('\ufe7b', &['\u0640', '\u0650']), ('\ufe7c', &['\x20', '\u0651']), ('\ufe7d', &['\u0640',
+ '\u0651']), ('\ufe7e', &['\x20', '\u0652']), ('\ufe7f', &['\u0640', '\u0652']), ('\ufe80',
+ &['\u0621']), ('\ufe81', &['\u0622']), ('\ufe82', &['\u0622']), ('\ufe83', &['\u0623']),
+ ('\ufe84', &['\u0623']), ('\ufe85', &['\u0624']), ('\ufe86', &['\u0624']), ('\ufe87',
+ &['\u0625']), ('\ufe88', &['\u0625']), ('\ufe89', &['\u0626']), ('\ufe8a', &['\u0626']),
+ ('\ufe8b', &['\u0626']), ('\ufe8c', &['\u0626']), ('\ufe8d', &['\u0627']), ('\ufe8e',
+ &['\u0627']), ('\ufe8f', &['\u0628']), ('\ufe90', &['\u0628']), ('\ufe91', &['\u0628']),
+ ('\ufe92', &['\u0628']), ('\ufe93', &['\u0629']), ('\ufe94', &['\u0629']), ('\ufe95',
+ &['\u062a']), ('\ufe96', &['\u062a']), ('\ufe97', &['\u062a']), ('\ufe98', &['\u062a']),
+ ('\ufe99', &['\u062b']), ('\ufe9a', &['\u062b']), ('\ufe9b', &['\u062b']), ('\ufe9c',
+ &['\u062b']), ('\ufe9d', &['\u062c']), ('\ufe9e', &['\u062c']), ('\ufe9f', &['\u062c']),
+ ('\ufea0', &['\u062c']), ('\ufea1', &['\u062d']), ('\ufea2', &['\u062d']), ('\ufea3',
+ &['\u062d']), ('\ufea4', &['\u062d']), ('\ufea5', &['\u062e']), ('\ufea6', &['\u062e']),
+ ('\ufea7', &['\u062e']), ('\ufea8', &['\u062e']), ('\ufea9', &['\u062f']), ('\ufeaa',
+ &['\u062f']), ('\ufeab', &['\u0630']), ('\ufeac', &['\u0630']), ('\ufead', &['\u0631']),
+ ('\ufeae', &['\u0631']), ('\ufeaf', &['\u0632']), ('\ufeb0', &['\u0632']), ('\ufeb1',
+ &['\u0633']), ('\ufeb2', &['\u0633']), ('\ufeb3', &['\u0633']), ('\ufeb4', &['\u0633']),
+ ('\ufeb5', &['\u0634']), ('\ufeb6', &['\u0634']), ('\ufeb7', &['\u0634']), ('\ufeb8',
+ &['\u0634']), ('\ufeb9', &['\u0635']), ('\ufeba', &['\u0635']), ('\ufebb', &['\u0635']),
+ ('\ufebc', &['\u0635']), ('\ufebd', &['\u0636']), ('\ufebe', &['\u0636']), ('\ufebf',
+ &['\u0636']), ('\ufec0', &['\u0636']), ('\ufec1', &['\u0637']), ('\ufec2', &['\u0637']),
+ ('\ufec3', &['\u0637']), ('\ufec4', &['\u0637']), ('\ufec5', &['\u0638']), ('\ufec6',
+ &['\u0638']), ('\ufec7', &['\u0638']), ('\ufec8', &['\u0638']), ('\ufec9', &['\u0639']),
+ ('\ufeca', &['\u0639']), ('\ufecb', &['\u0639']), ('\ufecc', &['\u0639']), ('\ufecd',
+ &['\u063a']), ('\ufece', &['\u063a']), ('\ufecf', &['\u063a']), ('\ufed0', &['\u063a']),
+ ('\ufed1', &['\u0641']), ('\ufed2', &['\u0641']), ('\ufed3', &['\u0641']), ('\ufed4',
+ &['\u0641']), ('\ufed5', &['\u0642']), ('\ufed6', &['\u0642']), ('\ufed7', &['\u0642']),
+ ('\ufed8', &['\u0642']), ('\ufed9', &['\u0643']), ('\ufeda', &['\u0643']), ('\ufedb',
+ &['\u0643']), ('\ufedc', &['\u0643']), ('\ufedd', &['\u0644']), ('\ufede', &['\u0644']),
+ ('\ufedf', &['\u0644']), ('\ufee0', &['\u0644']), ('\ufee1', &['\u0645']), ('\ufee2',
+ &['\u0645']), ('\ufee3', &['\u0645']), ('\ufee4', &['\u0645']), ('\ufee5', &['\u0646']),
+ ('\ufee6', &['\u0646']), ('\ufee7', &['\u0646']), ('\ufee8', &['\u0646']), ('\ufee9',
+ &['\u0647']), ('\ufeea', &['\u0647']), ('\ufeeb', &['\u0647']), ('\ufeec', &['\u0647']),
+ ('\ufeed', &['\u0648']), ('\ufeee', &['\u0648']), ('\ufeef', &['\u0649']), ('\ufef0',
+ &['\u0649']), ('\ufef1', &['\u064a']), ('\ufef2', &['\u064a']), ('\ufef3', &['\u064a']),
+ ('\ufef4', &['\u064a']), ('\ufef5', &['\u0644', '\u0622']), ('\ufef6', &['\u0644',
+ '\u0622']), ('\ufef7', &['\u0644', '\u0623']), ('\ufef8', &['\u0644', '\u0623']), ('\ufef9',
+ &['\u0644', '\u0625']), ('\ufefa', &['\u0644', '\u0625']), ('\ufefb', &['\u0644',
+ '\u0627']), ('\ufefc', &['\u0644', '\u0627']), ('\uff01', &['\x21']), ('\uff02', &['\x22']),
+ ('\uff03', &['\x23']), ('\uff04', &['\x24']), ('\uff05', &['\x25']), ('\uff06', &['\x26']),
+ ('\uff07', &['\x27']), ('\uff08', &['\x28']), ('\uff09', &['\x29']), ('\uff0a', &['\x2a']),
+ ('\uff0b', &['\x2b']), ('\uff0c', &['\x2c']), ('\uff0d', &['\x2d']), ('\uff0e', &['\x2e']),
+ ('\uff0f', &['\x2f']), ('\uff10', &['\x30']), ('\uff11', &['\x31']), ('\uff12', &['\x32']),
+ ('\uff13', &['\x33']), ('\uff14', &['\x34']), ('\uff15', &['\x35']), ('\uff16', &['\x36']),
+ ('\uff17', &['\x37']), ('\uff18', &['\x38']), ('\uff19', &['\x39']), ('\uff1a', &['\x3a']),
+ ('\uff1b', &['\x3b']), ('\uff1c', &['\x3c']), ('\uff1d', &['\x3d']), ('\uff1e', &['\x3e']),
+ ('\uff1f', &['\x3f']), ('\uff20', &['\x40']), ('\uff21', &['\x41']), ('\uff22', &['\x42']),
+ ('\uff23', &['\x43']), ('\uff24', &['\x44']), ('\uff25', &['\x45']), ('\uff26', &['\x46']),
+ ('\uff27', &['\x47']), ('\uff28', &['\x48']), ('\uff29', &['\x49']), ('\uff2a', &['\x4a']),
+ ('\uff2b', &['\x4b']), ('\uff2c', &['\x4c']), ('\uff2d', &['\x4d']), ('\uff2e', &['\x4e']),
+ ('\uff2f', &['\x4f']), ('\uff30', &['\x50']), ('\uff31', &['\x51']), ('\uff32', &['\x52']),
+ ('\uff33', &['\x53']), ('\uff34', &['\x54']), ('\uff35', &['\x55']), ('\uff36', &['\x56']),
+ ('\uff37', &['\x57']), ('\uff38', &['\x58']), ('\uff39', &['\x59']), ('\uff3a', &['\x5a']),
+ ('\uff3b', &['\x5b']), ('\uff3c', &['\x5c']), ('\uff3d', &['\x5d']), ('\uff3e', &['\x5e']),
+ ('\uff3f', &['\x5f']), ('\uff40', &['\x60']), ('\uff41', &['\x61']), ('\uff42', &['\x62']),
+ ('\uff43', &['\x63']), ('\uff44', &['\x64']), ('\uff45', &['\x65']), ('\uff46', &['\x66']),
+ ('\uff47', &['\x67']), ('\uff48', &['\x68']), ('\uff49', &['\x69']), ('\uff4a', &['\x6a']),
+ ('\uff4b', &['\x6b']), ('\uff4c', &['\x6c']), ('\uff4d', &['\x6d']), ('\uff4e', &['\x6e']),
+ ('\uff4f', &['\x6f']), ('\uff50', &['\x70']), ('\uff51', &['\x71']), ('\uff52', &['\x72']),
+ ('\uff53', &['\x73']), ('\uff54', &['\x74']), ('\uff55', &['\x75']), ('\uff56', &['\x76']),
+ ('\uff57', &['\x77']), ('\uff58', &['\x78']), ('\uff59', &['\x79']), ('\uff5a', &['\x7a']),
+ ('\uff5b', &['\x7b']), ('\uff5c', &['\x7c']), ('\uff5d', &['\x7d']), ('\uff5e', &['\x7e']),
+ ('\uff5f', &['\u2985']), ('\uff60', &['\u2986']), ('\uff61', &['\u3002']), ('\uff62',
+ &['\u300c']), ('\uff63', &['\u300d']), ('\uff64', &['\u3001']), ('\uff65', &['\u30fb']),
+ ('\uff66', &['\u30f2']), ('\uff67', &['\u30a1']), ('\uff68', &['\u30a3']), ('\uff69',
+ &['\u30a5']), ('\uff6a', &['\u30a7']), ('\uff6b', &['\u30a9']), ('\uff6c', &['\u30e3']),
+ ('\uff6d', &['\u30e5']), ('\uff6e', &['\u30e7']), ('\uff6f', &['\u30c3']), ('\uff70',
+ &['\u30fc']), ('\uff71', &['\u30a2']), ('\uff72', &['\u30a4']), ('\uff73', &['\u30a6']),
+ ('\uff74', &['\u30a8']), ('\uff75', &['\u30aa']), ('\uff76', &['\u30ab']), ('\uff77',
+ &['\u30ad']), ('\uff78', &['\u30af']), ('\uff79', &['\u30b1']), ('\uff7a', &['\u30b3']),
+ ('\uff7b', &['\u30b5']), ('\uff7c', &['\u30b7']), ('\uff7d', &['\u30b9']), ('\uff7e',
+ &['\u30bb']), ('\uff7f', &['\u30bd']), ('\uff80', &['\u30bf']), ('\uff81', &['\u30c1']),
+ ('\uff82', &['\u30c4']), ('\uff83', &['\u30c6']), ('\uff84', &['\u30c8']), ('\uff85',
+ &['\u30ca']), ('\uff86', &['\u30cb']), ('\uff87', &['\u30cc']), ('\uff88', &['\u30cd']),
+ ('\uff89', &['\u30ce']), ('\uff8a', &['\u30cf']), ('\uff8b', &['\u30d2']), ('\uff8c',
+ &['\u30d5']), ('\uff8d', &['\u30d8']), ('\uff8e', &['\u30db']), ('\uff8f', &['\u30de']),
+ ('\uff90', &['\u30df']), ('\uff91', &['\u30e0']), ('\uff92', &['\u30e1']), ('\uff93',
+ &['\u30e2']), ('\uff94', &['\u30e4']), ('\uff95', &['\u30e6']), ('\uff96', &['\u30e8']),
+ ('\uff97', &['\u30e9']), ('\uff98', &['\u30ea']), ('\uff99', &['\u30eb']), ('\uff9a',
+ &['\u30ec']), ('\uff9b', &['\u30ed']), ('\uff9c', &['\u30ef']), ('\uff9d', &['\u30f3']),
+ ('\uff9e', &['\u3099']), ('\uff9f', &['\u309a']), ('\uffa0', &['\u3164']), ('\uffa1',
+ &['\u3131']), ('\uffa2', &['\u3132']), ('\uffa3', &['\u3133']), ('\uffa4', &['\u3134']),
+ ('\uffa5', &['\u3135']), ('\uffa6', &['\u3136']), ('\uffa7', &['\u3137']), ('\uffa8',
+ &['\u3138']), ('\uffa9', &['\u3139']), ('\uffaa', &['\u313a']), ('\uffab', &['\u313b']),
+ ('\uffac', &['\u313c']), ('\uffad', &['\u313d']), ('\uffae', &['\u313e']), ('\uffaf',
+ &['\u313f']), ('\uffb0', &['\u3140']), ('\uffb1', &['\u3141']), ('\uffb2', &['\u3142']),
+ ('\uffb3', &['\u3143']), ('\uffb4', &['\u3144']), ('\uffb5', &['\u3145']), ('\uffb6',
+ &['\u3146']), ('\uffb7', &['\u3147']), ('\uffb8', &['\u3148']), ('\uffb9', &['\u3149']),
+ ('\uffba', &['\u314a']), ('\uffbb', &['\u314b']), ('\uffbc', &['\u314c']), ('\uffbd',
+ &['\u314d']), ('\uffbe', &['\u314e']), ('\uffc2', &['\u314f']), ('\uffc3', &['\u3150']),
+ ('\uffc4', &['\u3151']), ('\uffc5', &['\u3152']), ('\uffc6', &['\u3153']), ('\uffc7',
+ &['\u3154']), ('\uffca', &['\u3155']), ('\uffcb', &['\u3156']), ('\uffcc', &['\u3157']),
+ ('\uffcd', &['\u3158']), ('\uffce', &['\u3159']), ('\uffcf', &['\u315a']), ('\uffd2',
+ &['\u315b']), ('\uffd3', &['\u315c']), ('\uffd4', &['\u315d']), ('\uffd5', &['\u315e']),
+ ('\uffd6', &['\u315f']), ('\uffd7', &['\u3160']), ('\uffda', &['\u3161']), ('\uffdb',
+ &['\u3162']), ('\uffdc', &['\u3163']), ('\uffe0', &['\xa2']), ('\uffe1', &['\xa3']),
+ ('\uffe2', &['\xac']), ('\uffe3', &['\xaf']), ('\uffe4', &['\xa6']), ('\uffe5', &['\xa5']),
+ ('\uffe6', &['\u20a9']), ('\uffe8', &['\u2502']), ('\uffe9', &['\u2190']), ('\uffea',
+ &['\u2191']), ('\uffeb', &['\u2192']), ('\uffec', &['\u2193']), ('\uffed', &['\u25a0']),
+ ('\uffee', &['\u25cb']), ('\U0001d400', &['\x41']), ('\U0001d401', &['\x42']),
+ ('\U0001d402', &['\x43']), ('\U0001d403', &['\x44']), ('\U0001d404', &['\x45']),
+ ('\U0001d405', &['\x46']), ('\U0001d406', &['\x47']), ('\U0001d407', &['\x48']),
+ ('\U0001d408', &['\x49']), ('\U0001d409', &['\x4a']), ('\U0001d40a', &['\x4b']),
+ ('\U0001d40b', &['\x4c']), ('\U0001d40c', &['\x4d']), ('\U0001d40d', &['\x4e']),
+ ('\U0001d40e', &['\x4f']), ('\U0001d40f', &['\x50']), ('\U0001d410', &['\x51']),
+ ('\U0001d411', &['\x52']), ('\U0001d412', &['\x53']), ('\U0001d413', &['\x54']),
+ ('\U0001d414', &['\x55']), ('\U0001d415', &['\x56']), ('\U0001d416', &['\x57']),
+ ('\U0001d417', &['\x58']), ('\U0001d418', &['\x59']), ('\U0001d419', &['\x5a']),
+ ('\U0001d41a', &['\x61']), ('\U0001d41b', &['\x62']), ('\U0001d41c', &['\x63']),
+ ('\U0001d41d', &['\x64']), ('\U0001d41e', &['\x65']), ('\U0001d41f', &['\x66']),
+ ('\U0001d420', &['\x67']), ('\U0001d421', &['\x68']), ('\U0001d422', &['\x69']),
+ ('\U0001d423', &['\x6a']), ('\U0001d424', &['\x6b']), ('\U0001d425', &['\x6c']),
+ ('\U0001d426', &['\x6d']), ('\U0001d427', &['\x6e']), ('\U0001d428', &['\x6f']),
+ ('\U0001d429', &['\x70']), ('\U0001d42a', &['\x71']), ('\U0001d42b', &['\x72']),
+ ('\U0001d42c', &['\x73']), ('\U0001d42d', &['\x74']), ('\U0001d42e', &['\x75']),
+ ('\U0001d42f', &['\x76']), ('\U0001d430', &['\x77']), ('\U0001d431', &['\x78']),
+ ('\U0001d432', &['\x79']), ('\U0001d433', &['\x7a']), ('\U0001d434', &['\x41']),
+ ('\U0001d435', &['\x42']), ('\U0001d436', &['\x43']), ('\U0001d437', &['\x44']),
+ ('\U0001d438', &['\x45']), ('\U0001d439', &['\x46']), ('\U0001d43a', &['\x47']),
+ ('\U0001d43b', &['\x48']), ('\U0001d43c', &['\x49']), ('\U0001d43d', &['\x4a']),
+ ('\U0001d43e', &['\x4b']), ('\U0001d43f', &['\x4c']), ('\U0001d440', &['\x4d']),
+ ('\U0001d441', &['\x4e']), ('\U0001d442', &['\x4f']), ('\U0001d443', &['\x50']),
+ ('\U0001d444', &['\x51']), ('\U0001d445', &['\x52']), ('\U0001d446', &['\x53']),
+ ('\U0001d447', &['\x54']), ('\U0001d448', &['\x55']), ('\U0001d449', &['\x56']),
+ ('\U0001d44a', &['\x57']), ('\U0001d44b', &['\x58']), ('\U0001d44c', &['\x59']),
+ ('\U0001d44d', &['\x5a']), ('\U0001d44e', &['\x61']), ('\U0001d44f', &['\x62']),
+ ('\U0001d450', &['\x63']), ('\U0001d451', &['\x64']), ('\U0001d452', &['\x65']),
+ ('\U0001d453', &['\x66']), ('\U0001d454', &['\x67']), ('\U0001d456', &['\x69']),
+ ('\U0001d457', &['\x6a']), ('\U0001d458', &['\x6b']), ('\U0001d459', &['\x6c']),
+ ('\U0001d45a', &['\x6d']), ('\U0001d45b', &['\x6e']), ('\U0001d45c', &['\x6f']),
+ ('\U0001d45d', &['\x70']), ('\U0001d45e', &['\x71']), ('\U0001d45f', &['\x72']),
+ ('\U0001d460', &['\x73']), ('\U0001d461', &['\x74']), ('\U0001d462', &['\x75']),
+ ('\U0001d463', &['\x76']), ('\U0001d464', &['\x77']), ('\U0001d465', &['\x78']),
+ ('\U0001d466', &['\x79']), ('\U0001d467', &['\x7a']), ('\U0001d468', &['\x41']),
+ ('\U0001d469', &['\x42']), ('\U0001d46a', &['\x43']), ('\U0001d46b', &['\x44']),
+ ('\U0001d46c', &['\x45']), ('\U0001d46d', &['\x46']), ('\U0001d46e', &['\x47']),
+ ('\U0001d46f', &['\x48']), ('\U0001d470', &['\x49']), ('\U0001d471', &['\x4a']),
+ ('\U0001d472', &['\x4b']), ('\U0001d473', &['\x4c']), ('\U0001d474', &['\x4d']),
+ ('\U0001d475', &['\x4e']), ('\U0001d476', &['\x4f']), ('\U0001d477', &['\x50']),
+ ('\U0001d478', &['\x51']), ('\U0001d479', &['\x52']), ('\U0001d47a', &['\x53']),
+ ('\U0001d47b', &['\x54']), ('\U0001d47c', &['\x55']), ('\U0001d47d', &['\x56']),
+ ('\U0001d47e', &['\x57']), ('\U0001d47f', &['\x58']), ('\U0001d480', &['\x59']),
+ ('\U0001d481', &['\x5a']), ('\U0001d482', &['\x61']), ('\U0001d483', &['\x62']),
+ ('\U0001d484', &['\x63']), ('\U0001d485', &['\x64']), ('\U0001d486', &['\x65']),
+ ('\U0001d487', &['\x66']), ('\U0001d488', &['\x67']), ('\U0001d489', &['\x68']),
+ ('\U0001d48a', &['\x69']), ('\U0001d48b', &['\x6a']), ('\U0001d48c', &['\x6b']),
+ ('\U0001d48d', &['\x6c']), ('\U0001d48e', &['\x6d']), ('\U0001d48f', &['\x6e']),
+ ('\U0001d490', &['\x6f']), ('\U0001d491', &['\x70']), ('\U0001d492', &['\x71']),
+ ('\U0001d493', &['\x72']), ('\U0001d494', &['\x73']), ('\U0001d495', &['\x74']),
+ ('\U0001d496', &['\x75']), ('\U0001d497', &['\x76']), ('\U0001d498', &['\x77']),
+ ('\U0001d499', &['\x78']), ('\U0001d49a', &['\x79']), ('\U0001d49b', &['\x7a']),
+ ('\U0001d49c', &['\x41']), ('\U0001d49e', &['\x43']), ('\U0001d49f', &['\x44']),
+ ('\U0001d4a2', &['\x47']), ('\U0001d4a5', &['\x4a']), ('\U0001d4a6', &['\x4b']),
+ ('\U0001d4a9', &['\x4e']), ('\U0001d4aa', &['\x4f']), ('\U0001d4ab', &['\x50']),
+ ('\U0001d4ac', &['\x51']), ('\U0001d4ae', &['\x53']), ('\U0001d4af', &['\x54']),
+ ('\U0001d4b0', &['\x55']), ('\U0001d4b1', &['\x56']), ('\U0001d4b2', &['\x57']),
+ ('\U0001d4b3', &['\x58']), ('\U0001d4b4', &['\x59']), ('\U0001d4b5', &['\x5a']),
+ ('\U0001d4b6', &['\x61']), ('\U0001d4b7', &['\x62']), ('\U0001d4b8', &['\x63']),
+ ('\U0001d4b9', &['\x64']), ('\U0001d4bb', &['\x66']), ('\U0001d4bd', &['\x68']),
+ ('\U0001d4be', &['\x69']), ('\U0001d4bf', &['\x6a']), ('\U0001d4c0', &['\x6b']),
+ ('\U0001d4c1', &['\x6c']), ('\U0001d4c2', &['\x6d']), ('\U0001d4c3', &['\x6e']),
+ ('\U0001d4c5', &['\x70']), ('\U0001d4c6', &['\x71']), ('\U0001d4c7', &['\x72']),
+ ('\U0001d4c8', &['\x73']), ('\U0001d4c9', &['\x74']), ('\U0001d4ca', &['\x75']),
+ ('\U0001d4cb', &['\x76']), ('\U0001d4cc', &['\x77']), ('\U0001d4cd', &['\x78']),
+ ('\U0001d4ce', &['\x79']), ('\U0001d4cf', &['\x7a']), ('\U0001d4d0', &['\x41']),
+ ('\U0001d4d1', &['\x42']), ('\U0001d4d2', &['\x43']), ('\U0001d4d3', &['\x44']),
+ ('\U0001d4d4', &['\x45']), ('\U0001d4d5', &['\x46']), ('\U0001d4d6', &['\x47']),
+ ('\U0001d4d7', &['\x48']), ('\U0001d4d8', &['\x49']), ('\U0001d4d9', &['\x4a']),
+ ('\U0001d4da', &['\x4b']), ('\U0001d4db', &['\x4c']), ('\U0001d4dc', &['\x4d']),
+ ('\U0001d4dd', &['\x4e']), ('\U0001d4de', &['\x4f']), ('\U0001d4df', &['\x50']),
+ ('\U0001d4e0', &['\x51']), ('\U0001d4e1', &['\x52']), ('\U0001d4e2', &['\x53']),
+ ('\U0001d4e3', &['\x54']), ('\U0001d4e4', &['\x55']), ('\U0001d4e5', &['\x56']),
+ ('\U0001d4e6', &['\x57']), ('\U0001d4e7', &['\x58']), ('\U0001d4e8', &['\x59']),
+ ('\U0001d4e9', &['\x5a']), ('\U0001d4ea', &['\x61']), ('\U0001d4eb', &['\x62']),
+ ('\U0001d4ec', &['\x63']), ('\U0001d4ed', &['\x64']), ('\U0001d4ee', &['\x65']),
+ ('\U0001d4ef', &['\x66']), ('\U0001d4f0', &['\x67']), ('\U0001d4f1', &['\x68']),
+ ('\U0001d4f2', &['\x69']), ('\U0001d4f3', &['\x6a']), ('\U0001d4f4', &['\x6b']),
+ ('\U0001d4f5', &['\x6c']), ('\U0001d4f6', &['\x6d']), ('\U0001d4f7', &['\x6e']),
+ ('\U0001d4f8', &['\x6f']), ('\U0001d4f9', &['\x70']), ('\U0001d4fa', &['\x71']),
+ ('\U0001d4fb', &['\x72']), ('\U0001d4fc', &['\x73']), ('\U0001d4fd', &['\x74']),
+ ('\U0001d4fe', &['\x75']), ('\U0001d4ff', &['\x76']), ('\U0001d500', &['\x77']),
+ ('\U0001d501', &['\x78']), ('\U0001d502', &['\x79']), ('\U0001d503', &['\x7a']),
+ ('\U0001d504', &['\x41']), ('\U0001d505', &['\x42']), ('\U0001d507', &['\x44']),
+ ('\U0001d508', &['\x45']), ('\U0001d509', &['\x46']), ('\U0001d50a', &['\x47']),
+ ('\U0001d50d', &['\x4a']), ('\U0001d50e', &['\x4b']), ('\U0001d50f', &['\x4c']),
+ ('\U0001d510', &['\x4d']), ('\U0001d511', &['\x4e']), ('\U0001d512', &['\x4f']),
+ ('\U0001d513', &['\x50']), ('\U0001d514', &['\x51']), ('\U0001d516', &['\x53']),
+ ('\U0001d517', &['\x54']), ('\U0001d518', &['\x55']), ('\U0001d519', &['\x56']),
+ ('\U0001d51a', &['\x57']), ('\U0001d51b', &['\x58']), ('\U0001d51c', &['\x59']),
+ ('\U0001d51e', &['\x61']), ('\U0001d51f', &['\x62']), ('\U0001d520', &['\x63']),
+ ('\U0001d521', &['\x64']), ('\U0001d522', &['\x65']), ('\U0001d523', &['\x66']),
+ ('\U0001d524', &['\x67']), ('\U0001d525', &['\x68']), ('\U0001d526', &['\x69']),
+ ('\U0001d527', &['\x6a']), ('\U0001d528', &['\x6b']), ('\U0001d529', &['\x6c']),
+ ('\U0001d52a', &['\x6d']), ('\U0001d52b', &['\x6e']), ('\U0001d52c', &['\x6f']),
+ ('\U0001d52d', &['\x70']), ('\U0001d52e', &['\x71']), ('\U0001d52f', &['\x72']),
+ ('\U0001d530', &['\x73']), ('\U0001d531', &['\x74']), ('\U0001d532', &['\x75']),
+ ('\U0001d533', &['\x76']), ('\U0001d534', &['\x77']), ('\U0001d535', &['\x78']),
+ ('\U0001d536', &['\x79']), ('\U0001d537', &['\x7a']), ('\U0001d538', &['\x41']),
+ ('\U0001d539', &['\x42']), ('\U0001d53b', &['\x44']), ('\U0001d53c', &['\x45']),
+ ('\U0001d53d', &['\x46']), ('\U0001d53e', &['\x47']), ('\U0001d540', &['\x49']),
+ ('\U0001d541', &['\x4a']), ('\U0001d542', &['\x4b']), ('\U0001d543', &['\x4c']),
+ ('\U0001d544', &['\x4d']), ('\U0001d546', &['\x4f']), ('\U0001d54a', &['\x53']),
+ ('\U0001d54b', &['\x54']), ('\U0001d54c', &['\x55']), ('\U0001d54d', &['\x56']),
+ ('\U0001d54e', &['\x57']), ('\U0001d54f', &['\x58']), ('\U0001d550', &['\x59']),
+ ('\U0001d552', &['\x61']), ('\U0001d553', &['\x62']), ('\U0001d554', &['\x63']),
+ ('\U0001d555', &['\x64']), ('\U0001d556', &['\x65']), ('\U0001d557', &['\x66']),
+ ('\U0001d558', &['\x67']), ('\U0001d559', &['\x68']), ('\U0001d55a', &['\x69']),
+ ('\U0001d55b', &['\x6a']), ('\U0001d55c', &['\x6b']), ('\U0001d55d', &['\x6c']),
+ ('\U0001d55e', &['\x6d']), ('\U0001d55f', &['\x6e']), ('\U0001d560', &['\x6f']),
+ ('\U0001d561', &['\x70']), ('\U0001d562', &['\x71']), ('\U0001d563', &['\x72']),
+ ('\U0001d564', &['\x73']), ('\U0001d565', &['\x74']), ('\U0001d566', &['\x75']),
+ ('\U0001d567', &['\x76']), ('\U0001d568', &['\x77']), ('\U0001d569', &['\x78']),
+ ('\U0001d56a', &['\x79']), ('\U0001d56b', &['\x7a']), ('\U0001d56c', &['\x41']),
+ ('\U0001d56d', &['\x42']), ('\U0001d56e', &['\x43']), ('\U0001d56f', &['\x44']),
+ ('\U0001d570', &['\x45']), ('\U0001d571', &['\x46']), ('\U0001d572', &['\x47']),
+ ('\U0001d573', &['\x48']), ('\U0001d574', &['\x49']), ('\U0001d575', &['\x4a']),
+ ('\U0001d576', &['\x4b']), ('\U0001d577', &['\x4c']), ('\U0001d578', &['\x4d']),
+ ('\U0001d579', &['\x4e']), ('\U0001d57a', &['\x4f']), ('\U0001d57b', &['\x50']),
+ ('\U0001d57c', &['\x51']), ('\U0001d57d', &['\x52']), ('\U0001d57e', &['\x53']),
+ ('\U0001d57f', &['\x54']), ('\U0001d580', &['\x55']), ('\U0001d581', &['\x56']),
+ ('\U0001d582', &['\x57']), ('\U0001d583', &['\x58']), ('\U0001d584', &['\x59']),
+ ('\U0001d585', &['\x5a']), ('\U0001d586', &['\x61']), ('\U0001d587', &['\x62']),
+ ('\U0001d588', &['\x63']), ('\U0001d589', &['\x64']), ('\U0001d58a', &['\x65']),
+ ('\U0001d58b', &['\x66']), ('\U0001d58c', &['\x67']), ('\U0001d58d', &['\x68']),
+ ('\U0001d58e', &['\x69']), ('\U0001d58f', &['\x6a']), ('\U0001d590', &['\x6b']),
+ ('\U0001d591', &['\x6c']), ('\U0001d592', &['\x6d']), ('\U0001d593', &['\x6e']),
+ ('\U0001d594', &['\x6f']), ('\U0001d595', &['\x70']), ('\U0001d596', &['\x71']),
+ ('\U0001d597', &['\x72']), ('\U0001d598', &['\x73']), ('\U0001d599', &['\x74']),
+ ('\U0001d59a', &['\x75']), ('\U0001d59b', &['\x76']), ('\U0001d59c', &['\x77']),
+ ('\U0001d59d', &['\x78']), ('\U0001d59e', &['\x79']), ('\U0001d59f', &['\x7a']),
+ ('\U0001d5a0', &['\x41']), ('\U0001d5a1', &['\x42']), ('\U0001d5a2', &['\x43']),
+ ('\U0001d5a3', &['\x44']), ('\U0001d5a4', &['\x45']), ('\U0001d5a5', &['\x46']),
+ ('\U0001d5a6', &['\x47']), ('\U0001d5a7', &['\x48']), ('\U0001d5a8', &['\x49']),
+ ('\U0001d5a9', &['\x4a']), ('\U0001d5aa', &['\x4b']), ('\U0001d5ab', &['\x4c']),
+ ('\U0001d5ac', &['\x4d']), ('\U0001d5ad', &['\x4e']), ('\U0001d5ae', &['\x4f']),
+ ('\U0001d5af', &['\x50']), ('\U0001d5b0', &['\x51']), ('\U0001d5b1', &['\x52']),
+ ('\U0001d5b2', &['\x53']), ('\U0001d5b3', &['\x54']), ('\U0001d5b4', &['\x55']),
+ ('\U0001d5b5', &['\x56']), ('\U0001d5b6', &['\x57']), ('\U0001d5b7', &['\x58']),
+ ('\U0001d5b8', &['\x59']), ('\U0001d5b9', &['\x5a']), ('\U0001d5ba', &['\x61']),
+ ('\U0001d5bb', &['\x62']), ('\U0001d5bc', &['\x63']), ('\U0001d5bd', &['\x64']),
+ ('\U0001d5be', &['\x65']), ('\U0001d5bf', &['\x66']), ('\U0001d5c0', &['\x67']),
+ ('\U0001d5c1', &['\x68']), ('\U0001d5c2', &['\x69']), ('\U0001d5c3', &['\x6a']),
+ ('\U0001d5c4', &['\x6b']), ('\U0001d5c5', &['\x6c']), ('\U0001d5c6', &['\x6d']),
+ ('\U0001d5c7', &['\x6e']), ('\U0001d5c8', &['\x6f']), ('\U0001d5c9', &['\x70']),
+ ('\U0001d5ca', &['\x71']), ('\U0001d5cb', &['\x72']), ('\U0001d5cc', &['\x73']),
+ ('\U0001d5cd', &['\x74']), ('\U0001d5ce', &['\x75']), ('\U0001d5cf', &['\x76']),
+ ('\U0001d5d0', &['\x77']), ('\U0001d5d1', &['\x78']), ('\U0001d5d2', &['\x79']),
+ ('\U0001d5d3', &['\x7a']), ('\U0001d5d4', &['\x41']), ('\U0001d5d5', &['\x42']),
+ ('\U0001d5d6', &['\x43']), ('\U0001d5d7', &['\x44']), ('\U0001d5d8', &['\x45']),
+ ('\U0001d5d9', &['\x46']), ('\U0001d5da', &['\x47']), ('\U0001d5db', &['\x48']),
+ ('\U0001d5dc', &['\x49']), ('\U0001d5dd', &['\x4a']), ('\U0001d5de', &['\x4b']),
+ ('\U0001d5df', &['\x4c']), ('\U0001d5e0', &['\x4d']), ('\U0001d5e1', &['\x4e']),
+ ('\U0001d5e2', &['\x4f']), ('\U0001d5e3', &['\x50']), ('\U0001d5e4', &['\x51']),
+ ('\U0001d5e5', &['\x52']), ('\U0001d5e6', &['\x53']), ('\U0001d5e7', &['\x54']),
+ ('\U0001d5e8', &['\x55']), ('\U0001d5e9', &['\x56']), ('\U0001d5ea', &['\x57']),
+ ('\U0001d5eb', &['\x58']), ('\U0001d5ec', &['\x59']), ('\U0001d5ed', &['\x5a']),
+ ('\U0001d5ee', &['\x61']), ('\U0001d5ef', &['\x62']), ('\U0001d5f0', &['\x63']),
+ ('\U0001d5f1', &['\x64']), ('\U0001d5f2', &['\x65']), ('\U0001d5f3', &['\x66']),
+ ('\U0001d5f4', &['\x67']), ('\U0001d5f5', &['\x68']), ('\U0001d5f6', &['\x69']),
+ ('\U0001d5f7', &['\x6a']), ('\U0001d5f8', &['\x6b']), ('\U0001d5f9', &['\x6c']),
+ ('\U0001d5fa', &['\x6d']), ('\U0001d5fb', &['\x6e']), ('\U0001d5fc', &['\x6f']),
+ ('\U0001d5fd', &['\x70']), ('\U0001d5fe', &['\x71']), ('\U0001d5ff', &['\x72']),
+ ('\U0001d600', &['\x73']), ('\U0001d601', &['\x74']), ('\U0001d602', &['\x75']),
+ ('\U0001d603', &['\x76']), ('\U0001d604', &['\x77']), ('\U0001d605', &['\x78']),
+ ('\U0001d606', &['\x79']), ('\U0001d607', &['\x7a']), ('\U0001d608', &['\x41']),
+ ('\U0001d609', &['\x42']), ('\U0001d60a', &['\x43']), ('\U0001d60b', &['\x44']),
+ ('\U0001d60c', &['\x45']), ('\U0001d60d', &['\x46']), ('\U0001d60e', &['\x47']),
+ ('\U0001d60f', &['\x48']), ('\U0001d610', &['\x49']), ('\U0001d611', &['\x4a']),
+ ('\U0001d612', &['\x4b']), ('\U0001d613', &['\x4c']), ('\U0001d614', &['\x4d']),
+ ('\U0001d615', &['\x4e']), ('\U0001d616', &['\x4f']), ('\U0001d617', &['\x50']),
+ ('\U0001d618', &['\x51']), ('\U0001d619', &['\x52']), ('\U0001d61a', &['\x53']),
+ ('\U0001d61b', &['\x54']), ('\U0001d61c', &['\x55']), ('\U0001d61d', &['\x56']),
+ ('\U0001d61e', &['\x57']), ('\U0001d61f', &['\x58']), ('\U0001d620', &['\x59']),
+ ('\U0001d621', &['\x5a']), ('\U0001d622', &['\x61']), ('\U0001d623', &['\x62']),
+ ('\U0001d624', &['\x63']), ('\U0001d625', &['\x64']), ('\U0001d626', &['\x65']),
+ ('\U0001d627', &['\x66']), ('\U0001d628', &['\x67']), ('\U0001d629', &['\x68']),
+ ('\U0001d62a', &['\x69']), ('\U0001d62b', &['\x6a']), ('\U0001d62c', &['\x6b']),
+ ('\U0001d62d', &['\x6c']), ('\U0001d62e', &['\x6d']), ('\U0001d62f', &['\x6e']),
+ ('\U0001d630', &['\x6f']), ('\U0001d631', &['\x70']), ('\U0001d632', &['\x71']),
+ ('\U0001d633', &['\x72']), ('\U0001d634', &['\x73']), ('\U0001d635', &['\x74']),
+ ('\U0001d636', &['\x75']), ('\U0001d637', &['\x76']), ('\U0001d638', &['\x77']),
+ ('\U0001d639', &['\x78']), ('\U0001d63a', &['\x79']), ('\U0001d63b', &['\x7a']),
+ ('\U0001d63c', &['\x41']), ('\U0001d63d', &['\x42']), ('\U0001d63e', &['\x43']),
+ ('\U0001d63f', &['\x44']), ('\U0001d640', &['\x45']), ('\U0001d641', &['\x46']),
+ ('\U0001d642', &['\x47']), ('\U0001d643', &['\x48']), ('\U0001d644', &['\x49']),
+ ('\U0001d645', &['\x4a']), ('\U0001d646', &['\x4b']), ('\U0001d647', &['\x4c']),
+ ('\U0001d648', &['\x4d']), ('\U0001d649', &['\x4e']), ('\U0001d64a', &['\x4f']),
+ ('\U0001d64b', &['\x50']), ('\U0001d64c', &['\x51']), ('\U0001d64d', &['\x52']),
+ ('\U0001d64e', &['\x53']), ('\U0001d64f', &['\x54']), ('\U0001d650', &['\x55']),
+ ('\U0001d651', &['\x56']), ('\U0001d652', &['\x57']), ('\U0001d653', &['\x58']),
+ ('\U0001d654', &['\x59']), ('\U0001d655', &['\x5a']), ('\U0001d656', &['\x61']),
+ ('\U0001d657', &['\x62']), ('\U0001d658', &['\x63']), ('\U0001d659', &['\x64']),
+ ('\U0001d65a', &['\x65']), ('\U0001d65b', &['\x66']), ('\U0001d65c', &['\x67']),
+ ('\U0001d65d', &['\x68']), ('\U0001d65e', &['\x69']), ('\U0001d65f', &['\x6a']),
+ ('\U0001d660', &['\x6b']), ('\U0001d661', &['\x6c']), ('\U0001d662', &['\x6d']),
+ ('\U0001d663', &['\x6e']), ('\U0001d664', &['\x6f']), ('\U0001d665', &['\x70']),
+ ('\U0001d666', &['\x71']), ('\U0001d667', &['\x72']), ('\U0001d668', &['\x73']),
+ ('\U0001d669', &['\x74']), ('\U0001d66a', &['\x75']), ('\U0001d66b', &['\x76']),
+ ('\U0001d66c', &['\x77']), ('\U0001d66d', &['\x78']), ('\U0001d66e', &['\x79']),
+ ('\U0001d66f', &['\x7a']), ('\U0001d670', &['\x41']), ('\U0001d671', &['\x42']),
+ ('\U0001d672', &['\x43']), ('\U0001d673', &['\x44']), ('\U0001d674', &['\x45']),
+ ('\U0001d675', &['\x46']), ('\U0001d676', &['\x47']), ('\U0001d677', &['\x48']),
+ ('\U0001d678', &['\x49']), ('\U0001d679', &['\x4a']), ('\U0001d67a', &['\x4b']),
+ ('\U0001d67b', &['\x4c']), ('\U0001d67c', &['\x4d']), ('\U0001d67d', &['\x4e']),
+ ('\U0001d67e', &['\x4f']), ('\U0001d67f', &['\x50']), ('\U0001d680', &['\x51']),
+ ('\U0001d681', &['\x52']), ('\U0001d682', &['\x53']), ('\U0001d683', &['\x54']),
+ ('\U0001d684', &['\x55']), ('\U0001d685', &['\x56']), ('\U0001d686', &['\x57']),
+ ('\U0001d687', &['\x58']), ('\U0001d688', &['\x59']), ('\U0001d689', &['\x5a']),
+ ('\U0001d68a', &['\x61']), ('\U0001d68b', &['\x62']), ('\U0001d68c', &['\x63']),
+ ('\U0001d68d', &['\x64']), ('\U0001d68e', &['\x65']), ('\U0001d68f', &['\x66']),
+ ('\U0001d690', &['\x67']), ('\U0001d691', &['\x68']), ('\U0001d692', &['\x69']),
+ ('\U0001d693', &['\x6a']), ('\U0001d694', &['\x6b']), ('\U0001d695', &['\x6c']),
+ ('\U0001d696', &['\x6d']), ('\U0001d697', &['\x6e']), ('\U0001d698', &['\x6f']),
+ ('\U0001d699', &['\x70']), ('\U0001d69a', &['\x71']), ('\U0001d69b', &['\x72']),
+ ('\U0001d69c', &['\x73']), ('\U0001d69d', &['\x74']), ('\U0001d69e', &['\x75']),
+ ('\U0001d69f', &['\x76']), ('\U0001d6a0', &['\x77']), ('\U0001d6a1', &['\x78']),
+ ('\U0001d6a2', &['\x79']), ('\U0001d6a3', &['\x7a']), ('\U0001d6a4', &['\u0131']),
+ ('\U0001d6a5', &['\u0237']), ('\U0001d6a8', &['\u0391']), ('\U0001d6a9', &['\u0392']),
+ ('\U0001d6aa', &['\u0393']), ('\U0001d6ab', &['\u0394']), ('\U0001d6ac', &['\u0395']),
+ ('\U0001d6ad', &['\u0396']), ('\U0001d6ae', &['\u0397']), ('\U0001d6af', &['\u0398']),
+ ('\U0001d6b0', &['\u0399']), ('\U0001d6b1', &['\u039a']), ('\U0001d6b2', &['\u039b']),
+ ('\U0001d6b3', &['\u039c']), ('\U0001d6b4', &['\u039d']), ('\U0001d6b5', &['\u039e']),
+ ('\U0001d6b6', &['\u039f']), ('\U0001d6b7', &['\u03a0']), ('\U0001d6b8', &['\u03a1']),
+ ('\U0001d6b9', &['\u03f4']), ('\U0001d6ba', &['\u03a3']), ('\U0001d6bb', &['\u03a4']),
+ ('\U0001d6bc', &['\u03a5']), ('\U0001d6bd', &['\u03a6']), ('\U0001d6be', &['\u03a7']),
+ ('\U0001d6bf', &['\u03a8']), ('\U0001d6c0', &['\u03a9']), ('\U0001d6c1', &['\u2207']),
+ ('\U0001d6c2', &['\u03b1']), ('\U0001d6c3', &['\u03b2']), ('\U0001d6c4', &['\u03b3']),
+ ('\U0001d6c5', &['\u03b4']), ('\U0001d6c6', &['\u03b5']), ('\U0001d6c7', &['\u03b6']),
+ ('\U0001d6c8', &['\u03b7']), ('\U0001d6c9', &['\u03b8']), ('\U0001d6ca', &['\u03b9']),
+ ('\U0001d6cb', &['\u03ba']), ('\U0001d6cc', &['\u03bb']), ('\U0001d6cd', &['\u03bc']),
+ ('\U0001d6ce', &['\u03bd']), ('\U0001d6cf', &['\u03be']), ('\U0001d6d0', &['\u03bf']),
+ ('\U0001d6d1', &['\u03c0']), ('\U0001d6d2', &['\u03c1']), ('\U0001d6d3', &['\u03c2']),
+ ('\U0001d6d4', &['\u03c3']), ('\U0001d6d5', &['\u03c4']), ('\U0001d6d6', &['\u03c5']),
+ ('\U0001d6d7', &['\u03c6']), ('\U0001d6d8', &['\u03c7']), ('\U0001d6d9', &['\u03c8']),
+ ('\U0001d6da', &['\u03c9']), ('\U0001d6db', &['\u2202']), ('\U0001d6dc', &['\u03f5']),
+ ('\U0001d6dd', &['\u03d1']), ('\U0001d6de', &['\u03f0']), ('\U0001d6df', &['\u03d5']),
+ ('\U0001d6e0', &['\u03f1']), ('\U0001d6e1', &['\u03d6']), ('\U0001d6e2', &['\u0391']),
+ ('\U0001d6e3', &['\u0392']), ('\U0001d6e4', &['\u0393']), ('\U0001d6e5', &['\u0394']),
+ ('\U0001d6e6', &['\u0395']), ('\U0001d6e7', &['\u0396']), ('\U0001d6e8', &['\u0397']),
+ ('\U0001d6e9', &['\u0398']), ('\U0001d6ea', &['\u0399']), ('\U0001d6eb', &['\u039a']),
+ ('\U0001d6ec', &['\u039b']), ('\U0001d6ed', &['\u039c']), ('\U0001d6ee', &['\u039d']),
+ ('\U0001d6ef', &['\u039e']), ('\U0001d6f0', &['\u039f']), ('\U0001d6f1', &['\u03a0']),
+ ('\U0001d6f2', &['\u03a1']), ('\U0001d6f3', &['\u03f4']), ('\U0001d6f4', &['\u03a3']),
+ ('\U0001d6f5', &['\u03a4']), ('\U0001d6f6', &['\u03a5']), ('\U0001d6f7', &['\u03a6']),
+ ('\U0001d6f8', &['\u03a7']), ('\U0001d6f9', &['\u03a8']), ('\U0001d6fa', &['\u03a9']),
+ ('\U0001d6fb', &['\u2207']), ('\U0001d6fc', &['\u03b1']), ('\U0001d6fd', &['\u03b2']),
+ ('\U0001d6fe', &['\u03b3']), ('\U0001d6ff', &['\u03b4']), ('\U0001d700', &['\u03b5']),
+ ('\U0001d701', &['\u03b6']), ('\U0001d702', &['\u03b7']), ('\U0001d703', &['\u03b8']),
+ ('\U0001d704', &['\u03b9']), ('\U0001d705', &['\u03ba']), ('\U0001d706', &['\u03bb']),
+ ('\U0001d707', &['\u03bc']), ('\U0001d708', &['\u03bd']), ('\U0001d709', &['\u03be']),
+ ('\U0001d70a', &['\u03bf']), ('\U0001d70b', &['\u03c0']), ('\U0001d70c', &['\u03c1']),
+ ('\U0001d70d', &['\u03c2']), ('\U0001d70e', &['\u03c3']), ('\U0001d70f', &['\u03c4']),
+ ('\U0001d710', &['\u03c5']), ('\U0001d711', &['\u03c6']), ('\U0001d712', &['\u03c7']),
+ ('\U0001d713', &['\u03c8']), ('\U0001d714', &['\u03c9']), ('\U0001d715', &['\u2202']),
+ ('\U0001d716', &['\u03f5']), ('\U0001d717', &['\u03d1']), ('\U0001d718', &['\u03f0']),
+ ('\U0001d719', &['\u03d5']), ('\U0001d71a', &['\u03f1']), ('\U0001d71b', &['\u03d6']),
+ ('\U0001d71c', &['\u0391']), ('\U0001d71d', &['\u0392']), ('\U0001d71e', &['\u0393']),
+ ('\U0001d71f', &['\u0394']), ('\U0001d720', &['\u0395']), ('\U0001d721', &['\u0396']),
+ ('\U0001d722', &['\u0397']), ('\U0001d723', &['\u0398']), ('\U0001d724', &['\u0399']),
+ ('\U0001d725', &['\u039a']), ('\U0001d726', &['\u039b']), ('\U0001d727', &['\u039c']),
+ ('\U0001d728', &['\u039d']), ('\U0001d729', &['\u039e']), ('\U0001d72a', &['\u039f']),
+ ('\U0001d72b', &['\u03a0']), ('\U0001d72c', &['\u03a1']), ('\U0001d72d', &['\u03f4']),
+ ('\U0001d72e', &['\u03a3']), ('\U0001d72f', &['\u03a4']), ('\U0001d730', &['\u03a5']),
+ ('\U0001d731', &['\u03a6']), ('\U0001d732', &['\u03a7']), ('\U0001d733', &['\u03a8']),
+ ('\U0001d734', &['\u03a9']), ('\U0001d735', &['\u2207']), ('\U0001d736', &['\u03b1']),
+ ('\U0001d737', &['\u03b2']), ('\U0001d738', &['\u03b3']), ('\U0001d739', &['\u03b4']),
+ ('\U0001d73a', &['\u03b5']), ('\U0001d73b', &['\u03b6']), ('\U0001d73c', &['\u03b7']),
+ ('\U0001d73d', &['\u03b8']), ('\U0001d73e', &['\u03b9']), ('\U0001d73f', &['\u03ba']),
+ ('\U0001d740', &['\u03bb']), ('\U0001d741', &['\u03bc']), ('\U0001d742', &['\u03bd']),
+ ('\U0001d743', &['\u03be']), ('\U0001d744', &['\u03bf']), ('\U0001d745', &['\u03c0']),
+ ('\U0001d746', &['\u03c1']), ('\U0001d747', &['\u03c2']), ('\U0001d748', &['\u03c3']),
+ ('\U0001d749', &['\u03c4']), ('\U0001d74a', &['\u03c5']), ('\U0001d74b', &['\u03c6']),
+ ('\U0001d74c', &['\u03c7']), ('\U0001d74d', &['\u03c8']), ('\U0001d74e', &['\u03c9']),
+ ('\U0001d74f', &['\u2202']), ('\U0001d750', &['\u03f5']), ('\U0001d751', &['\u03d1']),
+ ('\U0001d752', &['\u03f0']), ('\U0001d753', &['\u03d5']), ('\U0001d754', &['\u03f1']),
+ ('\U0001d755', &['\u03d6']), ('\U0001d756', &['\u0391']), ('\U0001d757', &['\u0392']),
+ ('\U0001d758', &['\u0393']), ('\U0001d759', &['\u0394']), ('\U0001d75a', &['\u0395']),
+ ('\U0001d75b', &['\u0396']), ('\U0001d75c', &['\u0397']), ('\U0001d75d', &['\u0398']),
+ ('\U0001d75e', &['\u0399']), ('\U0001d75f', &['\u039a']), ('\U0001d760', &['\u039b']),
+ ('\U0001d761', &['\u039c']), ('\U0001d762', &['\u039d']), ('\U0001d763', &['\u039e']),
+ ('\U0001d764', &['\u039f']), ('\U0001d765', &['\u03a0']), ('\U0001d766', &['\u03a1']),
+ ('\U0001d767', &['\u03f4']), ('\U0001d768', &['\u03a3']), ('\U0001d769', &['\u03a4']),
+ ('\U0001d76a', &['\u03a5']), ('\U0001d76b', &['\u03a6']), ('\U0001d76c', &['\u03a7']),
+ ('\U0001d76d', &['\u03a8']), ('\U0001d76e', &['\u03a9']), ('\U0001d76f', &['\u2207']),
+ ('\U0001d770', &['\u03b1']), ('\U0001d771', &['\u03b2']), ('\U0001d772', &['\u03b3']),
+ ('\U0001d773', &['\u03b4']), ('\U0001d774', &['\u03b5']), ('\U0001d775', &['\u03b6']),
+ ('\U0001d776', &['\u03b7']), ('\U0001d777', &['\u03b8']), ('\U0001d778', &['\u03b9']),
+ ('\U0001d779', &['\u03ba']), ('\U0001d77a', &['\u03bb']), ('\U0001d77b', &['\u03bc']),
+ ('\U0001d77c', &['\u03bd']), ('\U0001d77d', &['\u03be']), ('\U0001d77e', &['\u03bf']),
+ ('\U0001d77f', &['\u03c0']), ('\U0001d780', &['\u03c1']), ('\U0001d781', &['\u03c2']),
+ ('\U0001d782', &['\u03c3']), ('\U0001d783', &['\u03c4']), ('\U0001d784', &['\u03c5']),
+ ('\U0001d785', &['\u03c6']), ('\U0001d786', &['\u03c7']), ('\U0001d787', &['\u03c8']),
+ ('\U0001d788', &['\u03c9']), ('\U0001d789', &['\u2202']), ('\U0001d78a', &['\u03f5']),
+ ('\U0001d78b', &['\u03d1']), ('\U0001d78c', &['\u03f0']), ('\U0001d78d', &['\u03d5']),
+ ('\U0001d78e', &['\u03f1']), ('\U0001d78f', &['\u03d6']), ('\U0001d790', &['\u0391']),
+ ('\U0001d791', &['\u0392']), ('\U0001d792', &['\u0393']), ('\U0001d793', &['\u0394']),
+ ('\U0001d794', &['\u0395']), ('\U0001d795', &['\u0396']), ('\U0001d796', &['\u0397']),
+ ('\U0001d797', &['\u0398']), ('\U0001d798', &['\u0399']), ('\U0001d799', &['\u039a']),
+ ('\U0001d79a', &['\u039b']), ('\U0001d79b', &['\u039c']), ('\U0001d79c', &['\u039d']),
+ ('\U0001d79d', &['\u039e']), ('\U0001d79e', &['\u039f']), ('\U0001d79f', &['\u03a0']),
+ ('\U0001d7a0', &['\u03a1']), ('\U0001d7a1', &['\u03f4']), ('\U0001d7a2', &['\u03a3']),
+ ('\U0001d7a3', &['\u03a4']), ('\U0001d7a4', &['\u03a5']), ('\U0001d7a5', &['\u03a6']),
+ ('\U0001d7a6', &['\u03a7']), ('\U0001d7a7', &['\u03a8']), ('\U0001d7a8', &['\u03a9']),
+ ('\U0001d7a9', &['\u2207']), ('\U0001d7aa', &['\u03b1']), ('\U0001d7ab', &['\u03b2']),
+ ('\U0001d7ac', &['\u03b3']), ('\U0001d7ad', &['\u03b4']), ('\U0001d7ae', &['\u03b5']),
+ ('\U0001d7af', &['\u03b6']), ('\U0001d7b0', &['\u03b7']), ('\U0001d7b1', &['\u03b8']),
+ ('\U0001d7b2', &['\u03b9']), ('\U0001d7b3', &['\u03ba']), ('\U0001d7b4', &['\u03bb']),
+ ('\U0001d7b5', &['\u03bc']), ('\U0001d7b6', &['\u03bd']), ('\U0001d7b7', &['\u03be']),
+ ('\U0001d7b8', &['\u03bf']), ('\U0001d7b9', &['\u03c0']), ('\U0001d7ba', &['\u03c1']),
+ ('\U0001d7bb', &['\u03c2']), ('\U0001d7bc', &['\u03c3']), ('\U0001d7bd', &['\u03c4']),
+ ('\U0001d7be', &['\u03c5']), ('\U0001d7bf', &['\u03c6']), ('\U0001d7c0', &['\u03c7']),
+ ('\U0001d7c1', &['\u03c8']), ('\U0001d7c2', &['\u03c9']), ('\U0001d7c3', &['\u2202']),
+ ('\U0001d7c4', &['\u03f5']), ('\U0001d7c5', &['\u03d1']), ('\U0001d7c6', &['\u03f0']),
+ ('\U0001d7c7', &['\u03d5']), ('\U0001d7c8', &['\u03f1']), ('\U0001d7c9', &['\u03d6']),
+ ('\U0001d7ca', &['\u03dc']), ('\U0001d7cb', &['\u03dd']), ('\U0001d7ce', &['\x30']),
+ ('\U0001d7cf', &['\x31']), ('\U0001d7d0', &['\x32']), ('\U0001d7d1', &['\x33']),
+ ('\U0001d7d2', &['\x34']), ('\U0001d7d3', &['\x35']), ('\U0001d7d4', &['\x36']),
+ ('\U0001d7d5', &['\x37']), ('\U0001d7d6', &['\x38']), ('\U0001d7d7', &['\x39']),
+ ('\U0001d7d8', &['\x30']), ('\U0001d7d9', &['\x31']), ('\U0001d7da', &['\x32']),
+ ('\U0001d7db', &['\x33']), ('\U0001d7dc', &['\x34']), ('\U0001d7dd', &['\x35']),
+ ('\U0001d7de', &['\x36']), ('\U0001d7df', &['\x37']), ('\U0001d7e0', &['\x38']),
+ ('\U0001d7e1', &['\x39']), ('\U0001d7e2', &['\x30']), ('\U0001d7e3', &['\x31']),
+ ('\U0001d7e4', &['\x32']), ('\U0001d7e5', &['\x33']), ('\U0001d7e6', &['\x34']),
+ ('\U0001d7e7', &['\x35']), ('\U0001d7e8', &['\x36']), ('\U0001d7e9', &['\x37']),
+ ('\U0001d7ea', &['\x38']), ('\U0001d7eb', &['\x39']), ('\U0001d7ec', &['\x30']),
+ ('\U0001d7ed', &['\x31']), ('\U0001d7ee', &['\x32']), ('\U0001d7ef', &['\x33']),
+ ('\U0001d7f0', &['\x34']), ('\U0001d7f1', &['\x35']), ('\U0001d7f2', &['\x36']),
+ ('\U0001d7f3', &['\x37']), ('\U0001d7f4', &['\x38']), ('\U0001d7f5', &['\x39']),
+ ('\U0001d7f6', &['\x30']), ('\U0001d7f7', &['\x31']), ('\U0001d7f8', &['\x32']),
+ ('\U0001d7f9', &['\x33']), ('\U0001d7fa', &['\x34']), ('\U0001d7fb', &['\x35']),
+ ('\U0001d7fc', &['\x36']), ('\U0001d7fd', &['\x37']), ('\U0001d7fe', &['\x38']),
+ ('\U0001d7ff', &['\x39']), ('\U0001ee00', &['\u0627']), ('\U0001ee01', &['\u0628']),
+ ('\U0001ee02', &['\u062c']), ('\U0001ee03', &['\u062f']), ('\U0001ee05', &['\u0648']),
+ ('\U0001ee06', &['\u0632']), ('\U0001ee07', &['\u062d']), ('\U0001ee08', &['\u0637']),
+ ('\U0001ee09', &['\u064a']), ('\U0001ee0a', &['\u0643']), ('\U0001ee0b', &['\u0644']),
+ ('\U0001ee0c', &['\u0645']), ('\U0001ee0d', &['\u0646']), ('\U0001ee0e', &['\u0633']),
+ ('\U0001ee0f', &['\u0639']), ('\U0001ee10', &['\u0641']), ('\U0001ee11', &['\u0635']),
+ ('\U0001ee12', &['\u0642']), ('\U0001ee13', &['\u0631']), ('\U0001ee14', &['\u0634']),
+ ('\U0001ee15', &['\u062a']), ('\U0001ee16', &['\u062b']), ('\U0001ee17', &['\u062e']),
+ ('\U0001ee18', &['\u0630']), ('\U0001ee19', &['\u0636']), ('\U0001ee1a', &['\u0638']),
+ ('\U0001ee1b', &['\u063a']), ('\U0001ee1c', &['\u066e']), ('\U0001ee1d', &['\u06ba']),
+ ('\U0001ee1e', &['\u06a1']), ('\U0001ee1f', &['\u066f']), ('\U0001ee21', &['\u0628']),
+ ('\U0001ee22', &['\u062c']), ('\U0001ee24', &['\u0647']), ('\U0001ee27', &['\u062d']),
+ ('\U0001ee29', &['\u064a']), ('\U0001ee2a', &['\u0643']), ('\U0001ee2b', &['\u0644']),
+ ('\U0001ee2c', &['\u0645']), ('\U0001ee2d', &['\u0646']), ('\U0001ee2e', &['\u0633']),
+ ('\U0001ee2f', &['\u0639']), ('\U0001ee30', &['\u0641']), ('\U0001ee31', &['\u0635']),
+ ('\U0001ee32', &['\u0642']), ('\U0001ee34', &['\u0634']), ('\U0001ee35', &['\u062a']),
+ ('\U0001ee36', &['\u062b']), ('\U0001ee37', &['\u062e']), ('\U0001ee39', &['\u0636']),
+ ('\U0001ee3b', &['\u063a']), ('\U0001ee42', &['\u062c']), ('\U0001ee47', &['\u062d']),
+ ('\U0001ee49', &['\u064a']), ('\U0001ee4b', &['\u0644']), ('\U0001ee4d', &['\u0646']),
+ ('\U0001ee4e', &['\u0633']), ('\U0001ee4f', &['\u0639']), ('\U0001ee51', &['\u0635']),
+ ('\U0001ee52', &['\u0642']), ('\U0001ee54', &['\u0634']), ('\U0001ee57', &['\u062e']),
+ ('\U0001ee59', &['\u0636']), ('\U0001ee5b', &['\u063a']), ('\U0001ee5d', &['\u06ba']),
+ ('\U0001ee5f', &['\u066f']), ('\U0001ee61', &['\u0628']), ('\U0001ee62', &['\u062c']),
+ ('\U0001ee64', &['\u0647']), ('\U0001ee67', &['\u062d']), ('\U0001ee68', &['\u0637']),
+ ('\U0001ee69', &['\u064a']), ('\U0001ee6a', &['\u0643']), ('\U0001ee6c', &['\u0645']),
+ ('\U0001ee6d', &['\u0646']), ('\U0001ee6e', &['\u0633']), ('\U0001ee6f', &['\u0639']),
+ ('\U0001ee70', &['\u0641']), ('\U0001ee71', &['\u0635']), ('\U0001ee72', &['\u0642']),
+ ('\U0001ee74', &['\u0634']), ('\U0001ee75', &['\u062a']), ('\U0001ee76', &['\u062b']),
+ ('\U0001ee77', &['\u062e']), ('\U0001ee79', &['\u0636']), ('\U0001ee7a', &['\u0638']),
+ ('\U0001ee7b', &['\u063a']), ('\U0001ee7c', &['\u066e']), ('\U0001ee7e', &['\u06a1']),
+ ('\U0001ee80', &['\u0627']), ('\U0001ee81', &['\u0628']), ('\U0001ee82', &['\u062c']),
+ ('\U0001ee83', &['\u062f']), ('\U0001ee84', &['\u0647']), ('\U0001ee85', &['\u0648']),
+ ('\U0001ee86', &['\u0632']), ('\U0001ee87', &['\u062d']), ('\U0001ee88', &['\u0637']),
+ ('\U0001ee89', &['\u064a']), ('\U0001ee8b', &['\u0644']), ('\U0001ee8c', &['\u0645']),
+ ('\U0001ee8d', &['\u0646']), ('\U0001ee8e', &['\u0633']), ('\U0001ee8f', &['\u0639']),
+ ('\U0001ee90', &['\u0641']), ('\U0001ee91', &['\u0635']), ('\U0001ee92', &['\u0642']),
+ ('\U0001ee93', &['\u0631']), ('\U0001ee94', &['\u0634']), ('\U0001ee95', &['\u062a']),
+ ('\U0001ee96', &['\u062b']), ('\U0001ee97', &['\u062e']), ('\U0001ee98', &['\u0630']),
+ ('\U0001ee99', &['\u0636']), ('\U0001ee9a', &['\u0638']), ('\U0001ee9b', &['\u063a']),
+ ('\U0001eea1', &['\u0628']), ('\U0001eea2', &['\u062c']), ('\U0001eea3', &['\u062f']),
+ ('\U0001eea5', &['\u0648']), ('\U0001eea6', &['\u0632']), ('\U0001eea7', &['\u062d']),
+ ('\U0001eea8', &['\u0637']), ('\U0001eea9', &['\u064a']), ('\U0001eeab', &['\u0644']),
+ ('\U0001eeac', &['\u0645']), ('\U0001eead', &['\u0646']), ('\U0001eeae', &['\u0633']),
+ ('\U0001eeaf', &['\u0639']), ('\U0001eeb0', &['\u0641']), ('\U0001eeb1', &['\u0635']),
+ ('\U0001eeb2', &['\u0642']), ('\U0001eeb3', &['\u0631']), ('\U0001eeb4', &['\u0634']),
+ ('\U0001eeb5', &['\u062a']), ('\U0001eeb6', &['\u062b']), ('\U0001eeb7', &['\u062e']),
+ ('\U0001eeb8', &['\u0630']), ('\U0001eeb9', &['\u0636']), ('\U0001eeba', &['\u0638']),
+ ('\U0001eebb', &['\u063a']), ('\U0001f100', &['\x30', '\x2e']), ('\U0001f101', &['\x30',
+ '\x2c']), ('\U0001f102', &['\x31', '\x2c']), ('\U0001f103', &['\x32', '\x2c']),
+ ('\U0001f104', &['\x33', '\x2c']), ('\U0001f105', &['\x34', '\x2c']), ('\U0001f106',
+ &['\x35', '\x2c']), ('\U0001f107', &['\x36', '\x2c']), ('\U0001f108', &['\x37', '\x2c']),
+ ('\U0001f109', &['\x38', '\x2c']), ('\U0001f10a', &['\x39', '\x2c']), ('\U0001f110',
+ &['\x28', '\x41', '\x29']), ('\U0001f111', &['\x28', '\x42', '\x29']), ('\U0001f112',
+ &['\x28', '\x43', '\x29']), ('\U0001f113', &['\x28', '\x44', '\x29']), ('\U0001f114',
+ &['\x28', '\x45', '\x29']), ('\U0001f115', &['\x28', '\x46', '\x29']), ('\U0001f116',
+ &['\x28', '\x47', '\x29']), ('\U0001f117', &['\x28', '\x48', '\x29']), ('\U0001f118',
+ &['\x28', '\x49', '\x29']), ('\U0001f119', &['\x28', '\x4a', '\x29']), ('\U0001f11a',
+ &['\x28', '\x4b', '\x29']), ('\U0001f11b', &['\x28', '\x4c', '\x29']), ('\U0001f11c',
+ &['\x28', '\x4d', '\x29']), ('\U0001f11d', &['\x28', '\x4e', '\x29']), ('\U0001f11e',
+ &['\x28', '\x4f', '\x29']), ('\U0001f11f', &['\x28', '\x50', '\x29']), ('\U0001f120',
+ &['\x28', '\x51', '\x29']), ('\U0001f121', &['\x28', '\x52', '\x29']), ('\U0001f122',
+ &['\x28', '\x53', '\x29']), ('\U0001f123', &['\x28', '\x54', '\x29']), ('\U0001f124',
+ &['\x28', '\x55', '\x29']), ('\U0001f125', &['\x28', '\x56', '\x29']), ('\U0001f126',
+ &['\x28', '\x57', '\x29']), ('\U0001f127', &['\x28', '\x58', '\x29']), ('\U0001f128',
+ &['\x28', '\x59', '\x29']), ('\U0001f129', &['\x28', '\x5a', '\x29']), ('\U0001f12a',
+ &['\u3014', '\x53', '\u3015']), ('\U0001f12b', &['\x43']), ('\U0001f12c', &['\x52']),
+ ('\U0001f12d', &['\x43', '\x44']), ('\U0001f12e', &['\x57', '\x5a']), ('\U0001f130',
+ &['\x41']), ('\U0001f131', &['\x42']), ('\U0001f132', &['\x43']), ('\U0001f133', &['\x44']),
+ ('\U0001f134', &['\x45']), ('\U0001f135', &['\x46']), ('\U0001f136', &['\x47']),
+ ('\U0001f137', &['\x48']), ('\U0001f138', &['\x49']), ('\U0001f139', &['\x4a']),
+ ('\U0001f13a', &['\x4b']), ('\U0001f13b', &['\x4c']), ('\U0001f13c', &['\x4d']),
+ ('\U0001f13d', &['\x4e']), ('\U0001f13e', &['\x4f']), ('\U0001f13f', &['\x50']),
+ ('\U0001f140', &['\x51']), ('\U0001f141', &['\x52']), ('\U0001f142', &['\x53']),
+ ('\U0001f143', &['\x54']), ('\U0001f144', &['\x55']), ('\U0001f145', &['\x56']),
+ ('\U0001f146', &['\x57']), ('\U0001f147', &['\x58']), ('\U0001f148', &['\x59']),
+ ('\U0001f149', &['\x5a']), ('\U0001f14a', &['\x48', '\x56']), ('\U0001f14b', &['\x4d',
+ '\x56']), ('\U0001f14c', &['\x53', '\x44']), ('\U0001f14d', &['\x53', '\x53']),
+ ('\U0001f14e', &['\x50', '\x50', '\x56']), ('\U0001f14f', &['\x57', '\x43']), ('\U0001f16a',
+ &['\x4d', '\x43']), ('\U0001f16b', &['\x4d', '\x44']), ('\U0001f190', &['\x44', '\x4a']),
+ ('\U0001f200', &['\u307b', '\u304b']), ('\U0001f201', &['\u30b3', '\u30b3']), ('\U0001f202',
+ &['\u30b5']), ('\U0001f210', &['\u624b']), ('\U0001f211', &['\u5b57']), ('\U0001f212',
+ &['\u53cc']), ('\U0001f213', &['\u30c7']), ('\U0001f214', &['\u4e8c']), ('\U0001f215',
+ &['\u591a']), ('\U0001f216', &['\u89e3']), ('\U0001f217', &['\u5929']), ('\U0001f218',
+ &['\u4ea4']), ('\U0001f219', &['\u6620']), ('\U0001f21a', &['\u7121']), ('\U0001f21b',
+ &['\u6599']), ('\U0001f21c', &['\u524d']), ('\U0001f21d', &['\u5f8c']), ('\U0001f21e',
+ &['\u518d']), ('\U0001f21f', &['\u65b0']), ('\U0001f220', &['\u521d']), ('\U0001f221',
+ &['\u7d42']), ('\U0001f222', &['\u751f']), ('\U0001f223', &['\u8ca9']), ('\U0001f224',
+ &['\u58f0']), ('\U0001f225', &['\u5439']), ('\U0001f226', &['\u6f14']), ('\U0001f227',
+ &['\u6295']), ('\U0001f228', &['\u6355']), ('\U0001f229', &['\u4e00']), ('\U0001f22a',
+ &['\u4e09']), ('\U0001f22b', &['\u904a']), ('\U0001f22c', &['\u5de6']), ('\U0001f22d',
+ &['\u4e2d']), ('\U0001f22e', &['\u53f3']), ('\U0001f22f', &['\u6307']), ('\U0001f230',
+ &['\u8d70']), ('\U0001f231', &['\u6253']), ('\U0001f232', &['\u7981']), ('\U0001f233',
+ &['\u7a7a']), ('\U0001f234', &['\u5408']), ('\U0001f235', &['\u6e80']), ('\U0001f236',
+ &['\u6709']), ('\U0001f237', &['\u6708']), ('\U0001f238', &['\u7533']), ('\U0001f239',
+ &['\u5272']), ('\U0001f23a', &['\u55b6']), ('\U0001f240', &['\u3014', '\u672c', '\u3015']),
+ ('\U0001f241', &['\u3014', '\u4e09', '\u3015']), ('\U0001f242', &['\u3014', '\u4e8c',
+ '\u3015']), ('\U0001f243', &['\u3014', '\u5b89', '\u3015']), ('\U0001f244', &['\u3014',
+ '\u70b9', '\u3015']), ('\U0001f245', &['\u3014', '\u6253', '\u3015']), ('\U0001f246',
+ &['\u3014', '\u76d7', '\u3015']), ('\U0001f247', &['\u3014', '\u52dd', '\u3015']),
+ ('\U0001f248', &['\u3014', '\u6557', '\u3015']), ('\U0001f250', &['\u5f97']), ('\U0001f251',
+ &['\u53ef'])
+ ];
+
+ static combining_class_table : &'static [(char, char, u8)] = &[
+ ('\u0300', '\u0314', 230), ('\u0315', '\u0315', 232),
+ ('\u0316', '\u0319', 220), ('\u031a', '\u031a', 232),
+ ('\u031b', '\u031b', 216), ('\u031c', '\u0320', 220),
+ ('\u0321', '\u0322', 202), ('\u0323', '\u0326', 220),
+ ('\u0327', '\u0328', 202), ('\u0329', '\u0333', 220),
+ ('\u0334', '\u0338', 1), ('\u0339', '\u033c', 220),
+ ('\u033d', '\u0344', 230), ('\u0345', '\u0345', 240),
+ ('\u0346', '\u0346', 230), ('\u0347', '\u0349', 220),
+ ('\u034a', '\u034c', 230), ('\u034d', '\u034e', 220),
+ ('\u0350', '\u0352', 230), ('\u0353', '\u0356', 220),
+ ('\u0357', '\u0357', 230), ('\u0358', '\u0358', 232),
+ ('\u0359', '\u035a', 220), ('\u035b', '\u035b', 230),
+ ('\u035c', '\u035c', 233), ('\u035d', '\u035e', 234),
+ ('\u035f', '\u035f', 233), ('\u0360', '\u0361', 234),
+ ('\u0362', '\u0362', 233), ('\u0363', '\u036f', 230),
+ ('\u0483', '\u0487', 230), ('\u0591', '\u0591', 220),
+ ('\u0592', '\u0595', 230), ('\u0596', '\u0596', 220),
+ ('\u0597', '\u0599', 230), ('\u059a', '\u059a', 222),
+ ('\u059b', '\u059b', 220), ('\u059c', '\u05a1', 230),
+ ('\u05a2', '\u05a7', 220), ('\u05a8', '\u05a9', 230),
+ ('\u05aa', '\u05aa', 220), ('\u05ab', '\u05ac', 230),
+ ('\u05ad', '\u05ad', 222), ('\u05ae', '\u05ae', 228),
+ ('\u05af', '\u05af', 230), ('\u05b0', '\u05b0', 10),
+ ('\u05b1', '\u05b1', 11), ('\u05b2', '\u05b2', 12),
+ ('\u05b3', '\u05b3', 13), ('\u05b4', '\u05b4', 14),
+ ('\u05b5', '\u05b5', 15), ('\u05b6', '\u05b6', 16),
+ ('\u05b7', '\u05b7', 17), ('\u05b8', '\u05b8', 18),
+ ('\u05b9', '\u05ba', 19), ('\u05bb', '\u05bb', 20),
+ ('\u05bc', '\u05bc', 21), ('\u05bd', '\u05bd', 22),
+ ('\u05bf', '\u05bf', 23), ('\u05c1', '\u05c1', 24),
+ ('\u05c2', '\u05c2', 25), ('\u05c4', '\u05c4', 230),
+ ('\u05c5', '\u05c5', 220), ('\u05c7', '\u05c7', 18),
+ ('\u0610', '\u0617', 230), ('\u0618', '\u0618', 30),
+ ('\u0619', '\u0619', 31), ('\u061a', '\u061a', 32),
+ ('\u064b', '\u064b', 27), ('\u064c', '\u064c', 28),
+ ('\u064d', '\u064d', 29), ('\u064e', '\u064e', 30),
+ ('\u064f', '\u064f', 31), ('\u0650', '\u0650', 32),
+ ('\u0651', '\u0651', 33), ('\u0652', '\u0652', 34),
+ ('\u0653', '\u0654', 230), ('\u0655', '\u0656', 220),
+ ('\u0657', '\u065b', 230), ('\u065c', '\u065c', 220),
+ ('\u065d', '\u065e', 230), ('\u065f', '\u065f', 220),
+ ('\u0670', '\u0670', 35), ('\u06d6', '\u06dc', 230),
+ ('\u06df', '\u06e2', 230), ('\u06e3', '\u06e3', 220),
+ ('\u06e4', '\u06e4', 230), ('\u06e7', '\u06e8', 230),
+ ('\u06ea', '\u06ea', 220), ('\u06eb', '\u06ec', 230),
+ ('\u06ed', '\u06ed', 220), ('\u0711', '\u0711', 36),
+ ('\u0730', '\u0730', 230), ('\u0731', '\u0731', 220),
+ ('\u0732', '\u0733', 230), ('\u0734', '\u0734', 220),
+ ('\u0735', '\u0736', 230), ('\u0737', '\u0739', 220),
+ ('\u073a', '\u073a', 230), ('\u073b', '\u073c', 220),
+ ('\u073d', '\u073d', 230), ('\u073e', '\u073e', 220),
+ ('\u073f', '\u0741', 230), ('\u0742', '\u0742', 220),
+ ('\u0743', '\u0743', 230), ('\u0744', '\u0744', 220),
+ ('\u0745', '\u0745', 230), ('\u0746', '\u0746', 220),
+ ('\u0747', '\u0747', 230), ('\u0748', '\u0748', 220),
+ ('\u0749', '\u074a', 230), ('\u07eb', '\u07f1', 230),
+ ('\u07f2', '\u07f2', 220), ('\u07f3', '\u07f3', 230),
+ ('\u0816', '\u0819', 230), ('\u081b', '\u0823', 230),
+ ('\u0825', '\u0827', 230), ('\u0829', '\u082d', 230),
+ ('\u0859', '\u085b', 220), ('\u08e4', '\u08e5', 230),
+ ('\u08e6', '\u08e6', 220), ('\u08e7', '\u08e8', 230),
+ ('\u08e9', '\u08e9', 220), ('\u08ea', '\u08ec', 230),
+ ('\u08ed', '\u08ef', 220), ('\u08f0', '\u08f0', 27),
+ ('\u08f1', '\u08f1', 28), ('\u08f2', '\u08f2', 29),
+ ('\u08f3', '\u08f5', 230), ('\u08f6', '\u08f6', 220),
+ ('\u08f7', '\u08f8', 230), ('\u08f9', '\u08fa', 220),
+ ('\u08fb', '\u08fe', 230), ('\u093c', '\u093c', 7),
+ ('\u094d', '\u094d', 9), ('\u0951', '\u0951', 230),
+ ('\u0952', '\u0952', 220), ('\u0953', '\u0954', 230),
+ ('\u09bc', '\u09bc', 7), ('\u09cd', '\u09cd', 9),
+ ('\u0a3c', '\u0a3c', 7), ('\u0a4d', '\u0a4d', 9),
+ ('\u0abc', '\u0abc', 7), ('\u0acd', '\u0acd', 9),
+ ('\u0b3c', '\u0b3c', 7), ('\u0b4d', '\u0b4d', 9),
+ ('\u0bcd', '\u0bcd', 9), ('\u0c4d', '\u0c4d', 9),
+ ('\u0c55', '\u0c55', 84), ('\u0c56', '\u0c56', 91),
+ ('\u0cbc', '\u0cbc', 7), ('\u0ccd', '\u0ccd', 9),
+ ('\u0d4d', '\u0d4d', 9), ('\u0dca', '\u0dca', 9),
+ ('\u0e38', '\u0e39', 103), ('\u0e3a', '\u0e3a', 9),
+ ('\u0e48', '\u0e4b', 107), ('\u0eb8', '\u0eb9', 118),
+ ('\u0ec8', '\u0ecb', 122), ('\u0f18', '\u0f19', 220),
+ ('\u0f35', '\u0f35', 220), ('\u0f37', '\u0f37', 220),
+ ('\u0f39', '\u0f39', 216), ('\u0f71', '\u0f71', 129),
+ ('\u0f72', '\u0f72', 130), ('\u0f74', '\u0f74', 132),
+ ('\u0f7a', '\u0f7d', 130), ('\u0f80', '\u0f80', 130),
+ ('\u0f82', '\u0f83', 230), ('\u0f84', '\u0f84', 9),
+ ('\u0f86', '\u0f87', 230), ('\u0fc6', '\u0fc6', 220),
+ ('\u1037', '\u1037', 7), ('\u1039', '\u103a', 9),
+ ('\u108d', '\u108d', 220), ('\u135d', '\u135f', 230),
+ ('\u1714', '\u1714', 9), ('\u1734', '\u1734', 9),
+ ('\u17d2', '\u17d2', 9), ('\u17dd', '\u17dd', 230),
+ ('\u18a9', '\u18a9', 228), ('\u1939', '\u1939', 222),
+ ('\u193a', '\u193a', 230), ('\u193b', '\u193b', 220),
+ ('\u1a17', '\u1a17', 230), ('\u1a18', '\u1a18', 220),
+ ('\u1a60', '\u1a60', 9), ('\u1a75', '\u1a7c', 230),
+ ('\u1a7f', '\u1a7f', 220), ('\u1b34', '\u1b34', 7),
+ ('\u1b44', '\u1b44', 9), ('\u1b6b', '\u1b6b', 230),
+ ('\u1b6c', '\u1b6c', 220), ('\u1b6d', '\u1b73', 230),
+ ('\u1baa', '\u1bab', 9), ('\u1be6', '\u1be6', 7),
+ ('\u1bf2', '\u1bf3', 9), ('\u1c37', '\u1c37', 7),
+ ('\u1cd0', '\u1cd2', 230), ('\u1cd4', '\u1cd4', 1),
+ ('\u1cd5', '\u1cd9', 220), ('\u1cda', '\u1cdb', 230),
+ ('\u1cdc', '\u1cdf', 220), ('\u1ce0', '\u1ce0', 230),
+ ('\u1ce2', '\u1ce8', 1), ('\u1ced', '\u1ced', 220),
+ ('\u1cf4', '\u1cf4', 230), ('\u1dc0', '\u1dc1', 230),
+ ('\u1dc2', '\u1dc2', 220), ('\u1dc3', '\u1dc9', 230),
+ ('\u1dca', '\u1dca', 220), ('\u1dcb', '\u1dcc', 230),
+ ('\u1dcd', '\u1dcd', 234), ('\u1dce', '\u1dce', 214),
+ ('\u1dcf', '\u1dcf', 220), ('\u1dd0', '\u1dd0', 202),
+ ('\u1dd1', '\u1de6', 230), ('\u1dfc', '\u1dfc', 233),
+ ('\u1dfd', '\u1dfd', 220), ('\u1dfe', '\u1dfe', 230),
+ ('\u1dff', '\u1dff', 220), ('\u20d0', '\u20d1', 230),
+ ('\u20d2', '\u20d3', 1), ('\u20d4', '\u20d7', 230),
+ ('\u20d8', '\u20da', 1), ('\u20db', '\u20dc', 230),
+ ('\u20e1', '\u20e1', 230), ('\u20e5', '\u20e6', 1),
+ ('\u20e7', '\u20e7', 230), ('\u20e8', '\u20e8', 220),
+ ('\u20e9', '\u20e9', 230), ('\u20ea', '\u20eb', 1),
+ ('\u20ec', '\u20ef', 220), ('\u20f0', '\u20f0', 230),
+ ('\u2cef', '\u2cf1', 230), ('\u2d7f', '\u2d7f', 9),
+ ('\u2de0', '\u2dff', 230), ('\u302a', '\u302a', 218),
+ ('\u302b', '\u302b', 228), ('\u302c', '\u302c', 232),
+ ('\u302d', '\u302d', 222), ('\u302e', '\u302f', 224),
+ ('\u3099', '\u309a', 8), ('\ua66f', '\ua66f', 230),
+ ('\ua674', '\ua67d', 230), ('\ua69f', '\ua69f', 230),
+ ('\ua6f0', '\ua6f1', 230), ('\ua806', '\ua806', 9),
+ ('\ua8c4', '\ua8c4', 9), ('\ua8e0', '\ua8f1', 230),
+ ('\ua92b', '\ua92d', 220), ('\ua953', '\ua953', 9),
+ ('\ua9b3', '\ua9b3', 7), ('\ua9c0', '\ua9c0', 9),
+ ('\uaab0', '\uaab0', 230), ('\uaab2', '\uaab3', 230),
+ ('\uaab4', '\uaab4', 220), ('\uaab7', '\uaab8', 230),
+ ('\uaabe', '\uaabf', 230), ('\uaac1', '\uaac1', 230),
+ ('\uaaf6', '\uaaf6', 9), ('\uabed', '\uabed', 9),
+ ('\ufb1e', '\ufb1e', 26), ('\ufe20', '\ufe26', 230),
+ ('\U000101fd', '\U000101fd', 220), ('\U00010a0d', '\U00010a0d', 220),
+ ('\U00010a0f', '\U00010a0f', 230), ('\U00010a38', '\U00010a38', 230),
+ ('\U00010a39', '\U00010a39', 1), ('\U00010a3a', '\U00010a3a', 220),
+ ('\U00010a3f', '\U00010a3f', 9), ('\U00011046', '\U00011046', 9),
+ ('\U000110b9', '\U000110b9', 9), ('\U000110ba', '\U000110ba', 7),
+ ('\U00011100', '\U00011102', 230), ('\U00011133', '\U00011134', 9),
+ ('\U000111c0', '\U000111c0', 9), ('\U000116b6', '\U000116b6', 9),
+ ('\U000116b7', '\U000116b7', 7), ('\U0001d165', '\U0001d166', 216),
+ ('\U0001d167', '\U0001d169', 1), ('\U0001d16d', '\U0001d16d', 226),
+ ('\U0001d16e', '\U0001d172', 216), ('\U0001d17b', '\U0001d182', 220),
+ ('\U0001d185', '\U0001d189', 230), ('\U0001d18a', '\U0001d18b', 220),
+ ('\U0001d1aa', '\U0001d1ad', 230), ('\U0001d242', '\U0001d244', 230)
+ ];
+ pub fn canonical(c: char, i: &fn(char)) { d(c, i, false); }
+
+ pub fn compatibility(c: char, i: &fn(char)) { d(c, i, true); }
+
+ pub fn canonical_combining_class(c: char) -> u8 {
+ bsearch_range_value_table(c, combining_class_table)
+ }
+
+ fn d(c: char, i: &fn(char), k: bool) {
+ use iterator::Iterator;
+ if c <= '\x7f' { i(c); return; }
+
+ match bsearch_table(c, canonical_table) {
+ Some(canon) => {
+ for x in canon.iter() {
+ d(*x, |b| i(b), k);
+ }
+ return;
+ }
+ None => ()
+ }
+
+ if !k { i(c); return; }
+
+ match bsearch_table(c, compatibility_table) {
+ Some(compat) => {
+ for x in compat.iter() {
+ d(*x, |b| i(b), k);
+ }
+ return;
+ }
+ None => ()
+ }
+
+ i(c);
+ }
+}
+
pub mod derived_property {
fn bsearch_range_table(c: char, r: &'static [(char,char)]) -> bool {
}
/**
- * A signed atomic integer type, supporting basic atomic aritmetic operations
+ * A signed atomic integer type, supporting basic atomic arithmetic operations
*/
pub struct AtomicInt {
priv v: int
}
/**
- * An unsigned atomic integer type, supporting basic atomic aritmetic operations
+ * An unsigned atomic integer type, supporting basic atomic arithmetic operations
*/
pub struct AtomicUint {
priv v: uint
* A fence 'A' which has `Release` ordering semantics, synchronizes with a
* fence 'B' with (at least) `Acquire` semantics, if and only if there exists
* atomic operations X and Y, both operating on some atomic object 'M' such
- * that A is sequenced before X, Y is synchronized before B and Y obsevers
+ * that A is sequenced before X, Y is synchronized before B and Y observers
* the change to M. This provides a happens-before dependence between A and B.
*
* Atomic operations with `Release` or `Acquire` semantics can also synchronize
use result::*;
pub unsafe fn open_external(filename: &path::Path) -> *libc::c_void {
+ #[fixed_stack_segment]; #[inline(never)];
do filename.with_c_str |raw_name| {
dlopen(raw_name, Lazy as libc::c_int)
}
}
pub unsafe fn open_internal() -> *libc::c_void {
+ #[fixed_stack_segment]; #[inline(never)];
+
dlopen(ptr::null(), Lazy as libc::c_int)
}
pub fn check_for_errors_in<T>(f: &fn()->T) -> Result<T, ~str> {
+ #[fixed_stack_segment]; #[inline(never)];
+
unsafe {
do atomically {
let _old_error = dlerror();
}
pub unsafe fn symbol(handle: *libc::c_void, symbol: *libc::c_char) -> *libc::c_void {
+ #[fixed_stack_segment]; #[inline(never)];
+
dlsym(handle, symbol)
}
pub unsafe fn close(handle: *libc::c_void) {
+ #[fixed_stack_segment]; #[inline(never)];
+
dlclose(handle); ()
}
use result::*;
pub unsafe fn open_external(filename: &path::Path) -> *libc::c_void {
+ #[fixed_stack_segment]; #[inline(never)];
do os::win32::as_utf16_p(filename.to_str()) |raw_name| {
LoadLibraryW(raw_name)
}
}
pub unsafe fn open_internal() -> *libc::c_void {
+ #[fixed_stack_segment]; #[inline(never)];
let handle = ptr::null();
GetModuleHandleExW(0 as libc::DWORD, ptr::null(), &handle as **libc::c_void);
handle
}
pub fn check_for_errors_in<T>(f: &fn()->T) -> Result<T, ~str> {
+ #[fixed_stack_segment]; #[inline(never)];
unsafe {
do atomically {
SetLastError(0);
}
}
pub unsafe fn symbol(handle: *libc::c_void, symbol: *libc::c_char) -> *libc::c_void {
+ #[fixed_stack_segment]; #[inline(never)];
GetProcAddress(handle, symbol)
}
pub unsafe fn close(handle: *libc::c_void) {
+ #[fixed_stack_segment]; #[inline(never)];
FreeLibrary(handle); ()
}
use str;
use sys;
use num;
- use uint;
use vec;
use option::{Some, None, Option};
return if prec == 0u && num == 0u {
~""
} else {
- let s = uint::to_str_radix(num, radix);
+ let s = num.to_str_radix(radix);
let len = s.char_len();
if len < prec {
let diff = prec - len;
do || {
...
}.finally {
- alway_run_this();
+ always_run_this();
}
~~~
*/
A quick refresher on memory ordering:
-* Acquire - a barrier for aquiring a lock. Subsequent reads and writes
+* Acquire - a barrier for acquiring a lock. Subsequent reads and writes
take place after the barrier.
* Release - a barrier for releasing a lock. Preceding reads and writes
take place before the barrier.
borrowck::check_not_borrowed(a, file, line)
}
-#[lang="annihilate"]
-pub unsafe fn annihilate() {
- ::cleanup::annihilate()
-}
-
#[lang="start"]
pub fn start(main: *u8, argc: int, argv: **c_char,
crate_map: *u8) -> int {
use comm;
use prelude::*;
use task;
+use libc::uintptr_t;
pub mod dynamic_lib;
/// can lead to deadlock. Calling change_dir_locked recursively will
/// also deadlock.
pub fn change_dir_locked(p: &Path, action: &fn()) -> bool {
+ #[fixed_stack_segment]; #[inline(never)];
+
use os;
use os::change_dir;
use unstable::sync::atomically;
fn rust_drop_change_dir_lock();
}
}
+
+
+/// Dynamically inquire about whether we're running under V.
+/// You should usually not use this unless your test definitely
+/// can't run correctly un-altered. Valgrind is there to help
+/// you notice weirdness in normal, un-doctored code paths!
+pub fn running_on_valgrind() -> bool {
+ #[fixed_stack_segment]; #[inline(never)];
+ unsafe { rust_running_on_valgrind() != 0 }
+}
+
+extern {
+ fn rust_running_on_valgrind() -> uintptr_t;
+}
/**
* Enables a runtime assertion that no operation in the argument closure shall
- * use scheduler operations (yield, recv, spawn, etc). This is for use with
+ * use scheduler operations (deschedule, recv, spawn, etc). This is for use with
* pthread mutexes, which may block the entire scheduler thread, rather than
- * just one task, and is hence prone to deadlocks if mixed with yielding.
+ * just one task, and is hence prone to deadlocks if mixed with descheduling.
*
* NOTE: THIS DOES NOT PROVIDE LOCKING, or any sort of critical-section
* synchronization whatsoever. It only makes sense to use for CPU-local issues.
if in_green_task_context() {
let t = Local::unsafe_borrow::<Task>();
do (|| {
- (*t).death.inhibit_yield();
+ (*t).death.inhibit_deschedule();
f()
}).finally {
- (*t).death.allow_yield();
+ (*t).death.allow_deschedule();
}
} else {
f()
}
}
- #[inline]
pub unsafe fn lock<T>(&self, f: &fn() -> T) -> T {
do atomically {
rust_lock_little_lock(self.l);
* This uses a pthread mutex, not one that's aware of the userspace scheduler.
* The user of an Exclusive must be careful not to invoke any functions that may
* reschedule the task while holding the lock, or deadlock may result. If you
- * need to block or yield while accessing shared state, use extra::sync::RWArc.
+ * need to block or deschedule while accessing shared state, use extra::sync::RWArc.
*/
pub struct Exclusive<T> {
x: UnsafeAtomicRcBox<ExData<T>>
// Exactly like std::arc::MutexArc,access(), but with the LittleLock
// instead of a proper mutex. Same reason for being unsafe.
//
- // Currently, scheduling operations (i.e., yielding, receiving on a pipe,
+ // Currently, scheduling operations (i.e., descheduling, receiving on a pipe,
// accessing the provided condition variable) are prohibited while inside
// the Exclusive. Supporting that is a work in progress.
#[inline]
}
}
-extern {
- fn rust_create_little_lock() -> rust_little_lock;
- fn rust_destroy_little_lock(lock: rust_little_lock);
- fn rust_lock_little_lock(lock: rust_little_lock);
- fn rust_unlock_little_lock(lock: rust_little_lock);
+#[cfg(stage0)]
+mod macro_hack {
+#[macro_escape];
+macro_rules! externfn(
+ (fn $name:ident () $(-> $ret_ty:ty),*) => (
+ extern {
+ fn $name() $(-> $ret_ty),*;
+ }
+ );
+ (fn $name:ident ($($arg_name:ident : $arg_ty:ty),*) $(-> $ret_ty:ty),*) => (
+ extern {
+ fn $name($($arg_name : $arg_ty),*) $(-> $ret_ty),*;
+ }
+ )
+)
}
+externfn!(fn rust_create_little_lock() -> rust_little_lock)
+externfn!(fn rust_destroy_little_lock(lock: rust_little_lock))
+externfn!(fn rust_lock_little_lock(lock: rust_little_lock))
+externfn!(fn rust_unlock_little_lock(lock: rust_little_lock))
+
#[cfg(test)]
mod tests {
use cell::Cell;
fn test_atomically() {
// NB. The whole runtime will abort on an 'atomic-sleep' violation,
// so we can't really test for the converse behaviour.
- unsafe { do atomically { } } task::yield(); // oughtn't fail
+ unsafe { do atomically { } } task::deschedule(); // oughtn't fail
}
#[test]
c.send(());
}
p.recv();
- task::yield(); // Try to make the unwrapper get blocked first.
+ task::deschedule(); // Try to make the unwrapper get blocked first.
let left_x = x.try_unwrap();
assert!(left_x.is_left());
util::ignore(left_x);
do task::spawn {
let x2 = x2.take();
unsafe { do x2.with |_hello| { } }
- task::yield();
+ task::deschedule();
}
assert!(x.unwrap() == ~~"hello");
let x = Exclusive::new(~~"hello");
let x2 = x.clone();
do task::spawn {
- do 10.times { task::yield(); } // try to let the unwrapper go
+ do 10.times { task::deschedule(); } // try to let the unwrapper go
fail!(); // punt it awake from its deadlock
}
let _z = x.unwrap();
use cmp;
use iterator::*;
use libc::c_void;
-use num::Zero;
+use num::{Integer, Zero, CheckedAdd, Saturating};
use option::{None, Option, Some};
use ptr::to_unsafe_ptr;
use ptr;
}
impl<'self, T> Iterator<&'self [T]> for SplitIterator<'self, T> {
+ #[inline]
fn next(&mut self) -> Option<&'self [T]> {
if self.finished { return None; }
}
}
}
+
+ #[inline]
+ fn size_hint(&self) -> (uint, Option<uint>) {
+ if self.finished {
+ return (0, Some(0))
+ }
+ // if the predicate doesn't match anything, we yield one slice
+ // if it matches every element, we yield N+1 empty slices where
+ // N is either the number of elements or the number of splits.
+ match (self.v.len(), self.n) {
+ (0,_) => (1, Some(1)),
+ (_,0) => (1, Some(1)),
+ (l,n) => (1, cmp::min(l,n).checked_add(&1u))
+ }
+ }
}
/// An iterator over the slices of a vector separated by elements that
}
impl<'self, T> Iterator<&'self [T]> for RSplitIterator<'self, T> {
+ #[inline]
fn next(&mut self) -> Option<&'self [T]> {
if self.finished { return None; }
}
}
}
+
+ #[inline]
+ fn size_hint(&self) -> (uint, Option<uint>) {
+ if self.finished {
+ return (0, Some(0))
+ }
+ match (self.v.len(), self.n) {
+ (0,_) => (1, Some(1)),
+ (_,0) => (1, Some(1)),
+ (l,n) => (1, cmp::min(l,n).checked_add(&1u))
+ }
+ }
}
// Appending
}
impl<'self, T> Iterator<&'self [T]> for WindowIter<'self, T> {
+ #[inline]
fn next(&mut self) -> Option<&'self [T]> {
if self.size > self.v.len() {
None
ret
}
}
+
+ #[inline]
+ fn size_hint(&self) -> (uint, Option<uint>) {
+ if self.size > self.v.len() {
+ (0, Some(0))
+ } else {
+ let x = self.v.len() - self.size;
+ (x.saturating_add(1), x.checked_add(&1u))
+ }
+ }
}
/// An iterator over a vector in (non-overlapping) chunks (`size`
/// elements at a time).
///
/// When the vector len is not evenly divided by the chunk size,
-/// the last slice of the iteration will be the remainer.
+/// the last slice of the iteration will be the remainder.
#[deriving(Clone)]
pub struct ChunkIter<'self, T> {
priv v: &'self [T],
}
impl<'self, T> Iterator<&'self [T]> for ChunkIter<'self, T> {
+ #[inline]
fn next(&mut self) -> Option<&'self [T]> {
if self.v.len() == 0 {
None
Some(fst)
}
}
+
+ #[inline]
+ fn size_hint(&self) -> (uint, Option<uint>) {
+ if self.v.len() == 0 {
+ (0, Some(0))
+ } else {
+ let (n, rem) = self.v.len().div_rem(&self.size);
+ let n = if rem > 0 { n+1 } else { n };
+ (n, Some(n))
+ }
+ }
}
impl<'self, T> DoubleEndedIterator<&'self [T]> for ChunkIter<'self, T> {
+ #[inline]
fn next_back(&mut self) -> Option<&'self [T]> {
if self.v.len() == 0 {
None
fn reserve(&mut self, n: uint);
fn reserve_at_least(&mut self, n: uint);
fn capacity(&self) -> uint;
+ fn shrink_to_fit(&mut self);
fn push(&mut self, t: T);
unsafe fn push_fast(&mut self, t: T);
*
* * n - The number of elements to reserve space for
*/
+ #[inline]
fn reserve_at_least(&mut self, n: uint) {
self.reserve(uint::next_power_of_two(n));
}
}
}
+ /// Shrink the capacity of the vector to match the length
+ fn shrink_to_fit(&mut self) {
+ unsafe {
+ let ptr: *mut *mut Vec<()> = cast::transmute(self);
+ let alloc = (**ptr).fill;
+ let size = alloc + sys::size_of::<Vec<()>>();
+ *ptr = realloc_raw(*ptr as *mut c_void, size) as *mut Vec<()>;
+ (**ptr).alloc = alloc;
+ }
+ }
+
/// Append an element to a vector
#[inline]
fn push(&mut self, t: T) {
* Sets the length of a vector
*
* This will explicitly set the size of the vector, without actually
- * modifing its buffers, so it is up to the caller to ensure that
+ * modifying its buffers, so it is up to the caller to ensure that
* the vector is actually the specified size.
*/
#[inline]
exact
}
+ #[inline]
fn idx(&self, index: uint) -> Option<&'self T> {
unsafe {
if index < self.indexable() {
}
impl<T> Iterator<T> for MoveIterator<T> {
+ #[inline]
fn next(&mut self) -> Option<T> {
// this is peculiar, but is required for safety with respect
// to dtors. It traverses the first half of the vec, and
self.v.pop_opt()
}
+
+ #[inline]
+ fn size_hint(&self) -> (uint, Option<uint>) {
+ let l = self.v.len();
+ (l, Some(l))
+ }
}
/// An iterator that moves out of a vector in reverse order.
}
impl<T> Iterator<T> for MoveRevIterator<T> {
+ #[inline]
fn next(&mut self) -> Option<T> {
self.v.pop_opt()
}
+
+ #[inline]
+ fn size_hint(&self) -> (uint, Option<uint>) {
+ let l = self.v.len();
+ (l, Some(l))
+ }
}
impl<A> FromIterator<A> for ~[A] {
use sys;
use vec::*;
use cmp::*;
+ use prelude::*;
fn square(n: uint) -> uint { n * n }
}
assert!(cnt == 3);
}
+
+ #[test]
+ fn test_shrink_to_fit() {
+ let mut xs = ~[0, 1, 2, 3];
+ for i in range(4, 100) {
+ xs.push(i)
+ }
+ assert_eq!(xs.capacity(), 128);
+ xs.shrink_to_fit();
+ assert_eq!(xs.capacity(), 100);
+ assert_eq!(xs, range(0, 100).to_owned_vec());
+ }
}
#[cfg(test)]
}
// a "Path" is essentially Rust's notion of a name;
-// for instance: core::cmp::Eq . It's represented
+// for instance: std::cmp::Eq . It's represented
// as a sequence of identifiers, along with a bunch
// of supporting information.
#[deriving(Clone, Eq, Encodable, Decodable, IterBytes)]
/* hold off on tests ... they appear in a later merge.
#[cfg(test)]
mod test {
- use core::option::{None, Option, Some};
- use core::uint;
+ use std::option::{None, Option, Some};
+ use std::uint;
use extra;
use codemap::*;
use super::*;
self.expr(span, ast::expr_fn_block(fn_decl, blk))
}
+ #[cfg(stage0)]
fn lambda0(&self, _span: span, blk: ast::Block) -> @ast::expr {
let ext_cx = *self;
let blk_e = self.expr(blk.span, ast::expr_block(blk.clone()));
quote_expr!(|| $blk_e )
}
+ #[cfg(not(stage0))]
+ fn lambda0(&self, _span: span, blk: ast::Block) -> @ast::expr {
+ let blk_e = self.expr(blk.span, ast::expr_block(blk.clone()));
+ quote_expr!(*self, || $blk_e )
+ }
+ #[cfg(stage0)]
fn lambda1(&self, _span: span, blk: ast::Block, ident: ast::ident) -> @ast::expr {
let ext_cx = *self;
let blk_e = self.expr(blk.span, ast::expr_block(blk.clone()));
quote_expr!(|$ident| $blk_e )
}
+ #[cfg(not(stage0))]
+ fn lambda1(&self, _span: span, blk: ast::Block, ident: ast::ident) -> @ast::expr {
+ let blk_e = self.expr(blk.span, ast::expr_block(blk.clone()));
+ quote_expr!(*self, |$ident| $blk_e )
+ }
fn lambda_expr(&self, span: span, ids: ~[ast::ident], expr: @ast::expr) -> @ast::expr {
self.lambda(span, ids, self.block_expr(expr))
use std::os;
+#[cfg(stage0)]
pub fn expand_option_env(ext_cx: @ExtCtxt, sp: span, tts: &[ast::token_tree])
-> base::MacResult {
let var = get_single_str_from_tts(ext_cx, sp, tts, "option_env!");
};
MRExpr(e)
}
+#[cfg(not(stage0))]
+pub fn expand_option_env(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree])
+ -> base::MacResult {
+ let var = get_single_str_from_tts(cx, sp, tts, "option_env!");
+
+ let e = match os::getenv(var) {
+ None => quote_expr!(cx, ::std::option::None::<&'static str>),
+ Some(s) => quote_expr!(cx, ::std::option::Some($s))
+ };
+ MRExpr(e)
+}
-pub fn expand_env(ext_cx: @ExtCtxt, sp: span, tts: &[ast::token_tree])
+pub fn expand_env(cx: @ExtCtxt, sp: span, tts: &[ast::token_tree])
-> base::MacResult {
- let exprs = get_exprs_from_tts(ext_cx, sp, tts);
+ let exprs = get_exprs_from_tts(cx, sp, tts);
if exprs.len() == 0 {
- ext_cx.span_fatal(sp, "env! takes 1 or 2 arguments");
+ cx.span_fatal(sp, "env! takes 1 or 2 arguments");
}
- let var = expr_to_str(ext_cx, exprs[0], "expected string literal");
+ let var = expr_to_str(cx, exprs[0], "expected string literal");
let msg = match exprs.len() {
1 => fmt!("Environment variable %s not defined", var).to_managed(),
- 2 => expr_to_str(ext_cx, exprs[1], "expected string literal"),
- _ => ext_cx.span_fatal(sp, "env! takes 1 or 2 arguments")
+ 2 => expr_to_str(cx, exprs[1], "expected string literal"),
+ _ => cx.span_fatal(sp, "env! takes 1 or 2 arguments")
};
let e = match os::getenv(var) {
- None => ext_cx.span_fatal(sp, msg),
- Some(s) => ext_cx.expr_str(sp, s.to_managed())
+ None => cx.span_fatal(sp, msg),
+ Some(s) => cx.expr_str(sp, s.to_managed())
};
MRExpr(e)
}
println(fmt!($($arg),+))
)
)
+
+ // NOTE: use this after a snapshot lands to abstract the details
+ // of the TLS interface.
+ macro_rules! local_data_key (
+ ($name:ident: $ty:ty) => (
+ static $name: ::std::local_data::Key<$ty> = &::std::local_data::Key;
+ );
+ (pub $name:ident: $ty:ty) => (
+ pub static $name: ::std::local_data::Key<$ty> = &::std::local_data::Key;
+ )
+ )
+
+ // externfn! declares a wrapper for an external function.
+ // It is intended to be used like:
+ //
+ // externfn!(#[nolink]
+ // #[abi = \"cdecl\"]
+ // fn memcmp(cx: *u8, ct: *u8, n: u32) -> u32)
+ //
+ // Due to limitations in the macro parser, this pattern must be
+ // implemented with 4 distinct patterns (with attrs / without
+ // attrs CROSS with args / without ARGS).
+ //
+ // Also, this macro grammar allows for any number of return types
+ // because I couldn't figure out the syntax to specify at most one.
+ macro_rules! externfn(
+ (fn $name:ident () $(-> $ret_ty:ty),*) => (
+ pub unsafe fn $name() $(-> $ret_ty),* {
+ // Note: to avoid obscure bug in macros, keep these
+ // attributes *internal* to the fn
+ #[fixed_stack_segment];
+ #[inline(never)];
+ #[allow(missing_doc)];
+
+ return $name();
+
+ extern {
+ fn $name() $(-> $ret_ty),*;
+ }
+ }
+ );
+ (fn $name:ident ($($arg_name:ident : $arg_ty:ty),*) $(-> $ret_ty:ty),*) => (
+ pub unsafe fn $name($($arg_name : $arg_ty),*) $(-> $ret_ty),* {
+ // Note: to avoid obscure bug in macros, keep these
+ // attributes *internal* to the fn
+ #[fixed_stack_segment];
+ #[inline(never)];
+ #[allow(missing_doc)];
+
+ return $name($($arg_name),*);
+
+ extern {
+ fn $name($($arg_name : $arg_ty),*) $(-> $ret_ty),*;
+ }
+ }
+ );
+ ($($attrs:attr)* fn $name:ident () $(-> $ret_ty:ty),*) => (
+ pub unsafe fn $name() $(-> $ret_ty),* {
+ // Note: to avoid obscure bug in macros, keep these
+ // attributes *internal* to the fn
+ #[fixed_stack_segment];
+ #[inline(never)];
+ #[allow(missing_doc)];
+
+ return $name();
+
+ $($attrs)*
+ extern {
+ fn $name() $(-> $ret_ty),*;
+ }
+ }
+ );
+ ($($attrs:attr)* fn $name:ident ($($arg_name:ident : $arg_ty:ty),*) $(-> $ret_ty:ty),*) => (
+ pub unsafe fn $name($($arg_name : $arg_ty),*) $(-> $ret_ty),* {
+ // Note: to avoid obscure bug in macros, keep these
+ // attributes *internal* to the fn
+ #[fixed_stack_segment];
+ #[inline(never)];
+ #[allow(missing_doc)];
+
+ return $name($($arg_name),*);
+
+ $($attrs)*
+ extern {
+ fn $name($($arg_name : $arg_ty),*) $(-> $ret_ty),*;
+ }
+ }
+ )
+ )
+
}";
}
fn format_arg(&self, sp: span, arg: Either<uint, @str>,
ident: ast::ident) -> @ast::expr {
- let mut ty = match arg {
+ let ty = match arg {
Left(i) => self.arg_types[i].unwrap(),
Right(s) => *self.name_types.get(&s)
};
- // Default types to '?' if nothing else is specified.
- if ty == Unknown {
- ty = Known(@"?");
- }
let argptr = self.ecx.expr_addr_of(sp, self.ecx.expr_ident(sp, ident));
- match ty {
+ let fmt_trait = match ty {
+ Unknown => "Default",
Known(tyname) => {
- let fmt_trait = match tyname.as_slice() {
+ match tyname.as_slice() {
"?" => "Poly",
"b" => "Bool",
"c" => "Char",
`%s`", tyname));
"Dummy"
}
- };
- let format_fn = self.ecx.path_global(sp, ~[
- self.ecx.ident_of("std"),
- self.ecx.ident_of("fmt"),
- self.ecx.ident_of(fmt_trait),
- self.ecx.ident_of("fmt"),
- ]);
- self.ecx.expr_call_global(sp, ~[
- self.ecx.ident_of("std"),
- self.ecx.ident_of("fmt"),
- self.ecx.ident_of("argument"),
- ], ~[self.ecx.expr_path(format_fn), argptr])
+ }
}
String => {
- self.ecx.expr_call_global(sp, ~[
+ return self.ecx.expr_call_global(sp, ~[
self.ecx.ident_of("std"),
self.ecx.ident_of("fmt"),
self.ecx.ident_of("argumentstr"),
], ~[argptr])
}
Unsigned => {
- self.ecx.expr_call_global(sp, ~[
+ return self.ecx.expr_call_global(sp, ~[
self.ecx.ident_of("std"),
self.ecx.ident_of("fmt"),
self.ecx.ident_of("argumentuint"),
], ~[argptr])
}
- Unknown => { fail!() }
- }
+ };
+
+ let format_fn = self.ecx.path_global(sp, ~[
+ self.ecx.ident_of("std"),
+ self.ecx.ident_of("fmt"),
+ self.ecx.ident_of(fmt_trait),
+ self.ecx.ident_of("fmt"),
+ ]);
+ self.ecx.expr_call_global(sp, ~[
+ self.ecx.ident_of("std"),
+ self.ecx.ident_of("fmt"),
+ self.ecx.ident_of("argument"),
+ ], ~[self.ecx.expr_path(format_fn), argptr])
}
}
// Alas ... we write these out instead. All redundant.
- impl ToTokens for ast::ident {
- fn to_tokens(&self, cx: @ExtCtxt) -> ~[token_tree] {
- cx.parse_tts(self.to_source())
- }
- }
-
- impl ToTokens for @ast::item {
- fn to_tokens(&self, cx: @ExtCtxt) -> ~[token_tree] {
- cx.parse_tts(self.to_source())
- }
- }
-
- impl<'self> ToTokens for &'self [@ast::item] {
- fn to_tokens(&self, cx: @ExtCtxt) -> ~[token_tree] {
- cx.parse_tts(self.to_source())
- }
- }
-
- impl ToTokens for ast::Ty {
- fn to_tokens(&self, cx: @ExtCtxt) -> ~[token_tree] {
- cx.parse_tts(self.to_source())
- }
- }
-
- impl<'self> ToTokens for &'self [ast::Ty] {
- fn to_tokens(&self, cx: @ExtCtxt) -> ~[token_tree] {
- cx.parse_tts(self.to_source())
- }
- }
-
- impl ToTokens for Generics {
- fn to_tokens(&self, cx: @ExtCtxt) -> ~[token_tree] {
- cx.parse_tts(self.to_source())
- }
- }
-
- impl ToTokens for @ast::expr {
- fn to_tokens(&self, cx: @ExtCtxt) -> ~[token_tree] {
- cx.parse_tts(self.to_source())
- }
- }
-
- impl ToTokens for ast::Block {
- fn to_tokens(&self, cx: @ExtCtxt) -> ~[token_tree] {
- cx.parse_tts(self.to_source())
- }
- }
-
- impl<'self> ToTokens for &'self str {
- fn to_tokens(&self, cx: @ExtCtxt) -> ~[token_tree] {
- cx.parse_tts(self.to_source())
- }
- }
-
- impl ToTokens for int {
- fn to_tokens(&self, cx: @ExtCtxt) -> ~[token_tree] {
- cx.parse_tts(self.to_source())
- }
- }
-
- impl ToTokens for i8 {
- fn to_tokens(&self, cx: @ExtCtxt) -> ~[token_tree] {
- cx.parse_tts(self.to_source())
- }
- }
-
- impl ToTokens for i16 {
- fn to_tokens(&self, cx: @ExtCtxt) -> ~[token_tree] {
- cx.parse_tts(self.to_source())
- }
- }
-
- impl ToTokens for i32 {
- fn to_tokens(&self, cx: @ExtCtxt) -> ~[token_tree] {
- cx.parse_tts(self.to_source())
- }
- }
-
- impl ToTokens for i64 {
- fn to_tokens(&self, cx: @ExtCtxt) -> ~[token_tree] {
- cx.parse_tts(self.to_source())
- }
- }
-
- impl ToTokens for uint {
- fn to_tokens(&self, cx: @ExtCtxt) -> ~[token_tree] {
- cx.parse_tts(self.to_source())
- }
- }
-
- impl ToTokens for u8 {
- fn to_tokens(&self, cx: @ExtCtxt) -> ~[token_tree] {
- cx.parse_tts(self.to_source())
- }
- }
-
- impl ToTokens for u16 {
- fn to_tokens(&self, cx: @ExtCtxt) -> ~[token_tree] {
- cx.parse_tts(self.to_source())
- }
- }
-
- impl ToTokens for u32 {
- fn to_tokens(&self, cx: @ExtCtxt) -> ~[token_tree] {
- cx.parse_tts(self.to_source())
- }
- }
-
- impl ToTokens for u64 {
- fn to_tokens(&self, cx: @ExtCtxt) -> ~[token_tree] {
- cx.parse_tts(self.to_source())
- }
- }
+ macro_rules! impl_to_tokens(
+ ($t:ty) => (
+ impl ToTokens for $t {
+ fn to_tokens(&self, cx: @ExtCtxt) -> ~[token_tree] {
+ cx.parse_tts(self.to_source())
+ }
+ }
+ )
+ )
+
+ macro_rules! impl_to_tokens_self(
+ ($t:ty) => (
+ impl<'self> ToTokens for $t {
+ fn to_tokens(&self, cx: @ExtCtxt) -> ~[token_tree] {
+ cx.parse_tts(self.to_source())
+ }
+ }
+ )
+ )
+
+ impl_to_tokens!(ast::ident)
+ impl_to_tokens!(@ast::item)
+ impl_to_tokens_self!(&'self [@ast::item])
+ impl_to_tokens!(ast::Ty)
+ impl_to_tokens_self!(&'self [ast::Ty])
+ impl_to_tokens!(Generics)
+ impl_to_tokens!(@ast::expr)
+ impl_to_tokens!(ast::Block)
+ impl_to_tokens_self!(&'self str)
+ impl_to_tokens!(int)
+ impl_to_tokens!(i8)
+ impl_to_tokens!(i16)
+ impl_to_tokens!(i32)
+ impl_to_tokens!(i64)
+ impl_to_tokens!(uint)
+ impl_to_tokens!(u8)
+ impl_to_tokens!(u16)
+ impl_to_tokens!(u32)
+ impl_to_tokens!(u64)
pub trait ExtParseUtils {
fn parse_item(&self, s: @str) -> @ast::item;
pub fn expand_quote_tokens(cx: @ExtCtxt,
sp: span,
tts: &[ast::token_tree]) -> base::MacResult {
- base::MRExpr(expand_tts(cx, sp, tts))
+ let (cx_expr, expr) = expand_tts(cx, sp, tts);
+ base::MRExpr(expand_wrapper(cx, sp, cx_expr, expr))
}
pub fn expand_quote_expr(cx: @ExtCtxt,
fn expand_tts(cx: @ExtCtxt,
sp: span,
- tts: &[ast::token_tree]) -> @ast::expr {
+ tts: &[ast::token_tree]) -> (@ast::expr, @ast::expr) {
// NB: It appears that the main parser loses its mind if we consider
// $foo as a tt_nonterminal during the main parse, so we have to re-parse
tts.to_owned()
);
*p.quote_depth += 1u;
- let tts = p.parse_all_token_trees();
- p.abort_if_errors();
- // We want to emit a block expression that does a sequence of 'use's to
- // import the runtime module, followed by a tt-building expression.
+ let cx_expr = p.parse_expr();
+ if !p.eat(&token::COMMA) {
+ p.fatal("Expected token `,`");
+ }
- let uses = ~[ cx.view_use_glob(sp, ast::public,
- ids_ext(~[~"syntax",
- ~"ext",
- ~"quote",
- ~"rt"])) ];
+ let tts = p.parse_all_token_trees();
+ p.abort_if_errors();
// We also bind a single value, sp, to ext_cx.call_site()
//
// the site the string literal occurred, which was in a source file
// _other_ than the one the user has control over. For example, an
// error in a quote from the protocol compiler, invoked in user code
- // using macro_rules! for example, will be attributed to the macro_rules.rs file in
- // libsyntax, which the user might not even have source to (unless they
- // happen to have a compiler on hand). Over all, the phase distinction
+ // using macro_rules! for example, will be attributed to the macro_rules.rs
+ // file in libsyntax, which the user might not even have source to (unless
+ // they happen to have a compiler on hand). Over all, the phase distinction
// just makes quotes "hard to attribute". Possibly this could be fixed
// by recreating some of the original qq machinery in the tt regime
// (pushing fake FileMaps onto the parser to account for original sites
id_ext("tt"),
cx.expr_vec_uniq(sp, ~[]));
- cx.expr_block(
- cx.block_all(sp, uses,
- ~[stmt_let_sp,
- stmt_let_tt] + mk_tts(cx, sp, tts),
- Some(cx.expr_ident(sp, id_ext("tt")))))
+ let block = cx.expr_block(
+ cx.block_all(sp,
+ ~[],
+ ~[stmt_let_sp, stmt_let_tt] + mk_tts(cx, sp, tts),
+ Some(cx.expr_ident(sp, id_ext("tt")))));
+
+ (cx_expr, block)
+}
+
+fn expand_wrapper(cx: @ExtCtxt,
+ sp: span,
+ cx_expr: @ast::expr,
+ expr: @ast::expr) -> @ast::expr {
+ let uses = ~[ cx.view_use_glob(sp, ast::public,
+ ids_ext(~[~"syntax",
+ ~"ext",
+ ~"quote",
+ ~"rt"])) ];
+
+ let stmt_let_ext_cx = cx.stmt_let(sp, false, id_ext("ext_cx"), cx_expr);
+
+ cx.expr_block(cx.block_all(sp, uses, ~[stmt_let_ext_cx], Some(expr)))
}
fn expand_parse_call(cx: @ExtCtxt,
parse_method: &str,
arg_exprs: ~[@ast::expr],
tts: &[ast::token_tree]) -> @ast::expr {
- let tts_expr = expand_tts(cx, sp, tts);
+ let (cx_expr, tts_expr) = expand_tts(cx, sp, tts);
let cfg_call = || cx.expr_method_call(
sp, cx.expr_ident(sp, id_ext("ext_cx")),
id_ext("parse_sess"), ~[]);
let new_parser_call =
- cx.expr_call_global(sp,
- ids_ext(~[~"syntax",
- ~"ext",
- ~"quote",
- ~"rt",
- ~"new_parser_from_tts"]),
- ~[parse_sess_call(),
- cfg_call(),
- tts_expr]);
-
- cx.expr_method_call(sp, new_parser_call,
- id_ext(parse_method),
- arg_exprs)
+ cx.expr_call(sp,
+ cx.expr_ident(sp, id_ext("new_parser_from_tts")),
+ ~[parse_sess_call(), cfg_call(), tts_expr]);
+
+ let expr = cx.expr_method_call(sp, new_parser_call, id_ext(parse_method),
+ arg_exprs);
+
+ expand_wrapper(cx, sp, cx_expr, expr)
}
use ast;
use codemap::{spanned, mk_sp};
-use codemap::BytePos;
use parse::common::*; //resolve bug?
use parse::token;
use parse::parser::Parser;
c => {
// So the error span points to the unrecognized character
rdr.peek_span = codemap::mk_sp(rdr.last_pos, rdr.pos);
- rdr.fatal(fmt!("unknown start of token: %d", c as int));
+ let mut cs = ~"";
+ char::escape_default(c, |c| cs.push_char(c));
+ rdr.fatal(fmt!("unknown start of token: %s", cs));
}
}
}
pub enum ObsoleteSyntax {
ObsoleteLet,
ObsoleteFieldTerminator,
- ObsoleteStructCtor,
ObsoleteWith,
ObsoleteClassTraits,
ObsoletePrivSection,
fn token_is_obsolete_ident(&self, ident: &str, token: &Token) -> bool;
fn is_obsolete_ident(&self, ident: &str) -> bool;
fn eat_obsolete_ident(&self, ident: &str) -> bool;
- fn try_parse_obsolete_struct_ctor(&self) -> bool;
fn try_parse_obsolete_with(&self) -> bool;
fn try_parse_obsolete_priv_section(&self, attrs: &[Attribute]) -> bool;
}
"field declaration terminated with semicolon",
"fields are now separated by commas"
),
- ObsoleteStructCtor => (
- "struct constructor",
- "structs are now constructed with `MyStruct { foo: val }` \
- syntax. Structs with private fields cannot be created \
- outside of their defining module"
- ),
ObsoleteWith => (
"with",
"record update is done with `..`, e.g. \
}
}
- fn try_parse_obsolete_struct_ctor(&self) -> bool {
- if self.eat_obsolete_ident("new") {
- self.obsolete(*self.last_span, ObsoleteStructCtor);
- self.parse_fn_decl();
- self.parse_block();
- true
- } else {
- false
- }
- }
-
fn try_parse_obsolete_with(&self) -> bool {
if *self.token == token::COMMA
&& self.look_ahead(1,
_ => {
p.fatal(
fmt!(
- "expected `;` or `}` but found `%s`",
+ "expected `;` or `{` but found `%s`",
self.this_token_to_str()
)
);
return ~[self.parse_single_struct_field(public, attrs)];
}
- if self.try_parse_obsolete_struct_ctor() {
- return ~[];
- }
-
return ~[self.parse_single_struct_field(inherited, attrs)];
}
}
}
- pub fn parse_str(&self) -> @str {
+ pub fn parse_optional_str(&self) -> Option<@str> {
match *self.token {
token::LIT_STR(s) => {
self.bump();
- ident_to_str(&s)
+ Some(ident_to_str(&s))
}
+ _ => None
+ }
+ }
+
+ pub fn parse_str(&self) -> @str {
+ match self.parse_optional_str() {
+ Some(s) => { s }
_ => self.fatal("expected string literal")
}
}
"be", // 64
"pure", // 65
+ "yield", // 66
];
@ident_interner {
Once,
Priv,
Pub,
- Pure,
Ref,
Return,
Static,
// Reserved keywords
Be,
+ Pure,
+ Yield,
}
impl Keyword {
Once => ident { name: 50, ctxt: 0 },
Priv => ident { name: 51, ctxt: 0 },
Pub => ident { name: 52, ctxt: 0 },
- Pure => ident { name: 65, ctxt: 0 },
Ref => ident { name: 53, ctxt: 0 },
Return => ident { name: 54, ctxt: 0 },
Static => ident { name: 27, ctxt: 0 },
Use => ident { name: 61, ctxt: 0 },
While => ident { name: 62, ctxt: 0 },
Be => ident { name: 64, ctxt: 0 },
+ Pure => ident { name: 65, ctxt: 0 },
+ Yield => ident { name: 66, ctxt: 0 },
}
}
}
pub fn is_any_keyword(tok: &Token) -> bool {
match *tok {
token::IDENT(sid, false) => match sid.name {
- 8 | 27 | 32 .. 65 => true,
+ 8 | 27 | 32 .. 66 => true,
_ => false,
},
_ => false
pub fn is_reserved_keyword(tok: &Token) -> bool {
match *tok {
token::IDENT(sid, false) => match sid.name {
- 64 .. 65 => true,
+ 64 .. 66 => true,
_ => false,
},
_ => false,
use print::pprust;
use std::io;
-use std::u64;
// The @ps is stored here to prevent recursive type.
pub enum ann_node<'self> {
ast::lit_int(i, t) => {
if i < 0_i64 {
word(s.s,
- ~"-" + u64::to_str_radix(-i as u64, 10u)
+ ~"-" + (-i as u64).to_str_radix(10u)
+ ast_util::int_ty_to_str(t));
} else {
word(s.s,
- u64::to_str_radix(i as u64, 10u)
+ (i as u64).to_str_radix(10u)
+ ast_util::int_ty_to_str(t));
}
}
ast::lit_uint(u, t) => {
word(s.s,
- u64::to_str_radix(u, 10u)
+ u.to_str_radix(10u)
+ ast_util::uint_ty_to_str(t));
}
ast::lit_int_unsuffixed(i) => {
if i < 0_i64 {
- word(s.s, ~"-" + u64::to_str_radix(-i as u64, 10u));
+ word(s.s, ~"-" + (-i as u64).to_str_radix(10u));
} else {
- word(s.s, u64::to_str_radix(i as u64, 10u));
+ word(s.s, (i as u64).to_str_radix(10u));
}
}
ast::lit_float(f, t) => {
-Subproject commit f67442eee27d3d075a65cf7f9a70f7ec6649ffd1
+Subproject commit 0964c68ddf2c67ce455e7443a06f4bb3db9e92bb
#include "memory_region.h"
#include "boxed_region.h"
#include "rust_globals.h"
-#include "rust_env.h"
#include "rust_util.h"
// #define DUMP_BOXED_REGION
force_lazy_lock="1"
;;
+ *-*-linux-android*)
+ CFLAGS="$CFLAGS"
+ CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
+ abi="elf"
+ $as_echo "#define JEMALLOC_HAS_ALLOCA_H 1" >>confdefs.h
+
+ $as_echo "#define JEMALLOC_PURGE_MADVISE_DONTNEED " >>confdefs.h
+
+ $as_echo "#define JEMALLOC_THREADED_INIT " >>confdefs.h
+
+ default_munmap="0"
+ ;;
*-*-linux*)
CFLAGS="$CFLAGS"
CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
CTARGET='-o $@'
LDTARGET='-o $@'
EXTRA_LDFLAGS=
-MKLIB='ar crus $@'
+MKLIB='$(AR) crus $@'
CC_MM=1
dnl Platform-specific settings. abi and RPATH can probably be determined
AC_DEFINE([JEMALLOC_PURGE_MADVISE_FREE], [ ])
force_lazy_lock="1"
;;
+ *-*-linux-android*)
+ CFLAGS="$CFLAGS"
+ CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
+ abi="elf"
+ AC_DEFINE([JEMALLOC_HAS_ALLOCA_H])
+ AC_DEFINE([JEMALLOC_PURGE_MADVISE_DONTNEED], [ ])
+ AC_DEFINE([JEMALLOC_THREADED_INIT], [ ])
+ default_munmap="0"
+ ;;
*-*-linux*)
CFLAGS="$CFLAGS"
CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
return RUNNING_ON_VALGRIND;
}
-extern int get_num_cpus();
+#if defined(__WIN32__)
+int
+get_num_cpus() {
+ SYSTEM_INFO sysinfo;
+ GetSystemInfo(&sysinfo);
+
+ return (int) sysinfo.dwNumberOfProcessors;
+}
+#elif defined(__BSD__)
+int
+get_num_cpus() {
+ /* swiped from http://stackoverflow.com/questions/150355/
+ programmatically-find-the-number-of-cores-on-a-machine */
+
+ unsigned int numCPU;
+ int mib[4];
+ size_t len = sizeof(numCPU);
+
+ /* set the mib for hw.ncpu */
+ mib[0] = CTL_HW;
+ mib[1] = HW_AVAILCPU; // alternatively, try HW_NCPU;
+
+ /* get the number of CPUs from the system */
+ sysctl(mib, 2, &numCPU, &len, NULL, 0);
+
+ if( numCPU < 1 ) {
+ mib[1] = HW_NCPU;
+ sysctl( mib, 2, &numCPU, &len, NULL, 0 );
+
+ if( numCPU < 1 ) {
+ numCPU = 1;
+ }
+ }
+ return numCPU;
+}
+#elif defined(__GNUC__)
+int
+get_num_cpus() {
+ return sysconf(_SC_NPROCESSORS_ONLN);
+}
+#endif
extern "C" CDECL uintptr_t
rust_get_num_cpus() {
return 0;
}
+static lock_and_signal env_lock;
+
+extern "C" CDECL void
+rust_take_env_lock() {
+ env_lock.lock();
+}
+
+extern "C" CDECL void
+rust_drop_env_lock() {
+ env_lock.unlock();
+}
+
+extern "C" CDECL unsigned int
+rust_valgrind_stack_register(void *start, void *end) {
+ return VALGRIND_STACK_REGISTER(start, end);
+}
+
+extern "C" CDECL void
+rust_valgrind_stack_deregister(unsigned int id) {
+ VALGRIND_STACK_DEREGISTER(id);
+}
+
//
// Local Variables:
// mode: C++
+++ /dev/null
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// The runtime wants to pull a number of variables out of the
-// environment but calling getenv is not threadsafe, so every value
-// that might come from the environment is loaded here, once, during
-// init.
-
-#include "sync/lock_and_signal.h"
-#include "rust_env.h"
-
-// The environment variables that the runtime knows about
-#define RUST_THREADS "RUST_THREADS"
-#define RUST_MIN_STACK "RUST_MIN_STACK"
-#define RUST_MAX_STACK "RUST_MAX_STACK"
-#define RUST_LOG "RUST_LOG"
-#define DETAILED_LEAKS "DETAILED_LEAKS"
-#define RUST_SEED "RUST_SEED"
-#define RUST_POISON_ON_FREE "RUST_POISON_ON_FREE"
-#define RUST_DEBUG_MEM "RUST_DEBUG_MEM"
-#define RUST_DEBUG_BORROW "RUST_DEBUG_BORROW"
-
-#define DEFAULT_RUST_MIN_STACK_32 0x300
-#define DEFAULT_RUST_MIN_STACK_64 0x400000
-
-static lock_and_signal env_lock;
-
-extern "C" CDECL void
-rust_take_env_lock() {
- env_lock.lock();
-}
-
-extern "C" CDECL void
-rust_drop_env_lock() {
- env_lock.unlock();
-}
-
-#if defined(__WIN32__)
-int
-get_num_cpus() {
- SYSTEM_INFO sysinfo;
- GetSystemInfo(&sysinfo);
-
- return (int) sysinfo.dwNumberOfProcessors;
-}
-#elif defined(__BSD__)
-int
-get_num_cpus() {
- /* swiped from http://stackoverflow.com/questions/150355/
- programmatically-find-the-number-of-cores-on-a-machine */
-
- unsigned int numCPU;
- int mib[4];
- size_t len = sizeof(numCPU);
-
- /* set the mib for hw.ncpu */
- mib[0] = CTL_HW;
- mib[1] = HW_AVAILCPU; // alternatively, try HW_NCPU;
-
- /* get the number of CPUs from the system */
- sysctl(mib, 2, &numCPU, &len, NULL, 0);
-
- if( numCPU < 1 ) {
- mib[1] = HW_NCPU;
- sysctl( mib, 2, &numCPU, &len, NULL, 0 );
-
- if( numCPU < 1 ) {
- numCPU = 1;
- }
- }
- return numCPU;
-}
-#elif defined(__GNUC__)
-int
-get_num_cpus() {
- return sysconf(_SC_NPROCESSORS_ONLN);
-}
-#endif
-
-static int
-get_num_threads()
-{
- char *env = getenv(RUST_THREADS);
- if(env) {
- int num = atoi(env);
- if(num > 0)
- return num;
- }
- return get_num_cpus();
-}
-
-static size_t
-get_min_stk_size() {
- char *minsz = getenv(RUST_MIN_STACK);
- if(minsz) {
- return strtol(minsz, NULL, 0);
- }
- else if (sizeof(size_t) > 4) {
- return DEFAULT_RUST_MIN_STACK_64;
- } else {
- return DEFAULT_RUST_MIN_STACK_32;
- }
-}
-
-static size_t
-get_max_stk_size() {
- char *maxsz = getenv(RUST_MAX_STACK);
- if (maxsz) {
- return strtol(maxsz, NULL, 0);
- }
- else {
- return 1024*1024*1024;
- }
-}
-
-static char*
-copyenv(const char* name) {
- char *envvar = getenv(name);
- if (!envvar) {
- return NULL;
- } else {
- size_t slen = strlen(envvar);
- size_t buflen = slen + 1;
- char *var = (char*)malloc(buflen);
- memset(var, 0, buflen);
- strncpy(var, envvar, slen);
- return var;
- }
-}
-
-rust_env*
-load_env(int argc, char **argv) {
- scoped_lock with(env_lock);
-
- rust_env *env = (rust_env*)malloc(sizeof(rust_env));
-
- env->num_sched_threads = (size_t)get_num_threads();
- env->min_stack_size = get_min_stk_size();
- env->max_stack_size = get_max_stk_size();
- env->logspec = copyenv(RUST_LOG);
- env->detailed_leaks = getenv(DETAILED_LEAKS) != NULL;
- env->rust_seed = copyenv(RUST_SEED);
- env->poison_on_free = getenv(RUST_POISON_ON_FREE) != NULL;
- env->argc = argc;
- env->argv = argv;
- env->debug_mem = getenv(RUST_DEBUG_MEM) != NULL;
- env->debug_borrow = getenv(RUST_DEBUG_BORROW) != NULL;
- return env;
-}
-
-void
-free_env(rust_env *env) {
- free(env->logspec);
- free(env->rust_seed);
- free(env);
-}
+++ /dev/null
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-
-#ifndef RUST_ENV_H
-#define RUST_ENV_H
-
-#include "rust_globals.h"
-
-// Avoiding 'bool' type here since I'm not sure it has a standard size
-typedef uint8_t rust_bool;
-
-struct rust_env {
- size_t num_sched_threads;
- size_t min_stack_size;
- size_t max_stack_size;
- char* logspec;
- rust_bool detailed_leaks;
- char* rust_seed;
- rust_bool poison_on_free;
- int argc;
- char **argv;
- rust_bool debug_mem;
- rust_bool debug_borrow;
-};
-
-rust_env* load_env(int argc, char **argv);
-void free_env(rust_env *rust_env);
-
-#endif
#define CDECL __cdecl
#endif
#ifndef FASTCALL
-#define FASTCALL __fastcall
#endif
#else
#define CDECL __attribute__((cdecl))
-#define FASTCALL __attribute__((fastcall))
#endif
#else
#define CDECL
-#define FASTCALL
#endif
#define CHECKED(call) \
} \
}
-#define MUST_CHECK __attribute__((warn_unused_result))
-
-#define PTR "0x%" PRIxPTR
-
-// This accounts for logging buffers.
-static size_t const BUF_BYTES = 2048;
-
-#define INIT_TASK_ID 1
-
-// The error status to use when the process fails
-#define PROC_FAIL_CODE 101
-
-// A cond(ition) is something we can block on. This can be a channel
-// (writing), a port (reading) or a task (waiting).
-struct rust_cond { };
-
-extern void* global_crate_map;
-
#endif /* RUST_GLOBALS_H */
*/
-#include "rust_log.h"
#include "rust_crate_map.h"
#include "util/array_list.h"
#include "rust_util.h"
size_t level;
};
+
+const uint32_t log_err = 1;
+const uint32_t log_warn = 2;
+const uint32_t log_info = 3;
+const uint32_t log_debug = 4;
+
const size_t max_log_directives = 255;
const size_t max_log_level = 255;
const size_t default_log_level = log_err;
// This is a rather ugly parser for strings in the form
// "crate1,crate2.mod3,crate3.x=1". Log levels are 0-255,
-// with the most likely ones being 0-3 (defined in core::).
+// with the most likely ones being 0-3 (defined in std::).
size_t parse_logging_spec(char* spec, log_directive* dirs) {
size_t dir = 0;
while (dir < max_log_directives && *spec) {
}
}
-void update_module_map(const mod_entry* map, log_directive* dirs,
- size_t n_dirs, size_t *n_matches) {
- update_entry_args args = { dirs, n_dirs, n_matches };
- iter_module_map(map, update_entry, &args);
-}
-
void update_crate_map(const cratemap* map, log_directive* dirs,
size_t n_dirs, size_t *n_matches) {
update_entry_args args = { dirs, n_dirs, n_matches };
iter_crate_map(map, print_mod_name, NULL);
}
-// These are pseudo-modules used to control logging in the runtime.
-
-uint32_t log_rt_mem;
-uint32_t log_rt_box;
-uint32_t log_rt_comm;
-uint32_t log_rt_task;
-uint32_t log_rt_dom;
-uint32_t log_rt_trace;
-uint32_t log_rt_cache;
-uint32_t log_rt_upcall;
-uint32_t log_rt_timer;
-uint32_t log_rt_gc;
-uint32_t log_rt_stdlib;
-uint32_t log_rt_kern;
-uint32_t log_rt_backtrace;
-uint32_t log_rt_callback;
-
-static const mod_entry _rt_module_map[] =
- {{"::rt::mem", &log_rt_mem},
- {"::rt::box", &log_rt_box},
- {"::rt::comm", &log_rt_comm},
- {"::rt::task", &log_rt_task},
- {"::rt::dom", &log_rt_dom},
- {"::rt::trace", &log_rt_trace},
- {"::rt::cache", &log_rt_cache},
- {"::rt::upcall", &log_rt_upcall},
- {"::rt::timer", &log_rt_timer},
- {"::rt::gc", &log_rt_gc},
- {"::rt::stdlib", &log_rt_stdlib},
- {"::rt::kern", &log_rt_kern},
- {"::rt::backtrace", &log_rt_backtrace},
- {"::rt::callback", &log_rt_callback},
- {NULL, NULL}};
-
void update_log_settings(void* crate_map, char* settings) {
char* buffer = NULL;
log_directive dirs[256];
}
size_t n_matches = 0;
- update_module_map(_rt_module_map, &dirs[0], n_dirs, &n_matches);
update_crate_map((const cratemap*)crate_map, &dirs[0],
n_dirs, &n_matches);
+++ /dev/null
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#ifndef RUST_LOG_H
-#define RUST_LOG_H
-
-#include "rust_globals.h"
-
-const uint32_t log_err = 1;
-const uint32_t log_warn = 2;
-const uint32_t log_info = 3;
-const uint32_t log_debug = 4;
-
-void update_log_settings(void* crate_map, char* settings);
-
-extern uint32_t log_rt_mem;
-extern uint32_t log_rt_box;
-extern uint32_t log_rt_comm;
-extern uint32_t log_rt_task;
-extern uint32_t log_rt_dom;
-extern uint32_t log_rt_trace;
-extern uint32_t log_rt_cache;
-extern uint32_t log_rt_upcall;
-extern uint32_t log_rt_timer;
-extern uint32_t log_rt_gc;
-extern uint32_t log_rt_stdlib;
-extern uint32_t log_rt_kern;
-extern uint32_t log_rt_backtrace;
-extern uint32_t log_rt_callback;
-
-#endif /* RUST_LOG_H */
+++ /dev/null
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-
-#ifndef RUST_REFCOUNT_H
-#define RUST_REFCOUNT_H
-
-#include "sync/sync.h"
-
-// Refcounting defines
-typedef unsigned long ref_cnt_t;
-
-#define RUST_ATOMIC_REFCOUNT() \
-private: \
- intptr_t ref_count; \
-public: \
- void ref() { \
- intptr_t old = sync::increment(ref_count); \
- assert(old > 0); \
- } \
- void deref() { if(0 == sync::decrement(ref_count)) { delete_this(); } } \
- intptr_t get_ref_count() { return sync::read(ref_count); }
-
-#endif
+++ /dev/null
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#ifndef RUST_SIGNAL_H
-#define RUST_SIGNAL_H
-
-// Just an abstract class that represents something that can be signalled
-class rust_signal {
-public:
- virtual void signal() = 0;
- virtual ~rust_signal() {}
- rust_signal() {}
-
-private:
- // private and undefined to disable copying
- rust_signal(const rust_signal& rhs);
- rust_signal& operator=(const rust_signal& rhs);
-};
-
-#endif /* RUST_SIGNAL_H */
+++ /dev/null
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-
-#include "rust_stack.h"
-#include "vg/valgrind.h"
-#include "vg/memcheck.h"
-
-#include <cstdio>
-
-#ifdef _LP64
-const uintptr_t canary_value = 0xABCDABCDABCDABCD;
-#else
-const uintptr_t canary_value = 0xABCDABCD;
-#endif
-
-void
-register_valgrind_stack(stk_seg *stk) {
- stk->valgrind_id =
- VALGRIND_STACK_REGISTER(&stk->data[0],
- stk->end);
-}
-
-void
-reuse_valgrind_stack(stk_seg *stk, uint8_t *sp) {
- // Establish that the stack is accessible. This must be done when reusing
- // old stack segments, since the act of popping the stack previously
- // caused valgrind to consider the whole thing inaccessible.
- assert(sp >= stk->data && sp <= (uint8_t*) stk->end
- && "Stack pointer must be inside stack segment");
- size_t sz = stk->end - (uintptr_t)sp;
- (void) VALGRIND_MAKE_MEM_UNDEFINED(sp, sz);
- (void) sz;
-}
-
-void
-deregister_valgrind_stack(stk_seg *stk) {
- VALGRIND_STACK_DEREGISTER(stk->valgrind_id);
-}
-
-void
-add_stack_canary(stk_seg *stk) {
- stk->canary = canary_value;
-}
-
-void
-check_stack_canary(stk_seg *stk) {
- assert(stk->canary == canary_value && "Somebody killed the canary");
-}
-
-// XXX: Duplication here between the local and exchange heap constructors
-
-stk_seg *
-create_stack(memory_region *region, size_t sz) {
- size_t total_sz = sizeof(stk_seg) + sz;
- stk_seg *stk = (stk_seg *)region->malloc(total_sz, "stack");
- memset(stk, 0, sizeof(stk_seg));
- stk->end = (uintptr_t) &stk->data[sz];
- stk->is_big = 0;
- add_stack_canary(stk);
- register_valgrind_stack(stk);
- return stk;
-}
-
-void
-destroy_stack(memory_region *region, stk_seg *stk) {
- deregister_valgrind_stack(stk);
- region->free(stk);
-}
-
-stk_seg *
-create_exchange_stack(rust_exchange_alloc *exchange, size_t sz) {
- size_t total_sz = sizeof(stk_seg) + sz;
- stk_seg *stk = (stk_seg *)exchange->malloc(total_sz);
- memset(stk, 0, sizeof(stk_seg));
- stk->end = (uintptr_t) &stk->data[sz];
- stk->is_big = 0;
- add_stack_canary(stk);
- register_valgrind_stack(stk);
- return stk;
-}
-
-void
-destroy_exchange_stack(rust_exchange_alloc *exchange, stk_seg *stk) {
- deregister_valgrind_stack(stk);
- exchange->free(stk);
-}
-
-
-extern "C" CDECL unsigned int
-rust_valgrind_stack_register(void *start, void *end) {
- return VALGRIND_STACK_REGISTER(start, end);
-}
-
-extern "C" CDECL void
-rust_valgrind_stack_deregister(unsigned int id) {
- VALGRIND_STACK_DEREGISTER(id);
-}
+++ /dev/null
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#ifndef RUST_STACK_H
-#define RUST_STACK_H
-
-#include "rust_globals.h"
-#include "rust_exchange_alloc.h"
-#include "memory_region.h"
-
-struct rust_task;
-
-struct stk_seg {
- stk_seg *prev;
- stk_seg *next;
- uintptr_t end;
- unsigned int valgrind_id;
- uint8_t is_big;
-
- rust_task *task;
- uintptr_t canary;
-
- uint8_t data[];
-};
-
-stk_seg *
-create_stack(memory_region *region, size_t sz);
-
-void
-destroy_stack(memory_region *region, stk_seg *stk);
-
-stk_seg *
-create_exchange_stack(rust_exchange_alloc *exchange, size_t sz);
-
-void
-destroy_exchange_stack(rust_exchange_alloc *exchange, stk_seg *stk);
-
-// Must be called before each time a stack is reused to tell valgrind
-// that the stack is accessible.
-void
-reuse_valgrind_stack(stk_seg *stk, uint8_t *sp);
-
-// Run a sanity check
-void
-check_stack_canary(stk_seg *stk);
-
-#endif /* RUST_STACK_H */
#define RUST_TYPE_H
#include "rust_globals.h"
-#include "rust_refcount.h"
struct rust_opaque_box;
typedef void CDECL (glue_fn)(void *,
void *);
+typedef unsigned long ref_cnt_t;
+
// Corresponds to the boxed data in the @ region. The body follows the
// header; you can obtain a ptr via box_body() below.
struct rust_opaque_box {
size_t borrow_offset;
};
-extern "C" type_desc *rust_clone_type_desc(type_desc*);
-
#endif
//
*/
#include "rust_globals.h"
-#include "rust_upcall.h"
#include "rust_util.h"
//Unwinding ABI declarations.
+++ /dev/null
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#ifndef RUST_UPCALL_H
-#define RUST_UPCALL_H
-
-#endif
#include <limits.h>
#include "rust_exchange_alloc.h"
#include "rust_type.h"
-#include "rust_env.h"
extern struct type_desc str_body_tydesc;
#include <malloc.h>
#endif
+#ifndef __WIN32__
+// for signal
+#include <signal.h>
+#endif
+
#include "uv.h"
#include "rust_globals.h"
-// extern fn pointers
-typedef void (*extern_async_op_cb)(uv_loop_t* loop, void* data,
- uv_async_t* op_handle);
-typedef void (*extern_simple_cb)(uint8_t* id_buf, void* loop_data);
-typedef void (*extern_close_cb)(uint8_t* id_buf, void* handle,
- void* data);
-
-// data types
-#define RUST_UV_HANDLE_LEN 16
-
-struct handle_data {
- uint8_t id_buf[RUST_UV_HANDLE_LEN];
- extern_simple_cb cb;
- extern_close_cb close_cb;
-};
-
-static void
-foreign_timer_cb(uv_timer_t* handle, int status) {
- handle_data* handle_d = (handle_data*)handle->data;
- void* loop_data = handle->loop->data;
- handle_d->cb(handle_d->id_buf, loop_data);
-}
-
-static void
-foreign_close_cb(uv_handle_t* handle) {
- handle_data* data = (handle_data*)handle->data;
- data->close_cb(data->id_buf, handle, handle->loop->data);
-}
extern "C" void*
rust_uv_loop_new() {
+// XXX libuv doesn't always ignore SIGPIPE even though we don't need it.
+#ifndef __WIN32__
+ signal(SIGPIPE, SIG_IGN);
+#endif
return (void*)uv_loop_new();
}
uv_walk(loop, cb, arg);
}
-extern "C" void
-rust_uv_hilvl_close(uv_handle_t* handle, extern_close_cb cb) {
- handle_data* data = (handle_data*)handle->data;
- data->close_cb = cb;
- uv_close(handle, foreign_close_cb);
-}
-
extern "C" void
rust_uv_async_send(uv_async_t* handle) {
uv_async_send(handle);
return uv_async_init(loop_handle, async_handle, cb);
}
-extern "C" void
-rust_uv_hilvl_timer_start(uv_timer_t* the_timer, uint32_t timeout,
- uint32_t repeat) {
- uv_timer_start(the_timer, foreign_timer_cb, timeout, repeat);
-}
-
extern "C" int
rust_uv_timer_init(uv_loop_t* loop, uv_timer_t* timer) {
return uv_timer_init(loop, timer);
return uv_accept(server, client);
}
-extern "C" size_t
-rust_uv_helper_uv_tcp_t_size() {
- return sizeof(uv_tcp_t);
-}
-extern "C" size_t
-rust_uv_helper_uv_connect_t_size() {
- return sizeof(uv_connect_t);
-}
-extern "C" size_t
-rust_uv_helper_uv_buf_t_size() {
- return sizeof(uv_buf_t);
-}
-extern "C" size_t
-rust_uv_helper_uv_write_t_size() {
- return sizeof(uv_write_t);
-}
-extern "C" size_t
-rust_uv_helper_uv_err_t_size() {
- return sizeof(uv_err_t);
-}
-extern "C" size_t
-rust_uv_helper_sockaddr_in_size() {
- return sizeof(sockaddr_in);
-}
-extern "C" size_t
-rust_uv_helper_sockaddr_in6_size() {
- return sizeof(sockaddr_in6);
-}
-extern "C" size_t
-rust_uv_helper_uv_async_t_size() {
- return sizeof(uv_async_t);
-}
-extern "C" size_t
-rust_uv_helper_uv_timer_t_size() {
- return sizeof(uv_timer_t);
-}
-extern "C" size_t
-rust_uv_helper_addr_in_size() {
- return sizeof(sockaddr_in6);
-}
-extern "C" size_t
-rust_uv_helper_uv_getaddrinfo_t_size() {
- return sizeof(uv_getaddrinfo_t);
-}
-extern "C" size_t
-rust_uv_helper_addrinfo_size() {
- return sizeof(addrinfo);
-}
-extern "C" unsigned int
-rust_uv_helper_get_INADDR_NONE() {
- return INADDR_NONE;
-}
extern "C" uv_stream_t*
rust_uv_get_stream_handle_from_connect_req(uv_connect_t* connect) {
return connect->handle;
rust_uv_loop_set_data
rust_uv_run
rust_uv_close
-rust_uv_hilvl_close
rust_uv_async_send
rust_uv_async_init
-rust_uv_hilvl_timer_start
rust_uv_timer_init
rust_uv_timer_start
rust_uv_timer_stop
rust_uv_get_next_addrinfo
rust_uv_addrinfo_as_sockaddr_in
rust_uv_addrinfo_as_sockaddr_in6
-rust_uv_helper_uv_tcp_t_size
-rust_uv_helper_uv_connect_t_size
-rust_uv_helper_uv_buf_t_size
-rust_uv_helper_uv_write_t_size
-rust_uv_helper_uv_err_t_size
-rust_uv_helper_sockaddr_in_size
-rust_uv_helper_sockaddr_in6_size
-rust_uv_helper_addr_in_size
-rust_uv_helper_addrinfo_size
-rust_uv_helper_uv_getaddrinfo_t_size
-rust_uv_helper_get_INADDR_NONE
-rust_uv_helper_uv_async_t_size
-rust_uv_helper_uv_timer_t_size
rust_uv_get_stream_handle_from_connect_req
rust_uv_get_stream_handle_from_write_req
rust_uv_get_loop_for_uv_handle
const char* path) {
PassManager *PM = unwrap<PassManager>(PMR);
std::string ErrorInfo;
- raw_fd_ostream OS(path, ErrorInfo, raw_fd_ostream::F_Binary);
+ raw_fd_ostream OS(path, ErrorInfo, sys::fs::F_Binary);
formatted_raw_ostream FOS(OS);
PM->add(createPrintModulePass(&FOS));
PM->run(*unwrap(M));
bool NoVerify = false;
std::string ErrorInfo;
raw_fd_ostream OS(path, ErrorInfo,
- raw_fd_ostream::F_Binary);
+ sys::fs::F_Binary);
if (ErrorInfo != "") {
LLVMRustError = ErrorInfo.c_str();
return false;
return wrap(Type::getMetadataTy(*unwrap(C)));
}
+extern "C" void LLVMAddFunctionAttrString(LLVMValueRef fn, const char *Name) {
+ unwrap<Function>(fn)->addFnAttr(Name);
+}
+
extern "C" LLVMValueRef LLVMBuildAtomicLoad(LLVMBuilderRef B,
LLVMValueRef source,
const char* Name,
return wrap(Builder->createFunction(
unwrapDI<DIScope>(Scope), Name, LinkageName,
unwrapDI<DIFile>(File), LineNo,
- unwrapDI<DIType>(Ty), isLocalToUnit, isDefinition, ScopeLine,
+ unwrapDI<DICompositeType>(Ty), isLocalToUnit, isDefinition, ScopeLine,
Flags, isOptimized,
unwrap<Function>(Fn),
unwrapDI<MDNode*>(TParam),
extern "C" void LLVMSetUnnamedAddr(LLVMValueRef Value, LLVMBool Unnamed) {
unwrap<GlobalValue>(Value)->setUnnamedAddr(Unnamed);
}
+
+extern "C" LLVMValueRef LLVMDIBuilderCreateTemplateTypeParameter(
+ DIBuilderRef Builder,
+ LLVMValueRef Scope,
+ const char* Name,
+ LLVMValueRef Ty,
+ LLVMValueRef File = 0,
+ unsigned LineNo = 0,
+ unsigned ColumnNo = 0)
+{
+ return wrap(Builder->createTemplateTypeParameter(
+ unwrapDI<DIDescriptor>(Scope),
+ Name,
+ unwrapDI<DIType>(Ty),
+ unwrapDI<MDNode*>(File),
+ LineNo,
+ ColumnNo));
+}
# If this file is modified, then llvm will be forcibly cleaned and then rebuilt.
# The actual contents of this file do not matter, but to trigger a change on the
# build bots then the contents should be changed so git updates the mtime.
-2013-07-04
+2013-08-20
LLVMAddEarlyCSEPass
LLVMAddFunction
LLVMAddFunctionAttr
+LLVMAddFunctionAttrString
LLVMAddFunctionAttrsPass
LLVMAddFunctionInliningPass
LLVMAddGVNPass
LLVMDIBuilderCreateEnumerator
LLVMDIBuilderCreateEnumerationType
LLVMDIBuilderCreateUnionType
+LLVMDIBuilderCreateTemplateTypeParameter
LLVMSetUnnamedAddr
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::comm::*;
use std::task;
pub fn foo<T:Send + Clone>(x: T) -> Port<T> {
// except according to those terms.
pub mod kitties {
- use std::uint;
-
pub struct cat {
priv meows : uint,
how_hungry : int,
how_hungry: in_y
}
}
-
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::to_str::*;
-
pub mod kitty {
pub struct cat {
priv meows : uint,
}
impl add for name_pool {
- fn add(&self, s: ~str) {
+ fn add(&self, _s: ~str) {
}
}
}
pub fn nominal() -> e { e_val }
-pub fn nominal_eq(e1: e, e2: e) -> bool { true }
+pub fn nominal_eq(_e1: e, _e2: e) -> bool { true }
impl Eq for e {
fn eq(&self, other: &e) -> bool { nominal_eq(*self, *other) }
pub fn nominal() -> e { e_val }
-pub fn nominal_neq(e1: e, e2: e) -> bool { false }
+pub fn nominal_neq(_e1: e, _e2: e) -> bool { false }
pub fn f() -> int { 20 }
}
}
+#[fixed_stack_segment] #[inline(never)]
pub fn fact(n: uint) -> uint {
unsafe {
info!("n = %?", n);
}
fn init() -> arc_destruct<context_res> {
- unsafe {
- arc(context_res())
- }
+ arc(context_res())
}
struct context_res {
enum maybe<T> { just(T), nothing }
impl <T:Clone> Index<uint,T> for maybe<T> {
- fn index(&self, idx: &uint) -> T {
+ fn index(&self, _idx: &uint) -> T {
match self {
&just(ref t) => (*t).clone(),
¬hing => { fail!(); }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#[allow(unused_imports)];
+
extern mod issue_2316_a;
pub mod cloth {
pub fn f() {
let x = S { x: 1 };
let y = x;
- let z = y;
+ let _z = y;
}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+pub fn f(x: int) -> int { -x }
+
+pub static F: extern fn(int) -> int = f;
+pub static mut MutF: extern fn(int) -> int = f;
trait B<T> {
fn thing<U>(&self, x: T, y: U) -> (T, U) { (x, y) }
- fn staticthing<U>(z: &Self, x: T, y: U) -> (T, U) { (x, y) }
+ fn staticthing<U>(_z: &Self, x: T, y: U) -> (T, U) { (x, y) }
}
impl<T> B<T> for int { }
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Test library crate for cross-crate usages of traits inheriting
+// from the builtin kinds. Mostly tests metadata correctness.
+
+#[crate_type="lib"];
+
+pub trait RequiresFreeze : Freeze { }
+pub trait RequiresRequiresFreezeAndSend : RequiresFreeze + Send { }
--- /dev/null
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[crate_type="lib"];
+
+condition! {
+ pub oops: int -> int;
+}
+
+pub fn trouble() -> int {
+ oops::cond.raise(1)
+}
--- /dev/null
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[crate_type="lib"];
+
+condition! {
+ pub oops: int -> int;
+}
--- /dev/null
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[crate_type="lib"];
+
+condition! {
+ pub oops: int -> int;
+}
+
+pub fn guard(k: extern fn() -> int, x: int) -> int {
+ do oops::cond.trap(|i| i*x).inside {
+ k()
+ }
+}
--- /dev/null
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[crate_type="lib"];
+
+#[deriving(Eq)]
+pub enum Color {
+ Red, Green, Blue
+}
+
+condition! {
+ pub oops: (int,float,~str) -> ::Color;
+}
+
+pub trait Thunk<T> {
+ fn call(self) -> T;
+}
+
+pub fn callback<T,TH:Thunk<T>>(t:TH) -> T {
+ t.call()
+}
+
let mut set = f();
do timed(&mut self.sequential_strings) {
for i in range(0u, num_keys) {
- let s = uint::to_str(i);
- set.insert(s);
+ set.insert(i.to_str());
}
for i in range(0u, num_keys) {
- let s = uint::to_str(i);
- assert!(set.contains(&s));
+ assert!(set.contains(&i.to_str()));
}
}
}
let mut set = f();
do timed(&mut self.random_strings) {
for _ in range(0, num_keys) {
- let s = uint::to_str(rng.next() as uint);
+ let s = (rng.next() as uint).to_str();
set.insert(s);
}
}
{
let mut set = f();
for i in range(0u, num_keys) {
- set.insert(uint::to_str(i));
+ set.insert(i.to_str());
}
do timed(&mut self.delete_strings) {
for i in range(0u, num_keys) {
- assert!(set.remove(&uint::to_str(i)));
+ assert!(set.remove(&i.to_str()));
}
}
}
extern mod extra;
use extra::time::precise_time_s;
-use std::int;
use std::io;
use std::os;
use std::rand::RngUtil;
use std::rand;
-use std::result;
use std::str;
-use std::uint;
use std::util;
use std::vec;
let n = uint::from_str(args[1]).unwrap();
for i in range(0u, n) {
- let x = uint::to_str(i);
+ let x = i.to_str();
info!(x);
}
}
use extra::future;
use extra::time;
use std::cell::Cell;
-use std::io;
use std::os;
use std::uint;
use extra::future;
use extra::time;
use std::cell::Cell;
-use std::io;
use std::os;
use std::uint;
// Perlin noise benchmark from https://gist.github.com/1170424
use std::float;
-use std::int;
use std::rand::{Rng, RngUtil};
use std::rand;
fn gradient(orig: Vec2, grad: Vec2, p: Vec2) -> f32 {
let sp = Vec2 {x: p.x - orig.x, y: p.y - orig.y};
- grad.x * sp.x + grad.y + sp.y
+ grad.x * sp.x + grad.y * sp.y
}
struct Noise2DContext {
extern mod extra;
-use std::task::spawn;
use std::os;
use std::uint;
use std::rt::test::spawntask_later;
extern mod extra;
-use std::task::spawn;
use std::os;
use std::uint;
use std::rt::test::spawntask_later;
extern mod extra;
use std::int;
-use std::io;
use std::os;
fn ack(m: int, n: int) -> int {
use std::os;
use std::rand::Rng;
use std::rand;
-use std::result;
use std::str;
-use std::uint;
static LINE_LENGTH: uint = 60u;
extern mod extra;
use std::int;
-use std::io;
use std::os;
fn fib(n: int) -> int {
use std::io;
use std::option;
use std::os;
-use std::result;
use std::str;
use std::task;
use std::util;
let elapsed = stop - start;
out.write_line(fmt!("%d\t%d\t%s", n, fibn,
- u64::to_str(elapsed)));
+ elapsed.to_str()));
}
}
}
use std::io::{ReaderUtil, WriterUtil};
use std::io;
use std::os;
-use std::u8;
use std::uint;
use std::unstable::intrinsics::cttz16;
use std::vec;
do task::spawn_supervised {
let c = c.take();
if gens_left & 1 == 1 {
- task::yield(); // shake things up a bit
+ task::deschedule(); // shake things up a bit
}
if gens_left > 0 {
child_generation(gens_left - 1, c); // recurse
#[no_mangle]
fn test() {
- let x = foo(10);
+ let _x = foo(10);
}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Constants (static variables) can be used to match in patterns, but mutable
+// statics cannot. This ensures that there's some form of error if this is
+// attempted.
+
+use std::libc;
+
+#[nolink]
+extern {
+ static mut debug_static_mut: libc::c_int;
+ pub fn debug_static_mut_check_four();
+ #[cfg(stage37)] //~ ERROR expected item after attributes
+}
+
+pub fn main() {}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Test for traits that inherit from multiple builtin kinds at once,
+// testing that all such kinds must be present on implementing types.
+
+trait Foo : Send+Freeze { }
+
+impl <T: Freeze> Foo for (T,) { } //~ ERROR cannot implement this trait
+
+impl <T: Send> Foo for (T,T) { } //~ ERROR cannot implement this trait
+
+impl <T: Send+Freeze> Foo for (T,T,T) { } // (ok)
+
+fn main() { }
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// xfail-fast
+
+// aux-build:trait_superkinds_in_metadata.rs
+
+// Test for traits inheriting from the builtin kinds cross-crate.
+// Mostly tests correctness of metadata.
+
+extern mod trait_superkinds_in_metadata;
+use trait_superkinds_in_metadata::{RequiresRequiresFreezeAndSend, RequiresFreeze};
+
+struct X<T>(T);
+
+impl <T:Freeze> RequiresFreeze for X<T> { }
+
+impl <T:Freeze> RequiresRequiresFreezeAndSend for X<T> { } //~ ERROR cannot implement this trait
+
+fn main() { }
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Tests (negatively) the ability for the Self type in default methods
+// to use capabilities granted by builtin kinds as supertraits.
+
+use std::comm;
+
+trait Foo : Freeze {
+ fn foo(self, chan: comm::Chan<Self>) {
+ chan.send(self); //~ ERROR does not fulfill `Send`
+ }
+}
+
+impl <T: Freeze> Foo for T { }
+
+fn main() {
+ let (p,c) = comm::stream();
+ 1193182.foo(c);
+ assert!(p.recv() == 1193182);
+}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Basic test for traits inheriting from the builtin kinds, checking
+// the type contents of the implementing type (that's not a typaram).
+
+trait Foo : Send { }
+
+impl <'self> Foo for &'self mut () { } //~ ERROR cannot implement this trait
+
+trait Bar : Freeze { }
+
+impl <'self> Bar for &'self mut () { } //~ ERROR cannot implement this trait
+
+fn main() { }
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Basic test for traits inheriting from the builtin kinds.
+
+trait Foo : Send { }
+
+impl <T: Freeze> Foo for T { } //~ ERROR cannot implement this trait
+
+fn main() { }
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// See issue #8517 for why this should be illegal.
+
+struct X<T>(T);
+
+impl <T> Send for X<T> { } //~ ERROR cannot provide an explicit implementation for a builtin kind
+impl <T> Sized for X<T> { } //~ ERROR cannot provide an explicit implementation for a builtin kind
+impl <T> Freeze for X<T> { } //~ ERROR cannot provide an explicit implementation for a builtin kind
+
+fn main() { }
use std::local_data;
-static key: local_data::Key<@&int> = &local_data::Key;
+local_data_key!(key: @&int)
//~^ ERROR only 'static is allowed
fn main() {}
+++ /dev/null
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-use std::uint;
-
-fn uuid() -> uint { fail!(); }
-
-fn from_str(s: ~str) -> uint { fail!(); }
-fn to_str(u: uint) -> ~str { fail!(); }
-fn uuid_random() -> uint { fail!(); }
-
-fn main() {
- do range(0u, 100000).advance |_i| { //~ ERROR Do-block body must return bool, but
- };
- // should get a more general message if the callback
- // doesn't return nil
- do range(0u, 100000).advance |_i| { //~ ERROR mismatched types
- ~"str"
- };
-}
+++ /dev/null
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-fn main() {
- fn take_block(f: &fn() -> bool) -> bool { f() }
- do take_block {}; //~ ERROR Do-block body must return bool, but returns () here. Perhaps
-}
// except according to those terms.
// xfail-test
-use core::io::ReaderUtil;
-use core::io::Reader;
+use std::io::ReaderUtil;
+use std::io::Reader;
fn bar(r:@ReaderUtil) -> ~str { r.read_line() }
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn foo<T>(t: T) {}
+fn main() { foo(fail!()) } //~ ERROR cannot determine a type for this expression: unconstrained type
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn main() {
+ fmt!("%?", None); //~ ERROR: cannot determine a type for this expression: unconstrained type
+}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::cast;
+
+fn main() {
+ cast::transmute(0); //~ ERROR: cannot determine a type for this expression: unconstrained type
+}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn foo(b: bool) -> Result<bool,~str> {
+ Err(~"bar"); //~ ERROR: cannot determine a type for this expression: unconstrained type
+}
+
+fn main() {
+ foo(false);
+}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+pub struct TypeWithState<State>;
+pub struct MyState;
+
+pub fn foo<State>(_: TypeWithState<State>) {}
+
+pub fn bar() {
+ foo(TypeWithState); //~ ERROR: cannot determine a type for this expression: unconstrained type
+}
+
+fn main() {
+}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+trait Foo { fn a() } //~ ERROR expected `;` or `{` but found `}`
+
+fn main() {}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+struct Monster {
+ damage: int
+}
+
+
+fn main() {
+ let _m = Monster(); //~ ERROR `Monster` is a structure name, but
+ //~^ NOTE Did you mean to write: `Monster { /* fields */ }`?
+}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+extern mod extra;
+use extra::rc::RcMut;
+
+trait Foo
+{
+ fn set(&mut self, v: RcMut<A>);
+}
+
+struct B
+{
+ v: Option<RcMut<A>>
+}
+
+impl Foo for B
+{
+ fn set(&mut self, v: RcMut<A>)
+ {
+ self.v = Some(v);
+ }
+}
+
+struct A
+{
+ v: ~Foo,
+}
+
+fn main()
+{
+ let a = A {v: ~B{v: None} as ~Foo}; //~ ERROR cannot pack type `~B`, which does not fulfill `Send`
+ let v = RcMut::from_freeze(a); //~ ERROR instantiating a type parameter with an incompatible type
+ let w = v.clone();
+ v.with_mut_borrow(|p| {p.v.set(w.clone());})
+}
// Exercise the unused_unsafe attribute in some positive and negative cases
+#[allow(cstack)];
#[deny(unused_unsafe)];
mod foo {
}
}
}
+
unsafe fn good3() { foo::bar() }
fn good4() { unsafe { foo::bar() } }
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::local_data;
+
+// check that the local data keys are private by default.
+
+mod bar {
+ local_data_key!(baz: float)
+}
+
+fn main() {
+ local_data::set(bar::baz, -10.0);
+ //~^ ERROR unresolved name `bar::baz`
+}
//~^ ERROR obsolete syntax: `let` in field declaration
bar: ();
//~^ ERROR obsolete syntax: field declaration terminated with semicolon
- new() { }
- //~^ ERROR obsolete syntax: struct constructor
}
struct q : r {
fn main() {
- let ext_cx = mk_ctxt();
+ let cx = mk_ctxt();
- let abc = quote_expr!(23);
+ let abc = quote_expr!(cx, 23);
check_pp(abc, pprust::print_expr, "23");
- let expr3 = quote_expr!(2 - $abcd + 7); //~ ERROR unresolved name: abcd
+ let expr3 = quote_expr!(cx, 2 - $abcd + 7); //~ ERROR unresolved name: abcd
check_pp(expr3, pprust::print_expr, "2 - 23 + 7");
}
fn main() {
- let ext_cx = mk_ctxt();
+ let cx = mk_ctxt();
- let stmt = quote_stmt!(let x int = 20;); //~ ERROR expected end-of-string
+ let stmt = quote_stmt!(cx, let x int = 20;); //~ ERROR expected end-of-string
check_pp(*stmt, pprust::print_stmt, "");
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-//error-pattern:libc::c_int or libc::c_long should be used
+#[forbid(ctypes)];
+
mod xx {
extern {
- pub fn strlen(str: *u8) -> uint;
- pub fn foo(x: int, y: uint);
+ pub fn strlen(str: *u8) -> uint; //~ ERROR found rust type `uint`
+ pub fn foo(x: int, y: uint); //~ ERROR found rust type `int`
+ //~^ ERROR found rust type `uint`
}
}
fn main() {
- // let it fail to verify warning message
- fail!()
}
// debugger:print f64
// check:$15 = 3.5
+#[allow(unused_variable)];
+
fn main() {
let b: bool = false;
let i: int = -1;
// debugger:print *f64_ref
// check:$15 = 3.5
+#[allow(unused_variable)];
+
fn main() {
let bool_val: bool = true;
let bool_ref: &bool = &bool_val;
zzz();
}
-fn zzz() {()}
\ No newline at end of file
+fn zzz() {()}
// debugger:print *the_c_ref
// check:$3 = TheC
+#[allow(unused_variable)];
+
enum ABC { TheA, TheB, TheC }
fn main() {
zzz();
}
-fn zzz() {()}
\ No newline at end of file
+fn zzz() {()}
// debugger:print *univariant_ref
// check:$3 = {4820353753753434}
+#[allow(unused_variable)];
+
// The first element is to ensure proper alignment, irrespective of the machines word size. Since
// the size of the discriminant value is machine dependent, this has be taken into account when
// datatype layout should be predictable as in this case.
zzz();
}
-fn zzz() {()}
\ No newline at end of file
+fn zzz() {()}
// debugger:print *f64_ref
// check:$15 = 3.5
+#[allow(unused_variable)];
fn main() {
let bool_box: @bool = @true;
zzz();
}
-fn zzz() {()}
\ No newline at end of file
+fn zzz() {()}
// debugger:print *unique_val_interior_ref_2
// check:$10 = 26.5
-
+#[allow(unused_variable)];
struct SomeStruct {
x: int,
zzz();
}
-fn zzz() {()}
\ No newline at end of file
+fn zzz() {()}
// debugger:print *unique_val_ref
// check:$4 = {-17, -22}
+#[allow(unused_variable)];
+
fn main() {
let stack_val: (i16, f32) = (-14, -19f32);
let stack_val_ref: &(i16, f32) = &stack_val;
zzz();
}
-fn zzz() {()}
\ No newline at end of file
+fn zzz() {()}
// debugger:print *f64_ref
// check:$15 = 3.5
+#[allow(unused_variable)];
+
fn main() {
let bool_box: ~bool = ~true;
zzz();
}
-fn zzz() {()}
\ No newline at end of file
+fn zzz() {()}
// debugger:print d->val
// check:$4 = false
+#[allow(unused_variable)];
+
fn main() {
let a = ~1;
let b = ~(2, 3.5);
// debugger:print managed_dtor->val
// check:$4 = {x = 33, y = 333, z = 3333, w = 33333}
+#[allow(unused_variable)];
+
struct StructWithSomePadding {
x: i16,
y: i32,
zzz();
}
-fn zzz() {()}
\ No newline at end of file
+fn zzz() {()}
// debugger:print *((uint64_t[4]*)(unique->elements))
// check:$4 = {10, 11, 12, 13}
+#[allow(unused_variable)];
+
fn main() {
let managed: @[i64] = @[7, 8, 9];
zzz();
}
-fn zzz() {()}
\ No newline at end of file
+fn zzz() {()}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Does not work yet, see issue #8512
+// xfail-test
+
+// compile-flags:-Z extra-debug-info
+// debugger:break zzz
+// debugger:run
+
+// debugger:finish
+// debugger:print s
+// check:$1 = {a = 1, b = 2.5}
+// debugger:continue
+
+#[deriving(Clone)]
+struct Struct {
+ a: int,
+ b: float
+}
+
+fn fun(s: Struct) {
+ zzz();
+}
+
+fn main() {
+ fun(Struct { a: 1, b: 2.5 });
+}
+
+fn zzz() {()}
// debugger:print struct_with_drop
// check:$7 = {{a = OneHundred, b = Vienna}, 9}
+#[allow(unused_variable)];
+
enum AnEnum {
OneHundred = 100,
OneThousand = 1000,
zzz();
}
-fn zzz() {()}
\ No newline at end of file
+fn zzz() {()}
// debugger:print single_variant
// check:$7 = TheOnlyVariant
+#[allow(unused_variable)];
+
enum AutoDiscriminant {
One,
Two,
zzz();
}
-fn zzz() {()}
\ No newline at end of file
+fn zzz() {()}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// xfail-win32 Broken because of LLVM bug: http://llvm.org/bugs/show_bug.cgi?id=16249
+
+// compile-flags:-Z extra-debug-info
+// debugger:break zzz
+// debugger:run
+
+// debugger:finish
+// debugger:print x
+// check:$1 = 0.5
+// debugger:print y
+// check:$2 = 10
+// debugger:continue
+
+// debugger:finish
+// debugger:print *x
+// check:$3 = 29
+// debugger:print *y
+// check:$4 = 110
+// debugger:continue
+
+fn some_generic_fun<T1, T2>(a: T1, b: T2) -> (T2, T1) {
+
+ let closure = |x, y| {
+ zzz();
+ (y, x)
+ };
+
+ closure(a, b)
+}
+
+fn main() {
+ some_generic_fun(0.5, 10);
+ some_generic_fun(&29, ~110);
+}
+
+fn zzz() {()}
// check:$49 = 62
// debugger:continue
+#[allow(unused_variable)];
struct Struct {
a: i64,
}
-fn zzz() {()}
\ No newline at end of file
+fn zzz() {()}
// debugger:print *nn
// check:$43 = 56
+#[allow(unused_variable)];
struct Struct {
a: i64,
zzz();
}
-fn zzz() {()}
\ No newline at end of file
+fn zzz() {()}
// debugger:print struct_padded_at_end
// check:$5 = {x = {22, 23}, y = {24, 25}}
+#[allow(unused_variable)];
+
struct NoPadding1 {
x: [u32, ..3],
y: i32,
zzz();
}
-fn zzz() {()}
\ No newline at end of file
+fn zzz() {()}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// xfail-win32 Broken because of LLVM bug: http://llvm.org/bugs/show_bug.cgi?id=16249
+
+// compile-flags:-Z extra-debug-info
+// debugger:break zzz
+// debugger:run
+
+// debugger:finish
+// debugger:print *t0
+// check:$1 = 1
+// debugger:print *t1
+// check:$2 = 2.5
+// debugger:print ret
+// check:$3 = {{1, 2.5}, {2.5, 1}}
+// debugger:continue
+
+// debugger:finish
+// debugger:print *t0
+// check:$4 = 3.5
+// debugger:print *t1
+// check:$5 = 4
+// debugger:print ret
+// check:$6 = {{3.5, 4}, {4, 3.5}}
+// debugger:continue
+
+// debugger:finish
+// debugger:print *t0
+// check:$7 = 5
+// debugger:print *t1
+// check:$8 = {a = 6, b = 7.5}
+// debugger:print ret
+// check:$9 = {{5, {a = 6, b = 7.5}}, {{a = 6, b = 7.5}, 5}}
+// debugger:continue
+
+#[deriving(Clone)]
+struct Struct {
+ a: int,
+ b: float
+}
+
+fn dup_tup<T0: Clone, T1: Clone>(t0: &T0, t1: &T1) -> ((T0, T1), (T1, T0)) {
+ let ret = ((t0.clone(), t1.clone()), (t1.clone(), t0.clone()));
+ zzz();
+ ret
+}
+
+fn main() {
+
+ let _ = dup_tup(&1, &2.5);
+ let _ = dup_tup(&3.5, &4_u16);
+ let _ = dup_tup(&5, &Struct { a: 6, b: 7.5 });
+}
+
+fn zzz() {()}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// xfail-win32 Broken because of LLVM bug: http://llvm.org/bugs/show_bug.cgi?id=16249
+
+// compile-flags:-Z extra-debug-info
+// debugger:break zzz
+// debugger:run
+
+// debugger:finish
+// debugger:print x
+// check:$1 = -1
+// debugger:print y
+// check:$2 = 1
+// debugger:continue
+
+// debugger:finish
+// debugger:print x
+// check:$3 = -1
+// debugger:print y
+// check:$4 = 2.5
+// debugger:continue
+
+// debugger:finish
+// debugger:print x
+// check:$5 = -2.5
+// debugger:print y
+// check:$6 = 1
+// debugger:continue
+
+// debugger:finish
+// debugger:print x
+// check:$7 = -2.5
+// debugger:print y
+// check:$8 = 2.5
+// debugger:continue
+
+fn outer<TA: Clone>(a: TA) {
+ inner(a.clone(), 1);
+ inner(a.clone(), 2.5);
+
+ fn inner<TX, TY>(x: TX, y: TY) {
+ zzz();
+ }
+}
+
+fn main() {
+ outer(-1);
+ outer(-2.5);
+}
+
+fn zzz() {()}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// xfail-win32 Broken because of LLVM bug: http://llvm.org/bugs/show_bug.cgi?id=16249
+
+// compile-flags:-Z extra-debug-info
+// debugger:break zzz
+// debugger:run
+
+// STACK BY REF
+// debugger:finish
+// debugger:print *self
+// check:$1 = {x = {8888, -8888}}
+// debugger:print arg1
+// check:$2 = -1
+// debugger:print/d arg2
+// check:$3 = -2
+// debugger:continue
+
+// STACK BY VAL
+// debugger:finish
+// d ebugger:print self -- ignored for now because of issue #8512
+// c heck:$X = {x = {8888, -8888}}
+// debugger:print arg1
+// check:$4 = -3
+// debugger:print arg2
+// check:$5 = -4
+// debugger:continue
+
+// OWNED BY REF
+// debugger:finish
+// debugger:print *self
+// check:$6 = {x = 1234.5}
+// debugger:print arg1
+// check:$7 = -5
+// debugger:print arg2
+// check:$8 = -6
+// debugger:continue
+
+// OWNED BY VAL
+// debugger:finish
+// d ebugger:print self -- ignored for now because of issue #8512
+// c heck:$X = {x = 1234.5}
+// debugger:print arg1
+// check:$9 = -7
+// debugger:print arg2
+// check:$10 = -8
+// debugger:continue
+
+// OWNED MOVED
+// debugger:finish
+// debugger:print *self
+// check:$11 = {x = 1234.5}
+// debugger:print arg1
+// check:$12 = -9
+// debugger:print arg2
+// check:$13 = -10.5
+// debugger:continue
+
+// MANAGED BY REF
+// debugger:finish
+// debugger:print *self
+// check:$14 = {x = -1}
+// debugger:print arg1
+// check:$15 = -11
+// debugger:print arg2
+// check:$16 = -12.5
+// debugger:continue
+
+// MANAGED BY VAL
+// debugger:finish
+// d ebugger:print self -- ignored for now because of issue #8512
+// c heck:$X = {x = -1}
+// debugger:print arg1
+// check:$17 = -13
+// debugger:print *arg2
+// check:$18 = {-14, 14}
+// debugger:continue
+
+// MANAGED SELF
+// debugger:finish
+// debugger:print self->val
+// check:$19 = {x = -1}
+// debugger:print arg1
+// check:$20 = -15
+// debugger:print *arg2
+// check:$21 = {-16, 16.5}
+// debugger:continue
+
+struct Struct<T> {
+ x: T
+}
+
+impl<T1> Struct<T1> {
+
+ fn self_by_ref<T2>(&self, arg1: int, arg2: T2) -> int {
+ zzz();
+ arg1
+ }
+
+ fn self_by_val<T2>(self, arg1: int, arg2: T2) -> int {
+ zzz();
+ arg1
+ }
+
+ fn self_owned<T2>(~self, arg1: int, arg2: T2) -> int {
+ zzz();
+ arg1
+ }
+
+ fn self_managed<T2>(@self, arg1: int, arg2: T2) -> int {
+ zzz();
+ arg1
+ }
+}
+
+fn main() {
+ let stack = Struct { x: (8888_u32, -8888_i32) };
+ let _ = stack.self_by_ref(-1, -2_i8);
+ let _ = stack.self_by_val(-3, -4_i16);
+
+ let owned = ~Struct { x: 1234.5 };
+ let _ = owned.self_by_ref(-5, -6_i32);
+ let _ = owned.self_by_val(-7, -8_i64);
+ let _ = owned.self_owned(-9, -10.5_f32);
+
+ let managed = @Struct { x: -1_i16 };
+ let _ = managed.self_by_ref(-11, -12.5_f64);
+ let _ = managed.self_by_val(-13, &(-14, 14));
+ let _ = managed.self_managed(-15, &(-16, 16.5));
+}
+
+fn zzz() {()}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// xfail-win32 Broken because of LLVM bug: http://llvm.org/bugs/show_bug.cgi?id=16249
+
+// compile-flags:-Z extra-debug-info
+// debugger:break zzz
+// debugger:run
+
+// STRUCT
+// debugger:finish
+// debugger:print arg1
+// check:$1 = 1
+// debugger:print arg2
+// check:$2 = 2
+// debugger:continue
+
+// ENUM
+// debugger:finish
+// debugger:print arg1
+// check:$3 = -3
+// debugger:print arg2
+// check:$4 = 4.5
+// debugger:print arg3
+// check:$5 = 5
+// debugger:continue
+
+
+struct Struct {
+ x: int
+}
+
+impl Struct {
+
+ fn static_method<T1, T2>(arg1: T1, arg2: T2) -> int {
+ zzz();
+ return 0;
+ }
+}
+
+enum Enum {
+ Variant1 { x: int },
+ Variant2,
+ Variant3(float, int, char),
+}
+
+impl Enum {
+
+ fn static_method<T1, T2, T3>(arg1: T1, arg2: T2, arg3: T3) -> int {
+ zzz();
+ return 1;
+ }
+}
+
+fn main() {
+ Struct::static_method(1, 2);
+ Enum::static_method(-3, 4.5, 5);
+}
+
+fn zzz() {()}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// xfail-win32 Broken because of LLVM bug: http://llvm.org/bugs/show_bug.cgi?id=16249
+
+// compile-flags:-Z extra-debug-info
+// debugger:set print union on
+// debugger:break zzz
+// debugger:run
+// debugger:finish
+
+// debugger:print case1
+// check:$1 = {{Case1, a = 0, b = 31868, c = 31868, d = 31868, e = 31868}, {Case1, a = 0, b = 2088533116, c = 2088533116}, {Case1, a = 0, b = 8970181431921507452}}
+
+// debugger:print case2
+// check:$2 = {{Case2, a = 0, b = 4369, c = 4369, d = 4369, e = 4369}, {Case2, a = 0, b = 286331153, c = 286331153}, {Case2, a = 0, b = 1229782938247303441}}
+
+// debugger:print case3
+// check:$3 = {{Case3, a = 0, b = 22873, c = 22873, d = 22873, e = 22873}, {Case3, a = 0, b = 1499027801, c = 1499027801}, {Case3, a = 0, b = 6438275382588823897}}
+
+// debugger:print univariant
+// check:$4 = {a = -1}
+
+// NOTE: This is a copy of the non-generic test case. The `Txx` type parameters have to be
+// substituted with something of size `xx` bits and the same alignment as an integer type of the
+// same size.
+
+// The first element is to ensure proper alignment, irrespective of the machines word size. Since
+// the size of the discriminant value is machine dependent, this has be taken into account when
+// datatype layout should be predictable as in this case.
+enum Regular<T16, T32, T64> {
+ Case1 { a: T64, b: T16, c: T16, d: T16, e: T16},
+ Case2 { a: T64, b: T32, c: T32},
+ Case3 { a: T64, b: T64 }
+}
+
+enum Univariant<T> {
+ TheOnlyCase { a: T }
+}
+
+fn main() {
+
+ // In order to avoid endianess trouble all of the following test values consist of a single
+ // repeated byte. This way each interpretation of the union should look the same, no matter if
+ // this is a big or little endian machine.
+
+ // 0b0111110001111100011111000111110001111100011111000111110001111100 = 8970181431921507452
+ // 0b01111100011111000111110001111100 = 2088533116
+ // 0b0111110001111100 = 31868
+ // 0b01111100 = 124
+ let case1: Regular<u16, u32, i64> = Case1 { a: 0, b: 31868, c: 31868, d: 31868, e: 31868 };
+
+ // 0b0001000100010001000100010001000100010001000100010001000100010001 = 1229782938247303441
+ // 0b00010001000100010001000100010001 = 286331153
+ // 0b0001000100010001 = 4369
+ // 0b00010001 = 17
+ let case2: Regular<i16, u32, i64> = Case2 { a: 0, b: 286331153, c: 286331153 };
+
+ // 0b0101100101011001010110010101100101011001010110010101100101011001 = 6438275382588823897
+ // 0b01011001010110010101100101011001 = 1499027801
+ // 0b0101100101011001 = 22873
+ // 0b01011001 = 89
+ let case3: Regular<u16, i32, u64> = Case3 { a: 0, b: 6438275382588823897 };
+
+ let univariant = TheOnlyCase { a: -1 };
+
+ zzz();
+}
+
+fn zzz() {()}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// xfail-win32 Broken because of LLVM bug: http://llvm.org/bugs/show_bug.cgi?id=16249
+
+// compile-flags:-Z extra-debug-info
+// debugger:break zzz
+// debugger:run
+
+// debugger:finish
+// debugger:print int_int
+// check:$1 = {key = 0, value = 1}
+// debugger:print int_float
+// check:$2 = {key = 2, value = 3.5}
+// debugger:print float_int
+// check:$3 = {key = 4.5, value = 5}
+// debugger:print float_int_float
+// check:$4 = {key = 6.5, value = {key = 7, value = 8.5}}
+
+struct AGenericStruct<TKey, TValue> {
+ key: TKey,
+ value: TValue
+}
+
+fn main() {
+
+ let int_int = AGenericStruct { key: 0, value: 1 };
+ let int_float = AGenericStruct { key: 2, value: 3.5 };
+ let float_int = AGenericStruct { key: 4.5, value: 5 };
+ let float_int_float = AGenericStruct { key: 6.5, value: AGenericStruct { key: 7, value: 8.5 } };
+
+ zzz();
+}
+
+fn zzz() {()}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// xfail-win32 Broken because of LLVM bug: http://llvm.org/bugs/show_bug.cgi?id=16249
+
+// compile-flags:-Z extra-debug-info
+// debugger:break zzz
+// debugger:run
+
+// debugger:finish
+// debugger:print arg1
+// check:$1 = 1000
+// debugger:print *arg2
+// check:$2 = {1, 2.5}
+// debugger:continue
+
+// debugger:finish
+// debugger:print arg1
+// check:$3 = 2000
+// debugger:print *arg2
+// check:$4 = {3.5, {4, 5, 6}}
+// debugger:continue
+
+
+struct Struct {
+ x: int
+}
+
+trait Trait<T1> {
+ fn generic_static_default_method<T2>(arg1: int, arg2: &(T1, T2)) -> int {
+ zzz();
+ arg1
+ }
+}
+
+impl<T> Trait<T> for Struct;
+
+fn main() {
+
+ // Is this really how to use these?
+ Trait::generic_static_default_method::<int, Struct, float>(1000, &(1, 2.5));
+ Trait::generic_static_default_method::<float, Struct, (int, int, int)>(2000, &(3.5, (4, 5, 6)));
+
+}
+
+fn zzz() {()}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// xfail-win32 Broken because of LLVM bug: http://llvm.org/bugs/show_bug.cgi?id=16249
+
+// compile-flags:-Z extra-debug-info
+// debugger:set print union on
+// debugger:break zzz
+// debugger:run
+// debugger:finish
+
+// debugger:print case1
+// check:$1 = {{Case1, 0, 31868, 31868, 31868, 31868}, {Case1, 0, 2088533116, 2088533116}, {Case1, 0, 8970181431921507452}}
+
+// debugger:print case2
+// check:$2 = {{Case2, 0, 4369, 4369, 4369, 4369}, {Case2, 0, 286331153, 286331153}, {Case2, 0, 1229782938247303441}}
+
+// debugger:print case3
+// check:$3 = {{Case3, 0, 22873, 22873, 22873, 22873}, {Case3, 0, 1499027801, 1499027801}, {Case3, 0, 6438275382588823897}}
+
+// debugger:print univariant
+// check:$4 = {-1}
+
+
+// NOTE: This is a copy of the non-generic test case. The `Txx` type parameters have to be
+// substituted with something of size `xx` bits and the same alignment as an integer type of the
+// same size.
+
+// The first element is to ensure proper alignment, irrespective of the machines word size. Since
+// the size of the discriminant value is machine dependent, this has be taken into account when
+// datatype layout should be predictable as in this case.
+enum Regular<T16, T32, T64> {
+ Case1(T64, T16, T16, T16, T16),
+ Case2(T64, T32, T32),
+ Case3(T64, T64)
+}
+
+enum Univariant<T64> {
+ TheOnlyCase(T64)
+}
+
+fn main() {
+
+ // In order to avoid endianess trouble all of the following test values consist of a single
+ // repeated byte. This way each interpretation of the union should look the same, no matter if
+ // this is a big or little endian machine.
+
+ // 0b0111110001111100011111000111110001111100011111000111110001111100 = 8970181431921507452
+ // 0b01111100011111000111110001111100 = 2088533116
+ // 0b0111110001111100 = 31868
+ // 0b01111100 = 124
+ let case1: Regular<u16, u32, u64> = Case1(0_u64, 31868_u16, 31868_u16, 31868_u16, 31868_u16);
+
+ // 0b0001000100010001000100010001000100010001000100010001000100010001 = 1229782938247303441
+ // 0b00010001000100010001000100010001 = 286331153
+ // 0b0001000100010001 = 4369
+ // 0b00010001 = 17
+ let case2: Regular<i16, i32, i64> = Case2(0_i64, 286331153_i32, 286331153_i32);
+
+ // 0b0101100101011001010110010101100101011001010110010101100101011001 = 6438275382588823897
+ // 0b01011001010110010101100101011001 = 1499027801
+ // 0b0101100101011001 = 22873
+ // 0b01011001 = 89
+ let case3: Regular<i16, i32, i64> = Case3(0_i64, 6438275382588823897_i64);
+
+ let univariant = TheOnlyCase(-1_i64);
+
+ zzz();
+}
+
+fn zzz() {()}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// xfail-win32 Broken because of LLVM bug: http://llvm.org/bugs/show_bug.cgi?id=16249
+
+// compile-flags:-Z debug-info
+// debugger:run
+
+// Nothing to do here really, just make sure it compiles. See issue #8513.
+fn main() {
+ let _ = ||();
+ let _ = range(1u,3).map(|_| 5);
+}
+
// debugger:print univariant->val
// check:$3 = {-9747455}
+#[allow(unused_variable)];
+
// The first element is to ensure proper alignment, irrespective of the machines word size. Since
// the size of the discriminant value is machine dependent, this has be taken into account when
// datatype layout should be predictable as in this case.
zzz();
}
-fn zzz() {()}
\ No newline at end of file
+fn zzz() {()}
// debugger:print unique->val.elements[3]->val
// check:$4 = 13
+#[allow(unused_variable)];
+
fn main() {
let unique: ~[@i64] = ~[@10, @11, @12, @13];
zzz();
}
-fn zzz() {()}
\ No newline at end of file
+fn zzz() {()}
// debugger:print managed_within_unique.val->y->val
// check:$3 = -4
+#[allow(unused_variable)];
+
struct ContainsManaged
{
x: int,
zzz();
}
-fn zzz() {()}
\ No newline at end of file
+fn zzz() {()}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// xfail-win32 Broken because of LLVM bug: http://llvm.org/bugs/show_bug.cgi?id=16249
+
+// compile-flags:-Z extra-debug-info
+// debugger:break zzz
+// debugger:run
+
+// STACK BY REF
+// debugger:finish
+// debugger:print *self
+// check:$1 = {{Variant2, x = 1799, y = 1799}, {Variant2, 117901063}}
+// debugger:print arg1
+// check:$2 = -1
+// debugger:print arg2
+// check:$3 = -2
+// debugger:continue
+
+// STACK BY VAL
+// debugger:finish
+// d ebugger:print self -- ignored for now because of issue #8512
+// c heck:$X = {{Variant2, x = 1799, y = 1799}, {Variant2, 117901063}}
+// debugger:print arg1
+// check:$4 = -3
+// debugger:print arg2
+// check:$5 = -4
+// debugger:continue
+
+// OWNED BY REF
+// debugger:finish
+// debugger:print *self
+// check:$6 = {{Variant1, x = 1799, y = 1799}, {Variant1, 117901063}}
+// debugger:print arg1
+// check:$7 = -5
+// debugger:print arg2
+// check:$8 = -6
+// debugger:continue
+
+// OWNED BY VAL
+// debugger:finish
+// d ebugger:print self -- ignored for now because of issue #8512
+// c heck:$X = {{Variant1, x = 1799, y = 1799}, {Variant1, 117901063}}
+// debugger:print arg1
+// check:$9 = -7
+// debugger:print arg2
+// check:$10 = -8
+// debugger:continue
+
+// OWNED MOVED
+// debugger:finish
+// debugger:print *self
+// check:$11 = {{Variant1, x = 1799, y = 1799}, {Variant1, 117901063}}
+// debugger:print arg1
+// check:$12 = -9
+// debugger:print arg2
+// check:$13 = -10
+// debugger:continue
+
+// MANAGED BY REF
+// debugger:finish
+// debugger:print *self
+// check:$14 = {{Variant2, x = 1799, y = 1799}, {Variant2, 117901063}}
+// debugger:print arg1
+// check:$15 = -11
+// debugger:print arg2
+// check:$16 = -12
+// debugger:continue
+
+// MANAGED BY VAL
+// debugger:finish
+// d ebugger:print self -- ignored for now because of issue #8512
+// c heck:$X = {{Variant2, x = 1799, y = 1799}, {Variant2, 117901063}}
+// debugger:print arg1
+// check:$17 = -13
+// debugger:print arg2
+// check:$18 = -14
+// debugger:continue
+
+// MANAGED SELF
+// debugger:finish
+// debugger:print self->val
+// check:$19 = {{Variant2, x = 1799, y = 1799}, {Variant2, 117901063}}
+// debugger:print arg1
+// check:$20 = -15
+// debugger:print arg2
+// check:$21 = -16
+// debugger:continue
+
+enum Enum {
+ Variant1 { x: u16, y: u16 },
+ Variant2 (u32)
+}
+
+impl Enum {
+
+ fn self_by_ref(&self, arg1: int, arg2: int) -> int {
+ zzz();
+ arg1 + arg2
+ }
+
+ fn self_by_val(self, arg1: int, arg2: int) -> int {
+ zzz();
+ arg1 + arg2
+ }
+
+ fn self_owned(~self, arg1: int, arg2: int) -> int {
+ zzz();
+ arg1 + arg2
+ }
+
+ fn self_managed(@self, arg1: int, arg2: int) -> int {
+ zzz();
+ arg1 + arg2
+ }
+}
+
+fn main() {
+ let stack = Variant2(117901063);
+ let _ = stack.self_by_ref(-1, -2);
+ let _ = stack.self_by_val(-3, -4);
+
+ let owned = ~Variant1{ x: 1799, y: 1799 };
+ let _ = owned.self_by_ref(-5, -6);
+ let _ = owned.self_by_val(-7, -8);
+ let _ = owned.self_owned(-9, -10);
+
+ let managed = @Variant2(117901063);
+ let _ = managed.self_by_ref(-11, -12);
+ let _ = managed.self_by_val(-13, -14);
+ let _ = managed.self_managed(-15, -16);
+}
+
+fn zzz() {()}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// xfail-win32 Broken because of LLVM bug: http://llvm.org/bugs/show_bug.cgi?id=16249
+
+// compile-flags:-Z extra-debug-info
+// debugger:break zzz
+// debugger:run
+
+// STACK BY REF
+// debugger:finish
+// debugger:print *self
+// check:$1 = {x = {8888, -8888}}
+// debugger:print arg1
+// check:$2 = -1
+// debugger:print arg2
+// check:$3 = -2
+// debugger:continue
+
+// STACK BY VAL
+// debugger:finish
+// d ebugger:print self -- ignored for now because of issue #8512
+// c heck:$X = {x = {8888, -8888}}
+// debugger:print arg1
+// check:$4 = -3
+// debugger:print arg2
+// check:$5 = -4
+// debugger:continue
+
+// OWNED BY REF
+// debugger:finish
+// debugger:print *self
+// check:$6 = {x = 1234.5}
+// debugger:print arg1
+// check:$7 = -5
+// debugger:print arg2
+// check:$8 = -6
+// debugger:continue
+
+// OWNED BY VAL
+// debugger:finish
+// d ebugger:print self -- ignored for now because of issue #8512
+// c heck:$X = {x = 1234.5}
+// debugger:print arg1
+// check:$9 = -7
+// debugger:print arg2
+// check:$10 = -8
+// debugger:continue
+
+// OWNED MOVED
+// debugger:finish
+// debugger:print *self
+// check:$11 = {x = 1234.5}
+// debugger:print arg1
+// check:$12 = -9
+// debugger:print arg2
+// check:$13 = -10
+// debugger:continue
+
+// MANAGED BY REF
+// debugger:finish
+// debugger:print *self
+// check:$14 = {x = -1}
+// debugger:print arg1
+// check:$15 = -11
+// debugger:print arg2
+// check:$16 = -12
+// debugger:continue
+
+// MANAGED BY VAL
+// debugger:finish
+// d ebugger:print self -- ignored for now because of issue #8512
+// c heck:$X = {x = -1}
+// debugger:print arg1
+// check:$17 = -13
+// debugger:print arg2
+// check:$18 = -14
+// debugger:continue
+
+// MANAGED SELF
+// debugger:finish
+// debugger:print self->val
+// check:$19 = {x = -1}
+// debugger:print arg1
+// check:$20 = -15
+// debugger:print arg2
+// check:$21 = -16
+// debugger:continue
+
+struct Struct<T> {
+ x: T
+}
+
+impl<T> Struct<T> {
+
+ fn self_by_ref(&self, arg1: int, arg2: int) -> int {
+ zzz();
+ arg1 + arg2
+ }
+
+ fn self_by_val(self, arg1: int, arg2: int) -> int {
+ zzz();
+ arg1 + arg2
+ }
+
+ fn self_owned(~self, arg1: int, arg2: int) -> int {
+ zzz();
+ arg1 + arg2
+ }
+
+ fn self_managed(@self, arg1: int, arg2: int) -> int {
+ zzz();
+ arg1 + arg2
+ }
+}
+
+fn main() {
+ let stack = Struct { x: (8888_u32, -8888_i32) };
+ let _ = stack.self_by_ref(-1, -2);
+ let _ = stack.self_by_val(-3, -4);
+
+ let owned = ~Struct { x: 1234.5 };
+ let _ = owned.self_by_ref(-5, -6);
+ let _ = owned.self_by_val(-7, -8);
+ let _ = owned.self_owned(-9, -10);
+
+ let managed = @Struct { x: -1_i16 };
+ let _ = managed.self_by_ref(-11, -12);
+ let _ = managed.self_by_val(-13, -14);
+ let _ = managed.self_managed(-15, -16);
+}
+
+fn zzz() {()}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// xfail-win32 Broken because of LLVM bug: http://llvm.org/bugs/show_bug.cgi?id=16249
+
+// compile-flags:-Z extra-debug-info
+// debugger:break zzz
+// debugger:run
+
+// STACK BY REF
+// debugger:finish
+// debugger:print *self
+// check:$1 = {x = 100}
+// debugger:print arg1
+// check:$2 = -1
+// debugger:print arg2
+// check:$3 = -2
+// debugger:continue
+
+// STACK BY VAL
+// debugger:finish
+// d ebugger:print self -- ignored for now because of issue #8512
+// c heck:$X = {x = 100}
+// debugger:print arg1
+// check:$4 = -3
+// debugger:print arg2
+// check:$5 = -4
+// debugger:continue
+
+// OWNED BY REF
+// debugger:finish
+// debugger:print *self
+// check:$6 = {x = 200}
+// debugger:print arg1
+// check:$7 = -5
+// debugger:print arg2
+// check:$8 = -6
+// debugger:continue
+
+// OWNED BY VAL
+// debugger:finish
+// d ebugger:print self -- ignored for now because of issue #8512
+// c heck:$X = {x = 200}
+// debugger:print arg1
+// check:$9 = -7
+// debugger:print arg2
+// check:$10 = -8
+// debugger:continue
+
+// OWNED MOVED
+// debugger:finish
+// debugger:print *self
+// check:$11 = {x = 200}
+// debugger:print arg1
+// check:$12 = -9
+// debugger:print arg2
+// check:$13 = -10
+// debugger:continue
+
+// MANAGED BY REF
+// debugger:finish
+// debugger:print *self
+// check:$14 = {x = 300}
+// debugger:print arg1
+// check:$15 = -11
+// debugger:print arg2
+// check:$16 = -12
+// debugger:continue
+
+// MANAGED BY VAL
+// debugger:finish
+// d ebugger:print self -- ignored for now because of issue #8512
+// c heck:$X = {x = 300}
+// debugger:print arg1
+// check:$17 = -13
+// debugger:print arg2
+// check:$18 = -14
+// debugger:continue
+
+// MANAGED SELF
+// debugger:finish
+// debugger:print self->val
+// check:$19 = {x = 300}
+// debugger:print arg1
+// check:$20 = -15
+// debugger:print arg2
+// check:$21 = -16
+// debugger:continue
+
+struct Struct {
+ x: int
+}
+
+impl Struct {
+
+ fn self_by_ref(&self, arg1: int, arg2: int) -> int {
+ zzz();
+ self.x + arg1 + arg2
+ }
+
+ fn self_by_val(self, arg1: int, arg2: int) -> int {
+ zzz();
+ self.x + arg1 + arg2
+ }
+
+ fn self_owned(~self, arg1: int, arg2: int) -> int {
+ zzz();
+ self.x + arg1 + arg2
+ }
+
+ fn self_managed(@self, arg1: int, arg2: int) -> int {
+ zzz();
+ self.x + arg1 + arg2
+ }
+}
+
+fn main() {
+ let stack = Struct { x: 100 };
+ let _ = stack.self_by_ref(-1, -2);
+ let _ = stack.self_by_val(-3, -4);
+
+ let owned = ~Struct { x: 200 };
+ let _ = owned.self_by_ref(-5, -6);
+ let _ = owned.self_by_val(-7, -8);
+ let _ = owned.self_owned(-9, -10);
+
+ let managed = @Struct { x: 300 };
+ let _ = managed.self_by_ref(-11, -12);
+ let _ = managed.self_by_val(-13, -14);
+ let _ = managed.self_managed(-15, -16);
+}
+
+fn zzz() {()}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// xfail-win32 Broken because of LLVM bug: http://llvm.org/bugs/show_bug.cgi?id=16249
+
+// compile-flags:-Z extra-debug-info
+// debugger:break zzz
+// debugger:run
+
+// STACK BY REF
+// debugger:finish
+// debugger:print *self
+// check:$1 = {x = 100}
+// debugger:print arg1
+// check:$2 = -1
+// debugger:print arg2
+// check:$3 = -2
+// debugger:continue
+
+// STACK BY VAL
+// debugger:finish
+// d ebugger:print self -- ignored for now because of issue #8512
+// c heck:$X = {x = 100}
+// debugger:print arg1
+// check:$4 = -3
+// debugger:print arg2
+// check:$5 = -4
+// debugger:continue
+
+// OWNED BY REF
+// debugger:finish
+// debugger:print *self
+// check:$6 = {x = 200}
+// debugger:print arg1
+// check:$7 = -5
+// debugger:print arg2
+// check:$8 = -6
+// debugger:continue
+
+// OWNED BY VAL
+// debugger:finish
+// d ebugger:print self -- ignored for now because of issue #8512
+// c heck:$X = {x = 200}
+// debugger:print arg1
+// check:$9 = -7
+// debugger:print arg2
+// check:$10 = -8
+// debugger:continue
+
+// OWNED MOVED
+// debugger:finish
+// debugger:print *self
+// check:$11 = {x = 200}
+// debugger:print arg1
+// check:$12 = -9
+// debugger:print arg2
+// check:$13 = -10
+// debugger:continue
+
+// MANAGED BY REF
+// debugger:finish
+// debugger:print *self
+// check:$14 = {x = 300}
+// debugger:print arg1
+// check:$15 = -11
+// debugger:print arg2
+// check:$16 = -12
+// debugger:continue
+
+// MANAGED BY VAL
+// debugger:finish
+// d ebugger:print self -- ignored for now because of issue #8512
+// c heck:$X = {x = 300}
+// debugger:print arg1
+// check:$17 = -13
+// debugger:print arg2
+// check:$18 = -14
+// debugger:continue
+
+// MANAGED SELF
+// debugger:finish
+// debugger:print self->val
+// check:$19 = {x = 300}
+// debugger:print arg1
+// check:$20 = -15
+// debugger:print arg2
+// check:$21 = -16
+// debugger:continue
+
+struct Struct {
+ x: int
+}
+
+trait Trait {
+ fn self_by_ref(&self, arg1: int, arg2: int) -> int;
+ fn self_by_val(self, arg1: int, arg2: int) -> int;
+ fn self_owned(~self, arg1: int, arg2: int) -> int;
+ fn self_managed(@self, arg1: int, arg2: int) -> int;
+}
+
+impl Trait for Struct {
+
+ fn self_by_ref(&self, arg1: int, arg2: int) -> int {
+ zzz();
+ self.x + arg1 + arg2
+ }
+
+ fn self_by_val(self, arg1: int, arg2: int) -> int {
+ zzz();
+ self.x + arg1 + arg2
+ }
+
+ fn self_owned(~self, arg1: int, arg2: int) -> int {
+ zzz();
+ self.x + arg1 + arg2
+ }
+
+ fn self_managed(@self, arg1: int, arg2: int) -> int {
+ zzz();
+ self.x + arg1 + arg2
+ }
+}
+
+fn main() {
+ let stack = Struct { x: 100 };
+ let _ = stack.self_by_ref(-1, -2);
+ let _ = stack.self_by_val(-3, -4);
+
+ let owned = ~Struct { x: 200 };
+ let _ = owned.self_by_ref(-5, -6);
+ let _ = owned.self_by_val(-7, -8);
+ let _ = owned.self_owned(-9, -10);
+
+ let managed = @Struct { x: 300 };
+ let _ = managed.self_by_ref(-11, -12);
+ let _ = managed.self_by_val(-13, -14);
+ let _ = managed.self_managed(-15, -16);
+}
+
+fn zzz() {()}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// xfail-win32 Broken because of LLVM bug: http://llvm.org/bugs/show_bug.cgi?id=16249
+
+// compile-flags:-Z extra-debug-info
+// debugger:break zzz
+// debugger:run
+
+// STACK BY REF
+// debugger:finish
+// debugger:print *self
+// check:$1 = {100, -100.5}
+// debugger:print arg1
+// check:$2 = -1
+// debugger:print arg2
+// check:$3 = -2
+// debugger:continue
+
+// STACK BY VAL
+// debugger:finish
+// d ebugger:print self -- ignored for now because of issue #8512
+// c heck:$X = {100, -100.5}
+// debugger:print arg1
+// check:$4 = -3
+// debugger:print arg2
+// check:$5 = -4
+// debugger:continue
+
+// OWNED BY REF
+// debugger:finish
+// debugger:print *self
+// check:$6 = {200, -200.5}
+// debugger:print arg1
+// check:$7 = -5
+// debugger:print arg2
+// check:$8 = -6
+// debugger:continue
+
+// OWNED BY VAL
+// debugger:finish
+// d ebugger:print self -- ignored for now because of issue #8512
+// c heck:$X = {200, -200.5}
+// debugger:print arg1
+// check:$9 = -7
+// debugger:print arg2
+// check:$10 = -8
+// debugger:continue
+
+// OWNED MOVED
+// debugger:finish
+// debugger:print *self
+// check:$11 = {200, -200.5}
+// debugger:print arg1
+// check:$12 = -9
+// debugger:print arg2
+// check:$13 = -10
+// debugger:continue
+
+// MANAGED BY REF
+// debugger:finish
+// debugger:print *self
+// check:$14 = {300, -300.5}
+// debugger:print arg1
+// check:$15 = -11
+// debugger:print arg2
+// check:$16 = -12
+// debugger:continue
+
+// MANAGED BY VAL
+// debugger:finish
+// d ebugger:print self -- ignored for now because of issue #8512
+// c heck:$X = {300, -300.5}
+// debugger:print arg1
+// check:$17 = -13
+// debugger:print arg2
+// check:$18 = -14
+// debugger:continue
+
+// MANAGED SELF
+// debugger:finish
+// debugger:print self->val
+// check:$19 = {300, -300.5}
+// debugger:print arg1
+// check:$20 = -15
+// debugger:print arg2
+// check:$21 = -16
+// debugger:continue
+
+struct TupleStruct(int, float);
+
+impl TupleStruct {
+
+ fn self_by_ref(&self, arg1: int, arg2: int) -> int {
+ zzz();
+ arg1 + arg2
+ }
+
+ fn self_by_val(self, arg1: int, arg2: int) -> int {
+ zzz();
+ arg1 + arg2
+ }
+
+ fn self_owned(~self, arg1: int, arg2: int) -> int {
+ zzz();
+ arg1 + arg2
+ }
+
+ fn self_managed(@self, arg1: int, arg2: int) -> int {
+ zzz();
+ arg1 + arg2
+ }
+}
+
+fn main() {
+ let stack = TupleStruct(100, -100.5);
+ let _ = stack.self_by_ref(-1, -2);
+ let _ = stack.self_by_val(-3, -4);
+
+ let owned = ~TupleStruct(200, -200.5);
+ let _ = owned.self_by_ref(-5, -6);
+ let _ = owned.self_by_val(-7, -8);
+ let _ = owned.self_owned(-9, -10);
+
+ let managed = @TupleStruct(300, -300.5);
+ let _ = managed.self_by_ref(-11, -12);
+ let _ = managed.self_by_val(-13, -14);
+ let _ = managed.self_managed(-15, -16);
+}
+
+fn zzz() {()}
// debugger:print abc
// check:$3 = 30303
+#[allow(unused_variable)];
+
fn function_one() {
let abc = 10101;
zzz();
// debugger:print c
// check:$3 = 30303
+#[allow(unused_variable)];
+
fn function_one() {
let a = 10101;
zzz();
// debugger:print second
// check:$2 = {<No data fields>}
+#[allow(unused_variable)];
+
enum ANilEnum {}
enum AnotherNilEnum {}
}
}
-fn zzz() {()}
\ No newline at end of file
+fn zzz() {()}
// except according to those terms.
// xfail-win32 Broken because of LLVM bug: http://llvm.org/bugs/show_bug.cgi?id=16249
-// xfail-test broken in newrt?
// compile-flags:-Z extra-debug-info
// debugger:break zzz
// debugger:print full
// check:$3 = {454545, 0x87654321, 9988}
-// debugger:print empty
-// check:$4 = {0, 0x0, 0}
+// debugger:print empty->discr
+// check:$4 = (int *) 0x0
// debugger:print droid
// check:$5 = {id = 675675, range = 10000001, internals = 0x43218765}
-// debugger:print void_droid
-// check:$6 = {id = 0, range = 0, internals = 0x0}
+// debugger:print void_droid->internals
+// check:$6 = (int *) 0x0
+// debugger:continue
// If a struct has exactly two variants, one of them is empty, and the other one
// contains a non-nullable pointer, then this value is used as the discriminator.
// The test cases in this file make sure that something readable is generated for
// this kind of types.
+// Unfortunately (for these test cases) the content of the non-discriminant fields
+// in the null-case is not defined. So we just read the discriminator field in
+// this case (by casting the value to a memory-equivalent struct).
enum MoreFields<'self> {
Full(u32, &'self int, i16),
Empty
}
+struct MoreFieldsRepr<'self> {
+ a: u32,
+ discr: &'self int,
+ b: i16
+}
+
enum NamedFields<'self> {
Droid { id: i32, range: i64, internals: &'self int },
Void
}
+struct NamedFieldsRepr<'self> {
+ id: i32,
+ range: i64,
+ internals: &'self int
+}
+
fn main() {
let some: Option<&u32> = Some(unsafe { std::cast::transmute(0x12345678) });
let full = Full(454545, unsafe { std::cast::transmute(0x87654321) }, 9988);
let int_val = 0;
- let mut empty = Full(0, &int_val, 0);
- empty = Empty;
+ let empty: &MoreFieldsRepr = unsafe { std::cast::transmute(&Empty) };
- let droid = Droid { id: 675675, range: 10000001, internals: unsafe { std::cast::transmute(0x43218765) } };
+ let droid = Droid {
+ id: 675675,
+ range: 10000001,
+ internals: unsafe { std::cast::transmute(0x43218765) }
+ };
- let mut void_droid = Droid { id: 0, range: 0, internals: &int_val };
- void_droid = Void;
+ let void_droid: &NamedFieldsRepr = unsafe { std::cast::transmute(&Void) };
zzz();
}
-fn zzz() {()}
\ No newline at end of file
+fn zzz() {()}
// debugger:print deeplyNested
// check:$8 = {a = {a = 1, b = {x = 2, y = 3, z = 4}, c = 5, d = {x = 6, y = 7, z = 8}}, b = {a = 9, b = {x = 10, y = 11, z = 12}, c = {x = 13, y = 14, z = 15}, d = 16}, c = {a = 17, b = {x = 18, y = 19, z = 20}, c = 21, d = {x = 22, y = 23, z = 24}}, d = {a = 25, b = {x = 26, y = 27, z = 28}, c = 29, d = {x = 30, y = 31, z = 32}}, e = {a = 33, b = {x = 34, y = 35, z = 36}, c = {x = 37, y = 38, z = 39}, d = 40}, f = {a = 41, b = {x = 42, y = 43, z = 44}, c = 45, d = {x = 46, y = 47, z = 48}}}
+#[allow(unused_variable)];
+
#[packed]
struct Packed {
x: i16,
zzz();
}
-fn zzz() {()}
\ No newline at end of file
+fn zzz() {()}
// debugger:print sizeof(packedInPacked)
// check:$6 = 40
+#[allow(unused_variable)];
+
#[packed]
struct Packed {
x: i16,
zzz();
}
-fn zzz() {()}
\ No newline at end of file
+fn zzz() {()}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// xfail-win32 Broken because of LLVM bug: http://llvm.org/bugs/show_bug.cgi?id=16249
+
+// compile-flags:-Z extra-debug-info
+// debugger:break zzz
+// debugger:run
+
+// STACK BY REF
+// debugger:finish
+// debugger:print *self
+// check:$1 = {x = 100}
+// debugger:print arg1
+// check:$2 = -1
+// debugger:print arg2
+// check:$3 = -2
+// debugger:continue
+
+// STACK BY VAL
+// debugger:finish
+// d ebugger:print self -- ignored for now because of issue #8512
+// c heck:$X = {x = 100}
+// debugger:print arg1
+// check:$4 = -3
+// debugger:print arg2
+// check:$5 = -4
+// debugger:continue
+
+// OWNED BY REF
+// debugger:finish
+// debugger:print *self
+// check:$6 = {x = 200}
+// debugger:print arg1
+// check:$7 = -5
+// debugger:print arg2
+// check:$8 = -6
+// debugger:continue
+
+// OWNED BY VAL
+// debugger:finish
+// d ebugger:print self -- ignored for now because of issue #8512
+// c heck:$X = {x = 200}
+// debugger:print arg1
+// check:$9 = -7
+// debugger:print arg2
+// check:$10 = -8
+// debugger:continue
+
+// OWNED MOVED
+// debugger:finish
+// debugger:print *self
+// check:$11 = {x = 200}
+// debugger:print arg1
+// check:$12 = -9
+// debugger:print arg2
+// check:$13 = -10
+// debugger:continue
+
+// MANAGED BY REF
+// debugger:finish
+// debugger:print *self
+// check:$14 = {x = 300}
+// debugger:print arg1
+// check:$15 = -11
+// debugger:print arg2
+// check:$16 = -12
+// debugger:continue
+
+// MANAGED BY VAL
+// debugger:finish
+// d ebugger:print self -- ignored for now because of issue #8512
+// c heck:$X = {x = 300}
+// debugger:print arg1
+// check:$17 = -13
+// debugger:print arg2
+// check:$18 = -14
+// debugger:continue
+
+// MANAGED SELF
+// debugger:finish
+// debugger:print self->val
+// check:$19 = {x = 300}
+// debugger:print arg1
+// check:$20 = -15
+// debugger:print arg2
+// check:$21 = -16
+// debugger:continue
+
+struct Struct {
+ x: int
+}
+
+trait Trait {
+ fn self_by_ref(&self, arg1: int, arg2: int) -> int {
+ zzz();
+ arg1 + arg2
+ }
+
+ fn self_by_val(self, arg1: int, arg2: int) -> int {
+ zzz();
+ arg1 + arg2
+ }
+
+ fn self_owned(~self, arg1: int, arg2: int) -> int {
+ zzz();
+ arg1 + arg2
+ }
+
+ fn self_managed(@self, arg1: int, arg2: int) -> int {
+ zzz();
+ arg1 + arg2
+ }
+}
+
+impl Trait for Struct;
+
+fn main() {
+ let stack = Struct { x: 100 };
+ let _ = stack.self_by_ref(-1, -2);
+ let _ = stack.self_by_val(-3, -4);
+
+ let owned = ~Struct { x: 200 };
+ let _ = owned.self_by_ref(-5, -6);
+ let _ = owned.self_by_val(-7, -8);
+ let _ = owned.self_owned(-9, -10);
+
+ let managed = @Struct { x: 300 };
+ let _ = managed.self_by_ref(-11, -12);
+ let _ = managed.self_by_val(-13, -14);
+ let _ = managed.self_managed(-15, -16);
+}
+
+fn zzz() {()}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// xfail-win32 Broken because of LLVM bug: http://llvm.org/bugs/show_bug.cgi?id=16249
+
+// compile-flags:-Z extra-debug-info
+// debugger:break zzz
+// debugger:run
+
+// STACK BY REF
+// debugger:finish
+// debugger:print *self
+// check:$1 = {x = 987}
+// debugger:print arg1
+// check:$2 = -1
+// debugger:print/d arg2
+// check:$3 = -2
+// debugger:continue
+
+// STACK BY VAL
+// debugger:finish
+// d ebugger:print self -- ignored for now because of issue #8512
+// c heck:$X = {x = 987}
+// debugger:print arg1
+// check:$4 = -3
+// debugger:print arg2
+// check:$5 = -4
+// debugger:continue
+
+// OWNED BY REF
+// debugger:finish
+// debugger:print *self
+// check:$6 = {x = 879}
+// debugger:print arg1
+// check:$7 = -5
+// debugger:print arg2
+// check:$8 = -6
+// debugger:continue
+
+// OWNED BY VAL
+// debugger:finish
+// d ebugger:print self -- ignored for now because of issue #8512
+// c heck:$X = {x = 879}
+// debugger:print arg1
+// check:$9 = -7
+// debugger:print arg2
+// check:$10 = -8
+// debugger:continue
+
+// OWNED MOVED
+// debugger:finish
+// debugger:print *self
+// check:$11 = {x = 879}
+// debugger:print arg1
+// check:$12 = -9
+// debugger:print arg2
+// check:$13 = -10.5
+// debugger:continue
+
+// MANAGED BY REF
+// debugger:finish
+// debugger:print *self
+// check:$14 = {x = 897}
+// debugger:print arg1
+// check:$15 = -11
+// debugger:print arg2
+// check:$16 = -12.5
+// debugger:continue
+
+// MANAGED BY VAL
+// debugger:finish
+// d ebugger:print self -- ignored for now because of issue #8512
+// c heck:$X = {x = 897}
+// debugger:print arg1
+// check:$17 = -13
+// debugger:print *arg2
+// check:$18 = {-14, 14}
+// debugger:continue
+
+// MANAGED SELF
+// debugger:finish
+// debugger:print self->val
+// check:$19 = {x = 897}
+// debugger:print arg1
+// check:$20 = -15
+// debugger:print *arg2
+// check:$21 = {-16, 16.5}
+// debugger:continue
+
+struct Struct {
+ x: int
+}
+
+trait Trait {
+
+ fn self_by_ref<T>(&self, arg1: int, arg2: T) -> int {
+ zzz();
+ arg1
+ }
+
+ fn self_by_val<T>(self, arg1: int, arg2: T) -> int {
+ zzz();
+ arg1
+ }
+
+ fn self_owned<T>(~self, arg1: int, arg2: T) -> int {
+ zzz();
+ arg1
+ }
+
+ fn self_managed<T>(@self, arg1: int, arg2: T) -> int {
+ zzz();
+ arg1
+ }
+}
+
+impl Trait for Struct;
+
+fn main() {
+ let stack = Struct { x: 987 };
+ let _ = stack.self_by_ref(-1, -2_i8);
+ let _ = stack.self_by_val(-3, -4_i16);
+
+ let owned = ~Struct { x: 879 };
+ let _ = owned.self_by_ref(-5, -6_i32);
+ let _ = owned.self_by_val(-7, -8_i64);
+ let _ = owned.self_owned(-9, -10.5_f32);
+
+ let managed = @Struct { x: 897 };
+ let _ = managed.self_by_ref(-11, -12.5_f64);
+ let _ = managed.self_by_val(-13, &(-14, 14));
+ let _ = managed.self_managed(-15, &(-16, 16.5));
+}
+
+fn zzz() {()}
// debugger:print padding_at_end
// check:$6 = {x = -10014, y = 10015}
+#[allow(unused_variable)];
struct NoPadding16 {
x: u16,
zzz();
}
-fn zzz() {()}
\ No newline at end of file
+fn zzz() {()}
// debugger:print paddingAtEnd
// check:$7 = {15, 16}
+#[allow(unused_variable)];
fn main() {
let noPadding8: (i8, u8) = (-100, 100);
zzz();
}
-fn zzz() {()}
\ No newline at end of file
+fn zzz() {()}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// xfail-win32 Broken because of LLVM bug: http://llvm.org/bugs/show_bug.cgi?id=16249
+
+// compile-flags:-Z extra-debug-info
+// debugger:break zzz
+// debugger:run
+
+// STRUCT
+// debugger:finish
+// debugger:print arg1
+// check:$1 = 1
+// debugger:print arg2
+// check:$2 = 2
+// debugger:continue
+
+// ENUM
+// debugger:finish
+// debugger:print arg1
+// check:$3 = -3
+// debugger:print arg2
+// check:$4 = 4.5
+// debugger:print arg3
+// check:$5 = 5
+// debugger:continue
+
+
+struct Struct {
+ x: int
+}
+
+impl Struct {
+
+ fn static_method(arg1: int, arg2: int) -> int {
+ zzz();
+ arg1 + arg2
+ }
+}
+
+enum Enum {
+ Variant1 { x: int },
+ Variant2,
+ Variant3(float, int, char),
+}
+
+impl Enum {
+
+ fn static_method(arg1: int, arg2: float, arg3: uint) -> int {
+ zzz();
+ arg1
+ }
+}
+
+fn main() {
+ Struct::static_method(1, 2);
+ Enum::static_method(-3, 4.5, 5);
+}
+
+fn zzz() {()}
// debugger:print univariant
// check:$3 = {{x = 123, y = 456, z = 789}}
+#[allow(unused_variable)];
+
struct Struct {
x: u32,
y: i32,
// debugger:print padding_at_end_parent
// check:$3 = {x = {x = 10, y = 11}, y = {x = 12, y = 13}, z = {x = 14, y = 15}}
+#[allow(unused_variable)];
struct Simple {
x: i32
zzz();
}
-fn zzz() {()}
\ No newline at end of file
+fn zzz() {()}
// debugger:print univariant
// check:$4 = {a = -1}
+#[allow(unused_variable)];
+
// The first element is to ensure proper alignment, irrespective of the machines word size. Since
// the size of the discriminant value is machine dependent, this has be taken into account when
// datatype layout should be predictable as in this case.
zzz();
}
-fn zzz() {()}
\ No newline at end of file
+fn zzz() {()}
// debugger:print nested
// check:$4 = {a = {a = {x = 7890, y = 9870}}}
+#[allow(unused_variable)];
+
struct NoDestructor {
x: i32,
y: i64
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// xfail-win32 Broken because of LLVM bug: http://llvm.org/bugs/show_bug.cgi?id=16249
+
+// compile-flags:-Z extra-debug-info
+// debugger:break zzz
+// debugger:run
+
+// debugger:finish
+// debugger:print arg1
+// check:$1 = 1000
+// debugger:print arg2
+// check:$2 = 0.5
+// debugger:continue
+
+// debugger:finish
+// debugger:print arg1
+// check:$3 = 2000
+// debugger:print *arg2
+// check:$4 = {1, 2, 3}
+// debugger:continue
+
+
+struct Struct {
+ x: int
+}
+
+trait Trait {
+ fn generic_static_default_method<T>(arg1: int, arg2: T) -> int {
+ zzz();
+ arg1
+ }
+}
+
+impl Trait for Struct;
+
+fn main() {
+
+ // Is this really how to use these?
+ Trait::generic_static_default_method::<Struct, float>(1000, 0.5);
+ Trait::generic_static_default_method::<Struct, &(int, int, int)>(2000, &(1, 2, 3));
+
+}
+
+fn zzz() {()}
// debugger:print mixed_padding
// check:$10 = {x = {{40, 41, 42}, {43, 44}}, y = {45, 46, 47, 48}}
+#[allow(unused_variable)];
+
struct NoPadding1 {
x: (i32, i32),
y: i32,
zzz();
}
-fn zzz() {()}
\ No newline at end of file
+fn zzz() {()}
// debugger:print padding_at_end2
// check:$7 = {{21, 22}, 23}
+#[allow(unused_variable)];
+
fn main() {
let no_padding1: ((u32, u32), u32, u32) = ((0, 1), 2, 3);
let no_padding2: (u32, (u32, u32), u32) = (4, (5, 6), 7);
zzz();
}
-fn zzz() {()}
\ No newline at end of file
+fn zzz() {()}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// xfail-win32 Broken because of LLVM bug: http://llvm.org/bugs/show_bug.cgi?id=16249
+
+// compile-flags:-Z extra-debug-info
+// debugger:set print pretty off
+// debugger:break zzz
+// debugger:run
+// debugger:finish
+
+// debugger:print no_padding16
+// check:$1 = {10000, -10001}
+
+// debugger:print no_padding32
+// check:$2 = {-10002, -10003.5, 10004}
+
+// debugger:print no_padding64
+// check:$3 = {-10005.5, 10006, 10007}
+
+// debugger:print no_padding163264
+// check:$4 = {-10008, 10009, 10010, 10011}
+
+// debugger:print internal_padding
+// check:$5 = {10012, -10013}
+
+// debugger:print padding_at_end
+// check:$6 = {-10014, 10015}
+
+
+// This test case mainly makes sure that no field names are generated for tuple structs (as opposed
+// to all fields having the name "__field__"). Otherwise they are handled the same a normal structs.
+
+struct NoPadding16(u16, i16);
+struct NoPadding32(i32, f32, u32);
+struct NoPadding64(f64, i64, u64);
+struct NoPadding163264(i16, u16, i32, u64);
+struct InternalPadding(u16, i64);
+struct PaddingAtEnd(i64, u16);
+
+fn main() {
+ let no_padding16 = NoPadding16(10000, -10001);
+ let no_padding32 = NoPadding32(-10002, -10003.5, 10004);
+ let no_padding64 = NoPadding64(-10005.5, 10006, 10007);
+ let no_padding163264 = NoPadding163264(-10008, 10009, 10010, 10011);
+
+ let internal_padding = InternalPadding(10012, -10013);
+ let padding_at_end = PaddingAtEnd(-10014, 10015);
+
+ zzz();
+}
+
+fn zzz() {()}
// debugger:print univariant
// check:$4 = {-1}
+#[allow(unused_variable)];
+
// The first element is to ensure proper alignment, irrespective of the machines word size. Since
// the size of the discriminant value is machine dependent, this has be taken into account when
// datatype layout should be predictable as in this case.
zzz();
}
-fn zzz() {()}
\ No newline at end of file
+fn zzz() {()}
// debugger:print *univariant
// check:$3 = {123234}
+#[allow(unused_variable)];
+
// The first element is to ensure proper alignment, irrespective of the machines word size. Since
// the size of the discriminant value is machine dependent, this has be taken into account when
// datatype layout should be predictable as in this case.
zzz();
}
-fn zzz() {()}
\ No newline at end of file
+fn zzz() {()}
// debugger:print padded_struct.data_ptr[1]
// check:$13 = {x = 13, y = 14, z = 15}
+#[allow(unused_variable)];
+
struct AStruct {
x: i16,
y: i32,
// debugger:print a
// check:$1 = {1, 2, 3}
+#[allow(unused_variable)];
+
fn main() {
let a = [1, 2, 3];
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn blk1(b: &fn()) -> @fn() { return || { }; }
+fn blk1(_b: &fn()) -> @fn() { return || { }; }
fn test1() { (do blk1 { info!("hi"); })(); }
fn id(f: &fn() -> int) -> int { f() }
-fn wsucc(n: int) -> int { (do id || { 1 }) - 0 }
+fn wsucc(_n: int) -> int { (do id || { 1 }) - 0 }
fn main() { }
// pp-exact
-fn from_foreign_fn(x: extern "Rust" fn()) { }
-fn from_stack_closure(x: &fn()) { }
-fn from_box_closure(x: @fn()) { }
-fn from_unique_closure(x: ~fn()) { }
+fn from_foreign_fn(_x: extern "Rust" fn()) { }
+fn from_stack_closure(_x: &fn()) { }
+fn from_box_closure(_x: @fn()) { }
+fn from_unique_closure(_x: ~fn()) { }
fn main() { }
// pp-exact
-fn f(v: &[int]) {
+fn f(v: &[int]) -> int {
let mut n = 0;
for e in v.iter() {
n = *e; // This comment once triggered pretty printer bug
}
+
+ n
}
fn main() {
let x = Some(3);
- let y =
+ let _y =
match x {
Some(_) =>
- ~"some" + ~"very" + ~"very" + ~"very" + ~"very" + ~"very" +
- ~"very" + ~"very" + ~"very" + ~"long" + ~"string",
+ ~"some" + "very" + "very" + "very" + "very" + "very" + "very" +
+ "very" + "very" + "long" + "string",
None => ~"none"
};
}
fn main() {
let x = Some(3);
- let y = match x { Some(_) => ~"some(_)", None => ~"none" };
+ let _y = match x { Some(_) => ~"some(_)", None => ~"none" };
}
fn main() {
struct Foo2;
struct Bar2(int, int, int);
- let a = Bar(5, 5);
- let b = Foo;
+ let _a = Bar(5, 5);
+ let _b = Foo;
}
// Testing that comments are correctly interleaved
// pp-exact:vec-comments.pp
fn main() {
- let v1 =
+ let _v1 =
~[
// Comment
0,
1,
// Comment
2];
- let v2 =
+ let _v2 =
~[0, // Comment
1, // Comment
2]; // Comment
- let v3 =
+ let _v3 =
~[
/* Comment */
0,
1,
/* Comment */
2];
- let v4 =
+ let _v4 =
~[0, /* Comment */
1, /* Comment */
2]; /* Comment */
// Testing that comments are correctly interleaved
// pp-exact:vec-comments.pp
fn main() {
- let v1 =
+ let _v1 =
~[
// Comment
0,
1,
// Comment
2];
- let v2 =
+ let _v2 =
~[0, // Comment
1, // Comment
2]; // Comment
- let v3 =
+ let _v3 =
~[
/* Comment */
0,
1,
/* Comment */
2];
- let v4 =
+ let _v4 =
~[0, /* Comment */
1, /* Comment */
2]; /* Comment */
// pp-exact:vec-type.pp
-fn f1(x: ~[int]) { }
+fn f1(_x: ~[int]) { }
fn g1() { f1(~[1, 2, 3]); }
// pp-exact:vec-type.pp
-fn f1(x: ~[int]) { }
+fn f1(_x: ~[int]) { }
fn g1() { f1(~[1, 2, 3]); }
// except according to those terms.
// error-pattern:meep
-fn f(a: int, b: int, c: @int) { fail!("moop"); }
+fn f(_a: int, _b: int, _c: @int) { fail!("moop"); }
fn main() { f(1, fail!("meep"), @42); }
let c = @mut b;
// this should freeze `a` only
- let x: &mut [int] = c[0];
+ let _x: &mut [int] = c[0];
// hence this should fail
a[0] = a[0];
fn main() {
let x = @mut S { x: 3 };
- let y: &S = x;
+ let _y: &S = x;
let z = x;
z.x = 5;
}
fn main() {
let x = @mut 3;
- let y: &mut int = x;
+ let _y: &mut int = x;
let z = x;
*z = 5;
}
}
}
-fn it_takes_two(f: &Foo, g: &mut Foo) {
+fn it_takes_two(_f: &Foo, _g: &mut Foo) {
}
fn main() {
pub fn main()
{
let a = @mut 3;
- let b = &*a; // freezes a
+ let _b = &*a; // freezes a
add1(a);
}
pub fn main()
{
let a = @mut 3;
- let b = &mut *a; // freezes a
+ let _b = &mut *a; // freezes a
add1(a);
}
port: port_id,
}
-fn send<T:Send>(ch: chan_t<T>, data: T) { fail!(); }
+fn send<T:Send>(_ch: chan_t<T>, _data: T) { fail!(); }
fn main() { fail!("quux"); }
// error-pattern:test
fn main() {
- let i: int = fail!("test");
+ let _i: int = fail!("test");
}
// error-pattern:attempted to divide by zero
fn main() {
let y = 0;
- let z = 1 / y;
+ let _z = 1 / y;
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#[allow(unreachable_code)];
+
//error-pattern:One
fn main() {
fail!("One");
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#[allow(dead_assignment)];
+#[allow(unused_variable)];
+
// error-pattern:wooooo
fn main() {
- let mut a = 1; if 1 == 1 { a = 2; } fail!(~"woooo" + "o");
+ let mut a = 1;
+ if 1 == 1 { a = 2; }
+ fail!(~"woooo" + "o");
}
// error-pattern:explicit failure
-fn main() { let x = if false { 0 } else if true { fail!() } else { 10 }; }
+fn main() { let _x = if false { 0 } else if true { fail!() } else { 10 }; }
// error-pattern:explicit failure
-fn main() { let x = match true { false => { 0 } true => { fail!() } }; }
+fn main() { let _x = match true { false => { 0 } true => { fail!() } }; }
fn count(n: uint) -> uint {
unsafe {
- task::yield();
+ task::deschedule();
rustrt::rust_dbg_call(cb, n)
}
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#[allow(unnecessary_allocation)];
+
// error-pattern:explicit failure
// Don't double free the string
extern mod extra;
fn foo() -> e<int> {fail!();}
fn main() {
- let f = foo();
+ let _f = foo();
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#[allow(unnecessary_allocation)];
+#[allow(unreachable_code)];
+#[allow(unused_variable)];
+
// error-pattern:so long
fn main() {
let mut x = ~[];
// error-pattern:beep boop
+#[allow(unused_variable)];
+
struct Point { x: int, y: int }
fn main() {
fn main() {
let (p, _c) = comm::stream::<()>();
task::spawn(|| child() );
- task::yield();
+ task::deschedule();
}
// error-pattern:explicit failure
+#[allow(unreachable_code)];
+#[allow(unused_variable)];
+
fn foo(s: ~str) { }
fn main() {
// error-pattern:attempted remainder with a divisor of zero
fn main() {
let y = 0;
- let z = 1 % y;
+ let _z = 1 % y;
}
// as a _|_-typed thing, not a str-typed thing
// error-pattern:bye
+#[allow(unreachable_code)];
+#[allow(unused_variable)];
+
struct T { t: ~str }
-fn main() { let pth = fail!("bye"); let rs: T = T {t: pth}; }
+fn main() {
+ let pth = fail!("bye");
+ let _rs: T = T {t: pth};
+}
fn main() {
error!(~"whatever");
do task::spawn {
- let i = r(5);
+ let _i = r(5);
};
fail!();
}
use std::task;
fn goodfail() {
- task::yield();
+ task::deschedule();
fail!("goodfail");
}
// error-pattern:Ensure that the child task runs by failing
-use std::str;
use std::task;
fn main() {
// error-pattern:fail
fn main() {
- let a = @0;
+ let _a = @0;
assert!(false);
}
// error-pattern:fail
-fn f(a: @int) {
+fn f(_a: @int) {
fail!();
}
fn f() -> @int { fail!(); }
fn main() {
- let a: @int = f();
+ let _a: @int = f();
}
// error-pattern:fail
fn main() {
- let a: @int = {
+ let _a: @int = {
fail!();
};
}
fn b() { fail!(); }
fn main() {
- let x = ~[0];
+ let _x = ~[0];
a();
- let y = ~[0];
+ let _y = ~[0];
b();
}
// error-pattern:fail
+#[allow(unreachable_code)];
+#[allow(unused_variable)];
+
fn x(it: &fn(int)) {
fail!();
it(0);
// error-pattern:fail
fn x(it: &fn(int)) {
- let a = @0;
+ let _a = @0;
it(1);
}
let mush = food + cheese;
let cheese = cheese.clone();
let f: &fn() = || {
- let chew = mush + cheese;
+ let _chew = mush + cheese;
fail!("so yummy")
};
f();
// error-pattern:fail
fn main() {
- let count = @mut 0u;
+ let _count = @mut 0u;
let mut map = std::hashmap::HashMap::new();
let mut arr = ~[];
- for i in range(0u, 10u) {
+ for _i in range(0u, 10u) {
arr.push(@~"key stuff");
map.insert(arr.clone(), arr + &[@~"value stuff"]);
if arr.len() == 5 {
// error-pattern:fail
fn main() {
- let a = @0;
+ let _a = @0;
{
- let b = @0;
+ let _b = @0;
{
fail!();
}
}
fn partial() {
- let x = @f();
+ let _x = @f();
}
fn main() {
}
fn partial() {
- let x = ~f();
+ let _x = ~f();
}
fn main() {
}
fn partial() {
- let x = ~[~[0], f(), ~[0]];
+ let _x = ~[~[0], f(), ~[0]];
}
fn main() {
struct Blk { node: ~[int] }
fn main() {
- let blk = Blk {
+ let _blk = Blk {
node: build()
};
}
struct Blk { node: ~[int], span: ~[int] }
fn main() {
- let blk = Blk {
+ let _blk = Blk {
node: build1(),
span: build2()
};
fn main() {
@0;
- let r = r(0);
+ let _r = r(0);
}
// error-pattern:fail
fn f() {
- let a = @0;
+ let _a = @0;
fail!();
}
fn g() {
- let b = @0;
+ let _b = @0;
f();
}
fn main() {
- let a = @0;
+ let _a = @0;
g();
}
}
fn main() {
- let lss = (fold_local(), 0);
+ let _lss = (fold_local(), 0);
}
}
fn main() {
- let lss = (fold_local(), fold_remote());
+ let _lss = (fold_local(), fold_remote());
}
fn main() {
f();
- let a = @0;
+ let _a = @0;
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#[allow(while_true)];
+
// error-pattern:quux
-fn main() { let x: int = { while true { fail!("quux"); } ; 8 } ; }
+fn main() { let _x: int = { while true { fail!("quux"); } ; 8 } ; }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#[allow(while_true)];
+
// error-pattern:giraffe
fn main() {
fail!({ while true { fail!("giraffe") }; "clandestine" });
fn main() {
- let ext_cx = mk_ctxt();
- let s = quote_expr!(__s);
- let e = quote_expr!(__e);
- let f = quote_expr!($s.foo {|__e| $e});
+ let cx = mk_ctxt();
+ let s = quote_expr!(cx, __s);
+ let e = quote_expr!(cx, __e);
+ let f = quote_expr!(cx, $s.foo {|__e| $e});
log(error, pprust::expr_to_str(f));
}
}
fn main() {
- let ext_cx = mk_ctxt();
+ let cx = mk_ctxt();
- let abc = quote_expr!(23);
+ let abc = quote_expr!(cx, 23);
check_pp(ext_cx, abc, pprust::print_expr, ~"23");
- let ty = quote_ty!(int);
+ let ty = quote_ty!(cx, int);
check_pp(ext_cx, ty, pprust::print_type, ~"int");
- let item = quote_item!(static x : int = 10;).get();
+ let item = quote_item!(cx, static x : int = 10;).get();
check_pp(ext_cx, item, pprust::print_item, ~"static x: int = 10;");
- let stmt = quote_stmt!(let x = 20;);
+ let stmt = quote_stmt!(cx, let x = 20;);
check_pp(ext_cx, *stmt, pprust::print_stmt, ~"let x = 20;");
- let pat = quote_pat!(Some(_));
+ let pat = quote_pat!(cx, Some(_));
check_pp(ext_cx, pat, pprust::print_pat, ~"Some(_)");
}
use syntax::ext::base::ExtCtxt;
-fn syntax_extension(ext_cx: @ExtCtxt) {
- let e_toks : ~[syntax::ast::token_tree] = quote_tokens!(1 + 2);
- let p_toks : ~[syntax::ast::token_tree] = quote_tokens!((x, 1 .. 4, *));
+fn syntax_extension(cx: @ExtCtxt) {
+ let e_toks : ~[syntax::ast::token_tree] = quote_tokens!(cx, 1 + 2);
+ let p_toks : ~[syntax::ast::token_tree] = quote_tokens!(cx, (x, 1 .. 4, *));
- let a: @syntax::ast::expr = quote_expr!(1 + 2);
- let _b: Option<@syntax::ast::item> = quote_item!( static foo : int = $e_toks; );
- let _c: @syntax::ast::pat = quote_pat!( (x, 1 .. 4, *) );
- let _d: @syntax::ast::stmt = quote_stmt!( let x = $a; );
- let _e: @syntax::ast::expr = quote_expr!( match foo { $p_toks => 10 } );
+ let a: @syntax::ast::expr = quote_expr!(cx, 1 + 2);
+ let _b: Option<@syntax::ast::item> = quote_item!(cx, static foo : int = $e_toks; );
+ let _c: @syntax::ast::pat = quote_pat!(cx, (x, 1 .. 4, *) );
+ let _d: @syntax::ast::stmt = quote_stmt!(cx, let x = $a; );
+ let _e: @syntax::ast::expr = quote_expr!(cx, match foo { $p_toks => 10 } );
}
fn main() {
use anonexternmod::*;
+#[fixed_stack_segment]
pub fn main() {
unsafe {
rust_get_test_int();
fn rust_get_test_int() -> libc::intptr_t;
}
+#[fixed_stack_segment]
pub fn main() {
unsafe {
let _ = rust_get_test_int();
pub fn main() {
let mut a = X {x: 1};
let mut b = 2;
- let mut c = 3;
+ let c = 3;
assert_eq!(f1(&mut a, &mut b, c), 6);
assert_eq!(a.x, 0);
assert_eq!(b, 10);
- assert_eq!(f2(a.x, |x| a.x = 50), 0);
+ assert_eq!(f2(a.x, |_| a.x = 50), 0);
assert_eq!(a.x, 50);
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-
-
+#[allow(type_limits)];
// Unsigned integer operations
pub fn main() {
// Issue 483 - Assignment expressions result in nil
fn test_assign() {
let mut x: int;
- let mut y: () = x = 10;
+ let y: () = x = 10;
assert_eq!(x, 10);
+ assert_eq!(y, ());
let mut z = x = 11;
assert_eq!(x, 11);
+ assert_eq!(z, ());
z = x = 12;
assert_eq!(x, 12);
+ assert_eq!(z, ());
}
fn test_assign_op() {
let mut x: int = 0;
- let mut y: () = x += 10;
+ let y: () = x += 10;
assert_eq!(x, 10);
+ assert_eq!(y, ());
let mut z = x += 11;
assert_eq!(x, 21);
+ assert_eq!(z, ());
z = x += 12;
assert_eq!(x, 33);
+ assert_eq!(z, ());
}
pub fn main() { test_assign(); test_assign_op(); }
//xfail-fast
#[start]
-fn start(argc:int, argv: **u8, crate_map: *u8) -> int {
+fn start(_argc: int, _argv: **u8, _crate_map: *u8) -> int {
return 0;
}
// xfail-fast
extern mod extra;
use extra::arc;
-fn dispose(_x: arc::Arc<bool>) { unsafe { } }
+fn dispose(_x: arc::Arc<bool>) { }
pub fn main() {
let p = arc::Arc::new(true);
// Binop corner cases
-use std::libc;
-
fn test_nil() {
assert_eq!((), ());
assert!((!(() != ())));
}
fn test_class() {
- let mut q = p(1, 2);
+ let q = p(1, 2);
let mut r = p(1, 2);
unsafe {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::vec;
-
fn w_semi(v: ~[int]) -> int {
// the semicolon causes compiler not to
// complain about the ignored return value:
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::vec;
-
// Check usage and precedence of block arguments in expressions:
pub fn main() {
let v = ~[-1f, 0f, 1f, 2f, 3f];
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::uint;
use std::util;
struct Ints {sum: ~int, values: ~[int]}
}
Some(_) => { }
}
+ assert_eq!(x, Some(0));
}
pub fn main() {
let x: @mut @Option<~int> = @mut @None;
match x {
- @@Some(ref y) => {
+ @@Some(ref _y) => {
// here, the refcount of `*x` is bumped so
- // `y` remains valid even if `*x` is modified.
+ // `_y` remains valid even if `*x` is modified.
*x = @None;
}
@@None => {
struct F { f: ~int }
pub fn main() {
- let mut x = @mut @F {f: ~3};
+ let x = @mut @F {f: ~3};
match x {
@@F{f: ref b_x} => {
assert_eq!(**b_x, 3);
fn switcher(x: Option<@int>) {
let mut x = x;
match x {
- Some(@y) => { y.clone(); x = None; }
- None => { }
+ Some(@y) => { y.clone(); x = None; }
+ None => { }
}
+ assert_eq!(x, None);
}
pub fn main() {
let mut y = @4;
// borrow x and y
- let mut r_x = &*x;
- let mut r_y = &*y;
+ let r_x = &*x;
+ let r_y = &*y;
let mut r = r_x;
let mut exp = 3;
info!("*r = %d, exp = %d", *r, exp);
assert_eq!(*r, exp);
+ assert_eq!(x, @5);
+ assert_eq!(y, @6);
}
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-pub fn main() { let i: (@int, int) = (@10, 10); let (a, _) = i; }
+pub fn main() {
+ let i: (@int, int) = (@10, 10);
+ let (_a, _) = i;
+}
fn some_box(x: int) -> @int { return @x; }
-fn is_odd(n: int) -> bool { return true; }
+fn is_odd(_n: int) -> bool { return true; }
-fn length_is_even(vs: @int) -> bool { return true; }
+fn length_is_even(_vs: @int) -> bool { return true; }
-fn foo(acc: int, n: int) {
+fn foo(_acc: int, n: int) {
if is_odd(n) && length_is_even(some_box(1)) { error!("bloop"); }
}
fn some_box(x: int) -> @int { return @x; }
-fn is_odd(n: int) -> bool { return true; }
+fn is_odd(_n: int) -> bool { return true; }
-fn length_is_even(vs: @int) -> bool { return true; }
+fn length_is_even(_vs: @int) -> bool { return true; }
-fn foo(acc: int, n: int) {
+fn foo(_acc: int, n: int) {
if is_odd(n) || length_is_even(some_box(1)) { error!("bloop"); }
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::vec;
-
pub fn main() {
let mut i = 0;
while i < 20 { i += 1; if i == 10 { break; } }
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Tests "transitivity" of super-builtin-kinds on traits. Here, if
+// we have a Foo, we know we have a Bar, and if we have a Bar, we
+// know we have a Send. So if we have a Foo we should know we have
+// a Send. Basically this just makes sure rustc is using
+// each_bound_trait_and_supertraits in type_contents correctly.
+
+use std::comm;
+
+trait Bar : Send { }
+trait Foo : Bar { }
+
+impl <T: Send> Foo for T { }
+impl <T: Send> Bar for T { }
+
+fn foo<T: Foo>(val: T, chan: comm::Chan<T>) {
+ chan.send(val);
+}
+
+fn main() {
+ let (p,c) = comm::stream();
+ foo(31337, c);
+ assert!(p.recv() == 31337);
+}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// xfail-fast
+
+// aux-build:trait_superkinds_in_metadata.rs
+
+// Tests "capabilities" granted by traits with super-builtin-kinds,
+// even when using them cross-crate.
+
+extern mod trait_superkinds_in_metadata;
+use trait_superkinds_in_metadata::{RequiresRequiresFreezeAndSend, RequiresFreeze};
+use std::comm;
+
+#[deriving(Eq)]
+struct X<T>(T);
+
+impl <T: Freeze> RequiresFreeze for X<T> { }
+impl <T: Freeze+Send> RequiresRequiresFreezeAndSend for X<T> { }
+
+fn foo<T: RequiresRequiresFreezeAndSend>(val: T, chan: comm::Chan<T>) {
+ chan.send(val);
+}
+
+fn main() {
+ let (p,c) = comm::stream();
+ foo(X(31337), c);
+ assert!(p.recv() == X(31337));
+}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Tests "capabilities" granted by traits that inherit from super-
+// builtin-kinds, e.g., if a trait requires Send to implement, then
+// at usage site of that trait, we know we have the Send capability.
+
+use std::comm;
+
+trait Foo : Send { }
+
+impl <T: Send> Foo for T { }
+
+fn foo<T: Foo>(val: T, chan: comm::Chan<T>) {
+ chan.send(val);
+}
+
+fn main() {
+ let (p,c) = comm::stream();
+ foo(31337, c);
+ assert!(p.recv() == 31337);
+}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// xfail-fast
+
+// aux-build:trait_superkinds_in_metadata.rs
+
+// Tests (correct) usage of trait super-builtin-kinds cross-crate.
+
+extern mod trait_superkinds_in_metadata;
+use trait_superkinds_in_metadata::{RequiresRequiresFreezeAndSend, RequiresFreeze};
+
+struct X<T>(T);
+
+impl <T:Freeze> RequiresFreeze for X<T> { }
+
+impl <T:Freeze+Send> RequiresRequiresFreezeAndSend for X<T> { }
+
+fn main() { }
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Tests that even when a type paramenter doesn't implement a required
+// super-builtin-kind of a trait, if the type parameter is never used,
+// the type can implement the trait anyway.
+
+trait Foo : Send { }
+
+struct X<T>(());
+
+impl <T> Foo for X<T> { }
+
+fn main() { }
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Tests the ability for the Self type in default methods to use
+// capabilities granted by builtin kinds as supertraits.
+
+use std::comm;
+
+trait Foo : Send {
+ fn foo(self, chan: comm::Chan<Self>) {
+ chan.send(self);
+ }
+}
+
+impl <T: Send> Foo for T { }
+
+fn main() {
+ let (p,c) = comm::stream();
+ 1193182.foo(c);
+ assert!(p.recv() == 1193182);
+}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Simple test case of implementing a trait with super-builtin-kinds.
+
+trait Foo : Send { }
+
+impl Foo for int { }
+
+fn main() { }
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Tests correct implementation of traits with super-builtin-kinds
+// using a bounded type parameter.
+
+trait Foo : Send { }
+
+impl <T: Send> Foo for T { }
+
+fn main() { }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::libc;
-
mod rustrt {
use std::libc;
}
pub fn main() {
- unsafe {
- let _foo = rustrt::rust_get_test_int;
- }
+ let _foo = rustrt::rust_get_test_int;
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::str;
-
mod libc {
+ use std::libc::{c_char, c_long, c_longlong};
+
#[abi = "cdecl"]
#[nolink]
extern {
- pub fn atol(x: *u8) -> int;
- pub fn atoll(x: *u8) -> i64;
+ pub fn atol(x: *c_char) -> c_long;
+ pub fn atoll(x: *c_char) -> c_longlong;
}
}
+#[fixed_stack_segment]
fn atol(s: ~str) -> int {
- s.with_c_str(|x| unsafe { libc::atol(x as *u8) })
+ s.with_c_str(|x| unsafe { libc::atol(x) as int })
}
+#[fixed_stack_segment]
fn atoll(s: ~str) -> i64 {
- s.with_c_str(|x| unsafe { libc::atoll(x as *u8) })
+ s.with_c_str(|x| unsafe { libc::atoll(x) as i64 })
}
pub fn main() {
- unsafe {
- assert_eq!(atol(~"1024") * 10, atol(~"10240"));
- assert!((atoll(~"11111111111111111") * 10i64)
- == atoll(~"111111111111111110"));
- }
+ assert_eq!(atol(~"1024") * 10, atol(~"10240"));
+ assert!((atoll(~"11111111111111111") * 10) == atoll(~"111111111111111110"));
}
// course preferable, as the value itself is
// irrelevant).
-use std::comm::*;
use std::task;
fn foo(x: ()) -> Port<()> {
pub fn main() {
//let bt0 = sys::rusti::frame_address(1u32);
//info!("%?", bt0);
- do cci_iter_lib::iter(~[1, 2, 3]) |i| {
+ do cci_iter_lib::iter([1, 2, 3]) |i| {
printf!("%d", *i);
//assert!(bt0 == sys::rusti::frame_address(2u32));
}
use std::task;
-fn child2(s: ~str) { }
+fn child2(_s: ~str) { }
pub fn main() {
- let x = task::spawn(|| child2(~"hi"));
+ let _x = task::spawn(|| child2(~"hi"));
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::uint;
-
trait noisy {
fn speak(&self) -> int;
}
fn annoy_neighbors(critter: @noisy) {
- for i in range(0u, 10) { critter.speak(); }
+ for _i in range(0u, 10) { critter.speak(); }
}
pub fn main() {
// xfail-fast
use std::cmp;
-use std::int;
-use std::uint;
enum cat_type { tuxedo, tabby, tortoiseshell }
extern mod cci_class_trait;
use cci_class_trait::animals::*;
-use std::uint;
-
struct cat {
priv meows: uint,
// xfail-fast
-use std::uint;
-
trait noisy {
fn speak(&mut self);
}
pub fn main() {
let mut nyan : cat = cat(52u, 99);
- let mut kitty = cat(1000u, 2);
+ let kitty = cat(1000u, 2);
assert_eq!(nyan.how_hungry, 99);
assert_eq!(kitty.how_hungry, 2);
nyan.speak();
pub fn main() {
let mut nyan: cat = cat(52u, 99);
- let mut kitty = cat(1000u, 2);
+ let kitty = cat(1000u, 2);
assert_eq!(nyan.how_hungry, 99);
assert_eq!(kitty.how_hungry, 2);
nyan.speak();
impl ToStr for cat {
fn to_str(&self) -> ~str {
- // FIXME #5384: this unsafe block is to work around purity
- unsafe {
- self.name.clone()
- }
+ self.name.clone()
}
}
}
pub fn main() {
- let mut nyan : @ToStr = @cat(0u, 2, ~"nyan") as @ToStr;
+ let nyan : @ToStr = @cat(0u, 2, ~"nyan") as @ToStr;
print_out(nyan, ~"nyan");
}
}
pub fn main() {
- let nyan = cat(~"nyan");
+ let _nyan = cat(~"nyan");
}
pub fn main() {
- let mut _nyan : cat<int> = cat::<int>(52u, 99);
+ let _nyan : cat<int> = cat::<int>(52u, 99);
// let mut kitty = cat(1000u, 2);
}
extern mod cci_class_4;
use cci_class_4::kitties::*;
-use std::uint;
-
pub fn main() {
let mut nyan = cat(0u, 2, ~"nyan");
nyan.eat();
pub fn main() {
let mut nyan : cat = cat(52u, 99);
- let mut kitty = cat(1000u, 2);
+ let kitty = cat(1000u, 2);
assert_eq!(nyan.how_hungry, 99);
assert_eq!(kitty.how_hungry, 2);
nyan.speak();
}
pub fn main() {
- let mut nyan : cat = cat(52u, 99);
- let mut kitty = cat(1000u, 2);
+ let nyan : cat = cat(52u, 99);
+ let kitty = cat(1000u, 2);
assert_eq!(nyan.how_hungry, 99);
assert_eq!(kitty.how_hungry, 2);
}
// xfail-win32
-use std::result;
use std::task;
fn adder(x: @int, y: @int) -> int { return *x + *y; }
}
pub fn main() {
- let mut lincoln = SpeechMaker {speeches: 22};
+ let lincoln = SpeechMaker {speeches: 22};
assert_eq!(foo(&const lincoln), 55);
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::comm::*;
use std::task;
pub fn main() {
let (p, ch) = stream();
- let t = task::spawn(|| child(&ch) );
+ let _t = task::spawn(|| child(&ch) );
let y = p.recv();
error!("received");
error!(y);
fn nothing() { }
-fn putstr(s: ~str) { }
+fn putstr(_s: ~str) { }
-fn putint(i: int) {
+fn putint(_i: int) {
let mut i: int = 33;
while i < 36 { putstr(~"hi"); i = i + 1; }
}
// Exercise some of the configured items in ways that wouldn't be possible
// if they had the bogus definition
assert!((b));
- let x: t = true;
- let y: tg = bar;
+ let _x: t = true;
+ let _y: tg = bar;
test_in_fn_ctxt();
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::io;
-
static x : [int, ..4] = [1,2,3,4];
static p : int = x[2];
static y : &'static [int] = &[1,2,3,4];
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::io;
-
struct Pair<'self> { a: int, b: &'self int }
static x: &'static int = &10;
// except according to those terms.
use std::cmp;
-use std::io;
struct foo { a: int, b: int, c: int }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::io;
-
static x : [int, ..4] = [1,2,3,4];
static y : &'static [int] = &[1,2,3,4];
// instead of in std.
use std::libc;
-use std::os;
use std::run::*;
use std::run;
use std::str;
// except according to those terms.
pub fn main() {
- let x = ~[
+ let _x = ~[
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-pub fn main() { let x: @int = @10; let y: int = *x; }
+pub fn main() {
+ let x: @int = @10;
+ let _y: int = *x;
+}
}
pub fn main() {
- use std::hash::{Hash, HashUtil}; // necessary for IterBytes check
+ use std::hash::HashUtil; // necessary for IterBytes check
let a = Foo {bar: 4, baz: -3};
}
pub fn main() {
- use std::hash::{Hash, HashUtil}; // necessary for IterBytes check
+ use std::hash::HashUtil; // necessary for IterBytes check
let a = Foo {bar: 4, baz: -3};
// Just testing that fail!() type checks in statement or expr
+#[allow(unreachable_code)];
+
fn f() {
fail!();
- let x: int = fail!();
+ let _x: int = fail!();
}
pub fn main() {
// no-reformat
// Testing various forms of `do` with empty arg lists
-fn f(f: &fn() -> bool) -> bool {
+fn f(_f: &fn() -> bool) -> bool {
true
}
// Testing that we can drop the || in do exprs
-fn f(f: @fn() -> bool) -> bool { true }
+fn f(_f: @fn() -> bool) -> bool { true }
-fn d(f: @fn()) { }
+fn d(_f: @fn()) { }
pub fn main() {
do d { }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn f(f: &fn()) {
+fn f(_f: &fn()) {
}
fn g() {
bar: int
}
-fn g(i: int) { }
+fn g(_i: int) { }
fn f(foo: @@Quux) { g(foo.bar); }
pub fn main() { }
enum t { foo(@int), }
-pub fn main() { let tt = foo(@10); match tt { foo(z) => { } } }
+pub fn main() {
+ let tt = foo(@10);
+ match tt { foo(_z) => { } }
+}
// -*- rust -*-
-fn f() -> int { if true { let s: ~str = ~"should not leak"; return 1; } return 0; }
+fn f() -> int {
+ if true {
+ let _s: ~str = ~"should not leak";
+ return 1;
+ }
+ return 0;
+}
pub fn main() { f(); }
}
pub fn main() {
- let x = S { x: 1 };
+ let _x = S { x: 1 };
}
}
pub fn main() {
- let x: Foo = Foo { x: 3 };
+ let _x: Foo = Foo { x: 3 };
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#[allow(unused_mut)];
-
-pub fn main() { let mut v: ~[int] = ~[]; }
+pub fn main() { let mut _v: ~[int] = ~[]; }
fn addr_of<T>(ptr: &T) -> uint {
let ptr = ptr::to_unsafe_ptr(ptr);
- unsafe { ptr as uint }
+ ptr as uint
}
fn is_aligned<T>(ptr: &T) -> bool {
test_color(imaginary, -1, ~"imaginary");
}
-fn test_color(color: color, val: int, name: ~str) {
+fn test_color(color: color, val: int, _name: ~str) {
assert!(color as int == val);
assert!(color as float == val as float);
}
}
pub fn main() {
- let x = a::Bar;
+ let _x = a::Bar;
}
+#[allow(dead_assignment)];
+#[allow(unused_variable)];
+
enum Animal {
Dog (~str, float),
Cat { name: ~str, weight: float }
let mut a: Animal = Dog(~"Cocoa", 37.2);
a = Cat{ name: ~"Spotty", weight: 2.7 };
// permuting the fields should work too
- let c = Cat { weight: 3.1, name: ~"Spreckles" };
+ let _c = Cat { weight: 3.1, name: ~"Spreckles" };
}
static BAR2:uint = BAR;
fn main() {
- let v = [0, .. Bunny as uint];
- let v = [0, .. BAR];
- let v = [0, .. BAR2];
+ let _v = [0, .. Bunny as uint];
+ let _v = [0, .. BAR];
+ let _v = [0, .. BAR2];
static BAR3:uint = BAR2;
- let v = [0, .. BAR3];
-}
\ No newline at end of file
+ let _v = [0, .. BAR3];
+}
pub fn main() {
let x = &"hello";
let v = &"hello";
- let mut y : &str = &"there";
+ let y : &str = &"there";
info!(x);
info!(y);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#[allow(dead_assignment)];
+
pub fn main() {
let x : ~str = ~"hello";
let _y : ~str = ~"there";
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#[allow(dead_assignment)];
+
pub fn main() {
let x : [@int, ..5] = [@1,@2,@3,@4,@5];
let _y : [@int, ..5] = [@1,@2,@3,@4,@5];
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#[allow(dead_assignment)];
+
pub fn main() {
let x : &[int] = &[1,2,3,4,5];
let mut z = &[1,2,3,4,5];
use std::os;
pub fn main() {
- assert_eq!(os::getenv(~"TEST_EXEC_ENV"), Some(~"22"));
+ assert_eq!(os::getenv("TEST_EXEC_ENV"), Some(~"22"));
}
pub fn f() -> t { return t1; }
}
-pub fn main() { let v: foo::t = foo::f(); }
+pub fn main() { let _v: foo::t = foo::f(); }
pub static a : int = 10;
}
pub fn zum() {
- let b = a;
+ let _b = a;
}
}
pub enum t { t1, }
}
-pub fn main() { let v = foo::t1; }
+pub fn main() { let _v = foo::t1; }
type t = @fn() -> int;
fn ten() -> int { return 10; }
let rs: t = { ten };
- //assert!((rs() == 10));
+ assert!((rs() == 10));
}
pub fn main() { test_fn(); }
// except according to those terms.
// Regression test for issue #388
-pub fn main() { let x = { { @10 } }; }
+pub fn main() { let _x = { { @10 } }; }
// values from the else if branch
pub fn main() {
let y: @uint = @10u;
- let x = if false { y } else if true { y } else { y };
+ let _x = if false { y } else if true { y } else { y };
assert_eq!(*y, 10u);
}
// except according to those terms.
// Regression test for issue #388
-pub fn main() { let x = if false { @0u } else if true { @10u } else { @0u }; }
+pub fn main() {
+ let _x = if false {
+ @0u
+ } else if true {
+ @10u
+ } else {
+ @0u
+ };
+}
// Issue #521
-fn f() { let x = match true { true => { 10 } false => { return } }; }
+fn f() {
+ let _x = match true {
+ true => { 10 }
+ false => { return }
+ };
+}
pub fn main() { }
// When all branches of an if expression result in fail, the entire if
// expression results in fail.
-pub fn main() { let x = if true { 10 } else { if true { fail!() } else { fail!() } }; }
+pub fn main() {
+ let _x = if true {
+ 10
+ } else {
+ if true { fail!() } else { fail!() }
+ };
+}
// When all branches of an match expression result in fail, the entire
// match expression results in fail.
pub fn main() {
- let x =
+ let _x =
match true {
true => { 10 }
false => { match true { true => { fail!() } false => { fail!() } } }
}
fn test_inferrence() {
- let mut rs = match true { true => { true } false => { false } };
+ let rs = match true { true => { true } false => { false } };
assert!((rs));
}
}
}
+#[fixed_stack_segment]
fn count(n: uint) -> uint {
unsafe {
info!("n = %?", n);
}
}
+#[fixed_stack_segment] #[inline(never)]
fn count(n: uint) -> uint {
unsafe {
info!("n = %?", n);
}
}
+#[fixed_stack_segment] #[inline(never)]
fn count(n: uint) -> uint {
unsafe {
info!("n = %?", n);
}
}
+#[fixed_stack_segment] #[inline(never)]
fn fact(n: uint) -> uint {
unsafe {
info!("n = %?", n);
extern mod externcallback(vers = "0.1");
+#[fixed_stack_segment] #[inline(never)]
fn fact(n: uint) -> uint {
unsafe {
info!("n = %?", n);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#[allow(unused_imports)];
+
extern mod extra;
use extra::json::Object;
pub fn rust_dbg_extern_identity_TwoU32s(v: TwoU32s) -> TwoU32s;
}
+#[fixed_stack_segment] #[inline(never)]
pub fn main() {
unsafe {
let x = TwoU32s {one: 22, two: 23};
pub fn rust_dbg_extern_identity_TwoU64s(u: TwoU64s) -> TwoU64s;
}
+#[fixed_stack_segment] #[inline(never)]
pub fn main() {
unsafe {
let x = TwoU64s {one: 22, two: 23};
pub fn rust_dbg_extern_identity_TwoU64s(v: TwoU64s) -> TwoU64s;
}
+#[fixed_stack_segment] #[inline(never)]
pub fn main() {
unsafe {
let x = TwoU64s {one: 22, two: 23};
pub fn rust_dbg_extern_identity_u8(v: u8) -> u8;
}
+#[fixed_stack_segment] #[inline(never)]
pub fn main() {
unsafe {
assert_eq!(22_u8, rust_dbg_extern_identity_u8(22_u8));
pub fn rust_dbg_extern_identity_double(v: f64) -> f64;
}
+#[fixed_stack_segment] #[inline(never)]
pub fn main() {
unsafe {
assert_eq!(22.0_f64, rust_dbg_extern_identity_double(22.0_f64));
pub fn rust_dbg_extern_identity_u32(v: u32) -> u32;
}
+#[fixed_stack_segment] #[inline(never)]
pub fn main() {
unsafe {
assert_eq!(22_u32, rust_dbg_extern_identity_u32(22_u32));
pub fn rust_dbg_extern_identity_u64(v: u64) -> u64;
}
+#[fixed_stack_segment] #[inline(never)]
pub fn main() {
unsafe {
assert_eq!(22_u64, rust_dbg_extern_identity_u64(22_u64));
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// xfail-win32 #5745
-// xfail-macos Broken on mac i686
-
struct TwoU16s {
one: u16, two: u16
}
pub fn rust_dbg_extern_return_TwoU16s() -> TwoU16s;
}
+#[fixed_stack_segment] #[inline(never)]
pub fn main() {
unsafe {
let y = rust_dbg_extern_return_TwoU16s();
pub fn rust_dbg_extern_return_TwoU32s() -> TwoU32s;
}
+#[fixed_stack_segment] #[inline(never)]
pub fn main() {
unsafe {
let y = rust_dbg_extern_return_TwoU32s();
pub fn rust_dbg_extern_return_TwoU64s() -> TwoU64s;
}
+#[fixed_stack_segment] #[inline(never)]
pub fn main() {
unsafe {
let y = rust_dbg_extern_return_TwoU64s();
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// xfail-win32 #5745
-// xfail-macos Broken on mac i686
-
struct TwoU8s {
one: u8, two: u8
}
pub fn rust_dbg_extern_return_TwoU8s() -> TwoU8s;
}
+#[fixed_stack_segment] #[inline(never)]
pub fn main() {
unsafe {
let y = rust_dbg_extern_return_TwoU8s();
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// This creates a bunch of yielding tasks that run concurrently
+// This creates a bunch of descheduling tasks that run concurrently
// while holding onto C stacks
use std::libc;
if data == 1u {
data
} else {
- task::yield();
+ task::deschedule();
count(data - 1u) + count(data - 1u)
}
}
+#[fixed_stack_segment] #[inline(never)]
fn count(n: uint) -> uint {
unsafe {
rustrt::rust_dbg_call(cb, n)
}
}
+#[fixed_stack_segment] #[inline(never)]
fn count(n: uint) -> uint {
unsafe {
- task::yield();
+ task::deschedule();
rustrt::rust_dbg_call(cb, n)
}
}
pub fn main() {
fn f() {}
- let i: r = r {field: f};
+ let _i: r = r {field: f};
}
// -*- rust -*-
-fn foo(f: extern fn(int) -> int) { }
+fn foo(_f: extern fn(int) -> int) { }
fn id(x: int) -> int { return x; }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#[allow(unused_variable)];
+
pub fn main() {
// We should be able to type infer inside of @fns.
- let f = || {
+ let _f = || {
let i = 10;
};
}
use std::libc;
use std::unstable::run_in_bare_thread;
-extern {
- pub fn rust_dbg_call(cb: *u8, data: libc::uintptr_t) -> libc::uintptr_t;
-}
+externfn!(fn rust_dbg_call(cb: *u8, data: libc::uintptr_t) -> libc::uintptr_t)
pub fn main() {
unsafe {
do run_in_bare_thread() {
- unsafe {
- let i = &100;
- rust_dbg_call(callback, cast::transmute(i));
- }
+ let i = &100;
+ rust_dbg_call(callback, cast::transmute(i));
}
}
}
}
}
+#[fixed_stack_segment] #[inline(never)]
pub fn main() {
unsafe {
rustrt1::rust_get_test_int();
extern mod extra;
-use std::libc;
-use std::str;
-use std::vec;
-
mod libc {
+ use std::libc::{c_char, size_t};
+
#[nolink]
#[abi = "cdecl"]
extern {
#[link_name = "strlen"]
- pub fn my_strlen(str: *u8) -> uint;
+ pub fn my_strlen(str: *c_char) -> size_t;
}
}
+#[fixed_stack_segment] #[inline(never)]
fn strlen(str: ~str) -> uint {
- unsafe {
- // C string is terminated with a zero
- do str.with_c_str |buf| {
- libc::my_strlen(buf as *u8)
+ // C string is terminated with a zero
+ do str.with_c_str |buf| {
+ unsafe {
+ libc::my_strlen(buf) as uint
}
}
}
// except according to those terms.
mod foo {
+ use std::libc::c_int;
+
#[nolink]
extern {
- pub static errno: int;
+ pub static errno: c_int;
}
}
}
}
+#[fixed_stack_segment] #[inline(never)]
pub fn main() {
unsafe {
rustrt::rust_get_test_int();
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// xfail-win32
// Passing enums by value
pub enum void { }
}
mod libc {
+ use std::libc::{c_int, c_void, size_t, ssize_t};
+
#[abi = "cdecl"]
#[nolink]
extern {
- pub fn write(fd: int, buf: *u8, count: ::std::libc::size_t)
- -> ::std::libc::ssize_t;
+ pub fn write(fd: c_int, buf: *c_void, count: size_t) -> ssize_t;
}
}
--- /dev/null
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+struct Foo {
+ x: int,
+ y: int
+}
+
+pub fn main() {
+ let a = Foo { x: 1, y: 2 };
+ let c = Foo { x: 4, .. a};
+ printfln!(c);
+}
+++ /dev/null
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-struct Foo {
- x: int,
- y: int
-}
-
-pub fn main() {
- let a = Foo { x: 1, y: 2 };
- let c = Foo { x: 4, .. a};
- printfln!(c);
-}
struct Pair { x: @int, y: @int }
-fn f<T>(t: T) { let t1: T = t; }
+fn f<T>(t: T) { let _t1: T = t; }
pub fn main() { let x = Pair {x: @10, y: @12}; f(x); }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-
-
+#[allow(dead_assignment)];
// -*- rust -*-
fn id<T>(x: T) -> T { return x; }
enum wrapper<T> { wrapped(T), }
-pub fn main() { let w = wrapped(~[1, 2, 3, 4, 5]); }
+pub fn main() { let _w = wrapped(~[1, 2, 3, 4, 5]); }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn f<T>(v: @T) { }
+fn f<T>(_v: @T) { }
pub fn main() { f(@~[1, 2, 3, 4, 5]); }
enum list<T> { cons(@T, @list<T>), nil, }
pub fn main() {
- let a: list<int> =
+ let _a: list<int> =
cons::<int>(@10, @cons::<int>(@12, @cons::<int>(@13, @nil::<int>)));
}
// This causes memory corruption in stage0.
enum thing<K> { some(K), }
-pub fn main() { let x = some(~"hi"); }
+pub fn main() { let _x = some(~"hi"); }
enum clam<T> { a(T), }
-pub fn main() { let c = a(3); }
+pub fn main() { let _c = a(3); }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-
+#[allow(dead_assignment)];
enum foo<T> { arm(T), }
fn altfoo<T>(f: foo<T>) {
let mut hit = false;
- match f { arm::<T>(x) => { info!("in arm"); hit = true; } }
+ match f { arm::<T>(_x) => { info!("in arm"); hit = true; } }
assert!((hit));
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-
+#[allow(dead_assignment)];
+#[allow(unused_variable)];
enum option<T> { some(@T), none, }
-pub fn main() { let mut a: option<int> = some::<int>(@10); a = none::<int>; }
+pub fn main() {
+ let mut a: option<int> = some::<int>(@10);
+ a = none::<int>;
+}
type Bar<T> = Foo<T>;
-fn takebar<T>(b: Bar<T>) { }
+fn takebar<T>(_b: Bar<T>) { }
pub fn main() { }
pub fn main() {
let args = ~[];
- let opts = ~[optopt(~"b")];
+ let opts = ~[optopt("b")];
match getopts(args, opts) {
Ok(ref m) =>
match Pair {x: 10, y: 20} {
x if x.x < 5 && x.y < 5 => { 1 }
Pair {x: x, y: y} if x == 10 && y == 20 => { 2 }
- Pair {x: x, y: y} => { 3 }
+ Pair {x: _x, y: _y} => { 3 }
};
assert_eq!(b, 2);
}
)
pub fn main() {
- let page = html! (
+ let _page = html! (
<html>
<head><title>This is the title.</title></head>
<body>
macro_rules! t(($a:expr, $b:expr) => { assert_eq!($a, $b.to_owned()) })
// Make sure there's a poly formatter that takes anything
- t!(ifmt!("{}", 1), "1");
- t!(ifmt!("{}", A), "{}");
- t!(ifmt!("{}", ()), "()");
- t!(ifmt!("{}", @(~1, "foo")), "@(~1, \"foo\")");
+ t!(ifmt!("{:?}", 1), "1");
+ t!(ifmt!("{:?}", A), "{}");
+ t!(ifmt!("{:?}", ()), "()");
+ t!(ifmt!("{:?}", @(~1, "foo")), "@(~1, \"foo\")");
// Various edge cases without formats
t!(ifmt!(""), "");
t!(ifmt!("hello"), "hello");
t!(ifmt!("hello \\{"), "hello {");
+ // default formatters should work
+ t!(ifmt!("{}", 1i), "1");
+ t!(ifmt!("{}", 1i8), "1");
+ t!(ifmt!("{}", 1i16), "1");
+ t!(ifmt!("{}", 1i32), "1");
+ t!(ifmt!("{}", 1i64), "1");
+ t!(ifmt!("{}", 1u), "1");
+ t!(ifmt!("{}", 1u8), "1");
+ t!(ifmt!("{}", 1u16), "1");
+ t!(ifmt!("{}", 1u32), "1");
+ t!(ifmt!("{}", 1u64), "1");
+ t!(ifmt!("{}", 1.0f), "1");
+ t!(ifmt!("{}", 1.0f32), "1");
+ t!(ifmt!("{}", 1.0f64), "1");
+ t!(ifmt!("{}", "a"), "a");
+ t!(ifmt!("{}", ~"a"), "a");
+ t!(ifmt!("{}", @"a"), "a");
+ t!(ifmt!("{}", false), "false");
+ t!(ifmt!("{}", 'a'), "a");
+
// At least exercise all the formats
t!(ifmt!("{:b}", true), "true");
t!(ifmt!("{:c}", '☃'), "☃");
t!(ifmt!("{:x}", 10u), "a");
t!(ifmt!("{:X}", 10u), "A");
t!(ifmt!("{:s}", "foo"), "foo");
+ t!(ifmt!("{:s}", ~"foo"), "foo");
+ t!(ifmt!("{:s}", @"foo"), "foo");
t!(ifmt!("{:p}", 0x1234 as *int), "0x1234");
t!(ifmt!("{:p}", 0x1234 as *mut int), "0x1234");
t!(ifmt!("{:d}", A), "aloha");
t!(ifmt!("{foo} {bar}", foo=0, bar=1), "0 1");
t!(ifmt!("{foo} {1} {bar} {0}", 0, 1, foo=2, bar=3), "2 1 3 0");
t!(ifmt!("{} {0:s}", "a"), "a a");
- t!(ifmt!("{} {0}", "a"), "\"a\" \"a\"");
+ t!(ifmt!("{} {0}", "a"), "a a");
// Methods should probably work
t!(ifmt!("{0, plural, =1{a#} =2{b#} zero{c#} other{d#}}", 0u), "c0");
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#[allow(dead_assignment)];
extern mod extra;
use std::vec::*;
pub fn main() {
let mut v = from_elem(0u, 0);
- v = append(v, ~[4, 2]);
+ v = append(v, [4, 2]);
assert_eq!(from_fn(2, |i| 2*(i+1)), ~[2, 4]);
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#[allow(unused_imports)];
use baz::zed;
use baz::zed::bar;
pub fn bar() { info!("bar"); }
}
-pub fn main() { let zed = 42; bar(); }
+pub fn main() { let _zed = 42; bar(); }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#[allow(unused_imports)];
+
use foo::zed;
use bar::baz;
+
mod foo {
pub mod zed {
pub fn baz() { info!("baz"); }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#[allow(unused_imports)];
+
use foo::zed;
use bar::baz;
+
mod foo {
pub mod zed {
pub fn baz() { info!("baz"); }
#[unsafe_destructor]
impl Drop for r {
fn drop(&self) {
- unsafe {
- *(self.i) = *(self.i) + 1;
- }
+ *(self.i) = *(self.i) + 1;
}
}
fn test_box() {
let i = @mut 0;
{
- let a = @r(i);
+ let _a = @r(i);
}
assert_eq!(*i, 1);
}
fn test_rec() {
let i = @mut 0;
{
- let a = Box {x: r(i)};
+ let _a = Box {x: r(i)};
}
assert_eq!(*i, 1);
}
let i = @mut 0;
{
- let a = t0(r(i));
+ let _a = t0(r(i));
}
assert_eq!(*i, 1);
}
fn test_tup() {
let i = @mut 0;
{
- let a = (r(i), 0);
+ let _a = (r(i), 0);
}
assert_eq!(*i, 1);
}
fn test_unique() {
let i = @mut 0;
{
- let a = ~r(i);
+ let _a = ~r(i);
}
assert_eq!(*i, 1);
}
fn test_box_rec() {
let i = @mut 0;
{
- let a = @Box {
+ let _a = @Box {
x: r(i)
};
}
struct X { x: uint, nxt: *foo }
pub fn main() {
- let x = foo(X {x: 0, nxt: ptr::null()});
+ let _x = foo(X {x: 0, nxt: ptr::null()});
}
// -*- rust -*-
-pub fn main() { let x: int = 10; }
+pub fn main() { let _x: int = 10; }
use cci_intrinsic::atomic_xchg;
pub fn main() {
- unsafe {
- let mut x = 1;
- atomic_xchg(&mut x, 5);
- assert_eq!(x, 5);
- }
+ let mut x = 1;
+ atomic_xchg(&mut x, 5);
+ assert_eq!(x, 5);
}
pub fn main() {
unsafe {
- let mut x = @1;
+ let x = @1;
let mut y = @2;
rusti::move_val(&mut y, x);
assert_eq!(*y, 1);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::f64;
-
mod rusti {
#[abi = "rust-intrinsic"]
extern "rust-intrinsic" {
extern mod foreign_lib;
+#[fixed_stack_segment] #[inline(never)]
pub fn main() {
unsafe {
- let foo = foreign_lib::rustrt::rust_get_test_int();
+ let _foo = foreign_lib::rustrt::rust_get_test_int();
}
}
// except according to those terms.
use std::hashmap::HashMap;
-use std::str;
pub fn main() {
let mut m = HashMap::new();
use std::cast;
use std::libc::{c_double, c_int};
-use std::f64::*;
fn to_c_int(v: &mut int) -> &mut c_int {
unsafe {
}
}
+#[fixed_stack_segment] #[inline(never)]
fn lgamma(n: c_double, value: &mut int) -> c_double {
unsafe {
return m::lgamma(n, to_c_int(value));
}
impl<A> clam<A> for foo<A> {
- fn chowder(&self, y: A) {
+ fn chowder(&self, _y: A) {
}
}
}
impl<A> foo<A> {
- pub fn bar<B,C:clam<A>>(&self, c: C) -> B {
+ pub fn bar<B,C:clam<A>>(&self, _c: C) -> B {
fail!();
}
}
struct foo(int);
impl foo {
- pub fn bar<B,C:clam<B>>(&self, c: C) -> B { fail!(); }
+ pub fn bar<B,C:clam<B>>(&self, _c: C) -> B { fail!(); }
}
pub fn main() { }
// except according to those terms.
pub fn main() {
- let foo = 100;
+ let _foo = 100;
static quux: int = 5;
enum Stuff {
}
impl<T> c1<T> {
- pub fn f1(&self, x: int) {
+ pub fn f1(&self, _x: int) {
}
}
}
impl<T> c1<T> {
- pub fn f2(&self, x: int) {
+ pub fn f2(&self, _x: int) {
}
}
}
impl<T> c1<T> {
- pub fn f1(&self, x: T) {}
+ pub fn f1(&self, _x: T) {}
}
fn c1<T>(x: T) -> c1<T> {
}
impl<T> c1<T> {
- pub fn f2(&self, x: T) {}
+ pub fn f2(&self, _x: T) {}
}
g: 0,
};
- let y = Pair {
+ let _y = Pair {
f: 1,
g: 1,
.. x
};
- let z = Pair {
+ let _z = Pair {
f: 1,
.. x
};
// xfail-fast
// aux-build:issue-2526.rs
+#[allow(unused_imports)];
+
extern mod issue_2526;
use issue_2526::*;
}
pub fn main() {
- let mut kitty = cat();
+ let kitty = cat();
nyan(kitty, KittyInfo {kitty: kitty});
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::util;
-
pub type Task = int;
// tjc: I don't know why
// We should consider moving this to ::std::unsafe, although I
// suspect graydon would want us to use void pointers instead.
pub unsafe fn uniquify<T>(x: *T) -> ~T {
- unsafe { cast::transmute(x) }
+ cast::transmute(x)
}
pub fn swap_state_acq(dst: &mut state, src: state) -> state {
}
pub fn send<T:Send>(mut p: send_packet<T>, payload: T) {
- let mut p = p.unwrap();
+ let p = p.unwrap();
let mut p = unsafe { uniquify(p) };
assert!((*p).payload.is_none());
(*p).payload = Some(payload);
}
pub fn recv<T:Send>(mut p: recv_packet<T>) -> Option<T> {
- let mut p = p.unwrap();
+ let p = p.unwrap();
let mut p = unsafe { uniquify(p) };
loop {
let old_state = swap_state_acq(&mut (*p).state,
blocked);
match old_state {
- empty | blocked => { task::yield(); }
+ empty | blocked => { task::deschedule(); }
full => {
let payload = util::replace(&mut p.payload, None);
return Some(payload.unwrap())
}
}
- pub fn sender_terminate<T:Send>(mut p: *packet<T>) {
+ pub fn sender_terminate<T:Send>(p: *packet<T>) {
let mut p = unsafe { uniquify(p) };
match swap_state_rel(&mut (*p).state, terminated) {
empty | blocked => {
}
}
- pub fn receiver_terminate<T:Send>(mut p: *packet<T>) {
+ pub fn receiver_terminate<T:Send>(p: *packet<T>) {
let mut p = unsafe { uniquify(p) };
match swap_state_rel(&mut (*p).state, terminated) {
empty => {
pub mod pingpong {
use std::cast;
- use std::ptr;
- use std::util;
pub struct ping(::pipes::send_packet<pong>);
pub struct pong(::pipes::send_packet<ping>);
pub fn liberate_ping(p: ping) -> ::pipes::send_packet<pong> {
unsafe {
- let addr : *::pipes::send_packet<pong> = match &p {
+ let
_addr : *::pipes::send_packet<pong> = match &p {
&ping(ref x) => { cast::transmute(x) }
};
fail!()
pub fn liberate_pong(p: pong) -> ::pipes::send_packet<ping> {
unsafe {
- let addr : *::pipes::send_packet<ping> = match &p {
+ let
_addr : *::pipes::send_packet<ping> = match &p {
&pong(ref x) => { cast::transmute(x) }
};
fail!()
}
pub mod client {
- use std::option;
use pingpong;
pub type ping = ::pipes::send_packet<pingpong::ping>;
}
}
-fn add_interface(store: int, managed_ip: ~str, data: extra::json::Json) -> (~str, object)
+fn add_interface(_store: int, managed_ip: ~str, data: extra::json::Json) -> (~str, object)
{
match &data {
&extra::json::Object(ref interface) => {
use std::io::ReaderUtil;
use std::io;
-use std::str;
use std::to_str;
enum square {
extern mod extra;
-use std::io;
use std::vec;
trait methods {
pub fn main() {
let fd: libc::c_int = 1 as libc::c_int;
- let sock = @socket::socket_handle(fd);
+ let _sock = @socket::socket_handle(fd);
}
pub fn main() {
let x = 1;
let y: @fn() -> int = || x;
- let z = y();
+ let _z = y();
}
// Extern mod controls linkage. Use controls the visibility of names to modules that are
// already linked in. Using WriterUtil allows us to use the write_line method.
-use std::int;
use std::io::WriterUtil;
use std::io;
use std::str;
fn AsciiArt(width: uint, height: uint, fill: char) -> AsciiArt {
// Use an anonymous function to build a vector of vectors containing
// blank characters for each position in our canvas.
- let mut lines = do vec::build_sized(height) |push| {
+ let lines = do vec::build_sized(height) |push| {
do height.times {
push(vec::from_elem(width, '.'));
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#[allow(unnecessary_allocation)];
+
// rustc --test match_borrowed_str.rs.rs && ./match_borrowed_str.rs
extern mod extra;
pub fn main()
{
assert!(compare("foo", "foo"));
+ assert!(compare(~"foo", ~"foo"));
assert!(compare(@"foo", @"foo"));
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::io;
-
struct Vec2 {
x: float,
y: float
}
pub fn main() {
- let mut x = @mut Foo { x: 3 };
+ let x = @mut Foo { x: 3 };
// Neither of the next two lines should cause an error
let _ = x.stuff();
x.stuff();
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-pub fn main()
-{
+#[allow(path_statement)];
+
+pub fn main() {
let y = ~1;
y;
}
// except according to those terms.
pub fn main() {
- let id: &Mat2<float> = &Matrix::identity();
+ let _id: &Mat2<float> = &Matrix::identity();
}
pub trait Index<Index,Result> { }
// except according to those terms.
pub fn main() {
- let foo = [0, ..2*4];
+ let _foo = [0, ..2*4];
}
let x = os::args();
for arg in x.iter() {
match arg.clone() {
- s => { }
+ _s => { }
}
}
}
impl Drop for NonCopyable {
fn drop(&self) {
let p = **self;
- let v = unsafe { transmute::<*c_void, ~int>(p) };
+ let _v = unsafe { transmute::<*c_void, ~int>(p) };
}
}
fn main() {
let t = ~0;
let p = unsafe { transmute::<~int, *c_void>(t) };
- let z = NonCopyable(p);
+ let _z = NonCopyable(p);
}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn make_adder(x: int) -> @fn(int) -> int { |y| x + y }
+pub fn main() { }
}
fn main() {
- let mut sched = Scheduler::new(~UvEventLoop::new() as ~EventLoop);
+ let _sched = Scheduler::new(~UvEventLoop::new() as ~EventLoop);
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#[allow(dead_assignment)];
+
fn main() {
let s: ~str = ~"foobar";
let mut t: &str = s;
-fn foo<T: ::std::cmp::Eq>(t: T) { }
+fn foo<T: ::std::cmp::Eq>(_t: T) { }
fn main() { }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#[allow(unreachable_code)];
+
use std::io;
fn main() {
}
fn check(a: @Foo) {
- let mut _ic = Bar{ b: a, a: ~None };
+ let _ic = Bar{ b: a, a: ~None };
}
pub fn main(){}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// xfail-test
-
use std::io;
struct T (&'static [int]);
static t : T = T (&'static [5, 4, 3]);
fn main () {
assert_eq!(t[0], 5);
-}
\ No newline at end of file
+}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#[allow(unused_mut)];
+
pub fn main() {
let mut your_favorite_numbers = @[1,2,3];
let mut my_favorite_numbers = @[4,5,6];
pub fn main() {
match A(~Struct as ~Foo) {
- A(a) => 0,
+ A(_a) => 0,
};
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn foo(~(x, y): ~(int, int)) {}
+fn foo(~(_x, _y): ~(int, int)) {}
pub fn main() {}
#[unsafe_destructor]
impl Drop for r {
fn drop(&self) {
- unsafe {
- *(self.b) += 1;
- }
+ *(self.b) += 1;
}
}
pub fn main() {
let b = @mut 0;
{
- let p = Some(r(b));
+ let _p = Some(r(b));
}
assert_eq!(*b, 1);
fn test_heap_log() { let s = ~"a big ol' string"; info!(s); }
fn test_stack_add() {
- assert_eq!(~"a" + ~"b", ~"ab");
+ assert_eq!(~"a" + "b", ~"ab");
let s: ~str = ~"a";
assert_eq!(s + s, ~"aa");
- assert_eq!(~"" + ~"", ~"");
+ assert_eq!(~"" + "", ~"");
}
-fn test_stack_heap_add() { assert!((~"a" + ~"bracadabra" == ~"abracadabra")); }
+fn test_stack_heap_add() { assert!((~"a" + "bracadabra" == ~"abracadabra")); }
fn test_heap_add() {
- assert_eq!(~"this should" + ~" totally work", ~"this should totally work");
+ assert_eq!(~"this should" + " totally work", ~"this should totally work");
}
fn test_append() {
let mut s = ~"";
- s.push_str(~"a");
+ s.push_str("a");
assert_eq!(s, ~"a");
let mut s = ~"a";
- s.push_str(~"b");
+ s.push_str("b");
info!(s.clone());
assert_eq!(s, ~"ab");
let mut s = ~"c";
- s.push_str(~"offee");
+ s.push_str("offee");
assert!(s == ~"coffee");
- s.push_str(~"&tea");
+ s.push_str("&tea");
assert!(s == ~"coffee&tea");
}
extern mod extra;
pub fn f() {
- fmt!("test%s", ~"s");
+ fmt!("test%s", "s");
#[attr = "val"]
fn g() { }
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn f(a: ~[int]) { }
+fn f(_a: ~[int]) { }
pub fn main() { f(~[1, 2, 3, 4, 5]); }
-use std::comm::*;
use std::task;
fn producer(c: &Chan<~[u8]>) {
pub fn main() {
let (p, ch) = stream::<~[u8]>();
- let prod = task::spawn(|| producer(&ch) );
+ let _prod = task::spawn(|| producer(&ch) );
- let data: ~[u8] = p.recv();
+ let _data: ~[u8] = p.recv();
}
pub fn main() {
let e = @mut Refs{refs: ~[], n: 0};
- let f: @fn() = || error!(e.n);
+ let _f: @fn() = || error!(e.n);
e.refs.push(1);
}
k: int,
l: int}
fn f() {
- let foo: Large =
+ let _foo: Large =
Large {a: 0,
b: 0,
c: 0,
-fn leaky<T>(t: T) { }
+fn leaky<T>(_t: T) { }
pub fn main() { let x = @10; leaky::<@int>(x); }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-
+#[allow(dead_assignment)];
+#[allow(unused_variable)];
enum t { a, b(@int), }
-fn leaky<T>(t: T) { }
+fn leaky<T>(_t: T) { }
pub fn main() { let x = ~10; leaky::<~int>(x); }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#[allow(dead_assignment)];
+
struct X { x: int, y: @A }
struct A { a: int }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-fn test(cond: bool) {
+#[allow(dead_assignment)];
+#[allow(unreachable_code)];
+#[allow(unused_variable)];
+
+fn test(_cond: bool) {
let v: int;
v = 1;
loop { } // loop never terminates, so no error is reported
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#[allow(unreachable_code)];
+
fn test() {
let _v: int;
_v = 1;
-pub fn main() { if false { error!(~"foo" + ~"bar"); } }
+pub fn main() { if false { error!(~"foo" + "bar"); } }
}
pub fn main() {
- let x = list::from_vec(~[a(22u), b(~"hi")]);
+ let x = list::from_vec([a(22u), b(~"hi")]);
let exp = ~"@Cons(a(22), @Cons(b(~\"hi\"), @Nil))";
let act = fmt!("%?", x);
assert!(act == exp);
struct V<T> { v: ~[option<T>] }
fn mk<T:'static>() -> @mut Smallintmap<T> {
- let mut v: ~[option<T>] = ~[];
+ let v: ~[option<T>] = ~[];
return @mut Smallintmap {v: v};
}
fn f<T,U:'static>() {
- let mut sim = mk::<U>();
+ let sim = mk::<U>();
error!(sim);
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#[allow(unused_variable)];
-
-pub fn main() { let mut i: int = 0; while i < 1000000 { i += 1; let x = 3; } }
+pub fn main() {
+ let mut i: int = 0;
+ while i < 1000000 {
+ i += 1;
+ let x = 3;
+ }
+}
// except according to those terms.
pub fn main() {
- let i = 0u;
+ let _i = 0u;
loop {
break;
}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::local_data;
+
+local_data_key!(foo: int)
+
+mod bar {
+ local_data_key!(pub baz: float)
+}
+
+fn main() {
+ local_data::get(foo, |x| assert!(x.is_none()));
+ local_data::get(bar::baz, |y| assert!(y.is_none()));
+
+ local_data::set(foo, 3);
+ local_data::set(bar::baz, -10.0);
+
+ local_data::get(foo, |x| assert_eq!(*x.unwrap(), 3));
+ local_data::get(bar::baz, |y| assert_eq!(*y.unwrap(), -10.0));
+}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#[allow(unnecessary_allocation)];
+
fn f1(ref_string: &str) -> ~str {
match ref_string {
"a" => ~"found a",
pub fn main() {
let mut x = ~Pair {a: ~10, b: ~20};
match x {
- ~Pair {a: ref mut a, b: ref mut b} => {
+ ~Pair {a: ref mut a, b: ref mut _b} => {
assert!(**a == 10); *a = ~30; assert!(**a == 30);
}
}
struct X { x: int }
pub fn main() {
- let x = match 0 {
+ let _x = match 0 {
_ => X {
x: 0
}.x
struct X { x: int }
pub fn main() {
- let x = match 0 {
+ let _x = match 0 {
_ => X {
x: 0
}
enum maybe<T> { nothing, just(T), }
fn foo(x: maybe<int>) {
- match x { nothing => { error!("A"); } just(a) => { error!("B"); } }
+ match x {
+ nothing => { error!("A"); }
+ just(_a) => { error!("B"); }
+ }
}
pub fn main() { }
-fn altsimple(f: int) { match f { x => () } }
+fn altsimple(f: int) { match f { _x => () } }
pub fn main() { }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-
+#[allow(dead_assignment)];
+#[allow(unused_variable)];
enum thing { a, b, c, }
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn test1() {
+ // from issue 6338
+ match ((1, ~"a"), (2, ~"b")) {
+ ((1, a), (2, b)) | ((2, b), (1, a)) => {
+ assert_eq!(a, ~"a");
+ assert_eq!(b, ~"b");
+ },
+ _ => fail!(),
+ }
+}
+
+fn test2() {
+ match (1, 2, 3) {
+ (1, a, b) | (2, b, a) => {
+ assert_eq!(a, 2);
+ assert_eq!(b, 3);
+ },
+ _ => fail!(),
+ }
+}
+
+fn test3() {
+ match (1, 2, 3) {
+ (1, ref a, ref b) | (2, ref b, ref a) => {
+ assert_eq!(*a, 2);
+ assert_eq!(*b, 3);
+ },
+ _ => fail!(),
+ }
+}
+
+fn test4() {
+ match (1, 2, 3) {
+ (1, a, b) | (2, b, a) if a == 2 => {
+ assert_eq!(a, 2);
+ assert_eq!(b, 3);
+ },
+ _ => fail!(),
+ }
+}
+
+fn test5() {
+ match (1, 2, 3) {
+ (1, ref a, ref b) | (2, ref b, ref a) if *a == 2 => {
+ assert_eq!(*a, 2);
+ assert_eq!(*b, 3);
+ },
+ _ => fail!(),
+ }
+}
+
+fn main() {
+ test1();
+ test2();
+ test3();
+ test4();
+ test5();
+}
// sometimes we have had trouble finding
// the right type for f, as we unified
// bot and u32 here
- let f = match uint::from_str(~"1234") {
+ let f = match uint::from_str("1234") {
None => return (),
Some(num) => num as u32
};
pub fn f() -> ~[int] { vec::from_elem(1u, 0) }
}
-pub fn main() { let x = m::f(); }
+pub fn main() { let _x = m::f(); }
pub fn main() {
let x = m::S { x: 1, y: 2 };
- let m::S { x: a, y: b } = x;
+ let m::S { x: _a, y: _b } = x;
}
}
fn transform(x: Option<int>) -> Option<~str> {
- x.bind(|n| Some(*n + 1) ).bind(|n| Some(int::to_str(*n)) )
+ x.bind(|n| Some(*n + 1) ).bind(|n| Some(n.to_str()) )
}
pub fn main() {
assert_eq!(transform(Some(10)), Some(~"11"));
assert_eq!(transform(None), None);
assert!((~[~"hi"])
- .bind(|x| ~[x.clone(), *x + ~"!"] )
- .bind(|x| ~[x.clone(), *x + ~"?"] ) ==
+ .bind(|x| ~[x.clone(), *x + "!"] )
+ .bind(|x| ~[x.clone(), *x + "?"] ) ==
~[~"hi", ~"hi?", ~"hi!", ~"hi!?"]);
}
pub fn main() {
let x = @Triple{x: 1, y: 2, z: 3};
- for i in range(0u, 10000u) {
+ for _i in range(0u, 10000u) {
assert_eq!(test(true, x), 2);
}
assert_eq!(test(false, x), 5);
// except according to those terms.
// Issue #922
-fn f2(thing: @fn()) { }
+fn f2(_thing: @fn()) { }
fn f(thing: @fn()) {
f2(thing);
-use std::str;
-
struct StringBuffer {
s: ~str
}
sb.append("World!");
let str = to_str(sb);
assert_eq!(str, ~"Hello, World!");
-}
\ No newline at end of file
+}
// except according to those terms.
pub fn main() {
- let x: &mut [int] = &mut [ 1, 2, 3 ];
+ let _x: &mut [int] = &mut [ 1, 2, 3 ];
}
// -*- rust -*-
extern mod extra;
-use std::vec;
-
fn grow(v: &mut ~[int]) {
v.push(1);
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#[allow(unused_mut)];
struct Pair { a: int, b: int}
pub fn main() {
// This just tests whether the vec leaks its members.
- let mut pvec: ~[@Pair] =
+ let mut _pvec: ~[@Pair] =
~[@Pair{a: 1, b: 2}, @Pair{a: 3, b: 4}, @Pair{a: 5, b: 6}];
}
fn foo() {
match Some::<int>(5) {
- Some::<int>(x) => {
+ Some::<int>(_x) => {
let mut bar;
match None::<int> { None::<int> => { bar = 5; } _ => { baz(); } }
info!(bar);
fn nested(o: t) {
match o {
- bar(i, Some::<int>(_)) => { error!("wrong pattern matched"); fail!(); }
- _ => { error!("succeeded"); }
+ bar(_i, Some::<int>(_)) => { error!("wrong pattern matched"); fail!(); }
+ _ => { error!("succeeded"); }
}
}
pub fn main() {
match A {a: 10, b: @20} {
x@A {a, b: @20} => { assert!(x.a == 10); assert!(a == 10); }
- A {b, _} => { fail!(); }
+ A {b: _b, _} => { fail!(); }
}
let mut x@B {b, _} = B {a: 10, b: C {c: 20}};
x.b.c = 30;
// except according to those terms.
pub fn main() {
- let x: @mut [int] = @mut [ 1, 2, 3 ];
+ let _x: @mut [int] = @mut [ 1, 2, 3 ];
}
fn f(i: int, f: &fn(int) -> int) -> int { f(i) }
-fn g(g: &fn()) { }
+fn g(_g: &fn()) { }
fn ff() -> @fn(int) -> int {
return |x| x + 1;
fn main() {
let y = @mut 32;
{
- let x = Foo(y);
+ let _x = Foo(y);
}
assert_eq!(*y, 23);
}
pub struct Fd(c_int);
impl Drop for Fd {
+ #[fixed_stack_segment] #[inline(never)]
fn drop(&self) {
unsafe {
libc::close(**self);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::str;
-
pub fn main() {
let thing = ~"{{ f }}";
- let f = thing.find_str(~"{{");
+ let f = thing.find_str("{{");
if f.is_none() {
- println(~"None!");
+ println("None!");
}
}
impl Drop for dtor {
fn drop(&self) {
// abuse access to shared mutable state to write this code
- unsafe {
- *self.x -= 1;
- }
+ *self.x -= 1;
}
}
{
let b = Some(dtor { x:x });
- let c = unwrap(b);
+ let _c = unwrap(b);
}
assert_eq!(*x, 0);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#[allow(dead_assignment)];
+#[allow(unused_variable)];
+
struct A { a: int, b: int }
struct Abox { a: @int, b: @int }
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn f<T: 'static>(_x: T) {}
+
+fn main() {
+ f(~5);
+}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-
-
+#[allow(unreachable_code)];
// -*- rust -*-
fn dont_call_me() { fail!(); info!(1); }
mod foo {
- pub fn bar(offset: uint) { }
+ pub fn bar(_offset: uint) { }
}
pub fn main() { foo::bar(0u); }
match Some(src) {
Some(src_id) => {
- for i in range(0u, 10u) {
+ for _i in range(0u, 10u) {
let yyy = src_id;
assert_eq!(yyy, 0u);
}
pub fn main() {
let f = |(x, _): (int, int)| println((x + 1).to_str());
- let g = |Foo { x: x, y: y }: Foo| println((x + 1).to_str());
+ let g = |Foo { x: x, y: _y }: Foo| println((x + 1).to_str());
f((2, 3));
g(Foo { x: 1, y: 2 });
}
// this checks that a pred with a non-bool return
// type is rejected, even if the pred is never used
-fn bad(a: int) -> int { return 37; } //~ ERROR Non-boolean return type
+fn bad(_a: int) -> int { return 37; } //~ ERROR Non-boolean return type
pub fn main() { }
}
}
+#[fixed_stack_segment] #[inline(never)]
fn main() {
unsafe {
a::free(transmute(0));
use pub_use_xcrate2::Foo;
pub fn main() {
- let foo: Foo = Foo {
+ let _foo: Foo = Foo {
name: 0
};
}
// xfail-fast
// aux-build:pub_use_mods_xcrate.rs
+#[allow(unused_imports)];
+
extern mod pub_use_mods_xcrate;
use pub_use_mods_xcrate::a::c;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::vec;
-
trait sum {
fn sum_(self) -> int;
}
info!("y==%d", y);
assert_eq!(y, 6);
- let mut x = ~[1, 2, 3];
+ let x = ~[1, 2, 3];
let y = x.sum_();
info!("y==%d", y);
assert_eq!(y, 6);
}
fn visit_int(&self) -> bool {
do self.get::<int>() |i| {
- self.vals.push(int::to_str(i));
+ self.vals.push(i.to_str());
};
true
}
&foo.v3[i]
}
-fn get_v4<'v>(a: &'v A, i: uint) -> &'v int {
+fn get_v4<'v>(a: &'v A, _i: uint) -> &'v int {
let foo = &a.value;
&foo.v4.f
}
-fn get_v5<'v>(a: &'v A, i: uint) -> &'v int {
+fn get_v5<'v>(a: &'v A, _i: uint) -> &'v int {
let foo = &a.value;
&foo.v5.f
}
-fn get_v6_a<'v>(a: &'v A, i: uint) -> &'v int {
+fn get_v6_a<'v>(a: &'v A, _i: uint) -> &'v int {
match a.value.v6 {
Some(ref v) => &v.f,
None => fail!()
}
}
-fn get_v6_b<'v>(a: &'v A, i: uint) -> &'v int {
+fn get_v6_b<'v>(a: &'v A, _i: uint) -> &'v int {
match *a {
A { value: B { v6: Some(ref v), _ } } => &v.f,
_ => fail!()
}
}
-fn get_v6_c<'v>(a: &'v A, i: uint) -> &'v int {
+fn get_v6_c<'v>(a: &'v A, _i: uint) -> &'v int {
match a {
&A { value: B { v6: Some(ref v), _ } } => &v.f,
_ => fail!()
}
}
-fn get_v5_ref<'v>(a: &'v A, i: uint) -> &'v int {
+fn get_v5_ref<'v>(a: &'v A, _i: uint) -> &'v int {
match &a.value {
&B {v5: ~C {f: ref v}, _} => v
}
x = @5;
y = @6;
assert_eq!(*a, exp);
+ assert_eq!(x, @5);
+ assert_eq!(y, @6);
}
pub fn main() {
fn produce_static<T>() -> &'static T { fail!(); }
-fn foo<T>(x: &T) -> &uint { produce_static() }
+fn foo<T>(_x: &T) -> &uint { produce_static() }
pub fn main() {
}
add(&'self ast<'self>, &'self ast<'self>)
}
-fn mk_add_ok<'a>(x: &'a ast<'a>, y: &'a ast<'a>, z: &ast) -> ast<'a> {
+fn mk_add_ok<'a>(x: &'a ast<'a>, y: &'a ast<'a>, _z: &ast) -> ast<'a> {
add(x, y)
}
// Issue #2263.
+#[allow(dead_assignment)];
+#[allow(unused_variable)];
+
// Should pass region checking.
fn ok(f: @fn(x: &uint)) {
// Here, g is a function that can accept a uint pointer with
x: int
}
+#[fixed_stack_segment] #[inline(never)]
fn alloc<'a>(_bcx : &'a arena) -> &'a Bcx<'a> {
unsafe {
cast::transmute(libc::malloc(sys::size_of::<Bcx<'blk>>()
return alloc(bcx.fcx.arena);
}
+#[fixed_stack_segment] #[inline(never)]
fn g(fcx : &Fcx) {
let bcx = Bcx { fcx: fcx };
let bcx2 = h(&bcx);
#[unsafe_destructor]
impl Drop for r {
fn drop(&self) {
- unsafe {
- *(self.i) += 1;
- }
+ *(self.i) += 1;
}
}
impl Drop for r {
fn drop(&self) {
unsafe {
- let v2: ~int = cast::transmute(self.v.c);
+ let _v2: ~int = cast::transmute(self.v.c);
}
}
}
#[unsafe_destructor]
impl Drop for shrinky_pointer {
fn drop(&self) {
- unsafe {
- error!(~"Hello!"); **(self.i) -= 1;
- }
+ error!(~"Hello!"); **(self.i) -= 1;
}
}
#[unsafe_destructor]
impl Drop for close_res {
fn drop(&self) {
- unsafe {
- *(self.i) = false;
- }
+ *(self.i) = false;
}
}
enum option<T> { none, some(T), }
-fn sink(res: option<close_res>) { }
+fn sink(_res: option<close_res>) { }
pub fn main() {
let c = @mut true;
fn f() { let x: () = (); return x; }
-pub fn main() { let x = f(); }
+pub fn main() { let _x = f(); }
task::spawn(|| die() );
let (p, c) = comm::stream::<()>();
loop {
- // Sending and receiving here because these actions yield,
+ // Sending and receiving here because these actions deschedule,
// at which point our child can kill us.
c.send(());
p.recv();
// The above comment no longer makes sense but I'm
// reluctant to remove a linked failure test case.
- task::yield();
+ task::deschedule();
}
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::comm::*;
use std::task;
struct test {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::comm::*;
-
// tests that ctrl's type gets inferred properly
struct Command<K, V> {
key: K,
}
fn cache_server<K:Send,V:Send>(c: Chan<Chan<Command<K, V>>>) {
- let (ctrl_port, ctrl_chan) = stream();
+ let (_ctrl_port, ctrl_chan) = stream();
c.send(ctrl_chan);
}
pub fn main() { }
match none::<int> {
some::<int>(_) => {
- for i in c.iter() {
+ for _i in c.iter() {
info!(a);
let a = 17;
b.push(a);
fn uhoh<T>(v: ~[clam<T>]) {
match v[1] {
- a::<T>(ref t, ref u) => { info!("incorrect"); info!(u); fail!(); }
+ a::<T>(ref _t, ref u) => { info!("incorrect"); info!(u); fail!(); }
b::<T> => { info!("correct"); }
}
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+// xfail-test - FIXME(#8538) some kind of problem linking induced by extern "C" fns that I do not understand
// xfail-fast - windows doesn't like this
// Smallest hello world with no runtime
task::spawn(|| x(~"hello from second spawned fn", 66) );
task::spawn(|| x(~"hello from third spawned fn", 67) );
let mut i: int = 30;
- while i > 0 { i = i - 1; info!("parent sleeping"); task::yield(); }
+ while i > 0 { i = i - 1; info!("parent sleeping"); task::deschedule(); }
}
Arnold.
*/
-use std::comm::*;
use std::task;
type ctx = Chan<int>;
-fn iotask(cx: &ctx, ip: ~str) {
+fn iotask(_cx: &ctx, ip: ~str) {
assert_eq!(ip, ~"localhost");
}
pub fn main() {
- let (p, ch) = stream::<int>();
+ let (_p, ch) = stream::<int>();
task::spawn(|| iotask(&ch, ~"localhost") );
}
use std::io::WriterUtil;
use std::io;
use std::os;
-use std::uint;
pub fn main() {
let dir = tempfile::mkdtemp(&Path("."), "").unwrap();
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// xfail-fast
+// aux-build:static-function-pointer-aux.rs
+extern mod aux(name = "static-function-pointer-aux");
+
+fn f(x: int) -> int { x }
+
+fn main() {
+ assert_eq!(aux::F(42), -42);
+ unsafe {
+ assert_eq!(aux::MutF(42), -42);
+ aux::MutF = f;
+ assert_eq!(aux::MutF(42), 42);
+ aux::MutF = aux::f;
+ assert_eq!(aux::MutF(42), -42);
+ }
+}
--- /dev/null
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn f(x: int) -> int { x }
+fn g(x: int) -> int { 2 * x }
+
+static F: extern fn(int) -> int = f;
+static mut G: extern fn(int) -> int = f;
+
+pub fn main() {
+ assert_eq!(F(42), 42);
+ unsafe {
+ assert_eq!(G(42), 42);
+ G = g;
+ assert_eq!(G(42), 84);
+ }
+}
// xfail-fast
use std::uint;
-use std::vec;
pub trait plus {
fn plus(&self) -> int;
}
impl uint_utils for uint {
- fn str(&self) -> ~str { uint::to_str(*self) }
+ fn str(&self) -> ~str { self.to_str() }
fn multi(&self, f: &fn(uint)) {
let mut c = 0u;
while c < *self { f(c); c += 1u; }
*a = 3;
}
+#[fixed_stack_segment] #[inline(never)]
unsafe fn run() {
assert!(debug_static_mut == 3);
debug_static_mut = 4;
// This tests for issue #163
let ff: ~str = ~"abc";
- let a: ~str = ff + ~"ABC" + ff;
- let b: ~str = ~"ABC" + ff + ~"ABC";
+ let a: ~str = ff + "ABC" + ff;
+ let b: ~str = ~"ABC" + ff + "ABC";
info!(a.clone());
info!(b.clone());
assert_eq!(a, ~"abcABCabc");
extern mod extra;
-use std::str;
-
pub fn main() {
// Make sure we properly handle repeated self-appends.
let mut a: ~str = ~"A";
}
pub fn main() {
- let x = Bar { a: 2, b: 3 };
+ let _x = Bar { a: 2, b: 3 };
}
--- /dev/null
+struct Foo {
+ new: int,
+}
+
+pub fn main() {
+ let foo = Foo{ new: 3 };
+ assert_eq!(foo.new, 3);
+}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::str;
-
struct S { f0: ~str, f1: int }
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::str;
-
struct S { f0: ~str, f1: ~str }
pub fn main() {
}
}
+#[fixed_stack_segment] #[inline(never)]
fn test1() {
unsafe {
let q = Quad { a: 0xaaaa_aaaa_aaaa_aaaa_u64,
}
#[cfg(target_arch = "x86_64")]
+#[fixed_stack_segment]
+#[inline(never)]
fn test2() {
unsafe {
let f = Floats { a: 1.234567890e-15_f64,
// Issue #5041 - avoid overlapping memcpy when src and dest of a swap are the same
use std::ptr;
-use std::util;
pub fn main() {
let mut test = TestDescAndFn {
}
pub fn main() {
- test(fmt!("hello %d friends and %s things", 10, ~"formatted"),
+ test(fmt!("hello %d friends and %s things", 10, "formatted"),
~"hello 10 friends and formatted things");
test(fmt!("test"), ~"test");
test(fmt!("%i", 2), ~"2");
test(fmt!("%i", -1), ~"-1");
test(fmt!("%u", 10u), ~"10");
- test(fmt!("%s", ~"test"), ~"test");
+ test(fmt!("%s", "test"), ~"test");
test(fmt!("%b", true), ~"true");
test(fmt!("%b", false), ~"false");
test(fmt!("%c", 'A'), ~"A");
test(fmt!("%10d", 500), ~" 500");
test(fmt!("%10d", -500), ~" -500");
test(fmt!("%10u", 500u), ~" 500");
- test(fmt!("%10s", ~"test"), ~" test");
+ test(fmt!("%10s", "test"), ~" test");
test(fmt!("%10b", true), ~" true");
test(fmt!("%10x", 0xff_u), ~" ff");
test(fmt!("%10X", 0xff_u), ~" FF");
test(fmt!("%-10d", 500), ~"500 ");
test(fmt!("%-10d", -500), ~"-500 ");
test(fmt!("%-10u", 500u), ~"500 ");
- test(fmt!("%-10s", ~"test"), ~"test ");
+ test(fmt!("%-10s", "test"), ~"test ");
test(fmt!("%-10b", true), ~"true ");
test(fmt!("%-10x", 0xff_u), ~"ff ");
test(fmt!("%-10X", 0xff_u), ~"FF ");
test(fmt!("%.d", 10), ~"10");
test(fmt!("%.d", -10), ~"-10");
test(fmt!("%.u", 10u), ~"10");
- test(fmt!("%.s", ~"test"), ~"");
+ test(fmt!("%.s", "test"), ~"");
test(fmt!("%.x", 127u), ~"7f");
test(fmt!("%.o", 10u), ~"12");
test(fmt!("%.t", 3u), ~"11");
test(fmt!("%.0d", 10), ~"10");
test(fmt!("%.0d", -10), ~"-10");
test(fmt!("%.0u", 10u), ~"10");
- test(fmt!("%.0s", ~"test"), ~"");
+ test(fmt!("%.0s", "test"), ~"");
test(fmt!("%.0x", 127u), ~"7f");
test(fmt!("%.0o", 10u), ~"12");
test(fmt!("%.0t", 3u), ~"11");
test(fmt!("%.1d", 10), ~"10");
test(fmt!("%.1d", -10), ~"-10");
test(fmt!("%.1u", 10u), ~"10");
- test(fmt!("%.1s", ~"test"), ~"t");
+ test(fmt!("%.1s", "test"), ~"t");
test(fmt!("%.1x", 127u), ~"7f");
test(fmt!("%.1o", 10u), ~"12");
test(fmt!("%.1t", 3u), ~"11");
test(fmt!("%.5d", 10), ~"00010");
test(fmt!("%.5d", -10), ~"-00010");
test(fmt!("%.5u", 10u), ~"00010");
- test(fmt!("%.5s", ~"test"), ~"test");
+ test(fmt!("%.5s", "test"), ~"test");
test(fmt!("%.5x", 127u), ~"0007f");
test(fmt!("%.5o", 10u), ~"00012");
test(fmt!("%.5t", 3u), ~"00011");
test(fmt!("%05f", 5.82), ~"05.82");
// 0-padding a string is undefined but glibc does this:
- test(fmt!("%05s", ~"test"), ~" test");
+ test(fmt!("%05s", "test"), ~" test");
test(fmt!("%05c", 'A'), ~" A");
test(fmt!("%05b", true), ~" true");
// Left-justify overrides 0-padding
test(fmt!("%-05X", 127u), ~"7F ");
test(fmt!("%-05o", 10u), ~"12 ");
test(fmt!("%-05t", 3u), ~"11 ");
- test(fmt!("%-05s", ~"test"), ~"test ");
+ test(fmt!("%-05s", "test"), ~"test ");
test(fmt!("%-05c", 'A'), ~"A ");
test(fmt!("%-05b", true), ~"true ");
test(fmt!("%-05f", 5.82), ~"5.82 ");
test(fmt!("%06.5d", 10), ~" 00010");
test(fmt!("%06.5d", -10), ~"-00010");
test(fmt!("%06.5u", 10u), ~" 00010");
- test(fmt!("%06.5s", ~"test"), ~" test");
+ test(fmt!("%06.5s", "test"), ~" test");
test(fmt!("%06.5c", 'A'), ~" A");
test(fmt!("%06.5x", 127u), ~" 0007f");
test(fmt!("%06.5X", 127u), ~" 0007F");
assert_eq!(concat_idents!(asd, f_f, dsa), ~"<.<");
assert!(stringify!(use_mention_distinction) ==
- ~"use_mention_distinction");
+ "use_mention_distinction");
}
assert_eq!(line!(), 23);
//assert!((col!() == 11));
assert_eq!(indirect_line!(), 25);
- assert!((file!().to_owned().ends_with(~"syntax-extension-source-utils.rs")));
+ assert!((file!().to_owned().ends_with("syntax-extension-source-utils.rs")));
assert_eq!(stringify!((2*3) + 5).to_owned(), ~"( 2 * 3 ) + 5");
assert!(include!("syntax-extension-source-utils-files/includeme.fragment").to_owned()
== ~"victory robot 6");
assert!(
include_str!("syntax-extension-source-utils-files/includeme.fragment").to_owned()
- .starts_with(~"/* this is for "));
+ .starts_with("/* this is for "));
assert!(
include_bin!("syntax-extension-source-utils-files/includeme.fragment")
[1] == (42 as u8)); // '*'
// The Windows tests are wrapped in an extra module for some reason
- assert!((m1::m2::where_am_i().ends_with(~"m1::m2")));
+ assert!((m1::m2::where_am_i().ends_with("m1::m2")));
}
fn foo() {
- fn zed(z: bar) { }
+ fn zed(_z: bar) { }
enum bar { nil, }
fn baz() { zed(nil); }
}
extern mod extra;
use std::comm::Chan;
-use std::comm::Port;
use std::comm;
use std::task;
pub fn main() {
let (p, ch) = comm::stream();
- let child = task::spawn(|| start(&ch) );
+ let _child = task::spawn(|| start(&ch) );
let c = p.recv();
c.send(~"A");
c.send(~"B");
- task::yield();
+ task::deschedule();
}
use std::task;
fn start(c: &comm::Chan<comm::Chan<int>>) {
- let (p, ch) = comm::stream();
+ let (_p, ch) = comm::stream();
c.send(ch);
}
pub fn main() {
let (p, ch) = comm::stream();
- let child = task::spawn(|| start(&ch) );
- let c = p.recv();
+ let _child = task::spawn(|| start(&ch) );
+ let _c = p.recv();
}
pub fn main() { test00(); }
-fn start(task_number: int) { info!("Started / Finished task."); }
+fn start(_task_number: int) { info!("Started / Finished task."); }
fn test00() {
let i: int = 0;
// Sleep long enough for the task to finish.
let mut i = 0;
while i < 10000 {
- task::yield();
+ task::deschedule();
i += 1;
}
pub fn main() {
info!("Check that we don't deadlock.");
- let (p, ch) = comm::stream();
+ let (_p, ch) = comm::stream();
task::try(|| start(&ch, 0, 10) );
info!("Joined task");
}
// Read from spawned tasks...
let mut sum = 0;
- for r in results.iter() {
+ for _r in results.iter() {
i = 0;
while i < number_of_messages {
let value = po.recv();
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#[allow(dead_assignment)];
+
use std::comm;
pub fn main() { test00(); }
pub fn main() { test00(); }
fn test00() {
- let r: int = 0;
+ let _r: int = 0;
let mut sum: int = 0;
let (p, c) = comm::stream();
let number_of_messages: int = 1000;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#[allow(dead_assignment)];
+
use std::comm::SharedChan;
use std::comm;
// xfail-fast
+#[allow(dead_assignment)];
+
extern mod extra;
use std::comm;
}
fn supervised() {
- // Yield to make sure the supervisor joins before we
+ // Deschedule to make sure the supervisor joins before we
// fail. This is currently not needed because the supervisor
// runs first, but I can imagine that changing.
error!("supervised task=%?", 0);
- task::yield();
+ task::deschedule();
fail!();
}
use std::task;
fn supervised() {
- // Yield to make sure the supervisor joins before we fail. This is
+ // Deschedule to make sure the supervisor joins before we fail. This is
// currently not needed because the supervisor runs first, but I can
// imagine that changing.
- task::yield();
+ task::deschedule();
fail!();
}
task::spawn(|| child(~"Hello") );
}
-fn child(s: ~str) {
+fn child(_s: ~str) {
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::comm::*;
use std::ptr;
use std::task;
use std::task;
-fn test_break() { loop { let x: @int = break; } }
+fn test_break() { loop { let _x: @int = break; } }
-fn test_cont() { let mut i = 0; while i < 1 { i += 1; let x: @int = loop; } }
+fn test_cont() { let mut i = 0; while i < 1 { i += 1; let _x: @int = loop; } }
-fn test_ret() { let x: @int = return; }
+fn test_ret() { let _x: @int = return; }
fn test_fail() {
- fn f() { let x: @int = fail!(); }
+ fn f() { let _x: @int = fail!(); }
task::try(|| f() );
}
fn test_fail_indirect() {
fn f() -> ! { fail!(); }
- fn g() { let x: @int = f(); }
+ fn g() { let _x: @int = f(); }
task::try(|| g() );
}
assert_eq!(i.g(), 10);
}
-fn welp<T>(i: int, x: &T) -> int {
+fn welp<T>(i: int, _x: &T) -> int {
i.g()
}
use std::int;
trait to_str {
- fn to_str(&self) -> ~str;
+ fn to_string(&self) -> ~str;
}
impl to_str for int {
- fn to_str(&self) -> ~str { int::to_str(*self) }
+ fn to_string(&self) -> ~str { self.to_str() }
}
impl to_str for ~str {
- fn to_str(&self) -> ~str { self.clone() }
+ fn to_string(&self) -> ~str { self.clone() }
}
impl to_str for () {
- fn to_str(&self) -> ~str { ~"()" }
+ fn to_string(&self) -> ~str { ~"()" }
}
trait map<T> {
x.map(|_e| ~"hi" )
}
fn bar<U:to_str,T:map<U>>(x: T) -> ~[~str] {
- x.map(|_e| _e.to_str() )
+ x.map(|_e| _e.to_string() )
}
pub fn main() {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::cmp::{Eq, Ord};
+use std::cmp::Eq;
use std::num::NumCast;
pub trait NumExt: Eq + Num + NumCast {}
impl ::base::HasNew<Foo> for Foo {
fn new() -> Foo {
- unsafe { println("Foo"); }
+ println("Foo");
Foo { dummy: () }
}
}
impl ::base::HasNew<Bar> for Bar {
fn new() -> Bar {
- unsafe { io::println("Bar"); }
+ io::println("Bar");
Bar { dummy: () }
}
}
}
pub fn main() {
- let f: base::Foo = base::HasNew::new::<base::Foo, base::Foo>();
- let b: base::Bar = base::HasNew::new::<base::Bar, base::Bar>();
+ let _f: base::Foo = base::HasNew::new::<base::Foo, base::Foo>();
+ let _b: base::Bar = base::HasNew::new::<base::Bar, base::Bar>();
}
// xfail-fast
-#[no_std];
-
-extern mod std;
-
-use std::str::StrVector;
-use std::vec::ImmutableVector;
-use std::iterator::Iterator;
-use std::int;
-
trait to_str {
- fn to_str(&self) -> ~str;
+ fn to_string(&self) -> ~str;
}
impl to_str for int {
- fn to_str(&self) -> ~str { int::to_str(*self) }
+ fn to_string(&self) -> ~str { self.to_str() }
}
impl<T:to_str> to_str for ~[T] {
- fn to_str(&self) -> ~str {
- fmt!("[%s]", self.iter().map(|e| e.to_str()).collect::<~[~str]>().connect(", "))
+ fn to_string(&self) -> ~str {
+ fmt!("[%s]", self.iter().map(|e| e.to_string()).collect::<~[~str]>().connect(", "))
}
}
pub fn main() {
- assert!(1.to_str() == ~"1");
- assert!((~[2, 3, 4]).to_str() == ~"[2, 3, 4]");
+ assert!(1.to_string() == ~"1");
+ assert!((~[2, 3, 4]).to_string() == ~"[2, 3, 4]");
fn indirect<T:to_str>(x: T) -> ~str {
- x.to_str() + ~"!"
+ x.to_string() + "!"
}
assert!(indirect(~[10, 20]) == ~"[10, 20]!");
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#[allow(dead_assignment)];
+#[allow(unused_variable)];
trait Foo {
fn foo(&self, mut v: int) { v = 1; }
--- /dev/null
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[deriving(Eq)]
+struct Foo(int);
+#[deriving(Eq)]
+struct Bar(int, int);
+
+fn main() {
+ let f: extern fn(int) -> Foo = Foo;
+ let g: extern fn(int, int) -> Bar = Bar;
+ assert_eq!(f(42), Foo(42));
+ assert_eq!(g(4, 7), Bar(4, 7));
+}
pub mod b {
pub type t = int;
- pub fn foo() { let x: t = 10; }
+ pub fn foo() { let _x: t = 10; }
}
}
// xfail-fast
-fn p_foo<T>(pinned: T) { }
-fn s_foo<T>(shared: T) { }
-fn u_foo<T:Send>(unique: T) { }
+fn p_foo<T>(_pinned: T) { }
+fn s_foo<T>(_shared: T) { }
+fn u_foo<T:Send>(_unique: T) { }
struct r {
i: int,
while lo_ < hi { it(lo_); lo_ += 1u; }
}
-fn create_index<T>(index: ~[S<T>], hash_fn: extern fn(T) -> uint) {
- range_(0u, 256u, |_i| { let bucket: ~[T] = ~[]; } )
+fn create_index<T>(_index: ~[S<T>], _hash_fn: extern fn(T) -> uint) {
+ do range_(0u, 256u) |_i| {
+ let _bucket: ~[T] = ~[];
+ }
}
pub fn main() { }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-
+#[allow(dead_assignment)];
+#[allow(unused_variable)];
fn f() {
let x = 10; let mut y = 11;
// -*- rust -*-
-pub fn main() { let x: uint = 10 as uint; }
+pub fn main() { let _x: uint = 10 as uint; }
let c = 1;
let c_neg: i32 = -c;
- error!(b_neg);
+ error!(c_neg);
let d = 1;
let d_neg: i64 = -d;
- error!(b_neg);
+ error!(d_neg);
let e = 1;
let e_neg: int = -e;
- error!(b_neg);
+ error!(e_neg);
// intentional overflows
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#[allow(dead_assignment)];
+
pub fn main() {
let i = ~1;
let mut j = ~2;
pub fn main() {
enum t { t1(int), t2(int), }
- let x = ~t1(10);
+ let _x = ~t1(10);
/*alt *x {
t1(a) {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#[allow(unused_variable)];
+
use std::sys;
pub fn main() {
- unsafe {
- let i = ~@1;
- let j = ~@2;
- let rc1 = sys::refcount(*i);
- let j = i.clone();
- let rc2 = sys::refcount(*i);
- error!("rc1: %u rc2: %u", rc1, rc2);
- assert_eq!(rc1 + 1u, rc2);
- }
+ let i = ~@1;
+ let j = ~@2;
+ let rc1 = sys::refcount(*i);
+ let j = i.clone();
+ let rc2 = sys::refcount(*i);
+ error!("rc1: %u rc2: %u", rc1, rc2);
+ assert_eq!(rc1 + 1u, rc2);
}
let _: ~int;
}
-fn f(i: ~int) -> ~int {
+fn f(_i: ~int) -> ~int {
fail!();
}
// except according to those terms.
pub fn main() {
- let x = ~~[0,0,0,0,0];
+ let _x = ~~[0,0,0,0,0];
}
// except according to those terms.
pub fn main() {
- let i = ~100;
+ let _i = ~100;
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#[allow(unused_variable)];
+
pub fn main() {
let i = ~100;
let j = ~200;
pub fn main() {
let loop_: ~EventLoop = ~UvEventLoop { uvio: 0 } as ~EventLoop;
- let loop2_ = loop_;
-}
\ No newline at end of file
+ let _loop2_ = loop_;
+}
#[unsafe_destructor]
impl Drop for r {
fn drop(&self) {
- unsafe {
- *(self.i) = *(self.i) + 1;
- }
+ *(self.i) = *(self.i) + 1;
}
}
pub fn main() {
let i = @mut 0;
{
- let j = ~r(i);
+ let _j = ~r(i);
}
assert_eq!(*i, 1);
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::comm::*;
-
pub fn main() {
let (p, c) = stream();
c.send(~100);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-
-
+#[allow(unused_variable)];
+#[allow(dead_assignment)];
// -*- rust -*-
fn f(u: ()) { return u; }
-fn good(a: &int) {
+fn good(_a: &int) {
}
// unnamed argument &int is now parse x: &int
-fn called(f: &fn(&int)) {
+fn called(_f: &fn(&int)) {
}
pub fn main() {
-called(good);
+ called(good);
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#[allow(unreachable_code)];
+#[allow(unused_variable)];
fn id(x: bool) -> bool { x }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#[allow(path_statement)];
+#[allow(unreachable_code)];
+#[allow(unused_variable)];
fn id(x: bool) -> bool { x }
// except according to those terms.
pub fn main() {
- let x = ~1;
+ let _x = ~1;
let lam_move: @fn() = || {};
lam_move();
}
// Issue Name: Unused move causes a crash
// Abstract: zero-fill to block after drop
+#[allow(path_statement)];
+
pub fn main()
{
let y = ~1;
use std::task;
fn f() {
- let a = @0;
+ let _a = @0;
fail!();
}
}
fn f() {
- let c = complainer(@0);
+ let _c = complainer(@0);
fail!();
}
use std::task;
fn f() {
- let a = ~0;
+ let _a = ~0;
fail!();
}
fn foo<T>(o: myoption<T>) -> int {
let mut x: int = 5;
- match o { none::<T> => { } some::<T>(t) => { x += 1; } }
+ match o {
+ none::<T> => { }
+ some::<T>(_t) => { x += 1; }
+ }
return x;
}
fn foo<T>(o: myoption<T>) -> int {
let mut x: int;
- match o { none::<T> => { fail!(); } some::<T>(t) => { x = 5; } }
+ match o {
+ none::<T> => { fail!(); }
+ some::<T>(_t) => { x = 5; }
+ }
return x;
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#[allow(unused_imports)];
+
#[no_std];
extern mod std;
extern mod zed(name = "std");
extern mod extra;
use std::str;
-use std::vec;
pub fn main() {
// Chars of 1, 2, 3, and 4 bytes
assert!((str::is_utf8(s.as_bytes())));
// invalid prefix
- assert!((!str::is_utf8(~[0x80_u8])));
+ assert!((!str::is_utf8([0x80_u8])));
// invalid 2 byte prefix
- assert!((!str::is_utf8(~[0xc0_u8])));
- assert!((!str::is_utf8(~[0xc0_u8, 0x10_u8])));
+ assert!((!str::is_utf8([0xc0_u8])));
+ assert!((!str::is_utf8([0xc0_u8, 0x10_u8])));
// invalid 3 byte prefix
- assert!((!str::is_utf8(~[0xe0_u8])));
- assert!((!str::is_utf8(~[0xe0_u8, 0x10_u8])));
- assert!((!str::is_utf8(~[0xe0_u8, 0xff_u8, 0x10_u8])));
+ assert!((!str::is_utf8([0xe0_u8])));
+ assert!((!str::is_utf8([0xe0_u8, 0x10_u8])));
+ assert!((!str::is_utf8([0xe0_u8, 0xff_u8, 0x10_u8])));
// invalid 4 byte prefix
- assert!((!str::is_utf8(~[0xf0_u8])));
- assert!((!str::is_utf8(~[0xf0_u8, 0x10_u8])));
- assert!((!str::is_utf8(~[0xf0_u8, 0xff_u8, 0x10_u8])));
- assert!((!str::is_utf8(~[0xf0_u8, 0xff_u8, 0xff_u8, 0x10_u8])));
+ assert!((!str::is_utf8([0xf0_u8])));
+ assert!((!str::is_utf8([0xf0_u8, 0x10_u8])));
+ assert!((!str::is_utf8([0xf0_u8, 0xff_u8, 0x10_u8])));
+ assert!((!str::is_utf8([0xf0_u8, 0xff_u8, 0xff_u8, 0x10_u8])));
let mut stack = ~"a×c€";
assert_eq!(stack.pop_char(), '€');
pub fn main() {
// This just tests whether the vec leaks its members.
- let pvec: ~[@Pair] =
+ let _pvec: ~[@Pair] =
~[@Pair{x: 1, y: 2}, @Pair{x: 3, y: 4}, @Pair{x: 5, y: 6}];
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#[allow(dead_assignment)];
+
pub fn main() {
let a = ~[1, 2, 3, 4, 5];
let mut b = ~[a.clone(), a.clone()];
assert_eq!(b, 2);
assert!(tail.is_empty());
}
- ([..tail], _) => fail!()
+ ([.._tail], _) => fail!()
}
}
#[unsafe_destructor]
impl Drop for foo {
fn drop(&self) {
- unsafe {
- *self.x += 1;
- }
+ *self.x += 1;
}
}
assert!(tail[1].string == ~"baz");
match tail {
- [Foo { _ }, _, Foo { _ }, ..tail] => {
+ [Foo { _ }, _, Foo { _ }, .. _tail] => {
::std::util::unreachable();
}
[Foo { string: ref a }, Foo { string: ref b }] => {
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-pub fn main() { let quux: @~[uint] = @~[]; }
+pub fn main() { let _quux: @~[uint] = @~[]; }
break; }
}
-fn evil_lincoln() { let evil = info!("lincoln"); }
+fn evil_lincoln() { let _evil = info!("lincoln"); }
pub fn main() {
strange();
-pub fn main() { let x: int = 10; while x == 10 && x == 11 { let y = 0xf00; } }
+pub fn main() { let x: int = 10; while x == 10 && x == 11 { let _y = 0xf00; } }
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-pub fn main() {
+#[allow(dead_assignment)];
+#[allow(unused_variable)];
+pub fn main() {
let mut y: int = 42;
let mut z: int = 42;
let mut x: int;
info!(i);
i = i + 1;
if i == 95 {
- let v: ~[int] =
+ let _v: ~[int] =
~[1, 2, 3, 4, 5]; // we check that it is freed by break
info!("breaking");
pub type LPVOID = uint;
pub type BOOL = u8;
+#[cfg(target_os = "win32")]
mod kernel32 {
use super::{HANDLE, DWORD, SIZE_T, LPVOID, BOOL};
- #[cfg(target_os = "win32")]
#[abi = "stdcall"]
extern "stdcall" {
pub fn GetProcessHeap() -> HANDLE;
#[cfg(target_os = "win32")]
+#[fixed_stack_segment]
pub fn main() {
let heap = unsafe { kernel32::GetProcessHeap() };
let mem = unsafe { kernel32::HeapAlloc(heap, 0u32, 100u32) };
--- /dev/null
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// xfail-fast
+// aux-build:xc_conditions.rs
+
+extern mod xc_conditions;
+use xc_conditions::oops;
+use xc_conditions::trouble;
+
+// Tests of cross-crate conditions; the condition is
+// defined in lib, and we test various combinations
+// of `trap` and `raise` in the client or the lib where
+// the condition was defined. Also in test #4 we use
+// more complex features (generics, traits) in
+// combination with the condition.
+//
+// trap raise
+// ------------
+// xc_conditions : client lib
+// xc_conditions_2: client client
+// xc_conditions_3: lib client
+// xc_conditions_4: client client (with traits)
+//
+// the trap=lib, raise=lib case isn't tested since
+// there's no cross-crate-ness to test in that case.
+
+pub fn main() {
+ do oops::cond.trap(|_i| 12345).inside {
+ let x = trouble();
+ assert_eq!(x,12345);
+ }
+}
\ No newline at end of file
--- /dev/null
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// xfail-fast
+// aux-build:xc_conditions_2.rs
+
+extern mod xc_conditions_2;
+use xcc = xc_conditions_2;
+
+pub fn main() {
+ do xcc::oops::cond.trap(|_| 1).inside {
+ xcc::oops::cond.raise(1);
+ }
+}
--- /dev/null
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// xfail-fast
+// aux-build:xc_conditions_3.rs
+
+extern mod xc_conditions_3;
+use xcc = xc_conditions_3;
+
+pub fn main() {
+ assert_eq!(xcc::guard(a, 1), 40);
+}
+
+pub fn a() -> int {
+ assert_eq!(xcc::oops::cond.raise(7), 7);
+ xcc::guard(b, 2)
+}
+
+pub fn b() -> int {
+ assert_eq!(xcc::oops::cond.raise(8), 16);
+ xcc::guard(c, 3)
+}
+
+pub fn c() -> int {
+ assert_eq!(xcc::oops::cond.raise(9), 27);
+ xcc::guard(d, 4)
+}
+
+pub fn d() -> int {
+ xcc::oops::cond.raise(10)
+}
--- /dev/null
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// xfail-fast
+// aux-build:xc_conditions_4.rs
+
+extern mod xc_conditions_4;
+use xcc = xc_conditions_4;
+
+struct SThunk {
+ x: int
+}
+
+impl xcc::Thunk<xcc::Color> for SThunk {
+ fn call(self) -> xcc::Color {
+ xcc::oops::cond.raise((self.x, 1.23, ~"oh no"))
+ }
+}
+
+pub fn main() {
+ do xcc::oops::cond.trap(|_| xcc::Red).inside {
+ let t = SThunk { x : 10 };
+ assert_eq!(xcc::callback(t), xcc::Red)
+ }
+}
\ No newline at end of file
// xfail-fast
extern mod xcrate_unit_struct;
-use std::util;
-
static s1: xcrate_unit_struct::Struct = xcrate_unit_struct::Struct;
static s2: xcrate_unit_struct::Unit = xcrate_unit_struct::Unit;
static s3: xcrate_unit_struct::Unit =
builder.future_result(|r| { result = Some(r); });
builder.spawn(child);
error!("1");
- task::yield();
+ task::deschedule();
error!("2");
- task::yield();
+ task::deschedule();
error!("3");
result.unwrap().recv();
}
fn child() {
- error!("4"); task::yield(); error!("5"); task::yield(); error!("6");
+ error!("4"); task::deschedule(); error!("5"); task::deschedule(); error!("6");
}
builder.future_result(|r| { result = Some(r); });
builder.spawn(child);
error!("1");
- task::yield();
+ task::deschedule();
result.unwrap().recv();
}
pub fn main() {
let mut i: int = 0;
- while i < 100 { i = i + 1; error!(i); task::yield(); }
+ while i < 100 { i = i + 1; error!(i); task::deschedule(); }
}
projects / rust.git / commitdiff