[p5sagit/p5-mst-13.2.git] / usub / curses.mus

/* $Header: curses.mus,v 4.0 91/03/20 01:56:13 lwall Locked $
 *
 * $Log:	curses.mus,v $
 * Revision 4.0  91/03/20  01:56:13  lwall
 * 4.0 baseline.
 * 
 * Revision 3.0.1.1  90/08/09  04:05:21  lwall
 * patch19: Initial revision
 * 
 */

#include "EXTERN.h"
#include "perl.h"
extern int wantarray;

char *savestr();

#include <curses.h>

static enum uservars {
    UV_curscr,
    UV_stdscr,
    UV_Def_term,
    UV_My_term,
    UV_ttytype,
    UV_LINES,
    UV_COLS,
    UV_ERR,
    UV_OK,
};

static enum usersubs {
    US_addch,
    US_waddch,
    US_addstr,
    US_waddstr,
    US_box,
    US_clear,
    US_wclear,
    US_clearok,
    US_clrtobot,
    US_wclrtobot,
    US_clrtoeol,
    US_wclrtoeol,
    US_delch,
    US_wdelch,
    US_deleteln,
    US_wdeleteln,
    US_erase,
    US_werase,
    US_flushok,
    US_idlok,
    US_insch,
    US_winsch,
    US_insertln,
    US_winsertln,
    US_move,
    US_wmove,
    US_overlay,
    US_overwrite,
    US_printw,
    US_wprintw,
    US_refresh,
    US_wrefresh,
    US_standout,
    US_wstandout,
    US_standend,
    US_wstandend,
    US_cbreak,
    US_nocbreak,
    US_echo,
    US_noecho,
    US_getch,
    US_wgetch,
    US_getstr,
    US_wgetstr,
    US_raw,
    US_noraw,
    US_scanw,
    US_wscanw,
    US_baudrate,
    US_delwin,
    US_endwin,
    US_erasechar,
    US_getcap,
    US_getyx,
    US_inch,
    US_winch,
    US_initscr,
    US_killchar,
    US_leaveok,
    US_longname,
    US_fullname,
    US_mvwin,
    US_newwin,
    US_nl,
    US_nonl,
    US_scrollok,
    US_subwin,
    US_touchline,
    US_touchoverlap,
    US_touchwin,
    US_unctrl,
    US_gettmode,
    US_mvcur,
    US_scroll,
    US_savetty,
    US_resetty,
    US_setterm,
    US_tstp,
    US__putchar,
};

static int usersub();
static int userset();
static int userval();

