cdez/CS249-Projects
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Compare commits

base: cdez:91b6fc42d5992e4eec738ae686a1c6294145fbc8
Branches Tags
cdez:main
..
compare: cdez:3fe1820844855934affeb41899930aa05b8dff17
Branches Tags
cdez:main

No commits in common. "91b6fc42d5992e4eec738ae686a1c6294145fbc8" and "3fe1820844855934affeb41899930aa05b8dff17" have entirely different histories.
91b6fc42d5 ... 3fe1820844

18 changed files with 13 additions and 3768 deletions
Download patch file Download diff file Expand all files Collapse all files

278
PA01-0906/EncryptionUtility.c
View file

@ -84,47 +84,6 @@ Dependencies: as needed
*/ */
void decryptData( char *decryptStr, SquareArrayType *data ) void decryptData( char *decryptStr, SquareArrayType *data )
{ {
// opposite the encrypt data.
// extract the size data from the array
int arraySizeData = data->sideSize;
// iterate through the array
int oneDimensionIndex;
int twoDimensionIndex;
int differenceIndex;
int currentCharacter = 0;
int stringComplete = 0;
for(oneDimensionIndex = arraySizeData * 2; oneDimensionIndex >= 0;
oneDimensionIndex--)
{
// does one dimensional indices
for(twoDimensionIndex = oneDimensionIndex; twoDimensionIndex >= 0;
twoDimensionIndex--)
{
// does two dimensional indices
differenceIndex = oneDimensionIndex - twoDimensionIndex;
if(differenceIndex < arraySizeData && twoDimensionIndex < arraySizeData)
{
// second dimension to move through array
if(stringComplete == 0)
{
if(data->array[twoDimensionIndex][differenceIndex] ==
UNPRINTABLE_CHAR_VALUE)
{
// check for the unprintable character
decryptStr[currentCharacter] = NULL_CHAR;
stringComplete = 1;
}
else
{
// put the character into the string.
decryptStr[currentCharacter] =
data->array[twoDimensionIndex][differenceIndex];
currentCharacter = currentCharacter + 1;
}
}
}
}
}
// no return. // no return.
} }
@ -142,40 +101,6 @@ Notes: Does not handle empty square data type condition
*/ */
void displayArray( const SquareArrayType data, ControlCode ctrlCode ) void displayArray( const SquareArrayType data, ControlCode ctrlCode )
{ {
int arraySize = data.sideSize;
int oneDimensionIndex = 0, twoDimensionIndex = 0;
// check the control code, branch to the respective path.
// iterate through the array, one character at a time.
// get the side size from the array,
// iterate that number of times, then output a new line.
if(ctrlCode == DISPLAY_CHARS)
{
for(oneDimensionIndex = 0; oneDimensionIndex < arraySize;
oneDimensionIndex++)
{
for(twoDimensionIndex = 0; twoDimensionIndex < arraySize;
twoDimensionIndex++)
{
printCharacter((char)data.array[oneDimensionIndex][twoDimensionIndex]);
printCharacter(SPACE);
}
printEndline();
}
}
else
{
for(oneDimensionIndex = 0; oneDimensionIndex < arraySize;
oneDimensionIndex++)
{
for(twoDimensionIndex = 0; twoDimensionIndex < arraySize;
twoDimensionIndex++)
{
printInteger((int)data.array[oneDimensionIndex][twoDimensionIndex]);
printCharacter(SPACE);
}
printEndline();
}
}
// no return. // no return.
} }
/* /*
@ -192,59 +117,6 @@ Dependencies: as needed, File_Output_Utility tools
*/ */
void downloadData( const char *fileName, const SquareArrayType data ) void downloadData( const char *fileName, const SquareArrayType data )
{ {
bool fileOpenCheck;
int oneDimensionIndex, twoDimensionIndex;
int currentData;
int checkDigits, tempDigits;
// open file.
fileOpenCheck = openOutputFile(fileName);
// write file.
if(fileOpenCheck)
{
// write the size of the array as the first character.
writeIntegerToFile(data.sideSize);
// write a new line
writeEndlineToFile();
// iterate through array outputting each integer.
for(oneDimensionIndex = 0; oneDimensionIndex < data.sideSize;
oneDimensionIndex++)
{
//
for(twoDimensionIndex = 0; twoDimensionIndex < data.sideSize;
twoDimensionIndex++)
{
//
currentData = data.array[oneDimensionIndex][twoDimensionIndex];
// check to see if the integer is two digits, if it is, add a 0 before.
checkDigits = 1;
tempDigits = currentData;
while(tempDigits > 9)
{
tempDigits = tempDigits / 10;
checkDigits = checkDigits + 1;
}
if(checkDigits == 2)
{
writeCharacterToFile(ZERO_CHAR);
writeIntegerToFile(currentData);
}
else
{
writeIntegerToFile(currentData);
}
writeCharacterToFile(SPACE);
}
writeEndlineToFile();
}
}
else
{
// if the file doesn't open, notify the user.
printf("\nThe file either doesn't exist,"
"or you do not have permission to access it.\n");
}
// close file.
closeOutputFile();
// no return. // no return.
} }
@ -263,59 +135,8 @@ Dependencies: as needed, including findStringLength, findSquareRoot,
*/ */
SquareArrayType *encryptData( const char *toEncrypt ) SquareArrayType *encryptData( const char *toEncrypt )
{ {
// get length of string (store in variable)
int stringLen = findStringLength(toEncrypt);
// create the array (get the square root, add one,
// then call the function to make a square array.)
int stringLenRoot = findSquareRoot(stringLen) + 1;
SquareArrayType *encryptedData = createArrayType(stringLenRoot);
// iterate through the array (backwards, diagonally)
int oneDimensionIndex;
int twoDimensionIndex;
int differenceIndex;
int currentCharacter = 0;
for(oneDimensionIndex = stringLenRoot * 2; oneDimensionIndex >= 0;
oneDimensionIndex--)
{
// does one dimensional indices
for(twoDimensionIndex = oneDimensionIndex; twoDimensionIndex >= 0;
twoDimensionIndex--)
{
// does two dimensional indices
differenceIndex = oneDimensionIndex - twoDimensionIndex;
if(differenceIndex < stringLenRoot && twoDimensionIndex < stringLenRoot)
{
// second dimension to move through array
if(currentCharacter >= stringLen)
{
if(currentCharacter == stringLen)
{
// if the null character is there,
// replace with the Unprintable, set flag to one.
encryptedData->array[twoDimensionIndex][differenceIndex] =
UNPRINTABLE_CHAR_VALUE;
}
else
{
// if not the null, put random data into array
encryptedData->array[twoDimensionIndex][differenceIndex] =
getRandomLetterValue();
}
}
else
{
// otherwise, continue putting the data into the 2d array.
encryptedData->array[twoDimensionIndex][differenceIndex] =
toEncrypt[currentCharacter];
}
currentCharacter = currentCharacter + 1;
}
}
}
// once null character is reached, put the 'unprintable character'
// then random data afterward.
// returns a Square Array. // returns a Square Array.
return encryptedData; return NULL;
} }
/* /*
@ -331,47 +152,8 @@ Dependencies: as needed (library utilities may not be used)
*/ */
double findSquareRoot( int value ) double findSquareRoot( int value )
{ {
// declare, define variables as needed // returns a double.
return 0.0;
// set lower value to zero, upper value to the original value
double lowerValue = 0, upperValue = value;
// set middle value between the lower and upper values
double middleValue = ( lowerValue + upperValue ) / 2.0;
// calculate the initial temporary value
double tempResult = middleValue * middleValue;
// loop while absolute difference between test value and original value
// is greater than the specified precision
// function: abs, from stdlib.h
while( abs( tempResult - value ) > SQRT_PRECISION )
{
// test for the temporary result to be greater than the original value
if( tempResult > value )
{
// set the upper value to the middle value
upperValue = middleValue;
}
// otherwise, assume the temporary result is less than the original value
else
{
// set the lower value to the middle value
lowerValue = middleValue;
}
// end test
// recalculate middle value
middleValue = ( lowerValue + upperValue ) / 2.0;
// recalculate the temporary result
tempResult = middleValue * middleValue;
}
// end loop
// return middle value
return middleValue;
} }
/* /*
@ -386,15 +168,8 @@ Dependencies: as needed (library utilities may not be used)
*/ */
int findStringLength( const char *str ) int findStringLength( const char *str )
{ {
// needs to iterate through the 'string' checking if the character is NULL. // returns an integer.
// if character not null, add one to count. return 0;
int index = 0;
while(str[index] != NULL_CHAR)
{
index = index + 1;
}
// returns an integer count of the number of characters.
return index;
} }
/* /*
@ -410,13 +185,8 @@ Dependencies: as needed, including rand
*/ */
int getRandomLetterValue() int getRandomLetterValue()
{ {
int currentRand = 0;
// generate random number between 1 and 52
currentRand = rand() % (NUM_ALPHABET_LETTERS + 1) + 1;
// then get the integer that character corresponds to and return it.
int letterInt = (int)ALPHABET[currentRand];
// returns an integer. // returns an integer.
return letterInt; return 0;
} }
/* /*
@ -432,40 +202,6 @@ Dependencies: as needed, File_Input_Utility tools
*/ */
SquareArrayType *uploadData( const char *fileName ) SquareArrayType *uploadData( const char *fileName )
{ {
bool fileOpenCheck;
int arraySizeFile;
int oneDimensionIndex, twoDimensionIndex;
SquareArrayType *readArray;
// open file.
fileOpenCheck = openInputFile(fileName);
// read file.
if(fileOpenCheck)
{
// read the size of the array as the first character.
arraySizeFile = readIntegerFromFile();
// create the square array
readArray = createArrayType(arraySizeFile);
// read integer, iterate through array inputting each integer.
for(oneDimensionIndex = 0; oneDimensionIndex < arraySizeFile;
oneDimensionIndex++)
{
for(twoDimensionIndex = 0; twoDimensionIndex < arraySizeFile;
twoDimensionIndex++)
{
// input data into array from file
readArray->array[oneDimensionIndex][twoDimensionIndex] =
readIntegerFromFile();
}
}
}
else
{
// if the file doesn't open, notify the user.
printf("The file either doesn't exist,"
"or you do not have permission to access it.\n");
}
// close file.
closeInputFile();
// returns a Square Array. // returns a Square Array.
return readArray; return NULL;
} }

32
PA01-0906/Makefile
View file

@ -1,32 +0,0 @@
CC = gcc -Wall
SOURCES = PA01_Main.c EncryptionUtility.c Console_IO_Utility.c File_Input_Utility.c File_Output_Utility.c
OBJECTS = PA01_Main.o EncryptionUtility.o Console_IO_Utility.o File_Input_Utility.o File_Output_Utility.o
all: PA01_Main
PA01_Main: $(OBJECTS)
$(CC) $(OBJECTS) -o PA01_Main
PA01_Main.o: PA01_Main.c
$(CC) -c PA01_Main.c -o PA01_Main.o
EncryptionUtility.o: EncryptionUtility.c
$(CC) -c EncryptionUtility.c -o EncryptionUtility.o
Console_IO_Utility.o: Console_IO_Utility.c
$(CC) -c Console_IO_Utility.c -o Console_IO_Utility.o
File_Input_Utility.o: File_Input_Utility.c
$(CC) -c File_Input_Utility.c -o File_Input_Utility.o
File_Output_Utility.o: File_Output_Utility.c
$(CC) -c File_Output_Utility.c -o File_Output_Utility.o
clean:
rm -f $(OBJECTS) PA01_Main PA01_Main.out
clean_objects:
rm -f $(OBJECTS)
run:
./PA01_Main

4
PA01-0906/Makefile_Win
View file

@ -2,10 +2,10 @@ CC = gcc -Wall
SOURCES = PA01_Main.c EncryptionUtility.c Console_IO_Utility.c File_Input_Utility.c File_Output_Utility.c SOURCES = PA01_Main.c EncryptionUtility.c Console_IO_Utility.c File_Input_Utility.c File_Output_Utility.c
OBJECTS = PA01_Main.o EncryptionUtility.o Console_IO_Utility.o File_Input_Utility.o File_Output_Utility.o OBJECTS = PA01_Main.o EncryptionUtility.o Console_IO_Utility.o File_Input_Utility.o File_Output_Utility.o
all: PA01_Main all: PA01_Main.out
PA01_Main: $(OBJECTS) PA01_Main: $(OBJECTS)
$(CC) $(OBJECTS) -o PA01_Main.exe $(CC) $(OBJECTS) -o PA01_Main
PA01_Main.o: PA01_Main.c PA01_Main.o: PA01_Main.c
$(CC) -c PA01_Main.c -o PA01_Main.o $(CC) -c PA01_Main.c -o PA01_Main.o

BIN
PA01-0906/PA01_Main
View file

Binary file not shown.

21
PA01-0906/PA01_Main.c
View file

