宇宙からのメッセージ

'教科書通りの方法
A$=INKEY$
IF A$="4" THEN X=X-1
IF A$="6" THEN X=X+1
IF A$="2" THEN Y=Y-1
IF A$="8" THEN Y=Y+1

'少しマニアックな方法
A$=INKEY$
X=X+(A$="4")-(A$="6")
Y=Y+(A$="2")-(A$="8")

    /* Check for qualifiers */
    while (!nobareglob ||
	   (isset(EXTENDEDGLOB) && !zpc_disables[ZPC_HASH])) {
	struct qual *newquals;
	char *s;
	int sense, qualsfound;
	off_t data;
	char *sdata, *newcolonmod, *ptr;
	int (*func) _((char *, Statptr, off_t, char *));

	/*
	 * Initialise state variables for current file pattern.
	 * newquals is the root for the linked list of all qualifiers.
	 * qo is the root of the current list of alternatives.
	 * ql is the end of the current alternative where the `next' will go.
	 * qn is the current qualifier node to be added.
	 *
	 * Here is an attempt at a diagram.  An `or' is added horizontally
	 * to the top line, a `next' at the bottom of the right hand line.
	 * `qn' is usually NULL unless a new `or' has just been added.
	 *
	 * quals -> x  -> x -> qo
	 *          |     |    |
	 *          x     x    x
	 *          |          |
	 *          x          ql
	 *
	 * In fact, after each loop the complete set is in the file static
	 * `quals'.  Then, if we have a second set of qualifiers, we merge
	 * the lists together.  This is only tricky if one or both have an
	 * `or' in them; then we need to distribute over all alternatives.
	 */
	newquals = qo = qn = ql = NULL;

	sl = strlen(str);
	if (!(qualsfound = checkglobqual(str, sl, nobareglob, &s)))
	    break;

	/* Real qualifiers found. */
	nobareglob = 1;
	sense = 0;	   /* bit 0 for match (0)/don't match (1)   */
			   /* bit 1 for follow links (2), don't (0) */
	data = 0;	   /* Any numerical argument required       */
	sdata = NULL;	   /* Any list argument required            */
	newcolonmod = NULL; /* Contains trailing colon modifiers    */

	str[sl-1] = 0;
	*s++ = 0;
	if (qualsfound == 2)
	    s += 2;
	for (ptr = s; *ptr; ptr++)
	    if (*ptr == Dash)
		*ptr = '-';

	while (*s && !newcolonmod) {
	    func = (int (*) _((char *, Statptr, off_t, char *)))0;
	    if (*s == ',') {
		/* A comma separates alternative sets of qualifiers */
		s++;
		sense = 0;
		if (qualct) {
		    qn = (struct qual *)hcalloc(sizeof *qn);
		    qo->or = qn;
		    qo = qn;
		    qualorct++;
		    qualct = 0;
		    ql = NULL;
		}
	    } else {
		switch (*s++) {
		case ':':
		    /* Remaining arguments are history-type     *
		     * colon substitutions, handled separately. */
		    newcolonmod = s - 1;
		    untokenize(newcolonmod);
		    if (colonmod) {
			/* remember we're searching backwards */
			colonmod = dyncat(newcolonmod, colonmod);
		    } else
			colonmod = newcolonmod;
		    break;
		case Hat:
		case '^':
		    /* Toggle sense:  go from positive to *
		     * negative match and vice versa.     */
		    sense ^= 1;
		    break;

**この辺省略**

		default:
		    untokenize(--s);
		    zerr("unknown file attribute: %c", *s);
		    restore_globstate(saved);
		    return;
		}
	    }
	    if (func) {
		/* Requested test is performed by function func */
		if (!qn)
		    qn = (struct qual *)hcalloc(sizeof *qn);
		if (ql)
		    ql->next = qn;
		ql = qn;
		if (!newquals)
		    newquals = qo = qn;
		qn->func = func;
		qn->sense = sense;
		qn->data = data;
		qn->sdata = sdata;
		qn->range = g_range;
		qn->units = g_units;
		qn->amc = g_amc;

		qn = NULL;
		qualct++;
	    }
	    if (errflag) {
		restore_globstate(saved);
		return;
	    }
	}

		qn->func = func;

	if (quals && newquals) {
	    /* Merge previous group of qualifiers with new set. */
	    if (quals->or || newquals->or) {
		/* The hard case. */
		struct qual *qorhead = NULL, *qortail = NULL;
		/*
		 * Distribute in the most trivial way, by creating
		 * all possible combinations of the two sets and chaining
		 * these into one long set of alternatives given
		 * by qorhead and qortail.
		 */
		for (qn = newquals; qn; qn = qn->or) {
		    for (qo = quals; qo; qo = qo->or) {
			struct qual *qfirst, *qlast;
			int islast = !qn->or && !qo->or;
			/* Generate first set of qualifiers... */
			if (islast) {
			    /* Last time round:  don't bother copying. */
			    qfirst = qn;
			    for (qlast = qfirst; qlast->next;
				 qlast = qlast->next)
				;			    
			} else
			    qfirst = dup_qual_list(qn, &qlast);
			/* ... link into new `or' chain ... */
			if (!qorhead)
			    qorhead = qfirst;
			if (qortail)
			    qortail->or = qfirst;
			qortail = qfirst;
			/* ... and concatenate second set. */
			qlast->next = islast ? qo : dup_qual_list(qo, NULL);
		    }
		}
		quals = qorhead;
	    } else {
		/*
		 * Easy: we can just chain the qualifiers together.
		 * This is an optimisation; the code above will work, too.
		 * We retain the original left to right ordering --- remember
		 * we are searching for sets of qualifiers from the right.
		 */
		qn = newquals;
		for ( ; newquals->next; newquals = newquals->next)
		    ;
		newquals->next = quals;
		quals = qn;
	    }
	} else if (newquals)
	    quals = newquals;
    }