SplitDecimal.c

#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <math.h>
#include "SplitDecimal.h"

char validateDecimalCharacters(char *string);

/*****************************************************************
//
//  Function name: validDecimal
//
//  DESCRIPTION:   Determines if the given string contains a valid
//                 floating point decimal number.
//
//  Parameters:    string (char *): The floating point decimal number as a string.
//
//  Return values: TRUE = 1: If the given string is a valid decimal number.
//
//                 FALSE = 0: If the given string is not a valid decimal number.
//
//****************************************************************/

char validDecimal(char *string)
{
    char valid = TRUE;

    if (string == NULL )
    {
        valid = FALSE;
    }
    else
    {
        valid &= validateDecimalCharacters(string);
    }
    return valid;
}

/*****************************************************************
//
//  Function name: validateDecimalCharacters
//
//  DESCRIPTION:   Determines if the given string contains only
//                 valid characters for a floating point decimal
//                 number.
//
//                 The NULL checks must be handled BEFORE calling
//                 this function.
//
//  Parameters:    string (char *): The string to be checked.
//
//  Return values: TRUE = 1: The string only contains valid characters.
//
//                 FALSE = 0: If the string contains invalid characters.
//
//****************************************************************/

char validateDecimalCharacters(char *string)
{
    int i;
    char decimalFound = FALSE;
    char valid = TRUE;
    int stringLength = strlen(string);

    if (stringLength == 0 || (stringLength == 1 && string[0] == '.'))
    {
        valid = FALSE;
    }
    else
    {
        for (i = 0; string[i] != '\0'; i++)
        {
            if ((i == 0 && string[i] == '-') || isdigit(string[i]) || string[i] == '.')
            {
                if (string[i] == '.')
                {
                    if (decimalFound)
                    {
                        valid = FALSE;
                        break;
                    }
                    else
                    {
                        decimalFound = TRUE;
                    }
                }

            }
            else
            {
                valid = FALSE;
                break;
            }
        }
    }
    return valid;
}

/*****************************************************************
//
//  Function name: splitDecimal
//
//  DESCRIPTION:   Splits the floating point decimal number string
//                 into its whole number and decimal portions and
//                 returns them in a DecimalNumber struct.
//
//                 IMPORTANT: The string must be a valid decimal
//                            number as determined by the
//                            validDecimal function.
//
//  Parameters:    string (char *): The string to be split.
//
//  Return values: A DecimalNumber struct containing the values of
//                 the split string.  If something went wrong,
//                 the sign will be invalid (i.e. not 1 or -1).
//
//****************************************************************/

DecimalNumber splitDecimal(char *string)
{
    int wholeNumber;
    char * stringCopy, *decimal;
    DecimalNumber split;
    if (string)
    {
        stringCopy = (char *) malloc(sizeof(char) * (strlen(string) + 1));

        if (stringCopy != NULL )
        {
            strcpy(stringCopy, string);

            decimal = strchr(stringCopy, '.');

            if (decimal)
            {
                *decimal = '\0';
                decimal++;
                split.fractional = atoi(decimal);
            }

            // No decimal point, so the decimal part is 0
            else
            {
                split.fractional = 0;
            }

            wholeNumber = atoi(stringCopy);
            if (stringCopy[0] == '-')
            {
                split.integral = wholeNumber * -1;
                split.sign = -1;
            }
            else
            {
                split.integral = wholeNumber;
                split.sign = 1;
            }

            free(stringCopy);
        }
    }
    else
    {
        split.sign = INVALID_DECIMAL_SIGN;
    }

    return split;
}

/*****************************************************************
//
//  Function name: signToString
//
//  DESCRIPTION:   Converts the given value for a sign to a string.
//
//  Parameters:    sign (char): The sign value to be converted.
//
//  Return values: A string representing the sign.
//
//****************************************************************/
char *signToString(char sign)
{
    char *signString;
    if (sign == 1)
    {
        signString = "+";
    }
    else if (sign == -1)
    {
        signString = "-";
    }
    else
    {
        signString = "BAD SIGN";
    }
    return signString;
}