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 3926 - (hide annotations) (download) (as text)
Mon Jun 7 14:01:51 2010 UTC (13 years, 10 months ago) by yutakapon
File MIME type: text/x-csrc
File size: 45058 byte(s) 
以下に示す UTF-8 送信処理を、純粋なUnicodeとして処理するようにした。

　・IME入力
　・クリップボードの貼り付け

teraterm.iniに PureUTF8 エントリを追加。当該処理の on/off を切り替えられる。
デフォルトはまだ off とする。

これにより、SNOWMAN(U+2603)などの文字を送信しても、正しいUTF-8エンコーディングとして、
サーバへ送信される。
ただし、サロゲートペアには未対応。
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 doda 3462 _locale_t locale;
1231 maya 3227
1232 doda 3462 locale = _create_locale(LC_ALL, cv->Locale);
1233    
1234 maya 3227 Full = FALSE;
1235     i = 0;
1236     while (! Full && (i < C)) {
1237     TempLen = 0;
1238     d = (BYTE)B[i];
1239     SendCodeNew = cv->SendCode;
1240 doda 3442 KanjiFlagNew = FALSE;
1241 maya 3227
1242     if (cv->SendKanjiFlag) {
1243     SendCodeNew = IdKanji;
1244    
1245     K = (cv->SendKanjiFirst << 8) + d;
1246    
1247     // UTF-8への変換を行う。1〜3バイトまでの対応なので注意。
1248 doda 3408 if (cv->KanjiCodeSend == IdUTF8 || cv->Language == IdUtf8) {
1249 doda 3442 TempLen += OutputTextUTF8(K, TempStr, cv);
1250     }
1251     else {
1252     switch (cv->Language) {
1253     case IdJapanese:
1254     switch (cv->KanjiCodeSend) {
1255     case IdEUC:
1256 doda 3419 K = SJIS2EUC(K);
1257 doda 3442 break;
1258     case IdJIS:
1259 doda 3419 K = SJIS2JIS(K);
1260 doda 3442 if ((cv->SendCode==IdKatakana) &&
1261     (cv->JIS7KatakanaSend==1)) {
1262     TempStr[TempLen++] = SI;
1263     }
1264     break;
1265     case IdSJIS:
1266     /* nothing to do */
1267     break;
1268 doda 3419 }
1269 doda 3442 break;
1270     case IdKorean:
1271     break;
1272 maya 3227 }
1273 doda 3442 TempStr[TempLen++] = HIBYTE(K);
1274     TempStr[TempLen++] = LOBYTE(K);
1275 maya 3227 }
1276     }
1277 doda 3462 else if (_isleadbyte_l(d, locale)) {
1278 maya 3227 KanjiFlagNew = TRUE;
1279     cv->SendKanjiFirst = d;
1280     SendCodeNew = IdKanji;
1281    
1282 doda 3442 if (cv->Language == IdJapanese) {
1283     if ((cv->SendCode!=IdKanji) && (cv->KanjiCodeSend==IdJIS)) {
1284     TempStr[0] = 0x1B;
1285     TempStr[1] = '$';
1286     if (cv->KanjiIn == IdKanjiInB) {
1287     TempStr[2] = 'B';
1288     }
1289     else {
1290     TempStr[2] = '@';
1291     }
1292     TempLen = 3;
1293 maya 3392 }
1294 maya 3227 }
1295     }
1296     else {
1297 doda 3442 if (cv->Language == IdJapanese) {
1298     if ((cv->SendCode==IdKanji) && (cv->KanjiCodeSend==IdJIS)) {
1299     TempStr[0] = 0x1B;
1300     TempStr[1] = '(';
1301     switch (cv->KanjiOut) {
1302     case IdKanjiOutJ:
1303 maya 3409 TempStr[2] = 'J';
1304     break;
1305 doda 3442 case IdKanjiOutH:
1306 maya 3409 TempStr[2] = 'H';
1307     break;
1308 doda 3442 default:
1309 maya 3409 TempStr[2] = 'B';
1310 doda 3442 }
1311     TempLen = 3;
1312 maya 3227 }
1313    
1314 doda 3442 if ((0xa0<d) && (d<0xe0)) {
1315     SendCodeNew = IdKatakana;
1316     if ((cv->SendCode!=IdKatakana) &&
1317     (cv->KanjiCodeSend==IdJIS) &&
1318     (cv->JIS7KatakanaSend==1)) {
1319     TempStr[TempLen++] = SO;
1320     }
1321 maya 3227 }
1322 doda 3442 else {
1323     SendCodeNew = IdASCII;
1324     if ((cv->SendCode==IdKatakana) &&
1325     (cv->KanjiCodeSend==IdJIS) &&
1326     (cv->JIS7KatakanaSend==1)) {
1327     TempStr[TempLen++] = SI;
1328     }
1329 maya 3227 }
1330     }
1331    
1332 doda 3497 if (d==CR) {
1333 doda 3442 TempStr[TempLen++] = 0x0d;
1334 maya 3227 if (cv->CRSend==IdCRLF) {
1335 doda 3442 TempStr[TempLen++] = 0x0a;
1336 maya 3227 }
1337     else if ((cv->CRSend==IdCR) &&
1338 doda 3398 cv->TelFlag && ! cv->TelBinSend) {
1339 doda 3442 TempStr[TempLen++] = 0;
1340 maya 3227 }
1341 doda 3494 if (cv->TelLineMode) {
1342     cv->Flush = TRUE;
1343     }
1344 maya 3227 }
1345 doda 3497 else if (d==BS) {
1346     if (cv->TelLineMode) {
1347     if (cv->FlushLen < cv->LineModeBuffCount) {
1348     cv->LineModeBuffCount--;
1349     }
1350     }
1351     else {
1352     TempStr[TempLen++] = d;
1353     }
1354     }
1355 doda 3498 else if (d==0x15) { // Ctrl-U
1356     if (cv->TelLineMode) {
1357     cv->LineModeBuffCount = cv->FlushLen;
1358     }
1359     else {
1360     TempStr[TempLen++] = d;
1361     }
1362     }
1363 doda 3442 else if ((d>=0x80) && (cv->KanjiCodeSend==IdUTF8 || cv->Language==IdUtf8)) {
1364     TempLen += OutputTextUTF8((WORD)d, TempStr, cv);
1365     }
1366     else if ((d>=0xa1) && (d<=0xe0) && (cv->Language == IdJapanese)) {
1367 doda 3452 /* Katakana */
1368 maya 3227 if (cv->KanjiCodeSend==IdEUC) {
1369 doda 3444 TempStr[TempLen++] = (char)SS2;
1370 maya 3227 }
1371     if ((cv->KanjiCodeSend==IdJIS) &&
1372 maya 3392 (cv->JIS7KatakanaSend==1)) {
1373 doda 3442 TempStr[TempLen++] = d & 0x7f;
1374 maya 3392 }
1375     else {
1376 doda 3442 TempStr[TempLen++] = d;
1377 maya 3392 }
1378 maya 3227 }
1379     else {
1380 doda 3442 TempStr[TempLen++] = d;
1381 maya 3227 if (cv->TelFlag && (d==0xff)) {
1382 doda 3442 TempStr[TempLen++] = (char)0xff;
1383 maya 3227 }
1384     }
1385     } // if (cv->SendKanjiFlag) else if ... else ... end
1386    
1387 doda 3494 if (cv->TelLineMode) {
1388     if (TempLen == 0) {
1389     i++;
1390     cv->SendCode = SendCodeNew;
1391     cv->SendKanjiFlag = KanjiFlagNew;
1392     }
1393     else {
1394     Full = OutBuffSize - cv->LineModeBuffCount - TempLen < 0;
1395     if (!Full) {
1396     i++;
1397     cv->SendCode = SendCodeNew;
1398     cv->SendKanjiFlag = KanjiFlagNew;
1399     memcpy(&(cv->LineModeBuff[cv->LineModeBuffCount]), TempStr, TempLen);
1400     cv->LineModeBuffCount += TempLen;
1401     if (cv->Flush) {
1402     cv->FlushLen = cv->LineModeBuffCount;
1403     }
1404     }
1405     }
1406     if (cv->FlushLen > 0) {
1407     OutLen = CommRawOut(cv, cv->LineModeBuff, cv->FlushLen);
1408     cv->FlushLen -= OutLen;
1409     cv->LineModeBuffCount -= OutLen;
1410     memmove(cv->LineModeBuff, &(cv->LineModeBuff[OutLen]), cv->LineModeBuffCount);
1411     }
1412     cv->Flush = FALSE;
1413 maya 3227 }
1414     else {
1415 doda 3494 if (TempLen == 0) {
1416 maya 3227 i++;
1417     cv->SendCode = SendCodeNew;
1418     cv->SendKanjiFlag = KanjiFlagNew;
1419     }
1420 doda 3494 else {
1421     Full = OutBuffSize-cv->OutBuffCount-TempLen < 0;
1422     if (! Full) {
1423     i++;
1424     cv->SendCode = SendCodeNew;
1425     cv->SendKanjiFlag = KanjiFlagNew;
1426     CommRawOut(cv,TempStr,TempLen);
1427     }
1428     }
1429 maya 3227 }
1430    
1431     } // end of "while {}"
1432    
1433 doda 3462 _free_locale(locale);
1434    
1435 maya 3227 return i;
1436     }
1437    
1438     int FAR PASCAL CommTextOut(PComVar cv, PCHAR B, int C)
1439     {
1440 doda 3494 int i, TempLen, OutLen;
1441 doda 3442 char TempStr[12];
1442 maya 3227 BYTE d;
1443     BOOL Full;
1444    
1445 maya 3392 if (! cv->Ready ) {
1446 maya 3227 return C;
1447 maya 3392 }
1448 maya 3227
1449 yutakapon 3926 if (in_cv_utf(cv->pureutf8, cv->Language)) {
1450     // fall through
1451    
1452     } else {
1453     switch (cv->Language) {
1454     case IdUtf8:
1455     case IdJapanese:
1456     case IdKorean:
1457     return TextOutMBCS(cv, B, C);
1458     break;
1459     }
1460 maya 3392 }
1461 maya 3227
1462     Full = FALSE;
1463     i = 0;
1464     while (! Full && (i < C)) {
1465     TempLen = 0;
1466     d = (BYTE)B[i];
1467    
1468 doda 3497 switch (d) {
1469     case CR:
1470 maya 3227 TempStr[TempLen] = 0x0d;
1471     TempLen++;
1472     if (cv->CRSend==IdCRLF) {
1473 doda 3452 TempStr[TempLen++] = 0x0a;
1474 maya 3227 }
1475 doda 3452 else if (cv->CRSend==IdCR && cv->TelFlag && ! cv->TelBinSend) {
1476     TempStr[TempLen++] = 0;
1477 maya 3227 }
1478 doda 3494 if (cv->TelLineMode) {
1479     cv->Flush = TRUE;
1480     }
1481 doda 3497 break;
1482    
1483     case BS:
1484     if (cv->TelLineMode) {
1485     if (cv->FlushLen < cv->LineModeBuffCount) {
1486     cv->LineModeBuffCount--;
1487     }
1488     }
1489     else {
1490     TempStr[TempLen++] = d;
1491     }
1492     break;
1493    
1494 doda 3498 case 0x15: // Ctrl-U
1495     if (cv->TelLineMode) {
1496     cv->LineModeBuffCount = cv->FlushLen;
1497     }
1498     else {
1499     TempStr[TempLen++] = d;
1500     }
1501 doda 3504 break;
1502 doda 3498
1503 doda 3497 default:
1504 doda 3452 if ((cv->Language==IdRussian) && (d>=128)) {
1505 doda 3494 d = RussConv(cv->RussClient, cv->RussHost, d);
1506 doda 3452 }
1507     TempStr[TempLen++] = d;
1508 maya 3227 if (cv->TelFlag && (d==0xff)) {
1509 doda 3452 TempStr[TempLen++] = (char)0xff;
1510 maya 3227 }
1511     }
1512    
1513 doda 3494 if (cv->TelLineMode) {
1514     Full = OutBuffSize - cv->LineModeBuffCount - TempLen < 0;
1515     if (!Full) {
1516 doda 3888 i++;
1517 doda 3494 memcpy(&(cv->LineModeBuff[cv->LineModeBuffCount]), TempStr, TempLen);
1518     cv->LineModeBuffCount += TempLen;
1519     if (cv->Flush) {
1520     cv->FlushLen = cv->LineModeBuffCount;
1521     }
1522     }
1523     if (cv->FlushLen > 0) {
1524     OutLen = CommRawOut(cv, cv->LineModeBuff, cv->FlushLen);
1525     cv->FlushLen -= OutLen;
1526     cv->LineModeBuffCount -= OutLen;
1527     memmove(cv->LineModeBuff, &(cv->LineModeBuff[OutLen]), cv->LineModeBuffCount);
1528     }
1529     cv->Flush = FALSE;
1530 maya 3227 }
1531 doda 3494 else {
1532     Full = OutBuffSize - cv->OutBuffCount - TempLen < 0;
1533     if (! Full) {
1534     i++;
1535     CommRawOut(cv,TempStr,TempLen);
1536     }
1537     }
1538 maya 3227 } // end of while {}
1539    
1540     return i;
1541     }
1542    
1543     int FAR PASCAL CommBinaryEcho(PComVar cv, PCHAR B, int C)
1544     {
1545     int a, i, Len;
1546     char d[3];
1547    
1548     if ( ! cv->Ready )
1549     return C;
1550    
1551     if ( (cv->InPtr>0) && (cv->InBuffCount>0) ) {
1552     memmove(cv->InBuff,&(cv->InBuff[cv->InPtr]),cv->InBuffCount);
1553     cv->InPtr = 0;
1554     }
1555    
1556     i = 0;
1557     a = 1;
1558     while ((a>0) && (i<C)) {
1559     Len = 0;
1560    
1561     d[Len] = B[i];
1562     Len++;
1563    
1564     if ( cv->TelFlag && (B[i]=='\x0d') &&
1565     ! cv->TelBinSend ) {
1566     d[Len] = 0x00;
1567     Len++;
1568     }
1569    
1570     if ( cv->TelFlag && (B[i]=='\xff') ) {
1571     d[Len] = '\xff';
1572     Len++;
1573     }
1574    
1575     if ( InBuffSize-cv->InBuffCount-Len >=0 ) {
1576     memcpy(&(cv->InBuff[cv->InBuffCount]),d,Len);
1577     cv->InBuffCount = cv->InBuffCount + Len;
1578     a = 1;
1579     }
1580     else
1581     a = 0;
1582     i = i + a;
1583     }
1584     return i;
1585     }
1586    
1587 doda 3458 int FAR PASCAL TextEchoMBCS(PComVar cv, PCHAR B, int C)
1588 maya 3227 {
1589     int i, TempLen;
1590     WORD K;
1591 doda 3452 char TempStr[12];
1592 maya 3227 int EchoCodeNew;
1593     BYTE d;
1594     BOOL Full, KanjiFlagNew;
1595 doda 3462 _locale_t locale;
1596 maya 3227
1597 doda 3462 locale = _create_locale(LC_ALL, cv->Locale);
1598    
1599 maya 3227 Full = FALSE;
1600     i = 0;
1601     while (! Full && (i < C)) {
1602     TempLen = 0;
1603     d = (BYTE)B[i];
1604     EchoCodeNew = cv->EchoCode;
1605 doda 3452 KanjiFlagNew = FALSE;
1606 maya 3227
1607     if (cv->EchoKanjiFlag) {
1608     EchoCodeNew = IdKanji;
1609    
1610     K = (cv->EchoKanjiFirst << 8) + d;
1611 doda 3452
1612 maya 3227 // UTF-8への変換を行う。1〜3バイトまでの対応なので注意。
1613 doda 3452 if (cv->KanjiCodeEcho == IdUTF8 || cv->Language==IdUtf8) {
1614 doda 3442 TempLen += OutputTextUTF8(K, TempStr, cv);
1615 maya 3227 }
1616     else {
1617 doda 3452 switch (cv->Language) {
1618     case IdJapanese:
1619     switch (cv->KanjiCodeEcho) {
1620     case IdEUC:
1621     K = SJIS2EUC(K);
1622     break;
1623     case IdJIS:
1624     K = SJIS2JIS(K);
1625     if ((cv->EchoCode==IdKatakana) &&
1626     (cv->JIS7KatakanaEcho==1)) {
1627     TempStr[TempLen++] = SI;
1628     }
1629     break;
1630     case IdSJIS:
1631     /* nothing to do */
1632     break;
1633     }
1634     break;
1635     case IdKorean:
1636     break;
1637 maya 3392 }
1638 doda 3452 TempStr[TempLen++] = HIBYTE(K);
1639     TempStr[TempLen++] = LOBYTE(K);
1640 maya 3227 }
1641     }
1642 doda 3462 else if (_isleadbyte_l(d, locale)) {
1643 maya 3227 KanjiFlagNew = TRUE;
1644     cv->EchoKanjiFirst = d;
1645     EchoCodeNew = IdKanji;
1646    
1647 doda 3452 if (cv->Language == IdJapanese) {
1648     if ((cv->EchoCode!=IdKanji) && (cv->KanjiCodeEcho==IdJIS)) {
1649     TempStr[0] = 0x1B;
1650     TempStr[1] = '$';
1651     if (cv->KanjiIn == IdKanjiInB) {
1652     TempStr[2] = 'B';
1653     }
1654     else {
1655     TempStr[2] = '@';
1656     }
1657     TempLen = 3;
1658 maya 3392 }
1659 maya 3227 }
1660     }
1661     else {
1662 doda 3452 if (cv->Language == IdJapanese) {
1663     if ((cv->EchoCode==IdKanji) && (cv->KanjiCodeEcho==IdJIS)) {
1664     TempStr[0] = 0x1B;
1665     TempStr[1] = '(';
1666     switch (cv->KanjiOut) {
1667     case IdKanjiOutJ:
1668 maya 3227 TempStr[2] = 'J';
1669     break;
1670 doda 3452 case IdKanjiOutH:
1671 maya 3227 TempStr[2] = 'H';
1672     break;
1673 doda 3452 default:
1674 maya 3227 TempStr[2] = 'B';
1675 doda 3452 }
1676     TempLen = 3;
1677 maya 3227 }
1678    
1679 doda 3452 if ((0xa0<d) && (d<0xe0)) {
1680     EchoCodeNew = IdKatakana;
1681     if ((cv->EchoCode!=IdKatakana) &&
1682     (cv->KanjiCodeEcho==IdJIS) &&
1683     (cv->JIS7KatakanaEcho==1)) {
1684     TempStr[TempLen++] = SO;
1685     }
1686 maya 3227 }
1687 doda 3452 else {
1688     EchoCodeNew = IdASCII;
1689     if ((cv->EchoCode==IdKatakana) &&
1690     (cv->KanjiCodeEcho==IdJIS) &&
1691     (cv->JIS7KatakanaEcho==1)) {
1692     TempStr[TempLen++] = SI;
1693     }
1694 maya 3227 }
1695     }
1696    
1697 doda 3503 if (d==CR) {
1698 doda 3452 TempStr[TempLen++] = 0x0d;
1699 maya 3227 if (cv->CRSend==IdCRLF) {
1700 doda 3452 TempStr[TempLen++] = 0x0a;
1701 maya 3227 }
1702     else if ((cv->CRSend==IdCR) &&
1703 maya 3392 cv->TelFlag && ! cv->TelBinSend) {
1704 doda 3452 TempStr[TempLen++] = 0;
1705 maya 3227 }
1706     }
1707 doda 3503 else if (d==0x15) { // Ctrl-U
1708     if (cv->TelLineMode) {
1709     // Move to top of line (CHA "\033[G") and erase line (EL "\033[K")
1710     strncpy_s(TempStr, sizeof(TempStr), "\033[G\033[K", _TRUNCATE);
1711     TempLen += 6;
1712     }
1713     else {
1714     TempStr[TempLen++] = d;
1715     }
1716     }
1717 doda 3452 else if ((d>=0x80) && (cv->KanjiCodeEcho==IdUTF8 || cv->Language==IdUtf8)) {
1718     TempLen += OutputTextUTF8((WORD)d, TempStr, cv);
1719     }
1720     else if ((d>=0xa1) && (d<=0xe0) && (cv->Language == IdJapanese)) {
1721 maya 3227 /* Katakana */
1722     if (cv->KanjiCodeEcho==IdEUC) {
1723 doda 3452 TempStr[TempLen++] = (char)SS2;
1724 maya 3227 }
1725     if ((cv->KanjiCodeEcho==IdJIS) &&
1726 maya 3392 (cv->JIS7KatakanaEcho==1)) {
1727 doda 3452 TempStr[TempLen++] = d & 0x7f;
1728 maya 3392 }
1729     else {
1730 doda 3452 TempStr[TempLen++] = d;
1731 maya 3392 }
1732 maya 3227 }
1733     else {
1734 doda 3452 TempStr[TempLen++] = d;
1735 maya 3227 if (cv->TelFlag && (d==0xff)) {
1736 doda 3452 TempStr[TempLen++] = (char)0xff;
1737 maya 3227 }
1738     }
1739 doda 3452 } // if (cv->EchoKanjiFlag) else if ... else ... end
1740 maya 3227
1741     if (TempLen == 0) {
1742     i++;
1743     cv->EchoCode = EchoCodeNew;
1744     cv->EchoKanjiFlag = KanjiFlagNew;
1745     }
1746     else {
1747     Full = InBuffSize-cv->InBuffCount-TempLen < 0;
1748     if (! Full) {
1749     i++;
1750     cv->EchoCode = EchoCodeNew;
1751     cv->EchoKanjiFlag = KanjiFlagNew;
1752     memcpy(&(cv->InBuff[cv->InBuffCount]),TempStr,TempLen);
1753     cv->InBuffCount = cv->InBuffCount + TempLen;
1754     }
1755     }
1756    
1757     } // end of "while {}"
1758    
1759 doda 3462 _free_locale(locale);
1760    
1761 maya 3227 return i;
1762     }
1763    
1764     int FAR PASCAL CommTextEcho(PComVar cv, PCHAR B, int C)
1765     {
1766     int i, TempLen;
1767     char TempStr[11];
1768     BYTE d;
1769     BOOL Full;
1770    
1771 maya 3392 if ( ! cv->Ready ) {
1772 maya 3227 return C;
1773 maya 3392 }
1774 maya 3227
1775     if ( (cv->InPtr>0) && (cv->InBuffCount>0) ) {
1776     memmove(cv->InBuff,&(cv->InBuff[cv->InPtr]),cv->InBuffCount);
1777     cv->InPtr = 0;
1778     }
1779    
1780 doda 3452 switch (cv->Language) {
1781     case IdUtf8:
1782     case IdJapanese:
1783     case IdKorean:
1784 doda 3458 return TextEchoMBCS(cv,B,C);
1785 doda 3452 break;
1786 doda 3438 }
1787 maya 3227
1788     Full = FALSE;
1789     i = 0;
1790     while (! Full && (i < C)) {
1791     TempLen = 0;
1792     d = (BYTE)B[i];
1793    
1794 doda 3503 switch (d) {
1795     case CR:
1796 maya 3227 TempStr[TempLen] = 0x0d;
1797     TempLen++;
1798     if (cv->CRSend==IdCRLF) {
1799 doda 3452 TempStr[TempLen++] = 0x0a;
1800 maya 3227 }
1801 doda 3452 else if (cv->CRSend==IdCR && cv->TelFlag && ! cv->TelBinSend) {
1802     TempStr[TempLen++] = 0;
1803 maya 3227 }
1804 doda 3503 break;
1805    
1806     case 0x15: // Ctrl-U
1807     if (cv->TelLineMode) {
1808     // Move to top of line (CHA "\033[G") and erase line (EL "\033[K")
1809     strncpy_s(TempStr, sizeof(TempStr), "\033[G\033[K", _TRUNCATE);
1810     TempLen += 6;
1811     }
1812     else {
1813     TempStr[TempLen++] = d;
1814     }
1815     break;
1816    
1817     default:
1818 doda 3452 if ((cv->Language==IdRussian) && (d>=128)) {
1819 maya 3227 d = RussConv(cv->RussClient,cv->RussHost,d);
1820 maya 3392 }
1821 doda 3452 TempStr[TempLen++] = d;
1822 maya 3227 if (cv->TelFlag && (d==0xff)) {
1823 doda 3452 TempStr[TempLen++] = (char)0xff;
1824 maya 3227 }
1825     }
1826    
1827     Full = InBuffSize-cv->InBuffCount-TempLen < 0;
1828     if (! Full) {
1829     i++;
1830     memcpy(&(cv->InBuff[cv->InBuffCount]),TempStr,TempLen);
1831     cv->InBuffCount = cv->InBuffCount + TempLen;
1832     }
1833     } // end of while {}
1834    
1835     return i;
1836     }
1837    
1838     // listup serial port driver
1839     // cf. http://www.codeproject.com/system/setupdi.asp?df=100&forumid=4368&exp=0&select=479661
1840     // (2007.8.17 yutaka)
1841     static void ListupSerialPort(LPWORD ComPortTable, int comports, char **ComPortDesc, int ComPortMax)
1842     {
1843     GUID ClassGuid[1];
1844     DWORD dwRequiredSize;
1845     BOOL bRet;
1846     HDEVINFO DeviceInfoSet = NULL;
1847     SP_DEVINFO_DATA DeviceInfoData;
1848     DWORD dwMemberIndex = 0;
1849     int i;
1850    
1851     DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
1852    
1853     // 以前のメモリをフリーしておく
1854     for (i = 0 ; i < ComPortMax ; i++) {
1855     free(ComPortDesc[i]);
1856     ComPortDesc[i] = NULL;
1857     }
1858    
1859     // Get ClassGuid from ClassName for PORTS class
1860     bRet =
1861     SetupDiClassGuidsFromName(_T("PORTS"), (LPGUID) & ClassGuid, 1,
1862     &dwRequiredSize);
1863 maya 3392 if (!bRet) {
1864 maya 3227 goto cleanup;
1865 maya 3392 }
1866 maya 3227
1867     // Get class devices
1868     // COMポート番号を強制付け替えした場合に、現在のものではなく、レジストリに残っている
1869     // 古いFriendlyNameが表示されてしまう問題への対処。(2007.11.8 yutaka)
1870     DeviceInfoSet =
1871     SetupDiGetClassDevs(&ClassGuid[0], NULL, NULL, DIGCF_PRESENT | DIGCF_PROFILE);
1872    
1873     if (DeviceInfoSet) {
1874     // Enumerate devices
1875     dwMemberIndex = 0;
1876     while (SetupDiEnumDeviceInfo
1877 maya 3392 (DeviceInfoSet, dwMemberIndex++, &DeviceInfoData)) {
1878 maya 3227 TCHAR szFriendlyName[MAX_PATH];
1879     TCHAR szPortName[MAX_PATH];
1880     //TCHAR szMessage[MAX_PATH];
1881     DWORD dwReqSize = 0;
1882     DWORD dwPropType;
1883     DWORD dwType = REG_SZ;
1884     HKEY hKey = NULL;
1885    
1886     // Get friendlyname
1887     bRet = SetupDiGetDeviceRegistryProperty(DeviceInfoSet,
1888     &DeviceInfoData,
1889     SPDRP_FRIENDLYNAME,
1890     &dwPropType,
1891     (LPBYTE)
1892     szFriendlyName,
1893     sizeof(szFriendlyName),
1894     &dwReqSize);
1895    
1896     // Open device parameters reg key
1897     hKey = SetupDiOpenDevRegKey(DeviceInfoSet,
1898     &DeviceInfoData,
1899     DICS_FLAG_GLOBAL,
1900     0, DIREG_DEV, KEY_READ);
1901     if (hKey) {
1902     // Qurey for portname
1903     long lRet;
1904     dwReqSize = sizeof(szPortName);
1905     lRet = RegQueryValueEx(hKey,
1906     _T("PortName"),
1907     0,
1908     &dwType,
1909     (LPBYTE) & szPortName,
1910     &dwReqSize);
1911    
1912     // Close reg key
1913     RegCloseKey(hKey);
1914     }
1915    
1916     #if 0
1917     sprintf(szMessage, _T("Name: %s\nPort: %s\n"), szFriendlyName,
1918     szPortName);
1919     printf("%s\n", szMessage);
1920     #endif
1921    
1922     if (_strnicmp(szPortName, "COM", 3) == 0) { // COMポートドライバを発見
1923     int port = atoi(&szPortName[3]);
1924     int i;
1925    
1926     for (i = 0 ; i < comports ; i++) {
1927     if (ComPortTable[i] == port) { // 接続を確認
1928     ComPortDesc[i] = _strdup(szFriendlyName);
1929     break;
1930     }
1931     }
1932     }
1933    
1934     }
1935     }
1936    
1937 maya 3392 cleanup:
1938 maya 3227 // Destroy device info list
1939     SetupDiDestroyDeviceInfoList(DeviceInfoSet);
1940     }
1941    
1942    
1943     int PASCAL DetectComPorts(LPWORD ComPortTable, int ComPortMax, char **ComPortDesc)
1944     {
1945     HMODULE h;
1946     TCHAR devicesBuff[65535];
1947     TCHAR *p;
1948     int comports = 0;
1949     int i, j, min;
1950     WORD s;
1951    
1952     if (((h = GetModuleHandle("kernel32.dll")) != NULL) &&
1953     (GetProcAddress(h, "QueryDosDeviceA") != NULL) &&
1954     (QueryDosDevice(NULL, devicesBuff, 65535) != 0)) {
1955     p = devicesBuff;
1956     while (*p != '\0') {
1957     if (strncmp(p, "COM", 3) == 0 && p[3] != '\0') {
1958     ComPortTable[comports++] = atoi(p+3);
1959     if (comports >= ComPortMax)
1960     break;
1961     }
1962     p += (strlen(p)+1);
1963     }
1964    
1965     for (i=0; i<comports-1; i++) {
1966     min = i;
1967 maya 3392 for (j=i+1; j<comports; j++) {
1968     if (ComPortTable[min] > ComPortTable[j]) {
1969 maya 3227 min = j;
1970 maya 3392 }
1971     }
1972 maya 3227 if (min != i) {
1973     s = ComPortTable[i];
1974     ComPortTable[i] = ComPortTable[min];
1975     ComPortTable[min] = s;
1976     }
1977     }
1978     }
1979     else {
1980     #if 1
1981     for (i=1; i<=ComPortMax; i++) {
1982     FILE *fp;
1983 maya 3707 char buf[12]; // \\.\COMxxxx + NULL
1984 maya 3227 _snprintf_s(buf, sizeof(buf), _TRUNCATE, "\\\\.\\COM%d", i);
1985     if ((fp = fopen(buf, "r")) != NULL) {
1986     fclose(fp);
1987     ComPortTable[comports++] = i;
1988     }
1989     }
1990     #else
1991     comports = -1;
1992     #endif
1993     }
1994    
1995     ListupSerialPort(ComPortTable, comports, ComPortDesc, ComPortMax);
1996    
1997     return comports;
1998     }
1999    
2000     BOOL WINAPI DllMain(HANDLE hInstance,
2001     ULONG ul_reason_for_call,
2002     LPVOID lpReserved)
2003     {
2004     switch( ul_reason_for_call ) {
2005     case DLL_THREAD_ATTACH:
2006     /* do thread initialization */
2007     break;
2008     case DLL_THREAD_DETACH:
2009     /* do thread cleanup */
2010     break;
2011     case DLL_PROCESS_ATTACH:
2012     /* do process initialization */
2013     DoCover_IsDebuggerPresent();
2014     hInst = hInstance;
2015 maya 3392 HMap = CreateFileMapping((HANDLE) 0xFFFFFFFF, NULL, PAGE_READWRITE,
2016     0, sizeof(TMap), TT_FILEMAPNAME);
2017     if (HMap == NULL) {
2018 maya 3227 return FALSE;
2019 maya 3392 }
2020 maya 3227 FirstInstance = (GetLastError() != ERROR_ALREADY_EXISTS);
2021    
2022     pm = (PMap)MapViewOfFile(HMap,FILE_MAP_WRITE,0,0,0);
2023 maya 3392 if (pm == NULL) {
2024 maya 3227 return FALSE;
2025 maya 3392 }
2026 maya 3227 break;
2027     case DLL_PROCESS_DETACH:
2028     /* do process cleanup */
2029     UnmapViewOfFile(pm);
2030     CloseHandle(HMap);
2031     break;
2032     }
2033     return TRUE;
2034     }
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
About OSDN
Find Software
Develop Software
Help