database/postgres
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2025-11-10 17:42:29 +03:00
Code Activity

Used modified version of indent that understands over 100 typedefs.

Browse Source
This commit is contained in:
Bruce Momjian
1997-09-08 21:56:23 +00:00
parent 075cede748
commit 59f6a57e59
413 changed files with 4472 additions and 4460 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
src/backend/storage/ipc/ipc.c
View File

@@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/storage/ipc/ipc.c,v 1.13 1997/09/08 02:28:44 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/storage/ipc/ipc.c,v 1.14 1997/09/08 21:46:59 momjian Exp $
*
* NOTES
*
@@ -73,7 +73,7 @@ typedef struct _PrivateMemStruct
{
int id;
char *memptr;
} PrivateMem;
} PrivateMem;
PrivateMem IpcPrivateMem[16];
@@ -668,11 +668,11 @@ AttachSLockMemory(IPCKey key)
slockM = (struct ipcdummy *) IpcMemoryAttach(SLockMemoryId);
if (slockM == IpcMemAttachFailed)
elog(FATAL, "AttachSLockMemory: could not attach segment");
FreeSLockPP = (SLock **) & (slockM->free);
FreeSLockPP = (SLock **) &(slockM->free);
UnusedSLockIP = (int *) &(slockM->unused);
SLockMemoryLock = (slock_t *) & (slockM->memlock);
SLockMemoryLock = (slock_t *) &(slockM->memlock);
S_INIT_LOCK(SLockMemoryLock);
SLockArray = (SLock *) & (slockM->slocks[0]);
SLockArray = (SLock *) &(slockM->slocks[0]);
return;
}

84
src/backend/storage/ipc/s_lock.c
View File

