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

/* $RCSfile: bsdcurses.mus,v $$Revision: 4.0.1.2 $$Date: 92/06/08 16:05:28 $
 *
 * $Log:	bsdcurses.mus,v $
 * Revision 4.0.1.2  92/06/08  16:05:28  lwall
 * patch20: &getcap eventually dumped core in bsdcurses
 * 
 * Revision 4.0.1.1  91/11/05  19:04:53  lwall
 * initial checkin
 * 
 * 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"

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,
    US_testcallback,
};

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);
    make_usub("testcallback",	US_testcallback,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 US_getcap:
	if (items != 1)
	    fatal("Usage: &getcap($str)");
	else {
	    char* retval;
	    char*	str =		(char*)		str_get(st[1]);
	    char output[50], *outputp = output;

	    retval = tgetstr(str, &outputp);
	    str_set(st[0], (char*) retval);
	}
	return sp;

    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

    case US_testcallback:
	sp = callback("callback", sp + items, curcsv->wantarray, 1, items);
	break;

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