Vendor things

third-party/vendor/fsevent-sys/src/core_foundation.rs

@@ -0,0 +1,230 @@
+#![allow(non_upper_case_globals, non_camel_case_types)]
+
+extern crate libc;
+
+use std::ffi::CString;
+use std::ptr;
+use std::str;
+
+pub type Boolean = ::std::os::raw::c_uchar;
+
+pub type CFRef = *mut ::std::os::raw::c_void;
+
+pub type CFIndex = ::std::os::raw::c_long;
+pub type CFTimeInterval = f64;
+pub type CFAbsoluteTime = CFTimeInterval;
+
+#[doc(hidden)]
+pub enum CFError {}
+
+pub type CFAllocatorRef = CFRef;
+pub type CFArrayRef = CFRef;
+pub type CFMutableArrayRef = CFRef;
+pub type CFURLRef = CFRef;
+pub type CFErrorRef = *mut CFError;
+pub type CFStringRef = CFRef;
+pub type CFRunLoopRef = CFRef;
+
+pub const NULL: CFRef = 0 as CFRef;
+pub const NULL_REF_PTR: *mut CFRef = 0 as *mut CFRef;
+
+pub type CFAllocatorRetainCallBack =
+    extern "C" fn(*const ::std::os::raw::c_void) -> *const ::std::os::raw::c_void;
+pub type CFAllocatorReleaseCallBack = extern "C" fn(*const ::std::os::raw::c_void);
+pub type CFAllocatorCopyDescriptionCallBack =
+    extern "C" fn(*const ::std::os::raw::c_void) -> *const CFStringRef;
+
+pub type CFURLPathStyle = CFIndex;
+
+pub const kCFAllocatorDefault: CFAllocatorRef = NULL;
+pub const kCFURLPOSIXPathStyle: CFURLPathStyle = 0;
+pub const kCFURLHFSPathStyle: CFURLPathStyle = 1;
+pub const kCFURLWindowsPathStyle: CFURLPathStyle = 2;
+
+pub const kCFStringEncodingUTF8: CFStringEncoding = 0x08000100;
+pub type CFStringEncoding = u32;
+
+pub const kCFCompareEqualTo: CFIndex = 0;
+pub type CFComparisonResult = CFIndex;
+
+// MacOS uses Case Insensitive path
+pub const kCFCompareCaseInsensitive: CFStringCompareFlags = 1;
+pub type CFStringCompareFlags = ::std::os::raw::c_ulong;
+
+pub type CFArrayRetainCallBack =
+    extern "C" fn(CFAllocatorRef, *const ::std::os::raw::c_void) -> *const ::std::os::raw::c_void;
+pub type CFArrayReleaseCallBack = extern "C" fn(CFAllocatorRef, *const ::std::os::raw::c_void);
+pub type CFArrayCopyDescriptionCallBack =
+    extern "C" fn(*const ::std::os::raw::c_void) -> CFStringRef;
+pub type CFArrayEqualCallBack =
+    extern "C" fn(*const ::std::os::raw::c_void, *const ::std::os::raw::c_void) -> Boolean;
+
+#[repr(C)]
+pub struct CFArrayCallBacks {
+    version: CFIndex,
+    retain: Option<CFArrayRetainCallBack>,
+    release: Option<CFArrayReleaseCallBack>,
+    cp: Option<CFArrayCopyDescriptionCallBack>,
+    equal: Option<CFArrayEqualCallBack>,
+}
+//impl Clone for CFArrayCallBacks { }
+
+#[link(name = "CoreFoundation", kind = "framework")]
+extern "C" {
+    pub static kCFTypeArrayCallBacks: CFArrayCallBacks;
+    pub static kCFRunLoopDefaultMode: CFStringRef;
+
+    pub fn CFRelease(res: CFRef);
+    pub fn CFShow(res: CFRef);
+    pub fn CFCopyDescription(cf: CFRef) -> CFStringRef;
+
+    pub fn CFRunLoopRun();
+    pub fn CFRunLoopStop(run_loop: CFRunLoopRef);
+    pub fn CFRunLoopGetCurrent() -> CFRunLoopRef;
+
+    pub fn CFArrayCreateMutable(
+        allocator: CFRef,
+        capacity: CFIndex,
+        callbacks: *const CFArrayCallBacks,
+    ) -> CFMutableArrayRef;
+    pub fn CFArrayInsertValueAtIndex(arr: CFMutableArrayRef, position: CFIndex, element: CFRef);
+    pub fn CFArrayAppendValue(aff: CFMutableArrayRef, element: CFRef);
+    pub fn CFArrayGetCount(arr: CFMutableArrayRef) -> CFIndex;
+    pub fn CFArrayGetValueAtIndex(arr: CFMutableArrayRef, index: CFIndex) -> CFRef;
+
+    pub fn CFURLCreateFileReferenceURL(
+        allocator: CFRef,
+        url: CFURLRef,
+        err: *mut CFErrorRef,
+    ) -> CFURLRef;
+    pub fn CFURLCreateFilePathURL(
+        allocator: CFRef,
+        url: CFURLRef,
+        err: *mut CFErrorRef,
+    ) -> CFURLRef;
+    pub fn CFURLCreateFromFileSystemRepresentation(
+        allocator: CFRef,
+        path: *const ::std::os::raw::c_char,
+        len: CFIndex,
+        is_directory: bool,
+    ) -> CFURLRef;
+    pub fn CFURLCopyAbsoluteURL(res: CFURLRef) -> CFURLRef;
+    pub fn CFURLCopyLastPathComponent(res: CFURLRef) -> CFStringRef;
+    pub fn CFURLCreateCopyDeletingLastPathComponent(allocator: CFRef, url: CFURLRef) -> CFURLRef;
+    pub fn CFURLCreateCopyAppendingPathComponent(
+        allocation: CFRef,
+        url: CFURLRef,
+        path: CFStringRef,
+        is_directory: bool,
+    ) -> CFURLRef;
+    pub fn CFURLCopyFileSystemPath(anUrl: CFURLRef, path_style: CFURLPathStyle) -> CFStringRef;
+
+    pub fn CFURLResourceIsReachable(res: CFURLRef, err: *mut CFErrorRef) -> bool;
+
+    pub fn CFShowStr(str: CFStringRef);
+    pub fn CFStringGetCString(
+        theString: CFStringRef,
+        buffer: *mut ::std::os::raw::c_char,
+        buffer_size: CFIndex,
+        encoding: CFStringEncoding,
+    ) -> bool;
+    pub fn CFStringGetCStringPtr(
+        theString: CFStringRef,
+        encoding: CFStringEncoding,
+    ) -> *const ::std::os::raw::c_char;
+    pub fn CFStringCreateWithCString(
+        alloc: CFRef,
+        source: *const ::std::os::raw::c_char,
+        encoding: CFStringEncoding,
+    ) -> CFStringRef;
+
+    pub fn CFStringCompare(
+        theString1: CFStringRef,
+        theString2: CFStringRef,
+        compareOptions: CFStringCompareFlags,
+    ) -> CFComparisonResult;
+    pub fn CFArrayRemoveValueAtIndex(theArray: CFMutableArrayRef, idx: CFIndex);
+}
+
+pub unsafe fn str_path_to_cfstring_ref(source: &str, err: &mut CFErrorRef) -> CFStringRef {
+    let c_path = CString::new(source).unwrap();
+    let c_len = libc::strlen(c_path.as_ptr());
+    let mut url = CFURLCreateFromFileSystemRepresentation(
+        kCFAllocatorDefault,
+        c_path.as_ptr(),
+        c_len as CFIndex,
+        false,
+    );
+    if url.is_null() {
+        return ptr::null_mut();
+    }
+
+    let mut placeholder = CFURLCopyAbsoluteURL(url);
+    CFRelease(url);
+    if placeholder.is_null() {
+        return ptr::null_mut();
+    }
+
+    let mut imaginary: CFRef = ptr::null_mut();
+
+    while !CFURLResourceIsReachable(placeholder, ptr::null_mut()) {
+        if imaginary.is_null() {
+            imaginary = CFArrayCreateMutable(kCFAllocatorDefault, 0, &kCFTypeArrayCallBacks);
+            if imaginary.is_null() {
+                CFRelease(placeholder);
+                return ptr::null_mut();
+            }
+        }
+
+        let child = CFURLCopyLastPathComponent(placeholder);
+        CFArrayInsertValueAtIndex(imaginary, 0, child);
+        CFRelease(child);
+
+        url = CFURLCreateCopyDeletingLastPathComponent(kCFAllocatorDefault, placeholder);
+        CFRelease(placeholder);
+        placeholder = url;
+    }
+
+    url = CFURLCreateFileReferenceURL(kCFAllocatorDefault, placeholder, err);
+    CFRelease(placeholder);
+    if url.is_null() {
+        if !imaginary.is_null() {
+            CFRelease(imaginary);
+        }
+        return ptr::null_mut();
+    }
+
+    placeholder = CFURLCreateFilePathURL(kCFAllocatorDefault, url, err);
+    CFRelease(url);
+    if placeholder.is_null() {
+        if !imaginary.is_null() {
+            CFRelease(imaginary);
+        }
+        return ptr::null_mut();
+    }
+
+    if !imaginary.is_null() {
+        let mut count = 0;
+        while count < CFArrayGetCount(imaginary) {
+            let component = CFArrayGetValueAtIndex(imaginary, count);
+            url = CFURLCreateCopyAppendingPathComponent(
+                kCFAllocatorDefault,
+                placeholder,
+                component,
+                false,
+            );
+            CFRelease(placeholder);
+            if url.is_null() {
+                CFRelease(imaginary);
+                return ptr::null_mut();
+            }
+            placeholder = url;
+            count += 1;
+        }
+        CFRelease(imaginary);
+    }
+
+    let cf_path = CFURLCopyFileSystemPath(placeholder, kCFURLPOSIXPathStyle);
+    CFRelease(placeholder);
+    cf_path
+}

