usr.bin/window/xx.c

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