.ad 8
.bm 8
.fm 4
.bt $Copyright (c) 2000-2004 SAP AG$$Page %$
.tm 12
.hm 6
.hs 3
.tt 1 $SQL$Project Distributed Database System$VPA03WC$
.tt 2 $$$
.tt 3 $BurkhardD$SQLDB-ODBC DLL WINDOWS FUNCTIONS$2001-05-10$
***********************************************************
.nf

.nf


    ========== licence begin  GPL
    Copyright (c) 2000-2004 SAP AG

    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public License
    as published by the Free Software Foundation; either version 2
    of the License, or (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
    ========== licence end

.fo


.fo
Module  :
=========
.sp
Purpose :
.CM *-END-* purpose -------------------------------------
Define  :        
#ifndef DEBUG
#line 20 "vpa03wc"
#endif

#include "vpa00global.h"

#include <windows.h>
#include <direct.h>

#ifndef DYNAMICLOAD
#define DYNAMICLOAD
BOOL pa03LoadRte();
VOID pa03FreeRte(VOID);
#endif

#ifndef CTL3D_ALL
#define CTL3D_ALL 0xffff
VOID pa03InstallCtl3d(HANDLE hModule);
VOID pa03RemoveCtl3d(HANDLE hinst);
VOID pa03Set3dDialog (HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);
#endif
.CM *-END-* define --------------------------------------
Use     :
      
.CM *-END-* use -----------------------------------------
Synonym :
.CM *-END-* synonym -------------------------------------
.sp;.cp 3
Author  : BurkhardD
.sp
.cp 3
Created : 1993-09-13
.sp
.cp 3
Version : 1994-04-25
.sp
.cp 3
Release :  7.3    Date : 2001-05-10
.sp
Specification:
.CM *-END-* specification -------------------------------
.sp 2
***********************************************************
.sp
.cp 10
.fo
.oc _/1
Description:
.CM *-END-* description ---------------------------------
.sp 2
***********************************************************
.sp
.cp 10
.nf
.oc _/1
Structure:
.CM *-END-* structure -----------------------------------
.sp 2
**********************************************************
.sp
.cp 10
.nf
.CM -lll-
Code    :
#ifndef DEBUG
#line 76 "vpa03wc"
#endif

// MACROS
#define PUTBIT(b,i)             \
        { b [ ( unsigned ) i / 8 ] |=  ( 1 << (( unsigned ) i % 8 )); }
#define CLRBIT(b,i)             \
        { b [ ( unsigned ) i / 8 ] &= ~( 1 << (( unsigned ) i % 8 )); }
#define TSTBIT(b,i)             \
        ( b [ ( unsigned ) i / 8 ] &   ( 1 << (( unsigned ) i % 8 ))  )

#define MAKEPROCADDR(x) (PASCAL FAR *lp##x)
#define GETPROCADDR(hinst, x) (FARPROC)lp##x = GetProcAddress( hinst, #x)
#ifndef SAPDB_FAST
#define API_TR_STRING  (1)
#define API_TR_UCHAR   (2)
#define API_TR_SCHAR   (3)
#define API_TR_DWORD   (4)
#define API_TR_SDWORD  (5)
#define API_TR_UDWORD  (6)
#define API_TR_WORD    (7)
#define API_TR_SWORD   (8)
#define API_TR_UWORD   (9)
#define API_TR_SDOUBLE (10)
#define API_TR_LDOUBLE (11)
#define API_TR_SFLOAT  (12)
#define API_TR_PTR     (13)
#define API_TR_BOOL    API_TR_WORD

#define API_TR_HANDLE  (30)
#define API_TR_RETCODE (31)
#define API_TR_SQLSTATE (32)
#define API_TR_API_ESQ_BLOCK (33)
#define API_TR_API_RETCODE (34)
#define API_TR_ODBC_STRING (35)
#define API_TR_BUFFER (36)
#define API_TR_GETINFO (37)
#define API_TR_SFINFOTYPE (38)
#define API_TR_HWND (39)
#define API_TR_PARSID (40)

#define API_TR_ENTRY   (50)
#define API_TR_EXIT    (51)
#define API_TR_MSG     (52)

#endif	     
// TYPEDEFS
typedef void (FAR *SQLPROC)();
typedef teo07_ThreadErr (*SQLPROCRETURN)();

// PROTOTYPES
VOID pa03MissingFunction( UCHAR *szFunction, UCHAR *szLibrary, DWORD errCode );
SQLPROC pa03DynamicLoad( UCHAR *szSqlFunction);

// EXTERNALS
extern tsp00_Int2 api_trace_status;
extern HANDLE s_hModule;		/* Saved module handle. */
   
// GLOBALS
BOOL MAKEPROCADDR(Ctl3dRegister) ( HANDLE hModule );
BOOL MAKEPROCADDR(Ctl3dUnregister) ( HANDLE hModule );
BOOL MAKEPROCADDR(Ctl3dSubclassDlgEx) ( HWND hwnd, int flags );
BOOL MAKEPROCADDR(Ctl3dSubclassDlg) ( HWND hwnd, int flags );
BOOL MAKEPROCADDR(Ctl3dAutoSubclass) ( HANDLE hModule );
BOOL MAKEPROCADDR(Ctl3dColorChange) ( VOID );
BOOL MAKEPROCADDR(Ctl3dCtlColorEx) (UINT wm, WPARAM wParam, LPARAM lParam);
BOOL MAKEPROCADDR(Ctl3dDlgFramePaint) (HWND, UINT, WPARAM, LPARAM);
short  api_ctl3ddialog = FALSE;
short api_ctl3dsubclass = FALSE;
HINSTANCE pa03hinstRte;
#define SQLUSER_DLL "SQLUSER74N.DLL"
UCHAR *pa03szLibRte = SQLUSER_DLL;

/* #define TRACE_MUTEX */
void pa03_WriteToFile( char *fileName, char *str );

#ifdef CTL3D_ALL
HINSTANCE hinstCtl3d;

VOID pa03InstallCtl3d( HANDLE hModule )
{
    HINSTANCE hinst;
    BOOL ret;
    if (api_ctl3ddialog)
        if (hinstCtl3d == NULL) {
#ifdef WIN32
            if ((INT64)(hinst = LoadLibrary("CTL3D32.DLL")) > HINSTANCE_ERROR) {
#else
            if ((int)(hinst = LoadLibrary("CTL3DV2.DLL")) > HINSTANCE_ERROR) {
#endif
                hinstCtl3d = hinst;
                GETPROCADDR(hinst, Ctl3dRegister);
                GETPROCADDR(hinst, Ctl3dUnregister);
                if (api_ctl3dsubclass) {
#ifdef WIN32	    
                    GETPROCADDR(hinst, Ctl3dSubclassDlgEx);
#else	 
                    GETPROCADDR(hinst, Ctl3dSubclassDlg);
#endif	 
                    GETPROCADDR(hinst, Ctl3dAutoSubclass);
                }
                GETPROCADDR(hinst, Ctl3dColorChange);
                if (lpCtl3dRegister) {
                    ret = lpCtl3dRegister ( hModule );
                    if (lpCtl3dAutoSubclass)
                        ret = lpCtl3dAutoSubclass ( hModule );
                }      
            }
        }
} /* pa03InstallCtl3d */

/*    
VOID pa03Set3dDialog(  HWND   hDlg, 
                       UINT   message,
                       WPARAM wParam, 
                       LPARAM lParam )
{   
        switch ( message ) {
        case WM_INITDIALOG: {
            if (lpCtl3dSubclassDlgEx) {
                lpCtl3dSubclassDlgEx ( hDlg, CTL3D_ALL );
            }
            if (lpCtl3dSubclassDlg) {
                lpCtl3dSubclassDlg ( hDlg, CTL3D_ALL );
            }
            break;
        }
#ifdef WIN32
        case WM_CTLCOLORBTN:
        case WM_CTLCOLORDLG:
        case WM_CTLCOLOREDIT:
        case WM_CTLCOLORLISTBOX:
        case WM_CTLCOLORMSGBOX:
        case WM_CTLCOLORSCROLLBAR:	
        case WM_CTLCOLORSTATIC:
            if (lpCtl3dCtlColorEx)
                lpCtl3dCtlColorEx(message, wParam, lParam);
            break;
        case WM_SETTEXT:
        case WM_NCPAINT:
        case WM_NCACTIVATE:
            if (lpCtl3dDlgFramePaint)
                SetWindowLong( hDlg,
                               DWL_MSGRESULT, 
                               lpCtl3dDlgFramePaint( hDlg,
                                                     message,
                                                     wParam,
                                                     lParam));
            break;
#endif
        case WM_SYSCOLORCHANGE: {
            if (lpCtl3dColorChange) {
                lpCtl3dColorChange();
            }
            break;
        }
        }
}*/ /* pa03Set3dDialog */

 
VOID pa03RemoveCtl3d(HANDLE hModule)
{
    if (hinstCtl3d) {
        if (lpCtl3dUnregister) {
            lpCtl3dUnregister (hModule);
        }
        FreeLibrary(hinstCtl3d);
    }
} /* pa03RemoveCtl3d */
#endif

#ifdef DYNAMICLOAD

BOOL pa03LoadRte(HINSTANCE *hinstRte)
{
    UCHAR szBuf[MAX_PATH];
    UCHAR szCurPath[MAX_PATH];
    int cbCurDrive;
    HINSTANCE hinst=NULL;
   
    pa03hinstRte=NULL;
    cbCurDrive = _getdrive();
    szCurPath[0] = 0;
    szBuf[0] = 0;
    if (_getdcwd(cbCurDrive, szCurPath, sizeof(szCurPath))) {
        if (GetModuleFileName(s_hModule, szBuf, sizeof(szBuf))) {
            size_t i;
            for (i=strlen(szBuf); i > 0; i--) {
                if (szBuf[i] == '\\') {
                    szBuf[i+1] = 0;
                    break;
                }
            }
            _chdir(szBuf);
        }      
    }
    strcat(szBuf, pa03szLibRte);
    hinst = LoadLibraryEx(szBuf, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);      
    if(szCurPath[0]) {
        _chdir(szCurPath);
    }
    if ((INT64)hinst <= HINSTANCE_ERROR) {
        hinst = LoadLibrary(pa03szLibRte);      
    }
    if ((INT64)hinst > HINSTANCE_ERROR) {      
        pa03hinstRte=hinst;

        return TRUE;
    } else {
        UCHAR  errorMsg[2048];
        DWORD  errCode = GetLastError();
        UCHAR  msgBuf[128];
    
        /* get message for errCode */
        FormatMessage( FORMAT_MESSAGE_FROM_SYSTEM | 
                       FORMAT_MESSAGE_IGNORE_INSERTS,
                       NULL,
                       errCode,
                       MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
                       (LPTSTR) &msgBuf[0],
                       sizeof(msgBuf),
                       NULL);
        sprintf( errorMsg, "Loading of "SQLUSER_DLL" or one of its"
                 " dependants (sqltcp*.dll, sapni.dll) failed."
                 " %s (%d)", msgBuf, errCode );
        MessageBox(0, errorMsg, API_DBMS_NAME, MB_ICONEXCLAMATION | MB_OK);
        
        return FALSE;
    };
} /* pa03LoadRte */


VOID pa03FreeRte(VOID)
{
    if (pa03hinstRte) {
        FreeLibrary(pa03hinstRte);
    }
} /* pa03FreeRte */


SQLPROC pa03DynamicLoad(UCHAR FAR *szSqlFunction)
{
    SQLPROC p = NULL;

    if (!pa03hinstRte) {
        pa03LoadRte();
    }
    if (pa03hinstRte) {
        if(!(p = (SQLPROC)GetProcAddress( pa03hinstRte, szSqlFunction))) {
            DWORD errCode = GetLastError();
            pa03MissingFunction(szSqlFunction, pa03szLibRte, errCode );
        }
    };

    return(p);
} /* pa03DynamicLoad */


VOID pa03MissingFunction(UCHAR  *szFunction, UCHAR  *szLibrary, DWORD  errCode )
{
    UCHAR szMsg[MAX_PATH+MAX_PATH];
    UCHAR msgBuf[128];
    
    /* get message for errCode */
    FormatMessage( FORMAT_MESSAGE_FROM_SYSTEM | 
                   FORMAT_MESSAGE_IGNORE_INSERTS,
                   NULL,
                   errCode,
                   MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
                   (LPTSTR) &msgBuf[0],
                   sizeof(msgBuf),
                   NULL);
    sprintf( szMsg, "Missing function %s in %s.\x0D\x0A %s (%d)", szFunction,
             szLibrary, msgBuf, errCode );
    MessageBox(0, szMsg, API_DBMS_NAME, MB_ICONEXCLAMATION | MB_OK);
    exit(1);
} /* pa03MissingFunction */

#define PA03BEGIN(x)\
{static SQLPROC lpsql=NULL;\
static UCHAR  *lpFunc=#x;\
   API_TRACE(API_TR_ENTRY, lpFunc, 0);\
   if (!lpsql) {\
      lpsql = pa03DynamicLoad(#x);\
      if (!lpsql) \
        return;\
   };

#define PA30SQLPROC lpsql
      
#define PA03END     API_TRACE(API_TR_EXIT, lpFunc, 0);return;}

typedef tsp01_CommErr_Enum (*pa30CommErrProc)();

tsp01_CommErr_Enum 
SqlAConnect (char *szServerNode, tsp00_DbNamec VAR_ARRAY_REF szServerDB,
	     tsp01_Service_Enum service, tsp00_Int4 packet_cnt,
	     tsp00_Int4 *reference, tsp00_Int4 *sql_packet_size,
	     void *sql_packet_list[], 
	     tsp00_ErrTextc VAR_ARRAY_REF szErrText )
{
  static  pa30CommErrProc lpsql=NULL;
  UCHAR  *lpFunc="SqlAConnect";
  tsp01_CommErr_Enum CommErr;
  API_TRACE(API_TR_ENTRY, lpFunc, 0);
  API_TRACE(API_TR_STRING, "szServerNode", szServerNode);
  API_TRACE(API_TR_STRING, "szServerDB", szServerDB);
  API_TRACE(API_TR_UCHAR, "service", &service);
  API_TRACE(API_TR_SDWORD, "packet_cnt", &packet_cnt);
  API_TRACE(API_TR_PTR, "reference", &reference);
  API_TRACE(API_TR_SDWORD, "sql_packet_size", sql_packet_size);
  if (!lpsql)
    lpsql = (pa30CommErrProc) pa03DynamicLoad(lpFunc);
  CommErr = lpsql(szServerNode, szServerDB, service, packet_cnt, reference, sql_packet_size, sql_packet_list, szErrText);
  API_TRACE(API_TR_EXIT, lpFunc, 0);
  API_TRACE(API_TR_SDWORD, "reference", reference);
  API_TRACE(API_TR_SDWORD, "sql_packet_size", sql_packet_size);
  API_TRACE(API_TR_PTR, "sql_packet_list", &sql_packet_list[0]);
  API_TRACE(API_TR_STRING, "szErrText", szErrText);
  API_TRACE(API_TR_WORD, "CommErr", &CommErr);  
  return CommErr;
}

void sqlaconnect (tsp00_TaskId        pid,
                  tsp00_NodeId	      servernode,
                  tsp00_DbName        serverdb,
                  tsp01_Service_Enum  service,
                  tsp00_Int4          packet_cnt,			
                  tsp00_Int4         *reference,
                  tsp00_Int4         *sql_packet_size,
                  void              **sql_packet_list,
                  tsp00_ErrText       errtext,
                  tsp01_CommErr      *returncode)
PA03BEGIN(sqlaconnect)
API_TRACE(API_TR_SDWORD, "pid", &pid);
API_TRACE_LEN(API_TR_ODBC_STRING, "servernode", servernode, sizeof(SQL_NODEID));
API_TRACE_LEN(API_TR_ODBC_STRING, "serverdb", serverdb, sizeof(SQL_DBNAME));
API_TRACE(API_TR_UCHAR, "service", &service);
API_TRACE(API_TR_SDWORD, "packet_cnt", &packet_cnt);
API_TRACE(API_TR_PTR, "reference", &reference);
API_TRACE(API_TR_SDWORD, "sql_packet_size", sql_packet_size);
PA30SQLPROC( pid, servernode, serverdb, service, packet_cnt, reference,
   sql_packet_size, sql_packet_list, errtext, returncode);
API_TRACE(API_TR_SDWORD, "reference", reference);
API_TRACE(API_TR_SDWORD, "sql_packet_size", sql_packet_size);
API_TRACE(API_TR_PTR, "sql_packet_list", &sql_packet_list[0]);
API_TRACE(API_TR_UCHAR, "returncode", returncode);
#ifndef SAPDB_FAST
if(returncode && *returncode)
   API_TRACE_LEN(API_TR_ODBC_STRING, "errtext", errtext, sizeof(ERRORTEXT));
#endif
PA03END

VOID sqlarelease         ( tsp00_Int4                   reference )
PA03BEGIN(sqlarelease)
PA30SQLPROC(reference );
PA03END

void sqlarequest (tsp00_Int4	 reference,
                  void	        *sql_packet_addr,
                  tsp00_Int4     sql_packet_length,
                  tsp00_ErrText  errtext,			
                  tsp01_CommErr *returncode)
PA03BEGIN(sqlarequest)
API_TRACE(API_TR_SDWORD, "sql_packet_length", &sql_packet_length);
PA30SQLPROC( reference, sql_packet_addr, sql_packet_length, errtext, returncode );
API_TRACE(API_TR_UCHAR, "returncode", returncode);
#ifndef SAPDB_FAST
if(returncode && *returncode)
   API_TRACE_LEN(API_TR_ODBC_STRING, "errtext", errtext, sizeof(ERRORTEXT));
#endif
PA03END

externC void sqlareceive (tsp00_Int4		      reference,
						  void                  **res_packet_ptr,
						  tsp00_Int4             *res_packet_length,
						  tsp00_ErrText 		  errtext,			
						  tsp01_CommErr          *returncode)
PA03BEGIN(sqlareceive)
PA30SQLPROC(reference, res_packet_ptr, res_packet_length, errtext, returncode );
API_TRACE(API_TR_SDWORD, "res_packet_length", res_packet_length);
API_TRACE(API_TR_UCHAR, "returncode", returncode);
#ifndef SAPDB_FAST
if(returncode && *returncode)
   API_TRACE_LEN(API_TR_ODBC_STRING, "errtext", errtext, sizeof(ERRORTEXT));
#endif
PA03END

VOID sqlacancel          ( tsp00_Int4             reference )
PA03BEGIN(sqlacancel)
PA30SQLPROC(reference );
PA03END

#ifdef DUMP_ENABLED

void sqladump            ( void )
PA03BEGIN(sqladump)
PA30SQLPROC();
PA03END

#endif

void sqlfopenc (const char *rawFName,
                tsp05_RteDataKind_Enum dataKind,
                tsp05_RteFileMode_Enum fileMode,
                tsp05_RteBufferingKind_Enum buffering,
                tsp00_Int4 *fileHandle,
                tsp05_RteFileError *ferr)
PA03BEGIN(sqlfopenc)
API_TRACE_LEN(API_TR_ODBC_STRING, "rawFName",
              rawFName, sizeof(tsp00_VFilename));
API_TRACE(API_TR_UCHAR, "dataKind", &dataKind);
API_TRACE(API_TR_UCHAR, "fileMode", &fileMode);
API_TRACE(API_TR_UCHAR, "buffering", &buffering);
API_TRACE(API_TR_SDWORD,"fileHandle", fileHandle);
PA30SQLPROC(rawFName, dataKind, fileMode, buffering, fileHandle, ferr );
API_TRACE(API_TR_UCHAR, "ferror", ferr );
PA03END

void sqlfopenp (const tsp00_VFilename rawFName,
                tsp05_RteDataKind dataKind,
                tsp05_RteFileMode fileMode,
                tsp05_RteBufferingKind buffering,
                tsp00_Int4 *fileHandle,
                tsp05_RteFileError *ferr)
PA03BEGIN(sqlfopenp)
API_TRACE_LEN(API_TR_ODBC_STRING, "rawFName",
              rawFName, sizeof(tsp00_VFilename));
API_TRACE(API_TR_UCHAR, "dataKind", &dataKind);
API_TRACE(API_TR_UCHAR, "fileMode", &fileMode);
API_TRACE(API_TR_UCHAR, "buffering", &buffering);
API_TRACE(API_TR_SDWORD,"fileHandle", fileHandle);
PA30SQLPROC(rawFName, dataKind, fileMode, buffering, fileHandle, ferr );
API_TRACE(API_TR_UCHAR, "ferror", ferr );
PA03END

void sqlfclosec (tsp00_Int4 fileHandle,
                 tsp05_RteCloseOption_Enum option,
                 tsp05_RteFileError *ferr)
PA03BEGIN(sqlfclosec)
API_TRACE(API_TR_SDWORD, "fileHandle", &fileHandle);
API_TRACE(API_TR_UCHAR, "option", &option);
PA30SQLPROC(fileHandle, option, ferr );
API_TRACE(API_TR_UCHAR, "ferror", ferr );
PA03END

void sqlfclosep (tsp00_Int4 fileHandle,
                 tsp05_RteCloseOption option,
                 tsp05_RteFileError *ferr)
PA03BEGIN(sqlfclosep)
API_TRACE(API_TR_SDWORD, "fileHandle", &fileHandle);
API_TRACE(API_TR_UCHAR, "option", &option);
PA30SQLPROC(fileHandle, option, ferr );
API_TRACE(API_TR_UCHAR, "ferror", ferr );
PA03END

void sqlfreadc (tsp00_Int4 fileHandle,
                void* buf,
                tsp00_Longint bufSize,
                tsp00_Longint* outLen,
                tsp05_RteFileError *ferr)
PA03BEGIN(sqlfreadc)
API_TRACE(API_TR_SDWORD, "fileHandle", &fileHandle);
API_TRACE(API_TR_PTR, "buf", buf);
API_TRACE(API_TR_SDWORD, "bufSize", &bufSize);
API_TRACE(API_TR_SDWORD, "outLen", outLen);
PA30SQLPROC(fileHandle, buf, bufSize, outLen, ferr );
API_TRACE(API_TR_UCHAR, "ferror", ferr );
PA03END

void sqlfreadp (tsp00_Int4 fileHandle,
                void* buf,
                tsp00_Longint bufSize,
                tsp00_Longint* outLen,
                tsp05_RteFileError *ferr)
PA03BEGIN(sqlfreadp)
API_TRACE(API_TR_SDWORD, "fileHandle", &fileHandle);
API_TRACE(API_TR_PTR, "buf", buf);
API_TRACE(API_TR_SDWORD, "bufSize", &bufSize);
API_TRACE(API_TR_SDWORD, "outLen", outLen);
PA30SQLPROC(fileHandle, buf, bufSize, outLen, ferr );
API_TRACE(API_TR_UCHAR, "ferror", ferr );
PA03END

void sqlfwritec (tsp00_Int4 fileHandle,
                 const void* buf,
                 tsp00_Longint inLen,
                 tsp05_RteFileError *ferr)
PA03BEGIN(sqlfwritec)
API_TRACE(API_TR_SDWORD, "fileHandle", &fileHandle);
API_TRACE(API_TR_PTR, "buf", buf);
API_TRACE(API_TR_SDWORD, "inLen", &inLen);
PA30SQLPROC(fileHandle, buf, inLen, ferr );
API_TRACE(API_TR_UCHAR, "ferror", ferr );
PA03END

void sqlfwritep (tsp00_Int4 fileHandle,
                 const void* buf,
                 tsp00_Longint inLen,
                 tsp05_RteFileError *ferr)
PA03BEGIN(sqlfwritep)
API_TRACE(API_TR_SDWORD, "fileHandle", &fileHandle);
API_TRACE(API_TR_PTR, "buf", buf);
API_TRACE(API_TR_SDWORD, "inLen", &inLen);
PA30SQLPROC(fileHandle, buf, inLen, ferr );
API_TRACE(API_TR_UCHAR, "ferror", ferr );
PA03END

void sqlfseekc (tsp00_Int4 fileHandle,
                tsp00_Longint distance,
                tsp05_RteSeekKind_Enum whence,
                tsp05_RteFileError *ferr)
PA03BEGIN(sqlfseekc)
API_TRACE(API_TR_SDWORD, "fileHandle", &fileHandle);
API_TRACE(API_TR_SDWORD, "distance", &distance);
API_TRACE(API_TR_UCHAR, "whence", &whence);
PA30SQLPROC(fileHandle, distance, whence, ferr );
API_TRACE(API_TR_UCHAR, "ferror", ferr );
PA03END

void sqlfseekp (tsp00_Int4 fileHandle,
                tsp00_Longint distance,
                tsp05_RteSeekKind whence,
                tsp05_RteFileError *ferr)
PA03BEGIN(sqlfseekp)
API_TRACE(API_TR_SDWORD, "fileHandle", &fileHandle);
API_TRACE(API_TR_SDWORD, "distance", &distance);
API_TRACE(API_TR_UCHAR, "whence", &whence);
PA30SQLPROC(fileHandle, distance, whence, ferr );
API_TRACE(API_TR_UCHAR, "ferror", ferr );
PA03END

void sqlferasec (const char         *rawFName,
                 tsp05_RteFileError *ferr)
PA03BEGIN(sqlferasec)
API_TRACE_LEN(API_TR_ODBC_STRING, "rawFName", rawFName, sizeof(tsp00_VFilename));
PA30SQLPROC(rawFName, ferr );
API_TRACE(API_TR_UCHAR, "ferror", ferr );
PA03END

void sqlferasep (const tsp00_VFilename rawFName,
                 tsp05_RteFileError *ferr)
PA03BEGIN(sqlferasep)
API_TRACE_LEN(API_TR_ODBC_STRING, "rawFName", &rawFName,sizeof(tsp00_VFilename));
PA30SQLPROC(rawFName, ferr );
API_TRACE(API_TR_UCHAR, "ferror", ferr );
PA03END

void sqlexec (tsp00_ExecArgLine   pszCommand,
              tsp00_ExecMode      eMode,
              tsp00_ExecReturn   *peResult,
              tsp00_ErrText       pszErrMsg,
              tsp00_Int2         *pfProgResult)
PA03BEGIN(sqlexec)
PA30SQLPROC(pszCommand, eMode, peResult, pszErrMsg, pfProgResult     );
PA03END

VOID    sqlargl     (   tsp00_Line                acArgs  )
PA03BEGIN(sqlargl)
PA30SQLPROC(acArgs  );
PA03END

#define  SP4XU_SQL_DBLANG  11

externC void sqlarg3     (tsp04_XuserRecord  *prcUserParams,
                          tsp00_Pw            acPassword,
                          tsp4_args_options  *prcArgsOptions,
                          tsp4_xuserset       aucXuserType,
                          tsp00_ErrText       acErrorText,
                          tsp00_BoolAddr      pbOk            )
PA03BEGIN(sqlarg3)
PA30SQLPROC(prcUserParams, acPassword, prcArgsOptions, aucXuserType, acErrorText, pbOk            );
API_TRACE(API_TR_UCHAR, "pbOk", pbOk);
#ifndef SAPDB_FAST
if(pbOk && !*pbOk)
   API_TRACE_LEN(API_TR_ODBC_STRING, "acErrorText", acErrorText, sizeof(tsp00_ErrText));
#endif
PA03END


void    sqlabort    (   void    )
PA03BEGIN(sqlabort)
PA30SQLPROC();
PA03END

void sqlcharsetname ( tsp00_KnlIdentifier acCharSetName )
PA03BEGIN(sqlcharsetname)
PA30SQLPROC(acCharSetName);
PA03END

void sqlclock (tsp00_Int4   *pSeconds,
               tsp00_Int4   *pMilliSeconds)
PA03BEGIN(sqlclock)
PA30SQLPROC(pSeconds, pMilliSeconds   );
PA03END

void sqldattime (tsp00_Date  pDate,
                 tsp00_Time  pTime)
PA03BEGIN(sqldattime)
PA30SQLPROC(pDate, pTime     );
PA03END

void sqlinit (tsp00_CompName acComponent,
              tsp00_BoolAddr  pbCancelAddress)
PA03BEGIN(sqlinit)
API_TRACE_LEN(API_TR_ODBC_STRING, "psComponent", &acComponent, sizeof(tsp00_CompName));
PA30SQLPROC(acComponent, pbCancelAddress );
API_TRACE(API_TR_PTR, "pbCancelAddress", &pbCancelAddress);
PA03END

void sqlfinish           ( tsp00_Bool                   bTerminate )
PA03BEGIN(sqlfinish)
API_TRACE(API_TR_UCHAR, "bTerminate", &bTerminate);
PA30SQLPROC(bTerminate);
PA03END

void sqluid (tsp00_TaskId* pUserID)
PA03BEGIN(sqluid)
PA30SQLPROC(pUserID);
API_TRACE(API_TR_SDWORD, "uid", pUserID);
PA03END

void sqlos (tsp00_Os *pfOS)
PA03BEGIN(sqlos)
PA30SQLPROC(pfOS );
PA03END

void sqlresult (tsp00_Uint1 fResult)
PA03BEGIN(sqlresult)
PA30SQLPROC(fResult );
PA03END

void sqlsleep (tsp00_Int2 limit)
PA03BEGIN(sqlsleep)
PA30SQLPROC(limit );
PA03END

void sqlgetenv (tsp00_VFilename envname,
                tsp00_VFilename envvalue,
                tsp00_BoolAddr  envfound)
PA03BEGIN(sqlgetenv)
PA30SQLPROC(envname, envvalue, envfound );
PA03END

void sqlindexuser (tsp00_Int2          kUserIndex,
                   tsp04_XuserRecord  *prcUserParams,
                   SAPDB_Char *		   accountName,
                   tsp00_ErrText       acErrorText,
                   tsp00_BoolAddr pbOk)
PA03BEGIN(sqlindexuser)
//PA30SQLPROC(kUserIndex, prcUserParams, accountName, acErrorText, pbOk );
API_TRACE(API_TR_MSG, "sqlindexuser not called", 0);
memset ( prcUserParams -> xu_servernode, ' ', sizeof ( SQL_NODEID   ));
memset ( prcUserParams -> xu_user,      ' ',  sizeof ( tsp00_KnlIdentifier ));
memset ( prcUserParams -> xu_password,  '\0', sizeof ( tsp00_CryptPw  ));
memset ( prcUserParams -> xu_sqlmode,   ' ',  sizeof ( tsp4_sqlmode_name ));
memset ( prcUserParams -> xu_serverdb, ' ', sizeof ( SQL_DBNAME ));
prcUserParams -> xu_cachelimit = -1;
prcUserParams -> xu_timeout    = -1;
prcUserParams -> xu_isolation  = -1;
memset ( acErrorText, ' ', sizeof ( ERRORTEXT ));
*pbOk = TRUE;
API_TRACE(API_TR_UCHAR, "pbOk", pbOk);
#ifndef SAPDB_FAST
if(pbOk && !*pbOk)
   API_TRACE_LEN(API_TR_ODBC_STRING, "acErrorText", &acErrorText, sizeof(acErrorText));
#endif
PA03END

#define TERMID                  C18
void    sqltermid   (   tsp00_TermId  acTerminalId    )
PA03BEGIN(sqltermid)
PA30SQLPROC(acTerminalId    );
API_TRACE_LEN(API_TR_ODBC_STRING, "acTerminalId", &acTerminalId, sizeof(acTerminalId));
PA03END

/* #define MEMCHECK */

#ifdef MEMCHECK
static tsp00_Int4 pa03AllocCount = 0;

tsp00_Bool dump = false;
#define _DEBUG
#include <crtdbg.h>
#endif /* MEMCHECK */

void sqlfree (tsp00_Uint1*  pucObjPtr)
PA03BEGIN(sqlfree)
API_TRACE(API_TR_PTR, "FR pucObjPtr", &pucObjPtr);
#ifdef MEMCHECK
pa03AllocCount--;
free( pucObjPtr );
dump = (pucObjPtr == NULL);
if (dump) {
    _CrtDumpMemoryLeaks();
};
#else
PA30SQLPROC(pucObjPtr );
#endif
PA03END

void sqlallocat (tsp00_Int4        lSize,
                 tsp00_Uint1**     ppucObjPtr,
                 tsp00_BoolAddr    pbOk)
PA03BEGIN(sqlallocat)
API_TRACE(API_TR_SDWORD, "lSize", &lSize);
#ifdef MEMCHECK
pa03AllocCount++;
*ppucObjPtr = malloc( lSize );
*pbOk = (tsp00_Bool) (ppucObjPtr != NULL);
#else
PA30SQLPROC(lSize, ppucObjPtr, pbOk);
#endif
API_TRACE(API_TR_PTR, "AL ppucObjPtr", ppucObjPtr);
API_TRACE(API_TR_UCHAR, "pbOk", pbOk);
PA03END


void sqlreallocat (tsp00_Int4        lSize,
                   tsp00_Uint1**     ppucObjPtr,
                   tsp00_BoolAddr    pbOk)
PA03BEGIN(sqlreallocat)
API_TRACE(API_TR_SDWORD, "lSize", &lSize);
API_TRACE(API_TR_PTR, "RE ppucObjPtr", ppucObjPtr);
#ifdef MEMCHECK
*ppucObjPtr = realloc( *ppucObjPtr, lSize );
*pbOk = (tsp00_Bool) (ppucObjPtr != NULL);
#else
PA30SQLPROC(lSize, ppucObjPtr, pbOk);
#endif
API_TRACE(API_TR_PTR, "RE ppucObjPtr", ppucObjPtr);
API_TRACE(API_TR_UCHAR, "pbOk", pbOk);
PA03END

void sqlversion ( tsp00_Version      RteVersion)
PA03BEGIN(sqlversion)
API_TRACE_LEN(API_TR_STRING, "version", &RteVersion, sizeof(RteVersion));
PA30SQLPROC(RteVersion);
PA03END

void sqlgetpid (  tsp00_Int4         *pid)
PA03BEGIN(sqlgetpid)
PA30SQLPROC(pid);
API_TRACE(API_TR_DWORD, "pid", pid);
PA03END

#ifndef MAX_MSG_LINE_LEN
#define MAX_MSG_LINE_LEN 512
#endif

VOID sql60_int_err_msg_prio7 ( const char *pszFormatStr, ... )
PA03BEGIN(sql60_int_err_msg_prio7)
{
  CHAR    String[MAX_MSG_LINE_LEN];
  va_list arg_ptr;
  va_start(arg_ptr, pszFormatStr);
  vsprintf(String, pszFormatStr, arg_ptr);
  va_end(arg_ptr);
  API_TRACE(API_TR_STRING, "pszFormatStr", pszFormatStr);  
  PA30SQLPROC(pszFormatStr);
}
PA03END

typedef tsp00_Bool (*ISSAPROUTERSTRING_PROC)();

tsp00_Bool SqlIsSapRouterString( char *serverNode )
{
    static ISSAPROUTERSTRING_PROC lpsql=NULL;
    static UCHAR                 *lpFunc="SqlIsSaprouterString";
    tsp00_Bool                    isSapRouterString = false;
    
    API_TRACE(API_TR_ENTRY, lpFunc, 0);
    
    if (!lpsql) {
        lpsql = (ISSAPROUTERSTRING_PROC) pa03DynamicLoad(lpFunc);
        if (!lpsql) {
            return false;
        };
    };
    
    isSapRouterString = lpsql( serverNode );

    API_TRACE(API_TR_EXIT, lpFunc, 0);
    
    return isSapRouterString;
} /* SqlIsSapRouterString */


typedef tsp01_CommErr_Enum (*ACANCEL_PROC)();

tsp01_CommErr_Enum SqlACancel ( tsp00_Int4      reference ,
                                char           *szSapRouterString,
                                tsp00_ErrTextc  szErrText )
{
    static ACANCEL_PROC  lpsql=NULL;
    tsp01_CommErr_Enum   ret = commErrOk_esp01;
    static UCHAR        *lpfunc = "SqlACancel";
    
    API_TRACE(API_TR_ENTRY, lpfunc, 0);
    
    if (!lpsql) {
        lpsql = (ACANCEL_PROC) pa03DynamicLoad(lpfunc);
        if (!lpsql) {
            return commErrNotOk_esp01;
        };
    };
    
    ret = lpsql( reference,
                 szSapRouterString,
                 szErrText );
    
    API_TRACE(API_TR_EXIT, lpfunc, 0);
    
    return ret;
} /* SqlACancel */


typedef  void *(*ALLOCSHAREDMEM_PROC)();

void *sqlAllocSharedMem(const char *Path, const unsigned int SizeInBytes)
{
    static ALLOCSHAREDMEM_PROC  lpsql        = NULL;
    void                       *sharedMemPtr = NULL;
    static UCHAR               *lpfunc       = "sqlAllocSharedMem";
    
    API_TRACE(API_TR_ENTRY, lpfunc, 0);
    API_TRACE(API_TR_UDWORD, "SizeInBytes", &SizeInBytes);

    if (!lpsql) {
        lpsql = (ALLOCSHAREDMEM_PROC) pa03DynamicLoad(lpfunc);
        if (!lpsql) {
            return NULL;
        };
    };

    sharedMemPtr = lpsql( Path, SizeInBytes );
    API_TRACE(API_TR_PTR, "sharedMemPtr", &sharedMemPtr);

    API_TRACE(API_TR_EXIT, lpfunc, 0);

    return sharedMemPtr;
} /* sqlAllocSharedMem */


typedef void (*FREESHAREDMEM_PROC)( void               *ShmAddress,
                                    const unsigned int  SizeInBytes );

void sqlFreeSharedMem(void *ShmAddress, const unsigned int SizeInBytes)
{
    static FREESHAREDMEM_PROC  lpsql = NULL;
    static UCHAR              *lpfunc = "sqlFreeSharedMem";
    
    API_TRACE( API_TR_ENTRY, lpfunc, 0);
    API_TRACE( API_TR_PTR, "ShmAddress", &ShmAddress );
    API_TRACE(API_TR_UDWORD, "SizeInBytes", &SizeInBytes);
    
    if (!lpsql) {
        lpsql = (FREESHAREDMEM_PROC) pa03DynamicLoad(lpfunc);
        if (!lpsql) {
            return;
        };
    };
    lpsql( ShmAddress, SizeInBytes );

    API_TRACE(API_TR_EXIT, lpfunc, 0);
} /* sqlFreeSharedMem */


typedef tsp00_Bool (*GETINDPATH_PROC)();

tsp00_Bool
sqlGetIndependentProtPath( tsp00_Pathc VAR_ARRAY_REF    PROTPath,
                           int                          TerminateWithDelimiter,
                           tsp01_RteError              *RteError )
{
    static GETINDPATH_PROC  lpsql = NULL;
    static UCHAR           *lpfunc = "sqlGetIndependentProtPath";
    tsp00_Bool              ret = true;
    
    API_TRACE(API_TR_ENTRY, lpfunc, 0);
    
    if (!lpsql) {
        lpsql = (GETINDPATH_PROC) pa03DynamicLoad(lpfunc);
        if (!lpsql) {
            return false;
        };
    };
    ret = lpsql( PROTPath, TerminateWithDelimiter, RteError );

    API_TRACE(API_TR_EXIT, lpfunc, 0);

    return ret;
} /* sqlGetIndependentProtPath */


/**********************************************************
 * Multithreading runtime routines
 **********************************************************/

void sqlinit_multithreading(teo07_Thread *thread,
                            tsp00_ErrTextc VAR_ARRAY_REF errtext,
                            teo07_ThreadErr *err)
PA03BEGIN(sqlinit_multithreading)
{
    PA30SQLPROC( thread, errtext, err );
}
PA03END

void sqlbeginthread(tsp00_Int4 stack_size_in_bytes, 
                    teo07_ThreadCallback proc, 
                    void *arg, 
                    tsp00_Int4 flags, 
                    teo07_Thread *pThread,
                    tsp00_ErrTextc VAR_ARRAY_REF errtext, 
                    teo07_ThreadErr *err)
PA03BEGIN(sqlbeginthread)
{
    PA30SQLPROC(stack_size_in_bytes,
                proc,
                arg,
                flags,
                pThread,
                errtext, err );
}
PA03END


teo07_ThreadErr sqlsetthreadpriority(  teo07_Thread thread, 
                                       tsp00_Int4 priority)
{
  static SQLPROCRETURN lpsql=NULL;
  teo07_ThreadErr ret;
  API_TRACE(API_TR_ENTRY, "sqlsetthreadpriority", 0);
  if (!lpsql)
    lpsql = pa03DynamicLoad ("sqlsetthreadpriority");

  ret = lpsql (thread, priority);
  API_TRACE(API_TR_EXIT, "sqlsetthreadpriority", 0);
  return ret;
}



teo07_ThreadErr sqlgetthreadpriority(  teo07_Thread thread, 
                                       tsp00_Int4 VAR_VALUE_REF priority)
{
  static SQLPROCRETURN lpsql=NULL;
  teo07_ThreadErr ret;
  API_TRACE(API_TR_ENTRY, "sqlgetthreadpriority", 0);
  if (!lpsql)
    lpsql = pa03DynamicLoad ("sqlgetthreadpriority");

  ret = lpsql (thread, priority);
  API_TRACE(API_TR_EXIT, "sqlgetthreadpriority", 0);
  return ret;
}


void sqlendthread(tsp00_Int4 returncode)
PA03BEGIN(sqlendthread)
{
    PA30SQLPROC( returncode );
}
PA03END


void sqlkillthread(teo07_Thread thread, 
                   tsp00_ErrTextc VAR_ARRAY_REF errtext, 
                   teo07_ThreadErr *err)
PA03BEGIN(sqlkillthread)
{
    PA30SQLPROC( thread, errtext, err );
}
PA03END


void sqlsigthread( teo07_Thread thread, 
                   tsp00_Int4 signal,
                   tsp00_ErrTextc VAR_ARRAY_REF errtext, 
                   teo07_ThreadErr *err)
PA03BEGIN(sqlsigthread)
{
    PA30SQLPROC( thread, signal, errtext, err );
}
PA03END


void sqlcancelthread(teo07_Thread thread, 
                     tsp00_Int4 returncode,
                     tsp00_ErrTextc VAR_ARRAY_REF errtext, 
                     teo07_ThreadErr *err)
PA03BEGIN(sqlcancelthread)
{
    PA30SQLPROC( thread, returncode, errtext, err );
}
PA03END


void sqlforgetthread (teo07_Thread thread)
PA03BEGIN(sqlforgetthread)
{
    PA30SQLPROC( thread );
}
PA03END


void sqlyieldthread(void)
PA03BEGIN(sqlyieldthread)
{
    PA30SQLPROC();
}
PA03END


typedef teo07_Thread (*GETTHREAD_PROC)();

teo07_Thread   sqlgetthread()
{
    static GETTHREAD_PROC lpsql=NULL;
    static UCHAR         *lpFunc="sqlgetthread";
    teo07_Thread          thread;
    
    /* API_TRACE(API_TR_ENTRY, lpFunc, 0); */
    if (!lpsql)
        lpsql = (GETTHREAD_PROC) pa03DynamicLoad(lpFunc);
    thread = lpsql();
    
    /* API_TRACE(API_TR_EXIT, lpFunc, 0); */
    
    return thread;
}; /* sqlgetthread */


typedef teo07_ThreadId (*GETTHREADID_PROC)();
 
teo07_ThreadId sqlgetthreadid()
{
    static GETTHREADID_PROC lpsql=NULL;
    static UCHAR           *lpFunc="sqlgetthreadid";
    teo07_ThreadId          threadId;
    
    /*  API_TRACE(API_TR_ENTRY, lpFunc, 0); */
    if (!lpsql)
        lpsql = (GETTHREADID_PROC) pa03DynamicLoad(lpFunc);
    threadId = lpsql();
    
    /* API_TRACE(API_TR_EXIT, lpFunc, 0); */
    
    return threadId;
}; /* sqlgetthreadid */

 
teo07_ThreadId sqlthreadid(teo07_Thread thread)
{
    static GETTHREADID_PROC lpsql=NULL;
    static UCHAR           *lpFunc="sqlthreadid";
    teo07_ThreadId          threadId;
    
    API_TRACE(API_TR_ENTRY, lpFunc, 0);
    if (!lpsql)
        lpsql = (GETTHREADID_PROC) pa03DynamicLoad(lpFunc);
    threadId = lpsql( thread );
    
    API_TRACE(API_TR_EXIT, lpFunc, 0);

    return threadId;
}; /* sqlthreadid */


void sqlsuspendthread(teo07_Thread thread, 
                      tsp00_ErrTextc VAR_ARRAY_REF errtext, 
                      teo07_ThreadErr *err)
PA03BEGIN(sqlsuspendthread)
{
    PA30SQLPROC( thread, errtext, err );
}
PA03END


void sqlresumethread(teo07_Thread thread, 
                     tsp00_ErrTextc VAR_ARRAY_REF errtext, 
                     teo07_ThreadErr *err)
PA03BEGIN(sqlresumethread)
{
    PA30SQLPROC( thread, errtext, err );
}
PA03END


void sqljointhread(teo07_Thread thread, 
                   tsp00_Int4 *status, 
                   tsp00_ErrTextc VAR_ARRAY_REF errtext, 
                   teo07_ThreadErr *err)
PA03BEGIN(sqljointhread)
{
    PA30SQLPROC( thread, status, errtext, err );
}
PA03END


typedef int (*INT_PROC)();

int sqlthreadalive( teo07_Thread thread, 
                     tsp00_ErrTextc VAR_ARRAY_REF errtext, 
                     teo07_ThreadErr *err)
{
    static INT_PROC lpsql=NULL;
    static UCHAR   *lpFunc="sqlthreadalive";
    int             threadAlive;
    
    API_TRACE(API_TR_ENTRY, lpFunc, 0);
    if (!lpsql)
        lpsql = (INT_PROC) pa03DynamicLoad(lpFunc);
    threadAlive = lpsql( thread, errtext, err );
    
    API_TRACE(API_TR_EXIT, lpFunc, 0);

    return threadAlive;
}; /* sqlthreadalive */


void sqlonce (tsp00_Int4* initialized,
              teo07_ThreadCallback callback,
              void* arg)
PA03BEGIN(sqlonce)
{
    PA30SQLPROC( initialized, callback, arg );
}
PA03END


void sqlcreatemutex(teo07_Mutex *hMutex)
{ /* we can't trace this because it is called from apdtrac */
    static SQLPROC lpsql=NULL;
    static UCHAR  *lpFunc="sqlcreatemutex";

    if (!lpsql)
        lpsql = (INT_PROC) pa03DynamicLoad(lpFunc);
    lpsql( hMutex );

} /* sqlcreatemutex */


void sqldestroymutex(teo07_Mutex *hMutex)
PA03BEGIN(sqldestroymutex)
{
    PA30SQLPROC( hMutex );
}
PA03END


void sqlbeginmutex(teo07_Mutex *hMutex)
{ /* we can't trace this because it is called from apdtrac */
    static SQLPROC  lpsql=NULL;
    static UCHAR   *lpFunc="sqlbeginmutex";

#ifdef TRACE_MUTEX
    pa03_WriteToFile( "begin", "begin\n" );
#endif    
    if (!lpsql)
        lpsql = (INT_PROC) pa03DynamicLoad(lpFunc);
    lpsql( hMutex );

} /* sqlbeginmutex */


int sqlissetmutex(teo07_Mutex *hMutex)
{
    static INT_PROC lpsql=NULL;
    static UCHAR   *lpFunc="sqlissetmutex";
    int             isSet;
    
    API_TRACE(API_TR_ENTRY, lpFunc, 0);
    if (!lpsql)
        lpsql = (INT_PROC) pa03DynamicLoad(lpFunc);
    isSet = lpsql( hMutex );
    
    API_TRACE(API_TR_EXIT, lpFunc, 0);

    return isSet;
}; /* sqlissetmutex */


typedef tsp00_Int4 (*INT4_PROC)();

tsp00_Int4 sqltrybeginmutex(teo07_Mutex *hMutex)
{
    static INT4_PROC lpsql=NULL;
    static UCHAR    *lpFunc="sqltrybeginmutex";
    tsp00_Int4       retcode;
    
    API_TRACE(API_TR_ENTRY, lpFunc, 0);
    if (!lpsql)
        lpsql = (INT4_PROC) pa03DynamicLoad(lpFunc);
    retcode = lpsql( hMutex );
#ifdef TRACE_MUTEX    
    if (retcode) {
        pa03_WriteToFile( "trybegin", "trybegin\n" );
    };
#endif    
    API_TRACE(API_TR_EXIT, lpFunc, 0);

    return retcode;
}; /* sqltrybeginmutex */


void sqlendmutex(teo07_Mutex *hMutex)
{ /* we can't trace this because it is called from apdtrac */
    static SQLPROC  lpsql=NULL;
    static UCHAR   *lpFunc="sqlendmutex";
    
#ifdef TRACE_MUTEX    
    pa03_WriteToFile( "end", "end\n" );
#endif    
    if (!lpsql)
        lpsql = (INT_PROC) pa03DynamicLoad(lpFunc);
    lpsql( hMutex );

}; /* sqlendmutex */


void sqlcreatetls(tsp00_Int4 *hKey, 
                  tsp00_ErrTextc VAR_ARRAY_REF errtext, 
                  teo07_ThreadErr *err)
PA03BEGIN(sqlcreatetls)
{
    PA30SQLPROC( hKey, errtext, err );
}
PA03END


void sqldestroytls(tsp00_Int4 hKey, 
                   tsp00_ErrTextc VAR_ARRAY_REF errtext, 
                   teo07_ThreadErr *err)
PA03BEGIN(sqldestroytls)
{
    PA30SQLPROC( hKey, errtext, err );
}
PA03END


void sqlsettls(tsp00_Int4 hKey, 
               void*  pObjPtr, 
               tsp00_ErrTextc VAR_ARRAY_REF errtext, 
               teo07_ThreadErr *err)
PA03BEGIN(sqlsettls)
{
    PA30SQLPROC( hKey, pObjPtr, errtext, err );
}
PA03END


typedef void* (*GETTLS_PROC)();

void *sqlgettls(tsp00_Int4 hKey)
{
    static GETTLS_PROC lpsql=NULL;
    UCHAR          *lpFunc="sqlgettls";
    void           *tls;
    
    /* API_TRACE(API_TR_ENTRY, lpFunc, 0); */
    if (!lpsql)
        lpsql = (GETTLS_PROC) pa03DynamicLoad(lpFunc);
    tls = lpsql( hKey );
    
    /* API_TRACE(API_TR_EXIT, lpFunc, 0); */

    return tls;
}; /* sqlgettls */

void pa03_WriteToFile( char *fileName, char *str )
{
    FILE *fd = fopen( fileName, "a" );
    
    if (fd) {
        fprintf( fd, str );
        fclose( fd );
    }; /* if */
}; /* pa30wcWriteToFile */

#endif /* DYNAMICLOAD */
.CM *-END-* code ----------------------------------------
.SP 2 
***********************************************************
