(ps-mule-font-info-database): Doc-string modified.

(ps-mule-external-libraries): New element FEATURE.
(ps-mule-init-external-library): Ajusted for the above change.
(ps-mule-generate-font): Likewise.
(ps-mule-generate-glyphs): Likewise.
(ps-mule-prepare-font): Likewise.
(ps-mule-initialize): Likewise.
(ps-begin-file): Superfluous tailing parenthesis deleted.

Mule related code moved to ps-mule.el.
(ps-begin-job): While setting ps-control-or-escape-regexp, don't
check ps-mule-charset-list.
(ps-begin-page): Don't set ps-mule-current-charset, instead call
ps-mule-begin-page.
(ps-basic-plot-string): Call ps-mule-prepare-ascii-font.
(ps-plot-region): Don't set ps-mule-current-charset, instead call
ps-mule-set-ascii-font.  Don't call ps-mule-skip-same-charset,
instead skip same charsets by itself.
(ps-generate): Call ps-mule-initialize of needs-begin-file is
non-nil.  Call ps-mule-begin-job.

(ps-print-version): New version number (4.1.2), doc fix
and mule related code extraction. Autoload ps-mule funs.

Define several functions for Emacs 20.2 and the
earlier version.
(ps-printer-name): Check if printer-name is bound.

1 files changed, 104 insertions, 1142 deletions

diff --git a/lisp/ps-print.el b/lisp/ps-print.el
index 25f08f5fbe8..499711cb94c 100644
--- a/lisp/ps-print.el
+++ b/lisp/ps-print.el
@@ -9,11 +9,11 @@
 ;; Maintainer:	Kenichi Handa <handa@etl.go.jp> (multi-byte characters)
 ;; Maintainer:	Vinicius Jose Latorre <vinicius@cpqd.com.br>
 ;; Keywords:	print, PostScript
-;; Time-stamp:	<98/10/13  15:42:23 vinicius>
-;; Version:	4.1.1
+;; Time-stamp:	<98/11/13  9:32:27 vinicius>
+;; Version:	4.1.2
 
