Current File : //proc/thread-self/root/kunden/usr/share/emacs/27.2/lisp/international/ccl.elc

;ELC
;;; Compiled
;;; in Emacs version 27.2
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.

;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


#@35 Vector of CCL commands (symbols).
(defconst ccl-command-table [if branch loop break repeat write-repeat write-read-repeat read read-if read-branch write call end read-multibyte-character write-multibyte-character translate-character iterate-multiple-map map-multiple map-single lookup-integer lookup-character] (#$ . 408))
(byte-code "\301\302G

W\203\"H\262\303\304\305\306\307\"!#\210
T\262\202\266\207" [ccl-command-table nil 0 put ccl-compile-function intern format "ccl-compile-%s"] 10)
#@41 Vector of CCL compiled codes (symbols).
(defconst ccl-code-table [set-register set-short-const set-const set-array jump jump-cond write-register-jump write-register-read-jump write-const-jump write-const-read-jump write-string-jump write-array-read-jump read-jump branch read-register write-expr-const read-branch write-register write-expr-register call write-const-string write-array end set-assign-expr-const set-assign-expr-register set-expr-const set-expr-register jump-cond-expr-const jump-cond-expr-register read-jump-cond-expr-const read-jump-cond-expr-register ex-cmd] (#$ . 918))
#@50 Vector of CCL extended compiled codes (symbols).
(defconst ccl-extended-code-table [read-multibyte-character write-multibyte-character translate-character translate-character-const-tbl nil nil nil nil nil nil nil nil nil nil nil nil iterate-multiple-map map-multiple map-single lookup-int-const-tbl lookup-char-const-tbl] (#$ . 1513))
(byte-code "\302\303G

W\203(H\262\304\305#\210\304\306\307\310\311\"!#\210
T\262\202\266\302\303	G

W\203V	H\262\203O\304\312#\210\304\306\307\310\311\"!#\210
T\262\202.\266\207" [ccl-code-table ccl-extended-code-table nil 0 put ccl-code ccl-dump-function intern format "ccl-dump-%s" ccl-ex-code] 10)
(defconst ccl-jump-code-list '(jump jump-cond write-register-jump write-register-read-jump write-const-jump write-const-read-jump write-string-jump write-array-read-jump read-jump))
(byte-code "\211\203\301
@\302\303#\210\211A\262
\202
\207" [ccl-jump-code-list put jump-flag t] 5)
#@36 Vector of CCL registers (symbols).
(defconst ccl-register-table [r0 r1 r2 r3 r4 r5 r6 r7] (#$ . 2469))
(byte-code "\301\302G

W\203H\262\303\304#\210
T\262\202\266\207" [ccl-register-table nil 0 put ccl-register-number] 7)
#@55 Vector of CCL arithmetic/logical operators (symbols).
(defconst ccl-arith-table [+ - * / % & | ^ << >> <8 >8 // nil nil nil < > == <= >= != de-sjis en-sjis] (#$ . 2710))
(byte-code "\301\302G

W\203 H\262\203\303\304#\210
T\262\202\266\207" [ccl-arith-table nil 0 put ccl-arith-code] 7)
#@47 Vector of CCL assignment operators (symbols).
(defconst ccl-assign-arith-table [+= -= *= /= %= &= |= ^= <<= >>= <8= >8= //=] (#$ . 3017))
(byte-code "\301\302G

W\203H\262\303\304#\210
T\262\202\266\207" [ccl-assign-arith-table nil 0 put ccl-self-arith-code] 7)
#@55 Working vector of CCL codes produced by CCL compiler.
(defvar ccl-program-vector nil (#$ . 3297))
#@45 The current index for `ccl-program-vector'.
(defvar ccl-current-ic 0 (#$ . 3401))
#@55 Convert a CCL code word to a fixnum value.

(fn CODE)
(defalias 'ccl-fixnum #[257 "\300\301\302\"\303\"\303Z\207" [logxor logand 268435455 134217728] 5 (#$ . 3489)])
#@145 Embed integer DATA in `ccl-program-vector' at `ccl-current-ic' and
increment it.  If IC is specified, embed DATA at IC.

(fn DATA &optional IC)
(defalias 'ccl-embed-data #[513 "\211\203
\302!I\207G	
Y\203.\303
\304_\305\"
\306V\203-
S\262\211HI\210\202\210	\302!I\210	T\211\207" [ccl-program-vector ccl-current-ic ccl-fixnum make-vector 2 nil 0] 8 (#$ . 3663)])
#@233 Embed pair of SYMBOL and PROP where (get SYMBOL PROP) should give
proper index number for SYMBOL.  PROP should be
`translation-table-id', `translation-hash-table-id'
`code-conversion-map-id', or `ccl-program-idx'.

(fn SYMBOL PROP)
(defalias 'ccl-embed-symbol #[514 "\300B!\207" [ccl-embed-data] 5 (#$ . 4049)])
#@91 Embed string STR of length LEN in `ccl-program-vector' at
`ccl-current-ic'.

(fn LEN STR)
(defalias 'ccl-embed-string #[514 "
\300V\203\301\302\"\210\303
!V\203/
\304\211W\205.\211\305\306\307H\"!\266\211T\262
\202\207\304\211W\205n\305\306\310H\311\"TW\203P\310TH\312\"\202Q\304\313\\W\203b\313\\H\202c\304#!\210\211\314\\\262
\2020\207" [1048575 error "CCL: String too long: %d" string-bytes 0 ccl-embed-data logior 16777216 ash 16 8 2 3] 10 (#$ . 4369)])
#@128 Embed a relative jump address to `ccl-current-ic' in
`ccl-program-vector' at IC without altering the other bit field.

(fn IC)
(defalias 'ccl-embed-current-address #[257 "
TZ	\302	H\303\304\305\"!\"I\207" [ccl-current-ic ccl-program-vector logior ccl-fixnum ash 8] 10 (#$ . 4866)])
#@677 Embed CCL code for the operation OP and arguments REG and DATA in
`ccl-program-vector' at `ccl-current-ic' in the following format.
	|----------------- integer (28-bit) ------------------|
	|------------ 20-bit ------------|- 3-bit --|- 5-bit -|
	|------------- DATA -------------|-- REG ---|-- OP ---|
If REG2 is specified, embed a code in the following format.
	|------- 17-bit ------|- 3-bit --|- 3-bit --|- 5-bit -|
	|-------- DATA -------|-- REG2 --|-- REG ---|-- OP ---|

If REG is a CCL register symbol (e.g. r0, r1...), the register
number is embedded.  If OP is one of unconditional jumps, DATA is
changed to a relative jump address.

(fn OP REG DATA &optional REG2)
(defalias 'ccl-embed-code #[1027 "
\301V\203\302N\203
TZ\262\303\304N\3059\203\"\306N\202#\307\"\2039\303\305\306N\310\"\305\311\"\"\202=\305\310\"#\312
!\207" [ccl-current-ic 0 jump-flag logior ccl-code ash ccl-register-number 5 8 11 ccl-embed-data] 12 (#$ . 5160)])
#@169 extended ccl command format
	|- 14-bit -|- 3-bit --|- 3-bit --|- 3-bit --|- 5-bit -|
	|- EX-OP --|-- REG3 --|-- REG2 --|-- REG ---|-- OP ---|

(fn EX-OP REG REG2 REG3)
(defalias 'ccl-embed-extended-command #[1028 "\300\301\302N\303\"9\203\304N\202\305\"\306\307$\207" [logior ash ccl-ex-code 3 ccl-register-number 0 ccl-embed-code ex-cmd] 10 (#$ . 6131)])
#@49 Just advance `ccl-current-ic' by INC.

(fn INC)
(defalias 'ccl-increment-ic #[257 "
\\\211\207" [ccl-current-ic] 3 (#$ . 6504)])
#@53 If non-nil, index of the start of the current loop.
(defvar ccl-loop-head nil (#$ . 6641))
#@84 If non-nil, list of absolute addresses of the breaking points of
the current loop.
(defvar ccl-breaks nil (#$ . 6738))
#@84 Return the compiled code of CCL-PROGRAM as a vector of integers.

(fn CCL-PROGRAM)
(defalias 'ccl-compile #[257 "\211:\203\211@\250\203\211A@<\204\304\305\"\210\306!\204\"\307\310\311\"\312\211\311\313
@!\210\314\315!\210\316
A@!\210\313\315\"\210\317
8\203H\316\3178!\210\320\321\311\211#\210\307\311\"\311\211W\203g

HI\210\211T\262
\202S
\207" [ccl-program-vector ccl-loop-head ccl-breaks ccl-current-ic error "CCL: Invalid CCL program: %s" vectorp make-vector 8192 0 nil ccl-embed-data ccl-increment-ic 1 ccl-compile-1 2 ccl-embed-code end] 8 (#$ . 6863)])
#@32 Signal syntax error.

(fn CMD)
(defalias 'ccl-syntax-error #[257 "\300\301\"\207" [error "CCL: Syntax error: %s"] 4 (#$ . 7452)])
#@53 Check if ARG is a valid CCL register.

(fn ARG CMD)
(defalias 'ccl-check-register #[514 "
\300N\203
\207\301\302#\207" [ccl-register-number error "CCL: Invalid register %s in %s"] 6 (#$ . 7589)])
#@52 Check if ARG is a valid CCL command.

(fn ARG CMD)
(defalias 'ccl-check-compile-function #[514 "
\300N\206\n\301\302\"\207" [ccl-compile-function error "CCL: Invalid command: %s"] 5 (#$ . 7795)])
#@59 Compile CCL-BLOCK (see the syntax above).

(fn CCL-BLOCK)
(defalias 'ccl-compile-1 #[257 "\300\211\250\204;\204\203@9\203C\262\203y@\262
\211\250\2030\301\302\303E!\202p\211;\203;\304
!\202p\211<\203m\211A@\303=\203N\301
!\202p\211A@9\203c\211A@\305N\203c\306
!\202p\307
@\"
!\202p\310
!\262A\262\202
\207" [nil ccl-compile-set r0 = ccl-compile-write-string ccl-self-arith-code ccl-compile-self-set ccl-check-compile-function ccl-syntax-error] 7 (#$ . 7999)])
(defconst ccl-max-short-const (ash 1 19))
(defconst ccl-min-short-const (ash -1 19))
#@34 Compile SET statement.

(fn CMD)
(defalias 'ccl-compile-set #[257 "\302
@\"\3038\211<\203\304\"\210\202v\211\250\203<\211X\203/\211	Y\203/\305\306#\210\202v\305\307\310#\210\311
!\210\202v\302
\"\210\3128\313
!\203n\310
G\305\314$\210

W\203i\311H!\210
T\262\202V\266\202u\305\315\310$\210\210\266\316\207" [ccl-max-short-const ccl-min-short-const ccl-check-register 2 ccl-compile-expression ccl-embed-code set-short-const set-const 0 ccl-embed-data 3 vectorp set-array set-register nil] 11 (#$ . 8585)])
#@59 Compile SET statement with ASSIGNMENT_OPERATOR.

(fn CMD)
(defalias 'ccl-compile-self-set #[257 "\300
@\"\3018\211<\203\302\303\"\210\303\262
\302\211\304\305\306A@!\307\310#!E\"\266\311\207" [ccl-check-register 2 ccl-compile-expression r7 intern substring symbol-name 0 -1 nil] 11 (#$ . 9130)])
#@66 Compile SET statement of the form `(RRR = EXPR)'.

(fn RRR EXPR)
(defalias 'ccl-compile-expression #[514 "\211@
A@\301N\3028<\203\303\304\"\210\304\262=\203L
GW\203L\211\250\203:\305\306\307\310\"\311$\210\312
!\202y\313
\"\210\305\314\307\310\"$\202y\211\250\203c\305\315\307\310\"$\210\312
!\202y\313
\"\210\305\316\317\307\310\"\320N\"$\207" [ccl-assign-arith-table ccl-arith-code 2 ccl-compile-expression r7 ccl-embed-code set-assign-expr-const ash 3 r0 ccl-embed-data ccl-check-register set-assign-expr-register set-expr-const set-expr-register logior ccl-register-number] 12 (#$ . 9442)])
#@57 Compile WRITE statement with string argument.

(fn STR)
(defalias 'ccl-compile-write-string #[257 "\211G\300\301\302#\210\303
\"\266\304\207" [ccl-embed-code write-const-string 1 ccl-embed-string nil] 6 (#$ . 10080)])
#@209 Compile IF statement of the form `(if CONDITION TRUE-PART FALSE-PART)'.
If READ-FLAG is non-nil, this statement has the form
`(read-if (REG OPERATOR ARG) TRUE-PART FALSE-PART)'.

(fn CMD &optional READ-FLAG)
(defalias 'ccl-compile-if #[513 "
G\301U\204
G\302U\204\303\304\"\210
A@\3058\3018\306<\203?@<\203?\307\310@\"\210\310AB\262@AABB\262\262
9\203V\311\"\210\312\313\314#\210\202\264@A@\315N\3058\311\n\"\210
\250\204t\303\316A@\"\210\211\250\203\223\312\203\203\317\202\204\320\314#\210\321!\210\321
!\210\202\262\311
\n\"\210\312\203\243\322\202\244\323\314#\210\321!\210\321
\324N!\210\266\325!\204\305\326!\210\306\262
\202\351\306
\204\323\262
\312\327\314\211#\210\326!\210\325!\205\336
\262\211\203\350\326
!\210\210\211\262
\207" [ccl-current-ic 3 4 error "CCL: Invalid number of arguments: %s" 2 nil ccl-compile-expression r7 ccl-check-register ccl-embed-code jump-cond 0 ccl-arith-code "CCL: invalid operator: %s" read-jump-cond-expr-const jump-cond-expr-const ccl-embed-data read-jump-cond-expr-register jump-cond-expr-register ccl-register-number ccl-compile-1 ccl-embed-current-address jump] 13 (#$ . 10308)])
#@37 Compile BRANCH statement.

(fn CMD)
(defalias 'ccl-compile-branch #[257 "\211G\300W\203\f\301\302\"\210\303\304\305A@\"AA#\207" [3 error "CCL: Invalid number of arguments: %s" ccl-compile-branch-blocks branch ccl-compile-branch-expression] 6 (#$ . 11505)])
#@86 Compile READ statement of the form `(read-branch EXPR BLOCK0 BLOCK1 ...)'.

(fn CMD)
(defalias 'ccl-compile-read-branch #[257 "\211G\300W\203\f\301\302\"\210\303\304\305A@\"AA#\207" [3 error "CCL: Invalid number of arguments: %s" ccl-compile-branch-blocks read-branch ccl-compile-branch-expression] 6 (#$ . 11773)])
#@119 Compile EXPRESSION part of BRANCH statement and return register
which holds a value of the expression.

(fn EXPR CMD)
(defalias 'ccl-compile-branch-expression #[514 "
<\203\f\300\301\"\210\301\207\302\"\207" [ccl-compile-expression r7 ccl-check-register] 5 (#$ . 12101)])
#@184 Compile BLOCKs of BRANCH statement.  CODE is 'branch or 'read-branch.
REG is a register which holds a value of EXPRESSION part.  BLOCKs
is a list of CCL-BLOCKs.

(fn CODE RRR BLOCKS)
(defalias 'ccl-compile-branch-blocks #[771 "\211G\301\211\211\211\211\302		#\210\262\303T!\210C\262\304\262\203b@\2046B\262\305\262
\202V\306Z\\\"\210\307@!\262
\211\204VB\262\302\310\304\211#\210T\262A\262\202 \211\204m
A\262S
\203}\311@!\210
A\262\202m\203\222\306Z@\\\"\210A\262\202}\266\301\207" [ccl-current-ic nil ccl-embed-code ccl-increment-ic 0 t ccl-embed-data ccl-compile-1 jump ccl-embed-current-address] 13 (#$ . 12384)])
#@35 Compile LOOP statement.

(fn CMD)
(defalias 'ccl-compile-loop #[257 "\211G\303W\203\f\304\305\"\210\306\211
A\262
\205F\307\262

\2031\310@!\205(\211\262

A\262\202\n\203E\n\203E\311\n@!\210\nA\211\2049\306*\207" [ccl-current-ic ccl-loop-head ccl-breaks 2 error "CCL: Invalid number of arguments: %s" nil t ccl-compile-1 ccl-embed-current-address] 5 (#$ . 13064)])
#@36 Compile BREAK statement.

(fn CMD)
(defalias 'ccl-compile-break #[257 "\211G\303U\204\f\304\305\"\210\204\304\306\"\210	\nB\307\310\311\211#\210\312\207" [ccl-loop-head ccl-current-ic ccl-breaks 1 error "CCL: Invalid number of arguments: %s" "CCL: No outer loop: %s" ccl-embed-code jump 0 t] 5 (#$ . 13452)])
#@37 Compile REPEAT statement.

(fn CMD)
(defalias 'ccl-compile-repeat #[257 "\211G\301U\204\f\302\303\"\210\204\302\304\"\210\305\306\307#\210\310\207" [ccl-loop-head 1 error "CCL: Invalid number of arguments: %s" "CCL: No outer loop: %s" ccl-embed-code jump 0 t] 5 (#$ . 13774)])
#@43 Compile WRITE-REPEAT statement.

(fn CMD)
(defalias 'ccl-compile-write-repeat #[257 "\211G\301U\204\f\302\303\"\210\204\302\304\"\210\211A@\211\250\203*\305\306\307#\210\310
!\210\202O\211;\203D\211G\305\311\307#\210\310
!\210\312
\"\266\202O\313
\"\210\305\314#\210\210\315\207" [ccl-loop-head 2 error "CCL: Invalid number of arguments: %s" "CCL: No outer loop: %s" ccl-embed-code write-const-jump 0 ccl-embed-data write-string-jump ccl-embed-string ccl-check-register write-register-jump t] 7 (#$ . 14064)])
#@48 Compile WRITE-READ-REPEAT statement.

(fn CMD)
(defalias 'ccl-compile-write-read-repeat #[257 "\211G\301W\204\211G\302V\203\303\304\"\210\204\303\305\"\210\306
A@\"\3018\211\2042\307\310#\210\202r\211\250\203A\307\311$\210\202r\312
!\203l\211G\313\307\314#\210\315!\210\211W\203g\315H!\210\211T\262
\202T\266\202r\303\316#\210\307\317#\266\320\207" [ccl-loop-head 2 3 error "CCL: Invalid number of arguments: %s" "CCL: No outer loop: %s" ccl-check-register ccl-embed-code write-register-read-jump write-const-read-jump vectorp 0 write-array-read-jump ccl-embed-data "CCL: Invalid argument %s: %s" read-jump t] 9 (#$ . 14597)])
#@35 Compile READ statement.

(fn CMD)
(defalias 'ccl-compile-read #[257 "\211G\300W\203\f\301\302\"\210\211A\211GS
\203+\303@\"\304\305#\210A\262
S\266\202\202\266\306\207" [2 error "CCL: Invalid number of arguments: %s" ccl-check-register ccl-embed-code read-register nil] 8 (#$ . 15266)])
#@38 Compile READ-IF statement.

(fn CMD)
(defalias 'ccl-compile-read-if #[257 "\300
\301\"\207" [ccl-compile-if read] 4 (#$ . 15571)])
#@36 Compile WRITE statement.

(fn CMD)
(defalias 'ccl-compile-write #[257 "\211G\300W\203\f\301\302\"\210\211A@\211\250\203,\211\303V\203#\304\305!!\210\202\372\306\307\310#\210\202\372\211;\2038\304
!\210\202\372\2119\203|\311\3008!\203|\312
\"\210\3008\211G\310\306\313#\210\211W\203w
H\250\204j\301\314#\210\315H!\210\211T\262
\202V\266\202\372\2119\203\247
A\211GS
\203\242\312@\"\262\306\316#\210
A\262\211S\262
\202\206\266\202\372\211<\203\365\211@
A@\317N\3008<\203\303\320\321\"\210\321\262\211\250\203\332\306\322\310\323\324\"$\210\315
!\210\202\360\312
\"\210\306\325\310\326\323\324\"\327N\"$\210\266\202\372\301\330\"\210\210\331\207" [2 error "CCL: Invalid number of arguments: %s" 1048575 ccl-compile-write-string string ccl-embed-code write-const-string 0 vectorp ccl-check-register write-array "CCL: Invalid argument %s: %s" ccl-embed-data write-register ccl-arith-code ccl-compile-expression r7 write-expr-const ash 3 write-expr-register logior ccl-register-number "CCL: Invalid argument: %s" nil] 12 (#$ . 15708)])
#@35 Compile CALL statement.

(fn CMD)
(defalias 'ccl-compile-call #[257 "\211G\300U\204\f\301\302\"\210\211A@9\204\301\303\"\210\304\305\306\307#\210\310
A@\311\"\210\312\207" [2 error "CCL: Invalid number of arguments: %s" "CCL: Subroutine should be a symbol: %s" ccl-embed-code call 1 0 ccl-embed-symbol ccl-program-idx nil] 5 (#$ . 16805)])
#@34 Compile END statement.

(fn CMD)
(defalias 'ccl-compile-end #[257 "\211G\300U\204\f\301\302\"\210\303\304\305\211#\210\306\207" [1 error "CCL: Invalid number of arguments: %s" ccl-embed-code end 0 t] 5 (#$ . 17156)])
#@45 Compile read-multibyte-character.

(fn CMD)
(defalias 'ccl-compile-read-multibyte-character #[257 "\211G\300U\204\f\301\302\"\210\211A@\3038\304
\"\210\304\"\210\305\306\307$\266\310\207" [3 error "CCL: Invalid number of arguments: %s" 2 ccl-check-register ccl-embed-extended-command read-multibyte-character 0 nil] 8 (#$ . 17381)])
#@46 Compile write-multibyte-character.

(fn CMD)
(defalias 'ccl-compile-write-multibyte-character #[257 "\211G\300U\204\f\301\302\"\210\211A@\3038\304
\"\210\304\"\210\305\306\307$\266\310\207" [3 error "CCL: Invalid number of arguments: %s" 2 ccl-check-register ccl-embed-extended-command write-multibyte-character 0 nil] 8 (#$ . 17729)])
#@40 Compile translate-character.

(fn CMD)
(defalias 'ccl-compile-translate-character #[257 "\211G\300U\204\f\301\302\"\210\211A@\3038\3048\305
\"\210\305\"\2109\2039\306N\2049\307\310\311$\210\312\313\"\210\202F\305\"\210\307\314$\210\266\315\207" [4 error "CCL: Invalid number of arguments: %s" 2 3 ccl-check-register ccl-register-number ccl-embed-extended-command translate-character-const-tbl 0 ccl-embed-symbol translation-table-id translate-character nil] 9 (#$ . 18080)])
#@35 Compile lookup-integer.

(fn CMD)
(defalias 'ccl-compile-lookup-integer #[257 "\211G\300U\204\f\301\302\"\210\211A@\3038\3048\305\"\210\305
\"\2109\2039\306N\2049\307\310\311$\210\312\313\"\210\202J\301\314\"\210\305\"\210\307\315\311$\210\266\316\207" [4 error "CCL: Invalid number of arguments: %s" 2 3 ccl-check-register ccl-register-number ccl-embed-extended-command lookup-int-const-tbl 0 ccl-embed-symbol translation-hash-table-id "CCL: non-constant table: %s" lookup-int nil] 9 (#$ . 18583)])
#@37 Compile lookup-character.

(fn CMD)
(defalias 'ccl-compile-lookup-character #[257 "\211G\300U\204\f\301\302\"\210\211A@\3038\3048\305\"\210\305
\"\2109\2039\306N\2049\307\310\311$\210\312\313\"\210\202J\301\314\"\210\305\"\210\307\315\311$\210\266\316\207" [4 error "CCL: Invalid number of arguments: %s" 2 3 ccl-check-register ccl-register-number ccl-embed-extended-command lookup-char-const-tbl 0 ccl-embed-symbol translation-hash-table-id "CCL: non-constant table: %s" lookup-char nil] 9 (#$ . 19110)])
#@12 

(fn CMD)
(defalias 'ccl-compile-iterate-multiple-map #[257 "\300\301\"\210\302\207" [ccl-compile-multiple-map-function iterate-multiple-map nil] 4 (#$ . 19643)])
#@12 

(fn CMD)
(defalias 'ccl-compile-map-multiple #[257 "\211G\300U\204\f\301\302\"\210\303C\303
\304\305\306\307\310!\311\"\312\313%\240\210\314@A@\3158E\242\3168\303\"\"\262
\317\320\"\266\303\207" [4 error "CCL: Invalid number of arguments: %s" nil make-byte-code 514 "\301\302\211\203<@:\203$\300\242@\303\"\262
\304\"\262\211@[T\262
\2020\304@C\"\262\305\262
A\262
\\\262\202\203G[B\202H
\207" vconcat vector [0 nil t append 1] 8 "\n\n(fn ARG MP)" append 2 3 ccl-compile-multiple-map-function map-multiple] 10 (#$ . 19814)])
#@12 

(fn CMD)
(defalias 'ccl-compile-map-single #[257 "\211G\300U\204\f\301\302\"\210\211A@\3038\3048\305\"\210\305\"\210\306\307\310$\210\2119\203A\211\311N\2039\312
\313\"\210\202F\301\314\"\210\202F\301\315\"\210\266\316\207" [4 error "CCL: Invalid number of arguments: %s" 2 3 ccl-check-register ccl-embed-extended-command map-single 0 code-conversion-map ccl-embed-symbol code-conversion-map-id "CCL: Invalid map: %s" "CCL: Invalid type of arguments: %s" nil] 9 (#$ . 20384)])
#@20 

(fn COMMAND CMD)
(defalias 'ccl-compile-multiple-map-function #[514 "\211G\300W\203\f\301\302\"\210\211A@\3038\304\233\305\306\"\210\306\"\210\307\310$\210\311G!\210
\205l
@\262
\2119\203S\211\312N\203K\313
\314\"\210\202e\301\315\"\210\202e\211\247\203_\311
!\210\202e\301\316\"\210
A\262\2020\207" [4 error "CCL: Invalid number of arguments: %s" 2 3 nil ccl-check-register ccl-embed-extended-command 0 ccl-embed-data code-conversion-map ccl-embed-symbol code-conversion-map-id "CCL: Invalid map: %s" "CCL: Invalid type of arguments: %s"] 11 (#$ . 20886)])
#@48 Disassemble compiled CCL-code CODE.

(fn CODE)
(defalias 'ccl-dump #[257 "\211\211G\302H\211\302U\203\303\304!c\210\202'\211\305U\203!\306c\210\202'\307\310\"c\210\311c\210\312\305H\302V\203E	\305HW\203B\313 \210\2024\314c\210	W\205Q\313 \210\202E)\207" [ccl-code ccl-current-ic 0 substitute-command-keys "Don't output anything.\n" 1 "Out-buffer must be as large as in-buffer.\n" format "Out-buffer must be %d times bigger than in-buffer.\n" "Main-body:\n" 2 ccl-dump-1 "At EOF:\n"] 6 (#$ . 21480)])
#@54 Return a CCL code in `ccl-code' at `ccl-current-ic'.
(defalias 'ccl-get-next-code #[0 "	H\211\247\203\302
!\202\211\262
	T\207" [ccl-code ccl-current-ic ccl-fixnum] 3 (#$ . 22003)])
(defalias 'ccl-dump-1 #[0 "\302 \303\304\"H\305\303\306\"\307\"\305\310\"\311\312	S#c\210\313N\"\207" [ccl-code-table ccl-current-ic ccl-get-next-code logand 31 ash 255 -5 -8 format "%5d:[%s] " ccl-dump-function] 8])
#@15 

(fn RRR CC)
(defalias 'ccl-dump-set-register #[514 "\300\301#c\207" [format "r%d = r%d\n"] 6 (#$ . 22422)])
#@15 

(fn RRR CC)
(defalias 'ccl-dump-set-short-const #[514 "\300\301#c\207" [format "r%d = %d\n"] 6 (#$ . 22540)])
#@19 

(fn RRR IGNORE)
(defalias 'ccl-dump-set-const #[514 "\300\301\302 #c\207" [format "r%d = %d\n" ccl-get-next-code] 6 (#$ . 22660)])
#@15 

(fn RRR CC)
(defalias 'ccl-dump-set-array #[514 "\300
\301\"\302\303\"\304\305\306$c\210\211W\203&\305\307\310 \"c\210\211T\262
\202\311c\207" [logand 7 ash -3 0 format "r%d = array[r%d] of length %d\n	" "%d " ccl-get-next-code "\n"] 10 (#$ . 22800)])
#@36 

(fn IGNORE CC &optional ADDRESS)
(defalias 'ccl-dump-jump #[770 "\301\302\206\\\"c\210
\303Y\203\304c\210\301\305T\"c\207" [ccl-current-ic format "jump to %d(" 0 "+" "%d)\n"] 7 (#$ . 23069)])
#@15 

(fn RRR CC)
(defalias 'ccl-dump-jump-cond #[514 "\300\301\"c\210\302\303\"\207" [format "if (r%d == 0), " ccl-dump-jump nil] 5 (#$ . 23277)])
#@15 

(fn RRR CC)
(defalias 'ccl-dump-write-register-jump #[514 "\300\301\"c\210\302\303\"\207" [format "write r%d, " ccl-dump-jump nil] 5 (#$ . 23429)])
#@15 

(fn RRR CC)
(defalias 'ccl-dump-write-register-read-jump #[514 "\300\301\211#c\210\302\303\"\210\304 \207" [format "write r%d, read r%d, " ccl-dump-jump nil ccl-get-next-code] 6 (#$ . 23587)])
#@11 

(fn CC)
(defalias 'ccl-extract-arith-op #[257 "\301\302\"H\207" [ccl-arith-table ash -6] 5 (#$ . 23790)])
#@18 

(fn IGNORE CC)
(defalias 'ccl-dump-write-expr-const #[514 "\300\301\302\303\"\304!\305 $c\207" [format "write (r%d %s %d)\n" logand 7 ccl-extract-arith-op ccl-get-next-code] 7 (#$ . 23906)])
#@18 

(fn IGNORE CC)
(defalias 'ccl-dump-write-expr-register #[514 "\300\301\302\303\"\304!\302\305\306\"\303\"$c\207" [format "write (r%d %s r%d)\n" logand 7 ccl-extract-arith-op ash -3] 10 (#$ . 24107)])
#@11 

(fn CC)
(defalias 'ccl-dump-insert-char #[257 "\211\300U\203	\301c\207\211\302U\203\303c\207\304\305\"c\207" [9 " \"^I\"" 10 " \"^J\"" format " \"%c\""] 4 (#$ . 24319)])
#@18 

(fn IGNORE CC)
(defalias 'ccl-dump-write-const-jump #[514 "\301c\210\302\303 !\210\304c\210\305\306#\207" [ccl-current-ic "write char" ccl-dump-insert-char ccl-get-next-code ", " ccl-dump-jump nil] 7 (#$ . 24501)])
#@15 

(fn RRR CC)
(defalias 'ccl-dump-write-const-read-jump #[514 "\301c\210\302\303 !\210\304\305\"c\210\306\"\210\303 \207" [ccl-current-ic "write char" ccl-dump-insert-char ccl-get-next-code format ", read r%d, " ccl-dump-jump] 6 (#$ . 24727)])
#@18 

(fn IGNORE CC)
(defalias 'ccl-dump-write-string-jump #[514 "\301 \302\303c\210\211W\203<\301 \304
\305\"c\210
TW\203%\306\304\307\"\310\"c\210
\311\\W\2033\306
\310\"c\210\210\211\312\\\262
\202\313c\210\314\315#\207" [ccl-current-ic ccl-get-next-code 0 "write \"" ash -16 logand -8 255 2 3 "\", " ccl-dump-jump nil] 10 (#$ . 24981)])
#@15 

(fn RRR CC)
(defalias 'ccl-dump-write-array-read-jump #[514 "\301 \302\303\304#c\210\211W\203\305\301 !\210\211T\262
\202\f\303\306\"c\210\307\310#\210\301 \207" [ccl-current-ic ccl-get-next-code 0 format "write array[r%d] of length %d,\n	" ccl-dump-insert-char "\n	then read r%d, " ccl-dump-jump nil] 9 (#$ . 25336)])
#@15 

(fn RRR CC)
(defalias 'ccl-dump-read-jump #[514 "\300\301\"c\210\302\303\"\207" [format "read r%d, " ccl-dump-jump nil] 5 (#$ . 25675)])
#@16 

(fn RRR LEN)
(defalias 'ccl-dump-branch #[514 "\301\302\303#c\210\211X\203\302\304\305 \\\"c\210\211T\262
\202	\306c\207" [ccl-current-ic 0 format "jump to array[r%d] of length %d\n	" "%d " ccl-get-next-code "\n"] 8 (#$ . 25822)])
#@15 

(fn RRR CC)
(defalias 'ccl-dump-read-register #[514 "\300\301#c\207" [format "read r%d (%d remaining)\n"] 6 (#$ . 26069)])
#@16 

(fn RRR LEN)
(defalias 'ccl-dump-read-branch #[514 "\300\301\"c\210\302\"\207" [format "read r%d, " ccl-dump-branch] 5 (#$ . 26202)])
#@15 

(fn RRR CC)
(defalias 'ccl-dump-write-register #[514 "\300\301#c\207" [format "write r%d (%d remaining)\n"] 6 (#$ . 26347)])
#@18 

(fn IGNORE CC)
(defalias 'ccl-dump-call #[514 "\300 @\301\302\"c\207" [ccl-get-next-code format-message "call subroutine `%s'\n"] 6 (#$ . 26482)])
#@15 

(fn RRR CC)
(defalias 'ccl-dump-write-const-string #[514 "
\300U\203\301c\210\302
!\210\303 \207\211\300\304c\210\211W\203i\305 \306
\307\"\300U\2043\306
\310\"c\210
T\262\202e\311\312\313\314\"\"c\210
TW\203O\311\312\306\313\315\"\316\"\"c\210
\317\\W\203`\311\312\306\316\"\"c\210
\320\\\262\210\202\321c\207" [0 "write char" ccl-dump-insert-char newline "write \"" ccl-get-next-code logand 16777216 16777215 format "%c" ash -16 -8 255 2 3 "\"\n"] 11 (#$ . 26638)])
#@15 

(fn RRR CC)
(defalias 'ccl-dump-write-array #[514 "\300\301\302#c\210\211W\203\303\304 !\210\211T\262
\202\305c\207" [0 format "write array[r%d] of length %d\n	" ccl-dump-insert-char ccl-get-next-code "\n"] 7 (#$ . 27131)])
#@21 

(fn &rest IGNORE)
(defalias 'ccl-dump-end #[128 "\300c\207" ["end\n"] 2 (#$ . 27370)])
#@15 

(fn RRR CC)
(defalias 'ccl-dump-set-assign-expr-const #[514 "\300\301\302!\303 $c\207" [format "r%d %s= %d\n" ccl-extract-arith-op ccl-get-next-code] 7 (#$ . 27465)])
#@15 

(fn RRR CC)
(defalias 'ccl-dump-set-assign-expr-register #[514 "\300\301\302!\303\304\"$c\207" [format "r%d %s= r%d\n" ccl-extract-arith-op logand 7] 9 (#$ . 27642)])
#@15 

(fn RRR CC)
(defalias 'ccl-dump-set-expr-const #[514 "\300\301\302\303\"\304!\305 %c\207" [format "r%d = r%d %s %d\n" logand 7 ccl-extract-arith-op ccl-get-next-code] 8 (#$ . 27820)])
#@15 

(fn RRR CC)
(defalias 'ccl-dump-set-expr-register #[514 "\300\301\302\303\"\304!\302\305\306\"\303\"%c\207" [format "r%d = r%d %s r%d\n" logand 7 ccl-extract-arith-op ash -3] 11 (#$ . 28015)])
#@15 

(fn RRR CC)
(defalias 'ccl-dump-jump-cond-expr-const #[514 "\302\303	\304 H\304 $c\210\305\306#\207" [ccl-current-ic ccl-arith-table format "if !(r%d %s %d), " ccl-get-next-code ccl-dump-jump nil] 8 (#$ . 28221)])
#@15 

(fn RRR CC)
(defalias 'ccl-dump-jump-cond-expr-register #[514 "\302\303	\304 H\304 $c\210\305\306#\207" [ccl-current-ic ccl-arith-table format "if !(r%d %s r%d), " ccl-get-next-code ccl-dump-jump nil] 8 (#$ . 28447)])
#@15 

(fn RRR CC)
(defalias 'ccl-dump-read-jump-cond-expr-const #[514 "\300\301\"c\210\302\"\207" [format "read r%d, " ccl-dump-jump-cond-expr-const] 5 (#$ . 28677)])
#@15 

(fn RRR CC)
(defalias 'ccl-dump-read-jump-cond-expr-register #[514 "\300\301\"c\210\302\"\207" [format "read r%d, " ccl-dump-jump-cond-expr-register] 5 (#$ . 28849)])
#@13 

(fn CODE)
(defalias 'ccl-dump-binary #[257 "\211\211G\302\211W\205O
H\303\211\304Y\203/\305\306\307\"\"\304U\203%\310\202&\311c\210\211S\262
\202\305\312\"\262
	GW\203D\313\314	H\"c\210\315c\266\211T\262
\202)\207" [ccl-code ccl-code-table 2 27 0 logand ash 1 48 49 31 format ":%s" "\n"] 10 (#$ . 29027)])
#@15 

(fn RRR CC)
(defalias 'ccl-dump-ex-cmd #[514 "\301
\302\"\301\303\304\"\302\"\301\303\305\"\306\"H\307\310\"c\210\211\311N#\207" [ccl-extended-code-table logand 7 ash -3 -6 16383 format "<%s> " ccl-dump-function] 9 (#$ . 29359)])
#@20 

(fn RRR RRR RRR)
(defalias 'ccl-dump-read-multibyte-character #[771 "\300\301#c\207" [format "read-multibyte-character r%d r%d\n"] 7 (#$ . 29604)])
#@20 

(fn RRR RRR RRR)
(defalias 'ccl-dump-write-multibyte-character #[771 "\300\301#c\207" [format "write-multibyte-character r%d r%d\n"] 7 (#$ . 29762)])
#@20 

(fn RRR RRR RRR)
(defalias 'ccl-dump-translate-character #[771 "\300\301$c\207" [format "translation table(r%d) r%d r%d\n"] 8 (#$ . 29922)])
#@20 

(fn RRR RRR RRR)
(defalias 'ccl-dump-translate-character-const-tbl #[771 "\300 \301\302$c\207" [ccl-get-next-code format "translation table(%S) r%d r%d\n"] 9 (#$ . 30075)])
#@20 

(fn RRR RRR RRR)
(defalias 'ccl-dump-lookup-int-const-tbl #[771 "\300 \301\302$c\207" [ccl-get-next-code format "hash table(%S) r%d r%d\n"] 9 (#$ . 30260)])
#@20 

(fn RRR RRR RRR)
(defalias 'ccl-dump-lookup-char-const-tbl #[771 "\300 \301\302$c\207" [ccl-get-next-code format "hash table(%S) r%d r%d\n"] 9 (#$ . 30429)])
#@20 

(fn RRR RRR RRR)
(defalias 'ccl-dump-iterate-multiple-map #[771 "\300 \301\302\303\304#c\210\303\305\"c\210
W\203*\300 \262
\303\306\"c\210
T\262\202\307c\207" [ccl-get-next-code 0 nil format "iterate-multiple-map r%d r%d\n" "	number of maps is %d .\n	 [" "%S" "]\n"] 10 (#$ . 30599)])
#@20 

(fn RRR RRR RRR)
(defalias 'ccl-dump-map-multiple #[771 "\300 \301\302\303\304#c\210\303\305\"c\210
W\2036\300 \262
\211\306U\203)\307c\210\202/\303\310\"c\210
T\262\202\311c\207" [ccl-get-next-code 0 nil format "map-multiple r%d r%d\n" "	number of maps and separators is %d\n	 [" -1 "]\n	 [" "%S " "]\n"] 10 (#$ . 30904)])
#@20 

(fn RRR RRR RRR)
(defalias 'ccl-dump-map-single #[771 "\300 \301\302$c\207" [ccl-get-next-code format "map-single r%d r%d map(%S)\n"] 9 (#$ . 31249)])
#@415 Declare NAME as a name of CCL program.

This macro exists for backward compatibility.  In the old version of
Emacs, to compile a CCL program which calls another CCL program not
yet defined, it must be declared as a CCL program in advance.  But,
now CCL program names are resolved not at compile time but before
execution.

Optional arg VECTOR is a compiled CCL code of the CCL program.

(fn NAME &optional VECTOR)
(defalias 'declare-ccl-program '(macro . #[513 "\300\301D\302\303\301DEF\207" [put quote 'ccl-program-idx register-ccl-program] 8 (#$ . 31413)]))
#@7841 Set NAME the compiled code of CCL-PROGRAM.

CCL-PROGRAM has this form:
	(BUFFER_MAGNIFICATION
	 CCL_MAIN_CODE
	 [ CCL_EOF_CODE ])

BUFFER_MAGNIFICATION is an integer value specifying the approximate
output buffer magnification size compared with the bytes of input data
text.  It is assured that the actual output buffer has 256 bytes
more than the size calculated by BUFFER_MAGNIFICATION.
If the value is zero, the CCL program can't execute `read' and
`write' commands.

CCL_MAIN_CODE and CCL_EOF_CODE are CCL program codes.  CCL_MAIN_CODE
executed at first.  If there's no more input data when `read' command
is executed in CCL_MAIN_CODE, CCL_EOF_CODE is executed.  If
CCL_MAIN_CODE is terminated, CCL_EOF_CODE is not executed.

Here's the syntax of CCL program code in BNF notation.  The lines
starting by two semicolons (and optional leading spaces) describe the
semantics.

CCL_MAIN_CODE := CCL_BLOCK

CCL_EOF_CODE := CCL_BLOCK

CCL_BLOCK := STATEMENT | (STATEMENT [STATEMENT ...])

STATEMENT :=
	SET | IF | BRANCH | LOOP | REPEAT | BREAK | READ | WRITE | CALL
	| TRANSLATE | MAP | LOOKUP | END

SET :=	(REG = EXPRESSION)
	| (REG ASSIGNMENT_OPERATOR EXPRESSION)
	;; The following form is the same as (r0 = integer).
	| integer

EXPRESSION := ARG | (EXPRESSION OPERATOR ARG)

;; Evaluate EXPRESSION.  If the result is nonzero, execute
;; CCL_BLOCK_0.  Otherwise, execute CCL_BLOCK_1.
IF :=	(if EXPRESSION CCL_BLOCK_0 CCL_BLOCK_1)

;; Evaluate EXPRESSION.  Provided that the result is N, execute
;; CCL_BLOCK_N.
BRANCH := (branch EXPRESSION CCL_BLOCK_0 [CCL_BLOCK_1 ...])

;; Execute STATEMENTs until (break) or (end) is executed.

;; Create a block of STATEMENTs for repeating.  The STATEMENTs
;; are executed sequentially until REPEAT or BREAK is executed.
;; If REPEAT statement is executed, STATEMENTs are executed from the
;; start again.  If BREAK statements is executed, the execution
;; exits from the block.  If neither REPEAT nor BREAK is
;; executed, the execution exits from the block after executing the
;; last STATEMENT.
LOOP := (loop STATEMENT [STATEMENT ...])

;; Terminate the most inner loop.
BREAK := (break)

REPEAT :=
	;; Jump to the head of the most inner loop.
	(repeat)
	;; Same as: ((write [REG | integer | string])
	;;	     (repeat))
	| (write-repeat [REG | integer | string])
	;; Same as: ((write REG [ARRAY])
	;;	     (read REG)
	;;	     (repeat))
	| (write-read-repeat REG [ARRAY])
	;; Same as: ((write integer)
	;;	     (read REG)
	;;	     (repeat))
	| (write-read-repeat REG integer)

READ := ;; Set REG_0 to a byte read from the input text, set REG_1
	;; to the next byte read, and so on.
	(read REG_0 [REG_1 ...])
	;; Same as: ((read REG)
	;;	     (if (REG OPERATOR ARG) CCL_BLOCK_0 CCL_BLOCK_1))
	| (read-if (REG OPERATOR ARG) CCL_BLOCK_0 CCL_BLOCK_1)
	;; Same as: ((read REG)
	;;	     (branch REG CCL_BLOCK_0 [CCL_BLOCK_1 ...]))
	| (read-branch REG CCL_BLOCK_0 [CCL_BLOCK_1 ...])
	;; Read a character from the input text while parsing
	;; multibyte representation, set REG_0 to the charset ID of
	;; the character, set REG_1 to the code point of the
	;; character.  If the dimension of charset is two, set REG_1
	;; to ((CODE0 << 7) | CODE1), where CODE0 is the first code
	;; point and CODE1 is the second code point.
	| (read-multibyte-character REG_0 REG_1)

WRITE :=
	;; Write REG_0, REG_1, ... to the output buffer.  If REG_N is
	;; a multibyte character, write the corresponding multibyte
	;; representation.
	(write REG_0 [REG_1 ...])
	;; Same as: ((r7 = EXPRESSION)
	;;	     (write r7))
	| (write EXPRESSION)
	;; Write the value of `integer' to the output buffer.  If it
	;; is a multibyte character, write the corresponding multibyte
	;; representation.
	| (write integer)
	;; Write the byte sequence of `string' as is to the output
	;; buffer.
	| (write string)
	;; Same as: (write string)
	| string
	;; Provided that the value of REG is N, write Nth element of
	;; ARRAY to the output buffer.  If it is a multibyte
	;; character, write the corresponding multibyte
	;; representation.
	| (write REG ARRAY)
	;; Write a multibyte representation of a character whose
	;; charset ID is REG_0 and code point is REG_1.  If the
	;; dimension of the charset is two, REG_1 should be ((CODE0 <<
	;; 7) | CODE1), where CODE0 is the first code point and CODE1
	;; is the second code point of the character.
	| (write-multibyte-character REG_0 REG_1)

;; Call CCL program whose name is ccl-program-name.
CALL := (call ccl-program-name)

;; Terminate the CCL program.
END := (end)

;; CCL registers that can contain any integer value.  As r7 is also
;; used by CCL interpreter, its value is changed unexpectedly.
REG := r0 | r1 | r2 | r3 | r4 | r5 | r6 | r7

ARG := REG | integer

OPERATOR :=
	;; Normal arithmetic operators (same meaning as C code).
	+ | - | * | / | %

	;; Bitwise operators (same meaning as C code)
	| & | `|' | ^

	;; Shifting operators (same meaning as C code)
	| << | >>

	;; (REG = ARG_0 <8 ARG_1) means:
	;;	(REG = ((ARG_0 << 8) | ARG_1))
	| <8

	;; (REG = ARG_0 >8 ARG_1) means:
	;;	((REG = (ARG_0 >> 8))
	;;	 (r7 = (ARG_0 & 255)))
	| >8

	;; (REG = ARG_0 // ARG_1) means:
	;;	((REG = (ARG_0 / ARG_1))
	;;	 (r7 = (ARG_0 % ARG_1)))
	| //

	;; Normal comparing operators (same meaning as C code)
	| < | > | == | <= | >= | !=

	;; If ARG_0 and ARG_1 are higher and lower byte of Shift-JIS
	;; code, and CHAR is the corresponding JISX0208 character,
	;; (REG = ARG_0 de-sjis ARG_1) means:
	;;	((REG = CODE0)
	;;	 (r7 = CODE1))
	;; where CODE0 is the first code point of CHAR, CODE1 is the
	;; second code point of CHAR.
	| de-sjis

	;; If ARG_0 and ARG_1 are the first and second code point of
	;; JISX0208 character CHAR, and SJIS is the corresponding
	;; Shift-JIS code,
	;; (REG = ARG_0 en-sjis ARG_1) means:
	;;	((REG = HIGH)
	;;	 (r7 = LOW))
	;; where HIGH is the higher byte of SJIS, LOW is the lower
	;; byte of SJIS.
	| en-sjis

ASSIGNMENT_OPERATOR :=
	;; Same meaning as C code
	+= | -= | *= | /= | %= | &= | `|=' | ^= | <<= | >>=

	;; (REG <8= ARG) is the same as:
	;;	((REG <<= 8)
	;;	 (REG |= ARG))
	| <8=

	;; (REG >8= ARG) is the same as:
	;;	((r7 = (REG & 255))
	;;	 (REG >>= 8))

	;; (REG //= ARG) is the same as:
	;;	((r7 = (REG % ARG))
	;;	 (REG /= ARG))
	| //=

ARRAY := `[' integer ... `]'


TRANSLATE :=
	;; Decode character SRC, translate it by translate table
	;; TABLE, and encode it back to DST.  TABLE is specified
	;; by its id number in REG_0, SRC is specified by its
	;; charset id number and codepoint in REG_1 and REG_2
	;; respectively.
	;; On encoding, the charset of highest priority is selected.
	;; After the execution, DST is specified by its charset
	;; id number and codepoint in REG_1 and REG_2 respectively.
	(translate-character REG_0 REG_1 REG_2)

	;; Same as above except for SYMBOL specifying the name of
	;; the translate table defined by `define-translation-table'.
	| (translate-character SYMBOL REG_1 REG_2)

LOOKUP :=
	;; Look up character SRC in hash table TABLE.  TABLE is
	;; specified by its name in SYMBOL, and SRC is specified by
	;; its charset id number and codepoint in REG_1 and REG_2
	;; respectively.
	;; If its associated value is an integer, set REG_1 to that
	;; value, and set r7 to 1.  Otherwise, set r7 to 0.
	(lookup-character SYMBOL REG_1 REG_2)

	;; Look up integer value N in hash table TABLE.  TABLE is
	;; specified by its name in SYMBOL and N is specified in
	;; REG.
	;; If its associated value is a character, set REG to that
	;; value, and set r7 to 1.  Otherwise, set r7 to 0.
	| (lookup-integer SYMBOL REG(integer))

MAP :=
	;; The following statements are for internal use only.
	(iterate-multiple-map REG REG MAP-IDs)
	| (map-multiple REG REG (MAP-SET))
	| (map-single REG REG MAP-ID)

MAP-IDs := MAP-ID ...
MAP-SET := MAP-IDs | (MAP-IDs) MAP-SET
MAP-ID := integer

(fn NAME CCL-PROGRAM &optional DOC)
(defalias 'define-ccl-program '(macro . #[770 "\300\301\302\216\303\304M\210\305\306!!)DC\307\301F\310\311D\312\313\311\nD\314BBF\315BBBB\207" [let prog #[0 "\300\301!\207" [fmakunbound charset-id] 2] charset-id charset-id-internal ccl-compile eval defconst put quote 'ccl-program-idx register-ccl-program (prog) (nil)] 12 (#$ . 31985)]))
(byte-code "\300\301\302\303#\300\207" [function-put define-ccl-program doc-string-elt 3] 4)
#@276 Check validity of CCL-PROGRAM.
If CCL-PROGRAM is a symbol denoting a CCL program, return
CCL-PROGRAM, else return nil.
If CCL-PROGRAM is a vector and optional arg NAME (symbol) is supplied,
register CCL-PROGRAM by name NAME, and return NAME.

(fn CCL-PROGRAM &optional NAME)
(defalias 'check-ccl-program '(macro . #[513 "\300\301D\300\302D\303\304EEFE\207" [if ccl-program-p vectorp progn register-ccl-program] 10 (#$ . 40270)]))
#@232 Execute CCL-PROGRAM with registers initialized by the remaining args.
The return value is a vector of resulting CCL registers.

See the documentation of `define-ccl-program' for the detail of CCL program.

(fn CCL-PROG &rest ARGS)
(defalias 'ccl-execute-with-args #[385 "\300\301\302\"\302\203*\211\301W\203*@\250\204\303\304!\210

@I\210A\262\211T\262
\202\305\"\210
\207" [make-vector 8 0 error "Arguments should be integer" ccl-execute] 7 (#$ . 40717)])
(provide 'ccl)