2019 day5: cleaner (final ?) version

2019/day05/aoc-c.c

@@ -19,22 +19,12 @@
 #include "bits.h"
 #include "debug.h"
 
-static struct {
-    int cur;
-    int length;
-    int val[10];
-} input, output;
-
 typedef enum {
-    ADD = 1,
+    ADD    = 1, MUL    = 2,
-    MUL = 2,
+    INP    = 3, OUT    = 4,
-    INP = 3,
+    JMP_T  = 5, JMP_F  = 6,
-    OUT = 4,
+    SET_LT = 7, SET_EQ = 8,
-    JMP_T = 5,
+    HLT    = 99
-    JMP_F = 6,
-    SET_LT = 7,
-    SET_EQ = 8,
-    HLT = 99
 } opcode_t;
 
 /**
@@ -52,211 +42,78 @@ static struct {
     [MUL]    = { MUL,    3, 4, __stringify(MUL) },
     [INP]    = { INP,    1, 2, __stringify(INP) },
     [OUT]    = { OUT,    1, 2, __stringify(OUT) },
-    [JMP_T]  = { JMP_T,  2, 0, __stringify(JMP_T) },
+    [JMP_T]  = { JMP_T,  2, 3, __stringify(JMP_T) },
-    [JMP_F]  = { JMP_F,  2, 0, __stringify(JMP_F) },
+    [JMP_F]  = { JMP_F,  2, 3, __stringify(JMP_F) },
     [SET_LT] = { SET_LT, 3, 4, __stringify({SET_LT) },
     [SET_EQ] = { SET_EQ, 3, 4, __stringify(SET_EQ) },
-    [HLT] = { HLT, 0, 1, __stringify(HLT) }
+    [HLT]    = { HLT,    0, 1, __stringify(HLT) }
-};
-
-union mem {
-    struct {
-        u8 op: 8;
-        u8 nargs;
-        u8 flags: 8;
-    };
-    uint instr;
-    int param;
-    int *ind;
 };
 
 #define MAXOPS 1024
 struct program {
     int length;                                   /* total program length */
     int cur;                                      /* current position */
-    union mem mem[MAXOPS];                        /* should really be dynamic */
+    int mem [MAXOPS];                             /* should really be dynamic */
 };
 
 static int _flag_pow10[] = {1, 100, 1000, 10000};
-#define OP(p, n)        ((p->mem[n].instr) % 100)
+#define OP(p, n)           ((p->mem[n]) % 100)
-#define MODE(p, n, i)   (((p->mem[n].instr) / _flag_pow10[i]) % 10)
+#define ISDIRECT(p, n, i)  ((((p->mem[n]) / _flag_pow10[i]) % 10))
+#define DIRECT(p, i)       ((p)->mem[i])
+#define INDIRECT(p, i)     (DIRECT(p, DIRECT(p, i)))
 
