kit

pratt_calc_test.c (6462B)

---

 #include "generated_pratt_calc.h"
 
 #include <ctype.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 typedef struct Node {
     int tk;
     long val;
 } Node;
 
 typedef struct {
     Node **mem;
     size_t nmem, capmem;
     int enters, exits, tokens;
 } Emb;
 
 static Node *node_new(Emb *e) {
     Node *n = calloc(1, sizeof *n);
     if (e->nmem == e->capmem) {
         e->capmem = e->capmem ? e->capmem * 2 : 16;
         e->mem = realloc(e->mem, e->capmem * sizeof *e->mem);
     }
     e->mem[e->nmem++] = n;
     return n;
 }
 
 static void emb_free(Emb *e) {
     for (size_t i = 0; i < e->nmem; i++) free(e->mem[i]);
     free(e->mem);
 }
 
 static Node *mk_long(Emb *e, long v) {
     Node *n = node_new(e);
     n->val = v;
     return n;
 }
 
 static long ipow(long base, long exp) {
     long out = 1;
     while (exp-- > 0) out *= base;
     return out;
 }
 
 static long fact(long x) {
     long out = 1;
     for (long i = 2; i <= x; i++) out *= i;
     return out;
 }
 
 static KitGramSem cb_lift(void *ud, KitGramToken t) {
     Emb *e = ud;
     Node *n = node_new(e);
     n->tk = t.kind;
     if (t.kind == PRATT_CALC_TOK_NUMBER) {
         char b[32];
         size_t len = t.len < sizeof b - 1 ? t.len : sizeof b - 1;
         memcpy(b, t.lexeme, len);
         b[len] = '\0';
         n->val = atol(b);
     }
     return n;
 }
 
 static KitGramSem cb_reduce(void *ud, KitGramRuleId r, int prod, KitGramSem *k, size_t n) {
     Emb *e = ud;
     (void)n;
     switch (r) {
     case PRATT_CALC_R_primary:
         return prod == 0 ? k[0] : k[1];
     case PRATT_CALC_R_expr:
         switch (prod) {
         case PRATT_CALC_EXPR_PRIMARY:
             return k[0];
         case PRATT_CALC_EXPR_PREFIX_MINUS:
             return mk_long(e, -((Node *)k[1])->val);
         case PRATT_CALC_EXPR_PREFIX_PLUS:
             return mk_long(e, ((Node *)k[1])->val);
         case PRATT_CALC_EXPR_POSTFIX_BANG:
             return mk_long(e, fact(((Node *)k[0])->val));
         case PRATT_CALC_EXPR_INFIX_PLUS:
             return mk_long(e, ((Node *)k[0])->val + ((Node *)k[2])->val);
         case PRATT_CALC_EXPR_INFIX_MINUS:
             return mk_long(e, ((Node *)k[0])->val - ((Node *)k[2])->val);
         case PRATT_CALC_EXPR_INFIX_STAR:
             return mk_long(e, ((Node *)k[0])->val * ((Node *)k[2])->val);
         case PRATT_CALC_EXPR_INFIX_SLASH:
             return mk_long(e, ((Node *)k[0])->val / ((Node *)k[2])->val);
         case PRATT_CALC_EXPR_INFIX_CARET:
             return mk_long(e, ipow(((Node *)k[0])->val, ((Node *)k[2])->val));
         }
         break;
     }
     return NULL;
 }
 
 static void cb_enter(void *ud, KitGramRuleId r, int prod) {
     (void)r;
     (void)prod;
     ((Emb *)ud)->enters++;
 }
 
 static void cb_exit(void *ud, KitGramRuleId r, int prod) {
     (void)r;
     (void)prod;
     ((Emb *)ud)->exits++;
 }
 
 static void cb_token(void *ud, KitGramToken t) {
     (void)t;
     ((Emb *)ud)->tokens++;
 }
 
 typedef struct { const char *s; size_t i; } Lexer;
 
 static int lex_next(Lexer *lx, KitGramToken *out) {
     while (lx->s[lx->i] && isspace((unsigned char)lx->s[lx->i])) lx->i++;
     char c = lx->s[lx->i];
     if (!c) return 0;
 
     out->lexeme = &lx->s[lx->i];
     out->len = 1;
     out->line = 1;
     out->col = (uint32_t)(lx->i + 1);
 
     if (isdigit((unsigned char)c)) {
         size_t j = lx->i;
         while (isdigit((unsigned char)lx->s[j])) j++;
         out->kind = PRATT_CALC_TOK_NUMBER;
         out->len = j - lx->i;
         lx->i = j;
         return 1;
     }
 
     lx->i++;
     switch (c) {
     case '+': out->kind = PRATT_CALC_TOK_PLUS;   break;
     case '-': out->kind = PRATT_CALC_TOK_MINUS;  break;
     case '*': out->kind = PRATT_CALC_TOK_STAR;   break;
     case '/': out->kind = PRATT_CALC_TOK_SLASH;  break;
     case '^': out->kind = PRATT_CALC_TOK_CARET;  break;
     case '!': out->kind = PRATT_CALC_TOK_BANG;   break;
     case '(': out->kind = PRATT_CALC_TOK_LPAREN; break;
     case ')': out->kind = PRATT_CALC_TOK_RPAREN; break;
     default:  out->kind = PRATT_CALC_TOK__COUNT; break;
     }
     return 1;
 }
 
 static int eval(const char *src, long *result, int *enters, int *exits, int *tokens) {
     Emb e;
     memset(&e, 0, sizeof e);
     KitGramActions acts = {
         .reduce = cb_reduce,
         .lift_token = cb_lift,
         .enter = cb_enter,
         .exit = cb_exit,
         .on_token = cb_token,
     };
     KitGramParser ps;
     KitGramSlot ctl[256];
     KitGramSem vals[256];
     KitGramConfig cfg = { .actions = &acts, .ud = &e, .recover = false,
                       .ctl_stack = ctl, .ctl_cap = 256,
                       .val_stack = vals, .val_cap = 256 };
     pratt_calc_parser_init(&ps, &cfg);
 
     Lexer lx = { src, 0 };
     KitGramToken t;
     int ok = 1;
     while (ok && lex_next(&lx, &t))
         if (kit_gram_parser_push(&ps, t) == KIT_GRAM_PARSE_ERROR) ok = 0;
     if (ok && kit_gram_parser_finish(&ps) != KIT_GRAM_PARSE_ACCEPT) ok = 0;
     if (ok && result) {
         Node *r = kit_gram_parser_result(&ps);
         *result = r ? r->val : 0;
     }
     if (enters) *enters = e.enters;
     if (exits) *exits = e.exits;
     if (tokens) *tokens = e.tokens;
     emb_free(&e);
     return ok;
 }
 
 static int failures = 0;
 
 static void check_val(const char *src, long want) {
     long got = 0;
     int en = 0, ex = 0, tk = 0;
     if (!eval(src, &got, &en, &ex, &tk)) {
         printf("FAIL  %-18s parse error (wanted %ld)\n", src, want);
         failures++;
         return;
     }
     if (got != want) {
         printf("FAIL  %-18s = %ld (wanted %ld)\n", src, got, want);
         failures++;
         return;
     }
     if (en != ex || en == 0 || tk == 0) {
         printf("FAIL  %-18s listener mismatch enter=%d exit=%d tok=%d\n", src, en, ex, tk);
         failures++;
         return;
     }
     printf("ok    %-18s = %-5ld [enter=%d exit=%d tok=%d]\n", src, got, en, ex, tk);
 }
 
 static void check_err(const char *src) {
     long got = 0;
     if (eval(src, &got, NULL, NULL, NULL)) {
         printf("FAIL  %-18s parsed = %ld (wanted rejection)\n", src, got);
         failures++;
         return;
     }
     printf("ok    %-18s -> rejected\n", src);
 }
 
 int main(void) {
     printf("== generated Pratt arithmetic parser ==\n");
     check_val("1 + 2 * 3", 7);
     check_val("(1 + 2) * 3", 9);
     check_val("10 - 2 - 3", 5);
     check_val("2 ^ 3 ^ 2", 512);
     check_val("-3!", -6);
     check_val("2 * -3 + +4", -2);
     check_val("3!!", 720);
 
     check_err("1 +");
     check_err("1 2");
     check_err("!");
 
     return failures ? 1 : 0;
 }