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

#include "external.h"

#include "filename.h"

#include "list.h"

#include "execute.h"

#include "flags.h"

#include "compile.h"

#include "main.h"

#include "options.h"

#include "startup.h"

#include "suffix.h"

#include "utility.h"

/*

    CURRENT VERSION NUMBER

    Version 4.0 of tcc is a complete rewrite from version 3.x.  The

    revision number is automatically generated from the RCS revision

    and is stored in version.h.

*/

#define VERSION_STRING		"Version: 4.0"

#ifndef RELEASE

#define RELEASE 		"unknown"

#endif

/*

    PRINT THE CURRENT VERSION

    This routine prints the version number.

*/

void print_version

    PROTO_Z ()

{

    error ( INFO, "%s%s, Machine: %s, Release: %s", VERSION_STRING,

	    ( checker ? " (checker)" : "" ), machine_name, RELEASE ) ;

    flag_no_files = 1 ;

    return ;

}

/*

    ENVIRONMENT

    This variable given the array of environmental variables which is

    passed as the third argument to main.

*/

char **environment = null ;

/*

    SIGNAL HANDLER

    This routine is the main signal handler.  It reports any interesting

    signals and then cleans up.

*/

void handler

    PROTO_N ( ( sig ) )

    PROTO_T ( int sig )

{

    IGNORE signal ( SIGINT, SIG_IGN ) ;

    if ( verbose ) comment ( 1, "\n" ) ;

    if ( sig != SIGINT ) {

	char *cmd = ( last_command ? last_command : "unknown" ) ;

	error ( SERIOUS, "Caught signal %d in '%s'", sig, cmd ) ;

	if ( !flag_keep_err && ( remove ( "core" ) == 0 ) ) {

	    error ( WARNING, "Removed core" ) ;

	}

    }

    exit_status = EXIT_FAILURE ;

    main_end () ;

    return ;

}

/*

    TEMPORARY DIRECTORY FLAG

    This flag is true to indicate that the temporary directory needs

    removing.

*/

static boolean made_tempdir = 0 ;

/*

    MAIN INITIALISATION ROUTINE

    This is the initialisation routine called at the very start of the

    program.  The signals SIGINT, SIGSEGV, SIGTERM and SIGFPE are all

    in ANSI.

*/

static void main_start

    PROTO_N ( ( prog, envp ) )

    PROTO_T ( char *prog X char **envp )

{

    environment = envp ;

    buffer = alloc_nof ( char, buffer_size ) ;

    progname = find_basename ( prog ) ;

    IGNORE signal ( SIGINT, handler ) ;

    IGNORE signal ( SIGSEGV, handler ) ;

    IGNORE signal ( SIGTERM, handler ) ;

#ifdef SIGFPE

    IGNORE signal ( SIGFPE, handler ) ;

#endif

    initialise_options () ;

    return ;

}

/*

    MAIN CONSOLIDATION ROUTINE

    This routine is called after all the command-line arguments have

    been processed, but before any actual compilation takes place.

*/

static void main_middle

    PROTO_Z ()

{

    char *s = temp_name ( temporary_dir, progname ) ;

    tempdir = string_copy ( s ) ;

    cmd_list ( exec_mkdir ) ;

    cmd_string ( tempdir ) ;

    IGNORE execute ( no_filename, no_filename ) ;

    if ( last_return ) {

	error ( FATAL, "Can't create temporary directory" ) ;

    }

    made_tempdir = 1 ;

    return ;

}

/*

    MAIN CLEAN UP ROUTINE

    This routine always used to exit the program, except when an

    exec fails in the child process.  It cleans up the temporary

    directory etc. and returns exit_status to the calling process.

*/

void main_end

    PROTO_Z ()

{

    IGNORE signal ( SIGINT, SIG_IGN ) ;

    remove_junk () ;

    remove_startup () ;

    if ( made_tempdir ) {

	made_tempdir = 0 ;

	cmd_string ( ( char * ) null ) ;

	cmd_list ( exec_remove ) ;

	cmd_string ( tempdir ) ;

	IGNORE execute ( no_filename, no_filename ) ;

    }

    kill_stray () ;

    exit ( exit_status ) ;

}

/*

    MAIN ROUTINE

    This is the main routine.

*/

int main

    PROTO_N ( ( argc, argv ) )

    PROTO_T ( int argc X char **argv )

{ 

    int a ;

    char *s ;

    filename *output ;

    list *opts = null ;

    /* Initialisation */

    main_start ( PROGNAME_TCC, environ ) ;

    /* Check TCCOPTS options */

    s = getenv ( TCCOPT_VAR ) ;

    if ( s != null ) {

    	opts = make_list ( s ) ;

        process_options ( opts, main_optmap ) ;

        free_list ( opts ) ;

        opts = null ;

    }

    /* Process command line options */

    for ( a = argc - 1 ; a >= 1 ; a-- ) {

	opts = insert_item ( argv [a], opts ) ;

    }

    process_options ( opts, main_optmap ) ;

    update_options () ;

    free_list ( opts ) ;

    /* Check for input files */

    if ( input_files == null ) {

	if ( flag_no_files ) main_end () ;

	error ( FATAL, "No input files specified" ) ;

    }

    /* Apply compilation */

    main_middle () ;

    output = apply_all ( input_files ) ;

    /* Check for unprocessed files */

    while ( output != null ) {

	if ( output->storage == INPUT_FILE ) {

	    error ( WARNING, "Input file '%s' not processed", output->name ) ;

	}

	output = output->next ;

    }

    /* Exit from program */

    main_end () ;

    return ( 0 ) ;

}