open-dsi
/
postgres
mirror of https://github.com/postgres/postgres
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Add these files to ${SRCDIR}/include

Browse Source
REL2_0B
Marc G. Fournier 29 years ago
parent 0a761375e9
commit 83311355d7
3 changed files with 1179 additions and 0 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 768
      src/include/c.h
  2. 185
      src/include/miscadmin.h
  3. 226
      src/include/postgres.h

768
src/include/c.h
Unescape View File

@ -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 <stddef.h>
#include <stdlib.h>
#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 */

185
src/include/miscadmin.h
Unescape View File

@ -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 */

226
src/include/postgres.h
Unescape View File

@ -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 */
Write Preview
Loading…
Cancel
Save