src/rxvtperl.xs

   1 /*----------------------------------------------------------------------*
   2  * File:        rxvtperl.xs
   3  *----------------------------------------------------------------------*
   4  *
   5  * All portions of code are copyright by their respective author/s.
   6  * Copyright (c) 2005-2005 Marc Lehmann <pcg@goof.com>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21  *----------------------------------------------------------------------*/
  22
  23 #define line_t perl_line_t
  24 #include <EXTERN.h>
  25 #include <perl.h>
  26 #include <XSUB.h>
  27 #undef line_t
  28
  29 #include "../config.h"
  30
  31 #include <cstdarg>
  32
  33 #include "rxvt.h"
  34 #include "iom.h"
  35 #include "rxvtutil.h"
  36 #include "rxvtperl.h"
  37
  38 #include "perlxsi.c"
  39
  40 #undef LINENO
  41 #define LINENO(n) MOD (THIS->term_start + int(n), THIS->total_rows)
  42 #undef ROW
  43 #define ROW(n) THIS->row_buf [LINENO (n)]
  44
  45 /////////////////////////////////////////////////////////////////////////////
  46
  47 static wchar_t *
  48 sv2wcs (SV *sv)
  49 {
  50   STRLEN len;
  51   char *str = SvPVutf8 (sv, len);
  52   return rxvt_utf8towcs (str, len);
  53 }
  54
  55 static SV *
  56 new_ref (HV *hv, const char *klass)
  57 {
  58   return sv_bless (newRV ((SV *)hv), gv_stashpv (klass, 1));
  59 }
  60
  61 //TODO: use magic
  62 static SV *
  63 newSVptr (void *ptr, const char *klass)
  64 {
  65   HV *hv = newHV ();
  66   sv_magic ((SV *)hv, 0, PERL_MAGIC_ext, (char *)ptr, 0);
  67   return sv_bless (newRV_noinc ((SV *)hv), gv_stashpv (klass, 1));
  68 }
  69
  70 static void
  71 clearSVptr (SV *sv)
  72 {
  73   if (SvROK (sv))
  74     sv = SvRV (sv);
  75
  76   hv_clear ((HV *)sv);
  77   sv_unmagic (sv, PERL_MAGIC_ext);
  78 }
  79
  80 static long
  81 SvPTR (SV *sv, const char *klass)
  82 {
  83   if (!sv_derived_from (sv, klass))
  84     croak ("object of type %s expected", klass);
  85
  86   MAGIC *mg = mg_find (SvRV (sv), PERL_MAGIC_ext);
  87
  88   if (!mg)
  89     croak ("perl code used %s object, but C++ object is already destroyed, caught", klass);
  90
  91   return (long)mg->mg_ptr;
  92 }
  93
  94 #define newSVterm(term) SvREFCNT_inc ((SV *)term->self)
  95 #define SvTERM(sv) (rxvt_term *)SvPTR (sv, "urxvt::term")
  96
  97 /////////////////////////////////////////////////////////////////////////////
  98
  99 struct perl_watcher
 100 {
 101   SV *cbsv;
 102   HV *self;
 103
 104   perl_watcher ()
 105   : cbsv (newSV (0))
 106   {
 107   }
 108
 109   ~perl_watcher ()
 110   {
 111     SvREFCNT_dec (cbsv);
 112   }
 113
 114   void cb (SV *cb)
 115   {
 116     sv_setsv (cbsv, cb);
 117   }
 118
 119   void invoke (const char *type, SV *self, int arg = -1);
 120 };
 121
 122 void
 123 perl_watcher::invoke (const char *type, SV *self, int arg)
 124 {
 125   dSP;
 126
 127   ENTER;
 128   SAVETMPS;
 129
 130   PUSHMARK (SP);
 131
 132   XPUSHs (sv_2mortal (self));
 133
 134   if (arg >= 0)
 135     XPUSHs (sv_2mortal (newSViv (arg)));
 136
 137   PUTBACK;
 138   call_sv (cbsv, G_VOID | G_EVAL | G_DISCARD);
 139   SPAGAIN;
 140
 141   PUTBACK;
 142   FREETMPS;
 143   LEAVE;
 144
 145   if (SvTRUE (ERRSV))
 146     rxvt_warn ("%s callback evaluation error: %s", type, SvPV_nolen (ERRSV));
 147 }
 148
 149 #define newSVtimer(timer) new_ref (timer->self, "urxvt::timer")
 150 #define SvTIMER(sv) (timer *)SvPTR (sv, "urxvt::timer")
 151
 152 struct timer : time_watcher, perl_watcher
 153 {
 154   tstamp interval;
 155
 156   timer ()
 157   : time_watcher (this, &timer::execute)
 158   {
 159   }
 160
 161   void execute (time_watcher &w)
 162   {
 163     if (interval)
 164       start (at + interval);
 165
 166     invoke ("urxvt::timer", newSVtimer (this));
 167   }
 168 };
 169
 170 #define newSViow(iow) new_ref (iow->self, "urxvt::iow")
 171 #define SvIOW(sv) (iow *)SvPTR (sv, "urxvt::iow")
 172
 173 struct iow : io_watcher, perl_watcher
 174 {
 175   iow ()
 176   : io_watcher (this, &iow::execute)
 177   {
 178   }
 179
 180   void execute (io_watcher &w, short revents)
 181   {
 182     invoke ("urxvt::iow", newSViow (this), revents);
 183   }
 184 };
 185
 186 /////////////////////////////////////////////////////////////////////////////
 187
 188 #define SvOVERLAY(sv) (overlay *)SvPTR (sv, "urxvt::overlay")
 189
 190 struct overlay {
 191   HV *self;
 192   rxvt_term *THIS;
 193   int x, y, w, h;
 194   int border;
 195   text_t **text;
 196   rend_t **rend;
 197
 198   overlay (rxvt_term *THIS, int x_, int y_, int w_, int h_, rend_t rstyle, int border);
 199   ~overlay ();
 200
 201   void show ();
 202   void hide ();
 203
 204   void swap ();
 205
 206   void set (int x, int y, SV *str, SV *rend);
 207 };
 208
 209 overlay::overlay (rxvt_term *THIS, int x_, int y_, int w_, int h_, rend_t rstyle, int border)
 210 : THIS(THIS), x(x_), y(y_), w(w_), h(h_), border(border == 2)
 211 {
 212   if (border == 2)
 213     {
 214       w += 2;
 215       h += 2;
 216     }
 217
 218   text = new text_t *[h];
 219   rend = new rend_t *[h];
 220
 221   for (int y = 0; y < h; y++)
 222     {
 223       text_t *tp = text[y] = new text_t[w];
 224       rend_t *rp = rend[y] = new rend_t[w];
 225
 226       text_t t0, t1, t2;
 227       rend_t r = rstyle;
 228
 229       if (border == 2)
 230         {
 231           if (y == 0)
 232             t0 = 0x2554, t1 = 0x2550, t2 = 0x2557;
 233           else if (y < h - 1)
 234             t0 = 0x2551, t1 = 0x0020, t2 = 0x2551;
 235           else
 236             t0 = 0x255a, t1 = 0x2550, t2 = 0x255d;
 237
 238           *tp++ = t0;
 239           *rp++ = r;
 240
 241           for (int x = w - 2; x-- > 0; )
 242             {
 243               *tp++ = t1;
 244               *rp++ = r;
 245             }
 246
 247           *tp = t2;
 248           *rp = r;
 249         }
 250       else
 251         for (int x = w; x-- > 0; )
 252           {
 253             *tp++ = 0x0020;
 254             *rp++ = r;
 255           }
 256     }
 257
 258   show ();
 259   THIS->want_refresh = 1;
 260 }
 261
 262 overlay::~overlay ()
 263 {
 264   hide ();
 265
 266   for (int y = h; y--; )
 267     {
 268       delete [] text[y];
 269       delete [] rend[y];
 270     }
 271
 272   delete [] text;
 273   delete [] rend;
 274
 275   THIS->want_refresh = 1;
 276 }
 277
 278 void
 279 overlay::show ()
 280 {
 281   char key[33]; sprintf (key, "%32lx", (long)this);
 282
 283   HV *hv = (HV *)SvRV (*hv_fetch ((HV *)SvRV ((SV *)THIS->self), "_overlay", 8, 0));
 284   hv_store (hv, key, 32, newSViv ((long)this), 0);
 285 }
 286
 287 void
 288 overlay::hide ()
 289 {
 290   SV **ovs = hv_fetch ((HV *)SvRV ((SV *)THIS->self), "_overlay", 8, 0);
 291
 292   if (ovs)
 293     {
 294       char key[33]; sprintf (key, "%32lx", (long)this);
 295
 296       HV *hv = (HV *)SvRV (*ovs);
 297       hv_delete (hv, key, 32, G_DISCARD);
 298     }
 299 }
 300
 301 void overlay::swap ()
 302 {
 303   int ov_x = max (0, min (MOD (x, THIS->ncol), THIS->ncol - w));
 304   int ov_y = max (0, min (MOD (y, THIS->nrow), THIS->nrow - h));
 305
 306   int ov_w = min (w, THIS->ncol - ov_x);
 307   int ov_h = min (h, THIS->nrow - ov_y);
 308
 309   for (int y = ov_h; y--; )
 310     {
 311       text_t *t1 = text [y];
 312       rend_t *r1 = rend [y];
 313
 314       text_t *t2 = ROW(y + ov_y - THIS->view_start).t + ov_x;
 315       rend_t *r2 = ROW(y + ov_y - THIS->view_start).r + ov_x;
 316
 317       for (int x = ov_w; x--; )
 318         {
 319           text_t t = *t1; *t1++ = *t2; *t2++ = t;
 320           rend_t r = *r1; *r1++ = *r2; *r2++ = SET_FONT (r, THIS->fontset [GET_STYLE (r)]->find_font (t));
 321         }
 322     }
 323
 324 }
 325
 326 void overlay::set (int x, int y, SV *text, SV *rend)
 327 {
 328   x += border;
 329   y += border;
 330
 331   if (!IN_RANGE_EXC (y, 0, h - border))
 332     return;
 333
 334   wchar_t *wtext = sv2wcs (text);
 335
 336   for (int col = min (wcslen (wtext), w - x - border); col--; )
 337     this->text [y][x + col] = wtext [col];
 338
 339   free (wtext);
 340
 341   if (rend)
 342     {
 343       if (!SvROK (rend) || SvTYPE (SvRV (rend)) != SVt_PVAV)
 344         croak ("rend must be arrayref");
 345
 346       AV *av = (AV *)SvRV (rend);
 347
 348       for (int col = min (av_len (av) + 1, w - x - border); col--; )
 349         this->rend [y][x + col] = SvIV (*av_fetch (av, col, 1));
 350     }
 351
 352   THIS->want_refresh = 1;
 353 }
 354
 355
 356 /////////////////////////////////////////////////////////////////////////////
 357
 358 struct rxvt_perl_interp rxvt_perl;
 359
 360 static PerlInterpreter *perl;
 361
 362 rxvt_perl_interp::rxvt_perl_interp ()
 363 {
 364 }
 365
 366 rxvt_perl_interp::~rxvt_perl_interp ()
 367 {
 368   if (perl)
 369     {
 370       perl_destruct (perl);
 371       perl_free (perl);
 372     }
 373 }
 374
 375 void
 376 rxvt_perl_interp::init ()
 377 {
 378   if (!perl)
 379     {
 380       char *argv[] = {
 381         "",
 382         "-edo '" LIBDIR "/urxvt.pm' or ($@ and die $@) or exit 1",
 383       };
 384
 385       perl = perl_alloc ();
 386       perl_construct (perl);
 387
 388       if (perl_parse (perl, xs_init, 2, argv, (char **)NULL)
 389           || perl_run (perl))
 390         {
 391           rxvt_warn ("unable to initialize perl-interpreter, continuing without.\n");
 392
 393           perl_destruct (perl);
 394           perl_free (perl);
 395           perl = 0;
 396         }
 397     }
 398 }
 399
 400 bool
 401 rxvt_perl_interp::invoke (rxvt_term *term, hook_type htype, ...)
 402 {
 403   if (!perl)
 404     return false;
 405
 406   if (htype == HOOK_INIT) // first hook ever called
 407     {
 408       term->self = (void *)newSVptr ((void *)term, "urxvt::term");
 409       hv_store ((HV *)SvRV ((SV *)term->self), "_overlay", 8, newRV_noinc ((SV *)newHV ()), 0);
 410     }
 411   else if (!term->self)
 412     return false; // perl not initialized for this instance
 413   else if (htype == HOOK_DESTROY)
 414     {
 415       // handled later
 416     }
 417   else if (htype == HOOK_REFRESH_BEGIN || htype == HOOK_REFRESH_END)
 418     {
 419       HV *hv = (HV *)SvRV (*hv_fetch ((HV *)SvRV ((SV *)term->self), "_overlay", 8, 0));
 420
 421       if (HvKEYS (hv))
 422         {
 423           hv_iterinit (hv);
 424
 425           while (HE *he = hv_iternext (hv))
 426             ((overlay *)SvIV (hv_iterval (hv, he)))->swap ();
 427         }
 428     }
 429   else if (!should_invoke [htype])
 430     return false;
 431
 432   dSP;
 433   va_list ap;
 434
 435   va_start (ap, htype);
 436
 437   ENTER;
 438   SAVETMPS;
 439
 440   PUSHMARK (SP);
 441
 442   XPUSHs (sv_2mortal (newSVterm (term)));
 443   XPUSHs (sv_2mortal (newSViv (htype)));
 444
 445   for (;;) {
 446     data_type dt = (data_type)va_arg (ap, int);
 447
 448     switch (dt)
 449       {
 450         case DT_INT:
 451           XPUSHs (sv_2mortal (newSViv (va_arg (ap, int))));
 452           break;
 453
 454         case DT_LONG:
 455           XPUSHs (sv_2mortal (newSViv (va_arg (ap, long))));
 456           break;
 457
 458         case DT_STRING:
 459           XPUSHs (sv_2mortal (newSVpv (va_arg (ap, char *), 0)));
 460           break;
 461
 462         case DT_END:
 463           {
 464             va_end (ap);
 465
 466             PUTBACK;
 467             int count = call_pv ("urxvt::invoke", G_ARRAY | G_EVAL);
 468             SPAGAIN;
 469
 470             if (count)
 471               {
 472                 SV *status = POPs;
 473                 count = SvTRUE (status);
 474               }
 475
 476             PUTBACK;
 477             FREETMPS;
 478             LEAVE;
 479
 480             if (SvTRUE (ERRSV))
 481               rxvt_warn ("perl hook %d evaluation error: %s", htype, SvPV_nolen (ERRSV));
 482
 483             if (htype == HOOK_DESTROY)
 484               {
 485                 clearSVptr ((SV *)term->self);
 486                 SvREFCNT_dec ((SV *)term->self);
 487               }
 488
 489             return count;
 490           }
 491
 492         default:
 493           rxvt_fatal ("FATAL: unable to pass data type %d\n", dt);
 494       }
 495   }
 496 }
 497
 498 /////////////////////////////////////////////////////////////////////////////
 499
 500 MODULE = urxvt             PACKAGE = urxvt
 501
 502 PROTOTYPES: ENABLE
 503
 504 BOOT:
 505 {
 506 # define export_const(name) newCONSTSUB (gv_stashpv ("urxvt", 1), # name, newSViv (name));
 507   AV *hookname = get_av ("urxvt::HOOKNAME", 1);
 508 # define def(sym) av_store (hookname, HOOK_ ## sym, newSVpv (# sym, 0));
 509 # include "hookinc.h"
 510 # undef def
 511
 512   export_const (DEFAULT_RSTYLE);
 513   export_const (OVERLAY_RSTYLE);
 514   export_const (RS_Bold);
 515   export_const (RS_Italic);
 516   export_const (RS_Blink);
 517   export_const (RS_RVid);
 518   export_const (RS_Uline);
 519
 520   sv_setpv (get_sv ("urxvt::LIBDIR", 1), LIBDIR);
 521 }
 522
 523 void
 524 set_should_invoke (int htype, int value)
 525         CODE:
 526         rxvt_perl.should_invoke [htype] = value;
 527
 528 void
 529 warn (const char *msg)
 530         CODE:
 531         rxvt_warn ("%s", msg);
 532
 533 void
 534 fatal (const char *msg)
 535         CODE:
 536         rxvt_fatal ("%s", msg);
 537
 538 NV
 539 NOW ()
 540         CODE:
 541         RETVAL = NOW;
 542         OUTPUT:
 543         RETVAL
 544
 545 int
 546 GET_BASEFG (int rend)
 547         CODE:
 548         RETVAL = GET_BASEFG (rend);
 549         OUTPUT:
 550         RETVAL
 551
 552 int
 553 GET_BASEBG (int rend)
 554         CODE:
 555         RETVAL = GET_BASEBG (rend);
 556         OUTPUT:
 557         RETVAL
 558
 559 int
 560 SET_FGCOLOR (int rend, int new_color)
 561         CODE:
 562         RETVAL = SET_FGCOLOR (rend, new_color);
 563         OUTPUT:
 564         RETVAL
 565
 566 int
 567 SET_BGCOLOR (int rend, int new_color)
 568         CODE:
 569         RETVAL = SET_BGCOLOR (rend, new_color);
 570         OUTPUT:
 571         RETVAL
 572
 573 int
 574 GET_CUSTOM (int rend)
 575         CODE:
 576         RETVAL = (rend && RS_customMask) >> RS_customShift;
 577         OUTPUT:
 578         RETVAL
 579
 580 int
 581 SET_CUSTOM (int rend, int new_value)
 582         CODE:
 583 {
 584         if (!IN_RANGE_EXC (new_value, 0, RS_customCount))
 585           croak ("custom value out of range, must be 0..%d", RS_customCount - 1);
 586
 587         RETVAL = (rend & ~RS_customMask)
 588                | ((new_value << RS_customShift) & RS_customMask);
 589 }
 590         OUTPUT:
 591         RETVAL
 592
 593 MODULE = urxvt             PACKAGE = urxvt::term
 594
 595 int
 596 rxvt_term::strwidth (SV *str)
 597         CODE:
 598 {
 599         wchar_t *wstr = sv2wcs (str);
 600
 601         rxvt_push_locale (THIS->locale);
 602         RETVAL = wcswidth (wstr, wcslen (wstr));
 603         rxvt_pop_locale ();
 604
 605         free (wstr);
 606 }
 607         OUTPUT:
 608         RETVAL
 609
 610 SV *
 611 rxvt_term::locale_encode (SV *str)
 612         CODE:
 613 {
 614         wchar_t *wstr = sv2wcs (str);
 615
 616         rxvt_push_locale (THIS->locale);
 617         char *mbstr = rxvt_wcstombs (wstr);
 618         rxvt_pop_locale ();
 619
 620         free (wstr);
 621
 622         RETVAL = newSVpv (mbstr, 0);
 623         free (mbstr);
 624 }
 625         OUTPUT:
 626         RETVAL
 627
 628 SV *
 629 rxvt_term::locale_decode (SV *octets)
 630         CODE:
 631 {
 632         STRLEN len;
 633         char *data = SvPVbyte (octets, len);
 634
 635         rxvt_push_locale (THIS->locale);
 636         wchar_t *wstr = rxvt_mbstowcs (data, len);
 637         rxvt_pop_locale ();
 638
 639         char *str = rxvt_wcstoutf8 (wstr);
 640         free (wstr);
 641
 642         RETVAL = newSVpv (str, 0);
 643         SvUTF8_on (RETVAL);
 644         free (str);
 645 }
 646         OUTPUT:
 647         RETVAL
 648
 649 int
 650 rxvt_term::nsaved ()
 651         CODE:
 652         RETVAL = THIS->nsaved;
 653         OUTPUT:
 654         RETVAL
 655
 656 int
 657 rxvt_term::view_start (int newval = -1)
 658         CODE:
 659 {
 660         RETVAL = THIS->view_start;
 661
 662         if (newval >= 0)
 663           {
 664             THIS->view_start = min (newval, THIS->nsaved);
 665             THIS->scr_changeview (RETVAL);
 666           }
 667 }
 668         OUTPUT:
 669         RETVAL
 670
 671 int
 672 rxvt_term::nrow ()
 673         CODE:
 674         RETVAL = THIS->nrow;
 675         OUTPUT:
 676         RETVAL
 677
 678 int
 679 rxvt_term::ncol ()
 680         CODE:
 681         RETVAL = THIS->ncol;
 682         OUTPUT:
 683         RETVAL
 684
 685 void
 686 rxvt_term::want_refresh ()
 687         CODE:
 688         THIS->want_refresh = 1;
 689
 690 void
 691 rxvt_term::ROW_t (int row_number, SV *new_text = 0, int start_col = 0)
 692         PPCODE:
 693 {
 694         if (!IN_RANGE_EXC (row_number, -THIS->nsaved, THIS->nrow))
 695           XSRETURN_EMPTY;
 696
 697         line_t &l = ROW(row_number);
 698
 699         if (GIMME_V != G_VOID)
 700           {
 701             wchar_t *wstr = new wchar_t [THIS->ncol];
 702
 703             for (int col = 0; col <THIS->ncol; col++)
 704               wstr [col] = l.t [col];
 705
 706             char *str = rxvt_wcstoutf8 (wstr, THIS->ncol);
 707             free (wstr);
 708
 709             SV *sv = newSVpv (str, 0);
 710             SvUTF8_on (sv);
 711             XPUSHs (sv_2mortal (sv));
 712             free (str);
 713           }
 714
 715         if (new_text)
 716           {
 717             wchar_t *wstr = sv2wcs (new_text);
 718
 719             int len = wcslen (wstr);
 720
 721             if (!IN_RANGE_INC (start_col, 0, THIS->ncol - len))
 722               {
 723                 free (wstr);
 724                 croak ("new_text extends beyond horizontal margins");
 725               }
 726
 727             for (int col = start_col; col < start_col + len; col++)
 728               {
 729                 l.t [col] = wstr [col - start_col];
 730                 l.r [col] = SET_FONT (l.r [col], THIS->fontset [GET_STYLE (l.r [col])]->find_font (l.t [col]));
 731               }
 732
 733             free (wstr);
 734           }
 735 }
 736
 737 void
 738 rxvt_term::ROW_r (int row_number, SV *new_rend = 0, int start_col = 0)
 739         PPCODE:
 740 {
 741         if (!IN_RANGE_EXC (row_number, -THIS->nsaved, THIS->nrow))
 742           XSRETURN_EMPTY;
 743
 744         line_t &l = ROW(row_number);
 745
 746         if (GIMME_V != G_VOID)
 747           {
 748             AV *av = newAV ();
 749
 750             av_extend (av, THIS->ncol - 1);
 751             for (int col = 0; col < THIS->ncol; col++)
 752               av_store (av, col, newSViv (l.r [col]));
 753
 754             XPUSHs (sv_2mortal (newRV_noinc ((SV *)av)));
 755           }
 756
 757         if (new_rend)
 758           {
 759             if (!SvROK (new_rend) || SvTYPE (SvRV (new_rend)) != SVt_PVAV)
 760               croak ("new_rend must be arrayref");
 761
 762             AV *av = (AV *)SvRV (new_rend);
 763             int len = av_len (av) + 1;
 764
 765             if (!IN_RANGE_INC (start_col, 0, THIS->ncol - len))
 766               croak ("new_rend array extends beyond horizontal margins");
 767
 768             for (int col = start_col; col < start_col + len; col++)
 769               {
 770                 rend_t r = SvIV (*av_fetch (av, col - start_col, 1)) & ~RS_fontMask;
 771
 772                 l.r [col] = SET_FONT (r, THIS->fontset [GET_STYLE (r)]->find_font (l.t [col]));
 773               }
 774           }
 775 }
 776
 777 int
 778 rxvt_term::ROW_l (int row_number, int new_length = -2)
 779         CODE:
 780 {
 781         if (!IN_RANGE_EXC (row_number, -THIS->nsaved, THIS->nrow))
 782           XSRETURN_EMPTY;
 783
 784         line_t &l = ROW(row_number);
 785         RETVAL = l.l < 0 ? THIS->ncol : l.l;
 786
 787         if (new_length >= -1)
 788           l.l = new_length;
 789 }
 790         OUTPUT:
 791         RETVAL
 792
 793 bool
 794 rxvt_term::ROW_is_longer (int row_number)
 795         CODE:
 796 {
 797         if (!IN_RANGE_EXC (row_number, -THIS->nsaved, THIS->nrow))
 798           XSRETURN_EMPTY;
 799
 800         line_t &l = ROW(row_number);
 801         RETVAL = l.l < 0;
 802 }
 803         OUTPUT:
 804         RETVAL
 805
 806 SV *
 807 rxvt_term::special_encode (SV *str)
 808         CODE:
 809         abort ();//TODO
 810
 811 SV *
 812 rxvt_term::special_decode (SV *str)
 813         CODE:
 814         abort ();//TODO
 815
 816 void
 817 rxvt_term::_resource (char *name, int index, SV *newval = 0)
 818         PPCODE:
 819 {
 820         struct resval { const char *name; int value; } rslist [] = {
 821 #         define def(name) { # name, Rs_ ## name },
 822 #         define reserve(name,count)
 823 #         include "rsinc.h"
 824 #         undef def
 825 #         undef reserve
 826         };
 827
 828         struct resval *rs = rslist + sizeof (rslist) / sizeof (rslist [0]);
 829
 830         do {
 831           if (rs-- == rslist)
 832             croak ("no such resource '%s', requested", name);
 833         } while (strcmp (name, rs->name));
 834
 835         index += rs->value;
 836
 837         if (!IN_RANGE_EXC (index, 0, NUM_RESOURCES))
 838           croak ("requested out-of-bound resource %s+%d,", name, index - rs->value);
 839
 840         if (GIMME_V != G_VOID)
 841           XPUSHs (THIS->rs [index] ? sv_2mortal (newSVpv (THIS->rs [index], 0)) : &PL_sv_undef);
 842
 843         if (newval)
 844           {
 845             if (SvOK (newval))
 846               {
 847                 char *str = strdup (SvPVbyte_nolen (newval));
 848                 THIS->rs [index] = str;
 849                 THIS->allocated.push_back (str);
 850               }
 851             else
 852               THIS->rs [index] = 0;
 853           }
 854 }
 855
 856 void
 857 rxvt_term::selection_mark (...)
 858         PROTOTYPE: $;$$
 859         ALIAS:
 860            selection_beg = 1
 861            selection_end = 2
 862         PPCODE:
 863 {
 864         row_col_t &sel = ix == 1 ? THIS->selection.beg
 865                        : ix == 2 ? THIS->selection.end
 866                        :           THIS->selection.mark;
 867
 868         if (GIMME_V != G_VOID)
 869           {
 870             EXTEND (SP, 2);
 871             PUSHs (sv_2mortal (newSViv (sel.row)));
 872             PUSHs (sv_2mortal (newSViv (sel.col)));
 873           }
 874
 875         if (items == 3)
 876           {
 877             sel.row = clamp (SvIV (ST (1)), -THIS->nsaved, THIS->nrow - 1);
 878             sel.col = clamp (SvIV (ST (2)), 0, THIS->ncol - 1);
 879
 880             if (ix)
 881               THIS->want_refresh = 1;
 882           }
 883 }
 884
 885 int
 886 rxvt_term::selection_grab (int eventtime = CurrentTime)
 887
 888 void
 889 rxvt_term::selection (SV *newtext = 0)
 890         PPCODE:
 891 {
 892         if (GIMME_V != G_VOID)
 893           {
 894             char *sel = rxvt_wcstoutf8 (THIS->selection.text, THIS->selection.len);
 895             SV *sv = newSVpv (sel, 0);
 896             SvUTF8_on (sv);
 897             free (sel);
 898             XPUSHs (sv_2mortal (sv));
 899           }
 900
 901         if (newtext)
 902           {
 903             free (THIS->selection.text);
 904
 905             THIS->selection.text = sv2wcs (newtext);
 906             THIS->selection.len = wcslen (THIS->selection.text);
 907           }
 908 }
 909
 910 void
 911 rxvt_term::tt_write (SV *octets)
 912         INIT:
 913           STRLEN len;
 914           char *str = SvPVbyte (octets, len);
 915         C_ARGS:
 916           str, len
 917
 918 SV *
 919 rxvt_term::overlay (int x, int y, int w, int h, int rstyle = OVERLAY_RSTYLE, int border = 2)
 920         CODE:
 921 {
 922         overlay *o = new overlay (THIS, x, y, w, h, rstyle, border);
 923         RETVAL = newSVptr ((void *)o, "urxvt::overlay");
 924         o->self = (HV *)SvRV (RETVAL);
 925 }
 926         OUTPUT:
 927         RETVAL
 928
 929 MODULE = urxvt             PACKAGE = urxvt::overlay
 930
 931 void
 932 overlay::set (int x, int y, SV *text, SV *rend = 0)
 933
 934 void
 935 overlay::show ()
 936
 937 void
 938 overlay::hide ()
 939
 940 void
 941 overlay::DESTROY ()
 942
 943 MODULE = urxvt             PACKAGE = urxvt::timer
 944
 945 SV *
 946 timer::new ()
 947         CODE:
 948         timer *w =  new timer;
 949         w->start (NOW);
 950         RETVAL = newSVptr ((void *)w, "urxvt::timer");
 951         w->self = (HV *)SvRV (RETVAL);
 952         OUTPUT:
 953         RETVAL
 954
 955 timer *
 956 timer::cb (SV *cb)
 957         CODE:
 958         THIS->cb (cb);
 959         RETVAL = THIS;
 960         OUTPUT:
 961         RETVAL
 962
 963 NV
 964 timer::at ()
 965         CODE:
 966         RETVAL = THIS->at;
 967         OUTPUT:
 968         RETVAL
 969
 970 timer *
 971 timer::interval (NV interval)
 972         CODE:
 973         THIS->interval = interval;
 974         RETVAL = THIS;
 975         OUTPUT:
 976         RETVAL
 977
 978 timer *
 979 timer::set (NV tstamp)
 980         CODE:
 981         THIS->set (tstamp);
 982         RETVAL = THIS;
 983         OUTPUT:
 984         RETVAL
 985
 986 timer *
 987 timer::start (NV tstamp = THIS->at)
 988         CODE:
 989         THIS->start (tstamp);
 990         RETVAL = THIS;
 991         OUTPUT:
 992         RETVAL
 993
 994 timer *
 995 timer::stop ()
 996         CODE:
 997         THIS->stop ();
 998         RETVAL = THIS;
 999         OUTPUT:
