mirror of
https://github.com/servo/servo.git
synced 2025-08-06 06:00:15 +01:00
Rust upgrade to rustc hash b03a2755193cd756583bcf5831cf4545d75ecb8a
This commit is contained in:
parent
26045d7fcb
commit
d1b433a3b3
160 changed files with 1427 additions and 1162 deletions
|
@ -6,10 +6,10 @@
|
|||
|
||||
use string_cache::{Atom, Namespace};
|
||||
|
||||
static KEY_SIZE: uint = 12;
|
||||
static ARRAY_SIZE: uint = 1 << KEY_SIZE;
|
||||
static KEY_MASK: u32 = (1 << KEY_SIZE) - 1;
|
||||
static KEY_SHIFT: uint = 16;
|
||||
const KEY_SIZE: uint = 12;
|
||||
const ARRAY_SIZE: uint = 1 << KEY_SIZE;
|
||||
const KEY_MASK: u32 = (1 << KEY_SIZE) - 1;
|
||||
const KEY_SHIFT: uint = 16;
|
||||
|
||||
/// A counting Bloom filter with 8-bit counters. For now we assume
|
||||
/// that having two hash functions is enough, but we may revisit that
|
||||
|
@ -334,4 +334,3 @@ mod bench {
|
|||
})
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -2,7 +2,8 @@
|
|||
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
||||
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
||||
|
||||
use std::collections::hashmap::HashMap;
|
||||
use std::collections::HashMap;
|
||||
use std::collections::hash_map::{Occupied, Vacant};
|
||||
use rand::Rng;
|
||||
use std::hash::{Hash, sip};
|
||||
use std::rand::task_rng;
|
||||
|
@ -36,14 +37,21 @@ impl<K: Clone + PartialEq + Eq + Hash, V: Clone> Cache<K,V> for HashCache<K,V> {
|
|||
}
|
||||
|
||||
fn find(&mut self, key: &K) -> Option<V> {
|
||||
match self.entries.find(key) {
|
||||
match self.entries.get(key) {
|
||||
Some(v) => Some(v.clone()),
|
||||
None => None,
|
||||
}
|
||||
}
|
||||
|
||||
fn find_or_create(&mut self, key: &K, blk: |&K| -> V) -> V {
|
||||
self.entries.find_or_insert_with(key.clone(), blk).clone()
|
||||
match self.entries.entry(key.clone()) {
|
||||
Occupied(occupied) => {
|
||||
(*occupied.get()).clone()
|
||||
}
|
||||
Vacant(vacant) => {
|
||||
(*vacant.set(blk(key))).clone()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn evict_all(&mut self) {
|
||||
|
@ -53,7 +61,7 @@ impl<K: Clone + PartialEq + Eq + Hash, V: Clone> Cache<K,V> for HashCache<K,V> {
|
|||
}
|
||||
|
||||
impl<K,V> HashCache<K,V> where K: Clone + PartialEq + Eq + Hash, V: Clone {
|
||||
pub fn find_equiv<'a,Q>(&'a self, key: &Q) -> Option<&'a V> where Q: Hash + Equiv<K> {
|
||||
pub fn find_equiv<'a,Sized? Q>(&'a self, key: &Q) -> Option<&'a V> where Q: Hash + Equiv<K> {
|
||||
self.entries.find_equiv(key)
|
||||
}
|
||||
}
|
||||
|
@ -171,7 +179,7 @@ impl<K:Clone+PartialEq+Hash,V:Clone> SimpleHashCache<K,V> {
|
|||
impl<K:Clone+PartialEq+Hash,V:Clone> Cache<K,V> for SimpleHashCache<K,V> {
|
||||
fn insert(&mut self, key: K, value: V) {
|
||||
let bucket_index = self.bucket_for_key(&key);
|
||||
*self.entries.get_mut(bucket_index) = Some((key, value));
|
||||
self.entries[bucket_index] = Some((key, value));
|
||||
}
|
||||
|
||||
fn find(&mut self, key: &K) -> Option<V> {
|
||||
|
|
|
@ -24,7 +24,7 @@ struct RawNode<T> {
|
|||
#[unsafe_destructor]
|
||||
impl<T> Drop for RawDList<T> {
|
||||
fn drop(&mut self) {
|
||||
fail!("shouldn't happen")
|
||||
panic!("shouldn't happen")
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -36,7 +36,7 @@ pub fn split<T>(list: &mut DList<T>) -> DList<T> {
|
|||
};
|
||||
|
||||
if list.length == 0 {
|
||||
fail!("split_dlist(): empty list")
|
||||
panic!("split_dlist(): empty list")
|
||||
}
|
||||
let head_node = mem::replace(&mut list.head, ptr::null_mut());
|
||||
let head_list = RawDList {
|
||||
|
@ -96,4 +96,3 @@ pub fn append_from<T>(this: &mut DList<T>, other: &mut DList<T>) {
|
|||
other.length = 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -19,7 +19,7 @@ pub struct FnvHasher;
|
|||
pub struct FnvState(u64);
|
||||
|
||||
impl Hasher<FnvState> for FnvHasher {
|
||||
fn hash<T: Hash<FnvState>>(&self, t: &T) -> u64 {
|
||||
fn hash<Sized? T: Hash<FnvState>>(&self, t: &T) -> u64 {
|
||||
let mut state = FnvState(0xcbf29ce484222325);
|
||||
t.hash(&mut state);
|
||||
let FnvState(ret) = state;
|
||||
|
|
|
@ -28,6 +28,7 @@ use std::fmt;
|
|||
///
|
||||
/// The ratio between ScreenPx and DevicePixel for a given display be found by calling
|
||||
/// `servo::windowing::WindowMethods::hidpi_factor`.
|
||||
#[deriving(Show)]
|
||||
pub enum ScreenPx {}
|
||||
|
||||
/// One CSS "px" in the coordinate system of the "initial viewport":
|
||||
|
@ -39,7 +40,7 @@ pub enum ScreenPx {}
|
|||
///
|
||||
/// At the default zoom level of 100%, one PagePx is equal to one ScreenPx. However, if the
|
||||
/// document is zoomed in or out then this scale may be larger or smaller.
|
||||
#[deriving(Encodable)]
|
||||
#[deriving(Encodable, Show)]
|
||||
pub enum ViewportPx {}
|
||||
|
||||
/// One CSS "px" in the root coordinate system for the content document.
|
||||
|
@ -48,7 +49,7 @@ pub enum ViewportPx {}
|
|||
/// This is the mobile-style "pinch zoom" that enlarges content without reflowing it. When the
|
||||
/// viewport zoom is not equal to 1.0, then the layout viewport is no longer the same physical size
|
||||
/// as the viewable area.
|
||||
#[deriving(Encodable)]
|
||||
#[deriving(Encodable, Show)]
|
||||
pub enum PagePx {}
|
||||
|
||||
// In summary, the hierarchy of pixel units and the factors to convert from one to the next:
|
||||
|
@ -95,8 +96,8 @@ pub static MAX_RECT: Rect<Au> = Rect {
|
|||
}
|
||||
};
|
||||
|
||||
pub static MIN_AU: Au = Au(i32::MIN);
|
||||
pub static MAX_AU: Au = Au(i32::MAX);
|
||||
pub const MIN_AU: Au = Au(i32::MIN);
|
||||
pub const MAX_AU: Au = Au(i32::MAX);
|
||||
|
||||
impl<E, S: Encoder<E>> Encodable<S, E> for Au {
|
||||
fn encode(&self, e: &mut S) -> Result<(), E> {
|
||||
|
@ -319,4 +320,3 @@ pub fn f32_rect_to_au_rect(rect: Rect<f32>) -> Rect<Au> {
|
|||
Rect(Point2D(Au::from_frac32_px(rect.origin.x), Au::from_frac32_px(rect.origin.y)),
|
||||
Size2D(Au::from_frac32_px(rect.size.width), Au::from_frac32_px(rect.size.height)))
|
||||
}
|
||||
|
||||
|
|
|
@ -4,13 +4,13 @@
|
|||
|
||||
#![feature(default_type_params,macro_rules,unsafe_destructor)]
|
||||
|
||||
#![deny(unused_imports, unused_variable)]
|
||||
#![deny(unused_imports)]
|
||||
#![deny(unused_variables)]
|
||||
|
||||
#![feature(phase)]
|
||||
#[phase(plugin, link)]
|
||||
extern crate log;
|
||||
|
||||
extern crate debug;
|
||||
extern crate alloc;
|
||||
extern crate collections;
|
||||
extern crate geom;
|
||||
|
|
|
@ -12,39 +12,39 @@ use std::num::Zero;
|
|||
bitflags!(
|
||||
#[deriving(Encodable)]
|
||||
flags WritingMode: u8 {
|
||||
static FlagRTL = 1 << 0,
|
||||
static FlagVertical = 1 << 1,
|
||||
static FlagVerticalLR = 1 << 2,
|
||||
static FlagSidewaysLeft = 1 << 3
|
||||
const FLAG_RTL = 1 << 0,
|
||||
const FLAG_VERTICAL = 1 << 1,
|
||||
const FLAG_VERTICAL_LR = 1 << 2,
|
||||
const FLAG_SIDEWAYS_LEFT = 1 << 3
|
||||
}
|
||||
)
|
||||
|
||||
impl WritingMode {
|
||||
#[inline]
|
||||
pub fn is_vertical(&self) -> bool {
|
||||
self.intersects(FlagVertical)
|
||||
self.intersects(FLAG_VERTICAL)
|
||||
}
|
||||
|
||||
/// Asuming .is_vertical(), does the block direction go left to right?
|
||||
#[inline]
|
||||
pub fn is_vertical_lr(&self) -> bool {
|
||||
self.intersects(FlagVerticalLR)
|
||||
self.intersects(FLAG_VERTICAL_LR)
|
||||
}
|
||||
|
||||
/// Asuming .is_vertical(), does the inline direction go top to bottom?
|
||||
#[inline]
|
||||
pub fn is_inline_tb(&self) -> bool {
|
||||
!(self.intersects(FlagSidewaysLeft) ^ self.intersects(FlagRTL))
|
||||
!(self.intersects(FLAG_SIDEWAYS_LEFT) ^ self.intersects(FLAG_RTL))
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn is_bidi_ltr(&self) -> bool {
|
||||
!self.intersects(FlagRTL)
|
||||
!self.intersects(FLAG_RTL)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn is_sideways_left(&self) -> bool {
|
||||
self.intersects(FlagSidewaysLeft)
|
||||
self.intersects(FLAG_SIDEWAYS_LEFT)
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -57,7 +57,7 @@ impl Show for WritingMode {
|
|||
} else {
|
||||
try!(write!(formatter, " RL"));
|
||||
}
|
||||
if self.intersects(FlagSidewaysLeft) {
|
||||
if self.intersects(FLAG_SIDEWAYS_LEFT) {
|
||||
try!(write!(formatter, " SidewaysL"));
|
||||
}
|
||||
} else {
|
||||
|
|
|
@ -198,13 +198,12 @@ fn get_resident() -> Option<u64> {
|
|||
resident_size()
|
||||
}
|
||||
|
||||
#[cfg(not(target_os="linux"), not(target_os = "macos"))]
|
||||
#[cfg(not(any(target_os="linux", target_os = "macos")))]
|
||||
fn get_vsize() -> Option<u64> {
|
||||
None
|
||||
}
|
||||
|
||||
#[cfg(not(target_os="linux"), not(target_os = "macos"))]
|
||||
#[cfg(not(any(target_os="linux", target_os = "macos")))]
|
||||
fn get_resident() -> Option<u64> {
|
||||
None
|
||||
}
|
||||
|
||||
|
|
|
@ -161,6 +161,10 @@ impl InstrumentedRuntime {
|
|||
}
|
||||
|
||||
impl Runtime for InstrumentedRuntime {
|
||||
fn stack_guard(&self) -> Option<uint> {
|
||||
self.inner.as_ref().unwrap().stack_guard()
|
||||
}
|
||||
|
||||
fn yield_now(mut self: Box<InstrumentedRuntime>, cur_task: Box<Task>) {
|
||||
self.inner.take().unwrap().yield_now(cur_task);
|
||||
self.put(None)
|
||||
|
|
|
@ -5,7 +5,7 @@
|
|||
//! Small vectors in various sizes. These store a certain number of elements inline and fall back
|
||||
//! to the heap for larger allocations.
|
||||
|
||||
use std::mem::init as i;
|
||||
use std::mem::zeroed as i;
|
||||
use std::cmp;
|
||||
use std::fmt;
|
||||
use std::intrinsics;
|
||||
|
@ -153,7 +153,7 @@ pub trait SmallVec<T> : SmallVecPrivate<T> {
|
|||
let last_index = self.len() - 1;
|
||||
|
||||
if (last_index as int) < 0 {
|
||||
fail!("overflow")
|
||||
panic!("overflow")
|
||||
}
|
||||
let end_ptr = self.begin().offset(last_index as int);
|
||||
|
||||
|
@ -239,7 +239,7 @@ pub trait SmallVec<T> : SmallVecPrivate<T> {
|
|||
}
|
||||
|
||||
fn fail_bounds_check(&self, index: uint) {
|
||||
fail!("index {} beyond length ({})", index, self.len())
|
||||
panic!("index {} beyond length ({})", index, self.len())
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -71,7 +71,7 @@ pub fn split_html_space_chars<'a>(s: &'a str) -> Filter<'a, &'a str, CharSplits<
|
|||
fn do_parse_integer<T: Iterator<char>>(input: T) -> Option<i64> {
|
||||
fn is_ascii_digit(c: &char) -> bool {
|
||||
match *c {
|
||||
'0'..'9' => true,
|
||||
'0'...'9' => true,
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
@ -152,7 +152,7 @@ pub fn parse_length(mut value: &str) -> LengthOrPercentageOrAuto {
|
|||
let (mut found_full_stop, mut found_percent) = (false, false);
|
||||
for (i, ch) in value.chars().enumerate() {
|
||||
match ch {
|
||||
'0'..'9' => continue,
|
||||
'0'...'9' => continue,
|
||||
'%' => {
|
||||
found_percent = true;
|
||||
end_index = i;
|
||||
|
|
|
@ -13,13 +13,13 @@ pub use self::imp::{initialize, get, enter, exit};
|
|||
bitflags! {
|
||||
#[deriving(Show)]
|
||||
flags TaskState: u32 {
|
||||
static Script = 0x01,
|
||||
static Layout = 0x02,
|
||||
static Render = 0x04,
|
||||
const SCRIPT = 0x01,
|
||||
const LAYOUT = 0x02,
|
||||
const RENDER = 0x04,
|
||||
|
||||
static InWorker = 0x0100,
|
||||
static InGC = 0x0200,
|
||||
static InHTMLParser = 0x0400,
|
||||
const IN_WORKER = 0x0100,
|
||||
const IN_GC = 0x0200,
|
||||
const IN_HTML_PARSER = 0x0400,
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -38,9 +38,9 @@ macro_rules! task_types ( ( $( $fun:ident = $flag:ident ; )* ) => (
|
|||
))
|
||||
|
||||
task_types! {
|
||||
is_script = Script;
|
||||
is_layout = Layout;
|
||||
is_render = Render;
|
||||
is_script = SCRIPT;
|
||||
is_layout = LAYOUT;
|
||||
is_render = RENDER;
|
||||
}
|
||||
|
||||
#[cfg(not(ndebug))]
|
||||
|
@ -52,14 +52,14 @@ mod imp {
|
|||
pub fn initialize(x: TaskState) {
|
||||
match STATE.replace(Some(x)) {
|
||||
None => (),
|
||||
Some(s) => fail!("Task state already initialized as {}", s),
|
||||
Some(s) => panic!("Task state already initialized as {}", s),
|
||||
};
|
||||
get(); // check the assertion below
|
||||
}
|
||||
|
||||
pub fn get() -> TaskState {
|
||||
let state = match STATE.get() {
|
||||
None => fail!("Task state not initialized"),
|
||||
None => panic!("Task state not initialized"),
|
||||
Some(s) => *s,
|
||||
};
|
||||
|
||||
|
|
|
@ -2,7 +2,7 @@
|
|||
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
||||
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
||||
|
||||
use std::sync::atomics::{AtomicUint, INIT_ATOMIC_UINT, SeqCst};
|
||||
use std::sync::atomic::{AtomicUint, INIT_ATOMIC_UINT, SeqCst};
|
||||
|
||||
static mut next_tid: AtomicUint = INIT_ATOMIC_UINT;
|
||||
|
||||
|
|
|
@ -4,7 +4,7 @@
|
|||
|
||||
//! Timing functions.
|
||||
|
||||
use collections::treemap::TreeMap;
|
||||
use collections::TreeMap;
|
||||
use std::comm::{Sender, channel, Receiver};
|
||||
use std::f64;
|
||||
use std::io::timer::sleep;
|
||||
|
@ -196,7 +196,7 @@ impl TimeProfiler {
|
|||
}
|
||||
|
||||
fn find_or_insert(&mut self, k: (TimeProfilerCategory, Option<TimerMetadata>), t: f64) {
|
||||
match self.buckets.find_mut(&k) {
|
||||
match self.buckets.get_mut(&k) {
|
||||
None => {},
|
||||
Some(v) => { v.push(t); return; },
|
||||
}
|
||||
|
|
|
@ -4,6 +4,9 @@
|
|||
|
||||
use std::cmp::{PartialOrd, PartialEq};
|
||||
|
||||
#[cfg(test)]
|
||||
use std::fmt::Show;
|
||||
|
||||
/// FIXME(pcwalton): Workaround for lack of unboxed closures. This is called in
|
||||
/// performance-critical code, so a closure is insufficient.
|
||||
pub trait Comparator<K,T> {
|
||||
|
@ -71,11 +74,11 @@ fn test_find_all_elems<T: PartialEq + PartialOrd + Eq + Ord>(arr: &[T]) {
|
|||
}
|
||||
|
||||
#[cfg(test)]
|
||||
fn test_miss_all_elems<T: PartialEq + PartialOrd + Eq + Ord>(arr: &[T], misses: &[T]) {
|
||||
fn test_miss_all_elems<T: PartialEq + PartialOrd + Eq + Ord + Show>(arr: &[T], misses: &[T]) {
|
||||
let mut i = 0;
|
||||
while i < misses.len() {
|
||||
let res = arr.binary_search_(&misses[i]);
|
||||
debug!("{:?} == {:?} ?", misses[i], res);
|
||||
debug!("{} == {} ?", misses[i], res);
|
||||
assert!(!test_match(&misses[i], arr.binary_search_(&misses[i])));
|
||||
i += 1;
|
||||
}
|
||||
|
|
|
@ -14,7 +14,7 @@ use libc::funcs::posix88::unistd::usleep;
|
|||
use rand::{Rng, XorShiftRng};
|
||||
use std::mem;
|
||||
use std::rand::weak_rng;
|
||||
use std::sync::atomics::{AtomicUint, SeqCst};
|
||||
use std::sync::atomic::{AtomicUint, SeqCst};
|
||||
use std::sync::deque::{Abort, BufferPool, Data, Empty, Stealer, Worker};
|
||||
|
||||
/// A unit of work.
|
||||
|
@ -82,7 +82,7 @@ impl<QueueData: Send, WorkData: Send> WorkerThread<QueueData, WorkData> {
|
|||
// Wait for a start message.
|
||||
let (mut deque, ref_count, queue_data) = match self.port.recv() {
|
||||
StartMsg(deque, ref_count, queue_data) => (deque, ref_count, queue_data),
|
||||
StopMsg => fail!("unexpected stop message"),
|
||||
StopMsg => panic!("unexpected stop message"),
|
||||
ExitMsg => return,
|
||||
};
|
||||
|
||||
|
@ -105,7 +105,7 @@ impl<QueueData: Send, WorkData: Send> WorkerThread<QueueData, WorkData> {
|
|||
let mut should_continue = true;
|
||||
loop {
|
||||
let victim = (self.rng.next_u32() as uint) % self.other_deques.len();
|
||||
match self.other_deques.get_mut(victim).steal() {
|
||||
match self.other_deques[victim].steal() {
|
||||
Empty | Abort => {
|
||||
// Continue.
|
||||
}
|
||||
|
@ -130,7 +130,7 @@ impl<QueueData: Send, WorkData: Send> WorkerThread<QueueData, WorkData> {
|
|||
break
|
||||
}
|
||||
Ok(ExitMsg) => return,
|
||||
Ok(_) => fail!("unexpected message"),
|
||||
Ok(_) => panic!("unexpected message"),
|
||||
_ => {}
|
||||
}
|
||||
|
||||
|
@ -239,7 +239,7 @@ impl<QueueData: Send, WorkData: Send> WorkQueue<QueueData, WorkData> {
|
|||
for i in range(0, thread_count) {
|
||||
for j in range(0, thread_count) {
|
||||
if i != j {
|
||||
threads.get_mut(i).other_deques.push(infos[j].thief.clone())
|
||||
threads[i].other_deques.push(infos[j].thief.clone())
|
||||
}
|
||||
}
|
||||
assert!(threads[i].other_deques.len() == thread_count - 1)
|
||||
|
@ -251,7 +251,7 @@ impl<QueueData: Send, WorkData: Send> WorkQueue<QueueData, WorkData> {
|
|||
spawn_named_native(
|
||||
format!("{} worker {}/{}", task_name, i+1, thread_count),
|
||||
proc() {
|
||||
task_state::initialize(state | task_state::InWorker);
|
||||
task_state::initialize(state | task_state::IN_WORKER);
|
||||
let mut thread = thread;
|
||||
thread.start()
|
||||
})
|
||||
|
@ -268,9 +268,10 @@ impl<QueueData: Send, WorkData: Send> WorkQueue<QueueData, WorkData> {
|
|||
/// Enqueues a block into the work queue.
|
||||
#[inline]
|
||||
pub fn push(&mut self, work_unit: WorkUnit<QueueData, WorkData>) {
|
||||
match self.workers.get_mut(0).deque {
|
||||
let deque = &mut self.workers[0].deque;
|
||||
match *deque {
|
||||
None => {
|
||||
fail!("tried to push a block but we don't have the deque?!")
|
||||
panic!("tried to push a block but we don't have the deque?!")
|
||||
}
|
||||
Some(ref mut deque) => deque.push(work_unit),
|
||||
}
|
||||
|
@ -297,8 +298,8 @@ impl<QueueData: Send, WorkData: Send> WorkQueue<QueueData, WorkData> {
|
|||
// Get our deques back.
|
||||
for _ in range(0, self.workers.len()) {
|
||||
match self.port.recv() {
|
||||
ReturnDequeMsg(index, deque) => self.workers.get_mut(index).deque = Some(deque),
|
||||
FinishedMsg => fail!("unexpected finished message!"),
|
||||
ReturnDequeMsg(index, deque) => self.workers[index].deque = Some(deque),
|
||||
FinishedMsg => panic!("unexpected finished message!"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue