开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 查看源码
DUMP.CPP
资源名称：MSDN_VC98.zip　[点击查看]
上传用户：bangxh
上传日期：2007-01-31
资源大小：42235k
文件大小：16k
源码类别：

Windows编程

开发平台：

Visual C++

DUMP.CPP：源码内容
  1. //--------------------------------------------------------------------
  2. // Microsoft OLE DB Sample Consumer
  3. // (C) Copyright 1995 - 1998 Microsoft Corporation. All Rights Reserved.
  4. //
  5. // File name: DUMP.CPP
  6. //
  7. //      Dumpoutput routines for the SAMPCLNT sample OLE DB consumer.
  8. //
  9. //      See README.TXT for more information on the SAMPCLNT sample.
  10. //
  11. // Functions:
  12. //
  13. //      See SAMPCLNT.H for function prototypes
  14. //
  18. #include "sampclnt.h"
  23. void DumpErrorMsg
  24. (
  25.     const char* format,
  26.     ...
  27. )
  28. {
  29. va_list argptr;     
  31. assert(format != NULL);
  33. // log this message to stderr and to our log file
  34. va_start( argptr, format );
  35. tvfprintf( stderr, format, argptr);
  36.     tvfprintf( g_fpLogFile, format, argptr);
  37. va_end( argptr );
  38. }    
  42. void DumpStatusMsg
  43. (
  44.     const char* format,
  45.     ...
  46. )
  47. {
  48. va_list argptr;
  50. assert(format != NULL);
  52. // log this message to stdout and to our log file
  53. va_start( argptr, format );
  54. tvfprintf( stdout, format, argptr );
  55.     tvfprintf( g_fpLogFile, format, argptr );
  56. va_end( argptr );
  57. }    
  62. HRESULT DumpErrorHResult
  63. (
  64. HRESULT      hr_return,
  65. const char  *format, // can be NULL
  66. ... 
  67. )
  68. {
  69. char     buff[100];
  70. int      cBytesWritten;
  71. va_list  argptr;
  73. //
  74. // Dump an error message.
  75. // Print the text of the HRESULT,
  76. // Return the HRESULT we were passed.
  78.     // these result codes were generated from the oledberr.h 
  79. static Note ResultCodes[] = {
  80. // oledberr.h error codes
  81. NOTE(DB_E_BADACCESSORHANDLE),
  82. NOTE(DB_E_BADACCESSORHANDLE),
  83. NOTE(DB_E_ROWLIMITEXCEEDED),
  84. NOTE(DB_E_READONLYACCESSOR),
  85. NOTE(DB_E_SCHEMAVIOLATION),
  86. NOTE(DB_E_BADROWHANDLE),
  87. NOTE(DB_E_OBJECTOPEN),
  88. NOTE(DB_E_BADBINDINFO),
  89. NOTE(DB_SEC_E_PERMISSIONDENIED),
  90. NOTE(DB_E_NOTAREFERENCECOLUMN),
  91. NOTE(DB_E_NOCOMMAND),
  92. NOTE(DB_E_BADBOOKMARK),
  93. NOTE(DB_E_BADLOCKMODE),
  94. NOTE(DB_E_PARAMNOTOPTIONAL),
  95. NOTE(DB_E_BADRATIO),
  96. NOTE(DB_E_ERRORSINCOMMAND),
  97. NOTE(DB_E_BADSTARTPOSITION),
  98. NOTE(DB_E_NOTREENTRANT),
  99. NOTE(DB_E_NOAGGREGATION),
  100. NOTE(DB_E_DELETEDROW),
  101. NOTE(DB_E_CANTFETCHBACKWARDS),
  102. NOTE(DB_E_ROWSNOTRELEASED),
  103. NOTE(DB_E_BADSTORAGEFLAG),
  104. NOTE(DB_E_BADSTATUSVALUE),
  105. NOTE(DB_E_CANTSCROLLBACKWARDS),
  106. NOTE(DB_E_INTEGRITYVIOLATION),
  107. NOTE(DB_E_ABORTLIMITREACHED),
  108. NOTE(DB_E_DUPLICATEINDEXID),
  109. NOTE(DB_E_NOINDEX),
  110. NOTE(DB_E_INDEXINUSE),
  111. NOTE(DB_E_NOTABLE),
  112. NOTE(DB_E_CONCURRENCYVIOLATION),
  113. NOTE(DB_E_BADCOPY),
  114. NOTE(DB_E_BADPRECISION),
  115. NOTE(DB_E_BADSCALE),
  116. NOTE(DB_E_BADID),
  117. NOTE(DB_E_BADTYPE),
  118. NOTE(DB_E_DUPLICATECOLUMNID),
  119. NOTE(DB_E_DUPLICATETABLEID),
  120. NOTE(DB_E_TABLEINUSE),
  121. NOTE(DB_E_NOLOCALE),
  122. NOTE(DB_E_BADRECORDNUM),
  123. NOTE(DB_E_BOOKMARKSKIPPED),
  124. NOTE(DB_E_BADPROPERTYVALUE),
  125. NOTE(DB_E_INVALID),
  126. NOTE(DB_E_BADACCESSORFLAGS),
  127. NOTE(DB_E_BADSTORAGEFLAGS),
  128. NOTE(DB_E_BYREFACCESSORNOTSUPPORTED),
  129. NOTE(DB_E_NULLACCESSORNOTSUPPORTED),
  130. NOTE(DB_E_NOTPREPARED),
  131. NOTE(DB_E_BADACCESSORTYPE),
  132. NOTE(DB_E_WRITEONLYACCESSOR),
  133. NOTE(DB_SEC_E_AUTH_FAILED),
  134. NOTE(DB_E_CANCELED),
  135. NOTE(DB_E_BADSOURCEHANDLE),
  136. NOTE(DB_S_ROWLIMITEXCEEDED),
  137. NOTE(DB_S_COLUMNTYPEMISMATCH),
  138. NOTE(DB_S_TYPEINFOOVERRIDDEN),
  139. NOTE(DB_S_BOOKMARKSKIPPED),
  140. NOTE(DB_S_ENDOFROWSET),
  141. NOTE(DB_S_BUFFERFULL),
  142. NOTE(DB_S_CANTRELEASE),
  143. NOTE(DB_S_DIALECTIGNORED),
  144. NOTE(DB_S_UNWANTEDPHASE),
  145. NOTE(DB_S_COLUMNSCHANGED),
  146. NOTE(DB_S_ERRORSRETURNED),
  147. NOTE(DB_S_BADROWHANDLE),
  148. NOTE(DB_S_DELETEDROW),
  149. NOTE(DB_S_STOPLIMITREACHED),
  150. NOTE(DB_S_LOCKUPGRADED),
  151. NOTE(DB_S_PROPERTIESCHANGED),
  152. NOTE(DB_S_ERRORSOCCURRED),
  153. NOTE(DB_S_PARAMUNAVAILABLE),
  154. NOTE(DB_S_MULTIPLECHANGES),
  156. // winerr.h
  157. NOTE(E_UNEXPECTED),
  158. NOTE(E_NOTIMPL),
  159. NOTE(E_OUTOFMEMORY),
  160. NOTE(E_INVALIDARG),
  161. NOTE(E_NOINTERFACE),
  162. NOTE(E_POINTER),
  163. NOTE(E_HANDLE),
  164. NOTE(E_ABORT),
  165. NOTE(E_FAIL),
  166. NOTE(E_ACCESSDENIED),
  167. NOTE(S_OK),
  168. NOTE(S_FALSE),
  169. NOTE(E_UNEXPECTED),
  170. NOTE(E_NOTIMPL),
  171. NOTE(E_OUTOFMEMORY),
  172. NOTE(E_INVALIDARG),
  173. NOTE(E_NOINTERFACE),
  174. NOTE(E_POINTER),
  175. NOTE(E_HANDLE),
  176. NOTE(E_ABORT),
  177. NOTE(E_FAIL),
  178. NOTE(E_ACCESSDENIED),
  179. // BindMoniker Errors
  180. NOTE(MK_E_NOOBJECT),
  181. NOTE(MK_E_EXCEEDEDDEADLINE),
  182. NOTE(MK_E_CONNECTMANUALLY),
  183. NOTE(MK_E_INTERMEDIATEINTERFACENOTSUPPORTED),
  184. NOTE(STG_E_ACCESSDENIED),
  185. NOTE(MK_E_SYNTAX),
  186. NOTE(MK_E_CANTOPENFILE),
  187. };
  190. // Format the message.
  191. // Print name of hresult code.
  193. if (format)
  194. {
  195. va_start( argptr, format );
  196. cBytesWritten = _vsnprintf( buff, sizeof(buff), format, argptr );
  197. va_end( argptr );
  198. }
  199. else
  200. strcpy( buff, "" );
  202. // log to stderr and also to our log file
  203. tfprintf( stderr, "%.*s: Returned %.30sn", 
  204. sizeof(buff), buff, 
  205. GetNoteString( ResultCodes, NUMELEM(ResultCodes), GetScode(hr_return)) );
  206.         
  207.     tfprintf( g_fpLogFile, "%.*s: Returned %.30sn", 
  208. sizeof(buff), buff, 
  209. GetNoteString( ResultCodes, NUMELEM(ResultCodes), GetScode(hr_return)) );
  211. return ResultFromScode( hr_return );
  212. }
  217. void DumpColumnsInfo
  218. (
  219.     DBCOLUMNINFO* pColInfo,
  220.     ULONG       cCol
  221.     )
  222. {
  223. ULONG j;
  225. assert(pColInfo != NULL);
  226.  
  227. tfprintf( g_fpLogFile, "nColumn Information:nn"); 
  228.     
  229. for (j=0; j < cCol; j++)
  230. {
  231. WriteColumnInfo( g_fpLogFile, &pColInfo[j] );
  232. }
  233. }
  237. void WriteColumnInfo
  238. (
  239. FILE* fp,
  240. DBCOLUMNINFO* p 
  241. )
  242. {
  243. DBID      *pCol;
  244.     DBKIND      eKind;
  245. wchar_t  wszGuidBuff[MAX_GUID_STRING];
  246.     wchar_t     wszNameBuff[MAX_GUID_STRING];    
  247.     
  248. static char *szDbcolkind[] = { "Guid+Name", "Guid+PropID", "Name", 
  249.     "Guid+Name", "Guid+PropID", "PropID", "Guid" };
  251. assert(p != NULL);
  253. // For DBTYPEENUM.  Doesn't need to be in order.
  254. // Below we mask off the high bits.
  255. static Note typenotes[] = 
  256.     {
  257. NOTE(DBTYPE_EMPTY),
  258. NOTE(DBTYPE_NULL),
  259. NOTE(DBTYPE_I2),
  260. NOTE(DBTYPE_I4),
  261. NOTE(DBTYPE_R4),
  262. NOTE(DBTYPE_R8),
  263. NOTE(DBTYPE_CY),
  264. NOTE(DBTYPE_DATE),
  265. NOTE(DBTYPE_BSTR),
  266. NOTE(DBTYPE_IDISPATCH),
  267. NOTE(DBTYPE_ERROR),
  268. NOTE(DBTYPE_BOOL),
  269. NOTE(DBTYPE_VARIANT),
  270. NOTE(DBTYPE_IUNKNOWN),
  271. NOTE(DBTYPE_DECIMAL),
  272. NOTE(DBTYPE_UI1),
  273. NOTE(DBTYPE_ARRAY),
  274. NOTE(DBTYPE_BYREF),
  275. NOTE(DBTYPE_I1),
  276. NOTE(DBTYPE_UI2),
  277. NOTE(DBTYPE_UI4),
  278. NOTE(DBTYPE_I8),
  279. NOTE(DBTYPE_UI8),
  280. NOTE(DBTYPE_GUID),
  281. NOTE(DBTYPE_VECTOR),
  282. NOTE(DBTYPE_RESERVED),
  283. NOTE(DBTYPE_BYTES),
  284. NOTE(DBTYPE_STR),
  285. NOTE(DBTYPE_WSTR),
  286. NOTE(DBTYPE_NUMERIC),
  287. NOTE(DBTYPE_UDT),
  288. NOTE(DBTYPE_DBDATE),
  289. NOTE(DBTYPE_DBTIME),
  290. NOTE(DBTYPE_DBTIMESTAMP),
  291.     };
  293. static Note flagnotes[] = 
  294.     {
  295. NOTE(DBCOLUMNFLAGS_ISBOOKMARK),
  296. NOTE(DBCOLUMNFLAGS_MAYDEFER),
  297. NOTE(DBCOLUMNFLAGS_WRITE),
  298. NOTE(DBCOLUMNFLAGS_WRITEUNKNOWN),
  299. NOTE(DBCOLUMNFLAGS_ISFIXEDLENGTH),
  300. NOTE(DBCOLUMNFLAGS_ISNULLABLE),
  301. NOTE(DBCOLUMNFLAGS_MAYBENULL),
  302. NOTE(DBCOLUMNFLAGS_ISLONG),
  303. NOTE(DBCOLUMNFLAGS_ISROWID),
  304. NOTE(DBCOLUMNFLAGS_ISROWVER),
  305. NOTE(DBCOLUMNFLAGS_CACHEDEFERRED),
  306. };
  308. pCol = & p->columnid;
  309.     eKind = pCol->eKind;
  311.     // stringize GUID for pretty printing
  312.     switch (eKind)
  313.         {
  314.         case DBKIND_GUID_NAME:
  315.         case DBKIND_GUID_PROPID:
  316.         case DBKIND_GUID:
  317.         StringFromGUID2( pCol->uGuid.guid, wszGuidBuff, sizeof(wszGuidBuff) );
  318.             break;
  319.         case DBKIND_PGUID_NAME:
  320.         case DBKIND_PGUID_PROPID:          
  321.         StringFromGUID2( *(pCol->uGuid.pguid), wszGuidBuff, sizeof(wszGuidBuff) );
  322.             break;
  323.         default:
  324.             wcscpy( wszGuidBuff, L"<none>" );
  325.             break;    
  326.         }
  327.         
  328.     // stringize name or propID for pretty printing   
  329.     switch (eKind)
  330.         {
  331.         case DBKIND_GUID_NAME:
  332.         case DBKIND_NAME:
  333.         case DBKIND_PGUID_NAME:
  334.             swprintf( wszNameBuff, L"[name=%.50S]", pCol->uName.pwszName ? pCol->uName.pwszName : L"(unknown)" );
  335.             break;
  336.         case DBKIND_GUID_PROPID:
  337.         case DBKIND_PGUID_PROPID:
  338.         case DBKIND_PROPID:
  339.             swprintf( wszNameBuff, L"[propid=%lu]", pCol->uName.ulPropid );
  340.             break;
  341.         default:
  342.             wcscpy( wszNameBuff, L"" );
  343.             break;    
  344.         }   
  346.     // pretty print column info
  347.     tfprintf( fp, "ColumnId [kind=%.40s] [guid=%.40S] %.60Sn", 
  348.         szDbcolkind[eKind], wszGuidBuff, wszNameBuff );
  349.         
  351. // Now move on to other stuff...
  352. // Name in DBCOLUMNINFO different than name in DBCOLUMNID (maybe).
  353. tfprintf(fp, "  Name          = '%.50S'n", p->pwszName );
  354. tfprintf(fp, "  iOrdinal      = %dn", p->iOrdinal);
  355. tfprintf(fp, "  wType         = %.100sn", 
  356. GetNoteString( typenotes, NUMELEM(typenotes),
  357.     p->wType & (~DBTYPE_BYREF) & (~DBTYPE_ARRAY) & (~DBTYPE_VECTOR) ) );
  358. if (p->wType & DBTYPE_BYREF)
  359. tfprintf(fp, "      (BYREF)n");
  360. if (p->wType & DBTYPE_ARRAY)
  361. tfprintf(fp, "      (ARRAY)n");
  362. if (p->wType & DBTYPE_VECTOR)
  363. tfprintf(fp, "      (VECTOR)n");
  364. tfprintf(fp, "  ulColumnSize  = %ldn", p->ulColumnSize );
  365. tfprintf(fp, "  bPrecision    = %dn",  p->bPrecision );
  366. tfprintf(fp, "  bScale        = %dn",  p->bScale );
  367. tfprintf(fp, "  dwFlags       = %snn",
  368. GetNoteStringBitvals( flagnotes, NUMELEM(flagnotes), p->dwFlags ) );
  371. }
  374. char* GetNoteString
  375.     ( 
  376. Note * rgNote, 
  377. int    cNote,
  378. DWORD  dwValue 
  379. )
  380. {
  381. int j;
  383. assert(rgNote != NULL);
  385. // Scan a table of value/string,
  386. // return ptr to string found.
  388. for (j=0; j < cNote; j++) {
  389. if (rgNote[j].dwFlag == dwValue)
  390. return rgNote[j].szText;
  391. }
  392. return "<unknown>";
  393. }
  401. char* GetNoteStringBitvals
  402. (
  403. Note*  rgNote,
  404. int     cNote,
  405. DWORD   dwValue 
  406. )
  407. {
  408. static char buff[400];
  409. int j;
  411. assert(rgNote != NULL);
  413. // Make a string that combines all the bits ORed together.
  415. strcpy(buff, "");
  416. for (j=0; j < cNote; j++) {
  417. if (rgNote[j].dwFlag & dwValue) {
  418. if (buff[0])
  419. strcat( buff, " | " );
  420. strcat( buff, rgNote[j].szText );
  421. }
  422. }
  423. assert(strlen(buff) < sizeof(buff));
  424. return buff;
  425. }
  430. ULONG CalcPrettyPrintMaxColWidth
  431.     (
  432.     DBBINDING* rgBind,
  433.     ULONG       cBind
  434.     )
  435. {
  436. ULONG cMaxWidth;
  437.     ULONG   cTotalWidth;
  438.     ULONG iBind;
  440. assert(rgBind != NULL);
  442. cMaxWidth = DEFAULT_CBMAXLENGTH;
  443. while (1)
  444. {
  445. cTotalWidth = 0;
  447. for (iBind=0; iBind < cBind; iBind++)
  448. cTotalWidth += min( cMaxWidth, rgBind[iBind].cbMaxLen ) + 1;
  450. if (cTotalWidth < PRETTYPRINT_MAXTOTALWIDTH || cMaxWidth < PRETTYPRINT_MINCOLWIDTH)
  451. break;
  453. cMaxWidth--;
  454. }
  456. return cMaxWidth;
  457. }
  461. void DumpColumnHeadings
  462. (
  463. DBBINDING* rgBind, 
  464. ULONG cBind, 
  465. DBCOLUMNINFO*  pColInfo, 
  466. ULONG cCol,
  467.     ULONG cMaxColWidth
  468. )
  469. {
  470. ULONG iBind;
  472. assert(rgBind != NULL);
  473.     assert(pColInfo != NULL);
  474.  
  475. for (iBind=0; iBind < cBind; iBind++)
  476. tfprintf( g_fpLogFile, "%-*.*S ",
  477. min( cMaxColWidth, rgBind[iBind].cbMaxLen ),
  478. min( cMaxColWidth, rgBind[iBind].cbMaxLen ),
  479. LookupColumnName( pColInfo, cCol, rgBind[iBind].iOrdinal ) );
  480. tfprintf( g_fpLogFile, "n" );
  481. for (iBind=0; iBind < cBind; iBind++)
  482. tfprintf( g_fpLogFile, "%-*.*s ",
  483. min( cMaxColWidth, rgBind[iBind].cbMaxLen ),
  484. min( cMaxColWidth, rgBind[iBind].cbMaxLen ),
  485. "------------------------------" );
  486. tfprintf( g_fpLogFile, "n" );
  487. }
  491. WCHAR* LookupColumnName
  492. (
  493. DBCOLUMNINFO* rgColInfo,
  494. ULONG  cCol,
  495. ULONG  iCol 
  496. )
  497. {
  498. ULONG j;
  500. assert(rgColInfo != NULL);
  502. // A really slow way to get the column name, given the ordinal.
  503. // The problem is that result-set ordinals do not necessarily match
  504. // the index into the ColumnInfo array.
  505. // (May have bookmark, which is always column 0.)
  507. for (j=0; j < cCol; j++)
  508. if (rgColInfo[j].iOrdinal == iCol)
  509. return rgColInfo[j].pwszName;
  510.             
  511. return L"Error";
  512. }
  517. void DumpRow
  518. (
  519.     DBBINDING*  rgBind,
  520.     ULONG cBind,
  521.     ULONG cMaxColWidth,
  522.     BYTE*  pData
  523.     )
  524. {
  525. ULONG  iBind;
  526.     COLUMNDATA* pColumn;
  527.     
  528. assert(rgBind);
  529. assert( offsetof(COLUMNDATA, dwLength) == 0);
  530.     
  531. // Print each column we're bound to.
  532. for (iBind=0; iBind < cBind; iBind++)
  533. {
  534. // Columns are bound differently; not so easy.
  535. // Print out to at least DEFAULT_CBMAXLENGTH width (pretty),
  536. // Limit to first dwLength characters.
  538. pColumn = (COLUMNDATA *) (pData + rgBind[iBind].obLength);
  539. PrintColumn( pColumn, rgBind, iBind, cMaxColWidth );
  540. }
  541. tfprintf( g_fpLogFile, "n" );
  542. }    
  548. void PrintColumn
  549. (
  550. COLUMNDATA    *pColumn,
  551. DBBINDING     *rgBind,
  552. ULONG          iBind,
  553. ULONG          cMaxColWidth 
  554. )
  555. {
  556. void* p;
  557. ULONG   ulPrintWidth;
  558. ULONG   ulPrintPrecision;
  559. DWORD   dwStatus;
  560. DWORD   dwLength;
  561. BOOL    fDidVariant;
  562. BOOL    fIsUnicode;
  563. char* sFormat;
  564. HRESULT hr;
  566.     assert(pColumn != NULL);
  567.     assert(rgBind != NULL);
  568.     
  569. // Pretty print a column.
  570. // May have different type of binding.
  572. fDidVariant = FALSE;
  573. fIsUnicode  = FALSE;
  574. dwStatus = pColumn->dwStatus;
  575. dwLength = pColumn->dwLength;
  577. if (dwStatus == DBSTATUS_S_ISNULL)
  578. {
  579. p = "<null>";
  580. dwLength = strlen( (char *) p);
  581. }
  582.     else if (dwStatus == DBBINDSTATUS_UNSUPPORTEDCONVERSION)
  583.         {
  584.         p = "<unsupportedconversion>";
  585. dwLength = strlen( (char *) p);
  586.         }    
  587. else
  588. {
  589. switch (rgBind[iBind].wType) 
  590. {
  591. case DBTYPE_STR:
  592. // We have a string in our buffer, so use it.
  593. p = (void *) &pColumn->bData;
  594. break;
  595. case DBTYPE_VARIANT:
  596. // We have a variant in our buffer, so convert to string.
  597. p = (void *) &pColumn->bData;
  598. hr = VariantChangeTypeEx(
  599. (VARIANT *) p, // Destination (convert in place)
  600. (VARIANT *) p, // Source
  601. LOCALE_SYSTEM_DEFAULT, // LCID
  602. 0, // dwFlags
  603. VT_BSTR );
  604. if (FAILED(hr))
  605.              {
  606. DumpErrorHResult( hr, "VariantChangeTypeEx, field %d", iBind );
  607.                 return;
  608.                 }
  609. p = (wchar_t *) (((VARIANT *)p)->bstrVal) ;
  610. dwLength = ((DWORD *)p)[-1] / sizeof(wchar_t);
  611. fDidVariant = TRUE;
  612. fIsUnicode  = TRUE;
  613. break;
  614. default:
  615. p = "??? unknown type ???";
  616. break;
  617. }
  618. }
  620. // Print the column.
  621. // If it has been truncated or rounded, print a '#' in
  622. // the far right-hand column.
  623. ulPrintWidth     = min( cMaxColWidth, rgBind[iBind].cbMaxLen );
  624. ulPrintPrecision = min( cMaxColWidth, dwLength );
  625. if (dwStatus == DBSTATUS_S_TRUNCATED ||  cMaxColWidth < dwLength)
  626. {
  627. ulPrintWidth--;
  628. ulPrintPrecision--;
  629. }
  631. sFormat = fIsUnicode ? "%-*.*S" : "%-*.*s";
  633. tfprintf( g_fpLogFile, sFormat, ulPrintWidth, ulPrintPrecision, p );
  635. if (dwStatus == DBSTATUS_S_TRUNCATED ||  cMaxColWidth < dwLength)
  636. tfprintf( g_fpLogFile, "#" );
  637. tfprintf( g_fpLogFile, " " );
  639. // Free memory used by the variant.
  640. if (fDidVariant)
  641. VariantClear( (VARIANT *) &pColumn->bData );
  642.         
  643. return;
  644. }
  649. void tfprintf
  650. (
  651. FILE* fp,
  652. const char* format,
  653. ... 
  654. )
  655. {
  656. int  cBytesWritten;
  657. char  buff[400];
  658. va_list argptr;
  660. assert(format != NULL);
  662. // Dump a formatted string.
  663.     // _vsnprintf prevents overflowing our buffer.
  664. va_start( argptr, format );
  665. cBytesWritten = _vsnprintf( buff, sizeof(buff), format, argptr );
  666. va_end( argptr );
  667. buff[sizeof(buff)-1] = '';
  669. // Can't use fprintf, because string could contain '%'.
  670. if (fp)
  671. fputs( buff, fp );
  672. }
  676. void tvfprintf
  677. (
  678. FILE* fp,
  679. const char* format,
  680. va_list argptr 
  681. )
  682. {
  683. int  cBytesWritten;
  684. char  buff[400];
  687. assert(format != NULL);
  689. // Dump a formatted string.
  690.     // _vsnprintf prevents overflowing our buffer.
  691. cBytesWritten = _vsnprintf( buff, sizeof(buff), format, argptr );
  692. buff[sizeof(buff)-1] = '';
  694. // Can't use fprintf, because string could contain '%'.
  695. if (fp)
  696. fputs( buff, fp );
  697. }