xemacs-beta: src/print.c comparison

comparison src/print.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
 /* Force immediate output of all printed data.  Used for debugging. */
 int print_unbuffered;
 FILE *termscript;	/* Stdio stream being used for copy of all output.  */
-static void write_string_to_alternate_debugging_output (Intbyte *str,
+static void write_string_to_alternate_debugging_output (Ibyte *str,
 							Bytecount len);
 int stdout_needs_newline;
 /* Basic function to actually write to a stdio stream or TTY console. */
 static void
 write_string_to_stdio_stream (FILE *stream, struct console *con,
-			      const Intbyte *ptr, Bytecount len,
+			      const Ibyte *ptr, Bytecount len,
 			      int must_flush)
 {
 Extbyte *extptr = 0;
 Bytecount extlen = 0;
 int output_is_std_handle =
 2) (to be really correct) make a new lstream that outputs using
 mswindows_output_console_string().  */
 static void
-std_handle_out_va (FILE *stream, const CIntbyte *fmt, va_list args,
+std_handle_out_va (FILE *stream, const CIbyte *fmt, va_list args,
 		   int debug_output_as_well)
 {
-Intbyte kludge[8192];
+Ibyte kludge[8192];
 Bytecount kludgelen;
 if (initialized && !inhibit_non_essential_printing_operations)
 fmt = GETTEXT (fmt);
-vsprintf ((CIntbyte *) kludge, fmt, args);
+vsprintf ((CIbyte *) kludge, fmt, args);
 kludgelen = qxestrlen (kludge);
 write_string_to_stdio_stream (stream, 0, kludge, kludgelen, 1);
 if (debug_output_as_well)
 {
 This is safe even when not initialized or when dying -- we don't do
 conversion in such cases. */
 void
-stderr_out (const CIntbyte *fmt, ...)
+stderr_out (const CIbyte *fmt, ...)
 {
 va_list args;
 va_start (args, fmt);
 std_handle_out_va (stderr, fmt, args, 0);
 va_end (args);
 /* Output portably to stdout or its equivalent (i.e. may be a console
 window under MS Windows).  Works like stderr_out(). */
 void
-stdout_out (const CIntbyte *fmt, ...)
+stdout_out (const CIbyte *fmt, ...)
 {
 va_list args;
 va_start (args, fmt);
 std_handle_out_va (stdout, fmt, args, 0);
 va_end (args);
 window under MS Windows), as well as alternate-debugging-output and
 (under MS Windows) the C debugging output, i.e. OutputDebugString().
 Works like stderr_out(). */
 void
-debug_out (const CIntbyte *fmt, ...)
+debug_out (const CIbyte *fmt, ...)
 {
 va_list args;
 va_start (args, fmt);
 std_handle_out_va (stderr, fmt, args, 1);
 va_end (args);
 }
 DOESNT_RETURN
-fatal (const CIntbyte *fmt, ...)
+fatal (const CIbyte *fmt, ...)
 {
 va_list args;
 va_start (args, fmt);
 stderr_out ("\nXEmacs: fatal error: ");
 Use Qexternal_debugging_output to get output to stderr.
 */
 static void
-output_string (Lisp_Object function, const Intbyte *nonreloc,
+output_string (Lisp_Object function, const Ibyte *nonreloc,
 	       Lisp_Object reloc, Bytecount offset, Bytecount len)
 {
 /* This function can GC */
 Charcount cclen;
 /* We change the value of nonreloc (fetching it from reloc as
 necessary), but we don't want to pass this changed value on to
 other functions that take both a nonreloc and a reloc, or things
 may get confused and an assertion failure in
 fixup_internal_substring() may get triggered. */
-const Intbyte *newnonreloc = nonreloc;
+const Ibyte *newnonreloc = nonreloc;
 struct gcpro gcpro1, gcpro2;
 /* Emacs won't print while GCing, but an external debugger might */
 #ifdef NO_PRINT_DURING_GC
 if (gc_in_progress) return;
 	     relocating the string.  For small strings, we do it by
 	     alloc'ing the string and using a copy; for large strings,
 	     we inhibit GC.  */
 	  if (len < 65536)
 	    {
-	      Intbyte *copied = alloca_array (Intbyte, len);
+	      Ibyte *copied = alloca_array (Ibyte, len);
 	      memcpy (copied, newnonreloc + offset, len);
 	      Lstream_write (XLSTREAM (function), copied, len);
 	    }
 	  else
 	    {
 if (STRINGP (reloc))
 	{
 	  for (iii = ccoff; iii < cclen + ccoff; iii++)
 	    {
-	      call1 (function, make_char (string_emchar (reloc, iii)));
+	      call1 (function, make_char (string_ichar (reloc, iii)));
 	      if (STRINGP (reloc))
 		newnonreloc = XSTRING_DATA (reloc);
 	    }
 	}
 else
 	{
 	  for (iii = ccoff; iii < cclen + ccoff; iii++)
 	    {
 	      call1 (function,
-		     make_char (charptr_emchar_n (newnonreloc, iii)));
+		     make_char (itext_ichar_n (newnonreloc, iii)));
 	    }
 	}
 }
 UNGCPRO;
 Also note that STREAM should be the result of
 canonicalize_printcharfun() (i.e. Qnil means stdout, not
 Vstandard_output, etc.)  */
 void
-write_string_1 (Lisp_Object stream, const Intbyte *str, Bytecount size)
+write_string_1 (Lisp_Object stream, const Ibyte *str, Bytecount size)
 {
 /* This function can GC */
 #ifdef ERROR_CHECK_TEXT
 assert (size >= 0);
 #endif
 output_string (stream, str, Qnil, 0, size);
 }
 void
-write_string (Lisp_Object stream, const Intbyte *str)
+write_string (Lisp_Object stream, const Ibyte *str)
 {
 /* This function can GC */
 write_string_1 (stream, str, qxestrlen (str));
 }
 void
-write_c_string (Lisp_Object stream, const CIntbyte *str)
+write_c_string (Lisp_Object stream, const CIbyte *str)
 {
 /* This function can GC */
-write_string_1 (stream, (const Intbyte *) str, strlen (str));
+write_string_1 (stream, (const Ibyte *) str, strlen (str));
 }
 void
 write_eistring (Lisp_Object stream, const Eistring *ei)
 {
 }
 /* Write a printf-style string to STREAM; see output_string(). */
 void
-write_fmt_string (Lisp_Object stream, const CIntbyte *fmt, ...)
+write_fmt_string (Lisp_Object stream, const CIbyte *fmt, ...)
 {
 va_list va;
-Intbyte *str;
+Ibyte *str;
 Bytecount len;
 int count;
 va_start (va, fmt);
 str = emacs_vsprintf_malloc (fmt, va, &len);
 #### It shouldn't be necessary to specify the number of arguments.
 This would require some rewriting of the doprnt() functions, though. */
 void
-write_fmt_string_lisp (Lisp_Object stream, const CIntbyte *fmt, int nargs, ...)
+write_fmt_string_lisp (Lisp_Object stream, const CIbyte *fmt, int nargs, ...)
 {
 Lisp_Object *args = alloca_array (Lisp_Object, nargs);
 va_list va;
 int i;
-Intbyte *str;
+Ibyte *str;
 Bytecount len;
 int count;
 va_start (va, nargs);
 for (i = 0; i < nargs; i++)
 write_string_1 (stream, str, len);
 unbind_to (count);
 }
 void
-stderr_out_lisp (const CIntbyte *fmt, int nargs, ...)
+stderr_out_lisp (const CIbyte *fmt, int nargs, ...)
 {
 Lisp_Object *args = alloca_array (Lisp_Object, nargs);
 va_list va;
 int i;
-Intbyte *str;
+Ibyte *str;
 Bytecount len;
 int count;
 va_start (va, nargs);
 for (i = 0; i < nargs; i++)
 STREAM defaults to the value of `standard-output' (which see).
 */
 (character, stream))
 {
 /* This function can GC */
-Intbyte str[MAX_EMCHAR_LEN];
+Ibyte str[MAX_ICHAR_LEN];
 Bytecount len;
 CHECK_CHAR_COERCE_INT (character);
-len = set_charptr_emchar (str, XCHAR (character));
+len = set_itext_ichar (str, XCHAR (character));
 output_string (canonicalize_printcharfun (stream), str, Qnil, 0, len);
 return character;
 }
 void
 * 			-wsr
 */
 void
 float_to_string (char *buf, double data)
 {
-Intbyte *cp, c;
+Ibyte *cp, c;
 int width;
 if (NILP (Vfloat_output_format)
 || !STRINGP (Vfloat_output_format))
 lose:
 the read-equivalence of lisp objects.  (* x 1) and (* x 1.0) do
 not do the same thing, so it's important that the printed
 representation of that form not be corrupted by the printer.
 */
 {
-Intbyte *s = (Intbyte *) buf; /* don't use signed chars here!
+Ibyte *s = (Ibyte *) buf; /* don't use signed chars here!
 				     isdigit() can't hack them! */
 if (*s == '-') s++;
 for (; *s; s++)
 /* if there's a non-digit, then there is a decimal point, or
 	 it's in exponential notation, both of which are ok. */
 Bytecount i, last = 0;
 write_c_string (printcharfun, "\"");
 for (i = 0; i < bcmax; i++)
 	{
-	  Intbyte ch = string_byte (obj, i);
+	  Ibyte ch = string_byte (obj, i);
 	  if (ch == '\"' || ch == '\\'
 	      || (ch == '\n' && print_escape_newlines))
 	    {
 	      if (i > last)
 		{
 		{
 		  write_c_string (printcharfun, "\\n");
 		}
 	      else
 		{
-		  Intbyte temp[2];
+		  Ibyte temp[2];
 		  write_c_string (printcharfun, "\\");
 		  /* This is correct for Mule because the
 		     character is either \ or " */
 		  temp[0] = string_byte (obj, i);
 		  temp[1] = '\0';
 case Lisp_Type_Char:
 {
 	/* God intended that this be #\..., you know. */
 	char buf[16];
-	Emchar ch = XCHAR (obj);
+	Ichar ch = XCHAR (obj);
 	char *p = buf;
 	*p++ = '?';
 	if (ch < 32)
 	  {
 	    *p++ = '\\';
 	    *p++ = '\\', *p++ = '^', *p++ = '?';
 	  }
 	else if (ch < 160)
 	  {
 	    *p++ = '\\', *p++ = '^';
-	    p += set_charptr_emchar ((Intbyte *) p, ch + 64);
+	    p += set_itext_ichar ((Ibyte *) p, ch + 64);
 	  }
 	else
 	  {
-	    p += set_charptr_emchar ((Intbyte *) p, ch);
+	    p += set_itext_ichar ((Ibyte *) p, ch);
 	  }
-	output_string (printcharfun, (Intbyte *) buf, Qnil, 0, p - buf);
+	output_string (printcharfun, (Ibyte *) buf, Qnil, 0, p - buf);
 	break;
 }
 case Lisp_Type_Record:
 write_c_string (printcharfun, "#:");
 }
 /* Does it look like an integer or a float? */
 {
-Intbyte *data = XSTRING_DATA (name);
+Ibyte *data = XSTRING_DATA (name);
 Bytecount confusing = 0;
 if (size == 0)
 goto not_yet_confused;    /* Really confusing */
 else if (isdigit (data[0]))
 to be passed to `print'.  Before calling `print', set `alternate_do_pointer'
 to 0.
 */
 (character))
 {
-Intbyte str[MAX_EMCHAR_LEN];
+Ibyte str[MAX_ICHAR_LEN];
 Bytecount len;
 CHECK_CHAR_COERCE_INT (character);
-len = set_charptr_emchar (str, XCHAR (character));
+len = set_itext_ichar (str, XCHAR (character));
 write_string_to_alternate_debugging_output (str, len);
 return character;
 }
 static void
-write_string_to_alternate_debugging_output (Intbyte *str, Bytecount len)
+write_string_to_alternate_debugging_output (Ibyte *str, Bytecount len)
 {
 int extlen;
 const Extbyte *extptr;
 #if 0 /* We want to see the internal representation, don't we? */
 if (initialized && !inhibit_non_essential_printing_operations)
 				  XSTRING_DATA (char_or_string),
 				  XSTRING_LENGTH (char_or_string),
 				  print_unbuffered);
 else
 {
-Intbyte str[MAX_EMCHAR_LEN];
+Ibyte str[MAX_ICHAR_LEN];
 Bytecount len;
 CHECK_CHAR_COERCE_INT (char_or_string);
-len = set_charptr_emchar (str, XCHAR (char_or_string));
+len = set_itext_ichar (str, XCHAR (char_or_string));
 write_string_to_stdio_stream (file, con, str, len, print_unbuffered);
 }
 return char_or_string;
 }

Mercurial > hg > xemacs-beta

comparison src/print.c @ 867:804517e16990