int
init_curses()
{
    struct ufuncs uf;
    char *filename = "curses.c";

    uf.uf_set = userset;
    uf.uf_val = userval;

#define MAGICVAR(name, ix) uf.uf_index = ix, magicname(name, &uf, sizeof uf)

    MAGICVAR("curscr",	UV_curscr);
    MAGICVAR("stdscr",	UV_stdscr);
    MAGICVAR("Def_term",UV_Def_term);
    MAGICVAR("My_term",	UV_My_term);
    MAGICVAR("ttytype",	UV_ttytype);
    MAGICVAR("LINES",	UV_LINES);
    MAGICVAR("COLS",	UV_COLS);
    MAGICVAR("ERR",	UV_ERR);
    MAGICVAR("OK",	UV_OK);

    make_usub("addch",		US_addch,	usersub, filename);
    make_usub("waddch",		US_waddch,	usersub, filename);
    make_usub("addstr",		US_addstr,	usersub, filename);
    make_usub("waddstr",	US_waddstr,	usersub, filename);
    make_usub("box",		US_box,		usersub, filename);
    make_usub("clear",		US_clear,	usersub, filename);
    make_usub("wclear",		US_wclear,	usersub, filename);
    make_usub("clearok",	US_clearok,	usersub, filename);
    make_usub("clrtobot",	US_clrtobot,	usersub, filename);
    make_usub("wclrtobot",	US_wclrtobot,	usersub, filename);
    make_usub("clrtoeol",	US_clrtoeol,	usersub, filename);
    make_usub("wclrtoeol",	US_wclrtoeol,	usersub, filename);
    make_usub("delch",		US_delch,	usersub, filename);
    make_usub("wdelch",		US_wdelch,	usersub, filename);
    make_usub("deleteln",	US_deleteln,	usersub, filename);
    make_usub("wdeleteln",	US_wdeleteln,	usersub, filename);
    make_usub("erase",		US_erase,	usersub, filename);
    make_usub("werase",		US_werase,	usersub, filename);
    make_usub("flushok",	US_flushok,	usersub, filename);
    make_usub("idlok",		US_idlok,	usersub, filename);
    make_usub("insch",		US_insch,	usersub, filename);
    make_usub("winsch",		US_winsch,	usersub, filename);
    make_usub("insertln",	US_insertln,	usersub, filename);
    make_usub("winsertln",	US_winsertln,	usersub, filename);
    make_usub("move",		US_move,	usersub, filename);
    make_usub("wmove",		US_wmove,	usersub, filename);
    make_usub("overlay",	US_overlay,	usersub, filename);
    make_usub("overwrite",	US_overwrite,	usersub, filename);
    make_usub("printw",		US_printw,	usersub, filename);
    make_usub("wprintw",	US_wprintw,	usersub, filename);
    make_usub("refresh",	US_refresh,	usersub, filename);
    make_usub("wrefresh",	US_wrefresh,	usersub, filename);
    make_usub("standout",	US_standout,	usersub, filename);
    make_usub("wstandout",	US_wstandout,	usersub, filename);
    make_usub("standend",	US_standend,	usersub, filename);
    make_usub("wstandend",	US_wstandend,	usersub, filename);
    make_usub("cbreak",		US_cbreak,	usersub, filename);
    make_usub("nocbreak",	US_nocbreak,	usersub, filename);
    make_usub("echo",		US_echo,	usersub, filename);
    make_usub("noecho",		US_noecho,	usersub, filename);
    make_usub("getch",		US_getch,	usersub, filename);
    make_usub("wgetch",		US_wgetch,	usersub, filename);
    make_usub("getstr",		US_getstr,	usersub, filename);
    make_usub("wgetstr",	US_wgetstr,	usersub, filename);
    make_usub("raw",		US_raw,		usersub, filename);
    make_usub("noraw",		US_noraw,	usersub, filename);
    make_usub("scanw",		US_scanw,	usersub, filename);
    make_usub("wscanw",		US_wscanw,	usersub, filename);
    make_usub("baudrate",	US_baudrate,	usersub, filename);
    make_usub("delwin",		US_delwin,	usersub, filename);
    make_usub("endwin",		US_endwin,	usersub, filename);
    make_usub("erasechar",	US_erasechar,	usersub, filename);
    make_usub("getcap",		US_getcap,	usersub, filename);
    make_usub("getyx",		US_getyx,	usersub, filename);
    make_usub("inch",		US_inch,	usersub, filename);
    make_usub("winch",		US_winch,	usersub, filename);
    make_usub("initscr",	US_initscr,	usersub, filename);
    make_usub("killchar",	US_killchar,	usersub, filename);
    make_usub("leaveok",	US_leaveok,	usersub, filename);
    make_usub("longname",	US_longname,	usersub, filename);
    make_usub("fullname",	US_fullname,	usersub, filename);
    make_usub("mvwin",		US_mvwin,	usersub, filename);
    make_usub("newwin",		US_newwin,	usersub, filename);
    make_usub("nl",		US_nl,		usersub, filename);
    make_usub("nonl",		US_nonl,	usersub, filename);
    make_usub("scrollok",	US_scrollok,	usersub, filename);
    make_usub("subwin",		US_subwin,	usersub, filename);
    make_usub("touchline",	US_touchline,	usersub, filename);
    make_usub("touchoverlap",	US_touchoverlap,usersub, filename);
    make_usub("touchwin",	US_touchwin,	usersub, filename);
    make_usub("unctrl",		US_unctrl,	usersub, filename);
    make_usub("gettmode",	US_gettmode,	usersub, filename);
    make_usub("mvcur",		US_mvcur,	usersub, filename);
    make_usub("scroll",		US_scroll,	usersub, filename);
    make_usub("savetty",	US_savetty,	usersub, filename);
    make_usub("resetty",	US_resetty,	usersub, filename);
    make_usub("setterm",	US_setterm,	usersub, filename);
    make_usub("tstp",		US_tstp,	usersub, filename);
    make_usub("_putchar",	US__putchar,	usersub, filename);
};

