/**************************************
 * eggache? egg hurt?
 * support: + - * / % ^ ( )
 *-------------------------------------
 * original
 * E -> E+T|E-T|T
 * T -> T*F|T/F|T%F|F
 * F -> N^F|N
 * N -> (E)|-VAL|+VAL|VAL
 *-------------------------------------
 * remove left recursive
 * E -> TE'
 * E'-> +TE'|-TE'|e
 * T -> FT'
 * T'-> *FT'|/FT'|%FT'|e
 * F -> NF'
 * F'-> ^F|e
 * N -> (E)|-VAL|+VAL|VAL
 * ------------------------------------
 * char set [0-9]|.|e|+|-|*|/|%|^|(|)
 * VAL := [0-9]+(\.[0-9]+)?(e(+|-)?[0-9]+)?
 * ************************************/

#include <stdio.h>
#include <math.h>

#define ARRAY_SIZE(a) (int)(sizeof(a)/sizeof(*a))
typedef enum {
    LLS_NUM,
    LLS_ADD,
    LLS_SUB,
    LLS_MUL,
    LLS_DIV,
    LLS_MOD,
    LLS_POW,
    LLS_LBR,
    LLS_RBR,
    LLS_END,
    LLS_ERR,
} LLSTATE;

typedef enum {
    LLE_OK,
    LLE_INVALID_CHAR,
    LLE_BK_NOT_MATCH,
    LLE_NOT_A_NUM,
    LLE_NOT_OPERATOR,
} LLERROR;

#define LL_VAL_DEFVAL 0
typedef double LL_VAL;

typedef struct LL_state {
    const char* expr;
    LL_VAL val;
    int read;
    LLSTATE state;
    int errcode;
} LL_state;

LL_VAL LL_E( LL_state* self );
LL_VAL LL_T( LL_state* self );
LL_VAL LL_F( LL_state* self );

LL_VAL LL_NUM( LL_state* self ) {
    LL_VAL ret;
    int len;
    sscanf( &self->expr[self->read],
            "%lf%n", &ret, &len ); // %lf !! I'm lazy
    self->read += len;
    return ret;
}

LLSTATE LL_PARSE( LL_state* self ) {
    char c = self->expr[self->read];
    while ( c == ' ' ) //ignore space
        c = self->expr[++self->read];
    if ( c >= '0' && c <= '9' ) {
        self->val = LL_NUM( self );
        self->state = LLS_NUM;
    } else {
        ++self->read;
        if ( c == '+' ) {
            self->state = LLS_ADD;
        } else if ( c == '-' ) {
            self->state = LLS_SUB;
        } else if ( c == '*' ) {
            self->state = LLS_MUL;
        } else if ( c == '/' ) {
            self->state = LLS_DIV;
        } else if ( c == '%' ) {
            self->state = LLS_MOD;
        } else if ( c == '^' ) {
            self->state = LLS_POW;
        } else if ( c == '(' ) {
            self->state = LLS_LBR;
        } else if ( c == ')' ) {
            self->state = LLS_RBR;
        } else if ( c == '\0' ) {
            self->state = LLS_END;
        } else {
            self->errcode = LLE_INVALID_CHAR;
            self->state = LLS_ERR;
        }
    }
    return self->state;
}

LL_VAL LL_N( LL_state* self ) { // F -> (E)|-VAL|+VAL|VAL
    LL_VAL ret = LL_VAL_DEFVAL;
    int lbr_pos = self->read;
    if ( self->state == LLS_ERR ) return ret;
    switch ( self->state ) {
    case LLS_LBR:
        LL_PARSE( self );
        ret = LL_E( self );
        if ( self->state != LLS_RBR ) {
            if ( self->errcode == LLE_OK ) {
                self->errcode = LLE_BK_NOT_MATCH;
                self->read = lbr_pos;
            }
            self->state = LLS_ERR;
            return ret;
        }
        break;
    case LLS_ADD:
    case LLS_SUB:
        if ( 1 ) {
            LLSTATE s = self->state;
            LL_PARSE( self );
            if ( self->state != LLS_NUM ) {
                self->errcode = LLE_NOT_A_NUM;
                self->state = LLS_ERR;
                return ret;
            }
            ret = ( s == LLS_ADD ? self->val : -self->val ) ;
        }
        break;
    case LLS_NUM:
        ret = self->val;
        break;
    default:
        self->errcode = LLE_NOT_A_NUM;
        self->state = LLS_ERR;
        return ret;
    }
    LL_PARSE( self );
    return ret;
}

