struct json_object* json_object_from_file(char *filename)
{
struct printbuf *pb;
struct json_object *obj;
char buf[JSON_FILE_BUF_SIZE];
int fd, ret;
if((fd = open(filename, O_RDONLY)) < 0) {
mc_error("json_object_from_file: error reading file %s: %s\n",
filename, strerror(errno));
return error_ptr(-1);
}
if(!(pb = printbuf_new())) {
mc_error("json_object_from_file: printbuf_new failed\n");
return error_ptr(-1);
}
while((ret = read(fd, buf, JSON_FILE_BUF_SIZE)) > 0) {
printbuf_memappend(pb, buf, ret);
}
close(fd);
if(ret < 0) {
mc_abort("json_object_from_file: error reading file %s: %s\n",
filename, strerror(errno));
printbuf_free(pb);
return error_ptr(-1);
}
obj = json_tokener_parse(pb->buf);
printbuf_free(pb);
return obj;
}
int json_object_to_file(char *filename, struct json_object *obj)
{
char *json_str;
int fd, ret, wpos, wsize;
if(!obj) {
mc_error("json_object_to_file: object is null\n");
return -1;
}
if((fd = open(filename, O_WRONLY | O_TRUNC | O_CREAT, 0644)) < 0) {
mc_error("json_object_to_file: error opening file %s: %s\n",
filename, strerror(errno));
return -1;
}
if(!(json_str = json_object_to_json_string(obj))) return -1;
wsize = strlen(json_str);
wpos = 0;
while(wpos < wsize) {
if((ret = write(fd, json_str + wpos, wsize-wpos)) < 0) {
close(fd);
mc_error("json_object_to_file: error writing file %s: %s\n",
filename, strerror(errno));
return -1;
}
wpos += ret;
}
close(fd);
return 0;
}
int main(int argc, char **argv)
{
GLFWwindow *window = (GLFWwindow *) 0;
mc_world world;
mc_gc context;
if (!glfwInit()) {
mc_error(1, "GLFW error.");
}
atexit(glfwTerminate);
glfwSetErrorCallback((GLFWerrorfun) mc_error);
window = glfwCreateWindow(640, 480, "UntitledCraft", NULL, NULL);
if (!window) {
mc_error(1, "Window error.");
}
glfwMakeContextCurrent(window);
if (!mc_graphics_init(&context)) {
mc_error(1, "Context error.");
}
if (!mc_world_init(&world, (unsigned int) time(NULL))) {
mc_error(1, "World.");
}
glfwPollEvents();
while (!glfwWindowShouldClose(window)) {
mc_graphics_clear(&context);
glfwSwapBuffers(window);
glfwWaitEvents();
}
return 0;
}
int json_object_to_file(char *filename, struct json_object *obj)
{
char *json_str;
int fd, ret;
unsigned int wpos, wsize;
if(!obj) {
mc_error("json_object_to_file: object is null\n");
return -1;
}
if((fd = open(filename, O_WRONLY | O_TRUNC | O_CREAT, 0644)) < 0) {
mc_error("json_object_to_file: error opening file %s: %s\n",
filename, strerror(errno));
return -1;
}
if(!(json_str = json_object_to_json_string(obj))) { return -1; }
wsize = (unsigned int)(strlen(json_str) & UINT_MAX); /* CAW: probably unnecessary, but the most 64bit safe */
wpos = 0;
while(wpos < wsize) {
if((ret = write(fd, json_str + wpos, wsize-wpos)) < 0) {
close(fd);
mc_error("json_object_to_file: error writing file %s: %s\n",
filename, strerror(errno));
return -1;
}
/* because of the above check for ret < 0, we can safely cast and add */
wpos += (unsigned int)ret;
}
close(fd);
return 0;
}
/* Checks that test state TS matches the test model TM and
reports any mismatches via mc_error. Then, adds SX to MC as a
new state. */
static void
check_state (struct mc *mc, struct test_state *ts, const struct test_model *tm)
{
const struct test_params *params = mc_get_aux (mc);
int n_columns = params->n_columns;
unsigned int hash;
int i;
for (i = 0; i < params->n_xarrays; i++)
{
const struct xarray_model *model = &tm->models[i];
const struct sparse_xarray *sx = ts->xarrays[i];
bool difference;
int row, col;
int n_rows;
assert (n_columns < MAX_COLS);
/* Check row count. */
n_rows = 0;
for (row = 0; row < params->max_rows; row++)
if (model->contains_row[row])
n_rows = row + 1;
if (n_rows != sparse_xarray_get_n_rows (sx))
mc_error (mc, "xarray %d: row count (%zu) does not match expected "
"(%d)", i, sparse_xarray_get_n_rows (sx), n_rows);
/* Check row containment. */
for (row = 0; row < params->max_rows; row++)
{
bool contains = sparse_xarray_contains_row (sx, row);
if (contains && !model->contains_row[row])
mc_error (mc, "xarray %d: row %d is contained by sparse_xarray "
"but should not be", i, row);
else if (!contains && model->contains_row[row])
mc_error (mc, "xarray %d: row %d is not contained by "
"sparse_xarray but should be", i, row);
}
/* Check contents. */
difference = false;
for (row = 0; row < params->max_rows; row++)
{
unsigned char data[MAX_COLS];
if (!sparse_xarray_read (sx, row, 0, n_columns, data))
NOT_REACHED ();
for (col = 0; col < params->n_columns; col++)
if (data[col] != model->data[row][col])
{
mc_error (mc, "xarray %d: element %d,%d (of %d,%d) "
"differs: %d should be %d",
i, row, col, n_rows, n_columns, data[col],
model->data[row][col]);
difference = true;
}
}
if (difference)
{
struct string ds;
mc_error (mc, "xarray %d: expected:", i);
ds_init_empty (&ds);
for (row = 0; row < params->max_rows; row++)
{
ds_clear (&ds);
for (col = 0; col < n_columns; col++)
ds_put_format (&ds, " %d", model->data[row][col]);
mc_error (mc, "xarray %d: row %d:%s", i, row, ds_cstr (&ds));
}
mc_error (mc, "xarray %d: actual:", i);
ds_init_empty (&ds);
for (row = 0; row < params->max_rows; row++)
{
unsigned char data[MAX_COLS];
if (!sparse_xarray_read (sx, row, 0, n_columns, data))
NOT_REACHED ();
ds_clear (&ds);
for (col = 0; col < n_columns; col++)
ds_put_format (&ds, " %d", data[col]);
mc_error (mc, "xarray %d: row %d:%s", i, row, ds_cstr (&ds));
}
ds_destroy (&ds);
}
}
hash = 0;
for (i = 0; i < params->n_xarrays; i++)
hash = sparse_xarray_model_checker_hash (ts->xarrays[i], hash);
if (mc_discard_dup_state (mc, hash))
test_state_destroy (params, ts);
else
mc_add_state (mc, ts);
}
