• R/O
  • SSH
  • HTTPS

l2r: コミット


コミットメタ情報

リビジョン9 (tree)
日時2007-04-19 16:25:31
作者notanpe

ログメッセージ

コーディングスタイルの変更なそ。

変更サマリ

差分

--- mty.c (revision 8)
+++ mty.c (revision 9)
@@ -1,13 +1,3 @@
1-/***********************************************************************
2- *
3- * file: mty.c
4- *
5- * まあ、待て屋。
6- *
7- * $Id: mty.c 121 2007-04-15 06:23:51Z chapuni $
8- *
9- */
10-
111 #include <assert.h>
122 #include <ctype.h>
133 #include <errno.h>
@@ -35,17 +25,9 @@
3525 #include "cp932.h"
3626 #include "crypt64.h"
3727 #include "desconst.h"
38-#include "expr_parse.h"
39-#include "scoreboard.h"
40-#include "synth.h"
4128 #include "tr64.h"
4229 #include "translate.h"
43-#include "wdict.h"
4430
45-#if USE_DT
46-#include "dt4.h"
47-#endif
48-
4931 #include "l2.h"
5032
5133 /* 鍵文字列 */
@@ -66,247 +48,79 @@
6648 #define KCLS_DT1 128
6749 #define KCLS_K2 256
6850
69-#if USE_DT
70-/* 鍵キメ用辞書インデクス */
71-struct DT *kd[8 + 8];
72-
73-/* 辞書インデクス */
74-struct DT *dtidx[0x100 + 1];
75-#endif
76-
7751 /* 指定されたクラスと入っているキーから、classify を行う */
7852 void
79-key_make_map(int n)
53+key_make_map( n )
54+int n;
8055 {
81- int i, j;
82- unsigned c = kcls[n].map[key[n]];
56+ int i, j;
57+ unsigned int c = kcls[n].map[key[n]];
8358
84-#if USE_DT
85- if (3 <= n && n < 7 && kd[n - 3])
86- {
87- /* 辞書のケツの文字。後ろにナニヤラキャラクタが来る */
88- c = kd[n - 3]->c[0];
89- if ((0x81 <= c && c <= 0x9F)
90- || (0xE0 <= c && c <= 0xFC))
91- c = KCLS_K2;
92- else
93- c = (cp932[256 * key[n]]
94- | cp932[256 * (key[n] ^ 0x80)]);
95-#if DEBUG>=1
96- printf("*n=%d, key=%02X, cls=%04X\n",
97- n,
98- key[n],
99- c);
100-#endif
101- }
102- else if (2 <= n && n < 6 && kd[n - 2])
103- {
104- return;
105- }
106- else if (1 <= n && n < 5 && kd[n - 1])
107- {
108- return;
109- }
110- else if (1 <= n && n < 5 && !kd[n - 1]
111- //&& (c & KCLS_K2)
112- && (c & KCLS_DT1))
113- {
114- /* 漢字2文字を拾っていきまつ */
115-#if DEBUG>=1
116- printf("(%d)%02X %02X(%02X:%02X:%02X:%02X)\n",
117- n, key[n - 1], key[n],
118- cp932[(256 * key[n - 1] + key[n])],
119- cp932[(256 * key[n - 1] + key[n]) ^ 0x0080],
120- cp932[(256 * key[n - 1] + key[n]) ^ 0x8000],
121- cp932[(256 * key[n - 1] + key[n]) ^ 0x8080]);
122-#endif
123- if (n != 1 && n != 2
124- && (cp932[(256 * key[n - 1] + key[n]) ^ 0x0080] & KCLS_DT1))
125- key[n] ^= 0x80;
126- else if (n != 2 && n != 3
127- && (cp932[(256 * key[n - 1] + key[n]) ^ 0x8000] & KCLS_DT1))
128- key[n - 1] ^= 0x80;
129- else if (n > 3 && (cp932[(256 * key[n - 1] + key[n]) ^ 0x8080] & KCLS_DT1))
130- key[n - 1] ^= 0x80, key[n] ^= 0x80;
131- if (cp932[256 * key[n - 1] + key[n]] & KCLS_DT1)
132- {
133- for (kd[n - 1] = dtidx[key[n - 1]];
134- kd[n - 1]->c[1] != key[n];
135- kd[n - 1]++)
136- assert(kd[n - 1]->c[0] == key[n - 1]);
137-#if DEBUG>=1
138- printf("(%02X%02X:%02X%02X)%c%c%c%c\n",
139- kd[n - 1]->c[0],
140- kd[n - 1]->c[1],
141- kd[n - 1]->c[2],
142- kd[n - 1]->c[3],
143- kd[n - 1]->c[0],
144- kd[n - 1]->c[1],
145- kd[n - 1]->c[2],
146- kd[n - 1]->c[3]);
147-#endif
148- return;
149- }
150- }
151- else if (n < 4 && (c & KCLS_DT0) && kd[n] == NULL)
152- {
153- /* カタカナ埋め込みいきます */
154- assert(kd[n] == NULL);
155-#if DEBUG>=1
156- printf("n=%d, key=%02X\n", n, key[n]);
157-#endif
158- kd[n] = dtidx[key[n]];
159- if (!kd[n]
160- && !(n == 1 || n == 2)
161- && dtidx[key[n] ^ 0x80])
162- {
163- key[n] ^= 0x80;
164- kd[n] = dtidx[key[n]];
165- }
166- if (kd[n])
167- return;
168- }
169- else
170- {
171- kd[n] = NULL;
172- }
173-#endif
174-
17559 /* 最後の部分は class map を生成する必要ナシ */
176- if (n >= 6)
177- return;
60+ if ( n >= 6 ) {
61+ return;
62+ }
17863
179- for (i = 0; i < 256; i++)
180- {
181- unsigned bm = 0;
182-#if 1
183- if (c & KCLS_K1)
184- {
185- if (cp932[256 * key[n] + i] & KCLS_K1)
186- bm |= KCLS_K2 | (cp932[256 * key[n] + i] & KCLS_DT1);
187- if (cp932[256 * (key[n] ^ 0x80) + i] & KCLS_K1)
188- bm |= KCLS_K2 | (cp932[256 * (key[n] ^ 0x80) + i] & KCLS_DT1);
189-#if 0
190- bm |= ((cp932[256 * key[n] + i] & KCLS_K1)
191- || (cp932[256 * (key[n] ^ 0x80) + i] & KCLS_K1)
192- ? KCLS_K2 : 0);
193-#endif
194- }
195- if (c & (KCLS_AN | KCLS_KA | KCLS_K2))
196- for (j = 0; j < 256; j++)
197- {
198- bm |= cp932[256 * i + j] & (KCLS_AN | KCLS_KA | KCLS_K1
199- | KCLS_DT0);
200-#if 0
201- if (j >= 127 && !(n == 0 || n == 1))
202- break;
203-#endif
204- }
205- kcls[n + 1].map[i] = bm;
206-#endif
207- if (i >= 128 && !(n == 0 || n == 1))
208- kcls[n + 1].map[i - 128] |= kcls[n + 1].map[i];
209- }
64+ for ( i = 0; i < 256; i++ ) {
65+ unsigned bm = 0;
66+ if ( c & KCLS_K1 ) {
67+ if ( cp932[256 * key[n] + i] & KCLS_K1 ) {
68+ bm |= KCLS_K2 | (cp932[256 * key[n] + i] & KCLS_DT1);
69+ }
70+ if ( cp932[256 * (key[n] ^ 0x80) + i] & KCLS_K1 ) {
71+ bm |= KCLS_K2 | (cp932[256 * (key[n] ^ 0x80) + i] & KCLS_DT1);
72+ }
73+ }
74+ if ( c & (KCLS_AN | KCLS_KA | KCLS_K2) ) {
75+ for ( j = 0; j < 256; j++ ) {
76+ bm |= cp932[256 * i + j] & (KCLS_AN | KCLS_KA | KCLS_K1 | KCLS_DT0);
77+ }
78+ }
79+ kcls[n + 1].map[i] = bm;
80+ if ( i >= 128 && !(n == 0 || n == 1) ) {
81+ kcls[n + 1].map[i - 128] |= kcls[n + 1].map[i];
82+ }
83+ }
21084
211- if (n < 6)
212- kcls[n + 1].map[0x00] = kcls[n + 1].map[0x80] = 0;
213- if (n == 6)
214- kcls[7].map[0x00] |= KCLS_AN;
85+ if ( n < 6 ) {
86+ kcls[n + 1].map[0x00] = kcls[n + 1].map[0x80] = 0;
87+ }
88+ if ( n == 6 ) {
89+ kcls[7].map[0x00] |= KCLS_AN;
90+ }
21591 }
21692
217-#if USE_DT
218-unsigned
219-dt_get(int kdn,
220- int xn,
221- int n,
222- int ch)
223-{
224- int i;
225-#if DEBUG>=1
226- printf("*dt_get(%d)%c%c%c%c(%02X%02X:%02X%02X)->ch=%d",
227- n,
228- kd[kdn]->c[0], kd[kdn]->c[1], kd[kdn]->c[2], kd[kdn]->c[3],
229- kd[kdn]->c[0], kd[kdn]->c[1], kd[kdn]->c[2], kd[kdn]->c[3],
230- ch);
231-#endif
232- /* まずは数える */
233- for (i = 0;
234- kd[kdn][i].c[xn] == kd[kdn]->c[xn];
235- i++)
236- ;
237- assert(i > 0);
238- kd[kdn] += ch % i;
239-#if DEBUG>=1
240- printf("/%d\n dt_get: %c%c%c%c(%02X%02X:%02X%02X)->ch=%d\n",
241- i,
242- kd[kdn]->c[0], kd[kdn]->c[1], kd[kdn]->c[2], kd[kdn]->c[3],
243- kd[kdn]->c[0], kd[kdn]->c[1], kd[kdn]->c[2], kd[kdn]->c[3],
244- ch);
245-#endif
246- return kd[kdn]->c[n];
247-}
248-#endif
249-
25093 /* マップから文字を拾ってセット */
251-unsigned
252-key_set(int n, unsigned ch)
94+unsigned int
95+key_set( n, ch )
96+int n;
97+unsigned int ch;
25398 {
254- int cnt = 0, i;
99+ int cnt = 0, i;
255100
256-#if USE_DT
257- if (3 <= n && n < 7 && kd[n - 3])
258- {
259- return dt_get(n - 3, 2, 3, ch);
260- return kd[n - 3]->c[3];
261- }
262- else if (2 <= n && n < 6 && kd[n - 2])
263- {
264- return dt_get(n - 2, 1, 2, ch);
265- return kd[n - 2]->c[2];
266- }
267- else if (1 <= n && n < 5 && kd[n - 1])
268- {
269- return dt_get(n - 1, 0, 1, ch);
270- return kd[n - 1]->c[1];
271- }
272-#endif
273-
274-#if DEBUG>=3
275- if (cnt == 0)
276- {
277- printf("n=%d, ch=%d, (n-1)=%02X\n", n, ch, key[n - 1]);
278- int j;
279- for (i = 0; i < 16; i++)
280- {
281- printf("map[0x%02X] =", 16 * i);
282- for (j = 0; j < 16; j++)
283- printf(" %03X", kcls[n].map[16 * i + j]);
284- printf("\n");
285- }
286- }
287-#endif
288- for (i = 0; i < 256; i++)
289- {
290- if (kcls[n].map[i])
291- {
292- if (ch-- == 0)
293- return i;
294- cnt++;
295- }
296- if (n != 1 && n != 2 && i >= 127)
297- break;
298- }
101+ for ( i = 0; i < 256; i++ ) {
102+ if ( kcls[n].map[i] ) {
103+ if ( ch-- == 0 ) {
104+ return( i );
105+ }
106+ cnt++;
107+ }
108+ if ( n != 1 && n != 2 && i >= 127 ) {
109+ break;
110+ }
111+ }
299112 /* 見つからなかったのでもいっぺん */
300- assert(cnt > 0);
113+ assert( cnt > 0 );
301114 ch %= cnt;
302- for (i = 0; i < 256; i++)
303- if (kcls[n].map[i])
304- {
305- if (ch-- == 0)
306- return i;
307- }
308- assert(!"not matched");
309- return 0;
115+ for ( i = 0; i < 256; i++ ) {
116+ if ( kcls[n].map[i] ) {
117+ if ( ch-- == 0 ) {
118+ return( i );
119+ }
120+ }
121+ }
122+ assert( !"not matched" );
123+ return( 0 );
310124 }
311125
312126 /* bitwise key をセット */
@@ -318,88 +132,67 @@
318132 unsigned vk,
319133 unsigned sk)
320134 {
321- int i, j;
322- if (!((vk | sk) & 0x7F))
323- return;
135+ int i, j;
136+ int o;
324137
325- for (i = 0; i < 7; i++)
326- {
327- if (n == 7 && i < N_STRIDE) continue;
328- if (sk & (1 << i))
329- {
330- /* セット */
331- int o = tr_pc1[n][6 - i] - 1;
332- if (o < 28)
333- {
334- assert(o >= 0);
335- for (j = 0; j < N_ALU; j++)
336- key64->k[0][0][o].a[j]
337- = key64->k[0][1][o].a[j]
338- = -!!(k & (1 << i));
339- }
340- else
341- {
342- assert(o >= 28);
343- assert(o < 56);
344- for (j = 0; j < N_ALU; j++)
345- key64->k[1][0][o - 28].a[j]
346- = key64->k[1][1][o - 28].a[j]
347- = -!!(k & (1 << i));
348- }
349- }
350- else if (vk & (1 << i))
351- {
352- /* 反転 */
353- int o = tr_pc1[n][6 - i] - 1;
354- if (o < 28)
355- {
356- assert(o >= 0);
357- for (j = 0; j < N_ALU; j++)
358- key64->k[0][0][o].a[j]
359- = key64->k[0][1][o].a[j]
360- = ~key64->k[0][0][o].a[j];
361- }
362- else
363- {
364- assert(o >= 28);
365- assert(o < 56);
366- for (j = 0; j < N_ALU; j++)
367- key64->k[1][0][o - 28].a[j]
368- = key64->k[1][1][o - 28].a[j]
369- = ~key64->k[1][0][o - 28].a[j];
370- }
371- }
372- }
138+ if ( !((vk | sk) & 0x7F) ) {
139+ return;
140+ }
141+
142+ for ( i = 0; i < 7; i++ ) {
143+ if ( n == 7 && i < N_STRIDE ) {
144+ continue;
145+ }
146+ o = tr_pc1[n][6 - i] - 1;
147+ if ( sk & (1 << i) ) {
148+ if ( o < 28 ) {
149+ for ( j = 0; j < N_ALU; j++ ) {
150+ key64->k[0][0][o].a[j] = key64->k[0][1][o].a[j] = -!!(k & (1 << i));
151+ }
152+ } else {
153+ for ( j = 0; j < N_ALU; j++ ) {
154+ key64->k[1][0][o - 28].a[j] = key64->k[1][1][o - 28].a[j] = -!!(k & (1 << i));
155+ }
156+ }
157+ } else if ( vk & (1 << i) ) {
158+ if ( o < 28 ) {
159+ for ( j = 0; j < N_ALU; j++ ) {
160+ key64->k[0][0][o].a[j] = key64->k[0][1][o].a[j] = ~key64->k[0][0][o].a[j];
161+ }
162+ } else {
163+ for ( j = 0; j < N_ALU; j++ ) {
164+ key64->k[1][0][o - 28].a[j] = key64->k[1][1][o - 28].a[j] = ~key64->k[1][0][o - 28].a[j];
165+ }
166+ }
167+ }
168+ }
373169 }
374170
375171 /* 指定されたクラスの開始値にリセット
376172 直前の文字のクラスに縛られる */
377173 int
378-key_reset(int n)
174+key_reset( n )
175+int n;
379176 {
380- if (n >= 8)
381- return 1;
382- if (n == 7)
383- {
384- key[7] = 0;
385- return 1;
386- }
177+ if ( n >= 8 ) {
178+ return( 1 );
179+ }
180+ if ( n == 7 ) {
181+ key[7] = 0;
182+ return( 1 );
183+ }
387184
388- /* 0-2 文字目はランダムに決める
389- 3 文字目以降は初期値に */
390- if (n >= 3)
391- key[n] = key_set(n, 0);
392- else
393- key[n] = key_set(n, rand());
185+ /* 0-2 文字目はランダムに決める 3 文字目以降は初期値に */
186+ if ( n >= 3 ) {
187+ key[n] = key_set( n, 0 );
188+ } else {
189+ key[n] = key_set( n, rand() );
190+ }
394191
395-#if DEBUG>=3
396- printf("key[%d]=%02X ncls=%04X\n", n, key[n], kcls[n].map[key[n]]);
397-#endif
398-
399192 /* セットされた文字を元に、次キャラの文字クラスを決める */
400- key_make_map(n);
193+ key_make_map( n );
401194
402- return key_reset(n + 1);
195+ return( key_reset(n + 1) );
403196 }
404197
405198 /* 指定された鍵空間の中で、キーをひとつ進める
@@ -406,159 +199,45 @@
406199 安全にインクリメントできた場合 true を返す */
407200 static
408201 int
409-key_inc(int n)
202+key_inc( n )
203+int n;
410204 {
411- if (n >= 8)
412- return 0;
413- else if (n == 7)
414- {
415- /* 最後のバイト */
416- key[7] = (key[7] + (1 << N_STRIDE)) & 0x7F;
417- if (key[7]) return 1;
418- else return 0;
419- }
420- else if (key_inc(n + 1)
421- /*
422- && key_inc(n + 1)
423- && key_inc(n + 1)
424- && key_inc(n + 1)*/
425- )
426- return 1;
205+ if ( n >= 8 ) {
206+ return( 0 );
207+ } else if ( n == 7 ) {
208+ key[7] = (key[7] + (1 << N_STRIDE)) & 0x7F;
209+ if ( key[7] ) {
210+ return( 1 );
211+ } else {
212+ return( 0 );
213+ }
214+ } else if ( key_inc( n + 1 ) ) {
215+ return( 1 );
216+ }
427217
428- /* Salt はインクリメントしない約束にする */
429- if (n == 1 || n == 2)
430- return 1;
218+ if ( n == 1 || n == 2 ) {
219+ return( 1 );
220+ }
431221
432-#if DEBUG>=3
433- printf("key_inc(n=%d,ck=%02X)\n", n, key[n]);
434-#endif
435-
436-#if USE_DT
437- /* 辞書語はインクリメントしていい約束にする */
438- if (3 <= n && n < 7 && kd[n - 3])
439- {
440- if ((key[n - 3] & 0x7F) == ((kd[n - 3] + 1)->c[0] & 0x7F)
441- && (key[n - 2] & 0x7F) == ((kd[n - 3] + 1)->c[1] & 0x7F)
442- && (key[n - 1] & 0x7F) == ((kd[n - 3] + 1)->c[2] & 0x7F))
443- {
444- memcpy(&key[n - 3], &(++kd[n - 3])->c[0], 4);
445-#if DEBUG>=2
446- printf(">dt_get:%c%c%c%c(%02X%02X:%02X%02X)\n",
447- kd[n - 3]->c[0], kd[n - 3]->c[1], kd[n - 3]->c[2], kd[n - 3]->c[3],
448- kd[n - 3]->c[0], kd[n - 3]->c[1], kd[n - 3]->c[2], kd[n - 3]->c[3]);
449-#endif
450- return 1;
451- }
452- else
453- {
454- return 0;
455- }
456- }
457- else if (2 <= n && n < 6 && kd[n - 2])
458- {
459- if ((key[n - 2] & 0x7F) == ((kd[n - 2] + 1)->c[0] & 0x7F)
460- && (key[n - 1] & 0x7F) == ((kd[n - 2] + 1)->c[1] & 0x7F))
461- {
462- memcpy(&key[n - 2], &(++kd[n - 2])->c[0], 4);
463-#if DEBUG>=2
464- printf(">dt_get:%c%c%c%c(%02X%02X:%02X%02X)\n",
465- kd[n - 2]->c[0], kd[n - 2]->c[1], kd[n - 2]->c[2], kd[n - 2]->c[3],
466- kd[n - 2]->c[0], kd[n - 2]->c[1], kd[n - 2]->c[2], kd[n - 2]->c[3]);
467-#endif
468- return 1;
469- }
470- else
471- {
472- return 0;
473- }
474- if (kd[n - 2]->c[0] == key[n - 2])
475- return 1;
476- else
477- return 0;
478- }
479- else if (1 <= n && n < 5 && kd[n - 1])
480- {
481- unsigned c2 = kd[n - 1]->c[0];
482- if ((0x81 <= c2 && c2 <= 0x9F)
483- || (0xE0 <= c2 && c2 <= 0xFC))
484- {
485- kd[n - 1] = NULL;
486-#if 0
487- if (!(n == 1 && n == 2))
488- key[n] &= 0x7F;
489- if (!(n == 2 && n == 3))
490- key[n - 1] &= 0x7F;
491-#endif
492- key_make_map(n - 1);
493- }
494- else if ((key[n - 1] & 0x7F) == ((kd[n - 1] + 1)->c[0] & 0x7F))
495- {
496- memcpy(&key[n - 1], &(++kd[n - 1])->c[0], 4);
497-#if DEBUG>=2
498- printf(">dt_get:%c%c%c%c(%02X%02X:%02X%02X)\n",
499- kd[n - 1]->c[0], kd[n - 1]->c[1], kd[n - 1]->c[2], kd[n - 1]->c[3],
500- kd[n - 1]->c[0], kd[n - 1]->c[1], kd[n - 1]->c[2], kd[n - 1]->c[3]);
501-#endif
502- return 1;
503- }
504- else
505- {
506- return 0;
507- }
508-#if 0
509- if (kd[n - 1]->c[0] == key[n - 1])
510- return 1;
511- else
512- return 0;
513-#endif
514- }
515- else if (n < 4 && kd[n])
516- {
517- if (0 && kd[n]->c[0] == key[n])
518- return 1;
519- kd[n] = NULL;
520-#if 0
521- if (!(n == 1 || n == 2))
522- key[n] &= 0x7F;
523-#endif
524- }
525-#endif
526-
527222 /* 実際に増やしてみる */
528- assert(n >= 3);
529- for (;;)
530- {
531- if (n <= 3
532- && !(key[n] & 0x80)
533- && kcls[n].map[key[n] ^ 0x80] & (KCLS_DT0))
534- {
535- /* 半角カタカナの1バイト目 */
536- key[n] ^= 0x80;
537- }
538- else
539- {
540- key[n] = (key[n] & 0x7F) + 1;
541- if (key[n] >= 0x80)
542- return 0;
543- }
223+ for ( ;; ) {
224+ if ( n <= 3 && !(key[n] & 0x80) &&
225+ kcls[n].map[key[n] ^ 0x80] & (KCLS_DT0) ) {
226+ /* 半角カタカナの1バイト目 */
227+ key[n] ^= 0x80;
228+ } else {
229+ key[n] = (key[n] & 0x7F) + 1;
230+ if ( key[n] >= 0x80 ) {
231+ return( 0 );
232+ }
233+ }
544234
545- if (kcls[n].map[key[n]])
546- {
547- key_make_map(n);
548- key_reset(n + 1);
549- return 1;
550- }
551- }
552- while (++key[n] < 0x80)
553- {
554- if (kcls[n].map[key[n]])
555- {
556- key_make_map(n);
557- key_reset(n + 1);
558- return 1;
559- }
560- }
561- return 0;
235+ if ( kcls[n].map[key[n]] ) {
236+ key_make_map( n );
237+ key_reset( n + 1 );
238+ return( 1 );
239+ }
240+ }
562241 }
563242
564243 /* 鍵を完全にリセットする
@@ -567,73 +246,26 @@
567246 void
568247 key_init()
569248 {
570- int i, j;
249+ int i, j;
250+ unsigned int bm;
571251
572-#if USE_DT
573- /* 辞書を、インデクスを作りながらマップにはめこんで逝く
574- 辞書はコード順昇順に並んでるものとする */
575- for (i = 0; i < dtcnt; i++)
576- {
577- unsigned c = dt[i].c[0];
578-
579- assert(dt[i].c[0]
580- && dt[i].c[1]
581- && dt[i].c[2]
582- && dt[i].c[3]);
583-
584- /* BSD 鯖でしにそうな文字は残念ながら除外 */
585- assert((dt[i].c[0] & 0x7F)
586- && (dt[i].c[1] & 0x7F)
587- && (dt[i].c[2] & 0x7F)
588- && (dt[i].c[3] & 0x7F));
589-
590- /* インデクス */
591- if (!dtidx[c])
592- dtidx[c] = &dt[i];
593-
594- if ((0x81 <= c && c <= 0x9F)
595- || (0xE0 <= c && c <= 0xFC))
596- {
597- /* 全角なので、2バイトきまった時点で立てる */
598- cp932[256 * c + dt[i].c[1]] |= KCLS_DT1;
599- }
600- else if (0xA1 <= c && c <= 0xDF)
601- {
602- /* 半角カナ */
603- for (j = 0; j < 256; j++)
604- cp932[256 * c + j] |= KCLS_DT0;
605- }
606- }
607- /* ケツ、ちうか番人 */
608- dtidx[0x100] = &dt[i];
609-#endif
610-
611252 key[8] = 0;
612253
613254 /* 初期マップを組む */
614- for (i = 0; i < 256; i++)
615- {
616- unsigned bm = 0;
617- kcls[0].map[i] = 0;
618- for (j = 0; j < 256; j++)
619- bm |= cp932[256 * i + j];
620- kcls[0].map[i] = bm & (KCLS_AN | KCLS_KA | KCLS_K1
621- | KCLS_DT0
622- );
623- if (i >= 128)
624- kcls[0].map[i - 128] |= kcls[0].map[i];
625- }
255+ for ( i = 0; i < 256; i++ ) {
256+ bm = 0;
257+ for ( j = 0; j < 256; j++ ) {
258+ bm |= cp932[256 * i + j];
259+ }
260+ kcls[0].map[i] = bm & (KCLS_AN | KCLS_KA | KCLS_K1 | KCLS_DT0);
261+ if ( i >= 128 ) {
262+ kcls[0].map[i - 128] |= kcls[0].map[i];
263+ }
264+ }
626265
627- key_reset(0);
266+ key_reset( 0 );
628267 }
629268
630-/***************************************************************
631- *
632- * Salt のセット
633- * オペランドのオフセットを書き換えて回ってるので注意
634- *
635- */
636-
637269 #if N_STRIDE == 6
638270 #define C(c,i,j,o) (*(int8_t *)((c) + (loo - crypt64_sta) + los[6 * (i) + (j) + (o)]))
639271 #elif N_STRIDE == 7
@@ -644,54 +276,34 @@
644276 set_salt(signed char *code,
645277 unsigned char const *k)
646278 {
647- int i, j;
279+ int i, j;
648280
649- for (i = 0; i < 2; i++)
650- {
651- unsigned s = k[1 + i] & 255;
652- if (s > 'z')
653- s = 0;
654- else if (s >= 'a')
655- s = s - 'a' + 2 + 10 + 26;
656- else if (s >= 'A')
657- s = s - 'A' + 2 + 10;
658- else if (s >= '.')
659- s = s - '.';
660- else
661- s = 0;
281+ for ( i = 0; i < 2; i++ ) {
282+ unsigned s = k[1 + i] & 255;
283+ if ( s > 'z' ) {
284+ s = 0;
285+ } else if ( s >= 'a' ) {
286+ s = s - 'a' + 2 + 10 + 26;
287+ } else if ( s >= 'A' ) {
288+ s = s - 'A' + 2 + 10;
289+ } else if ( s >= '.' ) {
290+ s = s - '.';
291+ } else {
292+ s = 0;
293+ }
662294
663-#if DEBUG>=1
664- printf("Salt %d:%3o\n", i, s & 63);
665-#endif
666- for (j = 0; j < 6; j++)
667- {
668-#if DEBUG>=2
669- //printf("Salt %d:%d %+3d:%+3d",
670- printf("Salt %d:%d %08lX:%08lX",
671- i, j,
672- C(code, i, j, 0),
673- C(code, i, j, 24));
674-#endif
675- if (s & (1 << j))
676- {
677- C(code, i, j, 0) = sizeof(WS_T) * (((4 * i + j + 15) & 31) - 16);
678- C(code, i, j, 24) = sizeof(WS_T) * (((4 * i + j - 1) & 31) - 16);
679- }
680- else
681- {
682- C(code, i, j, 0) = sizeof(WS_T) * (((4 * i + j - 1) & 31) - 16);
683- C(code, i, j, 24) = sizeof(WS_T) * (((4 * i + j + 15) & 31) - 16);
684- }
685- C(code, i, j, 12) = sizeof(WS_T) * (((4 * i + j + 7) & 31) - 16);
686- C(code, i, j, 36) = sizeof(WS_T) * (((4 * i + j + 23) & 31) - 16);
687-#if DEBUG>=2
688- //printf(" => %+3d:%+3d\n",
689- printf(" => %08lX:%08lX\n",
690- C(code, i, j, 0),
691- C(code, i, j, 24));
692-#endif
693- }
694- }
295+ for ( j = 0; j < 6; j++ ) {
296+ if ( s & (1 << j) ) {
297+ C(code, i, j, 0) = sizeof(WS_T) * (((4 * i + j + 15) & 31) - 16);
298+ C(code, i, j, 24) = sizeof(WS_T) * (((4 * i + j - 1) & 31) - 16);
299+ } else {
300+ C(code, i, j, 0) = sizeof(WS_T) * (((4 * i + j - 1) & 31) - 16);
301+ C(code, i, j, 24) = sizeof(WS_T) * (((4 * i + j + 15) & 31) - 16);
302+ }
303+ C(code, i, j, 12) = sizeof(WS_T) * (((4 * i + j + 7) & 31) - 16);
304+ C(code, i, j, 36) = sizeof(WS_T) * (((4 * i + j + 23) & 31) - 16);
305+ }
306+ }
695307 }
696308
697309 static
@@ -698,17 +310,17 @@
698310 uint32_t
699311 usec()
700312 {
701- static uint32_t epoch = 0;
702- uint32_t sec, msec;
313+ static uint32_t epoch = 0;
314+ uint32_t sec, msec;
703315
704316 #if !defined(WIN32)
705- struct timeval tv;
706- gettimeofday(&tv, NULL);
317+ struct timeval tv;
318+ gettimeofday( &tv, NULL );
707319 sec = tv.tv_sec;
708320 msec = tv.tv_usec / 10000;
709321 #else
710- struct timeb tm;
711- ftime(&tm);
322+ struct timeb tm;
323+ ftime( &tm );
712324 sec = tm.time;
713325 msec = tm.millitm / 10;
714326 #endif
@@ -717,31 +329,9 @@
717329 epoch = sec;
718330 }
719331
720- return ((sec - epoch) * 100 + msec);
332+ return ( (sec - epoch) * 100 + msec );
721333 }
722334
723-static
724-int
725-log_printf(FILE *ofp, char const *fmt, ...)
726-{
727- int r;
728- va_list ap;
729- va_start(ap, fmt);
730- vfprintf(stdout, fmt, ap);
731- r = vfprintf(ofp, fmt, ap);
732- va_end(ap);
733- if (r > 0)
734- return r;
735- perror("log_printf");
736- exit(errno);
737-}
738-
739-/***************************************************************
740- *
741- * メインループとか
742- *
743- */
744-
745335 /* 定数項 */
746336 #if N_STRIDE == 7
747337 static SLICE const sk6[N_STRIDE] =
@@ -770,19 +360,16 @@
770360 ALIGN_PREFIX(16) struct PARAM param64 ALIGN_SUFFIX(16);
771361
772362 int
773-main(int argc, char *argv[])
363+main( ac, av )
364+int ac;
365+char *av[];
774366 {
775- int i;
776- int mincnt;
777- int nblk_hit, nblk_total;
778- signed char *code = NULL;
779- FILE *ofp;
780- FILE *sfp; /* scoreboard */
781- struct ITREE *root_expr;
782- int cr;
367+ int i;
368+ signed char *code;
369+ int cr;
370+ int codeSize;
371+ unsigned char buf[32];
783372
784- int xhash_loaded;
785-
786373 #define LOOP_FACTOR 128000 /* こんなもんでいいか */
787374 #define UPDATE_INTERVAL 8 /* 速度表示の間隔 秒 */
788375 #define AVG_SPD 480000 /* 平均速度の初期値 trips/s */
@@ -802,239 +389,205 @@
802389 LOOP_FACTOR * UINT32_MAX + LOOP_FACOTR 個検索するとオーバーフローする。w
803390 */
804391
805-#if 0
806- if (argc < 2)
807- {
808- fprintf(stderr, "式きぼんぬ\n");
809- return 1;
810- }
392+#ifdef WIN32
393+ HANDLE h;
811394 #endif
812395
813- assert((1 << N_STRIDE) == N_ALU * ALU_BITS);
396+#ifndef __GNUC__
397+ CRYPT64_PP d_crypt64;
398+#endif
814399
815400 /* t[16] は、内部演算で使用する、all 1 が入っている */
816- for (i = 0; i < N_ALU; i++)
817- param64.t[T_INV].a[i] = -1;
401+ for ( i = 0; i < N_ALU; i++ ) {
402+ param64.t[T_INV].a[i] = -1;
403+ }
818404
819405 /* 固定キーのコピー */
820- for (i = 0; i < N_STRIDE; i++)
821- {
822- int o = tr_pc1[7][6 - i] - 1;
823- if (o < 28)
824- {
825- key64.k[0][0][o] = key64.k[0][1][o] = sk6[i];
826- }
827- else
828- {
829- o -= 28;
830- key64.k[1][0][o] = key64.k[1][1][o] = sk6[i];
831- }
832- }
406+ for (i = 0; i < N_STRIDE; i++) {
407+ int o = tr_pc1[7][6 - i] - 1;
408+ if (o < 28) {
409+ key64.k[0][0][o] = key64.k[0][1][o] = sk6[i];
410+ } else {
411+ o -= 28;
412+ key64.k[1][0][o] = key64.k[1][1][o] = sk6[i];
413+ }
414+ }
833415
834- /* キースケジュールをここに押し込めておく
835- 従来は crypt64.S 内で完結するように引いていた */
836- for (i = 0; i < 28; i++)
837- key64.ks[i].a[0] = sizeof(WS_T) * ks_ls[i];
416+ for ( i = 0; i < 28; i++ ) {
417+ key64.ks[i].a[0] = sizeof(WS_T) * ks_ls[i];
418+ }
838419
839- /* タゲ読み込み */
840- root_expr = NULL;
420+ initComm();
421+ readList();
841422
842-initComm();
843-readList();
423+ codeSize = crypt64_end - crypt64_sta;
424+ code = NULL;
844425
845- /* コードを生成・展開 */
846- sfp = scoreboard_open();
847- fwrite(crypt64_sta, 1, crypt64_end - crypt64_sta, sfp); /* prologue */
848-/*
849- synth_synthesize(sfp, root_expr);
850-*/
851- fwrite(crypt64_ep, 1, crypt64_ep_end - crypt64_ep, sfp); /* epilogue */
426+#ifdef WIN32
427+ code = (signed char*)VirtualAlloc( NULL, codeSize, MEM_COMMIT,
428+ PAGE_EXECUTE_READWRITE );
429+ if ( code == NULL ) {
430+ DWORD errCode;
431+ errCode = GetLastError();
432+ fprintf( stderr, "VirtualAlloc に失敗。%lx\n", errCode );
433+ fprintf( stderr, "だが、気にせず続行。\n" );
434+ }
435+#if 0
436+ h = CreateFileMapping( INVALID_HANDLE_VALUE, NULL, PAGE_EXECUTE_READWRITE,
437+ 0, codeSize, NULL );
438+#ifndef FILE_MAP_EXECUTE
439+#define FILE_MAP_EXECUTE SECTION_MAP_EXECUTE /* XXX cygwin */
440+#endif /* FILE_MAP_EXECUTE */
441+ if ( SUCCEEDED( h ) ) {
442+ code = (signed char *)MapViewOfFile( h, FILE_MAP_EXECUTE | FILE_MAP_WRITE,
443+ 0, 0, 0 );
444+ if ( code == NULL ) {
445+ DWORD errCode;
446+ errCode = GetLastError();
447+ CloseHandle( h );
448+ fprintf( stderr, "MapViewOfFile に失敗。%lx\n", errCode );
449+ fprintf( stderr, "だが、気にせず続行。\n" );
450+ }
451+ } else {
452+ fprintf( stderr, "CreateFileMapping に失敗。\n" );
453+ fprintf( stderr, "だが、気にせず続行。\n" );
454+ }
455+#endif /* 0 */
456+#else
457+ code = (signed char *)mmap( NULL, codeSize,
458+ PROT_EXEC | PROT_READ | PROT_WRITE,
459+ MAP_PRIVATE | MAP_ANON,
460+ -1, 0 );
461+ if ( (void *)code == MAP_FAILED ) {
462+ code = NULL;
463+ fprintf( stderr, "mmap に失敗。\n" );
464+ fprintf( stderr, "だが、気にせず続行。\n" );
465+ }
466+#endif
852467
853- /* コードをメモリに貼り付ける */
854- code = scoreboard_map(sfp);
468+ if ( code == NULL ) {
469+ fprintf( stderr, "しょうがないので malloc でごまかしてみるテスト。\n" );
470+ code = (signed char *)malloc( codeSize );
471+ if ( code == NULL ) {
472+ fprintf( stderr, "だが、malloc にも失敗。\n" );
473+ exit( 1 );
474+ }
475+ }
855476
856- /* キーの初期化 */
857- srand(time(NULL));
858- key_init();
859- set_salt(code, key);
860- for (i = 0; i < 8; i++)
861- key_set64(&key64, i, okey[i] = key[i], 0, 0x7F);
477+ memcpy( code, crypt64_sta, codeSize );
862478
863-#if DEBUG>=1
864- printf("key=%p param=%p\n", &key64, &param64);
479+#ifndef __GNUC__
480+ d_crypt64 = (CRYPT64_PP)code;
865481 #endif
866- assert(!((ptrdiff_t)&key64 & (sizeof(WS_T) - 1)));
867- assert(!((ptrdiff_t)&param64 & (sizeof(WS_T) - 1)));
868482
869- if ((ofp = fopen("log.txt", "at")) == NULL)
870- {
871- perror("log.txt");
872- return errno;
873- }
483+ /* キーの初期化 */
484+ srand( time( NULL ) );
485+ key_init();
486+ set_salt( code, key );
487+ for ( i = 0; i < 8; i++ ) {
488+ key_set64( &key64, i, okey[i] = key[i], 0, 0x7F );
489+ }
874490
875- setvbuf(ofp, NULL, _IONBF, BUFSIZ); /* XXX MSVCRT では _IOLBF が期待通りに動作しない */
876-
877- mincnt = 0x7FFFFFFF;
878- nblk_hit = nblk_total = 0;
879491 cr = 0;
880492 memset( &status, 0, sizeof( struct status ) );
881493 status.startTime = status.lastTime = usec();
882- /* 探索ループだぞっと */
883- for (;;)
884- {
885- uint64_t cnt;
886- int k, kk;
494+ for ( ;; ) {
495+ int k, kk;
887496
888- /* 鍵のセット */
889- for (i = 0; i < 8; i++)
890- {
891- key_set64(&key64, i, key[i], key[i] ^ okey[i], 0);
892- okey[i] = key[i];
893- }
497+ /* 鍵のセット */
498+ for ( i = 0; i < 8; i++ ) {
499+ key_set64( &key64, i, key[i], key[i] ^ okey[i], 0 );
500+ okey[i] = key[i];
501+ }
502+ memcpy( buf, key, 32 );
503+ buf[8] = buf[9] = '\0';
894504
895- /* 呼ぶ!
896- LR 初期化は、サブモジュール内で行うべし
897- FASTCALL に準じた呼び出しのため、
898- ホントはいろいろレジスタが破壊されるハズ…なんだが。 */
899- cnt = CALL_CRYPT64(code, key64.k, param64.lr);
505+ CALL_CRYPT64( code, key64.k, param64.lr );
900506
901-#if DEBUG>=1
902- cnt2 = (int32_t)(cnt >> 32);
903- cnt1 = (int32_t)cnt;
904- if (mincnt > cnt1 && cnt1 > 0)
905- {
906- mincnt = cnt1;
907- if (cr)
908- fprintf(stderr, "\n");
909- cr = 0;
910- fprintf(stderr, "cycle=%6d/%6d\n", cnt1, cnt2);
911- }
912-#endif
507+ for ( kk = 0; kk < N_ALU; kk++ ) {
508+ static uint64_t xhash[64];
509+ CALL_TR64( &param64.lr[0][0].q[kk / (N_ALU / N_Q)], xhash );
510+ for ( k = 0; k < ALU_BITS; k++ ) {
511+ buf[7] = (buf[7] & -(1 << N_STRIDE) & 0x7F) + ALU_BITS * kk + k;
512+ checkIt( xhash[(ALU_BITS * kk + k)&63], buf );
513+#ifdef OLDDEBUG
514+ printf( "%03d : key %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
515+ ALU_BITS * kk + k,
516+ key[0], key[1], key[2], key[3], key[4],
517+ key[5], key[6], key[7], key[8], key[9] );
518+ printf( "%03d : buf %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
519+ ALU_BITS * kk + k,
520+ buf[0], buf[1], buf[2], buf[3], buf[4],
521+ buf[5], buf[6], buf[7], buf[8], buf[9] );
522+#endif /* DEBUG */
523+ }
524+ }
913525
914- /* ヒットしたときの処理 */
915- xhash_loaded = 0;
916- for (kk = 0; kk < N_ALU; kk++)
917- {
918- ALU_T t;
919- if (!(kk & (N_ALU / N_Q - 1)))
920- nblk_total++, xhash_loaded = 0;
526+ status.loop += N_ALU * ALU_BITS;
527+ if ( status.loop >= upd_int ) {
528+ /*
529+ ここで更新間隔のチェックをすれば、高速マシンで誤差の大きい速度表示が
530+ 出るのを防げる。
531+ だがそれをすると普通のマシンでムダな usec() 呼び出しをすることになる。
532+ だからやらない。決して手抜きではない。
533+ */
534+ uint32_t curTime, diffTime;
535+ int a, b, c;
921536
922- t = param64.t[HIT_ANY].a[kk];
923- for (k = 0; k < ALU_BITS; k++)
924- {
925- static uint64_t xhash[64];
926- char hash[16];
927- unsigned char buf[32];
928-
929- /* 転置 */
930- if (!xhash_loaded)
931- {
932- nblk_hit++;
933- CALL_TR64(&param64.lr[0][0].q[kk / (N_ALU / N_Q)], xhash);
934- xhash_loaded = 1;
935- }
936-
937- for (i = 1; i < 11; i++)
938- {
939- unsigned c = 0;
940- c = (xhash[(ALU_BITS * kk + k) & 63] >> (6 * (i - 1))) & 0x3F; /* XXX */
941- hash[i - 1] = C64[c];
942- }
943- hash[10] = 0;
944-
945- memcpy(buf, key, 32);
946- buf[8] = buf[9] = 0;
947- buf[7] = (buf[7] & -(1 << N_STRIDE) & 0x7F) + ALU_BITS * kk + k;
948-{
949- int i;
950-
951- i = ALU_BITS * kk + k;
952- checkIt( xhash[i&63], buf );
953-}
954- }
955- }
956-
957- status.loop += N_ALU * ALU_BITS;
958- if ( status.loop >= upd_int )
959- {
960-/*
961- ここで更新間隔のチェックをすれば、高速マシンで誤差の大きい速度表示が
962- 出るのを防げる。
963- だがそれをすると普通のマシンでムダな usec() 呼び出しをすることになる。
964- だからやらない。決して手抜きではない。
965- */
966- uint32_t curTime, diffTime;
967- int a, b, c;
968-
969537 #ifdef SPDEBUG
970- putchar( '\n' );
971- printf( "mloop = %d, loop = %d\n", status.mloop, status.loop );
538+ putchar( '\n' );
539+ printf( "mloop = %d, loop = %d\n", status.mloop, status.loop );
972540 #endif
973- curTime = usec();
974- diffTime = curTime - status.lastTime;
975- b = (status.loop - status.lastloop) * 100 / diffTime;
976- status.mloop += ( status.loop / LOOP_FACTOR );
977- status.loop %= LOOP_FACTOR;
978- diffTime = curTime - status.startTime;
979- if ( diffTime >= 1000000000 ) {
980- c = 1000000;
981- } else if ( diffTime >= 100000000 ) {
982- c = 100000;
983- } else if ( diffTime >= 10000000 ) {
984- c = 10000;
985- } else if ( diffTime >= 1000000 ) {
986- c = 1000;
987- } else if ( diffTime >= 100000 ) {
988- c = 100;
989- } else if ( diffTime >= 10000 ) {
990- c = 10;
991- } else {
992- c = 1;
993- }
994- a = status.mloop * (LOOP_FACTOR / (10 * c)) / (diffTime / c);
995- upd_int = b * UPDATE_INTERVAL;
996- upd_int = upd_int / LOOP_FACTOR * LOOP_FACTOR;
541+ curTime = usec();
542+ diffTime = curTime - status.lastTime;
543+ b = (status.loop - status.lastloop) * 100 / diffTime;
544+ status.mloop += ( status.loop / LOOP_FACTOR );
545+ status.loop %= LOOP_FACTOR;
546+ diffTime = curTime - status.startTime;
547+ if ( diffTime >= 1000000000 ) {
548+ c = 1000000;
549+ } else if ( diffTime >= 100000000 ) {
550+ c = 100000;
551+ } else if ( diffTime >= 10000000 ) {
552+ c = 10000;
553+ } else if ( diffTime >= 1000000 ) {
554+ c = 1000;
555+ } else if ( diffTime >= 100000 ) {
556+ c = 100;
557+ } else if ( diffTime >= 10000 ) {
558+ c = 10;
559+ } else {
560+ c = 1;
561+ }
562+ a = status.mloop * (LOOP_FACTOR / (10 * c)) / (diffTime / c);
563+ upd_int = b * UPDATE_INTERVAL;
564+ upd_int = upd_int / LOOP_FACTOR * LOOP_FACTOR;
997565 #ifdef SPDEBUG
998-{
999566 #ifndef USE_MMX
1000- double d;
1001- d = ((double)status.mloop * LOOP_FACTOR / 1000.0) / ((double)diffTime / 100.0);
1002- printf( "d = %f\n", d );
567+ printf( "%f\n",
568+ ((double)status.mloop * LOOP_FACTOR / 1000.0) /
569+ ((double)diffTime / 100.0) );
1003570 #endif
1004- printf( "mloop = %d, loop = %d\n", status.mloop, status.loop );
1005- printf( "%d - %d = %d\n", curTime, status.startTime, curTime - status.startTime );
1006- printf( "%d - %d = %d\n", curTime, status.lastTime, curTime - status.lastTime );
1007- printf( "c = %d\n", c );
1008- printf( "upd_int = %d\n", upd_int );
1009-}
571+ printf( "mloop = %d, loop = %d\n", status.mloop, status.loop );
572+ printf( "elapsed = %d, span = %d\n",
573+ curTime - status.startTime, curTime - status.lastTime );
574+ printf( "c = %d\n", c );
575+ printf( "upd_int = %d\n", upd_int );
1010576 #endif
1011- status.lastTime = curTime;
1012- status.lastloop = status.loop;
1013- fprintf( stderr,
1014- "%6dktrips/s [%6d.%03dktrips/s]\r",
1015- a, b / 1000, b % 1000 );
1016- cr++;
1017- }
1018-#if 1
1019- if (!key_inc(3))
1020- {
1021-#if DEBUG>=2
1022- printf("********************************\n");
1023-#endif
1024- key_reset(0);
1025- set_salt(code, key);
1026- for (i = 0; i < 8; i++)
1027- key_set64(&key64, i, okey[i] = key[i], 0, 0x7F);
1028- }
1029-#endif
1030- }
577+ status.lastTime = curTime;
578+ status.lastloop = status.loop;
579+ fprintf( stderr, "%6dktrips/s [%6d.%03dktrips/s]\r",
580+ a, b / 1000, b % 1000 );
581+ cr++;
582+ }
583+ if ( !key_inc( 3 ) ) {
584+ key_reset( 0 );
585+ set_salt( code, key );
586+ for ( i = 0; i < 8; i++ ) {
587+ key_set64( &key64, i, okey[i] = key[i], 0, 0x7F );
588+ }
589+ }
590+ }
1031591
1032- return 0;
592+ return( 0 );
1033593 }
1034-
1035-/*
1036- * Local Variables:
1037- * tab-width: 4
1038- * End:
1039- *
1040- * EOF */
--- l2.c (revision 8)
+++ l2.c (revision 9)
@@ -148,14 +148,15 @@
148148 uint64_t bin;
149149 unsigned char *key;
150150 {
151- unsigned char res[30];
151+ unsigned char res[30], tmpKey[30];
152152
153153 bin2trip( bin, res );
154- translate( key, 0, 1 );
154+ memcpy( tmpKey, key, 30 );
155+ translate( tmpKey, 0, 1 );
155156
156157 putchar( '\n' );
157- printf( "◆%s : #%s\n", res, key );
158- fprintf( hitFile, "◆%s : #%s\n", res, key );
158+ printf( "◆%s : #%s\n", res, tmpKey );
159+ fprintf( hitFile, "◆%s : #%s\n", res, tmpKey );
159160 fflush( stdout );
160161 fflush( hitFile );
161162
旧リポジトリブラウザで表示