wince串口打印函数是如何实现的？（作者wogoyixikexie@gliet）

     通常我们在BSP下一般使用RETAILMSG这个函数来实现串口打印，某些驱动也用DEBUGMSG。 在OAL又是另外一些串口打印函数。我们很早就知道这是OAL之下的debug.c的串口函数实现的，但是具体是怎么实现的，我从来没有去看过。今天碰到在串口MDD层无法使用串口打印的情况，搞得我很郁闷。就下决心找出来到底是怎么回事。

     C:\WINCE500\PUBLIC\COMMON\SDK\INC中的dbgapi.h实现了RETAILMSG和DEBUGMSG，下面来看看到底是怎么回事。

 

Module Name: dbgapi.h

Purpose: Debug Message and Zone APIs.

--*/
#ifndef __DBGAPI_H__
#define __DBGAPI_H__

#ifdef __cplusplus
extern "C" {
#endif
    
void WINAPIV NKDbgPrintfW(LPCWSTR lpszFmt, );
void WINAPI WriteDebugLED(WORD wIndex, DWORD dwPattern);


/*
@doc    EXTERNAL    KERNEL
@struct DBGPARAM | Debug zone information structure
@comm   The name of the module is used to look for zone initialization
        information in the host PC registry. Zone names are displayed by
        the control app (eg shell) which allows the user to dynamically
        set zones.
@xref   <f DEBUGREGISTER>
*/
typedef struct _DBGPARAM {
    WCHAR    lpszName[32];           // @field Name of module
    WCHAR   rglpszZones[16][32];    // @field names of zones for first 16 bits
    ULONG   ulZoneMask;             // @field Current zone Mask
} DBGPARAM, *LPDBGPARAM;

BOOL RegisterDbgZones(HMODULE hMod, LPDBGPARAM lpdbgparam);


/*
@func   BOOL | DEBUGZONE | Associates a mask bit with a zone
@parm   int | bitnum | Bitnumber being defined
@rdesc  A boolean which is TRUE if bitnum in '1' else is FALSE
@ex     Example of use is |
        // associate bit 0 with an info zone
        #define ZONE_INFO   DEBUGZONE(0)
        // we can now use ZONE_INFO as a boolean for anything.
        // We'd typically use it in a DEBUGMSG 
*/
#define DEBUGZONE(n)  (dpCurSettings.ulZoneMask&(0x00000001<<(n)))

#ifdef DEBUG
#ifdef SHIP_BUILD
#undef SHIP_BUILD
#pragma message (__FILE__ ":WARNING: SHIP_BUILD turned off since DEBUG defined")
#endif
#endif

#ifdef SHIP_BUILD //如果定义了SHIP_BUILD 那么以下串口打印函数就不会打印了。这个貌似可以使用环境变量设定。

#define ERRORMSG(cond,printf_exp) ((void)0)
#define RETAILMSG(cond,printf_exp) ((void)0)
#define DEBUGMSG(cond,printf_exp) ((void)0)
#define DEBUGLED(cond,parms) ((void)0)
#define DBGCHK(module,exp) ((void)0)
#define DEBUGCHK(exp) ((void)0)
#define DEBUGREGISTER(hMod) ((void)0)
#define RETAILREGISTERZONES(hMod) ((void)0)

#else // SHIP_BUILD

#ifdef DEBUG //debug模式NK

/*
@func BOOL | DEBUGMSG | Output a debug message conditionally
@parm BOOL | cond | The condition under which the message is printed
@parm <null> | (printf_exp) | A printf style expression to be output. Must be enclosed
      in parentheses. Gets passed on to the <f NKDbgPrintf> function.
@ex   Example of use |
      DEBUGMSG(ZONE_INFO, (L"DLLNAME: Entered func1. Param 1 = %d\r\n", par1));
@xref <f RETAILMSG> <tab> <f ERRORMSG> <tab> <f NKDbgPrintf>
*/
#define DEBUGMSG(cond,printf_exp)   \
   ((void)((cond)?(NKDbgPrintfW printf_exp),1:0)) //DEBUGMSG是通过NKDbgPrintfW 来实现的
#define DBGCHK(module,exp) \
   ((void)((exp)?1:(          \
       NKDbgPrintfW ( TEXT("%s: DEBUGCHK failed in file %s at line %d \r\n"), \
                 (LPWSTR)module, TEXT(__FILE__) ,__LINE__ ),    \
       DebugBreak(), \
       0  \
   )))

/*
@func BOOL | DEBUGLED | Output a debug LED pattern conditionally
@parm BOOL | cond | The condition under which the message is printed
@parm <null> | (parms) | The parameters to be passed to the WriteDebugLED
      function.  Must be in parentheses.  First parameter is wIndex and second
      parameter is dwPattern.
@ex   Example of use |
      DEBUGLED(ZONE_INFO, (3, 0x2345);
@xref <f RETAILMSG> <tab> <f ERRORMSG> <tab> <f WriteDebugLED>
*/
#define DEBUGLED(cond,parms)   \
   ((void)((cond)?(WriteDebugLED parms),1:0))    


/*
@func BOOL | DEBUGCHK | Asserts an expression
@parm BOOL | exp | Expression to be asserted
@comm If the expression is false, this will cause a DebugBreak to be hit which
      will cause you to enter the debugger if you are running with one. It will
      also give you the line number and file name where the assert failed.
*/
#define DEBUGCHK(exp) DBGCHK(dpCurSettings.lpszName, exp)
extern  DBGPARAM    dpCurSettings;
/*
@func  BOOL | DEBUGREGISTER | Registers debug settings for a process / module
@parm  HINSTANCE | hInstance | If target is a module this is it's hInstance. If
       target is a process this should be NULL.
@comm  This simply calls through to <f RegisterDebugZones>. It assumes that
       there is a variable of name <b dpCurSettings> visible in the code.
*/
#define DEBUGREGISTER(hMod)  RegisterDbgZones(hMod, &dpCurSettings)
#else // DEBUG 如果没有定义，就不会打印。

#define DEBUGMSG(cond,printf_exp) ((void)0)
#define DEBUGLED(cond,parms) ((void)0)
#define DBGCHK(module,exp) ((void)0)
#define DEBUGCHK(exp) ((void)0)
#define DEBUGREGISTER(hMod) ((void)0)

#endif // DEBUG

/*
@func BOOL | RETAILMSG | Output a message in retail builds
@parm BOOL | cond | The condition under which the message is printed
@parm <null> | (printf_exp) | A printf style expression to be output. Must be enclosed
      in parentheses. This is simply passed in to the <f NKDbgPrintf> function.
@comm This should be used in a very limited fashion since it can increase
      the size of your retail build.
@ex   Example of use |
      RETAILMSG(x==y, (L"DLLNAME: Expect. x==y = %d\r\n", x));
@xref <f DEBUGMSG> <tab> <f ERRORMSG> <tab> <f NKDbgPrintf>
*/
#define RETAILMSG(cond,printf_exp)\//从这里可以知道，RETAILMSG、DEBUGMSG一模一样，只是换了名字，通过NKDbgPrintfW来实现的
  ((cond)?(NKDbgPrintfW printf_exp),1:0)

/*
@func BOOL | ERRORMSG | Output an error msg
@parm BOOL | cond | The condition under which the message is printed
@parm <null> | (printf_exp) | A printf style expression to be output. Must be enclosed
      in parentheses. This is passed in to the <f NKDbgPrintf> function.
@comm Very similar to <f RETAILMSG> except that this will prefix the message
      with "ERROR" and give the file name & line number of the error.
@ex   Example of use |
      ERRORMSG(x==y, (L"DLLNAME: x===y = %d\r\n", x));
@xref <f DEBUGMSG> <tab> <f RETAILMSG> <tab> <f NKDbgPrintf>
*/
#define ERRORMSG(cond,printf_exp)     \
   ((cond)?(NKDbgPrintfW(TEXT("ERROR: %s line %d: "),TEXT(__FILE__),__LINE__), NKDbgPrintfW printf_exp),1:0)

/*
@func  BOOL | RETAILREGISTERZONES | Registers zone settings for a process / module
       (Same as DEBUGREGISTER except available in retail and debug builds)
@parm  HINSTANCE | hInstance | If target is a module this is it's hInstance. If
       target is a process this should be NULL.
@comm  This simply calls through to <f RegisterDebugZones>. It assumes that
       there is a variable of name <b dpCurSettings> visible in the code.
*/
#define RETAILREGISTERZONES(hMod)  RegisterDbgZones(hMod, &dpCurSettings)

#endif // SHIP_BUILD

/*
@func BOOL | RETAILLED | Output a LED code in retail builds
@parm BOOL | cond | The condition under which the message is printed
@parm <null> | (parms) | The parameters to be passed to the WriteDebugLED
      function.  Must be in parentheses.  First parameter is wIndex and second
      parameter is dwPattern.
@comm This should be used in a very limited fashion since it can increase
      the size of your retail build.
@ex   Example of use |
      RETAILLED(ZONE_INFO, (3, 0x2345);
@xref <f DEBUGMSG> <tab> <f ERRORMSG> <tab> <f WriteDebugLED>
*/
#define RETAILLED(cond,parms) \
   ((void)((cond)?(WriteDebugLED parms),1:0))    

// some alternate ways to get to these
#define ASSERTMSG(msg, exp) (DEBUGMSG(!exp,(msg)),DBGCHK(TEXT("Unknown"),exp))
#define ASSERT( exp )   DBGCHK(TEXT("Unknown"), exp)
#define ASSERT_IMPLIES( cond, exp ) ASSERT( !(cond) || (exp) )
#ifdef DEBUG
#define VERIFY(exp)  ASSERT(exp)
#else
#define VERIFY(exp)  ((void)(exp))
#endif

// Enable providing a hint to prefast via __assume
// e.g.
//   PREFAST_ASSUME( pPointer); // we know pPointer can never be NULL
#ifdef _PREFAST_
#define PREFAST_ASSUME(exp) __assume(exp)
#else
#define PREFAST_ASSUME(exp)
#endif

// Simplify the cases where a PREFAST_ASSUME would be followed by an assertion
#define PREFAST_DEBUGCHK(exp) \
    { \
        PREFAST_ASSUME(exp); \
        DEBUGCHK(exp); \
    }

#define PREFAST_ASSERT(exp) \
    { \
        PREFAST_ASSUME(exp); \
        ASSERT(exp); \
    }

// macro to tell Prefast to not issue a specific warning for the following line of code
// use to suppress false positives from Prefast
// e.g.
// if( fPointerNotNull )
//    PREFAST_SUPPRESS( 11, "pointer access is guarded by 'fPointerNotNull'" )
//    p->Foo();
#ifdef _PREFAST_
#define PREFAST_SUPPRESS( cWarning, comment) __pragma ( prefast(suppress: cWarning, comment) )
#else
#define PREFAST_SUPPRESS( cWarning, comment)
#endif

// Helpful DBG macros that tighten up code.
// They prepend __FUNCTION__ to your debug msg and add a \n to the end.

#define DEB_0(ZONE,STR) DEBUGMSG(ZONE,(L"%S:"STR L"\n",__FUNCTION__))
#define DEB_1(ZONE,STR,ARG1) DEBUGMSG(ZONE,(L"%S:"STR L"\n",__FUNCTION__,ARG1))
#define DEB_2(ZONE,STR,ARG1,ARG2) DEBUGMSG(ZONE,(L"%S:"STR L"\n",__FUNCTION__,ARG1,ARG2))
#define DEB_3(ZONE,STR,ARG1,ARG2,ARG3) DEBUGMSG(ZONE,(L"%S:"STR L"\n",__FUNCTION__,ARG1,ARG2,ARG3))
#define DEB_4(ZONE,STR,ARG1,ARG2,ARG3,ARG4) DEBUGMSG(ZONE,(L"%S:"STR L"\n",__FUNCTION__,ARG1,ARG2,ARG3,ARG4))
#define DEB_5(ZONE,STR,ARG1,ARG2,ARG3,ARG4,ARG5) DEBUGMSG(ZONE,(L"%S:"STR L"\n",__FUNCTION__,ARG1,ARG2,ARG3,ARG4,ARG5))

// 
//  The _A version of the above are identical, except they call assert  after the  DEB_*.  
//  It's highly recommend that you use DEB_*_A with ZONE_ERROR so the user can always see the error.
//  printed with the assert.
//  NOTE: The assert is not conditioned on the ZONE. 

#define DEB_0_A(ZONE,STR) { DEB_0(ZONE,STR);ASSERT(FALSE); }
#define DEB_1_A(ZONE,STR,ARG1) { DEB_1(ZONE,STR,ARG1); ASSERT(FALSE);}
#define DEB_2_A(ZONE,STR,ARG1,ARG2) { DEB_2(ZONE,STR,ARG1,ARG2); ASSERT(FALSE);}
#define DEB_3_A(ZONE,STR,ARG1,ARG2,ARG3) { DEB_3(ZONE,STR,ARG1,ARG2,ARG3); ASSERT(FALSE);}
#define DEB_4_A(ZONE,STR,ARG1,ARG2,ARG3,ARG4) {  DEB_4(ZONE,STR,ARG1,ARG2,ARG3,ARG4); ASSERT(FALSE);}
#define DEB_5_A(ZONE,STR,ARG1,ARG2,ARG3,ARG4,ARG5) {DEB_5(ZONE,STR,ARG1,ARG2,ARG3,ARG4,ARG5); ASSERT(FALSE);}


#ifdef __cplusplus
}
#endif
    
