Mercurial > hg > RemoteEditor > vim7

comparison src/if_ruby.c @ 0:76efa0be13f1

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Initial revision
author atsuki
date Sat, 10 Nov 2007 15:07:22 +0900
parents
children c16898406ff2
comparison
equal deleted inserted replaced
-1:000000000000 0:76efa0be13f1
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 #if defined(MACOS_X_UNIX) || defined(macintosh)
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 char *line = STR2CSTR(str);
647 aco_save_T aco;
648
649 if (n > 0 && n <= buf->b_ml.ml_line_count && line != NULL)
650 {
651 /* set curwin/curbuf for "buf" and save some things */
652 aucmd_prepbuf(&aco, buf);
653
654 if (u_savesub(n) == OK) {
655 ml_replace(n, (char_u *)line, TRUE);
656 changed();
657 #ifdef SYNTAX_HL
658 syn_changed(n); /* recompute syntax hl. for this line */
659 #endif
660 }
661
662 /* restore curwin/curbuf and a few other things */
663 aucmd_restbuf(&aco);
664 /* Careful: autocommands may have made "buf" invalid! */
665
666 update_curbuf(NOT_VALID);
667 }
668 else
669 {
670 rb_raise(rb_eIndexError, "index %d out of buffer", n);
671 return Qnil; /* For stop warning */
672 }
673 return str;
674 }
675
676 static VALUE buffer_aset(VALUE self, VALUE num, VALUE str)
677 {
678 buf_T *buf = get_buf(self);
679
680 if (buf != NULL)
681 return set_buffer_line(buf, (linenr_T)NUM2LONG(num), str);
682 return str;
683 }
684
685 static VALUE buffer_delete(VALUE self, VALUE num)
686 {
687 buf_T *buf = get_buf(self);
688 long n = NUM2LONG(num);
689 aco_save_T aco;
690
691 if (n > 0 && n <= buf->b_ml.ml_line_count)
692 {
693 /* set curwin/curbuf for "buf" and save some things */
694 aucmd_prepbuf(&aco, buf);
695
696 if (u_savedel(n, 1) == OK) {
697 ml_delete(n, 0);
698
699 /* Changes to non-active buffers should properly refresh
700 * SegPhault - 01/09/05 */
701 deleted_lines_mark(n, 1L);
702
703 changed();
704 }
705
706 /* restore curwin/curbuf and a few other things */
707 aucmd_restbuf(&aco);
708 /* Careful: autocommands may have made "buf" invalid! */
709
710 update_curbuf(NOT_VALID);
711 }
712 else
713 {
714 rb_raise(rb_eIndexError, "index %d out of buffer", n);
715 }
716 return Qnil;
717 }
718
719 static VALUE buffer_append(VALUE self, VALUE num, VALUE str)
720 {
721 buf_T *buf = get_buf(self);
722 char *line = STR2CSTR(str);
723 long n = NUM2LONG(num);
724 aco_save_T aco;
725
726 if (n >= 0 && n <= buf->b_ml.ml_line_count && line != NULL)
727 {
728 /* set curwin/curbuf for "buf" and save some things */
729 aucmd_prepbuf(&aco, buf);
730
731 if (u_inssub(n + 1) == OK) {
732 ml_append(n, (char_u *) line, (colnr_T) 0, FALSE);
733
734 /* Changes to non-active buffers should properly refresh screen
735 * SegPhault - 12/20/04 */
736 appended_lines_mark(n, 1L);
737
738 changed();
739 }
740
741 /* restore curwin/curbuf and a few other things */
742 aucmd_restbuf(&aco);
743 /* Careful: autocommands may have made "buf" invalid! */
744
745 update_curbuf(NOT_VALID);
746 }
747 else {
748 rb_raise(rb_eIndexError, "index %d out of buffer", n);
749 }
750 return str;
751 }
752
753 static VALUE window_new(win_T *win)
754 {
755 if (win->w_ruby_ref)
756 {
757 return (VALUE) win->w_ruby_ref;
758 }
759 else
760 {
761 VALUE obj = Data_Wrap_Struct(cVimWindow, 0, 0, win);
762 win->w_ruby_ref = (void *) obj;
763 rb_hash_aset(objtbl, rb_obj_id(obj), obj);
764 return obj;
765 }
766 }
767
768 static win_T *get_win(VALUE obj)
769 {
770 win_T *win;
771
772 Data_Get_Struct(obj, win_T, win);
773 if (win == NULL)
774 rb_raise(eDeletedWindowError, "attempt to refer to deleted window");
775 return win;
776 }
777
778 static VALUE window_s_current()
779 {
780 return window_new(curwin);
781 }
782
783 /*
784 * Added line manipulation functions
785 * SegPhault - 03/07/05
786 */
787 static VALUE line_s_current()
788 {
789 return get_buffer_line(curbuf, curwin->w_cursor.lnum);
790 }
791
792 static VALUE set_current_line(VALUE self, VALUE str)
793 {
794 return set_buffer_line(curbuf, curwin->w_cursor.lnum, str);
795 }
796
797 static VALUE current_line_number()
798 {
799 return INT2FIX((int)curwin->w_cursor.lnum);
800 }
801
802
803
804 static VALUE window_s_count()
805 {
806 #ifdef FEAT_WINDOWS
807 win_T *w;
808 int n = 0;
809
810 for (w = firstwin; w != NULL; w = w->w_next)
811 n++;
812 return INT2NUM(n);
813 #else
814 return INT2NUM(1);
815 #endif
816 }
817
818 static VALUE window_s_aref(VALUE self, VALUE num)
819 {
820 win_T *w;
821 int n = NUM2INT(num);
822
823 #ifndef FEAT_WINDOWS
824 w = curwin;
825 #else
826 for (w = firstwin; w != NULL; w = w->w_next, --n)
827 #endif
828 if (n == 0)
829 return window_new(w);
830 return Qnil;
831 }
832
833 static VALUE window_buffer(VALUE self)
834 {
835 win_T *win = get_win(self);
836
837 return buffer_new(win->w_buffer);
838 }
839
840 static VALUE window_height(VALUE self)
841 {
842 win_T *win = get_win(self);
843
844 return INT2NUM(win->w_height);
845 }
846
847 static VALUE window_set_height(VALUE self, VALUE height)
848 {
849 win_T *win = get_win(self);
850 win_T *savewin = curwin;
851
852 curwin = win;
853 win_setheight(NUM2INT(height));
854 curwin = savewin;
855 return height;
856 }
857
858 static VALUE window_width(VALUE self)
859 {
860 win_T *win = get_win(self);
861
862 return INT2NUM(win->w_width);
863 }
864
865 static VALUE window_set_width(VALUE self, VALUE width)
866 {
867 win_T *win = get_win(self);
868 win_T *savewin = curwin;
869
870 curwin = win;
871 win_setwidth(NUM2INT(width));
872 curwin = savewin;
873 return width;
874 }
875
876 static VALUE window_cursor(VALUE self)
877 {
878 win_T *win = get_win(self);
879
880 return rb_assoc_new(INT2NUM(win->w_cursor.lnum), INT2NUM(win->w_cursor.col));
881 }
882
883 static VALUE window_set_cursor(VALUE self, VALUE pos)
884 {
885 VALUE lnum, col;
886 win_T *win = get_win(self);
887
888 Check_Type(pos, T_ARRAY);
889 if (RARRAY(pos)->len != 2)
890 rb_raise(rb_eArgError, "array length must be 2");
891 lnum = RARRAY(pos)->ptr[0];
892 col = RARRAY(pos)->ptr[1];
893 win->w_cursor.lnum = NUM2LONG(lnum);
894 win->w_cursor.col = NUM2UINT(col);
895 check_cursor(); /* put cursor on an existing line */
896 update_screen(NOT_VALID);
897 return Qnil;
898 }
899
900 static VALUE f_p(int argc, VALUE *argv, VALUE self)
901 {
902 int i;
903 VALUE str = rb_str_new("", 0);
904
905 for (i = 0; i < argc; i++) {
906 if (i > 0) rb_str_cat(str, ", ", 2);
907 rb_str_concat(str, rb_inspect(argv[i]));
908 }
909 MSG(RSTRING(str)->ptr);
910 return Qnil;
911 }
912
913 static void ruby_io_init(void)
914 {
915 #ifndef DYNAMIC_RUBY
916 RUBYEXTERN VALUE rb_stdout;
917 #endif
918
919 rb_stdout = rb_obj_alloc(rb_cObject);
920 rb_define_singleton_method(rb_stdout, "write", vim_message, 1);
921 rb_define_global_function("p", f_p, -1);
922 }
923
924 static void ruby_vim_init(void)
925 {
926 objtbl = rb_hash_new();
927 rb_global_variable(&objtbl);
928
929 /* The Vim module used to be called "VIM", but "Vim" is better. Make an
930 * alias "VIM" for backwards compatiblity. */
931 mVIM = rb_define_module("Vim");
932 rb_define_const(rb_cObject, "VIM", mVIM);
933 rb_define_const(mVIM, "VERSION_MAJOR", INT2NUM(VIM_VERSION_MAJOR));
934 rb_define_const(mVIM, "VERSION_MINOR", INT2NUM(VIM_VERSION_MINOR));
935 rb_define_const(mVIM, "VERSION_BUILD", INT2NUM(VIM_VERSION_BUILD));
936 rb_define_const(mVIM, "VERSION_PATCHLEVEL", INT2NUM(VIM_VERSION_PATCHLEVEL));
937 rb_define_const(mVIM, "VERSION_SHORT", rb_str_new2(VIM_VERSION_SHORT));
938 rb_define_const(mVIM, "VERSION_MEDIUM", rb_str_new2(VIM_VERSION_MEDIUM));
939 rb_define_const(mVIM, "VERSION_LONG", rb_str_new2(VIM_VERSION_LONG));
940 rb_define_const(mVIM, "VERSION_LONG_DATE", rb_str_new2(VIM_VERSION_LONG_DATE));
941 rb_define_module_function(mVIM, "message", vim_message, 1);
942 rb_define_module_function(mVIM, "set_option", vim_set_option, 1);
943 rb_define_module_function(mVIM, "command", vim_command, 1);
944 rb_define_module_function(mVIM, "evaluate", vim_evaluate, 1);
945
946 eDeletedBufferError = rb_define_class_under(mVIM, "DeletedBufferError",
947 rb_eStandardError);
948 eDeletedWindowError = rb_define_class_under(mVIM, "DeletedWindowError",
949 rb_eStandardError);
950
951 cBuffer = rb_define_class_under(mVIM, "Buffer", rb_cObject);
952 rb_define_singleton_method(cBuffer, "current", buffer_s_current, 0);
953 rb_define_singleton_method(cBuffer, "count", buffer_s_count, 0);
954 rb_define_singleton_method(cBuffer, "[]", buffer_s_aref, 1);
955 rb_define_method(cBuffer, "name", buffer_name, 0);
956 rb_define_method(cBuffer, "number", buffer_number, 0);
957 rb_define_method(cBuffer, "count", buffer_count, 0);
958 rb_define_method(cBuffer, "length", buffer_count, 0);
959 rb_define_method(cBuffer, "[]", buffer_aref, 1);
960 rb_define_method(cBuffer, "[]=", buffer_aset, 2);
961 rb_define_method(cBuffer, "delete", buffer_delete, 1);
962 rb_define_method(cBuffer, "append", buffer_append, 2);
963
964 /* Added line manipulation functions
965 * SegPhault - 03/07/05 */
966 rb_define_method(cBuffer, "line_number", current_line_number, 0);
967 rb_define_method(cBuffer, "line", line_s_current, 0);
968 rb_define_method(cBuffer, "line=", set_current_line, 1);
969
970
971 cVimWindow = rb_define_class_under(mVIM, "Window", rb_cObject);
972 rb_define_singleton_method(cVimWindow, "current", window_s_current, 0);
973 rb_define_singleton_method(cVimWindow, "count", window_s_count, 0);
974 rb_define_singleton_method(cVimWindow, "[]", window_s_aref, 1);
975 rb_define_method(cVimWindow, "buffer", window_buffer, 0);
976 rb_define_method(cVimWindow, "height", window_height, 0);
977 rb_define_method(cVimWindow, "height=", window_set_height, 1);
978 rb_define_method(cVimWindow, "width", window_width, 0);
979 rb_define_method(cVimWindow, "width=", window_set_width, 1);
980 rb_define_method(cVimWindow, "cursor", window_cursor, 0);
981 rb_define_method(cVimWindow, "cursor=", window_set_cursor, 1);
982
983 rb_define_virtual_variable("$curbuf", buffer_s_current, 0);
984 rb_define_virtual_variable("$curwin", window_s_current, 0);
985 }