/*
*   $Id: routines.c,v 1.18 2003/07/20 22:48:37 darren Exp $
*
*   Copyright (c) 2002-2003, Darren Hiebert
*
*   This source code is released for free distribution under the terms of the
*   GNU General Public License.
*
*   This module contains a lose assortment of shared functions.
*/

/*
*   INCLUDE FILES
*/
#include "general.h"	/* must always come first */

#ifdef HAVE_STDLIB_H
# include <stdlib.h>	/* to declare malloc (), realloc () */
#endif
#include <ctype.h>
#include <string.h>
#include <stdarg.h>
#include <errno.h>
#include <stdio.h>	/* to declare tempnam(), and SEEK_SET (hopefully) */

#ifdef HAVE_FCNTL_H
# include <fcntl.h>	/* to declar O_RDWR, O_CREAT, O_EXCL */
#endif
#ifdef HAVE_UNISTD_H
# include <unistd.h>	/* to declare mkstemp () */
#endif

/*  To declare "struct stat" and stat ().
 */
#if defined (HAVE_SYS_TYPES_H)
# include <sys/types.h>
#else
# if defined (HAVE_TYPES_H)
#  include <types.h>
# endif
#endif
#ifdef HAVE_SYS_STAT_H
# include <sys/stat.h>
#else
# ifdef HAVE_STAT_H
#  include <stat.h>
# endif
#endif

#ifdef HAVE_DOS_H
# include <dos.h>	/* to declare MAXPATH */
#endif
#ifdef HAVE_DIRECT_H
# include <direct.h>	/* to _getcwd */
#endif
#ifdef HAVE_DIR_H
# include <dir.h>	/* to declare findfirst() and findnext() */
#endif
#ifdef HAVE_IO_H
# include <io.h>	/* to declare open() */
#endif
#include "debug.h"
#include "routines.h"

#ifdef TRAP_MEMORY_CALLS
# include "safe_malloc.h"
#endif

/*
*   MACROS
*/
#ifndef TMPDIR
# define TMPDIR "/tmp"
#endif

/*  File type tests.
 */
#ifndef S_ISREG
# if defined (S_IFREG) && ! defined (AMIGA)
#  define S_ISREG(mode)	    ((mode) & S_IFREG)
# else
#  define S_ISREG(mode)	    TRUE	/* assume regular file */
# endif
#endif

#ifndef S_ISLNK
# ifdef S_IFLNK
#  define S_ISLNK(mode)	    (((mode) & S_IFMT) == S_IFLNK)
# else
#  define S_ISLNK(mode)	    FALSE	/* assume no soft links */
# endif
#endif

#ifndef S_ISDIR
# ifdef S_IFDIR
#  define S_ISDIR(mode)	    (((mode) & S_IFMT) == S_IFDIR)
# else
#  define S_ISDIR(mode)	    FALSE	/* assume no soft links */
# endif
#endif

#ifndef S_IFMT
# define S_IFMT 0
#endif

#ifndef S_IXUSR
# define S_IXUSR 0
#endif
#ifndef S_IXGRP
# define S_IXGRP 0
#endif
#ifndef S_IXOTH
# define S_IXOTH 0
#endif

#ifndef S_IRUSR
# define S_IRUSR 0400
#endif
#ifndef S_IWUSR
# define S_IWUSR 0200
#endif

#ifndef S_ISUID
# define S_ISUID 0
#endif

/*  Hack for rediculous practice of Microsoft Visual C++.
 */
#if defined (WIN32)
# if defined (_MSC_VER)
#  define stat    _stat
#  define getcwd  _getcwd
#  define currentdrive() (_getdrive() + 'A' - 1)
#  define PATH_MAX  _MAX_PATH
# elif defined (__BORLANDC__)
#  define PATH_MAX  MAXPATH
#  define currentdrive() (getdisk() + 'A')
# else
#  define currentdrive() 'C'
# endif
#endif

#ifndef PATH_MAX
# define PATH_MAX 256
#endif

/*
 *  Miscellaneous macros
 */
