// utils.c - miscellaneous utilities

//

// © Portions Copyright (c) Symbian Software Ltd 2007. 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.

 *

 */

#include "zsh.mdh"

#include "utils.pro"

#ifdef __SYMBIAN32__

#ifdef __WINSCW__

#pragma warn_possunwant off

#endif//__WINSCW__

#endif//__SYMBIAN32__

#ifdef __SYMBIAN32__

#include "dummy.h"

#endif //__SYMBIAN32__

#if defined(HAVE_WCHAR_H) && defined(HAVE_WCTOMB) && defined (__STDC_ISO_10646__)

# include <wchar.h>

#else

# ifdef HAVE_LANGINFO_H

#   include <langinfo.h>

#   if defined(HAVE_ICONV_H) || defined(HAVE_ICONV) || defined(HAVE_LIBICONV)

#     include <iconv.h>

#   endif

# endif

#endif

/* name of script being sourced */

/**/

char *scriptname;

/* Print an error */

/**/

mod_export void

zerr(const char *fmt, const char *str, int num)

{

    if (errflag || noerrs) {

	if (noerrs < 2)

	    errflag = 1;

	return;

    }

    zwarn(fmt, str, num);

    errflag = 1;

}

/**/

mod_export void

zerrnam(const char *cmd, const char *fmt, const char *str, int num)

{

    if (errflag || noerrs)

	return;

    zwarnnam(cmd, fmt, str, num);

    errflag = 1;

}

/**/

mod_export void

zwarn(const char *fmt, const char *str, int num)

{

    if (errflag || noerrs)

	return;

    if (isatty(2))

	trashzle();

    /*

     * scriptname is set when sourcing scripts, so that we get the

     * correct name instead of the generic name of whatever

     * program/script is running.  It's also set in shell functions,

     * so test locallevel, too.

     */

#ifdef __SYMBIAN32__     

    dup2(1, 2); //redirect stdout to stdin.

#endif//  __SYMBIAN32__  

    nicezputs((isset(SHINSTDIN) && !locallevel) ? "zsh" :

	      scriptname ? scriptname : argzero, stderr);

    fputc((unsigned char)':', stderr);

    zerrmsg(fmt, str, num);

}

/**/

mod_export void

zwarnnam(const char *cmd, const char *fmt, const char *str, int num)

{

#ifdef __SYMBIAN32__     

    dup2(1, 2); //redirect stdout to stdout.

#endif//  __SYMBIAN32__ 

    if (!cmd) {

	zwarn(fmt, str, num);

	return;

    }

    if (errflag || noerrs)

	return;

    trashzle();

    if (unset(SHINSTDIN) || locallevel) {

	nicezputs(scriptname ? scriptname : argzero, stderr);

	fputc((unsigned char)':', stderr);

    }

    nicezputs(cmd, stderr);

    fputc((unsigned char)':', stderr);

    zerrmsg(fmt, str, num);

}

#ifdef __CYGWIN__

/*

 * This works around an occasional problem with dllwrap on Cygwin, seen

 * on at least two installations.  It fails to find the last symbol

 * exported in alphabetical order (in our case zwarnnam).  Until this is

 * properly categorised and fixed we add a dummy symbol at the end.

 */

mod_export void

zz_plural_z_alpha(void)

{

}

#endif

/**/

void

zerrmsg(const char *fmt, const char *str, int num)

{

	dup2(1, 2);

    if ((unset(SHINSTDIN) || locallevel) && lineno)

	fprintf(stderr, "%ld: ", (long)lineno);

    else

	fputc((unsigned char)' ', stderr);

    while (*fmt)

	if (*fmt == '%') {

	    fmt++;

	    switch (*fmt++) {

	    case 's':

		nicezputs(str, stderr);

		break;

	    case 'l': {

		char *s;

		num = metalen(str, num);

		s = zhalloc(num + 1);

		memcpy(s, str, num);

		s[num] = '\0';

		nicezputs(s, stderr);

		break;

	    }

	    case 'd':

		fprintf(stderr, "%d", num);

		break;

	    case '%':

		putc('%', stderr);

		break;

	    case 'c':

		fputs(nicechar(num), stderr);

		break;

	    case 'e':

		/* print the corresponding message for this errno */

		if (num == EINTR) {

		    fputs("interrupt\n", stderr);

		    errflag = 1;

		    return;

		}

		/* If the message is not about I/O problems, it looks better *

		 * if we uncapitalize the first letter of the message        */

		if (num == EIO)

		    fputs(strerror(num), stderr);

		else {

		    char *errmsg = strerror(num);

		    fputc(tulower(errmsg[0]), stderr);

		    fputs(errmsg + 1, stderr);

		}

		break;

	    }

	} else {

	    putc(*fmt == Meta ? *++fmt ^ 32 : *fmt, stderr);

	    fmt++;

	}

    putc('\n', stderr);

    fflush(stderr);

}

