/usr/src/RPM/BUILD/ctwm-4.1.0/parse.c

Go to the documentation of this file.

/*
 *       Copyright 1988 by Evans & Sutherland Computer Corporation,
 *                          Salt Lake City, Utah
 *  Portions Copyright 1989 by the Massachusetts Institute of Technology
 *                        Cambridge, Massachusetts
 *
 * Copyright 1992 Claude Lecommandeur.
 */
 
/***********************************************************************
 *
 * $XConsortium: parse.c,v 1.52 91/07/12 09:59:37 dave Exp $
 *
 * parse the .twmrc file
 *
 * 17-Nov-87 Thomas E. LaStrange       File created
 * 10-Oct-90 David M. Sternlicht       Storing saved colors on root
 *
 * Do the necessary modification to be integrated in ctwm.
 * Can no longer be used for the standard twm.
 *
 * 22-April-92 Claude Lecommandeur.
 *
 ***********************************************************************/
 
#include "ctwm.h"
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#ifdef USEM4
# include <sys/types.h>
# include <sys/wait.h>
#endif
 
#include "ctwm_atoms.h"
#include "screen.h"
#include "parse.h"
#include "parse_int.h"
#include "deftwmrc.h"
#ifdef SOUNDS
#  include "sound.h"
#endif
 
#ifndef SYSTEM_INIT_FILE
#error "No SYSTEM_INIT_FILE set"
#endif
 
static bool ParseStringList(const char **sl);
 
/*
 * With current bison, this is defined in the gram.tab.h, so this causes
 * a warning for redundant declaration.  With older bisons and byacc,
 * it's not, so taking it out causes a warning for implicit declaration.
 * A little looking around doesn't show any handy #define's we could use
 * to be sure of the difference.  This should quiet it down on gcc/clang
 * anyway...
 */
#ifdef __GNUC__
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wredundant-decls"
extern int yyparse(void);
# pragma GCC diagnostic pop
#else
extern int yyparse(void);
#endif
 
// Because of how this winds up shared with callback funcs in the
// parsing, it's difficult to unwind from being global, so just accept
// it.
static FILE *twmrc;
 
static int ptr = 0;
static int len = 0;
#define BUF_LEN 300
static char buff[BUF_LEN + 1];
static const char **stringListSource, *currentString;
 
#ifdef NON_FLEX_LEX
/*
 * While these are (were) referenced in a number of places through the
 * file, overflowlen is initialized to 0, only possibly changed in
 * twmUnput(), and unless it's non-zero, neither is otherwise touched.
 * So this is purely a twmUnput()-related var, and with flex, never used
 * for anything.
 */
static char overflowbuff[20];           /* really only need one */
static int overflowlen;
#endif
 
int ConstrainedMoveTime = 400;          /* milliseconds, event times */
bool ParseError;                        /* error parsing the .twmrc file */
int RaiseDelay = 0;                     /* msec, for AutoRaise */
int (*twmInputFunc)(void);              /* used in lexer */
 
static int twmrc_lineno;
 
 
/* Actual file loader */
static int ParseTwmrc(const char *filename);
 
/* lex plumbing funcs */
static bool doparse(int (*ifunc)(void), const char *srctypename,
                    const char *srcname);
 
static int twmStringListInput(void);
#ifndef USEM4
static int twmFileInput(void);
#else
static int m4twmFileInput(void);
#endif
 
#if defined(YYDEBUG) && YYDEBUG
int yydebug = 1;
#endif
 
 
/**
 * Principal entry point from top-level code to parse the config file.
 * This tries the various permutations of config files we could load.
 * For most possible names, we try loading `$NAME.$SCREENNUM` before
 * trying `$NAME`.  If a `-f filename` is given on the command line, it's
 * passed in here, and the normal `~/.[c]twmrc*` attempts are skipped if
 * it's not found.
 *
 * \param filename A filename given in the -f command-line argument (or
 * NULL)
 * \return true/false for whether a valid config was parsed out from
 * somewhere.
 */
