Merge branch 'arkkra' into shiny

[mup] / mup / mup / macros.c

/* Copyright (c) 1995, 1996, 1997, 1999, 2000, 2001, 2002, 2004, 2005, 2006 by Arkkra Enterprises */
/* All rights reserved */

/* functions to support Mup macros */

/* When a macro is defined, its text is copied to a file. When a macro is
 * invoked, information about the current input file is pushed on a stack,
 * and the macro text is read from the macro file. This file also has the
 * code to handle include files. They are handled similarly. Info about the
 * current file is pushed on a stack, and text is read from the included
 * file. */

#include <string.h>
#include <fcntl.h>
#include "globals.h"

#ifdef VMS
#define unlink delete
#endif

/* size of macro name hash table. should be prime, big enough to not have too
 * many collisions, small enough to not use too much memory. */
#define MTSIZE	(79)

/* how many bytes to allocate at a time when collecting macro arguments */
#define MAC_ARG_SZ	(512)

/* We may need just a plain copy of the text passed as a macro parameter,
 * or a quoted copy, or both. These flags say which we need.
 * This is currently only actually implemented in a limited form:
 * we always generate an unquoted copy, and if there is any chance any
 * parameter in a macro will be needed in quoted form, we make quoted
 * copies of all parameters for that macro. This is because to really
 * figure out unequivicably which we need would be complicated enough
 * that we'd probably wind up spending more than we'd save,
 * so just doing this half-hearted optimization seems like the best tradeoff.
 */
#define QS_UNQUOTED	(0x1)
#define QS_QUOTED	(0x2)

/* information about a macro parameter */
struct MAC_PARAM {
	char	*param_name;	/* name of the parameter */
	int	quote_style;	/* bitmap of QS_* values */
	struct MAC_PARAM *next;	/* for linked list */
};

/* info about a macro */
struct MACRO {
	char	*macname;	/* name of macro */
	char	*filename;	/* file in which macro was defined */	
	int	lineno;		/* line in file where macro definition began */
	int	lineoffset;	/* how many lines we are into macro */
	long	offset;		/* offset in macro temporary file where the
				 * text of the macro is stored for later use */
	long	quoted_offset;	/* offset into macro temp file where the
				 * quoted version is stored, if any.
				 * Only used on macro parameters. */
	struct MACRO 	*next;	/* for hash collision list */
	int	recursion;	/* incremented each time the macro is called,
				 * and decremented on completion. If this gets
				 * above 1 we are in trouble and ufatal */
	int	num_params;	/* how many parameters */
	struct	MAC_PARAM *parameters_p;	/* list of macro parameter
				 * names. Null if this macro doesn't
				 * have parameters */
};

/* macro information hash table */
static struct MACRO *Mactable[MTSIZE];

/* temporary file for saving text of macros. Need separate handles for reading
 * and writing */
static FILE *Mactmp_read = (FILE *) 0;
static FILE *Mactmp_write = (FILE *) 0;
#ifdef UNIX_LIKE_FILES
static char Macfile[] = "mupmacXXXXXX";		/* name of temp file */
#else
/* As last resort, we use a temp file name of 11 character length,
 * so make sure we have enough room for that. Usually L_tmpnam is
 * already longer than that, but better safe than core dump.
 */
#if L_tmpnam < 12
#undef L_tmpnam
#define L_tmpnam 12
#endif
static char Macfile[L_tmpnam];		/* name of temp file */
#endif

/* Some OSs require us to open files in binary mode. Most implementations
 * of fopen these days accept the 'b' suffix, even when they don't care
 * about it, but to be safe, we only add on systems that appear to have
 * binary mode defined. */
#ifdef O_BINARY
static char *Read_mode = "rb";
#ifndef UNIX_LIKE_FILES
static char *Write_mode = "wb";
static char *Append_mode = "ab";
#endif
#else
static char *Read_mode = "r";
#ifndef UNIX_LIKE_FILES
static char *Write_mode = "w";
static char *Append_mode = "a";
#endif
#endif

/* maximum number of files on file stack */
#ifndef FOPEN_MAX
#ifdef _NFILE
#define FOPEN_MAX	_NFILE
#else
#define FOPEN_MAX	(20)
#endif
#endif
/* The -5 is to account for stdin, stdout, stderr, and the 2 tmp file handles.
 * The +20 is to allow for nested macros. They can take 2 stack slots per call
 * since argument expansion also uses a slot, but they don't take extra
 * file descriptors, since all the macros are kept in one file. */
#define MAXFSTK	(FOPEN_MAX - 5 + 20)


struct FILESTACK {
	FILE	*file;
	char	*filename;
	long	fileoffset;		/* fseek position in file */
	int	lineno;			/* where we are in the file */
	struct MACRO	*mac_p;		/* if pushing because of a macro call,
					 * this will point to info about the
					 * macro, otherwise 0. */
};

static struct FILESTACK Filestack[MAXFSTK];

static int Fstkptr = -1;		/* stack pointer for Filestack */
static char quote_designator[] = "`";

