![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to emterm.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / usr.bin / bsc / cmd / 3270|
Return to emterm.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / usr.bin / bsc / cmd / 3270 |
1.1 root 1: /* D.L.Buck and Associates, Inc. - May, 1984
2: *
3: * COPYRIGHT NOTICE:
4: * Copyright c 1984 - An unpublished work by
5: * D.L.Buck and Associates, Inc.
6: *
7: * PROPRIETARY RIGHTS NOTICE:
8: * All rights reserved. This document and program contains
9: * proprietary information of D.L.Buck and Associates,Inc.
10: * of San Jose, California, U.S.A., embodying confidential
11: * information, ideas, and expressions, no part of which
12: * may be reproduced, or transmitted in any form or by any
13: * means, electronic, mechanical, or otherwise, without
14: * the written permission of D.L.Buck and Associates, Inc.
15: *
16: * NAME
17: * emsetup
18: * SYNOPSIS
19: * emsetup(term)
20: * char *term;
21: * DESCRIPTION
22: * NOTE: If terminal is to be managed, 'do_screen' must be
23: * set to a non-zero value. Otherwise, the package only
24: * manages the data structures fldstart, fldmax, fldattr,
25: * totfields, curfield, bufaddr, and cursaddr.
26: * emsetup() sets the terminal characteristics for emulation via
27: * ioctl, does keyboard mapping of special function keys via
28: * termcap, initializes the window curses uses to manipulate
29: * the cursor and the screen image, and the data structures
30: * used to attend to the screen image.
31: *
32: * ALGORITHM
33: * I. Initialize data structures
34: * A. screen-image cross-indices and arrays
35: * B. termcap key string structures and arrays
36: * The function key structure tcts defines function key
37: * name, where to find corresponding character string,
38: * default character string value, and value to return
39: * if that key has been pressed.
40: * C. terminal information structures
41: * These are used to save the original terminal
42: * characteristics and set the emulation characteristics.
43: *
44: * II. Set up function key table
45: * A. assign values defined in tcts structure to the
46: * function key table.
47: *
48: * III. Get terminal information
49: * A. terminal type
50: * B. termcap entry
51: * This is captured by tgetent(), which gets the
52: * terminal's termcap entry and saves it in a convenient
53: * buffer.
54: * C. get the number of lines, columns, and characters
55: * added by the standout mode from the entry.
56: * This information is captured by tgetnum(), which
57: * returns the numeric value for specified character-
58: * istics.
59: * D. put termcap's function key string values for each
60: * function into the function table.
61: * for each function key:
62: * get its string value from termcap
63: * (tgetstr() does this nicely)
64: *
65: * if no value was assigned in termcap:
66: * assign function key's string to
67: * the default value contained in the
68: * table
69: * set its length to 1
70: * else
71: * set the string value's length to
72: * the termcap string's length
73: *
74: * III. Set terminal characteristics
75: * A. do ioctls to get current characteristics
76: * B. save terminal's characteristics and baud rate
77: * C. set signal to call the cleanup routine if
78: * interrupt encountered
79: * cleanup() sets the original terminal characteristics
80: * and exits
81: * D. use ioctl to set the terminal characteristics for
82: * 3277 emulation.
83: *
84: * IV. Initialize the curses window
85: */
86: static char s_emterm[] = "@(#)CCIemterm.c 1.24 REL";
87:
88: #include <em.h>
89: #include "local.h"
90: #include <signal.h>
91: #include <ctype.h>
92: #include <setjmp.h>
93: #ifndef v7
94: #ifndef DEBUG
95: #include <fcntl.h>
96: #endif
97: #endif
98:
99: jmp_buf env;
100: int do_screen; /* Set if caller wants display managed */
101: extern int initflag; /* set if initscr called */
102: extern FILE *aud;
103: extern char audname[];
104: extern char new_audnm[];
105: extern char auditlock[];
106: extern WINDOW *curscr;
107:
108: int fldstart[MAXFIELDS]; /* Index of starting position of each
109: field's first data character.
110: Attribute characters are immediately
111: before each field. */
112: char fldattr[MAXFIELDS]; /* Attribute of each field */
113: int fldmax[MAXFIELDS]; /* Maximum width of each field */
114: int totfields; /* Total number of fields on screen */
115: int curfield; /* Current field number */
116: int bufaddr; /* Current buffer address, 0 to
117: MAXSCREENSIZE-1 */
118: int cursaddr; /* Current cursor address, 0 to
119: MAXSCREENSIZE-1 */
120: /* scrn_image is a replica of the current ASCII screen image, except that
121: attribute characters are replaced with ATTRCODE (see em.h) */
122: char scrn_image[MAXSCREENSIZE];
123:
124: /* scrn_xref is a cross-reference into scrn_image. It contains the current
125: field number corresponding to each screen location.
126: For example, a screen containing two fields, one beginning at screen
127: position 10 and the other beginning at screen position 30, can be
128: visualized as follows (top row of numbers represent screen positions):
129: 0 1 2 3 4 5
130: 012345678901234567890123456789012345678901234567890...
131: 111111111122222222222222222222333333333333333333333...
132:
133: */
134: int scrn_xref[MAXSCREENSIZE];
135:
136: /* status indicates 3277 terminal status */
137: int status;
138:
139: WINDOW *stat_scr;
140:
141: int sigalrm(); /* for dealing with v7 alarm signals */
142:
143: int COLS; /* number of columns */
144: int LINES; /* # lines on screen */
145: int SG; /* # chars added by SO */
146: char *SO; /* standout character sequence */
147: char *SE; /* standend character sequence */
148: char * S0; /* ESC string */
149: char * S1; /* ENTER string */
150: char * S2; /* CLEAR string */
151: char * S3; /* BACKTAB string */
152: char * S4; /* ERASE_EOF string */
153: char * S5; /* ERASE_INP string */
154: char * S6; /* INS string */
155: char * S7; /* DELCHAR string */
156: char * S8; /* DUP string */
157: char * S9; /* FM string */
158: char * bs; /* bs key */
159: char * cr; /* cr key */
160: char * kd; /* down arrow key */
161: char * kl; /* left arrow key */
162: char * kr; /* right arrow key */
163: char * ta; /* tab key string */
164: char * ku; /* up arrow key */
165: char * P1; /* pf1 string */
166: char * P2; /* pf2 string */
167: char * P3; /* pf3 string */
168: char * P4; /* pf4 string */
169: char * P5; /* pf5 string */
170: char * P6; /* pf6 string */
171: char * P7; /* pf7 string */
172: char * P8; /* pf8 string */
173: char * P9; /* pf9 string */
174: char * Pa; /* pf10 string */
175: char * Pb; /* pf11 string */
176: char * Pc; /* pf12 string */
177: char * A1; /* pa1 string */
178: char * A2; /* pa2 string */
179: char * A3; /* pa3 string */
180: char * SZ; /* reset string */
181: char * SH; /* help string */
182: char * ST; /* statistics string */
183: char * SP; /* print string */
184:
185: struct tcts {
186: char em_name[4]; /* name of item in termcap entry */
187: char **em_s; /* addr of addr of corresponding char string */
188: char em_def; /* default single char. if none in termcap */
189: int em_keycode; /* value to be returned to caller if this
190: char. sequence arrives at the terminal */
191: };
192: struct tcts em_ktbl[] = {
193: {"bs", &bs, 010, BACKSP}, /* bs key */
194: {"cr", &cr, 015, CARRET}, /* CR key */
195: {"kd", &kd, 012, DOWN}, /* down arrow key */
196: {"kl", &kl, 010, LEFT}, /* left arrow key */
197: {"kr", &kr, 014, RIGHT}, /* right arrow key */
198: {"ku", &ku, 013, UPAR}, /* up arrow key */
199: {"ta", &ta, 011, TAB}, /* tab key */
200: {"S0", &S0, 033, ESC}, /* escape key */
201: {"S1", &S1, 016, ENTER}, /* enter key */
202: {"S2", &S2, 017, CLEAR}, /* clear key */
203: {"S3", &S3, 025, BACKTAB}, /* backtab string*/
204: {"S4", &S4, 031, ERASE_EOF}, /* erase eof string */
205: {"S5", &S5, 020, ERASE_INP}, /* erase input string*/
206: {"S6", &S6, 036, INS}, /* insert string */
207: {"S7", &S7, 0177, DELCHR}, /* delete character string */
208: {"S8", &S8, 034, DUP}, /* duplicate op. string */
209: {"S9", &S9, 035, FM}, /* field mark key */
210: {"P1", &P1, 021, PF1}, /* program function key 1 */
211: {"P2", &P2, 027, PF2}, /* program function key 2 */
212: {"P3", &P3, 005, PF3}, /* program function key 3 */
213: {"P4", &P4, 022, PF4}, /* program function key 4 */
214: {"P5", &P5, 024, PF5}, /* program function key 5 */
215: {"P6", &P6, 001, PF6}, /* program function key 6 */
216: {"P7", &P7, 023, PF7}, /* program function key 7 */
217: {"P8", &P8, 004, PF8}, /* program function key 8 */
218: {"P9", &P9, 006, PF9}, /* program function key 9 */
219: {"Pa", &Pa, 007, PF10}, /* program function key 10 */
220: {"Pb", &Pb, 026, PF11}, /* program function key 11 */
221: {"Pc", &Pc, 002, PF12}, /* program function key 12 */
222: {"A1", &A1, 032, PA1}, /* program attention key 1 */
223: {"A2", &A2, 030, PA2}, /* program attention key 2 */
224: {"A3", &A3, 003, PA3}, /* program attention key 3 */
225: {"SZ", &SZ, 0, RESET}, /* reset key */
226: {"SH", &SH, 0, HELP}, /* help key */
227: {"ST", &ST, 0, STATS}, /* statistics key */
228: {"SP", &SP, 0, PRINT}, /* print key */
229: {"", (char **)0, 000, 0} /* end of list */
230: };
231:
232: #ifdef v7
233: struct tchars origtchar, termtchar;
234: struct sgttyb origtio, termio;
235: struct ltchars olchars, lchars;
236: #else
237: struct termio origtio, termio;
238: #endif
239:
240: char emarea[256], *emaptr = emarea;
241:
242: /*
243: * The following character array, `kytrt', is used by the `getchar'
244: * routine to translate incoming keystrokes into 3270 keystrokes.
245: * It is built by examining the TERMCAP entry for this terminal
246: * for all special keystroke sequences.
247: * The resulting table has one element per ASCII character; the
248: * first incoming ASCII character is matched against this table,
249: * with the following results:
250: * kytrt[c] == 0 Not a special keystroke
251: * kytrt[c] == n, n <> 0 Special keystroke of max n chars
252: */
253: char kytrt[128]; /* function key trt table */
254:
255: #define max(a,b) ((a) > (b)?(a):(b))
256:
257: emsetup(term) /* set up terminal attributes via em_ktbl */
258: char *term;
259: {
260: register struct tcts *tps; /* pointer into em_ktbl */
261: register char *sp; /* key string pointer */
262: char tbuf[2048]; /* buffer for tgetent */
263: char tname[20];
264: int ans; /* answer to help ? goes here */
265: int cleanwin(); /* cleanup before exiting */
266:
267: /* tgetstr() gets the capability string for a particular function key
268: from the termcap database entry for this terminal. It decodes the
269: abbreviations used by termcap, returns the key string which
270: performs the function desired, and places it in a buffer
271: (emarea is used here).
272: for example, tgets for the clear screen function key on a
273: Zentec 8001 terminal would get:
274: cl=\EH\EJ
275: from /etc/termcap, and return the key sequence escape-H escape-J,
276: which clears the screen. */
277: char *tgetstr();
278: int cleanup();
279:
280: if (term == (char *) 0) term = "dumb";
281: if (term[0] == '\0') term = "dumb";
282:
283: if (tgetent(tbuf, term) != 1) {
284: fprintf(stderr,"em3277: terminal type <%s> unknown\n",
285: term);
286: return(1);
287: }
288:
289: /* tgetnum is the numeric version of tgetstr -- it get the numeric
290: * value of the capability named from the /etc/termcap entry for this
291: * terminal. */
292: LINES = tgetnum("li");
293: COLS = tgetnum("co");
294: SG = tgetnum("sg");
295: if (SG == -1)
296: SG = 0;
297:
298: for (tps = em_ktbl; tps->em_name[0]; ++tps) {
299: sp = *tps->em_s = tgetstr(tps->em_name,&emaptr);
300: if (sp == (char *)0) { /* doesn't appear - default */
301: *tps->em_s = &tps->em_def;
302: kytrt[tps->em_def] = 1; /* def. string is one char */
303: } else
304: kytrt[*sp] = max(strlen(sp), kytrt[*sp]);
305: }
306:
307: /* get standout, standend sequences */
308: SO = tgetstr("so", &emaptr);
309: SE = tgetstr("se", &emaptr);
310:
311: #ifdef v7
312: ioctl (0, TIOCGETC, &origtchar);
313: ioctl (0, TIOCGETP, &origtio);
314: ioctl (0, TIOCGLTC, &olchars);
315: #else
316: ioctl(0,TCGETA, &origtio);
317: #endif
318:
319: signal(SIGHUP,cleanwin);
320: signal(SIGTERM,cleanwin);
321: cursaddr = 0;
322: if (do_screen) { /* screen to be managed */
323: My_term = TRUE; /* force curses to use stdout */
324: Def_term = term;
325: gettmode();
326: initscr(); /* set up virtual terminal screen */
327: initflag = 1; /* initscr has been called */
328: crmode(); /* set cbreak mode */
329: noecho(); /* turn off echo */
330: nonl(); /* turn off cr-lf mapping */
331: clearok(curscr,TRUE); /* clear screen next refresh */
332: /* Set up our 24x80 terminal screen */
333: vterm_scr = newwin(24,80,0,0);
334: wmove(vterm_scr,0,0);
335: werase(vterm_scr);
336: wrefresh(vterm_scr);
337: clearok(curscr,FALSE);
338:
339: /* initialize help screen */
340: help_scr = newwin(24,80,0,0);
341: wmove(help_scr,0,0);
342: werase(help_scr);
343:
344: /* fill with keyboard map */
345: tgetent(tbuf, term);
346: helpinit(term);
347:
348: /* set up hidden subwindow behind status and command area */
349: sub_vterm = subwin(vterm_scr,2,80,22,0);
350:
351: /* set up command window */
352: cmd_scr = newwin(1,80,LINES-1,0);
353: wmove(cmd_scr,0,0);
354: werase(cmd_scr);
355:
356: /* set up status window */
357: stat_scr = newwin(1,80,LINES-2,0);
358: wmove(stat_scr,0,0);
359: werase(stat_scr);
360:
361: /* disable interrupts */
362: #ifdef v7
363: ioctl (0, TIOCGETC, &termtchar);
364: termtchar.t_intrc = -1; /* disable DEL as INTR */
365: ioctl (0, TIOCSETC, &termtchar);
366: ioctl (0, TIOCGETP, &termio);
367: ioctl (0, TIOCGLTC, &lchars);
368: lchars.t_suspc = -1;
369: ioctl (0, TIOCSLTC, &lchars);
370: #else
371: ioctl(0, TCGETA, &termio);
372: termio.c_cc[VINTR] = -1; /* disable DEL as INTR */
373: termio.c_iflag |= BRKINT; /* break key is reset */
374: termio.c_iflag &= ~IXON; /* disable xon, xoff */
375: ioctl(0,TCSETA, &termio);
376: #endif
377: signal(SIGALRM,sigalrm);
378: /* ask if user wants a keyboard map */
379: wstandout(vterm_scr);
380: mvwaddstr(vterm_scr,0,0,"Would you like help? (Y/N):");
381: wmove(vterm_scr,0,30);
382: wstandend(vterm_scr);
383: wrefresh(vterm_scr);
384: while((ans=emgetchar()) == NOCHAR) continue;
385: if (ans == 'y' || ans == 'Y') {
386: werase(vterm_scr);
387: em_help();
388: }
389:
390: clearok(curscr,TRUE);
391: }
392:
393: return(0);
394: }
395:
396: /* emgetchar() - get a character keyed in at the terminal and process it
397: * Called from emulate().
398: *
399: * ALGORITHM
400: * I. Read the character into a temporary character buffer, cbuf
401: * II. If nothing was read in, return NOCHAR
402: * III. If read returned -1, return ERROR
403: * IV. If character read in has a value in the key length array, it's
404: * a special function key character. Process it:
405: * A. for the length specified, read characters into cbuf
406: * B. search through the function key table for a string value
407: * match.
408: * C. if a match is found, return the function key code specified
409: * in the function key table.
410: * D. If no match is found, return OTHER.
411: * V. If the character is not a special function key, process it:
412: * A. if it's printable, return it
413: * B. otherwise, return OTHER
414: * VI. return
415: */
416: #define ERROR -1
417: extern int errno;
418:
419: int emgetchar()
420: {
421: register int nread;
422: register char cc;
423: register struct tcts *em_kyptr; /* ptr into em_ktbl */
424: register char *s;
425: extern char kytrt[];
426: char cbuf[10];
427: int nmax,nhave;
428:
429: if(setjmp(env) == 0) {
430: alarm(1);
431: nread = read(0,cbuf,1);
432: alarm(0);
433: }
434: else
435: return NOCHAR;
436:
437: if (nread < 0 && errno == EINTR) return NOCHAR;
438: if (nread < 0) return ERROR;
439: if (nread == 0)
440: return NOCHAR;
441: cc = cbuf[0];
442: nhave = nread;
443: if (nmax = kytrt[cc]) { /* Special keystroke sequence indicated */
444: while (nread > 0) {
445: /* Search em_ktbl for sequence of this length */
446: cbuf[nhave] = '\0'; /* Null-terminate */
447: for (em_kyptr = em_ktbl; em_kyptr->em_s; em_kyptr++)
448: if (strcmp(*(em_kyptr->em_s),cbuf)==0) {
449: return em_kyptr->em_keycode;
450: }
451: if (nhave >= nmax)
452: return OTHER;
453: nread = read(0, &cbuf[nhave], nmax-nhave);
454: nhave += nread;
455: cbuf[nhave] = '\0';
456: }
457: if (nread < 0)
458: return ERROR;
459: if (nread == 0)
460: return NOCHAR;
461: }
462:
463: if (isprint(cc) || cc == ' ')
464: return cc;
465: else return OTHER;
466: }
467:
468: /* cleanwin() - clean up before exiting em3277.
469: *
470: * ALGORITHM
471: * I. Finish off curses routines and close the window
472: * II. Reset the terminal characteristics to their original
473: * values
474: * III. Remove temp audit files, lock files, ...
475: */
476:
477: cleanwin()
478: {
479: if (initflag) {
480:
481: endwin();
482: /* reset original terminal characteristics */
483: #ifdef v7
484: ioctl (0, TIOCSETC, &origtchar);
485: ioctl (0, TIOCSETP, &origtio);
486: ioctl (0, TIOCSLTC, &olchars);
487: #else
488: ioctl(0,TCSETA, &origtio);
489: #endif
490: }
491: /* remove temp audit files, lock files, etc.. */
492: if (aud) {
493: fclose(aud);
494: if (link(audname,new_audnm) >= 0)
495: unlink(audname);
496: unlink(auditlock);
497: }
498: }
499:
500: /* cleanup -- clean up before exiting em3277 */
501: cleanup()
502: {
503: cleanwin();
504: write(1,"\n",1); /* make screen pretty before leaving */
505: exit(0);
506: }
507:
508: /* update the keyboard status */
509: updstat(val)
510: register int val;
511: {
512: status = val;
513: werase(stat_scr);
514:
515: wstandout(stat_scr);
516: if (status & LOCK_OUT)
517: mvwaddstr(stat_scr,0,0,"Input Inhibited");
518: if (status & SYS_AVAIL)
519: mvwaddstr(stat_scr,0,20,"System Available");
520: if (status & INSERT_MODE)
521: mvwaddstr(stat_scr,0,40,"Insert Mode");
522: touchwin(stat_scr);
523: wstandend(stat_scr);
524: wrefresh(stat_scr);
525: }
526:
527: /* sigalrm -- reset alarm signal (for no-delay reading under v7) */
528: sigalrm()
529: {
530: signal(SIGALRM,sigalrm);
531: longjmp(env,1);
532: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.