From 83311355d78607e5c84ded555759f1d78dd466ea Mon Sep 17 00:00:00 2001 From: "Marc G. Fournier" Date: Thu, 31 Oct 1996 07:10:14 +0000 Subject: [PATCH] Add these files to ${SRCDIR}/include --- src/include/c.h | 768 ++++++++++++++++++++++++++++++++++++++++++++++++ src/include/miscadmin.h | 185 ++++++++++++ src/include/postgres.h | 226 ++++++++++++++ 3 files changed, 1179 insertions(+) create mode 100644 src/include/c.h create mode 100644 src/include/miscadmin.h create mode 100644 src/include/postgres.h diff --git a/src/include/c.h b/src/include/c.h new file mode 100644 index 0000000000..3433eaf793 --- /dev/null +++ b/src/include/c.h @@ -0,0 +1,768 @@ +/*------------------------------------------------------------------------- + * + * c.h-- + * Fundamental C definitions. This is included by every .c file in + * postgres. + * + * + * Copyright (c) 1994, Regents of the University of California + * + * $Id: c.h,v 1.1 1996/10/31 07:10:12 scrappy Exp $ + * + *------------------------------------------------------------------------- + */ +/* + * TABLE OF CONTENTS + * + * When adding stuff to this file, please try and put stuff + * into the relevant section, or add new sections as appropriate. + * + * section description + * ------- ------------------------------------------------ + * 1) bool, true, false, TRUE, FALSE + * 2) __STDC__, non-ansi C definitions: + * Pointer typedef, NULL + * cpp magic macros + * type prefixes: const, signed, volatile, inline + * 3) standard system types + * 4) datum type + * 5) IsValid macros for system types + * 6) offsetof, lengthof, endof + * 7) exception handling definitions, Assert, Trap, etc macros + * 8) Min, Max, Abs macros + * 9) externs + * 10) Berkeley-specific defs + * 11) system-specific hacks + * + * NOTES + * + * This file is MACHINE AND COMPILER dependent!!! (For now.) + * + * ---------------------------------------------------------------- + */ +#ifndef C_H +#define C_H + +/* ---------------------------------------------------------------- + * Section 1: bool, true, false, TRUE, FALSE + * ---------------------------------------------------------------- + */ +/* + * bool -- + * Boolean value, either true or false. + * + */ +#define false ((char) 0) +#define true ((char) 1) +typedef char bool; +typedef bool *BoolPtr; + +#ifndef TRUE +#define TRUE 1 +#endif /* TRUE */ + +#ifndef FALSE +#define FALSE 0 +#endif /* FALSE */ + +/* ---------------------------------------------------------------- + * Section 2: __STDC__, non-ansi C definitions: + * + * cpp magic macros + * Pointer typedef, NULL + * type prefixes: const, signed, volatile, inline + * ---------------------------------------------------------------- + */ + +#ifdef __STDC__ /* ANSI C */ + +/* + * 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; + +#ifndef NULL +/* + * NULL -- + * Null pointer. + */ +#define NULL ((void *) 0) +#endif /* !defined(NULL) */ + +#define HAVE_ANSI_CPP /* all ANSI C compilers must have this! */ +#if defined(NEED_STD_HDRS) +#undef NEED_STD_HDRS /* all ANSI systems must have stddef/stdlib */ +#endif /* NEED_STD_HDRS */ + +#else /* !defined(__STDC__) */ /* NOT ANSI C */ + +/* + * Pointer -- + * Variable containing address of any memory resident object. + */ +typedef char *Pointer; + +#ifndef NULL +/* + * NULL -- + * Null pointer. + */ +#define NULL 0 +#endif /* !defined(NULL) */ + +/* + * const -- + * Type modifier. Identifies read only variables. + * + * Example: + * extern const Version RomVersion; + */ +#define const /* const */ + +/* + * signed -- + * Type modifier. Identifies signed integral types. + */ +#define signed /* signed */ + +/* + * volatile -- + * Type modifier. Identifies variables which may change in ways not + * noticeable by the compiler, e.g. via asynchronous interrupts. + * + * Example: + * extern volatile unsigned int NumberOfInterrupts; + */ +#define volatile /* volatile */ + +#endif /* !defined(__STDC__) */ /* NOT ANSI C */ + +/* + * CppAsString -- + * Convert the argument to a string, using the C preprocessor. + * CppConcat -- + * Concatenate two arguments together, using the C preprocessor. + */ +#if defined(HAVE_ANSI_CPP) + +#define CppAsString(identifier) #identifier +#define CppConcat(x, y) x##y +#define CppConcat0(x, y) x##y +#define CppConcat1(x, y) x##y +#define CppConcat2(x, y) x##y +#define CppConcat3(x, y) x##y +#define CppConcat4(x, y) x##y + +#else /* !HAVE_ANSI_CPP */ + +#define CppAsString(identifier) "identifier" + +/* + * CppIdentity -- On Reiser based cpp's this is used to concatenate + * two tokens. That is + * CppIdentity(A)B ==> AB + * We renamed it to _private_CppIdentity because it should not + * be referenced outside this file. On other cpp's it + * produces A B. + */ +#define _priv_CppIdentity(x)x +#define CppConcat(x, y) _priv_CppIdentity(x)y +#define CppConcat0(x, y) _priv_CppIdentity(x)y +#define CppConcat1(x, y) _priv_CppIdentity(x)y +#define CppConcat2(x, y) _priv_CppIdentity(x)y +#define CppConcat3(x, y) _priv_CppIdentity(x)y +#define CppConcat4(x, y) _priv_CppIdentity(x)y + +#endif /* !HAVE_ANSI_CPP */ + +#ifndef __GNUC__ /* GNU cc */ +# define inline +#endif + +#if defined(NEED_STD_HDRS) +/* + * You're doomed. We've removed almost all of our own C library + * extern declarations because they conflict on the different + * systems. You'll have to write your own stdlib.h. + */ +#include "stdlib.h" +#else /* NEED_STD_HDRS */ +#include +#include +#endif /* NEED_STD_HDRS */ + +/* ---------------------------------------------------------------- + * Section 3: standard system types + * ---------------------------------------------------------------- + */ + +/* + * intN -- + * Signed integer, AT LEAST N BITS IN SIZE, + * used for numerical computations. + */ +typedef signed char int8; /* >= 8 bits */ +typedef signed short int16; /* >= 16 bits */ +typedef signed int int32; /* >= 32 bits */ + +/* + * uintN -- + * Unsigned integer, AT LEAST N BITS IN SIZE, + * used for numerical computations. + */ +typedef unsigned char uint8; /* >= 8 bits */ +typedef unsigned short uint16; /* >= 16 bits */ +typedef unsigned int uint32; /* >= 32 bits */ + +/* + * floatN -- + * Floating point number, AT LEAST N BITS IN SIZE, + * used for numerical computations. + * + * Since sizeof(floatN) may be > sizeof(char *), always pass + * floatN by reference. + */ +typedef float float32data; +typedef double float64data; +typedef float *float32; +typedef double *float64; + +/* + * boolN -- + * Boolean value, AT LEAST N BITS IN SIZE. + */ +typedef uint8 bool8; /* >= 8 bits */ +typedef uint16 bool16; /* >= 16 bits */ +typedef uint32 bool32; /* >= 32 bits */ + +/* + * 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 */ + +/* + * wordN -- + * Unit of storage, AT LEAST N BITS IN SIZE, + * used to fetch/store data. + */ +typedef uint8 word8; /* >= 8 bits */ +typedef uint16 word16; /* >= 16 bits */ +typedef uint32 word32; /* >= 32 bits */ + +/* + * Size -- + * Size of any memory resident object, as returned by sizeof. + */ +typedef unsigned int Size; + +/* + * Index -- + * Index into any memory resident array. + * + * Note: + * Indices are non negative. + */ +typedef unsigned int Index; + +#define MAXDIM 6 +typedef struct { + int indx[MAXDIM]; +} IntArray; + +/* + * 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; + +/* ---------------------------------------------------------------- + * Section 4: datum type + support macros + * ---------------------------------------------------------------- + */ +/* + * datum.h -- + * POSTGRES abstract data type datum representation definitions. + * + * Note: + * + * Port Notes: + * Postgres makes the following assumption about machines: + * + * sizeof(Datum) == sizeof(long) >= sizeof(void *) >= 4 + * + * Postgres also assumes that + * + * sizeof(char) == 1 + * + * and that + * + * sizeof(short) == 2 + * + * If your machine meets these requirements, Datums should also be checked + * to see if the positioning is correct. + * + * This file is MACHINE AND COMPILER dependent!!! + */ + +typedef unsigned long Datum; /* XXX sizeof(long) >= sizeof(void *) */ +typedef Datum * DatumPtr; + +#define GET_1_BYTE(datum) (((Datum) (datum)) & 0x000000ff) +#define GET_2_BYTES(datum) (((Datum) (datum)) & 0x0000ffff) +#define GET_4_BYTES(datum) (((Datum) (datum)) & 0xffffffff) +#define SET_1_BYTE(value) (((Datum) (value)) & 0x000000ff) +#define SET_2_BYTES(value) (((Datum) (value)) & 0x0000ffff) +#define SET_4_BYTES(value) (((Datum) (value)) & 0xffffffff) + +/* + * DatumGetChar -- + * Returns character value of a datum. + */ + +#define DatumGetChar(X) ((char) GET_1_BYTE(X)) + +/* + * CharGetDatum -- + * Returns datum representation for a character. + */ + +#define CharGetDatum(X) ((Datum) SET_1_BYTE(X)) + +/* + * Int8GetDatum -- + * Returns datum representation for an 8-bit integer. + */ + +#define Int8GetDatum(X) ((Datum) SET_1_BYTE(X)) + +/* + * DatumGetUInt8 -- + * Returns 8-bit unsigned integer value of a datum. + */ + +#define DatumGetUInt8(X) ((uint8) GET_1_BYTE(X)) + +/* + * UInt8GetDatum -- + * Returns datum representation for an 8-bit unsigned integer. + */ + +#define UInt8GetDatum(X) ((Datum) SET_1_BYTE(X)) + +/* + * DatumGetInt16 -- + * Returns 16-bit integer value of a datum. + */ + +#define DatumGetInt16(X) ((int16) GET_2_BYTES(X)) + +/* + * Int16GetDatum -- + * Returns datum representation for a 16-bit integer. + */ + +#define Int16GetDatum(X) ((Datum) SET_2_BYTES(X)) + +/* + * DatumGetUInt16 -- + * Returns 16-bit unsigned integer value of a datum. + */ + +#define DatumGetUInt16(X) ((uint16) GET_2_BYTES(X)) + +/* + * UInt16GetDatum -- + * Returns datum representation for a 16-bit unsigned integer. + */ + +#define UInt16GetDatum(X) ((Datum) SET_2_BYTES(X)) + +/* + * DatumGetInt32 -- + * Returns 32-bit integer value of a datum. + */ + +#define DatumGetInt32(X) ((int32) GET_4_BYTES(X)) + +/* + * Int32GetDatum -- + * Returns datum representation for a 32-bit integer. + */ + +#define Int32GetDatum(X) ((Datum) SET_4_BYTES(X)) + +/* + * DatumGetUInt32 -- + * Returns 32-bit unsigned integer value of a datum. + */ + +#define DatumGetUInt32(X) ((uint32) GET_4_BYTES(X)) + +/* + * UInt32GetDatum -- + * Returns datum representation for a 32-bit unsigned integer. + */ + +#define UInt32GetDatum(X) ((Datum) SET_4_BYTES(X)) + +/* + * DatumGetObjectId -- + * Returns object identifier value of a datum. + */ + +#define DatumGetObjectId(X) ((Oid) GET_4_BYTES(X)) + +/* + * ObjectIdGetDatum -- + * Returns datum representation for an object identifier. + */ + +#define ObjectIdGetDatum(X) ((Datum) SET_4_BYTES(X)) + +/* + * DatumGetPointer -- + * Returns pointer value of a datum. + */ + +#define DatumGetPointer(X) ((Pointer) X) + +/* + * PointerGetDatum -- + * Returns datum representation for a pointer. + */ + +#define PointerGetDatum(X) ((Datum) X) + +/* + * DatumGetName -- + * Returns name value of a datum. + */ + +#define DatumGetName(X) ((Name) DatumGetPointer((Datum) X)) + +/* + * NameGetDatum -- + * Returns datum representation for a name. + */ + +#define NameGetDatum(X) PointerGetDatum((Pointer) X) + + +/* + * DatumGetFloat32 -- + * Returns 32-bit floating point value of a datum. + * This is really a pointer, of course. + */ + +#define DatumGetFloat32(X) ((float32) DatumGetPointer((Datum) X)) + +/* + * Float32GetDatum -- + * Returns datum representation for a 32-bit floating point number. + * This is really a pointer, of course. + */ + +#define Float32GetDatum(X) PointerGetDatum((Pointer) X) + +/* + * DatumGetFloat64 -- + * Returns 64-bit floating point value of a datum. + * This is really a pointer, of course. + */ + +#define DatumGetFloat64(X) ((float64) DatumGetPointer(X)) + +/* + * Float64GetDatum -- + * Returns datum representation for a 64-bit floating point number. + * This is really a pointer, of course. + */ + +#define Float64GetDatum(X) PointerGetDatum((Pointer) X) + +/* ---------------------------------------------------------------- + * Section 5: 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) (bool)((void*)(pointer) != NULL) + +/* + * PointerIsInBounds -- + * True iff pointer is within given bounds. + * + * Note: + * Assumes the bounded interval to be [min,max), + * i.e. closed on the left and open on the right. + */ +#define PointerIsInBounds(pointer, min, max) \ + ((min) <= (pointer) && (pointer) < (max)) + +/* + * PointerIsAligned -- + * True iff pointer is properly aligned to point to the given type. + */ +#define PointerIsAligned(pointer, type) \ + (((long)(pointer) % (sizeof (type))) == 0) + +/* ---------------------------------------------------------------- + * Section 6: offsetof, lengthof, endof + * ---------------------------------------------------------------- + */ +/* + * 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)]) + +/* ---------------------------------------------------------------- + * Section 7: exception handling definitions + * Assert, Trap, etc macros + * ---------------------------------------------------------------- + */ +/* + * Exception Handling definitions + */ + +typedef char *ExcMessage; +typedef struct Exception { + ExcMessage message; +} Exception; + +/* + * NO_ASSERT_CHECKING, if defined, turns off all the assertions. + * - plai 9/5/90 + * + * It should _NOT_ be undef'ed in releases or in benchmark copies + * + * #undef NO_ASSERT_CHECKING + */ + +/* + * Trap -- + * Generates an exception if the given condition is true. + * + */ +#define Trap(condition, exception) \ + { if (condition) \ + ExceptionalCondition(CppAsString(condition), &(exception), \ + (char*)NULL, __FILE__, __LINE__); } + +/* + * TrapMacro is the same as Trap but it's intended for use in macros: + * + * #define foo(x) (AssertM(x != 0) && bar(x)) + * + * Isn't CPP fun? + */ +#define TrapMacro(condition, exception) \ + ((bool) ((! condition) || \ + (ExceptionalCondition(CppAsString(condition), \ + &(exception), \ + (char*) NULL, __FILE__, __LINE__)))) + +#ifdef NO_ASSERT_CHECKING +#define Assert(condition) +#define AssertMacro(condition) true +#define AssertArg(condition) +#define AssertState(condition) +#else +#define Assert(condition) \ + Trap(!(condition), FailedAssertion) + +#define AssertMacro(condition) \ + TrapMacro(!(condition), FailedAssertion) + +#define AssertArg(condition) \ + Trap(!(condition), BadArg) + +#define AssertState(condition) \ + Trap(!(condition), BadState) + +#endif /* NO_ASSERT_CHECKING */ + +/* + * LogTrap -- + * Generates an exception with a message if the given condition is true. + * + */ +#define LogTrap(condition, exception, printArgs) \ + { if (condition) \ + ExceptionalCondition(CppAsString(condition), &(exception), \ + form printArgs, __FILE__, __LINE__); } + +/* + * LogTrapMacro is the same as LogTrap but it's intended for use in macros: + * + * #define foo(x) (LogAssertMacro(x != 0, "yow!") && bar(x)) + */ +#define LogTrapMacro(condition, exception, printArgs) \ + ((bool) ((! condition) || \ + (ExceptionalCondition(CppAsString(condition), \ + &(exception), \ + form printArgs, __FILE__, __LINE__)))) + +#ifdef NO_ASSERT_CHECKING +#define LogAssert(condition, printArgs) +#define LogAssertMacro(condition, printArgs) true +#define LogAssertArg(condition, printArgs) +#define LogAssertState(condition, printArgs) +#else +#define LogAssert(condition, printArgs) \ + LogTrap(!(condition), FailedAssertion, printArgs) + +#define LogAssertMacro(condition, printArgs) \ + LogTrapMacro(!(condition), FailedAssertion, printArgs) + +#define LogAssertArg(condition, printArgs) \ + LogTrap(!(condition), BadArg, printArgs) + +#define LogAssertState(condition, printArgs) \ + LogTrap(!(condition), BadState, printArgs) + +#endif /* NO_ASSERT_CHECKING */ + +/* ---------------------------------------------------------------- + * Section 8: Min, Max, Abs 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)) + +/* ---------------------------------------------------------------- + * Section 9: externs + * ---------------------------------------------------------------- + */ + +extern Exception FailedAssertion; +extern Exception BadArg; +extern Exception BadState; + +/* in utils/error/assert.c */ +extern int ExceptionalCondition(char *conditionName, + Exception *exceptionP, char *details, + char *fileName, int lineNumber); + + +/* ---------------- + * form is used by assert and the exception handling stuff + * ---------------- + */ +extern char *form(char *fmt, ...); + + + +/* ---------------------------------------------------------------- + * Section 10: berkeley-specific configuration + * + * this section contains settings which are only relevant to the UC Berkeley + * sites. Other sites can ignore this + * ---------------------------------------------------------------- + */ + +/* ---------------- + * storage managers + * + * These are experimental and are not supported in the code that + * we distribute to other sites. + * ---------------- + */ +#ifdef SEQUOIA +#define MAIN_MEMORY +#endif + + + +/* ---------------------------------------------------------------- + * Section 11: system-specific hacks + * + * This should be limited to things that absolutely have to be + * included in every source file. The changes should be factored + * into a separate file so that changes to one port don't require + * changes to c.h (and everyone recompiling their whole system). + * ---------------------------------------------------------------- + */ + +#if defined(PORTNAME_hpux) +#include "port/hpux/fixade.h" /* for 8.07 unaligned access fixup */ +#endif /* PORTNAME_hpux */ + +#if defined(PORTNAME_sparc) +#define memmove(d, s, l) bcopy(s, d, l) +#endif + +/* These are for things that are one way on Unix and another on NT */ +#ifndef WIN32 +#define NULL_DEV "/dev/null" +#define COPY_CMD "cp" +#define SEP_CHAR '/' +#else +#define NULL_DEV "NUL" +#define COPY_CMD "copy" +#define SEP_CHAR '\\' +#endif /* WIN32 */ + +#if defined(WIN32) +#include "port/win32/nt.h" +#include "port/win32/machine.h" +#endif /* WIN32 */ + +/* ---------------- + * end of c.h + * ---------------- + */ +#endif /* C_H */ diff --git a/src/include/miscadmin.h b/src/include/miscadmin.h new file mode 100644 index 0000000000..c95177e8d1 --- /dev/null +++ b/src/include/miscadmin.h @@ -0,0 +1,185 @@ +/*------------------------------------------------------------------------- + * + * miscadmin.h-- + * this file contains general postgres administration and initialization + * stuff that used to be spread out between the following files: + * globals.h global variables + * magic.h PG_RELEASE, PG_VERSION, etc defines + * pdir.h directory path crud + * pinit.h postgres initialization + * pmod.h processing modes + * + * + * Copyright (c) 1994, Regents of the University of California + * + * $Id: miscadmin.h,v 1.1 1996/10/31 07:10:13 scrappy Exp $ + * + * NOTES + * some of the information in this file will be moved to + * other files. + * + *------------------------------------------------------------------------- + */ +#ifndef MISCADMIN_H +#define MISCADMIN_H + +/***************************************************************************** + * globals.h -- * + *****************************************************************************/ + +#include "postgres.h" + +/* #include "storage/sinval.h" */ + +/* + * from postmaster/postmaster.c + */ +extern int PostmasterMain(int argc, char* argv[]); + +/* + * from utils/init/globals.c + */ +extern int Portfd; +extern int Noversion; /* moved from magic.c */ +extern int MasterPid; /* declared and defined in utils/initglobals.c */ +extern int Quiet; +extern char *DataDir; + +extern char OutputFileName[]; +extern void InitGlobals(void); + +/* + * done in storage/backendid.h for now. + * + * extern BackendId MyBackendId; + * extern BackendTag MyBackendTag; + */ +extern bool MyDatabaseIdIsInitialized; +extern Oid MyDatabaseId; +extern bool TransactionInitWasProcessed; + +extern bool IsUnderPostmaster; +extern bool IsPostmaster; + +extern short DebugLvl; + +extern Oid LastOidProcessed; /* for query rewrite */ + +#define MAX_PARSE_BUFFER 8192 + +/* + * default number of buffers in buffer pool + * + */ +#define NDBUFS 64 + +/***************************************************************************** + * magic.h - definitions of the indexes of the magic numbers * + *****************************************************************************/ + +#define PG_RELEASE 6 +#define PG_VERSION 0 +#define PG_VERFILE "PG_VERSION" + +/***************************************************************************** + * pdir.h -- * + * POSTGRES directory path definitions. * + *****************************************************************************/ + +/* now in utils/init/miscinit.c */ +extern char *GetDatabasePath(void); +extern char *GetDatabaseName(void); +extern void SetDatabaseName(char *name); +extern void SetDatabasePath(char *path); +extern char *GetPgUserName(void); +extern void SetPgUserName(void); +extern Oid GetUserId(void); +extern void SetUserId(void); +extern char *GetPGHome(void); +extern char *GetPGData(void); +extern int ValidateBackend(char *path); +extern int FindBackend(char *backend, char *argv0); +extern int CheckPathAccess(char *path, char *name, int open_mode); + + +/***************************************************************************** + * pmod.h -- * + * POSTGRES processing mode definitions. * + *****************************************************************************/ +/* + * Description: + * There are four processing modes in POSTGRES. They are NoProcessing + * or "none," BootstrapProcessing or "bootstrap," InitProcessing or + * "initialization," and NormalProcessing or "normal." + * + * If a POSTGRES binary is in normal mode, then all code may be executed + * normally. In the none mode, only bookkeeping code may be called. In + * particular, access method calls may not occur in this mode since the + * execution state is outside a transaction. + * + * The final two processing modes are used during special times. When the + * system state indicates bootstrap processing, transactions are all given + * transaction id "one" and are consequently guarenteed to commit. This mode + * is used during the initial generation of template databases. + * + * Finally, the execution state is in initialization mode until all normal + * initialization is complete. Some code behaves differently when executed in + * this mode to enable system bootstrapping. + */ + +typedef enum ProcessingMode { + NoProcessing, /* "nothing" can be done */ + BootstrapProcessing, /* bootstrap creation of template database */ + InitProcessing, /* initializing system */ + NormalProcessing /* normal processing */ +} ProcessingMode; + + +/***************************************************************************** + * pinit.h -- * + * POSTGRES initialization and cleanup definitions. * + *****************************************************************************/ +/* + * Note: + * XXX AddExitHandler not defined yet. + */ + +typedef int16 ExitStatus; + +#define NormalExitStatus (0) +#define FatalExitStatus (127) +/* XXX are there any other meaningful exit codes? */ + +/* in utils/init/postinit.c */ +extern void InitMyDatabaseId(void); +extern void DoChdirAndInitDatabaseNameAndPath(char *name, char *path); +extern void InitUserid(void); +extern void InitCommunication(void); +extern void InitStdio(void); + +extern bool PostgresIsInitialized; + +extern void InitPostgres(char *name); + +/* in miscinit.c */ +extern void ExitPostgres(ExitStatus status); +extern void AbortPostgres(void); +extern void StatusBackendExit(int status); +extern void StatusPostmasterExit(int status); + +extern bool IsNoProcessingMode(void); +extern bool IsBootstrapProcessingMode(void); +extern bool IsInitProcessingMode(void); +extern bool IsNormalProcessingMode(void); +extern void SetProcessingMode(ProcessingMode mode); +extern ProcessingMode GetProcessingMode(void); + + +/* + * Prototypes for utils/init/magic.c + */ +extern int DatabaseMetaGunkIsConsistent(const char *database, char *path); +extern int ValidPgVersion(const char *path); +extern void SetPgVersion(const char *path); + +#endif /* MISCADMIN_H */ diff --git a/src/include/postgres.h b/src/include/postgres.h new file mode 100644 index 0000000000..703e9d69a3 --- /dev/null +++ b/src/include/postgres.h @@ -0,0 +1,226 @@ +/*------------------------------------------------------------------------- + * + * postgres.h-- + * definition of (and support for) postgres system types. + * this file is included by almost every .c in the system + * + * Copyright (c) 1995, Regents of the University of California + * + * $Id: postgres.h,v 1.1 1996/10/31 07:10:14 scrappy Exp $ + * + *------------------------------------------------------------------------- + */ +/* + * NOTES + * this file will eventually contain the definitions for the + * following (and perhaps other) system types: + * + * int2 int4 float4 float8 + * Oid regproc RegProcedure + * aclitem + * struct varlena + * char8 char16 int28 oid8 + * bytea text + * NameData Name + * oidint4 oidint2 oidname + * + * TABLE OF CONTENTS + * 1) simple type definitions + * 2) varlena and array types + * 3) TransactionId and CommandId + * 4) genbki macros used by catalog/pg_xxx.h files + * 5) random SIGNBIT, MAXPGPATH, STATUS macros + * + * ---------------------------------------------------------------- + */ +#ifndef POSTGRES_H +#define POSTGRES_H + +#include "config.h" +#include "c.h" +#include "utils/elog.h" + +/* ---------------------------------------------------------------- + * Section 1: simple type definitions + * ---------------------------------------------------------------- + */ + +typedef int16 int2; +typedef int32 int4; +typedef float float4; +typedef double float8; + +typedef int4 aclitem; + + +typedef uint32 Oid; +#define InvalidOid 0 +#define OidIsValid(objectId) ((bool) (objectId != InvalidOid)) + +/* unfortunately, both regproc and RegProcedure are used */ +typedef Oid regproc; +typedef Oid RegProcedure; + +/* ptr to func returning (char *) */ +typedef char * ((*func_ptr)()); + + +#define RegProcedureIsValid(p) OidIsValid(p) + +/* ---------------------------------------------------------------- + * Section 2: variable length and array types + * ---------------------------------------------------------------- + */ +/* ---------------- + * struct varlena + * ---------------- + */ +struct varlena { + int32 vl_len; + char vl_dat[1]; +}; + +#define VARSIZE(PTR) (((struct varlena *)(PTR))->vl_len) +#define VARDATA(PTR) (((struct varlena *)(PTR))->vl_dat) +#define VARHDRSZ sizeof(int32) + +typedef struct varlena bytea; +typedef struct varlena text; + +typedef struct char8 { + char data[8]; +} char8; + +/* ---------------- + * char16 + * ---------------- + */ +typedef struct char16 { + char data[16]; +} char16; + +typedef char16 *Char16; + +typedef int2 int28[8]; +typedef Oid oid8[8]; + +/* char16 is distinct from Name. + now, you can truly change the max length of system names + by altering the NAMEDATALEN define below. + don't set the value too high because tuples are still constrained + to be less than 8K +*/ + + /* NAMEDATALEN is the maximum string length (counting terminating null) + of a Name */ +/* defined in Makefile.global */ +/* if you change the value of NAMEDATALEN, you may need to change the + alignment of the 'name' type in pg_type.h */ +#ifndef NAMEDATALEN +#define NAMEDATALEN 16 +#endif /* NAMEDATALEN */ +/* OIDNAMELEN should be NAMEDATALEN + sizeof(Oid) */ +#ifndef OIDNAMELEN +#define OIDNAMELEN 20 +#endif /* OIDNAMELEN */ + +typedef struct nameData { + char data[NAMEDATALEN]; +} NameData; +typedef NameData *Name; + +/* ---------------- + * oidint4 + * + * this is a new system type used by the file interface. + * ---------------- + */ +typedef struct OidInt4Data { + Oid oi_oid; + int32 oi_int4; +} OidInt4Data; + +typedef struct OidInt4Data *OidInt4; + +/* ---------------- + * oidint2 + * + * this is a new system type used to define indices on two attrs. + * ---------------- + */ +typedef struct OidInt2Data { + Oid oi_oid; + int16 oi_int2; +} OidInt2Data; + +typedef struct OidInt2Data *OidInt2; + +/* ---------------- + * oidname + * + * this is a new system type used to define indices on two attrs. + * ---------------- + */ +typedef struct OidNameData { + Oid id; + NameData name; +} OidNameData; + +typedef struct OidNameData *OidName; + +/* ---------------------------------------------------------------- + * Section 3: TransactionId and CommandId + * ---------------------------------------------------------------- + */ + +typedef uint32 TransactionId; +#define InvalidTransactionId 0 +typedef uint16 CommandId; +#define FirstCommandId 0 + +/* ---------------------------------------------------------------- + * Section 4: genbki macros used by the + * catalog/pg_xxx.h files + * ---------------------------------------------------------------- + */ +#define CATALOG(x) \ + typedef struct CppConcat(FormData_,x) + +#define DATA(x) extern int errno +#define DECLARE_INDEX(x) extern int errno + +#define BUILD_INDICES +#define BOOTSTRAP + +#define BKI_BEGIN +#define BKI_END + +/* ---------------------------------------------------------------- + * Section 5: random stuff + * SIGNBIT, MAXPGPATH, STATUS... + * ---------------------------------------------------------------- + */ + +/* msb for int/unsigned */ +#define SIGNBIT (0x8000) + +/* msb for char */ +#define CSIGNBIT (1 << 7) + +/* ---------------- + * global variables which should probably go someplace else. + * ---------------- + */ +#define MAXPGPATH 128 + +#define STATUS_OK (0) +#define STATUS_ERROR (-1) +#define STATUS_NOT_FOUND (-2) +#define STATUS_INVALID (-3) +#define STATUS_UNCATALOGUED (-4) +#define STATUS_REPLACED (-5) +#define STATUS_NOT_DONE (-6) +#define STATUS_BAD_PACKET (-7) +#define STATUS_FOUND (1) + +#endif /* POSTGRES_H */ -- 2.11.0