head	1.21;
access;
symbols
	OSSP_RC_ALPHA_06:1.19
	OSSP_RC_EXBROKEN:1.14;
locks; strict;
comment	@ * @;


1.21
date	2003.06.18.14.35.29;	author ms;	state dead;
branches;
next	1.20;

1.20
date	2003.06.13.18.33.07;	author ms;	state Exp;
branches;
next	1.19;

1.19
date	2003.05.28.19.03.25;	author ms;	state Exp;
branches;
next	1.18;

1.18
date	2003.05.28.15.09.29;	author ms;	state Exp;
branches;
next	1.17;

1.17
date	2003.05.28.13.12.31;	author ms;	state Exp;
branches;
next	1.16;

1.16
date	2003.05.27.14.51.38;	author ms;	state Exp;
branches;
next	1.15;

1.15
date	2003.05.26.16.03.56;	author ms;	state Exp;
branches;
next	1.14;

1.14
date	2003.05.20.15.06.41;	author ms;	state Exp;
branches;
next	1.13;

1.13
date	2003.05.15.12.49.11;	author ms;	state Exp;
branches;
next	1.12;

1.12
date	2003.05.12.15.43.32;	author ms;	state Exp;
branches;
next	1.11;

1.11
date	2002.08.02.20.09.59;	author ms;	state Exp;
branches;
next	1.10;

1.10
date	2002.08.01.09.45.19;	author ms;	state Exp;
branches;
next	1.9;

1.9
date	2002.08.01.08.55.05;	author ms;	state Exp;
branches;
next	1.8;

1.8
date	2002.06.28.17.43.23;	author ms;	state Exp;
branches;
next	1.7;

1.7
date	2002.06.28.14.20.23;	author ms;	state Exp;
branches;
next	1.6;

1.6
date	2002.06.27.15.35.58;	author ms;	state Exp;
branches;
next	1.5;

1.5
date	2002.06.26.14.11.16;	author ms;	state Exp;
branches;
next	1.4;

1.4
date	2002.06.05.16.24.20;	author ms;	state Exp;
branches;
next	1.3;

1.3
date	2002.05.29.12.42.08;	author ms;	state Exp;
branches;
next	1.2;

1.2
date	2002.05.23.18.03.20;	author ms;	state Exp;
branches;
next	1.1;

1.1
date	2002.05.22.16.01.49;	author ms;	state Exp;
branches;
next	;


desc
@@


1.21
log
@Removed analyzer class, removed label class, implemented list class,
implemented file class, cleanup and restructure.
@
text
@/*  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_anal.c: Run-command processor ISO C source file
*/

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

#include "rc.h"         /* Public interfaces        */
#include "rc_const.h"   /* String constants         */
#include "rc_config.h"  /* Configuration interface  */


/************************************************
* analNew(void)                                 *
* Construct a new analyser                      *
************************************************/
rc_anal_t *analNew(void)
{
    rc_anal_t *pNew = NULL;

    /* Allocate storage for 1 anal object */
    pNew = calloc(1, sizeof(rc_anal_t));
    return(pNew);
}

/************************************************
* private analRcs(rc_anal_t *, const char *)    *
* Read a rc file identifier to analyse          *
************************************************/
rc_return_t analRcs(rc_anal_t *pInst, const char *kszName)
{
    ex_t Except;

    assert(!(pInst)->m_pszRcs); /* Rcs should be NULL until we set them */

    if (!kszName)
        return(RC_THROW(RC_ERR_RCF));
    else { /* Only enter block with valid string, strdup can't handle NULL */
        pInst->m_pszRcs = malloc(sizeof(char **));
        if (strcmp(kszName, RC_GLOB_WILD)) {
            pInst->m_pszRcs = malloc(sizeof(*(pInst->m_pszRcs)) * 2);
            pInst->m_pszRcs[0] = strdup(kszName);
            pInst->m_pszRcs[0] = strdup(kszName);
            pInst->m_pszRcs[1] = NULL;
            pInst->m_nRcs = 1;            /* We handle just one rc file */
        }
        else { /* Wildcard rcfile indicates we must glob the locs directories */
            try {
                analGloblocs(pInst);
            }
            catch(Except)
                rethrow;
        }
    }

    return(RC_THROW(RC_OK));
}

