FCL/sf/mw/appsupport: comparison openenvutils/commandshell/shell/src/builtin.c

equal deleted inserted replaced

--1:000000000000
+:2e3d3ce01487
+//builtin.c - builtin commands
+//
+// © Portions Copyright (c) Symbian Software Ltd 2007 - 2008. All rights reserved.
+//
+/*
+* This file is part of zsh, the Z shell.
+*
+* Copyright (c) 1992-1997 Paul Falstad
+* All rights reserved.
+*
+* Permission is hereby granted, without written agreement and without
+* license or royalty fees, to use, copy, modify, and distribute this
+* software and to distribute modified versions of this software for any
+* purpose, provided that the above copyright notice and the following
+* two paragraphs appear in all copies of this software.
+*
+* In no event shall Paul Falstad or the Zsh Development Group be liable
+* to any party for direct, indirect, special, incidental, or consequential
+* damages arising out of the use of this software and its documentation,
+* even if Paul Falstad and the Zsh Development Group have been advised of
+* the possibility of such damage.
+*
+* Paul Falstad and the Zsh Development Group specifically disclaim any
+* warranties, including, but not limited to, the implied warranties of
+* merchantability and fitness for a particular purpose.  The software
+* provided hereunder is on an "as is" basis, and Paul Falstad and the
+* Zsh Development Group have no obligation to provide maintenance,
+* support, updates, enhancements, or modifications.
+*
+*/
+#ifdef __SYMBIAN32__
+#ifdef __WINSCW__
+#pragma warn_unusedarg off
+#pragma warn_possunwant off
+#endif//__WINSCW__
+#endif//__SYMBIAN32__
+/* this is defined so we get the prototype for open_memstream */
+#define _GNU_SOURCE 1
+#include "zsh.mdh"
+#include "builtin.pro"
+#ifdef __SYMBIAN32__
+#include "dummy.h"
+#endif//__SYMBIAN32__
+/* Builtins in the main executable */
+static struct builtin builtins[] =
+{
+BIN_PREFIX("-", BINF_DASH),
+BIN_PREFIX("builtin", BINF_BUILTIN),
+BIN_PREFIX("command", BINF_COMMAND),
+BIN_PREFIX("exec", BINF_EXEC),
+BIN_PREFIX("noglob", BINF_NOGLOB),
+BUILTIN("[", 0, bin_test, 0, -1, BIN_BRACKET, NULL, NULL),
+BUILTIN(".", BINF_PSPECIAL, bin_dot, 1, -1, 0, NULL, NULL),
+BUILTIN(":", BINF_PSPECIAL, bin_true, 0, -1, 0, NULL, NULL),
+BUILTIN("alias", BINF_MAGICEQUALS | BINF_PLUSOPTS, bin_alias, 0, -1, 0, "Lgmrs", NULL),
+BUILTIN("autoload", BINF_PLUSOPTS, bin_functions, 0, -1, 0, "tUXkz", "u"),
+#ifndef __SYMBIAN32__
+BUILTIN("bg", 0, bin_fg, 0, -1, BIN_BG, NULL, NULL),
+#endif
+BUILTIN("break", BINF_PSPECIAL, bin_break, 0, 1, BIN_BREAK, NULL, NULL),
+BUILTIN("bye", 0, bin_break, 0, 1, BIN_EXIT, NULL, NULL),
+BUILTIN("cd", BINF_SKIPINVALID | BINF_SKIPDASH | BINF_DASHDASHVALID, bin_cd, 0, 2, BIN_CD, "sPL", NULL),
+BUILTIN("chdir", BINF_SKIPINVALID | BINF_SKIPDASH | BINF_DASHDASHVALID, bin_cd, 0, 2, BIN_CD, "sPL", NULL),
+BUILTIN("continue", BINF_PSPECIAL, bin_break, 0, 1, BIN_CONTINUE, NULL, NULL),
+BUILTIN("declare", BINF_PLUSOPTS | BINF_MAGICEQUALS | BINF_PSPECIAL, bin_typeset, 0, -1, 0, "AE:%F:%HL:%R:%TUZ:%afghi:%klmprtuxz", NULL),
+BUILTIN("dirs", 0, bin_dirs, 0, -1, 0, "clpv", NULL),
+#ifndef __SYMBIAN32__
+BUILTIN("disable", 0, bin_enable, 0, -1, BIN_DISABLE, "afmrs", NULL),
+BUILTIN("disown", 0, bin_fg, 0, -1, BIN_DISOWN, NULL, NULL),
+#endif
+BUILTIN("echo", BINF_PRINTOPTS | BINF_SKIPINVALID, bin_print, 0, -1, BIN_ECHO, "neE", "-"),
+BUILTIN("emulate", 0, bin_emulate, 1, 1, 0, "LR", NULL),
+#ifndef __SYMBIAN32__
+BUILTIN("enable", 0, bin_enable, 0, -1, BIN_ENABLE, "afmrs", NULL),
+#endif
+BUILTIN("eval", BINF_PSPECIAL, bin_eval, 0, -1, BIN_EVAL, NULL, NULL),
+BUILTIN("exit", BINF_PSPECIAL, bin_break, 0, 1, BIN_EXIT, NULL, NULL),
+BUILTIN("export", BINF_PLUSOPTS | BINF_MAGICEQUALS | BINF_PSPECIAL, bin_typeset, 0, -1, BIN_EXPORT, "E:%F:%HL:%R:%TUZ:%afhi:%lprtu", "xg"),
+BUILTIN("false", 0, bin_false, 0, -1, 0, NULL, NULL),
+/*
+* We used to behave as if the argument to -e was optional.
+* But that's actually not useful, so it's more consistent to
+* cause an error.
+*/
+BUILTIN("fc", 0, bin_fc, 0, -1, BIN_FC, "nlre:IRWAdDfEimpPa", NULL),
+#ifndef __SYMBIAN32__
+BUILTIN("fg", 0, bin_fg, 0, -1, BIN_FG, NULL, NULL),
+#endif
+BUILTIN("float", BINF_PLUSOPTS | BINF_MAGICEQUALS | BINF_PSPECIAL, bin_typeset, 0, -1, 0, "E:%F:%HL:%R:%Z:%ghlprtux", "E"),
+BUILTIN("functions", BINF_PLUSOPTS, bin_functions, 0, -1, 0, "kmtuUz", NULL),
+BUILTIN("getln", 0, bin_read, 0, -1, 0, "ecnAlE", "zr"),
+BUILTIN("getopts", 0, bin_getopts, 2, -1, 0, NULL, NULL),
+#ifndef __SYMBIAN32__
+BUILTIN("hash", BINF_MAGICEQUALS, bin_hash, 0, -1, 0, "Ldfmrv", NULL),
+#ifdef ZSH_HASH_DEBUG
+BUILTIN("hashinfo", 0, bin_hashinfo, 0, 0, 0, NULL, NULL),
+#endif
+#endif //__SYMBIAN32__
+BUILTIN("history", 0, bin_fc, 0, -1, BIN_FC, "nrdDfEimpPa", "l"),
+BUILTIN("integer", BINF_PLUSOPTS | BINF_MAGICEQUALS | BINF_PSPECIAL, bin_typeset, 0, -1, 0, "HL:%R:%Z:%ghi:%lprtux", "i"),
+#ifndef __SYMBIAN32__
+BUILTIN("jobs", 0, bin_fg, 0, -1, BIN_JOBS, "dlpZrs", NULL),
+BUILTIN("kill", 0, bin_kill, 0, -1, 0, NULL, NULL),
+#endif
+BUILTIN("let", 0, bin_let, 1, -1, 0, NULL, NULL),
+BUILTIN("local", BINF_PLUSOPTS | BINF_MAGICEQUALS | BINF_PSPECIAL, bin_typeset, 0, -1, 0, "AE:%F:%HL:%R:%TUZ:%ahi:%lprtux", NULL),
+#ifndef __SYMBIAN32__
+BUILTIN("log", 0, bin_log, 0, 0, 0, NULL, NULL),
+#endif
+BUILTIN("logout", 0, bin_break, 0, 1, BIN_LOGOUT, NULL, NULL),
+#if defined(ZSH_MEM) & defined(ZSH_MEM_DEBUG)
+BUILTIN("mem", 0, bin_mem, 0, 0, 0, "v", NULL),
+#endif
+#if defined(ZSH_PAT_DEBUG)
+BUILTIN("patdebug", 0, bin_patdebug, 1, -1, 0, "p", NULL),
+#endif
+BUILTIN("popd", 0, bin_cd, 0, 1, BIN_POPD, NULL, NULL),
+BUILTIN("print", BINF_PRINTOPTS, bin_print, 0, -1, BIN_PRINT, "acC:f:ilmnNoOPrRsu:z-", NULL),
+BUILTIN("printf", 0, bin_print, 1, -1, BIN_PRINTF, NULL, NULL),
+BUILTIN("pushd", BINF_SKIPINVALID | BINF_SKIPDASH | BINF_DASHDASHVALID, bin_cd, 0, 2, BIN_PUSHD, "sPL", NULL),
+BUILTIN("pushln", BINF_PRINTOPTS, bin_print, 0, -1, BIN_PRINT, NULL, "-nz"),
+BUILTIN("pwd", 0, bin_pwd, 0, 0, 0, "rLP", NULL),
+BUILTIN("r", 0, bin_fc, 0, -1, BIN_R, "nrl", NULL),
+BUILTIN("read", 0, bin_read, 0, -1, 0, "cd:ek:%lnpqrst:%zu:AE", NULL),
+BUILTIN("readonly", BINF_PLUSOPTS | BINF_MAGICEQUALS | BINF_PSPECIAL, bin_typeset, 0, -1, 0, "AE:%F:%HL:%R:%TUZ:%afghi:%lptux", "r"),
+#ifndef __SYMBIAN32__
+BUILTIN("rehash", 0, bin_hash, 0, 0, 0, "df", "r"),
+#endif
+BUILTIN("return", BINF_PSPECIAL, bin_break, 0, 1, BIN_RETURN, NULL, NULL),
+BUILTIN("set", BINF_PSPECIAL, bin_set, 0, -1, 0, NULL, NULL),
+BUILTIN("setopt", 0, bin_setopt, 0, -1, BIN_SETOPT, NULL, NULL),
+BUILTIN("shift", BINF_PSPECIAL, bin_shift, 0, -1, 0, NULL, NULL),
+BUILTIN("source", BINF_PSPECIAL, bin_dot, 1, -1, 0, NULL, NULL),
+#ifndef __SYMBIAN32__
+BUILTIN("suspend", 0, bin_suspend, 0, 0, 0, "f", NULL),
+#endif
+BUILTIN("test", 0, bin_test, 0, -1, BIN_TEST, NULL, NULL),
+#ifndef __SYMBIAN32__
+BUILTIN("ttyctl", 0, bin_ttyctl, 0, 0, 0, "fu", NULL),
+BUILTIN("times", BINF_PSPECIAL, bin_times, 0, 0, 0, NULL, NULL),
+BUILTIN("trap", BINF_PSPECIAL, bin_trap, 0, -1, 0, NULL, NULL),
+#endif
+BUILTIN("true", 0, bin_true, 0, -1, 0, NULL, NULL),
+BUILTIN("type", 0, bin_whence, 0, -1, 0, "ampfsw", "v"),
+BUILTIN("typeset", BINF_PLUSOPTS | BINF_MAGICEQUALS | BINF_PSPECIAL, bin_typeset, 0, -1, 0, "AE:%F:%HL:%R:%TUZ:%afghi:%klprtuxmz", NULL),
+#ifndef __SYMBIAN32__
+BUILTIN("umask", 0, bin_umask, 0, 1, 0, "S", NULL),
+#endif
+BUILTIN("unalias", 0, bin_unhash, 1, -1, 0, "ms", "a"),
+BUILTIN("unfunction", 0, bin_unhash, 1, -1, 0, "m", "f"),
+BUILTIN("unhash", 0, bin_unhash, 1, -1, 0, "adfms", NULL),
+BUILTIN("unset", BINF_PSPECIAL, bin_unset, 1, -1, 0, "fmv", NULL),
+BUILTIN("unsetopt", 0, bin_setopt, 0, -1, BIN_UNSETOPT, NULL, NULL),
+#ifndef __SYMBIAN32__
+BUILTIN("wait", 0, bin_fg, 0, -1, BIN_WAIT, NULL, NULL),
+#endif
+BUILTIN("whence", 0, bin_whence, 0, -1, 0, "acmpvfsw", NULL),
+BUILTIN("where", 0, bin_whence, 0, -1, 0, "pmsw", "ca"),
+BUILTIN("which", 0, bin_whence, 0, -1, 0, "ampsw", "c"),
+#ifndef __SYMBIAN32__
+BUILTIN("zmodload", 0, bin_zmodload, 0, -1, 0, "ARILabcfdipue", NULL),
+BUILTIN("zcompile", 0, bin_zcompile, 0, -1, 0, "tUMRcmzka", NULL),
+#endif
+BUILTIN("mkdir", 0, bin_mkdir, 1, -1, 0,         "p",   NULL),
+BUILTIN("mv",    0, bin_ln,    2, -1, BIN_MV,    "fi",    NULL),
+BUILTIN("rm",    0, bin_rm,    1, -1, 0,         "dfir", NULL),
+BUILTIN("rmdir", 0, bin_rmdir, 1, -1, 0,         NULL,    NULL),
+	BUILTIN("ls", 0, bin_ls, 0, -1, 0,         "1ACFRSWacdfklmpqrstux",    NULL),
+	BUILTIN("touch", 0, bin_touch, 1, -1, 0,         "acfmrt",    NULL),
+	BUILTIN("cp", 0, bin_cp, 2, -1, 0,         "Rfipr",    NULL),
+	BUILTIN("cat", 0, bin_cat, 0, -1, 0,         "benstu",    NULL),
+	BUILTIN("more", 0, bin_more, 0, -1, 0,         NULL,    NULL),
+};
+/****************************************/
+/* Builtin Command Hash Table Functions */
+/****************************************/
+/* hash table containing builtin commands */
+/**/
+mod_export HashTable builtintab;
+#ifdef __SYMBIAN32__
+extern int pipeUsed;
+#endif
+/**/
+void
+createbuiltintable(void)
+{
+builtintab = newhashtable(85, "builtintab", NULL);
+builtintab->hash        = hasher;
+builtintab->emptytable  = NULL;
+builtintab->filltable   = NULL;
+builtintab->cmpnodes    = strcmp;
+builtintab->addnode     = addhashnode;
+builtintab->getnode     = gethashnode;
+builtintab->getnode2    = gethashnode2;
+builtintab->removenode  = removehashnode;
+builtintab->disablenode = disablehashnode;
+builtintab->enablenode  = enablehashnode;
+builtintab->freenode    = freebuiltinnode;
+builtintab->printnode   = printbuiltinnode;
+addbuiltins("zsh", builtins, sizeof(builtins)/sizeof(*builtins));
+}
+/* Print a builtin */
+/**/
+static void
+printbuiltinnode(HashNode hn, int printflags)
+{
+Builtin bn = (Builtin) hn;
+if (printflags & PRINT_WHENCE_WORD) {
+	printf("%s: builtin command\n", bn->nam);
+	return;
+}
+if (printflags & PRINT_WHENCE_CSH) {
+	printf("%s: shell built-in command\n", bn->nam);
+	return;
+}
+if (printflags & PRINT_WHENCE_VERBOSE) {
+	printf("%s is a shell builtin\n", bn->nam);
+	return;
+}
+/* default is name only */
+printf("%s\n", bn->nam);
+}
+/**/
+static void
+freebuiltinnode(HashNode hn)
+{
+Builtin bn = (Builtin) hn;
+if(!(bn->flags & BINF_ADDED)) {
+	zsfree(bn->nam);
+	zsfree(bn->optstr);
+	zfree(bn, sizeof(struct builtin));
+}
+}
+/* Make sure we have space for a new option and increment. */
+#define OPT_ALLOC_CHUNK 16
+/**/
+static int
+new_optarg(Options ops)
+{
+/* Argument index must be a non-zero 6-bit number. */
+if (ops->argscount == 63)
+	return 1;
+if (ops->argsalloc == ops->argscount) {
+	char **newptr =
+	    (char **)zhalloc((ops->argsalloc + OPT_ALLOC_CHUNK) *
+			     sizeof(char *));
+	if (ops->argsalloc)
+	    memcpy(newptr, ops->args, ops->argsalloc * sizeof(char *));
+	ops->args = newptr;
+	ops->argsalloc += OPT_ALLOC_CHUNK;
+}
+ops->argscount++;
+return 0;
+}
+#ifdef __SYMBIAN32__
+#define MAX_CMD_LEN 50
+#define SCREEN_SIZE 20
+size_t fd_total=0; //holds the current index in the table
+//need to be filled in the order of command execution...
+typedef struct fd_tab
+{
+	char command[MAX_CMD_LEN]; //command name
+	int index; //index of this command in the array...
+	pid_t pid; //pid of this command...
+	int fds[3]; //stdin, stdout, stderr of this command...
+	int hasTerminated;
+}FD_PERSIST;
+//interfaces to access this table entry..
+FD_PERSIST *fds_root=NULL;
+FD_PERSIST* getPrev(FD_PERSIST* curr)
+{
+	if(curr==NULL || curr->index<=0)
+		return NULL;
+	else
+		{
+		return &fds_root[curr->index-1];
+		}
+}
+FD_PERSIST* getNext(FD_PERSIST* curr)
+{
+	if(curr==NULL || curr->index>=fd_total-1)
+		return NULL;
+	else
+		{
+		return &fds_root[curr->index+1];
+		}
+}
+FD_PERSIST* getFirst()
+{
+	return fds_root;
+}
+FD_PERSIST* GetNextInLoop(FD_PERSIST* curr)
+{
+	if(curr==NULL || curr->index>=fd_total-1)
+		return fds_root;
+	else
+		{
+		return &fds_root[curr->index+1];
+		}
+}
+FD_PERSIST* getLast()
+{
+	if(fds_root==NULL || fd_total<=0)
+		return fds_root;
+	else
+		{
+		return  &fds_root[fd_total-1];
+		}
+}
+//generate the command arguments to be passed to popen3...
+char* getCommand(char* name, char** argv, struct options ops, int funcid)
+{
+char *pcmd=NULL;
+	size_t tot_allocated=0, curwrite=0;
+	char* ret=NULL;
+	//update the command..
+	tot_allocated=strlen(name)+2; //for space and \0
+	pcmd=(char*)calloc(tot_allocated, sizeof(char));
+	if(pcmd==NULL)
+		{
+		free(pcmd);
+		return ret;
+		}
+	sprintf(pcmd, "%s ", name);
+	curwrite=tot_allocated-1;
+	//update the arguments for the command...
+	if(argv && *argv)
+		{
+		int back_cur=curwrite;
+		int arg_cnt=0;
+		char temp[2];
+		//hold the count of args...
+		pcmd=(char*)realloc(pcmd, tot_allocated+=2);
+		if(pcmd==NULL)
+			{
+			free(pcmd);
+			return ret;
+			}
+		sprintf(pcmd+curwrite, "%d ", 0);
+		curwrite+=2;
+		//start updating args...
+		while(argv && *argv)
+			{
+			tot_allocated=strlen(*argv)+tot_allocated+1;
+			pcmd=(char*)realloc(pcmd, tot_allocated);
+			if(pcmd==NULL)
+				{
+				free(pcmd);
+				return ret;
+				}
+			sprintf(pcmd+curwrite, "%s ", *argv);
+			curwrite=curwrite+strlen(*argv)+1;
+			arg_cnt++;
+			++argv;
+			}
+		sprintf(temp,"%d", arg_cnt);
+		pcmd[back_cur]=temp[0];
+		}
+		else
+		{
+		//update with zero if no args...
+		pcmd=(char*)realloc(pcmd, tot_allocated+=2);
+		if(pcmd==NULL)
+			{
+			free(pcmd);
+			return ret;
+			}
+		sprintf(pcmd+curwrite, "%d ", 0);
+		curwrite+=2;
+		}
+	   //START: start updating the options
+	   //update ops.ind
+	    {
+	    int idx=0;
+		pcmd=(char*)realloc(pcmd, tot_allocated+=2);
+		if(pcmd==NULL)
+			{
+			free(pcmd);
+			return ret;
+			}
+		sprintf(pcmd+curwrite, "%d ", 1);
+		curwrite+=2;
+		tot_allocated=tot_allocated+MAX_OPS+2;
+	   	pcmd=(char*)realloc(pcmd, tot_allocated);
+		if(pcmd==NULL)
+			{
+			free(pcmd);
+			return ret;
+			 }
+		while(idx<MAX_OPS)
+			{
+			sprintf(pcmd+curwrite, "%d", ops.ind[idx]);
+			idx++;
+			curwrite++;
+			}
+		sprintf(pcmd+curwrite, " ");
+		curwrite=curwrite+1;
+	    }
+		//update ops.args
+	if(ops.args && *ops.args)
+		{
+		int back_cur=curwrite;
+		int arg_cnt=0;
+		char temp[2];
+		//hold the count of args...
+		pcmd=(char*)realloc(pcmd, tot_allocated+=2);
+		if(pcmd==NULL)
+			{
+			free(pcmd);
+			return ret;
+			}
+		sprintf(pcmd+curwrite, "%d ", 0);
+		curwrite+=2;
+		while(ops.args && *ops.args)
+			{
+			tot_allocated=strlen(*ops.args)+tot_allocated+1;
+			pcmd=(char*)realloc(pcmd, tot_allocated);
+			if(pcmd==NULL)
+				{
+				free(pcmd);
+				return ret;
+				}
+			sprintf(pcmd+curwrite, "%s ", *ops.args);
+			curwrite=curwrite+strlen(*ops.args)+1;
+			ops.args++;
+			arg_cnt++;
+			}
+		sprintf(temp,"%d", arg_cnt);
+		pcmd[back_cur]=temp[0];
+		}
+	else
+		{
+		//update with zero if no args...
+		pcmd=(char*)realloc(pcmd, tot_allocated+=2);
+		if(pcmd==NULL)
+			{
+			free(pcmd);
+			return ret;
+			}
+		sprintf(pcmd+curwrite, "%d ", 0);
+		curwrite+=2;
+		}
+	//update the ops.argscount
+	pcmd=(char*)realloc(pcmd, tot_allocated+=2);
+	if(pcmd==NULL)
+		{
+		free(pcmd);
+		return ret;
+		}
+	sprintf(pcmd+curwrite, "%d ", ops.argscount);
+	curwrite+=2;
+	//update the ops.argsalloc
+	pcmd=(char*)realloc(pcmd, tot_allocated+=2);
+	if(pcmd==NULL)
+		{
+		free(pcmd);
+		return ret;
+		}
+	sprintf(pcmd+curwrite, "%d ", ops.argsalloc);
+	curwrite+=2;
+	//End: end of options update...
+	//update the function id ...
+	pcmd=(char*)realloc(pcmd, tot_allocated+=1);
+	if(pcmd==NULL)
+		{
+		free(pcmd);
+		return ret;
+		}
+	sprintf(pcmd+curwrite, "%d", funcid);
+	return pcmd;
+}
+void clearfds(void)
+{
+	FD_PERSIST* fdset=getFirst();
+	while(fdset)
+		{
+		close(fdset->fds[0]);
+		close(fdset->fds[1]);
+		close(fdset->fds[2]);
+		fdset=getNext(fdset);
+		}
+	free(fds_root);
+	fds_root=0;
+}
+//this functions handles the transfer of data between commands in
+//the pipe list
+int handlePipeCmds(char* name, pid_t pid, int fds[3], int output)
+{
+	int ret=0;
+	if(fds_root==NULL)
+		{
+		fds_root= (FD_PERSIST*)calloc(1, sizeof(FD_PERSIST));
+		if(fds_root==NULL)
+			{
+			return (1);
+			}
+		fd_total=1;
+		memset(fds_root->command, 0, MAX_CMD_LEN);
+		strcpy(fds_root->command, name);
+		fds_root->index=0;
+		fds_root->pid=pid;
+		memcpy(fds_root->fds, fds, sizeof(int)*3);
+		fds_root->hasTerminated=0;
+		}
+	else
+		{
+		fds_root=(FD_PERSIST*)realloc(fds_root,
+						sizeof(FD_PERSIST)* (fd_total+1));
+		if(fds_root==NULL)
+			{
+			free(fds_root);
+			return (1);
+			}
+		memset(fds_root[fd_total].command, 0, MAX_CMD_LEN);
+		strcpy(fds_root[fd_total].command, name);
+		fds_root[fd_total].index=fd_total;
+		fds_root[fd_total].pid=pid;
+		memcpy(fds_root[fd_total].fds, fds, sizeof(int)*3);
+		fds_root[fd_total].hasTerminated=0;
+		fd_total++;
+		}
+	if(output==0 && fd_total>1)//if previous command is the last command
+		{
+		struct timeval tv;
+		char read_buf[512];
+		int read_cnt=0;
+		fd_set readfds, exceptfds;
+		int line_cnt=0;
+		int nterminated = 0;
+		FD_PERSIST* curr=getFirst();
+		while(curr!=NULL && (curr->index<fd_total))
+			{
+			if(nterminated == fd_total)
+			{
+				break;
+			}
+			if(curr->hasTerminated == 1)
+				goto jump_out;
+			for(;;)
+			  	{
+				int read_idx=0;
+			  	int max=0;
+				FD_ZERO(&readfds);
+				FD_SET(curr->fds[1], &readfds);
+			    FD_SET(curr->fds[2], &readfds);
+			    max=MAX(curr->fds[1], curr->fds[2]);
+			    FD_ZERO(&exceptfds);
+				FD_SET(curr->fds[1], &exceptfds);
+				FD_SET(curr->fds[2], &exceptfds);
+			  	if(curr->index==0)
+				    {
+				    FD_SET(0, &readfds);
+				    }
+			 	tv.tv_sec = 0;
+				tv.tv_usec = 1;
+				if(select(max+1, &readfds, NULL, &exceptfds, &tv) > 0)
+					{
+					if(FD_ISSET(curr->fds[1], &readfds))
+						{
+						memset(&read_buf[0], 0, 512);
+						read_cnt=read(curr->fds[1], &read_buf[0], 512);
+						if(read_cnt>0)
+							{
+							if(curr->index==(fd_total-1) &&
+								strcmp("more", curr->command)) //is the last command
+								{
+								write(1, read_buf, read_cnt);
+								}
+								else
+								{
+								//is more the last command, Zsh's stdio is used
+								//for more
+								if(strcmp("more", curr->command)==0 &&
+									curr->index==(fd_total-1))
+									{
+									if(line_cnt<SCREEN_SIZE)
+										{
+										while(read_idx<read_cnt)
+											{
+											write(1, &read_buf[read_idx], 1);
+											if(read_buf[++read_idx]=='\n')
+												line_cnt++;
+											if(line_cnt==SCREEN_SIZE)
+												break;
+											}
+										}
+									if(line_cnt>=SCREEN_SIZE)
+										{
+										char temp;
+										while(read_idx<read_cnt)
+											{
+											read(0, &temp, 1);
+											switch(temp)
+												{
+												case '\n':
+													{
+													while(read_idx<read_cnt)
+														{
+														if (read_buf[read_idx] == '\n')
+															{
+															read_idx++;
+															break;
+															}
+														write(1, &read_buf[read_idx++], 1);
+														}
+												}
+												break;
+												case 'q':
+													write(1, "\n", 1);
+													goto jump_out;
+												break;
+												case ' ':
+												 	{
+												 	line_cnt=0;
+												 	while(read_idx<read_cnt)
+													 	{
+														write(1, &read_buf[read_idx], 1);
+														if(read_buf[++read_idx]=='\n')
+															line_cnt++;
+														if(line_cnt==SCREEN_SIZE)
+															break;
+													 	}
+													 }
+												break;
+												default:
+												break;
+												}
+											}
+										}
+									}
+								else
+									//write the output to next command
+									write(getNext(curr)->fds[0], read_buf, read_cnt);
+								}
+							}
+						}
+					if(FD_ISSET(curr->fds[2], &readfds))
+						{
+						memset(&read_buf[0], 0, 512);
+						read_cnt=read(curr->fds[2], &read_buf[0], 512);
+						if(read_cnt>0)
+							{
+							//write the error on stderr....
+							write(2, read_buf, read_cnt);
+							}
+						}
+					if(curr->index==0 && FD_ISSET(0, &readfds))
+						{
+						char temp;
+						read(0, &temp, 1);
+						write(curr->fds[0], &temp, 1);
+						continue;
+						}
+					if(FD_ISSET(curr->fds[1], &exceptfds) || (FD_ISSET(curr->fds[2], &exceptfds)))
+						{
+						if(curr->hasTerminated != 1)
+							nterminated++;
+			    		curr->hasTerminated = 1;
+			    		goto jump_out;
+						}
+					break;
+					}
+				else
+					{
+					int status;
+					int wait_pid;
+					FD_PERSIST* prev=getPrev(curr);
+					/*
+					 * As signals are not supported(when this code was written)
+					 * there is no obvious way to terminate a proces.
+					 *
+					 * Waiting for a process to terminate may hang the shell as there is no certainity
+					 * that the launched process shall terminate and hence
+					 * the below logic is used to decide when to wait for a process termination.
+					 */
+					//break if current command is terminated by now...
+					if (curr->hasTerminated)
+						{
+						break;
+						}
+					//break if the current command is terminated...
+					wait_pid = waitpid(curr->pid, &status, WNOHANG);
+				    if ((wait_pid == curr->pid) || (wait_pid == -1))
+						{
+						if(curr->hasTerminated != 1)
+							nterminated++;
+						curr->hasTerminated=1;
+						continue;	//To check for the data being output by the curr command ...
+						}
+					/*
+					 * Break if the previous command in the pipe list exited.
+					 * This is the toughest decision(to break even if the current command exist), because
+					 * we will endup in losing the data that the current command might output at later point in time.
+					 */
+					else if (!prev || prev->hasTerminated)
+						{
+						tv.tv_sec = 1;
+						tv.tv_usec = 0;
+						FD_ZERO(&readfds);
+						FD_SET(curr->fds[1], &readfds);
+					    FD_SET(curr->fds[2], &readfds);
+					    if(!prev)
+					    	FD_SET(0,&readfds);
+						max=MAX(curr->fds[1], curr->fds[2]);
+						if(select(max+1, &readfds, NULL, NULL, &tv) <=0)
+							{
+							if(curr->hasTerminated != 1)
+								nterminated++;
+							curr->hasTerminated = 1;
+							break;
+							}
+						}
+				//continue the look up again...
+					else
+						{
+						continue;
+						}
+					}
+			  	}
+jump_out:
+			curr=GetNextInLoop(curr);
+			}
+		clearfds();
+		}
+	return ret;
+}
+#endif //__SYMBIAN32__
+/* execute a builtin handler function after parsing the arguments */
+/**/
+int
+execbuiltin(LinkList args, Builtin bn, int input, int output)
+{
+char *pp, *name, *optstr;
+int flags, sense, argc, execop, xtr = isset(XTRACE);
+struct options ops;
+	int ret;
+/* initialise options structure */
+memset(ops.ind, 0, MAX_OPS*sizeof(unsigned char));
+ops.args = NULL;
+ops.argscount = ops.argsalloc = 0;
+/* initialize some local variables */
+name = (char *) ugetnode(args);
+if (!bn->handlerfunc) {
+	zwarnnam(name, "autoload failed", NULL, 0);
+	deletebuiltin(bn->nam);
+	return 1;
+}
+/* get some information about the command */
+flags = bn->flags;
+optstr = bn->optstr;
+/* Set up the argument list. */
+/* count the arguments */
+argc = countlinknodes(args);
+{
+	/*
+	 * Keep all arguments, including options, in an array.
+	 * We don't actually need the option part of the argument
+	 * after option processing, but it makes XTRACE output
+	 * much simpler.
+	 */
+	VARARR(char *, argarr, argc + 1);
+	char **argv;
+	/*
+	 * Get the actual arguments, into argv.  Remember argarr
+	 * may be an array declaration, depending on the compiler.
+	 */
+	argv = argarr;
+	while ((*argv++ = (char *)ugetnode(args)));
+	argv = argarr;
+	/* Sort out the options. */
+	if (optstr) {
+	    char *arg = *argv;
+	    /* while arguments look like options ... */
+	    while (arg &&
+		   /* Must begin with - or maybe + */
+		   ((sense = (*arg == '-')) ||
+		    ((flags & BINF_PLUSOPTS) && *arg == '+'))) {
+		/* Digits aren't arguments unless the command says they are. */
+		if (!(flags & BINF_KEEPNUM) && idigit(arg[1]))
+		    break;
+		/* For cd and friends, a single dash is not an option. */
+		if ((flags & BINF_SKIPDASH) && !arg[1])
+		    break;
+		if ((flags & BINF_DASHDASHVALID) && !strcmp(arg, "--")) {
+		    /*
+		     * Need to skip this before checking whether this is
+		     * really an option.
+		     */
+		    argv++;
+		    break;
+		}
+		/*
+		 * Unrecognised options to echo etc. are not really
+		 * options.
+		 *
+		 * Note this flag is not smart enough to handle option
+		 * arguments.  In fact, ideally it shouldn't be added
+		 * to any new builtins, to preserve standard option
+		 * handling as much as possible.
+		*/
+		if (flags & BINF_SKIPINVALID) {
+		    char *p = arg;
+		    if (optstr)
+			while (*++p && strchr(optstr, (int) *p));
+		    else
+			p++;
+		    if (*p)
+			break;
+		}
+		/* handle -- or - (ops.ind['-']), and +
+		 * (ops.ind['-'] and ops.ind['+']) */
+		if (arg[1] == '-')
+		    arg++;
+		if (!arg[1]) {
+		    ops.ind['-'] = 1;
+		    if (!sense)
+			ops.ind['+'] = 1;
+		}
+		/* save options in ops, as long as they are in bn->optstr */
+		while (*++arg) {
+		    char *optptr;
+		    if ((optptr = strchr(optstr, execop = (int)*arg))) {
+			ops.ind[(int)*arg] = (sense) ? 1 : 2;
+			if (optptr[1] == ':') {
+			    char *argptr = NULL;
+			    if (optptr[2] == ':') {
+				if (arg[1])
+				    argptr = arg+1;
+				/* Optional argument in same word*/
+			    } else if (optptr[2] == '%') {
+				/* Optional numeric argument in same
+				 * or next word. */
+				if (arg[1] && idigit(arg[1]))
+				    argptr = arg+1;
+				else if (argv[1] && idigit(*argv[1]))
+				    argptr = arg = *++argv;
+			    } else {
+				/* Mandatory argument */
+				if (arg[1])
+				    argptr = arg+1;
+				else if ((arg = *++argv))
+				    argptr = arg;
+				else {
+				    zwarnnam(name, "argument expected: -%c",
+					     NULL, execop);
+				    return 1;
+				}
+			    }
+			    if (argptr) {
+				if (new_optarg(&ops)) {
+				    zwarnnam(name,
+					     "too many option arguments",
+					     NULL, 0);
+				    return 1;
+				}
+				ops.ind[execop] |= ops.argscount << 2;
+				ops.args[ops.argscount-1] = argptr;
+				while (arg[1])
+				    arg++;
+			    }
+			}
+		    } else
+			break;
+		}
+		/* The above loop may have exited on an invalid option.  (We  *
+		 * assume that any option requiring metafication is invalid.) */
+		if (*arg) {
+		    if(*arg == Meta)
+			*++arg ^= 32;
+		    zwarn("bad option: -%c", NULL, *arg);
+		    return 1;
+		}
+		arg = *++argv;
+		/* for the "print" builtin, the options after -R are treated as
+		   options to "echo" */
+		if ((flags & BINF_PRINTOPTS) && ops.ind['R'] &&
+		    !ops.ind['f']) {
+		    optstr = "ne";
+		    flags |= BINF_SKIPINVALID;
+		}
+		/* the option -- indicates the end of the options */
+		if (ops.ind['-'])
+		    break;
+	    }
+	}
+	/* handle built-in options, for overloaded handler functions */
+	if ((pp = bn->defopts)) {
+	    while (*pp) {
+		/* only if not already set */
+		if (!ops.ind[(int)*pp])
+		    ops.ind[(int)*pp] = 1;
+		pp++;
+	    }
+	}
+	/* Fix the argument count by subtracting option arguments */
+	argc -= argv - argarr;
+	if (errflag) {
+	    errflag = 0;
+	    return 1;
+	}
+	/* check that the argument count lies within the specified bounds */
+	if (argc < bn->minargs || (argc > bn->maxargs && bn->maxargs != -1)) {
+	    zwarnnam(name, (argc < bn->minargs)
+		     ? "not enough arguments" : "too many arguments", NULL, 0);
+	    return 1;
+	}
+	/* display execution trace information, if required */
+	if (xtr) {
+	    /* Use full argument list including options for trace output */
+	    char **fullargv = argarr;
+	    printprompt4();
+	    fprintf(xtrerr, "%s", name);
+	    while (*fullargv) {
+	        fputc(' ', xtrerr);
+	        quotedzputs(*fullargv++, xtrerr);
+	    }
+	    fputc('\n', xtrerr);
+	    fflush(xtrerr);
+	}
+	if(input||output)
+		{
+		int fds[3];
+		int pid;
+		char* pcmd=getCommand(name, argv, ops, bn->funcid);
+	    //zsh should call a builtin function..
+	    // so have a flag to denote that
+		if ( (pid=popen3("zsh", pcmd, environ, fds)) == -1)
+			{
+			printf("zsh: process creation failed for command %s\n",name);
+			}
+		else
+			{
+			ret=handlePipeCmds(name, pid, &fds[0], output);
+			}
+		free(pcmd);
+		}
+	else
+		{
+		#ifdef __SYMBIAN32__
+		/* The part of code added here is to handle the Unix style root directory name. 		 	*
+		 * Here, On Symbian OS, the root dir name is the root dir of the PWD. So, we check 		 	*
+		 * to see if the first char is "/", it is supposed to be changed with root of the present	*
+		 * working directory. Also, for this the space allocated for the *argv is increases by 2 	*
+		 * bytes in "string.c" to accomodate a maximum of 2 letter more. Since a drive name can be  *
+		 * of maxlength 2, drive name followed by a colon (":")
+		 */
+		if(*argv && *argv[0] == '\\')
+			{
+			char dir[MAXPATHLEN];
+			getcwd(dir,MAXPATHLEN);
+		dir[2] = '\0';
+			strcat(dir,*argv);
+			strcpy(*argv,dir);
+			}
+	#endif
+	/* call the handler function, and return its return value */
+		ret= (*(bn->handlerfunc)) (name, argv, &ops, bn->funcid);
+		}
+	}
+return ret;
+}
+#ifndef __SYMBIAN32__
+/* Enable/disable an element in one of the internal hash tables.  *
+* With no arguments, it lists all the currently enabled/disabled *
+* elements in that particular hash table.                        */
+/**/
+int
+bin_enable(char *name, char **argv, Options ops, int func)
+{
+HashTable ht;
+HashNode hn;
+ScanFunc scanfunc;
+Patprog pprog;
+int flags1 = 0, flags2 = 0;
+int match = 0, returnval = 0;
+/* Find out which hash table we are working with. */
+if (OPT_ISSET(ops,'f'))
+	ht = shfunctab;
+else if (OPT_ISSET(ops,'r'))
+	ht = reswdtab;
+else if (OPT_ISSET(ops,'s'))
+	ht = sufaliastab;
+else if (OPT_ISSET(ops,'a'))
+	ht = aliastab;
+else
+	ht = builtintab;
+/* Do we want to enable or disable? */
+if (func == BIN_ENABLE) {
+	flags2 = DISABLED;
+	scanfunc = ht->enablenode;
+} else {
+	flags1 = DISABLED;
+	scanfunc = ht->disablenode;
+}
+/* Given no arguments, print the names of the enabled/disabled elements  *
+* in this hash table.  If func == BIN_ENABLE, then scanhashtable will   *
+* print nodes NOT containing the DISABLED flag, else scanhashtable will *
+* print nodes containing the DISABLED flag.                             */
+if (!*argv) {
+	queue_signals();
+	scanhashtable(ht, 1, flags1, flags2, ht->printnode, 0);
+	unqueue_signals();
+	return 0;
+}
+/* With -m option, treat arguments as glob patterns. */
+if (OPT_ISSET(ops,'m')) {
+	for (; *argv; argv++) {
+	    /* parse pattern */
+	    tokenize(*argv);
+	    if ((pprog = patcompile(*argv, PAT_STATIC, 0))) {
+		queue_signals();
+		match += scanmatchtable(ht, pprog, 0, 0, scanfunc, 0);
+		unqueue_signals();
+	    }
+	    else {
+		untokenize(*argv);
+		zwarnnam(name, "bad pattern : %s", *argv, 0);
+		returnval = 1;
+	    }
+	}
+	/* If we didn't match anything, we return 1. */
+	if (!match)
+	    returnval = 1;
+	return returnval;
+}
+/* Take arguments literally -- do not glob */
+queue_signals();
+for (; *argv; argv++) {
+	if ((hn = ht->getnode2(ht, *argv))) {
+	    scanfunc(hn, 0);
+	} else {
+	    zwarnnam(name, "no such hash table element: %s", *argv, 0);
+	    returnval = 1;
+	}
+}
+unqueue_signals();
+return returnval;
+}
+#endif //__SYMBIAN32__
+/* set: either set the shell options, or set the shell arguments, *
+* or declare an array, or show various things                    */
+/**/
+int
+bin_set(char *nam, char **args, UNUSED(Options ops), UNUSED(int func))
+{
+int action, optno, array = 0, hadopt = 0,
+	hadplus = 0, hadend = 0, sort = 0;
+char **x, *arrayname = NULL;
+/* Obsolescent sh compatibility: set - is the same as set +xv *
+* and set - args is the same as set +xv -- args              */
+if (*args && **args == '-' && !args[0][1]) {
+	dosetopt(VERBOSE, 0, 0);
+	dosetopt(XTRACE, 0, 0);
+	if (!args[1])
+	    return 0;
+}
+/* loop through command line options (begins with "-" or "+") */
+while (*args && (**args == '-' || **args == '+')) {
+	action = (**args == '-');
+	hadplus |= !action;
+	if(!args[0][1])
+	    *args = "--";
+	while (*++*args) {
+	    if(**args == Meta)
+		*++*args ^= 32;
+	    if(**args != '-' || action)
+		hadopt = 1;
+	    /* The pseudo-option `--' signifies the end of options. */
+	    if (**args == '-') {
+		hadend = 1;
+		args++;
+		goto doneoptions;
+	    } else if (**args == 'o') {
+		if (!*++*args)
+		    args++;
+		if (!*args) {
+		    printoptionstates(hadplus);
+		    inittyptab();
+		    return 0;
+		}
+		if(!(optno = optlookup(*args)))
+		    zwarnnam(nam, "no such option: %s", *args, 0);
+		else if(dosetopt(optno, action, 0))
+		    zwarnnam(nam, "can't change option: %s", *args, 0);
+		break;
+	    } else if(**args == 'A') {
+		if(!*++*args)
+		    args++;
+		array = action ? 1 : -1;
+		arrayname = *args;
+		if (!arrayname)
+		    goto doneoptions;
+		else if  (!isset(KSHARRAYS))
+		{
+		    args++;
+		    goto doneoptions;
+		}
+		break;
+	    } else if (**args == 's')
+		sort = action ? 1 : -1;
+	    else {
+	    	if (!(optno = optlookupc(**args)))
+		    zwarnnam(nam, "bad option: -%c", NULL, **args);
+		else if(dosetopt(optno, action, 0))
+		    zwarnnam(nam, "can't change option: -%c", NULL, **args);
+	    }
+	}
+	args++;
+}
+doneoptions:
+inittyptab();
+/* Show the parameters, possibly with values */
+queue_signals();
+if (!arrayname)
+{
+	if (!hadopt && !*args)
+	    scanhashtable(paramtab, 1, 0, 0, paramtab->printnode,
+			  hadplus ? PRINT_NAMEONLY : 0);
+	if (array) {
+	    /* display arrays */
+	    scanhashtable(paramtab, 1, PM_ARRAY, 0, paramtab->printnode,
+			  hadplus ? PRINT_NAMEONLY : 0);
+	}
+	if (!*args && !hadend) {
+	    unqueue_signals();
+	    return 0;
+	}
+}
+if (sort)
+	qsort(args, arrlen(args), sizeof(char *),
+	      sort > 0 ? strpcmp : invstrpcmp);
+if (array) {
+	/* create an array with the specified elements */
+	char **a = NULL, **y;
+	int len = arrlen(args);
+	if (array < 0 && (a = getaparam(arrayname))) {
+	    int al = arrlen(a);
+	    if (al > len)
+		len = al;
+	}
+	for (x = y = zalloc((len + 1) * sizeof(char *)); len--; a++) {
+	    if (!*args)
+		args = a;
+	    *y++ = ztrdup(*args++);
+	}
+	*y++ = NULL;
+	setaparam(arrayname, x);
+} else {
+	/* set shell arguments */
+	freearray(pparams);
+	pparams = zarrdup(args);
+}
+unqueue_signals();
+return 0;
+}
+/**** directory-handling builtins ****/
+/**/
+int doprintdir = 0;		/* set in exec.c (for autocd) */
+/* pwd: display the name of the current directory */
+/**/
+int
+bin_pwd(UNUSED(char *name), UNUSED(char **argv), Options ops, UNUSED(int func))
+{
+	char maxpath[126];
+if (OPT_ISSET(ops,'r') || OPT_ISSET(ops,'P') ||
+	(isset(CHASELINKS) && !OPT_ISSET(ops,'L')))
+	printf("%s\n", getcwd(maxpath, 126));
+else {
+	zputs(pwd, stdout);
+	putchar('\n');
+}
+return 0;
+}
+/* the directory stack */
+/**/
+mod_export LinkList dirstack;
+/* dirs: list the directory stack, or replace it with a provided list */
+/**/
+int
+bin_dirs(UNUSED(char *name), char **argv, Options ops, UNUSED(int func))
+{
+LinkList l;
+queue_signals();
+/* with -v, -p or no arguments display the directory stack */
+if (!(*argv || OPT_ISSET(ops,'c')) || OPT_ISSET(ops,'v') ||
+	OPT_ISSET(ops,'p')) {
+	LinkNode node;
+	char *fmt;
+	int pos = 1;
+	/* with the -v option, display a numbered list, starting at zero */
+	if (OPT_ISSET(ops,'v')) {
+	    printf("0\t");
+	    fmt = "\n%d\t";
+	/* with the -p option, display entries one per line */
+	} else if (OPT_ISSET(ops,'p'))
+	    fmt = "\n";
+	else
+	    fmt = " ";
+	if (OPT_ISSET(ops,'l'))
+	    fputs(pwd, stdout);
+	else
+	    fprintdir(pwd, stdout);
+	for (node = firstnode(dirstack); node; incnode(node)) {
+	    printf(fmt, pos++);
+	    if (OPT_ISSET(ops,'l'))
+		fputs(getdata(node), stdout);
+	    else
+		fprintdir(getdata(node), stdout);
+	}
+	unqueue_signals();
+	putchar('\n');
+	return 0;
+}
+/* replace the stack with the specified directories */
+l = znewlinklist();
+while (*argv)
+	zaddlinknode(l, ztrdup(*argv++));
+freelinklist(dirstack, freestr);
+dirstack = l;
+unqueue_signals();
+return 0;
+}
+/* cd, chdir, pushd, popd */
+/**/
+void
+set_pwd_env(void)
+{
+Param pm;
+/* update the PWD and OLDPWD shell parameters */
+pm = (Param) paramtab->getnode(paramtab, "PWD");
+if (pm && PM_TYPE(pm->flags) != PM_SCALAR) {
+	pm->flags &= ~PM_READONLY;
+	unsetparam_pm(pm, 0, 1);
+}
+pm = (Param) paramtab->getnode(paramtab, "OLDPWD");
+if (pm && PM_TYPE(pm->flags) != PM_SCALAR) {
+	pm->flags &= ~PM_READONLY;
+	unsetparam_pm(pm, 0, 1);
+}
+setsparam("PWD", ztrdup(pwd));
+setsparam("OLDPWD", ztrdup(oldpwd));
+pm = (Param) paramtab->getnode(paramtab, "PWD");
+if (!(pm->flags & PM_EXPORTED))
+	addenv(pm, pwd);
+pm = (Param) paramtab->getnode(paramtab, "OLDPWD");
+if (!(pm->flags & PM_EXPORTED))
+	addenv(pm, oldpwd);
+}
+/* set if we are resolving links to their true paths */
+static int chasinglinks;
+/* The main pwd changing function.  The real work is done by other     *
+* functions.  cd_get_dest() does the initial argument processing;     *
+* cd_do_chdir() actually changes directory, if possible; cd_new_pwd() *
+* does the ancillary processing associated with actually changing    *
+* directory.                                                          */
+/**/
+int
+bin_cd(char *nam, char **argv, Options ops, int func)
+{
+LinkNode dir;
+struct stat st1, st2;
+if (isset(RESTRICTED)) {
+	zwarnnam(nam, "restricted", NULL, 0);
+	return 1;
+}
+doprintdir = (doprintdir == -1);
+chasinglinks = OPT_ISSET(ops,'P') ||
+	(isset(CHASELINKS) && !OPT_ISSET(ops,'L'));
+queue_signals();
+zpushnode(dirstack, ztrdup(pwd));
+if (!(dir = cd_get_dest(nam, argv, OPT_ISSET(ops,'s'), func))) {
+	zsfree(getlinknode(dirstack));
+	unqueue_signals();
+	return 1;
+}
+cd_new_pwd(func, dir);
+if (stat(unmeta(pwd), &st1) < 0 && errno!=EACCES) {
+	setjobpwd();
+	zsfree(pwd);
+	pwd = metafy(zgetcwd(), -1, META_DUP);
+} else if (stat(".", &st2) < 0)
+	chdir(unmeta(pwd));
+else if (st1.st_ino != st2.st_ino || st1.st_dev != st2.st_dev) {
+	if (chasinglinks) {
+	    setjobpwd();
+	    zsfree(pwd);
+	    pwd = metafy(zgetcwd(), -1, META_DUP);
+	} else {
+	    chdir(unmeta(pwd));
+	}
+}
+unqueue_signals();
+return 0;
+}
+/* Get directory to chdir to */
+/**/
+static LinkNode
+cd_get_dest(char *nam, char **argv, int hard, int func)
+{
+LinkNode dir = NULL;
+LinkNode target;
+char *dest;
+if (!argv[0]) {
+	if (func == BIN_POPD && !nextnode(firstnode(dirstack))) {
+	    zwarnnam(nam, "directory stack empty", NULL, 0);
+	    return NULL;
+	}
+	if (func == BIN_PUSHD && unset(PUSHDTOHOME))
+	    dir = nextnode(firstnode(dirstack));
+	if (dir)
+	    zinsertlinknode(dirstack, dir, getlinknode(dirstack));
+	else if (func != BIN_POPD)
+	    zpushnode(dirstack, ztrdup(home));
+} else if (!argv[1]) {
+	int dd;
+	char *end;
+	doprintdir++;
+	if (argv[0][1] && (argv[0][0] == '+' || argv[0][0] == '-')) {
+	    dd = zstrtol(argv[0] + 1, &end, 10);
+	    if (*end == '\0') {
+		if ((argv[0][0] == '+') ^ isset(PUSHDMINUS))
+		    for (dir = firstnode(dirstack); dir && dd; dd--, incnode(dir));
+		else
+		    for (dir = lastnode(dirstack); dir != (LinkNode) dirstack && dd;
+			 dd--, dir = prevnode(dir));
+		if (!dir || dir == (LinkNode) dirstack) {
+		    zwarnnam(nam, "no such entry in dir stack", NULL, 0);
+		    return NULL;
+		}
+	    }
+	}
+	if (!dir)
+	    zpushnode(dirstack, ztrdup(strcmp(argv[0], "-")
+				       ? (doprintdir--, argv[0]) : oldpwd));
+} else {
+	char *u, *d;
+	int len1, len2, len3;
+	if (!(u = strstr(pwd, argv[0]))) {
+	    zwarnnam(nam, "string not in pwd: %s", argv[0], 0);
+	    return NULL;
+	}
+	len1 = strlen(argv[0]);
+	len2 = strlen(argv[1]);
+	len3 = u - pwd;
+	d = (char *)zalloc(len3 + len2 + strlen(u + len1) + 1);
+	strncpy(d, pwd, len3);
+	strcpy(d + len3, argv[1]);
+	strcat(d, u + len1);
+	zpushnode(dirstack, d);
+	doprintdir++;
+}
+target = dir;
+if (func == BIN_POPD) {
+	if (!dir) {
+	    target = dir = firstnode(dirstack);
+	} else if (dir != firstnode(dirstack)) {
+	    return dir;
+	}
+	dir = nextnode(dir);
+}
+if (!dir) {
+	dir = firstnode(dirstack);
+}
+if (!(dest = cd_do_chdir(nam, getdata(dir), hard))) {
+	if (!target)
+	    zsfree(getlinknode(dirstack));
+	if (func == BIN_POPD)
+	    zsfree(remnode(dirstack, dir));
+	return NULL;
+}
+if (dest != (char *)getdata(dir)) {
+	zsfree(getdata(dir));
+	setdata(dir, dest);
+}
+return target ? target : dir;
+}
+/* Change to given directory, if possible.  This function works out  *
+* exactly how the directory should be interpreted, including cdpath *
+* and CDABLEVARS.  For each possible interpretation of the given    *
+* path, this calls cd_try_chdir(), which attempts to chdir to that  *
+* particular path.                                                  */
+/**/
+static char *
+cd_do_chdir(char *cnam, char *dest, int hard)
+{
+char **pp, *ret;
+int hasdot = 0, eno = ENOENT;
+/*
+* nocdpath indicates that cdpath should not be used.
+* This is the case iff dest is a relative path
+* whose first segment is . or .., but if the path is
+* absolute then cdpath won't be used anyway.
+*/
+int nocdpath;
+#ifdef __CYGWIN__
+/*
+* Normalize path under Cygwin to avoid messing with
+* DOS style names with drives in them
+*/
+static char buf[PATH_MAX];
+#ifndef _SYS_CYGWIN_H
+void cygwin_conv_to_posix_path(const char *, char *);
+#endif
+cygwin_conv_to_posix_path(dest, buf);
+dest = buf;
+#endif
+nocdpath = dest[0] == '.' &&
+	(dest[1] == '/' || dest[1] == '\\' || !dest[1] || (dest[1] == '.' &&
+					(dest[2] == '/' || dest[2] == '\\' || !dest[2])));
+/*
+* If we have an absolute path, use it as-is only
+*/
+if (*dest == '/' || *dest == '\\') {
+	if ((ret = cd_try_chdir(NULL, dest, hard)))
+	    return ret;
+	zwarnnam(cnam, "%e: %s", dest, errno);
+	return NULL;
+}
+/* if cdpath is being used, check it for . */
+if (!nocdpath)
+	for (pp = cdpath; *pp; pp++)
+	    if (!(*pp)[0] || ((*pp)[0] == '.' && (*pp)[1] == '\0'))
+		hasdot = 1;
+/* if there is no . in cdpath (or it is not being used), try the directory
+as-is (i.e. from .) */
+if (!hasdot) {
+	if ((ret = cd_try_chdir(NULL, dest, hard)))
+	    return ret;
+	if (errno != ENOENT)
+	    eno = errno;
+}
+/* if cdpath is being used, try given directory relative to each element in
+cdpath in turn */
+if (!nocdpath)
+	for (pp = cdpath; *pp; pp++) {
+	    if ((ret = cd_try_chdir(*pp, dest, hard))) {
+		if (strcmp(*pp, ".")) {
+		    doprintdir++;
+		}
+		return ret;
+	    }
+	    if (errno != ENOENT)
+		eno = errno;
+	}
+/* handle the CDABLEVARS option */
+if ((ret = cd_able_vars(dest))) {
+	if ((ret = cd_try_chdir(NULL, ret,hard))) {
+	    doprintdir++;
+	    return ret;
+	}
+	if (errno != ENOENT)
+	    eno = errno;
+}
+/* If we got here, it means that we couldn't chdir to any of the
+multitudinous possible paths allowed by zsh.  We've run out of options!
+Add more here! */
+	if(eno)
+	zwarnnam(cnam, "%e: %s", dest, eno);
+return NULL;
+}
+/* If the CDABLEVARS option is set, return the new *
+* interpretation of the given path.               */
+/**/
+char *
+cd_able_vars(char *s)
+{
+char *rest, save;
+if (isset(CDABLEVARS)) {
+	for (rest = s; *rest && *rest != '/'; rest++);
+	save = *rest;
+	*rest = 0;
+	s = getnameddir(s);
+	*rest = save;
+	if (s && *rest)
+	    s = dyncat(s, rest);
+	return s;
+}
+return NULL;
+}
+/* Attempt to change to a single given directory.  The directory,    *
+* for the convenience of the calling function, may be provided in   *
+* two parts, which must be concatenated before attempting to chdir. *
+* Returns NULL if the chdir fails.  If the directory change is      *
+* possible, it is performed, and a pointer to the new full pathname *
+* is returned.                                                      */
+/**/
+static char *
+cd_try_chdir(char *pfix, char *dest, int hard)
+{
+char *buf;
+int dlen, dochaselinks = 0;
+/* handle directory prefix */
+if (pfix && *pfix) {
+	if (*pfix == '/' || *pfix == '\\' )
+#ifdef __CYGWIN__
+/* NB: Don't turn "/"+"bin" into "//"+"bin" by mistake!  "//bin" may *
+* not be what user really wants (probably wants "/bin"), but        *
+* "//bin" could be valid too (see fixdir())!  This is primarily for *
+* handling CDPATH correctly.                                        */
+	    buf = tricat(pfix, ( pfix[1] == '\0' ? "" : "/" ), dest);
+#else
+	    buf = tricat(pfix, "/", dest);
+#endif
+	else {
+	    int pfl = strlen(pfix);
+	    dlen = strlen(pwd);
+	    buf = zalloc(dlen + pfl + strlen(dest) + 3);
+	    strcpy(buf, pwd);
+#ifdef __SYMBIAN32__
+	    buf[dlen] = '\\';
+#else
+	    buf[dlen] = '/'
+#endif
+	    strcpy(buf + dlen + 1, pfix);
+	    buf[dlen + 1 + pfl] = '/';
+	    strcpy(buf + dlen + pfl + 2, dest);
+	}
+} else if (*dest == '/' || *dest == '\\')
+	buf = ztrdup(dest);
+else {
+	dlen = strlen(pwd);
+	if (pwd[dlen-1] == '/' || pwd[dlen-1] == '\\')
+	    --dlen;
+	buf = zalloc(dlen + strlen(dest) + 2);
+	if(!strstr(dest, ":"))
+		{
+		//do only if destination path is actual path
+		strcpy(buf, pwd);
+		buf[dlen] = '\\';
+		strcpy(buf + dlen + 1, dest);
+		}
+	else
+		{
+		size_t des=strlen(dest);
+		strcpy(buf, dest);
+		buf[des] = '\\';
+		buf[des+1] = '\0';
+		}
+}
+/* Normalise path.  See the definition of fixdir() for what this means.
+* We do not do this if we are chasing links.
+*/
+if (!chasinglinks)
+	dochaselinks = fixdir(buf);
+else
+	unmetafy(buf, &dlen);
+/* We try the full path first.  If that fails, try the
+* argument to cd relatively.  This is useful if the cwd
+* or a parent directory is renamed in the interim.
+*/
+if (lchdir(buf, NULL, hard)/* && lchdir(dest, NULL, hard)*/) {
+	free(buf);
+	return NULL;
+}
+/* the chdir succeeded, so decide if we should force links to be chased */
+if (dochaselinks)
+	chasinglinks = 1;
+return metafy(buf, -1, META_NOALLOC);
+}
+/* do the extra processing associated with changing directory */
+/**/
+static void
+cd_new_pwd(int func, LinkNode dir)
+{
+Eprog prog;
+char *new_pwd, *s;
+int dirstacksize;
+if (func == BIN_PUSHD)
+	rolllist(dirstack, dir);
+new_pwd = remnode(dirstack, dir);
+if (func == BIN_POPD && firstnode(dirstack)) {
+	zsfree(new_pwd);
+	new_pwd = getlinknode(dirstack);
+} else if (func == BIN_CD && unset(AUTOPUSHD))
+	zsfree(getlinknode(dirstack));
+if (chasinglinks) {
+	s = new_pwd;
+	new_pwd = findpwd(s);
+	zsfree(s);
+}
+if (isset(PUSHDIGNOREDUPS)) {
+	LinkNode n;
+	for (n = firstnode(dirstack); n; incnode(n)) {
+	    if (!strcmp(new_pwd, getdata(n))) {
+		zsfree(remnode(dirstack, n));
+		break;
+	    }
+	}
+}
+/* shift around the pwd variables, to make oldpwd and pwd relate to the
+current (i.e. new) pwd */
+zsfree(oldpwd);
+oldpwd = pwd;
+setjobpwd();
+pwd = new_pwd;
+set_pwd_env();
+if (isset(INTERACTIVE)) {
+	if (unset(PUSHDSILENT) && func != BIN_CD)
+	    printdirstack();
+	else if (doprintdir) {
+	    fprintdir(pwd, stdout);
+	    putchar('\n');
+	}
+}
+/* execute the chpwd function */
+if ((prog = getshfunc("chpwd")) != &dummy_eprog) {
+	int osc = sfcontext;
+	fflush(stdout);
+	fflush(stderr);
+	sfcontext = SFC_HOOK;
+	doshfunc("chpwd", prog, NULL, 0, 1);
+	sfcontext = osc;
+}
+dirstacksize = getiparam("DIRSTACKSIZE");
+/* handle directory stack sizes out of range */
+if (dirstacksize > 0) {
+	int remove = countlinknodes(dirstack) -
+	    (dirstacksize < 2 ? 2 : dirstacksize);
+	while (remove-- >= 0)
+	    zsfree(remnode(dirstack, lastnode(dirstack)));
+}
+}
+/* Print the directory stack */
+/**/
+static void
+printdirstack(void)
+{
+LinkNode node;
+fprintdir(pwd, stdout);
+for (node = firstnode(dirstack); node; incnode(node)) {
+	putchar(' ');
+	fprintdir(getdata(node), stdout);
+}
+putchar('\n');
+}
+/* Normalise a path.  Segments consisting of ., and foo/.. *
+* combinations, are removed and the path is unmetafied.
+* Returns 1 if we found a ../ path which should force links to
+* be chased, 0 otherwise.
+*/
+/**/
+int
+fixdir(char *src)
+{
+char *dest = src, *d0 = dest;
+#ifdef __CYGWIN__
+char *s0 = src;
+#endif
+int ret = 0;
+/*** if have RFS superroot directory ***/
+#ifdef HAVE_SUPERROOT
+/* allow /.. segments to remain */
+while (*src == '/' && src[1] == '.' && src[2] == '.' &&
+	   (!src[3] || src[3] == '/')) {
+	*dest++ = '/';
+	*dest++ = '.';
+	*dest++ = '.';
+	src += 3;
+}
+#endif
+for (;;) {
+	/* compress multiple /es into single */
+	if (*src == '/'||*src == '\\') {
+#ifdef __CYGWIN__
+	    /* allow leading // under cygwin */
+	    if (src == s0 && (src[1] == '/' || src[1] == '\\'))
+		*dest++ = *src++;
+#endif
+	    *dest++ = *src++;
+	    while (*src == '/'||*src == '\\')
+		src++;
+	}
+	/* if we are at the end of the input path, remove a trailing / (if it
+	   exists), and return ct */
+	if (!*src) {
+	    while (dest > d0 + 1 && (dest[-1] == '/' ||dest[-1] == '\\' ))
+		dest--;
+	    *dest = '\0';
+	    return ret;
+	}
+	if (src[0] == '.' && src[1] == '.' &&
+	    (src[2] == '\0' || src[2] == '/' || src[2] == '\\')) {
+	    if (isset(CHASEDOTS)) {
+		ret = 1;
+		/* and treat as normal path segment */
+	    } else {
+		if (dest > d0 + 1) {
+		    /*
+		     * remove a foo/.. combination:
+		     * first check foo exists, else return.
+		     */
+		    struct stat st;
+		    *dest = '\0';
+		    if ( (stat(d0, &st) < 0 && errno!=EACCES) || !S_ISDIR(st.st_mode)) {
+			char *ptrd, *ptrs;
+			if (dest == src)
+			    *dest = '.';
+			for (ptrs = src, ptrd = dest; *ptrs; ptrs++, ptrd++)
+			    *ptrd = (*ptrs == Meta) ? (*++ptrs ^ 32) : *ptrs;
+			*ptrd = '\0';
+			return 1;
+		    }
+		    for (dest--; dest > d0 + 1 && (dest[-1] != '/'&&dest[-1] != '\\'); dest--);
+		    if (dest[-1] != '/' && dest[-1] != '\\')
+			dest--;
+		}
+		src++;
+		while (*++src == '/' || *src == '\\');
+		continue;
+	    }
+	}
+	if (src[0] == '.' && (src[1] == '/' || src[1] == '\\'|| src[1] == '\0')) {
+	    /* skip a . section */
+	    while (*++src == '/'||*src == '\\');
+	} else {
+	    /* copy a normal segment into the output */
+	    while ( (*src != '/' && *src != '\\') && *src != '\0')
+		if ((*dest++ = *src++) == Meta)
+		    dest[-1] = *src++ ^ 32;
+	}
+}
+}
+#ifndef __SYMBIAN32__
+/**/
+mod_export void
+printqt(char *str)
+{
+/* Print str, but turn any single quote into '\'' or ''. */
+for (; *str; str++)
+	if (*str == '\'')
+	    printf(isset(RCQUOTES) ? "''" : "'\\''");
+	else
+	    putchar(*str);
+}
+/**/
+mod_export void
+printif(char *str, int c)
+{
+/* If flag c has an argument, print that */
+if (str) {
+	printf(" -%c ", c);
+	quotedzputs(str, stdout);
+}
+}
+#endif
+/**** history list functions ****/
+/* fc, history, r */
+/**/
+int
+bin_fc(char *nam, char **argv, Options ops, int func)
+{
+zlong first = -1, last = -1;
+int retval;
+char *s;
+struct asgment *asgf = NULL, *asgl = NULL;
+Patprog pprog = NULL;
+/* fc is only permitted in interactive shells */
+if (!interact) {
+	zwarnnam(nam, "not interactive shell", NULL, 0);
+	return 1;
+}
+if (OPT_ISSET(ops,'p')) {
+	char *hf = "";
+	zlong hs = DEFAULT_HISTSIZE;
+	zlong shs = 0;
+	int level = OPT_ISSET(ops,'a') ? locallevel : -1;
+	if (*argv) {
+	    hf = *argv++;
+	    if (*argv) {
+		hs = zstrtol(*argv++, NULL, 10);
+		if (*argv)
+		    shs = zstrtol(*argv++, NULL, 10);
+		else
+		    shs = hs;
+		if (*argv) {
+		    zwarnnam("fc", "too many arguments", NULL, 0);
+		    return 1;
+		}
+	    } else {
+		hs = histsiz;
+		shs = savehistsiz;
+	    }
+	}
+	if (!pushhiststack(hf, hs, shs, level))
+	    return 1;
+	if (*hf) {
+	    struct stat st;
+	    if (stat(hf, &st) >= 0 || errno != ENOENT)
+		readhistfile(hf, 1, HFILE_USE_OPTIONS);
+	}
+	return 0;
+}
+if (OPT_ISSET(ops,'P')) {
+	if (*argv) {
+	    zwarnnam("fc", "too many arguments", NULL, 0);
+	    return 1;
+	}
+	return !saveandpophiststack(-1, HFILE_USE_OPTIONS);
+}
+/* with the -m option, the first argument is taken *
+* as a pattern that history lines have to match   */
+if (*argv && OPT_ISSET(ops,'m')) {
+	tokenize(*argv);
+	if (!(pprog = patcompile(*argv++, 0, NULL))) {
+	    zwarnnam(nam, "invalid match pattern", NULL, 0);
+	    return 1;
+	}
+}
+queue_signals();
+if (OPT_ISSET(ops,'R')) {
+	/* read history from a file */
+	readhistfile(*argv, 1, OPT_ISSET(ops,'I') ? HFILE_SKIPOLD : 0);
+	unqueue_signals();
+	return 0;
+}
+if (OPT_ISSET(ops,'W')) {
+	/* write history to a file */
+	savehistfile(*argv, 1, OPT_ISSET(ops,'I') ? HFILE_SKIPOLD : 0);
+	unqueue_signals();
+	return 0;
+}
+if (OPT_ISSET(ops,'A')) {
+	/* append history to a file */
+	savehistfile(*argv, 1, HFILE_APPEND |
+		     (OPT_ISSET(ops,'I') ? HFILE_SKIPOLD : 0));
+	unqueue_signals();
+	return 0;
+}
+/* put foo=bar type arguments into the substitution list */
+while (*argv && equalsplit(*argv, &s)) {
+	Asgment a = (Asgment) zhalloc(sizeof *a);
+	if (!**argv) {
+	    zwarnnam(nam, "invalid replacement pattern: =%s", s, 0);
+	    return 1;
+	}
+	if (!asgf)
+	    asgf = asgl = a;
+	else {
+	    asgl->next = a;
+	    asgl = a;
+	}
+	a->name = *argv;
+	a->value = s;
+	a->next = NULL;
+	argv++;
+}
+/* interpret and check first history line specifier */
+if (*argv) {
+	first = fcgetcomm(*argv);
+	if (first == -1) {
+	    unqueue_signals();
+	    return 1;
+	}
+	argv++;
+}
+/* interpret and check second history line specifier */
+if (*argv) {
+	last = fcgetcomm(*argv);
+	if (last == -1) {
+	    unqueue_signals();
+	    return 1;
+	}
+	argv++;
+}
+/* There is a maximum of two history specifiers.  At least, there *
+* will be as long as the history list is one-dimensional.        */
+if (*argv) {
+	unqueue_signals();
+	zwarnnam("fc", "too many arguments", NULL, 0);
+	return 1;
+}
+/* default values of first and last, and range checking */
+if (last == -1) {
+	if (OPT_ISSET(ops,'l') && first < curhist) {
+	    last = addhistnum(curline.histnum,-1,0);
+	    if (last < firsthist())
+		last = firsthist();
+	}
+	else
+	    last = first;
+}
+if (first == -1) {
+	first = OPT_ISSET(ops,'l')? addhistnum(curline.histnum,-16,0)
+			: addhistnum(curline.histnum,-1,0);
+	if (first < 1)
+	    first = 1;
+	if (last < first)
+	    last = first;
+}
+if (OPT_ISSET(ops,'l')) {
+	/* list the required part of the history */
+	retval = fclist(stdout, ops, first, last, asgf, pprog);
+	unqueue_signals();
+}
+else {
+	/* edit history file, and (if successful) use the result as a new command */
+	int tempfd;
+	FILE *out;
+	char *fil;
+	retval = 1;
+	if ((tempfd = gettempfile(NULL, 1, &fil)) < 0
+	 || ((out = fdopen(tempfd, "w")) == NULL)) {
+	    unqueue_signals();
+	    zwarnnam("fc", "can't open temp file: %e", NULL, errno);
+	} else {
+ops->ind['n'] = 1;  /* No line numbers here. */
+if (!fclist(out, ops, first, last, asgf, pprog)) {
+char *editor;
+if (func == BIN_R)
+editor = "-";
+else if (OPT_HASARG(ops, 'e'))
+editor = OPT_ARG(ops, 'e');
+else
+	{
+	editor = getsparam("FCEDIT");
+#ifdef __SYMBIAN32__
+			if(editor)
+				{
+				zwarnnam("fc", "vi is not supported", NULL, errno);
+				editor=NULL;
+				}
+#endif
+	}
+if (!editor)
+editor = DEFAULT_FCEDIT;
+if (fcedit(editor, fil)) {
+if (stuff(fil))
+zwarnnam("fc", "%e: %s", s, errno);
+else {
+loop(0,1);
+retval = lastval;
+}
+}
+} else
+unqueue_signals();
+	}
+	unlink(fil);
+}
+return retval;
+}
+/* History handling functions: these are called by ZLE, as well as  *
+* the actual builtins.  fcgetcomm() gets a history line, specified *
+* either by number or leading string.  fcsubs() performs a given   *
+* set of simple old=new substitutions on a given command line.     *
+* fclist() outputs a given range of history lines to a text file.  */
+/* get the history event associated with s */
+/**/
+static zlong
+fcgetcomm(char *s)
+{
+zlong cmd;
+/* First try to match a history number.  Negative *
+* numbers indicate reversed numbering.           */
+if ((cmd = atoi(s)) != 0 || *s == '0') {
+	if (cmd < 0)
+	    cmd = addhistnum(curline.histnum,cmd,HIST_FOREIGN);
+	if (cmd < 0)
+	    cmd = 0;
+	return cmd;
+}
+/* not a number, so search by string */
+cmd = hcomsearch(s);
+if (cmd == -1)
+	zwarnnam("fc", "event not found: %s", s, 0);
+return cmd;
+}
+/* Perform old=new substitutions.  Uses the asgment structure from zsh.h, *
+* which is essentially a linked list of string,replacement pairs.       */
+/**/
+static int
+fcsubs(char **sp, struct asgment *sub)
+{
+char *oldstr, *newstr, *oldpos, *newpos, *newmem, *s = *sp;
+int subbed = 0;
+/* loop through the linked list */
+while (sub) {
+	oldstr = sub->name;
+	newstr = sub->value;
+	sub = sub->next;
+	oldpos = s;
+	/* loop over occurences of oldstr in s, replacing them with newstr */
+	while ((newpos = (char *)strstr(oldpos, oldstr))) {
+	    newmem = (char *) zhalloc(1 + (newpos - s)
+				      + strlen(newstr) + strlen(newpos + strlen(oldstr)));
+	    ztrncpy(newmem, s, newpos - s);
+	    strcat(newmem, newstr);
+	    oldpos = newmem + strlen(newmem);
+	    strcat(newmem, newpos + strlen(oldstr));
+	    s = newmem;
+	    subbed = 1;
+	}
+}
+*sp = s;
+return subbed;
+}
+/* Print a series of history events to a file.  The file pointer is     *
+* given by f, and the required range of events by first and last.      *
+* subs is an optional list of foo=bar substitutions to perform on the  *
+* history lines before output.  com is an optional comp structure      *
+* that the history lines are required to match.  n, r, D and d are     *
+* options: n indicates that each line should be numbered.  r indicates *
+* that the lines should be output in reverse order (newest first).     *
+* D indicates that the real time taken by each command should be       *
+* output.  d indicates that the time of execution of each command      *
+* should be output; d>1 means that the date should be output too; d>3  *
+* means that mm/dd/yyyy form should be used for the dates, as opposed  *
+* to dd.mm.yyyy form; d>7 means that yyyy-mm-dd form should be used.   */
+/**/
+static int
+fclist(FILE *f, Options ops, zlong first, zlong last,
+struct asgment *subs, Patprog pprog)
+{
+int fclistdone = 0;
+zlong tmp;
+char *s;
+Histent ent;
+/* reverse range if required */
+if (OPT_ISSET(ops,'r')) {
+	tmp = last;
+	last = first;
+	first = tmp;
+}
+/* suppress "no substitution" warning if no substitution is requested */
+if (!subs)
+	fclistdone = 1;
+ent = gethistent(first, first < last? GETHIST_DOWNWARD : GETHIST_UPWARD);
+if (!ent || (first < last? ent->histnum > last : ent->histnum < last)) {
+	if (first == last) {
+	    char buf[DIGBUFSIZE];
+	    convbase(buf, first, 10);
+	    zwarnnam("fc", "no such event: %s", buf, 0);
+	} else
+	    zwarnnam("fc", "no events in that range", NULL, 0);
+	return 1;
+}
+#ifdef __SYMBIAN32__
+	{
+	Histent up=ent->up;
+if( (strcmp(ent->text, "r")==0) && up &&
+	(strcmp(up->text, "r")==0))
+	    {
+	    zwarnnam("fc", "no history", NULL, 0);
+	    return 1;
+	    }
+	}
+#endif
+for (;;) {
+	s = dupstring(ent->text);
+	/* this if does the pattern matching, if required */
+	if (!pprog || pattry(pprog, s)) {
+	    /* perform substitution */
+	    fclistdone |= fcsubs(&s, subs);
+	    /* do numbering */
+	    if (!OPT_ISSET(ops,'n')) {
+		char buf[DIGBUFSIZE];
+		convbase(buf, ent->histnum, 10);
+		fprintf(f, "%5s%c ", buf,
+			ent->flags & HIST_FOREIGN? '*' : ' ');
+	    }
+	    /* output actual time (and possibly date) of execution of the
+	       command, if required */
+	    if (OPT_ISSET(ops,'d') || OPT_ISSET(ops,'f') ||
+		OPT_ISSET(ops,'E') || OPT_ISSET(ops,'i')) {
+		struct tm *ltm;
+		ltm = localtime(&ent->stim);
+		if (OPT_ISSET(ops,'i')) {
+		    fprintf(f, "%d-%02d-%02d ",
+			    ltm->tm_year + 1900,
+			    ltm->tm_mon + 1, ltm->tm_mday);
+		} else if (OPT_ISSET(ops,'E')) {
+		    fprintf(f, "%d.%d.%d ",
+			    ltm->tm_mday, ltm->tm_mon + 1,
+			    ltm->tm_year + 1900);
+		} else if (OPT_ISSET(ops,'f')) {
+		    fprintf(f, "%d/%d/%d ",
+			    ltm->tm_mon + 1, ltm->tm_mday,
+			    ltm->tm_year + 1900);
+		}
+		fprintf(f, "%02d:%02d  ", ltm->tm_hour, ltm->tm_min);
+	    }
+	    /* display the time taken by the command, if required */
+	    if (OPT_ISSET(ops,'D')) {
+		long diff;
+		diff = (ent->ftim) ? ent->ftim - ent->stim : 0;
+		fprintf(f, "%ld:%02ld  ", diff / 60, diff % 60);
+	    }
+	    /* output the command */
+	    if (f == stdout) {
+		nicezputs(s, f);
+		putc('\n', f);
+	    } else
+		fprintf(f, "%s\n", s);
+	    fflush(f);
+	}
+	/* move on to the next history line, or quit the loop */
+	if (first < last) {
+	    if (!(ent = down_histent(ent)) || ent->histnum > last)
+		break;
+	}
+	else {
+	    if (!(ent = up_histent(ent)) || ent->histnum < last)
+		break;
+	}
+}
+/* final processing */
+if (f != stdout)
+	fclose(f);
+if (!fclistdone) {
+	zwarnnam("fc", "no substitutions performed", NULL, 0);
+	return 1;
+}
+return 0;
+}
+/* edit a history file */
+/**/
+static int
+fcedit(char *ename, char *fn)
+{
+char *s;
+if (!strcmp(ename, "-"))
+	return 1;
+s = tricat(ename, " ", fn);
+execstring(s, 1, 0);
+zsfree(s);
+return lastval;
+}
+/**** parameter builtins ****/
+/* Separate an argument into name=value parts, returning them in an     *
+* asgment structure.  Because the asgment structure used is global,    *
+* only one of these can be active at a time.  The string s gets placed *
+* in this global structure, so it needs to be in permanent memory.     */
+/**/
+static Asgment
+getasg(char *s)
+{
+static struct asgment asg;
+/* sanity check for valid argument */
+if (!s)
+	return NULL;
+/* check if name is empty */
+if (*s == '=') {
+	zerr("bad assignment", NULL, 0);
+	return NULL;
+}
+asg.name = s;
+/* search for `=' */
+for (; *s && *s != '='; s++);
+/* found `=', so return with a value */
+if (*s) {
+	*s = '\0';
+	asg.value = s + 1;
+} else {
+	/* didn't find `=', so we only have a name */
+	asg.value = NULL;
+}
+return &asg;
+}
+/* for new special parameters */
+enum {
+NS_NONE,
+NS_NORMAL,
+NS_SECONDS
+};
+static const struct gsu_scalar tiedarr_gsu =
+{ tiedarrgetfn, tiedarrsetfn, tiedarrunsetfn };
+/* Install a base if we are turning on a numeric option with an argument */
+static int
+typeset_setbase(const char *name, Param pm, Options ops, int on, int always)
+{
+char *arg = NULL;
+if ((on & PM_INTEGER) && OPT_HASARG(ops,'i'))
+	arg = OPT_ARG(ops,'i');
+else if ((on & PM_EFLOAT) && OPT_HASARG(ops,'E'))
+	arg = OPT_ARG(ops,'E');
+else if ((on & PM_FFLOAT) && OPT_HASARG(ops,'F'))
+	arg = OPT_ARG(ops,'F');
+if (arg) {
+	char *eptr;
+	pm->base = (int)zstrtol(arg, &eptr, 10);
+	if (*eptr) {
+	    if (on & PM_INTEGER)
+		zwarnnam(name, "bad base value: %s", arg, 0);
+	    else
+		zwarnnam(name, "bad precision value: %s", arg, 0);
+	    return 1;
+	}
+} else if (always)
+	pm->base = 0;
+return 0;
+}
+/* Install a width if we are turning on a padding option with an argument */
+static int
+typeset_setwidth(const char * name, Param pm, Options ops, int on, int always)
+{
+char *arg = NULL;
+if ((on & PM_LEFT) && OPT_HASARG(ops,'L'))
+	arg = OPT_ARG(ops,'L');
+else if ((on & PM_RIGHT_B) && OPT_HASARG(ops,'R'))
+	arg = OPT_ARG(ops,'R');
+else if ((on & PM_RIGHT_Z) && OPT_HASARG(ops,'Z'))
+	arg = OPT_ARG(ops,'Z');
+if (arg) {
+	char *eptr;
+	pm->width = (int)zstrtol(arg, &eptr, 10);
+	if (*eptr) {
+	    zwarnnam(name, "bad width value: %s", arg, 0);
+	    return 1;
+	}
+} else if (always)
+	pm->width = 0;
+return 0;
+}
+/* function to set a single parameter */
+/**/
+static Param
+typeset_single(char *cname, char *pname, Param pm, UNUSED(int func),
+	       int on, int off, int roff, char *value, Param altpm,
+	       Options ops, int joinchar)
+{
+int usepm, tc, keeplocal = 0, newspecial = NS_NONE, readonly;
+char *subscript;
+/*
+* Do we use the existing pm?  Note that this isn't the end of the
+* story, because if we try and create a new pm at the same
+* locallevel as an unset one we use the pm struct anyway: that's
+* handled in createparam().  Here we just avoid using it for the
+* present tests if it's unset.
+*/
+usepm = pm && !(pm->flags & PM_UNSET);
+/*
+* We need to compare types with an existing pm if special,
+* even if that's unset
+*/
+if (pm && (pm->flags & PM_SPECIAL))
+	usepm = 1;
+/*
+* Don't use an existing param if
+*   - the local level has changed, and
+*   - we are really locallizing the parameter
+*/
+if (usepm && locallevel != pm->level && (on & PM_LOCAL)) {
+	/*
+	 * If the original parameter was special and we're creating
+	 * a new one, we need to keep it special.
+	 *
+	 * The -h (hide) flag prevents an existing special being made
+	 * local.  It can be applied either to the special or in the
+	 * typeset/local statement for the local variable.
+	 */
+	if ((pm->flags & PM_SPECIAL)
+	    && !(on & PM_HIDE) && !(pm->flags & PM_HIDE & ~off))
+	    newspecial = NS_NORMAL;
+	usepm = 0;
+}
+/* attempting a type conversion, or making a tied colonarray? */
+tc = 0;
+if (usepm || newspecial != NS_NONE) {
+	int chflags = ((off & pm->flags) | (on & ~pm->flags)) &
+	    (PM_INTEGER|PM_EFLOAT|PM_FFLOAT|PM_HASHED|
+	     PM_ARRAY|PM_TIED|PM_AUTOLOAD);
+	/* keep the parameter if just switching between floating types */
+	if ((tc = chflags && chflags != (PM_EFLOAT|PM_FFLOAT)))
+	    usepm = 0;
+}
+/*
+* Extra checks if converting the type of a parameter, or if
+* trying to remove readonlyness.  It's dangerous doing either
+* with a special or a parameter which isn't loaded yet (which
+* may be special when it is loaded; we can't tell yet).
+*/
+if ((readonly =
+	 ((usepm || newspecial != NS_NONE) &&
+	  (off & pm->flags & PM_READONLY))) ||
+	tc) {
+	if (pm->flags & PM_SPECIAL) {
+	    int err = 1;
+	    if (!readonly && !strcmp(pname, "SECONDS"))
+	    {
+		/*
+		 * We allow SECONDS to change type between integer
+		 * and floating point.  If we are creating a new
+		 * local copy we check the type here and allow
+		 * a new special to be created with that type.
+		 * We then need to make sure the correct type
+		 * for the special is restored at the end of the scope.
+		 * If we are changing the type of an existing
+		 * parameter, we do the whole thing here.
+		 */
+		if (newspecial != NS_NONE)
+		{
+		    /*
+		     * The first test allows `typeset' to copy the
+		     * existing type.  This is the usual behaviour
+		     * for making special parameters local.
+		     */
+		    if (PM_TYPE(on) == 0 || PM_TYPE(on) == PM_INTEGER ||
+			PM_TYPE(on) == PM_FFLOAT || PM_TYPE(on) == PM_EFLOAT)
+		    {
+			newspecial = NS_SECONDS;
+			err = 0;	/* and continue */
+			tc = 0;	/* but don't do a normal conversion */
+		    }
+		} else if (!setsecondstype(pm, on, off)) {
+		    if (value && !setsparam(pname, ztrdup(value)))
+			return NULL;
+		    return pm;
+		}
+	    }
+	    if (err)
+	    {
+		zerrnam(cname, "%s: can't change type of a special parameter",
+			pname, 0);
+		return NULL;
+	    }
+	} else if (pm->flags & PM_AUTOLOAD) {
+	    zerrnam(cname, "%s: can't change type of autoloaded parameter",
+		    pname, 0);
+	    return NULL;
+	}
+}
+else if (newspecial != NS_NONE && strcmp(pname, "SECONDS") == 0)
+	newspecial = NS_SECONDS;
+/*
+* A parameter will be local if
+* 1. we are re-using an existing local parameter
+*    or
+* 2. we are not using an existing parameter, but
+*   i. there is already a parameter, which will be hidden
+*     or
+*   ii. we are creating a new local parameter
+*/
+if (usepm) {
+	on &= ~PM_LOCAL;
+	if (!on && !roff && !value) {
+	    if (OPT_ISSET(ops,'p'))
+		paramtab->printnode((HashNode)pm, PRINT_TYPESET);
+	    else if (unset(TYPESETSILENT) || OPT_ISSET(ops,'m'))
+		paramtab->printnode((HashNode)pm, PRINT_INCLUDEVALUE);
+	    return pm;
+	}
+	if ((pm->flags & PM_RESTRICTED) && isset(RESTRICTED)) {
+	    zerrnam(cname, "%s: restricted", pname, 0);
+	    return pm;
+	}
+	if ((on & PM_UNIQUE) && !(pm->flags & PM_READONLY & ~off)) {
+	    Param apm;
+	    char **x;
+	    if (PM_TYPE(pm->flags) == PM_ARRAY) {
+		x = (*pm->gsu.a->getfn)(pm);
+		uniqarray(x);
+		if (pm->ename && x)
+		    arrfixenv(pm->ename, x);
+	    } else if (PM_TYPE(pm->flags) == PM_SCALAR && pm->ename &&
+		       (apm =
+			(Param) paramtab->getnode(paramtab, pm->ename))) {
+		x = (*apm->gsu.a->getfn)(apm);
+		uniqarray(x);
+		if (x)
+		    arrfixenv(pm->nam, x);
+	    }
+	}
+	pm->flags = (pm->flags | (on & ~PM_READONLY)) & ~(off | PM_UNSET);
+	if (on & (PM_LEFT | PM_RIGHT_B | PM_RIGHT_Z)) {
+	    if (typeset_setwidth(cname, pm, ops, on, 0))
+		return NULL;
+	}
+	if (on & (PM_INTEGER | PM_EFLOAT | PM_FFLOAT)) {
+	    if (typeset_setbase(cname, pm, ops, on, 0))
+		return NULL;
+	}
+	if (!(pm->flags & (PM_ARRAY|PM_HASHED))) {
+	    if (pm->flags & PM_EXPORTED) {
+		if (!(pm->flags & PM_UNSET) && !pm->env && !value)
+		    addenv(pm, getsparam(pname));
+	    } else if (pm->env && !(pm->flags & PM_HASHELEM))
+		delenv(pm);
+	    if (value && !(pm = setsparam(pname, ztrdup(value))))
+		return NULL;
+	} else if (value) {
+	    zwarnnam(cname, "can't assign new value for array %s", pname, 0);
+	    return NULL;
+	}
+	pm->flags |= (on & PM_READONLY);
+	if (OPT_ISSET(ops,'p'))
+	    paramtab->printnode((HashNode)pm, PRINT_TYPESET);
+	return pm;
+}
+/*
+* We're here either because we're creating a new parameter,
+* or we're adding a parameter at a different local level,
+* or we're converting the type of a parameter.  In the
+* last case only, we need to delete the old parameter.
+*/
+if (tc) {
+	/* Maintain existing readonly/exported status... */
+	on |= ~off & (PM_READONLY|PM_EXPORTED) & pm->flags;
+	/* ...but turn off existing readonly so we can delete it */
+	pm->flags &= ~PM_READONLY;
+	/*
+	 * If we're just changing the type, we should keep the
+	 * variable at the current level of localness.
+	 */
+	keeplocal = pm->level;
+	/*
+	 * Try to carry over a value, but not when changing from,
+	 * to, or between non-scalar types.
+	 */
+	if (!value && !((pm->flags|on) & (PM_ARRAY|PM_HASHED)))
+	    value = dupstring(getsparam(pname));
+	/* pname may point to pm->nam which is about to disappear */
+	pname = dupstring(pname);
+	unsetparam_pm(pm, 0, 1);
+}
+if (newspecial != NS_NONE) {
+	Param tpm, pm2;
+	if ((pm->flags & PM_RESTRICTED) && isset(RESTRICTED)) {
+	    zerrnam(cname, "%s: restricted", pname, 0);
+	    return pm;
+	}
+	/*
+	 * For specials, we keep the same struct but zero everything.
+	 * Maybe it would be easier to create a new struct but copy
+	 * the get/set methods.
+	 */
+	tpm = (Param) zshcalloc(sizeof *tpm);
+	tpm->nam = pm->nam;
+	if (pm->ename &&
+	    (pm2 = (Param) paramtab->getnode(paramtab, pm->ename)) &&
+	    pm2->level == locallevel) {
+	    /* This is getting silly, but anyway:  if one of a path/PATH
+	     * pair has already been made local at the current level, we
+	     * have to make sure that the other one does not have its value
+	     * saved:  since that comes from an internal variable it will
+	     * already reflect the local value, so restoring it on exit
+	     * would be wrong.
+	     *
+	     * This problem is also why we make sure we have a copy
+	     * of the environment entry in tpm->env, rather than relying
+	     * on the restored value to provide it.
+	     */
+	    tpm->flags = pm->flags | PM_NORESTORE;
+	} else {
+	    copyparam(tpm, pm, 1);
+	}
+	tpm->old = pm->old;
+	tpm->level = pm->level;
+	tpm->base = pm->base;
+	tpm->width = pm->width;
+	if (pm->env)
+	    delenv(pm);
+	tpm->env = NULL;
+	pm->old = tpm;
+	/*
+	 * The remaining on/off flags should be harmless to use,
+	 * because we've checked for unpleasant surprises above.
+	 */
+	pm->flags = (PM_TYPE(pm->flags) | on | PM_SPECIAL) & ~off;
+	if (newspecial == NS_SECONDS) {
+	    /* We save off the raw internal value of the SECONDS var */
+	    tpm->u.dval = getrawseconds();
+	    setsecondstype(pm, on, off);
+	}
+	/*
+	 * Final tweak: if we've turned on one of the flags with
+	 * numbers, we should use the appropriate integer.
+	 */
+	if (on & (PM_LEFT|PM_RIGHT_B|PM_RIGHT_Z)) {
+	    if (typeset_setwidth(cname, pm, ops, on, 1))
+		return NULL;
+	}
+	if (on & (PM_INTEGER|PM_EFLOAT|PM_FFLOAT)) {
+	    if (typeset_setbase(cname, pm, ops, on, 1))
+		return NULL;
+	}
+} else if ((subscript = strchr(pname, '['))) {
+	if (on & PM_READONLY) {
+	    zerrnam(cname,
+		    "%s: can't create readonly array elements", pname, 0);
+	    return NULL;
+	} else if (on & PM_LOCAL) {
+	    *subscript = 0;
+	    pm = (Param) (paramtab == realparamtab ?
+			  gethashnode2(paramtab, pname) :
+			  paramtab->getnode(paramtab, pname));
+	    *subscript = '[';
+	    if (!pm || pm->level != locallevel) {
+		zerrnam(cname,
+			"%s: can't create local array elements", pname, 0);
+		return NULL;
+	    }
+	}
+	if (PM_TYPE(on) == PM_SCALAR) {
+	    /*
+	     * This will either complain about bad identifiers, or will set
+	     * a hash element or array slice.  This once worked by accident,
+	     * creating a stray parameter along the way via createparam(),
+	     * now called below in the isident() branch.
+	     */
+	    if (!(pm = setsparam(pname, ztrdup(value ? value : ""))))
+		return NULL;
+	    value = NULL;
+	    keeplocal = 0;
+	    on = pm->flags;
+	} else {
+	    zerrnam(cname,
+		    "%s: array elements must be scalar", pname, 0);
+	    return NULL;
+	}
+} else if (isident(pname) && !idigit(*pname)) {
+	/*
+	 * Create a new node for a parameter with the flags in `on' minus the
+	 * readonly flag
+	 */
+	pm = createparam(pname, on & ~PM_READONLY);
+	DPUTS(!pm, "BUG: parameter not created");
+	if (on & (PM_LEFT | PM_RIGHT_B | PM_RIGHT_Z)) {
+	    if (typeset_setwidth(cname, pm, ops, on, 0))
+		return NULL;
+	}
+	if (on & (PM_INTEGER | PM_EFLOAT | PM_FFLOAT)) {
+	    if (typeset_setbase(cname, pm, ops, on, 0))
+		return NULL;
+	}
+} else {
+	if (isident(pname))
+	    zerrnam(cname, "not valid in this context: %s", pname, 0);
+	else
+	    zerrnam(cname, "not an identifier: %s", pname, 0);
+	return NULL;
+}
+if (altpm && PM_TYPE(pm->flags) == PM_SCALAR) {
+	/*
+	 * It seems safer to set this here than in createparam(),
+	 * to make sure we only ever use the colonarr functions
+	 * when u.data is correctly set.
+	 */
+	struct tieddata *tdp = (struct tieddata *)
+	    zalloc(sizeof(struct tieddata));
+	if (!tdp)
+	    return NULL;
+	tdp->joinchar = joinchar;
+	tdp->arrptr = &altpm->u.arr;
+	pm->gsu.s = &tiedarr_gsu;
+	pm->u.data = tdp;
+}
+if (keeplocal)
+	pm->level = keeplocal;
+else if (on & PM_LOCAL)
+	pm->level = locallevel;
+if (value && !(pm->flags & (PM_ARRAY|PM_HASHED))) {
+	Param ipm = pm;
+	if (!(pm = setsparam(pname, ztrdup(value))))
+	    return NULL;
+	if (pm != ipm) {
+	    DPUTS(ipm->flags != pm->flags,
+		  "BUG: parameter recreated with wrong flags");
+	    unsetparam_pm(ipm, 0, 1);
+	}
+} else if (newspecial != NS_NONE && !(pm->old->flags & PM_NORESTORE)) {
+	/*
+	 * We need to use the special setting function to re-initialise
+	 * the special parameter to empty.
+	 */
+	switch (PM_TYPE(pm->flags)) {
+	case PM_SCALAR:
+	    pm->gsu.s->setfn(pm, ztrdup(""));
+	    break;
+	case PM_INTEGER:
+	    pm->gsu.i->setfn(pm, 0);
+	    break;
+	case PM_EFLOAT:
+	case PM_FFLOAT:
+	    pm->gsu.f->setfn(pm, 0.0);
+	    break;
+	case PM_ARRAY:
+	    pm->gsu.a->setfn(pm, mkarray(NULL));
+	    break;
+	case PM_HASHED:
+	    pm->gsu.h->setfn(pm, newparamtable(17, pm->nam));
+	    break;
+	}
+}
+pm->flags |= (on & PM_READONLY);
+if (value && (pm->flags & (PM_ARRAY|PM_HASHED))) {
+	zerrnam(cname, "%s: can't assign initial value for array", pname, 0);
+	/* the only safe thing to do here seems to be unset the param */
+	unsetparam_pm(pm, 0, 1);
+	return NULL;
+}
+if (OPT_ISSET(ops,'p'))
+	paramtab->printnode((HashNode)pm, PRINT_TYPESET);
+return pm;
+}
+/* declare, export, integer, local, readonly, typeset */
+/**/
+int
+bin_typeset(char *name, char **argv, Options ops, int func)
+{
+Param pm;
+Asgment asg;
+Patprog pprog;
+char *optstr = TYPESET_OPTSTR;
+int on = 0, off = 0, roff, bit = PM_ARRAY;
+int i;
+int returnval = 0, printflags = 0;
+/* hash -f is really the builtin `functions' */
+if (OPT_ISSET(ops,'f'))
+	return bin_functions(name, argv, ops, func);
+/* Translate the options into PM_* flags.   *
+* Unfortunately, this depends on the order *
+* these flags are defined in zsh.h         */
+for (; *optstr; optstr++, bit <<= 1)
+{
+	int optval = STOUC(*optstr);
+	if (OPT_MINUS(ops,optval))
+	    on |= bit;
+	else if (OPT_PLUS(ops,optval))
+	    off |= bit;
+}
+roff = off;
+/* Sanity checks on the options.  Remove conflicting options. */
+if (on & PM_FFLOAT) {
+	off |= PM_UPPER | PM_ARRAY | PM_HASHED | PM_INTEGER | PM_EFLOAT;
+	/* Allow `float -F' to work even though float sets -E by default */
+	on &= ~PM_EFLOAT;
+}
+if (on & PM_EFLOAT)
+	off |= PM_UPPER | PM_ARRAY | PM_HASHED | PM_INTEGER | PM_FFLOAT;
+if (on & PM_INTEGER)
+	off |= PM_UPPER | PM_ARRAY | PM_HASHED | PM_EFLOAT | PM_FFLOAT;
+/*
+* Allowing -Z with -L is a feature: left justify, suppressing
+* leading zeroes.
+*/
+if (on & (PM_LEFT|PM_RIGHT_Z))
+	off |= PM_RIGHT_B;
+if (on & PM_RIGHT_B)
+	off |= PM_LEFT | PM_RIGHT_Z;
+if (on & PM_UPPER)
+	off |= PM_LOWER;
+if (on & PM_LOWER)
+	off |= PM_UPPER;
+if (on & PM_HASHED)
+	off |= PM_ARRAY;
+if (on & PM_TIED)
+	off |= PM_INTEGER | PM_EFLOAT | PM_FFLOAT | PM_ARRAY | PM_HASHED;
+on &= ~off;
+queue_signals();
+/* Given no arguments, list whatever the options specify. */
+if (OPT_ISSET(ops,'p'))
+	printflags |= PRINT_TYPESET;
+if (!*argv) {
+	if (!OPT_ISSET(ops,'p')) {
+	    if (!(on|roff))
+		printflags |= PRINT_TYPE;
+	    if (roff || OPT_ISSET(ops,'+'))
+		printflags |= PRINT_NAMEONLY;
+	}
+	scanhashtable(paramtab, 1, on|roff, 0, paramtab->printnode, printflags);
+	unqueue_signals();
+	return 0;
+}
+if (!(OPT_ISSET(ops,'g') || OPT_ISSET(ops,'x') || OPT_ISSET(ops,'m')) ||
+	OPT_PLUS(ops,'g') || *name == 'l' ||
+	(!isset(GLOBALEXPORT) && !OPT_ISSET(ops,'g')))
+	on |= PM_LOCAL;
+if (on & PM_TIED) {
+	Param apm;
+	struct asgment asg0;
+	char *oldval = NULL;
+	int joinchar;
+	if (OPT_ISSET(ops,'m')) {
+	    zwarnnam(name, "incompatible options for -T", NULL, 0);
+	    unqueue_signals();
+	    return 1;
+	}
+	on &= ~off;
+	if (!argv[1] || (argv[2] && argv[3])) {
+	    zwarnnam(name, "-T requires names of scalar and array", NULL, 0);
+	    unqueue_signals();
+	    return 1;
+	}
+	/*
+	 * Third argument, if given, is character used to join
+	 * the elements of the array in the scalar.
+	 */
+	if (!argv[2])
+	    joinchar = ':';
+	else if (!*argv[2])
+	    joinchar = 0;
+	else if (*argv[2] == Meta)
+	    joinchar = argv[2][1] ^ 32;
+	else
+	    joinchar = *argv[2];
+	if (!(asg = getasg(argv[0]))) {
+	    unqueue_signals();
+	    return 1;
+	}
+	asg0 = *asg;
+	if (!(asg = getasg(argv[1]))) {
+	    unqueue_signals();
+	    return 1;
+	}
+	if (!strcmp(asg0.name, asg->name)) {
+	    unqueue_signals();
+	    zerrnam(name, "can't tie a variable to itself", NULL, 0);
+	    return 1;
+	}
+	if (strchr(asg0.name, '[') || strchr(asg->name, '[')) {
+	    unqueue_signals();
+	    zerrnam(name, "can't tie array elements", NULL, 0);
+	    return 1;
+	}
+	/*
+	 * Keep the old value of the scalar.  We need to do this
+	 * here as if it is already tied to the same array it
+	 * will be unset when we retie the array.  This is all
+	 * so that typeset -T is idempotent.
+	 *
+	 * We also need to remember here whether the damn thing is
+	 * exported and pass that along.  Isn't the world complicated?
+	 */
+	if ((pm = (Param) paramtab->getnode(paramtab, asg0.name))
+	    && !(pm->flags & PM_UNSET)
+	    && (locallevel == pm->level || !(on & PM_LOCAL))) {
+	    if (!asg0.value && !(PM_TYPE(pm->flags) & (PM_ARRAY|PM_HASHED)))
+		oldval = ztrdup(getsparam(asg0.name));
+	    on |= (pm->flags & PM_EXPORTED);
+	}
+	/*
+	 * Create the tied array; this is normal except that
+	 * it has the PM_TIED flag set.  Do it first because
+	 * we need the address.
+	 */
+	if (!(apm=typeset_single(name, asg->name,
+				 (Param)paramtab->getnode(paramtab,
+							  asg->name),
+				 func, (on | PM_ARRAY) & ~PM_EXPORTED,
+				 off, roff, asg->value, NULL, ops, 0))) {
+	    unqueue_signals();
+	    return 1;
+	}
+	/*
+	 * Create the tied colonarray.  We make it as a normal scalar
+	 * and fix up the oddities later.
+	 */
+	if (!(pm=typeset_single(name, asg0.name,
+				(Param)paramtab->getnode(paramtab,
+							 asg0.name),
+				func, on, off, roff, asg0.value, apm,
+				ops, joinchar))) {
+	    if (oldval)
+		zsfree(oldval);
+	    unsetparam_pm(apm, 1, 1);
+	    unqueue_signals();
+	    return 1;
+	}
+	/*
+	 * pm->ename is only deleted when the struct is, so
+	 * we need to free it here if it already exists.
+	 */
+	if (pm->ename)
+	    zsfree(pm->ename);
+	pm->ename = ztrdup(asg->name);
+	if (apm->ename)
+	    zsfree(apm->ename);
+	apm->ename = ztrdup(asg0.name);
+	if (oldval)
+	    setsparam(asg0.name, oldval);
+	unqueue_signals();
+	return 0;
+}
+if (off & PM_TIED) {
+	zerrnam(name, "use unset to remove tied variables", NULL, 0);
+	return 1;
+}
+/* With the -m option, treat arguments as glob patterns */
+if (OPT_ISSET(ops,'m')) {
+	if (!OPT_ISSET(ops,'p')) {
+	    if (!(on|roff))
+		printflags |= PRINT_TYPE;
+	    if (!on)
+		printflags |= PRINT_NAMEONLY;
+	}
+	while ((asg = getasg(*argv++))) {
+	    LinkList pmlist = newlinklist();
+	    LinkNode pmnode;
+	    tokenize(asg->name);   /* expand argument */
+	    if (!(pprog = patcompile(asg->name, 0, NULL))) {
+		untokenize(asg->name);
+		zwarnnam(name, "bad pattern : %s", argv[-1], 0);
+		returnval = 1;
+		continue;
+	    }
+	    if (OPT_PLUS(ops,'m') && !asg->value) {
+		scanmatchtable(paramtab, pprog, on|roff, 0,
+			       paramtab->printnode, printflags);
+		continue;
+	    }
+	    /*
+	     * Search through the parameter table and change all parameters
+	     * matching the glob pattern to have these flags and/or value.
+	     * Bad news:  if the parameter gets altered, e.g. by
+	     * a type conversion, then paramtab can be shifted around,
+	     * so we need to store the parameters to alter on a separate
+	     * list for later use.
+	     */
+	    for (i = 0; i < paramtab->hsize; i++) {
+		for (pm = (Param) paramtab->nodes[i]; pm;
+		     pm = (Param) pm->next) {
+		    if (((pm->flags & PM_RESTRICTED) && isset(RESTRICTED)) ||
+			(pm->flags & PM_UNSET))
+			continue;
+		    if (pattry(pprog, pm->nam))
+			addlinknode(pmlist, pm);
+		}
+	    }
+	    for (pmnode = firstnode(pmlist); pmnode; incnode(pmnode)) {
+		pm = (Param) getdata(pmnode);
+		if (!typeset_single(name, pm->nam, pm, func, on, off, roff,
+				    asg->value, NULL, ops, 0))
+		    returnval = 1;
+	    }
+	}
+	unqueue_signals();
+	return returnval;
+}
+/* Take arguments literally.  Don't glob */
+while ((asg = getasg(*argv++))) {
+	if (!typeset_single(name, asg->name,
+			    (Param) (paramtab == realparamtab ?
+				     gethashnode2(paramtab, asg->name) :
+				     paramtab->getnode(paramtab, asg->name)),
+			    func, on, off, roff, asg->value, NULL,
+			    ops, 0))
+	    returnval = 1;
+}
+unqueue_signals();
+return returnval;
+}
+/* Helper for bin_functions() when run as "autoload -X" */
+/**/
+int
+eval_autoload(Shfunc shf, char *name, Options ops, int func)
+{
+if (!(shf->flags & PM_UNDEFINED))
+	return 1;
+if (shf->funcdef) {
+	freeeprog(shf->funcdef);
+	shf->funcdef = &dummy_eprog;
+}
+if (OPT_MINUS(ops,'X')) {
+	char *fargv[3];
+	fargv[0] = name;
+	fargv[1] = "\"$@\"";
+	fargv[2] = 0;
+	shf->funcdef = mkautofn(shf);
+	return bin_eval(name, fargv, ops, func);
+}
+return !loadautofn(shf, (OPT_ISSET(ops,'k') ? 2 :
+			     (OPT_ISSET(ops,'z') ? 0 : 1)), 1);
+}
+/* Display or change the attributes of shell functions.   *
+* If called as autoload, it will define a new autoloaded *
+* (undefined) shell function.                            */
+/**/
+int
+bin_functions(char *name, char **argv, Options ops, int func)
+{
+Patprog pprog;
+Shfunc shf;
+int i, returnval = 0;
+int on = 0, off = 0, pflags = 0;
+/* Do we have any flags defined? */
+if (OPT_PLUS(ops,'u'))
+	off |= PM_UNDEFINED;
+else if (OPT_MINUS(ops,'u') || OPT_ISSET(ops,'X'))
+	on |= PM_UNDEFINED;
+if (OPT_MINUS(ops,'U'))
+	on |= PM_UNALIASED|PM_UNDEFINED;
+else if (OPT_PLUS(ops,'U'))
+	off |= PM_UNALIASED;
+if (OPT_MINUS(ops,'t'))
+	on |= PM_TAGGED;
+else if (OPT_PLUS(ops,'t'))
+	off |= PM_TAGGED;
+if (OPT_MINUS(ops,'z')) {
+	on |= PM_ZSHSTORED;
+	off |= PM_KSHSTORED;
+} else if (OPT_PLUS(ops,'z'))
+	off |= PM_ZSHSTORED;
+if (OPT_MINUS(ops,'k')) {
+	on |= PM_KSHSTORED;
+	off |= PM_ZSHSTORED;
+} else if (OPT_PLUS(ops,'k'))
+	off |= PM_KSHSTORED;
+if ((off & PM_UNDEFINED) || (OPT_ISSET(ops,'k') && OPT_ISSET(ops,'z')) ||
+	(OPT_MINUS(ops,'X') && (OPT_ISSET(ops,'m') || *argv || !scriptname))) {
+	zwarnnam(name, "invalid option(s)", NULL, 0);
+	return 1;
+}
+if (OPT_PLUS(ops,'f') || OPT_ISSET(ops,'+'))
+	pflags |= PRINT_NAMEONLY;
+/* If no arguments given, we will print functions.  If flags *
+* are given, we will print only functions containing these  *
+* flags, else we'll print them all.                         */
+if (!*argv) {
+	int ret = 0;
+	queue_signals();
+	if (OPT_MINUS(ops,'X')) {
+	    if ((shf = (Shfunc) shfunctab->getnode(shfunctab, scriptname))) {
+		DPUTS(!shf->funcdef,
+		      "BUG: Calling autoload from empty function");
+	    } else {
+		shf = (Shfunc) zshcalloc(sizeof *shf);
+		shfunctab->addnode(shfunctab, ztrdup(scriptname), shf);
+	    }
+	    shf->flags = on;
+	    ret = eval_autoload(shf, scriptname, ops, func);
+	} else {
+	    if (OPT_ISSET(ops,'U') && !OPT_ISSET(ops,'u'))
+		on &= ~PM_UNDEFINED;
+	    scanhashtable(shfunctab, 1, on|off, DISABLED, shfunctab->printnode,
+			  pflags);
+	}
+	unqueue_signals();
+	return ret;
+}
+/* With the -m option, treat arguments as glob patterns */
+if (OPT_ISSET(ops,'m')) {
+	on &= ~PM_UNDEFINED;
+	for (; *argv; argv++) {
+	    /* expand argument */
+	    tokenize(*argv);
+	    if ((pprog = patcompile(*argv, PAT_STATIC, 0))) {
+		/* with no options, just print all functions matching the glob pattern */
+		queue_signals();
+		if (!(on|off)) {
+		    scanmatchtable(shfunctab, pprog, 0, DISABLED,
+				   shfunctab->printnode, pflags);
+		} else {
+		    /* apply the options to all functions matching the glob pattern */
+		    for (i = 0; i < shfunctab->hsize; i++) {
+			for (shf = (Shfunc) shfunctab->nodes[i]; shf;
+			     shf = (Shfunc) shf->next)
+			    if (pattry(pprog, shf->nam) &&
+				!(shf->flags & DISABLED)) {
+				shf->flags = (shf->flags |
+					      (on & ~PM_UNDEFINED)) & ~off;
+				if (OPT_ISSET(ops,'X') &&
+				    eval_autoload(shf, shf->nam, ops, func)) {
+				    returnval = 1;
+				}
+			    }
+		    }
+		}
+		unqueue_signals();
+	    } else {
+		untokenize(*argv);
+		zwarnnam(name, "bad pattern : %s", *argv, 0);
+		returnval = 1;
+	    }
+	}
+	return returnval;
+}
+/* Take the arguments literally -- do not glob */
+queue_signals();
+for (; *argv; argv++) {
+#ifndef __SYMBIAN32__
+	if (OPT_ISSET(ops,'w'))
+	    returnval = dump_autoload(name, *argv, on, ops, func);
+	else
+#endif
+	 if ((shf = (Shfunc) shfunctab->getnode(shfunctab, *argv))) {
+	    /* if any flag was given */
+	    if (on|off) {
+		/* turn on/off the given flags */
+		shf->flags = (shf->flags | (on & ~PM_UNDEFINED)) & ~off;
+		if (OPT_ISSET(ops,'X') &&
+		    eval_autoload(shf, shf->nam, ops, func))
+		    returnval = 1;
+	    } else
+		/* no flags, so just print */
+		shfunctab->printnode((HashNode) shf, pflags);
+	} else if (on & PM_UNDEFINED) {
+	    int signum = -1, ok = 1;
+	    if (!strncmp(*argv, "TRAP", 4) &&
+		(signum = getsignum(*argv + 4)) != -1) {
+		/*
+		 * Because of the possibility of alternative names,
+		 * we must remove the trap explicitly.
+		 */
+		removetrapnode(signum);
+	    }
+	    /* Add a new undefined (autoloaded) function to the *
+	     * hash table with the corresponding flags set.     */
+	    shf = (Shfunc) zshcalloc(sizeof *shf);
+	    shf->flags = on;
+	    shf->funcdef = mkautofn(shf);
+	    shfunctab->addnode(shfunctab, ztrdup(*argv), shf);
+	    if (signum != -1) {
+		if (settrap(signum, shf->funcdef)) {
+		    shfunctab->removenode(shfunctab, *argv);
+		    shfunctab->freenode((HashNode)shf);
+		    returnval = 1;
+		    ok = 0;
+		}
+		else
+		    sigtrapped[signum] |= ZSIG_FUNC;
+	    }
+	    if (ok && OPT_ISSET(ops,'X') &&
+		eval_autoload(shf, shf->nam, ops, func))
+		returnval = 1;
+	} else
+	    returnval = 1;
+}
+unqueue_signals();
+return returnval;
+}
+/**/
+Eprog
+mkautofn(Shfunc shf)
+{
+Eprog p;
+p = (Eprog) zalloc(sizeof(*p));
+p->len = 5 * sizeof(wordcode);
+p->prog = (Wordcode) zalloc(p->len);
+p->strs = NULL;
+p->shf = shf;
+p->npats = 0;
+p->nref = 1; /* allocated from permanent storage */
+p->pats = (Patprog *) p->prog;
+p->flags = EF_REAL;
+p->dump = NULL;
+p->prog[0] = WCB_LIST((Z_SYNC | Z_END), 0);
+p->prog[1] = WCB_SUBLIST(WC_SUBLIST_END, 0, 3);
+p->prog[2] = WCB_PIPE(WC_PIPE_END, 0);
+p->prog[3] = WCB_AUTOFN();
+p->prog[4] = WCB_END();
+return p;
+}
+/* unset: unset parameters */
+/**/
+int
+bin_unset(char *name, char **argv, Options ops, int func)
+{
+Param pm, next;
+Patprog pprog;
+char *s;
+int match = 0, returnval = 0;
+int i;
+/* unset -f is the same as unfunction */
+if (OPT_ISSET(ops,'f'))
+	return bin_unhash(name, argv, ops, func);
+/* with -m option, treat arguments as glob patterns */
+if (OPT_ISSET(ops,'m')) {
+	while ((s = *argv++)) {
+	    /* expand */
+	    tokenize(s);
+	    if ((pprog = patcompile(s, PAT_STATIC, NULL))) {
+		/* Go through the parameter table, and unset any matches */
+		queue_signals();
+		for (i = 0; i < paramtab->hsize; i++) {
+		    for (pm = (Param) paramtab->nodes[i]; pm; pm = next) {
+			/* record pointer to next, since we may free this one */
+			next = (Param) pm->next;
+			if ((!(pm->flags & PM_RESTRICTED) ||
+			     unset(RESTRICTED)) &&
+			    pattry(pprog, pm->nam)) {
+			    unsetparam_pm(pm, 0, 1);
+			    match++;
+			}
+		    }
+		}
+		unqueue_signals();
+	    } else {
+		untokenize(s);
+		zwarnnam(name, "bad pattern : %s", s, 0);
+		returnval = 1;
+	    }
+	}
+	/* If we didn't match anything, we return 1. */
+	if (!match)
+	    returnval = 1;
+	return returnval;
+}
+/* do not glob -- unset the given parameter */
+queue_signals();
+while ((s = *argv++)) {
+	char *ss = strchr(s, '[');
+	char *sse = ss;
+	if (ss) {
+	    if (skipparens('[', ']', &sse) || *sse) {
+		zerrnam(name, "%s: invalid parameter name", s, 0);
+		returnval = 1;
+		continue;
+	    }
+	    *ss = 0;
+	}
+	pm = (Param) (paramtab == realparamtab ?
+		      gethashnode2(paramtab, s) :
+		      paramtab->getnode(paramtab, s));
+	if (!pm)
+	    returnval = 1;
+	else if ((pm->flags & PM_RESTRICTED) && isset(RESTRICTED)) {
+	    zerrnam(name, "%s: restricted", pm->nam, 0);
+	    returnval = 1;
+	} else if (ss) {
+	    if (PM_TYPE(pm->flags) == PM_HASHED) {
+		HashTable tht = paramtab;
+		if ((paramtab = pm->gsu.h->getfn(pm))) {
+		    *--sse = 0;
+		    unsetparam(ss+1);
+		    *sse = ']';
+		}
+		paramtab = tht;
+	    } else {
+		zerrnam(name, "%s: invalid element for unset", s, 0);
+		returnval = 1;
+	    }
+	} else {
+	    if (unsetparam_pm(pm, 0, 1))
+		returnval = 1;
+	}
+	if (ss)
+	    *ss = '[';
+}
+unqueue_signals();
+return returnval;
+}
+/* type, whence, which, command */
+/**/
+int
+bin_whence(char *nam, char **argv, Options ops, int func)
+{
+HashNode hn;
+Patprog pprog;
+int returnval = 0;
+int printflags = 0;
+int aliasflags;
+int csh, all, v, wd;
+int informed;
+char *cnam;
+/* Check some option information */
+csh = OPT_ISSET(ops,'c');
+v   = OPT_ISSET(ops,'v');
+all = OPT_ISSET(ops,'a');
+wd  = OPT_ISSET(ops,'w');
+if (OPT_ISSET(ops,'w'))
+	printflags |= PRINT_WHENCE_WORD;
+else if (OPT_ISSET(ops,'c'))
+	printflags |= PRINT_WHENCE_CSH;
+else if (OPT_ISSET(ops,'v'))
+	printflags |= PRINT_WHENCE_VERBOSE;
+else
+	printflags |= PRINT_WHENCE_SIMPLE;
+if (OPT_ISSET(ops,'f'))
+	printflags |= PRINT_WHENCE_FUNCDEF;
+if (func == BIN_COMMAND)
+	if (OPT_ISSET(ops,'V')) {
+	    printflags = aliasflags = PRINT_WHENCE_VERBOSE;
+	    v = 1;
+	} else {
+	    aliasflags = PRINT_LIST;
+	    printflags = PRINT_WHENCE_SIMPLE;
+	    v = 0;
+	}
+else
+	aliasflags = printflags;
+/* With -m option -- treat arguments as a glob patterns */
+if (OPT_ISSET(ops,'m')) {
+	for (; *argv; argv++) {
+	    /* parse the pattern */
+	    tokenize(*argv);
+	    if (!(pprog = patcompile(*argv, PAT_STATIC, NULL))) {
+		untokenize(*argv);
+		zwarnnam(nam, "bad pattern : %s", *argv, 0);
+		returnval = 1;
+		continue;
+	    }
+	    queue_signals();
+	    if (!OPT_ISSET(ops,'p')) {
+		/* -p option is for path search only.    *
+		 * We're not using it, so search for ... */
+		/* aliases ... */
+		scanmatchtable(aliastab, pprog, 0, DISABLED,
+			       aliastab->printnode, printflags);
+		/* and reserved words ... */
+		scanmatchtable(reswdtab, pprog, 0, DISABLED,
+			       reswdtab->printnode, printflags);
+		/* and shell functions... */
+		scanmatchtable(shfunctab, pprog, 0, DISABLED,
+			       shfunctab->printnode, printflags);
+		/* and builtins. */
+		scanmatchtable(builtintab, pprog, 0, DISABLED,
+			       builtintab->printnode, printflags);
+	    }
+	    /* Done search for `internal' commands, if the -p option *
+	     * was not used.  Now search the path.                   */
+	    cmdnamtab->filltable(cmdnamtab);
+	    scanmatchtable(cmdnamtab, pprog, 0, 0,
+			   cmdnamtab->printnode, printflags);
+	    unqueue_signals();
+	}
+	return returnval;
+}
+/* Take arguments literally -- do not glob */
+queue_signals();
+for (; *argv; argv++) {
+	informed = 0;
+	if (!OPT_ISSET(ops,'p')) {
+	    char *suf;
+	    /* Look for alias */
+	    if ((hn = aliastab->getnode(aliastab, *argv))) {
+		aliastab->printnode(hn, aliasflags);
+		if (!all)
+		    continue;
+		informed = 1;
+	    }
+	    /* Look for suffix alias */
+	    if ((suf = strrchr(*argv, '.')) && suf[1] &&
+		suf > *argv && suf[-1] != Meta &&
+		(hn = sufaliastab->getnode(sufaliastab, suf+1))) {
+		sufaliastab->printnode(hn, printflags);
+		if (!all)
+		    continue;
+		informed = 1;
+	    }
+	    /* Look for reserved word */
+	    if ((hn = reswdtab->getnode(reswdtab, *argv))) {
+		reswdtab->printnode(hn, printflags);
+		if (!all)
+		    continue;
+		informed = 1;
+	    }
+	    /* Look for shell function */
+	    if ((hn = shfunctab->getnode(shfunctab, *argv))) {
+		shfunctab->printnode(hn, printflags);
+		if (!all)
+		    continue;
+		informed = 1;
+	    }
+	    /* Look for builtin command */
+	    if ((hn = builtintab->getnode(builtintab, *argv))) {
+		builtintab->printnode(hn, printflags);
+		if (!all)
+		    continue;
+		informed = 1;
+	    }
+	    /* Look for commands that have been added to the *
+	     * cmdnamtab with the builtin `hash foo=bar'.    */
+	    if ((hn = cmdnamtab->getnode(cmdnamtab, *argv)) && (hn->flags & HASHED)) {
+		cmdnamtab->printnode(hn, printflags);
+		if (!all)
+		    continue;
+		informed = 1;
+	    }
+	}
+	/* Option -a is to search the entire path, *
+	 * rather than just looking for one match. */
+	if (all) {
+	    char **pp, *buf;
+	    pushheap();
+	    for (pp = path; *pp; pp++) {
+		if (**pp) {
+		    buf = zhtricat(*pp, "/", *argv);
+		} else buf = ztrdup(*argv);
+		if (iscom(buf)) {
+		    if (wd) {
+			printf("%s: command\n", *argv);
+		    } else {
+			if (v && !csh)
+			    zputs(*argv, stdout), fputs(" is ", stdout);
+			zputs(buf, stdout);
+			if (OPT_ISSET(ops,'s'))
+			    print_if_link(buf);
+			fputc('\n', stdout);
+		    }
+		    informed = 1;
+		}
+	    }
+	    if (!informed && (wd || v || csh)) {
+		zputs(*argv, stdout);
+		puts(wd ? ": none" : " not found");
+		returnval = 1;
+	    }
+	    popheap();
+	} else if ((cnam = findcmd(*argv, 1))) {
+	    /* Found external command. */
+	    if (wd) {
+		printf("%s: command\n", *argv);
+	    }else {
+		if (v && !csh)
+		    zputs(*argv, stdout), fputs(" is ", stdout);
+		zputs(cnam, stdout);
+		if (OPT_ISSET(ops,'s'))
+		    print_if_link(cnam);
+		fputc('\n', stdout);
+	    }
+	}else {
+	    /* Not found at all. */
+	    if (v || csh || wd)
+	   zputs(*argv, stdout), puts(wd ? ": not builtin command" : " not found");
+	    returnval = 1;
+	}
+}
+unqueue_signals();
+return returnval;
+}
+#ifndef __SYMBIAN32__
+/**** command & named directory hash table builtins ****/
+/*****************************************************************
+* hash -- explicitly hash a command.                            *
+* 1) Given no arguments, list the hash table.                   *
+* 2) The -m option prints out commands in the hash table that   *
+*    match a given glob pattern.                                *
+* 3) The -f option causes the entire path to be added to the    *
+*    hash table (cannot be combined with any arguments).        *
+* 4) The -r option causes the entire hash table to be discarded *
+*    (cannot be combined with any arguments).                   *
+* 5) Given argument of the form foo=bar, add element to command *
+*    hash table, so that when `foo' is entered, then `bar' is   *
+*    executed.                                                  *
+* 6) Given arguments not of the previous form, add it to the    *
+*    command hash table as if it were being executed.           *
+* 7) The -d option causes analogous things to be done using     *
+*    the named directory hash table.                            *
+*****************************************************************/
+/**/
+int
+bin_hash(char *name, char **argv, Options ops, UNUSED(int func))
+{
+HashTable ht;
+Patprog pprog;
+Asgment asg;
+int returnval = 0;
+int printflags = 0;
+if (OPT_ISSET(ops,'d'))
+	ht = nameddirtab;
+else
+	ht = cmdnamtab;
+if (OPT_ISSET(ops,'r') || OPT_ISSET(ops,'f')) {
+	/* -f and -r can't be used with any arguments */
+	if (*argv) {
+	    zwarnnam("hash", "too many arguments", NULL, 0);
+	    return 1;
+	}
+	/* empty the hash table */
+	if (OPT_ISSET(ops,'r'))
+	    ht->emptytable(ht);
+	/* fill the hash table in a standard way */
+	if (OPT_ISSET(ops,'f'))
+	    ht->filltable(ht);
+	return 0;
+}
+if (OPT_ISSET(ops,'L')) printflags |= PRINT_LIST;
+/* Given no arguments, display current hash table. */
+if (!*argv) {
+	queue_signals();
+	scanhashtable(ht, 1, 0, 0, ht->printnode, printflags);
+	unqueue_signals();
+	return 0;
+}
+queue_signals();
+while (*argv) {
+	void *hn;
+	if (OPT_ISSET(ops,'m')) {
+	    /* with the -m option, treat the argument as a glob pattern */
+	    tokenize(*argv);  /* expand */
+	    if ((pprog = patcompile(*argv, PAT_STATIC, NULL))) {
+		/* display matching hash table elements */
+		scanmatchtable(ht, pprog, 0, 0, ht->printnode, printflags);
+	    } else {
+		untokenize(*argv);
+		zwarnnam(name, "bad pattern : %s", *argv, 0);
+		returnval = 1;
+	    }
+	} else if ((asg = getasg(*argv)) && asg->value) {
+	    if(isset(RESTRICTED)) {
+		zwarnnam(name, "restricted: %s", asg->value, 0);
+		returnval = 1;
+	    } else {
+		/* The argument is of the form foo=bar, *
+		 * so define an entry for the table.    */
+		if(OPT_ISSET(ops,'d')) {
+		    Nameddir nd = hn = zshcalloc(sizeof *nd);
+		    nd->flags = 0;
+		    nd->dir = ztrdup(asg->value);
+		} else {
+		    Cmdnam cn = hn = zshcalloc(sizeof *cn);
+		    cn->flags = HASHED;
+		    cn->u.cmd = ztrdup(asg->value);
+		}
+		ht->addnode(ht, ztrdup(asg->name), hn);
+		if(OPT_ISSET(ops,'v'))
+		    ht->printnode(hn, 0);
+	    }
+	} else if (!(hn = ht->getnode2(ht, asg->name))) {
+	    /* With no `=value' part to the argument, *
+	     * work out what it ought to be.          */
+	    if(OPT_ISSET(ops,'d')) {
+		if(!getnameddir(asg->name)) {
+		    zwarnnam(name, "no such directory name: %s", asg->name, 0);
+		    returnval = 1;
+		}
+	    } else {
+		if (!hashcmd(asg->name, path)) {
+		    zwarnnam(name, "no such command: %s", asg->name, 0);
+		    returnval = 1;
+		}
+	    }
+	    if(OPT_ISSET(ops,'v') && (hn = ht->getnode2(ht, asg->name)))
+		ht->printnode(hn, 0);
+	} else if(OPT_ISSET(ops,'v'))
+	    ht->printnode(hn, 0);
+	argv++;
+}
+unqueue_signals();
+return returnval;
+}
+#endif //__SYMBIAN32__
+/* unhash: remove specified elements from a hash table */
+/**/
+int
+bin_unhash(char *name, char **argv, Options ops, UNUSED(int func))
+{
+HashTable ht;
+HashNode hn, nhn;
+Patprog pprog;
+int match = 0, returnval = 0;
+int i;
+/* Check which hash table we are working with. */
+if (OPT_ISSET(ops,'d'))
+	ht = nameddirtab;	/* named directories */
+else if (OPT_ISSET(ops,'f'))
+	ht = shfunctab;		/* shell functions   */
+else if (OPT_ISSET(ops,'s'))
+	ht = sufaliastab;	/* suffix aliases, must precede aliases */
+else if (OPT_ISSET(ops,'a'))
+	ht = aliastab;		/* aliases           */
+else
+	ht = cmdnamtab;		/* external commands */
+/* With -m option, treat arguments as glob patterns. *
+* "unhash -m '*'" is legal, but not recommended.    */
+if (OPT_ISSET(ops,'m')) {
+	for (; *argv; argv++) {
+	    /* expand argument */
+	    tokenize(*argv);
+	    if ((pprog = patcompile(*argv, PAT_STATIC, NULL))) {
+		/* remove all nodes matching glob pattern */
+		queue_signals();
+		for (i = 0; i < ht->hsize; i++) {
+		    for (hn = ht->nodes[i]; hn; hn = nhn) {
+			/* record pointer to next, since we may free this one */
+			nhn = hn->next;
+			if (pattry(pprog, hn->nam)) {
+			    ht->freenode(ht->removenode(ht, hn->nam));
+			    match++;
+			}
+		    }
+		}
+		unqueue_signals();
+	    } else {
+		untokenize(*argv);
+		zwarnnam(name, "bad pattern : %s", *argv, 0);
+		returnval = 1;
+	    }
+	}
+	/* If we didn't match anything, we return 1. */
+	if (!match)
+	    returnval = 1;
+	return returnval;
+}
+/* Take arguments literally -- do not glob */
+queue_signals();
+for (; *argv; argv++) {
+	if ((hn = ht->removenode(ht, *argv))) {
+	    ht->freenode(hn);
+	} else {
+	    zwarnnam(name, "no such hash table element: %s", *argv, 0);
+	    returnval = 1;
+	}
+}
+unqueue_signals();
+return returnval;
+}
+/**** alias builtins ****/
+/* alias: display or create aliases. */
+/**/
+int
+bin_alias(char *name, char **argv, Options ops, UNUSED(int func))
+{
+Alias a;
+Patprog pprog;
+Asgment asg;
+int returnval = 0;
+int flags1 = 0, flags2 = DISABLED;
+int printflags = 0;
+int type_opts;
+HashTable ht = aliastab;
+/* Did we specify the type of alias? */
+type_opts = OPT_ISSET(ops, 'r') + OPT_ISSET(ops, 'g') +
+	OPT_ISSET(ops, 's');
+if (type_opts) {
+	if (type_opts > 1) {
+	    zwarnnam(name, "illegal combination of options", NULL, 0);
+	    return 1;
+	}
+	if (OPT_ISSET(ops,'g'))
+	    flags1 |= ALIAS_GLOBAL;
+	else
+	    flags2 |= ALIAS_GLOBAL;
+	if (OPT_ISSET(ops, 's')) {
+	    /*
+	     * Although we keep suffix aliases in a different table,
+	     * it is useful to be able to distinguish Alias structures
+	     * without reference to the table, so we have a separate
+	     * flag, too.
+	     */
+	    flags1 |= ALIAS_SUFFIX;
+	    ht = sufaliastab;
+	} else
+	    flags2 |= ALIAS_SUFFIX;
+}
+if (OPT_ISSET(ops,'L'))
+	printflags |= PRINT_LIST;
+else if (OPT_PLUS(ops,'g') || OPT_PLUS(ops,'r') || OPT_PLUS(ops,'s') ||
+	     OPT_PLUS(ops,'m') || OPT_ISSET(ops,'+'))
+	printflags |= PRINT_NAMEONLY;
+/* In the absence of arguments, list all aliases.  If a command *
+* line flag is specified, list only those of that type.        */
+if (!*argv) {
+	queue_signals();
+	scanhashtable(ht, 1, flags1, flags2, ht->printnode, printflags);
+	unqueue_signals();
+	return 0;
+}
+/* With the -m option, treat the arguments as *
+* glob patterns of aliases to display.       */
+if (OPT_ISSET(ops,'m')) {
+	for (; *argv; argv++) {
+	    tokenize(*argv);  /* expand argument */
+	    if ((pprog = patcompile(*argv, PAT_STATIC, NULL))) {
+		/* display the matching aliases */
+		queue_signals();
+		scanmatchtable(ht, pprog, flags1, flags2,
+			       ht->printnode, printflags);
+		unqueue_signals();
+	    } else {
+		untokenize(*argv);
+		zwarnnam(name, "bad pattern : %s", *argv, 0);
+		returnval = 1;
+	    }
+	}
+	return returnval;
+}
+/* Take arguments literally.  Don't glob */
+queue_signals();
+while ((asg = getasg(*argv++))) {
+	if (asg->value && !OPT_ISSET(ops,'L')) {
+	    /* The argument is of the form foo=bar and we are not *
+	     * forcing a listing with -L, so define an alias      */
+	    ht->addnode(ht, ztrdup(asg->name),
+			createaliasnode(ztrdup(asg->value), flags1));
+	} else if ((a = (Alias) ht->getnode(ht, asg->name))) {
+	    /* display alias if appropriate */
+	    if (!type_opts || ht == sufaliastab ||
+		(OPT_ISSET(ops,'r') &&
+		 !(a->flags & (ALIAS_GLOBAL|ALIAS_SUFFIX))) ||
+		(OPT_ISSET(ops,'g') && (a->flags & ALIAS_GLOBAL)))
+		ht->printnode((HashNode) a, printflags);
+	} else
+	    returnval = 1;
+}
+unqueue_signals();
+return returnval;
+}
+/**** miscellaneous builtins ****/
+/* true, : (colon) */
+/**/
+int
+bin_true(UNUSED(char *name), UNUSED(char **argv), UNUSED(Options ops), UNUSED(int func))
+{
+return 0;
+}
+/* false builtin */
+/**/
+int
+bin_false(UNUSED(char *name), UNUSED(char **argv), UNUSED(Options ops), UNUSED(int func))
+{
+return 1;
+}
+/* the zle buffer stack */
+/**/
+mod_export LinkList bufstack;
+/* echo, print, printf, pushln */
+#define print_val(VAL) \
+if (prec >= 0) \
+	count += fprintf(fout, spec, width, prec, VAL); \
+else \
+	count += fprintf(fout, spec, width, VAL);
+/**/
+int
+bin_print(char *name, char **args, Options ops, int func)
+{
+int flen, width, prec, type, argc, n, narg;
+int nnl = 0, ret = 0, maxarg = 0;
+int flags[5], *len;
+char *start, *endptr, *c, *d, *flag, *buf, spec[13], *fmt = NULL;
+char **first, *curarg, *flagch = "0+- #", save = '\0', nullstr = '\0';
+size_t rcount, count = 0;
+#ifdef HAVE_OPEN_MEMSTREAM
+size_t mcount;
+#endif
+FILE *fout = stdout;
+Histent ent;
+mnumber mnumval;
+double doubleval;
+int intval;
+zlong zlongval;
+zulong zulongval;
+char *stringval;
+if (func == BIN_PRINTF) {
+if (!strcmp(*args, "--") && !*++args) {
+zwarnnam(name, "not enough arguments", NULL, 0);
+	    return 1;
+}
+	fmt = *args++;
+} else if (func == BIN_ECHO && isset(BSDECHO))
+	ops->ind['E'] = 1;
+else if (OPT_HASARG(ops,'f'))
+	fmt = OPT_ARG(ops,'f');
+if (fmt)
+#ifndef __SYMBIAN32__
+	fmt = getkeystring(fmt, &flen, OPT_ISSET(ops,'b') ? 2 : 0, &nnl);
+#else
+	fmt = getkeystring(fmt, &flen, 0, &nnl);
+#endif
+first = args;
+/* -m option -- treat the first argument as a pattern and remove
+* arguments not matching */
+if (OPT_ISSET(ops,'m')) {
+	Patprog pprog;
+	char **t, **p;
+	if (!*args) {
+	    zwarnnam(name, "no pattern specified", NULL, 0);
+	    return 1;
+	}
+	tokenize(*args);
+	if (!(pprog = patcompile(*args, PAT_STATIC, NULL))) {
+	    untokenize(*args);
+	    zwarnnam(name, "bad pattern : %s", *args, 0);
+	    return 1;
+	}
+	for (t = p = ++args; *p; p++)
+	    if (pattry(pprog, *p))
+		*t++ = *p;
+	*t = NULL;
+	first = args;
+	if (fmt && !*args) return 0;
+}
+/* compute lengths, and interpret according to -P, -D, -e, etc. */
+argc = arrlen(args);
+len = (int *) hcalloc(argc * sizeof(int));
+for(n = 0; n < argc; n++) {
+	/* first \ sequences */
+	if (fmt ||
+	    (!OPT_ISSET(ops,'e') &&
+	     (OPT_ISSET(ops,'R') || OPT_ISSET(ops,'r') || OPT_ISSET(ops,'E'))))
+	    unmetafy(args[n], &len[n]);
+	else
+#ifndef __SYMBIAN32__
+	    args[n] = getkeystring(args[n], &len[n], OPT_ISSET(ops,'b') ? 2 :
+				   (func != BIN_ECHO && !OPT_ISSET(ops,'e')),
+				   &nnl);
+#else
+	    args[n] = getkeystring(args[n], &len[n], (func != BIN_ECHO && !OPT_ISSET(ops,'e')),
+				   &nnl);
+#endif
+	/* -P option -- interpret as a prompt sequence */
+	if(OPT_ISSET(ops,'P')) {
+	    /*
+	     * promptexpand uses permanent storage: to avoid
+	     * messy memory management, stick it on the heap
+	     * instead.
+	     */
+	    char *str = unmetafy(promptexpand(metafy(args[n], len[n],
+						     META_NOALLOC), 0, NULL, NULL), &len[n]);
+	    args[n] = dupstring(str);
+	    free(str);
+	}
+#ifndef __SYMBIAN32__
+	/* -D option -- interpret as a directory, and use ~ */
+	if(OPT_ISSET(ops,'D')) {
+	    Nameddir d;
+	    queue_signals();
+	    d = finddir(args[n]);
+	    if(d) {
+		char *arg = zhalloc(strlen(args[n]) + 1);
+		sprintf(arg, "~%s%s", d->nam,
+			args[n] + strlen(d->dir));
+		args[n] = arg;
+		len[n] = strlen(args[n]);
+	    }
+	    unqueue_signals();
+	}
+#endif
+}
+/* -u and -p -- output to other than standard output */
+if (OPT_HASARG(ops,'u')/* || OPT_ISSET(ops,'p')*/) {
+	int fd;
+	if (OPT_ISSET(ops, 'p'))
+	    fd = coprocout;
+	else {
+	    char *argptr = OPT_ARG(ops,'u'), *eptr;
+	    /* Handle undocumented feature that -up worked */
+	    if (!strcmp(argptr, "p")) {
+		fd = coprocout;
+	    } else {
+		fd = (int)zstrtol(argptr, &eptr, 10);
+		if (*eptr) {
+		    zwarnnam(name, "number expected after -%c: %s", argptr,
+			     'u');
+		    return 1;
+		}
+	    }
+	}
+	if ((fd = dup(fd)) < 0) {
+	    zwarnnam(name, "bad file number: %d", NULL, fd);
+	    return 1;
+	}
+	if ((fout = fdopen(fd, "w")) == 0) {
+	    close(fd);
+	    zwarnnam(name, "bad mode on fd %d", NULL, fd);
+	    return 1;
+	}
+}
+/* -o and -O -- sort the arguments */
+if (OPT_ISSET(ops,'o')) {
+	if (fmt && !*args) return 0;
+	if (OPT_ISSET(ops,'i'))
+	    qsort(args, arrlen(args), sizeof(char *), cstrpcmp);
+	else
+	    qsort(args, arrlen(args), sizeof(char *), strpcmp);
+} else if (OPT_ISSET(ops,'O')) {
+	if (fmt && !*args) return 0;
+	if (OPT_ISSET(ops,'i'))
+	    qsort(args, arrlen(args), sizeof(char *), invcstrpcmp);
+	else
+	    qsort(args, arrlen(args), sizeof(char *), invstrpcmp);
+}
+/* after sorting arguments, recalculate lengths */
+if(OPT_ISSET(ops,'o') || OPT_ISSET(ops,'O'))
+	for(n = 0; n < argc; n++)
+	    len[n] = strlen(args[n]);
+/* -c -- output in columns */
+if (OPT_ISSET(ops,'c') || OPT_ISSET(ops,'C')) {
+	int l, nc, nr, sc, n, t, i;
+	char **ap;
+	if (OPT_ISSET(ops,'C')) {
+	    char *eptr, *argptr = OPT_ARG(ops,'C');
+	    nc = (int)zstrtol(argptr, &eptr, 10);
+	    if (*eptr) {
+		zwarnnam(name, "number expected after -%c: %s", argptr, 'C');
+		return 1;
+	    }
+	    if (nc <= 0) {
+		zwarnnam(name, "invalid number of columns: %s", argptr, 0);
+		return 1;
+	    }
+	    /*
+	     * n: number of elements
+	     * nc: number of columns
+	     * nr: number of rows
+	     */
+	    n = arrlen(args);
+	    nr = (n + nc - 1) / nc;
+	    /*
+	     * i: loop counter
+	     * ap: array iterator
+	     * l: maximum length seen
+	     *
+	     * Ignore lengths in last column since they don't affect
+	     * the separation.
+	     */
+	    for (i = l = 0, ap = args; *ap; ap++, i++) {
+		if (OPT_ISSET(ops, 'a')) {
+		    if ((i % nc) == nc - 1)
+			continue;
+		} else {
+		    if (i >= nr * (nc - 1))
+			break;
+		}
+		if (l < (t = strlen(*ap)))
+		    l = t;
+	    }
+	    sc = l + 2;
+	}
+	else
+	{
+	    /*
+	     * n: loop counter
+	     * ap: array iterator
+	     * l: maximum length seen
+	     */
+	    for (n = l = 0, ap = args; *ap; ap++, n++)
+		if (l < (t = strlen(*ap)))
+		    l = t;
+	    /*
+	     * sc: column width
+	     * nc: number of columns (at least one)
+	     */
+	    sc = l + 2;
+	    nc = (columns + 1) / sc;
+	    if (!nc)
+		nc = 1;
+	    nr = (n + nc - 1) / nc;
+	}
+	if (OPT_ISSET(ops,'a'))	/* print across, i.e. columns first */
+	    ap = args;
+	for (i = 0; i < nr; i++) {
+	    if (OPT_ISSET(ops,'a'))
+	    {
+		int ic;
+		for (ic = 0; ic < nc && *ap; ic++, ap++)
+		{
+		    l = strlen(*ap);
+		    fprintf(fout, "%s", *ap);
+		    if (*ap)
+			for (; l < sc; l++)
+			    fputc(' ', fout);
+		}
+	    }
+	    else
+	    {
+		ap = args + i;
+		do {
+		    l = strlen(*ap);
+		    fprintf(fout, "%s", *ap);
+		    for (t = nr; t && *ap; t--, ap++);
+		    if(*ap)
+			for (; l < sc; l++)
+			    fputc(' ', fout);
+		} while (*ap);
+	    }
+	    fputc(OPT_ISSET(ops,'N') ? '\0' : '\n', fout);
+	}
+	/* Testing EBADF special-cases >&- redirections */
+	if ((fout != stdout) ? (fclose(fout) != 0) :
+	    (fflush(fout) != 0 && errno != EBADF)) {
+zwarnnam(name, "write error: %e", NULL, errno);
+ret = 1;
+	}
+	return ret;
+}
+/* normal output */
+if (!fmt) {
+	/* -z option -- push the arguments onto the editing buffer stack */
+	if (OPT_ISSET(ops,'z')) {
+	    queue_signals();
+	    zpushnode(bufstack, sepjoin(args, NULL, 0));
+	    unqueue_signals();
+	    return 0;
+	}
+	/* -s option -- add the arguments to the history list */
+	if (OPT_ISSET(ops,'s')) {
+	    int nwords = 0, nlen, iwords;
+	    char **pargs = args;
+	    queue_signals();
+	    ent = prepnexthistent();
+	    while (*pargs++)
+		nwords++;
+	    if ((ent->nwords = nwords)) {
+		ent->words = (short *)zalloc(nwords*2*sizeof(short));
+		nlen = iwords = 0;
+		for (pargs = args; *pargs; pargs++) {
+		    ent->words[iwords++] = nlen;
+		    nlen += strlen(*pargs);
+		    ent->words[iwords++] = nlen;
+		    nlen++;
+		}
+	    } else
+		ent->words = (short *)NULL;
+	    ent->text = zjoin(args, ' ', 0);
+	    ent->stim = ent->ftim = time(NULL);
+	    ent->flags = 0;
+	    addhistnode(histtab, ent->text, ent);
+	    unqueue_signals();
+	    return 0;
+	}
+	for (; *args; args++, len++) {
+	    fwrite(*args, *len, 1, fout);
+	    if (args[1])
+		fputc(OPT_ISSET(ops,'l') ? '\n' :
+		      OPT_ISSET(ops,'N') ? '\0' : ' ', fout);
+	}
+	if (!(OPT_ISSET(ops,'n') || nnl))
+	    fputc(OPT_ISSET(ops,'N') ? '\0' : '\n', fout);
+	/* Testing EBADF special-cases >&- redirections */
+	if ((fout != stdout) ? (fclose(fout) != 0) :
+	    (fflush(fout) != 0 && errno != EBADF)) {
+zwarnnam(name, "write error: %e", NULL, errno);
+ret = 1;
+	}
+	return ret;
+}
+if (OPT_ISSET(ops,'z') || OPT_ISSET(ops,'s')) {
+#ifdef HAVE_OPEN_MEMSTREAM
+	if ((fout = open_memstream(&buf, &mcount)) == NULL)
+	    zwarnnam(name, "open_memstream failed", NULL, 0);
+#else
+	int tempfd;
+	char *tmpf;
+	if ((tempfd = gettempfile(NULL, 1, &tmpf)) < 0
+	 || (fout = fdopen(tempfd, "w+")) == NULL)
+	    zwarnnam(name, "can't open temp file: %e", NULL, errno);
+	unlink(tmpf);
+#endif
+}
+/* printf style output */
+*spec='%';
+do {
+	rcount = count;
+	if (maxarg) {
+	    first += maxarg;
+	    argc -= maxarg;
+	    maxarg = 0;
+	}
+	for (c = fmt;c-fmt < flen;c++) {
+	    if (*c != '%') {
+		putc(*c, fout);
+		++count;
+		continue;
+	    }
+	    start = c++;
+	    if (*c == '%') {
+		putchar('%');
+		++count;
+		continue;
+	    }
+	    type = prec = -1;
+	    width = 0;
+	    curarg = NULL;
+	    d = spec + 1;
+	    if (*c >= '1' && *c <= '9') {
+	    	narg = strtoul(c, &endptr, 0);
+		if (*endptr == '$') {
+		    c = endptr + 1;
+		    DPUTS(narg <= 0, "specified zero or negative arg");
+		    if (narg > argc) {
+		    	zwarnnam(name, "%d: argument specifier out of range",
+				 0, narg);
+			return 1;
+		    } else {
+		    	if (narg > maxarg) maxarg = narg;
+		    	curarg = *(first + narg - 1);
+		    }
+		}
+	    }
+	    /* copy only one of each flag as spec has finite size */
+	    memset(flags, 0, sizeof(flags));
+	    while ((flag = strchr(flagch, *c))) {
+	    	if (!flags[flag - flagch]) {
+	    	    flags[flag - flagch] = 1;
+		    *d++ = *c;
+		}
+	    	c++;
+	    }
+	    if (idigit(*c)) {
+		width = strtoul(c, &endptr, 0);
+		c = endptr;
+	    } else if (*c == '*') {
+		if (idigit(*++c)) {
+		    narg = strtoul(c, &endptr, 0);
+		    if (*endptr == '$') {
+		    	c = endptr + 1;
+			if (narg > argc || narg <= 0) {
+		    	    zwarnnam(name,
+				     "%d: argument specifier out of range",
+				     0, narg);
+			    return 1;
+			} else {
+		    	    if (narg > maxarg) maxarg = narg;
+		    	    args = first + narg - 1;
+			}
+		    }
+		}
+		if (*args) {
+		    width = (int)mathevali(*args++);
+		    if (errflag) {
+			errflag = 0;
+			ret = 1;
+		    }
+		}
+	    }
+	    *d++ = '*';
+	    if (*c == '.') {
+		if (*++c == '*') {
+		    if (idigit(*++c)) {
+			narg = strtoul(c, &endptr, 0);
+			if (*endptr == '$') {
+			    c = endptr + 1;
+			    if (narg > argc || narg <= 0) {
+		    		zwarnnam(name,
+					 "%d: argument specifier out of range",
+					 0, narg);
+				return 1;
+			    } else {
+		    		if (narg > maxarg) maxarg = narg;
+		    		args = first + narg - 1;
+			    }
+			}
+		    }
+		    if (*args) {
+			prec = (int)mathevali(*args++);
+			if (errflag) {
+			    errflag = 0;
+			    ret = 1;
+			}
+		    }
+		} else if (idigit(*c)) {
+		    prec = strtoul(c, &endptr, 0);
+		    c = endptr;
+		}
+		if (prec >= 0) *d++ = '.', *d++ = '*';
+	    }
+	    /* ignore any size modifier */
+	    if (*c == 'l' || *c == 'L' || *c == 'h') c++;
+	    if (!curarg && *args) curarg = *args++;
+	    d[1] = '\0';
+	    switch (*d = *c) {
+	    case 'c':
+		if (curarg) {
+		    intval = *curarg;
+		} else
+		    intval = 0;
+		print_val(intval);
+		break;
+	    case 's':
+		stringval = curarg ? curarg : &nullstr;
+		print_val(stringval);
+		break;
+	    case 'b':
+		if (curarg) {
+		    int l;
+#ifndef __SYMBIAN32__
+		    char *b = getkeystring(curarg, &l,
+					   OPT_ISSET(ops,'b') ? 2 : 0, &nnl);
+#else
+		    char *b = getkeystring(curarg, &l,
+					   0, &nnl);
+#endif
+		    /* handle width/precision here and use fwrite so that
+		     * nul characters can be output */
+		    if (prec >= 0 && prec < l) l = prec;
+		    if (width > 0 && flags[2]) width = -width;
+		    if (width > 0 && l < width)
+		    	printf("%*c", width - l, ' ');
+		    fwrite(b, l, 1, fout);
+		    if (width < 0 && l < -width)
+		    	printf("%*c", -width - l, ' ');
+		    count += l;
+		}
+		break;
+	    case 'q':
+		stringval = curarg ? bslashquote(curarg, NULL, 0) : &nullstr;
+		*d = 's';
+		print_val(stringval);
+		break;
+	    case 'd':
+	    case 'i':
+		type=1;
+		break;
+	    case 'e':
+	    case 'E':
+	    case 'f':
+	    case 'g':
+	    case 'G':
+		type=2;
+		break;
+	    case 'o':
+	    case 'u':
+	    case 'x':
+	    case 'X':
+		type=3;
+		break;
+	    case 'n':
+		if (curarg) setiparam(curarg, count - rcount);
+		break;
+	    default:
+	        if (*c) {
+		    save = c[1];
+	            c[1] = '\0';
+		}
+		zwarnnam(name, "%s: invalid directive", start, 0);
+		if (*c) c[1] = save;
+		/* Testing EBADF special-cases >&- redirections */
+		if ((fout != stdout) ? (fclose(fout) != 0) :
+		    (fflush(fout) != 0 && errno != EBADF)) {
+		    zwarnnam(name, "write error: %e", NULL, errno);
+		}
+		return 1;
+	    }
+	    if (type > 0) {
+		if (curarg && (*curarg == '\'' || *curarg == '"' )) {
+		    if (type == 2) {
+			doubleval = (unsigned char)curarg[1];
+			print_val(doubleval);
+		    } else {
+			intval = (unsigned char)curarg[1];
+			print_val(intval);
+		    }
+		} else {
+		    switch (type) {
+		    case 1:
+#ifdef ZSH_64_BIT_TYPE
+		    	*d++ = 'l';
+#endif
+		    	*d++ = 'l', *d++ = *c, *d = '\0';
+			zlongval = (curarg) ? mathevali(curarg) : 0;
+			if (errflag) {
+			    zlongval = 0;
+			    errflag = 0;
+			    ret = 1;
+			}
+			print_val(zlongval)
+			    break;
+		    case 2:
+			if (curarg) {
+			    mnumval = matheval(curarg);
+			    doubleval = (mnumval.type & MN_FLOAT) ?
+			    	mnumval.u.d : (double)mnumval.u.l;
+			} else doubleval = 0;
+			if (errflag) {
+			    doubleval = 0;
+			    errflag = 0;
+			    ret = 1;
+			}
+			print_val(doubleval)
+			    break;
+		    case 3:
+#ifdef ZSH_64_BIT_UTYPE
+		    	*d++ = 'l';
+#endif
+		    	*d++ = 'l', *d++ = *c, *d = '\0';
+			zulongval = (curarg) ? mathevali(curarg) : 0;
+			if (errflag) {
+			    zulongval = 0;
+			    errflag = 0;
+			    ret = 1;
+			}
+			print_val(zulongval)
+			    }
+		}
+	    }
+	    if (maxarg && (args - first > maxarg))
+	    	maxarg = args - first;
+	}
+#ifdef __SYMBIAN32__
+	fputc('\n', fout);
+#endif
+	if (maxarg) args = first + maxarg;
+	/* if there are remaining args, reuse format string */
+} while (*args && args != first && !OPT_ISSET(ops,'r'));
+if (OPT_ISSET(ops,'z') || OPT_ISSET(ops,'s')) {
+#ifdef HAVE_OPEN_MEMSTREAM
+	putc(0, fout);
+	fflush(fout);
+	count = mcount;
+#else
+	rewind(fout);
+	buf = (char *)zalloc(count + 1);
+	fread(buf, count, 1, fout);
+	buf[count] = '\0';
+#endif
+	queue_signals();
+	if (OPT_ISSET(ops,'z')) {
+	    zpushnode(bufstack, buf);
+	} else {
+	    ent = prepnexthistent();
+	    ent->text = buf;
+	    ent->stim = ent->ftim = time(NULL);
+	    ent->flags = 0;
+	    ent->words = (short *)NULL;
+	    addhistnode(histtab, ent->text, ent);
+	}
+	unqueue_signals();
+}
+/* Testing EBADF special-cases >&- redirections */
+if ((fout != stdout) ? (fclose(fout) != 0) :
+	(fflush(fout) != 0 && errno != EBADF)) {
+	zwarnnam(name, "write error: %e", NULL, errno);
+	ret = 1;
+}
+return ret;
+}
+/* shift builtin */
+/**/
+int
+bin_shift(char *name, char **argv, UNUSED(Options ops), UNUSED(int func))
+{
+int num = 1, l, ret = 0;
+char **s;
+/* optional argument can be either numeric or an array */
+queue_signals();
+if (*argv && !getaparam(*argv))
+num = mathevali(*argv++);
+if (num < 0) {
+	unqueue_signals();
+zwarnnam(name, "argument to shift must be non-negative", NULL, 0);
+return 1;
+}
+if (*argv) {
+for (; *argv; argv++)
+if ((s = getaparam(*argv))) {
+if (num > arrlen(s)) {
+		    zwarnnam(name, "shift count must be <= $#", NULL, 0);
+		    ret++;
+		    continue;
+		}
+		s = zarrdup(s + num);
+setaparam(*argv, s);
+}
+} else {
+if (num > (l = arrlen(pparams))) {
+	    zwarnnam(name, "shift count must be <= $#", NULL, 0);
+	    ret = 1;
+	} else {
+	    s = zalloc((l - num + 1) * sizeof(char *));
+	    memcpy(s, pparams + num, (l - num + 1) * sizeof(char *));
+	    while (num--)
+		zsfree(pparams[num]);
+	    zfree(pparams, (l + 1) * sizeof(char *));
+	    pparams = s;
+	}
+}
+unqueue_signals();
+return ret;
+}
+/**/
+int optcind;
+/* getopts: automagical option handling for shell scripts */
+/**/
+int
+bin_getopts(UNUSED(char *name), char **argv, UNUSED(Options ops), UNUSED(int func))
+{
+int lenstr, lenoptstr, quiet, lenoptbuf;
+char *optstr = unmetafy(*argv++, &lenoptstr), *var = *argv++;
+char **args = (*argv) ? argv : pparams;
+char *str, optbuf[2] = " ", *p, opch;
+/* zoptind keeps count of the current argument number.  The *
+* user can set it to zero to start a new option parse.     */
+if (zoptind < 1) {
+	/* first call */
+	zoptind = 1;
+	optcind = 0;
+}
+if(zoptind > arrlen(args))
+	/* no more options */
+	return 1;
+/* leading ':' in optstr means don't print an error message */
+quiet = *optstr == ':';
+optstr += quiet;
+lenoptstr -= quiet;
+/* find place in relevant argument */
+str = unmetafy(dupstring(args[zoptind - 1]), &lenstr);
+if (!lenstr)		/* Definitely not an option. */
+	return 1;
+if(optcind >= lenstr) {
+	optcind = 0;
+	if(!args[zoptind++])
+	    return 1;
+	str = unmetafy(dupstring(args[zoptind - 1]), &lenstr);
+}
+if(!optcind) {
+	if(lenstr < 2 || (*str != '-' && *str != '+'))
+	    return 1;
+	if(lenstr == 2 && str[0] == '-' && str[1] == '-') {
+	    zoptind++;
+	    return 1;
+	}
+	optcind++;
+}
+opch = str[optcind++];
+if(str[0] == '+') {
+	optbuf[0] = '+';
+	lenoptbuf = 2;
+} else
+	lenoptbuf = 1;
+optbuf[lenoptbuf - 1] = opch;
+/* check for legality */
+if(opch == ':' || !(p = memchr(optstr, opch, lenoptstr))) {
+	p = "?";
+err:
+	zsfree(zoptarg);
+	setsparam(var, ztrdup(p));
+	if(quiet) {
+	    zoptarg = metafy(optbuf, lenoptbuf, META_DUP);
+	} else {
+	    zwarn(*p == '?' ? "bad option: -%c" :
+		  "argument expected after -%c option", NULL, opch);
+	    zoptarg=ztrdup("");
+	}
+	return 0;
+}
+/* check for required argument */
+if(p[1] == ':') {
+	if(optcind == lenstr) {
+	    if(!args[zoptind]) {
+		p = ":";
+		goto err;
+	    }
+	    p = ztrdup(args[zoptind++]);
+	} else
+	    p = metafy(str+optcind, lenstr-optcind, META_DUP);
+	/*
+	 * Careful:  I've just changed the following two lines from
+	 *   optcind = ztrlen(args[zoptind - 1]);
+	 * and it's a rigorous theorem that every change in getopts breaks
+	 * something.  See zsh-workers/9095 for the bug fixed here.
+	 *   PWS 2000/05/02
+	 */
+	optcind = 0;
+	zoptind++;
+	zsfree(zoptarg);
+	zoptarg = p;
+} else {
+	zsfree(zoptarg);
+	zoptarg = ztrdup("");
+}
+setsparam(var, metafy(optbuf, lenoptbuf, META_DUP));
+return 0;
+}
+/* Flag that we should exit the shell as soon as all functions return. */
+/**/
+mod_export int
+exit_pending;
+/* break, bye, continue, exit, logout, return -- most of these take   *
+* one numeric argument, and the other (logout) is related to return. *
+* (return is treated as a logout when in a login shell.)             */
+/**/
+int
+bin_break(char *name, char **argv, UNUSED(Options ops), int func)
+{
+int num = lastval, nump = 0;
+/* handle one optional numeric argument */
+if (*argv) {
+	num = mathevali(*argv++);
+	nump = 1;
+}
+switch (func) {
+case BIN_CONTINUE:
+	if (!loops) {   /* continue is only permitted in loops */
+		/* TODO: Check zerrnam() behaviour with fprintf*/
+	    fprintf(stdout,"not in while, until, select, or repeat loop");
+	    return 1;
+	}
+	contflag = 1;   /* ARE WE SUPPOSED TO FALL THROUGH HERE? */
+case BIN_BREAK:
+	if (!loops) {   /* break is only permitted in loops */
+	    zerrnam(name, "not in while, until, select, or repeat loop", NULL, 0);
+	    return 1;
+	}
+	breaks = nump ? minimum(num,loops) : 1;
+	break;
+case BIN_RETURN:
+	if (isset(INTERACTIVE) || locallevel || sourcelevel) {
+	    retflag = 1;
+	    breaks = loops;
+	    lastval = num;
+	    if (trapreturn == -2)
+		trapreturn = lastval;
+	    return lastval;
+	}
+	zexit(num, 0);	/* else treat return as logout/exit */
+	break;
+case BIN_LOGOUT:
+#ifndef __SYMBIAN32__
+	if (unset(LOGINSHELL)) {
+	    zerrnam(name, "not login shell", NULL, 0);
+	    return 1;
+	}
+#else
+		{
+		zerrnam(name, "not supported", NULL, 0);
+		return 1;
+		}
+#endif
+	/*FALLTHROUGH*/
+case BIN_EXIT:
+	if (locallevel) {
+	    /*
+	     * We don't exit directly from functions to allow tidying
+	     * up, in particular EXIT traps.  We still need to perform
+	     * the usual interactive tests to see if we can exit at
+	     * all, however.
+	     */
+	    if (stopmsg || (zexit(0,2), !stopmsg)) {
+		retflag = 1;
+		breaks = loops;
+		exit_pending = (num << 1) | 1;
+	    }
+	} else
+	    zexit(num, 0);
+	break;
+}
+return 0;
+}
+/* we have printed a 'you have stopped (running) jobs.' message */
+/**/
+mod_export int stopmsg;
+/* check to see if user has jobs running/stopped */
+/**/
+static void
+checkjobs(void)
+{
+int i;
+for (i = 1; i <= maxjob; i++)
+	if (i != thisjob && (jobtab[i].stat & STAT_LOCKED) &&
+	    !(jobtab[i].stat & STAT_NOPRINT))
+	    break;
+if (i <= maxjob) {
+	if (jobtab[i].stat & STAT_STOPPED) {
+#ifdef USE_SUSPENDED
+	    zerr("you have suspended jobs.", NULL, 0);
+#else
+	    zerr("you have stopped jobs.", NULL, 0);
+#endif
+	} else
+	    zerr("you have running jobs.", NULL, 0);
+	stopmsg = 1;
+}
+}
+/* exit the shell.  val is the return value of the shell.  *
+* from_where is
+*   1   if zexit is called because of a signal
+*   2   if we can't actually exit yet (e.g. functions need
+*       terminating) but should perform the usual interactive tests.
+*/
+/**/
+mod_export void
+zexit(int val, int from_where)
+{
+static int in_exit;
+if (isset(MONITOR) && !stopmsg && from_where != 1) {
+	scanjobs();    /* check if jobs need printing           */
+	if (isset(CHECKJOBS))
+	    checkjobs();   /* check if any jobs are running/stopped */
+	if (stopmsg) {
+	    stopmsg = 2;
+	    return;
+	}
+}
+if (from_where == 2 || (in_exit++ && from_where))
+	return;
+if (isset(MONITOR)) {
+	/* send SIGHUP to any jobs left running  */
+	killrunjobs(from_where == 1);
+}
+if (isset(RCS) && interact) {
+	if (!nohistsave) {
+	    int writeflags = HFILE_USE_OPTIONS;
+	    if (from_where == 1)
+		writeflags |= HFILE_NO_REWRITE;
+	    saveandpophiststack(1, writeflags);
+	    savehistfile(NULL, 1, writeflags);
+	}
+	if (islogin && !subsh) {
+	    sourcehome(".zlogout");
+#ifdef GLOBAL_ZLOGOUT
+	    if (isset(RCS) && isset(GLOBALRCS))
+		source(GLOBAL_ZLOGOUT);
+#endif
+	}
+}
+if (sigtrapped[SIGEXIT])
+	dotrap(SIGEXIT);
+runhookdef(EXITHOOK, NULL);
+if (opts[MONITOR] && interact && (SHTTY != -1)) {
+release_pgrp();
+}
+if (mypid != getpid())
+	_exit(val);
+else
+	exit(val);
+}
+/* . (dot), source */
+/**/
+int
+bin_dot(char *name, char **argv, UNUSED(Options ops), UNUSED(int func))
+{
+char **old, *old0 = NULL;
+int ret, diddot = 0, dotdot = 0;
+char *s, **t, *enam, *arg0, *buf;
+struct stat st;
+if (!*argv)
+	return 0;
+old = pparams;
+/* get arguments for the script */
+if (argv[1])
+	pparams = zarrdup(argv + 1);
+enam = arg0 = ztrdup(*argv);
+if (isset(FUNCTIONARGZERO)) {
+	old0 = argzero;
+	argzero = arg0;
+}
+s = unmeta(enam);
+errno = ENOENT;
+ret = 1;
+/* for source only, check in current directory first */
+if (*name != '.' && access(s, F_OK) == 0
+	&& stat(s, &st) >= 0 && !S_ISDIR(st.st_mode)) {
+	diddot = 1;
+	ret = source(enam);
+}
+if (ret) {
+	/* use a path with / in it */
+	for (s = arg0; *s; s++)
+	    if (*s == '/' || *s == '\\') {
+		if (*arg0 == '.') {
+		    if (arg0 + 1 == s)
+			++diddot;
+		    else if (arg0[1] == '.' && arg0 + 2 == s)
+			++dotdot;
+		}
+		ret = source(arg0);
+		break;
+	    }
+	if (!*s || (ret && isset(PATHDIRS) && diddot < 2 && dotdot == 0)) {
+	    pushheap();
+	    /* search path for script */
+	    for (t = path; *t; t++) {
+		if (!(*t)[0] || ((*t)[0] == '.' && !(*t)[1])) {
+		    if (diddot)
+			continue;
+		    diddot = 1;
+		    buf = dupstring(arg0);
+		} else
+		    buf = zhtricat(*t, "/", arg0);
+		s = unmeta(buf);
+		if (access(s, F_OK) == 0 && stat(s, &st) >= 0
+		    && !S_ISDIR(st.st_mode)) {
+		    ret = source(enam = buf);
+		    break;
+		}
+	    }
+	    popheap();
+	}
+}
+/* clean up and return */
+if (argv[1]) {
+	freearray(pparams);
+	pparams = old;
+}
+if (ret)
+	zwarnnam(name, "%e: %s", enam, errno);
+zsfree(arg0);
+if (old0)
+	argzero = old0;
+return ret ? ret : lastval;
+}
+/**/
+int
+bin_emulate(UNUSED(char *nam), char **argv, Options ops, UNUSED(int func))
+{
+emulate(*argv, OPT_ISSET(ops,'R'));
+if (OPT_ISSET(ops,'L'))
+	opts[LOCALOPTIONS] = opts[LOCALTRAPS] = 1;
+return 0;
+}
+/* eval: simple evaluation */
+/**/
+int ineval;
+/**/
+int
+bin_eval(UNUSED(char *nam), char **argv, UNUSED(Options ops), UNUSED(int func))
+{
+Eprog prog;
+char *oscriptname = scriptname;
+int oineval = ineval;
+/*
+* If EVALLINENO is not set, we use the line number of the
+* environment and must flag this up to exec.c.  Otherwise,
+* we use a special script name to indicate the special line number.
+*/
+ineval = !isset(EVALLINENO);
+if (!ineval)
+	scriptname = "(eval)";
+prog = parse_string(zjoin(argv, ' ', 1));
+if (prog) {
+	lastval = 0;
+	execode(prog, 1, 0);
+	if (errflag)
+	    lastval = errflag;
+} else {
+	lastval = 1;
+}
+errflag = 0;
+scriptname = oscriptname;
+ineval = oineval;
+return lastval;
+}
+static char *zbuf;
+static int readfd;
+/* Read a character from readfd, or from the buffer zbuf.  Return EOF on end of
+file/buffer. */
+/* read: get a line of input, or (for compctl functions) return some *
+* useful data about the state of the editing line.  The -E and -e   *
+* options mean that the result should be sent to stdout.  -e means, *
+* in addition, that the result should not actually be assigned to   *
+* the specified parameters.                                         */
+/**/
+int
+bin_read(char *name, char **args, Options ops, UNUSED(int func))
+{
+char *reply, *readpmpt;
+int bsiz, c = 0, gotnl = 0, al = 0, first, nchars = 1, bslash, keys = 0;
+int haso = 0;	/* true if /dev/tty has been opened specially */
+int isem = !strcmp(term, "emacs"), izle = zleactive && getkeyptr;
+char *buf, *bptr, *firstarg, *zbuforig;
+LinkList readll = newlinklist();
+FILE *oshout = NULL;
+int readchar = -1, val, resettty = 0;
+struct ttyinfo saveti;
+char d;
+char delim = '\n';
+char *eptr, *optarg;
+if (OPT_HASARG(ops,c='k')) {
+	optarg = OPT_ARG(ops,c);
+	nchars = (int)zstrtol(optarg, &eptr, 10);
+	if (*eptr) {
+	    zwarnnam(name, "number expected after -%c: %s", optarg, c);
+	    return 1;
+	}
+}
+/* This `*args++ : *args' looks a bit weird, but it works around a bug
+* in gcc-2.8.1 under DU 4.0. */
+firstarg = (*args && **args == '?' ? *args++ : *args);
+reply = *args ? *args++ : OPT_ISSET(ops,'A') ? "reply" : "REPLY";
+if (OPT_ISSET(ops,'A') && *args) {
+	zwarnnam(name, "only one array argument allowed", NULL, 0);
+	return 1;
+}
+/* handle compctl case */
+if(OPT_ISSET(ops,'l') || OPT_ISSET(ops,'c'))
+	return compctlread(name, args, ops, reply);
+if ((OPT_ISSET(ops,'k') && !OPT_ISSET(ops,'u') &&
+	 !OPT_ISSET(ops,'p')) || OPT_ISSET(ops,'q')) {
+	if (!zleactive) {
+	    if (SHTTY == -1) {
+		/* need to open /dev/tty specially */
+		if ((SHTTY = open("/dev/tty", O_RDWR|O_NOCTTY)) != -1) {
+		    haso = 1;
+		    oshout = shout;
+		    init_shout();
+		}
+	    } else if (!shout) {
+		/* We need an output FILE* on the tty */
+		init_shout();
+	    }
+	    /* We should have a SHTTY opened by now. */
+	    if (SHTTY == -1) {
+		/* Unfortunately, we didn't. */
+		fprintf(stderr, "not interactive and can't open terminal\n");
+		fflush(stderr);
+		return 1;
+	    }
+	    if (unset(INTERACTIVE))
+		gettyinfo(&shttyinfo);
+	    /* attach to the tty */
+	    attachtty(mypgrp);
+	    if (!isem && OPT_ISSET(ops,'k'))
+		setcbreak();
+	    readfd = SHTTY;
+	}
+	keys = 1;
+} else if (OPT_HASARG(ops,'u') && !OPT_ISSET(ops,'p')) {
+	/* -u means take input from the specified file descriptor. */
+	char *eptr, *argptr = OPT_ARG(ops,'u');
+	/* The old code handled -up, but that was never documented. Still...*/
+	if (!strcmp(argptr, "p")) {
+	    readfd = coprocin;
+	} else {
+	    readfd = (int)zstrtol(argptr, &eptr, 10);
+	    if (*eptr) {
+		zwarnnam(name, "number expected after -%c: %s", argptr, 'u');
+		return 1;
+	    }
+	}
+#if 0
+	/* This code is left as a warning to future generations --- pws. */
+	for (readfd = 9; readfd && !OPT_ISSET(ops,readfd + '0'); --readfd);
+#endif
+	izle = 0;
+} else if (OPT_ISSET(ops,'p')) {
+	readfd = coprocin;
+	izle = 0;
+} else
+	readfd = izle = 0;
+if (OPT_ISSET(ops,'t')) {
+	zlong timeout = 0;
+	if (OPT_HASARG(ops,'t')) {
+	    mnumber mn = zero_mnumber;
+	    mn = matheval(OPT_ARG(ops,'t'));
+	    if (errflag)
+		return 1;
+	    if (mn.type == MN_FLOAT) {
+		mn.u.d *= 1e6;
+		timeout = (zlong)mn.u.d;
+	    } else {
+		timeout = (zlong)mn.u.l * (zlong)1000000;
+	    }
+	}
+	if (readfd == -1 ||
+	    !read_poll(readfd, &readchar, keys && !zleactive, timeout)) {
+	    if (OPT_ISSET(ops,'k') && !zleactive && !isem)
+		settyinfo(&shttyinfo);
+	    if (haso) {
+		fclose(shout);
+		shout = oshout;
+		SHTTY = -1;
+	    }
+	    return 1;
+	}
+}
+if (OPT_ISSET(ops,'d')) {
+	char *delimstr = OPT_ARG(ops,'d');
+delim = (delimstr[0] == Meta) ? delimstr[1] ^ 32 : delimstr[0];
+	if (SHTTY != -1) {
+	    struct ttyinfo ti;
+	    gettyinfo(&ti);
+	    saveti = ti;
+	    resettty = 1;
+#ifdef HAS_TIO
+	    ti.tio.c_lflag &= ~ICANON;
+	    ti.tio.c_cc[VMIN] = 1;
+	    ti.tio.c_cc[VTIME] = 0;
+#else
+	    ti.sgttyb.sg_flags |= CBREAK;
+#endif
+	    settyinfo(&ti);
+	}
+}
+if (OPT_ISSET(ops,'s') && SHTTY != -1) {
+#ifndef __SYMBIAN32__
+	struct ttyinfo ti;
+	gettyinfo(&ti);
+	if (! resettty) {
+	    saveti = ti;
+	    resettty = 1;
+	}
+#ifdef HAS_TIO
+	ti.tio.c_lflag &= ~ECHO;
+#else
+	ti.sgttyb.sg_flags &= ~ECHO;
+#endif
+	settyinfo(&ti);
+#else
+	zwarn("bad option: -%c", NULL, 's');
+	return 1;
+#endif
+}
+/* handle prompt */
+if (firstarg) {
+	for (readpmpt = firstarg;
+	     *readpmpt && *readpmpt != '?'; readpmpt++);
+	if (*readpmpt++) {
+	    if (keys || isatty(0)) {
+		zputs(readpmpt, (shout ? shout : stderr));
+		fflush(shout ? shout : stderr);
+	    }
+	    readpmpt[-1] = '\0';
+	}
+}
+/* option -k means read only a given number of characters (default 1) */
+if (OPT_ISSET(ops,'k')) {
+	/* allocate buffer space for result */
+	bptr = buf = (char *)zalloc(nchars+1);
+	do {
+	    if (izle) {
+		if ((val = getkeyptr(0)) < 0)
+		    break;
+		*bptr++ = (char) val;
+		nchars--;
+	    } else {
+		/* If read returns 0, is end of file */
+		if (readchar >= 0) {
+		    *bptr = readchar;
+		    val = 1;
+		    readchar = -1;
+		} else if ((val = read(readfd, bptr, nchars)) <= 0)
+		    break;
+		/* decrement number of characters read from number required */
+		nchars -= val;
+		/* increment pointer past read characters */
+		bptr += val;
+	    }
+	} while (nchars > 0);
+	if (!izle && !OPT_ISSET(ops,'u') && !OPT_ISSET(ops,'p')) {
+	    /* dispose of result appropriately, etc. */
+	    if (isem)
+		while (val > 0 && read(SHTTY, &d, 1) == 1 && d != '\n');
+	    else {
+		settyinfo(&shttyinfo);
+		resettty = 0;
+	    }
+	    if (haso) {
+		fclose(shout);	/* close(SHTTY) */
+		shout = oshout;
+		SHTTY = -1;
+	    }
+	}
+	if (OPT_ISSET(ops,'e') || OPT_ISSET(ops,'E'))
+	    fwrite(buf, bptr - buf, 1, stdout);
+	if (!OPT_ISSET(ops,'e'))
+	    setsparam(reply, metafy(buf, bptr - buf, META_REALLOC));
+	else
+	    zfree(buf, bptr - buf + 1);
+	if (resettty && SHTTY != -1)
+	    settyinfo(&saveti);
+	return val <= 0;
+}
+/* option -q means get one character, and interpret it as a Y or N */
+if (OPT_ISSET(ops,'q')) {
+	char readbuf[2];
+	/* set up the buffer */
+	readbuf[1] = '\0';
+	/* get, and store, reply */
+	if (izle) {
+	    int key = getkeyptr(0);
+	    readbuf[0] = (key == 'y' ? 'y' : 'n');
+	} else {
+	    readbuf[0] = ((char)getquery(NULL, 0)) == 'y' ? 'y' : 'n';
+	    /* dispose of result appropriately, etc. */
+	    if (haso) {
+		fclose(shout);	/* close(SHTTY) */
+		shout = oshout;
+		SHTTY = -1;
+	    }
+	}
+	if (OPT_ISSET(ops,'e') || OPT_ISSET(ops,'E'))
+	    printf("%s\n", readbuf);
+	if (!OPT_ISSET(ops,'e'))
+	    setsparam(reply, ztrdup(readbuf));
+	if (resettty && SHTTY != -1)
+	    settyinfo(&saveti);
+	return readbuf[0] == 'n';
+}
+/* All possible special types of input have been exhausted.  Take one line,
+and assign words to the parameters until they run out.  Leftover words go
+onto the last parameter.  If an array is specified, all the words become
+separate elements of the array. */
+zbuforig = zbuf = (!OPT_ISSET(ops,'z')) ? NULL :
+	(nonempty(bufstack)) ? (char *) getlinknode(bufstack) : ztrdup("");
+first = 1;
+bslash = 0;
+while (*args || (OPT_ISSET(ops,'A') && !gotnl)) {
+	sigset_t s = child_unblock();
+	buf = bptr = (char *)zalloc(bsiz = 64);
+	/* get input, a character at a time */
+	while (!gotnl) {
+	    c = zread(izle, &readchar);
+	    /* \ at the end of a line indicates a continuation *
+	     * line, except in raw mode (-r option)            */
+	    if (bslash && c == delim) {
+		bslash = 0;
+		continue;
+	    }
+	    if (c == EOF || c == delim)
+		break;
+	    /*
+	     * `first' is non-zero if any separator we encounter is a
+	     * non-whitespace separator, which means that anything
+	     * (even an empty string) between, before or after separators
+	     * is significant.  If it is zero, we have a whitespace
+	     * separator, which shouldn't cause extra empty strings to
+	     * be emitted.  Hence the test for (*buf || first) when
+	     * we assign the result of reading a word.
+	     */
+	    if (!bslash && isep(c)) {
+		if (bptr != buf || (!iwsep(c) && first)) {
+		    first |= !iwsep(c);
+		    break;
+		}
+		first |= !iwsep(c);
+		continue;
+	    }
+	    bslash = c == '\\' && !bslash && !OPT_ISSET(ops,'r');
+	    if (bslash)
+		continue;
+	    first = 0;
+	    if (imeta(c)) {
+		*bptr++ = Meta;
+		*bptr++ = c ^ 32;
+	    } else
+		*bptr++ = c;
+	    /* increase the buffer size, if necessary */
+	    if (bptr >= buf + bsiz - 1) {
+		int blen = bptr - buf;
+		buf = realloc(buf, bsiz *= 2);
+		bptr = buf + blen;
+	    }
+	}
+	signal_setmask(s);
+	if (c == delim || c == EOF)
+	    gotnl = 1;
+	*bptr = '\0';
+	/* dispose of word appropriately */
+	if (OPT_ISSET(ops,'e') || OPT_ISSET(ops,'E')) {
+	    zputs(buf, stdout);
+	    putchar('\n');
+	}
+	if (!OPT_ISSET(ops,'e') && (*buf || first)) {
+	    if (OPT_ISSET(ops,'A')) {
+		addlinknode(readll, buf);
+		al++;
+	    } else
+		setsparam(reply, buf);
+	} else
+	    free(buf);
+	if (!OPT_ISSET(ops,'A'))
+	    reply = *args++;
+}
+/* handle EOF */
+if (c == EOF) {
+	if (readfd == coprocin) {
+	    close(coprocin);
+	    close(coprocout);
+	    coprocin = coprocout = -1;
+	}
+}
+/* final assignment (and display) of array parameter */
+if (OPT_ISSET(ops,'A')) {
+	char **pp, **p = NULL;
+	LinkNode n;
+	p = (OPT_ISSET(ops,'e') ? (char **)NULL
+	     : (char **)zalloc((al + 1) * sizeof(char *)));
+	for (pp = p, n = firstnode(readll); n; incnode(n)) {
+	    if (OPT_ISSET(ops,'e') || OPT_ISSET(ops,'E')) {
+		zputs((char *) getdata(n), stdout);
+		putchar('\n');
+	    }
+	    if (p)
+		*pp++ = (char *)getdata(n);
+	    else
+		zsfree(getdata(n));
+	}
+	if (p) {
+	    *pp++ = NULL;
+	    setaparam(reply, p);
+	}
+	if (resettty && SHTTY != -1)
+	    settyinfo(&saveti);
+	return c == EOF;
+}
+buf = bptr = (char *)zalloc(bsiz = 64);
+/* any remaining part of the line goes into one parameter */
+bslash = 0;
+if (!gotnl) {
+	sigset_t s = child_unblock();
+	for (;;) {
+	    c = zread(izle, &readchar);
+	    /* \ at the end of a line introduces a continuation line, except in
+	       raw mode (-r option) */
+	    if (bslash && c == delim) {
+		bslash = 0;
+		continue;
+	    }
+	    if (c == EOF || (c == delim && !zbuf))
+		break;
+	    if (!bslash && isep(c) && bptr == buf) {
+		if (iwsep(c))
+		    continue;
+		else if (!first) {
+		    first = 1;
+		    continue;
+		}
+	    }
+	    bslash = c == '\\' && !bslash && !OPT_ISSET(ops,'r');
+	    if (bslash)
+		continue;
+	    if (imeta(c)) {
+		*bptr++ = Meta;
+		*bptr++ = c ^ 32;
+	    } else
+		*bptr++ = c;
+	    /* increase the buffer size, if necessary */
+	    if (bptr >= buf + bsiz - 1) {
+		int blen = bptr - buf;
+		buf = realloc(buf, bsiz *= 2);
+		bptr = buf + blen;
+	    }
+	}
+	signal_setmask(s);
+}
+while (bptr > buf) {
+	if (bptr > buf + 1 && bptr[-2] == Meta) {
+	    if (iwsep(bptr[-1] ^ 32))
+		bptr -= 2;
+	    else
+		break;
+	} else if (iwsep(bptr[-1]))
+	    bptr--;
+	else
+	    break;
+}
+*bptr = '\0';
+if (resettty && SHTTY != -1)
+	settyinfo(&saveti);
+/* final assignment of reply, etc. */
+if (OPT_ISSET(ops,'e') || OPT_ISSET(ops,'E')) {
+	zputs(buf, stdout);
+	putchar('\n');
+}
+if (!OPT_ISSET(ops,'e'))
+	setsparam(reply, buf);
+else
+	zsfree(buf);
+if (zbuforig) {
+	char first = *zbuforig;
+	zsfree(zbuforig);
+	if (!first)
+	    return 1;
+} else if (c == EOF) {
+	if (readfd == coprocin) {
+	    close(coprocin);
+	    close(coprocout);
+	    coprocin = coprocout = -1;
+	}
+	return 1;
+}
+return 0;
+}
+/**/
+static int
+zread(int izle, int *readchar)
+{
+char cc, retry = 0;
+int ret;
+if (izle) {
+	int c = getkeyptr(0);
+	return (c < 0 ? EOF : c);
+}
+/* use zbuf if possible */
+if (zbuf) {
+	/* If zbuf points to anything, it points to the next character in the
+	   buffer.  This may be a null byte to indicate EOF.  If reading from the
+	   buffer, move on the buffer pointer. */
+	if (*zbuf == Meta)
+	    return zbuf++, STOUC(*zbuf++ ^ 32);
+	else
+	    return (*zbuf) ? STOUC(*zbuf++) : EOF;
+}
+if (*readchar >= 0) {
+	cc = *readchar;
+	*readchar = -1;
+	return STOUC(cc);
+}
+for (;;) {
+	/* read a character from readfd */
+	ret = read(readfd, &cc, 1);
+	switch (ret) {
+	case 1:
+	    /* return the character read */
+	    return STOUC(cc);
+	case -1:
+#if defined(EAGAIN) || defined(EWOULDBLOCK)
+	    if (!retry && readfd == 0 && (
+# ifdef EAGAIN
+		errno == EAGAIN
+#  ifdef EWOULDBLOCK
+		||
+#  endif /* EWOULDBLOCK */
+# endif /* EAGAIN */
+# ifdef EWOULDBLOCK
+		errno == EWOULDBLOCK
+# endif /* EWOULDBLOCK */
+		) && setblock_stdin()) {
+		retry = 1;
+		continue;
+	    } else
+#endif /* EAGAIN || EWOULDBLOCK */
+		if (errno == EINTR && !(errflag || retflag || breaks || contflag))
+		    continue;
+	    break;
+	}
+	return EOF;
+}
+}
+/* holds arguments for testlex() */
+/**/
+char **testargs;
+/* test, [: the old-style general purpose logical expression builtin */
+/**/
+void
+testlex(void)
+{
+if (tok == LEXERR)
+	return;
+tokstr = *testargs;
+if (!*testargs) {
+	/* if tok is already zero, reading past the end:  error */
+	tok = tok ? NULLTOK : LEXERR;
+	return;
+} else if (!strcmp(*testargs, "-o"))
+	tok = DBAR;
+else if (!strcmp(*testargs, "-a"))
+	tok = DAMPER;
+else if (!strcmp(*testargs, "!"))
+	tok = BANG;
+else if (!strcmp(*testargs, "("))
+	tok = INPAR;
+else if (!strcmp(*testargs, ")"))
+	tok = OUTPAR;
+else
+	tok = STRING;
+testargs++;
+}
+/**/
+int
+bin_test(char *name, char **argv, UNUSED(Options ops), int func)
+{
+char **s;
+Eprog prog;
+struct estate state;
+/* if "test" was invoked as "[", it needs a matching "]" *
+* which is subsequently ignored                         */
+if (func == BIN_BRACKET) {
+	for (s = argv; *s; s++);
+	if (s == argv || strcmp(s[-1], "]")) {
+	    zwarnnam(name, "']' expected", NULL, 0);
+	    return 1;
+	}
+	s[-1] = NULL;
+}
+/* an empty argument list evaluates to false (1) */
+if (!*argv)
+	return 1;
+testargs = argv;
+tok = NULLTOK;
+condlex = testlex;
+testlex();
+prog = parse_cond();
+condlex = yylex;
+if (errflag) {
+	errflag = 0;
+	return 1;
+}
+if (!prog || tok == LEXERR) {
+	zwarnnam(name, tokstr ? "parse error" : "argument expected", NULL, 0);
+	return 1;
+}
+/* syntax is OK, so evaluate */
+state.prog = prog;
+state.pc = prog->prog;
+state.strs = prog->strs;
+return evalcond(&state, name);
+}
+/* display a time, provided in units of 1/60s, as minutes and seconds */
+#define pttime(X) printf("%ldm%ld.%02lds",((long) (X))/3600,\
+			 ((long) (X))/60%60,((long) (X))*100/60%100)
+#ifndef __SYMBIAN32__
+/* times: display, in a two-line format, the times provided by times(3) */
+/**/
+int
+bin_times(UNUSED(char *name), UNUSED(char **argv), UNUSED(Options ops), UNUSED(int func))
+{
+struct tms buf;
+/* get time accounting information */
+if (times(&buf) == -1)
+	return 1;
+pttime(buf.tms_utime);	/* user time */
+putchar(' ');
+pttime(buf.tms_stime);	/* system time */
+putchar('\n');
+pttime(buf.tms_cutime);	/* user time, children */
+putchar(' ');
+pttime(buf.tms_cstime);	/* system time, children */
+putchar('\n');
+return 0;
+}
+/* trap: set/unset signal traps */
+/**/
+int
+bin_trap(char *name, char **argv, UNUSED(Options ops), UNUSED(int func))
+{
+Eprog prog;
+char *arg, *s;
+int sig;
+if (*argv && !strcmp(*argv, "--"))
+	argv++;
+/* If given no arguments, list all currently-set traps */
+if (!*argv) {
+	queue_signals();
+	for (sig = 0; sig < VSIGCOUNT; sig++) {
+	    if (sigtrapped[sig] & ZSIG_FUNC) {
+		HashNode hn;
+		if ((hn = gettrapnode(sig, 0)))
+		    shfunctab->printnode(hn, 0);
+		DPUTS(!hn, "BUG: I did not find any trap functions!");
+	    } else if (sigtrapped[sig]) {
+		if (!sigfuncs[sig])
+		    printf("trap -- '' %s\n", sigs[sig]);
+		else {
+		    s = getpermtext(sigfuncs[sig], NULL);
+		    printf("trap -- ");
+		    quotedzputs(s, stdout);
+		    printf(" %s\n", sigs[sig]);
+		    zsfree(s);
+		}
+	    }
+	}
+	unqueue_signals();
+	return 0;
+}
+/* If we have a signal number, unset the specified *
+* signals.  With only -, remove all traps.        */
+if ((getsignum(*argv) != -1) || (!strcmp(*argv, "-") && argv++)) {
+	if (!*argv)
+	    for (sig = 0; sig < VSIGCOUNT; sig++)
+		unsettrap(sig);
+	else
+	    while (*argv)
+		unsettrap(getsignum(*argv++));
+	return 0;
+}
+/* Sort out the command to execute on trap */
+arg = *argv++;
+if (!*arg)
+	prog = &dummy_eprog;
+else if (!(prog = parse_string(arg))) {
+	zwarnnam(name, "couldn't parse trap command", NULL, 0);
+	return 1;
+}
+/* set traps */
+for (; *argv; argv++) {
+	Eprog t;
+	sig = getsignum(*argv);
+	if (sig == -1) {
+	    zwarnnam(name, "undefined signal: %s", *argv, 0);
+	    break;
+	}
+	t = dupeprog(prog, 0);
+	if (settrap(sig, t))
+	    freeeprog(t);
+}
+return *argv != NULL;
+}
+/**/
+int
+bin_ttyctl(UNUSED(char *name), UNUSED(char **argv), Options ops, UNUSED(int func))
+{
+if (OPT_ISSET(ops,'f'))
+	ttyfrozen = 1;
+else if (OPT_ISSET(ops,'u'))
+	ttyfrozen = 0;
+else
+	printf("tty is %sfrozen\n", ttyfrozen ? "" : "not ");
+return 0;
+}
+#endif //__SYMBIAN32__
+/* let -- mathematical evaluation */
+/**/
+int
+bin_let(UNUSED(char *name), char **argv, UNUSED(Options ops), UNUSED(int func))
+{
+mnumber val = zero_mnumber;
+while (*argv)
+	val = matheval(*argv++);
+/* Errors in math evaluation in let are non-fatal. */
+errflag = 0;
+/* should test for fabs(val.u.d) < epsilon? */
+return (val.type == MN_INTEGER) ? val.u.l == 0 : val.u.d == 0.0;
+}
+#ifndef __SYMBIAN32__
+/* umask command.  umask may be specified as octal digits, or in the  *
+* symbolic form that chmod(1) uses.  Well, a subset of it.  Remember *
+* that only the bottom nine bits of umask are used, so there's no    *
+* point allowing the set{u,g}id and sticky bits to be specified.     */
+/**/
+int
+bin_umask(char *nam, char **args, Options ops, UNUSED(int func))
+{
+mode_t um;
+char *s = *args;
+/* Get the current umask. */
+um = umask(0);
+umask(um);
+/* No arguments means to display the current setting. */
+if (!s) {
+	if (OPT_ISSET(ops,'S')) {
+	    char *who = "ugo";
+	    while (*who) {
+		char *what = "rwx";
+		printf("%c=", *who++);
+		while (*what) {
+		    if (!(um & 0400))
+			putchar(*what);
+		    um <<= 1;
+		    what++;
+		}
+		putchar(*who ? ',' : '\n');
+	    }
+	} else {
+	    if (um & 0700)
+		putchar('0');
+	    printf("%03o\n", (unsigned)um);
+	}
+	return 0;
+}
+if (idigit(*s)) {
+	/* Simple digital umask. */
+	um = zstrtol(s, &s, 8);
+	if (*s) {
+	    zwarnnam(nam, "bad umask", NULL, 0);
+	    return 1;
+	}
+} else {
+	/* Symbolic notation -- slightly complicated. */
+	int whomask, umaskop, mask;
+	/* More than one symbolic argument may be used at once, each separated
+	   by commas. */
+	for (;;) {
+	    /* First part of the argument -- who does this apply to?
+	       u=owner, g=group, o=other. */
+	    whomask = 0;
+	    while (*s == 'u' || *s == 'g' || *s == 'o' || *s == 'a')
+		if (*s == 'u')
+		    s++, whomask |= 0700;
+		else if (*s == 'g')
+		    s++, whomask |= 0070;
+		else if (*s == 'o')
+		    s++, whomask |= 0007;
+		else if (*s == 'a')
+		    s++, whomask |= 0777;
+	    /* Default whomask is everyone. */
+	    if (!whomask)
+		whomask = 0777;
+	    /* Operation may be +, - or =. */
+	    umaskop = (int)*s;
+	    if (!(umaskop == '+' || umaskop == '-' || umaskop == '=')) {
+		if (umaskop)
+		    zwarnnam(nam, "bad symbolic mode operator: %c", NULL, umaskop);
+		else
+		    zwarnnam(nam, "bad umask", NULL, 0);
+		return 1;
+	    }
+	    /* Permissions mask -- r=read, w=write, x=execute. */
+	    mask = 0;
+	    while (*++s && *s != ',')
+		if (*s == 'r')
+		    mask |= 0444 & whomask;
+		else if (*s == 'w')
+		    mask |= 0222 & whomask;
+		else if (*s == 'x')
+		    mask |= 0111 & whomask;
+		else {
+		    zwarnnam(nam, "bad symbolic mode permission: %c",
+			     NULL, *s);
+		    return 1;
+		}
+	    /* Apply parsed argument to um. */
+	    if (umaskop == '+')
+		um &= ~mask;
+	    else if (umaskop == '-')
+		um |= mask;
+	    else		/* umaskop == '=' */
+		um = (um | (whomask)) & ~mask;
+	    if (*s == ',')
+		s++;
+	    else
+		break;
+	}
+	if (*s) {
+	    zwarnnam(nam, "bad character in symbolic mode: %c", NULL, *s);
+	    return 1;
+	}
+}
+/* Finally, set the new umask. */
+umask(um);
+return 0;
+}
+#endif//__SYMBIAN32__
+#ifdef __SYMBIAN32__
+extern ls_internal(int, char**);
+extern cp_internal(int, char**);
+extern cat_internal(int, char**);
+extern touch_internal(int, char**);
+//generate the arguments to be passed to the _internal of
+//all the ported external commands
+char** make_arg(char* cmd, char* opts, char** argv, int argc)
+	{
+	if(!cmd)
+		return NULL;
+	else
+		{
+		int opts_exist=0;
+		char** made_arg=NULL;
+		if(opts && *opts)
+			opts_exist=1;
+		made_arg=(char**) calloc(argc+opts_exist+2, sizeof(char*));
+		if(made_arg!=NULL)
+			{
+			int index=0;
+			made_arg[index]=calloc(strlen(cmd)+1, sizeof(char));
+			if(made_arg[index])
+				{
+				int index_args=0;
+				strcpy(made_arg[index], cmd);
+				if(opts_exist)
+					{
+					made_arg[++index]=calloc(strlen(opts)+1, sizeof(char));
+					if(made_arg[index])
+						{
+						strcpy(made_arg[index], opts);
+						}
+					else
+						{
+						free(made_arg[index-1]);
+						free(made_arg);
+						return NULL;
+						}
+					}
+				while(index_args<argc)
+					{
+					made_arg[++index]=calloc(strlen(argv[index-opts_exist])+1, sizeof(char));
+					if(made_arg[index])
+						{
+						strcpy(made_arg[index],argv[index-opts_exist-1]);
+						}
+					else
+						{
+						while(index_args>0)
+							{
+							free(made_arg[index_args-1]);
+							index_args--;
+							}
+						if(opts_exist)
+							{
+							free(made_arg[1]);	//opts will be at 1;
+							}
+						free(made_arg);
+						return NULL;
+						}
+					index_args++;
+					}
+				}
+			else
+				{
+				free(made_arg);
+				return NULL;
+				}
+			made_arg[++index]=NULL; //terminate the array
+			}
+		return made_arg;
+		}
+	}
+//clear the argument list...
+void clear_arg(char** argv, int arg_cnt)
+	{
+	int cur_idx=arg_cnt-1;
+	if(arg_cnt<=0 || argv==NULL)
+		return;
+	while(cur_idx>=0)
+		{
+		free(argv[cur_idx]);
+		cur_idx--;
+		}
+	free(argv);
+	return;
+	}
+int
+bin_ls(char *name, char **argv, Options ops, UNUSED(int func))
+{
+	char** bck_up=argv;
+	int count=1; //hold the argument count...
+	int cur_idx=0; // consider - (hyphen)
+	char arg_buf[8+1];
+	int err=-1;
+	arg_buf[cur_idx]='-';
+	cur_idx++;
+	if(OPT_ISSET(ops,'1'))
+		{
+		arg_buf[cur_idx]='1';
+		cur_idx++;
+		}
+	if(OPT_ISSET(ops,'A'))
+		{
+		arg_buf[cur_idx]='A';
+		cur_idx++;
+		}
+	if(OPT_ISSET(ops,'C'))
+		{
+		arg_buf[cur_idx]='C';
+		cur_idx++;
+		}
+	if(OPT_ISSET(ops,'F'))
+		{
+		arg_buf[cur_idx]='F';
+		cur_idx++;
+		}
+	if(OPT_ISSET(ops,'L'))
+		{
+		arg_buf[cur_idx]='L';
+		cur_idx++;
+		}
+	if(OPT_ISSET(ops,'R'))
+		{
+		arg_buf[cur_idx]='R';
+		cur_idx++;
+		}
+	if(OPT_ISSET(ops,'S'))
+		{
+		arg_buf[cur_idx]='S';
+		cur_idx++;
+		}
+	if(OPT_ISSET(ops,'T'))
+		{
+		arg_buf[cur_idx]='T';
+		cur_idx++;
+		}
+	if(OPT_ISSET(ops,'W'))
+		{
+		arg_buf[cur_idx]='W';
+		cur_idx++;
+		}
+	if(OPT_ISSET(ops,'a'))
+		{
+		arg_buf[cur_idx]='a';
+		cur_idx++;
+		}
+	if(OPT_ISSET(ops,'c'))
+		{
+		arg_buf[cur_idx]='c';
+		cur_idx++;
+		}
+	if(OPT_ISSET(ops,'d'))
+		{
+		arg_buf[cur_idx]='d';
+		cur_idx++;
+		}
+	if(OPT_ISSET(ops,'f'))
+		{
+		arg_buf[cur_idx]='f';
+		cur_idx++;
+		}
+	if(OPT_ISSET(ops,'g'))
+		{
+		arg_buf[cur_idx]='g';
+		cur_idx++;
+		}
+	if(OPT_ISSET(ops,'i'))
+		{
+		arg_buf[cur_idx]='i';
+		cur_idx++;
+		}
+	if(OPT_ISSET(ops,'k'))
+		{
+		arg_buf[cur_idx]='k';
+		cur_idx++;
+		}
+	if(OPT_ISSET(ops,'l'))
+		{
+		arg_buf[cur_idx]='l';
+		cur_idx++;
+		}
+	if(OPT_ISSET(ops,'m'))
+		{
+		arg_buf[cur_idx]='m';
+		cur_idx++;
+		}
+	if(OPT_ISSET(ops,'n'))
+		{
+		arg_buf[cur_idx]='n';
+		cur_idx++;
+		}
+	if(OPT_ISSET(ops,'o'))
+		{
+		arg_buf[cur_idx]='o';
+		cur_idx++;
+		}
+	if(OPT_ISSET(ops,'p'))
+		{
+		arg_buf[cur_idx]='p';
+		cur_idx++;
+		}
+	if(OPT_ISSET(ops,'q'))
+		{
+		arg_buf[cur_idx]='q';
+		cur_idx++;
+		}
+	if(OPT_ISSET(ops,'r'))
+		{
+		arg_buf[cur_idx]='r';
+		cur_idx++;
+		}
+	if(OPT_ISSET(ops,'s'))
+		{
+		arg_buf[cur_idx]='s';
+		cur_idx++;
+		}
+	if(OPT_ISSET(ops,'t'))
+		{
+		arg_buf[cur_idx]='t';
+		cur_idx++;
+		}
+	if(OPT_ISSET(ops,'u'))
+		{
+		arg_buf[cur_idx]='u';
+		cur_idx++;
+		}
+	if(OPT_ISSET(ops,'x'))
+		{
+		arg_buf[cur_idx]='x';
+		cur_idx++;
+		}
+	if(cur_idx>1) //consider hyphen
+		{
+		arg_buf[cur_idx]='\0';
+		count++;
+		}
+	else
+		{
+		arg_buf[0]='\0';
+		cur_idx--;
+		}
+	while(argv && *argv)
+		{
+		count++;
+		argv++;
+		}
+	bck_up=make_arg("ls", &arg_buf[0], bck_up, (cur_idx>0?count-2:count-1));
+	if(bck_up)
+		{
+		err=ls_internal(count, bck_up);
+		clear_arg(bck_up, count);
+		}
+	return err;
+}
+int
+bin_cat(char *name, char **argv, Options ops, UNUSED(int func))
+{
+	char** bck_up=argv;
+	int count=1; //hold the argument count...
+	int cur_idx=0; // consider - (hyphen)
+	char arg_buf[8+1];
+	int err=-1;
+	arg_buf[cur_idx]='-';
+	cur_idx++;
+	if(OPT_ISSET(ops,'b'))
+		{
+		arg_buf[cur_idx]='b';
+		cur_idx++;
+		}
+	if(OPT_ISSET(ops,'e'))
+		{
+		arg_buf[cur_idx]='e';
+		cur_idx++;
+		}
+	if(OPT_ISSET(ops,'n'))
+		{
+		arg_buf[cur_idx]='n';
+		cur_idx++;
+		}
+	if(OPT_ISSET(ops,'s'))
+		{
+		arg_buf[cur_idx]='s';
+		cur_idx++;
+		}
+	if(OPT_ISSET(ops,'t'))
+		{
+		arg_buf[cur_idx]='t';
+		cur_idx++;
+		}
+	if(OPT_ISSET(ops,'u'))
+		{
+		arg_buf[cur_idx]='u';
+		cur_idx++;
+		}
+	if(OPT_ISSET(ops,'v'))
+		{
+		arg_buf[cur_idx]='v';
+		cur_idx++;
+		}
+	if(cur_idx>1) //consider hyphen
+		{
+		arg_buf[cur_idx]='\0';
+		count++;
+		}
+	else
+		{
+		arg_buf[0]='\0';
+		cur_idx--;
+		}
+	while(argv && *argv)
+		{
+		count++;
+		argv++;
+		}
+	bck_up=make_arg("ls", &arg_buf[0], bck_up, (cur_idx>0?count-2:count-1));
+	if(bck_up)
+		{
+		err=cat_internal(count, bck_up);
+		clear_arg(bck_up, count);
+		}
+	return err;
+}
+int
+bin_cp(char *name, char **argv, Options ops, UNUSED(int func))
+{
+	char** bck_up=argv;
+	int count=1; //hold the argument count...
+	int cur_idx=0; // consider - (hyphen)
+	char arg_buf[9+1];
+	int err=-1;
+	arg_buf[cur_idx]='-';
+	cur_idx++;
+	if(OPT_ISSET(ops,'H'))
+		{
+		arg_buf[cur_idx]='H';
+		cur_idx++;
+		}
+	if(OPT_ISSET(ops,'L'))
+		{
+		arg_buf[cur_idx]='L';
+		cur_idx++;
+		}
+	if(OPT_ISSET(ops,'P'))
+		{
+		arg_buf[cur_idx]='P';
+		cur_idx++;
+		}
+	if(OPT_ISSET(ops,'R'))
+		{
+		arg_buf[cur_idx]='R';
+		cur_idx++;
+		}
+	if(OPT_ISSET(ops,'f'))
+		{
+		arg_buf[cur_idx]='f';
+		cur_idx++;
+		}
+	if(OPT_ISSET(ops,'i'))
+		{
+		arg_buf[cur_idx]='i';
+		cur_idx++;
+		}
+	if(OPT_ISSET(ops,'p'))
+		{
+		arg_buf[cur_idx]='p';
+		cur_idx++;
+		}
+	if(OPT_ISSET(ops,'r'))
+		{
+		arg_buf[cur_idx]='r';
+		cur_idx++;
+		}
+	if(cur_idx>1) //consider hyphen
+		{
+		arg_buf[cur_idx]='\0';
+		count++;
+		}
+	else
+		{
+		arg_buf[0]='\0';
+		cur_idx--;
+		}
+	while(argv && *argv)
+		{
+		count++;
+		argv++;
+		}
+	bck_up=make_arg("ls", &arg_buf[0], bck_up, (cur_idx>0?count-2:count-1));
+	if(bck_up)
+		{
+		err=cp_internal(count, bck_up);
+		clear_arg(bck_up, count);
+		}
+	return err;
+}
+int
+bin_touch(char *name, char **argv, Options ops, UNUSED(int func))
+{
+	char** bck_up=argv;
+	int count=1; //hold the argument count...
+	int cur_idx=0; // consider - (hyphen)
+	char arg_buf[7+1];
+	int err=-1;
+	arg_buf[cur_idx]='-';
+	cur_idx++;
+	if(OPT_ISSET(ops,'a'))
+		{
+		arg_buf[cur_idx]='a';
+		cur_idx++;
+		}
+	if(OPT_ISSET(ops,'c'))
+		{
+		arg_buf[cur_idx]='c';
+		cur_idx++;
+		}
+	if(OPT_ISSET(ops,'f'))
+		{
+		arg_buf[cur_idx]='f';
+		cur_idx++;
+		}
+	if(OPT_ISSET(ops,'m'))
+		{
+		arg_buf[cur_idx]='m';
+		cur_idx++;
+		}
+	if(OPT_ISSET(ops,'r'))
+		{
+		arg_buf[cur_idx]='r';
+		cur_idx++;
+		}
+	if(OPT_ISSET(ops,'t'))
+		{
+		arg_buf[cur_idx]='t';
+		cur_idx++;
+		}
+	if(cur_idx>1) //consider hyphen
+		{
+		arg_buf[cur_idx]='\0';
+		count++;
+		}
+	else
+		{
+		arg_buf[0]='\0';
+		cur_idx--;
+		}
+	while(argv && *argv)
+		{
+		count++;
+		argv++;
+		}
+	bck_up=make_arg("ls", &arg_buf[0], bck_up, (cur_idx>0?count-2:count-1));
+	if(bck_up)
+		{
+		err=touch_internal(count, bck_up);
+		clear_arg(bck_up, count);
+		}
+	return err;
+}
+int
+bin_more(char *name, char **argv, Options ops, UNUSED(int func))
+{
+	char data[512];
+	int read_cnt;
+	if(pipeUsed==0)
+		{
+		printf("more: Usage: Supported with pipes only\n");
+		return 1;
+		}
+	if(argv && *argv)
+	   	{
+	   	printf("more: No options are supported\n");
+	   	return 1;
+	   	}
+	for(;;)
+		{
+		memset(&data[0], 0, 512);
+		read_cnt=read(0, &data[0], 512);
+		/* Comparing with -1 in case of any error other than KErrNotReady */
+		if((read_cnt==-1) || (read_cnt==0))
+			break;
+		write(1, &data[0], read_cnt);
+		fflush(stdout);
+		}
+	return 0;
+}
+#endif //__SYMBIAN32__
+/* Generic builtin for facilities not available on this OS */
+/**/
+mod_export int
+bin_notavail(char *nam, UNUSED(char **argv), UNUSED(Options ops), UNUSED(int func))
+{
+zwarnnam(nam, "not available on this system", NULL, 0);
+return 1;
+}

changeset 0	2e3d3ce01487
child 4	0fdb7f6b0309