parsinc.cc File Reference

#include "mbconfig.h"
#include <cstring>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include "parsinc.h"
#include "filename.h"

Include dependency graph for parsinc.cc:

Go to the source code of this file.

Classes
struct	IncludeDR
struct	ChDirDR

Macros
#define	PATH_MAX   4096
#define	MAXSUBST   10

Functions
static void	InitDescData (void)
static char *	expand_environment (const char *in)
static char *	resolve_filename (const char *filename_in)

Variables
static unsigned	desc_done

Macro Definition Documentation

#define MAXSUBST   10

Referenced by expand_environment().

#define PATH_MAX   4096

Definition at line 49 of file parsinc.cc.

Referenced by IncludeParser::Include_int(), and IncludeParser::IncludeParser().

Function Documentation

static char* expand_environment ( const char *  in )

static

Definition at line 436 of file parsinc.cc.

References buf, c, DEBUGCOUT, MAXSUBST, and SAFENEWARR.

Referenced by resolve_filename().

{
        char            *out = NULL;
#define MAXSUBST                10
        struct {
                unsigned        start;
                unsigned        end;
                const char      *value;
                unsigned        length;
        }               subst[MAXSUBST];
        unsigned        cnt = 0, c;

        DEBUGCOUT(">> expand_environment: " << in << std::endl);

        subst[cnt].start = 0;
        subst[cnt].end = 0;
        subst[cnt].value = NULL;
        subst[cnt].length = 0;
        for (c = 0; in[c]; c++) {
                if (in[c] == '$') {
                        if (cnt >= MAXSUBST - 2) {
                                silent_cerr("too many substitutions in \""
                                                << in << "\"" << std::endl);
                                return NULL;
                        }

                        subst[cnt].end = c;
                        if (in[c + 1] == '$') {
                                c++;
                                subst[cnt].start = c;
                                subst[cnt].value = "";
                                subst[cnt].length = 0;
                                continue;
                        }

                        c++;
                        unsigned namepos = c;
                        if (in[c] == '{') {
                                const char *end = std::strchr(&in[c], '}');

                                if (end == NULL) {
                                        silent_cerr("missing trailing \"}\" "
                                                        "in \"" << in << "\""
                                                        << std::endl);
                                        return NULL;
                                }

                                namepos++;
                                unsigned l = end - &in[namepos];
                                char buf[l + 1];
                                memcpy(buf, &in[namepos], l);
                                buf[l] = '\0';
                                subst[cnt].value = getenv(buf);
                                if (subst[cnt].value == NULL) {
                                        silent_cerr("unable to find "
                                                        "environment "
                                                        "variable \""
                                                        << buf << "\""
                                                        << std::endl);
                                        return NULL;
                                }

                                c = end - &in[0] + 1;

                        } else {
                                if (in[c] != '_' && !isalpha(in[c])) {
                                        silent_cerr("illegal leading char "
                                                        "in environment "
                                                        "variable name in \""
                                                        << in << "\""
                                                        << std::endl);
                                        return NULL;
                                }

                                for (c++; in[c]; c++) {
                                        if (in[c] != '_' && !isalnum(in[c])) {
                                                break;
                                        }
                                }

                                unsigned l = &in[c] - &in[namepos];
                                char buf[l + 1];
                                memcpy(buf, &in[namepos], l);
                                buf[l] = '\0';

                                subst[cnt].value = getenv(buf);
                                if (subst[cnt].value == NULL) {
                                        silent_cerr("unable to find "
                                                        "environment "
                                                        "variable \""
                                                        << buf << "\""
                                                        << std::endl);
                                        return NULL;
                                }
                        }

                        /* can't be NULL */
                        subst[cnt].length = strlen(subst[cnt].value);

                        cnt++;
                        subst[cnt].start = c;

                        /* because it's incremented again by "for" */
                        c--;
                }
        }
        subst[cnt].end = c;
        subst[cnt].value = NULL;
        subst[cnt].length = 0;

        unsigned len = 0;
        for (c = 0; c < cnt; c++) {
                len += (subst[c].end - subst[c].start) + subst[c].length;
        }
        len += subst[c].end - subst[c].start;

        SAFENEWARR(out, char, len + 1);

        unsigned p = 0;
        for (c = 0; c < cnt; c++) {
                unsigned l = subst[c].end - subst[c].start;
                if (l > 0) {
                        memcpy(&out[p], &in[subst[c].start], l);
                        p += l;
                }
                if (subst[c].length > 0) {
                        memcpy(&out[p], subst[c].value, subst[c].length);
                        p += subst[c].length;
                }
        }
        unsigned l = subst[c].end - subst[c].start;
        if (l > 0) {
                memcpy(&out[p], &in[subst[c].start], l);
                p += l;
        }
        out[p] = '\0';

        DEBUGCOUT("<< expand_environment: " << out << std::endl);

        return out;
}

