Subversion Repositories tendra.SVN

/*

 * Copyright (c) 2002-2005 The TenDRA Project <http://www.tendra.org/>.

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions are met:

 *

 * 1. Redistributions of source code must retain the above copyright notice,

 *    this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright notice,

 *    this list of conditions and the following disclaimer in the documentation

 *    and/or other materials provided with the distribution.

 * 3. Neither the name of The TenDRA Project nor the names of its contributors

 *    may be used to endorse or promote products derived from this software

 *    without specific, prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS

 * IS'' AND ANY EXPRESS 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 COPYRIGHT HOLDERS OR

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

 *

 * $Id$

 */

/*

    		 Crown Copyright (c) 1997

    This TenDRA(r) Computer Program is subject to Copyright

    owned by the United Kingdom Secretary of State for Defence

    acting through the Defence Evaluation and Research Agency

    (DERA).  It is made available to Recipients with a

    royalty-free licence for its use, reproduction, transfer

    to other parties and amendment for any purpose not excluding

    product development provided that any such use et cetera

    shall be deemed to be acceptance of the following conditions:-

        (1) Its Recipients shall ensure that this Notice is

        reproduced upon any copies or amended versions of it;

        (2) Any amended version of it shall be clearly marked to

        show both the nature of and the organisation responsible

        for the relevant amendment or amendments;

        (3) Its onward transfer from a recipient to another

        party shall be deemed to be that party's acceptance of

        these conditions;

        (4) DERA gives no warranty or assurance as to its

        quality or suitability for any purpose and DERA accepts

        no liability whatsoever in relation to any use to which

        it may be put.

*/

#include "config.h"

#include "system.h"

#include "c_types.h"

#include "loc_ext.h"

#include "error.h"

#include "catalog.h"

#include "option.h"

#include "file.h"

#include "buffer.h"

#include "char.h"

#include "dump.h"

#include "lex.h"

#include "preproc.h"

#include "syntax.h"

#include "token.h"

#include "ustring.h"

#include "xalloc.h"

/*

    INPUT AND OUTPUT FILES

    These are the files from which the lexical routines read their input

    and to which the output routines write.

*/

FILE *input_file = NULL;

FILE *output_file[OUTPUT_FILES] = { NULL, NULL, NULL, NULL, NULL };

/*

    CURRENT FILE NAMES

    The variable input_name is used to hold the name of the current input

    file name.  This remains constant and is not, for example, changed by

    #line directives.  Similarly output_name holds the names of the output

    files.

*/

string input_name = NULL;

string output_name[OUTPUT_FILES] = { NULL, NULL, NULL, NULL, NULL };

/*

    STANDARD FILE NAME

    The macro std_file_name checks whether the file name A is the special

    string "-" used to indicate the standard input or output.  The other

    macros give the corresponding names used in error reports.

*/

#define std_file_name(A)	ustrseq((A), "-")

#define stdin_name		ustrlit("<stdin>")

#define stdout_name		ustrlit("<stdout>")

/*

    INTERNAL FILE BUFFER

    This buffer is used as the internal file buffer which is used to hold

    any preprocessing directives arising from command-line options.  It

    has an associated dummy file and file name.

*/

BUFFER internal_buff = NULL_buff;

static FILE *internal_file = NULL;

static string internal_name = NULL;

/*

    INCLUDE FILE BUFFER

    This buffer is used to build up file names when processing #include

    directives.

*/

BUFFER incl_buff = NULL_buff;

/*

    INPUT FLAGS

    These flags are used to record changes in the current file location.

*/

unsigned long crt_spaces = 0;

unsigned long tab_width = 8;

int crt_line_changed = 0;

int crt_file_changed = 0;

int crt_col_changed = 0;

int crt_file_type = 0;

int bad_crt_loc = 0;

/*

    INPUT BUFFERS

    These variables describe the buffers used in reading the input file.

    Each buffer consists of an array of characters, preceded by space

    for the storage of unread characters, and followed by an overflow

    area for repeated end of file markers.  The position within the

    buffer is indicated by the pointer input_posn.  Other pointers give

    the end of the current buffer and the end of the last buffer.

    Characters beyond the end of the buffer hold char_end.

*/

