mirror of
https://github.com/glebarez/go-sqlite.git
synced 2025-10-06 00:06:56 +08:00
5724 lines
236 KiB
Go
5724 lines
236 KiB
Go
// Code generated by 'ccgo -o internal/mptest/main_linux_amd64.go -trace-translation-units -volatile=sqlite3_io_error_pending,sqlite3_open_file_count,sqlite3_pager_readdb_count,sqlite3_pager_writedb_count,sqlite3_pager_writej_count,sqlite3_search_count,sqlite3_sort_count,saved_cnt 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_SOUNDEX -DSQLITE_TEMP_STORE=1 -DSQLITE_TEST -DSQLITE_THREADSAFE=1 -DSQLITE_OS_UNIX=1', DO NOT EDIT.
|
|
|
|
package main
|
|
|
|
import (
|
|
"math"
|
|
"reflect"
|
|
"sync/atomic"
|
|
"unsafe"
|
|
|
|
"modernc.org/libc"
|
|
"modernc.org/sqlite/lib"
|
|
)
|
|
|
|
var _ = math.Pi
|
|
var _ reflect.Kind
|
|
var _ atomic.Value
|
|
var _ unsafe.Pointer
|
|
|
|
func main() { libc.Start(main1) }
|
|
|
|
// 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
|
|
)
|
|
|
|
// 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
|
|
)
|
|
|
|
type ptrdiff_t = int64 /* <builtin>:3:26 */
|
|
|
|
type size_t = uint64 /* <builtin>:9:23 */
|
|
|
|
type wchar_t = int32 /* <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.
|
|
|
|
type off_t = int64 /* stdio.h:65: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 */
|
|
|
|
// 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.
|
|
|
|
// Both x86-64 and x32 use the 64-bit system call interface.
|
|
|
|
// 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.
|
|
|
|
// Environments with 32-bit wide pointers are optionally provided.
|
|
// Therefore following macros aren't defined:
|
|
// # undef _POSIX_V7_ILP32_OFF32
|
|
// # undef _POSIX_V7_ILP32_OFFBIG
|
|
// # undef _POSIX_V6_ILP32_OFF32
|
|
// # undef _POSIX_V6_ILP32_OFFBIG
|
|
// # undef _XBS5_ILP32_OFF32
|
|
// # undef _XBS5_ILP32_OFFBIG
|
|
// and users need to check at runtime.
|
|
|
|
// 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 x86.
|
|
// 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/>.
|
|
|
|
// 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. The required
|
|
// libgcc support was added some time after the basic compiler
|
|
// support, for x86_64 and x86.
|
|
|
|
// 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.
|
|
|
|
// 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.
|
|
|
|
// __builtin_huge_valf128 doesn't exist before GCC 7.0.
|
|
|
|
// Older GCC has only a subset of built-in functions for _Float128 on
|
|
// x86, and __builtin_infq is not usable in static initializers.
|
|
// Converting a narrower sNaN to _Float128 produces a quiet NaN, so
|
|
// attempts to use _Float128 sNaNs will not work properly with older
|
|
// compilers.
|
|
|
|
// In math/math.h, __MATH_TG will expand signbit to __builtin_signbit*,
|
|
// e.g.: __builtin_signbitf128, before GCC 6. However, there has never
|
|
// been a __builtin_signbitf128 in GCC and the type-generic builtin is
|
|
// only available since GCC 6.
|
|
|
|
// 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-96 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.
|
|
|
|
// 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.
|
|
|
|
// 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 dev_t = uint64 /* types.h:59:17 */
|
|
|
|
type mode_t = uint32 /* types.h:69:18 */
|
|
|
|
type nlink_t = uint64 /* 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 */
|
|
|
|
// For GCC 2.7 and later, we can use specific type-size attributes.
|
|
|
|
type u_int8_t = uint32 /* types.h:177:1 */
|
|
type u_int16_t = uint32 /* types.h:178:1 */
|
|
type u_int32_t = uint32 /* types.h:179:1 */
|
|
type u_int64_t = uint32 /* types.h:180:1 */
|
|
|
|
type register_t = int32 /* types.h:182: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 = int64 /* 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.
|
|
|
|
// 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/>.
|
|
|
|
// Determine the wordsize from the preprocessor defines.
|
|
|
|
// Both x86-64 and x32 use the 64-bit system call interface.
|
|
|
|
// 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
|
|
__rwelision int8
|
|
__pad1 [7]uint8
|
|
__pad2 uint64
|
|
__flags uint32
|
|
_ [4]byte
|
|
} /* pthreadtypes-arch.h:65: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.
|
|
|
|
type __pthread_mutex_s = struct {
|
|
__lock int32
|
|
__count uint32
|
|
__owner int32
|
|
__nusers uint32
|
|
__kind int32
|
|
__spins int16
|
|
__elision int16
|
|
__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 [4]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 [4]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 [56]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 } /* 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 [4]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.Xfopen(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: */
|
|
atomic.AddInt32(&cnt, 1)
|
|
}
|
|
|
|
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 {
|
|
// no-op
|
|
} 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.Xfopen(tls, g.zErrLog, ts+2562 /* "a" */)
|
|
} else {
|
|
g.pErrLog = libc.Xstderr
|
|
}
|
|
if g.zLog != 0 {
|
|
g.pLog = libc.Xfopen(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
|