string.c

Intrisyc 公司的PXA255-bootloader,源码易懂

         *value += *number - '0';
      }
      else if(*number >= 'A' && *number <= 'F')
      {
         *value <<= 4;
         *value += *number - 'A' + 10;
      }
      else if(*number >= 'a' && *number <= 'f')
      {
         *value <<= 4;
         *value += *number - 'a' + 10;
      }
      else
      {
         break;
      }

      number++;
      count--;
   }
   return (sizeof(u8) * 2) - count;
}
#endif

////////////////////////////////////////////////////////////////////////////////
// atou16
// PURPOSE: Converts an ASCII hexadecimal string into a u16.
// PARAMS:  (IN)  char *number - number to convert.
//          (OUT) u16 *value    - Number as a u16.
// RETURNS: Number of characters converted.
////////////////////////////////////////////////////////////////////////////////
int
atou16(char const *number,
       u16 *value)
{
   int count = sizeof(u16) * 2;

   *value = 0;

   while(*number != 0 && count)
   {
      if(*number >= '0' && *number <= '9')
      {
         *value <<= 4;
         *value += *number - '0';
      }
      else if(*number >= 'A' && *number <= 'F')
      {
         *value <<= 4;
         *value += *number - 'A' + 10;
      }
      else if(*number >= 'a' && *number <= 'f')
      {
         *value <<= 4;
         *value += *number - 'a' + 10;
      }
      else
      {
         break;
      }

      number++;
      count--;
   }
   return (sizeof(u16) * 2) - count;
}

////////////////////////////////////////////////////////////////////////////////
// atou32
// PURPOSE: Converts an ASCII hexadecimal string into a u32.
// PARAMS:  (IN)  char *number - number to convert.
//          (OUT) u32 *value    - Number as a u32.
// RETURNS: Number of characters converted.
////////////////////////////////////////////////////////////////////////////////
int
atou32(char const *number,
       u32 *value)
{
   int count = sizeof(u32) * 2;
 
   *value = 0;

   while(*number != 0 && count)
   {
      if(*number >= '0' && *number <= '9')
      {
         *value <<= 4;
         *value += *number - '0';
      }
      else if(*number >= 'A' && *number <= 'F')
      {
         *value <<= 4;
         *value += *number - 'A' + 10;
      }
      else if(*number >= 'a' && *number <= 'f')
      {
         *value <<= 4;
         *value += *number - 'a' + 10;
      }
      else
      {
         break;
      }

      number++;
      count--;
   }
   return (sizeof(u32) * 2) - count;
}

////////////////////////////////////////////////////////////////////////////////
// atoip
// PURPOSE: Converts an ASCII IP address (e.g. 192.168.1.1) to a u32.
// PARAMS:  (IN)  char *ip - IP address to convert.
// RETURNS: IP address as a u32.
////////////////////////////////////////////////////////////////////////////////
u32
atoip(char const *ip)
{
   u32 result = 0;
   u32 temp = 0;
   int i = 0;

   do
   {
      if(*ip >= '0' && *ip <= '9')
      {
         temp *= 10;
         temp += *ip - '0';
      }
      if(*ip == '.' || *ip == 0 || *ip == ' ')
      {
	 if(temp > 255)
	 {
	    return 0;
	 }
         i++;
         result <<= 8;
         result |= temp;
         temp = 0;
      }
   } while(*ip != 0 && *ip++ != ' ');

   if(i == 4)
   {
      return result;
   }
   else
   {
      return 0;
   }
}

////////////////////////////////////////////////////////////////////////////////
// iptoa
// PURPOSE: Returns a static string with an IP address in dotted decimal
// PARAMS:  (IN) u32 addr - IP address
// RETURNS: pointer to static string
////////////////////////////////////////////////////////////////////////////////
char const *
iptoa(u32 addr)
{
   static char ipstring[17];

   // itoa doesn't null terminate the strings so do it now
   memset8(ipstring, 0, sizeof(ipstring));
   itoa((u8)((addr & 0xFF000000) >> 24), ipstring);
   ipstring[itc_strlen(ipstring)] = '.';
   itoa((u8)((addr & 0x00FF0000) >> 16), ipstring+itc_strlen(ipstring));
   ipstring[itc_strlen(ipstring)] = '.';
   itoa((u8)((addr & 0x0000FF00) >> 8), ipstring+itc_strlen(ipstring));
   ipstring[itc_strlen(ipstring)] = '.';
   itoa((u8)(addr), ipstring+itc_strlen(ipstring));
   return ipstring;
}

