Subversion Repositories tendra.SVN

/*

    		 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

    PROTO_N ( ( nm ) )

    PROTO_T ( 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

    PROTO_N ( ( nm ) )

    PROTO_T ( 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

    PROTO_N ( ( s ) )

    PROTO_T ( 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 '//' */

		p++ ;

		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

    PROTO_N ( ( nm, special ) )

    PROTO_T ( string nm X 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

    PROTO_N ( ( bin ) )

    PROTO_T ( 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

    PROTO_Z ()

{

    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

    PROTO_N ( ( n, bin ) )

    PROTO_T ( int n X 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

    PROTO_Z ()

{

    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

    PROTO_N ( ( n ) )

    PROTO_T ( 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

    PROTO_Z ()

{

    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

    PROTO_N ( ( i ) )

    PROTO_T ( 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

    PROTO_N ( ( i ) )

    PROTO_T ( 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

    PROTO_N ( ( i ) )

    PROTO_T ( 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

    PROTO_N ( ( i, n, started ) )

    PROTO_T ( unsigned long i X long n X 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

    PROTO_Z ()

{

    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

    PROTO_Z ()

{

    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

    PROTO_N ( ( nm ) )

    PROTO_T ( 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

    PROTO_N ( ( dir, nm ) )

    PROTO_T ( string dir X 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

    PROTO_N ( ( nm, p ) )

    PROTO_T ( string nm X 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

    PROTO_Z ()

{

    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

    PROTO_Z ()

{

    LIST ( string ) p = startup_files ;

    while ( !IS_NULL_list ( p ) ) {

	string fn = DEREF_string ( HEAD_list ( p ) ) ;

	p = TAIL_list ( p ) ;

	startup_files = p ;

	preproc_loc = crt_loc ;

	crt_file_type = 1 ;

	if ( start_include ( fn, char_quote, 2, 0 ) ) return ;

    }

    crt_file_type = 0 ;

    return ;

}

/*

    LIST OF INCLUDED FILES

    This list is used to record all the files included plus the position

    of the current file within this list.

*/

typedef struct incl_file_tag {

    string name ;

    int imported ;

    HASHID macro ;

    unsigned test ;

    int state ;

    PTR ( LOCATION ) from ;

    STAT_TYPE *data ;

    STAT_TYPE data_ref ;

    struct incl_file_tag *next ;

} INCL_FILE ;

static INCL_FILE *included_files = NULL ;

static INCL_FILE *crt_included_file = NULL ;

/*

    TABLE OF INCLUSIONS

    This table is used to hold the file positions for all the currently

    active #include directives.  Note that this is done as a finite

    (but hopefully sufficiently large) array to detect recursive

    inclusions.

*/

typedef struct {

    string name ;

    FILE *fileptr ;

    long offset ;

    int special ;

    int startup ;

    int interface ;

    OPTIONS *mode ;

    INCL_DIR *path ;

    INCL_DIR *found ;

    INCL_FILE *incl ;

} INCL_BUFF ;

#define MAX_INCL_DEPTH		256

static INCL_BUFF position_array [ MAX_INCL_DEPTH ] ;

static INCL_BUFF *position = position_array ;

static unsigned long position_size = MAX_INCL_DEPTH ;

/*

    SIMPLE INCLUSION DEPTH

    There are two approaches to suspending the current file - either

    leaving the file open or closing it and reopening it later.  The

    latter is more efficient, but is limited by the maximum number of

    files which can be opened at one time (FOPEN_MAX).  Therefore this

    strategy is only used for this number of files.  Note that FOPEN_MAX

    is at least 8 (including the 3 standard files).

*/