Subversion Repositories zxusbnet

Rev

Rev 47 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. /////////////////////////////////////////////////////////////////////////////////
  2. // Copyright(c) 2001-2002 Hybus Co,.ltd. All rights reserved.
  3. //
  4. // Module name:
  5. //      lstring.c
  6. //
  7. // Description:
  8. //
  9. //
  10. // Author:
  11. //      bedguy
  12. //
  13. // Created:
  14. //      2002.10
  15. //
  16. ///////////////////////////////////////////////////////////////////////////////
  17.  
  18.  
  19. #include "stdarg.h"
  20. #include "lstring.h"
  21.  
  22. static void PrintChar(char *fmt, char c);
  23. static void PrintDec(char *fmt, int value);
  24. static void PrintHex(char *fmt, uint value);
  25. static void PrintString(char *fmt, char *cptr);
  26. static int Power(int num, int cnt);
  27.  
  28.  
  29. void MemCpy32(void *dest, void *src, int numWords){
  30.         volatile long *s1=dest, *s2=src;
  31.         while(numWords--) {
  32.                 *s1++ = *s2++;
  33.         }
  34.         return;
  35. }       // MemCpy32.
  36.  
  37.  
  38. void MemCpy(void *dest, void *src, int cnt){
  39.         char *s1=dest, *s2=src, *endptr=(char *)dest+cnt;
  40.        
  41.         while (s1<endptr)
  42.                 *s1++ = *s2++;
  43.         return;
  44. }       // MemCpy.
  45.  
  46.  
  47. void MemSet(void *dest, char c, int len){
  48.         char *s=dest;
  49.         char *limit = (char *)dest+len;
  50.  
  51.         while (s < limit) *s++ = c;
  52. }       // MemSet.
  53.  
  54.  
  55. int MemCmp(void *addr1, void *addr2, int len){
  56.         volatile char *s1=addr1, *s2=addr2;
  57.         volatile char *endptr = (char*)addr1+len;
  58.  
  59.         while ((ulong)s1 < (ulong)endptr){
  60.                 if (*s1++ != *s2++) return *(--s1) - *(--s2);
  61.         }
  62.         return 0;
  63. }       // MemCmp.
  64.  
  65.  
  66. void StrCpy(char *dest, char *src){
  67.         volatile char *s1=dest, *s2=src;
  68.        
  69.         while (*s2!=0) *s1++ = *s2++;
  70.         *s1 = 0;
  71.         return;
  72. }       // StrCpy.
  73.  
  74.  
  75. int StrLen(char *dest){
  76.         volatile char *tmp = dest;
  77.  
  78.         if (!tmp) return -1;
  79.         while (*tmp!=0) tmp++;
  80.         return (tmp - dest);
  81. }       // StrLen.
  82.  
  83.  
  84. int StrNCmp(char *s1, char *s2, int len){
  85.         int i;
  86.  
  87.         for(i = 0; i < len; i++){
  88.                 if(s1[i] != s2[i])      return ((int)s1[i]) - ((int)s2[i]);
  89.                 if(s1[i] == 0)          return 0;
  90.         }
  91.         return 0;
  92. } // StrNCmp.
  93.  
  94.  
  95. int StrCmp(char *s1, char *s2){
  96.         for (; *s1 && *s2; s1++, s2++){
  97.                 if (*s1 != *s2) return ((int)(*s1) - (int)(*s2));
  98.         }
  99.         if (*s1 || *s2) return ((int)(*s1) - (int)(*s2));
  100.         return 0;
  101. }       // StrCmp.
  102.  
  103.  
  104. bool HexToInt(char *s, void *retval, VAR_TYPE type){
  105.         char    c;
  106.         int             i;
  107.         long    rval;
  108.  
  109.         if (!s || !retval) return false;
  110.         if (!StrNCmp(s, "0x", 2)) s+=2;
  111.         // fine int value.
  112.         for (i=0, rval=0; i<type/4; i++){
  113.                 if (*s=='\0'){
  114.                         if (i==0) return false;
  115.                         else      break;
  116.                 }
  117.                 c = *s++;
  118.  
  119.                 if      (c>='0' && c<='9') c-='0';
  120.                 else if (c>='a' && c<='f') c=c-'a'+10;
  121.                 else if (c>='A' && c<='F') c=c-'A'+10;
  122.                 else    return false;
  123.  
  124.                 rval = rval<<4 | c;
  125.         }
  126.         // make retval.
  127.         switch (type){
  128.                 case 8 :
  129.                         *(char *)retval = (char)rval;
  130.                         break;
  131.                 case 16 :
  132.                         *(short *)retval = (short)rval;
  133.                         break;
  134.                 case 32 :
  135.                         *(long *)retval = (long)rval;
  136.                         break;
  137.                 default :
  138.                         return false;
  139.         }
  140.         return true;
  141. }       // HexToInt.
  142.  
  143.  
  144. bool DecToLong(char *s, long *retval){
  145.         long remainder;
  146.         if (!s || !s[0]) return false;
  147.  
  148.         for (*retval=0; *s; s++){
  149.                 if (*s < '0' || *s > '9') return false;
  150.                 remainder = *s - '0';
  151.                 *retval = *retval * 10 + remainder;
  152.         }
  153.  
  154.         return true;
  155. }       // DecToLong.
  156.  
  157.  
  158. void HexDump(char *addr, int len){
  159.         char    *s=addr, *endPtr=(char *)((long)addr+len);
  160.         int             i, remainder=len%16;
  161.        
  162.         printf("\n");
  163.         printf("Offset      Hex Value                                        Ascii value\n");
  164.        
  165.         // print out 16 byte blocks.
  166.         while (s+16<=endPtr){
  167.                 // offset ├т╖┬.
  168.                 printf("0x%08lx  ", (long)(s-addr));
  169.                 // 16 bytes ┤▄└з╖╬ │╗┐ы ├т╖┬.
  170.                 for (i=0; i<16; i++){
  171.                         printf("%02x ", s[i]);
  172.                 }
  173.                 printf(" ");
  174.                 for (i=0; i<16; i++){
  175.                         if              (s[i]>=32 && s[i]<=125) printf("%c", s[i]);
  176.                         else                                                    printf(".");
  177.                 }
  178.                 s += 16;
  179.                 printf("\n");
  180.         }
  181.        
  182.         // Print out remainder.
  183.         if (remainder){
  184.                 // offset ├т╖┬.
  185.                 printf("0x%08lx  ", (long)(s-addr));
  186.                 // 16 bytes ┤▄└з╖╬ ├т╖┬╟╧░э │▓└║ ░═ ├т╖┬.
  187.                 for (i=0; i<remainder; i++){
  188.                         printf("%02x ", s[i]);
  189.                 }
  190.                 for (i=0; i<(16-remainder); i++){
  191.                         printf("   ");
  192.                 }
  193.                 printf(" ");
  194.                 for (i=0; i<remainder; i++){
  195.                         if              (s[i]>=32 && s[i]<=125) printf("%c", s[i]);
  196.                         else                                                    printf(".");
  197.                 }
  198.                 for (i=0; i<(16-remainder); i++){
  199.                         printf(" ");
  200.                 }
  201.                 printf("\n");
  202.         }
  203.         return;
  204. }       // HexDump.
  205.  
  206.  
  207. //void printf(char *fmt, ...){
  208. //
  209. //      int             i;
  210. //      va_list args;
  211. //      char    *s=fmt;
  212. //      char    format[10];             // fmt└╟ └╬└┌░б "%08lx"╢є╕щ, "08l"╕ж └╙╜├╖╬ ▒т╖╧.
  213. //     
  214. //      va_start(args, fmt);
  215. //      while (*s){
  216. //              if (*s=='%'){
  217. //                      s++;
  218. //                      // s┐б╝н "%08lx"╟№╜─└╗ ░б┴о┐═ format┐б ▒т╖╧. │к┴▀┐б ├т╖┬╟╘╝Ў┐б │╤░▄┴▄.
  219. //                      format[0] = '%';
  220. //                      for (i=1; i<10;){
  221. //                              if (*s=='c' || *s=='d' || *s=='x' || *s=='s' || *s=='%'){
  222. //                                      format[i++] = *s;
  223. //                                      format[i] = '\0';
  224. //                                      break;
  225. //                              }
  226. //                              else {
  227. //                                      format[i++] = *s++;
  228. //                              }
  229. //                      }
  230. //                      // "%s", "%c", "%d", "%x"╕ж ├г╛╞ ├т╖┬╟╥ ╟╘╝Ў ╚г├т.
  231. //                      switch (*s++){
  232. //                              case 'c' :
  233. //                                      PrintChar(format, va_arg(args, int));
  234. //                                      break;
  235. //                              case 'd' :
  236. //                                      PrintDec(format, va_arg(args, int));
  237. //                                      break;
  238. //                              case 'x' :
  239. //                                      PrintHex(format, va_arg(args, int));
  240. //                                      break;
  241. //                              case 's' :
  242. //                                      PrintString(format, va_arg(args, char *));
  243. //                                      break;
  244. //                              case '%' :
  245. //                                      PrintChar("%c", '%');
  246. //                                      break;
  247. //                      }
  248. //              }
  249. //              else {
  250. //                      PrintChar("%c", *s);
  251. //                      s++;
  252. //              }
  253. //      }
  254. //      va_end(args);
  255. //      return;
  256. ///*
  257. //      va_list args;
  258. //      static char printf_buf[512];
  259. //      int i;
  260. //
  261. //      va_start(args, fmt);
  262. //      i = vsnprintf(printf_buf, sizeof(printf_buf), fmt, args);
  263. //      va_end(args);
  264. //      PrintString("%s",printf_buf);
  265. //      //return i;
  266. //      return ;
  267. //*/   
  268. //}
  269.  
  270.  
  271. void PrintChar(char *fmt, char c){
  272.         SerialOutputByte(c);
  273.         return;
  274. }
  275.  
  276.  
  277. void PrintDec(char *fmt, int l){
  278.         int             i, j;
  279.         char    c, *s=fmt, tol[10];
  280.         bool    flag0=false, flagl=false;       // "%08lx"┐б╝н '0', 'l'└╟ ┴╕└ч ┐й║╬.
  281.         long    flagcnt=0;                                      // "%08lx"┐б╝н "8"└╗ ├г╛╞╝н long╟№└╕╖╬.
  282.         bool    leading_zero=true;                      // long╟№└╟ data╕ж ├т╖┬╟╧▒т └з╟╤ ║п╝Ў.
  283.         long    divisor, result, remainder;
  284.  
  285.         // fmt└╟ "%08lx"┐б╝н '0', '8', 'l'└╗ ╟╪╝о.
  286.         for (i=0; (c=s[i]); i++){
  287.                 if (c=='d') break;
  288.                 else if (c>='1' && c<='9'){
  289.                         for (j=0; s[i]>='0' && s[i]<='9'; j++){
  290.                                 tol[j] = s[i++];
  291.                         }
  292.                         tol[j] = '\0';
  293.                         i--;
  294.                         DecToLong(tol, &flagcnt);
  295.                 }
  296.                 else if (c=='0') flag0=true;
  297.                 else if (c=='l') flagl=true;
  298.                 else continue;
  299.         }
  300.  
  301.         // └з└╟ flag┐б ╡√╢є ├т╖┬.
  302.         if (flagcnt){
  303.                 if (flagcnt>9) flagcnt=9;
  304.                 remainder = l%(Power(10, flagcnt));     // flagcnt║╕┤┘ └н└┌╕о└╟ ╝Ў┤┬ ░╔╖п│┐. 199┐б flagcnt==2└╠╕щ, 99╕╕.
  305.  
  306.                 for (divisor=Power(10, flagcnt-1); divisor>0; divisor/=10){
  307.                         result = remainder/divisor;
  308.                         remainder %= divisor;
  309.  
  310.                         if (result!=0 || divisor==1) leading_zero = false;
  311.  
  312.                         if (leading_zero==true){
  313.                                 if (flag0)      SerialOutputByte('0');
  314.                                 else            SerialOutputByte(' ');
  315.                         }
  316.                         else SerialOutputByte((char)(result)+'0');
  317.                 }
  318.         } else {
  319.                 remainder = l;
  320.  
  321.                 for (divisor=1000000000; divisor>0; divisor/=10){
  322.                         result = remainder/divisor;
  323.                         remainder %= divisor;
  324.  
  325.                         if (result!=0 || divisor==1) leading_zero = false;
  326.                         if (leading_zero==false) SerialOutputByte((char)(result)+'0');
  327.                 }
  328.         }
  329.         return;
  330. }
  331.  
  332.  
  333. void PrintHex(char *fmt, uint l){
  334.         int             i, j;
  335.         char    c, tol[10];
  336.         uchar *s=(uchar*)fmt;
  337.         bool    flag0=false, flagr=false, flagl=false;  // flags.
  338.         long    flagcnt=0;
  339.         bool    leading_zero=true;
  340.         char    uHex, lHex;
  341.         int             cnt;                                            // "%5x"└╟ ░ц┐ь 5░│╕╕ ├т╖┬╟╧╡╡╖╧ ├т╖┬╟╤ ░│╝Ў.
  342.  
  343.         // fmt└╟ "%08l(L)x"┐б╝н '0', '8', 'l', 'L'└╗ ╟╪╝о.
  344.         for (i=0; (c=s[i]); i++){
  345.                 if (c=='x') break;
  346.                 else if (c>='1' && c<='9'){
  347.                         for (j=0; s[i]>='0' && s[i]<='9'; j++){
  348.                                 tol[j] = s[i++];
  349.                         }
  350.                         tol[j] = '\0';
  351.                         i--;
  352.                         DecToLong(tol, &flagcnt);
  353.                 }
  354.                 else if (c=='0') flag0=true;
  355.                 else if (c=='r') flagr=true;  // SWAP
  356.                 else if (c=='l') flagl=true;  // Long Type
  357.                 else continue;
  358.         }
  359.  
  360.  
  361.         s = (uchar *)(&l);
  362.    if(!flagr) l = SWAP32(l);               // little, big endian┐б ╡√╢є╝н.(big└╠ ├т╖┬╟╧▒т ╜м┐Ў ╝°╝н╕ж ╣┘▓▐)
  363.          
  364.        
  365.         // └з└╟ flag┐б ╡√╢є ├т╖┬.
  366.         if (flagcnt){
  367.                 if (flagcnt&0x01){      // flagcnt░б ╚ж╝Ў └╧╢з, upper╕ж ╣л╜├, lower╕╕ ├т╖┬.
  368.                         c = s[(8-(flagcnt+1))/2]; // ╚ж╝Ў └╧╢з ▒╫ └з─б╕ж ╞ў╟╘╟╧┤┬ ░ў└╟ ░к└╗ ░б┴о ┐╔┤╧┤┘.
  369.                        
  370.                         // lower 4 bits╕ж ░б┴о┐═╝н ascii code╖╬.
  371.                         lHex = ((c>>0)&0x0f);
  372.                         if (lHex!=0) leading_zero=false;
  373.                         if (lHex<10) lHex+='0';
  374.                         else         lHex+='A'-10;
  375.  
  376.                         // lower 4 bits ├т╖┬.
  377.                         if (leading_zero){
  378.                                 if (flag0) SerialOutputByte('0');
  379.                                 else       SerialOutputByte(' ');
  380.                         }
  381.                         else SerialOutputByte(lHex);
  382.                        
  383.                         flagcnt--;
  384.                 }
  385.  
  386.                 // byte┤▄└з└╟ data╕ж Hex╖╬ ├т╖┬.
  387.                 for (cnt=0, i=(8-flagcnt)/2; i<4; i++){
  388.                         c = s[i];
  389.                                
  390.                         // get upper 4 bits and lower 4 bits.
  391.                         uHex = ((c>>4)&0x0f);
  392.                         lHex = ((c>>0)&0x0f);
  393.  
  394.                         // upper 4 bits and lower 4 bits to '0'~'9', 'A'~'F'.
  395.                         // upper 4 bits╕ж ascii code╖╬.
  396.                         if (uHex!=0) leading_zero = false;
  397.                         if (uHex<10) uHex+='0';
  398.                         else         uHex+='A'-10;
  399.  
  400.                         // upper 4 bits ├т╖┬.
  401.                         if (leading_zero){
  402.                                 if (flag0) SerialOutputByte('0');
  403.                                 else       SerialOutputByte(' ');
  404.                         }
  405.                         else SerialOutputByte(uHex);
  406.                        
  407.                         // lower 4 bits╕ж ascii code╖╬.
  408.                         if (lHex!=0) leading_zero = false;
  409.                         if (lHex<10) lHex+='0';
  410.                         else         lHex+='A'-10;
  411.  
  412.                         // lower 4 bits ├т╖┬.
  413.                         if (leading_zero){
  414.                                 if (flag0) SerialOutputByte('0');
  415.                                 else       SerialOutputByte(' ');
  416.                         }
  417.                         else SerialOutputByte(lHex);
  418.                 }
  419.         }
  420.         else {
  421.                 for (i=0; i<4; i++){
  422.                         c = s[i];
  423.        
  424.                         // get upper 4 bits and lower 4 bits.
  425.                         uHex = ((c>>4)&0x0f);
  426.                         lHex = ((c>>0)&0x0f);
  427.  
  428.                         // upper 4 bits and lower 4 bits to '0'~'9', 'A'~'F'.
  429.                         if (uHex!=0) leading_zero = false;
  430.                         if (uHex<10) uHex+='0';
  431.                         else         uHex+='A'-10;
  432.                         if (!leading_zero) SerialOutputByte(uHex);
  433.                        
  434.                         if (lHex!=0 || i==3) leading_zero = false;
  435.                         if (lHex<10) lHex+='0';
  436.                         else         lHex+='A'-10;
  437.                         if (!leading_zero) SerialOutputByte(lHex);
  438.                 }
  439.         }
  440.         return;
  441. }
  442.  
  443.  
  444. void PrintString(char *fmt, char *s){
  445.         if (!fmt || !s) return;
  446.         while (*s) SerialOutputByte(*s++);
  447.         return;
  448. }
  449.  
  450.  
  451. int Power(int num, int cnt){
  452.         long retval=num;
  453.         cnt--;
  454.  
  455.         while (cnt--){
  456.                 retval *= num;
  457.         }
  458.         return retval;
  459. }
  460.