prompt.c:53:11: error: unknown type name ‘mpc_ast_t’; did you mean ‘mpc_rnd_t’?
 lval eval(mpc_ast_t* t);
           ^~~~~~~~~
           mpc_rnd_t
prompt.c: In function ‘main’:
prompt.c:65:2: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
  mpc_parser_t* Number = mpc_new("number");
  ^~~~~~~~~~~~
  mp_prec_t
prompt.c:65:25: warning: implicit declaration of function ‘mpc_new’; did you mean ‘mpc_neg’? [-Wimplicit-function-declaration]
  mpc_parser_t* Number = mpc_new("number");
                         ^~~~~~~
                         mpc_neg
prompt.c:65:25: warning: initialization of ‘int *’ from ‘int’ makes pointer from integer without a cast [-Wint-conversion]
prompt.c:66:2: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
  mpc_parser_t* Operator = mpc_new("operator");
  ^~~~~~~~~~~~
  mp_prec_t
prompt.c:66:27: warning: initialization of ‘int *’ from ‘int’ makes pointer from integer without a cast [-Wint-conversion]
  mpc_parser_t* Operator = mpc_new("operator");
                           ^~~~~~~
prompt.c:67:2: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
  mpc_parser_t* Expr = mpc_new("expr");
  ^~~~~~~~~~~~
  mp_prec_t
prompt.c:67:23: warning: initialization of ‘int *’ from ‘int’ makes pointer from integer without a cast [-Wint-conversion]
  mpc_parser_t* Expr = mpc_new("expr");
                       ^~~~~~~
prompt.c:68:2: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
  mpc_parser_t* Lispy = mpc_new("lispy");
  ^~~~~~~~~~~~
  mp_prec_t
prompt.c:68:24: warning: initialization of ‘int *’ from ‘int’ makes pointer from integer without a cast [-Wint-conversion]
  mpc_parser_t* Lispy = mpc_new("lispy");
                        ^~~~~~~
