pvjc20/du4/program.c

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<stdbool.h>
#include<ctype.h>

#define SCAN_FIRST_NUMBER 0
#define SCAN_FIRST_OPERATOR 1
#define SCAN_SECOND_NUMBER 2
#define SCAN_SECOND_OPERATOR 3
#define SCAN_RESULT 4
// #define SCAN_END 5

char* scanValue(char *s, float *output);
char* scanOperator(char *s, char *output);

// bool isDigit(char c);
bool isOperator(char c);
// bool isFloatingPoint(char c);
// bool isWhitespace(char c);
bool isNewline(char c);
bool evaluate(float a, float b, float c, char op);

void error();

int main(){
    char buffer[2048];
    // char str[512];
    
    float a;
    float b;
    float c;
    char operator;
    
    char *retVal = fgets (buffer, sizeof(buffer), stdin);
    
    if (retVal == 0 || isNewline(buffer[0]) == true) {
        puts("KONIEC");

        return 0;
    }

    int l = strlen(buffer);

    if (isNewline(buffer[l - 1]) == false) {
        error();

        return 0;
    }

    int scanStatus = SCAN_FIRST_NUMBER;
    char *currentChar = buffer;
    char *endChar = buffer + l - 1;

    // for (char *i = 0; i < l; i++) {
    //     // int forward = 0;
        
    //     char currentChar = buffer[i];

    //     if (i == l - 1 && isNewline(currentChar) == false) {

    //     }
    // }

    while (currentChar < endChar) {
        if (scanStatus == SCAN_FIRST_NUMBER) {
            retVal = scanValue(currentChar, &a);
        } else if (scanStatus == SCAN_FIRST_OPERATOR) {
            retVal = scanOperator(currentChar, &operator);
        } else if (scanStatus == SCAN_SECOND_NUMBER) {
            retVal = scanValue(currentChar, &b);
        } else if (scanStatus == SCAN_SECOND_OPERATOR) {
            char eqOp;
            
            retVal = scanOperator(currentChar, &eqOp);

            if (eqOp != '=') {
                retVal = 0;
            }
        } else if (scanStatus == SCAN_RESULT) {
            retVal = scanValue(currentChar, &c);
        } else {
            error();

            break;
        }

        if (retVal == 0) {
            error();

            break;
        } else if (scanStatus == SCAN_RESULT) {
            bool validResult = evaluate(a, b, c, operator);

            if (validResult == true) {
                puts("OK");
            } else {
                puts("ZLE");
            }

            break;
        }

        currentChar = retVal;
        scanStatus++;
    }

    return 0;
}

char* scanValue(char *s, float *output) {
    char *retVal = 0;

    *output = strtof(s, &retVal);

    if (retVal == 0 || retVal == s || ((*output) == 0 && *(retVal - 1) != '0')) {
        return 0;
    }

    return retVal;
    
    // int outPosition = 0;
    // int l = strlen(s);
    // bool hasPoint = false;

    // for (int i = 0; i < l - 1; i++) {
    //     char c = s[i];
    //     char cNext = s[i+1];
    //     bool isError = (outPosition == 0 && isDigit(c) == false)
    //         || (outPosition > 0 && (
    //             (hasPoint == true && isFloatingPoint(c))
    //             || (hasPoint == false && isFloatingPoint(c) == true && isDigit(cNext) == false)
    //             || (isDigit(c) == true && (
    //                 (hasPoint == true && isOperator(cNext) == false && isWhitespace(cNext) == false && isNewline(cNext) == false)
    //                 || (hasPoint == false && isOperator(cNext) == false && isWhitespace(cNext) == false && isNewline(cNext) == false && isFloatingPoint(cNext) == false))
    //             )
    //             || (hasPoint == true && isDigit(c) == false)
    //             || (hasPoint == false && isFloatingPoint(c) == false && isDigit(c) == false)
    //         ));

    //     if (isError == true) {
    //         return 0;
    //     }

    //     if (isFloatingPoint(c)) {
    //         hasPoint = true;
    //         outPosition++;
            
    //         continue;
    //     }

    //     bool endsHere = isOperator(cNext) == true || isWhitespace(cNext) == true || isNewline(cNext) == true;

    //     if (endsHere == true) {
    //         break;
    //     }

    //     outPosition++;
    // }

    // if (outPosition > 0) {
    //     *output = strtof(s, s + outPosition - 1);
    // }

    // return outPosition;
}

char* scanOperator(char *s, char *output) {
    char *start = s;

    while (isspace(*start) != 0) {
        start++;
    }

    char c = *start;

    if (isOperator(c) == false) {
        return 0;
    }

    (*output) = c;

    return start + 1;
}

// bool isDigit(char c) {
//     return c >= '0' && c <= '9';
// }

bool isOperator(char c) {
    return c == '+' || c == '-' || c == '*' || c == '/' || c == '=';
}

// bool isFloatingPoint(char c) {
//     return c == '.' || c == ',';
// }

// bool isWhitespace(char c) {
//     return c == ' ' || c == '\t';
// }

bool isNewline(char c) {
    return c == '\n';
}

bool evaluate(float a, float b, float c, char op) {
    float resultL = c - 0.001F;
    float resultR = c + 0.001F;
    float result;

    switch (op)
    {
        case '+':
            result = a + b;
            break;

        case '-':
            result = a - b;
            break;

        case '*':
            result = a * b;
            break;

        case '/':
            result = a / b;
            break;
        
        default:
            error();
            return false;
    }

    return result == c || (result >= resultL && result <= resultR);
}

void error() {
    puts("CHYBA");
}