URL https://opencores.org/ocsvn/or1k/or1k/trunk
Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [uClibc/] [libc/] [misc/] [wordexp/] [wordexp.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

/* vi: set sw=4 ts=4: */
/* POSIX.2 wordexp implementation.
   Copyright (C) 1997, 1998, 1999 Free Software Foundation, Inc.
   This file is part of the GNU C Library.
   Contributed by Tim Waugh <tim@cyberelk.demon.co.uk>.
 
   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public License as
   published by the Free Software Foundation; either version 2 of the
   License, or (at your option) any later version.
 
   The GNU C Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.
 
   You should have received a copy of the GNU Library General Public
   License along with the GNU C Library; see the file COPYING.LIB.  If not,
   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */
 
#define _GNU_SOURCE
#include <sys/cdefs.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <paths.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pwd.h>
#include <errno.h>
#include <assert.h>
#include <fnmatch.h>
#include <glob.h>
#include <wordexp.h>
 
#define __WORDEXP_FULL
//#undef __WORDEXP_FULL
 
/*
 * This is a recursive-descent-style word expansion routine.
 */
 
/* These variables are defined and initialized in the startup code.  */
//extern int __libc_argc;
//extern char **__libc_argv;
 
/* FIXME!!!! */
int __libc_argc;
char **__libc_argv;
 
/* Some forward declarations */
static int parse_dollars(char **word, size_t * word_length,
                                                 size_t * max_length, const char *words,
                                                 size_t * offset, int flags, wordexp_t * pwordexp,
                                                 const char *ifs, const char *ifs_white,
                                                 int quoted);
static int parse_backtick(char **word, size_t * word_length,
                                                  size_t * max_length, const char *words,
                                                  size_t * offset, int flags, wordexp_t * pwordexp,
                                                  const char *ifs, const char *ifs_white);
static int parse_dquote(char **word, size_t * word_length,
                                                size_t * max_length, const char *words,
                                                size_t * offset, int flags, wordexp_t * pwordexp,
                                                const char *ifs, const char *ifs_white);
 
 
 
/* The w_*() functions manipulate word lists. */
#define W_CHUNK (100)
 
/* Result of w_newword will be ignored if it's the last word. */
static inline char *w_newword(size_t * actlen, size_t * maxlen)
{
        *actlen = *maxlen = 0;
        return NULL;
}
 
/* Add a character to the buffer, allocating room for it if needed.  */
static inline char *w_addchar(char *buffer, size_t * actlen,
                                                          size_t * maxlen, char ch)
         /* (lengths exclude trailing zero) */
{
 
        if (*actlen == *maxlen) {
                char *old_buffer = buffer;
                assert(buffer == NULL || *maxlen != 0);
                *maxlen += W_CHUNK;
                buffer = realloc(buffer, 1 + *maxlen);
                if (buffer == NULL)
                        free(old_buffer);
        }
 
        if (buffer != NULL) {
                buffer[*actlen] = ch;
                buffer[++(*actlen)] = '\0';
        }
 
        return buffer;
}
 
#define MAX( a, b ) ( ( ( a ) > ( b ) ) ? ( a ) : ( b ) )
static char *w_addmem(char *buffer, size_t * actlen, size_t * maxlen,
                                          const char *str, size_t len)
{
        /* Add a string to the buffer, allocating room for it if needed.
         */
        if (*actlen + len > *maxlen) {
                char *old_buffer = buffer;
                assert(buffer == NULL || *maxlen != 0);
                *maxlen += MAX(2 * len, W_CHUNK);
                buffer = realloc(old_buffer, 1 + *maxlen);
                if (buffer == NULL)
                        free(old_buffer);
        }
 
        if (buffer != NULL) {
                *((char *) mempcpy(&buffer[*actlen], str, len)) = '\0';
                *actlen += len;
        }
        return buffer;
}
 
/* Add a string to the buffer, allocating room for it if needed.  */
static char *w_addstr(char *buffer, size_t * actlen, size_t * maxlen,
                                          const char *str)
         /* (lengths exclude trailing zero) */
{
        size_t len;
        assert(str != NULL);            /* w_addstr only called from this file */
        len = strlen(str);
 
        return w_addmem(buffer, actlen, maxlen, str, len);
}
 
/* Add a word to the wordlist */
static int w_addword(wordexp_t * pwordexp, char *word)
{
        size_t num_p;
        char **new_wordv;
 
        /* Internally, NULL acts like "".  Convert NULLs to "" before
         * the caller sees them.
         */
        if (word == NULL) {
                word = strdup("");
                if (word == NULL)
                        goto no_space;
        }
 
        num_p = 2 + pwordexp->we_wordc + pwordexp->we_offs;
        new_wordv = realloc(pwordexp->we_wordv, sizeof(char *) * num_p);
        if (new_wordv != NULL) {
                pwordexp->we_wordv = new_wordv;
                pwordexp->we_wordv[pwordexp->we_offs + pwordexp->we_wordc++] = word;
                pwordexp->we_wordv[pwordexp->we_offs + pwordexp->we_wordc] = NULL;
                return 0;
        }
 
  no_space:
        return WRDE_NOSPACE;
}
 
/* The parse_*() functions should leave *offset being the offset in 'words'
 * to the last character processed.
 */
static int
parse_backslash(char **word, size_t * word_length, size_t * max_length,
                                const char *words, size_t * offset)
{
        /* We are poised _at_ a backslash, not in quotes */
 
        switch (words[1 + *offset]) {
        case 0:
                /* Backslash is last character of input words */
                return WRDE_SYNTAX;
 
        case '\n':
                ++(*offset);
                break;
 
        default:
                *word = w_addchar(*word, word_length, max_length, words[1 + *offset]);
                if (*word == NULL)
                        return WRDE_NOSPACE;
 
                ++(*offset);
                break;
        }
 
        return 0;
}
 
static int
parse_qtd_backslash(char **word, size_t * word_length, size_t * max_length,
                                        const char *words, size_t * offset)
{
        /* We are poised _at_ a backslash, inside quotes */
 
        switch (words[1 + *offset]) {
        case 0:
                /* Backslash is last character of input words */
                return WRDE_SYNTAX;
 
        case '\n':
                ++(*offset);
                break;
 
        case '$':
        case '`':
        case '"':
        case '\\':
                *word =
                        w_addchar(*word, word_length, max_length, words[1 + *offset]);
                if (*word == NULL)
                        return WRDE_NOSPACE;
 
                ++(*offset);
                break;
 
        default:
                *word = w_addchar(*word, word_length, max_length, words[*offset]);
                if (*word != NULL)
                        *word =
                                w_addchar(*word, word_length, max_length,
                                                  words[1 + *offset]);
 
                if (*word == NULL)
                        return WRDE_NOSPACE;
 
                ++(*offset);
                break;
        }
 
        return 0;
}
 
static int
parse_tilde(char **word, size_t * word_length, size_t * max_length,
                        const char *words, size_t * offset, size_t wordc)
{
        /* We are poised _at_ a tilde */
        size_t i;
 
        if (*word_length != 0) {
                if (!((*word)[*word_length - 1] == '=' && wordc == 0)) {
                        if (!((*word)[*word_length - 1] == ':'
                                  && strchr(*word, '=') && wordc == 0)) {
                                *word = w_addchar(*word, word_length, max_length, '~');
                                return *word ? 0 : WRDE_NOSPACE;
                        }
                }
        }
 
        for (i = 1 + *offset; words[i]; i++) {
                if (words[i] == ':' || words[i] == '/' || words[i] == ' ' ||
                        words[i] == '\t' || words[i] == 0)
                        break;
 
                if (words[i] == '\\') {
                        *word = w_addchar(*word, word_length, max_length, '~');
                        return *word ? 0 : WRDE_NOSPACE;
                }
        }
 
        if (i == 1 + *offset) {
                /* Tilde appears on its own */
                uid_t uid;
                struct passwd pwd, *tpwd;
                int buflen = 1000;
                char *home;
                char *buffer;
                int result;
 
                /* POSIX.2 says ~ expands to $HOME and if HOME is unset the
                   results are unspecified.  We do a lookup on the uid if
                   HOME is unset. */
 
                home = getenv("HOME");
                if (home != NULL) {
                        *word = w_addstr(*word, word_length, max_length, home);
                        if (*word == NULL)
                                return WRDE_NOSPACE;
                } else {
                        uid = getuid();
                        buffer = alloca(buflen);
 
                        while ((result = getpwuid_r(uid, &pwd, buffer, buflen, &tpwd))
                                        != 0 && errno == ERANGE)
                        {
                                buflen += 1000;
                                buffer = alloca(buflen);
                        }
 
                        if (result == 0 && tpwd != NULL && pwd.pw_dir != NULL) {
                                *word = w_addstr(*word, word_length, max_length, pwd.pw_dir);
                                if (*word == NULL)
                                        return WRDE_NOSPACE;
                        } else {
                                *word = w_addchar(*word, word_length, max_length, '~');
                                if (*word == NULL)
                                        return WRDE_NOSPACE;
                        }
                }
        } else {
                /* Look up user name in database to get home directory */
                char *user = strndup(&words[1 + *offset], i - (1 + *offset));
                struct passwd pwd, *tpwd;
                int buflen = 1000;
                char *buffer = alloca(buflen);
                int result;
 
                while ((result = getpwnam_r(user, &pwd, buffer, buflen, &tpwd)) != 0
                           && errno == ERANGE) {
                        buflen += 1000;
                        buffer = alloca(buflen);
                }
 
                if (result == 0 && tpwd != NULL && pwd.pw_dir)
                        *word = w_addstr(*word, word_length, max_length, pwd.pw_dir);
                else {
                        /* (invalid login name) */
                        *word = w_addchar(*word, word_length, max_length, '~');
                        if (*word != NULL)
                                *word = w_addstr(*word, word_length, max_length, user);
                }
 
                *offset = i - 1;
        }
        return *word ? 0 : WRDE_NOSPACE;
}
 
 
static int
do_parse_glob(const char *glob_word, char **word, size_t * word_length,
                          size_t * max_length, wordexp_t * pwordexp, const char *ifs,
                          const char *ifs_white)
{
        int error;
        int match;
        glob_t globbuf;
 
        error = glob(glob_word, GLOB_NOCHECK, NULL, &globbuf);
 
        if (error != 0) {
                /* We can only run into memory problems.  */
                assert(error == GLOB_NOSPACE);
                return WRDE_NOSPACE;
        }
 
        if (ifs && !*ifs) {
                /* No field splitting allowed. */
                assert(globbuf.gl_pathv[0] != NULL);
                *word = w_addstr(*word, word_length, max_length, globbuf.gl_pathv[0]);
                for (match = 1; match < globbuf.gl_pathc && *word != NULL; ++match) {
                        *word = w_addchar(*word, word_length, max_length, ' ');
                        if (*word != NULL)
                                *word = w_addstr(*word, word_length, max_length,
                                                                 globbuf.gl_pathv[match]);
                }
 
                globfree(&globbuf);
                return *word ? 0 : WRDE_NOSPACE;
        }
 
        assert(ifs == NULL || *ifs != '\0');
        if (*word != NULL) {
                free(*word);
                *word = w_newword(word_length, max_length);
        }
 
        for (match = 0; match < globbuf.gl_pathc; ++match) {
                char *matching_word = strdup(globbuf.gl_pathv[match]);
 
                if (matching_word == NULL || w_addword(pwordexp, matching_word)) {
                        globfree(&globbuf);
                        return WRDE_NOSPACE;
                }
        }
 
        globfree(&globbuf);
        return 0;
}
 
static int
parse_glob(char **word, size_t * word_length, size_t * max_length,
                   const char *words, size_t * offset, int flags,
                   wordexp_t * pwordexp, const char *ifs, const char *ifs_white)
{
        /* We are poised just after a '*', a '[' or a '?'. */
        int error = WRDE_NOSPACE;
        int quoted = 0;                          /* 1 if singly-quoted, 2 if doubly */
        int i;
        wordexp_t glob_list;            /* List of words to glob */
 
        glob_list.we_wordc = 0;
        glob_list.we_wordv = NULL;
        glob_list.we_offs = 0;
        for (; words[*offset] != '\0'; ++*offset) {
                if ((ifs && strchr(ifs, words[*offset])) ||
                        (!ifs && strchr(" \t\n", words[*offset])))
                        /* Reached IFS */
                        break;
 
                /* Sort out quoting */
                if (words[*offset] == '\'') {
                        if (quoted == 0) {
                                quoted = 1;
                                continue;
                        } else if (quoted == 1) {
                                quoted = 0;
                                continue;
                        }
                } else if (words[*offset] == '"') {
                        if (quoted == 0) {
                                quoted = 2;
                                continue;
                        } else if (quoted == 2) {
                                quoted = 0;
                                continue;
                        }
                }
 
                /* Sort out other special characters */
                if (quoted != 1 && words[*offset] == '$') {
                        error = parse_dollars(word, word_length, max_length, words,
                                                                  offset, flags, &glob_list, ifs,
                                                                  ifs_white, quoted == 2);
                        if (error)
                                goto tidy_up;
 
                        continue;
                } else if (words[*offset] == '\\') {
                        if (quoted)
                                error = parse_qtd_backslash(word, word_length, max_length,
                                                                                        words, offset);
                        else
                                error = parse_backslash(word, word_length, max_length,
                                                                                words, offset);
 
                        if (error)
                                goto tidy_up;
 
                        continue;
                }
 
                *word = w_addchar(*word, word_length, max_length, words[*offset]);
                if (*word == NULL)
                        goto tidy_up;
        }
 
        /* Don't forget to re-parse the character we stopped at. */
        --*offset;
 
        /* Glob the words */
        error = w_addword(&glob_list, *word);
        *word = w_newword(word_length, max_length);
        for (i = 0; error == 0 && i < glob_list.we_wordc; i++)
                error = do_parse_glob(glob_list.we_wordv[i], word, word_length,
                                                          max_length, pwordexp, ifs, ifs_white);
 
        /* Now tidy up */
  tidy_up:
        wordfree(&glob_list);
        return error;
}
 
static int
parse_squote(char **word, size_t * word_length, size_t * max_length,
                         const char *words, size_t * offset)
{
        /* We are poised just after a single quote */
        for (; words[*offset]; ++(*offset)) {
                if (words[*offset] != '\'') {
                        *word = w_addchar(*word, word_length, max_length, words[*offset]);
                        if (*word == NULL)
                                return WRDE_NOSPACE;
                } else
                        return 0;
        }
 
        /* Unterminated string */
        return WRDE_SYNTAX;
}
 
#ifdef __WORDEXP_FULL
static int eval_expr(char *expr, long int *result);
 
static char *_itoa(unsigned long long int value, char *buflim)
{
        sprintf(buflim, "%llu", value);
        return buflim;
}
 
/* Functions to evaluate an arithmetic expression */
static int eval_expr_val(char **expr, long int *result)
{
        int sgn = +1;
        char *digit;
 
        /* Skip white space */
        for (digit = *expr; digit && *digit && isspace(*digit); ++digit);
 
        switch (*digit) {
        case '(':
 
                /* Scan for closing paren */
                for (++digit; **expr && **expr != ')'; ++(*expr));
 
                /* Is there one? */
                if (!**expr)
                        return WRDE_SYNTAX;
 
                *(*expr)++ = 0;
 
                if (eval_expr(digit, result))
                        return WRDE_SYNTAX;
 
                return 0;
 
        case '+':                                       /* Positive value */
                ++digit;
                break;
 
        case '-':                                       /* Negative value */
                ++digit;
                sgn = -1;
                break;
 
        default:
                if (!isdigit(*digit))
                        return WRDE_SYNTAX;
        }
 
        *result = 0;
        for (; *digit && isdigit(*digit); ++digit)
                *result = (*result * 10) + (*digit - '0');
 
        *expr = digit;
        *result *= sgn;
        return 0;
}
 
static int eval_expr_multdiv(char **expr, long int *result)
{
        long int arg;
 
        /* Read a Value */
        if (eval_expr_val(expr, result) != 0)
                return WRDE_SYNTAX;
 
        while (**expr) {
                /* Skip white space */
                for (; *expr && **expr && isspace(**expr); ++(*expr));
 
                if (**expr == '*') {
                        ++(*expr);
                        if (eval_expr_val(expr, &arg) != 0)
                                return WRDE_SYNTAX;
 
                        *result *= arg;
                } else if (**expr == '/') {
                        ++(*expr);
                        if (eval_expr_val(expr, &arg) != 0)
                                return WRDE_SYNTAX;
 
                        *result /= arg;
                } else
                        break;
        }
 
        return 0;
}
 
static int eval_expr(char *expr, long int *result)
{
        long int arg;
 
        /* Read a Multdiv */
        if (eval_expr_multdiv(&expr, result) != 0)
                return WRDE_SYNTAX;
 
        while (*expr) {
                /* Skip white space */
                for (; expr && *expr && isspace(*expr); ++expr);
 
                if (*expr == '+') {
                        ++expr;
                        if (eval_expr_multdiv(&expr, &arg) != 0)
                                return WRDE_SYNTAX;
 
                        *result += arg;
                } else if (*expr == '-') {
                        ++expr;
                        if (eval_expr_multdiv(&expr, &arg) != 0)
                                return WRDE_SYNTAX;
 
                        *result -= arg;
                } else
                        break;
        }
 
        return 0;
}
 
static int
parse_arith(char **word, size_t * word_length, size_t * max_length,
                        const char *words, size_t * offset, int flags, int bracket)
{
        /* We are poised just after "$((" or "$[" */
        int error;
        int paren_depth = 1;
        size_t expr_length;
        size_t expr_maxlen;
        char *expr;
 
        expr = w_newword(&expr_length, &expr_maxlen);
        for (; words[*offset]; ++(*offset)) {
                switch (words[*offset]) {
                case '$':
                        error = parse_dollars(&expr, &expr_length, &expr_maxlen,
                                                                  words, offset, flags, NULL, NULL, NULL,
                                                                  1);
                        /* The ``1'' here is to tell parse_dollars not to
                         * split the fields.
                         */
                        if (error) {
                                free(expr);
                                return error;
                        }
                        break;
 
                case '`':
                        (*offset)++;
                        error = parse_backtick(&expr, &expr_length, &expr_maxlen,
                                                                   words, offset, flags, NULL, NULL, NULL);
                        /* The first NULL here is to tell parse_backtick not to
                         * split the fields.
                         */
                        if (error) {
                                free(expr);
                                return error;
                        }
                        break;
 
                case '\\':
                        error = parse_qtd_backslash(&expr, &expr_length, &expr_maxlen,
                                                                                words, offset);
                        if (error) {
                                free(expr);
                                return error;
                        }
                        /* I think that a backslash within an
                         * arithmetic expansion is bound to
                         * cause an error sooner or later anyway though.
                         */
                        break;
 
                case ')':
                        if (--paren_depth == 0) {
                                char result[21];        /* 21 = ceil(log10(2^64)) + 1 */
                                long int numresult = 0;
                                long long int convertme;
 
                                if (bracket || words[1 + *offset] != ')') {
                                        free(expr);
                                        return WRDE_SYNTAX;
                                }
 
                                ++(*offset);
 
                                /* Go - evaluate. */
                                if (*expr && eval_expr(expr, &numresult) != 0) {
                                        free(expr);
                                        return WRDE_SYNTAX;
                                }
 
                                if (numresult < 0) {
                                        convertme = -numresult;
                                        *word = w_addchar(*word, word_length, max_length, '-');
                                        if (!*word) {
                                                free(expr);
                                                return WRDE_NOSPACE;
                                        }
                                } else
                                        convertme = numresult;
 
                                result[20] = '\0';
                                *word = w_addstr(*word, word_length, max_length,
                                                                 _itoa(convertme, &result[20]));
                                free(expr);
                                return *word ? 0 : WRDE_NOSPACE;
                        }
                        expr =
                                w_addchar(expr, &expr_length, &expr_maxlen,
                                                  words[*offset]);
                        if (expr == NULL)
                                return WRDE_NOSPACE;
 
                        break;
 
                case ']':
                        if (bracket && paren_depth == 1) {
                                char result[21];        /* 21 = ceil(log10(2^64)) + 1 */
                                long int numresult = 0;
 
                                /* Go - evaluate. */
                                if (*expr && eval_expr(expr, &numresult) != 0) {
                                        free(expr);
                                        return WRDE_SYNTAX;
                                }
 
                                result[20] = '\0';
                                *word = w_addstr(*word, word_length, max_length,
                                                                 _itoa(numresult, &result[20]));
                                free(expr);
                                return *word ? 0 : WRDE_NOSPACE;
                        }
 
                        free(expr);
                        return WRDE_SYNTAX;
 
                case '\n':
                case ';':
                case '{':
                case '}':
                        free(expr);
                        return WRDE_BADCHAR;
 
                case '(':
                        ++paren_depth;
                default:
                        expr =
                                w_addchar(expr, &expr_length, &expr_maxlen,
                                                  words[*offset]);
                        if (expr == NULL)
                                return WRDE_NOSPACE;
                }
        }
 
        /* Premature end */
        free(expr);
        return WRDE_SYNTAX;
}
 
/* Function called by child process in exec_comm() */
static void
exec_comm_child(char *comm, int *fildes, int showerr, int noexec)
{
        const char *args[4] = { _PATH_BSHELL, "-c", comm, NULL };
 
        /* Execute the command, or just check syntax? */
        if (noexec)
                args[1] = "-nc";
 
        /* Redirect output.  */
        dup2(fildes[1], 1);
        close(fildes[1]);
 
        /* Redirect stderr to /dev/null if we have to.  */
        if (showerr == 0) {
                int fd;
 
                close(2);
                fd = open(_PATH_DEVNULL, O_WRONLY);
                if (fd >= 0 && fd != 2) {
                        dup2(fd, 2);
                        close(fd);
                }
        }
 
        /* Make sure the subshell doesn't field-split on our behalf. */
        unsetenv("IFS");
 
        close(fildes[0]);
        execve(_PATH_BSHELL, (char *const *) args, __environ);
 
        /* Bad.  What now?  */
        abort();
}
 
/* Function to execute a command and retrieve the results */
/* pwordexp contains NULL if field-splitting is forbidden */
static int
exec_comm(char *comm, char **word, size_t * word_length,
                  size_t * max_length, int flags, wordexp_t * pwordexp,
                  const char *ifs, const char *ifs_white)
{
        int fildes[2];
        int bufsize = 128;
        int buflen;
        int i;
        int status = 0;
        size_t maxnewlines = 0;
        char *buffer;
        pid_t pid;
 
        /* Don't fork() unless necessary */
        if (!comm || !*comm)
                return 0;
 
        if (pipe(fildes))
                /* Bad */
                return WRDE_NOSPACE;
 
        if ((pid = fork()) < 0) {
                /* Bad */
                close(fildes[0]);
                close(fildes[1]);
                return WRDE_NOSPACE;
        }
 
        if (pid == 0)
                exec_comm_child(comm, fildes, (flags & WRDE_SHOWERR), 0);
 
        /* Parent */
 
        close(fildes[1]);
        buffer = alloca(bufsize);
 
        if (!pwordexp)
                /* Quoted - no field splitting */
        {
                while (1) {
                        if ((buflen = read(fildes[0], buffer, bufsize)) < 1) {
                                if (waitpid(pid, &status, WNOHANG) == 0)
                                        continue;
                                if ((buflen = read(fildes[0], buffer, bufsize)) < 1)
                                        break;
                        }
 
                        maxnewlines += buflen;
 
                        *word = w_addmem(*word, word_length, max_length, buffer, buflen);
                        if (*word == NULL)
                                goto no_space;
                }
        } else
                /* Not quoted - split fields */
        {
                int copying = 0;
 
                /* 'copying' is:
                 *  0 when searching for first character in a field not IFS white space
                 *  1 when copying the text of a field
                 *  2 when searching for possible non-whitespace IFS
                 *  3 when searching for non-newline after copying field
                 */
 
                while (1) {
                        if ((buflen = read(fildes[0], buffer, bufsize)) < 1) {
                                if (waitpid(pid, &status, WNOHANG) == 0)
                                        continue;
                                if ((buflen = read(fildes[0], buffer, bufsize)) < 1)
                                        break;
                        }
 
                        for (i = 0; i < buflen; ++i) {
                                if (strchr(ifs, buffer[i]) != NULL) {
                                        /* Current character is IFS */
                                        if (strchr(ifs_white, buffer[i]) == NULL) {
                                                /* Current character is IFS but not whitespace */
                                                if (copying == 2) {
                                                        /*            current character
                                                         *                   |
                                                         *                   V
                                                         * eg: text<space><comma><space>moretext
                                                         *
                                                         * So, strip whitespace IFS (like at the start)
                                                         */
                                                        copying = 0;
                                                        continue;
                                                }
 
                                                copying = 0;
                                                /* fall through and delimit field.. */
                                        } else {
                                                if (buffer[i] == '\n') {
                                                        /* Current character is (IFS) newline */
 
                                                        /* If copying a field, this is the end of it,
                                                           but maybe all that's left is trailing newlines.
                                                           So start searching for a non-newline. */
                                                        if (copying == 1)
                                                                copying = 3;
 
                                                        continue;
                                                } else {
                                                        /* Current character is IFS white space, but
                                                           not a newline */
 
                                                        /* If not either copying a field or searching
                                                           for non-newline after a field, ignore it */
                                                        if (copying != 1 && copying != 3)
                                                                continue;
 
                                                        /* End of field (search for non-ws IFS afterwards) */
                                                        copying = 2;
                                                }
                                        }
 
                                        /* First IFS white space (non-newline), or IFS non-whitespace.
                                         * Delimit the field.  Nulls are converted by w_addword. */
                                        if (w_addword(pwordexp, *word) == WRDE_NOSPACE)
                                                goto no_space;
 
                                        *word = w_newword(word_length, max_length);
 
                                        maxnewlines = 0;
                                        /* fall back round the loop.. */
                                } else {
                                        /* Not IFS character */
 
                                        if (copying == 3) {
                                                /* Nothing but (IFS) newlines since the last field,
                                                   so delimit it here before starting new word */
                                                if (w_addword(pwordexp, *word) == WRDE_NOSPACE)
                                                        goto no_space;
 
                                                *word = w_newword(word_length, max_length);
                                        }
 
                                        copying = 1;
 
                                        if (buffer[i] == '\n')  /* happens if newline not in IFS */
                                                maxnewlines++;
                                        else
                                                maxnewlines = 0;
 
                                        *word = w_addchar(*word, word_length, max_length,
                                                                          buffer[i]);
                                        if (*word == NULL)
                                                goto no_space;
                                }
                        }
                }
        }
 
        /* Chop off trailing newlines (required by POSIX.2)  */
        /* Ensure we don't go back further than the beginning of the
           substitution (i.e. remove maxnewlines bytes at most) */
        while (maxnewlines-- != 0 &&
                   *word_length > 0 && (*word)[*word_length - 1] == '\n') {
                (*word)[--*word_length] = '\0';
 
                /* If the last word was entirely newlines, turn it into a new word
                 * which can be ignored if there's nothing following it. */
                if (*word_length == 0) {
                        free(*word);
                        *word = w_newword(word_length, max_length);
                        break;
                }
        }
 
        close(fildes[0]);
 
        /* Check for syntax error (re-execute but with "-n" flag) */
        if (buflen < 1 && status != 0) {
                if ((pid = fork()) < 0) {
                        /* Bad */
                        return WRDE_NOSPACE;
                }
 
                if (pid == 0) {
                        fildes[0] = fildes[1] = -1;
                        exec_comm_child(comm, fildes, 0, 1);
                }
 
                if (waitpid(pid, &status, 0) == pid && status != 0)
                        return WRDE_SYNTAX;
        }
 
        return 0;
 
  no_space:
        kill(pid, SIGKILL);
        waitpid(pid, NULL, 0);
        close(fildes[0]);
        return WRDE_NOSPACE;
}
 
static int
parse_comm(char **word, size_t * word_length, size_t * max_length,
                   const char *words, size_t * offset, int flags,
                   wordexp_t * pwordexp, const char *ifs, const char *ifs_white)
{
        /* We are poised just after "$(" */
        int paren_depth = 1;
        int error = 0;
        int quoted = 0;                          /* 1 for singly-quoted, 2 for doubly-quoted */
        size_t comm_length;
        size_t comm_maxlen;
        char *comm = w_newword(&comm_length, &comm_maxlen);
 
        for (; words[*offset]; ++(*offset)) {
                switch (words[*offset]) {
                case '\'':
                        if (quoted == 0)
                                quoted = 1;
                        else if (quoted == 1)
                                quoted = 0;
 
                        break;
 
                case '"':
                        if (quoted == 0)
                                quoted = 2;
                        else if (quoted == 2)
                                quoted = 0;
 
                        break;
 
                case ')':
                        if (!quoted && --paren_depth == 0) {
                                /* Go -- give script to the shell */
                                if (comm) {
                                        error = exec_comm(comm, word, word_length, max_length,
                                                                          flags, pwordexp, ifs, ifs_white);
                                        free(comm);
                                }
 
                                return error;
                        }
 
                        /* This is just part of the script */
                        break;
 
                case '(':
                        if (!quoted)
                                ++paren_depth;
                }
 
                comm = w_addchar(comm, &comm_length, &comm_maxlen, words[*offset]);
                if (comm == NULL)
                        return WRDE_NOSPACE;
        }
 
        /* Premature end */
        if (comm)
                free(comm);
 
        return WRDE_SYNTAX;
}
 
static int
parse_backtick(char **word, size_t * word_length, size_t * max_length,
                           const char *words, size_t * offset, int flags,
                           wordexp_t * pwordexp, const char *ifs,
                           const char *ifs_white)
{
        /* We are poised just after "`" */
        int error;
        int squoting = 0;
        size_t comm_length;
        size_t comm_maxlen;
        char *comm = w_newword(&comm_length, &comm_maxlen);
 
        for (; words[*offset]; ++(*offset)) {
                switch (words[*offset]) {
                case '`':
                        /* Go -- give the script to the shell */
                        error = exec_comm(comm, word, word_length, max_length, flags,
                                                          pwordexp, ifs, ifs_white);
                        free(comm);
                        return error;
 
                case '\\':
                        if (squoting) {
                                error = parse_qtd_backslash(&comm, &comm_length, &comm_maxlen,
                                                                                words, offset);
 
                                if (error) {
                                        free(comm);
                                        return error;
                                }
 
                                break;
                        }
 
                        ++(*offset);
                        error = parse_backslash(&comm, &comm_length, &comm_maxlen, words,
                                                                offset);
 
                        if (error) {
                                free(comm);
                                return error;
                        }
 
                        break;
 
                case '\'':
                        squoting = 1 - squoting;
                default:
                        comm = w_addchar(comm, &comm_length, &comm_maxlen,
                                                  words[*offset]);
                        if (comm == NULL)
                                return WRDE_NOSPACE;
                }
        }
 
        /* Premature end */
        free(comm);
        return WRDE_SYNTAX;
}
 
static int
parse_param(char **word, size_t * word_length, size_t * max_length,
                        const char *words, size_t * offset, int flags,
                        wordexp_t * pwordexp, const char *ifs, const char *ifs_white,
                        int quoted)
{
        /* We are poised just after "$" */
        enum action {
                ACT_NONE,
                ACT_RP_SHORT_LEFT = '#',
                ACT_RP_LONG_LEFT = 'L',
                ACT_RP_SHORT_RIGHT = '%',
                ACT_RP_LONG_RIGHT = 'R',
                ACT_NULL_ERROR = '?',
                ACT_NULL_SUBST = '-',
                ACT_NONNULL_SUBST = '+',
                ACT_NULL_ASSIGN = '='
        };
        size_t env_length;
        size_t env_maxlen;
        size_t pat_length;
        size_t pat_maxlen;
        size_t start = *offset;
        char *env;
        char *pattern;
        char *value = NULL;
        enum action action = ACT_NONE;
        int depth = 0;
        int colon_seen = 0;
        int seen_hash = 0;
        int free_value = 0;
        int pattern_is_quoted = 0;       /* 1 for singly-quoted, 2 for doubly-quoted */
        int error;
        int special = 0;
        char buffer[21];
        int brace = words[*offset] == '{';
 
        env = w_newword(&env_length, &env_maxlen);
        pattern = w_newword(&pat_length, &pat_maxlen);
 
        if (brace)
                ++ * offset;
 
        /* First collect the parameter name. */
 
        if (words[*offset] == '#') {
                seen_hash = 1;
                if (!brace)
                        goto envsubst;
                ++*offset;
        }
 
        if (isalpha(words[*offset]) || words[*offset] == '_') {
                /* Normal parameter name. */
                do {
                        env = w_addchar(env, &env_length, &env_maxlen, words[*offset]);
                        if (env == NULL)
                                goto no_space;
                }
                while (isalnum(words[++*offset]) || words[*offset] == '_');
        } else if (isdigit(words[*offset])) {
                /* Numeric parameter name. */
                special = 1;
                do {
                        env = w_addchar(env, &env_length, &env_maxlen, words[*offset]);
                        if (env == NULL)
                                goto no_space;
                        if (!brace)
                                goto envsubst;
                }
                while (isdigit(words[++*offset]));
        } else if (strchr("*@$", words[*offset]) != NULL) {
                /* Special parameter. */
                special = 1;
                env = w_addchar(env, &env_length, &env_maxlen, words[*offset]);
                if (env == NULL)
                        goto no_space;
                ++*offset;
        } else {
                if (brace)
                        goto syntax;
        }
 
        if (brace) {
                /* Check for special action to be applied to the value. */
                switch (words[*offset]) {
                case '}':
                        /* Evaluate. */
                        goto envsubst;
 
                case '#':
                        action = ACT_RP_SHORT_LEFT;
                        if (words[1 + *offset] == '#') {
                                ++*offset;
                                action = ACT_RP_LONG_LEFT;
                        }
                        break;
 
                case '%':
                        action = ACT_RP_SHORT_RIGHT;
                        if (words[1 + *offset] == '%') {
                                ++*offset;
                                action = ACT_RP_LONG_RIGHT;
                        }
                        break;
 
                case ':':
                        if (strchr("-=?+", words[1 + *offset]) == NULL)
                                goto syntax;
 
                        colon_seen = 1;
                        action = words[++*offset];
                        break;
 
                case '-':
                case '=':
                case '?':
                case '+':
                        action = words[*offset];
                        break;
 
                default:
                        goto syntax;
                }
 
                /* Now collect the pattern, but don't expand it yet. */
                ++*offset;
                for (; words[*offset]; ++(*offset)) {
                        switch (words[*offset]) {
                        case '{':
                                if (!pattern_is_quoted)
                                        ++depth;
                                break;
 
                        case '}':
                                if (!pattern_is_quoted) {
                                        if (depth == 0)
                                                goto envsubst;
                                        --depth;
                                }
                                break;
 
                        case '\\':
                                if (pattern_is_quoted)
                                        /* Quoted; treat as normal character. */
                                        break;
 
                                /* Otherwise, it's an escape: next character is literal. */
                                if (words[++*offset] == '\0')
                                        goto syntax;
 
                                pattern = w_addchar(pattern, &pat_length, &pat_maxlen, '\\');
                                if (pattern == NULL)
                                        goto no_space;
 
                                break;
 
                        case '\'':
                                if (pattern_is_quoted == 0)
                                        pattern_is_quoted = 1;
                                else if (pattern_is_quoted == 1)
                                        pattern_is_quoted = 0;
 
                                break;
 
                        case '"':
                                if (pattern_is_quoted == 0)
                                        pattern_is_quoted = 2;
                                else if (pattern_is_quoted == 2)
                                        pattern_is_quoted = 0;
 
                                break;
                        }
 
                        pattern = w_addchar(pattern, &pat_length, &pat_maxlen,
                                                                words[*offset]);
                        if (pattern == NULL)
                                goto no_space;
                }
        }
 
        /* End of input string -- remember to reparse the character that we
         * stopped at.  */
        --(*offset);
 
  envsubst:
        if (words[start] == '{' && words[*offset] != '}')
                goto syntax;
 
        if (env == NULL) {
                if (seen_hash) {
                        /* $# expands to the number of positional parameters */
                        buffer[20] = '\0';
                        value = _itoa(__libc_argc - 1, &buffer[20]);
                        seen_hash = 0;
                } else {
                        /* Just $ on its own */
                        *offset = start - 1;
                        *word = w_addchar(*word, word_length, max_length, '$');
                        return *word ? 0 : WRDE_NOSPACE;
                }
        }
        /* Is it a numeric parameter? */
        else if (isdigit(env[0])) {
                int n = atoi(env);
 
                if (n >= __libc_argc)
                        /* Substitute NULL. */
                        value = NULL;
                else
                        /* Replace with appropriate positional parameter. */
                        value = __libc_argv[n];
        }
        /* Is it a special parameter? */
        else if (special) {
                /* Is it `$$'? */
                if (*env == '$') {
                        buffer[20] = '\0';
                        value = _itoa(getpid(), &buffer[20]);
                }
                /* Is it `${#*}' or `${#@}'? */
                else if ((*env == '*' || *env == '@') && seen_hash) {
                        buffer[20] = '\0';
                        value = _itoa(__libc_argc > 0 ? __libc_argc - 1 : 0,
                                                           &buffer[20]);
                        *word = w_addstr(*word, word_length, max_length, value);
                        free(env);
                        if (pattern)
                                free(pattern);
                        return *word ? 0 : WRDE_NOSPACE;
                }
                /* Is it `$*' or `$@' (unquoted) ? */
                else if (*env == '*' || (*env == '@' && !quoted)) {
                        size_t plist_len = 0;
                        int p;
                        char *end;
 
                        /* Build up value parameter by parameter (copy them) */
                        for (p = 1; __libc_argv[p]; ++p)
                                plist_len += strlen(__libc_argv[p]) + 1;        /* for space */
                        value = malloc(plist_len);
                        if (value == NULL)
                                goto no_space;
                        end = value;
                        *end = 0;
                        for (p = 1; __libc_argv[p]; ++p) {
                                if (p > 1)
                                        *end++ = ' ';
                                end = stpcpy(end, __libc_argv[p]);
                        }
 
                        free_value = 1;
                } else {
                        /* Must be a quoted `$@' */
                        assert(*env == '@' && quoted);
 
                        /* Each parameter is a separate word ("$@") */
                        if (__libc_argc == 2)
                                value = __libc_argv[1];
                        else if (__libc_argc > 2) {
                                int p;
 
                                /* Append first parameter to current word. */
                                value = w_addstr(*word, word_length, max_length,
                                                                 __libc_argv[1]);
                                if (value == NULL || w_addword(pwordexp, value))
                                        goto no_space;
 
                                for (p = 2; __libc_argv[p + 1]; p++) {
                                        char *newword = strdup(__libc_argv[p]);
 
                                        if (newword == NULL || w_addword(pwordexp, newword))
                                                goto no_space;
                                }
 
                                /* Start a new word with the last parameter. */
                                *word = w_newword(word_length, max_length);
                                value = __libc_argv[p];
                        } else {
                                free(env);
                                free(pattern);
                                return 0;
                        }
                }
        } else
                value = getenv(env);
 
        if (value == NULL && (flags & WRDE_UNDEF)) {
                /* Variable not defined. */
                error = WRDE_BADVAL;
                goto do_error;
        }
 
        if (action != ACT_NONE) {
                int expand_pattern = 0;
 
                /* First, find out if we need to expand pattern (i.e. if we will
                 * use it). */
                switch (action) {
                case ACT_RP_SHORT_LEFT:
                case ACT_RP_LONG_LEFT:
                case ACT_RP_SHORT_RIGHT:
                case ACT_RP_LONG_RIGHT:
                        /* Always expand for these. */
                        expand_pattern = 1;
                        break;
 
                case ACT_NULL_ERROR:
                case ACT_NULL_SUBST:
                case ACT_NULL_ASSIGN:
                        if (!value || (!*value && colon_seen))
                                /* If param is unset, or set but null and a colon has been seen,
                                   the expansion of the pattern will be needed. */
                                expand_pattern = 1;
 
                        break;
 
                case ACT_NONNULL_SUBST:
                        /* Expansion of word will be needed if parameter is set and not null,
                           or set null but no colon has been seen. */
                        if (value && (*value || !colon_seen))
                                expand_pattern = 1;
 
                        break;
 
                default:
                        assert(!"Unrecognised action!");
                }
 
                if (expand_pattern) {
                        /* We need to perform tilde expansion, parameter expansion,
                           command substitution, and arithmetic expansion.  We also
                           have to be a bit careful with wildcard characters, as
                           pattern might be given to fnmatch soon.  To do this, we
                           convert quotes to escapes. */
 
                        char *expanded;
                        size_t exp_len;
                        size_t exp_maxl;
                        char *p;
                        int quoted = 0;          /* 1: single quotes; 2: double */
 
                        expanded = w_newword(&exp_len, &exp_maxl);
                        for (p = pattern; p && *p; p++) {
                                size_t offset;
 
                                switch (*p) {
                                case '"':
                                        if (quoted == 2)
                                                quoted = 0;
                                        else if (quoted == 0)
                                                quoted = 2;
                                        else
                                                break;
 
                                        continue;
 
                                case '\'':
                                        if (quoted == 1)
                                                quoted = 0;
                                        else if (quoted == 0)
                                                quoted = 1;
                                        else
                                                break;
 
                                        continue;
 
                                case '*':
                                case '?':
                                        if (quoted) {
                                                /* Convert quoted wildchar to escaped wildchar. */
                                                expanded = w_addchar(expanded, &exp_len,
                                                                                         &exp_maxl, '\\');
 
                                                if (expanded == NULL)
                                                        goto no_space;
                                        }
                                        break;
 
                                case '$':
                                        offset = 0;
                                        error = parse_dollars(&expanded, &exp_len, &exp_maxl, p,
                                                                          &offset, flags, NULL, NULL, NULL, 1);
                                        if (error) {
                                                if (free_value)
                                                        free(value);
 
                                                if (expanded)
                                                        free(expanded);
 
                                                goto do_error;
                                        }
 
                                        p += offset;
                                        continue;
 
                                case '~':
                                        if (quoted || exp_len)
                                                break;
 
                                        offset = 0;
                                        error = parse_tilde(&expanded, &exp_len, &exp_maxl, p,
                                                                                &offset, 0);
                                        if (error) {
                                                if (free_value)
                                                        free(value);
 
                                                if (expanded)
                                                        free(expanded);
 
                                                goto do_error;
                                        }
 
                                        p += offset;
                                        continue;
 
                                case '\\':
                                        expanded = w_addchar(expanded, &exp_len, &exp_maxl, '\\');
                                        ++p;
                                        assert(*p);     /* checked when extracted initially */
                                        if (expanded == NULL)
                                                goto no_space;
                                }
 
                                expanded = w_addchar(expanded, &exp_len, &exp_maxl, *p);
 
                                if (expanded == NULL)
                                        goto no_space;
                        }
 
                        if (pattern)
                                free(pattern);
 
                        pattern = expanded;
                }
 
                switch (action) {
                case ACT_RP_SHORT_LEFT:
                case ACT_RP_LONG_LEFT:
                case ACT_RP_SHORT_RIGHT:
                case ACT_RP_LONG_RIGHT:
                {
                        char *p;
                        char c;
                        char *end;
 
                        if (value == NULL || pattern == NULL || *pattern == '\0')
                                break;
 
                        end = value + strlen(value);
 
                        switch (action) {
                        case ACT_RP_SHORT_LEFT:
                                for (p = value; p <= end; ++p) {
                                        c = *p;
                                        *p = '\0';
                                        if (fnmatch(pattern, value, 0) != FNM_NOMATCH) {
                                                *p = c;
                                                if (free_value) {
                                                        char *newval = strdup(p);
 
                                                        if (newval == NULL) {
                                                                free(value);
                                                                goto no_space;
                                                        }
                                                        free(value);
                                                        value = newval;
                                                } else
                                                        value = p;
                                                break;
                                        }
                                        *p = c;
                                }
 
                                break;
 
                        case ACT_RP_LONG_LEFT:
                                for (p = end; p >= value; --p) {
                                        c = *p;
                                        *p = '\0';
                                        if (fnmatch(pattern, value, 0) != FNM_NOMATCH) {
                                                *p = c;
                                                if (free_value) {
                                                        char *newval = strdup(p);
 
                                                        if (newval == NULL) {
                                                                free(value);
                                                                goto no_space;
                                                        }
                                                        free(value);
                                                        value = newval;
                                                } else
                                                        value = p;
                                                break;
                                        }
                                        *p = c;
                                }
 
                                break;
 
                        case ACT_RP_SHORT_RIGHT:
                                for (p = end; p >= value; --p) {
                                        if (fnmatch(pattern, p, 0) != FNM_NOMATCH) {
                                                char *newval;
 
                                                newval = malloc(p - value + 1);
 
                                                if (newval == NULL) {
                                                        if (free_value)
                                                                free(value);
                                                        goto no_space;
                                                }
 
                                                *(char *) mempcpy(newval, value, p - value) = '\0';
                                                if (free_value)
                                                        free(value);
                                                value = newval;
                                                free_value = 1;
                                                break;
                                        }
                                }
 
                                break;
 
                        case ACT_RP_LONG_RIGHT:
                                for (p = value; p <= end; ++p) {
                                        if (fnmatch(pattern, p, 0) != FNM_NOMATCH) {
                                                char *newval;
 
                                                newval = malloc(p - value + 1);
 
                                                if (newval == NULL) {
                                                        if (free_value)
                                                                free(value);
                                                        goto no_space;
                                                }
 
                                                *(char *) mempcpy(newval, value, p - value) = '\0';
                                                if (free_value)
                                                        free(value);
                                                value = newval;
                                                free_value = 1;
                                                break;
                                        }
                                }
 
                                break;
 
                        default:
                                break;
                        }
 
                        break;
                }
 
                case ACT_NULL_ERROR:
                        if (value && *value)
                                /* Substitute parameter */
                                break;
 
                        error = 0;
                        if (!colon_seen && value)
                                /* Substitute NULL */
                                ;
                        else if (*pattern)
                                fprintf(stderr, "%s: %s\n", env, pattern);
                        else {
                                fprintf(stderr, "%s: parameter null or not set\n", env);
                                error = WRDE_BADVAL;
                        }
 
                        if (free_value)
                                free(value);
                        goto do_error;
 
                case ACT_NULL_SUBST:
                        if (value && *value)
                                /* Substitute parameter */
                                break;
 
                        if (free_value && value)
                                free(value);
 
                        if (!colon_seen && value)
                                /* Substitute NULL */
                                goto success;
 
                        value = pattern ? strdup(pattern) : pattern;
                        free_value = 1;
 
                        if (pattern && !value)
                                goto no_space;
 
                        break;
 
                case ACT_NONNULL_SUBST:
                        if (value && (*value || !colon_seen)) {
                                if (free_value && value)
                                        free(value);
 
                                value = pattern ? strdup(pattern) : pattern;
                                free_value = 1;
 
                                if (pattern && !value)
                                        goto no_space;
 
                                break;
                        }
 
                        /* Substitute NULL */
                        if (free_value)
                                free(value);
                        goto success;
 
                case ACT_NULL_ASSIGN:
                        if (value && *value)
                                /* Substitute parameter */
                                break;
 
                        if (!colon_seen && value) {
                                /* Substitute NULL */
                                if (free_value)
                                        free(value);
                                goto success;
                        }
 
                        if (free_value && value)
                                free(value);
 
                        value = pattern ? strdup(pattern) : pattern;
                        free_value = 1;
 
                        if (pattern && !value)
                                goto no_space;
 
                        setenv(env, value, 1);
                        break;
 
                default:
                        assert(!"Unrecognised action!");
                }
        }
 
        free(env);
        env = NULL;
        free(pattern);
        pattern = NULL;
 
        if (seen_hash) {
                char param_length[21];
 
                param_length[20] = '\0';
                *word = w_addstr(*word, word_length, max_length,
                                                 _itoa(value ? strlen(value) : 0,
                                                                        &param_length[20]));
                if (free_value) {
                        assert(value != NULL);
                        free(value);
                }
 
                return *word ? 0 : WRDE_NOSPACE;
        }
 
        if (value == NULL)
                return 0;
 
        if (quoted || !pwordexp) {
                /* Quoted - no field split */
                *word = w_addstr(*word, word_length, max_length, value);
                if (free_value)
                        free(value);
 
                return *word ? 0 : WRDE_NOSPACE;
        } else {
                /* Need to field-split */
                char *value_copy = strdup(value);       /* Don't modify value */
                char *field_begin = value_copy;
                int seen_nonws_ifs = 0;
 
                if (free_value)
                        free(value);
 
                if (value_copy == NULL)
                        goto no_space;
 
                do {
                        char *field_end = field_begin;
                        char *next_field;
 
                        /* If this isn't the first field, start a new word */
                        if (field_begin != value_copy) {
                                if (w_addword(pwordexp, *word) == WRDE_NOSPACE) {
                                        free(value_copy);
                                        goto no_space;
                                }
 
                                *word = w_newword(word_length, max_length);
                        }
 
                        /* Skip IFS whitespace before the field */
                        field_begin += strspn(field_begin, ifs_white);
 
                        if (!seen_nonws_ifs && *field_begin == 0)
                                /* Nothing but whitespace */
                                break;
 
                        /* Search for the end of the field */
                        field_end = field_begin + strcspn(field_begin, ifs);
 
                        /* Set up pointer to the character after end of field and
                           skip whitespace IFS after it. */
                        next_field = field_end + strspn(field_end, ifs_white);
 
                        /* Skip at most one non-whitespace IFS character after the field */
                        seen_nonws_ifs = 0;
                        if (*next_field && strchr(ifs, *next_field)) {
                                seen_nonws_ifs = 1;
                                next_field++;
                        }
 
                        /* Null-terminate it */
                        *field_end = 0;
 
                        /* Tag a copy onto the current word */
                        *word = w_addstr(*word, word_length, max_length, field_begin);
 
                        if (*word == NULL && *field_begin != '\0') {
                                free(value_copy);
                                goto no_space;
                        }
 
                        field_begin = next_field;
                }
                while (seen_nonws_ifs || *field_begin);
 
                free(value_copy);
        }
 
        return 0;
 
  success:
        error = 0;
        goto do_error;
 
  no_space:
        error = WRDE_NOSPACE;
        goto do_error;
 
  syntax:
        error = WRDE_SYNTAX;
 
  do_error:
        if (env)
                free(env);
 
        if (pattern)
                free(pattern);
 
        return error;
}
#else
static inline int
parse_backtick(char **word, size_t * word_length, size_t * max_length,
                           const char *words, size_t * offset, int flags,
                           wordexp_t * pwordexp, const char *ifs,
                           const char *ifs_white)
{
        return 0;
}
#endif
 
static int
parse_dollars(char **word, size_t * word_length, size_t * max_length,
                          const char *words, size_t * offset, int flags,
                          wordexp_t * pwordexp, const char *ifs, const char *ifs_white,
                          int quoted)
{
        /* We are poised _at_ "$" */
        switch (words[1 + *offset]) {
        case '"':
        case '\'':
        case 0:
                *word = w_addchar(*word, word_length, max_length, '$');
                return *word ? 0 : WRDE_NOSPACE;
 
#ifdef __WORDEXP_FULL
        case '(':
                if (words[2 + *offset] == '(') {
                        /* Differentiate between $((1+3)) and $((echo);(ls)) */
                        int i = 3 + *offset;
                        int depth = 0;
 
                        while (words[i] && !(depth == 0 && words[i] == ')')) {
                                if (words[i] == '(')
                                        ++depth;
                                else if (words[i] == ')')
                                        --depth;
 
                                ++i;
                        }
 
                        if (words[i] == ')' && words[i + 1] == ')') {
                                (*offset) += 3;
                                /* Call parse_arith -- 0 is for "no brackets" */
                                return parse_arith(word, word_length, max_length, words,
                                                                   offset, flags, 0);
                        }
                }
 
                if (flags & WRDE_NOCMD)
                        return WRDE_CMDSUB;
 
                (*offset) += 2;
                return parse_comm(word, word_length, max_length, words, offset,
                                                  flags, quoted ? NULL : pwordexp, ifs, ifs_white);
 
        case '[':
                (*offset) += 2;
                /* Call parse_arith -- 1 is for "brackets" */
                return parse_arith(word, word_length, max_length, words, offset,
                                                   flags, 1);
 
        case '{':
        default:
                ++(*offset);                    /* parse_param needs to know if "{" is there */
                return parse_param(word, word_length, max_length, words, offset,
                                                   flags, pwordexp, ifs, ifs_white, quoted);
#else
        default:
                ++(*offset);                    /* parse_param needs to know if "{" is there */
                return 0;
#endif
        }
}
 
static int
parse_dquote(char **word, size_t * word_length, size_t * max_length,
                         const char *words, size_t * offset, int flags,
                         wordexp_t * pwordexp, const char *ifs, const char *ifs_white)
{
        /* We are poised just after a double-quote */
        int error;
 
        for (; words[*offset]; ++(*offset)) {
                switch (words[*offset]) {
                case '"':
                        return 0;
 
                case '$':
                        error = parse_dollars(word, word_length, max_length, words, offset,
                                                          flags, pwordexp, ifs, ifs_white, 1);
                        /* The ``1'' here is to tell parse_dollars not to
                         * split the fields.  It may need to, however ("$@").
                         */
                        if (error)
                                return error;
 
                        break;
 
                case '`':
                        if (flags & WRDE_NOCMD)
                                return WRDE_CMDSUB;
 
                        ++(*offset);
                        error = parse_backtick(word, word_length, max_length, words,
                                                                   offset, flags, NULL, NULL, NULL);
                        /* The first NULL here is to tell parse_backtick not to
                         * split the fields.
                         */
                        if (error)
                                return error;
 
                        break;
 
                case '\\':
                        error = parse_qtd_backslash(word, word_length, max_length, words,
                                                                        offset);
 
                        if (error)
                                return error;
 
                        break;
 
                default:
                        *word = w_addchar(*word, word_length, max_length, words[*offset]);
                        if (*word == NULL)
                                return WRDE_NOSPACE;
                }
        }
 
        /* Unterminated string */
        return WRDE_SYNTAX;
}
 
/*
 * wordfree() is to be called after pwordexp is finished with.
 */
 
void wordfree(wordexp_t * pwordexp)
{
 
        /* wordexp can set pwordexp to NULL */
        if (pwordexp && pwordexp->we_wordv) {
                char **wordv = pwordexp->we_wordv;
 
                for (wordv += pwordexp->we_offs; *wordv; ++wordv)
                        free(*wordv);
 
                free(pwordexp->we_wordv);
                pwordexp->we_wordv = NULL;
        }
}
 
/*
 * wordexp()
 */
 
int wordexp(const char *words, wordexp_t * we, int flags)
{
        size_t words_offset;
        size_t word_length;
        size_t max_length;
        char *word = w_newword(&word_length, &max_length);
        int error;
        char *ifs;
        char ifs_white[4];
        wordexp_t old_word = *we;
 
        if (flags & WRDE_REUSE) {
                /* Minimal implementation of WRDE_REUSE for now */
                wordfree(we);
                old_word.we_wordv = NULL;
        }
 
        if ((flags & WRDE_APPEND) == 0) {
                we->we_wordc = 0;
 
                if (flags & WRDE_DOOFFS) {
                        we->we_wordv = calloc(1 + we->we_offs, sizeof(char *));
                        if (we->we_wordv == NULL) {
                                error = WRDE_NOSPACE;
                                goto do_error;
                        }
                } else {
                        we->we_wordv = calloc(1, sizeof(char *));
                        if (we->we_wordv == NULL) {
                                error = WRDE_NOSPACE;
                                goto do_error;
                        }
 
                        we->we_offs = 0;
                }
        }
 
        /* Find out what the field separators are.
         * There are two types: whitespace and non-whitespace.
         */
        ifs = getenv("IFS");
 
        if (!ifs)
                /* IFS unset - use <space><tab><newline>. */
                ifs = strcpy(ifs_white, " \t\n");
        else {
                char *ifsch = ifs;
                char *whch = ifs_white;
 
                /* Start off with no whitespace IFS characters */
                ifs_white[0] = '\0';
 
                while (*ifsch != '\0') {
                        if ((*ifsch == ' ') || (*ifsch == '\t') || (*ifsch == '\n')) {
                                /* Whitespace IFS.  See first whether it is already in our
                                   collection.  */
                                char *runp = ifs_white;
 
                                while (runp < whch && *runp != '\0' && *runp != *ifsch)
                                        ++runp;
 
                                if (runp == whch)
                                        *whch++ = *ifsch;
                        }
 
                        ++ifsch;
                }
                *whch = '\0';
        }
 
        for (words_offset = 0; words[words_offset]; ++words_offset)
                switch (words[words_offset]) {
                case '\\':
                        error = parse_backslash(&word, &word_length, &max_length, words,
                                                                &words_offset);
 
                        if (error)
                                goto do_error;
 
                        break;
 
                case '$':
                        error = parse_dollars(&word, &word_length, &max_length, words,
                                                                  &words_offset, flags, we, ifs, ifs_white,
                                                                  0);
 
                        if (error)
                                goto do_error;
 
                        break;
 
                case '`':
                        if (flags & WRDE_NOCMD) {
                                error = WRDE_CMDSUB;
                                goto do_error;
                        }
 
                        ++words_offset;
                        error = parse_backtick(&word, &word_length, &max_length, words,
                                                                   &words_offset, flags, we, ifs,
                                                                   ifs_white);
 
                        if (error)
                                goto do_error;
 
                        break;
 
                case '"':
                        ++words_offset;
                        error = parse_dquote(&word, &word_length, &max_length, words,
                                                                 &words_offset, flags, we, ifs, ifs_white);
 
                        if (error)
                                goto do_error;
 
                        if (!word_length) {
                                error = w_addword(we, NULL);
 
                                if (error)
                                        return error;
                        }
 
                        break;
 
                case '\'':
                        ++words_offset;
                        error = parse_squote(&word, &word_length, &max_length, words,
                                                                 &words_offset);
 
                        if (error)
                                goto do_error;
 
                        if (!word_length) {
                                error = w_addword(we, NULL);
 
                                if (error)
                                        return error;
                        }
 
                        break;
 
                case '~':
                        error = parse_tilde(&word, &word_length, &max_length, words,
                                                                &words_offset, we->we_wordc);
 
                        if (error)
                                goto do_error;
 
                        break;
 
                case '*':
                case '[':
                case '?':
                        error = parse_glob(&word, &word_length, &max_length, words,
                                                           &words_offset, flags, we, ifs, ifs_white);
 
                        if (error)
                                goto do_error;
 
                        break;
 
                default:
                        /* Is it a word separator? */
                        if (strchr(" \t", words[words_offset]) == NULL) {
                                char ch = words[words_offset];
 
                                /* Not a word separator -- but is it a valid word char? */
                                if (strchr("\n|&;<>(){}", ch)) {
                                        /* Fail */
                                        error = WRDE_BADCHAR;
                                        goto do_error;
                                }
 
                                /* "Ordinary" character -- add it to word */
                                word = w_addchar(word, &word_length, &max_length, ch);
                                if (word == NULL) {
                                        error = WRDE_NOSPACE;
                                        goto do_error;
                                }
 
                                break;
                        }
 
                        /* If a word has been delimited, add it to the list. */
                        if (word != NULL) {
                                error = w_addword(we, word);
                                if (error)
                                        goto do_error;
                        }
 
                        word = w_newword(&word_length, &max_length);
                }
 
        /* End of string */
 
        /* There was a word separator at the end */
        if (word == NULL)                       /* i.e. w_newword */
                return 0;
 
        /* There was no field separator at the end */
        return w_addword(we, word);
 
  do_error:
        /* Error:
         *  free memory used (unless error is WRDE_NOSPACE), and
         *  set we members back to what they were.
         */
 
        if (word != NULL)
                free(word);
 
        if (error == WRDE_NOSPACE)
                return WRDE_NOSPACE;
 
        if ((flags & WRDE_APPEND) == 0)
                wordfree(we);
 
        *we = old_word;
        return error;
}
Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [uClibc/] [libc/] [misc/] [wordexp/] [wordexp.c] - Blame information for rev 1765

Line No.	Rev	Author	Line
1	1325	phoenix	`/* vi: set sw=4 ts=4: */`
2			`/* POSIX.2 wordexp implementation.`
3			`Copyright (C) 1997, 1998, 1999 Free Software Foundation, Inc.`
4			`This file is part of the GNU C Library.`
5			`Contributed by Tim Waugh <tim@cyberelk.demon.co.uk>.`
6
7			`The GNU C Library is free software; you can redistribute it and/or`
8			`modify it under the terms of the GNU Library General Public License as`
9			`published by the Free Software Foundation; either version 2 of the`
10			`License, or (at your option) any later version.`
11
12			`The GNU C Library is distributed in the hope that it will be useful,`
13			`but WITHOUT ANY WARRANTY; without even the implied warranty of`
14			`MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU`
15			`Library General Public License for more details.`
16
17			`You should have received a copy of the GNU Library General Public`
18			`License along with the GNU C Library; see the file COPYING.LIB. If not,`
19			`write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,`
20			`Boston, MA 02111-1307, USA. */`
21
22			`#define _GNU_SOURCE`
23			`#include <sys/cdefs.h>`
24			`#include <sys/types.h>`
25			`#include <sys/wait.h>`
26			`#include <fcntl.h>`
27			`#include <paths.h>`
28			`#include <stdio.h>`
29			`#include <stdlib.h>`
30			`#include <string.h>`
31			`#include <unistd.h>`
32			`#include <pwd.h>`
33			`#include <errno.h>`
34			`#include <assert.h>`
35			`#include <fnmatch.h>`
36			`#include <glob.h>`
37			`#include <wordexp.h>`
38
39			`#define __WORDEXP_FULL`
40			`//#undef __WORDEXP_FULL`