#define NO_BUFFER		4

#define CHAR_SZ			sizeof(character)

#define BUFF_SZ			((size_t)(BUFSIZ))

#define PENDING_SZ		16

#define OVERFLOW_SZ		16

#define TOTAL_SZ		(PENDING_SZ + BUFF_SZ + OVERFLOW_SZ)

typedef struct {

	string buff;

	string posn;

	string end;

	string eof;

	long bytes;

} INPUT_BUFFER;

static INPUT_BUFFER input_buff[NO_BUFFER] = {

	{ NULL, NULL, NULL, NULL, 0 },

	{ NULL, NULL, NULL, NULL, 0 },

	{ NULL, NULL, NULL, NULL, 0 },

	{ NULL, NULL, NULL, NULL, 0 }

};

string input_start = NULL;

string input_posn = NULL;

string input_end = NULL;

string input_eof = NULL;

string input_crt = NULL;

static long input_bytes = 0;

static int input_special = 0;

static int started_buff = 0;

unsigned long crt_buff_no = 0;

/*

    IS A FILE NAME A FULL PATHNAME?

    This routine checks whether the file name nm represents a full

    pathname.

*/

int

is_full_pathname(string nm)

{

	character c = nm[0];

	character q = (character)drive_sep;

	if (c == char_slash) {

		return(1);

	}

	if (c && q && nm[1] == q) {

		/* Allow for DOS drive letters */

		return(is_alpha_char((unsigned long)c));

	}

	return(0);

}

/*

    CONVERT A FILE NAME TO STANDARD FORMAT

    This routine modifies the file name nm to the standard format with

    sensible forward slashes rather backslashes.

*/

string

make_pathname(string nm)

{

	character q = (character)file_sep;

	if (q != char_slash) {

		string s;

		nm = xustrcpy(nm);

		for (s = nm; *s; s++) {

			if (*s == q) {

				*s = char_slash;

			}

		}

	}

	return(nm);

}

/*

    NORMALISE A FILE NAME

    This routine normalises the file name s by removing any . or ..

    components.  The result is only used in the printing of error

    messages so it doesn't matter too much if the result isn't quite

    right.

*/

static string

normalise_pathname(string s)

{

	character c;

	string p = s;

	int depth = 0;

	int changed = 0;

	BUFFER *bf = clear_buffer(&incl_buff, NIL(FILE));

	while (c = *(p++), c != 0) {

		if (c == char_slash) {

			if (p[0] == char_dot) {

				if (p[1] == char_slash) {

					/* Have '/./' */

					p++;

					changed = 1;

				} else if (p[1] == char_dot &&

					   p[2] == char_slash) {

					/* Have '/../' */

					string q = bf->posn;

					if (depth > 0) {

						string q0 = bf->start;

						*q = 0;

						q = ustrrchr(q0, char_slash);

						if (q && q != q0) {

							bf->posn = q;

							p += 2;

							changed = 1;

							c = 0;

						}

					}

					if (c) {

						bfputc(bf, (int)c);

					}

					depth--;

				} else {

					bfputc(bf, (int)c);

					depth++;

				}

			} else if (p[0] == char_slash) {

				/* Have '//' */

				changed = 1;

			} else {

				bfputc(bf, (int)c);

				depth++;

			}

		} else {

			bfputc(bf, (int)c);

		}

	}

	bfputc(bf, 0);

	if (changed) {

		s = xustrcpy(bf->start);

	}

	return(s);

}

/*

    SET CURRENT LOCATION

    This routine sets the current location from the filename nm.  It returns

    the result of applying make_pathname to nm.

*/

string

set_crt_loc(string nm, int special)

{

	string en;

	unsigned long date;

	if (special) {

		/* Standard input */

		en = ustrlit("");

		date = 0;

	} else {

		/* Simple file */

		STAT_TYPE *fs;

		STAT_TYPE fstr;

		nm = make_pathname(nm);

		en = nm;

		fs = stat_func(strlit(nm), &fstr);

		date = stat_date(fs);

	}

	CREATE_loc(nm, en, nm, NULL, NULL_ptr(LOCATION), date, crt_loc);

	return(nm);

}

