void history_processFlags(history_t* past)
// to be called after completely recording this history, before calculating any values.
{
state_t* flagState = dict_lookup(past->states, "flags");
state_t* nextState;
U16 nextFlags, toggledFlags, currentFlags = (U16)flagState->value;
while (flagState->next)
{
nextState = flagState->next;
nextFlags = (U16)nextState->value;
toggledFlags = currentFlags ^ nextFlags;
if (toggledFlags & IF_FIXED_ALIGNMENT)
{ // the IF_FIXED_ALIGNMENT bit will change in the next state
if (nextFlags & IF_FIXED_ALIGNMENT)
{ // the IF_FIXED_ALIGNMENT bit will be set
int onFrame = nextState->frame;
state_t* rotations = dict_lookup(past->states, "rotate");
nextState->params.instanceAngle = state_value(rotations, onFrame);
state_t* resetRotate = state_new(onFrame, CF_JUMP, 0, 0);
state_insert(rotations, resetRotate);
if (onFrame == past->firstFrame)
onFrame++;
state_t *x, *y;
float dx, dy;
do
{
x = dict_lookup(past->states, "x");
dx = state_tangent(x, onFrame, T_SYMMETRIC);
y = dict_lookup(past->states, "y");
dy = state_tangent(y, onFrame, T_SYMMETRIC);
onFrame++;
}
while (dx == 0 && dy == 0 && onFrame < past->lastFrame);
if (onFrame == past->lastFrame)
nextState->params.pathAngle = 0;
else
nextState->params.pathAngle = getAngle(dx, dy) / M_PI * 180;
}
else // the IF_FIXED_ALIGNMENT bit will be reset
{
int offFrame = nextState->frame;
state_t* rotations = dict_lookup(past->states, "rotate");
state_t* setRotate = state_new(offFrame, CF_JUMP, flagState->params.instanceAngle + state_value(rotations, offFrame), 0);
state_insert(rotations, setRotate);
}
}
else // the IF_FIXED_ALIGNMENT bit will not change but some processing may be
// required just the same
{
if (nextFlags & IF_FIXED_ALIGNMENT)
{
nextState->params.instanceAngle = flagState->params.instanceAngle;
nextState->params.pathAngle = flagState->params.pathAngle;
}
}
// and so on for all the other bits.
flagState = nextState;
currentFlags = nextFlags;
}
}
/* Parse the given disk state and set a newly allocated state. On success,
* return that state else NULL. */
static sr_state_t *
disk_state_parse(const sr_disk_state_t *new_disk_state)
{
sr_state_t *new_state = state_new(default_fname, time(NULL));
tor_assert(new_disk_state);
new_state->version = new_disk_state->Version;
new_state->valid_until = new_disk_state->ValidUntil;
new_state->valid_after = new_disk_state->ValidAfter;
/* Set our current phase according to the valid-after time in our disk
* state. The disk state we are parsing contains everything for the phase
* starting at valid_after so make sure our phase reflects that. */
new_state->phase = get_sr_protocol_phase(new_state->valid_after);
/* Parse the shared random values. */
if (disk_state_parse_sr_values(new_state, new_disk_state) < 0) {
goto error;
}
/* Parse the commits. */
if (disk_state_parse_commits(new_state, new_disk_state) < 0) {
goto error;
}
/* Great! This new state contains everything we had on disk. */
return new_state;
error:
state_free(new_state);
return NULL;
}
void history_begin(history_t* past, char* parameter, U16 frame, TAG* tag, float value)
{
state_t* first = state_new(frame, CF_PUT, value, 0);
past->firstTag = tag;
past->firstFrame = frame;
dict_put2(past->states, parameter, first);
}
Profile *
tracker_create_profile (tracker_t *tracker)
{
uint8_t *end = tracker->events + tracker->n_event_bytes;
StackStash *resolved_stash;
Profile *profile;
state_t *state;
uint8_t *event;
state = state_new ();
resolved_stash = stack_stash_new (g_free);
event = tracker->events;
while (event < end)
{
event_type_t type = GET_TYPE (*(uint32_t *)event);
switch (type)
{
case NEW_PROCESS:
create_process (state, (new_process_t *)event);
event += sizeof (new_process_t);
break;
case NEW_MAP:
create_map (state, (new_map_t *)event);
event += sizeof (new_map_t);
break;
case FORK:
process_fork (state, (fork_t *)event);
event += sizeof (fork_t);
break;
case EXIT:
process_exit (state, (exit_t *)event);
event += sizeof (exit_t);
break;
case SAMPLE:
process_sample (state, resolved_stash, (sample_t *)event);
event += sizeof (sample_t);
break;
}
}
profile = profile_new (resolved_stash);
state_free (state);
stack_stash_unref (resolved_stash);
return profile;
}
void history_remember(history_t* past, char* parameter, U16 frame, int function, float value, interpolation_t* inter)
{
past->lastFrame = frame;
state_t* state = dict_lookup(past->states, parameter);
if (state) //should always be true
{
state_t* next = state_new(frame, function, value, inter);
state_append(state, next);
}
else
syntaxerror("Internal error: changing parameter %s, which is unknown for the instance.", parameter);
}
/* Initialize the disk and memory state.
*
* If save_to_disk is set to 1, the state is immediately saved to disk after
* creation else it's not thus only kept in memory.
* If read_from_disk is set to 1, we try to load the state from the disk and
* if not found, a new state is created.
*
* Return 0 on success else a negative value on error. */
int
sr_state_init(int save_to_disk, int read_from_disk)
{
int ret = -ENOENT;
time_t now = time(NULL);
/* We shouldn't have those assigned. */
tor_assert(sr_disk_state == NULL);
tor_assert(sr_state == NULL);
/* First, try to load the state from disk. */
if (read_from_disk) {
ret = disk_state_load_from_disk();
}
if (ret < 0) {
switch (-ret) {
case EINVAL:
/* We have a state on disk but it contains something we couldn't parse
* or an invalid entry in the state file. Let's remove it since it's
* obviously unusable and replace it by an new fresh state below. */
case ENOENT:
{
/* No state on disk so allocate our states for the first time. */
sr_state_t *new_state = state_new(default_fname, now);
sr_disk_state_t *new_disk_state = disk_state_new(now);
state_set(new_state);
/* It's important to set our disk state pointer since the save call
* below uses it to synchronized it with our memory state. */
disk_state_set(new_disk_state);
/* No entry, let's save our new state to disk. */
if (save_to_disk && disk_state_save_to_disk() < 0) {
goto error;
}
break;
}
default:
/* Big problem. Not possible. */
tor_assert(0);
}
}
/* We have a state in memory, let's make sure it's updated for the current
* and next voting round. */
{
time_t valid_after = voting_schedule_get_next_valid_after_time();
sr_state_update(valid_after);
}
return 0;
error:
return -1;
}
/*
* A spatial file manager. Treat directories as independent resources with
* fixed positions. Useful for navigating your filesystem with a predictable
* GUI.
*/
int
main(int argc, char *argv[])
{
struct geometry *geometry;
GtkWidget *window;
WnckWindow *w;
struct state *d;
char *dir, ch;
if ((d = state_new(argv[0])) == NULL)
err(1, "could not build the callback data");
gtk_init(&argc, &argv);
while ((ch = getopt(argc, argv, "")) != -1)
switch (ch) {
default:
usage();
/* NOTREACHED */
}
argc -= optind;
argv += optind;
dir = getdir(argc, argv);
if (((w = window_by_title(dir)) != NULL) && window_activate(w) != -1)
goto done;
if (state_add_dir(d, dir) < 0)
err(1, "state_add_dir");
if ((geometry = malloc(sizeof(struct geometry))) == NULL)
err(1, "malloc");
getgeometry(dir, geometry);
window = prepare_window(dir, geometry, d);
free(geometry);
gtk_widget_show(window);
gtk_main();
done:
state_free(d);
return 0;
}
State state_new(Settings *settings) {
// Allocate memory for tracking previous sets
int **completed_games = (int **) malloc(settings->num_games * sizeof(int*));
for (int i = 0; i < settings->num_games; i++) {
completed_games[i] = (int *) malloc(4 * sizeof(int*));
completed_games[i][0] = 0;
completed_games[i][1] = 0;
}
return (State)
{ .player_points = 0
, .opponent_points = 0
, .player_games = 0
, .opponent_games = 0
, .num_games = settings->num_games
, .num_points = settings->num_points
, .scoring_mode = settings->scoring_mode
, .server = settings->first_server
// Collected stats
, .match_start_time = -1
, .match_end_time = -1
, .player_total_points = 0
, .completed_games = completed_games
};
}
void state_destroy(State *s) {
for (int i = 0; i < s->num_games; i++) free(s->completed_games[i]);
free(s->completed_games);
}
State compute_state(list_t *serial, Settings *settings) {
list_node_t *node;
list_iterator_t *it = list_iterator_new(serial, LIST_HEAD);
State state = state_new(settings);
while ((node = list_iterator_next(it))) next_state(&state, (Point *) node->val);
list_iterator_destroy(it);
return state;
}
/*
* A desktop file manager. This opens files and directories the same way that
* argonaut(1) does.
*/
int
main(int argc, char *argv[])
{
GtkBuilder *builder;
GtkWidget *root, *icons;
struct state *d;
char *dir;
if ((dir = get_dir()) == NULL)
err(1, "get_dir");
if ((d = state_new(BINDIR"/argonaut")) == NULL)
err(1, "could not build the callback data");
if (state_add_dir(d, dir) < 0)
err(1, "state_add_dir");
gtk_init(&argc, &argv);
builder = gtk_builder_new_from_file(INTERFACE_PATH);
icons = GTK_WIDGET(gtk_builder_get_object(builder, "desktop-icons"));
d->icon_view = GTK_ICON_VIEW(icons);
root = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_set_name(root, "argonaut-desktop");
set_window_geometry(GTK_WINDOW(root), GTK_WIDGET(icons));
desktopize(root);
skip_pager(root);
populate_model(dir, d->icon_view);
set_up_icon_view(icons, d);
gtk_container_add(GTK_CONTAINER(root), icons);
gtk_widget_show(icons);
gtk_widget_show(root);
gtk_main();
state_free(d);
free(dir);
return 0;
}
static state *
state_list_append (symbol_number sym, size_t core_size, item_number *core)
{
state_list *node = xmalloc (sizeof *node);
state *s = state_new (sym, core_size, core);
if (trace_flag & trace_automaton)
fprintf (stderr, "state_list_append (state = %d, symbol = %d (%s))\n",
nstates, sym, symbols[sym]->tag);
node->next = NULL;
node->state = s;
if (!first_state)
first_state = node;
if (last_state)
last_state->next = node;
last_state = node;
return s;
}
/* Handle a wire connection from a client. */
static void *wire_server_thread(void *arg)
{
struct wire_server *wire_server = (struct wire_server *)arg;
struct netdev *netdev = NULL;
char *error = NULL;
DEBUGP("wire_server_thread\n");
set_default_config(&wire_server->config);
if (wire_server_receive_args(wire_server))
goto error_done;
if (wire_server_receive_script_path(wire_server))
goto error_done;
if (wire_server_receive_script(wire_server))
goto error_done;
if (wire_server_receive_hw_address(wire_server))
goto error_done;
if (parse_script_and_set_config(wire_server->argc,
wire_server->argv,
&wire_server->config,
&wire_server->script,
wire_server->script_path,
wire_server->script_buffer))
goto error_done;
set_scheduling_priority();
lock_memory();
netdev =
wire_server_netdev_new(&wire_server->config,
wire_server->wire_server_device,
&wire_server->client_ether_addr,
&wire_server->server_ether_addr);
wire_server->state = state_new(&wire_server->config,
&wire_server->script,
netdev);
if (wire_server_send_server_ready(wire_server))
goto error_done;
if (wire_server_receive_client_starting(wire_server))
goto error_done;
if (wire_server_run_script(wire_server, &error))
goto error_done;
DEBUGP("wire_server_thread: finished test successfully\n");
error_done:
if (error != NULL)
fprintf(stderr, "%s\n", error);
if (wire_server->state != NULL)
state_free(wire_server->state, 0);
DEBUGP("wire_server_thread: connection is done\n");
wire_server_free(wire_server);
return NULL;
}
void run_script(struct config *config, struct script *script)
{
char *error = NULL;
struct state *state = NULL;
struct netdev *netdev = NULL;
struct event *event = NULL;
DEBUGP("run_script: running script\n");
set_scheduling_priority();
lock_memory();
/* This interpreter loop runs for local mode or wire client mode. */
assert(!config->is_wire_server);
/* How we use the network is of course a little different in
* each of the two cases....
*/
if (config->is_wire_client)
netdev = wire_client_netdev_new(config);
else
netdev = local_netdev_new(config);
state = state_new(config, script, netdev);
if (config->is_wire_client)
{
state->wire_client = wire_client_new();
wire_client_init(state->wire_client, config, script, state);
}
if (script->init_command != NULL)
{
if (safe_system(script->init_command->command_line,
&error))
{
die("%s: error executing init command: %s\n",
config->script_path, error);
}
}
signal(SIGPIPE, SIG_IGN); /* ignore EPIPE */
state->live_start_time_usecs = schedule_start_time_usecs();
DEBUGP("live_start_time_usecs is %lld\n",
state->live_start_time_usecs);
if (state->wire_client != NULL)
wire_client_send_client_starting(state->wire_client);
while (1)
{
if (get_next_event(state, &error))
die("%s", error);
event = state->event;
if (event == NULL)
break;
if (state->wire_client != NULL)
wire_client_next_event(state->wire_client, event);
/* In wire mode, we adjust relative times after
* getting notification that previous packet events
* have completed, if any.
*/
adjust_relative_event_times(state, event);
switch (event->type)
{
case PACKET_EVENT:
/* For wire clients, the server handles packets. */
if (!config->is_wire_client)
{
run_local_packet_event(state, event,
event->event.packet);
}
break;
case SYSCALL_EVENT:
run_system_call_event(state, event,
event->event.syscall);
break;
case COMMAND_EVENT:
run_command_event(state, event,
event->event.command);
break;
case CODE_EVENT:
run_code_event(state, event,
event->event.code->text);
break;
case INVALID_EVENT:
case NUM_EVENT_TYPES:
assert(!"bogus type");
break;
/* We omit default case so compiler catches missing values. */
}
}
/* Wait for any outstanding packet events we requested on the server. */
if (state->wire_client != NULL)
wire_client_next_event(state->wire_client, NULL);
if (code_execute(state->code, &error))
{
die("%s: error executing code: %s\n",
state->config->script_path, error);
free(error);
}
state_free(state);
DEBUGP("run_script: done running\n");
}
void history_rememberSweep(history_t* past, U16 frame, float x, float y, float r, int clockwise, int short_arc, interpolation_t* inter)
{
float lastX, lastY, dX, dY;
U16 lastFrame;
past->lastFrame = frame;
state_t* change = dict_lookup(past->states, "x");
if (change) //should always be true
{
while (change->next)
change = change->next;
lastFrame = change->frame;
lastX = change->value;
change = dict_lookup(past->states, "y");
if (change) //should always be true
{
while (change->next)
change = change->next;
lastY = change->value;
dX = x - lastX;
dY = y - lastY;
if (dX == 0 && dY == 0)
syntaxerror("sweep not possible: startpoint and endpoint must not be equal");
if ((dX) * (dX) + (dY) * (dY) > 4 * r * r)
syntaxerror("sweep not possible: radius is to small");
if (change->frame > lastFrame)
{
lastFrame = change->frame;
history_remember(past, "x", lastFrame, CF_JUMP, lastX, 0);
}
else
if (change->frame < lastFrame)
history_remember(past, "y", lastFrame, CF_JUMP, lastY, 0);
float c1X, c1Y, c2X, c2Y;
if (dX == 0) //vertical
{
c1Y = c2Y = (lastY + y) / 2;
c1X = x + sqrt(r * r - (c1Y - y) * (c1Y - y));
c2X = 2 * x -c1X;
}
else
if (dY == 0) //horizontal
{
c1X = c2X = (lastX + x) / 2;
c1Y = y +sqrt(r * r - (c1X - x) * (c1X - x));
c2Y = 2 * y -c1Y;
}
else
{
c1X = sqrt((r * r - (dX * dX + dY * dY) / 4) / (1 + dX * dX / dY / dY));
c2X = -c1X;
c1Y = -dX / dY * c1X;
c2Y = -c1Y;
c1X += (x + lastX) / 2;
c2X += (x + lastX) / 2;
c1Y += (y + lastY) / 2;
c2Y += (y + lastY) / 2;
}
float angle1, angle2, delta_angle, centerX, centerY;
angle1 = getAngle(lastX - c1X, lastY - c1Y);
angle2 = getAngle(x - c1X, y - c1Y);
delta_angle = getDeltaAngle(angle1, angle2, clockwise);
if ((short_arc && fabs(delta_angle) <= M_PI) || (! short_arc && fabs(delta_angle) >= M_PI))
{
centerX = c1X;
centerY = c1Y;
}
else
{
angle1 = getAngle(lastX - c2X, lastY - c2Y);
angle2 = getAngle(x - c2X, y - c2Y);
delta_angle = getDeltaAngle(angle1, angle2, clockwise);
centerX = c2X;
centerY = c2Y;
}
change = dict_lookup(past->states, "x");
state_t* nextX = state_new(frame, CF_SWEEP, x, inter);
nextX->arc.r = r;
nextX->arc.angle = angle1;
nextX->arc.delta_angle = delta_angle;
nextX->arc.cX = centerX;
nextX->arc.cY = centerY;
nextX->arc.X = 1;
state_append(change, nextX);
change = dict_lookup(past->states, "y");
state_t* nextY = state_new(frame, CF_SWEEP, y, inter);
nextY->arc.r = r;
nextY->arc.angle = angle1;
nextY->arc.delta_angle = delta_angle;
nextY->arc.cX = centerX;
nextY->arc.cY = centerY;
nextY->arc.X = 0;
state_append(change, nextY);
}
else
syntaxerror("Internal error: changing parameter y in sweep, which is unknown for the instance.");
}
else
syntaxerror("Internal error: changing parameter x in sweep, which is unknown for the instance.");
}
