/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 1995 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
/*	  All Rights Reserved  	*/

/*
 *	UNIX shell
 *
 */

#include	"defs.h"
#include	<sys/types.h>
#include	<sys/stat.h>
#include	<dirent.h>



/*
 * globals (file name generation)
 *
 * "*" in params matches r.e ".*"
 * "?" in params matches r.e. "."
 * "[...]" in params matches character class
 * "[...a-z...]" in params matches a through z.
 *
 */
static void addg(unsigned char *, unsigned char *, unsigned char *,
    unsigned char *);
void makearg(struct argnod *);

int
expand(unsigned char	*as, int rcnt)
{
	int	count;
	DIR	*dirf;
	BOOL	dir = 0;
	unsigned char	*rescan = 0;
	unsigned char 	*slashsav = 0;
	unsigned char	*s, *cs;
	unsigned char *s2 = 0;
	struct argnod	*schain = gchain;
	BOOL	slash;
	int	len;
	wchar_t	wc;

	if (trapnote & SIGSET)
		return (0);
	s = cs = as;
	/*
	 * check for meta chars
	 */
	{
		BOOL open;

		slash = 0;
		open = 0;
		do
		{
			if ((len = mbtowc(&wc, (char *)cs, MB_LEN_MAX)) <= 0) {
				len = 1;
				wc = (unsigned char)*cs;
			}

			cs += len;
			switch (wc) {
			case 0:
				if (rcnt && slash)
					break;
				else
					return (0);

			case '/':
				slash++;
				open = 0;
				continue;

			case '[':
				open++;
				continue;

			case ']':
				if (open == 0)
					continue;

			case '?':
			case '*':
				if (rcnt > slash)
					continue;
				else
					cs--;
				break;

			case '\\':
				cs++;
			default:
				continue;
			}
			break;
		} while (TRUE);
	}

	for (;;) {
		if (cs == s) {
			s = (unsigned char *)nullstr;
			break;
		} else if (*--cs == '/') {
			*cs = 0;
			if (s == cs)
				s = (unsigned char *)"/";
			else {
				/*
				 * push trimmed copy of directory prefix
				 * onto stack
				 */
				s2 = cpystak(s);
				trim(s2);
				s = s2;
			}
			break;
		}
	}

	if ((dirf = opendir(*s ? (char *)s : (char *)".")) != 0)
		dir++;

	/* Let s point to original string because it will be trimmed later */
	if (s2)
		s = as;
	count = 0;
	if (*cs == 0)
		slashsav = cs++; /* remember where first slash in as is */

	/* check for rescan */
	if (dir) {
		unsigned char *rs;
		struct dirent *e;

		rs = cs;
		do /* find next / in as */
		{
			if (*rs == '/') {
				rescan = rs;
				*rs = 0;
				gchain = 0;
			}
		} while (*rs++);

		while ((e = readdir(dirf)) && (trapnote & SIGSET) == 0) {
			if (e->d_name[0] == '.' && *cs != '.')
				continue;

			if (gmatch(e->d_name, cs)) {
				addg(s, (unsigned char *)e->d_name, rescan,
				    slashsav);
				count++;
			}
		}
		(void) closedir(dirf);

		if (rescan) {
			struct argnod	*rchain;

			rchain = gchain;
			gchain = schain;
			if (count) {
				count = 0;
				while (rchain) {
					count += expand(rchain->argval,
							slash + 1);
					rchain = rchain->argnxt;
				}
			}
			*rescan = '/';
		}
	}

	if (slashsav)
		*slashsav = '/';
	return (count);
}

static void
addg(unsigned char *as1, unsigned char *as2, unsigned char *as3,
    unsigned char *as4)
{
	unsigned char	*s1, *s2;
	int	c;
	int		len;
	wchar_t		wc;

	s2 = locstak() + BYTESPERWORD;
	s1 = as1;
	if (as4) {
		while (c = *s1++) {
			if (s2 >= brkend)
				growstak(s2);
			*s2++ = c;
		}
		/*
		 * Restore first slash before the first metacharacter
		 * if as1 is not "/"
		 */
		if (as4 + 1 == s1) {
			if (s2 >= brkend)
				growstak(s2);
			*s2++ = '/';
		}
	}
/* add matched entries, plus extra \\ to escape \\'s */
	s1 = as2;
	for (;;) {
		if ((len = mbtowc(&wc, (char *)s1, MB_LEN_MAX)) <= 0) {
			len = 1;
			wc = (unsigned char)*s1;
		}
		if (s2 >= brkend)
			growstak(s2);

		if (wc == 0) {
			*s2 = *s1++;
			break;
		}

		if (wc == '\\') {
			*s2++ = '\\';
			if (s2 >= brkend)
				growstak(s2);
			*s2++ = '\\';
			s1++;
			continue;
		}
		if ((s2 + len) >= brkend)
			growstak(s2 + len);
		memcpy(s2, s1, len);
		s2 += len;
		s1 += len;
	}
	if (s1 = as3) {
		if (s2 >= brkend)
			growstak(s2);
		*s2++ = '/';
		do
		{
			if (s2 >= brkend)
				growstak(s2);
		}
		while (*s2++ = *++s1);
	}
	makearg((struct argnod *)endstak(s2));
}

void
makearg(struct argnod *args)
{
	args->argnxt = gchain;
	gchain = args;
}