?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'vim'
[MacVim.git] / src / netbeans.c
blobc7e9b9801b712555ef34b16f42abf5c6a358a2ca
1 /* vi:set ts=8 sts=4 sw=4:
2 *
3 * VIM - Vi IMproved by Bram Moolenaar
4 * Netbeans integration by David Weatherford
5 * Adopted for Win32 by Sergey Khorev
6 *
7 * Do ":help uganda" in Vim to read copying and usage conditions.
8 * Do ":help credits" in Vim to see a list of people who contributed.
9 */
10
11 /*
12 * Implements client side of org.netbeans.modules.emacs editor
13 * integration protocol. Be careful! The protocol uses offsets
14 * which are *between* characters, whereas vim uses line number
15 * and column number which are *on* characters.
16 * See ":help netbeans-protocol" for explanation.
17 */
18
19 #if defined(MSDOS) || defined(WIN16) || defined(WIN32) || defined(_WIN64)
20 # include "vimio.h" /* for mch_open(), must be before vim.h */
21 #endif
22
23 #include "vim.h"
24
25 #if defined(FEAT_NETBEANS_INTG) || defined(PROTO)
26
27 /* Note: when making changes here also adjust configure.in. */
28 #ifdef WIN32
29 # ifdef DEBUG
30 # include <tchar.h> /* for _T definition for TRACEn macros */
31 # endif
32 /* WinSock API is separated from C API, thus we can't use read(), write(),
33 * errno... */
34 # define sock_errno WSAGetLastError()
35 # undef ECONNREFUSED
36 # define ECONNREFUSED WSAECONNREFUSED
37 # ifdef EINTR
38 # undef EINTR
39 # endif
40 # define EINTR WSAEINTR
41 # define sock_write(sd, buf, len) send(sd, buf, len, 0)
42 # define sock_read(sd, buf, len) recv(sd, buf, len, 0)
43 # define sock_close(sd) closesocket(sd)
44 # define sleep(t) Sleep(t*1000) /* WinAPI Sleep() accepts milliseconds */
45 #else
46 # include <netdb.h>
47 # include <netinet/in.h>
48 # include <sys/socket.h>
49 # ifdef HAVE_LIBGEN_H
50 # include <libgen.h>
51 # endif
52 # define sock_errno errno
53 # define sock_write(sd, buf, len) write(sd, buf, len)
54 # define sock_read(sd, buf, len) read(sd, buf, len)
55 # define sock_close(sd) close(sd)
56 #endif
57
58 #include "version.h"
59
60 #define INET_SOCKETS
61
62 #define GUARDED 10000 /* typenr for "guarded" annotation */
63 #define GUARDEDOFFSET 1000000 /* base for "guarded" sign id's */
64
65 /* The first implementation (working only with Netbeans) returned "1.1". The
66 * protocol implemented here also supports A-A-P. */
67 static char *ExtEdProtocolVersion = "2.4";
68
69 static long pos2off __ARGS((buf_T *, pos_T *));
70 static pos_T *off2pos __ARGS((buf_T *, long));
71 static pos_T *get_off_or_lnum __ARGS((buf_T *buf, char_u **argp));
72 static long get_buf_size __ARGS((buf_T *));
73 static int netbeans_keystring __ARGS((char_u *keystr));
74 static void postpone_keycommand __ARGS((char_u *keystr));
75 static void special_keys __ARGS((char_u *args));
76
77 static void netbeans_connect __ARGS((void));
78 static int getConnInfo __ARGS((char *file, char **host, char **port, char **password));
79
80 static void nb_init_graphics __ARGS((void));
81 static void coloncmd __ARGS((char *cmd, ...));
82 static void nb_set_curbuf __ARGS((buf_T *buf));
83 #ifdef FEAT_GUI_MOTIF
84 static void messageFromNetbeans __ARGS((XtPointer, int *, XtInputId *));
85 #endif
86 #ifdef FEAT_GUI_GTK
87 static void messageFromNetbeans __ARGS((gpointer, gint, GdkInputCondition));
88 #endif
89 static void nb_parse_cmd __ARGS((char_u *));
90 static int nb_do_cmd __ARGS((int, char_u *, int, int, char_u *));
91 static void nb_send __ARGS((char *buf, char *fun));
92
93 #ifdef WIN64
94 typedef __int64 NBSOCK;
95 #else
96 typedef int NBSOCK;
97 #endif
98
99 static NBSOCK sd = -1; /* socket fd for Netbeans connection */
100 #ifdef FEAT_GUI_MOTIF
101 static XtInputId inputHandler; /* Cookie for input */
102 #endif
103 #ifdef FEAT_GUI_GTK
104 static gint inputHandler; /* Cookie for input */
105 #endif
106 #ifdef FEAT_GUI_W32
107 static int inputHandler = -1; /* simply ret.value of WSAAsyncSelect() */
108 extern HWND s_hwnd; /* Gvim's Window handle */
109 #endif
110 static int r_cmdno; /* current command number for reply */
111 static int haveConnection = FALSE; /* socket is connected and
112 initialization is done */
113 #ifdef FEAT_GUI_MOTIF
114 static void netbeans_Xt_connect __ARGS((void *context));
115 #endif
116 #ifdef FEAT_GUI_GTK
117 static void netbeans_gtk_connect __ARGS((void));
118 #endif
119 #ifdef FEAT_GUI_W32
120 static void netbeans_w32_connect __ARGS((void));
121 #endif
122 #ifdef FEAT_GUI_MACVIM
123 static void netbeans_macvim_connect __ARGS((void));
124 static int sock_select(int s);
125 #endif
126
127 static int dosetvisible = FALSE;
128
129 /*
130 * Include the debugging code if wanted.
131 */
132 #ifdef NBDEBUG
133 # include "nbdebug.c"
134 #endif
135
136 /* Connect back to Netbeans process */
137 #ifdef FEAT_GUI_MOTIF
138 static void
139 netbeans_Xt_connect(void *context)
140 {
141 netbeans_connect();
142 if (sd > 0)
143 {
144 /* tell notifier we are interested in being called
145 * when there is input on the editor connection socket
146 */
147 inputHandler = XtAppAddInput((XtAppContext)context, sd,
148 (XtPointer)(XtInputReadMask + XtInputExceptMask),
149 messageFromNetbeans, NULL);
150 }
151 }
152
153 static void
154 netbeans_disconnect(void)
155 {
156 if (inputHandler != (XtInputId)NULL)
157 {
158 XtRemoveInput(inputHandler);
159 inputHandler = (XtInputId)NULL;
160 }
161 sd = -1;
162 haveConnection = FALSE;
163 # ifdef FEAT_BEVAL
164 bevalServers &= ~BEVAL_NETBEANS;
165 # endif
166 }
167 #endif /* FEAT_MOTIF_GUI */
168
169 #ifdef FEAT_GUI_GTK
170 static void
171 netbeans_gtk_connect(void)
172 {
173 netbeans_connect();
174 if (sd > 0)
175 {
176 /*
177 * Tell gdk we are interested in being called when there
178 * is input on the editor connection socket
179 */
180 inputHandler = gdk_input_add((gint)sd, (GdkInputCondition)
181 ((int)GDK_INPUT_READ + (int)GDK_INPUT_EXCEPTION),
182 messageFromNetbeans, NULL);
183 }
184 }
185
186 static void
187 netbeans_disconnect(void)
188 {
189 if (inputHandler != 0)
190 {
191 gdk_input_remove(inputHandler);
192 inputHandler = 0;
193 }
194 sd = -1;
195 haveConnection = FALSE;
196 # ifdef FEAT_BEVAL
197 bevalServers &= ~BEVAL_NETBEANS;
198 # endif
199 }
200 #endif /* FEAT_GUI_GTK */
201
202 #if defined(FEAT_GUI_W32) || defined(PROTO)
203 static void
204 netbeans_w32_connect(void)
205 {
206 netbeans_connect();
207 if (sd > 0)
208 {
209 /*
210 * Tell Windows we are interested in receiving message when there
211 * is input on the editor connection socket
212 */
213 inputHandler = WSAAsyncSelect(sd, s_hwnd, WM_NETBEANS, FD_READ);
214 }
215 }
216
217 static void
218 netbeans_disconnect(void)
219 {
220 if (inputHandler == 0)
221 {
222 WSAAsyncSelect(sd, s_hwnd, 0, 0);
223 inputHandler = -1;
224 }
225 sd = -1;
226 haveConnection = FALSE;
227 # ifdef FEAT_BEVAL
228 bevalServers &= ~BEVAL_NETBEANS;
229 # endif
230 }
231 #endif /* FEAT_GUI_W32 */
232
233 #if defined(FEAT_GUI_MACVIM) || defined(PROTO)
234 static void
235 netbeans_macvim_connect(void)
236 {
237 netbeans_connect();
238 if (sd > 0)
239 {
240 /*
241 * Tell Core Foundation we are interested in being called when there
242 * is input on the editor connection socket
243 */
244 gui_macvim_set_netbeans_socket(sd);
245 }
246 }
247
248 static void
249 netbeans_disconnect(void)
250 {
251 if (sd != -1)
252 {
253 sd = -1;
254 gui_macvim_set_netbeans_socket(sd);
255 }
256 haveConnection = FALSE;
257 # ifdef FEAT_BEVAL
258 bevalServers &= ~BEVAL_NETBEANS;
259 # endif
260 }
261
262 static int
263 sock_select(int s)
264 {
265 fd_set readset;
266 struct timeval timeout;
267
268 FD_ZERO(&readset);
269 FD_SET(s, &readset);
270 timeout.tv_sec = 0;
271 timeout.tv_usec = 0;
272
273 return select(s + 1, &readset, NULL, NULL, &timeout);
274 }
275 #endif /* FEAT_GUI_MACVIM */
276
277 #define NB_DEF_HOST "localhost"
278 #define NB_DEF_ADDR "3219"
279 #define NB_DEF_PASS "changeme"
280
281 static void
282 netbeans_connect(void)
283 {
284 #ifdef INET_SOCKETS
285 struct sockaddr_in server;
286 struct hostent * host;
287 # ifdef FEAT_GUI_W32
288 u_short port;
289 # else
290 int port;
291 #endif
292 #else
293 struct sockaddr_un server;
294 #endif
295 char buf[32];
296 char *hostname = NULL;
297 char *address = NULL;
298 char *password = NULL;
299 char *fname;
300 char *arg = NULL;
301
302 if (netbeansArg[3] == '=')
303 {
304 /* "-nb=fname": Read info from specified file. */
305 if (getConnInfo(netbeansArg + 4, &hostname, &address, &password)
306 == FAIL)
307 return;
308 }
309 else
310 {
311 if (netbeansArg[3] == ':')
312 /* "-nb:<host>:<addr>:<password>": get info from argument */
313 arg = netbeansArg + 4;
314 if (arg == NULL && (fname = getenv("__NETBEANS_CONINFO")) != NULL)
315 {
316 /* "-nb": get info from file specified in environment */
317 if (getConnInfo(fname, &hostname, &address, &password) == FAIL)
318 return;
319 }
320 else
321 {
322 if (arg != NULL)
323 {
324 /* "-nb:<host>:<addr>:<password>": get info from argument */
325 hostname = arg;
326 address = strchr(hostname, ':');
327 if (address != NULL)
328 {
329 *address++ = '\0';
330 password = strchr(address, ':');
331 if (password != NULL)
332 *password++ = '\0';
333 }
334 }
335
336 /* Get the missing values from the environment. */
337 if (hostname == NULL || *hostname == '\0')
338 hostname = getenv("__NETBEANS_HOST");
339 if (address == NULL)
340 address = getenv("__NETBEANS_SOCKET");
341 if (password == NULL)
342 password = getenv("__NETBEANS_VIM_PASSWORD");
343
344 /* Move values to allocated memory. */
345 if (hostname != NULL)
346 hostname = (char *)vim_strsave((char_u *)hostname);
347 if (address != NULL)
348 address = (char *)vim_strsave((char_u *)address);
349 if (password != NULL)
350 password = (char *)vim_strsave((char_u *)password);
351 }
352 }
353
354 /* Use the default when a value is missing. */
355 if (hostname == NULL || *hostname == '\0')
356 {
357 vim_free(hostname);
358 hostname = (char *)vim_strsave((char_u *)NB_DEF_HOST);
359 }
360 if (address == NULL || *address == '\0')
361 {
362 vim_free(address);
363 address = (char *)vim_strsave((char_u *)NB_DEF_ADDR);
364 }
365 if (password == NULL || *password == '\0')
366 {
367 vim_free(password);
368 password = (char *)vim_strsave((char_u *)NB_DEF_PASS);
369 }
370 if (hostname == NULL || address == NULL || password == NULL)
371 goto theend; /* out of memory */
372
373 #ifdef INET_SOCKETS
374 port = atoi(address);
375
376 if ((sd = (NBSOCK)socket(AF_INET, SOCK_STREAM, 0)) == (NBSOCK)-1)
377 {
378 nbdebug(("error in socket() in netbeans_connect()\n"));
379 PERROR("socket() in netbeans_connect()");
380 goto theend;
381 }
382
383 /* Get the server internet address and put into addr structure */
384 /* fill in the socket address structure and connect to server */
385 memset((char *)&server, '\0', sizeof(server));
386 server.sin_family = AF_INET;
387 server.sin_port = htons(port);
388 if ((host = gethostbyname(hostname)) == NULL)
389 {
390 if (mch_access(hostname, R_OK) >= 0)
391 {
392 /* DEBUG: input file */
393 sd = mch_open(hostname, O_RDONLY, 0);
394 goto theend;
395 }
396 nbdebug(("error in gethostbyname() in netbeans_connect()\n"));
397 PERROR("gethostbyname() in netbeans_connect()");
398 sd = -1;
399 goto theend;
400 }
401 memcpy((char *)&server.sin_addr, host->h_addr, host->h_length);
402 #else
403 if ((sd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1)
404 {
405 nbdebug(("error in socket() in netbeans_connect()\n"));
406 PERROR("socket() in netbeans_connect()");
407 goto theend;
408 }
409
410 server.sun_family = AF_UNIX;
411 strcpy(server.sun_path, address);
412 #endif
413 /* Connect to server */
414 if (connect(sd, (struct sockaddr *)&server, sizeof(server)))
415 {
416 nbdebug(("netbeans_connect: Connect failed with errno %d\n", sock_errno));
417 if (sock_errno == ECONNREFUSED)
418 {
419 sock_close(sd);
420 #ifdef INET_SOCKETS
421 if ((sd = (NBSOCK)socket(AF_INET, SOCK_STREAM, 0)) == (NBSOCK)-1)
422 {
423 nbdebug(("socket()#2 in netbeans_connect()\n"));
424 PERROR("socket()#2 in netbeans_connect()");
425 goto theend;
426 }
427 #else
428 if ((sd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1)
429 {
430 nbdebug(("socket()#2 in netbeans_connect()\n"));
431 PERROR("socket()#2 in netbeans_connect()");
432 goto theend;
433 }
434 #endif
435 if (connect(sd, (struct sockaddr *)&server, sizeof(server)))
436 {
437 int retries = 36;
438 int success = FALSE;
439 while (retries--
440 && ((sock_errno == ECONNREFUSED) || (sock_errno == EINTR)))
441 {
442 nbdebug(("retrying...\n"));
443 sleep(5);
444 if (connect(sd, (struct sockaddr *)&server,
445 sizeof(server)) == 0)
446 {
447 success = TRUE;
448 break;
449 }
450 }
451 if (!success)
452 {
453 /* Get here when the server can't be found. */
454 nbdebug(("Cannot connect to Netbeans #2\n"));
455 PERROR(_("Cannot connect to Netbeans #2"));
456 getout(1);
457 }
458 }
459
460 }
461 else
462 {
463 nbdebug(("Cannot connect to Netbeans\n"));
464 PERROR(_("Cannot connect to Netbeans"));
465 getout(1);
466 }
467 }
468
469 vim_snprintf(buf, sizeof(buf), "AUTH %s\n", password);
470 nb_send(buf, "netbeans_connect");
471
472 sprintf(buf, "0:version=0 \"%s\"\n", ExtEdProtocolVersion);
473 nb_send(buf, "externaleditor_version");
474
475 /* nb_init_graphics(); delay until needed */
476
477 haveConnection = TRUE;
478
479 theend:
480 vim_free(hostname);
481 vim_free(address);
482 vim_free(password);
483 return;
484 }
485
486 /*
487 * Obtain the NetBeans hostname, port address and password from a file.
488 * Return the strings in allocated memory.
489 * Return FAIL if the file could not be read, OK otherwise (no matter what it
490 * contains).
491 */
492 static int
493 getConnInfo(char *file, char **host, char **port, char **auth)
494 {
495 FILE *fp;
496 char_u buf[BUFSIZ];
497 char_u *lp;
498 char_u *nl;
499 #ifdef UNIX
500 struct stat st;
501
502 /*
503 * For Unix only accept the file when it's not accessible by others.
504 * The open will then fail if we don't own the file.
505 */
506 if (mch_stat(file, &st) == 0 && (st.st_mode & 0077) != 0)
507 {
508 nbdebug(("Wrong access mode for NetBeans connection info file: \"%s\"\n",
509 file));
510 EMSG2(_("E668: Wrong access mode for NetBeans connection info file: \"%s\""),
511 file);
512 return FAIL;
513 }
514 #endif
515
516 fp = mch_fopen(file, "r");
517 if (fp == NULL)
518 {
519 nbdebug(("Cannot open NetBeans connection info file\n"));
520 PERROR("E660: Cannot open NetBeans connection info file");
521 return FAIL;
522 }
523
524 /* Read the file. There should be one of each parameter */
525 while ((lp = (char_u *)fgets((char *)buf, BUFSIZ, fp)) != NULL)
526 {
527 if ((nl = vim_strchr(lp, '\n')) != NULL)
528 *nl = 0; /* strip off the trailing newline */
529
530 if (STRNCMP(lp, "host=", 5) == 0)
531 {
532 vim_free(*host);
533 *host = (char *)vim_strsave(&buf[5]);
534 }
535 else if (STRNCMP(lp, "port=", 5) == 0)
536 {
537 vim_free(*port);
538 *port = (char *)vim_strsave(&buf[5]);
539 }
540 else if (STRNCMP(lp, "auth=", 5) == 0)
541 {
542 vim_free(*auth);
543 *auth = (char *)vim_strsave(&buf[5]);
544 }
545 }
546 fclose(fp);
547
548 return OK;
549 }
550
551
552 struct keyqueue
553 {
554 char_u *keystr;
555 struct keyqueue *next;
556 struct keyqueue *prev;
557 };
558
559 typedef struct keyqueue keyQ_T;
560
561 static keyQ_T keyHead; /* dummy node, header for circular queue */
562
563
564 /*
565 * Queue up key commands sent from netbeans.
566 * We store the string, because it may depend on the global mod_mask and
567 * :nbkey doesn't have a key number.
568 */
569 static void
570 postpone_keycommand(char_u *keystr)
571 {
572 keyQ_T *node;
573
574 node = (keyQ_T *)alloc(sizeof(keyQ_T));
575 if (node == NULL)
576 return; /* out of memory, drop the key */
577
578 if (keyHead.next == NULL) /* initialize circular queue */
579 {
580 keyHead.next = &keyHead;
581 keyHead.prev = &keyHead;
582 }
583
584 /* insert node at tail of queue */
585 node->next = &keyHead;
586 node->prev = keyHead.prev;
587 keyHead.prev->next = node;
588 keyHead.prev = node;
589
590 node->keystr = vim_strsave(keystr);
591 }
592
593 /*
594 * Handle any queued-up NetBeans keycommands to be send.
595 */
596 static void
597 handle_key_queue(void)
598 {
599 int postponed = FALSE;
600
601 while (!postponed && keyHead.next && keyHead.next != &keyHead)
602 {
603 /* first, unlink the node */
604 keyQ_T *node = keyHead.next;
605 keyHead.next = node->next;
606 node->next->prev = node->prev;
607
608 /* Now, send the keycommand. This may cause it to be postponed again
609 * and change keyHead. */
610 if (node->keystr != NULL)
611 postponed = !netbeans_keystring(node->keystr);
612 vim_free(node->keystr);
613
614 /* Finally, dispose of the node */
615 vim_free(node);
616 }
617 }
618
619
620 struct cmdqueue
621 {
622 char_u *buffer;
623 struct cmdqueue *next;
624 struct cmdqueue *prev;
625 };
626
627 typedef struct cmdqueue queue_T;
628
629 static queue_T head; /* dummy node, header for circular queue */
630
631
632 /*
633 * Put the buffer on the work queue; possibly save it to a file as well.
634 */
635 static void
636 save(char_u *buf, int len)
637 {
638 queue_T *node;
639
640 node = (queue_T *)alloc(sizeof(queue_T));
641 if (node == NULL)
642 return; /* out of memory */
643 node->buffer = alloc(len + 1);
644 if (node->buffer == NULL)
645 {
646 vim_free(node);
647 return; /* out of memory */
648 }
649 mch_memmove(node->buffer, buf, (size_t)len);
650 node->buffer[len] = NUL;
651
652 if (head.next == NULL) /* initialize circular queue */
653 {
654 head.next = &head;
655 head.prev = &head;
656 }
657
658 /* insert node at tail of queue */
659 node->next = &head;
660 node->prev = head.prev;
661 head.prev->next = node;
662 head.prev = node;
663
664 #ifdef NBDEBUG
665 {
666 static int outfd = -2;
667
668 /* possibly write buffer out to a file */
669 if (outfd == -3)
670 return;
671
672 if (outfd == -2)
673 {
674 char *file = getenv("__NETBEANS_SAVE");
675 if (file == NULL)
676 outfd = -3;
677 else
678 outfd = mch_open(file, O_WRONLY|O_CREAT|O_TRUNC, 0666);
679 }
680
681 if (outfd >= 0)
682 write(outfd, buf, len);
683 }
684 #endif
685 }
686
687
688 /*
689 * While there's still a command in the work queue, parse and execute it.
690 */
691 void
692 netbeans_parse_messages(void)
693 {
694 char_u *p;
695 queue_T *node;
696
697 while (head.next != NULL && head.next != &head)
698 {
699 node = head.next;
700
701 /* Locate the first line in the first buffer. */
702 p = vim_strchr(node->buffer, '\n');
703 if (p == NULL)
704 {
705 /* Command isn't complete. If there is no following buffer,
706 * return (wait for more). If there is another buffer following,
707 * prepend the text to that buffer and delete this one. */
708 if (node->next == &head)
709 return;
710 p = alloc((unsigned)(STRLEN(node->buffer)
711 + STRLEN(node->next->buffer) + 1));
712 if (p == NULL)
713 return; /* out of memory */
714 STRCPY(p, node->buffer);
715 STRCAT(p, node->next->buffer);
716 vim_free(node->next->buffer);
717 node->next->buffer = p;
718
719 /* dispose of the node and buffer */
720 head.next = node->next;
721 node->next->prev = node->prev;
722 vim_free(node->buffer);
723 vim_free(node);
724 }
725 else
726 {
727 /* There is a complete command at the start of the buffer.
728 * Terminate it with a NUL. When no more text is following unlink
729 * the buffer. Do this before executing, because new buffers can
730 * be added while busy handling the command. */
731 *p++ = NUL;
732 if (*p == NUL)
733 {
734 head.next = node->next;
735 node->next->prev = node->prev;
736 }
737
738 /* now, parse and execute the commands */
739 nb_parse_cmd(node->buffer);
740
741 if (*p == NUL)
742 {
743 /* buffer finished, dispose of the node and buffer */
744 vim_free(node->buffer);
745 vim_free(node);
746 }
747 else
748 {
749 /* more follows, move to the start */
750 STRMOVE(node->buffer, p);
751 }
752 }
753 }
754 }
755
756 /* Buffer size for reading incoming messages. */
757 #define MAXMSGSIZE 4096
758
759 /*
760 * Read and process a command from netbeans.
761 */
762 #if defined(FEAT_GUI_W32) || defined(PROTO)
763 /* Use this one when generating prototypes, the others are static. */
764 void
765 messageFromNetbeansW32()
766 #endif
767 #ifdef FEAT_GUI_MOTIF
768 static void
769 messageFromNetbeans(XtPointer clientData UNUSED,
770 int *unused1 UNUSED,
771 XtInputId *unused2 UNUSED)
772 #endif
773 #ifdef FEAT_GUI_GTK
774 static void
775 messageFromNetbeans(gpointer clientData UNUSED,
776 gint unused1 UNUSED,
777 GdkInputCondition unused2 UNUSED)
778 #endif
779 #if defined(FEAT_GUI_MACVIM) || defined(PROTO)
780 void
781 messageFromNetbeansMacVim()
782 #endif
783 {
784 static char_u *buf = NULL;
785 int len;
786 int readlen = 0;
787 #ifndef FEAT_GUI_GTK
788 static int level = 0;
789 #endif
790 #ifdef HAVE_SELECT
791 struct timeval tval;
792 fd_set rfds;
793 #else
794 # ifdef HAVE_POLL
795 struct pollfd fds;
796 # endif
797 #endif
798
799 if (sd < 0)
800 {
801 nbdebug(("messageFromNetbeans() called without a socket\n"));
802 return;
803 }
804
805 #ifdef FEAT_GUI_MACVIM
806 /* It may happen that socket is not readable because socket has been already
807 * read by timing of CFRunLoop callback. So check socket using select. */
808 if (sock_select(sd) <= 0)
809 return;
810 #endif
811
812 #ifndef FEAT_GUI_GTK
813 ++level; /* recursion guard; this will be called from the X event loop */
814 #endif
815
816 /* Allocate a buffer to read into. */
817 if (buf == NULL)
818 {
819 buf = alloc(MAXMSGSIZE);
820 if (buf == NULL)
821 return; /* out of memory! */
822 }
823
824 /* Keep on reading for as long as there is something to read.
825 * Use select() or poll() to avoid blocking on a message that is exactly
826 * MAXMSGSIZE long. */
827 for (;;)
828 {
829 #ifdef HAVE_SELECT
830 FD_ZERO(&rfds);
831 FD_SET(sd, &rfds);
832 tval.tv_sec = 0;
833 tval.tv_usec = 0;
834 if (select(sd + 1, &rfds, NULL, NULL, &tval) <= 0)
835 break;
836 #else
837 # ifdef HAVE_POLL
838 fds.fd = sd;
839 fds.events = POLLIN;
840 if (poll(&fds, 1, 0) <= 0)
841 break;
842 # endif
843 #endif
844 len = sock_read(sd, buf, MAXMSGSIZE);
845 if (len <= 0)
846 break; /* error or nothing more to read */
847
848 /* Store the read message in the queue. */
849 save(buf, len);
850 readlen += len;
851 if (len < MAXMSGSIZE)
852 break; /* did read everything that's available */
853 }
854
855 if (readlen <= 0)
856 {
857 /* read error or didn't read anything */
858 netbeans_disconnect();
859 nbdebug(("messageFromNetbeans: Error in read() from socket\n"));
860 if (len < 0)
861 {
862 nbdebug(("read from Netbeans socket\n"));
863 PERROR(_("read from Netbeans socket"));
864 }
865 return; /* don't try to parse it */
866 }
867
868 #if defined(FEAT_GUI_GTK) || defined(FEAT_GUI_W32)
869 /* Let the main loop handle messages. */
870 # ifdef FEAT_GUI_GTK
871 if (gtk_main_level() > 0)
872 gtk_main_quit();
873 # endif
874 #else
875 /* Parse the messages now, but avoid recursion. */
876 if (level == 1)
877 netbeans_parse_messages();
878
879 --level;
880 #endif
881 }
882
883 /*
884 * Handle one NUL terminated command.
885 *
886 * format of a command from netbeans:
887 *
888 * 6:setTitle!84 "a.c"
889 *
890 * bufno
891 * colon
892 * cmd
893 * !
894 * cmdno
895 * args
896 *
897 * for function calls, the ! is replaced by a /
898 */
899 static void
900 nb_parse_cmd(char_u *cmd)
901 {
902 char *verb;
903 char *q;
904 int bufno;
905 int isfunc = -1;
906
907 if (STRCMP(cmd, "DISCONNECT") == 0)
908 {
909 /* We assume the server knows that we can safely exit! */
910 if (sd >= 0)
911 sock_close(sd);
912 /* Disconnect before exiting, Motif hangs in a Select error
913 * message otherwise. */
914 netbeans_disconnect();
915 getout(0);
916 /* NOTREACHED */
917 }
918
919 if (STRCMP(cmd, "DETACH") == 0)
920 {
921 /* The IDE is breaking the connection. */
922 if (sd >= 0)
923 sock_close(sd);
924 netbeans_disconnect();
925 return;
926 }
927
928 bufno = strtol((char *)cmd, &verb, 10);
929
930 if (*verb != ':')
931 {
932 nbdebug((" missing colon: %s\n", cmd));
933 EMSG2("E627: missing colon: %s", cmd);
934 return;
935 }
936 ++verb; /* skip colon */
937
938 for (q = verb; *q; q++)
939 {
940 if (*q == '!')
941 {
942 *q++ = NUL;
943 isfunc = 0;
944 break;
945 }
946 else if (*q == '/')
947 {
948 *q++ = NUL;
949 isfunc = 1;
950 break;
951 }
952 }
953
954 if (isfunc < 0)
955 {
956 nbdebug((" missing ! or / in: %s\n", cmd));
957 EMSG2("E628: missing ! or / in: %s", cmd);
958 return;
959 }
960
961 r_cmdno = strtol(q, &q, 10);
962
963 q = (char *)skipwhite((char_u *)q);
964
965 if (nb_do_cmd(bufno, (char_u *)verb, isfunc, r_cmdno, (char_u *)q) == FAIL)
966 {
967 #ifdef NBDEBUG
968 /*
969 * This happens because the ExtEd can send a command or 2 after
970 * doing a stopDocumentListen command. It doesn't harm anything
971 * so I'm disabling it except for debugging.
972 */
973 nbdebug(("nb_parse_cmd: Command error for \"%s\"\n", cmd));
974 EMSG("E629: bad return from nb_do_cmd");
975 #endif
976 }
977 }
978
979 struct nbbuf_struct
980 {
981 buf_T *bufp;
982 unsigned int fireChanges:1;
983 unsigned int initDone:1;
984 unsigned int insertDone:1;
985 unsigned int modified:1;
986 int nbbuf_number;
987 char *displayname;
988 int *signmap;
989 short_u signmaplen;
990 short_u signmapused;
991 };
992
993 typedef struct nbbuf_struct nbbuf_T;
994
995 static nbbuf_T *buf_list = 0;
996 static int buf_list_size = 0; /* size of buf_list */
997 static int buf_list_used = 0; /* nr of entries in buf_list actually in use */
998
999 static char **globalsignmap;
1000 static int globalsignmaplen;
1001 static int globalsignmapused;
1002
1003 static int mapsigntype __ARGS((nbbuf_T *, int localsigntype));
1004 static void addsigntype __ARGS((nbbuf_T *, int localsigntype, char_u *typeName,
1005 char_u *tooltip, char_u *glyphfile,
1006 int usefg, int fg, int usebg, int bg));
1007 static void print_read_msg __ARGS((nbbuf_T *buf));
1008 static void print_save_msg __ARGS((nbbuf_T *buf, long nchars));
1009
1010 static int curPCtype = -1;
1011
1012 /*
1013 * Get the Netbeans buffer number for the specified buffer.
1014 */
1015 static int
1016 nb_getbufno(buf_T *bufp)
1017 {
1018 int i;
1019
1020 for (i = 0; i < buf_list_used; i++)
1021 if (buf_list[i].bufp == bufp)
1022 return i;
1023 return -1;
1024 }
1025
1026 /*
1027 * Is this a NetBeans-owned buffer?
1028 */
1029 int
1030 isNetbeansBuffer(buf_T *bufp)
1031 {
1032 return usingNetbeans && bufp->b_netbeans_file;
1033 }
1034
1035 /*
1036 * NetBeans and Vim have different undo models. In Vim, the file isn't
1037 * changed if changes are undone via the undo command. In NetBeans, once
1038 * a change has been made the file is marked as modified until saved. It
1039 * doesn't matter if the change was undone.
1040 *
1041 * So this function is for the corner case where Vim thinks a buffer is
1042 * unmodified but NetBeans thinks it IS modified.
1043 */
1044 int
1045 isNetbeansModified(buf_T *bufp)
1046 {
1047 if (usingNetbeans && bufp->b_netbeans_file)
1048 {
1049 int bufno = nb_getbufno(bufp);
1050
1051 if (bufno > 0)
1052 return buf_list[bufno].modified;
1053 else
1054 return FALSE;
1055 }
1056 else
1057 return FALSE;
1058 }
1059
1060 /*
1061 * Given a Netbeans buffer number, return the netbeans buffer.
1062 * Returns NULL for 0 or a negative number. A 0 bufno means a
1063 * non-buffer related command has been sent.
1064 */
1065 static nbbuf_T *
1066 nb_get_buf(int bufno)
1067 {
1068 /* find or create a buffer with the given number */
1069 int incr;
1070
1071 if (bufno <= 0)
1072 return NULL;
1073
1074 if (!buf_list)
1075 {
1076 /* initialize */
1077 buf_list = (nbbuf_T *)alloc_clear(100 * sizeof(nbbuf_T));
1078 buf_list_size = 100;
1079 }
1080 if (bufno >= buf_list_used) /* new */
1081 {
1082 if (bufno >= buf_list_size) /* grow list */
1083 {
1084 incr = bufno - buf_list_size + 90;
1085 buf_list_size += incr;
1086 buf_list = (nbbuf_T *)vim_realloc(
1087 buf_list, buf_list_size * sizeof(nbbuf_T));
1088 memset(buf_list + buf_list_size - incr, 0, incr * sizeof(nbbuf_T));
1089 }
1090
1091 while (buf_list_used <= bufno)
1092 {
1093 /* Default is to fire text changes. */
1094 buf_list[buf_list_used].fireChanges = 1;
1095 ++buf_list_used;
1096 }
1097 }
1098
1099 return buf_list + bufno;
1100 }
1101
1102 /*
1103 * Return the number of buffers that are modified.
1104 */
1105 static int
1106 count_changed_buffers(void)
1107 {
1108 buf_T *bufp;
1109 int n;
1110
1111 n = 0;
1112 for (bufp = firstbuf; bufp != NULL; bufp = bufp->b_next)
1113 if (bufp->b_changed)
1114 ++n;
1115 return n;
1116 }
1117
1118 /*
1119 * End the netbeans session.
1120 */
1121 void
1122 netbeans_end(void)
1123 {
1124 int i;
1125 static char buf[128];
1126
1127 if (!haveConnection)
1128 return;
1129
1130 for (i = 0; i < buf_list_used; i++)
1131 {
1132 if (!buf_list[i].bufp)
1133 continue;
1134 if (netbeansForcedQuit)
1135 {
1136 /* mark as unmodified so NetBeans won't put up dialog on "killed" */
1137 sprintf(buf, "%d:unmodified=%d\n", i, r_cmdno);
1138 nbdebug(("EVT: %s", buf));
1139 nb_send(buf, "netbeans_end");
1140 }
1141 sprintf(buf, "%d:killed=%d\n", i, r_cmdno);
1142 nbdebug(("EVT: %s", buf));
1143 /* nb_send(buf, "netbeans_end"); avoid "write failed" messages */
1144 if (sd >= 0)
1145 ignored = sock_write(sd, buf, (int)STRLEN(buf));
1146 }
1147 }
1148
1149 /*
1150 * Send a message to netbeans.
1151 */
1152 static void
1153 nb_send(char *buf, char *fun)
1154 {
1155 /* Avoid giving pages full of error messages when the other side has
1156 * exited, only mention the first error until the connection works again. */
1157 static int did_error = FALSE;
1158
1159 if (sd < 0)
1160 {
1161 if (!did_error)
1162 {
1163 nbdebug((" %s(): write while not connected\n", fun));
1164 EMSG2("E630: %s(): write while not connected", fun);
1165 }
1166 did_error = TRUE;
1167 }
1168 else if (sock_write(sd, buf, (int)STRLEN(buf)) != (int)STRLEN(buf))
1169 {
1170 if (!did_error)
1171 {
1172 nbdebug((" %s(): write failed\n", fun));
1173 EMSG2("E631: %s(): write failed", fun);
1174 }
1175 did_error = TRUE;
1176 }
1177 else
1178 did_error = FALSE;
1179 }
1180
1181 /*
1182 * Some input received from netbeans requires a response. This function
1183 * handles a response with no information (except the command number).
1184 */
1185 static void
1186 nb_reply_nil(int cmdno)
1187 {
1188 char reply[32];
1189
1190 if (!haveConnection)
1191 return;
1192
1193 nbdebug(("REP %d: <none>\n", cmdno));
1194
1195 sprintf(reply, "%d\n", cmdno);
1196 nb_send(reply, "nb_reply_nil");
1197 }
1198
1199
1200 /*
1201 * Send a response with text.
1202 * "result" must have been quoted already (using nb_quote()).
1203 */
1204 static void
1205 nb_reply_text(int cmdno, char_u *result)
1206 {
1207 char_u *reply;
1208
1209 if (!haveConnection)
1210 return;
1211
1212 nbdebug(("REP %d: %s\n", cmdno, (char *)result));
1213
1214 reply = alloc((unsigned)STRLEN(result) + 32);
1215 sprintf((char *)reply, "%d %s\n", cmdno, (char *)result);
1216 nb_send((char *)reply, "nb_reply_text");
1217
1218 vim_free(reply);
1219 }
1220
1221
1222 /*
1223 * Send a response with a number result code.
1224 */
1225 static void
1226 nb_reply_nr(int cmdno, long result)
1227 {
1228 char reply[32];
1229
1230 if (!haveConnection)
1231 return;
1232
1233 nbdebug(("REP %d: %ld\n", cmdno, result));
1234
1235 sprintf(reply, "%d %ld\n", cmdno, result);
1236 nb_send(reply, "nb_reply_nr");
1237 }
1238
1239
1240 /*
1241 * Encode newline, ret, backslash, double quote for transmission to NetBeans.
1242 */
1243 static char_u *
1244 nb_quote(char_u *txt)
1245 {
1246 char_u *buf = alloc((unsigned)(2 * STRLEN(txt) + 1));
1247 char_u *p = txt;
1248 char_u *q = buf;
1249
1250 if (buf == NULL)
1251 return NULL;
1252 for (; *p; p++)
1253 {
1254 switch (*p)
1255 {
1256 case '\"':
1257 case '\\':
1258 *q++ = '\\'; *q++ = *p; break;
1259 /* case '\t': */
1260 /* *q++ = '\\'; *q++ = 't'; break; */
1261 case '\n':
1262 *q++ = '\\'; *q++ = 'n'; break;
1263 case '\r':
1264 *q++ = '\\'; *q++ = 'r'; break;
1265 default:
1266 *q++ = *p;
1267 break;
1268 }
1269 }
1270 *q = '\0';
1271
1272 return buf;
1273 }
1274
1275
1276 /*
1277 * Remove top level double quotes; convert backslashed chars.
1278 * Returns an allocated string (NULL for failure).
1279 * If "endp" is not NULL it is set to the character after the terminating
1280 * quote.
1281 */
1282 static char *
1283 nb_unquote(char_u *p, char_u **endp)
1284 {
1285 char *result = 0;
1286 char *q;
1287 int done = 0;
1288
1289 /* result is never longer than input */
1290 result = (char *)alloc_clear((unsigned)STRLEN(p) + 1);
1291 if (result == NULL)
1292 return NULL;
1293
1294 if (*p++ != '"')
1295 {
1296 nbdebug(("nb_unquote called with string that doesn't start with a quote!: %s\n",
1297 p));
1298 result[0] = NUL;
1299 return result;
1300 }
1301
1302 for (q = result; !done && *p != NUL;)
1303 {
1304 switch (*p)
1305 {
1306 case '"':
1307 /*
1308 * Unbackslashed dquote marks the end, if first char was dquote.
1309 */
1310 done = 1;
1311 break;
1312
1313 case '\\':
1314 ++p;
1315 switch (*p)
1316 {
1317 case '\\': *q++ = '\\'; break;
1318 case 'n': *q++ = '\n'; break;
1319 case 't': *q++ = '\t'; break;
1320 case 'r': *q++ = '\r'; break;
1321 case '"': *q++ = '"'; break;
1322 case NUL: --p; break;
1323 /* default: skip over illegal chars */
1324 }
1325 ++p;
1326 break;
1327
1328 default:
1329 *q++ = *p++;
1330 }
1331 }
1332
1333 if (endp != NULL)
1334 *endp = p;
1335
1336 return result;
1337 }
1338
1339 /*
1340 * Remove from "first" byte to "last" byte (inclusive), at line "lnum" of the
1341 * current buffer. Remove to end of line when "last" is MAXCOL.
1342 */
1343 static void
1344 nb_partialremove(linenr_T lnum, colnr_T first, colnr_T last)
1345 {
1346 char_u *oldtext, *newtext;
1347 int oldlen;
1348 int lastbyte = last;
1349
1350 oldtext = ml_get(lnum);
1351 oldlen = (int)STRLEN(oldtext);
1352 if (first >= (colnr_T)oldlen || oldlen == 0) /* just in case */
1353 return;
1354 if (lastbyte >= oldlen)
1355 lastbyte = oldlen - 1;
1356 newtext = alloc(oldlen - (int)(lastbyte - first));
1357 if (newtext != NULL)
1358 {
1359 mch_memmove(newtext, oldtext, first);
1360 STRMOVE(newtext + first, oldtext + lastbyte + 1);
1361 nbdebug((" NEW LINE %d: %s\n", lnum, newtext));
1362 ml_replace(lnum, newtext, FALSE);
1363 }
1364 }
1365
1366 /*
1367 * Replace the "first" line with the concatenation of the "first" and
1368 * the "other" line. The "other" line is not removed.
1369 */
1370 static void
1371 nb_joinlines(linenr_T first, linenr_T other)
1372 {
1373 int len_first, len_other;
1374 char_u *p;
1375
1376 len_first = (int)STRLEN(ml_get(first));
1377 len_other = (int)STRLEN(ml_get(other));
1378 p = alloc((unsigned)(len_first + len_other + 1));
1379 if (p != NULL)
1380 {
1381 mch_memmove(p, ml_get(first), len_first);
1382 mch_memmove(p + len_first, ml_get(other), len_other + 1);
1383 ml_replace(first, p, FALSE);
1384 }
1385 }
1386
1387 #define SKIP_STOP 2
1388 #define streq(a,b) (strcmp(a,b) == 0)
1389 static int needupdate = 0;
1390 static int inAtomic = 0;
1391
1392 /*
1393 * Do the actual processing of a single netbeans command or function.
1394 * The difference between a command and function is that a function
1395 * gets a response (it's required) but a command does not.
1396 * For arguments see comment for nb_parse_cmd().
1397 */
1398 static int
1399 nb_do_cmd(
1400 int bufno,
1401 char_u *cmd,
1402 int func,
1403 int cmdno,
1404 char_u *args) /* points to space before arguments or NUL */
1405 {
1406 int doupdate = 0;
1407 long off = 0;
1408 nbbuf_T *buf = nb_get_buf(bufno);
1409 static int skip = 0;
1410 int retval = OK;
1411 char *cp; /* for when a char pointer is needed */
1412
1413 nbdebug(("%s %d: (%d) %s %s\n", (func) ? "FUN" : "CMD", cmdno, bufno, cmd,
1414 STRCMP(cmd, "insert") == 0 ? "<text>" : (char *)args));
1415
1416 if (func)
1417 {
1418 /* =====================================================================*/
1419 if (streq((char *)cmd, "getModified"))
1420 {
1421 if (buf == NULL || buf->bufp == NULL)
1422 /* Return the number of buffers that are modified. */
1423 nb_reply_nr(cmdno, (long)count_changed_buffers());
1424 else
1425 /* Return whether the buffer is modified. */
1426 nb_reply_nr(cmdno, (long)(buf->bufp->b_changed
1427 || isNetbeansModified(buf->bufp)));
1428 /* =====================================================================*/
1429 }
1430 else if (streq((char *)cmd, "saveAndExit"))
1431 {
1432 /* Note: this will exit Vim if successful. */
1433 coloncmd(":confirm qall");
1434
1435 /* We didn't exit: return the number of changed buffers. */
1436 nb_reply_nr(cmdno, (long)count_changed_buffers());
1437 /* =====================================================================*/
1438 }
1439 else if (streq((char *)cmd, "getCursor"))
1440 {
1441 char_u text[200];
1442
1443 /* Note: nb_getbufno() may return -1. This indicates the IDE
1444 * didn't assign a number to the current buffer in response to a
1445 * fileOpened event. */
1446 sprintf((char *)text, "%d %ld %d %ld",
1447 nb_getbufno(curbuf),
1448 (long)curwin->w_cursor.lnum,
1449 (int)curwin->w_cursor.col,
1450 pos2off(curbuf, &curwin->w_cursor));
1451 nb_reply_text(cmdno, text);
1452 /* =====================================================================*/
1453 }
1454 else if (streq((char *)cmd, "getAnno"))
1455 {
1456 long linenum = 0;
1457 #ifdef FEAT_SIGNS
1458 if (buf == NULL || buf->bufp == NULL)
1459 {
1460 nbdebug((" Invalid buffer identifier in getAnno\n"));
1461 EMSG("E652: Invalid buffer identifier in getAnno");
1462 retval = FAIL;
1463 }
1464 else
1465 {
1466 int serNum;
1467
1468 cp = (char *)args;
1469 serNum = strtol(cp, &cp, 10);
1470 /* If the sign isn't found linenum will be zero. */
1471 linenum = (long)buf_findsign(buf->bufp, serNum);
1472 }
1473 #endif
1474 nb_reply_nr(cmdno, linenum);
1475 /* =====================================================================*/
1476 }
1477 else if (streq((char *)cmd, "getLength"))
1478 {
1479 long len = 0;
1480
1481 if (buf == NULL || buf->bufp == NULL)
1482 {
1483 nbdebug((" invalid buffer identifier in getLength\n"));
1484 EMSG("E632: invalid buffer identifier in getLength");
1485 retval = FAIL;
1486 }
1487 else
1488 {
1489 len = get_buf_size(buf->bufp);
1490 }
1491 nb_reply_nr(cmdno, len);
1492 /* =====================================================================*/
1493 }
1494 else if (streq((char *)cmd, "getText"))
1495 {
1496 long len;
1497 linenr_T nlines;
1498 char_u *text = NULL;
1499 linenr_T lno = 1;
1500 char_u *p;
1501 char_u *line;
1502
1503 if (buf == NULL || buf->bufp == NULL)
1504 {
1505 nbdebug((" invalid buffer identifier in getText\n"));
1506 EMSG("E633: invalid buffer identifier in getText");
1507 retval = FAIL;
1508 }
1509 else
1510 {
1511 len = get_buf_size(buf->bufp);
1512 nlines = buf->bufp->b_ml.ml_line_count;
1513 text = alloc((unsigned)((len > 0)
1514 ? ((len + nlines) * 2) : 4));
1515 if (text == NULL)
1516 {
1517 nbdebug((" nb_do_cmd: getText has null text field\n"));
1518 retval = FAIL;
1519 }
1520 else
1521 {
1522 p = text;
1523 *p++ = '\"';
1524 for (; lno <= nlines ; lno++)
1525 {
1526 line = nb_quote(ml_get_buf(buf->bufp, lno, FALSE));
1527 if (line != NULL)
1528 {
1529 STRCPY(p, line);
1530 p += STRLEN(line);
1531 *p++ = '\\';
1532 *p++ = 'n';
1533 vim_free(line);
1534 }
1535 }
1536 *p++ = '\"';
1537 *p = '\0';
1538 }
1539 }
1540 if (text == NULL)
1541 nb_reply_text(cmdno, (char_u *)"");
1542 else
1543 {
1544 nb_reply_text(cmdno, text);
1545 vim_free(text);
1546 }
1547 /* =====================================================================*/
1548 }
1549 else if (streq((char *)cmd, "remove"))
1550 {
1551 long count;
1552 pos_T first, last;
1553 pos_T *pos;
1554 pos_T *next;
1555 linenr_T del_from_lnum, del_to_lnum; /* lines to be deleted as a whole */
1556 int oldFire = netbeansFireChanges;
1557 int oldSuppress = netbeansSuppressNoLines;
1558 int wasChanged;
1559
1560 if (skip >= SKIP_STOP)
1561 {
1562 nbdebug((" Skipping %s command\n", (char *) cmd));
1563 nb_reply_nil(cmdno);
1564 return OK;
1565 }
1566
1567 if (buf == NULL || buf->bufp == NULL)
1568 {
1569 nbdebug((" invalid buffer identifier in remove\n"));
1570 EMSG("E634: invalid buffer identifier in remove");
1571 retval = FAIL;
1572 }
1573 else
1574 {
1575 netbeansFireChanges = FALSE;
1576 netbeansSuppressNoLines = TRUE;
1577
1578 nb_set_curbuf(buf->bufp);
1579 wasChanged = buf->bufp->b_changed;
1580 cp = (char *)args;
1581 off = strtol(cp, &cp, 10);
1582 count = strtol(cp, &cp, 10);
1583 args = (char_u *)cp;
1584 /* delete "count" chars, starting at "off" */
1585 pos = off2pos(buf->bufp, off);
1586 if (!pos)
1587 {
1588 nbdebug((" !bad position\n"));
1589 nb_reply_text(cmdno, (char_u *)"!bad position");
1590 netbeansFireChanges = oldFire;
1591 netbeansSuppressNoLines = oldSuppress;
1592 return FAIL;
1593 }
1594 first = *pos;
1595 nbdebug((" FIRST POS: line %d, col %d\n",
1596 first.lnum, first.col));
1597 pos = off2pos(buf->bufp, off+count-1);
1598 if (!pos)
1599 {
1600 nbdebug((" !bad count\n"));
1601 nb_reply_text(cmdno, (char_u *)"!bad count");
1602 netbeansFireChanges = oldFire;
1603 netbeansSuppressNoLines = oldSuppress;
1604 return FAIL;
1605 }
1606 last = *pos;
1607 nbdebug((" LAST POS: line %d, col %d\n",
1608 last.lnum, last.col));
1609 del_from_lnum = first.lnum;
1610 del_to_lnum = last.lnum;
1611 doupdate = 1;
1612
1613 /* Get the position of the first byte after the deleted
1614 * section. "next" is NULL when deleting to the end of the
1615 * file. */
1616 next = off2pos(buf->bufp, off + count);
1617
1618 /* Remove part of the first line. */
1619 if (first.col != 0
1620 || (next != NULL && first.lnum == next->lnum))
1621 {
1622 if (first.lnum != last.lnum
1623 || (next != NULL && first.lnum != next->lnum))
1624 {
1625 /* remove to the end of the first line */
1626 nb_partialremove(first.lnum, first.col,
1627 (colnr_T)MAXCOL);
1628 if (first.lnum == last.lnum)
1629 {
1630 /* Partial line to remove includes the end of
1631 * line. Join the line with the next one, have
1632 * the next line deleted below. */
1633 nb_joinlines(first.lnum, next->lnum);
1634 del_to_lnum = next->lnum;
1635 }
1636 }
1637 else
1638 {
1639 /* remove within one line */
1640 nb_partialremove(first.lnum, first.col, last.col);
1641 }
1642 ++del_from_lnum; /* don't delete the first line */
1643 }
1644
1645 /* Remove part of the last line. */
1646 if (first.lnum != last.lnum && next != NULL
1647 && next->col != 0 && last.lnum == next->lnum)
1648 {
1649 nb_partialremove(last.lnum, 0, last.col);
1650 if (del_from_lnum > first.lnum)
1651 {
1652 /* Join end of last line to start of first line; last
1653 * line is deleted below. */
1654 nb_joinlines(first.lnum, last.lnum);
1655 }
1656 else
1657 /* First line is deleted as a whole, keep the last
1658 * line. */
1659 --del_to_lnum;
1660 }
1661
1662 /* First is partial line; last line to remove includes
1663 * the end of line; join first line to line following last
1664 * line; line following last line is deleted below. */
1665 if (first.lnum != last.lnum && del_from_lnum > first.lnum
1666 && next != NULL && last.lnum != next->lnum)
1667 {
1668 nb_joinlines(first.lnum, next->lnum);
1669 del_to_lnum = next->lnum;
1670 }
1671
1672 /* Delete whole lines if there are any. */
1673 if (del_to_lnum >= del_from_lnum)
1674 {
1675 int i;
1676
1677 /* delete signs from the lines being deleted */
1678 for (i = del_from_lnum; i <= del_to_lnum; i++)
1679 {
1680 int id = buf_findsign_id(buf->bufp, (linenr_T)i);
1681 if (id > 0)
1682 {
1683 nbdebug((" Deleting sign %d on line %d\n",
1684 id, i));
1685 buf_delsign(buf->bufp, id);
1686 }
1687 else
1688 {
1689 nbdebug((" No sign on line %d\n", i));
1690 }
1691 }
1692
1693 nbdebug((" Deleting lines %d through %d\n",
1694 del_from_lnum, del_to_lnum));
1695 curwin->w_cursor.lnum = del_from_lnum;
1696 curwin->w_cursor.col = 0;
1697 del_lines(del_to_lnum - del_from_lnum + 1, FALSE);
1698 }
1699
1700 /* Leave cursor at first deleted byte. */
1701 curwin->w_cursor = first;
1702 check_cursor_lnum();
1703 buf->bufp->b_changed = wasChanged; /* logically unchanged */
1704 netbeansFireChanges = oldFire;
1705 netbeansSuppressNoLines = oldSuppress;
1706
1707 u_blockfree(buf->bufp);
1708 u_clearall(buf->bufp);
1709 }
1710 nb_reply_nil(cmdno);
1711 /* =====================================================================*/
1712 }
1713 else if (streq((char *)cmd, "insert"))
1714 {
1715 char_u *to_free;
1716
1717 if (skip >= SKIP_STOP)
1718 {
1719 nbdebug((" Skipping %s command\n", (char *) cmd));
1720 nb_reply_nil(cmdno);
1721 return OK;
1722 }
1723
1724 /* get offset */
1725 cp = (char *)args;
1726 off = strtol(cp, &cp, 10);
1727 args = (char_u *)cp;
1728
1729 /* get text to be inserted */
1730 args = skipwhite(args);
1731 args = to_free = (char_u *)nb_unquote(args, NULL);
1732 /*
1733 nbdebug((" CHUNK[%d]: %d bytes at offset %d\n",
1734 buf->bufp->b_ml.ml_line_count, STRLEN(args), off));
1735 */
1736
1737 if (buf == NULL || buf->bufp == NULL)
1738 {
1739 nbdebug((" invalid buffer identifier in insert\n"));
1740 EMSG("E635: invalid buffer identifier in insert");
1741 retval = FAIL;
1742 }
1743 else if (args != NULL)
1744 {
1745 int ff_detected = EOL_UNKNOWN;
1746 int buf_was_empty = (buf->bufp->b_ml.ml_flags & ML_EMPTY);
1747 size_t len = 0;
1748 int added = 0;
1749 int oldFire = netbeansFireChanges;
1750 int old_b_changed;
1751 char_u *nl;
1752 linenr_T lnum;
1753 linenr_T lnum_start;
1754 pos_T *pos;
1755
1756 netbeansFireChanges = 0;
1757
1758 /* Jump to the buffer where we insert. After this "curbuf"
1759 * can be used. */
1760 nb_set_curbuf(buf->bufp);
1761 old_b_changed = curbuf->b_changed;
1762
1763 /* Convert the specified character offset into a lnum/col
1764 * position. */
1765 pos = off2pos(curbuf, off);
1766 if (pos != NULL)
1767 {
1768 if (pos->lnum <= 0)
1769 lnum_start = 1;
1770 else
1771 lnum_start = pos->lnum;
1772 }
1773 else
1774 {
1775 /* If the given position is not found, assume we want
1776 * the end of the file. See setLocAndSize HACK. */
1777 if (buf_was_empty)
1778 lnum_start = 1; /* above empty line */
1779 else
1780 lnum_start = curbuf->b_ml.ml_line_count + 1;
1781 }
1782
1783 /* "lnum" is the line where we insert: either append to it or
1784 * insert a new line above it. */
1785 lnum = lnum_start;
1786
1787 /* Loop over the "\n" separated lines of the argument. */
1788 doupdate = 1;
1789 while (*args != NUL)
1790 {
1791 nl = vim_strchr(args, '\n');
1792 if (nl == NULL)
1793 {
1794 /* Incomplete line, probably truncated. Next "insert"
1795 * command should append to this one. */
1796 len = STRLEN(args);
1797 }
1798 else
1799 {
1800 len = nl - args;
1801
1802 /*
1803 * We need to detect EOL style, because the commands
1804 * use a character offset.
1805 */
1806 if (nl > args && nl[-1] == '\r')
1807 {
1808 ff_detected = EOL_DOS;
1809 --len;
1810 }
1811 else
1812 ff_detected = EOL_UNIX;
1813 }
1814 args[len] = NUL;
1815
1816 if (lnum == lnum_start
1817 && ((pos != NULL && pos->col > 0)
1818 || (lnum == 1 && buf_was_empty)))
1819 {
1820 char_u *oldline = ml_get(lnum);
1821 char_u *newline;
1822
1823 /* Insert halfway a line. For simplicity we assume we
1824 * need to append to the line. */
1825 newline = alloc_check((unsigned)(STRLEN(oldline) + len + 1));
1826 if (newline != NULL)
1827 {
1828 STRCPY(newline, oldline);
1829 STRCAT(newline, args);
1830 ml_replace(lnum, newline, FALSE);
1831 }
1832 }
1833 else
1834 {
1835 /* Append a new line. Not that we always do this,
1836 * also when the text doesn't end in a "\n". */
1837 ml_append((linenr_T)(lnum - 1), args, (colnr_T)(len + 1), FALSE);
1838 ++added;
1839 }
1840
1841 if (nl == NULL)
1842 break;
1843 ++lnum;
1844 args = nl + 1;
1845 }
1846
1847 /* Adjust the marks below the inserted lines. */
1848 appended_lines_mark(lnum_start - 1, (long)added);
1849
1850 /*
1851 * When starting with an empty buffer set the fileformat.
1852 * This is just guessing...
1853 */
1854 if (buf_was_empty)
1855 {
1856 if (ff_detected == EOL_UNKNOWN)
1857 #if defined(MSDOS) || defined(MSWIN) || defined(OS2)
1858 ff_detected = EOL_DOS;
1859 #else
1860 ff_detected = EOL_UNIX;
1861 #endif
1862 set_fileformat(ff_detected, OPT_LOCAL);
1863 curbuf->b_start_ffc = *curbuf->b_p_ff;
1864 }
1865
1866 /*
1867 * XXX - GRP - Is the next line right? If I've inserted
1868 * text the buffer has been updated but not written. Will
1869 * netbeans guarantee to write it? Even if I do a :q! ?
1870 */
1871 curbuf->b_changed = old_b_changed; /* logically unchanged */
1872 netbeansFireChanges = oldFire;
1873
1874 /* Undo info is invalid now... */
1875 u_blockfree(curbuf);
1876 u_clearall(curbuf);
1877 }
1878 vim_free(to_free);
1879 nb_reply_nil(cmdno); /* or !error */
1880 }
1881 else
1882 {
1883 nbdebug(("UNIMPLEMENTED FUNCTION: %s\n", cmd));
1884 nb_reply_nil(cmdno);
1885 retval = FAIL;
1886 }
1887 }
1888 else /* Not a function; no reply required. */
1889 {
1890 /* =====================================================================*/
1891 if (streq((char *)cmd, "create"))
1892 {
1893 /* Create a buffer without a name. */
1894 if (buf == NULL)
1895 {
1896 nbdebug((" invalid buffer identifier in create\n"));
1897 EMSG("E636: invalid buffer identifier in create");
1898 return FAIL;
1899 }
1900 vim_free(buf->displayname);
1901 buf->displayname = NULL;
1902
1903 netbeansReadFile = 0; /* don't try to open disk file */
1904 do_ecmd(0, NULL, 0, 0, ECMD_ONE, ECMD_HIDE + ECMD_OLDBUF, curwin);
1905 netbeansReadFile = 1;
1906 buf->bufp = curbuf;
1907 maketitle();
1908 buf->insertDone = FALSE;
1909 gui_update_menus(0);
1910 /* =====================================================================*/
1911 }
1912 else if (streq((char *)cmd, "insertDone"))
1913 {
1914 if (buf == NULL || buf->bufp == NULL)
1915 {
1916 nbdebug((" invalid buffer identifier in insertDone\n"));
1917 }
1918 else
1919 {
1920 buf->bufp->b_start_eol = *args == 'T';
1921 buf->insertDone = TRUE;
1922 args += 2;
1923 buf->bufp->b_p_ro = *args == 'T';
1924 print_read_msg(buf);
1925 }
1926 /* =====================================================================*/
1927 }
1928 else if (streq((char *)cmd, "saveDone"))
1929 {
1930 long savedChars = atol((char *)args);
1931
1932 if (buf == NULL || buf->bufp == NULL)
1933 {
1934 nbdebug((" invalid buffer identifier in saveDone\n"));
1935 }
1936 else
1937 print_save_msg(buf, savedChars);
1938 /* =====================================================================*/
1939 }
1940 else if (streq((char *)cmd, "startDocumentListen"))
1941 {
1942 if (buf == NULL)
1943 {
1944 nbdebug((" invalid buffer identifier in startDocumentListen\n"));
1945 EMSG("E637: invalid buffer identifier in startDocumentListen");
1946 return FAIL;
1947 }
1948 buf->fireChanges = 1;
1949 /* =====================================================================*/
1950 }
1951 else if (streq((char *)cmd, "stopDocumentListen"))
1952 {
1953 if (buf == NULL)
1954 {
1955 nbdebug((" invalid buffer identifier in stopDocumentListen\n"));
1956 EMSG("E638: invalid buffer identifier in stopDocumentListen");
1957 return FAIL;
1958 }
1959 buf->fireChanges = 0;
1960 if (buf->bufp != NULL && buf->bufp->b_was_netbeans_file)
1961 {
1962 if (!buf->bufp->b_netbeans_file)
1963 {
1964 nbdebug(("E658: NetBeans connection lost for buffer %ld\n", buf->bufp->b_fnum));
1965 EMSGN(_("E658: NetBeans connection lost for buffer %ld"),
1966 buf->bufp->b_fnum);
1967 }
1968 else
1969 {
1970 /* NetBeans uses stopDocumentListen when it stops editing
1971 * a file. It then expects the buffer in Vim to
1972 * disappear. */
1973 do_bufdel(DOBUF_DEL, (char_u *)"", 1,
1974 buf->bufp->b_fnum, buf->bufp->b_fnum, TRUE);
1975 vim_memset(buf, 0, sizeof(nbbuf_T));
1976 }
1977 }
1978 /* =====================================================================*/
1979 }
1980 else if (streq((char *)cmd, "setTitle"))
1981 {
1982 if (buf == NULL)
1983 {
1984 nbdebug((" invalid buffer identifier in setTitle\n"));
1985 EMSG("E639: invalid buffer identifier in setTitle");
1986 return FAIL;
1987 }
1988 vim_free(buf->displayname);
1989 buf->displayname = nb_unquote(args, NULL);
1990 /* =====================================================================*/
1991 }
1992 else if (streq((char *)cmd, "initDone"))
1993 {
1994 if (buf == NULL || buf->bufp == NULL)
1995 {
1996 nbdebug((" invalid buffer identifier in initDone\n"));
1997 EMSG("E640: invalid buffer identifier in initDone");
1998 return FAIL;
1999 }
2000 doupdate = 1;
2001 buf->initDone = TRUE;
2002 nb_set_curbuf(buf->bufp);
2003 #if defined(FEAT_AUTOCMD)
2004 apply_autocmds(EVENT_BUFREADPOST, 0, 0, FALSE, buf->bufp);
2005 #endif
2006
2007 /* handle any postponed key commands */
2008 handle_key_queue();
2009 /* =====================================================================*/
2010 }
2011 else if (streq((char *)cmd, "setBufferNumber")
2012 || streq((char *)cmd, "putBufferNumber"))
2013 {
2014 char_u *path;
2015 buf_T *bufp;
2016
2017 if (buf == NULL)
2018 {
2019 nbdebug((" invalid buffer identifier in setBufferNumber\n"));
2020 EMSG("E641: invalid buffer identifier in setBufferNumber");
2021 return FAIL;
2022 }
2023 path = (char_u *)nb_unquote(args, NULL);
2024 if (path == NULL)
2025 return FAIL;
2026 bufp = buflist_findname(path);
2027 vim_free(path);
2028 if (bufp == NULL)
2029 {
2030 nbdebug((" File %s not found in setBufferNumber\n", args));
2031 EMSG2("E642: File %s not found in setBufferNumber", args);
2032 return FAIL;
2033 }
2034 buf->bufp = bufp;
2035 buf->nbbuf_number = bufp->b_fnum;
2036
2037 /* "setBufferNumber" has the side effect of jumping to the buffer
2038 * (don't know why!). Don't do that for "putBufferNumber". */
2039 if (*cmd != 'p')
2040 coloncmd(":buffer %d", bufp->b_fnum);
2041 else
2042 {
2043 buf->initDone = TRUE;
2044
2045 /* handle any postponed key commands */
2046 handle_key_queue();
2047 }
2048
2049 #if 0 /* never used */
2050 buf->internalname = (char *)alloc_clear(8);
2051 sprintf(buf->internalname, "<%d>", bufno);
2052 buf->netbeansOwns = 0;
2053 #endif
2054 /* =====================================================================*/
2055 }
2056 else if (streq((char *)cmd, "setFullName"))
2057 {
2058 if (buf == NULL)
2059 {
2060 nbdebug((" invalid buffer identifier in setFullName\n"));
2061 EMSG("E643: invalid buffer identifier in setFullName");
2062 return FAIL;
2063 }
2064 vim_free(buf->displayname);
2065 buf->displayname = nb_unquote(args, NULL);
2066
2067 netbeansReadFile = 0; /* don't try to open disk file */
2068 do_ecmd(0, (char_u *)buf->displayname, 0, 0, ECMD_ONE,
2069 ECMD_HIDE + ECMD_OLDBUF, curwin);
2070 netbeansReadFile = 1;
2071 buf->bufp = curbuf;
2072 maketitle();
2073 gui_update_menus(0);
2074 /* =====================================================================*/
2075 }
2076 else if (streq((char *)cmd, "editFile"))
2077 {
2078 if (buf == NULL)
2079 {
2080 nbdebug((" invalid buffer identifier in editFile\n"));
2081 EMSG("E644: invalid buffer identifier in editFile");
2082 return FAIL;
2083 }
2084 /* Edit a file: like create + setFullName + read the file. */
2085 vim_free(buf->displayname);
2086 buf->displayname = nb_unquote(args, NULL);
2087 do_ecmd(0, (char_u *)buf->displayname, NULL, NULL, ECMD_ONE,
2088 ECMD_HIDE + ECMD_OLDBUF, curwin);
2089 buf->bufp = curbuf;
2090 buf->initDone = TRUE;
2091 doupdate = 1;
2092 #if defined(FEAT_TITLE)
2093 maketitle();
2094 #endif
2095 gui_update_menus(0);
2096 /* =====================================================================*/
2097 }
2098 else if (streq((char *)cmd, "setVisible"))
2099 {
2100 if (buf == NULL || buf->bufp == NULL)
2101 {
2102 nbdebug((" invalid buffer identifier in setVisible\n"));
2103 /* This message was commented out, probably because it can
2104 * happen when shutting down. */
2105 if (p_verbose > 0)
2106 EMSG("E645: invalid buffer identifier in setVisible");
2107 return FAIL;
2108 }
2109 if (streq((char *)args, "T") && buf->bufp != curbuf)
2110 {
2111 exarg_T exarg;
2112 exarg.cmd = (char_u *)"goto";
2113 exarg.forceit = FALSE;
2114 dosetvisible = TRUE;
2115 goto_buffer(&exarg, DOBUF_FIRST, FORWARD, buf->bufp->b_fnum);
2116 doupdate = 1;
2117 dosetvisible = FALSE;
2118
2119 /* Side effect!!!. */
2120 if (!gui.starting)
2121 gui_mch_set_foreground();
2122 }
2123 /* =====================================================================*/
2124 }
2125 else if (streq((char *)cmd, "raise"))
2126 {
2127 /* Bring gvim to the foreground. */
2128 if (!gui.starting)
2129 gui_mch_set_foreground();
2130 /* =====================================================================*/
2131 }
2132 else if (streq((char *)cmd, "setModified"))
2133 {
2134 int prev_b_changed;
2135
2136 if (buf == NULL || buf->bufp == NULL)
2137 {
2138 nbdebug((" invalid buffer identifier in setModified\n"));
2139 /* This message was commented out, probably because it can
2140 * happen when shutting down. */
2141 if (p_verbose > 0)
2142 EMSG("E646: invalid buffer identifier in setModified");
2143 return FAIL;
2144 }
2145 prev_b_changed = buf->bufp->b_changed;
2146 if (streq((char *)args, "T"))
2147 buf->bufp->b_changed = TRUE;
2148 else
2149 {
2150 struct stat st;
2151
2152 /* Assume NetBeans stored the file. Reset the timestamp to
2153 * avoid "file changed" warnings. */
2154 if (buf->bufp->b_ffname != NULL
2155 && mch_stat((char *)buf->bufp->b_ffname, &st) >= 0)
2156 buf_store_time(buf->bufp, &st, buf->bufp->b_ffname);
2157 buf->bufp->b_changed = FALSE;
2158 }
2159 buf->modified = buf->bufp->b_changed;
2160 if (prev_b_changed != buf->bufp->b_changed)
2161 {
2162 #ifdef FEAT_WINDOWS
2163 check_status(buf->bufp);
2164 redraw_tabline = TRUE;
2165 #endif
2166 #ifdef FEAT_TITLE
2167 maketitle();
2168 #endif
2169 update_screen(0);
2170 }
2171 /* =====================================================================*/
2172 }
2173 else if (streq((char *)cmd, "setModtime"))
2174 {
2175 if (buf == NULL || buf->bufp == NULL)
2176 nbdebug((" invalid buffer identifier in setModtime\n"));
2177 else
2178 buf->bufp->b_mtime = atoi((char *)args);
2179 /* =====================================================================*/
2180 }
2181 else if (streq((char *)cmd, "setReadOnly"))
2182 {
2183 if (buf == NULL || buf->bufp == NULL)
2184 nbdebug((" invalid buffer identifier in setReadOnly\n"));
2185 else if (streq((char *)args, "T"))
2186 buf->bufp->b_p_ro = TRUE;
2187 else
2188 buf->bufp->b_p_ro = FALSE;
2189 /* =====================================================================*/
2190 }
2191 else if (streq((char *)cmd, "setMark"))
2192 {
2193 /* not yet */
2194 /* =====================================================================*/
2195 }
2196 else if (streq((char *)cmd, "showBalloon"))
2197 {
2198 #if defined(FEAT_BEVAL)
2199 static char *text = NULL;
2200
2201 /*
2202 * Set up the Balloon Expression Evaluation area.
2203 * Ignore 'ballooneval' here.
2204 * The text pointer must remain valid for a while.
2205 */
2206 if (balloonEval != NULL)
2207 {
2208 vim_free(text);
2209 text = nb_unquote(args, NULL);
2210 if (text != NULL)
2211 gui_mch_post_balloon(balloonEval, (char_u *)text);
2212 }
2213 #endif
2214 /* =====================================================================*/
2215 }
2216 else if (streq((char *)cmd, "setDot"))
2217 {
2218 pos_T *pos;
2219 #ifdef NBDEBUG
2220 char_u *s;
2221 #endif
2222
2223 if (buf == NULL || buf->bufp == NULL)
2224 {
2225 nbdebug((" invalid buffer identifier in setDot\n"));
2226 EMSG("E647: invalid buffer identifier in setDot");
2227 return FAIL;
2228 }
2229
2230 nb_set_curbuf(buf->bufp);
2231
2232 #ifdef FEAT_VISUAL
2233 /* Don't want Visual mode now. */
2234 if (VIsual_active)
2235 end_visual_mode();
2236 #endif
2237 #ifdef NBDEBUG
2238 s = args;
2239 #endif
2240 pos = get_off_or_lnum(buf->bufp, &args);
2241 if (pos)
2242 {
2243 curwin->w_cursor = *pos;
2244 check_cursor();
2245 #ifdef FEAT_FOLDING
2246 foldOpenCursor();
2247 #endif
2248 }
2249 else
2250 {
2251 nbdebug((" BAD POSITION in setDot: %s\n", s));
2252 }
2253
2254 /* gui_update_cursor(TRUE, FALSE); */
2255 /* update_curbuf(NOT_VALID); */
2256 update_topline(); /* scroll to show the line */
2257 update_screen(VALID);
2258 setcursor();
2259 out_flush();
2260 gui_update_cursor(TRUE, FALSE);
2261 gui_mch_flush();
2262 /* Quit a hit-return or more prompt. */
2263 if (State == HITRETURN || State == ASKMORE)
2264 {
2265 #ifdef FEAT_GUI_GTK
2266 if (gtk_main_level() > 0)
2267 gtk_main_quit();
2268 #endif
2269 }
2270 /* =====================================================================*/
2271 }
2272 else if (streq((char *)cmd, "close"))
2273 {
2274 #ifdef NBDEBUG
2275 char *name = "<NONE>";
2276 #endif
2277
2278 if (buf == NULL)
2279 {
2280 nbdebug((" invalid buffer identifier in close\n"));
2281 EMSG("E648: invalid buffer identifier in close");
2282 return FAIL;
2283 }
2284
2285 #ifdef NBDEBUG
2286 if (buf->displayname != NULL)
2287 name = buf->displayname;
2288 #endif
2289 if (buf->bufp == NULL)
2290 {
2291 nbdebug((" invalid buffer identifier in close\n"));
2292 /* This message was commented out, probably because it can
2293 * happen when shutting down. */
2294 if (p_verbose > 0)
2295 EMSG("E649: invalid buffer identifier in close");
2296 }
2297 nbdebug((" CLOSE %d: %s\n", bufno, name));
2298 need_mouse_correct = TRUE;
2299 if (buf->bufp != NULL)
2300 do_buffer(DOBUF_WIPE, DOBUF_FIRST, FORWARD,
2301 buf->bufp->b_fnum, TRUE);
2302 buf->bufp = NULL;
2303 buf->initDone = FALSE;
2304 doupdate = 1;
2305 /* =====================================================================*/
2306 }
2307 else if (streq((char *)cmd, "setStyle")) /* obsolete... */
2308 {
2309 nbdebug((" setStyle is obsolete!\n"));
2310 /* =====================================================================*/
2311 }
2312 else if (streq((char *)cmd, "setExitDelay"))
2313 {
2314 /* Only used in version 2.1. */
2315 /* =====================================================================*/
2316 }
2317 else if (streq((char *)cmd, "defineAnnoType"))
2318 {
2319 #ifdef FEAT_SIGNS
2320 int typeNum;
2321 char_u *typeName;
2322 char_u *tooltip;
2323 char_u *p;
2324 char_u *glyphFile;
2325 int use_fg = 0;
2326 int use_bg = 0;
2327 int fg = -1;
2328 int bg = -1;
2329
2330 if (buf == NULL)
2331 {
2332 nbdebug((" invalid buffer identifier in defineAnnoType\n"));
2333 EMSG("E650: invalid buffer identifier in defineAnnoType");
2334 return FAIL;
2335 }
2336
2337 cp = (char *)args;
2338 typeNum = strtol(cp, &cp, 10);
2339 args = (char_u *)cp;
2340 args = skipwhite(args);
2341 typeName = (char_u *)nb_unquote(args, &args);
2342 args = skipwhite(args + 1);
2343 tooltip = (char_u *)nb_unquote(args, &args);
2344 args = skipwhite(args + 1);
2345
2346 p = (char_u *)nb_unquote(args, &args);
2347 glyphFile = vim_strsave_escaped(p, escape_chars);
2348 vim_free(p);
2349
2350 args = skipwhite(args + 1);
2351 if (STRNCMP(args, "none", 4) == 0)
2352 args += 5;
2353 else
2354 {
2355 use_fg = 1;
2356 cp = (char *)args;
2357 fg = strtol(cp, &cp, 10);
2358 args = (char_u *)cp;
2359 }
2360 if (STRNCMP(args, "none", 4) == 0)
2361 args += 5;
2362 else
2363 {
2364 use_bg = 1;
2365 cp = (char *)args;
2366 bg = strtol(cp, &cp, 10);
2367 args = (char_u *)cp;
2368 }
2369 if (typeName != NULL && tooltip != NULL && glyphFile != NULL)
2370 addsigntype(buf, typeNum, typeName, tooltip, glyphFile,
2371 use_fg, fg, use_bg, bg);
2372 else
2373 vim_free(typeName);
2374
2375 /* don't free typeName; it's used directly in addsigntype() */
2376 vim_free(tooltip);
2377 vim_free(glyphFile);
2378
2379 #endif
2380 /* =====================================================================*/
2381 }
2382 else if (streq((char *)cmd, "addAnno"))
2383 {
2384 #ifdef FEAT_SIGNS
2385 int serNum;
2386 int localTypeNum;
2387 int typeNum;
2388 pos_T *pos;
2389
2390 if (buf == NULL || buf->bufp == NULL)
2391 {
2392 nbdebug((" invalid buffer identifier in addAnno\n"));
2393 EMSG("E651: invalid buffer identifier in addAnno");
2394 return FAIL;
2395 }
2396
2397 doupdate = 1;
2398
2399 cp = (char *)args;
2400 serNum = strtol(cp, &cp, 10);
2401
2402 /* Get the typenr specific for this buffer and convert it to
2403 * the global typenumber, as used for the sign name. */
2404 localTypeNum = strtol(cp, &cp, 10);
2405 args = (char_u *)cp;
2406 typeNum = mapsigntype(buf, localTypeNum);
2407
2408 pos = get_off_or_lnum(buf->bufp, &args);
2409
2410 cp = (char *)args;
2411 ignored = (int)strtol(cp, &cp, 10);
2412 args = (char_u *)cp;
2413 # ifdef NBDEBUG
2414 if (ignored != -1)
2415 {
2416 nbdebug((" partial line annotation -- Not Yet Implemented!\n"));
2417 }
2418 # endif
2419 if (serNum >= GUARDEDOFFSET)
2420 {
2421 nbdebug((" too many annotations! ignoring...\n"));
2422 return FAIL;
2423 }
2424 if (pos)
2425 {
2426 coloncmd(":sign place %d line=%ld name=%d buffer=%d",
2427 serNum, pos->lnum, typeNum, buf->bufp->b_fnum);
2428 if (typeNum == curPCtype)
2429 coloncmd(":sign jump %d buffer=%d", serNum,
2430 buf->bufp->b_fnum);
2431 }
2432 #endif
2433 /* =====================================================================*/
2434 }
2435 else if (streq((char *)cmd, "removeAnno"))
2436 {
2437 #ifdef FEAT_SIGNS
2438 int serNum;
2439
2440 if (buf == NULL || buf->bufp == NULL)
2441 {
2442 nbdebug((" invalid buffer identifier in removeAnno\n"));
2443 return FAIL;
2444 }
2445 doupdate = 1;
2446 cp = (char *)args;
2447 serNum = strtol(cp, &cp, 10);
2448 args = (char_u *)cp;
2449 coloncmd(":sign unplace %d buffer=%d",
2450 serNum, buf->bufp->b_fnum);
2451 redraw_buf_later(buf->bufp, NOT_VALID);
2452 #endif
2453 /* =====================================================================*/
2454 }
2455 else if (streq((char *)cmd, "moveAnnoToFront"))
2456 {
2457 #ifdef FEAT_SIGNS
2458 nbdebug((" moveAnnoToFront: Not Yet Implemented!\n"));
2459 #endif
2460 /* =====================================================================*/
2461 }
2462 else if (streq((char *)cmd, "guard") || streq((char *)cmd, "unguard"))
2463 {
2464 int len;
2465 pos_T first;
2466 pos_T last;
2467 pos_T *pos;
2468 int un = (cmd[0] == 'u');
2469 static int guardId = GUARDEDOFFSET;
2470
2471 if (skip >= SKIP_STOP)
2472 {
2473 nbdebug((" Skipping %s command\n", (char *) cmd));
2474 return OK;
2475 }
2476
2477 nb_init_graphics();
2478
2479 if (buf == NULL || buf->bufp == NULL)
2480 {
2481 nbdebug((" invalid buffer identifier in %s command\n", cmd));
2482 return FAIL;
2483 }
2484 nb_set_curbuf(buf->bufp);
2485 cp = (char *)args;
2486 off = strtol(cp, &cp, 10);
2487 len = strtol(cp, NULL, 10);
2488 args = (char_u *)cp;
2489 pos = off2pos(buf->bufp, off);
2490 doupdate = 1;
2491 if (!pos)
2492 nbdebug((" no such start pos in %s, %ld\n", cmd, off));
2493 else
2494 {
2495 first = *pos;
2496 pos = off2pos(buf->bufp, off + len - 1);
2497 if (pos != NULL && pos->col == 0)
2498 {
2499 /*
2500 * In Java Swing the offset is a position between 2
2501 * characters. If col == 0 then we really want the
2502 * previous line as the end.
2503 */
2504 pos = off2pos(buf->bufp, off + len - 2);
2505 }
2506 if (!pos)
2507 nbdebug((" no such end pos in %s, %ld\n",
2508 cmd, off + len - 1));
2509 else
2510 {
2511 long lnum;
2512 last = *pos;
2513 /* set highlight for region */
2514 nbdebug((" %sGUARD %ld,%d to %ld,%d\n", (un) ? "UN" : "",
2515 first.lnum, first.col,
2516 last.lnum, last.col));
2517 #ifdef FEAT_SIGNS
2518 for (lnum = first.lnum; lnum <= last.lnum; lnum++)
2519 {
2520 if (un)
2521 {
2522 /* never used */
2523 }
2524 else
2525 {
2526 if (buf_findsigntype_id(buf->bufp, lnum,
2527 GUARDED) == 0)
2528 {
2529 coloncmd(
2530 ":sign place %d line=%ld name=%d buffer=%d",
2531 guardId++, lnum, GUARDED,
2532 buf->bufp->b_fnum);
2533 }
2534 }
2535 }
2536 #endif
2537 redraw_buf_later(buf->bufp, NOT_VALID);
2538 }
2539 }
2540 /* =====================================================================*/
2541 }
2542 else if (streq((char *)cmd, "startAtomic"))
2543 {
2544 inAtomic = 1;
2545 /* =====================================================================*/
2546 }
2547 else if (streq((char *)cmd, "endAtomic"))
2548 {
2549 inAtomic = 0;
2550 if (needupdate)
2551 {
2552 doupdate = 1;
2553 needupdate = 0;
2554 }
2555 /* =====================================================================*/
2556 }
2557 else if (streq((char *)cmd, "save"))
2558 {
2559 /*
2560 * NOTE - This command is obsolete wrt NetBeans. Its left in
2561 * only for historical reasons.
2562 */
2563 if (buf == NULL || buf->bufp == NULL)
2564 {
2565 nbdebug((" invalid buffer identifier in %s command\n", cmd));
2566 return FAIL;
2567 }
2568
2569 /* the following is taken from ex_cmds.c (do_wqall function) */
2570 if (bufIsChanged(buf->bufp))
2571 {
2572 /* Only write if the buffer can be written. */
2573 if (p_write
2574 && !buf->bufp->b_p_ro
2575 && buf->bufp->b_ffname != NULL
2576 #ifdef FEAT_QUICKFIX
2577 && !bt_dontwrite(buf->bufp)
2578 #endif
2579 )
2580 {
2581 buf_write_all(buf->bufp, FALSE);
2582 #ifdef FEAT_AUTOCMD
2583 /* an autocommand may have deleted the buffer */
2584 if (!buf_valid(buf->bufp))
2585 buf->bufp = NULL;
2586 #endif
2587 }
2588 }
2589 else
2590 {
2591 nbdebug((" Buffer has no changes!\n"));
2592 }
2593 /* =====================================================================*/
2594 }
2595 else if (streq((char *)cmd, "netbeansBuffer"))
2596 {
2597 if (buf == NULL || buf->bufp == NULL)
2598 {
2599 nbdebug((" invalid buffer identifier in %s command\n", cmd));
2600 return FAIL;
2601 }
2602 if (*args == 'T')
2603 {
2604 buf->bufp->b_netbeans_file = TRUE;
2605 buf->bufp->b_was_netbeans_file = TRUE;
2606 }
2607 else
2608 buf->bufp->b_netbeans_file = FALSE;
2609 /* =====================================================================*/
2610 }
2611 else if (streq((char *)cmd, "specialKeys"))
2612 {
2613 special_keys(args);
2614 /* =====================================================================*/
2615 }
2616 else if (streq((char *)cmd, "actionMenuItem"))
2617 {
2618 /* not used yet */
2619 /* =====================================================================*/
2620 }
2621 else if (streq((char *)cmd, "version"))
2622 {
2623 /* not used yet */
2624 }
2625 else
2626 {
2627 nbdebug(("Unrecognised command: %s\n", cmd));
2628 }
2629 /*
2630 * Unrecognized command is ignored.
2631 */
2632 }
2633 if (inAtomic && doupdate)
2634 {
2635 needupdate = 1;
2636 doupdate = 0;
2637 }
2638
2639 /*
2640 * Is this needed? I moved the netbeans_Xt_connect() later during startup
2641 * and it may no longer be necessary. If its not needed then needupdate
2642 * and doupdate can also be removed.
2643 */
2644 if (buf != NULL && buf->initDone && doupdate)
2645 {
2646 update_screen(NOT_VALID);
2647 setcursor();
2648 out_flush();
2649 gui_update_cursor(TRUE, FALSE);
2650 gui_mch_flush();
2651 /* Quit a hit-return or more prompt. */
2652 if (State == HITRETURN || State == ASKMORE)
2653 {
2654 #ifdef FEAT_GUI_GTK
2655 if (gtk_main_level() > 0)
2656 gtk_main_quit();
2657 #endif
2658 }
2659 }
2660
2661 return retval;
2662 }
2663
2664
2665 /*
2666 * If "buf" is not the current buffer try changing to a window that edits this
2667 * buffer. If there is no such window then close the current buffer and set
2668 * the current buffer as "buf".
2669 */
2670 static void
2671 nb_set_curbuf(buf_T *buf)
2672 {
2673 if (curbuf != buf && buf_jump_open_win(buf) == NULL)
2674 set_curbuf(buf, DOBUF_GOTO);
2675 }
2676
2677 /*
2678 * Process a vim colon command.
2679 */
2680 static void
2681 coloncmd(char *cmd, ...)
2682 {
2683 char buf[1024];
2684 va_list ap;
2685
2686 va_start(ap, cmd);
2687 vim_vsnprintf(buf, sizeof(buf), cmd, ap, NULL);
2688 va_end(ap);
2689
2690 nbdebug((" COLONCMD %s\n", buf));
2691
2692 /* ALT_INPUT_LOCK_ON; */
2693 do_cmdline((char_u *)buf, NULL, NULL, DOCMD_NOWAIT | DOCMD_KEYTYPED);
2694 /* ALT_INPUT_LOCK_OFF; */
2695
2696 setcursor(); /* restore the cursor position */
2697 out_flush(); /* make sure output has been written */
2698
2699 gui_update_cursor(TRUE, FALSE);
2700 gui_mch_flush();
2701 }
2702
2703
2704 /*
2705 * Parse the specialKeys argument and issue the appropriate map commands.
2706 */
2707 static void
2708 special_keys(char_u *args)
2709 {
2710 char *save_str = nb_unquote(args, NULL);
2711 char *tok = strtok(save_str, " ");
2712 char *sep;
2713 char keybuf[64];
2714 char cmdbuf[256];
2715
2716 while (tok != NULL)
2717 {
2718 int i = 0;
2719
2720 if ((sep = strchr(tok, '-')) != NULL)
2721 {
2722 *sep = NUL;
2723 while (*tok)
2724 {
2725 switch (*tok)
2726 {
2727 case 'A':
2728 case 'M':
2729 case 'C':
2730 case 'S':
2731 keybuf[i++] = *tok;
2732 keybuf[i++] = '-';
2733 break;
2734 }
2735 tok++;
2736 }
2737 tok++;
2738 }
2739
2740 strcpy(&keybuf[i], tok);
2741 vim_snprintf(cmdbuf, sizeof(cmdbuf),
2742 "<silent><%s> :nbkey %s<CR>", keybuf, keybuf);
2743 do_map(0, (char_u *)cmdbuf, NORMAL, FALSE);
2744 tok = strtok(NULL, " ");
2745 }
2746 vim_free(save_str);
2747 }
2748
2749
2750 void
2751 ex_nbkey(eap)
2752 exarg_T *eap;
2753 {
2754 (void)netbeans_keystring(eap->arg);
2755 }
2756
2757
2758 /*
2759 * Initialize highlights and signs for use by netbeans (mostly obsolete)
2760 */
2761 static void
2762 nb_init_graphics(void)
2763 {
2764 static int did_init = FALSE;
2765
2766 if (!did_init)
2767 {
2768 coloncmd(":highlight NBGuarded guibg=Cyan guifg=Black");
2769 coloncmd(":sign define %d linehl=NBGuarded", GUARDED);
2770
2771 did_init = TRUE;
2772 }
2773 }
2774
2775 /*
2776 * Convert key to netbeans name. This uses the global "mod_mask".
2777 */
2778 static void
2779 netbeans_keyname(int key, char *buf)
2780 {
2781 char *name = 0;
2782 char namebuf[2];
2783 int ctrl = 0;
2784 int shift = 0;
2785 int alt = 0;
2786
2787 if (mod_mask & MOD_MASK_CTRL)
2788 ctrl = 1;
2789 if (mod_mask & MOD_MASK_SHIFT)
2790 shift = 1;
2791 if (mod_mask & MOD_MASK_ALT)
2792 alt = 1;
2793
2794
2795 switch (key)
2796 {
2797 case K_F1: name = "F1"; break;
2798 case K_S_F1: name = "F1"; shift = 1; break;
2799 case K_F2: name = "F2"; break;
2800 case K_S_F2: name = "F2"; shift = 1; break;
2801 case K_F3: name = "F3"; break;
2802 case K_S_F3: name = "F3"; shift = 1; break;
2803 case K_F4: name = "F4"; break;
2804 case K_S_F4: name = "F4"; shift = 1; break;
2805 case K_F5: name = "F5"; break;
2806 case K_S_F5: name = "F5"; shift = 1; break;
2807 case K_F6: name = "F6"; break;
2808 case K_S_F6: name = "F6"; shift = 1; break;
2809 case K_F7: name = "F7"; break;
2810 case K_S_F7: name = "F7"; shift = 1; break;
2811 case K_F8: name = "F8"; break;
2812 case K_S_F8: name = "F8"; shift = 1; break;
2813 case K_F9: name = "F9"; break;
2814 case K_S_F9: name = "F9"; shift = 1; break;
2815 case K_F10: name = "F10"; break;
2816 case K_S_F10: name = "F10"; shift = 1; break;
2817 case K_F11: name = "F11"; break;
2818 case K_S_F11: name = "F11"; shift = 1; break;
2819 case K_F12: name = "F12"; break;
2820 case K_S_F12: name = "F12"; shift = 1; break;
2821 default:
2822 if (key >= ' ' && key <= '~')
2823 {
2824 /* Allow ASCII characters. */
2825 name = namebuf;
2826 namebuf[0] = key;
2827 namebuf[1] = NUL;
2828 }
2829 else
2830 name = "X";
2831 break;
2832 }
2833
2834 buf[0] = '\0';
2835 if (ctrl)
2836 strcat(buf, "C");
2837 if (shift)
2838 strcat(buf, "S");
2839 if (alt)
2840 strcat(buf, "M"); /* META */
2841 if (ctrl || shift || alt)
2842 strcat(buf, "-");
2843 strcat(buf, name);
2844 }
2845
2846 #ifdef FEAT_BEVAL
2847 /*
2848 * Function to be called for balloon evaluation. Grabs the text under the
2849 * cursor and sends it to the debugger for evaluation. The debugger should
2850 * respond with a showBalloon command when there is a useful result.
2851 */
2852 void
2853 netbeans_beval_cb(
2854 BalloonEval *beval,
2855 int state UNUSED)
2856 {
2857 win_T *wp;
2858 char_u *text;
2859 linenr_T lnum;
2860 int col;
2861 char buf[MAXPATHL * 2 + 25];
2862 char_u *p;
2863
2864 /* Don't do anything when 'ballooneval' is off, messages scrolled the
2865 * windows up or we have no connection. */
2866 if (!p_beval || msg_scrolled > 0 || !haveConnection)
2867 return;
2868
2869 if (get_beval_info(beval, TRUE, &wp, &lnum, &text, &col) == OK)
2870 {
2871 /* Send debugger request. Only when the text is of reasonable
2872 * length. */
2873 if (text != NULL && text[0] != NUL && STRLEN(text) < MAXPATHL)
2874 {
2875 p = nb_quote(text);
2876 if (p != NULL)
2877 {
2878 vim_snprintf(buf, sizeof(buf),
2879 "0:balloonText=%d \"%s\"\n", r_cmdno, p);
2880 vim_free(p);
2881 }
2882 nbdebug(("EVT: %s", buf));
2883 nb_send(buf, "netbeans_beval_cb");
2884 }
2885 vim_free(text);
2886 }
2887 }
2888 #endif
2889
2890 /*
2891 * Tell netbeans that the window was opened, ready for commands.
2892 */
2893 void
2894 netbeans_startup_done(void)
2895 {
2896 char *cmd = "0:startupDone=0\n";
2897
2898 if (usingNetbeans)
2899 #ifdef FEAT_GUI_MOTIF
2900 netbeans_Xt_connect(app_context);
2901 #else
2902 # ifdef FEAT_GUI_GTK
2903 netbeans_gtk_connect();
2904 # else
2905 # ifdef FEAT_GUI_W32
2906 netbeans_w32_connect();
2907 # else
2908 # ifdef FEAT_GUI_MACVIM
2909 netbeans_macvim_connect();
2910 # endif
2911 # endif
2912 # endif
2913 #endif
2914
2915 if (!haveConnection)
2916 return;
2917
2918 #ifdef FEAT_BEVAL
2919 bevalServers |= BEVAL_NETBEANS;
2920 #endif
2921
2922 nbdebug(("EVT: %s", cmd));
2923 nb_send(cmd, "netbeans_startup_done");
2924 }
2925
2926 /*
2927 * Tell netbeans that we're exiting. This should be called right
2928 * before calling exit.
2929 */
2930 void
2931 netbeans_send_disconnect()
2932 {
2933 char buf[128];
2934
2935 if (haveConnection)
2936 {
2937 sprintf(buf, "0:disconnect=%d\n", r_cmdno);
2938 nbdebug(("EVT: %s", buf));
2939 nb_send(buf, "netbeans_disconnect");
2940 }
2941 }
2942
2943 #if defined(FEAT_GUI_MOTIF) || defined(FEAT_GUI_W32) || defined(PROTO)
2944 /*
2945 * Tell netbeans that the window was moved or resized.
2946 */
2947 void
2948 netbeans_frame_moved(int new_x, int new_y)
2949 {
2950 char buf[128];
2951
2952 if (!haveConnection)
2953 return;
2954
2955 sprintf(buf, "0:geometry=%d %d %d %d %d\n",
2956 r_cmdno, (int)Columns, (int)Rows, new_x, new_y);
2957 /*nbdebug(("EVT: %s", buf)); happens too many times during a move */
2958 nb_send(buf, "netbeans_frame_moved");
2959 }
2960 #endif
2961
2962 /*
2963 * Tell netbeans the user opened or activated a file.
2964 */
2965 void
2966 netbeans_file_activated(buf_T *bufp)
2967 {
2968 int bufno = nb_getbufno(bufp);
2969 nbbuf_T *bp = nb_get_buf(bufno);
2970 char buffer[2*MAXPATHL];
2971 char_u *q;
2972
2973 if (!haveConnection || dosetvisible)
2974 return;
2975
2976 q = nb_quote(bufp->b_ffname);
2977 if (q == NULL || bp == NULL)
2978 return;
2979
2980 vim_snprintf(buffer, sizeof(buffer), "%d:fileOpened=%d \"%s\" %s %s\n",
2981 bufno,
2982 bufno,
2983 (char *)q,
2984 "T", /* open in NetBeans */
2985 "F"); /* modified */
2986
2987 vim_free(q);
2988 nbdebug(("EVT: %s", buffer));
2989
2990 nb_send(buffer, "netbeans_file_opened");
2991 }
2992
2993 /*
2994 * Tell netbeans the user opened a file.
2995 */
2996 void
2997 netbeans_file_opened(buf_T *bufp)
2998 {
2999 int bufno = nb_getbufno(bufp);
3000 char buffer[2*MAXPATHL];
3001 char_u *q;
3002 nbbuf_T *bp = nb_get_buf(nb_getbufno(bufp));
3003 int bnum;
3004
3005 if (!haveConnection)
3006 return;
3007
3008 q = nb_quote(bufp->b_ffname);
3009 if (q == NULL)
3010 return;
3011 if (bp != NULL)
3012 bnum = bufno;
3013 else
3014 bnum = 0;
3015
3016 vim_snprintf(buffer, sizeof(buffer), "%d:fileOpened=%d \"%s\" %s %s\n",
3017 bnum,
3018 0,
3019 (char *)q,
3020 "T", /* open in NetBeans */
3021 "F"); /* modified */
3022
3023 vim_free(q);
3024 nbdebug(("EVT: %s", buffer));
3025
3026 nb_send(buffer, "netbeans_file_opened");
3027 if (p_acd && vim_chdirfile(bufp->b_ffname) == OK)
3028 shorten_fnames(TRUE);
3029 }
3030
3031 /*
3032 * Tell netbeans that a file was deleted or wiped out.
3033 */
3034 void
3035 netbeans_file_killed(buf_T *bufp)
3036 {
3037 int bufno = nb_getbufno(bufp);
3038 nbbuf_T *nbbuf = nb_get_buf(bufno);
3039 char buffer[2*MAXPATHL];
3040
3041 if (!haveConnection || bufno == -1)
3042 return;
3043
3044 nbdebug(("netbeans_file_killed:\n"));
3045 nbdebug((" Killing bufno: %d", bufno));
3046
3047 sprintf(buffer, "%d:killed=%d\n", bufno, r_cmdno);
3048
3049 nbdebug(("EVT: %s", buffer));
3050
3051 nb_send(buffer, "netbeans_file_killed");
3052
3053 if (nbbuf != NULL)
3054 nbbuf->bufp = NULL;
3055 }
3056
3057 /*
3058 * Get a pointer to the Netbeans buffer for Vim buffer "bufp".
3059 * Return NULL if there is no such buffer or changes are not to be reported.
3060 * Otherwise store the buffer number in "*bufnop".
3061 */
3062 static nbbuf_T *
3063 nb_bufp2nbbuf_fire(buf_T *bufp, int *bufnop)
3064 {
3065 int bufno;
3066 nbbuf_T *nbbuf;
3067
3068 if (!haveConnection || !netbeansFireChanges)
3069 return NULL; /* changes are not reported at all */
3070
3071 bufno = nb_getbufno(bufp);
3072 if (bufno <= 0)
3073 return NULL; /* file is not known to NetBeans */
3074
3075 nbbuf = nb_get_buf(bufno);
3076 if (nbbuf != NULL && !nbbuf->fireChanges)
3077 return NULL; /* changes in this buffer are not reported */
3078
3079 *bufnop = bufno;
3080 return nbbuf;
3081 }
3082
3083 /*
3084 * Tell netbeans the user inserted some text.
3085 */
3086 void
3087 netbeans_inserted(
3088 buf_T *bufp,
3089 linenr_T linenr,
3090 colnr_T col,
3091 char_u *txt,
3092 int newlen)
3093 {
3094 char_u *buf;
3095 int bufno;
3096 nbbuf_T *nbbuf;
3097 pos_T pos;
3098 long off;
3099 char_u *p;
3100 char_u *newtxt;
3101
3102 nbbuf = nb_bufp2nbbuf_fire(bufp, &bufno);
3103 if (nbbuf == NULL)
3104 return;
3105
3106 /* Don't mark as modified for initial read */
3107 if (nbbuf->insertDone)
3108 nbbuf->modified = 1;
3109
3110 pos.lnum = linenr;
3111 pos.col = col;
3112 off = pos2off(bufp, &pos);
3113
3114 /* send the "insert" EVT */
3115 newtxt = alloc(newlen + 1);
3116 vim_strncpy(newtxt, txt, newlen);
3117 p = nb_quote(newtxt);
3118 if (p != NULL)
3119 {
3120 buf = alloc(128 + 2*newlen);
3121 sprintf((char *)buf, "%d:insert=%d %ld \"%s\"\n",
3122 bufno, r_cmdno, off, p);
3123 nbdebug(("EVT: %s", buf));
3124 nb_send((char *)buf, "netbeans_inserted");
3125 vim_free(p);
3126 vim_free(buf);
3127 }
3128 vim_free(newtxt);
3129 }
3130
3131 /*
3132 * Tell netbeans some bytes have been removed.
3133 */
3134 void
3135 netbeans_removed(
3136 buf_T *bufp,
3137 linenr_T linenr,
3138 colnr_T col,
3139 long len)
3140 {
3141 char_u buf[128];
3142 int bufno;
3143 nbbuf_T *nbbuf;
3144 pos_T pos;
3145 long off;
3146
3147 nbbuf = nb_bufp2nbbuf_fire(bufp, &bufno);
3148 if (nbbuf == NULL)
3149 return;
3150
3151 if (len < 0)
3152 {
3153 nbdebug(("Negative len %ld in netbeans_removed()!\n", len));
3154 return;
3155 }
3156
3157 nbbuf->modified = 1;
3158
3159 pos.lnum = linenr;
3160 pos.col = col;
3161
3162 off = pos2off(bufp, &pos);
3163
3164 sprintf((char *)buf, "%d:remove=%d %ld %ld\n", bufno, r_cmdno, off, len);
3165 nbdebug(("EVT: %s", buf));
3166 nb_send((char *)buf, "netbeans_removed");
3167 }
3168
3169 /*
3170 * Send netbeans an unmodified command.
3171 */
3172 void
3173 netbeans_unmodified(buf_T *bufp UNUSED)
3174 {
3175 #if 0
3176 char_u buf[128];
3177 int bufno;
3178 nbbuf_T *nbbuf;
3179
3180 /* This has been disabled, because NetBeans considers a buffer modified
3181 * even when all changes have been undone. */
3182 nbbuf = nb_bufp2nbbuf_fire(bufp, &bufno);
3183 if (nbbuf == NULL)
3184 return;
3185
3186 nbbuf->modified = 0;
3187
3188 sprintf((char *)buf, "%d:unmodified=%d\n", bufno, r_cmdno);
3189 nbdebug(("EVT: %s", buf));
3190 nb_send((char *)buf, "netbeans_unmodified");
3191 #endif
3192 }
3193
3194 /*
3195 * Send a button release event back to netbeans. Its up to netbeans
3196 * to decide what to do (if anything) with this event.
3197 */
3198 void
3199 netbeans_button_release(int button)
3200 {
3201 char buf[128];
3202 int bufno;
3203
3204 bufno = nb_getbufno(curbuf);
3205
3206 if (bufno >= 0 && curwin != NULL && curwin->w_buffer == curbuf)
3207 {
3208 int col = mouse_col - W_WINCOL(curwin) - (curwin->w_p_nu ? 9 : 1);
3209 long off = pos2off(curbuf, &curwin->w_cursor);
3210
3211 /* sync the cursor position */
3212 sprintf(buf, "%d:newDotAndMark=%d %ld %ld\n", bufno, r_cmdno, off, off);
3213 nbdebug(("EVT: %s", buf));
3214 nb_send(buf, "netbeans_button_release[newDotAndMark]");
3215
3216 sprintf(buf, "%d:buttonRelease=%d %d %ld %d\n", bufno, r_cmdno,
3217 button, (long)curwin->w_cursor.lnum, col);
3218 nbdebug(("EVT: %s", buf));
3219 nb_send(buf, "netbeans_button_release");
3220 }
3221 }
3222
3223
3224 /*
3225 * Send a keypress event back to netbeans. This usually simulates some
3226 * kind of function key press. This function operates on a key code.
3227 * Return TRUE when the key was sent, FALSE when the command has been
3228 * postponed.
3229 */
3230 int
3231 netbeans_keycommand(int key)
3232 {
3233 char keyName[60];
3234
3235 netbeans_keyname(key, keyName);
3236 return netbeans_keystring((char_u *)keyName);
3237 }
3238
3239
3240 /*
3241 * Send a keypress event back to netbeans. This usually simulates some
3242 * kind of function key press. This function operates on a key string.
3243 * Return TRUE when the key was sent, FALSE when the command has been
3244 * postponed.
3245 */
3246 static int
3247 netbeans_keystring(char_u *keyName)
3248 {
3249 char buf[2*MAXPATHL];
3250 int bufno = nb_getbufno(curbuf);
3251 long off;
3252 char_u *q;
3253
3254 if (!haveConnection)
3255 return TRUE;
3256
3257
3258 if (bufno == -1)
3259 {
3260 nbdebug(("got keycommand for non-NetBeans buffer, opening...\n"));
3261 q = curbuf->b_ffname == NULL ? (char_u *)""
3262 : nb_quote(curbuf->b_ffname);
3263 if (q == NULL)
3264 return TRUE;
3265 vim_snprintf(buf, sizeof(buf), "0:fileOpened=%d \"%s\" %s %s\n", 0,
3266 q,
3267 "T", /* open in NetBeans */
3268 "F"); /* modified */
3269 if (curbuf->b_ffname != NULL)
3270 vim_free(q);
3271 nbdebug(("EVT: %s", buf));
3272 nb_send(buf, "netbeans_keycommand");
3273
3274 postpone_keycommand(keyName);
3275 return FALSE;
3276 }
3277
3278 /* sync the cursor position */
3279 off = pos2off(curbuf, &curwin->w_cursor);
3280 sprintf(buf, "%d:newDotAndMark=%d %ld %ld\n", bufno, r_cmdno, off, off);
3281 nbdebug(("EVT: %s", buf));
3282 nb_send(buf, "netbeans_keycommand");
3283
3284 /* To work on Win32 you must apply patch to ExtEditor module
3285 * from ExtEdCaret.java.diff - make EVT_newDotAndMark handler
3286 * more synchronous
3287 */
3288
3289 /* now send keyCommand event */
3290 vim_snprintf(buf, sizeof(buf), "%d:keyCommand=%d \"%s\"\n",
3291 bufno, r_cmdno, keyName);
3292 nbdebug(("EVT: %s", buf));
3293 nb_send(buf, "netbeans_keycommand");
3294
3295 /* New: do both at once and include the lnum/col. */
3296 vim_snprintf(buf, sizeof(buf), "%d:keyAtPos=%d \"%s\" %ld %ld/%ld\n",
3297 bufno, r_cmdno, keyName,
3298 off, (long)curwin->w_cursor.lnum, (long)curwin->w_cursor.col);
3299 nbdebug(("EVT: %s", buf));
3300 nb_send(buf, "netbeans_keycommand");
3301 return TRUE;
3302 }
3303
3304
3305 /*
3306 * Send a save event to netbeans.
3307 */
3308 void
3309 netbeans_save_buffer(buf_T *bufp)
3310 {
3311 char_u buf[64];
3312 int bufno;
3313 nbbuf_T *nbbuf;
3314
3315 nbbuf = nb_bufp2nbbuf_fire(bufp, &bufno);
3316 if (nbbuf == NULL)
3317 return;
3318
3319 nbbuf->modified = 0;
3320
3321 sprintf((char *)buf, "%d:save=%d\n", bufno, r_cmdno);
3322 nbdebug(("EVT: %s", buf));
3323 nb_send((char *)buf, "netbeans_save_buffer");
3324 }
3325
3326
3327 /*
3328 * Send remove command to netbeans (this command has been turned off).
3329 */
3330 void
3331 netbeans_deleted_all_lines(buf_T *bufp)
3332 {
3333 char_u buf[64];
3334 int bufno;
3335 nbbuf_T *nbbuf;
3336
3337 nbbuf = nb_bufp2nbbuf_fire(bufp, &bufno);
3338 if (nbbuf == NULL)
3339 return;
3340
3341 /* Don't mark as modified for initial read */
3342 if (nbbuf->insertDone)
3343 nbbuf->modified = 1;
3344
3345 sprintf((char *)buf, "%d:remove=%d 0 -1\n", bufno, r_cmdno);
3346 nbdebug(("EVT(suppressed): %s", buf));
3347 /* nb_send(buf, "netbeans_deleted_all_lines"); */
3348 }
3349
3350
3351 /*
3352 * See if the lines are guarded. The top and bot parameters are from
3353 * u_savecommon(), these are the line above the change and the line below the
3354 * change.
3355 */
3356 int
3357 netbeans_is_guarded(linenr_T top, linenr_T bot)
3358 {
3359 signlist_T *p;
3360 int lnum;
3361
3362 for (p = curbuf->b_signlist; p != NULL; p = p->next)
3363 if (p->id >= GUARDEDOFFSET)
3364 for (lnum = top + 1; lnum < bot; lnum++)
3365 if (lnum == p->lnum)
3366 return TRUE;
3367
3368 return FALSE;
3369 }
3370
3371 #if defined(FEAT_GUI_MOTIF) || defined(PROTO)
3372 /*
3373 * We have multiple signs to draw at the same location. Draw the
3374 * multi-sign indicator instead. This is the Motif version.
3375 */
3376 void
3377 netbeans_draw_multisign_indicator(int row)
3378 {
3379 int i;
3380 int y;
3381 int x;
3382
3383 x = 0;
3384 y = row * gui.char_height + 2;
3385
3386 for (i = 0; i < gui.char_height - 3; i++)
3387 XDrawPoint(gui.dpy, gui.wid, gui.text_gc, x+2, y++);
3388
3389 XDrawPoint(gui.dpy, gui.wid, gui.text_gc, x+0, y);
3390 XDrawPoint(gui.dpy, gui.wid, gui.text_gc, x+2, y);
3391 XDrawPoint(gui.dpy, gui.wid, gui.text_gc, x+4, y++);
3392 XDrawPoint(gui.dpy, gui.wid, gui.text_gc, x+1, y);
3393 XDrawPoint(gui.dpy, gui.wid, gui.text_gc, x+2, y);
3394 XDrawPoint(gui.dpy, gui.wid, gui.text_gc, x+3, y++);
3395 XDrawPoint(gui.dpy, gui.wid, gui.text_gc, x+2, y);
3396 }
3397 #endif /* FEAT_GUI_MOTIF */
3398
3399 #ifdef FEAT_GUI_GTK
3400 /*
3401 * We have multiple signs to draw at the same location. Draw the
3402 * multi-sign indicator instead. This is the GTK/Gnome version.
3403 */
3404 void
3405 netbeans_draw_multisign_indicator(int row)
3406 {
3407 int i;
3408 int y;
3409 int x;
3410 GdkDrawable *drawable = gui.drawarea->window;
3411
3412 x = 0;
3413 y = row * gui.char_height + 2;
3414
3415 for (i = 0; i < gui.char_height - 3; i++)
3416 gdk_draw_point(drawable, gui.text_gc, x+2, y++);
3417
3418 gdk_draw_point(drawable, gui.text_gc, x+0, y);
3419 gdk_draw_point(drawable, gui.text_gc, x+2, y);
3420 gdk_draw_point(drawable, gui.text_gc, x+4, y++);
3421 gdk_draw_point(drawable, gui.text_gc, x+1, y);
3422 gdk_draw_point(drawable, gui.text_gc, x+2, y);
3423 gdk_draw_point(drawable, gui.text_gc, x+3, y++);
3424 gdk_draw_point(drawable, gui.text_gc, x+2, y);
3425 }
3426 #endif /* FEAT_GUI_GTK */
3427
3428 /*
3429 * If the mouse is clicked in the gutter of a line with multiple
3430 * annotations, cycle through the set of signs.
3431 */
3432 void
3433 netbeans_gutter_click(linenr_T lnum)
3434 {
3435 signlist_T *p;
3436
3437 for (p = curbuf->b_signlist; p != NULL; p = p->next)
3438 {
3439 if (p->lnum == lnum && p->next && p->next->lnum == lnum)
3440 {
3441 signlist_T *tail;
3442
3443 /* remove "p" from list, reinsert it at the tail of the sublist */
3444 if (p->prev)
3445 p->prev->next = p->next;
3446 else
3447 curbuf->b_signlist = p->next;
3448 p->next->prev = p->prev;
3449 /* now find end of sublist and insert p */
3450 for (tail = p->next;
3451 tail->next && tail->next->lnum == lnum
3452 && tail->next->id < GUARDEDOFFSET;
3453 tail = tail->next)
3454 ;
3455 /* tail now points to last entry with same lnum (except
3456 * that "guarded" annotations are always last) */
3457 p->next = tail->next;
3458 if (tail->next)
3459 tail->next->prev = p;
3460 p->prev = tail;
3461 tail->next = p;
3462 update_debug_sign(curbuf, lnum);
3463 break;
3464 }
3465 }
3466 }
3467
3468
3469 /*
3470 * Add a sign of the requested type at the requested location.
3471 *
3472 * Reverse engineering:
3473 * Apparently an annotation is defined the first time it is used in a buffer.
3474 * When the same annotation is used in two buffers, the second time we do not
3475 * need to define a new sign name but reuse the existing one. But since the
3476 * ID number used in the second buffer starts counting at one again, a mapping
3477 * is made from the ID specifically for the buffer to the global sign name
3478 * (which is a number).
3479 *
3480 * globalsignmap[] stores the signs that have been defined globally.
3481 * buf->signmapused[] maps buffer-local annotation IDs to an index in
3482 * globalsignmap[].
3483 */
3484 static void
3485 addsigntype(
3486 nbbuf_T *buf,
3487 int typeNum,
3488 char_u *typeName,
3489 char_u *tooltip UNUSED,
3490 char_u *glyphFile,
3491 int use_fg,
3492 int fg,
3493 int use_bg,
3494 int bg)
3495 {
3496 char fgbuf[32];
3497 char bgbuf[32];
3498 int i, j;
3499
3500 for (i = 0; i < globalsignmapused; i++)
3501 if (STRCMP(typeName, globalsignmap[i]) == 0)
3502 break;
3503
3504 if (i == globalsignmapused) /* not found; add it to global map */
3505 {
3506 nbdebug(("DEFINEANNOTYPE(%d,%s,%s,%s,%d,%d)\n",
3507 typeNum, typeName, tooltip, glyphFile, fg, bg));
3508 if (use_fg || use_bg)
3509 {
3510 sprintf(fgbuf, "guifg=#%06x", fg & 0xFFFFFF);
3511 sprintf(bgbuf, "guibg=#%06x", bg & 0xFFFFFF);
3512
3513 coloncmd(":highlight NB_%s %s %s", typeName, (use_fg) ? fgbuf : "",
3514 (use_bg) ? bgbuf : "");
3515 if (*glyphFile == NUL)
3516 /* no glyph, line highlighting only */
3517 coloncmd(":sign define %d linehl=NB_%s", i + 1, typeName);
3518 else if (vim_strsize(glyphFile) <= 2)
3519 /* one- or two-character glyph name, use as text glyph with
3520 * texthl */
3521 coloncmd(":sign define %d text=%s texthl=NB_%s", i + 1,
3522 glyphFile, typeName);
3523 else
3524 /* glyph, line highlighting */
3525 coloncmd(":sign define %d icon=%s linehl=NB_%s", i + 1,
3526 glyphFile, typeName);
3527 }
3528 else
3529 /* glyph, no line highlighting */
3530 coloncmd(":sign define %d icon=%s", i + 1, glyphFile);
3531
3532 if (STRCMP(typeName,"CurrentPC") == 0)
3533 curPCtype = typeNum;
3534
3535 if (globalsignmapused == globalsignmaplen)
3536 {
3537 if (globalsignmaplen == 0) /* first allocation */
3538 {
3539 globalsignmaplen = 20;
3540 globalsignmap = (char **)alloc_clear(globalsignmaplen*sizeof(char *));
3541 }
3542 else /* grow it */
3543 {
3544 int incr;
3545 int oldlen = globalsignmaplen;
3546
3547 globalsignmaplen *= 2;
3548 incr = globalsignmaplen - oldlen;
3549 globalsignmap = (char **)vim_realloc(globalsignmap,
3550 globalsignmaplen * sizeof(char *));
3551 memset(globalsignmap + oldlen, 0, incr * sizeof(char *));
3552 }
3553 }
3554
3555 globalsignmap[i] = (char *)typeName;
3556 globalsignmapused = i + 1;
3557 }
3558
3559 /* check local map; should *not* be found! */
3560 for (j = 0; j < buf->signmapused; j++)
3561 if (buf->signmap[j] == i + 1)
3562 return;
3563
3564 /* add to local map */
3565 if (buf->signmapused == buf->signmaplen)
3566 {
3567 if (buf->signmaplen == 0) /* first allocation */
3568 {
3569 buf->signmaplen = 5;
3570 buf->signmap = (int *)alloc_clear(buf->signmaplen * sizeof(int *));
3571 }
3572 else /* grow it */
3573 {
3574 int incr;
3575 int oldlen = buf->signmaplen;
3576 buf->signmaplen *= 2;
3577 incr = buf->signmaplen - oldlen;
3578 buf->signmap = (int *)vim_realloc(buf->signmap,
3579 buf->signmaplen*sizeof(int *));
3580 memset(buf->signmap + oldlen, 0, incr * sizeof(int *));
3581 }
3582 }
3583
3584 buf->signmap[buf->signmapused++] = i + 1;
3585
3586 }
3587
3588
3589 /*
3590 * See if we have the requested sign type in the buffer.
3591 */
3592 static int
3593 mapsigntype(nbbuf_T *buf, int localsigntype)
3594 {
3595 if (--localsigntype >= 0 && localsigntype < buf->signmapused)
3596 return buf->signmap[localsigntype];
3597
3598 return 0;
3599 }
3600
3601
3602 /*
3603 * Compute length of buffer, don't print anything.
3604 */
3605 static long
3606 get_buf_size(buf_T *bufp)
3607 {
3608 linenr_T lnum;
3609 long char_count = 0;
3610 int eol_size;
3611 long last_check = 100000L;
3612
3613 if (bufp->b_ml.ml_flags & ML_EMPTY)
3614 return 0;
3615 else
3616 {
3617 if (get_fileformat(bufp) == EOL_DOS)
3618 eol_size = 2;
3619 else
3620 eol_size = 1;
3621 for (lnum = 1; lnum <= bufp->b_ml.ml_line_count; ++lnum)
3622 {
3623 char_count += (long)STRLEN(ml_get_buf(bufp, lnum, FALSE))
3624 + eol_size;
3625 /* Check for a CTRL-C every 100000 characters */
3626 if (char_count > last_check)
3627 {
3628 ui_breakcheck();
3629 if (got_int)
3630 return char_count;
3631 last_check = char_count + 100000L;
3632 }
3633 }
3634 /* Correction for when last line doesn't have an EOL. */
3635 if (!bufp->b_p_eol && bufp->b_p_bin)
3636 char_count -= eol_size;
3637 }
3638
3639 return char_count;
3640 }
3641
3642 /*
3643 * Convert character offset to lnum,col
3644 */
3645 static pos_T *
3646 off2pos(buf_T *buf, long offset)
3647 {
3648 linenr_T lnum;
3649 static pos_T pos;
3650
3651 pos.lnum = 0;
3652 pos.col = 0;
3653 #ifdef FEAT_VIRTUALEDIT
3654 pos.coladd = 0;
3655 #endif
3656
3657 if (!(buf->b_ml.ml_flags & ML_EMPTY))
3658 {
3659 if ((lnum = ml_find_line_or_offset(buf, (linenr_T)0, &offset)) < 0)
3660 return NULL;
3661 pos.lnum = lnum;
3662 pos.col = offset;
3663 }
3664
3665 return &pos;
3666 }
3667
3668 /*
3669 * Convert an argument in the form "1234" to an offset and compute the
3670 * lnum/col from it. Convert an argument in the form "123/12" directly to a
3671 * lnum/col.
3672 * "argp" is advanced to after the argument.
3673 * Return a pointer to the position, NULL if something is wrong.
3674 */
3675 static pos_T *
3676 get_off_or_lnum(buf_T *buf, char_u **argp)
3677 {
3678 static pos_T mypos;
3679 long off;
3680
3681 off = strtol((char *)*argp, (char **)argp, 10);
3682 if (**argp == '/')
3683 {
3684 mypos.lnum = (linenr_T)off;
3685 ++*argp;
3686 mypos.col = strtol((char *)*argp, (char **)argp, 10);
3687 #ifdef FEAT_VIRTUALEDIT
3688 mypos.coladd = 0;
3689 #endif
3690 return &mypos;
3691 }
3692 return off2pos(buf, off);
3693 }
3694
3695
3696 /*
3697 * Convert (lnum,col) to byte offset in the file.
3698 */
3699 static long
3700 pos2off(buf_T *buf, pos_T *pos)
3701 {
3702 long offset = 0;
3703
3704 if (!(buf->b_ml.ml_flags & ML_EMPTY))
3705 {
3706 if ((offset = ml_find_line_or_offset(buf, pos->lnum, 0)) < 0)
3707 return 0;
3708 offset += pos->col;
3709 }
3710
3711 return offset;
3712 }
3713
3714
3715 /*
3716 * This message is printed after NetBeans opens a new file. Its
3717 * similar to the message readfile() uses, but since NetBeans
3718 * doesn't normally call readfile, we do our own.
3719 */
3720 static void
3721 print_read_msg(buf)
3722 nbbuf_T *buf;
3723 {
3724 int lnum = buf->bufp->b_ml.ml_line_count;
3725 long nchars = (long)buf->bufp->b_orig_size;
3726 char_u c;
3727
3728 msg_add_fname(buf->bufp, buf->bufp->b_ffname);
3729 c = FALSE;
3730
3731 if (buf->bufp->b_p_ro)
3732 {
3733 STRCAT(IObuff, shortmess(SHM_RO) ? _("[RO]") : _("[readonly]"));
3734 c = TRUE;
3735 }
3736 if (!buf->bufp->b_start_eol)
3737 {
3738 STRCAT(IObuff, shortmess(SHM_LAST) ? _("[noeol]") : _("[Incomplete last line]"));
3739 c = TRUE;
3740 }
3741 msg_add_lines(c, (long)lnum, nchars);
3742
3743 /* Now display it */
3744 vim_free(keep_msg);
3745 keep_msg = NULL;
3746 msg_scrolled_ign = TRUE;
3747 msg_trunc_attr(IObuff, FALSE, 0);
3748 msg_scrolled_ign = FALSE;
3749 }
3750
3751
3752 /*
3753 * Print a message after NetBeans writes the file. This message should be identical
3754 * to the standard message a non-netbeans user would see when writing a file.
3755 */
3756 static void
3757 print_save_msg(buf, nchars)
3758 nbbuf_T *buf;
3759 long nchars;
3760 {
3761 char_u c;
3762 char_u *p;
3763
3764 if (nchars >= 0)
3765 {
3766 msg_add_fname(buf->bufp, buf->bufp->b_ffname); /* fname in IObuff with quotes */
3767 c = FALSE;
3768
3769 msg_add_lines(c, buf->bufp->b_ml.ml_line_count,
3770 (long)buf->bufp->b_orig_size);
3771
3772 vim_free(keep_msg);
3773 keep_msg = NULL;
3774 msg_scrolled_ign = TRUE;
3775 p = msg_trunc_attr(IObuff, FALSE, 0);
3776 if ((msg_scrolled && !need_wait_return) || !buf->initDone)
3777 {
3778 /* Need to repeat the message after redrawing when:
3779 * - When reading from stdin (the screen will be cleared next).
3780 * - When restart_edit is set (otherwise there will be a delay
3781 * before redrawing).
3782 * - When the screen was scrolled but there is no wait-return
3783 * prompt. */
3784 set_keep_msg(p, 0);
3785 }
3786 msg_scrolled_ign = FALSE;
3787 /* add_to_input_buf((char_u *)"\f", 1); */
3788 }
3789 else
3790 {
3791 char_u ebuf[BUFSIZ];
3792
3793 STRCPY(ebuf, (char_u *)_("E505: "));
3794 STRCAT(ebuf, IObuff);
3795 STRCAT(ebuf, (char_u *)_("is read-only (add ! to override)"));
3796 STRCPY(IObuff, ebuf);
3797 nbdebug((" %s\n", ebuf ));
3798 emsg(IObuff);
3799 }
3800 }
3801
3802 #endif /* defined(FEAT_NETBEANS_INTG) */
Vim for the Mac