private mixed *ret;
private mixed value;

private void
load_lpc_info(int ix, object ob)
{
    mixed *tmp, *sing;
    value ret;
    int il, make_plural = 0;
    string str;
    
    if (!ob)
	return;

    if (pluid_list &&
	sizeof(pluid_list) > ix &&
	pluid_list[ix] == 0) {
	ret = ob->parse_command_plural_id_list();
	if (arrayp(ret))
	    pluid_list[ix] = ret;
	else {
	    make_plural = 1;
	    pluid_list[ix] = 1;
	}
    }
    if (id_list &&
	sizeof(id_list) > ix &&
	id_list[ix] == 0 &&
	ob) {
	ret = ob->parse_command_id_list();
	if (arrayp(ret)) {
	    id_list[ix] = ret;
	    if (make_plural)
		pluid_list[ix] = map(ret, (: stringp($1) ? pluralize($1) : 0 :));
	} else {
	    id_list[ix] = 1;
	}
    }
    if (adjid_list &&
	sizeof(adjid_list) > ix &&
	adjid_list[ix] == 0 &&
	ob) {
	ret = ob->parse_command_adjectiv_id_list();
	if (arrayp(ret))
	    adjid_list[ix] =  ret;
	else
	    adjid_list[ix] = 1;
    }
}

mixed *parse_command(string cmd, mixed obarr, string pattern) {
    mixed *saved_ret = ret, *cret;

    ret = ({ });
    
    /* pattern and command cannot be empty */
    if (cmd == "" || pattern = "") return ({ });

    if (!stringp(cmd)) error("Bad argument 1 to parse_command().\n");
    if (!stringp(pattern)) error("Bad argument 3 to parse_command().\n");

    /* array of words in command */
    parse_warr = explode(cmd, " ");

    /* array of pattern elements */
    parse_patarr = explode(pattern, " ");
    
#ifndef __NO_ENVIRONMENT__
    if (objectp(obarr))
	obarr = ({ obarr }) + deep_inventory(obarr);
#endif
    if (!arrayp(obarr)) error("Bad argument 2 to parse_command().\n");
    
    id_list = allocate(sizeof(obarr));
    pluid_list = allocate(sizeof(obarr));
    adjid_list = allocate(sizeof(obarr));

    id_list_d = master()->parse_command_id_list();
    pluid_list_d = master()->parse_command_plural_id_list();
    adjid_list_d = master()->parse_command_adjectiv_id_list();
    prepos_list = master()->parse_command_prepos_list();
    
    allword = master()->parse_command_all_word();
    
    /*
     * Loop through the pattern. Handle %s but not '/'
     */
    for (six = 0, cix = 0, pix = 0; pix < sizeof(parse_patarr); pix++) {
	value = 0;
	fail = 0;
	
	if (parse_patarr[pix] == "%s") {
	    /*
	     * We are at end of pattern, scrap up the remaining words and put
	     * them in the fill-in value.
	     */
	    if (pix == sizeof(parse_patarr - 1)) {
		store_words_slice(six++, parse_warr, cix, sizeof(parse_warr) - 1);
		cix = sizeof(parse_warr);
	    } else {
		/*
		 * There is something after %s, try to parse with the next
		 * pattern. Begin with the current word and step one word for
		 * each fail, until match or end of words.
		 */
		ocix = fword = cix; /* current word */
		fpix = ++pix; /* pix == next pattern */
		do {
		    /*
		     * Parse the following pattern, fill-in values:
		     * stack_args[six] = result of %s stack_args[six + 1] =
		     * result of following pattern, if it is a fill-in
		     * pattern
		     */
		    fail = sub_parse(obarr, parse_patarr, ref pix,
				      parse_warr, ref cix);
		    if (fail) {
			cix = ++ocix;
			pix = fpix;
		    }
		} while (fail && (cix < sizeof(parse_warr)));
		
		/*
		 * We found something mathing the pattern after %s. First
		 * stack_args[six + 1] = result of match Then stack_args[six]
		 * = the skipped words before match
		 */
		if (!fail) {
		    if (value) { /* A match with a value fill in param */
			store_value(six + 1, value);
			store_words_slice(six, parse_warr, fword, ocix - 1);
			six += 2;
		    } else {	/* A match with a non value ie 'word' */
			store_words_slice(six++, parse_warr, fword, ocix - 1);
		    }
		    value = 0;
		}
	    }
	}
	/*
	 * The pattern was not %s, parse the pattern if it is not '/', a '/'
	 * here is skipped. If match, put in fill-in value.
	 */
	else if (parse_patarr[pix] != "/") {
	    fail = sub_parse(obarr, parse_patarr, ref pix, 
			      parse_warr, ref cix, ref fail);
	    if (!fail && value)
		store_value(six++, value);
	}
	/*
	 * Terminate parsing if no match
	 */
	if (fail)
	    break;
    }

    /*
     * Also fail when there is words left to parse and pattern exhausted
     */
    if (fail || cix < sizeof(parse_warr))
	return 0;

    cret = ret;
    ret = saved_ret;
    return cret;
}

