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

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