home *** CD-ROM | disk | FTP | other *** search
/ IRIS Development Option 6.2 / IRIS_Development_Option_6.2_814-0478-001.iso / dist / dev.idb / usr / lib / lint / llib-lcurses.z / llib-lcurses
Text File  |  1996-03-14  |  17KB  |  727 lines
  1.  
  2. #ifdef        __STDC__
  3.  
  4. #include    <curses.h>
  5. #include    <term.h>
  6.  
  7. #else        /* __STDC__ */
  8.  
  9. #include    <curses.h>
  10. #include    <term.h>
  11.  
  12. static    char    *sp;
  13. static    chtype    cht;
  14. static    WINDOW    *wp;
  15. static    SCREEN    *scp;
  16.  
  17. /***************    START SVR3     ********************/
  18. #ifdef NOMACROS
  19. static    TERMINAL *tp;
  20. int    del_curterm(old) TERMINAL *old; { return 0; }
  21.  
  22. TERMINAL    *set_curterm(term)    TERMINAL *term;    { return tp; }
  23. #endif
  24.  
  25. void    termerr()    {}
  26.  
  27.     /*VARARGS*/
  28. int    mvprintw(y, x, fmt, args) int y, x; char *fmt; { return 0; }
  29.  
  30.     /*VARARGS3*/
  31. int    mvscanw(y, x, fmt, args) int y, x; char *fmt; { return 0; }
  32.  
  33.     /*VARARGS*/
  34. int    mvwprintw(win, y, x, fmt, args) WINDOW *win; int y, x; char *fmt; { return 0; }
  35.  
  36.     /*VARARGS*/
  37. int    mvwscanw(win, y, x, fmt, args) WINDOW *win; int y, x; char *fmt; { return 0; }
  38.  
  39. int    putp(str) char * str; { return 0; }
  40.  
  41.     /*VARARGS1*/
  42. int    printw(fmt, args) char *fmt; { return 0; }
  43.  
  44.     /*VARARGS1*/
  45. int    scanw(fmt, args) char *fmt; { return 0; }
  46.  
  47.     /*VARARGS2*/
  48. int    vwscanw(win, fmt, ap) WINDOW *win; char *fmt; { return 0; }
  49.  
  50.     /*VARARGS2*/
  51. int    vwprintw(win, fmt, ap) WINDOW *win; char *fmt; { return 0; }
  52.  
  53.     /*VARARGS2*/
  54. int    wprintw(win, fmt, args) WINDOW *win; char *fmt; { return 0; }
  55.  
  56.     /*VARARGS2*/
  57. int    wscanw(win, fmt, args) WINDOW *win; char *fmt; { return 0; }
  58.  
  59. int    LINES, COLS, TABSIZE, COLORS, COLOR_PAIRS;
  60. char    *UP, *BC, PC;
  61. short    ospeed;
  62. WINDOW    *stdscr, *curscr;
  63.  
  64. TERMINAL    *cur_term;
  65. struct    _bool_struct    *cur_bools;
  66. struct    _num_struct    *cur_nums;
  67. struct    _str_struct    *cur_strs;
  68.  
  69. TERMINAL        _first_term;
  70. struct    _bool_struct    _frst_bools;
  71. struct    _num_struct    _frst_nums;
  72. struct    _str_struct    _frst_strs;
  73.  
  74. char    *boolnames[], *boolcodes[], *boolfnames[],
  75.     *numnames[], *numcodes[], *numfnames[],
  76.     *strnames[], *strcodes[], *strfnames[];
  77.  
  78. /*
  79.  * Various tricks to shut up lint about things that are perfectly fine.
  80.  */
  81.  
  82. char    *Def_term, ttytype[1];
  83. char    *_unctrl[];
  84. chtype    *acs_map;
  85.  
  86. static
  87. _dummy_init()
  88. {
  89.     Def_term[0] = ttytype[0] = 0;
  90.     _unctrl[0] = "abc";
  91.     _dummy_init();
  92.     LINES = COLS = 1;
  93.     stdscr = curscr = NULL;
  94. }
  95.  
  96. /* internal routines and variables that no one else should be using */
  97. int    outchcount;
  98. SCREEN    *SP;
  99. int    _use_slk;
  100. int    _ripcounter;
  101. char    *curses_version;
  102. FILE    *outf;
  103.  
  104. struct    term *cur_term;
  105. int    _called_before;
  106. /***************    END SVR3    ********************/
  107. int    waddch(win, c) WINDOW *win; chtype c; { return 0; }
  108.  
  109. int    waddnstr(win, str, i)
  110.         WINDOW *win; char *str; int i; { return 0; }
  111.  
  112. int    baudrate() { return 0; }
  113.  
  114. int    wbkgd(win, ch) WINDOW *win; chtype ch; { return 0; }
  115.  
  116. int    wborder(win, ch1, ch2, ch3, ch4, ch5, ch6, ch7, ch8) 
  117.         WINDOW *win; chtype ch1, ch2, ch3, ch4, ch5, ch6, ch7, ch8;
  118.         { return 0; }
  119.  
  120. int    cbreak() { return 0; }
  121.  
  122. int    copywin(Srcwin,Dstwin,minRowSrc,minColSrc,
  123.         minRowDst,minColDst,maxRowDst,maxColDst,over_lay)
  124.         WINDOW *Srcwin,*Dstwin;
  125.         int minRowSrc,minColSrc,minRowDst,minColDst,maxRowDst,
  126.         maxColDst, over_lay; { return 0; }
  127.  
  128. int    curs_set(vis) int vis; { return 0; }
  129.  
  130. int    def_prog_mode() { return 0; }
  131.  
  132. void    delscreen(s) SCREEN *s; {}
  133.  
  134. void    curserr() {}
  135.  
  136. int    filter() { return 0; }
  137.  
  138. int    delterm(t) TERMINAL *t; { return 0; }
  139.  
  140. int    delay_output(ms) int ms; { return 0; }
  141.  
  142. int    m_addch(c) _ochtype c; { return 0; }
  143.  
  144. WINDOW    *m_initscr() { return wp; }
  145.  
  146. SCREEN    *m_newterm(type, outfptr, infptr) 
  147.         char *type; FILE *outfptr, infptr; { return scp; }
  148.  
  149. int    m_addstr(str) char * str; { return 0; }
  150.  
  151. int    m_clear() { return 0; }
  152.  
  153. int    m_erase() { return 0; }
  154.  
  155. int    m_move(y, x) int x, y; { return 0; }
  156.  
  157. int    m_refresh() { return 0; }
  158.  
  159. int    wdelch(win) WINDOW *win; { return 0; }
  160.  
  161. int    delkey(cp,i) char *cp; int i; { return 0; }
  162.  
  163. void    delkeymap(i) TERMINAL * i; {}
  164.  
  165. int    delwin(win) WINDOW *win; { return 0; }
  166.  
  167. WINDOW    *derwin(win, i1, i2, i3, i4) 
  168.         WINDOW *win; int i1, i2, i3, i4; { return wp; }
  169.  
  170. int    doupdate() { return 0; }
  171.  
  172. int    draino(ms) int ms; { return 0; }
  173.  
  174. WINDOW    *dupwin(win) WINDOW *win; { return wp; }
  175.  
  176. int    echo() { return 0; }
  177.  
  178. int    endwin() { return 0; }
  179.  
  180. int    isendwin() { return 0; }
  181.  
  182. char    erasechar() { return 'a'; }
  183.  
  184. int    flushinp() { return 0; }
  185.  
  186. int    garbagedlines(win, beg, num)
  187.         WINDOW *win; int beg, num; { return 0; }
  188.  
  189. int    garbagedwin(win) WINDOW *win; { return 0; }
  190.  
  191. int    wredrawln(win, beg, num)
  192.         WINDOW *win; int beg, num; { return 0; }
  193.  
  194. int    redrawwin(win) WINDOW *win; { return 0; }
  195.  
  196. int    wgetstr(win, str) WINDOW *win; char *str; { return 0; }
  197.  
  198. int    wgetnstr(win, str, n) WINDOW *win; char *str; int n; { return 0; }
  199.  
  200. int    _getsyx(y,x) int *y, *x; { return 0; }
  201.  
  202. WINDOW    *getwin(fp) FILE *fp; { return wp; }
  203.  
  204. int    has_ic() { return 0; }
  205.  
  206. int    has_il() { return 0; }
  207.  
  208. int    idlok(win,bf) WINDOW *win; int bf; { return 0; }
  209.  
  210. WINDOW    *initscr() { return wp; }
  211.  
  212. int    winsch(win, c) WINDOW *win; chtype c; { return 0; }
  213.  
  214. int    winsdelln(win,i) WINDOW *win; int i; { return 0; }
  215.  
  216. int    winsnstr(win, c, i) WINDOW *win; char *c; int i; { return 0; }
  217.  
  218. char    *keyname(key) int key; { return sp; }
  219.  
  220. int    keypad(win,bf) WINDOW *win; int bf; { return 0; }
  221.  
  222. char    killchar() { return 'a'; }
  223.  
  224. char    *longname() { return sp; }
  225.  
  226. int    meta(win,bf) WINDOW *win; int bf; { return 0; }
  227.  
  228. int    wmove(win, y, x) WINDOW *win; int y, x; { return 0; }
  229.  
  230. int    mvcur(ly, lx, y, x) int ly, lx, y, x; { return 0; }
  231.  
  232. int    mvderwin(win, c, i) WINDOW *win; int c, i; { return 0; }
  233.  
  234. int    mvwin(win, by, bx) WINDOW *win; int by, bx; { return 0; }
  235.  
  236. int    napms(ms) int ms; { return 0; }
  237.  
  238. int    newkey(c, i1, i2) char *c; int i1,i2; { return 0; }
  239.  
  240. SCREEN    *newscreen(c, i1, i2, i3, f1, f2)
  241.         char *c; int i1, i2, i3; FILE *f1, *f2; { return 0; }
  242.  
  243. WINDOW    *newwin(num_lines, num_cols, begy, begx)
  244.         int num_lines, num_cols, begy, begx; { return wp; }
  245.  
  246. int    nl() { return 0; }
  247.  
  248. int    nocbreak() { return 0; }
  249.  
  250. int    nodelay(win,bf) WINDOW *win; int bf; { return 0; }
  251.  
  252. int    noecho() { return 0; }
  253.  
  254. int    nonl() { return 0; }
  255.  
  256. int    noraw() { return 0; }
  257.  
  258. void    qiflush() {}
  259.  
  260. void    noqiflush() {}
  261.  
  262. int    pechochar(pad, ch) WINDOW *pad; chtype ch; { return 0; }
  263.  
  264. int    pnoutrefresh(pad, pminrow, pmincol, sminrow, smincol, smaxrow, smaxcol)
  265.         WINDOW *pad;
  266.         int pminrow, pmincol, sminrow, smincol, smaxrow, smaxcol;
  267.         { return 0; }
  268.  
  269. int    prefresh(pad, pminrow, pmincol, sminrow, smincol, smaxrow, smaxcol)
  270.         WINDOW *pad;
  271.         int pminrow, pmincol, sminrow, smincol, smaxrow, smaxcol;
  272.         { return 0; }
  273.  
  274. int    putwin(win,fp) WINDOW *win; FILE *fp; { return 0; }
  275.  
  276. int    raw() { return 0; }
  277.  
  278. int    wrefresh(win) WINDOW *win; { return 0; }
  279.  
  280. int    reset_shell_mode() { return 0; }
  281.  
  282. int    resetty() { return 0; }
  283.  
  284. int    restartterm(term, file, err) char *term; int file, *err; { return 0; }
  285.  
  286. int    ripoffline(line, init) int line, (*init)(); { return 0; }
  287.  
  288. int    getcury(win) WINDOW *win; { return 0; }
  289.  
  290. int    getcurx(win) WINDOW *win; { return 0; }
  291.  
  292. int    getmaxy(win) WINDOW *win; { return 0; }
  293.  
  294. int    getmaxx(win) WINDOW *win; { return 0; }
  295.  
  296. int    getbegy(win) WINDOW *win; { return 0; }
  297.  
  298. int    getbegx(win) WINDOW *win; { return 0; }
  299.  
  300. int    getpary(win) WINDOW *win; { return 0; }
  301.  
  302. int    getparx(win) WINDOW *win; { return 0; }
  303.  
  304. chtype    getbkgd(win) WINDOW *win; { return cht; }
  305.  
  306. chtype    getattrs(win) WINDOW *win; { return cht; }
  307.  
  308. int    savetty() { return 0; }
  309.  
  310. int    scr_dump(file) char *file; { return 0; }
  311.  
  312. int    scr_init(file) char *file; { return 0; }
  313.  
  314. int    scr_ll_dump(file) FILE *file; { return 0; }
  315.  
  316. int    scr_reset(file,i) FILE *file; int i; { return 0; }
  317.  
  318. int    scr_restore(file) char *file; { return 0; }
  319.  
  320. int    scr_set(file) char *file; { return 0; }
  321.  
  322. int    wscrl(win,i) WINDOW *win; int i; { return 0; }
  323.  
  324. SCREEN    *setcurscreen(new) SCREEN *new; { return scp; }
  325.  
  326. TERMINAL    *setcurterm(new) TERMINAL *new; { return (TERMINAL *)0; }
  327.  
  328. int    setkeymap() { return 0; }
  329.  
  330. int    wsetscrreg(win, i1, i2) WINDOW *win; int i1, i2; { return 0; }
  331.  
  332. int    setsyx(y,x) int y, x; { return 0; }
  333.  
  334. int    setupterm(term, file, err) char *term; int file, *err;
  335.         { return 0; }
  336.  
  337. int    reset_prog_mode() { return 0; }
  338.  
  339. int    def_shell_mode() { return 0; }
  340.  
  341. int    slk_clear() { return 0; }
  342.  
  343. char    *slk_label(num) int num; { return sp; }
  344.  
  345. int    slk_noutrefresh() { return 0; }
  346.  
  347. int    slk_refresh() { return 0; }
  348.  
  349. int    slk_restore() { return 0; }
  350.  
  351. int    slk_set(num, lab, fmt) int num, fmt; char *lab; { return 0; }
  352.  
  353. int    slk_start(i, ip) int i, *ip; { return 0; }
  354.  
  355. int    slk_touch() { return 0; }
  356.  
  357. int    slk_attron(a) chtype a; { return 0; }
  358.  
  359. int    slk_attroff(a) chtype a; { return 0; }
  360.  
  361. int    slk_attrset(a) chtype a; { return 0; }
  362.  
  363. void    wsyncdown(win) WINDOW *win; {}
  364.  
  365. void    wsyncup(win) WINDOW *win; {}
  366.  
  367. void    wcursyncup(win) WINDOW *win; {}
  368.  
  369. int    tgetent(bp, name) char *bp, *name; { return 0; }
  370.  
  371. int    tgetflag(id) char *id; { return 0; }
  372.  
  373. int    tgetnum(id) char *id; { return 0; }
  374.  
  375. char    *tgetstr(id, area) char *id, **area; { return sp; }
  376.  
  377. int    tgetch(i) int i; { return 0; }
  378.  
  379. char    *tgoto(cap, col, row) char *cap; int col, row; { return sp; }
  380.  
  381. int    tifgetflag(id) char *id; { return 0; }
  382.  
  383. int    tifgetnum(id) char *id; { return 0; }
  384.  
  385. char    *tifgetstr(id) char *id; { return sp; }
  386.  
  387. int    tigetflag(id) char *id; { return 0; }
  388.  
  389. int    tigetnum(id) char *id; { return 0; }
  390.  
  391. char    *tigetstr(id) char *id; { return sp; }
  392.  
  393. void    tinputfd(i) int i; {}
  394.  
  395. char    *tparm(instring, parms) 
  396.         char *instring; long parms; { return sp; }
  397.  
  398. int    tputs(cp, affcnt, outc) char *cp; int affcnt, (*outc)(); { return 0; }
  399.  
  400. int    traceon() { return 0; }
  401.  
  402. int    traceoff() { return 0; }
  403.  
  404. int    ttimeout(i) int i; { return 0; }
  405.  
  406. int    typeahead(fd) int fd; { return 0; }
  407.  
  408. void    vidupdate(a, b, c) chtype a, b; int (*c)(); {}
  409.  
  410. int    waddchnstr(win, b, c) 
  411.         WINDOW *win; chtype *b; int c; { return 0; }
  412.  
  413. int    wclrtobot(win) WINDOW *win; { return 0; }
  414.  
  415. int    wclrtoeol(win) WINDOW *win; { return 0; }
  416.  
  417. int    wechochar(win, ch) WINDOW *win; chtype ch; { return 0; }
  418.  
  419. int    wgetch(win) WINDOW *win; { return 0; }
  420.  
  421. int    winnstr(win, b, c) WINDOW *win; char *b; int c; { return 0; }
  422.  
  423. int    wnoutrefresh(win) WINDOW *win; { return 0; }
  424.  
  425. int    whline(win, a, b) WINDOW *win; chtype a; int b; { return 0; }
  426.  
  427. int    mvwhline(win, y,x,a, b) WINDOW *win; chtype a; int y,x,b; { return 0; }
  428.  
  429. int    mvwvline(win, y,x,a, b) WINDOW *win; chtype a; int y,x,b; { return 0; }
  430.  
  431. int    wvline(win, a, b) WINDOW *win; chtype a; int b; { return 0; }
  432.  
  433. int    addch(ch) chtype ch; { return 0; }
  434.  
  435. int    addnstr(s,n) char *s; int n; { return 0; }
  436.  
  437. int    addstr(str) char *str; { return 0; }
  438.  
  439. int    attroff(at) chtype at; { return 0; }
  440.  
  441. int    attron(at) chtype at; { return 0; }
  442.  
  443. int    attrset(at) chtype at; { return 0; }
  444.  
  445. int    bkgd(c) chtype c; { return 0; }
  446.  
  447. int    border(ch1, ch2, ch3, ch4, ch5, ch6, ch7, ch8) 
  448.         chtype ch1, ch2, ch3, ch4, ch5, ch6, ch7, ch8;
  449.         { return 0; }
  450.  
  451. int    clear() { return 0; }
  452.  
  453. int    clrtobot() { return 0; }
  454.  
  455. int    clrtoeol() { return 0; }
  456.  
  457. int    delch() { return 0; }
  458.  
  459. int    deleteln() { return 0; }
  460.  
  461. int    echochar(ch) chtype ch; { return 0; }
  462.  
  463. int    erase() { return 0; }
  464.  
  465. int    getch() { return 0; }
  466.  
  467. int    getstr(str) char *str; { return 0; }
  468.  
  469. chtype    inch() { return  cht; }
  470.  
  471. int    insch(c) chtype c; { return 0; }
  472.  
  473. int    insdelln(id) int id; { return 0; }
  474.  
  475. int    insertln() { return 0; }
  476.  
  477. int    insnstr(s,n) char *s; int n; { return 0; }
  478.  
  479. int    insstr(s) char *s; { return 0; }
  480.  
  481. int    move(y, x) int y, x; { return 0; }
  482.  
  483. int    refresh() { return 0; }
  484.  
  485. int    scrl(n) int n; { return 0; }
  486.  
  487. int    setscrreg(t,b) int t, b; { return 0; }
  488.  
  489. int    standend() { return 0; }
  490.  
  491. int    standout() { return 0; }
  492.  
  493. void    timeout(tm) int tm; {}
  494.  
  495. void    bkgdset(c) chtype c; {}
  496.  
  497. chtype    termattrs()    { return cht; }
  498.  
  499. /* functions to define environment flags of a window */
  500.  
  501. int    syncok(win,bf) WINDOW *win; int bf; { return 0; }
  502.  
  503. void    immedok(win,bf) WINDOW *win; int bf; {}
  504.  
  505. /* The following used to be functions in SVR3. */
  506.  
  507. int    notimeout(win,bf) WINDOW *win; int bf; { return 0; }
  508.  
  509. int    clearok(win,bf) WINDOW *win; int bf; { return 0; }
  510.  
  511. int    leaveok(win,bf) WINDOW *win; int bf; { return 0; }
  512.  
  513. int    scrollok(win,bf) WINDOW *win; int bf; { return 0; }
  514.  
  515. /* functions for handling video attributes */
  516.  
  517. int    wattroff(w,a) WINDOW *w; chtype a; { return 0; }
  518.  
  519. int    wattron(w,a) WINDOW *w; chtype a; { return 0; }
  520.  
  521. int    wattrset(w,a) WINDOW *w; chtype a; { return 0; }
  522.  
  523. /* functions for move and update */
  524. int    mvaddch(y,x,ch) int y,x; chtype ch; { return 0; }
  525.  
  526. int    mvaddchstr(y,x,ch) int y,x; chtype *ch; { return 0; }
  527.  
  528. int    mvaddchnstr(y,x,ch,n)
  529.         int y,x,n; chtype *ch; { return 0; }
  530.  
  531. int    mvinstr(y,x,s) int y,x;char *s; { return 0; }
  532.  
  533. int    mvwinstr(win,y,x,s) WINDOW *win;int y,x;char *s; { return 0; }
  534.  
  535. int    mvinnstr(y,x,s,n) int y,x,n;char *s; { return 0; }
  536.  
  537. int    mvwinnstr(win,y,x,s,n) WINDOW *win;int y,x,n;char *s; { return 0; }
  538.  
  539. int    mvinchstr(y,x,s) int y,x;chtype *s; { return 0; }
  540.  
  541. int    mvwinchstr(win,y,x,s) WINDOW *win;int y,x;chtype *s; { return 0; }
  542.  
  543. int    mvwinchnstr(win,y,x,s,n) WINDOW *win;int y,x,n;chtype *s; { return 0; }
  544.  
  545. int    mvwaddchstr(win,y,x,ch) WINDOW *win;int y,x; chtype *ch; { return 0; }
  546.  
  547. int    mvwaddchnstr(win,y,x,ch,n) WINDOW *win;int y,x; chtype *ch; int n; { return 0; }
  548.  
  549. int    mvaddnstr(y,x,s,n) char *s; int n, y, x; { return 0; }
  550.  
  551. int    mvaddstr(y,x,str) int y, x; char *str; { return 0; }
  552.  
  553. int    mvwaddstr(win,y,x,str) WINDOW *win;int y, x; char *str; { return 0; }
  554.  
  555. int    mvdelch(y,x) int y, x; { return 0; }
  556.  
  557. int    mvgetch(y,x) int y, x; { return 0; }
  558.  
  559. int    mvgetstr(y,x,str) int y, x; char *str; { return 0; }
  560.  
  561. chtype    mvinch(y,x) int y, x; { return cht; }
  562.  
  563. int    mvinsch(y,x,c) int y, x; chtype c; { return 0; }
  564.  
  565. int    mvinsnstr(y,x,s,n) int y, x, n; char *s; { return 0; }
  566.  
  567. int    mvinsstr(y,x,s) int y, x; char *s; { return 0; }
  568.  
  569. int    mvwaddch(win,y,x,ch)
  570.         WINDOW *win; int y,x; chtype ch; { return 0; }
  571.  
  572. int    mvwaddnstr(win,y,x,s,n)
  573.         WINDOW *win; char *s; int n, y, x; { return 0; }
  574.  
  575. int    mvwdelch(win,y,x) int y, x; WINDOW *win; { return 0; }
  576.  
  577. int    mvwgetch(win,y,x) int y, x; WINDOW *win; { return 0; }
  578.  
  579. int    mvwgetstr(win,y,x,str)
  580.         int y, x; WINDOW *win; char *str; { return 0; }
  581.  
  582. chtype    mvwinch(win,y,x) WINDOW *win; int y, x; { return cht; }
  583.  
  584. int    mvwinsch(win,y,x,c)
  585.         int y, x; WINDOW *win; chtype c; { return 0; }
  586.  
  587. int    mvwinsnstr(win,y,x,s,n)
  588.         int y, x, n; WINDOW *win; char *s; { return 0; }
  589.  
  590. int    mvwinsstr(win,y,x,s)
  591.         WINDOW *win; int y, x; char *s; { return 0; }
  592.  
  593. int    overlay(Src, Dst) WINDOW *Src, *Dst; { return 0; }
  594.  
  595. int    overwrite(Src, Dst) WINDOW *Src, *Dst; { return 0; }
  596.  
  597. int    wdeleteln(win) WINDOW *win; { return 0; }
  598.  
  599. int    winsertln(win) WINDOW *win; { return 0; }
  600.  
  601. int    wstandend(win) WINDOW *win; { return 0; }
  602.  
  603. int    wstandout(win) WINDOW *win; { return 0; }
  604.  
  605. int    beep() { return 0; }
  606.  
  607. int    flash() { return 0; }
  608.  
  609. WINDOW    *newpad(nlines, ncols) int nlines, ncols; { return wp; }
  610.  
  611. SCREEN    *set_term(new) SCREEN *new; { return scp; }
  612.  
  613. int    scroll(win) WINDOW *win; { return 0; }
  614.  
  615. int    slk_init(fmt) int fmt; { return 0; }
  616.  
  617. WINDOW    *subpad(orig, nlines, ncols, by, bx)
  618.     WINDOW *orig; int nlines, ncols, by, bx; { return wp; }
  619.  
  620. WINDOW    *subwin(orig, nlines, ncols, by, bx)
  621.         WINDOW *orig; int nlines, ncols, by, bx; { return wp; }
  622.  
  623. int    box(win, vert, hor) WINDOW *win; chtype vert, hor; { return 0; }
  624.  
  625. SCREEN    *newterm(type, ofd, ifd) 
  626.     char *type; FILE *ofd, *ifd; { return scp; }
  627.  
  628. int    vidputs(nmode, outc) chtype nmode, (*outc)(); { return 0; }
  629.  
  630. int    touchline(win, fline, num)
  631.         WINDOW *win; int fline, num; { return 0; }
  632.  
  633. int    wtouchln(win, y, n, flag) WINDOW *win; int y,n,flag; { return 0; }
  634.  
  635. int    touchwin(win) WINDOW *win; { return 0; }
  636.  
  637. chtype    winch(win) WINDOW *win; { return cht; }
  638.  
  639. int    waddstr(win,str) WINDOW *win; char *str; { return 0; }
  640.  
  641. int    werase(win) WINDOW *win; { return 0; }
  642.  
  643. int    wclear(win) WINDOW *win; { return 0; }
  644.  
  645. int    intrflush(win,bf) WINDOW *win; int bf; { return 0; }
  646.  
  647. int    ungetch(key) int key; { return 0; }
  648.  
  649. int    crmode() { return 0; }
  650.  
  651. int    nocrmode() { return 0; }
  652.  
  653. int    saveterm() { return 0; }
  654.  
  655. int    fixterm() { return 0; }
  656.  
  657. int    resetterm() { return 0; }
  658.  
  659. int    setterm(type) char *type; { return 0; }
  660.  
  661. int    gettmode() { return 0; }
  662.  
  663. int    halfdelay(tenths) int tenths; { return 0; }
  664.  
  665. int    winstr(win,str) WINDOW *win; char *str; { return 0; }
  666.  
  667. int    winchstr(win, s) WINDOW win; chtype *s; { return 0; }
  668.  
  669. int    winchnstr(win,s,n) WINDOW *win;chtype *s;int n; { return 0; }
  670.  
  671. int    waddchstr(win,str) WINDOW * win; char *str; { return 0; }
  672.  
  673. int    winsstr(win,str) WINDOW *win; char *str; { return 0; }
  674.  
  675. int    untouchwin(win) WINDOW *win; { return 0; }
  676.  
  677. /* functions for setting time-out length on inputs */
  678. void    wtimeout(win,tm) {}
  679.  
  680. int    vidattr(newmode) chtype newmode; { return 0; }
  681.  
  682. char    *unctrl(i)    int i; { return sp; }
  683.  
  684. int    is_wintouched(win)    WINDOW *win; { return 0; }
  685.  
  686. int    is_linetouched(win,line)    WINDOW *win; int line; { return 0; }
  687.  
  688. void    wbkgdset(win, ch) WINDOW *win; chtype ch; {}
  689.  
  690. char    *termname()    { return sp; }
  691.  
  692. void    idcok(win,bf) WINDOW *win; int bf; {}
  693.  
  694. int    color_content (color, r, g, b)    short color, *r,*g,*b;    { return 0; }
  695.  
  696. char    has_colors()    { return 'a'; }
  697.  
  698. int    init_color(color, r, g, b)    short color, r, g, b;    { return 0; }
  699.  
  700. int    start_color()    { return 0; }
  701.  
  702. int    init_pair (pair, f, b)    short pair, f, b;    { return 0; }
  703.  
  704. int    pair_content (pair, f, b)    short pair, *f, *b;    { return 0; }
  705.  
  706. char    can_change_color()    { return 'a'; }
  707.  
  708. void    use_env(bf)    bool bf; {}
  709.  
  710. int mouse_set(mbe) long int mbe; { return 0 ; }
  711.  
  712. int mouse_on(mbe) long int mbe; { return 0  ; }
  713.  
  714. int mouse_off(mbe) long int mbe; { return 0  ; } 
  715.  
  716. int request_mouse_pos() {}
  717.  
  718. void wmouse_position (win, x, y) WINDOW *win; int    *x, *y; {}
  719.  
  720.  
  721. int    map_button (a) unsigned long    a; { return 0 ; }
  722.  
  723. unsigned long getmouse() { }
  724.  
  725. unsigned long getbmap() { }
  726. #endif        /* __STDC__ */
  727.