1000         RETVAL
1001
1002 void
1003 timer::DESTROY ()
1004
1005 MODULE = urxvt             PACKAGE = urxvt::iow
1006
1007 SV *
1008 iow::new ()
1009         CODE:
1010         iow *w =  new iow;
1011         RETVAL = newSVptr ((void *)w, "urxvt::iow");
1012         w->self = (HV *)SvRV (RETVAL);
1013         OUTPUT:
1014         RETVAL
1015
1016 iow *
1017 iow::cb (SV *cb)
1018         CODE:
1019         THIS->cb (cb);
1020         RETVAL = THIS;
1021         OUTPUT:
1022         RETVAL
1023
1024 iow *
1025 iow::fd (int fd)
1026         CODE:
1027         THIS->fd = fd;
1028         RETVAL = THIS;
1029         OUTPUT:
1030         RETVAL
1031
1032 iow *
1033 iow::events (short events)
1034         CODE:
1035         THIS->events = events;
1036         RETVAL = THIS;
1037         OUTPUT:
1038         RETVAL
1039
1040 iow *
1041 iow::start ()
1042         CODE:
1043         THIS->start ();
1044         RETVAL = THIS;
1045         OUTPUT:
1046         RETVAL
1047
1048 iow *
1049 iow::stop ()
1050         CODE:
1051         THIS->stop ();
1052         RETVAL = THIS;
1053         OUTPUT:
1054         RETVAL
1055
1056 void
1057 iow::DESTROY ()
1058
1059