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 3888 - (hide annotations) (download) (as text)
Fri May 14 12:28:55 2010 UTC (13 years, 11 months ago) by doda
File MIME type: text/x-csrc
File size: 44897 byte(s) 
英語モードおよびロシア語モードで、"Line at a time" モードが正しく働かないのを修正。
http://logmett.com/forum/viewtopic.php?f=8&t=1389

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