reduce-historical/r36/cslbase/filename.c

/* filename.c                 Copyright (C) 1995-1997 Codemist Ltd */

/* Signature: 63e0f8da 26-Jan-1999 */

/*
 * Map file-names to expand references to shell variables etc.
 * and to provide portability of names across operating systems.
 */

static char *look_in_lisp_variable(char *o, int prefix)
{
    Lisp_Object nil, var;
/*
 * I will start by tagging a '$' (or whatever) on in front of the
 * parameter name.
 */
    o[0] = prefix;
    var = make_undefined_symbol(o);
    nil = C_nil;
/*
 * make_undefined_symbol() could fail either if we had utterly run out
 * of memory or if somebody generated an interrupt (eg ^C) around now. Ugh.
 */
    if (exception_pending())
    {   flip_exception();
        return NULL;
    }
/*
 * If the variable $name was undefined then I use an empty replacement
 * text for it. Otherwise I need to look harder at its value.
 */
    if (qvalue(var) == unset_var) return o;
    else
    {   Header h;
        int32 len;
        var = qvalue(var);
/*
 * Mostly I expect that the value will be a string or symbol.
 */
#ifdef COMMON
        if (complex_stringp(var))
        {   var = simplify_string(var);
            nil = C_nil;
            if (exception_pending())
            {   flip_exception();
                return NULL;
            }
        }
#endif /* COMMON */
        if (symbolp(var))
        {   var = get_pname(var);
            nil = C_nil;
            if (exception_pending())
            {   flip_exception();
                return NULL;
            }
            h = vechdr(var);
        }
        else if (!is_vector(var) ||
                 type_of_header(h = vechdr(var)) != TYPE_STRING)
            return NULL;
        len = length_of_header(h) - 4;
/*
 * Copy the characters from the string or from the name of the variable
 * into the file-name buffer. There could at present be a crash here
 * if the expansion was very very long and overflowed my buffer. Tough
 * luck for now - people doing that (maybe) get what they (maybe) deserve.
 */
        memcpy(o, (char *)var + (4L- TAG_VECTOR), (size_t)len);
        o = o + len;
        return o;
    }
}

static void process_file_name(char *filename, char *old, size_t n)
/*
 * This procedure maps filenames by expanding some environment
 * variables.  It is very thoroughly system specific, which is why it
 * is in this file.  See also LONGEST_LEGAL_FILENAME in "tags.h" for a
 * limit on the permitted size of an expanded filename.
 * The input (old) is not necessarily properly terminated as a C string,
 * so n says how many characters to inspect.  Build a converted name
 * in filename.
 * At present the expansions I allow are:
 *
 *    $xxx   (terminated by '.', '/' or '\' with at least one char x)
 *    ${xxx} (self-terminating)
 *           First check for a Lisp variable $xxx. If this is set (and is
 *           a string or a symbol) then its value is used. If not then
 *           next inspect the environment variable xxx and dump its
 *           value into the output.  If the variable is unset then a check
 *           is made for the value of a global lisp variable called @xxx,
 *           and if that exists and is a string or symbol it is used.
 *           If @xxx is undefined a null string is inserted.
 *           If one of the variables is defined but has an improper value
 *           then the whole file-translation fails.
 *           The use of two Lisp variables makes it possible to control
 *           precedence between these and shell variables.
 *
 *    ~      ) followed by '.', '/' or '\'
 *    ~xxx   )
 *           On Unix these try to find home directories using
 *           getpwuid(getuid()) for '~' and getpwnam() for ~xxx.
 *           If that fails ~ expands into nothing at all.
 *           This syntax is only recognised at the very start of a file-name.
 *           For systems other than Unix this syntax will not be useful and
 *           should be avoided, however as an experimental place-holder I
 *           may do things with environment variables called HOME etc.
 * 
 * 
 * I convert file-names of the form aaa/bbb/ccc.ddd into something
 * acceptable to the system being used, even though this may result in
 * some native file titles that include '/' characters becoming unavailable.
 * The reasoning here is that scripts and programs can then use Unix-like
 * names and non-Unix hosts will treat them forgivingly.
 *
 *
 */
