1/* Synchronous subprocess invocation for GNU Emacs. 2 Copyright (C) 1985, 1986, 1987, 1988, 1993, 1994, 1995, 1999, 2000, 2001, 3 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc. 4 5This file is part of GNU Emacs. 6 7GNU Emacs is free software; you can redistribute it and/or modify 8it under the terms of the GNU General Public License as published by 9the Free Software Foundation; either version 2, or (at your option) 10any later version. 11 12GNU Emacs is distributed in the hope that it will be useful, 13but WITHOUT ANY WARRANTY; without even the implied warranty of 14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15GNU General Public License for more details. 16 17You should have received a copy of the GNU General Public License 18along with GNU Emacs; see the file COPYING. If not, write to 19the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, 20Boston, MA 02110-1301, USA. */ 21 22 23#include <config.h> 24#include <signal.h> 25#include <errno.h> 26#include <stdio.h> 27 28#ifndef USE_CRT_DLL 29extern int errno; 30#endif 31 32/* Define SIGCHLD as an alias for SIGCLD. */ 33 34#if !defined (SIGCHLD) && defined (SIGCLD) 35#define SIGCHLD SIGCLD 36#endif /* SIGCLD */ 37 38#include <sys/types.h> 39 40#ifdef HAVE_UNISTD_H 41#include <unistd.h> 42#endif 43 44#include <sys/file.h> 45#ifdef HAVE_FCNTL_H 46#define INCLUDED_FCNTL 47#include <fcntl.h> 48#endif 49 50#ifdef WINDOWSNT 51#define NOMINMAX 52#include <windows.h> 53#include <stdlib.h> /* for proper declaration of environ */ 54#include <fcntl.h> 55#include "w32.h" 56#define _P_NOWAIT 1 /* from process.h */ 57#endif 58 59#ifdef MSDOS /* Demacs 1.1.1 91/10/16 HIRANO Satoshi */ 60#define INCLUDED_FCNTL 61#include <fcntl.h> 62#include <sys/stat.h> 63#include <sys/param.h> 64#include <errno.h> 65#endif /* MSDOS */ 66 67#ifndef O_RDONLY 68#define O_RDONLY 0 69#endif 70 71#ifndef O_WRONLY 72#define O_WRONLY 1 73#endif 74 75#include "lisp.h" 76#include "commands.h" 77#include "buffer.h" 78#include "charset.h" 79#include "ccl.h" 80#include "coding.h" 81#include "composite.h" 82#include <epaths.h> 83#include "process.h" 84#include "syssignal.h" 85#include "systty.h" 86#include "blockinput.h" 87 88#ifdef MSDOS 89#include "msdos.h" 90#endif 91 92#ifdef VMS 93extern noshare char **environ; 94#else 95#ifndef USE_CRT_DLL 96extern char **environ; 97#endif 98#endif 99 100#ifdef HAVE_SETPGID 101#if !defined (USG) || defined (BSD_PGRPS) 102#undef setpgrp 103#define setpgrp setpgid 104#endif 105#endif 106 107Lisp_Object Vexec_path, Vexec_directory, Vexec_suffixes; 108Lisp_Object Vdata_directory, Vdoc_directory; 109Lisp_Object Vconfigure_info_directory, Vshared_game_score_directory; 110Lisp_Object Vtemp_file_name_pattern; 111 112Lisp_Object Vshell_file_name; 113 114Lisp_Object Vprocess_environment; 115 116#ifdef DOS_NT 117Lisp_Object Qbuffer_file_type; 118#endif /* DOS_NT */ 119 120/* True iff we are about to fork off a synchronous process or if we 121 are waiting for it. */ 122int synch_process_alive; 123 124/* Nonzero => this is a string explaining death of synchronous subprocess. */ 125char *synch_process_death; 126 127/* Nonzero => this is the signal number that terminated the subprocess. */ 128int synch_process_termsig; 129 130/* If synch_process_death is zero, 131 this is exit code of synchronous subprocess. */ 132int synch_process_retcode; 133 134/* Clean up when exiting Fcall_process. 135 On MSDOS, delete the temporary file on any kind of termination. 136 On Unix, kill the process and any children on termination by signal. */ 137 138/* Nonzero if this is termination due to exit. */ 139static int call_process_exited; 140 141#ifndef VMS /* VMS version is in vmsproc.c. */ 142 143static Lisp_Object 144call_process_kill (fdpid) 145 Lisp_Object fdpid; 146{ 147 emacs_close (XFASTINT (Fcar (fdpid))); 148 EMACS_KILLPG (XFASTINT (Fcdr (fdpid)), SIGKILL); 149 synch_process_alive = 0; 150 return Qnil; 151} 152 153Lisp_Object 154call_process_cleanup (fdpid) 155 Lisp_Object fdpid; 156{ 157#if defined (MSDOS) || defined (MAC_OS8) 158 /* for MSDOS fdpid is really (fd . tempfile) */ 159 register Lisp_Object file; 160 file = Fcdr (fdpid); 161 emacs_close (XFASTINT (Fcar (fdpid))); 162 if (strcmp (SDATA (file), NULL_DEVICE) != 0) 163 unlink (SDATA (file)); 164#else /* not MSDOS and not MAC_OS8 */ 165 register int pid = XFASTINT (Fcdr (fdpid)); 166 167 if (call_process_exited) 168 { 169 emacs_close (XFASTINT (Fcar (fdpid))); 170 return Qnil; 171 } 172 173 if (EMACS_KILLPG (pid, SIGINT) == 0) 174 { 175 int count = SPECPDL_INDEX (); 176 record_unwind_protect (call_process_kill, fdpid); 177 message1 ("Waiting for process to die...(type C-g again to kill it instantly)"); 178 immediate_quit = 1; 179 QUIT; 180 wait_for_termination (pid); 181 immediate_quit = 0; 182 specpdl_ptr = specpdl + count; /* Discard the unwind protect. */ 183 message1 ("Waiting for process to die...done"); 184 } 185 synch_process_alive = 0; 186 emacs_close (XFASTINT (Fcar (fdpid))); 187#endif /* not MSDOS */ 188 return Qnil; 189} 190 191DEFUN ("call-process", Fcall_process, Scall_process, 1, MANY, 0, 192 doc: /* Call PROGRAM synchronously in separate process. 193The remaining arguments are optional. 194The program's input comes from file INFILE (nil means `/dev/null'). 195Insert output in BUFFER before point; t means current buffer; 196 nil for BUFFER means discard it; 0 means discard and don't wait. 197BUFFER can also have the form (REAL-BUFFER STDERR-FILE); in that case, 198REAL-BUFFER says what to do with standard output, as above, 199while STDERR-FILE says what to do with standard error in the child. 200STDERR-FILE may be nil (discard standard error output), 201t (mix it with ordinary output), or a file name string. 202 203Fourth arg DISPLAY non-nil means redisplay buffer as output is inserted. 204Remaining arguments are strings passed as command arguments to PROGRAM. 205 206If executable PROGRAM can't be found as an executable, `call-process' 207signals a Lisp error. `call-process' reports errors in execution of 208the program only through its return and output. 209 210If BUFFER is 0, `call-process' returns immediately with value nil. 211Otherwise it waits for PROGRAM to terminate 212and returns a numeric exit status or a signal description string. 213If you quit, the process is killed with SIGINT, or SIGKILL if you quit again. 214 215usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS) */) 216 (nargs, args) 217 int nargs; 218 register Lisp_Object *args; 219{ 220 Lisp_Object infile, buffer, current_dir, path; 221 int display_p; 222 int fd[2]; 223 int filefd; 224 register int pid; 225#define CALLPROC_BUFFER_SIZE_MIN (16 * 1024) 226#define CALLPROC_BUFFER_SIZE_MAX (4 * CALLPROC_BUFFER_SIZE_MIN) 227 char buf[CALLPROC_BUFFER_SIZE_MAX]; 228 int bufsize = CALLPROC_BUFFER_SIZE_MIN; 229 int count = SPECPDL_INDEX (); 230 231 register const unsigned char **new_argv 232 = (const unsigned char **) alloca ((max (2, nargs - 2)) * sizeof (char *)); 233 struct buffer *old = current_buffer; 234 /* File to use for stderr in the child. 235 t means use same as standard output. */ 236 Lisp_Object error_file; 237#ifdef MSDOS /* Demacs 1.1.1 91/10/16 HIRANO Satoshi */ 238 char *outf, *tempfile; 239 int outfilefd; 240#endif 241#ifdef MAC_OS8 242 char *tempfile; 243 int outfilefd; 244#endif 245#if 0 246 int mask; 247#endif 248 struct coding_system process_coding; /* coding-system of process output */ 249 struct coding_system argument_coding; /* coding-system of arguments */ 250 /* Set to the return value of Ffind_operation_coding_system. */ 251 Lisp_Object coding_systems; 252 253 /* Qt denotes that Ffind_operation_coding_system is not yet called. */ 254 coding_systems = Qt; 255 256 CHECK_STRING (args[0]); 257 258 error_file = Qt; 259 260#ifndef subprocesses 261 /* Without asynchronous processes we cannot have BUFFER == 0. */ 262 if (nargs >= 3 263 && (INTEGERP (CONSP (args[2]) ? XCAR (args[2]) : args[2]))) 264 error ("Operating system cannot handle asynchronous subprocesses"); 265#endif /* subprocesses */ 266 267 /* Decide the coding-system for giving arguments. */ 268 { 269 Lisp_Object val, *args2; 270 int i; 271 272 /* If arguments are supplied, we may have to encode them. */ 273 if (nargs >= 5) 274 { 275 int must_encode = 0; 276 277 for (i = 4; i < nargs; i++) 278 CHECK_STRING (args[i]); 279 280 for (i = 4; i < nargs; i++) 281 if (STRING_MULTIBYTE (args[i])) 282 must_encode = 1; 283 284 if (!NILP (Vcoding_system_for_write)) 285 val = Vcoding_system_for_write; 286 else if (! must_encode) 287 val = Qnil; 288 else 289 { 290 args2 = (Lisp_Object *) alloca ((nargs + 1) * sizeof *args2); 291 args2[0] = Qcall_process; 292 for (i = 0; i < nargs; i++) args2[i + 1] = args[i]; 293 coding_systems = Ffind_operation_coding_system (nargs + 1, args2); 294 if (CONSP (coding_systems)) 295 val = XCDR (coding_systems); 296 else if (CONSP (Vdefault_process_coding_system)) 297 val = XCDR (Vdefault_process_coding_system); 298 else 299 val = Qnil; 300 } 301 setup_coding_system (Fcheck_coding_system (val), &argument_coding); 302 if (argument_coding.common_flags & CODING_ASCII_INCOMPATIBLE_MASK) 303 setup_coding_system (Qraw_text, &argument_coding); 304 if (argument_coding.eol_type == CODING_EOL_UNDECIDED) 305 argument_coding.eol_type = system_eol_type; 306 } 307 } 308 309 if (nargs >= 2 && ! NILP (args[1])) 310 { 311 infile = Fexpand_file_name (args[1], current_buffer->directory); 312 CHECK_STRING (infile); 313 } 314 else 315 infile = build_string (NULL_DEVICE); 316 317 if (nargs >= 3) 318 { 319 buffer = args[2]; 320 321 /* If BUFFER is a list, its meaning is 322 (BUFFER-FOR-STDOUT FILE-FOR-STDERR). */ 323 if (CONSP (buffer)) 324 { 325 if (CONSP (XCDR (buffer))) 326 { 327 Lisp_Object stderr_file; 328 stderr_file = XCAR (XCDR (buffer)); 329 330 if (NILP (stderr_file) || EQ (Qt, stderr_file)) 331 error_file = stderr_file; 332 else 333 error_file = Fexpand_file_name (stderr_file, Qnil); 334 } 335 336 buffer = XCAR (buffer); 337 } 338 339 if (!(EQ (buffer, Qnil) 340 || EQ (buffer, Qt) 341 || INTEGERP (buffer))) 342 { 343 Lisp_Object spec_buffer; 344 spec_buffer = buffer; 345 buffer = Fget_buffer_create (buffer); 346 /* Mention the buffer name for a better error message. */ 347 if (NILP (buffer)) 348 CHECK_BUFFER (spec_buffer); 349 CHECK_BUFFER (buffer); 350 } 351 } 352 else 353 buffer = Qnil; 354 355 /* Make sure that the child will be able to chdir to the current 356 buffer's current directory, or its unhandled equivalent. We 357 can't just have the child check for an error when it does the 358 chdir, since it's in a vfork. 359 360 We have to GCPRO around this because Fexpand_file_name, 361 Funhandled_file_name_directory, and Ffile_accessible_directory_p 362 might call a file name handling function. The argument list is 363 protected by the caller, so all we really have to worry about is 364 buffer. */ 365 { 366 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4; 367 368 current_dir = current_buffer->directory; 369 370 GCPRO4 (infile, buffer, current_dir, error_file); 371 372 current_dir 373 = expand_and_dir_to_file (Funhandled_file_name_directory (current_dir), 374 Qnil); 375 if (NILP (Ffile_accessible_directory_p (current_dir))) 376 report_file_error ("Setting current directory", 377 Fcons (current_buffer->directory, Qnil)); 378 379 if (STRING_MULTIBYTE (infile)) 380 infile = ENCODE_FILE (infile); 381 if (STRING_MULTIBYTE (current_dir)) 382 current_dir = ENCODE_FILE (current_dir); 383 if (STRINGP (error_file) && STRING_MULTIBYTE (error_file)) 384 error_file = ENCODE_FILE (error_file); 385 UNGCPRO; 386 } 387 388 display_p = INTERACTIVE && nargs >= 4 && !NILP (args[3]); 389 390 filefd = emacs_open (SDATA (infile), O_RDONLY, 0); 391 if (filefd < 0) 392 { 393 infile = DECODE_FILE (infile); 394 report_file_error ("Opening process input file", Fcons (infile, Qnil)); 395 } 396 /* Search for program; barf if not found. */ 397 { 398 struct gcpro gcpro1; 399 400 GCPRO1 (current_dir); 401 openp (Vexec_path, args[0], Vexec_suffixes, &path, make_number (X_OK)); 402 UNGCPRO; 403 } 404 if (NILP (path)) 405 { 406 emacs_close (filefd); 407 report_file_error ("Searching for program", Fcons (args[0], Qnil)); 408 } 409 410 /* If program file name starts with /: for quoting a magic name, 411 discard that. */ 412 if (SBYTES (path) > 2 && SREF (path, 0) == '/' 413 && SREF (path, 1) == ':') 414 path = Fsubstring (path, make_number (2), Qnil); 415 416 new_argv[0] = SDATA (path); 417 if (nargs > 4) 418 { 419 register int i; 420 struct gcpro gcpro1, gcpro2, gcpro3; 421 422 GCPRO3 (infile, buffer, current_dir); 423 argument_coding.dst_multibyte = 0; 424 for (i = 4; i < nargs; i++) 425 { 426 argument_coding.src_multibyte = STRING_MULTIBYTE (args[i]); 427 if (CODING_REQUIRE_ENCODING (&argument_coding)) 428 { 429 /* We must encode this argument. */ 430 args[i] = encode_coding_string (args[i], &argument_coding, 1); 431 if (argument_coding.type == coding_type_ccl) 432 setup_ccl_program (&(argument_coding.spec.ccl.encoder), Qnil); 433 } 434 new_argv[i - 3] = SDATA (args[i]); 435 } 436 UNGCPRO; 437 new_argv[nargs - 3] = 0; 438 } 439 else 440 new_argv[1] = 0; 441 442#ifdef MSDOS /* MW, July 1993 */ 443 if ((outf = egetenv ("TMPDIR"))) 444 strcpy (tempfile = alloca (strlen (outf) + 20), outf); 445 else 446 { 447 tempfile = alloca (20); 448 *tempfile = '\0'; 449 } 450 dostounix_filename (tempfile); 451 if (*tempfile == '\0' || tempfile[strlen (tempfile) - 1] != '/') 452 strcat (tempfile, "/"); 453 strcat (tempfile, "detmp.XXX"); 454 mktemp (tempfile); 455 456 outfilefd = creat (tempfile, S_IREAD | S_IWRITE); 457 if (outfilefd < 0) 458 { 459 emacs_close (filefd); 460 report_file_error ("Opening process output file", 461 Fcons (build_string (tempfile), Qnil)); 462 } 463 fd[0] = filefd; 464 fd[1] = outfilefd; 465#endif /* MSDOS */ 466 467#ifdef MAC_OS8 468 /* Since we don't have pipes on the Mac, create a temporary file to 469 hold the output of the subprocess. */ 470 tempfile = (char *) alloca (SBYTES (Vtemp_file_name_pattern) + 1); 471 bcopy (SDATA (Vtemp_file_name_pattern), tempfile, 472 SBYTES (Vtemp_file_name_pattern) + 1); 473 474 mktemp (tempfile); 475 476 outfilefd = creat (tempfile, S_IREAD | S_IWRITE); 477 if (outfilefd < 0) 478 { 479 close (filefd); 480 report_file_error ("Opening process output file", 481 Fcons (build_string (tempfile), Qnil)); 482 } 483 fd[0] = filefd; 484 fd[1] = outfilefd; 485#endif /* MAC_OS8 */ 486 487 if (INTEGERP (buffer)) 488 fd[1] = emacs_open (NULL_DEVICE, O_WRONLY, 0), fd[0] = -1; 489 else 490 { 491#ifndef MSDOS 492#ifndef MAC_OS8 493 errno = 0; 494 if (pipe (fd) == -1) 495 { 496 emacs_close (filefd); 497 report_file_error ("Creating process pipe", Qnil); 498 } 499#endif 500#endif 501#if 0 502 /* Replaced by close_process_descs */ 503 set_exclusive_use (fd[0]); 504#endif 505 } 506 507 { 508 /* child_setup must clobber environ in systems with true vfork. 509 Protect it from permanent change. */ 510 register char **save_environ = environ; 511 register int fd1 = fd[1]; 512 int fd_error = fd1; 513 514#if 0 /* Some systems don't have sigblock. */ 515 mask = sigblock (sigmask (SIGCHLD)); 516#endif 517 518 /* Record that we're about to create a synchronous process. */ 519 synch_process_alive = 1; 520 521 /* These vars record information from process termination. 522 Clear them now before process can possibly terminate, 523 to avoid timing error if process terminates soon. */ 524 synch_process_death = 0; 525 synch_process_retcode = 0; 526 synch_process_termsig = 0; 527 528 if (NILP (error_file)) 529 fd_error = emacs_open (NULL_DEVICE, O_WRONLY, 0); 530 else if (STRINGP (error_file)) 531 { 532#ifdef DOS_NT 533 fd_error = emacs_open (SDATA (error_file), 534 O_WRONLY | O_TRUNC | O_CREAT | O_TEXT, 535 S_IREAD | S_IWRITE); 536#else /* not DOS_NT */ 537 fd_error = creat (SDATA (error_file), 0666); 538#endif /* not DOS_NT */ 539 } 540 541 if (fd_error < 0) 542 { 543 emacs_close (filefd); 544 if (fd[0] != filefd) 545 emacs_close (fd[0]); 546 if (fd1 >= 0) 547 emacs_close (fd1); 548#ifdef MSDOS 549 unlink (tempfile); 550#endif 551 if (NILP (error_file)) 552 error_file = build_string (NULL_DEVICE); 553 else if (STRINGP (error_file)) 554 error_file = DECODE_FILE (error_file); 555 report_file_error ("Cannot redirect stderr", Fcons (error_file, Qnil)); 556 } 557 558#ifdef MAC_OS8 559 { 560 /* Call run_mac_command in sysdep.c here directly instead of doing 561 a child_setup as for MSDOS and other platforms. Note that this 562 code does not handle passing the environment to the synchronous 563 Mac subprocess. */ 564 char *infn, *outfn, *errfn, *currdn; 565 566 /* close these files so subprocess can write to them */ 567 close (outfilefd); 568 if (fd_error != outfilefd) 569 close (fd_error); 570 fd1 = -1; /* No harm in closing that one! */ 571 572 infn = SDATA (infile); 573 outfn = tempfile; 574 if (NILP (error_file)) 575 errfn = NULL_DEVICE; 576 else if (EQ (Qt, error_file)) 577 errfn = outfn; 578 else 579 errfn = SDATA (error_file); 580 currdn = SDATA (current_dir); 581 pid = run_mac_command (new_argv, currdn, infn, outfn, errfn); 582 583 /* Record that the synchronous process exited and note its 584 termination status. */ 585 synch_process_alive = 0; 586 synch_process_retcode = pid; 587 if (synch_process_retcode < 0) /* means it couldn't be exec'ed */ 588 { 589 synchronize_system_messages_locale (); 590 synch_process_death = strerror (errno); 591 } 592 593 /* Since CRLF is converted to LF within `decode_coding', we can 594 always open a file with binary mode. */ 595 fd[0] = open (tempfile, O_BINARY); 596 if (fd[0] < 0) 597 { 598 unlink (tempfile); 599 close (filefd); 600 report_file_error ("Cannot re-open temporary file", Qnil); 601 } 602 } 603#else /* not MAC_OS8 */ 604#ifdef MSDOS /* MW, July 1993 */ 605 /* Note that on MSDOS `child_setup' actually returns the child process 606 exit status, not its PID, so we assign it to `synch_process_retcode' 607 below. */ 608 pid = child_setup (filefd, outfilefd, fd_error, (char **) new_argv, 609 0, current_dir); 610 611 /* Record that the synchronous process exited and note its 612 termination status. */ 613 synch_process_alive = 0; 614 synch_process_retcode = pid; 615 if (synch_process_retcode < 0) /* means it couldn't be exec'ed */ 616 { 617 synchronize_system_messages_locale (); 618 synch_process_death = strerror (errno); 619 } 620 621 emacs_close (outfilefd); 622 if (fd_error != outfilefd) 623 emacs_close (fd_error); 624 fd1 = -1; /* No harm in closing that one! */ 625 /* Since CRLF is converted to LF within `decode_coding', we can 626 always open a file with binary mode. */ 627 fd[0] = emacs_open (tempfile, O_RDONLY | O_BINARY, 0); 628 if (fd[0] < 0) 629 { 630 unlink (tempfile); 631 emacs_close (filefd); 632 report_file_error ("Cannot re-open temporary file", Qnil); 633 } 634#else /* not MSDOS */ 635#ifdef WINDOWSNT 636 pid = child_setup (filefd, fd1, fd_error, (char **) new_argv, 637 0, current_dir); 638#else /* not WINDOWSNT */ 639 BLOCK_INPUT; 640 641 pid = vfork (); 642 643 if (pid == 0) 644 { 645 if (fd[0] >= 0) 646 emacs_close (fd[0]); 647#ifdef HAVE_SETSID 648 setsid (); 649#endif 650#if defined (USG) && !defined (BSD_PGRPS) 651 setpgrp (); 652#else 653 setpgrp (pid, pid); 654#endif /* USG */ 655 child_setup (filefd, fd1, fd_error, (char **) new_argv, 656 0, current_dir); 657 } 658 659 UNBLOCK_INPUT; 660#endif /* not WINDOWSNT */ 661 662 /* The MSDOS case did this already. */ 663 if (fd_error >= 0) 664 emacs_close (fd_error); 665#endif /* not MSDOS */ 666#endif /* not MAC_OS8 */ 667 668 environ = save_environ; 669 670 /* Close most of our fd's, but not fd[0] 671 since we will use that to read input from. */ 672 emacs_close (filefd); 673 if (fd1 >= 0 && fd1 != fd_error) 674 emacs_close (fd1); 675 } 676 677 if (pid < 0) 678 { 679 if (fd[0] >= 0) 680 emacs_close (fd[0]); 681 report_file_error ("Doing vfork", Qnil); 682 } 683 684 if (INTEGERP (buffer)) 685 { 686 if (fd[0] >= 0) 687 emacs_close (fd[0]); 688#ifndef subprocesses 689 /* If Emacs has been built with asynchronous subprocess support, 690 we don't need to do this, I think because it will then have 691 the facilities for handling SIGCHLD. */ 692 wait_without_blocking (); 693#endif /* subprocesses */ 694 return Qnil; 695 } 696 697 /* Enable sending signal if user quits below. */ 698 call_process_exited = 0; 699 700#if defined(MSDOS) || defined(MAC_OS8) 701 /* MSDOS needs different cleanup information. */ 702 record_unwind_protect (call_process_cleanup, 703 Fcons (make_number (fd[0]), build_string (tempfile))); 704#else 705 record_unwind_protect (call_process_cleanup, 706 Fcons (make_number (fd[0]), make_number (pid))); 707#endif /* not MSDOS and not MAC_OS8 */ 708 709 710 if (BUFFERP (buffer)) 711 Fset_buffer (buffer); 712 713 if (NILP (buffer)) 714 { 715 /* If BUFFER is nil, we must read process output once and then 716 discard it, so setup coding system but with nil. */ 717 setup_coding_system (Qnil, &process_coding); 718 } 719 else 720 { 721 Lisp_Object val, *args2; 722 723 val = Qnil; 724 if (!NILP (Vcoding_system_for_read)) 725 val = Vcoding_system_for_read; 726 else 727 { 728 if (EQ (coding_systems, Qt)) 729 { 730 int i; 731 732 args2 = (Lisp_Object *) alloca ((nargs + 1) * sizeof *args2); 733 args2[0] = Qcall_process; 734 for (i = 0; i < nargs; i++) args2[i + 1] = args[i]; 735 coding_systems 736 = Ffind_operation_coding_system (nargs + 1, args2); 737 } 738 if (CONSP (coding_systems)) 739 val = XCAR (coding_systems); 740 else if (CONSP (Vdefault_process_coding_system)) 741 val = XCAR (Vdefault_process_coding_system); 742 else 743 val = Qnil; 744 } 745 setup_coding_system (Fcheck_coding_system (val), &process_coding); 746 /* In unibyte mode, character code conversion should not take 747 place but EOL conversion should. So, setup raw-text or one 748 of the subsidiary according to the information just setup. */ 749 if (NILP (current_buffer->enable_multibyte_characters) 750 && !NILP (val)) 751 setup_raw_text_coding_system (&process_coding); 752 } 753 process_coding.src_multibyte = 0; 754 process_coding.dst_multibyte 755 = (BUFFERP (buffer) 756 ? ! NILP (XBUFFER (buffer)->enable_multibyte_characters) 757 : ! NILP (current_buffer->enable_multibyte_characters)); 758 759 immediate_quit = 1; 760 QUIT; 761 762 { 763 register int nread; 764 int first = 1; 765 int total_read = 0; 766 int carryover = 0; 767 int display_on_the_fly = display_p; 768 struct coding_system saved_coding; 769 int pt_orig = PT, pt_byte_orig = PT_BYTE; 770 int inserted; 771 772 saved_coding = process_coding; 773 if (process_coding.composing != COMPOSITION_DISABLED) 774 coding_allocate_composition_data (&process_coding, PT); 775 while (1) 776 { 777 /* Repeatedly read until we've filled as much as possible 778 of the buffer size we have. But don't read 779 less than 1024--save that for the next bufferful. */ 780 nread = carryover; 781 while (nread < bufsize - 1024) 782 { 783 int this_read = emacs_read (fd[0], buf + nread, 784 bufsize - nread); 785 786 if (this_read < 0) 787 goto give_up; 788 789 if (this_read == 0) 790 { 791 process_coding.mode |= CODING_MODE_LAST_BLOCK; 792 break; 793 } 794 795 nread += this_read; 796 total_read += this_read; 797 798 if (display_on_the_fly) 799 break; 800 } 801 802 /* Now NREAD is the total amount of data in the buffer. */ 803 immediate_quit = 0; 804 805 if (!NILP (buffer)) 806 { 807 if (! CODING_MAY_REQUIRE_DECODING (&process_coding)) 808 insert_1_both (buf, nread, nread, 0, 1, 0); 809 else 810 { /* We have to decode the input. */ 811 int size; 812 char *decoding_buf; 813 814 repeat_decoding: 815 size = decoding_buffer_size (&process_coding, nread); 816 decoding_buf = (char *) xmalloc (size); 817 818 /* We can't use the macro CODING_REQUIRE_DETECTION 819 because it always returns nonzero if the coding 820 system requires EOL detection. Here, we have to 821 check only whether or not the coding system 822 requires text-encoding detection. */ 823 if (process_coding.type == coding_type_undecided) 824 { 825 detect_coding (&process_coding, buf, nread); 826 if (process_coding.composing != COMPOSITION_DISABLED) 827 /* We have not yet allocated the composition 828 data because the coding type was undecided. */ 829 coding_allocate_composition_data (&process_coding, PT); 830 } 831 if (process_coding.cmp_data) 832 process_coding.cmp_data->char_offset = PT; 833 834 decode_coding (&process_coding, buf, decoding_buf, 835 nread, size); 836 837 if (display_on_the_fly 838 && saved_coding.type == coding_type_undecided 839 && process_coding.type != coding_type_undecided) 840 { 841 /* We have detected some coding system. But, 842 there's a possibility that the detection was 843 done by insufficient data. So, we try the code 844 detection again with more data. */ 845 xfree (decoding_buf); 846 display_on_the_fly = 0; 847 process_coding = saved_coding; 848 carryover = nread; 849 /* This is to make the above condition always 850 fails in the future. */ 851 saved_coding.type = coding_type_no_conversion; 852 continue; 853 } 854 855 if (process_coding.produced > 0) 856 insert_1_both (decoding_buf, process_coding.produced_char, 857 process_coding.produced, 0, 1, 0); 858 xfree (decoding_buf); 859 860 if (process_coding.result == CODING_FINISH_INCONSISTENT_EOL) 861 { 862 Lisp_Object eol_type, coding; 863 864 if (process_coding.eol_type == CODING_EOL_CR) 865 { 866 /* CRs have been replaced with LFs. Undo 867 that in the text inserted above. */ 868 unsigned char *p; 869 870 move_gap_both (PT, PT_BYTE); 871 872 p = BYTE_POS_ADDR (pt_byte_orig); 873 for (; p < GPT_ADDR; ++p) 874 if (*p == '\n') 875 *p = '\r'; 876 } 877 else if (process_coding.eol_type == CODING_EOL_CRLF) 878 { 879 /* CR LFs have been replaced with LFs. Undo 880 that by inserting CRs in front of LFs in 881 the text inserted above. */ 882 EMACS_INT bytepos, old_pt, old_pt_byte, nCR; 883 884 old_pt = PT; 885 old_pt_byte = PT_BYTE; 886 nCR = 0; 887 888 for (bytepos = PT_BYTE - 1; 889 bytepos >= pt_byte_orig; 890 --bytepos) 891 if (FETCH_BYTE (bytepos) == '\n') 892 { 893 EMACS_INT charpos = BYTE_TO_CHAR (bytepos); 894 TEMP_SET_PT_BOTH (charpos, bytepos); 895 insert_1_both ("\r", 1, 1, 0, 1, 0); 896 ++nCR; 897 } 898 899 TEMP_SET_PT_BOTH (old_pt + nCR, old_pt_byte + nCR); 900 } 901 902 /* Set the coding system symbol to that for 903 Unix-like EOL. */ 904 eol_type = Fget (saved_coding.symbol, Qeol_type); 905 if (VECTORP (eol_type) 906 && ASIZE (eol_type) == 3 907 && SYMBOLP (AREF (eol_type, CODING_EOL_LF))) 908 coding = AREF (eol_type, CODING_EOL_LF); 909 else 910 coding = saved_coding.symbol; 911 912 process_coding.symbol = coding; 913 process_coding.eol_type = CODING_EOL_LF; 914 process_coding.mode 915 &= ~CODING_MODE_INHIBIT_INCONSISTENT_EOL; 916 } 917 918 nread -= process_coding.consumed; 919 carryover = nread; 920 if (carryover > 0) 921 /* As CARRYOVER should not be that large, we had 922 better avoid overhead of bcopy. */ 923 BCOPY_SHORT (buf + process_coding.consumed, buf, 924 carryover); 925 if (process_coding.result == CODING_FINISH_INSUFFICIENT_CMP) 926 { 927 /* The decoding ended because of insufficient data 928 area to record information about composition. 929 We must try decoding with additional data area 930 before reading more output for the process. */ 931 coding_allocate_composition_data (&process_coding, PT); 932 goto repeat_decoding; 933 } 934 } 935 } 936 937 if (process_coding.mode & CODING_MODE_LAST_BLOCK) 938 break; 939 940#if (CALLPROC_BUFFER_SIZE_MIN != CALLPROC_BUFFER_SIZE_MAX) 941 /* Make the buffer bigger as we continue to read more data, 942 but not past CALLPROC_BUFFER_SIZE_MAX. */ 943 if (bufsize < CALLPROC_BUFFER_SIZE_MAX && total_read > 32 * bufsize) 944 if ((bufsize *= 2) > CALLPROC_BUFFER_SIZE_MAX) 945 bufsize = CALLPROC_BUFFER_SIZE_MAX; 946#endif 947 948 if (display_p) 949 { 950 if (first) 951 prepare_menu_bars (); 952 first = 0; 953 redisplay_preserve_echo_area (1); 954 /* This variable might have been set to 0 for code 955 detection. In that case, we set it back to 1 because 956 we should have already detected a coding system. */ 957 display_on_the_fly = 1; 958 } 959 immediate_quit = 1; 960 QUIT; 961 } 962 give_up: ; 963 964 if (!NILP (buffer) 965 && process_coding.cmp_data) 966 { 967 coding_restore_composition (&process_coding, Fcurrent_buffer ()); 968 coding_free_composition_data (&process_coding); 969 } 970 971 { 972 int post_read_count = SPECPDL_INDEX (); 973 974 record_unwind_protect (save_excursion_restore, save_excursion_save ()); 975 inserted = PT - pt_orig; 976 TEMP_SET_PT_BOTH (pt_orig, pt_byte_orig); 977 if (SYMBOLP (process_coding.post_read_conversion) 978 && !NILP (Ffboundp (process_coding.post_read_conversion))) 979 call1 (process_coding.post_read_conversion, make_number (inserted)); 980 981 Vlast_coding_system_used = process_coding.symbol; 982 983 /* If the caller required, let the buffer inherit the 984 coding-system used to decode the process output. */ 985 if (inherit_process_coding_system) 986 call1 (intern ("after-insert-file-set-buffer-file-coding-system"), 987 make_number (total_read)); 988 989 unbind_to (post_read_count, Qnil); 990 } 991 } 992 993 /* Wait for it to terminate, unless it already has. */ 994 wait_for_termination (pid); 995 996 immediate_quit = 0; 997 998 set_buffer_internal (old); 999 1000 /* Don't kill any children that the subprocess may have left behind 1001 when exiting. */ 1002 call_process_exited = 1; 1003 1004 unbind_to (count, Qnil); 1005 1006 if (synch_process_termsig) 1007 { 1008 char *signame; 1009 1010 synchronize_system_messages_locale (); 1011 signame = strsignal (synch_process_termsig); 1012 1013 if (signame == 0) 1014 signame = "unknown"; 1015 1016 synch_process_death = signame; 1017 } 1018 1019 if (synch_process_death) 1020 return code_convert_string_norecord (build_string (synch_process_death), 1021 Vlocale_coding_system, 0); 1022 return make_number (synch_process_retcode); 1023} 1024#endif 1025 1026static Lisp_Object 1027delete_temp_file (name) 1028 Lisp_Object name; 1029{ 1030 /* Suppress jka-compr handling, etc. */ 1031 int count = SPECPDL_INDEX (); 1032 specbind (intern ("file-name-handler-alist"), Qnil); 1033 internal_delete_file (name); 1034 unbind_to (count, Qnil); 1035 return Qnil; 1036} 1037 1038DEFUN ("call-process-region", Fcall_process_region, Scall_process_region, 1039 3, MANY, 0, 1040 doc: /* Send text from START to END to a synchronous process running PROGRAM. 1041The remaining arguments are optional. 1042Delete the text if fourth arg DELETE is non-nil. 1043 1044Insert output in BUFFER before point; t means current buffer; 1045 nil for BUFFER means discard it; 0 means discard and don't wait. 1046BUFFER can also have the form (REAL-BUFFER STDERR-FILE); in that case, 1047REAL-BUFFER says what to do with standard output, as above, 1048while STDERR-FILE says what to do with standard error in the child. 1049STDERR-FILE may be nil (discard standard error output), 1050t (mix it with ordinary output), or a file name string. 1051 1052Sixth arg DISPLAY non-nil means redisplay buffer as output is inserted. 1053Remaining args are passed to PROGRAM at startup as command args. 1054 1055If BUFFER is 0, `call-process-region' returns immediately with value nil. 1056Otherwise it waits for PROGRAM to terminate 1057and returns a numeric exit status or a signal description string. 1058If you quit, the process is killed with SIGINT, or SIGKILL if you quit again. 1059 1060usage: (call-process-region START END PROGRAM &optional DELETE BUFFER DISPLAY &rest ARGS) */) 1061 (nargs, args) 1062 int nargs; 1063 register Lisp_Object *args; 1064{ 1065 struct gcpro gcpro1; 1066 Lisp_Object filename_string; 1067 register Lisp_Object start, end; 1068 int count = SPECPDL_INDEX (); 1069 /* Qt denotes we have not yet called Ffind_operation_coding_system. */ 1070 Lisp_Object coding_systems; 1071 Lisp_Object val, *args2; 1072 int i; 1073#ifdef DOS_NT 1074 char *tempfile; 1075 char *outf = '\0'; 1076 1077 if ((outf = egetenv ("TMPDIR")) 1078 || (outf = egetenv ("TMP")) 1079 || (outf = egetenv ("TEMP"))) 1080 strcpy (tempfile = alloca (strlen (outf) + 20), outf); 1081 else 1082 { 1083 tempfile = alloca (20); 1084 *tempfile = '\0'; 1085 } 1086 if (!IS_DIRECTORY_SEP (tempfile[strlen (tempfile) - 1])) 1087 strcat (tempfile, "/"); 1088 if ('/' == DIRECTORY_SEP) 1089 dostounix_filename (tempfile); 1090 else 1091 unixtodos_filename (tempfile); 1092#ifdef WINDOWSNT 1093 strcat (tempfile, "emXXXXXX"); 1094#else 1095 strcat (tempfile, "detmp.XXX"); 1096#endif 1097#else /* not DOS_NT */ 1098 char *tempfile = (char *) alloca (SBYTES (Vtemp_file_name_pattern) + 1); 1099 bcopy (SDATA (Vtemp_file_name_pattern), tempfile, 1100 SBYTES (Vtemp_file_name_pattern) + 1); 1101#endif /* not DOS_NT */ 1102 1103 coding_systems = Qt; 1104 1105#ifdef HAVE_MKSTEMP 1106 { 1107 int fd; 1108 1109 BLOCK_INPUT; 1110 fd = mkstemp (tempfile); 1111 UNBLOCK_INPUT; 1112 if (fd == -1) 1113 report_file_error ("Failed to open temporary file", 1114 Fcons (Vtemp_file_name_pattern, Qnil)); 1115 else 1116 close (fd); 1117 } 1118#else 1119 mktemp (tempfile); 1120#endif 1121 1122 filename_string = build_string (tempfile); 1123 GCPRO1 (filename_string); 1124 start = args[0]; 1125 end = args[1]; 1126 /* Decide coding-system of the contents of the temporary file. */ 1127 if (!NILP (Vcoding_system_for_write)) 1128 val = Vcoding_system_for_write; 1129 else if (NILP (current_buffer->enable_multibyte_characters)) 1130 val = Qnil; 1131 else 1132 { 1133 args2 = (Lisp_Object *) alloca ((nargs + 1) * sizeof *args2); 1134 args2[0] = Qcall_process_region; 1135 for (i = 0; i < nargs; i++) args2[i + 1] = args[i]; 1136 coding_systems = Ffind_operation_coding_system (nargs + 1, args2); 1137 if (CONSP (coding_systems)) 1138 val = XCDR (coding_systems); 1139 else if (CONSP (Vdefault_process_coding_system)) 1140 val = XCDR (Vdefault_process_coding_system); 1141 else 1142 val = Qnil; 1143 } 1144 1145 { 1146 int count1 = SPECPDL_INDEX (); 1147 1148 specbind (intern ("coding-system-for-write"), val); 1149 /* POSIX lets mk[s]temp use "."; don't invoke jka-compr if we 1150 happen to get a ".Z" suffix. */ 1151 specbind (intern ("file-name-handler-alist"), Qnil); 1152 Fwrite_region (start, end, filename_string, Qnil, Qlambda, Qnil, Qnil); 1153 1154 unbind_to (count1, Qnil); 1155 } 1156 1157 /* Note that Fcall_process takes care of binding 1158 coding-system-for-read. */ 1159 1160 record_unwind_protect (delete_temp_file, filename_string); 1161 1162 if (nargs > 3 && !NILP (args[3])) 1163 Fdelete_region (start, end); 1164 1165 if (nargs > 3) 1166 { 1167 args += 2; 1168 nargs -= 2; 1169 } 1170 else 1171 { 1172 args[0] = args[2]; 1173 nargs = 2; 1174 } 1175 args[1] = filename_string; 1176 1177 RETURN_UNGCPRO (unbind_to (count, Fcall_process (nargs, args))); 1178} 1179 1180#ifndef VMS /* VMS version is in vmsproc.c. */ 1181 1182static int relocate_fd (); 1183 1184/* This is the last thing run in a newly forked inferior 1185 either synchronous or asynchronous. 1186 Copy descriptors IN, OUT and ERR as descriptors 0, 1 and 2. 1187 Initialize inferior's priority, pgrp, connected dir and environment. 1188 then exec another program based on new_argv. 1189 1190 This function may change environ for the superior process. 1191 Therefore, the superior process must save and restore the value 1192 of environ around the vfork and the call to this function. 1193 1194 SET_PGRP is nonzero if we should put the subprocess into a separate 1195 process group. 1196 1197 CURRENT_DIR is an elisp string giving the path of the current 1198 directory the subprocess should have. Since we can't really signal 1199 a decent error from within the child, this should be verified as an 1200 executable directory by the parent. */ 1201 1202int 1203child_setup (in, out, err, new_argv, set_pgrp, current_dir) 1204 int in, out, err; 1205 register char **new_argv; 1206 int set_pgrp; 1207 Lisp_Object current_dir; 1208{ 1209 char **env; 1210 char *pwd_var; 1211#ifdef WINDOWSNT 1212 int cpid; 1213 HANDLE handles[3]; 1214#endif /* WINDOWSNT */ 1215 1216 int pid = getpid (); 1217 1218#ifdef SET_EMACS_PRIORITY 1219 { 1220 extern EMACS_INT emacs_priority; 1221 1222 if (emacs_priority < 0) 1223 nice (- emacs_priority); 1224 } 1225#endif 1226 1227#ifdef subprocesses 1228 /* Close Emacs's descriptors that this process should not have. */ 1229 close_process_descs (); 1230#endif 1231 /* DOS_NT isn't in a vfork, so if we are in the middle of load-file, 1232 we will lose if we call close_load_descs here. */ 1233#ifndef DOS_NT 1234 close_load_descs (); 1235#endif 1236 1237 /* Note that use of alloca is always safe here. It's obvious for systems 1238 that do not have true vfork or that have true (stack) alloca. 1239 If using vfork and C_ALLOCA it is safe because that changes 1240 the superior's static variables as if the superior had done alloca 1241 and will be cleaned up in the usual way. */ 1242 { 1243 register char *temp; 1244 register int i; 1245 1246 i = SBYTES (current_dir); 1247#ifdef MSDOS 1248 /* MSDOS must have all environment variables malloc'ed, because 1249 low-level libc functions that launch subsidiary processes rely 1250 on that. */ 1251 pwd_var = (char *) xmalloc (i + 6); 1252#else 1253 pwd_var = (char *) alloca (i + 6); 1254#endif 1255 temp = pwd_var + 4; 1256 bcopy ("PWD=", pwd_var, 4); 1257 bcopy (SDATA (current_dir), temp, i); 1258 if (!IS_DIRECTORY_SEP (temp[i - 1])) temp[i++] = DIRECTORY_SEP; 1259 temp[i] = 0; 1260 1261#ifndef DOS_NT 1262 /* We can't signal an Elisp error here; we're in a vfork. Since 1263 the callers check the current directory before forking, this 1264 should only return an error if the directory's permissions 1265 are changed between the check and this chdir, but we should 1266 at least check. */ 1267 if (chdir (temp) < 0) 1268 _exit (errno); 1269#endif 1270 1271#ifdef DOS_NT 1272 /* Get past the drive letter, so that d:/ is left alone. */ 1273 if (i > 2 && IS_DEVICE_SEP (temp[1]) && IS_DIRECTORY_SEP (temp[2])) 1274 { 1275 temp += 2; 1276 i -= 2; 1277 } 1278#endif 1279 1280 /* Strip trailing slashes for PWD, but leave "/" and "//" alone. */ 1281 while (i > 2 && IS_DIRECTORY_SEP (temp[i - 1])) 1282 temp[--i] = 0; 1283 } 1284 1285 /* Set `env' to a vector of the strings in Vprocess_environment. */ 1286 { 1287 register Lisp_Object tem; 1288 register char **new_env; 1289 register int new_length; 1290 1291 new_length = 0; 1292 for (tem = Vprocess_environment; 1293 CONSP (tem) && STRINGP (XCAR (tem)); 1294 tem = XCDR (tem)) 1295 new_length++; 1296 1297 /* new_length + 2 to include PWD and terminating 0. */ 1298 env = new_env = (char **) alloca ((new_length + 2) * sizeof (char *)); 1299 1300 /* If we have a PWD envvar, pass one down, 1301 but with corrected value. */ 1302 if (getenv ("PWD")) 1303 *new_env++ = pwd_var; 1304 1305 /* Copy the Vprocess_environment strings into new_env. */ 1306 for (tem = Vprocess_environment; 1307 CONSP (tem) && STRINGP (XCAR (tem)); 1308 tem = XCDR (tem)) 1309 { 1310 char **ep = env; 1311 char *string = (char *) SDATA (XCAR (tem)); 1312 /* See if this string duplicates any string already in the env. 1313 If so, don't put it in. 1314 When an env var has multiple definitions, 1315 we keep the definition that comes first in process-environment. */ 1316 for (; ep != new_env; ep++) 1317 { 1318 char *p = *ep, *q = string; 1319 while (1) 1320 { 1321 if (*q == 0) 1322 /* The string is malformed; might as well drop it. */ 1323 goto duplicate; 1324 if (*q != *p) 1325 break; 1326 if (*q == '=') 1327 goto duplicate; 1328 p++, q++; 1329 } 1330 } 1331 *new_env++ = string; 1332 duplicate: ; 1333 } 1334 *new_env = 0; 1335 } 1336#ifdef WINDOWSNT 1337 prepare_standard_handles (in, out, err, handles); 1338 set_process_dir (SDATA (current_dir)); 1339#else /* not WINDOWSNT */ 1340 /* Make sure that in, out, and err are not actually already in 1341 descriptors zero, one, or two; this could happen if Emacs is 1342 started with its standard in, out, or error closed, as might 1343 happen under X. */ 1344 { 1345 int oin = in, oout = out; 1346 1347 /* We have to avoid relocating the same descriptor twice! */ 1348 1349 in = relocate_fd (in, 3); 1350 1351 if (out == oin) 1352 out = in; 1353 else 1354 out = relocate_fd (out, 3); 1355 1356 if (err == oin) 1357 err = in; 1358 else if (err == oout) 1359 err = out; 1360 else 1361 err = relocate_fd (err, 3); 1362 } 1363 1364#ifndef MSDOS 1365 emacs_close (0); 1366 emacs_close (1); 1367 emacs_close (2); 1368 1369 dup2 (in, 0); 1370 dup2 (out, 1); 1371 dup2 (err, 2); 1372 emacs_close (in); 1373 emacs_close (out); 1374 emacs_close (err); 1375#endif /* not MSDOS */ 1376#endif /* not WINDOWSNT */ 1377 1378#if defined(USG) && !defined(BSD_PGRPS) 1379#ifndef SETPGRP_RELEASES_CTTY 1380 setpgrp (); /* No arguments but equivalent in this case */ 1381#endif 1382#else 1383 setpgrp (pid, pid); 1384#endif /* USG */ 1385 /* setpgrp_of_tty is incorrect here; it uses input_fd. */ 1386 EMACS_SET_TTY_PGRP (0, &pid); 1387 1388#ifdef MSDOS 1389 pid = run_msdos_command (new_argv, pwd_var + 4, in, out, err, env); 1390 xfree (pwd_var); 1391 if (pid == -1) 1392 /* An error occurred while trying to run the subprocess. */ 1393 report_file_error ("Spawning child process", Qnil); 1394 return pid; 1395#else /* not MSDOS */ 1396#ifdef WINDOWSNT 1397 /* Spawn the child. (See ntproc.c:Spawnve). */ 1398 cpid = spawnve (_P_NOWAIT, new_argv[0], new_argv, env); 1399 reset_standard_handles (in, out, err, handles); 1400 if (cpid == -1) 1401 /* An error occurred while trying to spawn the process. */ 1402 report_file_error ("Spawning child process", Qnil); 1403 return cpid; 1404#else /* not WINDOWSNT */ 1405 /* execvp does not accept an environment arg so the only way 1406 to pass this environment is to set environ. Our caller 1407 is responsible for restoring the ambient value of environ. */ 1408 environ = env; 1409 execvp (new_argv[0], new_argv); 1410 1411 emacs_write (1, "Can't exec program: ", 20); 1412 emacs_write (1, new_argv[0], strlen (new_argv[0])); 1413 emacs_write (1, "\n", 1); 1414 _exit (1); 1415#endif /* not WINDOWSNT */ 1416#endif /* not MSDOS */ 1417} 1418 1419/* Move the file descriptor FD so that its number is not less than MINFD. 1420 If the file descriptor is moved at all, the original is freed. */ 1421static int 1422relocate_fd (fd, minfd) 1423 int fd, minfd; 1424{ 1425 if (fd >= minfd) 1426 return fd; 1427 else 1428 { 1429 int new = dup (fd); 1430 if (new == -1) 1431 { 1432 char *message1 = "Error while setting up child: "; 1433 char *errmessage = strerror (errno); 1434 char *message2 = "\n"; 1435 emacs_write (2, message1, strlen (message1)); 1436 emacs_write (2, errmessage, strlen (errmessage)); 1437 emacs_write (2, message2, strlen (message2)); 1438 _exit (1); 1439 } 1440 /* Note that we hold the original FD open while we recurse, 1441 to guarantee we'll get a new FD if we need it. */ 1442 new = relocate_fd (new, minfd); 1443 emacs_close (fd); 1444 return new; 1445 } 1446} 1447 1448static int 1449getenv_internal (var, varlen, value, valuelen) 1450 char *var; 1451 int varlen; 1452 char **value; 1453 int *valuelen; 1454{ 1455 Lisp_Object scan; 1456 1457 for (scan = Vprocess_environment; CONSP (scan); scan = XCDR (scan)) 1458 { 1459 Lisp_Object entry; 1460 1461 entry = XCAR (scan); 1462 if (STRINGP (entry) 1463 && SBYTES (entry) > varlen 1464 && SREF (entry, varlen) == '=' 1465#ifdef WINDOWSNT 1466 /* NT environment variables are case insensitive. */ 1467 && ! strnicmp (SDATA (entry), var, varlen) 1468#else /* not WINDOWSNT */ 1469 && ! bcmp (SDATA (entry), var, varlen) 1470#endif /* not WINDOWSNT */ 1471 ) 1472 { 1473 *value = (char *) SDATA (entry) + (varlen + 1); 1474 *valuelen = SBYTES (entry) - (varlen + 1); 1475 return 1; 1476 } 1477 } 1478 1479 return 0; 1480} 1481 1482DEFUN ("getenv-internal", Fgetenv_internal, Sgetenv_internal, 1, 1, 0, 1483 doc: /* Return the value of environment variable VAR, as a string. 1484VAR should be a string. Value is nil if VAR is undefined in the environment. 1485This function consults the variable `process-environment' for its value. */) 1486 (var) 1487 Lisp_Object var; 1488{ 1489 char *value; 1490 int valuelen; 1491 1492 CHECK_STRING (var); 1493 if (getenv_internal (SDATA (var), SBYTES (var), 1494 &value, &valuelen)) 1495 return make_string (value, valuelen); 1496 else 1497 return Qnil; 1498} 1499 1500/* A version of getenv that consults process_environment, easily 1501 callable from C. */ 1502char * 1503egetenv (var) 1504 char *var; 1505{ 1506 char *value; 1507 int valuelen; 1508 1509 if (getenv_internal (var, strlen (var), &value, &valuelen)) 1510 return value; 1511 else 1512 return 0; 1513} 1514 1515#endif /* not VMS */ 1516 1517/* This is run before init_cmdargs. */ 1518 1519void 1520init_callproc_1 () 1521{ 1522 char *data_dir = egetenv ("EMACSDATA"); 1523 char *doc_dir = egetenv ("EMACSDOC"); 1524 1525 Vdata_directory 1526 = Ffile_name_as_directory (build_string (data_dir ? data_dir 1527 : PATH_DATA)); 1528 Vdoc_directory 1529 = Ffile_name_as_directory (build_string (doc_dir ? doc_dir 1530 : PATH_DOC)); 1531 1532 /* Check the EMACSPATH environment variable, defaulting to the 1533 PATH_EXEC path from epaths.h. */ 1534 Vexec_path = decode_env_path ("EMACSPATH", PATH_EXEC); 1535 Vexec_directory = Ffile_name_as_directory (Fcar (Vexec_path)); 1536 Vexec_path = nconc2 (decode_env_path ("PATH", ""), Vexec_path); 1537} 1538 1539/* This is run after init_cmdargs, when Vinstallation_directory is valid. */ 1540 1541void 1542init_callproc () 1543{ 1544 char *data_dir = egetenv ("EMACSDATA"); 1545 1546 register char * sh; 1547 Lisp_Object tempdir; 1548 1549 if (!NILP (Vinstallation_directory)) 1550 { 1551 /* Add to the path the lib-src subdir of the installation dir. */ 1552 Lisp_Object tem; 1553 tem = Fexpand_file_name (build_string ("lib-src"), 1554 Vinstallation_directory); 1555#ifndef DOS_NT 1556 /* MSDOS uses wrapped binaries, so don't do this. */ 1557 if (NILP (Fmember (tem, Vexec_path))) 1558 { 1559 Vexec_path = decode_env_path ("EMACSPATH", PATH_EXEC); 1560 Vexec_path = Fcons (tem, Vexec_path); 1561 Vexec_path = nconc2 (decode_env_path ("PATH", ""), Vexec_path); 1562 } 1563 1564 Vexec_directory = Ffile_name_as_directory (tem); 1565#endif /* not DOS_NT */ 1566 1567 /* Maybe use ../etc as well as ../lib-src. */ 1568 if (data_dir == 0) 1569 { 1570 tem = Fexpand_file_name (build_string ("etc"), 1571 Vinstallation_directory); 1572 Vdoc_directory = Ffile_name_as_directory (tem); 1573 } 1574 } 1575 1576 /* Look for the files that should be in etc. We don't use 1577 Vinstallation_directory, because these files are never installed 1578 near the executable, and they are never in the build 1579 directory when that's different from the source directory. 1580 1581 Instead, if these files are not in the nominal place, we try the 1582 source directory. */ 1583 if (data_dir == 0) 1584 { 1585 Lisp_Object tem, tem1, srcdir; 1586 1587 srcdir = Fexpand_file_name (build_string ("../src/"), 1588 build_string (PATH_DUMPLOADSEARCH)); 1589 tem = Fexpand_file_name (build_string ("GNU"), Vdata_directory); 1590 tem1 = Ffile_exists_p (tem); 1591 if (!NILP (Fequal (srcdir, Vinvocation_directory)) || NILP (tem1)) 1592 { 1593 Lisp_Object newdir; 1594 newdir = Fexpand_file_name (build_string ("../etc/"), 1595 build_string (PATH_DUMPLOADSEARCH)); 1596 tem = Fexpand_file_name (build_string ("GNU"), newdir); 1597 tem1 = Ffile_exists_p (tem); 1598 if (!NILP (tem1)) 1599 Vdata_directory = newdir; 1600 } 1601 } 1602 1603#ifndef CANNOT_DUMP 1604 if (initialized) 1605#endif 1606 { 1607 tempdir = Fdirectory_file_name (Vexec_directory); 1608 if (access (SDATA (tempdir), 0) < 0) 1609 dir_warning ("Warning: arch-dependent data dir (%s) does not exist.\n", 1610 Vexec_directory); 1611 } 1612 1613 tempdir = Fdirectory_file_name (Vdata_directory); 1614 if (access (SDATA (tempdir), 0) < 0) 1615 dir_warning ("Warning: arch-independent data dir (%s) does not exist.\n", 1616 Vdata_directory); 1617 1618#ifdef VMS 1619 Vshell_file_name = build_string ("*dcl*"); 1620#else 1621 sh = (char *) getenv ("SHELL"); 1622 Vshell_file_name = build_string (sh ? sh : "/bin/sh"); 1623#endif 1624 1625#ifdef VMS 1626 Vtemp_file_name_pattern = build_string ("tmp:emacsXXXXXX."); 1627#else 1628 if (getenv ("TMPDIR")) 1629 { 1630 char *dir = getenv ("TMPDIR"); 1631 Vtemp_file_name_pattern 1632 = Fexpand_file_name (build_string ("emacsXXXXXX"), 1633 build_string (dir)); 1634 } 1635 else 1636 Vtemp_file_name_pattern = build_string ("/tmp/emacsXXXXXX"); 1637#endif 1638 1639#ifdef DOS_NT 1640 Vshared_game_score_directory = Qnil; 1641#else 1642 Vshared_game_score_directory = build_string (PATH_GAME); 1643 if (NILP (Ffile_directory_p (Vshared_game_score_directory))) 1644 Vshared_game_score_directory = Qnil; 1645#endif 1646} 1647 1648void 1649set_process_environment () 1650{ 1651 register char **envp; 1652 1653 Vprocess_environment = Qnil; 1654#ifndef CANNOT_DUMP 1655 if (initialized) 1656#endif 1657 for (envp = environ; *envp; envp++) 1658 Vprocess_environment = Fcons (build_string (*envp), 1659 Vprocess_environment); 1660} 1661 1662void 1663syms_of_callproc () 1664{ 1665#ifdef DOS_NT 1666 Qbuffer_file_type = intern ("buffer-file-type"); 1667 staticpro (&Qbuffer_file_type); 1668#endif /* DOS_NT */ 1669 1670 DEFVAR_LISP ("shell-file-name", &Vshell_file_name, 1671 doc: /* *File name to load inferior shells from. 1672Initialized from the SHELL environment variable, or to a system-dependent 1673default if SHELL is not set. */); 1674 1675 DEFVAR_LISP ("exec-path", &Vexec_path, 1676 doc: /* *List of directories to search programs to run in subprocesses. 1677Each element is a string (directory name) or nil (try default directory). */); 1678 1679 DEFVAR_LISP ("exec-suffixes", &Vexec_suffixes, 1680 doc: /* *List of suffixes to try to find executable file names. 1681Each element is a string. */); 1682 Vexec_suffixes = Qnil; 1683 1684 DEFVAR_LISP ("exec-directory", &Vexec_directory, 1685 doc: /* Directory for executables for Emacs to invoke. 1686More generally, this includes any architecture-dependent files 1687that are built and installed from the Emacs distribution. */); 1688 1689 DEFVAR_LISP ("data-directory", &Vdata_directory, 1690 doc: /* Directory of machine-independent files that come with GNU Emacs. 1691These are files intended for Emacs to use while it runs. */); 1692 1693 DEFVAR_LISP ("doc-directory", &Vdoc_directory, 1694 doc: /* Directory containing the DOC file that comes with GNU Emacs. 1695This is usually the same as `data-directory'. */); 1696 1697 DEFVAR_LISP ("configure-info-directory", &Vconfigure_info_directory, 1698 doc: /* For internal use by the build procedure only. 1699This is the name of the directory in which the build procedure installed 1700Emacs's info files; the default value for `Info-default-directory-list' 1701includes this. */); 1702 Vconfigure_info_directory = build_string (PATH_INFO); 1703 1704 DEFVAR_LISP ("shared-game-score-directory", &Vshared_game_score_directory, 1705 doc: /* Directory of score files for games which come with GNU Emacs. 1706If this variable is nil, then Emacs is unable to use a shared directory. */); 1707#ifdef DOS_NT 1708 Vshared_game_score_directory = Qnil; 1709#else 1710 Vshared_game_score_directory = build_string (PATH_GAME); 1711#endif 1712 1713 DEFVAR_LISP ("temp-file-name-pattern", &Vtemp_file_name_pattern, 1714 doc: /* Pattern for making names for temporary files. 1715This is used by `call-process-region'. */); 1716 /* This variable is initialized in init_callproc. */ 1717 1718 DEFVAR_LISP ("process-environment", &Vprocess_environment, 1719 doc: /* List of environment variables for subprocesses to inherit. 1720Each element should be a string of the form ENVVARNAME=VALUE. 1721If multiple entries define the same variable, the first one always 1722takes precedence. 1723The environment which Emacs inherits is placed in this variable 1724when Emacs starts. 1725Non-ASCII characters are encoded according to the initial value of 1726`locale-coding-system', i.e. the elements must normally be decoded for use. 1727See `setenv' and `getenv'. */); 1728 1729#ifndef VMS 1730 defsubr (&Scall_process); 1731 defsubr (&Sgetenv_internal); 1732#endif 1733 defsubr (&Scall_process_region); 1734} 1735 1736/* arch-tag: 769b8045-1df7-4d2b-8968-e3fb49017f95 1737 (do not change this comment) */ 1738