static void InitDescData ( void  )

static

Definition at line 98 of file parsinc.cc.

References desc_done, and SetDescData().

Referenced by IncludeParser::IncludeParser().

{
        // NOTE: data will be destroyed when the underlying HighParser is destroyed (is this what we want?)
        if (::desc_done++ > 0) {
                return;
        }

        SetDescData("include", new IncludeDR);
        SetDescData("chdir", new ChDirDR);

        /* NOTE: add here initialization of new built-in descriptions;
         * alternative ways to register new custom descriptions are:
         * - call SetDescData() from anywhere in the code
         * - write a module that calls SetDescData() from inside a function
         *   called module_init(), and run-time load it using "module load"
         *   in the input file.
         */
}

Here is the call graph for this function:

static char* resolve_filename ( const char *  filename_in )

static

Definition at line 579 of file parsinc.cc.

References buf, DIR_SEP, expand_environment(), filename, SAFEDELETEARR, SAFENEWARR, and SAFESTRDUP.

Referenced by IncludeParser::GetFileName().

{
        char    *res = NULL,
                *filename = NULL;;

        if (strchr(filename_in, '$')) {
                filename = expand_environment(filename_in);
                if (filename == NULL) {
                        goto error_return;
                }
        } else {
                filename = (char *)filename_in;
        }
        
        if (filename[0] == '~') {
                filename++;
                if (filename[0] == DIR_SEP) {
                        /* do environment stuff */
                        char *home;
         
                        home = getenv("HOME");
                        if (home == NULL) {              
                                goto error_return;
                        }
         
                        char *s = NULL;
                        int l, ll;
         
                        l = strlen(home);
                        ll = l + strlen(filename) + 1;
                        SAFENEWARR(s, char, ll);
         
                        strncpy(s, home, l);
                        strcpy(s + l, filename);
         
                        res = s;
                        goto error_return;

#if defined(HAVE_PWD_H)
                } else {
                        const char *p;
         
                        p = std::strchr(filename, DIR_SEP);
                        if (p == NULL) {
                                goto error_return;
                        } 
         
                        int l = p - filename;
         
                        char buf[l + 1];
                        memcpy(buf, filename, l);
                        buf[l] = '\0';

                        /* do passwd stuff */
                        struct passwd *pw;
         
                        pw = getpwnam(buf);
         
                        if (pw == NULL ) {
                                goto error_return;
                        }
         
                        l = strlen(pw->pw_dir);
                        int ll = l + strlen(p) + 1;
                        char *s = NULL;
                        SAFENEWARR(s, char, ll);
                        strncpy(s, pw->pw_dir, l);
                        strcpy(s + l, p);
         
                        res = s;
                        goto error_return;
#endif /* HAVE_PWD_H */
                }
        }

error_return:;
        if (filename != NULL) {
                if (res == NULL) {
                        if (filename != filename_in) {
                                res = filename;
                        } else {
                                SAFESTRDUP(res, filename_in);
                        }
                } else {
                        if (filename != filename_in) {
                                SAFEDELETEARR(filename);
                        }
                }
        }

        return res;
}

Here is the call graph for this function:

Variable Documentation

unsigned desc_done

static

Definition at line 95 of file parsinc.cc.

Referenced by InitDescData().