Openstep 4.2 (Developer)/Openstep Developer 4.2.iso/NextDeveloper/Source/GNU/make/make-3.74/next.c

C/C++ Source or Header | 1996-02-28 | 5.2 KB | 229 lines

#if NeXT || NeXT_PDO
#include "make.h"
#include "commands.h"
#include "file.h"
#include "variable.h"
#include "dep.h"
#include <sys/types.h>
#include <sys/stat.h>

#if !__STDC__
#define const
#endif

/* Search through a pathlist for a file.  `search_path' will parse `path',
 * a list of pathnames separated by colons, prepending each pathname to
 * `filename'.  The resulting filename will be checked for existence via
 * stat().
 */
static int
search_path(path, file)
    const char *path;
    char **file;
{
    int n, length;
    char *filename, *name;
    const char *nextchar, *lastchar;

    filename = *file;
    n = strlen(filename);
    length = strlen(path) + n + 10;
    name = alloca(length) + length - 1;
    *name = '\0';

    filename += n;
    while (--n >= 0)
    *--name = *--filename;

    if (*name == '/' || path == 0)
    path = "";

    /* Strip off leading './'s, if any. */
    while (*name == '.' && *(name + 1) == '/')
    name += 2;

    do {
    /* Advance to the end of the next path in our path list. */
    nextchar = path;
#if defined (__MSDOS__) || defined (WIN32)
    while ((*nextchar != '\0' && *nextchar != ':' && !isspace (*nextchar))
    || (*nextchar == ':' && nextchar - path == 1
      && (nextchar[1] == '/' || nextchar[1] == '\\')))
        nextchar++;
#else
    while (*nextchar != '\0' && *nextchar != ':' && !isspace (*nextchar))
        nextchar++;
#endif

    lastchar = nextchar;
    filename = name;

    /* If we actually have a path, prepend the file name with a '/'. */
    if (nextchar != path)
        *--filename = '/';

    /* Prepend the file name with the path. */
    while (nextchar != path)
        *--filename = *--nextchar;

    path = (*lastchar) ? lastchar + 1 : lastchar;

    {
        struct stat s;
        if (stat(filename, &s) >= 0) {
        /* We have found a file.
         * Store the name we found into *FILE for the caller.  */
        *file = savestring(filename, strlen(filename));
        return (1);
        }
    }
    } while (*path != 0);
    return (0);
}

int
general_vpath_search(file)
    char **file;
{
    int s;
    int savelen;
    char *vpath, *save;

    save = save_variable_output(&savelen);
    vpath = variable_expand ("$(VPATH)");
    if (**file == '/' || *vpath == '\0') {
    restore_variable_output(save, savelen);
    return 0;
    }
    s = search_path(vpath, file);
    restore_variable_output(save, savelen);
    return s;
}

static int
match_dep(filename, file)
    char **filename;
    struct file *file;
{
    struct dep *d;

    /* don't substitute for . or .. */
    if (!strcmp (*filename, ".") || !strcmp (*filename, ".."))
        return 0;

    for (d = file->deps; d != 0; d = d->next) {
    if (d->file->old_name != 0) {
        if (strcmp(*filename, d->file->old_name) == 0) {
        *filename = dep_name(d);
        return 1;
        }
    }
    if (strcmp(*filename, dep_name(d)) == 0) {
        if (general_vpath_search(filename))
        return 1;
    }
    }
    return 0;
}

/* Scan LINE for vpath references. */

static char *
vpath_expand(line, file)
    char *line;
    struct file *file;
{
    struct variable *v;
    char *p, *p1, *o;
    static char *meta = 0;

    if (meta == 0) {
    static char buffer[256] = {0};
    meta = buffer;
    meta['\0'] = 1;
    for (p = "=|^();&<>*?[]:$`'\"\\\n"; *p != 0; p++)
        meta[*p] = 1;
    }

    p = line;
    o = initialize_variable_output ();

    while (1) {
    /* Copy all following uninteresting chars all at once to the
       variable output buffer, and skip them.  Uninteresting chars end
       at the next space or semicolon. */

    for (p1 = p; *p1 != 0 && (isspace(*p1) || meta[*p1]); p1++)
        ;
    o = variable_buffer_output (o, p, p1 - p);
    if (*p1 == 0)
        break;
    p = p1;
    while (*p1 != 0 && !(isspace(*p1) || meta[*p1]))
        p1++;
    {
        unsigned int n = p1 - p;
        char *buffer = malloc(n + 1);
        char *filename = buffer;
        struct dep *dep;

        strncpy(filename, p, n);
        filename[n] = 0;

        if (match_dep(&filename, file)) {
        static struct file *last_file = 0;
        if (last_file != file) {
            last_file = file;
            if (!(next_flag & NEXT_QUIET_FLAG)) {
              makefile_error(file->cmds->filename, file->cmds->lineno,
                     "Using old-style VPATH substitution.");
              makefile_error(file->cmds->filename, file->cmds->lineno,
                     "Consider using automatic variable substitution instead.");
            }
        }
        o = variable_buffer_output (o, filename, strlen(filename));
        } else {
        o = variable_buffer_output (o, filename, n);
        }
        p = p1;
        free(buffer);
    }
    if (*p == '\0')
        break;
    }
    (void) variable_buffer_output (o, "", 1);
    return initialize_variable_output ();
}

char *
allocated_vpath_expand_for_file(line, file)
    char *line;
    struct file *file;
{
    char *save, *value;
    struct variable_set_list *save_set_list;
    int savelen;

    if (file == 0)
    makefile_fatal("Can't do VPATH expansion on a null file.\n");

    save = save_variable_output (&savelen);

    save_set_list = current_variable_set_list;
    current_variable_set_list = file->variables;
    reading_filename = file->cmds->filename;
    reading_lineno_ptr = &file->cmds->lineno;
    value = vpath_expand (line, file);
    current_variable_set_list = save_set_list;
    reading_filename = 0;
    reading_lineno_ptr = 0;


    value = savestring (value, strlen (value));

    restore_variable_output (save, savelen);

    return value;
}
#endif    /* NeXT || NeXT_PDO */