@@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/storage/ipc/Attic/s_lock.c,v 1.23 1997/09/08 02:28:51 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/storage/ipc/Attic/s_lock.c,v 1.24 1997/09/08 21:47:04 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@@ -50,24 +50,24 @@
* slock_t is defined as a struct mutex.
*/
void
S_LOCK(slock_t * lock)
S_LOCK(slock_t *lock)
{
mutex_lock(lock);
}
void
S_UNLOCK(slock_t * lock)
S_UNLOCK(slock_t *lock)
{
mutex_unlock(lock);
}
void
S_INIT_LOCK(slock_t * lock)
S_INIT_LOCK(slock_t *lock)
{
mutex_init(lock);
}
/* S_LOCK_FREE should return 1 if lock is free; 0 if lock is locked */
int
S_LOCK_FREE(slock_t * lock)
S_LOCK_FREE(slock_t *lock)
{
/* For Mach, we have to delve inside the entrails of `struct mutex'. Ick! */
return (lock->lock == 0);
@@ -88,7 +88,7 @@ S_LOCK_FREE(slock_t * lock)
* for the R3000 chips out there.
*/
void
S_LOCK(slock_t * lock)
S_LOCK(slock_t *lock)
{
/* spin_lock(lock); */
while (!acquire_lock(lock))
@@ -96,20 +96,20 @@ S_LOCK(slock_t * lock)
}
void
S_UNLOCK(slock_t * lock)
S_UNLOCK(slock_t *lock)
{
release_lock(lock);
}
void
S_INIT_LOCK(slock_t * lock)
S_INIT_LOCK(slock_t *lock)
{
init_lock(lock);
}
/* S_LOCK_FREE should return 1 if lock is free; 0 if lock is locked */
int
S_LOCK_FREE(slock_t * lock)
S_LOCK_FREE(slock_t *lock)
{
return (stat_lock(lock) == UNLOCKED);
}
@@ -127,26 +127,26 @@ S_LOCK_FREE(slock_t * lock)
#if defined(__alpha__) || defined(__alpha)
void
S_LOCK(slock_t * lock)
S_LOCK(slock_t *lock)
{
while (msem_lock(lock, MSEM_IF_NOWAIT) < 0)
;
}
void
S_UNLOCK(slock_t * lock)
S_UNLOCK(slock_t *lock)
{
msem_unlock(lock, 0);
}
void
S_INIT_LOCK(slock_t * lock)
S_INIT_LOCK(slock_t *lock)
{
msem_init(lock, MSEM_UNLOCKED);
}
int
S_LOCK_FREE(slock_t * lock)
S_LOCK_FREE(slock_t *lock)
{
return (lock->msem_state ? 0 : 1);
}
@@ -161,23 +161,23 @@ S_LOCK_FREE(slock_t * lock)
defined(sparc_solaris)
/* for xxxxx_solaris, this is defined in port/.../tas.s */
static int tas(slock_t * lock);
static int tas(slock_t *lock);
void
S_LOCK(slock_t * lock)
S_LOCK(slock_t *lock)
{
while (tas(lock))
;
}
void
S_UNLOCK(slock_t * lock)
S_UNLOCK(slock_t *lock)
{
*lock = 0;
}
void
S_INIT_LOCK(slock_t * lock)
S_INIT_LOCK(slock_t *lock)
{
S_UNLOCK(lock);
}
@@ -194,20 +194,20 @@ S_INIT_LOCK(slock_t * lock)
#if defined(aix)
void
S_LOCK(slock_t * lock)
S_LOCK(slock_t *lock)
{
while (cs((int *) lock, 0, 1))
;
}
void
S_UNLOCK(slock_t * lock)
S_UNLOCK(slock_t *lock)
{
*lock = 0;
}
void
S_INIT_LOCK(slock_t * lock)
S_INIT_LOCK(slock_t *lock)
{
S_UNLOCK(lock);
}
@@ -229,29 +229,29 @@ S_INIT_LOCK(slock_t * lock)
*/
static slock_t clear_lock = {-1, -1, -1, -1};
static int tas(slock_t * lock);
static int tas(slock_t *lock);
void
S_LOCK(slock_t * lock)
S_LOCK(slock_t *lock)
{
while (tas(lock))
;
}
void
S_UNLOCK(slock_t * lock)
S_UNLOCK(slock_t *lock)
{
*lock = clear_lock; /* struct assignment */
}
void
S_INIT_LOCK(slock_t * lock)
S_INIT_LOCK(slock_t *lock)
{
S_UNLOCK(lock);
}
int
S_LOCK_FREE(slock_t * lock)
S_LOCK_FREE(slock_t *lock)
{
register int *lock_word = (int *) (((long) lock + 15) & ~15);
@@ -266,22 +266,22 @@ S_LOCK_FREE(slock_t * lock)
#if defined(sun3)
static int tas(slock_t * lock);
static int tas(slock_t *lock);
void
S_LOCK(slock_t * lock)
S_LOCK(slock_t *lock)
{
while (tas(lock));
}
void
S_UNLOCK(slock_t * lock)
S_UNLOCK(slock_t *lock)
{
*lock = 0;
}
void
S_INIT_LOCK(slock_t * lock)
S_INIT_LOCK(slock_t *lock)
{
S_UNLOCK(lock);
}
@@ -320,7 +320,7 @@ tas_dummy()
#define asm(x) __asm__(x)
#endif
static int tas(slock_t * lock);
static int tas(slock_t *lock);
static int
tas_dummy()
@@ -386,7 +386,7 @@ S_INIT_LOCK(unsigned char *addr)
#if defined(NEED_I386_TAS_ASM)
void
S_LOCK(slock_t * lock)
S_LOCK(slock_t *lock)
{
slock_t res;
@@ -397,13 +397,13 @@ __asm__("xchgb %0,%1": "=q"(res), "=m"(*lock):"0"(0x1));
}
void
S_UNLOCK(slock_t * lock)
S_UNLOCK(slock_t *lock)
{
*lock = 0;
}
void
S_INIT_LOCK(slock_t * lock)
S_INIT_LOCK(slock_t *lock)
{
S_UNLOCK(lock);
}
@@ -414,7 +414,7 @@ S_INIT_LOCK(slock_t * lock)
#if defined(__alpha__) && defined(linux)
void
S_LOCK(slock_t * lock)
S_LOCK(slock_t *lock)
{
slock_t res;
@@ -437,14 +437,14 @@ __asm__(" ldq $0, %0 \n\
}
void
S_UNLOCK(slock_t * lock)
S_UNLOCK(slock_t *lock)
{
__asm__("mb");
*lock = 0;
}
void
S_INIT_LOCK(slock_t * lock)
S_INIT_LOCK(slock_t *lock)
{
S_UNLOCK(lock);
}
@@ -454,7 +454,7 @@ S_INIT_LOCK(slock_t * lock)
#if defined(linux) && defined(sparc)
void
S_LOCK(slock_t * lock)
S_LOCK(slock_t *lock)
{
slock_t res;
@@ -467,13 +467,13 @@ S_LOCK(slock_t * lock)
}
void
S_UNLOCK(slock_t * lock)
S_UNLOCK(slock_t *lock)
{
*lock = 0;
}
void
S_INIT_LOCK(slock_t * lock)
S_INIT_LOCK(slock_t *lock)
{
S_UNLOCK(lock);
}
@@ -502,20 +502,20 @@ success: \n\
}
void
S_LOCK(slock_t * lock)
S_LOCK(slock_t *lock)
{
while (tas(lock))
;
}
void
S_UNLOCK(slock_t * lock)
S_UNLOCK(slock_t *lock)
{
*lock = 0;
}
void
S_INIT_LOCK(slock_t * lock)
S_INIT_LOCK(slock_t *lock)
{
S_UNLOCK(lock);
}

8
src/backend/storage/ipc/shmem.c
View File

@@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/storage/ipc/shmem.c,v 1.12 1997/09/08 02:28:53 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/storage/ipc/shmem.c,v 1.13 1997/09/08 21:47:09 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@@ -342,7 +342,7 @@ HTAB *
ShmemInitHash(char *name, /* table string name for binding */
long init_size, /* initial size */
long max_size, /* max size of the table */
HASHCTL * infoP, /* info about key and bucket size */
HASHCTL *infoP, /* info about key and bucket size */
int hash_flags) /* info about infoP */
{
bool found;
@@ -400,7 +400,7 @@ ShmemInitHash(char *name, /* table string name for binding */
* locationPtr.
*/
bool
ShmemPIDLookup(int pid, SHMEM_OFFSET * locationPtr)
ShmemPIDLookup(int pid, SHMEM_OFFSET *locationPtr)
{
BindingEnt *result,
item;
@@ -497,7 +497,7 @@ ShmemPIDDestroy(int pid)
* initialized).
*/
long *
ShmemInitStruct(char *name, unsigned long size, bool * foundPtr)
ShmemInitStruct(char *name, unsigned long size, bool *foundPtr)
{
BindingEnt *result,
item;

20
src/backend/storage/ipc/shmqueue.c
View File

@@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/storage/ipc/shmqueue.c,v 1.5 1997/09/08 02:28:56 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/storage/ipc/shmqueue.c,v 1.6 1997/09/08 21:47:10 momjian Exp $
*
* NOTES
*
@@ -39,7 +39,7 @@
* to itself
*/
void
SHMQueueInit(SHM_QUEUE * queue)
SHMQueueInit(SHM_QUEUE *queue)
{
Assert(SHM_PTR_VALID(queue));
(queue)->prev = (queue)->next = MAKE_OFFSET(queue);
@@ -51,7 +51,7 @@ SHMQueueInit(SHM_QUEUE * queue)
*/
#ifdef NOT_USED
bool
SHMQueueIsDetached(SHM_QUEUE * queue)
SHMQueueIsDetached(SHM_QUEUE *queue)
{
Assert(SHM_PTR_VALID(queue));
return ((queue)->prev == INVALID_OFFSET);
@@ -63,7 +63,7 @@ SHMQueueIsDetached(SHM_QUEUE * queue)
* SHMQueueElemInit -- clear an element's links
*/
void
SHMQueueElemInit(SHM_QUEUE * queue)
SHMQueueElemInit(SHM_QUEUE *queue)
{
Assert(SHM_PTR_VALID(queue));
(queue)->prev = (queue)->next = INVALID_OFFSET;
@@ -74,7 +74,7 @@ SHMQueueElemInit(SHM_QUEUE * queue)
* close the links
*/
void
SHMQueueDelete(SHM_QUEUE * queue)
SHMQueueDelete(SHM_QUEUE *queue)
{
SHM_QUEUE *nextElem = (SHM_QUEUE *) MAKE_PTR((queue)->next);
SHM_QUEUE *prevElem = (SHM_QUEUE *) MAKE_PTR((queue)->prev);
@@ -97,7 +97,7 @@ SHMQueueDelete(SHM_QUEUE * queue)
#ifdef SHMQUEUE_DEBUG
void
dumpQ(SHM_QUEUE * q, char *s)
dumpQ(SHM_QUEUE *q, char *s)
{
char elem[16];
char buf[1024];
@@ -152,7 +152,7 @@ dumpQ(SHM_QUEUE * q, char *s)
*/
#ifdef NOT_USED
void
SHMQueueInsertHD(SHM_QUEUE * queue, SHM_QUEUE * elem)
SHMQueueInsertHD(SHM_QUEUE *queue, SHM_QUEUE *elem)
{
SHM_QUEUE *prevPtr = (SHM_QUEUE *) MAKE_PTR((queue)->prev);
SHMEM_OFFSET elemOffset = MAKE_OFFSET(elem);
@@ -177,7 +177,7 @@ SHMQueueInsertHD(SHM_QUEUE * queue, SHM_QUEUE * elem)
#endif
void
SHMQueueInsertTL(SHM_QUEUE * queue, SHM_QUEUE * elem)
SHMQueueInsertTL(SHM_QUEUE *queue, SHM_QUEUE *elem)
{
SHM_QUEUE *nextPtr = (SHM_QUEUE *) MAKE_PTR((queue)->next);
SHMEM_OFFSET elemOffset = MAKE_OFFSET(elem);
@@ -222,7 +222,7 @@ SHMQueueInsertTL(SHM_QUEUE * queue, SHM_QUEUE * elem)
* next.
*/
void
SHMQueueFirst(SHM_QUEUE * queue, Pointer * nextPtrPtr, SHM_QUEUE * nextQueue)
SHMQueueFirst(SHM_QUEUE *queue, Pointer *nextPtrPtr, SHM_QUEUE *nextQueue)
{
SHM_QUEUE *elemPtr = (SHM_QUEUE *) MAKE_PTR((queue)->next);
@@ -243,7 +243,7 @@ SHMQueueFirst(SHM_QUEUE * queue, Pointer * nextPtrPtr, SHM_QUEUE * nextQueue)
* SHMQueueEmpty -- TRUE if queue head is only element, FALSE otherwise
*/
bool
SHMQueueEmpty(SHM_QUEUE * queue)
SHMQueueEmpty(SHM_QUEUE *queue)
{
Assert(SHM_PTR_VALID(queue));

72
src/backend/storage/ipc/sinvaladt.c
View File

@@ -7,7 +7,7 @@
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/storage/ipc/sinvaladt.c,v 1.7 1997/09/08 02:29:01 momjian Exp $
* $Header: /cvsroot/pgsql/src/backend/storage/ipc/sinvaladt.c,v 1.8 1997/09/08 21:47:15 momjian Exp $
*
*-------------------------------------------------------------------------
*/
@@ -59,9 +59,9 @@ IpcSemaphoreId SharedInvalidationSemaphore;
SISeg *shmInvalBuffer;
extern BackendId MyBackendId;
static void CleanupInvalidationState(int status, SISeg * segInOutP);
static BackendId SIAssignBackendId(SISeg * segInOutP, BackendTag backendTag);
static int SIGetNumEntries(SISeg * segP);
static void CleanupInvalidationState(int status, SISeg *segInOutP);
static BackendId SIAssignBackendId(SISeg *segInOutP, BackendTag backendTag);
static int SIGetNumEntries(SISeg *segP);
/************************************************************************/
/* SISetActiveProcess(segP, backendId) set the backend status active */
@@ -69,7 +69,7 @@ static int SIGetNumEntries(SISeg * segP);
/************************************************************************/
/* XXX I suspect that the segP parameter is extraneous. -hirohama */
static void
SISetActiveProcess(SISeg * segInOutP, BackendId backendId)
SISetActiveProcess(SISeg *segInOutP, BackendId backendId)
{
/* mark all messages as read */
@@ -83,7 +83,7 @@ SISetActiveProcess(SISeg * segInOutP, BackendId backendId)
/* SIBackendInit() initializes a backend to operate on the buffer */
/****************************************************************************/
int
SIBackendInit(SISeg * segInOutP)
SIBackendInit(SISeg *segInOutP)
{
LRelId LtCreateRelId();
TransactionId LMITransactionIdCopy();
@@ -109,7 +109,7 @@ SIBackendInit(SISeg * segInOutP)
* ----------------
*/
static BackendId
SIAssignBackendId(SISeg * segInOutP, BackendTag backendTag)
SIAssignBackendId(SISeg *segInOutP, BackendTag backendTag)
{
Index index;
ProcState *stateP;
@@ -180,7 +180,7 @@ SIAssignBackendId(SISeg * segInOutP, BackendTag backendTag)
/* should be called only by the postmaster when a backend died */
/************************************************************************/
static void
SISetDeadProcess(SISeg * segP, int backendId)
SISetDeadProcess(SISeg *segP, int backendId)
{
/* XXX call me.... */
@@ -197,7 +197,7 @@ SISetDeadProcess(SISeg * segP, int backendId)
*/
static void
CleanupInvalidationState(int status, /* XXX */
SISeg * segInOutP) /* XXX style */
SISeg *segInOutP) /* XXX style */
{
Assert(PointerIsValid(segInOutP));
@@ -237,7 +237,7 @@ SIComputeSize(int *segSize)
/* SISetStartEntrySection(segP, offset) - sets the offset */
/************************************************************************/
static void
SISetStartEntrySection(SISeg * segP, Offset offset)
SISetStartEntrySection(SISeg *segP, Offset offset)
{
segP->startEntrySection = offset;
}
@@ -246,7 +246,7 @@ SISetStartEntrySection(SISeg * segP, Offset offset)
/* SIGetStartEntrySection(segP) - returnss the offset */
/************************************************************************/
static Offset
SIGetStartEntrySection(SISeg * segP)
SIGetStartEntrySection(SISeg *segP)
{
return (segP->startEntrySection);
}
@@ -256,7 +256,7 @@ SIGetStartEntrySection(SISeg * segP)
/* SISetEndEntrySection(segP, offset) - sets the offset */
/************************************************************************/
static void
SISetEndEntrySection(SISeg * segP, Offset offset)
SISetEndEntrySection(SISeg *segP, Offset offset)
{
segP->endEntrySection = offset;
}
@@ -265,7 +265,7 @@ SISetEndEntrySection(SISeg * segP, Offset offset)
/* SISetEndEntryChain(segP, offset) - sets the offset */
/************************************************************************/
static void
SISetEndEntryChain(SISeg * segP, Offset offset)
SISetEndEntryChain(SISeg *segP, Offset offset)
{
segP->endEntryChain = offset;
}
@@ -274,7 +274,7 @@ SISetEndEntryChain(SISeg * segP, Offset offset)
/* SIGetEndEntryChain(segP) - returnss the offset */
/************************************************************************/
static Offset
SIGetEndEntryChain(SISeg * segP)
SIGetEndEntryChain(SISeg *segP)
{
return (segP->endEntryChain);
}
@@ -283,7 +283,7 @@ SIGetEndEntryChain(SISeg * segP)
/* SISetStartEntryChain(segP, offset) - sets the offset */
/************************************************************************/
static void
SISetStartEntryChain(SISeg * segP, Offset offset)
SISetStartEntryChain(SISeg *segP, Offset offset)
{
segP->startEntryChain = offset;
}
@@ -292,7 +292,7 @@ SISetStartEntryChain(SISeg * segP, Offset offset)
/* SIGetStartEntryChain(segP) - returns the offset */
/************************************************************************/
static Offset
SIGetStartEntryChain(SISeg * segP)
SIGetStartEntryChain(SISeg *segP)
{
return (segP->startEntryChain);
}
@@ -301,7 +301,7 @@ SIGetStartEntryChain(SISeg * segP)
/* SISetNumEntries(segP, num) sets the current nuber of entries */
/************************************************************************/
static bool
SISetNumEntries(SISeg * segP, int num)
SISetNumEntries(SISeg *segP, int num)
{
if (num <= MAXNUMMESSAGES)
{
@@ -318,7 +318,7 @@ SISetNumEntries(SISeg * segP, int num)
/* SIGetNumEntries(segP) - returns the current nuber of entries */
/************************************************************************/
static int
SIGetNumEntries(SISeg * segP)
SIGetNumEntries(SISeg *segP)
{
return (segP->numEntries);
}
@@ -328,7 +328,7 @@ SIGetNumEntries(SISeg * segP)
/* SISetMaxNumEntries(segP, num) sets the maximal number of entries */
/************************************************************************/
static bool
SISetMaxNumEntries(SISeg * segP, int num)
SISetMaxNumEntries(SISeg *segP, int num)
{
if (num <= MAXNUMMESSAGES)
{
@@ -346,7 +346,7 @@ SISetMaxNumEntries(SISeg * segP, int num)
/* SIGetProcStateLimit(segP, i) returns the limit of read messages */
/************************************************************************/
static int
SIGetProcStateLimit(SISeg * segP, int i)
SIGetProcStateLimit(SISeg *segP, int i)
{
return (segP->procState[i].limit);
}
@@ -355,7 +355,7 @@ SIGetProcStateLimit(SISeg * segP, int i)
/* SIIncNumEntries(segP, num) increments the current nuber of entries */
/************************************************************************/
static bool
SIIncNumEntries(SISeg * segP, int num)
SIIncNumEntries(SISeg *segP, int num)
{
if ((segP->numEntries + num) <= MAXNUMMESSAGES)
{
@@ -372,7 +372,7 @@ SIIncNumEntries(SISeg * segP, int num)
/* SIDecNumEntries(segP, num) decrements the current nuber of entries */
/************************************************************************/
static bool
SIDecNumEntries(SISeg * segP, int num)
SIDecNumEntries(SISeg *segP, int num)
{
if ((segP->numEntries - num) >= 0)
{
@@ -389,7 +389,7 @@ SIDecNumEntries(SISeg * segP, int num)
/* SISetStartFreeSpace(segP, offset) - sets the offset */
/************************************************************************/
static void
SISetStartFreeSpace(SISeg * segP, Offset offset)
SISetStartFreeSpace(SISeg *segP, Offset offset)
{
segP->startFreeSpace = offset;
}
@@ -398,7 +398,7 @@ SISetStartFreeSpace(SISeg * segP, Offset offset)
/* SIGetStartFreeSpace(segP) - returns the offset */
/************************************************************************/
static Offset
SIGetStartFreeSpace(SISeg * segP)
SIGetStartFreeSpace(SISeg *segP)
{
return (segP->startFreeSpace);
}
@@ -409,7 +409,7 @@ SIGetStartFreeSpace(SISeg * segP)
/* SIGetFirstDataEntry(segP) returns first data entry */
/************************************************************************/
static SISegEntry *
SIGetFirstDataEntry(SISeg * segP)
SIGetFirstDataEntry(SISeg *segP)
{
SISegEntry *eP;
Offset startChain;
@@ -430,7 +430,7 @@ SIGetFirstDataEntry(SISeg * segP)
/* SIGetLastDataEntry(segP) returns last data entry in the chain */
/************************************************************************/
static SISegEntry *
SIGetLastDataEntry(SISeg * segP)
SIGetLastDataEntry(SISeg *segP)
{
SISegEntry *eP;
Offset endChain;
@@ -450,7 +450,7 @@ SIGetLastDataEntry(SISeg * segP)
/* SIGetNextDataEntry(segP, offset) returns next data entry */
/************************************************************************/
static SISegEntry *
SIGetNextDataEntry(SISeg * segP, Offset offset)
SIGetNextDataEntry(SISeg *segP, Offset offset)
{
SISegEntry *eP;
@@ -468,7 +468,7 @@ SIGetNextDataEntry(SISeg * segP, Offset offset)
/* SIGetNthDataEntry(segP, n) returns the n-th data entry in chain */
/************************************************************************/
static SISegEntry *
SIGetNthDataEntry(SISeg * segP,
SIGetNthDataEntry(SISeg *segP,
int n) /* must range from 1 to MaxMessages */
{
SISegEntry *eP;
@@ -491,7 +491,7 @@ SIGetNthDataEntry(SISeg * segP,
/* SIEntryOffset(segP, entryP) returns the offset for an pointer */
/************************************************************************/
static Offset
SIEntryOffset(SISeg * segP, SISegEntry * entryP)
SIEntryOffset(SISeg *segP, SISegEntry *entryP)
{
/* relative to B !! */
return ((Offset) ((Pointer) entryP -
@@ -504,7 +504,7 @@ SIEntryOffset(SISeg * segP, SISegEntry * entryP)
/* SISetDataEntry(segP, data) - sets a message in the segemnt */
/************************************************************************/
bool
SISetDataEntry(SISeg * segP, SharedInvalidData * data)
SISetDataEntry(SISeg *segP, SharedInvalidData *data)
{
Offset offsetToNewData;
SISegEntry *eP,
@@ -543,7 +543,7 @@ SISetDataEntry(SISeg * segP, SharedInvalidData * data)
/* SIDecProcLimit(segP, num) decrements all process limits */
/************************************************************************/
static void
SIDecProcLimit(SISeg * segP, int num)
SIDecProcLimit(SISeg *segP, int num)
{
int i;
@@ -568,7 +568,7 @@ SIDecProcLimit(SISeg * segP, int num)
/* SIDelDataEntry(segP) - free the FIRST entry */
/************************************************************************/
bool
SIDelDataEntry(SISeg * segP)
SIDelDataEntry(SISeg *segP)
{
SISegEntry *e1P;
@@ -600,7 +600,7 @@ SIDelDataEntry(SISeg * segP)
/* invalid */
/************************************************************************/
void
SISetProcStateInvalid(SISeg * segP)
SISetProcStateInvalid(SISeg *segP)
{
int i;
@@ -625,7 +625,7 @@ SISetProcStateInvalid(SISeg * segP)
/* and executes function */
/************************************************************************/
void
SIReadEntryData(SISeg * segP,
SIReadEntryData(SISeg *segP,
int backendId,
void (*invalFunction) (),
void (*resetFunction) ())
@@ -673,7 +673,7 @@ SIReadEntryData(SISeg * segP,
/* SIDelExpiredDataEntries (segP) - removes irrelevant messages */
/************************************************************************/
void
SIDelExpiredDataEntries(SISeg * segP)
SIDelExpiredDataEntries(SISeg *segP)
{
int min,
i,
@@ -709,7 +709,7 @@ SIDelExpiredDataEntries(SISeg * segP)
/* SISegInit(segP) - initializes the segment */
/************************************************************************/
static void
SISegInit(SISeg * segP)
SISegInit(SISeg *segP)
{
SISegOffsets *oP;
int segSize,