Mercurial > hg > xemacs-beta
view lisp/mule/viet-util.el @ 4677:8f1ee2d15784
Support full Common Lisp multiple values in C.
lisp/ChangeLog
2009-08-11 Aidan Kehoe <kehoea@parhasard.net>
* bytecomp.el :
Update this file to support full C-level multiple values. This
involves:
-- Four new bytecodes, and special compiler functions to compile
multiple-value-call, multiple-value-list-internal, values,
values-list, and, since it now needs to pass back multiple values
and is a special form, throw.
-- There's a new compiler variable, byte-compile-checks-on-load,
which is a list of forms that are evaluated at the very start of a
file, with an error thrown if any of them give nil.
-- The header is now inserted *after* compilation, giving a chance
for the compilation process to influence what those checks
are. There is still a check done before compilation for non-ASCII
characters, to try to turn off dynamic docstrings if appopriate,
in `byte-compile-maybe-reset-coding'.
Space is reserved for checks; comments describing the version of
the byte compiler generating the file are inserted if space
remains for them.
* bytecomp.el (byte-compile-version):
Update this, we're a newer version of the byte compiler.
* byte-optimize.el (byte-optimize-funcall):
Correct a comment.
* bytecomp.el (byte-compile-lapcode):
Discard the arg with byte-multiple-value-call.
* bytecomp.el (byte-compile-checks-and-comments-space):
New variable, describe how many octets to reserve for checks at
the start of byte-compiled files.
* cl-compat.el:
Remove the fake multiple-value implementation. Have the functions
that use it use the real multiple-value implementation instead.
* cl-macs.el (cl-block-wrapper, cl-block-throw):
Revise the byte-compile properties of these symbols to work now
we've made throw into a special form; keep the byte-compile
properties as anonymous lambdas, since we don't have docstrings
for them.
* cl-macs.el (multiple-value-bind, multiple-value-setq)
(multiple-value-list, nth-value):
Update these functions to work with the C support for multiple
values.
* cl-macs.el (values):
Modify the setf handler for this to call
#'multiple-value-list-internal appropriately.
* cl-macs.el (cl-setf-do-store):
If the store form is a cons, treat it specially as wrapping the
store value.
* cl.el (cl-block-wrapper):
Make this an alias of #'and, not #'identity, since it needs to
pass back multiple values.
* cl.el (multiple-value-apply):
We no longer support this, mark it obsolete.
* lisp-mode.el (eval-interactive-verbose):
Remove a useless space in the docstring.
* lisp-mode.el (eval-interactive):
Update this function and its docstring. It now passes back a list,
basically wrapping any eval calls with multiple-value-list. This
allows multiple values to be printed by default in *scratch*.
* lisp-mode.el (prin1-list-as-multiple-values):
New function, printing a list as multiple values in the manner of
Bruno Haible's clisp, separating each entry with " ;\n".
* lisp-mode.el (eval-last-sexp):
Call #'prin1-list-as-multiple-values on the return value of
#'eval-interactive.
* lisp-mode.el (eval-defun):
Call #'prin1-list-as-multiple-values on the return value of
#'eval-interactive.
* mouse.el (mouse-eval-sexp):
Deal with lists corresponding to multiple values from
#'eval-interactive. Call #'cl-prettyprint, which is always
available, instead of sometimes calling #'pprint and sometimes
falling back to prin1.
* obsolete.el (obsolete-throw):
New function, called from eval.c when #'funcall encounters an
attempt to call #'throw (now a special form) as a function. Only
needed for compatibility with 21.4 byte-code.
man/ChangeLog addition:
2009-08-11 Aidan Kehoe <kehoea@parhasard.net>
* cl.texi (Organization):
Remove references to the obsolete multiple-value emulating code.
src/ChangeLog addition:
2009-08-11 Aidan Kehoe <kehoea@parhasard.net>
* bytecode.c (enum Opcode /* Byte codes */):
Add four new bytecodes, to deal with multiple values.
(POP_WITH_MULTIPLE_VALUES): New macro.
(POP): Modify this macro to ignore multiple values.
(DISCARD_PRESERVING_MULTIPLE_VALUES): New macro.
(DISCARD): Modify this macro to ignore multiple values.
(TOP_WITH_MULTIPLE_VALUES): New macro.
(TOP_ADDRESS): New macro.
(TOP): Modify this macro to ignore multiple values.
(TOP_LVALUE): New macro.
(Bcall): Ignore multiple values where appropriate.
(Breturn): Pass back multiple values.
(Bdup): Preserve multiple values.
Use TOP_LVALUE with most bytecodes that assign anything to
anything.
(Bbind_multiple_value_limits, Bmultiple_value_call,
Bmultiple_value_list_internal, Bthrow): Implement the new
bytecodes.
(Bgotoifnilelsepop, Bgotoifnonnilelsepop, BRgotoifnilelsepop,
BRgotoifnonnilelsepop):
Discard any multiple values.
* callint.c (Fcall_interactively):
Ignore multiple values when calling #'eval, in two places.
* device-x.c (x_IO_error_handler):
* macros.c (pop_kbd_macro_event):
* eval.c (Fsignal):
* eval.c (flagged_a_squirmer):
Call throw_or_bomb_out, not Fthrow, now that the latter is a
special form.
* eval.c:
Make Qthrow, Qobsolete_throw available as symbols.
Provide multiple_value_current_limit, multiple-values-limit (the
latter as specified by Common Lisp.
* eval.c (For):
Ignore multiple values when comparing with Qnil, but pass any
multiple values back for the last arg.
* eval.c (Fand):
Ditto.
* eval.c (Fif):
Ignore multiple values when examining the result of the
condition.
* eval.c (Fcond):
Ignore multiple values when comparing what the clauses give, but
pass them back if a clause gave non-nil.
* eval.c (Fprog2):
Never pass back multiple values.
* eval.c (FletX, Flet):
Ignore multiple when evaluating what exactly symbols should be
bound to.
* eval.c (Fwhile):
Ignore multiple values when evaluating the test.
* eval.c (Fsetq, Fdefvar, Fdefconst):
Ignore multiple values.
* eval.c (Fthrow):
Declare this as a special form; ignore multiple values for TAG,
preserve them for VALUE.
* eval.c (throw_or_bomb_out):
Make this available to other files, now Fthrow is a special form.
* eval.c (Feval):
Ignore multiple values when calling a compiled function, a
non-special-form subr, or a lambda expression.
* eval.c (Ffuncall):
If we attempt to call #'throw (now a special form) as a function,
don't error, call #'obsolete-throw instead.
* eval.c (make_multiple_value, multiple_value_aset)
(multiple_value_aref, print_multiple_value, mark_multiple_value)
(size_multiple_value):
Implement the multiple_value type. Add a long comment describing
our implementation.
* eval.c (bind_multiple_value_limits):
New function, used by the bytecode and by #'multiple-value-call,
#'multiple-value-list-internal.
* eval.c (multiple_value_call):
New function, used by the bytecode and #'multiple-value-call.
* eval.c (Fmultiple_value_call):
New special form.
* eval.c (multiple_value_list_internal):
New function, used by the byte code and
#'multiple-value-list-internal.
* eval.c (Fmultiple_value_list_internal, Fmultiple_value_prog1):
New special forms.
* eval.c (Fvalues, Fvalues_list):
New Lisp functions.
* eval.c (values2):
New function, for C code returning multiple values.
* eval.c (syms_of_eval):
Make our new Lisp functions and symbols available.
* eval.c (multiple-values-limit):
Make this available to Lisp.
* event-msw.c (dde_eval_string):
* event-stream.c (execute_help_form):
* glade.c (connector):
* glyphs-widget.c (glyph_instantiator_to_glyph):
* glyphs.c (evaluate_xpm_color_symbols):
* gui-x.c (wv_set_evalable_slot, button_item_to_widget_value):
* gui.c (gui_item_value, gui_item_display_flush_left):
* lread.c (check_if_suppressed):
* menubar-gtk.c (menu_convert, menu_descriptor_to_widget_1):
* menubar-msw.c (populate_menu_add_item):
* print.c (Fwith_output_to_temp_buffer):
* symbols.c (Fsetq_default):
Ignore multiple values when calling Feval.
* symeval.h:
Add the header declarations necessary for the multiple-values
implementation.
* inline.c:
#include symeval.h, now that it has some inline functions.
* lisp.h:
Update Fthrow's declaration. Make throw_or_bomb_out available to
all files.
* lrecord.h (enum lrecord_type):
Add the multiple_value type here.
| author | Aidan Kehoe <kehoea@parhasard.net> |
|---|---|
| date | Sun, 16 Aug 2009 20:55:49 +0100 |
| parents | aa28d959af41 |
| children | f00192e1cd49 308d34e9f07d |
line wrap: on
line source
;;; viet-util.el --- utilities for Vietnamese -*- coding: iso-2022-7bit; -*- ;; Copyright (C) 1995 Electrotechnical Laboratory, JAPAN. ;; Copyright (C) 2002 Ben Wing. ;; Licensed to the Free Software Foundation. ;; Keywords: mule, multilingual, Vietnamese ;; 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 Free Software Foundation; either version 2, or (at your option) ;; any later version. ;; XEmacs is distributed in the hope that it will be useful, but ;; WITHOUT ANY WARRANTY; without even the implied warranty of ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ;; General Public License for more details. ;; You should have received a copy of the GNU General Public License ;; along with XEmacs; see the file COPYING. If not, write to the Free ;; Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA ;; 02111-1307, USA. ;;; Synched up with: Emacs 21.1 (language/viet-util.el). ;;; Commentary: ;; Vietnamese uses ASCII characters and additional 134 unique ;; characters (these are Latin alphabets with various diacritical and ;; tone marks). As far as I know, Vietnamese now has 4 different ways ;; for representing these characters: VISCII, VSCII, VIQR, and ;; Unicode. VISCII and VSCII are simple 1-byte code which assigns 134 ;; unique characters in control-code area (0x00..0x1F) and right half ;; area (0x80..0xFF). VIQR is a menmonic encoding specification ;; representing diacritical marks by following ASCII characters. ;;; Code: ;;;###autoload (defun viet-encode-viscii-char (char) "Return VISCII character code of CHAR if appropriate." (check-argument-type #'characterp char) (if (eq char ?~) char (setq char (encode-coding-string char 'viscii)) (if (and (= 1 (length char)) (not (eq (aref char 0) ?~))) (aref char 0)))) ;; VIQR is a menmonic encoding specification for Vietnamese. ;; It represents diacritical marks by ASCII characters as follows: ;; ------------+----------+-------- ;; mark | mnemonic | example ;; ------------+----------+--------- ;; breve | ( | a( -> ,1e(B ;; circumflex | ^ | a^ -> ,1b(B ;; horn | + | o+ -> ,1=(B ;; ------------+----------+--------- ;; acute | ' | a' -> ,1a(B ;; grave | ` | a` -> ,1`(B ;; hook above | ? | a? -> ,1d(B ;; tilde | ~ | a~ -> ,1c(B ;; dot below | . | a. -> ,1U(B ;; ------------+----------+--------- ;; d bar | dd | dd -> ,1p(B ;; ------------+----------+--------- (defvar viet-viqr-alist '(;; lowercase (?,1!(B . "a('") ; 161 (?,1"(B . "a(`") ; 162 (?,1#(B . "a(.") ; 163 (?,1$(B . "a^'") ; 164 (?,1%(B . "a^`") ; 165 (?,1&(B . "a^?") ; 166 (?,1'(B . "a^.") ; 167 (?,1((B . "e~") ; 168 (?,1)(B . "e.") ; 169 (?,1*(B . "e^'") ; 170 (?,1+(B . "e^`") ; 171 (?,1,(B . "e^?") ; 172 (?,1-(B . "e^~") ; 173 (?,1.(B . "e^.") ; 174 (?,1/(B . "o^'") ; 175 (?,10(B . "o^`") ; 176 (?,11(B . "o^?") ; 177 (?,12(B . "o^~") ; 178 (?,15(B . "o^.") ; 181 (?,16(B . "o+`") ; 182 (?,17(B . "o+?") ; 183 (?,18(B . "i.") ; 184 (?,1=(B . "o+") ; 189 (?,1>(B . "o+'") ; 190 (?,1F(B . "a(?") ; 198 (?,1G(B . "a(~") ; 199 (?,1O(B . "y`") ; 207 (?,1Q(B . "u+'") ; 209 (?,1U(B . "a.") ; 213 (?,1V(B . "y?") ; 214 (?,1W(B . "u+`") ; 215 (?,1X(B . "u+?") ; 216 (?,1[(B . "y~") ; 219 (?,1\(B . "y.") ; 220 (?,1^(B . "o+~") ; 222 (?,1_(B . "u+") ; 223 (?,1`(B . "a`") ; 224 (?,1a(B . "a'") ; 225 (?,1b(B . "a^") ; 226 (?,1c(B . "a~") ; 227 (?,1d(B . "a?") ; 228 (?,1e(B . "a(") ; 229 (?,1f(B . "u+~") ; 230 (?,1g(B . "a^~") ; 231 (?,1h(B . "e`") ; 232 (?,1i(B . "e'") ; 233 (?,1j(B . "e^") ; 234 (?,1k(B . "e?") ; 235 (?,1l(B . "i`") ; 236 (?,1m(B . "i'") ; 237 (?,1n(B . "i~") ; 238 (?,1o(B . "i?") ; 239 (?,1p(B . "dd") ; 240 (?,1q(B . "u+.") ; 241 (?,1r(B . "o`") ; 242 (?,1s(B . "o'") ; 243 (?,1t(B . "o^") ; 244 (?,1u(B . "o~") ; 245 (?,1v(B . "o?") ; 246 (?,1w(B . "o.") ; 247 (?,1x(B . "u.") ; 248 (?,1y(B . "u`") ; 249 (?,1z(B . "u'") ; 250 (?,1{(B . "u~") ; 251 (?,1|(B . "u?") ; 252 (?,1}(B . "y'") ; 253 (?,1~(B . "o+.") ; 254 ;; upper case (?,2!(B . "A('") ; 161 (?,2"(B . "A(`") ; 162 (?,2#(B . "A(.") ; 163 (?,2$(B . "A^'") ; 164 (?,2%(B . "A^`") ; 165 (?,2&(B . "A^?") ; 166 (?,2'(B . "A^.") ; 167 (?,2((B . "E~") ; 168 (?,2)(B . "E.") ; 169 (?,2*(B . "E^'") ; 170 (?,2+(B . "E^`") ; 171 (?,2,(B . "E^?") ; 172 (?,2-(B . "E^~") ; 173 (?,2.(B . "E^.") ; 174 (?,2/(B . "O^'") ; 175 (?,20(B . "O^`") ; 176 (?,21(B . "O^?") ; 177 (?,22(B . "O^~") ; 178 (?,25(B . "O^.") ; 181 (?,26(B . "O+`") ; 182 (?,27(B . "O+?") ; 183 (?,28(B . "I.") ; 184 (?,2=(B . "O+") ; 189 (?,2>(B . "O+'") ; 190 (?,2F(B . "A(?") ; 198 (?,2G(B . "A(~") ; 199 (?,2O(B . "Y`") ; 207 (?,2Q(B . "U+'") ; 209 (?,2U(B . "A.") ; 213 (?,2V(B . "Y?") ; 214 (?,2W(B . "U+`") ; 215 (?,2X(B . "U+?") ; 216 (?,2[(B . "Y~") ; 219 (?,2\(B . "Y.") ; 220 (?,2^(B . "O+~") ; 222 (?,2_(B . "U+") ; 223 (?,2`(B . "A`") ; 224 (?,2a(B . "A'") ; 225 (?,2b(B . "A^") ; 226 (?,2c(B . "A~") ; 227 (?,2d(B . "A?") ; 228 (?,2e(B . "A(") ; 229 (?,2f(B . "U+~") ; 230 (?,2g(B . "A^~") ; 231 (?,2h(B . "E`") ; 232 (?,2i(B . "E'") ; 233 (?,2j(B . "E^") ; 234 (?,2k(B . "E?") ; 235 (?,2l(B . "I`") ; 236 (?,2m(B . "I'") ; 237 (?,2n(B . "I~") ; 238 (?,2o(B . "I?") ; 239 (?,2p(B . "DD") ; 240 (?,2p(B . "dD") ; 240 (?,2p(B . "Dd") ; 240 (?,2q(B . "U+.") ; 241 (?,2r(B . "O`") ; 242 (?,2s(B . "O'") ; 243 (?,2t(B . "O^") ; 244 (?,2u(B . "O~") ; 245 (?,2v(B . "O?") ; 246 (?,2w(B . "O.") ; 247 (?,2x(B . "U.") ; 248 (?,2y(B . "U`") ; 249 (?,2z(B . "U'") ; 250 (?,2{(B . "U~") ; 251 (?,2|(B . "U?") ; 252 (?,2}(B . "Y'") ; 253 (?,2~(B . "O+.") ; 254 ;; escape from composition (?\( . "\\(") ; breve (left parenthesis) (?^ . "\\^") ; circumflex (caret) (?+ . "\\+") ; horn (plus sign) (?' . "\\'") ; acute (apostrophe) (?` . "\\`") ; grave (backquote) (?? . "\\?") ; hook above (question mark) (?~ . "\\~") ; tilde (tilde) (?. . "\\.") ; dot below (period) (?d . "\\d") ; d-bar (d) (?\\ . "\\\\") ; literal backslash ) "Alist of Vietnamese characters vs corresponding `VIQR' string.") ;; Regular expression matching single Vietnamese character represented ;; by VIQR. (defconst viqr-regexp "[aeiouyAEIOUY]\\([(^+]?['`?~.]\\|[(^+]\\)\\|[Dd][Dd]") ;;;###autoload (defun viet-decode-viqr-region (from to) "Convert `VIQR' mnemonics of the current region to Vietnamese characters. When called from a program, expects two arguments, positions (integers or markers) specifying the stretch of the region." (interactive "r") (save-restriction (narrow-to-region from to) (goto-char (point-min)) (while (re-search-forward viqr-regexp nil t) (let* ((viqr (buffer-substring (match-beginning 0) (match-end 0))) (ch (car (rassoc viqr viet-viqr-alist)))) (if ch (progn (delete-region (match-beginning 0) (match-end 0)) (insert ch))))))) ;;;###autoload (defun viet-decode-viqr-buffer () "Convert `VIQR' mnemonics of the current buffer to Vietnamese characters." (interactive) (viet-decode-viqr-region (point-min) (point-max))) ;;;###autoload (defun viet-encode-viqr-region (from to) "Convert Vietnamese characters of the current region to `VIQR' mnemonics. When called from a program, expects two arguments, positions (integers or markers) specifying the stretch of the region." (interactive "r") (save-restriction (narrow-to-region from to) (goto-char (point-min)) (while (re-search-forward "\\cv" nil t) (let* ((ch (preceding-char)) (viqr (cdr (assq ch viet-viqr-alist)))) (if viqr (progn (delete-char -1) (insert viqr))))))) ;;;###autoload (defun viet-encode-viqr-buffer () "Convert Vietnamese characters of the current buffer to `VIQR' mnemonics." (interactive) (viet-encode-viqr-region (point-min) (point-max))) ;;;###autoload (defun viqr-post-read-conversion (len) (save-excursion (save-restriction (narrow-to-region (point) (+ (point) len)) (let ((buffer-modified-p (buffer-modified-p))) (viet-decode-viqr-region (point-min) (point-max)) (set-buffer-modified-p buffer-modified-p) (- (point-max) (point-min)))))) ;;;###autoload (defun viqr-pre-write-conversion (from to) (let ((old-buf (current-buffer))) (set-buffer (generate-new-buffer " *temp*")) (if (stringp from) (insert from) (insert-buffer-substring old-buf from to)) (viet-encode-viqr-region (point-min) (point-max)) ;; Should return nil as annotations. nil)) ;;; (provide 'viet-util) ;;; viet-util.el ends here