1pub type intmax_t = ::std::os::raw::c_long;
4pub type uintmax_t = ::std::os::raw::c_ulong;
5pub type char16_t = u16;
6#[repr(C)]
7#[derive(Debug, Copy, Clone)]
8pub struct napi_env__ {
9 _unused: [u8; 0],
10}
11pub type napi_env = u64;
12#[repr(C)]
13#[derive(Debug, Copy, Clone)]
14pub struct napi_value__ {
15 _unused: [u8; 0],
16}
17pub type napi_value = u64;
18#[repr(C)]
19#[derive(Debug, Copy, Clone)]
20pub struct napi_ref__ {
21 _unused: [u8; 0],
22}
23pub type napi_ref = *mut napi_ref__;
24#[repr(C)]
25#[derive(Debug, Copy, Clone)]
26pub struct napi_handle_scope__ {
27 _unused: [u8; 0],
28}
29pub type napi_handle_scope = *mut napi_handle_scope__;
30#[repr(C)]
31#[derive(Debug, Copy, Clone)]
32pub struct napi_escapable_handle_scope__ {
33 _unused: [u8; 0],
34}
35pub type napi_escapable_handle_scope = *mut napi_escapable_handle_scope__;
36#[repr(C)]
37#[derive(Debug, Copy, Clone)]
38pub struct napi_callback_info__ {
39 _unused: [u8; 0],
40}
41pub type napi_callback_info = *mut napi_callback_info__;
42#[repr(C)]
43#[derive(Debug, Copy, Clone)]
44pub struct napi_async_work__ {
45 _unused: [u8; 0],
46}
47pub type napi_async_work = *mut napi_async_work__;
48#[repr(u32)]
49#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
50pub enum napi_property_attributes {
51 napi_default = 0,
52 napi_writable = 1,
53 napi_enumerable = 2,
54 napi_configurable = 4,
55 napi_static = 1024,
56}
57#[repr(u32)]
58#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
59pub enum napi_valuetype {
60 napi_undefined = 0,
61 napi_null = 1,
62 napi_boolean = 2,
63 napi_number = 3,
64 napi_string = 4,
65 napi_symbol = 5,
66 napi_object = 6,
67 napi_function = 7,
68 napi_external = 8,
69}
70#[repr(u32)]
71#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
72pub enum napi_typedarray_type {
73 napi_int8_array = 0,
74 napi_uint8_array = 1,
75 napi_uint8_clamped_array = 2,
76 napi_int16_array = 3,
77 napi_uint16_array = 4,
78 napi_int32_array = 5,
79 napi_uint32_array = 6,
80 napi_float32_array = 7,
81 napi_float64_array = 8,
82}
83#[repr(u32)]
84#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
85pub enum napi_status {
86 napi_ok = 0,
87 napi_invalid_arg = 1,
88 napi_object_expected = 2,
89 napi_string_expected = 3,
90 napi_name_expected = 4,
91 napi_function_expected = 5,
92 napi_number_expected = 6,
93 napi_boolean_expected = 7,
94 napi_array_expected = 8,
95 napi_generic_failure = 9,
96 napi_pending_exception = 10,
97 napi_cancelled = 11,
98 napi_status_last = 12,
99}
100pub type napi_callback =
101 ::std::option::Option<unsafe extern "C" fn(env: napi_env,
102 info: napi_callback_info)
103 -> napi_value>;
104pub type napi_finalize =
105 ::std::option::Option<unsafe extern "C" fn(env: napi_env,
106 finalize_data:
107 *mut ::std::os::raw::c_void,
108 finalize_hint:
109 *mut ::std::os::raw::c_void)>;
110pub type napi_async_execute_callback =
111 ::std::option::Option<unsafe extern "C" fn(env: napi_env,
112 data:
113 *mut ::std::os::raw::c_void)>;
114pub type napi_async_complete_callback =
115 ::std::option::Option<unsafe extern "C" fn(env: napi_env,
116 status: napi_status,
117 data:
118 *mut ::std::os::raw::c_void)>;
119#[repr(C)]
120#[derive(Debug, Copy)]
121pub struct napi_property_descriptor {
122 pub utf8name: *const ::std::os::raw::c_char,
123 pub name: napi_value,
124 pub method: napi_callback,
125 pub getter: napi_callback,
126 pub setter: napi_callback,
127 pub value: napi_value,
128 pub attributes: napi_property_attributes,
129 pub data: *mut ::std::os::raw::c_void,
130}
131#[test]
132fn bindgen_test_layout_napi_property_descriptor() {
133 assert_eq!(::std::mem::size_of::<napi_property_descriptor>() , 64usize ,
134 concat ! (
135 "Size of: " , stringify ! ( napi_property_descriptor ) ));
136 assert_eq! (::std::mem::align_of::<napi_property_descriptor>() , 8usize ,
137 concat ! (
138 "Alignment of " , stringify ! ( napi_property_descriptor ) ));
139 assert_eq! (unsafe {
140 & ( * ( 0 as * const napi_property_descriptor ) ) . utf8name
141 as * const _ as usize } , 0usize , concat ! (
142 "Alignment of field: " , stringify ! (
143 napi_property_descriptor ) , "::" , stringify ! ( utf8name )
144 ));
145 assert_eq! (unsafe {
146 & ( * ( 0 as * const napi_property_descriptor ) ) . name as *
147 const _ as usize } , 8usize , concat ! (
148 "Alignment of field: " , stringify ! (
149 napi_property_descriptor ) , "::" , stringify ! ( name ) ));
150 assert_eq! (unsafe {
151 & ( * ( 0 as * const napi_property_descriptor ) ) . method as
152 * const _ as usize } , 16usize , concat ! (
153 "Alignment of field: " , stringify ! (
154 napi_property_descriptor ) , "::" , stringify ! ( method ) ));
155 assert_eq! (unsafe {
156 & ( * ( 0 as * const napi_property_descriptor ) ) . getter as
157 * const _ as usize } , 24usize , concat ! (
158 "Alignment of field: " , stringify ! (
159 napi_property_descriptor ) , "::" , stringify ! ( getter ) ));
160 assert_eq! (unsafe {
161 & ( * ( 0 as * const napi_property_descriptor ) ) . setter as
162 * const _ as usize } , 32usize , concat ! (
163 "Alignment of field: " , stringify ! (
164 napi_property_descriptor ) , "::" , stringify ! ( setter ) ));
165 assert_eq! (unsafe {
166 & ( * ( 0 as * const napi_property_descriptor ) ) . value as *
167 const _ as usize } , 40usize , concat ! (
168 "Alignment of field: " , stringify ! (
169 napi_property_descriptor ) , "::" , stringify ! ( value ) ));
170 assert_eq! (unsafe {
171 & ( * ( 0 as * const napi_property_descriptor ) ) . attributes
172 as * const _ as usize } , 48usize , concat ! (
173 "Alignment of field: " , stringify ! (
174 napi_property_descriptor ) , "::" , stringify ! ( attributes )
175 ));
176 assert_eq! (unsafe {
177 & ( * ( 0 as * const napi_property_descriptor ) ) . data as *
178 const _ as usize } , 56usize , concat ! (
179 "Alignment of field: " , stringify ! (
180 napi_property_descriptor ) , "::" , stringify ! ( data ) ));
181}
182impl Clone for napi_property_descriptor {
183 fn clone(&self) -> Self { *self }
184}
185#[repr(C)]
186#[derive(Debug, Copy)]
187pub struct napi_extended_error_info {
188 pub error_message: *const ::std::os::raw::c_char,
189 pub engine_reserved: *mut ::std::os::raw::c_void,
190 pub engine_error_code: u32,
191 pub error_code: napi_status,
192}
193#[test]
194fn bindgen_test_layout_napi_extended_error_info() {
195 assert_eq!(::std::mem::size_of::<napi_extended_error_info>() , 24usize ,
196 concat ! (
197 "Size of: " , stringify ! ( napi_extended_error_info ) ));
198 assert_eq! (::std::mem::align_of::<napi_extended_error_info>() , 8usize ,
199 concat ! (
200 "Alignment of " , stringify ! ( napi_extended_error_info ) ));
201 assert_eq! (unsafe {
202 & ( * ( 0 as * const napi_extended_error_info ) ) .
203 error_message as * const _ as usize } , 0usize , concat ! (
204 "Alignment of field: " , stringify ! (
205 napi_extended_error_info ) , "::" , stringify ! (
206 error_message ) ));
207 assert_eq! (unsafe {
208 & ( * ( 0 as * const napi_extended_error_info ) ) .
209 engine_reserved as * const _ as usize } , 8usize , concat ! (
210 "Alignment of field: " , stringify ! (
211 napi_extended_error_info ) , "::" , stringify ! (
212 engine_reserved ) ));
213 assert_eq! (unsafe {
214 & ( * ( 0 as * const napi_extended_error_info ) ) .
215 engine_error_code as * const _ as usize } , 16usize , concat !
216 (
217 "Alignment of field: " , stringify ! (
218 napi_extended_error_info ) , "::" , stringify ! (
219 engine_error_code ) ));
220 assert_eq! (unsafe {
221 & ( * ( 0 as * const napi_extended_error_info ) ) . error_code
222 as * const _ as usize } , 20usize , concat ! (
223 "Alignment of field: " , stringify ! (
224 napi_extended_error_info ) , "::" , stringify ! ( error_code )
225 ));
226}
227impl Clone for napi_extended_error_info {
228 fn clone(&self) -> Self { *self }
229}
230pub type napi_addon_register_func =
231 ::std::option::Option<unsafe extern "C" fn(env: napi_env,
232 exports: napi_value,
233 module: napi_value,
234 priv_:
235 *mut ::std::os::raw::c_void)>;
236#[repr(C)]
237#[derive(Debug, Copy)]
238pub struct napi_module {
239 pub nm_version: ::std::os::raw::c_int,
240 pub nm_flags: ::std::os::raw::c_uint,
241 pub nm_filename: *const ::std::os::raw::c_char,
242 pub nm_register_func: napi_addon_register_func,
243 pub nm_modname: *const ::std::os::raw::c_char,
244 pub nm_priv: *mut ::std::os::raw::c_void,
245 pub reserved: [*mut ::std::os::raw::c_void; 4usize],
246}
247#[test]
248fn bindgen_test_layout_napi_module() {
249 assert_eq!(::std::mem::size_of::<napi_module>() , 72usize , concat ! (
250 "Size of: " , stringify ! ( napi_module ) ));
251 assert_eq! (::std::mem::align_of::<napi_module>() , 8usize , concat ! (
252 "Alignment of " , stringify ! ( napi_module ) ));
253 assert_eq! (unsafe {
254 & ( * ( 0 as * const napi_module ) ) . nm_version as * const _
255 as usize } , 0usize , concat ! (
256 "Alignment of field: " , stringify ! ( napi_module ) , "::" ,
257 stringify ! ( nm_version ) ));
258 assert_eq! (unsafe {
259 & ( * ( 0 as * const napi_module ) ) . nm_flags as * const _
260 as usize } , 4usize , concat ! (
261 "Alignment of field: " , stringify ! ( napi_module ) , "::" ,
262 stringify ! ( nm_flags ) ));
263 assert_eq! (unsafe {
264 & ( * ( 0 as * const napi_module ) ) . nm_filename as * const
265 _ as usize } , 8usize , concat ! (
266 "Alignment of field: " , stringify ! ( napi_module ) , "::" ,
267 stringify ! ( nm_filename ) ));
268 assert_eq! (unsafe {
269 & ( * ( 0 as * const napi_module ) ) . nm_register_func as *
270 const _ as usize } , 16usize , concat ! (
271 "Alignment of field: " , stringify ! ( napi_module ) , "::" ,
272 stringify ! ( nm_register_func ) ));
273 assert_eq! (unsafe {
274 & ( * ( 0 as * const napi_module ) ) . nm_modname as * const _
275 as usize } , 24usize , concat ! (
276 "Alignment of field: " , stringify ! ( napi_module ) , "::" ,
277 stringify ! ( nm_modname ) ));
278 assert_eq! (unsafe {
279 & ( * ( 0 as * const napi_module ) ) . nm_priv as * const _ as
280 usize } , 32usize , concat ! (
281 "Alignment of field: " , stringify ! ( napi_module ) , "::" ,
282 stringify ! ( nm_priv ) ));
283 assert_eq! (unsafe {
284 & ( * ( 0 as * const napi_module ) ) . reserved as * const _
285 as usize } , 40usize , concat ! (
286 "Alignment of field: " , stringify ! ( napi_module ) , "::" ,
287 stringify ! ( reserved ) ));
288}
289impl Clone for napi_module {
290 fn clone(&self) -> Self { *self }
291}
292
293extern "C" {
294 pub fn napi_module_register(mod_: *mut napi_module);
295}
296extern "C" {
297 pub fn napi_get_last_error_info(env: napi_env,
298 result:
299 *mut *const napi_extended_error_info)
300 -> napi_status;
301}
302extern "C" {
303 pub fn napi_get_undefined(env: napi_env, result: *mut napi_value)
304 -> napi_status;
305}
306extern "C" {
307 pub fn napi_get_null(env: napi_env, result: *mut napi_value)
308 -> napi_status;
309}
310extern "C" {
311 pub fn napi_get_global(env: napi_env, result: *mut napi_value)
312 -> napi_status;
313}
314extern "C" {
315 pub fn napi_get_boolean(env: napi_env, value: bool,
316 result: *mut napi_value) -> napi_status;
317}
318extern "C" {
319 pub fn napi_create_object(env: napi_env, result: *mut napi_value)
320 -> napi_status;
321}
322extern "C" {
323 pub fn napi_create_array(env: napi_env, result: *mut napi_value)
324 -> napi_status;
325}
326extern "C" {
327 pub fn napi_create_array_with_length(env: napi_env, length: usize,
328 result: *mut napi_value)
329 -> napi_status;
330}
331extern "C" {
332 pub fn napi_create_number(env: napi_env, value: f64,
333 result: *mut napi_value) -> napi_status;
334}
335extern "C" {
336 pub fn napi_create_string_latin1(env: napi_env,
337 str: *const ::std::os::raw::c_char,
338 length: usize, result: *mut napi_value)
339 -> napi_status;
340}
341extern "C" {
342 pub fn napi_create_string_utf8(env: napi_env,
343 str: *const ::std::os::raw::c_char,
344 length: usize, result: *mut napi_value)
345 -> napi_status;
346}
347extern "C" {
348 pub fn napi_create_string_utf16(env: napi_env, str: *const char16_t,
349 length: usize, result: *mut napi_value)
350 -> napi_status;
351}
352extern "C" {
353 pub fn napi_create_symbol(env: napi_env, description: napi_value,
354 result: *mut napi_value) -> napi_status;
355}
356extern "C" {
357 pub fn napi_create_function(env: napi_env,
358 utf8name: *const ::std::os::raw::c_char,
359 cb: napi_callback,
360 data: *mut ::std::os::raw::c_void,
361 result: *mut napi_value) -> napi_status;
362}
363extern "C" {
364 pub fn napi_create_error(env: napi_env, msg: napi_value,
365 result: *mut napi_value) -> napi_status;
366}
367extern "C" {
368 pub fn napi_create_type_error(env: napi_env, msg: napi_value,
369 result: *mut napi_value) -> napi_status;
370}
371extern "C" {
372 pub fn napi_create_range_error(env: napi_env, msg: napi_value,
373 result: *mut napi_value) -> napi_status;
374}
375extern "C" {
376 pub fn napi_typeof(env: napi_env, value: napi_value,
377 result: *mut napi_valuetype) -> napi_status;
378}
379extern "C" {
380 pub fn napi_get_value_double(env: napi_env, value: napi_value,
381 result: *mut f64) -> napi_status;
382}
383extern "C" {
384 pub fn napi_get_value_int32(env: napi_env, value: napi_value,
385 result: *mut i32) -> napi_status;
386}
387extern "C" {
388 pub fn napi_get_value_uint32(env: napi_env, value: napi_value,
389 result: *mut u32) -> napi_status;
390}
391extern "C" {
392 pub fn napi_get_value_int64(env: napi_env, value: napi_value,
393 result: *mut i64) -> napi_status;
394}
395extern "C" {
396 pub fn napi_get_value_bool(env: napi_env, value: napi_value,
397 result: *mut bool) -> napi_status;
398}
399extern "C" {
400 pub fn napi_get_value_string_latin1(env: napi_env, value: napi_value,
401 buf: *mut ::std::os::raw::c_char,
402 bufsize: usize, result: *mut usize)
403 -> napi_status;
404}
405extern "C" {
406 pub fn napi_get_value_string_utf8(env: napi_env, value: napi_value,
407 buf: *mut ::std::os::raw::c_char,
408 bufsize: usize, result: *mut usize)
409 -> napi_status;
410}
411extern "C" {
412 pub fn napi_get_value_string_utf16(env: napi_env, value: napi_value,
413 buf: *mut char16_t, bufsize: usize,
414 result: *mut usize) -> napi_status;
415}
416extern "C" {
417 pub fn napi_coerce_to_bool(env: napi_env, value: napi_value,
418 result: *mut napi_value) -> napi_status;
419}
420extern "C" {
421 pub fn napi_coerce_to_number(env: napi_env, value: napi_value,
422 result: *mut napi_value) -> napi_status;
423}
424extern "C" {
425 pub fn napi_coerce_to_object(env: napi_env, value: napi_value,
426 result: *mut napi_value) -> napi_status;
427}
428extern "C" {
429 pub fn napi_coerce_to_string(env: napi_env, value: napi_value,
430 result: *mut napi_value) -> napi_status;
431}
432extern "C" {
433 pub fn napi_get_prototype(env: napi_env, object: napi_value,
434 result: *mut napi_value) -> napi_status;
435}
436extern "C" {
437 pub fn napi_get_property_names(env: napi_env, object: napi_value,
438 result: *mut napi_value) -> napi_status;
439}
440extern "C" {
441 pub fn napi_set_property(env: napi_env, object: napi_value,
442 key: napi_value, value: napi_value)
443 -> napi_status;
444}
445extern "C" {
446 pub fn napi_has_property(env: napi_env, object: napi_value,
447 key: napi_value, result: *mut bool)
448 -> napi_status;
449}
450extern "C" {
451 pub fn napi_get_property(env: napi_env, object: napi_value,
452 key: napi_value, result: *mut napi_value)
453 -> napi_status;
454}
455extern "C" {
456 pub fn napi_set_named_property(env: napi_env, object: napi_value,
457 utf8name: *const ::std::os::raw::c_char,
458 value: napi_value) -> napi_status;
459}
460extern "C" {
461 pub fn napi_has_named_property(env: napi_env, object: napi_value,
462 utf8name: *const ::std::os::raw::c_char,
463 result: *mut bool) -> napi_status;
464}
465extern "C" {
466 pub fn napi_get_named_property(env: napi_env, object: napi_value,
467 utf8name: *const ::std::os::raw::c_char,
468 result: *mut napi_value) -> napi_status;
469}
470extern "C" {
471 pub fn napi_set_element(env: napi_env, object: napi_value, index: u32,
472 value: napi_value) -> napi_status;
473}
474extern "C" {
475 pub fn napi_has_element(env: napi_env, object: napi_value, index: u32,
476 result: *mut bool) -> napi_status;
477}
478extern "C" {
479 pub fn napi_get_element(env: napi_env, object: napi_value, index: u32,
480 result: *mut napi_value) -> napi_status;
481}
482extern "C" {
483 pub fn napi_define_properties(env: napi_env, object: napi_value,
484 property_count: usize,
485 properties: *const napi_property_descriptor)
486 -> napi_status;
487}
488extern "C" {
489 pub fn napi_is_array(env: napi_env, value: napi_value, result: *mut bool)
490 -> napi_status;
491}
492extern "C" {
493 pub fn napi_get_array_length(env: napi_env, value: napi_value,
494 result: *mut u32) -> napi_status;
495}
496extern "C" {
497 pub fn napi_strict_equals(env: napi_env, lhs: napi_value, rhs: napi_value,
498 result: *mut bool) -> napi_status;
499}
500extern "C" {
501 pub fn napi_call_function(env: napi_env, recv: napi_value,
502 func: napi_value, argc: usize,
503 argv: *const napi_value,
504 result: *mut napi_value) -> napi_status;
505}
506extern "C" {
507 pub fn napi_new_instance(env: napi_env, constructor: napi_value,
508 argc: usize, argv: *const napi_value,
509 result: *mut napi_value) -> napi_status;
510}
511extern "C" {
512 pub fn napi_instanceof(env: napi_env, object: napi_value,
513 constructor: napi_value, result: *mut bool)
514 -> napi_status;
515}
516extern "C" {
517 pub fn napi_make_callback(env: napi_env, recv: napi_value,
518 func: napi_value, argc: usize,
519 argv: *const napi_value,
520 result: *mut napi_value) -> napi_status;
521}
522extern "C" {
523 pub fn napi_get_cb_info(env: napi_env, cbinfo: napi_callback_info,
524 argc: *mut usize, argv: *mut napi_value,
525 this_arg: *mut napi_value,
526 data: *mut *mut ::std::os::raw::c_void)
527 -> napi_status;
528}
529extern "C" {
530 pub fn napi_is_construct_call(env: napi_env, cbinfo: napi_callback_info,
531 result: *mut bool) -> napi_status;
532}
533extern "C" {
534 pub fn napi_define_class(env: napi_env,
535 utf8name: *const ::std::os::raw::c_char,
536 constructor: napi_callback,
537 data: *mut ::std::os::raw::c_void,
538 property_count: usize,
539 properties: *const napi_property_descriptor,
540 result: *mut napi_value) -> napi_status;
541}
542extern "C" {
543 pub fn napi_wrap(env: napi_env, js_object: napi_value,
544 native_object: *mut ::std::os::raw::c_void,
545 finalize_cb: napi_finalize,
546 finalize_hint: *mut ::std::os::raw::c_void,
547 result: *mut napi_ref) -> napi_status;
548}
549extern "C" {
550 pub fn napi_unwrap(env: napi_env, js_object: napi_value,
551 result: *mut *mut ::std::os::raw::c_void)
552 -> napi_status;
553}
554extern "C" {
555 pub fn napi_create_external(env: napi_env,
556 data: *mut ::std::os::raw::c_void,
557 finalize_cb: napi_finalize,
558 finalize_hint: *mut ::std::os::raw::c_void,
559 result: *mut napi_value) -> napi_status;
560}
561extern "C" {
562 pub fn napi_get_value_external(env: napi_env, value: napi_value,
563 result: *mut *mut ::std::os::raw::c_void)
564 -> napi_status;
565}
566extern "C" {
567 pub fn napi_create_reference(env: napi_env, value: napi_value,
568 initial_refcount: u32, result: *mut napi_ref)
569 -> napi_status;
570}
571extern "C" {
572 pub fn napi_delete_reference(env: napi_env, ref_: napi_ref)
573 -> napi_status;
574}
575extern "C" {
576 pub fn napi_reference_ref(env: napi_env, ref_: napi_ref, result: *mut u32)
577 -> napi_status;
578}
579extern "C" {
580 pub fn napi_reference_unref(env: napi_env, ref_: napi_ref,
581 result: *mut u32) -> napi_status;
582}
583extern "C" {
584 pub fn napi_get_reference_value(env: napi_env, ref_: napi_ref,
585 result: *mut napi_value) -> napi_status;
586}
587extern "C" {
588 pub fn napi_open_handle_scope(env: napi_env,
589 result: *mut napi_handle_scope)
590 -> napi_status;
591}
592extern "C" {
593 pub fn napi_close_handle_scope(env: napi_env, scope: napi_handle_scope)
594 -> napi_status;
595}
596extern "C" {
597 pub fn napi_open_escapable_handle_scope(env: napi_env,
598 result:
599 *mut napi_escapable_handle_scope)
600 -> napi_status;
601}
602extern "C" {
603 pub fn napi_close_escapable_handle_scope(env: napi_env,
604 scope:
605 napi_escapable_handle_scope)
606 -> napi_status;
607}
608extern "C" {
609 pub fn napi_escape_handle(env: napi_env,
610 scope: napi_escapable_handle_scope,
611 escapee: napi_value, result: *mut napi_value)
612 -> napi_status;
613}
614extern "C" {
615 pub fn napi_throw(env: napi_env, error: napi_value) -> napi_status;
616}
617extern "C" {
618 pub fn napi_throw_error(env: napi_env, msg: *const ::std::os::raw::c_char)
619 -> napi_status;
620}
621extern "C" {
622 pub fn napi_throw_type_error(env: napi_env,
623 msg: *const ::std::os::raw::c_char)
624 -> napi_status;
625}
626extern "C" {
627 pub fn napi_throw_range_error(env: napi_env,
628 msg: *const ::std::os::raw::c_char)
629 -> napi_status;
630}
631extern "C" {
632 pub fn napi_is_error(env: napi_env, value: napi_value, result: *mut bool)
633 -> napi_status;
634}
635extern "C" {
636 pub fn napi_is_exception_pending(env: napi_env, result: *mut bool)
637 -> napi_status;
638}
639extern "C" {
640 pub fn napi_get_and_clear_last_exception(env: napi_env,
641 result: *mut napi_value)
642 -> napi_status;
643}
644extern "C" {
645 pub fn napi_create_buffer(env: napi_env, length: usize,
646 data: *mut *mut ::std::os::raw::c_void,
647 result: *mut napi_value) -> napi_status;
648}
649extern "C" {
650 pub fn napi_create_external_buffer(env: napi_env, length: usize,
651 data: *mut ::std::os::raw::c_void,
652 finalize_cb: napi_finalize,
653 finalize_hint:
654 *mut ::std::os::raw::c_void,
655 result: *mut napi_value)
656 -> napi_status;
657}
658extern "C" {
659 pub fn napi_create_buffer_copy(env: napi_env, length: usize,
660 data: *const ::std::os::raw::c_void,
661 result_data:
662 *mut *mut ::std::os::raw::c_void,
663 result: *mut napi_value) -> napi_status;
664}
665extern "C" {
666 pub fn napi_is_buffer(env: napi_env, value: napi_value, result: *mut bool)
667 -> napi_status;
668}
669extern "C" {
670 pub fn napi_get_buffer_info(env: napi_env, value: napi_value,
671 data: *mut *mut ::std::os::raw::c_void,
672 length: *mut usize) -> napi_status;
673}
674extern "C" {
675 pub fn napi_is_arraybuffer(env: napi_env, value: napi_value,
676 result: *mut bool) -> napi_status;
677}
678extern "C" {
679 pub fn napi_create_arraybuffer(env: napi_env, byte_length: usize,
680 data: *mut *mut ::std::os::raw::c_void,
681 result: *mut napi_value) -> napi_status;
682}
683extern "C" {
684 pub fn napi_create_external_arraybuffer(env: napi_env,
685 external_data:
686 *mut ::std::os::raw::c_void,
687 byte_length: usize,
688 finalize_cb: napi_finalize,
689 finalize_hint:
690 *mut ::std::os::raw::c_void,
691 result: *mut napi_value)
692 -> napi_status;
693}
694extern "C" {
695 pub fn napi_get_arraybuffer_info(env: napi_env, arraybuffer: napi_value,
696 data: *mut *mut ::std::os::raw::c_void,
697 byte_length: *mut usize) -> napi_status;
698}
699extern "C" {
700 pub fn napi_is_typedarray(env: napi_env, value: napi_value,
701 result: *mut bool) -> napi_status;
702}
703extern "C" {
704 pub fn napi_create_typedarray(env: napi_env, type_: napi_typedarray_type,
705 length: usize, arraybuffer: napi_value,
706 byte_offset: usize, result: *mut napi_value)
707 -> napi_status;
708}
709extern "C" {
710 pub fn napi_get_typedarray_info(env: napi_env, typedarray: napi_value,
711 type_: *mut napi_typedarray_type,
712 length: *mut usize,
713 data: *mut *mut ::std::os::raw::c_void,
714 arraybuffer: *mut napi_value,
715 byte_offset: *mut usize) -> napi_status;
716}
717extern "C" {
718 pub fn napi_create_async_work(env: napi_env,
719 execute: napi_async_execute_callback,
720 complete: napi_async_complete_callback,
721 data: *mut ::std::os::raw::c_void,
722 result: *mut napi_async_work)
723 -> napi_status;
724}
725extern "C" {
726 pub fn napi_delete_async_work(env: napi_env, work: napi_async_work)
727 -> napi_status;
728}
729extern "C" {
730 pub fn napi_queue_async_work(env: napi_env, work: napi_async_work)
731 -> napi_status;
732}
733extern "C" {
734 pub fn napi_cancel_async_work(env: napi_env, work: napi_async_work)
735 -> napi_status;
736}
737#[repr(C)]
738#[derive(Debug, Copy)]
739pub struct __va_list_tag {
740 pub gp_offset: ::std::os::raw::c_uint,
741 pub fp_offset: ::std::os::raw::c_uint,
742 pub overflow_arg_area: *mut ::std::os::raw::c_void,
743 pub reg_save_area: *mut ::std::os::raw::c_void,
744}
745#[test]
746fn bindgen_test_layout___va_list_tag() {
747 assert_eq!(::std::mem::size_of::<__va_list_tag>() , 24usize , concat ! (
748 "Size of: " , stringify ! ( __va_list_tag ) ));
749 assert_eq! (::std::mem::align_of::<__va_list_tag>() , 8usize , concat ! (
750 "Alignment of " , stringify ! ( __va_list_tag ) ));
751 assert_eq! (unsafe {
752 & ( * ( 0 as * const __va_list_tag ) ) . gp_offset as * const
753 _ as usize } , 0usize , concat ! (
754 "Alignment of field: " , stringify ! ( __va_list_tag ) , "::"
755 , stringify ! ( gp_offset ) ));
756 assert_eq! (unsafe {
757 & ( * ( 0 as * const __va_list_tag ) ) . fp_offset as * const
758 _ as usize } , 4usize , concat ! (
759 "Alignment of field: " , stringify ! ( __va_list_tag ) , "::"
760 , stringify ! ( fp_offset ) ));
761 assert_eq! (unsafe {
762 & ( * ( 0 as * const __va_list_tag ) ) . overflow_arg_area as
763 * const _ as usize } , 8usize , concat ! (
764 "Alignment of field: " , stringify ! ( __va_list_tag ) , "::"
765 , stringify ! ( overflow_arg_area ) ));
766 assert_eq! (unsafe {
767 & ( * ( 0 as * const __va_list_tag ) ) . reg_save_area as *
768 const _ as usize } , 16usize , concat ! (
769 "Alignment of field: " , stringify ! ( __va_list_tag ) , "::"
770 , stringify ! ( reg_save_area ) ));
771}
772impl Clone for __va_list_tag {
773 fn clone(&self) -> Self { *self }
774}
775pub type __builtin_va_list = [__va_list_tag; 1usize];