Mercurial > hg > xemacs-beta
annotate src/lstream.h @ 5353:38e24b8be4ea
Improve the lexical scoping in #'block, #'return-from.
lisp/ChangeLog addition:
2011-02-07 Aidan Kehoe <kehoea@parhasard.net>
* bytecomp.el:
* bytecomp.el (byte-compile-initial-macro-environment):
Shadow `block', `return-from' here, we implement them differently
when byte-compiling.
* bytecomp.el (byte-compile-active-blocks): New.
* bytecomp.el (byte-compile-block-1): New.
* bytecomp.el (byte-compile-return-from-1): New.
* bytecomp.el (return-from-1): New.
* bytecomp.el (block-1): New.
These are two aliases that exist to have their own associated
byte-compile functions, which functions implement `block' and
`return-from'.
* cl-extra.el (cl-macroexpand-all):
Fix a bug here when macros in the environment have been compiled.
* cl-macs.el (block):
* cl-macs.el (return):
* cl-macs.el (return-from):
Be more careful about lexical scope in these macros.
* cl.el:
* cl.el ('cl-block-wrapper): Removed.
* cl.el ('cl-block-throw): Removed.
These aren't needed in code generated by this XEmacs. They
shouldn't be needed in code generated by XEmacs 21.4, but if it
turns out the packages do need them, we can put them back.
2011-01-30 Mike Sperber <mike@xemacs.org>
* font-lock.el (font-lock-fontify-pending-extents): Don't fail if
`font-lock-mode' is unset, which can happen in the middle of
`revert-buffer'.
2011-01-23 Aidan Kehoe <kehoea@parhasard.net>
* cl-macs.el (delete):
* cl-macs.el (delq):
* cl-macs.el (remove):
* cl-macs.el (remq):
Don't use the compiler macro if these functions were given the
wrong number of arguments, as happens in lisp-tests.el.
* cl-seq.el (remove, remq): Removed.
I added these to subr.el, and forgot to remove them from here.
2011-01-22 Aidan Kehoe <kehoea@parhasard.net>
* bytecomp.el (byte-compile-setq, byte-compile-set):
Remove kludge allowing keywords' values to be set, all the code
that does that is gone.
* cl-compat.el (elt-satisfies-test-p):
* faces.el (set-face-parent):
* faces.el (face-doc-string):
* gtk-font-menu.el:
* gtk-font-menu.el (gtk-reset-device-font-menus):
* msw-font-menu.el:
* msw-font-menu.el (mswindows-reset-device-font-menus):
* package-get.el (package-get-installedp):
* select.el (select-convert-from-image-data):
* sound.el:
* sound.el (load-sound-file):
* x-font-menu.el (x-reset-device-font-menus-core):
Don't quote keywords, they're self-quoting, and the
win from backward-compatibility is sufficiently small now that the
style problem overrides it.
2011-01-22 Aidan Kehoe <kehoea@parhasard.net>
* cl-macs.el (block, return-from): Require that NAME be a symbol
in these macros, as always documented in the #'block docstring and
as required by Common Lisp.
* descr-text.el (unidata-initialize-unihan-database):
Correct the use of non-symbols in #'block and #'return-from in
this function.
2011-01-15 Aidan Kehoe <kehoea@parhasard.net>
* cl-extra.el (concatenate): Accept more complicated TYPEs in this
function, handing the sequences over to #'coerce if we don't
understand them here.
* cl-macs.el (inline): Don't proclaim #'concatenate as inline, its
compiler macro is more useful than doing that.
2011-01-11 Aidan Kehoe <kehoea@parhasard.net>
* subr.el (delete, delq, remove, remq): Move #'remove, #'remq
here, they don't belong in cl-seq.el; move #'delete, #'delq here
from fns.c, implement them in terms of #'delete*, allowing support
for sequences generally.
* update-elc.el (do-autoload-commands): Use #'delete*, not #'delq
here, now the latter's no longer dumped.
* cl-macs.el (delete, delq): Add compiler macros transforming
#'delete and #'delq to #'delete* calls.
2011-01-10 Aidan Kehoe <kehoea@parhasard.net>
* dialog.el (make-dialog-box): Correct a misplaced parenthesis
here, thank you Mats Lidell in 87zkr9gqrh.fsf@mail.contactor.se !
2011-01-02 Aidan Kehoe <kehoea@parhasard.net>
* dialog.el (make-dialog-box):
* list-mode.el (display-completion-list):
These functions used to use cl-parsing-keywords; change them to
use defun* instead, fixing the build. (Not sure what led to me
not including this change in d1b17a33450b!)
2011-01-02 Aidan Kehoe <kehoea@parhasard.net>
* cl-macs.el (define-star-compiler-macros):
Make sure the form has ITEM and LIST specified before attempting
to change to calls with explicit tests; necessary for some tests
in lisp-tests.el to compile correctly.
(stable-union, stable-intersection): Add compiler macros for these
functions, in the same way we do for most of the other functions
in cl-seq.el.
2011-01-01 Aidan Kehoe <kehoea@parhasard.net>
* cl-macs.el (dolist, dotimes, do-symbols, macrolet)
(symbol-macrolet):
Define these macros with defmacro* instead of parsing the argument
list by hand, for the sake of style and readability; use backquote
where appropriate, instead of calling #'list and and friends, for
the same reason.
2010-12-30 Aidan Kehoe <kehoea@parhasard.net>
* x-misc.el (device-x-display):
Provide this function, documented in the Lispref for years, but
not existing previously. Thank you Julian Bradfield, thank you
Jeff Mincy.
2010-12-30 Aidan Kehoe <kehoea@parhasard.net>
* cl-seq.el:
Move the heavy lifting from this file to C. Dump the
cl-parsing-keywords macro, but don't use defun* for the functions
we define that do take keywords, dynamic scope lossage makes that
not practical.
* subr.el (sort, fillarray): Move these aliases here.
(map-plist): #'nsublis is now built-in, but at this point #'eql
isn't necessarily available as a test; use #'eq.
* obsolete.el (cl-delete-duplicates): Make this available for old
compiler macros and old code.
(memql): Document that this is equivalent to #'member*, and worse.
* cl.el (adjoin, subst): Removed. These are in C.
2010-12-30 Aidan Kehoe <kehoea@parhasard.net>
* simple.el (assoc-ignore-case): Remove a duplicate definition of
this function (it's already in subr.el).
* iso8859-1.el (char-width):
On non-Mule, make this function equivalent to that produced by
(constantly 1), but preserve its docstring.
* subr.el (subst-char-in-string): Define this in terms of
#'substitute, #'nsubstitute.
(string-width): Define this using #'reduce and #'char-width.
(char-width): Give this a simpler definition, it makes far more
sense to check for mule at load time and redefine, as we do in
iso8859-1.el.
(store-substring): Implement this in terms of #'replace, now
#'replace is cheap.
2010-12-30 Aidan Kehoe <kehoea@parhasard.net>
* update-elc.el (lisp-files-needed-for-byte-compilation)
(lisp-files-needing-early-byte-compilation):
cl-macs belongs in the former, not the latter, it is as
fundamental as bytecomp.el.
2010-12-30 Aidan Kehoe <kehoea@parhasard.net>
* cl.el:
Provde the Common Lisp program-error, type-error as error
symbols. This doesn't nearly go far enough for anyone using the
Common Lisp errors.
2010-12-29 Aidan Kehoe <kehoea@parhasard.net>
* cl-macs.el (delete-duplicates):
If the form has an incorrect number of arguments, don't attempt a
compiler macroexpansion.
2010-12-29 Aidan Kehoe <kehoea@parhasard.net>
* cl-macs.el (cl-safe-expr-p):
Forms that start with the symbol lambda are also safe.
2010-12-29 Aidan Kehoe <kehoea@parhasard.net>
* cl-macs.el (= < > <= >=):
For these functions' compiler macros, the optimisation is safe
even if the first and the last arguments have side effects, since
they're only used the once.
2010-12-29 Aidan Kehoe <kehoea@parhasard.net>
* cl-macs.el (inline-side-effect-free-compiler-macros):
Unroll a loop here at macro-expansion time, so these compiler
macros are compiled. Use #'eql instead of #'eq in a couple of
places for better style.
2010-12-29 Aidan Kehoe <kehoea@parhasard.net>
* cl-extra.el (notany, notevery): Avoid some dynamic scope
stupidity with local variable names in these functions, when they
weren't prefixed with cl-; go into some more detail in the doc
strings.
2010-12-29 Aidan Kehoe <kehoea@parhasard.net>
* byte-optimize.el (side-effect-free-fns): #'remove, #'remq are
free of side-effects.
(side-effect-and-error-free-fns):
Drop dot, dot-marker from the list.
2010-11-17 Aidan Kehoe <kehoea@parhasard.net>
* cl-extra.el (coerce):
In the argument list, name the first argument OBJECT, not X; the
former name was always used in the doc string and is clearer.
Handle vector type specifications which include the length of the
target sequence, error if there's a mismatch.
* cl-macs.el (cl-make-type-test): Handle type specifications
starting with the symbol 'eql.
2010-11-14 Aidan Kehoe <kehoea@parhasard.net>
* cl-macs.el (eql): Don't remove the byte-compile property of this
symbol. That was necessary to override a bug in bytecomp.el where
#'eql was confused with #'eq, which bug we no longer have.
If neither expression is constant, don't attempt to handle the
expression in this compiler macro, leave it to byte-compile-eql,
which produces better code anyway.
* bytecomp.el (eq): #'eql is not the function associated with the
byte-eq byte code.
(byte-compile-eql): Add an explicit compile method for this
function, for cases where the cl-macs compiler macro hasn't
reduced it to #'eq or #'equal.
2010-10-25 Aidan Kehoe <kehoea@parhasard.net>
Add compiler macros and compilation sanity-checking for various
functions that take keywords.
* byte-optimize.el (side-effect-free-fns): #'symbol-value is
side-effect free and not error free.
* bytecomp.el (byte-compile-normal-call): Check keyword argument
lists for sanity; store information about the positions where
keyword arguments start using the new byte-compile-keyword-start
property.
* cl-macs.el (cl-const-expr-val): Take a new optional argument,
cl-not-constant, defaulting to nil, in this function; return it if
the expression is not constant.
(cl-non-fixnum-number-p): Make this into a separate function, we
want to pass it to #'every.
(eql): Use it.
(define-star-compiler-macros): Use the same code to generate the
member*, assoc* and rassoc* compiler macros; special-case some
code in #'add-to-list in subr.el.
(remove, remq): Add compiler macros for these two functions, in
preparation for #'remove being in C.
(define-foo-if-compiler-macros): Transform (remove-if-not ...) calls to
(remove ... :if-not) at compile time, which will be a real win
once the latter is in C.
(define-substitute-if-compiler-macros)
(define-subst-if-compiler-macros): Similarly for these functions.
(delete-duplicates): Change this compiler macro to use
#'plists-equal; if we don't have information about the type of
SEQUENCE at compile time, don't bother attempting to inline the
call, the function will be in C soon enough.
(equalp): Remove an old commented-out compiler macro for this, if
we want to see it it's in version control.
(subst-char-in-string): Transform this to a call to nsubstitute or
nsubstitute, if that is appropriate.
* cl.el (ldiff): Don't call setf here, this makes for a load-time
dependency problem in cl-macs.el
2010-06-14 Stephen J. Turnbull <stephen@xemacs.org>
* term/vt100.el:
Refer to XEmacs, not GNU Emacs, in permissions.
* term/bg-mouse.el:
* term/sup-mouse.el:
Put copyright notice in canonical "Copyright DATE AUTHOR" form.
Refer to XEmacs, not GNU Emacs, in permissions.
* site-load.el:
Add permission boilerplate.
* mule/canna-leim.el:
* alist.el:
Refer to XEmacs, not APEL/this program, in permissions.
* mule/canna-leim.el:
Remove my copyright, I've assigned it to the FSF.
2010-06-14 Stephen J. Turnbull <stephen@xemacs.org>
* gtk.el:
* gtk-widget-accessors.el:
* gtk-package.el:
* gtk-marshal.el:
* gtk-compose.el:
* gnome.el:
Add copyright notice based on internal evidence.
2010-06-14 Stephen J. Turnbull <stephen@xemacs.org>
* easymenu.el: Add reference to COPYING to permission notice.
* gutter.el:
* gutter-items.el:
* menubar-items.el:
Fix typo "Xmacs" in permissions notice.
2010-06-14 Stephen J. Turnbull <stephen@xemacs.org>
* auto-save.el:
* font.el:
* fontconfig.el:
* mule/kinsoku.el:
Add "part of XEmacs" text to permission notice.
2010-10-14 Aidan Kehoe <kehoea@parhasard.net>
* byte-optimize.el (side-effect-free-fns):
* cl-macs.el (remf, getf):
* cl-extra.el (tailp, cl-set-getf, cl-do-remf):
* cl.el (ldiff, endp):
Tighten up Common Lisp compatibility for #'ldiff, #'endp, #'tailp;
add circularity checking for the first two.
#'cl-set-getf and #'cl-do-remf were Lisp implementations of
#'plist-put and #'plist-remprop; change the names to aliases,
changes the macros that use them to using #'plist-put and
#'plist-remprop directly.
2010-10-12 Aidan Kehoe <kehoea@parhasard.net>
* abbrev.el (fundamental-mode-abbrev-table, global-abbrev-table):
Create both these abbrev tables using the usual
#'define-abbrev-table calls, rather than attempting to
special-case them.
* cl-extra.el: Force cl-macs to be loaded here, if cl-extra.el is
being loaded interpreted. Previously other, later files would
redundantly call (load "cl-macs") when interpreted, it's more
reasonable to do it here, once.
* cmdloop.el (read-quoted-char-radix): Use defcustom here, we
don't have any dump-order dependencies that would prevent that.
* custom.el (eval-when-compile): Don't load cl-macs when
interpreted or when byte-compiling, rely on cl-extra.el in the
former case and the appropriate entry in bytecomp-load-hook in the
latter. Get rid of custom-declare-variable-list, we have no
dump-time dependencies that would require it.
* faces.el (eval-when-compile): Don't load cl-macs when
interpreted or when byte-compiling.
* packages.el: Remove some inaccurate comments.
* post-gc.el (cleanup-simple-finalizers): Use #'delete-if-not
here, now the order of preloaded-file-list has been changed to
make it available.
* subr.el (custom-declare-variable-list): Remove. No need for it.
Also remove a stub define-abbrev-table from this file, given the
current order of preloaded-file-list there's no need for it.
2010-10-10 Aidan Kehoe <kehoea@parhasard.net>
* bytecomp.el (byte-compile-constp) Forms quoted with FUNCTION are
also constant.
(byte-compile-initial-macro-environment): In #'the, if FORM is
constant and does not match TYPE, warn at byte-compile time.
2010-10-10 Aidan Kehoe <kehoea@parhasard.net>
* backquote.el (bq-vector-contents, bq-list*): Remove; the former
is equivalent to (append VECTOR nil), the latter to (list* ...).
(bq-process-2): Use (append VECTOR nil) instead of using
#'bq-vector-contents to convert to a list.
(bq-process-1): Now we use list* instead of bq-list
* subr.el (list*): Moved from cl.el, since it is now required to
be available the first time a backquoted form is encountered.
* cl.el (list*): Move to subr.el.
2010-09-16 Aidan Kehoe <kehoea@parhasard.net>
* test-harness.el (Check-Message):
Add an omitted comma here, thank you the buildbot.
2010-09-16 Aidan Kehoe <kehoea@parhasard.net>
* hash-table.el (hash-table-key-list, hash-table-value-list)
(hash-table-key-value-alist, hash-table-key-value-plist):
Remove some useless #'nreverse calls in these files; our hash
tables have no order, it's not helpful to pretend they do.
* behavior.el (read-behavior):
Do the same in this file, in some code evidently copied from
hash-table.el.
2010-09-16 Aidan Kehoe <kehoea@parhasard.net>
* info.el (Info-insert-dir):
* format.el (format-deannotate-region):
* files.el (cd, save-buffers-kill-emacs):
Use #'some, #'every and related functions for applying boolean
operations to lists, instead of rolling our own ones that cons and
don't short-circuit.
2010-09-16 Aidan Kehoe <kehoea@parhasard.net>
* bytecomp.el (byte-compile-initial-macro-environment):
* cl-macs.el (the):
Rephrase the docstring, make its implementation when compiling
files a little nicer.
2010-09-16 Aidan Kehoe <kehoea@parhasard.net>
* descr-text.el (unidata-initialize-unicodedata-database)
(unidata-initialize-unihan-database, describe-char-unicode-data)
(describe-char-unicode-data):
Wrap calls to the database functions with (with-fboundp ...),
avoiding byte compile warnings on builds without support for the
database functions.
(describe-char): (reduce #'max ...), not (apply #'max ...), no
need to cons needlessly.
(describe-char): Remove a redundant lambda wrapping
#'extent-properties.
(describe-char-unicode-data): Call #'nsubst when replacing "" with
nil in the result of #'split-string, instead of consing inside
mapcar.
2010-09-16 Aidan Kehoe <kehoea@parhasard.net>
* x-faces.el (x-available-font-sizes):
* specifier.el (let-specifier):
* package-ui.el (pui-add-required-packages):
* msw-faces.el (mswindows-available-font-sizes):
* modeline.el (modeline-minor-mode-menu):
* minibuf.el (minibuf-directory-files):
Replace the O2N (delq nil (mapcar (lambda (W) (and X Y)) Z)) with
the ON (mapcan (lambda (W) (and X (list Y))) Z) in these files.
2010-09-16 Aidan Kehoe <kehoea@parhasard.net>
* cl-macs.el (= < > <= >=):
When these functions are handed more than two arguments, and those
arguments have no side effects, transform to a series of two
argument calls, avoiding funcall in the byte-compiled code.
* mule/mule-cmds.el (finish-set-language-environment):
Take advantage of this change in a function called 256 times at
startup.
2010-09-16 Aidan Kehoe <kehoea@parhasard.net>
* bytecomp.el (byte-compile-function-form, byte-compile-quote)
(byte-compile-quote-form):
Warn at compile time, and error at runtime, if a (quote ...) or a
(function ...) form attempts to quote more than one object.
2010-09-16 Aidan Kehoe <kehoea@parhasard.net>
* byte-optimize.el (byte-optimize-apply): Transform (apply 'nconc
(mapcar ...)) to (mapcan ...); warn about use of the first idiom.
* update-elc.el (do-autoload-commands):
* packages.el (packages-find-package-library-path):
* frame.el (frame-list):
* extents.el (extent-descendants):
* etags.el (buffer-tag-table-files):
* dumped-lisp.el (preloaded-file-list):
* device.el (device-list):
* bytecomp-runtime.el (proclaim-inline, proclaim-notinline)
Use #'mapcan, not (apply #'nconc (mapcar ...) in all these files.
* bytecomp-runtime.el (eval-when-compile, eval-and-compile):
In passing, mention that these macros also evaluate the body when
interpreted.
tests/ChangeLog addition:
2011-02-07 Aidan Kehoe <kehoea@parhasard.net>
* automated/lisp-tests.el:
Test lexical scope for `block', `return-from'; add a
Known-Bug-Expect-Failure for a contorted example that fails when
byte-compiled.
| author | Aidan Kehoe <kehoea@parhasard.net> |
|---|---|
| date | Mon, 07 Feb 2011 12:01:24 +0000 |
| parents | a9c41067dd88 |
| children | 308d34e9f07d |
| rev | line source |
|---|---|
| 428 | 1 /* Generic stream implementation -- header file. |
| 2 Copyright (C) 1995 Free Software Foundation, Inc. | |
| 788 | 3 Copyright (C) 1996, 2001, 2002 Ben Wing. |
| 428 | 4 |
| 5 This file is part of XEmacs. | |
| 6 | |
| 7 XEmacs is free software; you can redistribute it and/or modify it | |
| 8 under the terms of the GNU General Public License as published by the | |
| 9 Free Software Foundation; either version 2, or (at your option) any | |
| 10 later version. | |
| 11 | |
| 12 XEmacs is distributed in the hope that it will be useful, but WITHOUT | |
| 13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 15 for more details. | |
| 16 | |
| 17 You should have received a copy of the GNU General Public License | |
| 18 along with XEmacs; see the file COPYING. If not, write to | |
| 19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330, | |
| 20 Boston, MA 02111-1307, USA. */ | |
| 21 | |
| 22 /* Synched up with: Not in FSF. */ | |
| 23 | |
| 24 /* Written by Ben Wing. */ | |
| 25 | |
| 440 | 26 #ifndef INCLUDED_lstream_h_ |
| 27 #define INCLUDED_lstream_h_ | |
| 428 | 28 |
| 29 /************************************************************************/ | |
| 30 /* definition of Lstream object */ | |
| 31 /************************************************************************/ | |
| 32 | |
|
5118
e0db3c197671
merge up to latest default branch, doesn't compile yet
Ben Wing <ben@xemacs.org>
parents:
3017
diff
changeset
|
33 DECLARE_LISP_OBJECT (lstream, struct lstream); |
| 428 | 34 #define XLSTREAM(x) XRECORD (x, lstream, struct lstream) |
| 617 | 35 #define wrap_lstream(p) wrap_record (p, lstream) |
| 428 | 36 #define LSTREAMP(x) RECORDP (x, lstream) |
| 37 /* #define CHECK_LSTREAM(x) CHECK_RECORD (x, lstream) | |
| 38 Lstream pointers should never escape to the Lisp level, so | |
| 39 functions should not be doing this. */ | |
| 40 | |
| 41 #ifndef EOF | |
| 42 #define EOF (-1) | |
| 43 #endif | |
| 44 | |
| 771 | 45 /* There have been some arguments over the what the type should be that |
| 665 | 46 specifies a count of bytes in a data block to be written out or read in, |
| 47 using Lstream_read(), Lstream_write(), and related functions. | |
| 48 Originally it was long, which worked fine; Martin "corrected" these to | |
| 49 size_t and ssize_t on the grounds that this is theoretically cleaner and | |
| 50 is in keeping with the C standards. Unfortunately, this practice is | |
| 51 horribly error-prone due to design flaws in the way that mixed | |
| 52 signed/unsigned arithmetic happens. In fact, by doing this change, | |
| 53 Martin introduced a subtle but fatal error that caused the operation of | |
| 54 sending large mail messages to the SMTP server under Windows to fail. | |
| 55 By putting all values back to be signed, avoiding any signed/unsigned | |
| 56 mixing, the bug immediately went away. The type then in use was | |
| 57 Lstream_Data_Count, so that it be reverted cleanly if a vote came to | |
| 58 that. Now it is Bytecount. | |
| 59 | |
| 60 Some earlier comments about why the type must be signed: This MUST BE | |
| 61 SIGNED, since it also is used in functions that return the number of | |
| 62 bytes actually read to or written from in an operation, and these | |
| 63 functions can return -1 to signal error. | |
| 462 | 64 |
| 65 Note that the standard Unix read() and write() functions define the | |
| 66 count going in as a size_t, which is UNSIGNED, and the count going | |
| 67 out as an ssize_t, which is SIGNED. This is a horrible design | |
| 68 flaw. Not only is it highly likely to lead to logic errors when a | |
| 69 -1 gets interpreted as a large positive number, but operations are | |
| 70 bound to fail in all sorts of horrible ways when a number in the | |
| 71 upper-half of the size_t range is passed in -- this number is | |
| 72 unrepresentable as an ssize_t, so code that checks to see how many | |
| 73 bytes are actually written (which is mandatory if you are dealing | |
| 74 with certain types of devices) will get completely screwed up. | |
| 771 | 75 |
| 665 | 76 --ben |
| 462 | 77 */ |
| 428 | 78 typedef enum lstream_buffering |
| 79 { | |
| 80 /* No buffering. */ | |
| 81 LSTREAM_UNBUFFERED, | |
| 82 /* Buffer until a '\n' character is reached. */ | |
| 83 LSTREAM_LINE_BUFFERED, | |
| 84 /* Buffer in standard-size (i.e. 512-byte) blocks. */ | |
| 85 LSTREAM_BLOCK_BUFFERED, | |
| 86 /* Buffer in blocks of a specified size. */ | |
| 87 LSTREAM_BLOCKN_BUFFERED, | |
| 88 /* Buffer until the stream is closed (only applies to write-only | |
| 89 streams). Only one call to the stream writer will be made, | |
| 90 and that is when the stream is closed. */ | |
| 91 LSTREAM_UNLIMITED | |
| 92 } Lstream_buffering; | |
| 93 | |
| 771 | 94 #if 0 |
| 95 | |
| 96 /* #### not currently implemented; correct EOF handling is quite tricky | |
| 97 in the presence of various levels of filtering streams, and simply | |
| 98 interpreting 0 as EOF works fairly well as long as the amount of | |
| 99 data you're attempting to read is large and you know whether the | |
| 100 source stream at the end of the chain is a pipe (or other blocking | |
| 101 source) or not. we really should fix this, though. */ | |
| 102 | |
| 103 /* Return values from Lstream_read(). We do NOT use the C lib trick | |
| 104 of returning 0 to maybe indicate EOF because that is simply too | |
| 105 random and error-prone. It is quite legitimate for there to be no | |
| 106 data available but no EOF, even when not in the presence of | |
| 107 non-blocking I/O. For example, decoding/encoding streams (and in | |
| 108 general, any type of filtering stream) may only be able to return | |
| 109 data after a certain amount of data on the other end is | |
| 110 available. */ | |
| 111 | |
| 112 #define LSTREAM_EOF -2 | |
| 113 | |
| 114 #endif /* 0 */ | |
| 115 | |
| 116 #define LSTREAM_ERROR -1 | |
| 117 | |
| 428 | 118 /* Methods defining how this stream works. Some may be undefined. */ |
| 119 | |
| 120 /* We do not implement the seek/tell paradigm. I tried to do that, | |
| 121 but getting the semantics right in the presence of buffering is | |
| 122 extremely tricky and very error-prone and basically not worth it. | |
| 123 This is especially the case with complicated streams like | |
| 124 decoding streams -- the seek pointer in this case can't be a single | |
| 125 integer but has to be a whole complicated structure that records | |
| 126 all of the stream's state at the time. | |
| 127 | |
| 128 Rewind semantics are generally easy to implement, so we do provide | |
| 129 a rewind method. Even rewind() may not be available on a stream, | |
| 130 however -- e.g. on process output. */ | |
| 131 | |
| 132 typedef struct lstream_implementation | |
| 133 { | |
| 442 | 134 const char *name; |
| 665 | 135 Bytecount size; /* Number of additional bytes to be |
| 814 | 136 allocated with this stream. Access this |
| 137 data using Lstream_data(). */ | |
| 1204 | 138 |
| 139 /* Description of the extra data (struct foo_lstream) attached to a | |
| 140 coding system. */ | |
| 141 const struct sized_memory_description *extra_description; | |
| 142 | |
| 428 | 143 /* Read some data from the stream's end and store it into DATA, which |
| 144 can hold SIZE bytes. Return the number of bytes read. A return | |
| 145 value of 0 means no bytes can be read at this time. This may | |
| 146 be because of an EOF, or because there is a granularity greater | |
| 147 than one byte that the stream imposes on the returned data, and | |
| 148 SIZE is less than this granularity. (This will happen frequently | |
| 149 for streams that need to return whole characters, because | |
| 150 Lstream_read() calls the reader function repeatedly until it | |
| 151 has the number of bytes it wants or until 0 is returned.) | |
| 152 The lstream functions do not treat a 0 return as EOF or do | |
| 153 anything special; however, the calling function will interpret | |
| 154 any 0 it gets back as EOF. This will normally not happen unless | |
| 155 the caller calls Lstream_read() with a very small size. | |
| 156 | |
| 157 This function can be NULL if the stream is output-only. */ | |
| 442 | 158 /* The omniscient mly, blinded by the irresistible thrall of Common |
| 428 | 159 Lisp, thinks that it is bogus that the types and implementations |
| 160 of input and output streams are the same. */ | |
| 665 | 161 Bytecount (*reader) (Lstream *stream, unsigned char *data, |
| 814 | 162 Bytecount size); |
| 428 | 163 /* Send some data to the stream's end. Data to be sent is in DATA |
| 164 and is SIZE bytes. Return the number of bytes sent. This | |
| 165 function can send and return fewer bytes than is passed in; in | |
| 166 that case, the function will just be called again until there is | |
| 167 no data left or 0 is returned. A return value of 0 means that no | |
| 168 more data can be currently stored, but there is no error; the | |
| 169 data will be squirrelled away until the writer can accept | |
| 170 data. (This is useful, e.g., of you're dealing with a | |
| 171 non-blocking file descriptor and are getting EWOULDBLOCK errors.) | |
| 172 This function can be NULL if the stream is input-only. */ | |
| 665 | 173 Bytecount (*writer) (Lstream *stream, const unsigned char *data, |
| 814 | 174 Bytecount size); |
| 428 | 175 /* Return non-zero if the last write operation on the stream resulted |
| 176 in an attempt to block (EWOULDBLOCK). If this method does not | |
| 177 exists, the implementation returns 0 */ | |
| 178 int (*was_blocked_p) (Lstream *stream); | |
| 179 /* Rewind the stream. If this is NULL, the stream is not seekable. */ | |
| 180 int (*rewinder) (Lstream *stream); | |
| 181 /* Indicate whether this stream is seekable -- i.e. it can be rewound. | |
| 182 This method is ignored if the stream does not have a rewind | |
| 183 method. If this method is not present, the result is determined | |
| 184 by whether a rewind method is present. */ | |
| 185 int (*seekable_p) (Lstream *stream); | |
| 186 /* Perform any additional operations necessary to flush the | |
| 187 data in this stream. */ | |
| 188 int (*flusher) (Lstream *stream); | |
| 771 | 189 /* Perform any additional operations necessary to close this stream down. |
| 190 May be NULL. This function is called when Lstream_close() is called | |
| 191 (which will be called automatically on any open streams when they are | |
| 192 garbage-collected or deleted with Lstream_delete()). When this | |
| 193 function is called, all pending data in the stream will already have | |
| 194 been written out; however, the closer write more data, e.g. an "end" | |
| 195 section at the end of a file. */ | |
| 428 | 196 int (*closer) (Lstream *stream); |
| 771 | 197 /* Clean up any remaining data at the time that a stream is |
| 198 garbage-collected or deleted with Lstream_delete(). If the stream was | |
| 199 open at this point, the finalizer is called after calling | |
| 200 Lstream_close(). Called only once (NOT called at disksave time). */ | |
| 201 void (*finalizer) (Lstream *stream); | |
| 428 | 202 /* Mark this object for garbage collection. Same semantics as |
| 203 a standard Lisp_Object marker. This function can be NULL. */ | |
| 204 Lisp_Object (*marker) (Lisp_Object lstream); | |
| 205 } Lstream_implementation; | |
| 206 | |
| 771 | 207 #define DEFINE_LSTREAM_IMPLEMENTATION(name, c_name) \ |
| 208 Lstream_implementation lstream_##c_name[1] = \ | |
| 1204 | 209 { { (name), sizeof (struct c_name##_stream), \ |
| 210 &lstream_empty_extra_description } } | |
| 211 | |
| 212 #define DEFINE_LSTREAM_IMPLEMENTATION_WITH_DATA(name, c_name) \ | |
| 213 static const struct sized_memory_description c_name##_lstream_description_0 \ | |
| 214 = { \ | |
| 215 sizeof (struct c_name##_stream), \ | |
| 216 c_name##_lstream_description \ | |
| 217 }; \ | |
| 218 Lstream_implementation lstream_##c_name[1] = \ | |
| 219 { { (name), sizeof (struct c_name##_stream), \ | |
| 220 &c_name##_lstream_description_0 } } | |
| 771 | 221 |
| 222 #define DECLARE_LSTREAM(c_name) \ | |
| 223 extern Lstream_implementation lstream_##c_name[] | |
| 428 | 224 |
| 225 #define LSTREAM_FL_IS_OPEN 1 | |
| 226 #define LSTREAM_FL_READ 2 | |
| 227 #define LSTREAM_FL_WRITE 4 | |
| 228 #define LSTREAM_FL_NO_PARTIAL_CHARS 8 | |
| 229 #define LSTREAM_FL_CLOSE_AT_DISKSAVE 16 | |
| 230 | |
| 231 struct lstream | |
| 232 { | |
|
5127
a9c41067dd88
more cleanups, terminology clarification, lots of doc work
Ben Wing <ben@xemacs.org>
parents:
5120
diff
changeset
|
233 NORMAL_LISP_OBJECT_HEADER header; |
| 442 | 234 const Lstream_implementation *imp; /* methods for this stream */ |
| 428 | 235 Lstream_buffering buffering; /* type of buffering in use */ |
| 665 | 236 Bytecount buffering_size; /* number of bytes buffered */ |
| 428 | 237 |
| 238 unsigned char *in_buffer; /* holds characters read from stream end */ | |
| 665 | 239 Bytecount in_buffer_size; /* allocated size of buffer */ |
| 240 Bytecount in_buffer_current; /* number of characters in buffer */ | |
| 241 Bytecount in_buffer_ind; /* pointer to next character to | |
| 462 | 242 take from buffer */ |
| 428 | 243 |
| 244 unsigned char *out_buffer; /* holds characters to write to stream end */ | |
| 665 | 245 Bytecount out_buffer_size; /* allocated size of buffer */ |
| 246 Bytecount out_buffer_ind; /* pointer to next buffer spot to | |
| 462 | 247 write a character */ |
| 428 | 248 |
| 249 /* The unget buffer is more or less a stack -- things get pushed | |
| 250 onto the end and read back from the end. Lstream_read() | |
| 251 basically reads backwards from the end to get stuff; Lstream_unread() | |
| 252 similarly has to push the data on backwards. */ | |
| 253 unsigned char *unget_buffer; /* holds characters pushed back onto input */ | |
| 665 | 254 Bytecount unget_buffer_size; /* allocated size of buffer */ |
| 255 Bytecount unget_buffer_ind; /* pointer to next buffer spot | |
| 462 | 256 to write a character */ |
| 428 | 257 |
| 665 | 258 Bytecount byte_count; |
| 456 | 259 int flags; |
| 260 max_align_t data[1]; | |
| 428 | 261 }; |
| 262 | |
| 1204 | 263 extern const struct sized_memory_description lstream_empty_extra_description; |
| 264 | |
| 428 | 265 #define LSTREAM_TYPE_P(lstr, type) \ |
| 266 ((lstr)->imp == lstream_##type) | |
| 267 | |
| 800 | 268 #ifdef ERROR_CHECK_TYPES |
| 826 | 269 DECLARE_INLINE_HEADER ( |
| 270 struct lstream * | |
| 428 | 271 error_check_lstream_type (struct lstream *stream, |
| 442 | 272 const Lstream_implementation *imp) |
| 826 | 273 ) |
| 428 | 274 { |
| 275 assert (stream->imp == imp); | |
| 276 return stream; | |
| 277 } | |
| 771 | 278 # define LSTREAM_TYPE_DATA(lstr, type) \ |
| 279 ((struct type##_stream *) \ | |
| 280 Lstream_data (error_check_lstream_type (lstr, lstream_##type))) | |
| 428 | 281 #else |
| 771 | 282 # define LSTREAM_TYPE_DATA(lstr, type) \ |
| 428 | 283 ((struct type##_stream *) Lstream_data (lstr)) |
| 284 #endif | |
| 285 | |
| 771 | 286 /* Declare that lstream-type TYPE has method M; used in initialization |
| 287 routines */ | |
| 428 | 288 #define LSTREAM_HAS_METHOD(type, m) \ |
| 289 (lstream_##type->m = type##_##m) | |
| 290 | |
| 291 | |
| 442 | 292 Lstream *Lstream_new (const Lstream_implementation *imp, |
| 293 const char *mode); | |
| 428 | 294 void Lstream_reopen (Lstream *lstr); |
| 295 void Lstream_set_buffering (Lstream *lstr, Lstream_buffering buffering, | |
| 296 int buffering_size); | |
| 297 int Lstream_flush (Lstream *lstr); | |
| 298 int Lstream_flush_out (Lstream *lstr); | |
| 299 int Lstream_fputc (Lstream *lstr, int c); | |
| 300 int Lstream_fgetc (Lstream *lstr); | |
| 301 void Lstream_fungetc (Lstream *lstr, int c); | |
| 665 | 302 Bytecount Lstream_read (Lstream *lstr, void *data, |
| 303 Bytecount size); | |
| 771 | 304 int Lstream_write (Lstream *lstr, const void *data, |
| 305 Bytecount size); | |
| 428 | 306 int Lstream_was_blocked_p (Lstream *lstr); |
| 665 | 307 void Lstream_unread (Lstream *lstr, const void *data, Bytecount size); |
| 428 | 308 int Lstream_rewind (Lstream *lstr); |
| 309 int Lstream_seekable_p (Lstream *lstr); | |
| 310 int Lstream_close (Lstream *lstr); | |
| 771 | 311 |
| 428 | 312 void Lstream_delete (Lstream *lstr); |
| 313 void Lstream_set_character_mode (Lstream *str); | |
| 771 | 314 void Lstream_unset_character_mode (Lstream *lstr); |
| 428 | 315 |
| 771 | 316 /* Lstream_putc: Write out one byte to the stream. This is a macro |
| 317 and so it is very efficient. The C argument is only evaluated once | |
| 318 but the STREAM argument is evaluated more than once. Returns 0 on | |
| 319 success, -1 on error. */ | |
| 428 | 320 |
| 771 | 321 #define Lstream_putc(stream, c) \ |
| 322 /* Call the function equivalent if the out buffer is full. Otherwise, \ | |
| 323 add to the end of the out buffer and, if line buffering is called for \ | |
| 324 and the character marks the end of a line, write out the buffer. */ \ | |
| 325 ((stream)->out_buffer_ind >= (stream)->out_buffer_size ? \ | |
| 326 Lstream_fputc (stream, c) : \ | |
| 327 ((stream)->out_buffer[(stream)->out_buffer_ind++] = \ | |
| 328 (unsigned char) (c), \ | |
| 329 (stream)->byte_count++, \ | |
| 330 (stream)->buffering == LSTREAM_LINE_BUFFERED && \ | |
| 331 (stream)->out_buffer[(stream)->out_buffer_ind - 1] == '\n' ? \ | |
| 428 | 332 Lstream_flush_out (stream) : 0)) |
| 333 | |
| 771 | 334 /* Lstream_getc: Read one byte from the stream and returns it as an |
| 335 unsigned char cast to an int, or EOF on end of file or error. This | |
| 336 is a macro and so it is very efficient. The STREAM argument is | |
| 337 evaluated more than once. */ | |
| 338 | |
| 339 #define Lstream_getc(stream) \ | |
| 340 /* Retrieve from unget buffer if there are any characters there; \ | |
| 341 else retrieve from in buffer if there's anything there; \ | |
| 342 else call the function equivalent */ \ | |
| 428 | 343 ((stream)->unget_buffer_ind > 0 ? \ |
| 344 ((stream)->byte_count++, \ | |
| 345 (stream)->unget_buffer[--(stream)->unget_buffer_ind]) : \ | |
| 346 (stream)->in_buffer_ind < (stream)->in_buffer_current ? \ | |
| 347 ((stream)->byte_count++, \ | |
| 348 (stream)->in_buffer[(stream)->in_buffer_ind++]) : \ | |
| 349 Lstream_fgetc (stream)) | |
| 350 | |
| 771 | 351 /* Lstream_ungetc: Push one byte back onto the input queue, cast to |
| 352 unsigned char. This will be the next byte read from the stream. | |
| 353 Any number of bytes can be pushed back and will be read in the | |
| 354 reverse order they were pushed back -- most recent first. (This is | |
| 355 necessary for consistency -- if there are a number of bytes that | |
| 356 have been unread and I read and unread a byte, it needs to be the | |
| 357 first to be read again.) This is a macro and so it is very | |
| 358 efficient. The C argument is only evaluated once but the STREAM | |
| 359 argument is evaluated more than once. | |
| 360 */ | |
| 361 | |
| 428 | 362 #define Lstream_ungetc(stream, c) \ |
| 771 | 363 /* Add to the end if it won't overflow buffer; otherwise call the \ |
| 364 function equivalent */ \ | |
| 428 | 365 ((stream)->unget_buffer_ind >= (stream)->unget_buffer_size ? \ |
| 366 Lstream_fungetc (stream, c) : \ | |
| 367 (void) ((stream)->byte_count--, \ | |
| 368 ((stream)->unget_buffer[(stream)->unget_buffer_ind++] = \ | |
| 369 (unsigned char) (c)))) | |
| 370 | |
| 371 #define Lstream_data(stream) ((void *) ((stream)->data)) | |
| 372 #define Lstream_byte_count(stream) ((stream)->byte_count) | |
| 373 | |
| 374 | |
| 375 /************************************************************************/ | |
| 867 | 376 /* working with an Lstream as a stream of Ichars */ |
| 428 | 377 /************************************************************************/ |
| 378 | |
| 379 #ifdef MULE | |
| 380 | |
| 826 | 381 DECLARE_INLINE_HEADER ( |
| 867 | 382 Ichar |
| 383 Lstream_get_ichar (Lstream *stream) | |
| 826 | 384 ) |
| 428 | 385 { |
| 386 int c = Lstream_getc (stream); | |
| 826 | 387 return (c < 0x80 /* c == EOF || byte_ascii_p (c) */ |
| 867 | 388 ? (Ichar) c |
| 389 : Lstream_get_ichar_1 (stream, c)); | |
| 428 | 390 } |
| 391 | |
| 867 | 392 /* Write an Ichar to a stream. Return value is 0 for success, -1 for |
| 771 | 393 failure. */ |
| 394 | |
| 826 | 395 DECLARE_INLINE_HEADER ( |
| 396 int | |
| 867 | 397 Lstream_put_ichar (Lstream *stream, Ichar ch) |
| 826 | 398 ) |
| 428 | 399 { |
| 867 | 400 return ichar_ascii_p (ch) ? |
| 428 | 401 Lstream_putc (stream, ch) : |
| 867 | 402 Lstream_fput_ichar (stream, ch); |
| 428 | 403 } |
| 404 | |
| 826 | 405 DECLARE_INLINE_HEADER ( |
| 406 void | |
| 867 | 407 Lstream_unget_ichar (Lstream *stream, Ichar ch) |
| 826 | 408 ) |
| 428 | 409 { |
| 867 | 410 if (ichar_ascii_p (ch)) |
| 428 | 411 Lstream_ungetc (stream, ch); |
| 412 else | |
| 867 | 413 Lstream_funget_ichar (stream, ch); |
| 428 | 414 } |
| 415 #else /* not MULE */ | |
| 416 | |
| 867 | 417 # define Lstream_get_ichar(stream) Lstream_getc (stream) |
| 418 # define Lstream_put_ichar(stream, ch) Lstream_putc (stream, ch) | |
| 419 # define Lstream_unget_ichar(stream, ch) Lstream_ungetc (stream, ch) | |
| 428 | 420 |
| 421 #endif /* not MULE */ | |
| 422 | |
| 423 | |
| 424 /************************************************************************/ | |
| 425 /* Lstream implementations */ | |
| 426 /************************************************************************/ | |
| 427 | |
| 428 /* Flags we can pass to the filedesc and stdio streams. */ | |
| 429 | |
| 430 /* If set, close the descriptor or FILE * when the stream is closed. */ | |
| 431 #define LSTR_CLOSING 1 | |
| 432 | |
| 433 /* If set, allow quitting out of the actual I/O. */ | |
| 434 #define LSTR_ALLOW_QUIT 2 | |
| 435 | |
| 436 /* If set and filedesc_stream_set_pty_flushing() has been called | |
| 437 on the stream, do not send more than pty_max_bytes on a single | |
| 438 line without flushing the data out using the eof_char. */ | |
| 439 #define LSTR_PTY_FLUSHING 4 | |
| 440 | |
| 441 /* If set, an EWOULDBLOCK error is not treated as an error but | |
| 442 simply causes the write function to return 0 as the number | |
| 443 of bytes written out. */ | |
| 444 #define LSTR_BLOCKED_OK 8 | |
| 445 | |
| 446 Lisp_Object make_stdio_input_stream (FILE *stream, int flags); | |
| 447 Lisp_Object make_stdio_output_stream (FILE *stream, int flags); | |
| 448 Lisp_Object make_filedesc_input_stream (int filedesc, int offset, int count, | |
| 449 int flags); | |
| 450 Lisp_Object make_filedesc_output_stream (int filedesc, int offset, int count, | |
| 451 int flags); | |
| 452 void filedesc_stream_set_pty_flushing (Lstream *stream, | |
| 453 int pty_max_bytes, | |
| 867 | 454 Ibyte eof_char); |
| 428 | 455 int filedesc_stream_fd (Lstream *stream); |
| 456 Lisp_Object make_lisp_string_input_stream (Lisp_Object string, | |
| 457 Bytecount offset, | |
| 458 Bytecount len); | |
| 462 | 459 Lisp_Object make_fixed_buffer_input_stream (const void *buf, |
| 665 | 460 Bytecount size); |
| 462 | 461 Lisp_Object make_fixed_buffer_output_stream (void *buf, |
| 665 | 462 Bytecount size); |
| 442 | 463 const unsigned char *fixed_buffer_input_stream_ptr (Lstream *stream); |
| 428 | 464 unsigned char *fixed_buffer_output_stream_ptr (Lstream *stream); |
| 465 Lisp_Object make_resizing_buffer_output_stream (void); | |
| 466 unsigned char *resizing_buffer_stream_ptr (Lstream *stream); | |
| 788 | 467 Lisp_Object resizing_buffer_to_lisp_string (Lstream *stream); |
| 428 | 468 Lisp_Object make_dynarr_output_stream (unsigned_char_dynarr *dyn); |
| 469 #define LSTR_SELECTIVE 1 | |
| 470 #define LSTR_IGNORE_ACCESSIBLE 2 | |
| 665 | 471 Lisp_Object make_lisp_buffer_input_stream (struct buffer *buf, Charbpos start, |
| 472 Charbpos end, int flags); | |
| 473 Lisp_Object make_lisp_buffer_output_stream (struct buffer *buf, Charbpos pos, | |
| 428 | 474 int flags); |
| 665 | 475 Charbpos lisp_buffer_stream_startpos (Lstream *stream); |
| 428 | 476 |
| 440 | 477 #endif /* INCLUDED_lstream_h_ */ |