-(defconst ps-print-version "4.1.1"
-  "ps-print.el, v 4.1.1 <98/10/13 vinicius>
+(defconst ps-print-version "4.1.2"
+  "ps-print.el, v 4.1.2 <98/11/13 vinicius>
 
 Vinicius's last change version -- this file may have been edited as part of
 Emacs without changes to the version number.  When reporting bugs,
@@ -440,44 +440,7 @@ Please send all bug fixes and enhancements to
 ;; Printing Multi-byte Buffer
 ;; --------------------------
 ;;
-;; The variable `ps-multibyte-buffer' specifies the ps-print multi-byte buffer
-;; handling.
-;;
-;; Valid values for `ps-multibyte-buffer' are:
-;;
-;;  nil                     This is the value to use when you are printing
-;;			    buffer with only ASCII and Latin characters.
-;;
-;;  `non-latin-printer'     This is the value to use when you have a japanese
-;;			    or korean PostScript printer and want to print
-;;			    buffer with ASCII, Latin-1, Japanese (JISX0208 and
-;;			    JISX0201-Kana) and Korean characters.  At present,
-;;			    it was not tested the Korean characters printing.
-;;			    If you have a korean PostScript printer, please,
-;;			    test it.
-;;
-;;  `bdf-font'              This is the value to use when you want to print
-;;			    buffer with BDF fonts.  BDF fonts include both latin
-;;			    and non-latin fonts.  BDF (Bitmap Distribution
-;;			    Format) is a format used for distributing X's font
-;;			    source file.  BDF fonts are included in
-;;			    `intlfonts-1.1' which is a collection of X11 fonts
-;;			    for all characters supported by Emacs.  In order to
-;;			    use this value, be sure to have installed
-;;			    `intlfonts-1.1' and set the variable
-;;			    `bdf-directory-list' appropriately (see bdf.el for
-;;			    documentation of this variable).
-;;
-;;  `bdf-font-except-latin' This is like `bdf-font' except that it is used
-;;			    PostScript default fonts to print ASCII and Latin-1
-;;			    characters.  This is convenient when you want or
-;;			    need to use both latin and non-latin characters on
-;;			    the same buffer.  See `ps-font-family',
-;;			    `ps-header-font-family' and `ps-font-info-database'.
-;;
-;; Any other value is treated as nil.
-;;
-;; The default is nil.
+;; See ps-mule.el for documentation.
 ;;
 ;;
 ;; Line Number
@@ -975,6 +938,17 @@ Please send all bug fixes and enhancements to
 (unless (featurep 'lisp-float-type)
   (error "`ps-print' requires floating point support"))
 
+;; For Emacs 20.2 and the earlier version.
+(eval-and-compile
+  (and (string< mule-version "4.0")
+       (progn
+	 (defun set-buffer-multibyte (arg)
+	   (setq enable-multibyte-characters arg))
+	 (defun string-as-unibyte (arg) arg)
+	 (defun string-as-multibyte (arg) arg)
+	 (defun charset-after (&optional arg)
+	   (char-charset (char-after arg))))))
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; User Variables:
 
@@ -1023,46 +997,6 @@ Please send all bug fixes and enhancements to
   :group 'faces)
 
 
-(defcustom ps-multibyte-buffer nil
-  "*Specifies the multi-byte buffer handling.
-
-Valid values are:
-
-  nil                     This is the value to use when you are printing
-			  buffer with only ASCII and Latin characters.
-
-  `non-latin-printer'     This is the value to use when you have a japanese
-			  or korean PostScript printer and want to print
-			  buffer with ASCII, Latin-1, Japanese (JISX0208 and
-			  JISX0201-Kana) and Korean characters.  At present,
-			  it was not tested the Korean characters printing.
-			  If you have a korean PostScript printer, please,
-			  test it.
-
-  `bdf-font'              This is the value to use when you want to print
-			  buffer with BDF fonts.  BDF fonts include both latin
-			  and non-latin fonts.  BDF (Bitmap Distribution
-			  Format) is a format used for distributing X's font
-			  source file.  BDF fonts are included in
-			  `intlfonts-1.1' which is a collection of X11 fonts
-			  for all characters supported by Emacs.  In order to
-			  use this value, be sure to have installed
-			  `intlfonts-1.1' and set the variable
-			  `bdf-directory-list' appropriately (see bdf.el for
-			  documentation of this variable).
-
-  `bdf-font-except-latin' This is like `bdf-font' except that it is used
-			  PostScript default fonts to print ASCII and Latin-1
-			  characters.  This is convenient when you want or
-			  need to use both latin and non-latin characters on
-			  the same buffer.  See `ps-font-family',
-			  `ps-header-font-family' and `ps-font-info-database'.
-
-Any other value is treated as nil."
-  :type '(choice (const non-latin-printer) (const bdf-font)
-		 (const bdf-font-except-latin) (other :tag "nil" nil))
-  :group 'ps-print-font)
-
 (defcustom ps-print-prologue-header nil
   "*PostScript prologue header comments besides that ps-print generates.
 
@@ -1090,7 +1024,8 @@ For more information about PostScript document comments, see:
   :type '(choice string symbol (other :tag "nil" nil))
   :group 'ps-print)
 
-(defcustom ps-printer-name printer-name
+(defcustom ps-printer-name (and (boundp 'printer-name)
+				printer-name)
   "*The name of a local printer for printing PostScript files.
 
 On Unix-like systems, a string value should be a name understood by
@@ -1828,7 +1763,7 @@ Interactively, when you use a prefix argument (C-u), the command
 prompts the user for a file name, and saves the spooled PostScript
 image in that file instead of sending it to the printer.
 
-More specifically, the FILENAME argument is treated as follows: if it
+Noninteractively, the argument FILENAME is treated as follows: if it
 is nil, send the image to the printer.  If FILENAME is a string, save
 the PostScript image in a file with that name."
   (interactive (list (ps-print-preprint current-prefix-arg)))
@@ -1930,7 +1865,7 @@ The table depends on the current ps-print setup."
    ps-header-lines
    ps-show-n-of-n
    ps-spool-duplex
-   (ps-print-quote ps-multibyte-buffer)
+   (ps-print-quote ps-multibyte-buffer)	; see `ps-mule.el'
    (ps-print-quote ps-font-family)
    ps-font-size
    (ps-print-quote ps-header-font-family)
@@ -2367,6 +2302,7 @@ StandardEncoding 46 82 getinterval aload pop
   /SpaceWidth /f0 findfont setfont ( ) stringwidth pop def
   % ---- save the state of the document (useful for ghostscript!)
   /docState save def
+  % ---- [jack] Kludge: my ghostscript window is 21x27.7 instead of 21x29.7
   /JackGhostscript where {pop 1 27.7 29.7 div scale}if
   % ---- [andrewi] set PageSize based on chosen dimensions
   /setpagedevice where {
@@ -2942,1005 +2878,6 @@ x-dimension, of the text it has printed, and thus affects the point at
 which long lines wrap around."
   (get font-sym 'avg-char-width))
 
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; For handling multi-byte characters -- Begin.
-;;
-;; The following comments apply only to this part (through the next ^L).
-;; Author:	Kenichi Handa <handa@etl.go.jp>
-;; Maintainer:	Kenichi Handa <handa@etl.go.jp>
-
-(eval-and-compile
-  (if (not (string< mule-version "4.0"))
-      (progn
-	(defalias 'ps-mule-next-point '1+)
-	(defalias 'ps-mule-chars-in-string 'length)
-	(defalias 'ps-mule-string-char 'aref)
-	(defsubst ps-mule-next-index (str i) (1+ i)))
-    (defun set-buffer-multibyte (arg)
-      (setq enable-multibyte-characters arg))
-    (defun string-as-unibyte (arg) arg)
-    (defun string-as-multibyte (arg) arg)
-    (defun charset-after (&optional arg)
-      (char-charset (char-after arg)))
-    (defun ps-mule-next-point (arg)
-      (save-excursion (goto-char arg) (forward-char 1) (point)))
-    (defun ps-mule-chars-in-string (string)
-      (length string))
-    (defalias 'ps-mule-string-char 'aref)
-    (defun ps-mule-next-index (str i)
-      (1+ i)))
-  )
-
-(defvar ps-mule-font-info-database
-  nil
-  "Alist of charsets with the corresponding font information.
-Each element has the form:
-
-	(CHARSET (FONT-TYPE FONT-SRC FONT-NAME ENCODING BYTES) ...)
-
-Where
-
-CHARSET is a charset (symbol) for this font family,
-
-FONT-TYPE is a font type: normal, bold, italic, or bold-italic.
-
-FONT-SRC is a font source: builtin, bdf, vflib, or nil.
-
-  If FONT-SRC is builtin, FONT-NAME is a buitin PostScript font name.
-
-  If FONT-SRC is bdf, FONT-NAME is a BDF font file name.  To use this font,
-  the external library `bdf' is required.
-
-  If FONT-SRC is vflib, FONT-NAME is the name of a font that VFlib knows.
-  To use this font, the external library `vflib' is required.
-
-  If FONT-SRC is nil, a proper ASCII font in the variable
-  `ps-font-info-database' is used.  This is useful for Latin-1 characters.
-
-ENCODING is a coding system to encode a string of characters of CHARSET into a
-proper string matching an encoding of the specified font.  ENCODING may be a
-function that does this encoding.  In this case, the function is called with
-one argument, the string to encode, and it should return an encoded string.
-
-BYTES specifies how many bytes each character has in the encoded byte
-sequence; it should be 1 or 2. 
-
-All multi-byte characters are printed by fonts specified in this database
-regardless of a font family of ASCII characters.  The exception is Latin-1
-characters which are printed by the same font as ASCII characters, thus obey
-font family.
-
-See also the variable `ps-font-info-database'.")
-
-(defconst ps-mule-font-info-database-latin
-  '((latin-iso8859-1
-     (normal nil nil iso-latin-1)))
-  "Sample setting of `ps-mule-font-info-database' to use latin fonts.")
-
-(defconst ps-mule-font-info-database-ps
-  '((katakana-jisx0201
-     (normal builtin "Ryumin-Light.Katakana" ps-mule-encode-7bit 1)
-     (bold builtin "GothicBBB-Medium.Katakana" ps-mule-encode-7bit 1)
-     (bold-italic builtin "GothicBBB-Medium.Katakana" ps-mule-encode-7bit 1))
-    (latin-jisx0201
-     (normat builtin "Ryumin-Light.Hankaku" ps-mule-encode-7bit 1)
-     (bold builtin "GothicBBB-Medium.Hankaku" ps-mule-encode-7bit 1))
-    (japanese-jisx0208
-     (normal builtin "Ryumin-Light-H" ps-mule-encode-7bit 2)
-     (bold builtin "GothicBBB-Medium-H" ps-mule-encode-7bit 2))
-    (korean-ksc5601
-     (normal builtin "Batang-Medium-KSC-H" ps-mule-encode-7bit 2)
-     (bold builtin " Gulim-Medium-KSC-H" ps-mule-encode-7bit 2))
-    )
-  "Sample setting of the `ps-mule-font-info-database' to use builtin PS font.
-
-Currently, data for Japanese and Korean PostScript printers are listed.")
-
-(defconst ps-mule-font-info-database-bdf
-  '((ascii
-     (normal bdf "etl24-latin1.bdf" nil 1)
-     (bold bdf "etl16b-latin1.bdf" iso-latin-1 1)
-     (italic bdf "etl16i-latin1.bdf" iso-latin-1 1)
-     (bold-italic bdf "etl16bi-latin1.bdf" iso-latin-1 1))
-    (latin-iso8859-1
-     (normal bdf "etl24-latin1.bdf" iso-latin-1 1)
-     (bold bdf "etl16b-latin1.bdf" iso-latin-1 1)
-     (italic bdf "etl16i-latin1.bdf" iso-latin-1 1)
-     (bold-italic bdf "etl16bi-latin1.bdf" iso-latin-1 1))
-    (latin-iso8859-2
-     (normal bdf "etl24-latin2.bdf" iso-latin-2 1))
-    (latin-iso8859-3
-     (normal bdf "etl24-latin3.bdf" iso-latin-3 1))
-    (latin-iso8859-4
-     (normal bdf "etl24-latin4.bdf" iso-latin-4 1))
-    (thai-tis620
-     (normal bdf "thai-24.bdf" thai-tis620 1))
-    (greek-iso8859-7
-     (normal bdf "etl24-greek.bdf" greek-iso-8bit 1))
-    ;; (arabic-iso8859-6	nil) ; not yet available
-    (hebrew-iso8859-8
-     (normal bdf "etl24-hebrew.bdf" hebrew-iso-8bit 1))
-    (katakana-jisx0201
-     (normal bdf "12x24rk.bdf" ps-mule-encode-8bit 1))
-    (latin-jisx0201
-     (normal bdf "12x24rk.bdf" ps-mule-encode-7bit 1))
-    (cyrillic-iso8859-5
-     (normal bdf "etl24-cyrillic.bdf" cyrillic-iso-8bit 1))
-    (latin-iso8859-9
-     (normal bdf "etl24-latin5.bdf" iso-latin-5 1))
-    (japanese-jisx0208-1978
-     (normal bdf "jiskan24.bdf" ps-mule-encode-7bit 2))
-    (chinese-gb2312
-     (normal bdf "gb24st.bdf" ps-mule-encode-7bit 2))
-    (japanese-jisx0208
-     (normal bdf "jiskan24.bdf" ps-mule-encode-7bit 2))
-    (korean-ksc5601
-     (normal bdf "hanglm24.bdf" ps-mule-encode-7bit 2))
-    (japanese-jisx0212
-     (normal bdf "jisksp40.bdf" ps-mule-encode-7bit 2))
-    (chinese-cns11643-1
-     (normal bdf "cns-1-40.bdf" ps-mule-encode-7bit 2))
-    (chinese-cns11643-2
-     (normal bdf "cns-2-40.bdf" ps-mule-encode-7bit 2))
-    (chinese-big5-1
-     (normal bdf "taipei24.bdf" chinese-big5 2))
-    (chinese-big5-2
-     (normal bdf "taipei24.bdf" chinese-big5 2))
-    (chinese-sisheng
-     (normal bdf "etl24-sisheng.bdf" ps-mule-encode-8bit 1))
-    (ipa
-     (normal bdf "etl24-ipa.bdf" ps-mule-encode-8bit 1))
-    (vietnamese-viscii-lower
-     (normal bdf "etl24-viscii.bdf" vietnamese-viscii 1))
-    (vietnamese-viscii-upper
-     (normal bdf "etl24-viscii.bdf" vietnamese-viscii 1))
-    (arabic-digit
-     (normal bdf "etl24-arabic0.bdf" ps-mule-encode-7bit 1))
-    (arabic-1-column
-     (normal bdf "etl24-arabic1.bdf" ps-mule-encode-7bit 1))
-    ;; (ascii-right-to-left nil) ; not yet available
-    (lao
-     (normal bdf "mule-lao-24.bdf" lao 1))
-    (arabic-2-column
-     (normal bdf "etl24-arabic2.bdf" ps-mule-encode-7bit 1))
-    (indian-is13194
-     (normal bdf "mule-iscii-24.bdf" ps-mule-encode-7bit 1))
-    (indian-1-column
-     (normal bdf "mule-indian-1col-24.bdf" ps-mule-encode-7bit 2))
-    (tibetan-1-column
-     (normal bdf "mule-tibmdx-1col-24.bdf" ps-mule-encode-7bit 2))
-    (ethiopic
-     (normal bdf "ethiomx24f-uni.bdf" ps-mule-encode-ethiopic 2))
-    (chinese-cns11643-3
-     (normal bdf "cns-3-40.bdf" ps-mule-encode-7bit 2))
-    (chinese-cns11643-4
-     (normal bdf "cns-4-40.bdf" ps-mule-encode-7bit 2))
-    (chinese-cns11643-5
-     (normal bdf "cns-5-40.bdf" ps-mule-encode-7bit 2))
-    (chinese-cns11643-6
-     (normal bdf "cns-6-40.bdf" ps-mule-encode-7bit 2))
-    (chinese-cns11643-7
-     (normal bdf "cns-7-40.bdf" ps-mule-encode-7bit 2))
-    (indian-2-column
-     (normal bdf "mule-indian-24.bdf" ps-mule-encode-7bit 2))
-    (tibetan
-     (normal bdf "mule-tibmdx-24.bdf" ps-mule-encode-7bit 2)))
-  "Sample setting of the `ps-mule-font-info-database' to use BDF fonts.
-BDF (Bitmap Distribution Format) is a format used for distributing X's font
-source file.
-
-Current default value list for BDF fonts is included in `intlfonts-1.1' which is
-a collection of X11 fonts for all characters supported by Emacs.
-
-Using this list as default value to `ps-mule-font-info-database', all characters
-including ASCII and Latin-1 are printed by BDF fonts.
-
-See also `ps-mule-font-info-database-ps-bdf'.")
-
-(defconst ps-mule-font-info-database-ps-bdf
-  (cons (car ps-mule-font-info-database-latin)
-	(cdr (cdr ps-mule-font-info-database-bdf)))
-  "Sample setting of the `ps-mule-font-info-database' to use BDF fonts.
-
-Current default value list for BDF fonts is included in `intlfonts-1.1' which is
-a collection of X11 fonts for all characters supported by Emacs.
-
-Using this list as default value to `ps-mule-font-info-database', all characters
-except ASCII and Latin-1 characters are printed by BDF fonts.  ASCII and Latin-1
-characters are printed by PostScript font specified by `ps-font-family' and
-`ps-header-font-family'.
-
-See also `ps-mule-font-info-database-bdf'.")
-
-;; Two typical encoding functions for PostScript fonts.
-
-(defun ps-mule-encode-7bit (string)
-  (ps-mule-encode-bit string 0))
-
-(defun ps-mule-encode-8bit (string)
-  (ps-mule-encode-bit string 128))
-
-(defun ps-mule-encode-bit (string delta)
-  (let* ((dim (charset-dimension (char-charset (ps-mule-string-char string 0))))
-	 (len (* (ps-mule-chars-in-string string) dim))
-	 (str (make-string len 0))
-	 (i 0)
-	 (j 0))
-    (if (= dim 1)
-	(while (< j len)
-	  (aset str j
-		(+ (nth 1 (split-char (ps-mule-string-char string i))) delta))
-	  (setq i (ps-mule-next-index string i)
-		j (1+ j)))
-      (while (< j len)
-	(let ((split (split-char (ps-mule-string-char string i))))
-	  (aset str j (+ (nth 1 split) delta))
-	  (aset str (1+ j) (+ (nth 2 split) delta))
-	  (setq i (ps-mule-next-index string i)
-		j (+ j 2)))))
-    str))
-
-;; Special encoding function for Ethiopic.
-(define-ccl-program ccl-encode-ethio-unicode
-  `(1
-    ((read r2)
-     (loop
-      (if (r2 == ,leading-code-private-22)
-	  ((read r0)
-	   (if (r0 == ,(charset-id 'ethiopic))
-	       ((read r1 r2)
-		(r1 &= 127) (r2 &= 127)
-		(call ccl-encode-ethio-font)
-		(write r1)
-		(write-read-repeat r2))
-	     ((write r2 r0)
-	      (repeat))))
-	(write-read-repeat r2))))))
-
-(defun ps-mule-encode-ethiopic (string)
-  (ccl-execute-on-string (symbol-value 'ccl-encode-ethio-unicode)
-			 (make-vector 9 nil)
-			 string))
-
-;; A charset which we are now processing.
-(defvar ps-mule-current-charset nil)
-
-(defun ps-mule-get-font-spec (charset font-type)
-  "Return FONT-SPEC for printing characters CHARSET with FONT-TYPE.
-FONT-SPEC is a list that has the form:
-
-	(FONT-SRC FONT-NAME ENCODING BYTES)
-
-FONT-SPEC is extracted from `ps-mule-font-info-database'.
-
-See the documentation of `ps-mule-font-info-database' for the meaning of each
-element of the list."
-  (let ((slot (cdr (assq charset ps-mule-font-info-database))))
-    (and slot
-	 (cdr (or (assq font-type slot)
-		  (and (eq font-type 'bold-italic)
-		       (or (assq 'bold slot) (assq 'italic slot)))
-		  (assq 'normal slot))))))
-
-;; Functions to access each element of FONT-SPEC.
-(defsubst ps-mule-font-spec-src (font-spec) (car font-spec))
-(defsubst ps-mule-font-spec-name (font-spec) (nth 1 font-spec))
-(defsubst ps-mule-font-spec-encoding (font-spec) (nth 2 font-spec))
-(defsubst ps-mule-font-spec-bytes (font-spec) (nth 3 font-spec))
-
-(defsubst ps-mule-printable-p (charset)
-  "Non-nil if characters in CHARSET is printable."
-  (ps-mule-get-font-spec charset 'normal))
-
-(defconst ps-mule-external-libraries
-  '((builtin nil
-	     nil nil nil)
-    (bdf nil
-	 bdf-generate-prologue bdf-generate-font bdf-generate-glyphs)
-    (pcf nil
-	 pcf-generate-prologue pcf-generate-font pcf-generate-glyphs)
-    (vflib nil
-	   vflib-generate-prologue vflib-generate-font vflib-generate-glyphs))
-  "Alist of information of external libraries to support PostScript printing.
-Each element has the form:
-
-    (FONT-SRC INITIALIZED-P PROLOGUE-FUNC FONT-FUNC GLYPHS-FUNC)
-
-FONT-SRC is the font source: builtin, bdf, pcf, or vflib.  Except for `builtin',
-libraries must have the same name as indicated by FONT-SRC.  Currently, we only
-have the `bdf' library.
-
-INITIALIZED-P indicates if this library is initialized or not.
-
-PROLOGUE-FUNC is a function to generate PostScript code which define several
-PostScript procedures that will be called by FONT-FUNC and GLYPHS-FUNC.  It is
-called with no argument, and should return a list of strings.
-
-FONT-FUNC is a function to generate PostScript code which define a new font.  It
-is called with one argument FONT-SPEC, and should return a list of strings.
-
-GLYPHS-FUNC is a function to generate PostScript code which define glyphs of
-characters.  It is called with three arguments FONT-SPEC, CODE-LIST, and BYTES,
-and should return a list of strings.")
-
-(defun ps-mule-init-external-library (font-spec)
-  "Initialize external library specified by FONT-SPEC for PostScript printing.
-See the documentation of `ps-mule-get-font-spec' for FONT-SPEC's meaning."
-  (let* ((font-src (ps-mule-font-spec-src font-spec))
-	 (slot (assq font-src ps-mule-external-libraries)))
-    (or (not font-src)
-	(nth 1 slot)
-	(let ((func (nth 2 slot)))
-	  (if func
-	      (progn
-		(or (featurep font-src) (require font-src))
-		(ps-output-prologue (funcall func))))
-	  (setcar (cdr slot) t)))))
-
-;; Cached glyph information of fonts, alist of:
-;;	(FONT-NAME ((FONT-TYPE-NUMBER . SCALED-FONT-NAME) ...)
-;;	 cache CODE0 CODE1 ...)
-(defvar ps-mule-font-cache nil)
-
-(defun ps-mule-generate-font (font-spec charset)
-  "Generate PostScript codes to define a new font in FONT-SPEC for CHARSET."
-  (let* ((font-cache (assoc (ps-mule-font-spec-name font-spec)
-			    ps-mule-font-cache))
-	 (font-src (ps-mule-font-spec-src font-spec))
-	 (font-name (ps-mule-font-spec-name font-spec))
-	 (func (nth 3 (assq font-src ps-mule-external-libraries)))
-	 (scaled-font-name
-	  (if (eq charset 'ascii)
-	      (format "f%d" ps-current-font)
-	    (format "f%02x-%d"
-		    (charset-id charset) ps-current-font))))
-    (and func (not font-cache)
-	 (ps-output-prologue (funcall func charset font-spec)))
-    (ps-output-prologue
-     (list (format "/%s %f /%s Def%sFontMule\n"
-		   scaled-font-name ps-font-size font-name
-		   (if (eq ps-mule-current-charset 'ascii) "Ascii" ""))))
-    (if font-cache
-	(setcar (cdr font-cache)
-		(cons (cons ps-current-font scaled-font-name)
-		      (nth 1 font-cache)))
-      (setq font-cache (list font-name
-			     (list (cons ps-current-font scaled-font-name))
-			     'cache)
-	    ps-mule-font-cache (cons font-cache ps-mule-font-cache)))
-    font-cache))
-
-(defun ps-mule-generate-glyphs (font-spec code-list)
-  "Generate PostScript codes which generate glyphs for CODE-LIST of FONT-SPEC."
-  (let* ((font-src (ps-mule-font-spec-src font-spec))
-	 (func (nth 4 (assq font-src ps-mule-external-libraries))))
-    (and func
-	 (ps-output-prologue
-	  (funcall func font-spec code-list
-		   (ps-mule-font-spec-bytes font-spec))))))
-
-(defvar ps-last-font nil)
-
-(defun ps-mule-prepare-font (font-spec string charset &optional no-setfont)
-  "Generate PostScript codes to print STRING of CHARSET by font FONT-SPEC.
-
-The generated code is inserted on prologue part except the code that sets the
-current font (using PostScript procedure `FM').
-
-If optional arg NO-SETFONT is non-nil, don't generate the code for setting the
-current font."
-  (let ((font-cache (assoc (ps-mule-font-spec-name font-spec)
-			   ps-mule-font-cache)))
-    (or (and font-cache (assq ps-current-font (nth 1 font-cache)))
-	(setq font-cache (ps-mule-generate-font font-spec charset)))
-    (or no-setfont
-	(let ((new-font (cdr (assq ps-current-font (nth 1 font-cache)))))
-	  (or (equal new-font ps-last-font)
-	      (progn
-		(ps-output (format "/%s FM\n" new-font))
-		(setq ps-last-font new-font)))))
-    (if (nth 4 (assq (ps-mule-font-spec-src font-spec)
-		     ps-mule-external-libraries))
-	;; We have to generate PostScript codes which define glyphs.
-	(let* ((cached-codes (nthcdr 2 font-cache))
-	       (newcodes nil)
-	       (bytes (ps-mule-font-spec-bytes font-spec))
-	       (len (length string))
-	       (i 0)
-	       code)
-	  (while (< i len)
-	    (setq code (if (= bytes 1)
-			   (aref string i)
-			 (+ (* (aref string i) 256) (aref string (1+ i)))))
-	    (or (memq code cached-codes)
-		(progn
-		  (setq newcodes (cons code newcodes))
-		  (setcdr cached-codes (cons code (cdr cached-codes)))))
-	    (setq i (+ i bytes)))
-	  (and newcodes
-	       (ps-mule-generate-glyphs font-spec newcodes))))))
-
-;; List of charsets of multi-byte characters in a text being printed.
-;; If the text doesn't contain any multi-byte characters (i.e. only
-;; ASCII), the value is nil.
-(defvar ps-mule-charset-list nil)
-
-(defvar ps-mule-prologue-generated nil)
-
-;; This is a PostScript code inserted in the header of generated PostScript.
-(defconst ps-mule-prologue
-  "%%%% Start of Mule Section
-
-%% Working dictionary for general use.
-/MuleDict 10 dict def
-
-%% Define already scaled font for non-ASCII character sets.
-/DefFontMule {			% fontname size basefont  |-  --
-  findfont exch scalefont definefont pop
-} bind def
-
-%% Define already scaled font for ASCII character sets.
-/DefAsciiFontMule {		% fontname size basefont  |-
-  MuleDict begin
-  findfont dup /Encoding get /ISOLatin1Encoding exch def
-  exch scalefont reencodeFontISO
-  end
-} def
-
-%% Set the specified non-ASCII font to use.  It doesn't install
-%% Ascent, etc.
-/FM {				%  fontname  |-  --
-  findfont setfont
-} bind def
-
-%% Show vacant box for characters which don't have appropriate font.
-/SB {				% count column |-  --
-    SpaceWidth mul /w exch def
-    1 exch 1 exch { %for
-	pop
-	gsave
-	0 setlinewidth
-	0 Descent rmoveto w 0 rlineto
-	0 LineHeight rlineto w neg 0 rlineto closepath stroke
-	grestore
-	w 0 rmoveto
-    } for
-} bind def
-
-%% Flag to tell if we are now handling a composite character.  This is
-%% defined here because both composite character handler and bitmap font
-%% handler require it.
-/Cmpchar false def
-
-%%%% End of Mule Section
-
-"
-  "PostScript code for printing multi-byte characters.")
-
-(defun ps-mule-skip-same-charset (charset)
-  "Skip characters of CHARSET following the current point."
-  (while (eq (charset-after) charset)
-    (forward-char 1)))
-
-(defun ps-mule-find-wrappoint (from to char-width)
-  "Find the longest sequence which is printable in the current line.
-
-The search starts at FROM and goes until TO.  It is assumed that all characters
-between FROM and TO belong to a charset in `ps-mule-current-charset'.
-
-CHAR-WIDTH is the average width of ASCII characters in the current font.
-
-Returns the value:
-
-	(ENDPOS . RUN-WIDTH)
-
-Where ENDPOS is the end position of the sequence and RUN-WIDTH is the width of
-the sequence."
-  (let (run-width)
-    (if (eq ps-mule-current-charset 'composition)
-	;; We must draw one char by one.
-	(let ((ch (char-after from)))
-	  (setq run-width (* (char-width ch) char-width))
-	  (if (> run-width ps-width-remaining)
-	      (setq run-width ps-width-remaining)
-	    (setq from (ps-mule-next-point from))))
-      ;; We assume that all characters in this range have the same width.
-      (let ((width (charset-width ps-mule-current-charset)))
-	(setq run-width (* (- to from) char-width width))
-	(if (> run-width ps-width-remaining)
-	    (setq from (min
-			(+ from (truncate (/ ps-width-remaining char-width)))
-			to)
-		  run-width ps-width-remaining)
-	  (setq from to))))
-    (cons from run-width)))
-
-(defun ps-mule-plot-string (from to &optional bg-color)
-  "Generate PostScript code for ploting characters in the region FROM and TO.
-
-It is assumed that all characters in this region belong to a charset in
-`ps-mule-current-charset'.
-
-Optional argument BG-COLOR specifies background color.
-
-Returns the value:
-
-	(ENDPOS . RUN-WIDTH)
-
-Where ENDPOS is the end position of the sequence and RUN-WIDTH is the width of
-the sequence."
-  (let* ((wrappoint (ps-mule-find-wrappoint
-		     from to (ps-avg-char-width 'ps-font-for-text)))
-	 (to (car wrappoint))
-	 (font-type (car (nth ps-current-font
-			      (ps-font-alist 'ps-font-for-text))))
-	 (font-spec (ps-mule-get-font-spec ps-mule-current-charset font-type))
-	 (string (buffer-substring-no-properties from to)))
-    (cond
-     ((= from to)
-      ;; We can't print any more characters in the current line.
-      nil)
-
-     (font-spec
-      ;; We surely have a font for printing this character set.
-      (ps-output-string (ps-mule-string-encoding font-spec string))
-      (ps-output " S\n"))
-
-     ((eq ps-mule-current-charset 'latin-iso8859-1)
-      ;; Latin-1 can be printed by a normal ASCII font.
-      (ps-output-string (ps-mule-string-ascii string))
-      (ps-output " S\n"))
-
-     ((eq ps-mule-current-charset 'composition)
-      (let* ((ch (char-after from))
-	     (width (char-width ch))
-	     (ch-list (decompose-composite-char ch 'list t)))
-	(if (consp (nth 1 ch-list))
-	    (ps-mule-plot-rule-cmpchar ch-list width font-type)
-	  (ps-mule-plot-cmpchar ch-list width t font-type))))
-
-     (t
-      ;; No way to print this charset.  Just show a vacant box of an
-      ;; appropriate width.
-      (ps-output (format "%d %d SB\n"
-			 (length string)
-			 (if (eq ps-mule-current-charset 'composition)
-			     (char-width (char-after from))
-			   (charset-width ps-mule-current-charset))))))
-    wrappoint))
-
-;; Composite font support
-
-(defvar ps-mule-cmpchar-prologue-generated nil)
-
-(defconst ps-mule-cmpchar-prologue
-  "%%%% Composite character handler
-/CmpcharWidth 0 def
-/CmpcharRelativeCompose 0 def
-/CmpcharRelativeSkip 0.4 def
-
-%% Get a bounding box (relative to currentpoint) of STR.
-/GetPathBox {			% str  |-  --
-    gsave
-    currentfont /FontType get 3 eq { %ifelse
-	stringwidth pop pop
-    } {
-	currentpoint /y exch def pop
-	false charpath flattenpath pathbbox
-	y sub /URY exch def pop
-	y sub /LLY exch def pop
-    } ifelse
-    grestore
-} bind def
-
-%% Beginning of composite char.
-/BC {				% str xoff width |-  --
-    /Cmpchar true def
-    /CmpcharWidth exch def
-    currentfont /RelativeCompose known {
-	/CmpcharRelativeCompose currentfont /RelativeCompose get def
-    } {
-	/CmpcharRelativeCompose false def
-    } ifelse
-    /bgsave bg def /bgcolorsave bgcolor def
-    /Effectsave Effect def
-    gsave			% Reflect effect only at first
-	/Effect Effect 1 2 add 4 add 16 add and def
-	/f0 findfont setfont (        ) 0 CmpcharWidth getinterval S
-    grestore
-    /Effect Effectsave 8 32 add and def	% enable only shadow and outline
-    false BG
-    gsave SpaceWidth mul 0 rmoveto dup GetPathBox S grestore
-    /y currentpoint exch pop def
-    /HIGH URY y add def /LOW LLY y add def
-} bind def
-
-%% End of composite char.
-/EC {				% --  |-  --
-    /bg bgsave def /bgcolor bgcolorsave def
-    /Effect Effectsave def
-    /Cmpchar false def
-    CmpcharWidth SpaceWidth mul 0 rmoveto
-} bind def
-
-%% Rule base composition
-/RBC {				% str xoff gref nref  |-  --
-    /nref exch def /gref exch def
-    gsave
-    SpaceWidth mul 0 rmoveto
-    dup
-    GetPathBox
-    [ HIGH currentpoint exch pop LOW HIGH LOW add 2 div ] gref get
-    [ URY LLY sub LLY neg 0 URY LLY sub 2 div ] nref get
-    sub /btm exch def
-    /top btm URY LLY sub add def
-    top HIGH gt { /HIGH top def } if
-    btm LOW lt { /LOW btm def } if
-    currentpoint pop btm LLY sub moveto
-    S
-    grestore
-} bind def
-
-%% Relative composition
-/RLC {				% str  |-  --
-    gsave
-    dup GetPathBox
-    CmpcharRelativeCompose type /integertype eq {
-	LLY CmpcharRelativeCompose gt {	% compose on top
-	    currentpoint pop HIGH LLY sub CmpcharRelativeSkip add moveto
-	    /HIGH HIGH URY LLY sub add CmpcharRelativeSkip add def
-	} { URY 0 le {			% compose under bottom
-	    currentpoint pop LOW LLY add CmpcharRelativeSkip sub moveto
-	    /LOW LOW URY LLY sub sub CmpcharRelativeSkip sub def
-    } if } ifelse } if
-    S
-    grestore
-} bind def
-%%%% End of composite character handler
-
-"
-  "PostScript code for printing composite characters.")
-
-(defun ps-mule-plot-rule-cmpchar (ch-rule-list total-width font-type)
-  (let* ((leftmost 0.0)
-	 (rightmost (float (char-width (car ch-rule-list))))
-	 (the-list (cons '(3 . 3) ch-rule-list))
-	 (cmpchar-elements nil))
-    (while the-list
-      (let* ((this (car the-list))
-	     (gref (car this))
-	     (nref (cdr this))
-	     ;; X-axis info (0:left, 1:center, 2:right)
-	     (gref-x (% gref 3))
-	     (nref-x (% nref 3))
-	     ;; Y-axis info (0:top, 1:base, 2:bottom, 3:center)
-	     (gref-y (if (= gref 4) 3 (/ gref 3)))
-	     (nref-y (if (= nref 4) 3 (/ nref 3)))
-	     (width (float (char-width (car (cdr the-list)))))
-	     left)
-	(setq left (+ leftmost
-		      (/ (* (- rightmost leftmost) gref-x) 2.0)
-		      (- (/ (* nref-x width) 2.0)))
-	      cmpchar-elements (cons (list (car (cdr the-list))
-					   left gref-y nref-y)
-				     cmpchar-elements)
-	      leftmost (min left leftmost)
-	      rightmost (max (+ left width) rightmost)
-	      the-list (nthcdr 2 the-list))))
-    (if (< leftmost 0)
-	(let ((the-list cmpchar-elements))
-	  (while the-list
-	    (setcar (cdr (car the-list))
-		    (- (nth 1 (car the-list)) leftmost))
-	    (setq the-list (cdr the-list)))))
-    (ps-mule-plot-cmpchar (nreverse cmpchar-elements)
-			  total-width nil font-type)))
-
-(defun ps-mule-plot-cmpchar (elements total-width relativep font-type)
-  (let* ((elt (car elements))
-	 (ch (if relativep elt (car elt))))
-    (ps-output-string (ps-mule-prepare-cmpchar-font ch font-type))
-    (ps-output (format " %d %d BC "
-		       (if relativep 0 (nth 1 elt))
-		       total-width))
-    (while (setq elements (cdr elements))
-      (setq elt (car elements)
-	    ch (if relativep elt (car elt)))
-      (ps-output-string (ps-mule-prepare-cmpchar-font ch font-type))
-      (ps-output (if relativep
-		     " RLC "
-		   (format " %d %d %d RBC "
-			   (nth 1 elt) (nth 2 elt) (nth 3 elt))))))
-  (ps-output "EC\n"))
-
-(defun ps-mule-prepare-cmpchar-font (char font-type)
-  (let* ((ps-mule-current-charset (char-charset char))
-	 (font-spec (ps-mule-get-font-spec ps-mule-current-charset font-type)))
-    (cond (font-spec
-	   (ps-mule-string-encoding font-spec (char-to-string char)))
-
-	  ((eq ps-mule-current-charset 'latin-iso8859-1)
-	   (ps-mule-string-ascii (char-to-string char)))
-
-	  (t
-	   ;; No font for CHAR.
-	   (ps-set-font ps-current-font)
-	   " "))))
-
-(defun ps-mule-string-ascii (str)
-  (ps-set-font ps-current-font)
-  (string-as-unibyte (encode-coding-string str 'iso-latin-1)))
-
-(defun ps-mule-string-encoding (font-spec str)
-  (let ((encoding (ps-mule-font-spec-encoding font-spec)))
-    (cond ((coding-system-p encoding)
-	   (setq str (encode-coding-string str encoding)))
-	  ((functionp encoding)
-	   (setq str (funcall encoding str)))
-	  (encoding
-	   (error "Invalid coding system or function: %s" encoding)))
-    (setq str (string-as-unibyte str))
-    (if (ps-mule-font-spec-src font-spec)
-	(ps-mule-prepare-font font-spec str ps-mule-current-charset)
-      (ps-set-font ps-current-font))
-    str))
-
-;; Bitmap font support
-
-(defvar ps-mule-bitmap-prologue-generated nil)
-
-(defconst ps-mule-bitmap-prologue
-  "%%%% Bitmap font handler
-
-/str7 7 string def		% working area
-
-%% We grow the dictionary one bunch (1024 entries) by one.
-/BitmapDictArray 256 array def
-/BitmapDictLength 1024 def
-/BitmapDictIndex -1 def
-
-/NewBitmapDict {		% --  |-  --
-    /BitmapDictIndex BitmapDictIndex 1 add def
-    BitmapDictArray BitmapDictIndex BitmapDictLength dict put
-} bind def
-
-%% Make at least one dictionary.
-NewBitmapDict
-
-/AddBitmap {			% gloval-charname bitmap-data  |-  --
-    BitmapDictArray BitmapDictIndex get
-    dup length BitmapDictLength ge {
-	pop
-	NewBitmapDict
-	BitmapDictArray BitmapDictIndex get
-    } if
-    3 1 roll put
-} bind def
-
-/GetBitmap {			% gloval-charname  |-  bitmap-data
-    0 1 BitmapDictIndex { BitmapDictArray exch get begin } for
-    load
-    0 1 BitmapDictIndex { pop end } for
-} bind def
-
-%% Return a global character name which can be used as a key in the
-%% bitmap dictionary.
-/GlobalCharName {		% fontidx code1 code2  |-  gloval-charname
-    exch 256 mul add exch 65536 mul add 16777216 add 16 str7 cvrs 0 66 put
-    str7 cvn
-} bind def
-
-%% Character code holder for a 2-byte character.
-/FirstCode -1 def
-
-%% Glyph rendering procedure
-/BuildGlyphCommon {		% fontdict charname  |-  --
-    1 index /FontDimension get 1 eq { /FirstCode 0 store } if
-    NameIndexDict exch get	% STACK: fontdict charcode
-    FirstCode 0 lt { %ifelse
-	%% This is the first byte of a 2-byte character.  Just
-	%% remember it for the moment.
-	/FirstCode exch store
-	pop
-	0 0 setcharwidth
-    } {
-	1 index /FontSize get /size exch def
-	1 index /FontSpaceWidthRatio get /ratio exch def
-	1 index /FontIndex get exch FirstCode exch
-	GlobalCharName GetBitmap /bmp exch def
-	%% bmp == [ DWIDTH BBX-WIDTH BBX-HEIGHT BBX-XOFF BBX-YOFF BITMAP ]
-	Cmpchar { %ifelse
-	    /FontMatrix get [ exch { size div } forall ] /mtrx exch def
-	    bmp 3 get bmp 4 get mtrx transform
-	    /LLY exch def pop
-	    bmp 1 get bmp 3 get add bmp 2 get bmp 4 get add mtrx transform
-	    /URY exch def pop
-	} {
-	    pop
-	} ifelse
-	/FirstCode -1 store
-
-	bmp 0 get SpaceWidthRatio ratio div mul size div 0	% wx wy
-	setcharwidth			% We can't use setcachedevice here.
-
-	bmp 1 get 0 gt bmp 2 get 0 gt and {
-	    bmp 1 get bmp 2 get		% width height
-	    true			% polarity
-	    [ size 0 0 size neg bmp 3 get neg bmp 2 get bmp 4 get add ] % matrix
-	    bmp 5 1 getinterval cvx	% datasrc
-	    imagemask
-	} if
-    } ifelse
-} bind def
-
-/BuildCharCommon {
-    1 index /Encoding get exch get
-    1 index /BuildGlyph get exec
-} bind def
-
-%% Bitmap font creater
-
-%% Common Encoding shared by all bitmap fonts.
-/EncodingCommon 256 array def
-%% Mapping table from character name to character code.
-/NameIndexDict 256 dict def
-0 1 255 { %for
-    /idx exch def
-    /idxname idx 256 add 16 (XXX) cvrs dup 0 67 put cvn def % `C' == 67
-    EncodingCommon idx idxname put
-    NameIndexDict idxname idx put
-} for
-
-/GlobalFontIndex 0 def
-
-%% fontname dim col fontsize relative-compose baseline-offset fbbx  |-  --
-/BitmapFont {
-    15 dict begin
-    /FontBBox exch def
-    /BaselineOffset exch def
-    /RelativeCompose exch def
-    /FontSize exch def
-    /FontBBox [ FontBBox { FontSize div } forall ] def
-    FontBBox 2 get FontBBox 0 get sub exch div
-    /FontSpaceWidthRatio exch def
-    /FontDimension exch def
-    /FontIndex GlobalFontIndex def
-    /FontType 3 def
-    /FontMatrix matrix def
-    /Encoding EncodingCommon def
-    /BuildGlyph { BuildGlyphCommon } def
-    /BuildChar { BuildCharCommon } def
-    currentdict end
-    definefont pop
-    /GlobalFontIndex GlobalFontIndex 1 add def
-} bind def
-
-%% Define a new bitmap font.
-%% fontname dim col fontsize relative-compose baseline-offset fbbx  |-  --
-/NF {
-    /fbbx exch def
-    %% Convert BDF's FontBoundingBox to PostScript's FontBBox
-    [ fbbx 2 get fbbx 3 get
-      fbbx 2 get fbbx 0 get add fbbx 3 get fbbx 1 get add ]
-    BitmapFont
-} bind def
-
-%% Define a glyph for the specified font and character.
-/NG {				% fontname charcode bitmap-data  |-  --
-    /bmp exch def
-    exch findfont dup /BaselineOffset get bmp 4 get add bmp exch 4 exch put
-    /FontIndex get exch
-    dup 256 idiv exch 256 mod GlobalCharName
-    bmp AddBitmap
-} bind def
-%%%% End of bitmap font handler
-
-")
-
-;; External library support.
-
-;; The following three functions are to be called from external
-;; libraries which support bitmap fonts (e.g. `bdf') to get
-;; appropriate PostScript code.
-
-(defun ps-mule-generate-bitmap-prologue ()
-  (unless ps-mule-bitmap-prologue-generated
-    (setq ps-mule-bitmap-prologue-generated t)
-    (list ps-mule-bitmap-prologue)))
-
-(defun ps-mule-generate-bitmap-font (&rest args)
-  (list (apply 'format "/%s %d %d %f %S %d %S NF\n" args)))
-
-(defun ps-mule-generate-bitmap-glyph (font-name code dwidth bbx bitmap)
-  (format "/%s %d [ %d %d %d %d %d <%s> ] NG\n"
-	  font-name code
-	  dwidth (aref bbx 0) (aref bbx 1) (aref bbx 2) (aref bbx 3)
-	  bitmap))
-
-;; Mule specific initializers.
-
-(defun ps-mule-initialize ()
-  "Produce Poscript code in the prologue part for multi-byte characters."
-  (setq ps-mule-font-info-database
-	(cond ((eq ps-multibyte-buffer 'non-latin-printer)
-	       ps-mule-font-info-database-ps)
-	      ((eq ps-multibyte-buffer 'bdf-font)
-	       ps-mule-font-info-database-bdf)
-	      ((eq ps-multibyte-buffer 'bdf-font-except-latin)
-	       ps-mule-font-info-database-ps-bdf)
-	      (t
-	       ps-mule-font-info-database-latin))
-	ps-mule-current-charset 'ascii
-	ps-mule-font-cache nil
-	ps-mule-prologue-generated nil
-	ps-mule-cmpchar-prologue-generated nil
-	ps-mule-bitmap-prologue-generated nil)
-  (mapcar `(lambda (x) (setcar (cdr x) nil))
-	  ps-mule-external-libraries))
-
-(defun ps-mule-begin (from to)
-  (and (boundp 'enable-multibyte-characters)
-       enable-multibyte-characters
-       ;; Initialize `ps-mule-charset-list'.  If some characters aren't
-       ;; printable, warn it.
-       (let ((charsets (delete 'ascii (find-charset-region from to))))
-	 (setq ps-mule-charset-list charsets)
-	 (save-excursion
-	   (goto-char from)
-	   (and (search-forward "\200" to t)
-		(setq ps-mule-charset-list
-		      (cons 'composition ps-mule-charset-list))))
-	 (while charsets
-	   (cond
-	    ((or (eq (car charsets) 'composition)
-		 (ps-mule-printable-p (car charsets)))
-	     (setq charsets (cdr charsets)))
-	    ((y-or-n-p "Font for some characters not found, continue anyway? ")
-	     (setq charsets nil))
-	    (t
-	     (error "Printing cancelled"))))))
-
-  (if ps-mule-charset-list
-      (let ((the-list ps-mule-charset-list)
-	    font-spec)
-	(unless ps-mule-prologue-generated
-	  (ps-output-prologue ps-mule-prologue)
-	  (setq ps-mule-prologue-generated t))
-	;; If external functions are necessary, generate prologues for them.
-	(while the-list
-	  (cond ((and (eq (car the-list) 'composition)
-		      (not ps-mule-cmpchar-prologue-generated))
-		 (ps-output-prologue ps-mule-cmpchar-prologue)
-		 (setq ps-mule-cmpchar-prologue-generated t))
-		((setq font-spec (ps-mule-get-font-spec (car the-list) 'normal))
-		 (ps-mule-init-external-library font-spec)))
-	  (setq the-list (cdr the-list)))))
-
-  ;; If ASCII font is also specified in ps-mule-font-info-database,
-  ;; use it istead of what specified in ps-font-info-database.
-  (let ((font-spec (ps-mule-get-font-spec 'ascii 'normal)))
-    (if font-spec
-	(progn
-	  (unless ps-mule-prologue-generated
-	    (ps-output-prologue ps-mule-prologue)
-	    (setq ps-mule-prologue-generated t))
-	  (ps-mule-init-external-library font-spec)
-	  (let ((font (ps-font-alist 'ps-font-for-text))
-		(i 0))
-	    (while font
-	      (let ((ps-current-font i))
-		;; Be sure to download a glyph for SPACE in advance.
-		(ps-mule-prepare-font
-		 (ps-mule-get-font-spec 'ascii (car font))
-		 " " 'ascii 'no-setfont))
-	      (setq font (cdr font)
-		    i (1+ i))))))))
-
-;; For handling multi-byte characters -- End.
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-
 (defun ps-line-lengths-internal ()
   "Display the correspondence between a line length and a font size,
 using the current ps-print setup.
@@ -4558,9 +3495,7 @@ page-height == bm + print-height + tm - ho - hh
     (ps-output (format "/SpaceWidthRatio %f def\n"
 		       (/ (ps-lookup 'space-width) (ps-lookup 'size)))))
 
-  (ps-mule-initialize)
-
-  (ps-output "%%EndPrologue\n%%BeginSetup\nBeginDoc\n%%EndSetup\n\n"))
+  (ps-output "\n%%EndPrologue\n\n%%BeginSetup\nBeginDoc\n%%EndSetup\n"))
 
 (defun ps-header-dirpart ()
   (let ((fname (buffer-file-name)))
@@ -4592,21 +3527,13 @@ page-height == bm + print-height + tm - ho - hh
   (setq ps-showline-count (if ps-printing-region (car ps-printing-region) 1)
 	ps-page-count 0
 	ps-control-or-escape-regexp
-	(if ps-mule-charset-list
-	    (cond ((eq ps-print-control-characters '8-bit)
-		   "[^\040-\176]")
-		  ((eq ps-print-control-characters 'control-8-bit)
-		   (string-as-multibyte "[^\040-\176\240-\377]"))
-		  ((eq ps-print-control-characters 'control)
-		   (string-as-multibyte "[^\040-\176\200-\377]"))
-		  (t (string-as-multibyte "[^\000-\011\013\015-\377")))
-	  (cond ((eq ps-print-control-characters '8-bit)
-		 (string-as-unibyte "[\000-\037\177-\377]"))
-		((eq ps-print-control-characters 'control-8-bit)
-		 (string-as-unibyte "[\000-\037\177-\237]"))
-		((eq ps-print-control-characters 'control)
-		 "[\000-\037\177]")
-		(t "[\t\n\f]")))))
+	(cond ((eq ps-print-control-characters '8-bit)
+	       (string-as-unibyte "[\000-\037\177-\377]"))
+	      ((eq ps-print-control-characters 'control-8-bit)
+	       (string-as-unibyte "[\000-\037\177-\237]"))
+	      ((eq ps-print-control-characters 'control)
+	       "[\000-\037\177]")
+	      (t "[\t\n\f]"))))
 
 (defmacro ps-page-number ()
   `(1+ (/ (1- ps-page-count) ps-number-of-columns)))
@@ -4643,8 +3570,7 @@ page-height == bm + print-height + tm - ho - hh
 (defun ps-begin-page ()
   (ps-get-page-dimensions)
   (setq ps-width-remaining  ps-print-width
-	ps-height-remaining ps-print-height
-	ps-mule-current-charset 'ascii)
+	ps-height-remaining ps-print-height)
 
   (ps-header-page)
 
@@ -4661,7 +3587,8 @@ page-height == bm + print-height + tm - ho - hh
   (ps-output "BeginPage\n")
   (ps-set-font  ps-current-font)
   (ps-set-bg    ps-current-bg)
-  (ps-set-color ps-current-color))
+  (ps-set-color ps-current-color)
+  (ps-mule-begin-page))
 
 (defun ps-end-page ()
   (ps-output "EndPage\nEndDSCPage\n"))
@@ -4701,13 +3628,8 @@ EndDSCPage\n"))
   (let* ((wrappoint (ps-find-wrappoint from to
 				       (ps-avg-char-width 'ps-font-for-text)))
 	 (to (car wrappoint))
-	 (string (buffer-substring-no-properties from to))
-	 (font-spec
-	  (ps-mule-get-font-spec
-	   'ascii
-	   (car (nth ps-current-font (ps-font-alist 'ps-font-for-text))))))
-    (and font-spec
-	 (ps-mule-prepare-font font-spec string 'ascii))
+	 (string (buffer-substring-no-properties from to)))
+    (ps-mule-prepare-ascii-font string)
     (ps-output-string string)
     (ps-output " S\n")
     wrappoint))
@@ -4742,6 +3664,8 @@ EndDSCPage\n"))
 			 (/ q-done (/ q-todo 100)))
 		       ))))))
 
+(defvar ps-last-font nil)
+
 (defun ps-set-font (font)
   (setq ps-last-font (format "f%d" (setq ps-current-font font)))
   (ps-output (format "/%s F\n" ps-last-font)))
@@ -4785,8 +3709,6 @@ EndDSCPage\n"))
     (ps-output (number-to-string effects) " EF\n")
     (setq ps-current-effect effects)))
 
-  (setq ps-mule-current-charset 'ascii)
-
   ;; Starting at the beginning of the specified region...
   (save-excursion
     (goto-char from)
@@ -4799,9 +3721,7 @@ EndDSCPage\n"))
 	  (let* ((match-point (match-beginning 0))
 		 (match (char-after match-point)))
 	    (when (< from match-point)
-	      (unless (eq ps-mule-current-charset 'ascii)
-		(ps-set-font ps-current-font)
-		(setq ps-mule-current-charset 'ascii))
+	      (ps-mule-set-ascii-font)
 	      (ps-plot 'ps-basic-plot-string from match-point bg-color))
 	    (cond
 	     ((= match ?\t)		; tab
@@ -4809,9 +3729,7 @@ EndDSCPage\n"))
 		(forward-char -1)
 		(setq from (+ linestart (current-column)))
 		(when (re-search-forward "[ \t]+" to t)
-		  (unless (eq ps-mule-current-charset 'ascii)
-		    (ps-set-font ps-current-font)
-		    (setq ps-mule-current-charset 'ascii))
+		  (ps-mule-set-ascii-font)
 		  (ps-plot 'ps-basic-plot-whitespace
 			   from (+ linestart (current-column))
 			   bg-color))))
@@ -4829,17 +3747,15 @@ EndDSCPage\n"))
 	     ((> match 255)		; a multi-byte character
 	      (let ((charset (char-charset match)))
 		(or (eq charset 'composition)
-		    (ps-mule-skip-same-charset charset))
-		(setq ps-mule-current-charset charset)
+		    (while (eq (charset-after) charset)
+		      (forward-char 1)))
 		(ps-plot 'ps-mule-plot-string match-point (point) bg-color)))
 					; characters from ^@ to ^_ and
 	     (t				; characters from 127 to 255
 	      (ps-control-character match)))
 	    (setq from (point)))
 	;; region without control characters nor multi-byte characters
-	(when (not (eq ps-mule-current-charset 'ascii))
-	  (ps-set-font  ps-current-font)
-	  (setq ps-mule-current-charset 'ascii))
+	(ps-mule-set-ascii-font)
 	(ps-plot 'ps-basic-plot-string from to bg-color)
 	(setq from to)))))
 
@@ -4969,6 +3885,19 @@ If FACE is not a valid face name, it is used default face."
   (goto-char to))
 
 
+(defun ps-xemacs-face-kind-p (face kind kind-regex kind-list)
+  (let* ((frame-font (or (face-font-instance face)
+			 (face-font-instance 'default)))
+	 (kind-cons (and frame-font
+			 (assq kind
+			       (font-instance-properties frame-font))))
+	 (kind-spec (cdr-safe kind-cons))
+	 (case-fold-search t))
+    (or (and kind-spec (string-match kind-regex kind-spec))
+	;; Kludge-compatible:
+	(memq face kind-list))))
+
+
 (cond ((eq ps-print-emacs-type 'emacs)  ; emacs
 
        (defun ps-face-bold-p (face)
@@ -4982,18 +3911,6 @@ If FACE is not a valid face name, it is used default face."
 					; xemacs
 					; lucid
       (t				; epoch
-       (defun ps-xemacs-face-kind-p (face kind kind-regex kind-list)
-	 (let* ((frame-font (or (face-font-instance face)
-				(face-font-instance 'default)))
-		(kind-cons (and frame-font
-				(assq kind
-				      (font-instance-properties frame-font))))
-		(kind-spec (cdr-safe kind-cons))
-		(case-fold-search t))
-	   (or (and kind-spec (string-match kind-regex kind-spec))
-	       ;; Kludge-compatible:
-	       (memq face kind-list))))
-
        (defun ps-face-bold-p (face)
 	 (ps-xemacs-face-kind-p face 'WEIGHT_NAME "bold\\|demibold"
 				ps-bold-faces))
@@ -5243,9 +4160,11 @@ If FACE is not a valid face name, it is used default face."
 		    (setq needs-begin-file t))
 		(save-excursion
 		  (set-buffer ps-source-buffer)
-		  (and needs-begin-file (ps-begin-file))
-		  (ps-mule-begin from to)
+		  (when needs-begin-file
+		    (ps-begin-file)
+		    (ps-mule-initialize))
 		  (ps-begin-job)
+		  (ps-mule-begin-job from to)
 		  (ps-begin-page))
 		(set-buffer ps-source-buffer)
 		(funcall genfunc from to)
@@ -5304,7 +4223,9 @@ If FACE is not a valid face name, it is used default face."
       (save-excursion
 	(set-buffer ps-spool-buffer)
 	(let* ((coding-system-for-write 'raw-text-unix)
-	       (ps-printer-name (or ps-printer-name printer-name))
+	       (ps-printer-name (or ps-printer-name
+				    (and (boundp 'printer-name)
+					 printer-name)))
 	       (ps-lpr-switches
 		(append
 		 (and (stringp ps-printer-name)
@@ -5377,14 +4298,16 @@ If FACE is not a valid face name, it is used default face."
       (t
        (setq kill-emacs-hook 'ps-kill-emacs-check)))
 
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;; Sample Setup Code:
 
 ;; This stuff is for anybody that's brave enough to look this far,
 ;; and able to figure out how to use it.  It isn't really part of
 ;; ps-print, but I'll leave it here in hopes it might be useful:
 
-;; WARNING!!! The following code is *sample* code only. Don't use it
-;; unless you understand what it does!
+;; WARNING!!! The following code is *sample* code only.
+;; Don't use it unless you understand what it does!
 
 (defmacro ps-prsc ()
   `(if (eq ps-print-emacs-type 'emacs) [f22] 'f22))
@@ -5577,6 +4500,45 @@ If FACE is not a valid face name, it is used default face."
 	ps-header-title-font-size  8)
   'ps-jack-setup)
 
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; To make this file smaller, some commands go in a separate file.
+;; But autoload them here to make the separation invisible.
+
+(autoload 'ps-mule-prepare-ascii-font "ps-mule"
+  "Setup special ASCII font for STRING.
+STRING should contain only ASCII characters.")
+
+(autoload 'ps-mule-set-ascii-font     "ps-mule"
+  "Adjust current font if current charset is not ASCII.")
+
+(autoload 'ps-mule-plot-string        "ps-mule"
+  "Generate PostScript code for ploting characters in the region FROM and TO.
+
+It is assumed that all characters in this region belong to the same charset.
+
+Optional argument BG-COLOR specifies background color.
+
+Returns the value:
+
+	(ENDPOS . RUN-WIDTH)
+
+Where ENDPOS is the end position of the sequence and RUN-WIDTH is the width of
+the sequence.")
+
+(autoload 'ps-mule-initialize         "ps-mule"
+  "Initialize global data for printing multi-byte characters.")
+
+(autoload 'ps-mule-begin-job          "ps-mule"
+  "Start printing job for multi-byte chars between FROM and TO.
+This checks if all multi-byte characters in the region are printable or not.")
+
+(autoload 'ps-mule-begin-page         "ps-mule"
+  "Initialize multi-byte charset for printing current page.")
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
 (provide 'ps-print)
 
 ;;; ps-print.el ends here