bool
LoadTwmrc(const char *filename)
{
    int ret = -1;
    char *tryname = NULL;
 
    /*
     * Check for the twmrc file in the following order:
     *   0.  -f filename.#
     *   1.  -f filename
     *       (skip to 6 if -f was given)
     *   2.  .ctwmrc.#
     *   3.  .ctwmrc
     *   4.  .twmrc.#
     *   5.  .twmrc
     *   6.  system.ctwmrc
     */
#define TRY(fn) if((ret = ParseTwmrc(fn)) != -1) { goto DONE_TRYING; }  (void)0
 
    if(filename) {
        /* -f filename.# */
        asprintf(&tryname, "%s.%d", filename, Scr->screen);
        if(tryname == NULL) {
            // Oh, we're _screwed_...
            return false;
        }
        TRY(tryname);
 
        /* -f filename */
        TRY(filename);
 
        /* If we didn't get either from -f, don't try the ~ bits */
        goto TRY_FALLBACK;
    }
 
    if(Home) {
        /* ~/.ctwmrc.screennum */
        free(tryname);
        asprintf(&tryname, "%s/.ctwmrc.%d", Home, Scr->screen);
        if(tryname == NULL) {
            return false;
        }
        TRY(tryname);
 
        // All later attempts are guaranteed shorter strings than that,
        // so we can just keep sprintf'ing over it.
 
        /* ~/.ctwmrc */
        sprintf(tryname, "%s/.ctwmrc", Home);
        TRY(tryname);
 
        /* ~/.twmrc.screennum */
        sprintf(tryname, "%s/.twmrc.%d", Home, Scr->screen);
        TRY(tryname);
 
        /* ~/.twmrc */
        sprintf(tryname, "%s/.twmrc", Home);
        TRY(tryname);
    }
 
TRY_FALLBACK:
    /* system.twmrc */
    if((ret = ParseTwmrc(SYSTEM_INIT_FILE)) != -1) {
        if(ret && filename) {
            // If we were -f'ing, fell back to the system default, and
            // that succeeeded, we warn.  It's "normal"(ish) to not have
            // a personal twmrc and fall back...
            fprintf(stderr,
                    "%s:  unable to open twmrc file %s, using %s instead\n",
                    ProgramName, filename, SYSTEM_INIT_FILE);
        }
        goto DONE_TRYING;
    }
 
 
DONE_TRYING:
#undef TRY
    free(tryname);
 
    /*
     * If we wound up with -1 all the way, we totally failed to find a
     * file to work with.  Fall back to builtin config.
     */
    if(ret == -1) {
        // Only warn if -f.
        if(filename) {
            fprintf(stderr,
                    "%s:  unable to open twmrc file %s, using built-in defaults instead\n",
                    ProgramName, filename);
        }
        return ParseStringList(defTwmrc);
    }
 
 
    /* Better have a useful value in ret... */
    return ret;
}
 
 
/**
 * Try parsing a file as a ctwmrc.
 *
 * \param filename The filename to try opening and parsing.
 * \return -1,0,1.  0/1 should be treated as false/true for whether
 * parsing the file succeeded.  -1 means the file couldn't be opened.
 */
static int
ParseTwmrc(const char *filename)
{
    bool status;
 
#if 0
    fprintf(stderr, "%s(): Trying %s\n", __func__, filename);
#endif
 
    /* See if we can open the file */
    if(!filename) {
        return -1;
    }
    twmrc = fopen(filename, "r");
    if(!twmrc) {
        return -1;
    }
 
 
    /* Got it.  Kick off the parsing, however we do it. */
#ifdef USEM4
    FILE *raw = NULL;
    if(CLarg.GoThroughM4) {
        /*
         * Hold onto raw filehandle so we can fclose() it below, and
         * swap twmrc over to the output from m4
         */
        raw = twmrc;
        twmrc = start_m4(raw);
    }
    status = doparse(m4twmFileInput, "file", filename);
    fclose(twmrc);
    if(raw) {
        fclose(raw);
    }
#else
    status = doparse(twmFileInput, "file", filename);
    fclose(twmrc);
#endif
 
    /* And we're done */
    return status;
 
    /* NOTREACHED */
}
 
static bool
ParseStringList(const char **sl)
{
    stringListSource = sl;
    currentString = *sl;
    return doparse(twmStringListInput, "string list", NULL);
}
 
 
/*
 * Util used throughout the code (possibly often wrongly?)
 */
void twmrc_error_prefix(void)
{
    fprintf(stderr, "%s:  line %d:  ", ProgramName, twmrc_lineno);
}
 
 
 
/*
 * Everything below here is related to plumbing and firing off lex/yacc
 */
 
 
/*
 * Backend func that takes an input-providing func and hooks it up to the
 * lex/yacc parser to do the work
 */
static bool
doparse(int (*ifunc)(void), const char *srctypename,
        const char *srcname)
{
    ptr = 0;
    len = 0;
    twmrc_lineno = 0;
    ParseError = false;
    twmInputFunc = ifunc;
#ifdef NON_FLEX_LEX
    overflowlen = 0;
#endif
 
    yyparse();
 
    if(ParseError) {
        fprintf(stderr, "%s:  errors found in twm %s",
                ProgramName, srctypename);
        if(srcname) {
            fprintf(stderr, " \"%s\"", srcname);
        }
        fprintf(stderr, "\n");
    }
    return !(ParseError);
}
 
 
/*
 * Various input routines for the lexer for the various sources of
 * config.
 */
 