/*

    OPEN INPUT FILE

    This routine opens the input file, using input_name as the name of the

    file to be opened.  If this is the null string then the standard input

    is used.  The file is opened in binary mode if bin is true.  The routine

    also allocates space for each of the buffers above.  The routine returns

    1 if the file is opened successfully.

*/

int

open_input(int bin)

{

	if (input_file == NULL) {

		string nm = input_name;

		if (nm == NULL || std_file_name(nm)) {

			nm = set_crt_loc(stdin_name, 1);

			input_special = 1;

			if (!bin) {

				input_file = stdin;

			}

		} else {

			CONST char *mode = (bin ? "rb" : "r");

			nm = set_crt_loc(nm, 0);

			input_special = 0;

			input_file = fopen(strlit(nm), mode);

		}

		input_name = nm;

		if (input_file == NULL) {

			return(0);

		}

		if (!started_buff) {

			unsigned i;

			for (i = 0; i < NO_BUFFER; i++) {

				string buff = xmalloc_nof(character, TOTAL_SZ);

				input_buff[i].buff = buff;

			}

			started_buff = 1;

		}

		crt_file_changed = 1;

		crt_line_changed = 1;

		crt_spaces = 0;

	}

	return(1);

}

/*

    FREE SPACE ALLOCATED FOR INPUT BUFFERS

    This routine frees the memory allocated for the input buffers.

*/

void

term_input(void)

{

	free_buffer(&incl_buff);

	free_buffer(&internal_buff);

	if (started_buff) {

		unsigned i;

		for (i = 0; i < NO_BUFFER; i++) {

			xfree_nof(input_buff[i].buff);

			input_buff[i].buff = NULL;

		}

		started_buff = 0;

	}

	input_start = NULL;

	input_bytes = 0;

	return;

}

/*

    OPEN OUTPUT FILE

    This routine opens the nth output file, using output_name as the name

    of the file to be opened.  If this is the null string then the standard

    output is used.  The file is opened in binary mode if bin is true.  The

    routine returns 1 if the file is opened successfully.

*/

int

open_output(int n, int bin)

{

	if (output_file[n] == NULL) {

		string nm = output_name[n];

		if (nm == NULL || std_file_name(nm)) {

			nm = stdout_name;

			output_name[n] = nm;

			output_file[n] = stdout;

			if (bin) {

				return(0);

			}

		} else {

			CONST char *mode = (bin ? "wb" : "w");

			nm = make_pathname(nm);

			output_name[n] = nm;

			output_file[n] = fopen(strlit(nm), mode);

			if (output_file[n] == NULL) {

				return(0);

			}

		}

	}

	return(1);

}

/*

    CLOSE INPUT FILE

    This routine closes the input file.

*/

void

close_input(void)

{

	FILE *fin = input_file;

	if (fin && !input_special) {

		if (ferror(fin) || fclose(fin)) {

			char *nm = strlit(input_name);

			error(ERROR_INTERNAL, "Reading error in '%s'", nm);

		}

	}

	input_file = NULL;

	return;

}

/*

    CLOSE OUTPUT FILE

    This routine closes the nth output file.

*/

void

close_output(int n)

{

	FILE *fout = output_file[n];

	if (fout && fout != stdout && fout != stderr) {

		if (ferror(fout) || fclose(fout)) {

			char *nm = strlit(output_name[n]);

			error(ERROR_INTERNAL, "Writing error in '%s'", nm);

		}

	}

	output_file[n] = NULL;

	return;

}

/*

    FILL THE INPUT BUFFER

    This routine fills the current input buffer from the input file, setting

    up the associated buffer pointers.  It returns NULL to indicate that no

    bytes were read.

*/

static string

fill_buffer(void)

