/*_ filespec.c   Mon Jul  3 1989   Modified by: Walter Bright */

/* Copyright (C) 1986-1987 by Northwest Software        */

/* All Rights Reserved                                  */

/* Written by Walter Bright                             */



/* Package with which to manipulate filespecs   */



#include        <stdio.h>

#include        "filespec.h"



#ifndef MEM_H

#include        "mem.h"

#endif



#ifndef VAX11C

#include <string.h>

#endif



#if BSDUNIX

#include        <pwd.h>

#endif



#if MSDOS || __OS2__ || __NT__ || _WIN32

#include        <direct.h>

#include        <ctype.h>

#endif



#if M_UNIX || M_XENIX || linux || __APPLE__ || __FreeBSD__ || __OpenBSD__ || __sun&&__SVR4

#include        <stdlib.h>

#include        <unistd.h>

#endif



#ifndef assert

#include        <assert.h>

#endif



/* Macro to determine if char is a path or drive delimiter      */

#if MSDOS || __OS2__ || __NT__ || _WIN32

#define ispathdelim(c)  ((c) == '\\' || (c) == ':' || (c) == '/')

#else

#ifdef VMS

#define ispathdelim(c)  ((c)==':' || (c)=='[' || (c)==']' )

#else

#ifdef MPW

#define ispathdelim(c)  ((c) == ':')

#else

#define ispathdelim(c)  ((c) == '/')

#endif /* MPW */

#endif /* VMS */

#endif



/**********************/



char * filespecaddpath(const char *path,const char *filename)

{   register char *filespec;

    register unsigned pathlen;



    if (!path || (pathlen = strlen(path)) == 0)

        filespec = mem_strdup(filename);

    else

    {

        filespec = (char *) mem_malloc(pathlen + 1 + strlen(filename) + 1);

        if (filespec)

        {   strcpy(filespec,path);

#if MSDOS || __OS2__ || __NT__ || _WIN32

            if (!ispathdelim(filespec[pathlen - 1]))

                strcat(filespec,"\\");

#else

#if VMS

#else

#if MPW

            if (!ispathdelim(filespec[pathlen - 1]))

                strcat(filespec,":");

#else

            if (!ispathdelim(filespec[pathlen - 1]))

                strcat(filespec,"/");

#endif /* MPW   */

#endif /* VMS   */

#endif

            strcat(filespec,filename);

        }

    }

    return filespec;

}



#ifndef MPW

/**********************/

char * filespecrootpath(char *filespec)

