/*  OSSP rc - Run-command processor
**  Copyright (c) 2002 Ralf S. Engelschall
**  Copyright (c) 2002 Cable & Wireless Deutschland GmbH
**  Copyright (c) 2002 The OSSP Project <http://www.ossp.org/>
**
**  This file is part of OSSP rc, a portable Run-command processor
**  which can be found at http://www.ossp.org/pkg/lib/rc/
**
**  Permission to use, copy, modify, and distribute this software for
**  any purpose with or without fee is hereby granted, provided that
**  the above copyright notice and this permission notice appear in all
**  copies.
**
**  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
**  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
**  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
**  IN NO EVENT SHALL THE AUTHORS AND COPYRIGHT HOLDERS AND THEIR
**  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
**  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
**  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
**  USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
**  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
**  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
**  OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
**  SUCH DAMAGE.
**
**  rc_util.c: Run-command processor ISO C source file
*/

#include <stdlib.h>
#include <string.h>

#include "rc.h"         /* Error definitions  */
#include "rc_const.h"   /* String definitions */


/* Translate an error code to a string */
char *strErr(rc_return_t rv)
{
    if      (rv == RC_OK)      return RC_ERRSTR_OK;
    else if (rv == RC_ERR_USE) return RC_ERRSTR_USE;
    else if (rv == RC_ERR_MEM) return RC_ERRSTR_MEM;
    else if (rv == RC_ERR_SYS) return RC_ERRSTR_SYS;
    else if (rv == RC_ERR_IO)  return RC_ERRSTR_IO;
    else if (rv == RC_ERR_INT) return RC_ERRSTR_INT;
    else if (rv == RC_ERR_FNC) return RC_ERRSTR_FNC;
    else if (rv == RC_ERR_DIR) return RC_ERRSTR_DIR;
    else if (rv == RC_ERR_RCF) return RC_ERRSTR_RCF;
    else if (rv == RC_ERR_TRM) return RC_ERRSTR_TRM;
    else if (rv == RC_WRN_OWR) return RC_WRNSTR_OWR;
    else if (rv == RC_WRN_NUL) return RC_WRNSTR_NUL;
    else                       return RC_ERRSTR_UNK;
}

/* Vector copy constructor */
char **vectorCopy(const char **kpszVec)
{
    int nSecs  = 0;
    int nIndex = 0;
    char **pszTemp = NULL;

    if (kpszVec) {
        for (nSecs = 0; kpszVec[nSecs]; nSecs++);   /* Count the sections */
        pszTemp = malloc(sizeof (char **) * nSecs + 1);

        for (nIndex = 0; kpszVec[nIndex]; nIndex++) {           /* Copy loop */
            pszTemp[nIndex] = malloc(strlen(kpszVec[nIndex]));  /* for each  */
            memcpy(pszTemp[nIndex], kpszVec[nIndex],            /* element   */
                   strlen(kpszVec[nIndex]));                    /* in vector */
        }
        pszTemp[nIndex] = NULL; /* Used later to find the end of the array */
        return(pszTemp);        /* Success */
    }
    else
        RC_THROW(RC_ERR_USE);   /* Incoming vector is NULL? */

    return(NULL);               /* Failure */
}

/* Vector destructor */
rc_return_t vectorDel(char **pszVec)
{
    int i;
    assert(pszVec);                 /* Check for unallocated incoming */

    for (i = 0; pszVec[i]; i++) {   /* Loop through elements   */
        free(pszVec[i]);            /* of vector, deallocating */
        pszVec[i] = NULL;           /* along the way           */
    }

    free(pszVec);                   /* Free the vector itself  */
    pszVec = NULL;

    return(RC_THROW(RC_OK));
}