cdez
08677204ca
+- Phase6_Prep.c +- StringUtils.c Note: Lev did things wrong using malloc in the videos. Corrections have been made. Wrong: malloc( sizeof( sourceStrLen + 1 ) ) Correct: malloc( sizeof(char) * (sourceStrLen + 1) ) This will correctly fix most of the dynamic memory allocation problems that will arise from programs described in the video.
454 lines
No EOL
14 KiB
C
454 lines
No EOL
14 KiB
C
// header files
|
|
#include "StringUtils.h"
|
|
|
|
// global constants
|
|
const int SUBSTRING_NOT_FOUND = 0;
|
|
|
|
// list of utils:
|
|
// string length
|
|
// getStringLength
|
|
// string copy
|
|
// copyString
|
|
// string concatenate
|
|
// catString
|
|
// string compare (<, >, =)
|
|
// compareString
|
|
// string substring get
|
|
// getSubString
|
|
// string substring find
|
|
// findSubString
|
|
// string set to lower
|
|
// toLowerCase
|
|
// string get to delimiter
|
|
// stringDelimiter
|
|
// string get to end of line
|
|
// stringEOL
|
|
|
|
// function implementations
|
|
|
|
/*
|
|
Name: catString
|
|
Process: concatenates two strings
|
|
Function input/parameters: c-style string (char *)
|
|
Function output/parameters: c-style string (char *)
|
|
Function output/returned: NONE
|
|
Device input/---: NONE
|
|
Device output/---: NONE
|
|
Dependencies: malloc, free, getStringLength
|
|
*/
|
|
void catString(char *outString, const char *inString)
|
|
{
|
|
// initialize variables
|
|
// set dest index
|
|
int destIndex = getStringLength(outString);
|
|
// set source str length
|
|
int sourceStrLen = getStringLength(inString);
|
|
// create temp string pointer
|
|
char *tempString;
|
|
int sourceIndex = 0;
|
|
|
|
// copy source string in case of aliasing
|
|
tempString = (char *)malloc(sizeof(char) * sourceStrLen);
|
|
copyString(tempString, inString);
|
|
|
|
// loop to end of source string
|
|
while(tempString[sourceIndex] != NULL_CHAR)
|
|
{
|
|
// assign characters to end of destination string
|
|
outString[destIndex] = inString[sourceIndex];
|
|
// update indices
|
|
destIndex = destIndex + 1;
|
|
sourceIndex = sourceIndex + 1;
|
|
}
|
|
// end loop to end of source string
|
|
// set temporary end of destination string
|
|
outString[destIndex] = NULL_CHAR;
|
|
|
|
// release memory used for temp string
|
|
free(tempString);
|
|
|
|
// no return, void.
|
|
}
|
|
|
|
/*
|
|
Name: compareString
|
|
Process: compares two strings as follows:
|
|
- if left string is alphabetically greater than the right string,
|
|
returns value greater than zero
|
|
- if left string is alphabetically less than the right string,
|
|
returns value less than zero
|
|
- if strings are alphabetically equal but one is longer,
|
|
longer one is greater
|
|
- otherwise, returns zero
|
|
Function input/parameters: c-style strings (char *) [first and second/left&right]
|
|
Function output/parameters: NONE
|
|
Function output/returned: results as specfifed above (int)
|
|
Device input/---: NONE
|
|
Device output/---: NONE
|
|
Dependencies: getStringLength
|
|
*/
|
|
int compareString(const char *firstString, const char *secondString)
|
|
{
|
|
// initialize variables
|
|
int diff, index = 0;
|
|
|
|
// loop to end of string (within bounds)
|
|
while(firstString[index] != NULL_CHAR && secondString[index] != NULL_CHAR)
|
|
{
|
|
// get diff of characters
|
|
diff = firstString[index] - secondString[index];
|
|
// check diff of characters
|
|
if(diff != 0)
|
|
{
|
|
// return diff
|
|
return diff;
|
|
}
|
|
// increment index
|
|
index = index + 1;
|
|
}
|
|
// end loop to end of string
|
|
|
|
// return difference in length of strings, if needed
|
|
return getStringLength(firstString) - getStringLength(secondString);
|
|
}
|
|
|
|
/*
|
|
Name: copyString
|
|
Process: copies string into new string variable, overwrites destination.
|
|
Function input/parameters: c-style string (char *)
|
|
Function output/parameters: c-style string (char *)
|
|
Function output/returned: NONE
|
|
Device input/---: NONE
|
|
Device output/---: NONE
|
|
Dependencies: getStringLength
|
|
*/
|
|
void copyString(char *outString, const char *inString)
|
|
{
|
|
// initialize variables
|
|
int index = 0;
|
|
|
|
// check to see if outString is not the same as inString.
|
|
if(outString != inString)
|
|
{
|
|
// loop to end of inString
|
|
while(inString[index] != NULL_CHAR)
|
|
{
|
|
// assign characters to end of outString
|
|
outString[index] = inString[index];
|
|
// increment index
|
|
index = index + 1;
|
|
}
|
|
// end loop to end of inString
|
|
// set end of the outString
|
|
outString[index] = NULL_CHAR;
|
|
}
|
|
|
|
// no return, void.
|
|
}
|
|
|
|
/*
|
|
Name: findSubString
|
|
Process: linear search for given substring within another string
|
|
Function input/parameters: c-style test string (char *),
|
|
c-style source string (char *)
|
|
Function output/parameters: NONE
|
|
Function output/returned: index of found substring, or
|
|
SUBSTRING_NOT_FOUND constant
|
|
if string not found
|
|
Device input/---: NONE
|
|
Device output/---: NONE
|
|
Dependencies: getStringLength
|
|
*/
|
|
int findSubString(const char *testStr, const char *searchSubStr)
|
|
{
|
|
// initialize variables
|
|
// initialize test string length
|
|
int testStrLength = getStringLength(testStr);
|
|
// initialize master index (location of substring start point)
|
|
int masterIndex = 0;
|
|
int searchIndex, internalIndex;
|
|
|
|
// loop across testStr
|
|
while(masterIndex < testStrLength)
|
|
{
|
|
// set internal loop index to current test string index
|
|
internalIndex = masterIndex;
|
|
// set internal search index to zero
|
|
searchIndex = 0;
|
|
// loop to end of testStr
|
|
// while testStr/searchSubStr characters are the same
|
|
while(internalIndex <= testStrLength &&
|
|
testStr[internalIndex] == searchSubStr[searchIndex])
|
|
{
|
|
// increment testStr and substring indices
|
|
internalIndex = internalIndex + 1;
|
|
searchIndex = searchIndex + 1;
|
|
// check for end of substring (search complete)
|
|
if(searchSubStr[searchIndex] == NULL_CHAR)
|
|
{
|
|
// return beginning location of substring
|
|
return masterIndex;
|
|
}
|
|
}
|
|
// end while testStr/searchSubStr characters are the same
|
|
// increment current location starting index
|
|
masterIndex = masterIndex + 1;
|
|
}
|
|
// end loop across testStr
|
|
|
|
// return SUBSTRING_NOT_FOUND
|
|
return SUBSTRING_NOT_FOUND;
|
|
}
|
|
|
|
/*
|
|
Name: getStringConstrained
|
|
Process: captures a string from the file stream with various constraints
|
|
Function input/parameters: input stream (FILE *),
|
|
clears leading non printable (bool),
|
|
clears leading space (bool),
|
|
stops at non printable (bool),
|
|
stops at specified delimiter (char)
|
|
will consume the delimiter.
|
|
Function output/parameters: c-style string (char *)
|
|
Function output/returned: success of operation (bool)
|
|
Device input/---: NONE
|
|
Device output/---: NONE
|
|
Dependencies: fgetc
|
|
*/
|
|
bool getStringConstrained(FILE *inStream, bool clearLeadingNonPrintable,
|
|
bool clearLeadingSpace, bool stopAtNonPrintable,
|
|
char delimiter, char *capString)
|
|
{
|
|
// initialize variables
|
|
int intChar = EOF, index = 0;
|
|
|
|
// initialize output string
|
|
capString[index] = NULL_CHAR;
|
|
// capture first value in stream using fgetc
|
|
intChar = fgetc(inStream);
|
|
// loop to clear non-printable or space if indicated
|
|
while((((intChar != EOF) &&
|
|
(clearLeadingNonPrintable && (intChar < (int)SPACE)))
|
|
|| (clearLeadingSpace && (intChar == (int)SPACE))))
|
|
{
|
|
// get next character in stream using fgetc
|
|
intChar = fgetc(inStream);
|
|
}
|
|
// end loop to clear non-printable or space if indicated
|
|
// check for end of file found
|
|
if(intChar == EOF)
|
|
{
|
|
// return false (failed)
|
|
return false;
|
|
}
|
|
// loop to get input from file stream
|
|
while(((intChar != EOF && index < MAX_STR_LEN - 1) &&
|
|
(stopAtNonPrintable && intChar >= (int)SPACE))
|
|
|| ((!stopAtNonPrintable) && (intChar != (char)delimiter)))
|
|
{
|
|
// [continues if not at end of file and max string len not reached ]
|
|
// [AND continues if not printable flag set and characters printable ]
|
|
// [OR continues if not printable flag not set ]
|
|
// [AND continues if specified delimited is not found ]
|
|
|
|
// place character in array element
|
|
capString[index] = (char)intChar;
|
|
// increment array index
|
|
index = index + 1;
|
|
// set next element to null character
|
|
capString[index] = NULL_CHAR;
|
|
// get next character as integer using fgetc
|
|
intChar = fgetc(inStream);
|
|
}
|
|
// end loop to get input from file stream
|
|
// return success
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
Name: getStringLength
|
|
Process: gets length of string from start to NULL_CHAR ('\0')
|
|
Function input/parameters: c-style string (char *)
|
|
Function output/parameters: NONE
|
|
Function output/returned: length of string (int)
|
|
Device input/---: NONE
|
|
Device output/---: NONE
|
|
Dependencies: included by standard libraries
|
|
*/
|
|
int getStringLength(const char *stringIn)
|
|
{
|
|
// define variables
|
|
int stringLength = 0, currentCharacter = 0;
|
|
// get user input (not needed)
|
|
// do calculations
|
|
while (currentCharacter < STD_STR_LEN && stringIn[currentCharacter] != NULL_CHAR)
|
|
{
|
|
// increment string length
|
|
stringLength = stringLength + 1;
|
|
// increment currentCharacter
|
|
currentCharacter = currentCharacter + 1;
|
|
}
|
|
// display results (not needed)
|
|
// return success
|
|
return stringLength;
|
|
}
|
|
|
|
/*
|
|
Name: getStringToDelimiter
|
|
Process: captures a string from the input stream to a specified delimiter.
|
|
will consume the delimiter.
|
|
Function input/parameters: input stream (FILE *),
|
|
stops at specified character
|
|
Function output/parameters: c-style string (char *)
|
|
Function output/returned: success of operation (bool)
|
|
Device input/---: NONE
|
|
Device output/---: NONE
|
|
Dependencies: getStringConstrained
|
|
*/
|
|
bool getStringToDelimiter(FILE *inStream, char delimiter, char *capString)
|
|
{
|
|
// use getStringConstrained with delimiter to get string
|
|
return getStringConstrained(inStream, true, true, true, delimiter, capString);
|
|
}
|
|
|
|
/*
|
|
Name: getStringToLineEnd
|
|
Process: captures a string from the input stream to the end of the line
|
|
Function input/parameters: input file stream (FILE *)
|
|
Function output/parameters: c-style string (char *)
|
|
Function output/returned: success of operation (bool)
|
|
Device input/---: NONE
|
|
Device output/---: NONE
|
|
Dependencies: getStringConstrained
|
|
*/
|
|
bool getStringToLineEnd(FILE *inStream, char *capString)
|
|
{
|
|
// use getStringConstrained with line end character to get string
|
|
return getStringConstrained(inStream, true, true, true, '\n', capString);
|
|
}
|
|
|
|
/*
|
|
Name: getSubString
|
|
Process: captures sub string within larger string
|
|
between two inclusive indices.
|
|
returns empty string if either index is out of range,
|
|
assumes enough memory in dest string
|
|
Function input/parameters: c-style string (char *)
|
|
start and end indices (int)
|
|
Function output/parameters: c-style destination string (char *)
|
|
Function output/returned: NONE
|
|
Device input/---: NONE
|
|
Device output/---: NONE
|
|
Dependencies: getStringLength, malloc, copyString, free
|
|
*/
|
|
void getSubString(char *destStr, const char *sourceStr,
|
|
int startIndex, int endIndex)
|
|
{
|
|
// initialize variables
|
|
// set length of source string using getStringLength
|
|
int sourceStrLen = getStringLength(sourceStr);
|
|
// initialize the destination index to zero
|
|
int destIndex = 0;
|
|
// initialize source index to start index (parameter)
|
|
int sourceIndex = startIndex;
|
|
// create pointer for temp string
|
|
char *tempStr;
|
|
|
|
// check for indices within limits
|
|
if(startIndex >= 0 && startIndex <= endIndex && endIndex < sourceStrLen)
|
|
{
|
|
// create temp string using malloc and copyString
|
|
tempStr = (char *)malloc(sourceStrLen + 1);
|
|
copyString(tempStr, sourceStr);
|
|
// loop across requested substring indices
|
|
while(sourceIndex <= endIndex)
|
|
{
|
|
// assign source character to destination element
|
|
destStr[destIndex] = tempStr[sourceIndex];
|
|
// increment indices
|
|
destIndex = destIndex + 1;
|
|
sourceIndex = sourceIndex + 1;
|
|
// set temporary end of destination string
|
|
destStr[destIndex] = NULL_CHAR;
|
|
}
|
|
// end loop across requested substring indices
|
|
// free temp string
|
|
free(tempStr);
|
|
}
|
|
|
|
// no return, void.
|
|
}
|
|
|
|
/*
|
|
Name: strToLowerCase
|
|
Process: iterates through string, sets any uppercase letter to lowercase
|
|
equivalent, does not affect any letter with an upper/lower diff.
|
|
Function input/parameters: c-style source string (char *)
|
|
Function output/parameters: c-style dest string (char *)
|
|
Function output/returned: NONE
|
|
Device input/---: NONE
|
|
Device output/---: NONE
|
|
Dependencies: toLowerCase
|
|
*/
|
|
void strToLowerCase(char *outString, const char *inString)
|
|
{
|
|
// initialize variables
|
|
// get source string length
|
|
int sourceStrLen = getStringLength(inString);
|
|
// create temporary string pointer
|
|
char *tempStr;
|
|
int index = 0;
|
|
|
|
// copy source string in case of aliasing using malloc and copyString
|
|
tempStr = (char *)malloc((sizeof(char) * (sourceStrLen + 1)));
|
|
copyString(tempStr, inString);
|
|
// loop across source string
|
|
while(tempStr[index] != NULL_CHAR && index < MAX_STR_LEN)
|
|
{
|
|
// set individual character to lowercase as needed, assigning back
|
|
outString[index] = toLowerCase(tempStr[index]);
|
|
// update index
|
|
index = index + 1;
|
|
// set temporary end of destination string
|
|
outString[index] = NULL_CHAR;
|
|
}
|
|
// end loop across source string
|
|
// free temporary string
|
|
free(tempStr);
|
|
|
|
// no return, void.
|
|
}
|
|
|
|
/*
|
|
Name: toLowerCase
|
|
Process: sets character to lowercase letter if uppercase letter,
|
|
returns character
|
|
Function input/parameters: character input (char)
|
|
Function output/parameters: NONE
|
|
Function output/returned: character output (char)
|
|
Device input/---: NONE
|
|
Device output/---: NONE
|
|
Dependencies: none
|
|
*/
|
|
char toLowerCase(char testChar)
|
|
{
|
|
// check for uppercase letter
|
|
if(testChar >= 'A' && testChar <= 'Z')
|
|
{
|
|
// return lowercase letter
|
|
return testChar - 'A' + 'a';
|
|
}
|
|
// otherwise, assume not uppercase letter, return unchanged
|
|
return testChar;
|
|
}
|
|
|
|
/*
|
|
Name: ???
|
|
Process: ???
|
|
Function input/parameters: ???
|
|
Function output/parameters: NONE
|
|
Function output/returned: ???
|
|
Device input/---: NONE
|
|
Device output/---: NONE
|
|
Dependencies: included by standard libraries
|
|
*/ |