LL_VAL LL_F_( LL_state* self ) { // F'-> ^F|e
    LL_VAL val = self->val;
    if ( self->state == LLS_ERR ) return val;
    switch ( self->state ) {
    case LLS_POW:
        LL_PARSE( self );
        return pow( val, LL_F( self ) );
    case LLS_ADD:
    case LLS_SUB:
    case LLS_MUL:
    case LLS_DIV:
    case LLS_MOD:
    case LLS_RBR:
    case LLS_END:
    case LLS_ERR:
        return val;
    default:
        self->errcode = LLE_NOT_OPERATOR;
        self->state = LLS_ERR;
        return val;
    }
}

LL_VAL LL_F( LL_state* self ) { // F -> NF'
    self->val = LL_N( self );
    return LL_F_( self );
}

LL_VAL LL_T_( LL_state* self ) { // T'-> *FT'|/FT'|%FT'|e
    LL_VAL val = self->val;
    if ( self->state == LLS_ERR ) return val;
    switch ( self->state ) {
    case LLS_MUL:
        LL_PARSE( self );
        self->val = val * LL_F( self );
        return LL_T_( self );
    case LLS_DIV:
        LL_PARSE( self );
        self->val = val / LL_F( self );
        return LL_T_( self );
    case LLS_MOD:
        LL_PARSE( self );
        self->val = fmod( val, LL_F( self ) );
        return LL_T_( self );
    case LLS_ADD:
    case LLS_SUB:
    case LLS_RBR:
    case LLS_END:
    case LLS_ERR:
        return val;
    default:
        self->errcode = LLE_NOT_OPERATOR;
        self->state = LLS_ERR;
        return val;
    }
}

LL_VAL LL_T( LL_state* self ) { // T -> FT'
    self->val = LL_F( self );
    return LL_T_( self );
}

LL_VAL LL_E_( LL_state* self ) { // E'-> +TE'|-TE'|e
    LL_VAL val = self->val;
    if ( self->state == LLS_ERR ) return val;
    switch ( self->state ) {
    case LLS_ADD:
        LL_PARSE( self );
        self->val = val + LL_T( self );
        return LL_E_( self );
    case LLS_SUB:
        LL_PARSE( self );
        self->val = val - LL_T( self );
        return LL_E_( self );
    case LLS_RBR:
    case LLS_END:
    case LLS_ERR:
        return val;
    default:
        self->errcode = LLE_NOT_OPERATOR;
        self->state = LLS_ERR;
        return val;
    }
}

LL_VAL LL_E( LL_state* self ) { // E -> TE'
    self->val = LL_T( self );
    return LL_E_( self );
}

int LL_calc( const char* expr, LL_VAL* val, int* pos ) {
    LL_state self = {expr, *val};
    LL_PARSE( &self );
    *val = LL_E( &self );
    *pos = self.read;
    if ( self.errcode == LLE_OK && self.state != LLS_END ) {
        self.errcode = LLE_BK_NOT_MATCH;
    }
    return self.errcode;
}

const char* LL_get_err_string( int errcode ) {
    static const char* errstr[] = {
        "",
        "invalid character",
        "bracket does not match",
        "not a number",
        "need operator",
    };
    if ( errcode < 0 || errcode > ARRAY_SIZE( errstr ) ) {
        errcode = 0;
    }
    return errstr[errcode];
}

int main() {
    char str[1024];
    LL_VAL v;
    int cnt_out = 0;
    while ( gets( str ) ) {
        int r, pos;
        r = LL_calc( str, &v, &pos );
        printf( "out[%d]: " , ++cnt_out );
        if ( r == LLE_OK ) {
            printf( "%s= %.10g\n", str, v );
        } else {
            printf( "error code %d: %s\n", r, LL_get_err_string( r ) );
            printf( "%s\n", str );
            printf( "%*s\n", pos, "^" );
        }
    }
    return 0;
}