static PyObject *ffi_fetch_int_constant(FFIObject *ffi, char *name,
int recursion)
{
int index;
index = search_in_globals(&ffi->types_builder.ctx, name, strlen(name));
if (index >= 0) {
const struct _cffi_global_s *g;
g = &ffi->types_builder.ctx.globals[index];
switch (_CFFI_GETOP(g->type_op)) {
case _CFFI_OP_CONSTANT_INT:
case _CFFI_OP_ENUM:
return realize_global_int(&ffi->types_builder, index);
default:
PyErr_Format(FFIError,
"function, global variable or non-integer constant "
"'%.200s' must be fetched from its original 'lib' "
"object", name);
return NULL;
}
}
if (ffi->types_builder.included_ffis != NULL) {
Py_ssize_t i;
PyObject *included_ffis = ffi->types_builder.included_ffis;
if (recursion > 100) {
PyErr_SetString(PyExc_RuntimeError,
"recursion overflow in ffi.include() delegations");
return NULL;
}
for (i = 0; i < PyTuple_GET_SIZE(included_ffis); i++) {
FFIObject *ffi1;
PyObject *x;
ffi1 = (FFIObject *)PyTuple_GET_ITEM(included_ffis, i);
x = ffi_fetch_int_constant(ffi1, name, recursion + 1);
if (x != NULL || PyErr_Occurred())
return x;
}
}
return NULL; /* no exception set, means "not found" */
}
static int parse_sequel(token_t *tok, int outer)
{
/* Emit opcodes for the "sequel", which is the optional part of a
type declaration that follows the type name, i.e. everything
with '*', '[ ]', '( )'. Returns the entry point index pointing
the innermost opcode (the one that corresponds to the complete
type). The 'outer' argument is the index of the opcode outside
this "sequel".
*/
int check_for_grouping, abi=0;
_cffi_opcode_t result, *p_current;
header:
switch (tok->kind) {
case TOK_STAR:
outer = write_ds(tok, _CFFI_OP(_CFFI_OP_POINTER, outer));
next_token(tok);
goto header;
case TOK_CONST:
/* ignored for now */
next_token(tok);
goto header;
case TOK_VOLATILE:
/* ignored for now */
next_token(tok);
goto header;
case TOK_CDECL:
case TOK_STDCALL:
/* must be in a function; checked below */
abi = tok->kind;
next_token(tok);
goto header;
default:
break;
}
check_for_grouping = 1;
if (tok->kind == TOK_IDENTIFIER) {
next_token(tok); /* skip a potential variable name */
check_for_grouping = 0;
}
result = 0;
p_current = &result;
while (tok->kind == TOK_OPEN_PAREN) {
next_token(tok);
if (tok->kind == TOK_CDECL || tok->kind == TOK_STDCALL) {
abi = tok->kind;
next_token(tok);
}
if ((check_for_grouping--) == 1 && (tok->kind == TOK_STAR ||
tok->kind == TOK_CONST ||
tok->kind == TOK_VOLATILE ||
tok->kind == TOK_OPEN_BRACKET)) {
/* just parentheses for grouping. Use a OP_NOOP to simplify */
int x;
assert(p_current == &result);
x = tok->output_index;
p_current = tok->output + x;
write_ds(tok, _CFFI_OP(_CFFI_OP_NOOP, 0));
x = parse_sequel(tok, x);
result = _CFFI_OP(_CFFI_GETOP(0), x);
}
else {
/* function type */
int arg_total, base_index, arg_next, flags=0;
if (abi == TOK_STDCALL) {
flags = 2;
/* note that an ellipsis below will overwrite this flags,
which is the goal: variadic functions are always cdecl */
}
abi = 0;
if (tok->kind == TOK_VOID && get_following_char(tok) == ')') {
next_token(tok);
}
/* (over-)estimate 'arg_total'. May return 1 when it is really 0 */
arg_total = number_of_commas(tok) + 1;
*p_current = _CFFI_OP(_CFFI_GETOP(*p_current), tok->output_index);
p_current = tok->output + tok->output_index;
base_index = write_ds(tok, _CFFI_OP(_CFFI_OP_FUNCTION, 0));
if (base_index < 0)
return -1;
/* reserve (arg_total + 1) slots for the arguments and the
final FUNCTION_END */
for (arg_next = 0; arg_next <= arg_total; arg_next++)
if (write_ds(tok, _CFFI_OP(0, 0)) < 0)
return -1;
arg_next = base_index + 1;
if (tok->kind != TOK_CLOSE_PAREN) {
while (1) {
int arg;
_cffi_opcode_t oarg;
if (tok->kind == TOK_DOTDOTDOT) {
flags = 1; /* ellipsis */
next_token(tok);
break;
}
arg = parse_complete(tok);
switch (_CFFI_GETOP(tok->output[arg])) {
case _CFFI_OP_ARRAY:
case _CFFI_OP_OPEN_ARRAY:
arg = _CFFI_GETARG(tok->output[arg]);
/* fall-through */
case _CFFI_OP_FUNCTION:
oarg = _CFFI_OP(_CFFI_OP_POINTER, arg);
break;
default:
oarg = _CFFI_OP(_CFFI_OP_NOOP, arg);
break;
}
assert(arg_next - base_index <= arg_total);
tok->output[arg_next++] = oarg;
if (tok->kind != TOK_COMMA)
break;
next_token(tok);
}
}
tok->output[arg_next] = _CFFI_OP(_CFFI_OP_FUNCTION_END, flags);
}
if (tok->kind != TOK_CLOSE_PAREN)
return parse_error(tok, "expected ')'");
next_token(tok);
}
if (abi != 0)
return parse_error(tok, "expected '('");
while (tok->kind == TOK_OPEN_BRACKET) {
*p_current = _CFFI_OP(_CFFI_GETOP(*p_current), tok->output_index);
p_current = tok->output + tok->output_index;
next_token(tok);
if (tok->kind != TOK_CLOSE_BRACKET) {
size_t length;
int gindex;
char *endptr;
switch (tok->kind) {
case TOK_INTEGER:
errno = 0;
if (sizeof(length) > sizeof(unsigned long)) {
#ifdef MS_WIN32
# ifdef _WIN64
length = _strtoui64(tok->p, &endptr, 0);
# else
abort(); /* unreachable */
# endif
#else
length = strtoull(tok->p, &endptr, 0);
#endif
}
else
length = strtoul(tok->p, &endptr, 0);
if (endptr != tok->p + tok->size)
return parse_error(tok, "invalid number");
if (errno == ERANGE || length > MAX_SSIZE_T)
return parse_error(tok, "number too large");
break;
case TOK_IDENTIFIER:
gindex = search_in_globals(tok->info->ctx, tok->p, tok->size);
if (gindex >= 0) {
const struct _cffi_global_s *g;
g = &tok->info->ctx->globals[gindex];
if (_CFFI_GETOP(g->type_op) == _CFFI_OP_CONSTANT_INT ||
_CFFI_GETOP(g->type_op) == _CFFI_OP_ENUM) {
int neg;
struct _cffi_getconst_s gc;
gc.ctx = tok->info->ctx;
gc.gindex = gindex;
neg = ((int(*)(struct _cffi_getconst_s*))g->address)
(&gc);
if (neg == 0 && gc.value > MAX_SSIZE_T)
return parse_error(tok,
"integer constant too large");
if (neg == 0 || gc.value == 0) {
length = (size_t)gc.value;
break;
}
if (neg != 1)
return parse_error(tok, "disagreement about"
" this constant's value");
}
}
/* fall-through to the default case */
default:
return parse_error(tok, "expected a positive integer constant");
}
next_token(tok);
write_ds(tok, _CFFI_OP(_CFFI_OP_ARRAY, 0));
write_ds(tok, (_cffi_opcode_t)length);
}
else
write_ds(tok, _CFFI_OP(_CFFI_OP_OPEN_ARRAY, 0));
if (tok->kind != TOK_CLOSE_BRACKET)
return parse_error(tok, "expected ']'");
next_token(tok);
}
*p_current = _CFFI_OP(_CFFI_GETOP(*p_current), outer);
return _CFFI_GETARG(result);
}
