Upload Lab 6 Files

++ Lab 6 Files

Signed-off-by: cdez <cdez@cdezselfhosted.pw>

Lab06/Console_IO_Utility.c

@@ -0,0 +1,590 @@
+// 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 );
+   }
+
+

Lab06/Console_IO_Utility.h

@@ -0,0 +1,291 @@
+// Preprocessor directive
+#ifndef CONSOLE_IO_UTILITY_H
+#define CONSOLE_IO_UTILITY_H
+
+//Header Files
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <time.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

Lab06/Lab_6_provided.c

@@ -0,0 +1,186 @@
+// header files
+#include "Console_IO_Utility.h"
+
+// global constants
+    // none
+
+// function prototypes
+int generateRandChoice();
+char playGame();
+char whoWins();
+
+// main program
+int main()
+    {
+     // show title
+        // function: printString, printEndline(s)
+    printEndline();
+    printString( "Rock / Paper / Scissors" );
+    printEndline();
+
+
+	 // initialize variables/functions
+     int userInput;
+	   char winner;
+
+
+	 // get user input
+        // Display options of user input
+            // functions: printString, printEndline
+	 printString("Options to choose:");
+	 printEndline();
+	 printString("0 - Scissors");
+	 printEndline();
+	 printString("1 - Paper");
+	 printEndline();
+	 printString("2 - Rock");
+	 printEndline();
+
+   // get users value for rock/paper/scissors
+      // function: promptForInteger, printEndline
+	 userInput = promptForInteger("Enter your value: ");
+	 printEndline();
+
+  // check for valid user input, if valid,
+  if (userInput > -1 && userInput < 3)
+    {
+     // use playGame
+     winner = playGame(userInput);
+     // display winner.
+       // functions: printString, printCharacter, printEndline
+     printString("The winner is: ");
+     printCharacter(winner);
+     printEndline();
+    }
+    else
+    {
+      // else, return zero and end the program,
+         // print "Sorry no such option! Try again"
+      printString("Sorry no such option! Try again");
+    }
+    return 0;
+   }
+
+// supporting functions
+
+/*
+Name: playGame
+Process: plays rock paper scissors game, generates random choice for AI player
+         and returns who won the game
+Function input/parameters: previously chosen players input
+                            rock / paper / scissors represented by 2 / 1 / 0
+Function output/parameters: none
+Function output/returned: character which represents who won the game
+Function input/keyboard: none
+Device output/file: none
+Dependencies: generateRandChoice, whoWins
+*/
+
+char playGame(int userInputValue)
+{
+  // initialize variables
+  int computerChoice;
+
+  // calculate computerChoice
+  computerChoice = generateRandChoice();
+
+  // return who whoWins
+  return whoWins(userInputValue, computerChoice);
+
+}
+
+/*
+Name: whoWins
+Process: based on user input and randomly generated value decides who wins
+         via series of decision making statements
+Function input/parameters: previously chosen players input
+                            rock / paper / scissors represented by 2 / 1 / 0
+                            and randomly generated number of the same range
+Function output/parameters: none
+Function output/returned: character which represents who won the game
+                            'U' - user; 'R' - random (AI); 'F' - friendship.
+Function input/keyboard: none
+Device output/file: none
+Dependencies: none
+*/
+
+char whoWins(int playerInputValue, int computerChoice)
+{
+  // define variables
+  char winnerCharacter;
+  // get function input
+    // given by values: playerInputValue, computerChoice
+
+// do calculations/comparisons
+  if (playerInputValue == computerChoice)
+  {
+    // check to see if the player and computer picked the same choice
+    winnerCharacter = 'F';
+  }
+  else
+  {
+    // otherwise, check which values the player chose versus the computer.
+    if(playerInputValue == 0 && computerChoice == 1)
+    {
+      // player loses, computer wins
+      winnerCharacter = 'R';
+    }
+    else if (playerInputValue == 1 && computerChoice == 0)
+    {
+      // player wins, computer loses
+      winnerCharacter = 'U';
+    }
+    else if (playerInputValue == 2 && computerChoice == 0)
+    {
+      // player wins, computer loses
+      winnerCharacter = 'U';
+    }
+    else if (playerInputValue == 0 && computerChoice == 2)
+    {
+      // player loses, computer wins
+      winnerCharacter = 'R';
+    }
+    else if (playerInputValue == 1 && computerChoice == 2)
+    {
+      // player wins, computer loses
+      winnerCharacter = 'U';
+    }
+    else
+    {
+      // player loses, computer wins. (playerInputValue == 2, computerChoice == 1)
+      winnerCharacter = 'R';
+    }
+  }
+
+// return output
+return winnerCharacter;
+}
+
+/*
+Name: generateRandChoice
+Process: based on user input and randomly generated value decides who wins
+         via series of decision making statments
+Function input/parameters: previously chosen players input
+                            rock / paper / scissors represented by 2 / 1 / 0
+                            and randomly generated number of the same range
+Function output/parameters: none
+Function output/returned: character which represents who won the game
+                            'U' - user; 'R' - random (AI); 'F' - friendship.
+Function input/keyboard: none
+Device output/file: none
+Dependencies: none
+*/
+int generateRandChoice()
+	{
+     // initialize variables
+	 int randNum;
+
+     // computations
+        // initialize random seed
+	 srand(time(0));
+        // generate random number between 0 and 2 (inclusive)
+	 randNum = rand() % 2 + rand() % 2;
+
+     // return result
+	 return randNum;
+	}

Lab06/StandardConstants.h

@@ -0,0 +1,54 @@
+// 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 '-'
+
+// constant for huge string length
+#define HUGE_STR_LEN 256
+
+// constant for end of c-string null character
+#define NEWLINE_CHAR '\n'
+
+// 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 NULL_CHAR '\0'
+
+//Constant for printing a pipe
+#define PIPE '|'
+
+//Constant for a period
+#define PERIOD '.'
+
+//Constant for PRECISION
+#define PRECISION 2
+
+// constant for space character
+#define SPACE ' '
+
+// constant for standard string length
+#define STD_STR_LEN 64
+
+#endif  // STANDARD_CONSTANTS
+
+