bc_interpreter.h

Go to the documentation of this file.

 
#ifndef BC_INTERPRETER_H
#define BC_INTERPRETER_H
 
#include "../../include/cst_macros.h"
#include "../../include/rdesc.h"
#include "../../include/util.h"
#include "../../src/common.h"
 
#include "../grammar/bc.h"
 
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
 
 
static inline double bc_pow10(int i)
{
        double r = 1;
 
        while (i--)
                r *= 10;
 
        return r;
}
 
static inline double bc_interpreter(struct rdesc *p, struct rdesc_node *n)
{
        size_t alt_idx = ralt_idx(n);
 
        /* for use in str->num serialization in NT_UNSIGNED_NUM */
        char *decimal_part, *floating_part;
        double converted;
 
        switch (rid(n)) {
        case NT_UNSIGNED_NUM:
                switch (alt_idx) {
                case 0:
                        memcpy(&decimal_part, rseminfo(rchild(p, n, 0)),
                               sizeof(char *));
 
                        converted = strtod(decimal_part, NULL);
 
                        free(decimal_part);
                        return converted;
                case 1:
                        memcpy(&floating_part, rseminfo(rchild(p, n, 1)),
                               sizeof(char *));
 
                        converted = strtod(floating_part, NULL) /
                                           bc_pow10(strlen(floating_part));
 
                        free(floating_part);
                        return converted;
                default:
                        memcpy(&decimal_part, rseminfo(rchild(p, n, 0)),
                               sizeof(char *));
                        memcpy(&floating_part, rseminfo(rchild(p, n, 2)),
                               sizeof(char *));
 
                        converted = strtod(decimal_part, NULL) +
                                           strtod(floating_part, NULL) /
                                           bc_pow10(strlen(floating_part));
 
                        free(decimal_part);
                        free(floating_part);
                        return converted;
                }
 
        case NT_OPTSIGN:
                return (alt_idx == 0) ? -1 : 1;
 
        case NT_FACTOR:
                return bc_interpreter(p, rchild(p, n, 0)) *
                        bc_interpreter(p, rchild(p, n, 1));
 
        case NT_EXPR:
                switch (alt_idx) {
                case 0:
                        rdesc_flip_left(p, n, 2)  /* flip term */;
 
                        return bc_interpreter(p, rchild(p, n, 0)) +
                                (ralt_idx(rchild(p, n, 1)) == 0 ? 1 : -1) *
                                bc_interpreter(p, rchild(p, n, 2));
                default:
                        rdesc_flip_left(p, n, 0)  /* flip term */;
 
                        return bc_interpreter(p, rchild(p, n, 0));
                }
 
        case NT_TERM:
                switch (alt_idx) {
                case 0:
                        return bc_interpreter(p, rchild(p, n, 0)) *
                                (ralt_idx(rchild(p, n, 1)) == 0 ?
                                         bc_interpreter(p, rchild(p, n, 2)) :
                                         1 / bc_interpreter(p, rchild(p, n, 2)));
                default:
                        return bc_interpreter(p, rchild(p, n, 0));
                }
 
        case NT_ATOM:
                switch (alt_idx) {
                case 0:
                        return bc_interpreter(p, rchild(p, n, 0));
                default:
                        rdesc_flip_left(p, n, 1)  /* flip expr */;
 
                        return bc_interpreter(p, rchild(p, n, 1));
                }
 
        case NT_STMT:
                rdesc_flip_left(p, n, 0)  /* flip expr */;
 
                return bc_interpreter(p, rchild(p, n, 0));
        }
 
        unreachable(); return 0;  // GCOV_EXCL_LINE
}
 
static inline void bc_tk_destroyer(uint16_t tk, void *seminfo_)
{
        if (tk == TK_NUM) {
                void *seminfo;
                memcpy(&seminfo, seminfo_, sizeof(void *));
 
                if (seminfo)
                        free(seminfo);
        }
}
 
 
#endif