Emanuele Torre
0b82b3841b
In C23 (default C standard used by GCC 15), jv (*fptr)(); has become
equivalent to jv (*fptr)(void); so we can no longer assign builtin
implemenations directly to the fptr member of cfunctions without
generating a compile error.
Since there does not seem to be any straight-forward way to tell
autoconf to force the compiler to use C99 short of explicitly adding
-std=c99 to CFLAGS, it is probably a cleaner solution to just make the
code C23 compatible.
A possible solution could have been to just redeclare cfunction.fptr
as void*, but then the functions' return type would not have been type
checked (e.g. if you tried to add a {printf, "printf", 2}, where printf
is a function that does not return jv, the compiler wouldn't have
complained.)
We were already not typechecking the arguments of the functions, so e.g.
{binop_plus, "_plus", 3}, /* instead of {f_plus, "_plus, 3}, */
{f_setpath, "setpath", 4}, /* instead of {f_setpath, "setpath", 3}, */
compile without errors despite not having the correct prototype.
So I thought of instead improving the situation by redefining
cfunction.fptr as a union of function pointers with the prototypes that
the jq bytecode interpreter can call, and use a macro to add the builtin
functions to function_list using to the arity argument to assign the
implementation function to the appropriate union member.
Now the code won't compile if the wrong arity, or an arity not supported
by the bytecode interpreter (>5 = 1input+4arguments), or a prototype not
jallable by the bytecode interpreter (e.g. binop_plus that doesn't
expect a jq_state* argument).
Also, the code now compiles with gcc -std=c23.
Fixes #3206
97 lines
1.7 KiB
C
97 lines
1.7 KiB
C
#ifndef BYTECODE_H
|
|
#define BYTECODE_H
|
|
#include <stdint.h>
|
|
|
|
#include "jq.h"
|
|
|
|
typedef enum {
|
|
#define OP(name, imm, in, out) name,
|
|
#include "opcode_list.h"
|
|
#undef OP
|
|
} opcode;
|
|
|
|
enum {
|
|
NUM_OPCODES =
|
|
#define OP(name, imm, in, out) +1
|
|
#include "opcode_list.h"
|
|
#undef OP
|
|
};
|
|
|
|
enum {
|
|
OP_HAS_CONSTANT = 2,
|
|
OP_HAS_VARIABLE = 4,
|
|
OP_HAS_BRANCH = 8,
|
|
OP_HAS_CFUNC = 32,
|
|
OP_HAS_UFUNC = 64,
|
|
OP_IS_CALL_PSEUDO = 128,
|
|
OP_HAS_BINDING = 1024,
|
|
// NOTE: Not actually part of any op -- a pseudo-op flag for special
|
|
// handling of `break`.
|
|
OP_BIND_WILDCARD = 2048,
|
|
};
|
|
struct opcode_description {
|
|
opcode op;
|
|
const char* name;
|
|
|
|
int flags;
|
|
|
|
// length in 16-bit units
|
|
int length;
|
|
|
|
int stack_in, stack_out;
|
|
};
|
|
|
|
const struct opcode_description* opcode_describe(opcode op);
|
|
|
|
|
|
#define MAX_CFUNCTION_ARGS 4
|
|
struct cfunction {
|
|
union {
|
|
jv (*a1)(jq_state *, jv);
|
|
jv (*a2)(jq_state *, jv, jv);
|
|
jv (*a3)(jq_state *, jv, jv, jv);
|
|
jv (*a4)(jq_state *, jv, jv, jv, jv);
|
|
} fptr;
|
|
const char* name;
|
|
int nargs;
|
|
};
|
|
|
|
struct symbol_table {
|
|
struct cfunction* cfunctions;
|
|
int ncfunctions;
|
|
jv cfunc_names;
|
|
};
|
|
|
|
// The bytecode format matters in:
|
|
// execute.c - interpreter
|
|
// compile.c - compiler
|
|
// bytecode.c - disassembler
|
|
|
|
#define ARG_NEWCLOSURE 0x1000
|
|
|
|
struct bytecode {
|
|
uint16_t* code;
|
|
int codelen;
|
|
|
|
int nlocals;
|
|
int nclosures;
|
|
|
|
jv constants; // JSON array of constants
|
|
struct symbol_table* globals;
|
|
|
|
struct bytecode** subfunctions;
|
|
int nsubfunctions;
|
|
|
|
struct bytecode* parent;
|
|
|
|
jv debuginfo;
|
|
};
|
|
|
|
void dump_disassembly(int, struct bytecode* code);
|
|
void dump_operation(struct bytecode* bc, uint16_t* op);
|
|
|
|
int bytecode_operation_length(uint16_t* codeptr);
|
|
void bytecode_free(struct bytecode* bc);
|
|
|
|
#endif
|