#define selected(var,feature)	(((int)(var) & (int)(feature)) == (int)feature)

/*
*   DATA DEFINITIONS
*/
#if defined (MSDOS_STYLE_PATH)
const char *const PathDelimiters = ":/\\";
#elif defined (VMS)
const char *const PathDelimiters = ":]>";
#endif

char *CurrentDirectory;

static const char *ExecutableProgram;
static const char *ExecutableName;

/*
*   FUNCTION PROTOTYPES
*/
#ifdef NEED_PROTO_STAT
extern int stat (const char *, struct stat *);
#endif
#ifdef NEED_PROTO_LSTAT
extern int lstat (const char *, struct stat *);
#endif
#if defined (MSDOS) || defined (WIN32) || defined (VMS) || defined (__EMX__) || defined (AMIGA)
# define lstat(fn,buf) stat(fn,buf)
#endif

/*
*   FUNCTION DEFINITIONS
*/

extern void setExecutableName (const char *const path)
{
    ExecutableProgram = path;
    ExecutableName = baseFilename (path);
#ifdef VAXC
{
    /* remove filetype from executable name */
    char *p = strrchr (ExecutableName, '.');
    if (p != NULL)
	*p = '\0';
}
#endif
}

extern const char *getExecutableName (void)
{
    return ExecutableName;
}

extern void error (const errorSelection selection,
		   const char *const format, ...)
{
    va_list ap;

    va_start (ap, format);
    fprintf (errout, "%s: %s", getExecutableName (),
	    selected (selection, WARNING) ? "Warning: " : "");
    vfprintf (errout, format, ap);
    if (selected (selection, PERROR))
#ifdef HAVE_STRERROR
	fprintf (errout, " : %s", strerror (errno));
#else
	perror (" ");
#endif
    fputs ("\n", errout);
    va_end (ap);
    if (selected (selection, FATAL))
	exit (1);
}

/*
 *  Memory allocation functions
 */

extern void *eMalloc (const size_t size)
{
    void *buffer = malloc (size);

    if (buffer == NULL)
	error (FATAL, "out of memory");

    return buffer;
}

extern void *eCalloc (const size_t count, const size_t size)
{
    void *buffer = calloc (count, size);

    if (buffer == NULL)
	error (FATAL, "out of memory");

    return buffer;
}

extern void *eRealloc (void *const ptr, const size_t size)
{
    void *buffer;
    if (ptr == NULL)
	buffer = eMalloc (size);
    else
    {
	buffer = realloc (ptr, size);
	if (buffer == NULL)
	    error (FATAL, "out of memory");
    }
    return buffer;
}

extern void eFree (void *const ptr)
{
    Assert (ptr != NULL);
    free (ptr);
}

/*
 *  String manipulation functions
 */

/*
 * Compare two strings, ignoring case.
 * Return 0 for match, < 0 for smaller, > 0 for bigger
 * Make sure case is folded to uppercase in comparison (like for 'sort -f')
 * This makes a difference when one of the chars lies between upper and lower
 * ie. one of the chars [ \ ] ^ _ ` for ascii. (The '_' in particular !)
 */
extern int struppercmp (const char *s1, const char *s2)
{
    int result;
    do
    {
	result = toupper ((int) *s1) - toupper ((int) *s2);
    } while (result == 0  &&  *s1++ != '\0'  &&  *s2++ != '\0');
    return result;
}

extern int strnuppercmp (const char *s1, const char *s2, size_t n)
{
    int result;
    do
    {
	result = toupper ((int) *s1) - toupper ((int) *s2);
    } while (result == 0  &&  --n > 0  &&  *s1++ != '\0'  &&  *s2++ != '\0');
    return result;
}

#ifndef HAVE_STRSTR
extern char* strstr (const char *str, const char *substr)
{
    const size_t length = strlen (substr);
    const char *match = NULL;
    const char *p;

    for (p = str  ;  *p != '\0'  &&  match == NULL  ;  ++p)
	if (strncmp (p, substr, length) == 0)
	    match = p;
    return (char*) match;
}
#endif