extern int unlink();			/* to remove temp file */
extern char *tmpnam();		/* generate temp file name */

/* static function declarations */
static void pushfile P((FILE *file, char *filename, int lineno,
		struct MACRO *mac_p));
static char *path_combiner P((char *prefix));
static int is_absolute_path P((char *filename));
static struct MACRO *findMacro P((char *macname));
static int hashmac P(( char *macname));
static struct MACRO *setup_macro P((char *macname));
static void free_parameters P((struct MAC_PARAM *param_p, char *macname,
		int values_only));
static char *dupstring P((char *string));
static char *mkmacparm_name P((char *macname, char *param_name));
static struct MACRO *resolve_mac_name P((char *macname));
static int has_quote_designator P((char *macname));


\f

/* add macro name to hash table and arrange to save its text in temp file */

void
define_macro(macname)

char *macname;		/* name of macro to be defined */

{
	int has_params = NO;
	char *mac_name;		/* copy of macro name, because what gets
				 * passed in can get overwritten by parameter
				 * names */
	struct MACRO *mac_p;
	struct MAC_PARAM *parm_p;

	debug (4, "define_macro macname=%s\n", macname);

	/* there might be some leading white space in front of macro name,
	 * if so, ignore that */
	while (*macname == ' ' || *macname == '\t') {
		macname++;
	}

	/* if ends with a ( this macro has parameters */
	if (macname[strlen(macname) - 1] == '(') {
		/* this is a macro with parameters */
		macname[strlen(macname) - 1] = '\0';
		has_params = YES;
	}

	mac_p = setup_macro(macname);
	mac_name = mac_p->macname;

	if (has_params == YES) {
		get_parameters(mac_name);
	}

	/* copy the macro text to the macro temp file */
	if (save_macro(Mactmp_write) == YES) {
		/* There may have been a reference to a parameter to be
		 * quoted. So remind ourseleves to create quoted copies
		 * of parameters when this macro is called later.
		 * This is a half-hearted optimization:
		 * we will sometimes create extra copies unnecessarily,
		 * but much of the time we will get the benefit of a
		 * full optimization with only a fraction of the work. */
		for (parm_p = mac_p->parameters_p;
					parm_p != (struct MAC_PARAM *) 0;
					parm_p = parm_p->next) {
			parm_p->quote_style |= QS_QUOTED;
		}
	}
		

	/* terminate the macro with a NULL, so that when lex hits it when
	 * the macro is called, it will think it hit EOF */
	putc('\0', Mactmp_write);

	/* make sure macro has really been written and not still buffered */
	(void) fflush(Mactmp_write);

#ifndef UNIX_LIKE_FILES
	/* on non-unix system, multiple opens on the same file may not work,
	 * so open and close each time */
	fclose(Mactmp_write);
#endif
}
\f

/* save macro info in hash table and make sure macro temporary file is
 * set up and ready to use */

static struct MACRO *
setup_macro(macname)

char *macname;		/* name of macro being defined */

