![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to keyboard.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / ucb / tn3270|
Return to keyboard.c CVS log | Up to [CSRG BSD Unix] / 43BSD / ucb / tn3270 |
1.1 root 1: /*
2: * Copyright 1984, 1985 by the Regents of the University of
3: * California and by Gregory Glenn Minshall.
4: *
5: * Permission to use, copy, modify, and distribute these
6: * programs and their documentation for any purpose and
7: * without fee is hereby granted, provided that this
8: * copyright and permission appear on all copies and
9: * supporting documentation, the name of the Regents of
10: * the University of California not be used in advertising
11: * or publicity pertaining to distribution of the programs
12: * without specific prior permission, and notice be given in
13: * supporting documentation that copying and distribution is
14: * by permission of the Regents of the University of California
15: * and by Gregory Glenn Minshall. Neither the Regents of the
16: * University of California nor Gregory Glenn Minshall make
17: * representations about the suitability of this software
18: * for any purpose. It is provided "as is" without
19: * express or implied warranty.
20: */
21:
22:
23:
24: /* test stub for DataFrom3270, etc. */
25:
26: #define DEFINEAIDS
27: #include "m4.out" /* output of termcodes.m4 */
28: #include "ascebc.h"
29: #include "3270.h"
30: #include "screen.h"
31: #include "options.h"
32: #include "ectype.h"
33:
34: #ifndef lint
35: static char sccsid[] = "@(#)keyboard.c 2.6 4/4/86";
36: #endif /* ndef lint */
37:
38: #define EmptyChar (ourPTail == ourBuffer)
39: #define FullChar (ourPTail == ourBuffer+sizeof ourBuffer)
40:
41: extern char ascebc[NASCEBC][NASCII];
42:
43: static char ourBuffer[4000];
44:
45: static char *ourPHead = ourBuffer,
46: *ourPTail = ourBuffer;
47:
48: static int trTbl = AE_IN; /* which ascii->ebcdic tr table */
49:
50: static int HadAid = 0; /* Had an AID haven't sent */
51:
52: /* the following are global variables */
53:
54: extern int UnLocked; /* keyboard is UnLocked? */
55:
56: /* Tab() - sets cursor to the start of the next unprotected field */
57: static void
58: Tab()
59: {
60: register int i, j;
61:
62: i = CursorAddress;
63: j = WhereAttrByte(CursorAddress);
64: do {
65: if (IsStartField(i) && IsUnProtected(ScreenInc(i))) {
66: break;
67: }
68: i = FieldInc(i);
69: } while (i != j);
70: if (IsStartField(i) && IsUnProtected(ScreenInc(i))) {
71: CursorAddress = ScreenInc(i);
72: } else {
73: CursorAddress = SetBufferAddress(0,0);
74: }
75: }
76:
77:
78: /* BackTab() - sets cursor to the start of the most recent field */
79:
80: static void
81: BackTab()
82: {
83: register int i;
84:
85: i = ScreenDec(CursorAddress);
86: for (;;) {
87: if (IsStartField(ScreenDec(i)) && IsUnProtected(i)) {
88: CursorAddress = i;
89: break;
90: }
91: if (i == CursorAddress) {
92: CursorAddress = SetBufferAddress(0,0);
93: break;
94: }
95: i = ScreenDec(i);
96: }
97: }
98:
99:
100: /* EraseEndOfField - erase all characters to the end of a field */
101:
102: static
103: EraseEndOfField()
104: {
105: register int i;
106:
107: if (IsProtected(CursorAddress)) {
108: RingBell();
109: } else {
110: TurnOnMdt(CursorAddress);
111: i = CursorAddress;
112: do {
113: AddHost(i, 0);
114: i = ScreenInc(i);
115: } while ((i != CursorAddress) && IsUnProtected(i));
116: }
117: }
118:
119: /* Delete() - deletes a character from the screen
120: *
121: * What we want to do is delete the section
122: * [where, from-1] from the screen,
123: * filling in with what comes at from.
124: *
125: * The deleting continues to the end of the field (or
126: * until the cursor wraps).
127: *
128: * From can be a start of a field. We
129: * check for that. However, there can't be any
130: * fields that start between where and from.
131: * We don't check for that.
132: *
133: * Also, we assume that the protection status of
134: * everything has been checked by the caller.
135: *
136: */
137:
138: static
139: Delete(where, from)
140: register int where, /* Where to start deleting from */
141: from; /* Where to pull back from */
142: {
143: register int i;
144:
145: TurnOnMdt(where); /* Only do this once in this field */
146: i = where;
147: do {
148: if (IsStartField(from)) {
149: AddHost(i, 0); /* Stick the edge at the start field */
150: } else {
151: AddHost(i, GetHost(from));
152: from = ScreenInc(from); /* Move the edge */
153: }
154: i = ScreenInc(i);
155: } while ((!IsStartField(i)) && (i != where));
156: }
157:
158: ColBak()
159: {
160: register int i;
161:
162: i = ScreenLineOffset(CursorAddress);
163: for (i = i-1; i >= 0; i--) {
164: if (OptColTabs[i]) {
165: break;
166: }
167: }
168: if (i < 0) {
169: i = 0;
170: }
171: CursorAddress = SetBufferAddress(ScreenLine(CursorAddress), i);
172: }
173:
174: ColTab()
175: {
176: register int i;
177:
178: i = ScreenLineOffset(CursorAddress);
179: for (i = i+1; i < LINESIZE; i++) {
180: if (OptColTabs[i]) {
181: break;
182: }
183: }
184: if (i >= LINESIZE) {
185: i = LINESIZE-1;
186: }
187: CursorAddress = SetBufferAddress(ScreenLine(CursorAddress), i);
188: }
189:
190: static
191: Home()
192: {
193: register int i;
194: register int j;
195:
196: i = SetBufferAddress(OptHome, 0);
197: j = WhereLowByte(i);
198: do {
199: if (IsUnProtected(i)) {
200: CursorAddress = i;
201: return;
202: }
203: /* the following could be a problem if we got here with an
204: * unformatted screen. However, this is "impossible", since
205: * with an unformatted screen, the IsUnProtected(i) above
206: * should be true.
207: */
208: i = ScreenInc(FieldInc(i));
209: } while (i != j);
210: CursorAddress = LowestScreen();
211: }
212:
213: static
214: LastOfField(i)
215: register int i; /* position to start from */
216: {
217: register int j;
218: register int k;
219:
220: k = j = i;
221: while (IsProtected(i) || Eisspace(GetHost(i))) {
222: i = ScreenInc(i);
223: if (i == j) {
224: break;
225: }
226: }
227: /* We are now IN a word IN an unprotected field (or wrapped) */
228: while (!IsProtected(i)) {
229: if (!Eisspace(GetHost(i))) {
230: k = i;
231: }
232: i = ScreenInc(i);
233: if (i == j) {
234: break;
235: }
236: }
237: return(k);
238: }
239:
240:
241: static
242: FlushChar()
243: {
244: ourPTail = ourPHead = ourBuffer;
245: }
246:
247:
248: static
249: AddChar(character)
250: char character;
251: {
252: *ourPHead++ = character;
253: }
254:
255:
256: static void
257: SendUnformatted()
258: {
259: register int i, j;
260: register int Nulls;
261: register int c;
262:
263: /* look for start of field */
264: Nulls = 0;
265: i = j = LowestScreen();
266: do {
267: c = GetHost(i);
268: if (c == 0) {
269: Nulls++;
270: } else {
271: while (Nulls) {
272: Nulls--;
273: AddChar(0x40); /* put in blanks */
274: }
275: AddChar(c);
276: }
277: i = ScreenInc(i);
278: } while (i != j);
279: }
280:
281: static
282: SendField(i)
283: register int i; /* where we saw MDT bit */
284: {
285: register int j;
286: register int k;
287: register int Nulls;
288: register int c;
289:
290: /* look for start of field */
291: i = j = WhereLowByte(i);
292:
293: AddChar(ORDER_SBA); /* set start field */
294: AddChar(BufferTo3270_0(j)); /* set address of this field */
295: AddChar(BufferTo3270_1(j));
296:
297: if (!IsStartField(j)) {
298: Nulls = 0;
299: k = ScreenInc(WhereHighByte(j));
300: do {
301: c = GetHost(j);
302: if (c == 0) {
303: Nulls++;
304: } else {
305: while (Nulls) {
306: Nulls--;
307: AddChar(0x40); /* put in blanks */
308: }
309: AddChar(c);
310: }
311: j = ScreenInc(j);
312: } while ((j != k) && (j != i));
313: }
314: return(j);
315: }
316:
317: /* Various types of reads... */
318: DoReadModified()
319: {
320: register int i, j;
321:
322: if (AidByte) {
323: AddChar(AidByte);
324: } else {
325: AddChar(0x60);
326: }
327: if ((AidByte != AID_PA1) && (AidByte != AID_PA2) && (AidByte != AID_PA3)
328: && (AidByte != AID_CLEAR)) {
329: AddChar(BufferTo3270_0(CursorAddress));
330: AddChar(BufferTo3270_1(CursorAddress));
331: i = j = WhereAttrByte(LowestScreen());
332: /* Is this an unformatted screen? */
333: if (!IsStartField(i)) { /* yes, handle separate */
334: SendUnformatted();
335: } else {
336: do {
337: if (HasMdt(i)) {
338: i = SendField(i);
339: } else {
340: i = FieldInc(i);
341: }
342: } while (i != j);
343: }
344: }
345: ourPTail += DataToNetwork(ourPTail, ourPHead-ourPTail);
346: if (ourPTail == ourPHead) {
347: FlushChar();
348: HadAid = 0; /* killed that buffer */
349: }
350: }
351:
352: /* A read buffer operation... */
353:
354: DoReadBuffer()
355: {
356: register int i, j;
357:
358: if (AidByte) {
359: AddChar(AidByte);
360: } else {
361: AddChar(0x60);
362: }
363: AddChar(BufferTo3270_0(CursorAddress));
364: AddChar(BufferTo3270_1(CursorAddress));
365: i = j = LowestScreen();
366: do {
367: if (IsStartField(i)) {
368: AddChar(ORDER_SF);
369: AddChar(BufferTo3270_1(FieldAttributes(i)));
370: } else {
371: AddChar(GetHost(i));
372: }
373: i = ScreenInc(i);
374: } while (i != j);
375: ourPTail += DataToNetwork(ourPTail, ourPHead-ourPTail);
376: if (ourPTail == ourPHead) {
377: FlushChar();
378: HadAid = 0; /* killed that buffer */
379: }
380: }
381: /* Try to send some data to host */
382:
383: SendToIBM()
384: {
385: extern int TransparentClock, OutputClock;
386:
387: if (TransparentClock == OutputClock) {
388: if (HadAid) {
389: AddChar(AidByte);
390: HadAid = 0;
391: } else {
392: AddChar(0xe8);
393: }
394: do {
395: ourPTail += DataToNetwork(ourPTail, ourPHead-ourPTail);
396: } while (ourPTail != ourPHead);
397: FlushChar();
398: } else if (HadAid) {
399: DoReadModified();
400: }
401: netflush();
402: }
403:
404: /* This takes in one character from the keyboard and places it on the
405: * screen.
406: */
407:
408: static
409: OneCharacter(c, insert)
410: int c; /* character (Ebcdic) to be shoved in */
411: int insert; /* are we in insert mode? */
412: {
413: register int i, j;
414:
415: if (IsProtected(CursorAddress)) {
416: RingBell();
417: return;
418: }
419: if (insert) {
420: /* is the last character in the field a blank or null? */
421: i = ScreenDec(FieldInc(CursorAddress));
422: j = GetHost(i);
423: if (!Eisspace(j)) {
424: RingBell();
425: return;
426: } else {
427: for (j = ScreenDec(i); i != CursorAddress;
428: j = ScreenDec(j), i = ScreenDec(i)) {
429: AddHost(i, GetHost(j));
430: }
431: }
432: }
433: AddHost(CursorAddress, c);
434: TurnOnMdt(CursorAddress);
435: CursorAddress = ScreenInc(CursorAddress);
436: if (IsStartField(CursorAddress) &&
437: ((FieldAttributes(CursorAddress)&ATTR_AUTO_SKIP_MASK) ==
438: ATTR_AUTO_SKIP_VALUE)) {
439: Tab();
440: }
441: }
442:
443: /* go through data until an AID character is hit, then generate an interrupt */
444:
445: DataFrom3270(buffer, count)
446: char *buffer; /* where the data is */
447: int count; /* how much data there is */
448: {
449: int origCount;
450: register int c;
451: register int i;
452: register int j;
453: static int InsertMode = 0; /* is the terminal in insert mode? */
454:
455: extern int OutputClock, TransparentClock;
456:
457: if (!UnLocked || HadAid) {
458: if (HadAid) {
459: SendToIBM();
460: if (!EmptyChar) {
461: return(0); /* nothing to do */
462: }
463: }
464: if (!HadAid && (((*buffer&0xff) == TC_RESET) ||
465: ((*buffer&0xff) == TC_MASTER_RESET)) && EmptyChar) {
466: UnLocked = 1;
467: }
468: if (!UnLocked) {
469: return(0);
470: }
471: }
472: /* now, either empty, or haven't seen aid yet */
473:
474: origCount = count;
475:
476: if (TransparentClock == OutputClock) {
477: while (count) {
478: c = (*buffer++)&0xff;
479: count--;
480: if (IsAid(c)) {
481: UnLocked = 0;
482: InsertMode = 0;
483: AidByte = TCtoAid(c);
484: HadAid = 1;
485: } else {
486: switch (c) {
487: case TC_ESCAPE:
488: Stop3270(1);
489: command(0);
490: ConnectScreen();
491: break;
492:
493: case TC_RESET:
494: case TC_MASTER_RESET:
495: UnLocked = 1;
496: break;
497:
498: default:
499: return(origCount-(count+1));
500: }
501: }
502: }
503: }
504:
505: while (count) {
506: c = (*buffer++)&0xff;
507: count--;
508:
509: if (!IsTc(c)) {
510: /* Add the character to the buffer */
511: OneCharacter(ascebc[trTbl][c], InsertMode);
512: } else if (IsAid(c)) { /* got Aid */
513: if (c == TC_CLEAR) {
514: LocalClear3270();
515: }
516: UnLocked = 0;
517: InsertMode = 0; /* just like a 3278 */
518: AidByte = TCtoAid(c);
519: HadAid = 1;
520: SendToIBM();
521: return(origCount-count);
522: } else {
523:
524: /* non-AID TC character */
525: switch (c) {
526:
527: case TC_ERASE:
528: if (IsProtected(ScreenDec(CursorAddress))) {
529: RingBell();
530: } else {
531: CursorAddress = ScreenDec(CursorAddress);
532: Delete(CursorAddress, ScreenInc(CursorAddress));
533: }
534: break;
535:
536: case TC_WERASE:
537: j = CursorAddress;
538: i = ScreenDec(j);
539: if (IsProtected(i)) {
540: RingBell();
541: } else {
542: while ((!IsProtected(i) && Eisspace(GetHost(i)))
543: && (i != j)) {
544: i = ScreenDec(i);
545: }
546: /* we are pointing at a character in a word, or
547: * at a protected position
548: */
549: while ((!IsProtected(i) && !Eisspace(GetHost(i)))
550: && (i != j)) {
551: i = ScreenDec(i);
552: }
553: /* we are pointing at a space, or at a protected
554: * position
555: */
556: CursorAddress = ScreenInc(i);
557: Delete(CursorAddress, j);
558: }
559: break;
560:
561: case TC_FERASE:
562: if (IsProtected(CursorAddress)) {
563: RingBell();
564: } else {
565: CursorAddress = ScreenInc(CursorAddress); /* for btab */
566: BackTab();
567: EraseEndOfField();
568: }
569: break;
570:
571: case TC_RESET:
572: InsertMode = 0;
573: break;
574:
575: case TC_MASTER_RESET:
576: InsertMode = 0;
577: RefreshScreen();
578: break;
579:
580: case TC_UP:
581: CursorAddress = ScreenUp(CursorAddress);
582: break;
583:
584: case TC_LEFT:
585: CursorAddress = ScreenDec(CursorAddress);
586: break;
587:
588: case TC_RIGHT:
589: CursorAddress = ScreenInc(CursorAddress);
590: break;
591:
592: case TC_DOWN:
593: CursorAddress = ScreenDown(CursorAddress);
594: break;
595:
596: case TC_DELETE:
597: if (IsProtected(CursorAddress)) {
598: RingBell();
599: } else {
600: Delete(CursorAddress, ScreenInc(CursorAddress));
601: }
602: break;
603:
604: case TC_INSRT:
605: InsertMode = !InsertMode;
606: break;
607:
608: case TC_HOME:
609: Home();
610: break;
611:
612: case TC_NL:
613: /* The algorithm is to look for the first unprotected
614: * column after column 0 of the following line. Having
615: * found that unprotected column, we check whether the
616: * cursor-address-at-entry is at or to the right of the
617: * LeftMargin AND the LeftMargin column of the found line
618: * is unprotected. If this conjunction is true, then
619: * we set the found pointer to the address of the LeftMargin
620: * column in the found line.
621: * Then, we set the cursor address to the found address.
622: */
623: i = SetBufferAddress(ScreenLine(ScreenDown(CursorAddress)), 0);
624: j = ScreenInc(WhereAttrByte(CursorAddress));
625: do {
626: if (IsUnProtected(i)) {
627: break;
628: }
629: /* Again (see comment in Home()), this COULD be a problem
630: * with an unformatted screen.
631: */
632: /* If there was a field with only an attribute byte,
633: * we may be pointing to the attribute byte of the NEXT
634: * field, so just look at the next byte.
635: */
636: if (IsStartField(i)) {
637: i = ScreenInc(i);
638: } else {
639: i = ScreenInc(FieldInc(i));
640: }
641: } while (i != j);
642: if (!IsUnProtected(i)) { /* couldn't find unprotected */
643: i = SetBufferAddress(0,0);
644: }
645: if (OptLeftMargin <= ScreenLineOffset(CursorAddress)) {
646: if (IsUnProtected(SetBufferAddress(ScreenLine(i),
647: OptLeftMargin))) {
648: i = SetBufferAddress(ScreenLine(i), OptLeftMargin);
649: }
650: }
651: CursorAddress = i;
652: break;
653:
654: case TC_EINP:
655: i = j = ScreenInc(WhereAttrByte(LowestScreen()));
656: do {
657: if (IsUnProtected(i)) {
658: AddHost(i, 0);
659: TurnOnMdt(i);
660: } else {
661: /* FieldInc() puts us at the start of the next
662: * field.
663: *
664: * We don't want to skip to the start of the
665: * next field if we are on the attribute byte,
666: * since we may be skipping over an otherwise
667: * unprotected field.
668: *
669: * Also, j points at the first byte of the first
670: * field on the screen, unprotected or not. If
671: * we never point there, we might loop here for
672: * ever.
673: */
674: if (!IsStartField(i)) {
675: i = FieldInc(i);
676: }
677: }
678: i = ScreenInc(i);
679: } while (i != j);
680: Home(); /* get to home position */
681: break;
682:
683: case TC_EEOF:
684: EraseEndOfField();
685: break;
686:
687: case TC_FM:
688: if (IsProtected(CursorAddress)) {
689: RingBell();
690: } else {
691: OneCharacter(EBCDIC_FM, InsertMode); /* Add field mark */
692: }
693: break;
694:
695: case TC_DP:
696: if (IsProtected(CursorAddress)) {
697: RingBell();
698: break;
699: }
700: OneCharacter(EBCDIC_DUP, InsertMode); /* Add dup character */
701: Tab();
702: break;
703:
704: case TC_TAB:
705: Tab();
706: break;
707:
708: case TC_BTAB:
709: BackTab();
710: break;
711:
712: #ifdef NOTUSED /* Actually, this is superseded by unix flow
713: * control.
714: */
715: case TC_XOFF:
716: Flow = 0; /* stop output */
717: break;
718:
719: case TC_XON:
720: if (!Flow) {
721: Flow = 1; /* turn it back on */
722: DoTerminalOutput();
723: }
724: break;
725: #endif /* NOTUSED */
726:
727: case TC_ESCAPE:
728: /* FlushChar(); do we want to flush characters from before? */
729: Stop3270(1);
730: command(0);
731: ConnectScreen();
732: break;
733:
734: case TC_DISC:
735: Stop3270(1);
736: suspend();
737: ConnectScreen();
738: break;
739:
740: case TC_RESHOW:
741: RefreshScreen();
742: break;
743:
744: case TC_SETTAB:
745: OptColTabs[ScreenLineOffset(CursorAddress)] = 1;
746: break;
747:
748: case TC_DELTAB:
749: OptColTabs[ScreenLineOffset(CursorAddress)] = 0;
750: break;
751:
752: case TC_CLRTAB:
753: for (i = 0; i < sizeof OptColTabs; i++) {
754: OptColTabs[i] = 0;
755: }
756: break;
757:
758: case TC_COLTAB:
759: ColTab();
760: break;
761:
762: case TC_COLBAK:
763: ColBak();
764: break;
765:
766: case TC_INDENT:
767: ColTab();
768: OptLeftMargin = ScreenLineOffset(CursorAddress);
769: break;
770:
771: case TC_UNDENT:
772: ColBak();
773: OptLeftMargin = ScreenLineOffset(CursorAddress);
774: break;
775:
776: case TC_SETMRG:
777: OptLeftMargin = ScreenLineOffset(CursorAddress);
778: break;
779:
780: case TC_SETHOM:
781: OptHome = ScreenLine(CursorAddress);
782: break;
783:
784: /*
785: * Point to first character of next unprotected word on
786: * screen.
787: */
788: case TC_WORDTAB:
789: i = CursorAddress;
790: while (!IsProtected(i) && !Eisspace(GetHost(i))) {
791: i = ScreenInc(i);
792: if (i == CursorAddress) {
793: break;
794: }
795: }
796: /* i is either protected, a space (blank or null),
797: * or wrapped
798: */
799: while (IsProtected(i) || Eisspace(GetHost(i))) {
800: i = ScreenInc(i);
801: if (i == CursorAddress) {
802: break;
803: }
804: }
805: CursorAddress = i;
806: break;
807:
808: case TC_WORDBACKTAB:
809: i = ScreenDec(CursorAddress);
810: while (IsProtected(i) || Eisspace(GetHost(i))) {
811: i = ScreenDec(i);
812: if (i == CursorAddress) {
813: break;
814: }
815: }
816: /* i is pointing to a character IN an unprotected word
817: * (or i wrapped)
818: */
819: while (!Eisspace(GetHost(i))) {
820: i = ScreenDec(i);
821: if (i == CursorAddress) {
822: break;
823: }
824: }
825: CursorAddress = ScreenInc(i);
826: break;
827:
828: /* Point to last non-blank character of this/next
829: * unprotected word.
830: */
831: case TC_WORDEND:
832: i = ScreenInc(CursorAddress);
833: while (IsProtected(i) || Eisspace(GetHost(i))) {
834: i = ScreenInc(i);
835: if (i == CursorAddress) {
836: break;
837: }
838: }
839: /* we are pointing at a character IN an
840: * unprotected word (or we wrapped)
841: */
842: while (!Eisspace(GetHost(i))) {
843: i = ScreenInc(i);
844: if (i == CursorAddress) {
845: break;
846: }
847: }
848: CursorAddress = ScreenDec(i);
849: break;
850:
851: /* Get to last non-blank of this/next unprotected
852: * field.
853: */
854: case TC_FIELDEND:
855: i = LastOfField(CursorAddress);
856: if (i != CursorAddress) {
857: CursorAddress = i; /* We moved; take this */
858: } else {
859: j = FieldInc(CursorAddress); /* Move to next field */
860: i = LastOfField(j);
861: if (i != j) {
862: CursorAddress = i; /* We moved; take this */
863: }
864: /* else - nowhere else on screen to be; stay here */
865: }
866: break;
867:
868: default:
869: RingBell(); /* We don't handle this yet */
870: }
871: }
872: }
873: return(origCount-count);
874: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.