private void
store_value(int pos, mixed what) {
    if (sizeof(ret) <= pos)
	ret += allocate(ret + 1 - pos);

    ret[pos] = what;
}

static void
store_words_slice(int pos, mixed *warr, int from, int to) {
    mixed *slice = warr[from..to];

    store_value(pos, implode(slice, " "));
}

private static int
sub_parse(mixed *obarr, mixed *patarr, int ref pix_in, 
	  mixed *warr, int ref cix_in)
{
    int cix, pix;
    int fail;
    
    /*
     * Fail if we have a pattern left but no words to parse
     */
    if (*cix_in == sizeof(warr))
	return 1;

    cix = *cix_in;
    pix = *pix_in;

    fail = one_parse(obarr, patarr[pix], warr, ref cix);

    while (fail) {
	pix++;
	cix = *cix_in;

	/*
	 * Find the next alternative pattern, consecutive '/' are skipped
	 */
	while (pix < sizeof(patarr) && patarr[pix] == "/") {
	    pix++;
	    fail = 0;
	}
	
	if (!fail && pix < sizeof(patarr)) {
	    fail = one_parse(obarr, patarr[pix], warr, ref cix);
	} else {
	    *pix_in = pix - 1;
	    return 1;
	}
    }

    /*
     * If there is alternatives left after the mathing pattern, skip them
     */
    if (pix + 1 < sizeof(patarr) && patarr[pix+1] == "/") {
	while (pix + 1 < sizeof(patarr) && patarr[pix+1] == "/") {
	    pix += 2;
	}
	if (pix >= sizeof(patarr))
	    pix = sizeof(patarr->size);
    }
    *cix_in = cix;
    *pix_in = pix;

    return fail;
}

private int
one_parse(mixed *obarr, string pat, mixed *warr, int ref cix_in)
{
    int ch, fail;
    string str1, str2;

    /*
     * Fail if we have a pattern left but no words to parse
     */
    if (*cix_in >= sizeof(warr))
	return 1;

    ch = pat[0];
    if (ch == '%')
	ch = pat[1];

    switch (ch) {
    case 'i':
    case 'I':
	fail = item_parse(obarr, warr, cix_in);
	break;

#ifndef __NO_ADD_ACTION__
    case 'l':
    case 'L':
	fail = living_parse(obarr, warr, cix_in);
	break;
#endif

    case 's':
    case 'S':
	value = 0;
	fail = 0;
	break;

    case 'w':
    case 'W':
	value = warr[*cix_in];
	(*cix_in)++;
	fail = 0;
	break;

    case 'o':
    case 'O':
	fail = single_parse(obarr, warr, cix_in);
	break;

    case 'p':
    case 'P':
	fail = prepos_parse(warr, cix_in);
	break;

    case 'd':
    case 'D':
	fail = number_parse(obarr, warr, cix_in);
	break;

    case '\'':
	str1 = pat[1..<2];
	str2 = warr[*cix_in];
	if (pat[<1] == '\'' && str1 == str2) {
	    fail = 0;
	    (*cix_in)++;
	} else
	    fail = 1;
	break;

    case '[':
	str1 = pat[1..<2];
	str2 = warr[*cix_in];
	if (str1 == str2)
	    (*cix_in)++;
	fail = 0;
	break;

    default:
	fail = 0;		/* Skip invalid patterns */
    }

    return fail;
}

string *ord1 = ({"", "first", "second", "third", "fourth", "fifth",
 "sixth", "seventh", "eighth", "nineth", "tenth",
 "eleventh", "twelfth", "thirteenth", "fourteenth",
 "fifteenth", "sixteenth", "seventeenth",
 "eighteenth", "nineteenth" });

string *ord10 = ({"", "", "twenty", "thirty", "forty", "fifty", "sixty",
 "seventy", "eighty", "ninety"});

string *sord10 = ({"", "", "twentieth", "thirtieth", "fortieth",
 "fiftieth", "sixtieth", "seventieth", "eightieth",
 "ninetieth"});

string *num1 = ({"", "one", "two", "three", "four", "five", "six",
 "seven", "eight", "nine", "ten",
 "eleven", "twelve", "thirteen", "fourteen", "fifteen",
 "sixteen", "seventeen", "eighteen", "nineteen"});

string *num10 = ({"", "", "twenty", "thirty", "forty", "fifty", "sixty",
 "seventy", "eighty", "ninety"});

