pub_ascbin.c

自已结累的Unix下C语言开发函数库

/*
 *bcd码和asc码之间转换的一些函数
 *zyq - shilyu - cff 0902
 *functionnum 007 
 */
 
#include "./../inc/pub.h"

#if !defined( DEBUG )
#define DEBUG
#endif

/*个数一定要是字节位数的整数倍*/
typedef struct {
        unsigned int    a : 1;
        unsigned int    b : 1;
        unsigned int    c : 1;
        unsigned int    d : 1;
        unsigned int    e : 1;
        unsigned int    f : 1;
        unsigned int    g : 1;
        unsigned int    h : 1;        
} bit_byte;

/*  001
 *len 为bcd_string 的长度 返回字符串的长度为len的2倍 
 *返回值为静态指针
 *这里的bcd其实是asc(0-256)其中有很多打印不出的字符 asc指的是将一个字符用16进制来表示
 */
char *Bcd2Ascii (char *bcd_string, int len) 
{
  static char	output_buffer[81];
  int	i;

  memset (output_buffer, 0x00, 81);
  len = ( len > ( sizeof ( output_buffer ) / 2 ) ) ? ( sizeof ( output_buffer ) / 2 ) : len ;
  for (i=0; i<len; i++)
    {
      sprintf (output_buffer + i * 2, "%02X", (unsigned char)bcd_string[i]);
    }

  return ( output_buffer);
}

/* 002
 * 将字符转换成2进制表示的字符串
 * 返回值为2进制字符串 example: 0x23 --> "00100011" 
 */
 
char *Char2Binary ( char my_byte)
{	
  static char	output_buffer[8+1];
  bit_byte	my_byte_bits;
  char *c ;
  
  c = ( char * )&my_byte_bits ;
  
  *c = my_byte ;
/*
  memcpy (&my_byte_bits, &my_byte, 1 );
*/
#ifdef DEBUG
  printf ("%02x %d %d %d %d %d %d %d %d\n", my_byte,
	my_byte_bits.a, my_byte_bits.b, my_byte_bits.c, my_byte_bits.d,
	my_byte_bits.e, my_byte_bits.f, my_byte_bits.g, my_byte_bits.h);
#endif

  /* 0x30 == '0' */
  output_buffer[0] = 0x30 | my_byte_bits.a;
  output_buffer[1] = 0x30 | my_byte_bits.b;
  output_buffer[2] = 0x30 | my_byte_bits.c;
  output_buffer[3] = 0x30 | my_byte_bits.d;
  output_buffer[4] = 0x30 | my_byte_bits.e;
  output_buffer[5] = 0x30 | my_byte_bits.f;
  output_buffer[6] = 0x30 | my_byte_bits.g;
  output_buffer[7] = 0x30 | my_byte_bits.h;

  return ( output_buffer ) ;
}

/* 003
 * 将字符转换成2进制表示的字符串
 * 返回值为2进制字符串 example: 0x23 --> "00100011" 
 */
 
char *S_Char2Binary( char byte ) 
{
	int i ;
   static unsigned char OutStr[ 8 ] ;
  
   memset( OutStr, 0x00, sizeof( OutStr ) ) ;
   i = 0 ;
   for( i=0; i<8; i++ )
   {
      if( ( ( 0x80 >> i ) & byte ) != 0 )
         OutStr[ i ] = '1' ;
      else
         OutStr[ i ] = '0' ;
   }

	return ( OutStr ) ;
}

/* 004
 * 将2进制的字符串转换成字符   example: "00100011" -> 0x23 
 */
unsigned char BinaryStr2Byte (char *binary_string)
{	
   unsigned char	my_byte_bits;
   int		i, len;
  
   len = (strlen (binary_string) < 8) ? strlen (binary_string) : 8;
   my_byte_bits = 0x00;
  
   for (i = 0; i < len; i ++)
   {      
      if (*(binary_string + (len - i - 1)) == '1')
      {
         my_byte_bits |= 0x80 >> (7-i);
      }
   }
   return (my_byte_bits);
}

/* 005
 * example: "AB" --> 0xAB 
 */
char AsciiByte2HexByte (char *asciibyte)
{	
  unsigned char	helf_byte[2];
  int		i;

  for (i = 0; i < 2; i ++)
    {
      switch ( *(asciibyte + i) )
	{
	  case '0':
	  case '1':
	  case '2':
	  case '3':
	  case '4':
	  case '5':
	  case '6':
	  case '7':
	  case '8':
	  case '9':
	    helf_byte[i] = *(asciibyte + i) - '0';
	    break;
	  case 'a':
	  case 'b':
	  case 'c':
	  case 'd':
	  case 'e':
	  case 'f':
	    helf_byte[i] = 0x0a + *(asciibyte + i) - 'a';
	    break;
	  case 'A':
	  case 'B':
	  case 'C':
	  case 'D':
	  case 'E':
	  case 'F':
	    helf_byte[i] = 0x0a + *(asciibyte + i) - 'A';
	    break;
	  default:
	    helf_byte[i] = 0x00;
	    break;
	}
    }

  return ((helf_byte[0] << 4) | helf_byte[1]);
}

/* 006
 * 将字符字符串转换在2进制字符串
 */
void String2BinaryStr ( source_string, target_string, len)
char *source_string ;  /* String                */
char *target_string ;  /* back string           */
int  len            ;  /* String 中要转换的 len */
{
  int	i;

  for (i = 0; i < len; i++)
    {
      memcpy( target_string + i * 8,
	           Char2Binary (*(source_string + i)), 8 ) ;
    }
}

/* 007
 * len为ascii_string的长度 返回的字符串长度为len的一半
 */ 
char *Ascii2Bcd (char *ascii_string, int len)
{
   static char	output_buffer[81];
   int	i;

   memset (output_buffer, 0x00, 81);
   for (i=0; i<len; i++)
   {
      output_buffer[i] = AsciiByte2HexByte (ascii_string + i * 2);
   }

  return (output_buffer);
}