#endif

 

     从上面可以知道，RETAILMSG、DEBUGMSG一模一样，只是换了名字，通过NKDbgPrintfW来实现的，那么这个NKDbgPrintfW又是怎么来的呢？

  1//
  2// Copyright (c) Microsoft Corporation.  All rights reserved.
  3//
  4//
  5// This source code is licensed under Microsoft Shared Source License
  6// Version 1.0 for Windows CE.
  7// For a copy of the license visit http://go.microsoft.com/fwlink/?LinkId=3223.
  8//
  9/**//*
 10 *              NK Kernel printf code
 11 *
 12 *
 13 * Module Name:
 14 *
 15 *              printf.c
 16 *
 17 * Abstract:
 18 *
 19 *              This file implements debug and string routines
 20 *
 21 */
 22 
 23/**//*
 24@doc    EXTERNAL KERNEL
 25@topic  Debug Support for Applications | 
 26    The kernel provides several kinds of supports for debugging
 27    applications. These are:
 28    
 29    <b Debug Messages>: The kernel provides API's for printing out
 30    of debug messages which can be turned on and off dynamically 
 31    using zones. Any module (DLL/Process) can register itself
 32    with the debug subsystem using <f DEBUGREGISTER>. This API
 33    registers the address of a Zonemask (which is a DWORD) with the
 34    kernel. Using the debug shell, a user can now dynamically turn
 35    bits of this zonemask on and off from the shell window.        
 36    The most typical way to use this is to filter debug messages
 37    based on these bits. A structured way to do this is to use
 38    the <f DEBUGZONE> macro to associate zones with bits, and then
 39    use the <f DEBUGMSG> function to associate each debug message
 40    with a zone. Type ? in the shell to see how to change zones 
 41    dynamically from the shell which uses the <f SetDbgZone> function
 42    to implement the change. See the example below for general zone
 43    usage.
 44    
 45    <b Asserts>: The kernel also provides for simple asserts. See
 46    <f DEBUGCHK> for details.
 47    
 48@ex     An example of using debug zones |
 49    // Declare a DBGPARAM structure & give names to all used zones
 50    DBGPARAM dpCurSettings = { L"foodll", {
 51        L"Info",       L"Validate",  L"bar",       L"random",
 52        L"Undefined",  L"Undefined", L"Undefined", L"Undefined",
 53        L"Undefined",  L"Undefined", L"Undefined", L"Undefined",
 54        L"Undefined",  L"Undefined", L"Undefined", L"Undefined" },
 55        0x00000000 };
 56        
 57    // Associate bits with a zone 
 58    // these should match up with the text strings above!
 59    #define ZONE_INFO       DEBUGZONE(0)
 60    #define ZONE_VALIDATE   DEBUGZONE(1)
 61
 62    // Register : Assume this is a DLL 
 63    // A Process would do the same in their libmain
 64    BOOL DllEntry (HANDLE hinstDLL, DWORD fdwReason, LPVOID lpv) {
 65        if ( fdwReason == DLL_PROCESS_ATTACH ) {
 66        DEBUGREGISTER(hinstDLL);
 67        }
 68        
 69    }
 70
 71    // Use the defined zone in debug messages
 72    DEBUGMSG (ZONE_INFO, (L"This is an illustrative messages only!"));
 73
 74    // Or use a zone to turn execution of some code on & off
 75    if (ZONE_VALIDATE) {
 76        // validate some stuff 
 77    }            
 78            
 79@xref   
 80    <f DEBUGMSG> <tab> <f RETAILMSG> <tab> <f ERRORMSG> <tab> <f DEBUGCHK> <tab>
 81    <f DEBUGREGISTER> <tab> <f DEBUGZONE> <tab> <t DBGPARAM> <tab>
 82    <f RegisterDebugZones> <tab> <f SetDbgZone>
 83*/ 
 84
 85#include "kernel.h"
 86
 87#define out(c) if (--cchLimit) *lpOut++=(c); else goto errorout
 88
 89//-------------------------- Prototype declarations ---------------------------
 90
 91int NKwvsprintfW(LPWSTR lpOut, LPCWSTR lpFmt, CONST VOID * lpParms, int maxchars);
 92LPCWSTR SP_GetFmtValue(LPCWSTR lpch, int  *lpw, va_list *plpParms);
 93int SP_PutNumber(LPWSTR, ULONG, int, int, int);
 94int SP_PutNumber64(LPWSTR lpb, __int64 i64, int limit, int radix, int mycase);
 95void SP_Reverse(LPWSTR lp1, LPWSTR lp2);
 96
 97extern CRITICAL_SECTION ODScs, DbgApiCS, VAcs, PhysCS;
 98
 99extern BOOL fSysStarted;
