|
70
|
1 ;; Utility for HankakuKana (jisx0201)
|
|
|
2
|
|
|
3 ;; This file is part of Egg on Mule (Japanese Environment)
|
|
|
4
|
|
|
5 ;; Egg is distributed in the forms of patches to GNU
|
|
|
6 ;; Emacs under the terms of the GNU EMACS GENERAL PUBLIC
|
|
|
7 ;; LICENSE which is distributed along with GNU Emacs by the
|
|
|
8 ;; Free Software Foundation.
|
|
|
9
|
|
|
10 ;; Egg is distributed in the hope that it will be useful,
|
|
|
11 ;; but WITHOUT ANY WARRANTY; without even the implied
|
|
|
12 ;; warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
|
|
13 ;; PURPOSE. See the GNU EMACS GENERAL PUBLIC LICENSE for
|
|
|
14 ;; more details.
|
|
|
15
|
|
|
16 ;; You should have received a copy of the GNU EMACS GENERAL
|
|
|
17 ;; PUBLIC LICENSE along with Nemacs; see the file COPYING.
|
|
|
18 ;; If not, write to the Free Software Foundation, 675 Mass
|
|
|
19 ;; Ave, Cambridge, MA 02139, USA.
|
|
|
20
|
|
|
21 ;;; 92.9.24 created for Mule Ver.0.9.6 by K.Shibata <shibata@sgi.co.jp>
|
|
|
22 ;;; 93.8.3 modified for Mule Ver.1.1 by K.Handa <handa@etl.go.jp>
|
|
|
23 ;;; Not to define regexp of Japanese word in this file.
|
|
|
24
|
|
|
25 (provide 'jisx0201)
|
|
|
26
|
|
|
27 (defvar *katakana-alist*
|
|
|
28 '(( 161 . "(I'(B" )
|
|
|
29 ( 162 . "(I1(B" )
|
|
|
30 ( 163 . "(I((B" )
|
|
|
31 ( 164 . "(I2(B" )
|
|
|
32 ( 165 . "(I)(B" )
|
|
|
33 ( 166 . "(I3(B" )
|
|
|
34 ( 167 . "(I*(B" )
|
|
|
35 ( 168 . "(I4(B" )
|
|
|
36 ( 169 . "(I+(B" )
|
|
|
37 ( 170 . "(I5(B" )
|
|
|
38 ( 171 . "(I6(B" )
|
|
|
39 ( 172 . "(I6^(B" )
|
|
|
40 ( 173 . "(I7(B" )
|
|
|
41 ( 174 . "(I7^(B" )
|
|
|
42 ( 175 . "(I8(B" )
|
|
|
43 ( 176 . "(I8^(B" )
|
|
|
44 ( 177 . "(I9(B" )
|
|
|
45 ( 178 . "(I9^(B" )
|
|
|
46 ( 179 . "(I:(B" )
|
|
|
47 ( 180 . "(I:^(B" )
|
|
|
48 ( 181 . "(I;(B" )
|
|
|
49 ( 182 . "(I;^(B" )
|
|
|
50 ( 183 . "(I<(B" )
|
|
|
51 ( 184 . "(I<^(B" )
|
|
|
52 ( 185 . "(I=(B" )
|
|
|
53 ( 186 . "(I=^(B" )
|
|
|
54 ( 187 . "(I>(B" )
|
|
|
55 ( 188 . "(I>^(B" )
|
|
|
56 ( 189 . "(I?(B" )
|
|
|
57 ( 190 . "(I?^(B" )
|
|
|
58 ( 191 . "(I@(B" )
|
|
|
59 ( 192 . "(I@^(B" )
|
|
|
60 ( 193 . "(IA(B" )
|
|
|
61 ( 194 . "(IA^(B" )
|
|
|
62 ( 195 . "(I/(B" )
|
|
|
63 ( 196 . "(IB(B" )
|
|
|
64 ( 197 . "(IB^(B" )
|
|
|
65 ( 198 . "(IC(B" )
|
|
|
66 ( 199 . "(IC^(B" )
|
|
|
67 ( 200 . "(ID(B" )
|
|
|
68 ( 201 . "(ID^(B" )
|
|
|
69 ( 202 . "(IE(B" )
|
|
|
70 ( 203 . "(IF(B" )
|
|
|
71 ( 204 . "(IG(B" )
|
|
|
72 ( 205 . "(IH(B" )
|
|
|
73 ( 206 . "(II(B" )
|
|
|
74 ( 207 . "(IJ(B" )
|
|
|
75 ( 208 . "(IJ^(B" )
|
|
|
76 ( 209 . "(IJ_(B" )
|
|
|
77 ( 210 . "(IK(B" )
|
|
|
78 ( 211 . "(IK^(B" )
|
|
|
79 ( 212 . "(IK_(B" )
|
|
|
80 ( 213 . "(IL(B" )
|
|
|
81 ( 214 . "(IL^(B" )
|
|
|
82 ( 215 . "(IL_(B" )
|
|
|
83 ( 216 . "(IM(B" )
|
|
|
84 ( 217 . "(IM^(B" )
|
|
|
85 ( 218 . "(IM_(B" )
|
|
|
86 ( 219 . "(IN(B" )
|
|
|
87 ( 220 . "(IN^(B" )
|
|
|
88 ( 221 . "(IN_(B" )
|
|
|
89 ( 222 . "(IO(B" )
|
|
|
90 ( 223 . "(IP(B" )
|
|
|
91 ( 224 . "(IQ(B" )
|
|
|
92 ( 225 . "(IR(B" )
|
|
|
93 ( 226 . "(IS(B" )
|
|
|
94 ( 227 . "(I,(B" )
|
|
|
95 ( 228 . "(IT(B" )
|
|
|
96 ( 229 . "(I-(B" )
|
|
|
97 ( 230 . "(IU(B" )
|
|
|
98 ( 231 . "(I.(B" )
|
|
|
99 ( 232 . "(IV(B" )
|
|
|
100 ( 233 . "(IW(B" )
|
|
|
101 ( 234 . "(IX(B" )
|
|
|
102 ( 235 . "(IY(B" )
|
|
|
103 ( 236 . "(IZ(B" )
|
|
|
104 ( 237 . "(I[(B" )
|
|
|
105 ( 239 . "(I\(B" ) ; (I\(B -> $B%o(B $B$KJQ49$9$k$h$&$K(B
|
|
|
106 ( 238 . "(I\(B" ) ; $B%o$H%n$N=gHV$,8r49$7$F$"$k!#(B
|
|
|
107 ( 240 . "(I((B" )
|
|
|
108 ( 241 . "(I*(B" )
|
|
|
109 ( 242 . "(I&(B" )
|
|
|
110 ( 243 . "(I](B" )
|
|
|
111 ( 244 . "(I3^(B" )
|
|
|
112 ( 245 . "(I6(B" )
|
|
|
113 ( 246 . "(I9(B" )))
|
|
|
114
|
|
|
115 (defvar *katakana-kigou-alist*
|
|
|
116 '(( 162 . "(I$(B" )
|
|
|
117 ( 163 . "(I!(B" )
|
|
|
118 ( 166 . "(I%(B" )
|
|
|
119 ( 171 . "(I^(B" )
|
|
|
120 ( 172 . "(I_(B" )
|
|
|
121 ( 188 . "(I0(B" )
|
|
|
122 ( 214 . "(I"(B" )
|
|
|
123 ( 215 . "(I#(B" )))
|
|
|
124
|
|
|
125 (defvar *dakuon-list*
|
|
|
126 '( ?$B%+(B ?$B%-(B ?$B%/(B ?$B%1(B ?$B%3(B
|
|
|
127 ?$B%5(B ?$B%7(B ?$B%9(B ?$B%;(B ?$B%=(B
|
|
|
128 ?$B%?(B ?$B%A(B ?$B%D(B ?$B%F(B ?$B%H(B
|
|
|
129 ?$B%O(B ?$B%R(B ?$B%U(B ?$B%X(B ?$B%[(B))
|
|
|
130
|
|
|
131 (defvar *handakuon-list* (memq ?$B%O(B *dakuon-list*))
|
|
|
132
|
|
|
133 ;;;
|
|
|
134 ;;; $BH>3QJQ49(B
|
|
|
135 ;;;
|
|
|
136
|
|
|
137 (defun hankaku-katakana-region (start end &optional arg)
|
|
|
138 (interactive "r\nP")
|
|
|
139 (save-restriction
|
|
|
140 (narrow-to-region start end)
|
|
|
141 (goto-char (point-min))
|
|
|
142 (let ((regexp (if arg "\\cS\\|\\cK\\|\\cH" "\\cS\\|\\cK")))
|
|
|
143 (while (re-search-forward regexp (point-max) (point-max))
|
|
|
144 (let* ((ch (preceding-char))
|
|
|
145 (ch1 (char-component ch 1))
|
|
|
146 (ch2 (char-component ch 2)))
|
|
|
147 (cond ((= ?\241 ch1)
|
|
|
148 (let ((val (cdr (assq ch2 *katakana-kigou-alist*))))
|
|
|
149 (if val (progn
|
|
|
150 (delete-char -1)
|
|
|
151 (insert val)))))
|
|
|
152 ((or (= ?\242 ch1) (= ?\250 ch1))
|
|
|
153 nil)
|
|
|
154 (t
|
|
|
155 (let ((val (cdr (assq ch2 *katakana-alist*))))
|
|
|
156 (if val (progn
|
|
|
157 (delete-char -1)
|
|
|
158 (insert val)))))))))))
|
|
|
159
|
|
|
160 (defun hankaku-katakana-paragraph ()
|
|
|
161 "hankaku-katakana paragraph at or after point."
|
|
|
162 (interactive )
|
|
|
163 (save-excursion
|
|
|
164 (forward-paragraph)
|
|
|
165 (let ((end (point)))
|
|
|
166 (backward-paragraph)
|
|
|
167 (hankaku-katakana-region (point) end ))))
|
|
|
168
|
|
|
169 (defun hankaku-katakana-sentence ()
|
|
|
170 "hankaku-katanaka sentence at or after point."
|
|
|
171 (interactive )
|
|
|
172 (save-excursion
|
|
|
173 (forward-sentence)
|
|
|
174 (let ((end (point)))
|
|
|
175 (backward-sentence)
|
|
|
176 (hankaku-katakana-region (point) end ))))
|
|
|
177
|
|
|
178 (defun hankaku-katakana-word (arg)
|
|
|
179 (interactive "p")
|
|
|
180 (let ((start (point)))
|
|
|
181 (forward-word arg)
|
|
|
182 (hankaku-katakana-region start (point))))
|
|
|
183
|
|
|
184 ;;;
|
|
|
185 ;;; $BA43QJQ49(B
|
|
|
186 ;;;
|
|
|
187 (defun search-henkan-alist (ch list)
|
|
|
188 (let ((ptr list)
|
|
|
189 (result nil))
|
|
|
190 (while ptr
|
|
|
191 (if (string= ch (cdr (car ptr)))
|
|
|
192 (progn
|
|
|
193 (setq result (car (car ptr)))
|
|
|
194 (setq ptr nil))
|
|
|
195 (setq ptr (cdr ptr))))
|
|
|
196 result))
|
|
|
197
|
|
|
198 (defun zenkaku-katakana-region (start end)
|
|
|
199 (interactive "r")
|
|
|
200 (save-restriction
|
|
|
201 (narrow-to-region start end)
|
|
|
202 (goto-char (point-min))
|
|
|
203 (while (re-search-forward "\\ck" (point-max) (point-max))
|
|
|
204 (let ((ch (preceding-char))
|
|
|
205 (wk nil))
|
|
|
206 (cond
|
|
|
207 ((= ch ?(I^(B)
|
|
|
208 (save-excursion
|
|
|
209 (backward-char 1)
|
|
|
210 (setq wk (preceding-char)))
|
|
|
211 (cond ((= wk ?$B%&(B)
|
|
|
212 (delete-char -2)
|
|
|
213 (insert "$B%t(B"))
|
|
|
214 ((setq wk (memq wk *dakuon-list*))
|
|
|
215 (delete-char -2)
|
|
|
216 (insert (1+ (car wk))))
|
|
|
217 (t
|
|
|
218 (delete-char -1)
|
|
|
219 (insert "$B!+(B"))))
|
|
|
220 ((= ch ?(I_(B)
|
|
|
221 (save-excursion
|
|
|
222 (backward-char 1)
|
|
|
223 (setq wk (preceding-char)))
|
|
|
224 (if (setq wk (memq wk *handakuon-list*))
|
|
|
225 (progn
|
|
|
226 (delete-char -2)
|
|
|
227 (insert (+ 2 (car wk))))
|
|
|
228 (progn
|
|
|
229 (delete-char -1)
|
|
|
230 (insert "$B!,(B"))))
|
|
|
231 ((setq wk (search-henkan-alist
|
|
|
232 (char-to-string ch) *katakana-alist*))
|
|
|
233 (progn
|
|
|
234 (delete-char -1)
|
|
|
235 (insert (make-char 'japanese-jisx0208 ?\045 wk))))
|
|
|
236 ((setq wk (search-henkan-alist
|
|
|
237 (char-to-string ch) *katakana-kigou-alist*))
|
|
|
238 (progn
|
|
|
239 (delete-char -1)
|
|
|
240 (insert (make-char 'japanese-jisx0208 ?\041 wk)))))))))
|
|
|
241
|
|
|
242 (defun zenkaku-katakana-paragraph ()
|
|
|
243 "zenkaku-katakana paragraph at or after point."
|
|
|
244 (interactive )
|
|
|
245 (save-excursion
|
|
|
246 (forward-paragraph)
|
|
|
247 (let ((end (point)))
|
|
|
248 (backward-paragraph)
|
|
|
249 (zenkaku-katakana-region (point) end ))))
|
|
|
250
|
|
|
251 (defun zenkaku-katakana-sentence ()
|
|
|
252 "zenkaku-katakana sentence at or after point."
|
|
|
253 (interactive )
|
|
|
254 (save-excursion
|
|
|
255 (forward-sentence)
|
|
|
256 (let ((end (point)))
|
|
|
257 (backward-sentence)
|
|
|
258 (zenkaku-katakana-region (point) end ))))
|
|
|
259
|
|
|
260 (defun zenkaku-katakana-word (arg)
|
|
|
261 (interactive "p")
|
|
|
262 (let ((start (point)))
|
|
|
263 (forward-word arg)
|
|
|
264 (zenkaku-katakana-region start (point))))
|
|
|
265
|
|
|
266 ;;;
|
|
|
267 ;;; JISX 0201 fence mode
|
|
|
268 ;;;
|
|
|
269
|
|
|
270 (defun fence-hankaku-katakana ()
|
|
|
271 (interactive)
|
|
|
272 (hankaku-katakana-region egg:*region-start* egg:*region-end* t))
|
|
|
273
|
|
|
274 (defun fence-katakana ()
|
|
|
275 (interactive)
|
|
|
276 (zenkaku-katakana-region egg:*region-start* egg:*region-end* )
|
|
|
277 (katakana-region egg:*region-start* egg:*region-end*))
|
|
|
278
|
|
|
279 (defun fence-hiragana ()
|
|
|
280 (interactive)
|
|
|
281 (zenkaku-katakana-region egg:*region-start* egg:*region-end*)
|
|
|
282 (hiragana-region egg:*region-start* egg:*region-end*))
|
|
|
283
|
|
|
284 (define-key fence-mode-map "\ex" 'fence-hankaku-katakana)
|