////////////////////////////////////////////////////////////////////////////////
// atoversion
// PURPOSE: Converts an ASCII dotted version quartet into 4 u8s.
// PARAMS:  (IN)  char *version - ASCII dotted quartet.
//          (OUT) u8 *major     - First number.
//          (OUT) u8 *minor     - Second number.
//          (OUT) u8 *build     - Third number.
//          (OUT) u8 *relinfo   - Fourth number.
// RETURNS: 1 for success, 0 for failure.
////////////////////////////////////////////////////////////////////////////////
int
atoversion(char const *version,
           u8 *major,
           u8 *minor,
           u8 *build,
           u8 *relinfo)
{
   u8 *current;
   int i = 0;
 
   current = major;
   *current = 0;

   do
   {
      if(*version >= '0' && *version <= '9')
      {
         *current *= 10;
         *current += *version - '0';
      }
      if(*version == '.')
      {
         if(current == major)
	 {
            current = minor;
	 }
         else if(current == minor)
	 {
            current = build;
	 }
         else if(current == build)
	 {
            current = relinfo;
	 }
         *current = 0;
         i++;
      }
   } while(*version++ != 0);

   return (i < 3 ? 0 : 1);
}

////////////////////////////////////////////////////////////////////////////////
// u8toa
// PURPOSE: Converts a u8 into its ASCII hexadecimal .
// PARAMS:  (IN)  u8 number    - number to convert.
//          (OUT) char *result - buffer to write ASCII to.
// RETURNS: Nothing.
////////////////////////////////////////////////////////////////////////////////
void
u8toa(u8 number,
      char *result)
{
   int digit, i;
 
   for(i = 4; i >= 0; i -= 4)
   {
      digit = (((0x0F << i) & number) >> i);
      if(digit < 10)
      {
         *result++ = '0' + digit;
      }
      else
      {
         *result++ = 'A' + digit - 10;
      }
   }
   *result = 0;
}

////////////////////////////////////////////////////////////////////////////////
// u16toa
// PURPOSE: Converts a u16 into its ASCII hexadecimal .
// PARAMS:  (IN)  u16 number   - number to convert.
//          (OUT) char *result - buffer to write ASCII to.
// RETURNS: Nothing.
////////////////////////////////////////////////////////////////////////////////
void
u16toa(u16 number,
       char *result)
{
   int digit, i;

   for(i = 12; i >= 0; i -= 4)
   {
      digit = (((0x000F << i) & number) >> i);
      if(digit < 10)
      {
         *result++ = '0' + digit;
      }
      else
      {
         *result++ = 'A' + digit - 10;
      }
   }
   *result = 0;
}

////////////////////////////////////////////////////////////////////////////////
// chopstr
// PURPOSE: Converts a string ending in a '\r' or '\n' into a null terminated
//          string.
// PARAMS:  (IN/OUT) char *string - string to chop.
// RETURNS: Nothing.
////////////////////////////////////////////////////////////////////////////////
void
chopstr(char *string)
{
   while(*string != 0)
   {
      if(*string == '\r' || *string == '\n')
      {
         *string = 0;
         break;
      }
      string++;
   }
}

////////////////////////////////////////////////////////////////////////////////
// atoi
// PURPOSE: Converts a decimal string into an int.
// PARAMS:  (IN)  char *number - decimal string to convert.
//          (OUT) int value    - resulting int.
// RETURNS: Number of characters converted.
////////////////////////////////////////////////////////////////////////////////
int
atoi(char const *number,
     int *value)
{
   int i = 0;

   *value = 0;

   while(*number >= '0' && *number <= '9')
   {
      *value *= 10;
      *value += *number - '0';
      number++;
      i++;
   }
   return i;
}

////////////////////////////////////////////////////////////////////////////////
// next_token
// PURPOSE: Skips to the first character of the next token.
// PARAMS:  char *string - string to parse.
// RETURNS: char * - pointer to offset in string.
////////////////////////////////////////////////////////////////////////////////
char const
*next_token(char const *string)
{
   if(*string == ':')
   {
      string++;
   }

   //skip to the next whitespace, skipping over backslash escaped characters
   while(*string != 0 && !(*string == ' ' || *string == ':'))
   {
      if (*string == '\\' && *(string+1))
      {
         string++;
      }
      string++;
   }

   //and pass it over
   while(*string != 0 && *string == ' ')
   {
      string++;
   }

   return string;
}