/************************************************
* analGloblocs(rc_anal_t *pInst)                *
* Glob all files of the location directories    *
************************************************/
rc_return_t analGloblocs(rc_anal_t *pInst)
{
    DIR *pLocdir = NULL;
    struct dirent *pDirent = NULL;
    char *szLocations = NULL;   /* Locations of run command files */
    int nCount = 0;             /* How many globbed files we find */
    int nIter = 0;              /* Used to step through found files */

    assert(pInst); /* Sanity check */

    /* Build the location path name */
    if (!configGetval(RC_LOC_VAL)) {
        szLocations = NULL;
        szLocations = strdup("./"); /* FIXME: Relocate default val */
        RC_THROW(RC_ERR_INT);       /* Config should have given a locs default */
    }
    else { /* Only enter block with valid string, strdup can't handle NULL */
        if (*(configGetval(RC_LOC_VAL) + strlen(configGetval(RC_LOC_VAL)) - sizeof (char)) != '/') {
            szLocations = malloc(strlen(configGetval(RC_LOC_VAL)) + \
                                 sizeof (char) + \
                                 sizeof (char));
            strcpy(szLocations, configGetval(RC_LOC_VAL));
            strcat(szLocations, "/");
        }
        else
            szLocations = strdup(configGetval(RC_LOC_VAL));
    }

    /* First just learn how many globbed files we have */
    if ((pLocdir = opendir(szLocations)) == NULL)
        return(RC_THROW(RC_ERR_DIR));
    for (pDirent = readdir(pLocdir); pDirent; pDirent = readdir(pLocdir))
        if (!strncmp(pDirent->d_name, "rc.", 3))
            nCount++;
    closedir(pLocdir);

    if (nCount == 0) /* Check out the health of this directory listing */
        return(RC_THROW(RC_ERR_DIR));
    else /* Allocate for the string array to hold directory entry names */
        pInst->m_pszRcs = malloc(sizeof(pInst->m_pszRcs) * (nCount + 1));

    /* Loop through file index setting rc file names according to dirent */
    if ((pLocdir = opendir(szLocations)) == NULL)
        return(RC_THROW(RC_ERR_DIR));
    for (pDirent = readdir(pLocdir); pDirent; pDirent = readdir(pLocdir)) {
        if (!strncmp(pDirent->d_name, "rc.", 3)) {
            pInst->m_pszRcs[nIter] = strdup(pDirent->d_name + \
                                         strlen("rc.") * sizeof(char));
            nIter++;
        }
    }
    closedir(pLocdir);

    pInst->m_pszRcs[nIter] = NULL; /* Terminate */
    pInst->m_nRcs = nCount; /* Store how many globbed files there are */

    return(RC_THROW(RC_OK));
}

/************************************************
* analDelete(rc_anal_t *)                       *
* Destruct an analyser                          *
************************************************/
rc_return_t analDelete(rc_anal_t *pInst)
{
/* FIXME: It could be that pInst needs to be a double pointer to */
/*        be properly used in destruction. Otherwise members are */
/*        just copies of the stack parameters passed in.         */
    int nIter = 0;

    assert(pInst); /* Verify sanity */

    if (pInst->m_pszRcs && pInst->m_pszRcs[nIter])
        while (pInst->m_pszRcs[nIter]) /* Rc file names    */
            free(pInst->m_pszRcs[nIter++]);
    if (pInst->m_pszRcs)            /* Rc file name index  */
        free(pInst->m_pszRcs);

    free(pInst);

    return(RC_THROW(RC_OK));
}

@


