cord-nvim 2.0.0-beta.34

🚀 The most extensible Discord Rich Presence plugin for Neovim, powered by Rust.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

#![allow(clippy::upper_case_acronyms)]

#[cfg(target_os = "windows")]
mod windows {
    pub type HANDLE = *mut std::ffi::c_void;
    pub type DWORD = u32;
    pub type BOOL = i32;
    pub type LPCWSTR = *const u16;
    pub type LPVOID = *mut std::ffi::c_void;

    pub const GENERIC_READ: DWORD = 0x80000000;
    pub const GENERIC_WRITE: DWORD = 0x40000000;
    pub const OPEN_EXISTING: DWORD = 3;
    pub const INVALID_HANDLE_VALUE: HANDLE = -1isize as HANDLE;
    pub const ERROR_PIPE_CONNECTED: DWORD = 535;
    pub const ERROR_IO_PENDING: DWORD = 997;
    pub const PIPE_ACCESS_DUPLEX: DWORD = 0x00000003;
    pub const FILE_FLAG_OVERLAPPED: DWORD = 0x40000000;
    pub const PIPE_TYPE_MESSAGE: DWORD = 0x00000004;
    pub const PIPE_READMODE_MESSAGE: DWORD = 0x00000002;
    pub const PIPE_WAIT: DWORD = 0x00000000;
    pub const PIPE_UNLIMITED_INSTANCES: DWORD = 255;

    #[repr(C)]
    pub struct Overlapped {
        pub internal: usize,
        pub internal_high: usize,
        pub offset: DWORD,
        pub offset_high: DWORD,
        pub h_event: HANDLE,
    }

    impl Default for Overlapped {
        fn default() -> Self {
            Self {
                internal: 0,
                internal_high: 0,
                offset: 0,
                offset_high: 0,
                h_event: unsafe {
                    CreateEventW(
                        std::ptr::null_mut(),
                        1,
                        0,
                        std::ptr::null_mut(),
                    )
                },
            }
        }
    }

    extern "system" {
        pub fn CreateFileW(
            lfFileName: LPCWSTR,
            dwDesiredAccess: DWORD,
            dwShareMode: DWORD,
            lpSecurityAttributes: LPVOID,
            dwCreationDisposition: DWORD,
            dwFlagsAndAttributes: DWORD,
            hTemplateFile: HANDLE,
        ) -> HANDLE;

        pub fn CreateNamedPipeW(
            lpName: LPCWSTR,
            dwOpenMode: DWORD,
            dwPipeMode: DWORD,
            nMaxInstances: DWORD,
            nOutBufferSize: DWORD,
            nInBufferSize: DWORD,
            nDefaultTimeOut: DWORD,
            lpSecurityAttributes: LPVOID,
        ) -> HANDLE;

        pub fn ConnectNamedPipe(
            hNamedPipe: HANDLE,
            lpOverlapped: *mut Overlapped,
        ) -> BOOL;

        pub fn GetLastError() -> DWORD;

        pub fn CloseHandle(hObject: HANDLE) -> BOOL;

        pub fn CreateEventW(
            lpEventAttributes: LPVOID,
            bManualReset: BOOL,
            bInitialState: BOOL,
            lpName: LPCWSTR,
        ) -> HANDLE;

        pub fn WriteFile(
            hFile: HANDLE,
            lpBuffer: *const u8,
            nNumberOfBytesToWrite: DWORD,
            lpNumberOfBytesWritten: *mut DWORD,
            lpOverlapped: *mut Overlapped,
        ) -> BOOL;

        pub fn ReadFile(
            hFile: HANDLE,
            lpBuffer: *mut u8,
            nNumberOfBytesToRead: DWORD,
            lpNumberOfBytesRead: *mut DWORD,
            lpOverlapped: *mut Overlapped,
        ) -> BOOL;

        pub fn GetOverlappedResult(
            hFile: HANDLE,
            lpOverlapped: *mut Overlapped,
            lpNumberOfBytesTransferred: *mut DWORD,
            bWait: BOOL,
        ) -> BOOL;
    }
}

#[cfg(target_os = "windows")]
pub use windows::*;