xemacs-beta: src/process.c comparison

comparison src/process.c @ 5125:b5df3737028a ben-lisp-object

merge

author	Ben Wing <ben@xemacs.org>
date	Wed, 24 Feb 2010 01:58:04 -0600
parents	623d57b7fbe8 ae48681c47fa
children	a9c41067dd88

comparison

equal deleted inserted replaced

-:623d57b7fbe8
+:b5df3737028a
 /* Asynchronous subprocess control for XEmacs.
 Copyright (C) 1985, 1986, 1987, 1988, 1992, 1993, 1994, 1995
 Free Software Foundation, Inc.
 Copyright (C) 1995 Sun Microsystems, Inc.
-Copyright (C) 1995, 1996, 2001, 2002, 2004, 2005 Ben Wing.
+Copyright (C) 1995, 1996, 2001, 2002, 2004, 2005, 2010 Ben Wing.
 This file is part of XEmacs.
 XEmacs is free software; you can redistribute it and/or modify it
 under the terms of the GNU General Public License as published by the
 #include "process-slots.h"
 return Qnil;
 }
 static void
-print_process (Lisp_Object object, Lisp_Object printcharfun, int escapeflag)
+print_process (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
 {
-Lisp_Process *process = XPROCESS (object);
+Lisp_Process *process = XPROCESS (obj);
 if (print_readably)
-printing_unreadable_object ("#<process %s>", XSTRING_DATA (process->name));
+printing_unreadable_lcrecord (obj, XSTRING_DATA (process->name));
 if (!escapeflag)
 {
 print_internal (process->name, printcharfun, 0);
 }
 else
 {
-int netp = network_connection_p (object);
+int netp = network_connection_p (obj);
-write_c_string (printcharfun,
+write_ascstring (printcharfun,
 		      netp ? GETTEXT ("#<network connection ") :
 		      GETTEXT ("#<process "));
 print_internal (process->name, printcharfun, 1);
-write_c_string (printcharfun, (netp ? " " : " pid "));
+write_ascstring (printcharfun, (netp ? " " : " pid "));
 print_internal (process->pid, printcharfun, 1);
 write_fmt_string_lisp (printcharfun, " state:%S", 1, process->status_symbol);
 MAYBE_PROCMETH (print_process_data, (process, printcharfun));
-write_c_string (printcharfun, ">");
+write_ascstring (printcharfun, ">");
 }
 }
 #ifdef HAVE_WINDOW_SYSTEM
 extern void debug_process_finalization (Lisp_Process *p);
 #endif /* HAVE_WINDOW_SYSTEM */
 if (p->process_data)
 {
 MAYBE_PROCMETH (finalize_process_data, (p));
-xfree (p->process_data, void *);
+xfree (p->process_data);
 }
 }
 DEFINE_NODUMP_LISP_OBJECT ("process", process,
 			   mark_process, print_process, finalize_process,
 assert (usid != USID_ERROR && usid != USID_DONTHASH);
 if (gethash ((const void*)usid, usid_to_process, &vval))
 {
 Lisp_Object process;
-process = VOID_TO_LISP (vval);
+process = GET_LISP_FROM_VOID (vval);
 return XPROCESS (process);
 }
 else
 return 0;
 }
 /************************************************************************/
 /*                          creating a process                          */
 /************************************************************************/
 DOESNT_RETURN
-report_process_error (const char *string, Lisp_Object data)
+report_process_error (const Ascbyte *reason, Lisp_Object data)
 {
-report_error_with_errno (Qprocess_error, string, data);
+report_error_with_errno (Qprocess_error, reason, data);
 }
 DOESNT_RETURN
