/* c4code.c   (c)Copyright Sequiter Software Inc., 1988-1996.  All rights reserved. */

#include "d4all.h"

#ifdef __TURBOC__
   #pragma hdrstop
#endif  /* __TUROBC__ */

#ifdef S4WINTEL
   #include <process.h>
#endif  /* S4WINTEL */

#if S4VERSION != 6001
   #error Your CodeBase source version does not match your header file version.
#endif

#ifdef S4TESTING
   #include <fcntl.h>
   #include <sys\types.h>
   #include <sys\stat.h>
#endif

#ifdef S4WINTEL
   #ifdef __TURBOC__
      #pragma hdrstop
      #ifndef __DLL__
         #ifndef S4OS2PM
            #ifndef S4WIN32
               #ifndef S4WINDOWS
                  extern unsigned _stklen ;
               #endif
            #endif
         #endif
      #endif
   #endif

   #ifdef _MSC_VER
       #ifndef __DLL__
          #include <malloc.h>
       #endif
   #endif
#endif

#ifdef S4CBPP
   #ifdef __cplusplus
      #include "d4data.hpp"
   #endif
#endif

#ifdef S4TESTING
   FILE4 s4test ;
#else
   #ifdef S4TRACK_FILES
      FILE4 s4test ;
   #endif
#endif

char f4memoNullChar = '\0' ;
char *expr4buf = 0 ;

static unsigned int numCode4 = 0 ;  /* used to determine when mem4reset() should be called */

int code4numCodeBase( void )
{
   return numCode4 ;
}

#ifdef S4SEMAPHORE
   #ifdef S4OS2
      #include <time.h>

      static char sem4mem[20], sem4expr[20] ;
      static HMTX hmtx4mem, hmtx4expr ;
   #endif
#endif

#ifdef S4IBMOS2
   #ifdef S4OS2DLL
      #ifndef __MULTI__     /* no multi-thread code is being produced */
         int errno = 0 ;
      #endif
   #endif
#endif

#ifdef __DLL__

#ifdef S4PASCAL
   #ifndef S4WIN32
      typedef char far* LPSTR ;
      typedef unsigned int HANDLE ;
      typedef unsigned short WORD ;
      #define PASCAL _pascal
      #define S4USE_WEP
   #endif
#endif

#ifndef S4PASCAL_DOS
   #ifdef S4DLL
      HINSTANCE cb5inst = (HINSTANCE)NULL ;
   #endif
#endif

#ifdef S4OS2
ULONG _dllmain (ULONG termflag, HMODULE modhandle)
{
   #ifdef S4SEMAPHORE
      int i ;
      APIRET rc ;
      time_t t ;
   #endif

   if ( termflag == 0 )
   {
      #ifdef S4SEMAPHORE
         strcpy( sem4expr, "\\SEM32\\S4A" ) ;
         strcpy( sem4mem, "\\SEM32\\S4B" ) ;
         for ( i = 0 ; i < 100 ; i++ )
         {
            u4delaySec() ;
            time( &t ) ;
            t %= 10000L ;

            c4ltoa45( t, sem4expr + 10, -4 ) ;
            c4ltoa45( t, sem4mem + 10, -4 ) ;

            rc = DosCreateMutexSem( sem4expr, &hmtx4expr, 0, 0 ) ;
            if ( rc != 0 )
               continue ;

            rc = DosCreateMutexSem( sem4mem, &hmtx4mem, 0, 0 ) ;
            if ( rc != 0 )
            {
               DosCloseMutexSem( hmtx4expr ) ;
               continue ;
            }
            return 1 ;
         }
      #else
         return 1 ;
      #endif
   }
   else
   {
      #ifdef S4SEMAPHORE
         DosCloseMutexSem( hmtx4mem ) ;
         DosCloseMutexSem( hmtx4expr ) ;
      #endif
   }

   return 1 ;
}
#endif

#ifdef S4PASCAL_DOS
/* 20-file handle fix for Pascal DOS */

void setfilemax (void) ;
#pragma startup setfilemax 0
#ifdef P4ARGS_USED
   #pragma argsused
#endif

void setfilemax (void)
{
   asm
   {
      /*;   If default number of file handles have changed then tell DOS*/
      cmp     _nfile, 20
      jbe     NoChange
      cmp     [_osmajor], 3   ;/* Check for >= DOS 3.3*/
      jb      NoChange
      ja      DoChange
      cmp     [_osminor], 1Eh
      jb      NoChange
   }

   DoChange:
      asm
      {
         mov     ax, 5801h      /*; Set last fit allocation*/
         mov     bx, 2
         int     21h
         jc      BadInit

         mov     ah, 67h        /*; Expand handle table*/
         mov     bx, _nfile
         int     21h
         jc      BadInit

         mov     ax, 5801h      /*; Set first fit allocation*/
         mov     bx, 0
         int     21h
         jnc     NoChange

      }

   BadInit:
         abort () ;

   NoChange:
         return ;
}

int far PASCAL LibMain( HANDLE hInstance, WORD wDataSeg, WORD cbHeapSize, LPSTR lpCmdLine )
{
   _nfile = 255 ;
   setfilemax() ;
   return 1 ;
}
#endif   /* S4PASCAL_DOS */

#ifndef S4WIN32
#ifndef S4PASCAL_DOS
#ifdef S4WINDOWS
#ifdef P4ARGS_USED
   #pragma argsused
#endif
int far PASCAL LibMain( HINSTANCE hInstance, WORD wDataSeg, WORD cbHeapSize, LPSTR lpCmdLine )
{
   if ( !cb5inst )
      cb5inst = hInstance ;

   return 1 ;
}
#endif   /* S4WINDOWS */
#endif   /* S4PASCAL_DOS */

#ifdef P4ARGS_USED
   #pragma argsused
#endif
int S4FUNCTION WEP( int nParameter )
{
   return 1 ;
}

#else

BOOL APIENTRY DllMain( HANDLE hModule, DWORD reasonForCall, LPVOID reserved )
{
   if ( !cb5inst )
      cb5inst = hModule ;

   return 1 ;
}

#endif   /* S4WIN32 */

#ifndef S4PASCAL_DOS
HINSTANCE S4FUNCTION c4dllInst( void )
{
   return cb5inst ;
}
#endif   /* S4PASCAL_DOS */

#endif   /* __DLL__ */

#ifndef S4OFF_COMMUNICATIONS
#ifndef S4SERVER
static int code4userConnect( CODE4 *c4, const char *userName, const char *password )
{
   int rc ;
   long version ;
   CONNECTION4 *connection ;
   static char defaultUser[] = "PUBLIC" ;

   if ( c4->defaultServer == 0 )
      return 0 ;
   connection = c4->defaultServer->connect ;
   if ( connection == 0 )
      return 0 ;

   if ( userName == 0 )
      userName = defaultUser ;
   else
      if ( userName[0] == 0 )
         userName = defaultUser ;
   if ( password == 0 )
      password = "" ;

   connection4assign( connection, CON4CONNECT, 0L, 0L ) ;
   version = S4VERSION ;
   connection4addData( connection, &version, sizeof( version ), 0 ) ;
   connection4addData( connection, userName, strlen( userName ) + 1, 0 ) ;
   connection4addData( connection, password, strlen( password ) + 1, 0 ) ;
   connection4send( connection ) ;
   rc = connection4receive( connection ) ;
   if ( rc < 0 )
      return rc ;
   rc = connection4status( connection ) ;
   if ( rc < 0 )
      connection4error( connection, c4, rc, E91005 ) ;
   return rc ;
}

int S4FUNCTION code4connect( CODE4 *c4, const char *serverId, const char *processId, const char *userName, const char *password, const char *protocol )
{
   int rc ;
   #ifndef S4DOS
      int len ;
   #endif

   #ifdef S4VBASIC
      if ( c4parm_check( c4, 1, E91004 ) )
         return 0 ;
   #endif

   #ifdef E4PARM_HIGH
      if ( c4 == 0 )
         return error4( 0, e4parm_null, E91004 ) ;
   #endif

   if ( c4->defaultServer != 0 )
      return r4connected ;

   #ifndef S4DOS
      if ( c4->protocol[0] == 0 )
      {
         if ( protocol == 0 )
            return error4( 0, e4parm_null, E81005 ) ;
         if ( protocol[0] == 0 )
            return error4( 0, e4parm_null, E81005 ) ;
      }

      if ( protocol != 0 )
         if ( protocol[0] != 0 )
         {
            len = strlen( protocol ) ;
            #ifdef E4PARM_HIGH
               if ( len > LEN4PROTOCOL )
                  return error4( 0, e4parm, E81005 ) ;
            #endif
            memcpy( c4->protocol, protocol, len ) ;
            c4->protocol[len] = 0 ;
         }
   #endif

   c4->defaultServer = socket4alloc( c4 ) ;
   if ( c4->defaultServer == 0 )
      return error4( c4, e4connection, E81001 ) ;

   if ( serverId == 0 )
      serverId = DEF4SERVER_ID ;
   else
      if ( serverId[0] == 0 )
         serverId = DEF4SERVER_ID ;
   if ( processId == 0 )
      processId = DEF4PROCESS_ID ;
   else
      if ( processId[0] == 0 )
         processId = DEF4PROCESS_ID ;

   rc = socket4init( c4->defaultServer, c4, serverId, processId ) ;
   if ( rc == 0 )
      rc = socket4connect( c4->defaultServer, serverId, processId ) ;
   #ifndef S4UTILS
      if ( rc == 0 )
         rc = code4userConnect( c4, userName, password ) ;
   #endif

   if ( rc != 0 )
   {
      socket4initUndo( c4->defaultServer ) ;
      socket4free( c4->defaultServer ) ;
      c4->defaultServer = 0 ;
      return rc ;
   }

   return 0 ;
}

