use new ioctl's

SCCS-vsn: bin/stty/stty.c 4.10

diff --git a/usr/src/bin/stty/stty.c b/usr/src/bin/stty/stty.c
index 03fe5b7..0d22251 100644 (file)
--- a/usr/src/bin/stty/stty.c
+++ b/usr/src/bin/stty/stty.c
@@ -1,4 +1,4 @@
-static char *sccsid ="@(#)stty.c       4.9 (Berkeley) %G%";
+static char *sccsid ="@(#)stty.c       4.10 (Berkeley) %G%";

 /*
  * set teletype modes
  */
 /*
  * set teletype modes
  */


@@ -6,155 +6,153 @@ static char *sccsid ="@(#)stty.c    4.9 (Berkeley) %G%";
 #include <stdio.h>
 #include <sgtty.h>
 
 #include <stdio.h>
 #include <sgtty.h>
 

-struct
-{
+struct {

        char    *string;
        int     speed;
 } speeds[] = {
        char    *string;
        int     speed;
 } speeds[] = {

-       "0",    B0,
-       "50",   B50,
-       "75",   B75,
-       "110",  B110,
-       "134",  B134,
-       "134.5",B134,
-       "150",  B150,
-       "200",  B200,
-       "300",  B300,
-       "600",  B600,
-       "1200", B1200,
-       "1800", B1800,
-       "2400", B2400,
-       "4800", B4800,
-       "9600", B9600,
-       "exta", EXTA,
-       "19200", EXTA,
-       "extb", EXTB,
-       "38400", EXTB,
-       0,
+       { "0",          B0 },
+       { "50",         B50 },
+       { "75",         B75 },
+       { "110",        B110 },
+       { "134",        B134 },
+       { "134.5",      B134 },
+       { "150",        B150 },
+       { "200",        B200 },
+       { "300",        B300 },
+       { "600",        B600 },
+       { "1200",       B1200 },
+       { "1800",       B1800 },
+       { "2400",       B2400 },
+       { "4800",       B4800 },
+       { "9600",       B9600 },
+       { "exta",       EXTA },
+       { "19200",      EXTA },
+       { "extb",       EXTB },
+       { "38400",      EXTB },
+       { 0 },

 };
 };

