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;
}
