xemacs-beta: src/fileio.c comparison

comparison src/fileio.c @ 867:804517e16990

[xemacs-hg @ 2002-06-05 09:54:39 by ben] Textual renaming: text/char names abbrev.c, alloc.c, buffer.c, buffer.h, bytecode.c, callint.c, casefiddle.c, casetab.c, charset.h, chartab.c, chartab.h, cmds.c, console-gtk.h, console-msw.c, console-msw.h, console-stream.c, console-tty.c, console-x.c, console-x.h, console.h, data.c, device-msw.c, device-x.c, dialog-msw.c, dired-msw.c, dired.c, doc.c, doprnt.c, editfns.c, eldap.c, emodules.c, eval.c, event-Xt.c, event-gtk.c, event-msw.c, event-stream.c, event-unixoid.c, events.c, events.h, file-coding.c, file-coding.h, fileio.c, filelock.c, fns.c, font-lock.c, frame-gtk.c, frame-msw.c, frame-x.c, frame.c, glyphs-eimage.c, glyphs-msw.c, glyphs-x.c, glyphs.c, glyphs.h, gpmevent.c, gui-x.c, gui-x.h, gui.c, gui.h, hpplay.c, indent.c, insdel.c, insdel.h, intl-win32.c, keymap.c, line-number.c, line-number.h, lisp-disunion.h, lisp-union.h, lisp.h, lread.c, lrecord.h, lstream.c, lstream.h, md5.c, menubar-msw.c, menubar-x.c, menubar.c, minibuf.c, mule-ccl.c, mule-charset.c, mule-coding.c, mule-wnnfns.c, ndir.h, nt.c, objects-gtk.c, objects-gtk.h, objects-msw.c, objects-tty.c, objects-x.c, objects.c, objects.h, postgresql.c, print.c, process-nt.c, process-unix.c, process.c, procimpl.h, realpath.c, redisplay-gtk.c, redisplay-msw.c, redisplay-output.c, redisplay-tty.c, redisplay-x.c, redisplay.c, redisplay.h, regex.c, search.c, select-common.h, select-gtk.c, select-x.c, sound.h, symbols.c, syntax.c, syntax.h, sysdep.c, sysdep.h, sysdir.h, sysfile.h, sysproc.h, syspwd.h, systime.h, syswindows.h, termcap.c, tests.c, text.c, text.h, toolbar-common.c, tooltalk.c, ui-gtk.c, unexnt.c, unicode.c, win32.c: Text/char naming rationalization. [a] distinguish between "charptr" when it refers to operations on the pointer itself and when it refers to operations on text; and [b] use consistent naming for everything referring to internal format, i.e. Itext == text in internal format Ibyte == a byte in such text Ichar == a char as represented in internal character format thus e.g. set_charptr_emchar -> set_itext_ichar The pre and post tags on either side of this change are: pre-internal-format-textual-renaming post-internal-format-textual-renaming See the Internals Manual for details of exactly how this was done, how to handle the change in your workspace, etc.

author	ben
date	Wed, 05 Jun 2002 09:58:45 +0000
parents	2b6fa2618f76
children	79c6ff3eef26

comparison

equal deleted inserted replaced

-:613552a02607
+:804517e16990
 /* DATA can be anything acceptable to signal_error ().
 */
 DOESNT_RETURN
 report_file_type_error (Lisp_Object errtype, Lisp_Object oserrmess,
-			const CIntbyte *string, Lisp_Object data)
+			const CIbyte *string, Lisp_Object data)
 {
 struct gcpro gcpro1;
 Lisp_Object errdata = build_error_data (NULL, data);
 GCPRO1 (errdata);
 /* UNGCPRO; not reached */
 }
 DOESNT_RETURN
 report_error_with_errno (Lisp_Object errtype,
-			 const CIntbyte *string, Lisp_Object data)
+			 const CIbyte *string, Lisp_Object data)
 {
 report_file_type_error (errtype, lisp_strerror (errno), string, data);
 }
 /* signal a file error when errno contains a meaningful value. */
 DOESNT_RETURN
