xemacs-beta: src/ntproc.c comparison

comparison src/ntproc.c @ 398:74fd4e045ea6 r21-2-29

Import from CVS: tag r21-2-29

author	cvs
date	Mon, 13 Aug 2007 11:13:30 +0200
parents	8626e4521993
children	a86b2b5e0111

comparison

equal deleted inserted replaced

-:f4aeb21a5bad
+:74fd4e045ea6
 #include <io.h>
 #include <fcntl.h>
 #include <signal.h>
 /* must include CRT headers *before* config.h */
-/* ### I don't believe it - martin */
+/* #### I don't believe it - martin */
 #include <config.h>
 #undef signal
 #undef wait
 #undef spawnve
 #undef select
 #undef kill
 #include <windows.h>
 #include <sys/socket.h>
+#ifdef HAVE_A_OUT_H
+#include <a.out.h>
+#endif
 #include "lisp.h"
 #include "sysproc.h"
 #include "nt.h"
 #include "ntheap.h" /* From 19.34.6 */
 #include "systime.h"
 #include "syssignal.h"
+#include "sysfile.h"
 #include "syswait.h"
+#include "buffer.h"
 #include "process.h"
 /*#include "w32term.h"*/ /* From 19.34.6: sync in ? --marcpa */
 /* #### I'm not going to play with shit. */
 #pragma warning (disable:4013 4024 4090)
 allows the possibility of hash collisions.  */
 Lisp_Object Vwin32_generate_fake_inodes;
 Lisp_Object Qhigh, Qlow;
