contrib/nvi/ip/ip_funcs.c

   1 /*-
   2  * Copyright (c) 1996
   3  *      Keith Bostic.  All rights reserved.
   4  *
   5  * See the LICENSE file for redistribution information.
   6  */
   7
   8 #include "config.h"
   9
  10 #ifndef lint
  11 static const char sccsid[] = "@(#)ip_funcs.c    8.4 (Berkeley) 10/13/96";
  12 #endif /* not lint */
  13
  14 #include <sys/types.h>
  15 #include <sys/queue.h>
  16 #include <sys/time.h>
  17
  18 #include <bitstring.h>
  19 #include <stdio.h>
  20
  21 #include "../common/common.h"
  22 #include "../vi/vi.h"
  23 #include "ip.h"
  24
  25 static int ip_send __P((SCR *, char *, IP_BUF *));
  26
  27 /*
  28  * ip_addstr --
  29  *      Add len bytes from the string at the cursor, advancing the cursor.
  30  *
  31  * PUBLIC: int ip_addstr __P((SCR *, const char *, size_t));
  32  */
  33 int
  34 ip_addstr(sp, str, len)
  35         SCR *sp;
  36         const char *str;
  37         size_t len;
  38 {
  39         IP_BUF ipb;
  40         IP_PRIVATE *ipp;
  41         int iv, rval;
  42
  43         ipp = IPP(sp);
  44
  45         /*
  46          * If ex isn't in control, it's the last line of the screen and
  47          * it's a split screen, use inverse video.
  48          */
  49         iv = 0;
  50         if (!F_ISSET(sp, SC_SCR_EXWROTE) &&
  51             ipp->row == LASTLINE(sp) && IS_SPLIT(sp)) {
  52                 iv = 1;
  53                 ip_attr(sp, SA_INVERSE, 1);
  54         }
  55         ipb.code = IPO_ADDSTR;
  56         ipb.len = len;
  57         ipb.str = str;
  58         rval = ip_send(sp, "s", &ipb);
  59
  60         if (iv)
  61                 ip_attr(sp, SA_INVERSE, 0);
  62         return (rval);
  63 }
  64
  65 /*
  66  * ip_attr --
  67  *      Toggle a screen attribute on/off.
  68  *
  69  * PUBLIC: int ip_attr __P((SCR *, scr_attr_t, int));
  70  */
  71 int
  72 ip_attr(sp, attribute, on)
  73         SCR *sp;
  74         scr_attr_t attribute;
  75         int on;
  76 {
  77         IP_BUF ipb;
  78
  79         ipb.code = IPO_ATTRIBUTE;
  80         ipb.val1 = attribute;
  81         ipb.val2 = on;
  82
  83         return (ip_send(sp, "12", &ipb));
  84 }
  85
  86 /*
  87  * ip_baud --
  88  *      Return the baud rate.
  89  *
  90  * PUBLIC: int ip_baud __P((SCR *, u_long *));
  91  */
  92 int
  93 ip_baud(sp, ratep)
  94         SCR *sp;
  95         u_long *ratep;
  96 {
  97         *ratep = 9600;          /* XXX: Translation: fast. */
  98         return (0);
  99 }
 100
 101 /*
 102  * ip_bell --
 103  *      Ring the bell/flash the screen.
 104  *
 105  * PUBLIC: int ip_bell __P((SCR *));
 106  */
 107 int
 108 ip_bell(sp)
 109         SCR *sp;
 110 {
 111         IP_BUF ipb;
 112
 113         ipb.code = IPO_BELL;
 114
 115         return (ip_send(sp, NULL, &ipb));
 116 }
 117
 118 /*
 119  * ip_busy --
 120  *      Display a busy message.
 121  *
 122  * PUBLIC: void ip_busy __P((SCR *, const char *, busy_t));
 123  */
 124 void
 125 ip_busy(sp, str, bval)
 126         SCR *sp;
 127         const char *str;
 128         busy_t bval;
 129 {
 130         IP_BUF ipb;
 131
 132         ipb.code = IPO_BUSY;
 133         if (str == NULL) {
 134                 ipb.len = 0;
 135                 ipb.str = "";
 136         } else {
 137                 ipb.len = strlen(str);
 138                 ipb.str = str;
 139         }
 140         ipb.val1 = bval;
 141
 142         (void)ip_send(sp, "s1", &ipb);
 143 }
 144
 145 /*
 146  * ip_clrtoeol --
 147  *      Clear from the current cursor to the end of the line.
 148  *
 149  * PUBLIC: int ip_clrtoeol __P((SCR *));
 150  */
 151 int
 152 ip_clrtoeol(sp)
 153         SCR *sp;
 154 {
 155         IP_BUF ipb;
 156
 157         ipb.code = IPO_CLRTOEOL;
 158
 159         return (ip_send(sp, NULL, &ipb));
 160 }
 161
 162 /*
 163  * ip_cursor --
 164  *      Return the current cursor position.
 165  *
 166  * PUBLIC: int ip_cursor __P((SCR *, size_t *, size_t *));
 167  */
 168 int
 169 ip_cursor(sp, yp, xp)
 170         SCR *sp;
 171         size_t *yp, *xp;
 172 {
 173         IP_PRIVATE *ipp;
 174
 175         ipp = IPP(sp);
 176         *yp = ipp->row;
 177         *xp = ipp->col;
 178         return (0);
 179 }
 180
 181 /*
 182  * ip_deleteln --
 183  *      Delete the current line, scrolling all lines below it.
 184  *
 185  * PUBLIC: int ip_deleteln __P((SCR *));
 186  */
 187 int
 188 ip_deleteln(sp)
 189         SCR *sp;
 190 {
 191         IP_BUF ipb;
 192
 193         /*
 194          * This clause is required because the curses screen uses reverse
 195          * video to delimit split screens.  If the screen does not do this,
 196          * this code won't be necessary.
 197          *
 198          * If the bottom line was in reverse video, rewrite it in normal
 199          * video before it's scrolled.
 200          */
 201         if (!F_ISSET(sp, SC_SCR_EXWROTE) && IS_SPLIT(sp)) {
 202                 ipb.code = IPO_REWRITE;
 203                 ipb.val1 = RLNO(sp, LASTLINE(sp));
 204                 if (ip_send(sp, "1", &ipb))
 205                         return (1);
 206         }
 207
 208         /*
 209          * The bottom line is expected to be blank after this operation,
 210          * and other screens must support that semantic.
 211          */
 212         ipb.code = IPO_DELETELN;
 213         return (ip_send(sp, NULL, &ipb));
 214 }
 215
 216 /*
 217  * ip_ex_adjust --
 218  *      Adjust the screen for ex.
 219  *
 220  * PUBLIC: int ip_ex_adjust __P((SCR *, exadj_t));
 221  */
 222 int
 223 ip_ex_adjust(sp, action)
 224         SCR *sp;
 225         exadj_t action;
 226 {
 227         abort();
 228         /* NOTREACHED */
 229 }
 230
 231 /*
 232  * ip_insertln --
 233  *      Push down the current line, discarding the bottom line.
 234  *
 235  * PUBLIC: int ip_insertln __P((SCR *));
 236  */
 237 int
 238 ip_insertln(sp)
 239         SCR *sp;
 240 {
 241         IP_BUF ipb;
 242
 243         ipb.code = IPO_INSERTLN;
 244
 245         return (ip_send(sp, NULL, &ipb));
 246 }
 247
 248 /*
 249  * ip_keyval --
 250  *      Return the value for a special key.
 251  *
 252  * PUBLIC: int ip_keyval __P((SCR *, scr_keyval_t, CHAR_T *, int *));
 253  */
 254 int
 255 ip_keyval(sp, val, chp, dnep)
 256         SCR *sp;
 257         scr_keyval_t val;
 258         CHAR_T *chp;
 259         int *dnep;
 260 {
 261         /*
 262          * VEOF, VERASE and VKILL are required by POSIX 1003.1-1990,
 263          * VWERASE is a 4BSD extension.
 264          */
 265         switch (val) {
 266         case KEY_VEOF:
 267                 *dnep = '\004';         /* ^D */
 268                 break;
 269         case KEY_VERASE:
 270                 *dnep = '\b';           /* ^H */
 271                 break;
 272         case KEY_VKILL:
 273                 *dnep = '\025';         /* ^U */
 274                 break;
 275 #ifdef VWERASE
 276         case KEY_VWERASE:
 277                 *dnep = '\027';         /* ^W */
 278                 break;
 279 #endif
 280         default:
 281                 *dnep = 1;
 282                 break;
 283         }
 284         return (0);
 285 }
 286
 287 /*
 288  * ip_move --
 289  *      Move the cursor.
 290  *
 291  * PUBLIC: int ip_move __P((SCR *, size_t, size_t));
 292  */
 293 int
 294 ip_move(sp, lno, cno)
 295         SCR *sp;
 296         size_t lno, cno;
 297 {
 298         IP_PRIVATE *ipp;
 299         IP_BUF ipb;
 300
 301         ipp = IPP(sp);
 302         ipp->row = lno;
 303         ipp->col = cno;
 304
 305         ipb.code = IPO_MOVE;
 306         ipb.val1 = RLNO(sp, lno);
 307         ipb.val2 = cno;
 308         return (ip_send(sp, "12", &ipb));
 309 }
 310
 311 /*
 312  * ip_refresh --
 313  *      Refresh the screen.
 314  *
 315  * PUBLIC: int ip_refresh __P((SCR *, int));
 316  */
 317 int
 318 ip_refresh(sp, repaint)
 319         SCR *sp;
 320         int repaint;
 321 {
 322         IP_BUF ipb;
 323
 324         ipb.code = repaint ? IPO_REDRAW : IPO_REFRESH;
 325
 326         return (ip_send(sp, NULL, &ipb));
 327 }
 328
 329 /*
 330  * ip_rename --
 331  *      Rename the file.
 332  *
 333  * PUBLIC: int ip_rename __P((SCR *));
 334  */
 335 int
 336 ip_rename(sp)
 337         SCR *sp;
 338 {
 339         IP_BUF ipb;
 340
 341         ipb.code = IPO_RENAME;
 342         ipb.len = strlen(sp->frp->name);
 343         ipb.str = sp->frp->name;
 344
 345         return (ip_send(sp, "s", &ipb));
 346 }
 347
 348 /*
 349  * ip_suspend --
 350  *      Suspend a screen.
 351  *
 352  * PUBLIC: int ip_suspend __P((SCR *, int *));
 353  */
 354 int
 355 ip_suspend(sp, allowedp)
 356         SCR *sp;
 357         int *allowedp;
 358 {
 359         *allowedp = 0;
 360         return (0);
 361 }
 362
 363 /*
 364  * ip_usage --
 365  *      Print out the ip usage messages.
 366  *
 367  * PUBLIC: void ip_usage __P((void));
 368  */
 369 void
 370 ip_usage()
 371 {
 372 #define USAGE "\
 373 usage: vi [-eFlRrSv] [-c command] [-I ifd.ofd] [-t tag] [-w size] [file ...]\n"
 374         (void)fprintf(stderr, "%s", USAGE);
 375 #undef  USAGE
 376 }
 377
 378 /*
 379  * ip_send --
 380  *      Construct and send an IP buffer.
 381  */
 382 static int
 383 ip_send(sp, fmt, ipbp)
 384         SCR *sp;
 385         char *fmt;
 386         IP_BUF *ipbp;
 387 {
 388         IP_PRIVATE *ipp;
 389         size_t blen, off;
 390         u_int32_t ilen;
 391         int nlen, n, nw, rval;
 392         char *bp, *p;
 393
 394         ipp = IPP(sp);
 395
 396         GET_SPACE_RET(sp, bp, blen, 128);
 397
 398         p = bp;
 399         nlen = 0;
 400         *p++ = ipbp->code;
 401         nlen += IPO_CODE_LEN;
 402
 403         if (fmt != NULL)
 404                 for (; *fmt != '\0'; ++fmt)
 405                         switch (*fmt) {
 406                         case '1':                       /* Value 1. */
 407                                 ilen = htonl(ipbp->val1);
 408                                 goto value;
 409                         case '2':                       /* Value 2. */
 410                                 ilen = htonl(ipbp->val2);
 411 value:                          nlen += IPO_INT_LEN;
 412                                 off = p - bp;
 413                                 ADD_SPACE_RET(sp, bp, blen, nlen);
 414                                 p = bp + off;
 415                                 memmove(p, &ilen, IPO_INT_LEN);
 416                                 p += IPO_INT_LEN;
 417                                 break;
 418                         case 's':                       /* String. */
 419                                 ilen = ipbp->len;       /* XXX: conversion. */
 420                                 ilen = htonl(ilen);
 421                                 nlen += IPO_INT_LEN + ipbp->len;
 422                                 off = p - bp;
 423                                 ADD_SPACE_RET(sp, bp, blen, nlen);
 424                                 p = bp + off;
 425                                 memmove(p, &ilen, IPO_INT_LEN);
 426                                 p += IPO_INT_LEN;
 427                                 memmove(p, ipbp->str, ipbp->len);
 428                                 p += ipbp->len;
 429                                 break;
 430                         }
 431
 432
 433         rval = 0;
 434         for (n = p - bp, p = bp; n > 0; n -= nw, p += nw)
 435                 if ((nw = write(ipp->o_fd, p, n)) < 0) {
 436                         rval = 1;
 437                         break;
 438                 }
 439
 440         FREE_SPACE(sp, bp, blen);
 441
 442         return (rval);
 443 }