Develop and Download Open Source Software

Browse Subversion Repository

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 3462 - (hide annotations) (download) (as text)
Wed Jun 10 03:28:31 2009 UTC (14 years, 10 months ago) by doda
File MIME type: text/x-csrc
File size: 40385 byte(s)
IsDBCSLeadByteEx を _isleadbyte_l に置き換え。
Locale/CodePage の対応があっているならば動作に近いがないので問題ないはず。
これによって CodePage の設定は使われなくなる。

動作の違いの確認は以下のコードで行った。

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <ctype.h>
#include <locale.h>

void leadbyte_test(char *locale_str, unsigned int codepage) {
	_locale_t locale;
	int i;

	printf("testing %s(%d)\n", locale_str, codepage);
	locale = _create_locale(LC_ALL, locale_str);

	for (i=0; i<256; i++) {
		if ((_isleadbyte_l(i, locale)!=0) != (IsDBCSLeadByteEx(codepage, i)!=0)) {
			printf("%02x: Fail\n", i);
		}
	}

	_free_locale(locale);
}

int main(void) {
	leadbyte_test("Japanese", 932);
	leadbyte_test("Korean", 949);
	leadbyte_test("cht", 950);
	leadbyte_test("chs", 936);
	leadbyte_test("english", 1252);

	return 0;
}

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

Back to OSDN">Back to OSDN
ViewVC Help
Powered by ViewVC 1.1.26