1 /* vi:set ts=8 sts=4 sw=4: 2 * 3 * VIM - Vi IMproved by Bram Moolenaar 4 * 5 * Ruby interface by Shugo Maeda 6 * with improvements by SegPhault (Ryan Paul) 7 * 8 * Do ":help uganda" in Vim to read copying and usage conditions. 9 * Do ":help credits" in Vim to see a list of people who contributed. 10 * See README.txt for an overview of the Vim source code. 11 */ 12 13 #include <stdio.h> 14 #include <string.h> 15 16 #ifdef _WIN32 17 # if !defined(DYNAMIC_RUBY_VER) || (DYNAMIC_RUBY_VER < 18) 18 # define NT 19 # endif 20 # ifndef DYNAMIC_RUBY 21 # define IMPORT /* For static dll usage __declspec(dllimport) */ 22 # define RUBYEXTERN __declspec(dllimport) 23 # endif 24 #endif 25 #ifndef RUBYEXTERN 26 # define RUBYEXTERN extern 27 #endif 28 29 /* 30 * This is tricky. In ruby.h there is (inline) function rb_class_of() 31 * definition. This function use these variables. But we want function to 32 * use dll_* variables. 33 */ 34 #ifdef DYNAMIC_RUBY 35 # define rb_cFalseClass (*dll_rb_cFalseClass) 36 # define rb_cFixnum (*dll_rb_cFixnum) 37 # define rb_cNilClass (*dll_rb_cNilClass) 38 # define rb_cSymbol (*dll_rb_cSymbol) 39 # define rb_cTrueClass (*dll_rb_cTrueClass) 40 # if defined(DYNAMIC_RUBY_VER) && DYNAMIC_RUBY_VER >= 18 41 /* 42 * On ver 1.8, all Ruby functions are exported with "__declspce(dllimport)" 43 * in ruby.h. But it cause trouble for these variables, because it is 44 * defined in this file. When defined this RUBY_EXPORT it modified to 45 * "extern" and be able to avoid this problem. 46 */ 47 # define RUBY_EXPORT 48 # endif 49 #endif 50 51 #include <ruby.h> 52 53 #undef EXTERN 54 #undef _ 55 56 /* T_DATA defined both by Ruby and Mac header files, hack around it... */ 57 #ifdef FEAT_GUI_MAC 58 # define __OPENTRANSPORT__ 59 # define __OPENTRANSPORTPROTOCOL__ 60 # define __OPENTRANSPORTPROVIDERS__ 61 #endif 62 63 #include "vim.h" 64 #include "version.h" 65 66 #if defined(PROTO) && !defined(FEAT_RUBY) 67 /* Define these to be able to generate the function prototypes. */ 68 # define VALUE int 69 # define RUBY_DATA_FUNC int 70 #endif 71 72 static int ruby_initialized = 0; 73 static VALUE objtbl; 74 75 static VALUE mVIM; 76 static VALUE cBuffer; 77 static VALUE cVimWindow; 78 static VALUE eDeletedBufferError; 79 static VALUE eDeletedWindowError; 80 81 static int ensure_ruby_initialized(void); 82 static void error_print(int); 83 static void ruby_io_init(void); 84 static void ruby_vim_init(void); 85 86 #if defined(DYNAMIC_RUBY) || defined(PROTO) 87 #ifdef PROTO 88 # define HINSTANCE int /* for generating prototypes */ 89 #endif 90 91 /* 92 * Wrapper defines 93 */ 94 #define rb_assoc_new dll_rb_assoc_new 95 #define rb_cObject (*dll_rb_cObject) 96 #define rb_check_type dll_rb_check_type 97 #define rb_class_path dll_rb_class_path 98 #define rb_data_object_alloc dll_rb_data_object_alloc 99 #define rb_define_class_under dll_rb_define_class_under 100 #define rb_define_const dll_rb_define_const 101 #define rb_define_global_function dll_rb_define_global_function 102 #define rb_define_method dll_rb_define_method 103 #define rb_define_module dll_rb_define_module 104 #define rb_define_module_function dll_rb_define_module_function 105 #define rb_define_singleton_method dll_rb_define_singleton_method 106 #define rb_define_virtual_variable dll_rb_define_virtual_variable 107 #define rb_stdout (*dll_rb_stdout) 108 #define rb_eArgError (*dll_rb_eArgError) 109 #define rb_eIndexError (*dll_rb_eIndexError) 110 #define rb_eRuntimeError (*dll_rb_eRuntimeError) 111 #define rb_eStandardError (*dll_rb_eStandardError) 112 #define rb_eval_string_protect dll_rb_eval_string_protect 113 #define rb_global_variable dll_rb_global_variable 114 #define rb_hash_aset dll_rb_hash_aset 115 #define rb_hash_new dll_rb_hash_new 116 #define rb_inspect dll_rb_inspect 117 #define rb_int2inum dll_rb_int2inum 118 #define rb_lastline_get dll_rb_lastline_get 119 #define rb_lastline_set dll_rb_lastline_set 120 #define rb_load_protect dll_rb_load_protect 121 #define rb_num2long dll_rb_num2long 122 #define rb_num2ulong dll_rb_num2ulong 123 #define rb_obj_alloc dll_rb_obj_alloc 124 #define rb_obj_as_string dll_rb_obj_as_string 125 #define rb_obj_id dll_rb_obj_id 126 #define rb_raise dll_rb_raise 127 #define rb_str2cstr dll_rb_str2cstr 128 #define rb_str_cat dll_rb_str_cat 129 #define rb_str_concat dll_rb_str_concat 130 #define rb_str_new dll_rb_str_new 131 #define rb_str_new2 dll_rb_str_new2 132 #define ruby_errinfo (*dll_ruby_errinfo) 133 #define ruby_init dll_ruby_init 134 #define ruby_init_loadpath dll_ruby_init_loadpath 135 #if defined(DYNAMIC_RUBY_VER) && DYNAMIC_RUBY_VER >= 18 136 # define rb_w32_snprintf dll_rb_w32_snprintf 137 #endif 138 139 /* 140 * Pointers for dynamic link 141 */ 142 static VALUE (*dll_rb_assoc_new) (VALUE, VALUE); 143 static VALUE *dll_rb_cFalseClass; 144 static VALUE *dll_rb_cFixnum; 145 static VALUE *dll_rb_cNilClass; 146 static VALUE *dll_rb_cObject; 147 static VALUE *dll_rb_cSymbol; 148 static VALUE *dll_rb_cTrueClass; 149 static void (*dll_rb_check_type) (VALUE,int); 150 static VALUE (*dll_rb_class_path) (VALUE); 151 static VALUE (*dll_rb_data_object_alloc) (VALUE, void*, RUBY_DATA_FUNC, RUBY_DATA_FUNC); 152 static VALUE (*dll_rb_define_class_under) (VALUE, const char*, VALUE); 153 static void (*dll_rb_define_const) (VALUE,const char*,VALUE); 154 static void (*dll_rb_define_global_function) (const char*,VALUE(*)(),int); 155 static void (*dll_rb_define_method) (VALUE,const char*,VALUE(*)(),int); 156 static VALUE (*dll_rb_define_module) (const char*); 157 static void (*dll_rb_define_module_function) (VALUE,const char*,VALUE(*)(),int); 158 static void (*dll_rb_define_singleton_method) (VALUE,const char*,VALUE(*)(),int); 159 static void (*dll_rb_define_virtual_variable) (const char*,VALUE(*)(),void(*)()); 160 static VALUE *dll_rb_stdout; 161 static VALUE *dll_rb_eArgError; 162 static VALUE *dll_rb_eIndexError; 163 static VALUE *dll_rb_eRuntimeError; 164 static VALUE *dll_rb_eStandardError; 165 static VALUE (*dll_rb_eval_string_protect) (const char*, int*); 166 static void (*dll_rb_global_variable) (VALUE*); 167 static VALUE (*dll_rb_hash_aset) (VALUE, VALUE, VALUE); 168 static VALUE (*dll_rb_hash_new) (void); 169 static VALUE (*dll_rb_inspect) (VALUE); 170 static VALUE (*dll_rb_int2inum) (long); 171 static VALUE (*dll_rb_int2inum) (long); 172 static VALUE (*dll_rb_lastline_get) (void); 173 static void (*dll_rb_lastline_set) (VALUE); 174 static void (*dll_rb_load_protect) (VALUE, int, int*); 175 static long (*dll_rb_num2long) (VALUE); 176 static unsigned long (*dll_rb_num2ulong) (VALUE); 177 static VALUE (*dll_rb_obj_alloc) (VALUE); 178 static VALUE (*dll_rb_obj_as_string) (VALUE); 179 static VALUE (*dll_rb_obj_id) (VALUE); 180 static void (*dll_rb_raise) (VALUE, const char*, ...); 181 static char *(*dll_rb_str2cstr) (VALUE,int*); 182 static VALUE (*dll_rb_str_cat) (VALUE, const char*, long); 183 static VALUE (*dll_rb_str_concat) (VALUE, VALUE); 184 static VALUE (*dll_rb_str_new) (const char*, long); 185 static VALUE (*dll_rb_str_new2) (const char*); 186 static VALUE *dll_ruby_errinfo; 187 static void (*dll_ruby_init) (void); 188 static void (*dll_ruby_init_loadpath) (void); 189 #if defined(DYNAMIC_RUBY_VER) && DYNAMIC_RUBY_VER >= 18 190 static int (*dll_rb_w32_snprintf)(char*, size_t, const char*, ...); 191 #endif 192 193 static HINSTANCE hinstRuby = 0; /* Instance of ruby.dll */ 194 195 /* 196 * Table of name to function pointer of ruby. 197 */ 198 #define RUBY_PROC FARPROC 199 static struct 200 { 201 char *name; 202 RUBY_PROC *ptr; 203 } ruby_funcname_table[] = 204 { 205 {"rb_assoc_new", (RUBY_PROC*)&dll_rb_assoc_new}, 206 {"rb_cFalseClass", (RUBY_PROC*)&dll_rb_cFalseClass}, 207 {"rb_cFixnum", (RUBY_PROC*)&dll_rb_cFixnum}, 208 {"rb_cNilClass", (RUBY_PROC*)&dll_rb_cNilClass}, 209 {"rb_cObject", (RUBY_PROC*)&dll_rb_cObject}, 210 {"rb_cSymbol", (RUBY_PROC*)&dll_rb_cSymbol}, 211 {"rb_cTrueClass", (RUBY_PROC*)&dll_rb_cTrueClass}, 212 {"rb_check_type", (RUBY_PROC*)&dll_rb_check_type}, 213 {"rb_class_path", (RUBY_PROC*)&dll_rb_class_path}, 214 {"rb_data_object_alloc", (RUBY_PROC*)&dll_rb_data_object_alloc}, 215 {"rb_define_class_under", (RUBY_PROC*)&dll_rb_define_class_under}, 216 {"rb_define_const", (RUBY_PROC*)&dll_rb_define_const}, 217 {"rb_define_global_function", (RUBY_PROC*)&dll_rb_define_global_function}, 218 {"rb_define_method", (RUBY_PROC*)&dll_rb_define_method}, 219 {"rb_define_module", (RUBY_PROC*)&dll_rb_define_module}, 220 {"rb_define_module_function", (RUBY_PROC*)&dll_rb_define_module_function}, 221 {"rb_define_singleton_method", (RUBY_PROC*)&dll_rb_define_singleton_method}, 222 {"rb_define_virtual_variable", (RUBY_PROC*)&dll_rb_define_virtual_variable}, 223 {"rb_stdout", (RUBY_PROC*)&dll_rb_stdout}, 224 {"rb_eArgError", (RUBY_PROC*)&dll_rb_eArgError}, 225 {"rb_eIndexError", (RUBY_PROC*)&dll_rb_eIndexError}, 226 {"rb_eRuntimeError", (RUBY_PROC*)&dll_rb_eRuntimeError}, 227 {"rb_eStandardError", (RUBY_PROC*)&dll_rb_eStandardError}, 228 {"rb_eval_string_protect", (RUBY_PROC*)&dll_rb_eval_string_protect}, 229 {"rb_global_variable", (RUBY_PROC*)&dll_rb_global_variable}, 230 {"rb_hash_aset", (RUBY_PROC*)&dll_rb_hash_aset}, 231 {"rb_hash_new", (RUBY_PROC*)&dll_rb_hash_new}, 232 {"rb_inspect", (RUBY_PROC*)&dll_rb_inspect}, 233 {"rb_int2inum", (RUBY_PROC*)&dll_rb_int2inum}, 234 {"rb_lastline_get", (RUBY_PROC*)&dll_rb_lastline_get}, 235 {"rb_lastline_set", (RUBY_PROC*)&dll_rb_lastline_set}, 236 {"rb_load_protect", (RUBY_PROC*)&dll_rb_load_protect}, 237 {"rb_num2long", (RUBY_PROC*)&dll_rb_num2long}, 238 {"rb_num2ulong", (RUBY_PROC*)&dll_rb_num2ulong}, 239 {"rb_obj_alloc", (RUBY_PROC*)&dll_rb_obj_alloc}, 240 {"rb_obj_as_string", (RUBY_PROC*)&dll_rb_obj_as_string}, 241 {"rb_obj_id", (RUBY_PROC*)&dll_rb_obj_id}, 242 {"rb_raise", (RUBY_PROC*)&dll_rb_raise}, 243 {"rb_str2cstr", (RUBY_PROC*)&dll_rb_str2cstr}, 244 {"rb_str_cat", (RUBY_PROC*)&dll_rb_str_cat}, 245 {"rb_str_concat", (RUBY_PROC*)&dll_rb_str_concat}, 246 {"rb_str_new", (RUBY_PROC*)&dll_rb_str_new}, 247 {"rb_str_new2", (RUBY_PROC*)&dll_rb_str_new2}, 248 {"ruby_errinfo", (RUBY_PROC*)&dll_ruby_errinfo}, 249 {"ruby_init", (RUBY_PROC*)&dll_ruby_init}, 250 {"ruby_init_loadpath", (RUBY_PROC*)&dll_ruby_init_loadpath}, 251 #if defined(DYNAMIC_RUBY_VER) && DYNAMIC_RUBY_VER >= 18 252 {"rb_w32_snprintf", (RUBY_PROC*)&dll_rb_w32_snprintf}, 253 #endif 254 {"", NULL}, 255 }; 256 257 /* 258 * Free ruby.dll 259 */ 260 static void 261 end_dynamic_ruby() 262 { 263 if (hinstRuby) 264 { 265 FreeLibrary(hinstRuby); 266 hinstRuby = 0; 267 } 268 } 269 270 /* 271 * Load library and get all pointers. 272 * Parameter 'libname' provides name of DLL. 273 * Return OK or FAIL. 274 */ 275 static int 276 ruby_runtime_link_init(char *libname, int verbose) 277 { 278 int i; 279 280 if (hinstRuby) 281 return OK; 282 hinstRuby = LoadLibrary(libname); 283 if (!hinstRuby) 284 { 285 if (verbose) 286 EMSG2(_(e_loadlib), libname); 287 return FAIL; 288 } 289 290 for (i = 0; ruby_funcname_table[i].ptr; ++i) 291 { 292 if (!(*ruby_funcname_table[i].ptr = GetProcAddress(hinstRuby, 293 ruby_funcname_table[i].name))) 294 { 295 FreeLibrary(hinstRuby); 296 hinstRuby = 0; 297 if (verbose) 298 EMSG2(_(e_loadfunc), ruby_funcname_table[i].name); 299 return FAIL; 300 } 301 } 302 return OK; 303 } 304 305 /* 306 * If ruby is enabled (there is installed ruby on Windows system) return TRUE, 307 * else FALSE. 308 */ 309 int 310 ruby_enabled(verbose) 311 int verbose; 312 { 313 return ruby_runtime_link_init(DYNAMIC_RUBY_DLL, verbose) == OK; 314 } 315 #endif /* defined(DYNAMIC_RUBY) || defined(PROTO) */ 316 317 void 318 ruby_end() 319 { 320 #ifdef DYNAMIC_RUBY 321 end_dynamic_ruby(); 322 #endif 323 } 324 325 void ex_ruby(exarg_T *eap) 326 { 327 int state; 328 char *script = NULL; 329 330 script = (char *)script_get(eap, eap->arg); 331 if (!eap->skip && ensure_ruby_initialized()) 332 { 333 if (script == NULL) 334 rb_eval_string_protect((char *)eap->arg, &state); 335 else 336 rb_eval_string_protect(script, &state); 337 if (state) 338 error_print(state); 339 } 340 vim_free(script); 341 } 342 343 void ex_rubydo(exarg_T *eap) 344 { 345 int state; 346 linenr_T i; 347 348 if (ensure_ruby_initialized()) 349 { 350 if (u_save(eap->line1 - 1, eap->line2 + 1) != OK) 351 return; 352 for (i = eap->line1; i <= eap->line2; i++) { 353 VALUE line, oldline; 354 355 line = oldline = rb_str_new2((char *)ml_get(i)); 356 rb_lastline_set(line); 357 rb_eval_string_protect((char *) eap->arg, &state); 358 if (state) { 359 error_print(state); 360 break; 361 } 362 line = rb_lastline_get(); 363 if (!NIL_P(line)) { 364 if (TYPE(line) != T_STRING) { 365 EMSG(_("E265: $_ must be an instance of String")); 366 return; 367 } 368 ml_replace(i, (char_u *) STR2CSTR(line), 1); 369 changed(); 370 #ifdef SYNTAX_HL 371 syn_changed(i); /* recompute syntax hl. for this line */ 372 #endif 373 } 374 } 375 check_cursor(); 376 update_curbuf(NOT_VALID); 377 } 378 } 379 380 void ex_rubyfile(exarg_T *eap) 381 { 382 int state; 383 384 if (ensure_ruby_initialized()) 385 { 386 rb_load_protect(rb_str_new2((char *) eap->arg), 0, &state); 387 if (state) error_print(state); 388 } 389 } 390 391 void ruby_buffer_free(buf_T *buf) 392 { 393 if (buf->b_ruby_ref) 394 { 395 rb_hash_aset(objtbl, rb_obj_id((VALUE) buf->b_ruby_ref), Qnil); 396 RDATA(buf->b_ruby_ref)->data = NULL; 397 } 398 } 399 400 void ruby_window_free(win_T *win) 401 { 402 if (win->w_ruby_ref) 403 { 404 rb_hash_aset(objtbl, rb_obj_id((VALUE) win->w_ruby_ref), Qnil); 405 RDATA(win->w_ruby_ref)->data = NULL; 406 } 407 } 408 409 static int ensure_ruby_initialized(void) 410 { 411 if (!ruby_initialized) 412 { 413 #ifdef DYNAMIC_RUBY 414 if (ruby_enabled(TRUE)) 415 { 416 #endif 417 ruby_init(); 418 ruby_init_loadpath(); 419 ruby_io_init(); 420 ruby_vim_init(); 421 ruby_initialized = 1; 422 #ifdef DYNAMIC_RUBY 423 } 424 else 425 { 426 EMSG(_("E266: Sorry, this command is disabled, the Ruby library could not be loaded.")); 427 return 0; 428 } 429 #endif 430 } 431 return ruby_initialized; 432 } 433 434 static void error_print(int state) 435 { 436 #ifndef DYNAMIC_RUBY 437 RUBYEXTERN VALUE ruby_errinfo; 438 #endif 439 VALUE eclass; 440 VALUE einfo; 441 char buff[BUFSIZ]; 442 443 #define TAG_RETURN 0x1 444 #define TAG_BREAK 0x2 445 #define TAG_NEXT 0x3 446 #define TAG_RETRY 0x4 447 #define TAG_REDO 0x5 448 #define TAG_RAISE 0x6 449 #define TAG_THROW 0x7 450 #define TAG_FATAL 0x8 451 #define TAG_MASK 0xf 452 453 switch (state) { 454 case TAG_RETURN: 455 EMSG(_("E267: unexpected return")); 456 break; 457 case TAG_NEXT: 458 EMSG(_("E268: unexpected next")); 459 break; 460 case TAG_BREAK: 461 EMSG(_("E269: unexpected break")); 462 break; 463 case TAG_REDO: 464 EMSG(_("E270: unexpected redo")); 465 break; 466 case TAG_RETRY: 467 EMSG(_("E271: retry outside of rescue clause")); 468 break; 469 case TAG_RAISE: 470 case TAG_FATAL: 471 eclass = CLASS_OF(ruby_errinfo); 472 einfo = rb_obj_as_string(ruby_errinfo); 473 if (eclass == rb_eRuntimeError && RSTRING(einfo)->len == 0) { 474 EMSG(_("E272: unhandled exception")); 475 } 476 else { 477 VALUE epath; 478 char *p; 479 480 epath = rb_class_path(eclass); 481 vim_snprintf(buff, BUFSIZ, "%s: %s", 482 RSTRING(epath)->ptr, RSTRING(einfo)->ptr); 483 p = strchr(buff, '\n'); 484 if (p) *p = '\0'; 485 EMSG(buff); 486 } 487 break; 488 default: 489 vim_snprintf(buff, BUFSIZ, _("E273: unknown longjmp status %d"), state); 490 EMSG(buff); 491 break; 492 } 493 } 494 495 static VALUE vim_message(VALUE self, VALUE str) 496 { 497 char *buff, *p; 498 499 str = rb_obj_as_string(str); 500 buff = ALLOCA_N(char, RSTRING(str)->len); 501 strcpy(buff, RSTRING(str)->ptr); 502 p = strchr(buff, '\n'); 503 if (p) *p = '\0'; 504 MSG(buff); 505 return Qnil; 506 } 507 508 static VALUE vim_set_option(VALUE self, VALUE str) 509 { 510 do_set((char_u *)STR2CSTR(str), 0); 511 update_screen(NOT_VALID); 512 return Qnil; 513 } 514 515 static VALUE vim_command(VALUE self, VALUE str) 516 { 517 do_cmdline_cmd((char_u *)STR2CSTR(str)); 518 return Qnil; 519 } 520 521 static VALUE vim_evaluate(VALUE self, VALUE str) 522 { 523 #ifdef FEAT_EVAL 524 char_u *value = eval_to_string((char_u *)STR2CSTR(str), NULL, TRUE); 525 526 if (value != NULL) 527 { 528 VALUE val = rb_str_new2((char *)value); 529 vim_free(value); 530 return val; 531 } 532 else 533 #endif 534 return Qnil; 535 } 536 537 static VALUE buffer_new(buf_T *buf) 538 { 539 if (buf->b_ruby_ref) 540 { 541 return (VALUE) buf->b_ruby_ref; 542 } 543 else 544 { 545 VALUE obj = Data_Wrap_Struct(cBuffer, 0, 0, buf); 546 buf->b_ruby_ref = (void *) obj; 547 rb_hash_aset(objtbl, rb_obj_id(obj), obj); 548 return obj; 549 } 550 } 551 552 static buf_T *get_buf(VALUE obj) 553 { 554 buf_T *buf; 555 556 Data_Get_Struct(obj, buf_T, buf); 557 if (buf == NULL) 558 rb_raise(eDeletedBufferError, "attempt to refer to deleted buffer"); 559 return buf; 560 } 561 562 static VALUE buffer_s_current() 563 { 564 return buffer_new(curbuf); 565 } 566 567 static VALUE buffer_s_count() 568 { 569 buf_T *b; 570 int n = 0; 571 572 for (b = firstbuf; b != NULL; b = b->b_next) 573 { 574 /* Deleted buffers should not be counted 575 * SegPhault - 01/07/05 */ 576 if (b->b_p_bl) 577 n++; 578 } 579 580 return INT2NUM(n); 581 } 582 583 static VALUE buffer_s_aref(VALUE self, VALUE num) 584 { 585 buf_T *b; 586 int n = NUM2INT(num); 587 588 for (b = firstbuf; b != NULL; b = b->b_next) 589 { 590 /* Deleted buffers should not be counted 591 * SegPhault - 01/07/05 */ 592 if (!b->b_p_bl) 593 continue; 594 595 if (n == 0) 596 return buffer_new(b); 597 598 n--; 599 } 600 return Qnil; 601 } 602 603 static VALUE buffer_name(VALUE self) 604 { 605 buf_T *buf = get_buf(self); 606 607 return buf->b_ffname ? rb_str_new2((char *)buf->b_ffname) : Qnil; 608 } 609 610 static VALUE buffer_number(VALUE self) 611 { 612 buf_T *buf = get_buf(self); 613 614 return INT2NUM(buf->b_fnum); 615 } 616 617 static VALUE buffer_count(VALUE self) 618 { 619 buf_T *buf = get_buf(self); 620 621 return INT2NUM(buf->b_ml.ml_line_count); 622 } 623 624 static VALUE get_buffer_line(buf_T *buf, linenr_T n) 625 { 626 if (n > 0 && n <= buf->b_ml.ml_line_count) 627 { 628 char *line = (char *)ml_get_buf(buf, n, FALSE); 629 return line ? rb_str_new2(line) : Qnil; 630 } 631 rb_raise(rb_eIndexError, "index %d out of buffer", n); 632 return Qnil; /* For stop warning */ 633 } 634 635 static VALUE buffer_aref(VALUE self, VALUE num) 636 { 637 buf_T *buf = get_buf(self); 638 639 if (buf != NULL) 640 return get_buffer_line(buf, (linenr_T)NUM2LONG(num)); 641 return Qnil; /* For stop warning */ 642 } 643 644 static VALUE set_buffer_line(buf_T *buf, linenr_T n, VALUE str) 645 { 646 buf_T *savebuf = curbuf; 647 char *line = STR2CSTR(str); 648 649 if (n > 0 && n <= buf->b_ml.ml_line_count && line != NULL) { 650 curbuf = buf; 651 if (u_savesub(n) == OK) { 652 ml_replace(n, (char_u *)line, TRUE); 653 changed(); 654 #ifdef SYNTAX_HL 655 syn_changed(n); /* recompute syntax hl. for this line */ 656 #endif 657 } 658 curbuf = savebuf; 659 update_curbuf(NOT_VALID); 660 } 661 else { 662 rb_raise(rb_eIndexError, "index %d out of buffer", n); 663 return Qnil; /* For stop warning */ 664 } 665 return str; 666 } 667 668 static VALUE buffer_aset(VALUE self, VALUE num, VALUE str) 669 { 670 buf_T *buf = get_buf(self); 671 672 if (buf != NULL) 673 return set_buffer_line(buf, (linenr_T)NUM2LONG(num), str); 674 return str; 675 } 676 677 static VALUE buffer_delete(VALUE self, VALUE num) 678 { 679 buf_T *buf = get_buf(self); 680 buf_T *savebuf = curbuf; 681 long n = NUM2LONG(num); 682 683 if (n > 0 && n <= buf->b_ml.ml_line_count) { 684 curbuf = buf; 685 if (u_savedel(n, 1) == OK) { 686 ml_delete(n, 0); 687 688 /* Changes to non-active buffers should properly refresh 689 * SegPhault - 01/09/05 */ 690 deleted_lines_mark(n, 1L); 691 692 changed(); 693 } 694 curbuf = savebuf; 695 update_curbuf(NOT_VALID); 696 } 697 else { 698 rb_raise(rb_eIndexError, "index %d out of buffer", n); 699 } 700 return Qnil; 701 } 702 703 static VALUE buffer_append(VALUE self, VALUE num, VALUE str) 704 { 705 buf_T *buf = get_buf(self); 706 buf_T *savebuf = curbuf; 707 char *line = STR2CSTR(str); 708 long n = NUM2LONG(num); 709 710 if (n >= 0 && n <= buf->b_ml.ml_line_count && line != NULL) { 711 curbuf = buf; 712 if (u_inssub(n + 1) == OK) { 713 ml_append(n, (char_u *) line, (colnr_T) 0, FALSE); 714 715 /* Changes to non-active buffers should properly refresh screen 716 * SegPhault - 12/20/04 */ 717 appended_lines_mark(n, 1L); 718 719 changed(); 720 } 721 curbuf = savebuf; 722 update_curbuf(NOT_VALID); 723 } 724 else { 725 rb_raise(rb_eIndexError, "index %d out of buffer", n); 726 } 727 return str; 728 } 729 730 static VALUE window_new(win_T *win) 731 { 732 if (win->w_ruby_ref) 733 { 734 return (VALUE) win->w_ruby_ref; 735 } 736 else 737 { 738 VALUE obj = Data_Wrap_Struct(cVimWindow, 0, 0, win); 739 win->w_ruby_ref = (void *) obj; 740 rb_hash_aset(objtbl, rb_obj_id(obj), obj); 741 return obj; 742 } 743 } 744 745 static win_T *get_win(VALUE obj) 746 { 747 win_T *win; 748 749 Data_Get_Struct(obj, win_T, win); 750 if (win == NULL) 751 rb_raise(eDeletedWindowError, "attempt to refer to deleted window"); 752 return win; 753 } 754 755 static VALUE window_s_current() 756 { 757 return window_new(curwin); 758 } 759 760 /* 761 * Added line manipulation functions 762 * SegPhault - 03/07/05 763 */ 764 static VALUE line_s_current() 765 { 766 return get_buffer_line(curbuf, curwin->w_cursor.lnum); 767 } 768 769 static VALUE set_current_line(VALUE str) 770 { 771 return set_buffer_line(curbuf, curwin->w_cursor.lnum, str); 772 } 773 774 static VALUE current_line_number() 775 { 776 return INT2FIX((int)curwin->w_cursor.lnum); 777 } 778 779 780 781 static VALUE window_s_count() 782 { 783 #ifdef FEAT_WINDOWS 784 win_T *w; 785 int n = 0; 786 787 for (w = firstwin; w != NULL; w = w->w_next) 788 n++; 789 return INT2NUM(n); 790 #else 791 return INT2NUM(1); 792 #endif 793 } 794 795 static VALUE window_s_aref(VALUE self, VALUE num) 796 { 797 win_T *w; 798 int n = NUM2INT(num); 799 800 #ifndef FEAT_WINDOWS 801 w = curwin; 802 #else 803 for (w = firstwin; w != NULL; w = w->w_next, --n) 804 #endif 805 if (n == 0) 806 return window_new(w); 807 return Qnil; 808 } 809 810 static VALUE window_buffer(VALUE self) 811 { 812 win_T *win = get_win(self); 813 814 return buffer_new(win->w_buffer); 815 } 816 817 static VALUE window_height(VALUE self) 818 { 819 win_T *win = get_win(self); 820 821 return INT2NUM(win->w_height); 822 } 823 824 static VALUE window_set_height(VALUE self, VALUE height) 825 { 826 win_T *win = get_win(self); 827 win_T *savewin = curwin; 828 829 curwin = win; 830 win_setheight(NUM2INT(height)); 831 curwin = savewin; 832 return height; 833 } 834 835 static VALUE window_width(VALUE self) 836 { 837 win_T *win = get_win(self); 838 839 return INT2NUM(win->w_width); 840 } 841 842 static VALUE window_set_width(VALUE self, VALUE width) 843 { 844 win_T *win = get_win(self); 845 win_T *savewin = curwin; 846 847 curwin = win; 848 win_setwidth(NUM2INT(width)); 849 curwin = savewin; 850 return width; 851 } 852 853 static VALUE window_cursor(VALUE self) 854 { 855 win_T *win = get_win(self); 856 857 return rb_assoc_new(INT2NUM(win->w_cursor.lnum), INT2NUM(win->w_cursor.col)); 858 } 859 860 static VALUE window_set_cursor(VALUE self, VALUE pos) 861 { 862 VALUE lnum, col; 863 win_T *win = get_win(self); 864 865 Check_Type(pos, T_ARRAY); 866 if (RARRAY(pos)->len != 2) 867 rb_raise(rb_eArgError, "array length must be 2"); 868 lnum = RARRAY(pos)->ptr[0]; 869 col = RARRAY(pos)->ptr[1]; 870 win->w_cursor.lnum = NUM2LONG(lnum); 871 win->w_cursor.col = NUM2UINT(col); 872 check_cursor(); /* put cursor on an existing line */ 873 update_screen(NOT_VALID); 874 return Qnil; 875 } 876 877 static VALUE f_p(int argc, VALUE *argv, VALUE self) 878 { 879 int i; 880 VALUE str = rb_str_new("", 0); 881 882 for (i = 0; i < argc; i++) { 883 if (i > 0) rb_str_cat(str, ", ", 2); 884 rb_str_concat(str, rb_inspect(argv[i])); 885 } 886 MSG(RSTRING(str)->ptr); 887 return Qnil; 888 } 889 890 static void ruby_io_init(void) 891 { 892 #ifndef DYNAMIC_RUBY 893 RUBYEXTERN VALUE rb_stdout; 894 #endif 895 896 rb_stdout = rb_obj_alloc(rb_cObject); 897 rb_define_singleton_method(rb_stdout, "write", vim_message, 1); 898 rb_define_global_function("p", f_p, -1); 899 } 900 901 static void ruby_vim_init(void) 902 { 903 objtbl = rb_hash_new(); 904 rb_global_variable(&objtbl); 905 906 mVIM = rb_define_module("VIM"); 907 rb_define_const(mVIM, "VERSION_MAJOR", INT2NUM(VIM_VERSION_MAJOR)); 908 rb_define_const(mVIM, "VERSION_MINOR", INT2NUM(VIM_VERSION_MINOR)); 909 rb_define_const(mVIM, "VERSION_BUILD", INT2NUM(VIM_VERSION_BUILD)); 910 rb_define_const(mVIM, "VERSION_PATCHLEVEL", INT2NUM(VIM_VERSION_PATCHLEVEL)); 911 rb_define_const(mVIM, "VERSION_SHORT", rb_str_new2(VIM_VERSION_SHORT)); 912 rb_define_const(mVIM, "VERSION_MEDIUM", rb_str_new2(VIM_VERSION_MEDIUM)); 913 rb_define_const(mVIM, "VERSION_LONG", rb_str_new2(VIM_VERSION_LONG)); 914 rb_define_const(mVIM, "VERSION_LONG_DATE", rb_str_new2(VIM_VERSION_LONG_DATE)); 915 rb_define_module_function(mVIM, "message", vim_message, 1); 916 rb_define_module_function(mVIM, "set_option", vim_set_option, 1); 917 rb_define_module_function(mVIM, "command", vim_command, 1); 918 rb_define_module_function(mVIM, "evaluate", vim_evaluate, 1); 919 920 eDeletedBufferError = rb_define_class_under(mVIM, "DeletedBufferError", 921 rb_eStandardError); 922 eDeletedWindowError = rb_define_class_under(mVIM, "DeletedWindowError", 923 rb_eStandardError); 924 925 cBuffer = rb_define_class_under(mVIM, "Buffer", rb_cObject); 926 rb_define_singleton_method(cBuffer, "current", buffer_s_current, 0); 927 rb_define_singleton_method(cBuffer, "count", buffer_s_count, 0); 928 rb_define_singleton_method(cBuffer, "[]", buffer_s_aref, 1); 929 rb_define_method(cBuffer, "name", buffer_name, 0); 930 rb_define_method(cBuffer, "number", buffer_number, 0); 931 rb_define_method(cBuffer, "count", buffer_count, 0); 932 rb_define_method(cBuffer, "length", buffer_count, 0); 933 rb_define_method(cBuffer, "[]", buffer_aref, 1); 934 rb_define_method(cBuffer, "[]=", buffer_aset, 2); 935 rb_define_method(cBuffer, "delete", buffer_delete, 1); 936 rb_define_method(cBuffer, "append", buffer_append, 2); 937 938 /* Added line manipulation functions 939 * SegPhault - 03/07/05 */ 940 rb_define_method(cBuffer, "line_number", current_line_number, 0); 941 rb_define_method(cBuffer, "line", line_s_current, 0); 942 rb_define_method(cBuffer, "line=", set_current_line, 1); 943 944 945 cVimWindow = rb_define_class_under(mVIM, "Window", rb_cObject); 946 rb_define_singleton_method(cVimWindow, "current", window_s_current, 0); 947 rb_define_singleton_method(cVimWindow, "count", window_s_count, 0); 948 rb_define_singleton_method(cVimWindow, "[]", window_s_aref, 1); 949 rb_define_method(cVimWindow, "buffer", window_buffer, 0); 950 rb_define_method(cVimWindow, "height", window_height, 0); 951 rb_define_method(cVimWindow, "height=", window_set_height, 1); 952 rb_define_method(cVimWindow, "width", window_width, 0); 953 rb_define_method(cVimWindow, "width=", window_set_width, 1); 954 rb_define_method(cVimWindow, "cursor", window_cursor, 0); 955 rb_define_method(cVimWindow, "cursor=", window_set_cursor, 1); 956 957 rb_define_virtual_variable("$curbuf", buffer_s_current, 0); 958 rb_define_virtual_variable("$curwin", window_s_current, 0); 959 } 960