#ifdef S4UTIL
int S4FUNCTION code4passwordSet( CODE4 *c4, const char *userId, const char *oldPass, const char *newPass ) ;
{
   CONNECTION4 *connection ;
   unsigned short int len[3] ;

   #ifdef E4PARM_HIGH
      if ( userId == 0 || oldPass == 0 || newPass == 0 )
         return error4( c4, e4parmNull, E91017 ) ;
   #endif

   connection = c4->defaultServer->connect ;
   if ( connection == 0 )  /* not connected */
      return error4( c4, e4connection, E91017 ) ;

   connection4assign( connection, CON4PASSWORD_SET, 0L, 0L ) ;
   len[0] = strlen( userId ) ;
   len[1] = strlen( oldPass ) ;
   len[2] = strlen( newPass ) ;
   connection4send( connection ) ;
   connection4addData( connection, len, sizeof( len ), 0 ) ;
   connection4addData( connection, userId, len[0], 0 ) ;
   connection4addData( connection, oldPass, len[1], 0 ) ;
   connection4addData( connection, newPass, len[2], 0 ) ;
   rc = connection4receive( connection ) ;
   if ( rc < 0 )
      return rc ;
   return connection4status( connection ) ;
}
#endif /* S4UTIL */
#endif /* S4SERVER */
#endif /* S4OFF_COMMUNICATIONS */

#ifdef P4ARGS_USED
   #pragma argsused
#endif
int S4FUNCTION code4initLow( CODE4 *c4, const char *defaultProtocol, long versionId )
{
   char v1[10], v2[10] ;
#ifdef S4WINDOWS
	 int n;
#endif

   #ifdef S4TESTING
      int exclusiveFlag ;
      int openFlag ;
      char *envLog ;
      #ifdef S4CASE_SEN
         char *logFile = "T4TEST.log" ;
      #else
         char *logFile = "T4TEST.LOG" ;
      #endif
   #else
      #ifdef S4TRACK_FILES
         int openFlag ;
         char *envLog ;
         #ifdef S4CASE_SEN
            char *logFile = "T4TEST.log" ;
         #else
            char *logFile = "T4TEST.LOG" ;
         #endif
      #endif
   #endif
   #ifndef S4SERVER
      int rc ;
   #endif
   #ifdef S4CLIENT
      #ifndef S4DOS
         int len ;
      #endif
   #endif
   #ifndef S4OFF_OPTIMIZE
      #ifdef S4OPTIMIZE_STATS
         DATA4 *stat ;
         int oldOffErr ;
      #endif
   #endif

   #ifdef E4PARM_HIGH
      if ( c4 == 0 )
         return error4( 0, e4parm, E91001 ) ;
   #endif

   /***********************************************************************

      This code must reside at the beginning of the function to ensure that
      no file open/create incorrectly auto-starts the optimization process

    ***********************************************************************/

   #ifdef S4WINDOWS
     n = SetHandleCount(40);
   #endif
   #ifndef S4OFF_OPTIMIZE
      c4->hadOpt = 1 ;
   #endif

   #ifdef S4TESTING
      if ( numCode4 == 0 )
      {
         memset( &s4test, 0, sizeof( s4test ) ) ;
         s4test.hand = -1 ;
      }
   #else
      #ifdef S4TRACK_FILES
         if ( numCode4 == 0 )
         {
            memset( &s4test, 0, sizeof( s4test ) ) ;
            s4test.hand = -1 ;
         }
      #endif
   #endif

   if ( versionId != S4VERSION )
   {
      c4ltoa45( e4version, v1, sizeof( v1 ) ) ;
      c4ltoa45( S4VERSION, v2, sizeof( v2 ) ) ;
      return error4describe( c4, e4version, E91001, v1, v2, 0 ) ;
   }

   memset( (void *)c4, 0, sizeof( CODE4 ) ) ;

   /* if a DLL, can't check the stack length since this is a separate executable */
   #ifndef S4WIN32
      #ifndef S4WINDOWS
         #ifndef __DLL__
            #ifdef __TURBOC__
               #ifndef S4OS2PM
                  if ( _stklen < 5000U ) /* 5000 seems to be an appropriate minimum */
                        return error4( c4, e4result, E81003 ) ;
               #endif
            #endif
         #endif
         #ifdef _MSC_VER
            if ( stackavail() < 5000U )
               error4( c4, e4result, E81003 ) ;
         #endif
      #endif
   #endif

   if ( numCode4 == 0 )
      mem4init() ;
   numCode4++ ;

   #ifdef E4ANALYZE
      c4->debugInt = E4DEBUG_INT ; /* Some random value for double checking. */
   #else
      #ifdef S4VBASIC
         c4->debugInt = E4DEBUG_INT ; /* Some random value for double checking. */
      #endif  /* S4VBASIC */
   #endif  /* E4MISC */

   #ifndef S4OFF_MEMO
      c4->memSizeMemoExpr = 0x400 ;        /*  1024 */
   #endif

   c4->numericStrLen = 17 ;    /* default length for clipper numeric keys is 10  */
   c4->decimals = 2 ;

   /* Flags initialization */

   c4->errCreate =  1 ;
   c4->errDefaultUnique = r4uniqueContinue ;
   c4->errExpr = 1 ;
   c4->errFieldName = 1 ;
   c4->errOpen = 1 ;
   #ifndef S4OFF_INDEX
      c4->errTagName = 1 ;
   #endif
   c4->autoOpen = 1 ;
   c4->safety = 1 ;

   #ifndef S4OFF_MULTI
      c4->lockDelay = 100 ;
   #endif

   c4->collatingSequence = sort4machine ;   /* default to FoxPro 2.x values */
   c4->codePage = cp0 ;

   c4->memStartDataFile = 5 ;
   c4->memExpandDataFile = 5 ;
   #ifndef S4OFF_INDEX
      c4->memStartTagFile = 10 ;
      c4->memExpandTagFile =5 ;
   #endif

   #ifndef S4SINGLE
      c4->memStartLock = 5 ;
      c4->memExpandLock = 10 ;
   #endif

   #ifndef N4OTHER
      c4->memStartIndexFile = 5 ;
      c4->memExpandIndexFile = 5 ;
   #endif

   #ifndef S4OFF_MULTI
      c4->lockAttemptsSingle = 1 ;
   #endif

   #ifdef S4SERVER
      #ifdef S4DEBUG_LOG
         c4->logFile.hand = -1 ;
      #endif
      c4->lockAttempts = 1 ;
      c4->memStartClient = 5 ;
      c4->memExpandClient = 5 ;
      #ifdef N4OTHER
         c4->memStartIndex = 10 ;
         c4->memStartTag = 10 ;
         c4->memExpandIndex = 5 ;
         c4->memExpandTag = 10 ;
      #endif
   #else
      c4->errGo = 1 ;
      c4->errSkip = 1 ;
      c4->errRelate = 1 ;
      #ifndef S4OFF_MULTI
         c4->lockAttempts = WAIT4EVER ;   /* wait forever */
      #endif
      c4->singleOpen = 1 ;
      #ifndef S4OFF_ENFORCE_LOCK
         c4->lockEnforce = 0 ;
      #endif
      #ifdef S4OFF_OPTIMIZE
         #ifndef S4OFF_INDEX
            c4->memSizeBlock = 0x400 ;        /*  1024 */
         #endif
      #else
         c4->memSizeBlock = 0x400 ;        /*  1024 */
      #endif
      c4->memSizeSortPool = 0xF000 ;    /* 61440 */
      c4->memSizeSortBuffer = 0x1000 ;  /*  4096 */
      c4->memSizeBuffer = 0x8000 ;      /* 32768 */
      #ifndef S4OFF_MEMO
         c4->memSizeMemo = 0x200 ;         /*   512 */
      #endif
      c4->memStartData = 10 ;
      c4->memExpandData = 5 ;
      #ifndef S4OFF_INDEX
         c4->memExpandBlock = 10 ;
         c4->memStartBlock = 10 ;
         c4->memStartIndex = 10 ;
         c4->memStartTag = 10 ;
         c4->memExpandIndex = 5 ;
         c4->memExpandTag = 10 ;
      #endif
   #endif

   #ifdef S4CLIENT
      #ifndef S4DOS
         if ( defaultProtocol != 0 )
         {
            len = strlen( defaultProtocol ) ;
            #ifdef E4PARM_HIGH
               if ( len > LEN4PROTOCOL )
                  return error4( 0, e4parm, E81005 ) ;
            #endif
            memcpy( c4->protocol, defaultProtocol, len ) ;
            c4->protocol[len] = 0 ;
         }
      #endif
   #else
      c4->doIndexVerify = 1 ;
   #endif

   #ifndef S4OFF_TRAN
      #ifndef S4OFF_WRITE
         #ifndef S4CIENT
            c4->log = LOG4ON ;
         #endif
         #ifdef S4STAND_ALONE
            c4->logOpen = 1 ;
         #endif
      #endif
   #endif

   #ifndef S4OFF_COMMUNICATIONS
      #ifdef S4TIMEOUT_HOOK
         c4->timeout = 100 ;
      #else
         c4->timeout = -1 ;
      #endif
   #endif

   #ifndef S4OPTIMIZE_OFF
      c4->doOpt = 1 ;   /* by default do optimization */
      #ifndef S4SERVER
         c4->optimize = OPT4EXCLUSIVE ;   /* by default optimize non-shared files */
         c4->optimizeWrite = OPT4EXCLUSIVE ;
      #endif  /* S4SERVER */
   #endif  /* not S4OPTIMIZE_OFF */

   #ifndef S4SERVER
      rc = code4tranInit( c4 ) ;
      if ( rc < 0 )
         return error4( c4, rc, E91001 ) ;

      #ifndef S4OFF_COMMUNICATIONS
         c4->clientDataCount = 1 ;
      #endif

      #ifndef S4LANGUAGE
         code4dateFormatSet( c4, "MM/DD/YY" ) ;
      #else
         #ifdef S4GERMAN
            code4dateFormatSet( c4, "DD.MM.YY" ) ;
         #endif
         #ifdef S4FRENCH
            code4dateFormatSet( c4, "MM/DD/YY" ) ;
         #endif
         #ifdef S4SWEDISH
            code4dateFormatSet( c4, "YYYY-MM-DD" ) ;
         #endif
         #ifdef S4FINNISH
            code4dateFormatSet( c4, "YYYY-MM-DD" ) ;
         #endif
         #ifdef S4NORWEGIAN
            code4dateFormatSet( c4, "DD-MM-YYYY" ) ;
         #endif
      #endif
   #endif

   c4->initialized = 1 ;

   if ( numCode4 == 1 )
   {
      #ifdef S4TESTING
         openFlag = c4->errOpen ;
         exclusiveFlag = c4->accessMode ;
         c4->errOpen = 0 ;
         c4->accessMode = OPEN4DENY_NONE ;
         envLog = getenv( "T4LOG" ) ;
         if ( envLog )           /* if env. var. exists, use it */
            logFile = envLog ;
         if ( file4open( &s4test, c4, logFile, 0 ) != r4success )
            file4create( &s4test, c4, logFile, 0 ) ;
         c4->accessMode = exclusiveFlag ;
         c4->errOpen = openFlag ;
      #else
         #ifdef S4TRACK_FILES
            openFlag = c4->errOpen ;
            c4->errOpen = 0 ;
            envLog = getenv( "CB51_LOG" ) ;
            if ( envLog )           /* if env. var. exists, use it */
               logFile = envLog ;
            if ( file4open( &s4test, c4, logFile, 0 ) != r4success )
               file4create( &s4test, c4, logFile, 0 ) ;
            c4->errOpen = openFlag ;
         #endif
      #endif
   }

   #ifndef S4SERVER
      #ifndef S4SINGLE
         #ifdef S4CB51
            code4unlockAutoSet( c4, LOCK4DATA ) ;
         #else
            code4unlockAutoSet( c4, LOCK4ALL ) ;
         #endif
      #endif
   #endif

   #ifndef S4OFF_OPTIMIZE
      #ifdef S4OPTIMIZE_STATS
         stat = c4->statusDbf ;
         if ( stat == 0 )  /* open the stat database */
         {
            oldOffErr = c4->errOpen ;
            c4->errOpen = 0 ;
            c4->statusDbf = d4open( c4, "OPT4STAT" ) ;
            c4->errOpen = oldOffErr ;
            stat = c4->statusDbf ;
            if ( stat == 0 )
               error4set( c4, 0 ) ;
            else
            {
               d4optimize( stat, OPT4OFF ) ;
               c4->typeFld = d4field( stat, "TYPE" ) ;
               c4->fileNameFld = d4field( stat, "FILE_NAME" ) ;
               c4->offsetFld = d4field( stat, "OFFSET" ) ;
               c4->lengthFld = d4field( stat, "LENGTH" ) ;
               if ( c4->typeFld == 0 || c4->fileNameFld == 0 || c4->offsetFld == 0 || c4->lengthFld == 0 )
               {
                  d4close( stat ) ;
                  c4->statusDbf = 0 ;
               }
            }
         }
      #endif
   #endif /* S4OFF_OPTIMIZE */

   #ifdef S4WRITE_DELAY
      /* if the begin thread fails, then delay-writes are simply not enabled,
         which is ok because it will simply be bypassed. */
      InitializeCriticalSection( &c4->critical4delayWriteList ) ;
      c4->pendingWriteEvent = CreateEvent( 0, TRUE, FALSE, 0 ) ;
      if ( c4->pendingWriteEvent != INVALID_HANDLE_VALUE )
      {
         /* cast unsigned long to long for BORLAND C++ avoid warning message
            (verified with Borland) */
         if ( (long)_beginthread( file4writeDelayMain, 5000, c4 ) == -1 )
         {
            CloseHandle( c4->pendingWriteEvent ) ;
            DeleteCriticalSection( &c4->critical4delayWriteList ) ;
         }
         else
            while ( c4->delayWritesEnabled != 1 )  /* ensure thread starts to avoid initUndo thread corruptions */
               Sleep( 0 ) ;
      }
   #endif

   #ifdef S4READ_ADVANCE
      /* if the begin thread fails, then delay-writes are simply not enabled,
         which is ok because it will simply be bypassed. */
      InitializeCriticalSection( &c4->critical4advanceReadList ) ;
      c4->pendingReadEvent = CreateEvent( 0, TRUE, FALSE, 0 ) ;
      if ( c4->pendingReadEvent != INVALID_HANDLE_VALUE )
      {
         /* cast unsigned long to long for BORLAND C++ avoid warning message
            (verified with Borland) */
         if ( (long)_beginthread( file4advanceReadMain, 5000, c4 ) == -1 )
         {
            CloseHandle( c4->pendingReadEvent ) ;
            DeleteCriticalSection( &c4->critical4advanceReadList ) ;
         }
         else
            while ( c4->advanceReadsEnabled != 1 )  /* ensure thread starts to avoid initUndo thread corruptions */
               Sleep( 0 ) ;
      }
   #endif

   /***********************************************************************

      This code must reside at the end of the function to ensure that no
      file open/create incorrectly auto-starts the optimization process

    ***********************************************************************/
   #ifndef S4OFF_OPTIMIZE
      c4->hadOpt = 1 ;
      #ifdef S4SERVER
         c4->memMaxPercent = -1 ;   /* use server configuration file */
      #else
         c4->memMaxPercent = 25 ;   /* default use 25% of available memory */
      #endif
      #ifdef S4OS2
         c4->memStartMax = 0xF0000L ;
      #else
         #ifndef S4WINTEL
            c4->memStartMax = 0xF0000L ;
         #else
            #ifdef S4WINDOWS
               c4->memStartMax = 0xF0000L ;
            #else
               c4->memStartMax = 0x50000L ;
            #endif  /* S4WINDOWS */
         #endif
      #endif
   #endif

   return 0 ;
}

