1#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
7#![allow(
8 clippy::approx_constant,
9 clippy::type_complexity,
10 clippy::unreadable_literal,
11 clippy::upper_case_acronyms
12)]
13#![cfg_attr(docsrs, feature(doc_cfg))]
14
15use glib_sys as glib;
16use gobject_sys as gobject;
17
18#[allow(unused_imports)]
19use libc::{
20 c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void,
21 intptr_t, off_t, size_t, ssize_t, time_t, uintptr_t, FILE,
22};
23#[cfg(unix)]
24#[allow(unused_imports)]
25use libc::{dev_t, gid_t, pid_t, socklen_t, uid_t};
26
27#[allow(unused_imports)]
28use glib::{gboolean, gconstpointer, gpointer, GType};
29
30pub type JSCCheckSyntaxMode = c_int;
32pub const JSC_CHECK_SYNTAX_MODE_SCRIPT: JSCCheckSyntaxMode = 0;
33pub const JSC_CHECK_SYNTAX_MODE_MODULE: JSCCheckSyntaxMode = 1;
34
35pub type JSCCheckSyntaxResult = c_int;
36pub const JSC_CHECK_SYNTAX_RESULT_SUCCESS: JSCCheckSyntaxResult = 0;
37pub const JSC_CHECK_SYNTAX_RESULT_RECOVERABLE_ERROR: JSCCheckSyntaxResult = 1;
38pub const JSC_CHECK_SYNTAX_RESULT_IRRECOVERABLE_ERROR: JSCCheckSyntaxResult = 2;
39pub const JSC_CHECK_SYNTAX_RESULT_UNTERMINATED_LITERAL_ERROR: JSCCheckSyntaxResult = 3;
40pub const JSC_CHECK_SYNTAX_RESULT_OUT_OF_MEMORY_ERROR: JSCCheckSyntaxResult = 4;
41pub const JSC_CHECK_SYNTAX_RESULT_STACK_OVERFLOW_ERROR: JSCCheckSyntaxResult = 5;
42
43pub type JSCOptionType = c_int;
44pub const JSC_OPTION_BOOLEAN: JSCOptionType = 0;
45pub const JSC_OPTION_INT: JSCOptionType = 1;
46pub const JSC_OPTION_UINT: JSCOptionType = 2;
47pub const JSC_OPTION_SIZE: JSCOptionType = 3;
48pub const JSC_OPTION_DOUBLE: JSCOptionType = 4;
49pub const JSC_OPTION_STRING: JSCOptionType = 5;
50pub const JSC_OPTION_RANGE_STRING: JSCOptionType = 6;
51
52pub type JSCTypedArrayType = c_int;
53pub const JSC_TYPED_ARRAY_NONE: JSCTypedArrayType = 0;
54pub const JSC_TYPED_ARRAY_INT8: JSCTypedArrayType = 1;
55pub const JSC_TYPED_ARRAY_INT16: JSCTypedArrayType = 2;
56pub const JSC_TYPED_ARRAY_INT32: JSCTypedArrayType = 3;
57pub const JSC_TYPED_ARRAY_INT64: JSCTypedArrayType = 4;
58pub const JSC_TYPED_ARRAY_UINT8: JSCTypedArrayType = 5;
59pub const JSC_TYPED_ARRAY_UINT8_CLAMPED: JSCTypedArrayType = 6;
60pub const JSC_TYPED_ARRAY_UINT16: JSCTypedArrayType = 7;
61pub const JSC_TYPED_ARRAY_UINT32: JSCTypedArrayType = 8;
62pub const JSC_TYPED_ARRAY_UINT64: JSCTypedArrayType = 9;
63pub const JSC_TYPED_ARRAY_FLOAT32: JSCTypedArrayType = 10;
64pub const JSC_TYPED_ARRAY_FLOAT64: JSCTypedArrayType = 11;
65
66pub const JSC_OPTIONS_USE_DFG: &[u8] = b"useDFGJIT\0";
68pub const JSC_OPTIONS_USE_FTL: &[u8] = b"useFTLJIT\0";
69pub const JSC_OPTIONS_USE_JIT: &[u8] = b"useJIT\0";
70pub const JSC_OPTIONS_USE_LLINT: &[u8] = b"useLLInt\0";
71
72pub type JSCValuePropertyFlags = c_uint;
74pub const JSC_VALUE_PROPERTY_CONFIGURABLE: JSCValuePropertyFlags = 1;
75pub const JSC_VALUE_PROPERTY_ENUMERABLE: JSCValuePropertyFlags = 2;
76pub const JSC_VALUE_PROPERTY_WRITABLE: JSCValuePropertyFlags = 4;
77
78pub type JSCClassDeletePropertyFunction = Option<
80 unsafe extern "C" fn(*mut JSCClass, *mut JSCContext, gpointer, *const c_char) -> gboolean,
81>;
82pub type JSCClassEnumeratePropertiesFunction =
83 Option<unsafe extern "C" fn(*mut JSCClass, *mut JSCContext, gpointer) -> *mut *mut c_char>;
84pub type JSCClassGetPropertyFunction = Option<
85 unsafe extern "C" fn(*mut JSCClass, *mut JSCContext, gpointer, *const c_char) -> *mut JSCValue,
86>;
87pub type JSCClassHasPropertyFunction = Option<
88 unsafe extern "C" fn(*mut JSCClass, *mut JSCContext, gpointer, *const c_char) -> gboolean,
89>;
90pub type JSCClassSetPropertyFunction = Option<
91 unsafe extern "C" fn(
92 *mut JSCClass,
93 *mut JSCContext,
94 gpointer,
95 *const c_char,
96 *mut JSCValue,
97 ) -> gboolean,
98>;
99pub type JSCExceptionHandler =
100 Option<unsafe extern "C" fn(*mut JSCContext, *mut JSCException, gpointer)>;
101pub type JSCOptionsFunc =
102 Option<unsafe extern "C" fn(*const c_char, JSCOptionType, *const c_char, gpointer) -> gboolean>;
103
104#[derive(Copy, Clone)]
106#[repr(C)]
107pub struct JSCClassClass {
108 pub parent_class: gobject::GObjectClass,
109}
110
111impl ::std::fmt::Debug for JSCClassClass {
112 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
113 f.debug_struct(&format!("JSCClassClass @ {self:p}"))
114 .field("parent_class", &self.parent_class)
115 .finish()
116 }
117}
118
119#[derive(Copy, Clone)]
120#[repr(C)]
121pub struct JSCClassVTable {
122 pub get_property: JSCClassGetPropertyFunction,
123 pub set_property: JSCClassSetPropertyFunction,
124 pub has_property: JSCClassHasPropertyFunction,
125 pub delete_property: JSCClassDeletePropertyFunction,
126 pub enumerate_properties: JSCClassEnumeratePropertiesFunction,
127 pub _jsc_reserved0: Option<unsafe extern "C" fn()>,
128 pub _jsc_reserved1: Option<unsafe extern "C" fn()>,
129 pub _jsc_reserved2: Option<unsafe extern "C" fn()>,
130 pub _jsc_reserved3: Option<unsafe extern "C" fn()>,
131 pub _jsc_reserved4: Option<unsafe extern "C" fn()>,
132 pub _jsc_reserved5: Option<unsafe extern "C" fn()>,
133 pub _jsc_reserved6: Option<unsafe extern "C" fn()>,
134 pub _jsc_reserved7: Option<unsafe extern "C" fn()>,
135}
136
137impl ::std::fmt::Debug for JSCClassVTable {
138 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
139 f.debug_struct(&format!("JSCClassVTable @ {self:p}"))
140 .field("get_property", &self.get_property)
141 .field("set_property", &self.set_property)
142 .field("has_property", &self.has_property)
143 .field("delete_property", &self.delete_property)
144 .field("enumerate_properties", &self.enumerate_properties)
145 .field("_jsc_reserved0", &self._jsc_reserved0)
146 .field("_jsc_reserved1", &self._jsc_reserved1)
147 .field("_jsc_reserved2", &self._jsc_reserved2)
148 .field("_jsc_reserved3", &self._jsc_reserved3)
149 .field("_jsc_reserved4", &self._jsc_reserved4)
150 .field("_jsc_reserved5", &self._jsc_reserved5)
151 .field("_jsc_reserved6", &self._jsc_reserved6)
152 .field("_jsc_reserved7", &self._jsc_reserved7)
153 .finish()
154 }
155}
156
157#[derive(Copy, Clone)]
158#[repr(C)]
159pub struct JSCContextClass {
160 pub parent_class: gobject::GObjectClass,
161}
162
163impl ::std::fmt::Debug for JSCContextClass {
164 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
165 f.debug_struct(&format!("JSCContextClass @ {self:p}"))
166 .field("parent_class", &self.parent_class)
167 .finish()
168 }
169}
170
171#[derive(Copy, Clone)]
172#[repr(C)]
173pub struct JSCExceptionClass {
174 pub parent_class: gobject::GObjectClass,
175}
176
177impl ::std::fmt::Debug for JSCExceptionClass {
178 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
179 f.debug_struct(&format!("JSCExceptionClass @ {self:p}"))
180 .field("parent_class", &self.parent_class)
181 .finish()
182 }
183}
184
185#[derive(Copy, Clone)]
186#[repr(C)]
187pub struct JSCValueClass {
188 pub parent_class: gobject::GObjectClass,
189}
190
191impl ::std::fmt::Debug for JSCValueClass {
192 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
193 f.debug_struct(&format!("JSCValueClass @ {self:p}"))
194 .field("parent_class", &self.parent_class)
195 .finish()
196 }
197}
198
199#[derive(Copy, Clone)]
200#[repr(C)]
201pub struct JSCVirtualMachineClass {
202 pub parent_class: gobject::GObjectClass,
203}
204
205impl ::std::fmt::Debug for JSCVirtualMachineClass {
206 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
207 f.debug_struct(&format!("JSCVirtualMachineClass @ {self:p}"))
208 .field("parent_class", &self.parent_class)
209 .finish()
210 }
211}
212
213#[derive(Copy, Clone)]
214#[repr(C)]
215pub struct JSCWeakValueClass {
216 pub parent_class: gobject::GObjectClass,
217}
218
219impl ::std::fmt::Debug for JSCWeakValueClass {
220 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
221 f.debug_struct(&format!("JSCWeakValueClass @ {self:p}"))
222 .field("parent_class", &self.parent_class)
223 .finish()
224 }
225}
226
227#[repr(C)]
229pub struct JSCClass {
230 _data: [u8; 0],
231 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
232}
233
234impl ::std::fmt::Debug for JSCClass {
235 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
236 f.debug_struct(&format!("JSCClass @ {self:p}")).finish()
237 }
238}
239
240#[repr(C)]
241pub struct JSCContext {
242 _data: [u8; 0],
243 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
244}
245
246impl ::std::fmt::Debug for JSCContext {
247 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
248 f.debug_struct(&format!("JSCContext @ {self:p}")).finish()
249 }
250}
251
252#[repr(C)]
253pub struct JSCException {
254 _data: [u8; 0],
255 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
256}
257
258impl ::std::fmt::Debug for JSCException {
259 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
260 f.debug_struct(&format!("JSCException @ {self:p}")).finish()
261 }
262}
263
264#[repr(C)]
265pub struct JSCValue {
266 _data: [u8; 0],
267 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
268}
269
270impl ::std::fmt::Debug for JSCValue {
271 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
272 f.debug_struct(&format!("JSCValue @ {self:p}")).finish()
273 }
274}
275
276#[repr(C)]
277pub struct JSCVirtualMachine {
278 _data: [u8; 0],
279 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
280}
281
282impl ::std::fmt::Debug for JSCVirtualMachine {
283 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
284 f.debug_struct(&format!("JSCVirtualMachine @ {self:p}"))
285 .finish()
286 }
287}
288
289#[repr(C)]
290pub struct JSCWeakValue {
291 _data: [u8; 0],
292 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
293}
294
295impl ::std::fmt::Debug for JSCWeakValue {
296 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
297 f.debug_struct(&format!("JSCWeakValue @ {self:p}")).finish()
298 }
299}
300
301#[link(name = "javascriptcoregtk-6.0")]
302extern "C" {
303
304 pub fn jsc_class_get_type() -> GType;
308 pub fn jsc_class_add_constructor(
309 jsc_class: *mut JSCClass,
310 name: *const c_char,
311 callback: gobject::GCallback,
312 user_data: gpointer,
313 destroy_notify: glib::GDestroyNotify,
314 return_type: GType,
315 n_params: c_uint,
316 ...
317 ) -> *mut JSCValue;
318 pub fn jsc_class_add_constructor_variadic(
319 jsc_class: *mut JSCClass,
320 name: *const c_char,
321 callback: gobject::GCallback,
322 user_data: gpointer,
323 destroy_notify: glib::GDestroyNotify,
324 return_type: GType,
325 ) -> *mut JSCValue;
326 pub fn jsc_class_add_constructorv(
327 jsc_class: *mut JSCClass,
328 name: *const c_char,
329 callback: gobject::GCallback,
330 user_data: gpointer,
331 destroy_notify: glib::GDestroyNotify,
332 return_type: GType,
333 n_parameters: c_uint,
334 parameter_types: *mut GType,
335 ) -> *mut JSCValue;
336 pub fn jsc_class_add_method(
337 jsc_class: *mut JSCClass,
338 name: *const c_char,
339 callback: gobject::GCallback,
340 user_data: gpointer,
341 destroy_notify: glib::GDestroyNotify,
342 return_type: GType,
343 n_params: c_uint,
344 ...
345 );
346 pub fn jsc_class_add_method_variadic(
347 jsc_class: *mut JSCClass,
348 name: *const c_char,
349 callback: gobject::GCallback,
350 user_data: gpointer,
351 destroy_notify: glib::GDestroyNotify,
352 return_type: GType,
353 );
354 pub fn jsc_class_add_methodv(
355 jsc_class: *mut JSCClass,
356 name: *const c_char,
357 callback: gobject::GCallback,
358 user_data: gpointer,
359 destroy_notify: glib::GDestroyNotify,
360 return_type: GType,
361 n_parameters: c_uint,
362 parameter_types: *mut GType,
363 );
364 pub fn jsc_class_add_property(
365 jsc_class: *mut JSCClass,
366 name: *const c_char,
367 property_type: GType,
368 getter: gobject::GCallback,
369 setter: gobject::GCallback,
370 user_data: gpointer,
371 destroy_notify: glib::GDestroyNotify,
372 );
373 pub fn jsc_class_get_name(jsc_class: *mut JSCClass) -> *const c_char;
374 pub fn jsc_class_get_parent(jsc_class: *mut JSCClass) -> *mut JSCClass;
375
376 pub fn jsc_context_get_type() -> GType;
380 pub fn jsc_context_new() -> *mut JSCContext;
381 pub fn jsc_context_new_with_virtual_machine(vm: *mut JSCVirtualMachine) -> *mut JSCContext;
382 pub fn jsc_context_get_current() -> *mut JSCContext;
383 pub fn jsc_context_check_syntax(
384 context: *mut JSCContext,
385 code: *const c_char,
386 length: ssize_t,
387 mode: JSCCheckSyntaxMode,
388 uri: *const c_char,
389 line_number: c_uint,
390 exception: *mut *mut JSCException,
391 ) -> JSCCheckSyntaxResult;
392 pub fn jsc_context_clear_exception(context: *mut JSCContext);
393 pub fn jsc_context_evaluate(
394 context: *mut JSCContext,
395 code: *const c_char,
396 length: ssize_t,
397 ) -> *mut JSCValue;
398 pub fn jsc_context_evaluate_in_object(
399 context: *mut JSCContext,
400 code: *const c_char,
401 length: ssize_t,
402 object_instance: gpointer,
403 object_class: *mut JSCClass,
404 uri: *const c_char,
405 line_number: c_uint,
406 object: *mut *mut JSCValue,
407 ) -> *mut JSCValue;
408 pub fn jsc_context_evaluate_with_source_uri(
409 context: *mut JSCContext,
410 code: *const c_char,
411 length: ssize_t,
412 uri: *const c_char,
413 line_number: c_uint,
414 ) -> *mut JSCValue;
415 pub fn jsc_context_get_exception(context: *mut JSCContext) -> *mut JSCException;
416 pub fn jsc_context_get_global_object(context: *mut JSCContext) -> *mut JSCValue;
417 pub fn jsc_context_get_value(context: *mut JSCContext, name: *const c_char) -> *mut JSCValue;
418 pub fn jsc_context_get_virtual_machine(context: *mut JSCContext) -> *mut JSCVirtualMachine;
419 pub fn jsc_context_pop_exception_handler(context: *mut JSCContext);
420 pub fn jsc_context_push_exception_handler(
421 context: *mut JSCContext,
422 handler: JSCExceptionHandler,
423 user_data: gpointer,
424 destroy_notify: glib::GDestroyNotify,
425 );
426 pub fn jsc_context_register_class(
427 context: *mut JSCContext,
428 name: *const c_char,
429 parent_class: *mut JSCClass,
430 vtable: *mut JSCClassVTable,
431 destroy_notify: glib::GDestroyNotify,
432 ) -> *mut JSCClass;
433 pub fn jsc_context_set_value(
434 context: *mut JSCContext,
435 name: *const c_char,
436 value: *mut JSCValue,
437 );
438 pub fn jsc_context_throw(context: *mut JSCContext, error_message: *const c_char);
439 pub fn jsc_context_throw_exception(context: *mut JSCContext, exception: *mut JSCException);
440 pub fn jsc_context_throw_printf(context: *mut JSCContext, format: *const c_char, ...);
441 pub fn jsc_context_throw_with_name(
442 context: *mut JSCContext,
443 error_name: *const c_char,
444 error_message: *const c_char,
445 );
446 pub fn jsc_context_throw_with_name_printf(
447 context: *mut JSCContext,
448 error_name: *const c_char,
449 format: *const c_char,
450 ...
451 );
452
453 pub fn jsc_exception_get_type() -> GType;
457 pub fn jsc_exception_new(context: *mut JSCContext, message: *const c_char)
458 -> *mut JSCException;
459 pub fn jsc_exception_new_printf(
460 context: *mut JSCContext,
461 format: *const c_char,
462 ...
463 ) -> *mut JSCException;
464 pub fn jsc_exception_new_with_name(
466 context: *mut JSCContext,
467 name: *const c_char,
468 message: *const c_char,
469 ) -> *mut JSCException;
470 pub fn jsc_exception_new_with_name_printf(
471 context: *mut JSCContext,
472 name: *const c_char,
473 format: *const c_char,
474 ...
475 ) -> *mut JSCException;
476 pub fn jsc_exception_get_backtrace_string(exception: *mut JSCException) -> *const c_char;
478 pub fn jsc_exception_get_column_number(exception: *mut JSCException) -> c_uint;
479 pub fn jsc_exception_get_line_number(exception: *mut JSCException) -> c_uint;
480 pub fn jsc_exception_get_message(exception: *mut JSCException) -> *const c_char;
481 pub fn jsc_exception_get_name(exception: *mut JSCException) -> *const c_char;
482 pub fn jsc_exception_get_source_uri(exception: *mut JSCException) -> *const c_char;
483 pub fn jsc_exception_report(exception: *mut JSCException) -> *mut c_char;
484 pub fn jsc_exception_to_string(exception: *mut JSCException) -> *mut c_char;
485
486 pub fn jsc_value_get_type() -> GType;
490 pub fn jsc_value_new_array(
491 context: *mut JSCContext,
492 first_item_type: GType,
493 ...
494 ) -> *mut JSCValue;
495 pub fn jsc_value_new_array_buffer(
496 context: *mut JSCContext,
497 data: gpointer,
498 size: size_t,
499 destroy_notify: glib::GDestroyNotify,
500 user_data: gpointer,
501 ) -> *mut JSCValue;
502 pub fn jsc_value_new_array_from_garray(
503 context: *mut JSCContext,
504 array: *mut glib::GPtrArray,
505 ) -> *mut JSCValue;
506 pub fn jsc_value_new_array_from_strv(
507 context: *mut JSCContext,
508 strv: *const *const c_char,
509 ) -> *mut JSCValue;
510 pub fn jsc_value_new_boolean(context: *mut JSCContext, value: gboolean) -> *mut JSCValue;
511 pub fn jsc_value_new_from_json(context: *mut JSCContext, json: *const c_char) -> *mut JSCValue;
512 pub fn jsc_value_new_function(
513 context: *mut JSCContext,
514 name: *const c_char,
515 callback: gobject::GCallback,
516 user_data: gpointer,
517 destroy_notify: glib::GDestroyNotify,
518 return_type: GType,
519 n_params: c_uint,
520 ...
521 ) -> *mut JSCValue;
522 pub fn jsc_value_new_function_variadic(
523 context: *mut JSCContext,
524 name: *const c_char,
525 callback: gobject::GCallback,
526 user_data: gpointer,
527 destroy_notify: glib::GDestroyNotify,
528 return_type: GType,
529 ) -> *mut JSCValue;
530 pub fn jsc_value_new_functionv(
531 context: *mut JSCContext,
532 name: *const c_char,
533 callback: gobject::GCallback,
534 user_data: gpointer,
535 destroy_notify: glib::GDestroyNotify,
536 return_type: GType,
537 n_parameters: c_uint,
538 parameter_types: *mut GType,
539 ) -> *mut JSCValue;
540 pub fn jsc_value_new_null(context: *mut JSCContext) -> *mut JSCValue;
541 pub fn jsc_value_new_number(context: *mut JSCContext, number: c_double) -> *mut JSCValue;
542 pub fn jsc_value_new_object(
543 context: *mut JSCContext,
544 instance: gpointer,
545 jsc_class: *mut JSCClass,
546 ) -> *mut JSCValue;
547 pub fn jsc_value_new_string(context: *mut JSCContext, string: *const c_char) -> *mut JSCValue;
548 pub fn jsc_value_new_string_from_bytes(
549 context: *mut JSCContext,
550 bytes: *mut glib::GBytes,
551 ) -> *mut JSCValue;
552 pub fn jsc_value_new_typed_array(
553 context: *mut JSCContext,
554 type_: JSCTypedArrayType,
555 length: size_t,
556 ) -> *mut JSCValue;
557 pub fn jsc_value_new_undefined(context: *mut JSCContext) -> *mut JSCValue;
558 pub fn jsc_value_array_buffer_get_data(value: *mut JSCValue, size: *mut size_t) -> gpointer;
559 pub fn jsc_value_array_buffer_get_size(value: *mut JSCValue) -> size_t;
560 pub fn jsc_value_constructor_call(
561 value: *mut JSCValue,
562 first_parameter_type: GType,
563 ...
564 ) -> *mut JSCValue;
565 pub fn jsc_value_constructor_callv(
566 value: *mut JSCValue,
567 n_parameters: c_uint,
568 parameters: *mut *mut JSCValue,
569 ) -> *mut JSCValue;
570 pub fn jsc_value_function_call(
571 value: *mut JSCValue,
572 first_parameter_type: GType,
573 ...
574 ) -> *mut JSCValue;
575 pub fn jsc_value_function_callv(
576 value: *mut JSCValue,
577 n_parameters: c_uint,
578 parameters: *mut *mut JSCValue,
579 ) -> *mut JSCValue;
580 pub fn jsc_value_get_context(value: *mut JSCValue) -> *mut JSCContext;
581 pub fn jsc_value_is_array(value: *mut JSCValue) -> gboolean;
582 pub fn jsc_value_is_array_buffer(value: *mut JSCValue) -> gboolean;
583 pub fn jsc_value_is_boolean(value: *mut JSCValue) -> gboolean;
584 pub fn jsc_value_is_constructor(value: *mut JSCValue) -> gboolean;
585 pub fn jsc_value_is_function(value: *mut JSCValue) -> gboolean;
586 pub fn jsc_value_is_null(value: *mut JSCValue) -> gboolean;
587 pub fn jsc_value_is_number(value: *mut JSCValue) -> gboolean;
588 pub fn jsc_value_is_object(value: *mut JSCValue) -> gboolean;
589 pub fn jsc_value_is_string(value: *mut JSCValue) -> gboolean;
590 pub fn jsc_value_is_typed_array(value: *mut JSCValue) -> gboolean;
591 pub fn jsc_value_is_undefined(value: *mut JSCValue) -> gboolean;
592 pub fn jsc_value_new_typed_array_with_buffer(
593 array_buffer: *mut JSCValue,
594 type_: JSCTypedArrayType,
595 offset: size_t,
596 length: ssize_t,
597 ) -> *mut JSCValue;
598 pub fn jsc_value_object_define_property_accessor(
599 value: *mut JSCValue,
600 property_name: *const c_char,
601 flags: JSCValuePropertyFlags,
602 property_type: GType,
603 getter: gobject::GCallback,
604 setter: gobject::GCallback,
605 user_data: gpointer,
606 destroy_notify: glib::GDestroyNotify,
607 );
608 pub fn jsc_value_object_define_property_data(
609 value: *mut JSCValue,
610 property_name: *const c_char,
611 flags: JSCValuePropertyFlags,
612 property_value: *mut JSCValue,
613 );
614 pub fn jsc_value_object_delete_property(value: *mut JSCValue, name: *const c_char) -> gboolean;
615 pub fn jsc_value_object_enumerate_properties(value: *mut JSCValue) -> *mut *mut c_char;
616 pub fn jsc_value_object_get_property(
617 value: *mut JSCValue,
618 name: *const c_char,
619 ) -> *mut JSCValue;
620 pub fn jsc_value_object_get_property_at_index(
621 value: *mut JSCValue,
622 index: c_uint,
623 ) -> *mut JSCValue;
624 pub fn jsc_value_object_has_property(value: *mut JSCValue, name: *const c_char) -> gboolean;
625 pub fn jsc_value_object_invoke_method(
626 value: *mut JSCValue,
627 name: *const c_char,
628 first_parameter_type: GType,
629 ...
630 ) -> *mut JSCValue;
631 pub fn jsc_value_object_invoke_methodv(
632 value: *mut JSCValue,
633 name: *const c_char,
634 n_parameters: c_uint,
635 parameters: *mut *mut JSCValue,
636 ) -> *mut JSCValue;
637 pub fn jsc_value_object_is_instance_of(value: *mut JSCValue, name: *const c_char) -> gboolean;
638 pub fn jsc_value_object_set_property(
639 value: *mut JSCValue,
640 name: *const c_char,
641 property: *mut JSCValue,
642 );
643 pub fn jsc_value_object_set_property_at_index(
644 value: *mut JSCValue,
645 index: c_uint,
646 property: *mut JSCValue,
647 );
648 pub fn jsc_value_to_boolean(value: *mut JSCValue) -> gboolean;
649 pub fn jsc_value_to_double(value: *mut JSCValue) -> c_double;
650 pub fn jsc_value_to_int32(value: *mut JSCValue) -> i32;
651 pub fn jsc_value_to_json(value: *mut JSCValue, indent: c_uint) -> *mut c_char;
652 pub fn jsc_value_to_string(value: *mut JSCValue) -> *mut c_char;
653 pub fn jsc_value_to_string_as_bytes(value: *mut JSCValue) -> *mut glib::GBytes;
654 pub fn jsc_value_typed_array_get_buffer(value: *mut JSCValue) -> *mut JSCValue;
655 pub fn jsc_value_typed_array_get_data(value: *mut JSCValue, length: *mut size_t) -> gpointer;
656 pub fn jsc_value_typed_array_get_length(value: *mut JSCValue) -> size_t;
657 pub fn jsc_value_typed_array_get_offset(value: *mut JSCValue) -> size_t;
658 pub fn jsc_value_typed_array_get_size(value: *mut JSCValue) -> size_t;
659 pub fn jsc_value_typed_array_get_type(value: *mut JSCValue) -> JSCTypedArrayType;
660
661 pub fn jsc_virtual_machine_get_type() -> GType;
665 pub fn jsc_virtual_machine_new() -> *mut JSCVirtualMachine;
666
667 pub fn jsc_weak_value_get_type() -> GType;
671 pub fn jsc_weak_value_new(value: *mut JSCValue) -> *mut JSCWeakValue;
672 pub fn jsc_weak_value_get_value(weak_value: *mut JSCWeakValue) -> *mut JSCValue;
673
674 pub fn jsc_get_major_version() -> c_uint;
678 pub fn jsc_get_micro_version() -> c_uint;
679 pub fn jsc_get_minor_version() -> c_uint;
680 pub fn jsc_options_foreach(function: JSCOptionsFunc, user_data: gpointer);
681 pub fn jsc_options_get_boolean(option: *const c_char, value: *mut gboolean) -> gboolean;
682 pub fn jsc_options_get_double(option: *const c_char, value: *mut c_double) -> gboolean;
683 pub fn jsc_options_get_int(option: *const c_char, value: *mut c_int) -> gboolean;
684 pub fn jsc_options_get_option_group() -> *mut glib::GOptionGroup;
685 pub fn jsc_options_get_range_string(option: *const c_char, value: *mut *mut c_char)
686 -> gboolean;
687 pub fn jsc_options_get_size(option: *const c_char, value: *mut size_t) -> gboolean;
688 pub fn jsc_options_get_string(option: *const c_char, value: *mut *mut c_char) -> gboolean;
689 pub fn jsc_options_get_uint(option: *const c_char, value: *mut c_uint) -> gboolean;
690 pub fn jsc_options_set_boolean(option: *const c_char, value: gboolean) -> gboolean;
691 pub fn jsc_options_set_double(option: *const c_char, value: c_double) -> gboolean;
692 pub fn jsc_options_set_int(option: *const c_char, value: c_int) -> gboolean;
693 pub fn jsc_options_set_range_string(option: *const c_char, value: *const c_char) -> gboolean;
694 pub fn jsc_options_set_size(option: *const c_char, value: size_t) -> gboolean;
695 pub fn jsc_options_set_string(option: *const c_char, value: *const c_char) -> gboolean;
696 pub fn jsc_options_set_uint(option: *const c_char, value: c_uint) -> gboolean;
697
698}