{
	struct MACRO *mac_p;	/* info about current macro */
	int h;			/* hash number */
	static int have_mac_file = NO;
#ifdef UNIX_LIKE_FILES
	int filedesc;		/* of tmp file for storing macros */
#endif


	/* if macro has not been defined before, add to hash table */
	if ((mac_p = findMacro(macname)) == (struct MACRO *) 0) {

		MALLOC(MACRO, mac_p, 1);
		h = hashmac(macname);
		mac_p->next = Mactable[h];
		Mactable[h] = mac_p;

		mac_p->macname = dupstring(macname);
		mac_p->num_params = 0;
		mac_p->parameters_p = (struct MAC_PARAM *) 0;
		mac_p->recursion = 0;
	}
	else {
		l_warning(Curr_filename, yylineno,
					"macro '%s' redefined", macname);
		free_parameters(mac_p->parameters_p, macname, NO);
		mac_p->parameters_p = (struct MAC_PARAM *) 0;
		mac_p->num_params = 0;
	}

	/* save current filename and line number so they can be used to give
	 * useful error messages when the macro is called */
	if (Fstkptr >= 0 && Filestack[Fstkptr].mac_p != (struct MACRO *) 0) {
		/* if current expanding a macro, get file/line info relative
		 * to the macro */
		mac_p->filename = Filestack[Fstkptr].mac_p->filename;
		mac_p->lineno = Filestack[Fstkptr].mac_p->lineno +
				Filestack[Fstkptr].mac_p->lineoffset;
	}
	else {
		mac_p->filename = Curr_filename;
		mac_p->lineno = yylineno;
	}

	/* if we don't yet have a temp file to store macro info, open one */
	if (have_mac_file == NO) {
		/* We need separate read/write file pointers in case of defining
		 * one macro inside another, so can't easily use tmpfile().
		 * The most straightforward way to do this is to use tmpnam.
		 * But recent versions of gcc complain loudly that tmpnam
		 * is dangerous--you should use mkstemp instead. While it's
		 * true tmpnam could have problems under certain conditions,
		 * Mup's use of it hardly qualifies as "dangerous." Yes,
		 * perhaps if you tried really hard by running lots and
		 * lots of instances of Mup simultaneously, and they all
		 * used macros, maybe you could get one of them to fail once
		 * in a while. But some systems may not support mkstemp,
		 * since it's more from BSD than System V, and it's unclear
		 * how it ought to function on a system that has DOS-style
		 * (8.3 character) filenames if you gave it a longer string
		 * than would be a legal file name.
		 * And, interestingly, the Solaris manual pages say
		 * that you should NOT use mkstemp, in direct conflict with
		 * gcc's opinion. They say to use tmpfile, which we can't do
		 * because that just gives a single file pointer for writing,
		 * but we want one for writing and one for reading.
		 * So it's very unclear what to do. For unix-ish systems
		 * we'll go with mkstemp, and for others use tmpnam.
		 * We get a temp file name, open it twice, once for writing,
		 * once for reading, then remove the file. This will make it a
 		 * hidden file that will disappear when the 2 file pointers
		 * are closed.
		 */
#ifdef UNIX_LIKE_FILES
		if ((filedesc = mkstemp(Macfile)) < 0) {
			ufatal("can't create temporary file for macro storage (possibly you don't have write permissions on directory/file?)");
		}
		if ((Mactmp_write = fdopen(filedesc, "w")) == (FILE *) 0) {
			pfatal("can't fdopen temporary file for macro storage");
		}
		if ((Mactmp_read = fopen(Macfile, "r")) == (FILE *) 0) {
			pfatal("can't open temporary file for reading macro");
		}

		/* arrange for file to vanish */
		(void) unlink(Macfile);
#else
		/* On non-UNIX systems, unlinking an open file may not have
		 * the desired effect, and some systems don't properly
		 * handle both a read and write FILE * on the same file.
		 * So for those we just create it here and have to open
		 * and close the file each time. */
		(void) tmpnam(Macfile);
		if ((Mactmp_write = fopen(Macfile, Write_mode)) == (FILE *) 0) {
			/* If tmpnam isn't implemented or fails,
			 * try a hard-coded temp name and hope
			 * for the best... */
			(void) strcpy(Macfile, "MupMacF.tmp");
			if ((Mactmp_write = fopen(Macfile, Write_mode))
							== (FILE *) 0) {
				ufatal("can't open temporary file for macro storage (possibly you don't have write permissions on directory/file?)");
			}
		}
#endif
		have_mac_file = YES;
	}
#ifndef UNIX_LIKE_FILES
	else {
		if ((Mactmp_write = fopen(Macfile, Append_mode)) == (FILE *) 0) {
			pfatal("can't open temporary file for macro storage (maybe out of memory?)");
		}
	}
#endif
	/* make sure we're at the end. Now that we have separate read/write
	 * file pointers, this should be unnecessary. However, on one non-UNIX
	 * system is seemed the opening for append didn't really work,
	 * requiring this fseek to actually go to the end. And in a previous
	 * variation of this code, this fseek was needed for the UNIX way too.
	 * In any case, it doesn't hurt to be sure we are where we want to be. */
	if (fseek(Mactmp_write, 0L, SEEK_END) != 0) {
		pfatal("fseek failed in setup_macro");
	}

	/* keep track of where this macro will begin in the temp file */
	mac_p->offset = ftell(Mactmp_write);

	return(mac_p);
}
\f

#ifndef UNIX_LIKE_FILES
/* on non-unix systems, unlinking an open file may produce undesired results,
 * so clean up the macro temp file after parsing is done. Unfortunately,
 * this leave a higher possibility of leaving an orphan temp file. */

void
mac_cleanup()

{
	if (Macfile[0] != '\0') {
		unlink(Macfile);
	}
	Macfile[0] =  '\0';
}
#endif
\f

/* look up macro name in hash table and return info about it, or null if
 * not defined */

static struct MACRO *
findMacro(macname)

char *macname;		/* which macro to look up */

{
	struct MACRO *mac_p;	/* pointer to info about macro */


	/* search hash table and collision chain off the table for match
	 * of macro name */
	for (mac_p = Mactable[ hashmac(macname) ]; mac_p != (struct MACRO *) 0;
						mac_p = mac_p->next) {

		if (strcmp(mac_p->macname, macname) == 0) {
			/* found it! */
			return(mac_p);
		}
	}

	/* macro not defined */
	return( (struct MACRO *) 0);
}
\f

/* remove a macro definition. We just remove its entry from the hash table.
 * Its text will still remain in the macro temp file, because it seems like
 * too much trouble to do storage management on a temp file. */
/* Note that if asked to undef a macro that isn't defined, it silently
 * does nothing. */

void
undef_macro(macname)

char *macname;		/* which macro to undefine */