/* if doInit is set to 1, code4init() is called on the allocated CODE4 */
CODE4 *S4FUNCTION code4allocLow( int doInit, const char *defaultProtocol, long versionId )
{
   CODE4 *c4 ;
   #ifndef S4CBPP
      c4 = (CODE4 *)u4alloc( (long)sizeof( CODE4 ) ) ;
   #else
      #ifdef __cplusplus
         c4 = (CODE4 *)u4alloc( (long)sizeof( Code4 ) ) ;
      #else
         c4 = (CODE4 *)u4alloc( (long)sizeof( CODE4 ) ) ;
      #endif
   #endif

   if ( c4 == 0 )
      return 0 ;

   if ( doInit == 1 )
      code4initLow( c4, defaultProtocol, versionId ) ;
   return c4 ;
}

void S4FUNCTION expr4calcDelete( EXPR4CALC *calc )
{
   CODE4 *c4;

   if( !calc || !calc->expr )
      return;

   c4 = calc->expr->codeBase ;

   #ifndef S4SERVER
      if( calc->total != 0 )
      {
         expr4free( calc->total->resetExpression );
         l4remove( &c4->totalList, calc->total ) ;
         mem4free( c4->totalMemory, calc->total ) ;
      }
   #endif
   #ifdef S4SERVER
      l4remove( &c4->currentClient->calcList, calc ) ;
   #else
      l4remove( &c4->calcList, calc ) ;
   #endif
   expr4free( calc->expr ) ;
   mem4free( c4->calcMemory, calc ) ;
}

void S4FUNCTION code4calcReset( CODE4 *c4 )
{
   LIST4 *list ;
   #ifdef S4CLIENT
      CONNECTION4 *connection ;
      int rc ;
   #endif

   #ifdef E4PARM_HIGH
      if ( c4 == 0 )
      {
         error4( 0, e4parm_null, E90921 ) ;
         return ;
      }
   #endif

   #ifdef S4SERVER
      list = &c4->currentClient->calcList ;
   #else
      list = &c4->calcList ;
   #endif

   if( list > (LIST4 *)NULL )
   {
      while( list->nLink > 0 )
         expr4calcDelete( (EXPR4CALC *)list->lastNode ) ;

      #ifdef S4CLIENT
         if ( c4->defaultServer != 0 )
         {
            connection = c4->defaultServer->connect ;
            rc = connection4assign( connection, CON4CALC_RESET, 0, 0 ) ;
            if ( rc < 0 )
               return ;
            connection4send( connection ) ;
            rc = connection4receive( connection ) ;
            if ( rc < 0 )
               return ;
            rc = connection4status( connection ) ;
            if ( rc < 0 )
               connection4error( connection, c4, rc, E90921 ) ;
         }
      #endif
   }
}

#ifdef S4MEM_PRINT
   extern char *write4buf ;
   extern FILE4SEQ_WRITE *file4seqPtr ;
#endif

