external/bsd/nvi/dist/ip/ip_funcs.c

   1 /*      $NetBSD: ip_funcs.c,v 1.3 2013/11/27 17:55:46 christos Exp $    */
   2 /*-
   3  * Copyright (c) 1996
   4  *      Keith Bostic.  All rights reserved.
   5  *
   6  * See the LICENSE file for redistribution information.
   7  */
   8
   9 #include "config.h"
  10
  11 #ifndef lint
  12 static const char sccsid[] = "Id: ip_funcs.c,v 8.23 2001/06/25 15:19:23 skimo Exp  (Berkeley) Date: 2001/06/25 15:19:23 ";
  13 #endif /* not lint */
  14
  15 #include <sys/types.h>
  16 #include <sys/queue.h>
  17 #include <sys/time.h>
  18
  19 #include <bitstring.h>
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #include <unistd.h>
  23 #include <string.h>
  24
  25 #include "../common/common.h"
  26 #include "../vi/vi.h"
  27 #include "../ipc/ip.h"
  28
  29 /*
  30  * ip_addstr --
  31  *      Add len bytes from the string at the cursor, advancing the cursor.
  32  *
  33  * PUBLIC: int ip_waddstr __P((SCR *, const CHAR_T *, size_t));
  34  */
  35 int
  36 ip_waddstr(SCR *sp, const CHAR_T *str, size_t len)
  37 {
  38         IP_BUF ipb;
  39         IP_PRIVATE *ipp;
  40         int rval;
  41
  42         ipp = IPP(sp);
  43
  44         memset(&ipb, 0, sizeof(ipb));
  45         ipb.code = SI_WADDSTR;
  46         ipb.len1 = len * sizeof(CHAR_T);
  47         ipb.str1 = __UNCONST(str);
  48         rval = vi_send(ipp->o_fd, "a", &ipb);
  49         /* XXXX */
  50         ipp->col += len;
  51
  52         return (rval);
  53 }
  54
  55 /*
  56  * ip_addstr --
  57  *      Add len bytes from the string at the cursor, advancing the cursor.
  58  *
  59  * PUBLIC: int ip_addstr __P((SCR *, const char *, size_t));
  60  */
  61 int
  62 ip_addstr(SCR *sp, const char *str, size_t len)
  63 {
  64         IP_BUF ipb;
  65         IP_PRIVATE *ipp;
  66         int iv, rval;
  67
  68         ipp = IPP(sp);
  69
  70         /*
  71          * If ex isn't in control, it's the last line of the screen and
  72          * it's a split screen, use inverse video.
  73          */
  74         memset(&ipb, 0, sizeof(ipb));
  75         iv = 0;
  76         if (!F_ISSET(sp, SC_SCR_EXWROTE) &&
  77             ipp->row == LASTLINE(sp) && IS_SPLIT(sp)) {
  78                 iv = 1;
  79                 ip_attr(sp, SA_INVERSE, 1);
  80         }
  81         ipb.code = SI_ADDSTR;
  82         ipb.len1 = len;
  83         ipb.str1 = str;
  84         rval = vi_send(ipp->o_fd, "a", &ipb);
  85         /* XXXX */
  86         ipp->col += len;
  87
  88         if (iv)
  89                 ip_attr(sp, SA_INVERSE, 0);
  90         return (rval);
  91 }
  92
  93 /*
  94  * ip_attr --
  95  *      Toggle a screen attribute on/off.
  96  *
  97  * PUBLIC: int ip_attr __P((SCR *, scr_attr_t, int));
  98  */
  99 int
 100 ip_attr(SCR *sp, scr_attr_t attribute, int on)
 101 {
 102         IP_BUF ipb;
 103         IP_PRIVATE *ipp = IPP(sp);
 104
 105         memset(&ipb, 0, sizeof(ipb));
 106         if (attribute == SA_ALTERNATE) {
 107                 if (on) F_SET(ipp, IP_ON_ALTERNATE);
 108                 else F_CLR(ipp, IP_ON_ALTERNATE);
 109         }
 110
 111         ipb.code = SI_ATTRIBUTE;
 112         ipb.val1 = attribute;
 113         ipb.val2 = on;
 114
 115         return (vi_send(ipp->o_fd, "12", &ipb));
 116 }
 117
 118 /*
 119  * ip_baud --
 120  *      Return the baud rate.
 121  *
 122  * PUBLIC: int ip_baud __P((SCR *, u_long *));
 123  */
 124 int
 125 ip_baud(SCR *sp, u_long *ratep)
 126 {
 127         *ratep = 9600;          /* XXX: Translation: fast. */
 128         return (0);
 129 }
 130
 131 /*
 132  * ip_bell --
 133  *      Ring the bell/flash the screen.
 134  *
 135  * PUBLIC: int ip_bell __P((SCR *));
 136  */
 137 int
 138 ip_bell(SCR *sp)
 139 {
 140         IP_BUF ipb;
 141         IP_PRIVATE *ipp = IPP(sp);
 142
 143         memset(&ipb, 0, sizeof(ipb));
 144         ipb.code = SI_BELL;
 145
 146         return (vi_send(ipp->o_fd, NULL, &ipb));
 147 }
 148
 149 /*
 150  * ip_busy --
 151  *      Display a busy message.
 152  *
 153  * PUBLIC: void ip_busy __P((SCR *, const char *, busy_t));
 154  */
 155 void
 156 ip_busy(SCR *sp, const char *str, busy_t bval)
 157 {
 158         IP_BUF ipb;
 159         IP_PRIVATE *ipp = IPP(sp);
 160
 161         memset(&ipb, 0, sizeof(ipb));
 162         switch (bval) {
 163         case BUSY_ON:
 164                 ipb.code = SI_BUSY_ON;
 165                 ipb.str1 = str;
 166                 ipb.len1 = strlen(str);
 167                 (void)vi_send(ipp->o_fd, "a", &ipb);
 168                 break;
 169         case BUSY_OFF:
 170                 ipb.code = SI_BUSY_OFF;
 171                 (void)vi_send(ipp->o_fd, NULL, &ipb);
 172                 break;
 173         case BUSY_UPDATE:
 174                 break;
 175         }
 176         return;
 177 }
 178
 179 /*
 180  * ip_child --
 181  *      Prepare child.
 182  *
 183  * PUBLIC: int ip_child __P((SCR *));
 184  */
 185 int
 186 ip_child(SCR *sp)
 187 {
 188         IP_PRIVATE *ipp = IPP(sp);
 189
 190         if (ipp->t_fd != -1) {
 191             dup2(ipp->t_fd, 0);
 192             dup2(ipp->t_fd, 1);
 193             dup2(ipp->t_fd, 2);
 194             close(ipp->t_fd);
 195         }
 196         return 0;
 197 }
 198
 199 /*
 200  * ip_clrtoeol --
 201  *      Clear from the current cursor to the end of the line.
 202  *
 203  * PUBLIC: int ip_clrtoeol __P((SCR *));
 204  */
 205 int
 206 ip_clrtoeol(SCR *sp)
 207 {
 208         IP_BUF ipb;
 209         IP_PRIVATE *ipp = IPP(sp);
 210
 211         /* Temporary hack until we can pass screen pointers
 212          * or name screens
 213          */
 214         memset(&ipb, 0, sizeof(ipb));
 215         if (IS_VSPLIT(sp)) {
 216                 size_t x, y, spcnt;
 217                 int error;
 218
 219                 y = ipp->row;
 220                 x = ipp->col;
 221                 error = 0;
 222                 for (spcnt = sp->cols - x;
 223                      spcnt > 0 && ! error; --spcnt)
 224                         error = ip_addstr(sp, " ", 1);
 225                 if (sp->coff == 0)
 226                         error |= ip_addstr(sp, "|", 1);
 227                 error |= ip_move(sp, y, x);
 228                 return error;
 229         }
 230
 231         ipb.code = SI_CLRTOEOL;
 232
 233         return (vi_send(ipp->o_fd, NULL, &ipb));
 234 }
 235
 236 /*
 237  * ip_cursor --
 238  *      Return the current cursor position.
 239  *
 240  * PUBLIC: int ip_cursor __P((SCR *, size_t *, size_t *));
 241  */
 242 int
 243 ip_cursor(SCR *sp, size_t *yp, size_t *xp)
 244 {
 245         IP_PRIVATE *ipp;
 246
 247         ipp = IPP(sp);
 248         *yp = ipp->row;
 249         *xp = ipp->col;
 250         return (0);
 251 }
 252
 253 /*
 254  * ip_deleteln --
 255  *      Delete the current line, scrolling all lines below it.
 256  *
 257  * PUBLIC: int ip_deleteln __P((SCR *));
 258  */
 259 int
 260 ip_deleteln(SCR *sp)
 261 {
 262         IP_BUF ipb;
 263         IP_PRIVATE *ipp = IPP(sp);
 264
 265         /*
 266          * This clause is required because the curses screen uses reverse
 267          * video to delimit split screens.  If the screen does not do this,
 268          * this code won't be necessary.
 269          *
 270          * If the bottom line was in reverse video, rewrite it in normal
 271          * video before it's scrolled.
 272          */
 273         memset(&ipb, 0, sizeof(ipb));
 274         if (!F_ISSET(sp, SC_SCR_EXWROTE) && IS_SPLIT(sp)) {
 275                 ipb.code = SI_REWRITE;
 276                 ipb.val1 = RLNO(sp, LASTLINE(sp));
 277                 if (vi_send(ipp->o_fd, "1", &ipb))
 278                         return (1);
 279         }
 280
 281         /*
 282          * The bottom line is expected to be blank after this operation,
 283          * and other screens must support that semantic.
 284          */
 285         ipb.code = SI_DELETELN;
 286         return (vi_send(ipp->o_fd, NULL, &ipb));
 287 }
 288
 289 /*
 290  * ip_discard --
 291  *      Discard a screen.
 292  *
 293  * PUBLIC: int ip_discard __P((SCR *, SCR **));
 294  */
 295 int
 296 ip_discard(SCR *discardp, SCR **acquirep)
 297 {
 298         return (0);
 299 }
 300
 301 /*
 302  * ip_ex_adjust --
 303  *      Adjust the screen for ex.
 304  *
 305  * PUBLIC: int ip_ex_adjust __P((SCR *, exadj_t));
 306  */
 307 int
 308 ip_ex_adjust(SCR *sp, exadj_t action)
 309 {
 310         abort();
 311         /* NOTREACHED */
 312 }
 313
 314 /*
 315  * ip_insertln --
 316  *      Push down the current line, discarding the bottom line.
 317  *
 318  * PUBLIC: int ip_insertln __P((SCR *));
 319  */
 320 int
 321 ip_insertln(SCR *sp)
 322 {
 323         IP_BUF ipb;
 324         IP_PRIVATE *ipp = IPP(sp);
 325
 326         memset(&ipb, 0, sizeof(ipb));
 327         ipb.code = SI_INSERTLN;
 328
 329         return (vi_send(ipp->o_fd, NULL, &ipb));
 330 }
 331
 332 /*
 333  * ip_keyval --
 334  *      Return the value for a special key.
 335  *
 336  * PUBLIC: int ip_keyval __P((SCR *, scr_keyval_t, CHAR_T *, int *));
 337  */
 338 int
 339 ip_keyval(SCR *sp, scr_keyval_t val, CHAR_T *chp, int *dnep)
 340 {
 341         /*
 342          * VEOF, VERASE and VKILL are required by POSIX 1003.1-1990,
 343          * VWERASE is a 4BSD extension.
 344          */
 345         switch (val) {
 346         case KEY_VEOF:
 347                 *dnep = '\004';         /* ^D */
 348                 break;
 349         case KEY_VERASE:
 350                 *dnep = '\b';           /* ^H */
 351                 break;
 352         case KEY_VKILL:
 353                 *dnep = '\025';         /* ^U */
 354                 break;
 355 #ifdef VWERASE
 356         case KEY_VWERASE:
 357                 *dnep = '\027';         /* ^W */
 358                 break;
 359 #endif
 360         default:
 361                 *dnep = 1;
 362                 break;
 363         }
 364         return (0);
 365 }
 366
 367 /*
 368  * ip_move --
 369  *      Move the cursor.
 370  *
 371  * PUBLIC: int ip_move __P((SCR *, size_t, size_t));
 372  */
 373 int
 374 ip_move(SCR *sp, size_t lno, size_t cno)
 375 {
 376         IP_PRIVATE *ipp;
 377         IP_BUF ipb;
 378
 379         ipp = IPP(sp);
 380         ipp->row = lno;
 381         ipp->col = cno;
 382
 383         memset(&ipb, 0, sizeof(ipb));
 384         ipb.code = SI_MOVE;
 385         ipb.val1 = RLNO(sp, lno);
 386         ipb.val2 = RCNO(sp, cno);
 387         return (vi_send(ipp->o_fd, "12", &ipb));
 388 }
 389
 390 /*
 391  * PUBLIC: void ip_msg __P((SCR *, mtype_t, char *, size_t));
 392  */
 393 void
 394 ip_msg(SCR *sp, mtype_t mtype, char *line, size_t len)
 395 {
 396         IP_PRIVATE *ipp = IPP(sp);
 397
 398         if (F_ISSET(ipp, IP_ON_ALTERNATE))
 399                 vs_msg(sp, mtype, line, len);
 400         else {
 401                 write(ipp->t_fd, line, len);
 402                 F_CLR(sp, SC_EX_WAIT_NO);
 403         }
 404 }
 405
 406 /*
 407  * ip_refresh --
 408  *      Refresh the screen.
 409  *
 410  * PUBLIC: int ip_refresh __P((SCR *, int));
 411  */
 412 int
 413 ip_refresh(SCR *sp, int repaint)
 414 {
 415         IP_BUF ipb;
 416         IP_PRIVATE *ipp;
 417         db_recno_t total;
 418
 419         ipp = IPP(sp);
 420
 421         /*
 422          * If the scroll bar information has changed since we last sent
 423          * it, resend it.  Currently, we send three values:
 424          *
 425          * top          The line number of the first line in the screen.
 426          * num          The number of lines visible on the screen.
 427          * total        The number of lines in the file.
 428          *
 429          * XXX
 430          * This is a gross violation of layering... we're looking at data
 431          * structures at which we have absolutely no business whatsoever
 432          * looking...
 433          */
 434         memset(&ipb, 0, sizeof(ipb));
 435         ipb.val1 = HMAP->lno;
 436         ipb.val2 = TMAP->lno - HMAP->lno;
 437         if (sp->ep != NULL && sp->ep->db != NULL)
 438                 (void)db_last(sp, &total);
 439         ipb.val3 = total == 0 ? 1 : total;
 440         if (ipb.val1 != ipp->sb_top ||
 441             ipb.val2 != ipp->sb_num || ipb.val3 != ipp->sb_total) {
 442                 ipb.code = SI_SCROLLBAR;
 443                 (void)vi_send(ipp->o_fd, "123", &ipb);
 444                 ipp->sb_top = ipb.val1;
 445                 ipp->sb_num = ipb.val2;
 446                 ipp->sb_total = ipb.val3;
 447         }
 448
 449         /* Refresh/repaint the screen. */
 450         ipb.code = repaint ? SI_REDRAW : SI_REFRESH;
 451         return (vi_send(ipp->o_fd, NULL, &ipb));
 452 }
 453
 454 /*
 455  * ip_rename --
 456  *      Rename the file.
 457  *
 458  * PUBLIC: int ip_rename __P((SCR *, char *, int));
 459  */
 460 int
 461 ip_rename(SCR *sp, char *name, int on)
 462 {
 463         IP_BUF ipb;
 464         IP_PRIVATE *ipp = IPP(sp);
 465
 466         memset(&ipb, 0, sizeof(ipb));
 467         ipb.code = SI_RENAME;
 468         ipb.str1 = name;
 469         ipb.len1 = name ? strlen(name) : 0;
 470         return (vi_send(ipp->o_fd, "a", &ipb));
 471 }
 472
 473 /*
 474  * ip_reply --
 475  *      Reply to a message.
 476  *
 477  * PUBLIC: int ip_reply __P((SCR *, int, char *));
 478  */
 479 int
 480 ip_reply(SCR *sp, int status, char *msg)
 481 {
 482         IP_BUF ipb;
 483         IP_PRIVATE *ipp = IPP(sp);
 484
 485         memset(&ipb, 0, sizeof(ipb));
 486         ipb.code = SI_REPLY;
 487         ipb.val1 = status;
 488         ipb.str1 = msg == NULL ? "" : msg;
 489         ipb.len1 = strlen(ipb.str1);
 490         return (vi_send(ipp->o_fd, "1a", &ipb));
 491 }
 492
 493 /*
 494  * ip_split --
 495  *      Split a screen.
 496  *
 497  * PUBLIC: int ip_split __P((SCR *, SCR *));
 498  */
 499 int
 500 ip_split(SCR *origp, SCR *newp)
 501 {
 502         return (0);
 503 }
 504
 505 /*
 506  * ip_suspend --
 507  *      Suspend a screen.
 508  *
 509  * PUBLIC: int ip_suspend __P((SCR *, int *));
 510  */
 511 int
 512 ip_suspend(SCR *sp, int *allowedp)
 513 {
 514         *allowedp = 0;
 515         return (0);
 516 }
 517
 518 /*
 519  * ip_usage --
 520  *      Print out the ip usage messages.
 521  *
 522  * PUBLIC: void ip_usage __P((void));
 523  */
 524 void
 525 ip_usage(void)
 526 {
 527 #define USAGE "\
 528 usage: vi [-eFlRrSv] [-c command] [-I ifd.ofd] [-t tag] [-w size] [file ...]\n"
 529         (void)fprintf(stderr, "%s", USAGE);
 530 #undef  USAGE
 531 }