extern char* eStrdup (const char* str)
{
    char* result = xMalloc (strlen (str) + 1, char);
    strcpy (result, str);
    return result;
}

extern void toLowerString (char* str)
{
    while (*str != '\0')
    {
	*str = tolower ((int) *str);
	++str;
    }
}

extern void toUpperString (char* str)
{
    while (*str != '\0')
    {
	*str = toupper ((int) *str);
	++str;
    }
}

/*  Newly allocated string containing lower case conversion of a string.
 */
extern char* newLowerString (const char* str)
{
    char* const result = xMalloc (strlen (str) + 1, char);
    int i = 0;
    do
	result [i] = tolower ((int) str [i]);
    while (str [i++] != '\0');
    return result;
}

/*  Newly allocated string containing upper case conversion of a string.
 */
extern char* newUpperString (const char* str)
{
    char* const result = xMalloc (strlen (str) + 1, char);
    int i = 0;
    do
	result [i] = toupper ((int) str [i]);
    while (str [i++] != '\0');
    return result;
}

/*
 * File system functions
 */

extern void setCurrentDirectory (void)
{
#ifndef AMIGA
    char* buf;
#endif
    if (CurrentDirectory == NULL)
	CurrentDirectory = xMalloc ((size_t) (PATH_MAX + 1), char);
#ifdef AMIGA
    strcpy (CurrentDirectory, ".");
#else
    buf = getcwd (CurrentDirectory, PATH_MAX);
    if (buf == NULL)
	perror ("");
#endif
    if (CurrentDirectory [strlen (CurrentDirectory) - (size_t) 1] !=
	    PATH_SEPARATOR)
    {
	sprintf (CurrentDirectory + strlen (CurrentDirectory), "%c",
		OUTPUT_PATH_SEPARATOR);
    }
}

#ifdef AMIGA
static boolean isAmigaDirectory (const char *const name)
{
    boolean result = FALSE;
    struct FileInfoBlock *const fib = xMalloc (1, struct FileInfoBlock);
    if (fib != NULL)
    {
	const BPTR flock = Lock ((UBYTE *) name, (long) ACCESS_READ);

	if (flock != (BPTR) NULL)
	{
	    if (Examine (flock, fib))
		result = ((fib->fib_DirEntryType >= 0) ? TRUE : FALSE);
	    UnLock (flock);
	}
	eFree (fib);
    }
    return result;
}
#endif

/* For caching of stat() calls */
extern fileStatus *eStat (const char *const fileName)
{
    struct stat status;
    static fileStatus file;
    if (file.name == NULL  ||  strcmp (fileName, file.name) != 0)
    {
	if (file.name != NULL)
	    eFree (file.name);
	file.name = eStrdup (fileName);
	if (lstat (file.name, &status) != 0)
	    file.exists = FALSE;
	else
	{
	    file.isSymbolicLink = (boolean) S_ISLNK (status.st_mode);
	    if (file.isSymbolicLink  &&  stat (file.name, &status) != 0)
		file.exists = FALSE;
	    else
	    {
		file.exists = TRUE;
#ifdef AMIGA
		file.isDirectory = isAmigaDirectory (file.name);
#else
		file.isDirectory = (boolean) S_ISDIR (status.st_mode);
#endif
		file.isNormalFile = (boolean) (S_ISREG (status.st_mode));
		file.isExecutable = (boolean) ((status.st_mode &
		    (S_IXUSR | S_IXGRP | S_IXOTH)) != 0);
		file.isSetuid = (boolean) ((status.st_mode & S_ISUID) != 0);
		file.size = status.st_size;
	    }
	}
    }
    return &file;
}

extern boolean doesFileExist (const char *const fileName)
{
    fileStatus *status = eStat (fileName);
    return status->exists;
}