static int code4initUndo2( CODE4 *c4, int doClose )
{
   #ifdef S4DISTRIBUTED
      #ifdef S4CLIENT
         SOCKET4 *socket, *socketNext ;
      #endif
   #endif
   #ifndef S4OFF_COMMUNICATIONS
      MESSAGE4DATA *message ;
   #endif
   #ifndef S4SERVER
      #ifndef S4OFF_TRAN
      #endif
   #endif

   #ifdef E4PARM_HIGH
      if ( c4 == 0 )
         return e4parm_null ;
   #endif

   if ( c4->initialized == 0 )  /* already uninitialized */
      return 0 ;

   #ifdef E4MISC
      if ( numCode4 == 0 )   /* code4initUndo already called... */
      {
         if ( doClose == 1 )   /* if zero, don't error out since severe already */
            return error4( 0, e4info, E81004 ) ;
         else
            return e4info ;
      }
   #endif

   #ifdef S4SEMAPHORE
      #ifdef S4OS2
         DosCloseMutexSem( hmtx4mem ) ;
         DosCloseMutexSem( hmtx4expr ) ;
      #endif
   #endif

   #ifndef S4OPTIMIZE_OFF
      code4optSuspend( c4 ) ;
   #endif

   #ifndef S4SERVER
      #ifndef S4OFF_TRAN
         #ifndef S4CLIENT
            if ( code4transEnabled( c4 ) )
         #endif
         if ( code4tranStatus( c4 ) == r4active )
            code4tranRollback( c4 ) ;
      #endif

      if ( doClose )
         code4close( c4 ) ;
   #endif

   #ifndef S4SERVER
      code4calcReset( c4 ) ;
      #ifndef S4OFF_COMMUNICATIONS
         #ifdef S4DISTRIBUTED
            socketNext = (SOCKET4 *)l4first( &c4->servers ) ;
            for ( ;; )
            {
               socket = socketNext ;
               if ( socket == 0 )
                  break ;
               socketNext = (SOCKET4 *)l4next( &c4->servers, socket ) ;
               socket4initUndo( socket ) ;
               l4remove( &c4->servers, socket ) ;
               socket4free( socket ) ;
            }
         #else
            if ( c4->defaultServer != 0 )
            {
               socket4initUndo( c4->defaultServer ) ;
               socket4free( c4->defaultServer ) ;
            }
         #endif
         c4->defaultServer = 0 ;
      #endif

      #ifndef S4OFF_TRAN
         code4tranInitUndo( c4 ) ;
      #endif
   #endif

   #ifdef S4OPTIMIZE_STATS
      if ( c4->statusDbf != 0 )
      {
         d4close( c4->statusDbf ) ;
         c4->statusDbf = 0 ;
      }
   #endif

   if ( c4->version != 0 )
   {
      u4free( c4->version ) ;
      c4->version = 0 ;
   }

   #ifdef S4MNDX
      if ( c4->memoUseBuffer != 0 )
      {
         u4free( c4->memoUseBuffer ) ;
         c4->memoUseBuffer = 0 ;
      }
   #endif

   #ifdef S4WRITE_DELAY
      /* set the event semaphore to terminate the delay-write thread */
      if ( c4->delayWritesEnabled )
      {
         c4->initUndoDelayWrite = CreateEvent( 0, TRUE, FALSE, 0 ) ;
         if ( c4->initUndoDelayWrite != INVALID_HANDLE_VALUE )
         {
            InterlockedIncrement( &c4->uninitializeDelayWrite ) ;
            /* notify the write thread */
            if ( SetEvent( c4->pendingWriteEvent ) == TRUE ) /* wait for the delay-write thread to uninitialize */
               WaitForSingleObject( c4->initUndoDelayWrite, INFINITE ) ;
            CloseHandle( c4->initUndoDelayWrite ) ;
            CloseHandle( c4->pendingWriteEvent ) ;
            DeleteCriticalSection( &c4->critical4delayWriteList ) ;
         }
      }
   #endif

   #ifdef S4READ_ADVANCE
      /* set the event semaphore to terminate the advance-read thread */
      if ( c4->advanceReadsEnabled )
      {
         c4->initUndoAdvanceRead = CreateEvent( 0, TRUE, FALSE, 0 ) ;
         if ( c4->initUndoAdvanceRead != INVALID_HANDLE_VALUE )
         {
            InterlockedIncrement( &c4->uninitializeAdvanceRead ) ;
            /* notify the write thread */
            if ( SetEvent( c4->pendingReadEvent ) == TRUE ) /* wait for the delay-write thread to uninitialize */
               WaitForSingleObject( c4->initUndoAdvanceRead, INFINITE ) ;
            CloseHandle( c4->initUndoAdvanceRead ) ;
            CloseHandle( c4->pendingReadEvent ) ;
            DeleteCriticalSection( &c4->critical4advanceReadList ) ;
         }
      }
   #endif

   #ifndef S4OFF_INDEX
      mem4release( c4->indexMemory ) ;
      c4->indexMemory = 0 ;

      mem4release( c4->index4fileMemory ) ;
      c4->index4fileMemory = 0 ;
   #endif

   mem4release( c4->dataMemory ) ;
   c4->dataMemory = 0 ;

   mem4release( c4->data4fileMemory ) ;
   c4->data4fileMemory = 0 ;

   #ifndef S4OFF_MULTI
      mem4release( c4->lockMemory ) ;
      c4->lockMemory = 0 ;

      mem4release( c4->lockLinkMemory ) ;
      c4->lockLinkMemory = 0 ;
   #endif

   #ifndef S4OFF_INDEX
      mem4release( c4->tagMemory ) ;
      c4->tagMemory = 0 ;

      mem4release( c4->tagFileMemory ) ;
      c4->tagFileMemory = 0 ;
   #endif

   mem4release( c4->dataListMemory ) ;
   c4->dataListMemory = 0 ;
   mem4release( c4->relateDataListMemory ) ;
   c4->relateDataListMemory = 0 ;
   mem4release( c4->relateMemory ) ;
   c4->relateMemory = 0 ;
   mem4release( c4->relateListMemory ) ;
   c4->relateListMemory = 0 ;
   mem4release( c4->relationMemory ) ;
   c4->relationMemory = 0 ;

   mem4release( c4->calcMemory ) ;
   c4->calcMemory = 0 ;

   #ifdef S4SERVER
      if ( c4->catalogClient != 0 )
      {
         mem4free( c4->clientMemory, c4->catalogClient ) ;
         c4->catalogClient = 0 ;
      }
      mem4release( c4->clientMemory ) ;
      c4->clientMemory = 0 ;
   #endif

   #ifndef S4STAND_ALONE
      message4release( c4 ) ;
   #endif

   mem4release( c4->bitmapMemory ) ;
   c4->bitmapMemory = 0 ;

   if ( c4->fieldBuffer != 0 )
   {
      u4free( c4->fieldBuffer ) ;
      c4->fieldBuffer = 0 ;
      c4->bufLen = 0 ;
   }

   if ( c4->exprWorkBuf != 0 )
   {
      u4free( c4->exprWorkBuf ) ;
      c4->exprWorkBuf = 0 ;
      c4->exprBufLen = 0 ;
   }

   if ( c4->storedKey != 0 )
   {
      u4free( c4->storedKey ) ;
      c4->storedKey = 0 ;
      c4->storedKeyLen = 0 ;
   }

   if ( c4->errorLog != 0 )
   {
      if ( c4->errorLog->hand > 0 )
         file4close( c4->errorLog ) ;
      u4free( c4->errorLog ) ;
      c4->errorLog = 0 ;
   }

   #ifdef E4ANALYZE
      c4->debugInt = 0 ; /* Some random value for double checking. */
   #endif

   #ifdef S4DEBUG_LOG
      #ifdef S4SERVER
         code4logInitUndo( c4 ) ;
      #endif
   #endif

   #ifndef S4OFF_TRAN
      if ( c4->tranData != 0 )
      {
         u4free( c4->tranData ) ;
         c4->tranData = 0 ;
         c4->tranDataLen = 0 ;
      }
   #endif

   #ifndef S4OFF_COMMUNICATIONS
      for ( ;; )
      {
         message = (MESSAGE4DATA *)l4pop( &c4->availDataMessages ) ;
         if ( message == 0 )
            break ;
         if ( message->didAlloc == 1 )
         {
            u4free( message->allocatedData ) ;
            message->didAlloc = 0 ;
         }
         mem4free( c4->messageLinkMemory, message ) ;
      }
      mem4release( c4->messageLinkMemory ) ;
      c4->messageLinkMemory = 0 ;
      mem4release( c4->connectionMemory ) ;
      c4->connectionMemory = 0 ;
      mem4release( c4->connectionNetMemory ) ;
      c4->connectionNetMemory = 0 ;
   #endif

   numCode4-- ;
   #ifdef S4TESTING
      if ( s4test.codeBase == c4 )
      {
         if ( s4test.hand )
         {
            #ifdef S4MEM_PRINT
               if ( write4buf != 0 )
               {
                  file4seqWriteFlush( file4seqPtr ) ;
                  u4free( write4buf ) ;
                  write4buf = 0 ;
               }
            #endif
            file4close( &s4test ) ;
         }
      }
   #else
      #ifdef S4TRACK_FILES
         if ( s4test.codeBase == c4 )
            if ( s4test.hand )
               file4close( &s4test ) ;
      #endif
   #endif

   if ( numCode4 == 0 )   /* reset memory */
      mem4reset() ;

   c4->initialized = 0 ;
   return error4code( c4 ) ;
}

