static void on_c2p_recv_msg(void *arg, int success) {
proxy_call *pc = arg;
grpc_op op;
grpc_call_error err;
if (!pc->proxy->shutdown && success) {
if (pc->c2p_msg != NULL) {
op.op = GRPC_OP_SEND_MESSAGE;
op.flags = 0;
op.reserved = NULL;
op.data.send_message = pc->c2p_msg;
refpc(pc, "on_p2s_sent_message");
err = grpc_call_start_batch(pc->p2s, &op, 1,
new_closure(on_p2s_sent_message, pc), NULL);
GPR_ASSERT(err == GRPC_CALL_OK);
} else {
op.op = GRPC_OP_SEND_CLOSE_FROM_CLIENT;
op.flags = 0;
op.reserved = NULL;
refpc(pc, "on_p2s_sent_close");
err = grpc_call_start_batch(pc->p2s, &op, 1,
new_closure(on_p2s_sent_close, pc), NULL);
GPR_ASSERT(err == GRPC_CALL_OK);
}
}
unrefpc(pc, "on_c2p_recv_msg");
}
void add_audio_status_listener(audio_status_callback_t function, ptr_t data)
{
OSStatus result;
CFRunLoopRef theRunLoop;
closure_t closure;
AudioObjectPropertyAddress runLoop = {
.mSelector = kAudioHardwarePropertyRunLoop,
.mScope = kAudioObjectPropertyScopeGlobal,
.mElement = kAudioObjectPropertyElementMaster
};
AudioObjectPropertyAddress devices = {
.mSelector = kAudioHardwarePropertyDevices,
.mScope = kAudioObjectPropertyScopeGlobal,
.mElement = kAudioObjectPropertyElementMaster
};
theRunLoop = NULL; // necessary?
result = AudioObjectSetPropertyData(kAudioObjectSystemObject, &runLoop, 0, NULL, sizeof(CFRunLoopRef), &theRunLoop);
assert(result == noErr);
closure = new_closure(function, data);
result = AudioObjectAddPropertyListener(kAudioObjectSystemObject, &devices, audio_listener, closure);
assert(result == noErr);
}
void
print_results (void)
{
state_number i;
/* We used to use just .out if SPEC_NAME_PREFIX (-p) was used, but
that conflicts with Posix. */
FILE *out = xfopen (spec_verbose_file, "w");
reduce_output (out);
grammar_rules_partial_print (out,
_("Rules never reduced"), rule_never_reduced_p);
conflicts_output (out);
print_grammar (out);
/* If the whole state item sets, not only the kernels, are wanted,
`closure' will be run, which needs memory allocation/deallocation. */
if (report_flag & report_itemsets)
new_closure (nritems);
/* Storage for print_reductions. */
shift_set = bitset_create (ntokens, BITSET_FIXED);
look_ahead_set = bitset_create (ntokens, BITSET_FIXED);
for (i = 0; i < nstates; i++)
print_state (out, states[i]);
bitset_free (shift_set);
bitset_free (look_ahead_set);
if (report_flag & report_itemsets)
free_closure ();
xfclose (out);
}
static void request_call(grpc_end2end_proxy *proxy) {
proxy->new_call = NULL;
GPR_ASSERT(GRPC_CALL_OK == grpc_server_request_call(
proxy->server, &proxy->new_call,
&proxy->new_call_details,
&proxy->new_call_metadata, proxy->cq,
proxy->cq, new_closure(on_new_call, proxy)));
}
void
allocAndAdd(struct environment_s **env, char *name, char *cmd)
{
struct closure_s *closure;
closure = new_closure(ccnl_strdup(cmd), NULL);
add_to_environment(env, ccnl_strdup(name), closure);
}
void grpc_end2end_proxy_destroy(grpc_end2end_proxy *proxy) {
grpc_server_shutdown_and_notify(proxy->server, proxy->cq,
new_closure(shutdown_complete, proxy));
gpr_thd_join(proxy->thd);
gpr_free(proxy->proxy_port);
gpr_free(proxy->server_port);
grpc_server_destroy(proxy->server);
grpc_channel_destroy(proxy->client);
grpc_completion_queue_destroy(proxy->cq);
grpc_call_details_destroy(&proxy->new_call_details);
gpr_free(proxy);
}
void
print_xml (void)
{
int level = 0;
FILE *out = xfopen (spec_xml_file, "w");
fputs ("<?xml version=\"1.0\"?>\n\n", out);
xml_printf (out, level,
"<bison-xml-report version=\"%s\" bug-report=\"%s\""
" url=\"%s\">",
xml_escape_n (0, VERSION),
xml_escape_n (1, PACKAGE_BUGREPORT),
xml_escape_n (2, PACKAGE_URL));
fputc ('\n', out);
xml_printf (out, level + 1, "<filename>%s</filename>",
xml_escape (grammar_file));
/* print grammar */
print_grammar (out, level + 1);
new_closure (nritems);
no_reduce_set = bitset_create (ntokens, BITSET_FIXED);
/* print automaton */
fputc ('\n', out);
xml_puts (out, level + 1, "<automaton>");
{
state_number i;
for (i = 0; i < nstates; i++)
print_state (out, level + 2, states[i]);
}
xml_puts (out, level + 1, "</automaton>");
bitset_free (no_reduce_set);
free_closure ();
xml_puts (out, 0, "</bison-xml-report>");
{
int i;
for (i = 0; i < num_escape_bufs; ++i)
free (escape_bufs[i].ptr);
}
xfclose (out);
}
static void on_c2p_sent_message(void *arg, int success) {
proxy_call *pc = arg;
grpc_op op;
grpc_call_error err;
grpc_byte_buffer_destroy(pc->p2s_msg);
if (!pc->proxy->shutdown && success) {
op.op = GRPC_OP_RECV_MESSAGE;
op.flags = 0;
op.reserved = NULL;
op.data.recv_message = &pc->p2s_msg;
refpc(pc, "on_p2s_recv_msg");
err = grpc_call_start_batch(pc->p2s, &op, 1,
new_closure(on_p2s_recv_msg, pc), NULL);
GPR_ASSERT(err == GRPC_CALL_OK);
}
unrefpc(pc, "on_c2p_sent_message");
}
static void on_p2s_recv_initial_metadata(void *arg, int success) {
proxy_call *pc = arg;
grpc_op op;
grpc_call_error err;
if (!pc->proxy->shutdown) {
op.op = GRPC_OP_SEND_INITIAL_METADATA;
op.flags = 0;
op.reserved = NULL;
op.data.send_initial_metadata.count = pc->p2s_initial_metadata.count;
op.data.send_initial_metadata.metadata = pc->p2s_initial_metadata.metadata;
refpc(pc, "on_c2p_sent_initial_metadata");
err = grpc_call_start_batch(
pc->c2p, &op, 1, new_closure(on_c2p_sent_initial_metadata, pc), NULL);
GPR_ASSERT(err == GRPC_CALL_OK);
}
unrefpc(pc, "on_p2s_recv_initial_metadata");
}
void
generate_states (void)
{
item_number initial_core = 0;
state_list *list = NULL;
allocate_storage ();
new_closure (nritems);
/* Create the initial state. The 0 at the lhs is the index of the
item of this initial rule. */
state_list_append (0, 1, &initial_core);
/* States are queued when they are created; process them all. */
for (list = first_state; list; list = list->next)
{
state *s = list->state;
if (trace_flag & trace_automaton)
fprintf (stderr, "Processing state %d (reached by %s)\n",
s->number,
symbols[s->accessing_symbol]->tag);
/* Set up itemset for the transitions out of this state. itemset gets a
vector of all the items that could be accepted next. */
closure (s->items, s->nitems);
/* Record the reductions allowed out of this state. */
save_reductions (s);
/* Find the itemsets of the states that shifts can reach. */
new_itemsets (s);
/* Find or create the core structures for those states. */
append_states (s);
/* Create the shifts structures for the shifts to those states,
now that the state numbers transitioning to are known. */
state_transitions_set (s, nshifts, shiftset);
}
/* discard various storage */
free_closure ();
free_storage ();
/* Set up STATES. */
set_states ();
}
static void on_p2s_status(void *arg, int success) {
proxy_call *pc = arg;
grpc_op op;
grpc_call_error err;
if (!pc->proxy->shutdown) {
GPR_ASSERT(success);
op.op = GRPC_OP_SEND_STATUS_FROM_SERVER;
op.flags = 0;
op.reserved = NULL;
op.data.send_status_from_server.trailing_metadata_count =
pc->p2s_trailing_metadata.count;
op.data.send_status_from_server.trailing_metadata =
pc->p2s_trailing_metadata.metadata;
op.data.send_status_from_server.status = pc->p2s_status;
op.data.send_status_from_server.status_details = pc->p2s_status_details;
refpc(pc, "on_c2p_sent_status");
err = grpc_call_start_batch(pc->c2p, &op, 1,
new_closure(on_c2p_sent_status, pc), NULL);
GPR_ASSERT(err == GRPC_CALL_OK);
}
unrefpc(pc, "on_p2s_status");
}
static void on_new_call(void *arg, int success) {
grpc_end2end_proxy *proxy = arg;
grpc_call_error err;
if (success) {
grpc_op op;
proxy_call *pc = gpr_malloc(sizeof(*pc));
memset(pc, 0, sizeof(*pc));
pc->proxy = proxy;
GPR_SWAP(grpc_metadata_array, pc->c2p_initial_metadata,
proxy->new_call_metadata);
pc->c2p = proxy->new_call;
pc->p2s = grpc_channel_create_call(
proxy->client, pc->c2p, GRPC_PROPAGATE_DEFAULTS, proxy->cq,
proxy->new_call_details.method, proxy->new_call_details.host,
proxy->new_call_details.deadline, NULL);
gpr_ref_init(&pc->refs, 1);
op.flags = 0;
op.reserved = NULL;
op.op = GRPC_OP_RECV_INITIAL_METADATA;
op.data.recv_initial_metadata = &pc->p2s_initial_metadata;
refpc(pc, "on_p2s_recv_initial_metadata");
err = grpc_call_start_batch(
pc->p2s, &op, 1, new_closure(on_p2s_recv_initial_metadata, pc), NULL);
GPR_ASSERT(err == GRPC_CALL_OK);
op.op = GRPC_OP_SEND_INITIAL_METADATA;
op.data.send_initial_metadata.count = pc->c2p_initial_metadata.count;
op.data.send_initial_metadata.metadata = pc->c2p_initial_metadata.metadata;
refpc(pc, "on_p2s_sent_initial_metadata");
err = grpc_call_start_batch(
pc->p2s, &op, 1, new_closure(on_p2s_sent_initial_metadata, pc), NULL);
GPR_ASSERT(err == GRPC_CALL_OK);
op.op = GRPC_OP_RECV_MESSAGE;
op.data.recv_message = &pc->c2p_msg;
refpc(pc, "on_c2p_recv_msg");
err = grpc_call_start_batch(pc->c2p, &op, 1,
new_closure(on_c2p_recv_msg, pc), NULL);
GPR_ASSERT(err == GRPC_CALL_OK);
op.op = GRPC_OP_RECV_MESSAGE;
op.data.recv_message = &pc->p2s_msg;
refpc(pc, "on_p2s_recv_msg");
err = grpc_call_start_batch(pc->p2s, &op, 1,
new_closure(on_p2s_recv_msg, pc), NULL);
GPR_ASSERT(err == GRPC_CALL_OK);
op.op = GRPC_OP_RECV_STATUS_ON_CLIENT;
op.data.recv_status_on_client.trailing_metadata =
&pc->p2s_trailing_metadata;
op.data.recv_status_on_client.status = &pc->p2s_status;
op.data.recv_status_on_client.status_details = &pc->p2s_status_details;
op.data.recv_status_on_client.status_details_capacity =
&pc->p2s_status_details_capacity;
refpc(pc, "on_p2s_status");
err = grpc_call_start_batch(pc->p2s, &op, 1, new_closure(on_p2s_status, pc),
NULL);
GPR_ASSERT(err == GRPC_CALL_OK);
op.op = GRPC_OP_RECV_CLOSE_ON_SERVER;
op.data.recv_close_on_server.cancelled = &pc->c2p_server_cancelled;
refpc(pc, "on_c2p_closed");
err = grpc_call_start_batch(pc->c2p, &op, 1, new_closure(on_c2p_closed, pc),
NULL);
GPR_ASSERT(err == GRPC_CALL_OK);
request_call(proxy);
unrefpc(pc, "init");
} else {
GPR_ASSERT(proxy->new_call == NULL);
}
}
// executes a ZAM instruction, returns the term to continue working on
char*
ZAM_term(struct ccnl_relay_s *ccnl, struct configuration_s *config,
int *halt, char *dummybuf, int *restart)
{
// struct ccnl_lambdaTerm_s *t;
// char *pending, *p, *cp, *prog = config->prog;
// int len;
char *prog = config->prog;
struct builtin_s *bp;
char *arg, *contd;
int tok;
//pop closure
if (!prog || strlen(prog) == 0) {
if (config->result_stack) {
prog = ccnl_malloc(strlen((char*)config->result_stack->content)+1);
strcpy(prog, config->result_stack->content);
return prog;
}
DEBUGMSG(DEBUG, "no result returned\n");
return NULL;
}
tok = ZAM_nextToken(prog, &arg, &contd);
// TODO: count opening/closing parentheses when hunting for ';' ?
/*
pending = strchr(prog, ';');
p = strchr(prog, '(');
*/
switch (tok) {
case ZAM_ACCESS:
{
struct closure_s *closure = search_in_environment(config->env, arg);
DEBUGMSG(DEBUG, "---to do: access <%s>\n", arg);
if (!closure) {
// TODO: is the following needed? Above search should have
// visited global_dict, already!
closure = search_in_environment(config->global_dict, arg);
if (!closure) {
DEBUGMSG(WARNING, "?? could not lookup var %s\n", arg);
ccnl_free(arg);
return NULL;
}
}
ccnl_free(arg);
closure = new_closure(ccnl_strdup(closure->term), closure->env);
push_to_stack(&config->argument_stack, closure, STACK_TYPE_CLOSURE);
return ccnl_strdup(contd);
}
case ZAM_APPLY:
{
struct stack_s *fct = pop_from_stack(&config->argument_stack);
struct stack_s *par = pop_from_stack(&config->argument_stack);
struct closure_s *fclosure, *aclosure;
char *code;
DEBUGMSG(DEBUG, "---to do: apply\n");
if (!fct || !par)
return NULL;
fclosure = (struct closure_s *) fct->content;
aclosure = (struct closure_s *) par->content;
if (!fclosure || !aclosure)
return NULL;
ccnl_free(fct);
ccnl_free(par);
code = aclosure->term;
if (config->env)
ccnl_nfn_releaseEnvironment(&config->env);
config->env = aclosure->env;
ccnl_free(aclosure);
push_to_stack(&config->argument_stack, fclosure, STACK_TYPE_CLOSURE);
if (contd)
sprintf(dummybuf, "%s;%s", code, contd);
else
strcat(dummybuf, code);
ccnl_free(code);
return ccnl_strdup(dummybuf);
}
case ZAM_CALL:
{
struct stack_s *h = pop_or_resolve_from_result_stack(ccnl, config);
int i, offset, num_params = *(int *)h->content;
char name[5];
DEBUGMSG(DEBUG, "---to do: CALL <%s>\n", arg);
ccnl_free(h->content);
ccnl_free(h);
sprintf(dummybuf, "CLOSURE(FOX);RESOLVENAME(@op(");
// ... @x(@y y x 2 op)));TAILAPPLY";
offset = strlen(dummybuf);
for (i = 0; i < num_params; ++i) {
sprintf(name, "x%d", i);
offset += sprintf(dummybuf+offset, "@%s(", name);
}
for (i = num_params - 1; i >= 0; --i) {
sprintf(name, "x%d", i);
offset += sprintf(dummybuf+offset, " %s", name);
}
offset += sprintf(dummybuf + offset, " %d", num_params);
offset += sprintf(dummybuf+offset, " op");
for (i = 0; i < num_params+2; ++i)
offset += sprintf(dummybuf + offset, ")");
if (contd)
sprintf(dummybuf + offset, ";%s", contd);
return ccnl_strdup(dummybuf);
}
case ZAM_CLOSURE:
{
struct closure_s *closure;
DEBUGMSG(DEBUG, "---to do: closure <%s> (contd=%s)\n", arg, contd);
if (!config->argument_stack && !strncmp(arg, "RESOLVENAME(", 12)) {
char v[500], *c;
int len;
c = strchr(arg+12, ')');
if (!c)
goto normal;
len = c - (arg+12);
memcpy(v, arg+12, len);
v[len] = '\0';
closure = search_in_environment(config->env, v);
if (!closure)
goto normal;
if (!strcmp(closure->term, arg)) {
DEBUGMSG(WARNING, "** detected tail recursion case %s/%s\n",
closure->term, arg);
} else
goto normal;
} else {
normal:
closure = new_closure(arg, config->env);
//configuration->env = NULL;//FIXME new environment?
push_to_stack(&config->argument_stack, closure, STACK_TYPE_CLOSURE);
arg = NULL;
}
if (contd) {
ccnl_free(arg);
return ccnl_strdup(contd);
}
DEBUGMSG(ERROR, "** not implemented, see line %d\n", __LINE__);
return arg;
}
case ZAM_FOX:
return ZAM_fox(ccnl, config, restart, halt, prog, arg, contd);
case ZAM_GRAB:
{
struct stack_s *stack = pop_from_stack(&config->argument_stack);
DEBUGMSG(DEBUG, "---to do: grab <%s>\n", arg);
add_to_environment(&config->env, arg, stack->content);
ccnl_free(stack);
return ccnl_strdup(contd);
}
case ZAM_HALT:
ccnl_nfn_freeStack(config->argument_stack);
//ccnl_nfn_freeStack(config->result_stack);
config->argument_stack = /*config->result_stack =*/ NULL;
*halt = 1;
return ccnl_strdup(contd);
case ZAM_RESOLVENAME:
return ZAM_resolvename(config, dummybuf, arg, contd);
case ZAM_TAILAPPLY:
{
struct stack_s *stack = pop_from_stack(&config->argument_stack);
struct closure_s *closure = (struct closure_s *) stack->content;
char *code = closure->term;
DEBUGMSG(DEBUG, "---to do: tailapply\n");
ccnl_free(stack);
if (contd) //build new term
sprintf(dummybuf, "%s;%s", code, contd);
else
strcpy(dummybuf, code);
if (config->env)
ccnl_nfn_releaseEnvironment(&config->env);
config->env = closure->env; //set environment from closure
ccnl_free(code);
ccnl_free(closure);
return ccnl_strdup(dummybuf);
}
case ZAM_UNKNOWN:
break;
default:
DEBUGMSG(DEBUG, "builtin: %s (%s/%s)\n", bifs[-tok - 1].name, prog, contd);
return bifs[-tok - 1].fct(ccnl, config, restart, halt, prog,
contd, &config->result_stack);
}
ccnl_free(arg);
// iterate through all extension operations
for (bp = op_extensions; bp; bp = bp->next)
if (!strncmp(prog, bp->name, strlen(bp->name)))
return (bp->fct)(ccnl, config, restart, halt, prog,
contd, &config->result_stack);
DEBUGMSG(INFO, "unknown (built-in) command <%s>\n", prog);
return NULL;
}
char*
ZAM_resolvename(struct configuration_s *config, char *dummybuf,
char *arg, char *contd)
{
struct ccnl_lambdaTerm_s *t;
char res[1000], *cp = arg;
int len;
DEBUGMSG(DEBUG, "---to do: resolveNAME <%s>\n", arg);
//function definition
if (!strncmp(cp, "let", 3)) {
int i, end = 0, cp2len, namelength, lambdalen;
char *h, *cp2, *name, *lambda_expr, *resolveterm;
DEBUGMSG(DEBUG, " fct definition: %s\n", cp);
strcpy(res, cp+3);
for (i = 0; i < strlen(res); ++i) {
if (!strncmp(res+i, "endlet", 6)) {
end = i;
break;
}
}
cp2len = strlen(res+end) + strlen("RESOLVENAME()");
h = strchr(cp, '=');
namelength = h - cp;
lambda_expr = ccnl_malloc(strlen(h));
name = ccnl_malloc(namelength);
cp2 = ccnl_malloc(cp2len);
memset(cp2, 0, cp2len);
memset(name, 0, namelength);
memset(lambda_expr, 0, strlen(h));
sprintf(cp2, "RESOLVENAME(%s)", res+end+7); //add 7 to overcome endlet
memcpy(name, cp+3, namelength-3); //copy name without let and endlet
trim(name);
lambdalen = strlen(h)-strlen(cp2)+11-6;
memcpy(lambda_expr, h+1, lambdalen); //copy lambda expression without =
trim(lambda_expr);
resolveterm = ccnl_malloc(strlen("RESOLVENAME()")+strlen(lambda_expr));
sprintf(resolveterm, "RESOLVENAME(%s)", lambda_expr);
add_to_environment(&config->env, name, new_closure(resolveterm, NULL));
ccnl_free(cp);
return strdup(contd);
}
//check if term can be made available, if yes enter it as a var
//try with searching in global env for an added term!
t = ccnl_lambdaStrToTerm(0, &cp, NULL);
ccnl_free(arg);
if (term_is_var(t)) {
char *end = 0;
cp = t->v;
if (isdigit(*cp)) {
// is disgit...
int *integer = ccnl_malloc(sizeof(int));
*integer = strtol(cp, &end, 0);
if (end && *end)
end = 0;
if (end)
push_to_stack(&config->result_stack, integer, STACK_TYPE_INT);
else
ccnl_free(integer);
} else if (*cp == '\'') { // quoted name (constant)
//determine size
struct const_s *con = ccnl_nfn_krivine_str2const(cp);
push_to_stack(&config->result_stack, con, STACK_TYPE_CONST);
end = (char*)1;
} else if (iscontentname(cp)) { // is content...
struct ccnl_prefix_s *prefix;
prefix = ccnl_URItoPrefix(cp, config->suite, NULL, NULL);
push_to_stack(&config->result_stack, prefix, STACK_TYPE_PREFIX);
end = (char*)1;
}
if (end) {
if (contd)
sprintf(res, "TAILAPPLY;%s", contd);
else
sprintf(res, "TAILAPPLY");
} else {
if (contd)
sprintf(res, "ACCESS(%s);TAILAPPLY;%s", t->v, contd);
else
sprintf(res, "ACCESS(%s);TAILAPPLY", t->v);
}
ccnl_lambdaFreeTerm(t);
return ccnl_strdup(res);
}
if (term_is_lambda(t)) {
char *var;
var = t->v;
ccnl_lambdaTermToStr(dummybuf, t->m, 0);
if (contd)
sprintf(res, "GRAB(%s);RESOLVENAME(%s);%s", var, dummybuf, contd);
else
sprintf(res, "GRAB(%s);RESOLVENAME(%s)", var, dummybuf);
ccnl_lambdaFreeTerm(t);
return ccnl_strdup(res);
}
if (term_is_app(t)) {
ccnl_lambdaTermToStr(dummybuf, t->n, 0);
len = sprintf(res, "CLOSURE(RESOLVENAME(%s));", dummybuf);
ccnl_lambdaTermToStr(dummybuf, t->m, 0);
len += sprintf(res+len, "RESOLVENAME(%s)", dummybuf);
if (contd)
len += sprintf(res+len, ";%s", contd);
ccnl_lambdaFreeTerm(t);
return ccnl_strdup(res);
}
return NULL;
}
