Windows编程

开发平台：
Visual C++

STANDARD.C：源码内容
							//*---------------------------------------------------------------------------------
//|  ODBC System Administrator
//|
//|  This code is furnished on an as-is basis as part of the ODBC SDK and is
//|  intended for example purposes only.
//|
//|   Title:   STANDARD.C
//|      This module contains standard functions which can be used by many
//|      different tools.
//|
//|      The DumpDebugInfo function when enabled will cause all memory requests
//|      and frees to be written to a comma separated file.  This file can then
//|      be queries via the sample Text ODBC Driver to find memory problems.
//*---------------------------------------------------------------------------------
#include "standard.h"
#include <windowsx.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include "errcheck.h"
#include "strings.h"
//*---------------------------------------------------------------------------------
//|   Global variables
//*---------------------------------------------------------------------------------
char OutStr[MAXBUFF];
dCSEG(char) szui[]                        =  "%u";
dCSEG(char) szEmpty[]                     =  "";
dCSEG(char) szcrlf[]                      =  "rn";
#ifdef _DEBUG
#include "time.h"
#define szASSERTERROR (LPSTR)"Assert: %s, %s, %d"
#define szDEBUGFILE (LPSTR)"C:\TMP\MEM"
char szDbgOut[200];
BOOL fNew=TRUE;
void WinAssertReal(int exp, LPSTR msg, LPSTR file, int line)
{
   if(!exp) {
      wsprintf(szDbgOut, szASSERTERROR, msg, file, line);
      MessageBox(GetActiveWindow(), szDbgOut, szErrTitle, MB_OK);
   }
}
void DumpDebugInfo(LPVOID tmp, LPSTR szFile, int cbLine, int stat,
         DWORD rqSize, DWORD aSize)
{
   static   OFSTRUCT    ofs;
   static   HFILE       hf;
   static   time_t      thetime;
   static   struct tm * tmVal;
   if(fNew) {
      fNew = FALSE;
      ofs.cBytes = sizeof(OFSTRUCT);
      hf = OpenFile(szDEBUGFILE, &ofs, OF_DELETE);
      _lclose(hf);
   }
   // Creates file MEM which is a comma separated text file.
   // Issue the select statement to find memory ptrs
   // which were allocated but never freed (status=1), and
   // pointers which were freed but never allocated (status=-1).
   // Of course "No data found" is the desired response.
   //    create table mem
   //        (address char(9),
   //         logtime char(8),
   //         status integer,
   //         desired integer,
   //         actual integer,
   //         line integer,
   //         file char(45))
   //    select address, sum(status) from mem
   //      group by address having sum(status) <> 0
   time(&thetime);
   tmVal = localtime(&thetime);
   wsprintf(szDbgOut, (LPSTR)"%04X:%04X,%02u:%02u:%02u,%d,%lu,%lu,%u,%srn",
            HIWORD(tmp), LOWORD(tmp), tmVal->tm_hour, tmVal->tm_min, tmVal->tm_sec,
            stat, rqSize, aSize, cbLine, (LPSTR)szFile);
   if((hf = _lopen(szDEBUGFILE, WRITE)) == -1)  // File not found
      hf = OpenFile(szDEBUGFILE, &ofs, OF_CREATE);
   _llseek(hf, 0L, 2);                    // Try to go to end of file
   _lwrite(hf, szDbgOut, lstrlen(szDbgOut));  // Write wherever we are
   _lclose(hf);
}
void FAR * DebugGetMemory(DWORD size, LPSTR szFile, int cbLine)
{
   LPVOID   ptr;
   DWORD    aSize;
   ptr = DoGetMemory(size);
   if(!ptr)
      return ptr;
   aSize = GlobalSize(GlobalPtrHandle(ptr));
   DumpDebugInfo(ptr, szFile, cbLine, 1, size, aSize);
   return ptr;
}
void DebugReleaseMemory(LPVOID ptr, LPSTR szFile, int cbLine)
{
   GlobalFreePtr(ptr);
   DumpDebugInfo(ptr, szFile, cbLine, -1, 0, 0);
}
#endif      // Debug memory routines
//*---------------------------------------------------------------------------------
//| DoGetMemory:
//|   This function allocates the specified amount of memory.
//| Parms:
//|   in       size                 How much memory
//| Returns:
//|   Long pointer to void
//*---------------------------------------------------------------------------------
void FAR * DoGetMemory(DWORD size)
{
   LPVOID   tmp;
   tmp = GlobalAllocPtr(GMEM_FIXED | GMEM_ZEROINIT, size);
   if(!tmp)
      szMessageBox(GetActiveWindow(),
                   MB_ICONEXCLAMATION,
                   (LPSTR)szErrTitle,
                   GetidsString(idsOutOfMemory, OutStr, MAXBUFF));
   return tmp;
}
//*---------------------------------------------------------------------------------
//| DoReleaseMemory:
//|   Free up the memory we have requested
//| Parms:
//|   ptr         The pointer to free
//| Returns:
//|   Nothing.
//*---------------------------------------------------------------------------------
void DoReleaseMemory(LPVOID ptr)
{
   GlobalFreePtr(ptr);
}
//*---------------------------------------------------------------------------------
//| RemoveCrLf:
//|   This will remove all carriage return/line feeds from the input buffer.
//| Parms:
//|   in       instr                Null terminated string
//| Returns:
//|   Nothing
//*---------------------------------------------------------------------------------
void RemoveCrLf(LPSTR instr)
{
   LPSTR str=instr;
   if(!str ||
      !*str)
      return;
   while((str = _fstrstr(str, (LPSTR)szcrlf))) {
      *str++ = ' ';
      *str++ = ' ';
   }
}
//*---------------------------------------------------------------------------------
//| GetNewDirectory:
//|   This function will take a complete file name (must have path included)
//|   and return only the path portion with no trailing ''
//| Parms:
//|   outstr            Output path name with no file
//|   instr             Input complete file name
//| Returns:
//|   Nothing
//*---------------------------------------------------------------------------------
void GetNewDirectory(LPSTR outstr, LPSTR instr)
{
   LPSTR    str=outstr;
   LPSTR    lstr=outstr;
   lstrcpy(str, instr);
   while((str = _fstrchr(lstr+1, '\')))
      lstr = str++;
   *++lstr = '';
}
//*---------------------------------------------------------------------------------
//| ValidName:
//|   This function parses a string to look for invalid characters which would
//|   preclude it from being written as a section or entry in an .ini file.
//| Parms:
//|   instr             Input complete file name
//| Returns:
//|   TRUE if it is valid, FALSE on error
//*---------------------------------------------------------------------------------
BOOL ValidName(LPSTR instr)
{
   LPSTR str=instr;
   if(!str)
      return TRUE;
   while(*str)
      switch(*str) {
        case '[':
        case ']':
        case '=':
         return FALSE;
        default:
         ++str;
      }
   return TRUE;
}
//*---------------------------------------------------------------------------------
//| lpatoi:
//|   atoi only works for NEAR host vars, which makes it useless in a large
//|   application.  This function tricks atoi by copy the long string to a
//|   local variable and then doing the conversion.  This is a major cluge,
//|   but a necessary one.
//| Parms:
//|   instr             Input number
//| Returns:
//|   The integer value of instr
//*---------------------------------------------------------------------------------
int lpatoi(LPSTR instr)
{
   char szStr[35];
   lstrcpy((LPSTR)szStr, instr);
   return atoi(szStr);
}
//*------------------------------------------------------------------------
//|  GetidsString:
//|      Will retrieve a string from our resource fork given the id.
//|  Parms:
//|      ids            The id of the string
//|      szOut          Output buffer for string
//|      cbSize         How big is the buffer
//|  Returns:
//|      Pointer to szOut
//*------------------------------------------------------------------------
LPSTR EXTFUN GetidsString(UINT ids, LPSTR szOut, UINT cbSize)
{
   extern HINSTANCE hInst;
   if(!szOut)
      return NULL;
   if(!LoadString(hInst, ids, szOut, cbSize))
      lstrcpy(szOut, "Not found");
   return szOut;
}
//*------------------------------------------------------------------------
//|  szWrite:
//|      Allows you to format an output string which is then added
//|      to the specified edit window.
//|  Parms:
//|      hwnd           Edit window for output
//|      szFmt          Format string
//|      (varying)      Arguements for format string
//|  Returns:
//|      Nothing
//*------------------------------------------------------------------------
VOID FAR CDECL szWrite(HWND hwnd, LPSTR szFmt, ...)
{
#define MAXEDITBUFF 30000
   static      char  szBuffer[MAXBUFF];
   UCHAR *     pszBuffer;
   UCHAR       bufFmt[MAXBUFF];
   va_list           marker;
   UINT              rtn=0;
   UINT              len=0;
   pszBuffer = &szBuffer[0];
   lstrcpy(bufFmt, szFmt);
   // Use format and arguements as input
   va_start(marker, szFmt);
   if (_vsnprintf(pszBuffer, MAXBUFF, bufFmt, marker) < 0) {
      wsprintf(pszBuffer,"Buffer overflow reporting '%*.*s'", 50,50,(LPSTR)szBuffer);
      return;
   }
   va_end(marker);
   // Now we have the string to add to the end of our output.  Verify that the
   // new string will not be too large and set selection accordingly.
   len = (UINT)SendMessage(hwnd, WM_GETTEXTLENGTH, 0, 0L);
   if(len + lstrlen(pszBuffer) > MAXEDITBUFF) {    //  Need to truncate
      SendMessage(hwnd, EM_SETSEL, 0, MAKELPARAM(0,len + 10));
      SendMessage(hwnd, EM_REPLACESEL, 0, (LPARAM)((LPSTR)"...rn"));
      SendMessage(hwnd, EM_SETSEL, 0, MAKELPARAM(len,len));
   }
   SendMessage(hwnd, EM_REPLACESEL, 0, (LPARAM)((LPSTR)pszBuffer));
}
//*------------------------------------------------------------------------
//|  szMessageBox:
//|      Works like sprintf only the output goes to a message box.
//|  Parms:
//|      hwnd           Owner window, NULL uses GetActiveWindow
//|      style          Flags for MessageBox
//|      szTitle        Title for message box
//|      szFmt          Format string
//|      (varying)      Arguements for format string
//|  Returns:
//|      Id from MessageBox
//*------------------------------------------------------------------------
int FAR CDECL szMessageBox(HWND hwnd, UINT style, LPSTR szTitle, LPSTR szFmt, ...)
{
   char        szBuffer[MAXBUFF];
   char *      pszBuffer;
   UCHAR       bufFmt[MAXBUFF];
   va_list     marker;
   pszBuffer = &szBuffer[0];
   lstrcpy(bufFmt, szFmt);
   // Use format and arguements as input
   va_start(marker, szFmt);
   if (_vsnprintf(pszBuffer, MAXBUFF, bufFmt, marker) < 0)
      wsprintf(pszBuffer,"Buffer overflow reporting '%*.*s'", 50,50,szBuffer);
   va_end(marker);
   return(MessageBox((hwnd) ? hwnd : GetActiveWindow(),
                     pszBuffer,
                     szTitle,
                     style) == IDOK);
}

						