#ifndef S4SERVER
void S4FUNCTION code4exit( CODE4 *c4 )
{
   #ifndef S4WINDOWS
      int rc ;

      if ( c4 == 0 )
         rc = -1 ;
      else
      {
         rc = c4->errorCode ;
   #endif
      code4initUndo2( c4, 0 ) ;
      #ifdef E4MISC
         #ifdef S4TESTING
            mem4freeCheck( 100 ) ;
            mem4checkMemory() ;
            mem4reset() ;
         #endif
      #endif
   #ifndef S4WINDOWS
      }
      exit( rc ) ;
   #else
      #ifdef S4TESTING
         u4terminate() ;
      #else
         FatalAppExit( 0, E4_MESSAG_EXI ) ;
      #endif
   #endif
}
#endif /* S4SERVER */

int S4FUNCTION code4initUndo( CODE4 *c4 )
{
   #ifdef S4SERVER
      return code4initUndo2( c4, 0 ) ;
   #else
      return code4initUndo2( c4, 1 ) ;
   #endif
}

#ifndef S4SERVER
int S4FUNCTION code4close( CODE4 *c4 )
{
   DATA4 *dataOn, *dataNext ;
   LIST4 *list ;

   #ifdef S4VBASIC
      if ( c4parm_check( c4, 1, E91003 ) )
         return -1 ;
   #endif  /* S4VBASIC */

   #ifdef E4PARM_HIGH
      if ( c4 == 0 )
         return error4( 0, e4parm_null, E91003 ) ;
   #endif

   list = tran4dataList( (&(c4->c4trans.trans)) ) ;
   for ( dataNext = (DATA4 *)l4first( list ) ; ; )
   {
      dataOn = dataNext ;
      if ( dataOn == 0 )
         break ;
      dataNext = (DATA4 *)l4next( list, dataNext ) ;
      if ( dataOn == dataNext )   /* error -- stuck in endless loop */
         return -1 ;
      #ifndef S4OFF_OPTIMIZE
         #ifdef S4OPTIMIZE_STATS
            /* don't close the internal opt tracking dbf here. */
            if ( dataOn != dataOn->codeBase->statusDbf )
         #endif
      #endif
         d4close( dataOn ) ;
   }

   if ( error4code( c4 ) < 0 )
      return error4code( c4 ) ;
   return 0 ;
}
#endif

/* input must be in capital letters */
DATA4FILE *dfile4data( CODE4 *c4, const char *aliasName )
{
   DATA4FILE *dataOn ;
   #ifdef E4MISC
      DATA4FILE *dataResult ;
   #endif

   #ifdef E4PARM_LOW
      if ( c4 == 0 || aliasName == 0 )
      {
         error4( c4, e4parm_null, E91102 ) ;
         return 0 ;
      }
   #endif

   dataOn = 0 ;
   #ifdef E4MISC
      dataResult = 0 ;
   #endif

   for(;;)
   {
      dataOn = (DATA4FILE *)l4next( &c4->dataFileList, dataOn ) ;
      if ( !dataOn )
         break ;

      if ( strcmp( aliasName, dfile4name( dataOn ) ) == 0 )
      {
         #ifdef E4MISC
            if ( dataResult != 0 )
            {
               error4( c4, e4info, E83501 ) ;
               return 0 ;
            }
            dataResult = dataOn ;
         #else
            return dataOn ;
         #endif  /* E4MISC */
      }
   }

   #ifdef E4MISC
      return dataResult ;
   #else
      return dataOn ;
   #endif
}

#ifdef P4ARGS_USED
   #pragma argsused
#endif
DATA4 *tran4dataName( TRAN4 *trans, const char *name, const long clientId, const int doPath )
{
   DATA4 *dataOn ;
   #ifdef E4MISC
      DATA4 *dataResult ;
   #endif
   #ifndef S4CLIENT
      char name1[258] ;
   #endif

   #ifdef E4ANALYZE
      if ( tran4verify( trans, 1 ) < 0 )
         return 0 ;
   #endif

   dataOn = 0 ;
   #ifdef E4MISC
      dataResult = 0 ;
   #endif

   #ifndef S4CLIENT
      u4nameCurrent( name1, sizeof( name1 ), name ) ;
      #ifdef S4CASE_SEN
         u4nameExt( name1, sizeof( name1 ), ".dbf", 0 ) ;
      #else
         u4nameExt( name1, sizeof( name1 ), ".DBF", 0 ) ;
      #endif
   #endif

   for (;; )
   {
      dataOn = (DATA4 *)l4next( tran4dataList( trans ), dataOn ) ;
      if ( dataOn == 0 )
         break ;
      if ( strcmp( name, d4alias( dataOn ) ) == 0 )  /* try simple alias check */
      {
         #ifdef S4SERVER
            if ( clientId != 0 )
               dataOn->clientId = clientId ;
         #endif
         #ifdef E4MISC
            if ( dataResult != 0 )
            {
               error4( trans->c4trans->c4, e4info, E83501 ) ;
               return 0 ;
            }
            dataResult = dataOn ;
         #else
            return dataOn ;
         #endif
      }
      #ifndef S4CLIENT
         #ifdef E4MISC
            else
         #endif
         /* otherwise, try file name check */
         if ( doPath )
            if ( strcmp( name1, dataOn->dataFile->file.name ) == 0 )
            {
               #ifdef S4SERVER
                  if ( clientId != 0 )
                     dataOn->clientId = clientId ;
               #endif
               #ifdef E4MISC
                  if ( dataResult != 0 )
                  {
                     error4( trans->c4trans->c4, e4info, E83501 ) ;
                     return 0 ;
                  }
                  dataResult = dataOn ;
               #else
                  return dataOn ;
               #endif
            }
      #endif
   }
   #ifdef E4MISC
      return dataResult ;
   #else
      return dataOn ;
   #endif
}

/* gets the data4 corresponding to the serverId, and sets the current clientId to clientId */
DATA4 *tran4data( TRAN4 *trans, const long serverId, const long clientId )
{
   DATA4 *dataOn ;
   #ifdef E4MISC
      DATA4 *dataResult ;
   #endif
   #ifdef S4SERVER
      int rc = 0 ;
   #endif

   #ifdef E4ANALYZE
      if ( tran4verify( trans, 1 ) < 0 )
         return 0 ;
   #endif

   dataOn = 0 ;
   #ifdef E4MISC
      dataResult = 0 ;
   #endif

   for (;; )
   {
      dataOn = (DATA4 *)l4next( tran4dataList( trans ), dataOn ) ;
      if ( dataOn == 0 )
         break ;
      if ( data4serverId( dataOn ) == serverId )
      {
         dataOn->clientId = clientId ;
         #ifdef E4MISC
            if ( dataResult != 0 )
            {
               error4( trans->c4trans->c4, e4info, E83501 ) ;
               return 0 ;
            }
            dataResult = dataOn ;
         #else
            break ;
         #endif
      }
   }

   /*
   #ifdef S4SERVER
      #ifdef E4MISC
         if ( dataResult != 0 )
            rc = d4tagUniqueSync( dataResult ) ;
      #else
         if ( dataOn != 0 )
            rc = d4tagUniqueSync( dataOn ) ;
      #endif
      if ( rc < 0 )
         return 0 ;
   #endif
   */

   #ifdef E4MISC
      return dataResult ;
   #else
      return dataOn ;
   #endif
}

DATA4 *S4FUNCTION code4data( CODE4 *c4, const char *aliasName )
{
   char buf[12] ;
   #ifdef S4SERVER
      RELATE4 *relate ;
   #endif

   #ifdef S4VBASIC
      if ( c4parm_check( c4, 1, E91102 ) )
         return 0 ;
   #endif  /* S4VBASIC */

   #ifdef E4PARM_HIGH
      if ( c4 == 0 || aliasName == 0 )
      {
         error4( c4, e4parm_null, E91102 ) ;
         return 0 ;
      }
   #endif

   u4ncpy( buf, aliasName, sizeof( buf ) ) ;
   #ifndef S4CASE_SEN
      c4upper( buf ) ;
   #endif

   #ifdef S4SERVER
      if ( c4->currentRelation == 0 )
         return tran4dataName( code4trans( c4 ), buf, 0L, 1 ) ;

      relate = &(c4->currentRelation->relate) ;
      for ( ;; )
      {
         if ( relate == 0 )
            return 0 ;
         if ( strcmp( aliasName, d4alias( relate->data ) ) == 0 )
            return relate->data ;
         if ( relate4next( &relate ) == 2 )
            return 0 ;
      }
   #else
      return tran4dataName( code4trans( c4 ), buf, 0L, 0 ) ;
   #endif
}

const char *code4version( CODE4 *c4 )
{
   char ver[] = "S4VERSION" ;

   #ifdef E4PARM_HIGH
      if ( c4 == 0 )
      {
         error4( 0, e4parm_null, E91111 ) ;
         return 0 ;
      }
   #endif
   if ( c4->version == 0 )
   {
      c4->version = (char *)u4allocFree( c4, (long)sizeof( ver ) ) ;
      if ( c4->version == 0 )
         return 0 ;
      memcpy( c4->version, ver, sizeof( ver ) ) ;
   }
   return c4->version ;
}

#ifdef S4CLIENT
/* used for testing only */
int S4FUNCTION code4catalogSet( CODE4 *c4, int catalogAdd, int catalogStatus )
{
   CONNECTION4 *connection ;
   CONNECTION4CATALOG_SET_INFO_IN infoIn ;
   int rc ;

   if ( c4->defaultServer != 0 )
   {
      connection = c4->defaultServer->connect ;
      connection4assign( connection, CON4CATALOG, 0L, 0L ) ;
      infoIn.catalogAdd = catalogAdd ;
      infoIn.catalogStatus = catalogStatus ;
      connection4addData( connection, &infoIn, sizeof(CONNECTION4CATALOG_SET_INFO_IN), 0 ) ;
      connection4send( connection ) ;
      rc = connection4receive( connection ) ;
      if ( rc < 0 )
         return rc ;

      rc = connection4status( connection ) ;
      if ( rc < 0 )
         connection4error( connection, c4, rc, 0 ) ;

      return rc ;
   }

   return 0 ;
}