-struct
-{
+
+struct {

        char    *string;
        char    *string;

-       int     set;
-       int     reset;
-       int     lset;
-       int     lreset;
+       long    set;
+       long    reset;

 } modes[] = {
 } modes[] = {

-       "even",         EVENP, 0, 0, 0,
-       "-even",        0, EVENP, 0, 0,
-       "odd",          ODDP, 0, 0, 0,
-       "-odd",         0, ODDP, 0, 0,
-       "raw",          RAW, 0, 0, 0,
-       "-raw",         0, RAW, 0, 0,
-       "cooked",       0, RAW, 0, 0,
-       "-nl",          CRMOD, 0, 0, 0,
-       "nl",           0, CRMOD, 0, 0,
-       "echo",         ECHO, 0, 0, 0,
-       "-echo",        0, ECHO, 0, 0,
-       "LCASE",        LCASE, 0, 0, 0,
-       "lcase",        LCASE, 0, 0, 0,
-       "-LCASE",       0, LCASE, 0, 0,
-       "-lcase",       0, LCASE, 0, 0,
-       "-tabs",        XTABS, 0, 0, 0,
-       "tabs",         0, XTABS, 0, 0,
-       "tandem",       TANDEM, 0, 0, 0,
-       "-tandem",      0, TANDEM, 0, 0,
-       "cbreak",       CBREAK, 0, 0, 0,
-       "-cbreak",      0, CBREAK, 0, 0,
-       "cr0",          CR0, CR3, 0, 0,
-       "cr1",          CR1, CR3, 0, 0,
-       "cr2",          CR2, CR3, 0, 0,
-       "cr3",          CR3, CR3, 0, 0,
-       "tab0",         TAB0, XTABS, 0, 0,
-       "tab1",         TAB1, XTABS, 0, 0,
-       "tab2",         TAB2, XTABS, 0, 0,
-       "nl0",          NL0, NL3, 0, 0,
-       "nl1",          NL1, NL3, 0, 0,
-       "nl2",          NL2, NL3, 0, 0,
-       "nl3",          NL3, NL3, 0, 0,
-       "ff0",          FF0, FF1, 0, 0,
-       "ff1",          FF1, FF1, 0, 0,
-       "bs0",          BS0, BS1, 0, 0,
-       "bs1",          BS1, BS1, 0, 0,
-       "33",           CR1, ALLDELAY, 0, 0,
-       "tty33",        CR1, ALLDELAY, 0, 0,
-       "37",           FF1+CR2+TAB1+NL1, ALLDELAY, 0, 0,
-       "tty37",        FF1+CR2+TAB1+NL1, ALLDELAY, 0, 0,
-       "05",           NL2, ALLDELAY, 0, 0,
-       "vt05",         NL2, ALLDELAY, 0, 0,
-       "tn",           CR1, ALLDELAY, 0, 0,
-       "tn300",        CR1, ALLDELAY, 0, 0,
-       "ti",           CR2, ALLDELAY, 0, 0,
-       "ti700",        CR2, ALLDELAY, 0, 0,
-       "tek",          FF1, ALLDELAY, 0, 0,
-       "crtbs",        0, 0, LCRTBS, LPRTERA,
-       "-crtbs",       0, 0, 0, LCRTBS,
-       "prterase",     0, 0, LPRTERA, LCRTBS+LCRTKIL+LCRTERA,
-       "-prterase",    0, 0, 0, LPRTERA,
-       "crterase",     0, 0, LCRTERA, LPRTERA,
-       "-crterase",    0, 0, 0, LCRTERA,
-       "crtkill",      0, 0, LCRTKIL, LPRTERA,
-       "-crtkill",     0, 0, 0, LCRTKIL,
-       "tilde",        0, 0, LTILDE, 0,
-       "-tilde",       0, 0, 0, LTILDE,
-       "mdmbuf",       0, 0, LMDMBUF, 0,
-       "-mdmbuf",      0, 0, 0, LMDMBUF,
-       "litout",       0, 0, LLITOUT, 0,
-       "-litout",      0, 0, 0, LLITOUT,
-       "tostop",       0, 0, LTOSTOP, 0,
-       "-tostop",      0, 0, 0, LTOSTOP,
-       "flusho",       0, 0, LFLUSHO, 0,
-       "-flusho",      0, 0, 0, LFLUSHO,
-       "nohang",       0, 0, LNOHANG, 0,
-       "-nohang",      0, 0, 0, LNOHANG,
-       "etxack",       0, 0, LETXACK, 0,
-       "-etxack",      0, 0, 0, LETXACK,
-       "ctlecho",      0, 0, LCTLECH, 0,
-       "-ctlecho",     0, 0, 0, LCTLECH,
-       "pendin",       0, 0, LPENDIN, 0,
-       "-pendin",      0, 0, 0, LPENDIN,
-       "decctlq",      0, 0, LDECCTQ, 0,
-       "-decctlq",     0, 0, 0, LDECCTQ,
-       "noflsh",       0, 0, LNOFLSH, 0,
-       "-noflsh",      0, 0, 0, LNOFLSH,
-       0,
+       { "even",       EVENP,          0 },
+       { "-even",      0,              EVENP },
+       { "odd",        ODDP,           0 },
+       { "-odd",       0,              ODDP },
+       { "raw",        RAW,            0 },
+       { "-raw",       0,              RAW },
+       { "cooked",     0,              RAW },
+       { "-nl",        CRMOD,          0 },
+       { "nl",         0,              CRMOD },
+       { "echo",       ECHO,           0 },
+       { "-echo",      0,              ECHO },
+       { "LCASE",      LCASE,          0 },
+       { "lcase",      LCASE,          0 },
+       { "-LCASE",     0,              LCASE },
+       { "-lcase",     0,              LCASE },
+       { "-tabs",      XTABS,          0 },
+       { "tabs",       0,              XTABS },
+       { "tandem",     TANDEM,         0 },
+       { "-tandem",    0,              TANDEM },
+       { "cbreak",     CBREAK,         0 },
+       { "-cbreak",    0,              CBREAK },
+       { "cr0",        CR0,            CR3 },
+       { "cr1",        CR1,            CR3 },
+       { "cr2",        CR2,            CR3 },
+       { "cr3",        CR3,            CR3 },
+       { "tab0",       TAB0,           XTABS },
+       { "tab1",       TAB1,           XTABS },
+       { "tab2",       TAB2,           XTABS },
+       { "nl0",        NL0,            NL3 },
+       { "nl1",        NL1,            NL3 },
+       { "nl2",        NL2,            NL3 },
+       { "nl3",        NL3,            NL3 },
+       { "ff0",        FF0,            FF1 },
+       { "ff1",        FF1,            FF1 },
+       { "bs0",        BS0,            BS1 },
+       { "bs1",        BS1,            BS1 },
+       { "33",         CR1,            ALLDELAY },
+       { "tty33",      CR1,            ALLDELAY },
+       { "37",         FF1+CR2+TAB1+NL1, ALLDELAY },
+       { "tty37",      FF1+CR2+TAB1+NL1, ALLDELAY },
+       { "05",         NL2,            ALLDELAY },
+       { "vt05",       NL2,            ALLDELAY },
+       { "tn",         CR1,            ALLDELAY },
+       { "tn300",      CR1,            ALLDELAY },
+       { "ti",         CR2,            ALLDELAY },
+       { "ti700",      CR2,            ALLDELAY },
+       { "tek",        FF1,            ALLDELAY },
+       { "crtbs",      CRTBS,          PRTERA },
+       { "-crtbs",     0,              CRTBS },
+       { "prterase",   PRTERA,         CRTBS+CRTKIL+CRTERA },
+       { "-prterase",  0,              PRTERA },
+       { "crterase",   CRTERA,         PRTERA },
+       { "-crterase",  0,              CRTERA },
+       { "crtkill",    CRTKIL,         PRTERA },
+       { "-crtkill",   0,              CRTKIL },
+       { "tilde",      TILDE,          0 },
+       { "-tilde",     0,              TILDE },
+       { "mdmbuf",     MDMBUF,         0 },
+       { "-mdmbuf",    0,              MDMBUF },
+       { "litout",     LITOUT,         0 },
+       { "-litout",    0,              LITOUT },
+       { "tostop",     TOSTOP,         0 },
+       { "-tostop",    0,              TOSTOP },
+       { "flusho",     FLUSHO,         0 },
+       { "-flusho",    0,              FLUSHO },
+       { "nohang",     NOHANG,         0 },
+       { "-nohang",    0,              NOHANG },
+#ifdef notdef
+       { "etxack",     ETXACK,         0 },
+       { "-etxack",    0,              ETXACK },
+#endif
+       { "ctlecho",    CTLECH,         0 },
+       { "-ctlecho",   0,              CTLECH },
+       { "pendin",     PENDIN,         0 },
+       { "-pendin",    0,              PENDIN },
+       { "decctlq",    DECCTQ,         0 },
+       { "-decctlq",   0,              DECCTQ },
+       { "noflsh",     NOFLSH,         0 },
+       { "-noflsh",    0,              NOFLSH },
+       { 0 },

 };
 
 };
 

