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