const char *S4FUNCTION code4serverName( CODE4 *c4 )
{
   #ifdef E4PARM_HIGH
      if ( c4 == 0 )
      {
         error4( 0, e4parm_null, E91112 ) ;
         return 0 ;
      }
   #endif

   #ifdef S4OFF_COMMUNICATIONS
      return 0 ;
   #else
      if ( c4->defaultServer == 0 )
         return 0 ;
      return c4->defaultServer->serverName ;
   #endif
}

int S4FUNCTION code4indexFormat( CODE4 *c4 )
{
   #ifdef S4OFF_INDEX
      return 0 ;
   #else
      CONNECTION4 *connection ;
      int rc ;

      #ifdef E4PARM_HIGH
         if ( c4 == 0 )
            return error4( 0, e4parm_null, E91110 ) ;
      #endif

      if ( c4->indexFormat != 0 )
         return c4->indexFormat ;

      if ( c4->defaultServer == 0 )
         return r4unknown ;

      connection = c4->defaultServer->connect ;
      if ( connection == 0 )
         return r4unknown ;
      connection4assign( connection, CON4INDEX_FORMAT, 0L, 0L ) ;
      connection4send( connection ) ;
      rc = connection4receive( connection ) ;
      if ( rc < 0 )
         return error4stack( c4, rc, E91110 ) ;

      rc = connection4status( connection ) ;
      if ( rc < 0 )
         return connection4error( connection, c4, rc, E91110 ) ;

      #ifdef E4MISC
         switch( rc )
         {
            case r4ndx:
            case r4mdx:
            case r4cdx:
            case r4ntx:
               break ;
            default:
               return error4( c4, e4info, E81102 ) ;
         }
      #endif

      c4->indexFormat = rc ;

      return rc ;
   #endif
}

/*#ifdef S4TESTING*/
/* for testing only, restarts the server if this is the last client, after
   we disconnect */
int S4FUNCTION code4serverRestart( CODE4 *c4 )
{
   CONNECTION4 *connection ;
   int rc ;

   connection = c4->defaultServer->connect ;
   if ( connection == 0 )
      return error4( c4, e4connection, E81102 ) ;
   connection4assign( connection, CON4RESTART, 0L, 0L ) ;
   connection4send( connection ) ;
   rc = connection4receive( connection ) ;
   if ( rc < 0 )
      return error4stack( c4, rc, E91110 ) ;

   rc = connection4status( connection ) ;
   if ( rc < 0 )
      return connection4error( connection, c4, rc, E91110 ) ;

   return rc ;
}

/* for testing only, causes a server crash */
int S4FUNCTION code4serverCrash( CODE4 *c4 )
{
   CONNECTION4 *connection ;
   int rc ;

   connection = c4->defaultServer->connect ;
   if ( connection == 0 )
      return error4( c4, e4connection, E81102 ) ;
   connection4assign( connection, CON4CRASH, 0L, 0L ) ;
   connection4send( connection ) ;
   rc = connection4receive( connection ) ;
   if ( rc < 0 )
      return error4stack( c4, rc, E91110 ) ;

   rc = connection4status( connection ) ;
   if ( rc < 0 )
      return connection4error( connection, c4, rc, E91110 ) ;

   return rc ;
}

#else /* S4CLIENT */
#ifdef P4ARGS_USED
   #pragma argsused
#endif
int S4FUNCTION code4indexFormat( CODE4 *c4 )
{
   #ifdef S4OFF_INDEX
      return 0 ;
   #else
      #ifdef E4PARM_HIGH
         if ( c4 == 0 )
            return error4( 0, e4parm_null, E91110 ) ;
      #endif

      #ifdef S4MDX
         return r4mdx ;
      #endif
      #ifdef S4FOX
         return r4cdx ;
      #endif
      #ifdef S4CLIPPER
         return r4ntx ;
      #endif
      #ifdef S4NDX
         return r4ndx ;
      #endif
   #endif
}
#endif

#ifndef S4SERVER
#ifdef S4STAND_ALONE
#ifndef S4OFF_WRITE
#ifndef S4OFF_TRAN
int S4FUNCTION code4logCreate( CODE4 *c4, const char *fileName, const char *userId )
{
   int rc ;
   static char defaultUser[] = "PUBLIC" ;

   #ifdef E4PARM_HIGH
      if ( c4 == 0 )
         return error4( c4, e4parm_null, E91013 ) ;
   #endif

   if ( userId == 0 )
      userId = defaultUser ;
   else
      if ( userId[0] == 0 )  /* null string */
         userId = defaultUser ;

   if ( c4->c4trans.transFile != 0 )
      return r4logOpen ;

   if ( fileName == 0 )
      #ifdef S4CASE_SEN
         fileName = "C4.log" ;
      #else
         fileName = "C4.LOG" ;
      #endif
   else
      if ( fileName[0] == 0 )  /* null string */
         #ifdef S4CASE_SEN
            fileName = "C4.log" ;
         #else
            fileName = "C4.LOG" ;
         #endif

   rc = code4transFileEnable( &c4->c4trans, fileName, 1 ) ;

   #ifndef S4UTILS
      tran4addUser( &c4->c4trans.trans, 0L, userId, (unsigned short int)strlen( userId ) ) ;
   #endif

   return rc ;
}

const char *S4FUNCTION code4logFileName( CODE4 *c4 )
{
   #ifdef E4PARM_HIGH
      if ( c4 == 0 )
      {
         error4( c4, e4parm_null, E91014 ) ;
         return 0 ;
      }
   #endif

   if ( c4->c4trans.transFile == 0 )
      return 0 ;
   return c4->c4trans.transFile->file.name ;
}

int S4FUNCTION code4logOpen( CODE4 *c4, const char *fileName, const char *userId )
{
   int rc ;
   static char defaultUser[] = "PUBLIC" ;

   #ifdef E4PARM_HIGH
      if ( c4 == 0 )
         return error4( c4, e4parm_null, E91015 ) ;
   #endif

   if ( userId == 0 )
      userId = defaultUser ;
   else
      if ( userId[0] == 0 )  /* null string */
         userId = defaultUser ;

   if ( c4->c4trans.transFile != 0 )
      return r4logOpen ;

   if ( fileName == 0 )
      #ifdef S4CASE_SEN
         fileName = "C4.log" ;
      #else
         fileName = "C4.LOG" ;
      #endif
   else
      if ( fileName[0] == 0 )  /* null string */
         #ifdef S4CASE_SEN
            fileName = "C4.log" ;
         #else
            fileName = "C4.LOG" ;
         #endif

   rc = code4transFileEnable( code4trans( c4 )->c4trans, fileName, 0 ) ;

   #ifndef S4UTILS
      tran4addUser( &c4->c4trans.trans, 0L, userId, (unsigned short int)strlen( userId ) ) ;
   #endif
   return rc ;
}

void S4FUNCTION code4logOpenOff( CODE4 *c4 )
{
   #ifdef E4PARM_HIGH
      if ( c4 == 0 )
      {
         error4( c4, e4parm_null, E91016 ) ;
         return ;
      }
   #endif

   c4->logOpen = 0 ;
}
#endif /* S4OFF_TRAN */
#endif /* S4OFF_WRITE */
#endif /* S4STAND_ALONE */
#endif /* S4SERVER */

const char *S4FUNCTION code4indexExtension( CODE4 *c4 )
{
   if ( c4->indexExtension[0] == 0 )
      switch ( code4indexFormat( c4 ) )
      {
         case r4mdx:
            #ifdef S4CASE_SEN
               memcpy( c4->indexExtension, "mdx", 3 ) ;
            #else
               memcpy( c4->indexExtension, "MDX", 3 ) ;
            #endif
            break ;
         case r4cdx:
            #ifdef S4CASE_SEN
               memcpy( c4->indexExtension, "cdx", 3 ) ;
            #else
               memcpy( c4->indexExtension, "CDX", 3 ) ;
            #endif
            break ;
         case r4ntx:
            #ifdef S4CASE_SEN
               memcpy( c4->indexExtension, "ntx", 3 ) ;
            #else
               memcpy( c4->indexExtension, "NTX", 3 ) ;
            #endif
            break ;
         case r4ndx:
            #ifdef S4CASE_SEN
               memcpy( c4->indexExtension, "ndx", 3 ) ;
            #else
               memcpy( c4->indexExtension, "NDX", 3 ) ;
            #endif
            break ;
         default:
            return 0 ;
      }

   return c4->indexExtension ;
}

#ifdef S4FOX
   #define S4FORMAT 1
#endif

#ifdef S4CLIPPER
   #ifdef S4FORMAT
      #error Choose only one CodeBase index file compatibility option.
   #endif
   #define S4FORMAT 2
#endif

#ifdef S4MDX
   #ifdef S4FORMAT
      #error Choose only one CodeBase index file compatibility option.
   #endif
   #define S4FORMAT 4
#endif

#ifdef S4CLIENT
   #ifndef S4FORMAT
      #define S4FORMAT 0
   #endif
#else
   #ifndef S4FORMAT
      #error You must define either S4FOX, S4CLIPPER or S4MDX
   #endif
#endif

