shared_source/c_datd/strfuncs.c

//$Header$
//-------------------------------------------------------------------------------------------------
//This file is part of "David T. Ashley's Shared Source Code", a set of shared components
//integrated into many of David T. Ashley's projects.
//-------------------------------------------------------------------------------------------------
//This source code and any program in which it is compiled/used is provided under the MIT License,
//reproduced below.
//-------------------------------------------------------------------------------------------------
//Permission is hereby granted, free of charge, to any person obtaining a copy of
//this software and associated documentation files(the "Software"), to deal in the
//Software without restriction, including without limitation the rights to use,
//copy, modify, merge, publish, distribute, sublicense, and / or sell copies of the
//Software, and to permit persons to whom the Software is furnished to do so,
//subject to the following conditions :
//
//The above copyright notice and this permission notice shall be included in all
//copies or substantial portions of the Software.
//
//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
//SOFTWARE.
//-------------------------------------------------------------------------------------------------
#define MODULE_STRFUNCS

#include <string.h>

#include "strfuncs.h"


//Converts from an unsigned char quantity to a hexadecimal digit, with
//upper-case/lower-case option.  Only the lowest four bits are considered.
DECMOD_STRFUNCS 
char Strfuncs_NibbleToHexadecimalChar(unsigned char arg, int use_upper_case)
   {
   char rv;

   switch (arg & 0x0F)
      {
      case  0:
         rv = '0';
         break;
      case  1:
         rv = '1';
         break;
      case  2:
         rv = '2';
         break;
      case  3:
         rv = '3';
         break;
      case  4:
         rv = '4';
         break;
      case  5:
         rv = '5';
         break;
      case  6:
         rv = '6';
         break;
      case  7:
         rv = '7';
         break;
      case  8: 
         rv = '8';
         break;
      case  9:
         rv = '9';
         break;
      case 10:
         rv = 'A';
         break;
      case 11:
         rv = 'B';
         break;
      case 12:
         rv = 'C';
         break;
      case 13:
         rv = 'D';
         break;
      case 14:
         rv = 'E';
         break;
      case 15:
         rv = 'F';
         break;
      }

   //If upper-case is not desired, convert to lower.
   if (!use_upper_case && (rv >= 'A'))
      rv += ('a'-'A');

   return(rv);
   }


//Given a single unsigned long number, assigns eight consecutive characters of a 
//string to be the hexadecimal digits of the number.  The eight characters must
//already be allocated in the caller's area.  An option is provided to use
//upper-case or lower-case.  The caller is responsible for null termination.
DECMOD_STRFUNCS
void Strfuncs_UlToHexString(unsigned long num,
                            char *output,
                            int use_upper_case)
   {
   unsigned i;

   for (i=0; i<8; i++)
      {
      output[7-i] = Strfuncs_NibbleToHexadecimalChar((unsigned char)num, use_upper_case);
      num >>= 4;
      }
   }


//Returns true if substr is a substring of arg.  An empty string is a substring
//of anything except a NULL pointer, and a NULL pointer is a substring of
//anything.
DECMOD_STRFUNCS 
int Strfuncs_IsSubstring(const char *substr, const char *arg)
   {
   size_t i;

   if (!substr)
      {
      return(1);
      //A NULL pointer is a substring of anything.
      }

   if (!arg)
      {
      return(0);
      //arg is NULL but substr is not, no substring.
      }

   //Will not be here unless both pointers are valid.  These are the
   //non-degenerate cases.
   i = 0;
   while(1)
      {
      if (!substr[i])
         {
         return(1);
         //Ran out of substr chars before arg chars.  Is a substring.
         }
      if (!arg[i])
         {
         return(0);
         //Ran out of arg characters with substr chars still remaining.
         //Definitely not a substring.
         }
      //Have exhausted neither string.  Not a substring if lack of equality.
      if (substr[i] != arg[i])
         {
         return(0);
         //Definitely not a substring.
         }

      //Can't make a determination.  Advance to next character.
      i++;
      }
   }


//Returns version control string for file.
//
DECMOD_STRFUNCS
const char *StrfuncsCversion(void)
{   
    return ("$Header$");
}


//Returns version control string for associated .H file.
//
DECMOD_STRFUNCS
const char *StrfuncsHversion(void)
{   
    return (STRFUNCS_H_VERSION);
}