{

	size_t i, n;

	size_t m = TOTAL_SZ;

	FILE *f = input_file;

	string p = input_start;

	/* Fill the buffer from the input file */

	if (f == internal_file) {

		n = (size_t)bfread(&internal_buff, p, (gen_size)BUFF_SZ);

		if (n < BUFF_SZ)m = n;

	} else if (f) {

		n = fread((gen_ptr)p, CHAR_SZ, BUFF_SZ, f);

		if (n < BUFF_SZ)m = n;

	} else {

		n = 0;

		m = 0;

	}

	input_posn = p;

	input_end = p + n;

	input_eof = p + m;

	input_crt = p;

	input_bytes += (long)n;

	/* Fill the overflow area with char_end's */

	for (i = n; i < n + OVERFLOW_SZ; i++) {

		p[i] = char_end;

	}

	if (n == 0) {

		p = NULL;

	}

	return(p);

}

/*

    INITIALISE BUFFER

    This routine initialises buffer number i and makes it into the current

    buffer.  It returns NULL to indicate an empty file.

*/

string

init_buffer(unsigned long i)

{

	crt_buff_no = i;

	input_start = input_buff[i].buff + PENDING_SZ;

	input_bytes = 0;

	return(fill_buffer());

}

/*

    RESUME BUFFER

    This routine makes buffer number i into the current buffer by restoring

    the main values from those stored in the buffer.

*/

static void

resume_buffer(unsigned long i)

{

	INPUT_BUFFER *p = input_buff + i;

	input_start = p->buff + PENDING_SZ;

	input_posn = p->posn;

	input_end = p->end;

	input_eof = p->eof;

	input_crt = p->posn;

	input_bytes = p->bytes;

	return;

}

/*

    FIND CURRENT FILE POSITION

    This routine finds the current file position and updates the pointers

    in buffer i (which should be the current buffer number).

*/

long

tell_buffer(unsigned long i)

{

	long bytes_left;

	INPUT_BUFFER *p = input_buff + i;

	p->posn = input_posn;

	p->end = input_end;

	p->eof = input_eof;

	p->bytes = input_bytes;

	bytes_left = (long)(input_end - input_posn);

	if (bytes_left < 0) {

		bytes_left = 0;

	}

	return(input_bytes - bytes_left);

}

/*

    SET CURRENT FILE POSITION

    This routine sets the current file position to n and the current buffer

    to number i.  started is false if the file has just been opened.

*/

void

seek_buffer(unsigned long i, long n, int started)

{

	int s;

	FILE *f = input_file;

	if (f == NULL) {

		return;

	}

	if (f == internal_file) {

		if (started) {

			/* Reset position to start of buffer */

			internal_buff.posn = internal_buff.start;

			started = 0;

		}

		s = 0;

	} else {

		s = file_seek(f, n);

	}

	if (s == 0) {

		/* Perform seek by hand */

		string p;

		if (started) {

			/* Rewind to start of file */

			IGNORE file_seek(f, (long)0);

		}

		p = init_buffer(i);

		while (input_bytes < n) {

			if (p == NULL) {

				char *nm = strlit(input_name);

				CONST char *msg = "Internal seek error in '%s'";

				error(ERROR_INTERNAL, msg, nm);

				return;

			}

			p = fill_buffer();

		}

		input_posn = input_end - (input_bytes - n);

		input_crt = input_posn;

	} else {

		if (s == -1) {

			char *nm = strlit(input_name);

			CONST char *msg = "Internal seek error in '%s'";

			error(ERROR_INTERNAL, msg, nm);

		}

		input_start = input_buff[i].buff + PENDING_SZ;

		input_bytes = n;

		IGNORE fill_buffer();

	}

	return;

}

/*

    UPDATE THE CURRENT COLUMN POSITION

    The current column position is only updated at convenient junctures.

    The variable input_crt is used to keep track of the last such location.

*/

void

update_column(void)

{

	string p = input_posn;

	if (p) {

		unsigned long n = (unsigned long)(p - input_crt);

		if (n) {

			crt_loc.column += n;

			input_crt = p;

		}

	}

	return;

}

