I cant get my code to work and/or finish it. Please fix. Below are code instructions and then sample runs and lastly my code so far.

//*********************************************************************

Program

You will write a program that uses a recursive function to determine whether a string is a character unit palindrome. Moreover, flags can be used to indicate whether to do case sensitive comparisons and whether to ignore spaces. For example "A nut for a jar of tuna" is a palindrome if spaces are ignored and not otherwise. "Step on no pets" is a palindrome whether spaces are ignored or not, but is not a palindrome if it is case sensitive since the S and s are not the same.

Background

Palindromes are character sequences that read the same forward or backwards (e.g. the strings "mom" or "123 454 321"). Punctuation and spaces are frequently ignored so that phrases like "Dog, as a devil deified, lived as a god." are palindromes. Conversely, even if spaces are not ignored phrases like "Rats live on no evil star" are still palindromes. .

Specifications

Command Line Parameters

The program name will be followed by a list of strings. The program will determine whether each string is a palindrome and output the results. Punctuation will always be ignored. An optional flag can precede the terms that modifies how a palindrome is determined.

Strings

Each string will be separated by a space on the command line. If you want to include a string that has spaces in it (e.g. "Rats live on no evil star"), then put quotes around it. The quote characters will not be part of the string that is read in.

Flags

Optional for the user

If present, flags always appear immediately after the program name and before any strings are processed and apply to all subsequent strings processed.

Flags must start with a minus (-) sign followed by flag values that can be capital or lowercase. e.g. -c, -S, -Cs, -Sc, -alphabetsoup, etc.

There are no spaces between starting minus (-) sign and flag(s).

Flags values are case insensitive.

c or C: Indicates that comparisons should be case-sensitive for all input strings. The default condition (i.e. if the flag is NOT included) is to ignore case-sensitivity. So, for example:

palindrome Mom should evaluate as being a palindrome.

palindrome -c Mom should not evaluate as being a palindrome.

s or S: Indicates that comparisons should not ignore spaces for all input strings. The default condition (i.e. if the flag is NOT included) is to ignore spaces. So, for example:

palindrome "A nut for a jar of tuna" should evaluate as being a palindrome.

palindrome -s "A nut for a jar of tuna" should not evaluate as being a palindrome.

Any flag values beside c and s are invalid (see program flow notes below)

Options can appear in different flags, e.g. you can use -Sc or -S -c

Repeated flags should be ignored, e.g. -ccs

The argument -- (two dashes) signifies that every argument that follows is not a flag (allowing for strings that begin with a dash), e.g. palindrome -- -s

Code Expectations

Your program should only get user input from the command line. (i.e. "cin" should not be anywhere in your code).

Required Functions:

Function that prints program usage message in case no input strings were found at command line.

Name: printUsageInfo

Parameter(s): a string representing the name of the executable from the command line. (Not a c string)

Return: void.

Function that determines whether a string is a character-unit palindrome.

Name: isPalindrome

Parameter(s): an input string, a boolean flag that considers case-sensitivity when true, and a boolean flag that ignores spaces when true. (Not a c string)

Return: bool.

Calls helper function isPalindromeR to determine whether string is a palindrome.

String passed into isPalindromeR after dealing with flags.

If case insensitive, make all lower or upper case so that case does not matter.

If spaces are ignored, remove spaces from string.

Helper recursive function that determines whether a string is a character-unit palindrome. This does not deal with flags.

Name: isPalindromeR

Parameter(s): an input string (Not a c string)

Return: bool

All functions should be placed in a separate file following the code organization conventions we covered.

Program Flow

Your program will take arguments from the command-line.

Determine if you have enough arguments. If not, output a usage message and exit program.

If flags are present.

Process and set values to use when processing a palindrome.

Loop through remaining arguments which are all input strings:

Process each by calling isPalindrome function with flag values.

Output results

Program Flow Notes:

Any time you encounter a syntax error, you should print a usage message and exit the program immediately.

E.g. an invalid flag

Hints

Remember rules for a good recursive function.

Recommended Functions to write:

