diff options
Diffstat (limited to 'internal/mptest/main_linux_arm64.go')
| -rw-r--r-- | internal/mptest/main_linux_arm64.go | 5789 |
1 files changed, 5789 insertions, 0 deletions
diff --git a/internal/mptest/main_linux_arm64.go b/internal/mptest/main_linux_arm64.go new file mode 100644 index 0000000..5d0d255 --- /dev/null +++ b/internal/mptest/main_linux_arm64.go @@ -0,0 +1,5789 @@ +// Code generated by 'ccgo -o internal/mptest/main_linux_arm64.go testdata/sqlite-src-3330000/mptest/mptest.c -Itestdata/sqlite-amalgamation-3330000 -l modernc.org/sqlite/lib -DNDEBUG -DHAVE_USLEEP -DLONGDOUBLE_TYPE=double -DSQLITE_CORE -DSQLITE_DEFAULT_MEMSTATUS=0 -DSQLITE_DEFAULT_PAGE_SIZE=1024 -DSQLITE_ENABLE_BYTECODE_VTAB -DSQLITE_ENABLE_COLUMN_METADATA -DSQLITE_ENABLE_DBPAGE_VTAB -DSQLITE_ENABLE_DBSTAT_VTAB -DSQLITE_ENABLE_DESERIALIZE -DSQLITE_ENABLE_EXPLAIN_COMMENTS -DSQLITE_ENABLE_FTS5 -DSQLITE_ENABLE_GEOPOLY -DSQLITE_ENABLE_JSON1 -DSQLITE_ENABLE_MEMORY_MANAGEMENT -DSQLITE_ENABLE_OFFSET_SQL_FUNC -DSQLITE_ENABLE_PREUPDATE_HOOK -DSQLITE_ENABLE_RBU -DSQLITE_ENABLE_RTREE -DSQLITE_ENABLE_SNAPSHOT -DSQLITE_ENABLE_STAT4 -DSQLITE_ENABLE_STMTVTAB -DSQLITE_ENABLE_UNLOCK_NOTIFY -DSQLITE_HAVE_ZLIB=1 -DSQLITE_LIKE_DOESNT_MATCH_BLOBS -DSQLITE_MUTEX_APPDEF=1 -DSQLITE_MUTEX_NOOP -DSQLITE_OS_UNIX=1 -DSQLITE_SOUNDEX -DSQLITE_TEMP_STORE=1 -DSQLITE_TEST -DSQLITE_THREADSAFE=1 -ccgo-long-double-is-double', DO NOT EDIT. + +package main + +import ( + "math" + "reflect" + "unsafe" + + "modernc.org/libc" + "modernc.org/sqlite/lib" +) + +var _ = math.Pi +var _ reflect.Kind +var _ unsafe.Pointer + +func main() { libc.Start(main1) } + +// Get the `_PC_*' symbols for the NAME argument to `pathconf' and `fpathconf'; +// the `_SC_*' symbols for the NAME argument to `sysconf'; +// and the `_CS_*' symbols for the NAME argument to `confstr'. +// `sysconf', `pathconf', and `confstr' NAME values. Generic version. +// Copyright (C) 1993-2018 Free Software Foundation, Inc. +// This file is part of the GNU C Library. +// +// The GNU C Library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// The GNU C Library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with the GNU C Library; if not, see +// <http://www.gnu.org/licenses/>. + +// Values for the NAME argument to `pathconf' and `fpathconf'. +const ( /* confname.h:24:1: */ + _PC_LINK_MAX = 0 + _PC_MAX_CANON = 1 + _PC_MAX_INPUT = 2 + _PC_NAME_MAX = 3 + _PC_PATH_MAX = 4 + _PC_PIPE_BUF = 5 + _PC_CHOWN_RESTRICTED = 6 + _PC_NO_TRUNC = 7 + _PC_VDISABLE = 8 + _PC_SYNC_IO = 9 + _PC_ASYNC_IO = 10 + _PC_PRIO_IO = 11 + _PC_SOCK_MAXBUF = 12 + _PC_FILESIZEBITS = 13 + _PC_REC_INCR_XFER_SIZE = 14 + _PC_REC_MAX_XFER_SIZE = 15 + _PC_REC_MIN_XFER_SIZE = 16 + _PC_REC_XFER_ALIGN = 17 + _PC_ALLOC_SIZE_MIN = 18 + _PC_SYMLINK_MAX = 19 + _PC_2_SYMLINKS = 20 +) + +// Values for the NAME argument to `confstr'. +const ( /* confname.h:533:1: */ + _CS_PATH = 0 // The default search path. + + _CS_V6_WIDTH_RESTRICTED_ENVS = 1 + + _CS_GNU_LIBC_VERSION = 2 + _CS_GNU_LIBPTHREAD_VERSION = 3 + + _CS_V5_WIDTH_RESTRICTED_ENVS = 4 + + _CS_V7_WIDTH_RESTRICTED_ENVS = 5 + + _CS_LFS_CFLAGS = 1000 + _CS_LFS_LDFLAGS = 1001 + _CS_LFS_LIBS = 1002 + _CS_LFS_LINTFLAGS = 1003 + _CS_LFS64_CFLAGS = 1004 + _CS_LFS64_LDFLAGS = 1005 + _CS_LFS64_LIBS = 1006 + _CS_LFS64_LINTFLAGS = 1007 + + _CS_XBS5_ILP32_OFF32_CFLAGS = 1100 + _CS_XBS5_ILP32_OFF32_LDFLAGS = 1101 + _CS_XBS5_ILP32_OFF32_LIBS = 1102 + _CS_XBS5_ILP32_OFF32_LINTFLAGS = 1103 + _CS_XBS5_ILP32_OFFBIG_CFLAGS = 1104 + _CS_XBS5_ILP32_OFFBIG_LDFLAGS = 1105 + _CS_XBS5_ILP32_OFFBIG_LIBS = 1106 + _CS_XBS5_ILP32_OFFBIG_LINTFLAGS = 1107 + _CS_XBS5_LP64_OFF64_CFLAGS = 1108 + _CS_XBS5_LP64_OFF64_LDFLAGS = 1109 + _CS_XBS5_LP64_OFF64_LIBS = 1110 + _CS_XBS5_LP64_OFF64_LINTFLAGS = 1111 + _CS_XBS5_LPBIG_OFFBIG_CFLAGS = 1112 + _CS_XBS5_LPBIG_OFFBIG_LDFLAGS = 1113 + _CS_XBS5_LPBIG_OFFBIG_LIBS = 1114 + _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS = 1115 + + _CS_POSIX_V6_ILP32_OFF32_CFLAGS = 1116 + _CS_POSIX_V6_ILP32_OFF32_LDFLAGS = 1117 + _CS_POSIX_V6_ILP32_OFF32_LIBS = 1118 + _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS = 1119 + _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS = 1120 + _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS = 1121 + _CS_POSIX_V6_ILP32_OFFBIG_LIBS = 1122 + _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS = 1123 + _CS_POSIX_V6_LP64_OFF64_CFLAGS = 1124 + _CS_POSIX_V6_LP64_OFF64_LDFLAGS = 1125 + _CS_POSIX_V6_LP64_OFF64_LIBS = 1126 + _CS_POSIX_V6_LP64_OFF64_LINTFLAGS = 1127 + _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS = 1128 + _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS = 1129 + _CS_POSIX_V6_LPBIG_OFFBIG_LIBS = 1130 + _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS = 1131 + + _CS_POSIX_V7_ILP32_OFF32_CFLAGS = 1132 + _CS_POSIX_V7_ILP32_OFF32_LDFLAGS = 1133 + _CS_POSIX_V7_ILP32_OFF32_LIBS = 1134 + _CS_POSIX_V7_ILP32_OFF32_LINTFLAGS = 1135 + _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS = 1136 + _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS = 1137 + _CS_POSIX_V7_ILP32_OFFBIG_LIBS = 1138 + _CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS = 1139 + _CS_POSIX_V7_LP64_OFF64_CFLAGS = 1140 + _CS_POSIX_V7_LP64_OFF64_LDFLAGS = 1141 + _CS_POSIX_V7_LP64_OFF64_LIBS = 1142 + _CS_POSIX_V7_LP64_OFF64_LINTFLAGS = 1143 + _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS = 1144 + _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS = 1145 + _CS_POSIX_V7_LPBIG_OFFBIG_LIBS = 1146 + _CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS = 1147 + + _CS_V6_ENV = 1148 + _CS_V7_ENV = 1149 +) + +// Values for the argument to `sysconf'. +const ( /* confname.h:71:1: */ + _SC_ARG_MAX = 0 + _SC_CHILD_MAX = 1 + _SC_CLK_TCK = 2 + _SC_NGROUPS_MAX = 3 + _SC_OPEN_MAX = 4 + _SC_STREAM_MAX = 5 + _SC_TZNAME_MAX = 6 + _SC_JOB_CONTROL = 7 + _SC_SAVED_IDS = 8 + _SC_REALTIME_SIGNALS = 9 + _SC_PRIORITY_SCHEDULING = 10 + _SC_TIMERS = 11 + _SC_ASYNCHRONOUS_IO = 12 + _SC_PRIORITIZED_IO = 13 + _SC_SYNCHRONIZED_IO = 14 + _SC_FSYNC = 15 + _SC_MAPPED_FILES = 16 + _SC_MEMLOCK = 17 + _SC_MEMLOCK_RANGE = 18 + _SC_MEMORY_PROTECTION = 19 + _SC_MESSAGE_PASSING = 20 + _SC_SEMAPHORES = 21 + _SC_SHARED_MEMORY_OBJECTS = 22 + _SC_AIO_LISTIO_MAX = 23 + _SC_AIO_MAX = 24 + _SC_AIO_PRIO_DELTA_MAX = 25 + _SC_DELAYTIMER_MAX = 26 + _SC_MQ_OPEN_MAX = 27 + _SC_MQ_PRIO_MAX = 28 + _SC_VERSION = 29 + _SC_PAGESIZE = 30 + _SC_RTSIG_MAX = 31 + _SC_SEM_NSEMS_MAX = 32 + _SC_SEM_VALUE_MAX = 33 + _SC_SIGQUEUE_MAX = 34 + _SC_TIMER_MAX = 35 + + // Values for the argument to `sysconf' + // corresponding to _POSIX2_* symbols. + _SC_BC_BASE_MAX = 36 + _SC_BC_DIM_MAX = 37 + _SC_BC_SCALE_MAX = 38 + _SC_BC_STRING_MAX = 39 + _SC_COLL_WEIGHTS_MAX = 40 + _SC_EQUIV_CLASS_MAX = 41 + _SC_EXPR_NEST_MAX = 42 + _SC_LINE_MAX = 43 + _SC_RE_DUP_MAX = 44 + _SC_CHARCLASS_NAME_MAX = 45 + + _SC_2_VERSION = 46 + _SC_2_C_BIND = 47 + _SC_2_C_DEV = 48 + _SC_2_FORT_DEV = 49 + _SC_2_FORT_RUN = 50 + _SC_2_SW_DEV = 51 + _SC_2_LOCALEDEF = 52 + + _SC_PII = 53 + _SC_PII_XTI = 54 + _SC_PII_SOCKET = 55 + _SC_PII_INTERNET = 56 + _SC_PII_OSI = 57 + _SC_POLL = 58 + _SC_SELECT = 59 + _SC_UIO_MAXIOV = 60 + _SC_IOV_MAX = 60 + _SC_PII_INTERNET_STREAM = 61 + _SC_PII_INTERNET_DGRAM = 62 + _SC_PII_OSI_COTS = 63 + _SC_PII_OSI_CLTS = 64 + _SC_PII_OSI_M = 65 + _SC_T_IOV_MAX = 66 + + // Values according to POSIX 1003.1c (POSIX threads). + _SC_THREADS = 67 + _SC_THREAD_SAFE_FUNCTIONS = 68 + _SC_GETGR_R_SIZE_MAX = 69 + _SC_GETPW_R_SIZE_MAX = 70 + _SC_LOGIN_NAME_MAX = 71 + _SC_TTY_NAME_MAX = 72 + _SC_THREAD_DESTRUCTOR_ITERATIONS = 73 + _SC_THREAD_KEYS_MAX = 74 + _SC_THREAD_STACK_MIN = 75 + _SC_THREAD_THREADS_MAX = 76 + _SC_THREAD_ATTR_STACKADDR = 77 + _SC_THREAD_ATTR_STACKSIZE = 78 + _SC_THREAD_PRIORITY_SCHEDULING = 79 + _SC_THREAD_PRIO_INHERIT = 80 + _SC_THREAD_PRIO_PROTECT = 81 + _SC_THREAD_PROCESS_SHARED = 82 + + _SC_NPROCESSORS_CONF = 83 + _SC_NPROCESSORS_ONLN = 84 + _SC_PHYS_PAGES = 85 + _SC_AVPHYS_PAGES = 86 + _SC_ATEXIT_MAX = 87 + _SC_PASS_MAX = 88 + + _SC_XOPEN_VERSION = 89 + _SC_XOPEN_XCU_VERSION = 90 + _SC_XOPEN_UNIX = 91 + _SC_XOPEN_CRYPT = 92 + _SC_XOPEN_ENH_I18N = 93 + _SC_XOPEN_SHM = 94 + + _SC_2_CHAR_TERM = 95 + _SC_2_C_VERSION = 96 + _SC_2_UPE = 97 + + _SC_XOPEN_XPG2 = 98 + _SC_XOPEN_XPG3 = 99 + _SC_XOPEN_XPG4 = 100 + + _SC_CHAR_BIT = 101 + _SC_CHAR_MAX = 102 + _SC_CHAR_MIN = 103 + _SC_INT_MAX = 104 + _SC_INT_MIN = 105 + _SC_LONG_BIT = 106 + _SC_WORD_BIT = 107 + _SC_MB_LEN_MAX = 108 + _SC_NZERO = 109 + _SC_SSIZE_MAX = 110 + _SC_SCHAR_MAX = 111 + _SC_SCHAR_MIN = 112 + _SC_SHRT_MAX = 113 + _SC_SHRT_MIN = 114 + _SC_UCHAR_MAX = 115 + _SC_UINT_MAX = 116 + _SC_ULONG_MAX = 117 + _SC_USHRT_MAX = 118 + + _SC_NL_ARGMAX = 119 + _SC_NL_LANGMAX = 120 + _SC_NL_MSGMAX = 121 + _SC_NL_NMAX = 122 + _SC_NL_SETMAX = 123 + _SC_NL_TEXTMAX = 124 + + _SC_XBS5_ILP32_OFF32 = 125 + _SC_XBS5_ILP32_OFFBIG = 126 + _SC_XBS5_LP64_OFF64 = 127 + _SC_XBS5_LPBIG_OFFBIG = 128 + + _SC_XOPEN_LEGACY = 129 + _SC_XOPEN_REALTIME = 130 + _SC_XOPEN_REALTIME_THREADS = 131 + + _SC_ADVISORY_INFO = 132 + _SC_BARRIERS = 133 + _SC_BASE = 134 + _SC_C_LANG_SUPPORT = 135 + _SC_C_LANG_SUPPORT_R = 136 + _SC_CLOCK_SELECTION = 137 + _SC_CPUTIME = 138 + _SC_THREAD_CPUTIME = 139 + _SC_DEVICE_IO = 140 + _SC_DEVICE_SPECIFIC = 141 + _SC_DEVICE_SPECIFIC_R = 142 + _SC_FD_MGMT = 143 + _SC_FIFO = 144 + _SC_PIPE = 145 + _SC_FILE_ATTRIBUTES = 146 + _SC_FILE_LOCKING = 147 + _SC_FILE_SYSTEM = 148 + _SC_MONOTONIC_CLOCK = 149 + _SC_MULTI_PROCESS = 150 + _SC_SINGLE_PROCESS = 151 + _SC_NETWORKING = 152 + _SC_READER_WRITER_LOCKS = 153 + _SC_SPIN_LOCKS = 154 + _SC_REGEXP = 155 + _SC_REGEX_VERSION = 156 + _SC_SHELL = 157 + _SC_SIGNALS = 158 + _SC_SPAWN = 159 + _SC_SPORADIC_SERVER = 160 + _SC_THREAD_SPORADIC_SERVER = 161 + _SC_SYSTEM_DATABASE = 162 + _SC_SYSTEM_DATABASE_R = 163 + _SC_TIMEOUTS = 164 + _SC_TYPED_MEMORY_OBJECTS = 165 + _SC_USER_GROUPS = 166 + _SC_USER_GROUPS_R = 167 + _SC_2_PBS = 168 + _SC_2_PBS_ACCOUNTING = 169 + _SC_2_PBS_LOCATE = 170 + _SC_2_PBS_MESSAGE = 171 + _SC_2_PBS_TRACK = 172 + _SC_SYMLOOP_MAX = 173 + _SC_STREAMS = 174 + _SC_2_PBS_CHECKPOINT = 175 + + _SC_V6_ILP32_OFF32 = 176 + _SC_V6_ILP32_OFFBIG = 177 + _SC_V6_LP64_OFF64 = 178 + _SC_V6_LPBIG_OFFBIG = 179 + + _SC_HOST_NAME_MAX = 180 + _SC_TRACE = 181 + _SC_TRACE_EVENT_FILTER = 182 + _SC_TRACE_INHERIT = 183 + _SC_TRACE_LOG = 184 + + _SC_LEVEL1_ICACHE_SIZE = 185 + _SC_LEVEL1_ICACHE_ASSOC = 186 + _SC_LEVEL1_ICACHE_LINESIZE = 187 + _SC_LEVEL1_DCACHE_SIZE = 188 + _SC_LEVEL1_DCACHE_ASSOC = 189 + _SC_LEVEL1_DCACHE_LINESIZE = 190 + _SC_LEVEL2_CACHE_SIZE = 191 + _SC_LEVEL2_CACHE_ASSOC = 192 + _SC_LEVEL2_CACHE_LINESIZE = 193 + _SC_LEVEL3_CACHE_SIZE = 194 + _SC_LEVEL3_CACHE_ASSOC = 195 + _SC_LEVEL3_CACHE_LINESIZE = 196 + _SC_LEVEL4_CACHE_SIZE = 197 + _SC_LEVEL4_CACHE_ASSOC = 198 + _SC_LEVEL4_CACHE_LINESIZE = 199 + // Leave room here, maybe we need a few more cache levels some day. + + _SC_IPV6 = 235 + _SC_RAW_SOCKETS = 236 + + _SC_V7_ILP32_OFF32 = 237 + _SC_V7_ILP32_OFFBIG = 238 + _SC_V7_LP64_OFF64 = 239 + _SC_V7_LPBIG_OFFBIG = 240 + + _SC_SS_REPL_MAX = 241 + + _SC_TRACE_EVENT_NAME_MAX = 242 + _SC_TRACE_NAME_MAX = 243 + _SC_TRACE_SYS_MAX = 244 + _SC_TRACE_USER_EVENT_MAX = 245 + + _SC_XOPEN_STREAMS = 246 + + _SC_THREAD_ROBUST_PRIO_INHERIT = 247 + _SC_THREAD_ROBUST_PRIO_PROTECT = 248 +) + +// In 4.3bsd-net2, leave these undefined to indicate that size_t, etc. +// are already defined. +// BSD/OS 3.1 and FreeBSD [23].x require the MACHINE_ANSI_H check here. +// NetBSD 5 requires the I386_ANSI_H and X86_64_ANSI_H checks here. + +// A null pointer constant. + +// XPG requires a few symbols from <sys/wait.h> being defined. +// Definitions of flag bits for `waitpid' et al. +// Copyright (C) 1992-2018 Free Software Foundation, Inc. +// This file is part of the GNU C Library. +// +// The GNU C Library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// The GNU C Library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with the GNU C Library; if not, see +// <http://www.gnu.org/licenses/>. + +// Bits in the third argument to `waitpid'. + +// Bits in the fourth argument to `waitid'. + +// The following values are used by the `waitid' function. + +// The Linux kernel defines these bare, rather than an enum, +// which causes a conflict if the include order is reversed. + +const ( /* waitflags.h:52:1: */ + P_ALL = 0 // Wait for any child. + P_PID = 1 // Wait for specified process. + P_PGID = 2 +) + +// Copyright (C) 1991-2018 Free Software Foundation, Inc. +// This file is part of the GNU C Library. +// +// The GNU C Library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// The GNU C Library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with the GNU C Library; if not, see +// <http://www.gnu.org/licenses/>. + +// ISO C99 Standard: 7.2 Diagnostics <assert.h> + +// Copyright (C) 1991-2018 Free Software Foundation, Inc. +// This file is part of the GNU C Library. +// +// The GNU C Library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// The GNU C Library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with the GNU C Library; if not, see +// <http://www.gnu.org/licenses/>. + +// void assert (int expression); +// +// If NDEBUG is defined, do nothing. +// If not, and EXPRESSION is zero, print an error message and abort. + +// void assert_perror (int errnum); +// +// If NDEBUG is defined, do nothing. If not, and ERRNUM is not zero, print an +// error message with the error text for ERRNUM and abort. +// (This is a GNU extension.) + +// Copyright (C) 1991-2018 Free Software Foundation, Inc. +// This file is part of the GNU C Library. +// +// The GNU C Library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// The GNU C Library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with the GNU C Library; if not, see +// <http://www.gnu.org/licenses/>. + +// ISO C99 Standard 7.4: Character handling <ctype.h> + +// Copyright (C) 1991-2018 Free Software Foundation, Inc. +// This file is part of the GNU C Library. +// +// The GNU C Library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// The GNU C Library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with the GNU C Library; if not, see +// <http://www.gnu.org/licenses/>. + +// bits/types.h -- definitions of __*_t types underlying *_t types. +// Copyright (C) 2002-2018 Free Software Foundation, Inc. +// This file is part of the GNU C Library. +// +// The GNU C Library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// The GNU C Library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with the GNU C Library; if not, see +// <http://www.gnu.org/licenses/>. + +// Never include this file directly; use <sys/types.h> instead. + +// These are all the characteristics of characters. +// If there get to be more than 16 distinct characteristics, +// many things must be changed that use `unsigned short int's. +// +// The characteristics are stored always in network byte order (big +// endian). We define the bit value interpretations here dependent on the +// machine's byte order. + +// Copyright (C) 1992-2018 Free Software Foundation, Inc. +// This file is part of the GNU C Library. +// +// The GNU C Library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// The GNU C Library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with the GNU C Library; if not, see +// <http://www.gnu.org/licenses/>. + +const ( /* ctype.h:46:1: */ + _ISupper = 256 // UPPERCASE. + _ISlower = 512 // lowercase. + _ISalpha = 1024 // Alphabetic. + _ISdigit = 2048 // Numeric. + _ISxdigit = 4096 // Hexadecimal numeric. + _ISspace = 8192 // Whitespace. + _ISprint = 16384 // Printing. + _ISgraph = 32768 // Graphical. + _ISblank = 1 // Blank (usually SPC and TAB). + _IScntrl = 2 // Control character. + _ISpunct = 4 // Punctuation. + _ISalnum = 8 +) + +type ptrdiff_t = int64 /* <builtin>:3:26 */ + +type size_t = uint64 /* <builtin>:9:23 */ + +type wchar_t = uint32 /* <builtin>:15:24 */ + +// Define the standard macros for the user, +// if this invocation was from the user program. + +// Define va_list, if desired, from __gnuc_va_list. +// We deliberately do not define va_list when called from +// stdio.h, because ANSI C says that stdio.h is not supposed to define +// va_list. stdio.h needs to have access to that data type, +// but must not use that name. It should use the name __gnuc_va_list, +// which is safe because it is reserved for the implementation. + +// The macro _VA_LIST_ is the same thing used by this file in Ultrix. +// But on BSD NET2 we must not test or define or undef it. +// (Note that the comments in NET 2's ansi.h +// are incorrect for _VA_LIST_--see stdio.h!) +// The macro _VA_LIST_DEFINED is used in Windows NT 3.5 +// The macro _VA_LIST is used in SCO Unix 3.2. +// The macro _VA_LIST_T_H is used in the Bull dpx2 +// The macro __va_list__ is used by BeOS. +type va_list = uintptr /* stdarg.h:99:24 */ + +// CAPI3REF: 64-Bit Integer Types +// KEYWORDS: sqlite_int64 sqlite_uint64 +// +// Because there is no cross-platform way to specify 64-bit integer types +// SQLite includes typedefs for 64-bit signed and unsigned integers. +// +// The sqlite3_int64 and sqlite3_uint64 are the preferred type definitions. +// The sqlite_int64 and sqlite_uint64 types are supported for backwards +// compatibility only. +// +// ^The sqlite3_int64 and sqlite_int64 types can store integer values +// between -9223372036854775808 and +9223372036854775807 inclusive. ^The +// sqlite3_uint64 and sqlite_uint64 types can store integer values +// between 0 and +18446744073709551615 inclusive. +type sqlite_int64 = int64 /* sqlite3.h:278:25 */ +type sqlite_uint64 = uint64 /* sqlite3.h:279:34 */ +type sqlite3_int64 = sqlite_int64 /* sqlite3.h:281:22 */ +type sqlite3_uint64 = sqlite_uint64 /* sqlite3.h:282:23 */ + +// The type for a callback function. +// This is legacy and deprecated. It is included for historical +// compatibility and is not documented. +type sqlite3_callback = uintptr /* sqlite3.h:338:13 */ + +// CAPI3REF: Result Codes +// KEYWORDS: {result code definitions} +// +// Many SQLite functions return an integer result code from the set shown +// here in order to indicate success or failure. +// +// New error codes may be added in future versions of SQLite. +// +// See also: [extended result code definitions] +// beginning-of-error-codes +// end-of-error-codes + +// CAPI3REF: Extended Result Codes +// KEYWORDS: {extended result code definitions} +// +// In its default configuration, SQLite API routines return one of 30 integer +// [result codes]. However, experience has shown that many of +// these result codes are too coarse-grained. They do not provide as +// much information about problems as programmers might like. In an effort to +// address this, newer versions of SQLite (version 3.3.8 [dateof:3.3.8] +// and later) include +// support for additional result codes that provide more detailed information +// about errors. These [extended result codes] are enabled or disabled +// on a per database connection basis using the +// [sqlite3_extended_result_codes()] API. Or, the extended code for +// the most recent error can be obtained using +// [sqlite3_extended_errcode()]. + +// CAPI3REF: Flags For File Open Operations +// +// These bit values are intended for use in the +// 3rd parameter to the [sqlite3_open_v2()] interface and +// in the 4th parameter to the [sqlite3_vfs.xOpen] method. + +// Reserved: 0x00F00000 +// Legacy compatibility: + +// CAPI3REF: Device Characteristics +// +// The xDeviceCharacteristics method of the [sqlite3_io_methods] +// object returns an integer which is a vector of these +// bit values expressing I/O characteristics of the mass storage +// device that holds the file that the [sqlite3_io_methods] +// refers to. +// +// The SQLITE_IOCAP_ATOMIC property means that all writes of +// any size are atomic. The SQLITE_IOCAP_ATOMICnnn values +// mean that writes of blocks that are nnn bytes in size and +// are aligned to an address which is an integer multiple of +// nnn are atomic. The SQLITE_IOCAP_SAFE_APPEND value means +// that when data is appended to a file, the data is appended +// first then the size of the file is extended, never the other +// way around. The SQLITE_IOCAP_SEQUENTIAL property means that +// information is written to disk in the same order as calls +// to xWrite(). The SQLITE_IOCAP_POWERSAFE_OVERWRITE property means that +// after reboot following a crash or power loss, the only bytes in a +// file that were written at the application level might have changed +// and that adjacent bytes, even bytes within the same sector are +// guaranteed to be unchanged. The SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN +// flag indicates that a file cannot be deleted when open. The +// SQLITE_IOCAP_IMMUTABLE flag indicates that the file is on +// read-only media and cannot be changed even by processes with +// elevated privileges. +// +// The SQLITE_IOCAP_BATCH_ATOMIC property means that the underlying +// filesystem supports doing multiple write operations atomically when those +// write operations are bracketed by [SQLITE_FCNTL_BEGIN_ATOMIC_WRITE] and +// [SQLITE_FCNTL_COMMIT_ATOMIC_WRITE]. + +// CAPI3REF: File Locking Levels +// +// SQLite uses one of these integer values as the second +// argument to calls it makes to the xLock() and xUnlock() methods +// of an [sqlite3_io_methods] object. + +// CAPI3REF: Synchronization Type Flags +// +// When SQLite invokes the xSync() method of an +// [sqlite3_io_methods] object it uses a combination of +// these integer values as the second argument. +// +// When the SQLITE_SYNC_DATAONLY flag is used, it means that the +// sync operation only needs to flush data to mass storage. Inode +// information need not be flushed. If the lower four bits of the flag +// equal SQLITE_SYNC_NORMAL, that means to use normal fsync() semantics. +// If the lower four bits equal SQLITE_SYNC_FULL, that means +// to use Mac OS X style fullsync instead of fsync(). +// +// Do not confuse the SQLITE_SYNC_NORMAL and SQLITE_SYNC_FULL flags +// with the [PRAGMA synchronous]=NORMAL and [PRAGMA synchronous]=FULL +// settings. The [synchronous pragma] determines when calls to the +// xSync VFS method occur and applies uniformly across all platforms. +// The SQLITE_SYNC_NORMAL and SQLITE_SYNC_FULL flags determine how +// energetic or rigorous or forceful the sync operations are and +// only make a difference on Mac OSX for the default SQLite code. +// (Third-party VFS implementations might also make the distinction +// between SQLITE_SYNC_NORMAL and SQLITE_SYNC_FULL, but among the +// operating systems natively supported by SQLite, only Mac OSX +// cares about the difference.) + +// CAPI3REF: OS Interface Open File Handle +// +// An [sqlite3_file] object represents an open file in the +// [sqlite3_vfs | OS interface layer]. Individual OS interface +// implementations will +// want to subclass this object by appending additional fields +// for their own use. The pMethods entry is a pointer to an +// [sqlite3_io_methods] object that defines methods for performing +// I/O operations on the open file. +type sqlite3_file1 = struct{ pMethods uintptr } /* sqlite3.h:683:9 */ + +// CAPI3REF: Result Codes +// KEYWORDS: {result code definitions} +// +// Many SQLite functions return an integer result code from the set shown +// here in order to indicate success or failure. +// +// New error codes may be added in future versions of SQLite. +// +// See also: [extended result code definitions] +// beginning-of-error-codes +// end-of-error-codes + +// CAPI3REF: Extended Result Codes +// KEYWORDS: {extended result code definitions} +// +// In its default configuration, SQLite API routines return one of 30 integer +// [result codes]. However, experience has shown that many of +// these result codes are too coarse-grained. They do not provide as +// much information about problems as programmers might like. In an effort to +// address this, newer versions of SQLite (version 3.3.8 [dateof:3.3.8] +// and later) include +// support for additional result codes that provide more detailed information +// about errors. These [extended result codes] are enabled or disabled +// on a per database connection basis using the +// [sqlite3_extended_result_codes()] API. Or, the extended code for +// the most recent error can be obtained using +// [sqlite3_extended_errcode()]. + +// CAPI3REF: Flags For File Open Operations +// +// These bit values are intended for use in the +// 3rd parameter to the [sqlite3_open_v2()] interface and +// in the 4th parameter to the [sqlite3_vfs.xOpen] method. + +// Reserved: 0x00F00000 +// Legacy compatibility: + +// CAPI3REF: Device Characteristics +// +// The xDeviceCharacteristics method of the [sqlite3_io_methods] +// object returns an integer which is a vector of these +// bit values expressing I/O characteristics of the mass storage +// device that holds the file that the [sqlite3_io_methods] +// refers to. +// +// The SQLITE_IOCAP_ATOMIC property means that all writes of +// any size are atomic. The SQLITE_IOCAP_ATOMICnnn values +// mean that writes of blocks that are nnn bytes in size and +// are aligned to an address which is an integer multiple of +// nnn are atomic. The SQLITE_IOCAP_SAFE_APPEND value means +// that when data is appended to a file, the data is appended +// first then the size of the file is extended, never the other +// way around. The SQLITE_IOCAP_SEQUENTIAL property means that +// information is written to disk in the same order as calls +// to xWrite(). The SQLITE_IOCAP_POWERSAFE_OVERWRITE property means that +// after reboot following a crash or power loss, the only bytes in a +// file that were written at the application level might have changed +// and that adjacent bytes, even bytes within the same sector are +// guaranteed to be unchanged. The SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN +// flag indicates that a file cannot be deleted when open. The +// SQLITE_IOCAP_IMMUTABLE flag indicates that the file is on +// read-only media and cannot be changed even by processes with +// elevated privileges. +// +// The SQLITE_IOCAP_BATCH_ATOMIC property means that the underlying +// filesystem supports doing multiple write operations atomically when those +// write operations are bracketed by [SQLITE_FCNTL_BEGIN_ATOMIC_WRITE] and +// [SQLITE_FCNTL_COMMIT_ATOMIC_WRITE]. + +// CAPI3REF: File Locking Levels +// +// SQLite uses one of these integer values as the second +// argument to calls it makes to the xLock() and xUnlock() methods +// of an [sqlite3_io_methods] object. + +// CAPI3REF: Synchronization Type Flags +// +// When SQLite invokes the xSync() method of an +// [sqlite3_io_methods] object it uses a combination of +// these integer values as the second argument. +// +// When the SQLITE_SYNC_DATAONLY flag is used, it means that the +// sync operation only needs to flush data to mass storage. Inode +// information need not be flushed. If the lower four bits of the flag +// equal SQLITE_SYNC_NORMAL, that means to use normal fsync() semantics. +// If the lower four bits equal SQLITE_SYNC_FULL, that means +// to use Mac OS X style fullsync instead of fsync(). +// +// Do not confuse the SQLITE_SYNC_NORMAL and SQLITE_SYNC_FULL flags +// with the [PRAGMA synchronous]=NORMAL and [PRAGMA synchronous]=FULL +// settings. The [synchronous pragma] determines when calls to the +// xSync VFS method occur and applies uniformly across all platforms. +// The SQLITE_SYNC_NORMAL and SQLITE_SYNC_FULL flags determine how +// energetic or rigorous or forceful the sync operations are and +// only make a difference on Mac OSX for the default SQLite code. +// (Third-party VFS implementations might also make the distinction +// between SQLITE_SYNC_NORMAL and SQLITE_SYNC_FULL, but among the +// operating systems natively supported by SQLite, only Mac OSX +// cares about the difference.) + +// CAPI3REF: OS Interface Open File Handle +// +// An [sqlite3_file] object represents an open file in the +// [sqlite3_vfs | OS interface layer]. Individual OS interface +// implementations will +// want to subclass this object by appending additional fields +// for their own use. The pMethods entry is a pointer to an +// [sqlite3_io_methods] object that defines methods for performing +// I/O operations on the open file. +type sqlite3_file = sqlite3_file1 /* sqlite3.h:683:29 */ +type sqlite3_io_methods1 = struct { + iVersion int32 + _ [4]byte + xClose uintptr + xRead uintptr + xWrite uintptr + xTruncate uintptr + xSync uintptr + xFileSize uintptr + xLock uintptr + xUnlock uintptr + xCheckReservedLock uintptr + xFileControl uintptr + xSectorSize uintptr + xDeviceCharacteristics uintptr + xShmMap uintptr + xShmLock uintptr + xShmBarrier uintptr + xShmUnmap uintptr + xFetch uintptr + xUnfetch uintptr +} /* sqlite3.h:683:9 */ + +// CAPI3REF: OS Interface File Virtual Methods Object +// +// Every file opened by the [sqlite3_vfs.xOpen] method populates an +// [sqlite3_file] object (or, more commonly, a subclass of the +// [sqlite3_file] object) with a pointer to an instance of this object. +// This object defines the methods used to perform various operations +// against the open file represented by the [sqlite3_file] object. +// +// If the [sqlite3_vfs.xOpen] method sets the sqlite3_file.pMethods element +// to a non-NULL pointer, then the sqlite3_io_methods.xClose method +// may be invoked even if the [sqlite3_vfs.xOpen] reported that it failed. The +// only way to prevent a call to xClose following a failed [sqlite3_vfs.xOpen] +// is for the [sqlite3_vfs.xOpen] to set the sqlite3_file.pMethods element +// to NULL. +// +// The flags argument to xSync may be one of [SQLITE_SYNC_NORMAL] or +// [SQLITE_SYNC_FULL]. The first choice is the normal fsync(). +// The second choice is a Mac OS X style fullsync. The [SQLITE_SYNC_DATAONLY] +// flag may be ORed in to indicate that only the data of the file +// and not its inode needs to be synced. +// +// The integer values to xLock() and xUnlock() are one of +// <ul> +// <li> [SQLITE_LOCK_NONE], +// <li> [SQLITE_LOCK_SHARED], +// <li> [SQLITE_LOCK_RESERVED], +// <li> [SQLITE_LOCK_PENDING], or +// <li> [SQLITE_LOCK_EXCLUSIVE]. +// </ul> +// xLock() increases the lock. xUnlock() decreases the lock. +// The xCheckReservedLock() method checks whether any database connection, +// either in this process or in some other process, is holding a RESERVED, +// PENDING, or EXCLUSIVE lock on the file. It returns true +// if such a lock exists and false otherwise. +// +// The xFileControl() method is a generic interface that allows custom +// VFS implementations to directly control an open file using the +// [sqlite3_file_control()] interface. The second "op" argument is an +// integer opcode. The third argument is a generic pointer intended to +// point to a structure that may contain arguments or space in which to +// write return values. Potential uses for xFileControl() might be +// functions to enable blocking locks with timeouts, to change the +// locking strategy (for example to use dot-file locks), to inquire +// about the status of a lock, or to break stale locks. The SQLite +// core reserves all opcodes less than 100 for its own use. +// A [file control opcodes | list of opcodes] less than 100 is available. +// Applications that define a custom xFileControl method should use opcodes +// greater than 100 to avoid conflicts. VFS implementations should +// return [SQLITE_NOTFOUND] for file control opcodes that they do not +// recognize. +// +// The xSectorSize() method returns the sector size of the +// device that underlies the file. The sector size is the +// minimum write that can be performed without disturbing +// other bytes in the file. The xDeviceCharacteristics() +// method returns a bit vector describing behaviors of the +// underlying device: +// +// <ul> +// <li> [SQLITE_IOCAP_ATOMIC] +// <li> [SQLITE_IOCAP_ATOMIC512] +// <li> [SQLITE_IOCAP_ATOMIC1K] +// <li> [SQLITE_IOCAP_ATOMIC2K] +// <li> [SQLITE_IOCAP_ATOMIC4K] +// <li> [SQLITE_IOCAP_ATOMIC8K] +// <li> [SQLITE_IOCAP_ATOMIC16K] +// <li> [SQLITE_IOCAP_ATOMIC32K] +// <li> [SQLITE_IOCAP_ATOMIC64K] +// <li> [SQLITE_IOCAP_SAFE_APPEND] +// <li> [SQLITE_IOCAP_SEQUENTIAL] +// <li> [SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN] +// <li> [SQLITE_IOCAP_POWERSAFE_OVERWRITE] +// <li> [SQLITE_IOCAP_IMMUTABLE] +// <li> [SQLITE_IOCAP_BATCH_ATOMIC] +// </ul> +// +// The SQLITE_IOCAP_ATOMIC property means that all writes of +// any size are atomic. The SQLITE_IOCAP_ATOMICnnn values +// mean that writes of blocks that are nnn bytes in size and +// are aligned to an address which is an integer multiple of +// nnn are atomic. The SQLITE_IOCAP_SAFE_APPEND value means +// that when data is appended to a file, the data is appended +// first then the size of the file is extended, never the other +// way around. The SQLITE_IOCAP_SEQUENTIAL property means that +// information is written to disk in the same order as calls +// to xWrite(). +// +// If xRead() returns SQLITE_IOERR_SHORT_READ it must also fill +// in the unread portions of the buffer with zeros. A VFS that +// fails to zero-fill short reads might seem to work. However, +// failure to zero-fill short reads will eventually lead to +// database corruption. +type sqlite3_io_methods = sqlite3_io_methods1 /* sqlite3.h:782:35 */ + +// CAPI3REF: OS Interface Object +// +// An instance of the sqlite3_vfs object defines the interface between +// the SQLite core and the underlying operating system. The "vfs" +// in the name of the object stands for "virtual file system". See +// the [VFS | VFS documentation] for further information. +// +// The VFS interface is sometimes extended by adding new methods onto +// the end. Each time such an extension occurs, the iVersion field +// is incremented. The iVersion value started out as 1 in +// SQLite [version 3.5.0] on [dateof:3.5.0], then increased to 2 +// with SQLite [version 3.7.0] on [dateof:3.7.0], and then increased +// to 3 with SQLite [version 3.7.6] on [dateof:3.7.6]. Additional fields +// may be appended to the sqlite3_vfs object and the iVersion value +// may increase again in future versions of SQLite. +// Note that due to an oversight, the structure +// of the sqlite3_vfs object changed in the transition from +// SQLite [version 3.5.9] to [version 3.6.0] on [dateof:3.6.0] +// and yet the iVersion field was not increased. +// +// The szOsFile field is the size of the subclassed [sqlite3_file] +// structure used by this VFS. mxPathname is the maximum length of +// a pathname in this VFS. +// +// Registered sqlite3_vfs objects are kept on a linked list formed by +// the pNext pointer. The [sqlite3_vfs_register()] +// and [sqlite3_vfs_unregister()] interfaces manage this list +// in a thread-safe way. The [sqlite3_vfs_find()] interface +// searches the list. Neither the application code nor the VFS +// implementation should use the pNext pointer. +// +// The pNext field is the only field in the sqlite3_vfs +// structure that SQLite will ever modify. SQLite will only access +// or modify this field while holding a particular static mutex. +// The application should never modify anything within the sqlite3_vfs +// object once the object has been registered. +// +// The zName field holds the name of the VFS module. The name must +// be unique across all VFS modules. +// +// [[sqlite3_vfs.xOpen]] +// ^SQLite guarantees that the zFilename parameter to xOpen +// is either a NULL pointer or string obtained +// from xFullPathname() with an optional suffix added. +// ^If a suffix is added to the zFilename parameter, it will +// consist of a single "-" character followed by no more than +// 11 alphanumeric and/or "-" characters. +// ^SQLite further guarantees that +// the string will be valid and unchanged until xClose() is +// called. Because of the previous sentence, +// the [sqlite3_file] can safely store a pointer to the +// filename if it needs to remember the filename for some reason. +// If the zFilename parameter to xOpen is a NULL pointer then xOpen +// must invent its own temporary name for the file. ^Whenever the +// xFilename parameter is NULL it will also be the case that the +// flags parameter will include [SQLITE_OPEN_DELETEONCLOSE]. +// +// The flags argument to xOpen() includes all bits set in +// the flags argument to [sqlite3_open_v2()]. Or if [sqlite3_open()] +// or [sqlite3_open16()] is used, then flags includes at least +// [SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE]. +// If xOpen() opens a file read-only then it sets *pOutFlags to +// include [SQLITE_OPEN_READONLY]. Other bits in *pOutFlags may be set. +// +// ^(SQLite will also add one of the following flags to the xOpen() +// call, depending on the object being opened: +// +// <ul> +// <li> [SQLITE_OPEN_MAIN_DB] +// <li> [SQLITE_OPEN_MAIN_JOURNAL] +// <li> [SQLITE_OPEN_TEMP_DB] +// <li> [SQLITE_OPEN_TEMP_JOURNAL] +// <li> [SQLITE_OPEN_TRANSIENT_DB] +// <li> [SQLITE_OPEN_SUBJOURNAL] +// <li> [SQLITE_OPEN_SUPER_JOURNAL] +// <li> [SQLITE_OPEN_WAL] +// </ul>)^ +// +// The file I/O implementation can use the object type flags to +// change the way it deals with files. For example, an application +// that does not care about crash recovery or rollback might make +// the open of a journal file a no-op. Writes to this journal would +// also be no-ops, and any attempt to read the journal would return +// SQLITE_IOERR. Or the implementation might recognize that a database +// file will be doing page-aligned sector reads and writes in a random +// order and set up its I/O subsystem accordingly. +// +// SQLite might also add one of the following flags to the xOpen method: +// +// <ul> +// <li> [SQLITE_OPEN_DELETEONCLOSE] +// <li> [SQLITE_OPEN_EXCLUSIVE] +// </ul> +// +// The [SQLITE_OPEN_DELETEONCLOSE] flag means the file should be +// deleted when it is closed. ^The [SQLITE_OPEN_DELETEONCLOSE] +// will be set for TEMP databases and their journals, transient +// databases, and subjournals. +// +// ^The [SQLITE_OPEN_EXCLUSIVE] flag is always used in conjunction +// with the [SQLITE_OPEN_CREATE] flag, which are both directly +// analogous to the O_EXCL and O_CREAT flags of the POSIX open() +// API. The SQLITE_OPEN_EXCLUSIVE flag, when paired with the +// SQLITE_OPEN_CREATE, is used to indicate that file should always +// be created, and that it is an error if it already exists. +// It is <i>not</i> used to indicate the file should be opened +// for exclusive access. +// +// ^At least szOsFile bytes of memory are allocated by SQLite +// to hold the [sqlite3_file] structure passed as the third +// argument to xOpen. The xOpen method does not have to +// allocate the structure; it should just fill it in. Note that +// the xOpen method must set the sqlite3_file.pMethods to either +// a valid [sqlite3_io_methods] object or to NULL. xOpen must do +// this even if the open fails. SQLite expects that the sqlite3_file.pMethods +// element will be valid after xOpen returns regardless of the success +// or failure of the xOpen call. +// +// [[sqlite3_vfs.xAccess]] +// ^The flags argument to xAccess() may be [SQLITE_ACCESS_EXISTS] +// to test for the existence of a file, or [SQLITE_ACCESS_READWRITE] to +// test whether a file is readable and writable, or [SQLITE_ACCESS_READ] +// to test whether a file is at least readable. The SQLITE_ACCESS_READ +// flag is never actually used and is not implemented in the built-in +// VFSes of SQLite. The file is named by the second argument and can be a +// directory. The xAccess method returns [SQLITE_OK] on success or some +// non-zero error code if there is an I/O error or if the name of +// the file given in the second argument is illegal. If SQLITE_OK +// is returned, then non-zero or zero is written into *pResOut to indicate +// whether or not the file is accessible. +// +// ^SQLite will always allocate at least mxPathname+1 bytes for the +// output buffer xFullPathname. The exact size of the output buffer +// is also passed as a parameter to both methods. If the output buffer +// is not large enough, [SQLITE_CANTOPEN] should be returned. Since this is +// handled as a fatal error by SQLite, vfs implementations should endeavor +// to prevent this by setting mxPathname to a sufficiently large value. +// +// The xRandomness(), xSleep(), xCurrentTime(), and xCurrentTimeInt64() +// interfaces are not strictly a part of the filesystem, but they are +// included in the VFS structure for completeness. +// The xRandomness() function attempts to return nBytes bytes +// of good-quality randomness into zOut. The return value is +// the actual number of bytes of randomness obtained. +// The xSleep() method causes the calling thread to sleep for at +// least the number of microseconds given. ^The xCurrentTime() +// method returns a Julian Day Number for the current date and time as +// a floating point value. +// ^The xCurrentTimeInt64() method returns, as an integer, the Julian +// Day Number multiplied by 86400000 (the number of milliseconds in +// a 24-hour day). +// ^SQLite will use the xCurrentTimeInt64() method to get the current +// date and time if that method is available (if iVersion is 2 or +// greater and the function pointer is not NULL) and will fall back +// to xCurrentTime() if xCurrentTimeInt64() is unavailable. +// +// ^The xSetSystemCall(), xGetSystemCall(), and xNestSystemCall() interfaces +// are not used by the SQLite core. These optional interfaces are provided +// by some VFSes to facilitate testing of the VFS code. By overriding +// system calls with functions under its control, a test program can +// simulate faults and error conditions that would otherwise be difficult +// or impossible to induce. The set of system calls that can be overridden +// varies from one VFS to another, and from one version of the same VFS to the +// next. Applications that use these interfaces must be prepared for any +// or all of these interfaces to be NULL or for their behavior to change +// from one release to the next. Applications must not attempt to access +// any of these methods if the iVersion of the VFS is less than 3. +type sqlite3_vfs1 = struct { + iVersion int32 + szOsFile int32 + mxPathname int32 + _ [4]byte + pNext uintptr + zName uintptr + pAppData uintptr + xOpen uintptr + xDelete uintptr + xAccess uintptr + xFullPathname uintptr + xDlOpen uintptr + xDlError uintptr + xDlSym uintptr + xDlClose uintptr + xRandomness uintptr + xSleep uintptr + xCurrentTime uintptr + xGetLastError uintptr + xCurrentTimeInt64 uintptr + xSetSystemCall uintptr + xGetSystemCall uintptr + xNextSystemCall uintptr +} /* sqlite3.h:1367:9 */ + +// CAPI3REF: OS Interface Object +// +// An instance of the sqlite3_vfs object defines the interface between +// the SQLite core and the underlying operating system. The "vfs" +// in the name of the object stands for "virtual file system". See +// the [VFS | VFS documentation] for further information. +// +// The VFS interface is sometimes extended by adding new methods onto +// the end. Each time such an extension occurs, the iVersion field +// is incremented. The iVersion value started out as 1 in +// SQLite [version 3.5.0] on [dateof:3.5.0], then increased to 2 +// with SQLite [version 3.7.0] on [dateof:3.7.0], and then increased +// to 3 with SQLite [version 3.7.6] on [dateof:3.7.6]. Additional fields +// may be appended to the sqlite3_vfs object and the iVersion value +// may increase again in future versions of SQLite. +// Note that due to an oversight, the structure +// of the sqlite3_vfs object changed in the transition from +// SQLite [version 3.5.9] to [version 3.6.0] on [dateof:3.6.0] +// and yet the iVersion field was not increased. +// +// The szOsFile field is the size of the subclassed [sqlite3_file] +// structure used by this VFS. mxPathname is the maximum length of +// a pathname in this VFS. +// +// Registered sqlite3_vfs objects are kept on a linked list formed by +// the pNext pointer. The [sqlite3_vfs_register()] +// and [sqlite3_vfs_unregister()] interfaces manage this list +// in a thread-safe way. The [sqlite3_vfs_find()] interface +// searches the list. Neither the application code nor the VFS +// implementation should use the pNext pointer. +// +// The pNext field is the only field in the sqlite3_vfs +// structure that SQLite will ever modify. SQLite will only access +// or modify this field while holding a particular static mutex. +// The application should never modify anything within the sqlite3_vfs +// object once the object has been registered. +// +// The zName field holds the name of the VFS module. The name must +// be unique across all VFS modules. +// +// [[sqlite3_vfs.xOpen]] +// ^SQLite guarantees that the zFilename parameter to xOpen +// is either a NULL pointer or string obtained +// from xFullPathname() with an optional suffix added. +// ^If a suffix is added to the zFilename parameter, it will +// consist of a single "-" character followed by no more than +// 11 alphanumeric and/or "-" characters. +// ^SQLite further guarantees that +// the string will be valid and unchanged until xClose() is +// called. Because of the previous sentence, +// the [sqlite3_file] can safely store a pointer to the +// filename if it needs to remember the filename for some reason. +// If the zFilename parameter to xOpen is a NULL pointer then xOpen +// must invent its own temporary name for the file. ^Whenever the +// xFilename parameter is NULL it will also be the case that the +// flags parameter will include [SQLITE_OPEN_DELETEONCLOSE]. +// +// The flags argument to xOpen() includes all bits set in +// the flags argument to [sqlite3_open_v2()]. Or if [sqlite3_open()] +// or [sqlite3_open16()] is used, then flags includes at least +// [SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE]. +// If xOpen() opens a file read-only then it sets *pOutFlags to +// include [SQLITE_OPEN_READONLY]. Other bits in *pOutFlags may be set. +// +// ^(SQLite will also add one of the following flags to the xOpen() +// call, depending on the object being opened: +// +// <ul> +// <li> [SQLITE_OPEN_MAIN_DB] +// <li> [SQLITE_OPEN_MAIN_JOURNAL] +// <li> [SQLITE_OPEN_TEMP_DB] +// <li> [SQLITE_OPEN_TEMP_JOURNAL] +// <li> [SQLITE_OPEN_TRANSIENT_DB] +// <li> [SQLITE_OPEN_SUBJOURNAL] +// <li> [SQLITE_OPEN_SUPER_JOURNAL] +// <li> [SQLITE_OPEN_WAL] +// </ul>)^ +// +// The file I/O implementation can use the object type flags to +// change the way it deals with files. For example, an application +// that does not care about crash recovery or rollback might make +// the open of a journal file a no-op. Writes to this journal would +// also be no-ops, and any attempt to read the journal would return +// SQLITE_IOERR. Or the implementation might recognize that a database +// file will be doing page-aligned sector reads and writes in a random +// order and set up its I/O subsystem accordingly. +// +// SQLite might also add one of the following flags to the xOpen method: +// +// <ul> +// <li> [SQLITE_OPEN_DELETEONCLOSE] +// <li> [SQLITE_OPEN_EXCLUSIVE] +// </ul> +// +// The [SQLITE_OPEN_DELETEONCLOSE] flag means the file should be +// deleted when it is closed. ^The [SQLITE_OPEN_DELETEONCLOSE] +// will be set for TEMP databases and their journals, transient +// databases, and subjournals. +// +// ^The [SQLITE_OPEN_EXCLUSIVE] flag is always used in conjunction +// with the [SQLITE_OPEN_CREATE] flag, which are both directly +// analogous to the O_EXCL and O_CREAT flags of the POSIX open() +// API. The SQLITE_OPEN_EXCLUSIVE flag, when paired with the +// SQLITE_OPEN_CREATE, is used to indicate that file should always +// be created, and that it is an error if it already exists. +// It is <i>not</i> used to indicate the file should be opened +// for exclusive access. +// +// ^At least szOsFile bytes of memory are allocated by SQLite +// to hold the [sqlite3_file] structure passed as the third +// argument to xOpen. The xOpen method does not have to +// allocate the structure; it should just fill it in. Note that +// the xOpen method must set the sqlite3_file.pMethods to either +// a valid [sqlite3_io_methods] object or to NULL. xOpen must do +// this even if the open fails. SQLite expects that the sqlite3_file.pMethods +// element will be valid after xOpen returns regardless of the success +// or failure of the xOpen call. +// +// [[sqlite3_vfs.xAccess]] +// ^The flags argument to xAccess() may be [SQLITE_ACCESS_EXISTS] +// to test for the existence of a file, or [SQLITE_ACCESS_READWRITE] to +// test whether a file is readable and writable, or [SQLITE_ACCESS_READ] +// to test whether a file is at least readable. The SQLITE_ACCESS_READ +// flag is never actually used and is not implemented in the built-in +// VFSes of SQLite. The file is named by the second argument and can be a +// directory. The xAccess method returns [SQLITE_OK] on success or some +// non-zero error code if there is an I/O error or if the name of +// the file given in the second argument is illegal. If SQLITE_OK +// is returned, then non-zero or zero is written into *pResOut to indicate +// whether or not the file is accessible. +// +// ^SQLite will always allocate at least mxPathname+1 bytes for the +// output buffer xFullPathname. The exact size of the output buffer +// is also passed as a parameter to both methods. If the output buffer +// is not large enough, [SQLITE_CANTOPEN] should be returned. Since this is +// handled as a fatal error by SQLite, vfs implementations should endeavor +// to prevent this by setting mxPathname to a sufficiently large value. +// +// The xRandomness(), xSleep(), xCurrentTime(), and xCurrentTimeInt64() +// interfaces are not strictly a part of the filesystem, but they are +// included in the VFS structure for completeness. +// The xRandomness() function attempts to return nBytes bytes +// of good-quality randomness into zOut. The return value is +// the actual number of bytes of randomness obtained. +// The xSleep() method causes the calling thread to sleep for at +// least the number of microseconds given. ^The xCurrentTime() +// method returns a Julian Day Number for the current date and time as +// a floating point value. +// ^The xCurrentTimeInt64() method returns, as an integer, the Julian +// Day Number multiplied by 86400000 (the number of milliseconds in +// a 24-hour day). +// ^SQLite will use the xCurrentTimeInt64() method to get the current +// date and time if that method is available (if iVersion is 2 or +// greater and the function pointer is not NULL) and will fall back +// to xCurrentTime() if xCurrentTimeInt64() is unavailable. +// +// ^The xSetSystemCall(), xGetSystemCall(), and xNestSystemCall() interfaces +// are not used by the SQLite core. These optional interfaces are provided +// by some VFSes to facilitate testing of the VFS code. By overriding +// system calls with functions under its control, a test program can +// simulate faults and error conditions that would otherwise be difficult +// or impossible to induce. The set of system calls that can be overridden +// varies from one VFS to another, and from one version of the same VFS to the +// next. Applications that use these interfaces must be prepared for any +// or all of these interfaces to be NULL or for their behavior to change +// from one release to the next. Applications must not attempt to access +// any of these methods if the iVersion of the VFS is less than 3. +type sqlite3_vfs = sqlite3_vfs1 /* sqlite3.h:1367:28 */ +type sqlite3_syscall_ptr = uintptr /* sqlite3.h:1368:14 */ + +// CAPI3REF: Memory Allocation Routines +// +// An instance of this object defines the interface between SQLite +// and low-level memory allocation routines. +// +// This object is used in only one place in the SQLite interface. +// A pointer to an instance of this object is the argument to +// [sqlite3_config()] when the configuration option is +// [SQLITE_CONFIG_MALLOC] or [SQLITE_CONFIG_GETMALLOC]. +// By creating an instance of this object +// and passing it to [sqlite3_config]([SQLITE_CONFIG_MALLOC]) +// during configuration, an application can specify an alternative +// memory allocation subsystem for SQLite to use for all of its +// dynamic memory needs. +// +// Note that SQLite comes with several [built-in memory allocators] +// that are perfectly adequate for the overwhelming majority of applications +// and that this object is only useful to a tiny minority of applications +// with specialized memory allocation requirements. This object is +// also used during testing of SQLite in order to specify an alternative +// memory allocator that simulates memory out-of-memory conditions in +// order to verify that SQLite recovers gracefully from such +// conditions. +// +// The xMalloc, xRealloc, and xFree methods must work like the +// malloc(), realloc() and free() functions from the standard C library. +// ^SQLite guarantees that the second argument to +// xRealloc is always a value returned by a prior call to xRoundup. +// +// xSize should return the allocated size of a memory allocation +// previously obtained from xMalloc or xRealloc. The allocated size +// is always at least as big as the requested size but may be larger. +// +// The xRoundup method returns what would be the allocated size of +// a memory allocation given a particular requested size. Most memory +// allocators round up memory allocations at least to the next multiple +// of 8. Some allocators round up to a larger multiple or to a power of 2. +// Every memory allocation request coming in through [sqlite3_malloc()] +// or [sqlite3_realloc()] first calls xRoundup. If xRoundup returns 0, +// that causes the corresponding memory allocation to fail. +// +// The xInit method initializes the memory allocator. For example, +// it might allocate any required mutexes or initialize internal data +// structures. The xShutdown method is invoked (indirectly) by +// [sqlite3_shutdown()] and should deallocate any resources acquired +// by xInit. The pAppData pointer is used as the only parameter to +// xInit and xShutdown. +// +// SQLite holds the [SQLITE_MUTEX_STATIC_MAIN] mutex when it invokes +// the xInit method, so the xInit method need not be threadsafe. The +// xShutdown method is only called from [sqlite3_shutdown()] so it does +// not need to be threadsafe either. For all other methods, SQLite +// holds the [SQLITE_MUTEX_STATIC_MEM] mutex as long as the +// [SQLITE_CONFIG_MEMSTATUS] configuration option is turned on (which +// it is by default) and so the methods are automatically serialized. +// However, if [SQLITE_CONFIG_MEMSTATUS] is disabled, then the other +// methods must be threadsafe or else make their own arrangements for +// serialization. +// +// SQLite will never invoke xInit() more than once without an intervening +// call to xShutdown(). +type sqlite3_mem_methods1 = struct { + xMalloc uintptr + xFree uintptr + xRealloc uintptr + xSize uintptr + xRoundup uintptr + xInit uintptr + xShutdown uintptr + pAppData uintptr +} /* sqlite3.h:1665:9 */ + +// CAPI3REF: Memory Allocation Routines +// +// An instance of this object defines the interface between SQLite +// and low-level memory allocation routines. +// +// This object is used in only one place in the SQLite interface. +// A pointer to an instance of this object is the argument to +// [sqlite3_config()] when the configuration option is +// [SQLITE_CONFIG_MALLOC] or [SQLITE_CONFIG_GETMALLOC]. +// By creating an instance of this object +// and passing it to [sqlite3_config]([SQLITE_CONFIG_MALLOC]) +// during configuration, an application can specify an alternative +// memory allocation subsystem for SQLite to use for all of its +// dynamic memory needs. +// +// Note that SQLite comes with several [built-in memory allocators] +// that are perfectly adequate for the overwhelming majority of applications +// and that this object is only useful to a tiny minority of applications +// with specialized memory allocation requirements. This object is +// also used during testing of SQLite in order to specify an alternative +// memory allocator that simulates memory out-of-memory conditions in +// order to verify that SQLite recovers gracefully from such +// conditions. +// +// The xMalloc, xRealloc, and xFree methods must work like the +// malloc(), realloc() and free() functions from the standard C library. +// ^SQLite guarantees that the second argument to +// xRealloc is always a value returned by a prior call to xRoundup. +// +// xSize should return the allocated size of a memory allocation +// previously obtained from xMalloc or xRealloc. The allocated size +// is always at least as big as the requested size but may be larger. +// +// The xRoundup method returns what would be the allocated size of +// a memory allocation given a particular requested size. Most memory +// allocators round up memory allocations at least to the next multiple +// of 8. Some allocators round up to a larger multiple or to a power of 2. +// Every memory allocation request coming in through [sqlite3_malloc()] +// or [sqlite3_realloc()] first calls xRoundup. If xRoundup returns 0, +// that causes the corresponding memory allocation to fail. +// +// The xInit method initializes the memory allocator. For example, +// it might allocate any required mutexes or initialize internal data +// structures. The xShutdown method is invoked (indirectly) by +// [sqlite3_shutdown()] and should deallocate any resources acquired +// by xInit. The pAppData pointer is used as the only parameter to +// xInit and xShutdown. +// +// SQLite holds the [SQLITE_MUTEX_STATIC_MAIN] mutex when it invokes +// the xInit method, so the xInit method need not be threadsafe. The +// xShutdown method is only called from [sqlite3_shutdown()] so it does +// not need to be threadsafe either. For all other methods, SQLite +// holds the [SQLITE_MUTEX_STATIC_MEM] mutex as long as the +// [SQLITE_CONFIG_MEMSTATUS] configuration option is turned on (which +// it is by default) and so the methods are automatically serialized. +// However, if [SQLITE_CONFIG_MEMSTATUS] is disabled, then the other +// methods must be threadsafe or else make their own arrangements for +// serialization. +// +// SQLite will never invoke xInit() more than once without an intervening +// call to xShutdown(). +type sqlite3_mem_methods = sqlite3_mem_methods1 /* sqlite3.h:1665:36 */ + +// CAPI3REF: Constants Defining Special Destructor Behavior +// +// These are special values for the destructor that is passed in as the +// final argument to routines like [sqlite3_result_blob()]. ^If the destructor +// argument is SQLITE_STATIC, it means that the content pointer is constant +// and will never change. It does not need to be destroyed. ^The +// SQLITE_TRANSIENT value means that the content will likely change in +// the near future and that SQLite should make its own private copy of +// the content before returning. +// +// The typedef is necessary to work around problems in certain +// C++ compilers. +type sqlite3_destructor_type = uintptr /* sqlite3.h:5621:14 */ + +// The interface to the virtual-table mechanism is currently considered +// to be experimental. The interface might change in incompatible ways. +// If this is a problem for you, do not use the interface at this time. +// +// When the virtual-table mechanism stabilizes, we will declare the +// interface fixed, support it indefinitely, and remove this comment. + +// Structures used by the virtual table interface +type sqlite3_vtab1 = struct { + pModule uintptr + nRef int32 + _ [4]byte + zErrMsg uintptr +} /* sqlite3.h:6689:9 */ + +// The interface to the virtual-table mechanism is currently considered +// to be experimental. The interface might change in incompatible ways. +// If this is a problem for you, do not use the interface at this time. +// +// When the virtual-table mechanism stabilizes, we will declare the +// interface fixed, support it indefinitely, and remove this comment. + +// Structures used by the virtual table interface +type sqlite3_vtab = sqlite3_vtab1 /* sqlite3.h:6689:29 */ +type sqlite3_index_info1 = struct { + nConstraint int32 + _ [4]byte + aConstraint uintptr + nOrderBy int32 + _ [4]byte + aOrderBy uintptr + aConstraintUsage uintptr + idxNum int32 + _ [4]byte + idxStr uintptr + needToFreeIdxStr int32 + orderByConsumed int32 + estimatedCost float64 + estimatedRows sqlite3_int64 + idxFlags int32 + _ [4]byte + colUsed sqlite3_uint64 +} /* sqlite3.h:6690:9 */ + +type sqlite3_index_info = sqlite3_index_info1 /* sqlite3.h:6690:35 */ +type sqlite3_vtab_cursor1 = struct{ pVtab uintptr } /* sqlite3.h:6691:9 */ + +type sqlite3_vtab_cursor = sqlite3_vtab_cursor1 /* sqlite3.h:6691:36 */ +type sqlite3_module1 = struct { + iVersion int32 + _ [4]byte + xCreate uintptr + xConnect uintptr + xBestIndex uintptr + xDisconnect uintptr + xDestroy uintptr + xOpen uintptr + xClose uintptr + xFilter uintptr + xNext uintptr + xEof uintptr + xColumn uintptr + xRowid uintptr + xUpdate uintptr + xBegin uintptr + xSync uintptr + xCommit uintptr + xRollback uintptr + xFindFunction uintptr + xRename uintptr + xSavepoint uintptr + xRelease uintptr + xRollbackTo uintptr + xShadowName uintptr +} /* sqlite3.h:6689:9 */ + +type sqlite3_module = sqlite3_module1 /* sqlite3.h:6692:31 */ + +// CAPI3REF: Virtual Table Indexing Information +// KEYWORDS: sqlite3_index_info +// +// The sqlite3_index_info structure and its substructures is used as part +// of the [virtual table] interface to +// pass information into and receive the reply from the [xBestIndex] +// method of a [virtual table module]. The fields under **Inputs** are the +// inputs to xBestIndex and are read-only. xBestIndex inserts its +// results into the **Outputs** fields. +// +// ^(The aConstraint[] array records WHERE clause constraints of the form: +// +// <blockquote>column OP expr</blockquote> +// +// where OP is =, <, <=, >, or >=.)^ ^(The particular operator is +// stored in aConstraint[].op using one of the +// [SQLITE_INDEX_CONSTRAINT_EQ | SQLITE_INDEX_CONSTRAINT_ values].)^ +// ^(The index of the column is stored in +// aConstraint[].iColumn.)^ ^(aConstraint[].usable is TRUE if the +// expr on the right-hand side can be evaluated (and thus the constraint +// is usable) and false if it cannot.)^ +// +// ^The optimizer automatically inverts terms of the form "expr OP column" +// and makes other simplifications to the WHERE clause in an attempt to +// get as many WHERE clause terms into the form shown above as possible. +// ^The aConstraint[] array only reports WHERE clause terms that are +// relevant to the particular virtual table being queried. +// +// ^Information about the ORDER BY clause is stored in aOrderBy[]. +// ^Each term of aOrderBy records a column of the ORDER BY clause. +// +// The colUsed field indicates which columns of the virtual table may be +// required by the current scan. Virtual table columns are numbered from +// zero in the order in which they appear within the CREATE TABLE statement +// passed to sqlite3_declare_vtab(). For the first 63 columns (columns 0-62), +// the corresponding bit is set within the colUsed mask if the column may be +// required by SQLite. If the table has at least 64 columns and any column +// to the right of the first 63 is required, then bit 63 of colUsed is also +// set. In other words, column iCol may be required if the expression +// (colUsed & ((sqlite3_uint64)1 << (iCol>=63 ? 63 : iCol))) evaluates to +// non-zero. +// +// The [xBestIndex] method must fill aConstraintUsage[] with information +// about what parameters to pass to xFilter. ^If argvIndex>0 then +// the right-hand side of the corresponding aConstraint[] is evaluated +// and becomes the argvIndex-th entry in argv. ^(If aConstraintUsage[].omit +// is true, then the constraint is assumed to be fully handled by the +// virtual table and might not be checked again by the byte code.)^ ^(The +// aConstraintUsage[].omit flag is an optimization hint. When the omit flag +// is left in its default setting of false, the constraint will always be +// checked separately in byte code. If the omit flag is change to true, then +// the constraint may or may not be checked in byte code. In other words, +// when the omit flag is true there is no guarantee that the constraint will +// not be checked again using byte code.)^ +// +// ^The idxNum and idxPtr values are recorded and passed into the +// [xFilter] method. +// ^[sqlite3_free()] is used to free idxPtr if and only if +// needToFreeIdxPtr is true. +// +// ^The orderByConsumed means that output from [xFilter]/[xNext] will occur in +// the correct order to satisfy the ORDER BY clause so that no separate +// sorting step is required. +// +// ^The estimatedCost value is an estimate of the cost of a particular +// strategy. A cost of N indicates that the cost of the strategy is similar +// to a linear scan of an SQLite table with N rows. A cost of log(N) +// indicates that the expense of the operation is similar to that of a +// binary search on a unique indexed field of an SQLite table with N rows. +// +// ^The estimatedRows value is an estimate of the number of rows that +// will be returned by the strategy. +// +// The xBestIndex method may optionally populate the idxFlags field with a +// mask of SQLITE_INDEX_SCAN_* flags. Currently there is only one such flag - +// SQLITE_INDEX_SCAN_UNIQUE. If the xBestIndex method sets this flag, SQLite +// assumes that the strategy may visit at most one row. +// +// Additionally, if xBestIndex sets the SQLITE_INDEX_SCAN_UNIQUE flag, then +// SQLite also assumes that if a call to the xUpdate() method is made as +// part of the same statement to delete or update a virtual table row and the +// implementation returns SQLITE_CONSTRAINT, then there is no need to rollback +// any database changes. In other words, if the xUpdate() returns +// SQLITE_CONSTRAINT, the database contents must be exactly as they were +// before xUpdate was called. By contrast, if SQLITE_INDEX_SCAN_UNIQUE is not +// set and xUpdate returns SQLITE_CONSTRAINT, any database changes made by +// the xUpdate method are automatically rolled back by SQLite. +// +// IMPORTANT: The estimatedRows field was added to the sqlite3_index_info +// structure for SQLite [version 3.8.2] ([dateof:3.8.2]). +// If a virtual table extension is +// used with an SQLite version earlier than 3.8.2, the results of attempting +// to read or write the estimatedRows field are undefined (but are likely +// to include crashing the application). The estimatedRows field should +// therefore only be used if [sqlite3_libversion_number()] returns a +// value greater than or equal to 3008002. Similarly, the idxFlags field +// was added for [version 3.9.0] ([dateof:3.9.0]). +// It may therefore only be used if +// sqlite3_libversion_number() returns a value greater than or equal to +// 3009000. +type sqlite3_index_constraint = struct { + iColumn int32 + op uint8 + usable uint8 + _ [2]byte + iTermOffset int32 +} /* sqlite3.h:6690:9 */ + +// CAPI3REF: Virtual Table Indexing Information +// KEYWORDS: sqlite3_index_info +// +// The sqlite3_index_info structure and its substructures is used as part +// of the [virtual table] interface to +// pass information into and receive the reply from the [xBestIndex] +// method of a [virtual table module]. The fields under **Inputs** are the +// inputs to xBestIndex and are read-only. xBestIndex inserts its +// results into the **Outputs** fields. +// +// ^(The aConstraint[] array records WHERE clause constraints of the form: +// +// <blockquote>column OP expr</blockquote> +// +// where OP is =, <, <=, >, or >=.)^ ^(The particular operator is +// stored in aConstraint[].op using one of the +// [SQLITE_INDEX_CONSTRAINT_EQ | SQLITE_INDEX_CONSTRAINT_ values].)^ +// ^(The index of the column is stored in +// aConstraint[].iColumn.)^ ^(aConstraint[].usable is TRUE if the +// expr on the right-hand side can be evaluated (and thus the constraint +// is usable) and false if it cannot.)^ +// +// ^The optimizer automatically inverts terms of the form "expr OP column" +// and makes other simplifications to the WHERE clause in an attempt to +// get as many WHERE clause terms into the form shown above as possible. +// ^The aConstraint[] array only reports WHERE clause terms that are +// relevant to the particular virtual table being queried. +// +// ^Information about the ORDER BY clause is stored in aOrderBy[]. +// ^Each term of aOrderBy records a column of the ORDER BY clause. +// +// The colUsed field indicates which columns of the virtual table may be +// required by the current scan. Virtual table columns are numbered from +// zero in the order in which they appear within the CREATE TABLE statement +// passed to sqlite3_declare_vtab(). For the first 63 columns (columns 0-62), +// the corresponding bit is set within the colUsed mask if the column may be +// required by SQLite. If the table has at least 64 columns and any column +// to the right of the first 63 is required, then bit 63 of colUsed is also +// set. In other words, column iCol may be required if the expression +// (colUsed & ((sqlite3_uint64)1 << (iCol>=63 ? 63 : iCol))) evaluates to +// non-zero. +// +// The [xBestIndex] method must fill aConstraintUsage[] with information +// about what parameters to pass to xFilter. ^If argvIndex>0 then +// the right-hand side of the corresponding aConstraint[] is evaluated +// and becomes the argvIndex-th entry in argv. ^(If aConstraintUsage[].omit +// is true, then the constraint is assumed to be fully handled by the +// virtual table and might not be checked again by the byte code.)^ ^(The +// aConstraintUsage[].omit flag is an optimization hint. When the omit flag +// is left in its default setting of false, the constraint will always be +// checked separately in byte code. If the omit flag is change to true, then +// the constraint may or may not be checked in byte code. In other words, +// when the omit flag is true there is no guarantee that the constraint will +// not be checked again using byte code.)^ +// +// ^The idxNum and idxPtr values are recorded and passed into the +// [xFilter] method. +// ^[sqlite3_free()] is used to free idxPtr if and only if +// needToFreeIdxPtr is true. +// +// ^The orderByConsumed means that output from [xFilter]/[xNext] will occur in +// the correct order to satisfy the ORDER BY clause so that no separate +// sorting step is required. +// +// ^The estimatedCost value is an estimate of the cost of a particular +// strategy. A cost of N indicates that the cost of the strategy is similar +// to a linear scan of an SQLite table with N rows. A cost of log(N) +// indicates that the expense of the operation is similar to that of a +// binary search on a unique indexed field of an SQLite table with N rows. +// +// ^The estimatedRows value is an estimate of the number of rows that +// will be returned by the strategy. +// +// The xBestIndex method may optionally populate the idxFlags field with a +// mask of SQLITE_INDEX_SCAN_* flags. Currently there is only one such flag - +// SQLITE_INDEX_SCAN_UNIQUE. If the xBestIndex method sets this flag, SQLite +// assumes that the strategy may visit at most one row. +// +// Additionally, if xBestIndex sets the SQLITE_INDEX_SCAN_UNIQUE flag, then +// SQLite also assumes that if a call to the xUpdate() method is made as +// part of the same statement to delete or update a virtual table row and the +// implementation returns SQLITE_CONSTRAINT, then there is no need to rollback +// any database changes. In other words, if the xUpdate() returns +// SQLITE_CONSTRAINT, the database contents must be exactly as they were +// before xUpdate was called. By contrast, if SQLITE_INDEX_SCAN_UNIQUE is not +// set and xUpdate returns SQLITE_CONSTRAINT, any database changes made by +// the xUpdate method are automatically rolled back by SQLite. +// +// IMPORTANT: The estimatedRows field was added to the sqlite3_index_info +// structure for SQLite [version 3.8.2] ([dateof:3.8.2]). +// If a virtual table extension is +// used with an SQLite version earlier than 3.8.2, the results of attempting +// to read or write the estimatedRows field are undefined (but are likely +// to include crashing the application). The estimatedRows field should +// therefore only be used if [sqlite3_libversion_number()] returns a +// value greater than or equal to 3008002. Similarly, the idxFlags field +// was added for [version 3.9.0] ([dateof:3.9.0]). +// It may therefore only be used if +// sqlite3_libversion_number() returns a value greater than or equal to +// 3009000. +type sqlite3_index_orderby = struct { + iColumn int32 + desc uint8 + _ [3]byte +} /* sqlite3.h:6690:9 */ + +// CAPI3REF: Virtual Table Indexing Information +// KEYWORDS: sqlite3_index_info +// +// The sqlite3_index_info structure and its substructures is used as part +// of the [virtual table] interface to +// pass information into and receive the reply from the [xBestIndex] +// method of a [virtual table module]. The fields under **Inputs** are the +// inputs to xBestIndex and are read-only. xBestIndex inserts its +// results into the **Outputs** fields. +// +// ^(The aConstraint[] array records WHERE clause constraints of the form: +// +// <blockquote>column OP expr</blockquote> +// +// where OP is =, <, <=, >, or >=.)^ ^(The particular operator is +// stored in aConstraint[].op using one of the +// [SQLITE_INDEX_CONSTRAINT_EQ | SQLITE_INDEX_CONSTRAINT_ values].)^ +// ^(The index of the column is stored in +// aConstraint[].iColumn.)^ ^(aConstraint[].usable is TRUE if the +// expr on the right-hand side can be evaluated (and thus the constraint +// is usable) and false if it cannot.)^ +// +// ^The optimizer automatically inverts terms of the form "expr OP column" +// and makes other simplifications to the WHERE clause in an attempt to +// get as many WHERE clause terms into the form shown above as possible. +// ^The aConstraint[] array only reports WHERE clause terms that are +// relevant to the particular virtual table being queried. +// +// ^Information about the ORDER BY clause is stored in aOrderBy[]. +// ^Each term of aOrderBy records a column of the ORDER BY clause. +// +// The colUsed field indicates which columns of the virtual table may be +// required by the current scan. Virtual table columns are numbered from +// zero in the order in which they appear within the CREATE TABLE statement +// passed to sqlite3_declare_vtab(). For the first 63 columns (columns 0-62), +// the corresponding bit is set within the colUsed mask if the column may be +// required by SQLite. If the table has at least 64 columns and any column +// to the right of the first 63 is required, then bit 63 of colUsed is also +// set. In other words, column iCol may be required if the expression +// (colUsed & ((sqlite3_uint64)1 << (iCol>=63 ? 63 : iCol))) evaluates to +// non-zero. +// +// The [xBestIndex] method must fill aConstraintUsage[] with information +// about what parameters to pass to xFilter. ^If argvIndex>0 then +// the right-hand side of the corresponding aConstraint[] is evaluated +// and becomes the argvIndex-th entry in argv. ^(If aConstraintUsage[].omit +// is true, then the constraint is assumed to be fully handled by the +// virtual table and might not be checked again by the byte code.)^ ^(The +// aConstraintUsage[].omit flag is an optimization hint. When the omit flag +// is left in its default setting of false, the constraint will always be +// checked separately in byte code. If the omit flag is change to true, then +// the constraint may or may not be checked in byte code. In other words, +// when the omit flag is true there is no guarantee that the constraint will +// not be checked again using byte code.)^ +// +// ^The idxNum and idxPtr values are recorded and passed into the +// [xFilter] method. +// ^[sqlite3_free()] is used to free idxPtr if and only if +// needToFreeIdxPtr is true. +// +// ^The orderByConsumed means that output from [xFilter]/[xNext] will occur in +// the correct order to satisfy the ORDER BY clause so that no separate +// sorting step is required. +// +// ^The estimatedCost value is an estimate of the cost of a particular +// strategy. A cost of N indicates that the cost of the strategy is similar +// to a linear scan of an SQLite table with N rows. A cost of log(N) +// indicates that the expense of the operation is similar to that of a +// binary search on a unique indexed field of an SQLite table with N rows. +// +// ^The estimatedRows value is an estimate of the number of rows that +// will be returned by the strategy. +// +// The xBestIndex method may optionally populate the idxFlags field with a +// mask of SQLITE_INDEX_SCAN_* flags. Currently there is only one such flag - +// SQLITE_INDEX_SCAN_UNIQUE. If the xBestIndex method sets this flag, SQLite +// assumes that the strategy may visit at most one row. +// +// Additionally, if xBestIndex sets the SQLITE_INDEX_SCAN_UNIQUE flag, then +// SQLite also assumes that if a call to the xUpdate() method is made as +// part of the same statement to delete or update a virtual table row and the +// implementation returns SQLITE_CONSTRAINT, then there is no need to rollback +// any database changes. In other words, if the xUpdate() returns +// SQLITE_CONSTRAINT, the database contents must be exactly as they were +// before xUpdate was called. By contrast, if SQLITE_INDEX_SCAN_UNIQUE is not +// set and xUpdate returns SQLITE_CONSTRAINT, any database changes made by +// the xUpdate method are automatically rolled back by SQLite. +// +// IMPORTANT: The estimatedRows field was added to the sqlite3_index_info +// structure for SQLite [version 3.8.2] ([dateof:3.8.2]). +// If a virtual table extension is +// used with an SQLite version earlier than 3.8.2, the results of attempting +// to read or write the estimatedRows field are undefined (but are likely +// to include crashing the application). The estimatedRows field should +// therefore only be used if [sqlite3_libversion_number()] returns a +// value greater than or equal to 3008002. Similarly, the idxFlags field +// was added for [version 3.9.0] ([dateof:3.9.0]). +// It may therefore only be used if +// sqlite3_libversion_number() returns a value greater than or equal to +// 3009000. +type sqlite3_index_constraint_usage = struct { + argvIndex int32 + omit uint8 + _ [3]byte +} /* sqlite3.h:6690:9 */ + +// CAPI3REF: Mutex Methods Object +// +// An instance of this structure defines the low-level routines +// used to allocate and use mutexes. +// +// Usually, the default mutex implementations provided by SQLite are +// sufficient, however the application has the option of substituting a custom +// implementation for specialized deployments or systems for which SQLite +// does not provide a suitable implementation. In this case, the application +// creates and populates an instance of this structure to pass +// to sqlite3_config() along with the [SQLITE_CONFIG_MUTEX] option. +// Additionally, an instance of this structure can be used as an +// output variable when querying the system for the current mutex +// implementation, using the [SQLITE_CONFIG_GETMUTEX] option. +// +// ^The xMutexInit method defined by this structure is invoked as +// part of system initialization by the sqlite3_initialize() function. +// ^The xMutexInit routine is called by SQLite exactly once for each +// effective call to [sqlite3_initialize()]. +// +// ^The xMutexEnd method defined by this structure is invoked as +// part of system shutdown by the sqlite3_shutdown() function. The +// implementation of this method is expected to release all outstanding +// resources obtained by the mutex methods implementation, especially +// those obtained by the xMutexInit method. ^The xMutexEnd() +// interface is invoked exactly once for each call to [sqlite3_shutdown()]. +// +// ^(The remaining seven methods defined by this structure (xMutexAlloc, +// xMutexFree, xMutexEnter, xMutexTry, xMutexLeave, xMutexHeld and +// xMutexNotheld) implement the following interfaces (respectively): +// +// <ul> +// <li> [sqlite3_mutex_alloc()] </li> +// <li> [sqlite3_mutex_free()] </li> +// <li> [sqlite3_mutex_enter()] </li> +// <li> [sqlite3_mutex_try()] </li> +// <li> [sqlite3_mutex_leave()] </li> +// <li> [sqlite3_mutex_held()] </li> +// <li> [sqlite3_mutex_notheld()] </li> +// </ul>)^ +// +// The only difference is that the public sqlite3_XXX functions enumerated +// above silently ignore any invocations that pass a NULL pointer instead +// of a valid mutex handle. The implementations of the methods defined +// by this structure are not required to handle this case. The results +// of passing a NULL pointer instead of a valid mutex handle are undefined +// (i.e. it is acceptable to provide an implementation that segfaults if +// it is passed a NULL pointer). +// +// The xMutexInit() method must be threadsafe. It must be harmless to +// invoke xMutexInit() multiple times within the same process and without +// intervening calls to xMutexEnd(). Second and subsequent calls to +// xMutexInit() must be no-ops. +// +// xMutexInit() must not use SQLite memory allocation ([sqlite3_malloc()] +// and its associates). Similarly, xMutexAlloc() must not use SQLite memory +// allocation for a static mutex. ^However xMutexAlloc() may use SQLite +// memory allocation for a fast or recursive mutex. +// +// ^SQLite will invoke the xMutexEnd() method when [sqlite3_shutdown()] is +// called, but only if the prior call to xMutexInit returned SQLITE_OK. +// If xMutexInit fails in any way, it is expected to clean up after itself +// prior to returning. +type sqlite3_mutex_methods1 = struct { + xMutexInit uintptr + xMutexEnd uintptr + xMutexAlloc uintptr + xMutexFree uintptr + xMutexEnter uintptr + xMutexTry uintptr + xMutexLeave uintptr + xMutexHeld uintptr + xMutexNotheld uintptr +} /* sqlite3.h:7524:9 */ + +// CAPI3REF: Mutex Methods Object +// +// An instance of this structure defines the low-level routines +// used to allocate and use mutexes. +// +// Usually, the default mutex implementations provided by SQLite are +// sufficient, however the application has the option of substituting a custom +// implementation for specialized deployments or systems for which SQLite +// does not provide a suitable implementation. In this case, the application +// creates and populates an instance of this structure to pass +// to sqlite3_config() along with the [SQLITE_CONFIG_MUTEX] option. +// Additionally, an instance of this structure can be used as an +// output variable when querying the system for the current mutex +// implementation, using the [SQLITE_CONFIG_GETMUTEX] option. +// +// ^The xMutexInit method defined by this structure is invoked as +// part of system initialization by the sqlite3_initialize() function. +// ^The xMutexInit routine is called by SQLite exactly once for each +// effective call to [sqlite3_initialize()]. +// +// ^The xMutexEnd method defined by this structure is invoked as +// part of system shutdown by the sqlite3_shutdown() function. The +// implementation of this method is expected to release all outstanding +// resources obtained by the mutex methods implementation, especially +// those obtained by the xMutexInit method. ^The xMutexEnd() +// interface is invoked exactly once for each call to [sqlite3_shutdown()]. +// +// ^(The remaining seven methods defined by this structure (xMutexAlloc, +// xMutexFree, xMutexEnter, xMutexTry, xMutexLeave, xMutexHeld and +// xMutexNotheld) implement the following interfaces (respectively): +// +// <ul> +// <li> [sqlite3_mutex_alloc()] </li> +// <li> [sqlite3_mutex_free()] </li> +// <li> [sqlite3_mutex_enter()] </li> +// <li> [sqlite3_mutex_try()] </li> +// <li> [sqlite3_mutex_leave()] </li> +// <li> [sqlite3_mutex_held()] </li> +// <li> [sqlite3_mutex_notheld()] </li> +// </ul>)^ +// +// The only difference is that the public sqlite3_XXX functions enumerated +// above silently ignore any invocations that pass a NULL pointer instead +// of a valid mutex handle. The implementations of the methods defined +// by this structure are not required to handle this case. The results +// of passing a NULL pointer instead of a valid mutex handle are undefined +// (i.e. it is acceptable to provide an implementation that segfaults if +// it is passed a NULL pointer). +// +// The xMutexInit() method must be threadsafe. It must be harmless to +// invoke xMutexInit() multiple times within the same process and without +// intervening calls to xMutexEnd(). Second and subsequent calls to +// xMutexInit() must be no-ops. +// +// xMutexInit() must not use SQLite memory allocation ([sqlite3_malloc()] +// and its associates). Similarly, xMutexAlloc() must not use SQLite memory +// allocation for a static mutex. ^However xMutexAlloc() may use SQLite +// memory allocation for a fast or recursive mutex. +// +// ^SQLite will invoke the xMutexEnd() method when [sqlite3_shutdown()] is +// called, but only if the prior call to xMutexInit returned SQLITE_OK. +// If xMutexInit fails in any way, it is expected to clean up after itself +// prior to returning. +type sqlite3_mutex_methods = sqlite3_mutex_methods1 /* sqlite3.h:7524:38 */ + +// CAPI3REF: Custom Page Cache Object +// +// The sqlite3_pcache_page object represents a single page in the +// page cache. The page cache will allocate instances of this +// object. Various methods of the page cache use pointers to instances +// of this object as parameters or as their return value. +// +// See [sqlite3_pcache_methods2] for additional information. +type sqlite3_pcache_page1 = struct { + pBuf uintptr + pExtra uintptr +} /* sqlite3.h:8277:9 */ + +// CAPI3REF: Custom Page Cache Object +// +// The sqlite3_pcache_page object represents a single page in the +// page cache. The page cache will allocate instances of this +// object. Various methods of the page cache use pointers to instances +// of this object as parameters or as their return value. +// +// See [sqlite3_pcache_methods2] for additional information. +type sqlite3_pcache_page = sqlite3_pcache_page1 /* sqlite3.h:8277:36 */ + +// CAPI3REF: Application Defined Page Cache. +// KEYWORDS: {page cache} +// +// ^(The [sqlite3_config]([SQLITE_CONFIG_PCACHE2], ...) interface can +// register an alternative page cache implementation by passing in an +// instance of the sqlite3_pcache_methods2 structure.)^ +// In many applications, most of the heap memory allocated by +// SQLite is used for the page cache. +// By implementing a +// custom page cache using this API, an application can better control +// the amount of memory consumed by SQLite, the way in which +// that memory is allocated and released, and the policies used to +// determine exactly which parts of a database file are cached and for +// how long. +// +// The alternative page cache mechanism is an +// extreme measure that is only needed by the most demanding applications. +// The built-in page cache is recommended for most uses. +// +// ^(The contents of the sqlite3_pcache_methods2 structure are copied to an +// internal buffer by SQLite within the call to [sqlite3_config]. Hence +// the application may discard the parameter after the call to +// [sqlite3_config()] returns.)^ +// +// [[the xInit() page cache method]] +// ^(The xInit() method is called once for each effective +// call to [sqlite3_initialize()])^ +// (usually only once during the lifetime of the process). ^(The xInit() +// method is passed a copy of the sqlite3_pcache_methods2.pArg value.)^ +// The intent of the xInit() method is to set up global data structures +// required by the custom page cache implementation. +// ^(If the xInit() method is NULL, then the +// built-in default page cache is used instead of the application defined +// page cache.)^ +// +// [[the xShutdown() page cache method]] +// ^The xShutdown() method is called by [sqlite3_shutdown()]. +// It can be used to clean up +// any outstanding resources before process shutdown, if required. +// ^The xShutdown() method may be NULL. +// +// ^SQLite automatically serializes calls to the xInit method, +// so the xInit method need not be threadsafe. ^The +// xShutdown method is only called from [sqlite3_shutdown()] so it does +// not need to be threadsafe either. All other methods must be threadsafe +// in multithreaded applications. +// +// ^SQLite will never invoke xInit() more than once without an intervening +// call to xShutdown(). +// +// [[the xCreate() page cache methods]] +// ^SQLite invokes the xCreate() method to construct a new cache instance. +// SQLite will typically create one cache instance for each open database file, +// though this is not guaranteed. ^The +// first parameter, szPage, is the size in bytes of the pages that must +// be allocated by the cache. ^szPage will always a power of two. ^The +// second parameter szExtra is a number of bytes of extra storage +// associated with each page cache entry. ^The szExtra parameter will +// a number less than 250. SQLite will use the +// extra szExtra bytes on each page to store metadata about the underlying +// database page on disk. The value passed into szExtra depends +// on the SQLite version, the target platform, and how SQLite was compiled. +// ^The third argument to xCreate(), bPurgeable, is true if the cache being +// created will be used to cache database pages of a file stored on disk, or +// false if it is used for an in-memory database. The cache implementation +// does not have to do anything special based with the value of bPurgeable; +// it is purely advisory. ^On a cache where bPurgeable is false, SQLite will +// never invoke xUnpin() except to deliberately delete a page. +// ^In other words, calls to xUnpin() on a cache with bPurgeable set to +// false will always have the "discard" flag set to true. +// ^Hence, a cache created with bPurgeable false will +// never contain any unpinned pages. +// +// [[the xCachesize() page cache method]] +// ^(The xCachesize() method may be called at any time by SQLite to set the +// suggested maximum cache-size (number of pages stored by) the cache +// instance passed as the first argument. This is the value configured using +// the SQLite "[PRAGMA cache_size]" command.)^ As with the bPurgeable +// parameter, the implementation is not required to do anything with this +// value; it is advisory only. +// +// [[the xPagecount() page cache methods]] +// The xPagecount() method must return the number of pages currently +// stored in the cache, both pinned and unpinned. +// +// [[the xFetch() page cache methods]] +// The xFetch() method locates a page in the cache and returns a pointer to +// an sqlite3_pcache_page object associated with that page, or a NULL pointer. +// The pBuf element of the returned sqlite3_pcache_page object will be a +// pointer to a buffer of szPage bytes used to store the content of a +// single database page. The pExtra element of sqlite3_pcache_page will be +// a pointer to the szExtra bytes of extra storage that SQLite has requested +// for each entry in the page cache. +// +// The page to be fetched is determined by the key. ^The minimum key value +// is 1. After it has been retrieved using xFetch, the page is considered +// to be "pinned". +// +// If the requested page is already in the page cache, then the page cache +// implementation must return a pointer to the page buffer with its content +// intact. If the requested page is not already in the cache, then the +// cache implementation should use the value of the createFlag +// parameter to help it determined what action to take: +// +// <table border=1 width=85% align=center> +// <tr><th> createFlag <th> Behavior when page is not already in cache +// <tr><td> 0 <td> Do not allocate a new page. Return NULL. +// <tr><td> 1 <td> Allocate a new page if it easy and convenient to do so. +// Otherwise return NULL. +// <tr><td> 2 <td> Make every effort to allocate a new page. Only return +// NULL if allocating a new page is effectively impossible. +// </table> +// +// ^(SQLite will normally invoke xFetch() with a createFlag of 0 or 1. SQLite +// will only use a createFlag of 2 after a prior call with a createFlag of 1 +// failed.)^ In between the xFetch() calls, SQLite may +// attempt to unpin one or more cache pages by spilling the content of +// pinned pages to disk and synching the operating system disk cache. +// +// [[the xUnpin() page cache method]] +// ^xUnpin() is called by SQLite with a pointer to a currently pinned page +// as its second argument. If the third parameter, discard, is non-zero, +// then the page must be evicted from the cache. +// ^If the discard parameter is +// zero, then the page may be discarded or retained at the discretion of +// page cache implementation. ^The page cache implementation +// may choose to evict unpinned pages at any time. +// +// The cache must not perform any reference counting. A single +// call to xUnpin() unpins the page regardless of the number of prior calls +// to xFetch(). +// +// [[the xRekey() page cache methods]] +// The xRekey() method is used to change the key value associated with the +// page passed as the second argument. If the cache +// previously contains an entry associated with newKey, it must be +// discarded. ^Any prior cache entry associated with newKey is guaranteed not +// to be pinned. +// +// When SQLite calls the xTruncate() method, the cache must discard all +// existing cache entries with page numbers (keys) greater than or equal +// to the value of the iLimit parameter passed to xTruncate(). If any +// of these pages are pinned, they are implicitly unpinned, meaning that +// they can be safely discarded. +// +// [[the xDestroy() page cache method]] +// ^The xDestroy() method is used to delete a cache allocated by xCreate(). +// All resources associated with the specified cache should be freed. ^After +// calling the xDestroy() method, SQLite considers the [sqlite3_pcache*] +// handle invalid, and will not use it with any other sqlite3_pcache_methods2 +// functions. +// +// [[the xShrink() page cache method]] +// ^SQLite invokes the xShrink() method when it wants the page cache to +// free up as much of heap memory as possible. The page cache implementation +// is not obligated to free any memory, but well-behaved implementations should +// do their best. +type sqlite3_pcache_methods21 = struct { + iVersion int32 + _ [4]byte + pArg uintptr + xInit uintptr + xShutdown uintptr + xCreate uintptr + xCachesize uintptr + xPagecount uintptr + xFetch uintptr + xUnpin uintptr + xRekey uintptr + xTruncate uintptr + xDestroy uintptr + xShrink uintptr +} /* sqlite3.h:8442:9 */ + +// CAPI3REF: Application Defined Page Cache. +// KEYWORDS: {page cache} +// +// ^(The [sqlite3_config]([SQLITE_CONFIG_PCACHE2], ...) interface can +// register an alternative page cache implementation by passing in an +// instance of the sqlite3_pcache_methods2 structure.)^ +// In many applications, most of the heap memory allocated by +// SQLite is used for the page cache. +// By implementing a +// custom page cache using this API, an application can better control +// the amount of memory consumed by SQLite, the way in which +// that memory is allocated and released, and the policies used to +// determine exactly which parts of a database file are cached and for +// how long. +// +// The alternative page cache mechanism is an +// extreme measure that is only needed by the most demanding applications. +// The built-in page cache is recommended for most uses. +// +// ^(The contents of the sqlite3_pcache_methods2 structure are copied to an +// internal buffer by SQLite within the call to [sqlite3_config]. Hence +// the application may discard the parameter after the call to +// [sqlite3_config()] returns.)^ +// +// [[the xInit() page cache method]] +// ^(The xInit() method is called once for each effective +// call to [sqlite3_initialize()])^ +// (usually only once during the lifetime of the process). ^(The xInit() +// method is passed a copy of the sqlite3_pcache_methods2.pArg value.)^ +// The intent of the xInit() method is to set up global data structures +// required by the custom page cache implementation. +// ^(If the xInit() method is NULL, then the +// built-in default page cache is used instead of the application defined +// page cache.)^ +// +// [[the xShutdown() page cache method]] +// ^The xShutdown() method is called by [sqlite3_shutdown()]. +// It can be used to clean up +// any outstanding resources before process shutdown, if required. +// ^The xShutdown() method may be NULL. +// +// ^SQLite automatically serializes calls to the xInit method, +// so the xInit method need not be threadsafe. ^The +// xShutdown method is only called from [sqlite3_shutdown()] so it does +// not need to be threadsafe either. All other methods must be threadsafe +// in multithreaded applications. +// +// ^SQLite will never invoke xInit() more than once without an intervening +// call to xShutdown(). +// +// [[the xCreate() page cache methods]] +// ^SQLite invokes the xCreate() method to construct a new cache instance. +// SQLite will typically create one cache instance for each open database file, +// though this is not guaranteed. ^The +// first parameter, szPage, is the size in bytes of the pages that must +// be allocated by the cache. ^szPage will always a power of two. ^The +// second parameter szExtra is a number of bytes of extra storage +// associated with each page cache entry. ^The szExtra parameter will +// a number less than 250. SQLite will use the +// extra szExtra bytes on each page to store metadata about the underlying +// database page on disk. The value passed into szExtra depends +// on the SQLite version, the target platform, and how SQLite was compiled. +// ^The third argument to xCreate(), bPurgeable, is true if the cache being +// created will be used to cache database pages of a file stored on disk, or +// false if it is used for an in-memory database. The cache implementation +// does not have to do anything special based with the value of bPurgeable; +// it is purely advisory. ^On a cache where bPurgeable is false, SQLite will +// never invoke xUnpin() except to deliberately delete a page. +// ^In other words, calls to xUnpin() on a cache with bPurgeable set to +// false will always have the "discard" flag set to true. +// ^Hence, a cache created with bPurgeable false will +// never contain any unpinned pages. +// +// [[the xCachesize() page cache method]] +// ^(The xCachesize() method may be called at any time by SQLite to set the +// suggested maximum cache-size (number of pages stored by) the cache +// instance passed as the first argument. This is the value configured using +// the SQLite "[PRAGMA cache_size]" command.)^ As with the bPurgeable +// parameter, the implementation is not required to do anything with this +// value; it is advisory only. +// +// [[the xPagecount() page cache methods]] +// The xPagecount() method must return the number of pages currently +// stored in the cache, both pinned and unpinned. +// +// [[the xFetch() page cache methods]] +// The xFetch() method locates a page in the cache and returns a pointer to +// an sqlite3_pcache_page object associated with that page, or a NULL pointer. +// The pBuf element of the returned sqlite3_pcache_page object will be a +// pointer to a buffer of szPage bytes used to store the content of a +// single database page. The pExtra element of sqlite3_pcache_page will be +// a pointer to the szExtra bytes of extra storage that SQLite has requested +// for each entry in the page cache. +// +// The page to be fetched is determined by the key. ^The minimum key value +// is 1. After it has been retrieved using xFetch, the page is considered +// to be "pinned". +// +// If the requested page is already in the page cache, then the page cache +// implementation must return a pointer to the page buffer with its content +// intact. If the requested page is not already in the cache, then the +// cache implementation should use the value of the createFlag +// parameter to help it determined what action to take: +// +// <table border=1 width=85% align=center> +// <tr><th> createFlag <th> Behavior when page is not already in cache +// <tr><td> 0 <td> Do not allocate a new page. Return NULL. +// <tr><td> 1 <td> Allocate a new page if it easy and convenient to do so. +// Otherwise return NULL. +// <tr><td> 2 <td> Make every effort to allocate a new page. Only return +// NULL if allocating a new page is effectively impossible. +// </table> +// +// ^(SQLite will normally invoke xFetch() with a createFlag of 0 or 1. SQLite +// will only use a createFlag of 2 after a prior call with a createFlag of 1 +// failed.)^ In between the xFetch() calls, SQLite may +// attempt to unpin one or more cache pages by spilling the content of +// pinned pages to disk and synching the operating system disk cache. +// +// [[the xUnpin() page cache method]] +// ^xUnpin() is called by SQLite with a pointer to a currently pinned page +// as its second argument. If the third parameter, discard, is non-zero, +// then the page must be evicted from the cache. +// ^If the discard parameter is +// zero, then the page may be discarded or retained at the discretion of +// page cache implementation. ^The page cache implementation +// may choose to evict unpinned pages at any time. +// +// The cache must not perform any reference counting. A single +// call to xUnpin() unpins the page regardless of the number of prior calls +// to xFetch(). +// +// [[the xRekey() page cache methods]] +// The xRekey() method is used to change the key value associated with the +// page passed as the second argument. If the cache +// previously contains an entry associated with newKey, it must be +// discarded. ^Any prior cache entry associated with newKey is guaranteed not +// to be pinned. +// +// When SQLite calls the xTruncate() method, the cache must discard all +// existing cache entries with page numbers (keys) greater than or equal +// to the value of the iLimit parameter passed to xTruncate(). If any +// of these pages are pinned, they are implicitly unpinned, meaning that +// they can be safely discarded. +// +// [[the xDestroy() page cache method]] +// ^The xDestroy() method is used to delete a cache allocated by xCreate(). +// All resources associated with the specified cache should be freed. ^After +// calling the xDestroy() method, SQLite considers the [sqlite3_pcache*] +// handle invalid, and will not use it with any other sqlite3_pcache_methods2 +// functions. +// +// [[the xShrink() page cache method]] +// ^SQLite invokes the xShrink() method when it wants the page cache to +// free up as much of heap memory as possible. The page cache implementation +// is not obligated to free any memory, but well-behaved implementations should +// do their best. +type sqlite3_pcache_methods2 = sqlite3_pcache_methods21 /* sqlite3.h:8442:40 */ + +// This is the obsolete pcache_methods object that has now been replaced +// by sqlite3_pcache_methods2. This object is not used by SQLite. It is +// retained in the header file for backwards compatibility only. +type sqlite3_pcache_methods1 = struct { + pArg uintptr + xInit uintptr + xShutdown uintptr + xCreate uintptr + xCachesize uintptr + xPagecount uintptr + xFetch uintptr + xUnpin uintptr + xRekey uintptr + xTruncate uintptr + xDestroy uintptr +} /* sqlite3.h:8465:9 */ + +// This is the obsolete pcache_methods object that has now been replaced +// by sqlite3_pcache_methods2. This object is not used by SQLite. It is +// retained in the header file for backwards compatibility only. +type sqlite3_pcache_methods = sqlite3_pcache_methods1 /* sqlite3.h:8465:39 */ + +// CAPI3REF: Database Snapshot +// KEYWORDS: {snapshot} {sqlite3_snapshot} +// +// An instance of the snapshot object records the state of a [WAL mode] +// database for some specific point in history. +// +// In [WAL mode], multiple [database connections] that are open on the +// same database file can each be reading a different historical version +// of the database file. When a [database connection] begins a read +// transaction, that connection sees an unchanging copy of the database +// as it existed for the point in time when the transaction first started. +// Subsequent changes to the database from other connections are not seen +// by the reader until a new read transaction is started. +// +// The sqlite3_snapshot object records state information about an historical +// version of the database file so that it is possible to later open a new read +// transaction that sees that historical version of the database rather than +// the most recent version. +type sqlite3_snapshot1 = struct{ hidden [48]uint8 } /* sqlite3.h:9512:9 */ + +// CAPI3REF: Database Snapshot +// KEYWORDS: {snapshot} {sqlite3_snapshot} +// +// An instance of the snapshot object records the state of a [WAL mode] +// database for some specific point in history. +// +// In [WAL mode], multiple [database connections] that are open on the +// same database file can each be reading a different historical version +// of the database file. When a [database connection] begins a read +// transaction, that connection sees an unchanging copy of the database +// as it existed for the point in time when the transaction first started. +// Subsequent changes to the database from other connections are not seen +// by the reader until a new read transaction is started. +// +// The sqlite3_snapshot object records state information about an historical +// version of the database file so that it is possible to later open a new read +// transaction that sees that historical version of the database rather than +// the most recent version. +type sqlite3_snapshot = sqlite3_snapshot1 /* sqlite3.h:9514:3 */ + +// CAPI3REF: Flags for sqlite3_deserialize() +// +// The following are allowed values for 6th argument (the F argument) to +// the [sqlite3_deserialize(D,S,P,N,M,F)] interface. +// +// The SQLITE_DESERIALIZE_FREEONCLOSE means that the database serialization +// in the P argument is held in memory obtained from [sqlite3_malloc64()] +// and that SQLite should take ownership of this memory and automatically +// free it when it has finished using it. Without this flag, the caller +// is responsible for freeing any dynamically allocated memory. +// +// The SQLITE_DESERIALIZE_RESIZEABLE flag means that SQLite is allowed to +// grow the size of the database using calls to [sqlite3_realloc64()]. This +// flag should only be used if SQLITE_DESERIALIZE_FREEONCLOSE is also used. +// Without this flag, the deserialized database cannot increase in size beyond +// the number of bytes specified by the M parameter. +// +// The SQLITE_DESERIALIZE_READONLY flag means that the deserialized database +// should be treated as read-only. + +// Undo the hack that converts floating point types to integer for +// builds on processors without floating point support. + +//******* Begin file sqlite3rtree.h ******** +// 2010 August 30 +// +// The author disclaims copyright to this source code. In place of +// a legal notice, here is a blessing: +// +// May you do good and not evil. +// May you find forgiveness for yourself and forgive others. +// May you share freely, never taking more than you give. +// +// + +type sqlite3_rtree_geometry1 = struct { + pContext uintptr + nParam int32 + _ [4]byte + aParam uintptr + pUser uintptr + xDelUser uintptr +} /* sqlite3.h:9839:9 */ + +// CAPI3REF: Flags for sqlite3_deserialize() +// +// The following are allowed values for 6th argument (the F argument) to +// the [sqlite3_deserialize(D,S,P,N,M,F)] interface. +// +// The SQLITE_DESERIALIZE_FREEONCLOSE means that the database serialization +// in the P argument is held in memory obtained from [sqlite3_malloc64()] +// and that SQLite should take ownership of this memory and automatically +// free it when it has finished using it. Without this flag, the caller +// is responsible for freeing any dynamically allocated memory. +// +// The SQLITE_DESERIALIZE_RESIZEABLE flag means that SQLite is allowed to +// grow the size of the database using calls to [sqlite3_realloc64()]. This +// flag should only be used if SQLITE_DESERIALIZE_FREEONCLOSE is also used. +// Without this flag, the deserialized database cannot increase in size beyond +// the number of bytes specified by the M parameter. +// +// The SQLITE_DESERIALIZE_READONLY flag means that the deserialized database +// should be treated as read-only. + +// Undo the hack that converts floating point types to integer for +// builds on processors without floating point support. + +//******* Begin file sqlite3rtree.h ******** +// 2010 August 30 +// +// The author disclaims copyright to this source code. In place of +// a legal notice, here is a blessing: +// +// May you do good and not evil. +// May you find forgiveness for yourself and forgive others. +// May you share freely, never taking more than you give. +// +// + +type sqlite3_rtree_geometry = sqlite3_rtree_geometry1 /* sqlite3.h:9839:39 */ +type sqlite3_rtree_query_info1 = struct { + pContext uintptr + nParam int32 + _ [4]byte + aParam uintptr + pUser uintptr + xDelUser uintptr + aCoord uintptr + anQueue uintptr + nCoord int32 + iLevel int32 + mxLevel int32 + _ [4]byte + iRowid sqlite3_int64 + rParentScore sqlite3_rtree_dbl + eParentWithin int32 + eWithin int32 + rScore sqlite3_rtree_dbl + apSqlParam uintptr +} /* sqlite3.h:9840:9 */ + +type sqlite3_rtree_query_info = sqlite3_rtree_query_info1 /* sqlite3.h:9840:41 */ + +// The double-precision datatype used by RTree depends on the +// SQLITE_RTREE_INT_ONLY compile-time option. +type sqlite3_rtree_dbl = float64 /* sqlite3.h:9848:18 */ + +// Allowed values for sqlite3_rtree_query.eWithin and .eParentWithin. + +//******* End of sqlite3rtree.h ******** +//******* Begin file sqlite3session.h ******** + +//******* End of sqlite3session.h ******** +//******* Begin file fts5.h ******** +// 2014 May 31 +// +// The author disclaims copyright to this source code. In place of +// a legal notice, here is a blessing: +// +// May you do good and not evil. +// May you find forgiveness for yourself and forgive others. +// May you share freely, never taking more than you give. +// +// +// +// Interfaces to extend FTS5. Using the interfaces defined in this file, +// FTS5 may be extended with: +// +// * custom tokenizers, and +// * custom auxiliary functions. + +// ************************************************************************ +// +// CUSTOM AUXILIARY FUNCTIONS +// +// Virtual table implementations may overload SQL functions by implementing +// the sqlite3_module.xFindFunction() method. + +type Fts5ExtensionApi1 = struct { + iVersion int32 + _ [4]byte + xUserData uintptr + xColumnCount uintptr + xRowCount uintptr + xColumnTotalSize uintptr + xTokenize uintptr + xPhraseCount uintptr + xPhraseSize uintptr + xInstCount uintptr + xInst uintptr + xRowid uintptr + xColumnText uintptr + xColumnSize uintptr + xQueryPhrase uintptr + xSetAuxdata uintptr + xGetAuxdata uintptr + xPhraseFirst uintptr + xPhraseNext uintptr + xPhraseFirstColumn uintptr + xPhraseNextColumn uintptr +} /* sqlite3.h:11634:9 */ + +// Allowed values for sqlite3_rtree_query.eWithin and .eParentWithin. + +//******* End of sqlite3rtree.h ******** +//******* Begin file sqlite3session.h ******** + +//******* End of sqlite3session.h ******** +//******* Begin file fts5.h ******** +// 2014 May 31 +// +// The author disclaims copyright to this source code. In place of +// a legal notice, here is a blessing: +// +// May you do good and not evil. +// May you find forgiveness for yourself and forgive others. +// May you share freely, never taking more than you give. +// +// +// +// Interfaces to extend FTS5. Using the interfaces defined in this file, +// FTS5 may be extended with: +// +// * custom tokenizers, and +// * custom auxiliary functions. + +// ************************************************************************ +// +// CUSTOM AUXILIARY FUNCTIONS +// +// Virtual table implementations may overload SQL functions by implementing +// the sqlite3_module.xFindFunction() method. + +type Fts5ExtensionApi = Fts5ExtensionApi1 /* sqlite3.h:11634:33 */ +type Fts5PhraseIter1 = struct { + a uintptr + b uintptr +} /* sqlite3.h:11636:9 */ + +type Fts5PhraseIter = Fts5PhraseIter1 /* sqlite3.h:11636:31 */ + +type fts5_extension_function = uintptr /* sqlite3.h:11638:14 */ +type fts5_tokenizer1 = struct { + xCreate uintptr + xDelete uintptr + xTokenize uintptr +} /* sqlite3.h:12097:9 */ + +type fts5_tokenizer = fts5_tokenizer1 /* sqlite3.h:12097:31 */ + +// Flags that may be passed as the third argument to xTokenize() + +// Flags that may be passed by the tokenizer implementation back to FTS5 +// as the third argument to the supplied xToken callback. + +// +// END OF CUSTOM TOKENIZERS +// + +// ************************************************************************ +// +// FTS5 EXTENSION REGISTRATION API +type fts5_api1 = struct { + iVersion int32 + _ [4]byte + xCreateTokenizer uintptr + xFindTokenizer uintptr + xCreateFunction uintptr +} /* sqlite3.h:12133:9 */ + +// Flags that may be passed as the third argument to xTokenize() + +// Flags that may be passed by the tokenizer implementation back to FTS5 +// as the third argument to the supplied xToken callback. + +// +// END OF CUSTOM TOKENIZERS +// + +// ************************************************************************ +// +// FTS5 EXTENSION REGISTRATION API +type fts5_api = fts5_api1 /* sqlite3.h:12133:25 */ + +// The tag name of this struct is _G_fpos_t to preserve historic +// C++ mangled names for functions taking fpos_t arguments. +// That name should not be used in new code. +type _G_fpos_t = struct { + __pos int64 + __state struct { + __count int32 + __value struct{ __wch uint32 } + } +} /* __fpos_t.h:10:9 */ + +// bits/types.h -- definitions of __*_t types underlying *_t types. +// Copyright (C) 2002-2018 Free Software Foundation, Inc. +// This file is part of the GNU C Library. +// +// The GNU C Library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// The GNU C Library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with the GNU C Library; if not, see +// <http://www.gnu.org/licenses/>. + +// Never include this file directly; use <sys/types.h> instead. + +// The tag name of this struct is _G_fpos64_t to preserve historic +// C++ mangled names for functions taking fpos_t and/or fpos64_t +// arguments. That name should not be used in new code. +type _G_fpos64_t = struct { + __pos int64 + __state struct { + __count int32 + __value struct{ __wch uint32 } + } +} /* __fpos64_t.h:10:9 */ + +type _IO_FILE = struct { + _flags int32 + _ [4]byte + _IO_read_ptr uintptr + _IO_read_end uintptr + _IO_read_base uintptr + _IO_write_base uintptr + _IO_write_ptr uintptr + _IO_write_end uintptr + _IO_buf_base uintptr + _IO_buf_end uintptr + _IO_save_base uintptr + _IO_backup_base uintptr + _IO_save_end uintptr + _markers uintptr + _chain uintptr + _fileno int32 + _flags2 int32 + _old_offset int64 + _cur_column uint16 + _vtable_offset int8 + _shortbuf [1]int8 + _ [4]byte + _lock uintptr + _offset int64 + _codecvt uintptr + _wide_data uintptr + _freeres_list uintptr + _freeres_buf uintptr + __pad5 size_t + _mode int32 + _unused2 [20]int8 +} /* __FILE.h:4:1 */ + +// The opaque type of streams. This is the definition used elsewhere. +type FILE = _IO_FILE /* FILE.h:7:25 */ + +// These macros are used by bits/stdio.h and internal headers. + +// Many more flag bits are defined internally. + +// Copyright (C) 1989-2018 Free Software Foundation, Inc. +// +//This file is part of GCC. +// +//GCC is free software; you can redistribute it and/or modify +//it under the terms of the GNU General Public License as published by +//the Free Software Foundation; either version 3, or (at your option) +//any later version. +// +//GCC is distributed in the hope that it will be useful, +//but WITHOUT ANY WARRANTY; without even the implied warranty of +//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +//GNU General Public License for more details. +// +//Under Section 7 of GPL version 3, you are granted additional +//permissions described in the GCC Runtime Library Exception, version +//3.1, as published by the Free Software Foundation. +// +//You should have received a copy of the GNU General Public License and +//a copy of the GCC Runtime Library Exception along with this program; +//see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +//<http://www.gnu.org/licenses/>. + +// ISO C Standard: 7.15 Variable arguments <stdarg.h> + +type off_t = int64 /* stdio.h:65:19 */ +type off64_t = int64 /* stdio.h:70:19 */ + +type ssize_t = int64 /* stdio.h:77:19 */ + +// The type of the second argument to `fgetpos' and `fsetpos'. +type fpos_t = _G_fpos64_t /* stdio.h:86:20 */ +type fpos64_t = _G_fpos64_t /* stdio.h:89:20 */ + +// If we are compiling with optimizing read this file. It contains +// several optimizing inline functions and macros. + +// Copyright (C) 1991-2018 Free Software Foundation, Inc. +// This file is part of the GNU C Library. +// +// The GNU C Library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// The GNU C Library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with the GNU C Library; if not, see +// <http://www.gnu.org/licenses/>. + +// POSIX Standard: 2.10 Symbolic Constants <unistd.h> + +// Copyright (C) 1991-2018 Free Software Foundation, Inc. +// This file is part of the GNU C Library. +// +// The GNU C Library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// The GNU C Library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with the GNU C Library; if not, see +// <http://www.gnu.org/licenses/>. + +// These may be used to determine what facilities are present at compile time. +// Their values can be obtained at run time from `sysconf'. + +// POSIX Standard approved as ISO/IEC 9945-1 as of September 2008. + +// These are not #ifdef __USE_POSIX2 because they are +// in the theoretically application-owned namespace. + +// The utilities on GNU systems also correspond to this version. + +// The utilities on GNU systems also correspond to this version. + +// This symbol was required until the 2001 edition of POSIX. + +// If defined, the implementation supports the +// C Language Bindings Option. + +// If defined, the implementation supports the +// C Language Development Utilities Option. + +// If defined, the implementation supports the +// Software Development Utilities Option. + +// If defined, the implementation supports the +// creation of locales with the localedef utility. + +// X/Open version number to which the library conforms. It is selectable. + +// Commands and utilities from XPG4 are available. + +// We are compatible with the old published standards as well. + +// The X/Open Unix extensions are available. + +// The enhanced internationalization capabilities according to XPG4.2 +// are present. + +// The legacy interfaces are also available. + +// Get values of POSIX options: +// +// If these symbols are defined, the corresponding features are +// always available. If not, they may be available sometimes. +// The current values can be obtained with `sysconf'. +// +// _POSIX_JOB_CONTROL Job control is supported. +// _POSIX_SAVED_IDS Processes have a saved set-user-ID +// and a saved set-group-ID. +// _POSIX_REALTIME_SIGNALS Real-time, queued signals are supported. +// _POSIX_PRIORITY_SCHEDULING Priority scheduling is supported. +// _POSIX_TIMERS POSIX.4 clocks and timers are supported. +// _POSIX_ASYNCHRONOUS_IO Asynchronous I/O is supported. +// _POSIX_PRIORITIZED_IO Prioritized asynchronous I/O is supported. +// _POSIX_SYNCHRONIZED_IO Synchronizing file data is supported. +// _POSIX_FSYNC The fsync function is present. +// _POSIX_MAPPED_FILES Mapping of files to memory is supported. +// _POSIX_MEMLOCK Locking of all memory is supported. +// _POSIX_MEMLOCK_RANGE Locking of ranges of memory is supported. +// _POSIX_MEMORY_PROTECTION Setting of memory protections is supported. +// _POSIX_MESSAGE_PASSING POSIX.4 message queues are supported. +// _POSIX_SEMAPHORES POSIX.4 counting semaphores are supported. +// _POSIX_SHARED_MEMORY_OBJECTS POSIX.4 shared memory objects are supported. +// _POSIX_THREADS POSIX.1c pthreads are supported. +// _POSIX_THREAD_ATTR_STACKADDR Thread stack address attribute option supported. +// _POSIX_THREAD_ATTR_STACKSIZE Thread stack size attribute option supported. +// _POSIX_THREAD_SAFE_FUNCTIONS Thread-safe functions are supported. +// _POSIX_THREAD_PRIORITY_SCHEDULING +// POSIX.1c thread execution scheduling supported. +// _POSIX_THREAD_PRIO_INHERIT Thread priority inheritance option supported. +// _POSIX_THREAD_PRIO_PROTECT Thread priority protection option supported. +// _POSIX_THREAD_PROCESS_SHARED Process-shared synchronization supported. +// _POSIX_PII Protocol-independent interfaces are supported. +// _POSIX_PII_XTI XTI protocol-indep. interfaces are supported. +// _POSIX_PII_SOCKET Socket protocol-indep. interfaces are supported. +// _POSIX_PII_INTERNET Internet family of protocols supported. +// _POSIX_PII_INTERNET_STREAM Connection-mode Internet protocol supported. +// _POSIX_PII_INTERNET_DGRAM Connectionless Internet protocol supported. +// _POSIX_PII_OSI ISO/OSI family of protocols supported. +// _POSIX_PII_OSI_COTS Connection-mode ISO/OSI service supported. +// _POSIX_PII_OSI_CLTS Connectionless ISO/OSI service supported. +// _POSIX_POLL Implementation supports `poll' function. +// _POSIX_SELECT Implementation supports `select' and `pselect'. +// +// _XOPEN_REALTIME X/Open realtime support is available. +// _XOPEN_REALTIME_THREADS X/Open realtime thread support is available. +// _XOPEN_SHM Shared memory interface according to XPG4.2. +// +// _XBS5_ILP32_OFF32 Implementation provides environment with 32-bit +// int, long, pointer, and off_t types. +// _XBS5_ILP32_OFFBIG Implementation provides environment with 32-bit +// int, long, and pointer and off_t with at least +// 64 bits. +// _XBS5_LP64_OFF64 Implementation provides environment with 32-bit +// int, and 64-bit long, pointer, and off_t types. +// _XBS5_LPBIG_OFFBIG Implementation provides environment with at +// least 32 bits int and long, pointer, and off_t +// with at least 64 bits. +// +// If any of these symbols is defined as -1, the corresponding option is not +// true for any file. If any is defined as other than -1, the corresponding +// option is true for all files. If a symbol is not defined at all, the value +// for a specific file can be obtained from `pathconf' and `fpathconf'. +// +// _POSIX_CHOWN_RESTRICTED Only the super user can use `chown' to change +// the owner of a file. `chown' can only be used +// to change the group ID of a file to a group of +// which the calling process is a member. +// _POSIX_NO_TRUNC Pathname components longer than +// NAME_MAX generate an error. +// _POSIX_VDISABLE If defined, if the value of an element of the +// `c_cc' member of `struct termios' is +// _POSIX_VDISABLE, no character will have the +// effect associated with that element. +// _POSIX_SYNC_IO Synchronous I/O may be performed. +// _POSIX_ASYNC_IO Asynchronous I/O may be performed. +// _POSIX_PRIO_IO Prioritized Asynchronous I/O may be performed. +// +// Support for the Large File Support interface is not generally available. +// If it is available the following constants are defined to one. +// _LFS64_LARGEFILE Low-level I/O supports large files. +// _LFS64_STDIO Standard I/O supports large files. +// + +// Define POSIX options for Linux. +// Copyright (C) 1996-2018 Free Software Foundation, Inc. +// This file is part of the GNU C Library. +// +// The GNU C Library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation; either version 2.1 of the +// License, or (at your option) any later version. +// +// The GNU C Library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with the GNU C Library; see the file COPYING.LIB. If +// not, see <http://www.gnu.org/licenses/>. + +// Job control is supported. + +// Processes have a saved set-user-ID and a saved set-group-ID. + +// Priority scheduling is supported. + +// Synchronizing file data is supported. + +// The fsync function is present. + +// Mapping of files to memory is supported. + +// Locking of all memory is supported. + +// Locking of ranges of memory is supported. + +// Setting of memory protections is supported. + +// Some filesystems allow all users to change file ownership. + +// `c_cc' member of 'struct termios' structure can be disabled by +// using the value _POSIX_VDISABLE. + +// Filenames are not silently truncated. + +// X/Open realtime support is available. + +// X/Open thread realtime support is available. + +// XPG4.2 shared memory is supported. + +// Tell we have POSIX threads. + +// We have the reentrant functions described in POSIX. + +// We provide priority scheduling for threads. + +// We support user-defined stack sizes. + +// We support user-defined stacks. + +// We support priority inheritence. + +// We support priority protection, though only for non-robust +// mutexes. + +// We support priority inheritence for robust mutexes. + +// We do not support priority protection for robust mutexes. + +// We support POSIX.1b semaphores. + +// Real-time signals are supported. + +// We support asynchronous I/O. +// Alternative name for Unix98. +// Support for prioritization is also available. + +// The LFS support in asynchronous I/O is also available. + +// The rest of the LFS is also available. + +// POSIX shared memory objects are implemented. + +// CPU-time clocks support needs to be checked at runtime. + +// Clock support in threads must be also checked at runtime. + +// GNU libc provides regular expression handling. + +// Reader/Writer locks are available. + +// We have a POSIX shell. + +// We support the Timeouts option. + +// We support spinlocks. + +// The `spawn' function family is supported. + +// We have POSIX timers. + +// The barrier functions are available. + +// POSIX message queues are available. + +// Thread process-shared synchronization is supported. + +// The monotonic clock might be available. + +// The clock selection interfaces are available. + +// Advisory information interfaces are available. + +// IPv6 support is available. + +// Raw socket support is available. + +// We have at least one terminal. + +// Neither process nor thread sporadic server interfaces is available. + +// trace.h is not available. + +// Typed memory objects are not available. + +// Get the environment definitions from Unix98. +// Copyright (C) 1999-2018 Free Software Foundation, Inc. +// This file is part of the GNU C Library. +// +// The GNU C Library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// The GNU C Library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with the GNU C Library; if not, see +// <http://www.gnu.org/licenses/>. + +// Determine the wordsize from the preprocessor defines. +// +// Copyright (C) 2016-2018 Free Software Foundation, Inc. +// This file is part of the GNU C Library. +// +// The GNU C Library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// The GNU C Library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with the GNU C Library; if not, see +// <http://www.gnu.org/licenses/>. + +// This header should define the following symbols under the described +// situations. A value `1' means that the model is always supported, +// `-1' means it is never supported. Undefined means it cannot be +// statically decided. +// +// _POSIX_V7_ILP32_OFF32 32bit int, long, pointers, and off_t type +// _POSIX_V7_ILP32_OFFBIG 32bit int, long, and pointers and larger off_t type +// +// _POSIX_V7_LP64_OFF32 64bit long and pointers and 32bit off_t type +// _POSIX_V7_LPBIG_OFFBIG 64bit long and pointers and large off_t type +// +// The macros _POSIX_V6_ILP32_OFF32, _POSIX_V6_ILP32_OFFBIG, +// _POSIX_V6_LP64_OFF32, _POSIX_V6_LPBIG_OFFBIG, _XBS5_ILP32_OFF32, +// _XBS5_ILP32_OFFBIG, _XBS5_LP64_OFF32, and _XBS5_LPBIG_OFFBIG were +// used in previous versions of the Unix standard and are available +// only for compatibility. + +// We can never provide environments with 32-bit wide pointers. +// We also have no use (for now) for an environment with bigger pointers +// and offsets. + +// By default we have 64-bit wide `long int', pointers and `off_t'. + +// Standard file descriptors. + +// All functions that are not declared anywhere else. + +// bits/types.h -- definitions of __*_t types underlying *_t types. +// Copyright (C) 2002-2018 Free Software Foundation, Inc. +// This file is part of the GNU C Library. +// +// The GNU C Library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// The GNU C Library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with the GNU C Library; if not, see +// <http://www.gnu.org/licenses/>. + +// Never include this file directly; use <sys/types.h> instead. + +// Copyright (C) 1989-2018 Free Software Foundation, Inc. +// +//This file is part of GCC. +// +//GCC is free software; you can redistribute it and/or modify +//it under the terms of the GNU General Public License as published by +//the Free Software Foundation; either version 3, or (at your option) +//any later version. +// +//GCC is distributed in the hope that it will be useful, +//but WITHOUT ANY WARRANTY; without even the implied warranty of +//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +//GNU General Public License for more details. +// +//Under Section 7 of GPL version 3, you are granted additional +//permissions described in the GCC Runtime Library Exception, version +//3.1, as published by the Free Software Foundation. +// +//You should have received a copy of the GNU General Public License and +//a copy of the GCC Runtime Library Exception along with this program; +//see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +//<http://www.gnu.org/licenses/>. + +// ISO C Standard: 7.17 Common definitions <stddef.h> + +// Any one of these symbols __need_* means that GNU libc +// wants us just to define one data type. So don't define +// the symbols that indicate this file's entire job has been done. + +// This avoids lossage on SunOS but only if stdtypes.h comes first. +// There's no way to win with the other order! Sun lossage. + +// On 4.3bsd-net2, make sure ansi.h is included, so we have +// one less case to deal with in the following. +// On FreeBSD 5, machine/ansi.h does not exist anymore... + +// In 4.3bsd-net2, machine/ansi.h defines these symbols, which are +// defined if the corresponding type is *not* defined. +// FreeBSD-2.1 defines _MACHINE_ANSI_H_ instead of _ANSI_H_. +// NetBSD defines _I386_ANSI_H_ and _X86_64_ANSI_H_ instead of _ANSI_H_ + +// Sequent's header files use _PTRDIFF_T_ in some conflicting way. +// Just ignore it. + +// On VxWorks, <type/vxTypesBase.h> may have defined macros like +// _TYPE_size_t which will typedef size_t. fixincludes patched the +// vxTypesBase.h so that this macro is only defined if _GCC_SIZE_T is +// not defined, and so that defining this macro defines _GCC_SIZE_T. +// If we find that the macros are still defined at this point, we must +// invoke them so that the type is defined as expected. + +// In case nobody has defined these types, but we aren't running under +// GCC 2.00, make sure that __PTRDIFF_TYPE__, __SIZE_TYPE__, and +// __WCHAR_TYPE__ have reasonable values. This can happen if the +// parts of GCC is compiled by an older compiler, that actually +// include gstddef.h, such as collect2. + +// Signed type of difference of two pointers. + +// Define this type if we are doing the whole job, +// or if we want this type in particular. + +// Unsigned type of `sizeof' something. + +// Define this type if we are doing the whole job, +// or if we want this type in particular. + +// Wide character type. +// Locale-writers should change this as necessary to +// be big enough to hold unique values not between 0 and 127, +// and not (wchar_t) -1, for each defined multibyte character. + +// Define this type if we are doing the whole job, +// or if we want this type in particular. + +// In 4.3bsd-net2, leave these undefined to indicate that size_t, etc. +// are already defined. +// BSD/OS 3.1 and FreeBSD [23].x require the MACHINE_ANSI_H check here. +// NetBSD 5 requires the I386_ANSI_H and X86_64_ANSI_H checks here. + +// A null pointer constant. + +// The Single Unix specification says that some more types are +// available here. +type gid_t = uint32 /* unistd.h:232:17 */ + +type uid_t = uint32 /* unistd.h:237:17 */ + +type useconds_t = uint32 /* unistd.h:255:22 */ + +type pid_t = int32 /* unistd.h:260:17 */ + +type intptr_t = int64 /* unistd.h:267:20 */ + +type socklen_t = uint32 /* unistd.h:274:21 */ + +// In 4.3bsd-net2, leave these undefined to indicate that size_t, etc. +// are already defined. +// BSD/OS 3.1 and FreeBSD [23].x require the MACHINE_ANSI_H check here. +// NetBSD 5 requires the I386_ANSI_H and X86_64_ANSI_H checks here. + +// A null pointer constant. + +// XPG requires a few symbols from <sys/wait.h> being defined. +// Definitions of flag bits for `waitpid' et al. +// Copyright (C) 1992-2018 Free Software Foundation, Inc. +// This file is part of the GNU C Library. +// +// The GNU C Library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// The GNU C Library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with the GNU C Library; if not, see +// <http://www.gnu.org/licenses/>. + +// Bits in the third argument to `waitpid'. + +// Bits in the fourth argument to `waitid'. + +// The following values are used by the `waitid' function. + +// The Linux kernel defines these bare, rather than an enum, +// which causes a conflict if the include order is reversed. + +type idtype_t = uint32 /* waitflags.h:57:3 */ +// Definitions of status bits for `wait' et al. +// Copyright (C) 1992-2018 Free Software Foundation, Inc. +// This file is part of the GNU C Library. +// +// The GNU C Library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// The GNU C Library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with the GNU C Library; if not, see +// <http://www.gnu.org/licenses/>. + +// Everything extant so far uses these same bits. + +// If WIFEXITED(STATUS), the low-order 8 bits of the status. + +// If WIFSIGNALED(STATUS), the terminating signal. + +// If WIFSTOPPED(STATUS), the signal that stopped the child. + +// Nonzero if STATUS indicates normal termination. + +// Nonzero if STATUS indicates termination by a signal. + +// Nonzero if STATUS indicates the child is stopped. + +// Nonzero if STATUS indicates the child continued after a stop. We only +// define this if <bits/waitflags.h> provides the WCONTINUED flag bit. + +// Nonzero if STATUS indicates the child dumped core. + +// Macros for constructing status values. + +// Define the macros <sys/wait.h> also would define this way. + +// _FloatN API tests for enablement. +// Macros to control TS 18661-3 glibc features on ldbl-128 platforms. +// Copyright (C) 2017-2018 Free Software Foundation, Inc. +// This file is part of the GNU C Library. +// +// The GNU C Library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// The GNU C Library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with the GNU C Library; if not, see +// <http://www.gnu.org/licenses/>. + +// Copyright (C) 1991-2018 Free Software Foundation, Inc. +// This file is part of the GNU C Library. +// +// The GNU C Library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// The GNU C Library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with the GNU C Library; if not, see +// <http://www.gnu.org/licenses/>. + +// Properties of long double type. ldbl-128 version. +// Copyright (C) 2016-2018 Free Software Foundation, Inc. +// This file is part of the GNU C Library. +// +// The GNU C Library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// The GNU C Library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with the GNU C Library; if not, see +// <http://www.gnu.org/licenses/>. + +// long double is distinct from double, so there is nothing to +// define here. + +// Defined to 1 if the current compiler invocation provides a +// floating-point type with the IEEE 754 binary128 format, and this +// glibc includes corresponding *f128 interfaces for it. + +// Defined to 1 if __HAVE_FLOAT128 is 1 and the type is ABI-distinct +// from the default float, double and long double types in this glibc. + +// Defined to 1 if the current compiler invocation provides a +// floating-point type with the right format for _Float64x, and this +// glibc includes corresponding *f64x interfaces for it. + +// Defined to 1 if __HAVE_FLOAT64X is 1 and _Float64x has the format +// of long double. Otherwise, if __HAVE_FLOAT64X is 1, _Float64x has +// the format of _Float128, which must be different from that of long +// double. + +// Defined to concatenate the literal suffix to be used with _Float128 +// types, if __HAVE_FLOAT128 is 1. +// The literal suffix f128 exists only since GCC 7.0. + +// Defined to a complex binary128 type if __HAVE_FLOAT128 is 1. + +// The remaining of this file provides support for older compilers. + +// The type _Float128 exists only since GCC 7.0. +type _Float128 = float64 /* floatn.h:80:21 */ + +// Various built-in functions do not exist before GCC 7.0. + +// Macros to control TS 18661-3 glibc features where the same +// definitions are appropriate for all platforms. +// Copyright (C) 2017-2018 Free Software Foundation, Inc. +// This file is part of the GNU C Library. +// +// The GNU C Library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// The GNU C Library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with the GNU C Library; if not, see +// <http://www.gnu.org/licenses/>. + +// Copyright (C) 1991-2018 Free Software Foundation, Inc. +// This file is part of the GNU C Library. +// +// The GNU C Library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// The GNU C Library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with the GNU C Library; if not, see +// <http://www.gnu.org/licenses/>. + +// Properties of long double type. ldbl-128 version. +// Copyright (C) 2016-2018 Free Software Foundation, Inc. +// This file is part of the GNU C Library. +// +// The GNU C Library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// The GNU C Library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with the GNU C Library; if not, see +// <http://www.gnu.org/licenses/>. + +// long double is distinct from double, so there is nothing to +// define here. + +// This header should be included at the bottom of each bits/floatn.h. +// It defines the following macros for each _FloatN and _FloatNx type, +// where the same definitions, or definitions based only on the macros +// in bits/floatn.h, are appropriate for all glibc configurations. + +// Defined to 1 if the current compiler invocation provides a +// floating-point type with the right format for this type, and this +// glibc includes corresponding *fN or *fNx interfaces for it. + +// Defined to 1 if the corresponding __HAVE_<type> macro is 1 and the +// type is the first with its format in the sequence of (the default +// choices for) float, double, long double, _Float16, _Float32, +// _Float64, _Float128, _Float32x, _Float64x, _Float128x for this +// glibc; that is, if functions present once per floating-point format +// rather than once per type are present for this type. +// +// All configurations supported by glibc have _Float32 the same format +// as float, _Float64 and _Float32x the same format as double, the +// _Float64x the same format as either long double or _Float128. No +// configurations support _Float128x or, as of GCC 7, have compiler +// support for a type meeting the requirements for _Float128x. + +// Defined to 1 if the corresponding _FloatN type is not binary compatible +// with the corresponding ISO C type in the current compilation unit as +// opposed to __HAVE_DISTINCT_FLOATN, which indicates the default types built +// in glibc. + +// Defined to 1 if any _FloatN or _FloatNx types that are not +// ABI-distinct are however distinct types at the C language level (so +// for the purposes of __builtin_types_compatible_p and _Generic). + +// Defined to concatenate the literal suffix to be used with _FloatN +// or _FloatNx types, if __HAVE_<type> is 1. The corresponding +// literal suffixes exist since GCC 7, for C only. + +// Defined to a complex type if __HAVE_<type> is 1. + +// The remaining of this file provides support for older compilers. + +type _Float32 = float32 /* floatn-common.h:214:15 */ + +// If double, long double and _Float64 all have the same set of +// values, TS 18661-3 requires the usual arithmetic conversions on +// long double and _Float64 to produce _Float64. For this to be the +// case when building with a compiler without a distinct _Float64 +// type, _Float64 must be a typedef for long double, not for +// double. + +type _Float64 = float64 /* floatn-common.h:251:16 */ + +type _Float32x = float64 /* floatn-common.h:268:16 */ + +type _Float64x = float64 /* floatn-common.h:285:21 */ + +// Returned by `div'. +type div_t = struct { + quot int32 + rem int32 +} /* stdlib.h:62:5 */ + +// Returned by `ldiv'. +type ldiv_t = struct { + quot int64 + rem int64 +} /* stdlib.h:70:5 */ + +// Returned by `lldiv'. +type lldiv_t = struct { + quot int64 + rem int64 +} /* stdlib.h:80:5 */ + +// Copyright (C) 1991-2018 Free Software Foundation, Inc. +// This file is part of the GNU C Library. +// +// The GNU C Library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// The GNU C Library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with the GNU C Library; if not, see +// <http://www.gnu.org/licenses/>. + +// POSIX Standard: 2.6 Primitive System Data Types <sys/types.h> + +// Copyright (C) 1991-2018 Free Software Foundation, Inc. +// This file is part of the GNU C Library. +// +// The GNU C Library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// The GNU C Library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with the GNU C Library; if not, see +// <http://www.gnu.org/licenses/>. + +// bits/types.h -- definitions of __*_t types underlying *_t types. +// Copyright (C) 2002-2018 Free Software Foundation, Inc. +// This file is part of the GNU C Library. +// +// The GNU C Library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// The GNU C Library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with the GNU C Library; if not, see +// <http://www.gnu.org/licenses/>. + +// Never include this file directly; use <sys/types.h> instead. + +type u_char = uint8 /* types.h:33:18 */ +type u_short = uint16 /* types.h:34:19 */ +type u_int = uint32 /* types.h:35:17 */ +type u_long = uint64 /* types.h:36:18 */ +type quad_t = int64 /* types.h:37:18 */ +type u_quad_t = uint64 /* types.h:38:20 */ +type fsid_t = struct{ __val [2]int32 } /* types.h:39:18 */ +type loff_t = int64 /* types.h:42:18 */ + +type ino_t = uint64 /* types.h:49:19 */ +type ino64_t = uint64 /* types.h:54:19 */ + +type dev_t = uint64 /* types.h:59:17 */ + +type mode_t = uint32 /* types.h:69:18 */ + +type nlink_t = uint32 /* types.h:74:19 */ + +type id_t = uint32 /* types.h:103:16 */ + +type daddr_t = int32 /* types.h:114:19 */ +type caddr_t = uintptr /* types.h:115:19 */ + +type key_t = int32 /* types.h:121:17 */ + +// bits/types.h -- definitions of __*_t types underlying *_t types. +// Copyright (C) 2002-2018 Free Software Foundation, Inc. +// This file is part of the GNU C Library. +// +// The GNU C Library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// The GNU C Library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with the GNU C Library; if not, see +// <http://www.gnu.org/licenses/>. + +// Never include this file directly; use <sys/types.h> instead. + +// Returned by `clock'. +type clock_t = int64 /* clock_t.h:7:19 */ + +// bits/types.h -- definitions of __*_t types underlying *_t types. +// Copyright (C) 2002-2018 Free Software Foundation, Inc. +// This file is part of the GNU C Library. +// +// The GNU C Library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// The GNU C Library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with the GNU C Library; if not, see +// <http://www.gnu.org/licenses/>. + +// Never include this file directly; use <sys/types.h> instead. + +// Clock ID used in clock and timer functions. +type clockid_t = int32 /* clockid_t.h:7:21 */ + +// bits/types.h -- definitions of __*_t types underlying *_t types. +// Copyright (C) 2002-2018 Free Software Foundation, Inc. +// This file is part of the GNU C Library. +// +// The GNU C Library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// The GNU C Library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with the GNU C Library; if not, see +// <http://www.gnu.org/licenses/>. + +// Never include this file directly; use <sys/types.h> instead. + +// Returned by `time'. +type time_t = int64 /* time_t.h:7:18 */ + +// bits/types.h -- definitions of __*_t types underlying *_t types. +// Copyright (C) 2002-2018 Free Software Foundation, Inc. +// This file is part of the GNU C Library. +// +// The GNU C Library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// The GNU C Library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with the GNU C Library; if not, see +// <http://www.gnu.org/licenses/>. + +// Never include this file directly; use <sys/types.h> instead. + +// Timer ID returned by `timer_create'. +type timer_t = uintptr /* timer_t.h:7:19 */ + +// Copyright (C) 1989-2018 Free Software Foundation, Inc. +// +//This file is part of GCC. +// +//GCC is free software; you can redistribute it and/or modify +//it under the terms of the GNU General Public License as published by +//the Free Software Foundation; either version 3, or (at your option) +//any later version. +// +//GCC is distributed in the hope that it will be useful, +//but WITHOUT ANY WARRANTY; without even the implied warranty of +//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +//GNU General Public License for more details. +// +//Under Section 7 of GPL version 3, you are granted additional +//permissions described in the GCC Runtime Library Exception, version +//3.1, as published by the Free Software Foundation. +// +//You should have received a copy of the GNU General Public License and +//a copy of the GCC Runtime Library Exception along with this program; +//see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +//<http://www.gnu.org/licenses/>. + +// ISO C Standard: 7.17 Common definitions <stddef.h> + +// Any one of these symbols __need_* means that GNU libc +// wants us just to define one data type. So don't define +// the symbols that indicate this file's entire job has been done. + +// This avoids lossage on SunOS but only if stdtypes.h comes first. +// There's no way to win with the other order! Sun lossage. + +// On 4.3bsd-net2, make sure ansi.h is included, so we have +// one less case to deal with in the following. +// On FreeBSD 5, machine/ansi.h does not exist anymore... + +// In 4.3bsd-net2, machine/ansi.h defines these symbols, which are +// defined if the corresponding type is *not* defined. +// FreeBSD-2.1 defines _MACHINE_ANSI_H_ instead of _ANSI_H_. +// NetBSD defines _I386_ANSI_H_ and _X86_64_ANSI_H_ instead of _ANSI_H_ + +// Sequent's header files use _PTRDIFF_T_ in some conflicting way. +// Just ignore it. + +// On VxWorks, <type/vxTypesBase.h> may have defined macros like +// _TYPE_size_t which will typedef size_t. fixincludes patched the +// vxTypesBase.h so that this macro is only defined if _GCC_SIZE_T is +// not defined, and so that defining this macro defines _GCC_SIZE_T. +// If we find that the macros are still defined at this point, we must +// invoke them so that the type is defined as expected. + +// In case nobody has defined these types, but we aren't running under +// GCC 2.00, make sure that __PTRDIFF_TYPE__, __SIZE_TYPE__, and +// __WCHAR_TYPE__ have reasonable values. This can happen if the +// parts of GCC is compiled by an older compiler, that actually +// include gstddef.h, such as collect2. + +// Signed type of difference of two pointers. + +// Define this type if we are doing the whole job, +// or if we want this type in particular. + +// Unsigned type of `sizeof' something. + +// Define this type if we are doing the whole job, +// or if we want this type in particular. + +// Wide character type. +// Locale-writers should change this as necessary to +// be big enough to hold unique values not between 0 and 127, +// and not (wchar_t) -1, for each defined multibyte character. + +// Define this type if we are doing the whole job, +// or if we want this type in particular. + +// In 4.3bsd-net2, leave these undefined to indicate that size_t, etc. +// are already defined. +// BSD/OS 3.1 and FreeBSD [23].x require the MACHINE_ANSI_H check here. +// NetBSD 5 requires the I386_ANSI_H and X86_64_ANSI_H checks here. + +// A null pointer constant. + +// Old compatibility names for C types. +type ulong = uint64 /* types.h:148:27 */ +type ushort = uint16 /* types.h:149:28 */ +type uint = uint32 /* types.h:150:22 */ + +// These size-specific names are used by some of the inet code. + +// Define intN_t types. +// Copyright (C) 2017-2018 Free Software Foundation, Inc. +// This file is part of the GNU C Library. +// +// The GNU C Library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// The GNU C Library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with the GNU C Library; if not, see +// <http://www.gnu.org/licenses/>. + +// bits/types.h -- definitions of __*_t types underlying *_t types. +// Copyright (C) 2002-2018 Free Software Foundation, Inc. +// This file is part of the GNU C Library. +// +// The GNU C Library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// The GNU C Library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with the GNU C Library; if not, see +// <http://www.gnu.org/licenses/>. + +// Never include this file directly; use <sys/types.h> instead. + +type int8_t = int8 /* stdint-intn.h:24:18 */ +type int16_t = int16 /* stdint-intn.h:25:19 */ +type int32_t = int32 /* stdint-intn.h:26:19 */ +type int64_t = int64 /* stdint-intn.h:27:19 */ + +// These were defined by ISO C without the first `_'. +type u_int8_t = uint8 /* types.h:160:23 */ +type u_int16_t = uint16 /* types.h:161:28 */ +type u_int32_t = uint32 /* types.h:162:22 */ +type u_int64_t = uint64 /* types.h:164:27 */ + +type register_t = int32 /* types.h:169:13 */ + +// A set of signals to be blocked, unblocked, or waited for. +type sigset_t = struct{ __val [16]uint64 } /* sigset_t.h:7:20 */ + +// Get definition of timer specification structures. + +// bits/types.h -- definitions of __*_t types underlying *_t types. +// Copyright (C) 2002-2018 Free Software Foundation, Inc. +// This file is part of the GNU C Library. +// +// The GNU C Library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// The GNU C Library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with the GNU C Library; if not, see +// <http://www.gnu.org/licenses/>. + +// Never include this file directly; use <sys/types.h> instead. + +// A time value that is accurate to the nearest +// microsecond but also has a range of years. +type timeval = struct { + tv_sec int64 + tv_usec int64 +} /* struct_timeval.h:8:1 */ + +// NB: Include guard matches what <linux/time.h> uses. + +// bits/types.h -- definitions of __*_t types underlying *_t types. +// Copyright (C) 2002-2018 Free Software Foundation, Inc. +// This file is part of the GNU C Library. +// +// The GNU C Library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// The GNU C Library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with the GNU C Library; if not, see +// <http://www.gnu.org/licenses/>. + +// Never include this file directly; use <sys/types.h> instead. + +// POSIX.1b structure for a time value. This is like a `struct timeval' but +// has nanoseconds instead of microseconds. +type timespec = struct { + tv_sec int64 + tv_nsec int64 +} /* struct_timespec.h:9:1 */ + +type suseconds_t = int64 /* select.h:43:23 */ + +// Some versions of <linux/posix_types.h> define this macros. +// It's easier to assume 8-bit bytes than to get CHAR_BIT. + +// fd_set for select and pselect. +type fd_set = struct{ __fds_bits [16]int64 } /* select.h:70:5 */ + +// Maximum number of file descriptors in `fd_set'. + +// Sometimes the fd_set member is assumed to have this type. +type fd_mask = int64 /* select.h:77:19 */ + +// Define some inlines helping to catch common problems. + +type blksize_t = int32 /* types.h:202:21 */ + +// Types from the Large File Support interface. +type blkcnt_t = int64 /* types.h:222:22 */ // Type to count number of disk blocks. +type fsblkcnt_t = uint64 /* types.h:226:24 */ // Type to count file system blocks. +type fsfilcnt_t = uint64 /* types.h:230:24 */ // Type to count file system inodes. + +type blkcnt64_t = int64 /* types.h:236:22 */ // Type to count number of disk blocks. +type fsblkcnt64_t = uint64 /* types.h:237:24 */ // Type to count file system blocks. +type fsfilcnt64_t = uint64 /* types.h:238:24 */ // Type to count file system inodes. + +// Now add the thread types. +// Declaration of common pthread types for all architectures. +// Copyright (C) 2017-2018 Free Software Foundation, Inc. +// This file is part of the GNU C Library. +// +// The GNU C Library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// The GNU C Library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with the GNU C Library; if not, see +// <http://www.gnu.org/licenses/>. + +// For internal mutex and condition variable definitions. +// Common threading primitives definitions for both POSIX and C11. +// Copyright (C) 2017-2018 Free Software Foundation, Inc. +// This file is part of the GNU C Library. +// +// The GNU C Library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// The GNU C Library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with the GNU C Library; if not, see +// <http://www.gnu.org/licenses/>. + +// Arch-specific definitions. Each architecture must define the following +// macros to define the expected sizes of pthread data types: +// +// __SIZEOF_PTHREAD_ATTR_T - size of pthread_attr_t. +// __SIZEOF_PTHREAD_MUTEX_T - size of pthread_mutex_t. +// __SIZEOF_PTHREAD_MUTEXATTR_T - size of pthread_mutexattr_t. +// __SIZEOF_PTHREAD_COND_T - size of pthread_cond_t. +// __SIZEOF_PTHREAD_CONDATTR_T - size of pthread_condattr_t. +// __SIZEOF_PTHREAD_RWLOCK_T - size of pthread_rwlock_t. +// __SIZEOF_PTHREAD_RWLOCKATTR_T - size of pthread_rwlockattr_t. +// __SIZEOF_PTHREAD_BARRIER_T - size of pthread_barrier_t. +// __SIZEOF_PTHREAD_BARRIERATTR_T - size of pthread_barrierattr_t. +// +// Also, the following macros must be define for internal pthread_mutex_t +// struct definitions (struct __pthread_mutex_s): +// +// __PTHREAD_COMPAT_PADDING_MID - any additional members after 'kind' +// and before '__spin' (for 64 bits) or +// '__nusers' (for 32 bits). +// __PTHREAD_COMPAT_PADDING_END - any additional members at the end of +// the internal structure. +// __PTHREAD_MUTEX_LOCK_ELISION - 1 if the architecture supports lock +// elision or 0 otherwise. +// __PTHREAD_MUTEX_NUSERS_AFTER_KIND - control where to put __nusers. The +// preferred value for new architectures +// is 0. +// __PTHREAD_MUTEX_USE_UNION - control whether internal __spins and +// __list will be place inside a union for +// linuxthreads compatibility. +// The preferred value for new architectures +// is 0. +// +// For a new port the preferred values for the required defines are: +// +// #define __PTHREAD_COMPAT_PADDING_MID +// #define __PTHREAD_COMPAT_PADDING_END +// #define __PTHREAD_MUTEX_LOCK_ELISION 0 +// #define __PTHREAD_MUTEX_NUSERS_AFTER_KIND 0 +// #define __PTHREAD_MUTEX_USE_UNION 0 +// +// __PTHREAD_MUTEX_LOCK_ELISION can be set to 1 if the hardware plans to +// eventually support lock elision using transactional memory. +// +// The additional macro defines any constraint for the lock alignment +// inside the thread structures: +// +// __LOCK_ALIGNMENT - for internal lock/futex usage. +// +// Same idea but for the once locking primitive: +// +// __ONCE_ALIGNMENT - for pthread_once_t/once_flag definition. +// +// And finally the internal pthread_rwlock_t (struct __pthread_rwlock_arch_t) +// must be defined. +// +// Copyright (C) 2002-2018 Free Software Foundation, Inc. +// +// This file is part of the GNU C Library. +// +// The GNU C Library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// The GNU C Library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with the GNU C Library; if not, see +// <http://www.gnu.org/licenses/>. + +// Copyright (C) 1992-2018 Free Software Foundation, Inc. +// This file is part of the GNU C Library. +// +// The GNU C Library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// The GNU C Library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with the GNU C Library; if not, see +// <http://www.gnu.org/licenses/>. + +// Definitions for internal mutex struct. + +type __pthread_rwlock_arch_t = struct { + __readers uint32 + __writers uint32 + __wrphase_futex uint32 + __writers_futex uint32 + __pad3 uint32 + __pad4 uint32 + __cur_writer int32 + __shared int32 + __pad1 uint64 + __pad2 uint64 + __flags uint32 + _ [4]byte +} /* pthreadtypes-arch.h:54:1 */ + +// Common definition of pthread_mutex_t. + +type __pthread_internal_list = struct { + __prev uintptr + __next uintptr +} /* thread-shared-types.h:82:9 */ + +// Lock elision support. +// Mutex __spins initializer used by PTHREAD_MUTEX_INITIALIZER. + +type __pthread_mutex_s = struct { + __lock int32 + __count uint32 + __owner int32 + __nusers uint32 + __kind int32 + __spins int32 + __list struct { + __prev uintptr + __next uintptr + } +} /* thread-shared-types.h:118:1 */ + +// Common definition of pthread_cond_t. + +type __pthread_cond_s = struct { + __0 struct{ __wseq uint64 } + __8 struct{ __g1_start uint64 } + __g_refs [2]uint32 + __g_size [2]uint32 + __g1_orig_size uint32 + __wrefs uint32 + __g_signals [2]uint32 +} /* thread-shared-types.h:171:1 */ + +// Thread identifiers. The structure of the attribute type is not +// exposed on purpose. +type pthread_t = uint64 /* pthreadtypes.h:27:27 */ + +// Data structures for mutex handling. The structure of the attribute +// type is not exposed on purpose. +type pthread_mutexattr_t = struct { + _ [0]uint32 + __size [8]int8 +} /* pthreadtypes.h:36:3 */ + +// Data structure for condition variable handling. The structure of +// the attribute type is not exposed on purpose. +type pthread_condattr_t = struct { + _ [0]uint32 + __size [8]int8 +} /* pthreadtypes.h:45:3 */ + +// Keys for thread-specific data +type pthread_key_t = uint32 /* pthreadtypes.h:49:22 */ + +// Once-only execution +type pthread_once_t = int32 /* pthreadtypes.h:53:30 */ + +type pthread_attr_t1 = struct { + _ [0]uint64 + __size [64]int8 +} /* pthreadtypes.h:56:1 */ + +type pthread_attr_t = pthread_attr_t1 /* pthreadtypes.h:62:30 */ + +type pthread_mutex_t = struct { + __data __pthread_mutex_s + _ [8]byte +} /* pthreadtypes.h:72:3 */ + +type pthread_cond_t = struct{ __data __pthread_cond_s } /* pthreadtypes.h:80:3 */ + +// Data structure for reader-writer lock variable handling. The +// structure of the attribute type is deliberately not exposed. +type pthread_rwlock_t = struct{ __data __pthread_rwlock_arch_t } /* pthreadtypes.h:91:3 */ + +type pthread_rwlockattr_t = struct { + _ [0]uint64 + __size [8]int8 +} /* pthreadtypes.h:97:3 */ + +// POSIX spinlock data type. +type pthread_spinlock_t = int32 /* pthreadtypes.h:103:22 */ + +// POSIX barriers data type. The structure of the type is +// deliberately not exposed. +type pthread_barrier_t = struct { + _ [0]uint64 + __size [32]int8 +} /* pthreadtypes.h:112:3 */ + +type pthread_barrierattr_t = struct { + _ [0]uint32 + __size [8]int8 +} /* pthreadtypes.h:118:3 */ + +// Reentrant versions of the `random' family of functions. +// These functions all use the following data structure to contain +// state, rather than global state variables. + +type random_data = struct { + fptr uintptr + rptr uintptr + state uintptr + rand_type int32 + rand_deg int32 + rand_sep int32 + _ [4]byte + end_ptr uintptr +} /* stdlib.h:423:1 */ + +// Data structure for communication with thread safe versions. This +// type is to be regarded as opaque. It's only exported because users +// have to allocate objects of this type. +type drand48_data = struct { + __x [3]uint16 + __old_x [3]uint16 + __c uint16 + __init uint16 + __a uint64 +} /* stdlib.h:490:1 */ + +// POSIX.1-2008 extended locale interface (see locale.h). +// Definition of locale_t. +// Copyright (C) 2017-2018 Free Software Foundation, Inc. +// This file is part of the GNU C Library. +// +// The GNU C Library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// The GNU C Library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with the GNU C Library; if not, see +// <http://www.gnu.org/licenses/>. + +// Definition of struct __locale_struct and __locale_t. +// Copyright (C) 1997-2018 Free Software Foundation, Inc. +// This file is part of the GNU C Library. +// Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997. +// +// The GNU C Library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// The GNU C Library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with the GNU C Library; if not, see +// <http://www.gnu.org/licenses/>. + +// POSIX.1-2008: the locale_t type, representing a locale context +// (implementation-namespace version). This type should be treated +// as opaque by applications; some details are exposed for the sake of +// efficiency in e.g. ctype functions. + +type __locale_struct = struct { + __locales [13]uintptr + __ctype_b uintptr + __ctype_tolower uintptr + __ctype_toupper uintptr + __names [13]uintptr +} /* __locale_t.h:28:1 */ + +type locale_t = uintptr /* locale_t.h:24:20 */ + +// The suffix to append to the child command lines, if any + +// The directory separator character(s) + +// Mark a parameter as unused to suppress compiler warnings + +// Global data +type Global = struct { + argv0 uintptr + zVfs uintptr + zDbFile uintptr + db uintptr + zErrLog uintptr + pErrLog uintptr + zLog uintptr + pLog uintptr + zName [32]int8 + taskId int32 + iTrace int32 + bSqlTrace int32 + bIgnoreSqlErrors int32 + nError int32 + nTest int32 + iTimeout int32 + bSync int32 +} /* mptest.c:72:8 */ + +// The suffix to append to the child command lines, if any + +// The directory separator character(s) + +// Mark a parameter as unused to suppress compiler warnings + +// Global data +var g Global /* mptest.c:90:3: */ + +// Default timeout + +// Print a message adding zPrefix[] to the beginning of every line. +func printWithPrefix(tls *libc.TLS, pOut uintptr, zPrefix uintptr, zMsg uintptr) { /* mptest.c:98:13: */ + bp := tls.Alloc(24) + defer tls.Free(24) + + for (zMsg != 0) && (*(*int8)(unsafe.Pointer(zMsg + uintptr(0))) != 0) { + var i int32 + for i = 0; ((*(*int8)(unsafe.Pointer(zMsg + uintptr(i))) != 0) && (int32(*(*int8)(unsafe.Pointer(zMsg + uintptr(i)))) != '\n')) && (int32(*(*int8)(unsafe.Pointer(zMsg + uintptr(i)))) != '\r'); i++ { + } + libc.Xfprintf(tls, pOut, ts /* "%s%.*s\n" */, libc.VaList(bp, zPrefix, i, zMsg)) + zMsg += uintptr(i) + for (int32(*(*int8)(unsafe.Pointer(zMsg + uintptr(0)))) == '\n') || (int32(*(*int8)(unsafe.Pointer(zMsg + uintptr(0)))) == '\r') { + zMsg++ + } + } +} + +// Compare two pointers to strings, where the pointers might be NULL. +func safe_strcmp(tls *libc.TLS, a uintptr, b uintptr) int32 { /* mptest.c:111:12: */ + if a == b { + return 0 + } + if a == uintptr(0) { + return -1 + } + if b == uintptr(0) { + return 1 + } + return libc.Xstrcmp(tls, a, b) +} + +// Return TRUE if string z[] matches glob pattern zGlob[]. +// Return FALSE if the pattern does not match. +// +// Globbing rules: +// +// '*' Matches any sequence of zero or more characters. +// +// '?' Matches exactly one character. +// +// [...] Matches one character from the enclosed list of +// characters. +// +// [^...] Matches one character not in the enclosed list. +// +// '#' Matches any sequence of one or more digits with an +// optional + or - sign in front +func strglob(tls *libc.TLS, zGlob uintptr, z uintptr) int32 { /* mptest.c:136:5: */ + var c int32 + var c2 int32 + var invert int32 + var seen int32 + + for (libc.AssignInt32(&c, int32(*(*int8)(unsafe.Pointer(libc.PostIncUintptr(&zGlob, 1)))))) != 0 { + if c == '*' { + for ((libc.AssignInt32(&c, int32(*(*int8)(unsafe.Pointer(libc.PostIncUintptr(&zGlob, 1)))))) == '*') || (c == '?') { + if (c == '?') && ((int32(*(*int8)(unsafe.Pointer(libc.PostIncUintptr(&z, 1))))) == 0) { + return 0 + } + } + if c == 0 { + return 1 + } else if c == '[' { + for (*(*int8)(unsafe.Pointer(z)) != 0) && (strglob(tls, (zGlob-uintptr(1)), z) != 0) { + z++ + } + return (libc.Bool32((int32(*(*int8)(unsafe.Pointer(z)))) != 0)) + } + for (libc.AssignInt32(&c2, int32(*(*int8)(unsafe.Pointer(libc.PostIncUintptr(&z, 1)))))) != 0 { + for c2 != c { + c2 = int32(*(*int8)(unsafe.Pointer(libc.PostIncUintptr(&z, 1)))) + if c2 == 0 { + return 0 + } + } + if strglob(tls, zGlob, z) != 0 { + return 1 + } + } + return 0 + } else if c == '?' { + if (int32(*(*int8)(unsafe.Pointer(libc.PostIncUintptr(&z, 1))))) == 0 { + return 0 + } + } else if c == '[' { + var prior_c int32 = 0 + seen = 0 + invert = 0 + c = int32(*(*int8)(unsafe.Pointer(libc.PostIncUintptr(&z, 1)))) + if c == 0 { + return 0 + } + c2 = int32(*(*int8)(unsafe.Pointer(libc.PostIncUintptr(&zGlob, 1)))) + if c2 == '^' { + invert = 1 + c2 = int32(*(*int8)(unsafe.Pointer(libc.PostIncUintptr(&zGlob, 1)))) + } + if c2 == ']' { + if c == ']' { + seen = 1 + } + c2 = int32(*(*int8)(unsafe.Pointer(libc.PostIncUintptr(&zGlob, 1)))) + } + for (c2 != 0) && (c2 != ']') { + if (((c2 == '-') && (int32(*(*int8)(unsafe.Pointer(zGlob + uintptr(0)))) != ']')) && (int32(*(*int8)(unsafe.Pointer(zGlob + uintptr(0)))) != 0)) && (prior_c > 0) { + c2 = int32(*(*int8)(unsafe.Pointer(libc.PostIncUintptr(&zGlob, 1)))) + if (c >= prior_c) && (c <= c2) { + seen = 1 + } + prior_c = 0 + } else { + if c == c2 { + seen = 1 + } + prior_c = c2 + } + c2 = int32(*(*int8)(unsafe.Pointer(libc.PostIncUintptr(&zGlob, 1)))) + } + if (c2 == 0) || ((seen ^ invert) == 0) { + return 0 + } + } else if c == '#' { + if ((int32(*(*int8)(unsafe.Pointer(z + uintptr(0)))) == '-') || (int32(*(*int8)(unsafe.Pointer(z + uintptr(0)))) == '+')) && ((int32(*(*uint16)(unsafe.Pointer((*(*uintptr)(unsafe.Pointer(libc.X__ctype_b_loc(tls)))) + uintptr(int32(uint8(*(*int8)(unsafe.Pointer(z + uintptr(1))))))*2))) & int32(_ISdigit)) != 0) { + z++ + } + if !((int32(*(*uint16)(unsafe.Pointer((*(*uintptr)(unsafe.Pointer(libc.X__ctype_b_loc(tls)))) + uintptr(int32(uint8(*(*int8)(unsafe.Pointer(z + uintptr(0))))))*2))) & int32(_ISdigit)) != 0) { + return 0 + } + z++ + for (int32(*(*uint16)(unsafe.Pointer((*(*uintptr)(unsafe.Pointer(libc.X__ctype_b_loc(tls)))) + uintptr(int32(uint8(*(*int8)(unsafe.Pointer(z + uintptr(0))))))*2))) & int32(_ISdigit)) != 0 { + z++ + } + } else { + if c != (int32(*(*int8)(unsafe.Pointer(libc.PostIncUintptr(&z, 1))))) { + return 0 + } + } + } + return (libc.Bool32(int32(*(*int8)(unsafe.Pointer(z))) == 0)) +} + +// Close output stream pOut if it is not stdout or stderr +func maybeClose(tls *libc.TLS, pOut uintptr) { /* mptest.c:208:13: */ + if (pOut != libc.Xstdout) && (pOut != libc.Xstderr) { + libc.Xfclose(tls, pOut) + } +} + +// Print an error message +func errorMessage(tls *libc.TLS, zFormat uintptr, va uintptr) { /* mptest.c:215:13: */ + bp := tls.Alloc(38) + defer tls.Free(38) + + var ap va_list + _ = ap + var zMsg uintptr + // var zPrefix [30]int8 at bp+8, 30 + + ap = va + zMsg = sqlite3.Xsqlite3_vmprintf(tls, zFormat, ap) + _ = ap + sqlite3.Xsqlite3_snprintf(tls, int32(unsafe.Sizeof([30]int8{})), bp+8 /* &zPrefix[0] */, ts+8 /* "%s:ERROR: " */, libc.VaList(bp, uintptr(unsafe.Pointer(&g))+64 /* &.zName */)) + if g.pLog != 0 { + printWithPrefix(tls, g.pLog, bp+8 /* &zPrefix[0] */, zMsg) + libc.Xfflush(tls, g.pLog) + } + if (g.pErrLog != 0) && (safe_strcmp(tls, g.zErrLog, g.zLog) != 0) { + printWithPrefix(tls, g.pErrLog, bp+8 /* &zPrefix[0] */, zMsg) + libc.Xfflush(tls, g.pErrLog) + } + sqlite3.Xsqlite3_free(tls, zMsg) + g.nError++ +} + +// Print an error message and then quit. +func fatalError(tls *libc.TLS, zFormat uintptr, va uintptr) { /* mptest.c:241:13: */ + bp := tls.Alloc(38) + defer tls.Free(38) + + var ap va_list + _ = ap + var zMsg uintptr + // var zPrefix [30]int8 at bp+8, 30 + + ap = va + zMsg = sqlite3.Xsqlite3_vmprintf(tls, zFormat, ap) + _ = ap + sqlite3.Xsqlite3_snprintf(tls, int32(unsafe.Sizeof([30]int8{})), bp+8 /* &zPrefix[0] */, ts+19 /* "%s:FATAL: " */, libc.VaList(bp, uintptr(unsafe.Pointer(&g))+64 /* &.zName */)) + if g.pLog != 0 { + printWithPrefix(tls, g.pLog, bp+8 /* &zPrefix[0] */, zMsg) + libc.Xfflush(tls, g.pLog) + maybeClose(tls, g.pLog) + } + if (g.pErrLog != 0) && (safe_strcmp(tls, g.zErrLog, g.zLog) != 0) { + printWithPrefix(tls, g.pErrLog, bp+8 /* &zPrefix[0] */, zMsg) + libc.Xfflush(tls, g.pErrLog) + maybeClose(tls, g.pErrLog) + } + sqlite3.Xsqlite3_free(tls, zMsg) + if g.db != 0 { + var nTry int32 = 0 + g.iTimeout = 0 + for (trySql(tls, ts+30 /* "UPDATE client SE..." */, 0) == 5) && + ((libc.PostIncInt32(&nTry, 1)) < 100) { + sqlite3.Xsqlite3_sleep(tls, 10) + } + } + sqlite3.Xsqlite3_close(tls, g.db) + libc.Xexit(tls, 1) +} + +// Print a log message +func logMessage(tls *libc.TLS, zFormat uintptr, va uintptr) { /* mptest.c:276:13: */ + bp := tls.Alloc(38) + defer tls.Free(38) + + var ap va_list + _ = ap + var zMsg uintptr + // var zPrefix [30]int8 at bp+8, 30 + + ap = va + zMsg = sqlite3.Xsqlite3_vmprintf(tls, zFormat, ap) + _ = ap + sqlite3.Xsqlite3_snprintf(tls, int32(unsafe.Sizeof([30]int8{})), bp+8 /* &zPrefix[0] */, ts+60 /* "%s: " */, libc.VaList(bp, uintptr(unsafe.Pointer(&g))+64 /* &.zName */)) + if g.pLog != 0 { + printWithPrefix(tls, g.pLog, bp+8 /* &zPrefix[0] */, zMsg) + libc.Xfflush(tls, g.pLog) + } + sqlite3.Xsqlite3_free(tls, zMsg) +} + +// Return the length of a string omitting trailing whitespace +func clipLength(tls *libc.TLS, z uintptr) int32 { /* mptest.c:294:12: */ + var n int32 = int32(libc.Xstrlen(tls, z)) + for (n > 0) && ((int32(*(*uint16)(unsafe.Pointer((*(*uintptr)(unsafe.Pointer(libc.X__ctype_b_loc(tls)))) + uintptr(int32(uint8(*(*int8)(unsafe.Pointer(z + uintptr((n - 1)))))))*2))) & int32(_ISspace)) != 0) { + n-- + } + return n +} + +// Auxiliary SQL function to return the name of the VFS +func vfsNameFunc(tls *libc.TLS, context uintptr, argc int32, argv uintptr) { /* mptest.c:303:13: */ + bp := tls.Alloc(8) + defer tls.Free(8) + + var db uintptr = sqlite3.Xsqlite3_context_db_handle(tls, context) + *(*uintptr)(unsafe.Pointer(bp /* zVfs */)) = uintptr(0) + _ = argc + _ = argv + sqlite3.Xsqlite3_file_control(tls, db, ts+65 /* "main" */, 12, bp /* &zVfs */) + if *(*uintptr)(unsafe.Pointer(bp /* zVfs */)) != 0 { + sqlite3.Xsqlite3_result_text(tls, context, *(*uintptr)(unsafe.Pointer(bp /* zVfs */)), -1, *(*uintptr)(unsafe.Pointer(&struct{ f func(*libc.TLS, uintptr) }{sqlite3.Xsqlite3_free}))) + } +} + +// Busy handler with a g.iTimeout-millisecond timeout +func busyHandler(tls *libc.TLS, pCD uintptr, count int32) int32 { /* mptest.c:321:12: */ + bp := tls.Alloc(8) + defer tls.Free(8) + + _ = pCD + if (count * 10) > g.iTimeout { + if g.iTimeout > 0 { + errorMessage(tls, ts+70 /* "timeout after %d..." */, libc.VaList(bp, g.iTimeout)) + } + return 0 + } + sqlite3.Xsqlite3_sleep(tls, 10) + return 1 +} + +// SQL Trace callback +func sqlTraceCallback(tls *libc.TLS, NotUsed1 uintptr, zSql uintptr) { /* mptest.c:334:13: */ + bp := tls.Alloc(16) + defer tls.Free(16) + + _ = NotUsed1 + logMessage(tls, ts+89 /* "[%.*s]" */, libc.VaList(bp, clipLength(tls, zSql), zSql)) +} + +// SQL error log callback +func sqlErrorCallback(tls *libc.TLS, pArg uintptr, iErrCode int32, zMsg uintptr) { /* mptest.c:342:13: */ + bp := tls.Alloc(24) + defer tls.Free(24) + + _ = pArg + if (iErrCode == 1) && (g.bIgnoreSqlErrors != 0) { + return + } + if ((iErrCode & 0xff) == 17) && (g.iTrace < 3) { + return + } + if ((g.iTimeout == 0) && ((iErrCode & 0xff) == 5)) && (g.iTrace < 3) { + return + } + if (iErrCode & 0xff) == 27 { + logMessage(tls, ts+96 /* "(info) %s" */, libc.VaList(bp, zMsg)) + } else { + errorMessage(tls, ts+106 /* "(errcode=%d) %s" */, libc.VaList(bp+8, iErrCode, zMsg)) + } +} + +// Prepare an SQL statement. Issue a fatal error if unable. +func prepareSql(tls *libc.TLS, zFormat uintptr, va uintptr) uintptr { /* mptest.c:357:21: */ + bp := tls.Alloc(24) + defer tls.Free(24) + + var ap va_list + _ = ap + var zSql uintptr + var rc int32 + *(*uintptr)(unsafe.Pointer(bp + 16 /* pStmt */)) = uintptr(0) + ap = va + zSql = sqlite3.Xsqlite3_vmprintf(tls, zFormat, ap) + _ = ap + rc = sqlite3.Xsqlite3_prepare_v2(tls, g.db, zSql, -1, bp+16 /* &pStmt */, uintptr(0)) + if rc != 0 { + sqlite3.Xsqlite3_finalize(tls, *(*uintptr)(unsafe.Pointer(bp + 16 /* pStmt */))) + fatalError(tls, ts+122 /* "%s\n%s\n" */, libc.VaList(bp, sqlite3.Xsqlite3_errmsg(tls, g.db), zSql)) + } + sqlite3.Xsqlite3_free(tls, zSql) + return *(*uintptr)(unsafe.Pointer(bp + 16 /* pStmt */)) +} + +// Run arbitrary SQL. Issue a fatal error on failure. +func runSql(tls *libc.TLS, zFormat uintptr, va uintptr) { /* mptest.c:377:13: */ + bp := tls.Alloc(16) + defer tls.Free(16) + + var ap va_list + _ = ap + var zSql uintptr + var rc int32 + ap = va + zSql = sqlite3.Xsqlite3_vmprintf(tls, zFormat, ap) + _ = ap + rc = sqlite3.Xsqlite3_exec(tls, g.db, zSql, uintptr(0), uintptr(0), uintptr(0)) + if rc != 0 { + fatalError(tls, ts+122 /* "%s\n%s\n" */, libc.VaList(bp, sqlite3.Xsqlite3_errmsg(tls, g.db), zSql)) + } + sqlite3.Xsqlite3_free(tls, zSql) +} + +// Try to run arbitrary SQL. Return success code. +func trySql(tls *libc.TLS, zFormat uintptr, va uintptr) int32 { /* mptest.c:394:12: */ + var ap va_list + _ = ap + var zSql uintptr + var rc int32 + ap = va + zSql = sqlite3.Xsqlite3_vmprintf(tls, zFormat, ap) + _ = ap + rc = sqlite3.Xsqlite3_exec(tls, g.db, zSql, uintptr(0), uintptr(0), uintptr(0)) + sqlite3.Xsqlite3_free(tls, zSql) + return rc +} + +// Structure for holding an arbitrary length string +type String1 = struct { + z uintptr + n int32 + nAlloc int32 +} /* mptest.c:408:9 */ + +// Structure for holding an arbitrary length string +type String = String1 /* mptest.c:408:23 */ + +// Free a string +func stringFree(tls *libc.TLS, p uintptr) { /* mptest.c:416:13: */ + if (*String)(unsafe.Pointer(p)).z != 0 { + sqlite3.Xsqlite3_free(tls, (*String)(unsafe.Pointer(p)).z) + } + libc.Xmemset(tls, p, 0, uint64(unsafe.Sizeof(String{}))) +} + +// Append n bytes of text to a string. If n<0 append the entire string. +func stringAppend(tls *libc.TLS, p uintptr, z uintptr, n int32) { /* mptest.c:422:13: */ + if n < 0 { + n = int32(libc.Xstrlen(tls, z)) + } + if ((*String)(unsafe.Pointer(p)).n + n) >= (*String)(unsafe.Pointer(p)).nAlloc { + var nAlloc int32 = ((((*String)(unsafe.Pointer(p)).nAlloc * 2) + n) + 100) + var zNew uintptr = sqlite3.Xsqlite3_realloc(tls, (*String)(unsafe.Pointer(p)).z, nAlloc) + if zNew == uintptr(0) { + fatalError(tls, ts+129 /* "out of memory" */, 0) + } + (*String)(unsafe.Pointer(p)).z = zNew + (*String)(unsafe.Pointer(p)).nAlloc = nAlloc + } + libc.Xmemcpy(tls, ((*String)(unsafe.Pointer(p)).z + uintptr((*String)(unsafe.Pointer(p)).n)), z, uint64(n)) + *(*int32)(unsafe.Pointer(p + 8 /* &.n */)) += (n) + *(*int8)(unsafe.Pointer((*String)(unsafe.Pointer(p)).z + uintptr((*String)(unsafe.Pointer(p)).n))) = int8(0) +} + +// Reset a string to an empty string +func stringReset(tls *libc.TLS, p uintptr) { /* mptest.c:437:13: */ + if (*String)(unsafe.Pointer(p)).z == uintptr(0) { + stringAppend(tls, p, ts+143 /* " " */, 1) + } + (*String)(unsafe.Pointer(p)).n = 0 + *(*int8)(unsafe.Pointer((*String)(unsafe.Pointer(p)).z + uintptr(0))) = int8(0) +} + +// Append a new token onto the end of the string +func stringAppendTerm(tls *libc.TLS, p uintptr, z uintptr) { /* mptest.c:444:13: */ + var i int32 + if (*String)(unsafe.Pointer(p)).n != 0 { + stringAppend(tls, p, ts+143 /* " " */, 1) + } + if z == uintptr(0) { + stringAppend(tls, p, ts+145 /* "nil" */, 3) + return + } + for i = 0; (*(*int8)(unsafe.Pointer(z + uintptr(i))) != 0) && !((int32(*(*uint16)(unsafe.Pointer((*(*uintptr)(unsafe.Pointer(libc.X__ctype_b_loc(tls)))) + uintptr(int32(uint8(*(*int8)(unsafe.Pointer(z + uintptr(i))))))*2))) & int32(_ISspace)) != 0); i++ { + } + if (i > 0) && (int32(*(*int8)(unsafe.Pointer(z + uintptr(i)))) == 0) { + stringAppend(tls, p, z, i) + return + } + stringAppend(tls, p, ts+149 /* "'" */, 1) + for *(*int8)(unsafe.Pointer(z + uintptr(0))) != 0 { + for i = 0; (*(*int8)(unsafe.Pointer(z + uintptr(i))) != 0) && (int32(*(*int8)(unsafe.Pointer(z + uintptr(i)))) != '\''); i++ { + } + if *(*int8)(unsafe.Pointer(z + uintptr(i))) != 0 { + stringAppend(tls, p, z, (i + 1)) + stringAppend(tls, p, ts+149 /* "'" */, 1) + z += (uintptr(i + 1)) + } else { + stringAppend(tls, p, z, i) + break + } + } + stringAppend(tls, p, ts+149 /* "'" */, 1) +} + +// Callback function for evalSql() +func evalCallback(tls *libc.TLS, pCData uintptr, argc int32, argv uintptr, azCol uintptr) int32 { /* mptest.c:474:12: */ + var p uintptr = pCData + var i int32 + _ = azCol + for i = 0; i < argc; i++ { + stringAppendTerm(tls, p, *(*uintptr)(unsafe.Pointer(argv + uintptr(i)*8))) + } + return 0 +} + +// Run arbitrary SQL and record the results in an output string +// given by the first parameter. +func evalSql(tls *libc.TLS, p uintptr, zFormat uintptr, va uintptr) int32 { /* mptest.c:486:12: */ + bp := tls.Alloc(46) + defer tls.Free(46) + + var ap va_list + _ = ap + var zSql uintptr + var rc int32 + *(*uintptr)(unsafe.Pointer(bp + 8 /* zErrMsg */)) = uintptr(0) + ap = va + zSql = sqlite3.Xsqlite3_vmprintf(tls, zFormat, ap) + _ = ap + + rc = sqlite3.Xsqlite3_exec(tls, g.db, zSql, *(*uintptr)(unsafe.Pointer(&struct { + f func(*libc.TLS, uintptr, int32, uintptr, uintptr) int32 + }{evalCallback})), p, bp+8 /* &zErrMsg */) + sqlite3.Xsqlite3_free(tls, zSql) + if rc != 0 { + // var zErr [30]int8 at bp+16, 30 + + sqlite3.Xsqlite3_snprintf(tls, int32(unsafe.Sizeof([30]int8{})), bp+16 /* &zErr[0] */, ts+151 /* "error(%d)" */, libc.VaList(bp, rc)) + stringAppendTerm(tls, p, bp+16 /* &zErr[0] */) + if *(*uintptr)(unsafe.Pointer(bp + 8 /* zErrMsg */)) != 0 { + stringAppendTerm(tls, p, *(*uintptr)(unsafe.Pointer(bp + 8 /* zErrMsg */))) + sqlite3.Xsqlite3_free(tls, *(*uintptr)(unsafe.Pointer(bp + 8 /* zErrMsg */))) + } + } + return rc +} + +// Auxiliary SQL function to recursively evaluate SQL. +func evalFunc(tls *libc.TLS, context uintptr, argc int32, argv uintptr) { /* mptest.c:512:13: */ + bp := tls.Alloc(24) + defer tls.Free(24) + + var db uintptr = sqlite3.Xsqlite3_context_db_handle(tls, context) + var zSql uintptr = sqlite3.Xsqlite3_value_text(tls, *(*uintptr)(unsafe.Pointer(argv + uintptr(0)*8))) + // var res String at bp, 16 + + *(*uintptr)(unsafe.Pointer(bp + 16 /* zErrMsg */)) = uintptr(0) + var rc int32 + _ = argc + libc.Xmemset(tls, bp /* &res */, 0, uint64(unsafe.Sizeof(String{}))) + rc = sqlite3.Xsqlite3_exec(tls, db, zSql, *(*uintptr)(unsafe.Pointer(&struct { + f func(*libc.TLS, uintptr, int32, uintptr, uintptr) int32 + }{evalCallback})), bp /* &res */, bp+16 /* &zErrMsg */) + if *(*uintptr)(unsafe.Pointer(bp + 16 /* zErrMsg */)) != 0 { + sqlite3.Xsqlite3_result_error(tls, context, *(*uintptr)(unsafe.Pointer(bp + 16 /* zErrMsg */)), -1) + sqlite3.Xsqlite3_free(tls, *(*uintptr)(unsafe.Pointer(bp + 16 /* zErrMsg */))) + } else if rc != 0 { + sqlite3.Xsqlite3_result_error_code(tls, context, rc) + } else { + sqlite3.Xsqlite3_result_text(tls, context, (*String)(unsafe.Pointer(bp /* &res */)).z, -1, libc.UintptrFromInt32(-1)) + } + stringFree(tls, bp /* &res */) +} + +// Look up the next task for client iClient in the database. +// Return the task script and the task number and mark that +// task as being under way. +func startScript(tls *libc.TLS, iClient int32, pzScript uintptr, pTaskId uintptr, pzTaskName uintptr) int32 { /* mptest.c:541:12: */ + bp := tls.Alloc(80) + defer tls.Free(80) + + var pStmt uintptr = uintptr(0) + var taskId int32 + var rc int32 + var totalTime int32 = 0 + + *(*uintptr)(unsafe.Pointer(pzScript)) = uintptr(0) + g.iTimeout = 0 + for 1 != 0 { + rc = trySql(tls, ts+161 /* "BEGIN IMMEDIATE" */, 0) + if rc == 5 { + sqlite3.Xsqlite3_sleep(tls, 10) + totalTime = totalTime + (10) + continue + } + if rc != 0 { + fatalError(tls, ts+177 /* "in startScript: ..." */, libc.VaList(bp, sqlite3.Xsqlite3_errmsg(tls, g.db))) + } + if (g.nError != 0) || (g.nTest != 0) { + runSql(tls, ts+196, /* "UPDATE counters ..." */ + libc.VaList(bp+8, g.nError, g.nTest)) + g.nError = 0 + g.nTest = 0 + } + pStmt = prepareSql(tls, ts+249 /* "SELECT 1 FROM cl..." */, libc.VaList(bp+24, iClient)) + rc = sqlite3.Xsqlite3_step(tls, pStmt) + sqlite3.Xsqlite3_finalize(tls, pStmt) + if rc == 100 { + runSql(tls, ts+295 /* "DELETE FROM clie..." */, libc.VaList(bp+32, iClient)) + g.iTimeout = 10000 + runSql(tls, ts+326 /* "COMMIT TRANSACTI..." */, 0) + return 101 + } + pStmt = prepareSql(tls, + + ts+346 /* "SELECT script, i..." */, libc.VaList(bp+40, iClient)) + rc = sqlite3.Xsqlite3_step(tls, pStmt) + if rc == 100 { + var n int32 = sqlite3.Xsqlite3_column_bytes(tls, pStmt, 0) + *(*uintptr)(unsafe.Pointer(pzScript)) = sqlite3.Xsqlite3_malloc(tls, (n + 1)) + libc.Xstrcpy(tls, *(*uintptr)(unsafe.Pointer(pzScript)), sqlite3.Xsqlite3_column_text(tls, pStmt, 0)) + *(*int32)(unsafe.Pointer(pTaskId)) = libc.AssignInt32(&taskId, sqlite3.Xsqlite3_column_int(tls, pStmt, 1)) + *(*uintptr)(unsafe.Pointer(pzTaskName)) = sqlite3.Xsqlite3_mprintf(tls, ts+438 /* "%s" */, libc.VaList(bp+48, sqlite3.Xsqlite3_column_text(tls, pStmt, 2))) + sqlite3.Xsqlite3_finalize(tls, pStmt) + runSql(tls, + + ts+441 /* "UPDATE task SE..." */, libc.VaList(bp+56, taskId)) + g.iTimeout = 10000 + runSql(tls, ts+326 /* "COMMIT TRANSACTI..." */, 0) + return 0 + } + sqlite3.Xsqlite3_finalize(tls, pStmt) + if rc == 101 { + if totalTime > 30000 { + errorMessage(tls, ts+524 /* "Waited over 30 s..." */, 0) + runSql(tls, ts+573 /* "DELETE FROM clie..." */, libc.VaList(bp+64, iClient)) + sqlite3.Xsqlite3_close(tls, g.db) + libc.Xexit(tls, 1) + } + for trySql(tls, ts+613 /* "COMMIT" */, 0) == 5 { + sqlite3.Xsqlite3_sleep(tls, 10) + totalTime = totalTime + (10) + } + sqlite3.Xsqlite3_sleep(tls, 100) + totalTime = totalTime + (100) + continue + } + fatalError(tls, ts+438 /* "%s" */, libc.VaList(bp+72, sqlite3.Xsqlite3_errmsg(tls, g.db))) + } + g.iTimeout = 10000 + return int32(0) +} + +// Mark a script as having finished. Remove the CLIENT table entry +// if bShutdown is true. +func finishScript(tls *libc.TLS, iClient int32, taskId int32, bShutdown int32) int32 { /* mptest.c:623:12: */ + bp := tls.Alloc(16) + defer tls.Free(16) + + runSql(tls, + + ts+620 /* "UPDATE task SE..." */, libc.VaList(bp, taskId)) + if bShutdown != 0 { + runSql(tls, ts+295 /* "DELETE FROM clie..." */, libc.VaList(bp+8, iClient)) + } + return 0 +} + +// Start up a client process for iClient, if it is not already +// running. If the client is already running, then this routine +// is a no-op. +func startClient(tls *libc.TLS, iClient int32) { /* mptest.c:638:13: */ + bp := tls.Alloc(96) + defer tls.Free(96) + + runSql(tls, ts+701 /* "INSERT OR IGNORE..." */, libc.VaList(bp, iClient)) + if sqlite3.Xsqlite3_changes(tls, g.db) != 0 { + var zSys uintptr + var rc int32 + zSys = sqlite3.Xsqlite3_mprintf(tls, ts+743, /* "%s \"%s\" --client..." */ + libc.VaList(bp+8, g.argv0, g.zDbFile, iClient, g.iTrace)) + if g.bSqlTrace != 0 { + zSys = sqlite3.Xsqlite3_mprintf(tls, ts+774 /* "%z --sqltrace" */, libc.VaList(bp+40, zSys)) + } + if g.bSync != 0 { + zSys = sqlite3.Xsqlite3_mprintf(tls, ts+788 /* "%z --sync" */, libc.VaList(bp+48, zSys)) + } + if g.zVfs != 0 { + zSys = sqlite3.Xsqlite3_mprintf(tls, ts+798 /* "%z --vfs \"%s\"" */, libc.VaList(bp+56, zSys, g.zVfs)) + } + if g.iTrace >= 2 { + logMessage(tls, ts+812 /* "system('%q')" */, libc.VaList(bp+72, zSys)) + } + zSys = sqlite3.Xsqlite3_mprintf(tls, ts+825 /* "%z &" */, libc.VaList(bp+80, zSys)) + rc = libc.Xsystem(tls, zSys) + if rc != 0 { + errorMessage(tls, ts+830 /* "system() fails w..." */, libc.VaList(bp+88, rc)) + } + sqlite3.Xsqlite3_free(tls, zSys) + } +} + +// Read the entire content of a file into memory +func readFile(tls *libc.TLS, zFilename uintptr) uintptr { /* mptest.c:684:13: */ + bp := tls.Alloc(8) + defer tls.Free(8) + + var in uintptr = libc.Xfopen64(tls, zFilename, ts+864 /* "rb" */) + var sz int64 + var z uintptr + if in == uintptr(0) { + fatalError(tls, ts+867 /* "cannot open \"%s\"..." */, libc.VaList(bp, zFilename)) + } + libc.Xfseek(tls, in, int64(0), 2) + sz = libc.Xftell(tls, in) + libc.Xrewind(tls, in) + z = sqlite3.Xsqlite3_malloc(tls, (int32(sz + int64(1)))) + sz = int64(libc.Xfread(tls, z, uint64(1), uint64(sz), in)) + *(*int8)(unsafe.Pointer(z + uintptr(sz))) = int8(0) + libc.Xfclose(tls, in) + return z +} + +// Return the length of the next token. +func tokenLength(tls *libc.TLS, z uintptr, pnLine uintptr) int32 { /* mptest.c:704:12: */ + var n int32 = 0 + if ((int32(*(*uint16)(unsafe.Pointer((*(*uintptr)(unsafe.Pointer(libc.X__ctype_b_loc(tls)))) + uintptr(int32(uint8(*(*int8)(unsafe.Pointer(z + uintptr(0))))))*2))) & int32(_ISspace)) != 0) || ((int32(*(*int8)(unsafe.Pointer(z + uintptr(0)))) == '/') && (int32(*(*int8)(unsafe.Pointer(z + uintptr(1)))) == '*')) { + var inC int32 = 0 + var c int32 + if int32(*(*int8)(unsafe.Pointer(z + uintptr(0)))) == '/' { + inC = 1 + n = 2 + } + for (libc.AssignInt32(&c, int32(*(*int8)(unsafe.Pointer(z + uintptr(libc.PostIncInt32(&n, 1))))))) != 0 { + if c == '\n' { + (*(*int32)(unsafe.Pointer(pnLine)))++ + } + if (int32(*(*uint16)(unsafe.Pointer((*(*uintptr)(unsafe.Pointer(libc.X__ctype_b_loc(tls)))) + uintptr(int32(uint8(c)))*2))) & int32(_ISspace)) != 0 { + continue + } + if ((inC != 0) && (c == '*')) && (int32(*(*int8)(unsafe.Pointer(z + uintptr(n)))) == '/') { + n++ + inC = 0 + } else if (!(inC != 0) && (c == '/')) && (int32(*(*int8)(unsafe.Pointer(z + uintptr(n)))) == '*') { + n++ + inC = 1 + } else if !(inC != 0) { + break + } + } + n-- + } else if (int32(*(*int8)(unsafe.Pointer(z + uintptr(0)))) == '-') && (int32(*(*int8)(unsafe.Pointer(z + uintptr(1)))) == '-') { + for n = 2; (*(*int8)(unsafe.Pointer(z + uintptr(n))) != 0) && (int32(*(*int8)(unsafe.Pointer(z + uintptr(n)))) != '\n'); n++ { + } + if *(*int8)(unsafe.Pointer(z + uintptr(n))) != 0 { + (*(*int32)(unsafe.Pointer(pnLine)))++ + n++ + } + } else if (int32(*(*int8)(unsafe.Pointer(z + uintptr(0)))) == '"') || (int32(*(*int8)(unsafe.Pointer(z + uintptr(0)))) == '\'') { + var delim int32 = int32(*(*int8)(unsafe.Pointer(z + uintptr(0)))) + for n = 1; *(*int8)(unsafe.Pointer(z + uintptr(n))) != 0; n++ { + if int32(*(*int8)(unsafe.Pointer(z + uintptr(n)))) == '\n' { + (*(*int32)(unsafe.Pointer(pnLine)))++ + } + if int32(*(*int8)(unsafe.Pointer(z + uintptr(n)))) == delim { + n++ + if int32(*(*int8)(unsafe.Pointer(z + uintptr((n + 1))))) != delim { + break + } + } + } + } else { + var c int32 + for n = 1; (((((libc.AssignInt32(&c, int32(*(*int8)(unsafe.Pointer(z + uintptr(n)))))) != 0) && !((int32(*(*uint16)(unsafe.Pointer((*(*uintptr)(unsafe.Pointer(libc.X__ctype_b_loc(tls)))) + uintptr(int32(uint8(c)))*2))) & int32(_ISspace)) != 0)) && (c != '"')) && (c != '\'')) && (c != ';'); n++ { + } + } + return n +} + +// Copy a single token into a string buffer. +func extractToken(tls *libc.TLS, zIn uintptr, nIn int32, zOut uintptr, nOut int32) int32 { /* mptest.c:749:12: */ + var i int32 + if nIn <= 0 { + *(*int8)(unsafe.Pointer(zOut + uintptr(0))) = int8(0) + return 0 + } + for i = 0; ((i < nIn) && (i < (nOut - 1))) && !((int32(*(*uint16)(unsafe.Pointer((*(*uintptr)(unsafe.Pointer(libc.X__ctype_b_loc(tls)))) + uintptr(int32(uint8(*(*int8)(unsafe.Pointer(zIn + uintptr(i))))))*2))) & int32(_ISspace)) != 0); i++ { + *(*int8)(unsafe.Pointer(zOut + uintptr(i))) = *(*int8)(unsafe.Pointer(zIn + uintptr(i))) + } + *(*int8)(unsafe.Pointer(zOut + uintptr(i))) = int8(0) + return i +} + +// Find the number of characters up to the start of the next "--end" token. +func findEnd(tls *libc.TLS, z uintptr, pnLine uintptr) int32 { /* mptest.c:763:12: */ + var n int32 = 0 + for (*(*int8)(unsafe.Pointer(z + uintptr(n))) != 0) && ((libc.Xstrncmp(tls, (z+uintptr(n)), ts+896 /* "--end" */, uint64(5)) != 0) || !((int32(*(*uint16)(unsafe.Pointer((*(*uintptr)(unsafe.Pointer(libc.X__ctype_b_loc(tls)))) + uintptr(int32(uint8(*(*int8)(unsafe.Pointer(z + uintptr((n + 5)))))))*2))) & int32(_ISspace)) != 0)) { + n = n + (tokenLength(tls, (z + uintptr(n)), pnLine)) + } + return n +} + +// Find the number of characters up to the first character past the +// of the next "--endif" or "--else" token. Nested --if commands are +// also skipped. +func findEndif(tls *libc.TLS, z uintptr, stopAtElse int32, pnLine uintptr) int32 { /* mptest.c:776:12: */ + var n int32 = 0 + for *(*int8)(unsafe.Pointer(z + uintptr(n))) != 0 { + var len int32 = tokenLength(tls, (z + uintptr(n)), pnLine) + if ((libc.Xstrncmp(tls, (z+uintptr(n)), ts+902 /* "--endif" */, uint64(7)) == 0) && ((int32(*(*uint16)(unsafe.Pointer((*(*uintptr)(unsafe.Pointer(libc.X__ctype_b_loc(tls)))) + uintptr(int32(uint8(*(*int8)(unsafe.Pointer(z + uintptr((n + 7)))))))*2))) & int32(_ISspace)) != 0)) || + (((stopAtElse != 0) && (libc.Xstrncmp(tls, (z+uintptr(n)), ts+910 /* "--else" */, uint64(6)) == 0)) && ((int32(*(*uint16)(unsafe.Pointer((*(*uintptr)(unsafe.Pointer(libc.X__ctype_b_loc(tls)))) + uintptr(int32(uint8(*(*int8)(unsafe.Pointer(z + uintptr((n + 6)))))))*2))) & int32(_ISspace)) != 0)) { + return (n + len) + } + if (libc.Xstrncmp(tls, (z+uintptr(n)), ts+917 /* "--if" */, uint64(4)) == 0) && ((int32(*(*uint16)(unsafe.Pointer((*(*uintptr)(unsafe.Pointer(libc.X__ctype_b_loc(tls)))) + uintptr(int32(uint8(*(*int8)(unsafe.Pointer(z + uintptr((n + 4)))))))*2))) & int32(_ISspace)) != 0) { + var skip int32 = findEndif(tls, ((z + uintptr(n)) + uintptr(len)), 0, pnLine) + n = n + (skip + len) + } else { + n = n + (len) + } + } + return n +} + +// Wait for a client process to complete all its tasks +func waitForClient(tls *libc.TLS, iClient int32, iTimeout int32, zErrPrefix uintptr) { /* mptest.c:798:13: */ + bp := tls.Alloc(32) + defer tls.Free(32) + + var pStmt uintptr + var rc int32 + if iClient > 0 { + pStmt = prepareSql(tls, + + ts+922, /* "SELECT 1 FROM ta..." */ + libc.VaList(bp, iClient)) + } else { + pStmt = prepareSql(tls, + + ts+1018 /* "SELECT 1 FROM ta..." */, 0) + } + g.iTimeout = 0 + for (((libc.AssignInt32(&rc, sqlite3.Xsqlite3_step(tls, pStmt))) == 5) || (rc == 100)) && + (iTimeout > 0) { + sqlite3.Xsqlite3_reset(tls, pStmt) + sqlite3.Xsqlite3_sleep(tls, 50) + iTimeout = iTimeout - (50) + } + sqlite3.Xsqlite3_finalize(tls, pStmt) + g.iTimeout = 10000 + if rc != 101 { + if zErrPrefix == uintptr(0) { + zErrPrefix = ts + 1099 /* "" */ + } + if iClient > 0 { + errorMessage(tls, ts+1100 /* "%stimeout waitin..." */, libc.VaList(bp+8, zErrPrefix, iClient)) + } else { + errorMessage(tls, ts+1132 /* "%stimeout waitin..." */, libc.VaList(bp+24, zErrPrefix)) + } + } +} + +// Return a pointer to the tail of a filename +func filenameTail(tls *libc.TLS, z uintptr) uintptr { /* mptest.c:836:13: */ + var i int32 + var j int32 + for i = libc.AssignInt32(&j, 0); *(*int8)(unsafe.Pointer(z + uintptr(i))) != 0; i++ { + if (int32(*(*int8)(unsafe.Pointer(z + uintptr(i))))) == '/' { + j = (i + 1) + } + } + return (z + uintptr(j)) +} + +// Interpret zArg as a boolean value. Return either 0 or 1. +func booleanValue(tls *libc.TLS, zArg uintptr) int32 { /* mptest.c:845:12: */ + bp := tls.Alloc(8) + defer tls.Free(8) + + var i int32 + if zArg == uintptr(0) { + return 0 + } + for i = 0; (int32(*(*int8)(unsafe.Pointer(zArg + uintptr(i)))) >= '0') && (int32(*(*int8)(unsafe.Pointer(zArg + uintptr(i)))) <= '9'); i++ { + } + if (i > 0) && (int32(*(*int8)(unsafe.Pointer(zArg + uintptr(i)))) == 0) { + return libc.Xatoi(tls, zArg) + } + if (sqlite3.Xsqlite3_stricmp(tls, zArg, ts+1166 /* "on" */) == 0) || (sqlite3.Xsqlite3_stricmp(tls, zArg, ts+1169 /* "yes" */) == 0) { + return 1 + } + if (sqlite3.Xsqlite3_stricmp(tls, zArg, ts+1173 /* "off" */) == 0) || (sqlite3.Xsqlite3_stricmp(tls, zArg, ts+1177 /* "no" */) == 0) { + return 0 + } + errorMessage(tls, ts+1180 /* "unknown boolean:..." */, libc.VaList(bp, zArg)) + return 0 +} + +// This routine exists as a convenient place to set a debugger +// breakpoint. +func test_breakpoint(tls *libc.TLS) { /* mptest.c:864:13: */ cnt++ } + +var cnt int32 = 0 /* mptest.c:864:56 */ + +// Maximum number of arguments to a --command + +// Run a script. +func runScript(tls *libc.TLS, iClient int32, taskId int32, zScript uintptr, zFilename uintptr) { /* mptest.c:872:13: */ + bp := tls.Alloc(1610) + defer tls.Free(1610) + + *(*int32)(unsafe.Pointer(bp + 376 /* lineno */)) = 1 + var prevLine int32 = 1 + var ii int32 = 0 + var iBegin int32 = 0 + var n int32 + var c int32 + var j int32 + var len int32 + var nArg int32 + // var sResult String at bp+360, 16 + + // var zCmd [30]int8 at bp+380, 30 + + // var zError [1000]int8 at bp+610, 1000 + + // var azArg [2][100]int8 at bp+410, 200 + + libc.Xmemset(tls, bp+360 /* &sResult */, 0, uint64(unsafe.Sizeof(String{}))) + stringReset(tls, bp+360 /* &sResult */) + for (libc.AssignInt32(&c, int32(*(*int8)(unsafe.Pointer(zScript + uintptr(ii)))))) != 0 { + prevLine = *(*int32)(unsafe.Pointer(bp + 376 /* lineno */)) + len = tokenLength(tls, (zScript + uintptr(ii)), bp+376 /* &lineno */) + if ((int32(*(*uint16)(unsafe.Pointer((*(*uintptr)(unsafe.Pointer(libc.X__ctype_b_loc(tls)))) + uintptr(int32(uint8(c)))*2))) & int32(_ISspace)) != 0) || ((c == '/') && (int32(*(*int8)(unsafe.Pointer(zScript + uintptr((ii + 1))))) == '*')) { + ii = ii + (len) + continue + } + if ((c != '-') || (int32(*(*int8)(unsafe.Pointer(zScript + uintptr((ii + 1))))) != '-')) || !((int32(*(*uint16)(unsafe.Pointer((*(*uintptr)(unsafe.Pointer(libc.X__ctype_b_loc(tls)))) + uintptr(int32(*(*int8)(unsafe.Pointer(zScript + uintptr((ii + 2))))))*2))) & int32(_ISalpha)) != 0) { + ii = ii + (len) + continue + } + + // Run any prior SQL before processing the new --command + if ii > iBegin { + var zSql uintptr = sqlite3.Xsqlite3_mprintf(tls, ts+1202 /* "%.*s" */, libc.VaList(bp, (ii-iBegin), (zScript+uintptr(iBegin)))) + evalSql(tls, bp+360 /* &sResult */, zSql, 0) + sqlite3.Xsqlite3_free(tls, zSql) + iBegin = (ii + len) + } + + // Parse the --command + if g.iTrace >= 2 { + logMessage(tls, ts+1202 /* "%.*s" */, libc.VaList(bp+16, len, (zScript+uintptr(ii)))) + } + n = extractToken(tls, ((zScript + uintptr(ii)) + uintptr(2)), (len - 2), bp+380 /* &zCmd[0] */, int32(unsafe.Sizeof([30]int8{}))) + for nArg = 0; (n < (len - 2)) && (nArg < 2); nArg++ { + for (n < (len - 2)) && ((int32(*(*uint16)(unsafe.Pointer((*(*uintptr)(unsafe.Pointer(libc.X__ctype_b_loc(tls)))) + uintptr(int32(uint8(*(*int8)(unsafe.Pointer(zScript + uintptr(((ii + 2) + n)))))))*2))) & int32(_ISspace)) != 0) { + n++ + } + if n >= (len - 2) { + break + } + n = n + (extractToken(tls, (((zScript + uintptr(ii)) + uintptr(2)) + uintptr(n)), ((len - 2) - n), + (bp + 410 /* &azArg[0] */ + uintptr(nArg)*100), int32(unsafe.Sizeof([100]int8{})))) + } + for j = nArg; j < 2; j++ { + *(*int8)(unsafe.Pointer((bp + 410 /* &azArg[0] */ + uintptr(libc.PostIncInt32(&j, 1))*100) + uintptr(0))) = int8(0) + } + + // --sleep N + // + // Pause for N milliseconds + if libc.Xstrcmp(tls, bp+380 /* &zCmd[0] */, ts+1207 /* "sleep" */) == 0 { + sqlite3.Xsqlite3_sleep(tls, libc.Xatoi(tls, (bp+410 /* &azArg[0] */ +uintptr(0)*100))) + } else + + // --exit N + // + // Exit this process. If N>0 then exit without shutting down + // SQLite. (In other words, simulate a crash.) + if libc.Xstrcmp(tls, bp+380 /* &zCmd[0] */, ts+1213 /* "exit" */) == 0 { + var rc int32 = libc.Xatoi(tls, (bp + 410 /* &azArg[0] */ + uintptr(0)*100)) + finishScript(tls, iClient, taskId, 1) + if rc == 0 { + sqlite3.Xsqlite3_close(tls, g.db) + } + libc.Xexit(tls, rc) + } else + + // --testcase NAME + // + // Begin a new test case. Announce in the log that the test case + // has begun. + if libc.Xstrcmp(tls, bp+380 /* &zCmd[0] */, ts+1218 /* "testcase" */) == 0 { + if g.iTrace == 1 { + logMessage(tls, ts+1202 /* "%.*s" */, libc.VaList(bp+32, (len-1), (zScript+uintptr(ii)))) + } + stringReset(tls, bp+360 /* &sResult */) + } else + + // --finish + // + // Mark the current task as having finished, even if it is not. + // This can be used in conjunction with --exit to simulate a crash. + if (libc.Xstrcmp(tls, bp+380 /* &zCmd[0] */, ts+1227 /* "finish" */) == 0) && (iClient > 0) { + finishScript(tls, iClient, taskId, 1) + } else + + // --reset + // + // Reset accumulated results back to an empty string + if libc.Xstrcmp(tls, bp+380 /* &zCmd[0] */, ts+1234 /* "reset" */) == 0 { + stringReset(tls, bp+360 /* &sResult */) + } else + + // --match ANSWER... + // + // Check to see if output matches ANSWER. Report an error if not. + if libc.Xstrcmp(tls, bp+380 /* &zCmd[0] */, ts+1240 /* "match" */) == 0 { + var jj int32 + var zAns uintptr = (zScript + uintptr(ii)) + for jj = 7; (jj < (len - 1)) && ((int32(*(*uint16)(unsafe.Pointer((*(*uintptr)(unsafe.Pointer(libc.X__ctype_b_loc(tls)))) + uintptr(int32(uint8(*(*int8)(unsafe.Pointer(zAns + uintptr(jj))))))*2))) & int32(_ISspace)) != 0); jj++ { + } + zAns += uintptr(jj) + if (((len - jj) - 1) != (*String)(unsafe.Pointer(bp+360 /* &sResult */)).n) || (libc.Xstrncmp(tls, (*String)(unsafe.Pointer(bp+360 /* &sResult */)).z, zAns, (uint64((len-jj)-1))) != 0) { + errorMessage(tls, ts+1246, /* "line %d of %s:\nE..." */ + libc.VaList(bp+48, prevLine, zFilename, ((len-jj)-1), zAns, (*String)(unsafe.Pointer(bp+360 /* &sResult */)).z)) + } + g.nTest++ + stringReset(tls, bp+360 /* &sResult */) + } else + + // --glob ANSWER... + // --notglob ANSWER.... + // + // Check to see if output does or does not match the glob pattern + // ANSWER. + if (libc.Xstrcmp(tls, bp+380 /* &zCmd[0] */, ts+1291 /* "glob" */) == 0) || (libc.Xstrcmp(tls, bp+380 /* &zCmd[0] */, ts+1296 /* "notglob" */) == 0) { + var jj int32 + var zAns uintptr = (zScript + uintptr(ii)) + var zCopy uintptr + var isGlob int32 = (libc.Bool32(int32(*(*int8)(unsafe.Pointer(bp + 380 /* &zCmd[0] */ + uintptr(0)))) == 'g')) + for jj = (9 - (3 * isGlob)); (jj < (len - 1)) && ((int32(*(*uint16)(unsafe.Pointer((*(*uintptr)(unsafe.Pointer(libc.X__ctype_b_loc(tls)))) + uintptr(int32(uint8(*(*int8)(unsafe.Pointer(zAns + uintptr(jj))))))*2))) & int32(_ISspace)) != 0); jj++ { + } + zAns += uintptr(jj) + zCopy = sqlite3.Xsqlite3_mprintf(tls, ts+1202 /* "%.*s" */, libc.VaList(bp+88, ((len-jj)-1), zAns)) + if ((libc.Bool32(sqlite3.Xsqlite3_strglob(tls, zCopy, (*String)(unsafe.Pointer(bp+360 /* &sResult */)).z) == 0)) ^ isGlob) != 0 { + errorMessage(tls, ts+1304, /* "line %d of %s:\nE..." */ + libc.VaList(bp+104, prevLine, zFilename, zCopy, (*String)(unsafe.Pointer(bp+360 /* &sResult */)).z)) + } + sqlite3.Xsqlite3_free(tls, zCopy) + g.nTest++ + stringReset(tls, bp+360 /* &sResult */) + } else + + // --output + // + // Output the result of the previous SQL. + if libc.Xstrcmp(tls, bp+380 /* &zCmd[0] */, ts+1347 /* "output" */) == 0 { + logMessage(tls, ts+438 /* "%s" */, libc.VaList(bp+136, (*String)(unsafe.Pointer(bp+360 /* &sResult */)).z)) + } else + + // --source FILENAME + // + // Run a subscript from a separate file. + if libc.Xstrcmp(tls, bp+380 /* &zCmd[0] */, ts+1354 /* "source" */) == 0 { + var zNewFile uintptr + var zNewScript uintptr + var zToDel uintptr = uintptr(0) + zNewFile = (bp + 410 /* &azArg[0] */ + uintptr(0)*100) + if !((int32(*(*int8)(unsafe.Pointer(zNewFile + uintptr(0))))) == '/') { + var k int32 + for k = (int32(libc.Xstrlen(tls, zFilename)) - 1); (k >= 0) && !((int32(*(*int8)(unsafe.Pointer(zFilename + uintptr(k))))) == '/'); k-- { + } + if k > 0 { + zNewFile = libc.AssignUintptr(&zToDel, sqlite3.Xsqlite3_mprintf(tls, ts+1361 /* "%.*s/%s" */, libc.VaList(bp+144, k, zFilename, zNewFile))) + } + } + zNewScript = readFile(tls, zNewFile) + if g.iTrace != 0 { + logMessage(tls, ts+1369 /* "begin script [%s..." */, libc.VaList(bp+168, zNewFile)) + } + runScript(tls, 0, 0, zNewScript, zNewFile) + sqlite3.Xsqlite3_free(tls, zNewScript) + if g.iTrace != 0 { + logMessage(tls, ts+1388 /* "end script [%s]\n" */, libc.VaList(bp+176, zNewFile)) + } + sqlite3.Xsqlite3_free(tls, zToDel) + } else + + // --print MESSAGE.... + // + // Output the remainder of the line to the log file + if libc.Xstrcmp(tls, bp+380 /* &zCmd[0] */, ts+1405 /* "print" */) == 0 { + var jj int32 + for jj = 7; (jj < len) && ((int32(*(*uint16)(unsafe.Pointer((*(*uintptr)(unsafe.Pointer(libc.X__ctype_b_loc(tls)))) + uintptr(int32(uint8(*(*int8)(unsafe.Pointer(zScript + uintptr((ii + jj)))))))*2))) & int32(_ISspace)) != 0); jj++ { + } + logMessage(tls, ts+1202 /* "%.*s" */, libc.VaList(bp+184, (len-jj), ((zScript+uintptr(ii))+uintptr(jj)))) + } else + + // --if EXPR + // + // Skip forward to the next matching --endif or --else if EXPR is false. + if libc.Xstrcmp(tls, bp+380 /* &zCmd[0] */, ts+1411 /* "if" */) == 0 { + var jj int32 + var rc int32 + var pStmt uintptr + for jj = 4; (jj < len) && ((int32(*(*uint16)(unsafe.Pointer((*(*uintptr)(unsafe.Pointer(libc.X__ctype_b_loc(tls)))) + uintptr(int32(uint8(*(*int8)(unsafe.Pointer(zScript + uintptr((ii + jj)))))))*2))) & int32(_ISspace)) != 0); jj++ { + } + pStmt = prepareSql(tls, ts+1414 /* "SELECT %.*s" */, libc.VaList(bp+200, (len-jj), ((zScript+uintptr(ii))+uintptr(jj)))) + rc = sqlite3.Xsqlite3_step(tls, pStmt) + if (rc != 100) || (sqlite3.Xsqlite3_column_int(tls, pStmt, 0) == 0) { + ii = ii + (findEndif(tls, ((zScript + uintptr(ii)) + uintptr(len)), 1, bp+376 /* &lineno */)) + } + sqlite3.Xsqlite3_finalize(tls, pStmt) + } else + + // --else + // + // This command can only be encountered if currently inside an --if that + // is true. Skip forward to the next matching --endif. + if libc.Xstrcmp(tls, bp+380 /* &zCmd[0] */, ts+1426 /* "else" */) == 0 { + ii = ii + (findEndif(tls, ((zScript + uintptr(ii)) + uintptr(len)), 0, bp+376 /* &lineno */)) + } else + + // --endif + // + // This command can only be encountered if currently inside an --if that + // is true or an --else of a false if. This is a no-op. + if libc.Xstrcmp(tls, bp+380 /* &zCmd[0] */, ts+1431 /* "endif" */) == 0 { + } else + + // --start CLIENT + // + // Start up the given client. + if (libc.Xstrcmp(tls, bp+380 /* &zCmd[0] */, ts+1437 /* "start" */) == 0) && (iClient == 0) { + var iNewClient int32 = libc.Xatoi(tls, (bp + 410 /* &azArg[0] */ + uintptr(0)*100)) + if iNewClient > 0 { + startClient(tls, iNewClient) + } + } else + + // --wait CLIENT TIMEOUT + // + // Wait until all tasks complete for the given client. If CLIENT is + // "all" then wait for all clients to complete. Wait no longer than + // TIMEOUT milliseconds (default 10,000) + if (libc.Xstrcmp(tls, bp+380 /* &zCmd[0] */, ts+1443 /* "wait" */) == 0) && (iClient == 0) { + var iTimeout int32 + if nArg >= 2 { + iTimeout = libc.Xatoi(tls, (bp + 410 /* &azArg[0] */ + uintptr(1)*100)) + } else { + iTimeout = 10000 + } + sqlite3.Xsqlite3_snprintf(tls, int32(unsafe.Sizeof([1000]int8{})), bp+610 /* &zError[0] */, ts+1448, /* "line %d of %s\n" */ + libc.VaList(bp+216, prevLine, zFilename)) + waitForClient(tls, libc.Xatoi(tls, (bp+410 /* &azArg[0] */ +uintptr(0)*100)), iTimeout, bp+610 /* &zError[0] */) + } else + + // --task CLIENT + // <task-content-here> + // --end + // + // Assign work to a client. Start the client if it is not running + // already. + if (libc.Xstrcmp(tls, bp+380 /* &zCmd[0] */, ts+1463 /* "task" */) == 0) && (iClient == 0) { + var iTarget int32 = libc.Xatoi(tls, (bp + 410 /* &azArg[0] */ + uintptr(0)*100)) + var iEnd int32 + var zTask uintptr + var zTName uintptr + iEnd = findEnd(tls, ((zScript + uintptr(ii)) + uintptr(len)), bp+376 /* &lineno */) + if iTarget < 0 { + errorMessage(tls, ts+1468, /* "line %d of %s: b..." */ + libc.VaList(bp+232, prevLine, zFilename, iTarget)) + } else { + zTask = sqlite3.Xsqlite3_mprintf(tls, ts+1202 /* "%.*s" */, libc.VaList(bp+256, iEnd, ((zScript+uintptr(ii))+uintptr(len)))) + if nArg > 1 { + zTName = sqlite3.Xsqlite3_mprintf(tls, ts+438 /* "%s" */, libc.VaList(bp+272, (bp+410 /* &azArg[0] */ +uintptr(1)*100))) + } else { + zTName = sqlite3.Xsqlite3_mprintf(tls, ts+1505 /* "%s:%d" */, libc.VaList(bp+280, filenameTail(tls, zFilename), prevLine)) + } + startClient(tls, iTarget) + runSql(tls, + ts+1511 /* "INSERT INTO task..." */, libc.VaList(bp+296, iTarget, zTask, zTName)) + sqlite3.Xsqlite3_free(tls, zTask) + sqlite3.Xsqlite3_free(tls, zTName) + } + iEnd = iEnd + (tokenLength(tls, (((zScript + uintptr(ii)) + uintptr(len)) + uintptr(iEnd)), bp+376 /* &lineno */)) + len = len + (iEnd) + iBegin = (ii + len) + } else + + // --breakpoint + // + // This command calls "test_breakpoint()" which is a routine provided + // as a convenient place to set a debugger breakpoint. + if libc.Xstrcmp(tls, bp+380 /* &zCmd[0] */, ts+1567 /* "breakpoint" */) == 0 { + test_breakpoint(tls) + } else + + // --show-sql-errors BOOLEAN + // + // Turn display of SQL errors on and off. + if libc.Xstrcmp(tls, bp+380 /* &zCmd[0] */, ts+1578 /* "show-sql-errors" */) == 0 { + g.bIgnoreSqlErrors = func() int32 { + if nArg >= 1 { + return libc.BoolInt32(!(booleanValue(tls, (bp+410 /* &azArg[0] */ +uintptr(0)*100)) != 0)) + } + return 1 + }() + } else { + errorMessage(tls, ts+1594, /* "line %d of %s: u..." */ + libc.VaList(bp+320, prevLine, zFilename, bp+380 /* &zCmd[0] */)) + } + ii = ii + (len) + } + if iBegin < ii { + var zSql uintptr = sqlite3.Xsqlite3_mprintf(tls, ts+1202 /* "%.*s" */, libc.VaList(bp+344, (ii-iBegin), (zScript+uintptr(iBegin)))) + runSql(tls, zSql, 0) + sqlite3.Xsqlite3_free(tls, zSql) + } + stringFree(tls, bp+360 /* &sResult */) +} + +// Look for a command-line option. If present, return a pointer. +// Return NULL if missing. +// +// hasArg==0 means the option is a flag. It is either present or not. +// hasArg==1 means the option has an argument. Return a pointer to the +// argument. +func findOption(tls *libc.TLS, azArg uintptr, pnArg uintptr, zOption uintptr, hasArg int32) uintptr { /* mptest.c:1201:13: */ + bp := tls.Alloc(8) + defer tls.Free(8) + + var i int32 + var j int32 + var zReturn uintptr = uintptr(0) + var nArg int32 = *(*int32)(unsafe.Pointer(pnArg)) + + for i = 0; i < nArg; i++ { + var z uintptr + if (i + hasArg) >= nArg { + break + } + z = *(*uintptr)(unsafe.Pointer(azArg + uintptr(i)*8)) + if int32(*(*int8)(unsafe.Pointer(z + uintptr(0)))) != '-' { + continue + } + z++ + if int32(*(*int8)(unsafe.Pointer(z + uintptr(0)))) == '-' { + if int32(*(*int8)(unsafe.Pointer(z + uintptr(1)))) == 0 { + break + } + z++ + } + if libc.Xstrcmp(tls, z, zOption) == 0 { + if (hasArg != 0) && (i == (nArg - 1)) { + fatalError(tls, ts+1630 /* "command-line opt..." */, libc.VaList(bp, z)) + } + if hasArg != 0 { + zReturn = *(*uintptr)(unsafe.Pointer(azArg + uintptr((i+1))*8)) + } else { + zReturn = *(*uintptr)(unsafe.Pointer(azArg + uintptr(i)*8)) + } + j = ((i + 1) + (libc.Bool32(hasArg != 0))) + for j < nArg { + *(*uintptr)(unsafe.Pointer(azArg + uintptr(libc.PostIncInt32(&i, 1))*8)) = *(*uintptr)(unsafe.Pointer(azArg + uintptr(libc.PostIncInt32(&j, 1))*8)) + } + *(*int32)(unsafe.Pointer(pnArg)) = i + return zReturn + } + } + return zReturn +} + +// Print a usage message for the program and exit +func usage(tls *libc.TLS, argv0 uintptr) { /* mptest.c:1241:13: */ + bp := tls.Alloc(8) + defer tls.Free(8) + + var i int32 + var zTail uintptr = argv0 + for i = 0; *(*int8)(unsafe.Pointer(argv0 + uintptr(i))) != 0; i++ { + if (int32(*(*int8)(unsafe.Pointer(argv0 + uintptr(i))))) == '/' { + zTail = ((argv0 + uintptr(i)) + uintptr(1)) + } + } + libc.Xfprintf(tls, libc.Xstderr, ts+1678 /* "Usage: %s DATABA..." */, libc.VaList(bp, zTail)) + libc.Xfprintf(tls, libc.Xstderr, + + ts+1717 /* "Options:\n --er..." */, 0) + libc.Xexit(tls, 1) +} + +// Report on unrecognized arguments +func unrecognizedArguments(tls *libc.TLS, argv0 uintptr, nArg int32, azArg uintptr) { /* mptest.c:1265:13: */ + bp := tls.Alloc(16) + defer tls.Free(16) + + var i int32 + libc.Xfprintf(tls, libc.Xstderr, ts+2289 /* "%s: unrecognized..." */, libc.VaList(bp, argv0)) + for i = 0; i < nArg; i++ { + libc.Xfprintf(tls, libc.Xstderr, ts+2317 /* " %s" */, libc.VaList(bp+8, *(*uintptr)(unsafe.Pointer(azArg + uintptr(i)*8)))) + } + libc.Xfprintf(tls, libc.Xstderr, ts+2321 /* "\n" */, 0) + libc.Xexit(tls, 1) +} + +func main1(tls *libc.TLS, argc int32, argv uintptr) int32 { /* mptest.c:1279:18: */ + bp := tls.Alloc(264) + defer tls.Free(264) + + var zClient uintptr + var iClient int32 + // var n int32 at bp+232, 4 + + var i int32 + var openFlags int32 = 0x00000002 + var rc int32 + // var zScript uintptr at bp+240, 8 + + // var taskId int32 at bp+248, 4 + + var zTrace uintptr + var zCOption uintptr + var zJMode uintptr + var zNRep uintptr + var nRep int32 = 1 + var iRep int32 + var iTmout int32 = 0 // Default: no timeout + var zTmout uintptr + + g.argv0 = *(*uintptr)(unsafe.Pointer(argv + uintptr(0)*8)) + g.iTrace = 1 + if argc < 2 { + usage(tls, *(*uintptr)(unsafe.Pointer(argv + uintptr(0)*8))) + } + g.zDbFile = *(*uintptr)(unsafe.Pointer(argv + uintptr(1)*8)) + if strglob(tls, ts+2323 /* "*.test" */, g.zDbFile) != 0 { + usage(tls, *(*uintptr)(unsafe.Pointer(argv + uintptr(0)*8))) + } + if libc.Xstrcmp(tls, sqlite3.Xsqlite3_sourceid(tls), ts+2330 /* "2020-08-14 13:23..." */) != 0 { + libc.Xfprintf(tls, libc.Xstderr, + + ts+2415, /* "SQLite library a..." */ + libc.VaList(bp, sqlite3.Xsqlite3_sourceid(tls), ts+2330 /* "2020-08-14 13:23..." */)) + libc.Xexit(tls, 1) + } + *(*int32)(unsafe.Pointer(bp + 232 /* n */)) = (argc - 2) + sqlite3.Xsqlite3_snprintf(tls, int32(unsafe.Sizeof([32]int8{})), uintptr(unsafe.Pointer(&g))+64 /* &.zName */, ts+2475 /* "%05d.mptest" */, libc.VaList(bp+16, libc.Xgetpid(tls))) + zJMode = findOption(tls, (argv + uintptr(2)*8), bp+232 /* &n */, ts+2487 /* "journalmode" */, 1) + zNRep = findOption(tls, (argv + uintptr(2)*8), bp+232 /* &n */, ts+2499 /* "repeat" */, 1) + if zNRep != 0 { + nRep = libc.Xatoi(tls, zNRep) + } + if nRep < 1 { + nRep = 1 + } + g.zVfs = findOption(tls, (argv + uintptr(2)*8), bp+232 /* &n */, ts+2506 /* "vfs" */, 1) + zClient = findOption(tls, (argv + uintptr(2)*8), bp+232 /* &n */, ts+2510 /* "client" */, 1) + g.zErrLog = findOption(tls, (argv + uintptr(2)*8), bp+232 /* &n */, ts+2517 /* "errlog" */, 1) + g.zLog = findOption(tls, (argv + uintptr(2)*8), bp+232 /* &n */, ts+2524 /* "log" */, 1) + zTrace = findOption(tls, (argv + uintptr(2)*8), bp+232 /* &n */, ts+2528 /* "trace" */, 1) + if zTrace != 0 { + g.iTrace = libc.Xatoi(tls, zTrace) + } + if findOption(tls, (argv+uintptr(2)*8), bp+232 /* &n */, ts+2534 /* "quiet" */, 0) != uintptr(0) { + g.iTrace = 0 + } + zTmout = findOption(tls, (argv + uintptr(2)*8), bp+232 /* &n */, ts+2540 /* "timeout" */, 1) + if zTmout != 0 { + iTmout = libc.Xatoi(tls, zTmout) + } + g.bSqlTrace = (libc.Bool32(findOption(tls, (argv+uintptr(2)*8), bp+232 /* &n */, ts+2548 /* "sqltrace" */, 0) != uintptr(0))) + g.bSync = (libc.Bool32(findOption(tls, (argv+uintptr(2)*8), bp+232 /* &n */, ts+2557 /* "sync" */, 0) != uintptr(0))) + if g.zErrLog != 0 { + g.pErrLog = libc.Xfopen64(tls, g.zErrLog, ts+2562 /* "a" */) + } else { + g.pErrLog = libc.Xstderr + } + if g.zLog != 0 { + g.pLog = libc.Xfopen64(tls, g.zLog, ts+2562 /* "a" */) + } else { + g.pLog = libc.Xstdout + } + + sqlite3.Xsqlite3_config(tls, 16, libc.VaList(bp+24, *(*uintptr)(unsafe.Pointer(&struct { + f func(*libc.TLS, uintptr, int32, uintptr) + }{sqlErrorCallback})), 0)) + if zClient != 0 { + iClient = libc.Xatoi(tls, zClient) + if iClient < 1 { + fatalError(tls, ts+2564 /* "illegal client n..." */, libc.VaList(bp+40, iClient)) + } + sqlite3.Xsqlite3_snprintf(tls, int32(unsafe.Sizeof([32]int8{})), uintptr(unsafe.Pointer(&g))+64 /* &.zName */, ts+2591, /* "%05d.client%02d" */ + libc.VaList(bp+48, libc.Xgetpid(tls), iClient)) + } else { + var nTry int32 = 0 + if g.iTrace > 0 { + libc.Xprintf(tls, ts+2607 /* "BEGIN: %s" */, libc.VaList(bp+64, *(*uintptr)(unsafe.Pointer(argv + uintptr(0)*8)))) + for i = 1; i < argc; i++ { + libc.Xprintf(tls, ts+2317 /* " %s" */, libc.VaList(bp+72, *(*uintptr)(unsafe.Pointer(argv + uintptr(i)*8)))) + } + libc.Xprintf(tls, ts+2321 /* "\n" */, 0) + libc.Xprintf(tls, ts+2617 /* "With SQLite 3.33..." */, 0) + for i = 0; (libc.AssignUintptr(&zCOption, sqlite3.Xsqlite3_compileoption_get(tls, i))) != uintptr(0); i++ { + libc.Xprintf(tls, ts+2722 /* "-DSQLITE_%s\n" */, libc.VaList(bp+80, zCOption)) + } + libc.Xfflush(tls, libc.Xstdout) + } + iClient = 0 + for ok := true; ok; ok = (((rc != 0) && ((libc.PreIncInt32(&nTry, 1)) < 60)) && (sqlite3.Xsqlite3_sleep(tls, 1000) > 0)) { + if (nTry % 5) == 4 { + libc.Xprintf(tls, ts+2735, /* "... %strying to ..." */ + libc.VaList(bp+88, func() uintptr { + if nTry > 5 { + return ts + 2764 /* "still " */ + } + return ts + 1099 /* "" */ + }(), g.zDbFile)) + } + rc = libc.Xunlink(tls, g.zDbFile) + if (rc != 0) && ((*(*int32)(unsafe.Pointer(libc.X__errno_location(tls)))) == 2) { + rc = 0 + } + } + if rc != 0 { + fatalError(tls, ts+2771, /* "unable to unlink..." */ + libc.VaList(bp+104, g.zDbFile, nTry)) + } + openFlags = openFlags | (0x00000004) + } + rc = sqlite3.Xsqlite3_open_v2(tls, g.zDbFile, (uintptr(unsafe.Pointer(&g)) + 24 /* &.db */), openFlags, g.zVfs) + if rc != 0 { + fatalError(tls, ts+2812 /* "cannot open [%s]" */, libc.VaList(bp+120, g.zDbFile)) + } + if iTmout > 0 { + sqlite3.Xsqlite3_busy_timeout(tls, g.db, iTmout) + } + + if zJMode != 0 { + runSql(tls, ts+2829 /* "PRAGMA journal_m..." */, libc.VaList(bp+128, zJMode)) + } + if !(g.bSync != 0) { + trySql(tls, ts+2853 /* "PRAGMA synchrono..." */, 0) + } + sqlite3.Xsqlite3_enable_load_extension(tls, g.db, 1) + sqlite3.Xsqlite3_busy_handler(tls, g.db, *(*uintptr)(unsafe.Pointer(&struct { + f func(*libc.TLS, uintptr, int32) int32 + }{busyHandler})), uintptr(0)) + sqlite3.Xsqlite3_create_function(tls, g.db, ts+2876 /* "vfsname" */, 0, 1, uintptr(0), + *(*uintptr)(unsafe.Pointer(&struct { + f func(*libc.TLS, uintptr, int32, uintptr) + }{vfsNameFunc})), uintptr(0), uintptr(0)) + sqlite3.Xsqlite3_create_function(tls, g.db, ts+2884 /* "eval" */, 1, 1, uintptr(0), + *(*uintptr)(unsafe.Pointer(&struct { + f func(*libc.TLS, uintptr, int32, uintptr) + }{evalFunc})), uintptr(0), uintptr(0)) + g.iTimeout = 10000 + if g.bSqlTrace != 0 { + sqlite3.Xsqlite3_trace(tls, g.db, *(*uintptr)(unsafe.Pointer(&struct { + f func(*libc.TLS, uintptr, uintptr) + }{sqlTraceCallback})), uintptr(0)) + } + if iClient > 0 { + if *(*int32)(unsafe.Pointer(bp + 232 /* n */)) > 0 { + unrecognizedArguments(tls, *(*uintptr)(unsafe.Pointer(argv + uintptr(0)*8)), *(*int32)(unsafe.Pointer(bp + 232 /* n */)), (argv + uintptr(2)*8)) + } + if g.iTrace != 0 { + logMessage(tls, ts+2889 /* "start-client" */, 0) + } + for 1 != 0 { + *(*uintptr)(unsafe.Pointer(bp + 256 /* zTaskName */)) = uintptr(0) + rc = startScript(tls, iClient, bp+240 /* &zScript */, bp+248 /* &taskId */, bp+256 /* &zTaskName */) + if rc == 101 { + break + } + if g.iTrace != 0 { + logMessage(tls, ts+2902 /* "begin %s (%d)" */, libc.VaList(bp+136, *(*uintptr)(unsafe.Pointer(bp + 256 /* zTaskName */)), *(*int32)(unsafe.Pointer(bp + 248 /* taskId */)))) + } + runScript(tls, iClient, *(*int32)(unsafe.Pointer(bp + 248 /* taskId */)), *(*uintptr)(unsafe.Pointer(bp + 240 /* zScript */)), *(*uintptr)(unsafe.Pointer(bp + 256 /* zTaskName */))) + if g.iTrace != 0 { + logMessage(tls, ts+2916 /* "end %s (%d)" */, libc.VaList(bp+152, *(*uintptr)(unsafe.Pointer(bp + 256 /* zTaskName */)), *(*int32)(unsafe.Pointer(bp + 248 /* taskId */)))) + } + finishScript(tls, iClient, *(*int32)(unsafe.Pointer(bp + 248 /* taskId */)), 0) + sqlite3.Xsqlite3_free(tls, *(*uintptr)(unsafe.Pointer(bp + 256 /* zTaskName */))) + sqlite3.Xsqlite3_sleep(tls, 10) + } + if g.iTrace != 0 { + logMessage(tls, ts+2928 /* "end-client" */, 0) + } + } else { + var pStmt uintptr + var iTimeout int32 + if *(*int32)(unsafe.Pointer(bp + 232 /* n */)) == 0 { + fatalError(tls, ts+2939 /* "missing script f..." */, 0) + } + if *(*int32)(unsafe.Pointer(bp + 232 /* n */)) > 1 { + unrecognizedArguments(tls, *(*uintptr)(unsafe.Pointer(argv + uintptr(0)*8)), *(*int32)(unsafe.Pointer(bp + 232 /* n */)), (argv + uintptr(2)*8)) + } + runSql(tls, + + ts+2963 /* "DROP TABLE IF EX..." */, 0) + *(*uintptr)(unsafe.Pointer(bp + 240 /* zScript */)) = readFile(tls, *(*uintptr)(unsafe.Pointer(argv + uintptr(2)*8))) + for iRep = 1; iRep <= nRep; iRep++ { + if g.iTrace != 0 { + logMessage(tls, ts+3399 /* "begin script [%s..." */, libc.VaList(bp+168, *(*uintptr)(unsafe.Pointer(argv + uintptr(2)*8)), iRep)) + } + runScript(tls, 0, 0, *(*uintptr)(unsafe.Pointer(bp + 240 /* zScript */)), *(*uintptr)(unsafe.Pointer(argv + uintptr(2)*8))) + if g.iTrace != 0 { + logMessage(tls, ts+3427 /* "end script [%s] ..." */, libc.VaList(bp+184, *(*uintptr)(unsafe.Pointer(argv + uintptr(2)*8)), iRep)) + } + } + sqlite3.Xsqlite3_free(tls, *(*uintptr)(unsafe.Pointer(bp + 240 /* zScript */))) + waitForClient(tls, 0, 2000, ts+3453 /* "during shutdown...." */) + trySql(tls, ts+3473 /* "UPDATE client SE..." */, 0) + sqlite3.Xsqlite3_sleep(tls, 10) + g.iTimeout = 0 + iTimeout = 1000 + for (((libc.AssignInt32(&rc, trySql(tls, ts+3502 /* "SELECT 1 FROM cl..." */, 0))) == 5) || + (rc == 100)) && (iTimeout > 0) { + sqlite3.Xsqlite3_sleep(tls, 10) + iTimeout = iTimeout - (10) + } + sqlite3.Xsqlite3_sleep(tls, 100) + pStmt = prepareSql(tls, ts+3523 /* "SELECT nError, n..." */, 0) + iTimeout = 1000 + for ((libc.AssignInt32(&rc, sqlite3.Xsqlite3_step(tls, pStmt))) == 5) && (iTimeout > 0) { + sqlite3.Xsqlite3_sleep(tls, 10) + iTimeout = iTimeout - (10) + } + if rc == 100 { + *(*int32)(unsafe.Pointer(uintptr(unsafe.Pointer(&g)) + 112 /* &.nError */)) += (sqlite3.Xsqlite3_column_int(tls, pStmt, 0)) + *(*int32)(unsafe.Pointer(uintptr(unsafe.Pointer(&g)) + 116 /* &.nTest */)) += (sqlite3.Xsqlite3_column_int(tls, pStmt, 1)) + } + sqlite3.Xsqlite3_finalize(tls, pStmt) + } + sqlite3.Xsqlite3_close(tls, g.db) + maybeClose(tls, g.pLog) + maybeClose(tls, g.pErrLog) + if iClient == 0 { + libc.Xprintf(tls, ts+3558 /* "Summary: %d erro..." */, libc.VaList(bp+200, g.nError, g.nTest)) + libc.Xprintf(tls, ts+3594 /* "END: %s" */, libc.VaList(bp+216, *(*uintptr)(unsafe.Pointer(argv + uintptr(0)*8)))) + for i = 1; i < argc; i++ { + libc.Xprintf(tls, ts+2317 /* " %s" */, libc.VaList(bp+224, *(*uintptr)(unsafe.Pointer(argv + uintptr(i)*8)))) + } + libc.Xprintf(tls, ts+2321 /* "\n" */, 0) + } + return (libc.Bool32(g.nError > 0)) +} + +var ts1 = "%s%.*s\n\x00%s:ERROR: \x00%s:FATAL: \x00UPDATE client SET wantHalt=1;\x00%s: \x00main\x00timeout after %dms\x00[%.*s]\x00(info) %s\x00(errcode=%d) %s\x00%s\n%s\n\x00out of memory\x00 \x00nil\x00'\x00error(%d)\x00BEGIN IMMEDIATE\x00in startScript: %s\x00UPDATE counters SET nError=nError+%d, nTest=nTest+%d\x00SELECT 1 FROM client WHERE id=%d AND wantHalt\x00DELETE FROM client WHERE id=%d\x00COMMIT TRANSACTION;\x00SELECT script, id, name FROM task WHERE client=%d AND starttime IS NULL ORDER BY id LIMIT 1\x00%s\x00UPDATE task SET starttime=strftime('%%Y-%%m-%%d %%H:%%M:%%f','now') WHERE id=%d;\x00Waited over 30 seconds with no work. Giving up.\x00DELETE FROM client WHERE id=%d; COMMIT;\x00COMMIT\x00UPDATE task SET endtime=strftime('%%Y-%%m-%%d %%H:%%M:%%f','now') WHERE id=%d;\x00INSERT OR IGNORE INTO client VALUES(%d,0)\x00%s \"%s\" --client %d --trace %d\x00%z --sqltrace\x00%z --sync\x00%z --vfs \"%s\"\x00system('%q')\x00%z &\x00system() fails with error code %d\x00rb\x00cannot open \"%s\" for reading\x00--end\x00--endif\x00--else\x00--if\x00SELECT 1 FROM task WHERE client=%d AND client IN (SELECT id FROM client) AND endtime IS NULL\x00SELECT 1 FROM task WHERE client IN (SELECT id FROM client) AND endtime IS NULL\x00\x00%stimeout waiting for client %d\x00%stimeout waiting for all clients\x00on\x00yes\x00off\x00no\x00unknown boolean: [%s]\x00%.*s\x00sleep\x00exit\x00testcase\x00finish\x00reset\x00match\x00line %d of %s:\nExpected [%.*s]\n Got [%s]\x00glob\x00notglob\x00line %d of %s:\nExpected [%s]\n Got [%s]\x00output\x00source\x00%.*s/%s\x00begin script [%s]\n\x00end script [%s]\n\x00print\x00if\x00SELECT %.*s\x00else\x00endif\x00start\x00wait\x00line %d of %s\n\x00task\x00line %d of %s: bad client number: %d\x00%s:%d\x00INSERT INTO task(client,script,name) VALUES(%d,'%q',%Q)\x00breakpoint\x00show-sql-errors\x00line %d of %s: unknown command --%s\x00command-line option \"--%s\" requires an argument\x00Usage: %s DATABASE ?OPTIONS? ?SCRIPT?\n\x00Options:\n --errlog FILENAME Write errors to FILENAME\n --journalmode MODE Use MODE as the journal_mode\n --log FILENAME Log messages to FILENAME\n --quiet Suppress unnecessary output\n --vfs NAME Use NAME as the VFS\n --repeat N Repeat the test N times\n --sqltrace Enable SQL tracing\n --sync Enable synchronous disk writes\n --timeout MILLISEC Busy timeout is MILLISEC\n --trace BOOLEAN Enable or disable tracing\n\x00%s: unrecognized arguments:\x00 %s\x00\n\x00*.test\x002020-08-14 13:23:32 fca8dc8b578f215a969cd899336378966156154710873e68b3d9ac5881b0ff3f\x00SQLite library and header mismatch\nLibrary: %s\nHeader: %s\n\x00%05d.mptest\x00journalmode\x00repeat\x00vfs\x00client\x00errlog\x00log\x00trace\x00quiet\x00timeout\x00sqltrace\x00sync\x00a\x00illegal client number: %d\n\x00%05d.client%02d\x00BEGIN: %s\x00With SQLite 3.33.0 2020-08-14 13:23:32 fca8dc8b578f215a969cd899336378966156154710873e68b3d9ac5881b0ff3f\n\x00-DSQLITE_%s\n\x00... %strying to unlink '%s'\n\x00still \x00unable to unlink '%s' after %d attempts\n\x00cannot open [%s]\x00PRAGMA journal_mode=%Q;\x00PRAGMA synchronous=OFF\x00vfsname\x00eval\x00start-client\x00begin %s (%d)\x00end %s (%d)\x00end-client\x00missing script filename\x00DROP TABLE IF EXISTS task;\nDROP TABLE IF EXISTS counters;\nDROP TABLE IF EXISTS client;\nCREATE TABLE task(\n id INTEGER PRIMARY KEY,\n name TEXT,\n client INTEGER,\n starttime DATE,\n endtime DATE,\n script TEXT\n);CREATE INDEX task_i1 ON task(client, starttime);\nCREATE INDEX task_i2 ON task(client, endtime);\nCREATE TABLE counters(nError,nTest);\nINSERT INTO counters VALUES(0,0);\nCREATE TABLE client(id INTEGER PRIMARY KEY, wantHalt);\n\x00begin script [%s] cycle %d\n\x00end script [%s] cycle %d\n\x00during shutdown...\n\x00UPDATE client SET wantHalt=1\x00SELECT 1 FROM client\x00SELECT nError, nTest FROM counters\x00Summary: %d errors out of %d tests\n\x00END: %s\x00" +var ts = (*reflect.StringHeader)(unsafe.Pointer(&ts1)).Data |