{
	struct MACRO *mac_p;	/* to walk though list of info about macros */
	struct MACRO **mac_p_p;	/* to keep track of delete place */


	/* there might be some leading white space in front of macro name,
	 * if so, ignore that */
	while (*macname == ' ' || *macname == '\t') {
		macname++;
	}

	/* keep track of where to delete from linked list */
	for (mac_p_p = &(Mactable[ hashmac(macname) ]);
					*mac_p_p != (struct MACRO *) 0;
					mac_p_p = &((*mac_p_p)->next)) {
		mac_p = *mac_p_p;
		if (strcmp(mac_p->macname, macname) == 0) {
			
			/* found it--delete this entry from list */
			*mac_p_p = mac_p->next;
			FREE(mac_p->macname);
			free_parameters(mac_p->parameters_p, macname, NO);
			FREE(mac_p);
			return;
		}
	}
}
\f

/* generate hash number from macro name */

static int
hashmac(macname)

char *macname;

{
	int h;

	/* add up characters of name and take sum modulo hash table size */
	for (h = 0; *macname != '\0'; macname++) {
		h += *macname;
	}
	return(h % MTSIZE);
}
\f

/* when macro is called, arrange to read its text from macro file */

void
call_macro(macname)

char *macname;		/* which macro to call */

{
	struct MACRO *mac_p;	/* info about the macro */


	debug(4, "call_macro macname=%s\n", macname);

	if ((mac_p = resolve_mac_name(macname)) == (struct MACRO *) 0) {
		l_yyerror(Curr_filename, yylineno,
				"macro '%s' not defined", macname);
		return;
	}

	
	/* if macro has parameter,  remove any previous arguments
	 * and gather the arguments for this call */
	if (mac_p->parameters_p != (struct MAC_PARAM *) 0) {
		free_parameters(mac_p->parameters_p, macname, YES);
		if (get_mac_arguments(macname, mac_p->num_params) == NO) {
			/* something was wrong with argument. Don't bother
			 * trying to expand, because we'll probably just
			 * just lots more error messages */
			return;
		}
	}

#ifndef UNIX_LIKE_FILES
	if ((Mactmp_read = fopen(Macfile, Read_mode)) == (FILE *) 0) {
		pfatal("can't open macro file for reading (maybe out of memory?)");
	}
#endif

	/* save old yyin value and make macro definition the input */
	pushfile(Mactmp_read, mac_p->filename, mac_p->lineno, mac_p);
	
	/* go to where macro definition begins */
	if (fseek(Mactmp_read, (has_quote_designator(macname)
			? mac_p->quoted_offset : mac_p->offset),
			SEEK_SET) != 0) {
		pfatal("fseek failed in call_macro");
	}
}
\f

/* save info about current yyin and set yyin to specified file */

static void
pushfile(file, filename, lineno, mac_p)

FILE *file;		/* replace current file with this file */
char *filename;		/* name of new file to use */
int lineno;		/* current linenumber in new file */
struct MACRO *mac_p;	/* if switching to macro temp file because of a
			 * macro call, this is information about macro.
			 * Otherwise, it will be null. */

{
	debug(4, "pushfile file=%s", filename);

	/* do error checks */
	if (++Fstkptr >= MAXFSTK) {
		l_ufatal(filename, lineno,
			"too many nested files or macros (%d levels maximum)\n",
			MAXFSTK);
	}
	
	if (mac_p != (struct MACRO *) 0) {
		if ( ++(mac_p->recursion) != 1) {
			l_ufatal(Curr_filename, yylineno,
				"macro '%s' called recursively",
				mac_p->macname);
		}
	}

	/* save current info */
	Filestack[Fstkptr].file = yyin;
	Filestack[Fstkptr].fileoffset = ftell(yyin);
	Filestack[Fstkptr].filename = Curr_filename;
	Filestack[Fstkptr].lineno = yylineno;
	Filestack[Fstkptr].mac_p = mac_p;

	/* arrange to use the new file */
	new_lexbuff(file);

	/* if we are now expanding a macro, we don't change the input line
	 * number.  If doing an include, then we do. */
	if (Filestack[Fstkptr].mac_p == (struct MACRO *) 0) {
		yylineno = lineno;
		Curr_filename = filename;
	}
	else {
		Filestack[Fstkptr].mac_p->lineoffset = 0;
	}
}
\f

/* if there are any files on the Filestack, go back to the previous one
 * on the stack. Return 1 if something was popped, 0 if stack was empty */

int
popfile()

{
	debug(4, "popfile");

	/* if nothing on file stack, nothing to do  except return 0 */
	if (Fstkptr < 0) {
		return(0);
	}

	if (Filestack[Fstkptr].mac_p != (struct MACRO *) 0) {
		/* returning from macro call */
		Filestack[Fstkptr].mac_p->recursion = 0;
#ifndef UNIX_LIKE_FILES
		(void) fclose(yyin);
#endif
	}
	else {
		/* this is an include rather than a macro file, so close it */
		(void) fclose(yyin);
	}

	/* set things back to the previous file */
	yyin = Filestack[Fstkptr].file;
	Curr_filename = Filestack[Fstkptr].filename;
	if (Filestack[Fstkptr].fileoffset >= 0) {
		if (fseek(yyin, Filestack[Fstkptr].fileoffset, SEEK_SET) != 0) {
			pfatal("fseek failed in popfile");
		}
	}
	yylineno = Filestack[Fstkptr].lineno;

	/* go back to previous file */
	del_lexbuff();

	/* decrement stackpointer */
	Fstkptr--;

	return(1);
}
\f

