tree xml_html_parser::parse_doctype () { s += 9; tree dt= tuple ("doctype"); skip_space (); dt << parse_name (); skip_space (); if (test (s, "SYSTEM")) dt << parse_system (); else if (test (s, "PUBLIC")) dt << parse_public (); skip_space (); if (test (s, "[")) { s += 1; while (s) { skip_space (); if (test (s, "]")) { s += 1; break; } else if (test (s, "<!ELEMENT")) dt << parse_element (); else if (test (s, "<!ATTLIST")) dt << parse_cdata (); else if (test (s, "<!ENTITY")) parse_entity_decl (); else if (test (s, "<!NOTATION")) a << parse_notation (); else if (test (s, "<?")) dt << parse_pi (); else if (test (s, "<!--")) dt << parse_comment (); else if (s[0] == '&' || s[0] == '%') (void) parse_entity (); else s += 1; } } skip_space (); if (test (s, ">")) s += 1; return dt; }
gpgme_error_t _gpgme_verify_status_handler (void *priv, gpgme_status_code_t code, char *args) { gpgme_ctx_t ctx = (gpgme_ctx_t) priv; gpgme_error_t err; void *hook; op_data_t opd; gpgme_signature_t sig; char *end; err = _gpgme_op_data_lookup (ctx, OPDATA_VERIFY, &hook, -1, NULL); opd = hook; if (err) return err; sig = opd->current_sig; switch (code) { case GPGME_STATUS_NEWSIG: if (sig) calc_sig_summary (sig); err = prepare_new_sig (opd); opd->only_newsig_seen = 1; return err; case GPGME_STATUS_GOODSIG: case GPGME_STATUS_EXPSIG: case GPGME_STATUS_EXPKEYSIG: case GPGME_STATUS_BADSIG: case GPGME_STATUS_ERRSIG: case GPGME_STATUS_REVKEYSIG: if (sig && !opd->did_prepare_new_sig) calc_sig_summary (sig); opd->only_newsig_seen = 0; return parse_new_sig (opd, code, args, ctx->protocol); case GPGME_STATUS_VALIDSIG: opd->only_newsig_seen = 0; return sig ? parse_valid_sig (sig, args, ctx->protocol) : trace_gpg_error (GPG_ERR_INV_ENGINE); case GPGME_STATUS_NODATA: opd->only_newsig_seen = 0; if (!sig) return gpg_error (GPG_ERR_NO_DATA); sig->status = gpg_error (GPG_ERR_NO_DATA); break; case GPGME_STATUS_UNEXPECTED: opd->only_newsig_seen = 0; if (!sig) return gpg_error (GPG_ERR_GENERAL); sig->status = gpg_error (GPG_ERR_NO_DATA); break; case GPGME_STATUS_NOTATION_NAME: case GPGME_STATUS_NOTATION_FLAGS: case GPGME_STATUS_NOTATION_DATA: case GPGME_STATUS_POLICY_URL: opd->only_newsig_seen = 0; return sig ? parse_notation (sig, code, args) : trace_gpg_error (GPG_ERR_INV_ENGINE); case GPGME_STATUS_TRUST_UNDEFINED: case GPGME_STATUS_TRUST_NEVER: case GPGME_STATUS_TRUST_MARGINAL: case GPGME_STATUS_TRUST_FULLY: case GPGME_STATUS_TRUST_ULTIMATE: opd->only_newsig_seen = 0; return sig ? parse_trust (sig, code, args) : trace_gpg_error (GPG_ERR_INV_ENGINE); case GPGME_STATUS_PKA_TRUST_BAD: case GPGME_STATUS_PKA_TRUST_GOOD: opd->only_newsig_seen = 0; /* Check that we only get one of these status codes per signature; if not the crypto backend misbehaves. */ if (!sig || sig->pka_trust || sig->pka_address) return trace_gpg_error (GPG_ERR_INV_ENGINE); sig->pka_trust = code == GPGME_STATUS_PKA_TRUST_GOOD? 2 : 1; end = strchr (args, ' '); if (end) *end = 0; sig->pka_address = strdup (args); break; case GPGME_STATUS_TOFU_USER: opd->only_newsig_seen = 0; return sig ? parse_tofu_user (sig, args) /* */ : trace_gpg_error (GPG_ERR_INV_ENGINE); case GPGME_STATUS_TOFU_STATS: opd->only_newsig_seen = 0; return sig ? parse_tofu_stats (sig, args) /* */ : trace_gpg_error (GPG_ERR_INV_ENGINE); case GPGME_STATUS_TOFU_STATS_LONG: opd->only_newsig_seen = 0; return sig ? parse_tofu_stats_long (sig, args, ctx->raw_description) /* */ : trace_gpg_error (GPG_ERR_INV_ENGINE); case GPGME_STATUS_ERROR: opd->only_newsig_seen = 0; /* Some error stati are informational, so we don't return an error code if we are not ready to process this status. */ return parse_error (sig, args, !!sig ); case GPGME_STATUS_FAILURE: opd->failure_code = _gpgme_parse_failure (args); break; case GPGME_STATUS_EOF: if (sig && !opd->did_prepare_new_sig) calc_sig_summary (sig); if (opd->only_newsig_seen && sig) { gpgme_signature_t sig2; /* The last signature has no valid information - remove it from the list. */ assert (!sig->next); if (sig == opd->result.signatures) opd->result.signatures = NULL; else { for (sig2 = opd->result.signatures; sig2; sig2 = sig2->next) if (sig2->next == sig) { sig2->next = NULL; break; } } /* Note that there is no need to release the members of SIG because we won't be here if they have been set. */ free (sig); opd->current_sig = NULL; } opd->only_newsig_seen = 0; if (opd->failure_code) return opd->failure_code; break; case GPGME_STATUS_PLAINTEXT: if (++opd->plaintext_seen > 1) return gpg_error (GPG_ERR_BAD_DATA); err = _gpgme_parse_plaintext (args, &opd->result.file_name); if (err) return err; default: break; } return 0; }
int main(int argc, const char** argv) { struct timeb t; ftime(&t); srand(1000*t.time+t.millitm); unsigned tries = 1, playouts = 0; int average = 0; strategy strategy = s_up; const char* server = NULL; // parse command line options while (argc>1) if (!strcmp(argv[argc-1], "-v")) { argc--, verbose = 1; } else if (!strcmp(argv[argc-1], "--average")) { argc--, average = 1; } else if (!strcmp(argv[argc-1], "--highscore")) { argc--, tries = ~0; } else if (!strcmp(argv[argc-1], "--up")) { argc--, strategy = s_up; } else if (!strcmp(argv[argc-1], "--score")) { argc--, strategy = s_score; } else if (!strcmp(argv[argc-1], "--lr")) { argc--, strategy = s_lr; } else if (argc>2 && !strcmp(argv[argc-2], "--server")) { server = argv[argc-1]; argc -= 2; } else { if (!strcmp(argv[argc-1], "-h")) argc--; else printf("%s: unknown option %s\n", basename((char*) argv[0]), argv[argc-1]); printf("usage: %s [--average] [--highscore] [--lr|--score|--up] [--server <ip-address>] [-v]\n", basename((char*) argv[0])); return argc-1; } board b; // board dir d = (dir) -1; // last move unsigned hs = 0; // highscore unsigned as = 0, an = 0; // average score while (tries--) { unsigned s = 0; int moved; playouts++; if (server) { // connect to server if (connect_server(server)) { printf("failure to communicate %s\n", server); return -1; } } else { // create a board memset(b, 0, sizeof(b)); drop(b); drop(b); } // move until the board is full do { if (server && ((d<last && !send_server(dirs[d])) || parse_notation(send_server("board"), b))) { printf("failure to communicate %s\n", server); return -1; } if (verbose) print_board(b); } while ( // simple strategy: move up, left, right or down, whatever works (strategy==s_up && ( ((s += move(b, d = up, &moved)), (moved && drop(b))) || ((s += move(b, d = left, &moved)), (moved && drop(b))) || ((s += move(b, d = right, &moved)), (moved && drop(b))) || ((s += move(b, d = down, &moved)), (moved && drop(b))))) || // other strategies: evaluate moves (strategy!=s_up && ( ((s += move(b, d = evaluate(b, strategy), &moved)), (moved && drop(b)))))); // calculate the average score as += s; an++; // print the score/board if (s>hs) { printf("score %u (%u)\n", s, playouts); print_board(b); hs = s; } else if (average && tries%16384==0) { printf("avg. %u\n", as/an); } // disconnect the server, if any if (server) send_server("gameover"); disconnect_server(); } return 0; }