void simple_menu_select_game::inkey_select(const event *menu_event) { const game_driver *driver = (const game_driver *)menu_event->itemref; // special case for configure inputs if ((FPTR)driver == 1) menu::stack_push<menu_game_options>(ui(), container()); // anything else is a driver else { // audit the game first to see if we're going to work driver_enumerator enumerator(machine().options(), *driver); enumerator.next(); media_auditor auditor(enumerator); media_auditor::summary summary = auditor.audit_media(AUDIT_VALIDATE_FAST); // if everything looks good, schedule the new driver if (summary == media_auditor::CORRECT || summary == media_auditor::BEST_AVAILABLE || summary == media_auditor::NONE_NEEDED) { mame_machine_manager::instance()->schedule_new_driver(*driver); machine().schedule_hard_reset(); stack_reset(); } // otherwise, display an error else { reset(reset_options::REMEMBER_REF); m_error = true; } } }
int main(int argc, char *argv[]) { char *buf, line[BUFSIZ + 1]; if (argc > 1 && strcmp(argv[1], "-v") == 0) { fprintf(stderr, "::Stack dumps enabled::\n"); verbose = 2; } stackptr = &opstack[0]; /* initialize stack */ /* If stdin has data, hit it and quit it */ if (!isatty(fileno(stdin))) { fgets(line, BUFSIZ, stdin); parse_expression(line); freopen(ctermid(NULL), "r", stdin); return 0; } /* going interactive. fire up readline */ using_history(); while ((buf = readline("> ")) != NULL) { add_history(buf); strcpy(line, buf); parse_expression(line); stack_reset(); free(buf); } putchar('\n'); clear_history(); return 0; }
int powaur_crawl(alpm_list_t *targets) { int ret = 0; char cwd[PATH_MAX]; if (!getcwd(cwd, PATH_MAX)) { return error(PW_ERR_GETCWD); } if (chdir(powaur_dir)) { return error(PW_ERR_CHDIR, powaur_dir); } struct pw_hashdb *hashdb = build_hashdb(); if (!hashdb) { pw_fprintf(PW_LOG_ERROR, stderr, "Unable to build hash database!\n"); ret = -1; } alpm_list_t *i, *target_pkgs; struct graph *graph; struct stack *topost = stack_new(sizeof(int)); int have_cycles; for (i = targets; i; i = i->next) { stack_reset(topost); graph = NULL; target_pkgs = alpm_list_add(NULL, i->data); build_dep_graph(&graph, hashdb, target_pkgs, RESOLVE_THOROUGH); if (have_cycles) { printf("Cyclic dependencies for package \"%s\"\n", i->data); } graph_toposort(graph, topost); if (stack_empty(topost)) { printf("Package \"%s\" has no dependencies.\n", i->data); } else { printf("\n"); pw_printf(PW_LOG_INFO, "\"%s\" topological order: ", i->data); print_topo_order(graph, topost); } graph_free(graph); alpm_list_free(target_pkgs); } stack_free(topost); hashdb_free(hashdb); if (chdir(cwd)) { return error(PW_ERR_RESTORECWD); } return ret; }
static void jq_reset(jq_state *jq) { while (stack_restore(jq)) {} assert(jq->stk_top == 0); assert(jq->fork_top == 0); assert(jq->curr_frame == 0); stack_reset(&jq->stk); if (jv_get_kind(jq->path) != JV_KIND_INVALID) jv_free(jq->path); jq->path = jv_null(); jq->subexp_nest = 0; }
int main(int argc, char** argv) { char buf[256]; regex_t regex_value, regex_operation; regcomp(®ex_value, "[0-9]+\\.?[0-9]*", REG_EXTENDED | REG_NOSUB); regcomp(®ex_operation, "[\\+\\-\\*\\/\\^]", REG_EXTENDED | REG_NOSUB); while(1) { stack_reset(); putchar('>'); fgets(buf, 256, stdin); for(char* token = strtok(buf, " "); token != NULL; token = strtok(NULL, " ")) { if(regexec(®ex_value, token, 0, NULL, 0) == 0) { stack_push(strtod(token, NULL)); } else if(regexec(®ex_operation, token, 0, NULL, 0) == 0) { double rhs = stack_pop(); double lhs = stack_pop(); switch(token[0]) { case '+': stack_push(lhs+rhs); break; case '-': stack_push(lhs-rhs); break; case '*': stack_push(lhs*rhs); break; case '/': stack_push(lhs/rhs); break; case '^': stack_push(pow(lhs,rhs)); break; } } else { printf("Giving Up: Unrecognised input: %s\n", token); stack_reset(); break; } } if(stack_size() > 0) { printf(">> %f\n", stack_pop()); } } return 0; }
static char * test_initial_state() { stack_reset(); /* test multiple braces */ sprintf(msg, "ERROR: %d: init_state: should not be empty", __LINE__); mu_assert(msg, stack_is_empty()); sprintf(msg, "ERROR: %d: init_state: should not be full", __LINE__); mu_assert(msg, ! stack_is_full()); push(1); sprintf(msg, "ERROR: %d: init_state: should not be empty", __LINE__); mu_assert(msg, ! stack_is_empty()); sprintf(msg, "ERROR: %d: init_state: should not be full", __LINE__); mu_assert(msg, ! stack_is_full()); return EXIT_SUCCESS; }
static char * test_push_till_full() { int i = 0; stack_reset(); for (i = 0; i < MAX_INTSTACK - 1; i++) { push(i); sprintf(msg, "ERROR: %d: iter %d: push_till_full: should not be full", __LINE__, i); mu_assert(msg, ! stack_is_full()); sprintf(msg, "ERROR: %d: iter %d: push_till_full: should not be full", __LINE__, i); mu_assert(msg, ! stack_is_empty()); } push(INT_MAX); sprintf(msg, "ERROR: %d: push_till_full: should not be empty", __LINE__); mu_assert(msg, ! stack_is_empty()); sprintf(msg, "ERROR: %d: push_till_full: should be full", __LINE__); mu_assert(msg, stack_is_full()); return EXIT_SUCCESS; }
static char * test_peek() { stack_reset(); // peek should return INT_MIN (with warning) when intstack is empty sprintf(msg, "ERROR: %d: peek should return INT_MIN when empty", __LINE__); mu_assert(msg, peek() == INT_MIN); push(55); sprintf(msg, "ERROR: %d: peek should return expected", __LINE__); mu_assert(msg, peek() == 55); sprintf(msg, "ERROR: %d: peek should return expected", __LINE__); mu_assert(msg, peek() == 55); sprintf(msg, "ERROR: %d: peek should return expected", __LINE__); mu_assert(msg, peek() == 55); push(56); sprintf(msg, "ERROR: %d: peek should return expected", __LINE__); mu_assert(msg, peek() == 56); sprintf(msg, "ERROR: %d: peek should return expected", __LINE__); mu_assert(msg, peek() == 56); sprintf(msg, "ERROR: %d: push_till_full: should not be empty", __LINE__); mu_assert(msg, ! stack_is_empty()); sprintf(msg, "ERROR: %d: push_till_full: should not be full", __LINE__); mu_assert(msg, ! stack_is_full()); pop(); sprintf(msg, "ERROR: %d: peek should return expected", __LINE__); mu_assert(msg, peek() == 55); pop(); sprintf(msg, "ERROR: %d: peek should return expected", __LINE__); mu_assert(msg, peek() == INT_MIN); return EXIT_SUCCESS; }
int dp_can_connect_str(str *domain, int rec_level) { struct rdata* head; struct rdata* l; struct naptr_rdata* naptr; struct naptr_rdata* next_naptr; int ret; str newdomain; char uri[MAX_URI_SIZE]; struct avp_stack stack; int last_order = -1; int failed = 0; int found_anything = 0; str pattern, replacement, result; stack_reset(&stack); /* If we're in a recursive call, set the domain-replacement */ if ( rec_level > 0 ) { stack_push(&stack, domain_replacement_name.s.s, domain->s); stack.succeeded = 0; } if (rec_level > MAX_DDDS_RECURSIONS) { LM_ERR("too many indirect NAPTRs. Aborting at %.*s.\n", domain->len, ZSW(domain->s)); return(DP_DDDS_RET_DNSERROR); } LM_INFO("looking up Domain itself: %.*s\n",domain->len, ZSW(domain->s)); ret = check_rule(domain,"D2P+sip:dom", 11, &stack); if (ret == 1) { LM_INFO("found a match on domain itself\n"); stack_to_avp(&stack); return(DP_DDDS_RET_POSITIVE); } else if (ret == 0) { LM_INFO("no match on domain itself.\n"); stack_reset(&stack); /* If we're in a recursive call, set the domain-replacement */ if ( rec_level > 0 ) { stack_push(&stack, domain_replacement_name.s.s, (char *) domain->s); stack.succeeded = 0; } } else { return(DP_DDDS_RET_DNSERROR); /* actually: DB error */ } LM_INFO("doing DDDS with %.*s\n",domain->len, ZSW(domain->s)); head = get_record(domain->s, T_NAPTR, RES_ONLY_TYPE); if (head == 0) { LM_NOTICE("no NAPTR record found for %.*s.\n", domain->len, ZSW(domain->s)); return(DP_DDDS_RET_NOTFOUND); } LM_DBG("found the following NAPTRs: \n"); for (l = head; l; l = l->next) { if (l->type != T_NAPTR) { LM_DBG("found non-NAPTR record.\n"); continue; /*should never happen*/ } naptr = (struct naptr_rdata*)l->rdata; if (naptr == 0) { LM_CRIT("null rdata\n"); continue; } LM_DBG("order %u, pref %u, flen %u, flags '%.*s', slen %u, " "services '%.*s', rlen %u, regexp '%.*s', repl '%s'\n", naptr->order, naptr->pref, naptr->flags_len, (int)(naptr->flags_len), ZSW(naptr->flags), naptr->services_len, (int)(naptr->services_len), ZSW(naptr->services), naptr->regexp_len, (int)(naptr->regexp_len), ZSW(naptr->regexp), ZSW(naptr->repl) ); } LM_DBG("sorting...\n"); naptr_sort(&head); for (l = head; l; l = l->next) { if (l->type != T_NAPTR) continue; /*should never happen*/ naptr = (struct naptr_rdata*)l->rdata; if (naptr == 0) { LM_CRIT("null rdata\n"); continue; } LM_DBG("considering order %u, pref %u, flen %u, flags '%.*s', slen %u, " "services '%.*s', rlen %u, regexp '%.*s', repl '%s'\n", naptr->order, naptr->pref, naptr->flags_len, (int)(naptr->flags_len), ZSW(naptr->flags), naptr->services_len, (int)(naptr->services_len), ZSW(naptr->services), naptr->regexp_len, (int)(naptr->regexp_len), ZSW(naptr->regexp), ZSW(naptr->repl) ); /* * New order? then we check whether the had success during the last one. * If yes, we can leave the loop. */ if (last_order != naptr->order) { last_order = naptr->order; failed = 0; if (stack_succeeded(&stack)) { LM_INFO("we don't need to consider further orders " "(starting with %d).\n",last_order); break; } } else if (failed) { LM_INFO("order %d has already failed.\n",last_order); continue; } /* * NAPTRs we don't care about */ if (!IS_D2PNAPTR(naptr)) continue; /* * once we've been here, don't return DP_DDDS_RET_NOTFOUND */ found_anything = 1; next_naptr = NULL; if (l->next && (l->next->type == T_NAPTR)) { next_naptr = (struct naptr_rdata*)l->next->rdata; } /* * Non-terminal? */ if ((naptr->services_len == 7) && !strncasecmp("D2P+SIP", naptr->services,7) && (naptr->flags_len == 0)){ LM_INFO("found non-terminal NAPTR\n"); /* * This needs to be the only record with this order. */ if (next_naptr && (next_naptr->order == naptr->order) && IS_D2PNAPTR(next_naptr)) { LM_ERR("non-terminal NAPTR needs to be the only one " "with this order %.*s.\n", domain->len, ZSW(domain->s)); return(DP_DDDS_RET_DNSERROR); } newdomain.s = naptr->repl; newdomain.len = strlen(naptr->repl); ret = dp_can_connect_str(&newdomain, rec_level + 1); if (ret == DP_DDDS_RET_POSITIVE) /* succeeded, we're done. */ return(ret); if (ret == DP_DDDS_RET_NEGATIVE) /* found rules, did not work */ continue; /* look for more rules */ if (ret == DP_DDDS_RET_DNSERROR) /* errors during lookup */ return(ret); /* report them */ if (ret == DP_DDDS_RET_NOTFOUND) /* no entries in linked domain? */ return(ret); /* ok, fine. go with that */ continue; /* not reached */ } /* * wrong kind of terminal */ if ((naptr->flags_len != 1) || (tolower(naptr->flags[0]) != 'u')) { LM_ERR("terminal NAPTR needs flag = 'u' and not '%.*s'.\n", (int)naptr->flags_len, ZSW(naptr->flags)); /* * It's not that clear what we should do now: Ignore this records or regard it as failed. * We go with "ignore" for now. */ continue; } if (parse_naptr_regexp(&(naptr->regexp[0]), naptr->regexp_len, &pattern, &replacement) < 0) { LM_ERR("parsing of NAPTR regexp failed\n"); continue; } result.s = &(uri[0]); result.len = MAX_URI_SIZE; /* Avoid making copies of pattern and replacement */ pattern.s[pattern.len] = (char)0; replacement.s[replacement.len] = (char)0; if (reg_replace(pattern.s, replacement.s, domain->s, &result) < 0) { pattern.s[pattern.len] = '!'; replacement.s[replacement.len] = '!'; LM_ERR("regexp replace failed\n"); continue; } LM_INFO("resulted in replacement: '%.*s'\n", result.len, ZSW(result.s)); pattern.s[pattern.len] = '!'; replacement.s[replacement.len] = '!'; ret = check_rule(&result,naptr->services,naptr->services_len, &stack); if (ret == 1) { LM_INFO("positive return\n"); } else if (ret == 0) { LM_INFO("check_rule failed.\n"); stack_reset(&stack); /* If we're in a recursive call, set the domain-replacement */ if ( rec_level > 0 ) { stack_push(&stack, domain_replacement_name.s.s, (char *) domain->s); stack.succeeded = 0; } failed = 1; } else { return(DP_DDDS_RET_DNSERROR); } } if (stack_succeeded(&stack)) { LM_INFO("calling stack_to_avp.\n"); stack_to_avp(&stack); return(DP_DDDS_RET_POSITIVE); } LM_INFO("returning %d.\n", (found_anything ? DP_DDDS_RET_NEGATIVE : DP_DDDS_RET_NOTFOUND)); return( found_anything ? DP_DDDS_RET_NEGATIVE : DP_DDDS_RET_NOTFOUND ); }
static char * test_push_pop() { int i; stack_reset(); /* push one, pop one */ push(INT_MAX); sprintf(msg, "ERROR: %d: should pop expected", __LINE__); mu_assert(msg, pop() == INT_MAX); sprintf(msg, "ERROR: %d: should be empty", __LINE__); mu_assert(msg, stack_is_empty()); sprintf(msg, "ERROR: %d: should pop INT_MIN when empty", __LINE__); mu_assert(msg, pop() == INT_MIN); sprintf(msg, "ERROR: %d: should pop INT_MIN when empty", __LINE__); mu_assert(msg, pop() == INT_MIN); /* push three, pop two */ push(INT_MAX); push(-1); push(44); sprintf(msg, "ERROR: %d: should pop expected", __LINE__); mu_assert(msg, pop() == 44); sprintf(msg, "ERROR: %d: should pop expected", __LINE__); mu_assert(msg, pop() == -1); /* push three, pop one */ push(1); push(2); push(3); sprintf(msg, "ERROR: %d: should pop expected", __LINE__); mu_assert(msg, pop() == 3); /* should have three on intstack - add till full */ for (i = 30; ! stack_is_full(); i++) { push(i); } sprintf(msg, "ERROR: %d: should be full", __LINE__); mu_assert(msg, stack_is_full()); /* now pop all remaining and test values */ sprintf(msg, "ERROR: %d: should pop expected", __LINE__); mu_assert(msg, pop() == 36); sprintf(msg, "ERROR: %d: should pop expected", __LINE__); mu_assert(msg, pop() == 35); sprintf(msg, "ERROR: %d: should pop expected", __LINE__); mu_assert(msg, pop() == 34); sprintf(msg, "ERROR: %d: should pop expected", __LINE__); mu_assert(msg, pop() == 33); sprintf(msg, "ERROR: %d: should pop expected", __LINE__); mu_assert(msg, pop() == 32); sprintf(msg, "ERROR: %d: should pop expected", __LINE__); mu_assert(msg, pop() == 31); sprintf(msg, "ERROR: %d: should pop expected", __LINE__); mu_assert(msg, pop() == 30); sprintf(msg, "ERROR: %d: should pop expected", __LINE__); mu_assert(msg, pop() == 2); sprintf(msg, "ERROR: %d: should pop expected", __LINE__); mu_assert(msg, pop() == 1); sprintf(msg, "ERROR: %d: should pop expected", __LINE__); mu_assert(msg, pop() == INT_MAX); sprintf(msg, "ERROR: %d: should be empty", __LINE__); mu_assert(msg, stack_is_empty()); sprintf(msg, "ERROR: %d: should pop expected", __LINE__); mu_assert(msg, pop() == INT_MIN); return EXIT_SUCCESS; }