cybrid_api_organization_ruby 0.117.27 → 0.117.29

data/vendor/bundle/ruby/3.2.0/gems/ffi-1.16.3/ext/ffi_c/Function.h

@@ -1,84 +0,0 @@
-/*
- * Copyright (c) 2009, Wayne Meissner
- *
- * Copyright (c) 2008-2013, Ruby FFI project contributors
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the Ruby FFI project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef RBFFI_FUNCTION_H
-#define	RBFFI_FUNCTION_H
-
-#ifdef	__cplusplus
-extern "C" {
-#endif
-
-# include <stdbool.h>
-
-#include <ffi.h>
-
-typedef struct FunctionType_ FunctionType;
-
-#include "Type.h"
-#include "Call.h"
-#include "ClosurePool.h"
-
-struct FunctionType_ {
-    Type type; /* The native type of a FunctionInfo object */
-    VALUE rbReturnType;
-    VALUE rbParameterTypes;
-
-    Type* returnType;
-    Type** parameterTypes;
-    NativeType* nativeParameterTypes;
-    ffi_type* ffiReturnType;
-    ffi_type** ffiParameterTypes;
-    ffi_cif ffi_cif;
-    Invoker invoke;
-    ClosurePool* closurePool;
-    int parameterCount;
-    int flags;
-    ffi_abi abi;
-    int callbackCount;
-    VALUE* callbackParameters;
-    VALUE rbEnums;
-    bool ignoreErrno;
-    bool blocking;
-    bool hasStruct;
-};
-
-extern const rb_data_type_t rbffi_fntype_data_type;
-extern VALUE rbffi_FunctionTypeClass, rbffi_FunctionClass;
-
-void rbffi_Function_Init(VALUE moduleFFI);
-VALUE rbffi_Function_NewInstance(VALUE functionInfo, VALUE proc);
-VALUE rbffi_Function_ForProc(VALUE cbInfo, VALUE proc);
-void rbffi_FunctionInfo_Init(VALUE moduleFFI);
-
-#ifdef	__cplusplus
-}
-#endif
-
-#endif	/* RBFFI_FUNCTION_H */
-

data/vendor/bundle/ruby/3.2.0/gems/ffi-1.16.3/ext/ffi_c/FunctionInfo.c