-report_network_error (const char *string, Lisp_Object data)
+report_network_error (const Ascbyte *reason, Lisp_Object data)
 {
-report_error_with_errno (Qnetwork_error, string, data);
+report_error_with_errno (Qnetwork_error, reason, data);
 }
 Lisp_Object
 make_process_internal (Lisp_Object name)
 {
 /* If name is already in use, modify it until it is unused.  */
 name1 = name;
 for (i = 1; ; i++)
 {
-char suffix[10];
+Ascbyte suffix[10];
 Lisp_Object tem = Fget_process (name1);
 if (NILP (tem))
 break;
 sprintf (suffix, "<%d>", i);
-name1 = concat2 (name, build_string (suffix));
+name1 = concat2 (name, build_ascstring (suffix));
 }
 name = name1;
 p->name = name;
 p->mark = Fmake_marker ();
 if (in_usid != USID_DONTHASH)
 {
 Lisp_Object process = Qnil;
 process = wrap_process (p);
-puthash ((const void*) in_usid, LISP_TO_VOID (process), usid_to_process);
+puthash ((const void*) in_usid, STORE_LISP_IN_VOID (process), usid_to_process);
 }
 if (err_usid != USID_DONTHASH)
 {
 Lisp_Object process = Qnil;
 process = wrap_process (p);
-puthash ((const void*) err_usid, LISP_TO_VOID (process),
+puthash ((const void*) err_usid, STORE_LISP_IN_VOID (process),
 	       usid_to_process);
 }
 MAYBE_PROCMETH (init_process_io_handles, (p, in, out, err, flags));
 	 ending, e.g. .exe */
 struct gcpro ngcpro1;
 tem = Qnil;
 NGCPRO1 (tem);
-locate_file (list1 (build_string ("")), program, Vlisp_EXEC_SUFFIXES,
+locate_file (list1 (build_ascstring ("")), program, Vlisp_EXEC_SUFFIXES,
 		   &tem, X_OK);
 if (NILP (tem))
 	signal_error (Qprocess_error, "Searching for program", program);
 program = tem;
 NUNGCPRO;
 int coredump = p->core_dumped;
 Lisp_Object string, string2;
 if (EQ (symbol, Qsignal) || EQ (symbol, Qstop))
 {
-string = build_string (signal_name (code));
+string = build_cistring (signal_name (code));
 if (coredump)
 	string2 = build_msg_string (" (core dumped)\n");
 else
-	string2 = build_string ("\n");
+	string2 = build_ascstring ("\n");
 set_string_char (string, 0,
 		       DOWNCASE (0, string_ichar (string, 0)));
 return concat2 (string, string2);
 }
 else if (EQ (symbol, Qexit))
 	return build_msg_string ("finished\n");
 string = Fnumber_to_string (make_int (code));
 if (coredump)
 	string2 = build_msg_string (" (core dumped)\n");
 else
-	string2 = build_string ("\n");
+	string2 = build_ascstring ("\n");
 return concat2 (build_msg_string ("exited abnormally with code "),
 		      concat2 (string, string2));
 }
 else
 return Fcopy_sequence (Fsymbol_name (symbol));
 	    {
 	      struct gcpro ngcpro1;
 	      int spec = process_setup_for_insertion (process, 0);
 	      NGCPRO1 (process);
-	      buffer_insert_c_string (current_buffer, "\nProcess ");
+	      buffer_insert_ascstring (current_buffer, "\nProcess ");
 	      Finsert (1, &p->name);
-	      buffer_insert_c_string (current_buffer, " ");
+	      buffer_insert_ascstring (current_buffer, " ");
 	      Finsert (1, &msg);
 	      Fset_marker (p->mark, make_int (BUF_PT (current_buffer)),
 			   p->buffer);
 	      unbind_to (spec);
 	  && ! memcmp (XSTRING_DATA (entry), var, varlen)
 #endif /* not WIN32_NATIVE */
 	  )
 	{
 	  XCAR (scan) = concat3 (make_string (var, varlen),
-				 build_string ("="),
+				 build_ascstring ("="),
 				 make_string (value, valuelen));
 	  return;
 	}
 }
 Vprocess_environment = Fcons (concat3 (make_string (var, varlen),
-					 build_string ("="),
+					 build_ascstring ("="),
 					 make_string (value, valuelen)),
 				Vprocess_environment);
 }
 /* NOTE:
 VAR is a string, the name of the variable.
 When invoked interactively, prints the value in the echo area.
 */
 (var, interactivep))
 {
-Ibyte *value;
+Ibyte *value = NULL;
 Bytecount valuelen;
 Lisp_Object v = Qnil;
 struct gcpro gcpro1;
 CHECK_STRING (var);
 Vprocess_environment = Qnil;
 #ifdef WIN32_NATIVE
 _wgetenv (L""); /* force initialization of _wenviron */
 for (envp = (Extbyte **) _wenviron; envp && *envp; envp++)
 Vprocess_environment =
-	Fcons (build_ext_string (*envp, Qmswindows_unicode),
+	Fcons (build_extstring (*envp, Qmswindows_unicode),
 	       Vprocess_environment);
 #else
 for (envp = environ; envp && *envp; envp++)
 Vprocess_environment =
-	Fcons (build_ext_string (*envp, Qnative), Vprocess_environment);
+	Fcons (build_extstring (*envp, Qenvironment_variable_encoding),
+	       Vprocess_environment);
 #endif
 /* This gets set back to 0 in disksave_object_finalization() */
 env_initted = 1;
 }
 if (!egetenv ("SHELL"))
 {
 	Ibyte *faux_var = alloca_ibytes (7 + qxestrlen (shell));
 	qxesprintf (faux_var, "SHELL=%s", shell);
-	Vprocess_environment = Fcons (build_intstring (faux_var),
+	Vprocess_environment = Fcons (build_istring (faux_var),
 				      Vprocess_environment);
 }
 #endif /* 0 */
-Vshell_file_name = build_intstring (shell);
+Vshell_file_name = build_istring (shell);
 }
 }
 void
 syms_of_process (void)
 it sends a non-ending stream of zero bytes.  It's used most often along
 with memory-mapping.  We don't provide a Lisp variable for this because
 the operations needing this are lower level than what ELisp programs
 typically do, and in any case no equivalent exists under native MS Windows.
 */ );
-Vnull_device = build_string (NULL_DEVICE);
+Vnull_device = build_ascstring (NULL_DEVICE);
 DEFVAR_LISP ("process-connection-type", &Vprocess_connection_type /*
 Control type of device used to communicate with subprocesses.
 Values are nil to use a pipe, or t or `pty' to use a pty.
 The value has no effect if the system has no ptys or if all ptys are busy:
 Each element should be a string of the form ENVVARNAME=VALUE.
 The environment which Emacs inherits is placed in this variable
 when Emacs starts.
 */ );
-Vlisp_EXEC_SUFFIXES = build_string (EXEC_SUFFIXES);
+Vlisp_EXEC_SUFFIXES = build_ascstring (EXEC_SUFFIXES);
 staticpro (&Vlisp_EXEC_SUFFIXES);
 }

Mercurial > hg > xemacs-beta

comparison src/process.c @ 5125:b5df3737028a ben-lisp-object