// executes (loops over) a Lambda expression: tries to run to termination, // or returns after having emitted further remote lookup/reduction requests // the return val is a buffer with the result stack's (concatenated) content struct ccnl_buf_s* Krivine_reduction(struct ccnl_relay_s *ccnl, char *expression, int start_locally, struct configuration_s **config, struct ccnl_prefix_s *prefix, int suite) { int steps = 0, halt = 0, restart = 1; int len = strlen("CLOSURE(HALT);RESOLVENAME()") + strlen(expression) + 1; char *dummybuf; DEBUGMSG(TRACE, "Krivine_reduction()\n"); if (!*config && strlen(expression) == 0) return 0; dummybuf = ccnl_malloc(2000); if (!*config) { char *prog; struct environment_s *global_dict = NULL; prog = ccnl_malloc(len*sizeof(char)); sprintf(prog, "CLOSURE(HALT);RESOLVENAME(%s)", expression); setup_global_environment(&global_dict); DEBUGMSG(DEBUG, "PREFIX %s\n", ccnl_prefix_to_path(prefix)); *config = new_config(ccnl, prog, global_dict, start_locally, prefix, ccnl->km->configid, suite); DBL_LINKED_LIST_ADD(ccnl->km->configuration_list, (*config)); restart = 0; --ccnl->km->configid; } DEBUGMSG(INFO, "Prog: %s\n", (*config)->prog); while ((*config)->prog && !halt) { char *oldprog = (*config)->prog; steps++; DEBUGMSG(DEBUG, "Step %d (%d/%d): %s\n", steps, stack_len((*config)->argument_stack), stack_len((*config)->result_stack), (*config)->prog); (*config)->prog = ZAM_term(ccnl, *config, &halt, dummybuf, &restart); ccnl_free(oldprog); } ccnl_free(dummybuf); if (halt < 0) { //HALT < 0 means pause computation DEBUGMSG(INFO,"Pause computation: %d\n", -(*config)->configid); return NULL; } //HALT > 0 means computation finished DEBUGMSG(INFO, "end-of-computation (%d/%d)\n", stack_len((*config)->argument_stack), stack_len((*config)->result_stack)); /* print_argument_stack((*config)->argument_stack); print_result_stack((*config)->result_stack); */ return Krivine_exportResultStack(ccnl, *config); }
int stack_top(stack_t *s, void *value) { if (stack_len(s) > 0) { memcpy(value, s->data + s->ele_size * s->top, s->ele_size); return 0; } return -1; }
void exec_op_code(Stack* s, int op, int n) { int output = 0; int a, b; switch (op) { case OPCODE_LEN: output = (int)stack_len(s); break; case OPCODE_TOP: output = stack_top(s); break; case OPCODE_POP: output = stack_pop(s); break; case OPCODE_PUSH: output = stack_push(s, n); break; case OPCODE_ADD: a = stack_pop(s); b = stack_pop(s); output = a + b; stack_push(s, output); break; case OPCODE_SUB: a = stack_pop(s); b = stack_pop(s); output = a - b; stack_push(s, output); break; case OPCODE_MUL: a = stack_pop(s); b = stack_pop(s); output = a * b; stack_push(s, output); break; case OPCODE_DIV: a = stack_pop(s); b = stack_pop(s); output = a / b; stack_push(s, output); break; case OPCODE_MOD: a = stack_pop(s); b = stack_pop(s); output = a % b; stack_push(s, output); break; case OPCODE_EXIT: exit(1); break; default: puts("Unknown Command"); } printf("%d\n", output); }
int stack_pop(stack_t *s, void *value) { /* Value that is popped from the stack is placed in value parameter, * @param s: Pointer to stack_t type variable * @param x: Pointer to a variable to store the value popped from the stack * Returns: Zero if stack is not empty when stack_pop() is called, * -1 Otherwise */ if (stack_len(s) > 0) { memcpy(value, s->data + s->ele_size * s->top, s->ele_size); s->top--; return 0; } else { return -1; } }
int stack_push(stack_t *s, void *x) { /* Pushes an element on to the stack * @param s: Pointer to stack_t type variable * @param x: Value to Push on to the stack * Returns : Zero if stack is not full when stack_push() is called, * -1 Otherwise */ if (stack_len(s) < s->capacity) { s->top++; memcpy(s->data + s->ele_size * s->top, x, s->ele_size); return 0; } else { return -1; } }
void sortLinkedList_Nums(Node *head) { Node *temp; int i; /* since the compare dereferences temp->next you'll have to verify that it is not NULL */ for (i = 0; i < stack_len(head); i++) { for (temp = head; temp && temp->next; temp = temp->next) { int32_t* blah = (int32_t *) temp->data; int32_t * blahNext = (int32_t *) temp->next->data; if (*blah > *blahNext) { /* no need for a whole node, since you only copy a pointer */ int32_t *cp; cp = temp->data; temp->data = temp->next->data; temp->next->data = cp; } } } }
void sortLinkedList_Names(Node *head) { Node *temp; int i; /* since the compare dereferences temp->next you'll have to verify that it is not NULL */ for (i = 0; i < stack_len(head); i++) { for (temp = head; temp && temp->next; temp = temp->next) { person* blah = (person *) temp->data; person * blahNext = (person *) temp->next->data; if (strcmp(blah->name, blahNext->name) > 0) { /* no need for a whole node, since you only copy a pointer */ person *cp; cp = temp->data; temp->data = temp->next->data; temp->next->data = cp; } } } }
static bool daemon_serve(int s, char *cmd) { /* Do <cmd> for client connected on <s>. */ static Node *null=NULL, **stack=&null; char buf[FILEPATH_MAX]; bool keep_running=true; if( strcmp(cmd, CMD_PUSH) == 0 ) { char *status; if( stack_len(stack) >= STACK_MAX ) { printf("daemon: push request failed (stack full)\n"); status = MSG_ERROR; strcpy(buf, MSG_ERR_STACK_FULL); } else { soc_w(s, MSG_SUCCESS); if( soc_r(s, buf, FILEPATH_MAX) <= 0 ) { printf("daemon: push request failed (read error)\n"); status = MSG_ERROR; strcpy(buf, MSG_ERR_LENGTH); } else { status = MSG_SUCCESS; stack_push(buf, stack); printf("daemon: PUSH `%s'\n", buf); } } soc_w(s, status); soc_w(s, buf); } else if( strcmp(cmd, CMD_POP) == 0 ) { char *status; if( stack_len(stack) > 0 ) { status = MSG_SUCCESS; sprintf(buf, "%s", stack_peek(stack)); stack_drop(stack); printf("daemon: POP `%s'\n", buf); } else { printf("daemon: tried to pop from empty stack\n"); status = MSG_ERROR; sprintf(buf, MSG_ERR_STACK_EMPTY); } soc_w(s, status); soc_w(s, buf); } else if( strcmp(cmd, CMD_PEEK) == 0 ) { char *status; if( stack_len(stack) > 0 ) { status = MSG_SUCCESS; sprintf(buf, "%s", stack_peek(stack)); } else { status = MSG_ERROR; sprintf(buf, MSG_ERR_STACK_EMPTY); } soc_w(s, status); soc_w(s, buf); } else if( strcmp(cmd, CMD_PICK) == 0 ) { char *picked; soc_w(s, MSG_SUCCESS); soc_r(s, buf, MSG_MAX); picked = stack_nth(atoi(buf), stack); if( picked == NULL ) { soc_w(s, MSG_ERROR); soc_w(s, "stack is not quite that deep"); } else { soc_w(s, MSG_SUCCESS); soc_w(s, picked); } } else if( strcmp(cmd, CMD_SIZE) == 0 ) { sprintf(buf, "%d", stack_len(stack)); soc_w(s, buf); } else if( strcmp(cmd, CMD_STOP) == 0 ) { printf("daemon: Shutting down...\n"); soc_w(s, MSG_SUCCESS); keep_running = false; } else { char msg[MSG_MAX + FILEPATH_MAX]; sprintf(msg, "unknown command `%s'", cmd); soc_w(s, msg); } return keep_running; }