1.20
log
@Sweeping cleanups. Reduced the analyzer to almost nothing. Removed unused
method prototypes. Added 'parse' mode option that doesn't work yet. Removed
procReadtmp. Change the way we build path names from the locations directory.
@
text
@@


1.19
log
@Clean up analyser object, and remove some obsolete code.
@
text
@d53 1
a53 1
* private analRcs(rc_anal_t **, const char *)   *
d56 1
a56 1
rc_return_t analRcs(rc_anal_t **ppInst, const char *kszName)
d60 1
a60 1
    assert(!(*ppInst)->m_pszRcs); /* Rcs should be NULL until we set them */
d65 1
a65 1
        (*ppInst)->m_pszRcs = malloc(sizeof(char **));
d67 5
a71 5
            (*ppInst)->m_pszRcs = malloc(sizeof(*((*ppInst)->m_pszRcs)) * 2);
            (*ppInst)->m_pszRcs[0] = strdup(kszName);
            (*ppInst)->m_pszRcs[0] = strdup(kszName);
            (*ppInst)->m_pszRcs[1] = NULL;
            (*ppInst)->m_nRcs = 1;            /* We handle just one rc file */
d75 1
a75 1
                analGloblocs(ppInst);
d86 2
a87 2
* private analTmp(rc_anal_t **, const char *)   *
* Read a temp file to analyze                   *
d89 1
a89 1
rc_return_t analTmp(rc_anal_t **ppInst, const char *kszName)
d91 13
a103 3
    if (!kszName) {
        (*ppInst)->m_szTmp = NULL;
/*        RC_THROW(RC_WRN_NUL);*/
d106 6
a111 40
        (*ppInst)->m_szTmp = strdup(kszName);
    }

    return(RC_THROW(RC_OK));
}

/************************************************
* private analFuncs(rc_anal_t **, const char *) *
* Read a functions file to analyse              *
************************************************/
rc_return_t analFuncs(rc_anal_t **ppInst, const char *kszName)
{
    if (!kszName) {
        (*ppInst)->m_szFuncs = NULL;
/*        RC_THROW(RC_WRN_NUL);*/
    }
    else { /* Only enter block with valid string, strdup can't handle NULL */
        (*ppInst)->m_szFuncs = strdup(kszName);
    }

    return(RC_THROW(RC_OK));
}