-struct tchars tc;
-struct ltchars ltc;
-struct sgttyb mode;
-int    lmode;
+struct ttychars tc;
+struct sgttyb sb;
+long   flags;

 int    oldisc, ldisc;
 
 int    oldisc, ldisc;
 

-#define        CTRL(x)         ('x'&037)
-

 struct special {
        char    *name;
        char    *cp;
        char    def;
 } special[] = {
 struct special {
        char    *name;
        char    *cp;
        char    def;
 } special[] = {

-       "erase",        &mode.sg_erase,         CTRL(h),
-       "kill",         &mode.sg_kill,          '@',
-       "intr",         &tc.t_intrc,            0177,
-       "quit",         &tc.t_quitc,            CTRL(\\\\),
-       "start",        &tc.t_startc,           CTRL(q),
-       "stop",         &tc.t_stopc,            CTRL(s),
-       "eof",          &tc.t_eofc,             CTRL(d),
-       "brk",          &tc.t_brkc,             0377,
-       "susp",         &ltc.t_suspc,           CTRL(z),
-       "dsusp",        &ltc.t_dsuspc,          CTRL(y),
-       "rprnt",        &ltc.t_rprntc,          CTRL(r),
-       "flush",        &ltc.t_flushc,          CTRL(o),
-       "werase",       &ltc.t_werasc,          CTRL(w),
-       "lnext",        &ltc.t_lnextc,          CTRL(v),
+       { "erase",      &tc.tc_erase,           CERASE },
+       { "kill",       &tc.tc_kill,            CKILL },
+       { "intr",       &tc.tc_intrc,           CINTR },
+       { "quit",       &tc.tc_quitc,           CQUIT },
+       { "start",      &tc.tc_startc,          CSTART },
+       { "stop",       &tc.tc_stopc,           CSTOP },
+       { "eof",        &tc.tc_eofc,            CEOF },
+       { "brk",        &tc.tc_brkc,            CBRK },
+       { "susp",       &tc.tc_suspc,           CSUSP },
+       { "dsusp",      &tc.tc_dsuspc,          CDSUSP },
+       { "rprnt",      &tc.tc_rprntc,          CRPRNT },
+       { "flush",      &tc.tc_flushc,          CFLUSH },
+       { "werase",     &tc.tc_werasc,          CWERASE },
+       { "lnext",      &tc.tc_lnextc,          CLNEXT },

        0
 };
 char   *arg;
 
 int    argc;
 char   **argv;
        0
 };
 char   *arg;
 
 int    argc;
 char   **argv;

