Develop and Download Open Source Software

Tera Term

Browse Subversion Repository

/[ttssh2]/trunk/teraterm/ttpcmn/ttcmn.c

Annotation of /trunk/teraterm/ttpcmn/ttcmn.c

Parent Directory Parent Directory | Revision Log Revision Log

Revision 2663 - (hide annotations) (download) (as text)
Wed Feb 18 15:20:25 2009 UTC (15 years, 1 month ago) by maya
Original Path: teraterm/trunk/ttpcmn/ttcmn.c
File MIME type: text/x-csrc
File size: 42806 byte(s) 
DoCover_IsDebuggerPresent() を WinMain, DllMain から呼ぶようにした。
1 maya 2476 /* Tera Term
2     Copyright(C) 1994-1998 T. Teranishi
3     All rights reserved. */
4    
5     /* TTCMN.DLL, main */
6     #include "teraterm.h"
7     #include "tttypes.h"
8     #include <direct.h>
9     #include <string.h>
10     #include "ttftypes.h"
11     #include "ttlib.h"
12     #include "language.h"
13     #include <stdio.h>
14     #include <windows.h>
15     #include <tchar.h>
16     #include <setupapi.h>
17    
18 maya 2660 // VS2005でビルドされたバイナリが Windows95 でも起動できるようにするために、
19     // IsDebuggerPresent()のシンボル定義を追加する。
20     //
21     // cf.http://jet2.u-abel.net/program/tips/forceimp.htm
22     // 装飾された名前のアドレスを作るための仮定義
23     // (これだけでインポートを横取りしている)
24 maya 2663 int WINAPI _imp__IsDebuggerPresent()
25 maya 2660 { return PtrToInt((void*) &_imp__IsDebuggerPresent); }
26     // 実際に横取り処理を行う関数
27 maya 2663 BOOL WINAPI Cover_IsDebuggerPresent()
28 maya 2660 { return FALSE; }
29     // 関数が実際に呼び出されたときに備えて
30     // 横取り処理関数を呼び出させるための下準備
31 maya 2663 void __stdcall DoCover_IsDebuggerPresent()
32 maya 2660 {
33     DWORD dw;
34     DWORD_PTR FAR* lpdw;
35     // 横取り関数を設定するアドレスを取得
36     lpdw = (DWORD_PTR FAR*) &_imp__IsDebuggerPresent;
37     // このアドレスを書き込めるように設定
38     // (同じプログラム内なので障害なく行える)
39     VirtualProtect(lpdw, sizeof(DWORD_PTR), PAGE_READWRITE, &dw);
40     // 横取り関数を設定
41     *lpdw = (DWORD_PTR)(FARPROC) Cover_IsDebuggerPresent;
42     // 読み書きの状態を元に戻す
43     VirtualProtect(lpdw, sizeof(DWORD_PTR), dw, NULL);
44     }
45     // アプリケーションが初期化される前に下準備を呼び出す
46     // ※ かなり早くに初期化したいときは、このコードを
47     // ファイルの末尾に書いて「#pragma init_seg(lib)」を、
48     // この変数宣言の手前に書きます。
49     // 初期化を急ぐ必要が無い場合は WinMain 内から
50     // DoCover_IsDebuggerPresent を呼び出して構いません。
51 yutakapon 2661 #if 0
52 maya 2663 /* C言語では以下のコードは、コンパイルエラーとなるので、DllMain から呼ぶ。*/
53     int s_DoCover_IsDebuggerPresent
54 maya 2660 = (int) (DoCover_IsDebuggerPresent(), 0);
55 yutakapon 2661 #endif
56 maya 2660
57 maya 2476 /* first instance flag */
58     static BOOL FirstInstance = TRUE;
59    
60     static HINSTANCE hInst;
61    
62     static PMap pm;
63    
64     static HANDLE HMap = NULL;
65     #define VTCLASSNAME "VTWin32"
66     #define TEKCLASSNAME "TEKWin32"
67    
68    
69     void PASCAL CopyShmemToTTSet(PTTSet ts)
70     {
71     // 現在の設定を共有メモリからコピーする
72     memcpy(ts, &pm->ts, sizeof(TTTSet));
73     }
74    
75     void PASCAL CopyTTSetToShmem(PTTSet ts)
76     {
77     // 現在の設定を共有メモリへコピーする
78     memcpy(&pm->ts, ts, sizeof(TTTSet));
79     }
80    
81    
82     BOOL PASCAL FAR StartTeraTerm(PTTSet ts)
83     {
84     char Temp[MAXPATHLEN];
85    
86     if (FirstInstance) {
87     // init window list
88     pm->NWin = 0;
89     }
90     else {
91     /* only the first instance uses saved position */
92     pm->ts.VTPos.x = CW_USEDEFAULT;
93     pm->ts.VTPos.y = CW_USEDEFAULT;
94     pm->ts.TEKPos.x = CW_USEDEFAULT;
95     pm->ts.TEKPos.y = CW_USEDEFAULT;
96     }
97    
98     memcpy(ts,&(pm->ts),sizeof(TTTSet));
99    
100     // if (FirstInstance) { の部分から移動 (2008.3.13 maya)
101     // 起動時には、共有メモリの HomeDir と SetupFName は空になる
102     /* Get home directory */
103     GetModuleFileName(hInst,Temp,sizeof(Temp));
104     ExtractDirName(Temp, ts->HomeDir);
105     _chdir(ts->HomeDir);
106     GetDefaultSetupFName(ts->HomeDir, ts->SetupFName, sizeof(ts->SetupFName));
107    
108     if (FirstInstance) {
109     FirstInstance = FALSE;
110     return TRUE;
111     }
112     else
113     return FALSE;
114     }
115    
116     void PASCAL FAR ChangeDefaultSet(PTTSet ts, PKeyMap km)
117     {
118     if ((ts!=NULL) &&
119     (_stricmp(ts->SetupFName, pm->ts.SetupFName) == 0))
120     memcpy(&(pm->ts),ts,sizeof(TTTSet));
121     if (km!=NULL)
122     memcpy(&(pm->km),km,sizeof(TKeyMap));
123     }
124    
125     void PASCAL FAR GetDefaultSet(PTTSet ts)
126     {
127     memcpy(ts,&(pm->ts),sizeof(TTTSet));
128     }
129    
130    
131     /* Key scan code -> Tera Term key code */
132     WORD PASCAL FAR GetKeyCode(PKeyMap KeyMap, WORD Scan)
133     {
134     WORD Key;
135    
136     if (KeyMap==NULL)
137     KeyMap = &(pm->km);
138     Key = IdKeyMax;
139     while ((Key>0) && (KeyMap->Map[Key-1] != Scan))
140     Key--;
141     return Key;
142     }
143    
144     void PASCAL FAR GetKeyStr(HWND HWin, PKeyMap KeyMap, WORD KeyCode,
145     BOOL AppliKeyMode, BOOL AppliCursorMode,
146     BOOL Send8BitMode, PCHAR KeyStr, int destlen,
147     LPINT Len, LPWORD Type)
148     {
149     MSG Msg;
150     char Temp[201];
151    
152     if (KeyMap==NULL)
153     KeyMap = &(pm->km);
154    
155     *Type = IdBinary; // key type
156     *Len = 0;
157     switch (KeyCode) {
158     case IdUp:
159     if (Send8BitMode) {
160     *Len = 2;
161     if (AppliCursorMode)
162     strncpy_s(KeyStr,destlen,"\217A",_TRUNCATE);
163     else
164     strncpy_s(KeyStr,destlen,"\233A",_TRUNCATE);
165     } else {
166     *Len = 3;
167     if (AppliCursorMode)
168     strncpy_s(KeyStr,destlen,"\033OA",_TRUNCATE);
169     else
170     strncpy_s(KeyStr,destlen,"\033[A",_TRUNCATE);
171     }
172     break;
173     case IdDown:
174     if (Send8BitMode) {
175     *Len = 2;
176     if (AppliCursorMode)
177     strncpy_s(KeyStr,destlen,"\217B",_TRUNCATE);
178     else
179     strncpy_s(KeyStr,destlen,"\233B",_TRUNCATE);
180     } else {
181     *Len = 3;
182     if (AppliCursorMode)
183     strncpy_s(KeyStr,destlen,"\033OB",_TRUNCATE);
184     else
185     strncpy_s(KeyStr,destlen,"\033[B",_TRUNCATE);
186     }
187     break;
188     case IdRight:
189     if (Send8BitMode) {
190     *Len = 2;
191     if (AppliCursorMode)
192     strncpy_s(KeyStr,destlen,"\217C",_TRUNCATE);
193     else
194     strncpy_s(KeyStr,destlen,"\233C",_TRUNCATE);
195     } else {
196     *Len = 3;
197     if (AppliCursorMode)
198     strncpy_s(KeyStr,destlen,"\033OC",_TRUNCATE);
199     else
200     strncpy_s(KeyStr,destlen,"\033[C",_TRUNCATE);
201     }
202     break;
203     case IdLeft:
204     if (Send8BitMode) {
205     *Len = 2;
206     if (AppliCursorMode)
207     strncpy_s(KeyStr,destlen,"\217D",_TRUNCATE);
208     else
209     strncpy_s(KeyStr,destlen,"\233D",_TRUNCATE);
210     } else {
211     *Len = 3;
212     if (AppliCursorMode)
213     strncpy_s(KeyStr,destlen,"\033OD",_TRUNCATE);
214     else
215     strncpy_s(KeyStr,destlen,"\033[D",_TRUNCATE);
216     }
217     break;
218     case Id0:
219     if (AppliKeyMode) {
220     if (Send8BitMode) {
221     *Len = 2;
222     strncpy_s(KeyStr,destlen,"\217p",_TRUNCATE);
223     } else {
224     *Len = 3;
225     strncpy_s(KeyStr,destlen,"\033Op",_TRUNCATE);
226     }
227     }
228     else {
229     *Len = 1;
230     KeyStr[0] = '0';
231     }
232     break;
233     case Id1:
234     if (AppliKeyMode) {
235     if (Send8BitMode) {
236     *Len = 2;
237     strncpy_s(KeyStr,destlen,"\217q",_TRUNCATE);
238     } else {
239     *Len = 3;
240     strncpy_s(KeyStr,destlen,"\033Oq",_TRUNCATE);
241     }
242     }
243     else {
244     *Len = 1;
245     KeyStr[0] = '1';
246     }
247     break;
248     case Id2:
249     if (AppliKeyMode) {
250     if (Send8BitMode) {
251     *Len = 2;
252     strncpy_s(KeyStr,destlen,"\217r",_TRUNCATE);
253     } else {
254     *Len = 3;
255     strncpy_s(KeyStr,destlen,"\033Or",_TRUNCATE);
256     }
257     }
258     else {
259     *Len = 1;
260     KeyStr[0] = '2';
261     }
262     break;
263     case Id3:
264     if (AppliKeyMode) {
265     if (Send8BitMode) {
266     *Len = 2;
267     strncpy_s(KeyStr,destlen,"\217s",_TRUNCATE);
268     } else {
269     *Len = 3;
270     strncpy_s(KeyStr,destlen,"\033Os",_TRUNCATE);
271     }
272     }
273     else {
274     *Len = 1;
275     KeyStr[0] = '3';
276     }
277     break;
278     case Id4:
279     if (AppliKeyMode) {
280     if (Send8BitMode) {
281     *Len = 2;
282     strncpy_s(KeyStr,destlen,"\217t",_TRUNCATE);
283     } else {
284     *Len = 3;
285     strncpy_s(KeyStr,destlen,"\033Ot",_TRUNCATE);
286     }
287     }
288     else {
289     *Len = 1;
290     KeyStr[0] = '4';
291     }
292     break;
293     case Id5:
294     if (AppliKeyMode) {
295     if (Send8BitMode) {
296     *Len = 2;
297     strncpy_s(KeyStr,destlen,"\217u",_TRUNCATE);
298     } else {
299     *Len = 3;
300     strncpy_s(KeyStr,destlen,"\033Ou",_TRUNCATE);
301     }
302     }
303     else {
304     *Len = 1;
305     KeyStr[0] = '5';
306     }
307     break;
308     case Id6:
309     if (AppliKeyMode) {
310     if (Send8BitMode) {
311     *Len = 2;
312     strncpy_s(KeyStr,destlen,"\217v",_TRUNCATE);
313     } else {
314     *Len = 3;
315     strncpy_s(KeyStr,destlen,"\033Ov",_TRUNCATE);
316     }
317     }
318     else {
319     *Len = 1;
320     KeyStr[0] = '6';
321     }
322     break;
323     case Id7:
324     if (AppliKeyMode) {
325     if (Send8BitMode) {
326     *Len = 2;
327     strncpy_s(KeyStr,destlen,"\217w",_TRUNCATE);
328     } else {
329     *Len = 3;
330     strncpy_s(KeyStr,destlen,"\033Ow",_TRUNCATE);
331     }
332     }
333     else {
334     *Len = 1;
335     KeyStr[0] = '7';
336     }
337     break;
338     case Id8:
339     if (AppliKeyMode) {
340     if (Send8BitMode) {
341     *Len = 2;
342     strncpy_s(KeyStr,destlen,"\217x",_TRUNCATE);
343     } else {
344     *Len = 3;
345     strncpy_s(KeyStr,destlen,"\033Ox",_TRUNCATE);
346     }
347     }
348     else {
349     *Len = 1;
350     KeyStr[0] = '8';
351     }
352     break;
353     case Id9:
354     if (AppliKeyMode) {
355     if (Send8BitMode) {
356     *Len = 2;
357     strncpy_s(KeyStr,destlen,"\217y",_TRUNCATE);
358     } else {
359     *Len = 3;
360     strncpy_s(KeyStr,destlen,"\033Oy",_TRUNCATE);
361     }
362     }
363     else {
364     *Len = 1;
365     KeyStr[0] = '9';
366     }
367     break;
368     case IdMinus: /* numeric pad - key (DEC) */
369     if (AppliKeyMode) {
370     if (Send8BitMode) {
371     *Len = 2;
372     strncpy_s(KeyStr,destlen,"\217m",_TRUNCATE);
373     } else {
374     *Len = 3;
375     strncpy_s(KeyStr,destlen,"\033Om",_TRUNCATE);
376     }
377     }
378     else {
379     *Len = 1;
380     KeyStr[0] = '-';
381     }
382     break;
383     case IdComma: /* numeric pad , key (DEC) */
384     if (AppliKeyMode) {
385     if (Send8BitMode) {
386     *Len = 2;
387     strncpy_s(KeyStr,destlen,"\217l",_TRUNCATE);
388     } else {
389     *Len = 3;
390     strncpy_s(KeyStr,destlen,"\033Ol",_TRUNCATE);
391     }
392     }
393     else {
394     *Len = 1;
395     KeyStr[0] = ',';
396     }
397     break;
398     case IdPeriod: /* numeric pad . key */
399     if (AppliKeyMode) {
400     if (Send8BitMode) {
401     *Len = 2;
402     strncpy_s(KeyStr,destlen,"\217n",_TRUNCATE);
403     } else {
404     *Len = 3;
405     strncpy_s(KeyStr,destlen,"\033On",_TRUNCATE);
406     }
407     }
408     else {
409     *Len = 1;
410     KeyStr[0] = '.';
411     }
412     break;
413     case IdEnter: /* numeric pad enter key */
414     if (AppliKeyMode) {
415     if (Send8BitMode) {
416     *Len = 2;
417     strncpy_s(KeyStr,destlen,"\217M",_TRUNCATE);
418     } else {
419     *Len = 3;
420     strncpy_s(KeyStr,destlen,"\033OM",_TRUNCATE);
421     }
422     }
423     else {
424     *Len = 1;
425     KeyStr[0] = 0x0D;
426     }
427     break;
428     case IdSlash: /* numeric pad slash key */
429     if (AppliKeyMode) {
430     if (Send8BitMode) {
431     *Len = 2;
432     strncpy_s(KeyStr,destlen,"\217o",_TRUNCATE);
433     } else {
434     *Len = 3;
435     strncpy_s(KeyStr,destlen,"\033Oo",_TRUNCATE);
436     }
437     }
438     else {
439     *Len = 1;
440     KeyStr[0] = '/';
441     }
442     break;
443     case IdAsterisk: /* numeric pad asterisk key */
444     if (AppliKeyMode) {
445     if (Send8BitMode) {
446     *Len = 2;
447     strncpy_s(KeyStr,destlen,"\217j",_TRUNCATE);
448     } else {
449     *Len = 3;
450     strncpy_s(KeyStr,destlen,"\033Oj",_TRUNCATE);
451     }
452     }
453     else {
454     *Len = 1;
455     KeyStr[0] = '*';
456     }
457     break;
458     case IdPlus: /* numeric pad plus key */
459     if (AppliKeyMode) {
460     if (Send8BitMode) {
461     *Len = 2;
462     strncpy_s(KeyStr,destlen,"\217k",_TRUNCATE);
463     } else {
464     *Len = 3;
465     strncpy_s(KeyStr,destlen,"\033Ok",_TRUNCATE);
466     }
467     }
468     else {
469     *Len = 1;
470     KeyStr[0] = '+';
471     }
472     break;
473     case IdPF1: /* DEC Key: PF1 */
474     if (Send8BitMode) {
475     *Len = 2;
476     strncpy_s(KeyStr,destlen,"\217P",_TRUNCATE);
477     } else {
478     *Len = 3;
479     strncpy_s(KeyStr,destlen,"\033OP",_TRUNCATE);
480     }
481     break;
482     case IdPF2: /* DEC Key: PF2 */
483     if (Send8BitMode) {
484     *Len = 2;
485     strncpy_s(KeyStr,destlen,"\217Q",_TRUNCATE);
486     } else {
487     *Len = 3;
488     strncpy_s(KeyStr,destlen,"\033OQ",_TRUNCATE);
489     }
490     break;
491     case IdPF3: /* DEC Key: PF3 */
492     if (Send8BitMode) {
493     *Len = 2;
494     strncpy_s(KeyStr,destlen,"\217R",_TRUNCATE);
495     } else {
496     *Len = 3;
497     strncpy_s(KeyStr,destlen,"\033OR",_TRUNCATE);
498     }
499     break;
500     case IdPF4: /* DEC Key: PF4 */
501     if (Send8BitMode) {
502     *Len = 2;
503     strncpy_s(KeyStr,destlen,"\217S",_TRUNCATE);
504     } else {
505     *Len = 3;
506     strncpy_s(KeyStr,destlen,"\033OS",_TRUNCATE);
507     }
508     break;
509     case IdFind: /* DEC Key: Find */
510     if (Send8BitMode) {
511     *Len = 3;
512     strncpy_s(KeyStr,destlen,"\2331~",_TRUNCATE);
513     } else {
514     *Len = 4;
515     strncpy_s(KeyStr,destlen,"\033[1~",_TRUNCATE);
516     }
517     break;
518     case IdInsert: /* DEC Key: Insert Here */
519     if (Send8BitMode) {
520     *Len = 3;
521     strncpy_s(KeyStr,destlen,"\2332~",_TRUNCATE);
522     } else {
523     *Len = 4;
524     strncpy_s(KeyStr,destlen,"\033[2~",_TRUNCATE);
525     }
526     break;
527     case IdRemove: /* DEC Key: Remove */
528     if (Send8BitMode) {
529     *Len = 3;
530     strncpy_s(KeyStr,destlen,"\2333~",_TRUNCATE);
531     } else {
532     *Len = 4;
533     strncpy_s(KeyStr,destlen,"\033[3~",_TRUNCATE);
534     }
535     break;
536     case IdSelect: /* DEC Key: Select */
537     if (Send8BitMode) {
538     *Len = 3;
539     strncpy_s(KeyStr,destlen,"\2334~",_TRUNCATE);
540     } else {
541     *Len = 4;
542     strncpy_s(KeyStr,destlen,"\033[4~",_TRUNCATE);
543     }
544     break;
545     case IdPrev: /* DEC Key: Prev */
546     if (Send8BitMode) {
547     *Len = 3;
548     strncpy_s(KeyStr,destlen,"\2335~",_TRUNCATE);
549     } else {
550     *Len = 4;
551     strncpy_s(KeyStr,destlen,"\033[5~",_TRUNCATE);
552     }
553     break;
554     case IdNext: /* DEC Key: Next */
555     if (Send8BitMode) {
556     *Len = 3;
557     strncpy_s(KeyStr,destlen,"\2336~",_TRUNCATE);
558     } else {
559     *Len = 4;
560     strncpy_s(KeyStr,destlen,"\033[6~",_TRUNCATE);
561     }
562     break;
563     case IdF6: /* DEC Key: F6 */
564     if (Send8BitMode) {
565     *Len = 4;
566     strncpy_s(KeyStr,destlen,"\23317~",_TRUNCATE);
567     } else {
568     *Len = 5;
569     strncpy_s(KeyStr,destlen,"\033[17~",_TRUNCATE);
570     }
571     break;
572     case IdF7: /* DEC Key: F7 */
573     if (Send8BitMode) {
574     *Len = 4;
575     strncpy_s(KeyStr,destlen,"\23318~",_TRUNCATE);
576     } else {
577     *Len = 5;
578     strncpy_s(KeyStr,destlen,"\033[18~",_TRUNCATE);
579     }
580     break;
581     case IdF8: /* DEC Key: F8 */
582     if (Send8BitMode) {
583     *Len = 4;
584     strncpy_s(KeyStr,destlen,"\23319~",_TRUNCATE);
585     } else {
586     *Len = 5;
587     strncpy_s(KeyStr,destlen,"\033[19~",_TRUNCATE);
588     }
589     break;
590     case IdF9: /* DEC Key: F9 */
591     if (Send8BitMode) {
592     *Len = 4;
593     strncpy_s(KeyStr,destlen,"\23320~",_TRUNCATE);
594     } else {
595     *Len = 5;
596     strncpy_s(KeyStr,destlen,"\033[20~",_TRUNCATE);
597     }
598     break;
599     case IdF10: /* DEC Key: F10 */
600     if (Send8BitMode) {
601     *Len = 4;
602     strncpy_s(KeyStr,destlen,"\23321~",_TRUNCATE);
603     } else {
604     *Len = 5;
605     strncpy_s(KeyStr,destlen,"\033[21~",_TRUNCATE);
606     }
607     break;
608     case IdF11: /* DEC Key: F11 */
609     if (Send8BitMode) {
610     *Len = 4;
611     strncpy_s(KeyStr,destlen,"\23323~",_TRUNCATE);
612     } else {
613     *Len = 5;
614     strncpy_s(KeyStr,destlen,"\033[23~",_TRUNCATE);
615     }
616     break;
617     case IdF12: /* DEC Key: F12 */
618     if (Send8BitMode) {
619     *Len = 4;
620     strncpy_s(KeyStr,destlen,"\23324~",_TRUNCATE);
621     } else {
622     *Len = 5;
623     strncpy_s(KeyStr,destlen,"\033[24~",_TRUNCATE);
624     }
625     break;
626     case IdF13: /* DEC Key: F13 */
627     if (Send8BitMode) {
628     *Len = 4;
629     strncpy_s(KeyStr,destlen,"\23325~",_TRUNCATE);
630     } else {
631     *Len = 5;
632     strncpy_s(KeyStr,destlen,"\033[25~",_TRUNCATE);
633     }
634     break;
635     case IdF14: /* DEC Key: F14 */
636     if (Send8BitMode) {
637     *Len = 4;
638     strncpy_s(KeyStr,destlen,"\23326~",_TRUNCATE);
639     } else {
640     *Len = 5;
641     strncpy_s(KeyStr,destlen,"\033[26~",_TRUNCATE);
642     }
643     break;
644     case IdHelp: /* DEC Key: Help */
645     if (Send8BitMode) {
646     *Len = 4;
647     strncpy_s(KeyStr,destlen,"\23328~",_TRUNCATE);
648     } else {
649     *Len = 5;
650     strncpy_s(KeyStr,destlen,"\033[28~",_TRUNCATE);
651     }
652     break;
653     case IdDo: /* DEC Key: Do */
654     if (Send8BitMode) {
655     *Len = 4;
656     strncpy_s(KeyStr,destlen,"\23329~",_TRUNCATE);
657     } else {
658     *Len = 5;
659     strncpy_s(KeyStr,destlen,"\033[29~",_TRUNCATE);
660     }
661     break;
662     case IdF17: /* DEC Key: F17 */
663     if (Send8BitMode) {
664     *Len = 4;
665     strncpy_s(KeyStr,destlen,"\23331~",_TRUNCATE);
666     } else {
667     *Len = 5;
668     strncpy_s(KeyStr,destlen,"\033[31~",_TRUNCATE);
669     }
670     break;
671     case IdF18: /* DEC Key: F18 */
672     if (Send8BitMode) {
673     *Len = 4;
674     strncpy_s(KeyStr,destlen,"\23332~",_TRUNCATE);
675     } else {
676     *Len = 5;
677     strncpy_s(KeyStr,destlen,"\033[32~",_TRUNCATE);
678     }
679     break;
680     case IdF19: /* DEC Key: F19 */
681     if (Send8BitMode) {
682     *Len = 4;
683     strncpy_s(KeyStr,destlen,"\23333~",_TRUNCATE);
684     } else {
685     *Len = 5;
686     strncpy_s(KeyStr,destlen,"\033[33~",_TRUNCATE);
687     }
688     break;
689     case IdF20: /* DEC Key: F20 */
690     if (Send8BitMode) {
691     *Len = 4;
692     strncpy_s(KeyStr,destlen,"\23334~",_TRUNCATE);
693     } else {
694     *Len = 5;
695     strncpy_s(KeyStr,destlen,"\033[34~",_TRUNCATE);
696     }
697     break;
698     case IdXF1: /* XTERM F1 */
699     if (Send8BitMode) {
700     *Len = 4;
701     strncpy_s(KeyStr,destlen,"\23311~",_TRUNCATE);
702     } else {
703     *Len = 5;
704     strncpy_s(KeyStr,destlen,"\033[11~",_TRUNCATE);
705     }
706     break;
707     case IdXF2: /* XTERM F2 */
708     if (Send8BitMode) {
709     *Len = 4;
710     strncpy_s(KeyStr,destlen,"\23312~",_TRUNCATE);
711     } else {
712     *Len = 5;
713     strncpy_s(KeyStr,destlen,"\033[12~",_TRUNCATE);
714     }
715     break;
716     case IdXF3: /* XTERM F3 */
717     if (Send8BitMode) {
718     *Len = 4;
719     strncpy_s(KeyStr,destlen,"\23313~",_TRUNCATE);
720     } else {
721     *Len = 5;
722     strncpy_s(KeyStr,destlen,"\033[13~",_TRUNCATE);
723     }
724     break;
725     case IdXF4: /* XTERM F4 */
726     if (Send8BitMode) {
727     *Len = 4;
728     strncpy_s(KeyStr,destlen,"\23314~",_TRUNCATE);
729     } else {
730     *Len = 5;
731     strncpy_s(KeyStr,destlen,"\033[14~",_TRUNCATE);
732     }
733     break;
734     case IdXF5: /* XTERM F5 */
735     if (Send8BitMode) {
736     *Len = 4;
737     strncpy_s(KeyStr,destlen,"\23315~",_TRUNCATE);
738     } else {
739     *Len = 5;
740     strncpy_s(KeyStr,destlen,"\033[15~",_TRUNCATE);
741     }
742     break;
743     case IdHold:
744     case IdPrint:
745     case IdBreak:
746     case IdCmdEditCopy:
747     case IdCmdEditPaste:
748     case IdCmdEditPasteCR:
749     case IdCmdEditCLS:
750     case IdCmdEditCLB:
751     case IdCmdCtrlOpenTEK:
752     case IdCmdCtrlCloseTEK:
753     case IdCmdLineUp:
754     case IdCmdLineDown:
755     case IdCmdPageUp:
756     case IdCmdPageDown:
757     case IdCmdBuffTop:
758     case IdCmdBuffBottom:
759     case IdCmdNextWin:
760     case IdCmdPrevWin:
761     case IdCmdLocalEcho:
762     case IdScrollLock:
763     PostMessage(HWin,WM_USER_ACCELCOMMAND,KeyCode,0);
764     break;
765     default:
766     if ((KeyCode >= IdUser1) && (KeyCode <= IdKeyMax)) {
767     *Type = (WORD)(*KeyMap).UserKeyType[KeyCode-IdUser1]; // key type
768     *Len = KeyMap->UserKeyLen[KeyCode-IdUser1];
769     memcpy(Temp,
770     &KeyMap->UserKeyStr[KeyMap->UserKeyPtr[KeyCode-IdUser1]],
771     *Len);
772     Temp[*Len] = 0;
773     if ((*Type==IdBinary) || (*Type==IdText))
774     *Len = Hex2Str(Temp,KeyStr,destlen);
775     else
776     strncpy_s(KeyStr,destlen,Temp,_TRUNCATE);
777     }
778     else
779     return;
780     }
781     /* remove WM_CHAR message for used keycode */
782     PeekMessage(&Msg,HWin, WM_CHAR, WM_CHAR,PM_REMOVE);
783     }
784    
785     void FAR PASCAL SetCOMFlag(int Com)
786     {
787     pm->ComFlag[(Com-1)/CHAR_BIT] |= 1 << ((Com-1)%CHAR_BIT);
788     }
789    
790     void FAR PASCAL ClearCOMFlag(int Com)
791     {
792     pm->ComFlag[(Com-1)/CHAR_BIT] &= ~(1 << ((Com-1)%CHAR_BIT));
793     }
794    
795     int FAR PASCAL CheckCOMFlag(int Com)
796     {
797     return ((pm->ComFlag[(Com-1)/CHAR_BIT] & 1 << (Com-1)%CHAR_BIT) > 0);
798     }
799    
800     int FAR PASCAL RegWin(HWND HWinVT, HWND HWinTEK)
801     {
802     int i, j;
803    
804     if (pm->NWin>=MAXNWIN)
805     return 0;
806     if (HWinVT==NULL)
807     return 0;
808     if (HWinTEK!=NULL) {
809     i = 0;
810     while ((i<pm->NWin) && (pm->WinList[i]!=HWinVT))
811     i++;
812     if (i>=pm->NWin)
813     return 0;
814     for (j=pm->NWin-1 ; j>i ; j--)
815     pm->WinList[j+1] = pm->WinList[j];
816     pm->WinList[i+1] = HWinTEK;
817     pm->NWin++;
818     return 0;
819     }
820     pm->WinList[pm->NWin++] = HWinVT;
821     if (pm->NWin==1)
822     return 1;
823     else
824     return (int)(SendMessage(pm->WinList[pm->NWin-2],
825     WM_USER_GETSERIALNO,0,0)+1);
826     }
827    
828     void FAR PASCAL UnregWin(HWND HWin)
829     {
830     int i, j;
831    
832     i = 0;
833     while ((i<pm->NWin) && (pm->WinList[i]!=HWin))
834     i++;
835     if (pm->WinList[i]!=HWin)
836     return;
837     for (j=i ; j<pm->NWin-1 ; j++)
838     pm->WinList[j] = pm->WinList[j+1];
839     if (pm->NWin>0)
840     pm->NWin--;
841     }
842    
843     void FAR PASCAL SetWinMenu(HMENU menu, PCHAR buf, int buflen, PCHAR langFile, int VTFlag)
844     {
845     int i;
846     char Temp[MAXPATHLEN];
847     HWND Hw;
848    
849     // delete all items in Window menu
850     i = GetMenuItemCount(menu);
851     if (i>0)
852     do {
853     i--;
854     RemoveMenu(menu,i,MF_BYPOSITION);
855     } while (i>0);
856    
857     i = 0;
858     while (i<pm->NWin) {
859     Hw = pm->WinList[i]; // get window handle
860     if ((GetClassName(Hw,Temp,sizeof(Temp))>0) &&
861     ((strcmp(Temp,VTCLASSNAME)==0) ||
862     (strcmp(Temp,TEKCLASSNAME)==0))) {
863     Temp[0] = '&';
864     Temp[1] = (char)(0x31 + i);
865     Temp[2] = ' ';
866     GetWindowText(Hw,&Temp[3],sizeof(Temp)-4);
867     AppendMenu(menu,MF_ENABLED | MF_STRING,ID_WINDOW_1+i,Temp);
868     i++;
869     if (i>8)
870     i = pm->NWin;
871     }
872     else
873     UnregWin(Hw);
874     }
875     get_lang_msg("MENU_WINDOW_WINDOW", buf, buflen, "&Window", langFile);
876     if (VTFlag == 1) {
877     AppendMenu(menu,MF_ENABLED | MF_STRING,ID_WINDOW_WINDOW, buf);
878     }
879     else {
880     AppendMenu(menu,MF_ENABLED | MF_STRING,ID_TEKWINDOW_WINDOW, buf);
881     }
882     }
883    
884     void FAR PASCAL SetWinList(HWND HWin, HWND HDlg, int IList)
885     {
886     int i;
887     char Temp[MAXPATHLEN];
888     HWND Hw;
889    
890     for (i=0; i<pm->NWin; i++) {
891     Hw = pm->WinList[i]; // get window handle
892     if ((GetClassName(Hw,Temp,sizeof(Temp))>0) &&
893     ((strcmp(Temp,VTCLASSNAME)==0) ||
894     (strcmp(Temp,TEKCLASSNAME)==0))) {
895     GetWindowText(Hw,Temp,sizeof(Temp)-1);
896     SendDlgItemMessage(HDlg, IList, LB_ADDSTRING,
897     0, (LONG)Temp);
898     if (Hw==HWin)
899     SendDlgItemMessage(HDlg, IList, LB_SETCURSEL,
900     i,0);
901     }
902     else
903     UnregWin(Hw);
904     }
905     }
906    
907     void FAR PASCAL SelectWin(int WinId)
908     {
909     if ((WinId>=0) && (WinId<pm->NWin)) {
910     ShowWindow(pm->WinList[WinId],SW_SHOWNORMAL);
911     SetForegroundWindow(pm->WinList[WinId]);
912     }
913     }
914    
915     void FAR PASCAL SelectNextWin(HWND HWin, int Next)
916     {
917     int i;
918    
919     i = 0;
920     while ((i<pm->NWin) && (pm->WinList[i]!=HWin))
921     i++;
922     if (pm->WinList[i]!=HWin)
923     return;
924     i = i + Next;
925     if (i >= pm->NWin)
926     i = 0;
927     else if (i<0)
928     i = pm->NWin-1;
929     SelectWin(i);
930     }
931    
932     HWND FAR PASCAL GetNthWin(int n)
933     {
934     if (n<pm->NWin)
935     return pm->WinList[n];
936     else
937     return NULL;
938     }
939    
940     int FAR PASCAL CommReadRawByte(PComVar cv, LPBYTE b)
941     {
942     if ( ! cv->Ready )
943     return 0;
944    
945     if ( cv->InBuffCount>0 ) {
946     *b = cv->InBuff[cv->InPtr];
947     cv->InPtr++;
948     cv->InBuffCount--;
949     if ( cv->InBuffCount==0 )
950     cv->InPtr = 0;
951     return 1;
952     }
953     else {
954     cv->InPtr = 0;
955     return 0;
956     }
957     }
958    
959     void PASCAL FAR CommInsert1Byte(PComVar cv, BYTE b)
960     {
961     if ( ! cv->Ready )
962     return;
963    
964     if (cv->InPtr == 0)
965     memmove(&(cv->InBuff[1]),&(cv->InBuff[0]),cv->InBuffCount);
966     else
967     cv->InPtr--;
968     cv->InBuff[cv->InPtr] = b;
969     cv->InBuffCount++;
970    
971     if (cv->HBinBuf!=0 )
972     cv->BinSkip++;
973     }
974    
975     void Log1Bin(PComVar cv, BYTE b)
976     {
977     if (((cv->FilePause & OpLog)!=0) || cv->ProtoFlag)
978     return;
979     if (cv->BinSkip > 0) {
980     cv->BinSkip--;
981     return;
982     }
983     cv->BinBuf[cv->BinPtr] = b;
984     cv->BinPtr++;
985     if (cv->BinPtr>=InBuffSize)
986     cv->BinPtr = cv->BinPtr-InBuffSize;
987     if (cv->BCount>=InBuffSize) {
988     cv->BCount = InBuffSize;
989     cv->BStart = cv->BinPtr;
990     }
991     else
992     cv->BCount++;
993     }
994    
995     int FAR PASCAL CommRead1Byte(PComVar cv, LPBYTE b)
996     {
997     int c;
998    
999     if ( ! cv->Ready )
1000     return 0;
1001    
1002     if ((cv->HLogBuf!=NULL) &&
1003     ((cv->LCount>=InBuffSize-10) ||
1004     (cv->DCount>=InBuffSize-10))) {
1005     // 自分のバッファに余裕がない場合は、CPUスケジューリングを他に回し、
1006     // CPUがストールするの防ぐ。
1007     // (2006.10.13 yutaka)
1008     Sleep(1);
1009     return 0;
1010     }
1011    
1012     if ((cv->HBinBuf!=NULL) &&
1013     (cv->BCount>=InBuffSize-10))
1014     return 0;
1015    
1016     if ( cv->TelMode )
1017     c = 0;
1018     else
1019     c = CommReadRawByte(cv,b);
1020    
1021     if ((c==1) && cv->TelCRFlag) {
1022     cv->TelCRFlag = FALSE;
1023     if (*b==0) c = 0;
1024     }
1025    
1026     if ( c==1 ) {
1027     if ( cv->IACFlag ) {
1028     cv->IACFlag = FALSE;
1029     if ( *b != 0xFF ) {
1030     cv->TelMode = TRUE;
1031     CommInsert1Byte(cv,*b);
1032     if ( cv->HBinBuf!=0 )
1033     cv->BinSkip--;
1034     c = 0;
1035     }
1036     }
1037     else if ((cv->PortType==IdTCPIP) && (*b==0xFF)) {
1038     if (!cv->TelFlag && cv->TelAutoDetect) /* TTPLUG */
1039     cv->TelFlag = TRUE;
1040     if (cv->TelFlag) {
1041     cv->IACFlag = TRUE;
1042     c = 0;
1043     }
1044     }
1045     else if (cv->TelFlag && ! cv->TelBinRecv && (*b==0x0D))
1046     cv->TelCRFlag = TRUE;
1047     }
1048    
1049     if ( (c==1) && (cv->HBinBuf!=0) )
1050     Log1Bin(cv, *b);
1051    
1052     return c;
1053     }
1054    
1055     int FAR PASCAL CommRawOut(PComVar cv, PCHAR B, int C)
1056     {
1057     int a;
1058    
1059     if ( ! cv->Ready )
1060     return C;
1061    
1062     if (C > OutBuffSize - cv->OutBuffCount)
1063     a = OutBuffSize - cv->OutBuffCount;
1064     else
1065     a = C;
1066     if ( cv->OutPtr > 0 ) {
1067     memmove(&(cv->OutBuff[0]),&(cv->OutBuff[cv->OutPtr]),cv->OutBuffCount);
1068     cv->OutPtr = 0;
1069     }
1070     memcpy(&(cv->OutBuff[cv->OutBuffCount]),B,a);
1071     cv->OutBuffCount = cv->OutBuffCount + a;
1072     return a;
1073     }
1074    
1075     int FAR PASCAL CommBinaryOut(PComVar cv, PCHAR B, int C)
1076     {
1077     int a, i, Len;
1078     char d[3];
1079    
1080     if ( ! cv->Ready )
1081     return C;
1082    
1083     i = 0;
1084     a = 1;
1085     while ((a>0) && (i<C)) {
1086     Len = 0;
1087    
1088     d[Len] = B[i];
1089     Len++;
1090    
1091     if ( cv->TelFlag && (B[i]=='\x0d') &&
1092     ! cv->TelBinSend ) {
1093     d[Len] = '\x00';
1094     Len++;
1095     };
1096    
1097     if ( cv->TelFlag && (B[i]=='\xff') ) {
1098     d[Len] = '\xff';
1099     Len++;
1100     }
1101    
1102     if ( OutBuffSize-cv->OutBuffCount-Len >=0 ) {
1103     CommRawOut(cv,d,Len);
1104     a = 1;
1105     }
1106     else
1107     a = 0;
1108    
1109     i = i + a;
1110     }
1111     return i;
1112     }
1113    
1114     static void OutputTextUTF8(WORD K, char *TempStr, int *TempLenSrc, PComVar cv)
1115     {
1116     unsigned int code;
1117     int byte;
1118     int TempLen = *TempLenSrc;
1119    
1120     code = SJIS2UTF8(K, &byte, cv->Locale);
1121     if (byte == 1) {
1122     TempStr[TempLen++] = code;
1123     }
1124     else if (byte == 2) {
1125     TempStr[TempLen++] = (code >> 8) & 0xff;
1126     TempStr[TempLen++] = code & 0xff;
1127    
1128     }
1129     else if (byte == 3) {
1130     TempStr[TempLen++] = (code >> 16) & 0xff;
1131     TempStr[TempLen++] = (code >> 8) & 0xff;
1132     TempStr[TempLen++] = code & 0xff;
1133    
1134     }
1135    
1136     *TempLenSrc = TempLen;
1137     }
1138    
1139    
1140     //
1141     // SJISから各種漢字コードへ変換して出力する。
1142     //
1143     int TextOutJP(PComVar cv, PCHAR B, int C)
1144     {
1145     int i, TempLen;
1146     WORD K;
1147     char TempStr[11];
1148     int SendCodeNew;
1149     BYTE d;
1150     BOOL Full, KanjiFlagNew;
1151    
1152     Full = FALSE;
1153     i = 0;
1154     while (! Full && (i < C)) {
1155     TempLen = 0;
1156     d = (BYTE)B[i];
1157     SendCodeNew = cv->SendCode;
1158    
1159     if (cv->SendKanjiFlag) {
1160     KanjiFlagNew = FALSE;
1161     SendCodeNew = IdKanji;
1162    
1163     K = (cv->SendKanjiFirst << 8) + d;
1164    
1165     // UTF-8への変換を行う。1〜3バイトまでの対応なので注意。
1166     if (cv->KanjiCodeSend == IdUTF8) {
1167     OutputTextUTF8(K, TempStr, &TempLen, cv);
1168    
1169     } else {
1170    
1171     if (cv->KanjiCodeSend == IdEUC)
1172     K = SJIS2EUC(K);
1173     else if (cv->KanjiCodeSend != IdSJIS)
1174     K = SJIS2JIS(K);
1175    
1176     if ((cv->SendCode==IdKatakana) &&
1177     (cv->KanjiCodeSend==IdJIS) &&
1178     (cv->JIS7KatakanaSend==1)) {
1179     TempStr[TempLen] = SI;
1180     TempLen++;
1181     }
1182    
1183     TempStr[TempLen] = HIBYTE(K);
1184     TempStr[TempLen+1] = LOBYTE(K);
1185     TempLen = TempLen + 2;
1186     }
1187     }
1188     else if (IsDBCSLeadByteEx(*cv->CodePage, d))
1189     {
1190     KanjiFlagNew = TRUE;
1191     cv->SendKanjiFirst = d;
1192     SendCodeNew = IdKanji;
1193    
1194     if ((cv->SendCode!=IdKanji) &&
1195     (cv->KanjiCodeSend==IdJIS)) {
1196     TempStr[0] = 0x1B;
1197     TempStr[1] = '$';
1198     if (cv->KanjiIn == IdKanjiInB)
1199     TempStr[2] = 'B';
1200     else
1201     TempStr[2] = '@';
1202     TempLen = 3;
1203     }
1204     else TempLen = 0;
1205     }
1206     else {
1207     KanjiFlagNew = FALSE;
1208    
1209     if ((cv->SendCode==IdKanji) &&
1210     (cv->KanjiCodeSend==IdJIS))
1211     {
1212     TempStr[0] = 0x1B;
1213     TempStr[1] = '(';
1214     switch (cv->KanjiOut) {
1215     case IdKanjiOutJ:
1216     TempStr[2] = 'J';
1217     break;
1218     case IdKanjiOutH:
1219     TempStr[2] = 'H';
1220     break;
1221     default:
1222     TempStr[2] = 'B';
1223     }
1224     TempLen = 3;
1225     }
1226     else TempLen = 0;
1227    
1228     if ((0xa0<d) && (d<0xe0)) {
1229     SendCodeNew = IdKatakana;
1230     if ((cv->SendCode!=IdKatakana) &&
1231     (cv->KanjiCodeSend==IdJIS) &&
1232     (cv->JIS7KatakanaSend==1)) {
1233     TempStr[TempLen] = SO;
1234     TempLen++;
1235     }
1236     }
1237     else {
1238     SendCodeNew = IdASCII;
1239     if ((cv->SendCode==IdKatakana) &&
1240     (cv->KanjiCodeSend==IdJIS) &&
1241     (cv->JIS7KatakanaSend==1)) {
1242     TempStr[TempLen] = SI;
1243     TempLen++;
1244     }
1245     }
1246    
1247     if (d==0x0d) {
1248     TempStr[TempLen] = 0x0d;
1249     TempLen++;
1250     if (cv->CRSend==IdCRLF) {
1251     TempStr[TempLen] = 0x0a;
1252     TempLen++;
1253     }
1254     else if ((cv->CRSend==IdCR) &&
1255     cv->TelFlag && ! cv->TelBinSend) {
1256     TempStr[TempLen] = 0;
1257     TempLen++;
1258     }
1259     }
1260     else if ((d>=0xa1) && (d<=0xe0)) {
1261     /* Katakana */
1262     if (cv->KanjiCodeSend==IdEUC) {
1263     TempStr[TempLen] = (char)0x8E;
1264     TempLen++;
1265     }
1266     if ((cv->KanjiCodeSend==IdJIS) &&
1267     (cv->JIS7KatakanaSend==1))
1268     TempStr[TempLen] = d & 0x7f;
1269     else
1270     TempStr[TempLen] = d;
1271     TempLen++;
1272    
1273     // 半角カナはUnicodeでは2バイトになる (2004.10.4 yutaka)
1274     if (cv->KanjiCodeSend==IdUTF8) {
1275     TempLen = 0;
1276     K = d;
1277     OutputTextUTF8(K, TempStr, &TempLen, cv);
1278     }
1279     }
1280     else {
1281     TempStr[TempLen] = d;
1282     TempLen++;
1283     if (cv->TelFlag && (d==0xff)) {
1284     TempStr[TempLen] = (char)0xff;
1285     TempLen++;
1286     }
1287     }
1288     } // if (cv->SendKanjiFlag) else if ... else ... end
1289    
1290     if (TempLen == 0) {
1291     i++;
1292     cv->SendCode = SendCodeNew;
1293     cv->SendKanjiFlag = KanjiFlagNew;
1294     }
1295     else {
1296     Full = OutBuffSize-cv->OutBuffCount-TempLen < 0;
1297     if (! Full) {
1298     i++;
1299     cv->SendCode = SendCodeNew;
1300     cv->SendKanjiFlag = KanjiFlagNew;
1301     CommRawOut(cv,TempStr,TempLen);
1302     }
1303     }
1304    
1305     } // end of "while {}"
1306    
1307     return i;
1308     }
1309    
1310 yutakapon 2556 int TextOutKR(PComVar cv, PCHAR B, int C) //HKS
1311     {
1312     int i, TempLen;
1313     WORD K;
1314     char TempStr[11];
1315     int SendCodeNew;
1316     BYTE d;
1317     BOOL Full, KanjiFlagNew;
1318    
1319     Full = FALSE;
1320     i = 0;
1321     while (! Full && (i < C))
1322     {
1323     TempLen = 0;
1324     d = (BYTE)B[i];
1325     SendCodeNew = cv->SendCode;
1326    
1327     if (cv->SendKanjiFlag)
1328     {
1329     KanjiFlagNew = FALSE;
1330     SendCodeNew = IdKanji;
1331    
1332     K = (cv->SendKanjiFirst << 8) + d;
1333    
1334     // UTF-8への変換を行う。1?3バイトまでの対応なので注意。
1335     if (cv->KanjiCodeSend == IdUTF8) {
1336     OutputTextUTF8(K, TempStr, &TempLen, cv);
1337    
1338     } else {
1339    
1340     if (cv->KanjiCodeSend == IdEUC) K = K;
1341     else if (cv->KanjiCodeSend != IdSJIS) K = K;
1342    
1343     if ((cv->SendCode==IdKatakana) &&
1344     (cv->KanjiCodeSend==IdJIS) &&
1345     (cv->JIS7KatakanaSend==1))
1346     {
1347     TempStr[TempLen] = SI;
1348     TempLen++;
1349     }
1350    
1351     TempStr[TempLen] = HIBYTE(K);
1352     TempStr[TempLen+1] = LOBYTE(K);
1353     TempLen = TempLen + 2;
1354     }
1355     }
1356     else if (IsDBCSLeadByteEx(*cv->CodePage, d))
1357     {
1358     KanjiFlagNew = TRUE;
1359     cv->SendKanjiFirst = d;
1360     SendCodeNew = IdKanji;
1361    
1362     if ((cv->SendCode!=IdKanji) &&
1363     (cv->KanjiCodeSend==IdJIS))
1364     {
1365     TempStr[0] = 0x1B;
1366     TempStr[1] = '$';
1367     if (cv->KanjiIn == IdKanjiInB)
1368     TempStr[2] = 'B';
1369     else
1370     TempStr[2] = '@';
1371     TempLen = 3;
1372     }
1373     else TempLen = 0;
1374     }
1375     else {
1376     KanjiFlagNew = FALSE;
1377    
1378     if ((cv->SendCode==IdKanji) &&
1379     (cv->KanjiCodeSend==IdJIS))
1380     {
1381     TempStr[0] = 0x1B;
1382     TempStr[1] = '(';
1383     switch (cv->KanjiOut) {
1384     case IdKanjiOutJ: TempStr[2] = 'J'; break;
1385     case IdKanjiOutH: TempStr[2] = 'H'; break;
1386     default:
1387     TempStr[2] = 'B';
1388     }
1389     TempLen = 3;
1390     }
1391     else TempLen = 0;
1392    
1393     if ((0xa0<d) && (d<0xe0))
1394     {
1395     SendCodeNew = IdKatakana;
1396     if ((cv->SendCode!=IdKatakana) &&
1397     (cv->KanjiCodeSend==IdJIS) &&
1398     (cv->JIS7KatakanaSend==1))
1399     {
1400     TempStr[TempLen] = SO;
1401     TempLen++;
1402     }
1403     }
1404     else {
1405     SendCodeNew = IdASCII;
1406     if ((cv->SendCode==IdKatakana) &&
1407     (cv->KanjiCodeSend==IdJIS) &&
1408     (cv->JIS7KatakanaSend==1))
1409     {
1410     TempStr[TempLen] = SI;
1411     TempLen++;
1412     }
1413     }
1414    
1415     if (d==0x0d)
1416     {
1417     TempStr[TempLen] = 0x0d;
1418     TempLen++;
1419     if (cv->CRSend==IdCRLF)
1420     {
1421     TempStr[TempLen] = 0x0a;
1422     TempLen++;
1423     }
1424     else if ((cv->CRSend==IdCR) &&
1425     cv->TelFlag && ! cv->TelBinSend)
1426     {
1427     TempStr[TempLen] = 0;
1428     TempLen++;
1429     }
1430     }
1431     else if ((d>=0xa1) && (d<=0xe0))
1432     {
1433     /* Katakana */
1434     if (cv->KanjiCodeSend==IdEUC)
1435     {
1436     TempStr[TempLen] = (char)0x8E;
1437     TempLen++;
1438     }
1439     if ((cv->KanjiCodeSend==IdJIS) &&
1440     (cv->JIS7KatakanaSend==1))
1441     TempStr[TempLen] = d & 0x7f;
1442     else
1443     TempStr[TempLen] = d;
1444     TempLen++;
1445    
1446     // 半角カナはUnicodeでは2バイトになる (2004.10.4 yutaka)
1447     if (cv->KanjiCodeSend==IdUTF8) {
1448     TempLen = 0;
1449     K = d;
1450     OutputTextUTF8(K, TempStr, &TempLen, cv);
1451     }
1452     }
1453     else {
1454     TempStr[TempLen] = d;
1455     TempLen++;
1456     if (cv->TelFlag && (d==0xff))
1457     {
1458     TempStr[TempLen] = (char)0xff;
1459     TempLen++;
1460     }
1461     }
1462     } // if (cv->SendKanjiFlag) else if ... else ... end
1463    
1464     if (TempLen == 0)
1465     {
1466     i++;
1467     cv->SendCode = SendCodeNew;
1468     cv->SendKanjiFlag = KanjiFlagNew;
1469     }
1470     else {
1471     Full = OutBuffSize-cv->OutBuffCount-TempLen < 0;
1472     if (! Full)
1473     {
1474     i++;
1475     cv->SendCode = SendCodeNew;
1476     cv->SendKanjiFlag = KanjiFlagNew;
1477     CommRawOut(cv,TempStr,TempLen);
1478     }
1479     }
1480    
1481     } // end of "while {}"
1482    
1483     return i;
1484     }
1485    
1486 maya 2476 int FAR PASCAL CommTextOut(PComVar cv, PCHAR B, int C)
1487     {
1488     int i, TempLen;
1489     char TempStr[11];
1490     BYTE d;
1491     BOOL Full;
1492    
1493     if (! cv->Ready )
1494     return C;
1495    
1496     if (cv->Language==IdJapanese)
1497     return TextOutJP(cv,B,C);
1498 yutakapon 2556 if (cv->Language==IdKorean) // HKS
1499     return TextOutKR(cv,B,C);
1500 maya 2476
1501 yutakapon 2556
1502 maya 2476 Full = FALSE;
1503     i = 0;
1504     while (! Full && (i < C)) {
1505     TempLen = 0;
1506     d = (BYTE)B[i];
1507    
1508     if (d==0x0d) {
1509     TempStr[TempLen] = 0x0d;
1510     TempLen++;
1511     if (cv->CRSend==IdCRLF) {
1512     TempStr[TempLen] = 0x0a;
1513     TempLen++;
1514     }
1515     else if ((cv->CRSend==IdCR) &&
1516     cv->TelFlag && ! cv->TelBinSend) {
1517     TempStr[TempLen] = 0;
1518     TempLen++;
1519     }
1520     }
1521     else {
1522     if ((cv->Language==IdRussian) &&
1523     (d>=128))
1524     d = RussConv(cv->RussClient,cv->RussHost,d);
1525     TempStr[TempLen] = d;
1526     TempLen++;
1527     if (cv->TelFlag && (d==0xff)) {
1528     TempStr[TempLen] = (char)0xff;
1529     TempLen++;
1530     }
1531     }
1532    
1533     Full = OutBuffSize-cv->OutBuffCount-TempLen < 0;
1534     if (! Full) {
1535     i++;
1536     CommRawOut(cv,TempStr,TempLen);
1537     }
1538     } // end of while {}
1539    
1540     return i;
1541     }
1542    
1543     int FAR PASCAL CommBinaryEcho(PComVar cv, PCHAR B, int C)
1544     {
1545     int a, i, Len;
1546     char d[3];
1547    
1548     if ( ! cv->Ready )
1549     return C;
1550    
1551     if ( (cv->InPtr>0) && (cv->InBuffCount>0) ) {
1552     memmove(cv->InBuff,&(cv->InBuff[cv->InPtr]),cv->InBuffCount);
1553     cv->InPtr = 0;
1554     }
1555    
1556     i = 0;
1557     a = 1;
1558     while ((a>0) && (i<C)) {
1559     Len = 0;
1560    
1561     d[Len] = B[i];
1562     Len++;
1563    
1564     if ( cv->TelFlag && (B[i]=='\x0d') &&
1565     ! cv->TelBinSend ) {
1566     d[Len] = 0x00;
1567     Len++;
1568     }
1569    
1570     if ( cv->TelFlag && (B[i]=='\xff') ) {
1571     d[Len] = '\xff';
1572     Len++;
1573     }
1574    
1575     if ( InBuffSize-cv->InBuffCount-Len >=0 ) {
1576     memcpy(&(cv->InBuff[cv->InBuffCount]),d,Len);
1577     cv->InBuffCount = cv->InBuffCount + Len;
1578     a = 1;
1579     }
1580     else
1581     a = 0;
1582     i = i + a;
1583     }
1584     return i;
1585     }
1586    
1587     int FAR PASCAL TextEchoJP(PComVar cv, PCHAR B, int C)
1588     {
1589     int i, TempLen;
1590     WORD K;
1591     char TempStr[11];
1592     int EchoCodeNew;
1593     BYTE d;
1594     BOOL Full, KanjiFlagNew;
1595    
1596     Full = FALSE;
1597     i = 0;
1598     while (! Full && (i < C)) {
1599     TempLen = 0;
1600     d = (BYTE)B[i];
1601     EchoCodeNew = cv->EchoCode;
1602    
1603     if (cv->EchoKanjiFlag) {
1604     KanjiFlagNew = FALSE;
1605     EchoCodeNew = IdKanji;
1606    
1607     K = (cv->EchoKanjiFirst << 8) + d;
1608     // UTF-8への変換を行う。1〜3バイトまでの対応なので注意。
1609     if (cv->KanjiCodeSend == IdUTF8) {
1610     OutputTextUTF8(K, TempStr, &TempLen, cv);
1611     }
1612     else {
1613     if (cv->KanjiCodeEcho == IdEUC)
1614     K = SJIS2EUC(K);
1615     else if (cv->KanjiCodeEcho != IdSJIS)
1616     K = SJIS2JIS(K);
1617    
1618     if ((cv->EchoCode==IdKatakana) &&
1619     (cv->KanjiCodeEcho==IdJIS) &&
1620     (cv->JIS7KatakanaEcho==1)) {
1621     TempStr[TempLen] = SI;
1622     TempLen++;
1623     }
1624    
1625     TempStr[TempLen] = HIBYTE(K);
1626     TempStr[TempLen+1] = LOBYTE(K);
1627     TempLen = TempLen + 2;
1628     }
1629     }
1630     else if (IsDBCSLeadByteEx(*cv->CodePage, d)) {
1631     KanjiFlagNew = TRUE;
1632     cv->EchoKanjiFirst = d;
1633     EchoCodeNew = IdKanji;
1634    
1635     if ((cv->EchoCode!=IdKanji) &&
1636     (cv->KanjiCodeEcho==IdJIS)) {
1637     TempStr[0] = 0x1B;
1638     TempStr[1] = '$';
1639     if (cv->KanjiIn == IdKanjiInB)
1640     TempStr[2] = 'B';
1641     else
1642     TempStr[2] = '@';
1643     TempLen = 3;
1644     }
1645     else
1646     TempLen = 0;
1647     }
1648     else {
1649     KanjiFlagNew = FALSE;
1650    
1651     if ((cv->EchoCode==IdKanji) &&
1652     (cv->KanjiCodeEcho==IdJIS)) {
1653     TempStr[0] = 0x1B;
1654     TempStr[1] = '(';
1655     switch (cv->KanjiOut) {
1656     case IdKanjiOutJ:
1657     TempStr[2] = 'J';
1658     break;
1659     case IdKanjiOutH:
1660     TempStr[2] = 'H';
1661     break;
1662     default:
1663     TempStr[2] = 'B';
1664     }
1665     TempLen = 3;
1666     }
1667     else
1668     TempLen = 0;
1669    
1670     if ((0xa0<d) && (d<0xe0)) {
1671     EchoCodeNew = IdKatakana;
1672     if ((cv->EchoCode!=IdKatakana) &&
1673     (cv->KanjiCodeEcho==IdJIS) &&
1674     (cv->JIS7KatakanaEcho==1)) {
1675     TempStr[TempLen] = SO;
1676     TempLen++;
1677     }
1678     }
1679     else {
1680     EchoCodeNew = IdASCII;
1681     if ((cv->EchoCode==IdKatakana) &&
1682     (cv->KanjiCodeEcho==IdJIS) &&
1683     (cv->JIS7KatakanaEcho==1)) {
1684     TempStr[TempLen] = SI;
1685     TempLen++;
1686     }
1687     }
1688    
1689     if (d==0x0d) {
1690     TempStr[TempLen] = 0x0d;
1691     TempLen++;
1692     if (cv->CRSend==IdCRLF) {
1693     TempStr[TempLen] = 0x0a;
1694     TempLen++;
1695     }
1696     else if ((cv->CRSend==IdCR) &&
1697     cv->TelFlag && ! cv->TelBinSend) {
1698     TempStr[TempLen] = 0;
1699     TempLen++;
1700     }
1701     }
1702     else if ((d>=0xa1) && (d<=0xe0)) {
1703     /* Katakana */
1704     if (cv->KanjiCodeEcho==IdEUC) {
1705     TempStr[TempLen] = (char)0x8E;
1706     TempLen++;
1707     }
1708     if ((cv->KanjiCodeEcho==IdJIS) &&
1709     (cv->JIS7KatakanaEcho==1))
1710     TempStr[TempLen] = d & 0x7f;
1711     else
1712     TempStr[TempLen] = d;
1713     TempLen++;
1714     }
1715     else {
1716     TempStr[TempLen] = d;
1717     TempLen++;
1718     if (cv->TelFlag && (d==0xff)) {
1719     TempStr[TempLen] = (char)0xff;
1720     TempLen++;
1721     }
1722     }
1723     } // if (cv->SendKanjiFlag) else if ... else ... end
1724    
1725     if (TempLen == 0) {
1726     i++;
1727     cv->EchoCode = EchoCodeNew;
1728     cv->EchoKanjiFlag = KanjiFlagNew;
1729     }
1730     else {
1731     Full = InBuffSize-cv->InBuffCount-TempLen < 0;
1732     if (! Full) {
1733     i++;
1734     cv->EchoCode = EchoCodeNew;
1735     cv->EchoKanjiFlag = KanjiFlagNew;
1736     memcpy(&(cv->InBuff[cv->InBuffCount]),TempStr,TempLen);
1737     cv->InBuffCount = cv->InBuffCount + TempLen;
1738     }
1739     }
1740    
1741     } // end of "while {}"
1742    
1743     return i;
1744     }
1745    
1746     int FAR PASCAL CommTextEcho(PComVar cv, PCHAR B, int C)
1747     {
1748     int i, TempLen;
1749     char TempStr[11];
1750     BYTE d;
1751     BOOL Full;
1752    
1753     if ( ! cv->Ready )
1754     return C;
1755    
1756     if ( (cv->InPtr>0) && (cv->InBuffCount>0) ) {
1757     memmove(cv->InBuff,&(cv->InBuff[cv->InPtr]),cv->InBuffCount);
1758     cv->InPtr = 0;
1759     }
1760    
1761     if (cv->Language==IdJapanese)
1762     return TextEchoJP(cv,B,C);
1763    
1764     Full = FALSE;
1765     i = 0;
1766     while (! Full && (i < C)) {
1767     TempLen = 0;
1768     d = (BYTE)B[i];
1769    
1770     if (d==0x0d) {
1771     TempStr[TempLen] = 0x0d;
1772     TempLen++;
1773     if (cv->CRSend==IdCRLF) {
1774     TempStr[TempLen] = 0x0a;
1775     TempLen++;
1776     }
1777     else if ((cv->CRSend==IdCR) &&
1778     cv->TelFlag && ! cv->TelBinSend) {
1779     TempStr[TempLen] = 0;
1780     TempLen++;
1781     }
1782     }
1783     else {
1784     if ((cv->Language==IdRussian) &&
1785     (d>=128))
1786     d = RussConv(cv->RussClient,cv->RussHost,d);
1787     TempStr[TempLen] = d;
1788     TempLen++;
1789     if (cv->TelFlag && (d==0xff)) {
1790     TempStr[TempLen] = (char)0xff;
1791     TempLen++;
1792     }
1793     }
1794    
1795     Full = InBuffSize-cv->InBuffCount-TempLen < 0;
1796     if (! Full) {
1797     i++;
1798     memcpy(&(cv->InBuff[cv->InBuffCount]),TempStr,TempLen);
1799     cv->InBuffCount = cv->InBuffCount + TempLen;
1800     }
1801     } // end of while {}
1802    
1803     return i;
1804     }
1805    
1806     // listup serial port driver
1807     // cf. http://www.codeproject.com/system/setupdi.asp?df=100&forumid=4368&exp=0&select=479661
1808     // (2007.8.17 yutaka)
1809     static void ListupSerialPort(LPWORD ComPortTable, int comports, char **ComPortDesc, int ComPortMax)
1810     {
1811     GUID ClassGuid[1];
1812     DWORD dwRequiredSize;
1813     BOOL bRet;
1814     HDEVINFO DeviceInfoSet = NULL;
1815     SP_DEVINFO_DATA DeviceInfoData;
1816     DWORD dwMemberIndex = 0;
1817     int i;
1818    
1819     DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
1820    
1821     // 以前のメモリをフリーしておく
1822     for (i = 0 ; i < ComPortMax ; i++) {
1823     free(ComPortDesc[i]);
1824     ComPortDesc[i] = NULL;
1825     }
1826    
1827     // Get ClassGuid from ClassName for PORTS class
1828     bRet =
1829     SetupDiClassGuidsFromName(_T("PORTS"), (LPGUID) & ClassGuid, 1,
1830     &dwRequiredSize);
1831     if (!bRet)
1832     goto cleanup;
1833    
1834     // Get class devices
1835     // COMポート番号を強制付け替えした場合に、現在のものではなく、レジストリに残っている
1836     // 古いFriendlyNameが表示されてしまう問題への対処。(2007.11.8 yutaka)
1837     DeviceInfoSet =
1838     SetupDiGetClassDevs(&ClassGuid[0], NULL, NULL, DIGCF_PRESENT | DIGCF_PROFILE);
1839    
1840     if (DeviceInfoSet) {
1841     // Enumerate devices
1842     dwMemberIndex = 0;
1843     while (SetupDiEnumDeviceInfo
1844     (DeviceInfoSet, dwMemberIndex++, &DeviceInfoData)) {
1845     TCHAR szFriendlyName[MAX_PATH];
1846     TCHAR szPortName[MAX_PATH];
1847     //TCHAR szMessage[MAX_PATH];
1848     DWORD dwReqSize = 0;
1849     DWORD dwPropType;
1850     DWORD dwType = REG_SZ;
1851     HKEY hKey = NULL;
1852    
1853     // Get friendlyname
1854     bRet = SetupDiGetDeviceRegistryProperty(DeviceInfoSet,
1855     &DeviceInfoData,
1856     SPDRP_FRIENDLYNAME,
1857     &dwPropType,
1858     (LPBYTE)
1859     szFriendlyName,
1860     sizeof(szFriendlyName),
1861     &dwReqSize);
1862    
1863     // Open device parameters reg key
1864     hKey = SetupDiOpenDevRegKey(DeviceInfoSet,
1865     &DeviceInfoData,
1866     DICS_FLAG_GLOBAL,
1867     0, DIREG_DEV, KEY_READ);
1868     if (hKey) {
1869     // Qurey for portname
1870     long lRet;
1871     dwReqSize = sizeof(szPortName);
1872     lRet = RegQueryValueEx(hKey,
1873     _T("PortName"),
1874     0,
1875     &dwType,
1876     (LPBYTE) & szPortName,
1877     &dwReqSize);
1878    
1879     // Close reg key
1880     RegCloseKey(hKey);
1881     }
1882    
1883     #if 0
1884     sprintf(szMessage, _T("Name: %s\nPort: %s\n"), szFriendlyName,
1885     szPortName);
1886     printf("%s\n", szMessage);
1887     #endif
1888    
1889     if (_strnicmp(szPortName, "COM", 3) == 0) { // COMポートドライバを発見
1890     int port = atoi(&szPortName[3]);
1891     int i;
1892    
1893     for (i = 0 ; i < comports ; i++) {
1894     if (ComPortTable[i] == port) { // 接続を確認
1895     ComPortDesc[i] = _strdup(szFriendlyName);
1896     break;
1897     }
1898     }
1899     }
1900    
1901     }
1902     }
1903    
1904     cleanup:
1905     // Destroy device info list
1906     SetupDiDestroyDeviceInfoList(DeviceInfoSet);
1907     }
1908    
1909    
1910     int PASCAL DetectComPorts(LPWORD ComPortTable, int ComPortMax, char **ComPortDesc)
1911     {
1912     HMODULE h;
1913     TCHAR devicesBuff[65535];
1914     TCHAR *p;
1915     int comports = 0;
1916     int i, j, min;
1917     WORD s;
1918    
1919     if (((h = GetModuleHandle("kernel32.dll")) != NULL) &&
1920     (GetProcAddress(h, "QueryDosDeviceA") != NULL) &&
1921     (QueryDosDevice(NULL, devicesBuff, 65535) != 0)) {
1922     p = devicesBuff;
1923     while (*p != '\0') {
1924     if (strncmp(p, "COM", 3) == 0 && p[3] != '\0') {
1925     ComPortTable[comports++] = atoi(p+3);
1926     if (comports >= ComPortMax)
1927     break;
1928     }
1929     p += (strlen(p)+1);
1930     }
1931    
1932     for (i=0; i<comports-1; i++) {
1933     min = i;
1934     for (j=i+1; j<comports; j++)
1935     if (ComPortTable[min] > ComPortTable[j])
1936     min = j;
1937     if (min != i) {
1938     s = ComPortTable[i];
1939     ComPortTable[i] = ComPortTable[min];
1940     ComPortTable[min] = s;
1941     }
1942     }
1943     }
1944     else {
1945     #if 1
1946     for (i=1; i<=ComPortMax; i++) {
1947     FILE *fp;
1948     char buf[11]; // \\.\COMxxx + NULL
1949     _snprintf_s(buf, sizeof(buf), _TRUNCATE, "\\\\.\\COM%d", i);
1950     if ((fp = fopen(buf, "r")) != NULL) {
1951     fclose(fp);
1952     ComPortTable[comports++] = i;
1953     }
1954     }
1955     #else
1956     comports = -1;
1957     #endif
1958     }
1959    
1960     ListupSerialPort(ComPortTable, comports, ComPortDesc, ComPortMax);
1961    
1962     return comports;
1963     }
1964    
1965     BOOL WINAPI DllMain(HANDLE hInstance,
1966     ULONG ul_reason_for_call,
1967     LPVOID lpReserved)
1968     {
1969     switch( ul_reason_for_call ) {
1970     case DLL_THREAD_ATTACH:
1971     /* do thread initialization */
1972     break;
1973     case DLL_THREAD_DETACH:
1974     /* do thread cleanup */
1975     break;
1976     case DLL_PROCESS_ATTACH:
1977     /* do process initialization */
1978 maya 2663 DoCover_IsDebuggerPresent();
1979 maya 2476 hInst = hInstance;
1980     HMap = CreateFileMapping(
1981     (HANDLE) 0xFFFFFFFF, NULL, PAGE_READWRITE,
1982     0, sizeof(TMap), TT_FILEMAPNAME);
1983     if (HMap == NULL)
1984     return FALSE;
1985     FirstInstance = (GetLastError() != ERROR_ALREADY_EXISTS);
1986    
1987     pm = (PMap)MapViewOfFile(HMap,FILE_MAP_WRITE,0,0,0);
1988     if (pm == NULL)
1989     return FALSE;
1990     break;
1991     case DLL_PROCESS_DETACH:
1992     /* do process cleanup */
1993     UnmapViewOfFile(pm);
1994     CloseHandle(HMap);
1995     break;
1996     }
1997     return TRUE;
1998     }
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
About OSDN
Find Software
Develop Software
Help