extern BOOL g_cInterruptsOff;    // this indicates KD had turned interrupts off


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
VOID WINAPI 
OutputDebugStringW(
    LPCWSTR str
    ) 
{
    BOOL fGetODScs = FALSE, fLockPages = FALSE;
    int len;

    // if we ever call OutputDebugString with interrupts off, send it to serial
    // port and return right away
    if (g_cInterruptsOff) {
        OEMWriteDebugString((unsigned short *)str);
        return;
    }

    // increase debug count to indicate we're in ODS
    if (!str)
        str = __TEXT("(NULL)");

    if (pCurThread) {

        pCurThread->bDbgCnt ++;

        // do not notify debugger while in power handler because we cannot block
        if (!InSysCall () && !IsInPwrHdlr ()) {
        
            if (pCurThread->pThrdDbg && (DbgApiCS.OwnerThread != hCurThread)  
                && ProcStarted(pCurProc) && pCurThread->pThrdDbg->hEvent) {
                pCurThread->pThrdDbg->dbginfo.dwDebugEventCode = OUTPUT_DEBUG_STRING_EVENT;
                pCurThread->pThrdDbg->dbginfo.dwProcessId = (DWORD)hCurProc;
                pCurThread->pThrdDbg->dbginfo.dwThreadId = (DWORD)hCurThread;
                pCurThread->pThrdDbg->dbginfo.u.DebugString.lpDebugStringData = (LPBYTE)str;
                pCurThread->pThrdDbg->dbginfo.u.DebugString.fUnicode = TRUE;
                pCurThread->pThrdDbg->dbginfo.u.DebugString.nDebugStringLength = (strlenW(str)+1)*2;
                SetEvent(pCurThread->pThrdDbg->hEvent);
                SC_WaitForMultiple(1,&pCurThread->pThrdDbg->hBlockEvent,FALSE,INFINITE);
            }
            
            fGetODScs = !ReadyForStrings && (hCurThread != ODScs.OwnerThread);
            fLockPages = (1 == pCurThread->bDbgCnt);

        }
    }
    
    // forces the string to be paged in if not already
    len = (strlenW(str)+1)*sizeof(WCHAR);

    // Lock page if we need to
    if (fLockPages)
        LockPages((LPVOID)str,len,0,0);

    if (fGetODScs)
        EnterCriticalSection(&ODScs);

    lpWriteDebugStringFunc((unsigned short *)str);

    if (fGetODScs)
        LeaveCriticalSection(&ODScs);

    if (fLockPages)
        UnlockPages((LPVOID)str,len);

    // decrement debug count to indicate we're out of ODS
    if (pCurThread) {
        pCurThread->bDbgCnt --;
    }
}



