WebSVN – tendra.SVN – Diff – /trunk/src/tools/tcc/execute.c

+/*
+ * 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 "flags.h"
 #include "main.h"
 #include "utility.h"
 /*
-    LAST COMMAND
+ * PRINT COMMAND INTO BUFFER
+ *
-    The name of the last command executed, and its return value (zero
+ * This routine prints the current command into a buffer and returns a pointer
-    indicating success) are stored.
-*/
-char *last_command = null ;
-int last_return = 0 ;
+ * to the result.
-/*
-    THE CURRENT PROCESS
-    When a process is active, its pid is stored as running_pid.  The
-    value -1 is used to indicate that no process is active.
-*/
+ */
-#if FS_FORK
+static void
+print_cmd(char *b)
+{
+	char **s;
-static long running_pid = -1 ;
+	for (s = command; *s != null; s++) {
+		*b = ' ';
+		IGNORE strcpy(b + 1, *s);
+		b += strlen(b);
+	}
-#endif
+	return;
+}
 /*
-    KILL ANY STRAY PROCESSES
+ * EXECUTE THE CURRENT COMMAND
+ *
+ * This routine executes the command given by the command array. It returns
+ * either output, the list of all output files, if successful, or null,
+ * otherwise. The routine is POSIX compliant. It uses fork and execv from
+ * unistd.h to fork a process and various routines from sys/wait.h to analyse
+ * the result. The interface with sys/wait.h has been abstracted to also allow
+ * the BSD implementation.
+ */
-    Occasionally a runaway process may occur.  This routine is indended
-    to deal with these by sending the signal SIGTERM to the process.
-    This routine is POSIX compliant.
-*/
-void kill_stray
+filename *
-    PROTO_Z ()
+execute(filename *input, filename *output)
+{
+	char *cmd;
+	int err = 0;
+	boolean filled_buff = 0;
+	char buff[buffer_size];
+	cmd_string((char *)null);
+	cmd = command[0];
+	if (cmd == null) {
+		error(INTERNAL, "Empty command");
+		return (null);
+	}
+	last_command = cmd;
+	last_return = 0;
+	junk = output;
+	if (taciturn) {
+		/* Print input files if in taciturn mode */
+		filename *p;
+		for (p = input; p != null; p = p->next) {
+			if (p->storage == INPUT_FILE) {
+				comment(1, "%s:\n", p->name);
+			}
+		}
+	}
+	if (verbose) {
+		/* Print command if in verbose mode */
+		print_cmd(buff);
+		filled_buff = 1;
+		comment(1, "%s\n", buff + 1);
+	}
+	if (cmd && strneq(cmd, "builtin/", 8)) {
+		/* Check built in commands */
+		cmd += 8;
+		switch (*cmd) {
+		case 'b':
+			if (streq(cmd, "build_archive")) {
+				err = build_archive(command[1], command + 2);
+				goto execute_error;
+			}
+			break;
+		case 'c':
+			if (streq(cmd, "cat")) {
+				err = cat_file(command[1]);
+				goto execute_error;
+			}
+			break;
+		case 'm':
+			if (streq(cmd, "mkdir")) {
+				err = make_dir(command[1]);
+				goto execute_error;
+			}
+			if (streq(cmd, "move")) {
+				err = move_file(command[1], command[2]);
+				goto execute_error;
+			}
+			break;
+		case 'r':
+			if (streq(cmd, "remove")) {
+				err = remove_file(command[1]);
+				goto execute_error;
+			}
+			break;
+		case 's':
+			if (streq(cmd, "split_archive")) {
+				err = split_archive(command[1], &output);
+				goto execute_error;
+			}
+			break;
+		case 't':
+			if (streq(cmd, "touch")) {
+				err = touch_file(command[1], command[2]);
+				goto execute_error;
+			}
+			break;
+		case 'u':
+			if (streq(cmd, "undef")) {
+				int sev;
+				if (dry_run) {
+					sev = WARNING;
+				} else {
+					sev = INTERNAL;
+					err = 1;
+				}
+				cmd = command[1];
+				error(sev, "The tool '%s' is not available", cmd);
+				goto execute_error;
+			}
+			break;
+		}
+		error(SERIOUS, "Built-in '%s' command not implemented", cmd);
+		err = 1;
+	} else if (!dry_run) {
+		/* Call system commands */
 #if FS_FORK
+		pid_t pid = fork();
+		if (pid == (pid_t) -1) {
+			error(SERIOUS, "Can't fork process");
+			err = 1;
+		} else {
+			if (pid) {
+				wait_type status;
-    if ( running_pid == -1 ) return ;
+				running_pid = (long)pid;
-    IGNORE kill ( ( pid_t ) running_pid, SIGTERM ) ;
+				while (process_wait ( &status ) != pid ) {
+					;	/* empty */
+				}
-    running_pid = -1 ;
+				running_pid = -1;
+				if (process_exited(status)) {
+					err = process_exit_value(status);
+					/* This only returns if there was no
+					 * remembered signal. */
+					process_delayed_signal();
+				} else {
+					if (process_signaled(status)) {
+						/* delay_signal_handling is a
+						 * global that tells us
+						 * that it is ok to let the
+						 * next call to execute report
+						 * that the command received a
+						 * signal. This supports the
+						 * way that the producer is
+						 * called. */
+						int sig = process_signal_value(status);
+						if (delay_signal_handling &&
+						    last_signal == 0) {
+							last_signaled_cmd =
+							    string_copy(cmd);
+							last_signal = sig;
+						} else {
+							handler(sig);
+						}
-#endif
+					}
-    return ;
+					err = 1;
+				}
+				goto execute_error;
+			}
-}
+			/* print tool chain commands sent to execv */
+			if (tool_chain) {
+				char **curr = command;
+				IGNORE printf ("\n%s \\\n", *curr++);
+				while (*curr) {
+					IGNORE printf ("\t%s", *curr++);
+					if (*curr) {
+						IGNORE printf (" \\");
+					}
-/*
-    LIST OF FILES TO BE REMOVED BY REMOVE_JUNK
+					IGNORE printf ("\n");
+				}
+			}
-    This gives the list of the files which are to be removed if an
+			/* print environment values sent to execv */
+			if (tool_chain_environ) {
-    error occurs.
+				char **curr = environment;
-*/
+				IGNORE printf ("\n\tEnvironment dump");
+				if (!tool_chain) {
-static filename *junk = null ;
+					IGNORE printf (" for cmd %s", cmd);
+				}
+				IGNORE printf ("\n");
-/*
-    REMOVE ANY INCOMPLETE OUTPUT FILES
-    Any files which are being created when an error occurs should be
-    removed.
-*/
-void remove_junk
-    PROTO_Z ()
-{
-    if ( !dry_run && !flag_keep_err ) {
-	filename *p ;
-	for ( p = junk ; p != null ; p = p->next ) {
-	    if ( p->storage == OUTPUT_FILE ) IGNORE remove ( p->name ) ;
-	}
-    }
-    junk = null ;
-    return ;
-}
-/*
-    PRINT COMMAND INTO BUFFER
-    This routine prints the current command into a buffer and returns
-    a pointer to the result.
-*/
-static void print_cmd
-    PROTO_N ( ( b ) )
-    PROTO_T ( char *b )
-{
-    char **s ;
-    for ( s = command ; *s != null ; s++ ) {
-	*b = ' ' ;
-	IGNORE strcpy ( b + 1, *s ) ;
-	b += strlen ( b ) ;
-    }
-    return ;
-}
-/*
-    EXECUTE THE CURRENT COMMAND
-    This routine executes the command given by the command array.  It
-    returns either output, the list of all output files, if successful,
-    or null, otherwise.  The routine is POSIX compliant.  It uses fork
-    and execv from unistd.h to fork a process and various routines from
-    sys/wait.h to analyse the result.  The interface with sys/wait.h
-    has been abstracted to also allow the BSD implementation.
-*/
-filename *execute
-    PROTO_N ( ( input, output ) )
-    PROTO_T ( filename *input X filename *output )
-{
-    char *cmd ;
-    int err = 0 ;
-    boolean filled_buff = 0 ;
-    char buff [ buffer_size ] ;
-    cmd_string ( ( char * ) null ) ;
-    cmd = command [0] ;
-    if ( cmd == null ) {
-	error ( INTERNAL, "Empty command" ) ;
-	return ( null ) ;
-    }
-    last_command = cmd ;
-    last_return = 0 ;
-    junk = output ;
-    if ( taciturn ) {
-	/* Print input files if in taciturn mode */
-	filename *p ;
-	for ( p = input ; p != null ; p = p->next ) {
-	    if ( p->storage == INPUT_FILE ) {
-		comment ( 1, "%s:\n", p->name ) ;
-	    }
-	}
-    }
-    if ( verbose ) {
-	/* Print command if in verbose mode */
-	print_cmd ( buff ) ;
-	filled_buff = 1 ;
-	comment ( 1, "%s\n", buff + 1 ) ;
-    }
-    if ( cmd && strneq ( cmd, "builtin/", 8 ) ) {
-	/* Check built in commands */
-	cmd += 8 ;
-	switch ( *cmd ) {
+				while (*curr) {
-	    case 'b' : {
-		if ( streq ( cmd, "build_archive" ) ) {
-		    err = build_archive ( command [1], command + 2 ) ;
-		    goto execute_error ;
-		}
-		break ;
-	    }
-	    case 'c' : {
-		if ( streq ( cmd, "cat" ) ) {
-		    err = cat_file ( command [1] ) ;
+					IGNORE printf ("\t%s\n", *curr);
-		    goto execute_error ;
-		}
-		break ;
+					curr++;
-	    }
-	    case 'm' : {
-		if ( streq ( cmd, "mkdir" ) ) {
-		    err = make_dir ( command [1] ) ;
-		    goto execute_error ;
-		}
-		if ( streq ( cmd, "move" ) ) {
-		    err = move_file ( command [1], command [2] ) ;
-		    goto execute_error ;
-		}
+				}
-		break ;
-	    }
-	    case 'r' : {
-		if ( streq ( cmd, "remove" ) ) {
-		    err = remove_file ( command [1] ) ;
-		    goto execute_error ;
-		}
+			}
-		break ;
-	    }
-	    case 's' : {
-		if ( streq ( cmd, "split_archive" ) ) {
-		    err = split_archive ( command [1], &output ) ;
-		    goto execute_error ;
-		}
-		break ;
-	    }
-	    case 't' : {
-		if ( streq ( cmd, "touch" ) ) {
-		    err = touch_file ( command [1], command [2] ) ;
-		    goto execute_error ;
-		}
-		break ;
-	    }
-	    case 'u' : {
-		if ( streq ( cmd, "undef" ) ) {
-		    int sev ;
-		    if ( dry_run ) {
-			sev = WARNING ;
-		    } else {
-			sev = INTERNAL ;
-			err = 1 ;
-		    }
-		    cmd = command [1] ;
-		    error ( sev, "The tool '%s' is not available", cmd ) ;
-		    goto execute_error ;
-		}
-		break ;
-	    }
-	}
-	error ( SERIOUS, "Built-in '%s' command not implemented", cmd ) ;
-	err = 1 ;
-    } else if ( !dry_run ) {
-	/* Call system commands */
+			IGNORE execve(cmd, command, environment);
-#if FS_FORK
-	{
-	    pid_t pid = fork () ;
+			running_pid = -1;
-	    if ( pid == ( pid_t ) -1 ) {
-		error ( SERIOUS, "Can't fork process" ) ;
+			error(SERIOUS, "Can't execute '%s'", cmd);
-		err = 1 ;
+			exit(2);
+		}
-	    } else {
+#else
+		wait_type status;
-		if ( pid ) {
+		if (!filled_buff) {
-		    wait_type status ;
+			print_cmd(buff);
-		    running_pid = ( long ) pid ;
+			filled_buff = 1;
+		}
-		    while ( process_wait ( &status ) != pid ) /* empty */ ;
+		err = system(buff + 1);
-		    running_pid = -1 ;
+		process_return(status, err);
-		    if ( process_exited ( status ) ) {
+		if (process_exited(status)) {
-			err = process_exit_value ( status ) ;
+			err = process_exit_value(status);
-			/* This only returns if there was no remembered
-			   signal. */
-			process_delayed_signal () ;
+			process_delayed_signal();
-		    } else {
+		} else {
-			if ( process_signaled ( status ) ) {
+			if (process_signaled(status)) {
-			    /* delay_signal_handling is a global that tells us
+				/* delay_signal_handling is a global that tells
-			       that it is ok to let the next call to execute
+				 * us that it is ok to let the next call to
-			       report that the command received a signal.
+				 * execute report that the command received a
-			       This supports the way that the producer is called. */
+				 * signal. This supports the way that the
+				 * producer is called. */
-			    int sig = process_signal_value ( status ) ;
+				int sig = process_signal_value(status);
-			    if ( delay_signal_handling && last_signal == 0 ) {
+				if (delay_signal_handling &&
+				    last_signal == 0) {
-				last_signaled_cmd = string_copy ( cmd ) ;
+					last_signaled_cmd = string_copy(cmd);
-				last_signal = sig ;
+					last_signal = sig;
-			    } else {
+				} else {
-				handler ( sig ) ;
+					handler(sig);
-			    }
+				}
 			}
-			err = 1 ;
+			err = 1;
-		    }
-		    goto execute_error ;
+		}
-		IGNORE execve ( cmd, command, environment ) ;
-		running_pid = -1 ;
-		error ( SERIOUS, "Can't execute '%s'", cmd ) ;
-		exit ( 2 ) ;
-	    }
-	}
-#else
-	{
-	    wait_type status ;
-	    if ( !filled_buff ) {
-		print_cmd ( buff ) ;
-		filled_buff = 1 ;
-	    }
-	    err = system ( buff + 1 ) ;
-	    process_return ( status, err ) ;
-	    if ( process_exited ( status ) ) {
-		err = process_exit_value ( status ) ;
-		process_delayed_signal () ;
-	    } else {
-		if ( process_signaled ( status ) ) {
-		    /* delay_signal_handling is a global that tells us
-		       that it is ok to let the next call to execute
-		       report that the command received a signal.
-		       This supports the way that the producer is called. */
-		    int sig = process_signal_value ( status ) ;
-		    if ( delay_signal_handling && last_signal == 0 ) {
-			last_signaled_cmd = string_copy ( cmd ) ;
-			last_signal = sig ;
-		    } else {
-			handler ( sig ) ;
-		    }
-		}
-		err = 1 ;
-	    }
-	}
 #endif
-    }
+	}
-    /* Deal with errors */
+	/* Deal with errors */
-    execute_error : {
+execute_error:
-        disable_delayed_signal () ;
+	disable_delayed_signal();
-	last_return = err ;
+	last_return = err;
-	if ( tidy_up ) {
+	if (tidy_up) {
-	    /* Remove unneeded files */
+		/* Remove unneeded files */
-	    filename *p ;
+		filename *p;
-	    for ( p = input ; p != null ; p = p->next ) {
+		for (p = input; p != null; p = p->next) {
-		if ( p->storage == TEMP_FILE && p->type != BINARY_OBJ ) {
+			if (p->storage == TEMP_FILE && p->type != BINARY_OBJ) {
-		    IGNORE remove ( p->name ) ;
+				IGNORE remove(p->name);
+			}
+		}
-	    }
+	}
-	if ( err ) {
+	if (err) {
-	    exec_error = 1 ;
+		exec_error = 1;
-	    exit_status = EXIT_FAILURE ;
+		exit_status = EXIT_FAILURE;
-	    if ( show_errors ) {
+		if (show_errors) {
-		/* Show when the error occurred */
+			/* Show when the error occurred */
-		if ( !filled_buff ) print_cmd ( buff ) ;
+			if (!filled_buff) {
+				print_cmd(buff);
+			}
-		error ( INFO, "Error in '%s'", buff + 1 ) ;
+			error(INFO, "Error in '%s'", buff + 1);
-	    }
+		}
-	    remove_junk () ;
+		remove_junk();
-	    return ( null ) ;
+		return (null);
+	}
-	junk = null ;
+	junk = null;
-	return ( output ) ;
+	return (output);
-    }
+}

Subversion Repositories tendra.SVN

(root)/trunk/src/tools/tcc/execute.c – Rev 2 → 7