#ifdef __vmsvax__
/*
 * This is maybe going to be a mess under VAX/VMS, but I will try
 * pretending that is still Unix for now since the VMS C runtime system
 * seems prepared to help a little in that case.
 */
#endif /* __vmsvax__ */
{
    int32 i, j;
    int c;
    char *o, *tail;
    if (n == 0)
    {   *filename = 0;
        return;    /* deem zero-length name to be illegal */
    }
    o = filename;
    c = *old;
/*
 * First I deal with a leading "~"
 */
    if (c == '~')
    {   old++;
        n--;
        while (n != 0)
        {   c = *old;
            if (c == '.' || c == '/' || c == '\\') break;
            old++;
            n--;
            *o++ = c;
        }
        *o = 0;
/*
 * actually deciding what the home directory is is passed down to a
 * system-specific call, but it is not to be relied upon especially
 * on personal computers.
 */
        if (o == filename)  /* '~' on its own */
        {   get_home_directory(filename, LONGEST_LEGAL_FILENAME);
            o = filename + strlen(filename);
        }
        else
        {   get_users_home_directory(filename, LONGEST_LEGAL_FILENAME);
            o = filename + strlen(filename);
        }
    }
/*
 * Having copies a user-name across (if there was one) I now copy the
 * rest of the file-name, expanding $xxx and ${xxx} as necessary.
 */
    while (n != 0)
    {   c = *old++;
        n--;
/*
 * If I find a "$" that is either at the end of the file-name or that is
 * immediately followed by ".", "/" or "\" then I will not use it for
 * parameter expansion. This at least gives me some help with the RISCOS
 * file-name $.abc.def where the "$" is used to indicate the root of the
 * current disc.
 */
        if (c == '$' && n != 0 &&
            (c = *old) != '.' && c != '/' && c != '\\')
        {   char *p = o, *w;
/*
 * I collect the name of the parameter at the end of my file-name buffer,
 * but will over-write it later on when I actually do the expansion.
 */
            if (c == '{')
            {   old++;
                n--;
                while (n != 0)
                {   c = *old++;
                    n--;
                    if (c == '}') break;
                    *p++ = c;
                }
            }
            else
            {   while (n != 0)
                {   c = *old;
                    if (c == '.' || c == '/' || c == '\\') break;
                    old++;
                    n--;
                    *p++ = c;
                }
            }
            *p = 0;
            i = strlen(o) + 2;
            while (i-- != 0) o[i] = o[i-1];
            if ((p = look_in_lisp_variable(o, '$')) != NULL &&
                p != o) o = p;
            else if ((w = my_getenv(o+1)) != NULL)    /* Shell variable? */
            {   strcpy(o, w);
                o = o + strlen(o);
            }
            else if ((p = look_in_lisp_variable(o, '@')) != NULL)
                o = p;
            else
            {   *filename = 0;  /* return reporting failure */
                return;
            }
        }
        else *o++ = c;
    }
    *o = 0;

#ifdef NOT_TOTALLY_DEBUGGED
    term_printf("[temp trace] File-name expands to \"%s\"\n", filename);
#endif

#ifdef MS_DOS
/*
 * Now the filename has had $ and ~ prefix things expanded - I "just"
 * need to deal with sub-directory representation issues. Specifically I need
 * to map "/" separators into "\" so that if a user presents a file
 * name such as aaa/bbb/ccc.d it gets passed to the operating system
 * as aaa\bbb\ccc.d
 * NOte that I enable this code under the heading MS_DOS but really it
 * means any file-system (eg Windows too) that uses "\" as its main
 * directory separator character.
 */
 
/*
 * I map / characters in MSDOS filenames into \s, so that users
 * can give file names with Unix-like slashes as separators if they want.
 * People who WANT to use filenames with '/' in them will be hurt.
 */
    tail = filename;
    while ((j = *tail) != 0)
    {   if (j == '/') *tail = '\\';
        tail++;
    }

/*
 * stat and friends do not like directories referred to as "\foo\", so check
 * for a trailing slash, being careful to respect directories with names
 * like "\" and "a:\".
 */
   j = strlen(filename);
   if (j > 0 && j != 1 && !(j == 3 && *(filename+1) == ':'))
   {
       if ( (*(tail - 1) == '\\')) *(tail - 1) = 0;
   }
#ifdef __WATCOMC__
/*
 * There is a bug in the stat function under some releases of Watcom C, where:
 *  stat("\\foo\\..", ...);
 * fails with errno=-1.  So we delete trailing ".." segments.
 */
   if (filename[0] == '\\' || filename[1] == ':')
   {   j = strlen(filename);
       while (filename[j-1] == '.' && filename[j-2] == '.')
       {   tail = strrchr(filename, '\\');
/*
 * Warning - the aerror0() function sets an internal flag to indicate
 * that something went wrong, and then returns. Thus if further processing
 * is not valid in one of these cases some explicit control flow (maybe a
 * "return") is called for,
 */
           if (tail == NULL)
               aerror0("Unexpected pathname - this error should never happen");
           else *tail = '\0';
           tail = strrchr(filename, '\\');
           if (tail == NULL)
               aerror0("Unexpected pathname - this error should never happen");
           else *tail = '\0';
           j = strlen(filename);
       }

       /* Make sure we don't have an empty string or just a drive */
       if (j == 0) strcpy(filename,"\\");
       else if (j==2 && filename[1] == ':') strcat(filename,"\\");
   }
#endif /* __WATCOMC__ */

#ifdef EIGHT_PLUS_THREE
/*
 * A *NASTY* hack here. I will explicitly truncate the name down to
 * and 8+3 format to keep as much DOS compatibility as I (in)conveniently can.
 * This is done here because if a user attempts to open a file with a long
 * name Windows 95 will try to honour the request and will then get confused
 * if old-style W3.x or DOS utilities made the file with a truncated name.
 * I rather think that this ought not to be wanted any more, especially if
 * it is possible to accept that raw DOS and Windows before 95 need not
 * be supported, but I will leave this in the code just in case!
 */
    tail = filename;
    eight_plus_three(tail);
    while ((j=*tail++)!=0) if (j=='\\' || j==':') eight_plus_three(tail);
#endif /* EIGHT_PLUS_THREE */
#endif /* MS_DOS */

#ifdef MACINTOSH
/*
 * Now the filename has had $ and ~ prefix things expanded - I "just"
 * need to deal with sub-directory representation issues. Specifically I need
 * to map "/" separators into "\" so that if a user presents a file
 * name such as aaa/bbb/ccc.d it gets passed to the operating system
 * as aaa\bbb\ccc.d
 * NOte that I enable this code under the heading MS_DOS but really it
 * means any file-system (eg Windows too) that uses "\" as its main
 * directory separator character.
 */
 
/*
 * I map '/'characters in Macintosh filenames into ':'s, so that users
 * can give file names with Unix-like slashes as separators if they want.
 * People who WANT to use filenames with '/' in them will be hurt.
 * Furthermore if the name originally had no colons in it a leading colon is
 * added, and if it originally started with a '/' (for a Unix fully rooted name)
 * then the leading ':' or '/' is removed.
 */
    tail = filename;
    while ((j = *tail) != 0 && j != ':') tail++;
    if (j == 0)
    {   memmove(&filename[1], filename, 1+strlen(filename));
        filename[0] = ':';
    }
    if (filename[0] == '/') memmove(filename, &filename[1], strlen(filename));
    tail = filename;
    while ((j = *tail) != 0)
    {   if (j == '/') *tail = ':';
        tail++;
    }
/*
 * I map the string :..: onto just :: to cope with Unix-format references to
 * the parent directory
 */
    i = 0;
    while ((c = filename[i]) != 0)
    {   if (c == ':' &&
            filename[i+1] == '.' &&
            filename[i+2] == '.' &&
            filename[i+3] == ':')
        {   j = i+1;
            do
            {   c = filename[j+2];
                filename[j++] = c;
            } while (c != 0);
        }
        i++;
    }
#endif /* MACINTOSH */

#ifdef RISCOS
/*
 * Now the filename has had $ and ~ prefix things expanded - I "just"
 * need to deal with sub-directory representation issues.
 */

/*
 * The Archimedes is best coped with by re-mapping file names
 * so that xxxx.y sometimes becomes y.xxxx
 */
 
    i = strlen(filename);
    for (j=i-1; j>=0; j--) if (filename[j] == '.') break;
    if (j >= 0)   /* No '.' => no possible conversion */
    {   tail = &filename[j+1];
        if (j == i - 2 ||               /* one character suffix */
/*
 * At present my policy is that any file with a one-character final
 * component gets mangled, and that as a special case files of
 * the form xxx.lsp, xxx.red, xxx.fsl and xxx.log are also flipped.
 */
          strcmp(tail, "lsp") == 0 ||
            strcmp(tail, "red") == 0 ||
            strcmp(tail, "fsl") == 0 ||
            strcmp(tail, "tst") == 0 ||
            strcmp(tail, "sl")  == 0 ||
            strcmp(tail, "log") == 0)
        {   int32 k;
            char suffix[8];
            for (k=j-1; k>=0; k--)
                if (filename[k] == '.' || filename[k] == '/') break;
            strcpy(suffix, tail);
            strcat(suffix, ".");
            do filename[--i] = filename[--j]; while (j > k);
            memcpy(&filename[k+1], suffix, (size_t)(i - j));
        }
    }
/*
 * Now if in the Unix world I had a component '..' in the file it will
 * appear something like //.aaa.bbb or aaa.//.bbb
 * Similarly I map an isolated '.' (now an isolated '/') into '@'.
 */
    {   int32 k = 0;
        j = -1;
        c = '/';
        for (;;)
        {   if (c == '/' || c == 0)
            {   if (j == k+1 && filename[k] == '.') filename[k] = '@';
                else if (j == k + 2 && filename[k] == '.' && filename[k+1] == '.')
                {   int c1;
                    filename[k++] = '^';
                    do
                    {   c1 = filename[k+1];
                        filename[k++] = c1;
                    } while (c1 != 0);
                }
                k = j+1;
            }
            if (c == 0) break;
            j++;
            c = filename[j];
        }
    }
/*
 * I map / characters in RISCOS filenames into dots, so that users
 * can give file names with Unix-like slashes as separators if they want.
 * People who WANT to use filenames with '/' in them will be hurt.
 * Note also that when files are created for output an attempt to open
 * (e.g.) "arthur.red" will fail unless the directory "red" already
 * exists.
 */
    tail = filename;
    while ((j = *tail) != 0)
    {   if (j == '/') *tail = '.';
        tail++;
    }
    if (*filename == '.')   /* Deal with fully-rooted Unix filenames */
    {   tail[1] = 0;
        while (tail != filename)
        {   tail--;
            tail[1] = tail[0];
        }
        tail[0] = '$';
    }
#endif /* RISCOS */
}


FILE *open_file(char *filename, char *old, size_t n,
                char *mode, FILE *old_file)
{
/*
 * mode is something like "r" or "w" or "rb", as needed by fopen(),
 * and old_file is NULL normally, but can be a (FILE *) to indicate
 * the use of freopen rather than fopen.
 */
    process_file_name(filename, old, n);
    if (*filename == 0) return NULL;
#ifdef NO_BINARY_FOPEN
/*
 * On some Unix implementations (I mean DECs version on its MIPS workstations
 * and on the microvax I tried) the library does not support "rb" and "wb"
 * modes, so I work around that here.  Explicit selection of binary file
 * access will be needed on some non-Unix operating systems, but should
 * never be relevant under Unix, hence my choice of a flag for the conditional
 * compilation here.
 */
    if (mode[0] == 'w')
    {   if (mode[1] == '+') mode = "w+";
        else mode = "w";
    }
    else if (mode[1] == '+') mode = "r+";
    else mode = "r";    /* That ought to patch it up */
#endif

    if (old_file == NULL) return fopen(filename, mode);
    else return freopen(filename, mode, old_file);
}

/* end of filename.c */