#ifndef USEM4
#include <ctype.h>
 
/* This has Tom's include() funtionality.  This is utterly useless if you
 * can use m4 for the same thing.               Chris P. Ross */
 
#define MAX_INCLUDES 10
 
static struct incl {
    FILE *fp;
    char *name;
    int lineno;
} rc_includes[MAX_INCLUDES];
static int include_file = 0;
 
 
static int twmFileInput(void)
{
#ifdef NON_FLEX_LEX
    if(overflowlen) {
        return (int) overflowbuff[--overflowlen];
    }
#endif
 
    while(ptr == len) {
        while(include_file) {
            if(fgets(buff, BUF_LEN, rc_includes[include_file].fp) == NULL) {
                free(rc_includes[include_file].name);
                fclose(rc_includes[include_file].fp);
                twmrc_lineno = rc_includes[include_file--].lineno;
            }
            else {
                break;
            }
        }
 
        if(!include_file)
            if(fgets(buff, BUF_LEN, twmrc) == NULL) {
                return 0;
            }
        twmrc_lineno++;
 
        if(strncmp(buff, "include", 7) == 0) {
            /* Whoops, an include file! */
            char *p = buff + 7, *q;
            FILE *fp;
 
            while(isspace(*p)) {
                p++;
            }
            for(q = p; *q && !isspace(*q); q++) {
                continue;
            }
            *q = 0;
 
            if((fp = fopen(p, "r")) == NULL) {
                fprintf(stderr, "%s: Unable to open included init file %s\n",
                        ProgramName, p);
                continue;
            }
            if(++include_file >= MAX_INCLUDES) {
                fprintf(stderr, "%s: init file includes nested too deep\n",
                        ProgramName);
                continue;
            }
            rc_includes[include_file].fp = fp;
            rc_includes[include_file].lineno = twmrc_lineno;
            twmrc_lineno = 0;
            rc_includes[include_file].name = strdup(p);
            continue;
        }
        ptr = 0;
        len = strlen(buff);
    }
    return ((int)buff[ptr++]);
}
#else /* USEM4 */
/* If you're going to use m4, use this version instead.  Much simpler.
 * m4 ism's credit to Josh Osborne (stripes) */
 
static int m4twmFileInput(void)
{
    int line;
    static FILE *cp = NULL;
 
    if(cp == NULL && CLarg.keepM4_filename) {
        cp = fopen(CLarg.keepM4_filename, "w");
        if(cp == NULL) {
            fprintf(stderr,
                    "%s:  unable to create m4 output %s, ignoring\n",
                    ProgramName, CLarg.keepM4_filename);
            CLarg.keepM4_filename = NULL;
        }
    }
 
#ifdef NON_FLEX_LEX
    if(overflowlen) {
        return((int) overflowbuff[--overflowlen]);
    }
#endif
 
    while(ptr == len) {
nextline:
        if(fgets(buff, BUF_LEN, twmrc) == NULL) {
            if(cp) {
                fclose(cp);
            }
            return(0);
        }
        if(cp) {
            fputs(buff, cp);
        }
 
        if(sscanf(buff, "#line %d", &line)) {
            twmrc_lineno = line - 1;
            goto nextline;
        }
        else {
            twmrc_lineno++;
        }
 
        ptr = 0;
        len = strlen(buff);
    }
    return ((int)buff[ptr++]);
}
#endif /* USEM4 */
 
 
static int twmStringListInput(void)
{
#ifdef NON_FLEX_LEX
    if(overflowlen) {
        return (int) overflowbuff[--overflowlen];
    }
#endif
 
    /*
     * return the character currently pointed to
     */
    if(currentString) {
        unsigned int c = (unsigned int) * currentString++;
 
        if(c) {
            return c;        /* if non-nul char */
        }
        currentString = *++stringListSource;  /* advance to next bol */
        return '\n';                    /* but say that we hit last eol */
    }
    return 0;                           /* eof */
}
 
 
 
/*
 * unput/output funcs for AT&T lex.  No longer supported, and expected to
 * be GC'd in a release or two.
 */
#ifdef NON_FLEX_LEX
 
void twmUnput(int c)
{
    if(overflowlen < sizeof overflowbuff) {
        overflowbuff[overflowlen++] = (char) c;
    }
    else {
        twmrc_error_prefix();
        fprintf(stderr, "unable to unput character (%c)\n",
                c);
    }
}
 
void TwmOutput(int c)
{
    putchar(c);
}
 
#endif /* NON_FLEX_LEX */