//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
int 
InputDebugCharW(void) 
{
    int retvalue;
    if (!InSysCall())
        EnterCriticalSection(&ODScs);
    retvalue = OEMReadDebugByte();
    if (!InSysCall())
        LeaveCriticalSection(&ODScs);
    return retvalue;
}

//------------------------------------------------------------------------------
// special version if we're on KStack
//------------------------------------------------------------------------------
static VOID _NKvDbgPrintfW(LPCWSTR lpszFmt, va_list lpParms) {
    static WCHAR rgchBuf[384];
    NKwvsprintfW(rgchBuf, lpszFmt, lpParms, sizeof(rgchBuf)/sizeof(WCHAR));
    OutputDebugStringW(rgchBuf);
}

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
#if (_MSC_VER >= 1300)
__declspec(noinline) // Too much KStack is used if this is inlined
#endif
static VOID NKvDbgPrintfWOnStack(LPCWSTR lpszFmt, va_list lpParms) 
{
    WCHAR rgchBuf[384];
    WORD wLen = 0;
    // Get it into a string
#ifdef DEBUG
    if (ZONE_DEBUG) {
        rgchBuf[0] = '0';
        rgchBuf[1] = 'x';
        wLen += 2;
        wLen += SP_PutNumber(rgchBuf+2,(ULONG)pCurThread,8,16,0);
        SP_Reverse(rgchBuf+2,rgchBuf+wLen-1);
        rgchBuf[wLen++] = ':';
        rgchBuf[wLen++] = ' ';
    }
#endif
    wLen += NKwvsprintfW(rgchBuf + wLen, lpszFmt, lpParms, sizeof(rgchBuf)/sizeof(WCHAR) - wLen);

    // don't need to call LockPages since it's on stack.
    if (pCurThread) {
        pCurThread->bDbgCnt ++;
    }
    OutputDebugStringW(rgchBuf);
    if (pCurThread) {
        pCurThread->bDbgCnt --;
    }
}