static int
usersub(ix, sp, items)
int ix;
register int sp;
register int items;
{
    STR **st = stack->ary_array + sp;
    register int i;
    register char *tmps;
    register STR *Str;		/* used in str_get and str_gnum macros */

    switch (ix) {
CASE int addch
I	char		ch
END

CASE int waddch
I	WINDOW*		win
I	char		ch
END

CASE int addstr
I	char*		str
END

CASE int waddstr
I	WINDOW*		win
I	char*		str
END

CASE int box
I	WINDOW*		win
I	char		vert
I	char		hor
END

CASE int clear
END

CASE int wclear
I	WINDOW*		win
END

CASE int clearok
I	WINDOW*		win
I	bool		boolf
END

CASE int clrtobot
END

CASE int wclrtobot
I	WINDOW*		win
END

CASE int clrtoeol
END

CASE int wclrtoeol
I	WINDOW*		win
END

CASE int delch
END

CASE int wdelch
I	WINDOW*		win
END

CASE int deleteln
END

CASE int wdeleteln
I	WINDOW*		win
END

CASE int erase
END

CASE int werase
I	WINDOW*		win
END

CASE int flushok
I	WINDOW*		win
I	bool		boolf
END

CASE int idlok
I	WINDOW*		win
I	bool		boolf
END

CASE int insch
I	char		c
END

CASE int winsch
I	WINDOW*		win
I	char		c
END

CASE int insertln
END

CASE int winsertln
I	WINDOW*		win
END

CASE int move
I	int		y
I	int		x
END

CASE int wmove
I	WINDOW*		win
I	int		y
I	int		x
END

CASE int overlay
I	WINDOW*		win1
I	WINDOW*		win2
END

CASE int overwrite
I	WINDOW*		win1
I	WINDOW*		win2
END

    case US_printw:
	if (items < 1)
	    fatal("Usage: &printw($fmt, $arg1, $arg2, ... )");
	else {
	    int retval;
	    STR*	str =		str_new(0);

	    do_sprintf(str, items - 1, st + 1);
	    retval = addstr(str->str_ptr);
	    str_numset(st[0], (double) retval);
	    str_free(str);
	}
	return sp;

    case US_wprintw:
	if (items < 2)
	    fatal("Usage: &wprintw($win, $fmt, $arg1, $arg2, ... )");
	else {
	    int retval;
	    STR*	str =		str_new(0);
	    WINDOW*	win =		*(WINDOW**)	str_get(st[1]);

	    do_sprintf(str, items - 1, st + 1);
	    retval = waddstr(win, str->str_ptr);
	    str_numset(st[0], (double) retval);
	    str_free(str);
	}
	return sp;

CASE int refresh
END

CASE int wrefresh
I	WINDOW*		win
END

CASE int standout
END

CASE int wstandout
I	WINDOW*		win
END

CASE int standend
END

CASE int wstandend
I	WINDOW*		win
END

CASE int cbreak
END

CASE int nocbreak
END

CASE int echo
END

CASE int noecho
END

    case US_getch:
        if (items != 0)
            fatal("Usage: &getch()");
        else {
            int retval;
	    char retch;

            retval = getch();
	    if (retval == EOF)
		st[0] = &str_undef;
	    else {
		retch = retval;
		str_nset(st[0], &retch, 1);
	    }
        }
        return sp;

    case US_wgetch:
        if (items != 1)
            fatal("Usage: &wgetch($win)");
        else {
            int retval;
	    char retch;
            WINDOW*     win =           *(WINDOW**)     str_get(st[1]);

            retval = wgetch(win);
	    if (retval == EOF)
		st[0] = &str_undef;
	    else {
		retch = retval;
		str_nset(st[0], &retch, 1);
	    }
        }
        return sp;

CASE int getstr
IO	char*		str
END

CASE int wgetstr
I	WINDOW*		win
IO	char*		str
END

CASE int raw
END

CASE int noraw
END

CASE int baudrate
END

CASE int delwin
I	WINDOW*		win
END

CASE int endwin
END

CASE int erasechar
END

CASE char* getcap
I	char*		str
END

    case US_getyx:
	if (items != 3)
	    fatal("Usage: &getyx($win, $y, $x)");
	else {
	    int retval;
	    STR*	str =		str_new(0);
	    WINDOW*	win =		*(WINDOW**)	str_get(st[1]);
	    int		y;
	    int		x;

	    do_sprintf(str, items - 1, st + 1);
	    retval = getyx(win, y, x);
	    str_numset(st[2], (double)y);
	    str_numset(st[3], (double)x);
	    str_numset(st[0], (double) retval);
	    str_free(str);
	}
	return sp;

	
CASE int inch
END

CASE int winch
I	WINDOW*		win
END

CASE WINDOW* initscr
END

CASE int killchar
END

CASE int leaveok
I	WINDOW*		win
I	bool		boolf
END

CASE char* longname
I	char*		termbuf
IO	char*		name
END

CASE int fullname
I	char*		termbuf
IO	char*		name
END

CASE int mvwin
I	WINDOW*		win
I	int		y
I	int		x
END

CASE WINDOW* newwin
I	int		lines
I	int		cols
I	int		begin_y
I	int		begin_x
END

CASE int nl
END

CASE int nonl
END

CASE int scrollok
I	WINDOW*		win
I	bool		boolf
END

CASE WINDOW* subwin
I	WINDOW*		win
I	int		lines
I	int		cols
I	int		begin_y
I	int		begin_x
END

CASE int touchline
I	WINDOW*		win
I	int		y
I	int		startx
I	int		endx
END

CASE int touchoverlap
I	WINDOW*		win1
I	WINDOW*		win2
END

CASE int touchwin
I	WINDOW*		win
END

CASE char* unctrl
I	char		ch
END

CASE int gettmode
END

CASE int mvcur
I	int		lasty
I	int		lastx
I	int		newy
I	int		newx
END

CASE int scroll
I	WINDOW*		win
END

CASE int savetty
END

CASE void resetty
END

CASE int setterm
I	char*		name
END

CASE int tstp
END

CASE int _putchar
I	char		ch
END

    default:
	fatal("Unimplemented user-defined subroutine");
    }
    return sp;
}

