Return to miniinit.c CVS log

Up to [Research Unix] / researchv10no / ncurses / screen

Annotation of researchv10no/ncurses/screen/miniinit.c, revision 1.1.1.1

1.1       root        1: /*     @(#) miniinit.c: 1.1 10/15/83   (1.5    3/16/83)        */
                      2: 
                      3: # include      "curses.ext"
                      4: # include      <signal.h>
                      5: 
                      6: char   *calloc();
                      7: extern char    *getenv();
                      8: 
                      9: static WINDOW  *makenew();
                     10: 
                     11: struct screen *m_newterm();
                     12: 
                     13: /*
                     14:  *     This routine initializes the current and standard screen.
                     15:  *
                     16:  * 3/5/81 (Berkeley) @(#)initscr.c     1.2
                     17:  */
                     18: 
                     19: WINDOW *
                     20: m_initscr() {
                     21:        reg char        *sp;
                     22:        
                     23: # ifdef DEBUG
                     24:        if (outf == NULL) {
                     25:                outf = fopen("trace", "w");
                     26:                if (outf == NULL) {
                     27:                        perror("trace");
                     28:                        exit(-1);
                     29:                }
                     30:        }
                     31: #endif
                     32: 
                     33:        if (isatty(2)) {
                     34:                if ((sp = getenv("TERM")) == NULL)
                     35:                        sp = Def_term;
                     36: # ifdef DEBUG
                     37:                if(outf) fprintf(outf, "INITSCR: term = %s\n", sp);
                     38: # endif
                     39:        }
                     40:        else {
                     41:                sp = Def_term;
                     42:        }
                     43:        (void) m_newterm(sp, stdout, stdin);
                     44:        return stdscr;
                     45: }
                     46: 
                     47: struct screen *
                     48: m_newterm(type, outfd, infd)
                     49: char *type;
                     50: FILE *outfd, *infd;
                     51: {
                     52:        int             m_tstp();
                     53:        struct screen *scp;
                     54:        struct screen *_new_tty();
                     55:        extern int _endwin;
                     56: 
                     57: #ifdef DEBUG
                     58:        if(outf) fprintf(outf, "NEWTERM() isatty(2) %d, getenv %s\n",
                     59:                isatty(2), getenv("TERM"));
                     60: # endif
                     61:        SP = (struct screen *) calloc(1, sizeof (struct screen));
                     62:        SP->term_file = outfd;
                     63:        SP->input_file = infd;
                     64:        savetty();
                     65:        scp = _new_tty(type, outfd);
                     66: # ifdef SIGTSTP
                     67:        signal(SIGTSTP, m_tstp);
                     68: # endif
                     69: 
                     70:        LINES = lines;
                     71:        COLS =  columns;
                     72: # ifdef DEBUG
                     73:        if(outf) fprintf(outf, "LINES = %d, COLS = %d\n", LINES, COLS);
                     74: # endif
                     75:        curscr = makenew(LINES, COLS, 0, 0);
                     76:        stdscr = makenew(LINES, COLS, 0, 0);
                     77: # ifdef DEBUG
                     78:        if(outf) fprintf(outf, "SP %x, stdscr %x, curscr %x\n", SP, stdscr, curscr);
                     79: # endif
                     80:        SP->std_scr = stdscr;
                     81:        SP->cur_scr = curscr;
                     82:        _endwin = FALSE;
                     83:        return scp;
                     84: }
                     85: 
                     86: /*
                     87:  * Low level interface, for compatibility with old curses.
                     88:  */
                     89: setterm(type)
                     90: char *type;
                     91: {
                     92:        setupterm(type, 1, 0);
                     93: }
                     94: 
                     95: gettmode()
                     96: {
                     97:        /* No-op included only for upward compatibility. */
                     98: }
                     99: 
                    100: /*
                    101:  *     This routine sets up a _window buffer and returns a pointer to it.
                    102:  */
                    103: static WINDOW *
                    104: makenew(num_lines, num_cols, begy, begx)
                    105: int    num_lines, num_cols, begy, begx;
                    106: {
                    107:        reg WINDOW      *win;
                    108:        char *calloc();
                    109: 
                    110: # ifdef        DEBUG
                    111:        if(outf) fprintf(outf, "MAKENEW(%d, %d, %d, %d)\n", num_lines, num_cols, begy, begx);
                    112: # endif
                    113:        if ((win = (WINDOW *) calloc(1, sizeof (WINDOW))) == NULL)
                    114:                return NULL;
                    115: # ifdef DEBUG
                    116:        if(outf) fprintf(outf, "MAKENEW: num_lines = %d\n", num_lines);
                    117: # endif
                    118:        win->_cury = win->_curx = 0;
                    119:        win->_maxy = num_lines;
                    120:        win->_maxx = num_cols;
                    121:        win->_begy = begy;
                    122:        win->_begx = begx;
                    123:        win->_scroll = win->_leave = win->_use_idl = FALSE;
                    124:        return win;
                    125: }

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