private int
number_parse(mixed *obarr, mixed *warr, int ref cix_in) {
    int cix, ten, ones, num;
    string buf;
    
    cix = *cix_in;

    if (sscanf(warr[cix], "%d", num)) {
	if (num >= 0) {
	    (*cix_in)++;
	    value = num;
	    return 0;
	}
	return 1; /* only nonnegative numbers */
    }
    if (warr[cix] == allword) {
	(*cix_in)++;
	value = 0;
	return 0;
    }
    /* This next double loop is incredibly stupid. -Beek */
    for (ten = 0; ten < 10; ten++)
	for (ones = 0; ones < 10; ones++) {
	    buf = num10[ten] + (ten > 1 ? num1[ones] : num1[ten * 10 + ones]);
	    if (buf == warr[cix]) {
		(*cix_in)++;
		value = ten * 10 + ones;
		return 0;
	    }
	}

    /* this one too */
    for (ten = 0; ten < 10; ten++)
	for (ones = 0; ones < 10; ones++) {
	    buf = (ones ? ord10[ten] : sord10[ten]) + (ten > 1 ? ord1[ones] : ord1[ten*10 + ones]);
	    if (buf == warr[cix]) {
		(*cix_in)++;
		value = -(ten * 10 + ones);
		return 0;
	    }
	}

    return 1;
}

private int
item_parse(mixed *obarr, mixed *warr, int ref cix_in) {
    mixed *tmp, *ret;
    int cix, tix, obix, plur_flag, max_cix, match_all;

    tmp = allocate(sizeof(obarr) + 1);
    
    if (!number_parse(obarr, warr, cix_in)) {
	tmp[0] = value;
	match_all = (value == 0);
	plur_flag = (match_all || value > 1);
	have_number = 1;
	value = 0;
    } else {
	plur_flag = 0;
	match_all = 0;
    }

    for (max_cix = *cix_in, tix = 1, obix = 0; obix < sizeof(obarr); obix++) {
	cix = *cix_in;
	if (!objectp(obarr[obix]))
	    continue;
	if (cix == sizeof(warr) && match_all) {
	    tmp[tix++] = obarr[obix];
	    continue;
	}
	load_lpc_info(obix, obarr[obix]);

	if (match_object(obix, warr, ref cix, ref plur_flag)) {
	    tmp[tix++] = obarr[obix];
	    max_cix = (max_cix < cix) ? cix : max_cix;
	}
    }

    if (tix < 2) {
	if (have_number)
	    (*cix_in)--;
	return 1;
    } else {
	if (*cix_in < sizeof(warr))
	    *cix_in = max_cix + 1;
	if (!have_number)
	    tmp[0] = !plur_flag;
	
	value = tmp[0..tix-1];
	return 0;
    }
}

#ifndef __NO_ADD_ACTION__
private int
living_parse(mixed *obarr, array warr, int ref cix_in, int ref fail)
{
    mixed *live;
    object ob;
    int obix, tix;

    live = allocate(sizeof(obarr));
    tix = 0;

    for (obix = 0; obix < sizeof(obarr); obix++)
	if (living(obarr[obix]))
	    live[tix++] = obarr[obix];

    if (tix && !item_parse(live, warr, cix_in))
	return 0;

    ob = find_player(warr[*cix_in]);
    if (!ob)
	ob = find_living(warr[*cix_in]);

    if (ob) {
	value = ob;
	(*cix_in)++;
	return 0;
    }
    return 1;
}
#endif

private int
single_parse(mixed *obarr, mixed *warr, int ref cix_in)
{
    int cix, obix, plur_flag;

    for (obix = 0; obix < sizeof(obarr); obix++) {
	cix = *cix_in;
	if (objectp(obarr[obix]))
	    load_lpc_info(obix, obarr[obix]);
	plur_flag = 0;
	if (match_object(obix, warr, ref cix, ref plur_flag)) {
	    *cix_in = cix + 1;
	    value = obarr[obix];
	    return 0;
	}
    }
    return 1;
}

private int
prepos_parse(mixed *warr, int ref cix_in, mixed prepos) {
    mixed *tarr;
    string tmp;
    int pix, tix;

    if (!prepos || !arrayp(prepos))
	prepos = prepos_list;

    for (pix = 0; pix < sizeof(prepos); pix++) {
	if (!stringp(prepos[pix]))
	    continue;

	tmp = prepos[pix];
	if (member_array(' ', tmp) == -1) {
	    if (tmp == warr[*cix_in]) {
		(*cix_in)++;
		break;
	    }
	} else {
	    tarr = explode(tmp, " ");
	    if (*cix_in + sizeof(tarr) <= sizeof(warr)) {
		for (tix = 0; tix < sizeof(tarr); tix++) {
		    if (*cix_in + tix >= sizeof(warr) ||
			warr[*cix_in + tix] != tarr[tix])
			break;
		}
		if (tix == sizeof(tarr)) {
		    (*cix_in) += sizeof(tarr);
		    break;
		}
	    }
	}
    }

    if (pix == sizeof(prepos)) {
	value = 0;
	return 1;
    } else {
	value = prepos[pix];
	return 0;
    }
}

