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