+

 main(iargc, iargv)
 main(iargc, iargv)

-char   **iargv;
+       int iargc;
+       char *iargv[];

 {
        int i;
        register struct special *sp;
 {
        int i;
        register struct special *sp;


@@ -163,13 +161,14 @@ char      **iargv;
        setbuf(stderr, obuf);
        argc = iargc;
        argv = iargv;
        setbuf(stderr, obuf);
        argc = iargc;
        argv = iargv;

-       gtty(1, &mode);
+       ioctl(1, TIOCCGET, (char *)&tc);
+       ioctl(1, TIOCGET, (char *)&flags);

        ioctl(1, TIOCGETD, &ldisc);
        ioctl(1, TIOCGETD, &ldisc);

+#ifndef notdef
+       ioctl(1, TIOCGETP, (char *)&sb);
+#endif

        oldisc = ldisc;
        oldisc = ldisc;

-       ioctl(1, TIOCGETC, &tc);
-       ioctl(1, TIOCLGET, &lmode);
-       ioctl(1, TIOCGLTC, &ltc);
-       if(argc == 1) {
+       if (argc == 1) {

                prmodes(0);
                exit(0);
        }
                prmodes(0);
                exit(0);
        }


@@ -181,58 +180,52 @@ char      **iargv;
                prmodes(2);
                exit(0);
        }
                prmodes(2);
                exit(0);
        }

-/*
-       if (argc == 2 && !strcmp(argv[1], "all")) {
-               prmodes(2);
-               exit(0);
-       }
-*/
-       while(--argc > 0) {
+       while (--argc > 0) {

                arg = *++argv;
                arg = *++argv;

-               if (eq("ek")){
-                       mode.sg_erase = '#';
-                       mode.sg_kill = '@';
+               if (eq("ek")) {
+                       tc.tc_erase = '#';
+                       tc.tc_kill = '@';

                        continue;
                }
                        continue;
                }

-               if (eq("new")){
+               if (eq("new")) {

                        ldisc = NTTYDISC;
                        ldisc = NTTYDISC;

-                       if (ioctl(1, TIOCSETD, &ldisc)<0)
+                       if (ioctl(1, TIOCSETD, &ldisc) < 0)

                                perror("ioctl");
                        continue;
                }
                                perror("ioctl");
                        continue;
                }

-               if (eq("newcrt")){
+               if (eq("newcrt")) {

                        ldisc = NTTYDISC;
                        ldisc = NTTYDISC;

-                       lmode &= ~LPRTERA;
-                       lmode |= LCRTBS|LCTLECH;
-                       if (mode.sg_ospeed >= B1200)
-                               lmode |= LCRTERA|LCRTKIL;
-                       if (ioctl(1, TIOCSETD, &ldisc)<0)
+                       flags &= ~PRTERA;
+                       flags |= CRTBS|CTLECH;
+                       if (sb.sg_ospeed >= B1200)
+                               flags |= CRTERA|CRTKIL;
+                       if (ioctl(1, TIOCSETD, &ldisc) < 0)

                                perror("ioctl");
                        continue;
                }
                                perror("ioctl");
                        continue;
                }

-               if (eq("crt")){
-                       lmode &= ~LPRTERA;
-                       lmode |= LCRTBS|LCTLECH;
-                       if (mode.sg_ospeed >= B1200)
-                               lmode |= LCRTERA|LCRTKIL;
+               if (eq("crt")) {
+                       flags &= ~PRTERA;
+                       flags |= CRTBS|CTLECH;
+                       if (sb.sg_ospeed >= B1200)
+                               flags |= CRTERA|CRTKIL;

                        continue;
                }
                        continue;
                }

-               if (eq("old")){
-                       ldisc = 0;
-                       if (ioctl(1, TIOCSETD, &ldisc)<0)
+               if (eq("old")) {
+                       ldisc = OTTYDISC;
+                       if (ioctl(1, TIOCSETD, &ldisc) < 0)

                                perror("ioctl");
                        continue;
                }
                                perror("ioctl");
                        continue;
                }

-               if (eq("dec")){
-                       mode.sg_erase = 0177;
-                       mode.sg_kill = CTRL(u);
-                       tc.t_intrc = CTRL(c);
+               if (eq("dec")) {
+                       tc.tc_erase = 0177;
+                       tc.tc_kill = CTRL(u);
+                       tc.tc_intrc = CTRL(c);

                        ldisc = NTTYDISC;
                        ldisc = NTTYDISC;

-                       lmode &= ~LPRTERA;
-                       lmode |= LCRTBS|LCTLECH|LDECCTQ;
-                       if (mode.sg_ospeed >= B1200)
-                               lmode |= LCRTERA|LCRTKIL;
-                       if (ioctl(1, TIOCSETD, &ldisc)<0)
+                       flags &= ~PRTERA;
+                       flags |= CRTBS|CTLECH|DECCTQ;
+                       if (sb.sg_ospeed >= B1200)
+                               flags |= CRTERA|CRTKIL;
+                       if (ioctl(1, TIOCSETD, &ldisc) < 0)

                                perror("ioctl");
                        continue;
                }
                                perror("ioctl");
                        continue;
                }


@@ -250,151 +243,160 @@ char    **iargv;
                                goto cont;
                        }
                if (eq("gspeed")) {
                                goto cont;
                        }
                if (eq("gspeed")) {

-                       mode.sg_ispeed = B300;
-                       mode.sg_ospeed = B9600;
+                       sb.sg_ispeed = B300;
+                       sb.sg_ospeed = B9600;

                        continue;
                }
                if (eq("hup")) {
                        continue;
                }
                if (eq("hup")) {

-                       ioctl(1, TIOCHPCL, NULL);
+                       if (ioctl(1, TIOCHPCL, NULL) < 0)
+                               perror("ioctl");

                        continue;
                }
                        continue;
                }