static int
userval(ix, str)
int ix;
STR *str;
{
    switch (ix) {
    case UV_COLS:
	str_numset(str, (double)COLS);
	break;
    case UV_Def_term:
	str_set(str, Def_term);
	break;
    case UV_ERR:
	str_numset(str, (double)ERR);
	break;
    case UV_LINES:
	str_numset(str, (double)LINES);
	break;
    case UV_My_term:
	str_numset(str, (double)My_term);
	break;
    case UV_OK:
	str_numset(str, (double)OK);
	break;
    case UV_curscr:
	str_nset(str, &curscr, sizeof(WINDOW*));
	break;
    case UV_stdscr:
	str_nset(str, &stdscr, sizeof(WINDOW*));
	break;
    case UV_ttytype:
	str_set(str, ttytype);
	break;
    }
    return 0;
}

static int
userset(ix, str)
int ix;
STR *str;
{
    switch (ix) {
    case UV_COLS:
	COLS = (int)str_gnum(str);
	break;
    case UV_Def_term:
	Def_term = savestr(str_get(str));	/* never freed */
	break;
    case UV_LINES:
	LINES = (int)str_gnum(str);
	break;
    case UV_My_term:
	My_term = (bool)str_gnum(str);
	break;
    case UV_ttytype:
	strcpy(ttytype, str_get(str));		/* hope it fits */
	break;
    }
    return 0;
}
Commit	Line	Data
fe14fcc3	1	/* $Header: curses.mus,v 4.0 91/03/20 01:56:13 lwall Locked $
ff8e2863	2	*
ff8e2863	3	* $Log: curses.mus,v $
fe14fcc3	4	* Revision 4.0 91/03/20 01:56:13 lwall
	5	* 4.0 baseline.
	6	*
ff8e2863	7	* Revision 3.0.1.1 90/08/09 04:05:21 lwall
	8	* patch19: Initial revision
	9	*
	10	*/
	11
	12	#include "EXTERN.h"
	13	#include "perl.h"
	14	extern int wantarray;
	15
	16	char *savestr();
	17
	18	#include <curses.h>
	19
	20	static enum uservars {
	21	UV_curscr,
	22	UV_stdscr,
	23	UV_Def_term,
	24	UV_My_term,
	25	UV_ttytype,
	26	UV_LINES,
	27	UV_COLS,
	28	UV_ERR,
	29	UV_OK,
	30	};
	31
	32	static enum usersubs {
	33	US_addch,
	34	US_waddch,
	35	US_addstr,
	36	US_waddstr,
	37	US_box,
	38	US_clear,
	39	US_wclear,
	40	US_clearok,
	41	US_clrtobot,
	42	US_wclrtobot,
	43	US_clrtoeol,
	44	US_wclrtoeol,
	45	US_delch,
	46	US_wdelch,
	47	US_deleteln,
	48	US_wdeleteln,
	49	US_erase,
	50	US_werase,
	51	US_flushok,
	52	US_idlok,
	53	US_insch,
	54	US_winsch,
	55	US_insertln,
	56	US_winsertln,
	57	US_move,
	58	US_wmove,
	59	US_overlay,
	60	US_overwrite,
	61	US_printw,
	62	US_wprintw,
	63	US_refresh,
	64	US_wrefresh,
	65	US_standout,
	66	US_wstandout,
	67	US_standend,
	68	US_wstandend,
	69	US_cbreak,
	70	US_nocbreak,
71	US_echo,
72	US_noecho,
73	US_getch,
74	US_wgetch,
75	US_getstr,
76	US_wgetstr,
77	US_raw,
78	US_noraw,
79	US_scanw,
80	US_wscanw,
81	US_baudrate,
82	US_delwin,
83	US_endwin,
84	US_erasechar,
85	US_getcap,
86	US_getyx,
87	US_inch,
88	US_winch,
89	US_initscr,
90	US_killchar,
91	US_leaveok,
92	US_longname,
93	US_fullname,
94	US_mvwin,
95	US_newwin,
96	US_nl,
97	US_nonl,
98	US_scrollok,
99	US_subwin,
100	US_touchline,
101	US_touchoverlap,
102	US_touchwin,
103	US_unctrl,
104	US_gettmode,
105	US_mvcur,
106	US_scroll,
107	US_savetty,
108	US_resetty,
109	US_setterm,
110	US_tstp,
111	US__putchar,
112	};
113
114	static int usersub();
115	static int userset();
116	static int userval();
117
118	int
119	init_curses()
120	{
121	struct ufuncs uf;
122	char *filename = "curses.c";
123
124	uf.uf_set = userset;
125	uf.uf_val = userval;
126
127	#define MAGICVAR(name, ix) uf.uf_index = ix, magicname(name, &uf, sizeof uf)
128
129	MAGICVAR("curscr", UV_curscr);
130	MAGICVAR("stdscr", UV_stdscr);
131	MAGICVAR("Def_term",UV_Def_term);
132	MAGICVAR("My_term", UV_My_term);
133	MAGICVAR("ttytype", UV_ttytype);
134	MAGICVAR("LINES", UV_LINES);
135	MAGICVAR("COLS", UV_COLS);
136	MAGICVAR("ERR", UV_ERR);
137	MAGICVAR("OK", UV_OK);
138
139	make_usub("addch", US_addch, usersub, filename);
140	make_usub("waddch", US_waddch, usersub, filename);
141	make_usub("addstr", US_addstr, usersub, filename);
142	make_usub("waddstr", US_waddstr, usersub, filename);
143	make_usub("box", US_box, usersub, filename);
144	make_usub("clear", US_clear, usersub, filename);
145	make_usub("wclear", US_wclear, usersub, filename);
146	make_usub("clearok", US_clearok, usersub, filename);
147	make_usub("clrtobot", US_clrtobot, usersub, filename);
148	make_usub("wclrtobot", US_wclrtobot, usersub, filename);
149	make_usub("clrtoeol", US_clrtoeol, usersub, filename);
150	make_usub("wclrtoeol", US_wclrtoeol, usersub, filename);
151	make_usub("delch", US_delch, usersub, filename);
152	make_usub("wdelch", US_wdelch, usersub, filename);
153	make_usub("deleteln", US_deleteln, usersub, filename);
154	make_usub("wdeleteln", US_wdeleteln, usersub, filename);
155	make_usub("erase", US_erase, usersub, filename);
156	make_usub("werase", US_werase, usersub, filename);
157	make_usub("flushok", US_flushok, usersub, filename);
158	make_usub("idlok", US_idlok, usersub, filename);
159	make_usub("insch", US_insch, usersub, filename);
160	make_usub("winsch", US_winsch, usersub, filename);
161	make_usub("insertln", US_insertln, usersub, filename);
162	make_usub("winsertln", US_winsertln, usersub, filename);
163	make_usub("move", US_move, usersub, filename);
164	make_usub("wmove", US_wmove, usersub, filename);
165	make_usub("overlay", US_overlay, usersub, filename);
166	make_usub("overwrite", US_overwrite, usersub, filename);
167	make_usub("printw", US_printw, usersub, filename);
168	make_usub("wprintw", US_wprintw, usersub, filename);
169	make_usub("refresh", US_refresh, usersub, filename);
170	make_usub("wrefresh", US_wrefresh, usersub, filename);
171	make_usub("standout", US_standout, usersub, filename);
172	make_usub("wstandout", US_wstandout, usersub, filename);
173	make_usub("standend", US_standend, usersub, filename);
174	make_usub("wstandend", US_wstandend, usersub, filename);
175	make_usub("cbreak", US_cbreak, usersub, filename);
176	make_usub("nocbreak", US_nocbreak, usersub, filename);
177	make_usub("echo", US_echo, usersub, filename);
178	make_usub("noecho", US_noecho, usersub, filename);
179	make_usub("getch", US_getch, usersub, filename);
180	make_usub("wgetch", US_wgetch, usersub, filename);
181	make_usub("getstr", US_getstr, usersub, filename);
182	make_usub("wgetstr", US_wgetstr, usersub, filename);
183	make_usub("raw", US_raw, usersub, filename);
184	make_usub("noraw", US_noraw, usersub, filename);
185	make_usub("scanw", US_scanw, usersub, filename);
186	make_usub("wscanw", US_wscanw, usersub, filename);
187	make_usub("baudrate", US_baudrate, usersub, filename);
188	make_usub("delwin", US_delwin, usersub, filename);
189	make_usub("endwin", US_endwin, usersub, filename);
190	make_usub("erasechar", US_erasechar, usersub, filename);
191	make_usub("getcap", US_getcap, usersub, filename);
192	make_usub("getyx", US_getyx, usersub, filename);
193	make_usub("inch", US_inch, usersub, filename);
194	make_usub("winch", US_winch, usersub, filename);
195	make_usub("initscr", US_initscr, usersub, filename);
196	make_usub("killchar", US_killchar, usersub, filename);
197	make_usub("leaveok", US_leaveok, usersub, filename);
198	make_usub("longname", US_longname, usersub, filename);
199	make_usub("fullname", US_fullname, usersub, filename);
200	make_usub("mvwin", US_mvwin, usersub, filename);
201	make_usub("newwin", US_newwin, usersub, filename);
202	make_usub("nl", US_nl, usersub, filename);
203	make_usub("nonl", US_nonl, usersub, filename);
204	make_usub("scrollok", US_scrollok, usersub, filename);
205	make_usub("subwin", US_subwin, usersub, filename);
206	make_usub("touchline", US_touchline, usersub, filename);
207	make_usub("touchoverlap", US_touchoverlap,usersub, filename);
208	make_usub("touchwin", US_touchwin, usersub, filename);
209	make_usub("unctrl", US_unctrl, usersub, filename);
210	make_usub("gettmode", US_gettmode, usersub, filename);
211	make_usub("mvcur", US_mvcur, usersub, filename);
212	make_usub("scroll", US_scroll, usersub, filename);
213	make_usub("savetty", US_savetty, usersub, filename);
214	make_usub("resetty", US_resetty, usersub, filename);
215	make_usub("setterm", US_setterm, usersub, filename);
216	make_usub("tstp", US_tstp, usersub, filename);
217	make_usub("_putchar", US__putchar, usersub, filename);
218	};
219
220	static int
221	usersub(ix, sp, items)
222	int ix;
223	register int sp;
224	register int items;
225	{
226	STR **st = stack->ary_array + sp;
227	register int i;
228	register char *tmps;
229	register STR Str; / used in str_get and str_gnum macros */
230
231	switch (ix) {
232	CASE int addch
233	I char ch
234	END
235
236	CASE int waddch
237	I WINDOW* win
238	I char ch
239	END
240
241	CASE int addstr
242	I char* str
243	END
244
245	CASE int waddstr
246	I WINDOW* win
247	I char* str
248	END
249
250	CASE int box
251	I WINDOW* win
252	I char vert
253	I char hor
254	END
255
256	CASE int clear
257	END
258
259	CASE int wclear
260	I WINDOW* win
261	END
262
263	CASE int clearok
264	I WINDOW* win
265	I bool boolf
266	END
267
268	CASE int clrtobot
269	END
270
271	CASE int wclrtobot
272	I WINDOW* win
273	END
274
275	CASE int clrtoeol
276	END
277
278	CASE int wclrtoeol
279	I WINDOW* win
280	END
281
282	CASE int delch
283	END
284
285	CASE int wdelch
286	I WINDOW* win
287	END
288
289	CASE int deleteln
290	END
291
292	CASE int wdeleteln
293	I WINDOW* win
294	END
295
296	CASE int erase
297	END
298
299	CASE int werase
300	I WINDOW* win
301	END
302
303	CASE int flushok
304	I WINDOW* win
305	I bool boolf
306	END
307
308	CASE int idlok
309	I WINDOW* win
310	I bool boolf
311	END
312
313	CASE int insch
314	I char c
315	END
316
317	CASE int winsch
318	I WINDOW* win
319	I char c
320	END
321
322	CASE int insertln
323	END
324
325	CASE int winsertln
326	I WINDOW* win
327	END
328
329	CASE int move
330	I int y
331	I int x
332	END
333
334	CASE int wmove
335	I WINDOW* win
336	I int y
337	I int x
338	END
339
340	CASE int overlay
341	I WINDOW* win1
342	I WINDOW* win2
343	END
344
345	CASE int overwrite
346	I WINDOW* win1
347	I WINDOW* win2
348	END
349
350	case US_printw:
351	if (items < 1)
352	fatal("Usage: &printw($fmt, $arg1, $arg2, ... )");
353	else {
354	int retval;
355	STR* str = str_new(0);
356
357	do_sprintf(str, items - 1, st + 1);
358	retval = addstr(str->str_ptr);
359	str_numset(st[0], (double) retval);
360	str_free(str);
361	}
362	return sp;
363
364	case US_wprintw:
365	if (items < 2)
366	fatal("Usage: &wprintw($win, $fmt, $arg1, $arg2, ... )");
367	else {
368	int retval;
369	STR* str = str_new(0);
370	WINDOW* win = (WINDOW*) str_get(st[1]);
371
372	do_sprintf(str, items - 1, st + 1);
373	retval = waddstr(win, str->str_ptr);
374	str_numset(st[0], (double) retval);
375	str_free(str);
376	}
377	return sp;
378
379	CASE int refresh
380	END
381
382	CASE int wrefresh
383	I WINDOW* win
384	END
385
386	CASE int standout
387	END
388
389	CASE int wstandout
390	I WINDOW* win
391	END
392
393	CASE int standend
394	END
395
396	CASE int wstandend
397	I WINDOW* win
398	END
399
400	CASE int cbreak
401	END
402
403	CASE int nocbreak
404	END
405
406	CASE int echo
407	END
408
409	CASE int noecho
410	END
411
412	case US_getch:
413	if (items != 0)
414	fatal("Usage: &getch()");
415	else {
416	int retval;
417	char retch;
418
419	retval = getch();
420	if (retval == EOF)
421	st[0] = &str_undef;
422	else {
423	retch = retval;
424	str_nset(st[0], &retch, 1);
425	}
426	}
427	return sp;
428
429	case US_wgetch:
430	if (items != 1)
431	fatal("Usage: &wgetch($win)");
432	else {
433	int retval;
434	char retch;
435	WINDOW* win = (WINDOW*) str_get(st[1]);
436
437	retval = wgetch(win);
438	if (retval == EOF)
439	st[0] = &str_undef;
440	else {
441	retch = retval;
442	str_nset(st[0], &retch, 1);
443	}
444	}
445	return sp;
446
447	CASE int getstr
448	IO char* str
449	END
450
451	CASE int wgetstr
452	I WINDOW* win
453	IO char* str
454	END
455
456	CASE int raw
457	END
458
459	CASE int noraw
460	END
461
462	CASE int baudrate
463	END
464
465	CASE int delwin
466	I WINDOW* win
467	END
468
469	CASE int endwin
470	END
471
472	CASE int erasechar
473	END
474
475	CASE char* getcap
476	I char* str
477	END
478
479	case US_getyx:
480	if (items != 3)
481	fatal("Usage: &getyx($win, $y, $x)");
482	else {
483	int retval;
484	STR* str = str_new(0);
485	WINDOW* win = (WINDOW*) str_get(st[1]);
486	int y;
487	int x;
488
489	do_sprintf(str, items - 1, st + 1);
490	retval = getyx(win, y, x);
491	str_numset(st[2], (double)y);
492	str_numset(st[3], (double)x);
493	str_numset(st[0], (double) retval);
494	str_free(str);
495	}
496	return sp;
497
498
499	CASE int inch
500	END
501
502	CASE int winch
503	I WINDOW* win
504	END
505
506	CASE WINDOW* initscr
507	END
508
509	CASE int killchar
510	END
511
512	CASE int leaveok
513	I WINDOW* win
514	I bool boolf
515	END
516
517	CASE char* longname
518	I char* termbuf
519	IO char* name
520	END
521
522	CASE int fullname
523	I char* termbuf
524	IO char* name
525	END
526
527	CASE int mvwin
528	I WINDOW* win
529	I int y
530	I int x
531	END
532
533	CASE WINDOW* newwin
534	I int lines
535	I int cols
536	I int begin_y
537	I int begin_x
538	END
539
540	CASE int nl
541	END
542
543	CASE int nonl
544	END
545
546	CASE int scrollok
547	I WINDOW* win
548	I bool boolf
549	END
550
551	CASE WINDOW* subwin
552	I WINDOW* win
553	I int lines
554	I int cols
555	I int begin_y
556	I int begin_x
557	END
558
559	CASE int touchline
560	I WINDOW* win
561	I int y
562	I int startx
563	I int endx
564	END
565
566	CASE int touchoverlap
567	I WINDOW* win1
568	I WINDOW* win2
569	END
570
571	CASE int touchwin
572	I WINDOW* win
573	END
574
575	CASE char* unctrl
576	I char ch
577	END
578
579	CASE int gettmode
580	END
581
582	CASE int mvcur
583	I int lasty
584	I int lastx
585	I int newy
586	I int newx
587	END
588
589	CASE int scroll
590	I WINDOW* win
591	END
592
593	CASE int savetty
594	END
595
596	CASE void resetty
597	END
598
599	CASE int setterm
600	I char* name
601	END
602
603	CASE int tstp
604	END
605
606	CASE int _putchar
607	I char ch
608	END
609
610	default:
611	fatal("Unimplemented user-defined subroutine");
612	}
613	return sp;
614	}
615
616	static int
617	userval(ix, str)
618	int ix;
619	STR *str;
620	{
621	switch (ix) {
622	case UV_COLS:
623	str_numset(str, (double)COLS);
624	break;
625	case UV_Def_term:
626	str_set(str, Def_term);
627	break;
628	case UV_ERR:
629	str_numset(str, (double)ERR);
630	break;
631	case UV_LINES:
632	str_numset(str, (double)LINES);
633	break;
634	case UV_My_term:
635	str_numset(str, (double)My_term);
636	break;
637	case UV_OK:
638	str_numset(str, (double)OK);
639	break;
640	case UV_curscr:
641	str_nset(str, &curscr, sizeof(WINDOW*));
642	break;
643	case UV_stdscr:
644	str_nset(str, &stdscr, sizeof(WINDOW*));
645	break;
646	case UV_ttytype:
647	str_set(str, ttytype);
648	break;
649	}
650	return 0;
651	}
652
653	static int
654	userset(ix, str)
655	int ix;
656	STR *str;
657	{
658	switch (ix) {
659	case UV_COLS:
660	COLS = (int)str_gnum(str);
661	break;
662	case UV_Def_term:
663	Def_term = savestr(str_get(str)); /* never freed */
664	break;
665	case UV_LINES:
666	LINES = (int)str_gnum(str);
667	break;
668	case UV_My_term:
669	My_term = (bool)str_gnum(str);
670	break;
671	case UV_ttytype:
672	strcpy(ttytype, str_get(str)); /* hope it fits */
673	break;
674	}
675	return 0;
676	}