private int
match_object(int obix, mixed *warr, int ref cix_in, int ref plur) {
    mixed *ids;
    int il, pos, cplur, old_cix;
    string str;

    for (cplur = (*plur * 2); cplur < 4; cplur++) {
	switch (cplur) {
	case 0:
	    if (!id_list_d)
		continue;
	    ids = id_list_d;
	    break;

	case 1:
	    if (!d_list ||
		sizeof(id_list) <= obix ||
		!arrayp(id_list[obix]))
		continue;
	    ids = id_list[obix];
	    break;

	case 2:
	    if (!pluid_list_d)
		continue;
	    ids = pluid_list_d;
	    break;

	case 3:
	    if (!pluid_list ||
		sizeof(gpluid_list) <= obix ||
		!arrayp(gpluid_list[obix]))
		continue;
	    ids = pluid_list[obix];
	    break;

	default:
	    ids = 0;
	}

	for (il = 0; il < sizeof(ids); il++) {
	    if (stringp(ids[il])) {
		str = ids[il];	/* A given id of the object */
		old_cix = *cix_in;
		if ((pos = find_string(str, warr, cix_in)) >= 0) {
		    if (pos == old_cix) {
			if (cplur > 1)
			    *plur = 1;
			return 1;
		    } else if (check_adjectiv(obix, warr, old_cix, pos - 1)) {
			if (cplur > 1)
			    *plur = 1;
			return 1;
		    }
		}
		*cix_in = old_cix;
	    }
	}
    }
    return 0;
}

static int
find_string(string str, mixed *warr, int ref cix_in)
{
    int fpos;
    string p1;
    mixed *split;

    for (; *cix_in < warr->size; (*cix_in)++) {
	p1 = warr[*cix_in];

	if (p1 == str)	/* str was one word and we found it */
	    return *cix_in;

	if (member_array(' ', str) == -1)
	    continue;

	/*
	 * If str was multi word we need to make some special checks
	 */
	if (*cix_in == sizeof(warr->size) - 1)
	    continue;

	split = explode(str, " ");

	/*
	 * warr->size - *cix_in ==	
	 * 2: One extra word 
	 * 3: Two extra words
	 */
	if (sizeof(split) > sizeof(warr) - *cix_in)
	    continue;

	fpos = *cix_in;
	for (; (*cix_in - fpos) < sizeof(split); (*cix_in)++) {
	    if (split[*cix_in - fpos] == warr[*cix_in])
		break;
	}
	if ((*cix_in - fpos) == sizeof(split))
	    return fpos;

	*cix_in = fpos;
    }
    return -1;
}

private int
check_adjectiv(int obix, mixed *warr, int from, int to)
{
    int il, back, fail;
    string adstr;
    mixed *ids;

    if (arrayp(adjid_list[obix]))
	ids = adjid_list[obix];
    else
	ids = 0;

    for (fail = 0, il = from; il <= to; il++) {
	if ((member_array(warr[il], ids) < 0) &&
	    (member_array(warr[il], adjid_list_d) < 0))
	    fail = 1;
    }

    /*
     * Simple case: all adjs were single word
     */
    if (!fail)
	return 1;

    if (from == to)
	return 0;

    /*
     * If we now have: "adj1 adj2 adj3 ... adjN"
     * We must test in order: "adj1 adj2 adj3 .... adjN-1 adjN"
                              "adj1 adj2 adj3 .... adjN-1"
			      "adj1 adj2 adj3 ...." 
			      ....
     * if match for adj1 .. adj3 continue with:
     *                        "adj4 adj5 .... adjN-1 adjN"
     *                        "adj4 adj5 .... adjN-1"
     *                        "adj4 adj5 ...."
     *                        .....
     */
    for (il = from; il <= to;) { /* adj1 .. adjN */
	for (back = to; back >= il; back--) {	/* back from adjN to adj[il] */
	    /*
	     * Create teststring with "adj[il] .. adj[back]"
	     */
	    adstr = "";
	    for (sum = il; sum <= back; sum++) {	/* test "adj[il] ..
							 * adj[back]" */
		if (sum > il)
		    adstr += " ";
		adstr += warr[sum];
	    }
	    if ((member_array(adstr, ids) < 0) &&
		(member_array(adstr, adjid_list_d) < 0))
		continue;
	    else {
		il = back + 1;	/* Match "adj[il] adj[il+1] .. adj[back]" */
		back = to;
		break;
	    }
	}
	if (back < to)
	    return 0;
    }
    return 1;
}