@ -12,19 +12,6 @@
// program // program
int main( int argc, char *args[] ) int main( int argc, char *args[] )
{ {
// int charNum;
// char* string = "MyStringLengthThing";
// charNum = findStringLength(string);
// printf("String Length: %d\n", charNum);
// int squaredPerfect = 100;
// int sqRT = findSquareRoot(squaredPerfect);
// printf("%d's Square Root: %d\n", squaredPerfect, sqRT);
// int randOne, randTwo, randThree;
// randOne = getRandomLetterValue();
// randTwo = getRandomLetterValue();
// randThree = getRandomLetterValue();
// printf("Char Test: %d/%c, %d/%c, %d/%c\n\n", randOne, (char)randOne, randTwo, (char)randTwo, randThree, (char)randThree);
char toEncrypt[ HUGE_STR_LEN ], decryptedStr[ HUGE_STR_LEN ]; char toEncrypt[ HUGE_STR_LEN ], decryptedStr[ HUGE_STR_LEN ];
char fileName[ STD_STR_LEN ], stringFromFile[ HUGE_STR_LEN ]; char fileName[ STD_STR_LEN ], stringFromFile[ HUGE_STR_LEN ];
SquareArrayType *encryptedInput, *uploadedInput; SquareArrayType *encryptedInput, *uploadedInput;
@ -43,12 +30,12 @@ int main( int argc, char *args[] )
printf( "\nDisplay encryption as characters:\n" ); printf( "\nDisplay encryption as characters:\n" );
displayArray( *encryptedInput, DISPLAY_CHARS ); displayArray( *encryptedInput, DISPLAY_CHARS );
printf( "\nDecrypting the input string\n" ); printf( "\nDecrypting the input string\n" );
decryptData( decryptedStr, encryptedInput ); decryptData( decryptedStr, encryptedInput );
printf( "\nDecrypted string: %s\n", decryptedStr ); printf( "\nDecrypted string: %s\n", decryptedStr );
printf( "\nDownloading encryption\n" ); printf( "\nDownloading encryption\n" );
promptForString( "\nEnter file name for download: ", fileName ); promptForString( "\nEnter file name for download: ", fileName );
downloadData( fileName, *encryptedInput ); downloadData( fileName, *encryptedInput );
@ -68,7 +55,7 @@ int main( int argc, char *args[] )
// end program // end program
// clear arrays // clear arrays
encryptedInput = clearArrayType( encryptedInput ); encryptedInput = clearArrayType( encryptedInput );
// display end of program // display end of program
printf( "\nProgram End\n" ); printf( "\nProgram End\n" );

BIN
PA01-0906/build/Release/outRelease
View file

Binary file not shown.

590
PA02-0913/Console_IO_Utility.c
View file

@ -1,590 +0,0 @@
// Header files included
#include "Console_IO_Utility.h"
// Function Implementations
/*
Name: clearLeadingCharacters
Process: Clears all leading non-printable characters from the console stream
Function input/parameters: allow space return (Boolean)
Function output/parameters: none
Function output/returned: first printable character as integer
Device input/keyboard: none
Device output/monitor: none
Dependencies: getchar
*/
int clearLeadingCharacters( bool allowSpaceReturn )
{
// initialize data, set input character to getChar, set count to zero
// function: getchar
int intChar = getchar();
int charCount = 0;
// loop while non-printable characters and space if not set
// also limits looping to constant limit
while( ( intChar < (int)SPACE
|| ( !allowSpaceReturn && intChar == SPACE ) )
&& charCount < MAX_STR_LEN )
{
// update character count
charCount++;
// get new input character
// function: getchar
intChar = getchar();
}
// return captured character
return intChar;
}
/*
Name: getChar
Process: returns next character in stream,
ignores all white space (including SPACE) prior to character
Function input/parameters: flag to accept space (Boolean)
Function output/parameters: none
Function output/returned: one character (char) is returned to calling method
Device input/keyboard: places one or more characters in stream
Device output/monitor: none
Dependencies: getCharFiltered
*/
char getChar()
{
// initialize variables, set space accept flag to false
bool dontAcceptSpace = false;
// call filtered function with space accept flag
// function: getCharFiltered
return getCharFiltered( dontAcceptSpace );
}
/*
Name: getCharFiltered
Process: returns next character in stream,
ignores non printable characters prior to input character
but may accept space depending on flag
Function input/parameters: flag to accept space (boolean)
Function output/parameters: none
Function output/returned: first printable character or space (if configured)
returned (char)
Device input/keyboard: places one or more characters in stream
Device output/monitor: none
Dependencies: getchar(), clearLeadingCharacters
*/
char getCharFiltered( bool acceptSpace )
{
//Initialize variables
int inCharInt;
// clear leading characters, capture first usable character
// function: clearLeadingCharacters
inCharInt = clearLeadingCharacters( acceptSpace );
// check for input character set to end of file
if( inCharInt == EOF )
{
// return character zero
return '0';
}
// return input character as character
return (char)inCharInt;
}
/*
Name: getInputString
Process: acquires input string from keyboard, if clear white space flag set,
ignores all white space, including space character
Function input/parameters: clear white space control (Boolean)
Function output/parameters: character array (char[])
Function output/returned: none
Device input/keyboard: user entry of a character stream
Device output/monitor: none
Dependencies: getchar(), clearLeadingCharacters
*/
void getInputString( char inputArr[], bool clearWhiteSpace )
{
//Initialize Variables, set character count and index to zero
int charCount = 0;
int index = 0;
int intChar;
// check for clear white space flag
if( clearWhiteSpace )
{
// clear leading characters, set flag to ignore space
// function: clearLeadingCharacters
intChar = clearLeadingCharacters( !clearWhiteSpace );
}
// otherwise, assume white space flag not set
else
{
// get first character
// function: getchar
intChar = getChar();
}
// loop until enter key found, limit loop to constant
while( intChar != (int)NEWLINE_CHAR && charCount < MAX_STR_LEN )
{
// set current value to array element
inputArr[ index ] = (char)intChar;
// increment string array index
index++;
// add null character to end of string array
inputArr[ index ] = NULL_CHAR;
// increment character count
charCount++;
// get next character
// function: getchar
intChar = getchar();
}
}
/*
Name: printCharacter
Process: prints a single character
Function input/parameters: character to be printed (char)
Function output/parameters: None
Function output/returned: None
Device input/keyboard: None
Device output/monitor: character printed as specified
Dependencies: printCharacters
*/
void printCharacter( char outputChar )
{
// initialize number of characters to one
int numberOfChars = 1;
// print one character
// function: printChars
printCharacters( numberOfChars, outputChar );
}
/*
Name: printCharacters
Process: prints given number of characters
Function input/parameters: number of characters (int),
character to be printed (char)
Function output/parameters: None
Function output/returned: None
Device input/keyboard: None
Device output/monitor: Number of specified characters printed
Dependencies: printf
*/
void printCharacters( int numChars, char outputChar )
{
// check for reminaing characters to print
if( numChars > 0 )
{
// print one character
// function: printf
printf( "%c", outputChar );
// (recursive) print remaining characters
// function: printChars
printCharacters( numChars - 1, outputChar );
}
}
/*
Name: printDouble
Process: simple print double function
Function input/parameters:
outVal - the double value to be output (double)
precision - the number of digits to the right of the decimal point (int)
Function output/parameters: none
Function output/returned: none
Device input: none
Device output/monitor: one double value displayed
Dependencies: printDoubleJustified
*/
void printDouble( double outVal, int precision )
{
// initialize variables, set block size to zero and justified to "LEFT"
int blockSize = 0;
char justified[] = "LEFT";
// call justified function with specified parameters
// function: printDoubleJustified
printDoubleJustified( outVal, precision, blockSize, justified );
}
/*
Name: printDoubleJustified
Process: the precision is set for the double value, then the pre-spaces
and post-spaces are calculated for the requested justification,
and then the pre-spaces are printed, the double value is printed,
and then the post-spaces are printed
Function input/parameters:
outVal - the double value to be output (double)
blockSize - the width of the block within which
to print the integer value (int)
justify - "LEFT," "RIGHT," or "CENTER" justification in block (c-string)
Function output/parameters: none
Function output/returned: none
Device input: none
Device output/monitor: one double value displayed, justified, with precision
Dependencies: formatDouble, printStringJustified
*/
void printDoubleJustified( double outVal, int precision,
int blockSize, const char* justify )
{
// initialize variables, create temp string for configuration string
char specStr[ MIN_STR_LEN ];
// initialize variables, create temporary output string
char outStr[ MIN_STR_LEN ];
// set configuration string with precision value
// function: sprintf
sprintf( specStr, "%s0.%dlf", "%", precision );
// set output string
// function: sprintf
sprintf( outStr, specStr, outVal );
// print string justified
// function: printStringJustified
printStringJustified( outStr, blockSize, justify );
}
/*
Name: printEndline
Process: prints single endline character to end a line or create vertical space
Function input/parameters: none
Function output/parameters: none
Function output/returned: none
Device input: none
Device output/monitor: one endline character output
Dependencies: printf
*/
void printEndline()
{
// print one newline character
// function: printf
printf( "\n" );
}
/*
Name: printEndlines
Process: prints the specified number of endline characters
to end a line and/or create vertical space(s)
Function input/parameters: number of endlines (int)
Function output/parameters: none
Function output/returned: none
Device input: none
Device output/monitor: endline characters output as specified
Dependencies: printEndline
*/
void printEndlines( int numEndlines )
{
// check for number of end lines remaining
if( numEndlines > 0 )
{
// print one endling
// function: printEndline
printEndline();
// (recursive) print remaining end lines
printEndlines( numEndlines - 1 );
}
}
/*
Name: printInteger
Process: prints integer value
Function input/parameters: outVal - the integer value to be output
Output: None
Device Input: None
Device Output: Integer is displayed as specified
Dependencies: printIntegerJustified
*/
void printInteger( int outVal )
{
// initialize variables, set block size to zero, justifification to "LEFT"
int blockSize = 0;
char justified[] = "LEFT";
// print justified integer with specified parameters
// function: printIntegerJustified
printIntegerJustified( outVal, blockSize, justified );
}
/*
Name: printIntegerJustified
Process: prints integer value with the specified justification
within the specified blockSize
Function input/parameters:
outVal - the integer value to be output
blockSize - the width of the block within which
to print the integer value (int)
justify - "LEFT," "RIGHT," or "CENTER" justification in block (c-string)
Output: None
Device Input: None
Device Output: Integer is displayed as specified
Dependencies: sprintf, printStringJustified
*/
void printIntegerJustified( int outVal, int blockSize, const char *justify )
{
// initialize variables, create temporary output string
char outStr[ MIN_STR_LEN ];
// convert integer to string
// function: sprintf
sprintf( outStr, "%d", outVal );
// print justified string
// function: printStringJustified
printStringJustified( outStr, blockSize, justify );
}
/*
Name: printLongInteger
Process: prints long integer
Function input/Parameters: outVal - the long integer value to be output
Function output/parameters: None
Function output/returned: None
Device Input/keyboard: None
Device Output/Monitor: integer is displayed as specified
Dependencies: printLongIntJustified
*/
void printLongInteger( long outVal )
{
// initialize variables, set block size to zero, justification to "LEFT"
int blockSize = 0;
char justified[] = "LEFT";
// print justified long integer with specified parameters
// function: printLongIntegerJustified
printLongIntegerJustified( outVal, blockSize, justified );
}
/*
Name: printLongIntegerJustified
Process: prints long integer with the specified justification
within the specified blockSize
Function input/Parameters:
outVal - the long integer value to be output
blockSize - the width of the block within which
to print the integer value (int)
justify - "LEFT," "RIGHT," or "CENTER" justification in block (c-string)
Function output/parameters: None
Function output/returned: None
Device Input/keyboard: None
Device Output/Monitor: integer is displayed as specified
Dependencies: sprintf, printStringJustified
*/
void printLongIntegerJustified( long outVal,
int blockSize, const char *justify )
{
// initialize variables, create temporary output string
char outStr[ MIN_STR_LEN ];
// convert long integer to string
// function: sprintf
sprintf( outStr, "%ld", outVal );
// print justified string
// function: printStringJustified
printStringJustified( outStr, blockSize, justify );
}
/*
Name: printString
Process: prints string
Function input/parameters: outVal - the string value to be output
Function output/parameters: None
Function output/returned: None
Function input/keyboard: None
Device output/monitor: string is displayed as specified
Dependencies: printStringJustified
*/
void printString( const char *outStr )
{
// initialize variables, set block size to zero, justification to "LEFT"
int blockSize = 0;
char justified[] = "LEFT";
// print justified string with specified parameters
// function: printStringJustified
printStringJustified( outStr, blockSize, justified );
}
/*
Name: printStringJustified
Process: prints string within specified block size
and with specified justification
Function input/parameters:
outVal - the string value to be output
blockSize - the width of the block within which
to print the integer value (int)
justify - "LEFT," "RIGHT," or "CENTER" justification in block (c-string)
Function output/parameters: None
Function output/returned: None
Function input/keyboard: None
Device output/monitor: string is displayed as specified
Dependencies: strlen, strcmp, printCharacters, printf
*/
void printStringJustified ( const char *outStr,
int blockSize, const char *justify )
{
// initialize variables, set pre-, post- spaces to zero
int preSpaces = 0, postSpaces = 0, strLength;
// find length of string
// function: strlen
strLength = strlen( outStr );
// check justification for "LEFT"
// function: strcmp
if( strcmp( justify, "LEFT" ) == 0 )
{
// set post spaces for left justification
postSpaces = blockSize - strLength;
}
// otherwise, check justification for "RIGHT"
// function: strcmp
else if( strcmp( justify, "RIGHT" ) == 0 )
{
// set pre spaces for right justification
preSpaces = blockSize - strLength;
}
// Otherwise, assume "CENTER" justification
else
{
// set pre spaces for centered
preSpaces = blockSize / 2 - strLength / 2;
// set post spaces for centered
postSpaces = blockSize - strLength - preSpaces;
}
// print pre spaces
// function: printChars
printCharacters( preSpaces, SPACE );
// print string
// function: printf
printf( "%s", outStr );
// print post spaces
// function: printChars
printCharacters( postSpaces, SPACE );
}
/*
Name: promptForCharacter
Process: prompts user for character, then returns it
Function input/parameters: text to prompt user (c-string)
Function output/parameters: None
Function output/returned: one character (chars
Device input/keyboard: user entry of a character
Device output/monitor: prompt string displayed
Dependencies: printf, getChar
*/
char promptForCharacter( const char *promptString )
{
// initialize variables
char outChar;
// print prompt string
// function: printf
printf( "%s", promptString );
// get character from stream
// function: getChar
outChar = (char)getChar();
// return captured character
return outChar;
}
/*
Name: promptForDouble
Process: prompts user for double, then returns it
Function input/parameters: test to prompt user (c-string)
Function output/parameters: None
Function output/returned: value (double)
Device input/keyboard: user entry of an integer value
Device output/monitor: prompt string displayed
Dependencies: printf, scanf
*/
double promptForDouble( const char *promptString )
{
// initialize variables
double outDouble;
// print prompt string
// function: printf
printf( "%s", promptString );
// get double value
// function: scanf
scanf( "%lf", &outDouble );
// return captured double
return outDouble;
}
/*
Name: promptForInteger
Process: prompts user for integer, then returns it
Function input/parameters: text to prompt user (c-string)
Function output/parameters: none
Function output/returned: integer value (int)
Device input/keyboard: user entry of a double value
Device output/monitor: prompt string displayed
Dependencies: printf, scanf
*/
int promptForInteger( const char *promptString )
{
// initialize variables
int outInt;
// print prompt string
// function: printf
printf( "%s", promptString );
// input integer
// function: scanf
scanf( "%d", &outInt );
// return captured integer
return outInt;
}
/*
Name: promptForString
Process: prompts user for string, then returns it
Function input/parameters: text to prompt user (c-string)
Function output/parameters: input string from user(c-string)
Function output/returned: none
Device input/keyboard: user entry of a string value
Device output/monitor: prompt string displayed
Dependencies: printf, getInputString
*/
void promptForString( const char *promptString, char returnStr[] )
{
// initialize variables, don't allow white space capture
bool dontClearWhitespace = false;
// pring prompt string
// function: printf
printf( "%s", promptString );
// get input string from user (returned via parameter)
// function: getInputString
getInputString( returnStr, dontClearWhitespace );
}

289
PA02-0913/Console_IO_Utility.h
View file

@ -1,289 +0,0 @@
// Preprocessor directive
#ifndef CONSOLE_IO_UTILITY_H
#define CONSOLE_IO_UTILITY_H
//Header Files
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include "StandardConstants.h"
//Global Constants
// none
//Function Prototypes
/*
Name: clearLeadingCharacters
Process: Clears all leading non-printable characters from the console stream
Function input/parameters: allow space return (bool)
Function output/parameters: none
Function output/returned: first printable character as integer
Device input/keyboard: none
Device output/monitor: none
Dependencies: getchar
*/
int clearLeadingCharacters( bool allowSpaceReturn );
/*
Name: getChar
Process: returns next character in stream,
ignores all white space (including SPACE) prior to character
Function input/parameters: flag to accept space (bool)
Function output/parameters: none
Function output/returned: one character (char) is returned to calling method
Device input/keyboard: places one or more characters in stream
Device output/monitor: none
Dependencies:
*/
char getChar();
/*
Name: getCharFiltered
Process: returns next character in stream,
ignores non printable characters prior to input character
but may accept space depending on flag
Function input/parameters: flag to accept space (bool)
Function output/parameters: none
Function output/returned: first printable character or space (if configured)
returned (char)
Device input/keyboard: places one or more characters in stream
Device output/monitor: none
Dependencies: getchar(), clearLeadingCharacters
*/
char getCharFiltered( bool acceptSpace );
/*
Name: getInputString
Process: acquires input string from keyboard, if clear white space flag set,
ignores all white space, including space character
Function input/parameters: clear white space control (bool)
Function output/parameters: character array (char[])
Function output/returned: none
Device input/keyboard: user entry of a character stream
Device output/monitor: none
Dependencies: getchar(), clearLeadingCharacters
*/
void getInputString(char inputArr[], bool clearWhiteSpace );
/*
Name: printCharacter
Process: prints a single character
Function input/parameters: character to be printed (char)
Function output/parameters: None
Function output/returned: None
Device input/keyboard: None
Device output/monitor: character printed as specified
Dependencies: printCharacters
*/
void printCharacter( char outputChar );
/*
Name: printCharacters
Process: prints given number of characters
Function input/parameters: number of characters (int),
character to be printed (char)
Function output/parameters: None
Function output/returned: None
Device input/keyboard: None
Device output/monitor: Number of specified characters printed
Dependencies: printf
*/
void printCharacters( int numChars, char outputChar );
/*
Name: printDouble
Process: simple print double function
Function input/parameters:
outVal - the double value to be output (double)
precision - the number of digits to the right of the decimal point (int)
Function output/parameters: none
Function output/returned: none
Device input: none
Device output/monitor: one double value displayed
Dependencies: printDoubleJustified
*/
void printDouble( double outVal, int precision );
/*
Name: printDoubleJustified
Process: the precision is set for the double value, then the pre-spaces
and post-spaces are calculated for the requested justification,
and then the pre-spaces are printed, the double value is printed,
and then the post-spaces are printed
Function input/parameters:
outVal - the double value to be output (double)
blockSize - the width of the block within which
to print the integer value (int)
justify - "LEFT," "RIGHT," or "CENTER" justification in block (c-string)
Function output/parameters: none
Function output/returned: none
Device input: none
Device output/monitor: one double value displayed, justified, with precision
Dependencies: formatDouble, printStringJustified
*/
void printDoubleJustified( double outVal, int precision,
int blockSize, const char* justify );
/*
Name: printEndline
Process: prints single endline character to end a line or create vertical space
Function input/parameters: none
Function output/parameters: none
Function output/returned: none
Device input: none
Device output/monitor: one endline character output
Dependencies: printEndline
*/
void printEndline();
/*
Name: printEndlines
Process: prints the specified number of endline characters
to end a line and/or create vertical space(s)
Function input/parameters: number of endlines (int)
Function output/parameters: none
Function output/returned: none
Device input: none
Device output/monitor: endline characters output as specified
Dependencies: printEndline
*/
void printEndlines( int numEndlines );
/*
Name: printInteger
Process: prints integer value
Function input/parameters: outVal - the integer value to be output
Function output/parameters: None
Device Input: None
Device Output: Integer is displayed as specified
Dependencies: printIntegerJustified
*/
void printInteger( int outVal );
/*
Name: printIntegerJustified
Process: prints integer value with the specified justification
within the specified blockSize
Function input/parameters:
outVal - the integer value to be output (int)
blockSize - the width of the block within which
to print the integer value (int)
justify - "LEFT," "RIGHT," or "CENTER" justification in block (c-string)
Function output/parameters: none
Device Input: None
Device Output: Integer is displayed as specified
Dependencies: sprintf, printStringJustified
*/
void printIntegerJustified( int outVal, int blockSize, const char *justify );
/*
Name: printLongInteger
Process: prints long integer
Function input/Parameters: outVal - the long integer value to be output
Function output/parameters: None
Function output/returned: None
Device Input/keyboard: None
Device Output/Monitor: integer is displayed as specified
Dependencies: printLongIntJustified
*/
void printLongInteger( long outVal );
/*
Name: printLongIntegerJustified
Process: prints long integer with the specified justification
within the specified blockSize
Function Input/Parameters:
outVal - the long integer value to be output (long int)
blockSize - the width of the block within which
to print the integer value (int)
justify - "LEFT," "RIGHT," or "CENTER" justification in block (c-string)
Function output/parameters: None
Function output/returned: None
Device Input/keyboard: None
Device Output/Monitor: integer is displayed as specified
Dependencies: sprintf, printStringJustified
*/
void printLongIntegerJustified( long outVal,
int blockSize, const char *justify );
/*
Name: printString
Process: prints string
Function input/parameters: outVal - the string value to be output
Function output/parameters: None
Function output/returned: None
Function input/keyboard: None
Device output/monitor: string is displayed as specified
Dependencies: printStringJustified
*/
void printString( const char *outStr );
/*
Name: printStringJustified
Process: prints string within specified block size
and with specified justification
Function input/parameters:
outStr - the string value to be output (c-string)
blockSize - the width of the block within which
to print the integer value (int)
justify - "LEFT," "RIGHT," or "CENTER" justification in block (c-string)
Function output/parameters: None
Function output/returned: None
Function input/keyboard: None
Device output/monitor: string is displayed as specified
Dependencies: strlen, strcmp, printCharacters, printf
*/
void printStringJustified( const char *outStr,
int blockSize, const char *justify );
/*
Name: promptForCharacter
Process: prompts user for character, then returns it
Function input/parameters: text to prompt user (c-string)
Function output/parameters: None
Function output/returned: one character (chars
Device input/keyboard: user entry of a character
Device output/monitor: prompt string displayed
Dependencies: printf, getChar
*/
char promptForCharacter( const char *promptString );
/*
Name: promptForDouble
Process: prompts user for double, then returns it
Function input/parameters: test to prompt user (c-string)
Function output/parameters: None
Function output/returned: value (double)
Device input/keyboard: user entry of an integer value
Device output/monitor: prompt string displayed
Dependencies: printf, scanf
*/
double promptForDouble( const char *promptString );
/*
Name: promptForInteger
Process: prompts user for integer, then returns it
Function input/parameters: text to prompt user (c-string)
Function output/parameters: none
Function output/returned: integer value (int)
Device input/keyboard: user entry of a double value
Device output/monitor: prompt string displayed
Dependencies: printf, scanf
*/
int promptForInteger( const char *promptString );
/*
Name: promptForString
Process: prompts user for string, then returns it
Function input/parameters: text to prompt user (c-string)
Function output/parameters: input string captured (c-string)
Function output/returned: none
Device input/keyboard: user entry of a string value
Device output/monitor: prompt string displayed
Dependencies: printf, getInputString
*/
void promptForString( const char *promptString, char returnStr[] );
#endif // end CONSOLE_IO_UTILITY_H

717
PA02-0913/File_Input_Utility.c
View file

@ -1,717 +0,0 @@
/*
Formatted file input utility, function implementations
Copyright (c) 2021 by Michael E. Leverington
Code is free for use in whole or in part and may be modified for other
non-commercial use as long as the above copyright statement is included.
*/
// header files
#include "File_Input_Utility.h"
#include <stdlib.h> //////////////////////////test
// local global constants, used only in this file
// dummy file pointer for accessInputFilePointer
const FILE *DUMMY_INPUT_FILE_PTR = NULL;
// dummy Boolean for accessEndOfInputFileFlag, accessOpenFlag
const char DUMMY_INPUT_FLAG = false;
// control code for accessing file pointer, accessInputFilePointer
const int GET_INPUT_FILE_PTR = 3003;
// control code for accessing flag value,
// accessEndOfInputFileFlag, accessOpenFlag
const int GET_INPUT_FLAG = 2002;
// control code for setting file pointer, accessInputFilePointer
const int SET_INPUT_FILE_PTR = 4004;
// control code for setting flag value, accessEndOfInputFileFlag,
// accessOpenFlag
const int SET_INPUT_FLAG = 1001;
/*
Name: accessEndOfInputFileFlag
process: allows accessing or modifying end of file flag state;
note: flag is maintained (static) value initialized to false
Function input/parameters: control code (int), flag state (bool)
Function output/parameters: none
Function output/returned: result of flag state (bool)
Device input/file: none
Device output/monitor: none
Dependencies: none
*/
bool accessEndOfInputFileFlag( int ctrlCode, bool setFlag )
{
// initialize end of file flag to false
static bool endOfFileFlag = false;
// test for set flag
if( ctrlCode == SET_INPUT_FLAG )
{
// set flag to given state
endOfFileFlag = setFlag;
}
// return flag state
return endOfFileFlag;
}
/*
Name: accessInputFilePointer
process: allows setting or accessing file pointer;
note: pointer is maintained (static) value initialized to NULL
Function input/parameters: control code (int), file pointer (FILE *)
DUMMY_INPUT_FILE_PTR used
if not setting file pointer
Function output/parameters: none
Function output/returned: file pointer (FILE *)
Device input/file: none
Device output/monitor: none
Dependencies: none
*/
FILE *accessInputFilePointer( int ctrlCode, const FILE *filePtr )
{
// initialize file pointer to null
static FILE *filePointer = NULL;
// check for set new pointer
if( ctrlCode == SET_INPUT_FILE_PTR )
{
// set file pointer to parameter
filePointer = (FILE *)filePtr;
}
// return file pointer
return filePointer;
}
/*
Name: checkForEndOfInputFile
process: checks to see if end of file flag has been encountered,
returns true if EOF has been encountered, false otherwise
Function input/parameters: none
Function output/parameters: none
Function output/returned: result of specified test (bool)
Device input/file: none
Device output/monitor: none
Dependencies: accessEndOfInputFileFlag
*/
bool checkForEndOfInputFile()
{
// return access to end of file flag
// function: accessEndOfInputFileFlag
return accessEndOfInputFileFlag( GET_INPUT_FLAG, DUMMY_INPUT_FLAG );
}
/*
Name: checkForInputFileOpen
process: checks to see if file is currently open
returns true if file pointer not null, false otherwise
Function input/parameters: none
Function output/parameters: none
Function output/returned: result of specified test (bool)
Device input/file: none
Device output/monitor: none
Dependencies: accessInputFilePointer
*/
bool checkForInputFileOpen()
{
// return access to end of file flag
// function: accessInputFilePointer
return accessInputFilePointer( GET_INPUT_FLAG,
DUMMY_INPUT_FILE_PTR ) != NULL;
}
/*
Name: clearLeadingWhiteSpace
process: captures non printable characters,
and space if flag set,
returns first non white space value found as integer
Function input/parameters: file pointer (FILE *), clear space flag (bool)
Function output/parameters: none
Function output/returned: first non WS character as integer
Device input/file: value captured from file
Device output/monitor: none
Dependencies: fgetc
*/
int clearLeadingWhiteSpace( FILE *filePtr, bool clearSpace )
{
// initialize character input value
// function: fgetc
int charInt = fgetc( filePtr );
while(
// continue if not at end of file
( charInt != EOF )
// AND
// continue if character is non printable
&& ( ( charInt < (int)SPACE || charInt > (int)HIGHEST_PRINTABLE_CHAR )
// OR
// continue if clear space flag set and space is found
|| ( clearSpace && charInt == SPACE ) )
)
{
// capture next character
// function: fgetc
charInt = fgetc( filePtr );
}
// return input value as character
return (char)charInt;
}
/*
Name: closeInputFile
process: closes input file, returns true if successful, false otherwise
Function input/parameters: none
Function output/parameters: none
Function output/returned: none
Device input/file: file closed
Device output/monitor: none
Dependencies: accessInputFilePointer, fclose, accessEndOfInputFileFlag
*/
bool closeInputFile()
{
// set local file pointer to working file pointer
// function: accessInputFilePointer
FILE *filePtr = accessInputFilePointer( GET_INPUT_FILE_PTR,
DUMMY_INPUT_FILE_PTR );
// check for valid file pointer
if( filePtr != NULL )
{
// close file
fclose( filePtr );
// set pointer to NULL
// function: accessInputFilePointer
accessInputFilePointer( SET_INPUT_FILE_PTR, NULL );
// set end of file flag to false
// function: accessEndOfInputFileFlag
accessEndOfInputFileFlag( SET_INPUT_FLAG, false );
// return successful operation
return true;
}
// return failed operation
return false;
}
/*
Name: openInputFile
process: opens input file, sets file pointer and unsets end of file flag,
returns true if successful, false otherwise
Function input/parameters: file name (c-string)
Function output/parameters: none
Function output/returned: success of operation (bool)
Device input/file: file opened
Device output/monitor: none
Dependencies: fopen, accessInputFilePointer, accessEndOfInputFileFlag
*/
bool openInputFile( const char *fileName )
{
// initialize variables
FILE *filePtr = NULL;
char readOnlyCharacter[] = "r";
// check for file not open
// function: checkForInputFileOpen
if( !checkForInputFileOpen() )
{
// open file
// function: fopen
filePtr = fopen( fileName, readOnlyCharacter );
// check for success of file open
if( filePtr != NULL )
{
// set pointer in access function
// function: accessInputFilePointer
accessInputFilePointer( SET_INPUT_FILE_PTR, filePtr );
// reset end of file flag, if needed
// accessEndOfInputFileFlag
accessEndOfInputFileFlag( SET_INPUT_FLAG, false );
// return operation success
return true;
}
}
// end of file not previously opened block
// return operation failure
return false;
}
/*
Name: readCharacterFromFile
process: ignores leading unprintable characters, including space,
captures first printable character
Function input/parameters: allow space capture (bool)
Function output/parameters: none
Function output/returned: character found if successful, ZERO_CHAR otherwise
Device input/file: character(s) captured from file as needed
Device output/monitor: none
Dependencies: readCharacterFromFileConfigured
*/
char readCharacterFromFile()
{
// initialize parameter to not allow space
bool noSpaceCapture = false;
// capture character, return
// function: getCharFromFileConfigured
return readCharacterFromFileConfigured( noSpaceCapture );
}
/*
Name: readCharacterFromFileConfigured
process: ignores leading unprintable characters,
captures first printable character,
including space if allowed
Function input/parameters: allow space capture (bool)
Function output/parameters: none
Function output/returned: character found if successful, ZERO_CHAR otherwise
Device input/file: character(s) captured from file as needed
Device output/monitor: none
Dependencies: checkForInputFileOpen, checkForEndOfInputFile,
accessInputFilePointer, clearLeadingWhiteSpace,
accessEndOfInputFileFlag
*/
char readCharacterFromFileConfigured( bool captureSpace )
{
// initialize variables
FILE *filePtr;
int intChar = ZERO_CHAR;
// check for file open and data accessible
// function: checkForInputFileOpen, checkForEndOfInputFile
if( checkForInputFileOpen() && !checkForEndOfInputFile() )
{
// set file pointer
// function: accessInputFilePointer
filePtr = accessInputFilePointer( GET_INPUT_FILE_PTR,
DUMMY_INPUT_FILE_PTR );
// get character
// function: clearLeadingWhiteSpace
intChar = clearLeadingWhiteSpace( filePtr, !captureSpace );
// check for end of file found
if( intChar == EOF )
{
// set end of file flag
// function: accessEndOfInputFileFlag
accessEndOfInputFileFlag( SET_INPUT_FLAG, true );
// set return value to zero
intChar = ZERO_CHAR;
}
}
// return value as character
return intChar;
}
/*
Name: readDoubleFromFile
process: ignores leading unprintable characters,
captures first contiguous double value
Function input/parameters: none
Function output/parameters: none
Function output/returned: double value found if successful (double)
Device input/file: double value captured from file
Device output/monitor: none
Dependencies: checkForInputFileOpen, checkForEndOfInputFile,
accessInputFilePointer, fscanf, accessEndOfInputFileFlag
*/
double readDoubleFromFile()
{
// initialize variables
FILE *filePtr = NULL;
int fscanfReturn = EOF;
double doubleVal = ZERO_VALUE;
// check for file open and data accessible
// function: checkForInputFileOpen, checkForEndOfInputFile
if( checkForInputFileOpen() && !checkForEndOfInputFile() )
{
// set file pointer
// function: accessInputFilePointer
filePtr = accessInputFilePointer( GET_INPUT_FILE_PTR,
DUMMY_INPUT_FILE_PTR );
// get double value
// function: fscanf
fscanfReturn = fscanf( filePtr, "%lf", &doubleVal );
// check for end of file found
if( fscanfReturn == EOF )
{
// set end of file flag
// function: accessEndOfInputFileFlag
accessEndOfInputFileFlag( SET_INPUT_FLAG, true );
// set return value to zero
doubleVal = ZERO_VALUE;
}
}
// return acquired value
return doubleVal;
}
/*
Name: readIntegerFromFile
process: ignores leading unprintable characters,
captures first contiguous integer
Function input/parameters: none
Function output/parameters: none
Function output/returned: integer found if successful, ZERO_VALUE otherwise
Device input/file: character(s) captured from file as needed
Device output/monitor: none
Dependencies: checkForInputFileOpen, checkForEndOfInputFile,
accessInputFilePointer, fscanf, accessEndOfInputFileFlag
*/
int readIntegerFromFile()
{
// initialize variables
FILE *filePtr = NULL;
int fscanfReturn = EOF;
int intVal = ZERO_VALUE;
// check for file open and data accessible
// function: checkForInputFileOpen, checkForEndOfInputFile
if( checkForInputFileOpen() && !checkForEndOfInputFile() )
{
// set file pointer
// function: accessInputFilePointer
filePtr = accessInputFilePointer( GET_INPUT_FILE_PTR,
DUMMY_INPUT_FILE_PTR );
// get integer value
// function: fscanf
fscanfReturn = fscanf( filePtr, "%d", &intVal );
// check for end of file found
if( fscanfReturn == EOF )
{
// set end of file flag
// function: accessEndOfInputFileFlag
accessEndOfInputFileFlag( SET_INPUT_FLAG, true );
// set return value to zero
intVal = ZERO_VALUE;
}
}
// return acquired value
return intVal;
}
/*
Name: readLongFromFile
process: ignores leading unprintable characters,
captures first contiguous long int
Function input/parameters: none
Function output/parameters: none
Function output/returned: long integer found if successful,
ZERO_VALUE otherwise
Device input/file: long value captured from file
Device output/monitor: none
Dependencies: checkForInputFileOpen, checkForEndOfInputFile,
accessInputFilePointer, fscanf, accessEndOfInputFileFlag
*/
long readLongFromFile()
{
// initialize variables
FILE *filePtr = NULL;
int fscanfReturn = EOF;
long longVal = ZERO_VALUE;
// check for file open and data accessible
// function: checkForInputFileOpen, checkForEndOfInputFile
if( checkForInputFileOpen() && !checkForEndOfInputFile() )
{
// set file pointer
// function: accessInputFilePointer
filePtr = accessInputFilePointer( GET_INPUT_FILE_PTR,
DUMMY_INPUT_FILE_PTR );
// get long value
// function: fscanf
fscanfReturn = fscanf( filePtr, "%ld", &longVal );
// check for end of file found
if( fscanfReturn == EOF )
{
// set end of file flag
// function: accessEndOfInputFileFlag
accessEndOfInputFileFlag( SET_INPUT_FLAG, true );
// set return value to zero
longVal = ZERO_VALUE;
}
}
// return acquired value
return longVal;
}
/*
Name: readRawCharFromFile
process: captures first character in file stream including non-printable
Function input/parameters: none
Function output/parameters: none
Function output/returned: character found if successful, ZERO_CHAR otherwise
Device input/file: character captured from file
Device output/monitor: none
Dependencies: checkForInputFileOpen, checkForEndOfInputFile,
accessInputFilePointer, fgetc, accessEndOfInputFileFlag
*/
char readRawCharFromFile()
{
// initialize variables
FILE *filePtr = NULL;
int intChar = (int)ZERO_CHAR;
// check for file open and data accessible
// function: checkForInputFileOpen, checkForEndOfInputFile
if( checkForInputFileOpen() && !checkForEndOfInputFile() )
{
// set file pointer
// function: accessInputFilePointer
filePtr = accessInputFilePointer( GET_INPUT_FILE_PTR,
DUMMY_INPUT_FILE_PTR );
// get character
// function: fgetc
intChar = fgetc( filePtr );
// check for end of file found
if( intChar == EOF )
{
// set end of file flag
// function: accessEndOfInputFileFlag
accessEndOfInputFileFlag( SET_INPUT_FLAG, true );
// set return value to zero
intChar = (int)ZERO_CHAR;
}
}
// return acquired value
return (char)intChar;
}
/*
Name: readStringConfiguredFromFile
Process: captures string with options:
- clear leading non printable (bool)
- clear leading space character (bool)
- adquires characters up to any non-printable (bool)
- adquires characters up to any printable delimiter (char)
- use constant NON_PRINTABLE if no delimiter
- also stops capture when full (MAX_STR_LEN)
Note: This function consumes the last character input,
including the space, delimiter, or non-printable character
Function input/parameters: see process above
Function output/parameters: captured string (char *), EMPTY_STRING otherwise
Function output/returned: success of operation (bool)
Device input/file: character(s) captured from file as needed
Device output/monitor: none
Dependencies: checkForInputFileOpen, checkForEndOfInputFile,
clearLeadingWhiteSpace, fgetc, accessEndOfInputFileFlag
*/
bool readStringConfiguredFromFile( bool clearLeadingNonPrintable,
bool clearLeadingSpace,
bool stopAtNonPrintable,
char delimiter,
char *capturedString )
{
// initialize variables
int intChar = EOF, index = 0;
FILE *filePtr = NULL;
// initialize output string
capturedString[ index ] = NULL_CHAR;
// check for file open and data accessible
// function: checkForInputFileOpen, checkForEndOfInputFile
if( checkForInputFileOpen() && !checkForEndOfInputFile() )
{
// get file pointer
// function: accessFilePtr
filePtr = accessInputFilePointer( GET_INPUT_FILE_PTR,
DUMMY_INPUT_FILE_PTR );
// check for clearing non printable
if( clearLeadingNonPrintable )
{
// clear leading white space, with clear space character flag
// function: clearLeadingWhiteSpace
intChar = clearLeadingWhiteSpace( filePtr, clearLeadingSpace );
}
// otherwise, assume non printable not cleared
else
{
// get first character
// function: fgetc
intChar = fgetc( filePtr );
// check for clearing spaces
if( clearLeadingSpace )
{
// loop while spaces found and end of file not found
while( intChar != EOF && intChar == (int)SPACE )
{
// capture new character
// function: fgetc
intChar = fgetc( filePtr );
}
}
} // end leading character clearing process
// check for end of file found
if( intChar == EOF )
{
// set end of file flag
// function: accessEndOfInputFileFlag
accessEndOfInputFileFlag( SET_INPUT_FLAG, true );
// return failed operation
return false;
}
// loop to capture input
while(
// continues if not at end of file and max string length not reached
( intChar != EOF && index < MAX_STR_LEN - 1 )
// AND
// continues if not printable flag set and characters are printable
// OR not printable flag not set
&& ( ( stopAtNonPrintable && intChar >= (int)SPACE )
|| ( !stopAtNonPrintable ) )
// AND
// continues if specified delimiter is not found
&& ( intChar != (char)delimiter )
)
{
// place character in array element
capturedString[ index ] = (char)intChar;
// increment array index
index++;
// set next element to null character / end of c-string
capturedString[ index ] = NULL_CHAR;
// get next character as integer
// function: fgetc
intChar = fgetc( filePtr );
}
// end loop
// return successful operation
return true;
}
// end of open file and accessible data block
return false; // temporary stub return
}
/*
Name: readStringSegmentFromFile
process: ignores leading white space, including space character,
captures series of characters up to first space,
or end of line, or full string
Function input/parameters: none
Function output/parameters: captured string (char *), EMPTY_STRING otherwise
Function output/returned: success of operation (bool)
Device input/file: character(s) captured from file as needed
Device output/monitor: none
Dependencies: readStringConfigured with appropriate parameters
*/
bool readStringSegmentFromFile( char *capturedString )
{
// initialize variables
bool clearLeadingNonPrintable = true;
bool clearLeadingSpace = true;
bool stopAtNonPrintable = true;
char delimiter = SPACE;
// call utility function, return
return readStringConfiguredFromFile( clearLeadingNonPrintable,
clearLeadingSpace,
stopAtNonPrintable,
delimiter,
capturedString );
}
/*
Name: readStringToLineEndFromFile
process: ignores leading white space, including space character,
captures series of characters up to end of current line
or full string
Function input/parameters: none
Function output/parameters: captured string (char *), EMPTY_STRING otherwise
Function output/returned: string found if successful
Device input/file: character(s) captured from file as needed
Device output/monitor: none
Dependencies: readStringConfigured with appropriate parameters
*/
bool readStringToLineEndFromFile( char *capturedString )
{
// initialize variables
bool clearLeadingNonPrintable = true;
bool clearLeadingSpace = true;
bool stopAtNonPrintable = true;
char delimiter = NON_PRINTABLE;
// call utility function, return
return readStringConfiguredFromFile( clearLeadingNonPrintable,
clearLeadingSpace,
stopAtNonPrintable,
delimiter,
capturedString );
}
/*
Name: readStringToDelimiterFromFile
process: ignores leading white space, including space character,
captures series of characters up to specified character
Function input/parameters: none
Function output/parameters: captured string (char *), EMPTY_STRING otherwise
Function output/returned: string found if successful
Device input/file: character(s) captured from file as needed
Device output/monitor: none
Dependencies: readStringConfigured with appropriate parameters
*/
bool readStringToDelimiterFromFile( char delimiter, char *capturedString )
{
// initialize variables
bool clearLeadingNonPrintable = true;
bool clearLeadingSpace = true;
bool stopAtNonPrintable = true;
// call utility function, return
return readStringConfiguredFromFile( clearLeadingNonPrintable,
clearLeadingSpace,
stopAtNonPrintable,
delimiter,
capturedString );
}

295
PA02-0913/File_Input_Utility.h
View file

@ -1,295 +0,0 @@
/*
Formatted file input utility, function prototypes
Copyright (c) 2021 by Michael E. Leverington
Code is free for use in whole or in part and may be modified for other
non-commercial use as long as the above copyright statement is included.
*/
/*
Rev 0.0: 30 June 2021, Initial creation of file
UTILITY USAGE INSTRUCTIONS:
1) This utility contains functions that may be used for file input operations
using the C programming language with text files.
The utility must be linked with the program code with which
it will be used.
2) Specifications for all the functions
are provided in a standardized format below.
3) Use this code at your own risk. There is no guarantee of any performance,
implied or otherwise, for any part of this code
END OF INSTRUCTIONS
*/
// PreProcessor test
#ifndef FILE_INPUT_UTILITY_H
#define FILE_INPUT_UTILITY_H
// header files
#include <stdbool.h>
#include <stdio.h>
#include "StandardConstants.h"
// constants shared with other files
// non printable flag, used in getStringConfigured
static const char NON_PRINTABLE = (char)(127);
// constant used for zero character return
static const char ZERO_CHAR = '0';
// constant used for zero int/double value return
static const char ZERO_VALUE = 0;
// function prototypes
/*
Name: accessEndOfInputFileFlag
process: allows accessing or modifying end of file flag state;
note: flag is maintained (static) value initialized to false
Function input/parameters: control code (int), flag state (bool)
Function output/parameters: none
Function output/returned: result of flag state (bool)
Device input/file: none
Device output/monitor: none
Dependencies: none
*/
bool accessEndOfInputFileFlag( int ctrlCode, bool setFlag );
/*
Name: accessInputFilePointer
process: allows setting or accessing file pointer;
note: pointer is maintained (static) value initialized to NULL
Function input/parameters: control code (int), file pointer (FILE *)
DUMMY_INPUT_FILE_PTR used
if not setting file pointer
Function output/parameters: none
Function output/returned: file pointer (FILE *)
Device input/file: none
Device output/monitor: none
Dependencies: none
*/
FILE *accessInputFilePointer( int ctrlCode, const FILE *filePtr );
/*
Name: checkForEndOfInputFile
process: checks to see if end of file flag has been encountered,
returns true if EOF has been encountered, false otherwise
Function input/parameters: none
Function output/parameters: none
Function output/returned: result of specified test (bool)
Device input/file: none
Device output/monitor: none
Dependencies: accessEndOfInputFileFlag
*/
bool checkForEndOfInputFile();
/*
Name: checkForInputFileOpen
process: checks to see if file is currently open
returns true if file pointer not null, false otherwise
Function input/parameters: none
Function output/parameters: none
Function output/returned: result of specified test (bool)
Device input/file: none
Device output/monitor: none
Dependencies: accessInputFilePointer
*/
bool checkForInputFileOpen();
/*
Name: clearLeadingWhiteSpace
process: captures non printable characters,
and space if flag set,
returns first non white space value found as integer
Function input/parameters: file pointer (FILE *), clear space flag (bool)
Function output/parameters: none
Function output/returned: first non WS character as integer
Device input/file: value captured from file
Device output/monitor: none
Dependencies: fgetc
*/
int clearLeadingWhiteSpace( FILE *filePtr, bool clearSpace );
/*
Name: closeInputFile
process: closes input file, returns true if successful, false otherwise
Function input/parameters: none
Function output/parameters: none
Function output/returned: none
Device input/file: file closed
Device output/monitor: none
Dependencies: accessInputFilePointer, fclose, accessEndOfInputFileFlag
*/
bool closeInputFile();
/*
Name: openInputFile
process: opens input file, sets file pointer and unsets end of file flag,
returns true if successful, false otherwise
Function input/parameters: file name (c-string)
Function output/parameters: none
Function output/returned: success of operation (bool)
Device input/file: file opened
Device output/monitor: none
Dependencies: fopen, accessInputFilePointer, accessEndOfInputFileFlag
*/
bool openInputFile( const char *fileName );
/*
Name: readCharacterFromFile
process: ignores leading unprintable characters, including space,
captures first printable character
Function input/parameters: allow space capture (bool)
Function output/parameters: none
Function output/returned: character found if successful, ZERO_CHAR otherwise
Device input/file: character(s) captured from file as needed
Device output/monitor: none
Dependencies: readCharacterFromFileConfigured
*/
char readCharacterFromFile();
/*
Name: readCharacterFromFileConfigured
process: ignores leading unprintable characters,
captures first printable character,
including space if allowed
Function input/parameters: allow space capture (bool)
Function output/parameters: none
Function output/returned: character found if successful, ZERO_CHAR otherwise
Device input/file: character(s) captured from file as needed
Device output/monitor: none
Dependencies: checkForInputFileOpen, checkForEndOfInputFile,
accessInputFilePointer, clearLeadingWhiteSpace,
accessEndOfInputFileFlag
*/
char readCharacterFromFileConfigured( bool captureSpace );
/*
Name: readDoubleFromFile
process: ignores leading unprintable characters,
captures first contiguous double value
Function input/parameters: none
Function output/parameters: none
Function output/returned: double value found if successful (double)
Device input/file: double value captured from file
Device output/monitor: none
Dependencies: checkForInputFileOpen, checkForEndOfInputFile,
accessInputFilePointer, fscanf, accessEndOfInputFileFlag
*/
double readDoubleFromFile();
/*
Name: readIntegerFromFile
process: ignores leading unprintable characters,
captures first contiguous integer
Function input/parameters: none
Function output/parameters: none
Function output/returned: integer found if successful, ZERO_VALUE otherwise
Device input/file: character(s) captured from file as needed
Device output/monitor: none
Dependencies: checkForInputFileOpen, checkForEndOfInputFile,
accessInputFilePointer, fscanf, accessEndOfInputFileFlag
*/
int readIntegerFromFile();
/*
Name: readLongFromFile
process: ignores leading unprintable characters,
captures first contiguous long int
Function input/parameters: none
Function output/parameters: none
Function output/returned: long integer found if successful,
ZERO_VALUE otherwise
Device input/file: long value captured from file
Device output/monitor: none
Dependencies: checkForInputFileOpen, checkForEndOfInputFile,
accessInputFilePointer, fscanf, accessEndOfInputFileFlag
*/
long readLongFromFile();
/*
Name: readRawCharFromFile
process: captures first character in file stream including non-printable
Function input/parameters: none
Function output/parameters: none
Function output/returned: character found if successful, ZERO_CHAR otherwise
Device input/file: character captured from file
Device output/monitor: none
Dependencies: checkForInputFileOpen, checkForEndOfInputFile,
accessInputFilePointer, fgetc, accessEndOfInputFileFlag
*/
char readRawCharFromFile();
/*
Name: readStringConfiguredFromFile
Process: captures string with options:
- clear leading non printable (bool)
- clear leading space character (bool)
- adquires characters up to any non-printable (bool)
- adquires characters up to any printable delimiter (char)
- use constant NON_PRINTABLE if no delimiter
- also stops capture when full (MAX_STR_LEN)
Note: This function consumes the last character input,
including the space, delimiter, or non-printable character
Function input/parameters: see process above
Function output/parameters: captured string (char *), EMPTY_STRING otherwise
Function output/returned: success of operation (bool)
Device input/file: character(s) captured from file as needed
Device output/monitor: none
Dependencies: checkForInputFileOpen, checkForEndOfInputFile,
clearLeadingWhiteSpace, fgetc, accessEndOfInputFileFlag
*/
bool readStringConfiguredFromFile( bool clearLeadingNonPrintable,
bool clearLeadingSpace,
bool stopAtNonPrintable,
char delimiter,
char *capturedString );
/*
Name: readStringSegmentFromFile
process: ignores leading white space, including space character,
captures series of characters up to first space,
or end of line, or full string
Function input/parameters: none
Function output/parameters: captured string (char *), EMPTY_STRING otherwise
Function output/returned: success of operation (bool)
Device input/file: character(s) captured from file as needed
Device output/monitor: none
Dependencies: readStringConfigured with appropriate parameters
*/
bool readStringSegmentFromFile( char *capturedString );
/*
Name: readStringToLineEndFromFile
process: ignores leading white space, including space character,
captures series of characters up to end of current line
or full string
Function input/parameters: none
Function output/parameters: captured string (char *), EMPTY_STRING otherwise
Function output/returned: string found if successful
Device input/file: character(s) captured from file as needed
Device output/monitor: none
Dependencies: readStringConfigured with appropriate parameters
*/
bool readStringToLineEndFromFile( char *capturedString );
/*
Name: readStringToDelimiterFromFile
process: ignores leading white space, including space character,
captures series of characters up to specified character
Function input/parameters: none
Function output/parameters: captured string (char *), EMPTY_STRING otherwise
Function output/returned: string found if successful
Device input/file: character(s) captured from file as needed
Device output/monitor: none
Dependencies: readStringConfigured with appropriate parameters
*/
bool readStringToDelimiterFromFile( char delimiter, char *capturedString );
#endif // FILE_INPUT_UTILITY_H

511
PA02-0913/File_Output_Utility.c
View file

@ -1,511 +0,0 @@
/*
Formatted file ouput utility, function implementations
Copyright (c) 2021 by Michael E. Leverington
Code is free for use in whole or in part and may be modified for other
non-commercial use as long as the above copyright statement is included.
*/
// header files
#include "File_Output_Utility.h"
// local global constants, used only in this file
// dummy file pointer for accessInputFilePointer
const FILE *DUMMY_OUTPUT_FILE_PTR = NULL;
// dummy Boolean for accessEndOfInputFileFlag, accessOpenFlag
// const char DUMMY_OUTPUT_FLAG = false;
// control code for accessing file pointer, accessInputFilePointer
const int GET_OUTPUT_FILE_PTR = 6006;
// control code for accessing flag value,
// accessEndOfInputFileFlag, accessOpenFlag
const int GET_OUTPUT_FLAG = 9009;
// control code for setting file pointer, accessInputFilePointer
const int SET_OUTPUT_FILE_PTR = 8008;
// control code for setting flag value, accessEndOfInputFileFlag,
// accessOpenFlag
// const int SET_OUTPUT_FLAG = 1001;
/*
Name: accessOutputFilePointer
process: allows setting or accessing file pointer;
note: pointer is maintained (static) value initialized to NULL
Function input/parameters: control code (int), file pointer (FILE *)
DUMMY_OUTPUT_FILE_PTR used
if not setting file pointer
Function output/parameters: none
Function output/returned: file pointer (FILE *)
Device input/file: none
Device output/monitor: none
Dependencies: none
*/
FILE *accessOutputFilePointer( int ctrlCode, const FILE *filePtr )
{
static FILE *filePointer = NULL;
// check for set new pointer
if( ctrlCode == SET_OUTPUT_FILE_PTR )
{
// set file pointer to parameter
filePointer = (FILE *)filePtr;
}
// return file pointer
return filePointer;
}
/*
Name: closeOutputFile
Process: closes output file, returns true if successful, false otherwise
Function input/parameters: none
Function output/parameters: none
Function output/returned: operation success (bool)
Device input/file: none
Device output/file: output file closed
Dependencies: accessOutputFilePointer, fclose
*/
bool closeOutputFile()
{
// set local file pointer to working file pointer
// function: accessOutputFilePointer
FILE *filePtr = accessOutputFilePointer( GET_OUTPUT_FILE_PTR,
DUMMY_OUTPUT_FILE_PTR );
// check for valid file pointer
if( filePtr != NULL )
{
// add two more endlines to verify that the data is ended
// and has at least one extra newline after the data
// function: fprintf
fprintf( filePtr, "\n\n" );
// flush all data to the device
// function: fflush
fflush( filePtr );
// close file
// function: fclose
fclose( filePtr );
// set pointer to NULL
// function: accessOutputFilePointer
accessOutputFilePointer( SET_OUTPUT_FILE_PTR, NULL );
// return successful operation
return true;
}
// return failed operation
return false;
}
/*
Name: openOutputFile
Process: opens input file, returns true if successful, false otherwise
Function input/parameters: file name (c-string)
Function output/parameters: none
Function output/returned: operation success (bool)
Device input/file: none
Device output/file: output file opened
Dependencies: accessOutputFilePointer, fopen
*/
bool openOutputFile( const char *fileName )
{
// initialize variables
FILE *filePtr = accessOutputFilePointer( GET_OUTPUT_FILE_PTR,
DUMMY_OUTPUT_FILE_PTR );
char writeCharacter[] = "w";
// check for file not open
if( filePtr == NULL )
{
// open file
// function: fopen
filePtr = fopen( fileName, writeCharacter );
// check for success of file open
if( filePtr != NULL )
{
// set pointer in access function
// function: accessInputFilePointer
accessOutputFilePointer( SET_OUTPUT_FILE_PTR, filePtr );
// return operation success
return true;
}
}
// end of file not previously opened block
// return operation failure
return false;
}
/*
Name: writeCharacterToFile
Process: writes individual character to file,
returns true if successful, false otherwise
Function input/parameters: character to output (char)
Function output/parameters: none
Function output/returned: operation success (bool)
Device input/file: none
Device output/file: character written to file
Dependencies: accessOutputFilePointer, fprintf
*/
bool writeCharacterToFile( char outChar )
{
// initialize variables, set file pointer
// function: accessOutputFilePointer
FILE *filePtr = accessOutputFilePointer( GET_OUTPUT_FILE_PTR,
DUMMY_OUTPUT_FILE_PTR );
// check for open file
// function: checkForOutputFileOpen
if( filePtr != NULL )
{
// write character
// function: fprintf
fprintf( filePtr, "%c", outChar );
// return successful operation
return true;
}
// return failed operation
return false;
}
/*
Name: writeCharactersToFile
Process: writes multiple characters to file,
returns true if successful, false otherwise
Function input/parameters: number of characters to output (int),
character to output (char)
Function output/parameters: none
Function output/returned: operation success (bool)
Device input/file: none
Device output/file: multiple characters written to file
Dependencies: writeCharacterToFile
*/
bool writeCharactersToFile( int numChars, char outChar )
{
// check for number of characters remaining,
if( numChars > 0 )
{
// write character, check for success
// function: writeChar
if( writeCharacterToFile( outChar ) )
{
// continue recursion,
// check for downstream success
// function: writeChars
return writeCharactersToFile( numChars - 1, outChar );
}
// quit recursion
// return unsuccessful operation - write operation failed
return false;
}
// return successful operation - all characters have been written
return true;
}
/*
Name: writeDoubleToFile
Process: writes individual formatted double value to file,
returns true if successful, false otherwise
Function input/parameters: double value to output (double),
number of digits to right of radix point
(precision) (int)
Function output/parameters: none
Function output/returned: operation success (bool)
Device input/file: none
Device output/file: double written to file
Dependencies: writeDoubleJustifiedToFile
*/
bool writeDoubleToFile( double outVal, int precision )
{
// initialize variables, set block size to zero and justified to "LEFT"
int blockSize = 0;
char justified[] = "LEFT";
// call to justified function
// function: writeDoubleJustifiedToFile
return writeDoubleJustifiedToFile( outVal, precision,
blockSize, justified );
}
/*
Name: writeDoubleToFileJustified
Process: writes individual formatted double value to file justified,
returns true if successful, false otherwise
outVal - the double value to be output
precision - number of digits to the right of the radix point
blockSize - the width of the block within which
to print the integer value (int)
justify - "LEFT," "RIGHT," or "CENTER" justification
in block (c-string)
Function output/parameters: none
Function output/returned: operation success (bool)
Device input/file: none
Device output/file: double written to file as specified
Dependencies: sprintf, writeStringJustifiedToFile
*/
bool writeDoubleJustifiedToFile( double outVal, int precision,
int blockSize, const char *justified )
{
// initialize variables, create temp string for configuration string
char specStr[ MIN_STR_LEN ];
// initialize variables, create temporary output string
char outStr[ MIN_STR_LEN ];
// set configuration string with precision value
// function: sprintf
sprintf( specStr, "%s0.%dlf", "%", precision );
// set double to string
// function: sprintf
sprintf( outStr, specStr, outVal );
// write as string, return result
// function: writeStringJustified
return writeStringJustifiedToFile( outStr, blockSize, justified );
}
/*
Name: writeEndlineToFile
Process: writes newline ('\n') to file,
returns true if successful, false otherwise
Function input/parameters: none
Function output/parameters: none
Function output/returned: operation success (bool)
Device input/file: none
Device output/file: newline written to file
Dependencies: accessOutputFilePointer, fprintf
*/
bool writeEndlineToFile()
{
// get file pointer, initialize variable
// function: accessOutputFilePointer
FILE *filePtr = accessOutputFilePointer( GET_OUTPUT_FILE_PTR,
DUMMY_OUTPUT_FILE_PTR );
// check for open file
if( filePtr != NULL )
{
// print endline to file
// function: fprintf
fprintf( filePtr, "%c", NEWLINE_CHAR );
// return successful operation
return true;
}
// file not open, return failed operation
return false;
}
/*
Name: writeEndlinesToFile
Process: writes multiple carriage return ('\r')
and newline ('\n') pairs to file,
returns true if successful, false otherwise
Function input/parameters: number of endline pairs to write (int)
Function output/parameters: none
Function output/returned: operation success (bool)
Device input/file: none
Device output/file: multiple newline characters written to file
Dependencies: writeString
*/
bool writeEndlinesToFile( int numEndlines )
{
// check for number of characters remaining,
if( numEndlines > 0 )
{
// write endline, check for success
// function: writeEndlineTofile
if( writeEndlineToFile() )
{
// continue recursion,
// check for downstream success
// function: writeEndlinesToFile
return writeEndlinesToFile( numEndlines - 1 );
}
// quit recursion
// return unsuccessful operation - write operation failed
return false;
}
// return successful operation - all endlines have been written
return true;
}
/*
Name: writeIntegerToFile
Process: writes individual integer to file,
returns true if successful, false otherwise
Function input/parameters: integer to output (int)
Function output/parameters: none
Function output/returned: operation success (bool)
Device input/file: none
Device output/file: integer written to file
Dependencies: writeIntegerJustifiedToFile
*/
bool writeIntegerToFile( int outVal )
{
// initialize variables, set block size to zero and justified to "LEFT"
int blockSize = 0;
char justified[] = "LEFT";
// call to justified function
// function: writeDoubleJustifiedToFile
return writeIntegerJustifiedToFile( outVal, blockSize, justified );
}
/*
Name: writeIntegerJustifiedToFile
Process: writes individual integer to file,
returns true if successful, false otherwise
Function input/parameters:
outVal - the integer value to be output
precision - number of digits to the right of the radix point
blockSize - the width of the block within which
to print the integer value (int)
justify - "LEFT," "RIGHT," or "CENTER" justification
in block (c-string)
Function output/parameters: none
Function output/returned: operation success (bool)
Device input/file: none
Device output/file: integer written to file as specified
Dependencies: sprintf, writeStringJustifiedToFile
*/
bool writeIntegerJustifiedToFile( int outVal, int blockSize,
const char *justified )
{
// initialize variables, create temporary output string
char outStr[ MIN_STR_LEN ];
// set integer to string
// function: sprintf
sprintf( outStr, "%d", outVal );
// write as string, return result
// function: writeStringJustified
return writeStringJustifiedToFile( outStr, blockSize, justified );
}
/*
Name: writeStringToFile
Process: writes String value to file,
returns true if successful, false otherwise
Function input/parameters: double value to output (double),
number of digits to right of radix point
(precision) (int)
Function output/parameters: none
Function output/returned: operation success (bool)
Device input/file: none
Device output/file: String written to file
Dependencies: writeStringJustifiedToFile
*/
bool writeStringToFile( const char *outString )
{
// initialize variables, set block size to zero and justified to "LEFT"
int blockSize = 0;
char justified[] = "LEFT";
// call to justified function
// function: writeStringJustifiedToFile
return writeStringJustifiedToFile( outString, blockSize, justified );
}
/*
Name: writeStringJustifiedToFile
Process: write string to file within specified block size
and with specified justification
Function input/parameters:
outVal - the string value to be output
blockSize - the width of the block within which
to print the integer value (int)
justify - "LEFT," "RIGHT," or "CENTER" justification
in block (c-string)
Function output/parameters: None
Function output/returned: success of output operation (bool)
Function input/keyboard: None
Device output/file: string written to file as specified
Dependencies: strlen, strcmp, writeCharactersToFile, fprint
*/
bool writeStringJustifiedToFile( const char *outStr,
int blockSize, const char *justify )
{
// initialize variables, set pre-, post- spaces to zero
int preSpaces = 0, postSpaces = 0, strLength;
// get file pointer
// function: accessFileOutputFilePointer
FILE *filePtr = accessOutputFilePointer( GET_OUTPUT_FILE_PTR,
DUMMY_OUTPUT_FILE_PTR );
if( filePtr != NULL )
{
// find length of string
// function: strlen
strLength = strlen( outStr );
// check justification for "LEFT"
// function: strcmp
if( strcmp( justify, "LEFT" ) == 0 )
{
// set post spaces for left justification
postSpaces = blockSize - strLength;
}
// otherwise, check justification for "RIGHT"
// function: strcmp
else if( strcmp( justify, "RIGHT" ) == 0 )
{
// set pre spaces for right justification
preSpaces = blockSize - strLength;
}
// Otherwise, assume "CENTER" justification
else
{
// set pre spaces for centered
preSpaces = blockSize / 2 - strLength / 2;
// set post spaces for centered
postSpaces = blockSize - strLength - preSpaces;
}
// print pre spaces, check for success
// function: writeCharactersToFile
writeCharactersToFile( preSpaces, SPACE );
// print string
// function: fprintf
fprintf( filePtr, "%s", outStr );
// print post spaces
// function: printChars
writeCharactersToFile( postSpaces, SPACE );
// return successful operation
return true;
}
// return failed operation
return false;
}

236
PA02-0913/File_Output_Utility.h
View file

@ -1,236 +0,0 @@
/*
Formatted file output utility, function prototypes
Copyright (c) 2021 by Michael E. Leverington
Code is free for use in whole or in part and may be modified for other
non-commercial use as long as the above copyright statement is included.
*/
/*
Rev 0.0: 30 June 2021, Initial creation of file
UTILITY USAGE INSTRUCTIONS:
1) This utility contains functions that may be used for file input operations
using the C programming language with text files.
The utility must be linked with the program code with which
it will be used.
2) Specifications for all the functions
are provided in a standardized format below.
3) Use this code at your own risk. There is no guarantee of any performance,
implied or otherwise, for any part of this code
END OF INSTRUCTIONS
*/
// PreProcessor directives
#ifndef FILE_OUTPUT_UTILITY_H
#define FILE_OUTPUT_UTILITY_H
// header files
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include "StandardConstants.h"
// function prototypes
/*
Name: accessOutputFilePointer
process: allows setting or accessing file pointer;
note: pointer is maintained (static) value initialized to NULL
Function input/parameters: control code (int), file pointer (FILE *)
DUMMY_OUTPUT_FILE_PTR used
if not setting file pointer
Function output/parameters: none
Function output/returned: file pointer (FILE *)
Device input/file: none
Device output/monitor: none
Dependencies: none
*/
FILE *accessOutputFilePointer( int ctrlCode, const FILE *filePtr );
/*
Name: closeOutputFile
Process: closes output file, returns true if successful, false otherwise
Function input/parameters: none
Function output/parameters: none
Function output/returned: operation success (bool)
Device input/file: none
Device output/file: output file closed
Dependencies: accessOutputFilePointer, fclose
*/
bool closeOutputFile();
/*
Name: openOutputFile
Process: opens input file, returns true if successful, false otherwise
Function input/parameters: file name (c-string)
Function output/parameters: none
Function output/returned: operation success (bool)
Device input/file: none
Device output/file: output file opened
Dependencies: accessOutputFilePointer, fopen
*/
bool openOutputFile( const char *fileName );
/*
Name: writeCharacterToFile
Process: writes individual character to file,
returns true if successful, false otherwise
Function input/parameters: character to output (char)
Function output/parameters: none
Function output/returned: operation success (bool)
Device input/file: none
Device output/file: character written to file
Dependencies: accessOutputFilePointer, fprintf
*/
bool writeCharacterToFile( char outChar );
/*
Name: writeCharactersToFile
Process: writes multiple characters to file,
returns true if successful, false otherwise
Function input/parameters: number of characters to output (int),
character to output (char)
Function output/parameters: none
Function output/returned: operation success (bool)
Device input/file: none
Device output/file: multiple characters written to file
Dependencies: writeCharacterToFile
*/
bool writeCharactersToFile( int numChars, char outChar );
/*
Name: writeDoubleToFile
Process: writes individual formatted double value to file,
returns true if successful, false otherwise
Function input/parameters: double value to output (double),
number of digits to right of radix point
(precision) (int)
Function output/parameters: none
Function output/returned: operation success (bool)
Device input/file: none
Device output/file: double written to file
Dependencies: writeDoubleJustifiedToFile
*/
bool writeDoubleToFile( double outVal, int precision );
/*
Name: writeDoubleToFileJustified
Process: writes individual formatted double value to file justified,
returns true if successful, false otherwise
outVal - the double value to be output
precision - number of digits to the right of the radix point
blockSize - the width of the block within which
to print the integer value (int)
justify - "LEFT," "RIGHT," or "CENTER" justification
in block (c-string)
Function output/parameters: none
Function output/returned: operation success (bool)
Device input/file: none
Device output/file: double written to file as specified
Dependencies: sprintf, writeStringJustifiedToFile
*/
bool writeDoubleJustifiedToFile( double outVal, int precision,
int blockSize, const char *justified );
/*
Name: writeEndlineToFile
Process: writes newline ('\n') to file,
returns true if successful, false otherwise
Function input/parameters: none
Function output/parameters: none
Function output/returned: operation success (bool)
Device input/file: none
Device output/file: newline written to file
Dependencies: accessOutputFilePointer, fprintf
*/
bool writeEndlineToFile();
/*
Name: writeEndlinesToFile
Process: writes multiple carriage return ('\r')
and newline ('\n') pairs to file,
returns true if successful, false otherwise
Function input/parameters: number of endline pairs to write (int)
Function output/parameters: none
Function output/returned: operation success (bool)
Device input/file: none
Device output/file: multiple newline characters written to file
Dependencies: writeString
*/
bool writeEndlinesToFile( int numEndlines );
/*
Name: writeIntegerToFile
Process: writes individual integer to file,
returns true if successful, false otherwise
Function input/parameters: integer to output (int)
Function output/parameters: none
Function output/returned: operation success (bool)
Device input/file: none
Device output/file: integer written to file
Dependencies: writeIntegerJustifiedToFile
*/
bool writeIntegerToFile( int outVal );
/*
Name: writeIntegerJustifiedToFile
Process: writes individual integer to file,
returns true if successful, false otherwise
Function input/parameters:
outVal - the integer value to be output
precision - number of digits to the right of the radix point
blockSize - the width of the block within which
to print the integer value (int)
justify - "LEFT," "RIGHT," or "CENTER" justification
in block (c-string)
Function output/parameters: none
Function output/returned: operation success (bool)
Device input/file: none
Device output/file: integer written to file as specified
Dependencies: sprintf, writeStringJustifiedToFile
*/
bool writeIntegerJustifiedToFile( int outVal, int blockSize,
const char *justified );
/*
Name: writeStringToFile
Process: writes String value to file,
returns true if successful, false otherwise
Function input/parameters: double value to output (double),
number of digits to right of radix point
(precision) (int)
Function output/parameters: none
Function output/returned: operation success (bool)
Device input/file: none
Device output/file: String written to file
Dependencies: writeStringJustifiedToFile
*/
bool writeStringToFile( const char *outString );
/*
Name: writeStringJustifiedToFile
Process: write string to file within specified block size
and with specified justification
Function input/parameters:
outVal - the string value to be output
blockSize - the width of the block within which
to print the integer value (int)
justify - "LEFT," "RIGHT," or "CENTER" justification
in block (c-string)
Function output/parameters: None
Function output/returned: success of output operation (bool)
Function input/keyboard: None
Device output/file: string written to file as specified
Dependencies: strlen, strcmp, writeCharactersToFile, fprint
*/
bool writeStringJustifiedToFile( const char *outStr,
int blockSize, const char *justify );
#endif // FILE_OUTPUT_UTILITY_H

35
PA02-0913/Makefile
View file

@ -1,35 +0,0 @@
CC = gcc -Wall
SOURCES = PA02_Main.c StateUtilities.c Console_IO_Utility.c File_Input_Utility.c File_Output_Utility.c
OBJECTS = PA02_Main.o StateUtilities.o Console_IO_Utility.o File_Input_Utility.o File_Output_Utility.o
all: PA02_Main
PA02_Main: $(OBJECTS)
$(CC) $(OBJECTS) -o PA02_Main
PA02_Main.o: PA02_Main.c
$(CC) -c PA02_Main.c -o PA02_Main.o
StateUtilities.o: StateUtilities.c
$(CC) -c StateUtilities.c -o StateUtilities.o
Console_IO_Utility.o: Console_IO_Utility.c
$(CC) -c Console_IO_Utility.c -o Console_IO_Utility.o
File_Input_Utility.o: File_Input_Utility.c
$(CC) -c File_Input_Utility.c -o File_Input_Utility.o
File_Output_Utility.o: File_Output_Utility.c
$(CC) -c File_Output_Utility.c -o File_Output_Utility.o
clean:
rm -f $(OBJECTS) PA02_Main PA02_Main.out
clean_objects:
rm -f $(OBJECTS)
run:
./PA02_Main
run_win:
PA02_Main

120
PA02-0913/PA02_Main.c
View file

@ -1,120 +0,0 @@
// header file
#include "Console_IO_Utility.h"
#include "StateUtilities.h"
// local constants for program
const int MAX_NUM_STATES = 50;
int main()
{
// initialize function/program
// initialize variables
int wkgNumStates, sortingNumStates;
int capacity = MAX_NUM_STATES;
char fileName[ MIN_STR_LEN ];
StateDataType *wkgArray, *sortingArray;
StateDataType resultData, searchData, removeData;
// show title
// function: showTitle
showTitle();
// create input/working and sorting arrays
wkgArray = createStateArray( MAX_NUM_STATES );
sortingArray = createStateArray( MAX_NUM_STATES );
// set empty data - data items will only have the state name
setEmptyElementData( &searchData );
strcpy( searchData.name, "North Dakota" );
setEmptyElementData( &removeData );
strcpy( removeData.name, "Wyoming" );
// get input
// get file name
// function: getFileName
promptForString( "Enter file name: ", fileName );
// upload state data
// function: uploadstateData
wkgNumStates = uploadStateData( wkgArray, capacity, fileName );
if( wkgNumStates > 0 )
{
// make copy of working array for later sorting use
sortingNumStates = wkgNumStates;
copyArray( sortingArray, wkgArray, sortingNumStates );
// process and display data
// display original list
displayData( wkgArray, wkgNumStates, "Original data after upload" );
// find state
printf( "\nFinding state: %s\n", searchData.name );
findStateByName( &resultData, wkgArray, wkgNumStates, searchData );
printf( "State found: %s, %d, %5.2f%%, %c\n", resultData.name,
resultData.population,
resultData.growth * 100.00,
resultData.majority );
// remove state
printf( "\nRemoving state: %s\n", removeData.name );
removeStateByName( &resultData, wkgArray, &wkgNumStates, removeData );
printf( "State removed: %s, %d, %5.2f%%, %c\n", resultData.name,
resultData.population,
resultData.growth * 100.00,
resultData.majority );
// display original list
displayData( wkgArray, wkgNumStates,
"Original data after state removal" );
// bubble sort
// function: runBubbleSort
runBubbleSortByName( sortingArray, sortingNumStates );
// display bubble-sorted list
displayData( sortingArray, sortingNumStates,
"Full list sorted by name using bubble sort" );
// insertion sort
// function: runInsertionSort
runInsertionSortByPopulation( sortingArray, sortingNumStates );
// display insertion-sorted list
displayData( sortingArray, sortingNumStates,
"Full list sorted by population using insertion sort" );
// selection sort
// function: runSelectionSort
runSelectionSortByGrowth( sortingArray, sortingNumStates );
// display insertion-sorted list
displayData( sortingArray, sortingNumStates,
"Full list sorted by growth using selection sort" );
}
else
{
printf( "\nData upload failed - program aborted\n" );
}
// end program
// report end program
// function: printf
printf( "\nProgram End\n" );
// clear dynamic array
wkgArray = clearStateArray( wkgArray );
sortingArray = clearStateArray( sortingArray );
// return program success
return 0;
}

73
PA02-0913/StandardConstants.h
View file

@ -1,73 +0,0 @@
// Preprocessor directives
#ifndef STANDARD_CONSTANTS_H
#define STANDARD_CONSTANTS_H
// Include Boolean
#include <stdbool.h>
// global constants
// constant for end of c-string null character
#define CARRIAGE_RETURN_CHAR '\r'
//constant for a COLON
#define COLON ':'
//constant for a COMMA
#define COMMA ','
//Constant to print a dash
#define DASH '-'
// highest printable character
#define HIGHEST_PRINTABLE_CHAR '~'
// constant for huge string length
#define HUGE_STR_LEN 256
// lowest printable character
#define LOWEST_PRINTABLE_CHAR ' '
// constant for small string length
#define MIN_STR_LEN 32
// constant for maximum string length
#define MAX_STR_LEN 128
// constant for end of c-string null character
#define NEWLINE_CHAR '\n'
// first non-printable above ASCII
#define DELETE_KEY 127
// constant for end of c-string null character
#define NULL_CHAR '\0'
// columns found in grade sheet before grading columns
#define NUM_BASE_COLS 5
// constant for number of grading frequency bins
#define NUM_FREQUENCY_BINS 10
//Constant for printing a pipe
#define PIPE '|'
//Constant for a period
#define PERIOD '.'
//Constant for PRECISION, 2 digits
#define PRECISION_2 2
//Constant for PRECISION, 4 digits
#define PRECISION_4 4
// constant for space character
#define SPACE ' '
// constant for standard string length
#define STD_STR_LEN 64
// constant for smallest string length
#define TINY_STR_LEN 16
#endif // STANDARD_CONSTANTS

297
PA02-0913/StateUtilities.c
View file

@ -1,297 +0,0 @@
#include "StateUtilities.h"
// local constants
const int NAME_BLOCK_SIZE = 16;
const int POPULATION_BLOCK_SIZE = 12;
const int GROWTH_BLOCK_SIZE = 10;
// functions
/*
Name: addElementFromData
Process: adds all individual data values to StateDataType array
if capacity has not been exceeded,
returns true upon success, false otherwise
Function input/parameters: data array (StateDataType *),
size (int), capacity (int),
state name (const char *),
state population (int),
state growth (double),
state political majority (char)
Function output/parameters: updated data array (StateDataType *),
updated size (int *)
Function output/returned: Boolean result of operation as specified
Device input/---: none
Device output/---: none
Dependencies: as needed, including strcpy
*/
bool addElementFromData( StateDataType *stateArr, int *size, int capacity,
const char *stateName, int statePop,
double stateGrowth, char politicalMajority )
{
//
return NULL;
}
/*
Name: addElementFromElement
Process: adds data from element to StateDataType array,
uses supporting function
Function input/parameters: data array (StateDataType *),
size and capacity (int),
source element (const StateDataType)
Function output/parameters: updated data array (StateDataType *),
updated size (int *)
Function output/returned: Boolean result of operation as specified
Device input/---: none
Device output/---: none
Dependencies: addElementFromData - function uses one code statement
*/
bool addElementFromElement( StateDataType *stateArr, int *size, int capacity,
const StateDataType state )
{
//
return NULL;
}
/*
Name: clearStateArray
Process: deallocates dynamically allocated array from memory
Function input/parameters: data array (StateDataType *)
Function output/parameters: none
Function output/returned: NULL
Device input/---: none
Device output/---: none
Dependencies: as needed, including free
*/
StateDataType *clearStateArray( StateDataType *array )
{
//
return NULL;
}
/*
Name: copyArray
Process: copies state data elements from one array to another
Function input/parameters: source array (const StateDataType *), size (int)
Function output/parameters: pointer to destination array (StateDataType *)
Function output/returned: none
Device input/---: none
Device output/---: none
Dependencies: as needed
*/
void copyArray( StateDataType *dest, const StateDataType *src, int srcSize )
{
// no return, void
}
/*
Name: createStateArray
Process: dynamically allocates array memory
Function input/parameters: initial capacity (int)
Function output/parameters: none
Function output/returned: pointer to newly created array (StateDataType *)
Device input/---: none
Device output/---: none
Dependencies: as needed, including function malloc and keyword sizeof
*/
StateDataType *createStateArray( int initialCapacity )
{
//
return NULL;
}
/*
Name: deepCopy
Process: copies all individual values from StateDataType source
to StateDataType destination
Function input/parameters: source element (const StateDataType)
Function output/parameters: pointer to destination value (StateDataType *)
Function output/returned: none
Device input/---: none
Device output/---: none
Dependencies: as needed, including strcpy
*/
void deepCopy( StateDataType *dest, const StateDataType src )
{
// no return, void
}
/*
Name: displayData
Process: displays element data in array as table if array is not empty,
otherwise displays "Data not found - Display aborted",
allows for subtitle to be added to "Display Data - "
Function input/parameters: state data array (const StateDataType *),
size (int), subtitle (const char *)
Function output/parameters: none
Function output/returned: none
Device input/---: none
Device output/monitor: data displayed as specified
Dependencies: as needed
*/
void displayData( const StateDataType *array, int size, const char *subTitle )
{
// no return, void
}
/*
Name: findStateByName
Process: finds element value in array by state name if it exists in the array,
saves data in return parameter and returns true,
otherwise sets data in return parameter to empty and returns false
Function input/parameters: state data array (const StateDataType *),
size (int), search value (const StateDataType)
Function output/parameters: value if found as return parameter,
otherwise, return parameter set to empty
(StateDataType *)
Function output/returned: Boolean result of operation
Device input/---: none
Device output/---: none
Dependencies: as needed
*/
bool findStateByName( StateDataType *foundElement,
const StateDataType *array, int size, const StateDataType searchValue )
{
//
return NULL;
}
/*
Name: removeStateByName
Process: searches for element, if found, sets data into return parameter,
shifts all remaining data down, and returns true,
otherwise sets data in return parameter to empty and returns false
Function input/parameters: state data array (StateDataType *),
size (int), search value (const StateDataType)
Function output/parameters: updated state data array (StateDataType *),
value if found and removed,
otherwise, value set to empty (StateDataType *),
updated size (int *)
Function output/returned: Boolean result of operation as specified
Device input/---: none
Device output/---: none
Dependencies: as needed
*/
bool removeStateByName( StateDataType *removedElement,
StateDataType *array, int *size, const StateDataType searchVal )
{
//
return NULL;
}
/*
Name: runBubbleSortByName
Process: sorts state data by name using bubble sort algorithm
Function input/parameters: state data array (StateDataType *), size (int)
Function output/parameters: updated state data array (StateDataType *)
Function output/returned: none
Device input/---: none
Device output/---: none
Dependencies: as needed
*/
void runBubbleSortByName( StateDataType *array, int size )
{
// no return, void
}
/*
Name: runInsertionSortByPopulation
Process: sorts state data by population using insertion sort algorithm
Function input/parameters: state data array (StateDataType *), size (int)
Function output/parameters: updated state data array (StateDataType *)
Function output/returned: none
Device input/---: none
Device output/---: none
Dependencies: as needed, swap may not be used
*/
void runInsertionSortByPopulation( StateDataType *array, int size )
{
// no return, void
}
/*
Name: runSelectionSortByGrowth
Process: sorts state data by growth using selection sort algorithm
Function input/parameters: state data array (StateDataType *), size (int)
Function output/parameters: updated state data array (StateDataType *)
Function output/returned: none
Device input/---: none
Device output/---: none
Dependencies: as needed
*/
void runSelectionSortByGrowth( StateDataType *array, int size )
{
// no return, void
}
/*
Name: setEmptyElementData
Process: sets state data type to empty or default values,
name to empty string, population and growth to zero,
and majority to 'x'
Function input/parameters: none
Function output/parameters: state data value (StateDataType *)
Function output/returned: none
Device input/---: none
Device output/---: none
Dependencies: none
*/
void setEmptyElementData( StateDataType *element )
{
// no return, void
}
/*
Name: showTitle
Process: displays program title with thick underline,
"Data Management with N-Squared Sorting"
Function input/parameters: none
Function output/parameters: none
Function output/returned: none
Device input/---: none
Device output/monitor: displays title as specified
Dependencies: as needed
*/
void showTitle()
{
// no return, void
}
/*
Name: swapElements
Process: swaps state data elements within an array
Function input/parameters: given array (StateDataType *),
left and right indices to be swapped (int)
Function output/parameters: updated array with swapped values (StateDataType *)
Function output/returned: none
Device input/---: none
Device output/---: none
Dependencies: as needed
*/
void swapElements( StateDataType *array, int leftIndex, int rightIndex )
{
// no return, void
}
/*
Name: uploadStateData
Process: uploads data from given file to state data array,
ignores first (title) line in .csv file,
then captures comma-delimited state name, population, growth,
and political majority data on each row,
returns number of items found;
stops uploading process if array is full
Function input/parameters: capacity (int) and file name (const char *)
Function output/parameters: updated array with uploaded values (StateDataType *)
Function output/returned: number of items uploaded (int)
Device input/HD: data uploaded from text file as specified
Device output/---: none
Dependencies: as needed
*/
int uploadStateData( StateDataType *StateDataArray,
int capacity, const char *fileName )
{
//
return 0;
}

263
PA02-0913/StateUtilities.h
View file

@ -1,263 +0,0 @@
#ifndef STATE_UTILITIES_H
#define STATE_UTILITIES_H
// header files
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "Console_IO_Utility.h"
#include "File_Input_Utility.h"
#include "StandardConstants.h"
// global constants
// data structure
typedef struct StateDataStruct
{
char name[ STD_STR_LEN ];
int population;
double growth;
char majority;
} StateDataType;
// Prototypes
/*
Name: addElementFromData
Process: adds all individual data values to StateDataType array
if capacity has not been exceeded,
returns true upon success, false otherwise
Function input/parameters: data array (StateDataType *),
size (int), capacity (int),
state name (const char *),
state population (int),
state growth (double),
state political majority (char)
Function output/parameters: updated data array (StateDataType *),
updated size (int *)
Function output/returned: Boolean result of operation as specified
Device input/---: none
Device output/---: none
Dependencies: as needed, including strcpy
*/
bool addElementFromData( StateDataType *stateArr, int *size, int capacity,
const char *stateName, int statePop,
double stateGrowth, char politicalMajority );
/*
Name: addElementFromElement
Process: adds data from element to StateDataType array,
uses supporting function
Function input/parameters: data array (StateDataType *),
size and capacity (int),
source element (const StateDataType)
Function output/parameters: updated data array (StateDataType *),
updated size (int *)
Function output/returned: Boolean result of operation as specified
Device input/---: none
Device output/---: none
Dependencies: addElementFromData - function uses one code statement
*/
bool addElementFromElement( StateDataType *stateArr, int *size, int capacity,
const StateDataType state );
/*
Name: clearStateArray
Process: deallocates dynamically allocated array from memory
Function input/parameters: data array (StateDataType *)
Function output/parameters: none
Function output/returned: NULL
Device input/---: none
Device output/---: none
Dependencies: as needed, including free
*/
StateDataType *clearStateArray( StateDataType *array );
/*
Name: copyArray
Process: copies state data elements from one array to another
Function input/parameters: source array (const StateDataType *), size (int)
Function output/parameters: pointer to destination array (StateDataType *)
Function output/returned: none
Device input/---: none
Device output/---: none
Dependencies: as needed
*/
void copyArray( StateDataType *dest, const StateDataType *src, int srcSize );
/*
Name: createStateArray
Process: dynamically allocates array memory
Function input/parameters: initial capacity (int)
Function output/parameters: none
Function output/returned: pointer to newly created array (StateDataType *)
Device input/---: none
Device output/---: none
Dependencies: as needed, including function malloc and keyword sizeof
*/
StateDataType *createStateArray( int initialCapacity );
/*
Name: deepCopy
Process: copies all individual values from StateDataType source
to StateDataType destination
Function input/parameters: source element (const StateDataType)
Function output/parameters: pointer to destination value (StateDataType *)
Function output/returned: none
Device input/---: none
Device output/---: none
Dependencies: as needed, including strcpy
*/
void deepCopy( StateDataType *dest, const StateDataType src );
/*
Name: displayData
Process: displays element data in array as table if array is not empty,
otherwise displays "Data not found - Display aborted",
allows for subtitle to be added to "Display Data - "
Function input/parameters: state data array (const StateDataType *),
size (int), subtitle (const char *)
Function output/parameters: none
Function output/returned: none
Device input/---: none
Device output/monitor: data displayed as specified
Dependencies: as needed
*/
void displayData( const StateDataType *array, int size, const char *subTitle );
/*
Name: findStateByName
Process: finds element value in array by state name if it exists in the array,
saves data in return parameter and returns true,
otherwise sets data in return parameter to empty and returns false
Function input/parameters: state data array (const StateDataType *),
size (int), search value (const StateDataType)
Function output/parameters: value if found as return parameter,
otherwise, return parameter set to empty
(StateDataType *)
Function output/returned: Boolean result of operation
Device input/---: none
Device output/---: none
Dependencies: as needed
*/
bool findStateByName( StateDataType *foundElement,
const StateDataType *array, int size, const StateDataType searchValue );
/*
Name: removeStateByName
Process: searches for element, if found, sets data into return parameter,
shifts all remaining data down, and returns true,
otherwise sets data in return parameter to empty and returns false
Function input/parameters: state data array (StateDataType *),
size (int), search value (const StateDataType)
Function output/parameters: updated state data array (StateDataType *),
value if found and removed,
otherwise, value set to empty (StateDataType *),
updated size (int *)
Function output/returned: Boolean result of operation as specified
Device input/---: none
Device output/---: none
Dependencies: as needed
*/
bool removeStateByName( StateDataType *removedElement,
StateDataType *array, int *size, const StateDataType searchVal );
/*
Name: runBubbleSortByName
Process: sorts state data by name using bubble sort algorithm
Function input/parameters: state data array (StateDataType *), size (int)
Function output/parameters: updated state data array (StateDataType *)
Function output/returned: none
Device input/---: none
Device output/---: none
Dependencies: as needed
*/
void runBubbleSortByName( StateDataType *array, int size );
/*
Name: runInsertionSortByPopulation
Process: sorts state data by population using insertion sort algorithm
Function input/parameters: state data array (StateDataType *), size (int)
Function output/parameters: updated state data array (StateDataType *)
Function output/returned: none
Device input/---: none
Device output/---: none
Dependencies: as needed, swap may not be used
*/
void runInsertionSortByPopulation( StateDataType *array, int size );
/*
Name: runSelectionSortByGrowth
Process: sorts state data by growth using selection sort algorithm
Function input/parameters: state data array (StateDataType *), size (int)
Function output/parameters: updated state data array (StateDataType *)
Function output/returned: none
Device input/---: none
Device output/---: none
Dependencies: as needed
*/
void runSelectionSortByGrowth( StateDataType *array, int size );
/*
Name: setEmptyElementData
Process: sets state data type to empty or default values,
name to empty string, population and growth to zero,
and majority to 'x'
Function input/parameters: none
Function output/parameters: state data value (StateDataType *)
Function output/returned: none
Device input/---: none
Device output/---: none
Dependencies: none
*/
void setEmptyElementData( StateDataType *element );
/*
Name: showTitle
Process: displays program title with thick underline,
"Data Management with N-Squared Sorting"
Function input/parameters: none
Function output/parameters: none
Function output/returned: none
Device input/---: none
Device output/monitor: displays title as specified
Dependencies: as needed
*/
void showTitle();
/*
Name: swapElements
Process: swaps state data elements within an array
Function input/parameters: given array (StateDataType *),
left and right indices to be swapped (int)
Function output/parameters: updated array with swapped values (StateDataType *)
Function output/returned: none
Device input/---: none
Device output/---: none
Dependencies: as needed
*/
void swapElements( StateDataType *array, int leftIndex, int rightIndex );
/*
Name: uploadStateData
Process: uploads data from given file to state data array,
ignores first (title) line in .csv file,
then captures comma-delimited state name, population, growth,
and political majority data on each row,
returns number of items found;
stops uploading process if array is full
Function input/parameters: capacity (int) and file name (const char *)
Function output/parameters: updated array with uploaded values (StateDataType *)
Function output/returned: number of items uploaded (int)
Device input/HD: data uploaded from text file as specified
Device output/---: none
Dependencies: as needed
*/
int uploadStateData( StateDataType *StateDataArray,
int capacity, const char *fileName );
#endif // STATE_UTILITIES_H

20
TypicalUtils/Makefile
View file

@ -1,20 +0,0 @@
CC = gcc -Wall
SOURCES = main.c get_student_id.c
OBJECTS = main.o get_student_id.o
all: main.out
main.out: main
./main | tee main.out
main: $(OBJECTS)
$(CC) $(OBJECTS) -o main
main.o: main.c
$(CC) -c main.c -o main.o
get_student_id.o: get_student_id.c
$(CC) -c get_student_id.c -o get_student_id.o
clean:
rm -f $(OBJECTS) main main.out