-               for(i=0; speeds[i].string; i++)
-                       if(eq(speeds[i].string)) {
-                               mode.sg_ispeed = mode.sg_ospeed = speeds[i].speed;
+               for (i = 0; speeds[i].string; i++)
+                       if (eq(speeds[i].string)) {
+                               sb.sg_ispeed = sb.sg_ospeed = speeds[i].speed;

                                goto cont;
                        }
                if (eq("speed")) {
                                goto cont;
                        }
                if (eq("speed")) {

-                       gtty(open("/dev/tty", 0), &mode);
-                       for(i=0; speeds[i].string; i++)
-                               if (mode.sg_ospeed == speeds[i].speed) {
+                       int fd = open("/dev/tty", 0);
+
+                       if (fd < 0) {
+                               perror("open");
+                               exit(1);
+                       }
+                       ioctl(fd, TIOCGETP, &sb);
+                       for (i = 0; speeds[i].string; i++)
+                               if (sb.sg_ospeed == speeds[i].speed) {

                                        printf("%s\n", speeds[i].string);
                                        exit(0);
                                }
                        printf("unknown\n");
                        exit(1);
                }
                                        printf("%s\n", speeds[i].string);
                                        exit(0);
                                }
                        printf("unknown\n");
                        exit(1);
                }

-               for(i=0; modes[i].string; i++)
-                       if(eq(modes[i].string)) {
-                               mode.sg_flags &= ~modes[i].reset;
-                               mode.sg_flags |= modes[i].set;
-                               lmode &= ~modes[i].lreset;
-                               lmode |= modes[i].lset;
+               for (i = 0; modes[i].string; i++)
+                       if (eq(modes[i].string)) {
+                               flags &= ~modes[i].reset;
+                               flags |= modes[i].set;

                        }
                        }

-               if(arg)
+               if (arg)

                        fprintf(stderr,"unknown mode: %s\n", arg);
 cont:
                ;
        }
 done:
                        fprintf(stderr,"unknown mode: %s\n", arg);
 cont:
                ;
        }
 done:

