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

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