Note: You could combine these into a single function. e.g. "preprocessString"

tolower - convert each letter to lowercase version for case insensitive comparisons.

Parameter(s): a string to be converted to lowercase

Return: a string with all lowercase characters

removePunctuation - Remove all punctuation marks possibly including spaces depending on the flag value.

Parameter(s): a string and a boolean flag indicating whether to also remove spaces

Return: a string with punctuation/spaces removed

Existing functions that might help:

tolower

substr

isalnum

erase (This can be used instead of substr, but is a bit more complicated.)

Example Output

Assumes executable is named palindrome

$ g++ -o palindrome

./palindrome

Usage: ./palindrome [-c] [-s] string ...

-c: turn on case sensitivity

-s: turn off ignoring spaces

./palindrome -c

Usage: ./palindrome [-c] [-s] string ...

-c: turn on case sensitivity

-s: turn off ignoring spaces

./palindrome Kayak

"Kayak" is a palindrome.

./palindrome -c Kayak

"Kayak" is not a palindrome.

./palindrome -C Kayak

"Kayak" is not a palindrome.

./palindrome -c kayak

"kayak" is a palindrome.

./palindrome "Test Set"

"Test Set" is a palindrome.

./palindrome -sc "Test Set"

"Test Set" is not a palindrome.

./palindrome -s -c "Test Set"

"Test Set" is not a palindrome.

./palindrome -s -s "Test Set"

"Test Set" is not a palindrome.

./palindrome -scs "Test Set"

"Test Set" is not a palindrome.

./palindrome Kayak madam "Test Set" "Evil Olive" "test set" "loop pool"

"Kayak" is a palindrome.

"madam" is a palindrome.

"Test Set" is a palindrome.

"Evil Olive" is a palindrome.

"test set" is a palindrome.

"loop pool" is a palindrome.

#include

#include

#include

using namespace std;

void printUsageInfo(string executableName) {

cout << "Usage: " << executableName << " [-c] [-s] string ... " << endl;

cout << " -c: turn on case sensitivity" << endl;

cout << " -s: turn off ignoring spaces" << endl;

exit(1);

//prints program usage message in case no strings were found at command line

}

bool isPalindrome(string str, bool caps, bool space) {

//determines whether a string is a character-unit palindrome

//should do everytyhing to find palindrome

return false;

}

bool isPalindromeR(string str, start, end) {

if (start >= end)

return true;

if(str.at(start) != str.at(end))

return false;

return isPalindromeR(str, ++start, --end);

//helper recursive function that determines whether string is a character-unit palindrome

}

string tolower(string str) {

for (unsigned int i = 0; i < str.length(); i++){

str.at(i) = tolower(str.at(i));

}

return str; //change to return string in all lowercase chars

}

string removePunctuation (string str, bool space) {

for(unsigned int i = 0; i < str.length(); i++){

if (ispunct(str.at(i))) {

str.erase(i);

cout << str;

}

}

return str;

//change to return string w/ punctuation/spaces removed

}

//****

int main(int argc, char* argv[]) {

bool caps = false;

bool space = true;

string executableName = argv[0];

if (argc < 2)

printUsageInfo(argv[0]);

int startIndex = 1;

int i = 1;

if ('-' == argv[1][0]) {

startIndex++;

while((argv[1][i]) != '\0') {

if ('c' == tolower(argv[1][i])){

caps = true;

}

else if ('s' == tolower(argv[1][i])) {

space = true;

}

else { //not a flag

printUsageInfo(argv[0]);

break;

}

i++;

}//while

//cout << space << endl;

//cout << caps << endl;

} //if

else {

}

//TO DO

for(int j = startIndex; j < argc; ++j) {

if (caps) {

cout << tolower(argv[j]);

}

else if (space) {

cout << removePunctuation(argv[j], space);

}

else if (caps && space){

cout << "seriously, fix me";

}

else {

cout << "else";

}

}

cout << endl;

//isPalindrome(cup, bool caps, bool space);

cout << "end of program" << endl;

return 0;

}