Mercurial > kinput2.yaz
comparison lib/cconv.c @ 0:92745d501b9a
initial import from kinput2-v3.1
author | Yoshiki Yazawa <yaz@honeyplanet.jp> |
---|---|
date | Mon, 08 Mar 2010 04:44:30 +0900 |
parents | |
children | 983aff0dcf18 |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:92745d501b9a |
---|---|
1 /* | |
2 * cconv.c -- $BF~NOJ8;zJQ49%i%$%V%i%j(B (for X11) | |
3 * ver 10.8 | |
4 */ | |
5 | |
6 /* | |
7 * Copyright (C) 1988 Software Research Associates, Inc. | |
8 * | |
9 * Permission to use, copy, modify, and distribute this software and its | |
10 * documentation for any purpose and without fee is hereby granted, provided | |
11 * that the above copyright notice appear in all copies and that both that | |
12 * copyright notice and this permission notice appear in supporting | |
13 * documentation, and that the name of Software Research Associates not be | |
14 * used in advertising or publicity pertaining to distribution of the | |
15 * software without specific, written prior permission. Software Research | |
16 * Associates makes no representations about the suitability of this software | |
17 * for any purpose. It is provided "as is" without express or implied | |
18 * warranty. | |
19 * | |
20 * Author: Makoto Ishisone, Software Research Associates, Inc., Japan | |
21 * ishisone@sra.co.jp | |
22 */ | |
23 | |
24 /* | |
25 * $B35MW(B | |
26 * | |
27 * $BF~NOJ8;zJQ49$O!"$+$J4A;zJQ49$NA0CJ3,$G$"$j!"$=$NL\E*$O%-!<%\!<%I$+$i(B | |
28 * $BF~NO$5$l$?%-!<%3!<%I$r2r<a$9$k$3$H$G$"$k!#(B | |
29 * $B=>$C$F!"Bg$-$/J,$1$k$H<!$N(B2$B$D$N5!G=$r;}$D$3$H$K$J$k!#(B | |
30 * | |
31 * 1. $B%m!<%^;z$+$JJQ49$J$IF~NO$5$l$?J8;z$rJL$NJ8;z$KJQ$($k5!G=(B | |
32 * 2. $B%-!<$NF~NO$K$h$j!"$+$J4A;zJQ49$G;H$o$l$k!VJQ49!W!"!V3NDj!W$J$I$N(B | |
33 * $B3F<o5!G=$r8F$S=P$95!G=(B | |
34 * | |
35 * $B$3$N(B cconv $B%i%$%V%i%j$O(B X Window version 11 $B$N$b$H$G;H$o$l$k$3$H$r(B | |
36 * $BA[Dj$7$F$$$k!#(B | |
37 */ | |
38 | |
39 /* | |
40 * $B%a%b(B | |
41 * | |
42 * version 6.0 88/06/05 | |
43 * $B$@$$$?$$$G$-$?(B | |
44 * version 6.1 88/06/06 | |
45 * $B%3%a%s%HF~$l(B | |
46 * version 6.2 88/06/07 | |
47 * $B$3$l$@$1F~$l$l$P%^%K%e%"%k=q$+$J$/$F$bBg>fIW$@$m$&(B | |
48 * version 6.4 88/09/05 | |
49 * $B2CF#;a(B@$BEl9)Bg$N0U8+$K$h$j(B redo $B5!G=$rF~$l$k(B | |
50 * $B$D$$$G$K(B static function $B$N@k8@$r$D$1$k(B | |
51 * $B$$$/$D$+$N4X?t$r(B external $B$+$i(B static $B$KJQ$($k(B | |
52 * version 6.5 88/09/07 | |
53 * function $B$,J#?t=q$1$k$h$&$K$7$?(B | |
54 * $B$=$N$?$a%G!<%?9=B$$rJQ99$9$k(B | |
55 * version 6.6 88/10/07 | |
56 * $B$J$s$H(B readRuleFile() $B$G%*!<%W%s$7$?%U%!%$%k$r(B | |
57 * $BJD$8$k$N$rK:$l$F$$$?(B -- $B$"!<$O$:$+$7$$(B | |
58 * $B=>$C$F(B wterm $B$G2?2s$b(B KanjiConvert $B$N(B on/off $B$r7+$jJV$9$H(B | |
59 * $B=i4|2=$K<:GT$9$k(B | |
60 * version 6.7 88/12/19 | |
61 * wstrlen() $B$O$3$N%i%$%V%i%j$GDj5A$9$k$Y$-$b$N$G$O$J$$$N$G30$9(B | |
62 * version 6.8 89/07/21 | |
63 * $B1F;3;a(B@$B>>2<EE4o$+$i%-!<%3!<%II=5-$,$&$^$/F0$+$J$$$H$NO"Mm$r<u$1$k(B | |
64 * getKey() $B$G(B XKEY $BI=5-$N>l9g!"(B#0x$B#1#6?J?t(B $B$NFI$_$H$j$K%P%0$,(B | |
65 * $B$"$k$3$H$,H=L@(B | |
66 * version 7.0 89/08/16 | |
67 * jclib $B$N(B Wnn version4 $BBP1~$K$h$j!"JQ49%P%C%U%!$,J#?t;}$F$k$h$&$K(B | |
68 * $B$J$C$?(B | |
69 * $B$=$l$K9g$o$;$F!"(Bcconv $B$b%P%C%U%!$,J#?t;}$F$k$h$&$K$7$J$1$l$P(B | |
70 * $B$J$i$J$$(B | |
71 * $B7k6IH>J,0J>e=q$-49$($F$7$^$C$?$h$&$@(B | |
72 * version 7.1 89/08/17 | |
73 * $B%P%0%U%#%C%/%9(B | |
74 * $B%b!<%IJQ99DLCNMQ$N%3!<%k%P%C%/$rDI2C$9$k(B | |
75 * version 7.2 89/08/23 | |
76 * $B%U%!%s%/%7%g%s%F!<%V%k$O!"$d$O$j(B ccParseRule() $B$G$O$J$/!"(B | |
77 * ccCreateBuf() $B$G;XDj$9$k$Y$-$b$N$J$N$G!"$=$N$h$&$KJQ99$9$k(B | |
78 * version 7.3 89/08/25 | |
79 * lint $B$G7Y9p$,=P$J$$$h$&$K=$@5(B | |
80 * dumpAllRules() $B$G$A$c$s$HJQ49%k!<%k$,%@%s%W$5$l$k$h$&$K=$@5(B | |
81 * version 7.4 89/08/26 | |
82 * ccParseRule() $B$G!"JQ49Dj5A%U%!%$%k$,A0$HF1$8$G$"$l$P(B | |
83 * $B%k!<%k$r6&MQ$9$k$h$&$KJQ99(B | |
84 * ccParseRule/ccFreeRule $B$G$N(B memory leak $B$N=$@5(B | |
85 * version 7.5 89/09/26 | |
86 * $BJQ49Dj5A%U%!%$%k$G(B include $B$,;H$($k$h$&$K=$@5(B | |
87 * version 7.6 89/09/27 | |
88 * include $B$N@bL@$r=q$/$N$rK:$l$F$$$?$N$G$=$l$rDI2C(B | |
89 * version 7.7 89/10/26 | |
90 * getKey() $B$G(B #$B?t;z(B $B7?$NI=5-$r$7$?;~$K$^$@%P%0$,$"$C$?$N$G=$@5(B | |
91 * $B$=$b$=$b$3$NJ}<0$NI=5-$G$O%^%9%/$,;XDj$G$-$J$$$H$$$&:,K\E*$J(B | |
92 * $BLdBj$,$"$k$,!"$^$"$3$l$O$$$$$3$H$K$7$F!#(B | |
93 * version 8.0 89/10/27 | |
94 * R4 contrib $B8~$1$N(B Release $B$K$"$?$C$F%P!<%8%g%sHV9f$r=$@5(B | |
95 * version 8.1 89/12/25 | |
96 * include $B%U%!%$%k$,$J$+$C$?;~$K%3%"%@%s%W$9$k%P%0$r=$@5(B | |
97 * version 8.2 90/02/15 | |
98 * X11R4 keyboard group support $BDI2C(B | |
99 * version 8.3 90/02/16 | |
100 * keyboard group support $B$N7k2L!"Nc$($P(B | |
101 * "" shift-Right "" foo | |
102 * "" Right "" bar | |
103 * $B$H$$$&%k!<%k$,$"$C$?;~!"(Bshift-Right $B$r2!$7$?$K$b$+$+$o$i$:(B | |
104 * $B$7$?$N%k!<%k$K%^%C%A$7$F$7$^$&$H$$$&%P%0$r=$@5(B | |
105 * $BDj5A%U%!%$%k(B (include $B%U%!%$%k$b4^$`(B) $B$N%5!<%A%Q%9$H$7$F(B | |
106 * $B4D6-JQ?t(B CC_DEF_PATH $B$r;H$&$h$&$K=$@5(B | |
107 * version 8.4 90/04/17 | |
108 * keyboard group support $B$N%3!<%I$N%1%"%l%9%_%9$r=$@5(B | |
109 * $BJQ?tL>(B ks1 $B$H(B ks2 $B$r4V0c$($?(B | |
110 * version 8.5 90/05/31 | |
111 * keyboard group support $B$NIT6q9g$r=$@5(B | |
112 * $BL1ED;a(B@$B%"%9%F%C%/$+$i$N%l%]!<%H(B | |
113 * version 8.6 91/03/20 | |
114 * $B$I$N%k!<%k$K$b%^%C%A$7$J$+$C$?;~$K$O%G%U%)%k%H%"%/%7%g%s$,8F$P$l$k$,!"(B | |
115 * $B$3$N=hM}$G(B | |
116 * + $B0z?t$,4V0c$C$F$$$?(B | |
117 * + XLookupString() $B$N%j%?!<%s%P%j%e!<$,(B 0 $B$N$H$-(B ($B$D$^$j(B | |
118 * $B%-!<%$%Y%s%H$KBP1~$9$kJ8;zNs$,$J$+$C$?;~(B) $B$K%G%U%)%k%H(B | |
119 * $B%"%/%7%g%s$,8F$P$l$J$+$C$?(B | |
120 * $B$H$$$&LdBj$r=$@5(B | |
121 * $B%G%U%)%k%H%"%/%7%g%s$,(B NULL $B$N;~!"$I$N%k!<%k$K$b%^%C%A$7$J$1$l$P(B | |
122 * ccConvchar() $B$,(B -1 $B$rJV$9$h$&$K=$@5(B | |
123 * version 8.7 91/03/25 | |
124 * $BA0$N%P!<%8%g%s$N=$@5$K$h$j!"C1$K%7%U%H%-!<$d%3%s%H%m!<%k%-!<$r(B | |
125 * $B2!$7$?$@$1$G%G%U%)%k%H%"%/%7%g%s$,8F$P$l$k$h$&$K$J$C$?$,!"$3$l$O(B | |
126 * $B%f!<%6$N4|BT$9$kF0:n$G$O$J$$$h$&$J5$$,$9$k$N$G!"(BXLookupString() $B$N(B | |
127 * $B%j%?!<%s%P%j%e!<$,(B 0 $B$N;~$K$O%G%U%)%k%H%"%/%7%g%s$r8F$P$J$$$h$&$K(B | |
128 * $B:F=$@5(B | |
129 * $B$^$?!"%G%U%)%k%H%"%/%7%g%s$,(B NULL $B$G$+$D%k!<%k$K%^%C%A$7$J$$;~$K(B | |
130 * ccConvchar() $B$,(B -1 $B$rJV$9$h$&$K$7$?$,!"%G%U%)%k%H%"%/%7%g%s$NCM$K(B | |
131 * $B$h$C$F%j%?!<%s%P%j%e!<$,JQ$o$k$N$OJQ$@$7!"(B-1 $B$rJV$9$N$O%(%i!<$,(B | |
132 * $B5/$3$C$?$_$?$$$J$N$G!"7k6I%G%U%)%k%H%"%/%7%g%s$,(B NULL $B$G$"$k$+(B | |
133 * $B$I$&$+$K4X$o$i$:%^%C%A$7$?;~$O(B 1$B!"%^%C%A$7$J$$;~$O(B 0 $B$rJV$9(B | |
134 * $B$h$&$K=$@5(B | |
135 * $B$3$NJQ99$K$h$j(B ccConvchar() $B$N%j%?!<%s%P%j%e!<$,(B 0 $B$+$I$&$+%A%'%C%/(B | |
136 * $B$7$F$$$?%"%W%j%1!<%7%g%s$OF0$+$J$/$J$k$,!":#$^$G(B ccConvchar() $B$N(B | |
137 * $B%j%?!<%s%P%j%e!<$ODj5A$7$F$$$J$+$C$?$N$G$3$l$O$=$N%"%W%j%1!<%7%g%s$N(B | |
138 * $B@UG$(B | |
139 * version 9.0 91/08/15 | |
140 * $BJ8;z$N%G!<%?7?$H$7$F:#$^$G$:$C$H(B wchar_t $B$r;H$C$F$$$?$,!"(Bwchar_t $B$N(B | |
141 * $BDj5A$,5!<o$K$h$C$F0[$J$k$?$a!"(Bwchar $B$H$$$&7?$KJQ99$9$k!#K\Ev$O(B | |
142 * Wnn $B$N<!4|%P!<%8%g%s$K9g$o$;$?$$$N$G8e$G:F$SJQ99$9$k2DG=@-$,$"$k(B | |
143 * version 9.1 91/09/18 | |
144 * Files $B9=B$BN$N(B index $B$H$$$&L>A0$N%U%#!<%k%I$,!"(BSystemV $B7O$N%^%7%s(B | |
145 * $B$@$H(B strchr $B$KJQ$o$C$F$7$^$&$N$G(B findex $B$H$$$&L>A0$KJQ99(B | |
146 * version 9.2 91/09/23 | |
147 * DEBUG $B$,Dj5A$5$l$F$$$k$HJQ49%k!<%k$,%@%s%W$5$l$F$7$^$&$N$O(B kinput2 | |
148 * $B$G;HMQ$9$k>l9g:$$k$N$G!"(BDEBUG $B$r(B DEBUG_CCONV $B$KJQ99(B | |
149 * version 10.0 91/10/01 | |
150 * R5 contrib $B8~$1$N%j%j!<%9$K$"$?$C$F%P!<%8%g%sHV9f$r=$@5(B | |
151 * version 10.1 92/06/05 | |
152 * Display $B9=B$BN$N(B mode_switch $B$r;2>H$7$F$$$?$,!"(BDisplay $B9=B$BN$O(B | |
153 * $BK\Mh(B opaque $B$G$"$j!"Cf$N%a%s%P!<$rD>@\%"%/%;%9$9$k$N$O$^$:$$$N$G(B | |
154 * mode_switch $B$NCM$r<+J,$G7W;;$9$k$h$&$KJQ99(B | |
155 * version 10.2 94/04/21 | |
156 * $B4X?t(B eproc $B$O(B varargs.h/stdarg.h $B$r;H$o$:$K=q$+$l$F$$$?$,!"(B | |
157 * $B0\?"@-$KLdBj$,$"$k(B (int $B$H(B long $B$N%5%$%:$,0[$J$k%^%7%s$J$I(B) | |
158 * $B$N$G=$@5(B | |
159 * version 10.3 97/09/17 | |
160 * $B$J$f$?$5$s(B@$BElBg$K$h$k5!G=3HD%%Q%C%A(B ($B%U%!%s%/%7%g%s%G%#%9%Q%C%A%c$N(B | |
161 * $BJV$jCM$G;D$j$N4X?t$N<B9T$r%9%-%C%W$G$-$k(B) $B$N<h$j9~$_(B | |
162 * version 10.4 97/11/20 | |
163 * $BF1$8%U%!%$%k$KBP$7$F(B fclose $B$rJ#?t2s8F$s$G$$$F!"(Blibc $B$N<BAu$K(B | |
164 * $B$h$C$F$O%3%"%@%s%W$9$k$H$$$&%P%0$r=$@5!#$D$$$G$KDj5A%U%!%$%k$N(B | |
165 * $BFI$_9~$_ESCf$G%(%i!<$K$J$C$?;~$K%/%m!<%:$7K:$l$F$$$?$N$G9g$o$;$F(B | |
166 * $B=$@5!#(B | |
167 * version 10.5 98/12/28 | |
168 * $B$J$f$?$5$s(B@$BElBg$K$h$k$5$i$J$k5!G=3HD%%Q%C%A(B ($B<+F03NDj5!G=(B) $B$N<h$j9~$_(B | |
169 * version 10.6 99/01/07 | |
170 * $B%=!<%9$N4A;z%3!<%I$r(B SJIS $B$+$i(B EUC $B$KJQ49!#$?$@$7$3$l$OFbIt$N(B | |
171 * $B4IM}>e$NOC$G!"G[I[MQ%=!<%9$O85!9(B JIS $B%3!<%I$K$J$C$F$$$k!#(B | |
172 * version 10.7 99/04/02 | |
173 * $B=i4|2=;~$N%(%i!<%A%'%C%/$N6/2=!"$H$$$&$+%P%0=$@5!#JQ49%k!<%kDj5A(B | |
174 * $B%U%!%$%k$K%k!<%k$,Dj5A$5$l$F$$$J$+$C$?>l9g(B ($B$D$^$j4V0c$C$FA4A3(B | |
175 * $BJL$N%U%!%$%k$rFI$_9~$s$G$7$^$C$?>l9g(B) $B$K%(%i!<$K$9$k!#(B | |
176 * version 10.8 99/05/07 | |
177 * $B<+F03NDj5!G=$,!"JQ49%k!<%kDj5A%U%!%$%k$G$N;XDj$K4X$o$i$:(B | |
178 * $B>o$K%*%s$K$J$C$F$7$^$&$H$$$&%P%0$r=$@5!#(B | |
179 */ | |
180 | |
181 /* | |
182 * $B;HMQK!(B | |
183 * | |
184 * $B;HMQK!$O3d9g4JC1$G$"$k!#:G=i$KJQ49%k!<%kDj5A%U%!%$%k$rFI$_9~$`$?$a$K(B | |
185 * ccParseRule() $B$r%3!<%k$9$k!#(B | |
186 * $B<!$KJQ49%P%C%U%!$r:n$k$?$a$K(B ccCreateBuf() $B$r8F$S!"%P%C%U%!$r:n$k!#(B | |
187 * $B$3$N;~$K!";HMQ$9$k%k!<%k$d<o!9$N%3!<%k%P%C%/4X?t$r;XDj$9$k!#(B | |
188 * $BJQ49%k!<%k$HJQ49%P%C%U%!$OJ#?t;}$D$3$H$,$G$-$k!#(B | |
189 * $B$^$?!"A0$N%P!<%8%g%s$H$N8_49@-$N$?$a$K!"JQ49%k!<%k$NFI$_9~$_$H(B | |
190 * $BJQ49%P%C%U%!$N:n@.$rF1;~$K9T$J$&!"(BccInit() $B$H$$$&4X?t$bMQ0U$5$l$F$$$k!#(B | |
191 * | |
192 * $B$"$H$O%-!<%W%l%9$N%$%Y%s%H$,Mh$?$i(B ccConvchar() $B$r8F$V$@$1$G$"$k!#(B | |
193 * $B$3$N%U%!%s%/%7%g%s$,JQ49$r9T$J$$!"E,Ev$J%3!<%k%P%C%/%k!<%A%s$r8F$V!#(B | |
194 * | |
195 * $B8e$OI,MW$K1~$8$FMQ0U$5$l$F$$$k$=$NB>$N%U%!%s%/%7%g%s$r8F$Y$P$h$$!#(B | |
196 */ | |
197 | |
198 /* | |
199 * $BJQ49$N;EAH$_(B | |
200 * | |
201 * $B$3$NF~NOJ8;zJQ49$N;EAH$_$rM}2r$9$k$?$a$N%-!<%o!<%I$O<!$N(B3$B$D$G$"$k!#(B | |
202 * $B!&%b!<%I(B | |
203 * $B!&JQ49%k!<%k(B | |
204 * $B!&%3%s%F%-%9%H(B | |
205 * | |
206 * $B!&%b!<%I(B | |
207 * $BF~NOJ8;zJQ49$K$O!V%b!<%I!W$,$"$k!#$3$l$ONc$($P!"(B | |
208 * $B!V%m!<%^;z2>L>JQ49$r$7$F$+$J$rF~NO$9$k%b!<%I!W$H$+(B | |
209 * $B!V%"%k%U%!%Y%C%H$rF~NO$9$k%b!<%I!W$H$$$C$?$b$N$G$"$k!#(B | |
210 * $B%b!<%I$4$H$K0[$J$kJQ49%k!<%k$,@_Dj$G$-$k!#EvA3%b!<%I$N@ZBX$($b(B | |
211 * $BJQ49%k!<%k$H$7$F5-=R$G$-$k!#(B | |
212 * | |
213 * $B!&JQ49%k!<%k(B | |
214 * $BJQ49%k!<%k$O(B4$B$D$N9`L\$+$i9=@.$5$l$k!#(B | |
215 * $BF~NO%-!<(B | |
216 * $B%3%s%F%-%9%HJ8;zNs(B | |
217 * $BJQ497k2LJ8;zNs(B | |
218 * $B%U%!%s%/%7%g%s(B | |
219 * $B$3$N$&$A!"F~NO%-!<$H%3%s%F%-%9%HJ8;zNs$,%k!<%k$N%^%C%A%s%0$K;H$o$l$k!#(B | |
220 * | |
221 * $BF~NO%-!<$O%-!<%3!<%I$r;XDj$9$k$b$N$G!"(BX $B$N%-!<%$%Y%s%H%3!<%I$G(B | |
222 * $B;XDj$9$kJ}K!$H!"$=$l$r(B XLookupString $B$7$?7k2L$N%-%c%i%/%?%3!<%I$G(B | |
223 * $B;XDj$9$kJ}K!$H$N(B2$BDL$j$,$"$k!#(B | |
224 * | |
225 * $B%3%s%F%-%9%HJ8;zNs$O!"$=$l$^$G$K$I$N$h$&$JJ8;z$,F~NO$5$l$?$+$r(B | |
226 * $B;XDj$9$k$b$N$G$"$k!#(B | |
227 * | |
228 * $BJQ497k2LJ8;zNs$O$=$NL>$NDL$j!"JQ497k2L$N;XDj$G!"%^%C%A$7$?(B | |
229 * $B%3%s%F%-%9%H$,$3$NJQ497k2L$KCV$-$+$o$k!#(B | |
230 * | |
231 * $B%U%!%s%/%7%g%s$O%k!<%k$,%^%C%A$7$?$H$-$K<B9T$5$l$k%U%!%s%/%7%g%s(B | |
232 * ("$BJQ49(B" $B$H$+(B "$B3NDj(B" $B$H$+(B) $B$N;XDj$G$"$k!#%U%!%s%/%7%g%s$OJ#?t(B | |
233 * $B;XDj$9$k$3$H$b$G$-$k!#(B | |
234 * | |
235 * $BNc$r$"$2$k$H!"(B | |
236 * $B!V(B"ky" $B$HF~$C$F$$$k$H$3$m$G(B 'a' $B$H$$$&%-!<$,2!$5$l$?$i(B | |
237 * "$B$-$c$C(B!" $B$HJQ49$7!"%Y%k$rLD$i$9!W(B | |
238 * $B$H$$$&%k!<%k(B ($B$"$s$^$j0UL#$J$$$1$I(B) $B$G!"(B | |
239 * 'a' $B$,F~NO%-!<!"(B | |
240 * "ky" $B$,%3%s%F%-%9%H!"(B | |
241 * "$B$-$c$C(B!" $B$,JQ497k2L!"(B | |
242 * <$B%Y%k$rLD$i$9(B> $B$,%U%!%s%/%7%g%s(B | |
243 * $B$H$$$&$3$H$K$J$k!#(B | |
244 * | |
245 * $B!&%3%s%F%-%9%H(B | |
246 * $B0J>e$N$h$&$K!"%3%s%F%-%9%H$H$$$&$N$O$=$l$^$G$K$I$N$h$&$JJ8;z$,(B | |
247 * $BF~NO$5$l$F$$$J$1$l$P$J$i$J$$$+$r;XDj$9$k$b$N$G$"$k!#(B | |
248 * $B$=$l$HF1;~$K$=$NJ8;z$rJQ497k2L$HCV$-JQ$($k$3$H$r;XDj$9$k$b$N(B | |
249 * $B$G$b$"$k!#(B | |
250 * | |
251 * $B%3%s%F%-%9%H$O6uJ8;zNs$G$b$h$$!#$=$N$H$-$K$O$=$l$^$G$K$I$N$h$&$J(B | |
252 * $BJ8;z$,F~NO$5$l$?$+$K$+$+$o$i$:!"%^%C%A%s%0$,5/$3$k!#(B | |
253 * | |
254 * $B%3%s%F%-%9%H$OH>3Q$N>l9gBgJ8;z>.J8;z$r6hJL$7$J$$!#(B | |
255 * $B$I$A$i$K$b%^%C%A$9$k!#$?$@$7!"(Bcasesensitive $B$r;XDj$9$k$3$H$G(B | |
256 * $BBgJ8;z>.J8;z$r6hJL$9$k$h$&$K$9$k$3$H$b$G$-$k!#(B | |
257 * | |
258 * autofix $B$r;XDj$9$k$H!"%3%s%F%-%9%H$,$J$$>uBV$G%3%s%F%-%9%H$KJ8(B | |
259 * $B;z$,DI2C$5$l$kD>A0$K<+F03NDj%U%!%s%/%7%g%s$,8F$P$l$k!#(B | |
260 * | |
261 * $B!&JQ49$N<B:](B | |
262 * $B$5$F!"$I$N$h$&$K$7$FJQ49$,9T$J$o$l$k$N$+$r4JC1$K=q$$$F$_$k!#(B | |
263 * | |
264 * $B%-!<%W%l%9%$%Y%s%H$r0z?t$K$7$F(B ccConvchar() $B$,8F$P$l$k!#(B | |
265 * $B$9$k$H!"$^$:$O%$%Y%s%H%3!<%I$G%+%l%s%H%b!<%I$GDj5A$5$l$F$$$k(B | |
266 * $BJQ49%k!<%k$NCf$+$i%^%C%A$9$k$b$N$rC5$9!#C5:w$O%k!<%k$N5-=R=g$K(B | |
267 * $B9T$J$o$l!":G=i$K%^%C%A$7$?$b$N$,A*$P$l$k!#(B | |
268 * $B$b$7%^%C%A$9$k%k!<%k$,$J$1$l$P!":#EY$O%$%Y%s%H%3!<%I$r(B | |
269 * XLookupString() $B$GJQ49$7$?%-%c%i%/%?%3!<%I$G!"%^%C%A$9$k$b$N$rC5$9!#(B | |
270 * | |
271 * $B$=$l$G$b%^%C%A$9$k%k!<%k$,8+$D$+$i$J$+$C$?$H$-$K$O!"%G%U%)%k%H(B | |
272 * $B%"%/%7%g%s$N%3!<%k%P%C%/%k!<%A%s$,8F$P$l$k!#(B | |
273 * | |
274 * $B%^%C%A$9$k%k!<%k$,8+$D$+$l$P!"JQ497k2LJ8;zNs$X$NCV$-49$($r9T$J$&!#(B | |
275 * $B$D$^$j!"$^$:%k!<%k$K5-=R$5$l$F$$$k%3%s%F%-%9%HJ8;zNs$NJ8;z?tJ,$@$1(B | |
276 * 1$BJ8;z:o=|MQ$N%3!<%k%P%C%/%k!<%A%s$,8F$P$l!"$=$N8eJQ497k2LJ8;zNs$,(B | |
277 * 1$BJ8;zF~NOMQ$N%3!<%k%P%C%/%k!<%A%s$r8F$s$GF~NO$5$l$k!#$=$N:]$K(B | |
278 * $B%3%s%F%-%9%H$,6u$G$"$C$?>l9g$O!"<+F03NDjMQ$N%3!<%k%P%C%/%k!<%A%s$,(B | |
279 * $B8F$P$l$k!#(B | |
280 * $B$=$N%k!<%k$K%U%!%s%/%7%g%s$,;XDj$5$l$F$$$l$P%G%#%9%Q%C%AMQ$N(B | |
281 * $B%3!<%k%P%C%/%k!<%A%s$,8F$S=P$5$l$k!#(B | |
282 * | |
283 * $B%U%!%s%/%7%g%s$,B>$N%b!<%I$X$N@ZBX$($@$C$?>l9g$K$O>/$7J#;($G$"$k!#(B | |
284 * $B$=$N$H$-$K$O!"$^$:(B EXITMODE $B$H$$$&5?;w%-!<$r0z?t$K$7$F(B ccConvchar() | |
285 * $B$,8F$P$l$k!#$3$l$O$"$k%b!<%I$+$iH4$1$k:]$K2?$+=hM}$r$7$?$$!"(B | |
286 * $B$H$$$&$H$-$N$?$a$K$"$k!#$=$N8e%+%l%s%H%b!<%I$r?7$7$$%b!<%I$K$7$F!"(B | |
287 * $B:#EY$O(B ENTERMODE $B$H$$$&5?;w%-!<$r0z?t$K$7$F(B ccConvchar $B$,8F$P$l$k!#(B | |
288 * $B$3$l$K$h$C$F$"$k%b!<%I$KF~$C$?$H$-$N=hM}$r$9$k$3$H$,$G$-$k!#(B | |
289 * $B$=$N8e!"%3%s%F%-%9%H$,%/%j%"$5$l!":G8e$K!"%b!<%IJQ99DLCNMQ$N(B | |
290 * $B%3!<%k%P%C%/4X?t$,;XDj$5$l$F$$$l$P$=$l$,8F$P$l$k!#(B | |
291 */ | |
292 | |
293 /* | |
294 * ccdef $B%U%!%$%k$N=q$-J}(B | |
295 * | |
296 * $BF~NOJ8;zJQ49Dj5A%U%!%$%k(B (ccdef $B%U%!%$%k$H>JN,$9$k(B) $B$N=q$-J}$r4JC1$K5-$9!#(B | |
297 * | |
298 * ccdef $B%U%!%$%k$O<!$N(B3$B$D$N%Q!<%H$+$i9=@.$5$l$k!#(B | |
299 * $B$3$l$i$O$3$N=g$KJB$s$G$$$J$1$l$P$J$i$J$$!#(B | |
300 * | |
301 * <$B%b!<%I@k8@(B> | |
302 * <$B=i4|%b!<%I@k8@(B> | |
303 * <$B3F%b!<%I$NJQ49%k!<%k5-=R(B> | |
304 * | |
305 * <$B%b!<%I@k8@(B> $B$O;HMQ$9$k%b!<%IL>$r@k8@$9$k$b$N$G!"%U%)!<%^%C%H$O<!$NDL$j!#(B | |
306 * defmode Mode1 Mode2 Mode3... | |
307 * $B;HMQ$9$k%b!<%I$O$9$Y$F$3$3$G@k8@$7$F$*$+$J$/$F$O$J$i$J$$!#(B | |
308 * | |
309 * <$B=i4|%b!<%I@k8@(B> $B$O(B cconv $B$,=i4|2=$5$l$?$H$-$N%b!<%I$r;XDj$9$k$b$N$G$"$k!#(B | |
310 * $B%U%)!<%^%C%H$O<!$NDL$j!#(B | |
311 * initialmode Mode3 | |
312 * | |
313 * | |
314 * <$B3F%b!<%I$NJQ49%k!<%k5-=R(B> $B$,<B:]$NJQ49%k!<%k$r5-=R$9$kItJ,$G$"$k!#(B | |
315 * 1$B$D$N%b!<%I$KBP$9$k5-=R7A<0$O<!$NDL$j!#(B | |
316 * | |
317 * mode <$B%b!<%IL>(B> "<$B%W%m%s%W%H(B>" [fallthrough <$B%b!<%IL>(B>] | |
318 * "<$B%3%s%F%-%9%H(B>" <$B%-!<(B> "<$BJQ497k2L(B>" [<$B%U%!%s%/%7%g%s(B>...] | |
319 * : | |
320 * : | |
321 * endmode | |
322 * | |
323 * <$B%b!<%IL>(B> $B$O(B <$B%b!<%I@k8@(B> $B$G@k8@$7$?%b!<%IL>$G$"$k!#(B | |
324 * | |
325 * <$B%W%m%s%W%H(B> $B$O%b!<%I$rI=$9J8;zNs$G$"$k!#$3$l$O%+%l%s%H%b!<%I$rI=<($9$k(B | |
326 * $B:]$K;HMQ$5$l$k$b$N$G!"4A;z$G$b$h$$!#D9$5$O<+M3$G$"$k$,!"M>$jD9$$$H(B | |
327 * $B$9$Y$FI=<($5$l$k$+$I$&$+5?Ld$G$"$k!#(B | |
328 * $B$=$N8e$N!"(B[ ] $B$K$/$k$^$l$?ItJ,$O>JN,2DG=$J$3$H$r<($9!#(B | |
329 * $B$b$7$"$l$P!"$3$N%b!<%I$G%^%C%A$9$k%k!<%k$,$J$+$C$?$H$-$K$O(B fallthrough $B$G(B | |
330 * $B;XDj$5$l$k%b!<%I$N%k!<%k$,0z$-B3$$$FC5$5$l$k!#(B | |
331 * | |
332 * mode $B$H(B endmode $B$K$O$5$^$l$?ItJ,$,8D!9$NJQ49%k!<%k$G$"$k!#(B | |
333 * <$B%3%s%F%-%9%H(B> $B$,%3%s%F%-%9%HJ8;zNs$G$"$k!#$3$3$G$O(B '^' $B$H(B '\' $B$,FC<l(B | |
334 * $B%-%c%i%/%?$H$7$F;HMQ$G$-$k!#(B"^C" $B$H=q$1$P$=$l$O(B $B%3%s%H%m!<%k(B-C $B$rI=$9!#(B | |
335 * $B%P%C%/%9%i%C%7%e(B '\' $B$O<!$NJ8;z$NFC<lJ8;z$H$7$F$N0UL#$r$J$/$9!#(B | |
336 * '^' $B<+?H$r;H$$$?$1$l$P(B "\^" $B$H%(%9%1!<%W$9$k!#F1MM$K(B '\' $B<+?H$r;H$$$?$1$l$P(B | |
337 * "\\" $B$H=E$M$l$P$h$$!#(B | |
338 * | |
339 * <$B%-!<(B> $B$OF~NO$5$l$?%-!<$G!"(BX $B$N%-!<%$%Y%s%H!"%-%c%i%/%?%3!<%I!"(B | |
340 * $B%a%?%-%c%i%/%?!"5?;w%-!<$N$$$:$l$+$G;XDj$9$k!#(B | |
341 * | |
342 * X $B$N%-!<%$%Y%s%H$O!"4pK\E*$K!"(B | |
343 * $B%b%G%#%U%!%$%"(B-Keysym$BL>(B | |
344 * $B$GI=$9!#Nc$($P!"(B | |
345 * Tab | |
346 * control-a | |
347 * shift-control-space | |
348 * $B$J$I$G$"$k!#(B | |
349 * | |
350 * $B%-%c%i%/%?%3!<%I$r=q$/$K$O!"%7%s%0%k%/%)!<%H$r;HMQ$9$k!#Nc$($P(B | |
351 * 'a' | |
352 * '^[' | |
353 * '\'' | |
354 * $B$J$I$G$"$k!#$o$+$k$H;W$&$,!"(B2$BHVL\$O(B ESCAPE$B!"(B3$BHVL\$O%7%s%0%k%/%)!<%H(B | |
355 * $B$=$N$b$N$r<($9!#(B | |
356 * | |
357 * $B%a%?%-%c%i%/%?$O<!$N(B10$B<oN`$,;HMQ$G$-$k!#(B | |
358 * $B%-!<%$%Y%s%H$G$b%-%c%i%/%?%3!<%I$G$b%^%C%A$9$k$b$N(B | |
359 * @any - $B2?$K$G$b%^%C%A$9$k(B | |
360 * $B%-!<%$%Y%s%H$K%^%C%A$9$k$b$N(B | |
361 * @raw - $B%-!<%$%Y%s%H$J$i2?$K$G$b%^%C%A(B | |
362 * @func - $B%U%!%s%/%7%g%s%-!<$K%^%C%A(B | |
363 * @cursor - $B%+!<%=%k%-!<$K%^%C%A(B | |
364 * @keypad - $B%F%s%-!<%Q%C%I$N%-!<$K%^%C%A(B | |
365 * @modifier - $B%b%G%#%U%!%$%"(B (shift, control $B$J$I(B) $B$K%^%C%A(B | |
366 * @non-ascii - $B%-!<%$%Y%s%H$N$&$A!"(BXLookupString() $B$N7k2L$,(B | |
367 * $BD9$5(B0$B!"$D$^$jBP1~$9$k%"%9%-!<J8;z$,$J$$$b$N$K%^%C%A(B | |
368 * $B%-%c%i%/%?%3!<%I$K%^%C%A$9$k$b$N(B | |
369 * @ascii - $B%-%c%i%/%?%3!<%I$J$i2?$K$G$b%^%C%A(B | |
370 * @printable - $B0u;z2DG=J8;z(B (0x20 $B!e(B c $B!e(B 0x7e) $B$K%^%C%A(B | |
371 * @control - $B%3%s%H%m!<%kJ8;z(B (0x00 $B!e(B c $B!e(B 0x1f) $B$K%^%C%A(B | |
372 * | |
373 * $B5?;w%-!<$OK\Ev$N%-!<F~NO$G$O$J$$!#$3$l$K$O(B2$B<oN`$"$k!#(B | |
374 * ENTERMODE - $B$"$k%b!<%I$KF~$C$?$H$-$K2>A[E*$KF~NO$5$l$k%-!<(B | |
375 * EXITMODE - $B$"$k%b!<%I$+$iH4$1$k$H$-$K2>A[E*$KF~NO$5$l$k%-!<(B | |
376 * | |
377 * <$BJQ497k2L(B> $B$OJQ497k2L$r;XDj$9$k!#$3$3$G$O(B '&'$B!"(B'/'$B!"(B'^'$B!"(B'\' $B$N(B4$B<oN`$N(B | |
378 * $BFC<lJ8;z$,;HMQ$G$-$k!#(B'^' $B$H(B '\' $B$K$D$$$F$O(B <$B%3%s%F%-%9%H(B> $B$HF1$8$G$"$k!#(B | |
379 * '&' $B$O(B $B%^%C%A$7$?(B <$B%-!<(B> $B$HCV$-49$($i$l$k!#(B<$B%-!<(B> $B$,%$%Y%s%H$N>l9g$K$O(B | |
380 * $B$=$N%$%Y%s%H$r(B XLookupString() $B$7$?7k2L$NJ8;zNs$GCV$-49$o$k!#(B | |
381 * '/' $B$,=P$F$/$k$H!"$=$3$G%3%s%F%-%9%H$O%/%j%"$5$l$k!#(B | |
382 * | |
383 * <$B%U%!%s%/%7%g%s(B> $B$O$J$/$F$b$h$$!#$"$l$PJQ49$N8e!"%U%!%s%/%7%g%s$,(B | |
384 * $B<B9T$5$l$k!#%U%!%s%/%7%g%s$rJ#?t;XDj$9$k$3$H$b$G$-!"$=$N>l9g$K$O(B | |
385 * $B;XDj$5$l$?=g=x$G<B9T$5$l$k!#%U%!%s%/%7%g%s$N6h@Z$j$O6uGrJ8;z$G$"$k!#(B | |
386 * func1 func2 func3 | |
387 * $B$N$h$&$K;XDj$9$k!#(B | |
388 * $B%U%!%s%/%7%g%s$H$7$F%+%l%s%H%b!<%I$NJQ99$r;XDj$9$k$3$H$b$G$-$k!#(B | |
389 * goto <$B%b!<%IL>(B> | |
390 * $B$G%+%l%s%H%b!<%I$,JQ$o$k!#$3$N%b!<%IL>$H$7$F(B "PREV" $B$,;HMQ$G$-$k!#(B | |
391 * $B$3$l$O0l$DA0$N%b!<%I$rI=$9!#(B | |
392 * $B$^$?!":FJQ49$r;XDj$9$k$3$H$b$G$-$k!#(B<$B%U%!%s%/%7%g%s(B>$B$H$7$F(B | |
393 * redo | |
394 * $B$H=q$/$H!"$b$&0lEY%^%C%A$9$k%k!<%k$r:G=i$+$iC5$7$K$$$/!#$?$@$7$=$NA0$K(B | |
395 * <$B%3%s%F%-%9%H(B> $B$,(B <$BJQ497k2L(B> $B$KCV$-49$($i$l$F$$$k$3$H$KCm0U!#$3$N5!G=$r(B | |
396 * $B;H$&;~$K$OL58B%k!<%W$K4Y$i$J$$$h$&$KCm0U$7$F%k!<%k$r=q$+$J$1$l$P$J$i$J$$!#(B | |
397 * $B0l1~0BA4:v$H$7$F(B redo $B$,(B MAXREDO (=20) $B2s8F$P$l$k$H<:GT$9$k$h$&$K(B | |
398 * $B$J$C$F$$$k!#(B | |
399 * $BCm0U(B: goto $B$H(B redo $B$N$"$H$K;XDj$5$l$?%U%!%s%/%7%g%s$O<B9T$5$l$J$$!#(B | |
400 * $B$D$^$j!"(B | |
401 * func1 goto XX func2 | |
402 * $B$@$H!":G=i$K(B func1 $B$,<B9T$5$l!"<!$K%+%l%s%H%b!<%I$,(B XX $B$KJQ99$5$l$k$,(B | |
403 * func2 $B$O<B9T$5$l$J$$!#(B | |
404 * $B$^$?!"<!$KF~NO$7$?%-!<$K%b%G%#%U%!%$%d$rDI2C$9$k$3$H$b$G$-$k!#(B<$B%U%!(B | |
405 * $B%s%/%7%g%s(B>$B$H$7$F!"(B | |
406 * add-modifier-shift | |
407 * add-modifier-control | |
408 * add-modifier-lock | |
409 * add-modifier-mod1 | |
410 * add-modifier-mod2 | |
411 * add-modifier-mod3 | |
412 * add-modifier-mod4 | |
413 * add-modifier-mod5 | |
414 * $B$r=q$/$H<!$KF~NO$7$?%-!<$K%b%G%#%U%!%$%d$rDI2C$9$k!#Nc$($P!"(B | |
415 * "" '^[' "" add-modifier-mod1 | |
416 * "" mod1-i "" shrink-s | |
417 * $B$H=q$$$F$*$/$H!"(Bmod1-i $B$HF~NO$7$F$b!"(B^[ i $B$HF~NO$7$F$b(B shrink-s $B$,(B | |
418 * $B<B9T$5$l$k!#(B | |
419 * | |
420 * $B:G8e$K=EMW$JCm0U$r0l$D!#(Bccdef $B%U%!%$%k$O(B EUC $B%3!<%I$G=q$+$l$F$$$J$1$l$P(B | |
421 * $B$J$i$J$$!#(B | |
422 * | |
423 * $B$J$*!"=q$-K:$l$?$,(B '#' $B$G;O$^$k9T$O%3%a%s%H9T$G$"$k!#(B | |
424 * | |
425 * $B$^$?!"B>$N%U%!%$%k$r(B include $BJ8$r;H$C$F%$%s%/%k!<%I$9$k$3$H$,$G$-$k!#(B | |
426 * $B=q<0$O(B | |
427 * include $B%U%!%$%kL>(B | |
428 * $B$G$"$k!#%U%!%$%kL>Cf$K6uGrJ8;z$,4^$^$l$k;~$K$O(B ' $B$+(B " $B$G0O$a$P$h$$!#(B | |
429 * $B%U%!%$%kL>$,AjBP%Q%9L>$N;~$K$O$^$:%+%l%s%H%G%#%l%/%H%j$,C5$5$l!"$J$1$l$P(B | |
430 * $B4D6-JQ?t(B CC_DEF_PATH $B$,Dj5A$5$l$F$$$l$P$=$l$K;XDj$5$l$?%G%#%l%/%H%j(B | |
431 * (':' $B$G6h@Z$C$FJ#?t;XDj$9$k$3$H$,$G$-$k(B) $B$N2<$,C5$5$l!"$=$l$G$b$J$1$l$P(B | |
432 * CCDEFPATH (/usr/lib/X11/ccdef/) $B$N2<$,C5$5$l$k!#(B | |
433 */ | |
434 | |
435 /* | |
436 * $B%$%s%?!<%U%'%$%9!&%U%!%s%/%7%g%s(B | |
437 * | |
438 * - $BJQ49%k!<%kFI$_9~$_(B - | |
439 * | |
440 * ccRule ccParseRule(char *deffile, void (*errprint)()) | |
441 * $BF~NOJ8;zJQ49%U%!%$%k$rFI$_9~$`!#(B | |
442 * deffile $B$G;XDj$5$l$k%U%!%$%k$+$iJQ49%k!<%k$rFI$_9~$`!#$b$7$b(B | |
443 * deffile $B$,(B NULL $B$N;~$O!"4D6-JQ?t(B CC_DEF $B$NCM$,;HMQ$5$l$k!#(B | |
444 * deffile $B$,AjBP%Q%9L>$N;~$K$O$^$:%+%l%s%H%G%#%l%/%H%j$N2<$,C5$5$l!"(B | |
445 * $B$J$1$l$P!"4D6-JQ?t(B CC_DEF_PATH $B$G;XDj$5$l$?%G%#%l%/%H%j$N2<$,(B | |
446 * $BC5$5$l$k!#(BCC_DEF_PATH $B$K$O4D6-JQ?t(B PATH $B$J$I$HF1$8$/J#?t$N(B | |
447 * $B%G%#%l%/%H%j$r(B ':' $B$G6h@Z$C$F;XDj$9$k$3$H$,$G$-$k!#(B | |
448 * $B$J$1$l$P(B CCDEFPATH (/usr/lib/X11/ccdef) $B$N2<$,C5$5$l$k!#(B | |
449 * $BF1$8JQ49%U%!%$%k$KBP$7$FJ#?t2s(B ccParseRule() $B$r9T$J$C$F$b!"(B | |
450 * $B<B:]$KFI$_9~$^$l$k$N$O:G=i$N0l2s$@$1$G$"$k!#(B | |
451 * errprint $B$O%(%i!<I=<(MQ$N%U%!%s%/%7%g%s$G$"$k$,!"(B NULL $B$N>l9g$K$O(B | |
452 * stderr $B$X(B fprintf() $B$r;HMQ$7$F=PNO$5$l$k!#(B | |
453 * $B@.8y;~$K$OJQ49%k!<%k$r!"<:GT;~$K$O(B NULL $B$rJV$9!#(B | |
454 * | |
455 * void ccFreeRule(ccRule rule) | |
456 * $B;HMQ$7$J$/$J$C$?JQ49%k!<%k$G;H$o$l$F$$$?NN0h$r2rJ|$9$k!#(B | |
457 * | |
458 * | |
459 * - $BJQ49%P%C%U%!:n@.(B - | |
460 * | |
461 * ccBuf ccCreateBuf(ccRule rule, int contextsize, | |
462 * char *functable[], int functablesize, | |
463 * void (*default_action)(), void (*insert_char)(), | |
464 * void (*delete_char)(), int (*function_dispatch)(), | |
465 * void (*mode_notify)(), void (*auto_fix)(), | |
466 * caddr_t client_data); | |
467 * $BJQ49%P%C%U%!$r:n$j!"$=$l$rJV$9!#(B | |
468 * rule $B$G!"$I$NJQ49%k!<%k$r;HMQ$9$k$+;XDj$9$k!#(B | |
469 * contextsize $B$K$O%3%s%F%-%9%H$r2?J8;zJ];}$9$k$+$r;XDj$9$k!#(B | |
470 * $B$h$[$IFC<l$J%k!<%k$,$J$$8B$j!"IaDL$O?tJ8;z$GB-$j$k$O$:$G$"$k!#(B | |
471 * functable $B$O%U%!%s%/%7%g%sL>$N0lMwI=!"(Bfunctablesize $B$O$=$N%5%$%:(B | |
472 * $B$G$"$k!#(B | |
473 * default_action $B$O!"F~NO$5$l$?%-!<$,$I$N%k!<%k$K$b%^%C%A$7$J$+$C$?(B | |
474 * $B$H$-$K8F$P$l$k%U%!%s%/%7%g%s$G$"$k!#(BNULL $B$r;XDj$9$k$H!"%^%C%A(B | |
475 * $B$7$J$+$C$?$H$-$K$O2?$b5/$3$i$J$$!#(B | |
476 * insert_char, delete_char $B$O$=$l$>$l(B 1$BJ8;zA^F~(B / 1$BJ8;z:o=|MQ$N(B | |
477 * $B%U%!%s%/%7%g%s$G$"$k!#(B | |
478 * function_dispatch $B$K$O%U%!%s%/%7%g%s%3!<%k$N$?$a$N%G%#%9%Q%C%A(B | |
479 * $B%k!<%A%s$r;XDj$9$k!#%G%#%9%Q%C%A4X?t$,(B True $B$rJV$;$P<!$N%U%!%s%/%7%g(B | |
480 * $B%s$r8F$V$,!"(BFalse $B$rJV$;$P(B goto $B$N$h$&$KB3$/4X?t$OL5;k$9$k!#(B | |
481 * auto_fix $B$O!"<+F03NDj$N$?$a$N%k!<%A%s$r;XDj$9$k!#(BNULL $B$r;XDj$9$k$H(B | |
482 * $B<+F03NDj$O$5$l$J$$!#(B | |
483 * mode_notify $B$O!"%b!<%I$,JQ$o$C$?;~$K8F$S=P$5$l$k%U%!%s%/%7%g%s$G$"$k!#(B | |
484 * $B%3!<%k%P%C%/$NI,MW$,$J$$$H$-$O(B NULL $B$r;XDj$7$F$*$1$P$h$$!#(B | |
485 * client_data $B$O!"%3!<%k%P%C%/;~$K0z?t$H$7$FEO$5$l$k%G!<%?$G$"$k!#(B | |
486 * $B@.8y;~$K$O%P%C%U%!$r!"%(%i!<$N;~$K$O(B NULL $B$,JV$5$l$k!#(B | |
487 * | |
488 * | |
489 * void ccDestroyBuf(ccBuf buf) | |
490 * $B;HMQ$7$J$/$J$C$?JQ49%P%C%U%!$G;H$o$l$F$$$?NN0h$r2rJ|$9$k!#(B | |
491 * | |
492 * | |
493 * - $BJQ49(B - | |
494 * | |
495 * int ccConvchar(ccBuf buf, XKeyPressedEvent *event) | |
496 * X11 $B$N%-!<%\!<%I$N%W%l%9%$%Y%s%H$r<u$1<h$j!"JQ49$r9T$J$&!#(B | |
497 * $B9T$J$C$?7k2L!"J8;z$NA^F~!&:o=|$O(B ccCreateBuf() $B$G;XDj$5$l$?(B | |
498 * insert_char, delete_char $B$,8F$S=P$5$l!"%U%!%s%/%7%g%s$K$D$$$F$O(B | |
499 * $BF1$8$/(B ccCreateBuf() $B$G;XDj$5$l$k(B function_dispatch $B$,%G%#%9%Q%C%A$N(B | |
500 * $B$?$a$K8F$P$l$k!#(B | |
501 * $B$I$N%k!<%k$K$b%^%C%A$7$J$1$l$P!"(Bdefault_action $B$,8F$P$l$k!#(B | |
502 * $B$I$N%k!<%k$K$b%^%C%A$7$J$+$C$?;~$K$O(B 0$B!"%^%C%A$7$?;~$K$O(B 1 $B$,(B | |
503 * $BJV$5$l$k!#(B | |
504 * | |
505 * | |
506 * - $B%+%l%s%H%b!<%I(B - | |
507 * | |
508 * int ccGetMode(ccBuf buf) | |
509 * $B%+%l%s%H%b!<%IHV9f$,JV$5$l$k!#(B | |
510 * | |
511 * wchar *ccGetModePrompt(ccBuf buf) | |
512 * $B%+%l%s%H%b!<%IL>$,(B EUC$B%W%m%;%9%3!<%I$GJV$5$l$k!#(B | |
513 * | |
514 * | |
515 * - $B%P%C%U%!$N;HMQ$7$F$$$k%k!<%k(B - | |
516 * | |
517 * ccRule ccGetRule(ccBuf buf) | |
518 * $B;XDj$5$l$?JQ49%P%C%U%!$,;HMQ$7$F$$$kJQ49%k!<%k$rJV$9!#(B | |
519 * | |
520 * | |
521 * - $B%3%s%F%-%9%H(B - | |
522 * | |
523 * $B%3%s%F%-%9%H$X$NJ8;z$NDI2C$d:o=|$O!"%k!<%k$K%^%C%A$7$?$H$-$K$O(B | |
524 * $B<+F0E*$K9T$J$o$l$k!#$^$?!"%+%l%s%H%b!<%I$NJQ99$K$H$b$J$C$F(B | |
525 * $B%3%s%F%-%9%H$O<+F0E*$K%/%j%"$5$l$k!#(B | |
526 * $B=>$C$FIaDL$O%f!<%6$,$3$l$i$N%U%!%s%/%7%g%s$r8F$VI,MW$O$J$$!#(B | |
527 * $B$?$@$7!"%^%C%A$7$J$+$C$?J8;z$r(B default_action $B$,A^F~$9$k$H$+!"(B | |
528 * $B%P%C%/%9%Z!<%9$N=hM}$r9T$J$&!"$J$I$N>l9g$K$O%f!<%6$,(B explicit $B$K(B | |
529 * $B8F$VI,MW$,$"$k!#(B | |
530 * | |
531 * void ccContextAppend(ccBuf buf, int c) | |
532 * $B%3%s%F%-%9%H$N:G8e$KJ8;z(B c (EUC $B%W%m%;%9%3!<%I(B)$B$rIU$12C$($k!#(B | |
533 * | |
534 * void ccContextDelete(ccBuf buf) | |
535 * $B%3%s%F%-%9%H$N:G8e$N(B1$BJ8;z$r:o=|$9$k!#(B | |
536 * | |
537 * void ccContextClear(ccBuf buf) | |
538 * $B%3%s%F%-%9%H$r%/%j%"$9$k!#(B | |
539 * | |
540 * void ccContextSet(ccBuf buf, wchar *cstr) | |
541 * $B%3%s%F%-%9%HJ8;zNs$r%;%C%H$9$k!#J8;zNs$O(B null $B%?!<%_%M!<%H$5$l$?(B | |
542 * EUC $B%W%m%;%9%3!<%I$G$J$1$l$P$J$i$J$$!#(B | |
543 * $BJ8;zNs$ND9$5$,(B ccCreateBuf() $B$G;XDj$5$l$?(B contextsize $B$h$j(B | |
544 * $BD9$$$H$-$K$O!":G8e$N(B contextsize $BJ8;z$,%;%C%H$5$l$k!#(B | |
545 * | |
546 * void ccContextGet(ccBuf buf, wchar *cstr) | |
547 * $B8=:_$N%3%s%F%-%9%HJ8;zNs$rJV$9!#J8;zNs$O(B null $B%?!<%_%M!<%H$5$l$?(B | |
548 * EUC $B%W%m%;%9%3!<%I$G$"$k!#(B | |
549 */ | |
550 | |
551 /* | |
552 * $B%3!<%k%P%C%/%U%!%s%/%7%g%s$H$=$N0z?t(B | |
553 * | |
554 * $B%G%#%9%Q%C%A%U%!%s%/%7%g%s(B: | |
555 * function_dispatch(int func, unsigned char *str, int nbytes, | |
556 * caddr_t client_data) | |
557 * $B%^%C%A$7$?%k!<%k$K%U%!%s%/%7%g%s$,=q$+$l$F$$$?$H$-$K(B | |
558 * $B8F$S=P$5$l$k!#(B | |
559 * $B0z?t(B func $B$O!"%U%!%s%/%7%g%sHV9f$G$"$k!#$3$l$O(B | |
560 * ccParseRule() $B$N0z?t$H$7$FEO$5$l$?!"(Bfunctable[] $B$N(B | |
561 * $B%$%s%G%C%/%9$G$"$k!#(Bstr, nbytes $B$O$3$N(B | |
562 * $B%U%!%s%/%7%g%s$r0z$-5/$3$7$?%-!<$NI=$9J8;zNs!#(B | |
563 * client_data $B$O(B ccCreateBuf() $B$N;~$K;XDj$5$l$?%G!<%?$G$"$k!#(B | |
564 * | |
565 * $B%G%U%)%k%H%"%/%7%g%sMQ%U%!%s%/%7%g%s(B: | |
566 * default_action(unsigned char *str, int nbytes, caddr_t client_data) | |
567 * $B2!$5$l$?%-!<$KBP$7$F%^%C%A$9$k%k!<%k$,$J$+$C$?$H$-$K(B | |
568 * $B8F$S=P$5$l$k!#(B | |
569 * str, nbytes $B$O%-!<$NI=$9J8;zNs!#(B | |
570 * client_data $B$O(B ccCreateBuf() $B$N;~$K;XDj$5$l$?%G!<%?!#(B | |
571 * | |
572 * $BJ8;zA^F~%U%!%s%/%7%g%s(B: | |
573 * insert_char(wchar c, caddr_t client_data) | |
574 * $BJQ497k2L$NJ8;z$r%"%W%j%1!<%7%g%s$KEO$9$N$K;HMQ$5$l$k!#(B | |
575 * c $B$O(B EUC $B%W%m%;%9%3!<%I$G$"$k!#$3$N%U%!%s%/%7%g%s$O(B | |
576 * 1$BJ8;z$4$H$K8F$P$l$k!#(B | |
577 * client_data $B$O(B ccCreateBuf() $B$N;~$K;XDj$5$l$?%G!<%?!#(B | |
578 * | |
579 * $BJ8;z:o=|%U%!%s%/%7%g%s(B: | |
580 * delete_char(caddr_t client_data) | |
581 * $BJQ497k2L$K$7$?$,$C$F:o=|$9$kJ8;z$,$"$l$P$=$NJ8;z?tJ,(B | |
582 * $B$3$N%U%!%s%/%7%g%s$,8F$P$l$k!#(B | |
583 * client_data $B$O(B ccCreateBuf() $B$N;~$K;XDj$5$l$?%G!<%?!#(B | |
584 * | |
585 * $B<+F03NDj%U%!%s%/%7%g%s(B: | |
586 * auto_fix(caddr_t client_data) | |
587 * $B%3%s%F%-%9%H$,$J$$>uBV$G%3%s%F%-%9%H$KJ8;z$,DI2C$5$l$k(B | |
588 * $BD>A0$K8F$P$l$k!#(B | |
589 * client_data $B$O(B ccCreateBuf() $B$N;~$K;XDj$5$l$?%G!<%?!#(B | |
590 * | |
591 * $B%b!<%IJQ99%U%!%s%/%7%g%s(B: | |
592 * mode_notify(int newmode, int oldmode, caddr_t client_data) | |
593 * $B%+%l%s%H%b!<%I$,JQ99$5$l$?;~$K$3$N%U%!%s%/%7%g%s$,(B | |
594 * $B8F$P$l$k!#(Bnewmode $B$,?7$7$$%+%l%s%H%b!<%I!"(Boldmode $B$,(B | |
595 * $BA0$N%+%l%s%H%b!<%IHV9f$G$"$k!#(B | |
596 * | |
597 * $B%(%i!<I=<(%U%!%s%/%7%g%s(B: | |
598 * error_handler(char *errstr) | |
599 * ccParseRule() $BCf$G!"%(%i!<$,H/@8$7$?;~$K8F$S=P$5$l$k!#(B | |
600 */ | |
601 | |
602 #ifndef lint | |
603 static char *rcsid = "$Id: cconv.c,v 10.10 1999/08/09 03:17:57 ishisone Exp $"; | |
604 #endif | |
605 | |
606 #include <stdio.h> | |
607 #include <X11/Xlib.h> | |
608 #include <X11/keysym.h> | |
609 #include <X11/Xutil.h> | |
610 #include <X11/Xos.h> | |
611 #include "cconv.h" | |
612 | |
613 #define uchar unsigned char | |
614 #define ushort unsigned short | |
615 #define ulong unsigned long | |
616 | |
617 #define Malloc(size) malloc((unsigned int)(size)) | |
618 #define Realloc(p, size) realloc((char *)(p), (unsigned int)(size)) | |
619 #define Free(p) { if (p) (void)free((char *)(p)); } | |
620 | |
621 #define Strcmp(s1, s2) strcmp((char *)(s1), (char *)(s2)) | |
622 #define Strncmp(s1, s2, n) strncmp((char *)(s1), (char *)(s2), n) | |
623 #define Strcpy(s1, s2) strcpy((char *)(s1), (char *)(s2)) | |
624 #define Strcat(s1, s2) strcat((char *)(s1), (char *)(s2)) | |
625 #define Strlen(s) strlen((char *)(s)) | |
626 | |
627 #define EPROC2(efunc, format, a) { \ | |
628 char tmp[1024]; \ | |
629 (void)sprintf(tmp, format, a); \ | |
630 eproc(efunc, tmp); } | |
631 | |
632 /* $B%-!<%3!<%I$N%(%s%3!<%IJ}K!(B */ | |
633 #define RAWKEY (1L<<31) | |
634 #define PSEUDO (1L<<30) | |
635 #define METAC (1L<<29) | |
636 #define META_ASCII 1 /* any ascii character (not useful) */ | |
637 #define META_CONTROL 2 /* any control character */ | |
638 #define META_RAW 3 /* any key event (not useful) */ | |
639 #define META_ANY 4 /* anything (character or event) */ | |
640 #define META_FUNC 5 /* any function key event */ | |
641 #define META_CURSOR 6 /* any cursor key event */ | |
642 #define META_KEYPAD 7 /* any keypad key event */ | |
643 #define META_MODIFIER 8 /* any modifier key event */ | |
644 #define META_PRINTABLE 9 /* any printable character */ | |
645 #define META_NONASCII 10 /* key event that has no ascii interpretation */ | |
646 | |
647 /* pseudo key code */ | |
648 #define ENTERMODE (ulong)(PSEUDO|1) | |
649 #define EXITMODE (ulong)(PSEUDO|2) | |
650 | |
651 /* function code */ | |
652 #define ENDFUNC 0xffff | |
653 #define MODECHANGE 0x8000 | |
654 #define REDO 0x7fff | |
655 #define PREVMODE (MODECHANGE|0x1000) | |
656 #define FUNC_MODIFIER_SHIFT 0x7ff0 | |
657 #define FUNC_MODIFIER_CONTROL 0x7ff1 | |
658 #define FUNC_MODIFIER_LOCK 0x7ff2 | |
659 #define FUNC_MODIFIER_MOD1 0x7ff3 | |
660 #define FUNC_MODIFIER_MOD2 0x7ff4 | |
661 #define FUNC_MODIFIER_MOD3 0x7ff5 | |
662 #define FUNC_MODIFIER_MOD4 0x7ff6 | |
663 #define FUNC_MODIFIER_MOD5 0x7ff7 | |
664 #define FUNC_MODIFIER_start FUNC_MODIFIER_SHIFT | |
665 #define FUNC_MODIFIER_end FUNC_MODIFIER_MOD5 | |
666 | |
667 #define MAXREDO 20 | |
668 | |
669 /* key encoding */ | |
670 #define ccEncodeKey(ev) ((ulong)XLookupKeysym(ev, 0) | (ulong)RAWKEY) | |
671 #define ccEncodeMask(ev) ((int)((ev)->state & 0xff)) | |
672 | |
673 #define ccEncodeChar(c) ((ulong)(c)) | |
674 | |
675 #define NOMODE 0xffff | |
676 | |
677 #define MATCHED_CHAR 0x8080 /* $B$3$l$O(B EUC $B$H$7$F$O(B illegal $B$J%3!<%I$J$N$G(B | |
678 * $BFCJL$JL\E*$KMQ$$$k(B */ | |
679 #define CCLEAR_CHAR 0x8081 /* $B>e$KF1$8(B */ | |
680 | |
681 #define CANONIC(c) (((c) >= 'A' && (c) <= 'Z') ? c += ('a' - 'A') : c) | |
682 | |
683 /* $B%G!<%?9=B$(B */ | |
684 /* $BJQ49%k!<%k(B */ | |
685 typedef struct convdesc { | |
686 ulong key; /* $BF~NO%-!<(B */ | |
687 ushort mask; /* modifier mask (of X KeyEvent) */ | |
688 ushort context; /* context$BJ8;zNs(B ($B5U=g$K3JG<$5$l$k(B) */ | |
689 ushort result; /* $BJQ497k2LJ8;zNs(B */ | |
690 ushort function; /* function $B%Y%/%?$N%$%s%G%C%/%9(B */ | |
691 } ConvDesc; | |
692 | |
693 /* $B%b!<%I$4$H$N%F!<%V%k(B */ | |
694 typedef struct { | |
695 char *name; /* $B%b!<%IL>(B */ | |
696 int nrule; /* $B%k!<%k$N?t(B */ | |
697 ConvDesc *cdbuf; /* $B%k!<%k(B */ | |
698 wchar *prompt; /* $B%W%m%s%W%HJ8;zNs(B */ | |
699 ushort fallthrough; | |
700 } ModeTable; | |
701 | |
702 /* ccParseRule() $B$GFbItI=8=$KJQ49$5$l$?%k!<%k(B */ | |
703 typedef struct _ccRule { | |
704 char *rulefile; /* $BDj5A%U%!%$%kL>(B */ | |
705 ccRule next; /* $B%k!<%k%j%9%H$N<!$NMWAG(B */ | |
706 int refcnt; /* $B;2>H?t(B */ | |
707 int nmode; /* $B%b!<%I$N?t(B */ | |
708 int initialmode; /* $B=i4|%b!<%I(B */ | |
709 ModeTable *modes; /* $B%b!<%I%F!<%V%k(B */ | |
710 wchar *strbuf; /* $B%9%H%j%s%0%P%C%U%!(B */ | |
711 ushort *funcbuf; /* $B%U%!%s%/%7%g%s%P%C%U%!(B */ | |
712 int nfunc; /* $B%U%!%s%/%7%g%s$N?t(B */ | |
713 char *funcnamebuf; /* $B%U%!%s%/%7%g%sL>$N%P%C%U%!(B */ | |
714 void (*errorfunc)(); /* $B%(%i!<%3!<%k%P%C%/(B */ | |
715 int casesensitive; /* $BBgJ8;z>.J8;z$r6hJL$9$k$+$I$&$+(B */ | |
716 int autofix; /* $B<+F03NDj$r$9$k$+$I$&$+(B */ | |
717 } ccRuleRec; | |
718 | |
719 static ccRule ccrules; /* $BJQ49%k!<%k$N%j%9%H(B */ | |
720 | |
721 /* ccCreateBuf() $B$G:n$i$l$kJQ49%P%C%U%!(B */ | |
722 typedef struct _ccBuf { | |
723 ccRule rule; /* $BJQ49%k!<%k(B */ | |
724 short *functbl; | |
725 void (*defaultaction)(); /* callback functions */ | |
726 void (*insertchar)(); | |
727 void (*deletechar)(); | |
728 int (*executefunction)(); /* True $B$rJV$;$P=>Mh$I$*$j<!$N%U%!%s%/(B | |
729 $B%7%g%s$r8F$V$,!"(BFalse $B$rJV$;$P!"(B | |
730 goto $B$N$h$&$K<!$N4X?t$OL5;k$9$k(B */ | |
731 void (*autofix)(); | |
732 void (*modenotify)(); | |
733 caddr_t client_data; | |
734 int currentmode; /* $B8=:_$N%b!<%I(B */ | |
735 int previousmode; /* $B0l$DA0$N%b!<%I(B */ | |
736 wchar *context; | |
737 wchar *contextend; | |
738 int contextsize; | |
739 unsigned int modifier; /* $B<!$NF~NO%-!<$r%b%G%#%U%!%$%d$D$-$K$9$k(B */ | |
740 } ccBufRec; | |
741 | |
742 #define STRSIZE 200 | |
743 #define MORESTRSIZE 100 | |
744 typedef struct { | |
745 wchar *strbuf; | |
746 wchar *strend; | |
747 wchar *strp; | |
748 } _strbufRec; | |
749 | |
750 #define CDSIZE 10 | |
751 #define MORECDSIZE 30 | |
752 typedef struct { | |
753 ConvDesc *cdbuf; /* ConvDesc $B%"%l%$(B */ | |
754 ConvDesc *cdend; | |
755 ConvDesc *cdp; | |
756 } _cdbufRec; | |
757 | |
758 #define FUNCSIZE 20 | |
759 #define MOREFUNCSIZE 20 | |
760 typedef struct { | |
761 ushort *funcbuf; /* $B%U%!%s%/%7%g%s%Y%/%?(B */ | |
762 ushort *funcend; | |
763 ushort *funcp; | |
764 } _funcbufRec; | |
765 | |
766 #define MAXFUNC 1024 /* $B%U%!%s%/%7%g%s$N<oN`$N>e8B(B */ | |
767 #define FUNCNAMESIZE 100 | |
768 #define MOREFUNCNAMESIZE 50 | |
769 typedef struct { | |
770 int nfunc; | |
771 ushort funcnames[MAXFUNC]; | |
772 char *funcnamebuf; | |
773 char *funcnameend; | |
774 char *funcnamep; | |
775 int funcsize; | |
776 } _funcnameRec; | |
777 | |
778 /* $BDj5A%U%!%$%k(B (for include directive) */ | |
779 #define MAXINC 10 | |
780 typedef struct { | |
781 int findex; | |
782 FILE *fp[MAXINC]; | |
783 } Files; | |
784 | |
785 #ifdef __STDC__ | |
786 static int wstrlen(wchar *); | |
787 static wchar *wrev(wchar *); | |
788 static void eproc(void (*)(), char *); | |
789 static wchar *promptsave(wchar *); | |
790 static int parseLine(uchar *, uchar **, int); | |
791 static FILE *openfile(char *); | |
792 static int doinclude(uchar *, Files *, void (*)()); | |
793 static uchar *getline(uchar *, int, Files *, void (*)()); | |
794 static int readRuleFile(ccRule, char *); | |
795 static int registMode(ccRule, int, uchar **); | |
796 static int newMode(ccRule, Files *, _strbufRec *, _funcbufRec *, | |
797 _funcnameRec *, int, uchar **); | |
798 static int getDesc(ccRule, uchar *, _funcbufRec *, _funcnameRec *, | |
799 ulong *, int *, wchar *, wchar *, int *); | |
800 static int getMode(ccRule, uchar *); | |
801 static uchar *getQuote(uchar *, wchar *, int); | |
802 static int getKey(uchar *, ulong *, int *); | |
803 static int getmask(uchar *); | |
804 static char *strinc(char *, char *); | |
805 static ulong getcode(uchar *); | |
806 static int getFunc(ccRule, _funcbufRec *, _funcnameRec *, int, uchar **); | |
807 static ccRule findRule(char *); | |
808 static void addRule(ccRule); | |
809 static void deleteRule(ccRule); | |
810 static int wstrsave(_strbufRec *, wchar *); | |
811 static int wstralloc(_strbufRec *, int); | |
812 static void wstradjust(_strbufRec *); | |
813 static ConvDesc *cdalloc(_cdbufRec *); | |
814 static void cdadjust(_cdbufRec *); | |
815 static int funcalloc(_funcbufRec *, int); | |
816 static void funcadjust(_funcbufRec *); | |
817 static int funcsearch(_funcnameRec *, char *); | |
818 static void funcnameadjust(_funcnameRec *); | |
819 static int convchar(ccBuf, ulong, int, char *, int); | |
820 static int cconvert(ccBuf, int, ulong, int, int *, char *, int); | |
821 static int metamatch(ulong, ulong, int); | |
822 static int contextMatch(ccBuf, wchar *); | |
823 static void substStr(ccBuf, wchar *, wchar *, char *, int); | |
824 #else | |
825 static int wstrlen(); | |
826 static wchar *wrev(); | |
827 static void eproc(); | |
828 static wchar *promptsave(); | |
829 static int parseLine(); | |
830 static int readRuleFile(); | |
831 static int registMode(); | |
832 static int newMode(); | |
833 static int getDesc(); | |
834 static int getMode(); | |
835 static uchar *getQuote(); | |
836 static int getKey(); | |
837 static int getmask(); | |
838 static char *strinc(); | |
839 static ulong getcode(); | |
840 static int getFunc(); | |
841 static int wstrsave(); | |
842 static int wstralloc(); | |
843 static void wstradjust(); | |
844 static ConvDesc *cdalloc(); | |
845 static void cdadjust(); | |
846 static int funcalloc(); | |
847 static void funcadjust(); | |
848 static int funcsearch(); | |
849 static void funcnameadjust(); | |
850 static int convchar(); | |
851 static int cconvert(); | |
852 static int metamatch(); | |
853 static int contextMatch(); | |
854 static void substStr(); | |
855 #endif | |
856 | |
857 /* | |
858 * Private Functions | |
859 */ | |
860 | |
861 static int wstrlen(str) | |
862 wchar *str; | |
863 { | |
864 int len = 0; | |
865 | |
866 while (*str++) | |
867 len++; | |
868 return len; | |
869 } | |
870 | |
871 static wchar *wrev(s) | |
872 wchar *s; | |
873 { | |
874 wchar *str = s; | |
875 wchar *end = str; | |
876 int c; | |
877 | |
878 while (*end++) | |
879 ; | |
880 end -= 2; | |
881 while (str < end) { | |
882 c = *str; | |
883 *str++ = *end; | |
884 *end-- = c; | |
885 } | |
886 return s; | |
887 } | |
888 | |
889 static void eproc(efunc, msg) | |
890 void (*efunc)(); | |
891 char *msg; | |
892 { | |
893 if (efunc == NULL) { | |
894 /* stderr $B$K%W%j%s%H(B */ | |
895 (void)fprintf(stderr, "%s\n", msg); | |
896 } else { | |
897 /* $B%(%i!<%O%s%I%i$r8F$V(B */ | |
898 (*efunc)(msg); | |
899 } | |
900 } | |
901 | |
902 static wchar *promptsave(str) | |
903 wchar *str; | |
904 { | |
905 int len = (wstrlen(str) + 1) * sizeof(wchar); | |
906 wchar *p = (wchar *)Malloc(len); | |
907 | |
908 if (p != NULL) { | |
909 wchar *q = p; | |
910 while (*q++ = *str++) | |
911 ; | |
912 } | |
913 return p; | |
914 } | |
915 | |
916 static int parseLine(line, argv, argvsize) | |
917 uchar *line; | |
918 uchar **argv; | |
919 int argvsize; | |
920 { | |
921 int c, qc; | |
922 int argc; | |
923 int state; | |
924 #define IN_WORD 1 /* $B%o!<%I$NCf(B */ | |
925 #define IN_QUOTE 2 /* $B%o!<%I$NCf$G$5$i$K%/%)!<%H$NCf(B */ | |
926 | |
927 qc = 0; /* not necessary, but for lint */ | |
928 argc = 0; | |
929 state = 0; /* $B%o!<%I$N30(B */ | |
930 while (c = *line) { | |
931 /* $B%/%)!<%H$5$l$F$$$J$$6uGrJ8;z$O!"%o!<%I$r=*$i$;$k(B */ | |
932 if (state != IN_QUOTE && (c == ' ' || c == '\t' || c == '\n')) { | |
933 /* NULL $B%?!<%_%M!<%H$5$;$k(B */ | |
934 *line++ = '\0'; | |
935 state = 0; | |
936 continue; | |
937 } | |
938 /* $B%o!<%I$N30$N6uGr0J30$NJ8;z$O!"%o!<%I$N;O$^$j$K$J$k(B */ | |
939 if (state == 0) { | |
940 if (argc >= argvsize) | |
941 return argc; | |
942 argv[argc++] = line; | |
943 state = IN_WORD; | |
944 } | |
945 /* $B%P%C%/%9%i%C%7%e$O!"<!$NJ8;z$r%9%-%C%W$5$;$k(B */ | |
946 if (c == '\\') { | |
947 /* $B$H$O$$$C$F$b<!$,(B Nul $BJ8;z$J$iOC$OJL(B */ | |
948 if (*++line == '\0') { | |
949 *--line = '\0'; | |
950 break; | |
951 } | |
952 } else if (state == IN_QUOTE) { | |
953 /* $B%/%)!<%H$O;O$^$j$HF1$8J8;z$G=*$k(B */ | |
954 if (c == qc) | |
955 state = IN_WORD; | |
956 } else if (c == '\'' || c == '"') { | |
957 /* $B%/%)!<%H$N30$K%/%)!<%HJ8;z$,$"$l$P%/%)!<%H$N;O$^$j(B */ | |
958 state = IN_QUOTE; | |
959 qc = c; | |
960 } | |
961 line++; | |
962 } | |
963 | |
964 /* $B:G8e$N%/%)!<%H$,JD$8$F$$$J$$$+$b$7$l$J$$(B */ | |
965 return state != IN_QUOTE ? argc : argc - 1; | |
966 } | |
967 | |
968 /* openfile -- $BDj5A%U%!%$%k$r%*!<%W%s$9$k(B */ | |
969 static FILE *openfile(file) | |
970 char *file; | |
971 { | |
972 FILE *fp; | |
973 char filename[1024]; | |
974 FILE *fopen(); | |
975 char *getenv(); | |
976 | |
977 if ((fp = fopen(file, "r")) == NULL && *file != '/') { | |
978 char *p, *q; | |
979 /* $B4D6-JQ?t(B CC_DEF_PATH $B$,$"$l$P$=$N%Q%9$N2<$r(B | |
980 * $B%5!<%A$9$k(B | |
981 */ | |
982 if ((p = getenv("CC_DEF_PATH")) != NULL) { | |
983 while (*p != '\0') { | |
984 q = filename; | |
985 while (*p != '\0' && *p != ':') | |
986 *q++ = *p++; | |
987 if (*p == ':') p++; | |
988 if (q == filename) continue; | |
989 *q++ = '/'; | |
990 *q = '\0'; | |
991 (void)Strcat(filename, file); | |
992 if ((fp = fopen(filename, "r")) != NULL) | |
993 return fp; | |
994 } | |
995 } | |
996 /* $B%G%U%)%k%H$N%5!<%A%Q%9(B CCDEFPATH(/usr/lib/X11/ccdef) $B$N(B | |
997 * $B2<$r%5!<%A$9$k(B | |
998 */ | |
999 (void)Strcpy(filename, CCDEFPATH); | |
1000 (void)Strcat(filename, file); | |
1001 fp = fopen(filename, "r"); | |
1002 } | |
1003 return fp; | |
1004 } | |
1005 | |
1006 /* doinclude -- include $B9T$N=hM}$r$9$k(B */ | |
1007 static int doinclude(line, files, efunc) | |
1008 uchar *line; | |
1009 Files *files; | |
1010 void (*efunc)(); | |
1011 { | |
1012 int argc; | |
1013 uchar *argv[2]; | |
1014 char *name; | |
1015 | |
1016 argc = parseLine(line, argv, 2); | |
1017 if (files->findex > MAXINC - 2) { | |
1018 eproc(efunc, "include nesting too deep"); | |
1019 return -1; | |
1020 } | |
1021 if (argc < 2) { | |
1022 eproc(efunc, "missing include filename"); | |
1023 return -1; | |
1024 } | |
1025 name = (char *)argv[1]; | |
1026 if (*name == '\'' || *name == '"') { | |
1027 name++; | |
1028 name[strlen(name) - 1] = '\0'; | |
1029 } | |
1030 if ((files->fp[++files->findex] = openfile(name)) == NULL) { | |
1031 EPROC2(efunc, "can't open %s", name); | |
1032 --files->findex; | |
1033 return -1; | |
1034 } | |
1035 return 0; | |
1036 } | |
1037 | |
1038 /* getline -- 1$B9TFI$_9~$`(B ($B$=$N:](B include $B$N=hM}$r9T$J$&(B) */ | |
1039 static uchar *getline(line, linesize, files, efunc) | |
1040 uchar *line; | |
1041 int linesize; | |
1042 Files *files; | |
1043 void (*efunc)(); | |
1044 { | |
1045 redo: | |
1046 if (fgets((char *)line, linesize, files->fp[files->findex])) { | |
1047 register uchar *p = line; | |
1048 while (*p == ' ' || *p == '\t') | |
1049 p++; | |
1050 if (!Strncmp(p, "include", 7)) { | |
1051 if (doinclude(p, files, efunc) < 0) { | |
1052 return NULL; | |
1053 } else { | |
1054 goto redo; | |
1055 } | |
1056 } | |
1057 return line; | |
1058 } | |
1059 (void)fclose(files->fp[files->findex]); | |
1060 files->findex--; | |
1061 | |
1062 if (files->findex >= 0) { | |
1063 goto redo; | |
1064 } | |
1065 | |
1066 return NULL; | |
1067 } | |
1068 | |
1069 /* readRuleFile -- $BJQ49%k!<%kDj5A%U%!%$%k$rFI$_9~$`(B */ | |
1070 static int readRuleFile(rule, file) | |
1071 ccRule rule; | |
1072 char *file; | |
1073 { | |
1074 FILE *fp; | |
1075 int moderegistered; | |
1076 uchar line[256], tmp[256]; | |
1077 uchar *argv[20]; | |
1078 int argc; | |
1079 _strbufRec strrec; | |
1080 _funcbufRec funcrec; | |
1081 _funcnameRec fnrec; | |
1082 Files files; | |
1083 void (*efunc)() = rule->errorfunc; | |
1084 int err = 0; | |
1085 | |
1086 if ((fp = openfile(file)) == NULL) { | |
1087 EPROC2(efunc, "can't open file %s", file); | |
1088 return -1; | |
1089 } | |
1090 files.findex = 0; | |
1091 files.fp[0] = fp; | |
1092 | |
1093 moderegistered = 0; | |
1094 | |
1095 strrec.strbuf = NULL; | |
1096 funcrec.funcbuf = NULL; | |
1097 fnrec.nfunc = 0; | |
1098 fnrec.funcnamebuf = NULL; | |
1099 | |
1100 rule->nmode = 0; | |
1101 rule->initialmode = -1; | |
1102 | |
1103 while (getline(line, sizeof(line), &files, efunc)) { | |
1104 (void)Strcpy(tmp, line); | |
1105 if ((argc = parseLine(tmp, argv, 20)) == 0) | |
1106 continue; | |
1107 | |
1108 /* '#' $B$G;O$^$k9T$O%3%a%s%H(B */ | |
1109 if (*line == '\0' || *line == '\n' || *line == '#') { | |
1110 continue; | |
1111 } else if (!moderegistered && argc > 1 && | |
1112 !Strcmp(argv[0], "defmode")) { | |
1113 /* $B%b!<%IDj5A9T(B */ | |
1114 if (registMode(rule, argc, argv) < 0) { | |
1115 err++; | |
1116 break; | |
1117 } | |
1118 moderegistered++; | |
1119 } else if (!Strcmp(argv[0], "mode") && argc > 2) { | |
1120 /* $B$"$k%b!<%I$KBP$9$kJQ49Dj5A(B */ | |
1121 if (!moderegistered) { | |
1122 eproc(efunc, "'mode' before 'defmode'"); | |
1123 err++; | |
1124 break; | |
1125 } | |
1126 if (newMode(rule, &files, &strrec, &funcrec, &fnrec, | |
1127 argc, argv) < 0) { | |
1128 err++; | |
1129 break; | |
1130 } | |
1131 } else if (!Strcmp(argv[0], "initialmode") && | |
1132 argc > 1) { | |
1133 if (!moderegistered) { | |
1134 eproc(efunc, "'initialmode' before 'defmode'"); | |
1135 err++; | |
1136 break; | |
1137 } | |
1138 rule->initialmode = getMode(rule, argv[1]); | |
1139 } else if (!Strcmp(argv[0], "casesensitive")) { | |
1140 rule->casesensitive = True; | |
1141 } else if (!Strcmp(argv[0], "caseinsensitive")) { | |
1142 rule->casesensitive = False; | |
1143 } else if (!Strcmp(argv[0], "autofix")) { | |
1144 rule->autofix = True; | |
1145 } else if (!Strcmp(argv[0], "noautofix")) { | |
1146 rule->autofix = False; | |
1147 } else { | |
1148 EPROC2(efunc, "syntax error - %s", line); | |
1149 } | |
1150 } | |
1151 | |
1152 /* Close all opened files. */ | |
1153 while (files.findex >= 0) { | |
1154 (void)fclose(files.fp[files.findex--]); | |
1155 } | |
1156 | |
1157 if (err) { | |
1158 return -1; | |
1159 } | |
1160 if (rule->nmode == 0) { | |
1161 eproc(efunc, "no modes defined"); | |
1162 return -1; | |
1163 } | |
1164 if (!moderegistered) { | |
1165 eproc(efunc, "'defmode' required"); | |
1166 return -1; | |
1167 } | |
1168 if (rule->initialmode < 0) { | |
1169 eproc(efunc, "'initialmode' required"); | |
1170 return -1; | |
1171 } | |
1172 | |
1173 wstradjust(&strrec); | |
1174 funcadjust(&funcrec); | |
1175 funcnameadjust(&fnrec); | |
1176 | |
1177 rule->strbuf = strrec.strbuf; | |
1178 rule->funcbuf = funcrec.funcbuf; | |
1179 rule->funcnamebuf = fnrec.funcnamebuf; | |
1180 rule->nfunc = fnrec.nfunc; | |
1181 #ifdef DEBUG_CCONV | |
1182 dumpAllRules(rule); | |
1183 #endif | |
1184 | |
1185 return 0; | |
1186 } | |
1187 | |
1188 static int registMode(rule, ac, av) | |
1189 ccRule rule; | |
1190 int ac; | |
1191 uchar **av; | |
1192 { | |
1193 int nmode; | |
1194 ModeTable *modes; | |
1195 int i; | |
1196 | |
1197 ac--, av++; | |
1198 | |
1199 nmode = ac; | |
1200 modes = (ModeTable *)Malloc(nmode * sizeof(ModeTable)); | |
1201 if (modes == NULL) { | |
1202 eproc(rule->errorfunc, "can't alloc memory"); | |
1203 return -1; | |
1204 } | |
1205 rule->modes = modes; | |
1206 | |
1207 for (i = 0; i < nmode; i++) { | |
1208 if ((modes[i].name = Malloc(Strlen(av[i]) + 1)) == NULL) { | |
1209 eproc(rule->errorfunc, "can't alloc memory"); | |
1210 Free(modes); | |
1211 return -1; | |
1212 } | |
1213 (void)Strcpy(modes[i].name, av[i]); | |
1214 modes[i].nrule = 0; | |
1215 modes[i].cdbuf = NULL; | |
1216 modes[i].prompt = NULL; | |
1217 modes[i].fallthrough = NOMODE; | |
1218 } | |
1219 | |
1220 rule->nmode = nmode; | |
1221 return 0; | |
1222 } | |
1223 | |
1224 /* newMode -- $B$"$k%b!<%I$K$D$$$F$N%k!<%k$rFI$_9~$`(B */ | |
1225 static int newMode(rule, files, srec, frec, fnrec, ac, av) | |
1226 ccRule rule; | |
1227 Files *files; | |
1228 _strbufRec *srec; | |
1229 _funcbufRec *frec; | |
1230 _funcnameRec *fnrec; | |
1231 int ac; | |
1232 uchar **av; | |
1233 { | |
1234 uchar line[256]; | |
1235 int mode; | |
1236 ulong inkey; | |
1237 int modmask; | |
1238 wchar prompt[30], context[100], result[100]; | |
1239 int func; | |
1240 int ndesc = 0; | |
1241 ModeTable *mp; | |
1242 ConvDesc *cdp; | |
1243 _cdbufRec cdbuf; | |
1244 void (*efunc)() = rule->errorfunc; | |
1245 | |
1246 /* $B%U%)!<%^%C%H$O(B | |
1247 * "mode <$B%b!<%IL>(B> <"$B%W%m%s%W%HJ8;zNs(B"> [fallthrough <$B%b!<%IL>(B>] | |
1248 */ | |
1249 /* $B%b!<%I$N%A%'%C%/(B */ | |
1250 if ((mode = getMode(rule, av[1])) < 0) { | |
1251 EPROC2(efunc, "illegal modename: %s", av[1]); | |
1252 return -1; /* No Such Mode */ | |
1253 } | |
1254 mp = &rule->modes[mode]; | |
1255 | |
1256 if (getQuote(av[2], prompt, 0) == NULL) { | |
1257 EPROC2(efunc, "illegal prompt: %s", av[2]); | |
1258 return -1; | |
1259 } | |
1260 mp->prompt = promptsave(prompt); | |
1261 mp->nrule = 0; | |
1262 | |
1263 if (ac > 4 && !Strcmp(av[3], "fallthrough")) { | |
1264 mp->fallthrough = getMode(rule, av[4]); | |
1265 } else { | |
1266 mp->fallthrough = NOMODE; | |
1267 } | |
1268 | |
1269 cdbuf.cdbuf = NULL; | |
1270 | |
1271 /* $B%k!<%k$rFI$s$G%9%H%"$9$k(B */ | |
1272 while (getline(line, sizeof(line), files, efunc)) { | |
1273 /* '#' $B$G;O$^$k9T$O%3%a%s%H(B */ | |
1274 if (*line == '\0' || *line == '\n' || *line == '#') | |
1275 continue; | |
1276 if (!Strncmp(line, "endmode", 6)) | |
1277 break; | |
1278 if (getDesc(rule, line, frec, fnrec, &inkey, &modmask, | |
1279 context, result, &func)) { | |
1280 if ((cdp = cdalloc(&cdbuf)) == NULL) { | |
1281 return -1; | |
1282 } | |
1283 | |
1284 /* $B%k!<%k$N%9%H%"(B */ | |
1285 cdp->key = inkey; | |
1286 cdp->mask = modmask; | |
1287 cdp->context = *context ? wstrsave(srec, wrev(context)) : 0; | |
1288 cdp->result = *result ? wstrsave(srec, result) : 0; | |
1289 cdp->function = func; | |
1290 ndesc++; | |
1291 } else | |
1292 EPROC2(efunc, "illegal description - %s", line); | |
1293 } | |
1294 | |
1295 /* $B%k!<%k$,#1$D$b$J$1$l$P%(%i!<$K$9$Y$-$@$m$&(B */ | |
1296 /* $B$H;W$C$?$,Nc$($P(B ASCII $B%b!<%I$N$H$-$K$O%k!<%k$,#1$D$b$J$$$3$H$,(B | |
1297 * $B$"$j$&$k(B | |
1298 */ | |
1299 | |
1300 cdadjust(&cdbuf); | |
1301 | |
1302 mp->nrule = ndesc; | |
1303 mp->cdbuf = cdbuf.cdbuf; | |
1304 | |
1305 return 0; | |
1306 } | |
1307 | |
1308 static int getDesc(rule, line, frec, fnrec, keyp, maskp, context, result, funcp) | |
1309 ccRule rule; | |
1310 uchar *line; | |
1311 _funcbufRec *frec; | |
1312 _funcnameRec *fnrec; | |
1313 ulong *keyp; | |
1314 int *maskp; | |
1315 wchar *context; | |
1316 wchar *result; | |
1317 int *funcp; | |
1318 { | |
1319 uchar tmp[256]; | |
1320 uchar *av[20]; | |
1321 int ac; | |
1322 void (*efunc)() = rule->errorfunc; | |
1323 | |
1324 /* valid description format is: | |
1325 "context" key "result" [function...] | |
1326 */ | |
1327 | |
1328 (void)Strcpy(tmp, line); | |
1329 ac = parseLine(tmp, av, 20); | |
1330 if (ac < 3) { | |
1331 EPROC2(efunc, "syntax error - %s", line); | |
1332 return 0; | |
1333 } | |
1334 | |
1335 /* context $B$NFI$_9~$_(B */ | |
1336 if (getQuote(av[0], context, 0) == NULL) | |
1337 return 0; | |
1338 | |
1339 /* $B%-!<%3!<%I$rFI$_9~$s$G(B */ | |
1340 if (getKey(av[1], keyp, maskp) < 0) { | |
1341 EPROC2(efunc, "no such key (%s)", av[1]); | |
1342 return 0; | |
1343 } | |
1344 | |
1345 /* result $B$rFI$_9~$s$G(B */ | |
1346 if (getQuote(av[2], result, 1) == NULL) | |
1347 return 0; | |
1348 | |
1349 /* $B%U%!%s%/%7%g%s$N5-=R$,$"$l$P$=$l$rFI$_9~$`(B */ | |
1350 /* $B$b$7AjEv$9$k%U%!%s%/%7%g%s$,$J$/$F$b%(%i!<$K$7$J$$(B */ | |
1351 if (ac > 3) { | |
1352 *funcp = getFunc(rule, frec, fnrec, ac - 3, &av[3]); | |
1353 } else { | |
1354 *funcp = 0; | |
1355 } | |
1356 | |
1357 return 1; | |
1358 } | |
1359 | |
1360 static int getMode(rule, str) | |
1361 ccRule rule; | |
1362 uchar *str; | |
1363 { | |
1364 ModeTable *modes = rule->modes; | |
1365 int i; | |
1366 | |
1367 for (i = 0; i < rule->nmode; i++) { | |
1368 if (!Strcmp(str, modes[i].name)) | |
1369 return i; | |
1370 } | |
1371 EPROC2(rule->errorfunc, "undefined mode %s", str); | |
1372 return -1; | |
1373 } | |
1374 | |
1375 /* getQuote -- $B%/%)!<%F!<%7%g%s5-9f$G0O$^$l$?J8;zNs$rFI$s$G(B wchar $B$K$9$k(B */ | |
1376 static uchar *getQuote(line, str, metaf) | |
1377 uchar *line; | |
1378 wchar *str; | |
1379 int metaf; /* '&' $B$H(B '/' $B$r%a%?!&%-%c%i%/%?$H$9$k$+$I$&$+(B */ | |
1380 { | |
1381 int c; | |
1382 int quote; /* quote flag */ | |
1383 int qc = *line++; /* quote character */ | |
1384 #define SS2 0x8e | |
1385 #define SS3 0x8f | |
1386 | |
1387 if (qc != '\'' && qc != '"') | |
1388 return((uchar *)NULL); | |
1389 | |
1390 quote = 0; | |
1391 while ((c = *line++) && c != qc) { | |
1392 if (c == '\\' && !quote) { | |
1393 quote = 1; | |
1394 continue; | |
1395 } | |
1396 | |
1397 if (c == '^' && !quote) { | |
1398 if (c = *line++) | |
1399 *str++ = c - '@'; | |
1400 else | |
1401 break; | |
1402 } else if (metaf && c == '&' && !quote) | |
1403 *str++ = MATCHED_CHAR; | |
1404 else if (metaf && c == '/' && !quote) | |
1405 *str++ = CCLEAR_CHAR; | |
1406 else if (c < 0x80) | |
1407 *str++ = c; | |
1408 else if (c == SS2) | |
1409 *str++ = *line++ | 0x80; | |
1410 else if (c == SS3) { | |
1411 c = *line++; | |
1412 *str++ = (c << 8) | (*line++ & 0x7f) | 0x8000; | |
1413 } else { | |
1414 *str++ = (c << 8) | *line++ | 0x8080; | |
1415 } | |
1416 } | |
1417 *str = 0; | |
1418 | |
1419 return((c == qc) ? line : (uchar *)NULL); | |
1420 } | |
1421 | |
1422 /* getKey -- $B%-!<%3!<%I$rFI$`(B */ | |
1423 static int getKey(line, keyp, maskp) | |
1424 uchar *line; | |
1425 ulong *keyp; | |
1426 int *maskp; | |
1427 { | |
1428 /* | |
1429 * $B%-!<%3!<%I$N5-=RK!$O#2DL$j(B | |
1430 * 1. ASCII $BI=5-(B | |
1431 * 'a' | |
1432 * '^H' | |
1433 * '\033' | |
1434 * '\xff' | |
1435 * | |
1436 * 2. XKEY $BI=5-(B | |
1437 * #124 | |
1438 * #0132 | |
1439 * #0x58 | |
1440 * shift-A | |
1441 * shift-control-meta-HENKAN | |
1442 * | |
1443 * pseudo code | |
1444 * ENTERMODE | |
1445 * EXITMODE | |
1446 * | |
1447 * wild character | |
1448 * @ascii | |
1449 * @control | |
1450 * @raw | |
1451 * @any | |
1452 */ | |
1453 | |
1454 int key = 0; | |
1455 | |
1456 *maskp = 0; | |
1457 | |
1458 if (*line == '\'') { /* $B%7%s%0%k%/%)!<%H$G;O$^$k$N$G(B ASCII $BI=5-(B */ | |
1459 if (*++line == '\\') { | |
1460 /* '\'' $B$N>l9g(B($B%7%s%0%k%/%)!<%H<+?H(B)$B!"(B | |
1461 * '\\' $B$N>l9g(B($B%P%C%/%9%i%C%7%e(B) | |
1462 * '\033' $B$N$h$&$J#8?JI=5-$N>l9g$H(B | |
1463 * '\x27' $B$N$h$&$J#1#6?JI=5-$N>l9g$,$"$k(B | |
1464 */ | |
1465 if (*++line == '\'') /* '\'' */ | |
1466 key = '\''; | |
1467 else if (*line == '\\') /* '\\' */ | |
1468 key = '\\'; | |
1469 else if (*line == 'x') /* hexadecimal */ | |
1470 (void)sscanf((char *)++line, "%x", &key); | |
1471 else /* octal */ | |
1472 (void)sscanf((char *)line, "%o", &key); | |
1473 key &= 0xff; | |
1474 } else if (*line == '^') { | |
1475 /* '^' ($B%+%l%C%H<+?H(B) $B$^$?$O%3%s%H%m!<%k%3!<%I(B */ | |
1476 if (*++line == '\'') | |
1477 key = '^'; | |
1478 else | |
1479 key = *line - '@'; | |
1480 } else { | |
1481 key = *line; | |
1482 } | |
1483 *keyp = key; | |
1484 } else if (*line == '#') { /* event code */ | |
1485 if (*++line == '0') { /* octal or hexadecimal */ | |
1486 if (*(line + 1) == 'x') /* hexadecimal */ | |
1487 (void)sscanf((char *)line + 2, "%x", &key); | |
1488 else /* octal */ | |
1489 (void)sscanf((char *)line, "%o", &key); | |
1490 } else { | |
1491 key = atoi((char *)line); | |
1492 } | |
1493 *keyp = (ulong)key | (ulong)RAWKEY; | |
1494 } else if (!Strcmp(line, "ENTERMODE")) { | |
1495 *keyp = ENTERMODE; | |
1496 } else if (!Strcmp(line, "EXITMODE")) { | |
1497 *keyp = EXITMODE; | |
1498 } else if (*line == '@') { | |
1499 /* $B%o%$%k%I!&%-%c%i%/%?(B */ | |
1500 line++; | |
1501 if (!Strcmp(line, "ascii")) | |
1502 key = META_ASCII; | |
1503 else if (!Strcmp(line, "printable")) | |
1504 key = META_PRINTABLE; | |
1505 else if (!Strcmp(line, "control")) | |
1506 key = META_CONTROL; | |
1507 else if (!Strcmp(line, "raw")) | |
1508 key = META_RAW; | |
1509 else if (!Strcmp(line, "any")) | |
1510 key = META_ANY; | |
1511 else if (!Strcmp(line, "func")) | |
1512 key = META_FUNC; | |
1513 else if (!Strcmp(line, "cursor")) | |
1514 key = META_CURSOR; | |
1515 else if (!Strcmp(line, "keypad")) | |
1516 key = META_KEYPAD; | |
1517 else if (!Strcmp(line, "modifier")) | |
1518 key = META_MODIFIER; | |
1519 else if (!Strcmp(line, "non-ascii")) | |
1520 key = META_NONASCII; | |
1521 else | |
1522 return -1; | |
1523 *keyp = (ulong)key | (ulong)METAC; | |
1524 } else { | |
1525 if ((key = getcode(line)) == 0) | |
1526 return -1; | |
1527 *keyp = (ulong)key | (ulong)RAWKEY; | |
1528 *maskp = getmask(line); | |
1529 } | |
1530 return 0; | |
1531 } | |
1532 | |
1533 /* getmask -- $B%b%G%#%U%!%$%"!&%^%9%/$rJV$9(B */ | |
1534 static int getmask(s) | |
1535 uchar *s; | |
1536 { | |
1537 int mask = 0; | |
1538 char buf[256]; | |
1539 uchar *p; | |
1540 | |
1541 if ((p = (uchar *)rindex((char *)s, '-')) == NULL) | |
1542 return 0; | |
1543 (void)strncpy(buf, (char *)s, p - s); | |
1544 buf[p - s] = '\0'; | |
1545 | |
1546 if (strinc(buf, "shift")) | |
1547 mask |= ShiftMask; | |
1548 if (strinc(buf, "control")) | |
1549 mask |= ControlMask; | |
1550 if (strinc(buf, "lock")) | |
1551 mask |= LockMask; | |
1552 if (strinc(buf, "mod1")) | |
1553 mask |= Mod1Mask; | |
1554 if (strinc(buf, "mod2")) | |
1555 mask |= Mod2Mask; | |
1556 if (strinc(buf, "mod3")) | |
1557 mask |= Mod3Mask; | |
1558 if (strinc(buf, "mod4")) | |
1559 mask |= Mod4Mask; | |
1560 if (strinc(buf, "mod5")) | |
1561 mask |= Mod5Mask; | |
1562 return mask; | |
1563 } | |
1564 | |
1565 static char *strinc(s, k) | |
1566 char *s; | |
1567 char *k; | |
1568 { | |
1569 register int len = Strlen(k); | |
1570 | |
1571 while (s = index(s, *k)) | |
1572 if (!Strncmp(s, k, len)) | |
1573 return s; | |
1574 else | |
1575 s++; | |
1576 return NULL; | |
1577 } | |
1578 | |
1579 | |
1580 /* getcode -- KeySym $B$rJV$9(B */ | |
1581 static ulong getcode(s) | |
1582 uchar *s; | |
1583 { | |
1584 register uchar *t; | |
1585 KeySym keysym; | |
1586 KeySym XStringToKeysym(); | |
1587 | |
1588 if ((t = (uchar *)rindex((char *)s, '-')) == NULL) | |
1589 t = s; | |
1590 else | |
1591 t++; | |
1592 keysym = XStringToKeysym((char *)t); | |
1593 if (keysym == NoSymbol) | |
1594 return (ulong)0; | |
1595 else | |
1596 return (ulong)keysym; | |
1597 } | |
1598 | |
1599 static int getFunc(rule, frec, fnrec, n, args) | |
1600 ccRule rule; | |
1601 _funcbufRec *frec; | |
1602 _funcnameRec *fnrec; | |
1603 int n; | |
1604 uchar **args; | |
1605 { | |
1606 int i, j; | |
1607 uchar *func; | |
1608 uchar *arg; | |
1609 ushort *fp; | |
1610 int findex; | |
1611 void (*efunc)() = rule->errorfunc; | |
1612 | |
1613 findex = funcalloc(frec, n + 1); | |
1614 fp = frec->funcbuf + findex; | |
1615 | |
1616 j = 0; | |
1617 while (n > 0) { | |
1618 func = *args++; | |
1619 if (!Strcmp(func, "goto")) { | |
1620 /* $B%b!<%I$NJQ99(B */ | |
1621 if (n < 2) | |
1622 break; /* $B%b!<%IL>$,=q$$$F$J$$(B */ | |
1623 arg = *args++; | |
1624 --n; | |
1625 if (!Strcmp(arg, "PREV")) { | |
1626 fp[j++] = PREVMODE; | |
1627 break; | |
1628 } | |
1629 if ((i = getMode(rule, arg)) < 0) { | |
1630 break; | |
1631 } | |
1632 fp[j++] = MODECHANGE | i; | |
1633 break; | |
1634 } else if (!Strcmp(func, "redo")) { | |
1635 fp[j++] = REDO; | |
1636 break; | |
1637 } else if (!Strncmp(func, "add-modifier-", | |
1638 sizeof("add-modifier-") - 1)) { | |
1639 /* $B<!$NF~NO%-!<$r%b%G%#%U%!%$%d$D$-$K$9$k(B */ | |
1640 char *mod = func + sizeof("add-modifier-") - 1; | |
1641 if (!Strcmp(mod, "shift" )) fp[j++] = FUNC_MODIFIER_SHIFT; | |
1642 else if (!Strcmp(mod, "control")) fp[j++] = FUNC_MODIFIER_CONTROL; | |
1643 else if (!Strcmp(mod, "lock" )) fp[j++] = FUNC_MODIFIER_LOCK; | |
1644 else if (!Strcmp(mod, "mod1" )) fp[j++] = FUNC_MODIFIER_MOD1; | |
1645 else if (!Strcmp(mod, "mod2" )) fp[j++] = FUNC_MODIFIER_MOD2; | |
1646 else if (!Strcmp(mod, "mod3" )) fp[j++] = FUNC_MODIFIER_MOD3; | |
1647 else if (!Strcmp(mod, "mod4" )) fp[j++] = FUNC_MODIFIER_MOD4; | |
1648 else if (!Strcmp(mod, "mod5" )) fp[j++] = FUNC_MODIFIER_MOD5; | |
1649 break; | |
1650 } else { | |
1651 /* $B%U%!%s%/%7%g%sI=$N8!:w(B */ | |
1652 int fnum; | |
1653 if ((fnum = funcsearch(fnrec, (char *)func)) < 0) { | |
1654 EPROC2(efunc, "too many functions (> %d)", MAXFUNC); | |
1655 } else { | |
1656 fp[j++] = fnum; | |
1657 } | |
1658 } | |
1659 --n; | |
1660 } | |
1661 fp[j++] = ENDFUNC; | |
1662 frec->funcp = fp + j; /* kludge */ | |
1663 return findex; | |
1664 } | |
1665 | |
1666 static ccRule | |
1667 findRule(rulefile) | |
1668 char *rulefile; | |
1669 { | |
1670 ccRule rule = ccrules; | |
1671 | |
1672 while (rule) { | |
1673 if (rule->rulefile && !strcmp(rulefile, rule->rulefile)) { | |
1674 return rule; | |
1675 } | |
1676 rule = rule->next; | |
1677 } | |
1678 return NULL; | |
1679 } | |
1680 | |
1681 static void | |
1682 addRule(rule) | |
1683 ccRule rule; | |
1684 { | |
1685 rule->refcnt = 1; | |
1686 rule->next = ccrules; | |
1687 ccrules = rule; | |
1688 } | |
1689 | |
1690 static void | |
1691 deleteRule(rule) | |
1692 ccRule rule; | |
1693 { | |
1694 ccRule rp = ccrules; | |
1695 ccRule rp0 = NULL; | |
1696 | |
1697 while (rp) { | |
1698 if (rule == rp) { | |
1699 if (rp0 == NULL) { | |
1700 ccrules = rp->next; | |
1701 } else { | |
1702 rp0->next = rp->next; | |
1703 } | |
1704 return; | |
1705 } | |
1706 rp0 = rp; | |
1707 rp = rp->next; | |
1708 } | |
1709 } | |
1710 | |
1711 static int wstrsave(srec, str) | |
1712 _strbufRec *srec; | |
1713 wchar *str; | |
1714 { | |
1715 int len = wstrlen(str); | |
1716 int pos; | |
1717 wchar *p; | |
1718 | |
1719 pos = wstralloc(srec, len + 1); | |
1720 if (pos > 0) { | |
1721 p = srec->strbuf + pos; | |
1722 while (len-- > 0) { | |
1723 *p++ = *str++; | |
1724 } | |
1725 *p = 0; | |
1726 } | |
1727 return pos; | |
1728 } | |
1729 | |
1730 /* $B%P%C%U%!%"%m%1!<%H%U%!%s%/%7%g%s(B */ | |
1731 | |
1732 static int wstralloc(srec, len) | |
1733 _strbufRec *srec; | |
1734 int len; | |
1735 { | |
1736 int ret; | |
1737 | |
1738 if (srec->strbuf == NULL) { | |
1739 /* allocate srec->strbuf */ | |
1740 srec->strbuf = (wchar *)Malloc(STRSIZE * sizeof(wchar)); | |
1741 if (srec->strbuf == NULL) | |
1742 return 0; | |
1743 srec->strend = srec->strbuf + STRSIZE; | |
1744 srec->strp = srec->strbuf; | |
1745 *srec->strp++ = 0; /* dummy */ | |
1746 } | |
1747 if (srec->strp + len > srec->strend) { | |
1748 /* allocate more memory */ | |
1749 int size = (srec->strp + len) - srec->strend; | |
1750 int offset = srec->strp - srec->strbuf; | |
1751 wchar *wp; | |
1752 | |
1753 if (size < MORESTRSIZE) | |
1754 size = MORESTRSIZE; | |
1755 size += srec->strend - srec->strbuf; | |
1756 wp = (wchar *)Realloc(srec->strbuf, size * sizeof(wchar)); | |
1757 if (wp == NULL) | |
1758 return 0; | |
1759 srec->strp = wp + offset; | |
1760 srec->strbuf = wp; | |
1761 srec->strend = wp + size; | |
1762 } | |
1763 | |
1764 ret = srec->strp - srec->strbuf; | |
1765 srec->strp += len; | |
1766 | |
1767 return ret; | |
1768 } | |
1769 | |
1770 static void wstradjust(srec) | |
1771 _strbufRec *srec; | |
1772 { | |
1773 int size = srec->strp - srec->strbuf; | |
1774 wchar *wp; | |
1775 | |
1776 if (size == 0) return; | |
1777 wp = (wchar *)Realloc(srec->strbuf, size * sizeof(wchar)); | |
1778 if (wp != NULL) { | |
1779 srec->strbuf = wp; | |
1780 srec->strp = srec->strend = wp + size; | |
1781 } | |
1782 } | |
1783 | |
1784 static ConvDesc *cdalloc(crec) | |
1785 _cdbufRec *crec; | |
1786 { | |
1787 ConvDesc *ret; | |
1788 | |
1789 if (crec->cdbuf == NULL) { | |
1790 crec->cdbuf = (ConvDesc *)Malloc(CDSIZE * sizeof(ConvDesc)); | |
1791 if (crec->cdbuf == NULL) | |
1792 return NULL; | |
1793 crec->cdend = crec->cdbuf + CDSIZE; | |
1794 crec->cdp = crec->cdbuf; | |
1795 } | |
1796 if (crec->cdp >= crec->cdend) { | |
1797 int size = crec->cdend - crec->cdbuf + MORECDSIZE; | |
1798 int offset = crec->cdp - crec->cdbuf; | |
1799 ConvDesc *cdp; | |
1800 | |
1801 cdp = (ConvDesc *)Realloc(crec->cdbuf, size * sizeof(ConvDesc)); | |
1802 if (cdp == NULL) { | |
1803 return NULL; | |
1804 } | |
1805 crec->cdp = cdp + offset; | |
1806 crec->cdbuf = cdp; | |
1807 crec->cdend = cdp + size; | |
1808 } | |
1809 | |
1810 ret = crec->cdp++; | |
1811 return ret; | |
1812 } | |
1813 | |
1814 static void cdadjust(crec) | |
1815 _cdbufRec *crec; | |
1816 { | |
1817 int size = crec->cdp - crec->cdbuf; | |
1818 ConvDesc *cdp; | |
1819 | |
1820 if (size == 0) return; | |
1821 cdp = (ConvDesc *)Realloc(crec->cdbuf, size * sizeof(ConvDesc)); | |
1822 if (cdp != NULL) { | |
1823 crec->cdbuf = cdp; | |
1824 crec->cdp = crec->cdend = cdp + size; | |
1825 } | |
1826 } | |
1827 | |
1828 static int funcalloc(frec, n) | |
1829 _funcbufRec *frec; | |
1830 int n; | |
1831 { | |
1832 int ret; | |
1833 | |
1834 if (frec->funcbuf == NULL) { | |
1835 /* allocate funcbuf */ | |
1836 frec->funcbuf = (ushort *)Malloc(FUNCSIZE * sizeof(ushort)); | |
1837 if (frec->funcbuf == NULL) | |
1838 return 0; | |
1839 frec->funcend = frec->funcbuf + FUNCSIZE; | |
1840 frec->funcp = frec->funcbuf; | |
1841 *(frec->funcp)++ = ENDFUNC; /* dummy */ | |
1842 } | |
1843 if (frec->funcp + n > frec->funcend) { | |
1844 /* allocate more memory */ | |
1845 int size = (frec->funcp + n) - frec->funcend; | |
1846 int offset = frec->funcp - frec->funcbuf; | |
1847 ushort *up; | |
1848 | |
1849 if (size < MOREFUNCSIZE) | |
1850 size = MOREFUNCSIZE; | |
1851 size += frec->funcend - frec->funcbuf; | |
1852 up = (ushort *)Realloc(frec->funcbuf, size * sizeof(ushort)); | |
1853 if (up == NULL) | |
1854 return 0; | |
1855 frec->funcp = up + offset; | |
1856 frec->funcbuf = up; | |
1857 frec->funcend = up + size; | |
1858 } | |
1859 | |
1860 ret = frec->funcp - frec->funcbuf; | |
1861 frec->funcp += n; | |
1862 | |
1863 return ret; | |
1864 } | |
1865 | |
1866 static void funcadjust(frec) | |
1867 _funcbufRec *frec; | |
1868 { | |
1869 int size = frec->funcp - frec->funcbuf; | |
1870 ushort *fp; | |
1871 | |
1872 if (size == 0) return; | |
1873 fp = (ushort *)Realloc(frec->funcbuf, size * sizeof(ushort)); | |
1874 if (fp != NULL) { | |
1875 frec->funcbuf = fp; | |
1876 frec->funcp = frec->funcend = fp + size; | |
1877 } | |
1878 } | |
1879 | |
1880 static int funcsearch(fnrec, funcname) | |
1881 _funcnameRec *fnrec; | |
1882 char *funcname; | |
1883 { | |
1884 int nfunc = fnrec->nfunc; | |
1885 ushort *fnames = fnrec->funcnames; | |
1886 char *fnbuf = fnrec->funcnamebuf; | |
1887 int i; | |
1888 int len; | |
1889 | |
1890 for (i = 0; i < nfunc; i++) { | |
1891 if (!strcmp(funcname, fnbuf + *fnames++)) | |
1892 return i; | |
1893 } | |
1894 | |
1895 if (nfunc >= MAXFUNC) | |
1896 return -1; | |
1897 | |
1898 len = strlen(funcname) + 1; | |
1899 | |
1900 /* add new function */ | |
1901 if (fnrec->funcnamebuf == NULL) { | |
1902 /* allocate funcnamebuf */ | |
1903 if ((fnrec->funcnamebuf = Malloc(FUNCNAMESIZE)) == NULL) | |
1904 return -1; | |
1905 fnrec->funcnameend = fnrec->funcnamebuf + FUNCNAMESIZE; | |
1906 fnrec->funcnamep = fnrec->funcnamebuf; | |
1907 } | |
1908 if (fnrec->funcnamep + len > fnrec->funcnameend) { | |
1909 /* allocate more memory */ | |
1910 int size = (fnrec->funcnamep + len) - fnrec->funcnameend; | |
1911 int offset = fnrec->funcnamep - fnrec->funcnamebuf; | |
1912 char *cp; | |
1913 | |
1914 if (size < MOREFUNCNAMESIZE) | |
1915 size = MOREFUNCNAMESIZE; | |
1916 size += fnrec->funcnameend - fnrec->funcnamebuf; | |
1917 if ((cp = Realloc(fnrec->funcnamebuf, size)) == NULL) | |
1918 return 0; | |
1919 fnrec->funcnamep = cp + offset; | |
1920 fnrec->funcnamebuf = cp; | |
1921 fnrec->funcnameend = cp + size; | |
1922 } | |
1923 | |
1924 (void)strcpy(fnrec->funcnamep, funcname); | |
1925 fnrec->funcnames[nfunc] = fnrec->funcnamep - fnrec->funcnamebuf; | |
1926 fnrec->funcnamep += len; | |
1927 | |
1928 return fnrec->nfunc++; | |
1929 } | |
1930 | |
1931 static void funcnameadjust(fnrec) | |
1932 _funcnameRec *fnrec; | |
1933 { | |
1934 int size = fnrec->funcnamep - fnrec->funcnamebuf; | |
1935 char *cp; | |
1936 | |
1937 if (size == 0) return; | |
1938 if (cp = Realloc(fnrec->funcnamebuf, size)) { | |
1939 fnrec->funcnamebuf = cp; | |
1940 fnrec->funcnamep = fnrec->funcnameend = cp + size; | |
1941 } | |
1942 } | |
1943 | |
1944 static int convchar(buf, key, mask, str, len) | |
1945 ccBuf buf; | |
1946 ulong key; /* keysym (RAWKEY) or ascii code */ | |
1947 int mask; /* modifier mask */ | |
1948 char *str; /* ascii interpretation */ | |
1949 int len; /* length of str */ | |
1950 { | |
1951 int r; | |
1952 int func; | |
1953 int redocount = 0; | |
1954 ushort *fp; | |
1955 ccRule rule = buf->rule; | |
1956 | |
1957 redo: | |
1958 /* $B$^$:$O8=:_$N%b!<%I$N%k!<%k$GJQ49$7$F$_$k(B */ | |
1959 r = cconvert(buf, buf->currentmode, key, mask, &func, str, len); | |
1960 if (r < 0) { | |
1961 /* $B%^%C%A$9$k%k!<%k$,8+$D$+$i$J$+$C$?$N$G(B | |
1962 * fallthrough $B$G;XDj$5$l$k%b!<%I$N%k!<%k$rC5$9(B | |
1963 */ | |
1964 int tmpmode = rule->modes[buf->currentmode].fallthrough; | |
1965 | |
1966 while (tmpmode != NOMODE) { | |
1967 r = cconvert(buf, tmpmode, key, mask, &func, str, len); | |
1968 if (r >= 0) /* $B%^%C%A$7$?(B */ | |
1969 break; | |
1970 tmpmode = rule->modes[tmpmode].fallthrough; | |
1971 } | |
1972 } | |
1973 | |
1974 if (r < 0) | |
1975 return -1; /* $B$I$l$K$b%^%C%A$7$J$+$C$?(B */ | |
1976 | |
1977 if (func == 0) | |
1978 return 0; /* $B2?$b$7$J$$(B */ | |
1979 | |
1980 fp = rule->funcbuf + func; | |
1981 while ((func = *fp++) != ENDFUNC) { | |
1982 if (func == REDO) { | |
1983 if (redocount++ > MAXREDO) | |
1984 return -1; /* $B$?$V$sL58B%k!<%W(B */ | |
1985 else | |
1986 goto redo; /* redo -- $B$b$&0lEY(B */ | |
1987 } else if (func & MODECHANGE) { /* $B%+%l%s%H%b!<%I$NJQ99(B */ | |
1988 int tmpmode = buf->currentmode; | |
1989 | |
1990 /* pseudo-key $B$NF~NO(B */ | |
1991 (void)convchar(buf, EXITMODE, 0, (char *)NULL, 0); | |
1992 | |
1993 if (func == PREVMODE) { | |
1994 buf->currentmode = buf->previousmode; | |
1995 } else { | |
1996 buf->currentmode = func & ~MODECHANGE; | |
1997 } | |
1998 buf->previousmode = tmpmode; | |
1999 | |
2000 /* pseudo-key $B$NF~NO(B */ | |
2001 (void)convchar(buf, ENTERMODE, 0, (char *)NULL, 0); | |
2002 | |
2003 /* $B%b!<%I$,JQ$o$C$?;~$K$O%3%s%F%-%9%H$r%/%j%"$9$k(B */ | |
2004 ccContextClear(buf); | |
2005 | |
2006 /* $B%b!<%IJQ99%3!<%k%P%C%/$,$"$l$P8F$S=P$9(B */ | |
2007 if (buf->modenotify) { | |
2008 (*buf->modenotify)(buf->currentmode, | |
2009 buf->previousmode, | |
2010 buf->client_data); | |
2011 } | |
2012 break; | |
2013 } else if (FUNC_MODIFIER_start <= func && | |
2014 func <= FUNC_MODIFIER_end) { | |
2015 /* $B<!$NF~NO%-!<$r%b%G%#%U%!%$%d$D$-$K$9$k(B */ | |
2016 switch (func) { | |
2017 case FUNC_MODIFIER_SHIFT: buf->modifier |= ShiftMask; break; | |
2018 case FUNC_MODIFIER_CONTROL: buf->modifier |= ControlMask; break; | |
2019 case FUNC_MODIFIER_LOCK: buf->modifier |= LockMask; break; | |
2020 case FUNC_MODIFIER_MOD1: buf->modifier |= Mod1Mask; break; | |
2021 case FUNC_MODIFIER_MOD2: buf->modifier |= Mod2Mask; break; | |
2022 case FUNC_MODIFIER_MOD3: buf->modifier |= Mod3Mask; break; | |
2023 case FUNC_MODIFIER_MOD4: buf->modifier |= Mod4Mask; break; | |
2024 case FUNC_MODIFIER_MOD5: buf->modifier |= Mod5Mask; break; | |
2025 } | |
2026 } else { | |
2027 int truefunc = buf->functbl[func]; | |
2028 /* $B%G%#%9%Q%C%A!&%k!<%A%s$r8F$V(B */ | |
2029 if (truefunc >= 0) { | |
2030 if (!(*buf->executefunction)(truefunc, str, len, | |
2031 buf->client_data)) | |
2032 break; | |
2033 } | |
2034 } | |
2035 } | |
2036 return 0; | |
2037 } | |
2038 | |
2039 static int cconvert(buf, mode, inkey, mask, func, str, len) | |
2040 ccBuf buf; | |
2041 int mode; /* current mode */ | |
2042 ulong inkey; /* input key (raw/mapped) */ | |
2043 int mask; | |
2044 int *func; /* function */ | |
2045 char *str; | |
2046 int len; | |
2047 { | |
2048 ccRule rule = buf->rule; | |
2049 ConvDesc *entry; | |
2050 ulong key; | |
2051 int n; | |
2052 ModeTable *modep; | |
2053 | |
2054 if (mode < 0 || mode >= rule->nmode) | |
2055 return -1; /* No Such Mode */ | |
2056 | |
2057 modep = &rule->modes[mode]; | |
2058 | |
2059 if ((n = modep->nrule) <= 0) | |
2060 return -1; /* No Rules */ | |
2061 | |
2062 for (entry = modep->cdbuf; --n >= 0; entry++) { | |
2063 key = entry->key; | |
2064 if (key & (ulong)METAC) { | |
2065 /* $B%o%$%k%I%+!<%IJ8;z$N%^%C%A%s%0(B */ | |
2066 if (!metamatch(key, inkey, len == 0)) | |
2067 continue; | |
2068 } else if (key & (ulong)RAWKEY && mask != entry->mask) { | |
2069 continue; | |
2070 } else if (key != inkey) { | |
2071 continue; | |
2072 } | |
2073 | |
2074 /* $B%-!<$,%^%C%A$7$?(B */ | |
2075 if (contextMatch(buf, rule->strbuf + entry->context)) { | |
2076 substStr(buf, rule->strbuf + entry->context, | |
2077 rule->strbuf + entry->result, str, len); | |
2078 *func = entry->function; | |
2079 return 0; | |
2080 } | |
2081 } | |
2082 | |
2083 return -1; /* No Match */ | |
2084 } | |
2085 | |
2086 static int metamatch(rkey, inkey, nonascii) | |
2087 ulong rkey; | |
2088 ulong inkey; | |
2089 int nonascii; | |
2090 { | |
2091 int type = (int)(rkey & 0xff); | |
2092 | |
2093 switch (type) { | |
2094 case META_ASCII: | |
2095 return !(inkey & (ulong)(RAWKEY|PSEUDO)); | |
2096 case META_PRINTABLE: | |
2097 return (0x20 <= inkey && inkey < 0x7f); | |
2098 case META_CONTROL: | |
2099 return inkey < 0x20; | |
2100 case META_RAW: | |
2101 return inkey & (ulong)RAWKEY; | |
2102 case META_ANY: | |
2103 return 1; | |
2104 case META_FUNC: | |
2105 return (inkey & (ulong)RAWKEY) && IsFunctionKey(inkey & 0xffff); | |
2106 case META_CURSOR: | |
2107 return (inkey & (ulong)RAWKEY) && IsCursorKey(inkey & 0xffff); | |
2108 case META_KEYPAD: | |
2109 return (inkey & (ulong)RAWKEY) && IsKeypadKey(inkey & 0xffff); | |
2110 case META_MODIFIER: | |
2111 return (inkey & (ulong)RAWKEY) && IsModifierKey(inkey & 0xffff); | |
2112 case META_NONASCII: | |
2113 return (inkey & (ulong)RAWKEY) && nonascii; | |
2114 default: | |
2115 return 0; | |
2116 } | |
2117 /* NOTREACHED */ | |
2118 } | |
2119 | |
2120 static int contextMatch(buf, context) | |
2121 ccBuf buf; | |
2122 wchar *context; | |
2123 { | |
2124 wchar *c0 = buf->contextend; | |
2125 wchar *c1 = buf->context; | |
2126 int cs = buf->rule->casesensitive; | |
2127 | |
2128 if (context == 0 || *context == 0) | |
2129 return 1; /* $BL5>r7o%^%C%A(B */ | |
2130 if (c0 - c1 < wstrlen(context)) /* $BD9$5$N%A%'%C%/(B */ | |
2131 return 0; /* matching fail */ | |
2132 c0--; | |
2133 while (*context) { | |
2134 if ((!cs && CANONIC(*c0) == CANONIC(*context)) || | |
2135 (cs && *c0 == *context)) | |
2136 c0--, context++; | |
2137 else | |
2138 return 0; /* fail */ | |
2139 } | |
2140 return 1; | |
2141 } | |
2142 | |
2143 static void substStr(buf, context, result, str, len) | |
2144 ccBuf buf; | |
2145 wchar *context; | |
2146 wchar *result; | |
2147 char *str; | |
2148 int len; | |
2149 { | |
2150 register int c; | |
2151 int nbytes; | |
2152 uchar *bufp; | |
2153 | |
2154 /* $B%3%s%F%-%9%H$NJ,$r>C$9(B */ | |
2155 while (*context++) { | |
2156 ccContextDelete(buf); | |
2157 (*buf->deletechar)(buf->client_data); | |
2158 } | |
2159 | |
2160 while (c = *result++) { | |
2161 if (c == MATCHED_CHAR) { | |
2162 nbytes = len; | |
2163 bufp = (uchar *)str; | |
2164 while (nbytes-- > 0) { | |
2165 c = *bufp++; | |
2166 /* bufp $B$NCf?H$O(B ASCII $B$+(B $B%+%J$J$N$G(B | |
2167 * EUC $B%W%m%;%9%3!<%I$X$NJQ49$r$o$6$o$6(B | |
2168 * $B$d$kI,MW$O$J$$(B | |
2169 */ | |
2170 ccContextAppend(buf, c); | |
2171 (*buf->insertchar)(c, buf->client_data); | |
2172 } | |
2173 continue; | |
2174 } else if (c == CCLEAR_CHAR) { | |
2175 /* $B%3%s%F%-%9%H$r%/%j%"$9$k(B */ | |
2176 ccContextClear(buf); | |
2177 continue; | |
2178 } | |
2179 ccContextAppend(buf, c); | |
2180 (*buf->insertchar)(c, buf->client_data); | |
2181 } | |
2182 } | |
2183 | |
2184 /* getModeSwitchMask -- mode-switch $B$N%b%G%#%U%!%$%"%^%9%/$rD4$Y$k(B */ | |
2185 int getModeSwitchMask(dpy) | |
2186 Display *dpy; | |
2187 { | |
2188 KeyCode modeswkey; | |
2189 struct modesw { | |
2190 Display *dpy; | |
2191 int mode_switch; | |
2192 struct modesw *next; | |
2193 } *msp; | |
2194 static struct modesw *modeswlist; | |
2195 | |
2196 for (msp = modeswlist; msp != NULL; msp = msp->next) { | |
2197 if (dpy == msp->dpy) return msp->mode_switch; | |
2198 } | |
2199 msp = (struct modesw *)Malloc(sizeof(struct modesw)); | |
2200 msp->dpy = dpy; | |
2201 msp->next = modeswlist; | |
2202 modeswlist = msp; | |
2203 | |
2204 msp->mode_switch = 0; | |
2205 | |
2206 if ((modeswkey = XKeysymToKeycode(dpy, XK_Mode_switch)) != 0) { | |
2207 XModifierKeymap *map = XGetModifierMapping(dpy); | |
2208 int keypermod = map->max_keypermod; | |
2209 int modbit; | |
2210 int i; | |
2211 | |
2212 for (modbit = 3; modbit < 8; modbit++) { | |
2213 for (i = 0; i < keypermod; i++) { | |
2214 if (map->modifiermap[keypermod * modbit + i] == modeswkey) { | |
2215 msp->mode_switch = 1 << modbit; | |
2216 goto found; | |
2217 } | |
2218 } | |
2219 } | |
2220 found: | |
2221 XFreeModifiermap(map); | |
2222 } | |
2223 | |
2224 return msp->mode_switch; | |
2225 } | |
2226 | |
2227 /* | |
2228 * Public Functions | |
2229 */ | |
2230 | |
2231 /* ccParseRule -- $BJQ49Dj5A%U%!%$%k$rFI$_9~$`(B */ | |
2232 ccRule ccParseRule(deffile, errprint) | |
2233 char *deffile; /* $BF~NOJ8;zJQ49Dj5A%U%!%$%k(B */ | |
2234 void (*errprint)(); /* $B%(%i!<%a%C%;!<%8I=<(MQ%3!<%k%P%C%/(B */ | |
2235 { | |
2236 ccRule rule; | |
2237 extern char *getenv(); | |
2238 | |
2239 /* $BJQ49Dj5A%U%!%$%k$NFI$_9~$_(B */ | |
2240 if (deffile == NULL) { | |
2241 /* $B4D6-JQ?t(B CC_DEF $B$rD4$Y$k(B */ | |
2242 if ((deffile = getenv("CC_DEF")) == NULL) { | |
2243 return (ccRule)NULL; | |
2244 } | |
2245 } | |
2246 | |
2247 if (rule = findRule(deffile)) { | |
2248 /* same rule found */ | |
2249 rule->refcnt++; | |
2250 return rule; | |
2251 } | |
2252 | |
2253 /* ccRuleRec $B$N%"%m%1!<%H(B */ | |
2254 if ((rule = (ccRule)Malloc(sizeof(ccRuleRec))) == NULL) { | |
2255 return (ccRule)NULL; | |
2256 } | |
2257 | |
2258 rule->errorfunc = errprint; | |
2259 rule->rulefile = Malloc(Strlen(deffile) + 1); | |
2260 if (rule->rulefile) { | |
2261 (void)Strcpy(rule->rulefile, deffile); | |
2262 } | |
2263 rule->casesensitive = False; | |
2264 rule->autofix = False; | |
2265 | |
2266 if (readRuleFile(rule, deffile) < 0) { | |
2267 Free(rule); | |
2268 return (ccRule)NULL; | |
2269 } | |
2270 | |
2271 addRule(rule); | |
2272 | |
2273 return rule; | |
2274 } | |
2275 | |
2276 /* ccCreateBuf -- $BJQ49%P%C%U%!$r:n$k(B */ | |
2277 ccBuf ccCreateBuf(rule, csize, functable, nfunc, | |
2278 def_action, insert, delete, execute, autofix, modenotify, | |
2279 data) | |
2280 ccRule rule; /* $B;HMQ$9$kF~NOJ8;zJQ49%k!<%k(B */ | |
2281 int csize; /* context size ($BJ8;z?t(B) */ | |
2282 char *functable[]; /* $B%U%!%s%/%7%g%s!&%F!<%V%k(B */ | |
2283 int nfunc; /* functable $B$N%(%s%H%j?t(B */ | |
2284 void (*def_action)(); /* $B%G%U%)%k%H!&%"%/%7%g%s!&%3!<%k%P%C%/(B */ | |
2285 void (*insert)(); /* $BJ8;zF~NO%3!<%k%P%C%/(B */ | |
2286 void (*delete)(); /* $BJ8;z:o=|%3!<%k%P%C%/(B */ | |
2287 int (*execute)(); /* $B%U%!%s%/%7%g%s<B9T%3!<%k%P%C%/(B */ | |
2288 void (*autofix)(); /* $B<+F03NDj%3!<%k%P%C%/(B */ | |
2289 void (*modenotify)(); /* $B%b!<%IJQ99DLCN%3!<%k%P%C%/(B */ | |
2290 caddr_t data; /* callback $B%G!<%?(B */ | |
2291 { | |
2292 ccBuf buf; | |
2293 char *funcnamep; | |
2294 short *functblp; | |
2295 int i, j; | |
2296 | |
2297 /* ccBuf $B$N%"%m%1!<%H(B */ | |
2298 if ((buf = (ccBuf)Malloc(sizeof(ccBufRec))) == NULL) { | |
2299 return (ccBuf)NULL; | |
2300 } | |
2301 | |
2302 buf->rule = rule; | |
2303 | |
2304 /* context $B%P%C%U%!$N%"%m%1!<%H(B */ | |
2305 if (csize <= 0) csize = 1; | |
2306 buf->context = (wchar *)Malloc(csize * sizeof(wchar)); | |
2307 if (buf->context == NULL) { | |
2308 Free(buf); | |
2309 return (ccBuf)NULL; | |
2310 } | |
2311 buf->contextend = buf->context; | |
2312 buf->contextsize = csize; | |
2313 | |
2314 /* function $B%3%s%P!<%H%F!<%V%k$N%"%m%1!<%H(B */ | |
2315 buf->functbl = (short *)Malloc(rule->nfunc * sizeof(short)); | |
2316 if (buf->functbl == NULL) { | |
2317 Free(buf->context); | |
2318 Free(buf); | |
2319 return (ccBuf)NULL; | |
2320 } | |
2321 /* ccRule $B$KF~$C$F$$$k%U%!%s%/%7%g%sI=$H!"0z?t$GM?$($i$l$?(B | |
2322 * $B%U%!%s%/%7%g%sI=$+$i!"(BccRule $BFbIt$N%U%!%s%/%7%g%sHV9f$H(B | |
2323 * $B:#M?$($i$l$?%U%!%s%/%7%g%sHV9f$H$NBP1~I=$r:n$k(B | |
2324 */ | |
2325 funcnamep = rule->funcnamebuf; | |
2326 functblp = buf->functbl; | |
2327 for (i = rule->nfunc, functblp = buf->functbl; i > 0; i--, functblp++) { | |
2328 for (j = 0; j < nfunc; j++) { | |
2329 if (!strcmp(functable[j], funcnamep)) { | |
2330 *functblp = j; | |
2331 break; | |
2332 } | |
2333 } | |
2334 if (j >= nfunc) *functblp = -1; | |
2335 | |
2336 while (*funcnamep++) | |
2337 ; | |
2338 } | |
2339 | |
2340 buf->defaultaction = def_action; | |
2341 buf->insertchar = insert; | |
2342 buf->deletechar = delete; | |
2343 buf->executefunction = execute; | |
2344 buf->modenotify = modenotify; | |
2345 buf->autofix = autofix; | |
2346 buf->client_data = data; | |
2347 | |
2348 /* $B%+%l%s%H%b!<%I$N@_Dj(B */ | |
2349 buf->previousmode = buf->currentmode = rule->initialmode; | |
2350 | |
2351 buf->modifier = 0; | |
2352 | |
2353 return buf; | |
2354 } | |
2355 | |
2356 /* ccFreeRule -- $B%k!<%k$r<N$F$k(B */ | |
2357 void ccFreeRule(rule) | |
2358 ccRule rule; | |
2359 { | |
2360 ModeTable *modep; | |
2361 int i; | |
2362 | |
2363 if (rule == NULL) return; | |
2364 if (--rule->refcnt > 0) return; | |
2365 | |
2366 deleteRule(rule); | |
2367 | |
2368 for (modep = rule->modes, i = 0; i < rule->nmode; modep++, i++) { | |
2369 Free(modep->name); | |
2370 Free(modep->cdbuf); | |
2371 Free(modep->prompt); | |
2372 } | |
2373 Free(rule->rulefile); | |
2374 Free(rule->modes); | |
2375 Free(rule->strbuf); | |
2376 Free(rule->funcbuf); | |
2377 Free(rule->funcnamebuf); | |
2378 Free(rule); | |
2379 } | |
2380 | |
2381 /* ccDestroyBuf -- $BJQ49%P%C%U%!$r<N$F$k(B */ | |
2382 void ccDestroyBuf(buf) | |
2383 ccBuf buf; | |
2384 { | |
2385 if (buf == NULL) return; | |
2386 Free(buf->context); | |
2387 Free(buf->functbl); | |
2388 Free(buf); | |
2389 } | |
2390 | |
2391 /* ccConvchar -- $BJQ49MQ%U%!%s%/%7%g%s(B */ | |
2392 int ccConvchar(buf, event) | |
2393 ccBuf buf; | |
2394 XKeyPressedEvent *event; /* $B%-!<%$%Y%s%H(B */ | |
2395 { | |
2396 int r; | |
2397 char str[256]; | |
2398 char *p; | |
2399 int nbytes; | |
2400 int n; | |
2401 KeySym ks1, ks2; | |
2402 int mask; | |
2403 | |
2404 /* $B$H$j$"$($:(B LookupString $B$7$F$*$/(B */ | |
2405 nbytes = XLookupString(event, str, sizeof(str), &ks2, 0); | |
2406 | |
2407 /* $BF~NO%-!<$r%b%G%#%U%!%$%d$D$-$K$9$k(B */ | |
2408 if (buf->modifier) { | |
2409 if (!IsModifierKey(ks2)) { | |
2410 event->state |= buf->modifier; | |
2411 buf->modifier = 0; | |
2412 nbytes = XLookupString(event, str, sizeof(str), &ks2, 0); | |
2413 } | |
2414 } | |
2415 | |
2416 /* $B$^$:$O%$%Y%s%H%3!<%I$GJQ49$7$F$_$k(B */ | |
2417 r = -1; | |
2418 mask = ccEncodeMask(event); | |
2419 | |
2420 /* $B$^$:$O%b%G%#%U%!%$%"$r0l:]9MN8$7$J$$(B KeySym $B$r(B | |
2421 * $B%3!<%I$H$7$FJQ49$7$F$_$k(B | |
2422 */ | |
2423 ks1 = (ulong)XLookupKeysym(event, 0); | |
2424 if (ks1 != NoSymbol) { | |
2425 r = convchar(buf, (ulong)ks1 | (ulong)RAWKEY, | |
2426 mask, str, nbytes); | |
2427 } | |
2428 | |
2429 /* $B>e$,%^%C%A$7$J$1$l$P!"(BShift, Lock, ModeSwitch $B$r(B | |
2430 * $B9MN8$7$?(B KeySym ($B$D$^$j(B XLookupString() $B$,JV$9(B KeySym) $B$,(B | |
2431 * NoSymbol $B$G$J$1$l$P$=$N%3!<%I$GJQ49$7$F$_$k(B | |
2432 */ | |
2433 if (r < 0 && ks2 != NoSymbol) { | |
2434 int msw = getModeSwitchMask(event->display); | |
2435 | |
2436 if (mask & (ShiftMask | LockMask | msw)) { | |
2437 mask &= ~(ShiftMask | LockMask | msw); | |
2438 r = convchar(buf, (ulong)ks2 | (ulong)RAWKEY, | |
2439 mask, str, nbytes); | |
2440 } | |
2441 } | |
2442 | |
2443 if (r < 0) { | |
2444 int match = 0; | |
2445 | |
2446 if (nbytes == 0) return 0; | |
2447 | |
2448 /* ASCII $BI=5-$GJQ49$7$F$_$k(B */ | |
2449 p = str; | |
2450 n = nbytes; | |
2451 while (n-- > 0) { | |
2452 r = convchar(buf, ccEncodeChar(*p), 0, p, 1); | |
2453 if (r >= 0) match = 1; | |
2454 p++; | |
2455 } | |
2456 if (!match) { | |
2457 /* default action $B$N%U%!%s%/%7%g%s$r$h$V(B */ | |
2458 if (buf->defaultaction != NULL) { | |
2459 (void)(*buf->defaultaction)(str, nbytes, buf->client_data); | |
2460 } | |
2461 return 0; | |
2462 } | |
2463 } | |
2464 return 1; | |
2465 } | |
2466 | |
2467 /* ccGetMode -- $B8=:_$N%b!<%IHV9f$rJV$9(B */ | |
2468 int ccGetMode(buf) | |
2469 ccBuf buf; | |
2470 { | |
2471 return buf->currentmode; | |
2472 } | |
2473 | |
2474 /* ccGetModePrompt -- $B8=:_$N%b!<%I$N%W%m%s%W%HJ8;zNs$rJV$9(B */ | |
2475 wchar *ccGetModePrompt(buf) | |
2476 ccBuf buf; | |
2477 { | |
2478 return buf->rule->modes[buf->currentmode].prompt; | |
2479 } | |
2480 | |
2481 /* ccGetRule -- $BJQ49%P%C%U%!$G;H$o$l$F$$$kJQ49%k!<%k$rJV$9(B */ | |
2482 ccRule ccGetRule(buf) | |
2483 ccBuf buf; | |
2484 { | |
2485 return buf->rule; | |
2486 } | |
2487 | |
2488 /* ccContextAppend -- $B%3%s%F%-%9%H$K(B1$BJ8;z2C$($k(B */ | |
2489 void ccContextAppend(buf, c) | |
2490 ccBuf buf; | |
2491 int c; | |
2492 { | |
2493 wchar *p; | |
2494 | |
2495 /* $B<+F03NDj(B */ | |
2496 if (buf->context == buf->contextend && | |
2497 buf->rule->autofix && buf->autofix) { | |
2498 buf->autofix(buf->client_data); | |
2499 } | |
2500 | |
2501 /* $B%3%s%F%-%9%HJ8;zNs$KA^F~(B */ | |
2502 if (buf->contextend - buf->context < buf->contextsize) { | |
2503 *buf->contextend++ = c; | |
2504 } else { | |
2505 /* $B%3%s%F%-%9%HJ8;zNs$,0lGU$J$N$G(B | |
2506 * $B@hF,$N#1J8;z$r<N$F$F$D$a$k(B | |
2507 */ | |
2508 p = buf->context + 1; | |
2509 while (p < buf->contextend) { | |
2510 *(p - 1) = *p; | |
2511 p++; | |
2512 } | |
2513 /* $B$"$$$?=j$KA^F~(B */ | |
2514 *--p = c; | |
2515 } | |
2516 } | |
2517 | |
2518 /* ccContextDelete -- $B%3%s%F%-%9%H$r(B1$BJ8;z:o=|$9$k(B */ | |
2519 void ccContextDelete(buf) | |
2520 ccBuf buf; | |
2521 { | |
2522 if (buf->contextend > buf->context) | |
2523 buf->contextend--; | |
2524 } | |
2525 | |
2526 /* ccContextClear -- $B%3%s%F%-%9%H$r%/%j%"$9$k(B */ | |
2527 void ccContextClear(buf) | |
2528 ccBuf buf; | |
2529 { | |
2530 /* $B%b!<%I$,JQ$o$C$?;~$K$O<+F0E*$K%/%j%"$5$l$k$,$=$l0J30$K(B | |
2531 * $B8=:_$N%3%s%F%-%9%H$r6/@)E*$K%/%j%"$7$?$$>l9g$KMQ$$$k(B | |
2532 */ | |
2533 buf->contextend = buf->context; | |
2534 } | |
2535 | |
2536 /* ccContextSet -- $B%3%s%F%-%9%H$r%;%C%H$9$k(B */ | |
2537 void ccContextSet(buf, cstr) | |
2538 ccBuf buf; | |
2539 wchar *cstr; | |
2540 { | |
2541 int len = wstrlen(cstr); | |
2542 wchar *p = buf->context; | |
2543 | |
2544 if (len > buf->contextsize) { | |
2545 cstr += len - buf->contextsize; | |
2546 len = buf->contextsize; | |
2547 } | |
2548 while (len-- > 0) { | |
2549 *p++ = *cstr++; | |
2550 } | |
2551 } | |
2552 | |
2553 /* ccContextGet -- $B8=:_$N%3%s%F%-%9%H$rJV$9(B */ | |
2554 void ccContextGet(buf, cstr) | |
2555 ccBuf buf; | |
2556 wchar *cstr; | |
2557 { | |
2558 register wchar *wp = buf->context; | |
2559 | |
2560 while (wp < buf->contextend) | |
2561 *cstr++ = *wp++; | |
2562 *cstr = 0; | |
2563 } | |
2564 | |
2565 | |
2566 /* | |
2567 * Obsolete Functions | |
2568 */ | |
2569 | |
2570 /* ccInit -- $BJQ49%k!<%k$rFI$_9~$s$G%P%C%U%!$r:n$k(B */ | |
2571 ccBuf ccInit(deffile, contextsize, defactfunc, insertfunc, deletefunc, dofunc, | |
2572 errprint, functable, functablesize) | |
2573 char *deffile; | |
2574 int contextsize; | |
2575 void (*defactfunc)(); | |
2576 void (*insertfunc)(); | |
2577 void (*deletefunc)(); | |
2578 int (*dofunc)(); | |
2579 void (*errprint)(); | |
2580 char *functable[]; | |
2581 int functablesize; | |
2582 { | |
2583 ccRule rule; | |
2584 | |
2585 if ((rule = ccParseRule(deffile, errprint)) == NULL) { | |
2586 return (ccBuf)NULL; | |
2587 } | |
2588 | |
2589 return ccCreateBuf(rule, contextsize, functable, functablesize, | |
2590 defactfunc, insertfunc, deletefunc, dofunc, | |
2591 (void (*)())NULL, (void (*)())NULL, (caddr_t)NULL); | |
2592 } | |
2593 | |
2594 /* ccTerminate -- $BF~NOJ8;zJQ49$r=*N;$9$k(B */ | |
2595 void ccTerminate(buf) | |
2596 ccBuf buf; | |
2597 { | |
2598 ccFreeRule(buf->rule); | |
2599 ccDestroyBuf(buf); | |
2600 } | |
2601 | |
2602 | |
2603 #ifdef DEBUG_CCONV | |
2604 /* | |
2605 * Debug Functions | |
2606 */ | |
2607 | |
2608 static void putws(s) | |
2609 wchar *s; | |
2610 { | |
2611 unsigned char line[256]; | |
2612 | |
2613 (void)convJWStoSJIS(s, line); | |
2614 fputs(line, stdout); | |
2615 } | |
2616 | |
2617 static void puteuc(s) | |
2618 uchar *s; | |
2619 { | |
2620 wchar tmp[256]; | |
2621 | |
2622 (void)convEUCtoJWS(s, tmp); | |
2623 putws(tmp); | |
2624 } | |
2625 | |
2626 void dumpRules(rule, mode) | |
2627 ccRule rule; | |
2628 int mode; | |
2629 { | |
2630 int nkey; | |
2631 ModeTable *modep; | |
2632 ConvDesc *cdp; | |
2633 wchar *strbuf = rule->strbuf; | |
2634 ushort *funcbuf = rule->funcbuf; | |
2635 char **funcnames; | |
2636 wchar *p, *q; | |
2637 wchar restmp[256]; | |
2638 ushort *funcp; | |
2639 int i, j; | |
2640 | |
2641 funcnames = (char **)__builtin_alloca(rule->nfunc * sizeof(char *)); | |
2642 { char *cp, **fnp; | |
2643 cp = rule->funcnamebuf; | |
2644 fnp = funcnames; | |
2645 for (i = 0; i < rule->nfunc; i++) { | |
2646 *fnp++ = cp; | |
2647 while (*cp++) | |
2648 ; | |
2649 } | |
2650 } | |
2651 | |
2652 if (mode < 0 || mode >= rule->nmode) { | |
2653 printf("No such mode %d\n", mode); | |
2654 return; | |
2655 } | |
2656 modep = &rule->modes[mode]; | |
2657 | |
2658 printf("mode: %s (%d) prompt: ", modep->name, mode); | |
2659 putws(modep->prompt); | |
2660 if (modep->fallthrough != NOMODE) { | |
2661 printf(" fallthrough: %d", modep->fallthrough); | |
2662 } | |
2663 putchar('\n'); | |
2664 cdp = modep->cdbuf; | |
2665 for (i = 0; i < modep->nrule; i++) { | |
2666 printf("rule[%d]: \"", i); | |
2667 putws(strbuf + cdp->context); | |
2668 printf("\"\t"); | |
2669 if (cdp->key & RAWKEY) { | |
2670 ulong key = cdp->key & ~RAWKEY; | |
2671 int mask = cdp->mask; | |
2672 char *keysymname; | |
2673 if (mask & ShiftMask) printf("shift-"); | |
2674 if (mask & ControlMask) printf("control-"); | |
2675 if (mask & LockMask) printf("lock-"); | |
2676 if (mask & Mod1Mask) printf("mod1-"); | |
2677 if (mask & Mod2Mask) printf("mod2-"); | |
2678 if (mask & Mod3Mask) printf("mod3-"); | |
2679 if (mask & Mod4Mask) printf("mod4-"); | |
2680 if (mask & Mod5Mask) printf("mod5-"); | |
2681 keysymname = XKeysymToString((KeySym)key); | |
2682 printf(keysymname ? keysymname : "<illegal keysym>"); | |
2683 } else if (cdp->key & METAC) { | |
2684 switch (cdp->key & ~METAC) { | |
2685 case META_ASCII: printf("@ascii"); break; | |
2686 case META_CONTROL: printf("@control"); break; | |
2687 case META_RAW: printf("@raw"); break; | |
2688 case META_ANY: printf("@any"); break; | |
2689 case META_FUNC: printf("@func"); break; | |
2690 case META_CURSOR: printf("@cursor"); break; | |
2691 case META_KEYPAD: printf("@keypad"); break; | |
2692 case META_MODIFIER: printf("@modifier"); break; | |
2693 case META_NONASCII: printf("@non-ascii"); break; | |
2694 case META_PRINTABLE: printf("@printable"); break; | |
2695 default: printf("<illegal meta>"); | |
2696 } | |
2697 } else if (cdp->key & PSEUDO) { | |
2698 switch (cdp->key) { | |
2699 case ENTERMODE: printf("ENTERMODE"); break; | |
2700 case EXITMODE: printf("EXITMODE"); break; | |
2701 default: printf("<illegal pseudo>"); | |
2702 } | |
2703 } else { | |
2704 putchar('\''); | |
2705 if (cdp->key >= 0x80) { | |
2706 printf("\\x%x", cdp->key); | |
2707 } else if (cdp->key < 0x20) { | |
2708 putchar('^'); | |
2709 putchar(cdp->key + '@'); | |
2710 } else if (cdp->key == 0x7f) { | |
2711 printf("^?"); | |
2712 } else { | |
2713 putchar(cdp->key); | |
2714 } | |
2715 putchar('\''); | |
2716 } | |
2717 printf("\t\""); | |
2718 p = restmp; | |
2719 q = strbuf + cdp->result; | |
2720 while (*q) { | |
2721 if (*q == MATCHED_CHAR) { | |
2722 *p++ = '&'; | |
2723 } else if (*q == CCLEAR_CHAR) { | |
2724 *p++ = '/'; | |
2725 } else { | |
2726 *p++ = *q; | |
2727 } | |
2728 q++; | |
2729 } | |
2730 *p = 0; | |
2731 putws(restmp); | |
2732 printf("\"\t"); | |
2733 funcp = funcbuf + cdp->function; | |
2734 while (*funcp != ENDFUNC) { | |
2735 if (*funcp == REDO) { | |
2736 printf("redo "); | |
2737 } else if (*funcp == PREVMODE) { | |
2738 printf("goto prev "); | |
2739 } else if (*funcp & MODECHANGE) { | |
2740 int gotomode = *funcp & ~MODECHANGE; | |
2741 if (gotomode < 0 || gotomode >= rule->nmode) { | |
2742 printf("<illegal goto>"); | |
2743 } else { | |
2744 printf("goto %s ", | |
2745 rule->modes[gotomode].name); | |
2746 } | |
2747 } else { | |
2748 if (*funcp >= rule->nfunc) { | |
2749 printf("<illegal function> "); | |
2750 } else { | |
2751 printf("%s ", funcnames[*funcp]); | |
2752 } | |
2753 } | |
2754 funcp++; | |
2755 } | |
2756 putchar('\n'); | |
2757 cdp++; | |
2758 } | |
2759 putchar('\n'); | |
2760 } | |
2761 | |
2762 void dumpAllRules(rule) | |
2763 ccRule rule; | |
2764 { | |
2765 int i; | |
2766 | |
2767 printf("** RULE DUMP **\n"); | |
2768 printf("number of modes: %d initialmode: %s (%d)\n\n", | |
2769 rule->nmode, | |
2770 rule->modes[rule->initialmode].name, | |
2771 rule->initialmode); | |
2772 for (i = 0; i < rule->nmode; i++) { | |
2773 dumpRules(rule, i); | |
2774 } | |
2775 fflush(stdout); | |
2776 } | |
2777 #endif |