file_name
large_stringlengths
4
69
prefix
large_stringlengths
0
26.7k
suffix
large_stringlengths
0
24.8k
middle
large_stringlengths
0
2.12k
fim_type
large_stringclasses
4 values
lib.rs
struct Lexer<'a> { src: &'a [u8], pos: usize } impl<'a> Lexer<'a> { fn new(src: &'a [u8]) -> Lexer { Lexer { src: src, pos: 0 } } } impl<'a> Lexer<'a> { fn ch(&self) -> u8 { self.src[self.pos] } fn
(&self) -> bool { self.pos >= self.src.len() } fn skip_ws(&mut self) -> usize { let prev_pos = self.pos; while self.valid_ws() { self.pos += 1; } self.pos - prev_pos } fn string(&mut self) -> Option<String> { let mut tok = Vec::<u8>::new(); loop { if self.eof() { break } match self.ch() { b' ' => break, b'\t' => break, b'\r' => break, b'\n' => break, b'"' => break, _ => () } tok.push(self.ch()); self.pos += 1; } match tok.len() { 0 => None, _ => Some(String::from_utf8(tok).unwrap()) } } fn quoted_string(&mut self) -> Option<String> { let mut tok = Vec::<u8>::new(); self.pos += 1; loop { if self.eof() { break; } match self.ch() { b'"' => { self.pos += 1; break; }, _ => () } tok.push(self.ch()); self.pos += 1; } match tok.len() { 0 => None, _ => Some(String::from_utf8(tok).unwrap()) } } fn valid_ws(&self) -> bool { if self.eof() { return false; } match self.ch() { b'' => true, b'\t' => true, b'\r' => true, b'\n' => true, _ => false } } } impl<'a> Iterator for Lexer<'a> { type Item = String; fn next(&mut self) -> Option<String> { self.skip_ws(); if self.eof() { return None; } match self.ch() { b'"' => self.quoted_string(), _ => self.string() } } } #[test] fn tokenize() { let src = b" foo bar \"a b\" baz "; let lexer = Lexer::new(src); let tokens: Vec<_> = lexer.collect(); assert_eq!(4, tokens.len()); assert_eq!("foo".to_string(), tokens[0]); assert_eq!("bar".to_string(), tokens[1]); assert_eq!("a b".to_string(), tokens[2]); assert_eq!("baz".to_string(), tokens[3]); }
eof
identifier_name
lib.rs
struct Lexer<'a> { src: &'a [u8], pos: usize } impl<'a> Lexer<'a> { fn new(src: &'a [u8]) -> Lexer
} impl<'a> Lexer<'a> { fn ch(&self) -> u8 { self.src[self.pos] } fn eof(&self) -> bool { self.pos >= self.src.len() } fn skip_ws(&mut self) -> usize { let prev_pos = self.pos; while self.valid_ws() { self.pos += 1; } self.pos - prev_pos } fn string(&mut self) -> Option<String> { let mut tok = Vec::<u8>::new(); loop { if self.eof() { break } match self.ch() { b' ' => break, b'\t' => break, b'\r' => break, b'\n' => break, b'"' => break, _ => () } tok.push(self.ch()); self.pos += 1; } match tok.len() { 0 => None, _ => Some(String::from_utf8(tok).unwrap()) } } fn quoted_string(&mut self) -> Option<String> { let mut tok = Vec::<u8>::new(); self.pos += 1; loop { if self.eof() { break; } match self.ch() { b'"' => { self.pos += 1; break; }, _ => () } tok.push(self.ch()); self.pos += 1; } match tok.len() { 0 => None, _ => Some(String::from_utf8(tok).unwrap()) } } fn valid_ws(&self) -> bool { if self.eof() { return false; } match self.ch() { b'' => true, b'\t' => true, b'\r' => true, b'\n' => true, _ => false } } } impl<'a> Iterator for Lexer<'a> { type Item = String; fn next(&mut self) -> Option<String> { self.skip_ws(); if self.eof() { return None; } match self.ch() { b'"' => self.quoted_string(), _ => self.string() } } } #[test] fn tokenize() { let src = b" foo bar \"a b\" baz "; let lexer = Lexer::new(src); let tokens: Vec<_> = lexer.collect(); assert_eq!(4, tokens.len()); assert_eq!("foo".to_string(), tokens[0]); assert_eq!("bar".to_string(), tokens[1]); assert_eq!("a b".to_string(), tokens[2]); assert_eq!("baz".to_string(), tokens[3]); }
{ Lexer { src: src, pos: 0 } }
identifier_body
lib.rs
struct Lexer<'a> { src: &'a [u8], pos: usize } impl<'a> Lexer<'a> { fn new(src: &'a [u8]) -> Lexer { Lexer { src: src, pos: 0 } } } impl<'a> Lexer<'a> { fn ch(&self) -> u8 { self.src[self.pos] } fn eof(&self) -> bool { self.pos >= self.src.len() } fn skip_ws(&mut self) -> usize { let prev_pos = self.pos; while self.valid_ws() { self.pos += 1; } self.pos - prev_pos } fn string(&mut self) -> Option<String> {
match self.ch() { b' ' => break, b'\t' => break, b'\r' => break, b'\n' => break, b'"' => break, _ => () } tok.push(self.ch()); self.pos += 1; } match tok.len() { 0 => None, _ => Some(String::from_utf8(tok).unwrap()) } } fn quoted_string(&mut self) -> Option<String> { let mut tok = Vec::<u8>::new(); self.pos += 1; loop { if self.eof() { break; } match self.ch() { b'"' => { self.pos += 1; break; }, _ => () } tok.push(self.ch()); self.pos += 1; } match tok.len() { 0 => None, _ => Some(String::from_utf8(tok).unwrap()) } } fn valid_ws(&self) -> bool { if self.eof() { return false; } match self.ch() { b'' => true, b'\t' => true, b'\r' => true, b'\n' => true, _ => false } } } impl<'a> Iterator for Lexer<'a> { type Item = String; fn next(&mut self) -> Option<String> { self.skip_ws(); if self.eof() { return None; } match self.ch() { b'"' => self.quoted_string(), _ => self.string() } } } #[test] fn tokenize() { let src = b" foo bar \"a b\" baz "; let lexer = Lexer::new(src); let tokens: Vec<_> = lexer.collect(); assert_eq!(4, tokens.len()); assert_eq!("foo".to_string(), tokens[0]); assert_eq!("bar".to_string(), tokens[1]); assert_eq!("a b".to_string(), tokens[2]); assert_eq!("baz".to_string(), tokens[3]); }
let mut tok = Vec::<u8>::new(); loop { if self.eof() { break }
random_line_split
base64.rs
#[allow(non_snake_case_functions)] #[allow(unnecessary_parens)] // Author - Vikram // Contact - @TheVikO_o // License - MIT mod Base64 { // Debug Module pub mod Debug { use std::str; // Print bytes as UTF-8 string pub fn PrintBytes(data: Vec<u8>) { println!("{}", str::from_utf8(data.as_slice())); } } // Encode array of u8 bytes pub fn EncodeBytes(source: &[u8])->Vec<u8> { let bytes = source; let mut i =0; let mut output:Vec<u8> = vec![]; let maxLen = bytes.len(); while i < maxLen { let b1 = (bytes[i] & 0b11111100) >> 2; output.push(BaseIndex(b1)); if (i + 1) < maxLen { let b2 = (((bytes[i] & 0b11) << 4) | ((bytes[i+1] & 0b11110000) >> 4)); output.push(BaseIndex(b2)); if (i + 2) < maxLen { let b3 = (((bytes[i+1] & 0b1111) << 2) | ((bytes[i+2] & 0b11000000) >> 6)); output.push(BaseIndex(b3)); let b4 = bytes[i+2] & 0b111111; output.push(BaseIndex(b4)); } else { let b3 = ((bytes[i+1] & 0b1111) << 2); output.push(BaseIndex(b3)); output.push(b'='); } } else { output.push(BaseIndex(((bytes[i] & 0b11) << 4))); output.push(b'='); output.push(b'='); } i += 3; } output } // Encode str pub fn EncodeStr(source: &str) -> Vec<u8> { EncodeBytes(source.as_bytes()) } // Decode array of u8 bytes pub fn DecodeBytes(source:&[u8]) -> Vec<u8> { let bytes = source; let mut i =0; let mut output:Vec<u8> = vec![]; let maxLen = bytes.len(); if source.len() % 4!= 0 { return output; } while i < maxLen { let value1:u8 = BaseIndexToByte(bytes[i]); let value2:u8 = BaseIndexToByte(bytes[i+1]); let value3:u8 = BaseIndexToByte(bytes[i+2]); let value4:u8 = BaseIndexToByte(bytes[i+3]); let b1: u8 = value1 << 2 | (value2 & 0b00110000) >> 4; let b2: u8 = (value2 & 0b1111) << 4 | (value3 & 0b111100) >> 2; let b3: u8 = (value3 & 0b11) << 6 | value4; output.push(b1); output.push(b2); output.push(b3); i += 4; } output } // Decode str pub fn
(source:&str)->Vec<u8>{ DecodeBytes(source.as_bytes()) } // Convert byte to base64 rep fn BaseIndex(index:u8) -> u8 { match index { 62 => {b'+'} 63 => {b'/'} 0..25 => { b'A' + index } 26..51 => { b'a' + index - 26 } _ => { b'0' + index - 52 } } } // Convert base64 rep to byte fn BaseIndexToByte(source:u8)->u8{ match source { b'+' => { 62 } b'/' => { 63 } b'A'..b'Z' => { source - b'A'} b'a'..b'z' => { 26 + source - b'a'} b'0'..b'9' => { 52 + source - b'0'} _ => { 0 } } } } // Some tests fn main() { let mut encoded = ::Base64::EncodeStr("Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut"); ::Base64::Debug::PrintBytes(encoded); let mut decoded = ::Base64::DecodeStr("TG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNlY3RldHVyIGFkaXBpc2ljaW5nIGVsaXQsIHNlZCBkbyBlaXVzbW9kIHRlbXBvciBpbmNpZGlkdW50IHV0"); ::Base64::Debug::PrintBytes(decoded); encoded = ::Base64::EncodeStr("ab"); ::Base64::Debug::PrintBytes(encoded); decoded = ::Base64::DecodeStr("YWI="); ::Base64::Debug::PrintBytes(decoded); encoded = ::Base64::EncodeStr("easure."); ::Base64::Debug::PrintBytes(encoded); decoded = ::Base64::DecodeStr("ZWFzdXJlLg=="); ::Base64::Debug::PrintBytes(decoded); encoded = ::Base64::EncodeStr("C:\\Users\\AppData\\Local\\Viky Notes\\VikyNotes.exe"); ::Base64::Debug::PrintBytes(encoded); decoded = ::Base64::DecodeStr("QzpcVXNlcnNcQXBwRGF0YVxMb2NhbFxWaWt5IE5vdGVzXFZpa3lOb3Rlcy5leGU="); ::Base64::Debug::PrintBytes(decoded); decoded = ::Base64::DecodeStr("TW"); ::Base64::Debug::PrintBytes(decoded); }
DecodeStr
identifier_name
base64.rs
#[allow(non_snake_case_functions)] #[allow(unnecessary_parens)] // Author - Vikram // Contact - @TheVikO_o // License - MIT mod Base64 { // Debug Module pub mod Debug { use std::str; // Print bytes as UTF-8 string pub fn PrintBytes(data: Vec<u8>) { println!("{}", str::from_utf8(data.as_slice())); } } // Encode array of u8 bytes pub fn EncodeBytes(source: &[u8])->Vec<u8> { let bytes = source; let mut i =0; let mut output:Vec<u8> = vec![]; let maxLen = bytes.len(); while i < maxLen { let b1 = (bytes[i] & 0b11111100) >> 2; output.push(BaseIndex(b1)); if (i + 1) < maxLen { let b2 = (((bytes[i] & 0b11) << 4) | ((bytes[i+1] & 0b11110000) >> 4)); output.push(BaseIndex(b2)); if (i + 2) < maxLen { let b3 = (((bytes[i+1] & 0b1111) << 2) | ((bytes[i+2] & 0b11000000) >> 6)); output.push(BaseIndex(b3)); let b4 = bytes[i+2] & 0b111111; output.push(BaseIndex(b4)); } else { let b3 = ((bytes[i+1] & 0b1111) << 2); output.push(BaseIndex(b3)); output.push(b'='); } } else { output.push(BaseIndex(((bytes[i] & 0b11) << 4))); output.push(b'='); output.push(b'='); } i += 3; } output } // Encode str pub fn EncodeStr(source: &str) -> Vec<u8> { EncodeBytes(source.as_bytes()) } // Decode array of u8 bytes pub fn DecodeBytes(source:&[u8]) -> Vec<u8> { let bytes = source; let mut i =0; let mut output:Vec<u8> = vec![]; let maxLen = bytes.len(); if source.len() % 4!= 0 { return output; } while i < maxLen { let value1:u8 = BaseIndexToByte(bytes[i]); let value2:u8 = BaseIndexToByte(bytes[i+1]); let value3:u8 = BaseIndexToByte(bytes[i+2]); let value4:u8 = BaseIndexToByte(bytes[i+3]); let b1: u8 = value1 << 2 | (value2 & 0b00110000) >> 4; let b2: u8 = (value2 & 0b1111) << 4 | (value3 & 0b111100) >> 2; let b3: u8 = (value3 & 0b11) << 6 | value4; output.push(b1); output.push(b2); output.push(b3); i += 4; } output } // Decode str pub fn DecodeStr(source:&str)->Vec<u8>{ DecodeBytes(source.as_bytes()) } // Convert byte to base64 rep fn BaseIndex(index:u8) -> u8 { match index { 62 => {b'+'} 63 => {b'/'} 0..25 => { b'A' + index } 26..51 => { b'a' + index - 26 } _ => { b'0' + index - 52 } } } // Convert base64 rep to byte fn BaseIndexToByte(source:u8)->u8{ match source { b'+' => { 62 } b'/' => { 63 } b'A'..b'Z' => { source - b'A'}
} } // Some tests fn main() { let mut encoded = ::Base64::EncodeStr("Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut"); ::Base64::Debug::PrintBytes(encoded); let mut decoded = ::Base64::DecodeStr("TG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNlY3RldHVyIGFkaXBpc2ljaW5nIGVsaXQsIHNlZCBkbyBlaXVzbW9kIHRlbXBvciBpbmNpZGlkdW50IHV0"); ::Base64::Debug::PrintBytes(decoded); encoded = ::Base64::EncodeStr("ab"); ::Base64::Debug::PrintBytes(encoded); decoded = ::Base64::DecodeStr("YWI="); ::Base64::Debug::PrintBytes(decoded); encoded = ::Base64::EncodeStr("easure."); ::Base64::Debug::PrintBytes(encoded); decoded = ::Base64::DecodeStr("ZWFzdXJlLg=="); ::Base64::Debug::PrintBytes(decoded); encoded = ::Base64::EncodeStr("C:\\Users\\AppData\\Local\\Viky Notes\\VikyNotes.exe"); ::Base64::Debug::PrintBytes(encoded); decoded = ::Base64::DecodeStr("QzpcVXNlcnNcQXBwRGF0YVxMb2NhbFxWaWt5IE5vdGVzXFZpa3lOb3Rlcy5leGU="); ::Base64::Debug::PrintBytes(decoded); decoded = ::Base64::DecodeStr("TW"); ::Base64::Debug::PrintBytes(decoded); }
b'a'..b'z' => { 26 + source - b'a'} b'0'..b'9' => { 52 + source - b'0'} _ => { 0 } }
random_line_split
base64.rs
#[allow(non_snake_case_functions)] #[allow(unnecessary_parens)] // Author - Vikram // Contact - @TheVikO_o // License - MIT mod Base64 { // Debug Module pub mod Debug { use std::str; // Print bytes as UTF-8 string pub fn PrintBytes(data: Vec<u8>) { println!("{}", str::from_utf8(data.as_slice())); } } // Encode array of u8 bytes pub fn EncodeBytes(source: &[u8])->Vec<u8> { let bytes = source; let mut i =0; let mut output:Vec<u8> = vec![]; let maxLen = bytes.len(); while i < maxLen { let b1 = (bytes[i] & 0b11111100) >> 2; output.push(BaseIndex(b1)); if (i + 1) < maxLen { let b2 = (((bytes[i] & 0b11) << 4) | ((bytes[i+1] & 0b11110000) >> 4)); output.push(BaseIndex(b2)); if (i + 2) < maxLen { let b3 = (((bytes[i+1] & 0b1111) << 2) | ((bytes[i+2] & 0b11000000) >> 6)); output.push(BaseIndex(b3)); let b4 = bytes[i+2] & 0b111111; output.push(BaseIndex(b4)); } else { let b3 = ((bytes[i+1] & 0b1111) << 2); output.push(BaseIndex(b3)); output.push(b'='); } } else { output.push(BaseIndex(((bytes[i] & 0b11) << 4))); output.push(b'='); output.push(b'='); } i += 3; } output } // Encode str pub fn EncodeStr(source: &str) -> Vec<u8> { EncodeBytes(source.as_bytes()) } // Decode array of u8 bytes pub fn DecodeBytes(source:&[u8]) -> Vec<u8> { let bytes = source; let mut i =0; let mut output:Vec<u8> = vec![]; let maxLen = bytes.len(); if source.len() % 4!= 0 { return output; } while i < maxLen { let value1:u8 = BaseIndexToByte(bytes[i]); let value2:u8 = BaseIndexToByte(bytes[i+1]); let value3:u8 = BaseIndexToByte(bytes[i+2]); let value4:u8 = BaseIndexToByte(bytes[i+3]); let b1: u8 = value1 << 2 | (value2 & 0b00110000) >> 4; let b2: u8 = (value2 & 0b1111) << 4 | (value3 & 0b111100) >> 2; let b3: u8 = (value3 & 0b11) << 6 | value4; output.push(b1); output.push(b2); output.push(b3); i += 4; } output } // Decode str pub fn DecodeStr(source:&str)->Vec<u8>{ DecodeBytes(source.as_bytes()) } // Convert byte to base64 rep fn BaseIndex(index:u8) -> u8
// Convert base64 rep to byte fn BaseIndexToByte(source:u8)->u8{ match source { b'+' => { 62 } b'/' => { 63 } b'A'..b'Z' => { source - b'A'} b'a'..b'z' => { 26 + source - b'a'} b'0'..b'9' => { 52 + source - b'0'} _ => { 0 } } } } // Some tests fn main() { let mut encoded = ::Base64::EncodeStr("Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut"); ::Base64::Debug::PrintBytes(encoded); let mut decoded = ::Base64::DecodeStr("TG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNlY3RldHVyIGFkaXBpc2ljaW5nIGVsaXQsIHNlZCBkbyBlaXVzbW9kIHRlbXBvciBpbmNpZGlkdW50IHV0"); ::Base64::Debug::PrintBytes(decoded); encoded = ::Base64::EncodeStr("ab"); ::Base64::Debug::PrintBytes(encoded); decoded = ::Base64::DecodeStr("YWI="); ::Base64::Debug::PrintBytes(decoded); encoded = ::Base64::EncodeStr("easure."); ::Base64::Debug::PrintBytes(encoded); decoded = ::Base64::DecodeStr("ZWFzdXJlLg=="); ::Base64::Debug::PrintBytes(decoded); encoded = ::Base64::EncodeStr("C:\\Users\\AppData\\Local\\Viky Notes\\VikyNotes.exe"); ::Base64::Debug::PrintBytes(encoded); decoded = ::Base64::DecodeStr("QzpcVXNlcnNcQXBwRGF0YVxMb2NhbFxWaWt5IE5vdGVzXFZpa3lOb3Rlcy5leGU="); ::Base64::Debug::PrintBytes(decoded); decoded = ::Base64::DecodeStr("TW"); ::Base64::Debug::PrintBytes(decoded); }
{ match index { 62 => {b'+'} 63 => {b'/'} 0..25 => { b'A' + index } 26..51 => { b'a' + index - 26 } _ => { b'0' + index - 52 } } }
identifier_body
base64.rs
#[allow(non_snake_case_functions)] #[allow(unnecessary_parens)] // Author - Vikram // Contact - @TheVikO_o // License - MIT mod Base64 { // Debug Module pub mod Debug { use std::str; // Print bytes as UTF-8 string pub fn PrintBytes(data: Vec<u8>) { println!("{}", str::from_utf8(data.as_slice())); } } // Encode array of u8 bytes pub fn EncodeBytes(source: &[u8])->Vec<u8> { let bytes = source; let mut i =0; let mut output:Vec<u8> = vec![]; let maxLen = bytes.len(); while i < maxLen { let b1 = (bytes[i] & 0b11111100) >> 2; output.push(BaseIndex(b1)); if (i + 1) < maxLen { let b2 = (((bytes[i] & 0b11) << 4) | ((bytes[i+1] & 0b11110000) >> 4)); output.push(BaseIndex(b2)); if (i + 2) < maxLen { let b3 = (((bytes[i+1] & 0b1111) << 2) | ((bytes[i+2] & 0b11000000) >> 6)); output.push(BaseIndex(b3)); let b4 = bytes[i+2] & 0b111111; output.push(BaseIndex(b4)); } else { let b3 = ((bytes[i+1] & 0b1111) << 2); output.push(BaseIndex(b3)); output.push(b'='); } } else
i += 3; } output } // Encode str pub fn EncodeStr(source: &str) -> Vec<u8> { EncodeBytes(source.as_bytes()) } // Decode array of u8 bytes pub fn DecodeBytes(source:&[u8]) -> Vec<u8> { let bytes = source; let mut i =0; let mut output:Vec<u8> = vec![]; let maxLen = bytes.len(); if source.len() % 4!= 0 { return output; } while i < maxLen { let value1:u8 = BaseIndexToByte(bytes[i]); let value2:u8 = BaseIndexToByte(bytes[i+1]); let value3:u8 = BaseIndexToByte(bytes[i+2]); let value4:u8 = BaseIndexToByte(bytes[i+3]); let b1: u8 = value1 << 2 | (value2 & 0b00110000) >> 4; let b2: u8 = (value2 & 0b1111) << 4 | (value3 & 0b111100) >> 2; let b3: u8 = (value3 & 0b11) << 6 | value4; output.push(b1); output.push(b2); output.push(b3); i += 4; } output } // Decode str pub fn DecodeStr(source:&str)->Vec<u8>{ DecodeBytes(source.as_bytes()) } // Convert byte to base64 rep fn BaseIndex(index:u8) -> u8 { match index { 62 => {b'+'} 63 => {b'/'} 0..25 => { b'A' + index } 26..51 => { b'a' + index - 26 } _ => { b'0' + index - 52 } } } // Convert base64 rep to byte fn BaseIndexToByte(source:u8)->u8{ match source { b'+' => { 62 } b'/' => { 63 } b'A'..b'Z' => { source - b'A'} b'a'..b'z' => { 26 + source - b'a'} b'0'..b'9' => { 52 + source - b'0'} _ => { 0 } } } } // Some tests fn main() { let mut encoded = ::Base64::EncodeStr("Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut"); ::Base64::Debug::PrintBytes(encoded); let mut decoded = ::Base64::DecodeStr("TG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNlY3RldHVyIGFkaXBpc2ljaW5nIGVsaXQsIHNlZCBkbyBlaXVzbW9kIHRlbXBvciBpbmNpZGlkdW50IHV0"); ::Base64::Debug::PrintBytes(decoded); encoded = ::Base64::EncodeStr("ab"); ::Base64::Debug::PrintBytes(encoded); decoded = ::Base64::DecodeStr("YWI="); ::Base64::Debug::PrintBytes(decoded); encoded = ::Base64::EncodeStr("easure."); ::Base64::Debug::PrintBytes(encoded); decoded = ::Base64::DecodeStr("ZWFzdXJlLg=="); ::Base64::Debug::PrintBytes(decoded); encoded = ::Base64::EncodeStr("C:\\Users\\AppData\\Local\\Viky Notes\\VikyNotes.exe"); ::Base64::Debug::PrintBytes(encoded); decoded = ::Base64::DecodeStr("QzpcVXNlcnNcQXBwRGF0YVxMb2NhbFxWaWt5IE5vdGVzXFZpa3lOb3Rlcy5leGU="); ::Base64::Debug::PrintBytes(decoded); decoded = ::Base64::DecodeStr("TW"); ::Base64::Debug::PrintBytes(decoded); }
{ output.push(BaseIndex(((bytes[i] & 0b11) << 4))); output.push(b'='); output.push(b'='); }
conditional_block
bitboard.rs
// use std::num::Int; pub type Bitboard = u32; pub trait BitMove { fn up_left(&self) -> Self; fn up_right(&self) -> Self; fn down_left(&self) -> Self; fn down_right(&self) -> Self; fn is(&self) -> bool; } pub const S: [Bitboard; 32] = [ 1 << 18, 1 << 12, 1 << 6, 1 << 0,
1 << 3, 1 << 29, 1 << 23, 1 << 17, 1 << 10, 1 << 4, 1 << 30, 1 << 24, 1 << 11, 1 << 05, 1 << 31, 1 << 25]; pub const BP_INIT: Bitboard = S[0] | S[1] | S[2] | S[3] | S[4] | S[5] | S[6] | S[7] | S[8] | S[9] | S[10] | S[11]; pub const WP_INIT: Bitboard = S[20] | S[21] | S[22] | S[23] | S[24] | S[25] | S[26] | S[27] | S[28] | S[29] | S[30] | S[31]; pub const ROW_1: Bitboard = S[0] | S[1] | S[2] | S[3]; pub const ROW_2: Bitboard = S[4] | S[5] | S[6] | S[7]; pub const ROW_7: Bitboard = S[24] | S[25] | S[26] | S[27]; pub const ROW_8: Bitboard = S[28] | S[29] | S[30] | S[31]; pub const CAN_UPLEFT: Bitboard =!(S[0] | S[8] | S[16] | S[24] | ROW_8); pub const CAN_UPRIGHT: Bitboard =!(S[7] | S[15] | S[23] | S[31] | ROW_8); pub const CAN_DOWNLEFT: Bitboard =!(S[0] | S[8] | S[16] | S[24] | ROW_1); pub const CAN_DOWNRIGHT: Bitboard =!(S[7] | S[15] | S[23] | S[31] | ROW_1); #[derive(Clone, PartialEq, Show, Copy)] pub struct Move { pub src: u16, pub dst: u16, pub jump: bool, __dummy: () } #[derive(Clone, PartialEq, Show, Copy)] pub enum Direction{ UpLeft, UpRight, DownLeft, DownRight } impl Move { pub fn new(src: u16, dst: u16, jump: bool) -> Move { assert!(src < 32); assert!(dst < 32); Move { src: src, dst: dst, jump: jump, __dummy: () } } pub fn calc_direction(&self) -> Option<Direction> { let (src, dst) = (S[self.src as usize], S[self.dst as usize]); if src.up_left() ^ dst == 0 { Some(Direction::UpLeft) } else if src.up_right() ^ dst == 0 { Some(Direction::UpRight) } else if src.down_right() ^ dst == 0 { Some(Direction::DownRight) } else if src.down_left() ^ dst == 0 { Some(Direction::DownLeft) } else { None } } } #[derive(Clone, Copy)] pub enum Cell { Empty = 0, Pw, Pb, Kw, Kb } pub const CELLTABLE: [&'static str; 5] = [ "---", "WHI", "BLK", "KWH", "KBK" ]; #[derive(Show, Clone, Copy, PartialEq)] pub enum MoveCode { Success, VoidPiece, IllegalMove, WrongPiece, Quit, InputFail } impl BitMove for Bitboard { #[inline] fn up_left(&self) -> Bitboard { self.rotate_left(7) } #[inline] fn up_right(&self) -> Bitboard { self.rotate_left(1) } #[inline] fn down_left(&self) -> Bitboard { self.rotate_right(1) } #[inline] fn down_right(&self) -> Bitboard { self.rotate_right(7) } #[inline] fn is(&self) -> bool { *self!= 0 } } // Maps from Bitboard indicating a position to the number // of that position itself pub fn bbumap(b: Bitboard) -> Bitboard { S.iter().position(|&x| x == b).unwrap() as u32 } #[inline] pub fn high_bit(mut board: Bitboard) -> Bitboard { board |= board >> 1; board |= board >> 2; board |= board >> 4; board |= board >> 8; board |= board >> 16; board - (board >> 1) } #[cfg(test)] mod test { use super::*; #[test] #[should_panic(expected = "assertion failed")] fn test_move_validation() { let _ = Move::new(0, 100, false); } #[test] fn test_move_validation2() { let _ = Move::new(1,2,false); let _ = Move::new(31,0,false); } #[test] fn test_direction_calculation() { let m = Move::new(9, 12, true); assert_eq!(m.calc_direction(), Some(Direction::UpLeft)); let m = Move::new(9, 13, false); assert_eq!(m.calc_direction(), Some(Direction::UpRight)); let m = Move::new(21, 17, false); assert_eq!(m.calc_direction(), Some(Direction::DownLeft)); let m = Move::new(21, 18, false); assert_eq!(m.calc_direction(), Some(Direction::DownRight)); let m = Move::new(21, 12, false); assert_eq!(m.calc_direction(), None); } }
1 << 19, 1 << 13, 1 << 7, 1 << 1, 1 << 26, 1 << 20, 1 << 14, 1 << 8, 1 << 27, 1 << 21, 1 << 15, 1 << 9, 1 << 2, 1 << 28, 1 << 22, 1 << 16,
random_line_split
bitboard.rs
// use std::num::Int; pub type Bitboard = u32; pub trait BitMove { fn up_left(&self) -> Self; fn up_right(&self) -> Self; fn down_left(&self) -> Self; fn down_right(&self) -> Self; fn is(&self) -> bool; } pub const S: [Bitboard; 32] = [ 1 << 18, 1 << 12, 1 << 6, 1 << 0, 1 << 19, 1 << 13, 1 << 7, 1 << 1, 1 << 26, 1 << 20, 1 << 14, 1 << 8, 1 << 27, 1 << 21, 1 << 15, 1 << 9, 1 << 2, 1 << 28, 1 << 22, 1 << 16, 1 << 3, 1 << 29, 1 << 23, 1 << 17, 1 << 10, 1 << 4, 1 << 30, 1 << 24, 1 << 11, 1 << 05, 1 << 31, 1 << 25]; pub const BP_INIT: Bitboard = S[0] | S[1] | S[2] | S[3] | S[4] | S[5] | S[6] | S[7] | S[8] | S[9] | S[10] | S[11]; pub const WP_INIT: Bitboard = S[20] | S[21] | S[22] | S[23] | S[24] | S[25] | S[26] | S[27] | S[28] | S[29] | S[30] | S[31]; pub const ROW_1: Bitboard = S[0] | S[1] | S[2] | S[3]; pub const ROW_2: Bitboard = S[4] | S[5] | S[6] | S[7]; pub const ROW_7: Bitboard = S[24] | S[25] | S[26] | S[27]; pub const ROW_8: Bitboard = S[28] | S[29] | S[30] | S[31]; pub const CAN_UPLEFT: Bitboard =!(S[0] | S[8] | S[16] | S[24] | ROW_8); pub const CAN_UPRIGHT: Bitboard =!(S[7] | S[15] | S[23] | S[31] | ROW_8); pub const CAN_DOWNLEFT: Bitboard =!(S[0] | S[8] | S[16] | S[24] | ROW_1); pub const CAN_DOWNRIGHT: Bitboard =!(S[7] | S[15] | S[23] | S[31] | ROW_1); #[derive(Clone, PartialEq, Show, Copy)] pub struct Move { pub src: u16, pub dst: u16, pub jump: bool, __dummy: () } #[derive(Clone, PartialEq, Show, Copy)] pub enum Direction{ UpLeft, UpRight, DownLeft, DownRight } impl Move { pub fn new(src: u16, dst: u16, jump: bool) -> Move { assert!(src < 32); assert!(dst < 32); Move { src: src, dst: dst, jump: jump, __dummy: () } } pub fn calc_direction(&self) -> Option<Direction> { let (src, dst) = (S[self.src as usize], S[self.dst as usize]); if src.up_left() ^ dst == 0 { Some(Direction::UpLeft) } else if src.up_right() ^ dst == 0 { Some(Direction::UpRight) } else if src.down_right() ^ dst == 0 { Some(Direction::DownRight) } else if src.down_left() ^ dst == 0 { Some(Direction::DownLeft) } else { None } } } #[derive(Clone, Copy)] pub enum Cell { Empty = 0, Pw, Pb, Kw, Kb } pub const CELLTABLE: [&'static str; 5] = [ "---", "WHI", "BLK", "KWH", "KBK" ]; #[derive(Show, Clone, Copy, PartialEq)] pub enum MoveCode { Success, VoidPiece, IllegalMove, WrongPiece, Quit, InputFail } impl BitMove for Bitboard { #[inline] fn up_left(&self) -> Bitboard { self.rotate_left(7) } #[inline] fn up_right(&self) -> Bitboard { self.rotate_left(1) } #[inline] fn down_left(&self) -> Bitboard { self.rotate_right(1) } #[inline] fn down_right(&self) -> Bitboard { self.rotate_right(7) } #[inline] fn is(&self) -> bool
} // Maps from Bitboard indicating a position to the number // of that position itself pub fn bbumap(b: Bitboard) -> Bitboard { S.iter().position(|&x| x == b).unwrap() as u32 } #[inline] pub fn high_bit(mut board: Bitboard) -> Bitboard { board |= board >> 1; board |= board >> 2; board |= board >> 4; board |= board >> 8; board |= board >> 16; board - (board >> 1) } #[cfg(test)] mod test { use super::*; #[test] #[should_panic(expected = "assertion failed")] fn test_move_validation() { let _ = Move::new(0, 100, false); } #[test] fn test_move_validation2() { let _ = Move::new(1,2,false); let _ = Move::new(31,0,false); } #[test] fn test_direction_calculation() { let m = Move::new(9, 12, true); assert_eq!(m.calc_direction(), Some(Direction::UpLeft)); let m = Move::new(9, 13, false); assert_eq!(m.calc_direction(), Some(Direction::UpRight)); let m = Move::new(21, 17, false); assert_eq!(m.calc_direction(), Some(Direction::DownLeft)); let m = Move::new(21, 18, false); assert_eq!(m.calc_direction(), Some(Direction::DownRight)); let m = Move::new(21, 12, false); assert_eq!(m.calc_direction(), None); } }
{ *self != 0 }
identifier_body
bitboard.rs
// use std::num::Int; pub type Bitboard = u32; pub trait BitMove { fn up_left(&self) -> Self; fn up_right(&self) -> Self; fn down_left(&self) -> Self; fn down_right(&self) -> Self; fn is(&self) -> bool; } pub const S: [Bitboard; 32] = [ 1 << 18, 1 << 12, 1 << 6, 1 << 0, 1 << 19, 1 << 13, 1 << 7, 1 << 1, 1 << 26, 1 << 20, 1 << 14, 1 << 8, 1 << 27, 1 << 21, 1 << 15, 1 << 9, 1 << 2, 1 << 28, 1 << 22, 1 << 16, 1 << 3, 1 << 29, 1 << 23, 1 << 17, 1 << 10, 1 << 4, 1 << 30, 1 << 24, 1 << 11, 1 << 05, 1 << 31, 1 << 25]; pub const BP_INIT: Bitboard = S[0] | S[1] | S[2] | S[3] | S[4] | S[5] | S[6] | S[7] | S[8] | S[9] | S[10] | S[11]; pub const WP_INIT: Bitboard = S[20] | S[21] | S[22] | S[23] | S[24] | S[25] | S[26] | S[27] | S[28] | S[29] | S[30] | S[31]; pub const ROW_1: Bitboard = S[0] | S[1] | S[2] | S[3]; pub const ROW_2: Bitboard = S[4] | S[5] | S[6] | S[7]; pub const ROW_7: Bitboard = S[24] | S[25] | S[26] | S[27]; pub const ROW_8: Bitboard = S[28] | S[29] | S[30] | S[31]; pub const CAN_UPLEFT: Bitboard =!(S[0] | S[8] | S[16] | S[24] | ROW_8); pub const CAN_UPRIGHT: Bitboard =!(S[7] | S[15] | S[23] | S[31] | ROW_8); pub const CAN_DOWNLEFT: Bitboard =!(S[0] | S[8] | S[16] | S[24] | ROW_1); pub const CAN_DOWNRIGHT: Bitboard =!(S[7] | S[15] | S[23] | S[31] | ROW_1); #[derive(Clone, PartialEq, Show, Copy)] pub struct Move { pub src: u16, pub dst: u16, pub jump: bool, __dummy: () } #[derive(Clone, PartialEq, Show, Copy)] pub enum Direction{ UpLeft, UpRight, DownLeft, DownRight } impl Move { pub fn
(src: u16, dst: u16, jump: bool) -> Move { assert!(src < 32); assert!(dst < 32); Move { src: src, dst: dst, jump: jump, __dummy: () } } pub fn calc_direction(&self) -> Option<Direction> { let (src, dst) = (S[self.src as usize], S[self.dst as usize]); if src.up_left() ^ dst == 0 { Some(Direction::UpLeft) } else if src.up_right() ^ dst == 0 { Some(Direction::UpRight) } else if src.down_right() ^ dst == 0 { Some(Direction::DownRight) } else if src.down_left() ^ dst == 0 { Some(Direction::DownLeft) } else { None } } } #[derive(Clone, Copy)] pub enum Cell { Empty = 0, Pw, Pb, Kw, Kb } pub const CELLTABLE: [&'static str; 5] = [ "---", "WHI", "BLK", "KWH", "KBK" ]; #[derive(Show, Clone, Copy, PartialEq)] pub enum MoveCode { Success, VoidPiece, IllegalMove, WrongPiece, Quit, InputFail } impl BitMove for Bitboard { #[inline] fn up_left(&self) -> Bitboard { self.rotate_left(7) } #[inline] fn up_right(&self) -> Bitboard { self.rotate_left(1) } #[inline] fn down_left(&self) -> Bitboard { self.rotate_right(1) } #[inline] fn down_right(&self) -> Bitboard { self.rotate_right(7) } #[inline] fn is(&self) -> bool { *self!= 0 } } // Maps from Bitboard indicating a position to the number // of that position itself pub fn bbumap(b: Bitboard) -> Bitboard { S.iter().position(|&x| x == b).unwrap() as u32 } #[inline] pub fn high_bit(mut board: Bitboard) -> Bitboard { board |= board >> 1; board |= board >> 2; board |= board >> 4; board |= board >> 8; board |= board >> 16; board - (board >> 1) } #[cfg(test)] mod test { use super::*; #[test] #[should_panic(expected = "assertion failed")] fn test_move_validation() { let _ = Move::new(0, 100, false); } #[test] fn test_move_validation2() { let _ = Move::new(1,2,false); let _ = Move::new(31,0,false); } #[test] fn test_direction_calculation() { let m = Move::new(9, 12, true); assert_eq!(m.calc_direction(), Some(Direction::UpLeft)); let m = Move::new(9, 13, false); assert_eq!(m.calc_direction(), Some(Direction::UpRight)); let m = Move::new(21, 17, false); assert_eq!(m.calc_direction(), Some(Direction::DownLeft)); let m = Move::new(21, 18, false); assert_eq!(m.calc_direction(), Some(Direction::DownRight)); let m = Move::new(21, 12, false); assert_eq!(m.calc_direction(), None); } }
new
identifier_name
lmcons.rs
// Copyright © 2015, Peter Atashian // Licensed under the MIT License <LICENSE.md> //! This file contains constants used throughout the LAN Manager API header files. pub const CNLEN: ::DWORD = 15; pub const LM20_CNLEN: ::DWORD = 15; pub const DNLEN: ::DWORD = CNLEN; pub const LM20_DNLEN: ::DWORD = LM20_CNLEN; pub const UNCLEN: ::DWORD = CNLEN + 2; pub const LM20_UNCLEN: ::DWORD = LM20_CNLEN + 2; pub const NNLEN: ::DWORD = 80; pub const LM20_NNLEN: ::DWORD = 12; pub const RMLEN: ::DWORD = UNCLEN + 1 + NNLEN; pub const LM20_RMLEN: ::DWORD = LM20_UNCLEN + 1 + LM20_NNLEN; pub const SNLEN: ::DWORD = 80; pub const LM20_SNLEN: ::DWORD = 15; pub const STXTLEN: ::DWORD = 256; pub const LM20_STXTLEN: ::DWORD = 63; pub const PATHLEN: ::DWORD = 256; pub const LM20_PATHLEN: ::DWORD = 256; pub const DEVLEN: ::DWORD = 80; pub const LM20_DEVLEN: ::DWORD = 8; pub const EVLEN: ::DWORD = 16; pub const UNLEN: ::DWORD = 256; pub const LM20_UNLEN: ::DWORD = 20; pub const GNLEN: ::DWORD = UNLEN; pub const LM20_GNLEN: ::DWORD = LM20_UNLEN; pub const PWLEN: ::DWORD = 256; pub const LM20_PWLEN: ::DWORD = 14; pub const SHPWLEN: ::DWORD = 8; pub const CLTYPE_LEN: ::DWORD = 12; pub const MAXCOMMENTSZ: ::DWORD = 256; pub const LM20_MAXCOMMENTSZ: ::DWORD = 48; pub const QNLEN: ::DWORD = NNLEN; pub const LM20_QNLEN: ::DWORD = LM20_NNLEN; pub const ALERTSZ: ::DWORD = 128; pub const MAXDEVENTRIES: ::DWORD = 4 * 8; // FIXME: sizeof(int) instead of 4 pub const NETBIOS_NAME_LEN: ::DWORD = 16; pub const MAX_PREFERRED_LENGTH: ::DWORD = -1i32 as ::DWORD; pub const CRYPT_KEY_LEN: ::DWORD = 7; pub const CRYPT_TXT_LEN: ::DWORD = 8; pub const ENCRYPTED_PWLEN: usize = 16; pub const SESSION_PWLEN: ::DWORD = 24; pub const SESSION_CRYPT_KLEN: ::DWORD = 21; pub const PARM_ERROR_UNKNOWN: ::DWORD = -1i32 as ::DWORD; pub const PARM_ERROR_NONE: ::DWORD = 0; pub const PARMNUM_BASE_INFOLEVEL: ::DWORD = 1000; pub type LMSTR = ::LPWSTR; pub type LMCSTR = ::LPCWSTR; pub type NET_API_STATUS = ::DWORD;
pub const PLATFORM_ID_NT: ::DWORD = 500; pub const PLATFORM_ID_OSF: ::DWORD = 600; pub const PLATFORM_ID_VMS: ::DWORD = 700;
pub type API_RET_TYPE = NET_API_STATUS; pub const PLATFORM_ID_DOS: ::DWORD = 300; pub const PLATFORM_ID_OS2: ::DWORD = 400;
random_line_split
lint-unused-imports.rs
// 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. #![feature(globs)] #![deny(unused_imports)] #![allow(dead_code)] #![allow(deprecated_owned_vector)] use cal = bar::c::cc; use std::mem::*; // shouldn't get errors for not using // everything imported // Should get errors for both 'Some' and 'None' use std::option::{Some, None}; //~ ERROR unused import //~^ ERROR unused import use test::A; //~ ERROR unused import // Be sure that if we just bring some methods into scope that they're also // counted as being used. use test::B; // Make sure this import is warned about when at least one of its imported names // is unused use std::slice::{from_fn, from_elem}; //~ ERROR unused import mod test { pub trait A { fn a(&self) {} } pub trait B { fn b(&self) {} } pub struct C; impl A for C {} impl B for C {} } mod foo { pub struct Point{x: int, y: int} pub struct Square{p: Point, h: uint, w: uint} } mod bar { // Don't ignore on 'pub use' because we're not sure if it's used or not pub use std::cmp::Eq; pub mod c { use foo::Point; use foo::Square; //~ ERROR unused import pub fn
(p: Point) -> int { return 2 * (p.x + p.y); } } #[allow(unused_imports)] mod foo { use std::cmp::Eq; } } fn main() { cal(foo::Point{x:3, y:9}); let mut a = 3; let mut b = 4; swap(&mut a, &mut b); test::C.b(); let _a = from_elem(0, 0); }
cc
identifier_name
lint-unused-imports.rs
// 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. #![feature(globs)] #![deny(unused_imports)] #![allow(dead_code)] #![allow(deprecated_owned_vector)] use cal = bar::c::cc; use std::mem::*; // shouldn't get errors for not using // everything imported // Should get errors for both 'Some' and 'None' use std::option::{Some, None}; //~ ERROR unused import //~^ ERROR unused import use test::A; //~ ERROR unused import // Be sure that if we just bring some methods into scope that they're also
// Make sure this import is warned about when at least one of its imported names // is unused use std::slice::{from_fn, from_elem}; //~ ERROR unused import mod test { pub trait A { fn a(&self) {} } pub trait B { fn b(&self) {} } pub struct C; impl A for C {} impl B for C {} } mod foo { pub struct Point{x: int, y: int} pub struct Square{p: Point, h: uint, w: uint} } mod bar { // Don't ignore on 'pub use' because we're not sure if it's used or not pub use std::cmp::Eq; pub mod c { use foo::Point; use foo::Square; //~ ERROR unused import pub fn cc(p: Point) -> int { return 2 * (p.x + p.y); } } #[allow(unused_imports)] mod foo { use std::cmp::Eq; } } fn main() { cal(foo::Point{x:3, y:9}); let mut a = 3; let mut b = 4; swap(&mut a, &mut b); test::C.b(); let _a = from_elem(0, 0); }
// counted as being used. use test::B;
random_line_split
svg.rs
/* This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ //! Generic types for CSS values in SVG use crate::parser::{Parse, ParserContext}; use cssparser::Parser; use style_traits::ParseError; /// The fallback of an SVG paint server value. #[derive( Animate, Clone, ComputeSquaredDistance, Debug, MallocSizeOf, PartialEq, Parse, SpecifiedValueInfo, ToAnimatedValue, ToAnimatedZero, ToComputedValue, ToCss, ToResolvedValue, ToShmem, )] #[repr(C, u8)] pub enum GenericSVGPaintFallback<C> { /// The `none` keyword. None, /// A magic value that represents no fallback specified and serializes to /// the empty string. #[css(skip)] Unset, /// A color. Color(C), } pub use self::GenericSVGPaintFallback as SVGPaintFallback; /// An SVG paint value /// /// <https://www.w3.org/TR/SVG2/painting.html#SpecifyingPaint> #[animation(no_bound(Url))] #[derive( Animate, Clone, ComputeSquaredDistance, Debug, MallocSizeOf, PartialEq, SpecifiedValueInfo, ToAnimatedValue, ToAnimatedZero, ToComputedValue, ToCss, ToResolvedValue, ToShmem, )] #[repr(C)] pub struct GenericSVGPaint<Color, Url> { /// The paint source. pub kind: GenericSVGPaintKind<Color, Url>, /// The fallback color. pub fallback: GenericSVGPaintFallback<Color>, } pub use self::GenericSVGPaint as SVGPaint; impl<C, U> Default for SVGPaint<C, U> { fn default() -> Self { Self { kind: SVGPaintKind::None, fallback: SVGPaintFallback::Unset, } } } /// An SVG paint value without the fallback. /// /// Whereas the spec only allows PaintServer to have a fallback, Gecko lets the /// context properties have a fallback as well. #[animation(no_bound(U))] #[derive( Animate, Clone, ComputeSquaredDistance, Debug, MallocSizeOf, PartialEq, Parse, SpecifiedValueInfo, ToAnimatedValue, ToAnimatedZero, ToComputedValue, ToCss, ToResolvedValue, ToShmem, )] #[repr(C, u8)] pub enum GenericSVGPaintKind<C, U> { /// `none` #[animation(error)] None, /// `<color>` Color(C), /// `url(...)` #[animation(error)] PaintServer(U), /// `context-fill` ContextFill, /// `context-stroke` ContextStroke, } pub use self::GenericSVGPaintKind as SVGPaintKind; impl<C: Parse, U: Parse> Parse for SVGPaint<C, U> { fn parse<'i, 't>( context: &ParserContext, input: &mut Parser<'i, 't>, ) -> Result<Self, ParseError<'i>> { let kind = SVGPaintKind::parse(context, input)?; if matches!(kind, SVGPaintKind::None | SVGPaintKind::Color(..)) { return Ok(SVGPaint { kind, fallback: SVGPaintFallback::Unset, }); } let fallback = input .try(|i| SVGPaintFallback::parse(context, i)) .unwrap_or(SVGPaintFallback::Unset); Ok(SVGPaint { kind, fallback }) } } /// An SVG length value supports `context-value` in addition to length. #[derive( Animate, Clone, ComputeSquaredDistance, Copy, Debug, MallocSizeOf, PartialEq, SpecifiedValueInfo, ToAnimatedValue, ToAnimatedZero, ToComputedValue, ToCss, ToResolvedValue, ToShmem, )] pub enum SVGLength<L> { /// `<length> | <percentage> | <number>` LengthPercentage(L), /// `context-value` #[animation(error)] ContextValue, } /// Generic value for stroke-dasharray. #[derive( Clone, Debug, MallocSizeOf, PartialEq, SpecifiedValueInfo, ToAnimatedValue, ToAnimatedZero, ToComputedValue, ToCss, ToResolvedValue, ToShmem, )] #[repr(C, u8)] pub enum GenericSVGStrokeDashArray<L> { /// `[ <length> | <percentage> | <number> ]#` #[css(comma)] Values(#[css(if_empty = "none", iterable)] crate::OwnedSlice<L>), /// `context-value` ContextValue, } pub use self::GenericSVGStrokeDashArray as SVGStrokeDashArray; /// An SVG opacity value accepts `context-{fill,stroke}-opacity` in /// addition to opacity value. #[derive( Animate, Clone, ComputeSquaredDistance, Copy, Debug, MallocSizeOf,
ToComputedValue, ToCss, ToResolvedValue, ToShmem, )] #[repr(C, u8)] pub enum GenericSVGOpacity<OpacityType> { /// `<opacity-value>` Opacity(OpacityType), /// `context-fill-opacity` #[animation(error)] ContextFillOpacity, /// `context-stroke-opacity` #[animation(error)] ContextStrokeOpacity, } pub use self::GenericSVGOpacity as SVGOpacity;
PartialEq, Parse, SpecifiedValueInfo, ToAnimatedZero,
random_line_split
svg.rs
/* This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ //! Generic types for CSS values in SVG use crate::parser::{Parse, ParserContext}; use cssparser::Parser; use style_traits::ParseError; /// The fallback of an SVG paint server value. #[derive( Animate, Clone, ComputeSquaredDistance, Debug, MallocSizeOf, PartialEq, Parse, SpecifiedValueInfo, ToAnimatedValue, ToAnimatedZero, ToComputedValue, ToCss, ToResolvedValue, ToShmem, )] #[repr(C, u8)] pub enum GenericSVGPaintFallback<C> { /// The `none` keyword. None, /// A magic value that represents no fallback specified and serializes to /// the empty string. #[css(skip)] Unset, /// A color. Color(C), } pub use self::GenericSVGPaintFallback as SVGPaintFallback; /// An SVG paint value /// /// <https://www.w3.org/TR/SVG2/painting.html#SpecifyingPaint> #[animation(no_bound(Url))] #[derive( Animate, Clone, ComputeSquaredDistance, Debug, MallocSizeOf, PartialEq, SpecifiedValueInfo, ToAnimatedValue, ToAnimatedZero, ToComputedValue, ToCss, ToResolvedValue, ToShmem, )] #[repr(C)] pub struct GenericSVGPaint<Color, Url> { /// The paint source. pub kind: GenericSVGPaintKind<Color, Url>, /// The fallback color. pub fallback: GenericSVGPaintFallback<Color>, } pub use self::GenericSVGPaint as SVGPaint; impl<C, U> Default for SVGPaint<C, U> { fn
() -> Self { Self { kind: SVGPaintKind::None, fallback: SVGPaintFallback::Unset, } } } /// An SVG paint value without the fallback. /// /// Whereas the spec only allows PaintServer to have a fallback, Gecko lets the /// context properties have a fallback as well. #[animation(no_bound(U))] #[derive( Animate, Clone, ComputeSquaredDistance, Debug, MallocSizeOf, PartialEq, Parse, SpecifiedValueInfo, ToAnimatedValue, ToAnimatedZero, ToComputedValue, ToCss, ToResolvedValue, ToShmem, )] #[repr(C, u8)] pub enum GenericSVGPaintKind<C, U> { /// `none` #[animation(error)] None, /// `<color>` Color(C), /// `url(...)` #[animation(error)] PaintServer(U), /// `context-fill` ContextFill, /// `context-stroke` ContextStroke, } pub use self::GenericSVGPaintKind as SVGPaintKind; impl<C: Parse, U: Parse> Parse for SVGPaint<C, U> { fn parse<'i, 't>( context: &ParserContext, input: &mut Parser<'i, 't>, ) -> Result<Self, ParseError<'i>> { let kind = SVGPaintKind::parse(context, input)?; if matches!(kind, SVGPaintKind::None | SVGPaintKind::Color(..)) { return Ok(SVGPaint { kind, fallback: SVGPaintFallback::Unset, }); } let fallback = input .try(|i| SVGPaintFallback::parse(context, i)) .unwrap_or(SVGPaintFallback::Unset); Ok(SVGPaint { kind, fallback }) } } /// An SVG length value supports `context-value` in addition to length. #[derive( Animate, Clone, ComputeSquaredDistance, Copy, Debug, MallocSizeOf, PartialEq, SpecifiedValueInfo, ToAnimatedValue, ToAnimatedZero, ToComputedValue, ToCss, ToResolvedValue, ToShmem, )] pub enum SVGLength<L> { /// `<length> | <percentage> | <number>` LengthPercentage(L), /// `context-value` #[animation(error)] ContextValue, } /// Generic value for stroke-dasharray. #[derive( Clone, Debug, MallocSizeOf, PartialEq, SpecifiedValueInfo, ToAnimatedValue, ToAnimatedZero, ToComputedValue, ToCss, ToResolvedValue, ToShmem, )] #[repr(C, u8)] pub enum GenericSVGStrokeDashArray<L> { /// `[ <length> | <percentage> | <number> ]#` #[css(comma)] Values(#[css(if_empty = "none", iterable)] crate::OwnedSlice<L>), /// `context-value` ContextValue, } pub use self::GenericSVGStrokeDashArray as SVGStrokeDashArray; /// An SVG opacity value accepts `context-{fill,stroke}-opacity` in /// addition to opacity value. #[derive( Animate, Clone, ComputeSquaredDistance, Copy, Debug, MallocSizeOf, PartialEq, Parse, SpecifiedValueInfo, ToAnimatedZero, ToComputedValue, ToCss, ToResolvedValue, ToShmem, )] #[repr(C, u8)] pub enum GenericSVGOpacity<OpacityType> { /// `<opacity-value>` Opacity(OpacityType), /// `context-fill-opacity` #[animation(error)] ContextFillOpacity, /// `context-stroke-opacity` #[animation(error)] ContextStrokeOpacity, } pub use self::GenericSVGOpacity as SVGOpacity;
default
identifier_name
svg.rs
/* This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ //! Generic types for CSS values in SVG use crate::parser::{Parse, ParserContext}; use cssparser::Parser; use style_traits::ParseError; /// The fallback of an SVG paint server value. #[derive( Animate, Clone, ComputeSquaredDistance, Debug, MallocSizeOf, PartialEq, Parse, SpecifiedValueInfo, ToAnimatedValue, ToAnimatedZero, ToComputedValue, ToCss, ToResolvedValue, ToShmem, )] #[repr(C, u8)] pub enum GenericSVGPaintFallback<C> { /// The `none` keyword. None, /// A magic value that represents no fallback specified and serializes to /// the empty string. #[css(skip)] Unset, /// A color. Color(C), } pub use self::GenericSVGPaintFallback as SVGPaintFallback; /// An SVG paint value /// /// <https://www.w3.org/TR/SVG2/painting.html#SpecifyingPaint> #[animation(no_bound(Url))] #[derive( Animate, Clone, ComputeSquaredDistance, Debug, MallocSizeOf, PartialEq, SpecifiedValueInfo, ToAnimatedValue, ToAnimatedZero, ToComputedValue, ToCss, ToResolvedValue, ToShmem, )] #[repr(C)] pub struct GenericSVGPaint<Color, Url> { /// The paint source. pub kind: GenericSVGPaintKind<Color, Url>, /// The fallback color. pub fallback: GenericSVGPaintFallback<Color>, } pub use self::GenericSVGPaint as SVGPaint; impl<C, U> Default for SVGPaint<C, U> { fn default() -> Self { Self { kind: SVGPaintKind::None, fallback: SVGPaintFallback::Unset, } } } /// An SVG paint value without the fallback. /// /// Whereas the spec only allows PaintServer to have a fallback, Gecko lets the /// context properties have a fallback as well. #[animation(no_bound(U))] #[derive( Animate, Clone, ComputeSquaredDistance, Debug, MallocSizeOf, PartialEq, Parse, SpecifiedValueInfo, ToAnimatedValue, ToAnimatedZero, ToComputedValue, ToCss, ToResolvedValue, ToShmem, )] #[repr(C, u8)] pub enum GenericSVGPaintKind<C, U> { /// `none` #[animation(error)] None, /// `<color>` Color(C), /// `url(...)` #[animation(error)] PaintServer(U), /// `context-fill` ContextFill, /// `context-stroke` ContextStroke, } pub use self::GenericSVGPaintKind as SVGPaintKind; impl<C: Parse, U: Parse> Parse for SVGPaint<C, U> { fn parse<'i, 't>( context: &ParserContext, input: &mut Parser<'i, 't>, ) -> Result<Self, ParseError<'i>> { let kind = SVGPaintKind::parse(context, input)?; if matches!(kind, SVGPaintKind::None | SVGPaintKind::Color(..))
let fallback = input .try(|i| SVGPaintFallback::parse(context, i)) .unwrap_or(SVGPaintFallback::Unset); Ok(SVGPaint { kind, fallback }) } } /// An SVG length value supports `context-value` in addition to length. #[derive( Animate, Clone, ComputeSquaredDistance, Copy, Debug, MallocSizeOf, PartialEq, SpecifiedValueInfo, ToAnimatedValue, ToAnimatedZero, ToComputedValue, ToCss, ToResolvedValue, ToShmem, )] pub enum SVGLength<L> { /// `<length> | <percentage> | <number>` LengthPercentage(L), /// `context-value` #[animation(error)] ContextValue, } /// Generic value for stroke-dasharray. #[derive( Clone, Debug, MallocSizeOf, PartialEq, SpecifiedValueInfo, ToAnimatedValue, ToAnimatedZero, ToComputedValue, ToCss, ToResolvedValue, ToShmem, )] #[repr(C, u8)] pub enum GenericSVGStrokeDashArray<L> { /// `[ <length> | <percentage> | <number> ]#` #[css(comma)] Values(#[css(if_empty = "none", iterable)] crate::OwnedSlice<L>), /// `context-value` ContextValue, } pub use self::GenericSVGStrokeDashArray as SVGStrokeDashArray; /// An SVG opacity value accepts `context-{fill,stroke}-opacity` in /// addition to opacity value. #[derive( Animate, Clone, ComputeSquaredDistance, Copy, Debug, MallocSizeOf, PartialEq, Parse, SpecifiedValueInfo, ToAnimatedZero, ToComputedValue, ToCss, ToResolvedValue, ToShmem, )] #[repr(C, u8)] pub enum GenericSVGOpacity<OpacityType> { /// `<opacity-value>` Opacity(OpacityType), /// `context-fill-opacity` #[animation(error)] ContextFillOpacity, /// `context-stroke-opacity` #[animation(error)] ContextStrokeOpacity, } pub use self::GenericSVGOpacity as SVGOpacity;
{ return Ok(SVGPaint { kind, fallback: SVGPaintFallback::Unset, }); }
conditional_block
rexpect.rs
#![cfg(unix)] extern crate rexpect; use std::process::Command; use rexpect::errors::*; use rexpect::session::{spawn_command, PtySession}; struct REPL { session: PtySession, prompt: &'static str, } impl REPL { fn new() -> REPL { let repl = REPL::new_().unwrap_or_else(|err| panic!("{}", err)); repl } /// Defines the command, timeout, and prompt settings. /// Wraps a rexpect::session::PtySession. expecting the prompt after launch. fn new_() -> Result<REPL> { let timeout: u64 = 30_000; let prompt: &'static str = "REXPECT> "; let mut command = Command::new("../target/debug/gluon"); command .args(&["-i", "--color", "never", "--prompt", prompt]) .env("GLUON_PATH", ".."); let mut session = spawn_command(command, Some(timeout))?; session.exp_string(prompt)?; Ok(REPL { session, prompt }) } fn test(&mut self, send: &str, expect: Option<&str>) { self.test_(send, expect) .unwrap_or_else(|err| panic!("{}", err)); } /// Ensures certain lines are expected to reduce race conditions. /// If no ouput is expected or desired to be tested, pass it an Option::None, /// causing rexpect to wait for the next prompt. fn test_(&mut self, send: &str, expect: Option<&str>) -> Result<()> { self.session.send_line(send)?; self.session.exp_string(send)?; if let Some(string) = expect { self.session.exp_string(string)?; } self.session.exp_string(self.prompt)?; Ok(()) } fn quit(&mut self) { self.quit_().unwrap_or_else(|err| panic!("{}", err)); } fn quit_(&mut self) -> Result<()> { let line: &'static str = ":q"; self.session.send_line(line)?; self.session.exp_string(line)?; self.session.exp_eof()?; Ok(()) } } #[test] fn prompt() { let _repl = REPL::new(); } #[test] fn quit() { let mut repl = REPL::new(); repl.quit(); } #[test] fn hello_world() { let mut repl = REPL::new(); repl.test("let io = import! std.io", None); repl.test("io.println \"Hello world\"", Some("Hello world")); } #[test] fn expression_types() { let mut repl = REPL::new(); repl.test(":t 5", Some("Int")); repl.test(":t 5 + 5", Some("Int")); repl.test(":t \"gluon\"", Some("String")); } #[test] fn names() { let mut repl = REPL::new(); repl.test( ":i std.prelude.show", Some("std.prelude.show: forall a. [std.show.Show a] -> a -> String"), ); } #[test] fn comments() { let mut repl = REPL::new(); repl.test("1 + 2 // Calls the + function on 1 and 2", Some("3")); repl.test("1 + 2 /* Calls the + function on 1 and 2 */", Some("3")); } #[test] fn
() { let mut repl = REPL::new(); repl.test("if True then 1 else 0", Some("1")); repl.test("if False then 1 else 0", Some("0")); } #[test] fn records() { let mut repl = REPL::new(); repl.test("let record = { pi = 3.14, add1 = (+) 1.0 }", None); repl.test("record.pi", Some("3.14")); repl.test("let record_2 = {x = 1.. record }", None); repl.test("record_2.x", Some("1")); repl.test("record_2.pi", Some("3.14")); } #[test] fn arrays() { let mut repl = REPL::new(); repl.test("let array = import! std.array", None); repl.test("array.len [1, 2, 3]", Some("3")); } #[test] fn comment() { let mut repl = REPL::new(); repl.test("// test", None); } #[test] fn error_reports_correct_line() { let mut repl = REPL::new(); repl.test("let { x } = {}", Some("let { x } = {}")); } #[test] fn import() { let mut repl = REPL::new(); repl.test("let { assert } = import! std.test", None); } #[test] fn assert() { let mut repl = REPL::new(); repl.test("let { assert } = import! std.test", None); repl.test("assert False", None); }
if_expressions
identifier_name
rexpect.rs
#![cfg(unix)] extern crate rexpect; use std::process::Command; use rexpect::errors::*; use rexpect::session::{spawn_command, PtySession}; struct REPL { session: PtySession, prompt: &'static str, } impl REPL { fn new() -> REPL { let repl = REPL::new_().unwrap_or_else(|err| panic!("{}", err)); repl } /// Defines the command, timeout, and prompt settings. /// Wraps a rexpect::session::PtySession. expecting the prompt after launch. fn new_() -> Result<REPL> { let timeout: u64 = 30_000; let prompt: &'static str = "REXPECT> "; let mut command = Command::new("../target/debug/gluon"); command .args(&["-i", "--color", "never", "--prompt", prompt]) .env("GLUON_PATH", ".."); let mut session = spawn_command(command, Some(timeout))?; session.exp_string(prompt)?; Ok(REPL { session, prompt }) } fn test(&mut self, send: &str, expect: Option<&str>) { self.test_(send, expect) .unwrap_or_else(|err| panic!("{}", err)); } /// Ensures certain lines are expected to reduce race conditions. /// If no ouput is expected or desired to be tested, pass it an Option::None, /// causing rexpect to wait for the next prompt. fn test_(&mut self, send: &str, expect: Option<&str>) -> Result<()> { self.session.send_line(send)?; self.session.exp_string(send)?; if let Some(string) = expect { self.session.exp_string(string)?; } self.session.exp_string(self.prompt)?; Ok(()) } fn quit(&mut self) { self.quit_().unwrap_or_else(|err| panic!("{}", err)); } fn quit_(&mut self) -> Result<()> { let line: &'static str = ":q"; self.session.send_line(line)?; self.session.exp_string(line)?; self.session.exp_eof()?; Ok(()) } } #[test] fn prompt() { let _repl = REPL::new(); } #[test] fn quit() { let mut repl = REPL::new(); repl.quit(); } #[test] fn hello_world() { let mut repl = REPL::new(); repl.test("let io = import! std.io", None); repl.test("io.println \"Hello world\"", Some("Hello world")); } #[test] fn expression_types() { let mut repl = REPL::new(); repl.test(":t 5", Some("Int")); repl.test(":t 5 + 5", Some("Int")); repl.test(":t \"gluon\"", Some("String")); } #[test] fn names() { let mut repl = REPL::new(); repl.test( ":i std.prelude.show", Some("std.prelude.show: forall a. [std.show.Show a] -> a -> String"), ); } #[test] fn comments() { let mut repl = REPL::new(); repl.test("1 + 2 // Calls the + function on 1 and 2", Some("3")); repl.test("1 + 2 /* Calls the + function on 1 and 2 */", Some("3")); } #[test] fn if_expressions() { let mut repl = REPL::new(); repl.test("if True then 1 else 0", Some("1")); repl.test("if False then 1 else 0", Some("0")); } #[test] fn records() { let mut repl = REPL::new(); repl.test("let record = { pi = 3.14, add1 = (+) 1.0 }", None); repl.test("record.pi", Some("3.14")); repl.test("let record_2 = {x = 1.. record }", None); repl.test("record_2.x", Some("1")); repl.test("record_2.pi", Some("3.14")); } #[test] fn arrays() { let mut repl = REPL::new(); repl.test("let array = import! std.array", None); repl.test("array.len [1, 2, 3]", Some("3")); } #[test] fn comment() { let mut repl = REPL::new(); repl.test("// test", None); } #[test] fn error_reports_correct_line() { let mut repl = REPL::new(); repl.test("let { x } = {}", Some("let { x } = {}")); } #[test] fn import()
#[test] fn assert() { let mut repl = REPL::new(); repl.test("let { assert } = import! std.test", None); repl.test("assert False", None); }
{ let mut repl = REPL::new(); repl.test("let { assert } = import! std.test", None); }
identifier_body
rexpect.rs
#![cfg(unix)] extern crate rexpect; use std::process::Command; use rexpect::errors::*; use rexpect::session::{spawn_command, PtySession}; struct REPL { session: PtySession, prompt: &'static str, } impl REPL { fn new() -> REPL { let repl = REPL::new_().unwrap_or_else(|err| panic!("{}", err)); repl } /// Defines the command, timeout, and prompt settings. /// Wraps a rexpect::session::PtySession. expecting the prompt after launch. fn new_() -> Result<REPL> { let timeout: u64 = 30_000; let prompt: &'static str = "REXPECT> "; let mut command = Command::new("../target/debug/gluon"); command .args(&["-i", "--color", "never", "--prompt", prompt]) .env("GLUON_PATH", ".."); let mut session = spawn_command(command, Some(timeout))?; session.exp_string(prompt)?; Ok(REPL { session, prompt }) } fn test(&mut self, send: &str, expect: Option<&str>) { self.test_(send, expect) .unwrap_or_else(|err| panic!("{}", err)); } /// Ensures certain lines are expected to reduce race conditions. /// If no ouput is expected or desired to be tested, pass it an Option::None, /// causing rexpect to wait for the next prompt. fn test_(&mut self, send: &str, expect: Option<&str>) -> Result<()> { self.session.send_line(send)?; self.session.exp_string(send)?; if let Some(string) = expect {
self.session.exp_string(self.prompt)?; Ok(()) } fn quit(&mut self) { self.quit_().unwrap_or_else(|err| panic!("{}", err)); } fn quit_(&mut self) -> Result<()> { let line: &'static str = ":q"; self.session.send_line(line)?; self.session.exp_string(line)?; self.session.exp_eof()?; Ok(()) } } #[test] fn prompt() { let _repl = REPL::new(); } #[test] fn quit() { let mut repl = REPL::new(); repl.quit(); } #[test] fn hello_world() { let mut repl = REPL::new(); repl.test("let io = import! std.io", None); repl.test("io.println \"Hello world\"", Some("Hello world")); } #[test] fn expression_types() { let mut repl = REPL::new(); repl.test(":t 5", Some("Int")); repl.test(":t 5 + 5", Some("Int")); repl.test(":t \"gluon\"", Some("String")); } #[test] fn names() { let mut repl = REPL::new(); repl.test( ":i std.prelude.show", Some("std.prelude.show: forall a. [std.show.Show a] -> a -> String"), ); } #[test] fn comments() { let mut repl = REPL::new(); repl.test("1 + 2 // Calls the + function on 1 and 2", Some("3")); repl.test("1 + 2 /* Calls the + function on 1 and 2 */", Some("3")); } #[test] fn if_expressions() { let mut repl = REPL::new(); repl.test("if True then 1 else 0", Some("1")); repl.test("if False then 1 else 0", Some("0")); } #[test] fn records() { let mut repl = REPL::new(); repl.test("let record = { pi = 3.14, add1 = (+) 1.0 }", None); repl.test("record.pi", Some("3.14")); repl.test("let record_2 = {x = 1.. record }", None); repl.test("record_2.x", Some("1")); repl.test("record_2.pi", Some("3.14")); } #[test] fn arrays() { let mut repl = REPL::new(); repl.test("let array = import! std.array", None); repl.test("array.len [1, 2, 3]", Some("3")); } #[test] fn comment() { let mut repl = REPL::new(); repl.test("// test", None); } #[test] fn error_reports_correct_line() { let mut repl = REPL::new(); repl.test("let { x } = {}", Some("let { x } = {}")); } #[test] fn import() { let mut repl = REPL::new(); repl.test("let { assert } = import! std.test", None); } #[test] fn assert() { let mut repl = REPL::new(); repl.test("let { assert } = import! std.test", None); repl.test("assert False", None); }
self.session.exp_string(string)?; }
random_line_split
rexpect.rs
#![cfg(unix)] extern crate rexpect; use std::process::Command; use rexpect::errors::*; use rexpect::session::{spawn_command, PtySession}; struct REPL { session: PtySession, prompt: &'static str, } impl REPL { fn new() -> REPL { let repl = REPL::new_().unwrap_or_else(|err| panic!("{}", err)); repl } /// Defines the command, timeout, and prompt settings. /// Wraps a rexpect::session::PtySession. expecting the prompt after launch. fn new_() -> Result<REPL> { let timeout: u64 = 30_000; let prompt: &'static str = "REXPECT> "; let mut command = Command::new("../target/debug/gluon"); command .args(&["-i", "--color", "never", "--prompt", prompt]) .env("GLUON_PATH", ".."); let mut session = spawn_command(command, Some(timeout))?; session.exp_string(prompt)?; Ok(REPL { session, prompt }) } fn test(&mut self, send: &str, expect: Option<&str>) { self.test_(send, expect) .unwrap_or_else(|err| panic!("{}", err)); } /// Ensures certain lines are expected to reduce race conditions. /// If no ouput is expected or desired to be tested, pass it an Option::None, /// causing rexpect to wait for the next prompt. fn test_(&mut self, send: &str, expect: Option<&str>) -> Result<()> { self.session.send_line(send)?; self.session.exp_string(send)?; if let Some(string) = expect
self.session.exp_string(self.prompt)?; Ok(()) } fn quit(&mut self) { self.quit_().unwrap_or_else(|err| panic!("{}", err)); } fn quit_(&mut self) -> Result<()> { let line: &'static str = ":q"; self.session.send_line(line)?; self.session.exp_string(line)?; self.session.exp_eof()?; Ok(()) } } #[test] fn prompt() { let _repl = REPL::new(); } #[test] fn quit() { let mut repl = REPL::new(); repl.quit(); } #[test] fn hello_world() { let mut repl = REPL::new(); repl.test("let io = import! std.io", None); repl.test("io.println \"Hello world\"", Some("Hello world")); } #[test] fn expression_types() { let mut repl = REPL::new(); repl.test(":t 5", Some("Int")); repl.test(":t 5 + 5", Some("Int")); repl.test(":t \"gluon\"", Some("String")); } #[test] fn names() { let mut repl = REPL::new(); repl.test( ":i std.prelude.show", Some("std.prelude.show: forall a. [std.show.Show a] -> a -> String"), ); } #[test] fn comments() { let mut repl = REPL::new(); repl.test("1 + 2 // Calls the + function on 1 and 2", Some("3")); repl.test("1 + 2 /* Calls the + function on 1 and 2 */", Some("3")); } #[test] fn if_expressions() { let mut repl = REPL::new(); repl.test("if True then 1 else 0", Some("1")); repl.test("if False then 1 else 0", Some("0")); } #[test] fn records() { let mut repl = REPL::new(); repl.test("let record = { pi = 3.14, add1 = (+) 1.0 }", None); repl.test("record.pi", Some("3.14")); repl.test("let record_2 = {x = 1.. record }", None); repl.test("record_2.x", Some("1")); repl.test("record_2.pi", Some("3.14")); } #[test] fn arrays() { let mut repl = REPL::new(); repl.test("let array = import! std.array", None); repl.test("array.len [1, 2, 3]", Some("3")); } #[test] fn comment() { let mut repl = REPL::new(); repl.test("// test", None); } #[test] fn error_reports_correct_line() { let mut repl = REPL::new(); repl.test("let { x } = {}", Some("let { x } = {}")); } #[test] fn import() { let mut repl = REPL::new(); repl.test("let { assert } = import! std.test", None); } #[test] fn assert() { let mut repl = REPL::new(); repl.test("let { assert } = import! std.test", None); repl.test("assert False", None); }
{ self.session.exp_string(string)?; }
conditional_block
aspect_frame.rs
// This file is part of rgtk. // // rgtk is free software: you can redistribute it and/or modify // it under the terms of the GNU Lesser General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // rgtk is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public License // along with rgtk. If not, see <http://www.gnu.org/licenses/>. //! A frame that constrains its child to a particular aspect ratio
use glib::translate::ToGlibPtr; use gtk::cast::GTK_ASPECTFRAME; use gtk::{self, ffi}; use glib::to_gboolean; /// AspectFrame — A frame that constrains its child to a particular aspect ratio struct_Widget!(AspectFrame); impl AspectFrame { pub fn new(label: Option<&str>, x_align: f32, y_align: f32, ratio: f32, obey_child: bool) -> Option<AspectFrame> { let tmp_pointer = unsafe { ffi::gtk_aspect_frame_new(label.borrow_to_glib().0, x_align as c_float, y_align as c_float, ratio as c_float, to_gboolean(obey_child)) }; check_pointer!(tmp_pointer, AspectFrame) } pub fn set(&mut self, x_align: f32, y_align: f32, ratio: f32, obey_child: bool) -> () { unsafe { ffi::gtk_aspect_frame_set(GTK_ASPECTFRAME(self.pointer), x_align as c_float, y_align as c_float, ratio as c_float, to_gboolean(obey_child)); } } } impl_drop!(AspectFrame); impl_TraitWidget!(AspectFrame); impl gtk::FrameTrait for AspectFrame {} impl gtk::ContainerTrait for AspectFrame {} impl_widget_events!(AspectFrame);
use libc::c_float;
random_line_split
aspect_frame.rs
// This file is part of rgtk. // // rgtk is free software: you can redistribute it and/or modify // it under the terms of the GNU Lesser General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // rgtk is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public License // along with rgtk. If not, see <http://www.gnu.org/licenses/>. //! A frame that constrains its child to a particular aspect ratio use libc::c_float; use glib::translate::ToGlibPtr; use gtk::cast::GTK_ASPECTFRAME; use gtk::{self, ffi}; use glib::to_gboolean; /// AspectFrame — A frame that constrains its child to a particular aspect ratio struct_Widget!(AspectFrame); impl AspectFrame { pub fn new(label: Option<&str>, x_align: f32, y_align: f32, ratio: f32, obey_child: bool) -> Option<AspectFrame> { let tmp_pointer = unsafe { ffi::gtk_aspect_frame_new(label.borrow_to_glib().0, x_align as c_float, y_align as c_float, ratio as c_float, to_gboolean(obey_child)) }; check_pointer!(tmp_pointer, AspectFrame) } pub fn se
mut self, x_align: f32, y_align: f32, ratio: f32, obey_child: bool) -> () { unsafe { ffi::gtk_aspect_frame_set(GTK_ASPECTFRAME(self.pointer), x_align as c_float, y_align as c_float, ratio as c_float, to_gboolean(obey_child)); } } } impl_drop!(AspectFrame); impl_TraitWidget!(AspectFrame); impl gtk::FrameTrait for AspectFrame {} impl gtk::ContainerTrait for AspectFrame {} impl_widget_events!(AspectFrame);
t(&
identifier_name
aspect_frame.rs
// This file is part of rgtk. // // rgtk is free software: you can redistribute it and/or modify // it under the terms of the GNU Lesser General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // rgtk is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public License // along with rgtk. If not, see <http://www.gnu.org/licenses/>. //! A frame that constrains its child to a particular aspect ratio use libc::c_float; use glib::translate::ToGlibPtr; use gtk::cast::GTK_ASPECTFRAME; use gtk::{self, ffi}; use glib::to_gboolean; /// AspectFrame — A frame that constrains its child to a particular aspect ratio struct_Widget!(AspectFrame); impl AspectFrame { pub fn new(label: Option<&str>, x_align: f32, y_align: f32, ratio: f32, obey_child: bool) -> Option<AspectFrame> {
pub fn set(&mut self, x_align: f32, y_align: f32, ratio: f32, obey_child: bool) -> () { unsafe { ffi::gtk_aspect_frame_set(GTK_ASPECTFRAME(self.pointer), x_align as c_float, y_align as c_float, ratio as c_float, to_gboolean(obey_child)); } } } impl_drop!(AspectFrame); impl_TraitWidget!(AspectFrame); impl gtk::FrameTrait for AspectFrame {} impl gtk::ContainerTrait for AspectFrame {} impl_widget_events!(AspectFrame);
let tmp_pointer = unsafe { ffi::gtk_aspect_frame_new(label.borrow_to_glib().0, x_align as c_float, y_align as c_float, ratio as c_float, to_gboolean(obey_child)) }; check_pointer!(tmp_pointer, AspectFrame) }
identifier_body
util.rs
// Copyright 2019 TiKV Project Authors. Licensed under Apache-2.0. use std::fmt; use std::str; // A struct that divide a name into serveral parts that meets rust's guidelines. struct NameSpliter<'a> { name: &'a [u8], pos: usize, } impl<'a> NameSpliter<'a> { fn new(s: &str) -> NameSpliter { NameSpliter { name: s.as_bytes(), pos: 0, } } } impl<'a> Iterator for NameSpliter<'a> { type Item = &'a str; fn next(&mut self) -> Option<&'a str> { if self.pos == self.name.len() { return None; } // skip all prefix '_' while self.pos < self.name.len() && self.name[self.pos] == b'_' { self.pos += 1; } let mut pos = self.name.len(); let mut upper_len = 0; let mut meet_lower = false; for i in self.pos..self.name.len() { let c = self.name[i]; if (b'A'..=b'Z').contains(&c) { if meet_lower { // So it should be AaA or aaA pos = i; break; } upper_len += 1; } else if c == b'_' { pos = i; break; } else { meet_lower = true; if upper_len > 1 { // So it should be AAa pos = i - 1; break; } } } let s = str::from_utf8(&self.name[self.pos..pos]).unwrap(); self.pos = pos; Some(s) } } /// Adjust method name to follow rust-guidelines. pub fn to_snake_case(name: &str) -> String { let mut snake_method_name = String::with_capacity(name.len()); for s in NameSpliter::new(name) { snake_method_name.push_str(&s.to_lowercase()); snake_method_name.push('_'); } snake_method_name.pop(); snake_method_name } #[cfg(feature = "protobuf-codec")] pub fn to_camel_case(name: &str) -> String { let mut camel_case_name = String::with_capacity(name.len()); for s in NameSpliter::new(name) { let mut chs = s.chars(); camel_case_name.extend(chs.next().unwrap().to_uppercase()); camel_case_name.push_str(&s[1..].to_lowercase()); } camel_case_name } pub fn fq_grpc(item: &str) -> String { format!("::grpcio::{}", item) } pub enum MethodType { Unary, ClientStreaming, ServerStreaming, Duplex, } impl fmt::Display for MethodType { fn
(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "{}", match self { MethodType::Unary => "MethodType::Unary", MethodType::ClientStreaming => "MethodType::ClientStreaming", MethodType::ServerStreaming => "MethodType::ServerStreaming", MethodType::Duplex => "MethodType::Duplex", } ) } } #[cfg(test)] mod test { #[test] fn test_snake_name() { let cases = vec![ ("AsyncRequest", "async_request"), ("asyncRequest", "async_request"), ("async_request", "async_request"), ("createID", "create_id"), ("AsyncRClient", "async_r_client"), ("CreateIDForReq", "create_id_for_req"), ("Create_ID_For_Req", "create_id_for_req"), ("Create_ID_For__Req", "create_id_for_req"), ("ID", "id"), ("id", "id"), ]; for (origin, exp) in cases { let res = super::to_snake_case(&origin); assert_eq!(res, exp); } } #[test] #[cfg(feature = "protobuf-codec")] fn test_camel_name() { let cases = vec![ ("AsyncRequest", "AsyncRequest"), ("asyncRequest", "AsyncRequest"), ("async_request", "AsyncRequest"), ("createID", "CreateId"), ("AsyncRClient", "AsyncRClient"), ("async_r_client", "AsyncRClient"), ("CreateIDForReq", "CreateIdForReq"), ("Create_ID_For_Req", "CreateIdForReq"), ("Create_ID_For__Req", "CreateIdForReq"), ("ID", "Id"), ("id", "Id"), ]; for (origin, exp) in cases { let res = super::to_camel_case(&origin); assert_eq!(res, exp); } } }
fmt
identifier_name
util.rs
// Copyright 2019 TiKV Project Authors. Licensed under Apache-2.0. use std::fmt; use std::str; // A struct that divide a name into serveral parts that meets rust's guidelines. struct NameSpliter<'a> { name: &'a [u8], pos: usize, } impl<'a> NameSpliter<'a> { fn new(s: &str) -> NameSpliter { NameSpliter { name: s.as_bytes(), pos: 0, } } } impl<'a> Iterator for NameSpliter<'a> { type Item = &'a str; fn next(&mut self) -> Option<&'a str> { if self.pos == self.name.len() { return None; } // skip all prefix '_' while self.pos < self.name.len() && self.name[self.pos] == b'_' { self.pos += 1; } let mut pos = self.name.len(); let mut upper_len = 0; let mut meet_lower = false; for i in self.pos..self.name.len() { let c = self.name[i]; if (b'A'..=b'Z').contains(&c)
else if c == b'_' { pos = i; break; } else { meet_lower = true; if upper_len > 1 { // So it should be AAa pos = i - 1; break; } } } let s = str::from_utf8(&self.name[self.pos..pos]).unwrap(); self.pos = pos; Some(s) } } /// Adjust method name to follow rust-guidelines. pub fn to_snake_case(name: &str) -> String { let mut snake_method_name = String::with_capacity(name.len()); for s in NameSpliter::new(name) { snake_method_name.push_str(&s.to_lowercase()); snake_method_name.push('_'); } snake_method_name.pop(); snake_method_name } #[cfg(feature = "protobuf-codec")] pub fn to_camel_case(name: &str) -> String { let mut camel_case_name = String::with_capacity(name.len()); for s in NameSpliter::new(name) { let mut chs = s.chars(); camel_case_name.extend(chs.next().unwrap().to_uppercase()); camel_case_name.push_str(&s[1..].to_lowercase()); } camel_case_name } pub fn fq_grpc(item: &str) -> String { format!("::grpcio::{}", item) } pub enum MethodType { Unary, ClientStreaming, ServerStreaming, Duplex, } impl fmt::Display for MethodType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "{}", match self { MethodType::Unary => "MethodType::Unary", MethodType::ClientStreaming => "MethodType::ClientStreaming", MethodType::ServerStreaming => "MethodType::ServerStreaming", MethodType::Duplex => "MethodType::Duplex", } ) } } #[cfg(test)] mod test { #[test] fn test_snake_name() { let cases = vec![ ("AsyncRequest", "async_request"), ("asyncRequest", "async_request"), ("async_request", "async_request"), ("createID", "create_id"), ("AsyncRClient", "async_r_client"), ("CreateIDForReq", "create_id_for_req"), ("Create_ID_For_Req", "create_id_for_req"), ("Create_ID_For__Req", "create_id_for_req"), ("ID", "id"), ("id", "id"), ]; for (origin, exp) in cases { let res = super::to_snake_case(&origin); assert_eq!(res, exp); } } #[test] #[cfg(feature = "protobuf-codec")] fn test_camel_name() { let cases = vec![ ("AsyncRequest", "AsyncRequest"), ("asyncRequest", "AsyncRequest"), ("async_request", "AsyncRequest"), ("createID", "CreateId"), ("AsyncRClient", "AsyncRClient"), ("async_r_client", "AsyncRClient"), ("CreateIDForReq", "CreateIdForReq"), ("Create_ID_For_Req", "CreateIdForReq"), ("Create_ID_For__Req", "CreateIdForReq"), ("ID", "Id"), ("id", "Id"), ]; for (origin, exp) in cases { let res = super::to_camel_case(&origin); assert_eq!(res, exp); } } }
{ if meet_lower { // So it should be AaA or aaA pos = i; break; } upper_len += 1; }
conditional_block
util.rs
// Copyright 2019 TiKV Project Authors. Licensed under Apache-2.0. use std::fmt; use std::str; // A struct that divide a name into serveral parts that meets rust's guidelines. struct NameSpliter<'a> { name: &'a [u8], pos: usize, } impl<'a> NameSpliter<'a> { fn new(s: &str) -> NameSpliter { NameSpliter { name: s.as_bytes(), pos: 0, } } } impl<'a> Iterator for NameSpliter<'a> { type Item = &'a str; fn next(&mut self) -> Option<&'a str> { if self.pos == self.name.len() { return None; } // skip all prefix '_' while self.pos < self.name.len() && self.name[self.pos] == b'_' { self.pos += 1; } let mut pos = self.name.len(); let mut upper_len = 0; let mut meet_lower = false; for i in self.pos..self.name.len() { let c = self.name[i]; if (b'A'..=b'Z').contains(&c) { if meet_lower { // So it should be AaA or aaA pos = i; break; } upper_len += 1; } else if c == b'_' { pos = i; break; } else { meet_lower = true; if upper_len > 1 { // So it should be AAa pos = i - 1; break; } } } let s = str::from_utf8(&self.name[self.pos..pos]).unwrap(); self.pos = pos; Some(s) } } /// Adjust method name to follow rust-guidelines. pub fn to_snake_case(name: &str) -> String { let mut snake_method_name = String::with_capacity(name.len()); for s in NameSpliter::new(name) { snake_method_name.push_str(&s.to_lowercase()); snake_method_name.push('_'); } snake_method_name.pop(); snake_method_name } #[cfg(feature = "protobuf-codec")] pub fn to_camel_case(name: &str) -> String { let mut camel_case_name = String::with_capacity(name.len()); for s in NameSpliter::new(name) { let mut chs = s.chars(); camel_case_name.extend(chs.next().unwrap().to_uppercase()); camel_case_name.push_str(&s[1..].to_lowercase()); } camel_case_name } pub fn fq_grpc(item: &str) -> String { format!("::grpcio::{}", item) } pub enum MethodType { Unary, ClientStreaming, ServerStreaming, Duplex, } impl fmt::Display for MethodType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "{}", match self { MethodType::Unary => "MethodType::Unary", MethodType::ClientStreaming => "MethodType::ClientStreaming", MethodType::ServerStreaming => "MethodType::ServerStreaming", MethodType::Duplex => "MethodType::Duplex", } ) } } #[cfg(test)] mod test {
("async_request", "async_request"), ("createID", "create_id"), ("AsyncRClient", "async_r_client"), ("CreateIDForReq", "create_id_for_req"), ("Create_ID_For_Req", "create_id_for_req"), ("Create_ID_For__Req", "create_id_for_req"), ("ID", "id"), ("id", "id"), ]; for (origin, exp) in cases { let res = super::to_snake_case(&origin); assert_eq!(res, exp); } } #[test] #[cfg(feature = "protobuf-codec")] fn test_camel_name() { let cases = vec![ ("AsyncRequest", "AsyncRequest"), ("asyncRequest", "AsyncRequest"), ("async_request", "AsyncRequest"), ("createID", "CreateId"), ("AsyncRClient", "AsyncRClient"), ("async_r_client", "AsyncRClient"), ("CreateIDForReq", "CreateIdForReq"), ("Create_ID_For_Req", "CreateIdForReq"), ("Create_ID_For__Req", "CreateIdForReq"), ("ID", "Id"), ("id", "Id"), ]; for (origin, exp) in cases { let res = super::to_camel_case(&origin); assert_eq!(res, exp); } } }
#[test] fn test_snake_name() { let cases = vec![ ("AsyncRequest", "async_request"), ("asyncRequest", "async_request"),
random_line_split
expr.rs
#![allow(dead_code)] use super::*; use std::fmt; use std::sync::Arc; #[derive(Clone, Debug)] pub enum Expr { Nil, Bool(bool), Int(i64), Flt(f64), Str(String), Sym(Symbol), Func(Arc<Function>), Macro(Arc<Macro>), List(List), Vector(Vector), Map(Map), } impl Expr {
} else { None } } pub fn int(&self) -> Option<i64> { if let Expr::Int(x) = *self { Some(x) } else { None } } pub fn flt(&self) -> Option<f64> { if let Expr::Flt(x) = *self { Some(x) } else { None } } pub fn str(&self) -> Option<&str> { if let Expr::Str(ref x) = *self { Some(x) } else { None } } pub fn sym(&self) -> Option<&Symbol> { if let Expr::Sym(ref x) = *self { Some(x) } else { None } } pub fn list(&self) -> Option<&List> { if let Expr::List(ref x) = *self { Some(x) } else { None } } pub fn vector(&self) -> Option<&Vector> { if let Expr::Vector(ref x) = *self { Some(x) } else { None } } pub fn func(&self) -> Option<Arc<Function>> { if let Expr::Func(ref x) = *self { Some(x.clone()) } else { None } } pub fn truthiness(&self) -> bool { match *self { Expr::Nil => false, Expr::Bool(b) => b, _ => true, } } pub fn is_int(&self) -> bool { self.int().is_some() } pub fn is_flt(&self) -> bool { self.flt().is_some() } pub fn is_num(&self) -> bool { match *self { Expr::Flt(_) | Expr::Int(_) => true, _ => false, } } pub fn map_int<E, F>(self, f: F) -> Expr where F: FnOnce(i64) -> E, E: Into<Expr> { match self { Expr::Int(int) => f(int).into(), _ => self, } } pub fn map_flt<E, F>(self, f: F) -> Expr where F: FnOnce(f64) -> E, E: Into<Expr> { match self { Expr::Flt(flt) => f(flt).into(), _ => self, } } } impl fmt::Display for Expr { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match *self { Expr::Nil => write!(f, "()"), Expr::Bool(boolean) => write!(f, "#{}", if boolean { "t" } else { "f" }), Expr::Int(int) => write!(f, "{}", int), Expr::Flt(flt) => write!(f, "{}", flt), Expr::Str(ref string) => write!(f, "\"{}\"", string), Expr::Sym(ref sym) => write!(f, "{}", sym.0), Expr::Func(ref func) => write!(f, "{}", func), Expr::Macro(ref mac) => write!(f, "{}", mac), Expr::List(ref list) => write!(f, "{}", list), Expr::Vector(ref vec) => write!(f, "{}", vec), Expr::Map(ref map) => write!(f, "{}", map), } } } impl PartialEq for Expr { fn eq(&self, other: &Self) -> bool { use self::Expr::*; match (self, other) { (&Nil, &Nil) => true, (&Bool(ref a), &Bool(ref b)) => a == b, (&Int(ref a), &Int(ref b)) => a == b, (&Flt(ref a), &Flt(ref b)) => a == b, (&Str(ref a), &Str(ref b)) => a == b, (&Sym(ref a), &Sym(ref b)) => a == b, (&Func(_), &Func(_)) => false, (&Macro(_), &Macro(_)) => false, (&List(ref a), &List(ref b)) => a == b, (&Vector(ref a), &Vector(ref b)) => a == b, (&Map(ref a), &Map(ref b)) => a == b, _ => false, } } } #[cfg(test)] mod test { use super::*; use env::Env; use ops; #[test] fn call_fn() { let env = ops::env(); let add = env.lookup("+").clone().and_then(|f| f.func()).expect( "Expected #[+] in builtins", ); let nums: Vec<Expr> = vec![1i64, 2i64].into_iter().map(Expr::from).collect(); let result = add.apply(nums.as_slice(), env.clone()); assert_eq!(Expr::from(3), result.unwrap()); } #[test] fn test_env() { let new_scope = Env::default(); assert!(new_scope.lookup("hello").is_none()); } }
pub fn boolean(&self) -> Option<bool> { if let Expr::Bool(x) = *self { Some(x)
random_line_split
expr.rs
#![allow(dead_code)] use super::*; use std::fmt; use std::sync::Arc; #[derive(Clone, Debug)] pub enum Expr { Nil, Bool(bool), Int(i64), Flt(f64), Str(String), Sym(Symbol), Func(Arc<Function>), Macro(Arc<Macro>), List(List), Vector(Vector), Map(Map), } impl Expr { pub fn boolean(&self) -> Option<bool> { if let Expr::Bool(x) = *self { Some(x) } else { None } } pub fn int(&self) -> Option<i64> { if let Expr::Int(x) = *self { Some(x) } else { None } } pub fn flt(&self) -> Option<f64> { if let Expr::Flt(x) = *self { Some(x) } else { None } } pub fn str(&self) -> Option<&str> { if let Expr::Str(ref x) = *self { Some(x) } else { None } } pub fn sym(&self) -> Option<&Symbol> { if let Expr::Sym(ref x) = *self { Some(x) } else { None } } pub fn list(&self) -> Option<&List> { if let Expr::List(ref x) = *self { Some(x) } else { None } } pub fn vector(&self) -> Option<&Vector> { if let Expr::Vector(ref x) = *self { Some(x) } else { None } } pub fn func(&self) -> Option<Arc<Function>> { if let Expr::Func(ref x) = *self { Some(x.clone()) } else { None } } pub fn truthiness(&self) -> bool { match *self { Expr::Nil => false, Expr::Bool(b) => b, _ => true, } } pub fn is_int(&self) -> bool
pub fn is_flt(&self) -> bool { self.flt().is_some() } pub fn is_num(&self) -> bool { match *self { Expr::Flt(_) | Expr::Int(_) => true, _ => false, } } pub fn map_int<E, F>(self, f: F) -> Expr where F: FnOnce(i64) -> E, E: Into<Expr> { match self { Expr::Int(int) => f(int).into(), _ => self, } } pub fn map_flt<E, F>(self, f: F) -> Expr where F: FnOnce(f64) -> E, E: Into<Expr> { match self { Expr::Flt(flt) => f(flt).into(), _ => self, } } } impl fmt::Display for Expr { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match *self { Expr::Nil => write!(f, "()"), Expr::Bool(boolean) => write!(f, "#{}", if boolean { "t" } else { "f" }), Expr::Int(int) => write!(f, "{}", int), Expr::Flt(flt) => write!(f, "{}", flt), Expr::Str(ref string) => write!(f, "\"{}\"", string), Expr::Sym(ref sym) => write!(f, "{}", sym.0), Expr::Func(ref func) => write!(f, "{}", func), Expr::Macro(ref mac) => write!(f, "{}", mac), Expr::List(ref list) => write!(f, "{}", list), Expr::Vector(ref vec) => write!(f, "{}", vec), Expr::Map(ref map) => write!(f, "{}", map), } } } impl PartialEq for Expr { fn eq(&self, other: &Self) -> bool { use self::Expr::*; match (self, other) { (&Nil, &Nil) => true, (&Bool(ref a), &Bool(ref b)) => a == b, (&Int(ref a), &Int(ref b)) => a == b, (&Flt(ref a), &Flt(ref b)) => a == b, (&Str(ref a), &Str(ref b)) => a == b, (&Sym(ref a), &Sym(ref b)) => a == b, (&Func(_), &Func(_)) => false, (&Macro(_), &Macro(_)) => false, (&List(ref a), &List(ref b)) => a == b, (&Vector(ref a), &Vector(ref b)) => a == b, (&Map(ref a), &Map(ref b)) => a == b, _ => false, } } } #[cfg(test)] mod test { use super::*; use env::Env; use ops; #[test] fn call_fn() { let env = ops::env(); let add = env.lookup("+").clone().and_then(|f| f.func()).expect( "Expected #[+] in builtins", ); let nums: Vec<Expr> = vec![1i64, 2i64].into_iter().map(Expr::from).collect(); let result = add.apply(nums.as_slice(), env.clone()); assert_eq!(Expr::from(3), result.unwrap()); } #[test] fn test_env() { let new_scope = Env::default(); assert!(new_scope.lookup("hello").is_none()); } }
{ self.int().is_some() }
identifier_body
expr.rs
#![allow(dead_code)] use super::*; use std::fmt; use std::sync::Arc; #[derive(Clone, Debug)] pub enum Expr { Nil, Bool(bool), Int(i64), Flt(f64), Str(String), Sym(Symbol), Func(Arc<Function>), Macro(Arc<Macro>), List(List), Vector(Vector), Map(Map), } impl Expr { pub fn boolean(&self) -> Option<bool> { if let Expr::Bool(x) = *self { Some(x) } else { None } } pub fn int(&self) -> Option<i64> { if let Expr::Int(x) = *self { Some(x) } else { None } } pub fn flt(&self) -> Option<f64> { if let Expr::Flt(x) = *self { Some(x) } else { None } } pub fn str(&self) -> Option<&str> { if let Expr::Str(ref x) = *self { Some(x) } else { None } } pub fn sym(&self) -> Option<&Symbol> { if let Expr::Sym(ref x) = *self { Some(x) } else { None } } pub fn list(&self) -> Option<&List> { if let Expr::List(ref x) = *self { Some(x) } else { None } } pub fn
(&self) -> Option<&Vector> { if let Expr::Vector(ref x) = *self { Some(x) } else { None } } pub fn func(&self) -> Option<Arc<Function>> { if let Expr::Func(ref x) = *self { Some(x.clone()) } else { None } } pub fn truthiness(&self) -> bool { match *self { Expr::Nil => false, Expr::Bool(b) => b, _ => true, } } pub fn is_int(&self) -> bool { self.int().is_some() } pub fn is_flt(&self) -> bool { self.flt().is_some() } pub fn is_num(&self) -> bool { match *self { Expr::Flt(_) | Expr::Int(_) => true, _ => false, } } pub fn map_int<E, F>(self, f: F) -> Expr where F: FnOnce(i64) -> E, E: Into<Expr> { match self { Expr::Int(int) => f(int).into(), _ => self, } } pub fn map_flt<E, F>(self, f: F) -> Expr where F: FnOnce(f64) -> E, E: Into<Expr> { match self { Expr::Flt(flt) => f(flt).into(), _ => self, } } } impl fmt::Display for Expr { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match *self { Expr::Nil => write!(f, "()"), Expr::Bool(boolean) => write!(f, "#{}", if boolean { "t" } else { "f" }), Expr::Int(int) => write!(f, "{}", int), Expr::Flt(flt) => write!(f, "{}", flt), Expr::Str(ref string) => write!(f, "\"{}\"", string), Expr::Sym(ref sym) => write!(f, "{}", sym.0), Expr::Func(ref func) => write!(f, "{}", func), Expr::Macro(ref mac) => write!(f, "{}", mac), Expr::List(ref list) => write!(f, "{}", list), Expr::Vector(ref vec) => write!(f, "{}", vec), Expr::Map(ref map) => write!(f, "{}", map), } } } impl PartialEq for Expr { fn eq(&self, other: &Self) -> bool { use self::Expr::*; match (self, other) { (&Nil, &Nil) => true, (&Bool(ref a), &Bool(ref b)) => a == b, (&Int(ref a), &Int(ref b)) => a == b, (&Flt(ref a), &Flt(ref b)) => a == b, (&Str(ref a), &Str(ref b)) => a == b, (&Sym(ref a), &Sym(ref b)) => a == b, (&Func(_), &Func(_)) => false, (&Macro(_), &Macro(_)) => false, (&List(ref a), &List(ref b)) => a == b, (&Vector(ref a), &Vector(ref b)) => a == b, (&Map(ref a), &Map(ref b)) => a == b, _ => false, } } } #[cfg(test)] mod test { use super::*; use env::Env; use ops; #[test] fn call_fn() { let env = ops::env(); let add = env.lookup("+").clone().and_then(|f| f.func()).expect( "Expected #[+] in builtins", ); let nums: Vec<Expr> = vec![1i64, 2i64].into_iter().map(Expr::from).collect(); let result = add.apply(nums.as_slice(), env.clone()); assert_eq!(Expr::from(3), result.unwrap()); } #[test] fn test_env() { let new_scope = Env::default(); assert!(new_scope.lookup("hello").is_none()); } }
vector
identifier_name
astconv.rs
Some(a) => fmt!("lifetime %s", lifetime_to_str(a, tcx.sess.intr())) }; tcx.sess.span_err( span, fmt!("Illegal %s: %s", descr, e.msg)); e.replacement } } } pub fn ast_region_to_region<AC:AstConv,RS:region_scope + Copy + Durable>( self: &AC, rscope: &RS, default_span: span, opt_lifetime: Option<@ast::Lifetime>) -> ty::Region { let (span, res) = match opt_lifetime { None => { (default_span, rscope.anon_region(default_span)) } Some(ref lifetime) if lifetime.ident == special_idents::static => { (lifetime.span, Ok(ty::re_static)) } Some(ref lifetime) if lifetime.ident == special_idents::self_ => { (lifetime.span, rscope.self_region(lifetime.span)) } Some(ref lifetime) => { (lifetime.span, rscope.named_region(lifetime.span, lifetime.ident)) } }; get_region_reporting_err(self.tcx(), span, opt_lifetime, res) } pub fn ast_path_to_substs_and_ty<AC:AstConv,RS:region_scope + Copy + Durable>( self: &AC, rscope: &RS, did: ast::def_id, path: @ast::path) -> ty_param_substs_and_ty { let tcx = self.tcx(); let ty::ty_param_bounds_and_ty { bounds: decl_bounds, region_param: decl_rp, ty: decl_ty } = self.get_item_ty(did); debug!("ast_path_to_substs_and_ty: did=%? decl_rp=%?", did, decl_rp); // If the type is parameterized by the self region, then replace self // region with the current anon region binding (in other words, // whatever & would get replaced with). let self_r = match (decl_rp, path.rp) { (None, None) => { None } (None, Some(_)) => { tcx.sess.span_err( path.span, fmt!("no region bound is allowed on `%s`, \ which is not declared as containing region pointers", ty::item_path_str(tcx, did))); None } (Some(_), None) => { let res = rscope.anon_region(path.span); let r = get_region_reporting_err(self.tcx(), path.span, None, res); Some(r) } (Some(_), Some(_)) => { Some(ast_region_to_region(self, rscope, path.span, path.rp)) } }; // Convert the type parameters supplied by the user. if!vec::same_length(*decl_bounds, path.types) { self.tcx().sess.span_fatal( path.span, fmt!("wrong number of type arguments: expected %u but found %u", (*decl_bounds).len(), path.types.len())); } let tps = path.types.map(|a_t| ast_ty_to_ty(self, rscope, *a_t)); let substs = substs {self_r:self_r, self_ty:None, tps:tps}; let ty = ty::subst(tcx, &substs, decl_ty); ty_param_substs_and_ty { substs: substs, ty: ty } } pub fn ast_path_to_ty<AC:AstConv,RS:region_scope + Copy + Durable>( self: &AC, rscope: &RS, did: ast::def_id, path: @ast::path) -> ty_param_substs_and_ty
pub static NO_REGIONS: uint = 1; pub static NO_TPS: uint = 2; // Parses the programmer's textual representation of a type into our // internal notion of a type. `getter` is a function that returns the type // corresponding to a definition ID: pub fn ast_ty_to_ty<AC:AstConv, RS:region_scope + Copy + Durable>( self: &AC, rscope: &RS, &&ast_ty: @ast::Ty) -> ty::t { fn ast_mt_to_mt<AC:AstConv, RS:region_scope + Copy + Durable>( self: &AC, rscope: &RS, mt: &ast::mt) -> ty::mt { ty::mt {ty: ast_ty_to_ty(self, rscope, mt.ty), mutbl: mt.mutbl} } // Handle @, ~, and & being able to mean estrs and evecs. // If a_seq_ty is a str or a vec, make it an estr/evec. // Also handle first-class trait types. fn mk_pointer<AC:AstConv,RS:region_scope + Copy + Durable>( self: &AC, rscope: &RS, a_seq_ty: &ast::mt, vst: ty::vstore, constr: &fn(ty::mt) -> ty::t) -> ty::t { let tcx = self.tcx(); match a_seq_ty.ty.node { ast::ty_vec(ref mt) => { let mut mt = ast_mt_to_mt(self, rscope, mt); if a_seq_ty.mutbl == ast::m_mutbl || a_seq_ty.mutbl == ast::m_const { mt = ty::mt { ty: mt.ty, mutbl: a_seq_ty.mutbl }; } return ty::mk_evec(tcx, mt, vst); } ast::ty_path(path, id) if a_seq_ty.mutbl == ast::m_imm => { match tcx.def_map.find(&id) { Some(&ast::def_prim_ty(ast::ty_str)) => { check_path_args(tcx, path, NO_TPS | NO_REGIONS); return ty::mk_estr(tcx, vst); } Some(&ast::def_ty(type_def_id)) => { let result = ast_path_to_substs_and_ty( self, rscope, type_def_id, path); match ty::get(result.ty).sty { ty::ty_trait(trait_def_id, ref substs, _) => { let trait_store = match vst { ty::vstore_box => ty::BoxTraitStore, ty::vstore_uniq => ty::UniqTraitStore, ty::vstore_slice(r) => { ty::RegionTraitStore(r) } ty::vstore_fixed(*) => { tcx.sess.span_err( path.span, ~"@trait, ~trait or &trait \ are the only supported \ forms of casting-to-\ trait"); ty::BoxTraitStore } }; return ty::mk_trait(tcx, trait_def_id, /*bad*/copy *substs, trait_store); } _ => {} } } _ => {} } } _ => {} } let seq_ty = ast_mt_to_mt(self, rscope, a_seq_ty); return constr(seq_ty); } fn check_path_args(tcx: ty::ctxt, path: @ast::path, flags: uint) { if (flags & NO_TPS)!= 0u { if path.types.len() > 0u { tcx.sess.span_err( path.span, ~"type parameters are not allowed on this type"); } } if (flags & NO_REGIONS)!= 0u { if path.rp.is_some() { tcx.sess.span_err( path.span, ~"region parameters are not allowed on this type"); } } } let tcx = self.tcx(); match tcx.ast_ty_to_ty_cache.find(&ast_ty.id) { Some(&ty::atttce_resolved(ty)) => return ty, Some(&ty::atttce_unresolved) => { tcx.sess.span_fatal(ast_ty.span, ~"illegal recursive type; \ insert an enum in the cycle, \ if this is desired"); } None => { /* go on */ } } tcx.ast_ty_to_ty_cache.insert(ast_ty.id, ty::atttce_unresolved); let typ = match ast_ty.node { ast::ty_nil => ty::mk_nil(tcx), ast::ty_bot => ty::mk_bot(tcx), ast::ty_box(ref mt) => { mk_pointer(self, rscope, mt, ty::vstore_box, |tmt| ty::mk_box(tcx, tmt)) } ast::ty_uniq(ref mt) => { mk_pointer(self, rscope, mt, ty::vstore_uniq, |tmt| ty::mk_uniq(tcx, tmt)) } ast::ty_vec(ref mt) => { tcx.sess.span_err(ast_ty.span, ~"bare `[]` is not a type"); // return /something/ so they can at least get more errors ty::mk_evec(tcx, ast_mt_to_mt(self, rscope, mt), ty::vstore_uniq) } ast::ty_ptr(ref mt) => { ty::mk_ptr(tcx, ast_mt_to_mt(self, rscope, mt)) } ast::ty_rptr(region, ref mt) => { let r = ast_region_to_region(self, rscope, ast_ty.span, region); mk_pointer(self, rscope, mt, ty::vstore_slice(r), |tmt| ty::mk_rptr(tcx, r, tmt)) } ast::ty_tup(ref fields) => { let flds = fields.map(|t| ast_ty_to_ty(self, rscope, *t)); ty::mk_tup(tcx, flds) } ast::ty_bare_fn(ref bf) => { ty::mk_bare_fn(tcx, ty_of_bare_fn(self, rscope, bf.purity, bf.abis, &bf.lifetimes, &bf.decl)) } ast::ty_closure(ref f) => { let fn_decl = ty_of_closure(self, rscope, f.sigil, f.purity, f.onceness, f.region, &f.decl, None, &f.lifetimes, ast_ty.span); ty::mk_closure(tcx, fn_decl) } ast::ty_path(path, id) => { let a_def = match tcx.def_map.find(&id) { None => tcx.sess.span_fatal( ast_ty.span, fmt!("unbound path %s", path_to_str(path, tcx.sess.intr()))), Some(&d) => d }; match a_def { ast::def_ty(did) | ast::def_struct(did) => { ast_path_to_ty(self, rscope, did, path).ty } ast::def_prim_ty(nty) => { match nty { ast::ty_bool => { check_path_args(tcx, path, NO_TPS | NO_REGIONS); ty::mk_bool(tcx) } ast::ty_int(it) => { check_path_args(tcx, path, NO_TPS | NO_REGIONS); ty::mk_mach_int(tcx, it) } ast::ty_uint(uit) => { check_path_args(tcx, path, NO_TPS | NO_REGIONS); ty::mk_mach_uint(tcx, uit) } ast::ty_float(ft) => { check_path_args(tcx, path, NO_TPS | NO_REGIONS); ty::mk_mach_float(tcx, ft) } ast::ty_str => { tcx.sess.span_err(ast_ty.span, ~"bare `str` is not a type"); // return /something/ so they can at least get more errors ty::mk_estr(tcx, ty::vstore_uniq) } } } ast::def_ty_param(id, n) => { check_path_args(tcx, path, NO_TPS | NO_REGIONS); ty::mk_param(tcx, n, id) } ast::def_self_ty(id) => { // n.b.: resolve guarantees that the self type only appears in a // trait, which we rely upon in various places when creating // substs check_path_args(tcx, path, NO_TPS | NO_REGIONS); let did = ast_util::local_def(id); ty::mk_self(tcx, did) } _ => { tcx.sess.span_fatal(ast_ty.span, ~"found type name used as a variable"); } } } ast::ty_fixed_length_vec(ref a_mt, e) => { match const_eval::eval_const_expr_partial(tcx, e) { Ok(ref r) => { match *r { const_eval::const_int(i) => ty::mk_evec(tcx, ast_mt_to_mt(self, rscope, a_mt), ty::vstore_fixed(i as uint)), const_eval::const_uint(i) => ty::mk_evec(tcx, ast_mt_to_mt(self, rscope, a_mt), ty::vstore_fixed(i as uint)), _ => { tcx.sess.span_fatal( ast_ty.span, ~"expected constant expr for vector length"); } } } Err(ref r) => { tcx.sess.span_fatal( ast_ty.span, fmt!("expected constant expr for vector length: %s", *r)); } } } ast::ty_infer => { // ty_infer should only appear as the type of arguments or return // values in a fn_expr, or as the type of local variables. Both of // these cases are handled specially and should not descend into this // routine. self.tcx().sess.span_bug( ast_ty.span, ~"found `ty_infer` in unexpected place"); } ast::ty_mac(_) => { tcx.sess.span_bug(ast_ty.span, ~"found `ty_mac` in unexpected place"); } }; tcx.ast_ty_to_ty_cache.insert(ast_ty.id, ty::atttce_resolved(typ)); return typ; } pub fn ty_of_arg<AC:AstConv,RS:region_scope + Copy + Durable>( self: &AC, rscope: &RS, a: ast::arg, expected_ty: Option<ty::arg>) -> ty::arg { let ty = match a.ty.node { ast::ty_infer if expected_ty.is_some() => expected_ty.get().ty, ast::ty_infer => self.ty_infer(a.ty.span), _ => ast_ty_to_ty(self, rscope, a.ty) }; let mode = { match a.mode {
{ // Look up the polytype of the item and then substitute the provided types // for any type/region parameters. let ty::ty_param_substs_and_ty { substs: substs, ty: ty } = ast_path_to_substs_and_ty(self, rscope, did, path); ty_param_substs_and_ty { substs: substs, ty: ty } }
identifier_body
astconv.rs
( tcx: ty::ctxt, span: span, a_r: Option<@ast::Lifetime>, res: Result<ty::Region, RegionError>) -> ty::Region { match res { result::Ok(r) => r, result::Err(ref e) => { let descr = match a_r { None => ~"anonymous lifetime", Some(a) => fmt!("lifetime %s", lifetime_to_str(a, tcx.sess.intr())) }; tcx.sess.span_err( span, fmt!("Illegal %s: %s", descr, e.msg)); e.replacement } } } pub fn ast_region_to_region<AC:AstConv,RS:region_scope + Copy + Durable>( self: &AC, rscope: &RS, default_span: span, opt_lifetime: Option<@ast::Lifetime>) -> ty::Region { let (span, res) = match opt_lifetime { None => { (default_span, rscope.anon_region(default_span)) } Some(ref lifetime) if lifetime.ident == special_idents::static => { (lifetime.span, Ok(ty::re_static)) } Some(ref lifetime) if lifetime.ident == special_idents::self_ => { (lifetime.span, rscope.self_region(lifetime.span)) } Some(ref lifetime) => { (lifetime.span, rscope.named_region(lifetime.span, lifetime.ident)) } }; get_region_reporting_err(self.tcx(), span, opt_lifetime, res) } pub fn ast_path_to_substs_and_ty<AC:AstConv,RS:region_scope + Copy + Durable>( self: &AC, rscope: &RS, did: ast::def_id, path: @ast::path) -> ty_param_substs_and_ty { let tcx = self.tcx(); let ty::ty_param_bounds_and_ty { bounds: decl_bounds, region_param: decl_rp, ty: decl_ty } = self.get_item_ty(did); debug!("ast_path_to_substs_and_ty: did=%? decl_rp=%?", did, decl_rp); // If the type is parameterized by the self region, then replace self // region with the current anon region binding (in other words, // whatever & would get replaced with). let self_r = match (decl_rp, path.rp) { (None, None) => { None } (None, Some(_)) => { tcx.sess.span_err( path.span, fmt!("no region bound is allowed on `%s`, \ which is not declared as containing region pointers", ty::item_path_str(tcx, did))); None } (Some(_), None) => { let res = rscope.anon_region(path.span); let r = get_region_reporting_err(self.tcx(), path.span, None, res); Some(r) } (Some(_), Some(_)) => { Some(ast_region_to_region(self, rscope, path.span, path.rp)) } }; // Convert the type parameters supplied by the user. if!vec::same_length(*decl_bounds, path.types) { self.tcx().sess.span_fatal( path.span, fmt!("wrong number of type arguments: expected %u but found %u", (*decl_bounds).len(), path.types.len())); } let tps = path.types.map(|a_t| ast_ty_to_ty(self, rscope, *a_t)); let substs = substs {self_r:self_r, self_ty:None, tps:tps}; let ty = ty::subst(tcx, &substs, decl_ty); ty_param_substs_and_ty { substs: substs, ty: ty } } pub fn ast_path_to_ty<AC:AstConv,RS:region_scope + Copy + Durable>( self: &AC, rscope: &RS, did: ast::def_id, path: @ast::path) -> ty_param_substs_and_ty { // Look up the polytype of the item and then substitute the provided types // for any type/region parameters. let ty::ty_param_substs_and_ty { substs: substs, ty: ty } = ast_path_to_substs_and_ty(self, rscope, did, path); ty_param_substs_and_ty { substs: substs, ty: ty } } pub static NO_REGIONS: uint = 1; pub static NO_TPS: uint = 2; // Parses the programmer's textual representation of a type into our // internal notion of a type. `getter` is a function that returns the type // corresponding to a definition ID: pub fn ast_ty_to_ty<AC:AstConv, RS:region_scope + Copy + Durable>( self: &AC, rscope: &RS, &&ast_ty: @ast::Ty) -> ty::t { fn ast_mt_to_mt<AC:AstConv, RS:region_scope + Copy + Durable>( self: &AC, rscope: &RS, mt: &ast::mt) -> ty::mt { ty::mt {ty: ast_ty_to_ty(self, rscope, mt.ty), mutbl: mt.mutbl} } // Handle @, ~, and & being able to mean estrs and evecs. // If a_seq_ty is a str or a vec, make it an estr/evec. // Also handle first-class trait types. fn mk_pointer<AC:AstConv,RS:region_scope + Copy + Durable>( self: &AC, rscope: &RS, a_seq_ty: &ast::mt, vst: ty::vstore, constr: &fn(ty::mt) -> ty::t) -> ty::t { let tcx = self.tcx(); match a_seq_ty.ty.node { ast::ty_vec(ref mt) => { let mut mt = ast_mt_to_mt(self, rscope, mt); if a_seq_ty.mutbl == ast::m_mutbl || a_seq_ty.mutbl == ast::m_const { mt = ty::mt { ty: mt.ty, mutbl: a_seq_ty.mutbl }; } return ty::mk_evec(tcx, mt, vst); } ast::ty_path(path, id) if a_seq_ty.mutbl == ast::m_imm => { match tcx.def_map.find(&id) { Some(&ast::def_prim_ty(ast::ty_str)) => { check_path_args(tcx, path, NO_TPS | NO_REGIONS); return ty::mk_estr(tcx, vst); } Some(&ast::def_ty(type_def_id)) => { let result = ast_path_to_substs_and_ty( self, rscope, type_def_id, path); match ty::get(result.ty).sty { ty::ty_trait(trait_def_id, ref substs, _) => { let trait_store = match vst { ty::vstore_box => ty::BoxTraitStore, ty::vstore_uniq => ty::UniqTraitStore, ty::vstore_slice(r) => { ty::RegionTraitStore(r) } ty::vstore_fixed(*) => { tcx.sess.span_err( path.span, ~"@trait, ~trait or &trait \ are the only supported \ forms of casting-to-\ trait"); ty::BoxTraitStore } }; return ty::mk_trait(tcx, trait_def_id, /*bad*/copy *substs, trait_store); } _ => {} } } _ => {} } } _ => {} } let seq_ty = ast_mt_to_mt(self, rscope, a_seq_ty); return constr(seq_ty); } fn check_path_args(tcx: ty::ctxt, path: @ast::path, flags: uint) { if (flags & NO_TPS)!= 0u { if path.types.len() > 0u { tcx.sess.span_err( path.span, ~"type parameters are not allowed on this type"); } } if (flags & NO_REGIONS)!= 0u { if path.rp.is_some() { tcx.sess.span_err( path.span, ~"region parameters are not allowed on this type"); } } } let tcx = self.tcx(); match tcx.ast_ty_to_ty_cache.find(&ast_ty.id) { Some(&ty::atttce_resolved(ty)) => return ty, Some(&ty::atttce_unresolved) => { tcx.sess.span_fatal(ast_ty.span, ~"illegal recursive type; \ insert an enum in the cycle, \ if this is desired"); } None => { /* go on */ } } tcx.ast_ty_to_ty_cache.insert(ast_ty.id, ty::atttce_unresolved); let typ = match ast_ty.node { ast::ty_nil => ty::mk_nil(tcx), ast::ty_bot => ty::mk_bot(tcx), ast::ty_box(ref mt) => { mk_pointer(self, rscope, mt, ty::vstore_box, |tmt| ty::mk_box(tcx, tmt)) } ast::ty_uniq(ref mt) => { mk_pointer(self, rscope, mt, ty::vstore_uniq, |tmt| ty::mk_uniq(tcx, tmt)) } ast::ty_vec(ref mt) => { tcx.sess.span_err(ast_ty.span, ~"bare `[]` is not a type"); // return /something/ so they can at least get more errors ty::mk_evec(tcx, ast_mt_to_mt(self, rscope, mt), ty::vstore_uniq) } ast::ty_ptr(ref mt) => { ty::mk_ptr(tcx, ast_mt_to_mt(self, rscope, mt)) } ast::ty_rptr(region, ref mt) => { let r = ast_region_to_region(self, rscope, ast_ty.span, region); mk_pointer(self, rscope, mt, ty::vstore_slice(r), |tmt| ty::mk_rptr(tcx, r, tmt)) } ast::ty_tup(ref fields) => { let flds = fields.map(|t| ast_ty_to_ty(self, rscope, *t)); ty::mk_tup(tcx, flds) } ast::ty_bare_fn(ref bf) => { ty::mk_bare_fn(tcx, ty_of_bare_fn(self, rscope, bf.purity, bf.abis, &bf.lifetimes, &bf.decl)) } ast::ty_closure(ref f) => { let fn_decl = ty_of_closure(self, rscope, f.sigil, f.purity, f.onceness, f.region, &f.decl, None, &f.lifetimes, ast_ty.span); ty::mk_closure(tcx, fn_decl) } ast::ty_path(path, id) => { let a_def = match tcx.def_map.find(&id) { None => tcx.sess.span_fatal( ast_ty.span, fmt!("unbound path %s", path_to_str(path, tcx.sess.intr()))), Some(&d) => d }; match a_def { ast::def_ty(did) | ast::def_struct(did) => { ast_path_to_ty(self, rscope, did, path).ty } ast::def_prim_ty(nty) => { match nty { ast::ty_bool => { check_path_args(tcx, path, NO_TPS | NO_REGIONS); ty::mk_bool(tcx) } ast::ty_int(it) => { check_path_args(tcx, path, NO_TPS | NO_REGIONS); ty::mk_mach_int(tcx, it) } ast::ty_uint(uit) => { check_path_args(tcx, path, NO_TPS | NO_REGIONS); ty::mk_mach_uint(tcx, uit) } ast::ty_float(ft) => { check_path_args(tcx, path, NO_TPS | NO_REGIONS); ty::mk_mach_float(tcx, ft) } ast::ty_str => { tcx.sess.span_err(ast_ty.span, ~"bare `str` is not a type"); // return /something/ so they can at least get more errors ty::mk_estr(tcx, ty::vstore_uniq) } } } ast::def_ty_param(id, n) => { check_path_args(tcx, path, NO_TPS | NO_REGIONS); ty::mk_param(tcx, n, id) } ast::def_self_ty(id) => { // n.b.: resolve guarantees that the self type only appears in a // trait, which we rely upon in various places when creating // substs check_path_args(tcx, path, NO_TPS | NO_REGIONS); let did = ast_util::local_def(id); ty::mk_self(tcx, did) } _ => { tcx.sess.span_fatal(ast_ty.span, ~"found type name used as a variable"); } } } ast::ty_fixed_length_vec(ref a_mt, e) => { match const_eval::eval_const_expr_partial(tcx, e) { Ok(ref r) => { match *r { const_eval::const_int(i) => ty::mk_evec(tcx, ast_mt_to_mt(self, rscope, a_mt), ty::vstore_fixed(i as uint)), const_eval::const_uint(i) => ty::mk_evec(tcx, ast_mt_to_mt(self, rscope, a_mt), ty::vstore_fixed(i as uint)), _ => { tcx.sess.span_fatal( ast_ty.span, ~"expected constant expr for vector length"); } } } Err(ref r) => { tcx.sess.span_fatal( ast_ty.span, fmt!("expected constant expr for vector length: %s", *r)); } } } ast::ty_infer => { // ty_infer should only appear as the type of arguments or return // values in a fn_expr, or as the type of local variables. Both of // these cases are handled specially and should not descend into this // routine. self.tcx().sess.span_bug( ast_ty.span, ~"found `ty_infer` in unexpected place"); } ast::ty_mac(_) => { tcx.sess.span_bug(ast_ty.span, ~"found `ty_mac` in unexpected place"); } }; tcx.ast_ty_to_ty_cache.insert(ast_ty.id, ty::atttce_resolved(typ)); return typ; } pub fn ty_of_arg<AC:AstConv,RS:region_scope + Copy + Durable>( self: &AC, rscope: &RS, a
get_region_reporting_err
identifier_name
astconv.rs
Some(a) => fmt!("lifetime %s", lifetime_to_str(a, tcx.sess.intr())) }; tcx.sess.span_err( span, fmt!("Illegal %s: %s", descr, e.msg)); e.replacement } } } pub fn ast_region_to_region<AC:AstConv,RS:region_scope + Copy + Durable>( self: &AC, rscope: &RS, default_span: span, opt_lifetime: Option<@ast::Lifetime>) -> ty::Region { let (span, res) = match opt_lifetime { None => { (default_span, rscope.anon_region(default_span)) } Some(ref lifetime) if lifetime.ident == special_idents::static => { (lifetime.span, Ok(ty::re_static)) } Some(ref lifetime) if lifetime.ident == special_idents::self_ => { (lifetime.span, rscope.self_region(lifetime.span)) } Some(ref lifetime) =>
}; get_region_reporting_err(self.tcx(), span, opt_lifetime, res) } pub fn ast_path_to_substs_and_ty<AC:AstConv,RS:region_scope + Copy + Durable>( self: &AC, rscope: &RS, did: ast::def_id, path: @ast::path) -> ty_param_substs_and_ty { let tcx = self.tcx(); let ty::ty_param_bounds_and_ty { bounds: decl_bounds, region_param: decl_rp, ty: decl_ty } = self.get_item_ty(did); debug!("ast_path_to_substs_and_ty: did=%? decl_rp=%?", did, decl_rp); // If the type is parameterized by the self region, then replace self // region with the current anon region binding (in other words, // whatever & would get replaced with). let self_r = match (decl_rp, path.rp) { (None, None) => { None } (None, Some(_)) => { tcx.sess.span_err( path.span, fmt!("no region bound is allowed on `%s`, \ which is not declared as containing region pointers", ty::item_path_str(tcx, did))); None } (Some(_), None) => { let res = rscope.anon_region(path.span); let r = get_region_reporting_err(self.tcx(), path.span, None, res); Some(r) } (Some(_), Some(_)) => { Some(ast_region_to_region(self, rscope, path.span, path.rp)) } }; // Convert the type parameters supplied by the user. if!vec::same_length(*decl_bounds, path.types) { self.tcx().sess.span_fatal( path.span, fmt!("wrong number of type arguments: expected %u but found %u", (*decl_bounds).len(), path.types.len())); } let tps = path.types.map(|a_t| ast_ty_to_ty(self, rscope, *a_t)); let substs = substs {self_r:self_r, self_ty:None, tps:tps}; let ty = ty::subst(tcx, &substs, decl_ty); ty_param_substs_and_ty { substs: substs, ty: ty } } pub fn ast_path_to_ty<AC:AstConv,RS:region_scope + Copy + Durable>( self: &AC, rscope: &RS, did: ast::def_id, path: @ast::path) -> ty_param_substs_and_ty { // Look up the polytype of the item and then substitute the provided types // for any type/region parameters. let ty::ty_param_substs_and_ty { substs: substs, ty: ty } = ast_path_to_substs_and_ty(self, rscope, did, path); ty_param_substs_and_ty { substs: substs, ty: ty } } pub static NO_REGIONS: uint = 1; pub static NO_TPS: uint = 2; // Parses the programmer's textual representation of a type into our // internal notion of a type. `getter` is a function that returns the type // corresponding to a definition ID: pub fn ast_ty_to_ty<AC:AstConv, RS:region_scope + Copy + Durable>( self: &AC, rscope: &RS, &&ast_ty: @ast::Ty) -> ty::t { fn ast_mt_to_mt<AC:AstConv, RS:region_scope + Copy + Durable>( self: &AC, rscope: &RS, mt: &ast::mt) -> ty::mt { ty::mt {ty: ast_ty_to_ty(self, rscope, mt.ty), mutbl: mt.mutbl} } // Handle @, ~, and & being able to mean estrs and evecs. // If a_seq_ty is a str or a vec, make it an estr/evec. // Also handle first-class trait types. fn mk_pointer<AC:AstConv,RS:region_scope + Copy + Durable>( self: &AC, rscope: &RS, a_seq_ty: &ast::mt, vst: ty::vstore, constr: &fn(ty::mt) -> ty::t) -> ty::t { let tcx = self.tcx(); match a_seq_ty.ty.node { ast::ty_vec(ref mt) => { let mut mt = ast_mt_to_mt(self, rscope, mt); if a_seq_ty.mutbl == ast::m_mutbl || a_seq_ty.mutbl == ast::m_const { mt = ty::mt { ty: mt.ty, mutbl: a_seq_ty.mutbl }; } return ty::mk_evec(tcx, mt, vst); } ast::ty_path(path, id) if a_seq_ty.mutbl == ast::m_imm => { match tcx.def_map.find(&id) { Some(&ast::def_prim_ty(ast::ty_str)) => { check_path_args(tcx, path, NO_TPS | NO_REGIONS); return ty::mk_estr(tcx, vst); } Some(&ast::def_ty(type_def_id)) => { let result = ast_path_to_substs_and_ty( self, rscope, type_def_id, path); match ty::get(result.ty).sty { ty::ty_trait(trait_def_id, ref substs, _) => { let trait_store = match vst { ty::vstore_box => ty::BoxTraitStore, ty::vstore_uniq => ty::UniqTraitStore, ty::vstore_slice(r) => { ty::RegionTraitStore(r) } ty::vstore_fixed(*) => { tcx.sess.span_err( path.span, ~"@trait, ~trait or &trait \ are the only supported \ forms of casting-to-\ trait"); ty::BoxTraitStore } }; return ty::mk_trait(tcx, trait_def_id, /*bad*/copy *substs, trait_store); } _ => {} } } _ => {} } } _ => {} } let seq_ty = ast_mt_to_mt(self, rscope, a_seq_ty); return constr(seq_ty); } fn check_path_args(tcx: ty::ctxt, path: @ast::path, flags: uint) { if (flags & NO_TPS)!= 0u { if path.types.len() > 0u { tcx.sess.span_err( path.span, ~"type parameters are not allowed on this type"); } } if (flags & NO_REGIONS)!= 0u { if path.rp.is_some() { tcx.sess.span_err( path.span, ~"region parameters are not allowed on this type"); } } } let tcx = self.tcx(); match tcx.ast_ty_to_ty_cache.find(&ast_ty.id) { Some(&ty::atttce_resolved(ty)) => return ty, Some(&ty::atttce_unresolved) => { tcx.sess.span_fatal(ast_ty.span, ~"illegal recursive type; \ insert an enum in the cycle, \ if this is desired"); } None => { /* go on */ } } tcx.ast_ty_to_ty_cache.insert(ast_ty.id, ty::atttce_unresolved); let typ = match ast_ty.node { ast::ty_nil => ty::mk_nil(tcx), ast::ty_bot => ty::mk_bot(tcx), ast::ty_box(ref mt) => { mk_pointer(self, rscope, mt, ty::vstore_box, |tmt| ty::mk_box(tcx, tmt)) } ast::ty_uniq(ref mt) => { mk_pointer(self, rscope, mt, ty::vstore_uniq, |tmt| ty::mk_uniq(tcx, tmt)) } ast::ty_vec(ref mt) => { tcx.sess.span_err(ast_ty.span, ~"bare `[]` is not a type"); // return /something/ so they can at least get more errors ty::mk_evec(tcx, ast_mt_to_mt(self, rscope, mt), ty::vstore_uniq) } ast::ty_ptr(ref mt) => { ty::mk_ptr(tcx, ast_mt_to_mt(self, rscope, mt)) } ast::ty_rptr(region, ref mt) => { let r = ast_region_to_region(self, rscope, ast_ty.span, region); mk_pointer(self, rscope, mt, ty::vstore_slice(r), |tmt| ty::mk_rptr(tcx, r, tmt)) } ast::ty_tup(ref fields) => { let flds = fields.map(|t| ast_ty_to_ty(self, rscope, *t)); ty::mk_tup(tcx, flds) } ast::ty_bare_fn(ref bf) => { ty::mk_bare_fn(tcx, ty_of_bare_fn(self, rscope, bf.purity, bf.abis, &bf.lifetimes, &bf.decl)) } ast::ty_closure(ref f) => { let fn_decl = ty_of_closure(self, rscope, f.sigil, f.purity, f.onceness, f.region, &f.decl, None, &f.lifetimes, ast_ty.span); ty::mk_closure(tcx, fn_decl) } ast::ty_path(path, id) => { let a_def = match tcx.def_map.find(&id) { None => tcx.sess.span_fatal( ast_ty.span, fmt!("unbound path %s", path_to_str(path, tcx.sess.intr()))), Some(&d) => d }; match a_def { ast::def_ty(did) | ast::def_struct(did) => { ast_path_to_ty(self, rscope, did, path).ty } ast::def_prim_ty(nty) => { match nty { ast::ty_bool => { check_path_args(tcx, path, NO_TPS | NO_REGIONS); ty::mk_bool(tcx) } ast::ty_int(it) => { check_path_args(tcx, path, NO_TPS | NO_REGIONS); ty::mk_mach_int(tcx, it) } ast::ty_uint(uit) => { check_path_args(tcx, path, NO_TPS | NO_REGIONS); ty::mk_mach_uint(tcx, uit) } ast::ty_float(ft) => { check_path_args(tcx, path, NO_TPS | NO_REGIONS); ty::mk_mach_float(tcx, ft) } ast::ty_str => { tcx.sess.span_err(ast_ty.span, ~"bare `str` is not a type"); // return /something/ so they can at least get more errors ty::mk_estr(tcx, ty::vstore_uniq) } } } ast::def_ty_param(id, n) => { check_path_args(tcx, path, NO_TPS | NO_REGIONS); ty::mk_param(tcx, n, id) } ast::def_self_ty(id) => { // n.b.: resolve guarantees that the self type only appears in a // trait, which we rely upon in various places when creating // substs check_path_args(tcx, path, NO_TPS | NO_REGIONS); let did = ast_util::local_def(id); ty::mk_self(tcx, did) } _ => { tcx.sess.span_fatal(ast_ty.span, ~"found type name used as a variable"); } } } ast::ty_fixed_length_vec(ref a_mt, e) => { match const_eval::eval_const_expr_partial(tcx, e) { Ok(ref r) => { match *r { const_eval::const_int(i) => ty::mk_evec(tcx, ast_mt_to_mt(self, rscope, a_mt), ty::vstore_fixed(i as uint)), const_eval::const_uint(i) => ty::mk_evec(tcx, ast_mt_to_mt(self, rscope, a_mt), ty::vstore_fixed(i as uint)), _ => { tcx.sess.span_fatal( ast_ty.span, ~"expected constant expr for vector length"); } } } Err(ref r) => { tcx.sess.span_fatal( ast_ty.span, fmt!("expected constant expr for vector length: %s", *r)); } } } ast::ty_infer => { // ty_infer should only appear as the type of arguments or return // values in a fn_expr, or as the type of local variables. Both of // these cases are handled specially and should not descend into this // routine. self.tcx().sess.span_bug( ast_ty.span, ~"found `ty_infer` in unexpected place"); } ast::ty_mac(_) => { tcx.sess.span_bug(ast_ty.span, ~"found `ty_mac` in unexpected place"); } }; tcx.ast_ty_to_ty_cache.insert(ast_ty.id, ty::atttce_resolved(typ)); return typ; } pub fn ty_of_arg<AC:AstConv,RS:region_scope + Copy + Durable>( self: &AC, rscope: &RS, a: ast::arg, expected_ty: Option<ty::arg>) -> ty::arg { let ty = match a.ty.node { ast::ty_infer if expected_ty.is_some() => expected_ty.get().ty, ast::ty_infer => self.ty_infer(a.ty.span), _ => ast_ty_to_ty(self, rscope, a.ty) }; let mode = { match a.mode {
{ (lifetime.span, rscope.named_region(lifetime.span, lifetime.ident)) }
conditional_block
astconv.rs
* Note that the self region for the `foo` defaulted to `&` in the first * case but `&a` in the second. Basically, defaults that appear inside * an rptr (`&r.T`) use the region `r` that appears in the rptr. */ use core::prelude::*; use middle::const_eval; use middle::ty::{arg, substs}; use middle::ty::{ty_param_substs_and_ty}; use middle::ty; use middle::typeck::rscope::in_binding_rscope; use middle::typeck::rscope::{region_scope, RegionError}; use middle::typeck::rscope::RegionParamNames; use core::result; use core::vec; use syntax::abi::AbiSet; use syntax::{ast, ast_util}; use syntax::codemap::span; use syntax::opt_vec::OptVec; use syntax::opt_vec; use syntax::print::pprust::{lifetime_to_str, path_to_str}; use syntax::parse::token::special_idents; use util::common::indenter; pub trait AstConv { fn tcx(&self) -> ty::ctxt; fn get_item_ty(&self, id: ast::def_id) -> ty::ty_param_bounds_and_ty; // what type should we use when a type is omitted? fn ty_infer(&self, span: span) -> ty::t; } pub fn get_region_reporting_err( tcx: ty::ctxt, span: span, a_r: Option<@ast::Lifetime>, res: Result<ty::Region, RegionError>) -> ty::Region { match res { result::Ok(r) => r, result::Err(ref e) => { let descr = match a_r { None => ~"anonymous lifetime", Some(a) => fmt!("lifetime %s", lifetime_to_str(a, tcx.sess.intr())) }; tcx.sess.span_err( span, fmt!("Illegal %s: %s", descr, e.msg)); e.replacement } } } pub fn ast_region_to_region<AC:AstConv,RS:region_scope + Copy + Durable>( self: &AC, rscope: &RS, default_span: span, opt_lifetime: Option<@ast::Lifetime>) -> ty::Region { let (span, res) = match opt_lifetime { None => { (default_span, rscope.anon_region(default_span)) } Some(ref lifetime) if lifetime.ident == special_idents::static => { (lifetime.span, Ok(ty::re_static)) } Some(ref lifetime) if lifetime.ident == special_idents::self_ => { (lifetime.span, rscope.self_region(lifetime.span)) } Some(ref lifetime) => { (lifetime.span, rscope.named_region(lifetime.span, lifetime.ident)) } }; get_region_reporting_err(self.tcx(), span, opt_lifetime, res) } pub fn ast_path_to_substs_and_ty<AC:AstConv,RS:region_scope + Copy + Durable>( self: &AC, rscope: &RS, did: ast::def_id, path: @ast::path) -> ty_param_substs_and_ty { let tcx = self.tcx(); let ty::ty_param_bounds_and_ty { bounds: decl_bounds, region_param: decl_rp, ty: decl_ty } = self.get_item_ty(did); debug!("ast_path_to_substs_and_ty: did=%? decl_rp=%?", did, decl_rp); // If the type is parameterized by the self region, then replace self // region with the current anon region binding (in other words, // whatever & would get replaced with). let self_r = match (decl_rp, path.rp) { (None, None) => { None } (None, Some(_)) => { tcx.sess.span_err( path.span, fmt!("no region bound is allowed on `%s`, \ which is not declared as containing region pointers", ty::item_path_str(tcx, did))); None } (Some(_), None) => { let res = rscope.anon_region(path.span); let r = get_region_reporting_err(self.tcx(), path.span, None, res); Some(r) } (Some(_), Some(_)) => { Some(ast_region_to_region(self, rscope, path.span, path.rp)) } }; // Convert the type parameters supplied by the user. if!vec::same_length(*decl_bounds, path.types) { self.tcx().sess.span_fatal( path.span, fmt!("wrong number of type arguments: expected %u but found %u", (*decl_bounds).len(), path.types.len())); } let tps = path.types.map(|a_t| ast_ty_to_ty(self, rscope, *a_t)); let substs = substs {self_r:self_r, self_ty:None, tps:tps}; let ty = ty::subst(tcx, &substs, decl_ty); ty_param_substs_and_ty { substs: substs, ty: ty } } pub fn ast_path_to_ty<AC:AstConv,RS:region_scope + Copy + Durable>( self: &AC, rscope: &RS, did: ast::def_id, path: @ast::path) -> ty_param_substs_and_ty { // Look up the polytype of the item and then substitute the provided types // for any type/region parameters. let ty::ty_param_substs_and_ty { substs: substs, ty: ty } = ast_path_to_substs_and_ty(self, rscope, did, path); ty_param_substs_and_ty { substs: substs, ty: ty } } pub static NO_REGIONS: uint = 1; pub static NO_TPS: uint = 2; // Parses the programmer's textual representation of a type into our // internal notion of a type. `getter` is a function that returns the type // corresponding to a definition ID: pub fn ast_ty_to_ty<AC:AstConv, RS:region_scope + Copy + Durable>( self: &AC, rscope: &RS, &&ast_ty: @ast::Ty) -> ty::t { fn ast_mt_to_mt<AC:AstConv, RS:region_scope + Copy + Durable>( self: &AC, rscope: &RS, mt: &ast::mt) -> ty::mt { ty::mt {ty: ast_ty_to_ty(self, rscope, mt.ty), mutbl: mt.mutbl} } // Handle @, ~, and & being able to mean estrs and evecs. // If a_seq_ty is a str or a vec, make it an estr/evec. // Also handle first-class trait types. fn mk_pointer<AC:AstConv,RS:region_scope + Copy + Durable>( self: &AC, rscope: &RS, a_seq_ty: &ast::mt, vst: ty::vstore, constr: &fn(ty::mt) -> ty::t) -> ty::t { let tcx = self.tcx(); match a_seq_ty.ty.node { ast::ty_vec(ref mt) => { let mut mt = ast_mt_to_mt(self, rscope, mt); if a_seq_ty.mutbl == ast::m_mutbl || a_seq_ty.mutbl == ast::m_const { mt = ty::mt { ty: mt.ty, mutbl: a_seq_ty.mutbl }; } return ty::mk_evec(tcx, mt, vst); } ast::ty_path(path, id) if a_seq_ty.mutbl == ast::m_imm => { match tcx.def_map.find(&id) { Some(&ast::def_prim_ty(ast::ty_str)) => { check_path_args(tcx, path, NO_TPS | NO_REGIONS); return ty::mk_estr(tcx, vst); } Some(&ast::def_ty(type_def_id)) => { let result = ast_path_to_substs_and_ty( self, rscope, type_def_id, path); match ty::get(result.ty).sty { ty::ty_trait(trait_def_id, ref substs, _) => { let trait_store = match vst { ty::vstore_box => ty::BoxTraitStore, ty::vstore_uniq => ty::UniqTraitStore, ty::vstore_slice(r) => { ty::RegionTraitStore(r) } ty::vstore_fixed(*) => { tcx.sess.span_err( path.span, ~"@trait, ~trait or &trait \ are the only supported \ forms of casting-to-\ trait"); ty::BoxTraitStore } }; return ty::mk_trait(tcx, trait_def_id, /*bad*/copy *substs, trait_store); } _ => {} } } _ => {} } } _ => {} } let seq_ty = ast_mt_to_mt(self, rscope, a_seq_ty); return constr(seq_ty); } fn check_path_args(tcx: ty::ctxt, path: @ast::path, flags: uint) { if (flags & NO_TPS)!= 0u { if path.types.len() > 0u { tcx.sess.span_err( path.span, ~"type parameters are not allowed on this type"); } } if (flags & NO_REGIONS)!= 0u { if path.rp.is_some() { tcx.sess.span_err( path.span, ~"region parameters are not allowed on this type"); } } } let tcx = self.tcx(); match tcx.ast_ty_to_ty_cache.find(&ast_ty.id) { Some(&ty::atttce_resolved(ty)) => return ty, Some(&ty::atttce_unresolved) => { tcx.sess.span_fatal(ast_ty.span, ~"illegal recursive type; \ insert an enum in the cycle, \ if this is desired"); } None => { /* go on */ } } tcx.ast_ty_to_ty_cache.insert(ast_ty.id, ty::atttce_unresolved); let typ = match ast_ty.node { ast::ty_nil => ty::mk_nil(tcx), ast::ty_bot => ty::mk_bot(tcx), ast::ty_box(ref mt) => { mk_pointer(self, rscope, mt, ty::vstore_box, |tmt| ty::mk_box(tcx, tmt)) } ast::ty_uniq(ref mt) => { mk_pointer(self, rscope, mt, ty::vstore_uniq, |tmt| ty::mk_uniq(tcx, tmt)) } ast::ty_vec(ref mt) => { tcx.sess.span_err(ast_ty.span, ~"bare `[]` is not a type"); // return /something/ so they can at least get more errors ty::mk_evec(tcx, ast_mt_to_mt(self, rscope, mt), ty::vstore_uniq) } ast::ty_ptr(ref mt) => { ty::mk_ptr(tcx, ast_mt_to_mt(self, rscope, mt)) } ast::ty_rptr(region, ref mt) => { let r = ast_region_to_region(self, rscope, ast_ty.span, region); mk_pointer(self, rscope, mt, ty::vstore_slice(r), |tmt| ty::mk_rptr(tcx, r, tmt)) } ast::ty_tup(ref fields) => { let flds = fields.map(|t| ast_ty_to_ty(self, rscope, *t)); ty::mk_tup(tcx, flds) } ast::ty_bare_fn(ref bf) => { ty::mk_bare_fn(tcx, ty_of_bare_fn(self, rscope, bf.purity, bf.abis, &bf.lifetimes, &bf.decl)) } ast::ty_closure(ref f) => { let fn_decl = ty_of_closure(self, rscope, f.sigil, f.purity, f.onceness, f.region, &f.decl, None, &f.lifetimes, ast_ty.span); ty::mk_closure(tcx, fn_decl) } ast::ty_path(path, id) => { let a_def = match tcx.def_map.find(&id) { None => tcx.sess.span_fatal( ast_ty.span, fmt!("unbound path %s", path_to_str(path, tcx.sess.intr()))), Some(&d) => d }; match a_def { ast::def_ty(did) | ast::def_struct(did) => { ast_path_to_ty(self, rscope, did, path).ty } ast::def_prim_ty(nty) => { match nty { ast::ty_bool => { check_path_args(tcx, path, NO_TPS | NO_REGIONS); ty::mk_bool(tcx) } ast::ty_int(it) => { check_path_args(tcx, path, NO_TPS | NO_REGIONS); ty::mk_mach_int(tcx, it) } ast::ty_uint(uit) => { check_path_args(tcx, path, NO_TPS | NO_REGIONS); ty::mk_mach_uint(tcx, uit) } ast::ty_float(ft) => { check_path_args(tcx, path, NO_TPS | NO_REGIONS); ty::mk_mach_float(tcx, ft) } ast::ty_str => { tcx.sess.span_err(ast_ty.span, ~"bare `str` is not a type"); // return /something/ so they can at least get more errors ty::mk_estr(tcx, ty::vstore_uniq) } } } ast::def_ty_param(id, n) => { check_path_args(tcx, path, NO_TPS | NO_REGIONS); ty::mk_param(tcx, n, id) } ast::def_self_ty(id) => { // n.b.: resolve guarantees that the self type only appears in a // trait, which we rely upon in various places when creating // substs check_path_args(tcx, path, NO_TPS | NO_REGIONS); let did = ast_util::local_def(id); ty::mk_self(tcx, did) } _ => { tcx.sess.span_fatal(ast_ty.span, ~"found type name used as a variable"); } } } ast::ty_fixed_length_vec(ref a_mt, e) => { match const_eval::eval_const_expr_partial(tcx, e) { Ok(ref r) => { match *r { const_eval::const_int(i) => ty::mk_evec(tcx, ast_mt_to_mt(self, rscope, a_mt), ty::vstore_fixed(i as uint)), const_eval::const_uint(i) => ty::mk_evec(tcx, ast_mt_to_mt(self, rscope, a_mt), ty::vstore_fixed(i as uint)), _ => { tcx.sess.span_fatal( ast_ty.span, ~"expected constant expr for vector length"); } } } Err(ref r) => { tcx.sess.span_fatal( ast_ty.span
* Case (b) says that if you have a type: * type foo<'self> = ...; * type bar = fn(&foo, &a.foo) * The fully expanded version of type bar is: * type bar = fn(&'foo &, &a.foo<'a>)
random_line_split
reporter.rs
// Copyright 2021 TiKV Project Authors. Licensed under Apache-2.0. use crate::cpu::collector::{register_collector, Collector, CollectorHandle}; use crate::cpu::recorder::CpuRecords; use crate::Config; use std::fmt::{self, Display, Formatter}; use std::sync::atomic::AtomicBool; use std::sync::atomic::Ordering::SeqCst; use std::sync::Arc; use collections::HashMap; use futures::SinkExt; use grpcio::{CallOption, ChannelBuilder, Environment, WriteFlags}; use kvproto::resource_usage_agent::{CpuTimeRecord, ResourceUsageAgentClient}; use tikv_util::time::Duration; use tikv_util::worker::{Runnable, RunnableWithTimer, Scheduler}; pub struct CpuRecordsCollector { scheduler: Scheduler<Task>, } impl CpuRecordsCollector { pub fn
(scheduler: Scheduler<Task>) -> Self { Self { scheduler } } } impl Collector for CpuRecordsCollector { fn collect(&self, records: Arc<CpuRecords>) { self.scheduler.schedule(Task::CpuRecords(records)).ok(); } } pub enum Task { ConfigChange(Config), CpuRecords(Arc<CpuRecords>), } impl Display for Task { fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result { match self { Task::ConfigChange(_) => { write!(f, "ConfigChange")?; } Task::CpuRecords(_) => { write!(f, "CpuRecords")?; } } Ok(()) } } pub struct ResourceMeteringReporter { config: Config, env: Arc<Environment>, scheduler: Scheduler<Task>, // TODO: mock client for testing client: Option<ResourceUsageAgentClient>, reporting: Arc<AtomicBool>, cpu_records_collector: Option<CollectorHandle>, // resource_tag -> ([timestamp_secs], [cpu_time_ms], total_cpu_time_ms) records: HashMap<Vec<u8>, (Vec<u64>, Vec<u32>, u32)>, // timestamp_secs -> cpu_time_ms others: HashMap<u64, u32>, find_top_k: Vec<u32>, } impl ResourceMeteringReporter { pub fn new(config: Config, scheduler: Scheduler<Task>, env: Arc<Environment>) -> Self { let mut reporter = Self { config, env, scheduler, client: None, reporting: Arc::new(AtomicBool::new(false)), cpu_records_collector: None, records: HashMap::default(), others: HashMap::default(), find_top_k: Vec::default(), }; if reporter.config.should_report() { reporter.init_client(); } reporter } pub fn init_client(&mut self) { let channel = { let cb = ChannelBuilder::new(self.env.clone()) .keepalive_time(Duration::from_secs(10)) .keepalive_timeout(Duration::from_secs(3)); cb.connect(&self.config.agent_address) }; self.client = Some(ResourceUsageAgentClient::new(channel)); if self.cpu_records_collector.is_none() { self.cpu_records_collector = Some(register_collector(Box::new( CpuRecordsCollector::new(self.scheduler.clone()), ))); } } } impl Runnable for ResourceMeteringReporter { type Task = Task; fn run(&mut self, task: Self::Task) { match task { Task::ConfigChange(new_config) => { let old_config_enabled = self.config.enabled; let old_config_agent_address = self.config.agent_address.clone(); self.config = new_config; if!self.config.should_report() { self.client.take(); self.cpu_records_collector.take(); } else if self.config.agent_address!= old_config_agent_address || self.config.enabled!= old_config_enabled { self.init_client(); } } Task::CpuRecords(records) => { let timestamp_secs = records.begin_unix_time_secs; for (tag, ms) in &records.records { let tag = &tag.infos.extra_attachment; if tag.is_empty() { continue; } let ms = *ms as u32; match self.records.get_mut(tag) { Some((ts, cpu_time, total)) => { if *ts.last().unwrap() == timestamp_secs { *cpu_time.last_mut().unwrap() += ms; } else { ts.push(timestamp_secs); cpu_time.push(ms); } *total += ms; } None => { self.records .insert(tag.clone(), (vec![timestamp_secs], vec![ms], ms)); } } } if self.records.len() > self.config.max_resource_groups { self.find_top_k.clear(); for (_, _, total) in self.records.values() { self.find_top_k.push(*total); } pdqselect::select_by( &mut self.find_top_k, self.config.max_resource_groups, |a, b| b.cmp(a), ); let kth = self.find_top_k[self.config.max_resource_groups]; let others = &mut self.others; self.records .drain_filter(|_, (_, _, total)| *total <= kth) .for_each(|(_, (secs_list, cpu_time_list, _))| { secs_list .into_iter() .zip(cpu_time_list.into_iter()) .for_each(|(secs, cpu_time)| { *others.entry(secs).or_insert(0) += cpu_time }) }); } } } } fn shutdown(&mut self) { self.cpu_records_collector.take(); self.client.take(); } } impl RunnableWithTimer for ResourceMeteringReporter { fn on_timeout(&mut self) { if self.records.is_empty() { assert!(self.others.is_empty()); return; } let records = std::mem::take(&mut self.records); let others = std::mem::take(&mut self.others); if self.reporting.load(SeqCst) { return; } if let Some(client) = self.client.as_ref() { match client.report_cpu_time_opt(CallOption::default().timeout(Duration::from_secs(2))) { Ok((mut tx, rx)) => { self.reporting.store(true, SeqCst); let reporting = self.reporting.clone(); client.spawn(async move { defer!(reporting.store(false, SeqCst)); for (tag, (timestamp_list, cpu_time_ms_list, _)) in records { let mut req = CpuTimeRecord::default(); req.set_resource_group_tag(tag); req.set_record_list_timestamp_sec(timestamp_list); req.set_record_list_cpu_time_ms(cpu_time_ms_list); if tx.send((req, WriteFlags::default())).await.is_err() { return; } } // others if!others.is_empty() { let timestamp_list = others.keys().cloned().collect::<Vec<_>>(); let cpu_time_ms_list = others.values().cloned().collect::<Vec<_>>(); let mut req = CpuTimeRecord::default(); req.set_record_list_timestamp_sec(timestamp_list); req.set_record_list_cpu_time_ms(cpu_time_ms_list); if tx.send((req, WriteFlags::default())).await.is_err() { return; } } if tx.close().await.is_err() { return; } rx.await.ok(); }); } Err(err) => { warn!("failed to connect resource usage agent"; "error" =>?err); } } } } fn get_interval(&self) -> Duration { self.config.report_agent_interval.0 } }
new
identifier_name
reporter.rs
// Copyright 2021 TiKV Project Authors. Licensed under Apache-2.0. use crate::cpu::collector::{register_collector, Collector, CollectorHandle}; use crate::cpu::recorder::CpuRecords; use crate::Config; use std::fmt::{self, Display, Formatter}; use std::sync::atomic::AtomicBool; use std::sync::atomic::Ordering::SeqCst; use std::sync::Arc; use collections::HashMap; use futures::SinkExt; use grpcio::{CallOption, ChannelBuilder, Environment, WriteFlags}; use kvproto::resource_usage_agent::{CpuTimeRecord, ResourceUsageAgentClient}; use tikv_util::time::Duration; use tikv_util::worker::{Runnable, RunnableWithTimer, Scheduler}; pub struct CpuRecordsCollector { scheduler: Scheduler<Task>, } impl CpuRecordsCollector { pub fn new(scheduler: Scheduler<Task>) -> Self { Self { scheduler } } } impl Collector for CpuRecordsCollector { fn collect(&self, records: Arc<CpuRecords>) { self.scheduler.schedule(Task::CpuRecords(records)).ok(); } } pub enum Task { ConfigChange(Config), CpuRecords(Arc<CpuRecords>), } impl Display for Task { fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result { match self { Task::ConfigChange(_) => { write!(f, "ConfigChange")?; } Task::CpuRecords(_) => { write!(f, "CpuRecords")?; } } Ok(()) } } pub struct ResourceMeteringReporter { config: Config, env: Arc<Environment>, scheduler: Scheduler<Task>, // TODO: mock client for testing client: Option<ResourceUsageAgentClient>, reporting: Arc<AtomicBool>, cpu_records_collector: Option<CollectorHandle>, // resource_tag -> ([timestamp_secs], [cpu_time_ms], total_cpu_time_ms) records: HashMap<Vec<u8>, (Vec<u64>, Vec<u32>, u32)>, // timestamp_secs -> cpu_time_ms others: HashMap<u64, u32>, find_top_k: Vec<u32>, } impl ResourceMeteringReporter { pub fn new(config: Config, scheduler: Scheduler<Task>, env: Arc<Environment>) -> Self { let mut reporter = Self { config, env, scheduler, client: None, reporting: Arc::new(AtomicBool::new(false)), cpu_records_collector: None, records: HashMap::default(), others: HashMap::default(), find_top_k: Vec::default(), }; if reporter.config.should_report() { reporter.init_client(); } reporter } pub fn init_client(&mut self)
} impl Runnable for ResourceMeteringReporter { type Task = Task; fn run(&mut self, task: Self::Task) { match task { Task::ConfigChange(new_config) => { let old_config_enabled = self.config.enabled; let old_config_agent_address = self.config.agent_address.clone(); self.config = new_config; if!self.config.should_report() { self.client.take(); self.cpu_records_collector.take(); } else if self.config.agent_address!= old_config_agent_address || self.config.enabled!= old_config_enabled { self.init_client(); } } Task::CpuRecords(records) => { let timestamp_secs = records.begin_unix_time_secs; for (tag, ms) in &records.records { let tag = &tag.infos.extra_attachment; if tag.is_empty() { continue; } let ms = *ms as u32; match self.records.get_mut(tag) { Some((ts, cpu_time, total)) => { if *ts.last().unwrap() == timestamp_secs { *cpu_time.last_mut().unwrap() += ms; } else { ts.push(timestamp_secs); cpu_time.push(ms); } *total += ms; } None => { self.records .insert(tag.clone(), (vec![timestamp_secs], vec![ms], ms)); } } } if self.records.len() > self.config.max_resource_groups { self.find_top_k.clear(); for (_, _, total) in self.records.values() { self.find_top_k.push(*total); } pdqselect::select_by( &mut self.find_top_k, self.config.max_resource_groups, |a, b| b.cmp(a), ); let kth = self.find_top_k[self.config.max_resource_groups]; let others = &mut self.others; self.records .drain_filter(|_, (_, _, total)| *total <= kth) .for_each(|(_, (secs_list, cpu_time_list, _))| { secs_list .into_iter() .zip(cpu_time_list.into_iter()) .for_each(|(secs, cpu_time)| { *others.entry(secs).or_insert(0) += cpu_time }) }); } } } } fn shutdown(&mut self) { self.cpu_records_collector.take(); self.client.take(); } } impl RunnableWithTimer for ResourceMeteringReporter { fn on_timeout(&mut self) { if self.records.is_empty() { assert!(self.others.is_empty()); return; } let records = std::mem::take(&mut self.records); let others = std::mem::take(&mut self.others); if self.reporting.load(SeqCst) { return; } if let Some(client) = self.client.as_ref() { match client.report_cpu_time_opt(CallOption::default().timeout(Duration::from_secs(2))) { Ok((mut tx, rx)) => { self.reporting.store(true, SeqCst); let reporting = self.reporting.clone(); client.spawn(async move { defer!(reporting.store(false, SeqCst)); for (tag, (timestamp_list, cpu_time_ms_list, _)) in records { let mut req = CpuTimeRecord::default(); req.set_resource_group_tag(tag); req.set_record_list_timestamp_sec(timestamp_list); req.set_record_list_cpu_time_ms(cpu_time_ms_list); if tx.send((req, WriteFlags::default())).await.is_err() { return; } } // others if!others.is_empty() { let timestamp_list = others.keys().cloned().collect::<Vec<_>>(); let cpu_time_ms_list = others.values().cloned().collect::<Vec<_>>(); let mut req = CpuTimeRecord::default(); req.set_record_list_timestamp_sec(timestamp_list); req.set_record_list_cpu_time_ms(cpu_time_ms_list); if tx.send((req, WriteFlags::default())).await.is_err() { return; } } if tx.close().await.is_err() { return; } rx.await.ok(); }); } Err(err) => { warn!("failed to connect resource usage agent"; "error" =>?err); } } } } fn get_interval(&self) -> Duration { self.config.report_agent_interval.0 } }
{ let channel = { let cb = ChannelBuilder::new(self.env.clone()) .keepalive_time(Duration::from_secs(10)) .keepalive_timeout(Duration::from_secs(3)); cb.connect(&self.config.agent_address) }; self.client = Some(ResourceUsageAgentClient::new(channel)); if self.cpu_records_collector.is_none() { self.cpu_records_collector = Some(register_collector(Box::new( CpuRecordsCollector::new(self.scheduler.clone()), ))); } }
identifier_body
reporter.rs
// Copyright 2021 TiKV Project Authors. Licensed under Apache-2.0. use crate::cpu::collector::{register_collector, Collector, CollectorHandle}; use crate::cpu::recorder::CpuRecords; use crate::Config; use std::fmt::{self, Display, Formatter}; use std::sync::atomic::AtomicBool; use std::sync::atomic::Ordering::SeqCst; use std::sync::Arc; use collections::HashMap; use futures::SinkExt; use grpcio::{CallOption, ChannelBuilder, Environment, WriteFlags}; use kvproto::resource_usage_agent::{CpuTimeRecord, ResourceUsageAgentClient}; use tikv_util::time::Duration; use tikv_util::worker::{Runnable, RunnableWithTimer, Scheduler}; pub struct CpuRecordsCollector { scheduler: Scheduler<Task>, } impl CpuRecordsCollector { pub fn new(scheduler: Scheduler<Task>) -> Self { Self { scheduler } } } impl Collector for CpuRecordsCollector { fn collect(&self, records: Arc<CpuRecords>) { self.scheduler.schedule(Task::CpuRecords(records)).ok(); } } pub enum Task { ConfigChange(Config), CpuRecords(Arc<CpuRecords>), } impl Display for Task { fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result { match self { Task::ConfigChange(_) => { write!(f, "ConfigChange")?; } Task::CpuRecords(_) => { write!(f, "CpuRecords")?; } } Ok(()) } } pub struct ResourceMeteringReporter { config: Config, env: Arc<Environment>, scheduler: Scheduler<Task>, // TODO: mock client for testing client: Option<ResourceUsageAgentClient>, reporting: Arc<AtomicBool>, cpu_records_collector: Option<CollectorHandle>, // resource_tag -> ([timestamp_secs], [cpu_time_ms], total_cpu_time_ms) records: HashMap<Vec<u8>, (Vec<u64>, Vec<u32>, u32)>, // timestamp_secs -> cpu_time_ms others: HashMap<u64, u32>, find_top_k: Vec<u32>, } impl ResourceMeteringReporter { pub fn new(config: Config, scheduler: Scheduler<Task>, env: Arc<Environment>) -> Self { let mut reporter = Self { config, env, scheduler, client: None, reporting: Arc::new(AtomicBool::new(false)), cpu_records_collector: None, records: HashMap::default(), others: HashMap::default(), find_top_k: Vec::default(), }; if reporter.config.should_report() { reporter.init_client(); } reporter } pub fn init_client(&mut self) { let channel = { let cb = ChannelBuilder::new(self.env.clone()) .keepalive_time(Duration::from_secs(10)) .keepalive_timeout(Duration::from_secs(3)); cb.connect(&self.config.agent_address) }; self.client = Some(ResourceUsageAgentClient::new(channel)); if self.cpu_records_collector.is_none() { self.cpu_records_collector = Some(register_collector(Box::new( CpuRecordsCollector::new(self.scheduler.clone()), ))); } } } impl Runnable for ResourceMeteringReporter { type Task = Task; fn run(&mut self, task: Self::Task) { match task { Task::ConfigChange(new_config) => { let old_config_enabled = self.config.enabled; let old_config_agent_address = self.config.agent_address.clone(); self.config = new_config; if!self.config.should_report() { self.client.take(); self.cpu_records_collector.take(); } else if self.config.agent_address!= old_config_agent_address || self.config.enabled!= old_config_enabled { self.init_client(); } } Task::CpuRecords(records) => { let timestamp_secs = records.begin_unix_time_secs; for (tag, ms) in &records.records { let tag = &tag.infos.extra_attachment; if tag.is_empty() { continue; } let ms = *ms as u32; match self.records.get_mut(tag) { Some((ts, cpu_time, total)) => { if *ts.last().unwrap() == timestamp_secs { *cpu_time.last_mut().unwrap() += ms; } else { ts.push(timestamp_secs); cpu_time.push(ms); } *total += ms; } None => { self.records .insert(tag.clone(), (vec![timestamp_secs], vec![ms], ms)); } } } if self.records.len() > self.config.max_resource_groups { self.find_top_k.clear(); for (_, _, total) in self.records.values() { self.find_top_k.push(*total); } pdqselect::select_by( &mut self.find_top_k, self.config.max_resource_groups, |a, b| b.cmp(a), ); let kth = self.find_top_k[self.config.max_resource_groups]; let others = &mut self.others; self.records .drain_filter(|_, (_, _, total)| *total <= kth) .for_each(|(_, (secs_list, cpu_time_list, _))| { secs_list .into_iter() .zip(cpu_time_list.into_iter()) .for_each(|(secs, cpu_time)| { *others.entry(secs).or_insert(0) += cpu_time }) }); } } } } fn shutdown(&mut self) { self.cpu_records_collector.take(); self.client.take(); } } impl RunnableWithTimer for ResourceMeteringReporter { fn on_timeout(&mut self) { if self.records.is_empty() { assert!(self.others.is_empty()); return; } let records = std::mem::take(&mut self.records); let others = std::mem::take(&mut self.others); if self.reporting.load(SeqCst) { return; } if let Some(client) = self.client.as_ref() { match client.report_cpu_time_opt(CallOption::default().timeout(Duration::from_secs(2))) { Ok((mut tx, rx)) => { self.reporting.store(true, SeqCst); let reporting = self.reporting.clone(); client.spawn(async move { defer!(reporting.store(false, SeqCst));
req.set_record_list_timestamp_sec(timestamp_list); req.set_record_list_cpu_time_ms(cpu_time_ms_list); if tx.send((req, WriteFlags::default())).await.is_err() { return; } } // others if!others.is_empty() { let timestamp_list = others.keys().cloned().collect::<Vec<_>>(); let cpu_time_ms_list = others.values().cloned().collect::<Vec<_>>(); let mut req = CpuTimeRecord::default(); req.set_record_list_timestamp_sec(timestamp_list); req.set_record_list_cpu_time_ms(cpu_time_ms_list); if tx.send((req, WriteFlags::default())).await.is_err() { return; } } if tx.close().await.is_err() { return; } rx.await.ok(); }); } Err(err) => { warn!("failed to connect resource usage agent"; "error" =>?err); } } } } fn get_interval(&self) -> Duration { self.config.report_agent_interval.0 } }
for (tag, (timestamp_list, cpu_time_ms_list, _)) in records { let mut req = CpuTimeRecord::default(); req.set_resource_group_tag(tag);
random_line_split
mod.rs
// This file is released under the same terms as Rust itself. pub mod github_status; pub mod jenkins; use config::PipelinesConfig; use hyper::Url; use pipeline::{GetPipelineId, PipelineId}; use vcs::Commit; #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] pub struct CiId(pub i32); #[derive(Clone, Debug)] pub enum Message { StartBuild(CiId, Commit), } #[derive(Clone, Debug)] pub enum
{ BuildStarted(CiId, Commit, Option<Url>), BuildSucceeded(CiId, Commit, Option<Url>), BuildFailed(CiId, Commit, Option<Url>), } impl GetPipelineId for Event { fn pipeline_id<C: PipelinesConfig +?Sized>(&self, config: &C) -> PipelineId { let ci_id = match *self { Event::BuildStarted(i, _, _) => i, Event::BuildSucceeded(i, _, _) => i, Event::BuildFailed(i, _, _) => i, }; config.by_ci_id(ci_id).pipeline_id } }
Event
identifier_name
mod.rs
// This file is released under the same terms as Rust itself. pub mod github_status; pub mod jenkins; use config::PipelinesConfig; use hyper::Url; use pipeline::{GetPipelineId, PipelineId}; use vcs::Commit; #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] pub struct CiId(pub i32); #[derive(Clone, Debug)] pub enum Message { StartBuild(CiId, Commit), } #[derive(Clone, Debug)] pub enum Event { BuildStarted(CiId, Commit, Option<Url>),
impl GetPipelineId for Event { fn pipeline_id<C: PipelinesConfig +?Sized>(&self, config: &C) -> PipelineId { let ci_id = match *self { Event::BuildStarted(i, _, _) => i, Event::BuildSucceeded(i, _, _) => i, Event::BuildFailed(i, _, _) => i, }; config.by_ci_id(ci_id).pipeline_id } }
BuildSucceeded(CiId, Commit, Option<Url>), BuildFailed(CiId, Commit, Option<Url>), }
random_line_split
arm.rs
//! Contains arm-specific types use core::convert::From; use core::{cmp, fmt, slice}; use capstone_sys::{ arm_op_mem, arm_op_type, cs_arm, cs_arm_op, arm_shifter, cs_arm_op__bindgen_ty_2}; use libc::c_uint; pub use crate::arch::arch_builder::arm::*; use crate::arch::DetailsArchInsn; use crate::instruction::{RegId, RegIdInt}; pub use capstone_sys::arm_insn_group as ArmInsnGroup; pub use capstone_sys::arm_insn as ArmInsn; pub use capstone_sys::arm_reg as ArmReg; pub use capstone_sys::arm_vectordata_type as ArmVectorData; pub use capstone_sys::arm_cpsmode_type as ArmCPSMode; pub use capstone_sys::arm_cpsflag_type as ArmCPSFlag; pub use capstone_sys::arm_cc as ArmCC; pub use capstone_sys::arm_mem_barrier as ArmMemBarrier; pub use capstone_sys::arm_setend_type as ArmSetendType; /// Contains ARM-specific details for an instruction pub struct ArmInsnDetail<'a>(pub(crate) &'a cs_arm); /// ARM shift amount #[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)] pub enum ArmShift { Invalid, /// Arithmetic shift right (immediate) Asr(u32), /// Logical shift lift (immediate) Lsl(u32), /// Logical shift right (immediate) Lsr(u32), /// Rotate right (immediate) Ror(u32), /// Rotate right with extend (immediate) Rrx(u32), /// Arithmetic shift right (register) AsrReg(RegId), /// Logical shift lift (register) LslReg(RegId), /// Logical shift right (register) LsrReg(RegId), /// Rotate right (register) RorReg(RegId), /// Rotate right with extend (register) RrxReg(RegId), } impl ArmShift { fn new(type_: arm_shifter, value: c_uint) -> ArmShift { use self::arm_shifter::*; use self::ArmShift::*; macro_rules! arm_shift_match { ( imm = [ $( $imm_r_enum:ident = $imm_c_enum:ident, )* ] reg = [ $( $reg_r_enum:ident = $reg_c_enum:ident, )* ] ) => { match type_ { ARM_SFT_INVALID => Invalid, $( $imm_c_enum => $imm_r_enum(value as u32), )* $( $reg_c_enum => $reg_r_enum(RegId(value as RegIdInt)), )* } } } arm_shift_match!( imm = [ Asr = ARM_SFT_ASR, Lsl = ARM_SFT_LSL, Lsr = ARM_SFT_LSR, Ror = ARM_SFT_ROR, Rrx = ARM_SFT_RRX, ] reg = [ AsrReg = ARM_SFT_ASR_REG, LslReg = ARM_SFT_LSL_REG, LsrReg = ARM_SFT_LSR_REG, RorReg = ARM_SFT_ROR_REG, RrxReg = ARM_SFT_RRX_REG, ] ) } } impl ArmOperandType { fn new(op_type: arm_op_type, value: cs_arm_op__bindgen_ty_2) -> ArmOperandType { use self::arm_op_type::*; use self::ArmOperandType::*; match op_type { ARM_OP_INVALID => Invalid, ARM_OP_REG => Reg(RegId(unsafe { value.reg } as RegIdInt)), ARM_OP_IMM => Imm(unsafe { value.imm }), ARM_OP_MEM => Mem(ArmOpMem(unsafe { value.mem })), ARM_OP_FP => Fp(unsafe { value.fp }), ARM_OP_CIMM => Cimm(unsafe { value.imm }), ARM_OP_PIMM => Pimm(unsafe { value.imm }), ARM_OP_SETEND => Setend(unsafe { value.setend }), ARM_OP_SYSREG => SysReg(RegId(unsafe { value.reg } as RegIdInt)), } } } /// ARM operand #[derive(Clone, Debug, PartialEq)] pub struct ArmOperand { /// Vector Index for some vector operands pub vector_index: Option<u32>, /// Whether operand is subtracted pub subtracted: bool, pub shift: ArmShift, /// Operand type pub op_type: ArmOperandType, } /// ARM operand #[derive(Clone, Debug, PartialEq)] pub enum ArmOperandType { /// Register Reg(RegId), /// Immediate Imm(i32), /// Memory Mem(ArmOpMem), /// Floating point Fp(f64), /// C-IMM Cimm(i32), /// P-IMM Pimm(i32), /// SETEND instruction endianness Setend(ArmSetendType), /// Sysreg SysReg(RegId), /// Invalid Invalid, } /// ARM memory operand #[derive(Debug, Copy, Clone)] pub struct ArmOpMem(pub(crate) arm_op_mem); impl<'a> ArmInsnDetail<'a> { /// Whether the instruction is a user mode pub fn usermode(&self) -> bool
/// Vector size pub fn vector_size(&self) -> i32 { self.0.vector_size as i32 } /// Type of vector data pub fn vector_data(&self) -> ArmVectorData { self.0.vector_data } /// CPS mode for CPS instruction pub fn cps_mode(&self) -> ArmCPSMode { self.0.cps_mode } /// CPS flag for CPS instruction pub fn cps_flag(&self) -> ArmCPSFlag { self.0.cps_flag } /// Condition codes pub fn cc(&self) -> ArmCC { self.0.cc } /// Whether this insn updates flags pub fn update_flags(&self) -> bool { self.0.update_flags } /// Whether writeback is required pub fn writeback(&self) -> bool { self.0.writeback } /// Memory barrier pub fn mem_barrier(&self) -> ArmMemBarrier { self.0.mem_barrier } } impl_PartialEq_repr_fields!(ArmInsnDetail<'a> [ 'a ]; usermode, vector_size, vector_data, cps_mode, cps_flag, cc, update_flags, writeback, mem_barrier, operands ); impl ArmOpMem { /// Base register pub fn base(&self) -> RegId { RegId(self.0.base as RegIdInt) } /// Index value pub fn index(&self) -> RegId { RegId(self.0.index as RegIdInt) } /// Scale for index register (can be 1, or -1) pub fn scale(&self) -> i32 { self.0.scale as i32 } /// Disp value pub fn disp(&self) -> i32 { self.0.disp as i32 } } impl_PartialEq_repr_fields!(ArmOpMem; base, index, scale, disp ); impl cmp::Eq for ArmOpMem {} impl Default for ArmOperand { fn default() -> Self { ArmOperand { vector_index: None, subtracted: false, shift: ArmShift::Invalid, op_type: ArmOperandType::Invalid } } } impl<'a> From<&'a cs_arm_op> for ArmOperand { fn from(op: &cs_arm_op) -> ArmOperand { let shift = ArmShift::new(op.shift.type_, op.shift.value); let op_type = ArmOperandType::new(op.type_, op.__bindgen_anon_1); let vector_index = if op.vector_index >= 0 { Some(op.vector_index as u32) } else { None }; ArmOperand { vector_index, shift, op_type, subtracted: op.subtracted, } } } def_arch_details_struct!( InsnDetail = ArmInsnDetail; Operand = ArmOperand; OperandIterator = ArmOperandIterator; OperandIteratorLife = ArmOperandIterator<'a>; [ pub struct ArmOperandIterator<'a>(slice::Iter<'a, cs_arm_op>); ] cs_arch_op = cs_arm_op; cs_arch = cs_arm; ); #[cfg(test)] mod test { use super::*; use capstone_sys::*; #[test] fn test_armshift() { use super::arm_shifter::*; use super::ArmShift::*; use libc::c_uint; fn t(shift_type_value: (arm_shifter, c_uint), arm_shift: ArmShift) { let (shift_type, value) = shift_type_value; assert_eq!(arm_shift, ArmShift::new(shift_type, value)); } t((ARM_SFT_INVALID, 0), Invalid); t((ARM_SFT_ASR, 0), Asr(0)); t((ARM_SFT_ASR_REG, 42), AsrReg(RegId(42))); t((ARM_SFT_RRX_REG, 42), RrxReg(RegId(42))); } #[test] fn test_arm_op_type() { use super::arm_op_type::*; use super::ArmOperandType::*; fn t( op_type_value: (arm_op_type, cs_arm_op__bindgen_ty_2), expected_op_type: ArmOperandType, ) { let (op_type, op_value) = op_type_value; let op_type = ArmOperandType::new(op_type, op_value); assert_eq!(expected_op_type, op_type); } t( (ARM_OP_INVALID, cs_arm_op__bindgen_ty_2 { reg: 0 }), Invalid, ); t( (ARM_OP_REG, cs_arm_op__bindgen_ty_2 { reg: 0 }), Reg(RegId(0)), ); } #[test] fn test_arm_insn_detail_eq() { let a1 = cs_arm { usermode: false, vector_size: 0, vector_data: arm_vectordata_type::ARM_VECTORDATA_INVALID, cps_mode: arm_cpsmode_type::ARM_CPSMODE_INVALID, cps_flag: arm_cpsflag_type::ARM_CPSFLAG_INVALID, cc: arm_cc::ARM_CC_INVALID, update_flags: false, writeback: false, mem_barrier: arm_mem_barrier::ARM_MB_INVALID, op_count: 0, operands: [ cs_arm_op { vector_index: 0, shift: cs_arm_op__bindgen_ty_1 { type_: arm_shifter::ARM_SFT_INVALID, value: 0 }, type_: arm_op_type::ARM_OP_INVALID, __bindgen_anon_1: cs_arm_op__bindgen_ty_2 { imm: 0 }, subtracted: false, access: 0, neon_lane: 0, } ; 36] }; let a2 = cs_arm { usermode: true, ..a1 }; let a3 = cs_arm { op_count: 20, ..a1 }; let a4 = cs_arm { op_count: 19, ..a1 }; let a4_clone = a4.clone(); assert_eq!(ArmInsnDetail(&a1), ArmInsnDetail(&a1)); assert_ne!(ArmInsnDetail(&a1), ArmInsnDetail(&a2)); assert_ne!(ArmInsnDetail(&a1), ArmInsnDetail(&a3)); assert_ne!(ArmInsnDetail(&a3), ArmInsnDetail(&a4)); assert_eq!(ArmInsnDetail(&a4), ArmInsnDetail(&a4_clone)); } }
{ self.0.usermode }
identifier_body
arm.rs
//! Contains arm-specific types use core::convert::From; use core::{cmp, fmt, slice}; use capstone_sys::{ arm_op_mem, arm_op_type, cs_arm, cs_arm_op, arm_shifter, cs_arm_op__bindgen_ty_2};
use libc::c_uint; pub use crate::arch::arch_builder::arm::*; use crate::arch::DetailsArchInsn; use crate::instruction::{RegId, RegIdInt}; pub use capstone_sys::arm_insn_group as ArmInsnGroup; pub use capstone_sys::arm_insn as ArmInsn; pub use capstone_sys::arm_reg as ArmReg; pub use capstone_sys::arm_vectordata_type as ArmVectorData; pub use capstone_sys::arm_cpsmode_type as ArmCPSMode; pub use capstone_sys::arm_cpsflag_type as ArmCPSFlag; pub use capstone_sys::arm_cc as ArmCC; pub use capstone_sys::arm_mem_barrier as ArmMemBarrier; pub use capstone_sys::arm_setend_type as ArmSetendType; /// Contains ARM-specific details for an instruction pub struct ArmInsnDetail<'a>(pub(crate) &'a cs_arm); /// ARM shift amount #[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)] pub enum ArmShift { Invalid, /// Arithmetic shift right (immediate) Asr(u32), /// Logical shift lift (immediate) Lsl(u32), /// Logical shift right (immediate) Lsr(u32), /// Rotate right (immediate) Ror(u32), /// Rotate right with extend (immediate) Rrx(u32), /// Arithmetic shift right (register) AsrReg(RegId), /// Logical shift lift (register) LslReg(RegId), /// Logical shift right (register) LsrReg(RegId), /// Rotate right (register) RorReg(RegId), /// Rotate right with extend (register) RrxReg(RegId), } impl ArmShift { fn new(type_: arm_shifter, value: c_uint) -> ArmShift { use self::arm_shifter::*; use self::ArmShift::*; macro_rules! arm_shift_match { ( imm = [ $( $imm_r_enum:ident = $imm_c_enum:ident, )* ] reg = [ $( $reg_r_enum:ident = $reg_c_enum:ident, )* ] ) => { match type_ { ARM_SFT_INVALID => Invalid, $( $imm_c_enum => $imm_r_enum(value as u32), )* $( $reg_c_enum => $reg_r_enum(RegId(value as RegIdInt)), )* } } } arm_shift_match!( imm = [ Asr = ARM_SFT_ASR, Lsl = ARM_SFT_LSL, Lsr = ARM_SFT_LSR, Ror = ARM_SFT_ROR, Rrx = ARM_SFT_RRX, ] reg = [ AsrReg = ARM_SFT_ASR_REG, LslReg = ARM_SFT_LSL_REG, LsrReg = ARM_SFT_LSR_REG, RorReg = ARM_SFT_ROR_REG, RrxReg = ARM_SFT_RRX_REG, ] ) } } impl ArmOperandType { fn new(op_type: arm_op_type, value: cs_arm_op__bindgen_ty_2) -> ArmOperandType { use self::arm_op_type::*; use self::ArmOperandType::*; match op_type { ARM_OP_INVALID => Invalid, ARM_OP_REG => Reg(RegId(unsafe { value.reg } as RegIdInt)), ARM_OP_IMM => Imm(unsafe { value.imm }), ARM_OP_MEM => Mem(ArmOpMem(unsafe { value.mem })), ARM_OP_FP => Fp(unsafe { value.fp }), ARM_OP_CIMM => Cimm(unsafe { value.imm }), ARM_OP_PIMM => Pimm(unsafe { value.imm }), ARM_OP_SETEND => Setend(unsafe { value.setend }), ARM_OP_SYSREG => SysReg(RegId(unsafe { value.reg } as RegIdInt)), } } } /// ARM operand #[derive(Clone, Debug, PartialEq)] pub struct ArmOperand { /// Vector Index for some vector operands pub vector_index: Option<u32>, /// Whether operand is subtracted pub subtracted: bool, pub shift: ArmShift, /// Operand type pub op_type: ArmOperandType, } /// ARM operand #[derive(Clone, Debug, PartialEq)] pub enum ArmOperandType { /// Register Reg(RegId), /// Immediate Imm(i32), /// Memory Mem(ArmOpMem), /// Floating point Fp(f64), /// C-IMM Cimm(i32), /// P-IMM Pimm(i32), /// SETEND instruction endianness Setend(ArmSetendType), /// Sysreg SysReg(RegId), /// Invalid Invalid, } /// ARM memory operand #[derive(Debug, Copy, Clone)] pub struct ArmOpMem(pub(crate) arm_op_mem); impl<'a> ArmInsnDetail<'a> { /// Whether the instruction is a user mode pub fn usermode(&self) -> bool { self.0.usermode } /// Vector size pub fn vector_size(&self) -> i32 { self.0.vector_size as i32 } /// Type of vector data pub fn vector_data(&self) -> ArmVectorData { self.0.vector_data } /// CPS mode for CPS instruction pub fn cps_mode(&self) -> ArmCPSMode { self.0.cps_mode } /// CPS flag for CPS instruction pub fn cps_flag(&self) -> ArmCPSFlag { self.0.cps_flag } /// Condition codes pub fn cc(&self) -> ArmCC { self.0.cc } /// Whether this insn updates flags pub fn update_flags(&self) -> bool { self.0.update_flags } /// Whether writeback is required pub fn writeback(&self) -> bool { self.0.writeback } /// Memory barrier pub fn mem_barrier(&self) -> ArmMemBarrier { self.0.mem_barrier } } impl_PartialEq_repr_fields!(ArmInsnDetail<'a> [ 'a ]; usermode, vector_size, vector_data, cps_mode, cps_flag, cc, update_flags, writeback, mem_barrier, operands ); impl ArmOpMem { /// Base register pub fn base(&self) -> RegId { RegId(self.0.base as RegIdInt) } /// Index value pub fn index(&self) -> RegId { RegId(self.0.index as RegIdInt) } /// Scale for index register (can be 1, or -1) pub fn scale(&self) -> i32 { self.0.scale as i32 } /// Disp value pub fn disp(&self) -> i32 { self.0.disp as i32 } } impl_PartialEq_repr_fields!(ArmOpMem; base, index, scale, disp ); impl cmp::Eq for ArmOpMem {} impl Default for ArmOperand { fn default() -> Self { ArmOperand { vector_index: None, subtracted: false, shift: ArmShift::Invalid, op_type: ArmOperandType::Invalid } } } impl<'a> From<&'a cs_arm_op> for ArmOperand { fn from(op: &cs_arm_op) -> ArmOperand { let shift = ArmShift::new(op.shift.type_, op.shift.value); let op_type = ArmOperandType::new(op.type_, op.__bindgen_anon_1); let vector_index = if op.vector_index >= 0 { Some(op.vector_index as u32) } else { None }; ArmOperand { vector_index, shift, op_type, subtracted: op.subtracted, } } } def_arch_details_struct!( InsnDetail = ArmInsnDetail; Operand = ArmOperand; OperandIterator = ArmOperandIterator; OperandIteratorLife = ArmOperandIterator<'a>; [ pub struct ArmOperandIterator<'a>(slice::Iter<'a, cs_arm_op>); ] cs_arch_op = cs_arm_op; cs_arch = cs_arm; ); #[cfg(test)] mod test { use super::*; use capstone_sys::*; #[test] fn test_armshift() { use super::arm_shifter::*; use super::ArmShift::*; use libc::c_uint; fn t(shift_type_value: (arm_shifter, c_uint), arm_shift: ArmShift) { let (shift_type, value) = shift_type_value; assert_eq!(arm_shift, ArmShift::new(shift_type, value)); } t((ARM_SFT_INVALID, 0), Invalid); t((ARM_SFT_ASR, 0), Asr(0)); t((ARM_SFT_ASR_REG, 42), AsrReg(RegId(42))); t((ARM_SFT_RRX_REG, 42), RrxReg(RegId(42))); } #[test] fn test_arm_op_type() { use super::arm_op_type::*; use super::ArmOperandType::*; fn t( op_type_value: (arm_op_type, cs_arm_op__bindgen_ty_2), expected_op_type: ArmOperandType, ) { let (op_type, op_value) = op_type_value; let op_type = ArmOperandType::new(op_type, op_value); assert_eq!(expected_op_type, op_type); } t( (ARM_OP_INVALID, cs_arm_op__bindgen_ty_2 { reg: 0 }), Invalid, ); t( (ARM_OP_REG, cs_arm_op__bindgen_ty_2 { reg: 0 }), Reg(RegId(0)), ); } #[test] fn test_arm_insn_detail_eq() { let a1 = cs_arm { usermode: false, vector_size: 0, vector_data: arm_vectordata_type::ARM_VECTORDATA_INVALID, cps_mode: arm_cpsmode_type::ARM_CPSMODE_INVALID, cps_flag: arm_cpsflag_type::ARM_CPSFLAG_INVALID, cc: arm_cc::ARM_CC_INVALID, update_flags: false, writeback: false, mem_barrier: arm_mem_barrier::ARM_MB_INVALID, op_count: 0, operands: [ cs_arm_op { vector_index: 0, shift: cs_arm_op__bindgen_ty_1 { type_: arm_shifter::ARM_SFT_INVALID, value: 0 }, type_: arm_op_type::ARM_OP_INVALID, __bindgen_anon_1: cs_arm_op__bindgen_ty_2 { imm: 0 }, subtracted: false, access: 0, neon_lane: 0, } ; 36] }; let a2 = cs_arm { usermode: true, ..a1 }; let a3 = cs_arm { op_count: 20, ..a1 }; let a4 = cs_arm { op_count: 19, ..a1 }; let a4_clone = a4.clone(); assert_eq!(ArmInsnDetail(&a1), ArmInsnDetail(&a1)); assert_ne!(ArmInsnDetail(&a1), ArmInsnDetail(&a2)); assert_ne!(ArmInsnDetail(&a1), ArmInsnDetail(&a3)); assert_ne!(ArmInsnDetail(&a3), ArmInsnDetail(&a4)); assert_eq!(ArmInsnDetail(&a4), ArmInsnDetail(&a4_clone)); } }
random_line_split
arm.rs
//! Contains arm-specific types use core::convert::From; use core::{cmp, fmt, slice}; use capstone_sys::{ arm_op_mem, arm_op_type, cs_arm, cs_arm_op, arm_shifter, cs_arm_op__bindgen_ty_2}; use libc::c_uint; pub use crate::arch::arch_builder::arm::*; use crate::arch::DetailsArchInsn; use crate::instruction::{RegId, RegIdInt}; pub use capstone_sys::arm_insn_group as ArmInsnGroup; pub use capstone_sys::arm_insn as ArmInsn; pub use capstone_sys::arm_reg as ArmReg; pub use capstone_sys::arm_vectordata_type as ArmVectorData; pub use capstone_sys::arm_cpsmode_type as ArmCPSMode; pub use capstone_sys::arm_cpsflag_type as ArmCPSFlag; pub use capstone_sys::arm_cc as ArmCC; pub use capstone_sys::arm_mem_barrier as ArmMemBarrier; pub use capstone_sys::arm_setend_type as ArmSetendType; /// Contains ARM-specific details for an instruction pub struct ArmInsnDetail<'a>(pub(crate) &'a cs_arm); /// ARM shift amount #[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)] pub enum ArmShift { Invalid, /// Arithmetic shift right (immediate) Asr(u32), /// Logical shift lift (immediate) Lsl(u32), /// Logical shift right (immediate) Lsr(u32), /// Rotate right (immediate) Ror(u32), /// Rotate right with extend (immediate) Rrx(u32), /// Arithmetic shift right (register) AsrReg(RegId), /// Logical shift lift (register) LslReg(RegId), /// Logical shift right (register) LsrReg(RegId), /// Rotate right (register) RorReg(RegId), /// Rotate right with extend (register) RrxReg(RegId), } impl ArmShift { fn new(type_: arm_shifter, value: c_uint) -> ArmShift { use self::arm_shifter::*; use self::ArmShift::*; macro_rules! arm_shift_match { ( imm = [ $( $imm_r_enum:ident = $imm_c_enum:ident, )* ] reg = [ $( $reg_r_enum:ident = $reg_c_enum:ident, )* ] ) => { match type_ { ARM_SFT_INVALID => Invalid, $( $imm_c_enum => $imm_r_enum(value as u32), )* $( $reg_c_enum => $reg_r_enum(RegId(value as RegIdInt)), )* } } } arm_shift_match!( imm = [ Asr = ARM_SFT_ASR, Lsl = ARM_SFT_LSL, Lsr = ARM_SFT_LSR, Ror = ARM_SFT_ROR, Rrx = ARM_SFT_RRX, ] reg = [ AsrReg = ARM_SFT_ASR_REG, LslReg = ARM_SFT_LSL_REG, LsrReg = ARM_SFT_LSR_REG, RorReg = ARM_SFT_ROR_REG, RrxReg = ARM_SFT_RRX_REG, ] ) } } impl ArmOperandType { fn new(op_type: arm_op_type, value: cs_arm_op__bindgen_ty_2) -> ArmOperandType { use self::arm_op_type::*; use self::ArmOperandType::*; match op_type { ARM_OP_INVALID => Invalid, ARM_OP_REG => Reg(RegId(unsafe { value.reg } as RegIdInt)), ARM_OP_IMM => Imm(unsafe { value.imm }), ARM_OP_MEM => Mem(ArmOpMem(unsafe { value.mem })), ARM_OP_FP => Fp(unsafe { value.fp }), ARM_OP_CIMM => Cimm(unsafe { value.imm }), ARM_OP_PIMM => Pimm(unsafe { value.imm }), ARM_OP_SETEND => Setend(unsafe { value.setend }), ARM_OP_SYSREG => SysReg(RegId(unsafe { value.reg } as RegIdInt)), } } } /// ARM operand #[derive(Clone, Debug, PartialEq)] pub struct ArmOperand { /// Vector Index for some vector operands pub vector_index: Option<u32>, /// Whether operand is subtracted pub subtracted: bool, pub shift: ArmShift, /// Operand type pub op_type: ArmOperandType, } /// ARM operand #[derive(Clone, Debug, PartialEq)] pub enum ArmOperandType { /// Register Reg(RegId), /// Immediate Imm(i32), /// Memory Mem(ArmOpMem), /// Floating point Fp(f64), /// C-IMM Cimm(i32), /// P-IMM Pimm(i32), /// SETEND instruction endianness Setend(ArmSetendType), /// Sysreg SysReg(RegId), /// Invalid Invalid, } /// ARM memory operand #[derive(Debug, Copy, Clone)] pub struct ArmOpMem(pub(crate) arm_op_mem); impl<'a> ArmInsnDetail<'a> { /// Whether the instruction is a user mode pub fn usermode(&self) -> bool { self.0.usermode } /// Vector size pub fn vector_size(&self) -> i32 { self.0.vector_size as i32 } /// Type of vector data pub fn vector_data(&self) -> ArmVectorData { self.0.vector_data } /// CPS mode for CPS instruction pub fn cps_mode(&self) -> ArmCPSMode { self.0.cps_mode } /// CPS flag for CPS instruction pub fn cps_flag(&self) -> ArmCPSFlag { self.0.cps_flag } /// Condition codes pub fn cc(&self) -> ArmCC { self.0.cc } /// Whether this insn updates flags pub fn update_flags(&self) -> bool { self.0.update_flags } /// Whether writeback is required pub fn writeback(&self) -> bool { self.0.writeback } /// Memory barrier pub fn mem_barrier(&self) -> ArmMemBarrier { self.0.mem_barrier } } impl_PartialEq_repr_fields!(ArmInsnDetail<'a> [ 'a ]; usermode, vector_size, vector_data, cps_mode, cps_flag, cc, update_flags, writeback, mem_barrier, operands ); impl ArmOpMem { /// Base register pub fn base(&self) -> RegId { RegId(self.0.base as RegIdInt) } /// Index value pub fn
(&self) -> RegId { RegId(self.0.index as RegIdInt) } /// Scale for index register (can be 1, or -1) pub fn scale(&self) -> i32 { self.0.scale as i32 } /// Disp value pub fn disp(&self) -> i32 { self.0.disp as i32 } } impl_PartialEq_repr_fields!(ArmOpMem; base, index, scale, disp ); impl cmp::Eq for ArmOpMem {} impl Default for ArmOperand { fn default() -> Self { ArmOperand { vector_index: None, subtracted: false, shift: ArmShift::Invalid, op_type: ArmOperandType::Invalid } } } impl<'a> From<&'a cs_arm_op> for ArmOperand { fn from(op: &cs_arm_op) -> ArmOperand { let shift = ArmShift::new(op.shift.type_, op.shift.value); let op_type = ArmOperandType::new(op.type_, op.__bindgen_anon_1); let vector_index = if op.vector_index >= 0 { Some(op.vector_index as u32) } else { None }; ArmOperand { vector_index, shift, op_type, subtracted: op.subtracted, } } } def_arch_details_struct!( InsnDetail = ArmInsnDetail; Operand = ArmOperand; OperandIterator = ArmOperandIterator; OperandIteratorLife = ArmOperandIterator<'a>; [ pub struct ArmOperandIterator<'a>(slice::Iter<'a, cs_arm_op>); ] cs_arch_op = cs_arm_op; cs_arch = cs_arm; ); #[cfg(test)] mod test { use super::*; use capstone_sys::*; #[test] fn test_armshift() { use super::arm_shifter::*; use super::ArmShift::*; use libc::c_uint; fn t(shift_type_value: (arm_shifter, c_uint), arm_shift: ArmShift) { let (shift_type, value) = shift_type_value; assert_eq!(arm_shift, ArmShift::new(shift_type, value)); } t((ARM_SFT_INVALID, 0), Invalid); t((ARM_SFT_ASR, 0), Asr(0)); t((ARM_SFT_ASR_REG, 42), AsrReg(RegId(42))); t((ARM_SFT_RRX_REG, 42), RrxReg(RegId(42))); } #[test] fn test_arm_op_type() { use super::arm_op_type::*; use super::ArmOperandType::*; fn t( op_type_value: (arm_op_type, cs_arm_op__bindgen_ty_2), expected_op_type: ArmOperandType, ) { let (op_type, op_value) = op_type_value; let op_type = ArmOperandType::new(op_type, op_value); assert_eq!(expected_op_type, op_type); } t( (ARM_OP_INVALID, cs_arm_op__bindgen_ty_2 { reg: 0 }), Invalid, ); t( (ARM_OP_REG, cs_arm_op__bindgen_ty_2 { reg: 0 }), Reg(RegId(0)), ); } #[test] fn test_arm_insn_detail_eq() { let a1 = cs_arm { usermode: false, vector_size: 0, vector_data: arm_vectordata_type::ARM_VECTORDATA_INVALID, cps_mode: arm_cpsmode_type::ARM_CPSMODE_INVALID, cps_flag: arm_cpsflag_type::ARM_CPSFLAG_INVALID, cc: arm_cc::ARM_CC_INVALID, update_flags: false, writeback: false, mem_barrier: arm_mem_barrier::ARM_MB_INVALID, op_count: 0, operands: [ cs_arm_op { vector_index: 0, shift: cs_arm_op__bindgen_ty_1 { type_: arm_shifter::ARM_SFT_INVALID, value: 0 }, type_: arm_op_type::ARM_OP_INVALID, __bindgen_anon_1: cs_arm_op__bindgen_ty_2 { imm: 0 }, subtracted: false, access: 0, neon_lane: 0, } ; 36] }; let a2 = cs_arm { usermode: true, ..a1 }; let a3 = cs_arm { op_count: 20, ..a1 }; let a4 = cs_arm { op_count: 19, ..a1 }; let a4_clone = a4.clone(); assert_eq!(ArmInsnDetail(&a1), ArmInsnDetail(&a1)); assert_ne!(ArmInsnDetail(&a1), ArmInsnDetail(&a2)); assert_ne!(ArmInsnDetail(&a1), ArmInsnDetail(&a3)); assert_ne!(ArmInsnDetail(&a3), ArmInsnDetail(&a4)); assert_eq!(ArmInsnDetail(&a4), ArmInsnDetail(&a4_clone)); } }
index
identifier_name
absurd_extreme_comparisons.rs
use rustc_hir::{BinOpKind, Expr, ExprKind}; use rustc_lint::{LateContext, LateLintPass}; use rustc_middle::ty; use rustc_session::{declare_lint_pass, declare_tool_lint}; use clippy_utils::comparisons::{normalize_comparison, Rel}; use clippy_utils::consts::{constant, Constant}; use clippy_utils::diagnostics::span_lint_and_help; use clippy_utils::source::snippet; use clippy_utils::ty::is_isize_or_usize; use clippy_utils::{clip, int_bits, unsext}; declare_clippy_lint! { /// ### What it does /// Checks for comparisons where one side of the relation is /// either the minimum or maximum value for its type and warns if it involves a /// case that is always true or always false. Only integer and boolean types are /// checked. /// /// ### Why is this bad? /// An expression like `min <= x` may misleadingly imply /// that it is possible for `x` to be less than the minimum. Expressions like /// `max < x` are probably mistakes. /// /// ### Known problems /// For `usize` the size of the current compile target will /// be assumed (e.g., 64 bits on 64 bit systems). This means code that uses such /// a comparison to detect target pointer width will trigger this lint. One can /// use `mem::sizeof` and compare its value or conditional compilation /// attributes /// like `#[cfg(target_pointer_width = "64")]..` instead. /// /// ### Example /// ```rust /// let vec: Vec<isize> = Vec::new(); /// if vec.len() <= 0 {} /// if 100 > i32::MAX {} /// ``` pub ABSURD_EXTREME_COMPARISONS, correctness, "a comparison with a maximum or minimum value that is always true or false" } declare_lint_pass!(AbsurdExtremeComparisons => [ABSURD_EXTREME_COMPARISONS]); impl<'tcx> LateLintPass<'tcx> for AbsurdExtremeComparisons { fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) { if let ExprKind::Binary(ref cmp, lhs, rhs) = expr.kind { if let Some((culprit, result)) = detect_absurd_comparison(cx, cmp.node, lhs, rhs) { if!expr.span.from_expansion() { let msg = "this comparison involving the minimum or maximum element for this \ type contains a case that is always true or always false"; let conclusion = match result { AbsurdComparisonResult::AlwaysFalse => "this comparison is always false".to_owned(), AbsurdComparisonResult::AlwaysTrue => "this comparison is always true".to_owned(), AbsurdComparisonResult::InequalityImpossible => format!( "the case where the two sides are not equal never occurs, consider using `{} == {}` \ instead", snippet(cx, lhs.span, "lhs"), snippet(cx, rhs.span, "rhs") ), }; let help = format!( "because `{}` is the {} value for this type, {}", snippet(cx, culprit.expr.span, "x"), match culprit.which { ExtremeType::Minimum => "minimum", ExtremeType::Maximum => "maximum", }, conclusion ); span_lint_and_help(cx, ABSURD_EXTREME_COMPARISONS, expr.span, msg, None, &help); } } } } } enum ExtremeType { Minimum, Maximum, } struct ExtremeExpr<'a> { which: ExtremeType, expr: &'a Expr<'a>, } enum AbsurdComparisonResult { AlwaysFalse, AlwaysTrue, InequalityImpossible, } fn is_cast_between_fixed_and_target<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool { if let ExprKind::Cast(cast_exp, _) = expr.kind { let precast_ty = cx.typeck_results().expr_ty(cast_exp); let cast_ty = cx.typeck_results().expr_ty(expr); return is_isize_or_usize(precast_ty)!= is_isize_or_usize(cast_ty); } false } fn detect_absurd_comparison<'tcx>( cx: &LateContext<'tcx>, op: BinOpKind, lhs: &'tcx Expr<'_>, rhs: &'tcx Expr<'_>, ) -> Option<(ExtremeExpr<'tcx>, AbsurdComparisonResult)> { use AbsurdComparisonResult::{AlwaysFalse, AlwaysTrue, InequalityImpossible}; use ExtremeType::{Maximum, Minimum}; // absurd comparison only makes sense on primitive types // primitive types don't implement comparison operators with each other if cx.typeck_results().expr_ty(lhs)!= cx.typeck_results().expr_ty(rhs) { return None; } // comparisons between fix sized types and target sized types are considered unanalyzable if is_cast_between_fixed_and_target(cx, lhs) || is_cast_between_fixed_and_target(cx, rhs) { return None; } let (rel, normalized_lhs, normalized_rhs) = normalize_comparison(op, lhs, rhs)?; let lx = detect_extreme_expr(cx, normalized_lhs); let rx = detect_extreme_expr(cx, normalized_rhs); Some(match rel { Rel::Lt => { match (lx, rx) { (Some(l @ ExtremeExpr { which: Maximum,.. }), _) => (l, AlwaysFalse), // max < x (_, Some(r @ ExtremeExpr { which: Minimum,.. })) => (r, AlwaysFalse), // x < min _ => return None, } }, Rel::Le => { match (lx, rx) { (Some(l @ ExtremeExpr { which: Minimum,.. }), _) => (l, AlwaysTrue), // min <= x (Some(l @ ExtremeExpr { which: Maximum,.. }), _) => (l, InequalityImpossible), // max <= x (_, Some(r @ ExtremeExpr { which: Minimum,.. })) => (r, InequalityImpossible), // x <= min (_, Some(r @ ExtremeExpr { which: Maximum,.. })) => (r, AlwaysTrue), // x <= max _ => return None, } }, Rel::Ne | Rel::Eq => return None, }) } fn detect_extreme_expr<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<ExtremeExpr<'tcx>> { let ty = cx.typeck_results().expr_ty(expr); let cv = constant(cx, cx.typeck_results(), expr)?.0; let which = match (ty.kind(), cv) { (&ty::Bool, Constant::Bool(false)) | (&ty::Uint(_), Constant::Int(0)) => ExtremeType::Minimum, (&ty::Int(ity), Constant::Int(i)) if i == unsext(cx.tcx, i128::MIN >> (128 - int_bits(cx.tcx, ity)), ity) => { ExtremeType::Minimum }, (&ty::Bool, Constant::Bool(true)) => ExtremeType::Maximum, (&ty::Int(ity), Constant::Int(i)) if i == unsext(cx.tcx, i128::MAX >> (128 - int_bits(cx.tcx, ity)), ity) => { ExtremeType::Maximum }, (&ty::Uint(uty), Constant::Int(i)) if clip(cx.tcx, u128::MAX, uty) == i => ExtremeType::Maximum, _ => return None, }; Some(ExtremeExpr { which, expr })
}
random_line_split
absurd_extreme_comparisons.rs
use rustc_hir::{BinOpKind, Expr, ExprKind}; use rustc_lint::{LateContext, LateLintPass}; use rustc_middle::ty; use rustc_session::{declare_lint_pass, declare_tool_lint}; use clippy_utils::comparisons::{normalize_comparison, Rel}; use clippy_utils::consts::{constant, Constant}; use clippy_utils::diagnostics::span_lint_and_help; use clippy_utils::source::snippet; use clippy_utils::ty::is_isize_or_usize; use clippy_utils::{clip, int_bits, unsext}; declare_clippy_lint! { /// ### What it does /// Checks for comparisons where one side of the relation is /// either the minimum or maximum value for its type and warns if it involves a /// case that is always true or always false. Only integer and boolean types are /// checked. /// /// ### Why is this bad? /// An expression like `min <= x` may misleadingly imply /// that it is possible for `x` to be less than the minimum. Expressions like /// `max < x` are probably mistakes. /// /// ### Known problems /// For `usize` the size of the current compile target will /// be assumed (e.g., 64 bits on 64 bit systems). This means code that uses such /// a comparison to detect target pointer width will trigger this lint. One can /// use `mem::sizeof` and compare its value or conditional compilation /// attributes /// like `#[cfg(target_pointer_width = "64")]..` instead. /// /// ### Example /// ```rust /// let vec: Vec<isize> = Vec::new(); /// if vec.len() <= 0 {} /// if 100 > i32::MAX {} /// ``` pub ABSURD_EXTREME_COMPARISONS, correctness, "a comparison with a maximum or minimum value that is always true or false" } declare_lint_pass!(AbsurdExtremeComparisons => [ABSURD_EXTREME_COMPARISONS]); impl<'tcx> LateLintPass<'tcx> for AbsurdExtremeComparisons { fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) { if let ExprKind::Binary(ref cmp, lhs, rhs) = expr.kind { if let Some((culprit, result)) = detect_absurd_comparison(cx, cmp.node, lhs, rhs) { if!expr.span.from_expansion() { let msg = "this comparison involving the minimum or maximum element for this \ type contains a case that is always true or always false"; let conclusion = match result { AbsurdComparisonResult::AlwaysFalse => "this comparison is always false".to_owned(), AbsurdComparisonResult::AlwaysTrue => "this comparison is always true".to_owned(), AbsurdComparisonResult::InequalityImpossible => format!( "the case where the two sides are not equal never occurs, consider using `{} == {}` \ instead", snippet(cx, lhs.span, "lhs"), snippet(cx, rhs.span, "rhs") ), }; let help = format!( "because `{}` is the {} value for this type, {}", snippet(cx, culprit.expr.span, "x"), match culprit.which { ExtremeType::Minimum => "minimum", ExtremeType::Maximum => "maximum", }, conclusion ); span_lint_and_help(cx, ABSURD_EXTREME_COMPARISONS, expr.span, msg, None, &help); } } } } } enum
{ Minimum, Maximum, } struct ExtremeExpr<'a> { which: ExtremeType, expr: &'a Expr<'a>, } enum AbsurdComparisonResult { AlwaysFalse, AlwaysTrue, InequalityImpossible, } fn is_cast_between_fixed_and_target<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool { if let ExprKind::Cast(cast_exp, _) = expr.kind { let precast_ty = cx.typeck_results().expr_ty(cast_exp); let cast_ty = cx.typeck_results().expr_ty(expr); return is_isize_or_usize(precast_ty)!= is_isize_or_usize(cast_ty); } false } fn detect_absurd_comparison<'tcx>( cx: &LateContext<'tcx>, op: BinOpKind, lhs: &'tcx Expr<'_>, rhs: &'tcx Expr<'_>, ) -> Option<(ExtremeExpr<'tcx>, AbsurdComparisonResult)> { use AbsurdComparisonResult::{AlwaysFalse, AlwaysTrue, InequalityImpossible}; use ExtremeType::{Maximum, Minimum}; // absurd comparison only makes sense on primitive types // primitive types don't implement comparison operators with each other if cx.typeck_results().expr_ty(lhs)!= cx.typeck_results().expr_ty(rhs) { return None; } // comparisons between fix sized types and target sized types are considered unanalyzable if is_cast_between_fixed_and_target(cx, lhs) || is_cast_between_fixed_and_target(cx, rhs) { return None; } let (rel, normalized_lhs, normalized_rhs) = normalize_comparison(op, lhs, rhs)?; let lx = detect_extreme_expr(cx, normalized_lhs); let rx = detect_extreme_expr(cx, normalized_rhs); Some(match rel { Rel::Lt => { match (lx, rx) { (Some(l @ ExtremeExpr { which: Maximum,.. }), _) => (l, AlwaysFalse), // max < x (_, Some(r @ ExtremeExpr { which: Minimum,.. })) => (r, AlwaysFalse), // x < min _ => return None, } }, Rel::Le => { match (lx, rx) { (Some(l @ ExtremeExpr { which: Minimum,.. }), _) => (l, AlwaysTrue), // min <= x (Some(l @ ExtremeExpr { which: Maximum,.. }), _) => (l, InequalityImpossible), // max <= x (_, Some(r @ ExtremeExpr { which: Minimum,.. })) => (r, InequalityImpossible), // x <= min (_, Some(r @ ExtremeExpr { which: Maximum,.. })) => (r, AlwaysTrue), // x <= max _ => return None, } }, Rel::Ne | Rel::Eq => return None, }) } fn detect_extreme_expr<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<ExtremeExpr<'tcx>> { let ty = cx.typeck_results().expr_ty(expr); let cv = constant(cx, cx.typeck_results(), expr)?.0; let which = match (ty.kind(), cv) { (&ty::Bool, Constant::Bool(false)) | (&ty::Uint(_), Constant::Int(0)) => ExtremeType::Minimum, (&ty::Int(ity), Constant::Int(i)) if i == unsext(cx.tcx, i128::MIN >> (128 - int_bits(cx.tcx, ity)), ity) => { ExtremeType::Minimum }, (&ty::Bool, Constant::Bool(true)) => ExtremeType::Maximum, (&ty::Int(ity), Constant::Int(i)) if i == unsext(cx.tcx, i128::MAX >> (128 - int_bits(cx.tcx, ity)), ity) => { ExtremeType::Maximum }, (&ty::Uint(uty), Constant::Int(i)) if clip(cx.tcx, u128::MAX, uty) == i => ExtremeType::Maximum, _ => return None, }; Some(ExtremeExpr { which, expr }) }
ExtremeType
identifier_name
absurd_extreme_comparisons.rs
use rustc_hir::{BinOpKind, Expr, ExprKind}; use rustc_lint::{LateContext, LateLintPass}; use rustc_middle::ty; use rustc_session::{declare_lint_pass, declare_tool_lint}; use clippy_utils::comparisons::{normalize_comparison, Rel}; use clippy_utils::consts::{constant, Constant}; use clippy_utils::diagnostics::span_lint_and_help; use clippy_utils::source::snippet; use clippy_utils::ty::is_isize_or_usize; use clippy_utils::{clip, int_bits, unsext}; declare_clippy_lint! { /// ### What it does /// Checks for comparisons where one side of the relation is /// either the minimum or maximum value for its type and warns if it involves a /// case that is always true or always false. Only integer and boolean types are /// checked. /// /// ### Why is this bad? /// An expression like `min <= x` may misleadingly imply /// that it is possible for `x` to be less than the minimum. Expressions like /// `max < x` are probably mistakes. /// /// ### Known problems /// For `usize` the size of the current compile target will /// be assumed (e.g., 64 bits on 64 bit systems). This means code that uses such /// a comparison to detect target pointer width will trigger this lint. One can /// use `mem::sizeof` and compare its value or conditional compilation /// attributes /// like `#[cfg(target_pointer_width = "64")]..` instead. /// /// ### Example /// ```rust /// let vec: Vec<isize> = Vec::new(); /// if vec.len() <= 0 {} /// if 100 > i32::MAX {} /// ``` pub ABSURD_EXTREME_COMPARISONS, correctness, "a comparison with a maximum or minimum value that is always true or false" } declare_lint_pass!(AbsurdExtremeComparisons => [ABSURD_EXTREME_COMPARISONS]); impl<'tcx> LateLintPass<'tcx> for AbsurdExtremeComparisons { fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) { if let ExprKind::Binary(ref cmp, lhs, rhs) = expr.kind { if let Some((culprit, result)) = detect_absurd_comparison(cx, cmp.node, lhs, rhs) { if!expr.span.from_expansion() { let msg = "this comparison involving the minimum or maximum element for this \ type contains a case that is always true or always false"; let conclusion = match result { AbsurdComparisonResult::AlwaysFalse => "this comparison is always false".to_owned(), AbsurdComparisonResult::AlwaysTrue => "this comparison is always true".to_owned(), AbsurdComparisonResult::InequalityImpossible => format!( "the case where the two sides are not equal never occurs, consider using `{} == {}` \ instead", snippet(cx, lhs.span, "lhs"), snippet(cx, rhs.span, "rhs") ), }; let help = format!( "because `{}` is the {} value for this type, {}", snippet(cx, culprit.expr.span, "x"), match culprit.which { ExtremeType::Minimum => "minimum", ExtremeType::Maximum => "maximum", }, conclusion ); span_lint_and_help(cx, ABSURD_EXTREME_COMPARISONS, expr.span, msg, None, &help); } } } } } enum ExtremeType { Minimum, Maximum, } struct ExtremeExpr<'a> { which: ExtremeType, expr: &'a Expr<'a>, } enum AbsurdComparisonResult { AlwaysFalse, AlwaysTrue, InequalityImpossible, } fn is_cast_between_fixed_and_target<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> bool
fn detect_absurd_comparison<'tcx>( cx: &LateContext<'tcx>, op: BinOpKind, lhs: &'tcx Expr<'_>, rhs: &'tcx Expr<'_>, ) -> Option<(ExtremeExpr<'tcx>, AbsurdComparisonResult)> { use AbsurdComparisonResult::{AlwaysFalse, AlwaysTrue, InequalityImpossible}; use ExtremeType::{Maximum, Minimum}; // absurd comparison only makes sense on primitive types // primitive types don't implement comparison operators with each other if cx.typeck_results().expr_ty(lhs)!= cx.typeck_results().expr_ty(rhs) { return None; } // comparisons between fix sized types and target sized types are considered unanalyzable if is_cast_between_fixed_and_target(cx, lhs) || is_cast_between_fixed_and_target(cx, rhs) { return None; } let (rel, normalized_lhs, normalized_rhs) = normalize_comparison(op, lhs, rhs)?; let lx = detect_extreme_expr(cx, normalized_lhs); let rx = detect_extreme_expr(cx, normalized_rhs); Some(match rel { Rel::Lt => { match (lx, rx) { (Some(l @ ExtremeExpr { which: Maximum,.. }), _) => (l, AlwaysFalse), // max < x (_, Some(r @ ExtremeExpr { which: Minimum,.. })) => (r, AlwaysFalse), // x < min _ => return None, } }, Rel::Le => { match (lx, rx) { (Some(l @ ExtremeExpr { which: Minimum,.. }), _) => (l, AlwaysTrue), // min <= x (Some(l @ ExtremeExpr { which: Maximum,.. }), _) => (l, InequalityImpossible), // max <= x (_, Some(r @ ExtremeExpr { which: Minimum,.. })) => (r, InequalityImpossible), // x <= min (_, Some(r @ ExtremeExpr { which: Maximum,.. })) => (r, AlwaysTrue), // x <= max _ => return None, } }, Rel::Ne | Rel::Eq => return None, }) } fn detect_extreme_expr<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<ExtremeExpr<'tcx>> { let ty = cx.typeck_results().expr_ty(expr); let cv = constant(cx, cx.typeck_results(), expr)?.0; let which = match (ty.kind(), cv) { (&ty::Bool, Constant::Bool(false)) | (&ty::Uint(_), Constant::Int(0)) => ExtremeType::Minimum, (&ty::Int(ity), Constant::Int(i)) if i == unsext(cx.tcx, i128::MIN >> (128 - int_bits(cx.tcx, ity)), ity) => { ExtremeType::Minimum }, (&ty::Bool, Constant::Bool(true)) => ExtremeType::Maximum, (&ty::Int(ity), Constant::Int(i)) if i == unsext(cx.tcx, i128::MAX >> (128 - int_bits(cx.tcx, ity)), ity) => { ExtremeType::Maximum }, (&ty::Uint(uty), Constant::Int(i)) if clip(cx.tcx, u128::MAX, uty) == i => ExtremeType::Maximum, _ => return None, }; Some(ExtremeExpr { which, expr }) }
{ if let ExprKind::Cast(cast_exp, _) = expr.kind { let precast_ty = cx.typeck_results().expr_ty(cast_exp); let cast_ty = cx.typeck_results().expr_ty(expr); return is_isize_or_usize(precast_ty) != is_isize_or_usize(cast_ty); } false }
identifier_body
compress.rs
use std::fs::File; use std::io::Write; use std::path::{Path, PathBuf}; use ::image; use ::image::GenericImage; use dct; use quantize; use color_space; use compressed_image; use protobuf::Message;
use flate2::Compression; use flate2::write::ZlibEncoder; pub fn compress_file(input_filename: &Path) { let file_stem = match input_filename.file_stem() { Some(stem) => stem, None => panic!("Invalid input filename: Could not automatically determine output file"), }; let file_container = match input_filename.parent() { Some(result) => result, None => { panic!("Invalid input filename: Could not automatically determine the output file \ directory") } }; let mut output_filename = PathBuf::from(&file_container); output_filename.push(file_stem); output_filename.set_extension("msca"); compress_file_to_output(input_filename, output_filename.as_path()); } pub fn compress_file_to_output(input_filename: &Path, output_filename: &Path) { if let Some(extension) = output_filename.extension() { assert!(extension == "msca", "Output file for compression must be'msca'") } else { panic!("Output file for compression must be msca") } let input_image = image::open(input_filename).unwrap(); let mut output_file = File::create(&Path::new(&output_filename)).unwrap(); compress(&input_image, &mut output_file); } fn compress(input_image: &image::DynamicImage, output: &mut File) { let (width, height) = input_image.dimensions(); let mut red_channel: Vec<f32> = Vec::with_capacity(width as usize * height as usize); let mut green_channel: Vec<f32> = Vec::with_capacity(width as usize * height as usize); let mut blue_channel: Vec<f32> = Vec::with_capacity(width as usize * height as usize); // split the color data into channels for y in 0..height { for x in 0..width { let pixel = input_image.get_pixel(x, y); let (y, cb, cr) = color_space::rgb_to_ycbcr(pixel[0], pixel[1], pixel[2]); red_channel.push(y); green_channel.push(cb); blue_channel.push(cr); } } let mut serializer = compressed_image::compressed_image::new(); serializer.set_width(width); serializer.set_height(height); // compress the data and put it directly into the serializer serializer.set_red(compress_color_channel(width as usize, height as usize, red_channel)); serializer.set_green(compress_color_channel(width as usize, height as usize, green_channel)); serializer.set_blue(compress_color_channel(width as usize, height as usize, blue_channel)); let serialized_bytes = serializer.write_to_bytes().unwrap(); // losslessly compress the serialized data let mut enc = ZlibEncoder::new(output, Compression::Default); let mut written = 0; while written < serialized_bytes.len() { written += enc.write(&serialized_bytes[written..serialized_bytes.len()]).unwrap(); } let _ = enc.finish(); } fn compress_color_channel(width: usize, height: usize, mut uncompressed_channel_data: Vec<f32>) -> Vec<i32> { dct::dct2_2d(width, height, &mut uncompressed_channel_data); quantize::encode(width, height, &uncompressed_channel_data) }
random_line_split
compress.rs
use std::fs::File; use std::io::Write; use std::path::{Path, PathBuf}; use ::image; use ::image::GenericImage; use dct; use quantize; use color_space; use compressed_image; use protobuf::Message; use flate2::Compression; use flate2::write::ZlibEncoder; pub fn compress_file(input_filename: &Path) { let file_stem = match input_filename.file_stem() { Some(stem) => stem, None => panic!("Invalid input filename: Could not automatically determine output file"), }; let file_container = match input_filename.parent() { Some(result) => result, None => { panic!("Invalid input filename: Could not automatically determine the output file \ directory") } }; let mut output_filename = PathBuf::from(&file_container); output_filename.push(file_stem); output_filename.set_extension("msca"); compress_file_to_output(input_filename, output_filename.as_path()); } pub fn compress_file_to_output(input_filename: &Path, output_filename: &Path) { if let Some(extension) = output_filename.extension() { assert!(extension == "msca", "Output file for compression must be'msca'") } else { panic!("Output file for compression must be msca") } let input_image = image::open(input_filename).unwrap(); let mut output_file = File::create(&Path::new(&output_filename)).unwrap(); compress(&input_image, &mut output_file); } fn compress(input_image: &image::DynamicImage, output: &mut File) { let (width, height) = input_image.dimensions(); let mut red_channel: Vec<f32> = Vec::with_capacity(width as usize * height as usize); let mut green_channel: Vec<f32> = Vec::with_capacity(width as usize * height as usize); let mut blue_channel: Vec<f32> = Vec::with_capacity(width as usize * height as usize); // split the color data into channels for y in 0..height { for x in 0..width { let pixel = input_image.get_pixel(x, y); let (y, cb, cr) = color_space::rgb_to_ycbcr(pixel[0], pixel[1], pixel[2]); red_channel.push(y); green_channel.push(cb); blue_channel.push(cr); } } let mut serializer = compressed_image::compressed_image::new(); serializer.set_width(width); serializer.set_height(height); // compress the data and put it directly into the serializer serializer.set_red(compress_color_channel(width as usize, height as usize, red_channel)); serializer.set_green(compress_color_channel(width as usize, height as usize, green_channel)); serializer.set_blue(compress_color_channel(width as usize, height as usize, blue_channel)); let serialized_bytes = serializer.write_to_bytes().unwrap(); // losslessly compress the serialized data let mut enc = ZlibEncoder::new(output, Compression::Default); let mut written = 0; while written < serialized_bytes.len() { written += enc.write(&serialized_bytes[written..serialized_bytes.len()]).unwrap(); } let _ = enc.finish(); } fn compress_color_channel(width: usize, height: usize, mut uncompressed_channel_data: Vec<f32>) -> Vec<i32>
{ dct::dct2_2d(width, height, &mut uncompressed_channel_data); quantize::encode(width, height, &uncompressed_channel_data) }
identifier_body
compress.rs
use std::fs::File; use std::io::Write; use std::path::{Path, PathBuf}; use ::image; use ::image::GenericImage; use dct; use quantize; use color_space; use compressed_image; use protobuf::Message; use flate2::Compression; use flate2::write::ZlibEncoder; pub fn compress_file(input_filename: &Path) { let file_stem = match input_filename.file_stem() { Some(stem) => stem, None => panic!("Invalid input filename: Could not automatically determine output file"), }; let file_container = match input_filename.parent() { Some(result) => result, None => { panic!("Invalid input filename: Could not automatically determine the output file \ directory") } }; let mut output_filename = PathBuf::from(&file_container); output_filename.push(file_stem); output_filename.set_extension("msca"); compress_file_to_output(input_filename, output_filename.as_path()); } pub fn
(input_filename: &Path, output_filename: &Path) { if let Some(extension) = output_filename.extension() { assert!(extension == "msca", "Output file for compression must be'msca'") } else { panic!("Output file for compression must be msca") } let input_image = image::open(input_filename).unwrap(); let mut output_file = File::create(&Path::new(&output_filename)).unwrap(); compress(&input_image, &mut output_file); } fn compress(input_image: &image::DynamicImage, output: &mut File) { let (width, height) = input_image.dimensions(); let mut red_channel: Vec<f32> = Vec::with_capacity(width as usize * height as usize); let mut green_channel: Vec<f32> = Vec::with_capacity(width as usize * height as usize); let mut blue_channel: Vec<f32> = Vec::with_capacity(width as usize * height as usize); // split the color data into channels for y in 0..height { for x in 0..width { let pixel = input_image.get_pixel(x, y); let (y, cb, cr) = color_space::rgb_to_ycbcr(pixel[0], pixel[1], pixel[2]); red_channel.push(y); green_channel.push(cb); blue_channel.push(cr); } } let mut serializer = compressed_image::compressed_image::new(); serializer.set_width(width); serializer.set_height(height); // compress the data and put it directly into the serializer serializer.set_red(compress_color_channel(width as usize, height as usize, red_channel)); serializer.set_green(compress_color_channel(width as usize, height as usize, green_channel)); serializer.set_blue(compress_color_channel(width as usize, height as usize, blue_channel)); let serialized_bytes = serializer.write_to_bytes().unwrap(); // losslessly compress the serialized data let mut enc = ZlibEncoder::new(output, Compression::Default); let mut written = 0; while written < serialized_bytes.len() { written += enc.write(&serialized_bytes[written..serialized_bytes.len()]).unwrap(); } let _ = enc.finish(); } fn compress_color_channel(width: usize, height: usize, mut uncompressed_channel_data: Vec<f32>) -> Vec<i32> { dct::dct2_2d(width, height, &mut uncompressed_channel_data); quantize::encode(width, height, &uncompressed_channel_data) }
compress_file_to_output
identifier_name
config.rs
use crate::files; use crate::package; use std::path::PathBuf; use serde_json; use treeflection::{Node, NodeRunner, NodeToken}; #[derive(Clone, Serialize, Deserialize, Node)] pub struct Config { pub current_package: Option<String>, pub netplay_region: Option<String>, pub auto_save_replay: bool, pub verify_package_hashes: bool, pub fullscreen: bool,
} impl Config { fn get_path() -> PathBuf { let mut path = files::get_path(); path.push("config.json"); path } pub fn load() -> Config { if let Ok (json) = files::load_json(Config::get_path()) { if let Ok (mut config) = serde_json::from_value::<Config>(json) { // current_package may have been deleted since config was last saved if let Some (ref current_package) = config.current_package.clone() { if!package::exists(current_package.as_str()) { config.current_package = None; } } return config; } } warn!("{:?} is invalid or does not exist, loading default values", Config::get_path()); Config::default() } pub fn save(&self) { files::save_struct(Config::get_path(), self); } } impl Default for Config { fn default() -> Config { Config { current_package: None, netplay_region: None, auto_save_replay: false, verify_package_hashes: true, fullscreen: false, physical_device_name: None, } } }
pub physical_device_name: Option<String>,
random_line_split
config.rs
use crate::files; use crate::package; use std::path::PathBuf; use serde_json; use treeflection::{Node, NodeRunner, NodeToken}; #[derive(Clone, Serialize, Deserialize, Node)] pub struct Config { pub current_package: Option<String>, pub netplay_region: Option<String>, pub auto_save_replay: bool, pub verify_package_hashes: bool, pub fullscreen: bool, pub physical_device_name: Option<String>, } impl Config { fn get_path() -> PathBuf { let mut path = files::get_path(); path.push("config.json"); path } pub fn
() -> Config { if let Ok (json) = files::load_json(Config::get_path()) { if let Ok (mut config) = serde_json::from_value::<Config>(json) { // current_package may have been deleted since config was last saved if let Some (ref current_package) = config.current_package.clone() { if!package::exists(current_package.as_str()) { config.current_package = None; } } return config; } } warn!("{:?} is invalid or does not exist, loading default values", Config::get_path()); Config::default() } pub fn save(&self) { files::save_struct(Config::get_path(), self); } } impl Default for Config { fn default() -> Config { Config { current_package: None, netplay_region: None, auto_save_replay: false, verify_package_hashes: true, fullscreen: false, physical_device_name: None, } } }
load
identifier_name
config.rs
use crate::files; use crate::package; use std::path::PathBuf; use serde_json; use treeflection::{Node, NodeRunner, NodeToken}; #[derive(Clone, Serialize, Deserialize, Node)] pub struct Config { pub current_package: Option<String>, pub netplay_region: Option<String>, pub auto_save_replay: bool, pub verify_package_hashes: bool, pub fullscreen: bool, pub physical_device_name: Option<String>, } impl Config { fn get_path() -> PathBuf { let mut path = files::get_path(); path.push("config.json"); path } pub fn load() -> Config { if let Ok (json) = files::load_json(Config::get_path())
warn!("{:?} is invalid or does not exist, loading default values", Config::get_path()); Config::default() } pub fn save(&self) { files::save_struct(Config::get_path(), self); } } impl Default for Config { fn default() -> Config { Config { current_package: None, netplay_region: None, auto_save_replay: false, verify_package_hashes: true, fullscreen: false, physical_device_name: None, } } }
{ if let Ok (mut config) = serde_json::from_value::<Config>(json) { // current_package may have been deleted since config was last saved if let Some (ref current_package) = config.current_package.clone() { if !package::exists(current_package.as_str()) { config.current_package = None; } } return config; } }
conditional_block
main.rs
extern crate llvm_sys as llvm; extern crate libc; extern crate itertools; #[macro_use] extern crate clap; extern crate uuid; extern crate toml; #[macro_use] extern crate serde_derive; extern crate serde; extern crate bincode; extern crate time; extern crate either; macro_rules! try_opt { ($e:expr) =>( match $e { Some(v) => v, None => return None, } ) } mod ast; mod compileerror; mod bytecode; mod exportlibrary; mod parser; mod typechecker; mod span; mod llvmbackend; mod target; mod timer; mod package; mod packagebuild; use std::fs::File; use std::process::exit; use std::path::PathBuf; use clap::ArgMatches; use compileerror::{CompileResult}; use llvmbackend::{OutputType, llvm_init, llvm_shutdown}; use packagebuild::{PackageData, BuildOptions}; use exportlibrary::ExportLibrary; fn build_command(matches: &ArgMatches, dump_flags: &str) -> CompileResult<i32> { let input_file = matches.value_of("INPUT_FILE").expect("No input file given"); let build_options = BuildOptions{ optimize: matches.is_present("OPTIMIZE"), dump_flags: dump_flags.into(), target_machine: llvm_init()?, sources_directory: String::new(), import_directories: matches.value_of("IMPORTS") .map(|dirs| dirs.split(',').map(PathBuf::from).collect()) .unwrap_or_else(Vec::new), }; let output_type = match matches.value_of("LIB") { Some("static") => OutputType::StaticLib, Some("shared") => OutputType::SharedLib, _ => OutputType::Binary, }; let pkg = PackageData::single_file(&input_file, output_type)?; pkg.build(&build_options)?; Ok(0) } fn build_package_command(matches: &ArgMatches, dump_flags: &str) -> CompileResult<i32> { let package_toml = if let Some(toml) = matches.value_of("PACKAGE_TOML") { toml } else { "./package.toml" }; let pkg = PackageData::load(package_toml)?; let build_options = BuildOptions{ optimize: matches.is_present("OPTIMIZE"), dump_flags: dump_flags.into(), target_machine: llvm_init()?, sources_directory: "src".into(), import_directories: matches.value_of("IMPORTS") .map(|dirs| dirs.split(',').map(PathBuf::from).collect()) .unwrap_or_else(Vec::new), }; pkg.build(&build_options)?; Ok(0) } fn exports_command(matches: &ArgMatches) -> CompileResult<i32> { let exports_file_path = matches.value_of("EXPORTS_FILE").ok_or_else(|| "No exports file given".to_owned())?; let mut exports_file = File::open(&exports_file_path)?; let lib = ExportLibrary::load(&mut exports_file)?; println!("{}", lib); Ok(0) } fn
() -> CompileResult<i32> { let app = clap_app!(cobrac => (version: "0.1") (author: "Joris Guisson <[email protected]>") (about: "Nomad language compiler") (@arg DUMP: -d --dump +takes_value "Dump internal compiler state for debug purposes. Argument can be all, ast, bytecode or ir. A comma separated list of these values is also supported.") (@arg TARGET_TRIPLET: -t --triplet "Print the default target triplet of the current system, and exit") (@subcommand build => (about: "Build a menhir file") (@arg INPUT_FILE: +required "File to build") (@arg OUTPUT_FILE: -o --output +takes_value "Name of binary to create (by default input file without the extensions)") (@arg OPTIMIZE: -O --optimize "Optimize the code") (@arg IMPORTS: -I --imports +takes_value "Directory to look for imports, use a comma separated list for more then one.") (@arg LIB: -l --lib +takes_value possible_value[static shared] "Create a library, type of library must be pass") ) (@subcommand buildpkg => (about: "Build a menhir package.") (@arg PACKAGE_TOML: -p --package +takes_value "Specify the package.toml file. If not specified, menhir will look in the current directory for one.") (@arg OPTIMIZE: -O --optimize "Optimize the code") (@arg IMPORTS: -I --imports +takes_value "Directory to look for imports, use a comma separated list for more then one.") ) (@subcommand exports => (about: "List the exported symbols in an exports file") (@arg EXPORTS_FILE: +required "Exports file") ) ); let matches = app.get_matches(); let dump_flags = matches.value_of("DUMP").unwrap_or(""); if matches.is_present("TARGET_TRIPLET") { let target_machine = llvm_init()?; print!("{}", target_machine.target.triplet); Ok(0) } else if let Some(matches) = matches.subcommand_matches("build") { build_command(matches, dump_flags) } else if let Some(matches) = matches.subcommand_matches("buildpkg") { build_package_command(matches, dump_flags) } else if let Some(matches) = matches.subcommand_matches("exports") { exports_command(matches) } else { println!("{}", matches.usage()); Ok(1) } } fn main() { match run() { Ok(ret) => { llvm_shutdown(); exit(ret) }, Err(e) => { e.print(); llvm_shutdown(); exit(-1); }, } }
run
identifier_name
main.rs
extern crate llvm_sys as llvm; extern crate libc; extern crate itertools; #[macro_use] extern crate clap; extern crate uuid; extern crate toml; #[macro_use] extern crate serde_derive; extern crate serde; extern crate bincode; extern crate time; extern crate either; macro_rules! try_opt { ($e:expr) =>( match $e { Some(v) => v, None => return None, } ) } mod ast; mod compileerror; mod bytecode; mod exportlibrary; mod parser; mod typechecker; mod span; mod llvmbackend; mod target; mod timer; mod package; mod packagebuild; use std::fs::File; use std::process::exit; use std::path::PathBuf; use clap::ArgMatches; use compileerror::{CompileResult}; use llvmbackend::{OutputType, llvm_init, llvm_shutdown}; use packagebuild::{PackageData, BuildOptions}; use exportlibrary::ExportLibrary; fn build_command(matches: &ArgMatches, dump_flags: &str) -> CompileResult<i32> { let input_file = matches.value_of("INPUT_FILE").expect("No input file given"); let build_options = BuildOptions{ optimize: matches.is_present("OPTIMIZE"), dump_flags: dump_flags.into(), target_machine: llvm_init()?, sources_directory: String::new(), import_directories: matches.value_of("IMPORTS") .map(|dirs| dirs.split(',').map(PathBuf::from).collect()) .unwrap_or_else(Vec::new), }; let output_type = match matches.value_of("LIB") { Some("static") => OutputType::StaticLib, Some("shared") => OutputType::SharedLib, _ => OutputType::Binary, }; let pkg = PackageData::single_file(&input_file, output_type)?; pkg.build(&build_options)?; Ok(0) } fn build_package_command(matches: &ArgMatches, dump_flags: &str) -> CompileResult<i32> { let package_toml = if let Some(toml) = matches.value_of("PACKAGE_TOML") { toml } else { "./package.toml" }; let pkg = PackageData::load(package_toml)?; let build_options = BuildOptions{ optimize: matches.is_present("OPTIMIZE"), dump_flags: dump_flags.into(), target_machine: llvm_init()?, sources_directory: "src".into(), import_directories: matches.value_of("IMPORTS") .map(|dirs| dirs.split(',').map(PathBuf::from).collect()) .unwrap_or_else(Vec::new), }; pkg.build(&build_options)?; Ok(0) } fn exports_command(matches: &ArgMatches) -> CompileResult<i32> { let exports_file_path = matches.value_of("EXPORTS_FILE").ok_or_else(|| "No exports file given".to_owned())?; let mut exports_file = File::open(&exports_file_path)?; let lib = ExportLibrary::load(&mut exports_file)?; println!("{}", lib); Ok(0) } fn run() -> CompileResult<i32> { let app = clap_app!(cobrac => (version: "0.1") (author: "Joris Guisson <[email protected]>") (about: "Nomad language compiler") (@arg DUMP: -d --dump +takes_value "Dump internal compiler state for debug purposes. Argument can be all, ast, bytecode or ir. A comma separated list of these values is also supported.") (@arg TARGET_TRIPLET: -t --triplet "Print the default target triplet of the current system, and exit") (@subcommand build => (about: "Build a menhir file") (@arg INPUT_FILE: +required "File to build") (@arg OUTPUT_FILE: -o --output +takes_value "Name of binary to create (by default input file without the extensions)") (@arg OPTIMIZE: -O --optimize "Optimize the code") (@arg IMPORTS: -I --imports +takes_value "Directory to look for imports, use a comma separated list for more then one.") (@arg LIB: -l --lib +takes_value possible_value[static shared] "Create a library, type of library must be pass") ) (@subcommand buildpkg => (about: "Build a menhir package.") (@arg PACKAGE_TOML: -p --package +takes_value "Specify the package.toml file. If not specified, menhir will look in the current directory for one.") (@arg OPTIMIZE: -O --optimize "Optimize the code") (@arg IMPORTS: -I --imports +takes_value "Directory to look for imports, use a comma separated list for more then one.") ) (@subcommand exports => (about: "List the exported symbols in an exports file") (@arg EXPORTS_FILE: +required "Exports file") ) ); let matches = app.get_matches(); let dump_flags = matches.value_of("DUMP").unwrap_or(""); if matches.is_present("TARGET_TRIPLET") { let target_machine = llvm_init()?; print!("{}", target_machine.target.triplet); Ok(0) } else if let Some(matches) = matches.subcommand_matches("build") { build_command(matches, dump_flags) } else if let Some(matches) = matches.subcommand_matches("buildpkg") { build_package_command(matches, dump_flags) } else if let Some(matches) = matches.subcommand_matches("exports") { exports_command(matches) } else { println!("{}", matches.usage()); Ok(1) } } fn main()
{ match run() { Ok(ret) => { llvm_shutdown(); exit(ret) }, Err(e) => { e.print(); llvm_shutdown(); exit(-1); }, } }
identifier_body
main.rs
extern crate llvm_sys as llvm; extern crate libc; extern crate itertools; #[macro_use] extern crate clap; extern crate uuid; extern crate toml; #[macro_use] extern crate serde_derive; extern crate serde; extern crate bincode; extern crate time; extern crate either; macro_rules! try_opt { ($e:expr) =>( match $e { Some(v) => v, None => return None, } ) } mod ast; mod compileerror; mod bytecode; mod exportlibrary; mod parser; mod typechecker; mod span; mod llvmbackend; mod target; mod timer; mod package; mod packagebuild; use std::fs::File; use std::process::exit; use std::path::PathBuf; use clap::ArgMatches; use compileerror::{CompileResult}; use llvmbackend::{OutputType, llvm_init, llvm_shutdown}; use packagebuild::{PackageData, BuildOptions}; use exportlibrary::ExportLibrary; fn build_command(matches: &ArgMatches, dump_flags: &str) -> CompileResult<i32> { let input_file = matches.value_of("INPUT_FILE").expect("No input file given"); let build_options = BuildOptions{ optimize: matches.is_present("OPTIMIZE"), dump_flags: dump_flags.into(), target_machine: llvm_init()?, sources_directory: String::new(), import_directories: matches.value_of("IMPORTS") .map(|dirs| dirs.split(',').map(PathBuf::from).collect()) .unwrap_or_else(Vec::new), }; let output_type = match matches.value_of("LIB") { Some("static") => OutputType::StaticLib, Some("shared") => OutputType::SharedLib, _ => OutputType::Binary, }; let pkg = PackageData::single_file(&input_file, output_type)?; pkg.build(&build_options)?; Ok(0) } fn build_package_command(matches: &ArgMatches, dump_flags: &str) -> CompileResult<i32> { let package_toml = if let Some(toml) = matches.value_of("PACKAGE_TOML") { toml } else { "./package.toml" }; let pkg = PackageData::load(package_toml)?; let build_options = BuildOptions{ optimize: matches.is_present("OPTIMIZE"), dump_flags: dump_flags.into(), target_machine: llvm_init()?, sources_directory: "src".into(), import_directories: matches.value_of("IMPORTS") .map(|dirs| dirs.split(',').map(PathBuf::from).collect()) .unwrap_or_else(Vec::new), }; pkg.build(&build_options)?; Ok(0) } fn exports_command(matches: &ArgMatches) -> CompileResult<i32> { let exports_file_path = matches.value_of("EXPORTS_FILE").ok_or_else(|| "No exports file given".to_owned())?; let mut exports_file = File::open(&exports_file_path)?; let lib = ExportLibrary::load(&mut exports_file)?; println!("{}", lib); Ok(0) } fn run() -> CompileResult<i32> { let app = clap_app!(cobrac => (version: "0.1") (author: "Joris Guisson <[email protected]>") (about: "Nomad language compiler") (@arg DUMP: -d --dump +takes_value "Dump internal compiler state for debug purposes. Argument can be all, ast, bytecode or ir. A comma separated list of these values is also supported.") (@arg TARGET_TRIPLET: -t --triplet "Print the default target triplet of the current system, and exit") (@subcommand build => (about: "Build a menhir file") (@arg INPUT_FILE: +required "File to build") (@arg OUTPUT_FILE: -o --output +takes_value "Name of binary to create (by default input file without the extensions)") (@arg OPTIMIZE: -O --optimize "Optimize the code") (@arg IMPORTS: -I --imports +takes_value "Directory to look for imports, use a comma separated list for more then one.") (@arg LIB: -l --lib +takes_value possible_value[static shared] "Create a library, type of library must be pass") ) (@subcommand buildpkg => (about: "Build a menhir package.") (@arg PACKAGE_TOML: -p --package +takes_value "Specify the package.toml file. If not specified, menhir will look in the current directory for one.") (@arg OPTIMIZE: -O --optimize "Optimize the code") (@arg IMPORTS: -I --imports +takes_value "Directory to look for imports, use a comma separated list for more then one.") ) (@subcommand exports => (about: "List the exported symbols in an exports file") (@arg EXPORTS_FILE: +required "Exports file") ) ); let matches = app.get_matches(); let dump_flags = matches.value_of("DUMP").unwrap_or(""); if matches.is_present("TARGET_TRIPLET") { let target_machine = llvm_init()?; print!("{}", target_machine.target.triplet); Ok(0)
build_command(matches, dump_flags) } else if let Some(matches) = matches.subcommand_matches("buildpkg") { build_package_command(matches, dump_flags) } else if let Some(matches) = matches.subcommand_matches("exports") { exports_command(matches) } else { println!("{}", matches.usage()); Ok(1) } } fn main() { match run() { Ok(ret) => { llvm_shutdown(); exit(ret) }, Err(e) => { e.print(); llvm_shutdown(); exit(-1); }, } }
} else if let Some(matches) = matches.subcommand_matches("build") {
random_line_split
compound2d.rs
extern crate nalgebra as na; use na::{Isometry2, Vector2}; use ncollide2d::shape::{Compound, Cuboid, ShapeHandle}; fn main() { // Delta transformation matrices. let delta1 = Isometry2::new(Vector2::new(0.0f32, -1.5), na::zero()); let delta2 = Isometry2::new(Vector2::new(-1.5f32, 0.0), na::zero()); let delta3 = Isometry2::new(Vector2::new(1.5f32, 0.0), na::zero()); // 1) Initialize the shape list. let mut shapes = Vec::new(); let horizontal_box = ShapeHandle::new(Cuboid::new(Vector2::new(1.5f32, 0.25))); let vertical_box = ShapeHandle::new(Cuboid::new(Vector2::new(0.25f32, 1.5))); shapes.push((delta1, horizontal_box)); shapes.push((delta2, vertical_box.clone())); shapes.push((delta3, vertical_box));
// 2) Create the compound shape. let compound = Compound::new(shapes); assert!(compound.shapes().len() == 3) }
random_line_split
compound2d.rs
extern crate nalgebra as na; use na::{Isometry2, Vector2}; use ncollide2d::shape::{Compound, Cuboid, ShapeHandle}; fn main()
{ // Delta transformation matrices. let delta1 = Isometry2::new(Vector2::new(0.0f32, -1.5), na::zero()); let delta2 = Isometry2::new(Vector2::new(-1.5f32, 0.0), na::zero()); let delta3 = Isometry2::new(Vector2::new(1.5f32, 0.0), na::zero()); // 1) Initialize the shape list. let mut shapes = Vec::new(); let horizontal_box = ShapeHandle::new(Cuboid::new(Vector2::new(1.5f32, 0.25))); let vertical_box = ShapeHandle::new(Cuboid::new(Vector2::new(0.25f32, 1.5))); shapes.push((delta1, horizontal_box)); shapes.push((delta2, vertical_box.clone())); shapes.push((delta3, vertical_box)); // 2) Create the compound shape. let compound = Compound::new(shapes); assert!(compound.shapes().len() == 3) }
identifier_body
compound2d.rs
extern crate nalgebra as na; use na::{Isometry2, Vector2}; use ncollide2d::shape::{Compound, Cuboid, ShapeHandle}; fn
() { // Delta transformation matrices. let delta1 = Isometry2::new(Vector2::new(0.0f32, -1.5), na::zero()); let delta2 = Isometry2::new(Vector2::new(-1.5f32, 0.0), na::zero()); let delta3 = Isometry2::new(Vector2::new(1.5f32, 0.0), na::zero()); // 1) Initialize the shape list. let mut shapes = Vec::new(); let horizontal_box = ShapeHandle::new(Cuboid::new(Vector2::new(1.5f32, 0.25))); let vertical_box = ShapeHandle::new(Cuboid::new(Vector2::new(0.25f32, 1.5))); shapes.push((delta1, horizontal_box)); shapes.push((delta2, vertical_box.clone())); shapes.push((delta3, vertical_box)); // 2) Create the compound shape. let compound = Compound::new(shapes); assert!(compound.shapes().len() == 3) }
main
identifier_name
lib.rs
// Copyright TUNTAP, 2017 The Chromium OS Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #![allow(non_upper_case_globals)] #![allow(non_camel_case_types)] #![allow(non_snake_case)] use base::{ioctl_ior_nr, ioctl_iow_nr}; // generated with bindgen /usr/include/linux/if.h --no-unstable-rust // --constified-enum '*' --with-derive-default -- -D __UAPI_DEF_IF_IFNAMSIZ -D // __UAPI_DEF_IF_NET_DEVICE_FLAGS -D __UAPI_DEF_IF_IFREQ -D __UAPI_DEF_IF_IFMAP // Name is "iff" to avoid conflicting with "if" keyword. // Generated against Linux 4.11 to include fix "uapi: fix linux/if.h userspace // compilation errors". // Manual fixup of ifrn_name to be of type c_uchar instead of c_char. #[allow(clippy::all)] pub mod iff; // generated with bindgen /usr/include/linux/if_tun.h --no-unstable-rust // --constified-enum '*' --with-derive-default pub mod if_tun; // generated with bindgen /usr/include/linux/in.h --no-unstable-rust // --constified-enum '*' --with-derive-default // Name is "inn" to avoid conflicting with "in" keyword. pub mod inn; // generated with bindgen /usr/include/linux/sockios.h --no-unstable-rust // --constified-enum '*' --with-derive-default pub mod sockios; pub use crate::if_tun::*; pub use crate::iff::*; pub use crate::inn::*; pub use crate::sockios::*; pub const TUNTAP: ::std::os::raw::c_uint = 84; pub const ARPHRD_ETHER: sa_family_t = 1; ioctl_iow_nr!(TUNSETNOCSUM, TUNTAP, 200, ::std::os::raw::c_int); ioctl_iow_nr!(TUNSETDEBUG, TUNTAP, 201, ::std::os::raw::c_int); ioctl_iow_nr!(TUNSETIFF, TUNTAP, 202, ::std::os::raw::c_int); ioctl_iow_nr!(TUNSETPERSIST, TUNTAP, 203, ::std::os::raw::c_int); ioctl_iow_nr!(TUNSETOWNER, TUNTAP, 204, ::std::os::raw::c_int); ioctl_iow_nr!(TUNSETLINK, TUNTAP, 205, ::std::os::raw::c_int); ioctl_iow_nr!(TUNSETGROUP, TUNTAP, 206, ::std::os::raw::c_int); ioctl_ior_nr!(TUNGETFEATURES, TUNTAP, 207, ::std::os::raw::c_uint); ioctl_iow_nr!(TUNSETOFFLOAD, TUNTAP, 208, ::std::os::raw::c_uint); ioctl_iow_nr!(TUNSETTXFILTER, TUNTAP, 209, ::std::os::raw::c_uint); ioctl_ior_nr!(TUNGETIFF, TUNTAP, 210, ::std::os::raw::c_uint); ioctl_ior_nr!(TUNGETSNDBUF, TUNTAP, 211, ::std::os::raw::c_int); ioctl_iow_nr!(TUNSETSNDBUF, TUNTAP, 212, ::std::os::raw::c_int); ioctl_iow_nr!(TUNATTACHFILTER, TUNTAP, 213, sock_fprog); ioctl_iow_nr!(TUNDETACHFILTER, TUNTAP, 214, sock_fprog); ioctl_ior_nr!(TUNGETVNETHDRSZ, TUNTAP, 215, ::std::os::raw::c_int); ioctl_iow_nr!(TUNSETVNETHDRSZ, TUNTAP, 216, ::std::os::raw::c_int);
ioctl_iow_nr!(TUNSETIFINDEX, TUNTAP, 218, ::std::os::raw::c_uint); ioctl_ior_nr!(TUNGETFILTER, TUNTAP, 219, sock_fprog); ioctl_iow_nr!(TUNSETVNETLE, TUNTAP, 220, ::std::os::raw::c_int); ioctl_ior_nr!(TUNGETVNETLE, TUNTAP, 221, ::std::os::raw::c_int); ioctl_iow_nr!(TUNSETVNETBE, TUNTAP, 222, ::std::os::raw::c_int); ioctl_ior_nr!(TUNGETVNETBE, TUNTAP, 223, ::std::os::raw::c_int);
ioctl_iow_nr!(TUNSETQUEUE, TUNTAP, 217, ::std::os::raw::c_int);
random_line_split
mod.rs
// Copyright (C) 2020 Sebastian Dröge <[email protected]> // // 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 glib::prelude::*; mod imp; // The public Rust wrapper type for our element glib::glib_wrapper! { pub struct Rgb2Gray(ObjectSubclass<imp::Rgb2Gray>) @extends gst_base::BaseTransform, gst::Element, gst::Object; } // GStreamer elements need to be thread-safe. For the private implementation this is automatically // enforced but for the public wrapper type we need to specify this manually. unsafe impl Send for Rgb2Gray {} unsafe impl Sync for Rgb2Gray {}
// the name "rsrgb2gray" for being able to instantiate it via e.g. // gst::ElementFactory::make(). pub fn register(plugin: &gst::Plugin) -> Result<(), glib::BoolError> { gst::Element::register( Some(plugin), "rsrgb2gray", gst::Rank::None, Rgb2Gray::static_type(), ) }
// Registers the type for our element, and then registers in GStreamer under
random_line_split
mod.rs
// Copyright (C) 2020 Sebastian Dröge <[email protected]> // // 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 glib::prelude::*; mod imp; // The public Rust wrapper type for our element glib::glib_wrapper! { pub struct Rgb2Gray(ObjectSubclass<imp::Rgb2Gray>) @extends gst_base::BaseTransform, gst::Element, gst::Object; } // GStreamer elements need to be thread-safe. For the private implementation this is automatically // enforced but for the public wrapper type we need to specify this manually. unsafe impl Send for Rgb2Gray {} unsafe impl Sync for Rgb2Gray {} // Registers the type for our element, and then registers in GStreamer under // the name "rsrgb2gray" for being able to instantiate it via e.g. // gst::ElementFactory::make(). pub fn r
plugin: &gst::Plugin) -> Result<(), glib::BoolError> { gst::Element::register( Some(plugin), "rsrgb2gray", gst::Rank::None, Rgb2Gray::static_type(), ) }
egister(
identifier_name
mod.rs
// Copyright (C) 2020 Sebastian Dröge <[email protected]> // // 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 glib::prelude::*; mod imp; // The public Rust wrapper type for our element glib::glib_wrapper! { pub struct Rgb2Gray(ObjectSubclass<imp::Rgb2Gray>) @extends gst_base::BaseTransform, gst::Element, gst::Object; } // GStreamer elements need to be thread-safe. For the private implementation this is automatically // enforced but for the public wrapper type we need to specify this manually. unsafe impl Send for Rgb2Gray {} unsafe impl Sync for Rgb2Gray {} // Registers the type for our element, and then registers in GStreamer under // the name "rsrgb2gray" for being able to instantiate it via e.g. // gst::ElementFactory::make(). pub fn register(plugin: &gst::Plugin) -> Result<(), glib::BoolError> {
gst::Element::register( Some(plugin), "rsrgb2gray", gst::Rank::None, Rgb2Gray::static_type(), ) }
identifier_body
build.rs
use std::env; use std::fs::File; use std::io::Write; use std::path::Path; use std::process::Command; fn rustc_version()->String { let cmd = Command::new(env::var("RUSTC").unwrap()) .args(&["--version"]) .output() .expect("failed to execute process"); let mut x = String::from_utf8(cmd.stdout).unwrap(); x = x.trim().to_string(); if x.starts_with("rustc")
x } fn pybuildinfo()->Vec<u8> { let pyscript = " import os import sys if __name__ == '__main__': path = os.path.abspath(os.path.join(os.getcwd(), '..')) sys.path.append(path) import pybuildinfo.cmd pybuildinfo.cmd.cmd(sys.argv[2:]) "; let dict = format!("-dict={}", format!("{{ \"build_toolchain\": \"rustc\", \"build_toolchain_version\": \"{}\", \"build_target\": \"{}\" }}", rustc_version(), env::var("TARGET").unwrap())); let cmd = Command::new("python") .args(&["-c", pyscript, "-vcs=\"..\"", "-template=buildinfo_template.rs", &dict]) .output() .expect("failed to execute process"); assert_eq!(cmd.status.code().unwrap(), 0); cmd.stdout } fn main() { let out_dir = env::var("OUT_DIR").unwrap(); let dest_path = Path::new(&out_dir).join("pybuildinfo.rs"); let mut f = File::create(&dest_path).unwrap(); let buildinfo = pybuildinfo(); f.write_all(&buildinfo).unwrap(); }
{ x = x[5..].trim().to_string(); }
conditional_block
build.rs
use std::env; use std::fs::File; use std::io::Write; use std::path::Path; use std::process::Command; fn rustc_version()->String
fn pybuildinfo()->Vec<u8> { let pyscript = " import os import sys if __name__ == '__main__': path = os.path.abspath(os.path.join(os.getcwd(), '..')) sys.path.append(path) import pybuildinfo.cmd pybuildinfo.cmd.cmd(sys.argv[2:]) "; let dict = format!("-dict={}", format!("{{ \"build_toolchain\": \"rustc\", \"build_toolchain_version\": \"{}\", \"build_target\": \"{}\" }}", rustc_version(), env::var("TARGET").unwrap())); let cmd = Command::new("python") .args(&["-c", pyscript, "-vcs=\"..\"", "-template=buildinfo_template.rs", &dict]) .output() .expect("failed to execute process"); assert_eq!(cmd.status.code().unwrap(), 0); cmd.stdout } fn main() { let out_dir = env::var("OUT_DIR").unwrap(); let dest_path = Path::new(&out_dir).join("pybuildinfo.rs"); let mut f = File::create(&dest_path).unwrap(); let buildinfo = pybuildinfo(); f.write_all(&buildinfo).unwrap(); }
{ let cmd = Command::new(env::var("RUSTC").unwrap()) .args(&["--version"]) .output() .expect("failed to execute process"); let mut x = String::from_utf8(cmd.stdout).unwrap(); x = x.trim().to_string(); if x.starts_with("rustc") { x = x[5..].trim().to_string(); } x }
identifier_body
build.rs
use std::env; use std::fs::File; use std::io::Write; use std::path::Path; use std::process::Command; fn rustc_version()->String { let cmd = Command::new(env::var("RUSTC").unwrap()) .args(&["--version"]) .output() .expect("failed to execute process"); let mut x = String::from_utf8(cmd.stdout).unwrap(); x = x.trim().to_string(); if x.starts_with("rustc") { x = x[5..].trim().to_string(); } x } fn pybuildinfo()->Vec<u8> { let pyscript = " import os import sys if __name__ == '__main__': path = os.path.abspath(os.path.join(os.getcwd(), '..')) sys.path.append(path) import pybuildinfo.cmd
\"build_toolchain_version\": \"{}\", \"build_target\": \"{}\" }}", rustc_version(), env::var("TARGET").unwrap())); let cmd = Command::new("python") .args(&["-c", pyscript, "-vcs=\"..\"", "-template=buildinfo_template.rs", &dict]) .output() .expect("failed to execute process"); assert_eq!(cmd.status.code().unwrap(), 0); cmd.stdout } fn main() { let out_dir = env::var("OUT_DIR").unwrap(); let dest_path = Path::new(&out_dir).join("pybuildinfo.rs"); let mut f = File::create(&dest_path).unwrap(); let buildinfo = pybuildinfo(); f.write_all(&buildinfo).unwrap(); }
pybuildinfo.cmd.cmd(sys.argv[2:]) "; let dict = format!("-dict={}", format!("{{ \"build_toolchain\": \"rustc\",
random_line_split
build.rs
use std::env; use std::fs::File; use std::io::Write; use std::path::Path; use std::process::Command; fn
()->String { let cmd = Command::new(env::var("RUSTC").unwrap()) .args(&["--version"]) .output() .expect("failed to execute process"); let mut x = String::from_utf8(cmd.stdout).unwrap(); x = x.trim().to_string(); if x.starts_with("rustc") { x = x[5..].trim().to_string(); } x } fn pybuildinfo()->Vec<u8> { let pyscript = " import os import sys if __name__ == '__main__': path = os.path.abspath(os.path.join(os.getcwd(), '..')) sys.path.append(path) import pybuildinfo.cmd pybuildinfo.cmd.cmd(sys.argv[2:]) "; let dict = format!("-dict={}", format!("{{ \"build_toolchain\": \"rustc\", \"build_toolchain_version\": \"{}\", \"build_target\": \"{}\" }}", rustc_version(), env::var("TARGET").unwrap())); let cmd = Command::new("python") .args(&["-c", pyscript, "-vcs=\"..\"", "-template=buildinfo_template.rs", &dict]) .output() .expect("failed to execute process"); assert_eq!(cmd.status.code().unwrap(), 0); cmd.stdout } fn main() { let out_dir = env::var("OUT_DIR").unwrap(); let dest_path = Path::new(&out_dir).join("pybuildinfo.rs"); let mut f = File::create(&dest_path).unwrap(); let buildinfo = pybuildinfo(); f.write_all(&buildinfo).unwrap(); }
rustc_version
identifier_name
mod.rs
use syntax::ptr::P; use syntax::{ast, codemap}; use syntax::ext::base; use syntax::ext::build::AstBuilder; use html::HtmlState; mod template; /// Trait meaning something can be turned into an ast::Item with configuration. pub trait Generate<Cfg> { /// Turn Self into an ast::Item with a configuration object. fn generate( self, codemap::Span, &mut base::ExtCtxt, Cfg ) -> P<ast::Item>; }
/// /// /// impl Generate<()> for HtmlState { fn generate( self, sp: codemap::Span, cx: &mut base::ExtCtxt, _: () ) -> P<ast::Item> { let skin = self.skin.clone().unwrap(); let template_items = self.templates.into_iter().map( |template| template.generate(sp, cx, ()) ).collect(); // we create the module made of the created function cx.item_mod(sp, sp, skin, vec![], vec![], template_items) } }
random_line_split
mod.rs
use syntax::ptr::P; use syntax::{ast, codemap}; use syntax::ext::base; use syntax::ext::build::AstBuilder; use html::HtmlState; mod template; /// Trait meaning something can be turned into an ast::Item with configuration. pub trait Generate<Cfg> { /// Turn Self into an ast::Item with a configuration object. fn generate( self, codemap::Span, &mut base::ExtCtxt, Cfg ) -> P<ast::Item>; } /// /// /// impl Generate<()> for HtmlState { fn
( self, sp: codemap::Span, cx: &mut base::ExtCtxt, _: () ) -> P<ast::Item> { let skin = self.skin.clone().unwrap(); let template_items = self.templates.into_iter().map( |template| template.generate(sp, cx, ()) ).collect(); // we create the module made of the created function cx.item_mod(sp, sp, skin, vec![], vec![], template_items) } }
generate
identifier_name
mod.rs
use syntax::ptr::P; use syntax::{ast, codemap}; use syntax::ext::base; use syntax::ext::build::AstBuilder; use html::HtmlState; mod template; /// Trait meaning something can be turned into an ast::Item with configuration. pub trait Generate<Cfg> { /// Turn Self into an ast::Item with a configuration object. fn generate( self, codemap::Span, &mut base::ExtCtxt, Cfg ) -> P<ast::Item>; } /// /// /// impl Generate<()> for HtmlState { fn generate( self, sp: codemap::Span, cx: &mut base::ExtCtxt, _: () ) -> P<ast::Item>
}
{ let skin = self.skin.clone().unwrap(); let template_items = self.templates.into_iter().map( |template| template.generate(sp, cx, ()) ).collect(); // we create the module made of the created function cx.item_mod(sp, sp, skin, vec![], vec![], template_items) }
identifier_body
billow.rs
// example.rs extern crate noise; extern crate image; extern crate time; use noise::gen::NoiseGen; use noise::gen::billow::Billow; use image::GenericImage; use std::io::File; use time::precise_time_s; fn
() { let mut ngen = Billow::new_rand(24, 0.5, 2.5, 100.0); println!("Noise seed is {}", ngen.get_seed()); let img_size = 512 as u32; let mut imbuf = image::ImageBuf::new(img_size, img_size); let start = precise_time_s(); for x in range(0, img_size) { for y in range(0, img_size) { let n = ngen.get_value2d((x as f64), (y as f64)); let col = (n * 255.0) as u8; let pixel = image::Luma(col); imbuf.put_pixel(x, y, pixel); } } let end = precise_time_s(); let fout = File::create(&Path::new("billow.png")).unwrap(); let _ = image::ImageLuma8(imbuf).save(fout, image::PNG); println!("billow.png saved"); println!("generated {} points in {} ms", img_size*img_size, (end-start)*1000.0); }
main
identifier_name
billow.rs
// example.rs extern crate noise; extern crate image; extern crate time; use noise::gen::NoiseGen; use noise::gen::billow::Billow; use image::GenericImage; use std::io::File; use time::precise_time_s; fn main()
let _ = image::ImageLuma8(imbuf).save(fout, image::PNG); println!("billow.png saved"); println!("generated {} points in {} ms", img_size*img_size, (end-start)*1000.0); }
{ let mut ngen = Billow::new_rand(24, 0.5, 2.5, 100.0); println!("Noise seed is {}", ngen.get_seed()); let img_size = 512 as u32; let mut imbuf = image::ImageBuf::new(img_size, img_size); let start = precise_time_s(); for x in range(0, img_size) { for y in range(0, img_size) { let n = ngen.get_value2d((x as f64), (y as f64)); let col = (n * 255.0) as u8; let pixel = image::Luma(col); imbuf.put_pixel(x, y, pixel); } } let end = precise_time_s(); let fout = File::create(&Path::new("billow.png")).unwrap();
identifier_body
billow.rs
// example.rs extern crate noise; extern crate image; extern crate time; use noise::gen::NoiseGen; use noise::gen::billow::Billow; use image::GenericImage; use std::io::File; use time::precise_time_s; fn main() { let mut ngen = Billow::new_rand(24, 0.5, 2.5, 100.0); println!("Noise seed is {}", ngen.get_seed()); let img_size = 512 as u32; let mut imbuf = image::ImageBuf::new(img_size, img_size);
let n = ngen.get_value2d((x as f64), (y as f64)); let col = (n * 255.0) as u8; let pixel = image::Luma(col); imbuf.put_pixel(x, y, pixel); } } let end = precise_time_s(); let fout = File::create(&Path::new("billow.png")).unwrap(); let _ = image::ImageLuma8(imbuf).save(fout, image::PNG); println!("billow.png saved"); println!("generated {} points in {} ms", img_size*img_size, (end-start)*1000.0); }
let start = precise_time_s(); for x in range(0, img_size) { for y in range(0, img_size) {
random_line_split
live_timers.rs
use std::collections::HashMap; use platform::time::time_now; use super::StartTime; use super::Timing; #[derive(Debug, Clone, PartialEq)] pub struct LiveTimers { timers: HashMap<String, StartTime>, }
impl LiveTimers { pub fn new() -> LiveTimers { LiveTimers { timers: HashMap::new() } } pub fn get_timers(&self) -> &HashMap<String, StartTime> { &self.timers } pub fn start(&mut self, name: &str) -> StartTime { let start_time = time_now(); self.timers.insert(name.to_string(), start_time.clone()); start_time } pub fn stop(&mut self, name: &str) -> Timing { let stop_time = time_now(); let opt = self.timers.remove(name); if opt.is_none() { panic!("Tried to stop non-live timer: {:?}", name); } let start_time = opt.unwrap(); let duration = stop_time - start_time; Timing::new(name, start_time, duration) } }
random_line_split
live_timers.rs
use std::collections::HashMap; use platform::time::time_now; use super::StartTime; use super::Timing; #[derive(Debug, Clone, PartialEq)] pub struct LiveTimers { timers: HashMap<String, StartTime>, } impl LiveTimers { pub fn
() -> LiveTimers { LiveTimers { timers: HashMap::new() } } pub fn get_timers(&self) -> &HashMap<String, StartTime> { &self.timers } pub fn start(&mut self, name: &str) -> StartTime { let start_time = time_now(); self.timers.insert(name.to_string(), start_time.clone()); start_time } pub fn stop(&mut self, name: &str) -> Timing { let stop_time = time_now(); let opt = self.timers.remove(name); if opt.is_none() { panic!("Tried to stop non-live timer: {:?}", name); } let start_time = opt.unwrap(); let duration = stop_time - start_time; Timing::new(name, start_time, duration) } }
new
identifier_name
live_timers.rs
use std::collections::HashMap; use platform::time::time_now; use super::StartTime; use super::Timing; #[derive(Debug, Clone, PartialEq)] pub struct LiveTimers { timers: HashMap<String, StartTime>, } impl LiveTimers { pub fn new() -> LiveTimers { LiveTimers { timers: HashMap::new() } } pub fn get_timers(&self) -> &HashMap<String, StartTime> { &self.timers } pub fn start(&mut self, name: &str) -> StartTime { let start_time = time_now(); self.timers.insert(name.to_string(), start_time.clone()); start_time } pub fn stop(&mut self, name: &str) -> Timing { let stop_time = time_now(); let opt = self.timers.remove(name); if opt.is_none()
let start_time = opt.unwrap(); let duration = stop_time - start_time; Timing::new(name, start_time, duration) } }
{ panic!("Tried to stop non-live timer: {:?}", name); }
conditional_block
live_timers.rs
use std::collections::HashMap; use platform::time::time_now; use super::StartTime; use super::Timing; #[derive(Debug, Clone, PartialEq)] pub struct LiveTimers { timers: HashMap<String, StartTime>, } impl LiveTimers { pub fn new() -> LiveTimers { LiveTimers { timers: HashMap::new() } } pub fn get_timers(&self) -> &HashMap<String, StartTime>
pub fn start(&mut self, name: &str) -> StartTime { let start_time = time_now(); self.timers.insert(name.to_string(), start_time.clone()); start_time } pub fn stop(&mut self, name: &str) -> Timing { let stop_time = time_now(); let opt = self.timers.remove(name); if opt.is_none() { panic!("Tried to stop non-live timer: {:?}", name); } let start_time = opt.unwrap(); let duration = stop_time - start_time; Timing::new(name, start_time, duration) } }
{ &self.timers }
identifier_body
try_chan.rs
// Copyright 2016 Google Inc. All rights reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. //! A simple test program for evaluating the speed of cross-thread communications. extern crate xi_rpc; use std::thread; use std::sync::mpsc; /* use xi_rpc::chan::Chan; pub fn test_chan() { let n_iter = 1000000; let chan1 = Chan::new(); let chan1s = chan1.clone(); let chan2 = Chan::new(); let chan2s = chan2.clone(); let thread1 = thread::spawn(move|| { for _ in 0..n_iter { chan2s.try_send(chan1.recv()); } }); let thread2 = thread::spawn(move|| { for _ in 0..n_iter { chan1s.try_send(42); let _ = chan2.recv(); } }); let _ = thread1.join(); let _ = thread2.join(); } */ pub fn test_mpsc() { let n_iter = 1000000; let (chan1s, chan1) = mpsc::channel(); let (chan2s, chan2) = mpsc::channel(); let thread1 = thread::spawn(move|| { for _ in 0..n_iter { chan2s.send(chan1.recv()).unwrap(); } }); let thread2 = thread::spawn(move|| { for _ in 0..n_iter { chan1s.send(42).unwrap(); let _ = chan2.recv(); } }); let _ = thread1.join(); let _ = thread2.join(); } pub fn main()
{ test_mpsc() }
identifier_body
try_chan.rs
// Copyright 2016 Google Inc. All rights reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. //! A simple test program for evaluating the speed of cross-thread communications. extern crate xi_rpc;
/* use xi_rpc::chan::Chan; pub fn test_chan() { let n_iter = 1000000; let chan1 = Chan::new(); let chan1s = chan1.clone(); let chan2 = Chan::new(); let chan2s = chan2.clone(); let thread1 = thread::spawn(move|| { for _ in 0..n_iter { chan2s.try_send(chan1.recv()); } }); let thread2 = thread::spawn(move|| { for _ in 0..n_iter { chan1s.try_send(42); let _ = chan2.recv(); } }); let _ = thread1.join(); let _ = thread2.join(); } */ pub fn test_mpsc() { let n_iter = 1000000; let (chan1s, chan1) = mpsc::channel(); let (chan2s, chan2) = mpsc::channel(); let thread1 = thread::spawn(move|| { for _ in 0..n_iter { chan2s.send(chan1.recv()).unwrap(); } }); let thread2 = thread::spawn(move|| { for _ in 0..n_iter { chan1s.send(42).unwrap(); let _ = chan2.recv(); } }); let _ = thread1.join(); let _ = thread2.join(); } pub fn main() { test_mpsc() }
use std::thread; use std::sync::mpsc;
random_line_split
try_chan.rs
// Copyright 2016 Google Inc. All rights reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. //! A simple test program for evaluating the speed of cross-thread communications. extern crate xi_rpc; use std::thread; use std::sync::mpsc; /* use xi_rpc::chan::Chan; pub fn test_chan() { let n_iter = 1000000; let chan1 = Chan::new(); let chan1s = chan1.clone(); let chan2 = Chan::new(); let chan2s = chan2.clone(); let thread1 = thread::spawn(move|| { for _ in 0..n_iter { chan2s.try_send(chan1.recv()); } }); let thread2 = thread::spawn(move|| { for _ in 0..n_iter { chan1s.try_send(42); let _ = chan2.recv(); } }); let _ = thread1.join(); let _ = thread2.join(); } */ pub fn
() { let n_iter = 1000000; let (chan1s, chan1) = mpsc::channel(); let (chan2s, chan2) = mpsc::channel(); let thread1 = thread::spawn(move|| { for _ in 0..n_iter { chan2s.send(chan1.recv()).unwrap(); } }); let thread2 = thread::spawn(move|| { for _ in 0..n_iter { chan1s.send(42).unwrap(); let _ = chan2.recv(); } }); let _ = thread1.join(); let _ = thread2.join(); } pub fn main() { test_mpsc() }
test_mpsc
identifier_name
get_type_id.rs
#![feature(core)] extern crate core; #[cfg(test)] mod tests { use core::any::Any; use core::any::TypeId; // #[derive(Clone, Copy, PartialEq, Eq, Debug, Hash)] // #[stable(feature = "rust1", since = "1.0.0")] // pub struct TypeId { // t: u64, // } // impl<T: Reflect +'static> Any for T { // fn get_type_id(&self) -> TypeId { TypeId::of::<T>() } // } type T = i32; #[test] fn get_type_id_test1() { let x: T = 68; let y: T = 500; let x_typeid: TypeId = x.get_type_id(); let y_typeid: TypeId = y.get_type_id(); assert_eq!(x_typeid, y_typeid); } #[test] fn get_type_id_test2()
}
{ struct A; let x: A = A; let _: TypeId = x.get_type_id(); }
identifier_body
get_type_id.rs
#![feature(core)] extern crate core; #[cfg(test)] mod tests { use core::any::Any; use core::any::TypeId; // #[derive(Clone, Copy, PartialEq, Eq, Debug, Hash)] // #[stable(feature = "rust1", since = "1.0.0")] // pub struct TypeId { // t: u64, // } // impl<T: Reflect +'static> Any for T { // fn get_type_id(&self) -> TypeId { TypeId::of::<T>() } // } type T = i32; #[test] fn get_type_id_test1() { let x: T = 68; let y: T = 500; let x_typeid: TypeId = x.get_type_id(); let y_typeid: TypeId = y.get_type_id(); assert_eq!(x_typeid, y_typeid); } #[test] fn get_type_id_test2() { struct A; let x: A = A; let _: TypeId = x.get_type_id();
} }
random_line_split
get_type_id.rs
#![feature(core)] extern crate core; #[cfg(test)] mod tests { use core::any::Any; use core::any::TypeId; // #[derive(Clone, Copy, PartialEq, Eq, Debug, Hash)] // #[stable(feature = "rust1", since = "1.0.0")] // pub struct TypeId { // t: u64, // } // impl<T: Reflect +'static> Any for T { // fn get_type_id(&self) -> TypeId { TypeId::of::<T>() } // } type T = i32; #[test] fn get_type_id_test1() { let x: T = 68; let y: T = 500; let x_typeid: TypeId = x.get_type_id(); let y_typeid: TypeId = y.get_type_id(); assert_eq!(x_typeid, y_typeid); } #[test] fn get_type_id_test2() { struct
; let x: A = A; let _: TypeId = x.get_type_id(); } }
A
identifier_name
sampler_renderer.rs
use core::{Camera, Integrator, Sampler, Scene}; use film::Spectrum; use linalg::ray_differential::RayDifferential; use integrator::{SurfaceIntegrator, VolumeIntegrator}; use renderer::Renderer; pub struct SamplerRenderer<'a, S: Sampler, C: Camera> { pub sampler: S, pub camera: C, pub surface_integrator: &'a SurfaceIntegrator, pub volume_integrator: &'a VolumeIntegrator, } impl<'a, S: Sampler, C: Camera> SamplerRenderer<'a, S, C> { fn new(sampler: S, camera: C, surface_integrator: &'a SurfaceIntegrator, volume_integrator: &'a VolumeIntegrator) -> SamplerRenderer<'a, S, C> { SamplerRenderer { sampler: sampler, camera: camera, surface_integrator: surface_integrator, volume_integrator: volume_integrator, } } } impl<'a, S: Sampler, C: Camera> Renderer for SamplerRenderer<'a, S, C> { fn render(&self, scene: &Scene)
#[allow(unused_variables)] fn li(&self, scene: &Scene, ray: &RayDifferential, sample: &Sampler) -> Box<Spectrum> { unimplemented!() } #[allow(unused_variables)] fn transmittance(&self, scene: &Scene, ray: &RayDifferential, sample: &Sampler) -> Box<Spectrum> { unimplemented!() } }
{ self.surface_integrator.preprocess(scene, &self.camera); self.volume_integrator.preprocess(scene, &self.camera); }
identifier_body
sampler_renderer.rs
use core::{Camera, Integrator, Sampler, Scene}; use film::Spectrum; use linalg::ray_differential::RayDifferential; use integrator::{SurfaceIntegrator, VolumeIntegrator}; use renderer::Renderer; pub struct SamplerRenderer<'a, S: Sampler, C: Camera> { pub sampler: S, pub camera: C, pub surface_integrator: &'a SurfaceIntegrator, pub volume_integrator: &'a VolumeIntegrator,
fn new(sampler: S, camera: C, surface_integrator: &'a SurfaceIntegrator, volume_integrator: &'a VolumeIntegrator) -> SamplerRenderer<'a, S, C> { SamplerRenderer { sampler: sampler, camera: camera, surface_integrator: surface_integrator, volume_integrator: volume_integrator, } } } impl<'a, S: Sampler, C: Camera> Renderer for SamplerRenderer<'a, S, C> { fn render(&self, scene: &Scene) { self.surface_integrator.preprocess(scene, &self.camera); self.volume_integrator.preprocess(scene, &self.camera); } #[allow(unused_variables)] fn li(&self, scene: &Scene, ray: &RayDifferential, sample: &Sampler) -> Box<Spectrum> { unimplemented!() } #[allow(unused_variables)] fn transmittance(&self, scene: &Scene, ray: &RayDifferential, sample: &Sampler) -> Box<Spectrum> { unimplemented!() } }
} impl<'a, S: Sampler, C: Camera> SamplerRenderer<'a, S, C> {
random_line_split
sampler_renderer.rs
use core::{Camera, Integrator, Sampler, Scene}; use film::Spectrum; use linalg::ray_differential::RayDifferential; use integrator::{SurfaceIntegrator, VolumeIntegrator}; use renderer::Renderer; pub struct
<'a, S: Sampler, C: Camera> { pub sampler: S, pub camera: C, pub surface_integrator: &'a SurfaceIntegrator, pub volume_integrator: &'a VolumeIntegrator, } impl<'a, S: Sampler, C: Camera> SamplerRenderer<'a, S, C> { fn new(sampler: S, camera: C, surface_integrator: &'a SurfaceIntegrator, volume_integrator: &'a VolumeIntegrator) -> SamplerRenderer<'a, S, C> { SamplerRenderer { sampler: sampler, camera: camera, surface_integrator: surface_integrator, volume_integrator: volume_integrator, } } } impl<'a, S: Sampler, C: Camera> Renderer for SamplerRenderer<'a, S, C> { fn render(&self, scene: &Scene) { self.surface_integrator.preprocess(scene, &self.camera); self.volume_integrator.preprocess(scene, &self.camera); } #[allow(unused_variables)] fn li(&self, scene: &Scene, ray: &RayDifferential, sample: &Sampler) -> Box<Spectrum> { unimplemented!() } #[allow(unused_variables)] fn transmittance(&self, scene: &Scene, ray: &RayDifferential, sample: &Sampler) -> Box<Spectrum> { unimplemented!() } }
SamplerRenderer
identifier_name
rmeta.rs
// Copyright 2016 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.
// aux-build:rmeta_rlib.rs extern crate rmeta_aux; use rmeta_aux::Foo; pub fn main() { let _ = Foo { field: 42 }; }
// Test that using rlibs and rmeta dep crates work together. Specifically, that // there can be both an rmeta and an rlib file and rustc will prefer the rlib. // aux-build:rmeta_rmeta.rs
random_line_split
rmeta.rs
// Copyright 2016 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 that using rlibs and rmeta dep crates work together. Specifically, that // there can be both an rmeta and an rlib file and rustc will prefer the rlib. // aux-build:rmeta_rmeta.rs // aux-build:rmeta_rlib.rs extern crate rmeta_aux; use rmeta_aux::Foo; pub fn main()
{ let _ = Foo { field: 42 }; }
identifier_body
rmeta.rs
// Copyright 2016 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 that using rlibs and rmeta dep crates work together. Specifically, that // there can be both an rmeta and an rlib file and rustc will prefer the rlib. // aux-build:rmeta_rmeta.rs // aux-build:rmeta_rlib.rs extern crate rmeta_aux; use rmeta_aux::Foo; pub fn
() { let _ = Foo { field: 42 }; }
main
identifier_name
metadata.rs
use ape; use id3; use lewton::inside_ogg::OggStreamReader; use metaflac; use mp3_duration; use regex::Regex; use std::fs; use std::path::Path; use errors::*; use utils; use utils::AudioFormat; #[derive(Debug, Clone, PartialEq)] pub struct SongTags { pub disc_number: Option<u32>, pub track_number: Option<u32>, pub title: Option<String>, pub duration: Option<u32>, pub artist: Option<String>, pub album_artist: Option<String>, pub album: Option<String>, pub year: Option<i32>, } pub fn read(path: &Path) -> Result<SongTags> { match utils::get_audio_format(path) { Some(AudioFormat::FLAC) => read_flac(path), Some(AudioFormat::MP3) => read_id3(path), Some(AudioFormat::MPC) => read_ape(path), Some(AudioFormat::OGG) => read_vorbis(path), _ => bail!("Unsupported file format for reading metadata"), } } fn read_id3(path: &Path) -> Result<SongTags> { let tag = id3::Tag::read_from_path(&path)?; let duration = mp3_duration::from_path(&path).map(|d| d.as_secs() as u32).ok(); let artist = tag.artist().map(|s| s.to_string()); let album_artist = tag.album_artist().map(|s| s.to_string()); let album = tag.album().map(|s| s.to_string()); let title = tag.title().map(|s| s.to_string()); let disc_number = tag.disc(); let track_number = tag.track(); let year = tag.year() .map(|y| y as i32) .or(tag.date_released().and_then(|d| Some(d.year))) .or(tag.date_recorded().and_then(|d| Some(d.year))); Ok(SongTags { artist: artist, album_artist: album_artist, album: album, title: title, duration: duration, disc_number: disc_number, track_number: track_number, year: year, }) } fn read_ape_string(item: &ape::Item) -> Option<String> { match item.value { ape::ItemValue::Text(ref s) => Some(s.clone()), _ => None, } } fn read_ape_i32(item: &ape::Item) -> Option<i32> { match item.value { ape::ItemValue::Text(ref s) => s.parse::<i32>().ok(), _ => None, } } fn read_ape_x_of_y(item: &ape::Item) -> Option<u32> { match item.value { ape::ItemValue::Text(ref s) => { let format = Regex::new(r#"^\d+"#).unwrap(); if let Some(m) = format.find(s) { s[m.start()..m.end()].parse().ok() } else { None } } _ => None, } } fn read_ape(path: &Path) -> Result<SongTags> { let tag = ape::read(path)?; let artist = tag.item("Artist").and_then(read_ape_string); let album = tag.item("Album").and_then(read_ape_string); let album_artist = tag.item("Album artist").and_then(read_ape_string); let title = tag.item("Title").and_then(read_ape_string); let year = tag.item("Year").and_then(read_ape_i32); let disc_number = tag.item("Disc").and_then(read_ape_x_of_y); let track_number = tag.item("Track").and_then(read_ape_x_of_y); Ok(SongTags { artist: artist, album_artist: album_artist, album: album, title: title, duration: None, disc_number: disc_number, track_number: track_number, year: year, }) } fn read_vorbis(path: &Path) -> Result<SongTags> { let file = fs::File::open(path)?; let source = OggStreamReader::new(file)?; let mut tags = SongTags { artist: None, album_artist: None, album: None, title: None, duration:None, disc_number: None, track_number: None, year: None, }; for (key, value) in source.comment_hdr.comment_list { match key.as_str() { "TITLE" => tags.title = Some(value), "ALBUM" => tags.album = Some(value), "ARTIST" => tags.artist = Some(value), "ALBUMARTIST" => tags.album_artist = Some(value), "TRACKNUMBER" => tags.track_number = value.parse::<u32>().ok(), "DISCNUMBER" => tags.disc_number = value.parse::<u32>().ok(), "DATE" => tags.year = value.parse::<i32>().ok(), _ => (), } } Ok(tags) } fn read_flac(path: &Path) -> Result<SongTags> { let tag = metaflac::Tag::read_from_path(path)?; let vorbis = tag.vorbis_comments().ok_or("Missing Vorbis comments")?; let disc_number = vorbis .get("DISCNUMBER") .and_then(|d| d[0].parse::<u32>().ok()); let year = vorbis.get("DATE").and_then(|d| d[0].parse::<i32>().ok()); let streaminfo = tag.get_blocks(metaflac::BlockType::StreamInfo); let duration = match streaminfo.first() { Some(&&metaflac::Block::StreamInfo(ref s)) => Some((s.total_samples as u32 / s.sample_rate) as u32), _ => None }; Ok(SongTags { artist: vorbis.artist().map(|v| v[0].clone()), album_artist: vorbis.album_artist().map(|v| v[0].clone()), album: vorbis.album().map(|v| v[0].clone()), title: vorbis.title().map(|v| v[0].clone()), duration: duration, disc_number: disc_number, track_number: vorbis.track(), year: year, }) } #[test] fn test_read_metadata() { let sample_tags = SongTags { disc_number: Some(3), track_number: Some(1), title: Some("TEST TITLE".into()), artist: Some("TEST ARTIST".into()), album_artist: Some("TEST ALBUM ARTIST".into()), album: Some("TEST ALBUM".into()), duration: None,
let mp3_sample_tag = SongTags {duration: Some(0),..sample_tags.clone()}; assert_eq!(read(Path::new("test/sample.mp3")).unwrap(), mp3_sample_tag); assert_eq!(read(Path::new("test/sample.ogg")).unwrap(), sample_tags); assert_eq!(read(Path::new("test/sample.flac")).unwrap(), flac_sample_tag); }
year: Some(2016), }; let flac_sample_tag = SongTags {duration: Some(0), ..sample_tags.clone()};
random_line_split
metadata.rs
use ape; use id3; use lewton::inside_ogg::OggStreamReader; use metaflac; use mp3_duration; use regex::Regex; use std::fs; use std::path::Path; use errors::*; use utils; use utils::AudioFormat; #[derive(Debug, Clone, PartialEq)] pub struct SongTags { pub disc_number: Option<u32>, pub track_number: Option<u32>, pub title: Option<String>, pub duration: Option<u32>, pub artist: Option<String>, pub album_artist: Option<String>, pub album: Option<String>, pub year: Option<i32>, } pub fn read(path: &Path) -> Result<SongTags> { match utils::get_audio_format(path) { Some(AudioFormat::FLAC) => read_flac(path), Some(AudioFormat::MP3) => read_id3(path), Some(AudioFormat::MPC) => read_ape(path), Some(AudioFormat::OGG) => read_vorbis(path), _ => bail!("Unsupported file format for reading metadata"), } } fn read_id3(path: &Path) -> Result<SongTags> { let tag = id3::Tag::read_from_path(&path)?; let duration = mp3_duration::from_path(&path).map(|d| d.as_secs() as u32).ok(); let artist = tag.artist().map(|s| s.to_string()); let album_artist = tag.album_artist().map(|s| s.to_string()); let album = tag.album().map(|s| s.to_string()); let title = tag.title().map(|s| s.to_string()); let disc_number = tag.disc(); let track_number = tag.track(); let year = tag.year() .map(|y| y as i32) .or(tag.date_released().and_then(|d| Some(d.year))) .or(tag.date_recorded().and_then(|d| Some(d.year))); Ok(SongTags { artist: artist, album_artist: album_artist, album: album, title: title, duration: duration, disc_number: disc_number, track_number: track_number, year: year, }) } fn read_ape_string(item: &ape::Item) -> Option<String> { match item.value { ape::ItemValue::Text(ref s) => Some(s.clone()), _ => None, } } fn read_ape_i32(item: &ape::Item) -> Option<i32> { match item.value { ape::ItemValue::Text(ref s) => s.parse::<i32>().ok(), _ => None, } } fn read_ape_x_of_y(item: &ape::Item) -> Option<u32> { match item.value { ape::ItemValue::Text(ref s) => { let format = Regex::new(r#"^\d+"#).unwrap(); if let Some(m) = format.find(s) { s[m.start()..m.end()].parse().ok() } else { None } } _ => None, } } fn read_ape(path: &Path) -> Result<SongTags> { let tag = ape::read(path)?; let artist = tag.item("Artist").and_then(read_ape_string); let album = tag.item("Album").and_then(read_ape_string); let album_artist = tag.item("Album artist").and_then(read_ape_string); let title = tag.item("Title").and_then(read_ape_string); let year = tag.item("Year").and_then(read_ape_i32); let disc_number = tag.item("Disc").and_then(read_ape_x_of_y); let track_number = tag.item("Track").and_then(read_ape_x_of_y); Ok(SongTags { artist: artist, album_artist: album_artist, album: album, title: title, duration: None, disc_number: disc_number, track_number: track_number, year: year, }) } fn read_vorbis(path: &Path) -> Result<SongTags> { let file = fs::File::open(path)?; let source = OggStreamReader::new(file)?; let mut tags = SongTags { artist: None, album_artist: None, album: None, title: None, duration:None, disc_number: None, track_number: None, year: None, }; for (key, value) in source.comment_hdr.comment_list { match key.as_str() { "TITLE" => tags.title = Some(value), "ALBUM" => tags.album = Some(value), "ARTIST" => tags.artist = Some(value), "ALBUMARTIST" => tags.album_artist = Some(value), "TRACKNUMBER" => tags.track_number = value.parse::<u32>().ok(), "DISCNUMBER" => tags.disc_number = value.parse::<u32>().ok(), "DATE" => tags.year = value.parse::<i32>().ok(), _ => (), } } Ok(tags) } fn
(path: &Path) -> Result<SongTags> { let tag = metaflac::Tag::read_from_path(path)?; let vorbis = tag.vorbis_comments().ok_or("Missing Vorbis comments")?; let disc_number = vorbis .get("DISCNUMBER") .and_then(|d| d[0].parse::<u32>().ok()); let year = vorbis.get("DATE").and_then(|d| d[0].parse::<i32>().ok()); let streaminfo = tag.get_blocks(metaflac::BlockType::StreamInfo); let duration = match streaminfo.first() { Some(&&metaflac::Block::StreamInfo(ref s)) => Some((s.total_samples as u32 / s.sample_rate) as u32), _ => None }; Ok(SongTags { artist: vorbis.artist().map(|v| v[0].clone()), album_artist: vorbis.album_artist().map(|v| v[0].clone()), album: vorbis.album().map(|v| v[0].clone()), title: vorbis.title().map(|v| v[0].clone()), duration: duration, disc_number: disc_number, track_number: vorbis.track(), year: year, }) } #[test] fn test_read_metadata() { let sample_tags = SongTags { disc_number: Some(3), track_number: Some(1), title: Some("TEST TITLE".into()), artist: Some("TEST ARTIST".into()), album_artist: Some("TEST ALBUM ARTIST".into()), album: Some("TEST ALBUM".into()), duration: None, year: Some(2016), }; let flac_sample_tag = SongTags {duration: Some(0),..sample_tags.clone()}; let mp3_sample_tag = SongTags {duration: Some(0),..sample_tags.clone()}; assert_eq!(read(Path::new("test/sample.mp3")).unwrap(), mp3_sample_tag); assert_eq!(read(Path::new("test/sample.ogg")).unwrap(), sample_tags); assert_eq!(read(Path::new("test/sample.flac")).unwrap(), flac_sample_tag); }
read_flac
identifier_name
metadata.rs
use ape; use id3; use lewton::inside_ogg::OggStreamReader; use metaflac; use mp3_duration; use regex::Regex; use std::fs; use std::path::Path; use errors::*; use utils; use utils::AudioFormat; #[derive(Debug, Clone, PartialEq)] pub struct SongTags { pub disc_number: Option<u32>, pub track_number: Option<u32>, pub title: Option<String>, pub duration: Option<u32>, pub artist: Option<String>, pub album_artist: Option<String>, pub album: Option<String>, pub year: Option<i32>, } pub fn read(path: &Path) -> Result<SongTags> { match utils::get_audio_format(path) { Some(AudioFormat::FLAC) => read_flac(path), Some(AudioFormat::MP3) => read_id3(path), Some(AudioFormat::MPC) => read_ape(path), Some(AudioFormat::OGG) => read_vorbis(path), _ => bail!("Unsupported file format for reading metadata"), } } fn read_id3(path: &Path) -> Result<SongTags> { let tag = id3::Tag::read_from_path(&path)?; let duration = mp3_duration::from_path(&path).map(|d| d.as_secs() as u32).ok(); let artist = tag.artist().map(|s| s.to_string()); let album_artist = tag.album_artist().map(|s| s.to_string()); let album = tag.album().map(|s| s.to_string()); let title = tag.title().map(|s| s.to_string()); let disc_number = tag.disc(); let track_number = tag.track(); let year = tag.year() .map(|y| y as i32) .or(tag.date_released().and_then(|d| Some(d.year))) .or(tag.date_recorded().and_then(|d| Some(d.year))); Ok(SongTags { artist: artist, album_artist: album_artist, album: album, title: title, duration: duration, disc_number: disc_number, track_number: track_number, year: year, }) } fn read_ape_string(item: &ape::Item) -> Option<String> { match item.value { ape::ItemValue::Text(ref s) => Some(s.clone()), _ => None, } } fn read_ape_i32(item: &ape::Item) -> Option<i32> { match item.value { ape::ItemValue::Text(ref s) => s.parse::<i32>().ok(), _ => None, } } fn read_ape_x_of_y(item: &ape::Item) -> Option<u32>
fn read_ape(path: &Path) -> Result<SongTags> { let tag = ape::read(path)?; let artist = tag.item("Artist").and_then(read_ape_string); let album = tag.item("Album").and_then(read_ape_string); let album_artist = tag.item("Album artist").and_then(read_ape_string); let title = tag.item("Title").and_then(read_ape_string); let year = tag.item("Year").and_then(read_ape_i32); let disc_number = tag.item("Disc").and_then(read_ape_x_of_y); let track_number = tag.item("Track").and_then(read_ape_x_of_y); Ok(SongTags { artist: artist, album_artist: album_artist, album: album, title: title, duration: None, disc_number: disc_number, track_number: track_number, year: year, }) } fn read_vorbis(path: &Path) -> Result<SongTags> { let file = fs::File::open(path)?; let source = OggStreamReader::new(file)?; let mut tags = SongTags { artist: None, album_artist: None, album: None, title: None, duration:None, disc_number: None, track_number: None, year: None, }; for (key, value) in source.comment_hdr.comment_list { match key.as_str() { "TITLE" => tags.title = Some(value), "ALBUM" => tags.album = Some(value), "ARTIST" => tags.artist = Some(value), "ALBUMARTIST" => tags.album_artist = Some(value), "TRACKNUMBER" => tags.track_number = value.parse::<u32>().ok(), "DISCNUMBER" => tags.disc_number = value.parse::<u32>().ok(), "DATE" => tags.year = value.parse::<i32>().ok(), _ => (), } } Ok(tags) } fn read_flac(path: &Path) -> Result<SongTags> { let tag = metaflac::Tag::read_from_path(path)?; let vorbis = tag.vorbis_comments().ok_or("Missing Vorbis comments")?; let disc_number = vorbis .get("DISCNUMBER") .and_then(|d| d[0].parse::<u32>().ok()); let year = vorbis.get("DATE").and_then(|d| d[0].parse::<i32>().ok()); let streaminfo = tag.get_blocks(metaflac::BlockType::StreamInfo); let duration = match streaminfo.first() { Some(&&metaflac::Block::StreamInfo(ref s)) => Some((s.total_samples as u32 / s.sample_rate) as u32), _ => None }; Ok(SongTags { artist: vorbis.artist().map(|v| v[0].clone()), album_artist: vorbis.album_artist().map(|v| v[0].clone()), album: vorbis.album().map(|v| v[0].clone()), title: vorbis.title().map(|v| v[0].clone()), duration: duration, disc_number: disc_number, track_number: vorbis.track(), year: year, }) } #[test] fn test_read_metadata() { let sample_tags = SongTags { disc_number: Some(3), track_number: Some(1), title: Some("TEST TITLE".into()), artist: Some("TEST ARTIST".into()), album_artist: Some("TEST ALBUM ARTIST".into()), album: Some("TEST ALBUM".into()), duration: None, year: Some(2016), }; let flac_sample_tag = SongTags {duration: Some(0),..sample_tags.clone()}; let mp3_sample_tag = SongTags {duration: Some(0),..sample_tags.clone()}; assert_eq!(read(Path::new("test/sample.mp3")).unwrap(), mp3_sample_tag); assert_eq!(read(Path::new("test/sample.ogg")).unwrap(), sample_tags); assert_eq!(read(Path::new("test/sample.flac")).unwrap(), flac_sample_tag); }
{ match item.value { ape::ItemValue::Text(ref s) => { let format = Regex::new(r#"^\d+"#).unwrap(); if let Some(m) = format.find(s) { s[m.start()..m.end()].parse().ok() } else { None } } _ => None, } }
identifier_body
app.rs
use clap::{App, Arg}; const DEFAULT_RETRY_INTERVAL: &str = "1000"; const DEFAULT_UPDATE_INTERVAL: &str = "1000"; const DEFAULT_CALCULATION_THREADS: &str = "1"; const DEFAULT_CALCULATION_LIMIT: &str = "1000"; const DEFAULT_GENERATION_LIMIT: &str = "10"; const DEFAULT_MILESTONE_ADDRESS: &str = "KPWCHICGJZXKE9GSUDXZYUAPLHAKAHYHDXNPHENTE\ RYMMBQOPSQIDENXKLKCEYCPVTZQLEEJVYJZV9BWU"; const DEFAULT_MILESTONE_START_INDEX: &str = "62000"; const DEFAULT_LOG_CONFIG: &str = "log4rs.yaml"; pub fn build<'a, 'b>() -> App<'a, 'b>
.arg( Arg::with_name("retry_interval") .short("r") .long("retry-interval") .takes_value(true) .value_name("INTERVAL") .default_value(DEFAULT_RETRY_INTERVAL) .help("MySQL connect retry interval in milliseconds"), ) .arg( Arg::with_name("update_interval") .short("u") .long("update-interval") .takes_value(true) .value_name("INTERVAL") .default_value(DEFAULT_UPDATE_INTERVAL) .help("MySQL update interval in milliseconds"), ) .arg( Arg::with_name("calculation_threads") .short("T") .long("calculation-threads") .takes_value(true) .value_name("THREADS") .default_value(DEFAULT_CALCULATION_THREADS) .help("Number of calculation threads"), ) .arg( Arg::with_name("calculation_limit") .short("t") .long("calculation-limit") .takes_value(true) .value_name("LIMIT") .default_value(DEFAULT_CALCULATION_LIMIT) .help("Calculation depth limit"), ) .arg( Arg::with_name("generation_limit") .short("g") .long("generation-limit") .takes_value(true) .value_name("LIMIT") .default_value(DEFAULT_GENERATION_LIMIT) .help("Garbage collector generation limit"), ) .arg( Arg::with_name("milestone_address") .short("M") .long("milestone-address") .takes_value(true) .value_name("ADDRESS") .default_value(DEFAULT_MILESTONE_ADDRESS) .help("Milestone address"), ) .arg( Arg::with_name("milestone_start_index") .short("I") .long("milestone-start-index") .takes_value(true) .value_name("INDEX") .default_value(DEFAULT_MILESTONE_START_INDEX) .help("Milestone start index"), ) .arg( Arg::with_name("log_config") .short("C") .long("log-config") .takes_value(true) .value_name("FILE") .default_value(DEFAULT_LOG_CONFIG) .help("Path to log4rs configuration file"), ) }
{ app_from_crate!() .arg( Arg::with_name("zmq_uri") .short("z") .long("zmq") .takes_value(true) .value_name("URI") .required(true) .help("ZMQ source server URI"), ) .arg( Arg::with_name("mysql_uri") .short("m") .long("mysql") .takes_value(true) .value_name("URI") .required(true) .help("MySQL destination server URI"), )
identifier_body
app.rs
use clap::{App, Arg}; const DEFAULT_RETRY_INTERVAL: &str = "1000"; const DEFAULT_UPDATE_INTERVAL: &str = "1000"; const DEFAULT_CALCULATION_THREADS: &str = "1"; const DEFAULT_CALCULATION_LIMIT: &str = "1000"; const DEFAULT_GENERATION_LIMIT: &str = "10"; const DEFAULT_MILESTONE_ADDRESS: &str = "KPWCHICGJZXKE9GSUDXZYUAPLHAKAHYHDXNPHENTE\ RYMMBQOPSQIDENXKLKCEYCPVTZQLEEJVYJZV9BWU"; const DEFAULT_MILESTONE_START_INDEX: &str = "62000"; const DEFAULT_LOG_CONFIG: &str = "log4rs.yaml"; pub fn
<'a, 'b>() -> App<'a, 'b> { app_from_crate!() .arg( Arg::with_name("zmq_uri") .short("z") .long("zmq") .takes_value(true) .value_name("URI") .required(true) .help("ZMQ source server URI"), ) .arg( Arg::with_name("mysql_uri") .short("m") .long("mysql") .takes_value(true) .value_name("URI") .required(true) .help("MySQL destination server URI"), ) .arg( Arg::with_name("retry_interval") .short("r") .long("retry-interval") .takes_value(true) .value_name("INTERVAL") .default_value(DEFAULT_RETRY_INTERVAL) .help("MySQL connect retry interval in milliseconds"), ) .arg( Arg::with_name("update_interval") .short("u") .long("update-interval") .takes_value(true) .value_name("INTERVAL") .default_value(DEFAULT_UPDATE_INTERVAL) .help("MySQL update interval in milliseconds"), ) .arg( Arg::with_name("calculation_threads") .short("T") .long("calculation-threads") .takes_value(true) .value_name("THREADS") .default_value(DEFAULT_CALCULATION_THREADS) .help("Number of calculation threads"), ) .arg( Arg::with_name("calculation_limit") .short("t") .long("calculation-limit") .takes_value(true) .value_name("LIMIT") .default_value(DEFAULT_CALCULATION_LIMIT) .help("Calculation depth limit"), ) .arg( Arg::with_name("generation_limit") .short("g") .long("generation-limit") .takes_value(true) .value_name("LIMIT") .default_value(DEFAULT_GENERATION_LIMIT) .help("Garbage collector generation limit"), ) .arg( Arg::with_name("milestone_address") .short("M") .long("milestone-address") .takes_value(true) .value_name("ADDRESS") .default_value(DEFAULT_MILESTONE_ADDRESS) .help("Milestone address"), ) .arg( Arg::with_name("milestone_start_index") .short("I") .long("milestone-start-index") .takes_value(true) .value_name("INDEX") .default_value(DEFAULT_MILESTONE_START_INDEX) .help("Milestone start index"), ) .arg( Arg::with_name("log_config") .short("C") .long("log-config") .takes_value(true) .value_name("FILE") .default_value(DEFAULT_LOG_CONFIG) .help("Path to log4rs configuration file"), ) }
build
identifier_name
app.rs
use clap::{App, Arg}; const DEFAULT_RETRY_INTERVAL: &str = "1000"; const DEFAULT_UPDATE_INTERVAL: &str = "1000"; const DEFAULT_CALCULATION_THREADS: &str = "1"; const DEFAULT_CALCULATION_LIMIT: &str = "1000"; const DEFAULT_GENERATION_LIMIT: &str = "10"; const DEFAULT_MILESTONE_ADDRESS: &str = "KPWCHICGJZXKE9GSUDXZYUAPLHAKAHYHDXNPHENTE\ RYMMBQOPSQIDENXKLKCEYCPVTZQLEEJVYJZV9BWU"; const DEFAULT_MILESTONE_START_INDEX: &str = "62000"; const DEFAULT_LOG_CONFIG: &str = "log4rs.yaml"; pub fn build<'a, 'b>() -> App<'a, 'b> { app_from_crate!() .arg( Arg::with_name("zmq_uri") .short("z") .long("zmq") .takes_value(true)
.help("ZMQ source server URI"), ) .arg( Arg::with_name("mysql_uri") .short("m") .long("mysql") .takes_value(true) .value_name("URI") .required(true) .help("MySQL destination server URI"), ) .arg( Arg::with_name("retry_interval") .short("r") .long("retry-interval") .takes_value(true) .value_name("INTERVAL") .default_value(DEFAULT_RETRY_INTERVAL) .help("MySQL connect retry interval in milliseconds"), ) .arg( Arg::with_name("update_interval") .short("u") .long("update-interval") .takes_value(true) .value_name("INTERVAL") .default_value(DEFAULT_UPDATE_INTERVAL) .help("MySQL update interval in milliseconds"), ) .arg( Arg::with_name("calculation_threads") .short("T") .long("calculation-threads") .takes_value(true) .value_name("THREADS") .default_value(DEFAULT_CALCULATION_THREADS) .help("Number of calculation threads"), ) .arg( Arg::with_name("calculation_limit") .short("t") .long("calculation-limit") .takes_value(true) .value_name("LIMIT") .default_value(DEFAULT_CALCULATION_LIMIT) .help("Calculation depth limit"), ) .arg( Arg::with_name("generation_limit") .short("g") .long("generation-limit") .takes_value(true) .value_name("LIMIT") .default_value(DEFAULT_GENERATION_LIMIT) .help("Garbage collector generation limit"), ) .arg( Arg::with_name("milestone_address") .short("M") .long("milestone-address") .takes_value(true) .value_name("ADDRESS") .default_value(DEFAULT_MILESTONE_ADDRESS) .help("Milestone address"), ) .arg( Arg::with_name("milestone_start_index") .short("I") .long("milestone-start-index") .takes_value(true) .value_name("INDEX") .default_value(DEFAULT_MILESTONE_START_INDEX) .help("Milestone start index"), ) .arg( Arg::with_name("log_config") .short("C") .long("log-config") .takes_value(true) .value_name("FILE") .default_value(DEFAULT_LOG_CONFIG) .help("Path to log4rs configuration file"), ) }
.value_name("URI") .required(true)
random_line_split
stdio.rs
// Copyright 2015 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. #[cfg(stage0)] use prelude::v1::*; use io; use libc; use sys::fd::FileDesc; pub struct Stdin(()); pub struct Stdout(()); pub struct Stderr(()); impl Stdin { pub fn new() -> io::Result<Stdin> { Ok(Stdin(())) } pub fn read(&self, data: &mut [u8]) -> io::Result<usize> { let fd = FileDesc::new(libc::STDIN_FILENO); let ret = fd.read(data); fd.into_raw(); return ret; } } impl Stdout { pub fn new() -> io::Result<Stdout>
pub fn write(&self, data: &[u8]) -> io::Result<usize> { let fd = FileDesc::new(libc::STDOUT_FILENO); let ret = fd.write(data); fd.into_raw(); return ret; } } impl Stderr { pub fn new() -> io::Result<Stderr> { Ok(Stderr(())) } pub fn write(&self, data: &[u8]) -> io::Result<usize> { let fd = FileDesc::new(libc::STDERR_FILENO); let ret = fd.write(data); fd.into_raw(); return ret; } } // FIXME: right now this raw stderr handle is used in a few places because // std::io::stderr_raw isn't exposed, but once that's exposed this impl // should go away impl io::Write for Stderr { fn write(&mut self, data: &[u8]) -> io::Result<usize> { Stderr::write(self, data) } fn flush(&mut self) -> io::Result<()> { Ok(()) } }
{ Ok(Stdout(())) }
identifier_body
stdio.rs
// Copyright 2015 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. #[cfg(stage0)] use prelude::v1::*; use io; use libc; use sys::fd::FileDesc; pub struct Stdin(()); pub struct Stdout(()); pub struct
(()); impl Stdin { pub fn new() -> io::Result<Stdin> { Ok(Stdin(())) } pub fn read(&self, data: &mut [u8]) -> io::Result<usize> { let fd = FileDesc::new(libc::STDIN_FILENO); let ret = fd.read(data); fd.into_raw(); return ret; } } impl Stdout { pub fn new() -> io::Result<Stdout> { Ok(Stdout(())) } pub fn write(&self, data: &[u8]) -> io::Result<usize> { let fd = FileDesc::new(libc::STDOUT_FILENO); let ret = fd.write(data); fd.into_raw(); return ret; } } impl Stderr { pub fn new() -> io::Result<Stderr> { Ok(Stderr(())) } pub fn write(&self, data: &[u8]) -> io::Result<usize> { let fd = FileDesc::new(libc::STDERR_FILENO); let ret = fd.write(data); fd.into_raw(); return ret; } } // FIXME: right now this raw stderr handle is used in a few places because // std::io::stderr_raw isn't exposed, but once that's exposed this impl // should go away impl io::Write for Stderr { fn write(&mut self, data: &[u8]) -> io::Result<usize> { Stderr::write(self, data) } fn flush(&mut self) -> io::Result<()> { Ok(()) } }
Stderr
identifier_name
stdio.rs
// Copyright 2015 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT.
// except according to those terms. #[cfg(stage0)] use prelude::v1::*; use io; use libc; use sys::fd::FileDesc; pub struct Stdin(()); pub struct Stdout(()); pub struct Stderr(()); impl Stdin { pub fn new() -> io::Result<Stdin> { Ok(Stdin(())) } pub fn read(&self, data: &mut [u8]) -> io::Result<usize> { let fd = FileDesc::new(libc::STDIN_FILENO); let ret = fd.read(data); fd.into_raw(); return ret; } } impl Stdout { pub fn new() -> io::Result<Stdout> { Ok(Stdout(())) } pub fn write(&self, data: &[u8]) -> io::Result<usize> { let fd = FileDesc::new(libc::STDOUT_FILENO); let ret = fd.write(data); fd.into_raw(); return ret; } } impl Stderr { pub fn new() -> io::Result<Stderr> { Ok(Stderr(())) } pub fn write(&self, data: &[u8]) -> io::Result<usize> { let fd = FileDesc::new(libc::STDERR_FILENO); let ret = fd.write(data); fd.into_raw(); return ret; } } // FIXME: right now this raw stderr handle is used in a few places because // std::io::stderr_raw isn't exposed, but once that's exposed this impl // should go away impl io::Write for Stderr { fn write(&mut self, data: &[u8]) -> io::Result<usize> { Stderr::write(self, data) } fn flush(&mut self) -> io::Result<()> { Ok(()) } }
// // 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
random_line_split
cttz32.rs
#![feature(core, core_intrinsics)] extern crate core; #[cfg(test)] mod tests { use core::intrinsics::cttz32; // pub fn cttz32(x: u32) -> u32; macro_rules! cttz32_test { ($value:expr, $BITS:expr) => ({ let x: u32 = $value; let result: u32 = unsafe { cttz32(x) }; assert_eq!(result, $BITS); }) } #[test] fn cttz32_test1()
cttz32_test!(0x00080000, 19); cttz32_test!(0x00100000, 20); cttz32_test!(0x00200000, 21); cttz32_test!(0x00400000, 22); cttz32_test!(0x00800000, 23); cttz32_test!(0x01000000, 24); cttz32_test!(0x02000000, 25); cttz32_test!(0x04000000, 26); cttz32_test!(0x08000000, 27); cttz32_test!(0x10000000, 28); cttz32_test!(0x20000000, 29); cttz32_test!(0x40000000, 30); cttz32_test!(0x80000000, 31); } }
{ cttz32_test!(0x00000001, 0); cttz32_test!(0x00000002, 1); cttz32_test!(0x00000004, 2); cttz32_test!(0x00000008, 3); cttz32_test!(0x00000010, 4); cttz32_test!(0x00000020, 5); cttz32_test!(0x00000040, 6); cttz32_test!(0x00000080, 7); cttz32_test!(0x00000100, 8); cttz32_test!(0x00000200, 9); cttz32_test!(0x00000400, 10); cttz32_test!(0x00000800, 11); cttz32_test!(0x00001000, 12); cttz32_test!(0x00002000, 13); cttz32_test!(0x00004000, 14); cttz32_test!(0x00008000, 15); cttz32_test!(0x00010000, 16); cttz32_test!(0x00020000, 17); cttz32_test!(0x00040000, 18);
identifier_body
cttz32.rs
#![feature(core, core_intrinsics)] extern crate core; #[cfg(test)] mod tests { use core::intrinsics::cttz32; // pub fn cttz32(x: u32) -> u32; macro_rules! cttz32_test { ($value:expr, $BITS:expr) => ({ let x: u32 = $value; let result: u32 = unsafe { cttz32(x) }; assert_eq!(result, $BITS); }) } #[test] fn
() { cttz32_test!(0x00000001, 0); cttz32_test!(0x00000002, 1); cttz32_test!(0x00000004, 2); cttz32_test!(0x00000008, 3); cttz32_test!(0x00000010, 4); cttz32_test!(0x00000020, 5); cttz32_test!(0x00000040, 6); cttz32_test!(0x00000080, 7); cttz32_test!(0x00000100, 8); cttz32_test!(0x00000200, 9); cttz32_test!(0x00000400, 10); cttz32_test!(0x00000800, 11); cttz32_test!(0x00001000, 12); cttz32_test!(0x00002000, 13); cttz32_test!(0x00004000, 14); cttz32_test!(0x00008000, 15); cttz32_test!(0x00010000, 16); cttz32_test!(0x00020000, 17); cttz32_test!(0x00040000, 18); cttz32_test!(0x00080000, 19); cttz32_test!(0x00100000, 20); cttz32_test!(0x00200000, 21); cttz32_test!(0x00400000, 22); cttz32_test!(0x00800000, 23); cttz32_test!(0x01000000, 24); cttz32_test!(0x02000000, 25); cttz32_test!(0x04000000, 26); cttz32_test!(0x08000000, 27); cttz32_test!(0x10000000, 28); cttz32_test!(0x20000000, 29); cttz32_test!(0x40000000, 30); cttz32_test!(0x80000000, 31); } }
cttz32_test1
identifier_name
cttz32.rs
#![feature(core, core_intrinsics)] extern crate core; #[cfg(test)] mod tests { use core::intrinsics::cttz32; // pub fn cttz32(x: u32) -> u32; macro_rules! cttz32_test { ($value:expr, $BITS:expr) => ({ let x: u32 = $value; let result: u32 = unsafe { cttz32(x) }; assert_eq!(result, $BITS); }) } #[test] fn cttz32_test1() { cttz32_test!(0x00000001, 0); cttz32_test!(0x00000002, 1); cttz32_test!(0x00000004, 2); cttz32_test!(0x00000008, 3);
cttz32_test!(0x00000080, 7); cttz32_test!(0x00000100, 8); cttz32_test!(0x00000200, 9); cttz32_test!(0x00000400, 10); cttz32_test!(0x00000800, 11); cttz32_test!(0x00001000, 12); cttz32_test!(0x00002000, 13); cttz32_test!(0x00004000, 14); cttz32_test!(0x00008000, 15); cttz32_test!(0x00010000, 16); cttz32_test!(0x00020000, 17); cttz32_test!(0x00040000, 18); cttz32_test!(0x00080000, 19); cttz32_test!(0x00100000, 20); cttz32_test!(0x00200000, 21); cttz32_test!(0x00400000, 22); cttz32_test!(0x00800000, 23); cttz32_test!(0x01000000, 24); cttz32_test!(0x02000000, 25); cttz32_test!(0x04000000, 26); cttz32_test!(0x08000000, 27); cttz32_test!(0x10000000, 28); cttz32_test!(0x20000000, 29); cttz32_test!(0x40000000, 30); cttz32_test!(0x80000000, 31); } }
cttz32_test!(0x00000010, 4); cttz32_test!(0x00000020, 5); cttz32_test!(0x00000040, 6);
random_line_split
raw.rs
extern crate libsqlite3_sys as ffi; extern crate libc; use std::ffi::{CString, CStr}; use std::io::{stderr, Write}; use std::{ptr, str}; use result::*; use result::Error::DatabaseError; #[allow(missing_debug_implementations, missing_copy_implementations)] pub struct RawConnection { pub internal_connection: *mut ffi::sqlite3, } impl RawConnection { pub fn establish(database_url: &str) -> ConnectionResult<Self> { let mut conn_pointer = ptr::null_mut(); let database_url = try!(CString::new(database_url)); let connection_status = unsafe { ffi::sqlite3_open(database_url.as_ptr(), &mut conn_pointer) }; match connection_status { ffi::SQLITE_OK => Ok(RawConnection { internal_connection: conn_pointer, }), err_code => { let message = super::error_message(err_code); Err(ConnectionError::BadConnection(message.into())) } } } pub fn exec(&self, query: &str) -> QueryResult<()> { let mut err_msg = ptr::null_mut(); let query = try!(CString::new(query)); let callback_fn = None; let callback_arg = ptr::null_mut(); unsafe { ffi::sqlite3_exec( self.internal_connection, query.as_ptr(), callback_fn, callback_arg, &mut err_msg, ); } if!err_msg.is_null() { let msg = convert_to_string_and_free(err_msg); let error_kind = DatabaseErrorKind::__Unknown; Err(DatabaseError(error_kind, Box::new(msg))) } else { Ok(()) } } pub fn rows_affected_by_last_query(&self) -> usize { unsafe { ffi::sqlite3_changes(self.internal_connection) as usize } } pub fn last_error_message(&self) -> String { let c_str = unsafe { CStr::from_ptr(ffi::sqlite3_errmsg(self.internal_connection)) }; c_str.to_string_lossy().into_owned() } pub fn last_error_code(&self) -> libc::c_int { unsafe { ffi::sqlite3_extended_errcode(self.internal_connection) } } } impl Drop for RawConnection { fn drop(&mut self) { use std::thread::panicking; let close_result = unsafe { ffi::sqlite3_close(self.internal_connection) }; if close_result!= ffi::SQLITE_OK { let error_message = super::error_message(close_result); if panicking() { write!(stderr(), "Error closing SQLite connection: {}", error_message).unwrap(); } else { panic!("Error closing SQLite connection: {}", error_message); } } } } fn
(err_msg: *const libc::c_char) -> String { let msg = unsafe { let bytes = CStr::from_ptr(err_msg).to_bytes(); str::from_utf8_unchecked(bytes).into() }; unsafe { ffi::sqlite3_free(err_msg as *mut libc::c_void) }; msg }
convert_to_string_and_free
identifier_name
raw.rs
extern crate libsqlite3_sys as ffi; extern crate libc; use std::ffi::{CString, CStr}; use std::io::{stderr, Write}; use std::{ptr, str}; use result::*; use result::Error::DatabaseError; #[allow(missing_debug_implementations, missing_copy_implementations)] pub struct RawConnection { pub internal_connection: *mut ffi::sqlite3, } impl RawConnection { pub fn establish(database_url: &str) -> ConnectionResult<Self> { let mut conn_pointer = ptr::null_mut(); let database_url = try!(CString::new(database_url)); let connection_status = unsafe { ffi::sqlite3_open(database_url.as_ptr(), &mut conn_pointer) }; match connection_status { ffi::SQLITE_OK => Ok(RawConnection { internal_connection: conn_pointer, }), err_code => { let message = super::error_message(err_code); Err(ConnectionError::BadConnection(message.into())) } } } pub fn exec(&self, query: &str) -> QueryResult<()> { let mut err_msg = ptr::null_mut(); let query = try!(CString::new(query)); let callback_fn = None; let callback_arg = ptr::null_mut(); unsafe { ffi::sqlite3_exec( self.internal_connection, query.as_ptr(), callback_fn, callback_arg, &mut err_msg, ); } if!err_msg.is_null()
else { Ok(()) } } pub fn rows_affected_by_last_query(&self) -> usize { unsafe { ffi::sqlite3_changes(self.internal_connection) as usize } } pub fn last_error_message(&self) -> String { let c_str = unsafe { CStr::from_ptr(ffi::sqlite3_errmsg(self.internal_connection)) }; c_str.to_string_lossy().into_owned() } pub fn last_error_code(&self) -> libc::c_int { unsafe { ffi::sqlite3_extended_errcode(self.internal_connection) } } } impl Drop for RawConnection { fn drop(&mut self) { use std::thread::panicking; let close_result = unsafe { ffi::sqlite3_close(self.internal_connection) }; if close_result!= ffi::SQLITE_OK { let error_message = super::error_message(close_result); if panicking() { write!(stderr(), "Error closing SQLite connection: {}", error_message).unwrap(); } else { panic!("Error closing SQLite connection: {}", error_message); } } } } fn convert_to_string_and_free(err_msg: *const libc::c_char) -> String { let msg = unsafe { let bytes = CStr::from_ptr(err_msg).to_bytes(); str::from_utf8_unchecked(bytes).into() }; unsafe { ffi::sqlite3_free(err_msg as *mut libc::c_void) }; msg }
{ let msg = convert_to_string_and_free(err_msg); let error_kind = DatabaseErrorKind::__Unknown; Err(DatabaseError(error_kind, Box::new(msg))) }
conditional_block