Trancation problem

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <windows.h>
#include <math.h>
using namespace std;
char charInput;


long double bracket();
long double exponent();

int main()
{

    char charInput;
    HANDLE hConsole;
hConsole = GetStdHandle (STD_OUTPUT_HANDLE);
SetConsoleTextAttribute
(hConsole, FOREGROUND_GREEN | FOREGROUND_INTENSITY);

    cout.setf(ios::fixed, ios::floatfield);
    cout.setf(ios::showpoint);

    cout << "Challenge 3: Create a calculator that can do calculations in standard \n";
    cout << "BEDMAS and use brackets" << endl << endl;
    cout << "Issued by Stephen \"WhiteDragon103\" Smolley" << endl << endl;
    cout << "Enter the equasion using the standard operators: (, ), +, -, *, /, ^, =" << endl;

    long double test = pow(2, 0.5);
    cout << test << endl;

    for (;;)
    {
    long double result = bracket();
    cout << result << endl;
    }

    return 0;
}

long double bracket()
{
    long double resultReturn = 0;
    long double multStorage = 1;
    long double digitReader = 0;
    long double divisionEntry = 0;
    long long int decimalPlacer = 1;
    long long int exponentEntry = 0;
    bool multiplicationSlot = false;
    bool negative = false;
    bool decimal = false;
    bool digitEntry = false;
    bool divisionSlot = false;
    //experimental
    bool exponentSlot = false;


    for (;;)
    {
        if (exponentSlot == false)
        {cin >> charInput;}
        switch (charInput)
            {

            case '1':
                if (divisionSlot == true)
                {
                divisionEntry *= 10;
                divisionEntry += 1;
                if (decimal == true)
                {decimalPlacer *= 10;}
                digitEntry = true;
                }
                else
                {digitReader *= 10;
                digitReader += 1;
                if (decimal == true)
                {decimalPlacer *= 10;}
                digitEntry = true;
                }
                break;
            case '2':
                if (divisionSlot == true)
                {
                divisionEntry *= 10;
                divisionEntry += 2;
                if (decimal == true)
                {decimalPlacer *= 10;}
                digitEntry = true;
                }
                else
                {digitReader *= 10;
                digitReader += 2;
                if (decimal == true)
                {decimalPlacer *= 10;}
                digitEntry = true;
                }
                break;
            case '3':
                if (divisionSlot == true)
                {
                divisionEntry *= 10;
                divisionEntry += 3;
                if (decimal == true)
                {decimalPlacer *= 10;}
                digitEntry = true;
                }
                else
                {digitReader *= 10;
                digitReader += 3;
                if (decimal == true)
                {decimalPlacer *= 10;}
                digitEntry = true;
                }
                break;
            case '4':
                if (divisionSlot == true)
                {
                divisionEntry *= 10;
                divisionEntry += 4;
                if (decimal == true)
                {decimalPlacer *= 10;}
                digitEntry = true;
                }
                else
                {digitReader *= 10;
                digitReader += 4;
                if (decimal == true)
                {decimalPlacer *= 10;}
                digitEntry = true;
                }
                break;
            case '5':
                if (divisionSlot == true)
                {
                divisionEntry *= 10;
                divisionEntry += 5;
                if (decimal == true)
                {decimalPlacer *= 10;}
                digitEntry = true;
                }
                else
                {digitReader *= 10;
                digitReader += 5;
                if (decimal == true)
                {decimalPlacer *= 10;}
                digitEntry = true;
                }
                break;
            case '6':
                if (divisionSlot == true)
                {
                divisionEntry *= 10;
                divisionEntry += 6;
                if (decimal == true)
                {decimalPlacer *= 10;}
                digitEntry = true;
                }
                else
                {digitReader *= 10;
                digitReader += 6;
                if (decimal == true)
                {decimalPlacer *= 10;}
                digitEntry = true;
                }
                break;
            case '7':
                if (divisionSlot == true)
                {
                divisionEntry *= 10;
                divisionEntry += 7;
                if (decimal == true)
                {decimalPlacer *= 10;}
                digitEntry = true;
                }
                else
                {digitReader *= 10;
                digitReader += 7;
                if (decimal == true)
                {decimalPlacer *= 10;}
                digitEntry = true;
                }
                break;
            case '8':
                if (divisionSlot == true)
                {
                divisionEntry *= 10;
                divisionEntry += 8;
                if (decimal == true)
                {decimalPlacer *= 10;}
                digitEntry = true;
                }
                else
                {digitReader *= 10;
                digitReader += 8;
                if (decimal == true)
                {decimalPlacer *= 10;}
                digitEntry = true;
                }
                break;
            case '9':
                if (divisionSlot == true)
                {
                divisionEntry *= 10;
                divisionEntry += 9;
                if (decimal == true)
                {decimalPlacer *= 10;}
                digitEntry = true;
                }
                else
                {digitReader *= 10;
                digitReader += 9;
                if (decimal == true)
                {decimalPlacer *= 10;}
                digitEntry = true;
                }
                break;
            case '0':
                if (divisionSlot == true)
                {
                divisionEntry *= 10;
                if (decimal == true)
                {decimalPlacer *= 10;}
                digitEntry = true;
                }
                else
                {digitReader *= 10;
                if (decimal == true)
                {decimalPlacer *= 10;}
                digitEntry = true;
                }
                break;

            //Complete for now
            case '+':
                if (exponentSlot == true)
                {exponentSlot = false;}
                if (divisionSlot == true)
                {
                if (decimal == true)
                    {
                    divisionEntry /= decimalPlacer;
                    decimalPlacer = 1;
                    decimal = false;
                    }
                    if (negative == true)
                    {
                    divisionEntry = -divisionEntry;
                    negative = false;
                    }

                    digitReader /= divisionEntry;
                    divisionSlot = false;
                    divisionEntry = 0;

                    if (multiplicationSlot == true)
                    {
                    multStorage *= digitReader;
                    resultReturn += multStorage;
                    digitReader = 0;
                    }
                }
                else
                {
                if (decimal == true)
                {
                    digitReader /= decimalPlacer;
                    decimalPlacer = 1;
                    decimal = false;
                }
                if (negative == true)
                {
                    digitReader = -digitReader;
                    negative = false;
                }
                if (multiplicationSlot == true)
                {
                    multStorage *= digitReader;
                    resultReturn += multStorage;
                    digitReader = 0;
                }
                }
                resultReturn += digitReader;
                digitReader = 0;
                multStorage = 1;
                multiplicationSlot = false;
                digitEntry = false;
                break;
            case '-':
                if (exponentSlot == true)
                {exponentSlot = false;}
                if (digitEntry == false && negative == false)
                {
                    negative = true;
                    resultReturn += digitReader;
                    digitReader = 0;
                }
                else if (digitEntry == false && negative == true)
                {
                    negative = false;
                    resultReturn += digitReader;
                    digitReader = 0;
                }
                else
                {
                if (divisionSlot == true)
                {
                if (decimal == true)
                    {
                    divisionEntry /= decimalPlacer;
                    decimalPlacer = 1;
                    decimal = false;
                    }
                    if (negative == true)
                    {
                    divisionEntry = -divisionEntry;
                    }

                    digitReader /= divisionEntry;
                    divisionSlot = false;
                    divisionEntry = 0;

                    if (multiplicationSlot == true)
                    {
                    multStorage *= digitReader;
                    resultReturn += multStorage;
                    }
                    digitReader = 0;
              }
                else
                {
                if (decimal == true)
                {
                    digitReader /= decimalPlacer;
                    decimalPlacer = 1;
                    decimal = false;
                }
                if (negative == true)
                {
                    digitReader = -digitReader;
                }
                if (multiplicationSlot == true)
                {
                    multStorage *= digitReader;
                    resultReturn += multStorage;
                    digitReader = 0;
                }
                negative = true;
                }
                resultReturn += digitReader;
                digitReader = 0;
                multStorage = 1;
                multiplicationSlot = false;
                digitEntry = false;
                }
                break;

            //Seems done for now
            case '*':
                if (exponentSlot == true)
                {exponentSlot = false;}
                if (divisionSlot == true)
                {
                if (decimal == true)
                    {
                    divisionEntry /= decimalPlacer;
                    decimalPlacer = 1;
                    decimal = false;
                    }
                    if (negative == true)
                    {
                    divisionEntry = -divisionEntry;
                    negative = false;
                    }

                    digitReader /= divisionEntry;
                    divisionSlot = false;
                    divisionEntry = 0;

                    if (multiplicationSlot == true)
                    {
                    multStorage *= digitReader;
                    resultReturn += multStorage;
                    digitReader = 0;
                    }
                }
                else
                {
                if (decimal == true)
                {
                    digitReader /= decimalPlacer;
                    decimalPlacer = 1;
                    decimal = false;
                }
                if (negative == true)
                {
                    digitReader = -digitReader;
                    negative = false;
                }
                if (multiplicationSlot == true)
                {
                    multStorage *= digitReader;
                    resultReturn += multStorage;
                    digitReader = 0;
                }
                }
                multStorage *= digitReader;
                digitReader = 0;
                multiplicationSlot = true;
                digitEntry = false;
                break;

            //HIGHLY TENTATIVE
            case '/':
                if (exponentSlot == true)
                {exponentSlot = false;}
                if (decimal == true)
                {
                    digitReader /= decimalPlacer;
                    decimalPlacer = 1;
                    decimal = false;
                }
                if (negative == true)
                {
                    digitReader = -digitReader;
                    negative = false;
                }
                if (divisionSlot == true)
                {
                    digitReader /= divisionEntry;
                    divisionEntry = 0;
                    divisionSlot = false;
                }
                divisionSlot = true;
                digitEntry = false;
                break;

            case '^':
                exponentEntry = exponent();
                digitReader = pow(digitReader, exponentEntry);
                exponentSlot = true;
                break;


            case '=':
                if (exponentSlot == true)
                {exponentSlot = false;}
                if (divisionSlot == true)
                {
                    digitReader /= divisionEntry;
                    divisionSlot = false;
                }
                if (decimal == true)
                {
                    digitReader /= decimalPlacer;
                    decimalPlacer = 1;
                    decimal = false;
                }
                if (negative == true)
                {
                    digitReader = -digitReader;
                    negative = false;
                }
                if (multiplicationSlot == true)
                {
                    multStorage *= digitReader;
                    resultReturn += multStorage;
                    multiplicationSlot = false;
                    multStorage = 1;
                    digitReader = 0;
                }
                resultReturn += digitReader;
                digitEntry = false;
                return resultReturn;
            case '.':
                decimal = true;
                break;
            case '(':
                   if (divisionSlot == true)
                    {
                       divisionEntry = bracket();
                    }
                   else
                    {
                        digitReader = bracket();
                        digitEntry = false;
                    }
                   break;
            case ')':
                if (divisionSlot == true)
                {
                    digitReader /= divisionEntry;
                    divisionSlot = false;
                }
                if (decimal == true)
                {
                    digitReader /= decimalPlacer;
                    decimalPlacer = 1;
                    decimal = false;
                }
                if (negative == true)
                {
                    digitReader = -digitReader;
                    negative = false;
                }
                if (multiplicationSlot == true)
                {
                    multStorage *= digitReader;
                    resultReturn += multStorage;
                    multiplicationSlot = false;
                    multStorage = 1;
                    digitReader = 0;
                }
                digitEntry = false;
                resultReturn += digitReader;
                return resultReturn;
            default:
                cout << "Please only use valid digits and operators!" << endl;
                    resultReturn = 0;
                    multStorage = 1;
                    digitReader = 0;
                    divisionEntry = 0;
                    multiplicationSlot = false;
                    negative = false;
                    decimal = false;
                    digitEntry = false;
                    decimalPlacer = 1;

            }
    }
}

