Tcl Source Code

    const char *p;
    const char *nextArg;
    int skip, lastBar, lastArg, i, j, atOK, flags, needCmd, errorToOutput = 0;
    Tcl_DString execBuffer;
    TclFile pipeIn;
    TclFile curInFile, curOutFile, curErrFile;
    Tcl_Channel channel;
    int newSyntax = 0;
    int subArgc;
    const char **subArgv = NULL;

    if (inPipePtr != NULL) {
	*inPipePtr = NULL;
    }
    if (outPipePtr != NULL) {
	*outPipePtr = NULL;
    }

     * list.
     */

    lastBar = -1;
    cmdCount = 1;
    needCmd = 1;
    for (i = 0; i < argc; i++) {
	if (newSyntax && needCmd) {
	    needCmd = 0;
	    continue;
	}
	errorToOutput = 0;
	skip = 0;
	p = argv[i];
	switch (*p++) {
	case '|':
	    if ((i == 0) && (*p == '\0')) {
		newSyntax = 1;
		lastBar = 0;
		continue;
	    }
	    if (*p == '&') {
		p++;
	    }
	    if (*p == '\0') {
		if ((i == (lastBar + 1)) || (i == (argc - 1))) {
		    Tcl_SetObjResult(interp, Tcl_NewStringObj(
			    "illegal use of | or |& in command", -1));

		if (errorFile == NULL) {
		    goto error;
		}
	    }
	    break;

	default:

	    if (newSyntax) {
		Tcl_SetObjResult(interp,
				 Tcl_ObjPrintf(
					       "Unsupported redirection \"%s\"",
					       argv[i]));
		Tcl_SetErrorCode(interp, "TCL", "OPERATION", "EXEC",
				 "PIPESYNTAX", NULL);
		goto error;
	    } else {

	    /*
	     * Got a command word, not a redirection.
	     */

	    needCmd = 0;
		/*
		 * Got a command word, not a redirection.
		 */
		
		needCmd = 0;
	    }
	    break;
	}

	if (skip != 0) {
	    for (j = i + skip; j < argc; j++) {
		argv[j - skip] = argv[j];
	    }

     * arguments between the "|" characters.
     */

    Tcl_ReapDetachedProcs();
    pidPtr = ckalloc(cmdCount * sizeof(Tcl_Pid));

    curInFile = inputFile;

    lastArg = argc; /* compiler warning */

    for (i = 0; i < argc; i = lastArg + 1) {
	int result, joinThisError;
	Tcl_Pid pid;
	const char *oldName;

	if (newSyntax) {
	    if (i == 0) {
		lastArg = i;
		continue;
	    }
	    if (Tcl_SplitList(interp, argv[i], &subArgc, &subArgv) != TCL_OK) {
		goto error;
	    }
	    if (Tcl_TranslateFileName(interp, subArgv[0], &execBuffer) == NULL) {
		goto error;
	    }
	} else {
	/*
	 * Convert the program name into native form.
	 */

	if (Tcl_TranslateFileName(interp, argv[i], &execBuffer) == NULL) {
	    goto error;
	    /*
	     * Convert the program name into native form.
	     */
	    
	    if (Tcl_TranslateFileName(interp, argv[i], &execBuffer) == NULL) {
		goto error;
	    }
	}

	/*
	 * Find the end of the current segment of the pipeline.
	 */

	joinThisError = 0;

	if (joinThisError != 0) {
	    curErrFile = curOutFile;
	} else {
	    curErrFile = errorFile;
	}

	if (newSyntax) {
	    subArgv[0] = Tcl_DStringValue(&execBuffer);
	    result = TclpCreateProcess(interp, subArgc, subArgv,
				       curInFile, curOutFile, curErrFile, &pid);
	    ckfree(subArgv);
	    subArgv = NULL;
	} else {
	/*
	 * Restore argv[i], since a caller wouldn't expect the contents of
	 * argv to be modified.
	 */

	oldName = argv[i];
	argv[i] = Tcl_DStringValue(&execBuffer);
	result = TclpCreateProcess(interp, lastArg - i, argv + i,
		curInFile, curOutFile, curErrFile, &pid);
	argv[i] = oldName;
	    /*
	     * Restore argv[i], since a caller wouldn't expect the contents of
	     * argv to be modified.
	     */
	    
	    oldName = argv[i];
	    argv[i] = Tcl_DStringValue(&execBuffer);
	    result = TclpCreateProcess(interp, lastArg - i, argv + i,
				       curInFile, curOutFile, curErrFile, &pid);
	    argv[i] = oldName;
	}
	if (result != TCL_OK) {
	    goto error;
	}
	Tcl_DStringFree(&execBuffer);

	pidPtr[numPids] = pid;
	numPids++;

    if (pidPtr != NULL) {
	for (i = 0; i < numPids; i++) {
	    if (pidPtr[i] != (Tcl_Pid) -1) {
		Tcl_DetachPids(1, &pidPtr[i]);
	    }
	}
	ckfree(pidPtr);
    }
    if (subArgv != NULL) {
	ckfree(subArgv);
	subArgv = NULL;
    }
    numPids = -1;
    goto cleanup;
}

/*
 *----------------------------------------------------------------------

# Errors in executing the Tcl command, as opposed to errors in the processes
# that are invoked.

test exec-10.1 {errors in exec invocation} -constraints {exec} -body {
    exec
} -returnCodes error -result {wrong # args: should be "exec ?-switch ...? arg ?arg ...?"}
test exec-10.2 {errors in exec invocation} -constraints {exec} -body {
    exec | cat
    exec |& cat
} -returnCodes error -result {illegal use of | or |& in command}
test exec-10.3 {errors in exec invocation} -constraints {exec} -body {
    exec cat |
} -returnCodes error -result {illegal use of | or |& in command}
test exec-10.4 {errors in exec invocation} -constraints {exec} -body {
    exec cat | | cat
} -returnCodes error -result {illegal use of | or |& in command}

    # Check that no bytes have got lost through mixups with overlapping
    # appends, which is only guaranteed to work when we set O_APPEND on the
    # file descriptor in the [exec >>...]
    file size $tmpfile
} -cleanup {
    removeFile $tmpfile
} -result 14

# New Syntax
test exec-20.1 {New exec syntax with sublists} {exec} {
    exec | {echo >}
} >


# ----------------------------------------------------------------------
# cleanup

foreach file {gorp.file gorp.file2 echo echo2 cat wc sh sh2 sleep exit err} {
    removeFile $file
}