/* Output a single character, for the termcap routines.     *

 * This is used instead of putchar since it can be a macro. */

/**/

mod_export int

putraw(int c)

{

    putc(c, stdout);

    return 0;

}

/* Output a single character, for the termcap routines. */

/**/

mod_export int

putshout(int c)

{

    putc(c, shout);

    return 0;

}

/* Turn a character into a visible representation thereof.  The visible *

 * string is put together in a static buffer, and this function returns *

 * a pointer to it.  Printable characters stand for themselves, DEL is  *

 * represented as "^?", newline and tab are represented as "\n" and     *

 * "\t", and normal control characters are represented in "^C" form.    *

 * Characters with bit 7 set, if unprintable, are represented as "\M-"  *

 * followed by the visible representation of the character with bit 7   *

 * stripped off.  Tokens are interpreted, rather than being treated as  *

 * literal characters.                                                  */

/**/

mod_export char *

nicechar(int c)

{

    static char buf[6];

    char *s = buf;

    c &= 0xff;

    if (isprint(c))

	goto done;

    if (c & 0x80) {

	if (isset(PRINTEIGHTBIT))

	    goto done;

	*s++ = '\\';

	*s++ = 'M';

	*s++ = '-';

	c &= 0x7f;

	if(isprint(c))

	    goto done;

    }

    if (c == 0x7f) {

	*s++ = '^';

	c = '?';

    } else if (c == '\n') {

	*s++ = '\\';

	c = 'n';

    } else if (c == '\t') {

	*s++ = '\\';

	c = 't';

    } else if (c < 0x20) {

	*s++ = '^';

	c += 0x40;

    }

    done:

    *s++ = c;

    *s = 0;

    return buf;

}

/* Output a string's visible representation. */

#if 0 /**/

void

nicefputs(char *s, FILE *f)

{

    for (; *s; s++)

	fputs(nicechar(STOUC(*s)), f);

}

#endif

/* Return the length of the visible representation of a string. */

/**/

size_t

nicestrlen(char *s)

{

    size_t l = 0;

    for (; *s; s++)

	l += strlen(nicechar(STOUC(*s)));

    return l;

}

/* get a symlink-free pathname for s relative to PWD */

/**/

#ifdef __SYMBIAN32__

#define SYM_ROOT '\\'

char drive;

#endif

char *

findpwd(char *s)

{

    char *t;

	drive=*s;

    if (*(s+2) == SYM_ROOT)

	return xsymlink(s);

    s = tricat((pwd[1]) ? pwd : "", "/", s);

    t = xsymlink(s);

    zsfree(s);

    return t;

}

/* Check whether a string contains the *

 * name of the present directory.      */

/**/

int

ispwd(char *s)

{

    struct stat sbuf, tbuf;

    if (stat(unmeta(s), &sbuf) == 0 && stat(".", &tbuf) == 0)

	if (sbuf.st_dev == tbuf.st_dev && sbuf.st_ino == tbuf.st_ino)

	    return 1;

    return 0;

}

static char xbuf[PATH_MAX*2];

/**/

static char **

slashsplit(char *s)

{

    char *t, **r, **q;

    int t0;

    if (!*s)

	return (char **) zshcalloc(sizeof(char **));

    for (t = s, t0 = 0; *t; t++)

	if (*t == '\\')

	    t0++;

    q = r = (char **) zalloc(sizeof(char **) * (t0 + 2));

    while ((t = strchr(s, '\\'))) {

	*q++ = ztrduppfx(s, t - s);

	while (*t == '\\')

	    t++;

	if (!*t) {

	    *q = NULL;

	    return r;

	}

	s = t;

    }

    *q++ = ztrdup(s);

    *q = NULL;

    return r;

}