/* return 1 if we are NOT currently expanding a macro, 0 if we are.
 * This backwards logic is used because when we ARE doing a macro, we
 * should NOT muck with yylineno, and vice versa. If in a macro, adjust
 * the line offset within the macro by the specified amount. */

int
not_in_mac(inc_dec)

int inc_dec;	/* how much to increment/decrement the in-macro line offset */
{
	if (Fstkptr >= 0 && Filestack[Fstkptr].mac_p != (struct MACRO *) 0) {
		/* we are in a macro */
		Filestack[Fstkptr].mac_p->lineoffset += inc_dec;
		return(0);
	}
	else {
		return(1);
	}
}
\f

/* if an error occurs while expanding a macro, give additional help */

void
mac_error()

{
	struct MACRO *mac_p;

	if (Fstkptr >= 0 && (mac_p = Filestack[Fstkptr].mac_p)
						!= (struct MACRO *) 0) {
		(void) fprintf(stderr, "note: previous error found while expanding macro %s'%s' from %s: line %d:\n",
				(strchr(mac_p->macname, '(') ? "parameter " : ""),
				mac_p->macname,
				mac_p->filename,
				mac_p->lineno + mac_p->lineoffset);
		print_offending_line(mac_p->filename, mac_p->lineno + mac_p->lineoffset);
	}
}
\f

/* process an included file */

void
includefile(fname)

char *fname;	/* name of file to include */

{
	FILE *file;		/* the included file */
	char *fnamecopy;


	/* attempt to open file. Give message if fail */
	/* Note that if we find the file somewhere up the MUPPATH
	 * rather than directly, fname will be updated to contain the
	 * actual path of the file we are using, so we can tell that
	 * to the user. That way if they have several files by the same
	 * name but in different directories, and we're picking up a different
	 * one than they had intended, we can give them a clue of what's
	 * going on... */
	if ((file = find_file(&fname)) == (FILE *) 0) {

		l_ufatal(Curr_filename, yylineno,
				"can't open include file '%s'", fname);
	}

	/* need to make copy of file name */
	fnamecopy = dupstring(fname);

	/* arrange to connect yyin to the included file, save info, etc */
	pushfile(file, fnamecopy, 1, (struct MACRO *) 0);
}
\f

/* Find a file to be included. First look using file name as is.
 * If not found, check if is absolute path name, and if so, give up.
 * Otherwise, try prepending each component of $MUPPATH in turn,
 * and trying that as a path. If a file is found, return that.
 * If we reach the end of the list, give up. 
 * Giving up means returning 0. If we find it somewhere up the MUPPATH
 * rather than directly, update filename to point to the actual path used.
 */

FILE *
find_file(filename_p)

char **filename_p;

{
	char *filename;
	FILE *file;
	char *fullpath;
	char *combiner;			/* what goes between path components */
	char *muppath;			/* value of $MUPPATH */
	char *prefix;			/* component of $MUPPATH,
					 * to prepend to filename */
	char *path_separator = "\0";	/* between components in $MUPPATH */


	/* first try name just as it is. */
	filename = *filename_p;
	if ((file = fopen(filename, Read_mode)) != (FILE *) 0) {
		return(file);
	}

	/* If it's an absolute path, we have to give up */
	if (is_absolute_path(filename)) {
		return ((FILE *) 0);
	}

	/* See if user set a $MUPPATH for where to look for includes */
	if ((muppath = getenv("MUPPATH")) != (char *) 0) {

#ifdef UNIX_LIKE_PATH_RULES
		path_separator = ":";
#endif
#ifdef DOS_LIKE_PATH_RULES
		path_separator = ";";
#endif
		if (*path_separator == '\0') {
			/* If user went to the trouble of setting $MUPPATH,
			 * they probably think it will work, so we better
			 * let them know it doesn't. Hopefully they will
			 * tell us what path rules their operating system
			 * uses, so we support it in the next release. */
			warning("MUPPATH facility not implemented for this operating system");
			return (FILE *) 0;
		}

		/* walk through $MUPPATH */
		for (prefix = strtok(muppath, path_separator);
				prefix != (char *) 0;
				prefix = strtok(0, path_separator)) {
	
			combiner = path_combiner(prefix);

			/* get enough space for the full name */
			MALLOCA(char, fullpath, strlen(filename) +
				strlen(prefix) + 1 + strlen(combiner));

			/* create full path */
			sprintf(fullpath, "%s%s%s", prefix, combiner, filename);

			/* See if this file exists */
			debug(4, "checking '%s' for include, using MUPPATH",
					fullpath);
			if ((file = fopen(fullpath, Read_mode)) != (FILE *) 0) {
				*filename_p = fullpath;
				return(file);
			}

			/* no file here, no need to save this path */
			FREE(fullpath);
		}
	}

	return (FILE *) 0;
}
\f