#ifdef S4CLIENT
   #define S4CLIENT_VAL 0x8
#else
   #define S4CLIENT_VAL 0x0
#endif

#ifdef S4DOS
   #define S4OPERATING 0x10
#endif

#ifdef S4WIN16
   #ifdef S4OPERATING
      #error Choose only one of CodeBase switches S4DOS, S4WIN16, S4WIN32, S4OS2, S4UNIX, S4MACINTOSH or S4PASCAL_WIN
   #endif
   #define S4OPERATING 0x20
#endif

#ifdef S4WIN32
   #ifdef S4OPERATING
      #error Choose only one of CodeBase switches S4DOS, S4WIN16, S4WIN32, S4OS2, S4UNIX, S4MACINTOSH or S4PASCAL_WIN
   #endif
   #define S4OPERATING 0x40
#endif

#ifdef S4STAND_ALONE
   #define S4STAND_ALONE_VAL 0x80
#else
   #define S4STAND_ALONE_VAL 0x0
#endif

#ifdef S4OS2
   #ifdef S4OPERATING
      #error Choose only one of CodeBase switches S4DOS, S4WIN16, S4WIN32, S4OS2, S4UNIX, S4MACINTOSH or S4PASCAL_WIN
   #endif
   #define S4OPERATING 0x100
#endif

#ifdef S4UNIX
   #ifdef S4OPERATING
      #error Choose only one of CodeBase switches S4DOS, S4WIN16, S4WIN32, S4OS2, S4UNIX, S4MACINTOSH or S4PASCAL_WIN
   #endif
   #define S4OPERATING 0x200
#endif

/* */
/* */
/* */
/* */
/* */
/* */

#ifdef S4PASCAL_WIN
   #ifdef S4OPERATING
      #error Choose only one of CodeBase switches S4DOS, S4WIN16, S4WIN32, S4OS2, S4UNIX, S4MACINTOSH or S4PASCAL_WIN
   #endif
   #define S4OPERATING 0x800
#endif

#ifndef S4OPERATING
   #error Must choose one of CodeBase switches S4DOS, S4WIN16, S4WIN32, S4OS2, S4UNIX, S4MACINTOSH or S4PASCAL_WIN
#endif

#ifdef S4CB51
   #define S4CB51_VAL  0x1000
#else
   #define S4CB51_VAL  0
#endif

#ifdef S4SAFE
   #define S4SAFE_VAL  0x2000
#else
   #define S4SAFE_VAL  0
#endif

#ifdef S4LOCK_HOOK
   #define S4LOCK_HOOK_VAL 0x4000
#else
   #define S4LOCK_HOOK_VAL 0
#endif

#ifdef S4MAX
   #define S4MAX_VAL 0x8000
#else
   #define S4MAX_VAL 0
#endif

#ifdef S4TIMEOUT_HOOK
   #define S4TIMEOUT_HOOK_VAL 0x10000
#else
   #define S4TIMEOUT_HOOK_VAL 0
#endif

#ifdef E4ANALYZE
   #define E4ANALYZE_VAL 0x20000
#else
   #define E4ANALYZE_VAL 0
#endif

#ifdef E4DEBUG
   #define E4DEBUG_VAL 0x40000
#else
   #define E4DEBUG_VAL 0
#endif

#ifdef E4HOOK
   #define E4HOOK_VAL 0x80000
#else
   #define E4HOOK_VAL 0
#endif

#ifdef E4LINK
   #define E4LINK_VAL 0x100000
#else
   #define E4LINK_VAL 0
#endif

#ifdef E4MISC
   #define E4MISC_VAL 0x200000
#else
   #define E4MISC_VAL 0
#endif

#ifdef E4OFF
   #define E4OFF_VAL 0x400000
#else
   #define E4OFF_VAL 0
#endif

#ifdef E4OFF_STRING
   #define E4OFF_STRING_VAL 0x800000
#else
   #define E4OFF_STRING_VAL 0
#endif

#ifdef E4PARM_HIGH
   #define E4PARM_HIGH_VAL 0x1000000
#else
   #define E4PARM_HIGH_VAL 0
#endif

#ifdef E4PAUSE
   #define E4PAUSE_VAL 0x2000000
#else
   #define E4PAUSE_VAL 0
#endif

#ifdef E4STOP
   #define E4STOP_VAL 0x4000000
#else
   #define E4STOP_VAL 0
#endif

#ifdef E4STOP_CRITICAL
   #define E4STOP_CRITICAL_VAL 0x8000000
#else
   #define E4STOP_CRITICAL_VAL 0
#endif

#ifdef S4OFF_INDEX
   #define S4OFF_INDEX_VAL 0x10000000
#else
   #define S4OFF_INDEX_VAL 0
#endif

#ifdef S4OFF_MEMO
   #define S4OFF_MEMO_VAL 0x20000000
#else
   #define S4OFF_MEMO_VAL 0
#endif

#ifdef S4OFF_MULTI
   #define S4OFF_MULTI_VAL 0x40000000
#else
   #define S4OFF_MULTI_VAL 0
#endif

#ifdef S4OFF_OPTIMIZE
   #define S4OFF_OPTIMIZE_VAL 0x80000000
#else
   #define S4OFF_OPTIMIZE_VAL 0
#endif

/*
   no room for these switches

#ifdef S4OFF_REPORT
   #define S4OFF_REPORT_VAL 0x100000000
#else
   #define S4OFF_REPORT_VAL 0
#endif

#ifdef S4OFF_TRAN
   #define S4OFF_TRAN_VAL 0x200000000
#else
   #define S4OFF_TRAN_VAL 0
#endif

#ifdef S4OFF_WRITE
   #define S4OFF_WRITE_VAL 0x400000000
#else
   #define S4OFF_WRITE_VAL 0
#endif
*/

long S4FUNCTION u4switch()
{
   return (long) ( S4FORMAT + S4OPERATING + S4CB51_VAL + S4SAFE_VAL +
          S4LOCK_HOOK_VAL + S4MAX_VAL + S4TIMEOUT_HOOK_VAL + E4ANALYZE_VAL +
          E4DEBUG_VAL + E4HOOK_VAL + E4LINK_VAL + E4MISC_VAL + E4OFF_VAL +
          E4OFF_STRING_VAL + E4PARM_HIGH_VAL + E4PAUSE_VAL + E4STOP_VAL +
          E4STOP_CRITICAL_VAL + S4OFF_INDEX_VAL + S4OFF_MEMO_VAL +
          S4OFF_MULTI_VAL + S4OFF_OPTIMIZE_VAL +
/*          S4OFF_REPORT_VAL + S4OFF_TRAN_VAL + S4OFF_WRITE_VAL +  no room */
          S4CLIENT_VAL + S4STAND_ALONE_VAL ) ;
}

#ifdef S4VB_DOS

DATA4 *d4data_v( CODE4 *c4, char *alias )
{
   return code4data( c4, c4str(alias) ) ;
}

#endif

/*#ifdef S4CB51*/
#ifndef S4SERVER
#ifdef S4DLL_BUILD
#ifndef S4PASCAL_DOS

#define CTRL4SERVERNAMESIZE 260

/*Structures for CodeControls Functions */

typedef   struct ctrl4code_tag
{
   LINK4       link ;
   HINSTANCE   hInst ;
   CODE4       *code ;
   int         alloc ;
   LIST4       form ;

#ifdef S4CLIENT
   char        ServerName[CTRL4SERVERNAMESIZE] ;
#endif


}CTRL4CODE ;

/***************************************************************\
\***************************************************************/

int         S4FUNCTION ctrl4addCode( HINSTANCE hInst ) ;                                 /*450*/
void        S4FUNCTION ctrl4codeListInit( void ) ;                                        /*451*/
void        S4FUNCTION ctrl4freeCtrlNode( CTRL4CODE *node ) ;
void        S4FUNCTION ctrl4freeCodeList( void ) ;                                        /*452*/
CTRL4CODE * S4FUNCTION ctrl4getCtrlCode( HINSTANCE hInst ) ;                              /*453*/
void        S4FUNCTION ctrl4getServerName( HINSTANCE hInst,char *serverName,int strLen ) ; /* 5 oh something */
void        S4FUNCTION ctrl4setServerName( HINSTANCE hInst,char *serverName ) ; /* 5 oh something */
void        S4FUNCTION ctrl4initVBX( CODE4 *code,HINSTANCE hInstance,int initialize ) ;   /*454*/
void        S4FUNCTION ctrl4initVBXUndo( CODE4 *code,HINSTANCE hInstance ) ;              /*455*/

/***************************************************************\
*  List Containing CODE4 and hInstance
*  structures for CodeControls
\***************************************************************/

LIST4    ctrl4codeListVBX ;


/***************************************************************\
\***************************************************************/

void S4FUNCTION ctrl4codeListInit( void )
{
      /*memset( &ctrl4codeListVBX,0,sizeof( LIST4 ) );*/
}

/***************************************************************\
\***************************************************************/

int S4FUNCTION ctrl4addCode( HINSTANCE hInst )
{
   CTRL4CODE   *node ;

   if ( !hInst )
      return -1 ;

   node = ( CTRL4CODE * ) u4alloc( sizeof( CTRL4CODE ) ) ;
   if ( node )
   {
      node->hInst = hInst ;
           node->alloc = 1 ;
      node->code = NULL ;
      l4add( &ctrl4codeListVBX,node ) ;
   }
   return 0 ;
}

/***************************************************************\
\***************************************************************/

