home *** CD-ROM | disk | FTP | other *** search
/ Boldly Go Collection / version40.iso / TS / 17A / DRWIN101.ZIP / DRSTR.CPP < prev    next >
C/C++ Source or Header  |  1991-12-06  |  8KB  |  212 lines
  1. #include <string.h>
  2.  
  3. #include "drstr.hpp"
  4.  
  5.  
  6. char hexadecimal_table[] = "0123456789ABCDEF?";
  7.  
  8.  
  9. //===========================================================================
  10. //  strNcpy (char*,char*,int)
  11. //  Does a strncpy(), but always inserts the terminator.
  12. //  If destination_length is 0, length-checking is not performed.
  13. //---------------------------------------------------------------------------
  14. void strNcpy(                  //no output
  15.   char* destination,           //destination string
  16.   char* source,                //source string to copy
  17.   int destination_length)      //maximum length of destination, with nul
  18. {
  19.   if (destination_length--) {
  20.     strncpy(destination, source, destination_length);
  21.     destination[destination_length]=0;
  22.   }
  23.   else
  24.     strcpy(destination, source);
  25. }   //strNcpy
  26.  
  27.  
  28. //===========================================================================
  29. //  digval (char)
  30. //  Converts a character as a digit into an integer.  Digit characters are
  31. //  assumed to run from '0' to '9' and then from 'A' to 'Z'.  Lowercase
  32. //  and uppercase are assumed to be equivalent.  Legal return values are
  33. //  0 through 35, with 36 indicating an unrecognized digit.
  34. //---------------------------------------------------------------------------
  35. int  inline digval(            //value of digit-character, 0-35, 36 on error
  36.   char c)                      //character to convert as a digit
  37. {
  38.   if ((c >= '0') && (c <= '9')) return c - '0';
  39.   if ((c >= 'A') && (c <= 'Z')) return c - 'A' + 10;
  40.   if ((c >= 'a') && (c <= 'z')) return c - 'a' + 10;
  41.   return ('Z' - 'A' + 10) + 1;
  42. }   //digval
  43.  
  44.  
  45. //===========================================================================
  46. //  strcchr (char*,char*)
  47. //  Converts a c-style (\-notation) string into a single character.  Only
  48. //  one destination character is produced, but multiple source characters
  49. //  may be used to generate it.
  50. //  Returns a pointer to the next character in the source string.
  51. //---------------------------------------------------------------------------
  52. char* strcchr(                 //next character to be converted
  53.   char* d,                     //destination string
  54.   char* s)                     //source string
  55. {
  56.   int n = 0;                   //current value during base conversion
  57.   int dig = 0;                 //value of current digit
  58.   int base = 8;                //base for conversion
  59.   char c;                      //current character
  60.  
  61.   c=*s++;
  62.   if (c!='\\') {                       //if not a special char
  63.     *d=c;                              //..just copy it
  64.     return s;                          //..and quit
  65.   }   //if not escape char
  66.  
  67.   c=*s++;
  68.   switch (c) {
  69.   case 0:    *d=0x5C; s--; return s;   //\-terminated string, leave in
  70.   case 'a':  *d=0x07; return s;        //special chars...
  71.   case 'b':  *d=0x08; return s;
  72.   case 't':  *d=0x09; return s;
  73.   case 'n':  *d=0x0A; return s;
  74.   case 'v':  *d=0x0B; return s;
  75.   case 'f':  *d=0x0C; return s;
  76.   case 'r':  *d=0x0D; return s;
  77.   case 'e':  *d=0x1B; return s;        //extension to the standard (<ESC>)
  78.   case '\"': *d=0x22; return s;
  79.   case '\'': *d=0x27; return s;
  80.   case '\\': *d=0x5C; return s;
  81.   default:
  82.     if      ((c=='x')||(c=='X')) { n=0;     dig=0; base=16; }
  83.     else if ((c=='d')||(c=='D')) { n=0;     dig=0; base=10; }
  84.     else if ((c>='0')&&(c<='7')) { n=c-'0'; dig=1; base=8; }
  85.     else { *d=c;  return s; }          //ignore ill-used \ char
  86.   }   /*switch*/
  87.  
  88.   while (dig<3) {
  89.     c=digval(*s++);
  90.     if (c<base) {
  91.       n = n*base + c;
  92.       dig++;
  93.     }
  94.     else {
  95.       s--;
  96.       break;
  97.     }   //if base 16
  98.   }   //while
  99.   if (dig)
  100.     *d = n;
  101.   else {
  102.     s--;
  103.     *d = *s++;
  104.   }
  105.   return s;
  106. }   //strcchr
  107.  
  108.  
  109. //===========================================================================
  110. //  strcstr (char*,char*,int)
  111. //  Converts a c-style (\-notation) source string into a binary destination
  112. //  string.
  113. //  Returns the number of characters in the destination string.
  114. //  If maxn is 0, length-checking is not performed on the destination.
  115. //  A terminator is placed in the destination string.
  116. //---------------------------------------------------------------------------
  117. int strcstr(                   //number of characters in destination string
  118.   char *d,                     //destination string
  119.   char *s,                     //source c-style string
  120.   int maxn)                    //max length of destination, including nul
  121. {
  122.   int i=0;
  123.   if (maxn--)                          //reduce by 1 for terminator
  124.     while (*s && (i<maxn)) s=strcchr(&d[i++],s);
  125.   else
  126.     while (*s) s=strcchr(&d[i++],s);
  127.   d[i]=0;
  128.   return i;
  129. }   /*strcstr*/
  130.  
  131.  
  132. //===========================================================================
  133. //  chrtocstr (char*,int)
  134. //  Converts a binary character into a c-style (\-notation) string.
  135. //  The destination string should be able to hold at least 5 characters.
  136. //  The terminator (nul) is placed on the destination string.
  137. //---------------------------------------------------------------------------
  138. int  chrtocstr(                //number of characters in result string
  139.   char* destination,           //destination string space
  140.   char character)              //character to be converted
  141. {
  142.   int n = 0;
  143.   unsigned char unsigned_char = (unsigned char) character;
  144.  
  145.   if ((unsigned_char < 0x20) || (unsigned_char > 0x7E))
  146.   {
  147.     switch (unsigned_char) {
  148.     case 0x07: destination[n++] = '\\';  destination[n++] = 'a';  break;
  149.     case 0x08: destination[n++] = '\\';  destination[n++] = 'b';  break;
  150.     case 0x09: destination[n++] = '\\';  destination[n++] = 't';  break;
  151.     case 0x0A: destination[n++] = '\\';  destination[n++] = 'n';  break;
  152.     case 0x0B: destination[n++] = '\\';  destination[n++] = 'v';  break;
  153.     case 0x0C: destination[n++] = '\\';  destination[n++] = 'f';  break;
  154.     case 0x0D: destination[n++] = '\\';  destination[n++] = 'r';  break;
  155.     default:
  156.       destination[n++] = '\\';
  157.       destination[n++] = 'x';
  158.       destination[n++] = HEX1(unsigned_char);
  159.       destination[n++] = HEX0(unsigned_char);
  160.     }   //switch on nonprintables
  161.   }
  162.   else
  163.   {
  164.     switch (unsigned_char)
  165.     {
  166.     case 0x22: destination[n++] = '\\';  destination[n++] = '\"';  break;
  167.     case 0x27: destination[n++] = '\\';  destination[n++] = '\'';  break;
  168.     case 0x5C: destination[n++] = '\\';  destination[n++] = '\\';  break;
  169.     default:
  170.       destination[n++] = character;
  171.     }   //switch on printables
  172.   }
  173.  
  174.   return n;
  175. }   //chrtocstr
  176.  
  177.  
  178. //===========================================================================
  179. //  strtocstr (char*,int,char*,int)
  180. //  Converts a string from binary character data into c-style \-notation.
  181. //  If destination_length is 0, length-checking is not performed.
  182. //---------------------------------------------------------------------------
  183. int  strtocstr(                //number of source characters converted
  184.   char* destination,           //destination string space
  185.   int destination_length,      //maximum length allowed including terminator
  186.   char* source,                //source string for the conversion
  187.   int source_length)           //number of characters to convert from source
  188. {
  189.   static char one_char_converted[8];  //local copy of a single conversion
  190.   int length_of_conversion = 0;       //length of single conversion
  191.   int source_index;                   //index into source string
  192.   int destination_index = 0;          //index into destination string
  193.  
  194.   if (destination_length == 0)
  195.     destination_length = 0x7ffe - 8;  //leave room for comparisons
  196.   else
  197.     destination_length--;
  198.  
  199.   for (source_index = 0; (source_index < source_length); source_index++)
  200.   {
  201.     length_of_conversion = chrtocstr(one_char_converted, source[source_index]);
  202.     if ((destination_index + length_of_conversion) > destination_length)
  203.       break;
  204.     strcpy(&destination[destination_index], one_char_converted);
  205.     destination_index += length_of_conversion;
  206.   }   //for each source character
  207.  
  208.   destination[destination_index] = 0;
  209.   return source_index;
  210. }   //strtocstr
  211.  
  212.