{

#if SUN || M_UNIX || M_XENIX || linux || __APPLE__ || __FreeBSD__ || __OpenBSD__ || __sun&&__SVR4

#define DIRCHAR '/'

#endif

#if MSDOS || __OS2__ || __NT__ || _WIN32

#define DIRCHAR '\\'

#endif

#ifdef MPW

#define DIRCHAR ':'

#endif



    char *cwd, *cwd_t;

    char *p, *p2;



    if (!filespec)

        return filespec;

#if MSDOS || __OS2__ || __NT__ || _WIN32

    /* if already absolute (with \ or drive:) ... */

    if (*filespec == DIRCHAR || (isalpha((unsigned char)*filespec) && *(filespec+1) == ':'))

        return filespec;        /*      ... return input string */

#else

    if (*filespec == DIRCHAR)   /* already absolute ... */

        return filespec;        /*      ... return input string */

#endif



    /* get current working directory path */

#if SUN || M_UNIX || M_XENIX || linux || __APPLE__ || __FreeBSD__ || __OpenBSD__ || __sun&&__SVR4

    cwd_t = (char *)getcwd(NULL, 256);

#endif

#if MSDOS || __OS2__ || __NT__ || _WIN32

    char cwd_d[132];

    if (getcwd(cwd_d, sizeof(cwd_d)))

       cwd_t = cwd_d;

    else

       cwd_t = NULL;

#endif



    if (cwd_t == NULL)

    {

        mem_free(filespec);

        return NULL;    /* error - path too long (more than 256 chars !)*/

    }

    cwd = mem_strdup(cwd_t);    /* convert cwd to mem package */

#if MSDOS

    assert(strlen(cwd) > 0);

    if (cwd[strlen(cwd) - 1] == DIRCHAR)

        cwd[strlen(cwd) - 1] = '\0';

#endif

#if SUN || M_UNIX || M_XENIX || linux || __APPLE__ || __FreeBSD__ || __OpenBSD__ || __sun&&__SVR4

    free(cwd_t);

#endif

    p = filespec;

    while (p != NULL)

    {

        p2 = (char *)strchr(p, DIRCHAR);

        if (p2 != NULL)

        {

            *p2 = '\0';

            if (strcmp(p, "..") == 0)   /* move up cwd */

                /* remove last directory from cwd */

                *((char *)strrchr(cwd, DIRCHAR)) = '\0';

            else if (strcmp(p, ".") != 0) /* not current directory */

            {

                cwd_t = cwd;

                cwd = (char *)mem_calloc(strlen(cwd_t) + 1 + strlen(p) + 1);

#if SUN || M_UNIX || M_XENIX || linux || __APPLE__ || __FreeBSD__ || __OpenBSD__ || __sun&&__SVR4

                sprintf(cwd, "%s/%s", cwd_t, p);  /* add relative directory */

#endif

#if MSDOS || __OS2__ || __NT__ || _WIN32

                sprintf(cwd, "%s\\%s", cwd_t, p);  /* add relative directory */

#endif

                mem_free(cwd_t);

            }

            /* else if ".", then ignore - it means current directory */

            *p2 = DIRCHAR;

            p2++;

        }

        else if (strcmp(p,"..") == 0)   /* move up cwd */

        {

            /* remove last directory from cwd */

            *((char *)strrchr(cwd, DIRCHAR)) = '\0';

        }

        else if (strcmp(p,".") != 0) /* no more subdirectories ... */

        {   /* ... save remaining string */

            cwd_t = cwd;

            cwd = (char *)mem_calloc(strlen(cwd_t) + 1 + strlen(p) + 1);

#if SUN || M_UNIX || M_XENIX || linux || __APPLE__ || __FreeBSD__ || __OpenBSD__ || __sun&&__SVR4

            sprintf(cwd, "%s/%s", cwd_t, p);  /* add relative directory */

#endif

#if MSDOS || __OS2__ || __NT__ || _WIN32

            sprintf(cwd, "%s\\%s", cwd_t, p);  /* add relative directory */

#endif

            mem_free(cwd_t);

        }

        p = p2;

    }

    mem_free(filespec);



    return cwd;

#ifdef VMS

    assert(0);

#endif

}

#endif



/**********************/



char * filespecdotext(const char *filespec)

{   register const char *p;

    register int len;



    if ((p = filespec) != NULL)

    {   p += (len = strlen(p));

        while (1)

        {       if (*p == '.')

                    break;

                if (p <= filespec || ispathdelim(*p))

                {   p = filespec + len;

                    break;

                }

                p--;

        }

    }

    return (char *)p;

}



/**********************/



char * filespecname(const char *filespec)

{   register const char *p;



    /* Start at end of string and back up till we find the beginning    */

    /* of the filename or a path.                                       */

    for (p = filespec + strlen(filespec);

         p != filespec && !ispathdelim(*(p - 1));

         p--

        )

            ;

    return (char *)p;

}



/***********************/



char * filespecgetroot(const char *name)

{       char *root,*p,c;



        p = filespecdotext(name);

        c = *p;

        *p = 0;

        root = mem_strdup(name);

        *p = c;

        return root;

}



/*****************************/



char * filespecforceext(const char *filespec,const char *ext)

{   register char *p;

    register const char *pext;



    if (*ext == '.')

        ext++;

    if ((p = (char *)filespec) != NULL)

    {   pext = filespecdotext(filespec);

        if (ext)

        {   int n = pext - filespec;

            p = (char *) mem_malloc(n + 1 + strlen(ext) + 1);

            if (p)

            {   memcpy(p,filespec,n);

                p[n] = '.';

                strcpy(&p[n + 1],ext);

            }

        }

        else

            p = mem_strdup(filespec);

    }

    return p;

}



/*****************************/