extern boolean isRecursiveLink (const char* const dirName)
{
    boolean result = FALSE;
    fileStatus *status = eStat (dirName);
    if (status->isSymbolicLink)
    {
	char* const path = absoluteFilename (dirName);
	while (path [strlen (path) - 1] == PATH_SEPARATOR)
	    path [strlen (path) - 1] = '\0';
	while (! result  &&  strlen (path) > (size_t) 1)
	{
	    char *const separator = strrchr (path, PATH_SEPARATOR);
	    if (separator == NULL)
		break;
	    else if (separator == path)	/* backed up to root directory */
		*(separator + 1) = '\0';
	    else
		*separator = '\0';
	    result = isSameFile (path, dirName);
	}
	eFree (path);
    }
    return result;
}

#ifndef HAVE_FGETPOS

extern int fgetpos (FILE *stream, fpos_t *pos)
{
    int result = 0;

    *pos = ftell (stream);
    if (*pos == -1L)
	result = -1;

    return result;
}

extern int fsetpos (FILE *stream, fpos_t const *pos)
{
    return fseek (stream, *pos, SEEK_SET);
}

#endif

/*
 *  Pathname manipulation (O/S dependent!!!)
 */

static boolean isPathSeparator (const int c)
{
    boolean result;
#if defined (MSDOS_STYLE_PATH) || defined (VMS)
    result = (boolean) (strchr (PathDelimiters, c) != NULL);
#else
    result = (boolean) (c == PATH_SEPARATOR);
#endif
    return result;
}

#if ! defined (HAVE_STAT_ST_INO)

static void canonicalizePath (char *const path __unused__)
{
#if defined (MSDOS_STYLE_PATH)
    char *p;
    for (p = path  ;  *p != '\0'  ;  ++p)
	if (isPathSeparator (*p)  &&  *p != ':')
	    *p = PATH_SEPARATOR;
#endif
}

#endif

extern boolean isSameFile (const char *const name1, const char *const name2)
{
    boolean result = FALSE;
#if defined (HAVE_STAT_ST_INO)
    struct stat stat1, stat2;

    if (stat (name1, &stat1) == 0  &&  stat (name2, &stat2) == 0)
	result = (boolean) (stat1.st_ino == stat2.st_ino);
#else
    {
	char *const n1 = absoluteFilename (name1);
	char *const n2 = absoluteFilename (name2);
	canonicalizePath (n1);
	canonicalizePath (n2);
# if defined (CASE_INSENSITIVE_FILENAMES)
	result = (boolean) (strcasecmp (n1, n2) == 0);
#else
	result = (boolean) (strcmp (n1, n2) == 0);
#endif
	free (n1);
	free (n2);
    }
#endif
    return result;
}

extern const char *baseFilename (const char *const filePath)
{
#if defined (MSDOS_STYLE_PATH) || defined (VMS)
    const char *tail = NULL;
    unsigned int i;

    /*  Find whichever of the path delimiters is last.
     */
    for (i = 0  ;  i < strlen (PathDelimiters)  ;  ++i)
    {
	const char *sep = strrchr (filePath, PathDelimiters [i]);

	if (sep > tail)
	    tail = sep;
    }
#else
    const char *tail = strrchr (filePath, PATH_SEPARATOR);
#endif
    if (tail == NULL)
	tail = filePath;
    else
	++tail;			/* step past last delimiter */
#ifdef VAXC
    {
	/* remove version number from filename */
	char *p = strrchr ((char *) tail, ';');
	if (p != NULL)
	    *p = '\0';
    }
#endif

    return tail;
}

extern const char *fileExtension (const char *const fileName)
{
    const char *extension;
    const char *pDelimiter = NULL;
    const char *const base = baseFilename (fileName);
#ifdef QDOS
    pDelimiter = strrchr (base, '_');
#endif
    if (pDelimiter == NULL)
        pDelimiter = strrchr (base, '.');

    if (pDelimiter == NULL)
	extension = "";
    else
	extension = pDelimiter + 1;	/* skip to first char of extension */

    return extension;
}