/*

    REFILL THE INPUT BUFFER

    This routine refills the input buffer, returning the first character.

    It is called whenever the next character in the buffer is char_end.

    It is possible that the character is really char_end, in which case

    this is returned.  Otherwise the buffer is refilled.  Note that in order

    for unread_char to work correctly with char_eof, ( char_eof & 0xff )

    must equal char_end.

*/

int

refill_char(void)

{

	int c;

	update_column();

	do {

		string p = input_posn;

		if (p <= input_end) {

			return(char_end);

		}

		if (p > input_eof) {

			return(char_eof);

		}

		crt_loc.column += (unsigned long)(p - input_crt);

		IGNORE fill_buffer();

		c = next_char();

	} while (c == char_end);

	input_crt = input_posn;

	return(c);

}

/*

    INCLUDE FILE SEARCH PATH

    The variable dir_path gives the list of directories searched for

    #include'd files.  The variable crt_dir_path is set after each #include

    directive to the position in the path after that at which the included

    file was found.

*/

INCL_DIR *dir_path = NULL;

static INCL_DIR *crt_dir_path = NULL;

static INCL_DIR *crt_found_path = NULL;

/*

    FIND A NAMED DIRECTORY

    This routine looks up a named directory called nm.  It returns the

    corresponding directory structure, or the null pointer if nm is not

    defined.

*/

static INCL_DIR *

find_directory(string nm)

{

	INCL_DIR *p = dir_path;

	while (p != NULL) {

		string s = p->name;

		if (s && ustreq(s, nm)) {

			return(p);

		}

		p = p->next;

	}

	return(NULL);

}

/*

    ADD A DIRECTORY TO THE SEARCH PATH

    This routine adds the directory dir with associated name nm to the

    include file search path.

*/

void

add_directory(string dir, string nm)

{

	INCL_DIR *p = dir_path;

	INCL_DIR *q = xmalloc_one(INCL_DIR);

	if (nm && find_directory(nm)) {

		char *s = strlit(nm);

		error(ERROR_WARNING, "Directory '%s' already defined", s);

		nm = NULL;

	}

	q->path = make_pathname(dir);

	q->name = nm;

	q->mode = NULL;

	q->no = LINK_NONE;

	q->next = NULL;

	if (p == NULL) {

		dir_path = q;

		crt_dir_path = q;

	} else {

		while (p->next) {

			p = p->next;

		}

		p->next = q;

	}

	return;

}

/*

    SET A DIRECTORY COMPILATION MODE

    This routine sets the compilation mode for the directory named nm

    to be p.

*/

void

directory_mode(string nm, OPTIONS *p)

{

	INCL_DIR *q = find_directory(nm);

	if (q) {

		if (q->mode) {

			report(preproc_loc, ERR_pragma_dir_mode(nm));

		}

		if (p) {

			q->mode = p;

		}

	} else {

		report(preproc_loc, ERR_pragma_dir_undef(nm));

	}

	return;

}

/*

    LISTS OF START-UP AND END-UP FILES

    These variables give the lists of start-up and end-up files.  These

    are equivalent to #include "file" directives at respectively the start

    and the end of the main include file.

*/

LIST(string)startup_files = NULL_list(string);

LIST(string)endup_files = NULL_list(string);

/*

    SET UP INTERNAL START-UP FILE

    This routine sets up the built-in internal start-up file.

*/

void

builtin_startup(void)

{

	BUFFER *bf = &internal_buff;

	internal_name = DEREF_string(posn_file(crt_loc.posn));

	internal_file = xmalloc_one(FILE *);

	if (bf->posn != bf->start) {

		/* Add to list of start-up files if necessary */

		CONS_string(internal_name, startup_files, startup_files);

		bf->end = bf->posn;

		bf->posn = bf->start;

	}

	return;

}

/*

    OPEN NEXT START-UP FILE

    This routine opens the next start-up file.  It continues trying until

    a start-up file is successfully opened or there are no start-up files

    left.

*/

void

open_startup(void)

{

	LIST(string)p = startup_files;

	while (!IS_NULL_list(p)) {