third-party/vendor/fsevent-sys/src/fsevent.rs

@@ -0,0 +1,135 @@
+#![allow(non_upper_case_globals, non_camel_case_types)]
+
+use crate::core_foundation::{
+    Boolean, CFAbsoluteTime, CFAllocatorCopyDescriptionCallBack, CFAllocatorRef,
+    CFAllocatorReleaseCallBack, CFAllocatorRetainCallBack, CFArrayRef, CFIndex, CFRunLoopRef,
+    CFStringRef, CFTimeInterval,
+};
+use libc::dev_t;
+use std::os::raw::{c_uint, c_void};
+
+pub type FSEventStreamRef = *mut c_void;
+pub type ConstFSEventStreamRef = *const c_void;
+
+pub type FSEventStreamCallback = extern "C" fn(
+    FSEventStreamRef,               // ConstFSEventStreamRef streamRef
+    *mut c_void,                    // void *clientCallBackInfo
+    usize,                          // size_t numEvents
+    *mut c_void,                    // void *eventPaths
+    *const FSEventStreamEventFlags, // const FSEventStreamEventFlags eventFlags[]
+    *const FSEventStreamEventId,    // const FSEventStreamEventId eventIds[]
+);
+
+pub type FSEventStreamEventId = u64;
+
+pub type FSEventStreamCreateFlags = c_uint;
+
+pub type FSEventStreamEventFlags = c_uint;
+
+pub const kFSEventStreamEventIdSinceNow: FSEventStreamEventId = 0xFFFFFFFFFFFFFFFF;
+
+pub const kFSEventStreamCreateFlagNone: FSEventStreamCreateFlags = 0x00000000;
+pub const kFSEventStreamCreateFlagUseCFTypes: FSEventStreamCreateFlags = 0x00000001;
+pub const kFSEventStreamCreateFlagNoDefer: FSEventStreamCreateFlags = 0x00000002;
+pub const kFSEventStreamCreateFlagWatchRoot: FSEventStreamCreateFlags = 0x00000004;
+pub const kFSEventStreamCreateFlagIgnoreSelf: FSEventStreamCreateFlags = 0x00000008;
+pub const kFSEventStreamCreateFlagFileEvents: FSEventStreamCreateFlags = 0x00000010;
+pub const kFSEventStreamCreateFlagMarkSelf: FSEventStreamCreateFlags = 0x00000020;
+pub const kFSEventStreamCreateFlagUseExtendedData: FSEventStreamCreateFlags = 0x00000040;
+pub const kFSEventStreamCreateFlagFullHistory: FSEventStreamCreateFlags = 0x00000080;
+
+pub const kFSEventStreamEventFlagNone: FSEventStreamEventFlags = 0x00000000;
+pub const kFSEventStreamEventFlagMustScanSubDirs: FSEventStreamEventFlags = 0x00000001;
+pub const kFSEventStreamEventFlagUserDropped: FSEventStreamEventFlags = 0x00000002;
+pub const kFSEventStreamEventFlagKernelDropped: FSEventStreamEventFlags = 0x00000004;
+pub const kFSEventStreamEventFlagEventIdsWrapped: FSEventStreamEventFlags = 0x00000008;
+pub const kFSEventStreamEventFlagHistoryDone: FSEventStreamEventFlags = 0x00000010;
+pub const kFSEventStreamEventFlagRootChanged: FSEventStreamEventFlags = 0x00000020;
+pub const kFSEventStreamEventFlagMount: FSEventStreamEventFlags = 0x00000040;
+pub const kFSEventStreamEventFlagUnmount: FSEventStreamEventFlags = 0x00000080;
+pub const kFSEventStreamEventFlagItemCreated: FSEventStreamEventFlags = 0x00000100;
+pub const kFSEventStreamEventFlagItemRemoved: FSEventStreamEventFlags = 0x00000200;
+pub const kFSEventStreamEventFlagItemInodeMetaMod: FSEventStreamEventFlags = 0x00000400;
+pub const kFSEventStreamEventFlagItemRenamed: FSEventStreamEventFlags = 0x00000800;
+pub const kFSEventStreamEventFlagItemModified: FSEventStreamEventFlags = 0x00001000;
+pub const kFSEventStreamEventFlagItemFinderInfoMod: FSEventStreamEventFlags = 0x00002000;
+pub const kFSEventStreamEventFlagItemChangeOwner: FSEventStreamEventFlags = 0x00004000;
+pub const kFSEventStreamEventFlagItemXattrMod: FSEventStreamEventFlags = 0x00008000;
+pub const kFSEventStreamEventFlagItemIsFile: FSEventStreamEventFlags = 0x00010000;
+pub const kFSEventStreamEventFlagItemIsDir: FSEventStreamEventFlags = 0x00020000;
+pub const kFSEventStreamEventFlagItemIsSymlink: FSEventStreamEventFlags = 0x00040000;
+pub const kFSEventStreamEventFlagOwnEvent: FSEventStreamEventFlags = 0x00080000;
+pub const kFSEventStreamEventFlagItemIsHardlink: FSEventStreamEventFlags = 0x00100000;
+pub const kFSEventStreamEventFlagItemIsLastHardlink: FSEventStreamEventFlags = 0x00200000;
+pub const kFSEventStreamEventFlagItemCloned: FSEventStreamEventFlags = 0x00400000;
+
+#[repr(C)]
+pub struct FSEventStreamContext {
+    pub version: CFIndex,
+    pub info: *mut c_void,
+    pub retain: Option<CFAllocatorRetainCallBack>,
+    pub release: Option<CFAllocatorReleaseCallBack>,
+    pub copy_description: Option<CFAllocatorCopyDescriptionCallBack>,
+}
+
+// https://developer.apple.com/documentation/coreservices/file_system_events
+#[link(name = "CoreServices", kind = "framework")]
+extern "C" {
+    pub fn FSEventStreamCopyDescription(stream_ref: ConstFSEventStreamRef) -> CFStringRef;
+    pub fn FSEventStreamCopyPathsBeingWatched(streamRef: ConstFSEventStreamRef) -> CFArrayRef;
+    pub fn FSEventStreamCreate(
+        allocator: CFAllocatorRef,
+        callback: FSEventStreamCallback,
+        context: *const FSEventStreamContext,
+        pathsToWatch: CFArrayRef,
+        sinceWhen: FSEventStreamEventId,
+        latency: CFTimeInterval,
+        flags: FSEventStreamCreateFlags,
+    ) -> FSEventStreamRef;
+    pub fn FSEventStreamCreateRelativeToDevice(
+        allocator: CFAllocatorRef,
+        callback: FSEventStreamCallback,
+        context: *const FSEventStreamContext,
+        deviceToWatch: dev_t,
+        pathsToWatchRelativeToDevice: CFArrayRef,
+        sinceWhen: FSEventStreamEventId,
+        latency: CFTimeInterval,
+        flags: FSEventStreamCreateFlags,
+    ) -> FSEventStreamRef;
+    pub fn FSEventStreamFlushAsync(stream_ref: FSEventStreamRef) -> FSEventStreamEventId;
+    pub fn FSEventStreamFlushSync(streamRef: FSEventStreamRef);
+    pub fn FSEventStreamGetDeviceBeingWatched(stream_ref: ConstFSEventStreamRef) -> dev_t;
+    pub fn FSEventStreamGetLatestEventId(stream_ref: ConstFSEventStreamRef)
+        -> FSEventStreamEventId;
+    pub fn FSEventStreamInvalidate(stream_ref: FSEventStreamRef);
+    pub fn FSEventStreamRelease(stream_ref: FSEventStreamRef);
+    pub fn FSEventStreamRetain(stream_ref: FSEventStreamRef);
+    pub fn FSEventStreamScheduleWithRunLoop(
+        stream_ref: FSEventStreamRef,
+        run_loop: CFRunLoopRef,
+        run_loop_mode: CFStringRef,
+    );
+    // pub fn FSEventStreamSetDispatchQueue(streamRef: FSEventStreamRef, q: DispatchQueue);
+    pub fn FSEventStreamSetExclusionPaths(
+        stream_ref: FSEventStreamRef,
+        paths_to_exclude: CFArrayRef,
+    ) -> Boolean;
+    pub fn FSEventStreamShow(stream_ref: FSEventStreamRef);
+    pub fn FSEventStreamStart(stream_ref: FSEventStreamRef) -> Boolean;
+    pub fn FSEventStreamStop(stream_ref: FSEventStreamRef);
+    pub fn FSEventStreamUnscheduleFromRunLoop(
+        stream_ref: FSEventStreamRef,
+        run_loop: CFRunLoopRef,
+        run_loop_mode: CFStringRef,
+    );
+    // pub fn FSEventsCopyUUIDForDevice(dev: dev_t) -> CFUUID;
+    pub fn FSEventsGetCurrentEventId() -> FSEventStreamEventId;
+    pub fn FSEventsGetLastEventIdForDeviceBeforeTime(
+        dev: dev_t,
+        time: CFAbsoluteTime,
+    ) -> FSEventStreamEventId;
+    pub fn FSEventsPurgeEventsForDeviceUpToEventId(
+        dev: dev_t,
+        eventId: FSEventStreamEventId,
+    ) -> Boolean;
+}

third-party/vendor/fsevent-sys/src/lib.rs

@@ -0,0 +1,7 @@
+#![cfg(target_os = "macos")]
+#![cfg_attr(feature = "cargo-clippy", allow(unreadable_literal))]
+
+pub mod core_foundation;
+mod fsevent;
+
+pub use fsevent::*;