extern boolean isAbsolutePath (const char *const path)
{
    boolean result = FALSE;
#if defined (MSDOS_STYLE_PATH)
    if (isPathSeparator (path [0]))
	result = TRUE;
    else if (isalpha (path [0])  &&  path [1] == ':')
    {
	if (isPathSeparator (path [2]))
	    result = TRUE;
	else
	    /*  We don't support non-absolute file names with a drive
	     *  letter, like `d:NAME' (it's too much hassle).
	     */
	    error (FATAL,
		"%s: relative file names with drive letters not supported",
		path);
    }
#elif defined (VMS)
    result = (boolean) (strchr (path, ':') != NULL);
#else
    result = isPathSeparator (path [0]);
#endif
    return result;
}

extern vString *combinePathAndFile (
    const char *const path, const char *const file)
{
    vString *const filePath = vStringNew ();
#ifdef VMS
    const char *const directoryId = strstr (file, ".DIR;1");

    if (directoryId == NULL)
    {
	const char *const versionId = strchr (file, ';');

	vStringCopyS (filePath, path);
	if (versionId == NULL)
	    vStringCatS (filePath, file);
	else
	    vStringNCatS (filePath, file, versionId - file);
	vStringCopyToLower (filePath, filePath);
    }
    else
    {
	/*  File really is a directory; append it to the path.
	 *  Gotcha: doesn't work with logical names.
	 */
	vStringNCopyS (filePath, path, strlen (path) - 1);
	vStringPut (filePath, '.');
	vStringNCatS (filePath, file, directoryId - file);
	if (strchr (path, '[') != NULL)
	    vStringPut (filePath, ']');
	else
	    vStringPut (filePath, '>');
	vStringTerminate (filePath);
    }
#else
    const int lastChar = path [strlen (path) - 1];
    boolean terminated = isPathSeparator (lastChar);

    vStringCopyS (filePath, path);
    if (! terminated)
    {
	vStringPut (filePath, OUTPUT_PATH_SEPARATOR);
	vStringTerminate (filePath);
    }
    vStringCatS (filePath, file);
#endif

    return filePath;
}

/* Return a newly-allocated string whose contents concatenate those of
 * s1, s2, s3.
 * Routine adapted from Gnu etags.
 */
static char* concat (const char *s1, const char *s2, const char *s3)
{
  int len1 = strlen (s1), len2 = strlen (s2), len3 = strlen (s3);
  char *result = xMalloc (len1 + len2 + len3 + 1, char);

  strcpy (result, s1);
  strcpy (result + len1, s2);
  strcpy (result + len1 + len2, s3);
  result [len1 + len2 + len3] = '\0';

  return result;
}

/* Return a newly allocated string containing the absolute file name of FILE
 * given CWD (which should end with a slash).
 * Routine adapted from Gnu etags.
 */
extern char* absoluteFilename (const char *file)
{
    char *slashp, *cp;
    char *res = NULL;
    if (isAbsolutePath (file))
    {
#ifdef MSDOS_STYLE_PATH
	if (file [1] == ':')
	    res = eStrdup (file);
	else
	{
	    char drive [3];
	    sprintf (drive, "%c:", currentdrive ());
	    res = concat (drive, file, "");
	}
printf ("absolute of %s = %s\n", file, res);
#else
	res = eStrdup (file);
#endif
    }
    else
	res = concat (CurrentDirectory, file, "");

    /* Delete the "/dirname/.." and "/." substrings. */
    slashp = strchr (res, PATH_SEPARATOR);
    while (slashp != NULL  &&  slashp [0] != '\0')
    {
	if (slashp[1] == '.')
	{
	    if (slashp [2] == '.' &&
		(slashp [3] == PATH_SEPARATOR || slashp [3] == '\0'))
	    {
		cp = slashp;
		do
		    cp--;
		while (cp >= res  &&  ! isAbsolutePath (cp));
		if (cp < res)
		    cp = slashp;/* the absolute name begins with "/.." */
#ifdef MSDOS_STYLE_PATH
		/* Under MSDOS and NT we get `d:/NAME' as absolute file name,
		 * so the luser could say `d:/../NAME'. We silently treat this
		 * as `d:/NAME'.
		 */
		else if (cp [0] != PATH_SEPARATOR)
		    cp = slashp;
#endif
		strcpy (cp, slashp + 3);
		slashp = cp;
		continue;
	    }
	    else if (slashp [2] == PATH_SEPARATOR  ||  slashp [2] == '\0')
	    {
		strcpy (slashp, slashp + 2);
		continue;
	    }
	}
	slashp = strchr (slashp + 1, PATH_SEPARATOR);
    }

    if (res [0] == '\0')
	return eStrdup ("/");
    else
    {
#ifdef MSDOS_STYLE_PATH
	/* Canonicalize drive letter case. */
	if (res [1] == ':'  &&  islower (res [0]))
	    res [0] = toupper (res [0]);
#endif

	return res;
    }
}