//End of strfuncs.c.
1	dashley	56	//$Header$
2	dashley	25	//-------------------------------------------------------------------------------------------------
3	dashley	56	//This file is part of "David T. Ashley's Shared Source Code", a set of shared components
4			//integrated into many of David T. Ashley's projects.
5	dashley	25	//-------------------------------------------------------------------------------------------------
6	dashley	56	//This source code and any program in which it is compiled/used is provided under the MIT License,
7			//reproduced below.
8			//-------------------------------------------------------------------------------------------------
9			//Permission is hereby granted, free of charge, to any person obtaining a copy of
10			//this software and associated documentation files(the "Software"), to deal in the
11			//Software without restriction, including without limitation the rights to use,
12			//copy, modify, merge, publish, distribute, sublicense, and / or sell copies of the
13			//Software, and to permit persons to whom the Software is furnished to do so,
14			//subject to the following conditions :
15	dashley	25	//
16	dashley	56	//The above copyright notice and this permission notice shall be included in all
17			//copies or substantial portions of the Software.
18	dashley	25	//
19	dashley	56	//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20			//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21			//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
22			//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23			//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24			//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
25			//SOFTWARE.
26	dashley	25	//-------------------------------------------------------------------------------------------------
27			#define MODULE_STRFUNCS
28
29			#include <string.h>
30
31			#include "strfuncs.h"
32
33
34			//Converts from an unsigned char quantity to a hexadecimal digit, with
35			//upper-case/lower-case option. Only the lowest four bits are considered.
36			DECMOD_STRFUNCS
37			char Strfuncs_NibbleToHexadecimalChar(unsigned char arg, int use_upper_case)
38			{
39			char rv;
40
41			switch (arg & 0x0F)
42			{
43			case 0:
44			rv = '0';
45			break;
46			case 1:
47			rv = '1';
48			break;
49			case 2:
50			rv = '2';
51			break;
52			case 3:
53			rv = '3';
54			break;
55			case 4:
56			rv = '4';
57			break;
58			case 5:
59			rv = '5';
60			break;
61			case 6:
62			rv = '6';
63			break;
64			case 7:
65			rv = '7';
66			break;
67			case 8:
68			rv = '8';
69			break;
70			case 9:
71			rv = '9';
72			break;
73			case 10:
74			rv = 'A';
75			break;
76			case 11:
77			rv = 'B';
78			break;
79			case 12:
80			rv = 'C';
81			break;
82			case 13:
83			rv = 'D';
84			break;
85			case 14:
86			rv = 'E';
87			break;
88			case 15:
89			rv = 'F';
90			break;
91			}
92
93			//If upper-case is not desired, convert to lower.
94			if (!use_upper_case && (rv >= 'A'))
95			rv += ('a'-'A');
96
97			return(rv);
98			}
99
100
101			//Given a single unsigned long number, assigns eight consecutive characters of a
102			//string to be the hexadecimal digits of the number. The eight characters must
103			//already be allocated in the caller's area. An option is provided to use
104			//upper-case or lower-case. The caller is responsible for null termination.
105			DECMOD_STRFUNCS
106			void Strfuncs_UlToHexString(unsigned long num,
107			char *output,
108			int use_upper_case)
109			{
110			unsigned i;
111
112			for (i=0; i<8; i++)
113			{
114			output[7-i] = Strfuncs_NibbleToHexadecimalChar((unsigned char)num, use_upper_case);
115			num >>= 4;
116			}
117			}
118
119
120			//Returns true if substr is a substring of arg. An empty string is a substring
121			//of anything except a NULL pointer, and a NULL pointer is a substring of
122			//anything.
123			DECMOD_STRFUNCS
124			int Strfuncs_IsSubstring(const char substr, const char arg)
125			{
126			size_t i;
127
128			if (!substr)
129			{
130			return(1);
131			//A NULL pointer is a substring of anything.
132			}
133
134			if (!arg)
135			{
136			return(0);
137			//arg is NULL but substr is not, no substring.
138			}
139
140			//Will not be here unless both pointers are valid. These are the
141			//non-degenerate cases.
142			i = 0;
143			while(1)
144			{
145			if (!substr[i])
146			{
147			return(1);
148			//Ran out of substr chars before arg chars. Is a substring.
149			}
150			if (!arg[i])
151			{
152			return(0);
153			//Ran out of arg characters with substr chars still remaining.
154			//Definitely not a substring.
155			}
156			//Have exhausted neither string. Not a substring if lack of equality.
157			if (substr[i] != arg[i])
158			{
159			return(0);
160			//Definitely not a substring.
161			}
162
163			//Can't make a determination. Advance to next character.
164			i++;
165			}
166			}
167
168
169			//Returns version control string for file.
170			//
171			DECMOD_STRFUNCS
172			const char *StrfuncsCversion(void)
173			{
174	dashley	56	return ("$Header$");
175	dashley	25	}
176
177
178			//Returns version control string for associated .H file.
179			//
180			DECMOD_STRFUNCS
181			const char *StrfuncsHversion(void)
182			{
183			return (STRFUNCS_H_VERSION);
184			}
185
186	dashley	56	//End of strfuncs.c.