Permalink
Cannot retrieve contributors at this time
Join GitHub today
GitHub is home to over 31 million developers working together to host and review code, manage projects, and build software together.
Sign up
Fetching contributors…
Cannot retrieve contributors at this time
| // Copyright © 2015-2017 winapi-rs developers | |
| // Licensed under the Apache License, Version 2.0 | |
| // <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license | |
| // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option. | |
| // All files in the project carrying such notice may not be copied, modified, or distributed | |
| // except according to those terms. | |
| //! Macros to make things easier to define | |
| macro_rules! DECLARE_HANDLE { | |
| ($name:ident, $inner:ident) => { | |
| pub enum $inner {} | |
| pub type $name = *mut $inner; | |
| }; | |
| } | |
| macro_rules! MAKE_HRESULT { | |
| ($sev:expr, $fac:expr, $code:expr) => { | |
| ($sev << 31) | ($fac << 16) | $code | |
| } | |
| } | |
| macro_rules! MAKE_SCODE { | |
| ($sev:expr, $fac:expr, $code:expr) => { | |
| ($sev << 31) | ($fac << 16) | $code | |
| } | |
| } | |
| macro_rules! HIDP_ERROR_CODES { | |
| ($sev:expr, $code:expr) => { | |
| ($sev << 28) | (FACILITY_HID_ERROR_CODE << 16) | $code | |
| } | |
| } | |
| macro_rules! MAKEFOURCC { | |
| ($a:expr, $b:expr, $c:expr, $d:expr) => { | |
| ($a as u32) | (($b as u32) << 8) | (($c as u32) << 16) | (($d as u32) << 24) | |
| } | |
| } | |
| #[macro_export] | |
| macro_rules! DEFINE_GUID { | |
| ( | |
| $name:ident, $l:expr, $w1:expr, $w2:expr, | |
| $b1:expr, $b2:expr, $b3:expr, $b4:expr, $b5:expr, $b6:expr, $b7:expr, $b8:expr | |
| ) => { | |
| pub const $name: $crate::shared::guiddef::GUID = $crate::shared::guiddef::GUID { | |
| Data1: $l, | |
| Data2: $w1, | |
| Data3: $w2, | |
| Data4: [$b1, $b2, $b3, $b4, $b5, $b6, $b7, $b8], | |
| }; | |
| } | |
| } | |
| #[macro_export] | |
| macro_rules! DEFINE_PROPERTYKEY { | |
| ( | |
| $name:ident, $l:expr, $w1:expr, $w2:expr, | |
| $b1:expr, $b2:expr, $b3:expr, $b4:expr, $b5:expr, $b6:expr, $b7:expr, $b8:expr, | |
| $pid:expr | |
| ) => { | |
| pub const $name: $crate::shared::wtypes::PROPERTYKEY | |
| = $crate::shared::wtypes::PROPERTYKEY { | |
| fmtid: $crate::shared::guiddef::GUID { | |
| Data1: $l, | |
| Data2: $w1, | |
| Data3: $w2, | |
| Data4: [$b1, $b2, $b3, $b4, $b5, $b6, $b7, $b8], | |
| }, | |
| pid: $pid, | |
| }; | |
| } | |
| } | |
| #[macro_export] | |
| macro_rules! DEFINE_DEVPROPKEY { | |
| ( | |
| $name:ident, $l:expr, $w1:expr, $w2:expr, | |
| $b1:expr, $b2:expr, $b3:expr, $b4:expr, $b5:expr, $b6:expr, $b7:expr, $b8:expr, | |
| $pid:expr | |
| ) => { | |
| pub const $name: DEVPROPKEY = DEVPROPKEY { | |
| fmtid: $crate::shared::guiddef::GUID { | |
| Data1: $l, | |
| Data2: $w1, | |
| Data3: $w2, | |
| Data4: [$b1, $b2, $b3, $b4, $b5, $b6, $b7, $b8], | |
| }, | |
| pid: $pid, | |
| }; | |
| } | |
| } | |
| macro_rules! CTL_CODE { | |
| ($DeviceType:expr, $Function:expr, $Method:expr, $Access:expr) => { | |
| ($DeviceType << 16) | ($Access << 14) | ($Function << 2) | $Method | |
| } | |
| } | |
| macro_rules! HID_CTL_CODE { | |
| ($id:expr) => { | |
| CTL_CODE!(FILE_DEVICE_KEYBOARD, $id, METHOD_NEITHER, FILE_ANY_ACCESS) | |
| } | |
| } | |
| macro_rules! HID_BUFFER_CTL_CODE { | |
| ($id:expr) => { | |
| CTL_CODE!(FILE_DEVICE_KEYBOARD, $id, METHOD_BUFFERED, FILE_ANY_ACCESS) | |
| } | |
| } | |
| macro_rules! HID_IN_CTL_CODE { | |
| ($id:expr) => { | |
| CTL_CODE!(FILE_DEVICE_KEYBOARD, $id, METHOD_IN_DIRECT, FILE_ANY_ACCESS) | |
| } | |
| } | |
| macro_rules! HID_OUT_CTL_CODE { | |
| ($id:expr) => { | |
| CTL_CODE!(FILE_DEVICE_KEYBOARD, $id, METHOD_OUT_DIRECT, FILE_ANY_ACCESS) | |
| } | |
| } | |
| macro_rules! AUDCLNT_ERR { | |
| ($n:expr) => { | |
| MAKE_HRESULT!(SEVERITY_ERROR, FACILITY_AUDCLNT, $n) | |
| }; | |
| } | |
| macro_rules! AUDCLNT_SUCCESS { | |
| ($n:expr) => { | |
| MAKE_SCODE!(SEVERITY_SUCCESS, FACILITY_AUDCLNT, $n) | |
| }; | |
| } | |
| macro_rules! BCRYPT_MAKE_INTERFACE_VERSION { | |
| ($major:expr, $minor:expr) => { | |
| $crate::shared::bcrypt::BCRYPT_INTERFACE_VERSION { | |
| MajorVersion: $major, MinorVersion: $minor, | |
| } | |
| } | |
| } | |
| macro_rules! MAKEINTRESOURCE { | |
| ($i:expr) => { $i as u16 as usize as LPWSTR } | |
| } | |
| #[macro_export] | |
| macro_rules! RIDL { | |
| (#[uuid($($uuid:expr),+)] | |
| interface $interface:ident ($vtbl:ident) {$( | |
| $(#[$($attrs:tt)*])* fn $method:ident($($p:ident : $t:ty,)*) -> $rtr:ty, | |
| )+}) => ( | |
| RIDL!{@vtbl $interface $vtbl () $( | |
| $(#[$($attrs)*])* fn $method($($p: $t,)*) -> $rtr, | |
| )+} | |
| #[repr(C)] | |
| pub struct $interface { | |
| pub lpVtbl: *const $vtbl, | |
| } | |
| impl $interface { | |
| $(RIDL!{@method $(#[$($attrs)*])* fn $method($($p: $t,)*) -> $rtr})+ | |
| } | |
| RIDL!{@uuid $interface $($uuid),+} | |
| ); | |
| (#[uuid($($uuid:expr),+)] | |
| interface $interface:ident ($vtbl:ident) : $pinterface:ident ($pvtbl:ident) { | |
| }) => ( | |
| RIDL!{@vtbl $interface $vtbl (pub parent: $pvtbl,)} | |
| #[repr(C)] | |
| pub struct $interface { | |
| pub lpVtbl: *const $vtbl, | |
| } | |
| RIDL!{@deref $interface $pinterface} | |
| RIDL!{@uuid $interface $($uuid),+} | |
| ); | |
| (#[uuid($($uuid:expr),+)] | |
| interface $interface:ident ($vtbl:ident) : $pinterface:ident ($pvtbl:ident) {$( | |
| $(#[$($attrs:tt)*])* fn $method:ident($($p:ident : $t:ty,)*) -> $rtr:ty, | |
| )+}) => ( | |
| RIDL!{@vtbl $interface $vtbl (pub parent: $pvtbl,) $( | |
| $(#[$($attrs)*])* fn $method($($p: $t,)*) -> $rtr, | |
| )+} | |
| #[repr(C)] | |
| pub struct $interface { | |
| pub lpVtbl: *const $vtbl, | |
| } | |
| impl $interface { | |
| $(RIDL!{@method $(#[$($attrs)*])* fn $method($($p: $t,)*) -> $rtr})+ | |
| } | |
| RIDL!{@deref $interface $pinterface} | |
| RIDL!{@uuid $interface $($uuid),+} | |
| ); | |
| (@deref $interface:ident $pinterface:ident) => ( | |
| impl $crate::_core::ops::Deref for $interface { | |
| type Target = $pinterface; | |
| #[inline] | |
| fn deref(&self) -> &$pinterface { | |
| unsafe { &*(self as *const $interface as *const $pinterface) } | |
| } | |
| } | |
| ); | |
| (@method fn $method:ident($($p:ident : $t:ty,)*) -> $rtr:ty) => ( | |
| #[inline] pub unsafe fn $method(&self, $($p: $t,)*) -> $rtr { | |
| ((*self.lpVtbl).$method)(self as *const _ as *mut _, $($p,)*) | |
| } | |
| ); | |
| (@method #[fixme] fn $method:ident($($p:ident : $t:ty,)*) -> $rtr:ty) => ( | |
| #[inline] pub unsafe fn $method(&self, $($p: $t,)*) -> $rtr { | |
| let mut ret = $crate::_core::mem::uninitialized(); | |
| ((*self.lpVtbl).$method)(self as *const _ as *mut _, &mut ret, $($p,)*); | |
| ret | |
| } | |
| ); | |
| (@vtbl $interface:ident $vtbl:ident ($($fields:tt)*) | |
| $(fn $method:ident($($p:ident : $t:ty,)*) -> $rtr:ty,)* | |
| ) => ( | |
| RIDL!{@item #[repr(C)] | |
| pub struct $vtbl { | |
| $($fields)* | |
| $(pub $method: unsafe extern "system" fn( | |
| This: *mut $interface, | |
| $($p: $t,)* | |
| ) -> $rtr,)* | |
| }} | |
| ); | |
| (@vtbl $interface:ident $vtbl:ident ($($fields:tt)*) | |
| fn $method:ident($($p:ident : $t:ty,)*) -> $rtr:ty, | |
| $($tail:tt)*) => ( | |
| RIDL!{@vtbl $interface $vtbl ( | |
| $($fields)* | |
| pub $method: unsafe extern "system" fn( | |
| This: *mut $interface, | |
| $($p: $t,)* | |
| ) -> $rtr, | |
| ) $($tail)*} | |
| ); | |
| (@vtbl $interface:ident $vtbl:ident ($($fields:tt)*) | |
| #[fixme] fn $method:ident($($p:ident : $t:ty,)*) -> $rtr:ty, | |
| $($tail:tt)*) => ( | |
| RIDL!{@vtbl $interface $vtbl ( | |
| $($fields)* | |
| pub $method: unsafe extern "system" fn( | |
| This: *mut $interface, | |
| ret: *mut $rtr, | |
| $($p: $t,)* | |
| ) -> *mut $rtr, | |
| ) $($tail)*} | |
| ); | |
| (@uuid $interface:ident | |
| $l:expr, $w1:expr, $w2:expr, | |
| $b1:expr, $b2:expr, $b3:expr, $b4:expr, $b5:expr, $b6:expr, $b7:expr, $b8:expr | |
| ) => ( | |
| impl $crate::Interface for $interface { | |
| #[inline] | |
| fn uuidof() -> $crate::shared::guiddef::GUID { | |
| $crate::shared::guiddef::GUID { | |
| Data1: $l, | |
| Data2: $w1, | |
| Data3: $w2, | |
| Data4: [$b1, $b2, $b3, $b4, $b5, $b6, $b7, $b8], | |
| } | |
| } | |
| } | |
| ); | |
| (@item $thing:item) => ($thing); | |
| } | |
| macro_rules! UNION { | |
| ($(#[$attrs:meta])* union $name:ident { | |
| [$stype:ty; $ssize:expr], | |
| $($variant:ident $variant_mut:ident: $ftype:ty,)+ | |
| }) => ( | |
| #[repr(C)] $(#[$attrs])* | |
| pub struct $name([$stype; $ssize]); | |
| impl Copy for $name {} | |
| impl Clone for $name { | |
| #[inline] | |
| fn clone(&self) -> $name { *self } | |
| } | |
| impl $name {$( | |
| #[inline] | |
| pub unsafe fn $variant(&self) -> &$ftype { | |
| &*(self as *const _ as *const $ftype) | |
| } | |
| #[inline] | |
| pub unsafe fn $variant_mut(&mut self) -> &mut $ftype { | |
| &mut *(self as *mut _ as *mut $ftype) | |
| } | |
| )+} | |
| ); | |
| ($(#[$attrs:meta])* union $name:ident { | |
| [$stype32:ty; $ssize32:expr] [$stype64:ty; $ssize64:expr], | |
| $($variant:ident $variant_mut:ident: $ftype:ty,)+ | |
| }) => ( | |
| #[repr(C)] $(#[$attrs])* #[cfg(target_arch = "x86")] | |
| pub struct $name([$stype32; $ssize32]); | |
| #[repr(C)] $(#[$attrs])* #[cfg(target_arch = "x86_64")] | |
| pub struct $name([$stype64; $ssize64]); | |
| impl Copy for $name {} | |
| impl Clone for $name { | |
| #[inline] | |
| fn clone(&self) -> $name { *self } | |
| } | |
| impl $name {$( | |
| #[inline] | |
| pub unsafe fn $variant(&self) -> &$ftype { | |
| &*(self as *const _ as *const $ftype) | |
| } | |
| #[inline] | |
| pub unsafe fn $variant_mut(&mut self) -> &mut $ftype { | |
| &mut *(self as *mut _ as *mut $ftype) | |
| } | |
| )+} | |
| ); | |
| } | |
| macro_rules! BITFIELD { | |
| ($base:ident $field:ident: $fieldtype:ty [ | |
| $($thing:ident $set_thing:ident[$r:expr],)+ | |
| ]) => { | |
| impl $base {$( | |
| #[inline] | |
| pub fn $thing(&self) -> $fieldtype { | |
| let size = $crate::core::mem::size_of::<$fieldtype>() * 8; | |
| self.$field << (size - $r.end) >> (size - $r.end + $r.start) | |
| } | |
| #[inline] | |
| pub fn $set_thing(&mut self, val: $fieldtype) { | |
| let mask = ((1 << ($r.end - $r.start)) - 1) << $r.start; | |
| self.$field &= !mask; | |
| self.$field |= (val << $r.start) & mask; | |
| } | |
| )+} | |
| } | |
| } | |
| #[macro_export] | |
| macro_rules! ENUM { | |
| {enum $name:ident { $($variant:ident = $value:expr,)+ }} => { | |
| pub type $name = u32; | |
| $(pub const $variant: $name = $value;)+ | |
| }; | |
| {enum $name:ident { $variant:ident = $value:expr, $($rest:tt)* }} => { | |
| pub type $name = u32; | |
| pub const $variant: $name = $value; | |
| ENUM!{@gen $name $variant, $($rest)*} | |
| }; | |
| {enum $name:ident { $variant:ident, $($rest:tt)* }} => { | |
| ENUM!{enum $name { $variant = 0, $($rest)* }} | |
| }; | |
| {@gen $name:ident $base:ident,} => {}; | |
| {@gen $name:ident $base:ident, $variant:ident = $value:expr, $($rest:tt)*} => { | |
| pub const $variant: $name = $value; | |
| ENUM!{@gen $name $variant, $($rest)*} | |
| }; | |
| {@gen $name:ident $base:ident, $variant:ident, $($rest:tt)*} => { | |
| pub const $variant: $name = $base + 1u32; | |
| ENUM!{@gen $name $variant, $($rest)*} | |
| }; | |
| } | |
| #[macro_export] | |
| macro_rules! STRUCT { | |
| ($(#[$attrs:meta])* struct $name:ident { | |
| $($field:ident: $ftype:ty,)+ | |
| }) => ( | |
| #[repr(C)] $(#[$attrs])* | |
| pub struct $name { | |
| $(pub $field: $ftype,)+ | |
| } | |
| impl Copy for $name {} | |
| impl Clone for $name { | |
| #[inline] | |
| fn clone(&self) -> $name { *self } | |
| } | |
| ); | |
| } | |
| macro_rules! IFDEF { | |
| ($($thing:item)*) => ($($thing)*) | |
| } | |
| macro_rules! FN { | |
| (stdcall $func:ident($($t:ty,)*) -> $ret:ty) => ( | |
| pub type $func = Option<unsafe extern "system" fn($($t,)*) -> $ret>; | |
| ); | |
| (stdcall $func:ident($($p:ident: $t:ty,)*) -> $ret:ty) => ( | |
| pub type $func = Option<unsafe extern "system" fn($($p: $t,)*) -> $ret>; | |
| ); | |
| (cdecl $func:ident($($t:ty,)*) -> $ret:ty) => ( | |
| pub type $func = Option<unsafe extern "C" fn($($t,)*) -> $ret>; | |
| ); | |
| (cdecl $func:ident($($p:ident: $t:ty,)*) -> $ret:ty) => ( | |
| pub type $func = Option<unsafe extern "C" fn($($p: $t,)*) -> $ret>; | |
| ); | |
| } |