/* Return a newly allocated string containing the absolute file name of dir
 * where `file' resides given `CurrentDirectory'.
 * Routine adapted from Gnu etags.
 */
extern char* absoluteDirname (char *file)
{
    char *slashp, *res;
    char save;
    slashp = strrchr (file, PATH_SEPARATOR);
    if (slashp == NULL)
	res = eStrdup (CurrentDirectory);
    else
    {
	save = slashp [1];
	slashp [1] = '\0';
	res = absoluteFilename (file);
	slashp [1] = save;
    }
    return res;
}

/* Return a newly allocated string containing the file name of FILE relative
 * to the absolute directory DIR (which should end with a slash).
 * Routine adapted from Gnu etags.
 */
extern char* relativeFilename (const char *file, const char *dir)
{
    const char *fp, *dp;
    char *absdir, *res;
    int i;

    /* Find the common root of file and dir (with a trailing slash). */
    absdir = absoluteFilename (file);
    fp = absdir;
    dp = dir;
    while (*fp++ == *dp++)
	continue;
    fp--;
    dp--;			/* back to the first differing char */
    do
    {				/* look at the equal chars until path sep */
	if (fp == absdir)
	    return absdir;	/* first char differs, give up */
	fp--;
	dp--;
    } while (*fp != PATH_SEPARATOR);

    /* Build a sequence of "../" strings for the resulting relative file name.
     */
    i = 0;
    while ((dp = strchr (dp + 1, PATH_SEPARATOR)) != NULL)
	i += 1;
    res = xMalloc (3 * i + strlen (fp + 1) + 1, char);
    res [0] = '\0';
    while (i-- > 0)
	strcat (res, "../");

    /* Add the file name relative to the common root of file and dir. */
    strcat (res, fp + 1);
    free (absdir);

    return res;
}

extern FILE *tempFile (const char *const mode, char **const pName)
{
    char *name;
    FILE *fp;
    int fd;
#if defined(HAVE_MKSTEMP)
    const char *const pattern = "tags.XXXXXX";
    const char *tmpdir = NULL;
    fileStatus *file = eStat (ExecutableProgram);
    if (! file->isSetuid)
	tmpdir = getenv ("TMPDIR");
    if (tmpdir == NULL)
	tmpdir = TMPDIR;
    name = xMalloc (strlen (tmpdir) + 1 + strlen (pattern) + 1, char);
    sprintf (name, "%s%c%s", tmpdir, OUTPUT_PATH_SEPARATOR, pattern);
    fd = mkstemp (name);
#elif defined(HAVE_TEMPNAM)
    name = tempnam (TMPDIR, "tags");
    if (name == NULL)
	error (FATAL | PERROR, "cannot allocate temporary file name");
    fd = open (name, O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR);
#else
    name = xMalloc (L_tmpnam, char);
    if (tmpnam (name) != name)
	error (FATAL | PERROR, "cannot assign temporary file name");
    fd = open (name, O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR);
#endif
    if (fd == -1)
	error (FATAL | PERROR, "cannot open temporary file");
    fp = fdopen (fd, mode);
    if (fp == NULL)
	error (FATAL | PERROR, "cannot open temporary file");
    DebugStatement (
	debugPrintf (DEBUG_STATUS, "opened temporary file %s\n", name); )
    Assert (*pName == NULL);
    *pName = name;
    return fp;
}

/* vi:set tabstop=8 shiftwidth=4: */
