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