//------------------------------------------------------------------------------
//
//  @doc    EXTERNAL KERNEL
//  @func   VOID | NKDbgPrintf | Prints debug messages
//  @parm   LPWSTR | lpszFmt | Printf style formatting string
//  @parmvar Variable argument list
//  @comm   Should not be used directly - macros like <f DEBUGMSG> should
//      be used to print messages. This function will format the
//      debug string into a buffer and then log it according to the
//      current logging paramters. If terminal logging is on it
//      outputs this to the debug terminal, and if file logging
//      is on it stores it to the file peg.log on the host PC.
//      
//      <b WARNING>: The message being output must be smaller than
//      256 bytes - ie 128 unicode characters.
//  @xref   <f DEBUGMSG>
//
//------------------------------------------------------------------------------
void WINAPIV 
NKDbgPrintfW(
    LPCWSTR lpszFmt,
    
    )  
{
    va_list arglist;
    va_start(arglist, lpszFmt);
    NKvDbgPrintfW(lpszFmt, arglist);
    va_end(arglist);
}

VOID NKvDbgPrintfW (LPCWSTR lpszFmt, va_list lpParms) 
{
    if (fSysStarted && !InSysCall ())        
        NKvDbgPrintfWOnStack (lpszFmt, lpParms);
    else
        _NKvDbgPrintfW(lpszFmt, lpParms);
}


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
int 
NKwvsprintfW(
    LPWSTR lpOut,
    LPCWSTR lpFmt,
    va_list lpParms,
    int maxchars
    ) 
{
    int left, width, prec, size, sign, radix, upper, cch, cchLimit;
    WCHAR prefix, fillch;
    LPWSTR lpT;
    LPCHAR lpC;
    union {
        long l;
        unsigned long ul;
        __int64 i64;
        WCHAR sz[sizeof(long)];
    } val;

    cchLimit = maxchars;
    while (*lpFmt) {
        if (*lpFmt==(WCHAR)'%') {
            /**//* read the flags.  These can be in any order */
            left=0;
            prefix=0;
            while (*++lpFmt) {
                if (*lpFmt==(WCHAR)'-')
                    left++;
                else if (*lpFmt==(WCHAR)'#')
                    prefix++;
                else
                    break;
            }
            /**//* find fill character */
            if (*lpFmt==(WCHAR)'0') {
                fillch=(WCHAR)'0';
                lpFmt++;
            } else
                fillch=(WCHAR)' ';
            /**//* read the width specification */
            lpFmt=SP_GetFmtValue(lpFmt,&cch, &lpParms);
            width=cch;
            /**//* read the precision */
            if (*lpFmt==(WCHAR)'.') {
                lpFmt=SP_GetFmtValue(++lpFmt,&cch, &lpParms);
                prec=cch;
            } else
                prec=-1;
            /**//* get the operand size */
            size=1;
            if (*lpFmt=='l') {
                lpFmt++;
            } else if (*lpFmt=='h') {
                size=0;
                lpFmt++;
            } else if ((*lpFmt == 'I') && (*(lpFmt+1) == '6') && (*(lpFmt+2) == '4')) {
                lpFmt+=3;
                size = 2;
            }
            upper=0;
            sign=0;
            radix=10;
            switch (*lpFmt) {
                case 0:
                    goto errorout;
                case (WCHAR)'i':
                case (WCHAR)'d':
                    sign++;
                case (WCHAR)'u':
                    /**//* turn off prefix if decimal */
                    prefix=0;
donumeric:
                    /**//* special cases to act like MSC v5.10 */
                    if (left || prec>=0)
                        fillch=(WCHAR)' ';
                    if (size == 1)
                        val.l=va_arg(lpParms, long);
                    else if (size == 2)
                        val.i64 = va_arg(lpParms, __int64);
                    else if (sign)
                        val.l=va_arg(lpParms, short);
                    else
                        val.ul=va_arg(lpParms, unsigned);
                    if (sign && val.l<0L)
                        val.l=-val.l;
                    else
                        sign=0;
                    lpT=lpOut;
                    /**//* blast the number backwards into the user buffer */
                    if (size == 2)
                        cch=SP_PutNumber64(lpOut,val.i64,cchLimit,radix,upper);
                    else
                        cch=SP_PutNumber(lpOut,val.l,cchLimit,radix,upper);
                    if (!(cchLimit-=cch))
                        goto errorout;
                    lpOut+=cch;
                    width-=cch;
                    prec-=cch;
                    if (prec>0)
                    width-=prec;
                    /**//* fill to the field precision */
                    while (prec-->0)
                        out((WCHAR)'0');
                    if (width>0 && !left) {
                        /**//* if we're filling with spaces, put sign first */
                        if (fillch!=(WCHAR)'0') {
                            if (sign) {
                                sign=0;
                                out((WCHAR)'-');
                            width--;
                            }
                            if (prefix) {
                                out(prefix);
                                out((WCHAR)'0');
                                prefix=0;
                            }
                        }
                        if (sign)
                            width--;
                        /**//* fill to the field width */
                        while (width-->0)
                            out(fillch);
                        /**//* still have a sign? */
                        if (sign)
                            out((WCHAR)'-');
                        if (prefix) {
                            out(prefix);
                            out((WCHAR)'0');
                        }
                        /**//* now reverse the string in place */
                        SP_Reverse(lpT,lpOut-1);
                } else {
                        /**//* add the sign character */
                        if (sign) {
                            out((WCHAR)'-');
                            width--;
                        }
                        if (prefix) {
                            out(prefix);
                            out((WCHAR)'0');
                        }
                        /**//* reverse the string in place */
                    SP_Reverse(lpT,lpOut-1);
                        /**//* pad to the right of the string in case left aligned */
                    while (width-->0)
                            out(fillch);
                }
                    break;
                case (WCHAR) 'p' :
                    // Fall into case below, since NT is going to 64 bit
                    // they are starting to use p to indicate a pointer
                    // value.  They only seem to support lower case 'p'
                case (WCHAR)'X':
                    upper++;
                case (WCHAR)'x':
                    radix=16;
                    if (prefix)
                    if (upper)
                            prefix=(WCHAR)'X';
                        else
                            prefix=(WCHAR)'x';
                    goto donumeric;
                case (WCHAR)'c':
                    val.sz[0] = va_arg(lpParms, WCHAR);
                    val.sz[1]=0;
                    lpT=val.sz;
                    cch = 1;  // Length is one character. 
                             /**//* stack aligned to larger size */
                    goto putstring;
                case 'a':   // ascii string!
                case 'S':
PrtAscii:
                    if (!(lpC=va_arg(lpParms, LPCHAR)))
                        lpC = "(NULL)";
                    cch=strlen(lpC);
                    if (prec>=0 && cch>prec)
                        cch=prec;
                    width -= cch;
                    if (left) {
                        while (cch--)
                            out((WCHAR)*lpC++);
                        while (width-->0)
                            out(fillch);
                    } else {
                        while (width-->0)
                            out(fillch);
                        while (cch--)
                            out((WCHAR)*lpC++);
                    }
                    break;
                case 's':
                    if (!size)
                        goto PrtAscii;
                    if (!(lpT=va_arg(lpParms,LPWSTR)))
                        lpT = L"(NULL)";
                    cch=strlenW(lpT);
putstring:
                    if (prec>=0 && cch>prec)
                        cch=prec;
                    width -= cch;
                    if (left) {
                        while (cch--)
                            out(*lpT++);
                        while (width-->0)
                            out(fillch);
                    } else {
                        while (width-->0)
                            out(fillch);
                        while (cch--)
                            out(*lpT++);
                    }
                    break;
                default:
                    out(*lpFmt);    /**//* Output the invalid char and continue */
                    break;
            }
        } else /**//* character not a '%', just do it */
            out(*lpFmt);
        /**//* advance to next format string character */
        lpFmt++;
    }
errorout:
    *lpOut=0;
    return maxchars-cchLimit;
}