/* expands symlinks and .. or . expressions */

/* if flag = 0, only expand .. and . expressions */

/**/

static int

xsymlinks(char *s)

{

    char **pp, **opp;

    char xbuf2[PATH_MAX*2], xbuf3[PATH_MAX*2];

    int t0, ret = 0;

	int init_buf=0;

    opp = pp = slashsplit(s);

    for (; *pp; pp++) {    

	if (!strcmp(*pp, ".")) {

	    zsfree(*pp);

	    continue;

	}

	if (!strcmp(*pp, "..")) {

	    char *p;

	    zsfree(*pp);

	    if (!strcmp(xbuf, "\\"))

		continue;

	    p = xbuf + strlen(xbuf);

	    while (*--p != '\\');

	    *(p+1) = '\0';

	    continue;

	}

	if(!init_buf)	

		sprintf(xbuf2, "%s%c:\\%s",xbuf,  drive, *pp);

	else

		sprintf(xbuf2, "%s\\%s", xbuf, *pp);

	t0 = readlink(unmeta(xbuf2), xbuf3, PATH_MAX);

	if (t0 == -1) {

		if(!init_buf)

			{

			strcat(xbuf, &drive);

			strcat(xbuf, ":\\");				

			}

		else

		    strcat(xbuf, "\\");

	    strcat(xbuf, *pp);

	    zsfree(*pp);

	} else {

	    ret = 1;

	    metafy(xbuf3, t0, META_NOALLOC);

	    if (*xbuf3 == '\\') {

		strcpy(xbuf, "");

		xsymlinks(xbuf3 + 1);

	    } else

		xsymlinks(xbuf3);

	    zsfree(*pp);

	}

	init_buf++;

    }

    free(opp);

    return ret;

}

/*

 * expand symlinks in s, and remove other weird things:

 * note that this always expands symlinks.

 */

/**/

char *

xsymlink(char *s)

{

    if (*(s+2) != SYM_ROOT)

	return NULL;

    *xbuf = '\0';

    xsymlinks(s + 3);

    if (!*xbuf)

	return ztrdup(s);

    return ztrdup(xbuf);

}

/**/

void

print_if_link(char *s)

{

    if (*s == '/') {

	*xbuf = '\0';

	if (xsymlinks(s + 1))

	    printf(" -> "), zputs(*xbuf ? xbuf : "/", stdout);

    }

}

/* print a directory */

/**/

void

fprintdir(char *s, FILE *f)

{

    Nameddir d = finddir(s);

    if (!d)

	fputs(unmeta(s), f);

    else {

#ifndef __SYMBIAN32__    

	putc('~', f);

	fputs(unmeta(d->nam), f);

#endif

	fputs(unmeta(s),f);

    }

}

/* Returns the current username.  It caches the username *

 * and uid to try to avoid requerying the password files *

 * or NIS/NIS+ database.                                 */

/**/

uid_t cached_uid;

/**/

char *cached_username;

/**/

char *

get_username(void)

{

#ifdef HAVE_GETPWUID

    struct passwd *pswd;

    uid_t current_uid;

    current_uid = getuid();

    if (current_uid != cached_uid) {

	cached_uid = current_uid;

	zsfree(cached_username);

	if ((pswd = getpwuid(current_uid)))

	    cached_username = ztrdup(pswd->pw_name);

	else

	    cached_username = ztrdup("");

    }

#else /* !HAVE_GETPWUID */

    cached_uid = getuid();

#endif /* !HAVE_GETPWUID */

    return cached_username;

}

/* static variables needed by finddir(). */

static char *finddir_full;

static Nameddir finddir_last;

static int finddir_best;

/* ScanFunc used by finddir(). */

/**/

static void

finddir_scan(HashNode hn, UNUSED(int flags))

{

    Nameddir nd = (Nameddir) hn;

#ifdef __SYMBIAN32__

	flags=flags;

#endif

    if(nd->diff > finddir_best && !dircmp(nd->dir, finddir_full)