开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 编辑器/阅读器 > 查看源码
if_perl.xs
资源名称：vim53src.zip　[点击查看]
上传用户：gddssl
上传日期：2007-01-06
资源大小：1003k
文件大小：15k
源码类别：

编辑器/阅读器

开发平台：

DOS

if_perl.xs：源码内容
  1. /* vi:set ts=8 sts=4 sw=4:
  2.  *
  3.  * VIM - Vi IMproved by Bram Moolenaar
  4.  *
  5.  * Do ":help uganda"  in Vim to read copying and usage conditions.
  6.  * Do ":help credits" in Vim to see a list of people who contributed.
  7.  */
  8. /*
  9.  * if_perl.xs: Main code for Perl interface support.
  10.  * Mostly written by Sven Verdoolaege.
  11.  */
  13. #define _memory_h /* avoid memset redeclaration */
  14. #define IN_PERL_FILE /* don't include if_perl.pro from proto.h */
  16. #include "vim.h"
  18. /*
  19.  * Avoid clashes between Perl and Vim namespace.
  20.  */
  21. #undef MAGIC
  22. #undef NORMAL
  23. #undef STRLEN
  24. #undef FF
  25. #undef OP_DELETE
  26. #ifdef __BORLANDC__
  27. #define NOPROTO 1
  28. #endif
  29. #include <EXTERN.h>
  30. #include <perl.h>
  31. #include <XSUB.h>
  33. /*
  34.  * Work around clashes between Perl and Vim namespace. proto.h doesn't
  35.  * include if_perl.pro and perlsfio.pro when IN_PERL_FILE is defined, because
  36.  * we need the CV typedef.  proto.h can't be moved to after including
  37.  * if_perl.h, because we get all sorts of name clashes then.
  38.  */
  39. #ifndef PROTO
  40. # include "proto/if_perl.pro"
  41. # include "proto/if_perlsfio.pro"
  42. #endif
  44. static void *perl_interp = NULL;
  45. static void xs_init __ARGS((void));
  46. static void VIM_init __ARGS((void));
  48. /*
  49.  * perl_init(): initialize perl interpreter
  50.  * We have to call perl_parse to initialize some structures,
  51.  * there's nothing to actually parse.
  52.  */
  53.     static void
  54. perl_init()
  55. {
  56.     char *bootargs[] = { "VI", NULL };
  57.     static char *args[] = { "", "-e", "" };
  59.     perl_interp = perl_alloc();
  60.     perl_construct(perl_interp);
  61.     perl_parse(perl_interp, xs_init, 3, args, 0);
  62.     perl_call_argv("VIM::bootstrap", (long)G_DISCARD, bootargs);
  63.     VIM_init();
  64. #ifdef USE_SFIO
  65.     sfdisc(PerlIO_stdout(), sfdcnewvim());
  66.     sfdisc(PerlIO_stderr(), sfdcnewvim());
  67.     sfsetbuf(PerlIO_stdout(), NULL, 0);
  68.     sfsetbuf(PerlIO_stderr(), NULL, 0);
  69. #endif
  70. }
  72. /*
  73.  * perl_end(): clean up after ourselves
  74.  */
  75.     void
  76. perl_end()
  77. {
  78.     if (perl_interp)
  79.     {
  80. perl_run(perl_interp);
  81. perl_destruct(perl_interp);
  82. perl_free(perl_interp);
  83.     }
  84. }
  86. /*
  87.  * msg_split(): send a message to the message handling routines
  88.  * split at 'n' first though.
  89.  */
  90.     void
  91. msg_split(s, attr)
  92.     char_u *s;
  93.     int attr; /* highlighting attributes */
  94. {
  95.     char *next;
  96.     char *token = (char *)s;
  98.     while ((next = strchr(token, 'n')))
  99.     {
  100. *next++ = ''; /* replace n with  */
  101. msg_attr((char_u *)token, attr);
  102. token = next;
  103.     }
  104.     if (*token)
  105. msg_attr((char_u *)token, attr);
  106. }
  108. #ifndef WANT_EVAL
  109. /*
  110.  * This stub is needed because an "#ifdef WANT_EVAL" around Eval() doesn't work properly.
  111.  */
  112.     char_u *
  113. eval_to_string(arg, nextcmd)
  114.     char_u *arg;
  115.     char_u **nextcmd;
  116. {
  117.     return NULL;
  118. }
  119. #endif
  121. /*
  122.  * Create a new reference to an SV pointing to the SCR structure
  123.  * The perl_private part of the SCR structure points to the SV,
  124.  * so there can only be one such SV for a particular SCR structure.
  125.  * When the last reference has gone (DESTROY is called),
  126.  * perl_private is reset; When the screen goes away before
  127.  * all references are gone, the value of the SV is reset;
  128.  * any subsequent use of any of those reference will produce
  129.  * a warning. (see typemap)
  130.  */
  131. #define newANYrv(TYPE)
  132. static SV *
  133. new ## TYPE ## rv(rv, ptr)
  134.     SV *rv;
  135.     TYPE *ptr;
  136. {
  137.     sv_upgrade(rv, SVt_RV);
  138.     if (!ptr->perl_private)
  139.     {
  140. ptr->perl_private = newSV(0);
  141. sv_setiv(ptr->perl_private, (IV)ptr);
  142.     }
  143.     else
  144. SvREFCNT_inc(ptr->perl_private);
  145.     SvRV(rv) = ptr->perl_private;
  146.     SvROK_on(rv);
  147.     return sv_bless(rv, gv_stashpv("VI" #TYPE, TRUE));
  148. }
  150. newANYrv(WIN)
  151. newANYrv(BUF)
  153. /*
  154.  * perl_win_free
  155.  * Remove all refences to the window to be destroyed
  156.  */
  157.     void
  158. perl_win_free(wp)
  159.     WIN *wp;
  160. {
  161.     if (wp->perl_private)
  162. sv_setiv((SV *)wp->perl_private, 0);
  163.     return;
  164. }
  166.     void
  167. perl_buf_free(bp)
  168.     BUF *bp;
  169. {
  170.     if (bp->perl_private)
  171. sv_setiv((SV *)bp->perl_private, 0);
  172.     return;
  173. }
  175. #ifndef PROTO
  176. I32 cur_val(IV iv, SV *sv);
  178. /*
  179.  * Handler for the magic variables $main::curwin and $main::curbuf.
  180.  * The handler is put into the magic vtbl for these variables.
  181.  * (This is effectively a C-level equivalent of a tied variable).
  182.  * There is no "set" function as the variables are read-only.
  183.  */
  184. I32 cur_val(IV iv, SV *sv)
  185. {
  186.     SV *rv;
  187.     if (iv == 0)
  188. rv = newWINrv(newSV(0), curwin);
  189.     else
  190. rv = newBUFrv(newSV(0), curbuf);
  191.     sv_setsv(sv, rv);
  192.     return 0;
  193. }
  194. #endif /* !PROTO */
  196. struct ufuncs cw_funcs = { cur_val, 0, 0 };
  197. struct ufuncs cb_funcs = { cur_val, 0, 1 };
  199. /*
  200.  * VIM_init(): Vim-specific initialisation.
  201.  * Make the magical main::curwin and main::curbuf variables
  202.  */
  203.     static void
  204. VIM_init()
  205. {
  206.     static char cw[] = "main::curwin";
  207.     static char cb[] = "main::curbuf";
  208.     MAGIC *m;
  209.     SV *sv;
  211.     sv = perl_get_sv(cw, TRUE);
  212.     sv_magic(sv, NULL, 'U', cw, strlen(cw));
  213.     m = mg_find(sv, 'U');
  214.     m->mg_ptr = (char *)&cw_funcs;
  215.     SvREADONLY_on(sv);
  217.     sv = perl_get_sv(cb, TRUE);
  218.     sv_magic(sv, NULL, 'U', cb, strlen(cb));
  219.     m = mg_find(sv, 'U');
  220.     m->mg_ptr = (char *)&cb_funcs;
  221.     SvREADONLY_on(sv);
  222. }
  224.     int
  225. do_perl(eap)
  226.     EXARG *eap;
  227. {
  228.     char *err;
  229.     STRLEN length;
  230.     SV *sv;
  231.     dSP;
  233.     if (!perl_interp)
  234.     {
  235. perl_init();
  236. SPAGAIN;
  237.     }
  239.     ENTER;
  240.     SAVETMPS;
  242.     sv = newSVpv((char *)eap->arg, 0);
  243.     perl_eval_sv(sv, G_DISCARD | G_NOARGS);
  244.     SvREFCNT_dec(sv);
  246.     err = SvPV(GvSV(errgv), length);
  248.     FREETMPS;
  249.     LEAVE;
  251.     if (!length)
  252. return OK;
  254.     msg_split((char_u *)err, highlight_attr[HLF_E]);
  255.     return FAIL;
  256.     
  257. }
  259.     static int
  260. replace_line(line, end)
  261.     linenr_t *line, *end;
  262. {
  263.     char *str;
  265.     if (SvOK(GvSV(defgv)))
  266.     {
  267. str = SvPV(GvSV(defgv), na);
  268. ml_replace(*line, (char_u *)str, 1);
  269. #ifdef SYNTAX_HL
  270. syn_changed(*line); /* recompute syntax hl. for this line */
  271. #endif
  272.     }
  273.     else
  274.     {
  275. mark_adjust(*line, *line, MAXLNUM, -1);
  276. ml_delete((*line)--, FALSE);
  277. (*end)--;
  278.     }
  279.     changed();
  280.     return OK;
  281. }
  283.     int
  284. do_perldo(eap)
  285.     EXARG *eap;
  286. {
  287.     STRLEN length;
  288.     SV *sv;
  289.     char *str;
  290.     linenr_t i;
  291.     dSP;
  293.     if (bufempty())
  294. return FAIL;
  296.     if (!perl_interp)
  297.     {
  298. perl_init();
  299. SPAGAIN;
  300.     }
  301.     length = strlen((char *)eap->arg);
  302.     sv = newSV(length + sizeof("sub VIM::perldo {")-1 + 1);
  303.     sv_setpvn(sv, "sub VIM::perldo {", sizeof("sub VIM::perldo {")-1);
  304.     sv_catpvn(sv, (char *)eap->arg, length);
  305.     sv_catpvn(sv, "}", 1);
  306.     perl_eval_sv(sv, G_DISCARD | G_NOARGS);
  307.     SvREFCNT_dec(sv);
  308.     str = SvPV(GvSV(errgv), length);
  309.     if (length)
  310. goto err;
  312.     if (u_save(eap->line1 - 1, eap->line2 + 1) != OK)
  313. return FAIL;
  315.     ENTER;
  316.     SAVETMPS;
  317.     for (i = eap->line1; i <= eap->line2; i++)
  318.     {
  319. sv_setpv(GvSV(defgv),(char *)ml_get(i));
  320. PUSHMARK(sp);
  321. perl_call_pv("VIM::perldo", G_SCALAR | G_EVAL);
  322. str = SvPV(GvSV(errgv), length);
  323. if (length)
  324.     break;
  325. SPAGAIN;
  326. if (SvTRUEx(POPs))
  327. {
  328.     if (replace_line(&i, &eap->line2) != OK)
  329.     {
  330. PUTBACK;
  331. break;
  332.     }
  333. }
  334. PUTBACK;
  335.     }
  336.     FREETMPS;
  337.     LEAVE;
  338.     adjust_cursor();
  339.     update_screen(NOT_VALID);
  340.     if (!length)
  341. return OK;
  343. err:
  344.     msg_split((char_u *)str, highlight_attr[HLF_E]);
  345.     return FAIL;
  346. }
  348. /* Register any extra external extensions */
  349. extern void 
  350. #ifdef __BORLANDC__
  351. __import
  352. #endif
  353. boot_DynaLoader _((CV* cv));
  354. extern void boot_VIM _((CV* cv));
  356.     static void
  357. xs_init()
  358. {
  359. #if 0
  360.     dXSUB_SYS;     /* causes an error with Perl 5.003_97 */
  361. #endif
  362.     char *file = __FILE__;
  364.     newXS("DynaLoader::boot_DynaLoader", boot_DynaLoader, file);
  365.     newXS("VIM::bootstrap", boot_VIM, file);
  366. }
  368. typedef WIN * VIWIN;
  369. typedef BUF * VIBUF;
  371. MODULE = VIM     PACKAGE = VIM
  373. void
  374. Msg(text, hl=NULL)
  375.     char *text;
  376.     char *hl;
  378.     PREINIT:
  379.     int attr;
  380.     int id;
  382.     PPCODE:
  383.     if (text != NULL)
  384.     {
  385. attr = 0;
  386. if (hl != NULL)
  387. {
  388.     id = syn_name2id((char_u *)hl);
  389.     if (id != 0)
  390. attr = syn_id2attr(id);
  391. }
  392. msg_split((char_u *)text, attr);
  393.     }
  395. void
  396. SetOption(line)
  397.     char *line;
  399.     PPCODE:
  400.     if (line != NULL)
  401. do_set((char_u *)line);
  402.     update_screen(NOT_VALID);
  404. void
  405. DoCommand(line)
  406.     char *line;
  408.     PPCODE:
  409.     if (line != NULL)
  410. do_cmdline((char_u *)line, NULL, NULL, DOCMD_VERBOSE + DOCMD_NOWAIT);
  412. void
  413. Eval(str)
  414.     char *str;
  416.     PREINIT:
  417. char_u *value;
  418.     PPCODE:
  419. value = eval_to_string((char_u *)str, (char_u**)0);
  420. if (value == NULL)
  421. {
  422.     XPUSHs(sv_2mortal(newSViv(0)));
  423.     XPUSHs(sv_2mortal(newSVpv("", 0)));
  424. }
  425. else
  426. {
  427.     XPUSHs(sv_2mortal(newSViv(1)));
  428.     XPUSHs(sv_2mortal(newSVpv((char *)value, 0)));
  429.     vim_free(value);
  430. }
  432. void
  433. Buffers(...)
  435.     PREINIT:
  436.     BUF *vimbuf;
  437.     int i, b;
  439.     PPCODE:
  440.     if (items == 0)
  441.     {
  442. if (GIMME == G_SCALAR)
  443. {
  444.     i = 0;
  445.     for (vimbuf = firstbuf; vimbuf; vimbuf = vimbuf->b_next)
  446. ++i;
  448.     XPUSHs(sv_2mortal(newSViv(i)));
  449. }
  450. else
  451. {
  452.     for (vimbuf = firstbuf; vimbuf; vimbuf = vimbuf->b_next)
  453. XPUSHs(newBUFrv(newSV(0), vimbuf));
  454. }
  455.     }
  456.     else
  457.     {
  458. for (i = 0; i < items; i++)
  459. {
  460.     SV *sv = ST(i);
  461.     if (SvIOK(sv))
  462. b = SvIV(ST(i));
  463.     else
  464.     {
  465. char_u *pat;
  466. int len;
  467. pat = (char_u *)SvPV(sv, len);
  468. ++emsg_off;
  469. b = buflist_findpat(pat, pat+len);
  470. --emsg_off;
  471.     }
  473.     if (b >= 0)
  474.     {
  475. vimbuf = buflist_findnr(b);
  476. if (vimbuf)
  477.     XPUSHs(newBUFrv(newSV(0), vimbuf));
  478.     }
  479. }
  480.     }
  482. void
  483. Windows(...)
  485.     PREINIT:
  486.     WIN *vimwin;
  487.     int i, w;
  489.     PPCODE:
  490.     if (items == 0)
  491.     {
  492. if (GIMME == G_SCALAR)
  493.     XPUSHs(sv_2mortal(newSViv(win_count())));
  494. else
  495. {
  496.     for (vimwin = firstwin; vimwin != NULL; vimwin = vimwin->w_next)
  497. XPUSHs(newWINrv(newSV(0), vimwin));
  498. }
  499.     }
  500.     else
  501.     {
  502. for (i = 0; i < items; i++)
  503. {
  504.     w = SvIV(ST(i));
  505.     vimwin = win_goto_nr(w);
  506.     if (vimwin)
  507. XPUSHs(newWINrv(newSV(0), vimwin));
  508. }
  509.     }
  511. MODULE = VIM     PACKAGE = VIWIN
  513. void
  514. DESTROY(win)
  515.     VIWIN win
  517.     CODE:
  518.     if (win_valid(win))
  519. win->perl_private = 0;
  521. SV *
  522. Buffer(win)
  523.     VIWIN win
  525.     CODE:
  526.     if (!win_valid(win))
  527. win = curwin;
  528.     RETVAL = newBUFrv(newSV(0), win->w_buffer);
  529.     OUTPUT:
  530.     RETVAL
  532. void
  533. SetHeight(win, height)
  534.     VIWIN win
  535.     int height;
  537.     PREINIT:
  538.     WIN *savewin;
  540.     PPCODE:
  541.     if (!win_valid(win))
  542. win = curwin;
  543.     savewin = curwin;
  544.     curwin = win;
  545.     win_setheight(height);
  546.     curwin = savewin;
  548. void
  549. Cursor(win, ...)
  550.     VIWIN win
  552.     PPCODE:
  553.     if(items == 1)
  554.     {
  555.       EXTEND(sp, 2);
  556.       if (!win_valid(win))
  557.   win = curwin;
  558.       PUSHs(sv_2mortal(newSViv(win->w_cursor.lnum)));
  559.       PUSHs(sv_2mortal(newSViv(win->w_cursor.col)));
  560.     }
  561.     else if(items == 3)
  562.     {
  563.       int lnum, col;
  565.       if (!win_valid(win))
  566.   win = curwin;
  567.       lnum = SvIV(ST(1));
  568.       col = SvIV(ST(2));
  569.       win->w_cursor.lnum = lnum;
  570.       win->w_cursor.col = col;
  571.       adjust_cursor();     /* put cursor on an existing line */
  572.       update_screen(NOT_VALID);
  573.     }
  575. MODULE = VIM     PACKAGE = VIBUF
  577. void
  578. DESTROY(vimbuf)
  579.     VIBUF vimbuf;
  581.     CODE:
  582.     if (buf_valid(vimbuf))
  583. vimbuf->perl_private = 0;
  585. void
  586. Name(vimbuf)
  587.     VIBUF vimbuf;
  589.     PPCODE:
  590.     if (!buf_valid(vimbuf))
  591. vimbuf = curbuf;
  592.     /* No file name returns an empty string */
  593.     if (vimbuf->b_fname == NULL)
  594. XPUSHs(sv_2mortal(newSVpv("", 0)));
  595.     else
  596. XPUSHs(sv_2mortal(newSVpv((char *)vimbuf->b_fname, 0)));
  598. void
  599. Number(vimbuf)
  600.     VIBUF vimbuf;
  602.     PPCODE:
  603.     if (!buf_valid(vimbuf))
  604. vimbuf = curbuf;
  605.     XPUSHs(sv_2mortal(newSViv(vimbuf->b_fnum)));
  607. void
  608. Count(vimbuf)
  609.     VIBUF vimbuf;
  611.     PPCODE:
  612.     if (!buf_valid(vimbuf))
  613. vimbuf = curbuf;
  614.     XPUSHs(sv_2mortal(newSViv(vimbuf->b_ml.ml_line_count)));
  616. void
  617. Get(vimbuf, ...)
  618.     VIBUF vimbuf;
  620.     PREINIT:
  621.     char_u *line;
  622.     int i;
  623.     long lnum;
  624.     PPCODE:
  625.     if (buf_valid(vimbuf))
  626.     {
  627. for (i = 1; i < items; i++)
  628. {
  629.     lnum = SvIV(ST(i));
  630.     if (lnum > 0 && lnum <= vimbuf->b_ml.ml_line_count)
  631.     {
  632. line = ml_get_buf(vimbuf, lnum, FALSE);
  633. XPUSHs(sv_2mortal(newSVpv((char *)line, 0)));
  634.     }
  635. }
  636.     }
  638. void
  639. Set(vimbuf, ...)
  640.     VIBUF vimbuf;
  642.     PREINIT:
  643.     int i;
  644.     long lnum;
  645.     char *line;
  646.     BUF *savebuf;
  647.     PPCODE:
  648.     if (buf_valid(vimbuf))
  649.     {
  650. if (items < 3)
  651.     croak("Usage: VIBUF::Set(vimbuf, lnum, @lines)");
  653. lnum = SvIV(ST(1));
  654. for(i=2; i<items; i++, lnum++)
  655. {
  656.     line = SvPV(ST(i),na);
  657.     if(lnum > 0 && lnum <= vimbuf->b_ml.ml_line_count && line != NULL)
  658.     {
  659. savebuf = curbuf;
  660. curbuf = vimbuf;
  661. if (u_savesub(lnum) == OK)
  662. {
  663.     ml_replace(lnum, (char_u *)line, TRUE);
  664.     changed();
  665. #ifdef SYNTAX_HL
  666.     syn_changed(lnum); /* recompute syntax hl. for this line */
  667. #endif
  668. }
  669. curbuf = savebuf;
  670. update_curbuf(NOT_VALID);
  671.     }
  672. }
  673.     }
  675. void
  676. Delete(vimbuf, ...)
  677.     VIBUF vimbuf;
  679.     PREINIT:
  680.     long i, lnum = 0, count = 0;
  681.     BUF *savebuf;
  682.     PPCODE:
  683.     if (buf_valid(vimbuf))
  684.     {
  685. if (items == 2)
  686. {
  687.     lnum = SvIV(ST(1));
  688.     count = 1;
  689. }
  690. else if (items == 3)
  691. {
  692.     lnum = SvIV(ST(1));
  693.     count = 1 + SvIV(ST(2)) - lnum;
  694.     if(count == 0)
  695. count = 1;
  696.     if(count < 0)
  697.     {
  698. lnum -= count;
  699. count = -count;
  700.     }
  701. }
  702. if (items >= 2)
  703. {
  704.     for (i=0; i<count; i++)
  705.     {
  706. if (lnum > 0 && lnum <= vimbuf->b_ml.ml_line_count)
  707. {
  708.     savebuf = curbuf;
  709.     curbuf = vimbuf;
  710.     if (u_savedel(lnum, 1) == OK)
  711.     {
  712. mark_adjust(lnum, lnum, MAXLNUM, -1);
  713. ml_delete(lnum, 0);
  714. changed();
  715.     }
  716.     curbuf = savebuf;
  717.     update_curbuf(NOT_VALID);
  718. }
  719.     }
  720. }
  721.     }
  723. void
  724. Append(vimbuf, ...)
  725.     VIBUF vimbuf;
  727.     PREINIT:
  728.     int i;
  729.     long lnum;
  730.     char *line;
  731.     BUF *savebuf;
  732.     PPCODE:
  733.     if (buf_valid(vimbuf))
  734.     {
  735. if (items < 3)
  736.     croak("Usage: VIBUF::Append(vimbuf, lnum, @lines)");
  738. lnum = SvIV(ST(1));
  739. for(i=2; i<items; i++, lnum++)
  740. {
  741.     line = SvPV(ST(i),na);
  742.     if(lnum >= 0 && lnum <= vimbuf->b_ml.ml_line_count && line != NULL)
  743.     {
  744. savebuf = curbuf;
  745. curbuf = vimbuf;
  746. if (u_inssub(lnum + 1) == OK)
  747. {
  748.     mark_adjust(lnum + 1, MAXLNUM, 1L, 0L);
  749.     ml_append(lnum, (char_u *)line, (colnr_t)0, FALSE);
  750.     changed();
  751. }
  752. curbuf = savebuf;
  753. update_curbuf(NOT_VALID);
  754.     }
  755. }
  756.     }