prompt.c:71:2: warning: implicit declaration of function ‘mpca_lang’; did you mean ‘mpc_tanh’? [-Wimplicit-function-declaration]
  mpca_lang(MPCA_LANG_DEFAULT,
  ^~~~~~~~~
  mpc_tanh
prompt.c:71:12: error: ‘MPCA_LANG_DEFAULT’ undeclared (first use in this function); did you mean ‘MPFR_EMIN_DEFAULT’?
  mpca_lang(MPCA_LANG_DEFAULT,
            ^~~~~~~~~~~~~~~~~
            MPFR_EMIN_DEFAULT
prompt.c:71:12: note: each undeclared identifier is reported only once for each function it appears in
prompt.c:95:3: error: unknown type name ‘mpc_result_t’; did you mean ‘mpc_rnd_t’?
   mpc_result_t r;
   ^~~~~~~~~~~~
   mpc_rnd_t
prompt.c:96:7: warning: implicit declaration of function ‘mpc_parse’; did you mean ‘mpc_proj’? [-Wimplicit-function-declaration]
   if (mpc_parse("<stdin>", input, Lispy, &r)) {
       ^~~~~~~~~
       mpc_proj
prompt.c:101:18: warning: implicit declaration of function ‘eval’ [-Wimplicit-function-declaration]
    lval result = eval(r.output);
                  ^~~~
prompt.c:101:24: error: request for member ‘output’ in something not a structure or union
    lval result = eval(r.output);
                        ^
prompt.c:103:4: warning: implicit declaration of function ‘mpc_ast_delete’; did you mean ‘mpc_out_str’? [-Wimplicit-function-declaration]
    mpc_ast_delete(r.output);
    ^~~~~~~~~~~~~~
    mpc_out_str
prompt.c:103:20: error: request for member ‘output’ in something not a structure or union
    mpc_ast_delete(r.output);
                    ^
prompt.c:106:4: warning: implicit declaration of function ‘mpc_err_print’; did you mean ‘mpfr_rint’? [-Wimplicit-function-declaration]
    mpc_err_print(r.error);
    ^~~~~~~~~~~~~
    mpfr_rint
prompt.c:106:19: error: request for member ‘error’ in something not a structure or union
    mpc_err_print(r.error);
                   ^
prompt.c:107:4: warning: implicit declaration of function ‘mpc_err_delete’; did you mean ‘mpc_free_str’? [-Wimplicit-function-declaration]
    mpc_err_delete(r.error);
    ^~~~~~~~~~~~~~
    mpc_free_str
prompt.c:107:20: error: request for member ‘error’ in something not a structure or union
    mpc_err_delete(r.error);
                    ^
prompt.c:114:2: warning: implicit declaration of function ‘mpc_cleanup’; did you mean ‘mpc_clear’? [-Wimplicit-function-declaration]
  mpc_cleanup(4, Number, Operator, Expr, Lispy);
  ^~~~~~~~~~~
  mpc_clear
prompt.c: In function ‘eval_op’:
prompt.c:122:6: warning: implicit declaration of function ‘strcmp’ [-Wimplicit-function-declaration]
  if (strcmp(op, "+")   == 0) { return lval_num(x.data.num + y.data.num);      }
      ^~~~~~
prompt.c:131:48: warning: implicit declaration of function ‘pow’ [-Wimplicit-function-declaration]
  if (strcmp(op, "^")   == 0) { return lval_num(pow(x.data.num, y.data.num));  }
                                                ^~~
prompt.c:131:48: warning: incompatible implicit declaration of built-in function ‘pow’
prompt.c:131:48: note: include ‘<math.h>’ or provide a declaration of ‘pow’
prompt.c:31:1:
+#include <math.h>
 #endif
prompt.c:131:48:
  if (strcmp(op, "^")   == 0) { return lval_num(pow(x.data.num, y.data.num));  }
                                                ^~~
prompt.c:132:48: warning: implicit declaration of function ‘fmod’ [-Wimplicit-function-declaration]
  if (strcmp(op, "%")   == 0) { return lval_num(fmod(x.data.num, y.data.num)); }
                                                ^~~~
prompt.c:132:48: warning: incompatible implicit declaration of built-in function ‘fmod’
prompt.c:132:48: note: include ‘<math.h>’ or provide a declaration of ‘fmod’
prompt.c: At top level:
prompt.c:146:11: error: unknown type name ‘mpc_ast_t’; did you mean ‘mpc_rnd_t’?
 lval eval(mpc_ast_t* t) {
           ^~~~~~~~~
           mpc_rnd_t
mpc.c:7:8: error: unknown type name ‘mpc_state_t’
 static mpc_state_t mpc_state_invalid(void) {
        ^~~~~~~~~~~
mpc.c: In function ‘mpc_state_invalid’:
mpc.c:8:3: error: unknown type name ‘mpc_state_t’; did you mean ‘mp_size_t’?
   mpc_state_t s;
   ^~~~~~~~~~~
   mp_size_t
mpc.c:9:4: error: request for member ‘pos’ in something not a structure or union
   s.pos = -1;
    ^
mpc.c:10:4: error: request for member ‘row’ in something not a structure or union
   s.row = -1;
    ^
mpc.c:11:4: error: request for member ‘col’ in something not a structure or union
   s.col = -1;
    ^
mpc.c: At top level:
mpc.c:15:8: error: unknown type name ‘mpc_state_t’
 static mpc_state_t mpc_state_new(void) {
        ^~~~~~~~~~~
mpc.c: In function ‘mpc_state_new’:
mpc.c:16:3: error: unknown type name ‘mpc_state_t’; did you mean ‘mp_size_t’?
   mpc_state_t s;
   ^~~~~~~~~~~
   mp_size_t
mpc.c:17:4: error: request for member ‘pos’ in something not a structure or union
   s.pos = 0;
    ^
mpc.c:18:4: error: request for member ‘row’ in something not a structure or union
   s.row = 0;
    ^
mpc.c:19:4: error: request for member ‘col’ in something not a structure or union
   s.col = 0;
    ^
mpc.c: At top level:
mpc.c:80:3: error: unknown type name ‘mpc_state_t’
   mpc_state_t state;
   ^~~~~~~~~~~
mpc.c:84:3: error: unknown type name ‘FILE’
   FILE *file;
   ^~~~
mpc.c:90:3: error: unknown type name ‘mpc_state_t’
   mpc_state_t *marks;
   ^~~~~~~~~~~
mpc.c: In function ‘mpc_input_new_string’:
mpc.c:103:20: warning: implicit declaration of function ‘malloc’ [-Wimplicit-function-declaration]
   mpc_input_t *i = malloc(sizeof(mpc_input_t));
                    ^~~~~~
mpc.c:103:20: warning: incompatible implicit declaration of built-in function ‘malloc’
mpc.c:103:20: note: include ‘<stdlib.h>’ or provide a declaration of ‘malloc’
mpc.c:2:1:
+#include <stdlib.h>
 
mpc.c:103:20:
   mpc_input_t *i = malloc(sizeof(mpc_input_t));
                    ^~~~~~
mpc.c:105:24: warning: implicit declaration of function ‘strlen’ [-Wimplicit-function-declaration]
   i->filename = malloc(strlen(filename) + 1);
                        ^~~~~~
mpc.c:105:24: warning: incompatible implicit declaration of built-in function ‘strlen’
mpc.c:105:24: note: include ‘<string.h>’ or provide a declaration of ‘strlen’
mpc.c:2:1:
+#include <string.h>
 
mpc.c:105:24:
   i->filename = malloc(strlen(filename) + 1);
                        ^~~~~~
mpc.c:106:3: warning: implicit declaration of function ‘strcpy’ [-Wimplicit-function-declaration]
   strcpy(i->filename, filename);
   ^~~~~~
mpc.c:106:3: warning: incompatible implicit declaration of built-in function ‘strcpy’
mpc.c:106:3: note: include ‘<string.h>’ or provide a declaration of ‘strcpy’
mpc.c:120:28: error: ‘mpc_state_t’ undeclared (first use in this function); did you mean ‘mpc_state_new’?
   i->marks = malloc(sizeof(mpc_state_t) * i->marks_slots);
                            ^~~~~~~~~~~
                            mpc_state_new
mpc.c:120:28: note: each undeclared identifier is reported only once for each function it appears in
mpc.c:125:3: warning: implicit declaration of function ‘memset’ [-Wimplicit-function-declaration]
   memset(i->mem_full, 0, sizeof(char) * MPC_INPUT_MEM_NUM);
   ^~~~~~
mpc.c:125:3: warning: incompatible implicit declaration of built-in function ‘memset’
mpc.c:125:3: note: include ‘<string.h>’ or provide a declaration of ‘memset’
mpc.c: In function ‘mpc_input_new_nstring’:
mpc.c:132:20: warning: incompatible implicit declaration of built-in function ‘malloc’
   mpc_input_t *i = malloc(sizeof(mpc_input_t));
                    ^~~~~~
mpc.c:132:20: note: include ‘<stdlib.h>’ or provide a declaration of ‘malloc’
mpc.c:134:24: warning: incompatible implicit declaration of built-in function ‘strlen’
   i->filename = malloc(strlen(filename) + 1);
                        ^~~~~~
mpc.c:134:24: note: include ‘<string.h>’ or provide a declaration of ‘strlen’
mpc.c:135:3: warning: incompatible implicit declaration of built-in function ‘strcpy’
   strcpy(i->filename, filename);
   ^~~~~~
mpc.c:135:3: note: include ‘<string.h>’ or provide a declaration of ‘strcpy’
mpc.c:141:3: warning: implicit declaration of function ‘strncpy’ [-Wimplicit-function-declaration]
   strncpy(i->string, string, length);
   ^~~~~~~
mpc.c:141:3: warning: incompatible implicit declaration of built-in function ‘strncpy’
mpc.c:141:3: note: include ‘<string.h>’ or provide a declaration of ‘strncpy’
mpc.c:150:28: error: ‘mpc_state_t’ undeclared (first use in this function); did you mean ‘mpc_state_new’?
   i->marks = malloc(sizeof(mpc_state_t) * i->marks_slots);
                            ^~~~~~~~~~~
                            mpc_state_new
mpc.c:155:3: warning: incompatible implicit declaration of built-in function ‘memset’
   memset(i->mem_full, 0, sizeof(char) * MPC_INPUT_MEM_NUM);
   ^~~~~~
mpc.c:155:3: note: include ‘<string.h>’ or provide a declaration of ‘memset’
mpc.c: At top level:
mpc.c:161:62: error: unknown type name ‘FILE’
 static mpc_input_t *mpc_input_new_pipe(const char *filename, FILE *pipe) {
                                                              ^~~~
mpc.c:161:62: note: ‘FILE’ is defined in header ‘<stdio.h>’; did you forget to ‘#include <stdio.h>’?
mpc.c:2:1:
+#include <stdio.h>
 
mpc.c:161:62:
 static mpc_input_t *mpc_input_new_pipe(const char *filename, FILE *pipe) {
                                                              ^~~~
mpc.c:190:62: error: unknown type name ‘FILE’
 static mpc_input_t *mpc_input_new_file(const char *filename, FILE *file) {
                                                              ^~~~
mpc.c:190:62: note: ‘FILE’ is defined in header ‘<stdio.h>’; did you forget to ‘#include <stdio.h>’?
mpc.c: In function ‘mpc_input_delete’:
mpc.c:219:3: warning: implicit declaration of function ‘free’ [-Wimplicit-function-declaration]
   free(i->filename);
   ^~~~
mpc.c:219:3: warning: incompatible implicit declaration of built-in function ‘free’
mpc.c:219:3: note: include ‘<stdlib.h>’ or provide a declaration of ‘free’
mpc.c: In function ‘mpc_malloc’:
mpc.c:239:39: warning: incompatible implicit declaration of built-in function ‘malloc’
   if (n > sizeof(mpc_mem_t)) { return malloc(n); }
                                       ^~~~~~
mpc.c:239:39: note: include ‘<stdlib.h>’ or provide a declaration of ‘malloc’
mpc.c:252:10: warning: incompatible implicit declaration of built-in function ‘malloc’
   return malloc(n);
          ^~~~~~
mpc.c:252:10: note: include ‘<stdlib.h>’ or provide a declaration of ‘malloc’
mpc.c: In function ‘mpc_calloc’:
mpc.c:257:3: warning: incompatible implicit declaration of built-in function ‘memset’
   memset(x, 0, n * m);
   ^~~~~~
mpc.c:257:3: note: include ‘<string.h>’ or provide a declaration of ‘memset’
mpc.c: In function ‘mpc_free’:
mpc.c:263:29: warning: incompatible implicit declaration of built-in function ‘free’
   if (!mpc_mem_ptr(i, p)) { free(p); return; }
                             ^~~~
mpc.c:263:29: note: include ‘<stdlib.h>’ or provide a declaration of ‘free’
mpc.c: In function ‘mpc_realloc’:
mpc.c:272:36: warning: implicit declaration of function ‘realloc’ [-Wimplicit-function-declaration]
   if (!mpc_mem_ptr(i, p)) { return realloc(p, n); }
                                    ^~~~~~~
mpc.c:272:36: warning: incompatible implicit declaration of built-in function ‘realloc’
mpc.c:272:36: note: include ‘<stdlib.h>’ or provide a declaration of ‘realloc’
mpc.c:275:9: warning: incompatible implicit declaration of built-in function ‘malloc’
     q = malloc(n);
         ^~~~~~
mpc.c:275:9: note: include ‘<stdlib.h>’ or provide a declaration of ‘malloc’
mpc.c:276:5: warning: implicit declaration of function ‘memcpy’ [-Wimplicit-function-declaration]
     memcpy(q, p, sizeof(mpc_mem_t));
     ^~~~~~
mpc.c:276:5: warning: incompatible implicit declaration of built-in function ‘memcpy’
mpc.c:276:5: note: include ‘<string.h>’ or provide a declaration of ‘memcpy’
mpc.c: In function ‘mpc_export’:
mpc.c:287:7: warning: incompatible implicit declaration of built-in function ‘malloc’
   q = malloc(sizeof(mpc_mem_t));
       ^~~~~~
mpc.c:287:7: note: include ‘<stdlib.h>’ or provide a declaration of ‘malloc’
mpc.c:288:3: warning: incompatible implicit declaration of built-in function ‘memcpy’
   memcpy(q, p, sizeof(mpc_mem_t));
   ^~~~~~
mpc.c:288:3: note: include ‘<string.h>’ or provide a declaration of ‘memcpy’
mpc.c: In function ‘mpc_input_mark’:
mpc.c:307:16: warning: incompatible implicit declaration of built-in function ‘realloc’
     i->marks = realloc(i->marks, sizeof(mpc_state_t) * i->marks_slots);
                ^~~~~~~
mpc.c:307:16: note: include ‘<stdlib.h>’ or provide a declaration of ‘realloc’
mpc.c:307:41: error: ‘mpc_state_t’ undeclared (first use in this function); did you mean ‘mpc_state_new’?
     i->marks = realloc(i->marks, sizeof(mpc_state_t) * i->marks_slots);
                                         ^~~~~~~~~~~
                                         mpc_state_new
mpc.c:315:17: warning: implicit declaration of function ‘calloc’ [-Wimplicit-function-declaration]
     i->buffer = calloc(1, 1);
                 ^~~~~~
mpc.c:315:17: warning: incompatible implicit declaration of built-in function ‘calloc’
mpc.c:315:17: note: include ‘<stdlib.h>’ or provide a declaration of ‘calloc’
mpc.c: In function ‘mpc_input_unmark’:
mpc.c:331:16: warning: incompatible implicit declaration of built-in function ‘realloc’
     i->marks = realloc(i->marks, sizeof(mpc_state_t) * i->marks_slots);
                ^~~~~~~
mpc.c:331:16: note: include ‘<stdlib.h>’ or provide a declaration of ‘realloc’
mpc.c:331:41: error: ‘mpc_state_t’ undeclared (first use in this function); did you mean ‘mpc_state_new’?
     i->marks = realloc(i->marks, sizeof(mpc_state_t) * i->marks_slots);
                                         ^~~~~~~~~~~
                                         mpc_state_new
mpc.c:336:5: warning: incompatible implicit declaration of built-in function ‘free’
     free(i->buffer);
     ^~~~
mpc.c:336:5: note: include ‘<stdlib.h>’ or provide a declaration of ‘free’
mpc.c: In function ‘mpc_input_rewind’:
mpc.c:350:5: warning: implicit declaration of function ‘fseek’ [-Wimplicit-function-declaration]
     fseek(i->file, i->state.pos, SEEK_SET);
     ^~~~~
mpc.c:350:28: error: request for member ‘pos’ in something not a structure or union
     fseek(i->file, i->state.pos, SEEK_SET);
                            ^
mpc.c:350:34: error: ‘SEEK_SET’ undeclared (first use in this function)
     fseek(i->file, i->state.pos, SEEK_SET);
                                  ^~~~~~~~
mpc.c: In function ‘mpc_input_buffer_in_range’:
mpc.c:357:18: error: request for member ‘pos’ in something not a structure or union
   return i->state.pos < (long)(strlen(i->buffer) + i->marks[0].pos);
                  ^
mpc.c:357:32: warning: incompatible implicit declaration of built-in function ‘strlen’
   return i->state.pos < (long)(strlen(i->buffer) + i->marks[0].pos);
                                ^~~~~~
mpc.c:357:32: note: include ‘<string.h>’ or provide a declaration of ‘strlen’
mpc.c:357:63: error: request for member ‘pos’ in something not a structure or union
   return i->state.pos < (long)(strlen(i->buffer) + i->marks[0].pos);
                                                               ^
mpc.c: In function ‘mpc_input_buffer_get’:
mpc.c:361:28: error: request for member ‘pos’ in something not a structure or union
   return i->buffer[i->state.pos - i->marks[0].pos];
                            ^
mpc.c:361:46: error: request for member ‘pos’ in something not a structure or union
   return i->buffer[i->state.pos - i->marks[0].pos];
                                              ^
mpc.c: In function ‘mpc_input_terminated’:
mpc.c:365:46: error: request for member ‘pos’ in something not a structure or union
   if (i->type == MPC_INPUT_STRING && i->state.pos == (long)strlen(i->string)) { return 1; }
                                              ^
mpc.c:365:60: warning: incompatible implicit declaration of built-in function ‘strlen’
   if (i->type == MPC_INPUT_STRING && i->state.pos == (long)strlen(i->string)) { return 1; }
                                                            ^~~~~~
mpc.c:365:60: note: include ‘<string.h>’ or provide a declaration of ‘strlen’
mpc.c:366:36: warning: implicit declaration of function ‘feof’; did you mean ‘offsetof’? [-Wimplicit-function-declaration]
   if (i->type == MPC_INPUT_FILE && feof(i->file)) { return 1; }
                                    ^~~~
                                    offsetof
mpc.c: In function ‘mpc_input_getc’:
mpc.c:377:53: error: request for member ‘pos’ in something not a structure or union
     case MPC_INPUT_STRING: return i->string[i->state.pos];
                                                     ^
mpc.c:378:30: warning: implicit declaration of function ‘fgetc’ [-Wimplicit-function-declaration]
     case MPC_INPUT_FILE: c = fgetc(i->file); return c;
                              ^~~~~
mpc.c:381:29: warning: implicit declaration of function ‘getc’ [-Wimplicit-function-declaration]
       if (!i->buffer) { c = getc(i->file); return c; }
                             ^~~~
mpc.c: In function ‘mpc_input_peekc’:
mpc.c:400:53: error: request for member ‘pos’ in something not a structure or union
     case MPC_INPUT_STRING: return i->string[i->state.pos];
                                                     ^
mpc.c:406:26: error: ‘SEEK_CUR’ undeclared (first use in this function)
       fseek(i->file, -1, SEEK_CUR);
                          ^~~~~~~~
mpc.c:414:9: warning: implicit declaration of function ‘ungetc’ [-Wimplicit-function-declaration]
         ungetc(c, i->file);
         ^~~~~~
mpc.c: In function ‘mpc_input_failure’:
mpc.c:436:45: error: ‘SEEK_CUR’ undeclared (first use in this function)
     case MPC_INPUT_FILE: fseek(i->file, -1, SEEK_CUR); { break; }
                                             ^~~~~~~~
mpc.c: In function ‘mpc_input_success’:
mpc.c:456:17: warning: incompatible implicit declaration of built-in function ‘realloc’
     i->buffer = realloc(i->buffer, strlen(i->buffer) + 2);
                 ^~~~~~~
mpc.c:456:17: note: include ‘<stdlib.h>’ or provide a declaration of ‘realloc’
mpc.c:456:36: warning: incompatible implicit declaration of built-in function ‘strlen’
     i->buffer = realloc(i->buffer, strlen(i->buffer) + 2);
                                    ^~~~~~
mpc.c:456:36: note: include ‘<string.h>’ or provide a declaration of ‘strlen’
mpc.c:462:11: error: request for member ‘pos’ in something not a structure or union
   i->state.pos++;
           ^
mpc.c:463:11: error: request for member ‘col’ in something not a structure or union
   i->state.col++;
           ^
mpc.c:466:13: error: request for member ‘col’ in something not a structure or union
     i->state.col = 0;
             ^
mpc.c:467:13: error: request for member ‘row’ in something not a structure or union
     i->state.row++;
             ^
mpc.c: In function ‘mpc_input_oneof’:
mpc.c:500:10: warning: implicit declaration of function ‘strchr’ [-Wimplicit-function-declaration]
   return strchr(c, x) != 0 ? mpc_input_success(i, x, o) : mpc_input_failure(i, x);
          ^~~~~~
mpc.c:500:10: warning: incompatible implicit declaration of built-in function ‘strchr’
mpc.c:500:10: note: include ‘<string.h>’ or provide a declaration of ‘strchr’
mpc.c: In function ‘mpc_input_noneof’:
mpc.c:506:10: warning: incompatible implicit declaration of built-in function ‘strchr’
   return strchr(c, x) == 0 ? mpc_input_success(i, x, o) : mpc_input_failure(i, x);
          ^~~~~~
mpc.c:506:10: note: include ‘<string.h>’ or provide a declaration of ‘strchr’
mpc.c: In function ‘mpc_input_string’:
mpc.c:529:22: warning: incompatible implicit declaration of built-in function ‘strlen’
   *o = mpc_malloc(i, strlen(c) + 1);
                      ^~~~~~
mpc.c:529:22: note: include ‘<string.h>’ or provide a declaration of ‘strlen’
mpc.c:530:3: warning: incompatible implicit declaration of built-in function ‘strcpy’
   strcpy(*o, c);
   ^~~~~~
mpc.c:530:3: note: include ‘<string.h>’ or provide a declaration of ‘strcpy’
mpc.c: At top level:
mpc.c:539:8: error: unknown type name ‘mpc_state_t’
 static mpc_state_t *mpc_input_state_copy(mpc_input_t *i) {
        ^~~~~~~~~~~
mpc.c: In function ‘mpc_input_state_copy’:
mpc.c:540:3: error: unknown type name ‘mpc_state_t’; did you mean ‘mp_size_t’?
   mpc_state_t *r = mpc_malloc(i, sizeof(mpc_state_t));
   ^~~~~~~~~~~
   mp_size_t
mpc.c:540:41: error: ‘mpc_state_t’ undeclared (first use in this function); did you mean ‘mpc_state_new’?
   mpc_state_t *r = mpc_malloc(i, sizeof(mpc_state_t));
                                         ^~~~~~~~~~~
                                         mpc_state_new
mpc.c:541:3: warning: incompatible implicit declaration of built-in function ‘memcpy’
   memcpy(r, &i->state, sizeof(mpc_state_t));
   ^~~~~~
mpc.c:541:3: note: include ‘<string.h>’ or provide a declaration of ‘memcpy’
mpc.c: At top level:
mpc.c:549:21: error: unknown type name ‘mpc_err_t’; did you mean ‘mpc_mem_t’?
 void mpc_err_delete(mpc_err_t *x) {
                     ^~~~~~~~~
                     mpc_mem_t
mpc.c:558:20: error: unknown type name ‘mpc_err_t’; did you mean ‘mpc_mem_t’?
 void mpc_err_print(mpc_err_t *x) {
                    ^~~~~~~~~
                    mpc_mem_t
mpc.c:562:23: error: unknown type name ‘mpc_err_t’; did you mean ‘mpc_mem_t’?
 void mpc_err_print_to(mpc_err_t *x, FILE *f) {
                       ^~~~~~~~~
                       mpc_mem_t
mpc.c:562:37: error: unknown type name ‘FILE’
 void mpc_err_print_to(mpc_err_t *x, FILE *f) {
                                     ^~~~
mpc.c:562:37: note: ‘FILE’ is defined in header ‘<stdio.h>’; did you forget to ‘#include <stdio.h>’?
mpc.c: In function ‘mpc_err_string_cat’:
mpc.c:571:3: error: unknown type name ‘va_list’
   va_list va;
   ^~~~~~~
mpc.c:571:3: note: ‘va_list’ is defined in header ‘<stdarg.h>’; did you forget to ‘#include <stdarg.h>’?
mpc.c:2:1:
+#include <stdarg.h>
 
mpc.c:571:3:
   va_list va;
   ^~~~~~~
mpc.c:572:3: warning: implicit declaration of function ‘va_start’ [-Wimplicit-function-declaration]
   va_start(va, fmt);
   ^~~~~~~~
mpc.c:574:13: warning: implicit declaration of function ‘vsprintf’ [-Wimplicit-function-declaration]
   (*pos) += vsprintf(buffer + (*pos), fmt, va);
             ^~~~~~~~
mpc.c:575:3: warning: implicit declaration of function ‘va_end’ [-Wimplicit-function-declaration]
   va_end(va);
   ^~~~~~
mpc.c: At top level:
mpc.c:604:22: error: unknown type name ‘mpc_err_t’; did you mean ‘mpc_mem_t’?
 char *mpc_err_string(mpc_err_t *x) {
                      ^~~~~~~~~
                      mpc_mem_t
mpc.c:640:8: error: unknown type name ‘mpc_err_t’
 static mpc_err_t *mpc_err_new(mpc_input_t *i, const char *expected) {
        ^~~~~~~~~
mpc.c: In function ‘mpc_err_new’:
mpc.c:641:3: error: unknown type name ‘mpc_err_t’; did you mean ‘mpc_mem_t’?
   mpc_err_t *x;
   ^~~~~~~~~
   mpc_mem_t
mpc.c:643:28: error: ‘mpc_err_t’ undeclared (first use in this function); did you mean ‘mpc_err_new’?
   x = mpc_malloc(i, sizeof(mpc_err_t));
                            ^~~~~~~~~
                            mpc_err_new
mpc.c:644:4: error: request for member ‘filename’ in something not a structure or union
   x->filename = mpc_malloc(i, strlen(i->filename) + 1);
    ^~
mpc.c:644:31: warning: incompatible implicit declaration of built-in function ‘strlen’
   x->filename = mpc_malloc(i, strlen(i->filename) + 1);
                               ^~~~~~
mpc.c:644:31: note: include ‘<string.h>’ or provide a declaration of ‘strlen’
mpc.c:645:3: warning: incompatible implicit declaration of built-in function ‘strcpy’
   strcpy(x->filename, i->filename);
   ^~~~~~
mpc.c:645:3: note: include ‘<string.h>’ or provide a declaration of ‘strcpy’
mpc.c:645:11: error: request for member ‘filename’ in something not a structure or union
   strcpy(x->filename, i->filename);
           ^~
mpc.c:646:4: error: request for member ‘state’ in something not a structure or union
   x->state = i->state;
    ^~
mpc.c:647:4: error: request for member ‘expected_num’ in something not a structure or union
   x->expected_num = 1;
    ^~
mpc.c:648:4: error: request for member ‘expected’ in something not a structure or union
   x->expected = mpc_malloc(i, sizeof(char*));
    ^~
mpc.c:649:4: error: request for member ‘expected’ in something not a structure or union
   x->expected[0] = mpc_malloc(i, strlen(expected) + 1);
    ^~
mpc.c:650:11: error: request for member ‘expected’ in something not a structure or union
   strcpy(x->expected[0], expected);
           ^~
mpc.c:651:4: error: request for member ‘failure’ in something not a structure or union
   x->failure = NULL;
    ^~
mpc.c:652:4: error: request for member ‘recieved’ in something not a structure or union
   x->recieved = mpc_input_peekc(i);
    ^~
mpc.c: At top level:
mpc.c:656:8: error: unknown type name ‘mpc_err_t’
 static mpc_err_t *mpc_err_fail(mpc_input_t *i, const char *failure) {
        ^~~~~~~~~
mpc.c: In function ‘mpc_err_fail’:
mpc.c:657:3: error: unknown type name ‘mpc_err_t’; did you mean ‘mpc_mem_t’?
   mpc_err_t *x;
   ^~~~~~~~~
   mpc_mem_t
mpc.c:659:28: error: ‘mpc_err_t’ undeclared (first use in this function); did you mean ‘mpc_err_new’?
   x = mpc_malloc(i, sizeof(mpc_err_t));
                            ^~~~~~~~~
                            mpc_err_new
mpc.c:660:4: error: request for member ‘filename’ in something not a structure or union
   x->filename = mpc_malloc(i, strlen(i->filename) + 1);
    ^~
mpc.c:660:31: warning: incompatible implicit declaration of built-in function ‘strlen’
   x->filename = mpc_malloc(i, strlen(i->filename) + 1);
                               ^~~~~~
mpc.c:660:31: note: include ‘<string.h>’ or provide a declaration of ‘strlen’
mpc.c:661:3: warning: incompatible implicit declaration of built-in function ‘strcpy’
   strcpy(x->filename, i->filename);
   ^~~~~~
mpc.c:661:3: note: include ‘<string.h>’ or provide a declaration of ‘strcpy’
mpc.c:661:11: error: request for member ‘filename’ in something not a structure or union
   strcpy(x->filename, i->filename);
           ^~
mpc.c:662:4: error: request for member ‘state’ in something not a structure or union
   x->state = i->state;
    ^~
mpc.c:663:4: error: request for member ‘expected_num’ in something not a structure or union
   x->expected_num = 0;
    ^~
mpc.c:664:4: error: request for member ‘expected’ in something not a structure or union
   x->expected = NULL;
    ^~
mpc.c:665:4: error: request for member ‘failure’ in something not a structure or union
   x->failure = mpc_malloc(i, strlen(failure) + 1);
    ^~
mpc.c:666:11: error: request for member ‘failure’ in something not a structure or union
   strcpy(x->failure, failure);
           ^~
mpc.c:667:4: error: request for member ‘recieved’ in something not a structure or union
   x->recieved = ' ';
    ^~
mpc.c: At top level:
mpc.c:671:8: error: unknown type name ‘mpc_err_t’
 static mpc_err_t *mpc_err_file(const char *filename, const char *failure) {
        ^~~~~~~~~
mpc.c: In function ‘mpc_err_file’:
mpc.c:672:3: error: unknown type name ‘mpc_err_t’; did you mean ‘mpc_mem_t’?
   mpc_err_t *x;
   ^~~~~~~~~
   mpc_mem_t
mpc.c:673:7: warning: incompatible implicit declaration of built-in function ‘malloc’
   x = malloc(sizeof(mpc_err_t));
       ^~~~~~
mpc.c:673:7: note: include ‘<stdlib.h>’ or provide a declaration of ‘malloc’
mpc.c:673:21: error: ‘mpc_err_t’ undeclared (first use in this function); did you mean ‘mpc_err_new’?
   x = malloc(sizeof(mpc_err_t));
                     ^~~~~~~~~
                     mpc_err_new
mpc.c:674:4: error: request for member ‘filename’ in something not a structure or union
   x->filename = malloc(strlen(filename) + 1);
    ^~
mpc.c:674:24: warning: incompatible implicit declaration of built-in function ‘strlen’
   x->filename = malloc(strlen(filename) + 1);
                        ^~~~~~
mpc.c:674:24: note: include ‘<string.h>’ or provide a declaration of ‘strlen’
mpc.c:675:3: warning: incompatible implicit declaration of built-in function ‘strcpy’
   strcpy(x->filename, filename);
   ^~~~~~
mpc.c:675:3: note: include ‘<string.h>’ or provide a declaration of ‘strcpy’
mpc.c:675:11: error: request for member ‘filename’ in something not a structure or union
   strcpy(x->filename, filename);
           ^~
mpc.c:676:4: error: request for member ‘state’ in something not a structure or union
   x->state = mpc_state_new();
    ^~
mpc.c:677:4: error: request for member ‘expected_num’ in something not a structure or union
   x->expected_num = 0;
    ^~
mpc.c:678:4: error: request for member ‘expected’ in something not a structure or union
   x->expected = NULL;
    ^~
mpc.c:679:4: error: request for member ‘failure’ in something not a structure or union
   x->failure = malloc(strlen(failure) + 1);
    ^~
mpc.c:680:11: error: request for member ‘failure’ in something not a structure or union
   strcpy(x->failure, failure);
           ^~
mpc.c:681:4: error: request for member ‘recieved’ in something not a structure or union
   x->recieved = ' ';
    ^~
mpc.c: At top level:
mpc.c:685:53: error: unknown type name ‘mpc_err_t’; did you mean ‘mpc_mem_t’?
 static void mpc_err_delete_internal(mpc_input_t *i, mpc_err_t *x) {
                                                     ^~~~~~~~~
                                                     mpc_mem_t
mpc.c:695:8: error: unknown type name ‘mpc_err_t’
 static mpc_err_t *mpc_err_export(mpc_input_t *i, mpc_err_t *x) {
        ^~~~~~~~~
mpc.c:695:50: error: unknown type name ‘mpc_err_t’; did you mean ‘mpc_mem_t’?
 static mpc_err_t *mpc_err_export(mpc_input_t *i, mpc_err_t *x) {
                                                  ^~~~~~~~~
                                                  mpc_mem_t
mpc.c:706:54: error: unknown type name ‘mpc_err_t’; did you mean ‘mpc_mem_t’?
 static int mpc_err_contains_expected(mpc_input_t *i, mpc_err_t *x, char *expected) {
                                                      ^~~~~~~~~
                                                      mpc_mem_t
mpc.c:715:50: error: unknown type name ‘mpc_err_t’; did you mean ‘mpc_mem_t’?
 static void mpc_err_add_expected(mpc_input_t *i, mpc_err_t *x, char *expected) {
                                                  ^~~~~~~~~
                                                  mpc_mem_t
mpc.c:723:8: error: unknown type name ‘mpc_err_t’
 static mpc_err_t *mpc_err_or(mpc_input_t *i, mpc_err_t** x, int n) {
        ^~~~~~~~~
mpc.c:723:46: error: unknown type name ‘mpc_err_t’; did you mean ‘mpc_mem_t’?
 static mpc_err_t *mpc_err_or(mpc_input_t *i, mpc_err_t** x, int n) {
                                              ^~~~~~~~~
                                              mpc_mem_t
mpc.c:775:8: error: unknown type name ‘mpc_err_t’
 static mpc_err_t *mpc_err_repeat(mpc_input_t *i, mpc_err_t *x, const char *prefix) {
        ^~~~~~~~~
mpc.c:775:50: error: unknown type name ‘mpc_err_t’; did you mean ‘mpc_mem_t’?
 static mpc_err_t *mpc_err_repeat(mpc_input_t *i, mpc_err_t *x, const char *prefix) {
                                                  ^~~~~~~~~
                                                  mpc_mem_t
mpc.c:831:8: error: unknown type name ‘mpc_err_t’
 static mpc_err_t *mpc_err_many1(mpc_input_t *i, mpc_err_t *x) {
        ^~~~~~~~~
mpc.c:831:49: error: unknown type name ‘mpc_err_t’; did you mean ‘mpc_mem_t’?
 static mpc_err_t *mpc_err_many1(mpc_input_t *i, mpc_err_t *x) {
                                                 ^~~~~~~~~
                                                 mpc_mem_t
mpc.c:835:8: error: unknown type name ‘mpc_err_t’
 static mpc_err_t *mpc_err_count(mpc_input_t *i, mpc_err_t *x, int n) {
        ^~~~~~~~~
mpc.c:835:49: error: unknown type name ‘mpc_err_t’; did you mean ‘mpc_mem_t’?
 static mpc_err_t *mpc_err_count(mpc_input_t *i, mpc_err_t *x, int n) {
                                                 ^~~~~~~~~
                                                 mpc_mem_t
mpc.c:846:8: error: unknown type name ‘mpc_err_t’
 static mpc_err_t *mpc_err_merge(mpc_input_t *i, mpc_err_t *x, mpc_err_t *y) {
        ^~~~~~~~~
mpc.c:846:49: error: unknown type name ‘mpc_err_t’; did you mean ‘mpc_mem_t’?
 static mpc_err_t *mpc_err_merge(mpc_input_t *i, mpc_err_t *x, mpc_err_t *y) {
                                                 ^~~~~~~~~
                                                 mpc_mem_t
mpc.c:846:63: error: unknown type name ‘mpc_err_t’; did you mean ‘mpc_mem_t’?
 static mpc_err_t *mpc_err_merge(mpc_input_t *i, mpc_err_t *x, mpc_err_t *y) {
                                                               ^~~~~~~~~
                                                               mpc_mem_t
mpc.c:892:18: error: unknown type name ‘mpc_ctor_t’
 typedef struct { mpc_ctor_t lf; void *x; } mpc_pdata_lift_t;
                  ^~~~~~~~~~
mpc.c:893:18: error: unknown type name ‘mpc_parser_t’
 typedef struct { mpc_parser_t *x; char *m; } mpc_pdata_expect_t;
                  ^~~~~~~~~~~~
mpc.c:899:18: error: unknown type name ‘mpc_parser_t’
 typedef struct { mpc_parser_t *x; mpc_apply_t f; } mpc_pdata_apply_t;
                  ^~~~~~~~~~~~
mpc.c:899:35: error: unknown type name ‘mpc_apply_t’
 typedef struct { mpc_parser_t *x; mpc_apply_t f; } mpc_pdata_apply_t;
                                   ^~~~~~~~~~~
mpc.c:900:18: error: unknown type name ‘mpc_parser_t’
 typedef struct { mpc_parser_t *x; mpc_apply_to_t f; void *d; } mpc_pdata_apply_to_t;
                  ^~~~~~~~~~~~
mpc.c:900:35: error: unknown type name ‘mpc_apply_to_t’
 typedef struct { mpc_parser_t *x; mpc_apply_to_t f; void *d; } mpc_pdata_apply_to_t;
                                   ^~~~~~~~~~~~~~
mpc.c:901:18: error: unknown type name ‘mpc_parser_t’
 typedef struct { mpc_parser_t *x; mpc_check_t f; char *e; } mpc_pdata_check_t;
                  ^~~~~~~~~~~~
mpc.c:901:35: error: unknown type name ‘mpc_check_t’
 typedef struct { mpc_parser_t *x; mpc_check_t f; char *e; } mpc_pdata_check_t;
                                   ^~~~~~~~~~~
mpc.c:902:18: error: unknown type name ‘mpc_parser_t’
 typedef struct { mpc_parser_t *x; mpc_check_with_t f; void *d; char *e; } mpc_pdata_check_with_t;
                  ^~~~~~~~~~~~
mpc.c:902:35: error: unknown type name ‘mpc_check_with_t’
 typedef struct { mpc_parser_t *x; mpc_check_with_t f; void *d; char *e; } mpc_pdata_check_with_t;
                                   ^~~~~~~~~~~~~~~~
mpc.c:903:18: error: unknown type name ‘mpc_parser_t’
 typedef struct { mpc_parser_t *x; } mpc_pdata_predict_t;
                  ^~~~~~~~~~~~
mpc.c:904:18: error: unknown type name ‘mpc_parser_t’
 typedef struct { mpc_parser_t *x; mpc_dtor_t dx; mpc_ctor_t lf; } mpc_pdata_not_t;
                  ^~~~~~~~~~~~
mpc.c:904:35: error: unknown type name ‘mpc_dtor_t’
 typedef struct { mpc_parser_t *x; mpc_dtor_t dx; mpc_ctor_t lf; } mpc_pdata_not_t;
                                   ^~~~~~~~~~
mpc.c:904:50: error: unknown type name ‘mpc_ctor_t’
 typedef struct { mpc_parser_t *x; mpc_dtor_t dx; mpc_ctor_t lf; } mpc_pdata_not_t;
                                                  ^~~~~~~~~~
mpc.c:905:25: error: unknown type name ‘mpc_fold_t’
 typedef struct { int n; mpc_fold_t f; mpc_parser_t *x; mpc_dtor_t dx; } mpc_pdata_repeat_t;
                         ^~~~~~~~~~
mpc.c:905:39: error: unknown type name ‘mpc_parser_t’
 typedef struct { int n; mpc_fold_t f; mpc_parser_t *x; mpc_dtor_t dx; } mpc_pdata_repeat_t;
                                       ^~~~~~~~~~~~
mpc.c:905:56: error: unknown type name ‘mpc_dtor_t’
 typedef struct { int n; mpc_fold_t f; mpc_parser_t *x; mpc_dtor_t dx; } mpc_pdata_repeat_t;
                                                        ^~~~~~~~~~
mpc.c:906:25: error: unknown type name ‘mpc_parser_t’
 typedef struct { int n; mpc_parser_t **xs; } mpc_pdata_or_t;
                         ^~~~~~~~~~~~
mpc.c:907:25: error: unknown type name ‘mpc_fold_t’
 typedef struct { int n; mpc_fold_t f; mpc_parser_t **xs; mpc_dtor_t *dxs;  } mpc_pdata_and_t;
                         ^~~~~~~~~~
mpc.c:907:39: error: unknown type name ‘mpc_parser_t’
 typedef struct { int n; mpc_fold_t f; mpc_parser_t **xs; mpc_dtor_t *dxs;  } mpc_pdata_and_t;
                                       ^~~~~~~~~~~~
mpc.c:907:58: error: unknown type name ‘mpc_dtor_t’
 typedef struct { int n; mpc_fold_t f; mpc_parser_t **xs; mpc_dtor_t *dxs;  } mpc_pdata_and_t;
                                                          ^~~~~~~~~~
mpc.c:936:8: error: unknown type name ‘mpc_val_t’
 static mpc_val_t *mpcf_input_nth_free(mpc_input_t *i, int n, mpc_val_t **xs, int x) {
        ^~~~~~~~~
mpc.c:936:62: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 static mpc_val_t *mpcf_input_nth_free(mpc_input_t *i, int n, mpc_val_t **xs, int x) {
                                                              ^~~~~~~~~
                                                              mpc_mem_t
mpc.c:942:8: error: unknown type name ‘mpc_val_t’
 static mpc_val_t *mpcf_input_fst_free(mpc_input_t *i, int n, mpc_val_t **xs) { return mpcf_input_nth_free(i, n, xs, 0); }
        ^~~~~~~~~
mpc.c:942:62: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 static mpc_val_t *mpcf_input_fst_free(mpc_input_t *i, int n, mpc_val_t **xs) { return mpcf_input_nth_free(i, n, xs, 0); }
                                                              ^~~~~~~~~
                                                              mpc_mem_t
mpc.c:943:8: error: unknown type name ‘mpc_val_t’
 static mpc_val_t *mpcf_input_snd_free(mpc_input_t *i, int n, mpc_val_t **xs) { return mpcf_input_nth_free(i, n, xs, 1); }
        ^~~~~~~~~
mpc.c:943:62: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 static mpc_val_t *mpcf_input_snd_free(mpc_input_t *i, int n, mpc_val_t **xs) { return mpcf_input_nth_free(i, n, xs, 1); }
                                                              ^~~~~~~~~
                                                              mpc_mem_t
mpc.c:944:8: error: unknown type name ‘mpc_val_t’
 static mpc_val_t *mpcf_input_trd_free(mpc_input_t *i, int n, mpc_val_t **xs) { return mpcf_input_nth_free(i, n, xs, 2); }
        ^~~~~~~~~
mpc.c:944:62: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 static mpc_val_t *mpcf_input_trd_free(mpc_input_t *i, int n, mpc_val_t **xs) { return mpcf_input_nth_free(i, n, xs, 2); }
                                                              ^~~~~~~~~
                                                              mpc_mem_t
mpc.c:946:8: error: unknown type name ‘mpc_val_t’
 static mpc_val_t *mpcf_input_strfold(mpc_input_t *i, int n, mpc_val_t **xs) {
        ^~~~~~~~~
mpc.c:946:61: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 static mpc_val_t *mpcf_input_strfold(mpc_input_t *i, int n, mpc_val_t **xs) {
                                                             ^~~~~~~~~
                                                             mpc_mem_t
mpc.c:956:8: error: unknown type name ‘mpc_val_t’
 static mpc_val_t *mpcf_input_state_ast(mpc_input_t *i, int n, mpc_val_t **xs) {
        ^~~~~~~~~
mpc.c:956:63: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 static mpc_val_t *mpcf_input_state_ast(mpc_input_t *i, int n, mpc_val_t **xs) {
                                                               ^~~~~~~~~
                                                               mpc_mem_t
mpc.c:965:8: error: unknown type name ‘mpc_val_t’
 static mpc_val_t *mpc_parse_fold(mpc_input_t *i, mpc_fold_t f, int n, mpc_val_t **xs) {
        ^~~~~~~~~
mpc.c:965:50: error: unknown type name ‘mpc_fold_t’; did you mean ‘mpc_rnd_t’?
 static mpc_val_t *mpc_parse_fold(mpc_input_t *i, mpc_fold_t f, int n, mpc_val_t **xs) {
                                                  ^~~~~~~~~~
                                                  mpc_rnd_t
mpc.c:965:71: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 static mpc_val_t *mpc_parse_fold(mpc_input_t *i, mpc_fold_t f, int n, mpc_val_t **xs) {
                                                                       ^~~~~~~~~
                                                                       mpc_mem_t
mpc.c:980:8: error: unknown type name ‘mpc_val_t’
 static mpc_val_t *mpcf_input_free(mpc_input_t *i, mpc_val_t *x) {
        ^~~~~~~~~
mpc.c:980:51: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 static mpc_val_t *mpcf_input_free(mpc_input_t *i, mpc_val_t *x) {
                                                   ^~~~~~~~~
                                                   mpc_mem_t
mpc.c:985:8: error: unknown type name ‘mpc_val_t’
 static mpc_val_t *mpcf_input_str_ast(mpc_input_t *i, mpc_val_t *c) {
        ^~~~~~~~~
mpc.c:985:54: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 static mpc_val_t *mpcf_input_str_ast(mpc_input_t *i, mpc_val_t *c) {
                                                      ^~~~~~~~~
                                                      mpc_mem_t
mpc.c:991:8: error: unknown type name ‘mpc_val_t’
 static mpc_val_t *mpc_parse_apply(mpc_input_t *i, mpc_apply_t f, mpc_val_t *x) {
        ^~~~~~~~~
mpc.c:991:51: error: unknown type name ‘mpc_apply_t’; did you mean ‘mpc_input_t’?
 static mpc_val_t *mpc_parse_apply(mpc_input_t *i, mpc_apply_t f, mpc_val_t *x) {
                                                   ^~~~~~~~~~~
                                                   mpc_input_t
mpc.c:991:66: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 static mpc_val_t *mpc_parse_apply(mpc_input_t *i, mpc_apply_t f, mpc_val_t *x) {
                                                                  ^~~~~~~~~
                                                                  mpc_mem_t
mpc.c:997:8: error: unknown type name ‘mpc_val_t’
 static mpc_val_t *mpc_parse_apply_to(mpc_input_t *i, mpc_apply_to_t f, mpc_val_t *x, mpc_val_t *d) {
        ^~~~~~~~~
mpc.c:997:54: error: unknown type name ‘mpc_apply_to_t’; did you mean ‘mpc_pdata_t’?
 static mpc_val_t *mpc_parse_apply_to(mpc_input_t *i, mpc_apply_to_t f, mpc_val_t *x, mpc_val_t *d) {
                                                      ^~~~~~~~~~~~~~
                                                      mpc_pdata_t
mpc.c:997:72: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 static mpc_val_t *mpc_parse_apply_to(mpc_input_t *i, mpc_apply_to_t f, mpc_val_t *x, mpc_val_t *d) {
                                                                        ^~~~~~~~~
                                                                        mpc_mem_t
mpc.c:997:86: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 static mpc_val_t *mpc_parse_apply_to(mpc_input_t *i, mpc_apply_to_t f, mpc_val_t *x, mpc_val_t *d) {
                                                                                      ^~~~~~~~~
                                                                                      mpc_mem_t
mpc.c:1001:44: error: unknown type name ‘mpc_dtor_t’; did you mean ‘mpc_pdata_t’?
 static void mpc_parse_dtor(mpc_input_t *i, mpc_dtor_t d, mpc_val_t *x) {
                                            ^~~~~~~~~~
                                            mpc_pdata_t
mpc.c:1001:58: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 static void mpc_parse_dtor(mpc_input_t *i, mpc_dtor_t d, mpc_val_t *x) {
                                                          ^~~~~~~~~
                                                          mpc_mem_t
mpc.c:1016:42: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 static int mpc_parse_run(mpc_input_t *i, mpc_parser_t *p, mpc_result_t *r, mpc_err_t **e) {
                                          ^~~~~~~~~~~~
                                          mp_prec_t
mpc.c:1016:59: error: unknown type name ‘mpc_result_t’; did you mean ‘mpc_input_t’?
 static int mpc_parse_run(mpc_input_t *i, mpc_parser_t *p, mpc_result_t *r, mpc_err_t **e) {
                                                           ^~~~~~~~~~~~
                                                           mpc_input_t
mpc.c:1016:76: error: unknown type name ‘mpc_err_t’; did you mean ‘mpc_mem_t’?
 static int mpc_parse_run(mpc_input_t *i, mpc_parser_t *p, mpc_result_t *r, mpc_err_t **e) {
                                                                            ^~~~~~~~~
                                                                            mpc_mem_t
mpc.c:1264:37: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 int mpc_parse_input(mpc_input_t *i, mpc_parser_t *p, mpc_result_t *r) {
                                     ^~~~~~~~~~~~
                                     mp_prec_t
mpc.c:1264:54: error: unknown type name ‘mpc_result_t’; did you mean ‘mpc_input_t’?
 int mpc_parse_input(mpc_input_t *i, mpc_parser_t *p, mpc_result_t *r) {
                                                      ^~~~~~~~~~~~
                                                      mpc_input_t
mpc.c:1278:57: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 int mpc_parse(const char *filename, const char *string, mpc_parser_t *p, mpc_result_t *r) {
                                                         ^~~~~~~~~~~~
                                                         mp_prec_t
mpc.c:1278:74: error: unknown type name ‘mpc_result_t’; did you mean ‘mpc_input_t’?
 int mpc_parse(const char *filename, const char *string, mpc_parser_t *p, mpc_result_t *r) {
                                                                          ^~~~~~~~~~~~
                                                                          mpc_input_t
mpc.c:1286:73: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 int mpc_nparse(const char *filename, const char *string, size_t length, mpc_parser_t *p, mpc_result_t *r) {
                                                                         ^~~~~~~~~~~~
                                                                         mp_prec_t
mpc.c:1286:90: error: unknown type name ‘mpc_result_t’; did you mean ‘mpc_input_t’?
 int mpc_nparse(const char *filename, const char *string, size_t length, mpc_parser_t *p, mpc_result_t *r) {
                                                                                          ^~~~~~~~~~~~
                                                                                          mpc_input_t
mpc.c:1294:42: error: unknown type name ‘FILE’
 int mpc_parse_file(const char *filename, FILE *file, mpc_parser_t *p, mpc_result_t *r) {
                                          ^~~~
mpc.c:1294:42: note: ‘FILE’ is defined in header ‘<stdio.h>’; did you forget to ‘#include <stdio.h>’?
mpc.c:1294:54: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 int mpc_parse_file(const char *filename, FILE *file, mpc_parser_t *p, mpc_result_t *r) {
                                                      ^~~~~~~~~~~~
                                                      mp_prec_t
mpc.c:1294:71: error: unknown type name ‘mpc_result_t’; did you mean ‘mpc_input_t’?
 int mpc_parse_file(const char *filename, FILE *file, mpc_parser_t *p, mpc_result_t *r) {
                                                                       ^~~~~~~~~~~~
                                                                       mpc_input_t
mpc.c:1302:42: error: unknown type name ‘FILE’
 int mpc_parse_pipe(const char *filename, FILE *pipe, mpc_parser_t *p, mpc_result_t *r) {
                                          ^~~~
mpc.c:1302:42: note: ‘FILE’ is defined in header ‘<stdio.h>’; did you forget to ‘#include <stdio.h>’?
mpc.c:1302:54: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 int mpc_parse_pipe(const char *filename, FILE *pipe, mpc_parser_t *p, mpc_result_t *r) {
                                                      ^~~~~~~~~~~~
                                                      mp_prec_t
mpc.c:1302:71: error: unknown type name ‘mpc_result_t’; did you mean ‘mpc_input_t’?
 int mpc_parse_pipe(const char *filename, FILE *pipe, mpc_parser_t *p, mpc_result_t *r) {
                                                                       ^~~~~~~~~~~~
                                                                       mpc_input_t
mpc.c:1310:46: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 int mpc_parse_contents(const char *filename, mpc_parser_t *p, mpc_result_t *r) {
                                              ^~~~~~~~~~~~
                                              mp_prec_t
mpc.c:1310:63: error: unknown type name ‘mpc_result_t’; did you mean ‘mpc_input_t’?
 int mpc_parse_contents(const char *filename, mpc_parser_t *p, mpc_result_t *r) {
                                                               ^~~~~~~~~~~~
                                                               mpc_input_t
mpc.c:1330:37: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 static void mpc_undefine_unretained(mpc_parser_t *p, int force);
                                     ^~~~~~~~~~~~
                                     mp_prec_t
mpc.c:1332:29: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 static void mpc_undefine_or(mpc_parser_t *p) {
                             ^~~~~~~~~~~~
                             mp_prec_t
mpc.c:1342:30: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 static void mpc_undefine_and(mpc_parser_t *p) {
                              ^~~~~~~~~~~~
                              mp_prec_t
mpc.c:1353:37: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 static void mpc_undefine_unretained(mpc_parser_t *p, int force) {
                                     ^~~~~~~~~~~~
                                     mp_prec_t
mpc.c:1410:17: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 void mpc_delete(mpc_parser_t *p) {
                 ^~~~~~~~~~~~
                 mp_prec_t
mpc.c:1425:29: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 static void mpc_soft_delete(mpc_val_t *x) {
                             ^~~~~~~~~
                             mpc_mem_t
mpc.c:1429:8: error: unknown type name ‘mpc_parser_t’
 static mpc_parser_t *mpc_undefined(void) {
        ^~~~~~~~~~~~
mpc.c: In function ‘mpc_undefined’:
mpc.c:1430:3: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
   mpc_parser_t *p = calloc(1, sizeof(mpc_parser_t));
   ^~~~~~~~~~~~
   struct 
mpc.c:1430:21: warning: incompatible implicit declaration of built-in function ‘calloc’
   mpc_parser_t *p = calloc(1, sizeof(mpc_parser_t));
                     ^~~~~~
mpc.c:1430:21: note: include ‘<stdlib.h>’ or provide a declaration of ‘calloc’
mpc.c:1430:38: error: ‘mpc_parser_t’ undeclared (first use in this function)
   mpc_parser_t *p = calloc(1, sizeof(mpc_parser_t));
                                      ^~~~~~~~~~~~
mpc.c:1431:4: error: request for member ‘retained’ in something not a structure or union
   p->retained = 0;
    ^~
mpc.c:1432:4: error: request for member ‘type’ in something not a structure or union
   p->type = MPC_TYPE_UNDEFINED;
    ^~
mpc.c:1433:4: error: request for member ‘name’ in something not a structure or union
   p->name = NULL;
    ^~
mpc.c: At top level:
mpc.c:1437:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_new(const char *name) {
 ^~~~~~~~~~~~
 struct 
mpc.c: In function ‘mpc_new’:
mpc.c:1438:3: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
   mpc_parser_t *p = mpc_undefined();
   ^~~~~~~~~~~~
   struct 
mpc.c:1439:4: error: request for member ‘retained’ in something not a structure or union
   p->retained = 1;
    ^~
mpc.c:1440:4: error: request for member ‘name’ in something not a structure or union
   p->name = realloc(p->name, strlen(name) + 1);
    ^~
mpc.c:1440:13: warning: incompatible implicit declaration of built-in function ‘realloc’
   p->name = realloc(p->name, strlen(name) + 1);
             ^~~~~~~
mpc.c:1440:13: note: include ‘<stdlib.h>’ or provide a declaration of ‘realloc’
mpc.c:1440:22: error: request for member ‘name’ in something not a structure or union
   p->name = realloc(p->name, strlen(name) + 1);
                      ^~
mpc.c:1440:30: warning: incompatible implicit declaration of built-in function ‘strlen’
   p->name = realloc(p->name, strlen(name) + 1);
                              ^~~~~~
mpc.c:1440:30: note: include ‘<string.h>’ or provide a declaration of ‘strlen’
mpc.c:1441:3: warning: incompatible implicit declaration of built-in function ‘strcpy’
   strcpy(p->name, name);
   ^~~~~~
mpc.c:1441:3: note: include ‘<string.h>’ or provide a declaration of ‘strcpy’
mpc.c:1441:11: error: request for member ‘name’ in something not a structure or union
   strcpy(p->name, name);
           ^~
mpc.c: At top level:
mpc.c:1445:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_copy(mpc_parser_t *a) {
 ^~~~~~~~~~~~
 struct 
mpc.c:1445:24: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 mpc_parser_t *mpc_copy(mpc_parser_t *a) {
                        ^~~~~~~~~~~~
                        mp_prec_t
mpc.c:1531:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_undefine(mpc_parser_t *p) {
 ^~~~~~~~~~~~
 struct 
mpc.c:1531:28: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 mpc_parser_t *mpc_undefine(mpc_parser_t *p) {
                            ^~~~~~~~~~~~
                            mp_prec_t
mpc.c:1537:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_define(mpc_parser_t *p, mpc_parser_t *a) {
 ^~~~~~~~~~~~
 struct 
mpc.c:1537:26: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 mpc_parser_t *mpc_define(mpc_parser_t *p, mpc_parser_t *a) {
                          ^~~~~~~~~~~~
                          mp_prec_t
mpc.c:1537:43: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 mpc_parser_t *mpc_define(mpc_parser_t *p, mpc_parser_t *a) {
                                           ^~~~~~~~~~~~
                                           mp_prec_t
mpc.c: In function ‘mpc_cleanup’:
mpc.c:1555:3: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
   mpc_parser_t **list = malloc(sizeof(mpc_parser_t*) * n);
   ^~~~~~~~~~~~
   struct 
mpc.c:1555:25: warning: incompatible implicit declaration of built-in function ‘malloc’
   mpc_parser_t **list = malloc(sizeof(mpc_parser_t*) * n);
                         ^~~~~~
mpc.c:1555:25: note: include ‘<stdlib.h>’ or provide a declaration of ‘malloc’
mpc.c:1555:39: error: ‘mpc_parser_t’ undeclared (first use in this function)
   mpc_parser_t **list = malloc(sizeof(mpc_parser_t*) * n);
                                       ^~~~~~~~~~~~
mpc.c:1555:52: error: expected expression before ‘)’ token
   mpc_parser_t **list = malloc(sizeof(mpc_parser_t*) * n);
                                                    ^
mpc.c:1557:3: error: unknown type name ‘va_list’
   va_list va;
   ^~~~~~~
mpc.c:1557:3: note: ‘va_list’ is defined in header ‘<stdarg.h>’; did you forget to ‘#include <stdarg.h>’?
mpc.c:1559:39: warning: implicit declaration of function ‘va_arg’; did you mean ‘mpc_arg’? [-Wimplicit-function-declaration]
   for (i = 0; i < n; i++) { list[i] = va_arg(va, mpc_parser_t*); }
                                       ^~~~~~
                                       mpc_arg
mpc.c:1559:63: error: expected expression before ‘)’ token
   for (i = 0; i < n; i++) { list[i] = va_arg(va, mpc_parser_t*); }
                                                               ^
mpc.c:1560:29: warning: implicit declaration of function ‘mpc_undefine’; did you mean ‘mpc_undefined’? [-Wimplicit-function-declaration]
   for (i = 0; i < n; i++) { mpc_undefine(list[i]); }
                             ^~~~~~~~~~~~
                             mpc_undefined
mpc.c:1561:29: warning: implicit declaration of function ‘mpc_delete’; did you mean ‘mpc_free’? [-Wimplicit-function-declaration]
   for (i = 0; i < n; i++) { mpc_delete(list[i]); }
                             ^~~~~~~~~~
                             mpc_free
mpc.c:1564:3: warning: incompatible implicit declaration of built-in function ‘free’
   free(list);
   ^~~~
mpc.c:1564:3: note: include ‘<stdlib.h>’ or provide a declaration of ‘free’
mpc.c: At top level:
mpc.c:1567:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_pass(void) {
 ^~~~~~~~~~~~
 struct 
mpc.c: In function ‘mpc_pass’:
mpc.c:1568:3: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
   mpc_parser_t *p = mpc_undefined();
   ^~~~~~~~~~~~
   struct 
mpc.c:1569:4: error: request for member ‘type’ in something not a structure or union
   p->type = MPC_TYPE_PASS;
    ^~
mpc.c: At top level:
mpc.c:1573:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_fail(const char *m) {
 ^~~~~~~~~~~~
 struct 
mpc.c: In function ‘mpc_fail’:
mpc.c:1574:3: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
   mpc_parser_t *p = mpc_undefined();
   ^~~~~~~~~~~~
   struct 
mpc.c:1575:4: error: request for member ‘type’ in something not a structure or union
   p->type = MPC_TYPE_FAIL;
    ^~
mpc.c:1576:4: error: request for member ‘data’ in something not a structure or union
   p->data.fail.m = malloc(strlen(m) + 1);
    ^~
mpc.c:1576:20: warning: incompatible implicit declaration of built-in function ‘malloc’
   p->data.fail.m = malloc(strlen(m) + 1);
                    ^~~~~~
mpc.c:1576:20: note: include ‘<stdlib.h>’ or provide a declaration of ‘malloc’
mpc.c:1576:27: warning: incompatible implicit declaration of built-in function ‘strlen’
   p->data.fail.m = malloc(strlen(m) + 1);
                           ^~~~~~
mpc.c:1576:27: note: include ‘<string.h>’ or provide a declaration of ‘strlen’
mpc.c:1577:3: warning: incompatible implicit declaration of built-in function ‘strcpy’
   strcpy(p->data.fail.m, m);
   ^~~~~~
mpc.c:1577:3: note: include ‘<string.h>’ or provide a declaration of ‘strcpy’
mpc.c:1577:11: error: request for member ‘data’ in something not a structure or union
   strcpy(p->data.fail.m, m);
           ^~
mpc.c: At top level:
mpc.c:1601:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_failf(const char *fmt, ...) {
 ^~~~~~~~~~~~
 struct 
mpc.c: In function ‘mpc_failf’:
mpc.c:1603:3: error: unknown type name ‘va_list’
   va_list va;
   ^~~~~~~
mpc.c:1603:3: note: ‘va_list’ is defined in header ‘<stdarg.h>’; did you forget to ‘#include <stdarg.h>’?
mpc.c:1606:3: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
   mpc_parser_t *p = mpc_undefined();
   ^~~~~~~~~~~~
   struct 
mpc.c:1607:4: error: request for member ‘type’ in something not a structure or union
   p->type = MPC_TYPE_FAIL;
    ^~
mpc.c:1610:12: warning: incompatible implicit declaration of built-in function ‘malloc’
   buffer = malloc(2048);
            ^~~~~~
mpc.c:1610:12: note: include ‘<stdlib.h>’ or provide a declaration of ‘malloc’
mpc.c:1614:12: warning: incompatible implicit declaration of built-in function ‘realloc’
   buffer = realloc(buffer, strlen(buffer) + 1);
            ^~~~~~~
mpc.c:1614:12: note: include ‘<stdlib.h>’ or provide a declaration of ‘realloc’
mpc.c:1614:28: warning: incompatible implicit declaration of built-in function ‘strlen’
   buffer = realloc(buffer, strlen(buffer) + 1);
                            ^~~~~~
mpc.c:1614:28: note: include ‘<string.h>’ or provide a declaration of ‘strlen’
mpc.c:1615:4: error: request for member ‘data’ in something not a structure or union
   p->data.fail.m = buffer;
    ^~
mpc.c: At top level:
mpc.c:1620:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_lift_val(mpc_val_t *x) {
 ^~~~~~~~~~~~
 struct 
mpc.c:1620:28: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_parser_t *mpc_lift_val(mpc_val_t *x) {
                            ^~~~~~~~~
                            mpc_mem_t
mpc.c:1627:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_lift(mpc_ctor_t lf) {
 ^~~~~~~~~~~~
 struct 
mpc.c:1627:24: error: unknown type name ‘mpc_ctor_t’; did you mean ‘mpc_mem_t’?
 mpc_parser_t *mpc_lift(mpc_ctor_t lf) {
                        ^~~~~~~~~~
                        mpc_mem_t
mpc.c:1634:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_anchor(int(*f)(char,char)) {
 ^~~~~~~~~~~~
 struct 
mpc.c: In function ‘mpc_anchor’:
mpc.c:1635:3: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
   mpc_parser_t *p = mpc_undefined();
   ^~~~~~~~~~~~
   struct 
mpc.c:1636:4: error: request for member ‘type’ in something not a structure or union
   p->type = MPC_TYPE_ANCHOR;
    ^~
mpc.c:1637:4: error: request for member ‘data’ in something not a structure or union
   p->data.anchor.f = f;
    ^~
mpc.c:1638:10: warning: implicit declaration of function ‘mpc_expect’; did you mean ‘mpc_export’? [-Wimplicit-function-declaration]
   return mpc_expect(p, "anchor");
          ^~~~~~~~~~
          mpc_export
mpc.c:1638:10: warning: returning ‘int’ from a function with return type ‘int *’ makes pointer from integer without a cast [-Wint-conversion]
   return mpc_expect(p, "anchor");
          ^~~~~~~~~~~~~~~~~~~~~~~
mpc.c: At top level:
mpc.c:1641:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_state(void) {
 ^~~~~~~~~~~~
 struct 
mpc.c: In function ‘mpc_state’:
mpc.c:1642:3: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
   mpc_parser_t *p = mpc_undefined();
   ^~~~~~~~~~~~
   struct 
mpc.c:1643:4: error: request for member ‘type’ in something not a structure or union
   p->type = MPC_TYPE_STATE;
    ^~
mpc.c: At top level:
mpc.c:1647:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_expect(mpc_parser_t *a, const char *expected) {
 ^~~~~~~~~~~~
 struct 
mpc.c:1647:26: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 mpc_parser_t *mpc_expect(mpc_parser_t *a, const char *expected) {
                          ^~~~~~~~~~~~
                          mp_prec_t
mpc.c:1676:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_expectf(mpc_parser_t *a, const char *fmt, ...) {
 ^~~~~~~~~~~~
 struct 
mpc.c:1676:27: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 mpc_parser_t *mpc_expectf(mpc_parser_t *a, const char *fmt, ...) {
                           ^~~~~~~~~~~~
                           mp_prec_t
mpc.c:1698:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_any(void) {
 ^~~~~~~~~~~~
 struct 
mpc.c: In function ‘mpc_any’:
mpc.c:1699:3: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
   mpc_parser_t *p = mpc_undefined();
   ^~~~~~~~~~~~
   struct 
mpc.c:1700:4: error: request for member ‘type’ in something not a structure or union
   p->type = MPC_TYPE_ANY;
    ^~
mpc.c:1701:10: warning: returning ‘int’ from a function with return type ‘int *’ makes pointer from integer without a cast [-Wint-conversion]
   return mpc_expect(p, "any character");
          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
mpc.c: At top level:
mpc.c:1704:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_char(char c) {
 ^~~~~~~~~~~~
 struct 
mpc.c: In function ‘mpc_char’:
mpc.c:1705:3: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
   mpc_parser_t *p = mpc_undefined();
   ^~~~~~~~~~~~
   struct 
mpc.c:1706:4: error: request for member ‘type’ in something not a structure or union
   p->type = MPC_TYPE_SINGLE;
    ^~
mpc.c:1707:4: error: request for member ‘data’ in something not a structure or union
   p->data.single.x = c;
    ^~
mpc.c:1708:10: warning: implicit declaration of function ‘mpc_expectf’; did you mean ‘mpc_export’? [-Wimplicit-function-declaration]
   return mpc_expectf(p, "'%c'", c);
          ^~~~~~~~~~~
          mpc_export
mpc.c:1708:10: warning: returning ‘int’ from a function with return type ‘int *’ makes pointer from integer without a cast [-Wint-conversion]
   return mpc_expectf(p, "'%c'", c);
          ^~~~~~~~~~~~~~~~~~~~~~~~~
mpc.c: At top level:
mpc.c:1711:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_range(char s, char e) {
 ^~~~~~~~~~~~
 struct 
mpc.c: In function ‘mpc_range’:
mpc.c:1712:3: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
   mpc_parser_t *p = mpc_undefined();
   ^~~~~~~~~~~~
   struct 
mpc.c:1713:4: error: request for member ‘type’ in something not a structure or union
   p->type = MPC_TYPE_RANGE;
    ^~
mpc.c:1714:4: error: request for member ‘data’ in something not a structure or union
   p->data.range.x = s;
    ^~
mpc.c:1715:4: error: request for member ‘data’ in something not a structure or union
   p->data.range.y = e;
    ^~
mpc.c:1716:10: warning: returning ‘int’ from a function with return type ‘int *’ makes pointer from integer without a cast [-Wint-conversion]
   return mpc_expectf(p, "character between '%c' and '%c'", s, e);
          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
mpc.c: At top level:
mpc.c:1719:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_oneof(const char *s) {
 ^~~~~~~~~~~~
 struct 
mpc.c: In function ‘mpc_oneof’:
mpc.c:1720:3: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
   mpc_parser_t *p = mpc_undefined();
   ^~~~~~~~~~~~
   struct 
mpc.c:1721:4: error: request for member ‘type’ in something not a structure or union
   p->type = MPC_TYPE_ONEOF;
    ^~
mpc.c:1722:4: error: request for member ‘data’ in something not a structure or union
   p->data.string.x = malloc(strlen(s) + 1);
    ^~
mpc.c:1722:22: warning: incompatible implicit declaration of built-in function ‘malloc’
   p->data.string.x = malloc(strlen(s) + 1);
                      ^~~~~~
mpc.c:1722:22: note: include ‘<stdlib.h>’ or provide a declaration of ‘malloc’
mpc.c:1722:29: warning: incompatible implicit declaration of built-in function ‘strlen’
   p->data.string.x = malloc(strlen(s) + 1);
                             ^~~~~~
mpc.c:1722:29: note: include ‘<string.h>’ or provide a declaration of ‘strlen’
mpc.c:1723:3: warning: incompatible implicit declaration of built-in function ‘strcpy’
   strcpy(p->data.string.x, s);
   ^~~~~~
mpc.c:1723:3: note: include ‘<string.h>’ or provide a declaration of ‘strcpy’
mpc.c:1723:11: error: request for member ‘data’ in something not a structure or union
   strcpy(p->data.string.x, s);
           ^~
mpc.c:1724:10: warning: returning ‘int’ from a function with return type ‘int *’ makes pointer from integer without a cast [-Wint-conversion]
   return mpc_expectf(p, "one of '%s'", s);
          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
mpc.c: At top level:
mpc.c:1727:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_noneof(const char *s) {
 ^~~~~~~~~~~~
 struct 
mpc.c: In function ‘mpc_noneof’:
mpc.c:1728:3: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
   mpc_parser_t *p = mpc_undefined();
   ^~~~~~~~~~~~
   struct 
mpc.c:1729:4: error: request for member ‘type’ in something not a structure or union
   p->type = MPC_TYPE_NONEOF;
    ^~
mpc.c:1730:4: error: request for member ‘data’ in something not a structure or union
   p->data.string.x = malloc(strlen(s) + 1);
    ^~
mpc.c:1730:22: warning: incompatible implicit declaration of built-in function ‘malloc’
   p->data.string.x = malloc(strlen(s) + 1);
                      ^~~~~~
mpc.c:1730:22: note: include ‘<stdlib.h>’ or provide a declaration of ‘malloc’
mpc.c:1730:29: warning: incompatible implicit declaration of built-in function ‘strlen’
   p->data.string.x = malloc(strlen(s) + 1);
                             ^~~~~~
mpc.c:1730:29: note: include ‘<string.h>’ or provide a declaration of ‘strlen’
mpc.c:1731:3: warning: incompatible implicit declaration of built-in function ‘strcpy’
   strcpy(p->data.string.x, s);
   ^~~~~~
mpc.c:1731:3: note: include ‘<string.h>’ or provide a declaration of ‘strcpy’
mpc.c:1731:11: error: request for member ‘data’ in something not a structure or union
   strcpy(p->data.string.x, s);
           ^~
mpc.c:1732:10: warning: returning ‘int’ from a function with return type ‘int *’ makes pointer from integer without a cast [-Wint-conversion]
   return mpc_expectf(p, "none of '%s'", s);
          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
mpc.c: At top level:
mpc.c:1736:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_satisfy(int(*f)(char)) {
 ^~~~~~~~~~~~
 struct 
mpc.c: In function ‘mpc_satisfy’:
mpc.c:1737:3: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
   mpc_parser_t *p = mpc_undefined();
   ^~~~~~~~~~~~
   struct 
mpc.c:1738:4: error: request for member ‘type’ in something not a structure or union
   p->type = MPC_TYPE_SATISFY;
    ^~
mpc.c:1739:4: error: request for member ‘data’ in something not a structure or union
   p->data.satisfy.f = f;
    ^~
mpc.c:1740:10: warning: returning ‘int’ from a function with return type ‘int *’ makes pointer from integer without a cast [-Wint-conversion]
   return mpc_expectf(p, "character satisfying function %p", f);
          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
mpc.c: At top level:
mpc.c:1743:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_string(const char *s) {
 ^~~~~~~~~~~~
 struct 
mpc.c: In function ‘mpc_string’:
mpc.c:1744:3: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
   mpc_parser_t *p = mpc_undefined();
   ^~~~~~~~~~~~
   struct 
mpc.c:1745:4: error: request for member ‘type’ in something not a structure or union
   p->type = MPC_TYPE_STRING;
    ^~
mpc.c:1746:4: error: request for member ‘data’ in something not a structure or union
   p->data.string.x = malloc(strlen(s) + 1);
    ^~
mpc.c:1746:22: warning: incompatible implicit declaration of built-in function ‘malloc’
   p->data.string.x = malloc(strlen(s) + 1);
                      ^~~~~~
mpc.c:1746:22: note: include ‘<stdlib.h>’ or provide a declaration of ‘malloc’
mpc.c:1746:29: warning: incompatible implicit declaration of built-in function ‘strlen’
   p->data.string.x = malloc(strlen(s) + 1);
                             ^~~~~~
mpc.c:1746:29: note: include ‘<string.h>’ or provide a declaration of ‘strlen’
mpc.c:1747:3: warning: incompatible implicit declaration of built-in function ‘strcpy’
   strcpy(p->data.string.x, s);
   ^~~~~~
mpc.c:1747:3: note: include ‘<string.h>’ or provide a declaration of ‘strcpy’
mpc.c:1747:11: error: request for member ‘data’ in something not a structure or union
   strcpy(p->data.string.x, s);
           ^~
mpc.c:1748:10: warning: returning ‘int’ from a function with return type ‘int *’ makes pointer from integer without a cast [-Wint-conversion]
   return mpc_expectf(p, "\"%s\"", s);
          ^~~~~~~~~~~~~~~~~~~~~~~~~~~
mpc.c: At top level:
mpc.c:1755:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_apply(mpc_parser_t *a, mpc_apply_t f) {
 ^~~~~~~~~~~~
 struct 
mpc.c:1755:25: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 mpc_parser_t *mpc_apply(mpc_parser_t *a, mpc_apply_t f) {
                         ^~~~~~~~~~~~
                         mp_prec_t
mpc.c:1755:42: error: unknown type name ‘mpc_apply_t’; did you mean ‘mpc_input_t’?
 mpc_parser_t *mpc_apply(mpc_parser_t *a, mpc_apply_t f) {
                                          ^~~~~~~~~~~
                                          mpc_input_t
mpc.c:1763:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_apply_to(mpc_parser_t *a, mpc_apply_to_t f, void *x) {
 ^~~~~~~~~~~~
 struct 
mpc.c:1763:28: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 mpc_parser_t *mpc_apply_to(mpc_parser_t *a, mpc_apply_to_t f, void *x) {
                            ^~~~~~~~~~~~
                            mp_prec_t
mpc.c:1763:45: error: unknown type name ‘mpc_apply_to_t’; did you mean ‘mpc_pdata_t’?
 mpc_parser_t *mpc_apply_to(mpc_parser_t *a, mpc_apply_to_t f, void *x) {
                                             ^~~~~~~~~~~~~~
                                             mpc_pdata_t
mpc.c:1772:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_check(mpc_parser_t *a, mpc_check_t f, const char *e) {
 ^~~~~~~~~~~~
 struct 
mpc.c:1772:25: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 mpc_parser_t *mpc_check(mpc_parser_t *a, mpc_check_t f, const char *e) {
                         ^~~~~~~~~~~~
                         mp_prec_t
mpc.c:1772:42: error: unknown type name ‘mpc_check_t’; did you mean ‘mpc_mem_t’?
 mpc_parser_t *mpc_check(mpc_parser_t *a, mpc_check_t f, const char *e) {
                                          ^~~~~~~~~~~
                                          mpc_mem_t
mpc.c:1782:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_check_with(mpc_parser_t *a, mpc_check_with_t f, void *x, const char *e) {
 ^~~~~~~~~~~~
 struct 
mpc.c:1782:30: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 mpc_parser_t *mpc_check_with(mpc_parser_t *a, mpc_check_with_t f, void *x, const char *e) {
                              ^~~~~~~~~~~~
                              mp_prec_t
mpc.c:1782:47: error: unknown type name ‘mpc_check_with_t’; did you mean ‘mpc_pdata_check_with_t’?
 mpc_parser_t *mpc_check_with(mpc_parser_t *a, mpc_check_with_t f, void *x, const char *e) {
                                               ^~~~~~~~~~~~~~~~
                                               mpc_pdata_check_with_t
mpc.c:1793:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_checkf(mpc_parser_t *a, mpc_check_t f, const char *fmt, ...) {
 ^~~~~~~~~~~~
 struct 
mpc.c:1793:26: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 mpc_parser_t *mpc_checkf(mpc_parser_t *a, mpc_check_t f, const char *fmt, ...) {
                          ^~~~~~~~~~~~
                          mp_prec_t
mpc.c:1793:43: error: unknown type name ‘mpc_check_t’; did you mean ‘mpc_mem_t’?
 mpc_parser_t *mpc_checkf(mpc_parser_t *a, mpc_check_t f, const char *fmt, ...) {
                                           ^~~~~~~~~~~
                                           mpc_mem_t
mpc.c:1809:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_check_withf(mpc_parser_t *a, mpc_check_with_t f, void *x, const char *fmt, ...) {
 ^~~~~~~~~~~~
 struct 
mpc.c:1809:31: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 mpc_parser_t *mpc_check_withf(mpc_parser_t *a, mpc_check_with_t f, void *x, const char *fmt, ...) {
                               ^~~~~~~~~~~~
                               mp_prec_t
mpc.c:1809:48: error: unknown type name ‘mpc_check_with_t’; did you mean ‘mpc_pdata_check_with_t’?
 mpc_parser_t *mpc_check_withf(mpc_parser_t *a, mpc_check_with_t f, void *x, const char *fmt, ...) {
                                                ^~~~~~~~~~~~~~~~
                                                mpc_pdata_check_with_t
mpc.c:1825:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_predictive(mpc_parser_t *a) {
 ^~~~~~~~~~~~
 struct 
mpc.c:1825:30: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 mpc_parser_t *mpc_predictive(mpc_parser_t *a) {
                              ^~~~~~~~~~~~
                              mp_prec_t
mpc.c:1832:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_not_lift(mpc_parser_t *a, mpc_dtor_t da, mpc_ctor_t lf) {
 ^~~~~~~~~~~~
 struct 
mpc.c:1832:28: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 mpc_parser_t *mpc_not_lift(mpc_parser_t *a, mpc_dtor_t da, mpc_ctor_t lf) {
                            ^~~~~~~~~~~~
                            mp_prec_t
mpc.c:1832:45: error: unknown type name ‘mpc_dtor_t’; did you mean ‘mpc_pdata_t’?
 mpc_parser_t *mpc_not_lift(mpc_parser_t *a, mpc_dtor_t da, mpc_ctor_t lf) {
                                             ^~~~~~~~~~
                                             mpc_pdata_t
mpc.c:1832:60: error: unknown type name ‘mpc_ctor_t’; did you mean ‘mpc_mem_t’?
 mpc_parser_t *mpc_not_lift(mpc_parser_t *a, mpc_dtor_t da, mpc_ctor_t lf) {
                                                            ^~~~~~~~~~
                                                            mpc_mem_t
mpc.c:1841:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_not(mpc_parser_t *a, mpc_dtor_t da) {
 ^~~~~~~~~~~~
 struct 
mpc.c:1841:23: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 mpc_parser_t *mpc_not(mpc_parser_t *a, mpc_dtor_t da) {
                       ^~~~~~~~~~~~
                       mp_prec_t
mpc.c:1841:40: error: unknown type name ‘mpc_dtor_t’; did you mean ‘mpc_pdata_t’?
 mpc_parser_t *mpc_not(mpc_parser_t *a, mpc_dtor_t da) {
                                        ^~~~~~~~~~
                                        mpc_pdata_t
mpc.c:1845:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_maybe_lift(mpc_parser_t *a, mpc_ctor_t lf) {
 ^~~~~~~~~~~~
 struct 
mpc.c:1845:30: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 mpc_parser_t *mpc_maybe_lift(mpc_parser_t *a, mpc_ctor_t lf) {
                              ^~~~~~~~~~~~
                              mp_prec_t
mpc.c:1845:47: error: unknown type name ‘mpc_ctor_t’; did you mean ‘mpc_mem_t’?
 mpc_parser_t *mpc_maybe_lift(mpc_parser_t *a, mpc_ctor_t lf) {
                                               ^~~~~~~~~~
                                               mpc_mem_t
mpc.c:1853:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_maybe(mpc_parser_t *a) {
 ^~~~~~~~~~~~
 struct 
mpc.c:1853:25: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 mpc_parser_t *mpc_maybe(mpc_parser_t *a) {
                         ^~~~~~~~~~~~
                         mp_prec_t
mpc.c:1857:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_many(mpc_fold_t f, mpc_parser_t *a) {
 ^~~~~~~~~~~~
 struct 
mpc.c:1857:24: error: unknown type name ‘mpc_fold_t’; did you mean ‘mpc_rnd_t’?
 mpc_parser_t *mpc_many(mpc_fold_t f, mpc_parser_t *a) {
                        ^~~~~~~~~~
                        mpc_rnd_t
mpc.c:1857:38: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 mpc_parser_t *mpc_many(mpc_fold_t f, mpc_parser_t *a) {
                                      ^~~~~~~~~~~~
                                      mp_prec_t
mpc.c:1865:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_many1(mpc_fold_t f, mpc_parser_t *a) {
 ^~~~~~~~~~~~
 struct 
mpc.c:1865:25: error: unknown type name ‘mpc_fold_t’; did you mean ‘mpc_rnd_t’?
 mpc_parser_t *mpc_many1(mpc_fold_t f, mpc_parser_t *a) {
                         ^~~~~~~~~~
                         mpc_rnd_t
mpc.c:1865:39: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 mpc_parser_t *mpc_many1(mpc_fold_t f, mpc_parser_t *a) {
                                       ^~~~~~~~~~~~
                                       mp_prec_t
mpc.c:1873:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_count(int n, mpc_fold_t f, mpc_parser_t *a, mpc_dtor_t da) {
 ^~~~~~~~~~~~
 struct 
mpc.c:1873:32: error: unknown type name ‘mpc_fold_t’; did you mean ‘mpc_rnd_t’?
 mpc_parser_t *mpc_count(int n, mpc_fold_t f, mpc_parser_t *a, mpc_dtor_t da) {
                                ^~~~~~~~~~
                                mpc_rnd_t
mpc.c:1873:46: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 mpc_parser_t *mpc_count(int n, mpc_fold_t f, mpc_parser_t *a, mpc_dtor_t da) {
                                              ^~~~~~~~~~~~
                                              mp_prec_t
mpc.c:1873:63: error: unknown type name ‘mpc_dtor_t’; did you mean ‘mpc_pdata_t’?
 mpc_parser_t *mpc_count(int n, mpc_fold_t f, mpc_parser_t *a, mpc_dtor_t da) {
                                                               ^~~~~~~~~~
                                                               mpc_pdata_t
mpc.c:1883:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_or(int n, ...) {
 ^~~~~~~~~~~~
 struct 
mpc.c: In function ‘mpc_or’:
mpc.c:1886:3: error: unknown type name ‘va_list’
   va_list va;
   ^~~~~~~
mpc.c:1886:3: note: ‘va_list’ is defined in header ‘<stdarg.h>’; did you forget to ‘#include <stdarg.h>’?
mpc.c:1888:3: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
   mpc_parser_t *p = mpc_undefined();
   ^~~~~~~~~~~~
   struct 
mpc.c:1890:4: error: request for member ‘type’ in something not a structure or union
   p->type = MPC_TYPE_OR;
    ^~
mpc.c:1891:4: error: request for member ‘data’ in something not a structure or union
   p->data.or.n = n;
    ^~
mpc.c:1892:4: error: request for member ‘data’ in something not a structure or union
   p->data.or.xs = malloc(sizeof(mpc_parser_t*) * n);
    ^~
mpc.c:1892:19: warning: incompatible implicit declaration of built-in function ‘malloc’
   p->data.or.xs = malloc(sizeof(mpc_parser_t*) * n);
                   ^~~~~~
mpc.c:1892:19: note: include ‘<stdlib.h>’ or provide a declaration of ‘malloc’
mpc.c:1892:33: error: ‘mpc_parser_t’ undeclared (first use in this function)
   p->data.or.xs = malloc(sizeof(mpc_parser_t*) * n);
                                 ^~~~~~~~~~~~
mpc.c:1892:46: error: expected expression before ‘)’ token
   p->data.or.xs = malloc(sizeof(mpc_parser_t*) * n);
                                              ^
mpc.c:1896:6: error: request for member ‘data’ in something not a structure or union
     p->data.or.xs[i] = va_arg(va, mpc_parser_t*);
      ^~
mpc.c:1896:48: error: expected expression before ‘)’ token
     p->data.or.xs[i] = va_arg(va, mpc_parser_t*);
                                                ^
mpc.c: At top level:
mpc.c:1903:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_and(int n, mpc_fold_t f, ...) {
 ^~~~~~~~~~~~
 struct 
mpc.c:1903:30: error: unknown type name ‘mpc_fold_t’; did you mean ‘mpc_rnd_t’?
 mpc_parser_t *mpc_and(int n, mpc_fold_t f, ...) {
                              ^~~~~~~~~~
                              mpc_rnd_t
mpc.c:1935:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_soi(void) { return mpc_expect(mpc_anchor(mpc_soi_anchor), "start of input"); }
 ^~~~~~~~~~~~
 struct 
mpc.c: In function ‘mpc_soi’:
mpc.c:1935:38: warning: returning ‘int’ from a function with return type ‘int *’ makes pointer from integer without a cast [-Wint-conversion]
 mpc_parser_t *mpc_soi(void) { return mpc_expect(mpc_anchor(mpc_soi_anchor), "start of input"); }
                                      ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
mpc.c: At top level:
mpc.c:1936:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_eoi(void) { return mpc_expect(mpc_anchor(mpc_eoi_anchor), "end of input"); }
 ^~~~~~~~~~~~
 struct 
mpc.c: In function ‘mpc_eoi’:
mpc.c:1936:38: warning: returning ‘int’ from a function with return type ‘int *’ makes pointer from integer without a cast [-Wint-conversion]
 mpc_parser_t *mpc_eoi(void) { return mpc_expect(mpc_anchor(mpc_eoi_anchor), "end of input"); }
                                      ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
mpc.c: In function ‘mpc_boundary_anchor’:
mpc.c:1942:8: warning: incompatible implicit declaration of built-in function ‘strchr’
   if ( strchr(word, next) &&  prev == '\0') { return 1; }
        ^~~~~~
mpc.c:1942:8: note: include ‘<string.h>’ or provide a declaration of ‘strchr’
mpc.c:1943:8: warning: incompatible implicit declaration of built-in function ‘strchr’
   if ( strchr(word, prev) &&  next == '\0') { return 1; }
        ^~~~~~
mpc.c:1943:8: note: include ‘<string.h>’ or provide a declaration of ‘strchr’
mpc.c:1944:8: warning: incompatible implicit declaration of built-in function ‘strchr’
   if ( strchr(word, next) && !strchr(word, prev)) { return 1; }
        ^~~~~~
mpc.c:1944:8: note: include ‘<string.h>’ or provide a declaration of ‘strchr’
mpc.c:1945:8: warning: incompatible implicit declaration of built-in function ‘strchr’
   if (!strchr(word, next) &&  strchr(word, prev)) { return 1; }
        ^~~~~~
mpc.c:1945:8: note: include ‘<string.h>’ or provide a declaration of ‘strchr’
mpc.c: At top level:
mpc.c:1949:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_boundary(void) { return mpc_expect(mpc_anchor(mpc_boundary_anchor), "boundary"); }
 ^~~~~~~~~~~~
 struct 
mpc.c: In function ‘mpc_boundary’:
mpc.c:1949:43: warning: returning ‘int’ from a function with return type ‘int *’ makes pointer from integer without a cast [-Wint-conversion]
 mpc_parser_t *mpc_boundary(void) { return mpc_expect(mpc_anchor(mpc_boundary_anchor), "boundary"); }
                                           ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
mpc.c: At top level:
mpc.c:1951:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_whitespace(void) { return mpc_expect(mpc_oneof(" \f\n\r\t\v"), "whitespace"); }
 ^~~~~~~~~~~~
 struct 
mpc.c: In function ‘mpc_whitespace’:
mpc.c:1951:45: warning: returning ‘int’ from a function with return type ‘int *’ makes pointer from integer without a cast [-Wint-conversion]
 mpc_parser_t *mpc_whitespace(void) { return mpc_expect(mpc_oneof(" \f\n\r\t\v"), "whitespace"); }
                                             ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
mpc.c: At top level:
mpc.c:1952:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_whitespaces(void) { return mpc_expect(mpc_many(mpcf_strfold, mpc_whitespace()), "spaces"); }
 ^~~~~~~~~~~~
 struct 
mpc.c: In function ‘mpc_whitespaces’:
mpc.c:1952:57: warning: implicit declaration of function ‘mpc_many’; did you mean ‘mpc_any’? [-Wimplicit-function-declaration]
 mpc_parser_t *mpc_whitespaces(void) { return mpc_expect(mpc_many(mpcf_strfold, mpc_whitespace()), "spaces"); }
                                                         ^~~~~~~~
                                                         mpc_any
mpc.c:1952:66: error: ‘mpcf_strfold’ undeclared (first use in this function); did you mean ‘mpc_strtoc’?
 mpc_parser_t *mpc_whitespaces(void) { return mpc_expect(mpc_many(mpcf_strfold, mpc_whitespace()), "spaces"); }
                                                                  ^~~~~~~~~~~~
                                                                  mpc_strtoc
mpc.c: At top level:
mpc.c:1953:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_blank(void) { return mpc_expect(mpc_apply(mpc_whitespaces(), mpcf_free), "whitespace"); }
 ^~~~~~~~~~~~
 struct 
mpc.c: In function ‘mpc_blank’:
mpc.c:1953:51: warning: implicit declaration of function ‘mpc_apply’; did you mean ‘mpc_any’? [-Wimplicit-function-declaration]
 mpc_parser_t *mpc_blank(void) { return mpc_expect(mpc_apply(mpc_whitespaces(), mpcf_free), "whitespace"); }
                                                   ^~~~~~~~~
                                                   mpc_any
mpc.c:1953:80: error: ‘mpcf_free’ undeclared (first use in this function); did you mean ‘mpc_free’?
 mpc_parser_t *mpc_blank(void) { return mpc_expect(mpc_apply(mpc_whitespaces(), mpcf_free), "whitespace"); }
                                                                                ^~~~~~~~~
                                                                                mpc_free
mpc.c: At top level:
mpc.c:1955:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_newline(void) { return mpc_expect(mpc_char('\n'), "newline"); }
 ^~~~~~~~~~~~
 struct 
mpc.c: In function ‘mpc_newline’:
mpc.c:1955:42: warning: returning ‘int’ from a function with return type ‘int *’ makes pointer from integer without a cast [-Wint-conversion]
 mpc_parser_t *mpc_newline(void) { return mpc_expect(mpc_char('\n'), "newline"); }
                                          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
mpc.c: At top level:
mpc.c:1956:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_tab(void) { return mpc_expect(mpc_char('\t'), "tab"); }
 ^~~~~~~~~~~~
 struct 
mpc.c: In function ‘mpc_tab’:
mpc.c:1956:38: warning: returning ‘int’ from a function with return type ‘int *’ makes pointer from integer without a cast [-Wint-conversion]
 mpc_parser_t *mpc_tab(void) { return mpc_expect(mpc_char('\t'), "tab"); }
                                      ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
mpc.c: At top level:
mpc.c:1957:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_escape(void) { return mpc_and(2, mpcf_strfold, mpc_char('\\'), mpc_any(), free); }
 ^~~~~~~~~~~~
 struct 
mpc.c: In function ‘mpc_escape’:
mpc.c:1957:41: warning: implicit declaration of function ‘mpc_and’; did you mean ‘mpc_any’? [-Wimplicit-function-declaration]
 mpc_parser_t *mpc_escape(void) { return mpc_and(2, mpcf_strfold, mpc_char('\\'), mpc_any(), free); }
                                         ^~~~~~~
                                         mpc_any
mpc.c:1957:52: error: ‘mpcf_strfold’ undeclared (first use in this function); did you mean ‘mpc_strtoc’?
 mpc_parser_t *mpc_escape(void) { return mpc_and(2, mpcf_strfold, mpc_char('\\'), mpc_any(), free); }
                                                    ^~~~~~~~~~~~
                                                    mpc_strtoc
mpc.c:1957:93: error: ‘free’ undeclared (first use in this function)
 mpc_parser_t *mpc_escape(void) { return mpc_and(2, mpcf_strfold, mpc_char('\\'), mpc_any(), free); }
                                                                                             ^~~~
mpc.c:1957:93: note: ‘free’ is defined in header ‘<stdlib.h>’; did you forget to ‘#include <stdlib.h>’?
mpc.c: At top level:
mpc.c:1959:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_digit(void) { return mpc_expect(mpc_oneof("0123456789"), "digit"); }
 ^~~~~~~~~~~~
 struct 
mpc.c: In function ‘mpc_digit’:
mpc.c:1959:40: warning: returning ‘int’ from a function with return type ‘int *’ makes pointer from integer without a cast [-Wint-conversion]
 mpc_parser_t *mpc_digit(void) { return mpc_expect(mpc_oneof("0123456789"), "digit"); }
                                        ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
mpc.c: At top level:
mpc.c:1960:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_hexdigit(void) { return mpc_expect(mpc_oneof("0123456789ABCDEFabcdef"), "hex digit"); }
 ^~~~~~~~~~~~
 struct 
mpc.c: In function ‘mpc_hexdigit’:
mpc.c:1960:43: warning: returning ‘int’ from a function with return type ‘int *’ makes pointer from integer without a cast [-Wint-conversion]
 mpc_parser_t *mpc_hexdigit(void) { return mpc_expect(mpc_oneof("0123456789ABCDEFabcdef"), "hex digit"); }
                                           ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
mpc.c: At top level:
mpc.c:1961:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_octdigit(void) { return mpc_expect(mpc_oneof("01234567"), "oct digit"); }
 ^~~~~~~~~~~~
 struct 
mpc.c: In function ‘mpc_octdigit’:
mpc.c:1961:43: warning: returning ‘int’ from a function with return type ‘int *’ makes pointer from integer without a cast [-Wint-conversion]
 mpc_parser_t *mpc_octdigit(void) { return mpc_expect(mpc_oneof("01234567"), "oct digit"); }
                                           ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
mpc.c: At top level:
mpc.c:1962:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_digits(void) { return mpc_expect(mpc_many1(mpcf_strfold, mpc_digit()), "digits"); }
 ^~~~~~~~~~~~
 struct 
mpc.c: In function ‘mpc_digits’:
mpc.c:1962:52: warning: implicit declaration of function ‘mpc_many1’; did you mean ‘mpc_any’? [-Wimplicit-function-declaration]
 mpc_parser_t *mpc_digits(void) { return mpc_expect(mpc_many1(mpcf_strfold, mpc_digit()), "digits"); }
                                                    ^~~~~~~~~
                                                    mpc_any
mpc.c:1962:62: error: ‘mpcf_strfold’ undeclared (first use in this function); did you mean ‘mpc_strtoc’?
 mpc_parser_t *mpc_digits(void) { return mpc_expect(mpc_many1(mpcf_strfold, mpc_digit()), "digits"); }
                                                              ^~~~~~~~~~~~
                                                              mpc_strtoc
mpc.c: At top level:
mpc.c:1963:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_hexdigits(void) { return mpc_expect(mpc_many1(mpcf_strfold, mpc_hexdigit()), "hex digits"); }
 ^~~~~~~~~~~~
 struct 
mpc.c: In function ‘mpc_hexdigits’:
mpc.c:1963:65: error: ‘mpcf_strfold’ undeclared (first use in this function); did you mean ‘mpc_strtoc’?
 mpc_parser_t *mpc_hexdigits(void) { return mpc_expect(mpc_many1(mpcf_strfold, mpc_hexdigit()), "hex digits"); }
                                                                 ^~~~~~~~~~~~
                                                                 mpc_strtoc
mpc.c: At top level:
mpc.c:1964:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_octdigits(void) { return mpc_expect(mpc_many1(mpcf_strfold, mpc_octdigit()), "oct digits"); }
 ^~~~~~~~~~~~
 struct 
mpc.c: In function ‘mpc_octdigits’:
mpc.c:1964:65: error: ‘mpcf_strfold’ undeclared (first use in this function); did you mean ‘mpc_strtoc’?
 mpc_parser_t *mpc_octdigits(void) { return mpc_expect(mpc_many1(mpcf_strfold, mpc_octdigit()), "oct digits"); }
                                                                 ^~~~~~~~~~~~
                                                                 mpc_strtoc
mpc.c: At top level:
mpc.c:1966:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_lower(void) { return mpc_expect(mpc_oneof("abcdefghijklmnopqrstuvwxyz"), "lowercase letter"); }
 ^~~~~~~~~~~~
 struct 
mpc.c: In function ‘mpc_lower’:
mpc.c:1966:40: warning: returning ‘int’ from a function with return type ‘int *’ makes pointer from integer without a cast [-Wint-conversion]
 mpc_parser_t *mpc_lower(void) { return mpc_expect(mpc_oneof("abcdefghijklmnopqrstuvwxyz"), "lowercase letter"); }
                                        ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
mpc.c: At top level:
mpc.c:1967:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_upper(void) { return mpc_expect(mpc_oneof("ABCDEFGHIJKLMNOPQRSTUVWXYZ"), "uppercase letter"); }
 ^~~~~~~~~~~~
 struct 
mpc.c: In function ‘mpc_upper’:
mpc.c:1967:40: warning: returning ‘int’ from a function with return type ‘int *’ makes pointer from integer without a cast [-Wint-conversion]
 mpc_parser_t *mpc_upper(void) { return mpc_expect(mpc_oneof("ABCDEFGHIJKLMNOPQRSTUVWXYZ"), "uppercase letter"); }
                                        ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
mpc.c: At top level:
mpc.c:1968:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_alpha(void) { return mpc_expect(mpc_oneof("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"), "letter"); }
 ^~~~~~~~~~~~
 struct 
mpc.c: In function ‘mpc_alpha’:
mpc.c:1968:40: warning: returning ‘int’ from a function with return type ‘int *’ makes pointer from integer without a cast [-Wint-conversion]
 mpc_parser_t *mpc_alpha(void) { return mpc_expect(mpc_oneof("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"), "letter"); }
                                        ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
mpc.c: At top level:
mpc.c:1969:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_underscore(void) { return mpc_expect(mpc_char('_'), "underscore"); }
 ^~~~~~~~~~~~
 struct 
mpc.c: In function ‘mpc_underscore’:
mpc.c:1969:45: warning: returning ‘int’ from a function with return type ‘int *’ makes pointer from integer without a cast [-Wint-conversion]
 mpc_parser_t *mpc_underscore(void) { return mpc_expect(mpc_char('_'), "underscore"); }
                                             ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
mpc.c: At top level:
mpc.c:1970:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_alphanum(void) { return mpc_expect(mpc_or(3, mpc_alpha(), mpc_digit(), mpc_underscore()), "alphanumeric"); }
 ^~~~~~~~~~~~
 struct 
mpc.c: In function ‘mpc_alphanum’:
mpc.c:1970:43: warning: returning ‘int’ from a function with return type ‘int *’ makes pointer from integer without a cast [-Wint-conversion]
 mpc_parser_t *mpc_alphanum(void) { return mpc_expect(mpc_or(3, mpc_alpha(), mpc_digit(), mpc_underscore()), "alphanumeric"); }
                                           ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
mpc.c: At top level:
mpc.c:1972:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_int(void) { return mpc_expect(mpc_apply(mpc_digits(), mpcf_int), "integer"); }
 ^~~~~~~~~~~~
 struct 
mpc.c: In function ‘mpc_int’:
mpc.c:1972:73: error: ‘mpcf_int’ undeclared (first use in this function); did you mean ‘mpc_int’?
 mpc_parser_t *mpc_int(void) { return mpc_expect(mpc_apply(mpc_digits(), mpcf_int), "integer"); }
                                                                         ^~~~~~~~
                                                                         mpc_int
mpc.c: At top level:
mpc.c:1973:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_hex(void) { return mpc_expect(mpc_apply(mpc_hexdigits(), mpcf_hex), "hexadecimal"); }
 ^~~~~~~~~~~~
 struct 
mpc.c: In function ‘mpc_hex’:
mpc.c:1973:76: error: ‘mpcf_hex’ undeclared (first use in this function); did you mean ‘mpc_hex’?
 mpc_parser_t *mpc_hex(void) { return mpc_expect(mpc_apply(mpc_hexdigits(), mpcf_hex), "hexadecimal"); }
                                                                            ^~~~~~~~
                                                                            mpc_hex
mpc.c: At top level:
mpc.c:1974:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_oct(void) { return mpc_expect(mpc_apply(mpc_octdigits(), mpcf_oct), "octadecimal"); }
 ^~~~~~~~~~~~
 struct 
mpc.c: In function ‘mpc_oct’:
mpc.c:1974:76: error: ‘mpcf_oct’ undeclared (first use in this function); did you mean ‘mpc_oct’?
 mpc_parser_t *mpc_oct(void) { return mpc_expect(mpc_apply(mpc_octdigits(), mpcf_oct), "octadecimal"); }
                                                                            ^~~~~~~~
                                                                            mpc_oct
mpc.c: At top level:
mpc.c:1975:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_number(void) { return mpc_expect(mpc_or(3, mpc_int(), mpc_hex(), mpc_oct()), "number"); }
 ^~~~~~~~~~~~
 struct 
mpc.c: In function ‘mpc_number’:
mpc.c:1975:41: warning: returning ‘int’ from a function with return type ‘int *’ makes pointer from integer without a cast [-Wint-conversion]
 mpc_parser_t *mpc_number(void) { return mpc_expect(mpc_or(3, mpc_int(), mpc_hex(), mpc_oct()), "number"); }
                                         ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
mpc.c: At top level:
mpc.c:1977:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_real(void) {
 ^~~~~~~~~~~~
 struct 
mpc.c:1977:15: error: conflicting types for ‘mpc_real’
 mpc_parser_t *mpc_real(void) {
               ^~~~~~~~
In file included from mpc.c:1:
/usr/include/mpc.h:180:21: note: previous declaration of ‘mpc_real’ was here
 __MPC_DECLSPEC int  mpc_real        (mpfr_ptr, mpc_srcptr, mpfr_rnd_t);
                     ^~~~~~~~
mpc.c: In function ‘mpc_real’:
mpc.c:1981:3: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
   mpc_parser_t *p0, *p1, *p2, *p30, *p31, *p32, *p3;
   ^~~~~~~~~~~~
   struct 
mpc.c:1983:8: warning: implicit declaration of function ‘mpc_maybe_lift’; did you mean ‘mpc_newline’? [-Wimplicit-function-declaration]
   p0 = mpc_maybe_lift(mpc_oneof("+-"), mpcf_ctor_str);
        ^~~~~~~~~~~~~~
        mpc_newline
mpc.c:1983:40: error: ‘mpcf_ctor_str’ undeclared (first use in this function); did you mean ‘mpc_free_str’?
   p0 = mpc_maybe_lift(mpc_oneof("+-"), mpcf_ctor_str);
                                        ^~~~~~~~~~~~~
                                        mpc_free_str
mpc.c:1985:34: error: ‘mpcf_strfold’ undeclared (first use in this function); did you mean ‘mpc_strtoc’?
   p2 = mpc_maybe_lift(mpc_and(2, mpcf_strfold, mpc_char('.'), mpc_digits(), free), mpcf_ctor_str);
                                  ^~~~~~~~~~~~
                                  mpc_strtoc
mpc.c:1985:77: error: ‘free’ undeclared (first use in this function)
   p2 = mpc_maybe_lift(mpc_and(2, mpcf_strfold, mpc_char('.'), mpc_digits(), free), mpcf_ctor_str);
                                                                             ^~~~
mpc.c:1985:77: note: ‘free’ is defined in header ‘<stdlib.h>’; did you forget to ‘#include <stdlib.h>’?
mpc.c: At top level:
mpc.c:1995:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_float(void) {
 ^~~~~~~~~~~~
 struct 
mpc.c: In function ‘mpc_float’:
mpc.c:1996:43: error: ‘mpcf_float’ undeclared (first use in this function); did you mean ‘mpc_float’?
   return mpc_expect(mpc_apply(mpc_real(), mpcf_float), "float");
                                           ^~~~~~~~~~
                                           mpc_float
mpc.c: At top level:
mpc.c:1999:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_char_lit(void) {
 ^~~~~~~~~~~~
 struct 
mpc.c: In function ‘mpc_char_lit’:
mpc.c:2000:21: warning: implicit declaration of function ‘mpc_between’; did you mean ‘mpc_set_nan’? [-Wimplicit-function-declaration]
   return mpc_expect(mpc_between(mpc_or(2, mpc_escape(), mpc_any()), free, "'", "'"), "char");
                     ^~~~~~~~~~~
                     mpc_set_nan
mpc.c:2000:69: error: ‘free’ undeclared (first use in this function)
   return mpc_expect(mpc_between(mpc_or(2, mpc_escape(), mpc_any()), free, "'", "'"), "char");
                                                                     ^~~~
mpc.c:2000:69: note: ‘free’ is defined in header ‘<stdlib.h>’; did you forget to ‘#include <stdlib.h>’?
mpc.c: At top level:
mpc.c:2003:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_string_lit(void) {
 ^~~~~~~~~~~~
 struct 
mpc.c: In function ‘mpc_string_lit’:
mpc.c:2004:3: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
   mpc_parser_t *strchar = mpc_or(2, mpc_escape(), mpc_noneof("\""));
   ^~~~~~~~~~~~
   struct 
mpc.c:2005:42: error: ‘mpcf_strfold’ undeclared (first use in this function); did you mean ‘mpc_strtoc’?
   return mpc_expect(mpc_between(mpc_many(mpcf_strfold, strchar), free, "\"", "\""), "string");
                                          ^~~~~~~~~~~~
                                          mpc_strtoc
mpc.c:2005:66: error: ‘free’ undeclared (first use in this function)
   return mpc_expect(mpc_between(mpc_many(mpcf_strfold, strchar), free, "\"", "\""), "string");
                                                                  ^~~~
mpc.c:2005:66: note: ‘free’ is defined in header ‘<stdlib.h>’; did you forget to ‘#include <stdlib.h>’?
mpc.c: At top level:
mpc.c:2008:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_regex_lit(void) {
 ^~~~~~~~~~~~
 struct 
mpc.c: In function ‘mpc_regex_lit’:
mpc.c:2009:3: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
   mpc_parser_t *regexchar = mpc_or(2, mpc_escape(), mpc_noneof("/"));
   ^~~~~~~~~~~~
   struct 
mpc.c:2010:42: error: ‘mpcf_strfold’ undeclared (first use in this function); did you mean ‘mpc_strtoc’?
   return mpc_expect(mpc_between(mpc_many(mpcf_strfold, regexchar), free, "/", "/"), "regex");
                                          ^~~~~~~~~~~~
                                          mpc_strtoc
mpc.c:2010:68: error: ‘free’ undeclared (first use in this function)
   return mpc_expect(mpc_between(mpc_many(mpcf_strfold, regexchar), free, "/", "/"), "regex");
                                                                    ^~~~
mpc.c:2010:68: note: ‘free’ is defined in header ‘<stdlib.h>’; did you forget to ‘#include <stdlib.h>’?
mpc.c: At top level:
mpc.c:2013:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_ident(void) {
 ^~~~~~~~~~~~
 struct 
mpc.c: In function ‘mpc_ident’:
mpc.c:2014:3: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
   mpc_parser_t *p0, *p1;
   ^~~~~~~~~~~~
   struct 
mpc.c:2016:17: error: ‘mpcf_strfold’ undeclared (first use in this function); did you mean ‘mpc_strtoc’?
   p1 = mpc_many(mpcf_strfold, mpc_alphanum());
                 ^~~~~~~~~~~~
                 mpc_strtoc
mpc.c:2017:43: error: ‘free’ undeclared (first use in this function)
   return mpc_and(2, mpcf_strfold, p0, p1, free);
                                           ^~~~
mpc.c:2017:43: note: ‘free’ is defined in header ‘<stdlib.h>’; did you forget to ‘#include <stdlib.h>’?
mpc.c: At top level:
mpc.c:2024:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_startwith(mpc_parser_t *a) { return mpc_and(2, mpcf_snd, mpc_soi(), a, mpcf_dtor_null); }
 ^~~~~~~~~~~~
 struct 
mpc.c:2024:29: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 mpc_parser_t *mpc_startwith(mpc_parser_t *a) { return mpc_and(2, mpcf_snd, mpc_soi(), a, mpcf_dtor_null); }
                             ^~~~~~~~~~~~
                             mp_prec_t
mpc.c:2025:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_endwith(mpc_parser_t *a, mpc_dtor_t da) { return mpc_and(2, mpcf_fst, a, mpc_eoi(), da); }
 ^~~~~~~~~~~~
 struct 
mpc.c:2025:27: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 mpc_parser_t *mpc_endwith(mpc_parser_t *a, mpc_dtor_t da) { return mpc_and(2, mpcf_fst, a, mpc_eoi(), da); }
                           ^~~~~~~~~~~~
                           mp_prec_t
mpc.c:2025:44: error: unknown type name ‘mpc_dtor_t’; did you mean ‘mpc_pdata_t’?
 mpc_parser_t *mpc_endwith(mpc_parser_t *a, mpc_dtor_t da) { return mpc_and(2, mpcf_fst, a, mpc_eoi(), da); }
                                            ^~~~~~~~~~
                                            mpc_pdata_t
mpc.c:2026:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_whole(mpc_parser_t *a, mpc_dtor_t da) { return mpc_and(3, mpcf_snd, mpc_soi(), a, mpc_eoi(), mpcf_dtor_null, da); }
 ^~~~~~~~~~~~
 struct 
mpc.c:2026:25: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 mpc_parser_t *mpc_whole(mpc_parser_t *a, mpc_dtor_t da) { return mpc_and(3, mpcf_snd, mpc_soi(), a, mpc_eoi(), mpcf_dtor_null, da); }
                         ^~~~~~~~~~~~
                         mp_prec_t
mpc.c:2026:42: error: unknown type name ‘mpc_dtor_t’; did you mean ‘mpc_pdata_t’?
 mpc_parser_t *mpc_whole(mpc_parser_t *a, mpc_dtor_t da) { return mpc_and(3, mpcf_snd, mpc_soi(), a, mpc_eoi(), mpcf_dtor_null, da); }
                                          ^~~~~~~~~~
                                          mpc_pdata_t
mpc.c:2028:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_stripl(mpc_parser_t *a) { return mpc_and(2, mpcf_snd, mpc_blank(), a, mpcf_dtor_null); }
 ^~~~~~~~~~~~
 struct 
mpc.c:2028:26: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 mpc_parser_t *mpc_stripl(mpc_parser_t *a) { return mpc_and(2, mpcf_snd, mpc_blank(), a, mpcf_dtor_null); }
                          ^~~~~~~~~~~~
                          mp_prec_t
mpc.c:2029:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_stripr(mpc_parser_t *a) { return mpc_and(2, mpcf_fst, a, mpc_blank(), mpcf_dtor_null); }
 ^~~~~~~~~~~~
 struct 
mpc.c:2029:26: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 mpc_parser_t *mpc_stripr(mpc_parser_t *a) { return mpc_and(2, mpcf_fst, a, mpc_blank(), mpcf_dtor_null); }
                          ^~~~~~~~~~~~
                          mp_prec_t
mpc.c:2030:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_strip(mpc_parser_t *a) { return mpc_and(3, mpcf_snd, mpc_blank(), a, mpc_blank(), mpcf_dtor_null, mpcf_dtor_null); }
 ^~~~~~~~~~~~
 struct 
mpc.c:2030:25: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 mpc_parser_t *mpc_strip(mpc_parser_t *a) { return mpc_and(3, mpcf_snd, mpc_blank(), a, mpc_blank(), mpcf_dtor_null, mpcf_dtor_null); }
                         ^~~~~~~~~~~~
                         mp_prec_t
mpc.c:2031:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_tok(mpc_parser_t *a) { return mpc_and(2, mpcf_fst, a, mpc_blank(), mpcf_dtor_null); }
 ^~~~~~~~~~~~
 struct 
mpc.c:2031:23: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 mpc_parser_t *mpc_tok(mpc_parser_t *a) { return mpc_and(2, mpcf_fst, a, mpc_blank(), mpcf_dtor_null); }
                       ^~~~~~~~~~~~
                       mp_prec_t
mpc.c:2032:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_sym(const char *s) { return mpc_tok(mpc_string(s)); }
 ^~~~~~~~~~~~
 struct 
mpc.c: In function ‘mpc_sym’:
mpc.c:2032:47: warning: implicit declaration of function ‘mpc_tok’; did you mean ‘mpc_tab’? [-Wimplicit-function-declaration]
 mpc_parser_t *mpc_sym(const char *s) { return mpc_tok(mpc_string(s)); }
                                               ^~~~~~~
                                               mpc_tab
mpc.c:2032:47: warning: returning ‘int’ from a function with return type ‘int *’ makes pointer from integer without a cast [-Wint-conversion]
 mpc_parser_t *mpc_sym(const char *s) { return mpc_tok(mpc_string(s)); }
                                               ^~~~~~~~~~~~~~~~~~~~~~
mpc.c: At top level:
mpc.c:2034:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_total(mpc_parser_t *a, mpc_dtor_t da) { return mpc_whole(mpc_strip(a), da); }
 ^~~~~~~~~~~~
 struct 
mpc.c:2034:25: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 mpc_parser_t *mpc_total(mpc_parser_t *a, mpc_dtor_t da) { return mpc_whole(mpc_strip(a), da); }
                         ^~~~~~~~~~~~
                         mp_prec_t
mpc.c:2034:42: error: unknown type name ‘mpc_dtor_t’; did you mean ‘mpc_pdata_t’?
 mpc_parser_t *mpc_total(mpc_parser_t *a, mpc_dtor_t da) { return mpc_whole(mpc_strip(a), da); }
                                          ^~~~~~~~~~
                                          mpc_pdata_t
mpc.c:2036:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_between(mpc_parser_t *a, mpc_dtor_t ad, const char *o, const char *c) {
 ^~~~~~~~~~~~
 struct 
mpc.c:2036:27: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 mpc_parser_t *mpc_between(mpc_parser_t *a, mpc_dtor_t ad, const char *o, const char *c) {
                           ^~~~~~~~~~~~
                           mp_prec_t
mpc.c:2036:44: error: unknown type name ‘mpc_dtor_t’; did you mean ‘mpc_pdata_t’?
 mpc_parser_t *mpc_between(mpc_parser_t *a, mpc_dtor_t ad, const char *o, const char *c) {
                                            ^~~~~~~~~~
                                            mpc_pdata_t
mpc.c:2042:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_parens(mpc_parser_t *a, mpc_dtor_t ad)   { return mpc_between(a, ad, "(", ")"); }
 ^~~~~~~~~~~~
 struct 
mpc.c:2042:26: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 mpc_parser_t *mpc_parens(mpc_parser_t *a, mpc_dtor_t ad)   { return mpc_between(a, ad, "(", ")"); }
                          ^~~~~~~~~~~~
                          mp_prec_t
mpc.c:2042:43: error: unknown type name ‘mpc_dtor_t’; did you mean ‘mpc_pdata_t’?
 mpc_parser_t *mpc_parens(mpc_parser_t *a, mpc_dtor_t ad)   { return mpc_between(a, ad, "(", ")"); }
                                           ^~~~~~~~~~
                                           mpc_pdata_t
mpc.c:2043:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_braces(mpc_parser_t *a, mpc_dtor_t ad)   { return mpc_between(a, ad, "<", ">"); }
 ^~~~~~~~~~~~
 struct 
mpc.c:2043:26: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 mpc_parser_t *mpc_braces(mpc_parser_t *a, mpc_dtor_t ad)   { return mpc_between(a, ad, "<", ">"); }
                          ^~~~~~~~~~~~
                          mp_prec_t
mpc.c:2043:43: error: unknown type name ‘mpc_dtor_t’; did you mean ‘mpc_pdata_t’?
 mpc_parser_t *mpc_braces(mpc_parser_t *a, mpc_dtor_t ad)   { return mpc_between(a, ad, "<", ">"); }
                                           ^~~~~~~~~~
                                           mpc_pdata_t
mpc.c:2044:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_brackets(mpc_parser_t *a, mpc_dtor_t ad) { return mpc_between(a, ad, "{", "}"); }
 ^~~~~~~~~~~~
 struct 
mpc.c:2044:28: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 mpc_parser_t *mpc_brackets(mpc_parser_t *a, mpc_dtor_t ad) { return mpc_between(a, ad, "{", "}"); }
                            ^~~~~~~~~~~~
                            mp_prec_t
mpc.c:2044:45: error: unknown type name ‘mpc_dtor_t’; did you mean ‘mpc_pdata_t’?
 mpc_parser_t *mpc_brackets(mpc_parser_t *a, mpc_dtor_t ad) { return mpc_between(a, ad, "{", "}"); }
                                             ^~~~~~~~~~
                                             mpc_pdata_t
mpc.c:2045:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_squares(mpc_parser_t *a, mpc_dtor_t ad)  { return mpc_between(a, ad, "[", "]"); }
 ^~~~~~~~~~~~
 struct 
mpc.c:2045:27: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 mpc_parser_t *mpc_squares(mpc_parser_t *a, mpc_dtor_t ad)  { return mpc_between(a, ad, "[", "]"); }
                           ^~~~~~~~~~~~
                           mp_prec_t
mpc.c:2045:44: error: unknown type name ‘mpc_dtor_t’; did you mean ‘mpc_pdata_t’?
 mpc_parser_t *mpc_squares(mpc_parser_t *a, mpc_dtor_t ad)  { return mpc_between(a, ad, "[", "]"); }
                                            ^~~~~~~~~~
                                            mpc_pdata_t
mpc.c:2047:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_tok_between(mpc_parser_t *a, mpc_dtor_t ad, const char *o, const char *c) {
 ^~~~~~~~~~~~
 struct 
mpc.c:2047:31: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 mpc_parser_t *mpc_tok_between(mpc_parser_t *a, mpc_dtor_t ad, const char *o, const char *c) {
                               ^~~~~~~~~~~~
                               mp_prec_t
mpc.c:2047:48: error: unknown type name ‘mpc_dtor_t’; did you mean ‘mpc_pdata_t’?
 mpc_parser_t *mpc_tok_between(mpc_parser_t *a, mpc_dtor_t ad, const char *o, const char *c) {
                                                ^~~~~~~~~~
                                                mpc_pdata_t
mpc.c:2053:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_tok_parens(mpc_parser_t *a, mpc_dtor_t ad)   { return mpc_tok_between(a, ad, "(", ")"); }
 ^~~~~~~~~~~~
 struct 
mpc.c:2053:30: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 mpc_parser_t *mpc_tok_parens(mpc_parser_t *a, mpc_dtor_t ad)   { return mpc_tok_between(a, ad, "(", ")"); }
                              ^~~~~~~~~~~~
                              mp_prec_t
mpc.c:2053:47: error: unknown type name ‘mpc_dtor_t’; did you mean ‘mpc_pdata_t’?
 mpc_parser_t *mpc_tok_parens(mpc_parser_t *a, mpc_dtor_t ad)   { return mpc_tok_between(a, ad, "(", ")"); }
                                               ^~~~~~~~~~
                                               mpc_pdata_t
mpc.c:2054:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_tok_braces(mpc_parser_t *a, mpc_dtor_t ad)   { return mpc_tok_between(a, ad, "<", ">"); }
 ^~~~~~~~~~~~
 struct 
mpc.c:2054:30: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 mpc_parser_t *mpc_tok_braces(mpc_parser_t *a, mpc_dtor_t ad)   { return mpc_tok_between(a, ad, "<", ">"); }
                              ^~~~~~~~~~~~
                              mp_prec_t
mpc.c:2054:47: error: unknown type name ‘mpc_dtor_t’; did you mean ‘mpc_pdata_t’?
 mpc_parser_t *mpc_tok_braces(mpc_parser_t *a, mpc_dtor_t ad)   { return mpc_tok_between(a, ad, "<", ">"); }
                                               ^~~~~~~~~~
                                               mpc_pdata_t
mpc.c:2055:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_tok_brackets(mpc_parser_t *a, mpc_dtor_t ad) { return mpc_tok_between(a, ad, "{", "}"); }
 ^~~~~~~~~~~~
 struct 
mpc.c:2055:32: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 mpc_parser_t *mpc_tok_brackets(mpc_parser_t *a, mpc_dtor_t ad) { return mpc_tok_between(a, ad, "{", "}"); }
                                ^~~~~~~~~~~~
                                mp_prec_t
mpc.c:2055:49: error: unknown type name ‘mpc_dtor_t’; did you mean ‘mpc_pdata_t’?
 mpc_parser_t *mpc_tok_brackets(mpc_parser_t *a, mpc_dtor_t ad) { return mpc_tok_between(a, ad, "{", "}"); }
                                                 ^~~~~~~~~~
                                                 mpc_pdata_t
mpc.c:2056:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_tok_squares(mpc_parser_t *a, mpc_dtor_t ad)  { return mpc_tok_between(a, ad, "[", "]"); }
 ^~~~~~~~~~~~
 struct 
mpc.c:2056:31: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 mpc_parser_t *mpc_tok_squares(mpc_parser_t *a, mpc_dtor_t ad)  { return mpc_tok_between(a, ad, "[", "]"); }
                               ^~~~~~~~~~~~
                               mp_prec_t
mpc.c:2056:48: error: unknown type name ‘mpc_dtor_t’; did you mean ‘mpc_pdata_t’?
 mpc_parser_t *mpc_tok_squares(mpc_parser_t *a, mpc_dtor_t ad)  { return mpc_tok_between(a, ad, "[", "]"); }
                                                ^~~~~~~~~~
                                                mpc_pdata_t
mpc.c:2108:8: error: unknown type name ‘mpc_val_t’
 static mpc_val_t *mpcf_re_or(int n, mpc_val_t **xs) {
        ^~~~~~~~~
mpc.c:2108:37: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 static mpc_val_t *mpcf_re_or(int n, mpc_val_t **xs) {
                                     ^~~~~~~~~
                                     mpc_mem_t
mpc.c:2114:8: error: unknown type name ‘mpc_val_t’
 static mpc_val_t *mpcf_re_and(int n, mpc_val_t **xs) {
        ^~~~~~~~~
mpc.c:2114:38: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 static mpc_val_t *mpcf_re_and(int n, mpc_val_t **xs) {
                                      ^~~~~~~~~
                                      mpc_mem_t
mpc.c:2123:8: error: unknown type name ‘mpc_val_t’
 static mpc_val_t *mpcf_re_repeat(int n, mpc_val_t **xs) {
        ^~~~~~~~~
mpc.c:2123:41: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 static mpc_val_t *mpcf_re_repeat(int n, mpc_val_t **xs) {
                                         ^~~~~~~~~
                                         mpc_mem_t
mpc.c:2140:8: error: unknown type name ‘mpc_parser_t’
 static mpc_parser_t *mpc_re_escape_char(char c) {
        ^~~~~~~~~~~~
mpc.c: In function ‘mpc_re_escape_char’:
mpc.c:2148:33: error: ‘mpcf_snd’ undeclared (first use in this function); did you mean ‘mpc_sym’?
     case 'b': return mpc_and(2, mpcf_snd, mpc_boundary(), mpc_lift(mpcf_ctor_str), free);
                                 ^~~~~~~~
                                 mpc_sym
mpc.c:2148:59: warning: implicit declaration of function ‘mpc_lift’; did you mean ‘mpc_int’? [-Wimplicit-function-declaration]
     case 'b': return mpc_and(2, mpcf_snd, mpc_boundary(), mpc_lift(mpcf_ctor_str), free);
                                                           ^~~~~~~~
                                                           mpc_int
mpc.c:2148:68: error: ‘mpcf_ctor_str’ undeclared (first use in this function); did you mean ‘mpc_free_str’?
     case 'b': return mpc_and(2, mpcf_snd, mpc_boundary(), mpc_lift(mpcf_ctor_str), free);
                                                                    ^~~~~~~~~~~~~
                                                                    mpc_free_str
mpc.c:2148:84: error: ‘free’ undeclared (first use in this function)
     case 'b': return mpc_and(2, mpcf_snd, mpc_boundary(), mpc_lift(mpcf_ctor_str), free);
                                                                                    ^~~~
mpc.c:2148:84: note: ‘free’ is defined in header ‘<stdlib.h>’; did you forget to ‘#include <stdlib.h>’?
mpc.c:2149:22: warning: implicit declaration of function ‘mpc_not_lift’; did you mean ‘mpc_char_lit’? [-Wimplicit-function-declaration]
     case 'B': return mpc_not_lift(mpc_boundary(), free, mpcf_ctor_str);
                      ^~~~~~~~~~~~
                      mpc_char_lit
mpc.c: At top level:
mpc.c:2162:8: error: unknown type name ‘mpc_val_t’
 static mpc_val_t *mpcf_re_escape(mpc_val_t *x) {
        ^~~~~~~~~
mpc.c:2162:34: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 static mpc_val_t *mpcf_re_escape(mpc_val_t *x) {
                                  ^~~~~~~~~
                                  mpc_mem_t
mpc.c:2203:8: error: unknown type name ‘mpc_val_t’
 static mpc_val_t *mpcf_re_range(mpc_val_t *x) {
        ^~~~~~~~~
mpc.c:2203:33: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 static mpc_val_t *mpcf_re_range(mpc_val_t *x) {
                                 ^~~~~~~~~
                                 mpc_mem_t
mpc.c:2266:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpc_re(const char *re) {
 ^~~~~~~~~~~~
 struct 
mpc.c: In function ‘mpc_re’:
mpc.c:2269:3: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
   mpc_parser_t *err_out;
   ^~~~~~~~~~~~
   struct 
mpc.c:2270:3: error: unknown type name ‘mpc_result_t’; did you mean ‘mpc_input_t’?
   mpc_result_t r;
   ^~~~~~~~~~~~
   mpc_input_t
mpc.c:2271:3: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
   mpc_parser_t *Regex, *Term, *Factor, *Base, *Range, *RegexEnclose;
   ^~~~~~~~~~~~
   struct 
mpc.c:2279:3: warning: implicit declaration of function ‘mpc_define’; did you mean ‘mpc_newline’? [-Wimplicit-function-declaration]
   mpc_define(Regex, mpc_and(2, mpcf_re_or,
   ^~~~~~~~~~
   mpc_newline
mpc.c:2279:32: error: ‘mpcf_re_or’ undeclared (first use in this function); did you mean ‘mpc_re’?
   mpc_define(Regex, mpc_and(2, mpcf_re_or,
                                ^~~~~~~~~~
                                mpc_re
mpc.c:2281:5: warning: implicit declaration of function ‘mpc_maybe’; did you mean ‘mpc_tab’? [-Wimplicit-function-declaration]
     mpc_maybe(mpc_and(2, mpcf_snd_free, mpc_char('|'), Regex, free)),
     ^~~~~~~~~
     mpc_tab
mpc.c:2281:26: error: ‘mpcf_snd_free’ undeclared (first use in this function); did you mean ‘mpc_free’?
     mpc_maybe(mpc_and(2, mpcf_snd_free, mpc_char('|'), Regex, free)),
                          ^~~~~~~~~~~~~
                          mpc_free
mpc.c:2281:63: error: ‘free’ undeclared (first use in this function)
     mpc_maybe(mpc_and(2, mpcf_snd_free, mpc_char('|'), Regex, free)),
                                                               ^~~~
mpc.c:2281:63: note: ‘free’ is defined in header ‘<stdlib.h>’; did you forget to ‘#include <stdlib.h>’?
mpc.c:2282:6: error: ‘mpc_dtor_t’ undeclared (first use in this function); did you mean ‘mpc_float’?
     (mpc_dtor_t)mpc_delete
      ^~~~~~~~~~
      mpc_float
mpc.c:2282:17: error: expected ‘)’ before ‘mpc_delete’
     (mpc_dtor_t)mpc_delete
                 ^~~~~~~~~~
                 )
mpc.c:2285:29: error: ‘mpcf_re_and’ undeclared (first use in this function); did you mean ‘mpc_real’?
   mpc_define(Term, mpc_many(mpcf_re_and, Factor));
                             ^~~~~~~~~~~
                             mpc_real
mpc.c:2287:33: error: ‘mpcf_re_repeat’ undeclared (first use in this function); did you mean ‘mpc_regex_lit’?
   mpc_define(Factor, mpc_and(2, mpcf_re_repeat,
                                 ^~~~~~~~~~~~~~
                                 mpc_regex_lit
mpc.c:2291:7: warning: implicit declaration of function ‘mpc_brackets’; did you mean ‘mpc_blank’? [-Wimplicit-function-declaration]
       mpc_brackets(mpc_int(), free),
       ^~~~~~~~~~~~
       mpc_blank
mpc.c:2293:17: error: expected ‘)’ before ‘mpc_delete’
     (mpc_dtor_t)mpc_delete
                 ^~~~~~~~~~
                 )
mpc.c:2297:5: warning: implicit declaration of function ‘mpc_parens’; did you mean ‘mpc_pass’? [-Wimplicit-function-declaration]
     mpc_parens(Regex, (mpc_dtor_t)mpc_delete),
     ^~~~~~~~~~
     mpc_pass
mpc.c:2297:35: error: expected ‘)’ before ‘mpc_delete’
     mpc_parens(Regex, (mpc_dtor_t)mpc_delete),
                                   ^~~~~~~~~~
                                   )
mpc.c:2298:5: warning: implicit declaration of function ‘mpc_squares’; did you mean ‘mpc_state’? [-Wimplicit-function-declaration]
     mpc_squares(Range, (mpc_dtor_t)mpc_delete),
     ^~~~~~~~~~~
     mpc_state
mpc.c:2298:36: error: expected ‘)’ before ‘mpc_delete’
     mpc_squares(Range, (mpc_dtor_t)mpc_delete),
                                    ^~~~~~~~~~
                                    )
mpc.c:2299:29: error: ‘mpcf_re_escape’ undeclared (first use in this function); did you mean ‘mpc_escape’?
     mpc_apply(mpc_escape(), mpcf_re_escape),
                             ^~~~~~~~~~~~~~
                             mpc_escape
mpc.c:2304:14: error: ‘mpcf_strfold’ undeclared (first use in this function); did you mean ‘mpc_strtoc’?
     mpc_many(mpcf_strfold, mpc_or(2, mpc_escape(), mpc_noneof("]"))),
              ^~~~~~~~~~~~
              mpc_strtoc
mpc.c:2305:5: error: ‘mpcf_re_range’ undeclared (first use in this function); did you mean ‘mpc_range’?
     mpcf_re_range
     ^~~~~~~~~~~~~
     mpc_range
mpc.c:2308:18: warning: implicit declaration of function ‘mpc_whole’; did you mean ‘mpc_re’? [-Wimplicit-function-declaration]
   RegexEnclose = mpc_whole(mpc_predictive(Regex), (mpc_dtor_t)mpc_delete);
                  ^~~~~~~~~
                  mpc_re
mpc.c:2308:28: warning: implicit declaration of function ‘mpc_predictive’; did you mean ‘mpc_fr_div’? [-Wimplicit-function-declaration]
   RegexEnclose = mpc_whole(mpc_predictive(Regex), (mpc_dtor_t)mpc_delete);
                            ^~~~~~~~~~~~~~
                            mpc_fr_div
mpc.c:2308:63: error: expected ‘)’ before ‘mpc_delete’
   RegexEnclose = mpc_whole(mpc_predictive(Regex), (mpc_dtor_t)mpc_delete);
                                                               ^~~~~~~~~~
                                                               )
mpc.c:2310:3: warning: implicit declaration of function ‘mpc_optimise’; did you mean ‘mpc_octdigits’? [-Wimplicit-function-declaration]
   mpc_optimise(RegexEnclose);
   ^~~~~~~~~~~~
   mpc_octdigits
mpc.c:2317:7: warning: implicit declaration of function ‘mpc_parse’; did you mean ‘mpc_pass’? [-Wimplicit-function-declaration]
   if(!mpc_parse("<mpc_re_compiler>", re, RegexEnclose, &r)) {
       ^~~~~~~~~
       mpc_pass
mpc.c:2318:15: warning: implicit declaration of function ‘mpc_err_string’; did you mean ‘mpc_string’? [-Wimplicit-function-declaration]
     err_msg = mpc_err_string(r.error);
               ^~~~~~~~~~~~~~
               mpc_string
mpc.c:2318:31: error: request for member ‘error’ in something not a structure or union
     err_msg = mpc_err_string(r.error);
                               ^
mpc.c:2320:5: warning: implicit declaration of function ‘mpc_err_delete’; did you mean ‘mpc_err_file’? [-Wimplicit-function-declaration]
     mpc_err_delete(r.error);
     ^~~~~~~~~~~~~~
     mpc_err_file
mpc.c:2320:21: error: request for member ‘error’ in something not a structure or union
     mpc_err_delete(r.error);
                     ^
mpc.c:2321:5: warning: incompatible implicit declaration of built-in function ‘free’
     free(err_msg);
     ^~~~
mpc.c:2321:5: note: include ‘<stdlib.h>’ or provide a declaration of ‘free’
mpc.c:2322:6: error: request for member ‘output’ in something not a structure or union
     r.output = err_out;
      ^
mpc.c:2327:17: error: request for member ‘output’ in something not a structure or union
   mpc_optimise(r.output);
                 ^
mpc.c:2329:11: error: request for member ‘output’ in something not a structure or union
   return r.output;
           ^
mpc.c: At top level:
mpc.c:2337:21: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 void mpcf_dtor_null(mpc_val_t *x) { (void) x; return; }
                     ^~~~~~~~~
                     mpc_mem_t
mpc.c:2339:1: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_ctor_null(void) { return NULL; }
 ^~~~~~~~~
 mpc_mem_t
mpc.c:2340:1: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_ctor_str(void) { return calloc(1, 1); }
 ^~~~~~~~~
 mpc_mem_t
mpc.c: In function ‘mpcf_ctor_str’:
mpc.c:2340:41: warning: incompatible implicit declaration of built-in function ‘calloc’
 mpc_val_t *mpcf_ctor_str(void) { return calloc(1, 1); }
                                         ^~~~~~
mpc.c:2340:41: note: include ‘<stdlib.h>’ or provide a declaration of ‘calloc’
mpc.c: At top level:
mpc.c:2341:1: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_free(mpc_val_t *x) { free(x); return NULL; }
 ^~~~~~~~~
 mpc_mem_t
mpc.c:2341:22: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_free(mpc_val_t *x) { free(x); return NULL; }
                      ^~~~~~~~~
                      mpc_mem_t
mpc.c:2343:1: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_int(mpc_val_t *x) {
 ^~~~~~~~~
 mpc_mem_t
mpc.c:2343:21: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_int(mpc_val_t *x) {
                     ^~~~~~~~~
                     mpc_mem_t
mpc.c:2350:1: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_hex(mpc_val_t *x) {
 ^~~~~~~~~
 mpc_mem_t
mpc.c:2350:21: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_hex(mpc_val_t *x) {
                     ^~~~~~~~~
                     mpc_mem_t
mpc.c:2357:1: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_oct(mpc_val_t *x) {
 ^~~~~~~~~
 mpc_mem_t
mpc.c:2357:21: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_oct(mpc_val_t *x) {
                     ^~~~~~~~~
                     mpc_mem_t
mpc.c:2364:1: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_float(mpc_val_t *x) {
 ^~~~~~~~~
 mpc_mem_t
mpc.c:2364:23: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_float(mpc_val_t *x) {
                       ^~~~~~~~~
                       mpc_mem_t
mpc.c:2371:1: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_strtriml(mpc_val_t *x) {
 ^~~~~~~~~
 mpc_mem_t
mpc.c:2371:26: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_strtriml(mpc_val_t *x) {
                          ^~~~~~~~~
                          mpc_mem_t
mpc.c:2379:1: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_strtrimr(mpc_val_t *x) {
 ^~~~~~~~~
 mpc_mem_t
mpc.c:2379:26: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_strtrimr(mpc_val_t *x) {
                          ^~~~~~~~~
                          mpc_mem_t
mpc.c:2388:1: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_strtrim(mpc_val_t *x) {
 ^~~~~~~~~
 mpc_mem_t
mpc.c:2388:25: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_strtrim(mpc_val_t *x) {
                         ^~~~~~~~~
                         mpc_mem_t
mpc.c:2409:8: error: unknown type name ‘mpc_val_t’
 static mpc_val_t *mpcf_escape_new(mpc_val_t *x, const char *input, const char **output) {
        ^~~~~~~~~
mpc.c:2409:35: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 static mpc_val_t *mpcf_escape_new(mpc_val_t *x, const char *input, const char **output) {
                                   ^~~~~~~~~
                                   mpc_mem_t
mpc.c:2445:8: error: unknown type name ‘mpc_val_t’
 static mpc_val_t *mpcf_unescape_new(mpc_val_t *x, const char *input, const char **output) {
        ^~~~~~~~~
mpc.c:2445:37: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 static mpc_val_t *mpcf_unescape_new(mpc_val_t *x, const char *input, const char **output) {
                                     ^~~~~~~~~
                                     mpc_mem_t
mpc.c:2485:1: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_escape(mpc_val_t *x) {
 ^~~~~~~~~
 mpc_mem_t
mpc.c:2485:24: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_escape(mpc_val_t *x) {
                        ^~~~~~~~~
                        mpc_mem_t
mpc.c:2491:1: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_unescape(mpc_val_t *x) {
 ^~~~~~~~~
 mpc_mem_t
mpc.c:2491:26: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_unescape(mpc_val_t *x) {
                          ^~~~~~~~~
                          mpc_mem_t
mpc.c:2497:1: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_escape_regex(mpc_val_t *x) {
 ^~~~~~~~~
 mpc_mem_t
mpc.c:2497:30: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_escape_regex(mpc_val_t *x) {
                              ^~~~~~~~~
                              mpc_mem_t
mpc.c:2503:1: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_unescape_regex(mpc_val_t *x) {
 ^~~~~~~~~
 mpc_mem_t
mpc.c:2503:32: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_unescape_regex(mpc_val_t *x) {
                                ^~~~~~~~~
                                mpc_mem_t
mpc.c:2509:1: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_escape_string_raw(mpc_val_t *x) {
 ^~~~~~~~~
 mpc_mem_t
mpc.c:2509:35: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_escape_string_raw(mpc_val_t *x) {
                                   ^~~~~~~~~
                                   mpc_mem_t
mpc.c:2515:1: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_unescape_string_raw(mpc_val_t *x) {
 ^~~~~~~~~
 mpc_mem_t
mpc.c:2515:37: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_unescape_string_raw(mpc_val_t *x) {
                                     ^~~~~~~~~
                                     mpc_mem_t
mpc.c:2521:1: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_escape_char_raw(mpc_val_t *x) {
 ^~~~~~~~~
 mpc_mem_t
mpc.c:2521:33: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_escape_char_raw(mpc_val_t *x) {
                                 ^~~~~~~~~
                                 mpc_mem_t
mpc.c:2527:1: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_unescape_char_raw(mpc_val_t *x) {
 ^~~~~~~~~
 mpc_mem_t
mpc.c:2527:35: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_unescape_char_raw(mpc_val_t *x) {
                                   ^~~~~~~~~
                                   mpc_mem_t
mpc.c:2533:1: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_null(int n, mpc_val_t** xs) { (void) n; (void) xs; return NULL; }
 ^~~~~~~~~
 mpc_mem_t
mpc.c:2533:29: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_null(int n, mpc_val_t** xs) { (void) n; (void) xs; return NULL; }
                             ^~~~~~~~~
                             mpc_mem_t
mpc.c:2534:1: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_fst(int n, mpc_val_t **xs) { (void) n; return xs[0]; }
 ^~~~~~~~~
 mpc_mem_t
mpc.c:2534:28: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_fst(int n, mpc_val_t **xs) { (void) n; return xs[0]; }
                            ^~~~~~~~~
                            mpc_mem_t
mpc.c:2535:1: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_snd(int n, mpc_val_t **xs) { (void) n; return xs[1]; }
 ^~~~~~~~~
 mpc_mem_t
mpc.c:2535:28: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_snd(int n, mpc_val_t **xs) { (void) n; return xs[1]; }
                            ^~~~~~~~~
                            mpc_mem_t
mpc.c:2536:1: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_trd(int n, mpc_val_t **xs) { (void) n; return xs[2]; }
 ^~~~~~~~~
 mpc_mem_t
mpc.c:2536:28: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_trd(int n, mpc_val_t **xs) { (void) n; return xs[2]; }
                            ^~~~~~~~~
                            mpc_mem_t
mpc.c:2538:8: error: unknown type name ‘mpc_val_t’
 static mpc_val_t *mpcf_nth_free(int n, mpc_val_t **xs, int x) {
        ^~~~~~~~~
mpc.c:2538:40: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 static mpc_val_t *mpcf_nth_free(int n, mpc_val_t **xs, int x) {
                                        ^~~~~~~~~
                                        mpc_mem_t
mpc.c:2546:1: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_fst_free(int n, mpc_val_t **xs) { return mpcf_nth_free(n, xs, 0); }
 ^~~~~~~~~
 mpc_mem_t
mpc.c:2546:33: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_fst_free(int n, mpc_val_t **xs) { return mpcf_nth_free(n, xs, 0); }
                                 ^~~~~~~~~
                                 mpc_mem_t
mpc.c:2547:1: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_snd_free(int n, mpc_val_t **xs) { return mpcf_nth_free(n, xs, 1); }
 ^~~~~~~~~
 mpc_mem_t
mpc.c:2547:33: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_snd_free(int n, mpc_val_t **xs) { return mpcf_nth_free(n, xs, 1); }
                                 ^~~~~~~~~
                                 mpc_mem_t
mpc.c:2548:1: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_trd_free(int n, mpc_val_t **xs) { return mpcf_nth_free(n, xs, 2); }
 ^~~~~~~~~
 mpc_mem_t
mpc.c:2548:33: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_trd_free(int n, mpc_val_t **xs) { return mpcf_nth_free(n, xs, 2); }
                                 ^~~~~~~~~
                                 mpc_mem_t
mpc.c:2550:1: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_strfold(int n, mpc_val_t **xs) {
 ^~~~~~~~~
 mpc_mem_t
mpc.c:2550:32: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_strfold(int n, mpc_val_t **xs) {
                                ^~~~~~~~~
                                mpc_mem_t
mpc.c:2567:1: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_maths(int n, mpc_val_t **xs) {
 ^~~~~~~~~
 mpc_mem_t
mpc.c:2567:30: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_maths(int n, mpc_val_t **xs) {
                              ^~~~~~~~~
                              mpc_mem_t
mpc.c:2590:34: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 static void mpc_print_unretained(mpc_parser_t *p, int force) {
                                  ^~~~~~~~~~~~
                                  mp_prec_t
mpc.c:2713:16: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 void mpc_print(mpc_parser_t *p) {
                ^~~~~~~~~~~~
                mp_prec_t
mpc.c:2733:19: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 int mpc_test_fail(mpc_parser_t *p, const char *s, const void *d,
                   ^~~~~~~~~~~~
                   mp_prec_t
mpc.c:2735:3: error: unknown type name ‘mpc_dtor_t’; did you mean ‘mpc_pdata_t’?
   mpc_dtor_t destructor,
   ^~~~~~~~~~
   mpc_pdata_t
mpc.c:2756:19: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 int mpc_test_pass(mpc_parser_t *p, const char *s, const void *d,
                   ^~~~~~~~~~~~
                   mp_prec_t
mpc.c:2758:3: error: unknown type name ‘mpc_dtor_t’; did you mean ‘mpc_pdata_t’?
   mpc_dtor_t destructor,
   ^~~~~~~~~~
   mpc_pdata_t
mpc.c:2788:21: error: unknown type name ‘mpc_ast_t’; did you mean ‘mpc_mem_t’?
 void mpc_ast_delete(mpc_ast_t *a) {
                     ^~~~~~~~~
                     mpc_mem_t
mpc.c:2805:40: error: unknown type name ‘mpc_ast_t’; did you mean ‘mpc_mem_t’?
 static void mpc_ast_delete_no_children(mpc_ast_t *a) {
                                        ^~~~~~~~~
                                        mpc_mem_t
mpc.c:2812:1: error: unknown type name ‘mpc_ast_t’; did you mean ‘mpc_mem_t’?
 mpc_ast_t *mpc_ast_new(const char *tag, const char *contents) {
 ^~~~~~~~~
 mpc_mem_t
mpc.c: In function ‘mpc_ast_new’:
mpc.c:2814:3: error: unknown type name ‘mpc_ast_t’; did you mean ‘mpc_mem_t’?
   mpc_ast_t *a = malloc(sizeof(mpc_ast_t));
   ^~~~~~~~~
   mpc_mem_t
mpc.c:2814:18: warning: incompatible implicit declaration of built-in function ‘malloc’
   mpc_ast_t *a = malloc(sizeof(mpc_ast_t));
                  ^~~~~~
mpc.c:2814:18: note: include ‘<stdlib.h>’ or provide a declaration of ‘malloc’
mpc.c:2814:32: error: ‘mpc_ast_t’ undeclared (first use in this function); did you mean ‘mpc_ast_new’?
   mpc_ast_t *a = malloc(sizeof(mpc_ast_t));
                                ^~~~~~~~~
                                mpc_ast_new
mpc.c:2816:4: error: request for member ‘tag’ in something not a structure or union
   a->tag = malloc(strlen(tag) + 1);
    ^~
mpc.c:2816:19: warning: incompatible implicit declaration of built-in function ‘strlen’
   a->tag = malloc(strlen(tag) + 1);
                   ^~~~~~
mpc.c:2816:19: note: include ‘<string.h>’ or provide a declaration of ‘strlen’
mpc.c:2817:3: warning: incompatible implicit declaration of built-in function ‘strcpy’
   strcpy(a->tag, tag);
   ^~~~~~
mpc.c:2817:3: note: include ‘<string.h>’ or provide a declaration of ‘strcpy’
mpc.c:2817:11: error: request for member ‘tag’ in something not a structure or union
   strcpy(a->tag, tag);
           ^~
mpc.c:2819:4: error: request for member ‘contents’ in something not a structure or union
   a->contents = malloc(strlen(contents) + 1);
    ^~
mpc.c:2820:11: error: request for member ‘contents’ in something not a structure or union
   strcpy(a->contents, contents);
           ^~
mpc.c:2822:4: error: request for member ‘state’ in something not a structure or union
   a->state = mpc_state_new();
    ^~
mpc.c:2824:4: error: request for member ‘children_num’ in something not a structure or union
   a->children_num = 0;
    ^~
mpc.c:2825:4: error: request for member ‘children’ in something not a structure or union
   a->children = NULL;
    ^~
mpc.c: At top level:
mpc.c:2830:1: error: unknown type name ‘mpc_ast_t’; did you mean ‘mpc_mem_t’?
 mpc_ast_t *mpc_ast_build(int n, const char *tag, ...) {
 ^~~~~~~~~
 mpc_mem_t
mpc.c: In function ‘mpc_ast_build’:
mpc.c:2832:3: error: unknown type name ‘mpc_ast_t’; did you mean ‘mpc_mem_t’?
   mpc_ast_t *a = mpc_ast_new(tag, "");
   ^~~~~~~~~
   mpc_mem_t
mpc.c:2835:3: error: unknown type name ‘va_list’
   va_list va;
   ^~~~~~~
mpc.c:2835:3: note: ‘va_list’ is defined in header ‘<stdarg.h>’; did you forget to ‘#include <stdarg.h>’?
mpc.c:2839:5: warning: implicit declaration of function ‘mpc_ast_add_child’; did you mean ‘mpc_ast_build’? [-Wimplicit-function-declaration]
     mpc_ast_add_child(a, va_arg(va, mpc_ast_t*));
     ^~~~~~~~~~~~~~~~~
     mpc_ast_build
mpc.c:2839:37: error: ‘mpc_ast_t’ undeclared (first use in this function); did you mean ‘mpc_ast_new’?
     mpc_ast_add_child(a, va_arg(va, mpc_ast_t*));
                                     ^~~~~~~~~
                                     mpc_ast_new
mpc.c:2839:47: error: expected expression before ‘)’ token
     mpc_ast_add_child(a, va_arg(va, mpc_ast_t*));
                                               ^
mpc.c: At top level:
mpc.c:2848:1: error: unknown type name ‘mpc_ast_t’; did you mean ‘mpc_mem_t’?
 mpc_ast_t *mpc_ast_add_root(mpc_ast_t *a) {
 ^~~~~~~~~
 mpc_mem_t
mpc.c:2848:29: error: unknown type name ‘mpc_ast_t’; did you mean ‘mpc_mem_t’?
 mpc_ast_t *mpc_ast_add_root(mpc_ast_t *a) {
                             ^~~~~~~~~
                             mpc_mem_t
mpc.c:2861:16: error: unknown type name ‘mpc_ast_t’; did you mean ‘mpc_mem_t’?
 int mpc_ast_eq(mpc_ast_t *a, mpc_ast_t *b) {
                ^~~~~~~~~
                mpc_mem_t
mpc.c:2861:30: error: unknown type name ‘mpc_ast_t’; did you mean ‘mpc_mem_t’?
 int mpc_ast_eq(mpc_ast_t *a, mpc_ast_t *b) {
                              ^~~~~~~~~
                              mpc_mem_t
mpc.c:2876:1: error: unknown type name ‘mpc_ast_t’; did you mean ‘mpc_mem_t’?
 mpc_ast_t *mpc_ast_add_child(mpc_ast_t *r, mpc_ast_t *a) {
 ^~~~~~~~~
 mpc_mem_t
mpc.c:2876:30: error: unknown type name ‘mpc_ast_t’; did you mean ‘mpc_mem_t’?
 mpc_ast_t *mpc_ast_add_child(mpc_ast_t *r, mpc_ast_t *a) {
                              ^~~~~~~~~
                              mpc_mem_t
mpc.c:2876:44: error: unknown type name ‘mpc_ast_t’; did you mean ‘mpc_mem_t’?
 mpc_ast_t *mpc_ast_add_child(mpc_ast_t *r, mpc_ast_t *a) {
                                            ^~~~~~~~~
                                            mpc_mem_t
mpc.c:2883:1: error: unknown type name ‘mpc_ast_t’; did you mean ‘mpc_mem_t’?
 mpc_ast_t *mpc_ast_add_tag(mpc_ast_t *a, const char *t) {
 ^~~~~~~~~
 mpc_mem_t
mpc.c:2883:28: error: unknown type name ‘mpc_ast_t’; did you mean ‘mpc_mem_t’?
 mpc_ast_t *mpc_ast_add_tag(mpc_ast_t *a, const char *t) {
                            ^~~~~~~~~
                            mpc_mem_t
mpc.c:2892:1: error: unknown type name ‘mpc_ast_t’; did you mean ‘mpc_mem_t’?
 mpc_ast_t *mpc_ast_add_root_tag(mpc_ast_t *a, const char *t) {
 ^~~~~~~~~
 mpc_mem_t
mpc.c:2892:33: error: unknown type name ‘mpc_ast_t’; did you mean ‘mpc_mem_t’?
 mpc_ast_t *mpc_ast_add_root_tag(mpc_ast_t *a, const char *t) {
                                 ^~~~~~~~~
                                 mpc_mem_t
mpc.c:2900:1: error: unknown type name ‘mpc_ast_t’; did you mean ‘mpc_mem_t’?
 mpc_ast_t *mpc_ast_tag(mpc_ast_t *a, const char *t) {
 ^~~~~~~~~
 mpc_mem_t
mpc.c:2900:24: error: unknown type name ‘mpc_ast_t’; did you mean ‘mpc_mem_t’?
 mpc_ast_t *mpc_ast_tag(mpc_ast_t *a, const char *t) {
                        ^~~~~~~~~
                        mpc_mem_t
mpc.c:2906:1: error: unknown type name ‘mpc_ast_t’; did you mean ‘mpc_mem_t’?
 mpc_ast_t *mpc_ast_state(mpc_ast_t *a, mpc_state_t s) {
 ^~~~~~~~~
 mpc_mem_t
mpc.c:2906:26: error: unknown type name ‘mpc_ast_t’; did you mean ‘mpc_mem_t’?
 mpc_ast_t *mpc_ast_state(mpc_ast_t *a, mpc_state_t s) {
                          ^~~~~~~~~
                          mpc_mem_t
mpc.c:2906:40: error: unknown type name ‘mpc_state_t’; did you mean ‘mpc_pdata_t’?
 mpc_ast_t *mpc_ast_state(mpc_ast_t *a, mpc_state_t s) {
                                        ^~~~~~~~~~~
                                        mpc_pdata_t
mpc.c:2912:33: error: unknown type name ‘mpc_ast_t’; did you mean ‘mpc_mem_t’?
 static void mpc_ast_print_depth(mpc_ast_t *a, int d, FILE *fp) {
                                 ^~~~~~~~~
                                 mpc_mem_t
mpc.c:2912:54: error: unknown type name ‘FILE’
 static void mpc_ast_print_depth(mpc_ast_t *a, int d, FILE *fp) {
                                                      ^~~~
mpc.c:2912:54: note: ‘FILE’ is defined in header ‘<stdio.h>’; did you forget to ‘#include <stdio.h>’?
mpc.c:2938:20: error: unknown type name ‘mpc_ast_t’; did you mean ‘mpc_mem_t’?
 void mpc_ast_print(mpc_ast_t *a) {
                    ^~~~~~~~~
                    mpc_mem_t
mpc.c:2942:23: error: unknown type name ‘mpc_ast_t’; did you mean ‘mpc_mem_t’?
 void mpc_ast_print_to(mpc_ast_t *a, FILE *fp) {
                       ^~~~~~~~~
                       mpc_mem_t
mpc.c:2942:37: error: unknown type name ‘FILE’
 void mpc_ast_print_to(mpc_ast_t *a, FILE *fp) {
                                     ^~~~
mpc.c:2942:37: note: ‘FILE’ is defined in header ‘<stdio.h>’; did you forget to ‘#include <stdio.h>’?
mpc.c:2946:23: error: unknown type name ‘mpc_ast_t’; did you mean ‘mpc_mem_t’?
 int mpc_ast_get_index(mpc_ast_t *ast, const char *tag) {
                       ^~~~~~~~~
                       mpc_mem_t
mpc.c:2950:26: error: unknown type name ‘mpc_ast_t’; did you mean ‘mpc_mem_t’?
 int mpc_ast_get_index_lb(mpc_ast_t *ast, const char *tag, int lb) {
                          ^~~~~~~~~
                          mpc_mem_t
mpc.c:2962:1: error: unknown type name ‘mpc_ast_t’; did you mean ‘mpc_mem_t’?
 mpc_ast_t *mpc_ast_get_child(mpc_ast_t *ast, const char *tag) {
 ^~~~~~~~~
 mpc_mem_t
mpc.c:2962:30: error: unknown type name ‘mpc_ast_t’; did you mean ‘mpc_mem_t’?
 mpc_ast_t *mpc_ast_get_child(mpc_ast_t *ast, const char *tag) {
                              ^~~~~~~~~
                              mpc_mem_t
mpc.c:2966:1: error: unknown type name ‘mpc_ast_t’; did you mean ‘mpc_mem_t’?
 mpc_ast_t *mpc_ast_get_child_lb(mpc_ast_t *ast, const char *tag, int lb) {
 ^~~~~~~~~
 mpc_mem_t
mpc.c:2966:33: error: unknown type name ‘mpc_ast_t’; did you mean ‘mpc_mem_t’?
 mpc_ast_t *mpc_ast_get_child_lb(mpc_ast_t *ast, const char *tag, int lb) {
                                 ^~~~~~~~~
                                 mpc_mem_t
mpc.c:2978:1: error: unknown type name ‘mpc_ast_trav_t’; did you mean ‘mpc_pdata_t’?
 mpc_ast_trav_t *mpc_ast_traverse_start(mpc_ast_t *ast,
 ^~~~~~~~~~~~~~
 mpc_pdata_t
mpc.c:2978:40: error: unknown type name ‘mpc_ast_t’; did you mean ‘mpc_mem_t’?
 mpc_ast_trav_t *mpc_ast_traverse_start(mpc_ast_t *ast,
                                        ^~~~~~~~~
                                        mpc_mem_t
mpc.c:2979:40: error: unknown type name ‘mpc_ast_trav_order_t’; did you mean ‘mpc_pdata_or_t’?
                                        mpc_ast_trav_order_t order)
                                        ^~~~~~~~~~~~~~~~~~~~
                                        mpc_pdata_or_t
mpc.c:3020:1: error: unknown type name ‘mpc_ast_t’; did you mean ‘mpc_mem_t’?
 mpc_ast_t *mpc_ast_traverse_next(mpc_ast_trav_t **trav) {
 ^~~~~~~~~
 mpc_mem_t
mpc.c:3020:34: error: unknown type name ‘mpc_ast_trav_t’; did you mean ‘mpc_pdata_t’?
 mpc_ast_t *mpc_ast_traverse_next(mpc_ast_trav_t **trav) {
                                  ^~~~~~~~~~~~~~
                                  mpc_pdata_t
mpc.c:3103:28: error: unknown type name ‘mpc_ast_trav_t’; did you mean ‘mpc_pdata_t’?
 void mpc_ast_traverse_free(mpc_ast_trav_t **trav) {
                            ^~~~~~~~~~~~~~
                            mpc_pdata_t
mpc.c:3114:1: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_fold_ast(int n, mpc_val_t **xs) {
 ^~~~~~~~~
 mpc_mem_t
mpc.c:3114:33: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_fold_ast(int n, mpc_val_t **xs) {
                                 ^~~~~~~~~
                                 mpc_mem_t
mpc.c:3152:1: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_str_ast(mpc_val_t *c) {
 ^~~~~~~~~
 mpc_mem_t
mpc.c:3152:25: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_str_ast(mpc_val_t *c) {
                         ^~~~~~~~~
                         mpc_mem_t
mpc.c:3158:1: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_state_ast(int n, mpc_val_t **xs) {
 ^~~~~~~~~
 mpc_mem_t
mpc.c:3158:34: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 mpc_val_t *mpcf_state_ast(int n, mpc_val_t **xs) {
                                  ^~~~~~~~~
                                  mpc_mem_t
mpc.c:3167:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpca_state(mpc_parser_t *a) {
 ^~~~~~~~~~~~
 struct 
mpc.c:3167:26: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 mpc_parser_t *mpca_state(mpc_parser_t *a) {
                          ^~~~~~~~~~~~
                          mp_prec_t
mpc.c:3171:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpca_tag(mpc_parser_t *a, const char *t) {
 ^~~~~~~~~~~~
 struct 
mpc.c:3171:24: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 mpc_parser_t *mpca_tag(mpc_parser_t *a, const char *t) {
                        ^~~~~~~~~~~~
                        mp_prec_t
mpc.c:3175:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpca_add_tag(mpc_parser_t *a, const char *t) {
 ^~~~~~~~~~~~
 struct 
mpc.c:3175:28: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 mpc_parser_t *mpca_add_tag(mpc_parser_t *a, const char *t) {
                            ^~~~~~~~~~~~
                            mp_prec_t
mpc.c:3179:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpca_root(mpc_parser_t *a) {
 ^~~~~~~~~~~~
 struct 
mpc.c:3179:25: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 mpc_parser_t *mpca_root(mpc_parser_t *a) {
                         ^~~~~~~~~~~~
                         mp_prec_t
mpc.c:3183:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpca_not(mpc_parser_t *a) { return mpc_not(a, (mpc_dtor_t)mpc_ast_delete); }
 ^~~~~~~~~~~~
 struct 
mpc.c:3183:24: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 mpc_parser_t *mpca_not(mpc_parser_t *a) { return mpc_not(a, (mpc_dtor_t)mpc_ast_delete); }
                        ^~~~~~~~~~~~
                        mp_prec_t
mpc.c:3184:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpca_maybe(mpc_parser_t *a) { return mpc_maybe(a); }
 ^~~~~~~~~~~~
 struct 
mpc.c:3184:26: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 mpc_parser_t *mpca_maybe(mpc_parser_t *a) { return mpc_maybe(a); }
                          ^~~~~~~~~~~~
                          mp_prec_t
mpc.c:3185:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpca_many(mpc_parser_t *a) { return mpc_many(mpcf_fold_ast, a); }
 ^~~~~~~~~~~~
 struct 
mpc.c:3185:25: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 mpc_parser_t *mpca_many(mpc_parser_t *a) { return mpc_many(mpcf_fold_ast, a); }
                         ^~~~~~~~~~~~
                         mp_prec_t
mpc.c:3186:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpca_many1(mpc_parser_t *a) { return mpc_many1(mpcf_fold_ast, a); }
 ^~~~~~~~~~~~
 struct 
mpc.c:3186:26: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 mpc_parser_t *mpca_many1(mpc_parser_t *a) { return mpc_many1(mpcf_fold_ast, a); }
                          ^~~~~~~~~~~~
                          mp_prec_t
mpc.c:3187:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpca_count(int n, mpc_parser_t *a) { return mpc_count(n, mpcf_fold_ast, a, (mpc_dtor_t)mpc_ast_delete); }
 ^~~~~~~~~~~~
 struct 
mpc.c:3187:33: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 mpc_parser_t *mpca_count(int n, mpc_parser_t *a) { return mpc_count(n, mpcf_fold_ast, a, (mpc_dtor_t)mpc_ast_delete); }
                                 ^~~~~~~~~~~~
                                 mp_prec_t
mpc.c:3189:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpca_or(int n, ...) {
 ^~~~~~~~~~~~
 struct 
mpc.c: In function ‘mpca_or’:
mpc.c:3192:3: error: unknown type name ‘va_list’
   va_list va;
   ^~~~~~~
mpc.c:3192:3: note: ‘va_list’ is defined in header ‘<stdarg.h>’; did you forget to ‘#include <stdarg.h>’?
mpc.c:3194:3: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
   mpc_parser_t *p = mpc_undefined();
   ^~~~~~~~~~~~
   struct 
mpc.c:3196:4: error: request for member ‘type’ in something not a structure or union
   p->type = MPC_TYPE_OR;
    ^~
mpc.c:3197:4: error: request for member ‘data’ in something not a structure or union
   p->data.or.n = n;
    ^~
mpc.c:3198:4: error: request for member ‘data’ in something not a structure or union
   p->data.or.xs = malloc(sizeof(mpc_parser_t*) * n);
    ^~
mpc.c:3198:19: warning: incompatible implicit declaration of built-in function ‘malloc’
   p->data.or.xs = malloc(sizeof(mpc_parser_t*) * n);
                   ^~~~~~
mpc.c:3198:19: note: include ‘<stdlib.h>’ or provide a declaration of ‘malloc’
mpc.c:3198:33: error: ‘mpc_parser_t’ undeclared (first use in this function)
   p->data.or.xs = malloc(sizeof(mpc_parser_t*) * n);
                                 ^~~~~~~~~~~~
mpc.c:3198:46: error: expected expression before ‘)’ token
   p->data.or.xs = malloc(sizeof(mpc_parser_t*) * n);
                                              ^
mpc.c:3202:6: error: request for member ‘data’ in something not a structure or union
     p->data.or.xs[i] = va_arg(va, mpc_parser_t*);
      ^~
mpc.c:3202:48: error: expected expression before ‘)’ token
     p->data.or.xs[i] = va_arg(va, mpc_parser_t*);
                                                ^
mpc.c: At top level:
mpc.c:3210:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpca_and(int n, ...) {
 ^~~~~~~~~~~~
 struct 
mpc.c: In function ‘mpca_and’:
mpc.c:3213:3: error: unknown type name ‘va_list’
   va_list va;
   ^~~~~~~
mpc.c:3213:3: note: ‘va_list’ is defined in header ‘<stdarg.h>’; did you forget to ‘#include <stdarg.h>’?
mpc.c:3215:3: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
   mpc_parser_t *p = mpc_undefined();
   ^~~~~~~~~~~~
   struct 
mpc.c:3217:4: error: request for member ‘type’ in something not a structure or union
   p->type = MPC_TYPE_AND;
    ^~
mpc.c:3218:4: error: request for member ‘data’ in something not a structure or union
   p->data.and.n = n;
    ^~
mpc.c:3219:4: error: request for member ‘data’ in something not a structure or union
   p->data.and.f = mpcf_fold_ast;
    ^~
mpc.c:3219:19: error: ‘mpcf_fold_ast’ undeclared (first use in this function); did you mean ‘mpc_float’?
   p->data.and.f = mpcf_fold_ast;
                   ^~~~~~~~~~~~~
                   mpc_float
mpc.c:3220:4: error: request for member ‘data’ in something not a structure or union
   p->data.and.xs = malloc(sizeof(mpc_parser_t*) * n);
    ^~
mpc.c:3220:20: warning: incompatible implicit declaration of built-in function ‘malloc’
   p->data.and.xs = malloc(sizeof(mpc_parser_t*) * n);
                    ^~~~~~
mpc.c:3220:20: note: include ‘<stdlib.h>’ or provide a declaration of ‘malloc’
mpc.c:3220:34: error: ‘mpc_parser_t’ undeclared (first use in this function)
   p->data.and.xs = malloc(sizeof(mpc_parser_t*) * n);
                                  ^~~~~~~~~~~~
mpc.c:3220:47: error: expected expression before ‘)’ token
   p->data.and.xs = malloc(sizeof(mpc_parser_t*) * n);
                                               ^
mpc.c:3221:4: error: request for member ‘data’ in something not a structure or union
   p->data.and.dxs = malloc(sizeof(mpc_dtor_t) * (n-1));
    ^~
mpc.c:3221:35: error: ‘mpc_dtor_t’ undeclared (first use in this function); did you mean ‘mpcf_ctor_str’?
   p->data.and.dxs = malloc(sizeof(mpc_dtor_t) * (n-1));
                                   ^~~~~~~~~~
                                   mpcf_ctor_str
mpc.c:3225:6: error: request for member ‘data’ in something not a structure or union
     p->data.and.xs[i] = va_arg(va, mpc_parser_t*);
      ^~
mpc.c:3225:49: error: expected expression before ‘)’ token
     p->data.and.xs[i] = va_arg(va, mpc_parser_t*);
                                                 ^
mpc.c:3228:6: error: request for member ‘data’ in something not a structure or union
     p->data.and.dxs[i] = (mpc_dtor_t)mpc_ast_delete;
      ^~
mpc.c:3228:38: error: expected ‘;’ before ‘mpc_ast_delete’
     p->data.and.dxs[i] = (mpc_dtor_t)mpc_ast_delete;
                                      ^~~~~~~~~~~~~~
                                      ;
mpc.c: At top level:
mpc.c:3235:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpca_total(mpc_parser_t *a) { return mpc_total(a, (mpc_dtor_t)mpc_ast_delete); }
 ^~~~~~~~~~~~
 struct 
mpc.c:3235:26: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 mpc_parser_t *mpca_total(mpc_parser_t *a) { return mpc_total(a, (mpc_dtor_t)mpc_ast_delete); }
                          ^~~~~~~~~~~~
                          mp_prec_t
mpc.c:3282:3: error: unknown type name ‘va_list’
   va_list *va;
   ^~~~~~~
mpc.c:3284:3: error: unknown type name ‘mpc_parser_t’
   mpc_parser_t **parsers;
   ^~~~~~~~~~~~
mpc.c:3288:8: error: unknown type name ‘mpc_val_t’
 static mpc_val_t *mpcaf_grammar_or(int n, mpc_val_t **xs) {
        ^~~~~~~~~
mpc.c:3288:43: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 static mpc_val_t *mpcaf_grammar_or(int n, mpc_val_t **xs) {
                                           ^~~~~~~~~
                                           mpc_mem_t
mpc.c:3294:8: error: unknown type name ‘mpc_val_t’
 static mpc_val_t *mpcaf_grammar_and(int n, mpc_val_t **xs) {
        ^~~~~~~~~
mpc.c:3294:44: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 static mpc_val_t *mpcaf_grammar_and(int n, mpc_val_t **xs) {
                                            ^~~~~~~~~
                                            mpc_mem_t
mpc.c:3303:8: error: unknown type name ‘mpc_val_t’
 static mpc_val_t *mpcaf_grammar_repeat(int n, mpc_val_t **xs) {
        ^~~~~~~~~
mpc.c:3303:47: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 static mpc_val_t *mpcaf_grammar_repeat(int n, mpc_val_t **xs) {
                                               ^~~~~~~~~
                                               mpc_mem_t
mpc.c:3320:8: error: unknown type name ‘mpc_val_t’
 static mpc_val_t *mpcaf_grammar_string(mpc_val_t *x, void *s) {
        ^~~~~~~~~
mpc.c:3320:40: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 static mpc_val_t *mpcaf_grammar_string(mpc_val_t *x, void *s) {
                                        ^~~~~~~~~
                                        mpc_mem_t
mpc.c:3328:8: error: unknown type name ‘mpc_val_t’
 static mpc_val_t *mpcaf_grammar_char(mpc_val_t *x, void *s) {
        ^~~~~~~~~
mpc.c:3328:38: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 static mpc_val_t *mpcaf_grammar_char(mpc_val_t *x, void *s) {
                                      ^~~~~~~~~
                                      mpc_mem_t
mpc.c:3336:8: error: unknown type name ‘mpc_val_t’
 static mpc_val_t *mpcaf_grammar_regex(mpc_val_t *x, void *s) {
        ^~~~~~~~~
mpc.c:3336:39: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 static mpc_val_t *mpcaf_grammar_regex(mpc_val_t *x, void *s) {
                                       ^~~~~~~~~
                                       mpc_mem_t
mpc.c: In function ‘is_number’:
mpc.c:3347:19: warning: incompatible implicit declaration of built-in function ‘strlen’
   for (i = 0; i < strlen(s); i++) { if (!strchr("0123456789", s[i])) { return 0; } }
                   ^~~~~~
mpc.c:3347:19: note: include ‘<string.h>’ or provide a declaration of ‘strlen’
mpc.c:3347:42: warning: incompatible implicit declaration of built-in function ‘strchr’
   for (i = 0; i < strlen(s); i++) { if (!strchr("0123456789", s[i])) { return 0; } }
                                          ^~~~~~
mpc.c:3347:42: note: include ‘<string.h>’ or provide a declaration of ‘strchr’
mpc.c: At top level:
mpc.c:3351:8: error: unknown type name ‘mpc_parser_t’
 static mpc_parser_t *mpca_grammar_find_parser(char *x, mpca_grammar_st_t *st) {
        ^~~~~~~~~~~~
mpc.c: In function ‘mpca_grammar_find_parser’:
mpc.c:3354:3: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
   mpc_parser_t *p;
   ^~~~~~~~~~~~
   struct 
mpc.c:3359:9: warning: implicit declaration of function ‘strtol’ [-Wimplicit-function-declaration]
     i = strtol(x, NULL, 10);
         ^~~~~~
mpc.c:3363:21: warning: incompatible implicit declaration of built-in function ‘realloc’
       st->parsers = realloc(st->parsers, sizeof(mpc_parser_t*) * st->parsers_num);
                     ^~~~~~~
mpc.c:3363:21: note: include ‘<stdlib.h>’ or provide a declaration of ‘realloc’
mpc.c:3363:49: error: ‘mpc_parser_t’ undeclared (first use in this function)
       st->parsers = realloc(st->parsers, sizeof(mpc_parser_t*) * st->parsers_num);
                                                 ^~~~~~~~~~~~
mpc.c:3363:62: error: expected expression before ‘)’ token
       st->parsers = realloc(st->parsers, sizeof(mpc_parser_t*) * st->parsers_num);
                                                              ^
mpc.c:3364:69: error: expected expression before ‘)’ token
       st->parsers[st->parsers_num-1] = va_arg(*st->va, mpc_parser_t*);
                                                                     ^
mpc.c:3377:21: error: ‘q’ undeclared (first use in this function)
       mpc_parser_t *q = st->parsers[i];
                     ^
mpc.c:3379:22: warning: implicit declaration of function ‘strcmp’ [-Wimplicit-function-declaration]
       if (q->name && strcmp(q->name, x) == 0) { return q; }
                      ^~~~~~
mpc.c:3385:40: error: expected expression before ‘)’ token
       p = va_arg(*st->va, mpc_parser_t*);
                                        ^
mpc.c:3388:21: warning: incompatible implicit declaration of built-in function ‘realloc’
       st->parsers = realloc(st->parsers, sizeof(mpc_parser_t*) * st->parsers_num);
                     ^~~~~~~
mpc.c:3388:21: note: include ‘<stdlib.h>’ or provide a declaration of ‘realloc’
mpc.c:3388:62: error: expected expression before ‘)’ token
       st->parsers = realloc(st->parsers, sizeof(mpc_parser_t*) * st->parsers_num);
                                                              ^
mpc.c:3391:25: error: request for member ‘name’ in something not a structure or union
       if (p == NULL || p->name == NULL) { return mpc_failf("Unknown Parser '%s'!", x); }
                         ^~
mpc.c:3392:12: error: request for member ‘name’ in something not a structure or union
       if (p->name && strcmp(p->name, x) == 0) { return p; }
            ^~
mpc.c:3392:30: error: request for member ‘name’ in something not a structure or union
       if (p->name && strcmp(p->name, x) == 0) { return p; }
                              ^~
mpc.c: At top level:
mpc.c:3400:8: error: unknown type name ‘mpc_val_t’
 static mpc_val_t *mpcaf_grammar_id(mpc_val_t *x, void *s) {
        ^~~~~~~~~
mpc.c:3400:36: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 static mpc_val_t *mpcaf_grammar_id(mpc_val_t *x, void *s) {
                                    ^~~~~~~~~
                                    mpc_mem_t
mpc.c:3413:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpca_grammar_st(const char *grammar, mpca_grammar_st_t *st) {
 ^~~~~~~~~~~~
 struct 
mpc.c: In function ‘mpca_grammar_st’:
mpc.c:3416:3: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
   mpc_parser_t *err_out;
   ^~~~~~~~~~~~
   struct 
mpc.c:3417:3: error: unknown type name ‘mpc_result_t’; did you mean ‘mpc_input_t’?
   mpc_result_t r;
   ^~~~~~~~~~~~
   mpc_input_t
mpc.c:3418:3: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
   mpc_parser_t *GrammarTotal, *Grammar, *Term, *Factor, *Base;
   ^~~~~~~~~~~~
   struct 
mpc.c:3427:20: warning: implicit declaration of function ‘mpc_total’; did you mean ‘mpc_real’? [-Wimplicit-function-declaration]
     mpc_predictive(mpc_total(Grammar, mpc_soft_delete))
                    ^~~~~~~~~
                    mpc_real
mpc.c:3427:39: error: ‘mpc_soft_delete’ undeclared (first use in this function); did you mean ‘mpc_input_delete’?
     mpc_predictive(mpc_total(Grammar, mpc_soft_delete))
                                       ^~~~~~~~~~~~~~~
                                       mpc_input_delete
mpc.c:3430:34: error: ‘mpcaf_grammar_or’ undeclared (first use in this function); did you mean ‘mpca_grammar_st’?
   mpc_define(Grammar, mpc_and(2, mpcaf_grammar_or,
                                  ^~~~~~~~~~~~~~~~
                                  mpca_grammar_st
mpc.c:3432:26: error: ‘mpcf_snd_free’ undeclared (first use in this function); did you mean ‘mpc_free’?
     mpc_maybe(mpc_and(2, mpcf_snd_free, mpc_sym("|"), Grammar, free)),
                          ^~~~~~~~~~~~~
                          mpc_free
mpc.c:3432:64: error: ‘free’ undeclared (first use in this function)
     mpc_maybe(mpc_and(2, mpcf_snd_free, mpc_sym("|"), Grammar, free)),
                                                                ^~~~
mpc.c:3432:64: note: ‘free’ is defined in header ‘<stdlib.h>’; did you forget to ‘#include <stdlib.h>’?
mpc.c:3436:30: error: ‘mpcaf_grammar_and’ undeclared (first use in this function); did you mean ‘mpca_grammar_st’?
   mpc_define(Term, mpc_many1(mpcaf_grammar_and, Factor));
                              ^~~~~~~~~~~~~~~~~
                              mpca_grammar_st
mpc.c:3438:33: error: ‘mpcaf_grammar_repeat’ undeclared (first use in this function); did you mean ‘mpca_grammar_st’?
   mpc_define(Factor, mpc_and(2, mpcaf_grammar_repeat,
                                 ^~~~~~~~~~~~~~~~~~~~
                                 mpca_grammar_st
mpc.c:3445:9: warning: implicit declaration of function ‘mpc_tok_brackets’ [-Wimplicit-function-declaration]
         mpc_tok_brackets(mpc_int(), free),
         ^~~~~~~~~~~~~~~~
mpc.c:3451:5: warning: implicit declaration of function ‘mpc_apply_to’; did you mean ‘mpc_float’? [-Wimplicit-function-declaration]
     mpc_apply_to(mpc_tok(mpc_string_lit()), mpcaf_grammar_string, st),
     ^~~~~~~~~~~~
     mpc_float
mpc.c:3451:45: error: ‘mpcaf_grammar_string’ undeclared (first use in this function); did you mean ‘mpca_grammar_st’?
     mpc_apply_to(mpc_tok(mpc_string_lit()), mpcaf_grammar_string, st),
                                             ^~~~~~~~~~~~~~~~~~~~
                                             mpca_grammar_st
mpc.c:3452:45: error: ‘mpcaf_grammar_char’ undeclared (first use in this function); did you mean ‘mpca_grammar_st’?
     mpc_apply_to(mpc_tok(mpc_char_lit()),   mpcaf_grammar_char, st),
                                             ^~~~~~~~~~~~~~~~~~
                                             mpca_grammar_st
mpc.c:3453:45: error: ‘mpcaf_grammar_regex’ undeclared (first use in this function); did you mean ‘mpca_grammar_st’?
     mpc_apply_to(mpc_tok(mpc_regex_lit()),  mpcaf_grammar_regex, st),
                                             ^~~~~~~~~~~~~~~~~~~
                                             mpca_grammar_st
mpc.c:3454:18: warning: implicit declaration of function ‘mpc_tok_braces’; did you mean ‘mpc_whitespaces’? [-Wimplicit-function-declaration]
     mpc_apply_to(mpc_tok_braces(mpc_or(2, mpc_digits(), mpc_ident()), free), mpcaf_grammar_id, st),
                  ^~~~~~~~~~~~~~
                  mpc_whitespaces
mpc.c:3454:78: error: ‘mpcaf_grammar_id’ undeclared (first use in this function); did you mean ‘mpca_grammar_st’?
     mpc_apply_to(mpc_tok_braces(mpc_or(2, mpc_digits(), mpc_ident()), free), mpcaf_grammar_id, st),
                                                                              ^~~~~~~~~~~~~~~~
                                                                              mpca_grammar_st
mpc.c:3455:5: warning: implicit declaration of function ‘mpc_tok_parens’; did you mean ‘mpc_set_prec’? [-Wimplicit-function-declaration]
     mpc_tok_parens(Grammar, mpc_soft_delete)
     ^~~~~~~~~~~~~~
     mpc_set_prec
mpc.c:3465:31: error: request for member ‘error’ in something not a structure or union
     err_msg = mpc_err_string(r.error);
                               ^
mpc.c:3467:21: error: request for member ‘error’ in something not a structure or union
     mpc_err_delete(r.error);
                     ^
mpc.c:3468:5: warning: incompatible implicit declaration of built-in function ‘free’
     free(err_msg);
     ^~~~
mpc.c:3468:5: note: include ‘<stdlib.h>’ or provide a declaration of ‘free’
mpc.c:3469:6: error: request for member ‘output’ in something not a structure or union
     r.output = err_out;
      ^
mpc.c:3474:17: error: request for member ‘output’ in something not a structure or union
   mpc_optimise(r.output);
                 ^
mpc.c:3476:23: error: ‘MPCA_LANG_PREDICTIVE’ undeclared (first use in this function); did you mean ‘MPC_TYPE_PREDICT’?
   return (st->flags & MPCA_LANG_PREDICTIVE) ? mpc_predictive(r.output) : r.output;
                       ^~~~~~~~~~~~~~~~~~~~
                       MPC_TYPE_PREDICT
mpc.c:3476:63: error: request for member ‘output’ in something not a structure or union
   return (st->flags & MPCA_LANG_PREDICTIVE) ? mpc_predictive(r.output) : r.output;
                                                               ^
mpc.c:3476:75: error: request for member ‘output’ in something not a structure or union
   return (st->flags & MPCA_LANG_PREDICTIVE) ? mpc_predictive(r.output) : r.output;
                                                                           ^
mpc.c: At top level:
mpc.c:3480:1: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
 mpc_parser_t *mpca_grammar(int flags, const char *grammar, ...) {
 ^~~~~~~~~~~~
 struct 
mpc.c: In function ‘mpca_grammar’:
mpc.c:3482:3: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
   mpc_parser_t *res;
   ^~~~~~~~~~~~
   struct 
mpc.c:3483:3: error: unknown type name ‘va_list’
   va_list va;
   ^~~~~~~
mpc.c:3483:3: note: ‘va_list’ is defined in header ‘<stdarg.h>’; did you forget to ‘#include <stdarg.h>’?
mpc.c:3492:3: warning: incompatible implicit declaration of built-in function ‘free’
   free(st.parsers);
   ^~~~
mpc.c:3492:3: note: include ‘<stdlib.h>’ or provide a declaration of ‘free’
mpc.c: At top level:
mpc.c:3500:3: error: unknown type name ‘mpc_parser_t’
   mpc_parser_t *grammar;
   ^~~~~~~~~~~~
mpc.c:3503:8: error: unknown type name ‘mpc_val_t’
 static mpc_val_t *mpca_stmt_afold(int n, mpc_val_t **xs) {
        ^~~~~~~~~
mpc.c:3503:42: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 static mpc_val_t *mpca_stmt_afold(int n, mpc_val_t **xs) {
                                          ^~~~~~~~~
                                          mpc_mem_t
mpc.c:3515:8: error: unknown type name ‘mpc_val_t’
 static mpc_val_t *mpca_stmt_fold(int n, mpc_val_t **xs) {
        ^~~~~~~~~
mpc.c:3515:41: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 static mpc_val_t *mpca_stmt_fold(int n, mpc_val_t **xs) {
                                         ^~~~~~~~~
                                         mpc_mem_t
mpc.c:3528:35: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 static void mpca_stmt_list_delete(mpc_val_t *x) {
                                   ^~~~~~~~~
                                   mpc_mem_t
mpc.c:3544:8: error: unknown type name ‘mpc_val_t’
 static mpc_val_t *mpca_stmt_list_apply_to(mpc_val_t *x, void *s) {
        ^~~~~~~~~
mpc.c:3544:43: error: unknown type name ‘mpc_val_t’; did you mean ‘mpc_mem_t’?
 static mpc_val_t *mpca_stmt_list_apply_to(mpc_val_t *x, void *s) {
                                           ^~~~~~~~~
                                           mpc_mem_t
mpc.c:3569:8: error: unknown type name ‘mpc_err_t’
 static mpc_err_t *mpca_lang_st(mpc_input_t *i, mpca_grammar_st_t *st) {
        ^~~~~~~~~
mpc.c: In function ‘mpca_lang_st’:
mpc.c:3571:3: error: unknown type name ‘mpc_result_t’; did you mean ‘mpc_input_t’?
   mpc_result_t r;
   ^~~~~~~~~~~~
   mpc_input_t
mpc.c:3572:3: error: unknown type name ‘mpc_err_t’; did you mean ‘mpc_mem_t’?
   mpc_err_t *e;
   ^~~~~~~~~
   mpc_mem_t
mpc.c:3573:3: error: unknown type name ‘mpc_parser_t’; use ‘struct’ keyword to refer to the type
   mpc_parser_t *Lang, *Stmt, *Grammar, *Term, *Factor, *Base;
   ^~~~~~~~~~~~
   struct 
mpc.c:3583:39: error: ‘mpca_stmt_fold’ undeclared (first use in this function); did you mean ‘mpca_stmt_t’?
     mpc_total(mpc_predictive(mpc_many(mpca_stmt_fold, Stmt)), mpca_stmt_list_delete),
                                       ^~~~~~~~~~~~~~
                                       mpca_stmt_t
mpc.c:3583:63: error: ‘mpca_stmt_list_delete’ undeclared (first use in this function); did you mean ‘mpc_input_delete’?
     mpc_total(mpc_predictive(mpc_many(mpca_stmt_fold, Stmt)), mpca_stmt_list_delete),
                                                               ^~~~~~~~~~~~~~~~~~~~~
                                                               mpc_input_delete
mpc.c:3584:5: error: ‘mpca_stmt_list_apply_to’ undeclared (first use in this function); did you mean ‘mpc_pdata_apply_t’?
     mpca_stmt_list_apply_to, st
     ^~~~~~~~~~~~~~~~~~~~~~~
     mpc_pdata_apply_t
mpc.c:3587:31: error: ‘mpca_stmt_afold’ undeclared (first use in this function); did you mean ‘mpca_stmt_t’?
   mpc_define(Stmt, mpc_and(5, mpca_stmt_afold,
                               ^~~~~~~~~~~~~~~
                               mpca_stmt_t
mpc.c:3589:5: error: ‘free’ undeclared (first use in this function)
     free, free, free, mpc_soft_delete
     ^~~~
mpc.c:3589:5: note: ‘free’ is defined in header ‘<stdlib.h>’; did you forget to ‘#include <stdlib.h>’?
mpc.c:3589:23: error: ‘mpc_soft_delete’ undeclared (first use in this function); did you mean ‘mpc_input_delete’?
     free, free, free, mpc_soft_delete
                       ^~~~~~~~~~~~~~~
                       mpc_input_delete
mpc.c:3592:34: error: ‘mpcaf_grammar_or’ undeclared (first use in this function); did you mean ‘mpca_grammar_st’?
   mpc_define(Grammar, mpc_and(2, mpcaf_grammar_or,
                                  ^~~~~~~~~~~~~~~~
                                  mpca_grammar_st
mpc.c:3594:28: error: ‘mpcf_snd_free’ undeclared (first use in this function); did you mean ‘mpc_free’?
       mpc_maybe(mpc_and(2, mpcf_snd_free, mpc_sym("|"), Grammar, free)),
                            ^~~~~~~~~~~~~
                            mpc_free
mpc.c:3598:30: error: ‘mpcaf_grammar_and’ undeclared (first use in this function); did you mean ‘mpca_grammar_st’?
   mpc_define(Term, mpc_many1(mpcaf_grammar_and, Factor));
                              ^~~~~~~~~~~~~~~~~
                              mpca_grammar_st
mpc.c:3600:33: error: ‘mpcaf_grammar_repeat’ undeclared (first use in this function); did you mean ‘mpca_grammar_st’?
   mpc_define(Factor, mpc_and(2, mpcaf_grammar_repeat,
                                 ^~~~~~~~~~~~~~~~~~~~
                                 mpca_grammar_st
mpc.c:3613:45: error: ‘mpcaf_grammar_string’ undeclared (first use in this function); did you mean ‘mpca_grammar_st’?
     mpc_apply_to(mpc_tok(mpc_string_lit()), mpcaf_grammar_string, st),
                                             ^~~~~~~~~~~~~~~~~~~~
                                             mpca_grammar_st
mpc.c:3614:45: error: ‘mpcaf_grammar_char’ undeclared (first use in this function); did you mean ‘mpca_grammar_st’?
     mpc_apply_to(mpc_tok(mpc_char_lit()),   mpcaf_grammar_char, st),
                                             ^~~~~~~~~~~~~~~~~~
                                             mpca_grammar_st
mpc.c:3615:45: error: ‘mpcaf_grammar_regex’ undeclared (first use in this function); did you mean ‘mpca_grammar_st’?
     mpc_apply_to(mpc_tok(mpc_regex_lit()),  mpcaf_grammar_regex, st),
                                             ^~~~~~~~~~~~~~~~~~~
                                             mpca_grammar_st
mpc.c:3616:78: error: ‘mpcaf_grammar_id’ undeclared (first use in this function); did you mean ‘mpca_grammar_st’?
     mpc_apply_to(mpc_tok_braces(mpc_or(2, mpc_digits(), mpc_ident()), free), mpcaf_grammar_id, st),
                                                                              ^~~~~~~~~~~~~~~~
                                                                              mpca_grammar_st
mpc.c:3627:8: warning: implicit declaration of function ‘mpc_parse_input’; did you mean ‘mpc_ast_new’? [-Wimplicit-function-declaration]
   if (!mpc_parse_input(i, Lang, &r)) {
        ^~~~~~~~~~~~~~~
        mpc_ast_new
mpc.c:3628:10: error: request for member ‘error’ in something not a structure or union
     e = r.error;
          ^
mpc.c: At top level:
mpc.c:3638:1: error: unknown type name ‘mpc_err_t’; did you mean ‘mpc_mem_t’?
 mpc_err_t *mpca_lang_file(int flags, FILE *f, ...) {
 ^~~~~~~~~
 mpc_mem_t
mpc.c:3638:38: error: unknown type name ‘FILE’
 mpc_err_t *mpca_lang_file(int flags, FILE *f, ...) {
                                      ^~~~
mpc.c:3638:38: note: ‘FILE’ is defined in header ‘<stdio.h>’; did you forget to ‘#include <stdio.h>’?
mpc.c:3660:1: error: unknown type name ‘mpc_err_t’; did you mean ‘mpc_mem_t’?
 mpc_err_t *mpca_lang_pipe(int flags, FILE *p, ...) {
 ^~~~~~~~~
 mpc_mem_t
mpc.c:3660:38: error: unknown type name ‘FILE’
 mpc_err_t *mpca_lang_pipe(int flags, FILE *p, ...) {
                                      ^~~~
mpc.c:3660:38: note: ‘FILE’ is defined in header ‘<stdio.h>’; did you forget to ‘#include <stdio.h>’?
mpc.c:3682:1: error: unknown type name ‘mpc_err_t’; did you mean ‘mpc_mem_t’?
 mpc_err_t *mpca_lang(int flags, const char *language, ...) {
 ^~~~~~~~~
 mpc_mem_t
mpc.c: In function ‘mpca_lang’:
mpc.c:3686:3: error: unknown type name ‘mpc_err_t’; did you mean ‘mpc_mem_t’?
   mpc_err_t *err;
   ^~~~~~~~~
   mpc_mem_t
mpc.c:3688:3: error: unknown type name ‘va_list’
   va_list va;
   ^~~~~~~
mpc.c:3688:3: note: ‘va_list’ is defined in header ‘<stdarg.h>’; did you forget to ‘#include <stdarg.h>’?
mpc.c:3700:3: warning: incompatible implicit declaration of built-in function ‘free’
   free(st.parsers);
   ^~~~
mpc.c:3700:3: note: include ‘<stdlib.h>’ or provide a declaration of ‘free’
mpc.c: At top level:
mpc.c:3705:1: error: unknown type name ‘mpc_err_t’; did you mean ‘mpc_mem_t’?
 mpc_err_t *mpca_lang_contents(int flags, const char *filename, ...) {
 ^~~~~~~~~
 mpc_mem_t
mpc.c: In function ‘mpca_lang_contents’:
mpc.c:3709:3: error: unknown type name ‘mpc_err_t’; did you mean ‘mpc_mem_t’?
   mpc_err_t *err;
   ^~~~~~~~~
   mpc_mem_t
mpc.c:3711:3: error: unknown type name ‘va_list’
   va_list va;
   ^~~~~~~
mpc.c:3711:3: note: ‘va_list’ is defined in header ‘<stdarg.h>’; did you forget to ‘#include <stdarg.h>’?
mpc.c:3713:3: error: unknown type name ‘FILE’
   FILE *f = fopen(filename, "rb");
   ^~~~
mpc.c:3713:3: note: ‘FILE’ is defined in header ‘<stdio.h>’; did you forget to ‘#include <stdio.h>’?
mpc.c:3713:13: warning: implicit declaration of function ‘fopen’ [-Wimplicit-function-declaration]
   FILE *f = fopen(filename, "rb");
             ^~~~~
mpc.c:3713:13: note: ‘fopen’ is defined in header ‘<stdio.h>’; did you forget to ‘#include <stdio.h>’?
mpc.c:3713:13: warning: initialization of ‘int *’ from ‘int’ makes pointer from integer without a cast [-Wint-conversion]
mpc.c:3727:7: warning: implicit declaration of function ‘mpc_input_new_file’; did you mean ‘mpc_input_rewind’? [-Wimplicit-function-declaration]
   i = mpc_input_new_file(filename, f);
       ^~~~~~~~~~~~~~~~~~
       mpc_input_rewind
mpc.c:3727:5: warning: assignment to ‘mpc_input_t *’ {aka ‘struct <anonymous> *’} from ‘int’ makes pointer from integer without a cast [-Wint-conversion]
   i = mpc_input_new_file(filename, f);
     ^
mpc.c:3731:3: warning: incompatible implicit declaration of built-in function ‘free’
   free(st.parsers);
   ^~~~
mpc.c:3731:3: note: include ‘<stdlib.h>’ or provide a declaration of ‘free’
mpc.c:3734:3: warning: implicit declaration of function ‘fclose’ [-Wimplicit-function-declaration]
   fclose(f);
   ^~~~~~
mpc.c: At top level:
mpc.c:3739:37: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 static int mpc_nodecount_unretained(mpc_parser_t* p, int force) {
                                     ^~~~~~~~~~~~
                                     mp_prec_t
mpc.c:3781:16: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 void mpc_stats(mpc_parser_t* p) {
                ^~~~~~~~~~~~
                mp_prec_t
mpc.c:3787:37: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 static void mpc_optimise_unretained(mpc_parser_t *p, int force) {
                                     ^~~~~~~~~~~~
                                     mp_prec_t
mpc.c:3956:19: error: unknown type name ‘mpc_parser_t’; did you mean ‘mp_prec_t’?
 void mpc_optimise(mpc_parser_t *p) {
                   ^~~~~~~~~~~~
                   mp_prec_t
mpc.c: In function ‘mpc_input_buffer_in_range’:
mpc.c:358:1: warning: control reaches end of non-void function [-Wreturn-type]
 }
 ^
mpc.c: In function ‘mpc_input_buffer_get’:
mpc.c:362:1: warning: control reaches end of non-void function [-Wreturn-type]
 }
 ^
mpc.c: In function ‘mpc_whitespaces’:
mpc.c:1952:1: warning: control reaches end of non-void function [-Wreturn-type]
 mpc_parser_t *mpc_whitespaces(void) { return mpc_expect(mpc_many(mpcf_strfold, mpc_whitespace()), "spaces"); }
 ^~~~~~~~~~~~
mpc.c: In function ‘mpc_blank’:
mpc.c:1953:1: warning: control reaches end of non-void function [-Wreturn-type]
 mpc_parser_t *mpc_blank(void) { return mpc_expect(mpc_apply(mpc_whitespaces(), mpcf_free), "whitespace"); }
 ^~~~~~~~~~~~
mpc.c: In function ‘mpc_escape’:
mpc.c:1957:1: warning: control reaches end of non-void function [-Wreturn-type]
 mpc_parser_t *mpc_escape(void) { return mpc_and(2, mpcf_strfold, mpc_char('\\'), mpc_any(), free); }
 ^~~~~~~~~~~~
mpc.c: In function ‘mpc_digits’:
mpc.c:1962:1: warning: control reaches end of non-void function [-Wreturn-type]
 mpc_parser_t *mpc_digits(void) { return mpc_expect(mpc_many1(mpcf_strfold, mpc_digit()), "digits"); }
 ^~~~~~~~~~~~
mpc.c: In function ‘mpc_hexdigits’:
mpc.c:1963:1: warning: control reaches end of non-void function [-Wreturn-type]
 mpc_parser_t *mpc_hexdigits(void) { return mpc_expect(mpc_many1(mpcf_strfold, mpc_hexdigit()), "hex digits"); }
 ^~~~~~~~~~~~
mpc.c: In function ‘mpc_octdigits’:
mpc.c:1964:1: warning: control reaches end of non-void function [-Wreturn-type]
 mpc_parser_t *mpc_octdigits(void) { return mpc_expect(mpc_many1(mpcf_strfold, mpc_octdigit()), "oct digits"); }
 ^~~~~~~~~~~~
mpc.c: In function ‘mpc_int’:
mpc.c:1972:1: warning: control reaches end of non-void function [-Wreturn-type]
 mpc_parser_t *mpc_int(void) { return mpc_expect(mpc_apply(mpc_digits(), mpcf_int), "integer"); }
 ^~~~~~~~~~~~
mpc.c: In function ‘mpc_hex’:
mpc.c:1973:1: warning: control reaches end of non-void function [-Wreturn-type]
 mpc_parser_t *mpc_hex(void) { return mpc_expect(mpc_apply(mpc_hexdigits(), mpcf_hex), "hexadecimal"); }
 ^~~~~~~~~~~~
mpc.c: In function ‘mpc_oct’:
mpc.c:1974:1: warning: control reaches end of non-void function [-Wreturn-type]
 mpc_parser_t *mpc_oct(void) { return mpc_expect(mpc_apply(mpc_octdigits(), mpcf_oct), "octadecimal"); }
 ^~~~~~~~~~~~
mpc.c: In function ‘mpc_real’:
mpc.c:1993:1: warning: control reaches end of non-void function [-Wreturn-type]
 }
 ^
mpc.c: In function ‘mpc_float’:
mpc.c:1997:1: warning: control reaches end of non-void function [-Wreturn-type]
 }
 ^
mpc.c: In function ‘mpc_char_lit’:
mpc.c:2001:1: warning: control reaches end of non-void function [-Wreturn-type]
 }
 ^
mpc.c: In function ‘mpc_string_lit’:
mpc.c:2006:1: warning: control reaches end of non-void function [-Wreturn-type]
 }
 ^
mpc.c: In function ‘mpc_regex_lit’:
mpc.c:2011:1: warning: control reaches end of non-void function [-Wreturn-type]
 }
 ^
mpc.c: In function ‘mpc_ident’:
mpc.c:2018:1: warning: control reaches end of non-void function [-Wreturn-type]
 }
 ^
mpc.c: In function ‘mpc_re’:
mpc.c:2331:1: warning: control reaches end of non-void function [-Wreturn-type]
 }
 ^
mpc.c: In function ‘mpca_grammar_st’:
mpc.c:3478:1: warning: control reaches end of non-void function [-Wreturn-type]
 }
 ^
At top level:
mpc.c:3351:22: warning: ‘mpca_grammar_find_parser’ defined but not used [-Wunused-function]
 static mpc_parser_t *mpca_grammar_find_parser(char *x, mpca_grammar_st_t *st) {
                      ^~~~~~~~~~~~~~~~~~~~~~~~
mpc.c:2407:20: warning: ‘mpc_escape_output_raw_cchar’ defined but not used [-Wunused-variable]
 static const char *mpc_escape_output_raw_cchar[] = { "\\'", NULL };
                    ^~~~~~~~~~~~~~~~~~~~~~~~~~~
mpc.c:2406:19: warning: ‘mpc_escape_input_raw_cchar’ defined but not used [-Wunused-const-variable=]
 static const char mpc_escape_input_raw_cchar[] = { '\'' };
                   ^~~~~~~~~~~~~~~~~~~~~~~~~~
mpc.c:2404:20: warning: ‘mpc_escape_output_raw_cstr’ defined but not used [-Wunused-variable]
 static const char *mpc_escape_output_raw_cstr[] = { "\\\"", NULL };
                    ^~~~~~~~~~~~~~~~~~~~~~~~~~
mpc.c:2403:19: warning: ‘mpc_escape_input_raw_cstr’ defined but not used [-Wunused-const-variable=]
 static const char mpc_escape_input_raw_cstr[] = { '"' };
                   ^~~~~~~~~~~~~~~~~~~~~~~~~
mpc.c:2401:20: warning: ‘mpc_escape_output_raw_re’ defined but not used [-Wunused-variable]
 static const char *mpc_escape_output_raw_re[] = { "\\/", NULL };
                    ^~~~~~~~~~~~~~~~~~~~~~~~
mpc.c:2400:19: warning: ‘mpc_escape_input_raw_re’ defined but not used [-Wunused-const-variable=]
 static const char mpc_escape_input_raw_re[] = { '/' };
                   ^~~~~~~~~~~~~~~~~~~~~~~
mpc.c:2396:20: warning: ‘mpc_escape_output_c’ defined but not used [-Wunused-variable]
 static const char *mpc_escape_output_c[] = {
                    ^~~~~~~~~~~~~~~~~~~
mpc.c:2392:19: warning: ‘mpc_escape_input_c’ defined but not used [-Wunused-const-variable=]
 static const char mpc_escape_input_c[]  = {
                   ^~~~~~~~~~~~~~~~~~
mpc.c:2186:20: warning: ‘mpc_re_range_escape_char’ defined but not used [-Wunused-function]
 static const char *mpc_re_range_escape_char(char c) {
                    ^~~~~~~~~~~~~~~~~~~~~~~~
mpc.c:2140:22: warning: ‘mpc_re_escape_char’ defined but not used [-Wunused-function]
 static mpc_parser_t *mpc_re_escape_char(char c) {
                      ^~~~~~~~~~~~~~~~~~
mpc.c:656:19: warning: ‘mpc_err_fail’ defined but not used [-Wunused-function]
 static mpc_err_t *mpc_err_fail(mpc_input_t *i, const char *failure) {
                   ^~~~~~~~~~~~
mpc.c:640:19: warning: ‘mpc_err_new’ defined but not used [-Wunused-function]
 static mpc_err_t *mpc_err_new(mpc_input_t *i, const char *expected) {
                   ^~~~~~~~~~~
mpc.c:580:20: warning: ‘mpc_err_char_unescape’ defined but not used [-Wunused-function]
 static const char *mpc_err_char_unescape(char c) {
                    ^~~~~~~~~~~~~~~~~~~~~
mpc.c:568:13: warning: ‘mpc_err_string_cat’ defined but not used [-Wunused-function]
 static void mpc_err_string_cat(char *buffer, int *pos, int *max, char const *fmt, ...) {
             ^~~~~~~~~~~~~~~~~~
mpc.c:539:21: warning: ‘mpc_input_state_copy’ defined but not used [-Wunused-function]
 static mpc_state_t *mpc_input_state_copy(mpc_input_t *i) {
                     ^~~~~~~~~~~~~~~~~~~~
mpc.c:534:12: warning: ‘mpc_input_anchor’ defined but not used [-Wunused-function]
 static int mpc_input_anchor(mpc_input_t* i, int(*f)(char,char), char **o) {
            ^~~~~~~~~~~~~~~~
mpc.c:515:12: warning: ‘mpc_input_string’ defined but not used [-Wunused-function]
 static int mpc_input_string(mpc_input_t *i, const char *c, char **o) {
            ^~~~~~~~~~~~~~~~
mpc.c:509:12: warning: ‘mpc_input_satisfy’ defined but not used [-Wunused-function]
 static int mpc_input_satisfy(mpc_input_t *i, int(*cond)(char), char **o) {
            ^~~~~~~~~~~~~~~~~
mpc.c:503:12: warning: ‘mpc_input_noneof’ defined but not used [-Wunused-function]
 static int mpc_input_noneof(mpc_input_t *i, const char *c, char **o) {
            ^~~~~~~~~~~~~~~~
mpc.c:497:12: warning: ‘mpc_input_oneof’ defined but not used [-Wunused-function]
 static int mpc_input_oneof(mpc_input_t *i, const char *c, char **o) {
            ^~~~~~~~~~~~~~~
mpc.c:491:12: warning: ‘mpc_input_range’ defined but not used [-Wunused-function]
 static int mpc_input_range(mpc_input_t *i, char c, char d, char **o) {
            ^~~~~~~~~~~~~~~
mpc.c:479:12: warning: ‘mpc_input_any’ defined but not used [-Wunused-function]
 static int mpc_input_any(mpc_input_t *i, char **o) {
            ^~~~~~~~~~~~~
mpc.c:297:13: warning: ‘mpc_input_suppress_enable’ defined but not used [-Wunused-function]
 static void mpc_input_suppress_enable(mpc_input_t *i) { i->suppress++; }
             ^~~~~~~~~~~~~~~~~~~~~~~~~
mpc.c:296:13: warning: ‘mpc_input_suppress_disable’ defined but not used [-Wunused-function]
 static void mpc_input_suppress_disable(mpc_input_t *i) { i->suppress--; }
             ^~~~~~~~~~~~~~~~~~~~~~~~~~
mpc.c:294:13: warning: ‘mpc_input_backtrack_enable’ defined but not used [-Wunused-function]
 static void mpc_input_backtrack_enable(mpc_input_t *i) { i->backtrack++; }
             ^~~~~~~~~~~~~~~~~~~~~~~~~~
mpc.c:293:13: warning: ‘mpc_input_backtrack_disable’ defined but not used [-Wunused-function]
 static void mpc_input_backtrack_disable(mpc_input_t *i) { i->backtrack--; }
             ^~~~~~~~~~~~~~~~~~~~~~~~~~~
mpc.c:284:14: warning: ‘mpc_export’ defined but not used [-Wunused-function]
 static void *mpc_export(mpc_input_t *i, void *p) {
              ^~~~~~~~~~
mpc.c:268:14: warning: ‘mpc_realloc’ defined but not used [-Wunused-function]
 static void *mpc_realloc(mpc_input_t *i, void *p, size_t n) {
              ^~~~~~~~~~~
mpc.c:255:14: warning: ‘mpc_calloc’ defined but not used [-Wunused-function]
 static void *mpc_calloc(mpc_input_t *i, size_t n, size_t m) {
              ^~~~~~~~~~
mpc.c:130:21: warning: ‘mpc_input_new_nstring’ defined but not used [-Wunused-function]
 static mpc_input_t *mpc_input_new_nstring(const char *filename, const char *string, size_t length) {
                     ^~~~~~~~~~~~~~~~~~~~~
mpc.c:7:20: warning: ‘mpc_state_invalid’ defined but not used [-Wunused-function]
 static mpc_state_t mpc_state_invalid(void) {
                    ^~~~~~~~~~~~~~~~~