+extern Lisp_Object Vlisp_EXEC_SUFFIXES;
 #ifndef DEBUG_XEMACS
 __inline
 #endif
 void _DebPrint (const char *fmt, ...)
 {
 int child_proc_count = 0;
 child_process child_procs[ MAX_CHILDREN ];
 child_process *dead_child = NULL;
 DWORD WINAPI reader_thread (void *arg);
+/* Determine if running on Windows 9x and not NT */
+static int
+windows9x_p (void)
+{
+return GetVersion () & 0x80000000;
+}
 /* Find an unused process slot.  */
 child_process *
 new_child (void)
 {
 if (CHILD_ACTIVE (cp) && pid == cp->pid)
 return cp;
 return NULL;
 }
+/* Function to do blocking read of one byte, needed to implement
+select.  It is only allowed on sockets and pipes. */
+static int
+_sys_read_ahead (int fd)
+{
+child_process * cp;
+int rc = 0;
+if (fd < 0 || fd >= MAXDESC)
+return STATUS_READ_ERROR;
+cp = fd_info[fd].cp;
+if (cp == NULL || cp->fd != fd || cp->status != STATUS_READ_READY)
+return STATUS_READ_ERROR;
+if ((fd_info[fd].flags & (FILE_PIPE | FILE_SOCKET)) == 0
+|| (fd_info[fd].flags & FILE_READ) == 0)
+{
+/* fd is not a pipe or socket */
+abort ();
+}
+cp->status = STATUS_READ_IN_PROGRESS;
+if (fd_info[fd].flags & FILE_PIPE)
+{
+rc = _read (fd, &cp->chr, sizeof (char));
+/* Give subprocess time to buffer some more output for us before
+	 reporting that input is available; we need this because Win95
+	 connects DOS programs to pipes by making the pipe appear to be
+	 the normal console stdout - as a result most DOS programs will
+	 write to stdout without buffering, ie.  one character at a
+	 time.  Even some Win32 programs do this - "dir" in a command
+	 shell on NT is very slow if we don't do this. */
+if (rc > 0)
+	{
+	  int wait = XINT (Vwin32_pipe_read_delay);
+	  if (wait > 0)
+	    Sleep (wait);
+	  else if (wait < 0)
+	    while (++wait <= 0)
+	      /* Yield remainder of our time slice, effectively giving a
+		 temporary priority boost to the child process. */
+	      Sleep (0);
+	}
+}
+if (rc == sizeof (char))
+cp->status = STATUS_READ_SUCCEEDED;
+else
+cp->status = STATUS_READ_FAILED;
+return cp->status;
+}
 /* Thread proc for child process and socket reader threads. Each thread
 is normally blocked until woken by select() to check for input by
 reading one char.  When the read completes, char_avail is signalled
 to wake up the select emulator and the thread blocks itself again. */
 the new process should start in.  This is set just before calling
 sys_spawnve, and is not generally valid at any other time.  */
 static const char * process_dir;
 static BOOL
-create_child (char *exe, char *cmdline, char *env,
+create_child (const char *exe, char *cmdline, char *env,
 	      int * pPid, child_process *cp)
 {
 STARTUPINFO start;
 SECURITY_ATTRIBUTES sec_attrs;
 SECURITY_DESCRIPTOR sec_desc;
 CloseHandle (cp->procinfo.hThread);
 CloseHandle (cp->procinfo.hProcess);
 cp->procinfo.hThread=NULL;
 cp->procinfo.hProcess=NULL;
-/* Hack for Windows 95, which assigns large (ie negative) pids */
-if (cp->pid < 0)
-cp->pid = -cp->pid;
 /* pid must fit in a Lisp_Int */
-#ifdef USE_UNION_TYPE
-cp->pid = (cp->pid & ((1U << VALBITS) - 1));
-#else
-cp->pid = (cp->pid & VALMASK);
-#endif
 *pPid = cp->pid;
 return TRUE;
 EH_Fail:
 DebPrint (("create_child.CreateProcess failed: %ld\n", GetLastError()););
 return FALSE;
 }
+#ifndef __MINGW32__
+/* Return pointer to section header for section containing the given
+relative virtual address. */
+static IMAGE_SECTION_HEADER *
+rva_to_section (DWORD rva, IMAGE_NT_HEADERS * nt_header)
+{
+PIMAGE_SECTION_HEADER section;
+int i;
+section = IMAGE_FIRST_SECTION (nt_header);
+for (i = 0; i < nt_header->FileHeader.NumberOfSections; i++)
+{
+if (rva >= section->VirtualAddress
+	  && rva < section->VirtualAddress + section->SizeOfRawData)
+	return section;
+section++;
+}
+return NULL;
+}
+#endif
 void
-win32_executable_type (char * filename, int * is_dos_app, int * is_cygnus_app)
+win32_executable_type (const char * filename, int * is_dos_app, int * is_cygnus_app)
 {
 file_data executable;
 char * p;
 /* Default values in case we can't tell for sure.  */
 	 COMSPEC to determine what executable to actually invoke.
 	     Therefore, we have to do the same here as well. */
 /* Actually, I think it uses the program association for that
 	 extension, which is defined in the registry.  */
 p = egetenv ("COMSPEC");
-	  if (p)
+if (p)
 	win32_executable_type (p, is_dos_app, is_cygnus_app);
-	}
+}
 else
 	{
 /* Look for DOS .exe signature - if found, we must also check that
 	 it isn't really a 16- or 32-bit Windows exe, since both formats
 	 start with a DOS program stub.  Note that 16-bit Windows
 	 executables use the OS/2 1.x format. */
-IMAGE_DOS_HEADER * dos_header;
+#ifdef __MINGW32__
-IMAGE_NT_HEADERS * nt_header;
+	  /* mingw32 doesn't have enough headers to detect cygwin
+apps, just do what we can. */
-dos_header = (PIMAGE_DOS_HEADER) executable.file_base;
+	  FILHDR * exe_header;
-if (dos_header->e_magic != IMAGE_DOS_SIGNATURE)
-	goto unwind;
+	  exe_header = (FILHDR*) executable.file_base;
+	  if (exe_header->e_magic != DOSMAGIC)
-nt_header = (PIMAGE_NT_HEADERS) ((char *) dos_header + dos_header->e_lfanew);
+	    goto unwind;
-if ((char *) nt_header > (char *) dos_header + executable.size)
+	  if ((char *) exe_header->e_lfanew > (char *) executable.size)
-	{
-	  /* Some dos headers (pkunzip) have bogus e_lfanew fields.  */
-	  *is_dos_app = TRUE;
-	}
-else if (nt_header->Signature != IMAGE_NT_SIGNATURE &&
-		 LOWORD (nt_header->Signature) != IMAGE_OS2_SIGNATURE)
-	{
-	  *is_dos_app = TRUE;
-	}
-else if (nt_header->Signature == IMAGE_NT_SIGNATURE)
-	{
-	  /* Look for cygwin.dll in DLL import list. */
-	  IMAGE_DATA_DIRECTORY import_dir =
-	    nt_header->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT];
-	  IMAGE_IMPORT_DESCRIPTOR * imports;
-	  IMAGE_SECTION_HEADER * section;
-	  section = rva_to_section (import_dir.VirtualAddress, nt_header);
-	  imports = RVA_TO_PTR (import_dir.VirtualAddress, section, executable);
-	  for ( ; imports->Name; imports++)
 	    {
-	      char * dllname = RVA_TO_PTR (imports->Name, section, executable);
+	      /* Some dos headers (pkunzip) have bogus e_lfanew fields.  */
+	      *is_dos_app = TRUE;
-	      if (strcmp (dllname, "cygwin.dll") == 0)
+	    }
+	  else if (exe_header->nt_signature != NT_SIGNATURE)
 	    {
-		  *is_cygnus_app = TRUE;
+	      *is_dos_app = TRUE;
-		  break;
+	    }
+#else
+	  IMAGE_DOS_HEADER * dos_header;
+	  IMAGE_NT_HEADERS * nt_header;
+	  dos_header = (PIMAGE_DOS_HEADER) executable.file_base;
+	  if (dos_header->e_magic != IMAGE_DOS_SIGNATURE)
+	    goto unwind;
+	  nt_header = (PIMAGE_NT_HEADERS) ((char *) dos_header + dos_header->e_lfanew);
+	  if ((char *) nt_header > (char *) dos_header + executable.size)
+	    {
+	      /* Some dos headers (pkunzip) have bogus e_lfanew fields.  */
+	      *is_dos_app = TRUE;
+	    }
+	  else if (nt_header->Signature != IMAGE_NT_SIGNATURE &&
+		   LOWORD (nt_header->Signature) != IMAGE_OS2_SIGNATURE)
+	    {
+	      *is_dos_app = TRUE;
+	    }
+	  else if (nt_header->Signature == IMAGE_NT_SIGNATURE)
+	    {
+	      /* Look for cygwin.dll in DLL import list. */
+	      IMAGE_DATA_DIRECTORY import_dir =
+		nt_header->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT];
+	      IMAGE_IMPORT_DESCRIPTOR * imports;
+	      IMAGE_SECTION_HEADER * section;
+	      section = rva_to_section (import_dir.VirtualAddress, nt_header);
+	      imports = RVA_TO_PTR (import_dir.VirtualAddress, section, executable);
+	      for ( ; imports->Name; imports++)
+		{
+		  char * dllname = RVA_TO_PTR (imports->Name, section, executable);
+		  if (strcmp (dllname, "cygwin.dll") == 0)
+		    {
+		      *is_cygnus_app = TRUE;
+		      break;
+		    }
 		}
 	    }
+#endif
 	}