-       ioctl(1, TIOCSETN, &mode);
-       ioctl(1, TIOCSETC, &tc);
-       ioctl(1, TIOCSLTC, &ltc);
-       ioctl(1, TIOCLSET, &lmode);
+#ifndef notdef
+       ioctl(1, TIOCSETN, &sb);
+#endif
+       ioctl(1, TIOCSET, &flags);
+       ioctl(1, TIOCCSET, &tc);

 }
 
 eq(string)
 }
 
 eq(string)

-char *string;
+       char *string;

 {
        int i;
 
 {
        int i;
 

-       if(!arg)
-               return(0);
+       if (!arg)
+               return (0);

        i = 0;
 loop:
        i = 0;
 loop:

-       if(arg[i] != string[i])
+       if (arg[i] != string[i])

                return(0);
                return(0);

-       if(arg[i++] != '\0')
+       if (arg[i++] != '\0')

                goto loop;
        arg = 0;
                goto loop;
        arg = 0;

-       return(1);
+       return (1);

 }
 
 prmodes(all)
 }
 
 prmodes(all)

+       int all;

 {
        register m;
        int any;
 
 {
        register m;
        int any;
 

-       if(ldisc==NETLDISC)
+       if (ldisc == NETLDISC)

                fprintf(stderr, "net discipline, ");
                fprintf(stderr, "net discipline, ");

-       else if(ldisc==NTTYDISC)
+       else if (ldisc == NTTYDISC)

                fprintf(stderr, "new tty, ");
                fprintf(stderr, "new tty, ");

-       else if(all==2)
+       else if (all == 2)

                fprintf(stderr, "old tty, ");
                fprintf(stderr, "old tty, ");

-       if(mode.sg_ispeed != mode.sg_ospeed) {
-               prspeed("input speed ", mode.sg_ispeed);
-               prspeed("output speed ", mode.sg_ospeed);
+       if(sb.sg_ispeed != sb.sg_ospeed) {
+               prspeed("input speed ", sb.sg_ispeed);
+               prspeed("output speed ", sb.sg_ospeed);

        } else
        } else

-               prspeed("speed ", mode.sg_ispeed);
-       fprintf(stderr, all==2 ? "\n" : "; ");
-       m = mode.sg_flags;
-       if(all==2 || (m&(EVENP|ODDP))!=(EVENP|ODDP)) {
-               if(m & EVENP)   fprintf(stderr,"even ");
-               if(m & ODDP)    fprintf(stderr,"odd ");
+               prspeed("speed ", sb.sg_ispeed);
+       fprintf(stderr, all == 2 ? "\n" : "; ");
+       m = flags;
+       if (all == 2 || (m&(EVENP|ODDP)) != (EVENP|ODDP)) {
+               if (m & EVENP)
+                       fprintf(stderr,"even ");
+               if (m & ODDP)
+                       fprintf(stderr,"odd ");

        }
        }

-       if(all==2 || m&RAW)
-               fprintf(stderr,"-raw "+((m&RAW)!=0));
-       if(all==2 || (m&CRMOD)==0)
-               fprintf(stderr,"-nl "+((m&CRMOD)==0));
-       if(all==2 || (m&ECHO)==0)
-               fprintf(stderr,"-echo "+((m&ECHO)!=0));
-       if(all==2 || (m&LCASE))
-               fprintf(stderr,"-lcase "+((m&LCASE)!=0));
-       if(all==2 || (m&TANDEM))
-               fprintf(stderr,"-tandem "+((m&TANDEM)!=0));
-       fprintf(stderr,"-tabs "+((m&XTABS)!=XTABS));
-       if(all==2 || (m&CBREAK))
-               fprintf(stderr,"-cbreak "+((m&CBREAK)!=0));
-       if(all==2 || (m&NLDELAY))
-               delay((m&NLDELAY)/NL1,  "nl");
-       if ((m&TBDELAY)!=XTABS)
-               delay((m&TBDELAY)/TAB1, "tab");
-       if(all==2 || (m&CRDELAY))
-               delay((m&CRDELAY)/CR1,  "cr");
-       if(all==2 || (m&VTDELAY))
-               delay((m&VTDELAY)/FF1,  "ff");
-       if(all==2 || (m&BSDELAY))
-               delay((m&BSDELAY)/BS1,  "bs");
+       if (all == 2 || m&RAW)
+               fprintf(stderr,"-raw " + ((m&RAW) != 0));
+       if (all == 2 || (m&CRMOD) == 0)
+               fprintf(stderr,"-nl " + ((m&CRMOD) == 0));
+       if (all == 2 || (m&ECHO) == 0)
+               fprintf(stderr,"-echo " + ((m&ECHO) != 0));
+       if (all == 2 || m&LCASE)
+               fprintf(stderr,"-lcase " + ((m&LCASE) != 0));
+       if (all == 2 || m&TANDEM)
+               fprintf(stderr,"-tandem " + ((m&TANDEM) != 0));
+       fprintf(stderr,"-tabs " + ((m&XTABS) != XTABS));
+       if (all == 2 || m&CBREAK)
+               fprintf(stderr,"-cbreak " + ((m&CBREAK) != 0));
+       if (all == 2 || m&NLDELAY)
+               delay((m&NLDELAY) / NL1, "nl");
+       if ((m&TBDELAY) != XTABS)
+               delay((m&TBDELAY)/ TAB1, "tab");
+       if (all == 2 || m&CRDELAY)
+               delay((m&CRDELAY) / CR1, "cr");
+       if (all == 2 || m&VTDELAY)
+               delay((m&VTDELAY) / FF1, "ff");
+       if (all == 2 || m&BSDELAY)
+               delay((m&BSDELAY) / BS1, "bs");

        if (all)
                fprintf(stderr,"\n");
 #define        lpit(what,str) \
        if (all)
                fprintf(stderr,"\n");
 #define        lpit(what,str) \

-       if (all==2||(lmode&what)) { \
-               fprintf(stderr,str+((lmode&what)!=0)); any++; \
+       if (all == 2 || flags&what) { \
+               fprintf(stderr,str + ((flags&what) != 0)); any++; \

        }
        if (ldisc == NTTYDISC) {
        }
        if (ldisc == NTTYDISC) {

-               int newcrt = (lmode&(LCTLECH|LCRTBS)) == (LCTLECH|LCRTBS) &&
-                   (lmode&(LCRTERA|LCRTKIL)) ==
-                     ((mode.sg_ospeed > B300) ? LCRTERA|LCRTKIL : 0);
+               int newcrt = (flags&(CTLECH|CRTBS)) == (CTLECH|CRTBS) &&
+                   (flags&(CRTERA|CRTKIL)) ==
+                     ((sb.sg_ospeed > B300) ? CRTERA|CRTKIL : 0);

                if (newcrt) {
                if (newcrt) {

-                       if (all==2)
-                               fprintf(stderr, "crt: (crtbs crterase crtkill ctlecho) ");
-                       else
-                               fprintf(stderr, "crt ");
+                       fprintf(stderr, all != 2 ? "crt" :
+                                "crt: (crtbs crterase crtkill ctlecho) ");

                        any++;
                } else {
                        any++;
                } else {

-                       lpit(LCRTBS, "-crtbs ");
-                       lpit(LCRTERA, "-crterase ");
-                       lpit(LCRTKIL, "-crtkill ");
-                       lpit(LCTLECH, "-ctlecho ");
-                       lpit(LPRTERA, "-prterase ");
+                       lpit(CRTBS, "-crtbs ");
+                       lpit(CRTERA, "-crterase ");
+                       lpit(CRTKIL, "-crtkill ");
+                       lpit(CTLECH, "-ctlecho ");
+                       lpit(PRTERA, "-prterase ");

                }
                }

-               lpit(LTOSTOP, "-tostop ");
-               if (all==2) {
+               lpit(TOSTOP, "-tostop ");
+               if (all == 2) {

                        fprintf(stderr, "\n");
                        any = 0;
                }
                        fprintf(stderr, "\n");
                        any = 0;
                }

-               lpit(LTILDE, "-tilde ");
-               lpit(LFLUSHO, "-flusho ");
-               lpit(LMDMBUF, "-mdmbuf ");
-               lpit(LLITOUT, "-litout ");
-               lpit(LNOHANG, "-nohang ");
+               lpit(TILDE, "-tilde ");
+               lpit(FLUSHO, "-flusho ");
+               lpit(MDMBUF, "-mdmbuf ");
+               lpit(LITOUT, "-litout ");
+               lpit(NOHANG, "-nohang ");

                if (any) {
                        fprintf(stderr,"\n");
                        any = 0;
                }
                if (any) {
                        fprintf(stderr,"\n");
                        any = 0;
                }

-               lpit(LETXACK, "-etxack ");
-               lpit(LPENDIN, "-pendin ");
-               lpit(LDECCTQ, "-decctlq ");
-               lpit(LNOFLSH, "-noflsh ");
+#ifdef notdef
+               lpit(ETXACK, "-etxack ");
+#endif
+               lpit(PENDIN, "-pendin ");
+               lpit(DECCTQ, "-decctlq ");
+               lpit(NOFLSH, "-noflsh ");

                if (any)
                        fprintf(stderr,"\n");
        } else if (!all)
                if (any)
                        fprintf(stderr,"\n");
        } else if (!all)


@@ -406,12 +408,12 @@ prmodes(all)
                        fprintf(stderr,"\
 erase  kill   intr   quit   stop   eof\
 \n");
                        fprintf(stderr,"\
 erase  kill   intr   quit   stop   eof\
 \n");

-                       pcol(mode.sg_erase, -1);
-                       pcol(mode.sg_kill, -1);
-                       pcol(tc.t_intrc, -1);
-                       pcol(tc.t_quitc, -1);
-                       pcol(tc.t_stopc, tc.t_startc);
-                       pcol(tc.t_eofc, tc.t_brkc);
+                       pcol(tc.tc_erase, -1);
+                       pcol(tc.tc_kill, -1);
+                       pcol(tc.tc_intrc, -1);
+                       pcol(tc.tc_quitc, -1);
+                       pcol(tc.tc_stopc, tc.tc_startc);
+                       pcol(tc.tc_eofc, tc.tc_brkc);

                        fprintf(stderr,"\n");
                        break;
 
                        fprintf(stderr,"\n");
                        break;
 


@@ -419,29 +421,30 @@ erase  kill   intr   quit   stop   eof\
                        fprintf(stderr,"\
 erase  kill   werase rprnt  flush  lnext  susp   intr   quit   stop   eof\
 \n"); 
                        fprintf(stderr,"\
 erase  kill   werase rprnt  flush  lnext  susp   intr   quit   stop   eof\
 \n"); 

-                       pcol(mode.sg_erase, -1);
-                       pcol(mode.sg_kill, -1);
-                       pcol(ltc.t_werasc, -1);
-                       pcol(ltc.t_rprntc, -1);
-                       pcol(ltc.t_flushc, -1);
-                       pcol(ltc.t_lnextc, -1);
-                       pcol(ltc.t_suspc, ltc.t_dsuspc);
-                       pcol(tc.t_intrc, -1);
-                       pcol(tc.t_quitc, -1);
-                       pcol(tc.t_stopc, tc.t_startc);
-                       pcol(tc.t_eofc, tc.t_brkc);
+                       pcol(tc.tc_erase, -1);
+                       pcol(tc.tc_kill, -1);
+                       pcol(tc.tc_werasc, -1);
+                       pcol(tc.tc_rprntc, -1);
+                       pcol(tc.tc_flushc, -1);
+                       pcol(tc.tc_lnextc, -1);
+                       pcol(tc.tc_suspc, tc.tc_dsuspc);
+                       pcol(tc.tc_intrc, -1);
+                       pcol(tc.tc_quitc, -1);
+                       pcol(tc.tc_stopc, tc.tc_startc);
+                       pcol(tc.tc_eofc, tc.tc_brkc);

                        fprintf(stderr,"\n");
                        break;
                }
        } else if (ldisc != NETLDISC) {
                register struct special *sp;
                int first = 1;
                        fprintf(stderr,"\n");
                        break;
                }
        } else if (ldisc != NETLDISC) {
                register struct special *sp;
                int first = 1;

+

                for (sp = special; sp->name; sp++) {
                        if ((*sp->cp&0377) != (sp->def&0377)) {
                                pit(*sp->cp, sp->name, first ? "" : ", ");
                                first = 0;
                        };
                for (sp = special; sp->name; sp++) {
                        if ((*sp->cp&0377) != (sp->def&0377)) {
                                pit(*sp->cp, sp->name, first ? "" : ", ");
                                first = 0;
                        };

-                       if (sp->cp == &tc.t_brkc && ldisc == 0)
+                       if (sp->cp == &tc.tc_brkc && ldisc == 0)

                                break;
                }
                if (first == 0)
                                break;
                }
                if (first == 0)


@@ -515,10 +518,10 @@ pit(what, itsname, sep)
 }
 
 delay(m, s)
 }
 
 delay(m, s)

-char *s;
+       char *s;

 {
 
 {
 

-       if(m)
+       if (m)

                fprintf(stderr,"%s%d ", s, m);
 }
 
                fprintf(stderr,"%s%d ", s, m);
 }