void S4FUNCTION ctrl4freeCtrlNode( CTRL4CODE *node )
{
   if ( node )
   {
      l4remove( &ctrl4codeListVBX,node ) ;
      if ( node->code )
      {
         code4initUndo( node->code ) ;
         u4free( node->code ) ;
      }
      u4free( node ) ;
   }
}

/***************************************************************\
\***************************************************************/

void S4FUNCTION ctrl4freeCodeList( void )
{
   CTRL4CODE   *node ;

   for( node = ( CTRL4CODE * ) l4first( &ctrl4codeListVBX );node != NULL; )
   {
      l4remove( &ctrl4codeListVBX,node ) ;
                if ( node->code && node->alloc )
                {
         code4initUndo( node->code ) ;
         u4free( node->code ) ;
                }
      u4free( node ) ;
      node = ( CTRL4CODE * ) l4next( &ctrl4codeListVBX,node ) ;
   }
}

/***************************************************************\
\***************************************************************/

CTRL4CODE * S4FUNCTION ctrl4getCtrlCode( HINSTANCE hInst )
{
   CTRL4CODE   *node,*returnnode = NULL ;

   if ( hInst == 0 )
      return NULL ;

   for( node = ( CTRL4CODE * ) l4first( &ctrl4codeListVBX );node != NULL; )
   {
      if ( node->hInst == hInst )
      {
         returnnode = node ;
         node = NULL ;
      }
      else
         node = ( CTRL4CODE * ) l4next( &ctrl4codeListVBX,node ) ;
   }
   return returnnode ;
}

/***************************************************************\
\***************************************************************/

void S4FUNCTION ctrl4initVBXUndo( CODE4 *code,HINSTANCE hInstance )
{
   CTRL4CODE   *node ;

   node = ctrl4getCtrlCode( hInstance ) ;
   if ( node )
   {
      if ( code != node->code )
         code4initUndo( code ) ;

      code4initUndo( node->code ) ;
      if ( node->alloc )
      {
         u4free( node->code ) ;
      }
      l4remove( &ctrl4codeListVBX,node ) ;
      u4free( node ) ;
   }
}

/***************************************************************\
\***************************************************************/

void S4FUNCTION ctrl4initVBX( CODE4 *code, HINSTANCE hInstance, int initialize )
{
   int dealloc ;
   CODE4 *oldcode ;
   CTRL4CODE *node ;

   if ( code )
   {
      node = ctrl4getCtrlCode( hInstance ) ;
      if ( !node )
      {
         ctrl4addCode( hInstance ) ;
         node = ctrl4getCtrlCode( hInstance ) ;
         if ( node )
            node->alloc = 0 ;
      }

      if ( node )
      {
         if ( node->code )
         {
            dealloc = 0 ;
            if ( node->alloc )
               dealloc = IDYES ;
            else
               dealloc = MessageBox( 0,
               "Warning! Detected two calls to ctrl4init\nwithout intervening call to ctrl4initUndo!\n\nOk to free previously allocated CODE4 memory ?","Multiple CODE4 Detected"
               ,MB_YESNO|MB_TASKMODAL|MB_ICONEXCLAMATION ) ;

            if ( dealloc == IDYES )
            {
               oldcode = node->code ;
               ctrl4initVBXUndo( node->code,hInstance ) ;
               u4free( oldcode ) ;
               node->code = NULL ;
            }
         }
         node->alloc = 0 ;
         node->code = code ;

         if ( initialize )
         {
            #ifdef S4CLIENT
               char setProtocol = 0 ;

               /* must choose a default protocol for C/C++ client/server dll
                  if user will be calling ctrl4init() */
               #ifndef S4VBASIC
                  #ifndef S4PASCAL
                     setProtocol = 1 ;
                  #endif
               #endif

               if( setProtocol )
                  code4initLow( code, "C4SPX.DLL", S4VERSION ) ;
               else
                  #ifdef S4SPX
                     code4initLow( code, "C4SPX.DLL", S4VERSION ) ;
                  #else
                     code4initLow( code, "C4SOCK.DLL", S4VERSION ) ;
                  #endif
            #else
               code4init( code ) ;
            #endif
         }
      }
   }
}

#ifdef S4CLIENT

void  S4FUNCTION ctrl4getServerName( HINSTANCE hInst,char *serverName,int strLen ) /*5 oh something*/
{
   CTRL4CODE   *code = NULL ;

   if ( !hInst )
      return ;

   if ( !serverName || strLen <= 0 )
      return ;

   memset( serverName,0,strLen ) ;
   code = ctrl4getCtrlCode( hInst ) ;

   if ( code )
   {
      memcpy( serverName,code->ServerName,min( strLen,CTRL4SERVERNAMESIZE ) ) ;
   }
   return ;
}

void S4FUNCTION ctrl4setServerName( HINSTANCE hInst,char *serverName ) /*5 oh something*/
{
   CTRL4CODE   *code = NULL ;

   if ( !hInst )
      return ;

   if ( !serverName )
      return ;

   code = ctrl4getCtrlCode( hInst ) ;

   if ( code )
   {
      memcpy( code->ServerName,serverName,CTRL4SERVERNAMESIZE ) ;
   }
   return ;
}
#else
#ifdef S4STAND_ALONE
#ifdef P4ARGS_USED
   #pragma argsused
#endif
void  S4FUNCTION ctrl4getServerName( HINSTANCE hInst,char *serverName,int strLen ) /*5 oh something*/
{
   return ;
}

#ifdef P4ARGS_USED
   #pragma argsused
#endif
void S4FUNCTION ctrl4setServerName( HINSTANCE hInst,char *serverName ) /*5 oh something*/
{
   return ;
}
#endif

#endif /* S4CLIENT */


#endif /* S4PASCAL_DOS */
#endif /* S4DLL_BUILD */
#endif /* S4SERVER */
/*#endif */ /* S4CB51 */

#ifdef S4STAND_ALONE
/* assumes that code4tranInitLow has already been called internally ( code4init ) */
#ifndef S4OFF_TRAN
#ifndef S4OFF_WRITE

int S4FUNCTION code4tranInit2( CODE4 *c4, const char *fileName, const char *charId )
{
   int rc ;

   #ifdef E4PARM_LOW
      if ( c4 == 0 || fileName == 0 )
         return error4( 0, e4parm_null, E93801 ) ;
   #endif

   c4->c4trans.c4 = c4 ;
   rc = code4transFileEnable( &c4->c4trans, fileName, 0 ) ;
   if ( rc < 0 )
      return rc ;
   c4->c4trans.trans.c4trans = &c4->c4trans ;

   if ( charId != 0 )
      return tran4addUser( &c4->c4trans.trans, 0L, charId, ( unsigned short )strlen( charId ) ) ;

   return 0 ;
}
#endif
#endif

int S4FUNCTION code4tranInit( CODE4 *c4 )
{
   #ifdef E4PARM_LOW
      if ( c4 == 0 )
         return error4( 0, e4parm_null, E93802 ) ;
   #endif

   c4->c4trans.c4 = c4 ;
   c4->c4trans.trans.c4trans = &c4->c4trans ;
   tran4dataListSet( &c4->c4trans.trans, &c4->c4trans.trans.localDataList ) ;
   return 0 ;
}
#endif

#ifdef S4CLIENT
#ifndef S4INLINE
int S4FUNCTION code4tranInit2( CODE4 *c4, const char *fileName, const char *charId )
{
   #ifdef E4PARM_LOW
      if ( c4 == 0 || fileName == 0 )
         return error4( 0, e4parm_null, E93801 ) ;
   #endif

   return 0 ;
}
#endif

int S4FUNCTION code4tranInit( CODE4 *c4 )
{
   #ifdef E4PARM_LOW
      if ( c4 == 0 )
         return error4( 0, e4parm_null, E93802 ) ;
   #endif

   #ifndef S4OFF_TRAN
      if ( code4transEnabled( c4 ) )
         return 0 ;
   #endif

   c4->c4trans.c4 = c4 ;
   c4->c4trans.trans.c4trans = &c4->c4trans ;
   #ifndef S4OFF_TRAN
      c4->c4trans.enabled = 1 ;
   #endif
   tran4dataListSet( &c4->c4trans.trans, &c4->c4trans.trans.localDataList ) ;
   return 0 ;
}
#endif

#ifndef S4OFF_TRAN
#ifndef S4OFF_WRITE

#ifdef S4CLIENT
   #ifndef S4INLINE
      void code4tranInitUndo( CODE4 *c4 )
      {
         return ;
      }
   #endif  /* S4INLINE */
#else
int code4tranInitUndoLow( TRAN4 *t4, const long clientId )
{
   int rc ;

   if ( t4 == 0 )
      return 0 ;

   if ( t4->c4trans->enabled == 1 && t4->userId[0] != 0 )  /* if it has been initialized */
   {
      rc = tran4set( t4, t4->currentTranStatus, -1L, clientId, TRAN4INIT_UNDO, 0, 0L, 0L ) ;
      if ( rc < 0 )
         return rc ;
      if ( tran4lowAppend( t4, 0 ) != 0 )
         return e4transAppend ;
      memset( t4->userId, 0, sizeof( t4->userId ) ) ;
   }

   t4->dataPos = 0 ;

   return 0 ;
}

#ifdef S4STAND_ALONE
void code4tranInitUndo( CODE4 *c4 )
{
   #ifdef E4PARM_LOW
      if ( c4 == 0 )
      {
         error4( 0, e4parm_null, E93804 ) ;
         return ;
      }
   #endif

   if ( code4transEnabled( c4 ) )
      code4transInitUndo( &c4->c4trans ) ;
}
#endif  /* S4STAND_ALONE */

#endif
#endif
#endif