Develop and Download Open Source Software

Browse Subversion Repository

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 3462 - (show 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 /* 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 #include <locale.h>
18
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 else {
77 return FALSE;
78 }
79 }
80
81 void PASCAL FAR ChangeDefaultSet(PTTSet ts, PKeyMap km)
82 {
83 if ((ts!=NULL) &&
84 (_stricmp(ts->SetupFName, pm->ts.SetupFName) == 0)) {
85 memcpy(&(pm->ts),ts,sizeof(TTTSet));
86 }
87 if (km!=NULL) {
88 memcpy(&(pm->km),km,sizeof(TKeyMap));
89 }
90 }
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 if (KeyMap==NULL) {
104 KeyMap = &(pm->km);
105 }
106 Key = IdKeyMax;
107 while ((Key>0) && (KeyMap->Map[Key-1] != Scan)) {
108 Key--;
109 }
110 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 if (KeyMap==NULL) {
122 KeyMap = &(pm->km);
123 }
124
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 if (pm->NWin==1) {
792 return 1;
793 }
794 else {
795 return (int)(SendMessage(pm->WinList[pm->NWin-2],
796 WM_USER_GETSERIALNO,0,0)+1);
797 }
798 }
799
800 void FAR PASCAL UnregWin(HWND HWin)
801 {
802 int i, j;
803
804 i = 0;
805 while ((i<pm->NWin) && (pm->WinList[i]!=HWin)) {
806 i++;
807 }
808 if (pm->WinList[i]!=HWin) {
809 return;
810 }
811 for (j=i ; j<pm->NWin-1 ; j++) {
812 pm->WinList[j] = pm->WinList[j+1];
813 }
814 if (pm->NWin>0) {
815 pm->NWin--;
816 }
817 }
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 if (i>8) {
846 i = pm->NWin;
847 }
848 }
849 else {
850 UnregWin(Hw);
851 }
852 }
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 if (Hw==HWin) {
877 SendDlgItemMessage(HDlg, IList, LB_SETCURSEL, i,0);
878 }
879 }
880 else {
881 UnregWin(Hw);
882 }
883 }
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 while ((i<pm->NWin) && (pm->WinList[i]!=HWin)) {
900 i++;
901 }
902 if (pm->WinList[i]!=HWin) {
903 return;
904 }
905 i = i + Next;
906 if (i >= pm->NWin) {
907 i = 0;
908 }
909 else if (i<0) {
910 i = pm->NWin-1;
911 }
912 SelectWin(i);
913 }
914
915 HWND FAR PASCAL GetNthWin(int n)
916 {
917 if (n<pm->NWin) {
918 return pm->WinList[n];
919 }
920 else {
921 return NULL;
922 }
923 }
924
925 int FAR PASCAL CommReadRawByte(PComVar cv, LPBYTE b)
926 {
927 if ( ! cv->Ready ) {
928 return 0;
929 }
930
931 if ( cv->InBuffCount>0 ) {
932 *b = cv->InBuff[cv->InPtr];
933 cv->InPtr++;
934 cv->InBuffCount--;
935 if ( cv->InBuffCount==0 ) {
936 cv->InPtr = 0;
937 }
938 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 if ( ! cv->Ready ) {
949 return;
950 }
951
952 if (cv->InPtr == 0) {
953 memmove(&(cv->InBuff[1]),&(cv->InBuff[0]),cv->InBuffCount);
954 }
955 else {
956 cv->InPtr--;
957 }
958 cv->InBuff[cv->InPtr] = b;
959 cv->InBuffCount++;
960
961 if (cv->HBinBuf!=0 ) {
962 cv->BinSkip++;
963 }
964 }
965
966 void Log1Bin(PComVar cv, BYTE b)
967 {
968 if (((cv->FilePause & OpLog)!=0) || cv->ProtoFlag) {
969 return;
970 }
971 if (cv->BinSkip > 0) {
972 cv->BinSkip--;
973 return;
974 }
975 cv->BinBuf[cv->BinPtr] = b;
976 cv->BinPtr++;
977 if (cv->BinPtr>=InBuffSize) {
978 cv->BinPtr = cv->BinPtr-InBuffSize;
979 }
980 if (cv->BCount>=InBuffSize) {
981 cv->BCount = InBuffSize;
982 cv->BStart = cv->BinPtr;
983 }
984 else {
985 cv->BCount++;
986 }
987 }
988
989 int FAR PASCAL CommRead1Byte(PComVar cv, LPBYTE b)
990 {
991 int c;
992
993 if ( ! cv->Ready ) {
994 return 0;
995 }
996
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 (cv->BCount>=InBuffSize-10)) {
1009 return 0;
1010 }
1011
1012 if ( cv->TelMode ) {
1013 c = 0;
1014 }
1015 else {
1016 c = CommReadRawByte(cv,b);
1017 }
1018
1019 if ((c==1) && cv->TelCRFlag) {
1020 cv->TelCRFlag = FALSE;
1021 if (*b==0) {
1022 c = 0;
1023 }
1024 }
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 if ( cv->HBinBuf!=0 ) {
1033 cv->BinSkip--;
1034 }
1035 c = 0;
1036 }
1037 }
1038 else if ((cv->PortType==IdTCPIP) && (*b==0xFF)) {
1039 if (!cv->TelFlag && cv->TelAutoDetect) { /* TTPLUG */
1040 cv->TelFlag = TRUE;
1041 }
1042 if (cv->TelFlag) {
1043 cv->IACFlag = TRUE;
1044 c = 0;
1045 }
1046 }
1047 else if (cv->TelFlag && ! cv->TelBinRecv && (*b==0x0D)) {
1048 cv->TelCRFlag = TRUE;
1049 }
1050 }
1051
1052 if ( (c==1) && (cv->HBinBuf!=0) ) {
1053 Log1Bin(cv, *b);
1054 }
1055
1056 return c;
1057 }
1058
1059 int FAR PASCAL CommRawOut(PComVar cv, PCHAR B, int C)
1060 {
1061 int a;
1062
1063 if ( ! cv->Ready ) {
1064 return C;
1065 }
1066
1067 if (C > OutBuffSize - cv->OutBuffCount) {
1068 a = OutBuffSize - cv->OutBuffCount;
1069 }
1070 else {
1071 a = C;
1072 }
1073 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 if ( ! cv->Ready ) {
1088 return C;
1089 }
1090
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 else {
1115 a = 0;
1116 }
1117
1118 i = i + a;
1119 }
1120 return i;
1121 }
1122
1123 static int OutputTextUTF8(WORD K, char *TempStr, PComVar cv)
1124 {
1125 unsigned int code;
1126 int outlen;
1127 int TempLen = 0;
1128
1129 code = SJIS2UTF8(K, &outlen, cv->Locale);
1130 switch (outlen) {
1131 case 4:
1132 TempStr[TempLen++] = (code >> 24) & 0xff;
1133 case 3:
1134 TempStr[TempLen++] = (code >> 16) & 0xff;
1135 case 2:
1136 TempStr[TempLen++] = (code >> 8) & 0xff;
1137 case 1:
1138 TempStr[TempLen++] = code & 0xff;
1139 }
1140
1141 return TempLen;
1142 }
1143
1144 //
1145 // MBCSから各種漢字コードへ変換して出力する。
1146 //
1147 int TextOutMBCS(PComVar cv, PCHAR B, int C)
1148 {
1149 int i, TempLen;
1150 WORD K;
1151 char TempStr[12];
1152 int SendCodeNew;
1153 BYTE d;
1154 BOOL Full, KanjiFlagNew;
1155 _locale_t locale;
1156
1157 locale = _create_locale(LC_ALL, cv->Locale);
1158
1159 Full = FALSE;
1160 i = 0;
1161 while (! Full && (i < C)) {
1162 TempLen = 0;
1163 d = (BYTE)B[i];
1164 SendCodeNew = cv->SendCode;
1165 KanjiFlagNew = FALSE;
1166
1167 if (cv->SendKanjiFlag) {
1168 SendCodeNew = IdKanji;
1169
1170 K = (cv->SendKanjiFirst << 8) + d;
1171
1172 // UTF-8への変換を行う。1〜3バイトまでの対応なので注意。
1173 if (cv->KanjiCodeSend == IdUTF8 || cv->Language == IdUtf8) {
1174 TempLen += OutputTextUTF8(K, TempStr, cv);
1175 }
1176 else {
1177 switch (cv->Language) {
1178 case IdJapanese:
1179 switch (cv->KanjiCodeSend) {
1180 case IdEUC:
1181 K = SJIS2EUC(K);
1182 break;
1183 case IdJIS:
1184 K = SJIS2JIS(K);
1185 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 }
1194 break;
1195 case IdKorean:
1196 break;
1197 }
1198 TempStr[TempLen++] = HIBYTE(K);
1199 TempStr[TempLen++] = LOBYTE(K);
1200 }
1201 }
1202 else if (_isleadbyte_l(d, locale)) {
1203 KanjiFlagNew = TRUE;
1204 cv->SendKanjiFirst = d;
1205 SendCodeNew = IdKanji;
1206
1207 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 }
1219 }
1220 }
1221 else {
1222 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 TempStr[2] = 'J';
1229 break;
1230 case IdKanjiOutH:
1231 TempStr[2] = 'H';
1232 break;
1233 default:
1234 TempStr[2] = 'B';
1235 }
1236 TempLen = 3;
1237 }
1238
1239 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 }
1247 else {
1248 SendCodeNew = IdASCII;
1249 if ((cv->SendCode==IdKatakana) &&
1250 (cv->KanjiCodeSend==IdJIS) &&
1251 (cv->JIS7KatakanaSend==1)) {
1252 TempStr[TempLen++] = SI;
1253 }
1254 }
1255 }
1256
1257 if (d==0x0d) {
1258 TempStr[TempLen++] = 0x0d;
1259 if (cv->CRSend==IdCRLF) {
1260 TempStr[TempLen++] = 0x0a;
1261 }
1262 else if ((cv->CRSend==IdCR) &&
1263 cv->TelFlag && ! cv->TelBinSend) {
1264 TempStr[TempLen++] = 0;
1265 }
1266 }
1267 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 /* Katakana */
1272 if (cv->KanjiCodeSend==IdEUC) {
1273 TempStr[TempLen++] = (char)SS2;
1274 }
1275 if ((cv->KanjiCodeSend==IdJIS) &&
1276 (cv->JIS7KatakanaSend==1)) {
1277 TempStr[TempLen++] = d & 0x7f;
1278 }
1279 else {
1280 TempStr[TempLen++] = d;
1281 }
1282 }
1283 else {
1284 TempStr[TempLen++] = d;
1285 if (cv->TelFlag && (d==0xff)) {
1286 TempStr[TempLen++] = (char)0xff;
1287 }
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 _free_locale(locale);
1309
1310 return i;
1311 }
1312
1313 int FAR PASCAL CommTextOut(PComVar cv, PCHAR B, int C)
1314 {
1315 int i, TempLen;
1316 char TempStr[12];
1317 BYTE d;
1318 BOOL Full;
1319
1320 if (! cv->Ready ) {
1321 return C;
1322 }
1323
1324 switch (cv->Language) {
1325 case IdUtf8:
1326 case IdJapanese:
1327 case IdKorean:
1328 return TextOutMBCS(cv, B, C);
1329 break;
1330 }
1331
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 TempStr[TempLen++] = 0x0a;
1343 }
1344 else if (cv->CRSend==IdCR && cv->TelFlag && ! cv->TelBinSend) {
1345 TempStr[TempLen++] = 0;
1346 }
1347 }
1348 else {
1349 if ((cv->Language==IdRussian) && (d>=128)) {
1350 d = RussConv(cv->RussClient,cv->RussHost,d);
1351 }
1352 TempStr[TempLen++] = d;
1353 if (cv->TelFlag && (d==0xff)) {
1354 TempStr[TempLen++] = (char)0xff;
1355 }
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 int FAR PASCAL TextEchoMBCS(PComVar cv, PCHAR B, int C)
1413 {
1414 int i, TempLen;
1415 WORD K;
1416 char TempStr[12];
1417 int EchoCodeNew;
1418 BYTE d;
1419 BOOL Full, KanjiFlagNew;
1420 _locale_t locale;
1421
1422 locale = _create_locale(LC_ALL, cv->Locale);
1423
1424 Full = FALSE;
1425 i = 0;
1426 while (! Full && (i < C)) {
1427 TempLen = 0;
1428 d = (BYTE)B[i];
1429 EchoCodeNew = cv->EchoCode;
1430 KanjiFlagNew = FALSE;
1431
1432 if (cv->EchoKanjiFlag) {
1433 EchoCodeNew = IdKanji;
1434
1435 K = (cv->EchoKanjiFirst << 8) + d;
1436
1437 // UTF-8への変換を行う。1〜3バイトまでの対応なので注意。
1438 if (cv->KanjiCodeEcho == IdUTF8 || cv->Language==IdUtf8) {
1439 TempLen += OutputTextUTF8(K, TempStr, cv);
1440 }
1441 else {
1442 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 }
1463 TempStr[TempLen++] = HIBYTE(K);
1464 TempStr[TempLen++] = LOBYTE(K);
1465 }
1466 }
1467 else if (_isleadbyte_l(d, locale)) {
1468 KanjiFlagNew = TRUE;
1469 cv->EchoKanjiFirst = d;
1470 EchoCodeNew = IdKanji;
1471
1472 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 }
1484 }
1485 }
1486 else {
1487 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 TempStr[2] = 'J';
1494 break;
1495 case IdKanjiOutH:
1496 TempStr[2] = 'H';
1497 break;
1498 default:
1499 TempStr[2] = 'B';
1500 }
1501 TempLen = 3;
1502 }
1503
1504 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 }
1512 else {
1513 EchoCodeNew = IdASCII;
1514 if ((cv->EchoCode==IdKatakana) &&
1515 (cv->KanjiCodeEcho==IdJIS) &&
1516 (cv->JIS7KatakanaEcho==1)) {
1517 TempStr[TempLen++] = SI;
1518 }
1519 }
1520 }
1521
1522 if (d==0x0d) {
1523 TempStr[TempLen++] = 0x0d;
1524 if (cv->CRSend==IdCRLF) {
1525 TempStr[TempLen++] = 0x0a;
1526 }
1527 else if ((cv->CRSend==IdCR) &&
1528 cv->TelFlag && ! cv->TelBinSend) {
1529 TempStr[TempLen++] = 0;
1530 }
1531 }
1532 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 /* Katakana */
1537 if (cv->KanjiCodeEcho==IdEUC) {
1538 TempStr[TempLen++] = (char)SS2;
1539 }
1540 if ((cv->KanjiCodeEcho==IdJIS) &&
1541 (cv->JIS7KatakanaEcho==1)) {
1542 TempStr[TempLen++] = d & 0x7f;
1543 }
1544 else {
1545 TempStr[TempLen++] = d;
1546 }
1547 }
1548 else {
1549 TempStr[TempLen++] = d;
1550 if (cv->TelFlag && (d==0xff)) {
1551 TempStr[TempLen++] = (char)0xff;
1552 }
1553 }
1554 } // if (cv->EchoKanjiFlag) else if ... else ... end
1555
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 _free_locale(locale);
1575
1576 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 if ( ! cv->Ready ) {
1587 return C;
1588 }
1589
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 switch (cv->Language) {
1596 case IdUtf8:
1597 case IdJapanese:
1598 case IdKorean:
1599 return TextEchoMBCS(cv,B,C);
1600 break;
1601 }
1602
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 TempStr[TempLen++] = 0x0a;
1614 }
1615 else if (cv->CRSend==IdCR && cv->TelFlag && ! cv->TelBinSend) {
1616 TempStr[TempLen++] = 0;
1617 }
1618 }
1619 else {
1620 if ((cv->Language==IdRussian) && (d>=128)) {
1621 d = RussConv(cv->RussClient,cv->RussHost,d);
1622 }
1623 TempStr[TempLen++] = d;
1624 if (cv->TelFlag && (d==0xff)) {
1625 TempStr[TempLen++] = (char)0xff;
1626 }
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 if (!bRet) {
1666 goto cleanup;
1667 }
1668
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 (DeviceInfoSet, dwMemberIndex++, &DeviceInfoData)) {
1680 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 cleanup:
1740 // 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 for (j=i+1; j<comports; j++) {
1770 if (ComPortTable[min] > ComPortTable[j]) {
1771 min = j;
1772 }
1773 }
1774 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 HMap = CreateFileMapping((HANDLE) 0xFFFFFFFF, NULL, PAGE_READWRITE,
1818 0, sizeof(TMap), TT_FILEMAPNAME);
1819 if (HMap == NULL) {
1820 return FALSE;
1821 }
1822 FirstInstance = (GetLastError() != ERROR_ALREADY_EXISTS);
1823
1824 pm = (PMap)MapViewOfFile(HMap,FILE_MAP_WRITE,0,0,0);
1825 if (pm == NULL) {
1826 return FALSE;
1827 }
1828 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