From c96db57f5a7f2ffb1433d71a694d23fda66364b0 Mon Sep 17 00:00:00 2001 From: edunham Date: Tue, 19 Apr 2016 10:27:14 -0700 Subject: [PATCH 1/2] add tidy for https://github.com/servo/servo/issues/10636 --- .travis.yml | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/.travis.yml b/.travis.yml index 7d735663e..f9e16379b 100644 --- a/.travis.yml +++ b/.travis.yml @@ -7,5 +7,12 @@ os: - linux - osx +before_script: + - export PATH=$HOME/.local/bin:/Users/travis/Library/Python/2.7/bin:$PATH + - pip install servo_tidy --user `whoami` + +script: + - servo-tidy + notifications: webhooks: http://build.servo.org:54856/travis From 6cb646f7e3d72d71cdceb6d04fbc14b3061ddb39 Mon Sep 17 00:00:00 2001 From: edunham Date: Tue, 19 Apr 2016 12:50:14 -0700 Subject: [PATCH 2/2] Pass tidy checks, except license waiting on https://github.com/servo/servo/pull/10715 and/or resolution to https://github.com/servo/servo/issues/10716 --- ipc.rs | 258 +- lib.rs | 4 +- platform/inprocess/mod.rs | 124 +- platform/linux/mod.rs | 232 +- platform/macos/mach_sys.rs | 6300 ++++++++++++++++++++++++------------ platform/macos/mod.rs | 209 +- platform/mod.rs | 61 +- platform/test.rs | 163 +- router.rs | 34 +- test.rs | 79 +- 10 files changed, 4750 insertions(+), 2714 deletions(-) diff --git a/ipc.rs b/ipc.rs index 4201b0619..32ee60aeb 100644 --- a/ipc.rs +++ b/ipc.rs @@ -7,11 +7,10 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use platform::{self, OsIpcChannel, OsIpcReceiver, OsIpcReceiverSet, OsIpcSender}; -use platform::{OsIpcOneShotServer, OsIpcSelectionResult, OsIpcSharedMemory, OsOpaqueIpcChannel}; - -use bincode::{self, SizeLimit}; use bincode::serde::DeserializeError; +use bincode::{self, SizeLimit}; +use platform::{OsIpcOneShotServer, OsIpcSelectionResult, OsIpcSharedMemory, OsOpaqueIpcChannel}; +use platform::{self, OsIpcChannel, OsIpcReceiver, OsIpcReceiverSet, OsIpcSender}; use serde::{Deserialize, Deserializer, Serialize, Serializer}; use std::cell::{RefCell, BorrowState}; use std::cmp::min; @@ -37,8 +36,9 @@ thread_local! { RefCell::new(Vec::new()) } -pub fn channel() -> Result<(IpcSender, IpcReceiver),Error> - where T: Deserialize + Serialize { +pub fn channel() -> Result<(IpcSender, IpcReceiver), Error> + where T: Deserialize + Serialize +{ let (os_sender, os_receiver) = try!(platform::channel()); let ipc_receiver = IpcReceiver { os_receiver: os_receiver, @@ -51,44 +51,46 @@ pub fn channel() -> Result<(IpcSender, IpcReceiver),Error> Ok((ipc_sender, ipc_receiver)) } -pub fn bytes_channel() -> Result<(IpcBytesSender, IpcBytesReceiver),Error> { +pub fn bytes_channel() -> Result<(IpcBytesSender, IpcBytesReceiver), Error> { let (os_sender, os_receiver) = try!(platform::channel()); - let ipc_bytes_receiver = IpcBytesReceiver { - os_receiver: os_receiver, - }; - let ipc_bytes_sender = IpcBytesSender { - os_sender: os_sender, - }; + let ipc_bytes_receiver = IpcBytesReceiver { os_receiver: os_receiver }; + let ipc_bytes_sender = IpcBytesSender { os_sender: os_sender }; Ok((ipc_bytes_sender, ipc_bytes_receiver)) } #[derive(Debug)] -pub struct IpcReceiver where T: Deserialize + Serialize { +pub struct IpcReceiver + where T: Deserialize + Serialize +{ os_receiver: OsIpcReceiver, phantom: PhantomData, } -impl IpcReceiver where T: Deserialize + Serialize { - pub fn recv(&self) -> Result { +impl IpcReceiver + where T: Deserialize + Serialize +{ + pub fn recv(&self) -> Result { let (data, os_ipc_channels, os_ipc_shared_memory_regions) = try!(self.os_receiver.recv()); OpaqueIpcMessage::new(data, os_ipc_channels, os_ipc_shared_memory_regions).to() } - pub fn try_recv(&self) -> Result { - let (data, os_ipc_channels, os_ipc_shared_memory_regions) = - try!(self.os_receiver.try_recv()); + pub fn try_recv(&self) -> Result { + let (data, os_ipc_channels, os_ipc_shared_memory_regions) = try!(self.os_receiver + .try_recv()); OpaqueIpcMessage::new(data, os_ipc_channels, os_ipc_shared_memory_regions).to() } pub fn to_opaque(self) -> OpaqueIpcReceiver { - OpaqueIpcReceiver { - os_receiver: self.os_receiver, - } + OpaqueIpcReceiver { os_receiver: self.os_receiver } } } -impl Deserialize for IpcReceiver where T: Deserialize + Serialize { - fn deserialize(deserializer: &mut D) -> Result where D: Deserializer { +impl Deserialize for IpcReceiver + where T: Deserialize + Serialize +{ + fn deserialize(deserializer: &mut D) -> Result + where D: Deserializer + { let index: usize = try!(Deserialize::deserialize(deserializer)); let os_receiver = OS_IPC_CHANNELS_FOR_DESERIALIZATION.with(|os_ipc_channels_for_deserialization| { @@ -103,8 +105,12 @@ impl Deserialize for IpcReceiver where T: Deserialize + Serialize { } } -impl Serialize for IpcReceiver where T: Deserialize + Serialize { - fn serialize(&self, serializer: &mut S) -> Result<(),S::Error> where S: Serializer { +impl Serialize for IpcReceiver + where T: Deserialize + Serialize +{ + fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> + where S: Serializer + { let index = OS_IPC_CHANNELS_FOR_SERIALIZATION.with(|os_ipc_channels_for_serialization| { let mut os_ipc_channels_for_serialization = os_ipc_channels_for_serialization.borrow_mut(); @@ -118,12 +124,16 @@ impl Serialize for IpcReceiver where T: Deserialize + Serialize { } #[derive(Debug)] -pub struct IpcSender where T: Serialize { +pub struct IpcSender + where T: Serialize +{ os_sender: OsIpcSender, phantom: PhantomData, } -impl Clone for IpcSender where T: Serialize { +impl Clone for IpcSender + where T: Serialize +{ fn clone(&self) -> IpcSender { IpcSender { os_sender: self.os_sender.clone(), @@ -132,15 +142,17 @@ impl Clone for IpcSender where T: Serialize { } } -impl IpcSender where T: Serialize { - pub fn connect(name: String) -> Result,Error> { +impl IpcSender + where T: Serialize +{ + pub fn connect(name: String) -> Result, Error> { Ok(IpcSender { os_sender: try!(OsIpcSender::connect(name)), phantom: PhantomData, }) } - pub fn send(&self, data: T) -> Result<(),Error> { + pub fn send(&self, data: T) -> Result<(), Error> { let mut bytes = Vec::with_capacity(4096); OS_IPC_CHANNELS_FOR_SERIALIZATION.with(|os_ipc_channels_for_serialization| { OS_IPC_SHARED_MEMORY_REGIONS_FOR_SERIALIZATION.with( @@ -178,14 +190,16 @@ impl IpcSender where T: Serialize { } pub fn to_opaque(self) -> OpaqueIpcSender { - OpaqueIpcSender { - os_sender: self.os_sender, - } + OpaqueIpcSender { os_sender: self.os_sender } } } -impl Deserialize for IpcSender where T: Serialize { - fn deserialize(deserializer: &mut D) -> Result where D: Deserializer { +impl Deserialize for IpcSender + where T: Serialize +{ + fn deserialize(deserializer: &mut D) -> Result + where D: Deserializer + { let os_sender = try!(deserialize_os_ipc_sender(deserializer)); Ok(IpcSender { os_sender: os_sender, @@ -194,8 +208,12 @@ impl Deserialize for IpcSender where T: Serialize { } } -impl Serialize for IpcSender where T: Serialize { - fn serialize(&self, serializer: &mut S) -> Result<(),S::Error> where S: Serializer { +impl Serialize for IpcSender + where T: Serialize +{ + fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> + where S: Serializer + { serialize_os_ipc_sender(&self.os_sender, serializer) } } @@ -205,26 +223,26 @@ pub struct IpcReceiverSet { } impl IpcReceiverSet { - pub fn new() -> Result { - Ok(IpcReceiverSet { - os_receiver_set: try!(OsIpcReceiverSet::new()), - }) + pub fn new() -> Result { + Ok(IpcReceiverSet { os_receiver_set: try!(OsIpcReceiverSet::new()) }) } - pub fn add(&mut self, receiver: IpcReceiver) -> Result - where T: Deserialize + Serialize { + pub fn add(&mut self, receiver: IpcReceiver) -> Result + where T: Deserialize + Serialize + { Ok(try!(self.os_receiver_set.add(receiver.os_receiver))) } - pub fn add_opaque(&mut self, receiver: OpaqueIpcReceiver) -> Result { + pub fn add_opaque(&mut self, receiver: OpaqueIpcReceiver) -> Result { Ok(try!(self.os_receiver_set.add(receiver.os_receiver))) } - pub fn select(&mut self) -> Result,Error> { + pub fn select(&mut self) -> Result, Error> { let results = try!(self.os_receiver_set.select()); - Ok(results.into_iter().map(|result| { - match result { - OsIpcSelectionResult::DataReceived(os_receiver_id, + Ok(results.into_iter() + .map(|result| { + match result { + OsIpcSelectionResult::DataReceived(os_receiver_id, data, os_ipc_channels, os_ipc_shared_memory_regions) => { @@ -238,11 +256,12 @@ impl IpcReceiverSet { }).collect(), }) } - OsIpcSelectionResult::ChannelClosed(os_receiver_id) => { - IpcSelectionResult::ChannelClosed(os_receiver_id) - } - } - }).collect()) + OsIpcSelectionResult::ChannelClosed(os_receiver_id) => { + IpcSelectionResult::ChannelClosed(os_receiver_id) + } + } + }) + .collect()) } } @@ -261,7 +280,9 @@ impl Deref for IpcSharedMemory { } impl Deserialize for IpcSharedMemory { - fn deserialize(deserializer: &mut D) -> Result where D: Deserializer { + fn deserialize(deserializer: &mut D) -> Result + where D: Deserializer + { let index: usize = try!(Deserialize::deserialize(deserializer)); let os_shared_memory = OS_IPC_SHARED_MEMORY_REGIONS_FOR_DESERIALIZATION.with( |os_ipc_shared_memory_regions_for_deserialization| { @@ -271,14 +292,14 @@ impl Deserialize for IpcSharedMemory { &mut os_ipc_shared_memory_regions_for_deserialization.borrow_mut()[index], None).unwrap() }); - Ok(IpcSharedMemory { - os_shared_memory: os_shared_memory, - }) + Ok(IpcSharedMemory { os_shared_memory: os_shared_memory }) } } impl Serialize for IpcSharedMemory { - fn serialize(&self, serializer: &mut S) -> Result<(),S::Error> where S: Serializer { + fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> + where S: Serializer + { let index = OS_IPC_SHARED_MEMORY_REGIONS_FOR_SERIALIZATION.with( |os_ipc_shared_memory_regions_for_serialization| { let mut os_ipc_shared_memory_regions_for_serialization = @@ -294,15 +315,11 @@ impl Serialize for IpcSharedMemory { impl IpcSharedMemory { pub fn from_bytes(bytes: &[u8]) -> IpcSharedMemory { - IpcSharedMemory { - os_shared_memory: OsIpcSharedMemory::from_bytes(bytes), - } + IpcSharedMemory { os_shared_memory: OsIpcSharedMemory::from_bytes(bytes) } } pub fn from_byte(byte: u8, length: usize) -> IpcSharedMemory { - IpcSharedMemory { - os_shared_memory: OsIpcSharedMemory::from_byte(byte, length), - } + IpcSharedMemory { os_shared_memory: OsIpcSharedMemory::from_byte(byte, length) } } } @@ -348,12 +365,15 @@ impl OpaqueIpcMessage { os_ipc_shared_memory_regions: os_ipc_shared_memory_regions.into_iter() .map(|os_ipc_shared_memory_region| { - Some(os_ipc_shared_memory_region) - }).collect(), + Some(os_ipc_shared_memory_region) + }) + .collect(), } } - pub fn to(mut self) -> Result where T: Deserialize + Serialize { + pub fn to(mut self) -> Result + where T: Deserialize + Serialize + { OS_IPC_CHANNELS_FOR_DESERIALIZATION.with(|os_ipc_channels_for_deserialization| { OS_IPC_SHARED_MEMORY_REGIONS_FOR_DESERIALIZATION.with( |os_ipc_shared_memory_regions_for_deserialization| { @@ -389,7 +409,9 @@ pub struct OpaqueIpcSender { } impl OpaqueIpcSender { - pub fn to(self) -> IpcSender where T: Deserialize + Serialize { + pub fn to(self) -> IpcSender + where T: Deserialize + Serialize + { IpcSender { os_sender: self.os_sender, phantom: PhantomData, @@ -398,16 +420,18 @@ impl OpaqueIpcSender { } impl Deserialize for OpaqueIpcSender { - fn deserialize(deserializer: &mut D) -> Result where D: Deserializer { + fn deserialize(deserializer: &mut D) -> Result + where D: Deserializer + { let os_sender = try!(deserialize_os_ipc_sender(deserializer)); - Ok(OpaqueIpcSender { - os_sender: os_sender, - }) + Ok(OpaqueIpcSender { os_sender: os_sender }) } } impl Serialize for OpaqueIpcSender { - fn serialize(&self, serializer: &mut S) -> Result<(),S::Error> where S: Serializer { + fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> + where S: Serializer + { serialize_os_ipc_sender(&self.os_sender, serializer) } } @@ -422,30 +446,37 @@ pub struct IpcOneShotServer { phantom: PhantomData, } -impl IpcOneShotServer where T: Deserialize + Serialize { - pub fn new() -> Result<(IpcOneShotServer, String),Error> { +impl IpcOneShotServer + where T: Deserialize + Serialize +{ + pub fn new() -> Result<(IpcOneShotServer, String), Error> { let (os_server, name) = try!(OsIpcOneShotServer::new()); Ok((IpcOneShotServer { os_server: os_server, phantom: PhantomData, - }, name)) + }, + name)) } - pub fn accept(self) -> Result<(IpcReceiver,T),DeserializeError> { - let (os_receiver, data, os_channels, os_shared_memory_regions) = - try!(self.os_server.accept()); + pub fn accept(self) -> Result<(IpcReceiver, T), DeserializeError> { + let (os_receiver, data, os_channels, os_shared_memory_regions) = try!(self.os_server + .accept()); let value = try!(OpaqueIpcMessage { - data: data, - os_ipc_channels: os_channels, - os_ipc_shared_memory_regions: os_shared_memory_regions.into_iter() - .map(|os_shared_memory_region| { - Some(os_shared_memory_region) - }).collect(), - }.to()); + data: data, + os_ipc_channels: os_channels, + os_ipc_shared_memory_regions: + os_shared_memory_regions.into_iter() + .map(|os_shared_memory_region| { + Some(os_shared_memory_region) + }) + .collect(), + } + .to()); Ok((IpcReceiver { os_receiver: os_receiver, phantom: PhantomData, - }, value)) + }, + value)) } } @@ -456,7 +487,7 @@ pub struct IpcBytesReceiver { impl IpcBytesReceiver { #[inline] - pub fn recv(&self) -> Result,DeserializeError> { + pub fn recv(&self) -> Result, DeserializeError> { match self.os_receiver.recv() { Ok((data, _, _)) => Ok(data), Err(err) => Err(err.into()), @@ -465,7 +496,9 @@ impl IpcBytesReceiver { } impl Deserialize for IpcBytesReceiver { - fn deserialize(deserializer: &mut D) -> Result where D: Deserializer { + fn deserialize(deserializer: &mut D) -> Result + where D: Deserializer + { let index: usize = try!(Deserialize::deserialize(deserializer)); let os_receiver = OS_IPC_CHANNELS_FOR_DESERIALIZATION.with(|os_ipc_channels_for_deserialization| { @@ -473,14 +506,14 @@ impl Deserialize for IpcBytesReceiver { // of bounds. We should return an `Err` result instead. os_ipc_channels_for_deserialization.borrow_mut()[index].to_receiver() }); - Ok(IpcBytesReceiver { - os_receiver: os_receiver, - }) + Ok(IpcBytesReceiver { os_receiver: os_receiver }) } } impl Serialize for IpcBytesReceiver { - fn serialize(&self, serializer: &mut S) -> Result<(),S::Error> where S: Serializer { + fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> + where S: Serializer + { let index = OS_IPC_CHANNELS_FOR_SERIALIZATION.with(|os_ipc_channels_for_serialization| { let mut os_ipc_channels_for_serialization = os_ipc_channels_for_serialization.borrow_mut(); @@ -500,39 +533,41 @@ pub struct IpcBytesSender { impl Clone for IpcBytesSender { fn clone(&self) -> IpcBytesSender { - IpcBytesSender { - os_sender: self.os_sender.clone(), - } + IpcBytesSender { os_sender: self.os_sender.clone() } } } impl Deserialize for IpcBytesSender { - fn deserialize(deserializer: &mut D) -> Result where D: Deserializer { + fn deserialize(deserializer: &mut D) -> Result + where D: Deserializer + { let os_sender = try!(deserialize_os_ipc_sender(deserializer)); - Ok(IpcBytesSender { - os_sender: os_sender, - }) + Ok(IpcBytesSender { os_sender: os_sender }) } } impl Serialize for IpcBytesSender { - fn serialize(&self, serializer: &mut S) -> Result<(),S::Error> where S: Serializer { + fn serialize(&self, serializer: &mut S) -> Result<(), S::Error> + where S: Serializer + { serialize_os_ipc_sender(&self.os_sender, serializer) } } impl IpcBytesSender { #[inline] - pub fn send(&self, data: &[u8]) -> Result<(),Error> { + pub fn send(&self, data: &[u8]) -> Result<(), Error> { self.os_sender.send(data, vec![], vec![]).map_err(|e| Error::from(e)) } } -fn serialize_os_ipc_sender(os_ipc_sender: &OsIpcSender, serializer: &mut S) - -> Result<(),S::Error> where S: Serializer { +fn serialize_os_ipc_sender(os_ipc_sender: &OsIpcSender, + serializer: &mut S) + -> Result<(), S::Error> + where S: Serializer +{ let index = OS_IPC_CHANNELS_FOR_SERIALIZATION.with(|os_ipc_channels_for_serialization| { - let mut os_ipc_channels_for_serialization = - os_ipc_channels_for_serialization.borrow_mut(); + let mut os_ipc_channels_for_serialization = os_ipc_channels_for_serialization.borrow_mut(); let index = os_ipc_channels_for_serialization.len(); os_ipc_channels_for_serialization.push(OsIpcChannel::Sender(os_ipc_sender.clone())); index @@ -540,8 +575,9 @@ fn serialize_os_ipc_sender(os_ipc_sender: &OsIpcSender, serializer: &mut S) index.serialize(serializer) } -fn deserialize_os_ipc_sender(deserializer: &mut D) - -> Result where D: Deserializer { +fn deserialize_os_ipc_sender(deserializer: &mut D) -> Result + where D: Deserializer +{ let index: usize = try!(Deserialize::deserialize(deserializer)); OS_IPC_CHANNELS_FOR_DESERIALIZATION.with(|os_ipc_channels_for_deserialization| { // FIXME(pcwalton): This could panic if the data was corrupt and the index was out of @@ -551,6 +587,6 @@ fn deserialize_os_ipc_sender(deserializer: &mut D) } fn recursive_io_error() -> Error { - Error::new(ErrorKind::Other, "recursive IPC channel use during serialization") + Error::new(ErrorKind::Other, + "recursive IPC channel use during serialization") } - diff --git a/lib.rs b/lib.rs index fc1fa1c7e..c9b3f4b12 100644 --- a/lib.rs +++ b/lib.rs @@ -12,8 +12,7 @@ #![cfg_attr(test, feature(time2))] #![plugin(serde_macros)] -#[macro_use] -extern crate lazy_static; +#[macro_use] extern crate lazy_static; extern crate bincode; extern crate byteorder; @@ -28,4 +27,3 @@ pub mod router; #[cfg(test)] mod test; - diff --git a/platform/inprocess/mod.rs b/platform/inprocess/mod.rs index e2f426170..909f8be55 100644 --- a/platform/inprocess/mod.rs +++ b/platform/inprocess/mod.rs @@ -8,17 +8,16 @@ // except according to those terms. use bincode::serde::DeserializeError; -use std::sync::mpsc; -use std::sync::{Arc, Mutex}; +use std::cell::RefCell; +use std::cmp::PartialEq; use std::collections::hash_map::HashMap; -use std::cell::{RefCell}; -use std::io::{Error, ErrorKind}; -use std::slice; use std::fmt::{self, Debug, Formatter}; -use std::cmp::{PartialEq}; -use std::ops::Deref; +use std::io::{Error, ErrorKind}; use std::mem; - +use std::ops::Deref; +use std::slice; +use std::sync::mpsc; +use std::sync::{Arc, Mutex}; use uuid::Uuid; struct ServerRecord { @@ -47,12 +46,12 @@ impl ServerRecord { } lazy_static! { - static ref ONE_SHOT_SERVERS: Mutex> = Mutex::new(HashMap::new()); + static ref ONE_SHOT_SERVERS: Mutex> = Mutex::new(HashMap::new()); } struct MpscChannelMessage(Vec, Vec, Vec); -pub fn channel() -> Result<(MpscSender, MpscReceiver),MpscError> { +pub fn channel() -> Result<(MpscSender, MpscReceiver), MpscError> { let (base_sender, base_receiver) = mpsc::channel::(); Ok((MpscSender::new(base_sender), MpscReceiver::new(base_receiver))) } @@ -64,7 +63,7 @@ pub struct MpscReceiver { impl PartialEq for MpscReceiver { fn eq(&self, other: &MpscReceiver) -> bool { self.receiver.borrow().as_ref().map(|rx| rx as *const _) == - other.receiver.borrow().as_ref().map(|rx| rx as *const _) + other.receiver.borrow().as_ref().map(|rx| rx as *const _) } } @@ -78,9 +77,7 @@ impl fmt::Debug for MpscReceiver { impl MpscReceiver { fn new(receiver: mpsc::Receiver) -> MpscReceiver { - MpscReceiver { - receiver: RefCell::new(Some(receiver)), - } + MpscReceiver { receiver: RefCell::new(Some(receiver)) } } pub fn consume(&self) -> MpscReceiver { @@ -88,29 +85,31 @@ impl MpscReceiver { MpscReceiver::new(receiver.unwrap()) } - pub fn recv(&self) -> Result<(Vec, Vec, Vec),MpscError> { + pub fn recv(&self) -> Result<(Vec, Vec, Vec), MpscError> { let r = self.receiver.borrow(); match r.as_ref().unwrap().recv() { - Ok(MpscChannelMessage(d,c,s)) => Ok((d, - c.into_iter().map(OpaqueMpscChannel::new).collect(), - s)), + Ok(MpscChannelMessage(d, c, s)) => { + Ok((d, c.into_iter().map(OpaqueMpscChannel::new).collect(), s)) + } Err(_) => Err(MpscError::ChannelClosedError), } } - pub fn try_recv(&self) -> Result<(Vec, Vec, Vec),MpscError> { + pub fn try_recv + (&self) + -> Result<(Vec, Vec, Vec), MpscError> { let r = self.receiver.borrow(); match r.as_ref().unwrap().try_recv() { - Ok(MpscChannelMessage(d,c,s)) => Ok((d, - c.into_iter().map(OpaqueMpscChannel::new).collect(), - s)), + Ok(MpscChannelMessage(d, c, s)) => { + Ok((d, c.into_iter().map(OpaqueMpscChannel::new).collect(), s)) + } Err(_) => Err(MpscError::ChannelClosedError), } } } -unsafe impl Send for MpscReceiver { } -unsafe impl Sync for MpscReceiver { } +unsafe impl Send for MpscReceiver {} +unsafe impl Sync for MpscReceiver {} #[derive(Clone)] pub struct MpscSender { @@ -119,8 +118,7 @@ pub struct MpscSender { impl PartialEq for MpscSender { fn eq(&self, other: &MpscSender) -> bool { - &*self.sender.borrow() as *const _ == - &*other.sender.borrow() as *const _ + &*self.sender.borrow() as *const _ == &*other.sender.borrow() as *const _ } } @@ -132,17 +130,15 @@ impl fmt::Debug for MpscSender { } } -unsafe impl Send for MpscSender { } -unsafe impl Sync for MpscSender { } +unsafe impl Send for MpscSender {} +unsafe impl Sync for MpscSender {} impl MpscSender { fn new(sender: mpsc::Sender) -> MpscSender { - MpscSender { - sender: RefCell::new(sender), - } + MpscSender { sender: RefCell::new(sender) } } - pub fn connect(name: String) -> Result { + pub fn connect(name: String) -> Result { let record = ONE_SHOT_SERVERS.lock().unwrap().remove(&name).unwrap(); record.connect(); Ok(record.sender) @@ -152,9 +148,10 @@ impl MpscSender { data: &[u8], ports: Vec, shared_memory_regions: Vec) - -> Result<(),MpscError> - { - match self.sender.borrow().send(MpscChannelMessage(data.to_vec(), ports, shared_memory_regions)) { + -> Result<(), MpscError> { + match self.sender + .borrow() + .send(MpscChannelMessage(data.to_vec(), ports, shared_memory_regions)) { Err(_) => Err(MpscError::ChannelClosedError), Ok(_) => Ok(()), } @@ -168,7 +165,7 @@ pub struct MpscReceiverSet { } impl MpscReceiverSet { - pub fn new() -> Result { + pub fn new() -> Result { Ok(MpscReceiverSet { last_index: 0, receiver_ids: vec![], @@ -176,28 +173,30 @@ impl MpscReceiverSet { }) } - pub fn add(&mut self, receiver: MpscReceiver) -> Result { + pub fn add(&mut self, receiver: MpscReceiver) -> Result { self.last_index += 1; self.receiver_ids.push(self.last_index); self.receivers.push(receiver.consume()); Ok(self.last_index as i64) } - pub fn select(&mut self) -> Result,MpscError> { - let mut receivers: Vec>> = Vec::with_capacity(self.receivers.len()); + pub fn select(&mut self) -> Result, MpscError> { + let mut receivers: Vec>> = + Vec::with_capacity(self.receivers.len()); let mut r_id: i64 = -1; let mut r_index: usize = 0; { let select = mpsc::Select::new(); // we *must* allocate exact capacity for this, because the Handles *can't move* - let mut handles: Vec> = Vec::with_capacity(self.receivers.len()); + let mut handles: Vec> = + Vec::with_capacity(self.receivers.len()); for r in &self.receivers { let inner_r = mem::replace(&mut *r.receiver.borrow_mut(), None); receivers.push(inner_r); } - + for r in &receivers { unsafe { handles.push(select.handle(r.as_ref().unwrap())); @@ -207,7 +206,7 @@ impl MpscReceiverSet { let id = select.wait(); - for (index,h) in handles.iter().enumerate() { + for (index, h) in handles.iter().enumerate() { if h.id() == id { r_index = index; r_id = self.receiver_ids[index] as i64; @@ -217,8 +216,9 @@ impl MpscReceiverSet { } // put the receivers back - for (index,r) in self.receivers.iter().enumerate() { - mem::replace(&mut *r.receiver.borrow_mut(), mem::replace(&mut receivers[index], None)); + for (index, r) in self.receivers.iter().enumerate() { + mem::replace(&mut *r.receiver.borrow_mut(), + mem::replace(&mut receivers[index], None)); } if r_id == -1 { @@ -227,13 +227,14 @@ impl MpscReceiverSet { let receivers = &mut self.receivers; match receivers[r_index].recv() { - Ok((data, channels, shmems)) => - Ok(vec![MpscSelectionResult::DataReceived(r_id, data, channels, shmems)]), + Ok((data, channels, shmems)) => { + Ok(vec![MpscSelectionResult::DataReceived(r_id, data, channels, shmems)]) + } Err(MpscError::ChannelClosedError) => { receivers.remove(r_index); self.receiver_ids.remove(r_index); Ok(vec![MpscSelectionResult::ChannelClosed(r_id)]) - }, + } Err(err) => Err(err), } } @@ -251,7 +252,8 @@ impl MpscSelectionResult { (id, data, channels, shared_memory_regions) } MpscSelectionResult::ChannelClosed(id) => { - panic!("MpscSelectionResult::unwrap(): receiver ID {} was closed!", id) + panic!("MpscSelectionResult::unwrap(): receiver ID {} was closed!", + id) } } } @@ -263,9 +265,9 @@ pub struct MpscOneShotServer { } impl MpscOneShotServer { - pub fn new() -> Result<(MpscOneShotServer, String),MpscError> { + pub fn new() -> Result<(MpscOneShotServer, String), MpscError> { let (sender, receiver) = match channel() { - Ok((s,r)) => (s,r), + Ok((s, r)) => (s, r), Err(err) => return Err(err), }; @@ -275,13 +277,14 @@ impl MpscOneShotServer { Ok((MpscOneShotServer { receiver: RefCell::new(Some(receiver)), name: name.clone(), - },name.clone())) + }, + name.clone())) } pub fn accept(&self) -> Result<(MpscReceiver, Vec, Vec, - Vec),MpscError> + Vec), MpscError> { ONE_SHOT_SERVERS.lock().unwrap().get(&self.name).unwrap().accept(); let receiver = self.receiver.borrow_mut().take().unwrap(); @@ -303,18 +306,16 @@ pub struct OpaqueMpscChannel { impl OpaqueMpscChannel { fn new(channel: MpscChannel) -> OpaqueMpscChannel { - OpaqueMpscChannel { - channel: RefCell::new(Some(channel)) - } + OpaqueMpscChannel { channel: RefCell::new(Some(channel)) } } pub fn to_receiver(&self) -> MpscReceiver { match self.channel.borrow_mut().take().unwrap() { MpscChannel::Sender(_) => panic!("Opaque channel is not a receiver!"), - MpscChannel::Receiver(r) => r + MpscChannel::Receiver(r) => r, } } - + pub fn to_sender(&self) -> MpscSender { match self.channel.borrow_mut().take().unwrap() { MpscChannel::Sender(s) => s, @@ -362,9 +363,7 @@ impl Deref for MpscSharedMemory { if self.ptr.is_null() { panic!("attempted to access a consumed `MpscSharedMemory`") } - unsafe { - slice::from_raw_parts(self.ptr, self.length) - } + unsafe { slice::from_raw_parts(self.ptr, self.length) } } } @@ -374,7 +373,7 @@ impl MpscSharedMemory { MpscSharedMemory { ptr: Arc::get_mut(&mut v).unwrap().as_mut_ptr(), length: length, - data: v + data: v, } } @@ -383,7 +382,7 @@ impl MpscSharedMemory { MpscSharedMemory { ptr: Arc::get_mut(&mut v).unwrap().as_mut_ptr(), length: v.len(), - data: v + data: v, } } } @@ -417,4 +416,3 @@ impl From for Error { } } } - diff --git a/platform/linux/mod.rs b/platform/linux/mod.rs index eda23e258..ab2f76df3 100644 --- a/platform/linux/mod.rs +++ b/platform/linux/mod.rs @@ -9,8 +9,8 @@ use bincode::serde::DeserializeError; use byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt}; -use libc::{self, MAP_SHARED, PROT_READ, PROT_WRITE, c_char, c_int, c_short, c_ulong}; use libc::{c_ushort, c_void, mode_t, off_t, size_t, sockaddr, sockaddr_un, socklen_t, ssize_t}; +use libc::{self, MAP_SHARED, PROT_READ, PROT_WRITE, c_char, c_int, c_short, c_ulong}; use std::cmp; use std::collections::HashSet; use std::ffi::{CStr, CString}; @@ -30,7 +30,7 @@ const MAP_FAILED: *mut u8 = (!0usize) as *mut u8; static LAST_FRAGMENT_ID: AtomicUsize = ATOMIC_USIZE_INIT; -pub fn channel() -> Result<(UnixSender, UnixReceiver),UnixError> { +pub fn channel() -> Result<(UnixSender, UnixReceiver), UnixError> { let mut results = [0, 0]; unsafe { if socketpair(libc::AF_UNIX, SOCK_SEQPACKET, 0, &mut results[0]) >= 0 { @@ -49,7 +49,7 @@ pub struct UnixReceiver { impl Drop for UnixReceiver { fn drop(&mut self) { unsafe { - //assert!(libc::close(self.fd) == 0) + // assert!(libc::close(self.fd) == 0) libc::close(self.fd); } } @@ -57,28 +57,24 @@ impl Drop for UnixReceiver { impl UnixReceiver { fn from_fd(fd: c_int) -> UnixReceiver { - UnixReceiver { - fd: fd, - } + UnixReceiver { fd: fd } } fn consume_fd(&self) -> c_int { - unsafe { - libc::dup(self.fd) - } + unsafe { libc::dup(self.fd) } } pub fn consume(&self) -> UnixReceiver { UnixReceiver::from_fd(self.consume_fd()) } - pub fn recv(&self) - -> Result<(Vec, Vec, Vec),UnixError> { + pub fn recv(&self) -> Result<(Vec, Vec, Vec), UnixError> { recv(self.fd, BlockingMode::Blocking) } - pub fn try_recv(&self) - -> Result<(Vec, Vec, Vec),UnixError> { + pub fn try_recv + (&self) + -> Result<(Vec, Vec, Vec), UnixError> { recv(self.fd, BlockingMode::Nonblocking) } } @@ -99,23 +95,17 @@ impl Drop for UnixSender { impl Clone for UnixSender { fn clone(&self) -> UnixSender { - unsafe { - UnixSender { - fd: libc::dup(self.fd) - } - } + unsafe { UnixSender { fd: libc::dup(self.fd) } } } } impl UnixSender { fn from_fd(fd: c_int) -> UnixSender { - UnixSender { - fd: fd, - } + UnixSender { fd: fd } } /// Maximum total data size that can be transferred over this channel in a single packet. - pub fn get_maximum_send_size(&self) -> Result { + pub fn get_maximum_send_size(&self) -> Result { unsafe { let mut maximum_send_size: usize = 0; let mut maximum_send_size_len = mem::size_of::() as socklen_t; @@ -124,7 +114,7 @@ impl UnixSender { libc::SO_SNDBUF, &mut maximum_send_size as *mut usize as *mut c_void, &mut maximum_send_size_len as *mut socklen_t) < 0 { - return Err(UnixError::last()) + return Err(UnixError::last()); } Ok(maximum_send_size) } @@ -134,7 +124,7 @@ impl UnixSender { data: &[u8], mut channels: Vec, shared_memory_regions: Vec) - -> Result<(),UnixError> { + -> Result<(), UnixError> { let mut data_buffer = vec![0; data.len() + mem::size_of::() * 2]; { let mut data_buffer = &mut data_buffer[..]; @@ -148,8 +138,8 @@ impl UnixSender { shared_memory_regions: &[UnixSharedMemory], data_buffer: &[u8]) -> (msghdr, Box) { - let cmsg_length = - (channels.len() + shared_memory_regions.len()) * mem::size_of::(); + let cmsg_length = (channels.len() + shared_memory_regions.len()) * + mem::size_of::(); let cmsg_buffer = libc::malloc(CMSG_SPACE(cmsg_length as size_t)) as *mut cmsghdr; (*cmsg_buffer).cmsg_len = CMSG_LEN(cmsg_length as size_t); (*cmsg_buffer).cmsg_level = libc::SOL_SOCKET; @@ -187,7 +177,9 @@ impl UnixSender { (msghdr, iovec) }; - let (msghdr, _iovec) = construct_header(&channels, &shared_memory_regions, &data_buffer); + let (msghdr, _iovec) = construct_header(&channels, + &shared_memory_regions, + &data_buffer); let result = sendmsg(self.fd, &msghdr, 0); libc::free(msghdr.msg_control); @@ -195,7 +187,7 @@ impl UnixSender { let mut downsize = false; if result > 0 { - return Ok(()) + return Ok(()); } else { let error = UnixError::last(); if error.0 == libc::ENOBUFS { @@ -209,7 +201,7 @@ impl UnixSender { // than the ordinary maximum send size. downsize = true; } else if error.0 != libc::EMSGSIZE { - return Err(error) + return Err(error); } } @@ -222,11 +214,14 @@ impl UnixSender { // along any other file descriptors that are to be transferred in the message. let (dedicated_tx, dedicated_rx) = try!(channel()); channels.push(UnixChannel::Receiver(dedicated_rx)); - let (msghdr, mut iovec) = construct_header(&channels, &shared_memory_regions, &data_buffer); + let (msghdr, mut iovec) = construct_header(&channels, + &shared_memory_regions, + &data_buffer); - let mut bytes_per_fragment = try!(self.get_maximum_send_size()) - - (mem::size_of::() * 2 - + msghdr.msg_controllen as usize + 256); + let mut bytes_per_fragment = try!(self.get_maximum_send_size()) - + (mem::size_of::() * 2 + + msghdr.msg_controllen as usize + + 256); // Split up the packet into fragments. let mut byte_position = 0; @@ -282,10 +277,10 @@ impl UnixSender { // so there is no point in further downsizing, // and we error out instead.) downsize = true; - continue + continue; } else { libc::free(msghdr.msg_control); - return Err(error) + return Err(error); } } @@ -298,22 +293,24 @@ impl UnixSender { } } - pub fn connect(name: String) -> Result { + pub fn connect(name: String) -> Result { let name = CString::new(name).unwrap(); unsafe { let fd = libc::socket(libc::AF_UNIX, SOCK_SEQPACKET, 0); let mut sockaddr = sockaddr_un { sun_family: libc::AF_UNIX as u16, - sun_path: [ 0; 108 ], + sun_path: [0; 108], }; libc::strncpy(sockaddr.sun_path.as_mut_ptr(), name.as_ptr(), sockaddr.sun_path.len() as size_t - 1); let len = mem::size_of::() + - (libc::strlen(sockaddr.sun_path.as_ptr()) as usize); - if libc::connect(fd, &sockaddr as *const _ as *const sockaddr, len as socklen_t) < 0 { - return Err(UnixError::last()) + (libc::strlen(sockaddr.sun_path.as_ptr()) as usize); + if libc::connect(fd, + &sockaddr as *const _ as *const sockaddr, + len as socklen_t) < 0 { + return Err(UnixError::last()); } Ok(UnixSender::from_fd(fd)) @@ -352,13 +349,11 @@ impl Drop for UnixReceiverSet { } impl UnixReceiverSet { - pub fn new() -> Result { - Ok(UnixReceiverSet { - pollfds: Vec::new(), - }) + pub fn new() -> Result { + Ok(UnixReceiverSet { pollfds: Vec::new() }) } - pub fn add(&mut self, receiver: UnixReceiver) -> Result { + pub fn add(&mut self, receiver: UnixReceiver) -> Result { let fd = receiver.consume_fd(); self.pollfds.push(pollfd { fd: fd, @@ -368,13 +363,11 @@ impl UnixReceiverSet { Ok(fd as i64) } - pub fn select(&mut self) -> Result,UnixError> { + pub fn select(&mut self) -> Result, UnixError> { let mut selection_results = Vec::new(); - let result = unsafe { - poll(self.pollfds.as_mut_ptr(), self.pollfds.len() as nfds_t, -1) - }; + let result = unsafe { poll(self.pollfds.as_mut_ptr(), self.pollfds.len() as nfds_t, -1) }; if result <= 0 { - return Err(UnixError::last()) + return Err(UnixError::last()); } let mut hangups = HashSet::new(); @@ -390,8 +383,7 @@ impl UnixReceiverSet { } Err(err) if err.channel_is_closed() => { hangups.insert(pollfd.fd); - selection_results.push(UnixSelectionResult::ChannelClosed( - pollfd.fd as i64)) + selection_results.push(UnixSelectionResult::ChannelClosed(pollfd.fd as i64)) } Err(err) => return Err(err), } @@ -419,7 +411,8 @@ impl UnixSelectionResult { (id, data, channels, shared_memory_regions) } UnixSelectionResult::ChannelClosed(id) => { - panic!("UnixSelectionResult::unwrap(): receiver ID {} was closed!", id) + panic!("UnixSelectionResult::unwrap(): receiver ID {} was closed!", + id) } } } @@ -433,28 +426,22 @@ pub struct OpaqueUnixChannel { impl Drop for OpaqueUnixChannel { fn drop(&mut self) { unsafe { - libc::close(self.fd); + libc::close(self.fd); } } } impl OpaqueUnixChannel { fn from_fd(fd: c_int) -> OpaqueUnixChannel { - OpaqueUnixChannel { - fd: fd, - } + OpaqueUnixChannel { fd: fd } } pub fn to_sender(&mut self) -> UnixSender { - unsafe { - UnixSender::from_fd(libc::dup(self.fd)) - } + unsafe { UnixSender::from_fd(libc::dup(self.fd)) } } pub fn to_receiver(&mut self) -> UnixReceiver { - unsafe { - UnixReceiver::from_fd(libc::dup(self.fd)) - } + unsafe { UnixReceiver::from_fd(libc::dup(self.fd)) } } } @@ -472,7 +459,7 @@ impl Drop for UnixOneShotServer { } impl UnixOneShotServer { - pub fn new() -> Result<(UnixOneShotServer, String),UnixError> { + pub fn new() -> Result<(UnixOneShotServer, String), UnixError> { unsafe { let fd = libc::socket(libc::AF_UNIX, SOCK_SEQPACKET, 0); let mut path: Vec; @@ -480,56 +467,57 @@ impl UnixOneShotServer { let path_string = CString::new(b"/tmp/rust-ipc-socket.XXXXXX" as &[u8]).unwrap(); path = path_string.as_bytes_with_nul().iter().cloned().collect(); if *mktemp(path.as_mut_ptr() as *mut c_char) == 0 { - return Err(UnixError::last()) + return Err(UnixError::last()); } let mut sockaddr = sockaddr_un { sun_family: libc::AF_UNIX as c_ushort, - sun_path: [ 0; 108 ], + sun_path: [0; 108], }; libc::strncpy(sockaddr.sun_path.as_mut_ptr(), path.as_ptr() as *const c_char, sockaddr.sun_path.len() as size_t - 1); - let len = mem::size_of::() + (libc::strlen(sockaddr.sun_path.as_ptr()) as - usize); - if libc::bind(fd, &sockaddr as *const _ as *const sockaddr, len as socklen_t) == 0 { - break + let len = mem::size_of::() + + (libc::strlen(sockaddr.sun_path.as_ptr()) as usize); + if libc::bind(fd, + &sockaddr as *const _ as *const sockaddr, + len as socklen_t) == 0 { + break; } let errno = UnixError::last(); if errno.0 != libc::EINVAL { - return Err(errno) + return Err(errno); } } if libc::listen(fd, 10) != 0 { - return Err(UnixError::last()) + return Err(UnixError::last()); } - Ok((UnixOneShotServer { - fd: fd, - }, String::from_utf8(CStr::from_ptr(path.as_ptr() as - *const c_char).to_bytes().to_owned()).unwrap())) + Ok((UnixOneShotServer { fd: fd }, + String::from_utf8(CStr::from_ptr(path.as_ptr() as *const c_char) + .to_bytes() + .to_owned()) + .unwrap())) } } pub fn accept(self) -> Result<(UnixReceiver, Vec, Vec, - Vec),UnixError> { + Vec), UnixError> { unsafe { let sockaddr: *mut sockaddr = ptr::null_mut(); let sockaddr_len: *mut socklen_t = ptr::null_mut(); let client_fd = libc::accept(self.fd, sockaddr, sockaddr_len); if client_fd < 0 { - return Err(UnixError::last()) + return Err(UnixError::last()); } try!(make_socket_lingering(client_fd)); - let receiver = UnixReceiver { - fd: client_fd, - }; + let receiver = UnixReceiver { fd: client_fd }; let (data, channels, shared_memory_regions) = try!(receiver.recv()); Ok((receiver, data, channels, shared_memory_regions)) } @@ -540,7 +528,7 @@ impl UnixOneShotServer { // close our end. // // See, for example, https://github.com/servo/ipc-channel/issues/29 -fn make_socket_lingering(sockfd: c_int) -> Result<(),UnixError> { +fn make_socket_lingering(sockfd: c_int) -> Result<(), UnixError> { let linger = linger { l_onoff: 1, l_linger: 30, @@ -553,7 +541,7 @@ fn make_socket_lingering(sockfd: c_int) -> Result<(),UnixError> { mem::size_of::() as socklen_t) }; if err < 0 { - return Err(UnixError::last()) + return Err(UnixError::last()); } Ok(()) } @@ -607,9 +595,7 @@ impl Deref for UnixSharedMemory { #[inline] fn deref(&self) -> &[u8] { - unsafe { - slice::from_raw_parts(self.ptr, self.length) - } + unsafe { slice::from_raw_parts(self.ptr, self.length) } } } @@ -680,8 +666,9 @@ enum BlockingMode { Nonblocking, } -fn recv(fd: c_int, blocking_mode: BlockingMode) - -> Result<(Vec, Vec, Vec),UnixError> { +fn recv(fd: c_int, + blocking_mode: BlockingMode) + -> Result<(Vec, Vec, Vec), UnixError> { unsafe { let mut maximum_recv_size: usize = 0; let mut maximum_recv_size_len = mem::size_of::() as socklen_t; @@ -690,7 +677,7 @@ fn recv(fd: c_int, blocking_mode: BlockingMode) libc::SO_RCVBUF, &mut maximum_recv_size as *mut usize as *mut c_void, &mut maximum_recv_size_len as *mut socklen_t) < 0 { - return Err(UnixError::last()) + return Err(UnixError::last()); } let mut cmsg = UnixCmsg::new(maximum_recv_size); @@ -708,7 +695,7 @@ fn recv(fd: c_int, blocking_mode: BlockingMode) let fd = *cmsg_fds.offset(index as isize); if is_socket(fd) { channels.push(OpaqueUnixChannel::from_fd(fd)); - continue + continue; } shared_memory_regions.push(UnixSharedMemory::from_fd(fd)); } @@ -716,17 +703,18 @@ fn recv(fd: c_int, blocking_mode: BlockingMode) // Separate out the fragmentation frame. let (fragment_info_buffer, main_data_buffer) = cmsg.data_buffer .split_at(mem::size_of::() * 2); - let mut main_data_buffer: Vec = - main_data_buffer[0..(bytes_read - mem::size_of::() * 2)].iter() - .cloned() - .collect(); + let mut main_data_buffer: Vec = main_data_buffer[0..(bytes_read - + mem::size_of::() * 2)] + .iter() + .cloned() + .collect(); let mut next_fragment_id = - (&fragment_info_buffer[mem::size_of::().. - (mem::size_of::() * 2)]).read_u32::() - .unwrap(); + (&fragment_info_buffer[mem::size_of::()..(mem::size_of::() * 2)]) + .read_u32::() + .unwrap(); if next_fragment_id == 0 { // Fast path: no fragments. - return Ok((main_data_buffer, channels, shared_memory_regions)) + return Ok((main_data_buffer, channels, shared_memory_regions)); } // Reassemble fragments. @@ -741,29 +729,31 @@ fn recv(fd: c_int, blocking_mode: BlockingMode) // we don't abort in the middle of it... let bytes_read = try!(cmsg.recv(dedicated_rx.fd, BlockingMode::Blocking)) as usize; - let this_fragment_id = - (&cmsg.data_buffer[0..mem::size_of::()]).read_u32::().unwrap(); + let this_fragment_id = (&cmsg.data_buffer[0..mem::size_of::()]) + .read_u32::() + .unwrap(); assert!(this_fragment_id == next_fragment_id); - next_fragment_id = - (&cmsg.data_buffer[mem::size_of::().. - (mem::size_of::() * 2)]).read_u32::() - .unwrap(); - main_data_buffer.extend( - cmsg.data_buffer[(mem::size_of::() * 2)..bytes_read].iter().cloned()) + next_fragment_id = (&cmsg.data_buffer[mem::size_of::()..(mem::size_of::() * + 2)]) + .read_u32::() + .unwrap(); + main_data_buffer.extend(cmsg.data_buffer[(mem::size_of::() * 2)..bytes_read] + .iter() + .cloned()) } Ok((main_data_buffer, channels, shared_memory_regions)) } } -#[cfg(target_os="android")] +#[cfg(target_os = "android")] const TEMP_FILE_TEMPLATE: &'static str = "/sdcard/servo/ipc-channel-shared-memory.XXXXXX"; -#[cfg(not(target_os="android"))] +#[cfg(not(target_os = "android"))] const TEMP_FILE_TEMPLATE: &'static str = "/tmp/ipc-channel-shared-memory.XXXXXX"; -#[cfg(target_os="android")] +#[cfg(target_os = "android")] fn maybe_unlink(_: *const c_char) -> c_int { // Calling `unlink` on a file stored on an sdcard immediately deletes it. // FIXME: use a better temporary directory than the sdcard via the Java APIs @@ -772,7 +762,7 @@ fn maybe_unlink(_: *const c_char) -> c_int { 0 } -#[cfg(not(target_os="android"))] +#[cfg(not(target_os = "android"))] unsafe fn maybe_unlink(c: *const c_char) -> c_int { libc::unlink(c) } @@ -796,7 +786,7 @@ unsafe fn map_file(fd: c_int, length: Option) -> (*mut u8, size_t) { }); if length == 0 { // This will cause `mmap` to fail, so handle it explicitly. - return (ptr::null_mut(), length) + return (ptr::null_mut(), length); } let address = libc::mmap(ptr::null_mut(), length, @@ -829,8 +819,8 @@ impl Drop for UnixCmsg { impl UnixCmsg { unsafe fn new(maximum_recv_size: usize) -> UnixCmsg { - let cmsg_length = mem::size_of::() + (MAX_FDS_IN_CMSG as usize) * - mem::size_of::(); + let cmsg_length = mem::size_of::() + + (MAX_FDS_IN_CMSG as usize) * mem::size_of::(); assert!(maximum_recv_size > cmsg_length); let mut data_buffer: Vec = vec![0; maximum_recv_size]; let cmsg_buffer = libc::malloc(cmsg_length as size_t) as *mut cmsghdr; @@ -855,11 +845,13 @@ impl UnixCmsg { } } - unsafe fn recv(&mut self, fd: c_int, blocking_mode: BlockingMode) + unsafe fn recv(&mut self, + fd: c_int, + blocking_mode: BlockingMode) -> Result { if let BlockingMode::Nonblocking = blocking_mode { if libc::fcntl(fd, libc::F_SETFL, libc::O_NONBLOCK) < 0 { - return Err(UnixError::last()) + return Err(UnixError::last()); } } @@ -874,7 +866,7 @@ impl UnixCmsg { if let BlockingMode::Nonblocking = blocking_mode { if libc::fcntl(fd, libc::F_SETFL, 0) < 0 { - return Err(UnixError::last()) + return Err(UnixError::last()); } } result @@ -889,7 +881,7 @@ fn is_socket(fd: c_int) -> bool { unsafe { let mut st = mem::uninitialized(); if libc::fstat(fd, &mut st) != 0 { - return false + return false; } S_ISSOCK(st.st_mode as mode_t) } @@ -915,7 +907,8 @@ fn CMSG_LEN(length: size_t) -> size_t { #[allow(non_snake_case)] fn CMSG_ALIGN(length: size_t) -> size_t { - (length + (mem::size_of::() as size_t) - 1) & ((!(mem::size_of::() - 1)) as size_t) + (length + (mem::size_of::() as size_t) - 1) & + ((!(mem::size_of::() - 1)) as size_t) } #[allow(non_snake_case)] @@ -928,7 +921,7 @@ fn S_ISSOCK(mode: mode_t) -> bool { (mode & S_IFMT) == S_IFSOCK } -extern { +extern "C" { fn getsockopt(sockfd: c_int, level: c_int, optname: c_int, @@ -986,4 +979,3 @@ struct linger { l_onoff: c_int, l_linger: c_int, } - diff --git a/platform/macos/mach_sys.rs b/platform/macos/mach_sys.rs index acdbe9d88..13f9f7591 100644 --- a/platform/macos/mach_sys.rs +++ b/platform/macos/mach_sys.rs @@ -1,4 +1,4 @@ -/* automatically generated by rust-bindgen */ +// automatically generated by rust-bindgen #![allow(warnings)] @@ -19,16 +19,16 @@ pub type uintptr_t = usize; #[repr(C)] pub struct mach_vm_info_region { - vir_start: mach_vm_offset_t, - vir_end: mach_vm_offset_t, - vir_object: mach_vm_offset_t, - vir_offset: memory_object_offset_t, - vir_needs_copy: boolean_t, - vir_protection: vm_prot_t, - vir_max_protection: vm_prot_t, - vir_inheritance: vm_inherit_t, - vir_wired_count: natural_t, - vir_user_wired_count: natural_t, + vir_start: mach_vm_offset_t, + vir_end: mach_vm_offset_t, + vir_object: mach_vm_offset_t, + vir_offset: memory_object_offset_t, + vir_needs_copy: boolean_t, + vir_protection: vm_prot_t, + vir_max_protection: vm_prot_t, + vir_inheritance: vm_inherit_t, + vir_wired_count: natural_t, + vir_user_wired_count: natural_t, } pub type mach_vm_info_region_t = mach_vm_info_region; @@ -77,10 +77,14 @@ pub struct Struct_mach_port_status { pub mps_flags: natural_t, } impl ::std::clone::Clone for Struct_mach_port_status { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_mach_port_status { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type mach_port_status_t = Struct_mach_port_status; #[repr(C)] @@ -89,10 +93,14 @@ pub struct Struct_mach_port_limits { pub mpl_qlimit: mach_port_msgcount_t, } impl ::std::clone::Clone for Struct_mach_port_limits { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_mach_port_limits { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type mach_port_limits_t = Struct_mach_port_limits; pub type mach_port_info_t = *mut integer_t; @@ -105,10 +113,14 @@ pub struct Struct_mach_port_qos { pub len: natural_t, } impl ::std::clone::Clone for Struct_mach_port_qos { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_mach_port_qos { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type mach_port_qos_t = Struct_mach_port_qos; pub type pointer_t = vm_offset_t; @@ -137,10 +149,14 @@ pub struct Struct_Unnamed1 { pub _bindgen_bitfield_2_: mach_msg_descriptor_type_t, } impl ::std::clone::Clone for Struct_Unnamed1 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed1 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type mach_msg_type_descriptor_t = Struct_Unnamed1; #[repr(C)] @@ -153,10 +169,14 @@ pub struct Struct_Unnamed2 { pub type_: u8, } impl ::std::clone::Clone for Struct_Unnamed2 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed2 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type mach_msg_port_descriptor_t = Struct_Unnamed2; #[repr(C)] @@ -170,10 +190,14 @@ pub struct Struct_Unnamed3 { pub _bindgen_bitfield_4_: mach_msg_descriptor_type_t, } impl ::std::clone::Clone for Struct_Unnamed3 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed3 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type mach_msg_ool_descriptor32_t = Struct_Unnamed3; #[repr(C)] @@ -187,10 +211,14 @@ pub struct Struct_Unnamed4 { pub size: mach_msg_size_t, } impl ::std::clone::Clone for Struct_Unnamed4 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed4 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type mach_msg_ool_descriptor64_t = Struct_Unnamed4; #[repr(C)] @@ -204,10 +232,14 @@ pub struct Struct_Unnamed5 { pub size: mach_msg_size_t, } impl ::std::clone::Clone for Struct_Unnamed5 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed5 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type mach_msg_ool_descriptor_t = Struct_Unnamed5; #[repr(C)] @@ -221,10 +253,14 @@ pub struct Struct_Unnamed6 { pub _bindgen_bitfield_4_: mach_msg_descriptor_type_t, } impl ::std::clone::Clone for Struct_Unnamed6 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed6 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type mach_msg_ool_ports_descriptor32_t = Struct_Unnamed6; #[repr(C)] @@ -238,10 +274,14 @@ pub struct Struct_Unnamed7 { pub count: mach_msg_size_t, } impl ::std::clone::Clone for Struct_Unnamed7 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed7 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type mach_msg_ool_ports_descriptor64_t = Struct_Unnamed7; #[repr(C)] @@ -255,10 +295,14 @@ pub struct Struct_Unnamed8 { pub count: mach_msg_size_t, } impl ::std::clone::Clone for Struct_Unnamed8 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed8 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type mach_msg_ool_ports_descriptor_t = Struct_Unnamed8; #[repr(C)] @@ -275,8 +319,7 @@ impl Union_Unnamed9 { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn ool_ports(&mut self) - -> *mut mach_msg_ool_ports_descriptor_t { + pub unsafe fn ool_ports(&mut self) -> *mut mach_msg_ool_ports_descriptor_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } @@ -286,10 +329,14 @@ impl Union_Unnamed9 { } } impl ::std::clone::Clone for Union_Unnamed9 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Union_Unnamed9 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type mach_msg_descriptor_t = Union_Unnamed9; #[repr(C)] @@ -298,10 +345,14 @@ pub struct Struct_Unnamed10 { pub msgh_descriptor_count: mach_msg_size_t, } impl ::std::clone::Clone for Struct_Unnamed10 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed10 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type mach_msg_body_t = Struct_Unnamed10; #[repr(C)] @@ -315,10 +366,14 @@ pub struct Struct_Unnamed11 { pub msgh_id: mach_msg_id_t, } impl ::std::clone::Clone for Struct_Unnamed11 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed11 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type mach_msg_header_t = Struct_Unnamed11; #[repr(C)] @@ -328,10 +383,14 @@ pub struct Struct_Unnamed12 { pub body: mach_msg_body_t, } impl ::std::clone::Clone for Struct_Unnamed12 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed12 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type mach_msg_base_t = Struct_Unnamed12; pub type mach_msg_trailer_type_t = ::libc::c_uint; @@ -343,10 +402,14 @@ pub struct Struct_Unnamed13 { pub msgh_trailer_size: mach_msg_trailer_size_t, } impl ::std::clone::Clone for Struct_Unnamed13 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed13 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type mach_msg_trailer_t = Struct_Unnamed13; #[repr(C)] @@ -357,10 +420,14 @@ pub struct Struct_Unnamed14 { pub msgh_seqno: mach_port_seqno_t, } impl ::std::clone::Clone for Struct_Unnamed14 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed14 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type mach_msg_seqno_trailer_t = Struct_Unnamed14; #[repr(C)] @@ -369,10 +436,14 @@ pub struct Struct_Unnamed15 { pub val: [::libc::c_uint; 2usize], } impl ::std::clone::Clone for Struct_Unnamed15 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed15 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type security_token_t = Struct_Unnamed15; #[repr(C)] @@ -384,10 +455,14 @@ pub struct Struct_Unnamed16 { pub msgh_sender: security_token_t, } impl ::std::clone::Clone for Struct_Unnamed16 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed16 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type mach_msg_security_trailer_t = Struct_Unnamed16; #[repr(C)] @@ -396,10 +471,14 @@ pub struct Struct_Unnamed17 { pub val: [::libc::c_uint; 8usize], } impl ::std::clone::Clone for Struct_Unnamed17 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed17 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type audit_token_t = Struct_Unnamed17; #[repr(C)] @@ -412,10 +491,14 @@ pub struct Struct_Unnamed18 { pub msgh_audit: audit_token_t, } impl ::std::clone::Clone for Struct_Unnamed18 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed18 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type mach_msg_audit_trailer_t = Struct_Unnamed18; #[repr(C)] @@ -429,10 +512,14 @@ pub struct Struct_Unnamed19 { pub msgh_context: mach_port_context_t, } impl ::std::clone::Clone for Struct_Unnamed19 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed19 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type mach_msg_context_trailer_t = Struct_Unnamed19; #[repr(C)] @@ -441,10 +528,14 @@ pub struct Struct_Unnamed20 { pub sender: mach_port_name_t, } impl ::std::clone::Clone for Struct_Unnamed20 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed20 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type msg_labels_t = Struct_Unnamed20; #[repr(C)] @@ -460,10 +551,14 @@ pub struct Struct_Unnamed21 { pub msgh_labels: msg_labels_t, } impl ::std::clone::Clone for Struct_Unnamed21 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed21 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type mach_msg_mac_trailer_t = Struct_Unnamed21; pub type mach_msg_max_trailer_t = mach_msg_mac_trailer_t; @@ -475,10 +570,14 @@ pub struct Struct_Unnamed22 { pub header: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed22 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed22 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type mach_msg_empty_send_t = Struct_Unnamed22; #[repr(C)] @@ -488,10 +587,14 @@ pub struct Struct_Unnamed23 { pub trailer: mach_msg_trailer_t, } impl ::std::clone::Clone for Struct_Unnamed23 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed23 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type mach_msg_empty_rcv_t = Struct_Unnamed23; #[repr(C)] @@ -510,10 +613,14 @@ impl Union_Unnamed24 { } } impl ::std::clone::Clone for Union_Unnamed24 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Union_Unnamed24 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type mach_msg_empty_t = Union_Unnamed24; pub type mach_msg_type_size_t = natural_t; @@ -540,10 +647,14 @@ pub struct Struct_vm_statistics { pub speculative_count: natural_t, } impl ::std::clone::Clone for Struct_vm_statistics { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_vm_statistics { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type vm_statistics_t = *mut Struct_vm_statistics; pub type vm_statistics_data_t = Struct_vm_statistics; @@ -567,10 +678,14 @@ pub struct Struct_vm_statistics64 { pub speculative_count: natural_t, } impl ::std::clone::Clone for Struct_vm_statistics64 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_vm_statistics64 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type vm_statistics64_t = *mut Struct_vm_statistics64; pub type vm_statistics64_data_t = Struct_vm_statistics64; @@ -585,10 +700,14 @@ pub struct Struct_vm_extmod_statistics { pub thread_set_state_caller_count: int64_t, } impl ::std::clone::Clone for Struct_vm_extmod_statistics { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_vm_extmod_statistics { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type vm_extmod_statistics_t = *mut Struct_vm_extmod_statistics; pub type vm_extmod_statistics_data_t = Struct_vm_extmod_statistics; @@ -602,10 +721,14 @@ pub struct Struct_time_value { pub microseconds: integer_t, } impl ::std::clone::Clone for Struct_time_value { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_time_value { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type time_value_t = Struct_time_value; pub type host_info_t = *mut integer_t; @@ -630,10 +753,14 @@ pub struct Struct_host_basic_info { pub max_mem: uint64_t, } impl ::std::clone::Clone for Struct_host_basic_info { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_host_basic_info { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type host_basic_info_data_t = Struct_host_basic_info; pub type host_basic_info_t = *mut Struct_host_basic_info; @@ -644,10 +771,14 @@ pub struct Struct_host_sched_info { pub min_quantum: integer_t, } impl ::std::clone::Clone for Struct_host_sched_info { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_host_sched_info { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type host_sched_info_data_t = Struct_host_sched_info; pub type host_sched_info_t = *mut Struct_host_sched_info; @@ -661,10 +792,14 @@ pub struct Struct_kernel_resource_sizes { pub memory_object: natural_t, } impl ::std::clone::Clone for Struct_kernel_resource_sizes { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_kernel_resource_sizes { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type kernel_resource_sizes_data_t = Struct_kernel_resource_sizes; pub type kernel_resource_sizes_t = *mut Struct_kernel_resource_sizes; @@ -681,10 +816,14 @@ pub struct Struct_host_priority_info { pub maximum_priority: integer_t, } impl ::std::clone::Clone for Struct_host_priority_info { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_host_priority_info { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type host_priority_info_data_t = Struct_host_priority_info; pub type host_priority_info_t = *mut Struct_host_priority_info; @@ -695,10 +834,14 @@ pub struct Struct_host_load_info { pub mach_factor: [integer_t; 3usize], } impl ::std::clone::Clone for Struct_host_load_info { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_host_load_info { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type host_load_info_data_t = Struct_host_load_info; pub type host_load_info_t = *mut Struct_host_load_info; @@ -708,10 +851,14 @@ pub struct Struct_host_cpu_load_info { pub cpu_ticks: [natural_t; 4usize], } impl ::std::clone::Clone for Struct_host_cpu_load_info { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_host_cpu_load_info { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type host_cpu_load_info_data_t = Struct_host_cpu_load_info; pub type host_cpu_load_info_t = *mut Struct_host_cpu_load_info; @@ -739,10 +886,14 @@ pub struct Struct_memory_object_perf_info { pub may_cache: boolean_t, } impl ::std::clone::Clone for Struct_memory_object_perf_info { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_memory_object_perf_info { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -753,10 +904,14 @@ pub struct Struct_memory_object_attr_info { pub temporary: boolean_t, } impl ::std::clone::Clone for Struct_memory_object_attr_info { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_memory_object_attr_info { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -768,10 +923,14 @@ pub struct Struct_memory_object_behave_info { pub advisory_pageout: boolean_t, } impl ::std::clone::Clone for Struct_memory_object_behave_info { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_memory_object_behave_info { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type memory_object_behave_info_t = *mut Struct_memory_object_behave_info; pub type memory_object_behave_info_data_t = Struct_memory_object_behave_info; @@ -800,10 +959,14 @@ pub struct Struct___darwin_i386_thread_state { pub __gs: ::libc::c_uint, } impl ::std::clone::Clone for Struct___darwin_i386_thread_state { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct___darwin_i386_thread_state { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -811,10 +974,14 @@ pub struct Struct___darwin_fp_control { pub _bindgen_bitfield_1_: ::libc::c_ushort, } impl ::std::clone::Clone for Struct___darwin_fp_control { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct___darwin_fp_control { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __darwin_fp_control_t = Struct___darwin_fp_control; #[repr(C)] @@ -823,10 +990,14 @@ pub struct Struct___darwin_fp_status { pub _bindgen_bitfield_1_: ::libc::c_ushort, } impl ::std::clone::Clone for Struct___darwin_fp_status { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct___darwin_fp_status { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __darwin_fp_status_t = Struct___darwin_fp_status; #[repr(C)] @@ -836,10 +1007,14 @@ pub struct Struct___darwin_mmst_reg { pub __mmst_rsrv: [::libc::c_char; 6usize], } impl ::std::clone::Clone for Struct___darwin_mmst_reg { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct___darwin_mmst_reg { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -847,10 +1022,14 @@ pub struct Struct___darwin_xmm_reg { pub __xmm_reg: [::libc::c_char; 16usize], } impl ::std::clone::Clone for Struct___darwin_xmm_reg { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct___darwin_xmm_reg { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -889,10 +1068,14 @@ pub struct Struct___darwin_i386_float_state { pub __fpu_reserved1: ::libc::c_int, } impl ::std::clone::Clone for Struct___darwin_i386_float_state { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct___darwin_i386_float_state { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -940,10 +1123,14 @@ pub struct Struct___darwin_i386_avx_state { pub __fpu_ymmh7: Struct___darwin_xmm_reg, } impl ::std::clone::Clone for Struct___darwin_i386_avx_state { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct___darwin_i386_avx_state { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -954,10 +1141,14 @@ pub struct Struct___darwin_i386_exception_state { pub __faultvaddr: __uint32_t, } impl ::std::clone::Clone for Struct___darwin_i386_exception_state { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct___darwin_i386_exception_state { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -972,10 +1163,14 @@ pub struct Struct___darwin_x86_debug_state32 { pub __dr7: ::libc::c_uint, } impl ::std::clone::Clone for Struct___darwin_x86_debug_state32 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct___darwin_x86_debug_state32 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -1003,10 +1198,14 @@ pub struct Struct___darwin_x86_thread_state64 { pub __gs: __uint64_t, } impl ::std::clone::Clone for Struct___darwin_x86_thread_state64 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct___darwin_x86_thread_state64 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -1053,10 +1252,14 @@ pub struct Struct___darwin_x86_float_state64 { pub __fpu_reserved1: ::libc::c_int, } impl ::std::clone::Clone for Struct___darwin_x86_float_state64 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct___darwin_x86_float_state64 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -1120,10 +1323,14 @@ pub struct Struct___darwin_x86_avx_state64 { pub __fpu_ymmh15: Struct___darwin_xmm_reg, } impl ::std::clone::Clone for Struct___darwin_x86_avx_state64 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct___darwin_x86_avx_state64 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -1134,10 +1341,14 @@ pub struct Struct___darwin_x86_exception_state64 { pub __faultvaddr: __uint64_t, } impl ::std::clone::Clone for Struct___darwin_x86_exception_state64 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct___darwin_x86_exception_state64 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -1152,10 +1363,14 @@ pub struct Struct___darwin_x86_debug_state64 { pub __dr7: __uint64_t, } impl ::std::clone::Clone for Struct___darwin_x86_debug_state64 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct___darwin_x86_debug_state64 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -1164,10 +1379,14 @@ pub struct Struct_x86_state_hdr { pub count: ::libc::c_int, } impl ::std::clone::Clone for Struct_x86_state_hdr { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_x86_state_hdr { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type x86_state_hdr_t = Struct_x86_state_hdr; pub type i386_thread_state_t = Struct___darwin_i386_thread_state; @@ -1190,10 +1409,14 @@ pub struct Struct_x86_thread_state { pub uts: Union_Unnamed25, } impl ::std::clone::Clone for Struct_x86_thread_state { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_x86_thread_state { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -1211,10 +1434,14 @@ impl Union_Unnamed25 { } } impl ::std::clone::Clone for Union_Unnamed25 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Union_Unnamed25 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -1223,10 +1450,14 @@ pub struct Struct_x86_float_state { pub ufs: Union_Unnamed26, } impl ::std::clone::Clone for Struct_x86_float_state { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_x86_float_state { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -1244,10 +1475,14 @@ impl Union_Unnamed26 { } } impl ::std::clone::Clone for Union_Unnamed26 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Union_Unnamed26 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -1256,10 +1491,14 @@ pub struct Struct_x86_exception_state { pub ues: Union_Unnamed27, } impl ::std::clone::Clone for Struct_x86_exception_state { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_x86_exception_state { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -1277,10 +1516,14 @@ impl Union_Unnamed27 { } } impl ::std::clone::Clone for Union_Unnamed27 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Union_Unnamed27 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -1289,10 +1532,14 @@ pub struct Struct_x86_debug_state { pub uds: Union_Unnamed28, } impl ::std::clone::Clone for Struct_x86_debug_state { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_x86_debug_state { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -1310,10 +1557,14 @@ impl Union_Unnamed28 { } } impl ::std::clone::Clone for Union_Unnamed28 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Union_Unnamed28 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -1322,10 +1573,14 @@ pub struct Struct_x86_avx_state { pub ufs: Union_Unnamed29, } impl ::std::clone::Clone for Struct_x86_avx_state { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_x86_avx_state { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -1343,10 +1598,14 @@ impl Union_Unnamed29 { } } impl ::std::clone::Clone for Union_Unnamed29 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Union_Unnamed29 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type x86_thread_state_t = Struct_x86_thread_state; pub type x86_float_state_t = Struct_x86_float_state; @@ -1364,10 +1623,14 @@ pub struct Struct_x86_seg_load_fault32 { pub efl: uint32_t, } impl ::std::clone::Clone for Struct_x86_seg_load_fault32 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_x86_seg_load_fault32 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type thread_state_t = *mut natural_t; pub type thread_state_data_t = [natural_t; 224usize]; @@ -1402,10 +1665,14 @@ pub struct Struct_processor_basic_info { pub is_master: boolean_t, } impl ::std::clone::Clone for Struct_processor_basic_info { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_processor_basic_info { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type processor_basic_info_data_t = Struct_processor_basic_info; pub type processor_basic_info_t = *mut Struct_processor_basic_info; @@ -1415,10 +1682,14 @@ pub struct Struct_processor_cpu_load_info { pub cpu_ticks: [::libc::c_uint; 4usize], } impl ::std::clone::Clone for Struct_processor_cpu_load_info { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_processor_cpu_load_info { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type processor_cpu_load_info_data_t = Struct_processor_cpu_load_info; pub type processor_cpu_load_info_t = *mut Struct_processor_cpu_load_info; @@ -1430,10 +1701,14 @@ pub struct Struct_processor_set_basic_info { pub default_policy: ::libc::c_int, } impl ::std::clone::Clone for Struct_processor_set_basic_info { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_processor_set_basic_info { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type processor_set_basic_info_data_t = Struct_processor_set_basic_info; pub type processor_set_basic_info_t = *mut Struct_processor_set_basic_info; @@ -1446,10 +1721,14 @@ pub struct Struct_processor_set_load_info { pub mach_factor: integer_t, } impl ::std::clone::Clone for Struct_processor_set_load_info { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_processor_set_load_info { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type processor_set_load_info_data_t = Struct_processor_set_load_info; pub type processor_set_load_info_t = *mut Struct_processor_set_load_info; @@ -1463,10 +1742,14 @@ pub struct Struct_policy_timeshare_base { pub base_priority: integer_t, } impl ::std::clone::Clone for Struct_policy_timeshare_base { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_policy_timeshare_base { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -1474,10 +1757,14 @@ pub struct Struct_policy_timeshare_limit { pub max_priority: integer_t, } impl ::std::clone::Clone for Struct_policy_timeshare_limit { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_policy_timeshare_limit { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -1489,10 +1776,14 @@ pub struct Struct_policy_timeshare_info { pub depress_priority: integer_t, } impl ::std::clone::Clone for Struct_policy_timeshare_info { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_policy_timeshare_info { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type policy_timeshare_base_t = *mut Struct_policy_timeshare_base; pub type policy_timeshare_limit_t = *mut Struct_policy_timeshare_limit; @@ -1507,10 +1798,14 @@ pub struct Struct_policy_rr_base { pub quantum: integer_t, } impl ::std::clone::Clone for Struct_policy_rr_base { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_policy_rr_base { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -1518,10 +1813,14 @@ pub struct Struct_policy_rr_limit { pub max_priority: integer_t, } impl ::std::clone::Clone for Struct_policy_rr_limit { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_policy_rr_limit { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -1533,10 +1832,14 @@ pub struct Struct_policy_rr_info { pub depress_priority: integer_t, } impl ::std::clone::Clone for Struct_policy_rr_info { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_policy_rr_info { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type policy_rr_base_t = *mut Struct_policy_rr_base; pub type policy_rr_limit_t = *mut Struct_policy_rr_limit; @@ -1550,10 +1853,14 @@ pub struct Struct_policy_fifo_base { pub base_priority: integer_t, } impl ::std::clone::Clone for Struct_policy_fifo_base { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_policy_fifo_base { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -1561,10 +1868,14 @@ pub struct Struct_policy_fifo_limit { pub max_priority: integer_t, } impl ::std::clone::Clone for Struct_policy_fifo_limit { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_policy_fifo_limit { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -1575,10 +1886,14 @@ pub struct Struct_policy_fifo_info { pub depress_priority: integer_t, } impl ::std::clone::Clone for Struct_policy_fifo_info { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_policy_fifo_info { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type policy_fifo_base_t = *mut Struct_policy_fifo_base; pub type policy_fifo_limit_t = *mut Struct_policy_fifo_limit; @@ -1594,10 +1909,14 @@ pub struct Struct_policy_bases { pub fifo: policy_fifo_base_data_t, } impl ::std::clone::Clone for Struct_policy_bases { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_policy_bases { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -1607,10 +1926,14 @@ pub struct Struct_policy_limits { pub fifo: policy_fifo_limit_data_t, } impl ::std::clone::Clone for Struct_policy_limits { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_policy_limits { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -1620,10 +1943,14 @@ pub struct Struct_policy_infos { pub fifo: policy_fifo_info_data_t, } impl ::std::clone::Clone for Struct_policy_infos { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_policy_infos { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type policy_base_data_t = Struct_policy_bases; pub type policy_limit_data_t = Struct_policy_limits; @@ -1642,10 +1969,14 @@ pub struct Struct_task_basic_info_32 { pub policy: policy_t, } impl ::std::clone::Clone for Struct_task_basic_info_32 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_task_basic_info_32 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type task_basic_info_32_data_t = Struct_task_basic_info_32; pub type task_basic_info_32_t = *mut Struct_task_basic_info_32; @@ -1660,10 +1991,14 @@ pub struct Struct_task_basic_info_64 { pub policy: policy_t, } impl ::std::clone::Clone for Struct_task_basic_info_64 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_task_basic_info_64 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type task_basic_info_64_data_t = Struct_task_basic_info_64; pub type task_basic_info_64_t = *mut Struct_task_basic_info_64; @@ -1678,10 +2013,14 @@ pub struct Struct_task_basic_info { pub policy: policy_t, } impl ::std::clone::Clone for Struct_task_basic_info { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_task_basic_info { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type task_basic_info_data_t = Struct_task_basic_info; pub type task_basic_info_t = *mut Struct_task_basic_info; @@ -1698,10 +2037,14 @@ pub struct Struct_task_events_info { pub csw: integer_t, } impl ::std::clone::Clone for Struct_task_events_info { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_task_events_info { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type task_events_info_data_t = Struct_task_events_info; pub type task_events_info_t = *mut Struct_task_events_info; @@ -1712,10 +2055,14 @@ pub struct Struct_task_thread_times_info { pub system_time: time_value_t, } impl ::std::clone::Clone for Struct_task_thread_times_info { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_task_thread_times_info { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type task_thread_times_info_data_t = Struct_task_thread_times_info; pub type task_thread_times_info_t = *mut Struct_task_thread_times_info; @@ -1728,10 +2075,14 @@ pub struct Struct_task_absolutetime_info { pub threads_system: uint64_t, } impl ::std::clone::Clone for Struct_task_absolutetime_info { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_task_absolutetime_info { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type task_absolutetime_info_data_t = Struct_task_absolutetime_info; pub type task_absolutetime_info_t = *mut Struct_task_absolutetime_info; @@ -1744,10 +2095,14 @@ pub struct Struct_task_kernelmemory_info { pub total_sfree: uint64_t, } impl ::std::clone::Clone for Struct_task_kernelmemory_info { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_task_kernelmemory_info { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type task_kernelmemory_info_data_t = Struct_task_kernelmemory_info; pub type task_kernelmemory_info_t = *mut Struct_task_kernelmemory_info; @@ -1760,10 +2115,14 @@ pub struct Struct_task_affinity_tag_info { pub task_count: integer_t, } impl ::std::clone::Clone for Struct_task_affinity_tag_info { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_task_affinity_tag_info { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type task_affinity_tag_info_data_t = Struct_task_affinity_tag_info; pub type task_affinity_tag_info_t = *mut Struct_task_affinity_tag_info; @@ -1775,10 +2134,14 @@ pub struct Struct_task_dyld_info { pub all_image_info_format: integer_t, } impl ::std::clone::Clone for Struct_task_dyld_info { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_task_dyld_info { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type task_dyld_info_data_t = Struct_task_dyld_info; pub type task_dyld_info_t = *mut Struct_task_dyld_info; @@ -1789,10 +2152,14 @@ pub struct Struct_task_extmod_info { pub extmod_statistics: vm_extmod_statistics_data_t, } impl ::std::clone::Clone for Struct_task_extmod_info { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_task_extmod_info { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type task_extmod_info_data_t = Struct_task_extmod_info; pub type task_extmod_info_t = *mut Struct_task_extmod_info; @@ -1807,10 +2174,14 @@ pub struct Struct_task_power_info { pub task_timer_wakeups_bin_2: uint64_t, } impl ::std::clone::Clone for Struct_task_power_info { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_task_power_info { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type task_power_info_data_t = Struct_task_power_info; pub type task_power_info_t = *mut Struct_task_power_info; @@ -1826,10 +2197,14 @@ pub struct Struct_mach_task_basic_info { pub suspend_count: integer_t, } impl ::std::clone::Clone for Struct_mach_task_basic_info { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_mach_task_basic_info { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type mach_task_basic_info_data_t = Struct_mach_task_basic_info; pub type mach_task_basic_info_t = *mut Struct_mach_task_basic_info; @@ -1852,10 +2227,14 @@ pub struct Struct_task_category_policy { pub role: task_role_t, } impl ::std::clone::Clone for Struct_task_category_policy { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_task_category_policy { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type task_category_policy_data_t = Struct_task_category_policy; pub type task_category_policy_t = *mut Struct_task_category_policy; @@ -1876,10 +2255,14 @@ pub struct Struct_thread_basic_info { pub sleep_time: integer_t, } impl ::std::clone::Clone for Struct_thread_basic_info { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_thread_basic_info { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type thread_basic_info_data_t = Struct_thread_basic_info; pub type thread_basic_info_t = *mut Struct_thread_basic_info; @@ -1891,10 +2274,14 @@ pub struct Struct_thread_identifier_info { pub dispatch_qaddr: uint64_t, } impl ::std::clone::Clone for Struct_thread_identifier_info { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_thread_identifier_info { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type thread_identifier_info_data_t = Struct_thread_identifier_info; pub type thread_identifier_info_t = *mut Struct_thread_identifier_info; @@ -1906,10 +2293,14 @@ pub struct Struct_thread_standard_policy { pub no_data: natural_t, } impl ::std::clone::Clone for Struct_thread_standard_policy { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_thread_standard_policy { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type thread_standard_policy_data_t = Struct_thread_standard_policy; pub type thread_standard_policy_t = *mut Struct_thread_standard_policy; @@ -1919,10 +2310,14 @@ pub struct Struct_thread_extended_policy { pub timeshare: boolean_t, } impl ::std::clone::Clone for Struct_thread_extended_policy { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_thread_extended_policy { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type thread_extended_policy_data_t = Struct_thread_extended_policy; pub type thread_extended_policy_t = *mut Struct_thread_extended_policy; @@ -1935,25 +2330,31 @@ pub struct Struct_thread_time_constraint_policy { pub preemptible: boolean_t, } impl ::std::clone::Clone for Struct_thread_time_constraint_policy { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_thread_time_constraint_policy { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } -pub type thread_time_constraint_policy_data_t = - Struct_thread_time_constraint_policy; -pub type thread_time_constraint_policy_t = - *mut Struct_thread_time_constraint_policy; +pub type thread_time_constraint_policy_data_t = Struct_thread_time_constraint_policy; +pub type thread_time_constraint_policy_t = *mut Struct_thread_time_constraint_policy; #[repr(C)] #[derive(Copy)] pub struct Struct_thread_precedence_policy { pub importance: integer_t, } impl ::std::clone::Clone for Struct_thread_precedence_policy { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_thread_precedence_policy { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type thread_precedence_policy_data_t = Struct_thread_precedence_policy; pub type thread_precedence_policy_t = *mut Struct_thread_precedence_policy; @@ -1963,10 +2364,14 @@ pub struct Struct_thread_affinity_policy { pub affinity_tag: integer_t, } impl ::std::clone::Clone for Struct_thread_affinity_policy { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_thread_affinity_policy { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type thread_affinity_policy_data_t = Struct_thread_affinity_policy; pub type thread_affinity_policy_t = *mut Struct_thread_affinity_policy; @@ -1976,10 +2381,14 @@ pub struct Struct_thread_background_policy { pub priority: integer_t, } impl ::std::clone::Clone for Struct_thread_background_policy { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_thread_background_policy { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type thread_background_policy_data_t = Struct_thread_background_policy; pub type thread_background_policy_t = *mut Struct_thread_background_policy; @@ -1996,10 +2405,14 @@ pub struct Struct_mach_timespec { pub tv_nsec: clock_res_t, } impl ::std::clone::Clone for Struct_mach_timespec { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_mach_timespec { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type mach_timespec_t = Struct_mach_timespec; pub type vm_machine_attribute_t = ::libc::c_uint; @@ -2027,10 +2440,14 @@ pub struct Struct_vm_region_basic_info_64 { pub user_wired_count: ::libc::c_ushort, } impl ::std::clone::Clone for Struct_vm_region_basic_info_64 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_vm_region_basic_info_64 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type vm_region_basic_info_64_t = *mut Struct_vm_region_basic_info_64; pub type vm_region_basic_info_data_64_t = Struct_vm_region_basic_info_64; @@ -2047,10 +2464,14 @@ pub struct Struct_vm_region_basic_info { pub user_wired_count: ::libc::c_ushort, } impl ::std::clone::Clone for Struct_vm_region_basic_info { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_vm_region_basic_info { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type vm_region_basic_info_t = *mut Struct_vm_region_basic_info; pub type vm_region_basic_info_data_t = Struct_vm_region_basic_info; @@ -2069,10 +2490,14 @@ pub struct Struct_vm_region_extended_info { pub share_mode: ::libc::c_uchar, } impl ::std::clone::Clone for Struct_vm_region_extended_info { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_vm_region_extended_info { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type vm_region_extended_info_t = *mut Struct_vm_region_extended_info; pub type vm_region_extended_info_data_t = Struct_vm_region_extended_info; @@ -2086,10 +2511,14 @@ pub struct Struct_vm_region_top_info { pub share_mode: ::libc::c_uchar, } impl ::std::clone::Clone for Struct_vm_region_top_info { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_vm_region_top_info { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type vm_region_top_info_t = *mut Struct_vm_region_top_info; pub type vm_region_top_info_data_t = Struct_vm_region_top_info; @@ -2115,10 +2544,14 @@ pub struct Struct_vm_region_submap_info { pub user_wired_count: ::libc::c_ushort, } impl ::std::clone::Clone for Struct_vm_region_submap_info { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_vm_region_submap_info { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type vm_region_submap_info_t = *mut Struct_vm_region_submap_info; pub type vm_region_submap_info_data_t = Struct_vm_region_submap_info; @@ -2144,10 +2577,14 @@ pub struct Struct_vm_region_submap_info_64 { pub user_wired_count: ::libc::c_ushort, } impl ::std::clone::Clone for Struct_vm_region_submap_info_64 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_vm_region_submap_info_64 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type vm_region_submap_info_64_t = *mut Struct_vm_region_submap_info_64; pub type vm_region_submap_info_data_64_t = Struct_vm_region_submap_info_64; @@ -2169,15 +2606,17 @@ pub struct Struct_vm_region_submap_short_info_64 { pub user_wired_count: ::libc::c_ushort, } impl ::std::clone::Clone for Struct_vm_region_submap_short_info_64 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_vm_region_submap_short_info_64 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } -pub type vm_region_submap_short_info_64_t = - *mut Struct_vm_region_submap_short_info_64; -pub type vm_region_submap_short_info_data_64_t = - Struct_vm_region_submap_short_info_64; +pub type vm_region_submap_short_info_64_t = *mut Struct_vm_region_submap_short_info_64; +pub type vm_region_submap_short_info_data_64_t = Struct_vm_region_submap_short_info_64; #[repr(C)] #[derive(Copy)] pub struct Struct_mach_vm_read_entry { @@ -2185,10 +2624,14 @@ pub struct Struct_mach_vm_read_entry { pub size: mach_vm_size_t, } impl ::std::clone::Clone for Struct_mach_vm_read_entry { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_mach_vm_read_entry { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -2197,10 +2640,14 @@ pub struct Struct_vm_read_entry { pub size: vm_size_t, } impl ::std::clone::Clone for Struct_vm_read_entry { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_vm_read_entry { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type mach_vm_read_entry_t = [Struct_mach_vm_read_entry; 256usize]; pub type vm_read_entry_t = [Struct_vm_read_entry; 256usize]; @@ -2218,20 +2665,22 @@ pub struct Struct_vm_page_info_basic { pub __pad: ::libc::c_int, } impl ::std::clone::Clone for Struct_vm_page_info_basic { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_vm_page_info_basic { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type vm_page_info_basic_t = *mut Struct_vm_page_info_basic; pub type vm_page_info_basic_data_t = Struct_vm_page_info_basic; pub type kmod_t = ::libc::c_int; -pub type kmod_start_func_t = - extern "C" fn(ki: *mut Struct_kmod_info, data: *mut ::libc::c_void) - -> kern_return_t; -pub type kmod_stop_func_t = - extern "C" fn(ki: *mut Struct_kmod_info, data: *mut ::libc::c_void) - -> kern_return_t; +pub type kmod_start_func_t = extern "C" fn(ki: *mut Struct_kmod_info, data: *mut ::libc::c_void) + -> kern_return_t; +pub type kmod_stop_func_t = extern "C" fn(ki: *mut Struct_kmod_info, data: *mut ::libc::c_void) + -> kern_return_t; #[repr(C)] #[derive(Copy)] pub struct Struct_kmod_reference { @@ -2239,10 +2688,14 @@ pub struct Struct_kmod_reference { pub info: *mut Struct_kmod_info, } impl ::std::clone::Clone for Struct_kmod_reference { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_kmod_reference { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type kmod_reference_t = Struct_kmod_reference; #[repr(C)] @@ -2262,10 +2715,14 @@ pub struct Struct_kmod_info { pub stop: *mut ::std::option::Option kern_return_t>, } impl ::std::clone::Clone for Struct_kmod_info { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_kmod_info { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type kmod_info_t = Struct_kmod_info; #[repr(C)] @@ -2285,10 +2742,14 @@ pub struct Struct_kmod_info_32_v1 { pub stop_addr: uint32_t, } impl ::std::clone::Clone for Struct_kmod_info_32_v1 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_kmod_info_32_v1 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type kmod_info_32_v1_t = Struct_kmod_info_32_v1; #[repr(C)] @@ -2308,10 +2769,14 @@ pub struct Struct_kmod_info_64_v1 { pub stop_addr: uint64_t, } impl ::std::clone::Clone for Struct_kmod_info_64_v1 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_kmod_info_64_v1 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type kmod_info_64_v1_t = Struct_kmod_info_64_v1; pub type kmod_args_t = *mut ::libc::c_void; @@ -2392,10 +2857,14 @@ pub struct Struct_Unnamed30 { pub reserved2: ::libc::c_uchar, } impl ::std::clone::Clone for Struct_Unnamed30 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed30 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type NDR_record_t = Struct_Unnamed30; pub type notify_port_t = mach_port_t; @@ -2408,10 +2877,14 @@ pub struct Struct_Unnamed31 { pub trailer: mach_msg_format_0_trailer_t, } impl ::std::clone::Clone for Struct_Unnamed31 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed31 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type mach_port_deleted_notification_t = Struct_Unnamed31; #[repr(C)] @@ -2423,10 +2896,14 @@ pub struct Struct_Unnamed32 { pub trailer: mach_msg_format_0_trailer_t, } impl ::std::clone::Clone for Struct_Unnamed32 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed32 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type mach_send_possible_notification_t = Struct_Unnamed32; #[repr(C)] @@ -2438,10 +2915,14 @@ pub struct Struct_Unnamed33 { pub trailer: mach_msg_format_0_trailer_t, } impl ::std::clone::Clone for Struct_Unnamed33 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed33 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type mach_port_destroyed_notification_t = Struct_Unnamed33; #[repr(C)] @@ -2453,10 +2934,14 @@ pub struct Struct_Unnamed34 { pub trailer: mach_msg_format_0_trailer_t, } impl ::std::clone::Clone for Struct_Unnamed34 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed34 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type mach_no_senders_notification_t = Struct_Unnamed34; #[repr(C)] @@ -2466,10 +2951,14 @@ pub struct Struct_Unnamed35 { pub trailer: mach_msg_format_0_trailer_t, } impl ::std::clone::Clone for Struct_Unnamed35 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed35 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type mach_send_once_notification_t = Struct_Unnamed35; #[repr(C)] @@ -2481,22 +2970,24 @@ pub struct Struct_Unnamed36 { pub trailer: mach_msg_format_0_trailer_t, } impl ::std::clone::Clone for Struct_Unnamed36 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed36 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type mach_dead_name_notification_t = Struct_Unnamed36; pub type mig_stub_routine_t = ::std::option::Option ()>; + OutHeadP: *mut mach_msg_header_t) + -> ()>; pub type mig_routine_t = mig_stub_routine_t; pub type mig_server_routine_t = - ::std::option::Option mig_routine_t>; -pub type mig_impl_routine_t = - ::std::option::Option kern_return_t>; + ::std::option::Option mig_routine_t>; +pub type mig_impl_routine_t = ::std::option::Option kern_return_t>; pub type routine_arg_descriptor = mach_msg_type_descriptor_t; pub type routine_arg_descriptor_t = *mut mach_msg_type_descriptor_t; pub type mig_routine_arg_descriptor_t = *mut mach_msg_type_descriptor_t; @@ -2511,10 +3002,14 @@ pub struct Struct_routine_descriptor { pub max_reply_msg: ::libc::c_uint, } impl ::std::clone::Clone for Struct_routine_descriptor { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_routine_descriptor { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type routine_descriptor_t = *mut Struct_routine_descriptor; pub type mig_routine_descriptor = Struct_routine_descriptor; @@ -2530,10 +3025,14 @@ pub struct Struct_mig_subsystem { pub routine: [mig_routine_descriptor; 1usize], } impl ::std::clone::Clone for Struct_mig_subsystem { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_mig_subsystem { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type mig_subsystem_t = *mut Struct_mig_subsystem; #[repr(C)] @@ -2544,10 +3043,14 @@ pub struct Struct_mig_symtab { pub ms_routine: ::std::option::Option ()>, } impl ::std::clone::Clone for Struct_mig_symtab { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_mig_symtab { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type mig_symtab_t = Struct_mig_symtab; #[repr(C)] @@ -2558,10 +3061,14 @@ pub struct Struct_Unnamed37 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed37 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed37 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type mig_reply_error_t = Struct_Unnamed37; #[repr(C)] @@ -2572,10 +3079,14 @@ pub struct Struct_Unnamed38 { pub new_time: mach_timespec_t, } impl ::std::clone::Clone for Struct_Unnamed38 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed38 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__clock_set_time_t = Struct_Unnamed38; #[repr(C)] @@ -2588,10 +3099,14 @@ pub struct Struct_Unnamed39 { pub clock_attr: [::libc::c_int; 1usize], } impl ::std::clone::Clone for Struct_Unnamed39 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed39 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__clock_set_attributes_t = Struct_Unnamed39; #[repr(C)] @@ -2600,22 +3115,24 @@ pub struct Union___RequestUnion__clock_priv_subsystem { pub _bindgen_data_: [u32; 11usize], } impl Union___RequestUnion__clock_priv_subsystem { - pub unsafe fn Request_clock_set_time(&mut self) - -> *mut __Request__clock_set_time_t { + pub unsafe fn Request_clock_set_time(&mut self) -> *mut __Request__clock_set_time_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_clock_set_attributes(&mut self) - -> *mut __Request__clock_set_attributes_t { + pub unsafe fn Request_clock_set_attributes(&mut self) -> *mut __Request__clock_set_attributes_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } } impl ::std::clone::Clone for Union___RequestUnion__clock_priv_subsystem { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Union___RequestUnion__clock_priv_subsystem { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -2625,10 +3142,14 @@ pub struct Struct_Unnamed40 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed40 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed40 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__clock_set_time_t = Struct_Unnamed40; #[repr(C)] @@ -2639,10 +3160,14 @@ pub struct Struct_Unnamed41 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed41 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed41 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__clock_set_attributes_t = Struct_Unnamed41; #[repr(C)] @@ -2651,22 +3176,24 @@ pub struct Union___ReplyUnion__clock_priv_subsystem { pub _bindgen_data_: [u32; 9usize], } impl Union___ReplyUnion__clock_priv_subsystem { - pub unsafe fn Reply_clock_set_time(&mut self) - -> *mut __Reply__clock_set_time_t { + pub unsafe fn Reply_clock_set_time(&mut self) -> *mut __Reply__clock_set_time_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_clock_set_attributes(&mut self) - -> *mut __Reply__clock_set_attributes_t { + pub unsafe fn Reply_clock_set_attributes(&mut self) -> *mut __Reply__clock_set_attributes_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } } impl ::std::clone::Clone for Union___ReplyUnion__clock_priv_subsystem { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Union___ReplyUnion__clock_priv_subsystem { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -2674,10 +3201,14 @@ pub struct Struct_Unnamed42 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed42 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed42 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__host_get_boot_info_t = Struct_Unnamed42; #[repr(C)] @@ -2688,10 +3219,14 @@ pub struct Struct_Unnamed43 { pub options: ::libc::c_int, } impl ::std::clone::Clone for Struct_Unnamed43 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed43 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__host_reboot_t = Struct_Unnamed43; #[repr(C)] @@ -2703,10 +3238,14 @@ pub struct Struct_Unnamed44 { pub host_info_outCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed44 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed44 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__host_priv_statistics_t = Struct_Unnamed44; #[repr(C)] @@ -2719,10 +3258,14 @@ pub struct Struct_Unnamed45 { pub cluster_size: memory_object_cluster_size_t, } impl ::std::clone::Clone for Struct_Unnamed45 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed45 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__host_default_memory_manager_t = Struct_Unnamed45; #[repr(C)] @@ -2737,10 +3280,14 @@ pub struct Struct_Unnamed46 { pub desired_access: vm_prot_t, } impl ::std::clone::Clone for Struct_Unnamed46 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed46 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__vm_wire_t = Struct_Unnamed46; #[repr(C)] @@ -2753,10 +3300,14 @@ pub struct Struct_Unnamed47 { pub wired: boolean_t, } impl ::std::clone::Clone for Struct_Unnamed47 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed47 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__thread_wire_t = Struct_Unnamed47; #[repr(C)] @@ -2771,10 +3322,14 @@ pub struct Struct_Unnamed48 { pub flags: ::libc::c_int, } impl ::std::clone::Clone for Struct_Unnamed48 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed48 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__vm_allocate_cpm_t = Struct_Unnamed48; #[repr(C)] @@ -2783,10 +3338,14 @@ pub struct Struct_Unnamed49 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed49 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed49 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__host_processors_t = Struct_Unnamed49; #[repr(C)] @@ -2797,10 +3356,14 @@ pub struct Struct_Unnamed50 { pub clock_id: clock_id_t, } impl ::std::clone::Clone for Struct_Unnamed50 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed50 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__host_get_clock_control_t = Struct_Unnamed50; #[repr(C)] @@ -2811,10 +3374,14 @@ pub struct Struct_Unnamed51 { pub info: vm_address_t, } impl ::std::clone::Clone for Struct_Unnamed51 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed51 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__kmod_create_t = Struct_Unnamed51; #[repr(C)] @@ -2825,10 +3392,14 @@ pub struct Struct_Unnamed52 { pub module: kmod_t, } impl ::std::clone::Clone for Struct_Unnamed52 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed52 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__kmod_destroy_t = Struct_Unnamed52; #[repr(C)] @@ -2843,10 +3414,14 @@ pub struct Struct_Unnamed53 { pub dataCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed53 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed53 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__kmod_control_t = Struct_Unnamed53; #[repr(C)] @@ -2858,10 +3433,14 @@ pub struct Struct_Unnamed54 { pub which: ::libc::c_int, } impl ::std::clone::Clone for Struct_Unnamed54 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed54 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__host_get_special_port_t = Struct_Unnamed54; #[repr(C)] @@ -2874,10 +3453,14 @@ pub struct Struct_Unnamed55 { pub which: ::libc::c_int, } impl ::std::clone::Clone for Struct_Unnamed55 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed55 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__host_set_special_port_t = Struct_Unnamed55; #[repr(C)] @@ -2892,10 +3475,14 @@ pub struct Struct_Unnamed56 { pub new_flavor: thread_state_flavor_t, } impl ::std::clone::Clone for Struct_Unnamed56 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed56 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__host_set_exception_ports_t = Struct_Unnamed56; #[repr(C)] @@ -2906,10 +3493,14 @@ pub struct Struct_Unnamed57 { pub exception_mask: exception_mask_t, } impl ::std::clone::Clone for Struct_Unnamed57 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed57 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__host_get_exception_ports_t = Struct_Unnamed57; #[repr(C)] @@ -2924,10 +3515,14 @@ pub struct Struct_Unnamed58 { pub new_flavor: thread_state_flavor_t, } impl ::std::clone::Clone for Struct_Unnamed58 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed58 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__host_swap_exception_ports_t = Struct_Unnamed58; #[repr(C)] @@ -2942,10 +3537,14 @@ pub struct Struct_Unnamed59 { pub desired_access: vm_prot_t, } impl ::std::clone::Clone for Struct_Unnamed59 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed59 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__mach_vm_wire_t = Struct_Unnamed59; #[repr(C)] @@ -2954,10 +3553,14 @@ pub struct Struct_Unnamed60 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed60 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed60 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__host_processor_sets_t = Struct_Unnamed60; #[repr(C)] @@ -2968,10 +3571,14 @@ pub struct Struct_Unnamed61 { pub set_name: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed61 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed61 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__host_processor_set_priv_t = Struct_Unnamed61; #[repr(C)] @@ -2982,10 +3589,14 @@ pub struct Struct_Unnamed62 { pub control_port: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed62 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed62 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__set_dp_control_port_t = Struct_Unnamed62; #[repr(C)] @@ -2994,10 +3605,14 @@ pub struct Struct_Unnamed63 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed63 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed63 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__get_dp_control_port_t = Struct_Unnamed63; #[repr(C)] @@ -3008,10 +3623,14 @@ pub struct Struct_Unnamed64 { pub server: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed64 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed64 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__host_set_UNDServer_t = Struct_Unnamed64; #[repr(C)] @@ -3020,10 +3639,14 @@ pub struct Struct_Unnamed65 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed65 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed65 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__host_get_UNDServer_t = Struct_Unnamed65; #[repr(C)] @@ -3037,10 +3660,14 @@ pub struct Struct_Unnamed66 { pub request_dataCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed66 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed66 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__kext_request_t = Struct_Unnamed66; #[repr(C)] @@ -3049,23 +3676,21 @@ pub struct Union___RequestUnion__host_priv_subsystem { pub _bindgen_data_: [u32; 17usize], } impl Union___RequestUnion__host_priv_subsystem { - pub unsafe fn Request_host_get_boot_info(&mut self) - -> *mut __Request__host_get_boot_info_t { + pub unsafe fn Request_host_get_boot_info(&mut self) -> *mut __Request__host_get_boot_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_host_reboot(&mut self) - -> *mut __Request__host_reboot_t { + pub unsafe fn Request_host_reboot(&mut self) -> *mut __Request__host_reboot_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_host_priv_statistics(&mut self) - -> *mut __Request__host_priv_statistics_t { + pub unsafe fn Request_host_priv_statistics(&mut self) -> *mut __Request__host_priv_statistics_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_host_default_memory_manager(&mut self) - -> *mut __Request__host_default_memory_manager_t { + pub unsafe fn Request_host_default_memory_manager + (&mut self) + -> *mut __Request__host_default_memory_manager_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } @@ -3073,112 +3698,104 @@ impl Union___RequestUnion__host_priv_subsystem { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_thread_wire(&mut self) - -> *mut __Request__thread_wire_t { + pub unsafe fn Request_thread_wire(&mut self) -> *mut __Request__thread_wire_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_vm_allocate_cpm(&mut self) - -> *mut __Request__vm_allocate_cpm_t { + pub unsafe fn Request_vm_allocate_cpm(&mut self) -> *mut __Request__vm_allocate_cpm_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_host_processors(&mut self) - -> *mut __Request__host_processors_t { + pub unsafe fn Request_host_processors(&mut self) -> *mut __Request__host_processors_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_host_get_clock_control(&mut self) - -> *mut __Request__host_get_clock_control_t { + -> *mut __Request__host_get_clock_control_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_kmod_create(&mut self) - -> *mut __Request__kmod_create_t { + pub unsafe fn Request_kmod_create(&mut self) -> *mut __Request__kmod_create_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_kmod_destroy(&mut self) - -> *mut __Request__kmod_destroy_t { + pub unsafe fn Request_kmod_destroy(&mut self) -> *mut __Request__kmod_destroy_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_kmod_control(&mut self) - -> *mut __Request__kmod_control_t { + pub unsafe fn Request_kmod_control(&mut self) -> *mut __Request__kmod_control_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_host_get_special_port(&mut self) - -> *mut __Request__host_get_special_port_t { + pub unsafe fn Request_host_get_special_port(&mut self) -> *mut __Request__host_get_special_port_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_host_set_special_port(&mut self) - -> *mut __Request__host_set_special_port_t { + pub unsafe fn Request_host_set_special_port(&mut self) -> *mut __Request__host_set_special_port_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_host_set_exception_ports(&mut self) - -> *mut __Request__host_set_exception_ports_t { + pub unsafe fn Request_host_set_exception_ports + (&mut self) + -> *mut __Request__host_set_exception_ports_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_host_get_exception_ports(&mut self) - -> *mut __Request__host_get_exception_ports_t { + pub unsafe fn Request_host_get_exception_ports + (&mut self) + -> *mut __Request__host_get_exception_ports_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_host_swap_exception_ports(&mut self) - -> *mut __Request__host_swap_exception_ports_t { + pub unsafe fn Request_host_swap_exception_ports + (&mut self) + -> *mut __Request__host_swap_exception_ports_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_mach_vm_wire(&mut self) - -> *mut __Request__mach_vm_wire_t { + pub unsafe fn Request_mach_vm_wire(&mut self) -> *mut __Request__mach_vm_wire_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_host_processor_sets(&mut self) - -> *mut __Request__host_processor_sets_t { + pub unsafe fn Request_host_processor_sets(&mut self) -> *mut __Request__host_processor_sets_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_host_processor_set_priv(&mut self) - -> *mut __Request__host_processor_set_priv_t { + -> *mut __Request__host_processor_set_priv_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_set_dp_control_port(&mut self) - -> *mut __Request__set_dp_control_port_t { + pub unsafe fn Request_set_dp_control_port(&mut self) -> *mut __Request__set_dp_control_port_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_get_dp_control_port(&mut self) - -> *mut __Request__get_dp_control_port_t { + pub unsafe fn Request_get_dp_control_port(&mut self) -> *mut __Request__get_dp_control_port_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_host_set_UNDServer(&mut self) - -> *mut __Request__host_set_UNDServer_t { + pub unsafe fn Request_host_set_UNDServer(&mut self) -> *mut __Request__host_set_UNDServer_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_host_get_UNDServer(&mut self) - -> *mut __Request__host_get_UNDServer_t { + pub unsafe fn Request_host_get_UNDServer(&mut self) -> *mut __Request__host_get_UNDServer_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_kext_request(&mut self) - -> *mut __Request__kext_request_t { + pub unsafe fn Request_kext_request(&mut self) -> *mut __Request__kext_request_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } } impl ::std::clone::Clone for Union___RequestUnion__host_priv_subsystem { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Union___RequestUnion__host_priv_subsystem { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -3191,10 +3808,14 @@ pub struct Struct_Unnamed67 { pub boot_info: [::libc::c_char; 4096usize], } impl ::std::clone::Clone for Struct_Unnamed67 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed67 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__host_get_boot_info_t = Struct_Unnamed67; #[repr(C)] @@ -3205,10 +3826,14 @@ pub struct Struct_Unnamed68 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed68 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed68 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__host_reboot_t = Struct_Unnamed68; #[repr(C)] @@ -3221,10 +3846,14 @@ pub struct Struct_Unnamed69 { pub host_info_out: [integer_t; 18usize], } impl ::std::clone::Clone for Struct_Unnamed69 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed69 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__host_priv_statistics_t = Struct_Unnamed69; #[repr(C)] @@ -3235,10 +3864,14 @@ pub struct Struct_Unnamed70 { pub default_manager: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed70 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed70 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__host_default_memory_manager_t = Struct_Unnamed70; #[repr(C)] @@ -3249,10 +3882,14 @@ pub struct Struct_Unnamed71 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed71 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed71 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__vm_wire_t = Struct_Unnamed71; #[repr(C)] @@ -3263,10 +3900,14 @@ pub struct Struct_Unnamed72 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed72 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed72 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__thread_wire_t = Struct_Unnamed72; #[repr(C)] @@ -3278,10 +3919,14 @@ pub struct Struct_Unnamed73 { pub address: vm_address_t, } impl ::std::clone::Clone for Struct_Unnamed73 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed73 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__vm_allocate_cpm_t = Struct_Unnamed73; #[repr(C)] @@ -3294,10 +3939,14 @@ pub struct Struct_Unnamed74 { pub out_processor_listCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed74 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed74 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__host_processors_t = Struct_Unnamed74; #[repr(C)] @@ -3308,10 +3957,14 @@ pub struct Struct_Unnamed75 { pub clock_ctrl: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed75 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed75 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__host_get_clock_control_t = Struct_Unnamed75; #[repr(C)] @@ -3323,10 +3976,14 @@ pub struct Struct_Unnamed76 { pub module: kmod_t, } impl ::std::clone::Clone for Struct_Unnamed76 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed76 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__kmod_create_t = Struct_Unnamed76; #[repr(C)] @@ -3337,10 +3994,14 @@ pub struct Struct_Unnamed77 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed77 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed77 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__kmod_destroy_t = Struct_Unnamed77; #[repr(C)] @@ -3353,10 +4014,14 @@ pub struct Struct_Unnamed78 { pub dataCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed78 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed78 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__kmod_control_t = Struct_Unnamed78; #[repr(C)] @@ -3367,10 +4032,14 @@ pub struct Struct_Unnamed79 { pub port: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed79 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed79 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__host_get_special_port_t = Struct_Unnamed79; #[repr(C)] @@ -3381,10 +4050,14 @@ pub struct Struct_Unnamed80 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed80 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed80 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__host_set_special_port_t = Struct_Unnamed80; #[repr(C)] @@ -3395,10 +4068,14 @@ pub struct Struct_Unnamed81 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed81 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed81 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__host_set_exception_ports_t = Struct_Unnamed81; #[repr(C)] @@ -3414,10 +4091,14 @@ pub struct Struct_Unnamed82 { pub old_flavors: [thread_state_flavor_t; 32usize], } impl ::std::clone::Clone for Struct_Unnamed82 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed82 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__host_get_exception_ports_t = Struct_Unnamed82; #[repr(C)] @@ -3433,10 +4114,14 @@ pub struct Struct_Unnamed83 { pub old_flavors: [thread_state_flavor_t; 32usize], } impl ::std::clone::Clone for Struct_Unnamed83 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed83 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__host_swap_exception_ports_t = Struct_Unnamed83; #[repr(C)] @@ -3447,10 +4132,14 @@ pub struct Struct_Unnamed84 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed84 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed84 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__mach_vm_wire_t = Struct_Unnamed84; #[repr(C)] @@ -3463,10 +4152,14 @@ pub struct Struct_Unnamed85 { pub processor_setsCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed85 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed85 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__host_processor_sets_t = Struct_Unnamed85; #[repr(C)] @@ -3477,10 +4170,14 @@ pub struct Struct_Unnamed86 { pub set: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed86 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed86 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__host_processor_set_priv_t = Struct_Unnamed86; #[repr(C)] @@ -3491,10 +4188,14 @@ pub struct Struct_Unnamed87 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed87 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed87 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__set_dp_control_port_t = Struct_Unnamed87; #[repr(C)] @@ -3505,10 +4206,14 @@ pub struct Struct_Unnamed88 { pub contorl_port: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed88 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed88 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__get_dp_control_port_t = Struct_Unnamed88; #[repr(C)] @@ -3519,10 +4224,14 @@ pub struct Struct_Unnamed89 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed89 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed89 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__host_set_UNDServer_t = Struct_Unnamed89; #[repr(C)] @@ -3533,10 +4242,14 @@ pub struct Struct_Unnamed90 { pub server: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed90 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed90 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__host_get_UNDServer_t = Struct_Unnamed90; #[repr(C)] @@ -3552,10 +4265,14 @@ pub struct Struct_Unnamed91 { pub op_result: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed91 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed91 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__kext_request_t = Struct_Unnamed91; #[repr(C)] @@ -3564,23 +4281,21 @@ pub struct Union___ReplyUnion__host_priv_subsystem { pub _bindgen_data_: [u32; 1035usize], } impl Union___ReplyUnion__host_priv_subsystem { - pub unsafe fn Reply_host_get_boot_info(&mut self) - -> *mut __Reply__host_get_boot_info_t { + pub unsafe fn Reply_host_get_boot_info(&mut self) -> *mut __Reply__host_get_boot_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_host_reboot(&mut self) - -> *mut __Reply__host_reboot_t { + pub unsafe fn Reply_host_reboot(&mut self) -> *mut __Reply__host_reboot_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_host_priv_statistics(&mut self) - -> *mut __Reply__host_priv_statistics_t { + pub unsafe fn Reply_host_priv_statistics(&mut self) -> *mut __Reply__host_priv_statistics_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_host_default_memory_manager(&mut self) - -> *mut __Reply__host_default_memory_manager_t { + pub unsafe fn Reply_host_default_memory_manager + (&mut self) + -> *mut __Reply__host_default_memory_manager_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } @@ -3588,112 +4303,99 @@ impl Union___ReplyUnion__host_priv_subsystem { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_thread_wire(&mut self) - -> *mut __Reply__thread_wire_t { + pub unsafe fn Reply_thread_wire(&mut self) -> *mut __Reply__thread_wire_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_vm_allocate_cpm(&mut self) - -> *mut __Reply__vm_allocate_cpm_t { + pub unsafe fn Reply_vm_allocate_cpm(&mut self) -> *mut __Reply__vm_allocate_cpm_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_host_processors(&mut self) - -> *mut __Reply__host_processors_t { + pub unsafe fn Reply_host_processors(&mut self) -> *mut __Reply__host_processors_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_host_get_clock_control(&mut self) - -> *mut __Reply__host_get_clock_control_t { + pub unsafe fn Reply_host_get_clock_control(&mut self) -> *mut __Reply__host_get_clock_control_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_kmod_create(&mut self) - -> *mut __Reply__kmod_create_t { + pub unsafe fn Reply_kmod_create(&mut self) -> *mut __Reply__kmod_create_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_kmod_destroy(&mut self) - -> *mut __Reply__kmod_destroy_t { + pub unsafe fn Reply_kmod_destroy(&mut self) -> *mut __Reply__kmod_destroy_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_kmod_control(&mut self) - -> *mut __Reply__kmod_control_t { + pub unsafe fn Reply_kmod_control(&mut self) -> *mut __Reply__kmod_control_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_host_get_special_port(&mut self) - -> *mut __Reply__host_get_special_port_t { + pub unsafe fn Reply_host_get_special_port(&mut self) -> *mut __Reply__host_get_special_port_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_host_set_special_port(&mut self) - -> *mut __Reply__host_set_special_port_t { + pub unsafe fn Reply_host_set_special_port(&mut self) -> *mut __Reply__host_set_special_port_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_host_set_exception_ports(&mut self) - -> *mut __Reply__host_set_exception_ports_t { + -> *mut __Reply__host_set_exception_ports_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_host_get_exception_ports(&mut self) - -> *mut __Reply__host_get_exception_ports_t { + -> *mut __Reply__host_get_exception_ports_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_host_swap_exception_ports(&mut self) - -> *mut __Reply__host_swap_exception_ports_t { + -> *mut __Reply__host_swap_exception_ports_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_mach_vm_wire(&mut self) - -> *mut __Reply__mach_vm_wire_t { + pub unsafe fn Reply_mach_vm_wire(&mut self) -> *mut __Reply__mach_vm_wire_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_host_processor_sets(&mut self) - -> *mut __Reply__host_processor_sets_t { + pub unsafe fn Reply_host_processor_sets(&mut self) -> *mut __Reply__host_processor_sets_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_host_processor_set_priv(&mut self) - -> *mut __Reply__host_processor_set_priv_t { + pub unsafe fn Reply_host_processor_set_priv(&mut self) -> *mut __Reply__host_processor_set_priv_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_set_dp_control_port(&mut self) - -> *mut __Reply__set_dp_control_port_t { + pub unsafe fn Reply_set_dp_control_port(&mut self) -> *mut __Reply__set_dp_control_port_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_get_dp_control_port(&mut self) - -> *mut __Reply__get_dp_control_port_t { + pub unsafe fn Reply_get_dp_control_port(&mut self) -> *mut __Reply__get_dp_control_port_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_host_set_UNDServer(&mut self) - -> *mut __Reply__host_set_UNDServer_t { + pub unsafe fn Reply_host_set_UNDServer(&mut self) -> *mut __Reply__host_set_UNDServer_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_host_get_UNDServer(&mut self) - -> *mut __Reply__host_get_UNDServer_t { + pub unsafe fn Reply_host_get_UNDServer(&mut self) -> *mut __Reply__host_get_UNDServer_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_kext_request(&mut self) - -> *mut __Reply__kext_request_t { + pub unsafe fn Reply_kext_request(&mut self) -> *mut __Reply__kext_request_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } } impl ::std::clone::Clone for Union___ReplyUnion__host_priv_subsystem { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Union___ReplyUnion__host_priv_subsystem { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -3710,10 +4412,14 @@ pub struct Struct_Unnamed92 { pub inherit_memory: boolean_t, } impl ::std::clone::Clone for Struct_Unnamed92 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed92 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__host_security_create_task_token_t = Struct_Unnamed92; #[repr(C)] @@ -3728,10 +4434,14 @@ pub struct Struct_Unnamed93 { pub audit_token: audit_token_t, } impl ::std::clone::Clone for Struct_Unnamed93 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed93 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__host_security_set_task_token_t = Struct_Unnamed93; #[repr(C)] @@ -3740,23 +4450,28 @@ pub struct Union___RequestUnion__host_security_subsystem { pub _bindgen_data_: [u32; 31usize], } impl Union___RequestUnion__host_security_subsystem { - pub unsafe fn Request_host_security_create_task_token(&mut self) - -> *mut __Request__host_security_create_task_token_t { + pub unsafe fn Request_host_security_create_task_token + (&mut self) + -> *mut __Request__host_security_create_task_token_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_host_security_set_task_token(&mut self) - -> *mut __Request__host_security_set_task_token_t { + pub unsafe fn Request_host_security_set_task_token + (&mut self) + -> *mut __Request__host_security_set_task_token_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } } impl ::std::clone::Clone for Union___RequestUnion__host_security_subsystem { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } -impl ::std::default::Default for Union___RequestUnion__host_security_subsystem - { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } +impl ::std::default::Default for Union___RequestUnion__host_security_subsystem { + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -3766,10 +4481,14 @@ pub struct Struct_Unnamed94 { pub child_task: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed94 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed94 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__host_security_create_task_token_t = Struct_Unnamed94; #[repr(C)] @@ -3780,10 +4499,14 @@ pub struct Struct_Unnamed95 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed95 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed95 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__host_security_set_task_token_t = Struct_Unnamed95; #[repr(C)] @@ -3792,22 +4515,28 @@ pub struct Union___ReplyUnion__host_security_subsystem { pub _bindgen_data_: [u32; 10usize], } impl Union___ReplyUnion__host_security_subsystem { - pub unsafe fn Reply_host_security_create_task_token(&mut self) - -> *mut __Reply__host_security_create_task_token_t { + pub unsafe fn Reply_host_security_create_task_token + (&mut self) + -> *mut __Reply__host_security_create_task_token_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_host_security_set_task_token(&mut self) - -> *mut __Reply__host_security_set_task_token_t { + pub unsafe fn Reply_host_security_set_task_token + (&mut self) + -> *mut __Reply__host_security_set_task_token_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } } impl ::std::clone::Clone for Union___ReplyUnion__host_security_subsystem { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Union___ReplyUnion__host_security_subsystem { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -3817,10 +4546,14 @@ pub struct Struct_Unnamed96 { pub lock_id: ::libc::c_int, } impl ::std::clone::Clone for Struct_Unnamed96 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed96 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__lock_acquire_t = Struct_Unnamed96; #[repr(C)] @@ -3831,10 +4564,14 @@ pub struct Struct_Unnamed97 { pub lock_id: ::libc::c_int, } impl ::std::clone::Clone for Struct_Unnamed97 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed97 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__lock_release_t = Struct_Unnamed97; #[repr(C)] @@ -3845,10 +4582,14 @@ pub struct Struct_Unnamed98 { pub lock_id: ::libc::c_int, } impl ::std::clone::Clone for Struct_Unnamed98 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed98 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__lock_try_t = Struct_Unnamed98; #[repr(C)] @@ -3859,10 +4600,14 @@ pub struct Struct_Unnamed99 { pub lock_id: ::libc::c_int, } impl ::std::clone::Clone for Struct_Unnamed99 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed99 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__lock_make_stable_t = Struct_Unnamed99; #[repr(C)] @@ -3873,10 +4618,14 @@ pub struct Struct_Unnamed100 { pub lock_id: ::libc::c_int, } impl ::std::clone::Clone for Struct_Unnamed100 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed100 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__lock_handoff_t = Struct_Unnamed100; #[repr(C)] @@ -3887,10 +4636,14 @@ pub struct Struct_Unnamed101 { pub lock_id: ::libc::c_int, } impl ::std::clone::Clone for Struct_Unnamed101 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed101 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__lock_handoff_accept_t = Struct_Unnamed101; #[repr(C)] @@ -3899,13 +4652,11 @@ pub struct Union___RequestUnion__lock_set_subsystem { pub _bindgen_data_: [u32; 9usize], } impl Union___RequestUnion__lock_set_subsystem { - pub unsafe fn Request_lock_acquire(&mut self) - -> *mut __Request__lock_acquire_t { + pub unsafe fn Request_lock_acquire(&mut self) -> *mut __Request__lock_acquire_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_lock_release(&mut self) - -> *mut __Request__lock_release_t { + pub unsafe fn Request_lock_release(&mut self) -> *mut __Request__lock_release_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } @@ -3913,27 +4664,28 @@ impl Union___RequestUnion__lock_set_subsystem { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_lock_make_stable(&mut self) - -> *mut __Request__lock_make_stable_t { + pub unsafe fn Request_lock_make_stable(&mut self) -> *mut __Request__lock_make_stable_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_lock_handoff(&mut self) - -> *mut __Request__lock_handoff_t { + pub unsafe fn Request_lock_handoff(&mut self) -> *mut __Request__lock_handoff_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_lock_handoff_accept(&mut self) - -> *mut __Request__lock_handoff_accept_t { + pub unsafe fn Request_lock_handoff_accept(&mut self) -> *mut __Request__lock_handoff_accept_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } } impl ::std::clone::Clone for Union___RequestUnion__lock_set_subsystem { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Union___RequestUnion__lock_set_subsystem { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -3943,10 +4695,14 @@ pub struct Struct_Unnamed102 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed102 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed102 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__lock_acquire_t = Struct_Unnamed102; #[repr(C)] @@ -3957,10 +4713,14 @@ pub struct Struct_Unnamed103 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed103 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed103 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__lock_release_t = Struct_Unnamed103; #[repr(C)] @@ -3971,10 +4731,14 @@ pub struct Struct_Unnamed104 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed104 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed104 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__lock_try_t = Struct_Unnamed104; #[repr(C)] @@ -3985,10 +4749,14 @@ pub struct Struct_Unnamed105 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed105 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed105 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__lock_make_stable_t = Struct_Unnamed105; #[repr(C)] @@ -3999,10 +4767,14 @@ pub struct Struct_Unnamed106 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed106 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed106 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__lock_handoff_t = Struct_Unnamed106; #[repr(C)] @@ -4013,10 +4785,14 @@ pub struct Struct_Unnamed107 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed107 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed107 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__lock_handoff_accept_t = Struct_Unnamed107; #[repr(C)] @@ -4025,13 +4801,11 @@ pub struct Union___ReplyUnion__lock_set_subsystem { pub _bindgen_data_: [u32; 9usize], } impl Union___ReplyUnion__lock_set_subsystem { - pub unsafe fn Reply_lock_acquire(&mut self) - -> *mut __Reply__lock_acquire_t { + pub unsafe fn Reply_lock_acquire(&mut self) -> *mut __Reply__lock_acquire_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_lock_release(&mut self) - -> *mut __Reply__lock_release_t { + pub unsafe fn Reply_lock_release(&mut self) -> *mut __Reply__lock_release_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } @@ -4039,27 +4813,28 @@ impl Union___ReplyUnion__lock_set_subsystem { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_lock_make_stable(&mut self) - -> *mut __Reply__lock_make_stable_t { + pub unsafe fn Reply_lock_make_stable(&mut self) -> *mut __Reply__lock_make_stable_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_lock_handoff(&mut self) - -> *mut __Reply__lock_handoff_t { + pub unsafe fn Reply_lock_handoff(&mut self) -> *mut __Reply__lock_handoff_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_lock_handoff_accept(&mut self) - -> *mut __Reply__lock_handoff_accept_t { + pub unsafe fn Reply_lock_handoff_accept(&mut self) -> *mut __Reply__lock_handoff_accept_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } } impl ::std::clone::Clone for Union___ReplyUnion__lock_set_subsystem { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Union___ReplyUnion__lock_set_subsystem { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -4067,10 +4842,14 @@ pub struct Struct_Unnamed108 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed108 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed108 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__processor_start_t = Struct_Unnamed108; #[repr(C)] @@ -4079,10 +4858,14 @@ pub struct Struct_Unnamed109 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed109 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed109 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__processor_exit_t = Struct_Unnamed109; #[repr(C)] @@ -4094,10 +4877,14 @@ pub struct Struct_Unnamed110 { pub processor_info_outCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed110 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed110 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__processor_info_t = Struct_Unnamed110; #[repr(C)] @@ -4109,10 +4896,14 @@ pub struct Struct_Unnamed111 { pub processor_cmd: [integer_t; 12usize], } impl ::std::clone::Clone for Struct_Unnamed111 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed111 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__processor_control_t = Struct_Unnamed111; #[repr(C)] @@ -4125,10 +4916,14 @@ pub struct Struct_Unnamed112 { pub wait: boolean_t, } impl ::std::clone::Clone for Struct_Unnamed112 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed112 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__processor_assign_t = Struct_Unnamed112; #[repr(C)] @@ -4137,10 +4932,14 @@ pub struct Struct_Unnamed113 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed113 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed113 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__processor_get_assignment_t = Struct_Unnamed113; #[repr(C)] @@ -4149,42 +4948,42 @@ pub struct Union___RequestUnion__processor_subsystem { pub _bindgen_data_: [u32; 21usize], } impl Union___RequestUnion__processor_subsystem { - pub unsafe fn Request_processor_start(&mut self) - -> *mut __Request__processor_start_t { + pub unsafe fn Request_processor_start(&mut self) -> *mut __Request__processor_start_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_processor_exit(&mut self) - -> *mut __Request__processor_exit_t { + pub unsafe fn Request_processor_exit(&mut self) -> *mut __Request__processor_exit_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_processor_info(&mut self) - -> *mut __Request__processor_info_t { + pub unsafe fn Request_processor_info(&mut self) -> *mut __Request__processor_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_processor_control(&mut self) - -> *mut __Request__processor_control_t { + pub unsafe fn Request_processor_control(&mut self) -> *mut __Request__processor_control_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_processor_assign(&mut self) - -> *mut __Request__processor_assign_t { + pub unsafe fn Request_processor_assign(&mut self) -> *mut __Request__processor_assign_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_processor_get_assignment(&mut self) - -> *mut __Request__processor_get_assignment_t { + pub unsafe fn Request_processor_get_assignment + (&mut self) + -> *mut __Request__processor_get_assignment_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } } impl ::std::clone::Clone for Union___RequestUnion__processor_subsystem { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Union___RequestUnion__processor_subsystem { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -4194,10 +4993,14 @@ pub struct Struct_Unnamed114 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed114 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed114 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__processor_start_t = Struct_Unnamed114; #[repr(C)] @@ -4208,10 +5011,14 @@ pub struct Struct_Unnamed115 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed115 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed115 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__processor_exit_t = Struct_Unnamed115; #[repr(C)] @@ -4225,10 +5032,14 @@ pub struct Struct_Unnamed116 { pub processor_info_out: [integer_t; 12usize], } impl ::std::clone::Clone for Struct_Unnamed116 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed116 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__processor_info_t = Struct_Unnamed116; #[repr(C)] @@ -4239,10 +5050,14 @@ pub struct Struct_Unnamed117 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed117 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed117 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__processor_control_t = Struct_Unnamed117; #[repr(C)] @@ -4253,10 +5068,14 @@ pub struct Struct_Unnamed118 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed118 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed118 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__processor_assign_t = Struct_Unnamed118; #[repr(C)] @@ -4267,10 +5086,14 @@ pub struct Struct_Unnamed119 { pub assigned_set: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed119 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed119 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__processor_get_assignment_t = Struct_Unnamed119; #[repr(C)] @@ -4279,42 +5102,41 @@ pub struct Union___ReplyUnion__processor_subsystem { pub _bindgen_data_: [u32; 25usize], } impl Union___ReplyUnion__processor_subsystem { - pub unsafe fn Reply_processor_start(&mut self) - -> *mut __Reply__processor_start_t { + pub unsafe fn Reply_processor_start(&mut self) -> *mut __Reply__processor_start_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_processor_exit(&mut self) - -> *mut __Reply__processor_exit_t { + pub unsafe fn Reply_processor_exit(&mut self) -> *mut __Reply__processor_exit_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_processor_info(&mut self) - -> *mut __Reply__processor_info_t { + pub unsafe fn Reply_processor_info(&mut self) -> *mut __Reply__processor_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_processor_control(&mut self) - -> *mut __Reply__processor_control_t { + pub unsafe fn Reply_processor_control(&mut self) -> *mut __Reply__processor_control_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_processor_assign(&mut self) - -> *mut __Reply__processor_assign_t { + pub unsafe fn Reply_processor_assign(&mut self) -> *mut __Reply__processor_assign_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_processor_get_assignment(&mut self) - -> *mut __Reply__processor_get_assignment_t { + -> *mut __Reply__processor_get_assignment_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } } impl ::std::clone::Clone for Union___ReplyUnion__processor_subsystem { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Union___ReplyUnion__processor_subsystem { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -4325,10 +5147,14 @@ pub struct Struct_Unnamed120 { pub info_outCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed120 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed120 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__processor_set_statistics_t = Struct_Unnamed120; #[repr(C)] @@ -4337,10 +5163,14 @@ pub struct Struct_Unnamed121 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed121 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed121 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__processor_set_destroy_t = Struct_Unnamed121; #[repr(C)] @@ -4352,10 +5182,14 @@ pub struct Struct_Unnamed122 { pub change_threads: boolean_t, } impl ::std::clone::Clone for Struct_Unnamed122 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed122 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__processor_set_max_priority_t = Struct_Unnamed122; #[repr(C)] @@ -4366,10 +5200,14 @@ pub struct Struct_Unnamed123 { pub policy: ::libc::c_int, } impl ::std::clone::Clone for Struct_Unnamed123 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed123 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__processor_set_policy_enable_t = Struct_Unnamed123; #[repr(C)] @@ -4381,10 +5219,14 @@ pub struct Struct_Unnamed124 { pub change_threads: boolean_t, } impl ::std::clone::Clone for Struct_Unnamed124 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed124 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__processor_set_policy_disable_t = Struct_Unnamed124; #[repr(C)] @@ -4393,10 +5235,14 @@ pub struct Struct_Unnamed125 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed125 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed125 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__processor_set_tasks_t = Struct_Unnamed125; #[repr(C)] @@ -4405,10 +5251,14 @@ pub struct Struct_Unnamed126 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed126 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed126 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__processor_set_threads_t = Struct_Unnamed126; #[repr(C)] @@ -4422,10 +5272,14 @@ pub struct Struct_Unnamed127 { pub change: boolean_t, } impl ::std::clone::Clone for Struct_Unnamed127 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed127 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__processor_set_policy_control_t = Struct_Unnamed127; #[repr(C)] @@ -4434,10 +5288,14 @@ pub struct Struct_Unnamed128 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed128 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed128 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__processor_set_stack_usage_t = Struct_Unnamed128; #[repr(C)] @@ -4449,10 +5307,14 @@ pub struct Struct_Unnamed129 { pub info_outCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed129 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed129 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__processor_set_info_t = Struct_Unnamed129; #[repr(C)] @@ -4461,63 +5323,68 @@ pub struct Union___RequestUnion__processor_set_subsystem { pub _bindgen_data_: [u32; 16usize], } impl Union___RequestUnion__processor_set_subsystem { - pub unsafe fn Request_processor_set_statistics(&mut self) - -> *mut __Request__processor_set_statistics_t { + pub unsafe fn Request_processor_set_statistics + (&mut self) + -> *mut __Request__processor_set_statistics_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_processor_set_destroy(&mut self) - -> *mut __Request__processor_set_destroy_t { + pub unsafe fn Request_processor_set_destroy(&mut self) -> *mut __Request__processor_set_destroy_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_processor_set_max_priority(&mut self) - -> *mut __Request__processor_set_max_priority_t { + pub unsafe fn Request_processor_set_max_priority + (&mut self) + -> *mut __Request__processor_set_max_priority_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_processor_set_policy_enable(&mut self) - -> *mut __Request__processor_set_policy_enable_t { + pub unsafe fn Request_processor_set_policy_enable + (&mut self) + -> *mut __Request__processor_set_policy_enable_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_processor_set_policy_disable(&mut self) - -> *mut __Request__processor_set_policy_disable_t { + pub unsafe fn Request_processor_set_policy_disable + (&mut self) + -> *mut __Request__processor_set_policy_disable_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_processor_set_tasks(&mut self) - -> *mut __Request__processor_set_tasks_t { + pub unsafe fn Request_processor_set_tasks(&mut self) -> *mut __Request__processor_set_tasks_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_processor_set_threads(&mut self) - -> *mut __Request__processor_set_threads_t { + pub unsafe fn Request_processor_set_threads(&mut self) -> *mut __Request__processor_set_threads_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_processor_set_policy_control(&mut self) - -> *mut __Request__processor_set_policy_control_t { + pub unsafe fn Request_processor_set_policy_control + (&mut self) + -> *mut __Request__processor_set_policy_control_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_processor_set_stack_usage(&mut self) - -> *mut __Request__processor_set_stack_usage_t { + pub unsafe fn Request_processor_set_stack_usage + (&mut self) + -> *mut __Request__processor_set_stack_usage_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_processor_set_info(&mut self) - -> *mut __Request__processor_set_info_t { + pub unsafe fn Request_processor_set_info(&mut self) -> *mut __Request__processor_set_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } } impl ::std::clone::Clone for Union___RequestUnion__processor_set_subsystem { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } -impl ::std::default::Default for Union___RequestUnion__processor_set_subsystem - { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } +impl ::std::default::Default for Union___RequestUnion__processor_set_subsystem { + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -4529,10 +5396,14 @@ pub struct Struct_Unnamed130 { pub info_out: [integer_t; 5usize], } impl ::std::clone::Clone for Struct_Unnamed130 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed130 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__processor_set_statistics_t = Struct_Unnamed130; #[repr(C)] @@ -4543,10 +5414,14 @@ pub struct Struct_Unnamed131 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed131 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed131 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__processor_set_destroy_t = Struct_Unnamed131; #[repr(C)] @@ -4557,10 +5432,14 @@ pub struct Struct_Unnamed132 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed132 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed132 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__processor_set_max_priority_t = Struct_Unnamed132; #[repr(C)] @@ -4571,10 +5450,14 @@ pub struct Struct_Unnamed133 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed133 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed133 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__processor_set_policy_enable_t = Struct_Unnamed133; #[repr(C)] @@ -4585,10 +5468,14 @@ pub struct Struct_Unnamed134 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed134 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed134 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__processor_set_policy_disable_t = Struct_Unnamed134; #[repr(C)] @@ -4601,10 +5488,14 @@ pub struct Struct_Unnamed135 { pub task_listCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed135 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed135 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__processor_set_tasks_t = Struct_Unnamed135; #[repr(C)] @@ -4617,10 +5508,14 @@ pub struct Struct_Unnamed136 { pub thread_listCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed136 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed136 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__processor_set_threads_t = Struct_Unnamed136; #[repr(C)] @@ -4631,10 +5526,14 @@ pub struct Struct_Unnamed137 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed137 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed137 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__processor_set_policy_control_t = Struct_Unnamed137; #[repr(C)] @@ -4650,10 +5549,14 @@ pub struct Struct_Unnamed138 { pub maxstack: vm_offset_t, } impl ::std::clone::Clone for Struct_Unnamed138 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed138 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__processor_set_stack_usage_t = Struct_Unnamed138; #[repr(C)] @@ -4667,10 +5570,14 @@ pub struct Struct_Unnamed139 { pub info_out: [integer_t; 5usize], } impl ::std::clone::Clone for Struct_Unnamed139 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed139 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__processor_set_info_t = Struct_Unnamed139; #[repr(C)] @@ -4680,61 +5587,65 @@ pub struct Union___ReplyUnion__processor_set_subsystem { } impl Union___ReplyUnion__processor_set_subsystem { pub unsafe fn Reply_processor_set_statistics(&mut self) - -> *mut __Reply__processor_set_statistics_t { + -> *mut __Reply__processor_set_statistics_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_processor_set_destroy(&mut self) - -> *mut __Reply__processor_set_destroy_t { + pub unsafe fn Reply_processor_set_destroy(&mut self) -> *mut __Reply__processor_set_destroy_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_processor_set_max_priority(&mut self) - -> *mut __Reply__processor_set_max_priority_t { + pub unsafe fn Reply_processor_set_max_priority + (&mut self) + -> *mut __Reply__processor_set_max_priority_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_processor_set_policy_enable(&mut self) - -> *mut __Reply__processor_set_policy_enable_t { + pub unsafe fn Reply_processor_set_policy_enable + (&mut self) + -> *mut __Reply__processor_set_policy_enable_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_processor_set_policy_disable(&mut self) - -> *mut __Reply__processor_set_policy_disable_t { + pub unsafe fn Reply_processor_set_policy_disable + (&mut self) + -> *mut __Reply__processor_set_policy_disable_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_processor_set_tasks(&mut self) - -> *mut __Reply__processor_set_tasks_t { + pub unsafe fn Reply_processor_set_tasks(&mut self) -> *mut __Reply__processor_set_tasks_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_processor_set_threads(&mut self) - -> *mut __Reply__processor_set_threads_t { + pub unsafe fn Reply_processor_set_threads(&mut self) -> *mut __Reply__processor_set_threads_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_processor_set_policy_control(&mut self) - -> *mut __Reply__processor_set_policy_control_t { + pub unsafe fn Reply_processor_set_policy_control + (&mut self) + -> *mut __Reply__processor_set_policy_control_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_processor_set_stack_usage(&mut self) - -> *mut __Reply__processor_set_stack_usage_t { + -> *mut __Reply__processor_set_stack_usage_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_processor_set_info(&mut self) - -> *mut __Reply__processor_set_info_t { + pub unsafe fn Reply_processor_set_info(&mut self) -> *mut __Reply__processor_set_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } } impl ::std::clone::Clone for Union___ReplyUnion__processor_set_subsystem { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Union___ReplyUnion__processor_set_subsystem { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type sync_policy_t = ::libc::c_int; #[repr(C)] @@ -4748,10 +5659,14 @@ pub struct Struct_Unnamed140 { pub inherit_memory: boolean_t, } impl ::std::clone::Clone for Struct_Unnamed140 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed140 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__task_create_t = Struct_Unnamed140; #[repr(C)] @@ -4760,10 +5675,14 @@ pub struct Struct_Unnamed141 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed141 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed141 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__task_terminate_t = Struct_Unnamed141; #[repr(C)] @@ -4772,10 +5691,14 @@ pub struct Struct_Unnamed142 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed142 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed142 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__task_threads_t = Struct_Unnamed142; #[repr(C)] @@ -4788,10 +5711,14 @@ pub struct Struct_Unnamed143 { pub init_port_setCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed143 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed143 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__mach_ports_register_t = Struct_Unnamed143; #[repr(C)] @@ -4800,10 +5727,14 @@ pub struct Struct_Unnamed144 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed144 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed144 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__mach_ports_lookup_t = Struct_Unnamed144; #[repr(C)] @@ -4815,10 +5746,14 @@ pub struct Struct_Unnamed145 { pub task_info_outCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed145 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed145 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__task_info_t = Struct_Unnamed145; #[repr(C)] @@ -4831,10 +5766,14 @@ pub struct Struct_Unnamed146 { pub task_info_in: [integer_t; 32usize], } impl ::std::clone::Clone for Struct_Unnamed146 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed146 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__task_set_info_t = Struct_Unnamed146; #[repr(C)] @@ -4843,10 +5782,14 @@ pub struct Struct_Unnamed147 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed147 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed147 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__task_suspend_t = Struct_Unnamed147; #[repr(C)] @@ -4855,10 +5798,14 @@ pub struct Struct_Unnamed148 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed148 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed148 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__task_resume_t = Struct_Unnamed148; #[repr(C)] @@ -4869,10 +5816,14 @@ pub struct Struct_Unnamed149 { pub which_port: ::libc::c_int, } impl ::std::clone::Clone for Struct_Unnamed149 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed149 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__task_get_special_port_t = Struct_Unnamed149; #[repr(C)] @@ -4885,10 +5836,14 @@ pub struct Struct_Unnamed150 { pub which_port: ::libc::c_int, } impl ::std::clone::Clone for Struct_Unnamed150 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed150 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__task_set_special_port_t = Struct_Unnamed150; #[repr(C)] @@ -4897,10 +5852,14 @@ pub struct Struct_Unnamed151 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed151 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed151 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__thread_create_t = Struct_Unnamed151; #[repr(C)] @@ -4913,10 +5872,14 @@ pub struct Struct_Unnamed152 { pub new_state: [natural_t; 224usize], } impl ::std::clone::Clone for Struct_Unnamed152 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed152 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__thread_create_running_t = Struct_Unnamed152; #[repr(C)] @@ -4931,10 +5894,14 @@ pub struct Struct_Unnamed153 { pub new_flavor: thread_state_flavor_t, } impl ::std::clone::Clone for Struct_Unnamed153 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed153 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__task_set_exception_ports_t = Struct_Unnamed153; #[repr(C)] @@ -4945,10 +5912,14 @@ pub struct Struct_Unnamed154 { pub exception_mask: exception_mask_t, } impl ::std::clone::Clone for Struct_Unnamed154 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed154 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__task_get_exception_ports_t = Struct_Unnamed154; #[repr(C)] @@ -4963,10 +5934,14 @@ pub struct Struct_Unnamed155 { pub new_flavor: thread_state_flavor_t, } impl ::std::clone::Clone for Struct_Unnamed155 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed155 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__task_swap_exception_ports_t = Struct_Unnamed155; #[repr(C)] @@ -4978,10 +5953,14 @@ pub struct Struct_Unnamed156 { pub policy: ::libc::c_int, } impl ::std::clone::Clone for Struct_Unnamed156 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed156 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__lock_set_create_t = Struct_Unnamed156; #[repr(C)] @@ -4992,10 +5971,14 @@ pub struct Struct_Unnamed157 { pub lock_set: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed157 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed157 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__lock_set_destroy_t = Struct_Unnamed157; #[repr(C)] @@ -5007,10 +5990,14 @@ pub struct Struct_Unnamed158 { pub value: ::libc::c_int, } impl ::std::clone::Clone for Struct_Unnamed158 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed158 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__semaphore_create_t = Struct_Unnamed158; #[repr(C)] @@ -5021,10 +6008,14 @@ pub struct Struct_Unnamed159 { pub semaphore: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed159 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed159 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__semaphore_destroy_t = Struct_Unnamed159; #[repr(C)] @@ -5037,10 +6028,14 @@ pub struct Struct_Unnamed160 { pub policy_info: [integer_t; 16usize], } impl ::std::clone::Clone for Struct_Unnamed160 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed160 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__task_policy_set_t = Struct_Unnamed160; #[repr(C)] @@ -5053,10 +6048,14 @@ pub struct Struct_Unnamed161 { pub get_default: boolean_t, } impl ::std::clone::Clone for Struct_Unnamed161 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed161 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__task_policy_get_t = Struct_Unnamed161; #[repr(C)] @@ -5067,10 +6066,14 @@ pub struct Struct_Unnamed162 { pub reply: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed162 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed162 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__task_sample_t = Struct_Unnamed162; #[repr(C)] @@ -5085,10 +6088,14 @@ pub struct Struct_Unnamed163 { pub change: boolean_t, } impl ::std::clone::Clone for Struct_Unnamed163 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed163 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__task_policy_t = Struct_Unnamed163; #[repr(C)] @@ -5100,10 +6107,14 @@ pub struct Struct_Unnamed164 { pub routine_number: ::libc::c_int, } impl ::std::clone::Clone for Struct_Unnamed164 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed164 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__task_set_emulation_t = Struct_Unnamed164; #[repr(C)] @@ -5112,10 +6123,14 @@ pub struct Struct_Unnamed165 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed165 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed165 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__task_get_emulation_vector_t = Struct_Unnamed165; #[repr(C)] @@ -5129,10 +6144,14 @@ pub struct Struct_Unnamed166 { pub emulation_vectorCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed166 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed166 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__task_set_emulation_vector_t = Struct_Unnamed166; #[repr(C)] @@ -5144,10 +6163,14 @@ pub struct Struct_Unnamed167 { pub boundspc: vm_address_t, } impl ::std::clone::Clone for Struct_Unnamed167 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed167 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__task_set_ras_pc_t = Struct_Unnamed167; #[repr(C)] @@ -5156,10 +6179,14 @@ pub struct Struct_Unnamed168 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed168 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed168 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__task_zone_info_t = Struct_Unnamed168; #[repr(C)] @@ -5172,10 +6199,14 @@ pub struct Struct_Unnamed169 { pub assign_threads: boolean_t, } impl ::std::clone::Clone for Struct_Unnamed169 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed169 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__task_assign_t = Struct_Unnamed169; #[repr(C)] @@ -5186,10 +6217,14 @@ pub struct Struct_Unnamed170 { pub assign_threads: boolean_t, } impl ::std::clone::Clone for Struct_Unnamed170 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed170 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__task_assign_default_t = Struct_Unnamed170; #[repr(C)] @@ -5198,10 +6233,14 @@ pub struct Struct_Unnamed171 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed171 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed171 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__task_get_assignment_t = Struct_Unnamed171; #[repr(C)] @@ -5219,10 +6258,14 @@ pub struct Struct_Unnamed172 { pub change: boolean_t, } impl ::std::clone::Clone for Struct_Unnamed172 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed172 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__task_set_policy_t = Struct_Unnamed172; #[repr(C)] @@ -5234,10 +6277,14 @@ pub struct Struct_Unnamed173 { pub old_stateCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed173 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed173 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__task_get_state_t = Struct_Unnamed173; #[repr(C)] @@ -5250,10 +6297,14 @@ pub struct Struct_Unnamed174 { pub new_state: [natural_t; 224usize], } impl ::std::clone::Clone for Struct_Unnamed174 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed174 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__task_set_state_t = Struct_Unnamed174; #[repr(C)] @@ -5262,187 +6313,166 @@ pub struct Union___RequestUnion__task_subsystem { pub _bindgen_data_: [u32; 234usize], } impl Union___RequestUnion__task_subsystem { - pub unsafe fn Request_task_create(&mut self) - -> *mut __Request__task_create_t { + pub unsafe fn Request_task_create(&mut self) -> *mut __Request__task_create_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_task_terminate(&mut self) - -> *mut __Request__task_terminate_t { + pub unsafe fn Request_task_terminate(&mut self) -> *mut __Request__task_terminate_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_task_threads(&mut self) - -> *mut __Request__task_threads_t { + pub unsafe fn Request_task_threads(&mut self) -> *mut __Request__task_threads_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_mach_ports_register(&mut self) - -> *mut __Request__mach_ports_register_t { + pub unsafe fn Request_mach_ports_register(&mut self) -> *mut __Request__mach_ports_register_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_mach_ports_lookup(&mut self) - -> *mut __Request__mach_ports_lookup_t { + pub unsafe fn Request_mach_ports_lookup(&mut self) -> *mut __Request__mach_ports_lookup_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_task_info(&mut self) - -> *mut __Request__task_info_t { + pub unsafe fn Request_task_info(&mut self) -> *mut __Request__task_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_task_set_info(&mut self) - -> *mut __Request__task_set_info_t { + pub unsafe fn Request_task_set_info(&mut self) -> *mut __Request__task_set_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_task_suspend(&mut self) - -> *mut __Request__task_suspend_t { + pub unsafe fn Request_task_suspend(&mut self) -> *mut __Request__task_suspend_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_task_resume(&mut self) - -> *mut __Request__task_resume_t { + pub unsafe fn Request_task_resume(&mut self) -> *mut __Request__task_resume_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_task_get_special_port(&mut self) - -> *mut __Request__task_get_special_port_t { + pub unsafe fn Request_task_get_special_port(&mut self) -> *mut __Request__task_get_special_port_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_task_set_special_port(&mut self) - -> *mut __Request__task_set_special_port_t { + pub unsafe fn Request_task_set_special_port(&mut self) -> *mut __Request__task_set_special_port_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_thread_create(&mut self) - -> *mut __Request__thread_create_t { + pub unsafe fn Request_thread_create(&mut self) -> *mut __Request__thread_create_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_thread_create_running(&mut self) - -> *mut __Request__thread_create_running_t { + pub unsafe fn Request_thread_create_running(&mut self) -> *mut __Request__thread_create_running_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_task_set_exception_ports(&mut self) - -> *mut __Request__task_set_exception_ports_t { + pub unsafe fn Request_task_set_exception_ports + (&mut self) + -> *mut __Request__task_set_exception_ports_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_task_get_exception_ports(&mut self) - -> *mut __Request__task_get_exception_ports_t { + pub unsafe fn Request_task_get_exception_ports + (&mut self) + -> *mut __Request__task_get_exception_ports_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_task_swap_exception_ports(&mut self) - -> *mut __Request__task_swap_exception_ports_t { + pub unsafe fn Request_task_swap_exception_ports + (&mut self) + -> *mut __Request__task_swap_exception_ports_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_lock_set_create(&mut self) - -> *mut __Request__lock_set_create_t { + pub unsafe fn Request_lock_set_create(&mut self) -> *mut __Request__lock_set_create_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_lock_set_destroy(&mut self) - -> *mut __Request__lock_set_destroy_t { + pub unsafe fn Request_lock_set_destroy(&mut self) -> *mut __Request__lock_set_destroy_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_semaphore_create(&mut self) - -> *mut __Request__semaphore_create_t { + pub unsafe fn Request_semaphore_create(&mut self) -> *mut __Request__semaphore_create_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_semaphore_destroy(&mut self) - -> *mut __Request__semaphore_destroy_t { + pub unsafe fn Request_semaphore_destroy(&mut self) -> *mut __Request__semaphore_destroy_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_task_policy_set(&mut self) - -> *mut __Request__task_policy_set_t { + pub unsafe fn Request_task_policy_set(&mut self) -> *mut __Request__task_policy_set_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_task_policy_get(&mut self) - -> *mut __Request__task_policy_get_t { + pub unsafe fn Request_task_policy_get(&mut self) -> *mut __Request__task_policy_get_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_task_sample(&mut self) - -> *mut __Request__task_sample_t { + pub unsafe fn Request_task_sample(&mut self) -> *mut __Request__task_sample_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_task_policy(&mut self) - -> *mut __Request__task_policy_t { + pub unsafe fn Request_task_policy(&mut self) -> *mut __Request__task_policy_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_task_set_emulation(&mut self) - -> *mut __Request__task_set_emulation_t { + pub unsafe fn Request_task_set_emulation(&mut self) -> *mut __Request__task_set_emulation_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_task_get_emulation_vector(&mut self) - -> *mut __Request__task_get_emulation_vector_t { + pub unsafe fn Request_task_get_emulation_vector + (&mut self) + -> *mut __Request__task_get_emulation_vector_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_task_set_emulation_vector(&mut self) - -> *mut __Request__task_set_emulation_vector_t { + pub unsafe fn Request_task_set_emulation_vector + (&mut self) + -> *mut __Request__task_set_emulation_vector_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_task_set_ras_pc(&mut self) - -> *mut __Request__task_set_ras_pc_t { + pub unsafe fn Request_task_set_ras_pc(&mut self) -> *mut __Request__task_set_ras_pc_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_task_zone_info(&mut self) - -> *mut __Request__task_zone_info_t { + pub unsafe fn Request_task_zone_info(&mut self) -> *mut __Request__task_zone_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_task_assign(&mut self) - -> *mut __Request__task_assign_t { + pub unsafe fn Request_task_assign(&mut self) -> *mut __Request__task_assign_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_task_assign_default(&mut self) - -> *mut __Request__task_assign_default_t { + pub unsafe fn Request_task_assign_default(&mut self) -> *mut __Request__task_assign_default_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_task_get_assignment(&mut self) - -> *mut __Request__task_get_assignment_t { + pub unsafe fn Request_task_get_assignment(&mut self) -> *mut __Request__task_get_assignment_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_task_set_policy(&mut self) - -> *mut __Request__task_set_policy_t { + pub unsafe fn Request_task_set_policy(&mut self) -> *mut __Request__task_set_policy_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_task_get_state(&mut self) - -> *mut __Request__task_get_state_t { + pub unsafe fn Request_task_get_state(&mut self) -> *mut __Request__task_get_state_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_task_set_state(&mut self) - -> *mut __Request__task_set_state_t { + pub unsafe fn Request_task_set_state(&mut self) -> *mut __Request__task_set_state_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } } impl ::std::clone::Clone for Union___RequestUnion__task_subsystem { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Union___RequestUnion__task_subsystem { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -5452,10 +6482,14 @@ pub struct Struct_Unnamed175 { pub child_task: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed175 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed175 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__task_create_t = Struct_Unnamed175; #[repr(C)] @@ -5466,10 +6500,14 @@ pub struct Struct_Unnamed176 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed176 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed176 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__task_terminate_t = Struct_Unnamed176; #[repr(C)] @@ -5482,10 +6520,14 @@ pub struct Struct_Unnamed177 { pub act_listCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed177 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed177 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__task_threads_t = Struct_Unnamed177; #[repr(C)] @@ -5496,10 +6538,14 @@ pub struct Struct_Unnamed178 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed178 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed178 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__mach_ports_register_t = Struct_Unnamed178; #[repr(C)] @@ -5512,10 +6558,14 @@ pub struct Struct_Unnamed179 { pub init_port_setCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed179 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed179 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__mach_ports_lookup_t = Struct_Unnamed179; #[repr(C)] @@ -5528,10 +6578,14 @@ pub struct Struct_Unnamed180 { pub task_info_out: [integer_t; 32usize], } impl ::std::clone::Clone for Struct_Unnamed180 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed180 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__task_info_t = Struct_Unnamed180; #[repr(C)] @@ -5542,10 +6596,14 @@ pub struct Struct_Unnamed181 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed181 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed181 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__task_set_info_t = Struct_Unnamed181; #[repr(C)] @@ -5556,10 +6614,14 @@ pub struct Struct_Unnamed182 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed182 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed182 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__task_suspend_t = Struct_Unnamed182; #[repr(C)] @@ -5570,10 +6632,14 @@ pub struct Struct_Unnamed183 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed183 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed183 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__task_resume_t = Struct_Unnamed183; #[repr(C)] @@ -5584,10 +6650,14 @@ pub struct Struct_Unnamed184 { pub special_port: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed184 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed184 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__task_get_special_port_t = Struct_Unnamed184; #[repr(C)] @@ -5598,10 +6668,14 @@ pub struct Struct_Unnamed185 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed185 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed185 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__task_set_special_port_t = Struct_Unnamed185; #[repr(C)] @@ -5612,10 +6686,14 @@ pub struct Struct_Unnamed186 { pub child_act: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed186 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed186 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__thread_create_t = Struct_Unnamed186; #[repr(C)] @@ -5626,10 +6704,14 @@ pub struct Struct_Unnamed187 { pub child_act: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed187 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed187 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__thread_create_running_t = Struct_Unnamed187; #[repr(C)] @@ -5640,10 +6722,14 @@ pub struct Struct_Unnamed188 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed188 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed188 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__task_set_exception_ports_t = Struct_Unnamed188; #[repr(C)] @@ -5659,10 +6745,14 @@ pub struct Struct_Unnamed189 { pub old_flavors: [thread_state_flavor_t; 32usize], } impl ::std::clone::Clone for Struct_Unnamed189 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed189 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__task_get_exception_ports_t = Struct_Unnamed189; #[repr(C)] @@ -5678,10 +6768,14 @@ pub struct Struct_Unnamed190 { pub old_flavors: [thread_state_flavor_t; 32usize], } impl ::std::clone::Clone for Struct_Unnamed190 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed190 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__task_swap_exception_ports_t = Struct_Unnamed190; #[repr(C)] @@ -5692,10 +6786,14 @@ pub struct Struct_Unnamed191 { pub new_lock_set: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed191 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed191 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__lock_set_create_t = Struct_Unnamed191; #[repr(C)] @@ -5706,10 +6804,14 @@ pub struct Struct_Unnamed192 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed192 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed192 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__lock_set_destroy_t = Struct_Unnamed192; #[repr(C)] @@ -5720,10 +6822,14 @@ pub struct Struct_Unnamed193 { pub semaphore: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed193 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed193 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__semaphore_create_t = Struct_Unnamed193; #[repr(C)] @@ -5734,10 +6840,14 @@ pub struct Struct_Unnamed194 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed194 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed194 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__semaphore_destroy_t = Struct_Unnamed194; #[repr(C)] @@ -5748,10 +6858,14 @@ pub struct Struct_Unnamed195 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed195 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed195 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__task_policy_set_t = Struct_Unnamed195; #[repr(C)] @@ -5765,10 +6879,14 @@ pub struct Struct_Unnamed196 { pub get_default: boolean_t, } impl ::std::clone::Clone for Struct_Unnamed196 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed196 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__task_policy_get_t = Struct_Unnamed196; #[repr(C)] @@ -5779,10 +6897,14 @@ pub struct Struct_Unnamed197 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed197 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed197 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__task_sample_t = Struct_Unnamed197; #[repr(C)] @@ -5793,10 +6915,14 @@ pub struct Struct_Unnamed198 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed198 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed198 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__task_policy_t = Struct_Unnamed198; #[repr(C)] @@ -5807,10 +6933,14 @@ pub struct Struct_Unnamed199 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed199 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed199 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__task_set_emulation_t = Struct_Unnamed199; #[repr(C)] @@ -5824,10 +6954,14 @@ pub struct Struct_Unnamed200 { pub emulation_vectorCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed200 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed200 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__task_get_emulation_vector_t = Struct_Unnamed200; #[repr(C)] @@ -5838,10 +6972,14 @@ pub struct Struct_Unnamed201 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed201 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed201 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__task_set_emulation_vector_t = Struct_Unnamed201; #[repr(C)] @@ -5852,10 +6990,14 @@ pub struct Struct_Unnamed202 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed202 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed202 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__task_set_ras_pc_t = Struct_Unnamed202; #[repr(C)] @@ -5870,10 +7012,14 @@ pub struct Struct_Unnamed203 { pub infoCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed203 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed203 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__task_zone_info_t = Struct_Unnamed203; #[repr(C)] @@ -5884,10 +7030,14 @@ pub struct Struct_Unnamed204 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed204 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed204 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__task_assign_t = Struct_Unnamed204; #[repr(C)] @@ -5898,10 +7048,14 @@ pub struct Struct_Unnamed205 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed205 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed205 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__task_assign_default_t = Struct_Unnamed205; #[repr(C)] @@ -5912,10 +7066,14 @@ pub struct Struct_Unnamed206 { pub assigned_set: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed206 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed206 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__task_get_assignment_t = Struct_Unnamed206; #[repr(C)] @@ -5926,10 +7084,14 @@ pub struct Struct_Unnamed207 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed207 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed207 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__task_set_policy_t = Struct_Unnamed207; #[repr(C)] @@ -5942,10 +7104,14 @@ pub struct Struct_Unnamed208 { pub old_state: [natural_t; 224usize], } impl ::std::clone::Clone for Struct_Unnamed208 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed208 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__task_get_state_t = Struct_Unnamed208; #[repr(C)] @@ -5956,10 +7122,14 @@ pub struct Struct_Unnamed209 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed209 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed209 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__task_set_state_t = Struct_Unnamed209; #[repr(C)] @@ -5968,28 +7138,23 @@ pub struct Union___ReplyUnion__task_subsystem { pub _bindgen_data_: [u32; 234usize], } impl Union___ReplyUnion__task_subsystem { - pub unsafe fn Reply_task_create(&mut self) - -> *mut __Reply__task_create_t { + pub unsafe fn Reply_task_create(&mut self) -> *mut __Reply__task_create_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_task_terminate(&mut self) - -> *mut __Reply__task_terminate_t { + pub unsafe fn Reply_task_terminate(&mut self) -> *mut __Reply__task_terminate_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_task_threads(&mut self) - -> *mut __Reply__task_threads_t { + pub unsafe fn Reply_task_threads(&mut self) -> *mut __Reply__task_threads_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_mach_ports_register(&mut self) - -> *mut __Reply__mach_ports_register_t { + pub unsafe fn Reply_mach_ports_register(&mut self) -> *mut __Reply__mach_ports_register_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_mach_ports_lookup(&mut self) - -> *mut __Reply__mach_ports_lookup_t { + pub unsafe fn Reply_mach_ports_lookup(&mut self) -> *mut __Reply__mach_ports_lookup_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } @@ -5997,157 +7162,137 @@ impl Union___ReplyUnion__task_subsystem { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_task_set_info(&mut self) - -> *mut __Reply__task_set_info_t { + pub unsafe fn Reply_task_set_info(&mut self) -> *mut __Reply__task_set_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_task_suspend(&mut self) - -> *mut __Reply__task_suspend_t { + pub unsafe fn Reply_task_suspend(&mut self) -> *mut __Reply__task_suspend_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_task_resume(&mut self) - -> *mut __Reply__task_resume_t { + pub unsafe fn Reply_task_resume(&mut self) -> *mut __Reply__task_resume_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_task_get_special_port(&mut self) - -> *mut __Reply__task_get_special_port_t { + pub unsafe fn Reply_task_get_special_port(&mut self) -> *mut __Reply__task_get_special_port_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_task_set_special_port(&mut self) - -> *mut __Reply__task_set_special_port_t { + pub unsafe fn Reply_task_set_special_port(&mut self) -> *mut __Reply__task_set_special_port_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_thread_create(&mut self) - -> *mut __Reply__thread_create_t { + pub unsafe fn Reply_thread_create(&mut self) -> *mut __Reply__thread_create_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_thread_create_running(&mut self) - -> *mut __Reply__thread_create_running_t { + pub unsafe fn Reply_thread_create_running(&mut self) -> *mut __Reply__thread_create_running_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_task_set_exception_ports(&mut self) - -> *mut __Reply__task_set_exception_ports_t { + -> *mut __Reply__task_set_exception_ports_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_task_get_exception_ports(&mut self) - -> *mut __Reply__task_get_exception_ports_t { + -> *mut __Reply__task_get_exception_ports_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_task_swap_exception_ports(&mut self) - -> *mut __Reply__task_swap_exception_ports_t { + -> *mut __Reply__task_swap_exception_ports_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_lock_set_create(&mut self) - -> *mut __Reply__lock_set_create_t { + pub unsafe fn Reply_lock_set_create(&mut self) -> *mut __Reply__lock_set_create_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_lock_set_destroy(&mut self) - -> *mut __Reply__lock_set_destroy_t { + pub unsafe fn Reply_lock_set_destroy(&mut self) -> *mut __Reply__lock_set_destroy_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_semaphore_create(&mut self) - -> *mut __Reply__semaphore_create_t { + pub unsafe fn Reply_semaphore_create(&mut self) -> *mut __Reply__semaphore_create_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_semaphore_destroy(&mut self) - -> *mut __Reply__semaphore_destroy_t { + pub unsafe fn Reply_semaphore_destroy(&mut self) -> *mut __Reply__semaphore_destroy_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_task_policy_set(&mut self) - -> *mut __Reply__task_policy_set_t { + pub unsafe fn Reply_task_policy_set(&mut self) -> *mut __Reply__task_policy_set_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_task_policy_get(&mut self) - -> *mut __Reply__task_policy_get_t { + pub unsafe fn Reply_task_policy_get(&mut self) -> *mut __Reply__task_policy_get_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_task_sample(&mut self) - -> *mut __Reply__task_sample_t { + pub unsafe fn Reply_task_sample(&mut self) -> *mut __Reply__task_sample_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_task_policy(&mut self) - -> *mut __Reply__task_policy_t { + pub unsafe fn Reply_task_policy(&mut self) -> *mut __Reply__task_policy_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_task_set_emulation(&mut self) - -> *mut __Reply__task_set_emulation_t { + pub unsafe fn Reply_task_set_emulation(&mut self) -> *mut __Reply__task_set_emulation_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_task_get_emulation_vector(&mut self) - -> *mut __Reply__task_get_emulation_vector_t { + -> *mut __Reply__task_get_emulation_vector_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_task_set_emulation_vector(&mut self) - -> *mut __Reply__task_set_emulation_vector_t { + -> *mut __Reply__task_set_emulation_vector_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_task_set_ras_pc(&mut self) - -> *mut __Reply__task_set_ras_pc_t { + pub unsafe fn Reply_task_set_ras_pc(&mut self) -> *mut __Reply__task_set_ras_pc_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_task_zone_info(&mut self) - -> *mut __Reply__task_zone_info_t { + pub unsafe fn Reply_task_zone_info(&mut self) -> *mut __Reply__task_zone_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_task_assign(&mut self) - -> *mut __Reply__task_assign_t { + pub unsafe fn Reply_task_assign(&mut self) -> *mut __Reply__task_assign_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_task_assign_default(&mut self) - -> *mut __Reply__task_assign_default_t { + pub unsafe fn Reply_task_assign_default(&mut self) -> *mut __Reply__task_assign_default_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_task_get_assignment(&mut self) - -> *mut __Reply__task_get_assignment_t { + pub unsafe fn Reply_task_get_assignment(&mut self) -> *mut __Reply__task_get_assignment_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_task_set_policy(&mut self) - -> *mut __Reply__task_set_policy_t { + pub unsafe fn Reply_task_set_policy(&mut self) -> *mut __Reply__task_set_policy_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_task_get_state(&mut self) - -> *mut __Reply__task_get_state_t { + pub unsafe fn Reply_task_get_state(&mut self) -> *mut __Reply__task_get_state_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_task_set_state(&mut self) - -> *mut __Reply__task_set_state_t { + pub unsafe fn Reply_task_set_state(&mut self) -> *mut __Reply__task_set_state_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } } impl ::std::clone::Clone for Union___ReplyUnion__task_subsystem { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Union___ReplyUnion__task_subsystem { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -6155,10 +7300,14 @@ pub struct Struct_Unnamed210 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed210 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed210 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__thread_terminate_t = Struct_Unnamed210; #[repr(C)] @@ -6170,10 +7319,14 @@ pub struct Struct_Unnamed211 { pub old_stateCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed211 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed211 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__act_get_state_t = Struct_Unnamed211; #[repr(C)] @@ -6186,10 +7339,14 @@ pub struct Struct_Unnamed212 { pub new_state: [natural_t; 224usize], } impl ::std::clone::Clone for Struct_Unnamed212 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed212 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__act_set_state_t = Struct_Unnamed212; #[repr(C)] @@ -6201,10 +7358,14 @@ pub struct Struct_Unnamed213 { pub old_stateCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed213 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed213 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__thread_get_state_t = Struct_Unnamed213; #[repr(C)] @@ -6217,10 +7378,14 @@ pub struct Struct_Unnamed214 { pub new_state: [natural_t; 224usize], } impl ::std::clone::Clone for Struct_Unnamed214 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed214 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__thread_set_state_t = Struct_Unnamed214; #[repr(C)] @@ -6229,10 +7394,14 @@ pub struct Struct_Unnamed215 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed215 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed215 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__thread_suspend_t = Struct_Unnamed215; #[repr(C)] @@ -6241,10 +7410,14 @@ pub struct Struct_Unnamed216 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed216 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed216 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__thread_resume_t = Struct_Unnamed216; #[repr(C)] @@ -6253,10 +7426,14 @@ pub struct Struct_Unnamed217 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed217 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed217 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__thread_abort_t = Struct_Unnamed217; #[repr(C)] @@ -6265,10 +7442,14 @@ pub struct Struct_Unnamed218 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed218 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed218 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__thread_abort_safely_t = Struct_Unnamed218; #[repr(C)] @@ -6277,10 +7458,14 @@ pub struct Struct_Unnamed219 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed219 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed219 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__thread_depress_abort_t = Struct_Unnamed219; #[repr(C)] @@ -6291,10 +7476,14 @@ pub struct Struct_Unnamed220 { pub which_port: ::libc::c_int, } impl ::std::clone::Clone for Struct_Unnamed220 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed220 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__thread_get_special_port_t = Struct_Unnamed220; #[repr(C)] @@ -6307,10 +7496,14 @@ pub struct Struct_Unnamed221 { pub which_port: ::libc::c_int, } impl ::std::clone::Clone for Struct_Unnamed221 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed221 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__thread_set_special_port_t = Struct_Unnamed221; #[repr(C)] @@ -6322,10 +7515,14 @@ pub struct Struct_Unnamed222 { pub thread_info_outCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed222 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed222 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__thread_info_t = Struct_Unnamed222; #[repr(C)] @@ -6340,10 +7537,14 @@ pub struct Struct_Unnamed223 { pub new_flavor: thread_state_flavor_t, } impl ::std::clone::Clone for Struct_Unnamed223 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed223 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__thread_set_exception_ports_t = Struct_Unnamed223; #[repr(C)] @@ -6354,10 +7555,14 @@ pub struct Struct_Unnamed224 { pub exception_mask: exception_mask_t, } impl ::std::clone::Clone for Struct_Unnamed224 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed224 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__thread_get_exception_ports_t = Struct_Unnamed224; #[repr(C)] @@ -6372,10 +7577,14 @@ pub struct Struct_Unnamed225 { pub new_flavor: thread_state_flavor_t, } impl ::std::clone::Clone for Struct_Unnamed225 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed225 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__thread_swap_exception_ports_t = Struct_Unnamed225; #[repr(C)] @@ -6389,10 +7598,14 @@ pub struct Struct_Unnamed226 { pub set_limit: boolean_t, } impl ::std::clone::Clone for Struct_Unnamed226 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed226 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__thread_policy_t = Struct_Unnamed226; #[repr(C)] @@ -6405,10 +7618,14 @@ pub struct Struct_Unnamed227 { pub policy_info: [integer_t; 16usize], } impl ::std::clone::Clone for Struct_Unnamed227 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed227 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__thread_policy_set_t = Struct_Unnamed227; #[repr(C)] @@ -6421,10 +7638,14 @@ pub struct Struct_Unnamed228 { pub get_default: boolean_t, } impl ::std::clone::Clone for Struct_Unnamed228 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed228 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__thread_policy_get_t = Struct_Unnamed228; #[repr(C)] @@ -6435,10 +7656,14 @@ pub struct Struct_Unnamed229 { pub reply: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed229 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed229 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__thread_sample_t = Struct_Unnamed229; #[repr(C)] @@ -6449,10 +7674,14 @@ pub struct Struct_Unnamed230 { pub trace_status: boolean_t, } impl ::std::clone::Clone for Struct_Unnamed230 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed230 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__etap_trace_thread_t = Struct_Unnamed230; #[repr(C)] @@ -6463,10 +7692,14 @@ pub struct Struct_Unnamed231 { pub new_set: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed231 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed231 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__thread_assign_t = Struct_Unnamed231; #[repr(C)] @@ -6475,10 +7708,14 @@ pub struct Struct_Unnamed232 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed232 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed232 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__thread_assign_default_t = Struct_Unnamed232; #[repr(C)] @@ -6487,10 +7724,14 @@ pub struct Struct_Unnamed233 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed233 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed233 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__thread_get_assignment_t = Struct_Unnamed233; #[repr(C)] @@ -6507,10 +7748,14 @@ pub struct Struct_Unnamed234 { pub limit: [integer_t; 1usize], } impl ::std::clone::Clone for Struct_Unnamed234 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed234 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__thread_set_policy_t = Struct_Unnamed234; #[repr(C)] @@ -6519,137 +7764,124 @@ pub struct Union___RequestUnion__thread_act_subsystem { pub _bindgen_data_: [u32; 234usize], } impl Union___RequestUnion__thread_act_subsystem { - pub unsafe fn Request_thread_terminate(&mut self) - -> *mut __Request__thread_terminate_t { + pub unsafe fn Request_thread_terminate(&mut self) -> *mut __Request__thread_terminate_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_act_get_state(&mut self) - -> *mut __Request__act_get_state_t { + pub unsafe fn Request_act_get_state(&mut self) -> *mut __Request__act_get_state_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_act_set_state(&mut self) - -> *mut __Request__act_set_state_t { + pub unsafe fn Request_act_set_state(&mut self) -> *mut __Request__act_set_state_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_thread_get_state(&mut self) - -> *mut __Request__thread_get_state_t { + pub unsafe fn Request_thread_get_state(&mut self) -> *mut __Request__thread_get_state_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_thread_set_state(&mut self) - -> *mut __Request__thread_set_state_t { + pub unsafe fn Request_thread_set_state(&mut self) -> *mut __Request__thread_set_state_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_thread_suspend(&mut self) - -> *mut __Request__thread_suspend_t { + pub unsafe fn Request_thread_suspend(&mut self) -> *mut __Request__thread_suspend_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_thread_resume(&mut self) - -> *mut __Request__thread_resume_t { + pub unsafe fn Request_thread_resume(&mut self) -> *mut __Request__thread_resume_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_thread_abort(&mut self) - -> *mut __Request__thread_abort_t { + pub unsafe fn Request_thread_abort(&mut self) -> *mut __Request__thread_abort_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_thread_abort_safely(&mut self) - -> *mut __Request__thread_abort_safely_t { + pub unsafe fn Request_thread_abort_safely(&mut self) -> *mut __Request__thread_abort_safely_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_thread_depress_abort(&mut self) - -> *mut __Request__thread_depress_abort_t { + pub unsafe fn Request_thread_depress_abort(&mut self) -> *mut __Request__thread_depress_abort_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_thread_get_special_port(&mut self) - -> *mut __Request__thread_get_special_port_t { + -> *mut __Request__thread_get_special_port_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_thread_set_special_port(&mut self) - -> *mut __Request__thread_set_special_port_t { + -> *mut __Request__thread_set_special_port_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_thread_info(&mut self) - -> *mut __Request__thread_info_t { + pub unsafe fn Request_thread_info(&mut self) -> *mut __Request__thread_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_thread_set_exception_ports(&mut self) - -> *mut __Request__thread_set_exception_ports_t { + pub unsafe fn Request_thread_set_exception_ports + (&mut self) + -> *mut __Request__thread_set_exception_ports_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_thread_get_exception_ports(&mut self) - -> *mut __Request__thread_get_exception_ports_t { + pub unsafe fn Request_thread_get_exception_ports + (&mut self) + -> *mut __Request__thread_get_exception_ports_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_thread_swap_exception_ports(&mut self) - -> *mut __Request__thread_swap_exception_ports_t { + pub unsafe fn Request_thread_swap_exception_ports + (&mut self) + -> *mut __Request__thread_swap_exception_ports_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_thread_policy(&mut self) - -> *mut __Request__thread_policy_t { + pub unsafe fn Request_thread_policy(&mut self) -> *mut __Request__thread_policy_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_thread_policy_set(&mut self) - -> *mut __Request__thread_policy_set_t { + pub unsafe fn Request_thread_policy_set(&mut self) -> *mut __Request__thread_policy_set_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_thread_policy_get(&mut self) - -> *mut __Request__thread_policy_get_t { + pub unsafe fn Request_thread_policy_get(&mut self) -> *mut __Request__thread_policy_get_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_thread_sample(&mut self) - -> *mut __Request__thread_sample_t { + pub unsafe fn Request_thread_sample(&mut self) -> *mut __Request__thread_sample_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_etap_trace_thread(&mut self) - -> *mut __Request__etap_trace_thread_t { + pub unsafe fn Request_etap_trace_thread(&mut self) -> *mut __Request__etap_trace_thread_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_thread_assign(&mut self) - -> *mut __Request__thread_assign_t { + pub unsafe fn Request_thread_assign(&mut self) -> *mut __Request__thread_assign_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_thread_assign_default(&mut self) - -> *mut __Request__thread_assign_default_t { + pub unsafe fn Request_thread_assign_default(&mut self) -> *mut __Request__thread_assign_default_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_thread_get_assignment(&mut self) - -> *mut __Request__thread_get_assignment_t { + pub unsafe fn Request_thread_get_assignment(&mut self) -> *mut __Request__thread_get_assignment_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_thread_set_policy(&mut self) - -> *mut __Request__thread_set_policy_t { + pub unsafe fn Request_thread_set_policy(&mut self) -> *mut __Request__thread_set_policy_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } } impl ::std::clone::Clone for Union___RequestUnion__thread_act_subsystem { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Union___RequestUnion__thread_act_subsystem { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -6659,10 +7891,14 @@ pub struct Struct_Unnamed235 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed235 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed235 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__thread_terminate_t = Struct_Unnamed235; #[repr(C)] @@ -6675,10 +7911,14 @@ pub struct Struct_Unnamed236 { pub old_state: [natural_t; 224usize], } impl ::std::clone::Clone for Struct_Unnamed236 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed236 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__act_get_state_t = Struct_Unnamed236; #[repr(C)] @@ -6689,10 +7929,14 @@ pub struct Struct_Unnamed237 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed237 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed237 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__act_set_state_t = Struct_Unnamed237; #[repr(C)] @@ -6705,10 +7949,14 @@ pub struct Struct_Unnamed238 { pub old_state: [natural_t; 224usize], } impl ::std::clone::Clone for Struct_Unnamed238 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed238 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__thread_get_state_t = Struct_Unnamed238; #[repr(C)] @@ -6719,10 +7967,14 @@ pub struct Struct_Unnamed239 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed239 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed239 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__thread_set_state_t = Struct_Unnamed239; #[repr(C)] @@ -6733,10 +7985,14 @@ pub struct Struct_Unnamed240 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed240 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed240 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__thread_suspend_t = Struct_Unnamed240; #[repr(C)] @@ -6747,10 +8003,14 @@ pub struct Struct_Unnamed241 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed241 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed241 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__thread_resume_t = Struct_Unnamed241; #[repr(C)] @@ -6761,10 +8021,14 @@ pub struct Struct_Unnamed242 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed242 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed242 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__thread_abort_t = Struct_Unnamed242; #[repr(C)] @@ -6775,10 +8039,14 @@ pub struct Struct_Unnamed243 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed243 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed243 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__thread_abort_safely_t = Struct_Unnamed243; #[repr(C)] @@ -6789,10 +8057,14 @@ pub struct Struct_Unnamed244 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed244 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed244 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__thread_depress_abort_t = Struct_Unnamed244; #[repr(C)] @@ -6803,10 +8075,14 @@ pub struct Struct_Unnamed245 { pub special_port: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed245 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed245 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__thread_get_special_port_t = Struct_Unnamed245; #[repr(C)] @@ -6817,10 +8093,14 @@ pub struct Struct_Unnamed246 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed246 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed246 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__thread_set_special_port_t = Struct_Unnamed246; #[repr(C)] @@ -6833,10 +8113,14 @@ pub struct Struct_Unnamed247 { pub thread_info_out: [integer_t; 12usize], } impl ::std::clone::Clone for Struct_Unnamed247 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed247 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__thread_info_t = Struct_Unnamed247; #[repr(C)] @@ -6847,10 +8131,14 @@ pub struct Struct_Unnamed248 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed248 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed248 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__thread_set_exception_ports_t = Struct_Unnamed248; #[repr(C)] @@ -6866,10 +8154,14 @@ pub struct Struct_Unnamed249 { pub old_flavors: [thread_state_flavor_t; 32usize], } impl ::std::clone::Clone for Struct_Unnamed249 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed249 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__thread_get_exception_ports_t = Struct_Unnamed249; #[repr(C)] @@ -6885,10 +8177,14 @@ pub struct Struct_Unnamed250 { pub old_flavors: [thread_state_flavor_t; 32usize], } impl ::std::clone::Clone for Struct_Unnamed250 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed250 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__thread_swap_exception_ports_t = Struct_Unnamed250; #[repr(C)] @@ -6899,10 +8195,14 @@ pub struct Struct_Unnamed251 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed251 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed251 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__thread_policy_t = Struct_Unnamed251; #[repr(C)] @@ -6913,10 +8213,14 @@ pub struct Struct_Unnamed252 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed252 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed252 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__thread_policy_set_t = Struct_Unnamed252; #[repr(C)] @@ -6930,10 +8234,14 @@ pub struct Struct_Unnamed253 { pub get_default: boolean_t, } impl ::std::clone::Clone for Struct_Unnamed253 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed253 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__thread_policy_get_t = Struct_Unnamed253; #[repr(C)] @@ -6944,10 +8252,14 @@ pub struct Struct_Unnamed254 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed254 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed254 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__thread_sample_t = Struct_Unnamed254; #[repr(C)] @@ -6958,10 +8270,14 @@ pub struct Struct_Unnamed255 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed255 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed255 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__etap_trace_thread_t = Struct_Unnamed255; #[repr(C)] @@ -6972,10 +8288,14 @@ pub struct Struct_Unnamed256 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed256 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed256 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__thread_assign_t = Struct_Unnamed256; #[repr(C)] @@ -6986,10 +8306,14 @@ pub struct Struct_Unnamed257 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed257 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed257 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__thread_assign_default_t = Struct_Unnamed257; #[repr(C)] @@ -7000,10 +8324,14 @@ pub struct Struct_Unnamed258 { pub assigned_set: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed258 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed258 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__thread_get_assignment_t = Struct_Unnamed258; #[repr(C)] @@ -7014,10 +8342,14 @@ pub struct Struct_Unnamed259 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed259 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed259 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__thread_set_policy_t = Struct_Unnamed259; #[repr(C)] @@ -7026,137 +8358,122 @@ pub struct Union___ReplyUnion__thread_act_subsystem { pub _bindgen_data_: [u32; 234usize], } impl Union___ReplyUnion__thread_act_subsystem { - pub unsafe fn Reply_thread_terminate(&mut self) - -> *mut __Reply__thread_terminate_t { + pub unsafe fn Reply_thread_terminate(&mut self) -> *mut __Reply__thread_terminate_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_act_get_state(&mut self) - -> *mut __Reply__act_get_state_t { + pub unsafe fn Reply_act_get_state(&mut self) -> *mut __Reply__act_get_state_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_act_set_state(&mut self) - -> *mut __Reply__act_set_state_t { + pub unsafe fn Reply_act_set_state(&mut self) -> *mut __Reply__act_set_state_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_thread_get_state(&mut self) - -> *mut __Reply__thread_get_state_t { + pub unsafe fn Reply_thread_get_state(&mut self) -> *mut __Reply__thread_get_state_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_thread_set_state(&mut self) - -> *mut __Reply__thread_set_state_t { + pub unsafe fn Reply_thread_set_state(&mut self) -> *mut __Reply__thread_set_state_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_thread_suspend(&mut self) - -> *mut __Reply__thread_suspend_t { + pub unsafe fn Reply_thread_suspend(&mut self) -> *mut __Reply__thread_suspend_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_thread_resume(&mut self) - -> *mut __Reply__thread_resume_t { + pub unsafe fn Reply_thread_resume(&mut self) -> *mut __Reply__thread_resume_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_thread_abort(&mut self) - -> *mut __Reply__thread_abort_t { + pub unsafe fn Reply_thread_abort(&mut self) -> *mut __Reply__thread_abort_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_thread_abort_safely(&mut self) - -> *mut __Reply__thread_abort_safely_t { + pub unsafe fn Reply_thread_abort_safely(&mut self) -> *mut __Reply__thread_abort_safely_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_thread_depress_abort(&mut self) - -> *mut __Reply__thread_depress_abort_t { + pub unsafe fn Reply_thread_depress_abort(&mut self) -> *mut __Reply__thread_depress_abort_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_thread_get_special_port(&mut self) - -> *mut __Reply__thread_get_special_port_t { + pub unsafe fn Reply_thread_get_special_port(&mut self) -> *mut __Reply__thread_get_special_port_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_thread_set_special_port(&mut self) - -> *mut __Reply__thread_set_special_port_t { + pub unsafe fn Reply_thread_set_special_port(&mut self) -> *mut __Reply__thread_set_special_port_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_thread_info(&mut self) - -> *mut __Reply__thread_info_t { + pub unsafe fn Reply_thread_info(&mut self) -> *mut __Reply__thread_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_thread_set_exception_ports(&mut self) - -> *mut __Reply__thread_set_exception_ports_t { + pub unsafe fn Reply_thread_set_exception_ports + (&mut self) + -> *mut __Reply__thread_set_exception_ports_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_thread_get_exception_ports(&mut self) - -> *mut __Reply__thread_get_exception_ports_t { + pub unsafe fn Reply_thread_get_exception_ports + (&mut self) + -> *mut __Reply__thread_get_exception_ports_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_thread_swap_exception_ports(&mut self) - -> *mut __Reply__thread_swap_exception_ports_t { + pub unsafe fn Reply_thread_swap_exception_ports + (&mut self) + -> *mut __Reply__thread_swap_exception_ports_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_thread_policy(&mut self) - -> *mut __Reply__thread_policy_t { + pub unsafe fn Reply_thread_policy(&mut self) -> *mut __Reply__thread_policy_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_thread_policy_set(&mut self) - -> *mut __Reply__thread_policy_set_t { + pub unsafe fn Reply_thread_policy_set(&mut self) -> *mut __Reply__thread_policy_set_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_thread_policy_get(&mut self) - -> *mut __Reply__thread_policy_get_t { + pub unsafe fn Reply_thread_policy_get(&mut self) -> *mut __Reply__thread_policy_get_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_thread_sample(&mut self) - -> *mut __Reply__thread_sample_t { + pub unsafe fn Reply_thread_sample(&mut self) -> *mut __Reply__thread_sample_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_etap_trace_thread(&mut self) - -> *mut __Reply__etap_trace_thread_t { + pub unsafe fn Reply_etap_trace_thread(&mut self) -> *mut __Reply__etap_trace_thread_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_thread_assign(&mut self) - -> *mut __Reply__thread_assign_t { + pub unsafe fn Reply_thread_assign(&mut self) -> *mut __Reply__thread_assign_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_thread_assign_default(&mut self) - -> *mut __Reply__thread_assign_default_t { + pub unsafe fn Reply_thread_assign_default(&mut self) -> *mut __Reply__thread_assign_default_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_thread_get_assignment(&mut self) - -> *mut __Reply__thread_get_assignment_t { + pub unsafe fn Reply_thread_get_assignment(&mut self) -> *mut __Reply__thread_get_assignment_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_thread_set_policy(&mut self) - -> *mut __Reply__thread_set_policy_t { + pub unsafe fn Reply_thread_set_policy(&mut self) -> *mut __Reply__thread_set_policy_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } } impl ::std::clone::Clone for Union___ReplyUnion__thread_act_subsystem { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Union___ReplyUnion__thread_act_subsystem { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -7168,10 +8485,14 @@ pub struct Struct_Unnamed260 { pub infoCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed260 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed260 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__vm_region_t = Struct_Unnamed260; #[repr(C)] @@ -7184,10 +8505,14 @@ pub struct Struct_Unnamed261 { pub flags: ::libc::c_int, } impl ::std::clone::Clone for Struct_Unnamed261 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed261 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__vm_allocate_t = Struct_Unnamed261; #[repr(C)] @@ -7199,10 +8524,14 @@ pub struct Struct_Unnamed262 { pub size: vm_size_t, } impl ::std::clone::Clone for Struct_Unnamed262 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed262 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__vm_deallocate_t = Struct_Unnamed262; #[repr(C)] @@ -7216,10 +8545,14 @@ pub struct Struct_Unnamed263 { pub new_protection: vm_prot_t, } impl ::std::clone::Clone for Struct_Unnamed263 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed263 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__vm_protect_t = Struct_Unnamed263; #[repr(C)] @@ -7232,10 +8565,14 @@ pub struct Struct_Unnamed264 { pub new_inheritance: vm_inherit_t, } impl ::std::clone::Clone for Struct_Unnamed264 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed264 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__vm_inherit_t = Struct_Unnamed264; #[repr(C)] @@ -7247,10 +8584,14 @@ pub struct Struct_Unnamed265 { pub size: vm_size_t, } impl ::std::clone::Clone for Struct_Unnamed265 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed265 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__vm_read_t = Struct_Unnamed265; #[repr(C)] @@ -7262,10 +8603,14 @@ pub struct Struct_Unnamed266 { pub count: natural_t, } impl ::std::clone::Clone for Struct_Unnamed266 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed266 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__vm_read_list_t = Struct_Unnamed266; #[repr(C)] @@ -7279,10 +8624,14 @@ pub struct Struct_Unnamed267 { pub dataCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed267 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed267 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__vm_write_t = Struct_Unnamed267; #[repr(C)] @@ -7295,10 +8644,14 @@ pub struct Struct_Unnamed268 { pub dest_address: vm_address_t, } impl ::std::clone::Clone for Struct_Unnamed268 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed268 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__vm_copy_t = Struct_Unnamed268; #[repr(C)] @@ -7311,10 +8664,14 @@ pub struct Struct_Unnamed269 { pub data: vm_address_t, } impl ::std::clone::Clone for Struct_Unnamed269 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed269 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__vm_read_overwrite_t = Struct_Unnamed269; #[repr(C)] @@ -7327,10 +8684,14 @@ pub struct Struct_Unnamed270 { pub sync_flags: vm_sync_t, } impl ::std::clone::Clone for Struct_Unnamed270 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed270 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__vm_msync_t = Struct_Unnamed270; #[repr(C)] @@ -7343,10 +8704,14 @@ pub struct Struct_Unnamed271 { pub new_behavior: vm_behavior_t, } impl ::std::clone::Clone for Struct_Unnamed271 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed271 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__vm_behavior_set_t = Struct_Unnamed271; #[repr(C)] @@ -7367,10 +8732,14 @@ pub struct Struct_Unnamed272 { pub inheritance: vm_inherit_t, } impl ::std::clone::Clone for Struct_Unnamed272 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed272 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__vm_map_t = Struct_Unnamed272; #[repr(C)] @@ -7384,10 +8753,14 @@ pub struct Struct_Unnamed273 { pub value: vm_machine_attribute_val_t, } impl ::std::clone::Clone for Struct_Unnamed273 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed273 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__vm_machine_attribute_t = Struct_Unnamed273; #[repr(C)] @@ -7406,10 +8779,14 @@ pub struct Struct_Unnamed274 { pub inheritance: vm_inherit_t, } impl ::std::clone::Clone for Struct_Unnamed274 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed274 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__vm_remap_t = Struct_Unnamed274; #[repr(C)] @@ -7420,10 +8797,14 @@ pub struct Struct_Unnamed275 { pub must_wire: boolean_t, } impl ::std::clone::Clone for Struct_Unnamed275 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed275 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__task_wire_t = Struct_Unnamed275; #[repr(C)] @@ -7438,10 +8819,14 @@ pub struct Struct_Unnamed276 { pub permission: vm_prot_t, } impl ::std::clone::Clone for Struct_Unnamed276 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed276 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__mach_make_memory_entry_t = Struct_Unnamed276; #[repr(C)] @@ -7452,10 +8837,14 @@ pub struct Struct_Unnamed277 { pub offset: vm_offset_t, } impl ::std::clone::Clone for Struct_Unnamed277 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed277 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__vm_map_page_query_t = Struct_Unnamed277; #[repr(C)] @@ -7466,10 +8855,14 @@ pub struct Struct_Unnamed278 { pub address: vm_address_t, } impl ::std::clone::Clone for Struct_Unnamed278 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed278 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__mach_vm_region_info_t = Struct_Unnamed278; #[repr(C)] @@ -7478,10 +8871,14 @@ pub struct Struct_Unnamed279 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed279 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed279 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__vm_mapped_pages_info_t = Struct_Unnamed279; #[repr(C)] @@ -7494,10 +8891,14 @@ pub struct Struct_Unnamed280 { pub infoCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed280 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed280 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__vm_region_recurse_t = Struct_Unnamed280; #[repr(C)] @@ -7510,10 +8911,14 @@ pub struct Struct_Unnamed281 { pub infoCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed281 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed281 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__vm_region_recurse_64_t = Struct_Unnamed281; #[repr(C)] @@ -7524,10 +8929,14 @@ pub struct Struct_Unnamed282 { pub address: vm_address_t, } impl ::std::clone::Clone for Struct_Unnamed282 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed282 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__mach_vm_region_info_64_t = Struct_Unnamed282; #[repr(C)] @@ -7540,10 +8949,14 @@ pub struct Struct_Unnamed283 { pub infoCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed283 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed283 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__vm_region_64_t = Struct_Unnamed283; #[repr(C)] @@ -7558,10 +8971,14 @@ pub struct Struct_Unnamed284 { pub permission: vm_prot_t, } impl ::std::clone::Clone for Struct_Unnamed284 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed284 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__mach_make_memory_entry_64_t = Struct_Unnamed284; #[repr(C)] @@ -7582,10 +8999,14 @@ pub struct Struct_Unnamed285 { pub inheritance: vm_inherit_t, } impl ::std::clone::Clone for Struct_Unnamed285 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed285 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__vm_map_64_t = Struct_Unnamed285; #[repr(C)] @@ -7598,10 +9019,14 @@ pub struct Struct_Unnamed286 { pub state: ::libc::c_int, } impl ::std::clone::Clone for Struct_Unnamed286 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed286 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__vm_purgable_control_t = Struct_Unnamed286; #[repr(C)] @@ -7610,28 +9035,23 @@ pub struct Union___RequestUnion__vm_map_subsystem { pub _bindgen_data_: [u32; 1033usize], } impl Union___RequestUnion__vm_map_subsystem { - pub unsafe fn Request_vm_region(&mut self) - -> *mut __Request__vm_region_t { + pub unsafe fn Request_vm_region(&mut self) -> *mut __Request__vm_region_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_vm_allocate(&mut self) - -> *mut __Request__vm_allocate_t { + pub unsafe fn Request_vm_allocate(&mut self) -> *mut __Request__vm_allocate_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_vm_deallocate(&mut self) - -> *mut __Request__vm_deallocate_t { + pub unsafe fn Request_vm_deallocate(&mut self) -> *mut __Request__vm_deallocate_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_vm_protect(&mut self) - -> *mut __Request__vm_protect_t { + pub unsafe fn Request_vm_protect(&mut self) -> *mut __Request__vm_protect_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_vm_inherit(&mut self) - -> *mut __Request__vm_inherit_t { + pub unsafe fn Request_vm_inherit(&mut self) -> *mut __Request__vm_inherit_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } @@ -7639,8 +9059,7 @@ impl Union___RequestUnion__vm_map_subsystem { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_vm_read_list(&mut self) - -> *mut __Request__vm_read_list_t { + pub unsafe fn Request_vm_read_list(&mut self) -> *mut __Request__vm_read_list_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } @@ -7652,8 +9071,7 @@ impl Union___RequestUnion__vm_map_subsystem { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_vm_read_overwrite(&mut self) - -> *mut __Request__vm_read_overwrite_t { + pub unsafe fn Request_vm_read_overwrite(&mut self) -> *mut __Request__vm_read_overwrite_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } @@ -7661,8 +9079,7 @@ impl Union___RequestUnion__vm_map_subsystem { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_vm_behavior_set(&mut self) - -> *mut __Request__vm_behavior_set_t { + pub unsafe fn Request_vm_behavior_set(&mut self) -> *mut __Request__vm_behavior_set_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } @@ -7670,8 +9087,7 @@ impl Union___RequestUnion__vm_map_subsystem { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_vm_machine_attribute(&mut self) - -> *mut __Request__vm_machine_attribute_t { + pub unsafe fn Request_vm_machine_attribute(&mut self) -> *mut __Request__vm_machine_attribute_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } @@ -7679,72 +9095,68 @@ impl Union___RequestUnion__vm_map_subsystem { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_task_wire(&mut self) - -> *mut __Request__task_wire_t { + pub unsafe fn Request_task_wire(&mut self) -> *mut __Request__task_wire_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_mach_make_memory_entry(&mut self) - -> *mut __Request__mach_make_memory_entry_t { + -> *mut __Request__mach_make_memory_entry_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_vm_map_page_query(&mut self) - -> *mut __Request__vm_map_page_query_t { + pub unsafe fn Request_vm_map_page_query(&mut self) -> *mut __Request__vm_map_page_query_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_mach_vm_region_info(&mut self) - -> *mut __Request__mach_vm_region_info_t { + pub unsafe fn Request_mach_vm_region_info(&mut self) -> *mut __Request__mach_vm_region_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_vm_mapped_pages_info(&mut self) - -> *mut __Request__vm_mapped_pages_info_t { + pub unsafe fn Request_vm_mapped_pages_info(&mut self) -> *mut __Request__vm_mapped_pages_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_vm_region_recurse(&mut self) - -> *mut __Request__vm_region_recurse_t { + pub unsafe fn Request_vm_region_recurse(&mut self) -> *mut __Request__vm_region_recurse_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_vm_region_recurse_64(&mut self) - -> *mut __Request__vm_region_recurse_64_t { + pub unsafe fn Request_vm_region_recurse_64(&mut self) -> *mut __Request__vm_region_recurse_64_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_mach_vm_region_info_64(&mut self) - -> *mut __Request__mach_vm_region_info_64_t { + -> *mut __Request__mach_vm_region_info_64_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_vm_region_64(&mut self) - -> *mut __Request__vm_region_64_t { + pub unsafe fn Request_vm_region_64(&mut self) -> *mut __Request__vm_region_64_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_mach_make_memory_entry_64(&mut self) - -> *mut __Request__mach_make_memory_entry_64_t { + pub unsafe fn Request_mach_make_memory_entry_64 + (&mut self) + -> *mut __Request__mach_make_memory_entry_64_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_vm_map_64(&mut self) - -> *mut __Request__vm_map_64_t { + pub unsafe fn Request_vm_map_64(&mut self) -> *mut __Request__vm_map_64_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_vm_purgable_control(&mut self) - -> *mut __Request__vm_purgable_control_t { + pub unsafe fn Request_vm_purgable_control(&mut self) -> *mut __Request__vm_purgable_control_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } } impl ::std::clone::Clone for Union___RequestUnion__vm_map_subsystem { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Union___RequestUnion__vm_map_subsystem { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -7759,10 +9171,14 @@ pub struct Struct_Unnamed287 { pub info: [::libc::c_int; 10usize], } impl ::std::clone::Clone for Struct_Unnamed287 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed287 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__vm_region_t = Struct_Unnamed287; #[repr(C)] @@ -7774,10 +9190,14 @@ pub struct Struct_Unnamed288 { pub address: vm_address_t, } impl ::std::clone::Clone for Struct_Unnamed288 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed288 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__vm_allocate_t = Struct_Unnamed288; #[repr(C)] @@ -7788,10 +9208,14 @@ pub struct Struct_Unnamed289 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed289 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed289 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__vm_deallocate_t = Struct_Unnamed289; #[repr(C)] @@ -7802,10 +9226,14 @@ pub struct Struct_Unnamed290 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed290 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed290 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__vm_protect_t = Struct_Unnamed290; #[repr(C)] @@ -7816,10 +9244,14 @@ pub struct Struct_Unnamed291 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed291 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed291 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__vm_inherit_t = Struct_Unnamed291; #[repr(C)] @@ -7832,10 +9264,14 @@ pub struct Struct_Unnamed292 { pub dataCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed292 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed292 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__vm_read_t = Struct_Unnamed292; #[repr(C)] @@ -7847,10 +9283,14 @@ pub struct Struct_Unnamed293 { pub data_list: vm_read_entry_t, } impl ::std::clone::Clone for Struct_Unnamed293 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed293 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__vm_read_list_t = Struct_Unnamed293; #[repr(C)] @@ -7861,10 +9301,14 @@ pub struct Struct_Unnamed294 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed294 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed294 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__vm_write_t = Struct_Unnamed294; #[repr(C)] @@ -7875,10 +9319,14 @@ pub struct Struct_Unnamed295 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed295 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed295 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__vm_copy_t = Struct_Unnamed295; #[repr(C)] @@ -7890,10 +9338,14 @@ pub struct Struct_Unnamed296 { pub outsize: vm_size_t, } impl ::std::clone::Clone for Struct_Unnamed296 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed296 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__vm_read_overwrite_t = Struct_Unnamed296; #[repr(C)] @@ -7904,10 +9356,14 @@ pub struct Struct_Unnamed297 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed297 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed297 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__vm_msync_t = Struct_Unnamed297; #[repr(C)] @@ -7918,10 +9374,14 @@ pub struct Struct_Unnamed298 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed298 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed298 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__vm_behavior_set_t = Struct_Unnamed298; #[repr(C)] @@ -7933,10 +9393,14 @@ pub struct Struct_Unnamed299 { pub address: vm_address_t, } impl ::std::clone::Clone for Struct_Unnamed299 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed299 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__vm_map_t = Struct_Unnamed299; #[repr(C)] @@ -7948,10 +9412,14 @@ pub struct Struct_Unnamed300 { pub value: vm_machine_attribute_val_t, } impl ::std::clone::Clone for Struct_Unnamed300 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed300 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__vm_machine_attribute_t = Struct_Unnamed300; #[repr(C)] @@ -7965,10 +9433,14 @@ pub struct Struct_Unnamed301 { pub max_protection: vm_prot_t, } impl ::std::clone::Clone for Struct_Unnamed301 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed301 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__vm_remap_t = Struct_Unnamed301; #[repr(C)] @@ -7979,10 +9451,14 @@ pub struct Struct_Unnamed302 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed302 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed302 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__task_wire_t = Struct_Unnamed302; #[repr(C)] @@ -7995,10 +9471,14 @@ pub struct Struct_Unnamed303 { pub size: vm_size_t, } impl ::std::clone::Clone for Struct_Unnamed303 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed303 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__mach_make_memory_entry_t = Struct_Unnamed303; #[repr(C)] @@ -8011,10 +9491,14 @@ pub struct Struct_Unnamed304 { pub ref_count: integer_t, } impl ::std::clone::Clone for Struct_Unnamed304 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed304 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__vm_map_page_query_t = Struct_Unnamed304; #[repr(C)] @@ -8027,10 +9511,14 @@ pub struct Struct_Unnamed306 { pub pagesCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed306 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed306 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__vm_mapped_pages_info_t = Struct_Unnamed306; #[repr(C)] @@ -8046,10 +9534,14 @@ pub struct Struct_Unnamed307 { pub info: [::libc::c_int; 19usize], } impl ::std::clone::Clone for Struct_Unnamed307 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed307 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__vm_region_recurse_t = Struct_Unnamed307; #[repr(C)] @@ -8065,10 +9557,14 @@ pub struct Struct_Unnamed308 { pub info: [::libc::c_int; 19usize], } impl ::std::clone::Clone for Struct_Unnamed308 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed308 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__vm_region_recurse_64_t = Struct_Unnamed308; #[repr(C)] @@ -8084,10 +9580,14 @@ pub struct Struct_Unnamed310 { pub info: [::libc::c_int; 10usize], } impl ::std::clone::Clone for Struct_Unnamed310 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed310 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__vm_region_64_t = Struct_Unnamed310; #[repr(C)] @@ -8100,10 +9600,14 @@ pub struct Struct_Unnamed311 { pub size: memory_object_size_t, } impl ::std::clone::Clone for Struct_Unnamed311 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed311 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__mach_make_memory_entry_64_t = Struct_Unnamed311; #[repr(C)] @@ -8115,10 +9619,14 @@ pub struct Struct_Unnamed312 { pub address: vm_address_t, } impl ::std::clone::Clone for Struct_Unnamed312 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed312 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__vm_map_64_t = Struct_Unnamed312; #[repr(C)] @@ -8130,10 +9638,14 @@ pub struct Struct_Unnamed313 { pub state: ::libc::c_int, } impl ::std::clone::Clone for Struct_Unnamed313 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed313 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__vm_purgable_control_t = Struct_Unnamed313; #[repr(C)] @@ -8146,13 +9658,11 @@ impl Union___ReplyUnion__vm_map_subsystem { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_vm_allocate(&mut self) - -> *mut __Reply__vm_allocate_t { + pub unsafe fn Reply_vm_allocate(&mut self) -> *mut __Reply__vm_allocate_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_vm_deallocate(&mut self) - -> *mut __Reply__vm_deallocate_t { + pub unsafe fn Reply_vm_deallocate(&mut self) -> *mut __Reply__vm_deallocate_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } @@ -8168,8 +9678,7 @@ impl Union___ReplyUnion__vm_map_subsystem { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_vm_read_list(&mut self) - -> *mut __Reply__vm_read_list_t { + pub unsafe fn Reply_vm_read_list(&mut self) -> *mut __Reply__vm_read_list_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } @@ -8181,8 +9690,7 @@ impl Union___ReplyUnion__vm_map_subsystem { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_vm_read_overwrite(&mut self) - -> *mut __Reply__vm_read_overwrite_t { + pub unsafe fn Reply_vm_read_overwrite(&mut self) -> *mut __Reply__vm_read_overwrite_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } @@ -8190,8 +9698,7 @@ impl Union___ReplyUnion__vm_map_subsystem { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_vm_behavior_set(&mut self) - -> *mut __Reply__vm_behavior_set_t { + pub unsafe fn Reply_vm_behavior_set(&mut self) -> *mut __Reply__vm_behavior_set_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } @@ -8199,8 +9706,7 @@ impl Union___ReplyUnion__vm_map_subsystem { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_vm_machine_attribute(&mut self) - -> *mut __Reply__vm_machine_attribute_t { + pub unsafe fn Reply_vm_machine_attribute(&mut self) -> *mut __Reply__vm_machine_attribute_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } @@ -8212,38 +9718,32 @@ impl Union___ReplyUnion__vm_map_subsystem { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_mach_make_memory_entry(&mut self) - -> *mut __Reply__mach_make_memory_entry_t { + pub unsafe fn Reply_mach_make_memory_entry(&mut self) -> *mut __Reply__mach_make_memory_entry_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_vm_map_page_query(&mut self) - -> *mut __Reply__vm_map_page_query_t { + pub unsafe fn Reply_vm_map_page_query(&mut self) -> *mut __Reply__vm_map_page_query_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_vm_mapped_pages_info(&mut self) - -> *mut __Reply__vm_mapped_pages_info_t { + pub unsafe fn Reply_vm_mapped_pages_info(&mut self) -> *mut __Reply__vm_mapped_pages_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_vm_region_recurse(&mut self) - -> *mut __Reply__vm_region_recurse_t { + pub unsafe fn Reply_vm_region_recurse(&mut self) -> *mut __Reply__vm_region_recurse_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_vm_region_recurse_64(&mut self) - -> *mut __Reply__vm_region_recurse_64_t { + pub unsafe fn Reply_vm_region_recurse_64(&mut self) -> *mut __Reply__vm_region_recurse_64_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_vm_region_64(&mut self) - -> *mut __Reply__vm_region_64_t { + pub unsafe fn Reply_vm_region_64(&mut self) -> *mut __Reply__vm_region_64_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_mach_make_memory_entry_64(&mut self) - -> *mut __Reply__mach_make_memory_entry_64_t { + -> *mut __Reply__mach_make_memory_entry_64_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } @@ -8251,17 +9751,20 @@ impl Union___ReplyUnion__vm_map_subsystem { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_vm_purgable_control(&mut self) - -> *mut __Reply__vm_purgable_control_t { + pub unsafe fn Reply_vm_purgable_control(&mut self) -> *mut __Reply__vm_purgable_control_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } } impl ::std::clone::Clone for Union___ReplyUnion__vm_map_subsystem { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Union___ReplyUnion__vm_map_subsystem { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -8269,10 +9772,14 @@ pub struct Struct_Unnamed314 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed314 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed314 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__mach_port_names_t = Struct_Unnamed314; #[repr(C)] @@ -8283,10 +9790,14 @@ pub struct Struct_Unnamed315 { pub name: mach_port_name_t, } impl ::std::clone::Clone for Struct_Unnamed315 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed315 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__mach_port_type_t = Struct_Unnamed315; #[repr(C)] @@ -8298,10 +9809,14 @@ pub struct Struct_Unnamed316 { pub new_name: mach_port_name_t, } impl ::std::clone::Clone for Struct_Unnamed316 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed316 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__mach_port_rename_t = Struct_Unnamed316; #[repr(C)] @@ -8313,10 +9828,14 @@ pub struct Struct_Unnamed317 { pub name: mach_port_name_t, } impl ::std::clone::Clone for Struct_Unnamed317 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed317 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__mach_port_allocate_name_t = Struct_Unnamed317; #[repr(C)] @@ -8327,10 +9846,14 @@ pub struct Struct_Unnamed318 { pub right: mach_port_right_t, } impl ::std::clone::Clone for Struct_Unnamed318 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed318 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__mach_port_allocate_t = Struct_Unnamed318; #[repr(C)] @@ -8341,10 +9864,14 @@ pub struct Struct_Unnamed319 { pub name: mach_port_name_t, } impl ::std::clone::Clone for Struct_Unnamed319 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed319 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__mach_port_destroy_t = Struct_Unnamed319; #[repr(C)] @@ -8355,10 +9882,14 @@ pub struct Struct_Unnamed320 { pub name: mach_port_name_t, } impl ::std::clone::Clone for Struct_Unnamed320 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed320 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__mach_port_deallocate_t = Struct_Unnamed320; #[repr(C)] @@ -8370,10 +9901,14 @@ pub struct Struct_Unnamed321 { pub right: mach_port_right_t, } impl ::std::clone::Clone for Struct_Unnamed321 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed321 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__mach_port_get_refs_t = Struct_Unnamed321; #[repr(C)] @@ -8386,10 +9921,14 @@ pub struct Struct_Unnamed322 { pub delta: mach_port_delta_t, } impl ::std::clone::Clone for Struct_Unnamed322 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed322 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__mach_port_mod_refs_t = Struct_Unnamed322; #[repr(C)] @@ -8401,10 +9940,14 @@ pub struct Struct_Unnamed323 { pub mscount: mach_port_mscount_t, } impl ::std::clone::Clone for Struct_Unnamed323 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed323 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__mach_port_set_mscount_t = Struct_Unnamed323; #[repr(C)] @@ -8415,10 +9958,14 @@ pub struct Struct_Unnamed324 { pub name: mach_port_name_t, } impl ::std::clone::Clone for Struct_Unnamed324 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed324 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__mach_port_get_set_status_t = Struct_Unnamed324; #[repr(C)] @@ -8430,10 +9977,14 @@ pub struct Struct_Unnamed325 { pub after: mach_port_name_t, } impl ::std::clone::Clone for Struct_Unnamed325 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed325 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__mach_port_move_member_t = Struct_Unnamed325; #[repr(C)] @@ -8448,10 +9999,14 @@ pub struct Struct_Unnamed326 { pub sync: mach_port_mscount_t, } impl ::std::clone::Clone for Struct_Unnamed326 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed326 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__mach_port_request_notification_t = Struct_Unnamed326; #[repr(C)] @@ -8464,10 +10019,14 @@ pub struct Struct_Unnamed327 { pub name: mach_port_name_t, } impl ::std::clone::Clone for Struct_Unnamed327 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed327 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__mach_port_insert_right_t = Struct_Unnamed327; #[repr(C)] @@ -8479,10 +10038,14 @@ pub struct Struct_Unnamed328 { pub msgt_name: mach_msg_type_name_t, } impl ::std::clone::Clone for Struct_Unnamed328 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed328 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__mach_port_extract_right_t = Struct_Unnamed328; #[repr(C)] @@ -8494,10 +10057,14 @@ pub struct Struct_Unnamed329 { pub seqno: mach_port_seqno_t, } impl ::std::clone::Clone for Struct_Unnamed329 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed329 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__mach_port_set_seqno_t = Struct_Unnamed329; #[repr(C)] @@ -8510,10 +10077,14 @@ pub struct Struct_Unnamed330 { pub port_info_outCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed330 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed330 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__mach_port_get_attributes_t = Struct_Unnamed330; #[repr(C)] @@ -8527,10 +10098,14 @@ pub struct Struct_Unnamed331 { pub port_info: [integer_t; 10usize], } impl ::std::clone::Clone for Struct_Unnamed331 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed331 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__mach_port_set_attributes_t = Struct_Unnamed331; #[repr(C)] @@ -8542,10 +10117,14 @@ pub struct Struct_Unnamed332 { pub qos: mach_port_qos_t, } impl ::std::clone::Clone for Struct_Unnamed332 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed332 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__mach_port_allocate_qos_t = Struct_Unnamed332; #[repr(C)] @@ -8560,10 +10139,14 @@ pub struct Struct_Unnamed333 { pub name: mach_port_name_t, } impl ::std::clone::Clone for Struct_Unnamed333 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed333 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__mach_port_allocate_full_t = Struct_Unnamed333; #[repr(C)] @@ -8574,10 +10157,14 @@ pub struct Struct_Unnamed334 { pub table_entries: ::libc::c_int, } impl ::std::clone::Clone for Struct_Unnamed334 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed334 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__task_set_port_space_t = Struct_Unnamed334; #[repr(C)] @@ -8588,10 +10175,14 @@ pub struct Struct_Unnamed335 { pub name: mach_port_name_t, } impl ::std::clone::Clone for Struct_Unnamed335 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed335 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__mach_port_get_srights_t = Struct_Unnamed335; #[repr(C)] @@ -8600,10 +10191,14 @@ pub struct Struct_Unnamed336 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed336 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed336 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__mach_port_space_info_t = Struct_Unnamed336; #[repr(C)] @@ -8614,10 +10209,14 @@ pub struct Struct_Unnamed337 { pub name: mach_port_name_t, } impl ::std::clone::Clone for Struct_Unnamed337 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed337 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__mach_port_dnrequest_info_t = Struct_Unnamed337; #[repr(C)] @@ -8628,10 +10227,14 @@ pub struct Struct_Unnamed338 { pub name: mach_port_name_t, } impl ::std::clone::Clone for Struct_Unnamed338 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed338 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__mach_port_kernel_object_t = Struct_Unnamed338; #[repr(C)] @@ -8643,10 +10246,14 @@ pub struct Struct_Unnamed339 { pub pset: mach_port_name_t, } impl ::std::clone::Clone for Struct_Unnamed339 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed339 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__mach_port_insert_member_t = Struct_Unnamed339; #[repr(C)] @@ -8658,10 +10265,14 @@ pub struct Struct_Unnamed340 { pub pset: mach_port_name_t, } impl ::std::clone::Clone for Struct_Unnamed340 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed340 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__mach_port_extract_member_t = Struct_Unnamed340; #[repr(C)] @@ -8672,10 +10283,14 @@ pub struct Struct_Unnamed341 { pub name: mach_port_name_t, } impl ::std::clone::Clone for Struct_Unnamed341 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed341 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__mach_port_get_context_t = Struct_Unnamed341; #[repr(C)] @@ -8687,10 +10302,14 @@ pub struct Struct_Unnamed342 { pub context: mach_port_context_t, } impl ::std::clone::Clone for Struct_Unnamed342 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed342 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__mach_port_set_context_t = Struct_Unnamed342; #[repr(C)] @@ -8701,10 +10320,14 @@ pub struct Struct_Unnamed343 { pub name: mach_port_name_t, } impl ::std::clone::Clone for Struct_Unnamed343 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed343 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__mach_port_kobject_t = Struct_Unnamed343; #[repr(C)] @@ -8713,162 +10336,155 @@ pub struct Union___RequestUnion__mach_port_subsystem { pub _bindgen_data_: [u32; 21usize], } impl Union___RequestUnion__mach_port_subsystem { - pub unsafe fn Request_mach_port_names(&mut self) - -> *mut __Request__mach_port_names_t { + pub unsafe fn Request_mach_port_names(&mut self) -> *mut __Request__mach_port_names_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_mach_port_type(&mut self) - -> *mut __Request__mach_port_type_t { + pub unsafe fn Request_mach_port_type(&mut self) -> *mut __Request__mach_port_type_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_mach_port_rename(&mut self) - -> *mut __Request__mach_port_rename_t { + pub unsafe fn Request_mach_port_rename(&mut self) -> *mut __Request__mach_port_rename_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_mach_port_allocate_name(&mut self) - -> *mut __Request__mach_port_allocate_name_t { + -> *mut __Request__mach_port_allocate_name_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_mach_port_allocate(&mut self) - -> *mut __Request__mach_port_allocate_t { + pub unsafe fn Request_mach_port_allocate(&mut self) -> *mut __Request__mach_port_allocate_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_mach_port_destroy(&mut self) - -> *mut __Request__mach_port_destroy_t { + pub unsafe fn Request_mach_port_destroy(&mut self) -> *mut __Request__mach_port_destroy_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_mach_port_deallocate(&mut self) - -> *mut __Request__mach_port_deallocate_t { + pub unsafe fn Request_mach_port_deallocate(&mut self) -> *mut __Request__mach_port_deallocate_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_mach_port_get_refs(&mut self) - -> *mut __Request__mach_port_get_refs_t { + pub unsafe fn Request_mach_port_get_refs(&mut self) -> *mut __Request__mach_port_get_refs_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_mach_port_mod_refs(&mut self) - -> *mut __Request__mach_port_mod_refs_t { + pub unsafe fn Request_mach_port_mod_refs(&mut self) -> *mut __Request__mach_port_mod_refs_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_mach_port_set_mscount(&mut self) - -> *mut __Request__mach_port_set_mscount_t { + pub unsafe fn Request_mach_port_set_mscount(&mut self) -> *mut __Request__mach_port_set_mscount_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_mach_port_get_set_status(&mut self) - -> *mut __Request__mach_port_get_set_status_t { + pub unsafe fn Request_mach_port_get_set_status + (&mut self) + -> *mut __Request__mach_port_get_set_status_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_mach_port_move_member(&mut self) - -> *mut __Request__mach_port_move_member_t { + pub unsafe fn Request_mach_port_move_member(&mut self) -> *mut __Request__mach_port_move_member_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_mach_port_request_notification(&mut self) - -> *mut __Request__mach_port_request_notification_t { + pub unsafe fn Request_mach_port_request_notification + (&mut self) + -> *mut __Request__mach_port_request_notification_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_mach_port_insert_right(&mut self) - -> *mut __Request__mach_port_insert_right_t { + -> *mut __Request__mach_port_insert_right_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_mach_port_extract_right(&mut self) - -> *mut __Request__mach_port_extract_right_t { + -> *mut __Request__mach_port_extract_right_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_mach_port_set_seqno(&mut self) - -> *mut __Request__mach_port_set_seqno_t { + pub unsafe fn Request_mach_port_set_seqno(&mut self) -> *mut __Request__mach_port_set_seqno_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_mach_port_get_attributes(&mut self) - -> *mut __Request__mach_port_get_attributes_t { + pub unsafe fn Request_mach_port_get_attributes + (&mut self) + -> *mut __Request__mach_port_get_attributes_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_mach_port_set_attributes(&mut self) - -> *mut __Request__mach_port_set_attributes_t { + pub unsafe fn Request_mach_port_set_attributes + (&mut self) + -> *mut __Request__mach_port_set_attributes_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_mach_port_allocate_qos(&mut self) - -> *mut __Request__mach_port_allocate_qos_t { + -> *mut __Request__mach_port_allocate_qos_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_mach_port_allocate_full(&mut self) - -> *mut __Request__mach_port_allocate_full_t { + -> *mut __Request__mach_port_allocate_full_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_task_set_port_space(&mut self) - -> *mut __Request__task_set_port_space_t { + pub unsafe fn Request_task_set_port_space(&mut self) -> *mut __Request__task_set_port_space_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_mach_port_get_srights(&mut self) - -> *mut __Request__mach_port_get_srights_t { + pub unsafe fn Request_mach_port_get_srights(&mut self) -> *mut __Request__mach_port_get_srights_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_mach_port_space_info(&mut self) - -> *mut __Request__mach_port_space_info_t { + pub unsafe fn Request_mach_port_space_info(&mut self) -> *mut __Request__mach_port_space_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_mach_port_dnrequest_info(&mut self) - -> *mut __Request__mach_port_dnrequest_info_t { + pub unsafe fn Request_mach_port_dnrequest_info + (&mut self) + -> *mut __Request__mach_port_dnrequest_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_mach_port_kernel_object(&mut self) - -> *mut __Request__mach_port_kernel_object_t { + -> *mut __Request__mach_port_kernel_object_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_mach_port_insert_member(&mut self) - -> *mut __Request__mach_port_insert_member_t { + -> *mut __Request__mach_port_insert_member_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_mach_port_extract_member(&mut self) - -> *mut __Request__mach_port_extract_member_t { + pub unsafe fn Request_mach_port_extract_member + (&mut self) + -> *mut __Request__mach_port_extract_member_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_mach_port_get_context(&mut self) - -> *mut __Request__mach_port_get_context_t { + pub unsafe fn Request_mach_port_get_context(&mut self) -> *mut __Request__mach_port_get_context_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_mach_port_set_context(&mut self) - -> *mut __Request__mach_port_set_context_t { + pub unsafe fn Request_mach_port_set_context(&mut self) -> *mut __Request__mach_port_set_context_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_mach_port_kobject(&mut self) - -> *mut __Request__mach_port_kobject_t { + pub unsafe fn Request_mach_port_kobject(&mut self) -> *mut __Request__mach_port_kobject_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } } impl ::std::clone::Clone for Union___RequestUnion__mach_port_subsystem { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Union___RequestUnion__mach_port_subsystem { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -8882,10 +10498,14 @@ pub struct Struct_Unnamed344 { pub typesCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed344 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed344 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__mach_port_names_t = Struct_Unnamed344; #[repr(C)] @@ -8897,10 +10517,14 @@ pub struct Struct_Unnamed345 { pub ptype: mach_port_type_t, } impl ::std::clone::Clone for Struct_Unnamed345 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed345 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__mach_port_type_t = Struct_Unnamed345; #[repr(C)] @@ -8911,10 +10535,14 @@ pub struct Struct_Unnamed346 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed346 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed346 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__mach_port_rename_t = Struct_Unnamed346; #[repr(C)] @@ -8925,10 +10553,14 @@ pub struct Struct_Unnamed347 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed347 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed347 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__mach_port_allocate_name_t = Struct_Unnamed347; #[repr(C)] @@ -8940,10 +10572,14 @@ pub struct Struct_Unnamed348 { pub name: mach_port_name_t, } impl ::std::clone::Clone for Struct_Unnamed348 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed348 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__mach_port_allocate_t = Struct_Unnamed348; #[repr(C)] @@ -8954,10 +10590,14 @@ pub struct Struct_Unnamed349 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed349 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed349 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__mach_port_destroy_t = Struct_Unnamed349; #[repr(C)] @@ -8968,10 +10608,14 @@ pub struct Struct_Unnamed350 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed350 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed350 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__mach_port_deallocate_t = Struct_Unnamed350; #[repr(C)] @@ -8983,10 +10627,14 @@ pub struct Struct_Unnamed351 { pub refs: mach_port_urefs_t, } impl ::std::clone::Clone for Struct_Unnamed351 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed351 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__mach_port_get_refs_t = Struct_Unnamed351; #[repr(C)] @@ -8997,10 +10645,14 @@ pub struct Struct_Unnamed352 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed352 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed352 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__mach_port_mod_refs_t = Struct_Unnamed352; #[repr(C)] @@ -9011,10 +10663,14 @@ pub struct Struct_Unnamed353 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed353 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed353 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__mach_port_set_mscount_t = Struct_Unnamed353; #[repr(C)] @@ -9027,10 +10683,14 @@ pub struct Struct_Unnamed354 { pub membersCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed354 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed354 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__mach_port_get_set_status_t = Struct_Unnamed354; #[repr(C)] @@ -9041,10 +10701,14 @@ pub struct Struct_Unnamed355 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed355 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed355 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__mach_port_move_member_t = Struct_Unnamed355; #[repr(C)] @@ -9055,10 +10719,14 @@ pub struct Struct_Unnamed356 { pub previous: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed356 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed356 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__mach_port_request_notification_t = Struct_Unnamed356; #[repr(C)] @@ -9069,10 +10737,14 @@ pub struct Struct_Unnamed357 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed357 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed357 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__mach_port_insert_right_t = Struct_Unnamed357; #[repr(C)] @@ -9083,10 +10755,14 @@ pub struct Struct_Unnamed358 { pub poly: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed358 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed358 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__mach_port_extract_right_t = Struct_Unnamed358; #[repr(C)] @@ -9097,10 +10773,14 @@ pub struct Struct_Unnamed359 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed359 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed359 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__mach_port_set_seqno_t = Struct_Unnamed359; #[repr(C)] @@ -9113,10 +10793,14 @@ pub struct Struct_Unnamed360 { pub port_info_out: [integer_t; 10usize], } impl ::std::clone::Clone for Struct_Unnamed360 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed360 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__mach_port_get_attributes_t = Struct_Unnamed360; #[repr(C)] @@ -9127,10 +10811,14 @@ pub struct Struct_Unnamed361 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed361 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed361 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__mach_port_set_attributes_t = Struct_Unnamed361; #[repr(C)] @@ -9143,10 +10831,14 @@ pub struct Struct_Unnamed362 { pub name: mach_port_name_t, } impl ::std::clone::Clone for Struct_Unnamed362 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed362 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__mach_port_allocate_qos_t = Struct_Unnamed362; #[repr(C)] @@ -9159,10 +10851,14 @@ pub struct Struct_Unnamed363 { pub name: mach_port_name_t, } impl ::std::clone::Clone for Struct_Unnamed363 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed363 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__mach_port_allocate_full_t = Struct_Unnamed363; #[repr(C)] @@ -9173,10 +10869,14 @@ pub struct Struct_Unnamed364 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed364 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed364 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__task_set_port_space_t = Struct_Unnamed364; #[repr(C)] @@ -9188,10 +10888,14 @@ pub struct Struct_Unnamed365 { pub srights: mach_port_rights_t, } impl ::std::clone::Clone for Struct_Unnamed365 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed365 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__mach_port_get_srights_t = Struct_Unnamed365; #[repr(C)] @@ -9204,10 +10908,14 @@ pub struct Struct_Unnamed367 { pub dnr_used: ::libc::c_uint, } impl ::std::clone::Clone for Struct_Unnamed367 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed367 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__mach_port_dnrequest_info_t = Struct_Unnamed367; #[repr(C)] @@ -9220,10 +10928,14 @@ pub struct Struct_Unnamed368 { pub object_addr: ::libc::c_uint, } impl ::std::clone::Clone for Struct_Unnamed368 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed368 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__mach_port_kernel_object_t = Struct_Unnamed368; #[repr(C)] @@ -9234,10 +10946,14 @@ pub struct Struct_Unnamed369 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed369 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed369 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__mach_port_insert_member_t = Struct_Unnamed369; #[repr(C)] @@ -9248,10 +10964,14 @@ pub struct Struct_Unnamed370 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed370 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed370 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__mach_port_extract_member_t = Struct_Unnamed370; #[repr(C)] @@ -9263,10 +10983,14 @@ pub struct Struct_Unnamed371 { pub context: mach_port_context_t, } impl ::std::clone::Clone for Struct_Unnamed371 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed371 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__mach_port_get_context_t = Struct_Unnamed371; #[repr(C)] @@ -9277,10 +11001,14 @@ pub struct Struct_Unnamed372 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed372 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed372 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__mach_port_set_context_t = Struct_Unnamed372; #[repr(C)] @@ -9293,10 +11021,14 @@ pub struct Struct_Unnamed373 { pub object_addr: mach_vm_address_t, } impl ::std::clone::Clone for Struct_Unnamed373 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed373 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__mach_port_kobject_t = Struct_Unnamed373; #[repr(C)] @@ -9305,157 +11037,139 @@ pub struct Union___ReplyUnion__mach_port_subsystem { pub _bindgen_data_: [u32; 25usize], } impl Union___ReplyUnion__mach_port_subsystem { - pub unsafe fn Reply_mach_port_names(&mut self) - -> *mut __Reply__mach_port_names_t { + pub unsafe fn Reply_mach_port_names(&mut self) -> *mut __Reply__mach_port_names_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_mach_port_type(&mut self) - -> *mut __Reply__mach_port_type_t { + pub unsafe fn Reply_mach_port_type(&mut self) -> *mut __Reply__mach_port_type_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_mach_port_rename(&mut self) - -> *mut __Reply__mach_port_rename_t { + pub unsafe fn Reply_mach_port_rename(&mut self) -> *mut __Reply__mach_port_rename_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_mach_port_allocate_name(&mut self) - -> *mut __Reply__mach_port_allocate_name_t { + pub unsafe fn Reply_mach_port_allocate_name(&mut self) -> *mut __Reply__mach_port_allocate_name_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_mach_port_allocate(&mut self) - -> *mut __Reply__mach_port_allocate_t { + pub unsafe fn Reply_mach_port_allocate(&mut self) -> *mut __Reply__mach_port_allocate_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_mach_port_destroy(&mut self) - -> *mut __Reply__mach_port_destroy_t { + pub unsafe fn Reply_mach_port_destroy(&mut self) -> *mut __Reply__mach_port_destroy_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_mach_port_deallocate(&mut self) - -> *mut __Reply__mach_port_deallocate_t { + pub unsafe fn Reply_mach_port_deallocate(&mut self) -> *mut __Reply__mach_port_deallocate_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_mach_port_get_refs(&mut self) - -> *mut __Reply__mach_port_get_refs_t { + pub unsafe fn Reply_mach_port_get_refs(&mut self) -> *mut __Reply__mach_port_get_refs_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_mach_port_mod_refs(&mut self) - -> *mut __Reply__mach_port_mod_refs_t { + pub unsafe fn Reply_mach_port_mod_refs(&mut self) -> *mut __Reply__mach_port_mod_refs_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_mach_port_set_mscount(&mut self) - -> *mut __Reply__mach_port_set_mscount_t { + pub unsafe fn Reply_mach_port_set_mscount(&mut self) -> *mut __Reply__mach_port_set_mscount_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_mach_port_get_set_status(&mut self) - -> *mut __Reply__mach_port_get_set_status_t { + -> *mut __Reply__mach_port_get_set_status_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_mach_port_move_member(&mut self) - -> *mut __Reply__mach_port_move_member_t { + pub unsafe fn Reply_mach_port_move_member(&mut self) -> *mut __Reply__mach_port_move_member_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_mach_port_request_notification(&mut self) - -> *mut __Reply__mach_port_request_notification_t { + pub unsafe fn Reply_mach_port_request_notification + (&mut self) + -> *mut __Reply__mach_port_request_notification_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_mach_port_insert_right(&mut self) - -> *mut __Reply__mach_port_insert_right_t { + pub unsafe fn Reply_mach_port_insert_right(&mut self) -> *mut __Reply__mach_port_insert_right_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_mach_port_extract_right(&mut self) - -> *mut __Reply__mach_port_extract_right_t { + pub unsafe fn Reply_mach_port_extract_right(&mut self) -> *mut __Reply__mach_port_extract_right_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_mach_port_set_seqno(&mut self) - -> *mut __Reply__mach_port_set_seqno_t { + pub unsafe fn Reply_mach_port_set_seqno(&mut self) -> *mut __Reply__mach_port_set_seqno_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_mach_port_get_attributes(&mut self) - -> *mut __Reply__mach_port_get_attributes_t { + -> *mut __Reply__mach_port_get_attributes_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_mach_port_set_attributes(&mut self) - -> *mut __Reply__mach_port_set_attributes_t { + -> *mut __Reply__mach_port_set_attributes_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_mach_port_allocate_qos(&mut self) - -> *mut __Reply__mach_port_allocate_qos_t { + pub unsafe fn Reply_mach_port_allocate_qos(&mut self) -> *mut __Reply__mach_port_allocate_qos_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_mach_port_allocate_full(&mut self) - -> *mut __Reply__mach_port_allocate_full_t { + pub unsafe fn Reply_mach_port_allocate_full(&mut self) -> *mut __Reply__mach_port_allocate_full_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_task_set_port_space(&mut self) - -> *mut __Reply__task_set_port_space_t { + pub unsafe fn Reply_task_set_port_space(&mut self) -> *mut __Reply__task_set_port_space_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_mach_port_get_srights(&mut self) - -> *mut __Reply__mach_port_get_srights_t { + pub unsafe fn Reply_mach_port_get_srights(&mut self) -> *mut __Reply__mach_port_get_srights_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_mach_port_dnrequest_info(&mut self) - -> *mut __Reply__mach_port_dnrequest_info_t { + -> *mut __Reply__mach_port_dnrequest_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_mach_port_kernel_object(&mut self) - -> *mut __Reply__mach_port_kernel_object_t { + pub unsafe fn Reply_mach_port_kernel_object(&mut self) -> *mut __Reply__mach_port_kernel_object_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_mach_port_insert_member(&mut self) - -> *mut __Reply__mach_port_insert_member_t { + pub unsafe fn Reply_mach_port_insert_member(&mut self) -> *mut __Reply__mach_port_insert_member_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_mach_port_extract_member(&mut self) - -> *mut __Reply__mach_port_extract_member_t { + -> *mut __Reply__mach_port_extract_member_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_mach_port_get_context(&mut self) - -> *mut __Reply__mach_port_get_context_t { + pub unsafe fn Reply_mach_port_get_context(&mut self) -> *mut __Reply__mach_port_get_context_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_mach_port_set_context(&mut self) - -> *mut __Reply__mach_port_set_context_t { + pub unsafe fn Reply_mach_port_set_context(&mut self) -> *mut __Reply__mach_port_set_context_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_mach_port_kobject(&mut self) - -> *mut __Reply__mach_port_kobject_t { + pub unsafe fn Reply_mach_port_kobject(&mut self) -> *mut __Reply__mach_port_kobject_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } } impl ::std::clone::Clone for Union___ReplyUnion__mach_port_subsystem { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Union___ReplyUnion__mach_port_subsystem { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -9466,10 +11180,14 @@ pub struct Struct_Unnamed374 { pub host_info_outCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed374 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed374 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__host_info_t = Struct_Unnamed374; #[repr(C)] @@ -9478,10 +11196,14 @@ pub struct Struct_Unnamed375 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed375 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed375 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__host_kernel_version_t = Struct_Unnamed375; #[repr(C)] @@ -9490,10 +11212,14 @@ pub struct Struct_Unnamed376 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed376 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed376 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request___host_page_size_t = Struct_Unnamed376; #[repr(C)] @@ -9508,10 +11234,14 @@ pub struct Struct_Unnamed377 { pub permission: vm_prot_t, } impl ::std::clone::Clone for Struct_Unnamed377 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed377 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__mach_memory_object_memory_entry_t = Struct_Unnamed377; #[repr(C)] @@ -9522,10 +11252,14 @@ pub struct Struct_Unnamed378 { pub flavor: processor_flavor_t, } impl ::std::clone::Clone for Struct_Unnamed378 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed378 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__host_processor_info_t = Struct_Unnamed378; #[repr(C)] @@ -9534,10 +11268,14 @@ pub struct Struct_Unnamed379 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed379 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed379 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__host_get_io_master_t = Struct_Unnamed379; #[repr(C)] @@ -9548,10 +11286,14 @@ pub struct Struct_Unnamed380 { pub clock_id: clock_id_t, } impl ::std::clone::Clone for Struct_Unnamed380 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed380 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__host_get_clock_service_t = Struct_Unnamed380; #[repr(C)] @@ -9560,10 +11302,14 @@ pub struct Struct_Unnamed381 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed381 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed381 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__kmod_get_info_t = Struct_Unnamed381; #[repr(C)] @@ -9572,10 +11318,14 @@ pub struct Struct_Unnamed382 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed382 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed382 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__host_zone_info_t = Struct_Unnamed382; #[repr(C)] @@ -9584,10 +11334,14 @@ pub struct Struct_Unnamed383 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed383 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed383 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__host_virtual_physical_table_info_t = Struct_Unnamed383; #[repr(C)] @@ -9596,10 +11350,14 @@ pub struct Struct_Unnamed384 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed384 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed384 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__processor_set_default_t = Struct_Unnamed384; #[repr(C)] @@ -9608,10 +11366,14 @@ pub struct Struct_Unnamed385 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed385 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed385 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__processor_set_create_t = Struct_Unnamed385; #[repr(C)] @@ -9626,10 +11388,14 @@ pub struct Struct_Unnamed386 { pub permission: vm_prot_t, } impl ::std::clone::Clone for Struct_Unnamed386 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed386 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__mach_memory_object_memory_entry_64_t = Struct_Unnamed386; #[repr(C)] @@ -9641,10 +11407,14 @@ pub struct Struct_Unnamed387 { pub host_info_outCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed387 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed387 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__host_statistics_t = Struct_Unnamed387; #[repr(C)] @@ -9657,10 +11427,14 @@ pub struct Struct_Unnamed388 { pub notify_type: host_flavor_t, } impl ::std::clone::Clone for Struct_Unnamed388 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed388 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__host_request_notification_t = Struct_Unnamed388; #[repr(C)] @@ -9669,10 +11443,14 @@ pub struct Struct_Unnamed389 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed389 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed389 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__host_lockgroup_info_t = Struct_Unnamed389; #[repr(C)] @@ -9684,10 +11462,14 @@ pub struct Struct_Unnamed390 { pub host_info64_outCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed390 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed390 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__host_statistics64_t = Struct_Unnamed390; #[repr(C)] @@ -9696,10 +11478,14 @@ pub struct Struct_Unnamed391 { pub Head: mach_msg_header_t, } impl ::std::clone::Clone for Struct_Unnamed391 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed391 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Request__mach_zone_info_t = Struct_Unnamed391; #[repr(C)] @@ -9708,102 +11494,97 @@ pub struct Union___RequestUnion__mach_host_subsystem { pub _bindgen_data_: [u32; 16usize], } impl Union___RequestUnion__mach_host_subsystem { - pub unsafe fn Request_host_info(&mut self) - -> *mut __Request__host_info_t { + pub unsafe fn Request_host_info(&mut self) -> *mut __Request__host_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_host_kernel_version(&mut self) - -> *mut __Request__host_kernel_version_t { + pub unsafe fn Request_host_kernel_version(&mut self) -> *mut __Request__host_kernel_version_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request__host_page_size(&mut self) - -> *mut __Request___host_page_size_t { + pub unsafe fn Request__host_page_size(&mut self) -> *mut __Request___host_page_size_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_mach_memory_object_memory_entry(&mut self) - -> *mut __Request__mach_memory_object_memory_entry_t { + pub unsafe fn Request_mach_memory_object_memory_entry + (&mut self) + -> *mut __Request__mach_memory_object_memory_entry_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_host_processor_info(&mut self) - -> *mut __Request__host_processor_info_t { + pub unsafe fn Request_host_processor_info(&mut self) -> *mut __Request__host_processor_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_host_get_io_master(&mut self) - -> *mut __Request__host_get_io_master_t { + pub unsafe fn Request_host_get_io_master(&mut self) -> *mut __Request__host_get_io_master_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Request_host_get_clock_service(&mut self) - -> *mut __Request__host_get_clock_service_t { + -> *mut __Request__host_get_clock_service_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_kmod_get_info(&mut self) - -> *mut __Request__kmod_get_info_t { + pub unsafe fn Request_kmod_get_info(&mut self) -> *mut __Request__kmod_get_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_host_zone_info(&mut self) - -> *mut __Request__host_zone_info_t { + pub unsafe fn Request_host_zone_info(&mut self) -> *mut __Request__host_zone_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_host_virtual_physical_table_info(&mut self) - -> *mut __Request__host_virtual_physical_table_info_t { + pub unsafe fn Request_host_virtual_physical_table_info + (&mut self) + -> *mut __Request__host_virtual_physical_table_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_processor_set_default(&mut self) - -> *mut __Request__processor_set_default_t { + pub unsafe fn Request_processor_set_default(&mut self) -> *mut __Request__processor_set_default_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_processor_set_create(&mut self) - -> *mut __Request__processor_set_create_t { + pub unsafe fn Request_processor_set_create(&mut self) -> *mut __Request__processor_set_create_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_mach_memory_object_memory_entry_64(&mut self) - -> *mut __Request__mach_memory_object_memory_entry_64_t { + pub unsafe fn Request_mach_memory_object_memory_entry_64 + (&mut self) + -> *mut __Request__mach_memory_object_memory_entry_64_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_host_statistics(&mut self) - -> *mut __Request__host_statistics_t { + pub unsafe fn Request_host_statistics(&mut self) -> *mut __Request__host_statistics_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_host_request_notification(&mut self) - -> *mut __Request__host_request_notification_t { + pub unsafe fn Request_host_request_notification + (&mut self) + -> *mut __Request__host_request_notification_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_host_lockgroup_info(&mut self) - -> *mut __Request__host_lockgroup_info_t { + pub unsafe fn Request_host_lockgroup_info(&mut self) -> *mut __Request__host_lockgroup_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_host_statistics64(&mut self) - -> *mut __Request__host_statistics64_t { + pub unsafe fn Request_host_statistics64(&mut self) -> *mut __Request__host_statistics64_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Request_mach_zone_info(&mut self) - -> *mut __Request__mach_zone_info_t { + pub unsafe fn Request_mach_zone_info(&mut self) -> *mut __Request__mach_zone_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } } impl ::std::clone::Clone for Union___RequestUnion__mach_host_subsystem { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Union___RequestUnion__mach_host_subsystem { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -9815,10 +11596,14 @@ pub struct Struct_Unnamed392 { pub host_info_out: [integer_t; 18usize], } impl ::std::clone::Clone for Struct_Unnamed392 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed392 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__host_info_t = Struct_Unnamed392; #[repr(C)] @@ -9832,10 +11617,14 @@ pub struct Struct_Unnamed393 { pub kernel_version: [::libc::c_char; 512usize], } impl ::std::clone::Clone for Struct_Unnamed393 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed393 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__host_kernel_version_t = Struct_Unnamed393; #[repr(C)] @@ -9847,10 +11636,14 @@ pub struct Struct_Unnamed394 { pub out_page_size: vm_size_t, } impl ::std::clone::Clone for Struct_Unnamed394 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed394 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply___host_page_size_t = Struct_Unnamed394; #[repr(C)] @@ -9861,10 +11654,14 @@ pub struct Struct_Unnamed395 { pub entry_handle: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed395 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed395 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__mach_memory_object_memory_entry_t = Struct_Unnamed395; #[repr(C)] @@ -9878,10 +11675,14 @@ pub struct Struct_Unnamed396 { pub out_processor_infoCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed396 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed396 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__host_processor_info_t = Struct_Unnamed396; #[repr(C)] @@ -9892,10 +11693,14 @@ pub struct Struct_Unnamed397 { pub io_master: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed397 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed397 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__host_get_io_master_t = Struct_Unnamed397; #[repr(C)] @@ -9906,10 +11711,14 @@ pub struct Struct_Unnamed398 { pub clock_serv: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed398 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed398 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__host_get_clock_service_t = Struct_Unnamed398; #[repr(C)] @@ -9922,10 +11731,14 @@ pub struct Struct_Unnamed399 { pub modulesCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed399 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed399 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__kmod_get_info_t = Struct_Unnamed399; #[repr(C)] @@ -9940,10 +11753,14 @@ pub struct Struct_Unnamed400 { pub infoCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed400 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed400 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__host_zone_info_t = Struct_Unnamed400; #[repr(C)] @@ -9956,10 +11773,14 @@ pub struct Struct_Unnamed401 { pub infoCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed401 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed401 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__host_virtual_physical_table_info_t = Struct_Unnamed401; #[repr(C)] @@ -9970,10 +11791,14 @@ pub struct Struct_Unnamed402 { pub default_set: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed402 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed402 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__processor_set_default_t = Struct_Unnamed402; #[repr(C)] @@ -9985,10 +11810,14 @@ pub struct Struct_Unnamed403 { pub new_name: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed403 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed403 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__processor_set_create_t = Struct_Unnamed403; #[repr(C)] @@ -9999,10 +11828,14 @@ pub struct Struct_Unnamed404 { pub entry_handle: mach_msg_port_descriptor_t, } impl ::std::clone::Clone for Struct_Unnamed404 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed404 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__mach_memory_object_memory_entry_64_t = Struct_Unnamed404; #[repr(C)] @@ -10015,10 +11848,14 @@ pub struct Struct_Unnamed405 { pub host_info_out: [integer_t; 18usize], } impl ::std::clone::Clone for Struct_Unnamed405 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed405 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__host_statistics_t = Struct_Unnamed405; #[repr(C)] @@ -10029,10 +11866,14 @@ pub struct Struct_Unnamed406 { pub RetCode: kern_return_t, } impl ::std::clone::Clone for Struct_Unnamed406 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed406 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__host_request_notification_t = Struct_Unnamed406; #[repr(C)] @@ -10045,10 +11886,14 @@ pub struct Struct_Unnamed407 { pub lockgroup_infoCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed407 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed407 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__host_lockgroup_info_t = Struct_Unnamed407; #[repr(C)] @@ -10061,10 +11906,14 @@ pub struct Struct_Unnamed408 { pub host_info64_out: [integer_t; 256usize], } impl ::std::clone::Clone for Struct_Unnamed408 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed408 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__host_statistics64_t = Struct_Unnamed408; #[repr(C)] @@ -10079,10 +11928,14 @@ pub struct Struct_Unnamed409 { pub infoCnt: mach_msg_type_number_t, } impl ::std::clone::Clone for Struct_Unnamed409 { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_Unnamed409 { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type __Reply__mach_zone_info_t = Struct_Unnamed409; #[repr(C)] @@ -10095,97 +11948,91 @@ impl Union___ReplyUnion__mach_host_subsystem { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_host_kernel_version(&mut self) - -> *mut __Reply__host_kernel_version_t { + pub unsafe fn Reply_host_kernel_version(&mut self) -> *mut __Reply__host_kernel_version_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply__host_page_size(&mut self) - -> *mut __Reply___host_page_size_t { + pub unsafe fn Reply__host_page_size(&mut self) -> *mut __Reply___host_page_size_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_mach_memory_object_memory_entry(&mut self) - -> *mut __Reply__mach_memory_object_memory_entry_t { + pub unsafe fn Reply_mach_memory_object_memory_entry + (&mut self) + -> *mut __Reply__mach_memory_object_memory_entry_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_host_processor_info(&mut self) - -> *mut __Reply__host_processor_info_t { + pub unsafe fn Reply_host_processor_info(&mut self) -> *mut __Reply__host_processor_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_host_get_io_master(&mut self) - -> *mut __Reply__host_get_io_master_t { + pub unsafe fn Reply_host_get_io_master(&mut self) -> *mut __Reply__host_get_io_master_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_host_get_clock_service(&mut self) - -> *mut __Reply__host_get_clock_service_t { + pub unsafe fn Reply_host_get_clock_service(&mut self) -> *mut __Reply__host_get_clock_service_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_kmod_get_info(&mut self) - -> *mut __Reply__kmod_get_info_t { + pub unsafe fn Reply_kmod_get_info(&mut self) -> *mut __Reply__kmod_get_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_host_zone_info(&mut self) - -> *mut __Reply__host_zone_info_t { + pub unsafe fn Reply_host_zone_info(&mut self) -> *mut __Reply__host_zone_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_host_virtual_physical_table_info(&mut self) - -> *mut __Reply__host_virtual_physical_table_info_t { + pub unsafe fn Reply_host_virtual_physical_table_info + (&mut self) + -> *mut __Reply__host_virtual_physical_table_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_processor_set_default(&mut self) - -> *mut __Reply__processor_set_default_t { + pub unsafe fn Reply_processor_set_default(&mut self) -> *mut __Reply__processor_set_default_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_processor_set_create(&mut self) - -> *mut __Reply__processor_set_create_t { + pub unsafe fn Reply_processor_set_create(&mut self) -> *mut __Reply__processor_set_create_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_mach_memory_object_memory_entry_64(&mut self) - -> *mut __Reply__mach_memory_object_memory_entry_64_t { + pub unsafe fn Reply_mach_memory_object_memory_entry_64 + (&mut self) + -> *mut __Reply__mach_memory_object_memory_entry_64_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_host_statistics(&mut self) - -> *mut __Reply__host_statistics_t { + pub unsafe fn Reply_host_statistics(&mut self) -> *mut __Reply__host_statistics_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } pub unsafe fn Reply_host_request_notification(&mut self) - -> *mut __Reply__host_request_notification_t { + -> *mut __Reply__host_request_notification_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_host_lockgroup_info(&mut self) - -> *mut __Reply__host_lockgroup_info_t { + pub unsafe fn Reply_host_lockgroup_info(&mut self) -> *mut __Reply__host_lockgroup_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_host_statistics64(&mut self) - -> *mut __Reply__host_statistics64_t { + pub unsafe fn Reply_host_statistics64(&mut self) -> *mut __Reply__host_statistics64_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } - pub unsafe fn Reply_mach_zone_info(&mut self) - -> *mut __Reply__mach_zone_info_t { + pub unsafe fn Reply_mach_zone_info(&mut self) -> *mut __Reply__mach_zone_info_t { let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_); ::std::mem::transmute(raw.offset(0)) } } impl ::std::clone::Clone for Union___ReplyUnion__mach_host_subsystem { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Union___ReplyUnion__mach_host_subsystem { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type routine_arg_type = ::libc::c_uint; pub type routine_arg_offset = ::libc::c_uint; @@ -10199,13 +12046,16 @@ pub struct Struct_rpc_routine_arg_descriptor { pub offset: routine_arg_offset, } impl ::std::clone::Clone for Struct_rpc_routine_arg_descriptor { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_rpc_routine_arg_descriptor { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } -pub type rpc_routine_arg_descriptor_t = - *mut Struct_rpc_routine_arg_descriptor; +pub type rpc_routine_arg_descriptor_t = *mut Struct_rpc_routine_arg_descriptor; #[repr(C)] #[derive(Copy)] pub struct Struct_rpc_routine_descriptor { @@ -10217,10 +12067,14 @@ pub struct Struct_rpc_routine_descriptor { pub max_reply_msg: ::libc::c_uint, } impl ::std::clone::Clone for Struct_rpc_routine_descriptor { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_rpc_routine_descriptor { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type rpc_routine_descriptor_t = *mut Struct_rpc_routine_descriptor; #[repr(C)] @@ -10230,10 +12084,14 @@ pub struct Struct_rpc_signature { pub rad: [Struct_rpc_routine_arg_descriptor; 1usize], } impl ::std::clone::Clone for Struct_rpc_signature { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_rpc_signature { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } #[repr(C)] #[derive(Copy)] @@ -10247,15 +12105,18 @@ pub struct Struct_rpc_subsystem { pub arg_descriptor: [Struct_rpc_routine_arg_descriptor; 1usize], } impl ::std::clone::Clone for Struct_rpc_subsystem { - fn clone(&self) -> Self { *self } + fn clone(&self) -> Self { + *self + } } impl ::std::default::Default for Struct_rpc_subsystem { - fn default() -> Self { unsafe { ::std::mem::zeroed() } } + fn default() -> Self { + unsafe { ::std::mem::zeroed() } + } } pub type rpc_subsystem_t = *mut Struct_rpc_subsystem; pub type mach_error_t = kern_return_t; -pub type mach_error_fn_t = - ::std::option::Option mach_error_t>; +pub type mach_error_fn_t = ::std::option::Option mach_error_t>; extern "C" { pub static mut KERNEL_SECURITY_TOKEN: security_token_t; pub static mut KERNEL_AUDIT_TOKEN: audit_token_t; @@ -10276,74 +12137,93 @@ extern "C" { notify: mach_port_name_t, rcv_msg: *mut mach_msg_header_t, rcv_limit: mach_msg_size_t) - -> mach_msg_return_t; - pub fn mach_msg(msg: *mut mach_msg_header_t, option: mach_msg_option_t, - send_size: mach_msg_size_t, rcv_size: mach_msg_size_t, - rcv_name: mach_port_name_t, timeout: mach_msg_timeout_t, - notify: mach_port_name_t) -> mach_msg_return_t; + -> mach_msg_return_t; + pub fn mach_msg(msg: *mut mach_msg_header_t, + option: mach_msg_option_t, + send_size: mach_msg_size_t, + rcv_size: mach_msg_size_t, + rcv_name: mach_port_name_t, + timeout: mach_msg_timeout_t, + notify: mach_port_name_t) + -> mach_msg_return_t; pub fn mig_get_reply_port() -> mach_port_t; pub fn mig_dealloc_reply_port(reply_port: mach_port_t) -> (); pub fn mig_put_reply_port(reply_port: mach_port_t) -> (); - pub fn mig_strncpy(dest: *mut ::libc::c_char, src: *const ::libc::c_char, - len: ::libc::c_int) -> ::libc::c_int; + pub fn mig_strncpy(dest: *mut ::libc::c_char, + src: *const ::libc::c_char, + len: ::libc::c_int) + -> ::libc::c_int; pub fn mig_allocate(arg1: *mut vm_address_t, arg2: vm_size_t) -> (); pub fn mig_deallocate(arg1: vm_address_t, arg2: vm_size_t) -> (); - pub fn clock_set_time(clock_ctrl: clock_ctrl_t, new_time: mach_timespec_t) - -> kern_return_t; + pub fn clock_set_time(clock_ctrl: clock_ctrl_t, new_time: mach_timespec_t) -> kern_return_t; pub fn clock_set_attributes(clock_ctrl: clock_ctrl_t, flavor: clock_flavor_t, clock_attr: clock_attr_t, clock_attrCnt: mach_msg_type_number_t) - -> kern_return_t; + -> kern_return_t; pub fn host_get_boot_info(host_priv: host_priv_t, - boot_info: kernel_boot_info_t) -> kern_return_t; - pub fn host_reboot(host_priv: host_priv_t, options: ::libc::c_int) - -> kern_return_t; - pub fn host_priv_statistics(host_priv: host_priv_t, flavor: host_flavor_t, + boot_info: kernel_boot_info_t) + -> kern_return_t; + pub fn host_reboot(host_priv: host_priv_t, options: ::libc::c_int) -> kern_return_t; + pub fn host_priv_statistics(host_priv: host_priv_t, + flavor: host_flavor_t, host_info_out: host_info_t, host_info_outCnt: *mut mach_msg_type_number_t) - -> kern_return_t; + -> kern_return_t; pub fn host_default_memory_manager(host_priv: host_priv_t, - default_manager: - *mut memory_object_default_t, - cluster_size: - memory_object_cluster_size_t) - -> kern_return_t; - pub fn vm_wire(host_priv: host_priv_t, task: vm_map_t, - address: vm_address_t, size: vm_size_t, - desired_access: vm_prot_t) -> kern_return_t; - pub fn thread_wire(host_priv: host_priv_t, thread: thread_act_t, - wired: boolean_t) -> kern_return_t; - pub fn vm_allocate_cpm(host_priv: host_priv_t, task: vm_map_t, - address: *mut vm_address_t, size: vm_size_t, - flags: ::libc::c_int) -> kern_return_t; + default_manager: *mut memory_object_default_t, + cluster_size: memory_object_cluster_size_t) + -> kern_return_t; + pub fn vm_wire(host_priv: host_priv_t, + task: vm_map_t, + address: vm_address_t, + size: vm_size_t, + desired_access: vm_prot_t) + -> kern_return_t; + pub fn thread_wire(host_priv: host_priv_t, + thread: thread_act_t, + wired: boolean_t) + -> kern_return_t; + pub fn vm_allocate_cpm(host_priv: host_priv_t, + task: vm_map_t, + address: *mut vm_address_t, + size: vm_size_t, + flags: ::libc::c_int) + -> kern_return_t; pub fn host_processors(host_priv: host_priv_t, out_processor_list: *mut processor_array_t, out_processor_listCnt: *mut mach_msg_type_number_t) - -> kern_return_t; + -> kern_return_t; pub fn host_get_clock_control(host_priv: host_priv_t, clock_id: clock_id_t, clock_ctrl: *mut clock_ctrl_t) - -> kern_return_t; - pub fn kmod_create(host_priv: host_priv_t, info: vm_address_t, - module: *mut kmod_t) -> kern_return_t; - pub fn kmod_destroy(host_priv: host_priv_t, module: kmod_t) - -> kern_return_t; - pub fn kmod_control(host_priv: host_priv_t, module: kmod_t, - flavor: kmod_control_flavor_t, data: *mut kmod_args_t, + -> kern_return_t; + pub fn kmod_create(host_priv: host_priv_t, + info: vm_address_t, + module: *mut kmod_t) + -> kern_return_t; + pub fn kmod_destroy(host_priv: host_priv_t, module: kmod_t) -> kern_return_t; + pub fn kmod_control(host_priv: host_priv_t, + module: kmod_t, + flavor: kmod_control_flavor_t, + data: *mut kmod_args_t, dataCnt: *mut mach_msg_type_number_t) - -> kern_return_t; - pub fn host_get_special_port(host_priv: host_priv_t, node: ::libc::c_int, - which: ::libc::c_int, port: *mut mach_port_t) - -> kern_return_t; - pub fn host_set_special_port(host_priv: host_priv_t, which: ::libc::c_int, - port: mach_port_t) -> kern_return_t; + -> kern_return_t; + pub fn host_get_special_port(host_priv: host_priv_t, + node: ::libc::c_int, + which: ::libc::c_int, + port: *mut mach_port_t) + -> kern_return_t; + pub fn host_set_special_port(host_priv: host_priv_t, + which: ::libc::c_int, + port: mach_port_t) + -> kern_return_t; pub fn host_set_exception_ports(host_priv: host_priv_t, exception_mask: exception_mask_t, new_port: mach_port_t, behavior: exception_behavior_t, new_flavor: thread_state_flavor_t) - -> kern_return_t; + -> kern_return_t; pub fn host_get_exception_ports(host_priv: host_priv_t, exception_mask: exception_mask_t, masks: exception_mask_array_t, @@ -10351,7 +12231,7 @@ extern "C" { old_handlers: exception_handler_array_t, old_behaviors: exception_behavior_array_t, old_flavors: exception_flavor_array_t) - -> kern_return_t; + -> kern_return_t; pub fn host_swap_exception_ports(host_priv: host_priv_t, exception_mask: exception_mask_t, new_port: mach_port_t, @@ -10360,39 +12240,37 @@ extern "C" { masks: exception_mask_array_t, masksCnt: *mut mach_msg_type_number_t, old_handlerss: exception_handler_array_t, - old_behaviors: - exception_behavior_array_t, + old_behaviors: exception_behavior_array_t, old_flavors: exception_flavor_array_t) - -> kern_return_t; - pub fn mach_vm_wire(host_priv: host_priv_t, task: vm_map_t, - address: mach_vm_address_t, size: mach_vm_size_t, - desired_access: vm_prot_t) -> kern_return_t; + -> kern_return_t; + pub fn mach_vm_wire(host_priv: host_priv_t, + task: vm_map_t, + address: mach_vm_address_t, + size: mach_vm_size_t, + desired_access: vm_prot_t) + -> kern_return_t; pub fn host_processor_sets(host_priv: host_priv_t, - processor_sets: - *mut processor_set_name_array_t, + processor_sets: *mut processor_set_name_array_t, processor_setsCnt: *mut mach_msg_type_number_t) - -> kern_return_t; + -> kern_return_t; pub fn host_processor_set_priv(host_priv: host_priv_t, set_name: processor_set_name_t, set: *mut processor_set_t) - -> kern_return_t; - pub fn set_dp_control_port(host: host_priv_t, control_port: mach_port_t) - -> kern_return_t; - pub fn get_dp_control_port(host: host_priv_t, - contorl_port: *mut mach_port_t) - -> kern_return_t; - pub fn host_set_UNDServer(host: host_priv_t, server: UNDServerRef) - -> kern_return_t; - pub fn host_get_UNDServer(host: host_priv_t, server: *mut UNDServerRef) - -> kern_return_t; - pub fn kext_request(host_priv: host_priv_t, user_log_flags: uint32_t, + -> kern_return_t; + pub fn set_dp_control_port(host: host_priv_t, control_port: mach_port_t) -> kern_return_t; + pub fn get_dp_control_port(host: host_priv_t, contorl_port: *mut mach_port_t) -> kern_return_t; + pub fn host_set_UNDServer(host: host_priv_t, server: UNDServerRef) -> kern_return_t; + pub fn host_get_UNDServer(host: host_priv_t, server: *mut UNDServerRef) -> kern_return_t; + pub fn kext_request(host_priv: host_priv_t, + user_log_flags: uint32_t, request_data: vm_offset_t, request_dataCnt: mach_msg_type_number_t, response_data: *mut vm_offset_t, response_dataCnt: *mut mach_msg_type_number_t, log_data: *mut vm_offset_t, log_dataCnt: *mut mach_msg_type_number_t, - op_result: *mut kern_return_t) -> kern_return_t; + op_result: *mut kern_return_t) + -> kern_return_t; pub fn host_security_create_task_token(host_security: host_security_t, parent_task: task_t, sec_token: security_token_t, @@ -10402,143 +12280,148 @@ extern "C" { ledgersCnt: mach_msg_type_number_t, inherit_memory: boolean_t, child_task: *mut task_t) - -> kern_return_t; + -> kern_return_t; pub fn host_security_set_task_token(host_security: host_security_t, target_task: task_t, sec_token: security_token_t, audit_token: audit_token_t, - host: host_t) -> kern_return_t; - pub fn lock_acquire(lock_set: lock_set_t, lock_id: ::libc::c_int) - -> kern_return_t; - pub fn lock_release(lock_set: lock_set_t, lock_id: ::libc::c_int) - -> kern_return_t; - pub fn lock_try(lock_set: lock_set_t, lock_id: ::libc::c_int) - -> kern_return_t; - pub fn lock_make_stable(lock_set: lock_set_t, lock_id: ::libc::c_int) - -> kern_return_t; - pub fn lock_handoff(lock_set: lock_set_t, lock_id: ::libc::c_int) - -> kern_return_t; - pub fn lock_handoff_accept(lock_set: lock_set_t, lock_id: ::libc::c_int) - -> kern_return_t; + host: host_t) + -> kern_return_t; + pub fn lock_acquire(lock_set: lock_set_t, lock_id: ::libc::c_int) -> kern_return_t; + pub fn lock_release(lock_set: lock_set_t, lock_id: ::libc::c_int) -> kern_return_t; + pub fn lock_try(lock_set: lock_set_t, lock_id: ::libc::c_int) -> kern_return_t; + pub fn lock_make_stable(lock_set: lock_set_t, lock_id: ::libc::c_int) -> kern_return_t; + pub fn lock_handoff(lock_set: lock_set_t, lock_id: ::libc::c_int) -> kern_return_t; + pub fn lock_handoff_accept(lock_set: lock_set_t, lock_id: ::libc::c_int) -> kern_return_t; pub fn processor_start(processor: processor_t) -> kern_return_t; pub fn processor_exit(processor: processor_t) -> kern_return_t; - pub fn processor_info(processor: processor_t, flavor: processor_flavor_t, + pub fn processor_info(processor: processor_t, + flavor: processor_flavor_t, host: *mut host_t, processor_info_out: processor_info_t, processor_info_outCnt: *mut mach_msg_type_number_t) - -> kern_return_t; + -> kern_return_t; pub fn processor_control(processor: processor_t, processor_cmd: processor_info_t, processor_cmdCnt: mach_msg_type_number_t) - -> kern_return_t; - pub fn processor_assign(processor: processor_t, new_set: processor_set_t, - wait: boolean_t) -> kern_return_t; + -> kern_return_t; + pub fn processor_assign(processor: processor_t, + new_set: processor_set_t, + wait: boolean_t) + -> kern_return_t; pub fn processor_get_assignment(processor: processor_t, assigned_set: *mut processor_set_name_t) - -> kern_return_t; + -> kern_return_t; pub fn processor_set_statistics(pset: processor_set_name_t, flavor: processor_set_flavor_t, info_out: processor_set_info_t, info_outCnt: *mut mach_msg_type_number_t) - -> kern_return_t; + -> kern_return_t; pub fn processor_set_destroy(set: processor_set_t) -> kern_return_t; pub fn processor_set_max_priority(processor_set: processor_set_t, max_priority: ::libc::c_int, change_threads: boolean_t) - -> kern_return_t; + -> kern_return_t; pub fn processor_set_policy_enable(processor_set: processor_set_t, policy: ::libc::c_int) - -> kern_return_t; + -> kern_return_t; pub fn processor_set_policy_disable(processor_set: processor_set_t, policy: ::libc::c_int, change_threads: boolean_t) - -> kern_return_t; + -> kern_return_t; pub fn processor_set_tasks(processor_set: processor_set_t, task_list: *mut task_array_t, task_listCnt: *mut mach_msg_type_number_t) - -> kern_return_t; + -> kern_return_t; pub fn processor_set_threads(processor_set: processor_set_t, thread_list: *mut thread_act_array_t, thread_listCnt: *mut mach_msg_type_number_t) - -> kern_return_t; + -> kern_return_t; pub fn processor_set_policy_control(pset: processor_set_t, flavor: processor_set_flavor_t, policy_info: processor_set_info_t, - policy_infoCnt: - mach_msg_type_number_t, - change: boolean_t) -> kern_return_t; + policy_infoCnt: mach_msg_type_number_t, + change: boolean_t) + -> kern_return_t; pub fn processor_set_stack_usage(pset: processor_set_t, ltotal: *mut ::libc::c_uint, space: *mut vm_size_t, resident: *mut vm_size_t, maxusage: *mut vm_size_t, maxstack: *mut vm_offset_t) - -> kern_return_t; + -> kern_return_t; pub fn processor_set_info(set_name: processor_set_name_t, - flavor: ::libc::c_int, host: *mut host_t, + flavor: ::libc::c_int, + host: *mut host_t, info_out: processor_set_info_t, info_outCnt: *mut mach_msg_type_number_t) - -> kern_return_t; + -> kern_return_t; pub fn semaphore_signal(semaphore: semaphore_t) -> kern_return_t; pub fn semaphore_signal_all(semaphore: semaphore_t) -> kern_return_t; pub fn semaphore_wait(semaphore: semaphore_t) -> kern_return_t; pub fn semaphore_timedwait(semaphore: semaphore_t, - wait_time: mach_timespec_t) -> kern_return_t; + wait_time: mach_timespec_t) + -> kern_return_t; pub fn semaphore_timedwait_signal(wait_semaphore: semaphore_t, signal_semaphore: semaphore_t, wait_time: mach_timespec_t) - -> kern_return_t; + -> kern_return_t; pub fn semaphore_wait_signal(wait_semaphore: semaphore_t, signal_semaphore: semaphore_t) - -> kern_return_t; - pub fn semaphore_signal_thread(semaphore: semaphore_t, thread: thread_t) - -> kern_return_t; - pub fn task_create(target_task: task_t, ledgers: ledger_array_t, + -> kern_return_t; + pub fn semaphore_signal_thread(semaphore: semaphore_t, thread: thread_t) -> kern_return_t; + pub fn task_create(target_task: task_t, + ledgers: ledger_array_t, ledgersCnt: mach_msg_type_number_t, - inherit_memory: boolean_t, child_task: *mut task_t) - -> kern_return_t; + inherit_memory: boolean_t, + child_task: *mut task_t) + -> kern_return_t; pub fn task_terminate(target_task: task_t) -> kern_return_t; pub fn task_threads(target_task: task_t, act_list: *mut thread_act_array_t, act_listCnt: *mut mach_msg_type_number_t) - -> kern_return_t; + -> kern_return_t; pub fn mach_ports_register(target_task: task_t, init_port_set: mach_port_array_t, init_port_setCnt: mach_msg_type_number_t) - -> kern_return_t; + -> kern_return_t; pub fn mach_ports_lookup(target_task: task_t, init_port_set: *mut mach_port_array_t, init_port_setCnt: *mut mach_msg_type_number_t) - -> kern_return_t; - pub fn task_info(target_task: task_name_t, flavor: task_flavor_t, + -> kern_return_t; + pub fn task_info(target_task: task_name_t, + flavor: task_flavor_t, task_info_out: task_info_t, task_info_outCnt: *mut mach_msg_type_number_t) - -> kern_return_t; - pub fn task_set_info(target_task: task_t, flavor: task_flavor_t, + -> kern_return_t; + pub fn task_set_info(target_task: task_t, + flavor: task_flavor_t, task_info_in: task_info_t, task_info_inCnt: mach_msg_type_number_t) - -> kern_return_t; + -> kern_return_t; pub fn task_suspend(target_task: task_t) -> kern_return_t; pub fn task_resume(target_task: task_t) -> kern_return_t; - pub fn task_get_special_port(task: task_t, which_port: ::libc::c_int, + pub fn task_get_special_port(task: task_t, + which_port: ::libc::c_int, special_port: *mut mach_port_t) - -> kern_return_t; - pub fn task_set_special_port(task: task_t, which_port: ::libc::c_int, - special_port: mach_port_t) -> kern_return_t; - pub fn thread_create(parent_task: task_t, child_act: *mut thread_act_t) - -> kern_return_t; + -> kern_return_t; + pub fn task_set_special_port(task: task_t, + which_port: ::libc::c_int, + special_port: mach_port_t) + -> kern_return_t; + pub fn thread_create(parent_task: task_t, child_act: *mut thread_act_t) -> kern_return_t; pub fn thread_create_running(parent_task: task_t, flavor: thread_state_flavor_t, new_state: thread_state_t, new_stateCnt: mach_msg_type_number_t, child_act: *mut thread_act_t) - -> kern_return_t; + -> kern_return_t; pub fn task_set_exception_ports(task: task_t, exception_mask: exception_mask_t, new_port: mach_port_t, behavior: exception_behavior_t, new_flavor: thread_state_flavor_t) - -> kern_return_t; + -> kern_return_t; pub fn task_get_exception_ports(task: task_t, exception_mask: exception_mask_t, masks: exception_mask_array_t, @@ -10546,7 +12429,7 @@ extern "C" { old_handlers: exception_handler_array_t, old_behaviors: exception_behavior_array_t, old_flavors: exception_flavor_array_t) - -> kern_return_t; + -> kern_return_t; pub fn task_swap_exception_ports(task: task_t, exception_mask: exception_mask_t, new_port: mach_port_t, @@ -10555,90 +12438,106 @@ extern "C" { masks: exception_mask_array_t, masksCnt: *mut mach_msg_type_number_t, old_handlerss: exception_handler_array_t, - old_behaviors: - exception_behavior_array_t, + old_behaviors: exception_behavior_array_t, old_flavors: exception_flavor_array_t) - -> kern_return_t; - pub fn lock_set_create(task: task_t, new_lock_set: *mut lock_set_t, - n_ulocks: ::libc::c_int, policy: ::libc::c_int) - -> kern_return_t; - pub fn lock_set_destroy(task: task_t, lock_set: lock_set_t) - -> kern_return_t; - pub fn semaphore_create(task: task_t, semaphore: *mut semaphore_t, - policy: ::libc::c_int, value: ::libc::c_int) - -> kern_return_t; - pub fn semaphore_destroy(task: task_t, semaphore: semaphore_t) - -> kern_return_t; - pub fn task_policy_set(task: task_t, flavor: task_policy_flavor_t, + -> kern_return_t; + pub fn lock_set_create(task: task_t, + new_lock_set: *mut lock_set_t, + n_ulocks: ::libc::c_int, + policy: ::libc::c_int) + -> kern_return_t; + pub fn lock_set_destroy(task: task_t, lock_set: lock_set_t) -> kern_return_t; + pub fn semaphore_create(task: task_t, + semaphore: *mut semaphore_t, + policy: ::libc::c_int, + value: ::libc::c_int) + -> kern_return_t; + pub fn semaphore_destroy(task: task_t, semaphore: semaphore_t) -> kern_return_t; + pub fn task_policy_set(task: task_t, + flavor: task_policy_flavor_t, policy_info: task_policy_t, policy_infoCnt: mach_msg_type_number_t) - -> kern_return_t; - pub fn task_policy_get(task: task_t, flavor: task_policy_flavor_t, + -> kern_return_t; + pub fn task_policy_get(task: task_t, + flavor: task_policy_flavor_t, policy_info: task_policy_t, policy_infoCnt: *mut mach_msg_type_number_t, - get_default: *mut boolean_t) -> kern_return_t; + get_default: *mut boolean_t) + -> kern_return_t; pub fn task_sample(task: task_t, reply: mach_port_t) -> kern_return_t; - pub fn task_policy(task: task_t, policy: policy_t, base: policy_base_t, - baseCnt: mach_msg_type_number_t, set_limit: boolean_t, - change: boolean_t) -> kern_return_t; + pub fn task_policy(task: task_t, + policy: policy_t, + base: policy_base_t, + baseCnt: mach_msg_type_number_t, + set_limit: boolean_t, + change: boolean_t) + -> kern_return_t; pub fn task_set_emulation(target_port: task_t, routine_entry_pt: vm_address_t, - routine_number: ::libc::c_int) -> kern_return_t; + routine_number: ::libc::c_int) + -> kern_return_t; pub fn task_get_emulation_vector(task: task_t, vector_start: *mut ::libc::c_int, - emulation_vector: - *mut emulation_vector_t, - emulation_vectorCnt: - *mut mach_msg_type_number_t) - -> kern_return_t; + emulation_vector: *mut emulation_vector_t, + emulation_vectorCnt: *mut mach_msg_type_number_t) + -> kern_return_t; pub fn task_set_emulation_vector(task: task_t, vector_start: ::libc::c_int, emulation_vector: emulation_vector_t, - emulation_vectorCnt: - mach_msg_type_number_t) - -> kern_return_t; - pub fn task_set_ras_pc(target_task: task_t, basepc: vm_address_t, - boundspc: vm_address_t) -> kern_return_t; - pub fn task_assign(task: task_t, new_set: processor_set_t, - assign_threads: boolean_t) -> kern_return_t; - pub fn task_assign_default(task: task_t, assign_threads: boolean_t) - -> kern_return_t; + emulation_vectorCnt: mach_msg_type_number_t) + -> kern_return_t; + pub fn task_set_ras_pc(target_task: task_t, + basepc: vm_address_t, + boundspc: vm_address_t) + -> kern_return_t; + pub fn task_assign(task: task_t, + new_set: processor_set_t, + assign_threads: boolean_t) + -> kern_return_t; + pub fn task_assign_default(task: task_t, assign_threads: boolean_t) -> kern_return_t; pub fn task_get_assignment(task: task_t, assigned_set: *mut processor_set_name_t) - -> kern_return_t; - pub fn task_set_policy(task: task_t, pset: processor_set_t, - policy: policy_t, base: policy_base_t, + -> kern_return_t; + pub fn task_set_policy(task: task_t, + pset: processor_set_t, + policy: policy_t, + base: policy_base_t, baseCnt: mach_msg_type_number_t, limit: policy_limit_t, limitCnt: mach_msg_type_number_t, - change: boolean_t) -> kern_return_t; - pub fn task_get_state(task: task_t, flavor: thread_state_flavor_t, + change: boolean_t) + -> kern_return_t; + pub fn task_get_state(task: task_t, + flavor: thread_state_flavor_t, old_state: thread_state_t, old_stateCnt: *mut mach_msg_type_number_t) - -> kern_return_t; - pub fn task_set_state(task: task_t, flavor: thread_state_flavor_t, + -> kern_return_t; + pub fn task_set_state(task: task_t, + flavor: thread_state_flavor_t, new_state: thread_state_t, new_stateCnt: mach_msg_type_number_t) - -> kern_return_t; + -> kern_return_t; pub fn thread_terminate(target_act: thread_act_t) -> kern_return_t; - pub fn act_get_state(target_act: thread_act_t, flavor: ::libc::c_int, + pub fn act_get_state(target_act: thread_act_t, + flavor: ::libc::c_int, old_state: thread_state_t, old_stateCnt: *mut mach_msg_type_number_t) - -> kern_return_t; - pub fn act_set_state(target_act: thread_act_t, flavor: ::libc::c_int, + -> kern_return_t; + pub fn act_set_state(target_act: thread_act_t, + flavor: ::libc::c_int, new_state: thread_state_t, new_stateCnt: mach_msg_type_number_t) - -> kern_return_t; + -> kern_return_t; pub fn thread_get_state(target_act: thread_act_t, flavor: thread_state_flavor_t, old_state: thread_state_t, old_stateCnt: *mut mach_msg_type_number_t) - -> kern_return_t; + -> kern_return_t; pub fn thread_set_state(target_act: thread_act_t, flavor: thread_state_flavor_t, new_state: thread_state_t, new_stateCnt: mach_msg_type_number_t) - -> kern_return_t; + -> kern_return_t; pub fn thread_suspend(target_act: thread_act_t) -> kern_return_t; pub fn thread_resume(target_act: thread_act_t) -> kern_return_t; pub fn thread_abort(target_act: thread_act_t) -> kern_return_t; @@ -10647,30 +12546,30 @@ extern "C" { pub fn thread_get_special_port(thr_act: thread_act_t, which_port: ::libc::c_int, special_port: *mut mach_port_t) - -> kern_return_t; + -> kern_return_t; pub fn thread_set_special_port(thr_act: thread_act_t, which_port: ::libc::c_int, special_port: mach_port_t) - -> kern_return_t; - pub fn thread_info(target_act: thread_act_t, flavor: thread_flavor_t, + -> kern_return_t; + pub fn thread_info(target_act: thread_act_t, + flavor: thread_flavor_t, thread_info_out: thread_info_t, thread_info_outCnt: *mut mach_msg_type_number_t) - -> kern_return_t; + -> kern_return_t; pub fn thread_set_exception_ports(thread: thread_act_t, exception_mask: exception_mask_t, new_port: mach_port_t, behavior: exception_behavior_t, new_flavor: thread_state_flavor_t) - -> kern_return_t; + -> kern_return_t; pub fn thread_get_exception_ports(thread: thread_act_t, exception_mask: exception_mask_t, masks: exception_mask_array_t, masksCnt: *mut mach_msg_type_number_t, old_handlers: exception_handler_array_t, - old_behaviors: - exception_behavior_array_t, + old_behaviors: exception_behavior_array_t, old_flavors: exception_flavor_array_t) - -> kern_return_t; + -> kern_return_t; pub fn thread_swap_exception_ports(thread: thread_act_t, exception_mask: exception_mask_t, new_port: mach_port_t, @@ -10678,171 +12577,242 @@ extern "C" { new_flavor: thread_state_flavor_t, masks: exception_mask_array_t, masksCnt: *mut mach_msg_type_number_t, - old_handlers: - exception_handler_array_t, - old_behaviors: - exception_behavior_array_t, + old_handlers: exception_handler_array_t, + old_behaviors: exception_behavior_array_t, old_flavors: exception_flavor_array_t) - -> kern_return_t; - pub fn thread_policy(thr_act: thread_act_t, policy: policy_t, - base: policy_base_t, baseCnt: mach_msg_type_number_t, - set_limit: boolean_t) -> kern_return_t; + -> kern_return_t; + pub fn thread_policy(thr_act: thread_act_t, + policy: policy_t, + base: policy_base_t, + baseCnt: mach_msg_type_number_t, + set_limit: boolean_t) + -> kern_return_t; pub fn thread_policy_set(thread: thread_act_t, flavor: thread_policy_flavor_t, policy_info: thread_policy_t, policy_infoCnt: mach_msg_type_number_t) - -> kern_return_t; + -> kern_return_t; pub fn thread_policy_get(thread: thread_act_t, flavor: thread_policy_flavor_t, policy_info: thread_policy_t, policy_infoCnt: *mut mach_msg_type_number_t, - get_default: *mut boolean_t) -> kern_return_t; - pub fn thread_sample(thread: thread_act_t, reply: mach_port_t) - -> kern_return_t; - pub fn etap_trace_thread(target_act: thread_act_t, - trace_status: boolean_t) -> kern_return_t; - pub fn thread_assign(thread: thread_act_t, new_set: processor_set_t) - -> kern_return_t; + get_default: *mut boolean_t) + -> kern_return_t; + pub fn thread_sample(thread: thread_act_t, reply: mach_port_t) -> kern_return_t; + pub fn etap_trace_thread(target_act: thread_act_t, trace_status: boolean_t) -> kern_return_t; + pub fn thread_assign(thread: thread_act_t, new_set: processor_set_t) -> kern_return_t; pub fn thread_assign_default(thread: thread_act_t) -> kern_return_t; pub fn thread_get_assignment(thread: thread_act_t, assigned_set: *mut processor_set_name_t) - -> kern_return_t; - pub fn thread_set_policy(thr_act: thread_act_t, pset: processor_set_t, - policy: policy_t, base: policy_base_t, + -> kern_return_t; + pub fn thread_set_policy(thr_act: thread_act_t, + pset: processor_set_t, + policy: policy_t, + base: policy_base_t, baseCnt: mach_msg_type_number_t, limit: policy_limit_t, limitCnt: mach_msg_type_number_t) - -> kern_return_t; - pub fn vm_region(target_task: vm_map_t, address: *mut vm_address_t, - size: *mut vm_size_t, flavor: vm_region_flavor_t, + -> kern_return_t; + pub fn vm_region(target_task: vm_map_t, + address: *mut vm_address_t, + size: *mut vm_size_t, + flavor: vm_region_flavor_t, info: vm_region_info_t, infoCnt: *mut mach_msg_type_number_t, - object_name: *mut mach_port_t) -> kern_return_t; - pub fn vm_allocate(target_task: vm_map_t, address: *mut vm_address_t, - size: vm_size_t, flags: ::libc::c_int) - -> kern_return_t; - pub fn vm_deallocate(target_task: vm_map_t, address: vm_address_t, - size: vm_size_t) -> kern_return_t; - pub fn vm_protect(target_task: vm_map_t, address: vm_address_t, - size: vm_size_t, set_maximum: boolean_t, - new_protection: vm_prot_t) -> kern_return_t; - pub fn vm_inherit(target_task: vm_map_t, address: vm_address_t, - size: vm_size_t, new_inheritance: vm_inherit_t) - -> kern_return_t; - pub fn vm_read(target_task: vm_map_t, address: vm_address_t, - size: vm_size_t, data: *mut vm_offset_t, - dataCnt: *mut mach_msg_type_number_t) -> kern_return_t; - pub fn vm_read_list(target_task: vm_map_t, data_list: vm_read_entry_t, - count: natural_t) -> kern_return_t; - pub fn vm_write(target_task: vm_map_t, address: vm_address_t, - data: vm_offset_t, dataCnt: mach_msg_type_number_t) - -> kern_return_t; - pub fn vm_copy(target_task: vm_map_t, source_address: vm_address_t, - size: vm_size_t, dest_address: vm_address_t) - -> kern_return_t; - pub fn vm_read_overwrite(target_task: vm_map_t, address: vm_address_t, - size: vm_size_t, data: vm_address_t, - outsize: *mut vm_size_t) -> kern_return_t; - pub fn vm_msync(target_task: vm_map_t, address: vm_address_t, - size: vm_size_t, sync_flags: vm_sync_t) -> kern_return_t; - pub fn vm_behavior_set(target_task: vm_map_t, address: vm_address_t, - size: vm_size_t, new_behavior: vm_behavior_t) - -> kern_return_t; - pub fn vm_map(target_task: vm_map_t, address: *mut vm_address_t, - size: vm_size_t, mask: vm_address_t, flags: ::libc::c_int, - object: mem_entry_name_port_t, offset: vm_offset_t, - copy: boolean_t, cur_protection: vm_prot_t, - max_protection: vm_prot_t, inheritance: vm_inherit_t) - -> kern_return_t; - pub fn vm_machine_attribute(target_task: vm_map_t, address: vm_address_t, + object_name: *mut mach_port_t) + -> kern_return_t; + pub fn vm_allocate(target_task: vm_map_t, + address: *mut vm_address_t, + size: vm_size_t, + flags: ::libc::c_int) + -> kern_return_t; + pub fn vm_deallocate(target_task: vm_map_t, + address: vm_address_t, + size: vm_size_t) + -> kern_return_t; + pub fn vm_protect(target_task: vm_map_t, + address: vm_address_t, + size: vm_size_t, + set_maximum: boolean_t, + new_protection: vm_prot_t) + -> kern_return_t; + pub fn vm_inherit(target_task: vm_map_t, + address: vm_address_t, + size: vm_size_t, + new_inheritance: vm_inherit_t) + -> kern_return_t; + pub fn vm_read(target_task: vm_map_t, + address: vm_address_t, + size: vm_size_t, + data: *mut vm_offset_t, + dataCnt: *mut mach_msg_type_number_t) + -> kern_return_t; + pub fn vm_read_list(target_task: vm_map_t, + data_list: vm_read_entry_t, + count: natural_t) + -> kern_return_t; + pub fn vm_write(target_task: vm_map_t, + address: vm_address_t, + data: vm_offset_t, + dataCnt: mach_msg_type_number_t) + -> kern_return_t; + pub fn vm_copy(target_task: vm_map_t, + source_address: vm_address_t, + size: vm_size_t, + dest_address: vm_address_t) + -> kern_return_t; + pub fn vm_read_overwrite(target_task: vm_map_t, + address: vm_address_t, + size: vm_size_t, + data: vm_address_t, + outsize: *mut vm_size_t) + -> kern_return_t; + pub fn vm_msync(target_task: vm_map_t, + address: vm_address_t, + size: vm_size_t, + sync_flags: vm_sync_t) + -> kern_return_t; + pub fn vm_behavior_set(target_task: vm_map_t, + address: vm_address_t, + size: vm_size_t, + new_behavior: vm_behavior_t) + -> kern_return_t; + pub fn vm_map(target_task: vm_map_t, + address: *mut vm_address_t, + size: vm_size_t, + mask: vm_address_t, + flags: ::libc::c_int, + object: mem_entry_name_port_t, + offset: vm_offset_t, + copy: boolean_t, + cur_protection: vm_prot_t, + max_protection: vm_prot_t, + inheritance: vm_inherit_t) + -> kern_return_t; + pub fn vm_machine_attribute(target_task: vm_map_t, + address: vm_address_t, size: vm_size_t, attribute: vm_machine_attribute_t, value: *mut vm_machine_attribute_val_t) - -> kern_return_t; - pub fn vm_remap(target_task: vm_map_t, target_address: *mut vm_address_t, - size: vm_size_t, mask: vm_address_t, flags: ::libc::c_int, - src_task: vm_map_t, src_address: vm_address_t, - copy: boolean_t, cur_protection: *mut vm_prot_t, - max_protection: *mut vm_prot_t, inheritance: vm_inherit_t) - -> kern_return_t; - pub fn task_wire(target_task: vm_map_t, must_wire: boolean_t) - -> kern_return_t; - pub fn mach_make_memory_entry(target_task: vm_map_t, size: *mut vm_size_t, - offset: vm_offset_t, permission: vm_prot_t, + -> kern_return_t; + pub fn vm_remap(target_task: vm_map_t, + target_address: *mut vm_address_t, + size: vm_size_t, + mask: vm_address_t, + flags: ::libc::c_int, + src_task: vm_map_t, + src_address: vm_address_t, + copy: boolean_t, + cur_protection: *mut vm_prot_t, + max_protection: *mut vm_prot_t, + inheritance: vm_inherit_t) + -> kern_return_t; + pub fn task_wire(target_task: vm_map_t, must_wire: boolean_t) -> kern_return_t; + pub fn mach_make_memory_entry(target_task: vm_map_t, + size: *mut vm_size_t, + offset: vm_offset_t, + permission: vm_prot_t, object_handle: *mut mem_entry_name_port_t, parent_entry: mem_entry_name_port_t) - -> kern_return_t; - pub fn vm_map_page_query(target_map: vm_map_t, offset: vm_offset_t, + -> kern_return_t; + pub fn vm_map_page_query(target_map: vm_map_t, + offset: vm_offset_t, disposition: *mut integer_t, - ref_count: *mut integer_t) -> kern_return_t; + ref_count: *mut integer_t) + -> kern_return_t; pub fn vm_region_recurse(target_task: vm_map_t, - address: *mut vm_address_t, size: *mut vm_size_t, + address: *mut vm_address_t, + size: *mut vm_size_t, nesting_depth: *mut natural_t, info: vm_region_recurse_info_t, infoCnt: *mut mach_msg_type_number_t) - -> kern_return_t; + -> kern_return_t; pub fn vm_region_recurse_64(target_task: vm_map_t, address: *mut vm_address_t, size: *mut vm_size_t, nesting_depth: *mut natural_t, info: vm_region_recurse_info_t, infoCnt: *mut mach_msg_type_number_t) - -> kern_return_t; - pub fn vm_region_64(target_task: vm_map_t, address: *mut vm_address_t, - size: *mut vm_size_t, flavor: vm_region_flavor_t, + -> kern_return_t; + pub fn vm_region_64(target_task: vm_map_t, + address: *mut vm_address_t, + size: *mut vm_size_t, + flavor: vm_region_flavor_t, info: vm_region_info_t, infoCnt: *mut mach_msg_type_number_t, - object_name: *mut mach_port_t) -> kern_return_t; + object_name: *mut mach_port_t) + -> kern_return_t; pub fn mach_make_memory_entry_64(target_task: vm_map_t, size: *mut memory_object_size_t, offset: memory_object_offset_t, permission: vm_prot_t, object_handle: *mut mach_port_t, parent_entry: mem_entry_name_port_t) - -> kern_return_t; - pub fn vm_map_64(target_task: vm_map_t, address: *mut vm_address_t, - size: vm_size_t, mask: vm_address_t, - flags: ::libc::c_int, object: mem_entry_name_port_t, - offset: memory_object_offset_t, copy: boolean_t, - cur_protection: vm_prot_t, max_protection: vm_prot_t, - inheritance: vm_inherit_t) -> kern_return_t; - pub fn vm_purgable_control(target_task: vm_map_t, address: vm_address_t, + -> kern_return_t; + pub fn vm_map_64(target_task: vm_map_t, + address: *mut vm_address_t, + size: vm_size_t, + mask: vm_address_t, + flags: ::libc::c_int, + object: mem_entry_name_port_t, + offset: memory_object_offset_t, + copy: boolean_t, + cur_protection: vm_prot_t, + max_protection: vm_prot_t, + inheritance: vm_inherit_t) + -> kern_return_t; + pub fn vm_purgable_control(target_task: vm_map_t, + address: vm_address_t, control: vm_purgable_t, - state: *mut ::libc::c_int) -> kern_return_t; + state: *mut ::libc::c_int) + -> kern_return_t; pub fn mach_port_names(task: ipc_space_t, names: *mut mach_port_name_array_t, namesCnt: *mut mach_msg_type_number_t, types: *mut mach_port_type_array_t, typesCnt: *mut mach_msg_type_number_t) - -> kern_return_t; - pub fn mach_port_type(task: ipc_space_t, name: mach_port_name_t, - ptype: *mut mach_port_type_t) -> kern_return_t; - pub fn mach_port_rename(task: ipc_space_t, old_name: mach_port_name_t, - new_name: mach_port_name_t) -> kern_return_t; + -> kern_return_t; + pub fn mach_port_type(task: ipc_space_t, + name: mach_port_name_t, + ptype: *mut mach_port_type_t) + -> kern_return_t; + pub fn mach_port_rename(task: ipc_space_t, + old_name: mach_port_name_t, + new_name: mach_port_name_t) + -> kern_return_t; pub fn mach_port_allocate_name(task: ipc_space_t, right: mach_port_right_t, - name: mach_port_name_t) -> kern_return_t; - pub fn mach_port_allocate(task: ipc_space_t, right: mach_port_right_t, - name: *mut mach_port_name_t) -> kern_return_t; - pub fn mach_port_destroy(task: ipc_space_t, name: mach_port_name_t) - -> kern_return_t; - pub fn mach_port_deallocate(task: ipc_space_t, name: mach_port_name_t) - -> kern_return_t; - pub fn mach_port_get_refs(task: ipc_space_t, name: mach_port_name_t, + name: mach_port_name_t) + -> kern_return_t; + pub fn mach_port_allocate(task: ipc_space_t, + right: mach_port_right_t, + name: *mut mach_port_name_t) + -> kern_return_t; + pub fn mach_port_destroy(task: ipc_space_t, name: mach_port_name_t) -> kern_return_t; + pub fn mach_port_deallocate(task: ipc_space_t, name: mach_port_name_t) -> kern_return_t; + pub fn mach_port_get_refs(task: ipc_space_t, + name: mach_port_name_t, right: mach_port_right_t, - refs: *mut mach_port_urefs_t) -> kern_return_t; - pub fn mach_port_mod_refs(task: ipc_space_t, name: mach_port_name_t, + refs: *mut mach_port_urefs_t) + -> kern_return_t; + pub fn mach_port_mod_refs(task: ipc_space_t, + name: mach_port_name_t, right: mach_port_right_t, - delta: mach_port_delta_t) -> kern_return_t; - pub fn mach_port_set_mscount(task: ipc_space_t, name: mach_port_name_t, + delta: mach_port_delta_t) + -> kern_return_t; + pub fn mach_port_set_mscount(task: ipc_space_t, + name: mach_port_name_t, mscount: mach_port_mscount_t) - -> kern_return_t; - pub fn mach_port_get_set_status(task: ipc_space_t, name: mach_port_name_t, + -> kern_return_t; + pub fn mach_port_get_set_status(task: ipc_space_t, + name: mach_port_name_t, members: *mut mach_port_name_array_t, membersCnt: *mut mach_msg_type_number_t) - -> kern_return_t; - pub fn mach_port_move_member(task: ipc_space_t, member: mach_port_name_t, - after: mach_port_name_t) -> kern_return_t; + -> kern_return_t; + pub fn mach_port_move_member(task: ipc_space_t, + member: mach_port_name_t, + after: mach_port_name_t) + -> kern_return_t; pub fn mach_port_request_notification(task: ipc_space_t, name: mach_port_name_t, msgid: mach_msg_id_t, @@ -10850,216 +12820,240 @@ extern "C" { notify: mach_port_t, notifyPoly: mach_msg_type_name_t, previous: *mut mach_port_t) - -> kern_return_t; - pub fn mach_port_insert_right(task: ipc_space_t, name: mach_port_name_t, + -> kern_return_t; + pub fn mach_port_insert_right(task: ipc_space_t, + name: mach_port_name_t, poly: mach_port_t, polyPoly: mach_msg_type_name_t) - -> kern_return_t; - pub fn mach_port_extract_right(task: ipc_space_t, name: mach_port_name_t, + -> kern_return_t; + pub fn mach_port_extract_right(task: ipc_space_t, + name: mach_port_name_t, msgt_name: mach_msg_type_name_t, poly: *mut mach_port_t, polyPoly: *mut mach_msg_type_name_t) - -> kern_return_t; - pub fn mach_port_set_seqno(task: ipc_space_t, name: mach_port_name_t, - seqno: mach_port_seqno_t) -> kern_return_t; - pub fn mach_port_get_attributes(task: ipc_space_t, name: mach_port_name_t, + -> kern_return_t; + pub fn mach_port_set_seqno(task: ipc_space_t, + name: mach_port_name_t, + seqno: mach_port_seqno_t) + -> kern_return_t; + pub fn mach_port_get_attributes(task: ipc_space_t, + name: mach_port_name_t, flavor: mach_port_flavor_t, port_info_out: mach_port_info_t, - port_info_outCnt: - *mut mach_msg_type_number_t) - -> kern_return_t; - pub fn mach_port_set_attributes(task: ipc_space_t, name: mach_port_name_t, + port_info_outCnt: *mut mach_msg_type_number_t) + -> kern_return_t; + pub fn mach_port_set_attributes(task: ipc_space_t, + name: mach_port_name_t, flavor: mach_port_flavor_t, port_info: mach_port_info_t, port_infoCnt: mach_msg_type_number_t) - -> kern_return_t; - pub fn mach_port_allocate_qos(task: ipc_space_t, right: mach_port_right_t, + -> kern_return_t; + pub fn mach_port_allocate_qos(task: ipc_space_t, + right: mach_port_right_t, qos: *mut mach_port_qos_t, name: *mut mach_port_name_t) - -> kern_return_t; + -> kern_return_t; pub fn mach_port_allocate_full(task: ipc_space_t, right: mach_port_right_t, proto: mach_port_t, qos: *mut mach_port_qos_t, name: *mut mach_port_name_t) - -> kern_return_t; - pub fn task_set_port_space(task: ipc_space_t, - table_entries: ::libc::c_int) -> kern_return_t; - pub fn mach_port_get_srights(task: ipc_space_t, name: mach_port_name_t, + -> kern_return_t; + pub fn task_set_port_space(task: ipc_space_t, table_entries: ::libc::c_int) -> kern_return_t; + pub fn mach_port_get_srights(task: ipc_space_t, + name: mach_port_name_t, srights: *mut mach_port_rights_t) - -> kern_return_t; - pub fn mach_port_dnrequest_info(task: ipc_space_t, name: mach_port_name_t, + -> kern_return_t; + pub fn mach_port_dnrequest_info(task: ipc_space_t, + name: mach_port_name_t, dnr_total: *mut ::libc::c_uint, dnr_used: *mut ::libc::c_uint) - -> kern_return_t; - pub fn mach_port_kernel_object(task: ipc_space_t, name: mach_port_name_t, + -> kern_return_t; + pub fn mach_port_kernel_object(task: ipc_space_t, + name: mach_port_name_t, object_type: *mut ::libc::c_uint, object_addr: *mut ::libc::c_uint) - -> kern_return_t; - pub fn mach_port_insert_member(task: ipc_space_t, name: mach_port_name_t, - pset: mach_port_name_t) -> kern_return_t; - pub fn mach_port_extract_member(task: ipc_space_t, name: mach_port_name_t, - pset: mach_port_name_t) -> kern_return_t; - pub fn mach_port_get_context(task: ipc_space_t, name: mach_port_name_t, + -> kern_return_t; + pub fn mach_port_insert_member(task: ipc_space_t, + name: mach_port_name_t, + pset: mach_port_name_t) + -> kern_return_t; + pub fn mach_port_extract_member(task: ipc_space_t, + name: mach_port_name_t, + pset: mach_port_name_t) + -> kern_return_t; + pub fn mach_port_get_context(task: ipc_space_t, + name: mach_port_name_t, context: *mut mach_port_context_t) - -> kern_return_t; - pub fn mach_port_set_context(task: ipc_space_t, name: mach_port_name_t, + -> kern_return_t; + pub fn mach_port_set_context(task: ipc_space_t, + name: mach_port_name_t, context: mach_port_context_t) - -> kern_return_t; - pub fn mach_port_kobject(task: ipc_space_t, name: mach_port_name_t, + -> kern_return_t; + pub fn mach_port_kobject(task: ipc_space_t, + name: mach_port_name_t, object_type: *mut natural_t, object_addr: *mut mach_vm_address_t) - -> kern_return_t; + -> kern_return_t; pub fn mach_host_self() -> mach_port_t; pub fn mach_thread_self() -> mach_port_t; - pub fn host_page_size(arg1: host_t, arg2: *mut vm_size_t) - -> kern_return_t; + pub fn host_page_size(arg1: host_t, arg2: *mut vm_size_t) -> kern_return_t; pub fn clock_sleep_trap(clock_name: mach_port_name_t, sleep_type: sleep_type_t, sleep_sec: ::libc::c_int, sleep_nsec: ::libc::c_int, wakeup_time: *mut mach_timespec_t) - -> kern_return_t; + -> kern_return_t; pub fn _kernelrpc_mach_vm_allocate_trap(target: mach_port_name_t, addr: *mut mach_vm_offset_t, size: mach_vm_size_t, flags: ::libc::c_int) - -> kern_return_t; + -> kern_return_t; pub fn _kernelrpc_mach_vm_deallocate_trap(target: mach_port_name_t, address: mach_vm_address_t, size: mach_vm_size_t) - -> kern_return_t; + -> kern_return_t; pub fn _kernelrpc_mach_vm_protect_trap(target: mach_port_name_t, address: mach_vm_address_t, size: mach_vm_size_t, set_maximum: boolean_t, new_protection: vm_prot_t) - -> kern_return_t; + -> kern_return_t; pub fn _kernelrpc_mach_port_allocate_trap(target: mach_port_name_t, right: mach_port_right_t, name: *mut mach_port_name_t) - -> kern_return_t; + -> kern_return_t; pub fn _kernelrpc_mach_port_destroy_trap(target: mach_port_name_t, name: mach_port_name_t) - -> kern_return_t; + -> kern_return_t; pub fn _kernelrpc_mach_port_deallocate_trap(target: mach_port_name_t, name: mach_port_name_t) - -> kern_return_t; + -> kern_return_t; pub fn _kernelrpc_mach_port_mod_refs_trap(target: mach_port_name_t, name: mach_port_name_t, right: mach_port_right_t, delta: mach_port_delta_t) - -> kern_return_t; + -> kern_return_t; pub fn _kernelrpc_mach_port_move_member_trap(target: mach_port_name_t, member: mach_port_name_t, after: mach_port_name_t) - -> kern_return_t; + -> kern_return_t; pub fn _kernelrpc_mach_port_insert_right_trap(target: mach_port_name_t, name: mach_port_name_t, poly: mach_port_name_t, - polyPoly: - mach_msg_type_name_t) - -> kern_return_t; + polyPoly: mach_msg_type_name_t) + -> kern_return_t; pub fn _kernelrpc_mach_port_insert_member_trap(target: mach_port_name_t, name: mach_port_name_t, pset: mach_port_name_t) - -> kern_return_t; + -> kern_return_t; pub fn _kernelrpc_mach_port_extract_member_trap(target: mach_port_name_t, name: mach_port_name_t, pset: mach_port_name_t) - -> kern_return_t; - pub fn macx_swapon(filename: uint64_t, flags: ::libc::c_int, - size: ::libc::c_int, priority: ::libc::c_int) - -> kern_return_t; - pub fn macx_swapoff(filename: uint64_t, flags: ::libc::c_int) - -> kern_return_t; - pub fn macx_triggers(hi_water: ::libc::c_int, low_water: ::libc::c_int, - flags: ::libc::c_int, alert_port: mach_port_t) - -> kern_return_t; + -> kern_return_t; + pub fn macx_swapon(filename: uint64_t, + flags: ::libc::c_int, + size: ::libc::c_int, + priority: ::libc::c_int) + -> kern_return_t; + pub fn macx_swapoff(filename: uint64_t, flags: ::libc::c_int) -> kern_return_t; + pub fn macx_triggers(hi_water: ::libc::c_int, + low_water: ::libc::c_int, + flags: ::libc::c_int, + alert_port: mach_port_t) + -> kern_return_t; pub fn macx_backing_store_suspend(suspend: boolean_t) -> kern_return_t; pub fn macx_backing_store_recovery(pid: ::libc::c_int) -> kern_return_t; pub fn swtch_pri(pri: ::libc::c_int) -> boolean_t; pub fn swtch() -> boolean_t; - pub fn thread_switch(thread_name: mach_port_name_t, option: ::libc::c_int, - option_time: mach_msg_timeout_t) -> kern_return_t; + pub fn thread_switch(thread_name: mach_port_name_t, + option: ::libc::c_int, + option_time: mach_msg_timeout_t) + -> kern_return_t; pub fn task_self_trap() -> mach_port_name_t; - pub fn task_for_pid(target_tport: mach_port_name_t, pid: ::libc::c_int, - t: *mut mach_port_name_t) -> kern_return_t; + pub fn task_for_pid(target_tport: mach_port_name_t, + pid: ::libc::c_int, + t: *mut mach_port_name_t) + -> kern_return_t; pub fn task_name_for_pid(target_tport: mach_port_name_t, - pid: ::libc::c_int, tn: *mut mach_port_name_t) - -> kern_return_t; - pub fn pid_for_task(t: mach_port_name_t, x: *mut ::libc::c_int) - -> kern_return_t; - pub fn host_info(host: host_t, flavor: host_flavor_t, + pid: ::libc::c_int, + tn: *mut mach_port_name_t) + -> kern_return_t; + pub fn pid_for_task(t: mach_port_name_t, x: *mut ::libc::c_int) -> kern_return_t; + pub fn host_info(host: host_t, + flavor: host_flavor_t, host_info_out: host_info_t, host_info_outCnt: *mut mach_msg_type_number_t) - -> kern_return_t; - pub fn host_kernel_version(host: host_t, kernel_version: kernel_version_t) - -> kern_return_t; - pub fn _host_page_size(host: host_t, out_page_size: *mut vm_size_t) - -> kern_return_t; - pub fn mach_memory_object_memory_entry(host: host_t, internal: boolean_t, + -> kern_return_t; + pub fn host_kernel_version(host: host_t, kernel_version: kernel_version_t) -> kern_return_t; + pub fn _host_page_size(host: host_t, out_page_size: *mut vm_size_t) -> kern_return_t; + pub fn mach_memory_object_memory_entry(host: host_t, + internal: boolean_t, size: vm_size_t, permission: vm_prot_t, pager: memory_object_t, entry_handle: *mut mach_port_t) - -> kern_return_t; - pub fn host_processor_info(host: host_t, flavor: processor_flavor_t, + -> kern_return_t; + pub fn host_processor_info(host: host_t, + flavor: processor_flavor_t, out_processor_count: *mut natural_t, - out_processor_info: - *mut processor_info_array_t, - out_processor_infoCnt: - *mut mach_msg_type_number_t) - -> kern_return_t; - pub fn host_get_io_master(host: host_t, io_master: *mut io_master_t) - -> kern_return_t; - pub fn host_get_clock_service(host: host_t, clock_id: clock_id_t, + out_processor_info: *mut processor_info_array_t, + out_processor_infoCnt: *mut mach_msg_type_number_t) + -> kern_return_t; + pub fn host_get_io_master(host: host_t, io_master: *mut io_master_t) -> kern_return_t; + pub fn host_get_clock_service(host: host_t, + clock_id: clock_id_t, clock_serv: *mut clock_serv_t) - -> kern_return_t; - pub fn kmod_get_info(host: host_t, modules: *mut kmod_args_t, + -> kern_return_t; + pub fn kmod_get_info(host: host_t, + modules: *mut kmod_args_t, modulesCnt: *mut mach_msg_type_number_t) - -> kern_return_t; + -> kern_return_t; pub fn processor_set_default(host: host_t, default_set: *mut processor_set_name_t) - -> kern_return_t; - pub fn processor_set_create(host: host_t, new_set: *mut processor_set_t, + -> kern_return_t; + pub fn processor_set_create(host: host_t, + new_set: *mut processor_set_t, new_name: *mut processor_set_name_t) - -> kern_return_t; + -> kern_return_t; pub fn mach_memory_object_memory_entry_64(host: host_t, internal: boolean_t, size: memory_object_size_t, permission: vm_prot_t, pager: memory_object_t, entry_handle: *mut mach_port_t) - -> kern_return_t; - pub fn host_statistics(host_priv: host_t, flavor: host_flavor_t, + -> kern_return_t; + pub fn host_statistics(host_priv: host_t, + flavor: host_flavor_t, host_info_out: host_info_t, host_info_outCnt: *mut mach_msg_type_number_t) - -> kern_return_t; - pub fn host_request_notification(host: host_t, notify_type: host_flavor_t, + -> kern_return_t; + pub fn host_request_notification(host: host_t, + notify_type: host_flavor_t, notify_port: mach_port_t) - -> kern_return_t; - pub fn host_statistics64(host_priv: host_t, flavor: host_flavor_t, + -> kern_return_t; + pub fn host_statistics64(host_priv: host_t, + flavor: host_flavor_t, host_info64_out: host_info64_t, host_info64_outCnt: *mut mach_msg_type_number_t) - -> kern_return_t; - pub fn mach_error_string(error_value: mach_error_t) - -> *mut ::libc::c_char; - pub fn mach_error(str: *const ::libc::c_char, error_value: mach_error_t) - -> (); + -> kern_return_t; + pub fn mach_error_string(error_value: mach_error_t) -> *mut ::libc::c_char; + pub fn mach_error(str: *const ::libc::c_char, error_value: mach_error_t) -> (); pub fn mach_error_type(error_value: mach_error_t) -> *mut ::libc::c_char; pub fn panic_init(arg1: mach_port_t) -> (); pub fn panic(arg1: *const ::libc::c_char, ...) -> (); - pub fn safe_gets(arg1: *mut ::libc::c_char, arg2: *mut ::libc::c_char, - arg3: ::libc::c_int) -> (); - pub fn slot_name(arg1: cpu_type_t, arg2: cpu_subtype_t, + pub fn safe_gets(arg1: *mut ::libc::c_char, + arg2: *mut ::libc::c_char, + arg3: ::libc::c_int) + -> (); + pub fn slot_name(arg1: cpu_type_t, + arg2: cpu_subtype_t, arg3: *mut *mut ::libc::c_char, - arg4: *mut *mut ::libc::c_char) -> (); - pub fn mig_reply_setup(arg1: *mut mach_msg_header_t, - arg2: *mut mach_msg_header_t) -> (); + arg4: *mut *mut ::libc::c_char) + -> (); + pub fn mig_reply_setup(arg1: *mut mach_msg_header_t, arg2: *mut mach_msg_header_t) -> (); pub fn mach_msg_destroy(arg1: *mut mach_msg_header_t) -> (); - pub fn mach_msg_receive(arg1: *mut mach_msg_header_t) - -> mach_msg_return_t; + pub fn mach_msg_receive(arg1: *mut mach_msg_header_t) -> mach_msg_return_t; pub fn mach_msg_send(arg1: *mut mach_msg_header_t) -> mach_msg_return_t; pub fn mach_msg_server_once(arg1: ::std::option::Option boolean_t>, arg2: mach_msg_size_t, arg3: mach_port_t, arg4: mach_msg_options_t) -> mach_msg_return_t; - pub fn clock_get_res(arg1: mach_port_t, arg2: *mut clock_res_t) - -> kern_return_t; - pub fn clock_set_res(arg1: mach_port_t, arg2: clock_res_t) - -> kern_return_t; - pub fn clock_sleep(arg1: mach_port_t, arg2: ::libc::c_int, - arg3: mach_timespec_t, arg4: *mut mach_timespec_t) - -> kern_return_t; + pub fn clock_get_res(arg1: mach_port_t, arg2: *mut clock_res_t) -> kern_return_t; + pub fn clock_set_res(arg1: mach_port_t, arg2: clock_res_t) -> kern_return_t; + pub fn clock_sleep(arg1: mach_port_t, + arg2: ::libc::c_int, + arg3: mach_timespec_t, + arg4: *mut mach_timespec_t) + -> kern_return_t; } diff --git a/platform/macos/mod.rs b/platform/macos/mod.rs index b8a822397..b14ee36ca 100644 --- a/platform/macos/mod.rs +++ b/platform/macos/mod.rs @@ -7,13 +7,12 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use bincode::serde::DeserializeError; +use libc::{self, c_char, c_uint, c_void, size_t}; use platform::macos::mach_sys::{kern_return_t, mach_msg_body_t, mach_msg_header_t}; use platform::macos::mach_sys::{mach_msg_ool_descriptor_t, mach_msg_port_descriptor_t}; use platform::macos::mach_sys::{mach_msg_timeout_t, mach_port_limits_t, mach_port_msgcount_t}; use platform::macos::mach_sys::{mach_port_right_t, mach_port_t, mach_task_self_, vm_inherit_t}; - -use bincode::serde::DeserializeError; -use libc::{self, c_char, c_uint, c_void, size_t}; use rand::{self, Rng}; use std::cell::Cell; use std::ffi::CString; @@ -105,7 +104,7 @@ const VM_INHERIT_SHARE: vm_inherit_t = 0; #[allow(non_camel_case_types)] type name_t = *const c_char; -pub fn channel() -> Result<(MachSender, MachReceiver),MachError> { +pub fn channel() -> Result<(MachSender, MachReceiver), MachError> { let receiver = try!(MachReceiver::new()); let sender = try!(receiver.sender()); try!(receiver.request_no_senders_notification()); @@ -132,17 +131,15 @@ impl Drop for MachReceiver { } impl MachReceiver { - fn new() -> Result { + fn new() -> Result { let mut port: mach_port_t = 0; let os_result = unsafe { mach_sys::mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &mut port) }; if os_result != KERN_SUCCESS { - return Err(MachError(os_result)) + return Err(MachError(os_result)); } - let limits = mach_port_limits_t { - mpl_qlimit: MACH_PORT_QLIMIT_MAX, - }; + let limits = mach_port_limits_t { mpl_qlimit: MACH_PORT_QLIMIT_MAX }; let os_result = unsafe { mach_sys::mach_port_set_attributes(mach_task_self(), port, @@ -158,9 +155,7 @@ impl MachReceiver { } fn from_name(port: mach_port_t) -> MachReceiver { - MachReceiver { - port: Cell::new(port), - } + MachReceiver { port: Cell::new(port) } } fn consume_port(&self) -> mach_port_t { @@ -174,7 +169,7 @@ impl MachReceiver { MachReceiver::from_name(self.consume_port()) } - fn sender(&self) -> Result { + fn sender(&self) -> Result { let port = self.port.get(); debug_assert!(port != MACH_PORT_NULL); unsafe { @@ -193,7 +188,7 @@ impl MachReceiver { } } - fn register_bootstrap_name(&self) -> Result { + fn register_bootstrap_name(&self) -> Result { let port = self.port.get(); debug_assert!(port != MACH_PORT_NULL); unsafe { @@ -202,7 +197,7 @@ impl MachReceiver { TASK_BOOTSTRAP_PORT, &mut bootstrap_port); if os_result != KERN_SUCCESS { - return Err(MachError(os_result)) + return Err(MachError(os_result)); } @@ -214,7 +209,7 @@ impl MachReceiver { &mut right, &mut acquired_right); if os_result != KERN_SUCCESS { - return Err(MachError(os_result)) + return Err(MachError(os_result)); } debug_assert!(acquired_right == MACH_MSG_TYPE_PORT_SEND as u32); @@ -225,32 +220,29 @@ impl MachReceiver { let c_name = CString::new(name.clone()).unwrap(); os_result = bootstrap_register2(bootstrap_port, c_name.as_ptr(), right, 0); if os_result == BOOTSTRAP_NAME_IN_USE { - continue + continue; } if os_result != BOOTSTRAP_SUCCESS { - return Err(MachError(os_result)) + return Err(MachError(os_result)); } - break + break; } Ok(name) } } - fn unregister_global_name(name: String) -> Result<(),MachError> { + fn unregister_global_name(name: String) -> Result<(), MachError> { unsafe { let mut bootstrap_port = 0; let os_result = mach_sys::task_get_special_port(mach_task_self(), TASK_BOOTSTRAP_PORT, &mut bootstrap_port); if os_result != KERN_SUCCESS { - return Err(MachError(os_result)) + return Err(MachError(os_result)); } let c_name = CString::new(name).unwrap(); - let os_result = bootstrap_register2(bootstrap_port, - c_name.as_ptr(), - MACH_PORT_NULL, - 0); + let os_result = bootstrap_register2(bootstrap_port, c_name.as_ptr(), MACH_PORT_NULL, 0); if os_result == BOOTSTRAP_SUCCESS { Ok(()) } else { @@ -259,7 +251,7 @@ impl MachReceiver { } } - fn request_no_senders_notification(&self) -> Result<(),MachError> { + fn request_no_senders_notification(&self) -> Result<(), MachError> { let port = self.port.get(); debug_assert!(port != MACH_PORT_NULL); unsafe { @@ -272,15 +264,16 @@ impl MachReceiver { MACH_MSG_TYPE_MAKE_SEND_ONCE as u32, &mut 0); if os_result != KERN_SUCCESS { - return Err(MachError(os_result)) + return Err(MachError(os_result)); } } Ok(()) } - fn recv_with_blocking_mode(&self, blocking_mode: BlockingMode) - -> Result<(Vec, Vec, Vec), - MachError> { + fn recv_with_blocking_mode + (&self, + blocking_mode: BlockingMode) + -> Result<(Vec, Vec, Vec), MachError> { select(self.port.get(), blocking_mode).and_then(|result| { match result { MachSelectionResult::DataReceived(_, data, channels, shared_memory_regions) => { @@ -291,13 +284,13 @@ impl MachReceiver { }) } - pub fn recv(&self) - -> Result<(Vec, Vec, Vec),MachError> { + pub fn recv(&self) -> Result<(Vec, Vec, Vec), MachError> { self.recv_with_blocking_mode(BlockingMode::Blocking) } - pub fn try_recv(&self) - -> Result<(Vec, Vec, Vec),MachError> { + pub fn try_recv + (&self) + -> Result<(Vec, Vec, Vec), MachError> { self.recv_with_blocking_mode(BlockingMode::Nonblocking) } } @@ -317,7 +310,9 @@ impl Drop for MachSender { // `KERN_INVALID_RIGHT` is returned if (as far as I can tell) the receiver already shut // down. This is fine. if error != KERN_SUCCESS && error != KERN_INVALID_RIGHT { - panic!("mach_port_mod_refs(-1, {}) failed: {:08x}", self.port, error) + panic!("mach_port_mod_refs(-1, {}) failed: {:08x}", + self.port, + error) } } } @@ -331,27 +326,23 @@ impl Clone for MachSender { MACH_PORT_RIGHT_SEND, 1) == KERN_SUCCESS); } - MachSender { - port: self.port, - } + MachSender { port: self.port } } } impl MachSender { fn from_name(port: mach_port_t) -> MachSender { - MachSender { - port: port, - } + MachSender { port: port } } - pub fn connect(name: String) -> Result { + pub fn connect(name: String) -> Result { unsafe { let mut bootstrap_port = 0; let os_result = mach_sys::task_get_special_port(mach_task_self(), TASK_BOOTSTRAP_PORT, &mut bootstrap_port); if os_result != KERN_SUCCESS { - return Err(MachError(os_result)) + return Err(MachError(os_result)); } let mut port = 0; @@ -369,12 +360,11 @@ impl MachSender { data: &[u8], ports: Vec, shared_memory_regions: Vec) - -> Result<(),MachError> { + -> Result<(), MachError> { unsafe { let size = Message::size_of(data.len(), ports.len(), shared_memory_regions.len()); let message = libc::malloc(size as size_t) as *mut Message; - (*message).header.msgh_bits = (MACH_MSG_TYPE_COPY_SEND as u32) | - MACH_MSGH_BITS_COMPLEX; + (*message).header.msgh_bits = (MACH_MSG_TYPE_COPY_SEND as u32) | MACH_MSGH_BITS_COMPLEX; (*message).header.msgh_size = size as u32; (*message).header.msgh_local_port = MACH_PORT_NULL; (*message).header.msgh_remote_port = self.port; @@ -432,7 +422,7 @@ impl MachSender { MACH_PORT_NULL); libc::free(message as *mut _); if os_result != MACH_MSG_SUCCESS { - return Err(MachError(os_result)) + return Err(MachError(os_result)); } Ok(()) } @@ -467,15 +457,11 @@ impl Drop for OpaqueMachChannel { impl OpaqueMachChannel { fn from_name(name: mach_port_t) -> OpaqueMachChannel { - OpaqueMachChannel { - port: name, - } + OpaqueMachChannel { port: name } } pub fn to_sender(&mut self) -> MachSender { - MachSender { - port: mem::replace(&mut self.port, MACH_PORT_NULL), - } + MachSender { port: mem::replace(&mut self.port, MACH_PORT_NULL) } } pub fn to_receiver(&mut self) -> MachReceiver { @@ -488,21 +474,19 @@ pub struct MachReceiverSet { } impl MachReceiverSet { - pub fn new() -> Result { + pub fn new() -> Result { let mut port: mach_port_t = 0; let os_result = unsafe { mach_sys::mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_PORT_SET, &mut port) }; if os_result == KERN_SUCCESS { - Ok(MachReceiverSet { - port: Cell::new(port), - }) + Ok(MachReceiverSet { port: Cell::new(port) }) } else { Err(MachError(os_result)) } } - pub fn add(&mut self, receiver: MachReceiver) -> Result { + pub fn add(&mut self, receiver: MachReceiver) -> Result { let receiver_port = receiver.consume_port(); let os_result = unsafe { mach_sys::mach_port_move_member(mach_task_self(), receiver_port, self.port.get()) @@ -514,12 +498,10 @@ impl MachReceiverSet { } } - pub fn select(&mut self) -> Result,MachError> { + pub fn select(&mut self) -> Result, MachError> { match select(self.port.get(), BlockingMode::Blocking).map(|result| vec![result]) { Ok(results) => Ok(results), - Err(error) => { - Err(error) - } + Err(error) => Err(error), } } } @@ -536,7 +518,8 @@ impl MachSelectionResult { (id, data, channels, shared_memory_regions) } MachSelectionResult::ChannelClosed(id) => { - panic!("MachSelectionResult::unwrap(): receiver ID {} was closed!", id) + panic!("MachSelectionResult::unwrap(): receiver ID {} was closed!", + id) } } } @@ -548,8 +531,9 @@ enum BlockingMode { Nonblocking, } -fn select(port: mach_port_t, blocking_mode: BlockingMode) - -> Result { +fn select(port: mach_port_t, + blocking_mode: BlockingMode) + -> Result { debug_assert!(port != MACH_PORT_NULL); unsafe { let mut buffer = [0; SMALL_MESSAGE_SIZE]; @@ -594,7 +578,7 @@ fn select(port: mach_port_t, blocking_mode: BlockingMode) } os_result => { libc::free(allocated_buffer.unwrap() as *mut _); - return Err(MachError(os_result)) + return Err(MachError(os_result)); } } } @@ -605,7 +589,7 @@ fn select(port: mach_port_t, blocking_mode: BlockingMode) let local_port = (*message).header.msgh_local_port; if (*message).header.msgh_id == MACH_NOTIFY_NO_SENDERS { - return Ok(MachSelectionResult::ChannelClosed(local_port as i64)) + return Ok(MachSelectionResult::ChannelClosed(local_port as i64)); } let (mut ports, mut shared_memory_regions) = (Vec::new(), Vec::new()); @@ -613,7 +597,7 @@ fn select(port: mach_port_t, blocking_mode: BlockingMode) let mut descriptors_remaining = (*message).body.msgh_descriptor_count; while descriptors_remaining > 0 { if (*port_descriptor).type_ != MACH_MSG_PORT_DESCRIPTOR { - break + break; } ports.push(OpaqueMachChannel::from_name((*port_descriptor).name)); port_descriptor = port_descriptor.offset(1); @@ -632,7 +616,7 @@ fn select(port: mach_port_t, blocking_mode: BlockingMode) let payload_ptr = shared_memory_descriptor as *mut u8; let payload_size = message as usize + ((*message).header.msgh_size as usize) - - (shared_memory_descriptor as usize); + (shared_memory_descriptor as usize); let payload = slice::from_raw_parts(payload_ptr, payload_size).to_vec(); if let Some(allocated_buffer) = allocated_buffer { @@ -658,21 +642,21 @@ impl Drop for MachOneShotServer { } impl MachOneShotServer { - pub fn new() -> Result<(MachOneShotServer, String),MachError> { + pub fn new() -> Result<(MachOneShotServer, String), MachError> { let receiver = try!(MachReceiver::new()); let name = try!(receiver.register_bootstrap_name()); Ok((MachOneShotServer { receiver: Some(receiver), name: name.clone(), - }, name)) + }, + name)) } pub fn accept(mut self) -> Result<(MachReceiver, Vec, Vec, - Vec),MachError> { - let (bytes, channels, shared_memory_regions) = - try!(self.receiver.as_mut().unwrap().recv()); + Vec), MachError> { + let (bytes, channels, shared_memory_regions) = try!(self.receiver.as_mut().unwrap().recv()); Ok((mem::replace(&mut self.receiver, None).unwrap(), bytes, channels, @@ -692,9 +676,8 @@ impl Drop for MachSharedMemory { fn drop(&mut self) { if !self.ptr.is_null() { unsafe { - assert!(mach_sys::vm_deallocate(mach_task_self(), - self.ptr as usize, - self.length) == KERN_SUCCESS); + assert!(mach_sys::vm_deallocate(mach_task_self(), self.ptr as usize, self.length) == + KERN_SUCCESS); } } } @@ -743,9 +726,7 @@ impl Deref for MachSharedMemory { if self.ptr.is_null() && self.length > 0 { panic!("attempted to access a consumed `MachSharedMemory`") } - unsafe { - slice::from_raw_parts(self.ptr, self.length) - } + unsafe { slice::from_raw_parts(self.ptr, self.length) } } } @@ -804,9 +785,9 @@ struct Message { impl Message { fn size_of(data_length: usize, port_length: usize, shared_memory_length: usize) -> usize { let mut size = mem::size_of::() + - mem::size_of::() * port_length + - mem::size_of::() * shared_memory_length + - data_length; + mem::size_of::() * port_length + + mem::size_of::() * shared_memory_length + + data_length; // Round up to the next 4 bytes. if (size & 0x3) != 0 { @@ -861,51 +842,55 @@ impl From for Error { MACH_SEND_INVALID_DATA => Error::new(ErrorKind::InvalidData, "Bogus in-line data."), MACH_SEND_INVALID_DEST => Error::new(ErrorKind::NotFound, "Bogus destination port."), MACH_SEND_TIMED_OUT => { - Error::new(ErrorKind::TimedOut, "Message not sent before timeout expired.") + Error::new(ErrorKind::TimedOut, + "Message not sent before timeout expired.") } MACH_SEND_INVALID_VOUCHER => Error::new(ErrorKind::NotFound, "Bogus voucher port."), MACH_SEND_INTERRUPTED => Error::new(ErrorKind::Interrupted, "Software interrupt."), MACH_SEND_MSG_TOO_SMALL => { - Error::new(ErrorKind::InvalidData, "Data doesn't contain a complete message.") + Error::new(ErrorKind::InvalidData, + "Data doesn't contain a complete message.") } MACH_SEND_INVALID_REPLY => Error::new(ErrorKind::InvalidInput, "Bogus reply port."), MACH_SEND_INVALID_RIGHT => { - Error::new(ErrorKind::InvalidInput, "Bogus port rights in the message body.") + Error::new(ErrorKind::InvalidInput, + "Bogus port rights in the message body.") } MACH_SEND_INVALID_NOTIFY => { Error::new(ErrorKind::InvalidInput, "Bogus notify port argument.") } MACH_SEND_INVALID_MEMORY => { - Error::new(ErrorKind::InvalidInput, "Invalid out-of-line memory pointer.") - } - MACH_SEND_NO_BUFFER => { - Error::new(ErrorKind::Other, "No message buffer is available.") - } - MACH_SEND_TOO_LARGE => { - Error::new(ErrorKind::InvalidData, "Send is too large for port") + Error::new(ErrorKind::InvalidInput, + "Invalid out-of-line memory pointer.") } + MACH_SEND_NO_BUFFER => Error::new(ErrorKind::Other, "No message buffer is available."), + MACH_SEND_TOO_LARGE => Error::new(ErrorKind::InvalidData, "Send is too large for port"), MACH_SEND_INVALID_TYPE => { Error::new(ErrorKind::InvalidInput, "Invalid msg-type specification.") } MACH_SEND_INVALID_HEADER => { - Error::new(ErrorKind::InvalidInput, "A field in the header had a bad value.") + Error::new(ErrorKind::InvalidInput, + "A field in the header had a bad value.") } MACH_SEND_INVALID_TRAILER => { Error::new(ErrorKind::InvalidData, "The trailer to be sent does not match kernel format.") } MACH_SEND_INVALID_RT_OOL_SIZE => { - Error::new(ErrorKind::Other, "compatibility: no longer a returned error") + Error::new(ErrorKind::Other, + "compatibility: no longer a returned error") } MACH_RCV_IN_PROGRESS => { Error::new(ErrorKind::Interrupted, "Thread is waiting for receive. (Internal use only.)") } MACH_RCV_INVALID_NAME => { - Error::new(ErrorKind::InvalidInput, "Bogus name for receive port/port-set.") + Error::new(ErrorKind::InvalidInput, + "Bogus name for receive port/port-set.") } MACH_RCV_TIMED_OUT => { - Error::new(ErrorKind::TimedOut, "Didn't get a message within the timeout value.") + Error::new(ErrorKind::TimedOut, + "Didn't get a message within the timeout value.") } MACH_RCV_TOO_LARGE => { Error::new(ErrorKind::InvalidInput, @@ -913,25 +898,31 @@ impl From for Error { } MACH_RCV_INTERRUPTED => Error::new(ErrorKind::Interrupted, "Software interrupt."), MACH_RCV_PORT_CHANGED => { - Error::new(ErrorKind::Other, "compatibility: no longer a returned error") + Error::new(ErrorKind::Other, + "compatibility: no longer a returned error") } MACH_RCV_INVALID_NOTIFY => { Error::new(ErrorKind::InvalidInput, "Bogus notify port argument.") } MACH_RCV_INVALID_DATA => { - Error::new(ErrorKind::InvalidInput, "Bogus message buffer for inline data.") + Error::new(ErrorKind::InvalidInput, + "Bogus message buffer for inline data.") } MACH_RCV_PORT_DIED => { - Error::new(ErrorKind::BrokenPipe, "Port/set was sent away/died during receive.") + Error::new(ErrorKind::BrokenPipe, + "Port/set was sent away/died during receive.") } MACH_RCV_IN_SET => { - Error::new(ErrorKind::Other, "compatibility: no longer a returned error") + Error::new(ErrorKind::Other, + "compatibility: no longer a returned error") } MACH_RCV_HEADER_ERROR => { - Error::new(ErrorKind::Other, "Error receiving message header. See special bits.") + Error::new(ErrorKind::Other, + "Error receiving message header. See special bits.") } MACH_RCV_BODY_ERROR => { - Error::new(ErrorKind::Other, "Error receiving message body. See special bits.") + Error::new(ErrorKind::Other, + "Error receiving message body. See special bits.") } MACH_RCV_INVALID_TYPE => { Error::new(ErrorKind::InvalidInput, @@ -957,10 +948,14 @@ impl From for Error { } } -extern { - fn bootstrap_register2(bp: mach_port_t, service_name: name_t, sp: mach_port_t, flags: u64) +extern "C" { + fn bootstrap_register2(bp: mach_port_t, + service_name: name_t, + sp: mach_port_t, + flags: u64) -> kern_return_t; - fn bootstrap_look_up(bp: mach_port_t, service_name: name_t, sp: *mut mach_port_t) + fn bootstrap_look_up(bp: mach_port_t, + service_name: name_t, + sp: *mut mach_port_t) -> kern_return_t; } - diff --git a/platform/mod.rs b/platform/mod.rs index f12f3d102..b060d26ac 100644 --- a/platform/mod.rs +++ b/platform/mod.rs @@ -7,71 +7,70 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#[cfg(target_os="linux")] +#[cfg(target_os = "linux")] pub use platform::linux::channel; -#[cfg(target_os="linux")] +#[cfg(target_os = "linux")] pub use platform::linux::UnixReceiver as OsIpcReceiver; -#[cfg(target_os="linux")] +#[cfg(target_os = "linux")] pub use platform::linux::UnixSender as OsIpcSender; -#[cfg(target_os="linux")] +#[cfg(target_os = "linux")] pub use platform::linux::UnixReceiverSet as OsIpcReceiverSet; -#[cfg(target_os="linux")] +#[cfg(target_os = "linux")] pub use platform::linux::UnixSharedMemory as OsIpcSharedMemory; -#[cfg(target_os="linux")] +#[cfg(target_os = "linux")] pub use platform::linux::UnixChannel as OsIpcChannel; -#[cfg(target_os="linux")] +#[cfg(target_os = "linux")] pub use platform::linux::UnixSelectionResult as OsIpcSelectionResult; -#[cfg(target_os="linux")] +#[cfg(target_os = "linux")] pub use platform::linux::OpaqueUnixChannel as OsOpaqueIpcChannel; -#[cfg(target_os="linux")] +#[cfg(target_os = "linux")] pub use platform::linux::UnixOneShotServer as OsIpcOneShotServer; -#[cfg(target_os="macos")] +#[cfg(target_os = "macos")] pub use platform::macos::channel; -#[cfg(target_os="macos")] +#[cfg(target_os = "macos")] pub use platform::macos::MachReceiver as OsIpcReceiver; -#[cfg(target_os="macos")] +#[cfg(target_os = "macos")] pub use platform::macos::MachSender as OsIpcSender; -#[cfg(target_os="macos")] +#[cfg(target_os = "macos")] pub use platform::macos::MachReceiverSet as OsIpcReceiverSet; -#[cfg(target_os="macos")] +#[cfg(target_os = "macos")] pub use platform::macos::MachSharedMemory as OsIpcSharedMemory; -#[cfg(target_os="macos")] +#[cfg(target_os = "macos")] pub use platform::macos::MachChannel as OsIpcChannel; -#[cfg(target_os="macos")] +#[cfg(target_os = "macos")] pub use platform::macos::MachSelectionResult as OsIpcSelectionResult; -#[cfg(target_os="macos")] +#[cfg(target_os = "macos")] pub use platform::macos::OpaqueMachChannel as OsOpaqueIpcChannel; -#[cfg(target_os="macos")] +#[cfg(target_os = "macos")] pub use platform::macos::MachOneShotServer as OsIpcOneShotServer; // Windows and Android use in-process mpsc channels IPC for now -#[cfg(any(target_os="windows", target_os="android"))] +#[cfg(any(target_os = "windows", target_os = "android"))] pub use platform::inprocess::channel; -#[cfg(any(target_os="windows", target_os="android"))] +#[cfg(any(target_os = "windows", target_os = "android"))] pub use platform::inprocess::MpscReceiver as OsIpcReceiver; -#[cfg(any(target_os="windows", target_os="android"))] +#[cfg(any(target_os = "windows", target_os = "android"))] pub use platform::inprocess::MpscSender as OsIpcSender; -#[cfg(any(target_os="windows", target_os="android"))] +#[cfg(any(target_os = "windows", target_os = "android"))] pub use platform::inprocess::MpscReceiverSet as OsIpcReceiverSet; -#[cfg(any(target_os="windows", target_os="android"))] +#[cfg(any(target_os = "windows", target_os = "android"))] pub use platform::inprocess::MpscSharedMemory as OsIpcSharedMemory; -#[cfg(any(target_os="windows", target_os="android"))] +#[cfg(any(target_os = "windows", target_os = "android"))] pub use platform::inprocess::MpscChannel as OsIpcChannel; -#[cfg(any(target_os="windows", target_os="android"))] +#[cfg(any(target_os = "windows", target_os = "android"))] pub use platform::inprocess::MpscSelectionResult as OsIpcSelectionResult; -#[cfg(any(target_os="windows", target_os="android"))] +#[cfg(any(target_os = "windows", target_os = "android"))] pub use platform::inprocess::OpaqueMpscChannel as OsOpaqueIpcChannel; -#[cfg(any(target_os="windows", target_os="android"))] +#[cfg(any(target_os = "windows", target_os = "android"))] pub use platform::inprocess::MpscOneShotServer as OsIpcOneShotServer; -#[cfg(target_os="linux")] +#[cfg(target_os = "linux")] mod linux; -#[cfg(target_os="macos")] +#[cfg(target_os = "macos")] mod macos; -#[cfg(any(target_os="windows", target_os="android"))] +#[cfg(any(target_os = "windows", target_os = "android"))] mod inprocess; #[cfg(test)] mod test; - diff --git a/platform/test.rs b/platform/test.rs index d344ac27e..f893457d2 100644 --- a/platform/test.rs +++ b/platform/test.rs @@ -8,15 +8,14 @@ // except according to those terms. use libc; +use platform::OsIpcSharedMemory; use platform::{self, OsIpcChannel, OsIpcReceiverSet, OsIpcSender, OsIpcOneShotServer}; -use platform::{OsIpcSharedMemory}; use std::mem; use std::sync::Arc; -use std::time::{Duration, Instant}; use std::thread; +use std::time::{Duration, Instant}; -#[cfg(not(windows))] -use test::{fork, Wait}; +#[cfg(not(windows))] use test::{ fork, Wait }; #[test] fn simple() { @@ -39,8 +38,8 @@ fn sender_transfer() { assert_eq!(received_channels.len(), 1); let sub_tx = received_channels.pop().unwrap().to_sender(); sub_tx.send(data, vec![], vec![]).unwrap(); - let (mut received_data, received_channels, received_shared_memory_regions) = - sub_rx.recv().unwrap(); + let (mut received_data, received_channels, received_shared_memory_regions) = sub_rx.recv() + .unwrap(); received_data.truncate(3); assert_eq!((&received_data[..], received_channels, received_shared_memory_regions), (data, vec![], vec![])); @@ -56,8 +55,8 @@ fn receiver_transfer() { assert_eq!(received_channels.len(), 1); let sub_rx = received_channels.pop().unwrap().to_receiver(); sub_tx.send(data, vec![], vec![]).unwrap(); - let (mut received_data, received_channels, received_shared_memory_regions) = - sub_rx.recv().unwrap(); + let (mut received_data, received_channels, received_shared_memory_regions) = sub_rx.recv() + .unwrap(); received_data.truncate(3); assert_eq!((&received_data[..], received_channels, received_shared_memory_regions), (data, vec![], vec![])); @@ -71,7 +70,8 @@ fn multisender_transfer() { let data: &[u8] = b"asdfasdf"; super_tx.send(data, vec![OsIpcChannel::Sender(sub0_tx), OsIpcChannel::Sender(sub1_tx)], - vec![]).unwrap(); + vec![]) + .unwrap(); let (_, mut received_channels, _) = super_rx.recv().unwrap(); assert_eq!(received_channels.len(), 2); @@ -98,8 +98,7 @@ fn medium_data() { let data: &[u8] = &data[..]; let (tx, rx) = platform::channel().unwrap(); tx.send(data, vec![], vec![]).unwrap(); - let (mut received_data, received_channels, received_shared_memory_regions) = - rx.recv().unwrap(); + let (mut received_data, received_channels, received_shared_memory_regions) = rx.recv().unwrap(); received_data.truncate(65536); assert_eq!((&received_data[..], received_channels, received_shared_memory_regions), (&data[..], vec![], vec![])); @@ -116,8 +115,8 @@ fn medium_data_with_sender_transfer() { assert_eq!(received_channels.len(), 1); let sub_tx = received_channels.pop().unwrap().to_sender(); sub_tx.send(data, vec![], vec![]).unwrap(); - let (mut received_data, received_channels, received_shared_memory_regions) = - sub_rx.recv().unwrap(); + let (mut received_data, received_channels, received_shared_memory_regions) = sub_rx.recv() + .unwrap(); received_data.truncate(65536); assert_eq!((&received_data[..], received_channels, received_shared_memory_regions), (data, vec![], vec![])); @@ -127,13 +126,12 @@ fn medium_data_with_sender_transfer() { fn big_data() { let (tx, rx) = platform::channel().unwrap(); let thread = thread::spawn(move || { - let data: Vec = (0.. 1024 * 1024).map(|i| (i % 251) as u8).collect(); + let data: Vec = (0..1024 * 1024).map(|i| (i % 251) as u8).collect(); let data: &[u8] = &data[..]; tx.send(data, vec![], vec![]).unwrap(); }); - let (mut received_data, received_channels, received_shared_memory_regions) = - rx.recv().unwrap(); - let data: Vec = (0.. 1024 * 1024).map(|i| (i % 251) as u8).collect(); + let (mut received_data, received_channels, received_shared_memory_regions) = rx.recv().unwrap(); + let data: Vec = (0..1024 * 1024).map(|i| (i % 251) as u8).collect(); let data: &[u8] = &data[..]; received_data.truncate(1024 * 1024); assert_eq!(received_data.len(), data.len()); @@ -147,13 +145,13 @@ fn big_data_with_sender_transfer() { let (super_tx, super_rx) = platform::channel().unwrap(); let (sub_tx, sub_rx) = platform::channel().unwrap(); let thread = thread::spawn(move || { - let data: Vec = (0.. 1024 * 1024).map(|i| (i % 251) as u8).collect(); + let data: Vec = (0..1024 * 1024).map(|i| (i % 251) as u8).collect(); let data: &[u8] = &data[..]; super_tx.send(data, vec![OsIpcChannel::Sender(sub_tx)], vec![]).unwrap(); }); let (mut received_data, mut received_channels, received_shared_memory_regions) = super_rx.recv().unwrap(); - let data: Vec = (0.. 1024 * 1024).map(|i| (i % 251) as u8).collect(); + let data: Vec = (0..1024 * 1024).map(|i| (i % 251) as u8).collect(); let data: &[u8] = &data[..]; received_data.truncate(1024 * 1024); assert_eq!(received_data.len(), data.len()); @@ -165,8 +163,8 @@ fn big_data_with_sender_transfer() { let data: &[u8] = &data[..]; let sub_tx = received_channels[0].to_sender(); sub_tx.send(data, vec![], vec![]).unwrap(); - let (mut received_data, received_channels, received_shared_memory_regions) = - sub_rx.recv().unwrap(); + let (mut received_data, received_channels, received_shared_memory_regions) = sub_rx.recv() + .unwrap(); received_data.truncate(65536); assert_eq!(received_data.len(), data.len()); assert_eq!((&received_data[..], received_channels, received_shared_memory_regions), @@ -176,7 +174,7 @@ fn big_data_with_sender_transfer() { #[test] // This test only applies to platforms that need fragmentation. -#[cfg(target_os="linux")] +#[cfg(target_os = "linux")] fn full_packet() { let (tx, rx) = platform::channel().unwrap(); @@ -194,8 +192,7 @@ fn full_packet() { let data: &[u8] = &data[..]; tx.send(data, vec![], vec![]).unwrap(); - let (mut received_data, received_channels, received_shared_memory_regions) = - rx.recv().unwrap(); + let (mut received_data, received_channels, received_shared_memory_regions) = rx.recv().unwrap(); received_data.truncate(size); assert_eq!((&received_data[..], received_channels, received_shared_memory_regions), (&data[..], vec![], vec![])); @@ -256,22 +253,26 @@ fn concurrent_senders() { let (tx, rx) = platform::channel().unwrap(); - let threads: Vec<_> = (0..num_senders).map(|i| { - let tx = tx.clone(); - thread::spawn(move || { - let data: Vec = (0.. 1024 * 1024).map(|j| (j % 13) as u8 | i << 4).collect(); - let data: &[u8] = &data[..]; - tx.send(data, vec![], vec![]).unwrap(); - }) - }).collect(); + let threads: Vec<_> = (0..num_senders) + .map(|i| { + let tx = tx.clone(); + thread::spawn(move || { + let data: Vec = (0..1024 * 1024) + .map(|j| (j % 13) as u8 | i << 4) + .collect(); + let data: &[u8] = &data[..]; + tx.send(data, vec![], vec![]).unwrap(); + }) + }) + .collect(); let mut received_vals: Vec = vec![]; for _ in 0..num_senders { - let (mut received_data, received_channels, received_shared_memory_regions) = - rx.recv().unwrap(); + let (mut received_data, received_channels, received_shared_memory_regions) = rx.recv() + .unwrap(); let val = received_data[0] >> 4; received_vals.push(val); - let data: Vec = (0.. 1024 * 1024).map(|j| (j % 13) as u8 | val << 4).collect(); + let data: Vec = (0..1024 * 1024).map(|j| (j % 13) as u8 | val << 4).collect(); let data: &[u8] = &data[..]; received_data.truncate(1024 * 1024); assert_eq!(received_data.len(), data.len()); @@ -297,15 +298,23 @@ fn receiver_set() { let data: &[u8] = b"1234567"; tx0.send(data, vec![], vec![]).unwrap(); - let (received_id, mut received_data, _, _) = - rx_set.select().unwrap().into_iter().next().unwrap().unwrap(); + let (received_id, mut received_data, _, _) = rx_set.select() + .unwrap() + .into_iter() + .next() + .unwrap() + .unwrap(); received_data.truncate(7); assert_eq!(received_id, rx0_id); assert_eq!(received_data, data); tx1.send(data, vec![], vec![]).unwrap(); - let (received_id, mut received_data, _, _) = - rx_set.select().unwrap().into_iter().next().unwrap().unwrap(); + let (received_id, mut received_data, _, _) = rx_set.select() + .unwrap() + .into_iter() + .next() + .unwrap() + .unwrap(); received_data.truncate(7); assert_eq!(received_id, rx1_id); assert_eq!(received_data, data); @@ -331,7 +340,7 @@ fn receiver_set() { } #[test] -//XXXjdm This hangs indefinitely on appveyor and warrants further investigation. +// XXXjdm This hangs indefinitely on appveyor and warrants further investigation. #[cfg(not(windows))] fn server() { let (server, name) = OsIpcOneShotServer::new().unwrap(); @@ -342,8 +351,8 @@ fn server() { tx.send(data, vec![], vec![]).unwrap(); }); - let (_, mut received_data, received_channels, received_shared_memory_regions) = - server.accept().unwrap(); + let (_, mut received_data, received_channels, received_shared_memory_regions) = server.accept() + .unwrap(); received_data.truncate(7); assert_eq!((&received_data[..], received_channels, received_shared_memory_regions), (data, vec![], vec![])); @@ -356,14 +365,16 @@ fn cross_process() { let (server, name) = OsIpcOneShotServer::new().unwrap(); let data: &[u8] = b"1234567"; - let child_pid = unsafe { fork(|| { - let tx = OsIpcSender::connect(name).unwrap(); - tx.send(data, vec![], vec![]).unwrap(); - libc::exit(0); - })}; + let child_pid = unsafe { + fork(|| { + let tx = OsIpcSender::connect(name).unwrap(); + tx.send(data, vec![], vec![]).unwrap(); + libc::exit(0); + }) + }; - let (_, mut received_data, received_channels, received_shared_memory_regions) = - server.accept().unwrap(); + let (_, mut received_data, received_channels, received_shared_memory_regions) = server.accept() + .unwrap(); child_pid.wait(); received_data.truncate(7); assert_eq!((&received_data[..], received_channels, received_shared_memory_regions), @@ -376,16 +387,18 @@ fn cross_process() { fn cross_process_sender_transfer() { let (server, name) = OsIpcOneShotServer::new().unwrap(); - let child_pid = unsafe { fork(|| { - let super_tx = OsIpcSender::connect(name).unwrap(); - let (sub_tx, sub_rx) = platform::channel().unwrap(); - let data: &[u8] = b"foo"; - super_tx.send(data, vec![OsIpcChannel::Sender(sub_tx)], vec![]).unwrap(); - sub_rx.recv().unwrap(); - let data: &[u8] = b"bar"; - super_tx.send(data, vec![], vec![]).unwrap(); - libc::exit(0); - })}; + let child_pid = unsafe { + fork(|| { + let super_tx = OsIpcSender::connect(name).unwrap(); + let (sub_tx, sub_rx) = platform::channel().unwrap(); + let data: &[u8] = b"foo"; + super_tx.send(data, vec![OsIpcChannel::Sender(sub_tx)], vec![]).unwrap(); + sub_rx.recv().unwrap(); + let data: &[u8] = b"bar"; + super_tx.send(data, vec![], vec![]).unwrap(); + libc::exit(0); + }) + }; let (super_rx, _, mut received_channels, _) = server.accept().unwrap(); assert_eq!(received_channels.len(), 1); @@ -394,8 +407,8 @@ fn cross_process_sender_transfer() { sub_tx.send(data, vec![], vec![]).unwrap(); let data: &[u8] = b"bar"; - let (mut received_data, received_channels, received_shared_memory_regions) = - super_rx.recv().unwrap(); + let (mut received_data, received_channels, received_shared_memory_regions) = super_rx.recv() + .unwrap(); child_pid.wait(); received_data.truncate(3); assert_eq!((&received_data[..], received_channels, received_shared_memory_regions), @@ -450,7 +463,7 @@ fn try_recv_large() { assert!(rx.try_recv().is_err()); let thread = thread::spawn(move || { - let data: Vec = (0.. 1024 * 1024).map(|i| (i % 251) as u8).collect(); + let data: Vec = (0..1024 * 1024).map(|i| (i % 251) as u8).collect(); let data: &[u8] = &data[..]; tx.send(data, vec![], vec![]).unwrap(); }); @@ -463,7 +476,7 @@ fn try_recv_large() { thread.join().unwrap(); let (mut received_data, received_channels, received_shared_memory) = result.unwrap(); - let data: Vec = (0.. 1024 * 1024).map(|i| (i % 251) as u8).collect(); + let data: Vec = (0..1024 * 1024).map(|i| (i % 251) as u8).collect(); let data: &[u8] = &data[..]; received_data.truncate(1024 * 1024); assert_eq!((&received_data[..], received_channels, received_shared_memory), @@ -509,16 +522,20 @@ fn try_recv_large_delayed() { let (tx, rx) = platform::channel().unwrap(); assert!(rx.try_recv().is_err()); - let threads: Vec<_> = (0..num_senders).map(|i| { - let tx = tx.clone(); - let delay = delay.clone(); - thread::spawn(move || { - let data: Vec = (0..msg_size).map(|j| (j % 13) as u8 | i << 4).collect(); - let data: &[u8] = &data[..]; - delay(thread_delay); - tx.send(data, vec![], vec![]).unwrap(); - }) - }).collect(); + let threads: Vec<_> = (0..num_senders) + .map(|i| { + let tx = tx.clone(); + let delay = delay.clone(); + thread::spawn(move || { + let data: Vec = (0..msg_size) + .map(|j| (j % 13) as u8 | i << 4) + .collect(); + let data: &[u8] = &data[..]; + delay(thread_delay); + tx.send(data, vec![], vec![]).unwrap(); + }) + }) + .collect(); let mut received_vals: Vec = vec![]; for _ in 0..num_senders { diff --git a/router.rs b/router.rs index 63a23e7f8..3f0a1e03e 100644 --- a/router.rs +++ b/router.rs @@ -7,15 +7,14 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use ipc::OpaqueIpcReceiver; +use ipc::{self, IpcReceiver, IpcReceiverSet, IpcSelectionResult, IpcSender, OpaqueIpcMessage}; +use serde::{Deserialize, Serialize}; use std::collections::HashMap; use std::sync::Mutex; use std::sync::mpsc::{self, Receiver, Sender}; use std::thread; -use ipc::{self, IpcReceiver, IpcReceiverSet, IpcSelectionResult, IpcSender, OpaqueIpcMessage}; -use ipc::{OpaqueIpcReceiver}; -use serde::{Deserialize, Serialize}; - lazy_static! { pub static ref ROUTER: RouterProxy = RouterProxy::new(); } @@ -47,23 +46,21 @@ impl RouterProxy { pub fn route_ipc_receiver_to_mpsc_sender(&self, ipc_receiver: IpcReceiver, mpsc_sender: Sender) - where T: Deserialize + - Serialize + - Send + - 'static { - self.add_route(ipc_receiver.to_opaque(), Box::new(move |message| { - drop(mpsc_sender.send(message.to::().unwrap())) - })) + where T: Deserialize + Serialize + Send + 'static + { + self.add_route(ipc_receiver.to_opaque(), + Box::new(move |message| { + drop(mpsc_sender.send(message.to::().unwrap())) + })) } /// A convenience function to route an `IpcReceiver` to a `Receiver`: the most common /// use of a `Router`. - pub fn route_ipc_receiver_to_new_mpsc_receiver(&self, ipc_receiver: IpcReceiver) - -> Receiver - where T: Deserialize + - Serialize + - Send + - 'static { + pub fn route_ipc_receiver_to_new_mpsc_receiver(&self, + ipc_receiver: IpcReceiver) + -> Receiver + where T: Deserialize + Serialize + Send + 'static + { let (mpsc_sender, mpsc_receiver) = mpsc::channel(); self.route_ipc_receiver_to_mpsc_sender(ipc_receiver, mpsc_sender); mpsc_receiver @@ -79,7 +76,7 @@ struct Router { msg_receiver: Receiver, msg_wakeup_id: i64, ipc_receiver_set: IpcReceiverSet, - handlers: HashMap, + handlers: HashMap, } impl Router { @@ -129,4 +126,3 @@ enum RouterMsg { } pub type RouterHandler = Box; - diff --git a/test.rs b/test.rs index 97559d5a8..8be66f0a2 100644 --- a/test.rs +++ b/test.rs @@ -7,10 +7,10 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +use ipc::OpaqueIpcSender; use ipc::{self, IpcOneShotServer, IpcReceiver, IpcReceiverSet, IpcSender, IpcSharedMemory}; -use ipc::{OpaqueIpcSender}; -use router::ROUTER; use libc; +use router::ROUTER; use std::io::Error; use std::iter; use std::ptr; @@ -24,7 +24,10 @@ use std::thread; pub unsafe fn fork(child_func: F) -> libc::pid_t { match libc::fork() { -1 => panic!("Fork failed: {}", Error::last_os_error()), - 0 => { child_func(); unreachable!() }, + 0 => { + child_func(); + unreachable!() + } pid => pid, } } @@ -138,15 +141,23 @@ fn select() { age: 29, }; tx0.send(person.clone()).unwrap(); - let (received_id, received_data) = - rx_set.select().unwrap().into_iter().next().unwrap().unwrap(); + let (received_id, received_data) = rx_set.select() + .unwrap() + .into_iter() + .next() + .unwrap() + .unwrap(); let received_person: Person = received_data.to().unwrap(); assert_eq!(received_id, rx0_id); assert_eq!(received_person, person); tx1.send(person.clone()).unwrap(); - let (received_id, received_data) = - rx_set.select().unwrap().into_iter().next().unwrap().unwrap(); + let (received_id, received_data) = rx_set.select() + .unwrap() + .into_iter() + .next() + .unwrap() + .unwrap(); let received_person: Person = received_data.to().unwrap(); assert_eq!(received_id, rx1_id); assert_eq!(received_person, person); @@ -181,15 +192,17 @@ fn cross_process_embedded_senders() { }; let (server0, server0_name) = IpcOneShotServer::new().unwrap(); let (server2, server2_name) = IpcOneShotServer::new().unwrap(); - let child_pid = unsafe { fork(|| { - let (tx1, rx1): (IpcSender, IpcReceiver) = ipc::channel().unwrap(); - let tx0 = IpcSender::connect(server0_name).unwrap(); - tx0.send(tx1).unwrap(); - rx1.recv().unwrap(); - let tx2: IpcSender = IpcSender::connect(server2_name).unwrap(); - tx2.send(person.clone()).unwrap(); - libc::exit(0); - })}; + let child_pid = unsafe { + fork(|| { + let (tx1, rx1): (IpcSender, IpcReceiver) = ipc::channel().unwrap(); + let tx0 = IpcSender::connect(server0_name).unwrap(); + tx0.send(tx1).unwrap(); + rx1.recv().unwrap(); + let tx2: IpcSender = IpcSender::connect(server2_name).unwrap(); + tx2.send(person.clone()).unwrap(); + libc::exit(0); + }) + }; let (_, tx1): (_, IpcSender) = server0.accept().unwrap(); tx1.send(person.clone()).unwrap(); let (_, received_person): (_, Person) = server2.accept().unwrap(); @@ -207,9 +220,10 @@ fn router_simple() { tx.send(person.clone()).unwrap(); let (callback_fired_sender, callback_fired_receiver) = mpsc::channel::(); - ROUTER.add_route(rx.to_opaque(), Box::new(move |person| { - callback_fired_sender.send(person.to().unwrap()).unwrap() - })); + ROUTER.add_route(rx.to_opaque(), + Box::new(move |person| { + callback_fired_sender.send(person.to().unwrap()).unwrap() + })); let received_person = callback_fired_receiver.recv().unwrap(); assert_eq!(received_person, person); } @@ -283,9 +297,7 @@ fn router_drops_callbacks_on_sender_shutdown() { let (tx0, rx0) = ipc::channel::<()>().unwrap(); let (drop_tx, drop_rx) = mpsc::channel(); - let dropper = Dropper { - sender: drop_tx, - }; + let dropper = Dropper { sender: drop_tx }; ROUTER.add_route(rx0.to_opaque(), Box::new(move |_| drop(&dropper))); drop(tx0); @@ -306,9 +318,7 @@ fn router_drops_callbacks_on_cloned_sender_shutdown() { let (tx0, rx0) = ipc::channel::<()>().unwrap(); let (drop_tx, drop_rx) = mpsc::channel(); - let dropper = Dropper { - sender: drop_tx, - }; + let dropper = Dropper { sender: drop_tx }; ROUTER.add_route(rx0.to_opaque(), Box::new(move |_| drop(&dropper))); let txs = vec![tx0.clone(), tx0.clone(), tx0.clone()]; @@ -331,9 +341,10 @@ fn router_big_data() { }); let (callback_fired_sender, callback_fired_receiver) = mpsc::channel::>(); - ROUTER.add_route(rx.to_opaque(), Box::new(move |people| { - callback_fired_sender.send(people.to().unwrap()).unwrap() - })); + ROUTER.add_route(rx.to_opaque(), + Box::new(move |people| { + callback_fired_sender.send(people.to().unwrap()).unwrap() + })); let received_people = callback_fired_receiver.recv().unwrap(); assert_eq!(received_people, people); thread.join().unwrap(); @@ -416,11 +427,9 @@ fn multiple_paths_to_a_sender() { person: person.clone(), sender: sub_tx, }); - let send_data = vec![ - person_and_sender.clone(), - person_and_sender.clone(), - person_and_sender.clone() - ]; + let send_data = vec![person_and_sender.clone(), + person_and_sender.clone(), + person_and_sender.clone()]; let (super_tx, super_rx) = ipc::channel().unwrap(); super_tx.send(send_data).unwrap(); let received_data = super_rx.recv().unwrap(); @@ -463,7 +472,9 @@ fn test_so_linger() { drop(sender); let val = match receiver.recv() { Ok(val) => val, - Err(e) => { panic!("err: `{}`", e); } + Err(e) => { + panic!("err: `{}`", e); + } }; assert_eq!(val, 42); }