struct list_res
res_walk_parents (const struct res *out, const struct hs *hs, int in_port,
array_t* out_arr)
{
struct res *curr_res = (struct res*) out;
struct list_res currq = {0};
// set up initial result to start inversion
struct hs int_hs;
hs_isect_arr (&int_hs, &out->hs, out_arr);
list_append (&currq, res_extend (out, &int_hs, out->port, true));
struct res *cur;
while (curr_res) {
if (curr_res->rules.cur) {
for (int i = curr_res->rules.cur - 1; i >= 0; i--) {
struct list_res nextq = {0};
struct res_rule r = curr_res->rules.arr[i];
while ((cur = currq.head)) {
list_pop (&currq);
struct list_res tmp = rule_inv_apply (r.tf_tf, r.tf_rule, cur, false);
list_concat (&nextq, &tmp);
res_free (cur);
} // for each current result from rule inversion
currq = nextq;
} // for each rule
}
else return currq;
// set (hs,port) which the inverted (hs,port) results must intersect
struct res *parent = curr_res->parent;
struct hs *next_hs = hs_create (curr_res->hs.len);
int next_port;
if (parent) {
hs_copy (next_hs, &parent->hs);
next_port = parent->port;
}
else {
hs_copy (next_hs, hs);
next_port = in_port;
}
// Intersect the results in `currq` with the target (hs,port)
struct list_res nextq = {0};
while ((cur = currq.head)) {
list_pop (&currq);
struct hs *new_hs = hs_isect_a (&cur->hs, next_hs);
if (cur->port == next_port && new_hs)
list_append (&nextq, res_extend (cur, new_hs, next_port, false));
else
res_free (cur);
}
currq = nextq;
curr_res = parent;
}
return currq;
}
int main(int argc, char** argv) {
struct sigaction sig = {};
/* Ensuring that we are in a separate group and session if possible prevents
* us from being killed by infantcidal hosts.
*/
setpgid(0,0);
setsid();
unlink_at_exit = argv[1];
atexit(cleanup);
event_queue = NULL;
directories_traversed = hs_create();
hs_defunct_at(directories_traversed, 65536);
directories_read = hs_create();
hs_defunct_at(directories_read, 65536);
/* If a profile is set, read it if possible, then open for writing. */
profile_open();
/* Don't die on SIGIO or SIGALRM */
sig.sa_handler = signal_ignore;
sigaction(SIGIO, &sig, NULL);
sigaction(SIGALRM, &sig, NULL);
/* Close stdin on SIGTERM, causing the program to exit normally. */
sig.sa_handler = close_stdin;
sigaction(SIGTERM, &sig, NULL);
/* Reconfigure stdin to be ASYNC and NONBLOCK */
if (-1 == fcntl(STDIN_FILENO, F_SETFL, O_ASYNC|O_NONBLOCK))
perror("fcntl(F_SETFL,O_ASYNC|O_NONBLOCK)");
if (-1 == fcntl(STDIN_FILENO, F_SETOWN, getpid()))
perror("fcntl(F_SETOWN)");
/* Run until we exit due to an unexpected error or the input stream closes. */
while (1) {
read_input();
run_events();
pause();
}
return 0;
}
static bool
port_append_res (struct list_res *res, const struct rule *r,
const struct tf *tf, const struct res *in, int32_t ports,
bool append, const struct hs *hs, bool inv_remove_deps)
{
/* Create new result containing headerspace `hs` for each port in `ports`. */
bool used_hs = false;
struct hs *new_hs;
uint32_t n, x;
const uint32_t *a;
if (ports > 0) { n = 1; x = ports; a = &x; }
else {
const struct ports *p = PORTS (tf, ports);
n = p->n; a = p->arr;
}
for (int i = 0; i < n; i++) {
if (a[i] == in->port) continue;
if (inv_remove_deps) {
/* For inversion, also remove dependencies for each input port of the
inverted rule. */
new_hs = hs_create (hs->len);
hs_copy (new_hs, hs);
if (r->deps) deps_diff_inv (new_hs, a[i], DEPS (tf, r->deps), tf);
if (!hs_compact_m (new_hs, r->mask ? DATA_ARR (r->mask) : NULL)) { hs_destroy(new_hs); continue; }
}
else new_hs = (struct hs*) hs;
// now *new_hs has the latest hs at this port
struct res *tmp;
if (! inv_remove_deps) {
if (used_hs) tmp = res_extend (in, hs, a[i], append);
else {
tmp = res_extend (in, NULL, a[i], append);
tmp->hs = *hs;
used_hs = true;
}
}
else {
tmp = res_extend (in, NULL, a[i], append);
tmp->hs = *new_hs;
}
res_rule_add (tmp, tf, r->idx, r);
list_append (res, tmp);
}
return used_hs;
}
void
hs_test (void)
{
array_t *arr;
struct hs *a = hs_create (1);
hs_add (a, array_from_str ("0011xx00"));
hs_add (a, array_from_str ("10100x0x"));
arr = array_from_str ("10100x01");
hs_diff (a, arr);
hs_print (a);
struct hs *b = hs_copy_a (a);
hs_print (b);
hs_free (b);
free (arr);
b = hs_create (1);
hs_add (b, array_from_str ("xxxx1x00"));
hs_add (b, array_from_str ("xxxxx1x0"));
hs_print (b);
hs_isect (b, a);
hs_print (b);
hs_free (b);
hs_free (a);
a = hs_create (1);
hs_add (a, array_from_str ("10xxxxxx"));
hs_add (a, array_from_str ("xxxxxx10"));
arr = array_from_str ("11111111");
hs_diff (a, arr);
hs_print (a);
hs_cmpl (a);
hs_print (a);
hs_free (a);
a = hs_create (1);
hs_add (a, array_from_str ("10xxxxxx"));
hs_add (a, array_from_str ("xxxxxx10"));
b = hs_create (1);
hs_add (b, array_from_str ("11111111"));
hs_minus (a, b);
hs_print (a);
hs_free (a);
hs_free (b);
a = hs_create (1);
hs_add (a, array_from_str ("11111111"));
//hs_add (a, array_from_str ("xxxxxxx1"));
hs_diff (a, arr);
hs_print (a);
hs_comp_diff (a);
char *s = hs_to_str (a);
printf ("S: %s\n", s);
free (s);
hs_free (a);
free (arr);
}
int
clip_HS_CREATE(ClipMachine * ClipMachineMemory)
{
const char *__PROC__ = "HS_CREATE";
const char *fname = _clip_parc(ClipMachineMemory, 1);
int pagesize = _clip_parni(ClipMachineMemory, 2) * 1024;
int lcase = _clip_parl(ClipMachineMemory, 4);
int filtset = _clip_parni(ClipMachineMemory, 5);
HIPER *hs;
int er;
CHECKARG1(1, CHARACTER_type_of_ClipVarType);
CHECKOPT1(2, NUMERIC_type_of_ClipVarType);
CHECKOPT1(4, LOGICAL_type_of_ClipVarType);
CHECKOPT1(5, NUMERIC_type_of_ClipVarType);
if (_clip_parinfo(ClipMachineMemory, 2) == UNDEF_type_of_ClipVarType)
pagesize = getpagesize();
if (_clip_parinfo(ClipMachineMemory, 4) == UNDEF_type_of_ClipVarType)
lcase = 0;
if (_clip_parinfo(ClipMachineMemory, 5) == UNDEF_type_of_ClipVarType)
filtset = 1;
if ((er = hs_create(ClipMachineMemory, fname, pagesize, lcase, filtset, &hs, __PROC__)))
goto err;
hs->map = calloc(1, 4);
_clip_retni(ClipMachineMemory, _clip_store_c_item(ClipMachineMemory, (void *) hs, _C_ITEM_TYPE_HIPER, destroy_hiper));
return 0;
err:
return er;
}
struct upTree* ut_create(size_t array_size) {
struct upTree* out = malloc(sizeof(struct upTree));
out->hs = hs_create(array_size);
return out;
}