-static int print_opcode(struct program *p, int pos)
+#define peek(p, n, i)      (ISDIRECT(p, n, i)? DIRECT(p, n + i): INDIRECT(p, n + i))
-{
+#define poke(p, n, i, val) do { INDIRECT(p, n + i) = val; } while (0)
-    int op = OP(p, pos);
+
-    if (ops[op].op) {
+static int run(struct program *p, int in)
-        int nargs = ops[op].len;
-
-        log(3, "%03d [%2d][%6s]\t", pos, op, ops[op].mnemo);
-        for (int i = 1; i <= nargs; ++i) {
-            int direct = p->mem[pos + i].param;
-            if (i > 1)
-                log(3, ", ");
-            if (i < 3 && !MODE(p, pos, i)) {
-                log(3, "*[%d]=", direct);
-                int val = p->mem[direct].param;
-                log(3, "%d", val);
-            } else {
-                log(3, "%d", direct);
-            }
-        }
-        log(3, "\n");
-        return nargs;
-    } else {
-        log(3, "%03d      \t", pos);
-        log(3, "%d\n", p->mem[pos].param);
-        return 0;
-    }
-}
-
-static void print_program_codes(struct program *p)
-{
-    log(3, "program codes: length=%d\n", p->length);
-    for (int i = 0; i < p->length; ++i)
-        log(3, "%d ", p->mem[i].param);
-    log(3, "\n");
-}
-
-static void print_program(struct program *p)
-{
-    print_program_codes(p);
-    log(3, "program: length=%d\n", p->length);
-    for (int i = 0; i < p->length; ++i) {
-        i += print_opcode(p, i);
-    }
-}
-
-#define INDIRECT(p, n) (p->mem[n].param)
-
-/**
- */
-static int peek(struct program *p, int pos, int arg)
-{
-    int flag = MODE(p, pos, arg);
-    int ret = p->mem[pos + arg].param;
-    if (!flag)
-        ret = p->mem[ret].param;
-    return ret;
-}
-
-static int poke(struct program *p, int pos, int arg, int val)
-{
-    int addr = p->mem[pos + arg].param;
-    p->mem[addr].param = val;
-    return val;
-}
-
-static int run(struct program *p)
 {
+    int out = -1;
     while (1) {
-        int op = OP(p, p->cur);
+        int op = OP(p, p->cur), _cur = p->cur;
-        int n1, n2;
+
         if (!(ops[op].op)) {
             fprintf(stderr, "PANIC: illegal instruction %d at %d.\n", op, p->cur);
             return -1;
         }
-        log(3, "OP=%s\n", ops[op].mnemo?  ops[op].mnemo: "UNKNOWN");
         switch (op) {
             case ADD:
-                n1 = peek(p, p->cur, 1);
+                poke(p, p->cur, 3, peek(p, p->cur, 1) +  peek(p, p->cur, 2));
-                n2 = peek(p, p->cur, 2);
-                poke(p, p->cur, 3, n1 + n2);
                 break;
             case MUL:
-                n1 = peek(p, p->cur, 1);
+                poke(p, p->cur, 3, peek(p, p->cur, 1) *  peek(p, p->cur, 2));
-                n2 = peek(p, p->cur, 2);
-                poke(p, p->cur, 3, n1 * n2);
                 break;
             case INP:
-                poke(p, p->cur, 1, input.val[input.cur++]);
+                poke(p, p->cur, 1, in);
                 break;
             case OUT:
-                output.val[output.length++] =  peek(p, p->cur, 1);
+                out = peek(p, p->cur, 1);
                 break;
             case JMP_T:
-                n1 = peek(p, p->cur, 1);
+                if (peek(p, p->cur, 1))
-                n2 = peek(p, p->cur, 2);
+                    p->cur =  peek(p, p->cur, 2);
-                if (n1)
-                    p->cur = n2;
-                else
-                    p->cur += ops[op].len + 1;
                 break;
             case JMP_F:
-                n1 = peek(p, p->cur, 1);
+                if (!peek(p, p->cur, 1))
-                n2 = peek(p, p->cur, 2);
+                    p->cur = peek(p, p->cur, 2);
-                if (!n1)
-                    p->cur = n2;
-                else
-                    p->cur += ops[op].len + 1;
                 break;
             case SET_LT:
-                n1 = peek(p, p->cur, 1);
+                poke(p, p->cur, 3, peek(p, p->cur, 1) < peek(p, p->cur, 2) ? 1: 0);
-                n2 = peek(p, p->cur, 2);
-                poke(p, p->cur, 3, n1 < n2 ? 1: 0);
                 break;
             case SET_EQ:
-                n1 = peek(p, p->cur, 1);
+                poke(p, p->cur, 3, peek(p, p->cur, 1) == peek(p, p->cur, 2) ? 1: 0);
-                n2 = peek(p, p->cur, 2);
-                poke(p, p->cur, 3, n1 == n2 ? 1: 0);
                 break;
             case HLT:
-                return p->mem[0].param;
+                return out;
-            default:
-                fprintf(stderr, "unknown error\n");
-                exit (1);
         }
-        p->cur += ops[op].next;
+        if (p->cur == _cur)
+            p->cur += ops[op].next;
     }
-    return -1;
 }
 
-static struct program *parse()
+static void parse(struct program *prog)
 {
-    size_t alloc = 0;
+    while (scanf("%d%*c", &prog->mem[prog->length++]) > 0)
-    ssize_t buflen;
+           ;
-    char *buf = NULL, *token;
-    int input;
-    struct program *prog = NULL;
-
-    if ((buflen = getline(&buf, &alloc, stdin)) <= 0) {
-        fprintf(stderr, "error reading file.\n");
-        goto end;
-    }
-
-    if (!(prog = calloc(1, sizeof(struct program)))) {
-        fprintf(stderr, "cannot allocate program.\n");
-        goto freebuf;
-    }
-    for (token = strtok(buf, ","); token; token = strtok(NULL, ",")) {
-        if (prog->length >= MAXOPS - 1) {
-            fprintf(stderr, "overflow !\n");
-            free(prog);
-            prog = NULL;
-            goto freebuf;
-        }
-        input=atoi(token);
-        prog->mem[prog->length++].param = input;
-    }
-freebuf:
-    free(buf);
-end:
-    return prog;
-}
-
-static int part1(struct program *p)
-{
-    if (!input.length)
-        input.val[input.length++] = 1;
-    run(p);
-    return output.val[output.length - 1];
-}
-
-static int part2(struct program *p)
-{
-    if (!input.length)
-        input.val[input.length++] = 5;
-    run(p);
-    return output.val[output.length - 1];
 }
 
 static int usage(char *prg)
@@ -267,8 +124,8 @@ static int usage(char *prg)
 
 int main(int ac, char **av)
 {
-    int opt, part = 1;
+    int opt, part = 1, in = -1;
-    struct program *p;
+    struct program p = { 0 };
 
     while ((opt = getopt(ac, av, "d:p:i:")) != -1) {
         switch (opt) {
@@ -276,7 +133,7 @@ int main(int ac, char **av)
                 debug_level_set(atoi(optarg));
                 break;
             case 'i':
-                input.val[input.length++] = atoi(optarg);
+                in = atoi(optarg);
                 break;
             case 'p':                             /* 1 or 2 */
                 part = atoi(optarg);
@@ -290,8 +147,9 @@ int main(int ac, char **av)
 
     if (optind < ac)
         return usage(*av);
-    p = parse();
+    if (in == -1)
-    print_program(p);
+        in = part == 1? 1: 5;
-    printf("%s : res=%d\n", *av, part == 1? part1(p): part2(p));
+    parse(&p);
+    printf("%s : res=%d\n", *av, run(&p, in));
     exit (0);
 }