From 60205f604217bafeccce58fde2ffd158a80a8985 Mon Sep 17 00:00:00 2001 From: Jason Cai Date: Sun, 3 Oct 2021 20:56:12 +0800 Subject: [PATCH] Generate javascriptcore-sys --- javascriptcore-sys/Cargo.toml | 27 +- javascriptcore-sys/build.rs | 17 + javascriptcore-sys/src/lib.rs | 738 +++++++++++++++++++++++++++- javascriptcore-sys/tests/abi.rs | 349 +++++++++++++ javascriptcore-sys/tests/constant.c | 57 +++ javascriptcore-sys/tests/layout.c | 26 + javascriptcore-sys/tests/manual.h | 3 + 7 files changed, 1190 insertions(+), 27 deletions(-) create mode 100644 javascriptcore-sys/build.rs create mode 100644 javascriptcore-sys/tests/abi.rs create mode 100644 javascriptcore-sys/tests/constant.c create mode 100644 javascriptcore-sys/tests/layout.c create mode 100644 javascriptcore-sys/tests/manual.h diff --git a/javascriptcore-sys/Cargo.toml b/javascriptcore-sys/Cargo.toml index 3e85f0c..b650ff7 100644 --- a/javascriptcore-sys/Cargo.toml +++ b/javascriptcore-sys/Cargo.toml @@ -2,15 +2,38 @@ name = "javascriptcore-rs-sys" version = "0.2.0" authors = ["The Gtk-rs Project Developers"] - description = "Sys functions for the Rust bindings of the javacriptcore library" repository = "https://github.com/gtk-rs/javascriptcore-rs" license = "MIT" homepage = "http://gtk-rs.org" keywords = ["javascript", "gtk-rs", "gnome"] +build = "build.rs" +edition="2018" + +[package.metadata.system-deps.javascriptcoregtk_4_0] +name = "javascriptcoregtk-4.0" +version = "2.24" + +[package.metadata.system-deps.javascriptcoregtk_4_0.v2_28] +version = "2.28" +[package.metadata.docs.rs] +features = ["dox"] [lib] name = "javascriptcore_sys" [dependencies] -libc = "^0.2" +libc = "0.2" +glib-sys = "^0.14" +gobject-sys = "^0.14" + +[build-dependencies] +system-deps = "5" + +[dev-dependencies] +shell-words = "1.0.0" +tempfile = "3" + +[features] +v2_28 = [] +dox = [] diff --git a/javascriptcore-sys/build.rs b/javascriptcore-sys/build.rs new file mode 100644 index 0000000..07b583d --- /dev/null +++ b/javascriptcore-sys/build.rs @@ -0,0 +1,17 @@ +// Generated by gir (https://github.com/gtk-rs/gir @ 05fe12c0b7e7) +// from ../gir-files (@ fc4e8657c758) +// DO NOT EDIT + +#[cfg(not(feature = "dox"))] +use std::process; + +#[cfg(feature = "dox")] +fn main() {} // prevent linking libraries to avoid documentation failure + +#[cfg(not(feature = "dox"))] +fn main() { + if let Err(s) = system_deps::Config::new().probe() { + println!("cargo:warning={}", s); + process::exit(1); + } +} diff --git a/javascriptcore-sys/src/lib.rs b/javascriptcore-sys/src/lib.rs index 2d29f65..2bb9388 100644 --- a/javascriptcore-sys/src/lib.rs +++ b/javascriptcore-sys/src/lib.rs @@ -1,30 +1,718 @@ -// Copyright 2013-2017, The Gtk-rs Project Developers. -// See the COPYRIGHT file at the top-level directory of this distribution. -// Licensed under the MIT license, see the LICENSE file or +// Generated by gir (https://github.com/gtk-rs/gir @ 05fe12c0b7e7) +// from ../gir-files (@ fc4e8657c758) +// DO NOT EDIT -extern crate libc; +#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)] +#![allow( + clippy::approx_constant, + clippy::type_complexity, + clippy::unreadable_literal, + clippy::upper_case_acronyms +)] +#![cfg_attr(feature = "dox", feature(doc_cfg))] -use libc::{c_char, c_double, c_void}; +use glib_sys as glib; +use gobject_sys as gobject; -pub type JSCValue = *mut c_void; -pub type JSCContext = *mut c_void; -pub type JSGlobalContextRef = *mut c_void; -pub type JSValueRef = *mut c_void; -pub type JSStringRef = *mut c_void; +#[allow(unused_imports)] +use libc::{ + c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void, + intptr_t, size_t, ssize_t, time_t, uintptr_t, FILE, +}; + +#[allow(unused_imports)] +use glib::{gboolean, gconstpointer, gpointer, GType}; + +// Enums +pub type JSCCheckSyntaxMode = c_int; +pub const JSC_CHECK_SYNTAX_MODE_SCRIPT: JSCCheckSyntaxMode = 0; +pub const JSC_CHECK_SYNTAX_MODE_MODULE: JSCCheckSyntaxMode = 1; + +pub type JSCCheckSyntaxResult = c_int; +pub const JSC_CHECK_SYNTAX_RESULT_SUCCESS: JSCCheckSyntaxResult = 0; +pub const JSC_CHECK_SYNTAX_RESULT_RECOVERABLE_ERROR: JSCCheckSyntaxResult = 1; +pub const JSC_CHECK_SYNTAX_RESULT_IRRECOVERABLE_ERROR: JSCCheckSyntaxResult = 2; +pub const JSC_CHECK_SYNTAX_RESULT_UNTERMINATED_LITERAL_ERROR: JSCCheckSyntaxResult = 3; +pub const JSC_CHECK_SYNTAX_RESULT_OUT_OF_MEMORY_ERROR: JSCCheckSyntaxResult = 4; +pub const JSC_CHECK_SYNTAX_RESULT_STACK_OVERFLOW_ERROR: JSCCheckSyntaxResult = 5; + +pub type JSCOptionType = c_int; +pub const JSC_OPTION_BOOLEAN: JSCOptionType = 0; +pub const JSC_OPTION_INT: JSCOptionType = 1; +pub const JSC_OPTION_UINT: JSCOptionType = 2; +pub const JSC_OPTION_SIZE: JSCOptionType = 3; +pub const JSC_OPTION_DOUBLE: JSCOptionType = 4; +pub const JSC_OPTION_STRING: JSCOptionType = 5; +pub const JSC_OPTION_RANGE_STRING: JSCOptionType = 6; + +// Constants +pub const JSC_MAJOR_VERSION: c_int = 2; +pub const JSC_MICRO_VERSION: c_int = 0; +pub const JSC_MINOR_VERSION: c_int = 34; +pub const JSC_OPTIONS_USE_DFG: *const c_char = b"useDFGJIT\0" as *const u8 as *const c_char; +pub const JSC_OPTIONS_USE_FTL: *const c_char = b"useFTLJIT\0" as *const u8 as *const c_char; +pub const JSC_OPTIONS_USE_JIT: *const c_char = b"useJIT\0" as *const u8 as *const c_char; +pub const JSC_OPTIONS_USE_LLINT: *const c_char = b"useLLInt\0" as *const u8 as *const c_char; + +// Flags +pub type JSCValuePropertyFlags = c_uint; +pub const JSC_VALUE_PROPERTY_CONFIGURABLE: JSCValuePropertyFlags = 1; +pub const JSC_VALUE_PROPERTY_ENUMERABLE: JSCValuePropertyFlags = 2; +pub const JSC_VALUE_PROPERTY_WRITABLE: JSCValuePropertyFlags = 4; + +// Callbacks +pub type JSCClassDeletePropertyFunction = Option< + unsafe extern "C" fn(*mut JSCClass, *mut JSCContext, gpointer, *const c_char) -> gboolean, +>; +pub type JSCClassEnumeratePropertiesFunction = + Option *mut *mut c_char>; +pub type JSCClassGetPropertyFunction = Option< + unsafe extern "C" fn(*mut JSCClass, *mut JSCContext, gpointer, *const c_char) -> *mut JSCValue, +>; +pub type JSCClassHasPropertyFunction = Option< + unsafe extern "C" fn(*mut JSCClass, *mut JSCContext, gpointer, *const c_char) -> gboolean, +>; +pub type JSCClassSetPropertyFunction = Option< + unsafe extern "C" fn( + *mut JSCClass, + *mut JSCContext, + gpointer, + *const c_char, + *mut JSCValue, + ) -> gboolean, +>; +pub type JSCExceptionHandler = + Option; +pub type JSCOptionsFunc = + Option gboolean>; + +// Records +#[repr(C)] +pub struct _JSCClassClass(c_void); + +pub type JSCClassClass = *mut _JSCClassClass; + +#[repr(C)] +#[derive(Copy, Clone)] +pub struct JSCClassVTable { + pub get_property: JSCClassGetPropertyFunction, + pub set_property: JSCClassSetPropertyFunction, + pub has_property: JSCClassHasPropertyFunction, + pub delete_property: JSCClassDeletePropertyFunction, + pub enumerate_properties: JSCClassEnumeratePropertiesFunction, + pub _jsc_reserved0: Option, + pub _jsc_reserved1: Option, + pub _jsc_reserved2: Option, + pub _jsc_reserved3: Option, +} + +impl ::std::fmt::Debug for JSCClassVTable { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + f.debug_struct(&format!("JSCClassVTable @ {:p}", self)) + .field("get_property", &self.get_property) + .field("set_property", &self.set_property) + .field("has_property", &self.has_property) + .field("delete_property", &self.delete_property) + .field("enumerate_properties", &self.enumerate_properties) + .field("_jsc_reserved0", &self._jsc_reserved0) + .field("_jsc_reserved1", &self._jsc_reserved1) + .field("_jsc_reserved2", &self._jsc_reserved2) + .field("_jsc_reserved3", &self._jsc_reserved3) + .finish() + } +} + +#[repr(C)] +#[derive(Copy, Clone)] +pub struct JSCContextClass { + pub parent_class: gobject::GObjectClass, + pub _jsc_reserved0: Option, + pub _jsc_reserved1: Option, + pub _jsc_reserved2: Option, + pub _jsc_reserved3: Option, +} + +impl ::std::fmt::Debug for JSCContextClass { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + f.debug_struct(&format!("JSCContextClass @ {:p}", self)) + .field("parent_class", &self.parent_class) + .field("_jsc_reserved0", &self._jsc_reserved0) + .field("_jsc_reserved1", &self._jsc_reserved1) + .field("_jsc_reserved2", &self._jsc_reserved2) + .field("_jsc_reserved3", &self._jsc_reserved3) + .finish() + } +} + +#[repr(C)] +pub struct _JSCContextPrivate(c_void); + +pub type JSCContextPrivate = *mut _JSCContextPrivate; + +#[repr(C)] +#[derive(Copy, Clone)] +pub struct JSCExceptionClass { + pub parent_class: gobject::GObjectClass, + pub _jsc_reserved0: Option, + pub _jsc_reserved1: Option, + pub _jsc_reserved2: Option, + pub _jsc_reserved3: Option, +} + +impl ::std::fmt::Debug for JSCExceptionClass { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + f.debug_struct(&format!("JSCExceptionClass @ {:p}", self)) + .field("parent_class", &self.parent_class) + .field("_jsc_reserved0", &self._jsc_reserved0) + .field("_jsc_reserved1", &self._jsc_reserved1) + .field("_jsc_reserved2", &self._jsc_reserved2) + .field("_jsc_reserved3", &self._jsc_reserved3) + .finish() + } +} + +#[repr(C)] +pub struct _JSCExceptionPrivate(c_void); + +pub type JSCExceptionPrivate = *mut _JSCExceptionPrivate; + +#[repr(C)] +#[derive(Copy, Clone)] +pub struct JSCValueClass { + pub parent_class: gobject::GObjectClass, + pub _jsc_reserved0: Option, + pub _jsc_reserved1: Option, + pub _jsc_reserved2: Option, + pub _jsc_reserved3: Option, +} + +impl ::std::fmt::Debug for JSCValueClass { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + f.debug_struct(&format!("JSCValueClass @ {:p}", self)) + .field("parent_class", &self.parent_class) + .field("_jsc_reserved0", &self._jsc_reserved0) + .field("_jsc_reserved1", &self._jsc_reserved1) + .field("_jsc_reserved2", &self._jsc_reserved2) + .field("_jsc_reserved3", &self._jsc_reserved3) + .finish() + } +} + +#[repr(C)] +pub struct _JSCValuePrivate(c_void); + +pub type JSCValuePrivate = *mut _JSCValuePrivate; + +#[repr(C)] +#[derive(Copy, Clone)] +pub struct JSCVirtualMachineClass { + pub parent_class: gobject::GObjectClass, + pub _jsc_reserved0: Option, + pub _jsc_reserved1: Option, + pub _jsc_reserved2: Option, + pub _jsc_reserved3: Option, +} + +impl ::std::fmt::Debug for JSCVirtualMachineClass { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + f.debug_struct(&format!("JSCVirtualMachineClass @ {:p}", self)) + .field("parent_class", &self.parent_class) + .field("_jsc_reserved0", &self._jsc_reserved0) + .field("_jsc_reserved1", &self._jsc_reserved1) + .field("_jsc_reserved2", &self._jsc_reserved2) + .field("_jsc_reserved3", &self._jsc_reserved3) + .finish() + } +} + +#[repr(C)] +pub struct _JSCVirtualMachinePrivate(c_void); + +pub type JSCVirtualMachinePrivate = *mut _JSCVirtualMachinePrivate; + +#[repr(C)] +#[derive(Copy, Clone)] +pub struct JSCWeakValueClass { + pub parent_class: gobject::GObjectClass, + pub _jsc_reserved0: Option, + pub _jsc_reserved1: Option, + pub _jsc_reserved2: Option, + pub _jsc_reserved3: Option, +} + +impl ::std::fmt::Debug for JSCWeakValueClass { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + f.debug_struct(&format!("JSCWeakValueClass @ {:p}", self)) + .field("parent_class", &self.parent_class) + .field("_jsc_reserved0", &self._jsc_reserved0) + .field("_jsc_reserved1", &self._jsc_reserved1) + .field("_jsc_reserved2", &self._jsc_reserved2) + .field("_jsc_reserved3", &self._jsc_reserved3) + .finish() + } +} + +#[repr(C)] +pub struct _JSCWeakValuePrivate(c_void); + +pub type JSCWeakValuePrivate = *mut _JSCWeakValuePrivate; + +// Classes +#[repr(C)] +pub struct JSCClass(c_void); + +impl ::std::fmt::Debug for JSCClass { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + f.debug_struct(&format!("JSCClass @ {:p}", self)).finish() + } +} + +#[repr(C)] +#[derive(Copy, Clone)] +pub struct JSCContext { + pub parent: gobject::GObject, + pub priv_: *mut JSCContextPrivate, +} + +impl ::std::fmt::Debug for JSCContext { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + f.debug_struct(&format!("JSCContext @ {:p}", self)) + .field("parent", &self.parent) + .finish() + } +} + +#[repr(C)] +#[derive(Copy, Clone)] +pub struct JSCException { + pub parent: gobject::GObject, + pub priv_: *mut JSCExceptionPrivate, +} + +impl ::std::fmt::Debug for JSCException { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + f.debug_struct(&format!("JSCException @ {:p}", self)) + .field("parent", &self.parent) + .finish() + } +} + +#[repr(C)] +#[derive(Copy, Clone)] +pub struct JSCValue { + pub parent: gobject::GObject, + pub priv_: *mut JSCValuePrivate, +} + +impl ::std::fmt::Debug for JSCValue { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + f.debug_struct(&format!("JSCValue @ {:p}", self)) + .field("parent", &self.parent) + .finish() + } +} + +#[repr(C)] +#[derive(Copy, Clone)] +pub struct JSCVirtualMachine { + pub parent: gobject::GObject, + pub priv_: *mut JSCVirtualMachinePrivate, +} + +impl ::std::fmt::Debug for JSCVirtualMachine { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + f.debug_struct(&format!("JSCVirtualMachine @ {:p}", self)) + .field("parent", &self.parent) + .finish() + } +} + +#[repr(C)] +#[derive(Copy, Clone)] +pub struct JSCWeakValue { + pub parent: gobject::GObject, + pub priv_: *mut JSCWeakValuePrivate, +} + +impl ::std::fmt::Debug for JSCWeakValue { + fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + f.debug_struct(&format!("JSCWeakValue @ {:p}", self)) + .field("parent", &self.parent) + .finish() + } +} + +#[link(name = "javascriptcoregtk-4.0")] +extern "C" { + + //========================================================================= + // JSCClass + //========================================================================= + pub fn jsc_class_get_type() -> GType; + pub fn jsc_class_add_constructor( + jsc_class: *mut JSCClass, + name: *const c_char, + callback: gobject::GCallback, + user_data: gpointer, + destroy_notify: glib::GDestroyNotify, + return_type: GType, + n_params: c_uint, + ... + ) -> *mut JSCValue; + pub fn jsc_class_add_constructor_variadic( + jsc_class: *mut JSCClass, + name: *const c_char, + callback: gobject::GCallback, + user_data: gpointer, + destroy_notify: glib::GDestroyNotify, + return_type: GType, + ) -> *mut JSCValue; + pub fn jsc_class_add_constructorv( + jsc_class: *mut JSCClass, + name: *const c_char, + callback: gobject::GCallback, + user_data: gpointer, + destroy_notify: glib::GDestroyNotify, + return_type: GType, + n_parameters: c_uint, + parameter_types: *mut GType, + ) -> *mut JSCValue; + pub fn jsc_class_add_method( + jsc_class: *mut JSCClass, + name: *const c_char, + callback: gobject::GCallback, + user_data: gpointer, + destroy_notify: glib::GDestroyNotify, + return_type: GType, + n_params: c_uint, + ... + ); + pub fn jsc_class_add_method_variadic( + jsc_class: *mut JSCClass, + name: *const c_char, + callback: gobject::GCallback, + user_data: gpointer, + destroy_notify: glib::GDestroyNotify, + return_type: GType, + ); + pub fn jsc_class_add_methodv( + jsc_class: *mut JSCClass, + name: *const c_char, + callback: gobject::GCallback, + user_data: gpointer, + destroy_notify: glib::GDestroyNotify, + return_type: GType, + n_parameters: c_uint, + parameter_types: *mut GType, + ); + pub fn jsc_class_add_property( + jsc_class: *mut JSCClass, + name: *const c_char, + property_type: GType, + getter: gobject::GCallback, + setter: gobject::GCallback, + user_data: gpointer, + destroy_notify: glib::GDestroyNotify, + ); + pub fn jsc_class_get_name(jsc_class: *mut JSCClass) -> *const c_char; + pub fn jsc_class_get_parent(jsc_class: *mut JSCClass) -> *mut JSCClass; + + //========================================================================= + // JSCContext + //========================================================================= + pub fn jsc_context_get_type() -> GType; + pub fn jsc_context_new() -> *mut JSCContext; + pub fn jsc_context_new_with_virtual_machine(vm: *mut JSCVirtualMachine) -> *mut JSCContext; + pub fn jsc_context_get_current() -> *mut JSCContext; + pub fn jsc_context_check_syntax( + context: *mut JSCContext, + code: *const c_char, + length: ssize_t, + mode: JSCCheckSyntaxMode, + uri: *const c_char, + line_number: c_uint, + exception: *mut *mut JSCException, + ) -> JSCCheckSyntaxResult; + pub fn jsc_context_clear_exception(context: *mut JSCContext); + pub fn jsc_context_evaluate( + context: *mut JSCContext, + code: *const c_char, + length: ssize_t, + ) -> *mut JSCValue; + pub fn jsc_context_evaluate_in_object( + context: *mut JSCContext, + code: *const c_char, + length: ssize_t, + object_instance: gpointer, + object_class: *mut JSCClass, + uri: *const c_char, + line_number: c_uint, + object: *mut *mut JSCValue, + ) -> *mut JSCValue; + pub fn jsc_context_evaluate_with_source_uri( + context: *mut JSCContext, + code: *const c_char, + length: ssize_t, + uri: *const c_char, + line_number: c_uint, + ) -> *mut JSCValue; + pub fn jsc_context_get_exception(context: *mut JSCContext) -> *mut JSCException; + pub fn jsc_context_get_global_object(context: *mut JSCContext) -> *mut JSCValue; + pub fn jsc_context_get_value(context: *mut JSCContext, name: *const c_char) -> *mut JSCValue; + pub fn jsc_context_get_virtual_machine(context: *mut JSCContext) -> *mut JSCVirtualMachine; + pub fn jsc_context_pop_exception_handler(context: *mut JSCContext); + pub fn jsc_context_push_exception_handler( + context: *mut JSCContext, + handler: JSCExceptionHandler, + user_data: gpointer, + destroy_notify: glib::GDestroyNotify, + ); + pub fn jsc_context_register_class( + context: *mut JSCContext, + name: *const c_char, + parent_class: *mut JSCClass, + vtable: *mut JSCClassVTable, + destroy_notify: glib::GDestroyNotify, + ) -> *mut JSCClass; + pub fn jsc_context_set_value( + context: *mut JSCContext, + name: *const c_char, + value: *mut JSCValue, + ); + pub fn jsc_context_throw(context: *mut JSCContext, error_message: *const c_char); + pub fn jsc_context_throw_exception(context: *mut JSCContext, exception: *mut JSCException); + pub fn jsc_context_throw_printf(context: *mut JSCContext, format: *const c_char, ...); + pub fn jsc_context_throw_with_name( + context: *mut JSCContext, + error_name: *const c_char, + error_message: *const c_char, + ); + pub fn jsc_context_throw_with_name_printf( + context: *mut JSCContext, + error_name: *const c_char, + format: *const c_char, + ... + ); + + //========================================================================= + // JSCException + //========================================================================= + pub fn jsc_exception_get_type() -> GType; + pub fn jsc_exception_new(context: *mut JSCContext, message: *const c_char) + -> *mut JSCException; + pub fn jsc_exception_new_printf( + context: *mut JSCContext, + format: *const c_char, + ... + ) -> *mut JSCException; + //pub fn jsc_exception_new_vprintf(context: *mut JSCContext, format: *const c_char, args: /*Unimplemented*/va_list) -> *mut JSCException; + pub fn jsc_exception_new_with_name( + context: *mut JSCContext, + name: *const c_char, + message: *const c_char, + ) -> *mut JSCException; + pub fn jsc_exception_new_with_name_printf( + context: *mut JSCContext, + name: *const c_char, + format: *const c_char, + ... + ) -> *mut JSCException; + //pub fn jsc_exception_new_with_name_vprintf(context: *mut JSCContext, name: *const c_char, format: *const c_char, args: /*Unimplemented*/va_list) -> *mut JSCException; + pub fn jsc_exception_get_backtrace_string(exception: *mut JSCException) -> *const c_char; + pub fn jsc_exception_get_column_number(exception: *mut JSCException) -> c_uint; + pub fn jsc_exception_get_line_number(exception: *mut JSCException) -> c_uint; + pub fn jsc_exception_get_message(exception: *mut JSCException) -> *const c_char; + pub fn jsc_exception_get_name(exception: *mut JSCException) -> *const c_char; + pub fn jsc_exception_get_source_uri(exception: *mut JSCException) -> *const c_char; + pub fn jsc_exception_report(exception: *mut JSCException) -> *mut c_char; + pub fn jsc_exception_to_string(exception: *mut JSCException) -> *mut c_char; + + //========================================================================= + // JSCValue + //========================================================================= + pub fn jsc_value_get_type() -> GType; + pub fn jsc_value_new_array( + context: *mut JSCContext, + first_item_type: GType, + ... + ) -> *mut JSCValue; + pub fn jsc_value_new_array_from_garray( + context: *mut JSCContext, + array: *mut glib::GPtrArray, + ) -> *mut JSCValue; + pub fn jsc_value_new_array_from_strv( + context: *mut JSCContext, + strv: *const *const c_char, + ) -> *mut JSCValue; + pub fn jsc_value_new_boolean(context: *mut JSCContext, value: gboolean) -> *mut JSCValue; + #[cfg(any(feature = "v2_28", feature = "dox"))] + #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_28")))] + pub fn jsc_value_new_from_json(context: *mut JSCContext, json: *const c_char) -> *mut JSCValue; + pub fn jsc_value_new_function( + context: *mut JSCContext, + name: *const c_char, + callback: gobject::GCallback, + user_data: gpointer, + destroy_notify: glib::GDestroyNotify, + return_type: GType, + n_params: c_uint, + ... + ) -> *mut JSCValue; + pub fn jsc_value_new_function_variadic( + context: *mut JSCContext, + name: *const c_char, + callback: gobject::GCallback, + user_data: gpointer, + destroy_notify: glib::GDestroyNotify, + return_type: GType, + ) -> *mut JSCValue; + pub fn jsc_value_new_functionv( + context: *mut JSCContext, + name: *const c_char, + callback: gobject::GCallback, + user_data: gpointer, + destroy_notify: glib::GDestroyNotify, + return_type: GType, + n_parameters: c_uint, + parameter_types: *mut GType, + ) -> *mut JSCValue; + pub fn jsc_value_new_null(context: *mut JSCContext) -> *mut JSCValue; + pub fn jsc_value_new_number(context: *mut JSCContext, number: c_double) -> *mut JSCValue; + pub fn jsc_value_new_object( + context: *mut JSCContext, + instance: gpointer, + jsc_class: *mut JSCClass, + ) -> *mut JSCValue; + pub fn jsc_value_new_string(context: *mut JSCContext, string: *const c_char) -> *mut JSCValue; + pub fn jsc_value_new_string_from_bytes( + context: *mut JSCContext, + bytes: *mut glib::GBytes, + ) -> *mut JSCValue; + pub fn jsc_value_new_undefined(context: *mut JSCContext) -> *mut JSCValue; + pub fn jsc_value_constructor_call( + value: *mut JSCValue, + first_parameter_type: GType, + ... + ) -> *mut JSCValue; + pub fn jsc_value_constructor_callv( + value: *mut JSCValue, + n_parameters: c_uint, + parameters: *mut *mut JSCValue, + ) -> *mut JSCValue; + pub fn jsc_value_function_call( + value: *mut JSCValue, + first_parameter_type: GType, + ... + ) -> *mut JSCValue; + pub fn jsc_value_function_callv( + value: *mut JSCValue, + n_parameters: c_uint, + parameters: *mut *mut JSCValue, + ) -> *mut JSCValue; + pub fn jsc_value_get_context(value: *mut JSCValue) -> *mut JSCContext; + pub fn jsc_value_is_array(value: *mut JSCValue) -> gboolean; + pub fn jsc_value_is_boolean(value: *mut JSCValue) -> gboolean; + pub fn jsc_value_is_constructor(value: *mut JSCValue) -> gboolean; + pub fn jsc_value_is_function(value: *mut JSCValue) -> gboolean; + pub fn jsc_value_is_null(value: *mut JSCValue) -> gboolean; + pub fn jsc_value_is_number(value: *mut JSCValue) -> gboolean; + pub fn jsc_value_is_object(value: *mut JSCValue) -> gboolean; + pub fn jsc_value_is_string(value: *mut JSCValue) -> gboolean; + pub fn jsc_value_is_undefined(value: *mut JSCValue) -> gboolean; + pub fn jsc_value_object_define_property_accessor( + value: *mut JSCValue, + property_name: *const c_char, + flags: JSCValuePropertyFlags, + property_type: GType, + getter: gobject::GCallback, + setter: gobject::GCallback, + user_data: gpointer, + destroy_notify: glib::GDestroyNotify, + ); + pub fn jsc_value_object_define_property_data( + value: *mut JSCValue, + property_name: *const c_char, + flags: JSCValuePropertyFlags, + property_value: *mut JSCValue, + ); + pub fn jsc_value_object_delete_property(value: *mut JSCValue, name: *const c_char) -> gboolean; + pub fn jsc_value_object_enumerate_properties(value: *mut JSCValue) -> *mut *mut c_char; + pub fn jsc_value_object_get_property( + value: *mut JSCValue, + name: *const c_char, + ) -> *mut JSCValue; + pub fn jsc_value_object_get_property_at_index( + value: *mut JSCValue, + index: c_uint, + ) -> *mut JSCValue; + pub fn jsc_value_object_has_property(value: *mut JSCValue, name: *const c_char) -> gboolean; + pub fn jsc_value_object_invoke_method( + value: *mut JSCValue, + name: *const c_char, + first_parameter_type: GType, + ... + ) -> *mut JSCValue; + pub fn jsc_value_object_invoke_methodv( + value: *mut JSCValue, + name: *const c_char, + n_parameters: c_uint, + parameters: *mut *mut JSCValue, + ) -> *mut JSCValue; + pub fn jsc_value_object_is_instance_of(value: *mut JSCValue, name: *const c_char) -> gboolean; + pub fn jsc_value_object_set_property( + value: *mut JSCValue, + name: *const c_char, + property: *mut JSCValue, + ); + pub fn jsc_value_object_set_property_at_index( + value: *mut JSCValue, + index: c_uint, + property: *mut JSCValue, + ); + pub fn jsc_value_to_boolean(value: *mut JSCValue) -> gboolean; + pub fn jsc_value_to_double(value: *mut JSCValue) -> c_double; + pub fn jsc_value_to_int32(value: *mut JSCValue) -> i32; + #[cfg(any(feature = "v2_28", feature = "dox"))] + #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_28")))] + pub fn jsc_value_to_json(value: *mut JSCValue, indent: c_uint) -> *mut c_char; + pub fn jsc_value_to_string(value: *mut JSCValue) -> *mut c_char; + pub fn jsc_value_to_string_as_bytes(value: *mut JSCValue) -> *mut glib::GBytes; + + //========================================================================= + // JSCVirtualMachine + //========================================================================= + pub fn jsc_virtual_machine_get_type() -> GType; + pub fn jsc_virtual_machine_new() -> *mut JSCVirtualMachine; + + //========================================================================= + // JSCWeakValue + //========================================================================= + pub fn jsc_weak_value_get_type() -> GType; + pub fn jsc_weak_value_new(value: *mut JSCValue) -> *mut JSCWeakValue; + pub fn jsc_weak_value_get_value(weak_value: *mut JSCWeakValue) -> *mut JSCValue; + + //========================================================================= + // Other functions + //========================================================================= + pub fn jsc_get_major_version() -> c_uint; + pub fn jsc_get_micro_version() -> c_uint; + pub fn jsc_get_minor_version() -> c_uint; + pub fn jsc_options_foreach(function: JSCOptionsFunc, user_data: gpointer); + pub fn jsc_options_get_boolean(option: *const c_char, value: *mut gboolean) -> gboolean; + pub fn jsc_options_get_double(option: *const c_char, value: *mut c_double) -> gboolean; + pub fn jsc_options_get_int(option: *const c_char, value: *mut c_int) -> gboolean; + pub fn jsc_options_get_option_group() -> *mut glib::GOptionGroup; + pub fn jsc_options_get_range_string(option: *const c_char, value: *mut *mut c_char) + -> gboolean; + pub fn jsc_options_get_size(option: *const c_char, value: *mut size_t) -> gboolean; + pub fn jsc_options_get_string(option: *const c_char, value: *mut *mut c_char) -> gboolean; + pub fn jsc_options_get_uint(option: *const c_char, value: *mut c_uint) -> gboolean; + pub fn jsc_options_set_boolean(option: *const c_char, value: gboolean) -> gboolean; + pub fn jsc_options_set_double(option: *const c_char, value: c_double) -> gboolean; + pub fn jsc_options_set_int(option: *const c_char, value: c_int) -> gboolean; + pub fn jsc_options_set_range_string(option: *const c_char, value: *const c_char) -> gboolean; + pub fn jsc_options_set_size(option: *const c_char, value: size_t) -> gboolean; + pub fn jsc_options_set_string(option: *const c_char, value: *const c_char) -> gboolean; + pub fn jsc_options_set_uint(option: *const c_char, value: c_uint) -> gboolean; -extern "C" { - pub fn JSValueIsBoolean(ctx: JSGlobalContextRef, value: JSValueRef) -> u8; - pub fn JSValueIsNull(ctx: JSGlobalContextRef, value: JSValueRef) -> u8; - pub fn JSValueIsUndefined(ctx: JSGlobalContextRef, value: JSValueRef) -> u8; - pub fn JSValueIsNumber(ctx: JSGlobalContextRef, value: JSValueRef) -> u8; - pub fn JSValueIsString(ctx: JSGlobalContextRef, value: JSValueRef) -> u8; - pub fn JSValueIsObject(ctx: JSGlobalContextRef, value: JSValueRef) -> u8; - pub fn JSValueIsArray(ctx: JSGlobalContextRef, value: JSValueRef) -> u8; - pub fn JSValueIsDate(ctx: JSGlobalContextRef, value: JSValueRef) -> u8; - pub fn JSValueToNumber(ctx: JSGlobalContextRef, value: JSValueRef, exception: *mut JSValueRef) -> c_double; - pub fn JSValueToBoolean(ctx: JSGlobalContextRef, value: JSValueRef) -> u8; - pub fn JSValueToStringCopy(ctx: JSGlobalContextRef, value: JSValueRef, exception: *mut JSValueRef) -> JSStringRef; - pub fn JSStringRelease(string: JSStringRef); - pub fn JSStringGetMaximumUTF8CStringSize(string: JSStringRef) -> usize; - pub fn JSStringGetUTF8CString(string: JSStringRef, buffer: *mut c_char, buffer_size: usize) -> usize; } diff --git a/javascriptcore-sys/tests/abi.rs b/javascriptcore-sys/tests/abi.rs new file mode 100644 index 0000000..79398e1 --- /dev/null +++ b/javascriptcore-sys/tests/abi.rs @@ -0,0 +1,349 @@ +// Generated by gir (https://github.com/gtk-rs/gir @ 05fe12c0b7e7) +// from ../gir-files (@ fc4e8657c758) +// DO NOT EDIT + +use javascriptcore_sys::*; +use std::env; +use std::error::Error; +use std::ffi::OsString; +use std::mem::{align_of, size_of}; +use std::path::Path; +use std::process::Command; +use std::str; +use tempfile::Builder; + +static PACKAGES: &[&str] = &["javascriptcoregtk-4.0"]; + +#[derive(Clone, Debug)] +struct Compiler { + pub args: Vec, +} + +impl Compiler { + pub fn new() -> Result> { + let mut args = get_var("CC", "cc")?; + args.push("-Wno-deprecated-declarations".to_owned()); + // For _Generic + args.push("-std=c11".to_owned()); + // For %z support in printf when using MinGW. + args.push("-D__USE_MINGW_ANSI_STDIO".to_owned()); + args.extend(get_var("CFLAGS", "")?); + args.extend(get_var("CPPFLAGS", "")?); + args.extend(pkg_config_cflags(PACKAGES)?); + Ok(Self { args }) + } + + pub fn compile(&self, src: &Path, out: &Path) -> Result<(), Box> { + let mut cmd = self.to_command(); + cmd.arg(src); + cmd.arg("-o"); + cmd.arg(out); + let status = cmd.spawn()?.wait()?; + if !status.success() { + return Err(format!("compilation command {:?} failed, {}", &cmd, status).into()); + } + Ok(()) + } + + fn to_command(&self) -> Command { + let mut cmd = Command::new(&self.args[0]); + cmd.args(&self.args[1..]); + cmd + } +} + +fn get_var(name: &str, default: &str) -> Result, Box> { + match env::var(name) { + Ok(value) => Ok(shell_words::split(&value)?), + Err(env::VarError::NotPresent) => Ok(shell_words::split(default)?), + Err(err) => Err(format!("{} {}", name, err).into()), + } +} + +fn pkg_config_cflags(packages: &[&str]) -> Result, Box> { + if packages.is_empty() { + return Ok(Vec::new()); + } + let pkg_config = env::var_os("PKG_CONFIG").unwrap_or_else(|| OsString::from("pkg-config")); + let mut cmd = Command::new(pkg_config); + cmd.arg("--cflags"); + cmd.args(packages); + let out = cmd.output()?; + if !out.status.success() { + return Err(format!("command {:?} returned {}", &cmd, out.status).into()); + } + let stdout = str::from_utf8(&out.stdout)?; + Ok(shell_words::split(stdout.trim())?) +} + +#[derive(Copy, Clone, Debug, Eq, PartialEq)] +struct Layout { + size: usize, + alignment: usize, +} + +#[derive(Copy, Clone, Debug, Default, Eq, PartialEq)] +struct Results { + /// Number of successfully completed tests. + passed: usize, + /// Total number of failed tests (including those that failed to compile). + failed: usize, +} + +impl Results { + fn record_passed(&mut self) { + self.passed += 1; + } + fn record_failed(&mut self) { + self.failed += 1; + } + fn summary(&self) -> String { + format!("{} passed; {} failed", self.passed, self.failed) + } + fn expect_total_success(&self) { + if self.failed == 0 { + println!("OK: {}", self.summary()); + } else { + panic!("FAILED: {}", self.summary()); + }; + } +} + +#[test] +fn cross_validate_constants_with_c() { + let mut c_constants: Vec<(String, String)> = Vec::new(); + + for l in get_c_output("constant").unwrap().lines() { + let mut words = l.trim().split(';'); + let name = words.next().expect("Failed to parse name").to_owned(); + let value = words + .next() + .and_then(|s| s.parse().ok()) + .expect("Failed to parse value"); + c_constants.push((name, value)); + } + + let mut results = Results::default(); + + for ((rust_name, rust_value), (c_name, c_value)) in + RUST_CONSTANTS.iter().zip(c_constants.iter()) + { + if rust_name != c_name { + results.record_failed(); + eprintln!("Name mismatch:\nRust: {:?}\nC: {:?}", rust_name, c_name,); + continue; + } + + if rust_value != c_value { + results.record_failed(); + eprintln!( + "Constant value mismatch for {}\nRust: {:?}\nC: {:?}", + rust_name, rust_value, &c_value + ); + continue; + } + + results.record_passed(); + } + + results.expect_total_success(); +} + +#[test] +fn cross_validate_layout_with_c() { + let mut c_layouts = Vec::new(); + + for l in get_c_output("layout").unwrap().lines() { + let mut words = l.trim().split(';'); + let name = words.next().expect("Failed to parse name").to_owned(); + let size = words + .next() + .and_then(|s| s.parse().ok()) + .expect("Failed to parse size"); + let alignment = words + .next() + .and_then(|s| s.parse().ok()) + .expect("Failed to parse alignment"); + c_layouts.push((name, Layout { size, alignment })); + } + + let mut results = Results::default(); + + for ((rust_name, rust_layout), (c_name, c_layout)) in RUST_LAYOUTS.iter().zip(c_layouts.iter()) + { + if rust_name != c_name { + results.record_failed(); + eprintln!("Name mismatch:\nRust: {:?}\nC: {:?}", rust_name, c_name,); + continue; + } + + if rust_layout != c_layout { + results.record_failed(); + eprintln!( + "Layout mismatch for {}\nRust: {:?}\nC: {:?}", + rust_name, rust_layout, &c_layout + ); + continue; + } + + results.record_passed(); + } + + results.expect_total_success(); +} + +fn get_c_output(name: &str) -> Result> { + let tmpdir = Builder::new().prefix("abi").tempdir()?; + let exe = tmpdir.path().join(name); + let c_file = Path::new("tests").join(name).with_extension("c"); + + let cc = Compiler::new().expect("configured compiler"); + cc.compile(&c_file, &exe)?; + + let mut abi_cmd = Command::new(exe); + let output = abi_cmd.output()?; + if !output.status.success() { + return Err(format!("command {:?} failed, {:?}", &abi_cmd, &output).into()); + } + + Ok(String::from_utf8(output.stdout)?) +} + +const RUST_LAYOUTS: &[(&str, Layout)] = &[ + ( + "JSCCheckSyntaxMode", + Layout { + size: size_of::(), + alignment: align_of::(), + }, + ), + ( + "JSCCheckSyntaxResult", + Layout { + size: size_of::(), + alignment: align_of::(), + }, + ), + ( + "JSCClassVTable", + Layout { + size: size_of::(), + alignment: align_of::(), + }, + ), + ( + "JSCContext", + Layout { + size: size_of::(), + alignment: align_of::(), + }, + ), + ( + "JSCContextClass", + Layout { + size: size_of::(), + alignment: align_of::(), + }, + ), + ( + "JSCException", + Layout { + size: size_of::(), + alignment: align_of::(), + }, + ), + ( + "JSCExceptionClass", + Layout { + size: size_of::(), + alignment: align_of::(), + }, + ), + ( + "JSCOptionType", + Layout { + size: size_of::(), + alignment: align_of::(), + }, + ), + ( + "JSCValue", + Layout { + size: size_of::(), + alignment: align_of::(), + }, + ), + ( + "JSCValueClass", + Layout { + size: size_of::(), + alignment: align_of::(), + }, + ), + ( + "JSCValuePropertyFlags", + Layout { + size: size_of::(), + alignment: align_of::(), + }, + ), + ( + "JSCVirtualMachine", + Layout { + size: size_of::(), + alignment: align_of::(), + }, + ), + ( + "JSCVirtualMachineClass", + Layout { + size: size_of::(), + alignment: align_of::(), + }, + ), + ( + "JSCWeakValue", + Layout { + size: size_of::(), + alignment: align_of::(), + }, + ), + ( + "JSCWeakValueClass", + Layout { + size: size_of::(), + alignment: align_of::(), + }, + ), +]; + +const RUST_CONSTANTS: &[(&str, &str)] = &[ + ("(gint) JSC_CHECK_SYNTAX_MODE_MODULE", "1"), + ("(gint) JSC_CHECK_SYNTAX_MODE_SCRIPT", "0"), + ("(gint) JSC_CHECK_SYNTAX_RESULT_IRRECOVERABLE_ERROR", "2"), + ("(gint) JSC_CHECK_SYNTAX_RESULT_OUT_OF_MEMORY_ERROR", "4"), + ("(gint) JSC_CHECK_SYNTAX_RESULT_RECOVERABLE_ERROR", "1"), + ("(gint) JSC_CHECK_SYNTAX_RESULT_STACK_OVERFLOW_ERROR", "5"), + ("(gint) JSC_CHECK_SYNTAX_RESULT_SUCCESS", "0"), + ( + "(gint) JSC_CHECK_SYNTAX_RESULT_UNTERMINATED_LITERAL_ERROR", + "3", + ), + ("JSC_MAJOR_VERSION", "2"), + ("JSC_MICRO_VERSION", "0"), + ("JSC_MINOR_VERSION", "34"), + ("JSC_OPTIONS_USE_DFG", "useDFGJIT"), + ("JSC_OPTIONS_USE_FTL", "useFTLJIT"), + ("JSC_OPTIONS_USE_JIT", "useJIT"), + ("JSC_OPTIONS_USE_LLINT", "useLLInt"), + ("(gint) JSC_OPTION_BOOLEAN", "0"), + ("(gint) JSC_OPTION_DOUBLE", "4"), + ("(gint) JSC_OPTION_INT", "1"), + ("(gint) JSC_OPTION_RANGE_STRING", "6"), + ("(gint) JSC_OPTION_SIZE", "3"), + ("(gint) JSC_OPTION_STRING", "5"), + ("(gint) JSC_OPTION_UINT", "2"), + ("(guint) JSC_VALUE_PROPERTY_CONFIGURABLE", "1"), + ("(guint) JSC_VALUE_PROPERTY_ENUMERABLE", "2"), + ("(guint) JSC_VALUE_PROPERTY_WRITABLE", "4"), +]; diff --git a/javascriptcore-sys/tests/constant.c b/javascriptcore-sys/tests/constant.c new file mode 100644 index 0000000..da0ceaf --- /dev/null +++ b/javascriptcore-sys/tests/constant.c @@ -0,0 +1,57 @@ +// Generated by gir (https://github.com/gtk-rs/gir @ 05fe12c0b7e7) +// from ../gir-files (@ fc4e8657c758) +// DO NOT EDIT + +#include "manual.h" +#include + +#define PRINT_CONSTANT(CONSTANT_NAME) \ + printf("%s;", #CONSTANT_NAME); \ + printf(_Generic((CONSTANT_NAME), \ + char *: "%s", \ + const char *: "%s", \ + char: "%c", \ + signed char: "%hhd", \ + unsigned char: "%hhu", \ + short int: "%hd", \ + unsigned short int: "%hu", \ + int: "%d", \ + unsigned int: "%u", \ + long: "%ld", \ + unsigned long: "%lu", \ + long long: "%lld", \ + unsigned long long: "%llu", \ + float: "%f", \ + double: "%f", \ + long double: "%ld"), \ + CONSTANT_NAME); \ + printf("\n"); + +int main() { + PRINT_CONSTANT((gint) JSC_CHECK_SYNTAX_MODE_MODULE); + PRINT_CONSTANT((gint) JSC_CHECK_SYNTAX_MODE_SCRIPT); + PRINT_CONSTANT((gint) JSC_CHECK_SYNTAX_RESULT_IRRECOVERABLE_ERROR); + PRINT_CONSTANT((gint) JSC_CHECK_SYNTAX_RESULT_OUT_OF_MEMORY_ERROR); + PRINT_CONSTANT((gint) JSC_CHECK_SYNTAX_RESULT_RECOVERABLE_ERROR); + PRINT_CONSTANT((gint) JSC_CHECK_SYNTAX_RESULT_STACK_OVERFLOW_ERROR); + PRINT_CONSTANT((gint) JSC_CHECK_SYNTAX_RESULT_SUCCESS); + PRINT_CONSTANT((gint) JSC_CHECK_SYNTAX_RESULT_UNTERMINATED_LITERAL_ERROR); + PRINT_CONSTANT(JSC_MAJOR_VERSION); + PRINT_CONSTANT(JSC_MICRO_VERSION); + PRINT_CONSTANT(JSC_MINOR_VERSION); + PRINT_CONSTANT(JSC_OPTIONS_USE_DFG); + PRINT_CONSTANT(JSC_OPTIONS_USE_FTL); + PRINT_CONSTANT(JSC_OPTIONS_USE_JIT); + PRINT_CONSTANT(JSC_OPTIONS_USE_LLINT); + PRINT_CONSTANT((gint) JSC_OPTION_BOOLEAN); + PRINT_CONSTANT((gint) JSC_OPTION_DOUBLE); + PRINT_CONSTANT((gint) JSC_OPTION_INT); + PRINT_CONSTANT((gint) JSC_OPTION_RANGE_STRING); + PRINT_CONSTANT((gint) JSC_OPTION_SIZE); + PRINT_CONSTANT((gint) JSC_OPTION_STRING); + PRINT_CONSTANT((gint) JSC_OPTION_UINT); + PRINT_CONSTANT((guint) JSC_VALUE_PROPERTY_CONFIGURABLE); + PRINT_CONSTANT((guint) JSC_VALUE_PROPERTY_ENUMERABLE); + PRINT_CONSTANT((guint) JSC_VALUE_PROPERTY_WRITABLE); + return 0; +} diff --git a/javascriptcore-sys/tests/layout.c b/javascriptcore-sys/tests/layout.c new file mode 100644 index 0000000..a572450 --- /dev/null +++ b/javascriptcore-sys/tests/layout.c @@ -0,0 +1,26 @@ +// Generated by gir (https://github.com/gtk-rs/gir @ 05fe12c0b7e7) +// from ../gir-files (@ fc4e8657c758) +// DO NOT EDIT + +#include "manual.h" +#include +#include + +int main() { + printf("%s;%zu;%zu\n", "JSCCheckSyntaxMode", sizeof(JSCCheckSyntaxMode), alignof(JSCCheckSyntaxMode)); + printf("%s;%zu;%zu\n", "JSCCheckSyntaxResult", sizeof(JSCCheckSyntaxResult), alignof(JSCCheckSyntaxResult)); + printf("%s;%zu;%zu\n", "JSCClassVTable", sizeof(JSCClassVTable), alignof(JSCClassVTable)); + printf("%s;%zu;%zu\n", "JSCContext", sizeof(JSCContext), alignof(JSCContext)); + printf("%s;%zu;%zu\n", "JSCContextClass", sizeof(JSCContextClass), alignof(JSCContextClass)); + printf("%s;%zu;%zu\n", "JSCException", sizeof(JSCException), alignof(JSCException)); + printf("%s;%zu;%zu\n", "JSCExceptionClass", sizeof(JSCExceptionClass), alignof(JSCExceptionClass)); + printf("%s;%zu;%zu\n", "JSCOptionType", sizeof(JSCOptionType), alignof(JSCOptionType)); + printf("%s;%zu;%zu\n", "JSCValue", sizeof(JSCValue), alignof(JSCValue)); + printf("%s;%zu;%zu\n", "JSCValueClass", sizeof(JSCValueClass), alignof(JSCValueClass)); + printf("%s;%zu;%zu\n", "JSCValuePropertyFlags", sizeof(JSCValuePropertyFlags), alignof(JSCValuePropertyFlags)); + printf("%s;%zu;%zu\n", "JSCVirtualMachine", sizeof(JSCVirtualMachine), alignof(JSCVirtualMachine)); + printf("%s;%zu;%zu\n", "JSCVirtualMachineClass", sizeof(JSCVirtualMachineClass), alignof(JSCVirtualMachineClass)); + printf("%s;%zu;%zu\n", "JSCWeakValue", sizeof(JSCWeakValue), alignof(JSCWeakValue)); + printf("%s;%zu;%zu\n", "JSCWeakValueClass", sizeof(JSCWeakValueClass), alignof(JSCWeakValueClass)); + return 0; +} diff --git a/javascriptcore-sys/tests/manual.h b/javascriptcore-sys/tests/manual.h new file mode 100644 index 0000000..af550a7 --- /dev/null +++ b/javascriptcore-sys/tests/manual.h @@ -0,0 +1,3 @@ +// Feel free to edit this file, it won't be regenerated by gir generator unless removed. + +#include