-report_file_error (const CIntbyte *string, Lisp_Object data)
+report_file_error (const CIbyte *string, Lisp_Object data)
 {
 report_error_with_errno (Qfile_error, string, data);
 }
 lisp_strerror (int errnum)
 {
 Extbyte *ret = strerror (errnum);
 if (!ret)
 {
-Intbyte ffff[99];
+Ibyte ffff[99];
 qxesprintf (ffff, "Unknown error %d", errnum);
 return build_intstring (ffff);
 }
 return build_ext_string (ret, Qstrerror_encoding);
 }
 */
 (filename))
 {
 /* This function can GC.  GC checked 2000-07-28 ben */
 /* This function synched with Emacs 21.0.103. */
-Intbyte *beg;
+Ibyte *beg;
-Intbyte *p;
+Ibyte *p;
 Lisp_Object handler;
 CHECK_STRING (filename);
 /* If the file name has special constructs in it,
 return Qnil;
 #ifdef WIN32_NATIVE
 /* Expansion of "c:" to drive and default directory.  */
 if (p[-1] == ':')
 {
-Intbyte *res;
+Ibyte *res;
-Intbyte *wd = mswindows_getdcwd (toupper (*beg) - 'A' + 1);
+Ibyte *wd = mswindows_getdcwd (toupper (*beg) - 'A' + 1);
-res = alloca_array (Intbyte,
+res = alloca_array (Ibyte,
 			  (wd ? qxestrlen (wd) : 0) + 10); /* go overboard */
 if (p == beg + 4 && IS_DIRECTORY_SEP (*beg) && beg[1] == ':')
 	{
 	  qxestrncpy (res, beg, 2);
 	  beg += 2;
 if (wd)
 	{
 	  qxestrcat (res, wd);
 	  if (!IS_DIRECTORY_SEP (res[qxestrlen (res) - 1]))
-	    qxestrcat (res, (Intbyte *) "/");
+	    qxestrcat (res, (Ibyte *) "/");
 	  beg = res;
 	  p = beg + qxestrlen (beg);
 	}
 if (wd)
 	xfree (wd);
 #if 0 /* No! This screws up efs, which calls file-name-directory on URL's
 	 and expects the slashes to be left alone.  This is here because of
 	 an analogous call in FSF 21. */
 {
 Bytecount len = p - beg;
-Intbyte *newbeg = alloca_intbytes (len + 1);
+Ibyte *newbeg = alloca_ibytes (len + 1);
 Lisp_Object return_me;
 qxestrncpy (newbeg, beg, len);
 newbeg[len] = '\0';
 newbeg = mswindows_canonicalize_filename (newbeg);
 */
 (filename))
 {
 /* This function can GC.  GC checked 2000-07-28 ben */
 /* This function synched with Emacs 21.0.103. */
-Intbyte *beg, *p, *end;
+Ibyte *beg, *p, *end;
 Lisp_Object handler;
 CHECK_STRING (filename);
 /* If the file name has special constructs in it,
 return Ffile_name_directory (filename);
 }
-static Intbyte *
+static Ibyte *
-file_name_as_directory (Intbyte *out, Intbyte *in)
+file_name_as_directory (Ibyte *out, Ibyte *in)
 {
 /* This function cannot GC */
 int size = qxestrlen (in);
 if (size == 0)
 except for (file-name-as-directory \"\") => \"./\".
 */
 (filename))
 {
 /* This function can GC.  GC checked 2000-07-28 ben */
-Intbyte *buf;
+Ibyte *buf;
 Lisp_Object handler;
 CHECK_STRING (filename);
 /* If the file name has special constructs in it,
 call the corresponding file handler.  */
 handler = Ffind_file_name_handler (filename, Qfile_name_as_directory);
 if (!NILP (handler))
 return call2_check_string (handler, Qfile_name_as_directory, filename);
-buf = alloca_intbytes (XSTRING_LENGTH (filename) + 10);
+buf = alloca_ibytes (XSTRING_LENGTH (filename) + 10);
 return build_intstring (file_name_as_directory (buf, XSTRING_DATA (filename)));
 }
 /*
 * Convert from directory name to filename.
 *
 * Value is nonzero if the string output is different from the input.
 */
 static int
-directory_file_name (const Intbyte *src, Intbyte *dst)
+directory_file_name (const Ibyte *src, Ibyte *dst)
 {
 /* This function cannot GC */
 long slen = qxestrlen (src);
 /* Process as Unix format: just remove any final slash.
 But leave "/" unchanged; do not change it to "".  */
 In Unix-syntax, this function just removes the final slash.
 */
 (directory))
 {
 /* This function can GC.  GC checked 2000-07-28 ben */
-Intbyte *buf;
+Ibyte *buf;
 Lisp_Object handler;
 CHECK_STRING (directory);
 #if 0 /* #### WTF? */
 /* If the file name has special constructs in it,
 call the corresponding file handler.  */
 handler = Ffind_file_name_handler (directory, Qdirectory_file_name);
 if (!NILP (handler))
 return call2_check_string (handler, Qdirectory_file_name, directory);
-buf = (Intbyte *) ALLOCA (XSTRING_LENGTH (directory) + 20);
+buf = (Ibyte *) ALLOCA (XSTRING_LENGTH (directory) + 20);
 directory_file_name (XSTRING_DATA (directory), buf);
 return build_intstring (buf);
 }
 /* Fmake_temp_name used to be a simple wrapper around mktemp(), but it
 'w','x','y','z','0','1','2','3',
 '4','5','6','7','8','9','-','_'
 };
 Bytecount len;
-Intbyte *p, *data;
+Ibyte *p, *data;
 Lisp_Object handler;
 CHECK_STRING (prefix);
 handler = Ffind_file_name_handler (prefix, Qmake_temp_name);
 if (!NILP (handler))
 [[ 3) It might yield unexpected (to stat(2)) results in the presence
 of EFS and file name handlers.]] Now that we check for a handler,
 that's less of a concern. --ben */
 len = XSTRING_LENGTH (prefix);
-data = alloca_intbytes (len + 7);
+data = alloca_ibytes (len + 7);
 memcpy (data, XSTRING_DATA (prefix), len);
 p = data + len;
 p[6] = '\0';
 /* VAL is created by adding 6 characters to PREFIX.  The first three
 */
 (name, default_directory))
 {
 /* This function can GC.  GC-checked 2000-11-18.
 This function synched with Emacs 21.0.103. */
-Intbyte *nm;
+Ibyte *nm;
-Intbyte *newdir, *p, *o;
+Ibyte *newdir, *p, *o;
 int tlen;
-Intbyte *target;
+Ibyte *target;
 #ifdef WIN32_FILENAMES
 int drive = 0;
 int collapse_newdir = 1;
 /* XEmacs note: This concerns the special '/:' syntax for preventing
 wildcards and such.  We don't support this currently but I'm
 nm = XSTRING_DATA (name);
 #ifdef WIN32_FILENAMES
 /* We will force directory separators to be either all \ or /, so make
 a local copy to modify, even if there ends up being no change. */
-nm = qxestrcpy (alloca_intbytes (qxestrlen (nm) + 1), nm);
+nm = qxestrcpy (alloca_ibytes (qxestrlen (nm) + 1), nm);
 /* Note if special escape prefix is present, but remove for now.  */
 if (nm[0] == '/' && nm[1] == ':')
 {
 is_escaped = 1;
 }
 /* Find and remove drive specifier if present; this makes nm absolute
 even if the rest of the name appears to be relative. */
 {
-Intbyte *colon = qxestrrchr (nm, ':');
+Ibyte *colon = qxestrrchr (nm, ':');
 if (colon)
 {
 /* Only recognize colon as part of drive specifier if there is a
 	 single alphabetic character preceding the colon (and if the
 if (!lose)
 	{
 #ifdef WIN32_FILENAMES
 	  if (drive || IS_DIRECTORY_SEP (nm[1]))
 	    {
-	      Intbyte *newnm;
+	      Ibyte *newnm;
 	      if (IS_DIRECTORY_SEP (nm[1]))
 		{
 		  newnm = mswindows_canonicalize_filename (nm);
 		  if (qxestrcmp (newnm, XSTRING_DATA (name)) != 0)
 if (nm[0] == '~')		/* prefix ~ */
 {
 if (IS_DIRECTORY_SEP (nm[1])
 	  || nm[1] == 0)	/* ~ by itself */
 	{
-	  Intbyte *homedir = get_home_directory ();
+	  Ibyte *homedir = get_home_directory ();
 	  if (!homedir)
-	    newdir = (Intbyte *) "";
+	    newdir = (Ibyte *) "";
 	  else
 	    newdir = homedir;
 	  nm++;
 #ifdef WIN32_FILENAMES
 	}
 else			/* ~user/filename */
 	{
 	  for (p = nm; *p && (!IS_DIRECTORY_SEP (*p)); p++)
 	    DO_NOTHING;
-	  o = (Intbyte *) ALLOCA (p - nm + 1);
+	  o = (Ibyte *) ALLOCA (p - nm + 1);
 	  memcpy (o, nm, p - nm);
 	  o [p - nm] = 0;
 	  /* #### While NT is single-user (for the moment) you still
 	     can have multiple user profiles users defined, each with
 	     its HOME.  So maybe possibly we should think about handling
 	     ~user. --ben */
 #ifndef WIN32_NATIVE
 #ifdef CYGWIN
 	  {
-	    Intbyte *user;
+	    Ibyte *user;
 	    if ((user = user_login_name (NULL)) != NULL)
 	      {
 		/* Does the user login name match the ~name? */
 		if (qxestrcmp (user, o + 1) == 0)
 	  slow_down_interrupts ();
 	  pw = (struct passwd *) qxe_getpwnam (o + 1);
 	  speed_up_interrupts ();
 	  if (pw)
 	    {
-	      newdir = (Intbyte *) pw->pw_dir;
+	      newdir = (Ibyte *) pw->pw_dir;
 	      nm = p;
 	      /* FSF: if WIN32_NATIVE, collapse_newdir = 0;
 		 not possible here. */
 	    }
 #ifdef CYGWIN
 {
 #ifdef WIN32_NATIVE
 /* Get default directory if needed to make nm absolute. */
 if (!IS_DIRECTORY_SEP (nm[0]))
 	{
-	  Intbyte *newcwd = mswindows_getdcwd (toupper (drive) - 'A' + 1);
+	  Ibyte *newcwd = mswindows_getdcwd (toupper (drive) - 'A' + 1);
 	  if (newcwd)
 	    {
-	      INTBYTE_STRING_TO_ALLOCA (newcwd, newdir);
+	      IBYTE_STRING_TO_ALLOCA (newcwd, newdir);
 	      xfree (newcwd);
 	    }
 	  else
 	    newdir = NULL;
 	}
 #endif /* WIN32_NATIVE */
 if (!newdir)
 	{
 	  /* Either nm starts with /, or drive isn't mounted. */
-	  newdir = (Intbyte *) ALLOCA (4);
+	  newdir = (Ibyte *) ALLOCA (4);
 	  newdir[0] = DRIVE_LETTER (drive);
 	  newdir[1] = ':';
 	  newdir[2] = '/';
 	  newdir[3] = 0;
 	}
 	      drive = newdir[0];
 	      newdir += 2;
 	    }
 	  if (!IS_DIRECTORY_SEP (nm[0]))
 	    {
-	      Intbyte *tmp = (Intbyte *) ALLOCA (qxestrlen (newdir) +
+	      Ibyte *tmp = (Ibyte *) ALLOCA (qxestrlen (newdir) +
 						 qxestrlen (nm) + 2);
 	      file_name_as_directory (tmp, newdir);
 	      qxestrcat (tmp, nm);
 	      nm = tmp;
 	    }
 	  if (drive)
 	    {
 #ifdef WIN32_NATIVE
-	      Intbyte *newcwd = mswindows_getdcwd (toupper (drive) - 'A' + 1);
+	      Ibyte *newcwd = mswindows_getdcwd (toupper (drive) - 'A' + 1);
 	      if (newcwd)
 		{
-		  INTBYTE_STRING_TO_ALLOCA (newcwd, newdir);
+		  IBYTE_STRING_TO_ALLOCA (newcwd, newdir);
 		  xfree (newcwd);
 		}
 	      else
 #endif
-		INTBYTE_STRING_TO_ALLOCA ((Intbyte *) "/", newdir);
+		IBYTE_STRING_TO_ALLOCA ((Ibyte *) "/", newdir);
 	    }
 	  else
-	    INTBYTE_STRING_TO_ALLOCA (get_initial_directory (0, 0), newdir);
+	    IBYTE_STRING_TO_ALLOCA (get_initial_directory (0, 0), newdir);
 	}
 /* Strip off drive name from prefix, if present. */
 if (IS_DRIVE (newdir[0]) && newdir[1] == ':')
 	{
 	  && collapse_newdir)
 	{
 	  if (IS_DIRECTORY_SEP (newdir[0]) && IS_DIRECTORY_SEP (newdir[1]))
 	    {
 	      newdir =
-		(Intbyte *)
+		(Ibyte *)
-		  qxestrcpy ((Intbyte *) ALLOCA (qxestrlen (newdir) + 1),
+		  qxestrcpy ((Ibyte *) ALLOCA (qxestrlen (newdir) + 1),
 			     newdir);
 	      p = newdir + 2;
 	      while (*p && !IS_DIRECTORY_SEP (*p)) p++;
 	      p++;
 	      while (*p && !IS_DIRECTORY_SEP (*p)) p++;
 	      *p = 0;
 	    }
 	  else
-	    newdir = (Intbyte *) "";
+	    newdir = (Ibyte *) "";
 	}
 }
 #endif /* WIN32_FILENAMES */
 if (newdir)
 #ifdef WIN32_FILENAMES
 	  && !(length == 2 && IS_DIRECTORY_SEP (newdir[0]))
 #endif
 	  )
 	{
-	  Intbyte *temp = (Intbyte *) ALLOCA (length);
+	  Ibyte *temp = (Ibyte *) ALLOCA (length);
 	  memcpy (temp, newdir, length - 1);
 	  temp[length - 1] = 0;
 	  newdir = temp;
 	}
 tlen = length + 1;
 tlen += qxestrlen (nm) + 1;
 #ifdef WIN32_FILENAMES
 /* Reserve space for drive specifier and escape prefix, since either
 or both may need to be inserted.  (The Microsoft x86 compiler
 produces incorrect code if the following two lines are combined.)  */
-target = (Intbyte *) ALLOCA (tlen + 4);
+target = (Ibyte *) ALLOCA (tlen + 4);
 target += 4;
 #else  /* not WIN32_FILENAMES */
-target = (Intbyte *) ALLOCA (tlen);
+target = (Ibyte *) ALLOCA (tlen);
 #endif /* not WIN32_FILENAMES */
 *target = 0;
 if (newdir)
 {
 }
 *o = '\0';
 {
-Intbyte *newtarget = mswindows_canonicalize_filename (target);
+Ibyte *newtarget = mswindows_canonicalize_filename (target);
 Lisp_Object result = build_intstring (newtarget);
 xfree (newtarget);
 RETURN_UNGCPRO (result);
 }
 RETURN_UNGCPRO
 	(call2_check_string (handler, Qfile_truename, expanded_name));
 }
 {
-Intbyte resolved_path[PATH_MAX];
+Ibyte resolved_path[PATH_MAX];
 Bytecount elen = XSTRING_LENGTH (expanded_name);
-Intbyte *path;
+Ibyte *path;
-Intbyte *p;
+Ibyte *p;
 LISP_STRING_TO_ALLOCA (expanded_name, path);
 p = path;
 /* Try doing it all at once. */
 	   Since we depend on undocumented semantics of various system
 	   realpath()s, we just use our own version in realpath.c. */
 	for (;;)
 	  {
-	    Intbyte *pos;
+	    Ibyte *pos;
 #ifdef WIN32_FILENAMES
 	    if (IS_DRIVE (p[0]) && IS_DEVICE_SEP (p[1])
 		&& IS_DIRECTORY_SEP (p[2]))
 	      /* don't test c: on windows */
 If `/~' appears, all of FILENAME through that `/' is discarded.
 */
 (filename))
 {
 /* This function can GC.  GC checked 2000-07-28 ben. */
-Intbyte *nm;
+Ibyte *nm;
-Intbyte *s, *p, *o, *x, *endp;
+Ibyte *s, *p, *o, *x, *endp;
-Intbyte *target = 0;
+Ibyte *target = 0;
 int total = 0;
 int substituted = 0;
-Intbyte *xnm;
+Ibyte *xnm;
 Lisp_Object handler;
 CHECK_STRING (filename);
 /* If the file name has special constructs in it,
 	    while (p != endp && (isalnum (*p) || *p == '_')) p++;
 	    s = p;
 	  }
 	/* Copy out the variable name */
-	target = (Intbyte *) ALLOCA (s - o + 1);
+	target = (Ibyte *) ALLOCA (s - o + 1);
 	qxestrncpy (target, o, s - o);
 	target[s - o] = 0;
 #ifdef WIN32_NATIVE
 	strupr (target); /* $home == $HOME etc.  */
 #endif /* WIN32_NATIVE */
 	/* Get variable value */
-	o = egetenv ((CIntbyte *) target);
+	o = egetenv ((CIbyte *) target);
 	if (!o) goto badvar;
 	total += qxestrlen (o);
 	substituted = 1;
 }
 if (!substituted)
 return filename;
 /* If substitution required, recopy the filename and do it */
 /* Make space in stack frame for the new copy */
-xnm = (Intbyte *) ALLOCA (XSTRING_LENGTH (filename) + total + 1);
+xnm = (Ibyte *) ALLOCA (XSTRING_LENGTH (filename) + total + 1);
 x = xnm;
 /* Copy the rest of the name through, replacing $ constructs with values */
 for (p = nm; *p;)
 if (*p != '$')
 	    while (p != endp && (isalnum (*p) || *p == '_')) p++;
 	    s = p;
 	  }
 	/* Copy out the variable name */
-	target = (Intbyte *) ALLOCA (s - o + 1);
+	target = (Ibyte *) ALLOCA (s - o + 1);
 	qxestrncpy (target, o, s - o);
 	target[s - o] = 0;
 #ifdef WIN32_NATIVE
 	strupr (target); /* $home == $HOME etc.  */
 #endif /* WIN32_NATIVE */
 	/* Get variable value */
-	o = egetenv ((CIntbyte *) target);
+	o = egetenv ((CIbyte *) target);
 	if (!o)
 	  goto badvar;
 	qxestrcpy (x, o);
 	x += qxestrlen (o);
 On Unix, this is a name starting with a `/' or a `~'.
 */
 (filename))
 {
 /* This function does not GC */
-Intbyte *ptr;
+Ibyte *ptr;
 CHECK_STRING (filename);
 ptr = XSTRING_DATA (filename);
 return (IS_DIRECTORY_SEP (*ptr) || *ptr == '~'
 #ifdef WIN32_FILENAMES
 }
 /* Return nonzero if file FILENAME exists and can be written.  */
 static int
-check_writable (const Intbyte *filename)
+check_writable (const Ibyte *filename)
 {
 #ifdef HAVE_EACCESS
 return (qxe_eaccess (filename, W_OK) >= 0);
 #else
 /* Access isn't quite right because it uses the real uid
 GCPRO1 (abspath);
 dir = Ffile_name_directory (abspath);
 UNGCPRO;
-return (check_writable (!NILP (dir) ? XSTRING_DATA (dir) : (Intbyte *) "")
+return (check_writable (!NILP (dir) ? XSTRING_DATA (dir) : (Ibyte *) "")
 	  ? Qt : Qnil);
 }
 DEFUN ("file-symlink-p", Ffile_symlink_p, 1, 1, 0, /*
 Return non-nil if file FILENAME is the name of a symbolic link.
 (filename))
 {
 /* This function can GC.  GC checked 1997.04.10. */
 /* XEmacs change: run handlers even if local machine doesn't have symlinks */
 #ifdef HAVE_READLINK
-Intbyte *buf;
+Ibyte *buf;
 int bufsize;
 int valsize;
 Lisp_Object val;
 #endif
 Lisp_Object handler;
 #ifdef HAVE_READLINK
 bufsize = 100;
 while (1)
 {
-buf = xnew_array_and_zero (Intbyte, bufsize);
+buf = xnew_array_and_zero (Ibyte, bufsize);
 valsize = qxe_readlink (XSTRING_DATA (filename),
 			      buf, bufsize);
 if (valsize < bufsize) break;
 /* Buffer was not long enough */
 xfree (buf);
 Charcount inserted = 0;
 int speccount;
 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
 Lisp_Object handler = Qnil, val;
 int total;
-Intbyte read_buf[READ_BUF_SIZE];
+Ibyte read_buf[READ_BUF_SIZE];
 int mc_count;
 struct buffer *buf = current_buffer;
 Lisp_Object curbuf;
 int not_regular = 0;
 int do_speedy_insert =
 	nextpos = XINT (tem);
 else
 	nextpos = INT_MAX;
 #ifdef MULE
 /* If there are annotations left and we have Mule, then we
-	 have to do the I/O one emchar at a time so we can
+	 have to do the I/O one ichar at a time so we can
 	 determine when to insert the annotation. */
 if (!NILP (*annot))
 	{
-	  Emchar ch;
+	  Ichar ch;
-	  while (pos != nextpos && (ch = Lstream_get_emchar (instr)) != EOF)
+	  while (pos != nextpos && (ch = Lstream_get_ichar (instr)) != EOF)
 	    {
-	      if (Lstream_put_emchar (outstr, ch) < 0)
+	      if (Lstream_put_ichar (outstr, ch) < 0)
 		return -1;
 	      pos++;
 	    }
 	}
 else

Mercurial > hg > xemacs-beta

comparison src/fileio.c @ 867:804517e16990