comparison src/lstream.c @ 826:6728e641994e

[xemacs-hg @ 2002-05-05 11:30:15 by ben] syntax cache, 8-bit-format, lots of code cleanup README.packages: Update info about --package-path. i.c: Create an inheritable event and pass it on to XEmacs, so that ^C can be handled properly. Intercept ^C and signal the event. "Stop Build" in VC++ now works. bytecomp-runtime.el: Doc string changes. compat.el: Some attempts to redo this to make it truly useful and fix the "multiple versions interacting with each other" problem. Not yet done. Currently doesn't work. files.el: Use with-obsolete-variable to avoid warnings in new revert-buffer code. xemacs.mak: Split up CFLAGS into a version without flags specifying the C library. The problem seems to be that minitar depends on zlib, which depends specifically on libc.lib, not on any of the other C libraries. Unless you compile with libc.lib, you get errors -- specifically, no _errno in the other libraries, which must make it something other than an int. (#### But this doesn't seem to obtain in XEmacs, which also uses zlib, and can be linked with any of the C libraries. Maybe zlib is used differently and doesn't need errno, or maybe XEmacs provides an int errno; ... I don't understand. Makefile.in.in: Fix so that packages are around when testing. abbrev.c, alloc.c, buffer.c, buffer.h, bytecode.c, callint.c, casefiddle.c, casetab.c, casetab.h, charset.h, chartab.c, chartab.h, cmds.c, console-msw.h, console-stream.c, console-x.c, console.c, console.h, data.c, device-msw.c, device.c, device.h, dialog-msw.c, dialog-x.c, dired-msw.c, dired.c, doc.c, doprnt.c, dumper.c, editfns.c, elhash.c, emacs.c, eval.c, event-Xt.c, event-gtk.c, event-msw.c, event-stream.c, events.c, events.h, extents.c, extents.h, faces.c, file-coding.c, file-coding.h, fileio.c, fns.c, font-lock.c, frame-gtk.c, frame-msw.c, frame-x.c, frame.c, frame.h, glade.c, glyphs-gtk.c, glyphs-msw.c, glyphs-msw.h, glyphs-x.c, glyphs.c, glyphs.h, gui-msw.c, gui-x.c, gui.h, gutter.h, hash.h, indent.c, insdel.c, intl-win32.c, intl.c, keymap.c, lisp-disunion.h, lisp-union.h, lisp.h, lread.c, lrecord.h, lstream.c, lstream.h, marker.c, menubar-gtk.c, menubar-msw.c, menubar-x.c, menubar.c, minibuf.c, mule-ccl.c, mule-charset.c, mule-coding.c, mule-wnnfns.c, nas.c, objects-msw.c, objects-x.c, opaque.c, postgresql.c, print.c, process-nt.c, process-unix.c, process.c, process.h, profile.c, rangetab.c, redisplay-gtk.c, redisplay-msw.c, redisplay-output.c, redisplay-x.c, redisplay.c, redisplay.h, regex.c, regex.h, scrollbar-msw.c, search.c, select-x.c, specifier.c, specifier.h, symbols.c, symsinit.h, syntax.c, syntax.h, syswindows.h, tests.c, text.c, text.h, tooltalk.c, ui-byhand.c, ui-gtk.c, unicode.c, win32.c, window.c: Another big Ben patch. -- FUNCTIONALITY CHANGES: add partial support for 8-bit-fixed, 16-bit-fixed, and 32-bit-fixed formats. not quite done yet. (in particular, needs functions to actually convert the buffer.) NOTE: lots of changes to regex.c here. also, many new *_fmt() inline funs that take an Internal_Format argument. redo syntax cache code. make the cache per-buffer; keep the cache valid across calls to functions that use it. also keep it valid across insertions/deletions and extent changes, as much as is possible. eliminate the junky regex-reentrancy code by passing in the relevant lisp info to the regex routines as local vars. add general mechanism in extents code for signalling extent changes. fix numerous problems with the case-table implementation; yoshiki never properly transferred many algorithms from old-style to new-style case tables. redo char tables to support a default argument, so that mapping only occurs over changed args. change many chartab functions to accept Lisp_Object instead of Lisp_Char_Table *. comment out the code in font-lock.c by default, because font-lock.el no longer uses it. we should consider eliminating it entirely. Don't output bell as ^G in console-stream when not a TTY. add -mswindows-termination-handle to interface with i.c, so we can properly kill a build. add more error-checking to buffer/string macros. add some additional buffer_or_string_() funs. -- INTERFACE CHANGES AFFECTING MORE CODE: switch the arguments of write_c_string and friends to be consistent with write_fmt_string, which must have printcharfun first. change BI_* macros to BYTE_* for increased clarity; similarly for bi_* local vars. change VOID_TO_LISP to be a one-argument function. eliminate no-longer-needed CVOID_TO_LISP. -- char/string macro changes: rename MAKE_CHAR() to make_emchar() for slightly less confusion with make_char(). (The former generates an Emchar, the latter a Lisp object. Conceivably we should rename make_char() -> wrap_char() and similarly for make_int(), make_float().) Similar changes for other *CHAR* macros -- we now consistently use names with `emchar' whenever we are working with Emchars. Any remaining name with just `char' always refers to a Lisp object. rename macros with XSTRING_* to string_* except for those that reference actual fields in the Lisp_String object, following conventions used elsewhere. rename set_string_{data,length} macros (the only ones to work with a Lisp_String_* instead of a Lisp_Object) to set_lispstringp_* to make the difference clear. try to be consistent about caps vs. lowercase in macro/inline-fun names for chars and such, which wasn't the case before. we now reserve caps either for XFOO_ macros that reference object fields (e.g. XSTRING_DATA) or for things that have non-function semantics, e.g. directly modifying an arg (BREAKUP_EMCHAR) or evaluating an arg (any arg) more than once. otherwise, use lowercase. here is a summary of most of the macros/inline funs changed by all of the above changes: BYTE_*_P -> byte_*_p XSTRING_BYTE -> string_byte set_string_data/length -> set_lispstringp_data/length XSTRING_CHAR_LENGTH -> string_char_length XSTRING_CHAR -> string_emchar INTBYTE_FIRST_BYTE_P -> intbyte_first_byte_p INTBYTE_LEADING_BYTE_P -> intbyte_leading_byte_p charptr_copy_char -> charptr_copy_emchar LEADING_BYTE_* -> leading_byte_* CHAR_* -> EMCHAR_* *_CHAR_* -> *_EMCHAR_* *_CHAR -> *_EMCHAR CHARSET_BY_ -> charset_by_* BYTE_SHIFT_JIS* -> byte_shift_jis* BYTE_BIG5* -> byte_big5* REP_BYTES_BY_FIRST_BYTE -> rep_bytes_by_first_byte char_to_unicode -> emchar_to_unicode valid_char_p -> valid_emchar_p Change intbyte_strcmp -> qxestrcmp_c (duplicated functionality). -- INTERFACE CHANGES AFFECTING LESS CODE: use DECLARE_INLINE_HEADER in various places. remove '#ifdef emacs' from XEmacs-only files. eliminate CHAR_TABLE_VALUE(), which duplicated the functionality of get_char_table(). add BUFFER_TEXT_LOOP to simplify iterations over buffer text. define typedefs for signed and unsigned types of fixed sizes (INT_32_BIT, UINT_32_BIT, etc.). create ALIGN_FOR_TYPE as a higher-level interface onto ALIGN_SIZE; fix code to use it. add charptr_emchar_len to return the text length of the character pointed to by a ptr; use it in place of charcount_to_bytecount(..., 1). add emchar_len to return the text length of a given character. add types Bytexpos and Charxpos to generalize Bytebpos/Bytecount and Charbpos/Charcount, in code (particularly, the extents code and redisplay code) that works with either kind of index. rename redisplay struct params with names such as `charbpos' to e.g. `charpos' when they are e.g. a Charxpos, not a Charbpos. eliminate xxDEFUN in place of DEFUN; no longer necessary with changes awhile back to doc.c. split up big ugly combined list of EXFUNs in lisp.h on a file-by-file basis, since other prototypes are similarly split. rewrite some "*_UNSAFE" macros as inline funs and eliminate the _UNSAFE suffix. move most string code from lisp.h to text.h; the string code and text.h code is now intertwined in such a fashion that they need to be in the same place and partially interleaved. (you can't create forward references for inline funs) automated/lisp-tests.el, automated/symbol-tests.el, automated/test-harness.el: Fix test harness to output FAIL messages to stderr when in batch mode. Fix up some problems in lisp-tests/symbol-tests that were causing spurious failures.
author ben
date Sun, 05 May 2002 11:33:57 +0000
parents a634e3b7acc8
children 1e4e42de23d5
comparison
equal deleted inserted replaced
825:eb3bc15a6e0f 826:6728e641994e
102 } 102 }
103 103
104 inline static Bytecount 104 inline static Bytecount
105 aligned_sizeof_lstream (Bytecount lstream_type_specific_size) 105 aligned_sizeof_lstream (Bytecount lstream_type_specific_size)
106 { 106 {
107 return ALIGN_SIZE (offsetof (Lstream, data) + lstream_type_specific_size, 107 return MAX_ALIGN_SIZE (offsetof (Lstream, data) +
108 ALIGNOF (max_align_t)); 108 lstream_type_specific_size);
109 } 109 }
110 110
111 static Bytecount 111 static Bytecount
112 sizeof_lstream (const void *header) 112 sizeof_lstream (const void *header)
113 { 113 {
306 incomplete character. */ 306 incomplete character. */
307 { 307 {
308 const unsigned char *dataend = data + size - 1; 308 const unsigned char *dataend = data + size - 1;
309 assert (size > 0); /* safety check ... */ 309 assert (size > 0); /* safety check ... */
310 /* Optimize the most common case. */ 310 /* Optimize the most common case. */
311 if (!BYTE_ASCII_P (*dataend)) 311 if (!byte_ascii_p (*dataend))
312 { 312 {
313 /* Go back to the beginning of the last (and possibly partial) 313 /* Go back to the beginning of the last (and possibly partial)
314 character, and bump forward to see if the character is 314 character, and bump forward to see if the character is
315 complete. */ 315 complete. */
316 VALIDATE_CHARPTR_BACKWARD (dataend); 316 VALIDATE_CHARPTR_BACKWARD (dataend);
317 if (dataend + REP_BYTES_BY_FIRST_BYTE (*dataend) != data + size) 317 if (dataend + rep_bytes_by_first_byte (*dataend) != data + size)
318 /* If not, chop the size down to ignore the last char 318 /* If not, chop the size down to ignore the last char
319 and stash it away for next time. */ 319 and stash it away for next time. */
320 size = dataend - data; 320 size = dataend - data;
321 /* If we don't even have one character to write, then just 321 /* If we don't even have one character to write, then just
322 skip out. */ 322 skip out. */
1584 1584
1585 DEFINE_LSTREAM_IMPLEMENTATION ("lisp-buffer", lisp_buffer); 1585 DEFINE_LSTREAM_IMPLEMENTATION ("lisp-buffer", lisp_buffer);
1586 1586
1587 static Lisp_Object 1587 static Lisp_Object
1588 make_lisp_buffer_stream_1 (struct buffer *buf, Charbpos start, Charbpos end, 1588 make_lisp_buffer_stream_1 (struct buffer *buf, Charbpos start, Charbpos end,
1589 int flags, const char *mode) 1589 int flags, const Char_ASCII *mode)
1590 { 1590 {
1591 Lstream *lstr; 1591 Lstream *lstr;
1592 struct lisp_buffer_stream *str; 1592 struct lisp_buffer_stream *str;
1593 Charbpos bmin, bmax; 1593 Charbpos bmin, bmax;
1594 int reading = !strcmp (mode, "r"); 1594 int reading = !strcmp (mode, "r");
1646 str->flags = flags; 1646 str->flags = flags;
1647 return wrap_lstream (lstr); 1647 return wrap_lstream (lstr);
1648 } 1648 }
1649 1649
1650 Lisp_Object 1650 Lisp_Object
1651 make_lisp_buffer_input_stream (struct buffer *buf, Charbpos start, Charbpos end, 1651 make_lisp_buffer_input_stream (struct buffer *buf, Charbpos start,
1652 int flags) 1652 Charbpos end, int flags)
1653 { 1653 {
1654 return make_lisp_buffer_stream_1 (buf, start, end, flags, "r"); 1654 return make_lisp_buffer_stream_1 (buf, start, end, flags, "r");
1655 } 1655 }
1656 1656
1657 Lisp_Object 1657 Lisp_Object
1662 Lstream_set_character_mode (XLSTREAM (lstr)); 1662 Lstream_set_character_mode (XLSTREAM (lstr));
1663 return lstr; 1663 return lstr;
1664 } 1664 }
1665 1665
1666 static Bytecount 1666 static Bytecount
1667 lisp_buffer_reader (Lstream *stream, unsigned char *data, 1667 lisp_buffer_reader (Lstream *stream, Intbyte *data, Bytecount size)
1668 Bytecount size)
1669 { 1668 {
1670 struct lisp_buffer_stream *str = LISP_BUFFER_STREAM_DATA (stream); 1669 struct lisp_buffer_stream *str = LISP_BUFFER_STREAM_DATA (stream);
1671 unsigned char *orig_data = data; 1670 Intbyte *orig_data = data;
1672 Bytebpos start; 1671 Bytebpos start;
1673 Bytebpos end; 1672 Bytebpos end;
1674 struct buffer *buf = XBUFFER (str->buffer); 1673 struct buffer *buf = XBUFFER (str->buffer);
1674 Bytecount src_used;
1675 1675
1676 if (!BUFFER_LIVE_P (buf)) 1676 if (!BUFFER_LIVE_P (buf))
1677 return 0; /* Fut. */ 1677 return 0; /* Fut. */
1678 1678
1679 /* NOTE: We do all our operations in Bytebpos's. 1679 start = byte_marker_position (str->start);
1680 Keep in mind that SIZE is a value in bytes, not chars. */ 1680 end = byte_marker_position (str->end);
1681
1682 start = bi_marker_position (str->start);
1683 end = bi_marker_position (str->end);
1684 if (!(str->flags & LSTR_IGNORE_ACCESSIBLE)) 1681 if (!(str->flags & LSTR_IGNORE_ACCESSIBLE))
1685 { 1682 {
1686 start = bytebpos_clip_to_bounds (BI_BUF_BEGV (buf), start, 1683 start = bytebpos_clip_to_bounds (BYTE_BUF_BEGV (buf), start,
1687 BI_BUF_ZV (buf)); 1684 BYTE_BUF_ZV (buf));
1688 end = bytebpos_clip_to_bounds (BI_BUF_BEGV (buf), end, 1685 end = bytebpos_clip_to_bounds (BYTE_BUF_BEGV (buf), end,
1689 BI_BUF_ZV (buf)); 1686 BYTE_BUF_ZV (buf));
1690 } 1687 }
1691 1688
1692 size = min (size, (Bytecount) (end - start)); 1689 size = copy_buffer_text_out (buf, start, end - start, data, size,
1693 end = start + size; 1690 FORMAT_DEFAULT, Qnil, &src_used);
1694 /* We cannot return a partial character. */ 1691 end = start + src_used;
1695 VALIDATE_BYTEBPOS_BACKWARD (buf, end);
1696
1697 while (start < end)
1698 {
1699 Bytebpos ceil;
1700 Bytecount chunk;
1701
1702 if (str->flags & LSTR_IGNORE_ACCESSIBLE)
1703 ceil = BI_BUF_CEILING_OF_IGNORE_ACCESSIBLE (buf, start);
1704 else
1705 ceil = BI_BUF_CEILING_OF (buf, start);
1706 chunk = min (ceil, end) - start;
1707 memcpy (data, BI_BUF_BYTE_ADDRESS (buf, start), chunk);
1708 data += chunk;
1709 start += chunk;
1710 }
1711 1692
1712 if (EQ (buf->selective_display, Qt) && str->flags & LSTR_SELECTIVE) 1693 if (EQ (buf->selective_display, Qt) && str->flags & LSTR_SELECTIVE)
1713 { 1694 {
1714 /* What a kludge. What a kludge. What a kludge. */ 1695 /* What a kludge. What a kludge. What a kludge. */
1715 unsigned char *p; 1696 Intbyte *p;
1716 for (p = orig_data; p < data; p++) 1697 for (p = orig_data; p < data; p++)
1717 if (*p == '\r') 1698 if (*p == '\r')
1718 *p = '\n'; 1699 *p = '\n';
1719 } 1700 }
1720 1701
1721 set_bi_marker_position (str->start, end); 1702 set_byte_marker_position (str->start, end);
1722 return data - orig_data; 1703 return size;
1723 } 1704 }
1724 1705
1725 static Bytecount 1706 static Bytecount
1726 lisp_buffer_writer (Lstream *stream, const unsigned char *data, 1707 lisp_buffer_writer (Lstream *stream, const Intbyte *data,
1727 Bytecount size) 1708 Bytecount size)
1728 { 1709 {
1729 struct lisp_buffer_stream *str = LISP_BUFFER_STREAM_DATA (stream); 1710 struct lisp_buffer_stream *str = LISP_BUFFER_STREAM_DATA (stream);
1730 Charbpos pos; 1711 Charbpos pos;
1731 struct buffer *buf = XBUFFER (str->buffer); 1712 struct buffer *buf = XBUFFER (str->buffer);