/* return true if given filename is an absolute path name */

static int
is_absolute_path(filename)

char *filename;

{

#ifdef UNIX_LIKE_PATH_RULES
	/* For Unix, a pathname is absolute if it starts with a slash */
	return (*filename == '/');
#endif

#ifdef DOS_LIKE_PATH_RULES
	/* If second character is a colon, then absolute */
	if (*filename != '\0' && *(filename + 1) == ':') {
		return(1);
	}
	else {
		return(0);
	}
#endif

#if ! defined(UNIX_LIKE_PATH_RULES) && ! defined(DOS_LIKE_PATH_RULES)
	/* Not implemented for this operating system. We'll pretend
	 * it's not, which will make it fall through and fail later. */
	return(0);
#endif
}
\f

/* What to use to glue together a prefix and relative path to get a
 * full path. */

static char *
path_combiner(prefix)

char *prefix;

{

#ifdef UNIX_LIKE_PATH_RULES
	/* Unix separator is slash. If there was already a slash at the
	 * end of the prefix, no problem: multiples slashes are like one */
	return ("/");
#endif

#ifdef DOS_LIKE_PATH_RULES
	/* Use backslash, unless prefix ended with slash or backslash,
	 * in which case we don't need anything. */
	char last_ch;
	last_ch = prefix[strlen(prefix) - 1];
	return ((last_ch == '\\' || last_ch == '/') ? "" : "\\");
#endif

#if ! defined(UNIX_LIKE_PATH_RULES) && ! defined(DOS_LIKE_PATH_RULES)
	/* Shouldn't be here. Unimplemented for this operating system */
	return ("");
#endif
}
\f

/* return YES if macro is currently defined, NO if it isn't */

int
is_defined(macname, paramtoo)

char *macname;
int paramtoo;	/* if YES, also look for macro parameter by this name,
		 * otherwise just macro */

{
	if (paramtoo) {
		return(resolve_mac_name(macname) == 0 ? NO : YES);
	}
	else {
		return(findMacro(macname) == 0 ? NO : YES);
	}
}
\f

/* when the -D option is used on the command line, save the macro definition. */

void
cmdline_macro(macdef)

char *macdef;	/* MACRO=definition */

{
	char *def;


	/* separate out the macro name */
	if (*macdef == '_') {
		if (Mupmate == YES) {
			l_yyerror(0, -1, "Run > Set Options > Define Macros: macro name cannot start with underscore.");
		}
		else {
			l_yyerror(0, -1, "argument for %cD is invalid: macro name cannot start with underscore", Optch);
		}
		return;
	}
	for (def = macdef; *def != '\0'; def++) {
		if ( ! isupper(*def) && ! isdigit(*def) && *def != '_') {
			break;
		}
	}

	/* make sure has form XXX=definition */
	if (def == macdef) {
		if (Mupmate == YES) {
			l_yyerror(0, -1, "Run > Set Options > Define Macros: macro name only allowed to contain upper case letters, numbers and underscores.");
		}
		else {
			l_yyerror(0, -1, "argument for %cD is missing or wrong format", Optch);
		}
		return;
	}

	if (*def == '=') {
		*def++ = '\0';
	}
	else if (*def != '\0') {
		if (Mupmate == YES) {
			l_yyerror(0, -1, "Run > Set Options > Define Macros: macro name is invalid or missing '=' on macro definition.");
		}
		else {
			l_yyerror(0, -1, "argument for %cD had invalid name or missing '=' on macro definition", Optch);
		}
		return;
	}

	Curr_filename = "Command line argument";
	(void) setup_macro(macdef);

	/* copy the macro to the macro temp file */
	do {
		putc(*def, Mactmp_write);
	} while ( *def++ != '\0');
	(void) fflush(Mactmp_write);
#ifndef UNIX_LIKE_FILES
	fclose(Mactmp_write);
#endif
}
\f

/* recursively free a list of macro parameters */

static void
free_parameters(param_p, macname, values_only)

struct MAC_PARAM *param_p;	/* what to free */
char *macname;			/* name of macro having this parameter */
int values_only;		/* if YES, just get rid of current
				 * argument values, otherwise dispose of
				 * the entire parameters list */

{
	char *mp_name;		/* internal name of macro parameter */


	if (param_p == (struct MAC_PARAM *) 0) {
		/* end of list */
		return;
	}

	/* recurse */
	free_parameters(param_p->next, macname, values_only);

	/* need to undef the internal name */
	mp_name = mkmacparm_name(macname, param_p->param_name);
	undef_macro(mp_name);
	FREE(mp_name);

	if (values_only == NO) {

		/* release space */
		if (param_p->param_name != (char *) 0) {
			FREE(param_p->param_name);
		}
		FREE(param_p);
	}
}
\f

/* given a macro name and a parameter name, add the parameter name to the
 * list of parameters for the macro */

void
add_parameter(macname, param_name)

char *macname;
char *param_name;		/* name of parameter to add */

