Return to llib-lcurses CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / usr.bin / lint

Annotation of 43BSDTahoe/usr.bin/lint/llib-lcurses, revision 1.1

1.1     ! root        1: /* @(#)llib-lcurses    1.6 (Berkeley) 4/22/87 */
        !             2: 
        !             3: /* LINTLIBRARY */
        !             4: # include      "curses.h"
        !             5: 
        !             6: /*
        !             7:  * Fake declarations; all of these are declared as externs in curses.h,
        !             8:  * but lint needs something a little more solid than that
        !             9:  */
        !            10: 
        !            11: bool   AM, BS, CA, DA, DB, EO, HC, HZ, IN, MI, MS, NC, NS, OS, UL,
        !            12:        XB, XN, XT, XS, XX;
        !            13: char   *AL, *BC, *BT, *CD, *CE, *CL, *CM, *CR, *CS, *DC, *DL,
        !            14:        *DM, *DO, *ED, *EI, *K0, *K1, *K2, *K3, *K4, *K5, *K6,
        !            15:        *K7, *K8, *K9, *HO, *IC, *IM, *IP, *KD, *KE, *KH, *KL,
        !            16:        *KR, *KS, *KU, *LL, *MA, *ND, *NL, *RC, *SC, *SE, *SF,
        !            17:        *SO, *SR, *TA, *TE, *TI, *UC, *UE, *UP, *US, *VB, *VS,
        !            18:        *VE, *AL_PARM, *DL_PARM, *UP_PARM, *DOWN_PARM,
        !            19:        *LEFT_PARM, *RIGHT_PARM;
        !            20: char   PC;
        !            21: 
        !            22: /*
        !            23:  * From the tty modes...
        !            24:  */
        !            25: 
        !            26: bool   GT, NONL, UPPERCASE, normtty, _pfast;
        !            27: 
        !            28: # define       WINDOW  struct _win_st
        !            29: 
        !            30: bool   My_term, _echoit, _rawmode, _endwin;
        !            31: 
        !            32: char   *Def_term, ttytype[];
        !            33: 
        !            34: int    LINES, COLS, _tty_ch, _res_flg;
        !            35: 
        !            36: SGTTY  _tty;
        !            37: 
        !            38: WINDOW *stdscr, *curscr;
        !            39: 
        !            40:        box(win,vert,hor) WINDOW *win; int vert, hor; {}
        !            41:        delwin(win) WINDOW *win; {}
        !            42:        endwin() {}
        !            43:        gettmode() {}
        !            44: WINDOW *initscr() {
        !            45:        AL = AL;
        !            46:        AM = AM;
        !            47:        BC = BC;
        !            48:        BS = BS;
        !            49:        BT = BT;
        !            50:        CA = CA;
        !            51:        CD = CD;
        !            52:        CE = CE;
        !            53:        CL = CL;
        !            54:        CM = CM;
        !            55:        DA = DA;
        !            56:        DB = DB;
        !            57:        DC = DC;
        !            58:        DL = DL;
        !            59:        DM = DM;
        !            60:        DO = DO;
        !            61:        ED = ED;
        !            62:        EO = EO;
        !            63:        EI = EI;
        !            64:        GT = GT;
        !            65:        HO = HO;
        !            66:        HZ = HZ;
        !            67:        IC = IC;
        !            68:        IN = IN;
        !            69:        IM = IM;
        !            70:        IP = IP;
        !            71:        LL = LL;
        !            72:        MA = MA;
        !            73:        MI = MI;
        !            74:        NC = NC;
        !            75:        ND = ND;
        !            76:        OS = OS;
        !            77:        PC = PC;
        !            78:        SE = SE;
        !            79:        SF = SF;
        !            80:        SO = SO;
        !            81:        SR = SR;
        !            82:        TA = TA;
        !            83:        TE = TE;
        !            84:        TI = TI;
        !            85:        UC = UC;
        !            86:        UE = UE;
        !            87:        UL = UL;
        !            88:        UP = UP;
        !            89:        US = US;
        !            90:        VB = VB;
        !            91:        VE = VE;
        !            92:        VS = VS;
        !            93:        XN = XN;
        !            94:        NONL = NONL;
        !            95:        UPPERCASE = UPPERCASE;
        !            96:        normtty = normtty;
        !            97:        _pfast = _pfast;
        !            98:        _tty = _tty;
        !            99:        My_term = My_term;
        !           100:        _echoit = _echoit;
        !           101:        _rawmode = _rawmode;
        !           102:        LINES = LINES;
        !           103:        COLS = COLS;
        !           104:        _tty_ch = _tty_ch;
        !           105:        _res_flg = _res_flg;
        !           106:        stdscr = stdscr;
        !           107:        curscr = curscr;
        !           108:        _echoit = _echoit;
        !           109:        _rawmode = _rawmode;
        !           110:        _tty_ch = _tty_ch;
        !           111:        return (WINDOW *) 0;
        !           112: }
        !           113: char * longname(bp, def) char *bp, *def; { return bp; }
        !           114:        mvcur(ly,lx,y,x) int ly, lx, y, x; { }
        !           115: /* VARARGS3 */
        !           116:        mvprintw(y,x,fmt) int y, x; char *fmt; { return 0; }
        !           117: /* VARARGS3 */
        !           118:        mvscanw(y,x,fmt) int y, x; char *fmt; { return 0; }
        !           119: /* VARARGS4 */
        !           120:        mvwprintw(win,y,x,fmt) WINDOW *win; int y, x; char *fmt; { return 0; }
        !           121: /* VARARGS4 */
        !           122:        mvwscanw(win,y,x,fmt) WINDOW *win; int y, x; char *fmt; { return 0; }
        !           123: WINDOW *newwin(Nl, Nc, by, bx) int Nl, Nc, by, bx; { return (WINDOW *) 0; }
        !           124:        overlay(win1, win2) WINDOW *win1, *win2; { }
        !           125:        overwrite(win1, win2) WINDOW *win1, *win2; { }
        !           126: /* VARARGS1 */
        !           127:        printw(fmt) char *fmt; { return 0; }
        !           128: /* VARARGS1 */
        !           129:        scanw(fmt) char *fmt; { return 0; }
        !           130:        scroll(win) WINDOW *win; { return 0; }
        !           131:        setterm(type) char *type; { return 0; }
        !           132: WINDOW *subwin(o, Nl, Nc, by, bx) WINDOW *o; int Nl, Nc, by, bx; { return o; }
        !           133:        waddch(win,ch) WINDOW *win; char ch; { return 0; }
        !           134:        waddstr(win,str) WINDOW *win; char *str; { return 0; }
        !           135:        wclear(win) WINDOW *win; { return 0; }
        !           136:        wclrtobot(win) WINDOW *win; { return 0; }
        !           137:        wclrtoeol(win) WINDOW *win; { return 0; }
        !           138:        wdeleteln(win) WINDOW *win; { return 0; }
        !           139:        werase(win) WINDOW *win; { return 0; }
        !           140:        wgetch(win) WINDOW *win; { return '0'; }
        !           141:        wgetstr(win,str) WINDOW *win; char *str; { return 0; }
        !           142:        winsertln(win) WINDOW *win; { return 0; }
        !           143:        wmove(win,y,x) WINDOW *win; int y, x; { return 0; }
        !           144: /* VARARGS2 */
        !           145:        wprintw(win,fmt) WINDOW *win; char *fmt; { return 0; }
        !           146:        wrefresh(win) WINDOW *win; { return 0; }
        !           147: /* VARARGS2 */
        !           148:        wscanw(win,fmt) WINDOW *win; char *fmt; { return 0; }
        !           149:        /* These really return char *'s but this will do. */
        !           150: int    wstandout(win) WINDOW *win; { return 0; }
        !           151: int    wstandend(win) WINDOW *win; { return 0; }
        !           152: char * getcap(name) char * name; { return 0; }
        !           153: char * _unctrl[1];

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