~ctwm/ctwm/trunk

/*

 *       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 */