{
	struct MACRO *macinfo_p;	/* which macro to add to */
	struct MAC_PARAM *new_p;	/* new parameter */
	struct MAC_PARAM *param_p;	/* to walk through parameter list */


	/* get space to store info about the parameter */
	MALLOC(MAC_PARAM, new_p, 1);

	/* get the macro information to know where to attach */
	if ((macinfo_p = findMacro(macname)) == (struct MACRO *) 0) {
		pfatal("add_parameter unable to find macro %s", macname);
	}

	/* if this is first parameter, link directly to macro, otherwise
	 * to the end of the parameter linked list */
	if (macinfo_p->parameters_p == (struct MAC_PARAM *) 0) {
		macinfo_p->parameters_p = new_p;
	}
	else {
		/* walk down current parameter list */
		for (param_p = macinfo_p->parameters_p;
				param_p != (struct MAC_PARAM *) 0;
				param_p = param_p->next) {

			/* check for duplicate name */
			if (strcmp(param_name, param_p->param_name) == 0) {
				l_yyerror(Curr_filename, yylineno,
					"duplicate parameter name %s for macro %s",
					param_name, macname);
			}

			/* link onto end of list */
			if (param_p->next == (struct MAC_PARAM *) 0) {
				param_p->next = new_p;
				break;
			}
		}
	}

	/* fill in the info */
	new_p->param_name = dupstring(param_name);
	/* assume non-quoted for now */
	new_p->quote_style = QS_UNQUOTED;
	new_p->next = (struct MAC_PARAM *) 0;

	(macinfo_p->num_params)++;
}
\f

/* given a string to duplicate, allocate space for a copy and return pointer
 * to the copy. Caller is responsible for freeing if it needs to be freed */

static char *
dupstring(string)

char *string;	/* what to duplicate */

{
	char *newstr;	/* the duplicate */

	/* get space and copy the old to new */
	MALLOCA(char, newstr, strlen(string) + 1);
	(void) strcpy(newstr, string);

	return(newstr);
}
\f

/* save the value of a macro argument by making a macro out of it */

void
set_parm_value(macname, argbuff, argnum)

char *macname;	/* name of macro */
char *argbuff;	/* value of argument */
int argnum;	/* which argument. 1 for the first, 2 for second, etc */

{
	static struct MAC_PARAM *param_p;	/* keep track of current
			 * parameter. The first time we are called for a
			 * given macro, we look up the macro and get its
			 * first parameter. After that, we just follow
			 * the linked list of parameters */
	struct MACRO *mac_p;	/* info about macro */
	struct MACRO *argmac_p;	/* info about the parameter */
	char *mp_name;	/* pointer to malloc-ed space containing internal
			 * name of MACRO(PARAMETER) */
	char *p;	/* to copy value to macro temp file */

	if (argnum == 1) {
		/* this is the first argument, so we have to look up the
		 * macro */
		if ((mac_p = findMacro(macname)) == (struct MACRO *) 0) {
			pfatal("set_parm_value can't find macro");
		}

		/* point to head of parameters list */
		param_p = mac_p->parameters_p;
	}
	else {
		/* just advance to the next parameter */
		if (param_p != (struct MAC_PARAM *) 0) {
			param_p = param_p->next;
		}
		if (param_p == (struct MAC_PARAM *) 0) {
			/* no next parameter. Error msg is printed elsewhere,
			 * so just clean up and return */
			FREE(argbuff);
			return;
		}
	}

	/* if argbuff is null, there is no argument, which really means the
	 * argument is the null string. */
	if (argbuff == (char *) 0) {
		argbuff = dupstring("");
	}

	/* now associate the value with the parameter */
	mp_name = mkmacparm_name(macname, param_p->param_name);
	argmac_p = setup_macro(mp_name);

	/* copy the macro to the macro temp file */
	if (param_p->quote_style & QS_UNQUOTED) {
		fprintf(Mactmp_write, "%s", argbuff);
		putc('\0', Mactmp_write);
	}

	if (param_p->quote_style & QS_QUOTED) {
		short in_string;	/* are we within double quotes? */
		short escaped;		/* did we just see a backslash? */

		/* Remember where we are stashing this quoted copy */
		argmac_p->quoted_offset = ftell(Mactmp_write);

		/* Add the initial quote */
		putc('"', Mactmp_write);

		/* Have to copy a character at a time, because we
		 * need to backslash any embedded quotes. This follows
		 * rules like the ANSI C preprocessor, except we only have
		 * to worry about strings, not character constants, because
		 * Mup doesn't have character constants. Also, we don't
		 * squeeze not-in-string white space runs to a single space,
		 * because this keeps the code simpler and there's no
		 * particular benefit in squeezing, other than perhaps
		 * saving a few bytes in the macro temp file. This code
		 * is similar to the gcc implementation of cpp. */
		in_string = escaped = NO;
		for (p = argbuff; *p != '\0'; p++) {
			if (escaped == YES) {
				escaped = NO;
			}
			else {
				if (*p == '\\') {
					escaped = YES;
				}
				if (in_string == YES) {
					if (*p == '"') {
						/* reached end of string */
						in_string = NO;
					}
				}
				else if (*p == '"') {
					/* starting a string */
					in_string = YES;
				}
			}

			/* Escape quotes always; escape backslashes
			 * when they are inside strings. */
			if (*p == '"' || (in_string == YES && *p == '\\')) {
				putc('\\', Mactmp_write);
			}
			putc(*p, Mactmp_write);
		}

		/* Add the final quote */
		putc('"', Mactmp_write);
		putc('\0', Mactmp_write);
	}
	(void) fflush(Mactmp_write);
#ifndef UNIX_LIKE_FILES
	fclose(Mactmp_write);
#endif

	/* temp space no longer needed */
	FREE(mp_name);
	FREE(argbuff);
}
\f

