[ViewVC] Diff of: cvs/rxvt-unicode/src/command.C

Comparing rxvt-unicode/src/command.C (file contents):
Revision 1.6 by pcg, Tue Nov 25 17:11:33 2003 UTC vs.
Revision 1.14 by pcg, Mon Dec 8 23:14:40 2003 UTC

…		…
1	/---------------------------------C----------------------------------	1	/---------------------------------C----------------------------------
2	* File: command.c	2	* File: command.c
3	----------------------------------------------------------------------	3	----------------------------------------------------------------------
4	* $Id: command.C,v 1.6 2003/11/25 17:11:33 pcg Exp $	4	* $Id: command.C,v 1.14 2003/12/08 23:14:40 pcg Exp $
5	*	5	*
6	* All portions of code are copyright by their respective author/s.	6	* All portions of code are copyright by their respective author/s.
7	* Copyright (c) 1992 John Bovey, University of Kent at Canterbury <jdb@ukc.ac.uk>	7	* Copyright (c) 1992 John Bovey, University of Kent at Canterbury <jdb@ukc.ac.uk>
8	* - original version	8	* - original version
9	* Copyright (c) 1994 Robert Nation <nation@rocket.sanders.lockheed.com>	9	* Copyright (c) 1994 Robert Nation <nation@rocket.sanders.lockheed.com>
61	unsigned int newlen;	61	unsigned int newlen;
62	KeySym keysym;	62	KeySym keysym;
63	#ifdef DEBUG_CMD	63	#ifdef DEBUG_CMD
64	static int debug_key = 1; /* accessible by a debugger only */	64	static int debug_key = 1; /* accessible by a debugger only */
65	#endif	65	#endif
66	#ifdef USE_XIM
67	int valid_keysym;	66	int valid_keysym;
68	#endif
69	unsigned char *kbuf = R->kbuf;	67	unsigned char *kbuf = R->kbuf;
70		68
71	/*	69	/*
72	* use Num_Lock to toggle Keypad on/off. If Num_Lock is off, allow an	70	* use Num_Lock to toggle Keypad on/off. If Num_Lock is off, allow an
73	* escape sequence to toggle the Keypad.	71	* escape sequence to toggle the Keypad.
…		…
75	* Always permit `shift' to override the current setting	73	* Always permit `shift' to override the current setting
76	*/	74	*/
77	shft = (ev->state & ShiftMask);	75	shft = (ev->state & ShiftMask);
78	ctrl = (ev->state & ControlMask);	76	ctrl = (ev->state & ControlMask);
79	meta = (ev->state & R->ModMetaMask);	77	meta = (ev->state & R->ModMetaMask);
		78
80	if (R->numlock_state \|\| (ev->state & R->ModNumLockMask)) {	79	if (R->numlock_state \|\| (ev->state & R->ModNumLockMask))
		80	{
81	R->numlock_state = (ev->state & R->ModNumLockMask);	81	R->numlock_state = (ev->state & R->ModNumLockMask);
82	PrivMode((!R->numlock_state), PrivMode_aplKP);	82	PrivMode((!R->numlock_state), PrivMode_aplKP);
83	}	83	}
		84
		85	kbuf[0] = 0;
		86
