static int wasFinalPass(void)
{
int result = 1;
struct map_iterator i[1];
struct map_entry *me;
for(map_get_iterator(s->guesses, i);
(me = (struct map_entry*)map_iterator_next(i)) != NULL;)
{
struct expr *guess_expr;
struct expr *sym_expr;
LOG(LOG_VERBOSE, ("Checking guessed symbol %s: ", me->key));
/* Was this guessed symbol used in this pass? */
if((sym_expr = map_get(s->sym_table, me->key)) == NULL)
{
/* No, skip it */
continue;
}
guess_expr = me->value;
LOG(LOG_VERBOSE, ("expected %d, actual %d\n",
resolve_expr(guess_expr),
resolve_expr(sym_expr)));
if(expr_cmp_cb(me->value, sym_expr) != 0)
{
/* Not the same, not the last pass.
* copy the actual value from the sym table */
me->value = sym_expr;
result = 0;
}
}
return result;
}
static void dump_sym_table(int level, struct map *m)
{
struct map_iterator i[1];
const struct map_entry *e;
for(map_get_iterator(m, i); (e = map_iterator_next(i)) != NULL;)
{
LOG(level, ("sym_table: %s ", e->key));
expr_dump(level, e->value);
}
}
static
void wildcard_router_receive(receiver_t* self,
bytecode_stream_t* message, context_t* context)
{
router_t* router = (router_t*) self;
bytecode_t* selector = message->pop(message);
if(selector && selector->verb == route_atom) {
bytecode_t* destination = message->pop(message);
if(!destination) {
WARNING1("no destination provided.");
return;
} else {
atom_t dest = destination->verb;
TRACE2("routing towards selector '%s' requested.", atom_get_cstring_value(dest));
if(dest == star_atom) {
map_iterator_t i;
map_value_t pslot = NULL_MAP_VALUE;
map_get_iterator(&router->children, &i);
while (map_value_is_there (pslot = map_iterator_next(&i))) {
router_slot_t* slot = map_value_obtain (pslot);
// clone each message
bytecode_stream_t* message_copy = bytecode_stream_instantiate_toplevel(NULL);
message_copy->copy(message_copy, message);
TRACE2("sending event to slot: '%s'",
atom_get_cstring_value(slot->name));
if(!router_route(slot, message_copy, context)) {
WARNING2("route '%s' not defined.",
atom_get_cstring_value(slot->name));
}
}
map_iterator_destroy (&i);
map_iterator_retire (&i);
bytecode_stream_retire (message);
} else {
if(!router_route(get_slot(router, dest), message, context)) {
WARNING2("route '%s' not defined.",
atom_get_cstring_value(dest));
}
}
}
} else {
message->push(message, selector);
router->receive_backup(self, message, context);
}
}
static void receiver_eval_all_pending(receiver_t *self, context_t *context)
{
map_iterator_t it;
map_value_t pfifo;
map_get_iterator(&self->fifos, &it);
while (map_value_is_there(pfifo = map_iterator_next(&it))) {
message_fifo_t *fifo = map_value_obtain(pfifo);
self->eval_pending(self, fifo->atom, context);
}
map_iterator_destroy(&it);
map_iterator_retire(&it);
}
int main() {
map *m = map_create(&demo_type);
assert(m != NULL);
char *key = NULL;
char *val = NULL;
srand(time(NULL));
int i = 0, j = 0;
//key = malloc()
// map_insert(m, "hellofjwoefjoewjfo", "world");
for (i = 0; i < 100; i++) {
key = malloc(sizeof(char) * 16);
val = malloc(sizeof(char) * 16);
for (j = 0; j < 15; j ++) {
key[j] = 'a' + rand_range(0, 25);
}
for (j = 0; j < 15; j++) {
val[j] = 'a' + rand_range(0, 25);
}
key[15] = '\0';
val[15] = '\0';
map_insert(m, key, val);
}
printf("map_size: %d\n", map_size(m));
struct timeval start, end;
gettimeofday(&start, NULL);
void *n = map_find(m, "hellofjwoefjoewjfo");
gettimeofday(&end, NULL);
assert(n == NULL);
// printf("%s\n", (char *)n);
int waist = (end.tv_sec - start.tv_sec) * 100000 + (end.tv_usec - start.tv_usec);
printf("waist time: %d, start:(sec: %d, usec: %d), end(sec: %d, usec: %d)\n", waist,
start.tv_sec, start.tv_usec, end.tv_sec, end.tv_usec);
map_iterator *mi = map_get_iterator(m);
assert(mi != NULL);
pair *data;
while ((data = map_next(mi))) {
printf("key: %s => val: %s\n", (char *)(((pair *)data)->first), (char *)(((pair*)data)->second));
}
map_release_iterator(mi);
map_release(m);
}
static message_node_t *receiver_peek_any_pending(receiver_t *self,
context_t *context)
{
map_iterator_t it;
message_node_t *head = NULL;
map_value_t pfifo;
/* find first occurence of next event in any fifo */
map_get_iterator(&self->fifos, &it);
while (map_value_is_there(pfifo = map_iterator_next(&it))) {
message_fifo_t *fifo = map_value_obtain(pfifo);
message_node_t *node = self->peek_pending(self, fifo->atom, context);
if (head == NULL) {
head = node;
} else if (node && node->context->ms < head->context->ms) {
head = node;
}
}
map_iterator_destroy(&it);
map_iterator_retire(&it);
return head;
}
