cdez
7452a9ca4f
Added Project 1/Homework 1 and Lab 1. Modified the Lab 2 folder to match conventions.
590 lines
17 KiB
C
590 lines
17 KiB
C
// 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 );
|
|
}
|
|
|
|
|