@@ -1,322 +0,0 @@
-/*
- * Copyright (c) 2009, Wayne Meissner
- * Copyright (C) 2009 Andrea Fazzi <andrea.fazzi@alcacoop.it>
- * Copyright (c) 2008-2013, Ruby FFI project contributors
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the Ruby FFI project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef _MSC_VER
-# include <sys/param.h>
-#endif
-#include <sys/types.h>
-#include <stdio.h>
-
-#include <stdint.h>
-#include <stdbool.h>
-
-#include <errno.h>
-#include <ruby.h>
-
-#include <ffi.h>
-#include "rbffi.h"
-#include "compat.h"
-
-#include "AbstractMemory.h"
-#include "Types.h"
-#include "Type.h"
-#include "StructByValue.h"
-#include "Function.h"
-
-static VALUE fntype_allocate(VALUE klass);
-static VALUE fntype_initialize(int argc, VALUE* argv, VALUE self);
-static void fntype_mark(void *);
-static void fntype_compact(void *);
-static void fntype_free(void *);
-static size_t fntype_memsize(const void *);
-
-const rb_data_type_t rbffi_fntype_data_type = { /* extern */
-    .wrap_struct_name = "FFI::FunctionType",
-    .function = {
-        .dmark = fntype_mark,
-        .dfree = fntype_free,
-        .dsize = fntype_memsize,
-        ffi_compact_callback( fntype_compact )
-    },
-    .parent = &rbffi_type_data_type,
-    // IMPORTANT: WB_PROTECTED objects must only use the RB_OBJ_WRITE()
-    // macro to update VALUE references, as to trigger write barriers.
-    .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | FFI_RUBY_TYPED_FROZEN_SHAREABLE
-};
-
-VALUE rbffi_FunctionTypeClass = Qnil;
-
-static VALUE
-fntype_allocate(VALUE klass)
-{
-    FunctionType* fnInfo;
-    VALUE obj = TypedData_Make_Struct(klass, FunctionType, &rbffi_fntype_data_type, fnInfo);
-
-    fnInfo->type.ffiType = &ffi_type_pointer;
-    fnInfo->type.nativeType = NATIVE_FUNCTION;
-    RB_OBJ_WRITE(obj, &fnInfo->rbReturnType, Qnil);
-    RB_OBJ_WRITE(obj, &fnInfo->rbParameterTypes, Qnil);
-    RB_OBJ_WRITE(obj, &fnInfo->rbEnums, Qnil);
-    fnInfo->invoke = rbffi_CallFunction;
-    fnInfo->closurePool = NULL;
-
-    return obj;
-}
-
-static void
-fntype_mark(void *data)
-{
-    FunctionType *fnInfo = (FunctionType *)data;
-    rb_gc_mark_movable(fnInfo->rbReturnType);
-    rb_gc_mark_movable(fnInfo->rbParameterTypes);
-    rb_gc_mark_movable(fnInfo->rbEnums);
-    if (fnInfo->callbackCount > 0 && fnInfo->callbackParameters != NULL) {
-        size_t index;
-        for (index = 0; index < fnInfo->callbackCount; index++) {
-            rb_gc_mark_movable(fnInfo->callbackParameters[index]);
-        }
-    }
-}
-
-static void
-fntype_compact(void *data)
-{
-    FunctionType *fnInfo = (FunctionType *)data;
-    ffi_gc_location(fnInfo->rbReturnType);
-    ffi_gc_location(fnInfo->rbParameterTypes);
-    ffi_gc_location(fnInfo->rbEnums);
-    if (fnInfo->callbackCount > 0 && fnInfo->callbackParameters != NULL) {
-        size_t index;
-        for (index = 0; index < fnInfo->callbackCount; index++) {
-            ffi_gc_location(fnInfo->callbackParameters[index]);
-        }
-    }
-}
-
-static void
-fntype_free(void *data)
-{
-    FunctionType *fnInfo = (FunctionType *)data;
-    xfree(fnInfo->parameterTypes);
-    xfree(fnInfo->ffiParameterTypes);
-    xfree(fnInfo->nativeParameterTypes);
-    xfree(fnInfo->callbackParameters);
-    if (fnInfo->closurePool != NULL) {
-        rbffi_ClosurePool_Free(fnInfo->closurePool);
-    }
-    xfree(fnInfo);
-}
-
-static size_t
-fntype_memsize(const void *data)
-{
-    const FunctionType *fnInfo = (const FunctionType *)data;
-
-    size_t memsize = sizeof(FunctionType);
-    memsize += fnInfo->callbackCount * sizeof(VALUE);
-
-    memsize += fnInfo->parameterCount * (
-        sizeof(*fnInfo->parameterTypes)
-        + sizeof(ffi_type *)
-        + sizeof(*fnInfo->nativeParameterTypes)
-    );
-
-    return memsize;
-}
-
-/*
- * call-seq: initialize(return_type, param_types, options={})
- * @param [Type, Symbol] return_type return type for the function
- * @param [Array<Type, Symbol>] param_types array of parameters types
- * @param [Hash] options
- * @option options [Boolean] :blocking set to true if the C function is a blocking call
- * @option options [Symbol] :convention calling convention see {FFI::Library#calling_convention}
- * @option options [FFI::Enums] :enums
- * @return [self]
- * A new FunctionType instance.
- */
-static VALUE
-fntype_initialize(int argc, VALUE* argv, VALUE self)
-{
-    FunctionType *fnInfo;
-    ffi_status status;
-    VALUE rbReturnType = Qnil, rbParamTypes = Qnil, rbOptions = Qnil;
-    VALUE rbEnums = Qnil, rbConvention = Qnil, rbBlocking = Qnil;
-#if defined(X86_WIN32)
-    VALUE rbConventionStr;
-#endif
-    int i, nargs;
-
-    nargs = rb_scan_args(argc, argv, "21", &rbReturnType, &rbParamTypes, &rbOptions);
-    if (nargs >= 3 && rbOptions != Qnil) {
-        rbConvention = rb_hash_aref(rbOptions, ID2SYM(rb_intern("convention")));
-        rbEnums = rb_hash_aref(rbOptions, ID2SYM(rb_intern("enums")));
-        rbBlocking = rb_hash_aref(rbOptions, ID2SYM(rb_intern("blocking")));
-    }
-
-    Check_Type(rbParamTypes, T_ARRAY);
-
-    TypedData_Get_Struct(self, FunctionType, &rbffi_fntype_data_type, fnInfo);
-    fnInfo->parameterCount = (int) RARRAY_LEN(rbParamTypes);
-    fnInfo->parameterTypes = xcalloc(fnInfo->parameterCount, sizeof(*fnInfo->parameterTypes));
-    fnInfo->ffiParameterTypes = xcalloc(fnInfo->parameterCount, sizeof(ffi_type *));
-    fnInfo->nativeParameterTypes = xcalloc(fnInfo->parameterCount, sizeof(*fnInfo->nativeParameterTypes));
-    RB_OBJ_WRITE(self, &fnInfo->rbParameterTypes, rb_ary_new2(fnInfo->parameterCount));
-    RB_OBJ_WRITE(self, &fnInfo->rbEnums, rbEnums);
-    fnInfo->blocking = RTEST(rbBlocking);
-    fnInfo->hasStruct = false;
-
-    for (i = 0; i < fnInfo->parameterCount; ++i) {
-        VALUE entry = rb_ary_entry(rbParamTypes, i);
-        VALUE type = rbffi_Type_Lookup(entry);
-
-        if (!RTEST(type)) {
-            VALUE typeName = rb_funcall2(entry, rb_intern("inspect"), 0, NULL);
-            rb_raise(rb_eTypeError, "Invalid parameter type (%s)", RSTRING_PTR(typeName));
-        }
-
-        if (rb_obj_is_kind_of(type, rbffi_FunctionTypeClass)) {
-            REALLOC_N(fnInfo->callbackParameters, VALUE, fnInfo->callbackCount + 1);
-            RB_OBJ_WRITE(self, &fnInfo->callbackParameters[fnInfo->callbackCount], type);
-            fnInfo->callbackCount++;
-        }
-
-        if (rb_obj_is_kind_of(type, rbffi_StructByValueClass)) {
-            fnInfo->hasStruct = true;
-        }
-
-        rb_ary_push(fnInfo->rbParameterTypes, type);
-        TypedData_Get_Struct(type, Type, &rbffi_type_data_type, fnInfo->parameterTypes[i]);
-        fnInfo->ffiParameterTypes[i] = fnInfo->parameterTypes[i]->ffiType;
-        fnInfo->nativeParameterTypes[i] = fnInfo->parameterTypes[i]->nativeType;
-    }
-
-    RB_OBJ_WRITE(self, &fnInfo->rbReturnType, rbffi_Type_Lookup(rbReturnType));
-    if (!RTEST(fnInfo->rbReturnType)) {
-        VALUE typeName = rb_funcall2(rbReturnType, rb_intern("inspect"), 0, NULL);
-        rb_raise(rb_eTypeError, "Invalid return type (%s)", RSTRING_PTR(typeName));
-    }
-
-    if (rb_obj_is_kind_of(fnInfo->rbReturnType, rbffi_StructByValueClass)) {
-        fnInfo->hasStruct = true;
-    }
-
-    TypedData_Get_Struct(fnInfo->rbReturnType, Type, &rbffi_type_data_type, fnInfo->returnType);
-    fnInfo->ffiReturnType = fnInfo->returnType->ffiType;
-
-#if defined(X86_WIN32)
-    rbConventionStr = (rbConvention != Qnil) ? rb_funcall2(rbConvention, rb_intern("to_s"), 0, NULL) : Qnil;
-    fnInfo->abi = (rbConventionStr != Qnil && strcmp(StringValueCStr(rbConventionStr), "stdcall") == 0)
-            ? FFI_STDCALL : FFI_DEFAULT_ABI;
-#else
-    fnInfo->abi = FFI_DEFAULT_ABI;
-#endif
-
-    status = ffi_prep_cif(&fnInfo->ffi_cif, fnInfo->abi, fnInfo->parameterCount,
-            fnInfo->ffiReturnType, fnInfo->ffiParameterTypes);
-    switch (status) {
-        case FFI_BAD_ABI:
-            rb_raise(rb_eArgError, "Invalid ABI specified");
-        case FFI_BAD_TYPEDEF:
-            rb_raise(rb_eArgError, "Invalid argument type specified");
-        case FFI_OK:
-            break;
-        default:
-            rb_raise(rb_eArgError, "Unknown FFI error");
-    }
-
-    fnInfo->invoke = rbffi_GetInvoker(fnInfo);
-
-    rb_obj_freeze(fnInfo->rbParameterTypes);
-    rb_obj_freeze(self);
-    return self;
-}
-
-/*
- * call-seq: return_type
- * @return [Type]
- * Get the return type of the function type
- */
-static VALUE
-fntype_return_type(VALUE self)
-{
-    FunctionType* ft;
-
-    TypedData_Get_Struct(self, FunctionType, &rbffi_fntype_data_type, ft);
-
-    return ft->rbReturnType;
-}
-
-/*
- * call-seq: param_types
- * @return [Array<Type>]
- * Get parameters types.
- */
-static VALUE
-fntype_param_types(VALUE self)
-{
-    FunctionType* ft;
-
-    TypedData_Get_Struct(self, FunctionType, &rbffi_fntype_data_type, ft);
-
-    return rb_ary_dup(ft->rbParameterTypes);
-}
-
-void
-rbffi_FunctionInfo_Init(VALUE moduleFFI)
-{
-    VALUE ffi_Type;
-
-    ffi_Type = rbffi_TypeClass;
-
-    /*
-     * Document-class: FFI::FunctionType < FFI::Type
-     */
-    rbffi_FunctionTypeClass = rb_define_class_under(moduleFFI, "FunctionType",ffi_Type);
-    rb_global_variable(&rbffi_FunctionTypeClass);
-    /*
-     * Document-const: FFI::CallbackInfo = FFI::FunctionType
-     */
-    rb_define_const(moduleFFI, "CallbackInfo", rbffi_FunctionTypeClass);
-    /*
-     * Document-const: FFI::FunctionInfo = FFI::FunctionType
-     */
-    rb_define_const(moduleFFI, "FunctionInfo", rbffi_FunctionTypeClass);
-    /*
-     * Document-const: FFI::Type::Function = FFI::FunctionType
-     */
-    rb_define_const(ffi_Type, "Function", rbffi_FunctionTypeClass);
-
-    rb_define_alloc_func(rbffi_FunctionTypeClass, fntype_allocate);
-    rb_define_method(rbffi_FunctionTypeClass, "initialize", fntype_initialize, -1);
-    rb_define_method(rbffi_FunctionTypeClass, "return_type", fntype_return_type, 0);
-    rb_define_method(rbffi_FunctionTypeClass, "param_types", fntype_param_types, 0);
-
-}
-

