Return to term.c CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / new / jove

Annotation of 43BSDTahoe/new/jove/term.c, revision 1.1

1.1     ! root        1: /***************************************************************************
        !             2:  * This program is Copyright (C) 1986, 1987, 1988 by Jonathan Payne.  JOVE *
        !             3:  * is provided to you without charge, and with no warranty.  You may give  *
        !             4:  * away copies of JOVE, including sources, provided that this notice is    *
        !             5:  * included in all the files.                                              *
        !             6:  ***************************************************************************/
        !             7: 
        !             8: #include "jove.h"
        !             9: #include <ctype.h>
        !            10: #include <errno.h>
        !            11: 
        !            12: #ifndef MAC    /* most of the file... */
        !            13: 
        !            14: #ifndef MSDOS
        !            15: # ifdef SYSV
        !            16: #   include <termio.h>
        !            17: # else
        !            18: #   include <sgtty.h>
        !            19: # endif /* SYSV */
        !            20: #endif /* MSDOS */
        !            21: 
        !            22: #ifdef IPROCS
        !            23: # include <signal.h>
        !            24: #endif
        !            25: 
        !            26: #define _TERM
        !            27: #include "termcap.h"
        !            28: 
        !            29: /* Termcap definitions */
        !            30: 
        !            31: #ifndef IBMPC
        !            32: char   *CS,
        !            33:        *SO,
        !            34:        *SE,
        !            35:        *CM,
        !            36:        *CL,
        !            37:        *CE,
        !            38:        *HO,
        !            39:        *AL,
        !            40:        *DL,
        !            41:        *VS,
        !            42:        *VE,
        !            43:        *KS,
        !            44:        *KE,
        !            45:        *TI,
        !            46:        *TE,
        !            47:        *IC,
        !            48:        *DC,
        !            49:        *IM,
        !            50:        *EI,
        !            51:        *LL,
        !            52:        *M_IC,  /* Insert char with arg */
        !            53:        *M_DC,  /* Delete char with arg */
        !            54:        *M_AL,  /* Insert line with arg */
        !            55:        *M_DL,  /* Delete line with arg */
        !            56:        *SF,    /* Scroll forward */
        !            57:        *SR,
        !            58:        *SP,    /* Send Cursor Position */
        !            59:        *VB,
        !            60:        *BL,
        !            61:        *IP,    /* insert pad after character inserted */
        !            62:        *lPC,
        !            63:        *NL;
        !            64: #endif
        !            65: 
        !            66: int    LI,
        !            67:        ILI,    /* Internal lines, i.e., 23 of LI is 24. */
        !            68:        CO,
        !            69: 
        !            70:        UL,
        !            71:        MI,
        !            72:        SG,     /* number of magic cookies left by SO and SE */
        !            73:        XS,     /* whether standout is braindamaged */
        !            74: 
        !            75:        TABS,
        !            76:        UPlen,
        !            77:        HOlen,
        !            78:        LLlen;
        !            79: 
        !            80: extern char    PC,
        !            81:                *BC,
        !            82:                *UP;
        !            83: 
        !            84: #ifdef notdef
        !            85:        /*
        !            86:         * Are you sure about this one Jon?  On the SYSV system I tried this
        !            87:         * on I got a multiple definition of PC because it was already
        !            88:         * defined in -ltermcap.  Similarly for BC and UP ...
        !            89:         */
        !            90: # ifdef SYSVR2 /* release 2, at least */
        !            91: char   PC;
        !            92: # else
        !            93: extern char    PC;
        !            94: # endif /* SYSVR2 */
        !            95: #endif
        !            96: 
        !            97: #ifndef IBMPC
        !            98: static char    tspace[256];
        !            99: 
        !           100: /* The ordering of ts and meas must agree !! */
        !           101: static char    *ts="vsvealdlspcssosecmclcehoupbcicimdceillsfsrvbksketiteALDLICDCpcipblnl";
        !           102: static char    **meas[] = {
        !           103:        &VS, &VE, &AL, &DL, &SP, &CS, &SO, &SE,
        !           104:        &CM, &CL, &CE, &HO, &UP, &BC, &IC, &IM,
        !           105:        &DC, &EI, &LL, &SF, &SR, &VB, &KS, &KE,
        !           106:        &TI, &TE, &M_AL, &M_DL, &M_IC, &M_DC,
        !           107:        &lPC, &IP, &BL, &NL, 0
        !           108: };
        !           109: 
        !           110: static void
        !           111: gets(buf)
        !           112: char   *buf;
        !           113: {
        !           114:        buf[read(0, buf, 12) - 1] = 0;
        !           115: }      
        !           116: 
        !           117: /* VARARGS1 */
        !           118: 
        !           119: static void
        !           120: TermError(fmt, a)
        !           121: char   *fmt;
        !           122: {
        !           123:        printf(fmt, a);
        !           124:        flusho();
        !           125:        _exit(1);
        !           126: }
        !           127: 
        !           128: void
        !           129: getTERM()
        !           130: {
        !           131:        char    *getenv(), *tgetstr() ;
        !           132:        char    termbuf[13],
        !           133:                *termname = NULL,
        !           134:                *termp = tspace,
        !           135:                tbuff[2048];    /* Good grief! */
        !           136:        int     i;
        !           137: 
        !           138:        termname = getenv("TERM");
        !           139:        if ((termname == NULL) || (*termname == '\0') ||
        !           140:            (strcmp(termname, "dumb") == 0) ||
        !           141:            (strcmp(termname, "unknown") == 0) ||
        !           142:            (strcmp(termname, "network") == 0)) {
        !           143:                putstr("Enter terminal type (e.g, vt100): ");
        !           144:                flusho();
        !           145:                gets(termbuf);
        !           146:                if (termbuf[0] == 0)
        !           147:                        TermError(NullStr);
        !           148: 
        !           149:                termname = termbuf;
        !           150:        }
        !           151: 
        !           152:        if (tgetent(tbuff, termname) < 1)
        !           153:                TermError("[\"%s\" unknown terminal type?]", termname);
        !           154: 
        !           155:        if ((CO = tgetnum("co")) == -1)
        !           156: wimperr:       TermError("You can't run JOVE on a %s terminal.\n", termname);
        !           157: 
        !           158:        else if (CO > MAXCOLS)
        !           159:                CO = MAXCOLS;
        !           160: 
        !           161:        if ((LI = tgetnum("li")) == -1)
        !           162:                goto wimperr;
        !           163: 
        !           164:        if ((SG = tgetnum("sg")) == -1)
        !           165:                SG = 0;                 /* Used for mode line only */
        !           166: 
        !           167:        if ((XS = tgetflag("xs")) == -1)
        !           168:                XS = 0;                 /* Used for mode line only */
        !           169: 
        !           170:        for (i = 0; meas[i]; i++) {
        !           171:                *(meas[i]) = (char *) tgetstr(ts, &termp);
        !           172:                ts += 2;
        !           173:        }
        !           174:        if (lPC)
        !           175:                PC = *lPC;
        !           176:        if (XS)
        !           177:                SO = SE = 0;
        !           178: 
        !           179:        if (CS && !SR)
        !           180:                CS = SR = SF = 0;
        !           181: 
        !           182:        if (CS && !SF)
        !           183:                SF = "\n";
        !           184: 
        !           185:        if (IM && (*IM == 0))
        !           186:                IM = 0;
        !           187:        else
        !           188:                MI = tgetflag("mi");
        !           189: 
        !           190:        UL = tgetflag("ul");
        !           191: 
        !           192:        if (NL == 0)
        !           193:                NL = "\n";
        !           194:        else {                  /* strip stupid padding information */
        !           195:                while (isdigit(*NL))
        !           196:                        NL += 1;
        !           197:                if (*NL == '*')
        !           198:                        NL += 1;
        !           199:        }
        !           200: 
        !           201:        if (BL == 0)
        !           202:                BL = "\007";
        !           203: 
        !           204: #ifdef ID_CHAR
        !           205:        disp_opt_init();
        !           206: #endif
        !           207:        if (CanScroll = ((AL && DL) || CS))
        !           208:                IDline_setup(termname);
        !           209: }
        !           210: 
        !           211: #else
        !           212: 
        !           213: void
        !           214: InitCM()
        !           215: {
        !           216: }
        !           217: 
        !           218: int EGA;
        !           219: 
        !           220: void
        !           221: getTERM()
        !           222: {
        !           223:        char    *getenv(), *tgetstr() ;
        !           224:        char    *termname;
        !           225:        void    init_43(), init_term();
        !           226:        unsigned char lpp(), chpl();
        !           227: 
        !           228:        if (getenv("EGA") || (!stricmp(getenv("TERM"), "EGA"))) {
        !           229:           termname = "ega";
        !           230:           init_43();
        !           231:           EGA = 1;
        !           232:        }
        !           233:        else {
        !           234:           termname = "ibmpc";
        !           235:           init_term();
        !           236:           EGA = 0;
        !           237:        }
        !           238: 
        !           239:        CO = chpl();
        !           240:        LI = lpp();
        !           241: 
        !           242:        SG = 0;                 /* Used for mode line only */
        !           243:        XS = 0;                 /* Used for mode line only */
        !           244: 
        !           245:        CanScroll = 1;
        !           246: }
        !           247: 
        !           248: #endif /* IBMPC */
        !           249: 
        !           250: #else /* MAC */
        !           251: int    LI,
        !           252:        ILI,    /* Internal lines, i.e., 23 of LI is 24. */
        !           253:        CO,
        !           254:        TABS,
        !           255:        SG;
        !           256:        
        !           257: void getTERM()
        !           258: {
        !           259:        SG = 0;
        !           260:        CanScroll = 1;
        !           261: }
        !           262: 
        !           263: #endif /* MAC */
        !           264: 
        !           265: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.