static nsresult run_end_load(HTMLDocumentNode *This, nsISupports *arg1, nsISupports *arg2)
{
TRACE("(%p)\n", This);
if(!This->basedoc.doc_obj)
return NS_OK;
if(This == This->basedoc.doc_obj->basedoc.doc_node) {
/*
* This should be done in the worker thread that parses HTML,
* but we don't have such thread (Gecko parses HTML for us).
*/
parse_complete(This->basedoc.doc_obj);
}
bind_event_scripts(This);
set_ready_state(This->basedoc.window, READYSTATE_INTERACTIVE);
return NS_OK;
}
/*
** This routine is the same as the parse_complete() routine described above, except that the parameter is required to be UTF-16 encoded, not UTF-8.
*/
int parse_complete16(const void *zSql)
{
system_value *pVal;
char const *zSql8;
int rc = SYSTEM_NOMEM;
#ifndef SYSTEM_OMIT_AUTOINIT
rc = system_initialize();
if (rc)
return rc;
#endif
pVal = systemValueNew(0);
systemValueSetStr(pVal, -1, zSql, SYSTEM_UTF16NATIVE, SYSTEM_STATIC);
zSql8 = systemValueText(pVal, SYSTEM_UTF8);
if (zSql8)
rc = parse_complete(zSql8);
else
rc = SYSTEM_NOMEM;
systemValueFree(pVal);
return systemApiExit(0, rc);
}
static
int parse_c_type_from(struct _cffi_parse_info_s *info, size_t *output_index,
const char *input)
{
int result;
token_t token;
token.info = info;
token.kind = TOK_START;
token.input = input;
token.p = input;
token.size = 0;
token.output = info->output;
token.output_index = *output_index;
next_token(&token);
result = parse_complete(&token);
*output_index = token.output_index;
if (token.kind != TOK_END)
return parse_error(&token, "unexpected symbol");
return result;
}
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);
}
