static void unload(ErlNifEnv* env, void* priv)
{
NifModPrivData* data = (NifModPrivData*) priv;
add_call(env, data, "unload");
NifModPrivData_release(data);
}
static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info)
{
PrivData* data = enif_alloc(sizeof(PrivData));
assert(data != NULL);
data->ref_cnt = 1;
data->call_history = NULL;
data->nif_mod = NULL;
add_call(env, data, "load");
data->rt_arr[0].t = enif_open_resource_type(env,NULL,"Gold",resource_dtor,
ERL_NIF_RT_CREATE,NULL);
data->rt_arr[1].t = enif_open_resource_type(env,NULL,"Silver",resource_dtor,
ERL_NIF_RT_CREATE,NULL);
binary_resource_type = enif_open_resource_type(env,NULL,"nif_SUITE.binary",
binary_resource_dtor,
ERL_NIF_RT_CREATE, NULL);
msgenv_resource_type = enif_open_resource_type(env,NULL,"nif_SUITE.msgenv",
msgenv_dtor,
ERL_NIF_RT_CREATE, NULL);
atom_self = enif_make_atom(env,"self");
atom_ok = enif_make_atom(env,"ok");
atom_join = enif_make_atom(env,"join");
atom_binary_resource_type = enif_make_atom(env,"binary_resource_type");
*priv_data = data;
return 0;
}
static int reload(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info)
{
PrivData* priv = (PrivData*) *priv_data;
add_call(env, priv, "reload");
resource_takeover(env,priv);
return 0;
}
static void ok_sequence_(struct call_sequence **seq, int sequence_index,
const struct call_entry *expected, const char *context, BOOL todo,
const char *file, int line)
{
struct call_sequence *call_seq = seq[sequence_index];
static const struct call_entry end_of_sequence = { LastKind };
const struct call_entry *actual, *sequence;
int failcount = 0;
struct testcontext ctxt;
add_call(seq, sequence_index, &end_of_sequence);
sequence = call_seq->sequence;
actual = sequence;
ctxt.failcount = &failcount;
ctxt.todo = todo;
ctxt.file = file;
ctxt.line = line;
while (expected->kind != LastKind && actual->kind != LastKind)
{
if (expected->kind == actual->kind)
{
ctxt.kind = expected->kind;
switch (actual->kind)
{
case ScriptAnalysis:
test_uint(actual->sa.pos, expected->sa.pos, "position", &ctxt);
test_uint(actual->sa.len, expected->sa.len, "length", &ctxt);
test_uint(actual->sa.shapes, expected->sa.shapes, "shapes", &ctxt);
break;
default:
ok(0, "%s: callback not handled, %s\n", context, get_analysis_kind_name(actual->kind));
}
expected++;
actual++;
}
else if (todo)
{
failcount++;
todo_wine
{
ok_(file, line) (0, "%s: call %s was expected, but got call %s instead\n",
context, get_analysis_kind_name(expected->kind), get_analysis_kind_name(actual->kind));
}
flush_sequence(seq, sequence_index);
return;
}
else
{
ok_(file, line) (0, "%s: call %s was expected, but got call %s instead\n",
context, get_analysis_kind_name(expected->kind), get_analysis_kind_name(actual->kind));
expected++;
actual++;
}
}
void visit_form(Process *process, Obj *env, Obj *bytecodeObj, int *position, Obj *form) {
if(eval_error) {
return;
}
else if(form->tag == 'C') {
if(form->car->car == NULL) {
add_literal(bytecodeObj, position, nil);
}
else if(HEAD_EQ("quote")) {
add_literal(bytecodeObj, position, form->car);
}
else if(HEAD_EQ("if")) {
add_if(process, env, bytecodeObj, position, form);
}
else if(HEAD_EQ("while")) {
add_while(process, env, bytecodeObj, position, form);
}
else if(HEAD_EQ("do")) {
add_do(process, env, bytecodeObj, position, form);
}
else if(HEAD_EQ("let")) {
add_let(process, env, bytecodeObj, position, form);
}
else if(HEAD_EQ("def")) {
add_def(process, env, bytecodeObj, position, form);
}
else if(HEAD_EQ("reset!")) {
add_reset(process, env, bytecodeObj, position, form);
}
else if(HEAD_EQ("ref")) {
add_ref(process, env, bytecodeObj, position, form);
}
/* else if(HEAD_EQ("or")) { */
/* add_or(process, env, bytecodeObj, position, form); */
/* } */
else if(HEAD_EQ("not")) {
add_not(process, env, bytecodeObj, position, form);
}
else if(HEAD_EQ("fn")) {
Obj *lambda = obj_new_lambda(form->cdr->car, form_to_bytecode(process, env, form->cdr->cdr->car), env, form);
add_literal(bytecodeObj, position, lambda);
}
else {
add_call(process, env, bytecodeObj, position, form);
}
}
else if(form->tag == 'Y') {
add_lookup(bytecodeObj, position, form);
}
else {
add_literal(bytecodeObj, position, form);
}
/* else { */
/* printf("Bytecode can't handle form: "); */
/* obj_print_cout(form); */
/* exit(1); */
/* } */
}
static int upgrade(ErlNifEnv* env, void** priv_data, void** old_priv_data, ERL_NIF_TERM load_info)
{
PrivData* priv = (PrivData*) *old_priv_data;
add_call(env, priv, "upgrade");
priv->ref_cnt++;
*priv_data = *old_priv_data;
resource_takeover(env,priv);
return 0;
}
static int reload(ErlNifEnv* env, void** priv, ERL_NIF_TERM load_info)
{
NifModPrivData* data = (NifModPrivData*) *priv;
int retval = 0;
init(env);
add_call(env, data, "reload");
do_load_info(env, load_info, &retval);
return retval;
}
static void unload(ErlNifEnv* env, void* priv_data)
{
PrivData* data = priv_data;
add_call(env, data, "unload");
if (--data->ref_cnt == 0) {
if (data->nif_mod != NULL) {
NifModPrivData_release(data->nif_mod);
}
enif_free(priv_data);
}
}
static int upgrade(ErlNifEnv* env, void** priv, void** old_priv_data, ERL_NIF_TERM load_info)
{
NifModPrivData* data = (NifModPrivData*) *old_priv_data;
int retval = 0;
init(env);
add_call(env, data, "upgrade");
data->ref_cnt++;
*priv = *old_priv_data;
do_load_info(env, load_info, &retval);
if (retval)
NifModPrivData_release(data);
return retval;
}
static void ok_sequence_(struct drawcall_sequence **seq, int sequence_index,
const struct drawcall_entry *expected, const char *context, BOOL todo,
const char *file, int line)
{
static const struct drawcall_entry end_of_sequence = { DRAW_LAST_KIND };
struct drawcall_sequence *call_seq = seq[sequence_index];
const struct drawcall_entry *actual, *sequence;
int failcount = 0;
add_call(seq, sequence_index, &end_of_sequence);
sequence = call_seq->sequence;
actual = sequence;
while (expected->kind != DRAW_LAST_KIND && actual->kind != DRAW_LAST_KIND) {
if (expected->kind != actual->kind) {
if (todo) {
failcount++;
todo_wine
ok_(file, line) (0, "%s: call %s was expected, but got call %s instead\n",
context, get_draw_kind_name(expected->kind), get_draw_kind_name(actual->kind));
flush_sequence(seq, sequence_index);
return;
}
else
ok_(file, line) (0, "%s: call %s was expected, but got call %s instead\n",
context, get_draw_kind_name(expected->kind), get_draw_kind_name(actual->kind));
}
expected++;
actual++;
}
if (todo) {
todo_wine {
if (expected->kind != DRAW_LAST_KIND || actual->kind != DRAW_LAST_KIND) {
failcount++;
ok_(file, line) (0, "%s: the call sequence is not complete: expected %s - actual %s\n",
context, get_draw_kind_name(expected->kind), get_draw_kind_name(actual->kind));
}
}
}
else if (expected->kind != DRAW_LAST_KIND || actual->kind != DRAW_LAST_KIND)
static int load(ErlNifEnv* env, void** priv, ERL_NIF_TERM load_info)
{
NifModPrivData* data;
int retval = 0;
init(env);
data = (NifModPrivData*) enif_alloc(sizeof(NifModPrivData));
CHECK(data != NULL);
*priv = data;
data->mtx = enif_mutex_create("nif_mod_priv_data");
data->ref_cnt = 1;
data->call_history = NULL;
add_call(env, data, "load");
do_load_info(env, load_info, &retval);
if (retval)
NifModPrivData_release(data);
return retval;
}
/* turn the format string into a list of function calls with args */
static void compile_format(void)
{
unsigned int i;
int j, found, ofs;
char *cmd, *arg, *ptr;
for (i = 0; i < strlen(logformat); i++) {
/* if not a % sequence, append character and start over */
if (logformat[i] != '%') {
char buf[4];
/* we have to stuff it into a string first */
snprintf(buf, sizeof(buf), "%c", logformat[i]);
add_call(print_literal, buf);
continue;
}
/* if a %%, append % and start over */
if (logformat[i+1] == '%') {
add_call(print_literal, "%");
/* make sure we don't parse the second % next time */
i++;
continue;
}
/* it must start with a % now - %<cmd>[ <arg>]%*/
cmd = xstrdup(&logformat[i+1]);
ptr = strchr(cmd, '%');
/* no trailing % = broken */
if (!ptr) {
add_call(print_literal, "INVALID");
free(cmd);
continue;
}
*ptr = '\0';
/* remember length (plus first %) so we can skip over it */
ofs = strlen(cmd) + 1;
/* jump out to argument (if any) */
arg = strchr(cmd, ' ');
if (arg)
*arg++ = '\0';
found = 0;
/* see if we know how to handle this command */
for (j = 0; logcmds[j].name != NULL; j++) {
if (strncasecmp(cmd, logcmds[j].name,
strlen(logcmds[j].name)) == 0) {
add_call(logcmds[j].func, arg);
found = 1;
break;
}
}
free(cmd);
if (!found)
add_call(print_literal, "INVALID");
/* now do the skip ahead saved from before */
i += ofs;
} /* for (i = 0; i < strlen(logformat); i++) */
}
void reader::section_t::call(call_id call, call_id parent, unsigned int flags, time::type duration)
{
add_call(ref, call, parent, flags, duration);
}