Usenet 1994 October/usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso/misc/volume8/make.gy/part01/tstring.c

C/C++ Source or Header | 1989-11-02 | 5.3 KB | 320 lines

/*
 * tstring.c
 *
 * 88-10-01 v1.0    created by greg yachuk, placed in the public domain
 * 88-10-06 v1.1    changed prerequisite list handling
 * 88-11-11 v1.2    fixed some bugs and added environment variables
 * 89-07-12 v1.3    stop appending shell commands, and flush output
 * 89-08-01 v1.4 AB    lots of new options and code
 * 89-10-30 v1.5 greggy    -f -S -q options, took some changes from v1.4
 *
 */
#include <stdio.h>
#include <ctype.h>
#include <malloc.h>
#include <string.h>

#include "tstring.h"


char   *
talloc(n)
int     n;
{
    register char *s;

    s = malloc(n);
    if (s == NULL)
        terror(1, "no free memory");
    return (s);
}


char   *
trealloc(s, n)
register char *s;
int     n;
{
    s = realloc(s, n);
    if (s == NULL)
        talloc(n);    /* force an error */
    return (s);
}


char   *
tstrncpy(s, n)
register char *s;
int     n;
{
    s = strncpy(talloc(n + 1), s, n);
    s[n] = '\0';
    return (s);
}


terror(n, s)
int     n;
char   *s;
{
    fputs("Make: ", stderr);
    fputs(s, stderr);
    putc('\n', stderr);
    if (n)
        exit(n);
}


/*
 * tstrspan -    move to the end of a quoted string, ignoring escaped quotes
 */
char   *
tstrspan(str)
char   *str;
{
    char    quote;

    if (*str != '\'' && *str != '"')
        return (str + 1);

    quote = *str++;

    while (*str && *str != quote)
    {
        /* check for escaped quote */
        if (*str == '\\' && str[1] == quote)
            ++str;
        ++str;
    }

    return (str);
}


/*
 * tunquote -    remove quotes from a string
 */
char   *
tunquote(str)
char   *str;
{
    char   *s;
    char   *d;

    d = s = str;

    while (*s)
    {
        while (*s && *s == '"')
            ++s;

        while (*s && *s != '"')
            *d++ = *s++;
    }

    *d = '\0';

    return (str);
}


/*
 * tsplit -    split a string into two components, normally a directory
 *        path and a filename.  If a pointer to a directory is
 *        supplied, a string is allocated to contain the directory.
 *        The filename is returned as a pointer into the supplied
 *        string.
 */
char   *
tsplit(s, seps, dp)
char   *s;
char   *seps;
char  **dp;
{
    char   *d;        /* directory portion */
    char   *f;        /* file portion */

    d = s;

    /* find the final separator */
    while ((f = strpbrk(d, seps)) != NULL)
        d = f + 1;

    /* back up to final component */
    f = d;

    /* if we are still at the beginning, there was no Directory */
    if (d == s || dp == NULL)
        d = NULL;
    else
    {
        int     len;

        /*
         * by the time we get here, d points to the final separator
         * char.  we can substitute a NULL for this sep-char.  Thus,
         * we don't need to add 1 in the following length
         * calculation.
         */
        len = d - s;

        d = talloc(len);
        d[--len] = '\0';
        while (--len >= 0)
            d[len] = s[len];
    }

    if (dp != NULL)
        *dp = d;

    return (f);
}


/*
 * token    - take an input string and return a token each call
 *        - default token delimiter characters are `isspace()'
 *        - separator chars are in addition to `isspace()'
 *        - text between quotes (" and ') is a single token
 *        - if requested, the separator char is returned
 *
 *    called as    s = token(string, seps, &schar);
 *        or    s = token(string, NULL, NULL);
 *
 *    followed by    s = token(NULL, seps, NULL);
 *        or    s = token(NULL, NULL, &schar);
 *
 *    returns NULL when no more tokens are available
 */
char   *
token(s, sep, schar)
char   *s;
char   *sep;
char   *schar;
{
    static char *olds = NULL;

    if (s)
        olds = s;    /* we are starting all over again */

    if (schar)
        *schar = '\0';

    if (!olds || !*olds)
        return (NULL);    /* no tokens left */

    while (isspace(*olds) || (sep && strchr(sep, *olds)))
        ++olds;        /* skip leading spaces and sep's */

    if (*olds == NULL)
        return (NULL);    /* remainder is all separator's */

    s = olds;

    while (*olds)
    {
        if (isspace(*olds) || (sep && strchr(sep, *olds)))
        {
            if (schar)
                *schar = *olds;
            *olds++ = '\0';    /* delimit the token */
            return (s);
        }
        else if (*olds == '"' || *olds == '\'')
        {
            olds = tstrspan(olds);
            if (*olds != '\0')
                ++olds;    /* didn't hit eos, so skip quote */
        }
        else
            ++olds;    /* otherwise, pass over char */
    }

    olds = NULL;
    return (s);        /* return last token */
}


/*
 * tokenize    - chop a string up into an array of (char *)'s
 */
char  **
tokenize(input)
char   *input;
{
    char  **argv;
    register int argc = 0;
    register int alen;

    alen = 20;        /* good initial guess */
    argv = (char **) talloc((alen + 1) * sizeof(char *));

    input = token(input, NULL, NULL);    /* use default separators */
    while (input)
    {
        if (alen == argc)
            argv = (char **) trealloc((char *) argv,
                         (alen <<= 1) * sizeof(char *));
        argv[argc++] = input;
        input = token(NULL, NULL, NULL);
    }

    argv[argc] = NULL;    /* mark end of array */

    return (argv);
}


/*
 * tgets    - read input, swallowing escaped newlines as necessary
 */
char   *
tgets(fd)
FILE   *fd;
{
    static char *input = NULL;
    static int inlen = 0;
    register char *ep;
    int     len;

    if (inlen == 0)
        input = talloc(inlen = 162);

    input[inlen - 2] = '\n';
    ep = input - 1;
    while ((fgets(input, inlen, fd)) != NULL)
    {
        for (;;)
        {
            while (input[inlen - 2] != '\n' && input[inlen - 2] != '\0')
            {
                len = inlen;
                input = trealloc(input, inlen <<= 1);
                ep = &input[len - 2];
                input[inlen - 2] = '\n';
                fgets(ep + 1, len + 1, fd);
            }

            while (*++ep);
            *--ep = '\0';
            do
            {
                --ep;
            } while (ep >= input && isspace(*ep));

            if (ep > input && *ep == '\\' && *--ep != '\\')
                fgets(ep + 1, inlen - (ep - input) - 1, fd);
            else
                break;
        }

        return (input);
    }

    inlen = 0;
    tfree(input);
    input = NULL;

    return (NULL);
}