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 "filename.h"

#include "list.h"

#include "environ.h"

#include "flags.h"

#include "options.h"

#include "suffix.h"

#include "utility.h"

/*

    THE CURRENT ENVIRONMENTS PATH

    The environment path is a colon-separated list of directories which

    are searched for tcc environments.

*/

static char *envpath = "." ;

/*

    UPDATE THE ENVIRONMENTS PATH

    This routine initialises and updates the environments path.  This is

    given by the contents of the system variable TCCENV, plus the default

    directory (environ_dir), plus the current directory.

*/

void find_envpath

    PROTO_Z ()

{

    char *p = buffer ;

    char *tcc_env = getenv ( TCCENV_VAR ) ;

    if ( tcc_env ) {

	IGNORE sprintf ( p, "%s:", tcc_env ) ;

	p += strlen ( p ) ;

    }

    IGNORE sprintf ( p, "%s:.", environ_dir ) ;

    if ( !streq ( buffer, envpath ) ) envpath = string_copy ( buffer ) ;

    return ;

}

/*

    PRINT THE ENVIRONMENTS PATH

    This routine prints the environment path.

*/

void show_envpath

    PROTO_Z ()

{

    find_envpath () ;

    error ( INFO, "Environment path is '%s'", envpath ) ;

    return ;

}

/*

    CHARACTER TYPES

    These macros identify various character types.

*/

#define is_alphanum( X )	( ( ( X ) >= 'A' && ( X ) <= 'Z' ) ||\

				  ( ( X ) >= '0' && ( X ) <= '9' ) ||\

				  ( ( X ) == '_' ) )

#define is_whitespace( X )	( ( X ) == ' ' || ( X ) == '\t' )

#define is_quote( X )		( ( X ) == '"' )

#define is_newline( X )		( ( X ) == '\n' )

/*

    READ AN ENVIRONMENT - AUXILIARY ROUTINE

    This routine reads the environment named nm, returning zero if it

    is successful.  A return value of 1 indicates that the environment

    could not be found, otherwise 2 is returned.

*/

int read_env_aux

    PROTO_N ( ( nm ) )

    PROTO_T ( char *nm )

{

    /* Find the environment */

    FILE *f ;

    char *p, *q ;

    if ( *nm == 0 ) {

	return ( 1 ) ;

    } else if ( *nm == '/' ) {

	f = fopen ( nm, "r" ) ;

    } else {

	p = envpath ;

	do {

	    q = buffer ;

	    while ( *p && *p != ':' ) *( q++ ) = *( p++ ) ;

	    *( q++ ) = '/' ;

	    IGNORE strcpy ( q, nm ) ;

	    f = fopen ( buffer, "r" ) ;

	} while ( f == null && *( p++ ) ) ;

    }

    if ( f == null ) return ( 1 ) ;

    /* Read the environment one line at a time */

    while ( fgets ( buffer, buffer_size, f ) != null ) {

	char c = *buffer ;

	if ( c == '<' || c == '>' || c == '+' || c == '?' ) {

	    /* Only process lines beginning with these characters */

	    char *sp ;

	    list dummy ;

	    char line [1000] ;

	    line [0] = c ;

	    p = buffer + 1 ;

	    q = line + 1 ;

	    while ( c = *( p++ ), is_alphanum ( c ) ) *( q++ ) = c ;

	    sp = q ;

	    *( q++ ) = 0 ;

	    if ( !is_whitespace ( c ) ) {

		error ( WARNING, "Illegal environmental variable, '%s'",

			line ) ;

	    }

	    while ( c = *( p++ ), is_whitespace ( c ) ) /* empty */ ;

	    if ( !is_quote ( c ) ) {

		error ( WARNING, "Illegal environmental value for '%s'",

			line ) ;

	    }

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

		if ( c == '\\' ) c = *( p++ ) ;

		if ( c == 0 || is_newline ( c ) ) {

		    error ( WARNING, "Illegal environmental value for '%s'",

			    line ) ;

		    break ;

		}

		*( q++ ) = c ;

	    }

	    while ( c = *( p++ ), is_whitespace ( c ) ) /* empty */ ;

	    if ( !is_newline ( c ) ) {

		error ( WARNING, "Illegal environmental value for '%s'",

			line ) ;

	    }

	    *sp = ' ' ;

	    *q = 0 ;

	    dummy.item = string_copy ( line ) ;

	    dummy.next = null ;

	    process_options ( &dummy, environ_optmap ) ;

	}

    }

    IGNORE fclose ( f ) ;

    return ( 0 ) ;

}

/*

    READ AN ENVIRONMENT

    This routine reads the environment named nm, reporting an error if

    it is unsuccessful.

*/

void read_env

    PROTO_N ( ( nm ) )

    PROTO_T ( char *nm )

{

    int e = read_env_aux ( nm ) ;

    if ( e == 1 ) error ( WARNING, "Can't find environment, '%s'", nm ) ;

    return ;

}