+1998-10-14 Tanaka Akira <akr@jaist.ac.jp>
+
+ * Sync up to flim-1_10_5 from flim-1_10_2.
+
+ * mime-def.el (mime-library-product): Bump up to FLAM-DOODLE
+ 1.10.2.
+
1998-10-09 Tanaka Akira <akr@jaist.ac.jp>
* mime-def.el (mime-library-product): Fix typo.
* eword-decode.el: Copied from AKEMI branch of SEMI.
\f
+1998-10-14 MORIOKA Tomohiko <morioka@jaist.ac.jp>
+
+ * FLIM: Version 1.10.5 (Kizugawadai) was released.
+
+ * mel.el: Must require poem.
+
+\f
+1998-10-12 MORIOKA Tomohiko <morioka@jaist.ac.jp>
+
+ * FLIM: Version 1.10.4 (Shin-H\e-Dòsono)\e-A was released.
+
+1998-10-12 Katsumi Yamaoka <yamaoka@jpl.org>
+
+ * README.en: Add explanation about `VERSION_SPECIFIC_LISPDIR'.
+
+ * Makefile (install): Add new arg `VERSION_SPECIFIC_LISPDIR'.
+ (elc): Likewise.
+
+ * FLIM-MK (config-flim): Refer to `VERSION_SPECIFIC_LISPDIR'.
+
+ * FLIM-CFG (VERSION_SPECIFIC_LISPDIR): New variable.
+
+1998-10-12 MORIOKA Tomohiko <morioka@jaist.ac.jp>
+
+ * mel.el (mel-ccl-module): Require path-util when the running
+ emacs has MULE.
+
+ * mel.el: Don't require emu.
+
+1998-10-11 MORIOKA Tomohiko <morioka@jaist.ac.jp>
+
+ * FLIM-ELS: Don't install mel-ccl in anything older than XEmacs 21
+ with MULE.
+
+\f
+1998-10-10 MORIOKA Tomohiko <morioka@jaist.ac.jp>
+
+ * FLIM: Version 1.10.3 (Komada) was released.
+
+ * mel-ccl.el (base64-ccl-write-decoded-region): bind
+ `jka-compr-compression-info-list' with nil.
+
+ * mel-b.el (base64-internal-decoding-limit): Switch default value
+ between XEmacs-mule and other emacsen.
+ Abolish function `base64-decode-string!'.
+ (base64-internal-decode-region): New implementation.
+ (base64-insert-encoded-file): New function.
+ (mime-insert-encoded-file): Use `base64-insert-encoded-file'.
+ (base64-write-decoded-region): New function.
+ (mime-write-decoded-region): Use `base64-write-decoded-region'.
+
+ * mel-b-dl.el (decode-base64-region): Renamed from
+ `base64-decode-region'.
+ (mime-insert-encoded-file): Change temporary-buffer to unibyte
+ representation. Abolish method `mime-write-decoded-region'
+ because it is slower than CCL based implementation.
+
+1998-10-09 Tanaka Akira <akr@jaist.ac.jp>
+
+ * mel-ccl.el: Check `ccl-execute-eof-block-on-decoding-some'
+ facility instead of `ccl-execute-eof-block-on-encoding-some'.
+
+1998-10-09 MORIOKA Tomohiko <morioka@jaist.ac.jp>
+
+ * mel-b.el (base64-characters): Enclose with `eval-and-compile'.
+
+ * eword-decode.el (eword-encoded-text-regexp): Enclose with
+ `eval-and-compile'.
+ (eword-encoded-word-regexp): Use `eval-when-compile'.
+
+1998-10-09 MORIOKA Tomohiko <morioka@jaist.ac.jp>
+
+ * eword-decode.el (eword-max-size-to-decode): New user option.
+ (eword-decode-and-fold-structured-field): Do nothing if size of
+ input is bigger than `eword-max-size-to-decode'.
+
+1998-10-08 MORIOKA Tomohiko <morioka@jaist.ac.jp>
+
+ * mel-b.el (base64-numbers): Use `eval-when-compile'.
+
+1998-10-09 Katsumi Yamaoka <yamaoka@jpl.org>
+
+ * FLIM-CFG: Use `add-latest-path' instead of `add-path' for adding
+ "custom" to load-path.
+
+1998-10-09 Katsumi Yamaoka <yamaoka@jpl.org>
+
+ * mime-def.el (mime-library-product): Enclose with
+ `eval-and-compile'.
+
+ * FLIM-CFG: Add "custom" to load-path.
+
+\f
1998-10-08 MORIOKA Tomohiko <morioka@jaist.ac.jp>
* FLIM: Version 1.10.2 (Kintetsu-Miyazu) was released.
15 \e$B?<;Y;R\e(B \e$B$3$-$/$A$J$7\e(B 10YR7.5/8.0 FLAM-DOODLE 1.9.5
16 \e$B4;;R\e(B \e$B$3$&$8\e(B 7.5YR7.0/11.0 FLAM-DOODLE 1.10.0
17 \e$B5`MU\e(B \e$B$/$A$P\e(B 10YR7.5/10.0 FLAM-DOODLE 1.10.1
- 18 \e$B@VGrFK\e(B \e$B$"$+$7$m$D$k$P$_\e(B 5.0YR8.0/6.0
+ 18 \e$B@VGrFK\e(B \e$B$"$+$7$m$D$k$P$_\e(B 5.0YR8.0/6.0 FLAM-DOODLE 1.10.2
19 \e$B>.F&\e(B \e$B$"$:$-\e(B 2.5R3.5/5.0
20 \e$BIrF:Cc\e(B \e$B$($S$A$c\e(B 5.0R4.0/11.0
21 \e$B??<k\e(B \e$B$7$s$7$e\e(B 2.5R4.5/10.0
(add-to-list 'load-path (expand-file-name "apel" LISPDIR))
))
+(defvar VERSION_SPECIFIC_LISPDIR nil)
+
+(if VERSION_SPECIFIC_LISPDIR
+ (add-to-list 'load-path VERSION_SPECIFIC_LISPDIR))
+
(require 'install)
+(add-latest-path "custom")
+
(add-path default-directory)
(or (fboundp 'write-region-as-binary)
)
(if (and (featurep 'mule)
- (not (and (boundp 'MULE) MULE)))
+ (not (or (and (boundp 'MULE) MULE)
+ (and (featurep 'xemacs) (< emacs-major-version 21))
+ )))
(setq flim-modules (cons 'mel-ccl flim-modules))
)
;;; -*-Emacs-Lisp-*-
;;;
-;;; $Id: FLIM-MK,v 1.1.16.1 1998-09-15 08:16:45 akr Exp $
+;;; $Id: FLIM-MK,v 1.1.16.2 1998-10-14 12:40:10 akr Exp $
;;;
(defun config-flim ()
- (let (prefix lisp-dir)
+ (let (prefix lisp-dir version-specific-lisp-dir)
(and (setq prefix (car command-line-args-left))
(or (string-equal "NONE" prefix)
(defvar PREFIX prefix)
(defvar LISPDIR lisp-dir)
))
(setq command-line-args-left (cdr command-line-args-left))
+ (and (setq version-specific-lisp-dir (car command-line-args-left))
+ (or (string-equal "NONE" version-specific-lisp-dir)
+ (progn
+ (defvar VERSION_SPECIFIC_LISPDIR version-specific-lisp-dir)
+ (princ (format "VERSION_SPECIFIC_LISPDIR=%s\n"
+ VERSION_SPECIFIC_LISPDIR)))
+ ))
+ (setq command-line-args-left (cdr command-line-args-left))
(load-file "FLIM-CFG")
(load-file "FLIM-ELS")
(princ (format "PREFIX=%s
1.10.0 K\e-Dòdo\e-A \e$(B6=8M\e(B
1.10.1 Miyamaki \e$(B;0;3LZ\e(B
1.10.2 Kintetsu-Miyazu \e$(B6aE45\DE\e(B
------ Komada \e$(B9}ED\e(B
------ Shin-H\e-Dòsono\e-A \e$(B?7=K1`\e(B ; <=> JR \e$(BJRD.@~\e(B \e$(B=K1`\e(B
------ Kizugawadai \e$(BLZDE@nBf\e(B
+1.10.3 Komada \e$(B9}ED\e(B
+1.10.4 Shin-H\e-Dòsono\e-A \e$(B?7=K1`\e(B ; <=> JR \e$(BJRD.@~\e(B \e$(B=K1`\e(B
+1.10.5 Kizugawadai \e$(BLZDE@nBf\e(B
----- Yamadagawa \e$(B;3ED@n\e(B
----- Takanohara \e$(B9b$N86\e(B
----- Heij\e-Dò\e-A \e$(BJ?>k\e(B
#
PACKAGE = flim
-VERSION = 1.10.2
+VERSION = 1.10.5
TAR = tar
RM = /bin/rm -f
PREFIX = NONE
LISPDIR = NONE
PACKAGEDIR = NONE
+VERSION_SPECIFIC_LISPDIR = NONE
GOMI = *.elc \
*.cp *.cps *.ky *.kys *.fn *.fns *.vr *.vrs \
elc: ew-parse.el
- $(EMACS) $(FLAGS) -l FLIM-MK -f compile-flim $(PREFIX) $(LISPDIR)
+ $(EMACS) $(FLAGS) -l FLIM-MK -f compile-flim $(PREFIX) $(LISPDIR) \
+ $(VERSION_SPECIFIC_LISPDIR)
install: elc
- $(EMACS) $(FLAGS) -l FLIM-MK -f install-flim $(PREFIX) $(LISPDIR)
+ $(EMACS) $(FLAGS) -l FLIM-MK -f install-flim $(PREFIX) $(LISPDIR) \
+ $(VERSION_SPECIFIC_LISPDIR)
package:
sed "s/VERSION/$(VERSION)/" < ftp.in > ftp
release:
- -$(RM) /pub/GNU/elisp/apel/$(PACKAGE)-$(VERSION).tar.gz
+ -$(RM) /pub/GNU/elisp/flim/$(PACKAGE)-$(VERSION).tar.gz
mv /tmp/$(PACKAGE)-$(VERSION).tar.gz /pub/GNU/elisp/flim/
cd /pub/GNU/elisp/semi/ ; \
ln -s ../flim/$(PACKAGE)-$(VERSION).tar.gz .
emacs command is used (perhaps /usr/local/share/emacs/site-lisp or
/usr/local/lib/xemacs/site-lisp).
+ If the emu modules (included in APEL package) have been installed in
+ the non-standard directory, you should specify where they will be
+ found, for example:
+
+ % make install VERSION_SPECIFIC_LISPDIR=~/elisp
+
You can specify other optional settings by editing the file
FLIM-CFG. Please read comments in it.
:group 'eword-decode
:type 'boolean)
+(defcustom eword-max-size-to-decode 1000
+ "*Max size to decode header field."
+ :group 'eword-decode
+ :type '(choice (integer :tag "Limit (bytes)")
+ (const :tag "Don't limit" nil)))
+
;;; @ MIME encoded-word definition
;;;
code-conversion
must-unfold))
+(defun eword-decode-and-fold-structured-field
+ (string start-column &optional max-column must-unfold)
+ "Decode and fold (fill) STRING as structured field body.
+It decodes non us-ascii characters in FULL-NAME encoded as
+encoded-words or invalid \"raw\" string. \"Raw\" non us-ascii
+characters are regarded as variable `default-mime-charset'.
+
+If an encoded-word is broken or your emacs implementation can not
+decode the charset included in it, it is not decoded.
+
+If MAX-COLUMN is omitted, `fill-column' is used.
+
+If MUST-UNFOLD is non-nil, it unfolds and eliminates line-breaks even
+if there are in decoded encoded-words (generated by bad manner MUA
+such as a version of Net$cape)."
+ (rotate-memo args-eword-decode-and-fold-structured-field
+ (list string start-column max-column must-unfold))
+ (or max-column
+ (setq max-column fill-column))
+ (let* ((field-name (make-string (1- start-column) ?X))
+ (field-body (ew-lf-crlf-to-crlf string))
+ (ew-decode-field-default-syntax '(ew-scan-unibyte-std11))
+ (decoded (ew-decode-field field-name field-body)))
+ (unless (equal field-body decoded)
+ (setq decoded (ew-crlf-refold decoded start-column max-column)))
+ (ew-crlf-to-lf decoded)))
+
+(defun eword-decode-and-unfold-structured-field (string)
+ "Decode and unfold STRING as structured field body.
+It decodes non us-ascii characters in FULL-NAME encoded as
+encoded-words or invalid \"raw\" string. \"Raw\" non us-ascii
+characters are regarded as variable `default-mime-charset'.
+
+If an encoded-word is broken or your emacs implementation can not
+decode the charset included in it, it is not decoded."
+ (rotate-memo args-eword-decode-and-unfold-structured-field (list string))
+ (let* ((ew-decode-field-default-syntax '(ew-scan-unibyte-std11))
+ (decoded (ew-decode-field "" (ew-lf-crlf-to-crlf string))))
+ (ew-crlf-to-lf (ew-crlf-unfold decoded))))
+
+(defun eword-decode-structured-field-body (string &optional must-unfold
+ start-column max-column)
+ "Decode non us-ascii characters in STRING as structured field body.
+STRING is unfolded before decoding.
+
+It decodes non us-ascii characters in FULL-NAME encoded as
+encoded-words or invalid \"raw\" string. \"Raw\" non us-ascii
+characters are regarded as variable `default-mime-charset'.
+
+If an encoded-word is broken or your emacs implementation can not
+decode the charset included in it, it is not decoded.
+
+If MUST-UNFOLD is non-nil, it unfolds and eliminates line-breaks even
+if there are in decoded encoded-words (generated by bad manner MUA
+such as a version of Net$cape)."
+ (rotate-memo args-eword-decode-structured-field-body
+ (list string must-unfold start-column max-column))
+ (if start-column
+ ;; fold with max-column
+ (eword-decode-and-fold-structured-field
+ string start-column max-column must-unfold)
+ ;; Don't fold
+ (let* ((ew-decode-field-default-syntax '(ew-scan-unibyte-std11))
+ (decoded (ew-decode-field "" (ew-lf-crlf-to-crlf string))))
+ (ew-crlf-to-lf decoded))))
+
+(defun eword-decode-unstructured-field-body (string &optional must-unfold)
+ "Decode non us-ascii characters in STRING as unstructured field body.
+STRING is unfolded before decoding.
+
+It decodes non us-ascii characters in FULL-NAME encoded as
+encoded-words or invalid \"raw\" string. \"Raw\" non us-ascii
+characters are regarded as variable `default-mime-charset'.
+
+If an encoded-word is broken or your emacs implementation can not
+decode the charset included in it, it is not decoded.
+
+If MUST-UNFOLD is non-nil, it unfolds and eliminates line-breaks even
+if there are in decoded encoded-words (generated by bad manner MUA
+such as a version of Net$cape)."
+ (rotate-memo args-eword-decode-unstructured-field-body
+ (list string must-unfold))
+ (let ((decoded (ew-decode-field "" (ew-lf-crlf-to-crlf string))))
+ (ew-crlf-to-lf (ew-crlf-unfold decoded))))
+
;;; @ for region
;;;
(defun eword-decode-token (token)
(cdr token))
-(defun eword-decode-and-fold-structured-field
- (string start-column &optional max-column must-unfold)
- "Decode and fold (fill) STRING as structured field body.
-It decodes non us-ascii characters in FULL-NAME encoded as
-encoded-words or invalid \"raw\" string. \"Raw\" non us-ascii
-characters are regarded as variable `default-mime-charset'.
-
-If an encoded-word is broken or your emacs implementation can not
-decode the charset included in it, it is not decoded.
-
-If MAX-COLUMN is omitted, `fill-column' is used.
-
-If MUST-UNFOLD is non-nil, it unfolds and eliminates line-breaks even
-if there are in decoded encoded-words (generated by bad manner MUA
-such as a version of Net$cape)."
- (rotate-memo args-eword-decode-and-fold-structured-field
- (list string start-column max-column must-unfold))
- (or max-column
- (setq max-column fill-column))
- (let* ((field-name (make-string (1- start-column) ?X))
- (field-body (ew-lf-crlf-to-crlf string))
- (ew-decode-field-default-syntax '(ew-scan-unibyte-std11))
- (decoded (ew-decode-field field-name field-body)))
- (unless (equal field-body decoded)
- (setq decoded (ew-crlf-refold decoded start-column max-column)))
- (ew-crlf-to-lf decoded)))
-
-(defun eword-decode-and-unfold-structured-field (string)
- "Decode and unfold STRING as structured field body.
-It decodes non us-ascii characters in FULL-NAME encoded as
-encoded-words or invalid \"raw\" string. \"Raw\" non us-ascii
-characters are regarded as variable `default-mime-charset'.
-
-If an encoded-word is broken or your emacs implementation can not
-decode the charset included in it, it is not decoded."
- (rotate-memo args-eword-decode-and-unfold-structured-field (list string))
- (let* ((ew-decode-field-default-syntax '(ew-scan-unibyte-std11))
- (decoded (ew-decode-field "" (ew-lf-crlf-to-crlf string))))
- (ew-crlf-to-lf (ew-crlf-unfold decoded))))
-
-(defun eword-decode-structured-field-body (string &optional must-unfold
- start-column max-column)
- "Decode non us-ascii characters in STRING as structured field body.
-STRING is unfolded before decoding.
-
-It decodes non us-ascii characters in FULL-NAME encoded as
-encoded-words or invalid \"raw\" string. \"Raw\" non us-ascii
-characters are regarded as variable `default-mime-charset'.
-
-If an encoded-word is broken or your emacs implementation can not
-decode the charset included in it, it is not decoded.
-
-If MUST-UNFOLD is non-nil, it unfolds and eliminates line-breaks even
-if there are in decoded encoded-words (generated by bad manner MUA
-such as a version of Net$cape)."
- (rotate-memo args-eword-decode-structured-field-body
- (list string must-unfold start-column max-column))
- (if start-column
- ;; fold with max-column
- (eword-decode-and-fold-structured-field
- string start-column max-column must-unfold)
- ;; Don't fold
- (let* ((ew-decode-field-default-syntax '(ew-scan-unibyte-std11))
- (decoded (ew-decode-field "" (ew-lf-crlf-to-crlf string))))
- (ew-crlf-to-lf decoded))))
-
-(defun eword-decode-unstructured-field-body (string &optional must-unfold)
- "Decode non us-ascii characters in STRING as unstructured field body.
-STRING is unfolded before decoding.
-
-It decodes non us-ascii characters in FULL-NAME encoded as
-encoded-words or invalid \"raw\" string. \"Raw\" non us-ascii
-characters are regarded as variable `default-mime-charset'.
-
-If an encoded-word is broken or your emacs implementation can not
-decode the charset included in it, it is not decoded.
-
-If MUST-UNFOLD is non-nil, it unfolds and eliminates line-breaks even
-if there are in decoded encoded-words (generated by bad manner MUA
-such as a version of Net$cape)."
- (rotate-memo args-eword-decode-unstructured-field-body
- (list string must-unfold))
- (let ((decoded (ew-decode-field "" (ew-lf-crlf-to-crlf string))))
- (ew-crlf-to-lf (ew-crlf-unfold decoded))))
-
(defun eword-extract-address-components (string)
"Extract full name and canonical address from STRING.
Returns a list of the form (FULL-NAME CANONICAL-ADDRESS).
(insert "\n"))
)
-(defun base64-decode-region (start end)
+(defun decode-base64-region (start end)
"Decode current region by base64.
START and END are buffer positions."
(interactive "r")
(mel-define-method-function (mime-encode-region start end (nil "base64"))
'base64-encode-region)
(mel-define-method-function (mime-decode-region start end (nil "base64"))
- 'base64-decode-region)
+ 'decode-base64-region)
(mel-define-method-function (encoded-text-encode-string string (nil "B"))
'encode-base64-string)
(interactive (list (read-file-name "Insert encoded file: ")))
(insert (encode-base64-string
(with-temp-buffer
+ (set-buffer-multibyte nil)
(insert-file-contents-as-binary filename)
(buffer-string))))
(or (bolp)
(insert "\n"))
)
-(mel-define-method mime-write-decoded-region (start end filename
- (nil "base64"))
- "Decode and write current region encoded by base64 into FILENAME.
-START and END are buffer positions."
- (interactive
- (list (region-beginning) (region-end)
- (read-file-name "Write decoded region to file: ")))
- (let ((str (buffer-substring start end)))
- (with-temp-buffer
- (insert (decode-base64-string str))
- (write-region-as-binary (point-min) (point-max) filename)
- )))
+;; (mel-define-method mime-write-decoded-region (start end filename
+;; (nil "base64"))
+;; "Decode and write current region encoded by base64 into FILENAME.
+;; START and END are buffer positions."
+;; (interactive
+;; (list (region-beginning) (region-end)
+;; (read-file-name "Write decoded region to file: ")))
+;; (let ((str (buffer-substring start end)))
+;; (with-temp-buffer
+;; (insert (decode-base64-string str))
+;; (write-region-as-binary (point-min) (point-max) filename)
+;; )))
;;; @ end
:type '(choice (const :tag "Always use internal encoder" nil)
(integer :tag "Size")))
-(defcustom base64-internal-decoding-limit 70000
+(defcustom base64-internal-decoding-limit (if (and (featurep 'xemacs)
+ (featurep 'mule))
+ 1000
+ 7600)
"*limit size to use internal base64 decoder.
If size of input to decode is larger than this limit,
external decoder is called."
;;; @ internal base64 encoder
;;; based on base64 decoder by Enami Tsugutomo
-(defconst base64-characters
- "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/")
+(eval-and-compile
+ (defconst base64-characters
+ "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/")
+ )
(defmacro base64-num-to-char (n)
`(aref base64-characters ,n))
;;;
(defconst base64-numbers
- `,(let ((len (length base64-characters))
+ (eval-when-compile
+ (let ((len (length base64-characters))
(vec (make-vector 123 nil))
(i 0))
(while (< i len)
(aset vec (aref base64-characters i) i)
(setq i (1+ i)))
- vec))
+ vec)))
(defmacro base64-char-to-num (c)
`(aref base64-numbers ,c))
(defun base64-internal-decode-string (string)
(base64-internal-decode string (make-string (length string) 0)))
-(defsubst base64-decode-string! (string)
- (base64-internal-decode string string))
+;; (defsubst base64-decode-string! (string)
+;; (setq string (string-as-unibyte string))
+;; (base64-internal-decode string string))
(defun base64-internal-decode-region (beg end)
(save-excursion
- (let ((str (buffer-substring beg end)))
+ (let ((str (string-as-unibyte (buffer-substring beg end))))
(delete-region beg end)
(goto-char beg)
- (insert (base64-decode-string! str)))))
+ (insert (base64-internal-decode str str)))))
+
+;; (defun base64-internal-decode-region2 (beg end)
+;; (save-excursion
+;; (let ((str (buffer-substring beg end)))
+;; (delete-region beg end)
+;; (goto-char beg)
+;; (insert (base64-decode-string! str)))))
+
+;; (defun base64-internal-decode-region3 (beg end)
+;; (save-excursion
+;; (let ((str (buffer-substring beg end)))
+;; (delete-region beg end)
+;; (goto-char beg)
+;; (insert (base64-internal-decode-string str)))))
;;; @ external encoder/decoder
(base64-decode-string string)
(error "Invalid encoded-text %s" string)))
-(mel-define-method mime-insert-encoded-file (filename (nil "base64"))
+(defun base64-insert-encoded-file (filename)
"Encode contents of file FILENAME to base64, and insert the result.
It calls external base64 encoder specified by
`base64-external-encoder'. So you must install the program (maybe
(insert
(base64-encode-string
(with-temp-buffer
+ (set-buffer-multibyte nil)
(insert-file-contents-as-binary filename)
(buffer-string))))
(or (bolp)
(insert "\n"))
))
-(mel-define-method mime-write-decoded-region (start end filename
- (nil "base64"))
+(mel-define-method-function (mime-insert-encoded-file filename (nil "base64"))
+ 'base64-insert-encoded-file)
+
+(defun base64-write-decoded-region (start end filename)
"Decode and write current region encoded by base64 into FILENAME.
START and END are buffer positions."
(interactive
(let ((str (buffer-substring start end)))
(with-temp-buffer
(insert (base64-internal-decode-string str))
- (write-region-as-binary (point-min) (point-max) filename)))))
+ (write-region-as-binary (point-min) (point-max) filename)
+ ))))
+
+(mel-define-method-function
+ (mime-write-decoded-region start end filename (nil "base64"))
+ 'base64-write-decoded-region)
;;; @ etc
;;; @ B
;;;
-(unless-broken ccl-execute-eof-block-on-encoding-some
+(unless-broken ccl-execute-eof-block-on-decoding-some
(defun base64-ccl-encode-string (string)
"Encode STRING with base64 encoding."
(interactive
(list (region-beginning) (region-end)
(read-file-name "Write decoded region to file: ")))
- (let ((coding-system-for-write 'mel-ccl-b-rev))
+ (let ((coding-system-for-write 'mel-ccl-b-rev)
+ jka-compr-compression-info-list)
(write-region start end filename)))
(mel-define-method-function (mime-decode-string string (nil "base64"))
;;; @ quoted-printable
;;;
-(unless-broken ccl-execute-eof-block-on-encoding-some
+(unless-broken ccl-execute-eof-block-on-decoding-some
(defun quoted-printable-ccl-encode-string (string)
"Encode STRING with quoted-printable encoding."
;;; Code:
-(require 'emu)
(require 'mime-def)
+(require 'poem)
(defcustom mime-encoding-list
'("7bit" "8bit" "binary" "base64" "quoted-printable")
(defvar mel-ccl-module
(and (featurep 'mule)
- (module-installed-p 'mel-ccl)))
+ (progn
+ (require 'path-util)
+ (module-installed-p 'mel-ccl)
+ )))
(mel-use-module 'mel-b '("base64" "B"))
(mel-use-module 'mel-q '("quoted-printable" "Q"))
;;; Code:
-(defconst mime-library-product ["FLAM-DOODLE" (1 10 1) "\e$B5`MU\e(B 10YR7.5/10.0"]
- "Product name, version number and code name of MIME-library package.")
+(eval-and-compile
+ (defconst mime-library-product ["FLAM-DOODLE" (1 10 2) "\e$B@VGrFK\e(B 5.0YR8.0/6.0"]
+ "Product name, version number and code name of MIME-library package.")
+ )
(defmacro mime-product-name (product)
`(aref ,product 0))
projects / elisp / flim.git / commitdiff