Welcome to the Lounge

Sander Rossel wrote:

but my uncle certainly isn't having any of it (although he could be dead three times over, is another way of looking at it).

M.D.V.

If something has a solution... Why do we have to worry about?. If it has no solution... For what reason do we have to worry about?
Help me to understand what I'm saying, and I'll explain it better to you
Rating helpful answers is nice, but saying thanks can be even nicer.

CPallini wrote:

Note to self: never be Sander's uncle.

result_t parse_float(ml_reader_base& rdr, const char** current, float* result) {
    char* end = NULL;
    double res = 0.0, sign = 1.0;
    long long intPart = 0, fracPart = 0;
    int fracCount = 0;
    long expPart = 0;
    char expNeg = 0;
    char hasIntPart = 0, hasFracPart = 0, hasExpPart = 0;
    int state = 0;
    // Parse optional sign
    if (**current == '+') {
        (*current)++;
    } else if (**current == '-') {
        sign = -1;
        (*current)++;
    }
    
    while (state<7) {
        if (**current) {
            switch (state) {
                case 0: // int part
                    if (!isdigit(**current)) {
                        state = 1;
                        break;
                    }
                    hasIntPart=1;
                    intPart = (intPart*10)+(**current-'0');
                    ++(*current);
                    break;
                case 1:
                    *result = (float)intPart;
                    if(**current!='.') {
                        state = 3;
                        break;
                    }
                    ++(*current);
                    state = 2;
                    break;
                case 2: // frac part
                    if (!isdigit(**current)) {
                        state = 3;
                        break;
                    }
                    ++fracCount;
                    hasFracPart=1;
                    fracPart = (fracPart*10)+(**current-'0');
                    ++(*current);
                    break;
                case 3:
                    if(hasFracPart) {
                        *result += (double)fracPart/pow(10.0,(double)fracCount);
                    }
                    if(**current=='E' || **current=='e') {
                        ++(*current);
                        state = 4;
                    } else {
                        state = 6;
                    }
                    break;
                case 4:
                    if(**current=='+') {
                        ++(*current);
                    }
                    if(**current=='-') {
                        expNeg = 1;
                        ++(*current);
                    }
                    state = 5;
                    break;
                case 5: 
                    if (!isdigit(**current)) {
                        state = 6;
                        break;
                    }
                    hasExpPart=1;
                    expPart = (expPart*10)+(**current-'0');
                    ++(*current);
                    break;
                case 6:
                    if(hasExpPart) {
                        if(expNeg) {
                            expPart = -expPart;
                        }
                        *result *= pow(10.0,(double)expPart);
                    }
                    *result*=sign;
                    state = 7;
                    break;
            }

        } else {
            if (!rdr.read()) {
                return IO_ERROR;
            }
            if (!rdr.has_value()) {
                *current = nullptr;
                break;
            }
            *current = rdr.value();
        }
    }
    if (rdr.node_type() == ml_node_type::attribute_end) {
        if (!rdr.read()) {
            return IO_ERROR;
        }
    }
    if(!hasIntPart&&!hasFracPart) {
        return FMT_ERROR;
    }
    return SUCCESS;
}