/* make an internal macro name for a macro parameter name. The internal
 * name is MACRO(PARAMETER). Space for name is malloc-ed, caller must free */

static char *
mkmacparm_name(macname, param_name)

char *macname;
char *param_name;

{
	char *internal_name;

	/* add 3 for the 2 parentheses and the null */
	MALLOCA(char, internal_name,
			strlen(macname) + strlen(param_name) + 3);

	(void) sprintf(internal_name, "%s(%s)", macname, param_name);
	return(internal_name);
}
\f

/* add a character to the current macro argument buffer. */

char *
add2argbuff(argbuff, c)

char *argbuff;		/* the argument buffer so far */
int c;			/* a character to add to the buffer */

{
	static int offset;	/* where in argbuff to put character */
	static int length;	/* how many characters we have allocated */


	if (argbuff == (char *) 0) {
		/* first time we were called, so malloc some space */
		MALLOCA(char, argbuff, MAC_ARG_SZ);
		offset = 0;
		length = MAC_ARG_SZ;
	}
	else if (offset == length - 1) {
		/* need more space */
		length += MAC_ARG_SZ;
		REALLOCA(char, argbuff, length);
	}

	/* put character in the buffer and null terminate it */
	argbuff[offset++] = (char) c;
	argbuff[offset] = '\0';

	return(argbuff);
}
\f

/* given a macro name that might be either a macro parameter or a regular
 * macro, return pointer to the proper MACRO struct. We do this by
 * searching up the stack of macros being expanded. If the name matches
 * that of a macro parameter, use that, otherwise treat as a normal macro.
 * Return null if can't resolve */

static struct MACRO *
resolve_mac_name(macname)

char *macname;

{
	struct MACRO *mac_p;	/* macro that matches the macname */
	int i;			/* index through file stack */
	char *mp_name;		/* macro parameter internal name */
	int quoted;		/* if has quote designator */
	char *basename;		/* macname not counting quote designator */


	if ((quoted = has_quote_designator(macname)) == YES) {
		basename = macname + strlen(quote_designator);
	}
	else {
		basename = macname;
	} 
		
	/* first go up the stack of macro calls, seeing if the macro
	 * name matches the parameter name of any macro. If so, that's
	 * the correct macro to use. Failing that, we look for the macro
	 * name just as is. If that fails too, we have to admit defeat
	 * and return null. */
	for (i = 0; i <= Fstkptr; i++) {
		if (Filestack[i].mac_p != (struct MACRO *) 0) {
			/* we are expanding a macro. See if that macro
			 * has a parameter by the name we are trying to
			 * resolve. If so, that's what we want */
			mp_name = mkmacparm_name(Filestack[i].mac_p->macname,
					basename);
			mac_p = findMacro(mp_name);
			FREE(mp_name);
			if (mac_p != 0) {
				/* Eureka! We found it */
				return(mac_p);
			}
		}
	}

	/* well, guess it wasn't a macro parameter. Try treating as
	 * just an ordinary macro name */
	/* Not allowed to be a special quoted macro; you can only do that
	 * to a macro parameter */
	if (quoted == YES) {
		l_yyerror(Curr_filename, yylineno,
			"cannot use '%s' on a macro, only on a macro parameter",
			quote_designator);
		return ((struct MACRO *) 0);
	}

	return(findMacro(macname));
}
\f

/* Return YES if macro name reference includes designator denoting
 * it is to be quoted (like usage of # in ANSI C preprocessor) */

static int
has_quote_designator(macname)

char *macname;

{
	return (strncmp(macname, quote_designator, strlen(quote_designator))
							== 0 ? YES : NO );
}
\f

/* For "preprocessor" option, similar to the C compiler option to
 * just run the macro preprocessor, instead of the usual yacc-generated
 * yyparse(), we have this function that simply writes tokens out.
 */

void
preproc()
{
	while (yylex() != 0) {
		/* In strings, the backslashes before any embedded quotes
		 * will have been swallowed, so we have to recreate them. */
		if (yytext[0] == '"') {
			char *t;
			putchar('"');
			for (t = yytext + 1; *t != '\0'; t++) {
				if (*t == '"' && *(t+1) != '\0') {
					putchar('\\');
				}
				putchar(*t);
			}
		}
		else {
			printf("%s", yytext);
		}
	}
}