![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to map3270.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / ucb / tn3270 / ascii|
Return to map3270.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / ucb / tn3270 / ascii |
1.1 root 1: /*
2: * Copyright (c) 1988 Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms are permitted
6: * provided that this notice is preserved and that due credit is given
7: * to the University of California at Berkeley. The name of the University
8: * may not be used to endorse or promote products derived from this
9: * software without specific prior written permission. This software
10: * is provided ``as is'' without express or implied warranty.
11: */
12:
13: #ifndef lint
14: static char sccsid[] = "@(#)map3270.c 3.2 (Berkeley) 3/28/88";
15: #endif /* not lint */
16:
17: /* This program reads a description file, somewhat like /etc/termcap,
18: that describes the mapping between the current terminal's keyboard and
19: a 3270 keyboard.
20: */
21: #ifdef DOCUMENTATION_ONLY
22: /* here is a sample (very small) entry...
23:
24: # this table is sensitive to position on a line. In particular,
25: # a terminal definition for a terminal is terminated whenever a
26: # (non-comment) line beginning in column one is found.
27: #
28: # this is an entry to map tvi924 to 3270 keys...
29: v8|tvi924|924|televideo model 924 {
30: pfk1 = '\E1';
31: pfk2 = '\E2';
32: clear = '^z'; # clear the screen
33: }
34: */
35: #endif /* DOCUMENTATION_ONLY */
36:
37: #include <stdio.h>
38: #include <ctype.h>
39: #if defined(unix)
40: #include <strings.h>
41: #else /* defined(unix) */
42: #include <string.h>
43: #endif /* defined(unix) */
44:
45: #define IsPrint(c) ((isprint(c) && !isspace(c)) || ((c) == ' '))
46:
47: #include "state.h"
48:
49: #include "../general/globals.h"
50: #include "map3270.ext"
51:
52: /* this is the list of types returned by the lex processor */
53: #define LEX_CHAR 400 /* plain unadorned character */
54: #define LEX_ESCAPED LEX_CHAR+1 /* escaped with \ */
55: #define LEX_CARETED LEX_ESCAPED+1 /* escaped with ^ */
56: #define LEX_END_OF_FILE LEX_CARETED+1 /* end of file encountered */
57: #define LEX_ILLEGAL LEX_END_OF_FILE+1 /* trailing escape character */
58:
59: /* the following is part of our character set dependancy... */
60: #define ESCAPE 0x1b
61: #define TAB 0x09
62: #define NEWLINE 0x0a
63: #define CARRIAGE_RETURN 0x0d
64:
65: typedef struct {
66: int type; /* LEX_* - type of character */
67: int value; /* character this was */
68: } lexicon;
69:
70: typedef struct {
71: int length; /* length of character string */
72: char array[500]; /* character string */
73: } stringWithLength;
74:
75: #define panic(s) { fprintf(stderr, s); exit(1); }
76:
77: static state firstentry = { 0, STATE_NULL, 0, 0 };
78: static state *headOfQueue = &firstentry;
79:
80: /* the following is a primitive adm3a table, to be used when nothing
81: * else seems to be avaliable.
82: */
83:
84: #ifdef DEBUG
85: static int debug = 0; /* debug flag (for debuggin tables) */
86: #endif /* DEBUG */
87:
88: static int (*GetTc)();
89: static int doPaste = 1; /* should we have side effects */
90: static int picky = 0; /* do we complain of unknown functions? */
91: static char usePointer = 0; /* use pointer, or file */
92: static FILE *ourFile= 0;
93: static char *environPointer = 0;/* if non-zero, point to input
94: * string in core.
95: */
96: static char **whichkey = 0;
97: static char *keysgeneric[] = {
98: #include "default.map" /* Define the default default */
99:
100: 0, /* Terminate list of entries */
101: };
102: ;
103:
104: static int Empty = 1, /* is the unget lifo empty? */
105: Full = 0; /* is the unget lifo full? */
106: static lexicon lifo[200] = { 0 }; /* character stack for parser */
107: static int rp = 0, /* read pointer into lifo */
108: wp = 0; /* write pointer into lifo */
109:
110: static int
111: GetC()
112: {
113: int character;
114:
115: if (usePointer) {
116: if ((*environPointer) == 0) {
117: /*
118: * If we have reached the end of this string, go on to
119: * the next (if there is a next).
120: */
121: if (whichkey == 0) {
122: static char suffix = 'A'; /* From environment */
123: char envname[9];
124: extern char *getenv();
125:
126: (void) sprintf(envname, "MAP3270%c", suffix++);
127: environPointer = getenv(envname);
128: } else {
129: whichkey++; /* default map */
130: environPointer = *whichkey;
131: }
132: }
133: if (*environPointer) {
134: character = 0xff&*environPointer++;
135: } else {
136: character = EOF;
137: }
138: } else {
139: character = getc(ourFile);
140: }
141: return(character);
142: }
143:
144: static lexicon
145: Get()
146: {
147: lexicon c;
148: register lexicon *pC = &c;
149: register int character;
150:
151: if (!Empty) {
152: *pC = lifo[rp];
153: rp++;
154: if (rp == sizeof lifo/sizeof (lexicon)) {
155: rp = 0;
156: }
157: if (rp == wp) {
158: Empty = 1;
159: }
160: Full = 0;
161: } else {
162: character = GetC();
163: switch (character) {
164: case EOF:
165: pC->type = LEX_END_OF_FILE;
166: break;
167: case '^':
168: character = GetC();
169: if (!IsPrint(character)) {
170: pC->type = LEX_ILLEGAL;
171: } else {
172: pC->type = LEX_CARETED;
173: if (character == '?') {
174: character |= 0x40; /* rubout */
175: } else {
176: character &= 0x1f;
177: }
178: }
179: break;
180: case '\\':
181: character = GetC();
182: if (!IsPrint(character)) {
183: pC->type = LEX_ILLEGAL;
184: } else {
185: pC->type = LEX_ESCAPED;
186: switch (character) {
187: case 'E': case 'e':
188: character = ESCAPE;
189: break;
190: case 't':
191: character = TAB;
192: break;
193: case 'n':
194: character = NEWLINE;
195: break;
196: case 'r':
197: character = CARRIAGE_RETURN;
198: break;
199: default:
200: pC->type = LEX_ILLEGAL;
201: break;
202: }
203: }
204: break;
205: default:
206: if ((IsPrint(character)) || isspace(character)) {
207: pC->type = LEX_CHAR;
208: } else {
209: pC->type = LEX_ILLEGAL;
210: }
211: break;
212: }
213: pC->value = character;
214: }
215: return(*pC);
216: }
217:
218: static void
219: UnGet(c)
220: lexicon c; /* character to unget */
221: {
222: if (Full) {
223: fprintf(stderr, "attempt to put too many characters in lifo\n");
224: panic("map3270");
225: /* NOTREACHED */
226: } else {
227: lifo[wp] = c;
228: wp++;
229: if (wp == sizeof lifo/sizeof (lexicon)) {
230: wp = 0;
231: }
232: if (wp == rp) {
233: Full = 1;
234: }
235: Empty = 0;
236: }
237: }
238:
239: /*
240: * Construct a control character sequence
241: * for a special character.
242: */
243: char *
244: uncontrol(c)
245: register int c;
246: {
247: static char buf[3];
248:
249: if (c == 0x7f)
250: return ("^?");
251: if (c == '\377') {
252: return "-1";
253: }
254: if (c >= 0x20) {
255: buf[0] = c;
256: buf[1] = 0;
257: } else {
258: buf[0] = '^';
259: buf[1] = '@'+c;
260: buf[2] = 0;
261: }
262: return (buf);
263: }
264:
265: /* compare two strings, ignoring case */
266:
267: ustrcmp(string1, string2)
268: register char *string1;
269: register char *string2;
270: {
271: register int c1, c2;
272:
273: while ((c1 = (unsigned char) *string1++) != 0) {
274: if (isupper(c1)) {
275: c1 = tolower(c1);
276: }
277: if (isupper(c2 = (unsigned char) *string2++)) {
278: c2 = tolower(c2);
279: }
280: if (c1 < c2) {
281: return(-1);
282: } else if (c1 > c2) {
283: return(1);
284: }
285: }
286: if (*string2) {
287: return(-1);
288: } else {
289: return(0);
290: }
291: }
292:
293:
294: static stringWithLength *
295: GetQuotedString()
296: {
297: lexicon lex;
298: static stringWithLength output = { 0 }; /* where return value is held */
299: char *pointer = output.array;
300:
301: lex = Get();
302: if ((lex.type != LEX_CHAR) || (lex.value != '\'')) {
303: UnGet(lex);
304: return(0);
305: }
306: while (1) {
307: lex = Get();
308: if ((lex.type == LEX_CHAR) && (lex.value == '\'')) {
309: break;
310: }
311: if ((lex.type == LEX_CHAR) && !IsPrint(lex.value)) {
312: UnGet(lex);
313: return(0); /* illegal character in quoted string */
314: }
315: if (pointer >= output.array+sizeof output.array) {
316: return(0); /* too long */
317: }
318: *pointer++ = lex.value;
319: }
320: output.length = pointer-output.array;
321: return(&output);
322: }
323:
324: #ifdef NOTUSED
325: static stringWithLength *
326: GetCharString()
327: {
328: lexicon lex;
329: static stringWithLength output;
330: char *pointer = output.array;
331:
332: lex = Get();
333:
334: while ((lex.type == LEX_CHAR) &&
335: !isspace(lex.value) && (lex.value != '=')) {
336: *pointer++ = lex.value;
337: lex = Get();
338: if (pointer >= output.array + sizeof output.array) {
339: return(0); /* too long */
340: }
341: }
342: UnGet(lex);
343: output.length = pointer-output.array;
344: return(&output);
345: }
346: #endif /* NOTUSED */
347:
348: static
349: GetCharacter(character)
350: int character; /* desired character */
351: {
352: lexicon lex;
353:
354: lex = Get();
355:
356: if ((lex.type != LEX_CHAR) || (lex.value != character)) {
357: UnGet(lex);
358: return(0);
359: }
360: return(1);
361: }
362:
363: #ifdef NOTUSED
364: static
365: GetString(string)
366: char *string; /* string to get */
367: {
368: lexicon lex;
369:
370: while (*string) {
371: lex = Get();
372: if ((lex.type != LEX_CHAR) || (lex.value != *string&0xff)) {
373: UnGet(lex);
374: return(0); /* XXX restore to state on entry */
375: }
376: string++;
377: }
378: return(1);
379: }
380: #endif /* NOTUSED */
381:
382:
383: static stringWithLength *
384: GetAlphaMericString()
385: {
386: lexicon lex;
387: static stringWithLength output = { 0 };
388: char *pointer = output.array;
389: # define IsAlnum(c) (isalnum(c) || (c == '_') \
390: || (c == '-') || (c == '.'))
391:
392: lex = Get();
393:
394: if ((lex.type != LEX_CHAR) || !IsAlnum(lex.value)) {
395: UnGet(lex);
396: return(0);
397: }
398:
399: while ((lex.type == LEX_CHAR) && IsAlnum(lex.value)) {
400: *pointer++ = lex.value;
401: lex = Get();
402: }
403: UnGet(lex);
404: *pointer = 0;
405: output.length = pointer-output.array;
406: return(&output);
407: }
408:
409:
410: /* eat up characters until a new line, or end of file. returns terminating
411: character.
412: */
413:
414: static lexicon
415: EatToNL()
416: {
417: lexicon lex;
418:
419: lex = Get();
420:
421: while (!((lex.type != LEX_ESCAPED) && (lex.type != LEX_CARETED) &&
422: (lex.value == '\n')) && (!(lex.type == LEX_END_OF_FILE))) {
423: lex = Get();
424: }
425: if (lex.type != LEX_END_OF_FILE) {
426: return(Get());
427: } else {
428: return(lex);
429: }
430: }
431:
432:
433: static void
434: GetWS()
435: {
436: lexicon lex;
437:
438: lex = Get();
439:
440: while ((lex.type == LEX_CHAR) &&
441: (isspace(lex.value) || (lex.value == '#'))) {
442: if (lex.value == '#') {
443: lex = EatToNL();
444: } else {
445: lex = Get();
446: }
447: }
448: UnGet(lex);
449: }
450:
451: static void
452: FreeState(pState)
453: state *pState;
454: {
455: extern void free();
456:
457: free((char *)pState);
458: }
459:
460:
461: static state *
462: GetState()
463: {
464: state *pState;
465: extern char *malloc();
466:
467: pState = (state *) malloc(sizeof (state));
468:
469: pState->result = STATE_NULL;
470: pState->next = 0;
471:
472: return(pState);
473: }
474:
475:
476: static state *
477: FindMatchAtThisLevel(pState, character)
478: state *pState;
479: int character;
480: {
481: while (pState) {
482: if (pState->match == character) {
483: return(pState);
484: }
485: pState = pState->next;
486: }
487: return(0);
488: }
489:
490:
491: static state *
492: PasteEntry(head, string, count, identifier)
493: state *head; /* points to who should point here... */
494: char *string; /* which characters to paste */
495: int count; /* number of character to do */
496: char *identifier; /* for error messages */
497: {
498: state *pState, *other;
499:
500: if (!doPaste) { /* flag to not have any side effects */
501: return((state *)1);
502: }
503: if (!count) {
504: return(head); /* return pointer to the parent */
505: }
506: if ((head->result != STATE_NULL) && (head->result != STATE_GOTO)) {
507: /* this means that a previously defined sequence is an initial
508: * part of this one.
509: */
510: fprintf(stderr, "Conflicting entries found when scanning %s\n",
511: identifier);
512: return(0);
513: }
514: # ifdef DEBUG
515: if (debug) {
516: fprintf(stderr, "%s", uncontrol(*string));
517: }
518: # endif /* DEBUG */
519: pState = GetState();
520: pState->match = *string;
521: if (head->result == STATE_NULL) {
522: head->result = STATE_GOTO;
523: head->address = pState;
524: other = pState;
525: } else { /* search for same character */
526: if ((other = FindMatchAtThisLevel(head->address, *string)) != 0) {
527: FreeState(pState);
528: } else {
529: pState->next = head->address;
530: head->address = pState;
531: other = pState;
532: }
533: }
534: return(PasteEntry(other, string+1, count-1, identifier));
535: }
536:
537: static
538: GetInput(tc, identifier)
539: int tc;
540: char *identifier; /* entry being parsed (for error messages) */
541: {
542: stringWithLength *outputString;
543: state *head;
544: state fakeQueue;
545:
546: if (doPaste) {
547: head = headOfQueue; /* always points to level above this one */
548: } else {
549: head = &fakeQueue; /* don't have any side effects... */
550: }
551:
552: if ((outputString = GetQuotedString()) == 0) {
553: return(0);
554: } else if (IsPrint(outputString->array[0])) {
555: fprintf(stderr,
556: "first character of sequence for %s is not a control type character\n",
557: identifier);
558: return(0);
559: } else {
560: if ((head = PasteEntry(head, outputString->array,
561: outputString->length, identifier)) == 0) {
562: return(0);
563: }
564: GetWS();
565: while ((outputString = GetQuotedString()) != 0) {
566: if ((head = PasteEntry(head, outputString->array,
567: outputString->length, identifier)) == 0) {
568: return(0);
569: }
570: GetWS();
571: }
572: }
573: if (!doPaste) {
574: return(1);
575: }
576: if ((head->result != STATE_NULL) && (head->result != tc)) {
577: /* this means that this sequence is an initial part
578: * of a previously defined one.
579: */
580: fprintf(stderr, "Conflicting entries found when scanning %s\n",
581: identifier);
582: return(0);
583: } else {
584: head->result = tc;
585: return(1); /* done */
586: }
587: }
588:
589: static
590: GetDefinition()
591: {
592: stringWithLength *string;
593: int Tc;
594:
595: GetWS();
596: if ((string = GetAlphaMericString()) == 0) {
597: return(0);
598: }
599: string->array[string->length] = 0;
600: if (doPaste) {
601: if ((Tc = (*GetTc)(string->array)) == -1) {
602: if (picky) {
603: fprintf(stderr, "%s: unknown 3270 key identifier\n",
604: string->array);
605: }
606: Tc = STATE_NULL;
607: }
608: } else {
609: Tc = STATE_NULL; /* XXX ? */
610: }
611: GetWS();
612: if (!GetCharacter('=')) {
613: fprintf(stderr,
614: "Required equal sign after 3270 key identifier %s missing\n",
615: string->array);
616: return(0);
617: }
618: GetWS();
619: if (!GetInput(Tc, string->array)) {
620: fprintf(stderr, "Missing definition part for 3270 key %s\n",
621: string->array);
622: return(0);
623: } else {
624: GetWS();
625: while (GetCharacter('|')) {
626: # ifdef DEBUG
627: if (debug) {
628: fprintf(stderr, " or ");
629: }
630: # endif /* DEBUG */
631: GetWS();
632: if (!GetInput(Tc, string->array)) {
633: fprintf(stderr, "Missing definition part for 3270 key %s\n",
634: string->array);
635: return(0);
636: }
637: GetWS();
638: }
639: }
640: GetWS();
641: if (!GetCharacter(';')) {
642: fprintf(stderr, "Missing semi-colon for 3270 key %s\n", string->array);
643: return(0);
644: }
645: # ifdef DEBUG
646: if (debug) {
647: fprintf(stderr, ";\n");
648: }
649: # endif /* DEBUG */
650: return(1);
651: }
652:
653:
654: static
655: GetDefinitions()
656: {
657: if (!GetDefinition()) {
658: return(0);
659: } else {
660: while (GetDefinition()) {
661: ;
662: }
663: }
664: return(1);
665: }
666:
667: static
668: GetBegin()
669: {
670: GetWS();
671: if (!GetCharacter('{')) {
672: return(0);
673: }
674: return(1);
675: }
676:
677: static
678: GetEnd()
679: {
680: GetWS();
681: if (!GetCharacter('}')) {
682: return(0);
683: }
684: return(1);
685: }
686:
687: static
688: GetName()
689: {
690: if (!GetAlphaMericString()) {
691: return(0);
692: }
693: GetWS();
694: while (GetAlphaMericString()) {
695: GetWS();
696: }
697: return(1);
698: }
699:
700: static
701: GetNames()
702: {
703: GetWS();
704: if (!GetName()) {
705: return(0);
706: } else {
707: GetWS();
708: while (GetCharacter('|')) {
709: GetWS();
710: if (!GetName()) {
711: return(0);
712: }
713: }
714: }
715: return(1);
716: }
717:
718: static
719: GetEntry0()
720: {
721: if (!GetBegin()) {
722: fprintf(stderr, "no '{'\n");
723: return(0);
724: } else if (!GetDefinitions()) {
725: fprintf(stderr, "unable to parse the definitions\n");
726: return(0);
727: } else if (!GetEnd()) {
728: fprintf(stderr, "No '}' or scanning stopped early due to error.\n");
729: return(0);
730: } else {
731: /* done */
732: return(1);
733: }
734: }
735:
736:
737: static
738: GetEntry()
739: {
740: if (!GetNames()) {
741: fprintf(stderr, "Invalid name field in entry.\n");
742: return(0);
743: } else {
744: return(GetEntry0());
745: }
746: }
747:
748: /* position ourselves within a given filename to the entry for the current
749: * KEYBD (or TERM) variable
750: */
751:
752: Position(filename, keybdPointer)
753: char *filename;
754: char *keybdPointer;
755: {
756: lexicon lex;
757: stringWithLength *name = 0;
758: stringWithLength *oldName;
759: # define Return(x) {doPaste = 1; return(x);}
760:
761: doPaste = 0;
762:
763: if ((ourFile = fopen(filename, "r")) == NULL) {
764: # if !defined(MSDOS)
765: fprintf(stderr, "Unable to open file %s\n", filename);
766: # endif /* !defined(MSDOS) */
767: Return(0);
768: }
769: lex = Get();
770: while (lex.type != LEX_END_OF_FILE) {
771: UnGet(lex);
772: /* now, find an entry that is our type. */
773: GetWS();
774: oldName = name;
775: if ((name = GetAlphaMericString()) != 0) {
776: if (!ustrcmp(name->array, keybdPointer)) {
777: /* need to make sure there is a name here... */
778: lex.type = LEX_CHAR;
779: lex.value = 'a';
780: UnGet(lex);
781: Return(1);
782: }
783: } else if (GetCharacter('|')) {
784: ; /* more names coming */
785: } else {
786: lex = Get();
787: UnGet(lex);
788: if (lex.type != LEX_END_OF_FILE) {
789: if (!GetEntry0()) { /* start of an entry */
790: fprintf(stderr,
791: "error was in entry for %s in file %s\n",
792: (oldName)? oldName->array:"(unknown)", filename);
793: Return(0);
794: }
795: }
796: }
797: lex = Get();
798: }
799: #if !defined(MSDOS)
800: fprintf(stderr, "Unable to find entry for %s in file %s\n", keybdPointer,
801: filename);
802: #endif /* !defined(MSDOS) */
803: Return(0);
804: }
805:
806: char *
807: strsave(string)
808: char *string;
809: {
810: char *p;
811: extern char *malloc();
812:
813: p = malloc(strlen(string)+1);
814: if (p != 0) {
815: strcpy(p, string);
816: }
817: return(p);
818: }
819:
820:
821: /*
822: * InitControl - our interface to the outside. What we should
823: * do is figure out keyboard (or terminal) type, set up file pointer
824: * (or string pointer), etc.
825: */
826:
827: state *
828: InitControl(keybdPointer, pickyarg, translator)
829: char *keybdPointer;
830: int pickyarg; /* Should we be picky? */
831: int (*translator)(); /* Translates ascii string to integer */
832: {
833: extern char *getenv();
834: int GotIt;
835:
836: picky = pickyarg;
837: GetTc = translator;
838:
839: if (keybdPointer == 0) {
840: keybdPointer = getenv("KEYBD");
841: }
842: if (keybdPointer == 0) {
843: keybdPointer = getenv("TERM");
844: }
845:
846: /*
847: * Some environments have getenv() return
848: * out of a static area. So, save the keyboard name.
849: */
850: if (keybdPointer) {
851: keybdPointer = strsave(keybdPointer);
852: }
853: environPointer = getenv("MAP3270");
854: if (environPointer
855: && (environPointer[0] != '/')
856: #if defined(MSDOS)
857: && (environPointer[0] != '\\')
858: #endif /* defined(MSDOS) */
859: && (strncmp(keybdPointer, environPointer,
860: strlen(keybdPointer) != 0)
861: || (environPointer[strlen(keybdPointer)] != '{'))) /* } */
862: {
863: environPointer = 0;
864: }
865:
866: if ((!environPointer)
867: #if defined(MSDOS)
868: || (*environPointer == '\\')
869: #endif /* defined(MSDOS) */
870: || (*environPointer == '/')) {
871: usePointer = 0;
872: GotIt = 0;
873: if (!keybdPointer) {
874: #if !defined(MSDOS)
875: fprintf(stderr, "%s%s%s%s",
876: "Neither the KEYBD environment variable nor the TERM ",
877: "environment variable\n(one of which is needed to determine ",
878: "the type of keyboard you are using)\n",
879: "is set. To set it, say 'setenv KEYBD <type>'\n");
880: #endif /* !defined(MSDOS) */
881: } else {
882: if (environPointer) {
883: GotIt = Position(environPointer, keybdPointer);
884: }
885: if (!GotIt) {
886: GotIt = Position("/etc/map3270", keybdPointer);
887: }
888: }
889: if (!GotIt) {
890: if (environPointer) {
891: GotIt = Position(environPointer, "unknown");
892: }
893: if (!GotIt) {
894: GotIt = Position("/etc/map3270", keybdPointer);
895: }
896: }
897: if (!GotIt) {
898: #if !defined(MSDOS)
899: fprintf(stderr, "Using default key mappings.\n");
900: #endif /* !defined(MSDOS) */
901: usePointer = 1; /* flag use of non-file */
902: whichkey = keysgeneric;
903: environPointer = *whichkey; /* use default table */
904: }
905: } else {
906: usePointer = 1;
907: }
908: (void) GetEntry();
909: return(firstentry.address);
910: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.