data/vendor/bundle/ruby/3.2.0/gems/ffi-1.16.3/ext/ffi_c/LastError.c

@@ -1,243 +0,0 @@
-/*
- * Copyright (c) 2008, 2009, Wayne Meissner
- * Copyright (C) 2009 Aman Gupta <aman@tmm1.net>
- *
- * Copyright (c) 2008-2013, Ruby FFI project contributors
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the Ruby FFI project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef _MSC_VER
-# include <sys/param.h>
-#endif
-#include <sys/types.h>
-#include <stdio.h>
-#include <stdint.h>
-#include <stdbool.h>
-#include <errno.h>
-#include <ruby.h>
-
-#include "LastError.h"
-
-#if defined(HAVE_NATIVETHREAD) && !defined(_WIN32) && !defined(__WIN32__)
-# include <pthread.h>
-# define USE_PTHREAD_LOCAL
-#endif
-
-#if defined(__CYGWIN__)
-typedef uint32_t DWORD;
-DWORD __stdcall GetLastError(void);
-void __stdcall SetLastError(DWORD);
-#endif
-
-typedef struct ThreadData {
-    int td_errno;
-#if defined(_WIN32) || defined(__CYGWIN__)
-    DWORD td_winapi_errno;
-#endif
-} ThreadData;
-
-#if defined(USE_PTHREAD_LOCAL)
-static pthread_key_t threadDataKey;
-#endif
-
-static inline ThreadData* thread_data_get(void);
-
-#if defined(USE_PTHREAD_LOCAL)
-
-static ThreadData*
-thread_data_init(void)
-{
-    ThreadData* td = xcalloc(1, sizeof(ThreadData));
-
-    pthread_setspecific(threadDataKey, td);
-
-    return td;
-}
-
-
-static inline ThreadData*
-thread_data_get(void)
-{
-    ThreadData* td = pthread_getspecific(threadDataKey);
-    return td != NULL ? td : thread_data_init();
-}
-
-static void
-thread_data_free(void *ptr)
-{
-    xfree(ptr);
-}
-
-#else
-static size_t
-thread_data_memsize(const void *data) {
-    return sizeof(ThreadData);
-}
-
-static const rb_data_type_t thread_data_data_type = {
-    .wrap_struct_name = "FFI::ThreadData",
-    .function = {
-        .dmark = NULL,
-        .dfree = RUBY_TYPED_DEFAULT_FREE,
-        .dsize = thread_data_memsize,
-    },
-    // IMPORTANT: WB_PROTECTED objects must only use the RB_OBJ_WRITE()
-    // macro to update VALUE references, as to trigger write barriers.
-    .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
-};
-
-static ID id_thread_data;
-
-static ThreadData*
-thread_data_init(void)
-{
-    ThreadData *td;
-    VALUE obj;
-
-    obj = TypedData_Make_Struct(rb_cObject, ThreadData, &thread_data_data_type, td);
-    rb_thread_local_aset(rb_thread_current(), id_thread_data, obj);
-
-    return td;
-}
-
-static inline ThreadData*
-thread_data_get(void)
-{
-    VALUE obj = rb_thread_local_aref(rb_thread_current(), id_thread_data);
-
-    if (NIL_P(obj)) {
-        return thread_data_init();
-    }
-
-    ThreadData *td;
-    TypedData_Get_Struct(obj, ThreadData, &thread_data_data_type, td);
-    return td;
-}
-
-#endif
-
-
-/*
- * call-seq: error
- * @return [Numeric]
- * Get +errno+ value.
- */
-static VALUE
-get_last_error(VALUE self)
-{
-    return INT2NUM(thread_data_get()->td_errno);
-}
-
-#if defined(_WIN32) || defined(__CYGWIN__)
-/*
- * call-seq: winapi_error
- * @return [Numeric]
- * Get +GetLastError()+ value. Only Windows or Cygwin.
- */
-static VALUE
-get_last_winapi_error(VALUE self)
-{
-    return INT2NUM(thread_data_get()->td_winapi_errno);
-}
-#endif
-
-
-/*
- * call-seq: error(error)
- * @param [Numeric] error
- * @return [nil]
- * Set +errno+ value.
- */
-static VALUE
-set_last_error(VALUE self, VALUE error)
-{
-#ifdef _WIN32
-    SetLastError(NUM2INT(error));
-#else
-    errno = NUM2INT(error);
-#endif
-
-    return Qnil;
-}
-
-#if defined(_WIN32) || defined(__CYGWIN__)
-/*
- * call-seq: error(error)
- * @param [Numeric] error
- * @return [nil]
- * Set +GetLastError()+ value. Only on Windows and Cygwin.
- */
-static VALUE
-set_last_winapi_error(VALUE self, VALUE error)
-{
-    SetLastError(NUM2INT(error));
-    return Qnil;
-}
-#endif
-
-
-void
-rbffi_save_errno(void)
-{
-    int error = 0;
-#ifdef _WIN32
-    error = GetLastError();
-#else
-    error = errno;
-#endif
-
-#if defined(_WIN32) || defined(__CYGWIN__)
-    DWORD winapi_error = GetLastError();
-    thread_data_get()->td_winapi_errno = winapi_error;
-#endif
-
-    thread_data_get()->td_errno = error;
-}
-
-void
-rbffi_LastError_Init(VALUE moduleFFI)
-{
-    /*
-     * Document-module: FFI::LastError
-     * This module defines a couple of method to set and get +errno+
-     * for current thread.
-     */
-    VALUE moduleError = rb_define_module_under(moduleFFI, "LastError");
-
-    rb_define_module_function(moduleError, "error", get_last_error, 0);
-    rb_define_module_function(moduleError, "error=", set_last_error, 1);
-
-#if defined(_WIN32) || defined(__CYGWIN__)
-    rb_define_module_function(moduleError, "winapi_error", get_last_winapi_error, 0);
-    rb_define_module_function(moduleError, "winapi_error=", set_last_winapi_error, 1);
-#endif
-
-#if defined(USE_PTHREAD_LOCAL)
-    pthread_key_create(&threadDataKey, thread_data_free);
-#else
-    id_thread_data = rb_intern("ffi_thread_local_data");
-#endif /* USE_PTHREAD_LOCAL */
-}
-

data/vendor/bundle/ruby/3.2.0/gems/ffi-1.16.3/ext/ffi_c/LastError.h

@@ -1,47 +0,0 @@
-/*
- * Copyright (c) 2008, 2009, Wayne Meissner
- *
- * Copyright (c) 2008-2013, Ruby FFI project contributors
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the Ruby FFI project nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef RBFFI_LASTERROR_H
-#define	RBFFI_LASTERROR_H
-
-#ifdef	__cplusplus
-extern "C" {
-#endif
-
-
-void rbffi_LastError_Init(VALUE moduleFFI);
-
-void rbffi_save_errno(void);
-
-#ifdef	__cplusplus
-}
-#endif
-
-#endif	/* RBFFI_LASTERROR_H */
-