3656 lines
203 KiB
Text
3656 lines
203 KiB
Text
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) {
|
||
^~~~~~~~~~~~~~~~~
|