//------------------------------------------------------------------------------
//  GetFmtValue
//  reads a width or precision value from the format string
//------------------------------------------------------------------------------
LPCWSTR 
SP_GetFmtValue(
    LPCWSTR lpch,
    int *lpw,
    va_list *plpParms
    ) 
{
    int i=0;
    if (*lpch == TEXT('*')) {
        *lpw = va_arg(*plpParms, int);
        lpch++;
    } else {
        while (*lpch>=(WCHAR)'0' && *lpch<=(WCHAR)'9') {
            i = i*10 + (*lpch-(WCHAR)'0');
            lpch++;
        }
        *lpw=i;
    }
    /**//* return the address of the first non-digit character */
    return lpch;
}



//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void 
SP_Reverse(
    LPWSTR lpFirst,
    LPWSTR lpLast
    ) 
{
    int swaps;
    WCHAR tmp;
    swaps = ((((DWORD)lpLast - (DWORD)lpFirst)/sizeof(WCHAR)) + 1)/2;
    while (swaps--) {
        tmp = *lpFirst;
        *lpFirst++ = *lpLast;
        *lpLast-- = tmp;
    }
}

const WCHAR lowerval[] = TEXT("0123456789abcdef");
const WCHAR upperval[] = TEXT("0123456789ABCDEF");



//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
int 
SP_PutNumber(
    LPWSTR lpb,
    ULONG n,
    int limit,
    int radix,
    int mycase
    ) 
{
    int used = 0;
    while (limit--) {
        *lpb++ = (mycase ? upperval[(n % radix)] : lowerval[(n % radix)]);
        used++;
        if (!(n /= radix))
            break;
    }
    return used;
}



//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
int 
SP_PutNumber64(
    LPWSTR lpb,
    __int64 i64,
    int limit,
    int radix,
    int mycase
    ) 
{
    int used = 0;
    while (limit--) {
        *lpb++ = (mycase ? upperval[(i64 % radix)] : lowerval[(i64 % radix)]);
        used++;
        if (!(i64 /= radix))
            break;
    }
    return used;
}

 

     关于OAL下的debug.c的