From f1f39911e0d2d88c98eae96a3eb14a53c664206f Mon Sep 17 00:00:00 2001 From: Karen Arutyunov Date: Sat, 30 Nov 2019 22:37:25 +0300 Subject: Upgrade to 12.1 --- libpq/postgresql/c.h | 1107 -------------------------------------------------- 1 file changed, 1107 deletions(-) delete mode 100644 libpq/postgresql/c.h (limited to 'libpq/postgresql/c.h') diff --git a/libpq/postgresql/c.h b/libpq/postgresql/c.h deleted file mode 100644 index 726f0f3..0000000 --- a/libpq/postgresql/c.h +++ /dev/null @@ -1,1107 +0,0 @@ -/*------------------------------------------------------------------------- - * - * c.h - * Fundamental C definitions. This is included by every .c file in - * PostgreSQL (via either postgres.h or postgres_fe.h, as appropriate). - * - * Note that the definitions here are not intended to be exposed to clients - * of the frontend interface libraries --- so we don't worry much about - * polluting the namespace with lots of stuff... - * - * - * Portions Copyright (c) 1996-2016, PostgreSQL Global Development Group - * Portions Copyright (c) 1994, Regents of the University of California - * - * src/include/c.h - * - *------------------------------------------------------------------------- - */ -/* - *---------------------------------------------------------------- - * TABLE OF CONTENTS - * - * When adding stuff to this file, please try to put stuff - * into the relevant section, or add new sections as appropriate. - * - * section description - * ------- ------------------------------------------------ - * 0) pg_config.h and standard system headers - * 1) hacks to cope with non-ANSI C compilers - * 2) bool, true, false, TRUE, FALSE, NULL - * 3) standard system types - * 4) IsValid macros for system types - * 5) offsetof, lengthof, endof, alignment - * 6) assertions - * 7) widely useful macros - * 8) random stuff - * 9) system-specific hacks - * - * NOTE: since this file is included by both frontend and backend modules, it's - * almost certainly wrong to put an "extern" declaration here. typedefs and - * macros are the kind of thing that might go here. - * - *---------------------------------------------------------------- - */ -#ifndef C_H -#define C_H - -#include "postgres_ext.h" - -/* Must undef pg_config_ext.h symbols before including pg_config.h */ -#undef PG_INT64_TYPE - -#include "pg_config.h" -#include "pg_config_manual.h" /* must be after pg_config.h */ - -/* - * We always rely on the WIN32 macro being set by our build system, - * but _WIN32 is the compiler pre-defined macro. So make sure we define - * WIN32 whenever _WIN32 is set, to facilitate standalone building. - */ -#if defined(_WIN32) && !defined(WIN32) -#define WIN32 -#endif - -#if !defined(WIN32) && !defined(__CYGWIN__) /* win32 includes further down */ -#include "pg_config_os.h" /* must be before any system header files */ -#endif - -#if _MSC_VER >= 1400 || defined(HAVE_CRTDEFS_H) -#define errcode __msvc_errcode -#include -#undef errcode -#endif - -/* - * We have to include stdlib.h here because it defines many of these macros - * on some platforms, and we only want our definitions used if stdlib.h doesn't - * have its own. The same goes for stddef and stdarg if present. - */ - -#include -#include -#include -#include -#include -#ifdef HAVE_STRINGS_H -#include -#endif -#ifdef HAVE_STDINT_H -#include -#endif -#include - -#include -#if defined(WIN32) || defined(__CYGWIN__) -#include /* ensure O_BINARY is available */ -#endif - -#if defined(WIN32) || defined(__CYGWIN__) -/* We have to redefine some system functions after they are included above. */ -#include "pg_config_os.h" -#endif - -/* - * Force disable inlining if PG_FORCE_DISABLE_INLINE is defined. This is used - * to work around compiler bugs and might also be useful for investigatory - * purposes by defining the symbol in the platform's header.. - * - * This is done early (in slightly the wrong section) as functionality later - * in this file might want to rely on inline functions. - */ -#ifdef PG_FORCE_DISABLE_INLINE -#undef inline -#define inline -#endif - -/* Must be before gettext() games below */ -#include - -#define _(x) gettext(x) - -#ifdef ENABLE_NLS -#include -#else -#define gettext(x) (x) -#define dgettext(d,x) (x) -#define ngettext(s,p,n) ((n) == 1 ? (s) : (p)) -#define dngettext(d,s,p,n) ((n) == 1 ? (s) : (p)) -#endif - -/* - * Use this to mark string constants as needing translation at some later - * time, rather than immediately. This is useful for cases where you need - * access to the original string and translated string, and for cases where - * immediate translation is not possible, like when initializing global - * variables. - * http://www.gnu.org/software/autoconf/manual/gettext/Special-cases.html - */ -#define gettext_noop(x) (x) - - -/* ---------------------------------------------------------------- - * Section 1: hacks to cope with non-ANSI C compilers - * - * type prefixes (const, signed, volatile, inline) are handled in pg_config.h. - * ---------------------------------------------------------------- - */ - -/* - * CppAsString - * Convert the argument to a string, using the C preprocessor. - * CppConcat - * Concatenate two arguments together, using the C preprocessor. - * - * Note: There used to be support here for pre-ANSI C compilers that didn't - * support # and ##. Nowadays, these macros are just for clarity and/or - * backward compatibility with existing PostgreSQL code. - */ -#define CppAsString(identifier) #identifier -#define CppConcat(x, y) x##y - -/* - * dummyret is used to set return values in macros that use ?: to make - * assignments. gcc wants these to be void, other compilers like char - */ -#ifdef __GNUC__ /* GNU cc */ -#define dummyret void -#else -#define dummyret char -#endif - -/* Which __func__ symbol do we have, if any? */ -#ifdef HAVE_FUNCNAME__FUNC -#define PG_FUNCNAME_MACRO __func__ -#else -#ifdef HAVE_FUNCNAME__FUNCTION -#define PG_FUNCNAME_MACRO __FUNCTION__ -#else -#define PG_FUNCNAME_MACRO NULL -#endif -#endif - -/* ---------------------------------------------------------------- - * Section 2: bool, true, false, TRUE, FALSE, NULL - * ---------------------------------------------------------------- - */ - -/* - * bool - * Boolean value, either true or false. - * - * XXX for C++ compilers, we assume the compiler has a compatible - * built-in definition of bool. - */ - -#ifndef __cplusplus - -#ifndef bool -typedef char bool; -#endif - -#ifndef true -#define true ((bool) 1) -#endif - -#ifndef false -#define false ((bool) 0) -#endif -#endif /* not C++ */ - -typedef bool *BoolPtr; - -#ifndef TRUE -#define TRUE 1 -#endif - -#ifndef FALSE -#define FALSE 0 -#endif - -/* - * NULL - * Null pointer. - */ -#ifndef NULL -#define NULL ((void *) 0) -#endif - - -/* ---------------------------------------------------------------- - * Section 3: standard system types - * ---------------------------------------------------------------- - */ - -/* - * Pointer - * Variable holding address of any memory resident object. - * - * XXX Pointer arithmetic is done with this, so it can't be void * - * under "true" ANSI compilers. - */ -typedef char *Pointer; - -/* - * intN - * Signed integer, EXACTLY N BITS IN SIZE, - * used for numerical computations and the - * frontend/backend protocol. - */ -#ifndef HAVE_INT8 -typedef signed char int8; /* == 8 bits */ -typedef signed short int16; /* == 16 bits */ -typedef signed int int32; /* == 32 bits */ -#endif /* not HAVE_INT8 */ - -/* - * uintN - * Unsigned integer, EXACTLY N BITS IN SIZE, - * used for numerical computations and the - * frontend/backend protocol. - */ -#ifndef HAVE_UINT8 -typedef unsigned char uint8; /* == 8 bits */ -typedef unsigned short uint16; /* == 16 bits */ -typedef unsigned int uint32; /* == 32 bits */ -#endif /* not HAVE_UINT8 */ - -/* - * bitsN - * Unit of bitwise operation, AT LEAST N BITS IN SIZE. - */ -typedef uint8 bits8; /* >= 8 bits */ -typedef uint16 bits16; /* >= 16 bits */ -typedef uint32 bits32; /* >= 32 bits */ - -/* - * 64-bit integers - */ -#ifdef HAVE_LONG_INT_64 -/* Plain "long int" fits, use it */ - -#ifndef HAVE_INT64 -typedef long int int64; -#endif -#ifndef HAVE_UINT64 -typedef unsigned long int uint64; -#endif -#elif defined(HAVE_LONG_LONG_INT_64) -/* We have working support for "long long int", use that */ - -#ifndef HAVE_INT64 -typedef long long int int64; -#endif -#ifndef HAVE_UINT64 -typedef unsigned long long int uint64; -#endif -#else -/* neither HAVE_LONG_INT_64 nor HAVE_LONG_LONG_INT_64 */ -#error must have a working 64-bit integer datatype -#endif - -/* Decide if we need to decorate 64-bit constants */ -#ifdef HAVE_LL_CONSTANTS -#define INT64CONST(x) ((int64) x##LL) -#define UINT64CONST(x) ((uint64) x##ULL) -#else -#define INT64CONST(x) ((int64) x) -#define UINT64CONST(x) ((uint64) x) -#endif - -/* snprintf format strings to use for 64-bit integers */ -#define INT64_FORMAT "%" INT64_MODIFIER "d" -#define UINT64_FORMAT "%" INT64_MODIFIER "u" - -/* - * 128-bit signed and unsigned integers - * There currently is only a limited support for the type. E.g. 128bit - * literals and snprintf are not supported; but math is. - */ -#if defined(PG_INT128_TYPE) -#define HAVE_INT128 -typedef PG_INT128_TYPE int128; -typedef unsigned PG_INT128_TYPE uint128; -#endif - -/* - * stdint.h limits aren't guaranteed to be present and aren't guaranteed to - * have compatible types with our fixed width types. So just define our own. - */ -#define PG_INT8_MIN (-0x7F-1) -#define PG_INT8_MAX (0x7F) -#define PG_UINT8_MAX (0xFF) -#define PG_INT16_MIN (-0x7FFF-1) -#define PG_INT16_MAX (0x7FFF) -#define PG_UINT16_MAX (0xFFFF) -#define PG_INT32_MIN (-0x7FFFFFFF-1) -#define PG_INT32_MAX (0x7FFFFFFF) -#define PG_UINT32_MAX (0xFFFFFFFF) -#define PG_INT64_MIN (-INT64CONST(0x7FFFFFFFFFFFFFFF) - 1) -#define PG_INT64_MAX INT64CONST(0x7FFFFFFFFFFFFFFF) -#define PG_UINT64_MAX UINT64CONST(0xFFFFFFFFFFFFFFFF) - -/* Select timestamp representation (float8 or int64) */ -#ifdef USE_INTEGER_DATETIMES -#define HAVE_INT64_TIMESTAMP -#endif - -/* - * Size - * Size of any memory resident object, as returned by sizeof. - */ -typedef size_t Size; - -/* - * Index - * Index into any memory resident array. - * - * Note: - * Indices are non negative. - */ -typedef unsigned int Index; - -/* - * Offset - * Offset into any memory resident array. - * - * Note: - * This differs from an Index in that an Index is always - * non negative, whereas Offset may be negative. - */ -typedef signed int Offset; - -/* - * Common Postgres datatype names (as used in the catalogs) - */ -typedef float float4; -typedef double float8; - -/* - * Oid, RegProcedure, TransactionId, SubTransactionId, MultiXactId, - * CommandId - */ - -/* typedef Oid is in postgres_ext.h */ - -/* - * regproc is the type name used in the include/catalog headers, but - * RegProcedure is the preferred name in C code. - */ -typedef Oid regproc; -typedef regproc RegProcedure; - -typedef uint32 TransactionId; - -typedef uint32 LocalTransactionId; - -typedef uint32 SubTransactionId; - -#define InvalidSubTransactionId ((SubTransactionId) 0) -#define TopSubTransactionId ((SubTransactionId) 1) - -/* MultiXactId must be equivalent to TransactionId, to fit in t_xmax */ -typedef TransactionId MultiXactId; - -typedef uint32 MultiXactOffset; - -typedef uint32 CommandId; - -#define FirstCommandId ((CommandId) 0) -#define InvalidCommandId (~(CommandId)0) - -/* - * Array indexing support - */ -#define MAXDIM 6 -typedef struct -{ - int indx[MAXDIM]; -} IntArray; - -/* ---------------- - * Variable-length datatypes all share the 'struct varlena' header. - * - * NOTE: for TOASTable types, this is an oversimplification, since the value - * may be compressed or moved out-of-line. However datatype-specific routines - * are mostly content to deal with de-TOASTed values only, and of course - * client-side routines should never see a TOASTed value. But even in a - * de-TOASTed value, beware of touching vl_len_ directly, as its representation - * is no longer convenient. It's recommended that code always use the VARDATA, - * VARSIZE, and SET_VARSIZE macros instead of relying on direct mentions of - * the struct fields. See postgres.h for details of the TOASTed form. - * ---------------- - */ -struct varlena -{ - char vl_len_[4]; /* Do not touch this field directly! */ - char vl_dat[FLEXIBLE_ARRAY_MEMBER]; /* Data content is here */ -}; - -#define VARHDRSZ ((int32) sizeof(int32)) - -/* - * These widely-used datatypes are just a varlena header and the data bytes. - * There is no terminating null or anything like that --- the data length is - * always VARSIZE(ptr) - VARHDRSZ. - */ -typedef struct varlena bytea; -typedef struct varlena text; -typedef struct varlena BpChar; /* blank-padded char, ie SQL char(n) */ -typedef struct varlena VarChar; /* var-length char, ie SQL varchar(n) */ - -/* - * Specialized array types. These are physically laid out just the same - * as regular arrays (so that the regular array subscripting code works - * with them). They exist as distinct types mostly for historical reasons: - * they have nonstandard I/O behavior which we don't want to change for fear - * of breaking applications that look at the system catalogs. There is also - * an implementation issue for oidvector: it's part of the primary key for - * pg_proc, and we can't use the normal btree array support routines for that - * without circularity. - */ -typedef struct -{ - int32 vl_len_; /* these fields must match ArrayType! */ - int ndim; /* always 1 for int2vector */ - int32 dataoffset; /* always 0 for int2vector */ - Oid elemtype; - int dim1; - int lbound1; - int16 values[FLEXIBLE_ARRAY_MEMBER]; -} int2vector; - -typedef struct -{ - int32 vl_len_; /* these fields must match ArrayType! */ - int ndim; /* always 1 for oidvector */ - int32 dataoffset; /* always 0 for oidvector */ - Oid elemtype; - int dim1; - int lbound1; - Oid values[FLEXIBLE_ARRAY_MEMBER]; -} oidvector; - -/* - * Representation of a Name: effectively just a C string, but null-padded to - * exactly NAMEDATALEN bytes. The use of a struct is historical. - */ -typedef struct nameData -{ - char data[NAMEDATALEN]; -} NameData; -typedef NameData *Name; - -#define NameStr(name) ((name).data) - -/* - * Support macros for escaping strings. escape_backslash should be TRUE - * if generating a non-standard-conforming string. Prefixing a string - * with ESCAPE_STRING_SYNTAX guarantees it is non-standard-conforming. - * Beware of multiple evaluation of the "ch" argument! - */ -#define SQL_STR_DOUBLE(ch, escape_backslash) \ - ((ch) == '\'' || ((ch) == '\\' && (escape_backslash))) - -#define ESCAPE_STRING_SYNTAX 'E' - -/* ---------------------------------------------------------------- - * Section 4: IsValid macros for system types - * ---------------------------------------------------------------- - */ -/* - * BoolIsValid - * True iff bool is valid. - */ -#define BoolIsValid(boolean) ((boolean) == false || (boolean) == true) - -/* - * PointerIsValid - * True iff pointer is valid. - */ -#define PointerIsValid(pointer) ((const void*)(pointer) != NULL) - -/* - * PointerIsAligned - * True iff pointer is properly aligned to point to the given type. - */ -#define PointerIsAligned(pointer, type) \ - (((uintptr_t)(pointer) % (sizeof (type))) == 0) - -#define OidIsValid(objectId) ((bool) ((objectId) != InvalidOid)) - -#define RegProcedureIsValid(p) OidIsValid(p) - - -/* ---------------------------------------------------------------- - * Section 5: offsetof, lengthof, endof, alignment - * ---------------------------------------------------------------- - */ -/* - * offsetof - * Offset of a structure/union field within that structure/union. - * - * XXX This is supposed to be part of stddef.h, but isn't on - * some systems (like SunOS 4). - */ -#ifndef offsetof -#define offsetof(type, field) ((long) &((type *)0)->field) -#endif /* offsetof */ - -/* - * lengthof - * Number of elements in an array. - */ -#define lengthof(array) (sizeof (array) / sizeof ((array)[0])) - -/* - * endof - * Address of the element one past the last in an array. - */ -#define endof(array) (&(array)[lengthof(array)]) - -/* ---------------- - * Alignment macros: align a length or address appropriately for a given type. - * The fooALIGN() macros round up to a multiple of the required alignment, - * while the fooALIGN_DOWN() macros round down. The latter are more useful - * for problems like "how many X-sized structures will fit in a page?". - * - * NOTE: TYPEALIGN[_DOWN] will not work if ALIGNVAL is not a power of 2. - * That case seems extremely unlikely to be needed in practice, however. - * ---------------- - */ - -#define TYPEALIGN(ALIGNVAL,LEN) \ - (((uintptr_t) (LEN) + ((ALIGNVAL) - 1)) & ~((uintptr_t) ((ALIGNVAL) - 1))) - -#define SHORTALIGN(LEN) TYPEALIGN(ALIGNOF_SHORT, (LEN)) -#define INTALIGN(LEN) TYPEALIGN(ALIGNOF_INT, (LEN)) -#define LONGALIGN(LEN) TYPEALIGN(ALIGNOF_LONG, (LEN)) -#define DOUBLEALIGN(LEN) TYPEALIGN(ALIGNOF_DOUBLE, (LEN)) -#define MAXALIGN(LEN) TYPEALIGN(MAXIMUM_ALIGNOF, (LEN)) -/* MAXALIGN covers only built-in types, not buffers */ -#define BUFFERALIGN(LEN) TYPEALIGN(ALIGNOF_BUFFER, (LEN)) -#define CACHELINEALIGN(LEN) TYPEALIGN(PG_CACHE_LINE_SIZE, (LEN)) - -#define TYPEALIGN_DOWN(ALIGNVAL,LEN) \ - (((uintptr_t) (LEN)) & ~((uintptr_t) ((ALIGNVAL) - 1))) - -#define SHORTALIGN_DOWN(LEN) TYPEALIGN_DOWN(ALIGNOF_SHORT, (LEN)) -#define INTALIGN_DOWN(LEN) TYPEALIGN_DOWN(ALIGNOF_INT, (LEN)) -#define LONGALIGN_DOWN(LEN) TYPEALIGN_DOWN(ALIGNOF_LONG, (LEN)) -#define DOUBLEALIGN_DOWN(LEN) TYPEALIGN_DOWN(ALIGNOF_DOUBLE, (LEN)) -#define MAXALIGN_DOWN(LEN) TYPEALIGN_DOWN(MAXIMUM_ALIGNOF, (LEN)) - -/* - * The above macros will not work with types wider than uintptr_t, like with - * uint64 on 32-bit platforms. That's not problem for the usual use where a - * pointer or a length is aligned, but for the odd case that you need to - * align something (potentially) wider, use TYPEALIGN64. - */ -#define TYPEALIGN64(ALIGNVAL,LEN) \ - (((uint64) (LEN) + ((ALIGNVAL) - 1)) & ~((uint64) ((ALIGNVAL) - 1))) - -/* we don't currently need wider versions of the other ALIGN macros */ -#define MAXALIGN64(LEN) TYPEALIGN64(MAXIMUM_ALIGNOF, (LEN)) - -/* ---------------- - * Attribute macros - * - * GCC: https://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html - * GCC: https://gcc.gnu.org/onlinedocs/gcc/Type-Attributes.html - * Sunpro: https://docs.oracle.com/cd/E18659_01/html/821-1384/gjzke.html - * XLC: http://www-01.ibm.com/support/knowledgecenter/SSGH2K_11.1.0/com.ibm.xlc111.aix.doc/language_ref/function_attributes.html - * XLC: http://www-01.ibm.com/support/knowledgecenter/SSGH2K_11.1.0/com.ibm.xlc111.aix.doc/language_ref/type_attrib.html - * ---------------- - */ - -/* only GCC supports the unused attribute */ -#ifdef __GNUC__ -#define pg_attribute_unused() __attribute__((unused)) -#else -#define pg_attribute_unused() -#endif - -/* GCC and XLC support format attributes */ -#if defined(__GNUC__) || defined(__IBMC__) -#define pg_attribute_format_arg(a) __attribute__((format_arg(a))) -#define pg_attribute_printf(f,a) __attribute__((format(PG_PRINTF_ATTRIBUTE, f, a))) -#else -#define pg_attribute_format_arg(a) -#define pg_attribute_printf(f,a) -#endif - -/* GCC, Sunpro and XLC support aligned, packed and noreturn */ -#if defined(__GNUC__) || defined(__SUNPRO_C) || defined(__IBMC__) -#define pg_attribute_aligned(a) __attribute__((aligned(a))) -#define pg_attribute_noreturn() __attribute__((noreturn)) -#define pg_attribute_packed() __attribute__((packed)) -#define HAVE_PG_ATTRIBUTE_NORETURN 1 -#else -/* - * NB: aligned and packed are not given default definitions because they - * affect code functionality; they *must* be implemented by the compiler - * if they are to be used. - */ -#define pg_attribute_noreturn() -#endif - -/* ---------------------------------------------------------------- - * Section 6: assertions - * ---------------------------------------------------------------- - */ - -/* - * USE_ASSERT_CHECKING, if defined, turns on all the assertions. - * - plai 9/5/90 - * - * It should _NOT_ be defined in releases or in benchmark copies - */ - -/* - * Assert() can be used in both frontend and backend code. In frontend code it - * just calls the standard assert, if it's available. If use of assertions is - * not configured, it does nothing. - */ -#ifndef USE_ASSERT_CHECKING - -#define Assert(condition) ((void)true) -#define AssertMacro(condition) ((void)true) -#define AssertArg(condition) ((void)true) -#define AssertState(condition) ((void)true) -#define AssertPointerAlignment(ptr, bndr) ((void)true) -#define Trap(condition, errorType) ((void)true) -#define TrapMacro(condition, errorType) (true) - -#elif defined(FRONTEND) - -#include -#define Assert(p) assert(p) -#define AssertMacro(p) ((void) assert(p)) -#define AssertArg(condition) assert(condition) -#define AssertState(condition) assert(condition) -#define AssertPointerAlignment(ptr, bndr) ((void)true) -#else /* USE_ASSERT_CHECKING && !FRONTEND */ - -/* - * Trap - * Generates an exception if the given condition is true. - */ -#define Trap(condition, errorType) \ - do { \ - if (condition) \ - ExceptionalCondition(CppAsString(condition), (errorType), \ - __FILE__, __LINE__); \ - } while (0) - -/* - * TrapMacro is the same as Trap but it's intended for use in macros: - * - * #define foo(x) (AssertMacro(x != 0), bar(x)) - * - * Isn't CPP fun? - */ -#define TrapMacro(condition, errorType) \ - ((bool) (! (condition) || \ - (ExceptionalCondition(CppAsString(condition), (errorType), \ - __FILE__, __LINE__), 0))) - -#define Assert(condition) \ - Trap(!(condition), "FailedAssertion") - -#define AssertMacro(condition) \ - ((void) TrapMacro(!(condition), "FailedAssertion")) - -#define AssertArg(condition) \ - Trap(!(condition), "BadArgument") - -#define AssertState(condition) \ - Trap(!(condition), "BadState") - -/* - * Check that `ptr' is `bndr' aligned. - */ -#define AssertPointerAlignment(ptr, bndr) \ - Trap(TYPEALIGN(bndr, (uintptr_t)(ptr)) != (uintptr_t)(ptr), \ - "UnalignedPointer") - -#endif /* USE_ASSERT_CHECKING && !FRONTEND */ - -/* - * Macros to support compile-time assertion checks. - * - * If the "condition" (a compile-time-constant expression) evaluates to false, - * throw a compile error using the "errmessage" (a string literal). - * - * gcc 4.6 and up supports _Static_assert(), but there are bizarre syntactic - * placement restrictions. These macros make it safe to use as a statement - * or in an expression, respectively. - * - * Otherwise we fall back on a kluge that assumes the compiler will complain - * about a negative width for a struct bit-field. This will not include a - * helpful error message, but it beats not getting an error at all. - */ -#ifdef HAVE__STATIC_ASSERT -#define StaticAssertStmt(condition, errmessage) \ - do { _Static_assert(condition, errmessage); } while(0) -#define StaticAssertExpr(condition, errmessage) \ - ({ StaticAssertStmt(condition, errmessage); true; }) -#else /* !HAVE__STATIC_ASSERT */ -#define StaticAssertStmt(condition, errmessage) \ - ((void) sizeof(struct { int static_assert_failure : (condition) ? 1 : -1; })) -#define StaticAssertExpr(condition, errmessage) \ - StaticAssertStmt(condition, errmessage) -#endif /* HAVE__STATIC_ASSERT */ - - -/* - * Compile-time checks that a variable (or expression) has the specified type. - * - * AssertVariableIsOfType() can be used as a statement. - * AssertVariableIsOfTypeMacro() is intended for use in macros, eg - * #define foo(x) (AssertVariableIsOfTypeMacro(x, int), bar(x)) - * - * If we don't have __builtin_types_compatible_p, we can still assert that - * the types have the same size. This is far from ideal (especially on 32-bit - * platforms) but it provides at least some coverage. - */ -#ifdef HAVE__BUILTIN_TYPES_COMPATIBLE_P -#define AssertVariableIsOfType(varname, typename) \ - StaticAssertStmt(__builtin_types_compatible_p(__typeof__(varname), typename), \ - CppAsString(varname) " does not have type " CppAsString(typename)) -#define AssertVariableIsOfTypeMacro(varname, typename) \ - ((void) StaticAssertExpr(__builtin_types_compatible_p(__typeof__(varname), typename), \ - CppAsString(varname) " does not have type " CppAsString(typename))) -#else /* !HAVE__BUILTIN_TYPES_COMPATIBLE_P */ -#define AssertVariableIsOfType(varname, typename) \ - StaticAssertStmt(sizeof(varname) == sizeof(typename), \ - CppAsString(varname) " does not have type " CppAsString(typename)) -#define AssertVariableIsOfTypeMacro(varname, typename) \ - ((void) StaticAssertExpr(sizeof(varname) == sizeof(typename), \ - CppAsString(varname) " does not have type " CppAsString(typename))) -#endif /* HAVE__BUILTIN_TYPES_COMPATIBLE_P */ - - -/* ---------------------------------------------------------------- - * Section 7: widely useful macros - * ---------------------------------------------------------------- - */ -/* - * Max - * Return the maximum of two numbers. - */ -#define Max(x, y) ((x) > (y) ? (x) : (y)) - -/* - * Min - * Return the minimum of two numbers. - */ -#define Min(x, y) ((x) < (y) ? (x) : (y)) - -/* - * Abs - * Return the absolute value of the argument. - */ -#define Abs(x) ((x) >= 0 ? (x) : -(x)) - -/* - * StrNCpy - * Like standard library function strncpy(), except that result string - * is guaranteed to be null-terminated --- that is, at most N-1 bytes - * of the source string will be kept. - * Also, the macro returns no result (too hard to do that without - * evaluating the arguments multiple times, which seems worse). - * - * BTW: when you need to copy a non-null-terminated string (like a text - * datum) and add a null, do not do it with StrNCpy(..., len+1). That - * might seem to work, but it fetches one byte more than there is in the - * text object. One fine day you'll have a SIGSEGV because there isn't - * another byte before the end of memory. Don't laugh, we've had real - * live bug reports from real live users over exactly this mistake. - * Do it honestly with "memcpy(dst,src,len); dst[len] = '\0';", instead. - */ -#define StrNCpy(dst,src,len) \ - do \ - { \ - char * _dst = (dst); \ - Size _len = (len); \ -\ - if (_len > 0) \ - { \ - strncpy(_dst, (src), _len); \ - _dst[_len-1] = '\0'; \ - } \ - } while (0) - - -/* Get a bit mask of the bits set in non-long aligned addresses */ -#define LONG_ALIGN_MASK (sizeof(long) - 1) - -/* - * MemSet - * Exactly the same as standard library function memset(), but considerably - * faster for zeroing small word-aligned structures (such as parsetree nodes). - * This has to be a macro because the main point is to avoid function-call - * overhead. However, we have also found that the loop is faster than - * native libc memset() on some platforms, even those with assembler - * memset() functions. More research needs to be done, perhaps with - * MEMSET_LOOP_LIMIT tests in configure. - */ -#define MemSet(start, val, len) \ - do \ - { \ - /* must be void* because we don't know if it is integer aligned yet */ \ - void *_vstart = (void *) (start); \ - int _val = (val); \ - Size _len = (len); \ -\ - if ((((uintptr_t) _vstart) & LONG_ALIGN_MASK) == 0 && \ - (_len & LONG_ALIGN_MASK) == 0 && \ - _val == 0 && \ - _len <= MEMSET_LOOP_LIMIT && \ - /* \ - * If MEMSET_LOOP_LIMIT == 0, optimizer should find \ - * the whole "if" false at compile time. \ - */ \ - MEMSET_LOOP_LIMIT != 0) \ - { \ - long *_start = (long *) _vstart; \ - long *_stop = (long *) ((char *) _start + _len); \ - while (_start < _stop) \ - *_start++ = 0; \ - } \ - else \ - memset(_vstart, _val, _len); \ - } while (0) - -/* - * MemSetAligned is the same as MemSet except it omits the test to see if - * "start" is word-aligned. This is okay to use if the caller knows a-priori - * that the pointer is suitably aligned (typically, because he just got it - * from palloc(), which always delivers a max-aligned pointer). - */ -#define MemSetAligned(start, val, len) \ - do \ - { \ - long *_start = (long *) (start); \ - int _val = (val); \ - Size _len = (len); \ -\ - if ((_len & LONG_ALIGN_MASK) == 0 && \ - _val == 0 && \ - _len <= MEMSET_LOOP_LIMIT && \ - MEMSET_LOOP_LIMIT != 0) \ - { \ - long *_stop = (long *) ((char *) _start + _len); \ - while (_start < _stop) \ - *_start++ = 0; \ - } \ - else \ - memset(_start, _val, _len); \ - } while (0) - - -/* - * MemSetTest/MemSetLoop are a variant version that allow all the tests in - * MemSet to be done at compile time in cases where "val" and "len" are - * constants *and* we know the "start" pointer must be word-aligned. - * If MemSetTest succeeds, then it is okay to use MemSetLoop, otherwise use - * MemSetAligned. Beware of multiple evaluations of the arguments when using - * this approach. - */ -#define MemSetTest(val, len) \ - ( ((len) & LONG_ALIGN_MASK) == 0 && \ - (len) <= MEMSET_LOOP_LIMIT && \ - MEMSET_LOOP_LIMIT != 0 && \ - (val) == 0 ) - -#define MemSetLoop(start, val, len) \ - do \ - { \ - long * _start = (long *) (start); \ - long * _stop = (long *) ((char *) _start + (Size) (len)); \ - \ - while (_start < _stop) \ - *_start++ = 0; \ - } while (0) - - -/* - * Mark a point as unreachable in a portable fashion. This should preferably - * be something that the compiler understands, to aid code generation. - * In assert-enabled builds, we prefer abort() for debugging reasons. - */ -#if defined(HAVE__BUILTIN_UNREACHABLE) && !defined(USE_ASSERT_CHECKING) -#define pg_unreachable() __builtin_unreachable() -#elif defined(_MSC_VER) && !defined(USE_ASSERT_CHECKING) -#define pg_unreachable() __assume(0) -#else -#define pg_unreachable() abort() -#endif - - -/* ---------------------------------------------------------------- - * Section 8: random stuff - * ---------------------------------------------------------------- - */ - -/* msb for char */ -#define HIGHBIT (0x80) -#define IS_HIGHBIT_SET(ch) ((unsigned char)(ch) & HIGHBIT) - -#define STATUS_OK (0) -#define STATUS_ERROR (-1) -#define STATUS_EOF (-2) -#define STATUS_FOUND (1) -#define STATUS_WAITING (2) - - -/* - * Append PG_USED_FOR_ASSERTS_ONLY to definitions of variables that are only - * used in assert-enabled builds, to avoid compiler warnings about unused - * variables in assert-disabled builds. - */ -#ifdef USE_ASSERT_CHECKING -#define PG_USED_FOR_ASSERTS_ONLY -#else -#define PG_USED_FOR_ASSERTS_ONLY pg_attribute_unused() -#endif - - -/* gettext domain name mangling */ - -/* - * To better support parallel installations of major PostgreSQL - * versions as well as parallel installations of major library soname - * versions, we mangle the gettext domain name by appending those - * version numbers. The coding rule ought to be that wherever the - * domain name is mentioned as a literal, it must be wrapped into - * PG_TEXTDOMAIN(). The macros below do not work on non-literals; but - * that is somewhat intentional because it avoids having to worry - * about multiple states of premangling and postmangling as the values - * are being passed around. - * - * Make sure this matches the installation rules in nls-global.mk. - */ - -/* need a second indirection because we want to stringize the macro value, not the name */ -#define CppAsString2(x) CppAsString(x) - -#ifdef SO_MAJOR_VERSION -#define PG_TEXTDOMAIN(domain) (domain CppAsString2(SO_MAJOR_VERSION) "-" PG_MAJORVERSION) -#else -#define PG_TEXTDOMAIN(domain) (domain "-" PG_MAJORVERSION) -#endif - - -/* ---------------------------------------------------------------- - * Section 9: system-specific hacks - * - * This should be limited to things that absolutely have to be - * included in every source file. The port-specific header file - * is usually a better place for this sort of thing. - * ---------------------------------------------------------------- - */ - -/* - * NOTE: this is also used for opening text files. - * WIN32 treats Control-Z as EOF in files opened in text mode. - * Therefore, we open files in binary mode on Win32 so we can read - * literal control-Z. The other affect is that we see CRLF, but - * that is OK because we can already handle those cleanly. - */ -#if defined(WIN32) || defined(__CYGWIN__) -#define PG_BINARY O_BINARY -#define PG_BINARY_A "ab" -#define PG_BINARY_R "rb" -#define PG_BINARY_W "wb" -#else -#define PG_BINARY 0 -#define PG_BINARY_A "a" -#define PG_BINARY_R "r" -#define PG_BINARY_W "w" -#endif - -/* - * Provide prototypes for routines not present in a particular machine's - * standard C library. - */ - -#if !HAVE_DECL_SNPRINTF -extern int snprintf(char *str, size_t count, const char *fmt,...) pg_attribute_printf(3, 4); -#endif - -#if !HAVE_DECL_VSNPRINTF -extern int vsnprintf(char *str, size_t count, const char *fmt, va_list args); -#endif - -#if !defined(HAVE_MEMMOVE) && !defined(memmove) -#define memmove(d, s, c) bcopy(s, d, c) -#endif - -/* no special DLL markers on most ports */ -#ifndef PGDLLIMPORT -#define PGDLLIMPORT -#endif -#ifndef PGDLLEXPORT -#define PGDLLEXPORT -#endif - -/* - * The following is used as the arg list for signal handlers. Any ports - * that take something other than an int argument should override this in - * their pg_config_os.h file. Note that variable names are required - * because it is used in both the prototypes as well as the definitions. - * Note also the long name. We expect that this won't collide with - * other names causing compiler warnings. - */ - -#ifndef SIGNAL_ARGS -#define SIGNAL_ARGS int postgres_signal_arg -#endif - -/* - * When there is no sigsetjmp, its functionality is provided by plain - * setjmp. Incidentally, nothing provides setjmp's functionality in - * that case. We now support the case only on Windows. - */ -#ifdef WIN32 -#define sigjmp_buf jmp_buf -#define sigsetjmp(x,y) setjmp(x) -#define siglongjmp longjmp -#endif - -#if defined(HAVE_FDATASYNC) && !HAVE_DECL_FDATASYNC -extern int fdatasync(int fildes); -#endif - -/* If strtoq() exists, rename it to the more standard strtoll() */ -#if defined(HAVE_LONG_LONG_INT_64) && !defined(HAVE_STRTOLL) && defined(HAVE_STRTOQ) -#define strtoll strtoq -#define HAVE_STRTOLL 1 -#endif - -/* If strtouq() exists, rename it to the more standard strtoull() */ -#if defined(HAVE_LONG_LONG_INT_64) && !defined(HAVE_STRTOULL) && defined(HAVE_STRTOUQ) -#define strtoull strtouq -#define HAVE_STRTOULL 1 -#endif - -/* - * We assume if we have these two functions, we have their friends too, and - * can use the wide-character functions. - */ -#if defined(HAVE_WCSTOMBS) && defined(HAVE_TOWLOWER) -#define USE_WIDE_UPPER_LOWER -#endif - -/* EXEC_BACKEND defines */ -#ifdef EXEC_BACKEND -#define NON_EXEC_STATIC -#else -#define NON_EXEC_STATIC static -#endif - -/* /port compatibility functions */ -#include "port.h" - -#endif /* C_H */ -- cgit v1.1