codekingpro/portable-devtools
115k
1/*-------------------------------------------------------------------------2 *3 * c.h4 * Fundamental C definitions. This is included by every .c file in5 * PostgreSQL (via either postgres.h or postgres_fe.h, as appropriate).6 *7 * Note that the definitions here are not intended to be exposed to clients8 * of the frontend interface libraries --- so we don't worry much about9 * polluting the namespace with lots of stuff...10 *11 *12 * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group13 * Portions Copyright (c) 1994, Regents of the University of California14 *15 * src/include/c.h16 *17 *-------------------------------------------------------------------------18 */19/*20 *----------------------------------------------------------------21 * TABLE OF CONTENTS22 *23 * When adding stuff to this file, please try to put stuff24 * into the relevant section, or add new sections as appropriate.25 *26 * section description27 * ------- ------------------------------------------------28 * 0) pg_config.h and standard system headers29 * 1) compiler characteristics30 * 2) bool, true, false31 * 3) standard system types32 * 4) IsValid macros for system types33 * 5) lengthof, alignment34 * 6) assertions35 * 7) widely useful macros36 * 8) random stuff37 * 9) system-specific hacks38 *39 * NOTE: since this file is included by both frontend and backend modules,40 * it's usually wrong to put an "extern" declaration here, unless it's41 * ifdef'd so that it's seen in only one case or the other.42 * typedefs and macros are the kind of thing that might go here.43 *44 *----------------------------------------------------------------45 */46#ifndef C_H47#define C_H48 49#include "postgres_ext.h"50 51/* Must undef pg_config_ext.h symbols before including pg_config.h */52#undef PG_INT64_TYPE53 54#include "pg_config.h"55#include "pg_config_manual.h" /* must be after pg_config.h */56#include "pg_config_os.h" /* must be before any system header files */57 58/* System header files that should be available everywhere in Postgres */59#include <stdio.h>60#include <stdlib.h>61#include <string.h>62#include <stddef.h>63#include <stdarg.h>64#ifdef HAVE_STRINGS_H65#include <strings.h>66#endif67#include <stdint.h>68#include <sys/types.h>69#include <errno.h>70#if defined(WIN32) || defined(__CYGWIN__)71#include <fcntl.h> /* ensure O_BINARY is available */72#endif73#include <locale.h>74#ifdef ENABLE_NLS75#include <libintl.h>76#endif77 78 79/* ----------------------------------------------------------------80 * Section 1: compiler characteristics81 *82 * type prefixes (const, signed, volatile, inline) are handled in pg_config.h.83 * ----------------------------------------------------------------84 */85 86/*87 * Disable "inline" if PG_FORCE_DISABLE_INLINE is defined.88 * This is used to work around compiler bugs and might also be useful for89 * investigatory purposes.90 */91#ifdef PG_FORCE_DISABLE_INLINE92#undef inline93#define inline94#endif95 96/*97 * Attribute macros98 *99 * GCC: https://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html100 * GCC: https://gcc.gnu.org/onlinedocs/gcc/Type-Attributes.html101 * Clang: https://clang.llvm.org/docs/AttributeReference.html102 * Sunpro: https://docs.oracle.com/cd/E18659_01/html/821-1384/gjzke.html103 * XLC: https://www.ibm.com/support/knowledgecenter/SSGH2K_13.1.2/com.ibm.xlc131.aix.doc/language_ref/function_attributes.html104 * XLC: https://www.ibm.com/support/knowledgecenter/SSGH2K_13.1.2/com.ibm.xlc131.aix.doc/language_ref/type_attrib.html105 */106 107/*108 * For compilers which don't support __has_attribute, we just define109 * __has_attribute(x) to 0 so that we can define macros for various110 * __attribute__s more easily below.111 */112#ifndef __has_attribute113#define __has_attribute(attribute) 0114#endif115 116/* only GCC supports the unused attribute */117#ifdef __GNUC__118#define pg_attribute_unused() __attribute__((unused))119#else120#define pg_attribute_unused()121#endif122 123/*124 * pg_nodiscard means the compiler should warn if the result of a function125 * call is ignored. The name "nodiscard" is chosen in alignment with126 * (possibly future) C and C++ standards. For maximum compatibility, use it127 * as a function declaration specifier, so it goes before the return type.128 */129#ifdef __GNUC__130#define pg_nodiscard __attribute__((warn_unused_result))131#else132#define pg_nodiscard133#endif134 135/*136 * Place this macro before functions that should be allowed to make misaligned137 * accesses. Think twice before using it on non-x86-specific code!138 * Testing can be done with "-fsanitize=alignment -fsanitize-trap=alignment"139 * on clang, or "-fsanitize=alignment -fno-sanitize-recover=alignment" on gcc.140 */141#if __clang_major__ >= 7 || __GNUC__ >= 8142#define pg_attribute_no_sanitize_alignment() __attribute__((no_sanitize("alignment")))143#else144#define pg_attribute_no_sanitize_alignment()145#endif146 147/*148 * pg_attribute_nonnull means the compiler should warn if the function is149 * called with the listed arguments set to NULL. If no arguments are150 * listed, the compiler should warn if any pointer arguments are set to NULL.151 */152#if __has_attribute (nonnull)153#define pg_attribute_nonnull(...) __attribute__((nonnull(__VA_ARGS__)))154#else155#define pg_attribute_nonnull(...)156#endif157 158/*159 * Append PG_USED_FOR_ASSERTS_ONLY to definitions of variables that are only160 * used in assert-enabled builds, to avoid compiler warnings about unused161 * variables in assert-disabled builds.162 */163#ifdef USE_ASSERT_CHECKING164#define PG_USED_FOR_ASSERTS_ONLY165#else166#define PG_USED_FOR_ASSERTS_ONLY pg_attribute_unused()167#endif168 169/* GCC and XLC support format attributes */170#if defined(__GNUC__) || defined(__IBMC__)171#define pg_attribute_format_arg(a) __attribute__((format_arg(a)))172#define pg_attribute_printf(f,a) __attribute__((format(PG_PRINTF_ATTRIBUTE, f, a)))173#else174#define pg_attribute_format_arg(a)175#define pg_attribute_printf(f,a)176#endif177 178/* GCC, Sunpro and XLC support aligned, packed and noreturn */179#if defined(__GNUC__) || defined(__SUNPRO_C) || defined(__IBMC__)180#define pg_attribute_aligned(a) __attribute__((aligned(a)))181#define pg_attribute_noreturn() __attribute__((noreturn))182#define pg_attribute_packed() __attribute__((packed))183#define HAVE_PG_ATTRIBUTE_NORETURN 1184#elif defined(_MSC_VER)185/*186 * MSVC supports aligned. noreturn is also possible but in MSVC it is187 * declared before the definition while pg_attribute_noreturn() macro188 * is currently used after the definition.189 *190 * Packing is also possible but only by wrapping the entire struct definition191 * which doesn't fit into our current macro declarations.192 */193#define pg_attribute_aligned(a) __declspec(align(a))194#define pg_attribute_noreturn()195#else196/*197 * NB: aligned and packed are not given default definitions because they198 * affect code functionality; they *must* be implemented by the compiler199 * if they are to be used.200 */201#define pg_attribute_noreturn()202#endif203 204/*205 * Use "pg_attribute_always_inline" in place of "inline" for functions that206 * we wish to force inlining of, even when the compiler's heuristics would207 * choose not to. But, if possible, don't force inlining in unoptimized208 * debug builds.209 */210#if (defined(__GNUC__) && __GNUC__ > 3 && defined(__OPTIMIZE__)) || defined(__SUNPRO_C) || defined(__IBMC__)211/* GCC > 3, Sunpro and XLC support always_inline via __attribute__ */212#define pg_attribute_always_inline __attribute__((always_inline)) inline213#elif defined(_MSC_VER)214/* MSVC has a special keyword for this */215#define pg_attribute_always_inline __forceinline216#else217/* Otherwise, the best we can do is to say "inline" */218#define pg_attribute_always_inline inline219#endif220 221/*222 * Forcing a function not to be inlined can be useful if it's the slow path of223 * a performance-critical function, or should be visible in profiles to allow224 * for proper cost attribution. Note that unlike the pg_attribute_XXX macros225 * above, this should be placed before the function's return type and name.226 */227/* GCC, Sunpro and XLC support noinline via __attribute__ */228#if (defined(__GNUC__) && __GNUC__ > 2) || defined(__SUNPRO_C) || defined(__IBMC__)229#define pg_noinline __attribute__((noinline))230/* msvc via declspec */231#elif defined(_MSC_VER)232#define pg_noinline __declspec(noinline)233#else234#define pg_noinline235#endif236 237/*238 * For now, just define pg_attribute_cold and pg_attribute_hot to be empty239 * macros on minGW 8.1. There appears to be a compiler bug that results in240 * compilation failure. At this time, we still have at least one buildfarm241 * animal running that compiler, so this should make that green again. It's242 * likely this compiler is not popular enough to warrant keeping this code243 * around forever, so let's just remove it once the last buildfarm animal244 * upgrades.245 */246#if defined(__MINGW64__) && __GNUC__ == 8 && __GNUC_MINOR__ == 1247 248#define pg_attribute_cold249#define pg_attribute_hot250 251#else252/*253 * Marking certain functions as "hot" or "cold" can be useful to assist the254 * compiler in arranging the assembly code in a more efficient way.255 */256#if __has_attribute (cold)257#define pg_attribute_cold __attribute__((cold))258#else259#define pg_attribute_cold260#endif261 262#if __has_attribute (hot)263#define pg_attribute_hot __attribute__((hot))264#else265#define pg_attribute_hot266#endif267 268#endif /* defined(__MINGW64__) && __GNUC__ == 8 &&269 * __GNUC_MINOR__ == 1 */270/*271 * Mark a point as unreachable in a portable fashion. This should preferably272 * be something that the compiler understands, to aid code generation.273 * In assert-enabled builds, we prefer abort() for debugging reasons.274 */275#if defined(HAVE__BUILTIN_UNREACHABLE) && !defined(USE_ASSERT_CHECKING)276#define pg_unreachable() __builtin_unreachable()277#elif defined(_MSC_VER) && !defined(USE_ASSERT_CHECKING)278#define pg_unreachable() __assume(0)279#else280#define pg_unreachable() abort()281#endif282 283/*284 * Hints to the compiler about the likelihood of a branch. Both likely() and285 * unlikely() return the boolean value of the contained expression.286 *287 * These should only be used sparingly, in very hot code paths. It's very easy288 * to mis-estimate likelihoods.289 */290#if __GNUC__ >= 3291#define likely(x) __builtin_expect((x) != 0, 1)292#define unlikely(x) __builtin_expect((x) != 0, 0)293#else294#define likely(x) ((x) != 0)295#define unlikely(x) ((x) != 0)296#endif297 298/*299 * CppAsString300 * Convert the argument to a string, using the C preprocessor.301 * CppAsString2302 * Convert the argument to a string, after one round of macro expansion.303 * CppConcat304 * Concatenate two arguments together, using the C preprocessor.305 *306 * Note: There used to be support here for pre-ANSI C compilers that didn't307 * support # and ##. Nowadays, these macros are just for clarity and/or308 * backward compatibility with existing PostgreSQL code.309 */310#define CppAsString(identifier) #identifier311#define CppAsString2(x) CppAsString(x)312#define CppConcat(x, y) x##y313 314/*315 * VA_ARGS_NARGS316 * Returns the number of macro arguments it is passed.317 *318 * An empty argument still counts as an argument, so effectively, this is319 * "one more than the number of commas in the argument list".320 *321 * This works for up to 63 arguments. Internally, VA_ARGS_NARGS_() is passed322 * 64+N arguments, and the C99 standard only requires macros to allow up to323 * 127 arguments, so we can't portably go higher. The implementation is324 * pretty trivial: VA_ARGS_NARGS_() returns its 64th argument, and we set up325 * the call so that that is the appropriate one of the list of constants.326 * This idea is due to Laurent Deniau.327 *328 * MSVC has an implementation of __VA_ARGS__ that doesn't conform to the329 * standard unless you use the /Zc:preprocessor compiler flag, but that330 * isn't available before Visual Studio 2019. For now, use a different331 * definition that also works on older compilers.332 */333#ifdef _MSC_VER334#define EXPAND(args) args335#define VA_ARGS_NARGS(...) \336 VA_ARGS_NARGS_ EXPAND((__VA_ARGS__, \337 63,62,61,60, \338 59,58,57,56,55,54,53,52,51,50, \339 49,48,47,46,45,44,43,42,41,40, \340 39,38,37,36,35,34,33,32,31,30, \341 29,28,27,26,25,24,23,22,21,20, \342 19,18,17,16,15,14,13,12,11,10, \343 9, 8, 7, 6, 5, 4, 3, 2, 1, 0))344#else345 346#define VA_ARGS_NARGS(...) \347 VA_ARGS_NARGS_(__VA_ARGS__, \348 63,62,61,60, \349 59,58,57,56,55,54,53,52,51,50, \350 49,48,47,46,45,44,43,42,41,40, \351 39,38,37,36,35,34,33,32,31,30, \352 29,28,27,26,25,24,23,22,21,20, \353 19,18,17,16,15,14,13,12,11,10, \354 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)355#endif356 357#define VA_ARGS_NARGS_( \358 _01,_02,_03,_04,_05,_06,_07,_08,_09,_10, \359 _11,_12,_13,_14,_15,_16,_17,_18,_19,_20, \360 _21,_22,_23,_24,_25,_26,_27,_28,_29,_30, \361 _31,_32,_33,_34,_35,_36,_37,_38,_39,_40, \362 _41,_42,_43,_44,_45,_46,_47,_48,_49,_50, \363 _51,_52,_53,_54,_55,_56,_57,_58,_59,_60, \364 _61,_62,_63, N, ...) \365 (N)366 367/*368 * Generic function pointer. This can be used in the rare cases where it's369 * necessary to cast a function pointer to a seemingly incompatible function370 * pointer type while avoiding gcc's -Wcast-function-type warnings.371 */372typedef void (*pg_funcptr_t) (void);373 374/*375 * We require C99, hence the compiler should understand flexible array376 * members. However, for documentation purposes we still consider it to be377 * project style to write "field[FLEXIBLE_ARRAY_MEMBER]" not just "field[]".378 * When computing the size of such an object, use "offsetof(struct s, f)"379 * for portability. Don't use "offsetof(struct s, f[0])", as this doesn't380 * work with MSVC and with C++ compilers.381 */382#define FLEXIBLE_ARRAY_MEMBER /* empty */383 384/*385 * Does the compiler support #pragma GCC system_header? We optionally use it386 * to avoid warnings that we can't fix (e.g. in the perl headers).387 * See https://gcc.gnu.org/onlinedocs/cpp/System-Headers.html388 *389 * Headers for which we do not want to show compiler warnings can,390 * conditionally, use #pragma GCC system_header to avoid warnings. Obviously391 * this should only be used for external headers over which we do not have392 * control.393 *394 * Support for the pragma is tested here, instead of during configure, as gcc395 * also warns about the pragma being used in a .c file. It's surprisingly hard396 * to get autoconf to use .h as the file-ending. Looks like gcc has397 * implemented the pragma since the 2000, so this test should suffice.398 *399 *400 * Alternatively, we could add the include paths for problematic headers with401 * -isystem, but that is a larger hammer and is harder to search for.402 *403 * A more granular alternative would be to use #pragma GCC diagnostic404 * push/ignored/pop, but gcc warns about unknown warnings being ignored, so405 * every to-be-ignored-temporarily compiler warning would require its own406 * pg_config.h symbol and #ifdef.407 */408#ifdef __GNUC__409#define HAVE_PRAGMA_GCC_SYSTEM_HEADER 1410#endif411 412 413/* ----------------------------------------------------------------414 * Section 2: bool, true, false415 * ----------------------------------------------------------------416 */417 418/*419 * bool420 * Boolean value, either true or false.421 *422 * We use stdbool.h if available and its bool has size 1. That's useful for423 * better compiler and debugger output and for compatibility with third-party424 * libraries. But PostgreSQL currently cannot deal with bool of other sizes;425 * there are static assertions around the code to prevent that.426 *427 * For C++ compilers, we assume the compiler has a compatible built-in428 * definition of bool.429 *430 * See also the version of this code in src/interfaces/ecpg/include/ecpglib.h.431 */432 433#ifndef __cplusplus434 435#ifdef PG_USE_STDBOOL436#include <stdbool.h>437#else438 439#ifndef bool440typedef unsigned char bool;441#endif442 443#ifndef true444#define true ((bool) 1)445#endif446 447#ifndef false448#define false ((bool) 0)449#endif450 451#endif /* not PG_USE_STDBOOL */452#endif /* not C++ */453 454 455/* ----------------------------------------------------------------456 * Section 3: standard system types457 * ----------------------------------------------------------------458 */459 460/*461 * Pointer462 * Variable holding address of any memory resident object.463 *464 * XXX Pointer arithmetic is done with this, so it can't be void *465 * under "true" ANSI compilers.466 */467typedef char *Pointer;468 469/*470 * intN471 * Signed integer, EXACTLY N BITS IN SIZE,472 * used for numerical computations and the473 * frontend/backend protocol.474 */475#ifndef HAVE_INT8476typedef signed char int8; /* == 8 bits */477typedef signed short int16; /* == 16 bits */478typedef signed int int32; /* == 32 bits */479#endif /* not HAVE_INT8 */480 481/*482 * uintN483 * Unsigned integer, EXACTLY N BITS IN SIZE,484 * used for numerical computations and the485 * frontend/backend protocol.486 */487#ifndef HAVE_UINT8488typedef unsigned char uint8; /* == 8 bits */489typedef unsigned short uint16; /* == 16 bits */490typedef unsigned int uint32; /* == 32 bits */491#endif /* not HAVE_UINT8 */492 493/*494 * bitsN495 * Unit of bitwise operation, AT LEAST N BITS IN SIZE.496 */497typedef uint8 bits8; /* >= 8 bits */498typedef uint16 bits16; /* >= 16 bits */499typedef uint32 bits32; /* >= 32 bits */500 501/*502 * 64-bit integers503 */504#ifdef HAVE_LONG_INT_64505/* Plain "long int" fits, use it */506 507#ifndef HAVE_INT64508typedef long int int64;509#endif510#ifndef HAVE_UINT64511typedef unsigned long int uint64;512#endif513#define INT64CONST(x) (x##L)514#define UINT64CONST(x) (x##UL)515#elif defined(HAVE_LONG_LONG_INT_64)516/* We have working support for "long long int", use that */517 518#ifndef HAVE_INT64519typedef long long int int64;520#endif521#ifndef HAVE_UINT64522typedef unsigned long long int uint64;523#endif524#define INT64CONST(x) (x##LL)525#define UINT64CONST(x) (x##ULL)526#else527/* neither HAVE_LONG_INT_64 nor HAVE_LONG_LONG_INT_64 */528#error must have a working 64-bit integer datatype529#endif530 531/* snprintf format strings to use for 64-bit integers */532#define INT64_FORMAT "%" INT64_MODIFIER "d"533#define UINT64_FORMAT "%" INT64_MODIFIER "u"534 535/*536 * 128-bit signed and unsigned integers537 * There currently is only limited support for such types.538 * E.g. 128bit literals and snprintf are not supported; but math is.539 * Also, because we exclude such types when choosing MAXIMUM_ALIGNOF,540 * it must be possible to coerce the compiler to allocate them on no541 * more than MAXALIGN boundaries.542 */543#if defined(PG_INT128_TYPE)544#if defined(pg_attribute_aligned) || ALIGNOF_PG_INT128_TYPE <= MAXIMUM_ALIGNOF545#define HAVE_INT128 1546 547typedef PG_INT128_TYPE int128548#if defined(pg_attribute_aligned)549 pg_attribute_aligned(MAXIMUM_ALIGNOF)550#endif551 ;552 553typedef unsigned PG_INT128_TYPE uint128554#if defined(pg_attribute_aligned)555 pg_attribute_aligned(MAXIMUM_ALIGNOF)556#endif557 ;558 559#endif560#endif561 562/*563 * stdint.h limits aren't guaranteed to have compatible types with our fixed564 * width types. So just define our own.565 */566#define PG_INT8_MIN (-0x7F-1)567#define PG_INT8_MAX (0x7F)568#define PG_UINT8_MAX (0xFF)569#define PG_INT16_MIN (-0x7FFF-1)570#define PG_INT16_MAX (0x7FFF)571#define PG_UINT16_MAX (0xFFFF)572#define PG_INT32_MIN (-0x7FFFFFFF-1)573#define PG_INT32_MAX (0x7FFFFFFF)574#define PG_UINT32_MAX (0xFFFFFFFFU)575#define PG_INT64_MIN (-INT64CONST(0x7FFFFFFFFFFFFFFF) - 1)576#define PG_INT64_MAX INT64CONST(0x7FFFFFFFFFFFFFFF)577#define PG_UINT64_MAX UINT64CONST(0xFFFFFFFFFFFFFFFF)578 579/*580 * We now always use int64 timestamps, but keep this symbol defined for the581 * benefit of external code that might test it.582 */583#define HAVE_INT64_TIMESTAMP584 585/*586 * Size587 * Size of any memory resident object, as returned by sizeof.588 */589typedef size_t Size;590 591/*592 * Index593 * Index into any memory resident array.594 *595 * Note:596 * Indices are non negative.597 */598typedef unsigned int Index;599 600/*601 * Offset602 * Offset into any memory resident array.603 *604 * Note:605 * This differs from an Index in that an Index is always606 * non negative, whereas Offset may be negative.607 */608typedef signed int Offset;609 610/*611 * Common Postgres datatype names (as used in the catalogs)612 */613typedef float float4;614typedef double float8;615 616#ifdef USE_FLOAT8_BYVAL617#define FLOAT8PASSBYVAL true618#else619#define FLOAT8PASSBYVAL false620#endif621 622/*623 * Oid, RegProcedure, TransactionId, SubTransactionId, MultiXactId,624 * CommandId625 */626 627/* typedef Oid is in postgres_ext.h */628 629/*630 * regproc is the type name used in the include/catalog headers, but631 * RegProcedure is the preferred name in C code.632 */633typedef Oid regproc;634typedef regproc RegProcedure;635 636typedef uint32 TransactionId;637 638typedef uint32 LocalTransactionId;639 640typedef uint32 SubTransactionId;641 642#define InvalidSubTransactionId ((SubTransactionId) 0)643#define TopSubTransactionId ((SubTransactionId) 1)644 645/* MultiXactId must be equivalent to TransactionId, to fit in t_xmax */646typedef TransactionId MultiXactId;647 648typedef uint32 MultiXactOffset;649 650typedef uint32 CommandId;651 652#define FirstCommandId ((CommandId) 0)653#define InvalidCommandId (~(CommandId)0)654 655 656/* ----------------657 * Variable-length datatypes all share the 'struct varlena' header.658 *659 * NOTE: for TOASTable types, this is an oversimplification, since the value660 * may be compressed or moved out-of-line. However datatype-specific routines661 * are mostly content to deal with de-TOASTed values only, and of course662 * client-side routines should never see a TOASTed value. But even in a663 * de-TOASTed value, beware of touching vl_len_ directly, as its664 * representation is no longer convenient. It's recommended that code always665 * use macros VARDATA_ANY, VARSIZE_ANY, VARSIZE_ANY_EXHDR, VARDATA, VARSIZE,666 * and SET_VARSIZE instead of relying on direct mentions of the struct fields.667 * See postgres.h for details of the TOASTed form.668 * ----------------669 */670struct varlena671{672 char vl_len_[4]; /* Do not touch this field directly! */673 char vl_dat[FLEXIBLE_ARRAY_MEMBER]; /* Data content is here */674};675 676#define VARHDRSZ ((int32) sizeof(int32))677 678/*679 * These widely-used datatypes are just a varlena header and the data bytes.680 * There is no terminating null or anything like that --- the data length is681 * always VARSIZE_ANY_EXHDR(ptr).682 */683typedef struct varlena bytea;684typedef struct varlena text;685typedef struct varlena BpChar; /* blank-padded char, ie SQL char(n) */686typedef struct varlena VarChar; /* var-length char, ie SQL varchar(n) */687 688/*689 * Specialized array types. These are physically laid out just the same690 * as regular arrays (so that the regular array subscripting code works691 * with them). They exist as distinct types mostly for historical reasons:692 * they have nonstandard I/O behavior which we don't want to change for fear693 * of breaking applications that look at the system catalogs. There is also694 * an implementation issue for oidvector: it's part of the primary key for695 * pg_proc, and we can't use the normal btree array support routines for that696 * without circularity.697 */698typedef struct699{700 int32 vl_len_; /* these fields must match ArrayType! */701 int ndim; /* always 1 for int2vector */702 int32 dataoffset; /* always 0 for int2vector */703 Oid elemtype;704 int dim1;705 int lbound1;706 int16 values[FLEXIBLE_ARRAY_MEMBER];707} int2vector;708 709typedef struct710{711 int32 vl_len_; /* these fields must match ArrayType! */712 int ndim; /* always 1 for oidvector */713 int32 dataoffset; /* always 0 for oidvector */714 Oid elemtype;715 int dim1;716 int lbound1;717 Oid values[FLEXIBLE_ARRAY_MEMBER];718} oidvector;719 720/*721 * Representation of a Name: effectively just a C string, but null-padded to722 * exactly NAMEDATALEN bytes. The use of a struct is historical.723 */724typedef struct nameData725{726 char data[NAMEDATALEN];727} NameData;728typedef NameData *Name;729 730#define NameStr(name) ((name).data)731 732 733/* ----------------------------------------------------------------734 * Section 4: IsValid macros for system types735 * ----------------------------------------------------------------736 */737/*738 * BoolIsValid739 * True iff bool is valid.740 */741#define BoolIsValid(boolean) ((boolean) == false || (boolean) == true)742 743/*744 * PointerIsValid745 * True iff pointer is valid.746 */747#define PointerIsValid(pointer) ((const void*)(pointer) != NULL)748 749/*750 * PointerIsAligned751 * True iff pointer is properly aligned to point to the given type.752 */753#define PointerIsAligned(pointer, type) \754 (((uintptr_t)(pointer) % (sizeof (type))) == 0)755 756#define OffsetToPointer(base, offset) \757 ((void *)((char *) base + offset))758 759#define OidIsValid(objectId) ((bool) ((objectId) != InvalidOid))760 761#define RegProcedureIsValid(p) OidIsValid(p)762 763 764/* ----------------------------------------------------------------765 * Section 5: lengthof, alignment766 * ----------------------------------------------------------------767 */768/*769 * lengthof770 * Number of elements in an array.771 */772#define lengthof(array) (sizeof (array) / sizeof ((array)[0]))773 774/* ----------------775 * Alignment macros: align a length or address appropriately for a given type.776 * The fooALIGN() macros round up to a multiple of the required alignment,777 * while the fooALIGN_DOWN() macros round down. The latter are more useful778 * for problems like "how many X-sized structures will fit in a page?".779 *780 * NOTE: TYPEALIGN[_DOWN] will not work if ALIGNVAL is not a power of 2.781 * That case seems extremely unlikely to be needed in practice, however.782 *783 * NOTE: MAXIMUM_ALIGNOF, and hence MAXALIGN(), intentionally exclude any784 * larger-than-8-byte types the compiler might have.785 * ----------------786 */787 788#define TYPEALIGN(ALIGNVAL,LEN) \789 (((uintptr_t) (LEN) + ((ALIGNVAL) - 1)) & ~((uintptr_t) ((ALIGNVAL) - 1)))790 791#define SHORTALIGN(LEN) TYPEALIGN(ALIGNOF_SHORT, (LEN))792#define INTALIGN(LEN) TYPEALIGN(ALIGNOF_INT, (LEN))793#define LONGALIGN(LEN) TYPEALIGN(ALIGNOF_LONG, (LEN))794#define DOUBLEALIGN(LEN) TYPEALIGN(ALIGNOF_DOUBLE, (LEN))795#define MAXALIGN(LEN) TYPEALIGN(MAXIMUM_ALIGNOF, (LEN))796/* MAXALIGN covers only built-in types, not buffers */797#define BUFFERALIGN(LEN) TYPEALIGN(ALIGNOF_BUFFER, (LEN))798#define CACHELINEALIGN(LEN) TYPEALIGN(PG_CACHE_LINE_SIZE, (LEN))799 800#define TYPEALIGN_DOWN(ALIGNVAL,LEN) \801 (((uintptr_t) (LEN)) & ~((uintptr_t) ((ALIGNVAL) - 1)))802 803#define SHORTALIGN_DOWN(LEN) TYPEALIGN_DOWN(ALIGNOF_SHORT, (LEN))804#define INTALIGN_DOWN(LEN) TYPEALIGN_DOWN(ALIGNOF_INT, (LEN))805#define LONGALIGN_DOWN(LEN) TYPEALIGN_DOWN(ALIGNOF_LONG, (LEN))806#define DOUBLEALIGN_DOWN(LEN) TYPEALIGN_DOWN(ALIGNOF_DOUBLE, (LEN))807#define MAXALIGN_DOWN(LEN) TYPEALIGN_DOWN(MAXIMUM_ALIGNOF, (LEN))808#define BUFFERALIGN_DOWN(LEN) TYPEALIGN_DOWN(ALIGNOF_BUFFER, (LEN))809 810/*811 * The above macros will not work with types wider than uintptr_t, like with812 * uint64 on 32-bit platforms. That's not problem for the usual use where a813 * pointer or a length is aligned, but for the odd case that you need to814 * align something (potentially) wider, use TYPEALIGN64.815 */816#define TYPEALIGN64(ALIGNVAL,LEN) \817 (((uint64) (LEN) + ((ALIGNVAL) - 1)) & ~((uint64) ((ALIGNVAL) - 1)))818 819/* we don't currently need wider versions of the other ALIGN macros */820#define MAXALIGN64(LEN) TYPEALIGN64(MAXIMUM_ALIGNOF, (LEN))821 822 823/* ----------------------------------------------------------------824 * Section 6: assertions825 * ----------------------------------------------------------------826 */827 828/*829 * USE_ASSERT_CHECKING, if defined, turns on all the assertions.830 * - plai 9/5/90831 *832 * It should _NOT_ be defined in releases or in benchmark copies833 */834 835/*836 * Assert() can be used in both frontend and backend code. In frontend code it837 * just calls the standard assert, if it's available. If use of assertions is838 * not configured, it does nothing.839 */840#ifndef USE_ASSERT_CHECKING841 842#define Assert(condition) ((void)true)843#define AssertMacro(condition) ((void)true)844 845#elif defined(FRONTEND)846 847#include <assert.h>848#define Assert(p) assert(p)849#define AssertMacro(p) ((void) assert(p))850 851#else /* USE_ASSERT_CHECKING && !FRONTEND */852 853/*854 * Assert855 * Generates a fatal exception if the given condition is false.856 */857#define Assert(condition) \858 do { \859 if (!(condition)) \860 ExceptionalCondition(#condition, __FILE__, __LINE__); \861 } while (0)862 863/*864 * AssertMacro is the same as Assert but it's suitable for use in865 * expression-like macros, for example:866 *867 * #define foo(x) (AssertMacro(x != 0), bar(x))868 */869#define AssertMacro(condition) \870 ((void) ((condition) || \871 (ExceptionalCondition(#condition, __FILE__, __LINE__), 0)))872 873#endif /* USE_ASSERT_CHECKING && !FRONTEND */874 875/*876 * Check that `ptr' is `bndr' aligned.877 */878#define AssertPointerAlignment(ptr, bndr) \879 Assert(TYPEALIGN(bndr, (uintptr_t)(ptr)) == (uintptr_t)(ptr))880 881/*882 * ExceptionalCondition is compiled into the backend whether or not883 * USE_ASSERT_CHECKING is defined, so as to support use of extensions884 * that are built with that #define with a backend that isn't. Hence,885 * we should declare it as long as !FRONTEND.886 */887#ifndef FRONTEND888extern void ExceptionalCondition(const char *conditionName,889 const char *fileName, int lineNumber) pg_attribute_noreturn();890#endif891 892/*893 * Macros to support compile-time assertion checks.894 *895 * If the "condition" (a compile-time-constant expression) evaluates to false,896 * throw a compile error using the "errmessage" (a string literal).897 *898 * C11 has _Static_assert(), and most C99 compilers already support that. For899 * portability, we wrap it into StaticAssertDecl(). _Static_assert() is a900 * "declaration", and so it must be placed where for example a variable901 * declaration would be valid. As long as we compile with902 * -Wno-declaration-after-statement, that also means it cannot be placed after903 * statements in a function. Macros StaticAssertStmt() and StaticAssertExpr()904 * make it safe to use as a statement or in an expression, respectively.905 *906 * For compilers without _Static_assert(), we fall back on a kluge that907 * assumes the compiler will complain about a negative width for a struct908 * bit-field. This will not include a helpful error message, but it beats not909 * getting an error at all.910 */911#ifndef __cplusplus912#ifdef HAVE__STATIC_ASSERT913#define StaticAssertDecl(condition, errmessage) \914 _Static_assert(condition, errmessage)915#define StaticAssertStmt(condition, errmessage) \916 do { _Static_assert(condition, errmessage); } while(0)917#define StaticAssertExpr(condition, errmessage) \918 ((void) ({ StaticAssertStmt(condition, errmessage); true; }))919#else /* !HAVE__STATIC_ASSERT */920#define StaticAssertDecl(condition, errmessage) \921 extern void static_assert_func(int static_assert_failure[(condition) ? 1 : -1])922#define StaticAssertStmt(condition, errmessage) \923 ((void) sizeof(struct { int static_assert_failure : (condition) ? 1 : -1; }))924#define StaticAssertExpr(condition, errmessage) \925 StaticAssertStmt(condition, errmessage)926#endif /* HAVE__STATIC_ASSERT */927#else /* C++ */928#if defined(__cpp_static_assert) && __cpp_static_assert >= 200410929#define StaticAssertDecl(condition, errmessage) \930 static_assert(condition, errmessage)931#define StaticAssertStmt(condition, errmessage) \932 static_assert(condition, errmessage)933#define StaticAssertExpr(condition, errmessage) \934 ({ static_assert(condition, errmessage); })935#else /* !__cpp_static_assert */936#define StaticAssertDecl(condition, errmessage) \937 extern void static_assert_func(int static_assert_failure[(condition) ? 1 : -1])938#define StaticAssertStmt(condition, errmessage) \939 do { struct static_assert_struct { int static_assert_failure : (condition) ? 1 : -1; }; } while(0)940#define StaticAssertExpr(condition, errmessage) \941 ((void) ({ StaticAssertStmt(condition, errmessage); }))942#endif /* __cpp_static_assert */943#endif /* C++ */944 945 946/*947 * Compile-time checks that a variable (or expression) has the specified type.948 *949 * AssertVariableIsOfType() can be used as a statement.950 * AssertVariableIsOfTypeMacro() is intended for use in macros, eg951 * #define foo(x) (AssertVariableIsOfTypeMacro(x, int), bar(x))952 *953 * If we don't have __builtin_types_compatible_p, we can still assert that954 * the types have the same size. This is far from ideal (especially on 32-bit955 * platforms) but it provides at least some coverage.956 */957#ifdef HAVE__BUILTIN_TYPES_COMPATIBLE_P958#define AssertVariableIsOfType(varname, typename) \959 StaticAssertStmt(__builtin_types_compatible_p(__typeof__(varname), typename), \960 CppAsString(varname) " does not have type " CppAsString(typename))961#define AssertVariableIsOfTypeMacro(varname, typename) \962 (StaticAssertExpr(__builtin_types_compatible_p(__typeof__(varname), typename), \963 CppAsString(varname) " does not have type " CppAsString(typename)))964#else /* !HAVE__BUILTIN_TYPES_COMPATIBLE_P */965#define AssertVariableIsOfType(varname, typename) \966 StaticAssertStmt(sizeof(varname) == sizeof(typename), \967 CppAsString(varname) " does not have type " CppAsString(typename))968#define AssertVariableIsOfTypeMacro(varname, typename) \969 (StaticAssertExpr(sizeof(varname) == sizeof(typename), \970 CppAsString(varname) " does not have type " CppAsString(typename)))971#endif /* HAVE__BUILTIN_TYPES_COMPATIBLE_P */972 973 974/* ----------------------------------------------------------------975 * Section 7: widely useful macros976 * ----------------------------------------------------------------977 */978/*979 * Max980 * Return the maximum of two numbers.981 */982#define Max(x, y) ((x) > (y) ? (x) : (y))983 984/*985 * Min986 * Return the minimum of two numbers.987 */988#define Min(x, y) ((x) < (y) ? (x) : (y))989 990 991/* Get a bit mask of the bits set in non-long aligned addresses */992#define LONG_ALIGN_MASK (sizeof(long) - 1)993 994/*995 * MemSet996 * Exactly the same as standard library function memset(), but considerably997 * faster for zeroing small word-aligned structures (such as parsetree nodes).998 * This has to be a macro because the main point is to avoid function-call999 * overhead. However, we have also found that the loop is faster than1000 * native libc memset() on some platforms, even those with assembler1001 * memset() functions. More research needs to be done, perhaps with1002 * MEMSET_LOOP_LIMIT tests in configure.1003 */1004#define MemSet(start, val, len) \1005 do \1006 { \1007 /* must be void* because we don't know if it is integer aligned yet */ \1008 void *_vstart = (void *) (start); \1009 int _val = (val); \1010 Size _len = (len); \1011\1012 if ((((uintptr_t) _vstart) & LONG_ALIGN_MASK) == 0 && \1013 (_len & LONG_ALIGN_MASK) == 0 && \1014 _val == 0 && \1015 _len <= MEMSET_LOOP_LIMIT && \1016 /* \1017 * If MEMSET_LOOP_LIMIT == 0, optimizer should find \1018 * the whole "if" false at compile time. \1019 */ \1020 MEMSET_LOOP_LIMIT != 0) \1021 { \1022 long *_start = (long *) _vstart; \1023 long *_stop = (long *) ((char *) _start + _len); \1024 while (_start < _stop) \1025 *_start++ = 0; \1026 } \1027 else \1028 memset(_vstart, _val, _len); \1029 } while (0)1030 1031/*1032 * MemSetAligned is the same as MemSet except it omits the test to see if1033 * "start" is word-aligned. This is okay to use if the caller knows a-priori1034 * that the pointer is suitably aligned (typically, because he just got it1035 * from palloc(), which always delivers a max-aligned pointer).1036 */1037#define MemSetAligned(start, val, len) \1038 do \1039 { \1040 long *_start = (long *) (start); \1041 int _val = (val); \1042 Size _len = (len); \1043\1044 if ((_len & LONG_ALIGN_MASK) == 0 && \1045 _val == 0 && \1046 _len <= MEMSET_LOOP_LIMIT && \1047 MEMSET_LOOP_LIMIT != 0) \1048 { \1049 long *_stop = (long *) ((char *) _start + _len); \1050 while (_start < _stop) \1051 *_start++ = 0; \1052 } \1053 else \1054 memset(_start, _val, _len); \1055 } while (0)1056 1057 1058/*1059 * MemSetTest/MemSetLoop are a variant version that allow all the tests in1060 * MemSet to be done at compile time in cases where "val" and "len" are1061 * constants *and* we know the "start" pointer must be word-aligned.1062 * If MemSetTest succeeds, then it is okay to use MemSetLoop, otherwise use1063 * MemSetAligned. Beware of multiple evaluations of the arguments when using1064 * this approach.1065 */1066#define MemSetTest(val, len) \1067 ( ((len) & LONG_ALIGN_MASK) == 0 && \1068 (len) <= MEMSET_LOOP_LIMIT && \1069 MEMSET_LOOP_LIMIT != 0 && \1070 (val) == 0 )1071 1072#define MemSetLoop(start, val, len) \1073 do \1074 { \1075 long * _start = (long *) (start); \1076 long * _stop = (long *) ((char *) _start + (Size) (len)); \1077 \1078 while (_start < _stop) \1079 *_start++ = 0; \1080 } while (0)1081 1082/*1083 * Macros for range-checking float values before converting to integer.1084 * We must be careful here that the boundary values are expressed exactly1085 * in the float domain. PG_INTnn_MIN is an exact power of 2, so it will1086 * be represented exactly; but PG_INTnn_MAX isn't, and might get rounded1087 * off, so avoid using that.1088 * The input must be rounded to an integer beforehand, typically with rint(),1089 * else we might draw the wrong conclusion about close-to-the-limit values.1090 * These macros will do the right thing for Inf, but not necessarily for NaN,1091 * so check isnan(num) first if that's a possibility.1092 */1093#define FLOAT4_FITS_IN_INT16(num) \1094 ((num) >= (float4) PG_INT16_MIN && (num) < -((float4) PG_INT16_MIN))1095#define FLOAT4_FITS_IN_INT32(num) \1096 ((num) >= (float4) PG_INT32_MIN && (num) < -((float4) PG_INT32_MIN))1097#define FLOAT4_FITS_IN_INT64(num) \1098 ((num) >= (float4) PG_INT64_MIN && (num) < -((float4) PG_INT64_MIN))1099#define FLOAT8_FITS_IN_INT16(num) \1100 ((num) >= (float8) PG_INT16_MIN && (num) < -((float8) PG_INT16_MIN))1101#define FLOAT8_FITS_IN_INT32(num) \1102 ((num) >= (float8) PG_INT32_MIN && (num) < -((float8) PG_INT32_MIN))1103#define FLOAT8_FITS_IN_INT64(num) \1104 ((num) >= (float8) PG_INT64_MIN && (num) < -((float8) PG_INT64_MIN))1105 1106 1107/* ----------------------------------------------------------------1108 * Section 8: random stuff1109 * ----------------------------------------------------------------1110 */1111 1112/*1113 * Invert the sign of a qsort-style comparison result, ie, exchange negative1114 * and positive integer values, being careful not to get the wrong answer1115 * for INT_MIN. The argument should be an integral variable.1116 */1117#define INVERT_COMPARE_RESULT(var) \1118 ((var) = ((var) < 0) ? 1 : -(var))1119 1120/*1121 * Use this, not "char buf[BLCKSZ]", to declare a field or local variable1122 * holding a page buffer, if that page might be accessed as a page. Otherwise1123 * the variable might be under-aligned, causing problems on alignment-picky1124 * hardware. We include both "double" and "int64" in the union to ensure that1125 * the compiler knows the value must be MAXALIGN'ed (cf. configure's1126 * computation of MAXIMUM_ALIGNOF).1127 */1128typedef union PGAlignedBlock1129{1130 char data[BLCKSZ];1131 double force_align_d;1132 int64 force_align_i64;1133} PGAlignedBlock;1134 1135/*1136 * Use this to declare a field or local variable holding a page buffer, if that1137 * page might be accessed as a page or passed to an SMgr I/O function. If1138 * allocating using the MemoryContext API, the aligned allocation functions1139 * should be used with PG_IO_ALIGN_SIZE. This alignment may be more efficient1140 * for I/O in general, but may be strictly required on some platforms when1141 * using direct I/O.1142 */1143typedef union PGIOAlignedBlock1144{1145#ifdef pg_attribute_aligned1146 pg_attribute_aligned(PG_IO_ALIGN_SIZE)1147#endif1148 char data[BLCKSZ];1149 double force_align_d;1150 int64 force_align_i64;1151} PGIOAlignedBlock;1152 1153/* Same, but for an XLOG_BLCKSZ-sized buffer */1154typedef union PGAlignedXLogBlock1155{1156#ifdef pg_attribute_aligned1157 pg_attribute_aligned(PG_IO_ALIGN_SIZE)1158#endif1159 char data[XLOG_BLCKSZ];1160 double force_align_d;1161 int64 force_align_i64;1162} PGAlignedXLogBlock;1163 1164/* msb for char */1165#define HIGHBIT (0x80)1166#define IS_HIGHBIT_SET(ch) ((unsigned char)(ch) & HIGHBIT)1167 1168/*1169 * Support macros for escaping strings. escape_backslash should be true1170 * if generating a non-standard-conforming string. Prefixing a string1171 * with ESCAPE_STRING_SYNTAX guarantees it is non-standard-conforming.1172 * Beware of multiple evaluation of the "ch" argument!1173 */1174#define SQL_STR_DOUBLE(ch, escape_backslash) \1175 ((ch) == '\'' || ((ch) == '\\' && (escape_backslash)))1176 1177#define ESCAPE_STRING_SYNTAX 'E'1178 1179 1180#define STATUS_OK (0)1181#define STATUS_ERROR (-1)1182#define STATUS_EOF (-2)1183 1184/*1185 * gettext support1186 */1187 1188#ifndef ENABLE_NLS1189/* stuff we'd otherwise get from <libintl.h> */1190#define gettext(x) (x)1191#define dgettext(d,x) (x)1192#define ngettext(s,p,n) ((n) == 1 ? (s) : (p))1193#define dngettext(d,s,p,n) ((n) == 1 ? (s) : (p))1194#endif1195 1196#define _(x) gettext(x)1197 1198/*1199 * Use this to mark string constants as needing translation at some later1200 * time, rather than immediately. This is useful for cases where you need