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