perl_api/perl.xs

   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  * Copyright (c) 1996-2001
   9  *      Sven Verdoolaege. All rights reserved.
  10  *
  11  * See the LICENSE file for redistribution information.
  12  */
  13
  14 #undef VI
  15
  16 #ifndef lint
  17 static const char sccsid[] = "$Id: perl.xs,v 8.46 2001/08/28 11:33:42 skimo Exp $ (Berkeley) $Date: 2001/08/28 11:33:42 $";
  18 #endif /* not lint */
  19
  20 #include <sys/types.h>
  21 #include <sys/queue.h>
  22 #include <sys/time.h>
  23
  24 #include <bitstring.h>
  25 #include <ctype.h>
  26 #include <limits.h>
  27 #include <signal.h>
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31 #include <termios.h>
  32 #include <unistd.h>
  33
  34 #include <EXTERN.h>
  35 #include <perl.h>
  36 #include <XSUB.h>
  37
  38 /* perl redefines them
  39  * avoid warnings
  40  */
  41 #undef re_compile
  42 #undef USE_DYNAMIC_LOADING
  43 #undef DEBUG
  44 #undef PACKAGE
  45 #undef ARGS
  46 #define ARGS ARGS
  47
  48 #include "config.h"
  49
  50 #include "../common/common.h"
  51 #include "../perl_api/extern.h"
  52
  53 #ifndef DEFSV
  54 #define DEFSV GvSV(defgv)
  55 #endif
  56 #ifndef ERRSV
  57 #define ERRSV GvSV(errgv)
  58 #endif
  59 #ifndef dTHX
  60 #define dTHXs
  61 #else
  62 #define dTHXs dTHX;
  63 #endif
  64
  65 static void msghandler __P((SCR *, mtype_t, char *, size_t));
  66
  67 typedef struct _perl_data {
  68         PerlInterpreter*        interp;
  69         SV      *svcurscr, *svstart, *svstop, *svid;
  70         CONVWIN  cw;
  71         char    *errmsg;
  72 } perl_data_t;
  73
  74 #define PERLP(sp)   ((perl_data_t *)sp->wp->perl_private)
  75
  76 #define CHAR2INTP(sp,n,nlen,w,wlen)                                         \
  77     CHAR2INT5(sp,((perl_data_t *)sp->wp->perl_private)->cw,n,nlen,w,wlen)
  78
  79 /*
  80  * INITMESSAGE --
  81  *      Macros to point messages at the Perl message handler.
  82  */
  83 #define INITMESSAGE(sp)                                                 \
  84         scr_msg = sp->wp->scr_msg;                                      \
  85         sp->wp->scr_msg = msghandler;
  86 #define ENDMESSAGE(sp)                                                  \
  87         sp->wp->scr_msg = scr_msg;                                      \
  88         if (rval) croak("%s", PERLP(sp)->errmsg);
  89
  90 void xs_init __P((pTHXo));
  91
  92 /*
  93  * perl_end --
  94  *      Clean up perl interpreter
  95  *
  96  * PUBLIC: int perl_end __P((GS *));
  97  */
  98 int
  99 perl_end(gp)
 100         GS *gp;
 101 {
 102         /*
 103          * Call perl_run and perl_destuct to call END blocks and DESTROY
 104          * methods.
 105          */
 106         if (gp->perl_interp) {
 107                 perl_run(gp->perl_interp);
 108                 perl_destruct(gp->perl_interp);
 109 #if defined(DEBUG) || defined(PURIFY) || defined(LIBRARY)
 110                 perl_free(gp->perl_interp);
 111 #endif
 112                 /* XXX rather make sure only one thread calls perl_end */
 113                 gp->perl_interp = 0;
 114         }
 115 }
 116
 117 /*
 118  * perl_eval
 119  *      Evaluate a string
 120  *      We don't use mortal SVs because no one will clean up after us
 121  */
 122 static void
 123 perl_eval(string)
 124         char *string;
 125 {
 126         dTHXs
 127
 128         SV* sv = newSVpv(string, 0);
 129
 130         /* G_KEEPERR to catch syntax error; better way ? */
 131         sv_setpv(ERRSV,"");
 132         perl_eval_sv(sv, G_DISCARD | G_NOARGS | G_KEEPERR);
 133         SvREFCNT_dec(sv);
 134 }
 135
 136 /*
 137  * perl_init --
 138  *      Create the perl commands used by nvi.
 139  *
 140  * PUBLIC: int perl_init __P((SCR *));
 141  */
 142 int
 143 perl_init(scrp)
 144         SCR *scrp;
 145 {
 146         AV * av;
 147         GS *gp;
 148         WIN *wp;
 149         char *bootargs[] = { "VI", NULL };
 150 #ifndef USE_SFIO
 151         SV *svcurscr;
 152 #endif
 153         perl_data_t *pp;
 154
 155         static char *args[] = { "", "-e", "" };
 156         size_t length;
 157         char *file = __FILE__;
 158
 159         gp = scrp->gp;
 160         wp = scrp->wp;
 161
 162         if (gp->perl_interp == NULL) {
 163         gp->perl_interp = perl_alloc();
 164         perl_construct(gp->perl_interp);
 165         if (perl_parse(gp->perl_interp, xs_init, 3, args, 0)) {
 166                 perl_destruct(gp->perl_interp);
 167                 perl_free(gp->perl_interp);
 168                 gp->perl_interp = NULL;
 169                 return 1;
 170         }
 171         {
 172         dTHXs
 173
 174         perl_call_argv("VI::bootstrap", G_DISCARD, bootargs);
 175         perl_eval("$SIG{__WARN__}='VI::Warn'");
 176
 177         av_unshift(av = GvAVn(PL_incgv), 1);
 178         av_store(av, 0, newSVpv(_PATH_PERLSCRIPTS,
 179                                 sizeof(_PATH_PERLSCRIPTS)-1));
 180
 181 #ifdef USE_SFIO
 182         sfdisc(PerlIO_stdout(), sfdcnewnvi(scrp));
 183         sfdisc(PerlIO_stderr(), sfdcnewnvi(scrp));
 184 #else
 185         svcurscr = perl_get_sv("curscr", TRUE);
 186         sv_magic((SV *)gv_fetchpv("STDOUT",TRUE, SVt_PVIO), svcurscr,
 187                         'q', Nullch, 0);
 188         sv_magic((SV *)gv_fetchpv("STDERR",TRUE, SVt_PVIO), svcurscr,
 189                         'q', Nullch, 0);
 190 #endif /* USE_SFIO */
 191         }
 192         }
 193         MALLOC(scrp, pp, perl_data_t *, sizeof(perl_data_t));
 194         wp->perl_private = pp;
 195         memset(&pp->cw, 0, sizeof(pp->cw));
 196 #ifdef USE_ITHREADS
 197         pp->interp = perl_clone(gp->perl_interp, 0);
 198         if (1) { /* hack for bug fixed in perl-current (5.6.1) */
 199             dTHXa(pp->interp);
 200             if (PL_scopestack_ix == 0) {
 201                 ENTER;
 202             }
 203         }
 204 #else
 205         pp->interp = gp->perl_interp;
 206 #endif
 207         pp->errmsg = 0;
 208         {
 209                 dTHXs
 210
 211                 SvREADONLY_on(pp->svcurscr = perl_get_sv("curscr", TRUE));
 212                 SvREADONLY_on(pp->svstart = perl_get_sv("VI::StartLine", TRUE));
 213                 SvREADONLY_on(pp->svstop = perl_get_sv("VI::StopLine", TRUE));
 214                 SvREADONLY_on(pp->svid = perl_get_sv("VI::ScreenId", TRUE));
 215         }
 216         return (0);
 217 }
 218
 219 /*
 220  * perl_screen_end
 221  *      Remove all refences to the screen to be destroyed
 222  *
 223  * PUBLIC: int perl_screen_end __P((SCR*));
 224  */
 225 int
 226 perl_screen_end(scrp)
 227         SCR *scrp;
 228 {
 229         dTHXs
 230
 231         if (scrp->perl_private) {
 232                 sv_setiv((SV*) scrp->perl_private, 0);
 233         }
 234         return 0;
 235 }
 236
 237 static void
 238 my_sighandler(i)
 239         int i;
 240 {
 241         croak("Perl command interrupted by SIGINT");
 242 }
 243
 244 /* Create a new reference to an SV pointing to the SCR structure
 245  * The perl_private part of the SCR structure points to the SV,
 246  * so there can only be one such SV for a particular SCR structure.
 247  * When the last reference has gone (DESTROY is called),
 248  * perl_private is reset; When the screen goes away before
 249  * all references are gone, the value of the SV is reset;
 250  * any subsequent use of any of those reference will produce
 251  * a warning. (see typemap)
 252  */
 253 static SV *
 254 newVIrv(rv, screen)
 255         SV *rv;
 256         SCR *screen;
 257 {
 258         dTHXs
 259
 260         if (!screen) return sv_setsv(rv, &PL_sv_undef), rv;
 261         sv_upgrade(rv, SVt_RV);
 262         if (!screen->perl_private) {
 263                 screen->perl_private = newSV(0);
 264                 sv_setiv(screen->perl_private, (IV) screen);
 265         }
 266         else SvREFCNT_inc(screen->perl_private);
 267         SvRV(rv) = screen->perl_private;
 268         SvROK_on(rv);
 269         return sv_bless(rv, gv_stashpv("VI", TRUE));
 270 }
 271
 272 /*
 273  * perl_setenv
 274  *      Use perl's setenv if perl interpreter has been started.
 275  *      Perl uses its own setenv and gets confused if we change
 276  *      the environment after it has started.
 277  *
 278  * PUBLIC: int perl_setenv __P((SCR* sp, const char *name, const char *value));
 279  */
 280 int
 281 perl_setenv(SCR* scrp, const char *name, const char *value)
 282 {
 283         if (scrp->wp->perl_private == NULL) {
 284             if (value == NULL)
 285                 unsetenv(name);
 286             else
 287                 setenv(name, value, 1);
 288         } else
 289             my_setenv(name, value);
 290 }
 291
 292
 293 /*
 294  * perl_ex_perl -- :[line [,line]] perl [command]
 295  *      Run a command through the perl interpreter.
 296  *
 297  * PUBLIC: int perl_ex_perl __P((SCR*, CHAR_T *, size_t, db_recno_t, db_recno_t));
 298  */
 299 int
 300 perl_ex_perl(scrp, cmdp, cmdlen, f_lno, t_lno)
 301         SCR *scrp;
 302         CHAR_T *cmdp;
 303         size_t cmdlen;
 304         db_recno_t f_lno, t_lno;
 305 {
 306         WIN *wp;
 307         size_t length;
 308         size_t len;
 309         char *err;
 310         char *np;
 311         size_t nlen;
 312         Signal_t (*istat)();
 313         perl_data_t *pp;
 314
 315         /* Initialize the interpreter. */
 316         if (scrp->wp->perl_private == NULL && perl_init(scrp))
 317                         return (1);
 318         pp = scrp->wp->perl_private;
 319     {
 320         dTHXs
 321         dSP;
 322
 323         sv_setiv(pp->svstart, f_lno);
 324         sv_setiv(pp->svstop, t_lno);
 325         newVIrv(pp->svcurscr, scrp);
 326         /* Backwards compatibility. */
 327         newVIrv(pp->svid, scrp);
 328
 329         istat = signal(SIGINT, my_sighandler);
 330         INT2CHAR(scrp, cmdp, STRLEN(cmdp)+1, np, nlen);
 331         perl_eval(np);
 332         signal(SIGINT, istat);
 333
 334         SvREFCNT_dec(SvRV(pp->svcurscr));
 335         SvROK_off(pp->svcurscr);
 336         SvREFCNT_dec(SvRV(pp->svid));
 337         SvROK_off(pp->svid);
 338
 339         err = SvPV(ERRSV, length);
 340         if (!length)
 341                 return (0);
 342
 343         err[length - 1] = '\0';
 344         msgq(scrp, M_ERR, "perl: %s", err);
 345         return (1);
 346     }
 347 }
 348
 349 /*
 350  * replace_line
 351  *      replace a line with the contents of the perl variable $_
 352  *      lines are split at '\n's
 353  *      if $_ is undef, the line is deleted
 354  *      returns possibly adjusted linenumber
 355  */
 356 static int
 357 replace_line(scrp, line, t_lno, defsv)
 358         SCR *scrp;
 359         db_recno_t line, *t_lno;
 360         SV *defsv;
 361 {
 362         char *str, *next;
 363         CHAR_T *wp;
 364         size_t len, wlen;
 365         dTHXs
 366
 367         if (SvOK(defsv)) {
 368                 str = SvPV(defsv,len);
 369                 next = memchr(str, '\n', len);
 370                 CHAR2INTP(scrp, str, next ? (next - str) : len, wp, wlen);
 371                 api_sline(scrp, line, wp, wlen);
 372                 while (next++) {
 373                         len -= next - str;
 374                         next = memchr(str = next, '\n', len);
 375                         CHAR2INTP(scrp, str, next ? (next - str) : len,
 376                                     wp, wlen);
 377                         api_iline(scrp, ++line, wp, wlen);
 378                         (*t_lno)++;
 379                 }
 380         } else {
 381                 api_dline(scrp, line--);
 382                 (*t_lno)--;
 383         }
 384         return line;
 385 }
 386
 387 /*
 388  * perl_ex_perldo -- :[line [,line]] perl [command]
 389  *      Run a set of lines through the perl interpreter.
 390  *
 391  * PUBLIC: int perl_ex_perldo __P((SCR*, CHAR_T *, size_t, db_recno_t, db_recno_t));
 392  */
 393 int
 394 perl_ex_perldo(scrp, cmdp, cmdlen, f_lno, t_lno)
 395         SCR *scrp;
 396         CHAR_T *cmdp;
 397         size_t cmdlen;
 398         db_recno_t f_lno, t_lno;
 399 {
 400         CHAR_T *p;
 401         WIN *wp;
 402         size_t length;
 403         size_t len;
 404         db_recno_t i;
 405         CHAR_T *str;
 406         char *estr;
 407         SV* cv;
 408         char *command;
 409         perl_data_t *pp;
 410         char *np;
 411         size_t nlen;
 412
 413         /* Initialize the interpreter. */
 414         if (scrp->wp->perl_private == NULL && perl_init(scrp))
 415                         return (1);
 416         pp = scrp->wp->perl_private;
 417     {
 418         dTHXs
 419         dSP;
 420
 421         newVIrv(pp->svcurscr, scrp);
 422         /* Backwards compatibility. */
 423         newVIrv(pp->svid, scrp);
 424
 425         INT2CHAR(scrp, cmdp, STRLEN(cmdp)+1, np, nlen);
 426         if (!(command = malloc(length = nlen - 1 + sizeof("sub {}"))))
 427                 return 1;
 428         snprintf(command, length, "sub {%s}", np);
 429
 430         ENTER;
 431         SAVETMPS;
 432
 433         cv = perl_eval_pv(command, FALSE);
 434         free (command);
 435
 436         estr = SvPV(ERRSV,length);
 437         if (length)
 438                 goto err;
 439
 440         for (i = f_lno; i <= t_lno && !api_gline(scrp, i, &str, &len); i++) {
 441                 INT2CHAR(scrp, str, len, np, nlen);
 442                 sv_setpvn(DEFSV,np,nlen);
 443                 sv_setiv(pp->svstart, i);
 444                 sv_setiv(pp->svstop, i);
 445                 PUSHMARK(sp);
 446                 perl_call_sv(cv, G_SCALAR | G_EVAL);
 447                 estr = SvPV(ERRSV, length);
 448                 if (length) break;
 449                 SPAGAIN;
 450                 if(SvTRUEx(POPs))
 451                         i = replace_line(scrp, i, &t_lno, DEFSV);
 452                 PUTBACK;
 453         }
 454         FREETMPS;
 455         LEAVE;
 456
 457         SvREFCNT_dec(SvRV(pp->svcurscr));
 458         SvROK_off(pp->svcurscr);
 459         SvREFCNT_dec(SvRV(pp->svid));
 460         SvROK_off(pp->svid);
 461
 462         if (!length)
 463                 return (0);
 464
 465 err:    estr[length - 1] = '\0';
 466         msgq(scrp, M_ERR, "perl: %s", estr);
 467         return (1);
 468     }
 469 }
 470
 471 /*
 472  * msghandler --
 473  *      Perl message routine so that error messages are processed in
 474  *      Perl, not in nvi.
 475  */
 476 static void
 477 msghandler(sp, mtype, msg, len)
 478         SCR *sp;
 479         mtype_t mtype;
 480         char *msg;
 481         size_t len;
 482 {
 483         char    *errmsg;
 484
 485         errmsg = PERLP(sp)->errmsg;
 486
 487         /* Replace the trailing <newline> with an EOS. */
 488         /* Let's do that later instead */
 489         if (errmsg) free (errmsg);
 490         errmsg = malloc(len + 1);
 491         memcpy(errmsg, msg, len);
 492         errmsg[len] = '\0';
 493         PERLP(sp)->errmsg = errmsg;
 494 }
 495
 496
 497 typedef SCR *   VI;
 498 typedef SCR *   VI__OPT;
 499 typedef SCR *   VI__MAP;
 500 typedef SCR *   VI__MARK;
 501 typedef SCR *   VI__LINE;
 502 typedef AV *    AVREF;
 503
 504 typedef struct {
 505     SV      *sprv;
 506     TAGQ    *tqp;
 507 } perl_tagq;
 508
 509 typedef perl_tagq *  VI__TAGQ;
 510 typedef perl_tagq *  VI__TAGQ2;
 511
 512 MODULE = VI     PACKAGE = VI
 513
 514 # msg --
 515 #       Set the message line to text.
 516 #
 517 # Perl Command: VI::Msg
 518 # Usage: VI::Msg screenId text
 519
 520 void
 521 Msg(screen, text)
 522         VI          screen
 523         char *      text
 524
 525         ALIAS:
 526         PRINT = 1
 527
 528         CODE:
 529         api_imessage(screen, text);
 530
 531 # XS_VI_escreen --
 532 #       End a screen.
 533 #
 534 # Perl Command: VI::EndScreen
 535 # Usage: VI::EndScreen screenId
 536
 537 void
 538 EndScreen(screen)
 539         VI      screen
 540
 541         PREINIT:
 542         void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
 543         int rval;
 544
 545         CODE:
 546         INITMESSAGE(screen);
 547         rval = api_escreen(screen);
 548         ENDMESSAGE(screen);
 549
 550 # XS_VI_iscreen --
 551 #       Create a new screen.  If a filename is specified then the screen
 552 #       is opened with that file.
 553 #
 554 # Perl Command: VI::NewScreen
 555 # Usage: VI::NewScreen screenId [file]
 556
 557 VI
 558 Edit(screen, ...)
 559         VI screen
 560
 561         ALIAS:
 562         NewScreen = 1
 563
 564         PROTOTYPE: $;$
 565         PREINIT:
 566         void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
 567         int rval;
 568         char *file;
 569         SCR *nsp;
 570
 571         CODE:
 572         file = (items == 1) ? NULL : (char *)SvPV(ST(1),PL_na);
 573         INITMESSAGE(screen);
 574         rval = api_edit(screen, file, &nsp, ix);
 575         ENDMESSAGE(screen);
 576
 577         RETVAL = ix ? nsp : screen;
 578
 579         OUTPUT:
 580         RETVAL
 581
 582 # XS_VI_fscreen --
 583 #       Return the screen id associated with file name.
 584 #
 585 # Perl Command: VI::FindScreen
 586 # Usage: VI::FindScreen file
 587
 588 VI
 589 FindScreen(file)
 590         char *file
 591
 592         PREINIT:
 593         SCR *fsp;
 594         CODE:
 595         RETVAL = api_fscreen(0, file);
 596
 597         OUTPUT:
 598         RETVAL
 599
 600 # XS_VI_GetFileName --
 601 #       Return the file name of the screen
 602 #
 603 # Perl Command: VI::GetFileName
 604 # Usage: VI::GetFileName screenId
 605
 606 char *
 607 GetFileName(screen)
 608         VI screen;
 609
 610         PPCODE:
 611         EXTEND(sp,1);
 612         PUSHs(sv_2mortal(newSVpv(screen->frp->name, 0)));
 613
 614 # XS_VI_aline --
 615 #       -- Append the string text after the line in lineNumber.
 616 #
 617 # Perl Command: VI::AppendLine
 618 # Usage: VI::AppendLine screenId lineNumber text
 619
 620 void
 621 AppendLine(screen, linenumber, text)
 622         VI screen
 623         int linenumber
 624         char *text
 625
 626         PREINIT:
 627         void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
 628         int rval;
 629         size_t length;
 630
 631         CODE:
 632         SvPV(ST(2), length);
 633         INITMESSAGE(screen);
 634         rval = api_aline(screen, linenumber, text, length);
 635         ENDMESSAGE(screen);
 636
 637 # XS_VI_dline --
 638 #       Delete lineNum.
 639 #
 640 # Perl Command: VI::DelLine
 641 # Usage: VI::DelLine screenId lineNum
 642
 643 void
 644 DelLine(screen, linenumber)
 645         VI screen
 646         int linenumber
 647
 648         PREINIT:
 649         void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
 650         int rval;
 651
 652         CODE:
 653         INITMESSAGE(screen);
 654         rval = api_dline(screen, (db_recno_t)linenumber);
 655         ENDMESSAGE(screen);
 656
 657 # XS_VI_gline --
 658 #       Return lineNumber.
 659 #
 660 # Perl Command: VI::GetLine
 661 # Usage: VI::GetLine screenId lineNumber
 662
 663 char *
 664 GetLine(screen, linenumber)
 665         VI screen
 666         int linenumber
 667
 668         PREINIT:
 669         size_t len;
 670         void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
 671         int rval;
 672         char *line;
 673         CHAR_T *p;
 674
 675         PPCODE:
 676         INITMESSAGE(screen);
 677         rval = api_gline(screen, (db_recno_t)linenumber, &p, &len);
 678         ENDMESSAGE(screen);
 679
 680         EXTEND(sp,1);
 681         PUSHs(sv_2mortal(newSVpv(len ? (char *)p : "", len)));
 682
 683 # XS_VI_sline --
 684 #       Set lineNumber to the text supplied.
 685 #
 686 # Perl Command: VI::SetLine
 687 # Usage: VI::SetLine screenId lineNumber text
 688
 689 void
 690 SetLine(screen, linenumber, text)
 691         VI screen
 692         int linenumber
 693         char *text
 694
 695         PREINIT:
 696         void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
 697         int rval;
 698         size_t length;
 699         size_t len;
 700         CHAR_T *line;
 701
 702         CODE:
 703         SvPV(ST(2), length);
 704         INITMESSAGE(screen);
 705         CHAR2INTP(screen, text, length, line, len);
 706         rval = api_sline(screen, linenumber, line, len);
 707         ENDMESSAGE(screen);
 708
 709 # XS_VI_iline --
 710 #       Insert the string text before the line in lineNumber.
 711 #
 712 # Perl Command: VI::InsertLine
 713 # Usage: VI::InsertLine screenId lineNumber text
 714
 715 void
 716 InsertLine(screen, linenumber, text)
 717         VI screen
 718         int linenumber
 719         char *text
 720
 721         PREINIT:
 722         void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
 723         int rval;
 724         size_t length;
 725         size_t len;
 726         CHAR_T *line;
 727
 728         CODE:
 729         SvPV(ST(2), length);
 730         INITMESSAGE(screen);
 731         CHAR2INTP(screen, text, length, line, len);
 732         rval = api_iline(screen, linenumber, line, len);
 733         ENDMESSAGE(screen);
 734
 735 # XS_VI_lline --
 736 #       Return the last line in the screen.
 737 #
 738 # Perl Command: VI::LastLine
 739 # Usage: VI::LastLine screenId
 740
 741 int
 742 LastLine(screen)
 743         VI screen
 744
 745         PREINIT:
 746         db_recno_t last;
 747         void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
 748         int rval;
 749
 750         CODE:
 751         INITMESSAGE(screen);
 752         rval = api_lline(screen, &last);
 753         ENDMESSAGE(screen);
 754         RETVAL=last;
 755
 756         OUTPUT:
 757         RETVAL
 758
 759 # XS_VI_getmark --
 760 #       Return the mark's cursor position as a list with two elements.
 761 #       {line, column}.
 762 #
 763 # Perl Command: VI::GetMark
 764 # Usage: VI::GetMark screenId mark
 765
 766 void
 767 GetMark(screen, mark)
 768         VI screen
 769         char mark
 770
 771         PREINIT:
 772         struct _mark cursor;
 773         void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
 774         int rval;
 775
 776         PPCODE:
 777         INITMESSAGE(screen);
 778         rval = api_getmark(screen, (int)mark, &cursor);
 779         ENDMESSAGE(screen);
 780
 781         EXTEND(sp,2);
 782         PUSHs(sv_2mortal(newSViv(cursor.lno)));
 783         PUSHs(sv_2mortal(newSViv(cursor.cno)));
 784
 785 # XS_VI_setmark --
 786 #       Set the mark to the line and column numbers supplied.
 787 #
 788 # Perl Command: VI::SetMark
 789 # Usage: VI::SetMark screenId mark line column
 790
 791 void
 792 SetMark(screen, mark, line, column)
 793         VI screen
 794         char mark
 795         int line
 796         int column
 797
 798         PREINIT:
 799         struct _mark cursor;
 800         void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
 801         int rval;
 802
 803         CODE:
 804         INITMESSAGE(screen);
 805         cursor.lno = line;
 806         cursor.cno = column;
 807         rval = api_setmark(screen, (int)mark, &cursor);
 808         ENDMESSAGE(screen);
 809
 810 # XS_VI_getcursor --
 811 #       Return the current cursor position as a list with two elements.
 812 #       {line, column}.
 813 #
 814 # Perl Command: VI::GetCursor
 815 # Usage: VI::GetCursor screenId
 816
 817 void
 818 GetCursor(screen)
 819         VI screen
 820
 821         PREINIT:
 822         struct _mark cursor;
 823         void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
 824         int rval;
 825
 826         PPCODE:
 827         INITMESSAGE(screen);
 828         rval = api_getcursor(screen, &cursor);
 829         ENDMESSAGE(screen);
 830
 831         EXTEND(sp,2);
 832         PUSHs(sv_2mortal(newSViv(cursor.lno)));
 833         PUSHs(sv_2mortal(newSViv(cursor.cno)));
 834
 835 # XS_VI_setcursor --
 836 #       Set the cursor to the line and column numbers supplied.
 837 #
 838 # Perl Command: VI::SetCursor
 839 # Usage: VI::SetCursor screenId line column
 840
 841 void
 842 SetCursor(screen, line, column)
 843         VI screen
 844         int line
 845         int column
 846
 847         PREINIT:
 848         struct _mark cursor;
 849         void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
 850         int rval;
 851
 852         CODE:
 853         INITMESSAGE(screen);
 854         cursor.lno = line;
 855         cursor.cno = column;
 856         rval = api_setcursor(screen, &cursor);
 857         ENDMESSAGE(screen);
 858
 859 # XS_VI_swscreen --
 860 #       Change the current focus to screen.
 861 #
 862 # Perl Command: VI::SwitchScreen
 863 # Usage: VI::SwitchScreen screenId screenId
 864
 865 void
 866 SwitchScreen(screenFrom, screenTo)
 867         VI screenFrom
 868         VI screenTo
 869
 870         PREINIT:
 871         void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
 872         int rval;
 873
 874         CODE:
 875         INITMESSAGE(screenFrom);
 876         rval = api_swscreen(screenFrom, screenTo);
 877         ENDMESSAGE(screenFrom);
 878
 879 # XS_VI_map --
 880 #       Associate a key with a perl procedure.
 881 #
 882 # Perl Command: VI::MapKey
 883 # Usage: VI::MapKey screenId key perlproc
 884
 885 void
 886 MapKey(screen, key, commandsv)
 887         VI screen
 888         char *key
 889         SV *commandsv
 890
 891         PREINIT:
 892         void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
 893         int rval;
 894         int length;
 895         char *command;
 896
 897         CODE:
 898         INITMESSAGE(screen);
 899         command = SvPV(commandsv, length);
 900         rval = api_map(screen, key, command, length);
 901         ENDMESSAGE(screen);
 902
 903 # XS_VI_unmap --
 904 #       Unmap a key.
 905 #
 906 # Perl Command: VI::UnmapKey
 907 # Usage: VI::UnmmapKey screenId key
 908
 909 void
 910 UnmapKey(screen, key)
 911         VI screen
 912         char *key
 913
 914         PREINIT:
 915         void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
 916         int rval;
 917
 918         CODE:
 919         INITMESSAGE(screen);
 920         rval = api_unmap(screen, key);
 921         ENDMESSAGE(screen);
 922
 923 # XS_VI_opts_set --
 924 #       Set an option.
 925 #
 926 # Perl Command: VI::SetOpt
 927 # Usage: VI::SetOpt screenId setting
 928
 929 void
 930 SetOpt(screen, setting)
 931         VI screen
 932         char *setting
 933
 934         PREINIT:
 935         void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
 936         int rval;
 937         SV *svc;
 938
 939         CODE:
 940         INITMESSAGE(screen);
 941         svc = sv_2mortal(newSVpv(":set ", 5));
 942         sv_catpv(svc, setting);
 943         rval = api_run_str(screen, SvPV(svc, PL_na));
 944         ENDMESSAGE(screen);
 945
 946 # XS_VI_opts_get --
 947 #       Return the value of an option.
 948 #
 949 # Perl Command: VI::GetOpt
 950 # Usage: VI::GetOpt screenId option
 951
 952 void
 953 GetOpt(screen, option)
 954         VI screen
 955         char *option
 956
 957         PREINIT:
 958         void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
 959         int rval;
 960         char *value;
 961         CHAR_T *wp;
 962         size_t wlen;
 963
 964         PPCODE:
 965         INITMESSAGE(screen);
 966         CHAR2INTP(screen, option, strlen(option)+1, wp, wlen);
 967         rval = api_opts_get(screen, wp, &value, NULL);
 968         ENDMESSAGE(screen);
 969
 970         EXTEND(SP,1);
 971         PUSHs(sv_2mortal(newSVpv(value, 0)));
 972         free(value);
 973
 974 # XS_VI_run --
 975 #       Run the ex command cmd.
 976 #
 977 # Perl Command: VI::Run
 978 # Usage: VI::Run screenId cmd
 979
 980 void
 981 Run(screen, command)
 982         VI screen
 983         char *command;
 984
 985         PREINIT:
 986         void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
 987         int rval;
 988
 989         CODE:
 990         INITMESSAGE(screen);
 991         rval = api_run_str(screen, command);
 992         ENDMESSAGE(screen);
 993
 994 void
 995 DESTROY(screensv)
 996         SV* screensv
 997
 998         PREINIT:
 999         VI  screen;