long double exponent()
{
    long double exponentEntry = 0;
    long double exponentEntry2 = 0;
    long double decimalDivider = 1;
    bool digitEntry = false;
    bool decimal = false;
    bool negative = false;
 for (;;)
 {
    cin >> charInput;
    switch (charInput)
    {
         case '1':
                exponentEntry *= 10;
                exponentEntry += 1;
                if (decimal == true)
                {decimalDivider *= 10;}
                digitEntry = true;
                break;
            case '2':
                exponentEntry *= 10;
                exponentEntry += 2;
                if (decimal == true)
                {decimalDivider *= 10;}
                digitEntry = true;
                break;
            case '3':
                exponentEntry *= 10;
                exponentEntry += 3;
                if (decimal == true)
                {decimalDivider *= 10;}
                digitEntry = true;
                break;
            case '4':
                exponentEntry *= 10;
                exponentEntry += 4;
                if (decimal == true)
                {decimalDivider *= 10;}
                digitEntry = true;
                break;
            case '5':
                exponentEntry *= 10;
                exponentEntry += 5;
                if (decimal == true)
                {decimalDivider *= 10;}
                digitEntry = true;
                break;
            case '6':
                exponentEntry *= 10;
                exponentEntry += 6;
                if (decimal == true)
                {decimalDivider *= 10;}
                digitEntry = true;
                break;
            case '7':
                exponentEntry *= 10;
                exponentEntry += 7;
                if (decimal == true)
                {decimalDivider *= 10;}
                digitEntry = true;
                break;
            case '8':
                exponentEntry *= 10;
                exponentEntry += 8;
                if (decimal == true)
                {decimalDivider *= 10;}
                digitEntry = true;
                break;
            case '9':
                exponentEntry *= 10;
                exponentEntry += 9;
                if (decimal == true)
                digitEntry = true;
                break;
            case '0':
                exponentEntry *= 10;
                if (decimal == true)
                {decimalDivider *= 10;}
                digitEntry = true;
                break;

            case '^':
                exponentEntry2 = exponent();
                if (decimal == true)
                {
                exponentEntry /= decimalDivider;
                decimalDivider = 1;
                }
                if (negative == true)
                {exponentEntry = -exponentEntry;}
                exponentEntry = pow(exponentEntry, exponentEntry2);
                return exponentEntry;
            case '+':
                if (decimal == true)
                {
                exponentEntry /= decimalDivider;
                decimalDivider = 1;
                }
                if (negative == true)
                {exponentEntry = -exponentEntry;}
                return exponentEntry;
            case '-':
                if (digitEntry == false)
                {
                    negative = true;
                    break;
                }
                else
                {
                if (decimal == true)
                {
                exponentEntry /= decimalDivider;
                decimalDivider = 1;}
                if (negative == true)
                {exponentEntry = -exponentEntry;}
                return exponentEntry;
                }
            case '*':
                if (decimal == true)
                {
                exponentEntry /= decimalDivider;
                decimalDivider = 1;
                }
                if (negative == true)
                {exponentEntry = -exponentEntry;}
                return exponentEntry;
            case '/':
                if (decimal == true)
                {
                exponentEntry /= decimalDivider;
                decimalDivider = 1;
                }
                if (negative == true)
                {exponentEntry = -exponentEntry;}
                return exponentEntry;
            case '=':
                if (decimal == true)
                {
                exponentEntry /= decimalDivider;
                decimalDivider = 1;
                }
                if (negative == true)
                {exponentEntry = -exponentEntry;}
                return exponentEntry;
            case '.':
                decimal = true;
                break;
            default:
                cout << "Please only use valid digits and operators!" << endl;
        }
    }
}