writing about pratt parsing so I remember it

#include <stdio.h>
#include <ctype.h>

typedef struct {
    char ops[32]; // limit of 32 operators
    int idx; // index of last operator
} Stk;

void push(Stk *s, char op) {
    s->idx += 1;
    s->ops[s->idx] = op;
}
void pop(Stk *s)   { s->idx -= 1; }
char peek(Stk *s)  { return s->ops[s->idx]; }
char empty(Stk *s) { return s->idx == -1; }

int get_bindpower(char op) {
    static const int bps[] = { ['+'] = 1, ['-'] = 1, ['*'] = 2, ['/'] = 2 };
    return bps[op];
}

int main(int argc, char **argv) {
    char *str = argv[1];
    Stk _opstk = (Stk){ .idx = -1 };
    Stk *opstk = &_opstk;

    while (*str != '\0') {
        if (isdigit(*str)) {
            // number
            printf("EMIT '%c'\n", *str);
        } else {
            // operator (assumed to be valid)
            // get_bindpower(peek(opstk)) is the binding power of the last operator
            // get_bindpower(*str) is the binding power of the current operator
            while (!empty(opstk) && get_bindpower(peek(opstk)) >= get_bindpower(*str)) {
                printf("EMIT '%c'\n", peek(opstk));
                pop(opstk);
            }
            push(opstk, *str);
        }
        str += 1;
    }

    while (!empty(opstk)) {
        printf("EMIT '%c'\n", peek(opstk));
        pop(opstk);
    }

    return 0;
}

$ ./a.out '1+5*2+6'
EMIT '1'
EMIT '5'
EMIT '2'
EMIT '*'
EMIT '+'
EMIT '6'
EMIT '+'

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

typedef struct {
    char *str;
} Parser;

char cur(Parser *p) { return *p->str; }
void bump(Parser *p) { p->str += 1; }

int get_bindpower(char op) {
    static const int bps[] = {
        ['+'] = 1, ['-'] = 1, ['*'] = 2, ['/'] = 2
    };
    return bps[op];
}

// instead of starting off with an immediate abstraction of
// code paths and whatnot, all the code is inlined into expr() so
// the control flow is more explicit. this will be abstracted later.
void
expr(Parser *parser, int last_operator_bindpower) {
    // all expressions *must* start with a "nud" token.
    // in this case, our only nuds are digits.
    if (isdigit(cur(parser))) {
        printf("EMIT '%c'\n", cur(parser));
    } else {
        fprintf(stderr, "expression doesn't start with a number\n");
        abort();
    }

    bump(parser);

    while (cur(parser) != '\0') {
        // assumed to be a valid binary operator (like the shunting yard code)

        // at this point, we're at an infix/postfix operator.
        // this is what pratt calls "leds" in his original paper.
        // when this check is false, it's kind of like "unwinding" the stack in shunting yard.
        char op = cur(parser);
        int current_operator_bindpower = get_bindpower(op);
        if (current_operator_bindpower >= last_operator_bindpower) {
            return;
        }

        bump(parser);
        expr(parser, current_operator_bindpower);

        printf("EMIT '%c'\n", op);
    }
}

int main(int argc, char **argv) {
    Parser parser = (Parser){ .str = argv[1] };

    // the initial call should be with a binding power less than that of any operator
    expr(&parser, 0);

    return 0;
}

$ ./a.out '1+5*2+6'
EMIT '1'
EMIT '5'
EMIT '2'
EMIT '*'
EMIT '+'
EMIT '6'
EMIT '+'

#include <stdio.h>
#include <stdlib.h>

typedef struct {
    char *str;
} Parser;

char cur(Parser *p) { return *p->str; }
void bump(Parser *p) { p->str += 1; }

typedef void (*ParserFunc)(Parser *);

int
get_bindpower(char op) {
    static const int bps[] = {
        ['\0'] = 0, [')'] = 0,
        ['+'] = 1,  ['-'] = 1, ['*'] = 2, ['/'] = 2
    };
    return bps[op];
}

// forward declaration of expr() for calling in nud/led functions
void
expr(Parser *parser, int last_operator_bindpower);

// nud functions
void
paren(Parser *parser) {
    bump(parser);
    expr(parser, 0);
    if (cur(parser) != ')') {
        fprintf(stderr, "parentheses expression doesn't end with )\n");
        abort();
    }
    bump(parser);
}

void
num(Parser *parser) {
    printf("EMIT '%c'\n", cur(parser));
    bump(parser);
}

ParserFunc
get_nudfunc(char nud) {
    static const ParserFunc nuds[] = {
        ['('] = paren,
        ['0'] = num, ['1'] = num, ['2'] = num, ['3'] = num, ['4'] = num,
        ['5'] = num, ['6'] = num, ['7'] = num, ['8'] = num, ['9'] = num,
    };
    return nuds[nud];
}

// led functions
void
binary(Parser *parser) {
    char op = cur(parser);
    bump(parser);
    expr(parser, get_bindpower(op));
    printf("EMIT %c\n", op);
}

ParserFunc
get_ledfunc(char led) {
    static const ParserFunc leds[] = {
        ['+'] = binary, ['-'] = binary, ['*'] = binary, ['/'] = binary,
    };
    return leds[led];
}

// the main expression parsing call
void
expr(Parser *parser, int last_operator_bindpower) {
    ParserFunc nud_func = get_nudfunc(cur(parser));
    if (nud_func == NULL) {
        fprintf(stderr, "invalid nud: %c\n", cur(parser));
        abort();
    }
    nud_func(parser);

    // condition is now reversed, since this is the condition to stay in the loop
    // rather than break out of the loop.
    while (last_operator_bindpower < get_bindpower(cur(parser))) {
        ParserFunc led_func = get_ledfunc(cur(parser));
        if (led_func == NULL) {
            fprintf(stderr, "invalid led: %c\n", cur(parser));
            abort();
        }
        led_func(parser);
    }
}

int main(int argc, char **argv) {
    Parser parser = (Parser){ .str = argv[1] };

    // the initial call should be with a binding power equal to the "end token"
    expr(&parser, 0);

    return 0;
}

$ ./a.out '1+5*(2+6)'
EMIT '1'
EMIT '5'
EMIT '2'
EMIT '6'
EMIT '+'
EMIT '*'
EMIT '+'