window(1): Remove __RCSID & friends.
[dragonfly.git] / usr.bin / window / xx.c
1 /*      @(#)xx.c        8.1 (Berkeley) 6/6/93   */
2 /*      $NetBSD: xx.c,v 1.7 2003/08/07 11:17:46 agc Exp $       */
3
4 /*
5  * Copyright (c) 1989, 1993
6  *      The Regents of the University of California.  All rights reserved.
7  *
8  * This code is derived from software contributed to Berkeley by
9  * Edward Wang at The University of California, Berkeley.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions and the following disclaimer.
16  * 2. Redistributions in binary form must reproduce the above copyright
17  *    notice, this list of conditions and the following disclaimer in the
18  *    documentation and/or other materials provided with the distribution.
19  * 3. Neither the name of the University nor the names of its contributors
20  *    may be used to endorse or promote products derived from this software
21  *    without specific prior written permission.
22  *
23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33  * SUCH DAMAGE.
34  */
35
36 #include <stdlib.h>
37 #include <string.h>
38 #define EXTERN
39 #include "xx.h"
40 #undef  EXTERN
41 #include "defs.h"
42 #include "tt.h"
43
44 int
45 xxinit(void)
46 {
47         if (ttinit() < 0)
48                 return -1;
49         xxbufsize = tt.tt_nrow * tt.tt_ncol * 2;
50         /* ccinit may choose to change xxbufsize */
51         if (tt.tt_ntoken > 0 && ccinit() < 0)
52                 return -1;
53         xxbuf = malloc((unsigned) xxbufsize * sizeof *xxbuf);
54         if (xxbuf == 0) {
55                 wwerrno = WWE_NOMEM;
56                 return -1;
57         }
58         xxbufp = xxbuf;
59         xxbufe = xxbuf + xxbufsize;
60         return 0;
61 }
62
63 void
64 xxstart(void)
65 {
66         (*tt.tt_start)();
67         if (tt.tt_ntoken > 0)
68                 ccstart();
69         xxreset1();                     /* might be a restart */
70 }
71
72 void
73 xxreset(void)
74 {
75         if (tt.tt_ntoken > 0)
76                 ccreset();
77         xxreset1();
78         (*tt.tt_reset)();
79 }
80
81 void
82 xxreset1(void)
83 {
84         struct xx *xp, *xq;
85
86         for (xp = xx_head; xp != 0; xp = xq) {
87                 xq = xp->link;
88                 xxfree(xp);
89         }
90         xx_tail = xx_head = 0;
91         xxbufp = xxbuf;
92 }
93
94 void
95 xxend(void)
96 {
97         if (tt.tt_scroll_top != 0 || tt.tt_scroll_bot != tt.tt_nrow - 1)
98                 /* tt.tt_setscroll is known to be defined */
99                 (*tt.tt_setscroll)(0, tt.tt_nrow - 1);
100         if (tt.tt_modes)
101                 (*tt.tt_setmodes)(0);
102         if (tt.tt_scroll_down)
103                 (*tt.tt_scroll_down)(1);
104         (*tt.tt_move)(tt.tt_nrow - 1, 0);
105         if (tt.tt_ntoken > 0)
106                 ccend();
107         (*tt.tt_end)();
108         ttflush();
109 }
110
111 struct xx *
112 xxalloc(void)
113 {
114         struct xx *xp;
115
116         if (xxbufp > xxbufe)
117                 abort();
118         if ((xp = xx_freelist) == 0)
119                 /* XXX can't deal with failure */
120                 xp = (struct xx *) malloc((unsigned) sizeof *xp);
121         else
122                 xx_freelist = xp->link;
123         if (xx_head == 0)
124                 xx_head = xp;
125         else
126                 xx_tail->link = xp;
127         xx_tail = xp;
128         xp->link = 0;
129         return xp;
130 }
131
132 void
133 xxfree(struct xx *xp)
134 {
135         xp->link = xx_freelist;
136         xx_freelist = xp;
137 }
138
139 void
140 xxmove(int row, int col)
141 {
142         struct xx *xp = xx_tail;
143
144         if (xp == 0 || xp->cmd != xc_move) {
145                 xp = xxalloc();
146                 xp->cmd = xc_move;
147         }
148         xp->arg0 = row;
149         xp->arg1 = col;
150 }
151
152 void
153 xxscroll(int dir, int top, int bot)
154 {
155         struct xx *xp = xx_tail;
156
157         if (xp != 0 && xp->cmd == xc_scroll &&
158             xp->arg1 == top && xp->arg2 == bot &&
159             ((xp->arg0 < 0 && dir < 0) || (xp->arg0 > 0 && dir > 0))) {
160                 xp->arg0 += dir;
161                 return;
162         }
163         xp = xxalloc();
164         xp->cmd = xc_scroll;
165         xp->arg0 = dir;
166         xp->arg1 = top;
167         xp->arg2 = bot;
168 }
169
170 void
171 xxinschar(int row, int col, int c, int m)
172 {
173         struct xx *xp;
174
175         xp = xxalloc();
176         xp->cmd = xc_inschar;
177         xp->arg0 = row;
178         xp->arg1 = col;
179         xp->arg2 = c;
180         xp->arg3 = m;
181 }
182
183 void
184 xxinsspace(int row, int col)
185 {
186         struct xx *xp = xx_tail;
187
188         if (xp != 0 && xp->cmd == xc_insspace && xp->arg0 == row &&
189             col >= xp->arg1 && col <= xp->arg1 + xp->arg2) {
190                 xp->arg2++;
191                 return;
192         }
193         xp = xxalloc();
194         xp->cmd = xc_insspace;
195         xp->arg0 = row;
196         xp->arg1 = col;
197         xp->arg2 = 1;
198 }
199
200 void
201 xxdelchar(int row, int col)
202 {
203         struct xx *xp = xx_tail;
204
205         if (xp != 0 && xp->cmd == xc_delchar &&
206             xp->arg0 == row && xp->arg1 == col) {
207                 xp->arg2++;
208                 return;
209         }
210         xp = xxalloc();
211         xp->cmd = xc_delchar;
212         xp->arg0 = row;
213         xp->arg1 = col;
214         xp->arg2 = 1;
215 }
216
217 void
218 xxclear(void)
219 {
220         struct xx *xp;
221
222         xxreset1();
223         xp = xxalloc();
224         xp->cmd = xc_clear;
225 }
226
227 void
228 xxclreos(int row, int col)
229 {
230         struct xx *xp = xxalloc();
231
232         xp->cmd = xc_clreos;
233         xp->arg0 = row;
234         xp->arg1 = col;
235 }
236
237 void
238 xxclreol(int row, int col)
239 {
240         struct xx *xp = xxalloc();
241
242         xp->cmd = xc_clreol;
243         xp->arg0 = row;
244         xp->arg1 = col;
245 }
246
247 void
248 xxwrite(int row, int col, char *p, int n, int m)
249 {
250         struct xx *xp;
251
252         if (xxbufp + n + 1 > xxbufe)
253                 xxflush(0);
254         xp = xxalloc();
255         xp->cmd = xc_write;
256         xp->arg0 = row;
257         xp->arg1 = col;
258         xp->arg2 = n;
259         xp->arg3 = m;
260         xp->buf = xxbufp;
261         memmove(xxbufp, p, n);
262         xxbufp += n;
263         *xxbufp++ = char_sep;
264 }