/************************************************
* private analLocs(rc_anal_t **, const char *)  *
* Read a location path expression to analyse    *
************************************************/
rc_return_t analLocs(rc_anal_t **ppInst, const char *kszPathexpr)
{
    if (!kszPathexpr) {
        (*ppInst)->m_szLocs = NULL;
        (*ppInst)->m_szLocs = strdup("./"); /* FIXME: Relocate default val */
/*        RC_THROW(RC_WRN_NUL);*/ /* FIXME: ex_ Illegal instruction - core dumped */
    }
    else { /* Only enter block with valid string, strdup can't handle NULL */
        if (*(kszPathexpr + strlen(kszPathexpr)) != '/') {
            (*ppInst)->m_szLocs = malloc(strlen(kszPathexpr) + 2 * sizeof(char));
            strcpy((*ppInst)->m_szLocs, kszPathexpr);
            if ((char)*((*ppInst)->m_szLocs + strlen((*ppInst)->m_szLocs) - 1) != '/')
                strcat((*ppInst)->m_szLocs, "/");
d114 1
a114 1
            (*ppInst)->m_szLocs = strdup(kszPathexpr);
a116 38
    return(RC_THROW(RC_OK));
}

/************************************************
* private analSecs(rc_anal_t **, const char **) *
* Read a sections vector to analyse             *
************************************************/
rc_return_t analSecs(rc_anal_t **ppInst, const char **pkszVector)
{
    ex_t Except;

    if (!pkszVector) {
        RC_THROW(RC_WRN_NUL);
    }

    ex_try {    /* Sections are a vector, so we must copy accordingly */
        (*ppInst)->m_pszSecs = vectorCopy(pkszVector);
        (*ppInst)->m_nSecs   = vectorCount(pkszVector);
    }
    ex_catch(Except)
        rethrow;

    return(RC_THROW(RC_OK));
}

/************************************************
* analGloblocs(rc_anal_t **ppInst)              *
* Glob all files of the location directories    *
************************************************/
rc_return_t analGloblocs(rc_anal_t **ppInst)
{
    DIR *pLocdir = NULL;
    struct dirent *pDirent = NULL;
    int nCount = 0; /* How many globbed files we find */
    int nIter = 0;  /* Used to step through found files */

    assert(*ppInst); /* Sanity check */

d118 1
a118 1
    if ((pLocdir = opendir((*ppInst)->m_szLocs)) == NULL)
d128 1
a128 1
        (*ppInst)->m_pszRcs = malloc(sizeof(*((*ppInst)->m_pszRcs)) * (nCount + 1));
d131 1
a131 1
    if ((pLocdir = opendir((*ppInst)->m_szLocs)) == NULL)
d135 1
a135 1
            (*ppInst)->m_pszRcs[nIter] = strdup(pDirent->d_name + \
d142 2
a143 24
    (*ppInst)->m_pszRcs[nIter] = NULL; /* Terminate */
    (*ppInst)->m_nRcs = nCount; /* Store how many globbed files there are */

    return(RC_THROW(RC_OK));
}

/************************************************
* analParse(rc_anal_t *)                        *
* Parse the analyzed configuration data         *
************************************************/
rc_return_t analParse(rc_anal_t *pInst)
{
    ex_t Except;

    assert(pInst); /* Verify sanity */
    ex_try { /* Read in data from the main configuration */
        analLocs (&pInst, configGetval(RC_LOC_VAL));
        analRcs  (&pInst, configGetrcfile());
        analTmp  (&pInst, configGetval(RC_TMP_VAL));
        analFuncs(&pInst, configGetval(RC_FNC_VAL));
        analSecs (&pInst, configGetsecs());
    }
    ex_catch(Except)
        rethrow;
a165 8
    if (pInst->m_szTmp)             /* Temp file name      */
        free(pInst->m_szTmp);
    if (pInst->m_szFuncs)           /* Function file names */
        free(pInst->m_szFuncs);
    if (pInst->m_szLocs)            /* Location path names */
        free(pInst->m_szLocs);
    if (pInst->m_pszSecs)           /* Section names       */
        vectorDel(pInst->m_pszSecs);
@


1.18
log
@Fix incorrect variable name m_szRcs, bug fix analyzer rc list algorythm.
@
text
@d32 1
a36 1
#include "rc_anal.h"    /* Anal specific headers    */
a163 14
}

/***************************************************************
* int analFileselect(struct dirent *Direntry)                  *
* Calculate whether a directory entry belongs to a defined set *
***************************************************************/
int analFileselect(struct dirent *Direntry)
{
    if ((Direntry->d_name != NULL) && (strncmp(Direntry->d_name, "rc.", 3) == 0))
        return (TRUE);
    else if ((strcmp(Direntry->d_name, ".") == 0) || (strcmp(Direntry->d_name, "..") == 0))
        return (FALSE);
    else /* Catchall returns false for all not met set conditions */
        return (FALSE);
@


1.17
log
@Replace nonportable scandir(3) with portable opendir(3) and readdir(3).
@
text
@d60 1
a60 1
    assert(!(*ppInst)->m_szRcs); /* Rcs should be NULL until we set them */
d65 1
a65 1
        (*ppInst)->m_szRcs = malloc(sizeof(char **));
d67 4
a70 2
            (*ppInst)->m_szRcs = malloc(sizeof(*((*ppInst)->m_szRcs)));
            *(*ppInst)->m_szRcs = strdup(kszName);
d204 1
a204 1
        (*ppInst)->m_szRcs = malloc(sizeof((*((*ppInst)->m_szRcs))) * (nCount + 1));
d211 2
a212 2
            (*ppInst)->m_szRcs[nIter] = strdup(pDirent->d_name + \
                                        strlen("rc.") * sizeof(char));
d218 1
a218 1
    (*ppInst)->m_szRcs[nIter] = NULL; /* Terminate */
d259 5
a263 5
    if (pInst->m_szRcs && pInst->m_szRcs[nIter])
        while (pInst->m_szRcs[nIter]) /* Rc file names     */
            free(pInst->m_szRcs[nIter++]);
    if (pInst->m_szRcs)             /* Rc file name index  */
        free(pInst->m_szRcs);
@


1.16
log
@Fix vector copy terminate bug, and add checks to processor.
@
text
@d184 2
a185 1
    struct dirent ***pppFiles = NULL;
d187 1
a187 1
    int nIter  = 0; /* Iterate over the number of globbed files */
d189 1
a189 1
    assert(*ppInst); /* Verify sanity */
d191 7
a197 3
    /* Write the globbed filenames to our anal object */
    pppFiles = malloc(sizeof(struct dirent));
    nCount = scandir((*ppInst)->m_szLocs, pppFiles, analFileselect, alphasort);
d199 1
a199 2
    /* Check out the health of this directory listing */
    if (nCount == -1)
d205 8
a212 3
    for (nIter = 0; nIter < nCount; ++nIter) {
        (*ppInst)->m_szRcs[nIter] = strdup((*pppFiles)[nIter]->d_name +\
            strlen("rc.") * sizeof(char));
d214 2
a217 6

    /* Cleanup our Dirent object */
    if (pppFiles) {
        free(pppFiles);
        pppFiles = NULL;
    }
@


1.15
log
@Preliminary exception handling repairs.
@
text
@d250 5
a254 2
    while (pInst->m_szRcs[nIter])   /* Rc file names       */
        free(pInst->m_szRcs[nIter++]);
@


1.14
log
@Implement rc label ordered command printing and execution.
@
text
@d75 2
a76 4
            catch(Except) {
fprintf(stderr, "Placeholder until ex_ looping bug is fixed.\n");
/*                rethrow;*/ /* FIXME: Ralf! Looping problem with ex_ hier! */
            }
d158 2
a159 4
    ex_catch(Except) {
TRACE("VectorCopy broke");
/*        rethrow;*/
    }
@


1.13
log
@Add sectionCopy(), sectionDump(), and vectorCount(), and change the processor
object's script vector to a section vector.
@
text
@d68 1
a68 2
            *(*ppInst)->m_szRcs = strdup("rc."); /* FIXME: Remove hardcoded */
            strcat(*(*ppInst)->m_szRcs, kszName);
d205 4
a208 2
    for (nIter = 0; nIter < nCount; ++nIter)
        (*ppInst)->m_szRcs[nIter] = strdup((*pppFiles)[nIter]->d_name);
@


1.12
log
@Bugfix the analyser and processor.
@
text
@d159 1
@


1.11
log
@Intermediate priority implementation flush. Build is broken.
@
text
@d70 1
@


1.10
log
@Fix rcfile globbing.
@
text
@d206 2
a207 1
    (*ppInst)->m_szRcs[nIter] = NULL;
@


1.9
log
@Sqash double-slash pathname bug.
@
text
@d67 1
d188 2
a189 2
    int nIter  = 0;
    int nCount = 0;
d197 1
a197 1
    /* Check out the health of this directory */
d200 2
d203 1
a203 1
    /* Loop through file index setting Rf file names according to dirent */
d245 3
@


1.8
log
@Improved section parsing and added back most error condition logic. All
combinations of wildcard globbing, multiple section parsing, and error
handling now work (except for a problem relating to or using ex).
@
text
@d133 2
a134 1
            strcat((*ppInst)->m_szLocs, "/");
@


1.7
log
@Fixed memory bound violation and added section parsing logic.
@
text
@d58 2
d62 2
a63 4
    if (!kszName) {
        (*ppInst)->m_szRcs = NULL;
/*        RC_THROW(RC_WRN_NUL);*/
    }
d67 1
a67 1
            *(*ppInst)->m_szRcs = strdup("rc.");
d70 9
a78 2
        else /* Wildcard rcfile indicates we must glob the locs directories */
            analGloblocs(ppInst);
d127 1
a127 1
/*        RC_THROW(RC_WRN_NUL);*/
d130 7
a136 1
        (*ppInst)->m_szLocs = strdup(kszPathexpr);
d195 4
d229 2
a230 4
    ex_catch(Except) {
TRACE("Parsing broke");
/*        rethrow;*/
    }
@


1.6
log
@Added 'all' wildcard rcfile globbing and removed location hardcoding and
rcfile prefix hardcoding.
@
text
@d58 2
a68 1
            *((*ppInst)->m_szRcs + sizeof(char **)) = NULL; /* Terminate list */
d245 1
@


1.5
log
@Intermediate committal, lots of additions, compiles and works very limited.
@
text
@d34 1
d36 1
d63 8
a70 1
        (*ppInst)->m_szRcs = strdup(kszName);
d118 1
d151 44
d205 1
a208 1
        analLocs (&pInst, configGetval(RC_LOC_VAL));
d225 5
a229 1
    if (pInst->m_szRcs)         /* Rc file names       */
d231 1
a231 1
    if (pInst->m_szTmp)         /* Temp file name      */
d233 1
a233 1
    if (pInst->m_szFuncs)       /* Function file names */
d235 1
a235 1
    if (pInst->m_szLocs)        /* Location path names */
d237 1
a237 1
    if (pInst->m_pszSecs)       /* Section names       */
@


1.4
log
@Found segfault bug to be a problem with ex_throw(3), so we go without error
reporting during analysis for the moment.
@
text
@d45 2
a46 1
    pNew = malloc(sizeof(rc_anal_t));
d56 2
a57 3
    if (!kszName)
        TRACE("Error codition, NULL passed as argument");
/* FIXME Das ist very broken!  */
d59 1
d69 1
a69 1
* Read a temp file to use for analysis          *
d74 1
a74 2
        TRACE("Error codition, NULL passed as argument");
/* FIXME Das ist very broken!  */
d90 2
a91 3
    if (!kszName)
        TRACE("Error codition, NULL passed as argument");
/* FIXME Das ist very broken!  */
d93 1
d107 2
a108 3
    if (!kszPathexpr)
        TRACE("Error codition, NULL passed as argument");
/* FIXME Das ist very broken!  */
d110 1
d126 3
a128 4
    if (!pkszVector)
        TRACE("Error codition, NULL passed as argument");
/* FIXME Das ist very broken!  */
/*        RC_THROW(RC_WRN_NUL);*/
d134 2
a135 1
        rethrow;
d158 2
a159 1
        rethrow;
@


1.3
log
@Temporary debug segfault committal.
@
text
@d56 3
a58 1
        RC_THROW(RC_WRN_NUL);
d60 1
a60 3
(*ppInst)->m_szRcs = strdup("Hello");
/*        (*ppInst)->m_szRcs = strdup(kszName);*/
        TRACE((*ppInst)->m_szRcs);
a71 1
TRACE("In analTmp 1");
d73 3
a75 3
TRACE("In analTmp 2");
        RC_THROW(RC_WRN_NUL);
TRACE("In analTmp 2.5");
d78 1
a78 5
TRACE("In analTmp 3");
        (*ppInst)->m_szTmp = strdup("Hello");
TRACE("In analTmp 4");
        TRACE((*ppInst)->m_szTmp);
TRACE("In analTmp 5");
a80 1
TRACE("In analTmp 6");
d91 3
a93 1
        RC_THROW(RC_WRN_NUL);
d95 1
a95 3
(*ppInst)->m_szFuncs = strdup("Hello");
/*        (*ppInst)->m_szFuncs = strdup(kszName);*/
        TRACE((*ppInst)->m_szFuncs);
d107 6
a112 7
TRACE("analLocs1");
    if (kszPathexpr) { /* Strdup can't handle NULL */
TRACE("analLocs2");
(*ppInst)->m_szLocs = strdup("Hello");
/*        (*ppInst)->m_szLocs = strdup(kszPathexpr);*/
        TRACE((*ppInst)->m_szLocs);
TRACE("analLocs3");
a114 1
TRACE("analLocs4");
d126 4
a129 5
#if 0
# FIXME Das ist very broken!
    if ((*ppInst)->m_pszSecs)   /* Warn on overwrites */
        RC_THROW(RC_WRN_OWR);
#endif
a137 1
    TRACE("Variable pkszVector is not an ANSI string.");
a151 1
TRACE("Alles wunderbar.0");
a152 1
TRACE("Alles wunderbar.1");
a153 1
TRACE("Alles wunderbar.nachFuncs");
a154 1
TRACE("Alles wunderbar.nachLocs");
a155 1
TRACE("Alles wunderbar.2");
d158 1
a158 2
TRACE("En analParse Exception catch state!");
/*        rethrow;*/
a169 2
TRACE("Alles wunderbar.3delete");
#if 0
a181 2
#endif
TRACE("Alles wunderbar.4delete");
@


1.2
log
@More flush work on analyzer.
@
text
@d58 2
a59 1
        (*ppInst)->m_szRcs = strdup(kszName);
d72 3
a74 1
    if (!kszName)
d76 2
d79 1
d81 1
d83 1
d86 1
d99 2
a100 1
        (*ppInst)->m_szFuncs = strdup(kszName);
d113 5
a117 4
    if (!kszPathexpr)
        RC_THROW(RC_WRN_NUL);
    else { /* Only enter block with valid string, strdup can't handle NULL */
        (*ppInst)->m_szLocs = strdup(kszPathexpr);
d119 1
d122 1
d134 2
d138 1
d162 1
d164 1
d166 1
d168 1
d170 1
d173 2
a174 1
        rethrow;
d186 2
d200 2
@


1.1
log
@Addition of configuration analyiser and related adjustments to other sources.
@
text
@d31 1
d50 1
a50 1
* private analRcs(rc_anal_t *, const char *)    *
d53 1
a53 1
rc_return_t analRcs(rc_anal_t *pInst, const char *kszName)
d55 7
a61 1
    TRACE(kszName);
d66 1
a66 1
* private analTmp(rc_anal_t *, const char *)    *
d69 1
a69 1
rc_return_t analTmp(rc_anal_t *pInst, const char *kszName)
d71 7
a77 1
    TRACE(kszName);
d82 1
a82 1
* private analFuncs(rc_anal_t *, const char *)  *
d85 1
a85 1
rc_return_t analFuncs(rc_anal_t *pInst, const char *kszName)
d87 7
a93 1
    TRACE(kszName);
d98 1
a98 1
* private analLocs(rc_anal_t *, const char *)   *
d101 1
a101 1
rc_return_t analLocs(rc_anal_t *pInst, const char *kszPathexpr)
d103 7
a109 1
    TRACE(kszPathexpr);
d114 1
a114 1
* private analSecs(rc_anal_t *, const char **)  *
d117 1
a117 1
rc_return_t analSecs(rc_anal_t *pInst, const char **pkszVector)
d119 12
d145 5
a149 5
        analRcs  (pInst, configGetrcfile());
        analTmp  (pInst, configGetval(RC_TMP_VAL));
        analFuncs(pInst, configGetval(RC_FNC_VAL));
        analLocs (pInst, configGetval(RC_LOC_VAL));
        analSecs (pInst, configGetsecs());
d164 11
@