API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jan 21st, 2017
78
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Rust 9.44 KB | None | 0 0
raw download clone embed print report
  1. pub mod exception;
  2. use self::exception::*;
  3.  
  4. #[allow(non_camel_case_types)]
  5. pub type cell = i32;
  6. #[allow(non_camel_case_types)]
  7. pub type ucell = u32;
  8.  
  9. /*
  10. ucell
  11. 16 => type $name = ::std::os::raw::c_ushort,
  12. 32 => type $name = ::std::os::raw::c_uint,
  13. 64 => type $name = ::std::os::raw::c_ulong,
  14.  
  15. cell
  16. 16 => type $name = ::std::os::raw::c_short,
  17. 32 => type $name = ::std::os::raw::c_int,
  18. 64 => type $name = ::std::os::raw::c_long,
  19. */
  20.  
  21. #[repr(C)]
  22. #[allow(non_camel_case_types)]
  23. pub enum AmxData
  24. {
  25.     USERNUM = 4,
  26.     EXPMAX = 19,
  27.     NAMEMAX = 31,
  28.     MAGIC = 0xF1E0,
  29.     EXEC_MAIN = -1,
  30.     EXEC_CONT = -2,
  31. }
  32.  
  33. #[repr(C)]
  34. pub struct Amx
  35. {
  36.     pub base: *mut u8,
  37.     pub data: *mut u8,
  38.     pub callback: AmxCallback_fn,
  39.     pub dbg: AmxDebug_fn,
  40.     pub cip: cell,
  41.     pub frm: cell,
  42.     pub hea: cell,
  43.     pub hlw: cell,
  44.     pub stk: cell,
  45.     pub stp: cell,
  46.     pub flags: i32,
  47.     pub usertags: [i32; AmxData::USERNUM as usize],
  48.     pub userdata: [*mut ::std::os::raw::c_void; AmxData::USERNUM as usize],
  49.     pub error: i32,
  50.     pub paramcount: i32,
  51.     pub pri: cell,
  52.     pub alt: cell,
  53.     pub reset_stk: cell,
  54.     pub reset_hea: cell,
  55.     pub sysreq_d: cell,
  56. }
  57.  
  58. #[repr(C)]
  59. pub struct AmxNativeInfo
  60. {
  61.     pub name: *const ::std::os::raw::c_char, //WORK???
  62.     pub func: AmxNative_fn,
  63. }
  64.  
  65. #[repr(C)]
  66. pub struct AmxMemInfo
  67. {
  68.     pub codesize: i32,
  69.     pub datasize: i32,
  70.     pub stackheap: i32,
  71. }
  72.  
  73. #[repr(C)]
  74. pub struct AmxFuncStub
  75. {
  76.     pub address: ucell,
  77.     pub name: [::std::os::raw::c_char; AmxData::EXPMAX as usize + 0x1],
  78. }
  79.  
  80. #[repr(C)]
  81. pub struct AmxFuncStubNT
  82. {
  83.     pub address: ucell,
  84.     pub nameofs: i32,
  85. }
  86.  
  87. #[repr(C)]
  88. pub struct AmxHeader
  89. {
  90.     pub size: i32,
  91.     pub magic: u16,
  92.     pub file_version: ::std::os::raw::c_char,
  93.     pub amx_version: ::std::os::raw::c_char,
  94.     pub flags: i16,
  95.     pub defsize: i16,
  96.     pub cod: i32,
  97.     pub dat: i32,
  98.     pub hea: i32,
  99.     pub stp: i32,
  100.     pub cip: i32,
  101.     pub publics: i32,
  102.     pub natives: i32,
  103.     pub libraries: i32,
  104.     pub pubvars: i32,
  105.     pub tags: i32,
  106.     pub nametable: i32,
  107. }
  108.  
  109. #[repr(C)]
  110. pub struct AmxTagInfo
  111. {
  112.     pub name: &'static str,
  113.     pub id: cell,
  114. }
  115.  
  116. #[repr(C)]
  117. pub enum AmxFlags
  118. {
  119.     DEBUG = 0x02,
  120.     COMPACT = 0x04,
  121.     BYTEOPC = 0x08,
  122.     NOCHECKS = 0x10,
  123.     NTVREG = 0x1000,
  124.     JITC = 0x2000,
  125.     BROWSE = 0x4000,
  126.     RELOC = 8000
  127. }
  128.  
  129. #[allow(non_camel_case_types)]
  130. pub type AmxAlign16_fn      = extern "C" fn(*mut u16) -> *mut u16;
  131. #[allow(non_camel_case_types)]
  132. pub type AmxAlign32_fn      = extern "C" fn(*mut u32) -> *mut u32;
  133. #[allow(non_camel_case_types)]
  134. pub type AmxAlign64_fn      = extern "C" fn(*mut u64) -> *mut u64;
  135. #[allow(non_camel_case_types)]
  136. pub type AmxAllot_fn        = extern "C" fn(&Amx, i32, *mut cell, *mut *mut cell) -> AmxError;
  137. #[allow(non_camel_case_types)]
  138. pub type AmxCallback_fn     = extern "C" fn(&Amx, cell, *mut cell, *mut cell) -> AmxError;
  139. #[allow(non_camel_case_types)]
  140. pub type AmxDebug_fn        = extern "C" fn(&Amx ) -> i32;
  141. #[allow(non_camel_case_types)]
  142. pub type AmxNative_fn       = extern "C" fn(&Amx, *mut cell) -> cell;
  143. #[allow(non_camel_case_types)]
  144. pub type AmxCleanup_fn      = extern "C" fn(&Amx) -> AmxError;
  145. #[allow(non_camel_case_types)]
  146. pub type AmxClone_fn        = extern "C" fn(&Amx, &Amx, *mut ::std::os::raw::c_void) -> AmxError;
  147. #[allow(non_camel_case_types)]
  148. pub type AmxExec_fn         = extern "C" fn(&Amx, *mut cell, i32) -> AmxError;
  149. #[allow(non_camel_case_types)]
  150. pub type AmxFindNative_fn   = extern "C" fn(&Amx, *const ::std::os::raw::c_char, *mut i32) -> AmxError;
  151. #[allow(non_camel_case_types)]
  152. pub type AmxFindPublic_fn   = extern "C" fn(&Amx, *const ::std::os::raw::c_char, *mut i32) -> AmxError;
  153. #[allow(non_camel_case_types)]
  154. pub type AmxFindPubVar_fn   = extern "C" fn(&Amx, *const ::std::os::raw::c_char, *mut i32) -> AmxError;
  155. #[allow(non_camel_case_types)]
  156. pub type AmxFindTagId_fn    = extern "C" fn(&Amx, cell, *const char) -> AmxError; //char* that *const char??
  157. #[allow(non_camel_case_types)]
  158. pub type AmxFlags_fn        = extern "C" fn(&Amx, cell, *mut AmxFlags) -> AmxError;
  159. #[allow(non_camel_case_types)]
  160. pub type AmxGetAddr_fn      = extern "C" fn(&Amx, cell, *mut *mut cell) -> AmxError;
  161. #[allow(non_camel_case_types)]
  162. pub type AmxGetNative_fn    = extern "C" fn(&Amx, i32, *const char) -> AmxError; //char* that *const char??
  163. #[allow(non_camel_case_types)]
  164. pub type AmxGetPublic_fn    = extern "C" fn(&Amx, i32, *const char) -> AmxError; //char* that *const char??
  165. #[allow(non_camel_case_types)]
  166. pub type AmxGetPubVar_fn    = extern "C" fn(&Amx, i32, *const char, *mut cell) -> AmxError; //char* that *const char??
  167. #[allow(non_camel_case_types)]
  168. pub type AmxGetString_fn    = extern "C" fn(*const char, *const cell, i32, usize) -> AmxError; //char* that *const char?? const cell* need *const or *mut???
  169. #[allow(non_camel_case_types)]
  170. pub type AmxGetTag_fn       = extern "C" fn(&Amx, i32, *const char, *mut cell) -> AmxError; //char* that *const char??
  171. #[allow(non_camel_case_types)]
  172. pub type AmxGetUserData_fn  = extern "C" fn(&Amx, i32, *mut *mut ::std::os::raw::c_void) -> AmxError; //void** that *mut *mut?
  173. #[allow(non_camel_case_types)]
  174. pub type AmxInit_fn         = extern "C" fn(&Amx, *mut ::std::os::raw::c_void) -> AmxError; //void* that *mut?
  175. #[allow(non_camel_case_types)]
  176. pub type AmxInitJIT_fn      = extern "C" fn(&Amx, *mut ::std::os::raw::c_void, *mut ::std::os::raw::c_void) -> AmxError; //void* that *mut?
  177. #[allow(non_camel_case_types)]
  178. pub type AmxMemInfo_fn      = extern "C" fn(&Amx, *mut i32, *mut i32, *mut i32) -> AmxError;
  179. #[allow(non_camel_case_types)]
  180. pub type AmxNameLength_fn   = extern "C" fn(&Amx, *mut i32) -> AmxError;
  181. #[allow(non_camel_case_types)]
  182. pub type AmxNativeInfo_fn   = extern "C" fn(*const ::std::os::raw::c_char, AmxNative_fn) -> AmxError;
  183. #[allow(non_camel_case_types)]
  184. pub type AmxNumNatives_fn   = extern "C" fn(&Amx, *mut i32) -> AmxError;
  185. #[allow(non_camel_case_types)]
  186. pub type AmxNumPublics_fn   = extern "C" fn(&Amx, *mut i32) -> AmxError;
  187. #[allow(non_camel_case_types)]
  188. pub type AmxNumPubVars_fn   = extern "C" fn(&Amx, *mut i32) -> AmxError;
  189. #[allow(non_camel_case_types)]
  190. pub type AmxNumTags_fn      = extern "C" fn(&Amx, *mut i32) -> AmxError;
  191. #[allow(non_camel_case_types)]
  192. pub type AmxPush_fn         = extern "C" fn(&Amx, cell) -> AmxError;
  193. #[allow(non_camel_case_types)]
  194. pub type AmxPushArray_fn    = extern "C" fn(&Amx, *mut cell, *mut *mut cell, *const cell, i32) -> AmxError;
  195. #[allow(non_camel_case_types)]
  196. pub type AmxPushString_fn   = extern "C" fn(&Amx, *mut cell, *mut *mut cell, *const ::std::os::raw::c_char, i32, i32) -> AmxError;
  197. #[allow(non_camel_case_types)]
  198. pub type AmxRaiseError_fn   = extern "C" fn(&Amx, i32) -> AmxError;
  199. #[allow(non_camel_case_types)]
  200. pub type AmxRegister_fn     = extern "C" fn(&Amx, *const AmxNativeInfo, i32) -> AmxError;
  201. #[allow(non_camel_case_types)]
  202. pub type AmxRelease_fn      = extern "C" fn(&Amx, cell) -> AmxError;
  203. #[allow(non_camel_case_types)]
  204. pub type AmxSetCallback_fn  = extern "C" fn(&Amx, AmxCallback_fn) -> AmxError;
  205. #[allow(non_camel_case_types)]
  206. pub type AmxSetDebugHook_fn = extern "C" fn(&Amx, AmxDebug_fn) -> AmxError;
  207. #[allow(non_camel_case_types)]
  208. pub type AmxSetString_fn    = extern "C" fn(*mut cell, *const ::std::os::raw::c_char, i32, i32, usize) -> AmxError;
  209. #[allow(non_camel_case_types)]
  210. pub type AmxSetUserData_fn  = extern "C" fn(&Amx, i32, *mut ::std::os::raw::c_void) -> AmxError;
  211. #[allow(non_camel_case_types)]
  212. pub type AmxStrLen_fn       = extern "C" fn(*const cell, *mut i32) -> AmxError;
  213. #[allow(non_camel_case_types)]
  214. pub type AmxUTF8Check_fn    = extern "C" fn(*const ::std::os::raw::c_char, *mut i32) -> AmxError;
  215. #[allow(non_camel_case_types)]
  216. pub type AmxUTF8Get_fn      = extern "C" fn(*const ::std::os::raw::c_char, *const *const ::std::os::raw::c_char, *mut cell) -> AmxError; //char** that *const *const char?
  217. #[allow(non_camel_case_types)]
  218. pub type AmxUTF8Len_fn      = extern "C" fn(*const cell, *mut i32) -> AmxError;
  219. #[allow(non_camel_case_types)]
  220. pub type AmxUTF8Put_fn      = extern "C" fn(*const ::std::os::raw::c_char, *const *const ::std::os::raw::c_char, i32, cell) -> AmxError; //char* that *const char? char** that *const *const char?
  221.  
  222. #[repr(C)]
  223. #[allow(dead_code, non_snake_case)]
  224. pub struct AmxFunctions
  225. {
  226.     pub Align16:        AmxAlign16_fn,
  227.     pub Align32:        AmxAlign32_fn,
  228.     pub Align64:        AmxAlign64_fn,
  229.     pub Allot:          AmxAllot_fn,
  230.     pub Callback:       AmxCallback_fn,
  231.     pub Cleanup:        AmxCleanup_fn,
  232.     pub Clone:          AmxClone_fn,
  233.     pub Exec:           AmxExec_fn,
  234.     pub FindNative:     AmxFindNative_fn,
  235.     pub FindPublic:     AmxFindPublic_fn,
  236.     pub FindPubVar:     AmxFindPubVar_fn,
  237.     pub FindTagId:      AmxFindTagId_fn,
  238.     pub Flags:          AmxFlags_fn,
  239.     pub GetAddr:        AmxGetAddr_fn,
  240.     pub GetNative:      AmxGetNative_fn,
  241.     pub GetPublic:      AmxGetPublic_fn,
  242.     pub GetPubVar:      AmxGetPubVar_fn,
  243.     pub GetString:      AmxGetString_fn,
  244.     pub GetTag:         AmxGetTag_fn,
  245.     pub GetUserData:    AmxGetUserData_fn,
  246.     pub Init:           AmxInit_fn,
  247.     pub InitJIT:        AmxInitJIT_fn,
  248.     pub MemInfo:        AmxMemInfo_fn,
  249.     pub NameLength:     AmxNameLength_fn,
  250.     pub NativeInfo:     AmxNativeInfo_fn,
  251.     pub NumNatives:     AmxNumNatives_fn,
  252.     pub NumPublics:     AmxNumPublics_fn,
  253.     pub NumPubVars:     AmxNumPubVars_fn,
  254.     pub NumTags:        AmxNumTags_fn,
  255.     pub Push:           AmxPush_fn,
  256.     pub PushArray:      AmxPushArray_fn,
  257.     pub PushString:     AmxPushString_fn,
  258.     pub RaiseError:     AmxRaiseError_fn,
  259.     pub Register:       AmxRegister_fn,
  260.     pub Release:        AmxRelease_fn,
  261.     pub SetCallback:    AmxSetCallback_fn,
  262.     pub SetDebugHook:   AmxSetDebugHook_fn,
  263.     pub SetString:      AmxSetString_fn,
  264.     pub SetUserData:    AmxSetUserData_fn,
  265.     pub StrLen:         AmxStrLen_fn,
  266.     pub UTF8Check:      AmxUTF8Check_fn,
  267.     pub UTF8Get:        AmxUTF8Get_fn,
  268.     pub UTF8Len:        AmxUTF8Len_fn,
  269.     pub UTF8Put:        AmxUTF8Put_fn,
  270. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!