char * filespecdefaultext(const char *filespec,const char *ext)

{       register char *p;

        register const char *pext;



        pext = filespecdotext(filespec);

        if (*pext == '.')               /* if already got an extension  */

        {

            p = mem_strdup(filespec);

        }

        else

        {   int n = pext - filespec;

            p = (char *) mem_malloc(n + 1 + strlen(ext) + 1);

            if (p)

            {

                memcpy(p,filespec,n);

                p[n] = '.';

                strcpy(&p[n + 1],ext);

            }

        }

        return p;

}



/************************************/



#if !(MSDOS || __OS2__ || __NT__ || _WIN32)



char *filespectilde(char *filespec)

{

#if BSDUNIX

    struct passwd *passwdPtr;

    register char *f;



    if (filespec && *filespec == '~')

    {

        passwdPtr = NULL;

        if (filespec[1] == '/' || filespec[1] == 0)     /* if ~/... or ~ */

        {   f = filespec + 1;

            passwdPtr = getpwuid(getuid());

        }

        else                            /* else ~name   */

        {

            char c;



            f = strpbrk(filespec," /");

            if (!f)

                f = filespec + strlen(filespec); /* point at trailing 0 */

            c = *f;

            *f = 0;

            passwdPtr = getpwnam(filespec + 1);

            *f = c;

        }

        if (passwdPtr)

        {   char *p;



            p = (char *) mem_malloc(strlen(passwdPtr->pw_dir) + strlen(f) + 1);

            if (p)

            {

                strcpy(p,passwdPtr->pw_dir);

                strcat(p,f);

                mem_free(filespec);

                filespec = p;

            }

        }

    }

#endif

#if MSDOS || __OS2__ || __NT__ || _WIN32

#endif

#if VMS

    assert(0);

#endif

    return filespec;

}



/************************************/



char *filespecmultitilde(char *string)

{

    register char *p, *p2, *p3, *p4;



    string = filespectilde(string);     /* expand if first character is a '~' */



    if (string)

    {

       for (p = string; *p != '\0'; p++)

       {

           if (*p == '~')

           {

              *p = '\0';        /* terminate sub string */

              p2 = mem_strdup(string); /* get new sub string from old string */

              *p = '~'; /* reset ~ character */

              for (p3 = p + 1; *p3 != ' ' && *p3 != '\0'; p3++)

                  ; /* scan to next name, or end of the string */

              p4 = NULL;

              if (*p3 == ' ')

              {

                 p4 = mem_strdup(p3);  /* save reminder of the string */

                 *p3 = '\0';

              }

              p = mem_strdup(p);    /* get tilde string */

              mem_free(string);

              p = filespectilde(p);



              /* reconstruct the string from pieces */

              if (p4)

              {

                 string = (char *)

                       mem_calloc(strlen(p2) + strlen(p) + strlen(p4) + 1);

                 sprintf(string, "%s%s%s", p2, p, p4);

              }

              else

              {

                 string = (char *)

                       mem_calloc(strlen(p2) + strlen(p) + 1);

                 sprintf(string, "%s%s", p2, p);

              }

              mem_free(p);

              p = string + strlen(p2) + 2;

              mem_free(p2);

              if (p4)

                 mem_free(p4);

           }

       }

    }

    return string;

}



#endif



#ifndef MPW

/************************************/



char * filespecbackup(const char *filespec)

{

#if MSDOS || __OS2__ || __NT__ || _WIN32

    return filespecforceext(filespec,"BAK");

#endif

#if BSDUNIX || linux || __APPLE__ || __FreeBSD__ || __OpenBSD__ || __sun&&__SVR4

    char *p,*f;



    /* Prepend .B to file name, if it isn't already there       */

    if (!filespec)

        return (char *)filespec;

    p = filespecname(filespec);

    if (p[0] == '.' && p[1] == 'B')

        return mem_strdup(filespec);

    f = (char *) mem_malloc(strlen(filespec) + 2 + 1);

    if (f)

    {   strcpy(f,filespec);

        strcpy(&f[p - filespec],".B");

        strcat(f,p);

    }

    return f;

#endif

}

#endif