84	#ifdef USE_XIM	87	#ifdef USE_XIM
85	if (R->Input_Context != NULL) {	88	if (R->Input_Context)
		89	{
86	Status status_return;	90	Status status_return;
87		91
88	kbuf[0] = '\0';
89	#ifdef X_HAVE_UTF8_STRING	92	#ifdef X_HAVE_UTF8_STRING
90	len = Xutf8LookupString(R->Input_Context, ev, (char *)kbuf,	93	len = Xutf8LookupString(R->Input_Context, ev, (char *)kbuf,
91	KBUFSZ, &keysym, &status_return);	94	KBUFSZ, &keysym, &status_return);
92	#else	95	#else
93	len = XmbLookupString(R->Input_Context, ev, (char *)kbuf,	96	len = XmbLookupString(R->Input_Context, ev, (char *)kbuf,
94	KBUFSZ, &keysym, &status_return);	97	KBUFSZ, &keysym, &status_return);
95	#endif	98	#endif
96	valid_keysym = ((status_return == XLookupKeySym)	99	valid_keysym = ((status_return == XLookupKeySym)
97	\|\| (status_return == XLookupBoth));	100	\|\| (status_return == XLookupBoth));
		101	}
98	} else {	102	else
		103	#endif
		104	{
99	len = XLookupString(ev, (char *)kbuf, KBUFSZ, &keysym,	105	len = XLookupString(ev, (char *)kbuf, KBUFSZ, &keysym, &R->compose);
100	&R->compose);
101	valid_keysym = 1;	106	valid_keysym = !len;
102	}	107	}
103	#else /* USE_XIM */
104	len = XLookupString(ev, (char *)kbuf, KBUFSZ, &keysym,
105	&R->compose);
106	/*
107	* map unmapped Latin[2-4]/Katakana/Arabic/Cyrillic/Greek entries -> Latin1
108	* good for installations with correct fonts, but without XLOCALE
109	*/
110	if (!len) {
111	if ((keysym >= 0x0100) && (keysym < 0x0800)) {
112	kbuf[0] = (keysym & 0xFF);
113	kbuf[1] = '\0';
114	len = 1;
115	} else
116	kbuf[0] = '\0';
117	}
118	#endif /* USE_XIM */
119		108
120	#ifdef USE_XIM
121	if (valid_keysym)	109	if (valid_keysym)
122	#endif
123	{	110	{
124	/* for some backwards compatibility */	111	/* for some backwards compatibility */
125	#if defined(HOTKEY_CTRL) \|\| defined(HOTKEY_META)	112	#if defined(HOTKEY_CTRL) \|\| defined(HOTKEY_META)
126	# ifdef HOTKEY_CTRL	113	# ifdef HOTKEY_CTRL
127	if (ctrl) {	114	if (ctrl)
128	# else	115	# else
129	if (meta) {	116	if (meta)
130	# endif	117	# endif
		118	{
131	if (keysym == R->ks_bigfont) {	119	if (keysym == R->ks_bigfont)
		120	{
132	rxvt_change_font(aR_ 0, FONT_UP);	121	rxvt_change_font(aR_ 0, FONT_UP);
133	return;	122	return;
		123	}
134	} else if (keysym == R->ks_smallfont) {	124	else if (keysym == R->ks_smallfont)
		125	{
135	rxvt_change_font(aR_ 0, FONT_DN);	126	rxvt_change_font(aR_ 0, FONT_DN);
136	return;	127	return;
137	}	128	}
138	}	129	}
139	#endif	130	#endif
140		131
141	if (R->TermWin.saveLines) {	132	if (R->TermWin.saveLines) {
142	#ifdef UNSHIFTED_SCROLLKEYS	133	#ifdef UNSHIFTED_SCROLLKEYS
143	if (!ctrl && !meta) {	134	if (!ctrl && !meta) {
…		…
237	/* escape prefix */	228	/* escape prefix */
238	if (meta)	229	if (meta)
239	# ifdef META8_OPTION	230	# ifdef META8_OPTION
240	if (R->meta_char == C0_ESC)	231	if (R->meta_char == C0_ESC)
241	# endif	232	# endif
242	rxvt_tt_write(aR_ &ch, 1);	233	R->tt_write (&ch, 1);
243	rxvt_tt_write(aR_ kbuf0, l);	234	R->tt_write (kbuf0, l);
244	return;	235	return;
245	} else	236	} else
246	#endif	237	#endif
247	{	238	{
248	newlen = 1;	239	newlen = 1;
…		…
572	if (R->greek_mode)	563	if (R->greek_mode)
573	len = greek_xlat(kbuf, len);	564	len = greek_xlat(kbuf, len);
574	#endif	565	#endif
575	/* nil */ ;	566	/* nil */ ;
576	}	567	}
577	}	568	}
578		569
579	if (len <= 0)	570	if (len <= 0)
580	return; /* not mapped */	571	return; /* not mapped */
581		572
582	if (R->Options & Opt_scrollTtyKeypress)	573	if (R->Options & Opt_scrollTtyKeypress)
…		…
605	&& (R->meta_char == C0_ESC)	596	&& (R->meta_char == C0_ESC)
606	#endif	597	#endif
607	) {	598	) {
608	const unsigned char ch = C0_ESC;	599	const unsigned char ch = C0_ESC;
609		600
610	rxvt_tt_write(aR_ &ch, 1);	601	R->tt_write(&ch, 1);
611	}	602	}
612	#ifdef DEBUG_CMD	603	#ifdef DEBUG_CMD
613	if (debug_key) { /* Display keyboard buffer contents */	604	if (debug_key) { /* Display keyboard buffer contents */
614	char *p;	605	char *p;
615	int i;	606	int i;
…		…
618	for (i = 0, p = kbuf; i < len; i++, p++)	609	for (i = 0, p = kbuf; i < len; i++, p++)
619	fprintf(stderr, (p >= ' ' && p < '\177' ? "%c" : "\\%03o"), *p);	610	fprintf(stderr, (p >= ' ' && p < '\177' ? "%c" : "\\%03o"), *p);
620	fprintf(stderr, "'\n");	611	fprintf(stderr, "'\n");
621	}	612	}
622	#endif /* DEBUG_CMD */	613	#endif /* DEBUG_CMD */
623	rxvt_tt_write(aR_ kbuf, (unsigned int)len);	614	R->tt_write(kbuf, (unsigned int)len);
624	}	615	}
625	/}}} /	616	/}}} /
626		617
627	#if (MENUBAR_MAX)	618	#if (MENUBAR_MAX)
628	/{{{ rxvt_cmd_write(), rxvt_cmd_getc() /	619	/{{{ rxvt_cmd_write(), rxvt_cmd_getc() /
…		…
654	R->cmdbuf_ptr = cmdbuf_ptr;	645	R->cmdbuf_ptr = cmdbuf_ptr;
655	R->cmdbuf_endp = cmdbuf_endp;	646	R->cmdbuf_endp = cmdbuf_endp;
656	return 0;	647	return 0;
657	}	648	}
658	#endif /* MENUBAR_MAX */	649	#endif /* MENUBAR_MAX */
		650
		651	void
		652	rxvt_term::flush ()
		653	{
		654	#ifdef TRANSPARENT
		655	if (want_full_refresh)
		656	{
		657	want_full_refresh = 0;
		658	rxvt_scr_clear (this);
		659	rxvt_scr_touch (this, False);
		660	want_refresh = 1;
		661	}
		662	#endif
		663
		664	if (want_refresh)
		665	{
		666	rxvt_scr_refresh (this, refresh_type);
		667	rxvt_scrollbar_show (this, 1);
		668	#ifdef USE_XIM
		669	rxvt_IMSendSpot (this);
		670	#endif
		671	}
		672
		673	XFlush (Xdisplay);
		674	#if 0
		675	if (XPending (Xdisplay)) process_x_events ();
		676	if (XPending (Xdisplay)) process_x_events ();
		677	#endif
		678	}
		679
		680	void
		681	rxvt_term::check_cb (check_watcher &w)
		682	{
		683	SET_R (this);
		684
		685	flush ();
		686	}
659		687
660	void	688	void
661	rxvt_term::process_x_events ()	689	rxvt_term::process_x_events ()
662	{	690	{
663	do	691	do
…		…
704	}	732	}
705		733
706	void	734	void
707	rxvt_term::blink_cb (time_watcher &w)	735	rxvt_term::blink_cb (time_watcher &w)
708	{	736	{
		737	SET_R (this);
		738
709	w.at += BLINK_INTERVAL;	739	w.at += BLINK_INTERVAL;
710	hidden_cursor = !hidden_cursor;	740	hidden_cursor = !hidden_cursor;
711	want_refresh = 1;	741	want_refresh = 1;
712	flush();
713	}	742	}
714		743
715	void	744	void
716	rxvt_term::x_cb (io_watcher &w, short revents)	745	rxvt_term::x_cb (io_watcher &w, short revents)
717	{	746	{
		747	SET_R (this);
		748
718	process_x_events ();	749	process_x_events ();
		750	}
719		751
720	flush ();	752	bool
		753	rxvt_term::pty_fill ()
		754	{
		755	ssize_t n = cmdbuf_endp - cmdbuf_ptr;
		756
		757	memmove (cmdbuf_base, cmdbuf_ptr, n);
		758	cmdbuf_ptr = cmdbuf_base;
		759	cmdbuf_endp = cmdbuf_ptr + n;
		760
		761	n = read (cmd_fd, cmdbuf_endp, BUFSIZ - n);
		762
		763	if (n > 0)
		764	{
		765	cmdbuf_endp += n;
		766	return true;
		767	}
		768	else if (n < 0 && errno != EAGAIN)
		769	destroy ();
		770
		771	return false;
		772	}
		773
		774	void
		775	rxvt_term::pty_cb (io_watcher &w, short revents)
		776	{
		777	SET_R (this);
		778
		779	if (revents & EVENT_WRITE)
		780	tt_write (0, 0);
		781	else if (revents & EVENT_READ)
		782	{
		783	bool flag = true;
		784
		785	// loop, but don't allow a single term to monopolize us
		786	// the number of loops is fully arbitrary, and thus wrong
		787	while (flag && pty_fill ())
		788	{
		789	if (!seen_input)
		790	{
		791	seen_input = 1;
		792	/* once we know the shell is running, send the screen size. Again! */
		793	tt_winch ();
		794	}
		795
		796	uint32_t ch = NOCHAR;
		797
		798	for (;;)
		799	{
		800	if (ch == NOCHAR)
		801	ch = next_char ();
		802
		803	if (ch == NOCHAR) // TODO: improve
		804	break;
		805
		806	if (ch >= ' ' \|\| ch == '\t' \|\| ch == '\n' \|\| ch == '\r')
		807	{
		808	/* Read a text string from the input buffer */
		809	uint32_t buf[BUFSIZ];
		810	bool refreshnow = false;
		811	int nlines = 0;
		812	uint32_t *str = buf;
		813
		814	*str++ = ch;
		815
		816	for (;;)
		817	{
		818	ch = next_char ();
		819
		820	if (ch == NOCHAR \|\| (ch < ' ' && ch != '\t' && ch != '\n' && ch != '\r'))
		821	break;
		822	else
		823	{
		824	*str++ = ch;
		825
		826	if (ch == '\n')
		827	{
		828	nlines++;
		829	refresh_count++;
		830
		831	if (!(Options & Opt_jumpScroll)
		832	\|\| (refresh_count >= (refresh_limit * (TermWin.nrow - 1))))
		833	{
		834	refreshnow = true;
		835	flag = false;
		836	ch = NOCHAR;
		837	break;
		838	}
		839	}
		840
		841	if (str >= buf + BUFSIZ)
		842	{
		843	ch = NOCHAR;
		844	break;
		845	}
		846	}
		847	}
		848
		849	rxvt_scr_add_lines (this, buf, nlines, str - buf);
		850
		851	/*
		852	* If there have been a lot of new lines, then update the screen
		853	* What the heck I'll cheat and only refresh less than every page-full.
		854	* the number of pages between refreshes is refresh_limit, which
		855	* is incremented here because we must be doing flat-out scrolling.
		856	*
		857	* refreshing should be correct for small scrolls, because of the
		858	* time-out
		859	*/
		860	if (refreshnow)
		861	{
		862	if ((Options & Opt_jumpScroll) && refresh_limit < REFRESH_PERIOD)
		863	refresh_limit++;
		864
		865	rxvt_scr_refresh (this, refresh_type);
		866	}
		867
		868	}
		869	else
		870	{
		871	switch (ch)
		872	{
		873	default:
		874	rxvt_process_nonprinting (this, ch);
		875	break;
		876	case C0_ESC: /* escape char */
		877	rxvt_process_escape_seq (this);
		878	break;
		879	/case 0x9b: / /* CSI */
		880	/* rxvt_process_csi_seq (this); */
		881	}
		882
		883	ch = NOCHAR;
		884	}
		885	}
		886	}
		887	}
721	}	888	}
722		889
723	// read the next character, currently handles UTF-8	890	// read the next character, currently handles UTF-8
724	// will probably handle all sorts of other stuff in the future	891	// will probably handle all sorts of other stuff in the future
725	uint32_t	892	uint32_t
…		…
773	}	940	}
774		941
775	return NOCHAR;	942	return NOCHAR;
776	}	943	}
777		944
778	bool
779	rxvt_term::pty_fill (size_t count)
780	{
781	ssize_t n = cmdbuf_endp - cmdbuf_ptr;
782
783	memmove (cmdbuf_base, cmdbuf_ptr, n);
784	cmdbuf_ptr = cmdbuf_base;
785	cmdbuf_endp = cmdbuf_ptr + n;
786
787	n = read (cmd_fd, cmdbuf_endp, count);
788
789	if (n > 0)
790	{
791	cmdbuf_endp += n;
792	return true;
793	}
794	else if (n < 0 && errno == EAGAIN)
795	return false;
796
797	rxvt_clean_exit();
798	exit(EXIT_FAILURE); /* bad order of events? */
799	}
800
801	void
802	rxvt_term::pty_cb (io_watcher &w, short revents)
803	{
804	while (pty_fill (BUFSIZ - (cmdbuf_endp - cmdbuf_ptr)))
805	{
806	/* once we know the shell is running, send the screen size. Again! */
807	//ch = rxvt_cmd_getc(aR); /* wait for something */
808	//rxvt_tt_winsize(cmd_fd, TermWin.ncol, TermWin.nrow, cmd_pid);
809
810	uint32_t ch = NOCHAR;
811
812	for (;;)
813	{
814	if (ch == NOCHAR)
815	ch = next_char ();
816
817	if (ch == NOCHAR) // TODO: improve
818	break;
819
820	if (ch >= ' ' \|\| ch == '\t' \|\| ch == '\n' \|\| ch == '\r')
821	{
822	/* Read a text string from the input buffer */
823	uint32_t buf[BUFSIZ];
824	bool refreshnow = false;
825	int nlines = 0;
826	uint32_t *str = buf;
827
828	*str++ = ch;
829
830	for (;;)
831	{
832	ch = next_char ();
833
834	if (ch == NOCHAR \|\| (ch < ' ' && ch != '\t' && ch != '\n' && ch != '\r'))
835	break;
836	else
837	{
838	*str++ = ch;
839
840	if (ch == '\n')
841	{
842	nlines++;
843	refresh_count++;
844
845	if (!(Options & Opt_jumpScroll)
846	\|\| (refresh_count >= (refresh_limit * (TermWin.nrow - 1))))
847	{
848	refreshnow = true;
849	ch = NOCHAR;
850	break;
851	}
852	}
853
854	if (str >= buf + BUFSIZ)
855	{
856	ch = NOCHAR;
857	break;
858	}
859	}
860	}
861
862	rxvt_scr_add_lines (this, buf, nlines, str - buf);
863
864	/*
865	* If there have been a lot of new lines, then update the screen
866	* What the heck I'll cheat and only refresh less than every page-full.
867	* the number of pages between refreshes is refresh_limit, which
868	* is incremented here because we must be doing flat-out scrolling.
869	*
870	* refreshing should be correct for small scrolls, because of the
871	* time-out
872	*/
873	if (refreshnow)
874	{
875	if ((Options & Opt_jumpScroll) && refresh_limit < REFRESH_PERIOD)
876	refresh_limit++;
877
878	rxvt_scr_refresh (this, refresh_type);
879	}
880
881	}
882	else
883	{
884	switch (ch)
885	{
886	default:
887	rxvt_process_nonprinting (this, ch);
888	break;
889	case C0_ESC: /* escape char */
890	rxvt_process_escape_seq (this);
891	break;
892	/case 0x9b: / /* CSI */
893	/* rxvt_process_csi_seq (this); */
894	}
895
896	ch = NOCHAR;
897	}
898	}
899	}
900
901	flush ();
902	}
903
904	void
905	rxvt_term::flush ()
906	{
907	#ifdef TRANSPARENT
908	if (want_full_refresh)
909	{
910	want_full_refresh = 0;
911	rxvt_scr_clear (this);
912	rxvt_scr_touch (this, False);
913	want_refresh = 1;
914	}
915	#endif
916
917	if (want_refresh)
918	{
919	rxvt_scr_refresh (this, refresh_type);
920	rxvt_scrollbar_show (this, 1);
921	#ifdef USE_XIM
922	rxvt_IMSendSpot (this);
923	#endif
924	}
925
926	XFlush (Xdisplay);
927	}
928
929	/* rxvt_cmd_getc() - Return next input character */	945	/* rxvt_cmd_getc() - Return next input character */
930	/*	946	/*
931	* Return the next input character after first passing any keyboard input	947	* Return the next input character after first passing any keyboard input
932	* to the command.	948	* to the command.
933	*/	949	*/
…		…
942	return c;	958	return c;
943		959
944	// incomplete sequences should occur rarely, still, a better solution	960	// incomplete sequences should occur rarely, still, a better solution
945	// would be preferred. either setjmp/longjmp or better design.	961	// would be preferred. either setjmp/longjmp or better design.
946	fcntl (R->cmd_fd, F_SETFL, 0);	962	fcntl (R->cmd_fd, F_SETFL, 0);
947	R->pty_fill (1);	963	R->pty_fill ();
948	fcntl (R->cmd_fd, F_SETFL, O_NONBLOCK);	964	fcntl (R->cmd_fd, F_SETFL, O_NONBLOCK);
949	}	965	}
950		966
951	#if 0	967	#if 0
952	#define TIMEOUT_USEC 5000	968	#define TIMEOUT_USEC 5000
…		…
960		976
961	for (;;) {	977	for (;;) {
962	/* loop until we can return something */	978	/* loop until we can return something */
963		979
964	if (R->v_bufstr < R->v_bufptr) /* output any pending chars */	980	if (R->v_bufstr < R->v_bufptr) /* output any pending chars */
965	rxvt_tt_write(aR_ NULL, 0);	981	R->tt_write(NULL, 0);
966		982
967	#if defined(MOUSE_WHEEL) && defined(MOUSE_SLIP_WHEELING)	983	#if defined(MOUSE_WHEEL) && defined(MOUSE_SLIP_WHEELING)
968	if (R->mouse_slip_wheel_speed) {	984	if (R->mouse_slip_wheel_speed) {
969	quick_timeout = 1;	985	quick_timeout = 1;
970	if (!R->mouse_slip_wheel_delay--	986	if (!R->mouse_slip_wheel_delay--
…		…
1006	quick_timeout \|= R->want_full_refresh;	1022	quick_timeout \|= R->want_full_refresh;
1007	#endif	1023	#endif
1008	#endif	1024	#endif
1009	}	1025	}
1010		1026
		1027	void
		1028	rxvt_term::pointer_unblank ()
		1029	{
		1030	XDefineCursor (Xdisplay, TermWin.vt, TermWin_cursor);
		1031	rxvt_recolour_cursor (this);
		1032
		1033	#ifdef POINTER_BLANK
		1034	hidden_pointer = 0;
		1035
		1036	if (Options & Opt_pointerBlank)
		1037	pointer_ev.start (NOW + pointerBlankDelay);
		1038	#endif
		1039	}
		1040
1011	#ifdef POINTER_BLANK	1041	#ifdef POINTER_BLANK
1012	void	1042	void
1013	rxvt_term::pointer_unblank ()	1043	rxvt_term::pointer_blank ()
1014	{	1044	{
		1045	pointer_ev.stop ();
		1046
1015	if (!(Options & Opt_pointerBlank))	1047	if (!(Options & Opt_pointerBlank))
1016	return;	1048	return;
1017		1049
1018	XDefineCursor (Xdisplay, TermWin.vt, TermWin_cursor);
1019	rxvt_recolour_cursor (this);
1020	hidden_pointer = 0;
1021
1022	pointer_ev.start (NOW + pointerBlankDelay);
1023	}
1024
1025	void
1026	rxvt_term::pointer_blank ()
1027	{
1028	pointer_ev.stop ();
1029
1030	if (!(Options & Opt_pointerBlank))
1031	return;
1032
1033	XDefineCursor (Xdisplay, TermWin.vt, blank_cursor);	1050	XDefineCursor (Xdisplay, TermWin.vt, blank_cursor);
1034	XFlush (Xdisplay);	1051	XFlush (Xdisplay);
1035		1052
1036	hidden_pointer = 1;	1053	hidden_pointer = 1;
1037	}	1054	}
1038		1055
1039	void	1056	void
1040	rxvt_term::pointer_cb (time_watcher &w)	1057	rxvt_term::pointer_cb (time_watcher &w)
1041	{	1058	{
		1059	SET_R (this);
		1060
1042	pointer_blank ();	1061	pointer_blank ();
1043	}	1062	}
1044	#endif	1063	#endif
1045		1064
1046	/* INTPROTO */	1065	/* INTPROTO */
…		…
1100	fprintf(stderr, "]: <%d>, %d/%d\n",	1119	fprintf(stderr, "]: <%d>, %d/%d\n",
1101	button_number,	1120	button_number,
1102	x + 1,	1121	x + 1,
1103	y + 1);	1122	y + 1);
1104	#else	1123	#else
1105	rxvt_tt_printf(aR_ "\033[M%c%c%c",	1124	R->tt_printf("\033[M%c%c%c",
1106	(32 + button_number + key_state),	1125	(32 + button_number + key_state),
1107	(32 + x + 1),	1126	(32 + x + 1),
1108	(32 + y + 1));	1127	(32 + y + 1));
1109	#endif	1128	#endif
1110	}	1129	}
…		…
1243	break;	1262	break;
1244		1263
1245	case ClientMessage:	1264	case ClientMessage:
1246	if (ev->xclient.format == 32	1265	if (ev->xclient.format == 32
1247	&& (Atom)ev->xclient.data.l[0] == R->xa[XA_WMDELETEWINDOW])	1266	&& (Atom)ev->xclient.data.l[0] == R->xa[XA_WMDELETEWINDOW])
1248	exit(EXIT_SUCCESS);	1267	R->destroy ();
1249	#ifdef OFFIX_DND	1268	#ifdef OFFIX_DND
1250	/* OffiX Dnd (drag 'n' drop) protocol */	1269	/* OffiX Dnd (drag 'n' drop) protocol */
1251	if (ev->xclient.message_type == R->xa[XA_DNDPROTOCOL]	1270	else if (ev->xclient.message_type == R->xa[XA_DNDPROTOCOL]
1252	&& (ev->xclient.data.l[0] == DndFile	1271	&& (ev->xclient.data.l[0] == DndFile
1253	\|\| ev->xclient.data.l[0] == DndDir	1272	\|\| ev->xclient.data.l[0] == DndDir
1254	\|\| ev->xclient.data.l[0] == DndLink)) {	1273	\|\| ev->xclient.data.l[0] == DndLink)) {
1255	/* Get Dnd data */	1274	/* Get Dnd data */
1256	Atom ActualType;	1275	Atom ActualType;
…		…
1288	* in the GraphicsExpose parts, which means that after each refresh,	1307	* in the GraphicsExpose parts, which means that after each refresh,
1289	* we need to wait for the graphics expose or Noexpose events,	1308	* we need to wait for the graphics expose or Noexpose events,
1290	* which ought to make things real slow!	1309	* which ought to make things real slow!
1291	*/	1310	*/
1292	case VisibilityNotify:	1311	case VisibilityNotify:
1293	switch (ev->xvisibility.state) {	1312	switch (ev->xvisibility.state)
		1313	{
1294	case VisibilityUnobscured:	1314	case VisibilityUnobscured:
1295	R->refresh_type = FAST_REFRESH;	1315	R->refresh_type = FAST_REFRESH;
1296	break;	1316	break;
1297	case VisibilityPartiallyObscured:	1317	case VisibilityPartiallyObscured:
1298	R->refresh_type = SLOW_REFRESH;	1318	R->refresh_type = SLOW_REFRESH;
1299	break;	1319	break;
1300	default:	1320	default:
1301	R->refresh_type = NO_REFRESH;	1321	R->refresh_type = NO_REFRESH;
1302	break;	1322	break;
1303	}	1323	}
1304	break;	1324	break;
1305		1325
1306	case FocusIn:	1326	case FocusIn:
1307	if (!R->TermWin.focus) {	1327	if (!R->TermWin.focus) {
1308	R->TermWin.focus = 1;	1328	R->TermWin.focus = 1;
…		…
1651	*/	1671	*/
1652	if ((R->scrollBar.style == R_SB_NEXT	1672	if ((R->scrollBar.style == R_SB_NEXT
1653	&& scrollbarnext_upButton(ev->y))	1673	&& scrollbarnext_upButton(ev->y))
1654	\|\| (R->scrollBar.style == R_SB_RXVT	1674	\|\| (R->scrollBar.style == R_SB_RXVT
1655	&& scrollbarrxvt_upButton(ev->y)))	1675	&& scrollbarrxvt_upButton(ev->y)))
1656	rxvt_tt_printf(aR_ "\033[A");	1676	R->tt_printf("\033[A");
1657	else if ((R->scrollBar.style == R_SB_NEXT	1677	else if ((R->scrollBar.style == R_SB_NEXT
1658	&& scrollbarnext_dnButton(ev->y))	1678	&& scrollbarnext_dnButton(ev->y))
1659	\|\| (R->scrollBar.style == R_SB_RXVT	1679	\|\| (R->scrollBar.style == R_SB_RXVT
1660	&& scrollbarrxvt_dnButton(ev->y)))	1680	&& scrollbarrxvt_dnButton(ev->y)))
1661	rxvt_tt_printf(aR_ "\033[B");	1681	R->tt_printf("\033[B");
1662	else	1682	else
1663	switch (ev->button) {	1683	switch (ev->button) {
1664	case Button2:	1684	case Button2:
1665	rxvt_tt_printf(aR_ "\014");	1685	R->tt_printf("\014");
1666	break;	1686	break;
1667	case Button1:	1687	case Button1:
1668	rxvt_tt_printf(aR_ "\033[6~");	1688	R->tt_printf("\033[6~");
1669	break;	1689	break;
1670	case Button3:	1690	case Button3:
1671	rxvt_tt_printf(aR_ "\033[5~");	1691	R->tt_printf("\033[5~");
1672	break;	1692	break;
1673	}	1693	}
1674	}	1694	}
1675	else	1695	else
1676	#endif /* NO_SCROLLBAR_REPORT */	1696	#endif /* NO_SCROLLBAR_REPORT */
…		…
2077	return stream;	2097	return stream;
2078	}	2098	}
2079		2099
2080	/* EXTPROTO */	2100	/* EXTPROTO */
2081	int	2101	int
2082	rxvt_pclose_printer(FILE *stream)	2102	rxvt_pclose_printer (FILE *stream)
2083	{	2103	{
2084	fflush(stream);	2104	fflush (stream);
2085	/* pclose() reported not to work on SunOS 4.1.3 */	2105	/* pclose() reported not to work on SunOS 4.1.3 */
2086	# if defined (__sun__) /* TODO: RESOLVE THIS */	2106	# if defined (__sun__) /* TODO: RESOLVE THIS */
2087	/* pclose works provided SIGCHLD handler uses waitpid */	2107	/* pclose works provided SIGCHLD handler uses waitpid */
2088	return pclose(stream); /* return fclose (stream); */	2108	return pclose (stream); /* return fclose (stream); */
2089	# else	2109	# else
2090	return pclose(stream);	2110	return pclose (stream);
2091	# endif	2111	# endif
2092	}	2112	}
2093		2113
2094	/*	2114	/*
2095	* simulate attached vt100 printer	2115	* simulate attached vt100 printer
…		…
2158	rxvt_process_nonprinting(pR_ unsigned char ch)	2178	rxvt_process_nonprinting(pR_ unsigned char ch)
2159	{	2179	{
2160	switch (ch) {	2180	switch (ch) {
2161	case C0_ENQ: /* terminal Status */	2181	case C0_ENQ: /* terminal Status */
2162	if (R->rs[Rs_answerbackstring])	2182	if (R->rs[Rs_answerbackstring])
2163	rxvt_tt_write(aR_	2183	R->tt_write(
2164	(const unsigned char *)R->rs[Rs_answerbackstring],	2184	(const unsigned char *)R->rs[Rs_answerbackstring],
2165	(unsigned int)STRLEN(R->rs[Rs_answerbackstring]));	2185	(unsigned int)STRLEN(R->rs[Rs_answerbackstring]));
2166	else	2186	else
2167	rxvt_tt_write(aR_ (unsigned char *)VT100_ANS,	2187	R->tt_write((unsigned char *)VT100_ANS,
2168	(unsigned int)STRLEN(VT100_ANS));	2188	(unsigned int)STRLEN(VT100_ANS));
2169	break;	2189	break;
2170	case C0_BEL: /* bell */	2190	case C0_BEL: /* bell */
2171	rxvt_scr_bell(aR);	2191	rxvt_scr_bell(aR);
2172	break;	2192	break;
…		…
2235	row = rxvt_cmd_getc(aR) - ' ';	2255	row = rxvt_cmd_getc(aR) - ' ';
2236	col = rxvt_cmd_getc(aR) - ' ';	2256	col = rxvt_cmd_getc(aR) - ' ';
2237	rxvt_scr_gotorc(aR_ row, col, 0);	2257	rxvt_scr_gotorc(aR_ row, col, 0);
2238	break;	2258	break;
2239	case 'Z': /* identify the terminal type */	2259	case 'Z': /* identify the terminal type */
2240	rxvt_tt_printf(aR_ "\033/Z"); /* I am a VT100 emulating a VT52 */	2260	R->tt_printf("\033/Z"); /* I am a VT100 emulating a VT52 */
2241	break;	2261	break;
2242	case '<': /* turn off VT52 mode */	2262	case '<': /* turn off VT52 mode */
2243	PrivMode(0, PrivMode_vt52);	2263	PrivMode(0, PrivMode_vt52);
2244	break;	2264	break;
2245	case 'F': /* use special graphics character set */	2265	case 'F': /* use special graphics character set */
…		…
2352	rxvt_process_dcs_seq(aR);	2372	rxvt_process_dcs_seq(aR);
2353	break;	2373	break;
2354		2374
2355	/* 8.3.110: SINGLE CHARACTER INTRODUCER */	2375	/* 8.3.110: SINGLE CHARACTER INTRODUCER */
2356	case C1_SCI: /* ESC Z */	2376	case C1_SCI: /* ESC Z */
2357	rxvt_tt_write(aR_ (const unsigned char *)ESCZ_ANSWER,	2377	R->tt_write((const unsigned char *)ESCZ_ANSWER,
2358	(unsigned int)(sizeof(ESCZ_ANSWER) - 1));	2378	(unsigned int)(sizeof(ESCZ_ANSWER) - 1));
2359	break; /* steal obsolete ESC [ c */	2379	break; /* steal obsolete ESC [ c */
2360		2380
2361	/* 8.3.16: CONTROL SEQUENCE INTRODUCER */	2381	/* 8.3.16: CONTROL SEQUENCE INTRODUCER */
2362	case C1_CSI: /* ESC [ */	2382	case C1_CSI: /* ESC [ */
…		…
2483	*/	2503	*/
2484	if (priv) {	2504	if (priv) {
2485	switch (priv) {	2505	switch (priv) {
2486	case '>':	2506	case '>':
2487	if (ch == CSI_DA) /* secondary device attributes */	2507	if (ch == CSI_DA) /* secondary device attributes */
2488	rxvt_tt_printf(aR_ "\033[>%d;%-.8s;0c", 'R', VSTRING);	2508	R->tt_printf("\033[>%d;%-.8s;0c", 'R', VSTRING);
2489	break;	2509	break;
2490	case '?':	2510	case '?':
2491	if (ch == 'h' \|\| ch == 'l' \|\| ch == 'r' \|\| ch == 's' \|\| ch == 't')	2511	if (ch == 'h' \|\| ch == 'l' \|\| ch == 'r' \|\| ch == 's' \|\| ch == 't')
2492	rxvt_process_terminal_mode(aR_ ch, priv, nargs, arg);	2512	rxvt_process_terminal_mode(aR_ ch, priv, nargs, arg);
2493	break;	2513	break;
…		…
2600	case CSI_SU: /* 8.3.148: (1) SCROLL UP */	2620	case CSI_SU: /* 8.3.148: (1) SCROLL UP */
2601	rxvt_scroll_text(aR_ R->screen.tscroll, R->screen.bscroll, arg[0], 0);	2621	rxvt_scroll_text(aR_ R->screen.tscroll, R->screen.bscroll, arg[0], 0);
2602	break;	2622	break;
2603		2623
2604	case CSI_DA: /* 8.3.24: (0) DEVICE ATTRIBUTES */	2624	case CSI_DA: /* 8.3.24: (0) DEVICE ATTRIBUTES */
2605	rxvt_tt_write(aR_ (const unsigned char *)VT100_ANS,	2625	R->tt_write((const unsigned char *)VT100_ANS,
2606	(unsigned int)(sizeof(VT100_ANS) - 1));	2626	(unsigned int)(sizeof(VT100_ANS) - 1));
2607	break;	2627	break;
2608		2628
2609	case CSI_SGR: /* 8.3.118: (0) SELECT GRAPHIC RENDITION */	2629	case CSI_SGR: /* 8.3.118: (0) SELECT GRAPHIC RENDITION */
2610	rxvt_process_sgr_mode(aR_ nargs, arg);	2630	rxvt_process_sgr_mode(aR_ nargs, arg);
2611	break;	2631	break;
2612		2632
2613	case CSI_DSR: /* 8.3.36: (0) DEVICE STATUS REPORT */	2633	case CSI_DSR: /* 8.3.36: (0) DEVICE STATUS REPORT */
2614	switch (arg[0]) {	2634	switch (arg[0]) {
2615	case 5: /* DSR requested */	2635	case 5: /* DSR requested */
2616	rxvt_tt_printf(aR_ "\033[0n");	2636	R->tt_printf("\033[0n");
2617	break;	2637	break;
2618	case 6: /* CPR requested */	2638	case 6: /* CPR requested */
2619	rxvt_scr_report_position(aR);	2639	rxvt_scr_report_position(aR);
2620	break;	2640	break;
2621	#if defined (ENABLE_DISPLAY_ANSWER)	2641	#if defined (ENABLE_DISPLAY_ANSWER)
2622	case 7: /* unofficial extension */	2642	case 7: /* unofficial extension */
2623	rxvt_tt_printf(aR_ "%-.250s\n", R->rs[Rs_display_name]);	2643	R->tt_printf("%-.250s\n", R->rs[Rs_display_name]);
2624	break;	2644	break;
2625	#endif	2645	#endif
2626	case 8: /* unofficial extension */	2646	case 8: /* unofficial extension */
2627	rxvt_xterm_seq(aR_ XTerm_title, APL_NAME "-" VERSION, CHAR_ST);	2647	rxvt_xterm_seq(aR_ XTerm_title, APL_NAME "-" VERSION, CHAR_ST);
2628	break;	2648	break;
…		…
2697	break;	2717	break;
2698	#endif	2718	#endif
2699		2719
2700	case CSI_78: /* DECREQTPARM */	2720	case CSI_78: /* DECREQTPARM */
2701	if (arg[0] == 0 \|\| arg[0] == 1)	2721	if (arg[0] == 0 \|\| arg[0] == 1)
2702	rxvt_tt_printf(aR_ "\033[%d;1;1;112;112;1;0x", arg[0] + 2);	2722	R->tt_printf("\033[%d;1;1;112;112;1;0x", arg[0] + 2);
2703	/* FALLTHROUGH */	2723	/* FALLTHROUGH */
2704		2724
2705	default:	2725	default:
2706	break;	2726	break;
2707	}	2727	}
…		…
2761	/*	2781	/*
2762	* reports - some output format copied from XTerm	2782	* reports - some output format copied from XTerm
2763	*/	2783	*/
2764	case 11: /* report window state */	2784	case 11: /* report window state */
2765	XGetWindowAttributes(R->Xdisplay, R->TermWin.parent[0], &wattr);	2785	XGetWindowAttributes(R->Xdisplay, R->TermWin.parent[0], &wattr);
2766	rxvt_tt_printf(aR_ "\033[%dt", wattr.map_state == IsViewable ? 1 : 2);	2786	R->tt_printf("\033[%dt", wattr.map_state == IsViewable ? 1 : 2);
2767	break;	2787	break;
2768	case 13: /* report window position */	2788	case 13: /* report window position */
2769	XGetWindowAttributes(R->Xdisplay, R->TermWin.parent[0], &wattr);	2789	XGetWindowAttributes(R->Xdisplay, R->TermWin.parent[0], &wattr);
2770	XTranslateCoordinates(R->Xdisplay, R->TermWin.parent[0], wattr.root,	2790	XTranslateCoordinates(R->Xdisplay, R->TermWin.parent[0], wattr.root,
2771	-wattr.border_width, -wattr.border_width,	2791	-wattr.border_width, -wattr.border_width,
2772	&x, &y, &wdummy);	2792	&x, &y, &wdummy);
2773	rxvt_tt_printf(aR_ "\033[3;%d;%dt", x, y);	2793	R->tt_printf("\033[3;%d;%dt", x, y);
2774	break;	2794	break;
2775	case 14: /* report window size (pixels) */	2795	case 14: /* report window size (pixels) */
2776	XGetWindowAttributes(R->Xdisplay, R->TermWin.parent[0], &wattr);	2796	XGetWindowAttributes(R->Xdisplay, R->TermWin.parent[0], &wattr);
2777	rxvt_tt_printf(aR_ "\033[4;%d;%dt", wattr.height, wattr.width);	2797	R->tt_printf("\033[4;%d;%dt", wattr.height, wattr.width);
2778	break;	2798	break;
2779	case 18: /* report window size (chars) */	2799	case 18: /* report window size (chars) */
2780	rxvt_tt_printf(aR_ "\033[8;%d;%dt", R->TermWin.nrow, R->TermWin.ncol);	2800	R->tt_printf("\033[8;%d;%dt", R->TermWin.nrow, R->TermWin.ncol);
2781	break;	2801	break;
2782	#if 0 /* XXX: currently disabled due to security concerns */	2802	#if 0 /* XXX: currently disabled due to security concerns */
2783	case 20: /* report icon label */	2803	case 20: /* report icon label */
2784	XGetIconName(R->Xdisplay, R->TermWin.parent[0], &s);	2804	XGetIconName(R->Xdisplay, R->TermWin.parent[0], &s);
2785	rxvt_tt_printf(aR_ "\033]L%-.200s\234", s ? s : ""); /* 8bit ST */	2805	R->tt_printf("\033]L%-.200s\234", s ? s : ""); /* 8bit ST */
2786	break;	2806	break;
2787	case 21: /* report window title */	2807	case 21: /* report window title */
2788	XFetchName(R->Xdisplay, R->TermWin.parent[0], &s);	2808	XFetchName(R->Xdisplay, R->TermWin.parent[0], &s);
2789	rxvt_tt_printf(aR_ "\033]l%-.200s\234", s ? s : ""); /* 8bit ST */	2809	R->tt_printf("\033]l%-.200s\234", s ? s : ""); /* 8bit ST */
2790	break;	2810	break;
2791	#endif	2811	#endif
2792	}	2812	}
2793	}	2813	}
2794	#endif	2814	#endif
…		…
3337	{	3357	{
3338	unsigned char ch, cmd = rxvt_cmd_getc(aR);	3358	unsigned char ch, cmd = rxvt_cmd_getc(aR);
3339		3359
3340	#ifndef RXVT_GRAPHICS	3360	#ifndef RXVT_GRAPHICS
3341	if (cmd == 'Q') { /* query graphics */	3361	if (cmd == 'Q') { /* query graphics */
3342	rxvt_tt_printf(aR_ "\033G0\n"); /* no graphics */	3362	R->tt_printf("\033G0\n"); /* no graphics */
3343	return;	3363	return;
3344	}	3364	}
3345	/* swallow other graphics sequences until terminating ':' */	3365	/* swallow other graphics sequences until terminating ':' */
3346	do	3366	do
3347	ch = rxvt_cmd_getc(aR);	3367	ch = rxvt_cmd_getc(aR);
…		…
3350	unsigned int nargs;	3370	unsigned int nargs;
3351	int args[NGRX_PTS];	3371	int args[NGRX_PTS];
3352	unsigned char *text = NULL;	3372	unsigned char *text = NULL;
3353		3373
3354	if (cmd == 'Q') { /* query graphics */	3374	if (cmd == 'Q') { /* query graphics */
3355	rxvt_tt_printf(aR_ "\033G1\n"); /* yes, graphics (color) */	3375	R->tt_printf("\033G1\n"); /* yes, graphics (color) */
3356	return;	3376	return;
3357	}	3377	}
3358	for (nargs = 0; nargs < (sizeof(args) / sizeof(args[0])) - 1;) {	3378	for (nargs = 0; nargs < (sizeof(args) / sizeof(args[0])) - 1;) {
3359	int neg;	3379	int neg;
3360		3380
…		…
3394		3414
3395	/*	3415	/*
3396	* Send printf() formatted output to the command.	3416	* Send printf() formatted output to the command.
3397	* Only use for small amounts of data.	3417	* Only use for small amounts of data.
3398	*/	3418	*/
3399	/* EXTPROTO */
3400	void	3419	void
3401	rxvt_tt_printf(pR_ const char *fmt,...)	3420	rxvt_term::tt_printf (const char *fmt,...)
3402	{	3421	{
3403	va_list arg_ptr;	3422	va_list arg_ptr;
3404	unsigned char buf[256];	3423	unsigned char buf[256];
3405		3424
3406	va_start(arg_ptr, fmt);	3425	va_start (arg_ptr, fmt);
3407	vsprintf((char *)buf, fmt, arg_ptr);	3426	vsnprintf ((char *)buf, 256, fmt, arg_ptr);
3408	va_end(arg_ptr);	3427	va_end (arg_ptr);
3409	rxvt_tt_write(aR_ buf, (unsigned int)STRLEN(buf));	3428	tt_write (buf, STRLEN (buf));
3410	}	3429	}
3411		3430
3412	/* ---------------------------------------------------------------------- */	3431	/* ---------------------------------------------------------------------- */
3413	/* Addresses pasting large amounts of data and rxvt hang
3414	* code pinched from xterm (v_write()) and applied originally to
3415	* rxvt-2.18 - Hops
3416	* Write data to the pty as typed by the user, pasted with the mouse,	3432	/* Write data to the pty as typed by the user, pasted with the mouse,
3417	* or generated by us in response to a query ESC sequence.	3433	* or generated by us in response to a query ESC sequence.
3418	*/	3434	*/
3419	/* EXTPROTO */
3420	void	3435	void
3421	rxvt_tt_write(pR_ const unsigned char *d, unsigned int len)	3436	rxvt_term::tt_write (const unsigned char *data, unsigned int len)
3422	{	3437	{
3423	#define MAX_PTY_WRITE 256 /* POSIX minimum MAX_INPUT */	3438	enum { MAX_PTY_WRITE = 255 }; // minimum MAX_INPUT
3424	int riten;
3425	unsigned int p;
3426	unsigned char v_buffer, / start of physical buffer */
3427	v_bufstr, / start of current buffer pending */
3428	v_bufptr, / end of current buffer pending */
3429	v_bufend; / end of physical buffer */
3430		3439
3431	if (R->v_bufstr == NULL && len > 0) {	3440	if (len)
3432	p = (len / MAX_PTY_WRITE + 1) * MAX_PTY_WRITE;
3433	v_buffer = v_bufstr = v_bufptr = (unsigned char *)rxvt_malloc(p);
3434	v_bufend = v_buffer + p;
3435	} else {
3436	v_buffer = R->v_buffer;
3437	v_bufstr = R->v_bufstr;
3438	v_bufptr = R->v_bufptr;
3439	v_bufend = R->v_bufend;
3440	}	3441	{
		3442	if (v_buflen == 0)
		3443	{
		3444	int written = write (cmd_fd, data, min (MAX_PTY_WRITE, len));
		3445	if (written == len)
		3446	return;
3441		3447
3442	/*	3448	data += written;
3443	* Append to the block we already have. Always doing this simplifies the	3449	len -= written;
3444	* code, and isn't too bad, either. If this is a short block, it isn't	3450	}
3445	* too expensive, and if this is a long block, we won't be able to write	3451
3446	* it all anyway.	3452
3447	*/	3453	v_buffer = (unsigned char *)realloc (v_buffer, v_buflen + len);
3448	if (len > 0) {	3454
3449	if (v_bufend < v_bufptr + len) { /* run out of room */	3455	memcpy (v_buffer + v_buflen, data, len);
3450	if (v_bufstr != v_buffer) {	3456	v_buflen += len;
3451	/* there is unused space, move everything down */
3452	MEMMOVE(v_buffer, v_bufstr,
3453	(unsigned int)(v_bufptr - v_bufstr));
3454	v_bufptr -= v_bufstr - v_buffer;
3455	v_bufstr = v_buffer;
3456	}	3457	}
3457	if (v_bufend < v_bufptr + len) {
3458	/* still won't fit: get more space */
3459	/* use most basic realloc because an error is not fatal. */
3460	unsigned int size = v_bufptr - v_buffer;
3461	unsigned int reallocto;
3462		3458
3463	reallocto = ((size + len) / MAX_PTY_WRITE + 1) * MAX_PTY_WRITE;	3459	for (;;)
3464	v_buffer = (unsigned char *)realloc(v_buffer, reallocto);	3460	{
3465	/* save across realloc */	3461	int written = write (cmd_fd, v_buffer, min (MAX_PTY_WRITE, v_buflen));
3466	if (v_buffer) {	3462
3467	v_bufstr = v_buffer;	3463	if (written > 0)
3468	v_bufptr = v_buffer + size;	3464	{
3469	v_bufend = v_buffer + reallocto;	3465	v_buflen -= written;
3470	} else { /* no memory: ignore entire write request */	3466
3471	rxvt_print_error("data loss: cannot allocate buffer space");	3467	if (v_buflen == 0)
3472	v_buffer = v_bufstr; /* restore clobbered pointer */	3468	{
3473	}	3469	free (v_buffer);
		3470	v_buffer = 0;
		3471	v_buflen = 0;
		3472
		3473	pty_ev.set (EVENT_READ);
		3474	return;
		3475	}
		3476
		3477	memmove (v_buffer, v_buffer + written, v_buflen);
		3478	}
		3479	else if (written != -1 \|\| (errno != EAGAIN && errno != EINTR))
		3480	// original code just ignores this...
		3481	destroy ();
		3482	else
		3483	{
		3484	pty_ev.set (EVENT_READ \| EVENT_WRITE);
		3485	return;
		3486	}
3474	}	3487	}
3475	}
3476	if (v_bufend >= v_bufptr + len) { /* new stuff will fit */
3477	MEMCPY(v_bufptr, d, len);
3478	v_bufptr += len;
3479	}
3480	}
3481
3482	/*
3483	* Write out as much of the buffer as we can.
3484	* Be careful not to overflow the pty's input silo.
3485	* We are conservative here and only write a small amount at a time.
3486	*
3487	* If we can't push all the data into the pty yet, we expect write
3488	* to return a non-negative number less than the length requested
3489	* (if some data written) or -1 and set errno to EAGAIN,
3490	* EWOULDBLOCK, or EINTR (if no data written).
3491	*
3492	* (Not all systems do this, sigh, so the code is actually
3493	* a little more forgiving.)
3494	*/
3495	if ((p = v_bufptr - v_bufstr) > 0) {
3496	riten = write(R->cmd_fd, v_bufstr, min(p, MAX_PTY_WRITE));
3497	if (riten < 0)
3498	riten = 0;
3499	v_bufstr += riten;
3500	if (v_bufstr >= v_bufptr) /* we wrote it all */
3501	v_bufstr = v_bufptr = v_buffer;
3502	}
3503	/*
3504	* If we have lots of unused memory allocated, return it
3505	*/
3506	if (v_bufend - v_bufptr > MAX_PTY_WRITE * 8) { /* arbitrary hysteresis */
3507	/* save pointers across realloc */
3508	unsigned int start = v_bufstr - v_buffer;
3509	unsigned int size = v_bufptr - v_buffer;
3510	unsigned int reallocto;
3511
3512	reallocto = (size / MAX_PTY_WRITE + 1) * MAX_PTY_WRITE;
3513	v_buffer = (unsigned char *)realloc(v_buffer, reallocto);
3514	if (v_buffer) {
3515	v_bufstr = v_buffer + start;
3516	v_bufptr = v_buffer + size;
3517	v_bufend = v_buffer + reallocto;
3518	} else {
3519	/* should we print a warning if couldn't return memory? */
3520	v_buffer = v_bufstr - start; /* restore clobbered pointer */
3521	}
3522	}
3523	R->v_buffer = v_buffer;
3524	R->v_bufstr = v_bufstr;
3525	R->v_bufptr = v_bufptr;
3526	R->v_bufend = v_bufend;
3527	}	3488	}
		3489
3528	/----------------------- end-of-file (C source) -----------------------/	3490	/----------------------- end-of-file (C source) -----------------------/
3529		3491

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing rxvt-unicode/src/command.C (file contents): Revision 1.6 by pcg, Tue Nov 25 17:11:33 2003 UTC vs. Revision 1.14 by pcg, Mon Dec 8 23:14:40 2003 UTC

Diff Legend

Comparing rxvt-unicode/src/command.C (file contents):
Revision 1.6 by pcg, Tue Nov 25 17:11:33 2003 UTC vs.
Revision 1.14 by pcg, Mon Dec 8 23:14:40 2003 UTC