1000
1001         CODE:
1002         if (sv_isa(screensv, "VI")) {
1003                 IV tmp = SvIV((SV*)SvRV(screensv));
1004                 screen = (SCR *) tmp;
1005         }
1006         else
1007                 croak("screen is not of type VI");
1008
1009         if (screen)
1010         screen->perl_private = 0;
1011
1012 void
1013 Warn(warning)
1014         char *warning;
1015
1016         CODE:
1017         sv_catpv(ERRSV,warning);
1018
1019 #define TIED(kind,package) \
1020         sv_magic((SV *) (var = \
1021             (kind##V *)sv_2mortal((SV *)new##kind##V())), \
1022                 sv_setref_pv(sv_newmortal(), package, \
1023                         newVIrv(newSV(0), screen)),\
1024                 'P', Nullch, 0);\
1025         RETVAL = newRV((SV *)var)
1026
1027 SV *
1028 Opt(screen)
1029         VI screen;
1030         PREINIT:
1031         HV *var;
1032         CODE:
1033         TIED(H,"VI::OPT");
1034         OUTPUT:
1035         RETVAL
1036
1037 SV *
1038 Map(screen)
1039         VI screen;
1040         PREINIT:
1041         HV *var;
1042         CODE:
1043         TIED(H,"VI::MAP");
1044         OUTPUT:
1045         RETVAL
1046
1047 SV *
1048 Mark(screen)
1049         VI screen
1050         PREINIT:
1051         HV *var;
1052         CODE:
1053         TIED(H,"VI::MARK");
1054         OUTPUT:
1055         RETVAL
1056
1057 SV *
1058 Line(screen)
1059         VI screen
1060         PREINIT:
1061         AV *var;
1062         CODE:
1063         TIED(A,"VI::LINE");
1064         OUTPUT:
1065         RETVAL
1066
1067 SV *
1068 TagQ(screen, tag)
1069         VI screen
1070         char *tag;
1071
1072         PREINIT:
1073         perl_tagq *ptag;
1074
1075         PPCODE:
1076         if ((ptag = malloc(sizeof(perl_tagq))) == NULL)
1077                 goto err;
1078
1079         ptag->sprv = newVIrv(newSV(0), screen);
1080         ptag->tqp = api_tagq_new(screen, tag);
1081         if (ptag->tqp != NULL) {
1082                 EXTEND(SP,1);
1083                 PUSHs(sv_2mortal(sv_setref_pv(newSV(0), "VI::TAGQ", ptag)));
1084         } else {
1085 err:
1086                 ST(0) = &PL_sv_undef;
1087                 return;
1088         }
1089
1090 MODULE = VI     PACKAGE = VI::OPT
1091
1092 void
1093 DESTROY(screen)
1094         VI::OPT screen
1095
1096         CODE:
1097         # typemap did all the checking
1098         SvREFCNT_dec((SV*)SvIV((SV*)SvRV(ST(0))));
1099
1100 void
1101 FETCH(screen, key)
1102         VI::OPT screen
1103         char *key
1104
1105         PREINIT:
1106         void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
1107         int rval;
1108         char *value;
1109         int boolvalue;
1110         CHAR_T *wp;
1111         size_t wlen;
1112
1113         PPCODE:
1114         INITMESSAGE(screen);
1115         CHAR2INTP(screen, key, strlen(key)+1, wp, wlen);
1116         rval = api_opts_get(screen, wp, &value, &boolvalue);
1117         if (!rval) {
1118                 EXTEND(SP,1);
1119                 PUSHs(sv_2mortal((boolvalue == -1) ? newSVpv(value, 0)
1120                                                    : newSViv(boolvalue)));
1121                 free(value);
1122         } else ST(0) = &PL_sv_undef;
1123         rval = 0;
1124         ENDMESSAGE(screen);
1125
1126 void
1127 STORE(screen, key, value)
1128         VI::OPT screen
1129         char    *key
1130         SV      *value
1131
1132         PREINIT:
1133         void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
1134         int rval;
1135         CHAR_T *wp;
1136         size_t wlen;
1137
1138         CODE:
1139         INITMESSAGE(screen);
1140         CHAR2INTP(screen, key, strlen(key)+1, wp, wlen);
1141         rval = api_opts_set(screen, wp, SvPV(value, PL_na), SvIV(value),
1142                                          SvTRUEx(value));
1143         ENDMESSAGE(screen);
1144
1145 MODULE = VI     PACKAGE = VI::MAP
1146
1147 void
1148 DESTROY(screen)
1149         VI::MAP screen
1150
1151         CODE:
1152         # typemap did all the checking
1153         SvREFCNT_dec((SV*)SvIV((SV*)SvRV(ST(0))));
1154
1155 void
1156 STORE(screen, key, commandsv)
1157         VI::MAP screen
1158         char *key
1159         SV *commandsv
1160
1161         PREINIT:
1162         void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
1163         int rval;
1164         int length;
1165         char *command;
1166
1167         CODE:
1168         INITMESSAGE(screen);
1169         command = SvPV(commandsv, length);
1170         rval = api_map(screen, key, command, length);
1171         ENDMESSAGE(screen);
1172
1173 void
1174 DELETE(screen, key)
1175         VI::MAP screen
1176         char *key
1177
1178         PREINIT:
1179         void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
1180         int rval;
1181
1182         CODE:
1183         INITMESSAGE(screen);
1184         rval = api_unmap(screen, key);
1185         ENDMESSAGE(screen);
1186
1187 MODULE = VI     PACKAGE = VI::MARK
1188
1189 void
1190 DESTROY(screen)
1191         VI::MARK screen
1192
1193         CODE:
1194         # typemap did all the checking
1195         SvREFCNT_dec((SV*)SvIV((SV*)SvRV(ST(0))));
1196
1197 int
1198 EXISTS(screen, mark)
1199         VI::MARK screen
1200         char mark
1201
1202         PREINIT:
1203         struct _mark cursor;
1204         void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
1205         int rval = 0; /* never croak */
1206         int missing;
1207
1208         CODE:
1209         INITMESSAGE(screen);
1210         missing = api_getmark(screen, (int)mark, &cursor);
1211         ENDMESSAGE(screen);
1212         RETVAL = !missing;
1213
1214         OUTPUT:
1215         RETVAL
1216
1217 AV *
1218 FETCH(screen, mark)
1219         VI::MARK screen
1220         char mark
1221
1222         PREINIT:
1223         struct _mark cursor;
1224         void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
1225         int rval;
1226
1227         CODE:
1228         INITMESSAGE(screen);
1229         rval = api_getmark(screen, (int)mark, &cursor);
1230         ENDMESSAGE(screen);
1231         RETVAL = newAV();
1232         av_push(RETVAL, newSViv(cursor.lno));
1233         av_push(RETVAL, newSViv(cursor.cno));
1234
1235         OUTPUT:
1236         RETVAL
1237
1238 void
1239 STORE(screen, mark, pos)
1240         VI::MARK screen
1241         char mark
1242         AVREF pos
1243
1244         PREINIT:
1245         struct _mark cursor;
1246         void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
1247         int rval;
1248
1249         CODE:
1250         if (av_len(pos) < 1)
1251             croak("cursor position needs 2 elements");
1252         INITMESSAGE(screen);
1253         cursor.lno = SvIV(*av_fetch(pos, 0, 0));
1254         cursor.cno = SvIV(*av_fetch(pos, 1, 0));
1255         rval = api_setmark(screen, (int)mark, &cursor);
1256         ENDMESSAGE(screen);
1257
1258 void
1259 FIRSTKEY(screen, ...)
1260         VI::MARK screen
1261
1262         ALIAS:
1263         NEXTKEY = 1
1264
1265         PROTOTYPE: $;$
1266
1267         PREINIT:
1268         int next;
1269         char key[] = {0, 0};
1270
1271         PPCODE:
1272         if (items == 2) {
1273                 next = 1;
1274                 *key = *(char *)SvPV(ST(1),PL_na);
1275         } else next = 0;
1276         if (api_nextmark(screen, next, key) != 1) {
1277                 EXTEND(sp, 1);
1278                 PUSHs(sv_2mortal(newSVpv(key, 1)));
1279         } else ST(0) = &PL_sv_undef;
1280
1281 MODULE = VI     PACKAGE = VI::LINE
1282
1283 void
1284 DESTROY(screen)
1285         VI::LINE screen
1286
1287         CODE:
1288         # typemap did all the checking
1289         SvREFCNT_dec((SV*)SvIV((SV*)SvRV(ST(0))));
1290
1291 # similar to SetLine
1292
1293 void
1294 STORE(screen, linenumber, text)
1295         VI::LINE screen
1296         int linenumber
1297         char *text
1298
1299         PREINIT:
1300         void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
1301         int rval;
1302         size_t length;
1303         db_recno_t last;
1304         size_t len;
1305         CHAR_T *line;
1306
1307         CODE:
1308         ++linenumber;   /* vi 1 based ; perl 0 based */
1309         SvPV(ST(2), length);
1310         INITMESSAGE(screen);
1311         rval = api_lline(screen, &last);
1312         if (!rval) {
1313             if (linenumber > last)
1314                 rval = api_extend(screen, linenumber);
1315             if (!rval)
1316                 CHAR2INTP(screen, text, length, line, len);
1317                 rval = api_sline(screen, linenumber, line, len);
1318         }
1319         ENDMESSAGE(screen);
1320
1321 # similar to GetLine
1322
1323 char *
1324 FETCH(screen, linenumber)
1325         VI::LINE screen
1326         int linenumber
1327
1328         PREINIT:
1329         size_t len;
1330         void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
1331         int rval;
1332         char *line;
1333         CHAR_T *p;
1334
1335         PPCODE:
1336         ++linenumber;   /* vi 1 based ; perl 0 based */
1337         INITMESSAGE(screen);
1338         rval = api_gline(screen, (db_recno_t)linenumber, &p, &len);
1339         ENDMESSAGE(screen);
1340
1341         EXTEND(sp,1);
1342         PUSHs(sv_2mortal(newSVpv(len ? (char*)p : "", len)));
1343
1344 # similar to LastLine
1345
1346 int
1347 FETCHSIZE(screen)
1348         VI::LINE screen
1349
1350         PREINIT:
1351         db_recno_t last;
1352         void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
1353         int rval;
1354
1355         CODE:
1356         INITMESSAGE(screen);
1357         rval = api_lline(screen, &last);
1358         ENDMESSAGE(screen);
1359         RETVAL=last;
1360
1361         OUTPUT:
1362         RETVAL
1363
1364 void
1365 STORESIZE(screen, count)
1366         VI::LINE screen
1367         int count
1368
1369         PREINIT:
1370         db_recno_t last;
1371         void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
1372         int rval;
1373
1374         CODE:
1375         INITMESSAGE(screen);
1376         rval = api_lline(screen, &last);
1377         if (!rval) {
1378             if (count > last)
1379                 rval = api_extend(screen, count);
1380             else while(last && last > count) {
1381                 rval = api_dline(screen, last--);
1382                 if (rval) break;
1383             }
1384         }
1385         ENDMESSAGE(screen);
1386
1387 void
1388 EXTEND(screen, count)
1389         VI::LINE screen
1390         int count
1391
1392         CODE:
1393
1394 void
1395 CLEAR(screen)
1396         VI::LINE screen
1397
1398         PREINIT:
1399         db_recno_t last;
1400         void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
1401         int rval;
1402
1403         CODE:
1404         INITMESSAGE(screen);
1405         rval = api_lline(screen, &last);
1406         if (!rval) {
1407             while(last) {
1408                 rval = api_dline(screen, last--);
1409                 if (rval) break;
1410             }
1411         }
1412         ENDMESSAGE(screen);
1413
1414 void
1415 PUSH(screen, ...)
1416         VI::LINE screen;
1417
1418         PREINIT:
1419         db_recno_t last;
1420         void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
1421         int rval, i, len;
1422         char *line;
1423
1424         CODE:
1425         INITMESSAGE(screen);
1426         rval = api_lline(screen, &last);
1427
1428         if (!rval)
1429                 for (i = 1; i < items; ++i) {
1430                         line = SvPV(ST(i), len);
1431                         if ((rval = api_aline(screen, last++, line, len)))
1432                                 break;
1433                 }
1434         ENDMESSAGE(screen);
1435
1436 SV *
1437 POP(screen)
1438         VI::LINE screen;
1439
1440         PREINIT:
1441         db_recno_t last;
1442         void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
1443         int rval, i, len;
1444         CHAR_T *line;
1445
1446         PPCODE:
1447         INITMESSAGE(screen);
1448         rval = api_lline(screen, &last);
1449         if (rval || last < 1)
1450                 ST(0) = &PL_sv_undef;
1451         else {
1452                 rval = api_gline(screen, last, &line, &len) ||
1453                        api_dline(screen, last);
1454                 EXTEND(sp,1);
1455                 PUSHs(sv_2mortal(newSVpv(len ? (char *)line : "", len)));
1456         }
1457         ENDMESSAGE(screen);
1458
1459 SV *
1460 SHIFT(screen)
1461         VI::LINE screen;
1462
1463         PREINIT:
1464         db_recno_t last;
1465         void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
1466         int rval, i, len;
1467         CHAR_T *line;
1468
1469         PPCODE:
1470         INITMESSAGE(screen);
1471         rval = api_lline(screen, &last);
1472         if (rval || last < 1)
1473                 ST(0) = &PL_sv_undef;
1474         else {
1475                 rval = api_gline(screen, (db_recno_t)1, &line, &len) ||
1476                        api_dline(screen, (db_recno_t)1);
1477                 EXTEND(sp,1);
1478                 PUSHs(sv_2mortal(newSVpv(len ? (char *)line : "", len)));
1479         }
1480         ENDMESSAGE(screen);
1481
1482 void
1483 UNSHIFT(screen, ...)
1484         VI::LINE screen;
1485
1486         PREINIT:
1487         void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
1488         int rval, i, len;
1489         char *np;
1490         size_t nlen;
1491         CHAR_T *line;
1492
1493         CODE:
1494         INITMESSAGE(screen);
1495         while (--items != 0) {
1496                 np = SvPV(ST(items), nlen);
1497                 CHAR2INTP(screen, np, nlen, line, len);
1498                 if ((rval = api_iline(screen, (db_recno_t)1, line, len)))
1499                         break;
1500         }
1501         ENDMESSAGE(screen);
1502
1503 void
1504 SPLICE(screen, ...)
1505         VI::LINE screen;
1506
1507         PREINIT:
1508         db_recno_t last, db_offset;
1509         void (*scr_msg) __P((SCR *, mtype_t, char *, size_t));
1510         int rval, length, common, len, i, offset;
1511         CHAR_T *line;
1512         char *np;
1513         size_t nlen;
1514
1515         PPCODE:
1516         INITMESSAGE(screen);
1517         rval = api_lline(screen, &last);
1518         offset = items > 1 ? (int)SvIV(ST(1)) : 0;
1519         if (offset < 0) offset += last;
1520         if (offset < 0) {
1521             ENDMESSAGE(screen);
1522             croak("Invalid offset");
1523         }
1524         length = items > 2 ? (int)SvIV(ST(2)) : last - offset;
1525         if (length > last - offset)
1526                 length = last - offset;
1527         db_offset = offset + 1; /* 1 based */
1528         EXTEND(sp,length);
1529         for (common = MIN(length, items - 3), i = 3; common > 0;
1530             --common, ++db_offset, --length, ++i) {
1531                 rval |= api_gline(screen, db_offset, &line, &len);
1532                 INT2CHAR(screen, line, len, np, nlen);
1533                 PUSHs(sv_2mortal(newSVpv(nlen ? np : "", nlen)));
1534                 np = SvPV(ST(i), nlen);
1535                 CHAR2INTP(screen, np, nlen, line, len);
1536                 rval |= api_sline(screen, db_offset, line, len);
1537         }
1538         for (; length; --length) {
1539                 rval |= api_gline(screen, db_offset, &line, &len);
1540                 INT2CHAR(screen, line, len, np, nlen);
1541                 PUSHs(sv_2mortal(newSVpv(len ? np : "", nlen)));
1542                 rval |= api_dline(screen, db_offset);
1543         }
1544         for (; i < items; ++i) {
1545                 np = SvPV(ST(i), len);
1546                 CHAR2INTP(screen, np, len, line, nlen);
1547                 rval |= api_iline(screen, db_offset, line, nlen);
1548         }
1549         ENDMESSAGE(screen);
1550
1551 MODULE = VI     PACKAGE = VI::TAGQ
1552
1553 void
1554 Add(tagq, filename, search, msg)
1555         VI::TAGQ    tagq;
1556         char       *filename;
1557         char       *search;
1558         char       *msg;
1559
1560         PREINIT:
1561         SCR *sp;
1562
1563         CODE:
1564         sp = (SCR *)SvIV((SV*)SvRV(tagq->sprv));
1565         if (!sp)
1566                 croak("screen no longer exists");
1567         api_tagq_add(sp, tagq->tqp, filename, search, msg);
1568
1569 void
1570 Push(tagq)
1571         VI::TAGQ    tagq;
1572
1573         PREINIT:
1574         SCR *sp;
1575
1576         CODE:
1577         sp = (SCR *)SvIV((SV*)SvRV(tagq->sprv));
1578         if (!sp)
1579                 croak("screen no longer exists");
1580         api_tagq_push(sp, &tagq->tqp);
1581
1582 void
1583 DESTROY(tagq)
1584         # Can already be invalidated by push
1585         VI::TAGQ2    tagq;
1586
1587         PREINIT:
1588         SCR *sp;
1589
1590         CODE:
1591         sp = (SCR *)SvIV((SV*)SvRV(tagq->sprv));
1592         if (sp)
1593                 api_tagq_free(sp, tagq->tqp);
1594         SvREFCNT_dec(tagq->sprv);
1595         free(tagq);