rustc for squiid. https://github.com/rust-lang/rust

Find a file

bors f647ccc79c auto merge of #9695 : huonw/rust/rand2, r=alexcrichton A pile of changes to `std::rand`: - Add the 64-bit variant of the ISAAC Rng. This also splits the `Rng.next() -> u32` method into `Rng.next_u32() -> u32` and `Rng.next_u64() -> u64` to be able to actually take advantage of the wider numbers. They have default implementations in terms of each other. (This is ~2× faster than the 32 bit one for generating anything larger than a `u32` on 64-bit computers.) - Add `ReaderRng` which just wraps a reader as an RNG, useful for `/dev/urandom`, `/dev/random`, `/dev/hwrng`, etc. This also adds the overrideable `fill_bytes` method to `Rng`, since readers can "generate" randomness more than just 8 bytes at a time. - Add an interface to `/dev/urandom` (and the windows API) that implements `Rng` (`os::OSRng`) so that it is a first-class randomness source. This means that experimenting with things like seeding hashmaps from it will be much easier. It deletes most of the C++ supporting the old form, except for thin wrappers around the Windows API; I don't have access to a windows with Rust other than the try branch. ( Note: on unices, this means that `OSRng` requires the runtime, so it's not possible to use it to seed the scheduler RNG; I've replaced it with direct libc calls for reading from `/dev/urandom`.) - Add the "blessed" `StdRng` which means users who just want a random number generator don't need to worry about the implementation details (which will make changing the underlying implementation from Isaac to something else will be easier, if this every happen). This actually changes between the 32 and 64-bit variants of Isaac depending on the platform at the moment. - Add a `SeedableRng` trait for random number generators that can be explicitly seeded, - Add the `ReseedingRng` wrapper for reseeding a RNG after a certain amount of randomness is emitted. (The method for reseeding is controlled via the `Reseeder` trait from the same module) - changes to the task rng: - uses `StdRng` - it will reseed itself every 32KB, that is, after outputting 32KB of random data it will read new data from the OS (via `OSRng`) - Implements `Rand` for `char`, and makes the `f32` and `f64` instances more reasonable (and more similar to most other languages I've looked at). - Documentation, examples and tests		2013-10-09 05:11:33 -07:00
doc	auto merge of #9674 : ben0x539/rust/raw-str, r=alexcrichton	2013-10-07 23:01:39 -07:00
man	rustdoc: Update the man page	2013-09-30 20:31:19 -07:00
mk	std::rand: make the windows OSRng more correct, remove some C++.	2013-10-09 22:22:42 +11:00
src	auto merge of #9695 : huonw/rust/rand2, r=alexcrichton	2013-10-09 05:11:33 -07:00
.gitattributes	stop fighting with rust logo filetype.	2013-09-25 23:52:08 +02:00
.gitignore
.gitmodules	Upgrade libuv to the current master (again)	2013-09-06 11:12:49 -07:00
.mailmap
AUTHORS.txt	Update AUTHORS.txt	2013-09-24 16:26:27 -07:00
configure	Build libuv/jemalloc only once (not per stage)	2013-10-08 14:26:56 -07:00
CONTRIBUTING.md	Update CONTRIBUTING.md	2013-06-13 15:41:34 -06:00
COPYRIGHT
LICENSE-APACHE
LICENSE-MIT
Makefile.in	Prevent leakage of fmt! into the compiler	2013-09-30 23:21:18 -07:00
README.md	Update version numbers to 0.8	2013-09-21 16:25:08 -07:00
RELEASES.txt	0.8 will be in September	2013-09-25 11:38:44 -07:00

README.md

The Rust Programming Language

This is a compiler for Rust, including standard libraries, tools and documentation.

Quick Start

Windows

Download and use the installer.
Read the tutorial.
Enjoy!

Note: Windows users should read the detailed getting started notes on the wiki. Even when using the binary installer the Windows build requires a MinGW installation, the precise details of which are not discussed here.

Linux / OS X

Install the prerequisites (if not already installed)
- g++ 4.4 or clang++ 3.x
- python 2.6 or later (but not 3.x)
- perl 5.0 or later
- gnu make 3.81 or later
- curl
Download and build Rust You can either download a tarball or build directly from the repo.

To build from the tarball do:
```
 $ curl -O http://static.rust-lang.org/dist/rust-0.8.tar.gz
 $ tar -xzf rust-0.8.tar.gz
 $ cd rust-0.8
```
Or to build from the repo do:
```
 $ git clone https://github.com/mozilla/rust.git
 $ cd rust
```
Now that you have Rust's source code, you can configure and build it:
```
 $ ./configure
 $ make && make install
```
You may need to use sudo make install if you do not normally have permission to modify the destination directory. The install locations can be adjusted by passing a --prefix argument to configure. Various other options are also supported, pass --help for more information on them.

When complete, make install will place several programs into /usr/local/bin: rustc, the Rust compiler; rustdoc, the API-documentation tool, and rustpkg, the Rust package manager and build system.
Read the tutorial.
Enjoy!

Notes

Since the Rust compiler is written in Rust, it must be built by a precompiled "snapshot" version of itself (made in an earlier state of development). As such, source builds require a connection to the Internet, to fetch snapshots, and an OS that can execute the available snapshot binaries.

Snapshot binaries are currently built and tested on several platforms:

Windows (7, Server 2008 R2), x86 only
Linux (various distributions), x86 and x86-64
OSX 10.6 ("Snow Leopard") or greater, x86 and x86-64

You may find that other platforms work, but these are our "tier 1" supported build environments that are most likely to work.

Rust currently needs about 1.8G of RAM to build without swapping; if it hits swap, it will take a very long time to build.

There is lots more documentation in the wiki.

License

Rust is primarily distributed under the terms of both the MIT license and the Apache License (Version 2.0), with portions covered by various BSD-like licenses.