common/api.c

   1 /*-
   2  * Copyright (c) 1992, 1993, 1994
   3  *      The Regents of the University of California.  All rights reserved.
   4  * Copyright (c) 1992, 1993, 1994, 1995, 1996
   5  *      Keith Bostic.  All rights reserved.
   6  * Copyright (c) 1995
   7  *      George V. Neville-Neil. All rights reserved.
   8  *
   9  * See the LICENSE file for redistribution information.
  10  */
  11
  12 #include "config.h"
  13
  14 #ifndef lint
  15 static const char sccsid[] = "$Id: api.c,v 8.30 2000/06/25 17:34:37 skimo Exp $ (Berkeley) $Date: 2000/06/25 17:34:37 $";
  16 #endif /* not lint */
  17
  18 #include <sys/types.h>
  19 #include <sys/queue.h>
  20 #include <sys/time.h>
  21
  22 #include <bitstring.h>
  23 #include <limits.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <termios.h>
  28 #include <unistd.h>
  29
  30 #include "../common/common.h"
  31 #include "../ex/tag.h"
  32
  33 extern GS *__global_list;                       /* XXX */
  34
  35 /*
  36  * api_fscreen --
  37  *      Return a pointer to the screen specified by the screen id
  38  *      or a file name.
  39  *
  40  * PUBLIC: SCR *api_fscreen __P((int, char *));
  41  */
  42 SCR *
  43 api_fscreen(id, name)
  44         int id;
  45         char *name;
  46 {
  47         GS *gp;
  48         SCR *tsp;
  49         WIN *wp;
  50
  51         gp = __global_list;
  52
  53         /* Search the displayed lists. */
  54         for (wp = gp->dq.cqh_first;
  55             wp != (void *)&gp->dq; wp = wp->q.cqe_next)
  56                 for (tsp = wp->scrq.cqh_first;
  57                     tsp != (void *)&wp->scrq; tsp = tsp->q.cqe_next)
  58                 if (name == NULL) {
  59                         if (id == tsp->id)
  60                                 return (tsp);
  61                 } else if (!strcmp(name, tsp->frp->name))
  62                         return (tsp);
  63
  64         /* Search the hidden list. */
  65         for (tsp = gp->hq.cqh_first;
  66             tsp != (void *)&gp->hq; tsp = tsp->q.cqe_next)
  67                 if (name == NULL) {
  68                         if (id == tsp->id)
  69                                 return (tsp);
  70                 } else if (!strcmp(name, tsp->frp->name))
  71                         return (tsp);
  72         return (NULL);
  73 }
  74
  75 /*
  76  * api_aline --
  77  *      Append a line.
  78  *
  79  * PUBLIC: int api_aline __P((SCR *, db_recno_t, char *, size_t));
  80  */
  81 int
  82 api_aline(sp, lno, line, len)
  83         SCR *sp;
  84         db_recno_t lno;
  85         char *line;
  86         size_t len;
  87 {
  88         return (db_append(sp, 1, lno, line, len));
  89 }
  90
  91 /*
  92  * api_extend --
  93  *      Extend file.
  94  *
  95  * PUBLIC: int api_extend __P((SCR *, db_recno_t));
  96  */
  97 int
  98 api_extend(sp, lno)
  99         SCR *sp;
 100         db_recno_t lno;
 101 {
 102         db_recno_t lastlno;
 103         if (db_last(sp, &lastlno))
 104             return 1;
 105         while(lastlno < lno)
 106             if (db_append(sp, 1, lastlno++, "", 0))
 107                 return 1;
 108         return 0;
 109 }
 110
 111 /*
 112  * api_dline --
 113  *      Delete a line.
 114  *
 115  * PUBLIC: int api_dline __P((SCR *, db_recno_t));
 116  */
 117 int
 118 api_dline(sp, lno)
 119         SCR *sp;
 120         db_recno_t lno;
 121 {
 122         if (db_delete(sp, lno))
 123                 return 1;
 124         /* change current line if deleted line is that one
 125          * or one berfore that
 126          */
 127         if (sp->lno >= lno && sp->lno > 1)
 128                 sp->lno--;
 129         return 0;
 130 }
 131
 132 /*
 133  * api_gline --
 134  *      Get a line.
 135  *
 136  * PUBLIC: int api_gline __P((SCR *, db_recno_t, CHAR_T **, size_t *));
 137  */
 138 int
 139 api_gline(sp, lno, linepp, lenp)
 140         SCR *sp;
 141         db_recno_t lno;
 142         CHAR_T **linepp;
 143         size_t *lenp;
 144 {
 145         int isempty;
 146
 147         if (db_eget(sp, lno, linepp, lenp, &isempty)) {
 148                 if (isempty)
 149                         msgq(sp, M_ERR, "209|The file is empty");
 150                 return (1);
 151         }
 152         return (0);
 153 }
 154
 155 /*
 156  * api_iline --
 157  *      Insert a line.
 158  *
 159  * PUBLIC: int api_iline __P((SCR *, db_recno_t, char *, size_t));
 160  */
 161 int
 162 api_iline(sp, lno, line, len)
 163         SCR *sp;
 164         db_recno_t lno;
 165         char *line;
 166         size_t len;
 167 {
 168         return (db_insert(sp, lno, line, len));
 169 }
 170
 171 /*
 172  * api_lline --
 173  *      Return the line number of the last line in the file.
 174  *
 175  * PUBLIC: int api_lline __P((SCR *, db_recno_t *));
 176  */
 177 int
 178 api_lline(sp, lnop)
 179         SCR *sp;
 180         db_recno_t *lnop;
 181 {
 182         return (db_last(sp, lnop));
 183 }
 184
 185 /*
 186  * api_sline --
 187  *      Set a line.
 188  *
 189  * PUBLIC: int api_sline __P((SCR *, db_recno_t, char *, size_t));
 190  */
 191 int
 192 api_sline(sp, lno, line, len)
 193         SCR *sp;
 194         db_recno_t lno;
 195         char *line;
 196         size_t len;
 197 {
 198         return (db_set(sp, lno, line, len));
 199 }
 200
 201 /*
 202  * api_getmark --
 203  *      Get the mark.
 204  *
 205  * PUBLIC: int api_getmark __P((SCR *, int, MARK *));
 206  */
 207 int
 208 api_getmark(sp, markname, mp)
 209         SCR *sp;
 210         int markname;
 211         MARK *mp;
 212 {
 213         return (mark_get(sp, (ARG_CHAR_T)markname, mp, M_ERR));
 214 }
 215
 216 /*
 217  * api_setmark --
 218  *      Set the mark.
 219  *
 220  * PUBLIC: int api_setmark __P((SCR *, int, MARK *));
 221  */
 222 int
 223 api_setmark(sp, markname, mp)
 224         SCR *sp;
 225         int markname;
 226         MARK *mp;
 227 {
 228         return (mark_set(sp, (ARG_CHAR_T)markname, mp, 1));
 229 }
 230
 231 /*
 232  * api_nextmark --
 233  *      Return the first mark if next not set, otherwise return the
 234  *      subsequent mark.
 235  *
 236  * PUBLIC: int api_nextmark __P((SCR *, int, char *));
 237  */
 238 int
 239 api_nextmark(sp, next, namep)
 240         SCR *sp;
 241         int next;
 242         char *namep;
 243 {
 244         LMARK *mp;
 245
 246         mp = sp->ep->marks.lh_first;
 247         if (next)
 248                 for (; mp != NULL; mp = mp->q.le_next)
 249                         if (mp->name == *namep) {
 250                                 mp = mp->q.le_next;
 251                                 break;
 252                         }
 253         if (mp == NULL)
 254                 return (1);
 255         *namep = mp->name;
 256         return (0);
 257 }
 258
 259 /*
 260  * api_getcursor --
 261  *      Get the cursor.
 262  *
 263  * PUBLIC: int api_getcursor __P((SCR *, MARK *));
 264  */
 265 int
 266 api_getcursor(sp, mp)
 267         SCR *sp;
 268         MARK *mp;
 269 {
 270         mp->lno = sp->lno;
 271         mp->cno = sp->cno;
 272         return (0);
 273 }
 274
 275 /*
 276  * api_setcursor --
 277  *      Set the cursor.
 278  *
 279  * PUBLIC: int api_setcursor __P((SCR *, MARK *));
 280  */
 281 int
 282 api_setcursor(sp, mp)
 283         SCR *sp;
 284         MARK *mp;
 285 {
 286         size_t len;
 287
 288         if (db_get(sp, mp->lno, DBG_FATAL, NULL, &len))
 289                 return (1);
 290         if (mp->cno < 0 || mp->cno > len) {
 291                 msgq(sp, M_ERR, "Cursor set to nonexistent column");
 292                 return (1);
 293         }
 294
 295         /* Set the cursor. */
 296         sp->lno = mp->lno;
 297         sp->cno = mp->cno;
 298         return (0);
 299 }
 300
 301 /*
 302  * api_emessage --
 303  *      Print an error message.
 304  *
 305  * PUBLIC: void api_emessage __P((SCR *, char *));
 306  */
 307 void
 308 api_emessage(sp, text)
 309         SCR *sp;
 310         char *text;
 311 {
 312         msgq(sp, M_ERR, "%s", text);
 313 }
 314
 315 /*
 316  * api_imessage --
 317  *      Print an informational message.
 318  *
 319  * PUBLIC: void api_imessage __P((SCR *, char *));
 320  */
 321 void
 322 api_imessage(sp, text)
 323         SCR *sp;
 324         char *text;
 325 {
 326         msgq(sp, M_INFO, "%s", text);
 327 }
 328
 329 /*
 330  * api_edit
 331  *      Create a new screen and return its id
 332  *      or edit a new file in the current screen.
 333  *
 334  * PUBLIC: int api_edit __P((SCR *, char *, SCR **, int));
 335  */
 336 int
 337 api_edit(sp, file, spp, newscreen)
 338         SCR *sp;
 339         char *file;
 340         SCR **spp;
 341         int newscreen;
 342 {
 343         EXCMD cmd;
 344
 345         if (file) {
 346                 ex_cinit(sp, &cmd, C_EDIT, 0, OOBLNO, OOBLNO, 0);
 347                 argv_exp0(sp, &cmd, file, strlen(file));
 348         } else
 349                 ex_cinit(sp, &cmd, C_EDIT, 0, OOBLNO, OOBLNO, 0);
 350         if (newscreen)
 351                 cmd.flags |= E_NEWSCREEN;               /* XXX */
 352         if (cmd.cmd->fn(sp, &cmd))
 353                 return (1);
 354         *spp = sp->nextdisp;
 355         return (0);
 356 }
 357
 358 /*
 359  * api_escreen
 360  *      End a screen.
 361  *
 362  * PUBLIC: int api_escreen __P((SCR *));
 363  */
 364 int
 365 api_escreen(sp)
 366         SCR *sp;
 367 {
 368         EXCMD cmd;
 369
 370         /*
 371          * XXX
 372          * If the interpreter exits anything other than the current
 373          * screen, vi isn't going to update everything correctly.
 374          */
 375         ex_cinit(sp, &cmd, C_QUIT, 0, OOBLNO, OOBLNO, 0);
 376         return (cmd.cmd->fn(sp, &cmd));
 377 }
 378
 379 /*
 380  * api_swscreen --
 381  *    Switch to a new screen.
 382  *
 383  * PUBLIC: int api_swscreen __P((SCR *, SCR *));
 384  */
 385 int
 386 api_swscreen(sp, new)
 387       SCR *sp, *new;
 388 {
 389         /*
 390          * XXX
 391          * If the interpreter switches from anything other than the
 392          * current screen, vi isn't going to update everything correctly.
 393          */
 394         sp->nextdisp = new;
 395         F_SET(sp, SC_SSWITCH);
 396
 397         return (0);
 398 }
 399
 400 /*
 401  * api_map --
 402  *      Map a key.
 403  *
 404  * PUBLIC: int api_map __P((SCR *, char *, char *, size_t));
 405  */
 406 int
 407 api_map(sp, name, map, len)
 408         SCR *sp;
 409         char *name, *map;
 410         size_t len;
 411 {
 412         EXCMD cmd;
 413
 414         ex_cinit(sp, &cmd, C_MAP, 0, OOBLNO, OOBLNO, 0);
 415         argv_exp0(sp, &cmd, name, strlen(name));
 416         argv_exp0(sp, &cmd, map, len);
 417         return (cmd.cmd->fn(sp, &cmd));
 418 }
 419
 420 /*
 421  * api_unmap --
 422  *      Unmap a key.
 423  *
 424  * PUBLIC: int api_unmap __P((SCR *, char *));
 425  */
 426 int
 427 api_unmap(sp, name)
 428         SCR *sp;
 429         char *name;
 430 {
 431         EXCMD cmd;
 432
 433         ex_cinit(sp, &cmd, C_UNMAP, 0, OOBLNO, OOBLNO, 0);
 434         argv_exp0(sp, &cmd, name, strlen(name));
 435         return (cmd.cmd->fn(sp, &cmd));
 436 }
 437
 438 /*
 439  * api_opts_get --
 440  *      Return a option value as a string, in allocated memory.
 441  *      If the option is of type boolean, boolvalue is (un)set
 442  *      according to the value; otherwise boolvalue is -1.
 443  *
 444  * PUBLIC: int api_opts_get __P((SCR *, char *, char **, int *));
 445  */
 446 int
 447 api_opts_get(sp, name, value, boolvalue)
 448         SCR *sp;
 449         char *name, **value;
 450         int *boolvalue;
 451 {
 452         OPTLIST const *op;
 453         int offset;
 454
 455         if ((op = opts_search(name)) == NULL) {
 456                 opts_nomatch(sp, name);
 457                 return (1);
 458         }
 459
 460         offset = op - optlist;
 461         if (boolvalue != NULL)
 462                 *boolvalue = -1;
 463         switch (op->type) {
 464         case OPT_0BOOL:
 465         case OPT_1BOOL:
 466                 MALLOC_RET(sp, *value, char *, strlen(op->name) + 2 + 1);
 467                 (void)sprintf(*value,
 468                     "%s%s", O_ISSET(sp, offset) ? "" : "no", op->name);
 469                 if (boolvalue != NULL)
 470                         *boolvalue = O_ISSET(sp, offset);
 471                 break;
 472         case OPT_NUM:
 473                 MALLOC_RET(sp, *value, char *, 20);
 474                 (void)sprintf(*value, "%lu", (u_long)O_VAL(sp, offset));
 475                 break;
 476         case OPT_STR:
 477                 if (O_STR(sp, offset) == NULL) {
 478                         MALLOC_RET(sp, *value, char *, 2);
 479                         value[0] = '\0';
 480                 } else {
 481                         MALLOC_RET(sp,
 482                             *value, char *, strlen(O_STR(sp, offset)) + 1);
 483                         (void)sprintf(*value, "%s", O_STR(sp, offset));
 484                 }
 485                 break;
 486         }
 487         return (0);
 488 }
 489
 490 /*
 491  * api_opts_set --
 492  *      Set options.
 493  *
 494  * PUBLIC: int api_opts_set __P((SCR *, char *, char *, u_long, int));
 495  */
 496 int
 497 api_opts_set(sp, name, str_value, num_value, bool_value)
 498         SCR *sp;
 499         char *name, *str_value;
 500         u_long num_value;
 501         int bool_value;
 502 {
 503         ARGS *ap[2], a, b;
 504         OPTLIST const *op;
 505         int rval;
 506         size_t blen;
 507         char *bp;
 508
 509         if ((op = opts_search(name)) == NULL) {
 510                 opts_nomatch(sp, name);
 511                 return (1);
 512         }
 513
 514         switch (op->type) {
 515         case OPT_0BOOL:
 516         case OPT_1BOOL:
 517                 GET_SPACE_RET(sp, bp, blen, 64);
 518                 a.len = snprintf(bp, 64, "%s%s", bool_value ? "" : "no", name);
 519                 break;
 520         case OPT_NUM:
 521                 GET_SPACE_RET(sp, bp, blen, 64);
 522                 a.len = snprintf(bp, 64, "%s=%lu", name, num_value);
 523                 break;
 524         case OPT_STR:
 525                 GET_SPACE_RET(sp, bp, blen, 1024);
 526                 a.len = snprintf(bp, 1024, "%s=%s", name, str_value);
 527                 break;
 528         }
 529         a.bp = bp;
 530         b.len = 0;
 531         b.bp = NULL;
 532         ap[0] = &a;
 533         ap[1] = &b;
 534         rval = opts_set(sp, ap, NULL);
 535
 536         FREE_SPACE(sp, bp, blen);
 537
 538         return (rval);
 539 }
 540
 541 /*
 542  * api_run_str --
 543  *      Execute a string as an ex command.
 544  *
 545  * PUBLIC: int api_run_str __P((SCR *, char *));
 546  */
 547 int
 548 api_run_str(sp, cmd)
 549         SCR *sp;
 550         char *cmd;
 551 {
 552         return (ex_run_str(sp, NULL, cmd, strlen(cmd), 0, 0));
 553 }
 554
 555 /*
 556  * PUBLIC: TAGQ * api_tagq_new __P((SCR*, char*));
 557  */
 558 TAGQ *
 559 api_tagq_new(sp, tag)
 560         SCR *sp;
 561         char *tag;
 562 {
 563         TAGQ *tqp;
 564         size_t len;
 565
 566         /* Allocate and initialize the tag queue structure. */
 567         len = strlen(tag);
 568         CALLOC_GOTO(sp, tqp, TAGQ *, 1, sizeof(TAGQ) + len + 1);
 569         CIRCLEQ_INIT(&tqp->tagq);
 570         tqp->tag = tqp->buf;
 571         memcpy(tqp->tag, tag, (tqp->tlen = len) + 1);
 572
 573         return tqp;
 574
 575 alloc_err:
 576         return (NULL);
 577 }
 578
 579 /*
 580  * PUBLIC: void api_tagq_add __P((SCR*, TAGQ*, char*, char *, char *));
 581  */
 582 void
 583 api_tagq_add(sp, tqp, filename, search, msg)
 584         SCR *sp;
 585         TAGQ *tqp;
 586         char *filename, *search, *msg;
 587 {
 588         TAG *tp;
 589         size_t flen = strlen(filename);
 590         size_t slen = strlen(search);
 591
 592         CALLOC_GOTO(sp, tp, TAG *, 1, sizeof(TAG) - 1 + flen + 1 + slen + 1);
 593         tp->fname = tp->buf;
 594         memcpy(tp->fname, filename, flen + 1);
 595         tp->fnlen = flen;
 596         tp->search = tp->fname + flen + 1;
 597         memcpy(tp->search, search, slen + 1);
 598         tp->slen = slen;
 599         CIRCLEQ_INSERT_TAIL(&tqp->tagq, tp, q);
 600
 601 alloc_err:
 602         return;
 603 }
 604
 605 /*
 606  * PUBLIC: int api_tagq_push __P((SCR*, TAGQ**));
 607  */
 608 int
 609 api_tagq_push(sp, tqpp)
 610         SCR *sp;
 611         TAGQ **tqpp;
 612 {
 613         FREF *frp;
 614         db_recno_t lno;
 615         size_t cno;
 616         int istmp;
 617         TAGQ *tqp;
 618
 619         tqp = *tqpp;
 620
 621         *tqpp = 0;
 622
 623         /* Check to see if we found anything. */
 624         if (tqp->tagq.cqh_first == (void *)&tqp->tagq) {
 625                 free(tqp);
 626                 return 0;
 627         }
 628
 629         tqp->current = tqp->tagq.cqh_first;
 630
 631         if (tagq_push(sp, tqp, 0, 0))
 632                 return 1;
 633
 634         return (0);
 635 }
 636
 637 /*
 638  * PUBLIC: void api_tagq_free __P((SCR*, TAGQ*));
 639  */
 640 void
 641 api_tagq_free(sp, tqp)
 642         SCR *sp;
 643         TAGQ *tqp;
 644 {
 645         if (tqp)
 646                 tagq_free(sp, tqp);
 647 }