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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > Windows CE > 查看源码
format.c
资源名称：SMDK2440.rar　[点击查看]
上传用户：qiulin1960
上传日期：2013-10-16
资源大小：2844k
文件大小：12k
源码类别：

Windows CE

开发平台：

Windows_Unix

format.c：源码内容
  1. //
  2. // Copyright (c) Microsoft Corporation.  All rights reserved.
  3. //
  4. //
  5. // Use of this source code is subject to the terms of the Microsoft end-user
  6. // license agreement (EULA) under which you licensed this SOFTWARE PRODUCT.
  7. // If you did not accept the terms of the EULA, you are not authorized to use
  8. // this source code. For a copy of the EULA, please see the LICENSE.RTF on your
  9. // install media.
  10. //
  11. /*++
  12. THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
  13. ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
  14. THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
  15. PARTICULAR PURPOSE.
  17. Module Name:  
  18.     format.c
  19. Abstract:  
  20.     This file contains simple formatted output string support for the
  21.     boot loader.
  22. Functions:
  25. Notes: 
  26.     supported, with no frills: x d s u X, H, and B
  27.     backslash n is converted to backslash n backslash r.
  29.     X is equivalent to 08x; B, 02x; and H, 04x in printf format.
  31. --*/
  32. #include <windows.h>
  33. #include <blcommon.h>
  34. //
  35. // Functional Prototypes
  36. //
  37. static void pOutputByte(unsigned char c);
  38. static void pOutputNumHex(unsigned long n,long depth);
  39. static void pOutputNumDecimal(unsigned long n);
  40. static void OutputString(const unsigned char *s);
  42. char *szSprintf;
  44. //
  45. // Routine starts
  46. //
  47. /*****************************************************************************
  48. *
  49. *
  50. *   @func   void    | EdbgOutputDebugString | Simple formatted debug output string routine
  51. *
  52. *   @rdesc  none
  53. *
  54. *   @parm   LPCSTR  |   sz,... |
  55. *               Format String:
  56. *
  57. *               @flag Format string | type
  58. *               @flag u | unsigned
  59. *               @flag d | int
  60. *               @flag c | char
  61. *               @flag s | string
  62. *               @flag x | 4-bit hex number
  63. *               @flag B | 8-bit hex number
  64. *               @flag H | 16-bit hex number
  65. *               @flag X | 32-bit hex number
  66. *
  67. *   @comm
  68. *           Same as FormatString, but output to serial port instead of buffer.
  69. */
  70. void EdbgOutputDebugString (LPCSTR sz, ...)
  71. {
  72.     unsigned char    c;
  73.     va_list         vl;
  74.     
  75.     va_start(vl, sz);
  76.     
  77.     while (*sz) {
  78.         c = *sz++;
  79.         switch (c) {
  80.         case '%':
  81.             c = *sz++;
  82.             switch (c) { 
  83.             case 'x':
  84.                 pOutputNumHex(va_arg(vl, unsigned long), 0);
  85.                 break;
  86.             case 'B':
  87.                 pOutputNumHex(va_arg(vl, unsigned long), 2);
  88.                 break;
  89.             case 'H':
  90.                 pOutputNumHex(va_arg(vl, unsigned long), 4);
  91.                 break;
  92.             case 'X':
  93.                 pOutputNumHex(va_arg(vl, unsigned long), 8);
  94.                 break;
  95.             case 'd':
  96.                 {
  97.                     long    l;
  98.                 
  99.                     l = va_arg(vl, long);
  100.                     if (l < 0) { 
  101.                         pOutputByte('-');
  102.                         l = - l;
  103.                     }
  104.                     pOutputNumDecimal((unsigned long)l);
  105.                 }
  106.                 break;
  107.             case 'u':
  108.                 pOutputNumDecimal(va_arg(vl, unsigned long));
  109.                 break;
  110.             case 's':
  111.                 OutputString(va_arg(vl, char *));
  112.                 break;
  113.             case '%':
  114.                 pOutputByte('%');
  115.                 break;
  116.             case 'c':
  117.                 c = va_arg(vl, unsigned char);
  118.                 pOutputByte(c);
  119.                 break;
  120.                 
  121.             default:
  122.                 pOutputByte(' ');
  123.                 break;
  124.             }
  125.             break;
  126.         case 'r':
  127.             if (*sz == 'n')
  128.                 sz ++;
  129.             c = 'n';
  130.             // fall through
  131.         case 'n':
  132.             pOutputByte('r');
  133.             // fall through
  134.         default:
  135.             pOutputByte(c);
  136.         }
  137.     }
  138.     
  139.     va_end(vl);
  140. }
  142. /*****************************************************************************
  143. *
  144. *
  145. *   @func   void    |   FormatString | Simple formatted output string routine
  146. *
  147. *   @rdesc  Returns length of formatted string
  148. *
  149. *   @parm   unsigned char * |   pBuf |
  150. *               Pointer to string to return formatted output.  User must ensure
  151. *               that buffer is large enough.
  152. *
  153. *   @parm   const unsigned char * |   sz,... |
  154. *               Format String:
  155. *
  156. *               @flag Format string | type
  157. *               @flag u | unsigned
  158. *               @flag d | int
  159. *               @flag c | char
  160. *               @flag s | string
  161. *               @flag x | 4-bit hex number
  162. *               @flag B | 8-bit hex number
  163. *               @flag H | 16-bit hex number
  164. *               @flag X | 32-bit hex number
  165. *
  166. *   @comm
  167. *           Same as OutputFormatString, but output to buffer instead of serial port.
  168. */
  169. unsigned int FormatString (unsigned char *pBuf, const unsigned char *sz, ...)
  170. {
  171.     unsigned char    c;
  172.     va_list         vl;
  173.     
  174.     va_start(vl, sz);
  175.     
  176.     szSprintf = pBuf;
  177.     while (*sz) {
  178.         c = *sz++;
  179.         switch (c) {
  180.         case '%':
  181.             c = *sz++;
  182.             switch (c) { 
  183.             case 'x':
  184.                 pOutputNumHex(va_arg(vl, unsigned long), 0);
  185.                 break;
  186.             case 'B':
  187.                 pOutputNumHex(va_arg(vl, unsigned long), 2);
  188.                 break;
  189.             case 'H':
  190.                 pOutputNumHex(va_arg(vl, unsigned long), 4);
  191.                 break;
  192.             case 'X':
  193.                 pOutputNumHex(va_arg(vl, unsigned long), 8);
  194.                 break;
  195.             case 'd':
  196.                 {
  197.                     long    l;
  198.                 
  199.                     l = va_arg(vl, long);
  200.                     if (l < 0) { 
  201.                         pOutputByte('-');
  202.                         l = - l;
  203.                     }
  204.                     pOutputNumDecimal((unsigned long)l);
  205.                 }
  206.                 break;
  207.             case 'u':
  208.                 pOutputNumDecimal(va_arg(vl, unsigned long));
  209.                 break;
  210.             case 's':
  211.                 OutputString(va_arg(vl, char *));
  212.                 break;
  213.             case '%':
  214.                 pOutputByte('%');
  215.                 break;
  216.             case 'c':
  217.                 c = va_arg(vl, unsigned char);
  218.                 pOutputByte(c);
  219.                 break;
  220.                 
  221.             default:
  222.                 pOutputByte(' ');
  223.                 break;
  224.             }
  225.             break;
  226.         case 'r':
  227.             if (*sz == 'n')
  228.                 sz ++;
  229.             c = 'n';
  230.             // fall through
  231.         case 'n':
  232.             pOutputByte('r');
  233.             // fall through
  234.         default:
  235.             pOutputByte(c);
  236.         }
  237.     }
  238.     pOutputByte(0);
  239.     c = szSprintf - pBuf;
  240.     szSprintf = 0;
  241.     va_end(vl);
  242.     return (c);
  243. }
  245. /*****************************************************************************
  246. *
  247. *
  248. *   @func   void    |   pOutputByte | Sends a byte out of the monitor port.
  249. *
  250. *   @rdesc  none
  251. *
  252. *   @parm   unsigned int |   c |
  253. *               Byte to send.
  254. *
  255. */
  256. static void
  257. pOutputByte(
  258.     unsigned char c
  259. )
  260. {
  261.     if (szSprintf)
  262.         *szSprintf++ = c;
  263.     else
  264.         OEMWriteDebugByte(c);
  265. }
  268. /*****************************************************************************
  269. *
  270. *
  271. *   @func   void    |   pOutputNumHex | Print the hex representation of a number through the monitor port.
  272. *
  273. *   @rdesc  none
  274. *
  275. *   @parm   unsigned long |   n |
  276. *               The number to print.
  277. *
  278. *   @parm   long | depth |
  279. *               Minimum number of digits to print.
  280. *
  281. */
  282. static void pOutputNumHex (unsigned long n, long depth)
  283. {
  284.     if (depth) {
  285.         depth--;
  286.     }
  287.     
  288.     if ((n & ~0xf) || depth) {
  289.         pOutputNumHex(n >> 4, depth);
  290.         n &= 0xf;
  291.     }
  292.     
  293.     if (n < 10) {
  294.         pOutputByte((unsigned char)(n + '0'));
  295.     } else { 
  296.     pOutputByte((unsigned char)(n - 10 + 'A'));
  297. }
  298. }
  301. /*****************************************************************************
  302. *
  303. *
  304. *   @func   void    |   pOutputNumDecimal | Print the decimal representation of a number through the monitor port.
  305. *
  306. *   @rdesc  none
  307. *
  308. *   @parm   unsigned long |   n |
  309. *               The number to print.
  310. *
  311. */
  312. static void pOutputNumDecimal (unsigned long n)
  313. {
  314.     if (n >= 10) {
  315.         pOutputNumDecimal(n / 10);
  316.         n %= 10;
  317.     }
  318.     pOutputByte((unsigned char)(n + '0'));
  319. }
  321. /*****************************************************************************
  322. *
  323. *
  324. *   @func   void    |   OutputString | Sends an unformatted string to the monitor port.
  325. *
  326. *   @rdesc  none
  327. *
  328. *   @parm   const unsigned char * |   s |
  329. *               points to the string to be printed.
  330. *
  331. *   @comm
  332. *           backslash n is converted to backslash r backslash n
  333. */
  334. static void OutputString (const unsigned char *s)
  335. {
  336.     while (*s) {        
  337.         if (*s == 'n') {
  338.             OEMWriteDebugByte('r');
  339.         }
  340.         OEMWriteDebugByte(*s++);
  341.     }
  342. }
  344. // This routine will take a binary IP address as represent here and return a dotted decimal version of it
  345. char *inet_ntoa( DWORD dwIP ) {
  347.     static char szDottedD[16];
  349.     FormatString( szDottedD, "%u.%u.%u.%u",
  350.         (BYTE)dwIP, (BYTE)(dwIP >> 8), (BYTE)(dwIP >> 16), (BYTE)(dwIP >> 24) );
  352.     return szDottedD;
  354. } // inet_ntoa()
  356. // This routine will take a dotted decimal IP address as represent here and return a binary version of it
  357. DWORD inet_addr( char *pszDottedD ) {
  359.     DWORD dwIP = 0;
  360.     DWORD cBytes;
  361.     char *pszLastNum;
  362.     int atoi (const char *s);
  363.     
  364.     // Replace the dots with NULL terminators
  365.     pszLastNum = pszDottedD;
  366.     for( cBytes = 0; cBytes < 4; cBytes++ ) {
  367.         while(*pszDottedD != '.' && *pszDottedD != '')
  368.             pszDottedD++;
  369.         if (pszDottedD == '' && cBytes != 3)
  370.             return 0;
  371.         *pszDottedD = '';
  372.         dwIP |= (atoi(pszLastNum) & 0xFF) << (8*cBytes);
  373.         pszLastNum = ++pszDottedD;
  374.     }
  376.     return dwIP;
  378. } // inet_ntoa()
  381. /*****************************************************************************
  382. *
  383. *   Function: NKDbgPrintfW
  384. *
  385. *   Description: Formats and writes a wide character string to the serial port
  386. *
  387. *   Parameters: sz - pointer to wide character string
  388. *
  389. *   Returns: Nothing
  390. *
  391. */
  392. #ifndef SIMULATOR
  393. void NKDbgPrintfW(
  394.     const WCHAR *sz, ...)
  395. {
  396.     unsigned char    c;
  397.     va_list         vl;
  398.     
  399.     va_start(vl, sz);
  400.     
  401.     while (*sz) {
  402.         c = (unsigned char)*sz++;
  403.         switch (c) { 
  404.             case (unsigned char)'%':
  405.             c = (unsigned char)*sz++;
  406.             switch (c) { 
  407.                 case 'x':
  408.                 pOutputNumHex(va_arg(vl, unsigned long), 0);
  409.                 break;
  410.                 case 'B':
  411.                 pOutputNumHex(va_arg(vl, unsigned long), 2);
  412.                 break;
  413.                 case 'H':
  414.                 pOutputNumHex(va_arg(vl, unsigned long), 4);
  415.                 break;
  416.                 case 'X':
  417.                 pOutputNumHex(va_arg(vl, unsigned long), 8);
  418.                 break;
  419.                 case 'd': {
  420.                 long    l;
  421.                 
  422.                 l = va_arg(vl, long);
  423.                 if (l < 0) { 
  424.                     pOutputByte('-');
  425.                     l = - l;
  426.                 }
  427.                 pOutputNumDecimal((unsigned long)l);
  428.             }
  429.                 break;
  430.                 case 'u':
  431.                 pOutputNumDecimal(va_arg(vl, unsigned long));
  432.                 break;
  433.                 case 's':
  434.                 OutputString(va_arg(vl, char *));
  435.                 break;
  436.                 case '%':
  437.                 pOutputByte('%');
  438.                 break;
  439.                 case 'c':
  440.                 c = va_arg(vl, unsigned char);
  441.                 pOutputByte(c);
  442.                 break;
  443.                 
  444.                 default:
  445.                 pOutputByte(' ');
  446.                 break;
  447.             }
  448.             break;
  449.             case 'n':
  450.             pOutputByte('r');
  451.             // fall through
  452.             default:
  453.             pOutputByte(c);
  454.         }
  455.     }
  456.     
  457.     va_end(vl);
  458. }
  459. #endif