-}
+unwind:
-unwind:
+close_file_data (&executable);
-close_file_data (&executable);
 }
 int
-compare_env (const char **strp1, const char **strp2)
+compare_env (const void *strp1, const void *strp2)
 {
-const char *str1 = *strp1, *str2 = *strp2;
+const char *str1 = *(const char**)strp1, *str2 = *(const char**)strp2;
 while (*str1 && *str2 && *str1 != '=' && *str2 != '=')
 {
 if ((*str1) > (*str2))
 	return 1;
 }
 /* When a new child process is created we need to register it in our list,
 so intercept spawn requests.  */
 int
-sys_spawnve (int mode, CONST char *cmdname,
+sys_spawnve (int mode, const char *cmdname,
-	     CONST char * CONST *argv, CONST char *CONST *envp)
+	     const char * const *argv, const char *const *envp)
 {
 Lisp_Object program, full;
 char *cmdline, *env, *parg, **targ;
 int arglen, numenv;
 int pid;
 child_process *cp;
 int is_dos_app, is_cygnus_app;
 int do_quoting = 0;
-char escape_char;
+char escape_char = 0;
 /* We pass our process ID to our children by setting up an environment
 variable in their environment.  */
 char ppid_env_var_buffer[64];
 char *extra_env[] = {ppid_env_var_buffer, NULL};
 struct gcpro gcpro1;
 program = make_string (cmdname, strlen (cmdname));
 GCPRO1 (program);
 if (NILP (Ffile_executable_p (program)))
 {
 full = Qnil;
-locate_file (Vexec_path, program, EXEC_SUFFIXES, &full, 1);
+locate_file (Vexec_path, program, Vlisp_EXEC_SUFFIXES, &full, 1);
 if (NILP (full))
 	{
 	  UNGCPRO;
 	  errno = EINVAL;
 	  return -1;
 	}
-cmdname = XSTRING_DATA (full);
+TO_EXTERNAL_FORMAT (LISP_STRING, full,
-/* #### KLUDGE */
+			  C_STRING_ALLOCA, cmdname,
-*(char**)(argv[0]) = cmdname;
+			  Qfile_name);
+}
+else
+{
+(char*)cmdname = alloca (strlen (argv[0]) + 1);
+strcpy ((char*)cmdname, argv[0]);
 }
 UNGCPRO;
 /* make sure argv[0] and cmdname are both in DOS format */
-strcpy (cmdname = alloca (strlen (cmdname) + 1), argv[0]);
+unixtodos_filename ((char*)cmdname);
-unixtodos_filename (cmdname);
 /* #### KLUDGE */
-*(char**)(argv[0]) = cmdname;
+((const char**)argv)[0] = cmdname;
 /* Determine whether program is a 16-bit DOS executable, or a Win32
 executable that is implicitly linked to the Cygnus dll (implying it
 was compiled with the Cygnus GNU toolchain and hence relies on
 cygwin.dll to parse the command line - we use this to decide how to
 while leaving the real app name as argv[0].  */
 if (is_dos_app)
 {
 cmdname = alloca (MAXPATHLEN);
 if (egetenv ("CMDPROXY"))
-	strcpy (cmdname, egetenv ("CMDPROXY"));
+	strcpy ((char*)cmdname, egetenv ("CMDPROXY"));
 else
 {
-	  strcpy (cmdname, XSTRING_DATA (Vinvocation_directory));
+	  strcpy ((char*)cmdname, XSTRING_DATA (Vinvocation_directory));
-	  strcat (cmdname, "cmdproxy.exe");
+	  strcat ((char*)cmdname, "cmdproxy.exe");
 	}
-unixtodos_filename (cmdname);
+unixtodos_filename ((char*)cmdname);
 }
 /* we have to do some conjuring here to put argv and envp into the
 form CreateProcess wants...  argv needs to be a space separated/null
 terminated list of parameters, and envp is a null
 	escape_char = is_cygnus_app ? '"' : '\\';
 }
 /* do argv...  */
 arglen = 0;
-targ = argv;
+targ = (char**)argv;
 while (*targ)
 {
 char * p = *targ;
 int need_quotes = 0;
 int escape_char_run = 0;
 	    arglen += escape_char_run;
 	}
 arglen += strlen (*targ++) + 1;
 }
 cmdline = alloca (arglen);
-targ = argv;
+targ = (char**)argv;
 parg = cmdline;
 while (*targ)
 {
 char * p = *targ;
 int need_quotes = 0;
 }
 *--parg = '\0';
 /* and envp...  */
 arglen = 1;
-targ = envp;
+targ = (char**)envp;
 numenv = 1; /* for end null */
 while (*targ)
 {
 arglen += strlen (*targ++) + 1;
 numenv++;
 arglen += strlen (ppid_env_var_buffer) + 1;
 numenv++;
 /* merge env passed in and extra env into one, and sort it.  */
 targ = (char **) alloca (numenv * sizeof (char *));
-merge_and_sort_env (envp, extra_env, targ);
+merge_and_sort_env ((char**)envp, extra_env, targ);
 /* concatenate env entries.  */
 env = alloca (arglen);
 parg = env;
 while (*targ)
 {
 char window_class[32];
 GetClassName (hwnd, window_class, sizeof (window_class));
 if (strcmp (window_class,
-		  (os_subtype == OS_WIN95)
+		  windows9x_p()
 		  ? "tty"
 		  : "ConsoleWindowClass") == 0)
 	{
 	  cp->hwnd = hwnd;
 	  return FALSE;
 {
 proc_hand = cp->procinfo.hProcess;
 pid = cp->procinfo.dwProcessId;
 /* Try to locate console window for process. */
-EnumWindows (find_child_console, (LPARAM) cp);
+EnumWindows ((WNDENUMPROC)find_child_console, (LPARAM) cp);
 }
 if (sig == SIGINT)
 {
 if (NILP (Vwin32_start_process_share_console) && cp && cp->hwnd)
 else
 {
 if (NILP (Vwin32_start_process_share_console) && cp && cp->hwnd)
 	{
 #if 1
-	  if (os_subtype == OS_WIN95)
+	  if (windows9x_p())
 	    {
 /*
 Another possibility is to try terminating the VDM out-right by
 calling the Shell VxD (id 0x17) V86 interface, function #4
 "SHELL_Destroy_VM", ie.
 return rc;
 }
 #if 0
 /* Sync with FSF Emacs 19.34.6 note: ifdef'ed out in XEmacs */
-extern int report_file_error (CONST char *, Lisp_Object);
+extern int report_file_error (const char *, Lisp_Object);
 #endif
 /* The following two routines are used to manipulate stdin, stdout, and
 stderr of our child processes.
 Assuming that in, out, and err are *not* inheritable, we make them
 if (!SetThreadLocale (XINT (lcid)))
 return Qnil;
 /* Sync with FSF Emacs 19.34.6 note: dwWinThreadId declared in
 w32term.h and defined in w32fns.c, both of which are not in current
-XEmacs.  ### Check what we lose by ifdef'ing out these. --marcpa */
+XEmacs.  #### Check what we lose by ifdef'ing out these. --marcpa */
 #if 0
 /* Need to set input thread locale if present.  */
 if (dwWinThreadId)
 /* Reply is not needed.  */
 PostThreadMessage (dwWinThreadId, WM_EMACS_SETLOCALE, XINT (lcid), 0);
 void
 syms_of_ntproc ()
 {
-Qhigh = intern ("high");
-Qlow = intern ("low");
 DEFSUBR (Fwin32_short_file_name);
 DEFSUBR (Fwin32_long_file_name);
 DEFSUBR (Fwin32_set_process_priority);
 DEFSUBR (Fwin32_get_locale_info);
 DEFSUBR (Fwin32_get_current_locale_id);
 DEFSUBR (Fwin32_get_default_locale_id);
 DEFSUBR (Fwin32_get_valid_locale_ids);
 DEFSUBR (Fwin32_set_current_locale);
+}
+void
+vars_of_ntproc (void)
+{
+defsymbol (&Qhigh, "high");
+defsymbol (&Qlow, "low");
 DEFVAR_LISP ("win32-quote-process-args", &Vwin32_quote_process_args /*
 Non-nil enables quoting of process arguments to ensure correct parsing.
 Because Windows does not directly pass argv arrays to child processes,
 programs have to reconstruct the argv array by parsing the command
 allowing only only DOS subprocess to run at a time (whether started directly
 or indirectly by Emacs), and preventing Emacs from cleanly terminating the
 subprocess group, but may allow Emacs to interrupt a subprocess that doesn't
 otherwise respond to interrupts from Emacs.
 */ );
-Vwin32_start_process_share_console = Qnil;
+Vwin32_start_process_share_console = Qt;
 DEFVAR_LISP ("win32-pipe-read-delay", &Vwin32_pipe_read_delay /*
 Forced delay before reading subprocess output.
 This is done to improve the buffering of subprocess output, by
 avoiding the inefficiency of frequently reading small amounts of data.
 the truename of a file can be slow.
 */ );
 Vwin32_generate_fake_inodes = Qnil;
 #endif
 }
 /* end of ntproc.c */

Mercurial > hg > xemacs-beta

comparison src/ntproc.c @ 398:74fd4e045ea6 r21-2-29