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