snowflake-connector-python 4.4.0__cp314-cp314-win_amd64.whl

snowflake/connector/nanoarrow_cpp/ArrowIterator/flatcc/flatcc_accessors.h

@@ -0,0 +1,101 @@
+#ifndef FLATCC_ACCESSORS
+#define FLATCC_ACCESSORS
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef UINT8_MAX
+#include <stdint.h>
+#endif
+
+#define __flatcc_basic_scalar_accessors_impl(N, T, W, E)                    \
+static inline size_t N ## __size(void)                                      \
+{ return sizeof(T); }                                                       \
+static inline T *N ## __ptr_add(T *p, size_t i)                             \
+{ return p + i; }                                                           \
+static inline const T *N ## __const_ptr_add(const T *p, size_t i)           \
+{ return p + i; }                                                           \
+static inline T N ## _read_from_pe(const void *p)                           \
+{ return N ## _cast_from_pe(*(T *)p); }                                     \
+static inline T N ## _read_to_pe(const void *p)                             \
+{ return N ## _cast_to_pe(*(T *)p); }                                       \
+static inline T N ## _read(const void *p)                                   \
+{ return *(T *)p; }                                                         \
+static inline void N ## _write_from_pe(void *p, T v)                        \
+{ *(T *)p = N ## _cast_from_pe(v); }                                        \
+static inline void N ## _write_to_pe(void *p, T v)                          \
+{ *(T *)p = N ## _cast_to_pe(v); }                                          \
+static inline void N ## _write(void *p, T v)                                \
+{ *(T *)p = v; }                                                            \
+static inline T N ## _read_from_le(const void *p)                           \
+{ return N ## _cast_from_le(*(T *)p); }                                     \
+typedef struct { int is_null; T value; } N ## _option_t;
+
+#define __flatcc_define_integer_accessors_impl(N, T, W, E)                  \
+static inline T N ## _cast_from_pe(T v)                                     \
+{ return (T) E ## W ## toh((uint ## W ## _t)v); }                           \
+static inline T N ## _cast_to_pe(T v)                                       \
+{ return (T) hto ## E ## W((uint ## W ## _t)v); }                           \
+static inline T N ## _cast_from_le(T v)                                     \
+{ return (T) le ## W ## toh((uint ## W ## _t)v); }                          \
+static inline T N ## _cast_to_le(T v)                                       \
+{ return (T) htole ## W((uint ## W ## _t)v); }                              \
+static inline T N ## _cast_from_be(T v)                                     \
+{ return (T) be ## W ## toh((uint ## W ## _t)v); }                          \
+static inline T N ## _cast_to_be(T v)                                       \
+{ return (T) htobe ## W((uint ## W ## _t)v); }                              \
+__flatcc_basic_scalar_accessors_impl(N, T, W, E)
+
+#define __flatcc_define_real_accessors_impl(N, T, W, E)                     \
+union __ ## N ## _cast { T v; uint ## W ## _t u; };                         \
+static inline T N ## _cast_from_pe(T v)                                     \
+{ union __ ## N ## _cast x;                                                 \
+  x.v = v; x.u = E ## W ## toh(x.u); return x.v; }                          \
+static inline T N ## _cast_to_pe(T v)                                       \
+{ union __ ## N ## _cast x;                                                 \
+  x.v = v; x.u = hto ## E ## W(x.u); return x.v; }                          \
+static inline T N ## _cast_from_le(T v)                                     \
+{ union __ ## N ## _cast x;                                                 \
+  x.v = v; x.u = le ## W ## toh(x.u); return x.v; }                         \
+static inline T N ## _cast_to_le(T v)                                       \
+{ union __ ## N ## _cast x;                                                 \
+  x.v = v; x.u = htole ## W(x.u); return x.v; }                             \
+static inline T N ## _cast_from_be(T v)                                     \
+{ union __ ## N ## _cast x;                                                 \
+  x.v = v; x.u = be ## W ## toh(x.u); return x.v; }                         \
+static inline T N ## _cast_to_be(T v)                                       \
+{ union __ ## N ## _cast x;                                                 \
+  x.v = v; x.u = htobe ## W(x.u); return x.v; }                             \
+__flatcc_basic_scalar_accessors_impl(N, T, W, E)
+
+#define __flatcc_define_integer_accessors(N, T, W, E)                       \
+__flatcc_define_integer_accessors_impl(N, T, W, E)
+
+#define __flatcc_define_real_accessors(N, T, W, E)                          \
+__flatcc_define_real_accessors_impl(N, T, W, E)
+
+#define __flatcc_define_basic_integer_accessors(NS, TN, T, W, E)            \
+__flatcc_define_integer_accessors(NS ## TN, T, W, E)
+
+#define __flatcc_define_basic_real_accessors(NS, TN, T, W, E)               \
+__flatcc_define_real_accessors(NS ## TN, T, W, E)
+
+#define __flatcc_define_basic_scalar_accessors(NS, E)                       \
+__flatcc_define_basic_integer_accessors(NS, char, char, 8, E)               \
+__flatcc_define_basic_integer_accessors(NS, uint8, uint8_t, 8, E)           \
+__flatcc_define_basic_integer_accessors(NS, uint16, uint16_t, 16, E)        \
+__flatcc_define_basic_integer_accessors(NS, uint32, uint32_t, 32, E)        \
+__flatcc_define_basic_integer_accessors(NS, uint64, uint64_t, 64, E)        \
+__flatcc_define_basic_integer_accessors(NS, int8, int8_t, 8, E)             \
+__flatcc_define_basic_integer_accessors(NS, int16, int16_t, 16, E)          \
+__flatcc_define_basic_integer_accessors(NS, int32, int32_t, 32, E)          \
+__flatcc_define_basic_integer_accessors(NS, int64, int64_t, 64, E)          \
+__flatcc_define_basic_real_accessors(NS, float, float, 32, E)               \
+__flatcc_define_basic_real_accessors(NS, double, double, 64, E)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FLATCC_ACCESSORS */

snowflake/connector/nanoarrow_cpp/ArrowIterator/flatcc/flatcc_alloc.h

@@ -0,0 +1,127 @@
+#ifndef FLATCC_ALLOC_H
+#define FLATCC_ALLOC_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * These allocation abstractions are __only__ for runtime libraries.
+ *
+ * The flatcc compiler uses Posix allocation routines regardless
+ * of how this file is configured.
+ *
+ * This header makes it possible to use systems where malloc is not
+ * valid to use. In this case the portable library will not help
+ * because it implements Posix / C11 abstractions.
+ *
+ * Systems like FreeRTOS do not work with Posix memory calls and here it
+ * can be helpful to override runtime allocation primitives.
+ *
+ * In general, it is better to customize the allocator and emitter via
+ * flatcc_builder_custom_init and to avoid using the default emitter
+ * specific high level calls the copy out a buffer that must later be
+ * deallocated. This provides full control of allocation withou the need
+ * for this file.
+ *
+ *
+ * IMPORTANT
+ *
+ * If you override malloc, free, etc., make sure your applications
+ * use the same allocation methods. For example, samples/monster.c
+ * and several test cases are no longer guaranteed to work out of the
+ * box.
+ *
+ * The changes must only affect target runtime compilation including the
+ * the runtime library libflatccrt.
+ *
+ * The host system flatcc compiler and the compiler library libflatcc
+ * should NOT be compiled with non-Posix allocation since the compiler
+ * has a dependency on the runtime library and the wrong free operation
+ * might be callled. The safest way to avoid this problem this is to
+ * compile flatcc with the CMake script and the runtime files with a
+ * dedicated build system for the target system.
+ */
+
+#include <stdlib.h>
+
+#ifndef FLATCC_ALLOC
+#define FLATCC_ALLOC(n) malloc(n)
+#endif
+
+#ifndef FLATCC_FREE
+#define FLATCC_FREE(p) free(p)
+#endif
+
+#ifndef FLATCC_REALLOC
+#define FLATCC_REALLOC(p, n) realloc(p, n)
+#endif
+
+#ifndef FLATCC_CALLOC
+#define FLATCC_CALLOC(nm, n) calloc(nm, n)
+#endif
+
+/*
+ * Implements `aligned_alloc` and `aligned_free`.
+ * Even with C11, this implements non-standard aligned_free needed for portable
+ * aligned_alloc implementations.
+ */
+#ifndef FLATCC_USE_GENERIC_ALIGNED_ALLOC
+
+#ifndef FLATCC_NO_PALIGNED_ALLOC
+#include "flatcc/portable/paligned_alloc.h"
+#else
+#if !defined(__aligned_free_is_defined) || !__aligned_free_is_defined
+#define aligned_free free
+#endif
+#endif
+
+#else /* FLATCC_USE_GENERIC_ALIGNED_ALLOC */
+
+#ifndef FLATCC_ALIGNED_ALLOC
+static inline void *__flatcc_aligned_alloc(size_t alignment, size_t size)
+{
+    char *raw;
+    void *buf;
+    size_t total_size = (size + alignment - 1 + sizeof(void *));
+
+    if (alignment < sizeof(void *)) {
+        alignment = sizeof(void *);
+    }
+    raw = (char *)(size_t)FLATCC_ALLOC(total_size);
+    buf = raw + alignment - 1 + sizeof(void *);
+    buf = (void *)(((size_t)buf) & ~(alignment - 1));
+    ((void **)buf)[-1] = raw;
+    return buf;
+}
+#define FLATCC_ALIGNED_ALLOC(alignment, size) __flatcc_aligned_alloc(alignment, size)
+#endif /* FLATCC_USE_GENERIC_ALIGNED_ALLOC */
+
+#ifndef FLATCC_ALIGNED_FREE
+static inline void __flatcc_aligned_free(void *p)
+{
+    char *raw;
+
+    if (!p) return;
+    raw = ((void **)p)[-1];
+
+    FLATCC_FREE(raw);
+}
+#define FLATCC_ALIGNED_FREE(p) __flatcc_aligned_free(p)
+#endif
+
+#endif /* FLATCC_USE_GENERIC_ALIGNED_ALLOC */
+
+#ifndef FLATCC_ALIGNED_ALLOC
+#define FLATCC_ALIGNED_ALLOC(a, n) aligned_alloc(a, n)
+#endif
+
+#ifndef FLATCC_ALIGNED_FREE
+#define FLATCC_ALIGNED_FREE(p) aligned_free(p)
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FLATCC_ALLOC_H */

snowflake/connector/nanoarrow_cpp/ArrowIterator/flatcc/flatcc_assert.h

@@ -0,0 +1,45 @@
+#ifndef FLATCC_ASSERT_H
+#define FLATCC_ASSERT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+* This assert abstraction is only used for the flatcc runtime library.
+* The flatcc compiler uses Posix assert routines regardless of how this
+* file is configured.
+*
+* This header makes it possible to use systems where assert is not
+* valid to use. Note that `<assert.h>` may remain a dependency for static
+* assertions.
+*
+* `FLATCC_ASSERT` is designed to handle errors which cannot be ignored
+* and could lead to crash. The portable library may use assertions that
+* are not affected by this macro.
+*
+* `FLATCC_ASSERT` defaults to POSIX assert but can be overrided by a
+* preprocessor definition.
+*
+* Runtime assertions can be entirely disabled by defining
+* `FLATCC_NO_ASSERT`.
+*/
+
+#ifdef FLATCC_NO_ASSERT
+/* NOTE: This will not affect inclusion of <assert.h> for static assertions. */
+#undef FLATCC_ASSERT
+#define FLATCC_ASSERT(x) ((void)0)
+/* Grisu3 is used for floating point conversion in JSON processing. */
+#define GRISU3_NO_ASSERT
+#endif
+
+#ifndef FLATCC_ASSERT
+#include <assert.h>
+#define FLATCC_ASSERT assert
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FLATCC_ASSERT_H */