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 { 1513 nbdebug((" invalid buffer identifier in saveDone\n")); 1514 } 1515 else 1516 print_save_msg(buf, savedChars); 1517 /* =====================================================================*/ 1518 } 1519 else if (streq((char *)cmd, "startDocumentListen")) 1520 { 1521 if (buf == NULL) 1522 { 1523 nbdebug((" invalid buffer identifier in startDocumentListen\n")); 1524 emsg("E637: invalid buffer identifier in startDocumentListen"); 1525 return FAIL; 1526 } 1527 buf->fireChanges = 1; 1528 /* =====================================================================*/ 1529 } 1530 else if (streq((char *)cmd, "stopDocumentListen")) 1531 { 1532 if (buf == NULL) 1533 { 1534 nbdebug((" invalid buffer identifier in stopDocumentListen\n")); 1535 emsg("E638: invalid buffer identifier in stopDocumentListen"); 1536 return FAIL; 1537 } 1538 buf->fireChanges = 0; 1539 if (buf->bufp != NULL && buf->bufp->b_was_netbeans_file) 1540 { 1541 if (!buf->bufp->b_netbeans_file) 1542 { 1543 nbdebug(("E658: NetBeans connection lost for buffer %d\n", buf->bufp->b_fnum)); 1544 semsg(_("E658: NetBeans connection lost for buffer %d"), 1545 buf->bufp->b_fnum); 1546 } 1547 else 1548 { 1549 /* NetBeans uses stopDocumentListen when it stops editing 1550 * a file. It then expects the buffer in Vim to 1551 * disappear. */ 1552 do_bufdel(DOBUF_DEL, (char_u *)"", 1, 1553 buf->bufp->b_fnum, buf->bufp->b_fnum, TRUE); 1554 vim_memset(buf, 0, sizeof(nbbuf_T)); 1555 } 1556 } 1557 /* =====================================================================*/ 1558 } 1559 else if (streq((char *)cmd, "setTitle")) 1560 { 1561 if (buf == NULL) 1562 { 1563 nbdebug((" invalid buffer identifier in setTitle\n")); 1564 emsg("E639: invalid buffer identifier in setTitle"); 1565 return FAIL; 1566 } 1567 vim_free(buf->displayname); 1568 buf->displayname = nb_unquote(args, NULL); 1569 /* =====================================================================*/ 1570 } 1571 else if (streq((char *)cmd, "initDone")) 1572 { 1573 if (buf == NULL || buf->bufp == NULL) 1574 { 1575 nbdebug((" invalid buffer identifier in initDone\n")); 1576 emsg("E640: invalid buffer identifier in initDone"); 1577 return FAIL; 1578 } 1579 do_update = 1; 1580 buf->initDone = TRUE; 1581 nb_set_curbuf(buf->bufp); 1582 apply_autocmds(EVENT_BUFREADPOST, 0, 0, FALSE, buf->bufp); 1583 1584 /* handle any postponed key commands */ 1585 handle_key_queue(); 1586 /* =====================================================================*/ 1587 } 1588 else if (streq((char *)cmd, "setBufferNumber") 1589 || streq((char *)cmd, "putBufferNumber")) 1590 { 1591 char_u *path; 1592 buf_T *bufp; 1593 1594 if (buf == NULL) 1595 { 1596 nbdebug((" invalid buffer identifier in setBufferNumber\n")); 1597 emsg("E641: invalid buffer identifier in setBufferNumber"); 1598 return FAIL; 1599 } 1600 path = (char_u *)nb_unquote(args, NULL); 1601 if (path == NULL) 1602 return FAIL; 1603 bufp = buflist_findname(path); 1604 vim_free(path); 1605 if (bufp == NULL) 1606 { 1607 nbdebug((" File %s not found in setBufferNumber\n", args)); 1608 semsg("E642: File %s not found in setBufferNumber", args); 1609 return FAIL; 1610 } 1611 buf->bufp = bufp; 1612 buf->nbbuf_number = bufp->b_fnum; 1613 1614 /* "setBufferNumber" has the side effect of jumping to the buffer 1615 * (don't know why!). Don't do that for "putBufferNumber". */ 1616 if (*cmd != 'p') 1617 coloncmd(":buffer %d", bufp->b_fnum); 1618 else 1619 { 1620 buf->initDone = TRUE; 1621 1622 /* handle any postponed key commands */ 1623 handle_key_queue(); 1624 } 1625 1626 /* =====================================================================*/ 1627 } 1628 else if (streq((char *)cmd, "setFullName")) 1629 { 1630 if (buf == NULL) 1631 { 1632 nbdebug((" invalid buffer identifier in setFullName\n")); 1633 emsg("E643: invalid buffer identifier in setFullName"); 1634 return FAIL; 1635 } 1636 vim_free(buf->displayname); 1637 buf->displayname = nb_unquote(args, NULL); 1638 1639 netbeansReadFile = 0; /* don't try to open disk file */ 1640 do_ecmd(0, (char_u *)buf->displayname, 0, 0, ECMD_ONE, 1641 ECMD_HIDE + ECMD_OLDBUF, curwin); 1642 netbeansReadFile = 1; 1643 buf->bufp = curbuf; 1644 maketitle(); 1645 #if defined(FEAT_MENU) && defined(FEAT_GUI) 1646 if (gui.in_use) 1647 gui_update_menus(0); 1648 #endif 1649 /* =====================================================================*/ 1650 } 1651 else if (streq((char *)cmd, "editFile")) 1652 { 1653 if (buf == NULL) 1654 { 1655 nbdebug((" invalid buffer identifier in editFile\n")); 1656 emsg("E644: invalid buffer identifier in editFile"); 1657 return FAIL; 1658 } 1659 /* Edit a file: like create + setFullName + read the file. */ 1660 vim_free(buf->displayname); 1661 buf->displayname = nb_unquote(args, NULL); 1662 do_ecmd(0, (char_u *)buf->displayname, NULL, NULL, ECMD_ONE, 1663 ECMD_HIDE + ECMD_OLDBUF, curwin); 1664 buf->bufp = curbuf; 1665 buf->initDone = TRUE; 1666 do_update = 1; 1667 #if defined(FEAT_TITLE) 1668 maketitle(); 1669 #endif 1670 #if defined(FEAT_MENU) && defined(FEAT_GUI) 1671 if (gui.in_use) 1672 gui_update_menus(0); 1673 #endif 1674 /* =====================================================================*/ 1675 } 1676 else if (streq((char *)cmd, "setVisible")) 1677 { 1678 if (buf == NULL || buf->bufp == NULL) 1679 { 1680 nbdebug((" invalid buffer identifier in setVisible\n")); 1681 /* This message was commented out, probably because it can 1682 * happen when shutting down. */ 1683 if (p_verbose > 0) 1684 emsg("E645: invalid buffer identifier in setVisible"); 1685 return FAIL; 1686 } 1687 if (streq((char *)args, "T") && buf->bufp != curbuf) 1688 { 1689 exarg_T exarg; 1690 exarg.cmd = (char_u *)"goto"; 1691 exarg.forceit = FALSE; 1692 dosetvisible = TRUE; 1693 goto_buffer(&exarg, DOBUF_FIRST, FORWARD, buf->bufp->b_fnum); 1694 do_update = 1; 1695 dosetvisible = FALSE; 1696 1697 #ifdef FEAT_GUI 1698 /* Side effect!!!. */ 1699 if (gui.in_use) 1700 gui_mch_set_foreground(); 1701 #endif 1702 } 1703 /* =====================================================================*/ 1704 } 1705 else if (streq((char *)cmd, "raise")) 1706 { 1707 #ifdef FEAT_GUI 1708 /* Bring gvim to the foreground. */ 1709 if (gui.in_use) 1710 gui_mch_set_foreground(); 1711 #endif 1712 /* =====================================================================*/ 1713 } 1714 else if (streq((char *)cmd, "setModified")) 1715 { 1716 int prev_b_changed; 1717 1718 if (buf == NULL || buf->bufp == NULL) 1719 { 1720 nbdebug((" invalid buffer identifier in setModified\n")); 1721 /* This message was commented out, probably because it can 1722 * happen when shutting down. */ 1723 if (p_verbose > 0) 1724 emsg("E646: invalid buffer identifier in setModified"); 1725 return FAIL; 1726 } 1727 prev_b_changed = buf->bufp->b_changed; 1728 if (streq((char *)args, "T")) 1729 buf->bufp->b_changed = TRUE; 1730 else 1731 { 1732 stat_T st; 1733 1734 /* Assume NetBeans stored the file. Reset the timestamp to 1735 * avoid "file changed" warnings. */ 1736 if (buf->bufp->b_ffname != NULL 1737 && mch_stat((char *)buf->bufp->b_ffname, &st) >= 0) 1738 buf_store_time(buf->bufp, &st, buf->bufp->b_ffname); 1739 buf->bufp->b_changed = FALSE; 1740 } 1741 buf->modified = buf->bufp->b_changed; 1742 if (prev_b_changed != buf->bufp->b_changed) 1743 { 1744 check_status(buf->bufp); 1745 redraw_tabline = TRUE; 1746 #ifdef FEAT_TITLE 1747 maketitle(); 1748 #endif 1749 update_screen(0); 1750 } 1751 /* =====================================================================*/ 1752 } 1753 else if (streq((char *)cmd, "setModtime")) 1754 { 1755 if (buf == NULL || buf->bufp == NULL) 1756 nbdebug((" invalid buffer identifier in setModtime\n")); 1757 else 1758 buf->bufp->b_mtime = atoi((char *)args); 1759 /* =====================================================================*/ 1760 } 1761 else if (streq((char *)cmd, "setReadOnly")) 1762 { 1763 if (buf == NULL || buf->bufp == NULL) 1764 nbdebug((" invalid buffer identifier in setReadOnly\n")); 1765 else if (streq((char *)args, "T")) 1766 buf->bufp->b_p_ro = TRUE; 1767 else 1768 buf->bufp->b_p_ro = FALSE; 1769 /* =====================================================================*/ 1770 } 1771 else if (streq((char *)cmd, "setMark")) 1772 { 1773 /* not yet */ 1774 /* =====================================================================*/ 1775 } 1776 else if (streq((char *)cmd, "showBalloon")) 1777 { 1778 #if defined(FEAT_BEVAL_GUI) 1779 static char *text = NULL; 1780 1781 /* 1782 * Set up the Balloon Expression Evaluation area. 1783 * Ignore 'ballooneval' here. 1784 * The text pointer must remain valid for a while. 1785 */ 1786 if (balloonEval != NULL) 1787 { 1788 vim_free(text); 1789 text = nb_unquote(args, NULL); 1790 if (text != NULL) 1791 gui_mch_post_balloon(balloonEval, (char_u *)text); 1792 } 1793 #endif 1794 /* =====================================================================*/ 1795 } 1796 else if (streq((char *)cmd, "setDot")) 1797 { 1798 pos_T *pos; 1799 #ifdef NBDEBUG 1800 char_u *s; 1801 #endif 1802 1803 if (buf == NULL || buf->bufp == NULL) 1804 { 1805 nbdebug((" invalid buffer identifier in setDot\n")); 1806 emsg("E647: invalid buffer identifier in setDot"); 1807 return FAIL; 1808 } 1809 1810 nb_set_curbuf(buf->bufp); 1811 1812 /* Don't want Visual mode now. */ 1813 if (VIsual_active) 1814 end_visual_mode(); 1815 #ifdef NBDEBUG 1816 s = args; 1817 #endif 1818 pos = get_off_or_lnum(buf->bufp, &args); 1819 if (pos) 1820 { 1821 curwin->w_cursor = *pos; 1822 check_cursor(); 1823 #ifdef FEAT_FOLDING 1824 foldOpenCursor(); 1825 #endif 1826 } 1827 else 1828 { 1829 nbdebug((" BAD POSITION in setDot: %s\n", s)); 1830 } 1831 1832 /* gui_update_cursor(TRUE, FALSE); */ 1833 /* update_curbuf(NOT_VALID); */ 1834 update_topline(); /* scroll to show the line */ 1835 update_screen(VALID); 1836 setcursor(); 1837 cursor_on(); 1838 out_flush_cursor(TRUE, FALSE); 1839 1840 /* Quit a hit-return or more prompt. */ 1841 if (State == HITRETURN || State == ASKMORE) 1842 { 1843 #ifdef FEAT_GUI_GTK 1844 if (gui.in_use && gtk_main_level() > 0) 1845 gtk_main_quit(); 1846 #endif 1847 } 1848 /* =====================================================================*/ 1849 } 1850 else if (streq((char *)cmd, "close")) 1851 { 1852 #ifdef NBDEBUG 1853 char *name = "<NONE>"; 1854 #endif 1855 1856 if (buf == NULL) 1857 { 1858 nbdebug((" invalid buffer identifier in close\n")); 1859 emsg("E648: invalid buffer identifier in close"); 1860 return FAIL; 1861 } 1862 1863 #ifdef NBDEBUG 1864 if (buf->displayname != NULL) 1865 name = buf->displayname; 1866 #endif 1867 if (buf->bufp == NULL) 1868 { 1869 nbdebug((" invalid buffer identifier in close\n")); 1870 /* This message was commented out, probably because it can 1871 * happen when shutting down. */ 1872 if (p_verbose > 0) 1873 emsg("E649: invalid buffer identifier in close"); 1874 } 1875 nbdebug((" CLOSE %d: %s\n", bufno, name)); 1876 #ifdef FEAT_GUI 1877 need_mouse_correct = TRUE; 1878 #endif 1879 if (buf->bufp != NULL) 1880 do_buffer(DOBUF_WIPE, DOBUF_FIRST, FORWARD, 1881 buf->bufp->b_fnum, TRUE); 1882 buf->bufp = NULL; 1883 buf->initDone = FALSE; 1884 do_update = 1; 1885 /* =====================================================================*/ 1886 } 1887 else if (streq((char *)cmd, "setStyle")) /* obsolete... */ 1888 { 1889 nbdebug((" setStyle is obsolete!\n")); 1890 /* =====================================================================*/ 1891 } 1892 else if (streq((char *)cmd, "setExitDelay")) 1893 { 1894 /* Only used in version 2.1. */ 1895 /* =====================================================================*/ 1896 } 1897 else if (streq((char *)cmd, "defineAnnoType")) 1898 { 1899 #ifdef FEAT_SIGNS 1900 int typeNum; 1901 char_u *typeName; 1902 char_u *tooltip; 1903 char_u *p; 1904 char_u *glyphFile; 1905 int parse_error = FALSE; 1906 char_u *fg; 1907 char_u *bg; 1908 1909 if (buf == NULL) 1910 { 1911 nbdebug((" invalid buffer identifier in defineAnnoType\n")); 1912 emsg("E650: invalid buffer identifier in defineAnnoType"); 1913 return FAIL; 1914 } 1915 1916 cp = (char *)args; 1917 typeNum = strtol(cp, &cp, 10); 1918 args = (char_u *)cp; 1919 args = skipwhite(args); 1920 typeName = (char_u *)nb_unquote(args, &args); 1921 args = skipwhite(args + 1); 1922 tooltip = (char_u *)nb_unquote(args, &args); 1923 args = skipwhite(args + 1); 1924 1925 p = (char_u *)nb_unquote(args, &args); 1926 glyphFile = vim_strsave_escaped(p, escape_chars); 1927 vim_free(p); 1928 1929 args = skipwhite(args + 1); 1930 p = skiptowhite(args); 1931 if (*p != NUL) 1932 { 1933 *p = NUL; 1934 p = skipwhite(p + 1); 1935 } 1936 fg = vim_strsave(args); 1937 bg = vim_strsave(p); 1938 if (STRLEN(fg) > MAX_COLOR_LENGTH || STRLEN(bg) > MAX_COLOR_LENGTH) 1939 { 1940 emsg("E532: highlighting color name too long in defineAnnoType"); 1941 vim_free(typeName); 1942 parse_error = TRUE; 1943 } 1944 else if (typeName != NULL && tooltip != NULL && glyphFile != NULL) 1945 addsigntype(buf, typeNum, typeName, tooltip, glyphFile, fg, bg); 1946 else 1947 vim_free(typeName); 1948 1949 /* don't free typeName; it's used directly in addsigntype() */ 1950 vim_free(fg); 1951 vim_free(bg); 1952 vim_free(tooltip); 1953 vim_free(glyphFile); 1954 if (parse_error) 1955 return FAIL; 1956 1957 #endif 1958 /* =====================================================================*/ 1959 } 1960 else if (streq((char *)cmd, "addAnno")) 1961 { 1962 #ifdef FEAT_SIGNS 1963 int serNum; 1964 int localTypeNum; 1965 int typeNum; 1966 pos_T *pos; 1967 1968 if (buf == NULL || buf->bufp == NULL) 1969 { 1970 nbdebug((" invalid buffer identifier in addAnno\n")); 1971 emsg("E651: invalid buffer identifier in addAnno"); 1972 return FAIL; 1973 } 1974 1975 do_update = 1; 1976 1977 cp = (char *)args; 1978 serNum = strtol(cp, &cp, 10); 1979 1980 /* Get the typenr specific for this buffer and convert it to 1981 * the global typenumber, as used for the sign name. */ 1982 localTypeNum = strtol(cp, &cp, 10); 1983 args = (char_u *)cp; 1984 typeNum = mapsigntype(buf, localTypeNum); 1985 1986 pos = get_off_or_lnum(buf->bufp, &args); 1987 1988 cp = (char *)args; 1989 vim_ignored = (int)strtol(cp, &cp, 10); 1990 args = (char_u *)cp; 1991 # ifdef NBDEBUG 1992 if (vim_ignored != -1) 1993 { 1994 nbdebug((" partial line annotation -- Not Yet Implemented!\n")); 1995 } 1996 # endif 1997 if (serNum >= GUARDEDOFFSET) 1998 { 1999 nbdebug((" too many annotations! ignoring...\n")); 2000 return FAIL; 2001 } 2002 if (pos) 2003 { 2004 coloncmd(":sign place %d line=%ld name=%d buffer=%d", 2005 serNum, pos->lnum, typeNum, buf->bufp->b_fnum); 2006 if (typeNum == curPCtype) 2007 coloncmd(":sign jump %d buffer=%d", serNum, 2008 buf->bufp->b_fnum); 2009 } 2010 #endif 2011 /* =====================================================================*/ 2012 } 2013 else if (streq((char *)cmd, "removeAnno")) 2014 { 2015 #ifdef FEAT_SIGNS 2016 int serNum; 2017 2018 if (buf == NULL || buf->bufp == NULL) 2019 { 2020 nbdebug((" invalid buffer identifier in removeAnno\n")); 2021 return FAIL; 2022 } 2023 do_update = 1; 2024 cp = (char *)args; 2025 serNum = strtol(cp, &cp, 10); 2026 args = (char_u *)cp; 2027 coloncmd(":sign unplace %d buffer=%d", 2028 serNum, buf->bufp->b_fnum); 2029 redraw_buf_later(buf->bufp, NOT_VALID); 2030 #endif 2031 /* =====================================================================*/ 2032 } 2033 else if (streq((char *)cmd, "moveAnnoToFront")) 2034 { 2035 #ifdef FEAT_SIGNS 2036 nbdebug((" moveAnnoToFront: Not Yet Implemented!\n")); 2037 #endif 2038 /* =====================================================================*/ 2039 } 2040 else if (streq((char *)cmd, "guard") || streq((char *)cmd, "unguard")) 2041 { 2042 int len; 2043 pos_T first; 2044 pos_T last; 2045 pos_T *pos; 2046 int un = (cmd[0] == 'u'); 2047 static int guardId = GUARDEDOFFSET; 2048 2049 if (skip >= SKIP_STOP) 2050 { 2051 nbdebug((" Skipping %s command\n", (char *) cmd)); 2052 return OK; 2053 } 2054 2055 nb_init_graphics(); 2056 2057 if (buf == NULL || buf->bufp == NULL) 2058 { 2059 nbdebug((" invalid buffer identifier in %s command\n", cmd)); 2060 return FAIL; 2061 } 2062 nb_set_curbuf(buf->bufp); 2063 cp = (char *)args; 2064 off = strtol(cp, &cp, 10); 2065 len = strtol(cp, NULL, 10); 2066 args = (char_u *)cp; 2067 pos = off2pos(buf->bufp, off); 2068 do_update = 1; 2069 if (!pos) 2070 nbdebug((" no such start pos in %s, %ld\n", cmd, off)); 2071 else 2072 { 2073 first = *pos; 2074 pos = off2pos(buf->bufp, off + len - 1); 2075 if (pos != NULL && pos->col == 0) 2076 { 2077 /* 2078 * In Java Swing the offset is a position between 2 2079 * characters. If col == 0 then we really want the 2080 * previous line as the end. 2081 */ 2082 pos = off2pos(buf->bufp, off + len - 2); 2083 } 2084 if (!pos) 2085 nbdebug((" no such end pos in %s, %ld\n", 2086 cmd, off + len - 1)); 2087 else 2088 { 2089 long lnum; 2090 last = *pos; 2091 /* set highlight for region */ 2092 nbdebug((" %sGUARD %ld,%d to %ld,%d\n", (un) ? "UN" : "", 2093 first.lnum, first.col, 2094 last.lnum, last.col)); 2095 #ifdef FEAT_SIGNS 2096 for (lnum = first.lnum; lnum <= last.lnum; lnum++) 2097 { 2098 if (un) 2099 { 2100 /* never used */ 2101 } 2102 else 2103 { 2104 if (buf_findsigntype_id(buf->bufp, lnum, 2105 GUARDED) == 0) 2106 { 2107 coloncmd( 2108 ":sign place %d line=%ld name=%d buffer=%d", 2109 guardId++, lnum, GUARDED, 2110 buf->bufp->b_fnum); 2111 } 2112 } 2113 } 2114 #endif 2115 redraw_buf_later(buf->bufp, NOT_VALID); 2116 } 2117 } 2118 /* =====================================================================*/ 2119 } 2120 else if (streq((char *)cmd, "startAtomic")) 2121 { 2122 inAtomic = 1; 2123 /* =====================================================================*/ 2124 } 2125 else if (streq((char *)cmd, "endAtomic")) 2126 { 2127 inAtomic = 0; 2128 if (needupdate) 2129 { 2130 do_update = 1; 2131 needupdate = 0; 2132 } 2133 /* =====================================================================*/ 2134 } 2135 else if (streq((char *)cmd, "save")) 2136 { 2137 /* 2138 * NOTE - This command is obsolete wrt NetBeans. It's left in 2139 * only for historical reasons. 2140 */ 2141 if (buf == NULL || buf->bufp == NULL) 2142 { 2143 nbdebug((" invalid buffer identifier in %s command\n", cmd)); 2144 return FAIL; 2145 } 2146 2147 /* the following is taken from ex_cmds.c (do_wqall function) */ 2148 if (bufIsChanged(buf->bufp)) 2149 { 2150 /* Only write if the buffer can be written. */ 2151 if (p_write 2152 && !buf->bufp->b_p_ro 2153 && buf->bufp->b_ffname != NULL 2154 #ifdef FEAT_QUICKFIX 2155 && !bt_dontwrite(buf->bufp) 2156 #endif 2157 ) 2158 { 2159 bufref_T bufref; 2160 2161 set_bufref(&bufref, buf->bufp); 2162 buf_write_all(buf->bufp, FALSE); 2163 /* an autocommand may have deleted the buffer */ 2164 if (!bufref_valid(&bufref)) 2165 buf->bufp = NULL; 2166 } 2167 } 2168 else 2169 { 2170 nbdebug((" Buffer has no changes!\n")); 2171 } 2172 /* =====================================================================*/ 2173 } 2174 else if (streq((char *)cmd, "netbeansBuffer")) 2175 { 2176 if (buf == NULL || buf->bufp == NULL) 2177 { 2178 nbdebug((" invalid buffer identifier in %s command\n", cmd)); 2179 return FAIL; 2180 } 2181 if (*args == 'T') 2182 { 2183 buf->bufp->b_netbeans_file = TRUE; 2184 buf->bufp->b_was_netbeans_file = TRUE; 2185 } 2186 else 2187 buf->bufp->b_netbeans_file = FALSE; 2188 /* =====================================================================*/ 2189 } 2190 else if (streq((char *)cmd, "specialKeys")) 2191 { 2192 special_keys(args); 2193 /* =====================================================================*/ 2194 } 2195 else if (streq((char *)cmd, "actionMenuItem")) 2196 { 2197 /* not used yet */ 2198 /* =====================================================================*/ 2199 } 2200 else if (streq((char *)cmd, "version")) 2201 { 2202 /* not used yet */ 2203 } 2204 else 2205 { 2206 nbdebug(("Unrecognised command: %s\n", cmd)); 2207 } 2208 /* 2209 * Unrecognized command is ignored. 2210 */ 2211 } 2212 if (inAtomic && do_update) 2213 { 2214 needupdate = 1; 2215 do_update = 0; 2216 } 2217 2218 /* 2219 * Is this needed? I moved the netbeans_Xt_connect() later during startup 2220 * and it may no longer be necessary. If it's not needed then needupdate 2221 * and do_update can also be removed. 2222 */ 2223 if (buf != NULL && buf->initDone && do_update) 2224 { 2225 update_screen(NOT_VALID); 2226 setcursor(); 2227 cursor_on(); 2228 out_flush_cursor(TRUE, FALSE); 2229 2230 /* Quit a hit-return or more prompt. */ 2231 if (State == HITRETURN || State == ASKMORE) 2232 { 2233 #ifdef FEAT_GUI_GTK 2234 if (gui.in_use && gtk_main_level() > 0) 2235 gtk_main_quit(); 2236 #endif 2237 } 2238 } 2239 2240 return retval; 2241 } 2242 2243 2244 /* 2245 * If "buf" is not the current buffer try changing to a window that edits this 2246 * buffer. If there is no such window then close the current buffer and set 2247 * the current buffer as "buf". 2248 */ 2249 static void 2250 nb_set_curbuf(buf_T *buf) 2251 { 2252 if (curbuf != buf) { 2253 if (buf_jump_open_win(buf) != NULL) 2254 return; 2255 if ((swb_flags & SWB_USETAB) && buf_jump_open_tab(buf) != NULL) 2256 return; 2257 set_curbuf(buf, DOBUF_GOTO); 2258 } 2259 } 2260 2261 /* 2262 * Process a vim colon command. 2263 */ 2264 static void 2265 coloncmd(char *cmd, ...) 2266 { 2267 char buf[1024]; 2268 va_list ap; 2269 2270 va_start(ap, cmd); 2271 vim_vsnprintf(buf, sizeof(buf), cmd, ap); 2272 va_end(ap); 2273 2274 nbdebug((" COLONCMD %s\n", buf)); 2275 2276 do_cmdline((char_u *)buf, NULL, NULL, DOCMD_NOWAIT | DOCMD_KEYTYPED); 2277 2278 setcursor(); /* restore the cursor position */ 2279 out_flush_cursor(TRUE, FALSE); 2280 } 2281 2282 2283 /* 2284 * Parse the specialKeys argument and issue the appropriate map commands. 2285 */ 2286 static void 2287 special_keys(char_u *args) 2288 { 2289 char *save_str = nb_unquote(args, NULL); 2290 char *tok = strtok(save_str, " "); 2291 char *sep; 2292 #define KEYBUFLEN 64 2293 char keybuf[KEYBUFLEN]; 2294 char cmdbuf[256]; 2295 2296 while (tok != NULL) 2297 { 2298 int i = 0; 2299 2300 if ((sep = strchr(tok, '-')) != NULL) 2301 { 2302 *sep = NUL; 2303 while (*tok) 2304 { 2305 switch (*tok) 2306 { 2307 case 'A': 2308 case 'M': 2309 case 'C': 2310 case 'S': 2311 keybuf[i++] = *tok; 2312 keybuf[i++] = '-'; 2313 break; 2314 } 2315 tok++; 2316 } 2317 tok++; 2318 } 2319 2320 if (strlen(tok) + i < KEYBUFLEN) 2321 { 2322 strcpy(&keybuf[i], tok); 2323 vim_snprintf(cmdbuf, sizeof(cmdbuf), 2324 "<silent><%s> :nbkey %s<CR>", keybuf, keybuf); 2325 do_map(0, (char_u *)cmdbuf, NORMAL, FALSE); 2326 } 2327 tok = strtok(NULL, " "); 2328 } 2329 vim_free(save_str); 2330 } 2331 2332 void 2333 ex_nbclose(exarg_T *eap UNUSED) 2334 { 2335 netbeans_close(); 2336 } 2337 2338 void 2339 ex_nbkey(exarg_T *eap) 2340 { 2341 (void)netbeans_keystring(eap->arg); 2342 } 2343 2344 void 2345 ex_nbstart( 2346 exarg_T *eap) 2347 { 2348 #ifdef FEAT_GUI 2349 # if !defined(FEAT_GUI_X11) && !defined(FEAT_GUI_GTK) \ 2350 && !defined(FEAT_GUI_MSWIN) 2351 if (gui.in_use) 2352 { 2353 emsg(_("E838: netbeans is not supported with this GUI")); 2354 return; 2355 } 2356 # endif 2357 #endif 2358 netbeans_open((char *)eap->arg, FALSE); 2359 } 2360 2361 /* 2362 * Initialize highlights and signs for use by netbeans (mostly obsolete) 2363 */ 2364 static void 2365 nb_init_graphics(void) 2366 { 2367 static int did_init = FALSE; 2368 2369 if (!did_init) 2370 { 2371 coloncmd(":highlight NBGuarded guibg=Cyan guifg=Black" 2372 " ctermbg=LightCyan ctermfg=Black"); 2373 coloncmd(":sign define %d linehl=NBGuarded", GUARDED); 2374 2375 did_init = TRUE; 2376 } 2377 } 2378 2379 /* 2380 * Convert key to netbeans name. This uses the global "mod_mask". 2381 */ 2382 static void 2383 netbeans_keyname(int key, char *buf) 2384 { 2385 char *name = 0; 2386 char namebuf[2]; 2387 int ctrl = 0; 2388 int shift = 0; 2389 int alt = 0; 2390 2391 if (mod_mask & MOD_MASK_CTRL) 2392 ctrl = 1; 2393 if (mod_mask & MOD_MASK_SHIFT) 2394 shift = 1; 2395 if (mod_mask & MOD_MASK_ALT) 2396 alt = 1; 2397 2398 2399 switch (key) 2400 { 2401 case K_F1: name = "F1"; break; 2402 case K_S_F1: name = "F1"; shift = 1; break; 2403 case K_F2: name = "F2"; break; 2404 case K_S_F2: name = "F2"; shift = 1; break; 2405 case K_F3: name = "F3"; break; 2406 case K_S_F3: name = "F3"; shift = 1; break; 2407 case K_F4: name = "F4"; break; 2408 case K_S_F4: name = "F4"; shift = 1; break; 2409 case K_F5: name = "F5"; break; 2410 case K_S_F5: name = "F5"; shift = 1; break; 2411 case K_F6: name = "F6"; break; 2412 case K_S_F6: name = "F6"; shift = 1; break; 2413 case K_F7: name = "F7"; break; 2414 case K_S_F7: name = "F7"; shift = 1; break; 2415 case K_F8: name = "F8"; break; 2416 case K_S_F8: name = "F8"; shift = 1; break; 2417 case K_F9: name = "F9"; break; 2418 case K_S_F9: name = "F9"; shift = 1; break; 2419 case K_F10: name = "F10"; break; 2420 case K_S_F10: name = "F10"; shift = 1; break; 2421 case K_F11: name = "F11"; break; 2422 case K_S_F11: name = "F11"; shift = 1; break; 2423 case K_F12: name = "F12"; break; 2424 case K_S_F12: name = "F12"; shift = 1; break; 2425 default: 2426 if (key >= ' ' && key <= '~') 2427 { 2428 /* Allow ASCII characters. */ 2429 name = namebuf; 2430 namebuf[0] = key; 2431 namebuf[1] = NUL; 2432 } 2433 else 2434 name = "X"; 2435 break; 2436 } 2437 2438 buf[0] = '\0'; 2439 if (ctrl) 2440 strcat(buf, "C"); 2441 if (shift) 2442 strcat(buf, "S"); 2443 if (alt) 2444 strcat(buf, "M"); /* META */ 2445 if (ctrl || shift || alt) 2446 strcat(buf, "-"); 2447 strcat(buf, name); 2448 } 2449 2450 #if defined(FEAT_BEVAL) || defined(PROTO) 2451 /* 2452 * Function to be called for balloon evaluation. Grabs the text under the 2453 * cursor and sends it to the debugger for evaluation. The debugger should 2454 * respond with a showBalloon command when there is a useful result. 2455 */ 2456 void 2457 netbeans_beval_cb( 2458 BalloonEval *beval, 2459 int state UNUSED) 2460 { 2461 win_T *wp; 2462 char_u *text; 2463 linenr_T lnum; 2464 int col; 2465 char *buf; 2466 char_u *p; 2467 2468 /* Don't do anything when 'ballooneval' is off, messages scrolled the 2469 * windows up or we have no connection. */ 2470 if (!can_use_beval() || !NETBEANS_OPEN) 2471 return; 2472 2473 if (get_beval_info(beval, TRUE, &wp, &lnum, &text, &col) == OK) 2474 { 2475 /* Send debugger request. Only when the text is of reasonable 2476 * length. */ 2477 if (text != NULL && text[0] != NUL && STRLEN(text) < MAXPATHL) 2478 { 2479 buf = (char *)alloc(MAXPATHL * 2 + 25); 2480 if (buf != NULL) 2481 { 2482 p = nb_quote(text); 2483 if (p != NULL) 2484 { 2485 vim_snprintf(buf, MAXPATHL * 2 + 25, 2486 "0:balloonText=%d \"%s\"\n", r_cmdno, p); 2487 vim_free(p); 2488 } 2489 nbdebug(("EVT: %s", buf)); 2490 nb_send(buf, "netbeans_beval_cb"); 2491 vim_free(buf); 2492 } 2493 } 2494 vim_free(text); 2495 } 2496 } 2497 #endif 2498 2499 /* 2500 * Return TRUE when the netbeans connection is active. 2501 */ 2502 int 2503 netbeans_active(void) 2504 { 2505 return NETBEANS_OPEN; 2506 } 2507 2508 /* 2509 * Tell netbeans that the window was opened, ready for commands. 2510 */ 2511 void 2512 netbeans_open(char *params, int doabort) 2513 { 2514 char *cmd = "0:startupDone=0\n"; 2515 2516 if (NETBEANS_OPEN) 2517 { 2518 emsg(_("E511: netbeans already connected")); 2519 return; 2520 } 2521 2522 if (netbeans_connect(params, doabort) != OK) 2523 return; 2524 2525 nbdebug(("EVT: %s", cmd)); 2526 nb_send(cmd, "netbeans_startup_done"); 2527 2528 /* update the screen after having added the gutter */ 2529 changed_window_setting(); 2530 update_screen(CLEAR); 2531 setcursor(); 2532 cursor_on(); 2533 out_flush_cursor(TRUE, FALSE); 2534 } 2535 2536 /* 2537 * Tell netbeans that we're exiting. This should be called right 2538 * before calling exit. 2539 */ 2540 void 2541 netbeans_send_disconnect(void) 2542 { 2543 char buf[128]; 2544 2545 if (NETBEANS_OPEN) 2546 { 2547 sprintf(buf, "0:disconnect=%d\n", r_cmdno); 2548 nbdebug(("EVT: %s", buf)); 2549 nb_send(buf, "netbeans_disconnect"); 2550 } 2551 } 2552 2553 #if defined(FEAT_EVAL) || defined(PROTO) 2554 int 2555 set_ref_in_nb_channel(int copyID) 2556 { 2557 int abort = FALSE; 2558 typval_T tv; 2559 2560 if (nb_channel != NULL) 2561 { 2562 tv.v_type = VAR_CHANNEL; 2563 tv.vval.v_channel = nb_channel; 2564 abort = set_ref_in_item(&tv, copyID, NULL, NULL); 2565 } 2566 return abort; 2567 } 2568 #endif 2569 2570 #if defined(FEAT_GUI_X11) || defined(FEAT_GUI_MSWIN) || defined(PROTO) 2571 /* 2572 * Tell netbeans that the window was moved or resized. 2573 */ 2574 void 2575 netbeans_frame_moved(int new_x, int new_y) 2576 { 2577 char buf[128]; 2578 2579 if (!NETBEANS_OPEN) 2580 return; 2581 2582 sprintf(buf, "0:geometry=%d %d %d %d %d\n", 2583 r_cmdno, (int)Columns, (int)Rows, new_x, new_y); 2584 /*nbdebug(("EVT: %s", buf)); happens too many times during a move */ 2585 nb_send(buf, "netbeans_frame_moved"); 2586 } 2587 #endif 2588 2589 /* 2590 * Tell netbeans the user opened or activated a file. 2591 */ 2592 void 2593 netbeans_file_activated(buf_T *bufp) 2594 { 2595 int bufno = nb_getbufno(bufp); 2596 nbbuf_T *bp = nb_get_buf(bufno); 2597 char buffer[2*MAXPATHL]; 2598 char_u *q; 2599 2600 if (!NETBEANS_OPEN || !bufp->b_netbeans_file || dosetvisible) 2601 return; 2602 2603 q = nb_quote(bufp->b_ffname); 2604 if (q == NULL || bp == NULL) 2605 return; 2606 2607 vim_snprintf(buffer, sizeof(buffer), "%d:fileOpened=%d \"%s\" %s %s\n", 2608 bufno, 2609 bufno, 2610 (char *)q, 2611 "T", /* open in NetBeans */ 2612 "F"); /* modified */ 2613 2614 vim_free(q); 2615 nbdebug(("EVT: %s", buffer)); 2616 2617 nb_send(buffer, "netbeans_file_opened"); 2618 } 2619 2620 /* 2621 * Tell netbeans the user opened a file. 2622 */ 2623 void 2624 netbeans_file_opened(buf_T *bufp) 2625 { 2626 int bufno = nb_getbufno(bufp); 2627 char buffer[2*MAXPATHL]; 2628 char_u *q; 2629 nbbuf_T *bp = nb_get_buf(nb_getbufno(bufp)); 2630 int bnum; 2631 2632 if (!NETBEANS_OPEN) 2633 return; 2634 2635 q = nb_quote(bufp->b_ffname); 2636 if (q == NULL) 2637 return; 2638 if (bp != NULL) 2639 bnum = bufno; 2640 else 2641 bnum = 0; 2642 2643 vim_snprintf(buffer, sizeof(buffer), "%d:fileOpened=%d \"%s\" %s %s\n", 2644 bnum, 2645 0, 2646 (char *)q, 2647 "T", /* open in NetBeans */ 2648 "F"); /* modified */ 2649 2650 vim_free(q); 2651 nbdebug(("EVT: %s", buffer)); 2652 2653 nb_send(buffer, "netbeans_file_opened"); 2654 if (p_acd && vim_chdirfile(bufp->b_ffname, "auto") == OK) 2655 shorten_fnames(TRUE); 2656 } 2657 2658 /* 2659 * Tell netbeans that a file was deleted or wiped out. 2660 */ 2661 void 2662 netbeans_file_killed(buf_T *bufp) 2663 { 2664 int bufno = nb_getbufno(bufp); 2665 nbbuf_T *nbbuf = nb_get_buf(bufno); 2666 char buffer[2*MAXPATHL]; 2667 2668 if (!NETBEANS_OPEN || bufno == -1) 2669 return; 2670 2671 nbdebug(("netbeans_file_killed:\n")); 2672 nbdebug((" Killing bufno: %d", bufno)); 2673 2674 sprintf(buffer, "%d:killed=%d\n", bufno, r_cmdno); 2675 2676 nbdebug(("EVT: %s", buffer)); 2677 2678 nb_send(buffer, "netbeans_file_killed"); 2679 2680 if (nbbuf != NULL) 2681 nbbuf->bufp = NULL; 2682 } 2683 2684 /* 2685 * Get a pointer to the Netbeans buffer for Vim buffer "bufp". 2686 * Return NULL if there is no such buffer or changes are not to be reported. 2687 * Otherwise store the buffer number in "*bufnop". 2688 */ 2689 static nbbuf_T * 2690 nb_bufp2nbbuf_fire(buf_T *bufp, int *bufnop) 2691 { 2692 int bufno; 2693 nbbuf_T *nbbuf; 2694 2695 if (!NETBEANS_OPEN || !netbeansFireChanges) 2696 return NULL; /* changes are not reported at all */ 2697 2698 bufno = nb_getbufno(bufp); 2699 if (bufno <= 0) 2700 return NULL; /* file is not known to NetBeans */ 2701 2702 nbbuf = nb_get_buf(bufno); 2703 if (nbbuf != NULL && !nbbuf->fireChanges) 2704 return NULL; /* changes in this buffer are not reported */ 2705 2706 *bufnop = bufno; 2707 return nbbuf; 2708 } 2709 2710 /* 2711 * Tell netbeans the user inserted some text. 2712 */ 2713 void 2714 netbeans_inserted( 2715 buf_T *bufp, 2716 linenr_T linenr, 2717 colnr_T col, 2718 char_u *txt, 2719 int newlen) 2720 { 2721 char_u *buf; 2722 int bufno; 2723 nbbuf_T *nbbuf; 2724 pos_T pos; 2725 long off; 2726 char_u *p; 2727 char_u *newtxt; 2728 2729 if (!NETBEANS_OPEN) 2730 return; 2731 2732 nbbuf = nb_bufp2nbbuf_fire(bufp, &bufno); 2733 if (nbbuf == NULL) 2734 return; 2735 2736 /* Don't mark as modified for initial read */ 2737 if (nbbuf->insertDone) 2738 nbbuf->modified = 1; 2739 2740 pos.lnum = linenr; 2741 pos.col = col; 2742 off = pos2off(bufp, &pos); 2743 2744 /* send the "insert" EVT */ 2745 newtxt = alloc(newlen + 1); 2746 vim_strncpy(newtxt, txt, newlen); 2747 p = nb_quote(newtxt); 2748 if (p != NULL) 2749 { 2750 buf = alloc(128 + 2*newlen); 2751 sprintf((char *)buf, "%d:insert=%d %ld \"%s\"\n", 2752 bufno, r_cmdno, off, p); 2753 nbdebug(("EVT: %s", buf)); 2754 nb_send((char *)buf, "netbeans_inserted"); 2755 vim_free(p); 2756 vim_free(buf); 2757 } 2758 vim_free(newtxt); 2759 } 2760 2761 /* 2762 * Tell netbeans some bytes have been removed. 2763 */ 2764 void 2765 netbeans_removed( 2766 buf_T *bufp, 2767 linenr_T linenr, 2768 colnr_T col, 2769 long len) 2770 { 2771 char_u buf[128]; 2772 int bufno; 2773 nbbuf_T *nbbuf; 2774 pos_T pos; 2775 long off; 2776 2777 if (!NETBEANS_OPEN) 2778 return; 2779 2780 nbbuf = nb_bufp2nbbuf_fire(bufp, &bufno); 2781 if (nbbuf == NULL) 2782 return; 2783 2784 if (len < 0) 2785 { 2786 nbdebug(("Negative len %ld in netbeans_removed()!\n", len)); 2787 return; 2788 } 2789 2790 nbbuf->modified = 1; 2791 2792 pos.lnum = linenr; 2793 pos.col = col; 2794 2795 off = pos2off(bufp, &pos); 2796 2797 sprintf((char *)buf, "%d:remove=%d %ld %ld\n", bufno, r_cmdno, off, len); 2798 nbdebug(("EVT: %s", buf)); 2799 nb_send((char *)buf, "netbeans_removed"); 2800 } 2801 2802 /* 2803 * Send netbeans an unmodified command. 2804 */ 2805 void 2806 netbeans_unmodified(buf_T *bufp UNUSED) 2807 { 2808 /* This is a no-op, because NetBeans considers a buffer modified 2809 * even when all changes have been undone. */ 2810 } 2811 2812 /* 2813 * Send a button release event back to netbeans. It's up to netbeans 2814 * to decide what to do (if anything) with this event. 2815 */ 2816 void 2817 netbeans_button_release(int button) 2818 { 2819 char buf[128]; 2820 int bufno; 2821 2822 if (!NETBEANS_OPEN) 2823 return; 2824 2825 bufno = nb_getbufno(curbuf); 2826 2827 if (bufno >= 0 && curwin != NULL && curwin->w_buffer == curbuf) 2828 { 2829 int col = mouse_col - curwin->w_wincol 2830 - ((curwin->w_p_nu || curwin->w_p_rnu) ? 9 : 1); 2831 long off = pos2off(curbuf, &curwin->w_cursor); 2832 2833 /* sync the cursor position */ 2834 sprintf(buf, "%d:newDotAndMark=%d %ld %ld\n", bufno, r_cmdno, off, off); 2835 nbdebug(("EVT: %s", buf)); 2836 nb_send(buf, "netbeans_button_release[newDotAndMark]"); 2837 2838 sprintf(buf, "%d:buttonRelease=%d %d %ld %d\n", bufno, r_cmdno, 2839 button, (long)curwin->w_cursor.lnum, col); 2840 nbdebug(("EVT: %s", buf)); 2841 nb_send(buf, "netbeans_button_release"); 2842 } 2843 } 2844 2845 2846 /* 2847 * Send a keypress event back to netbeans. This usually simulates some 2848 * kind of function key press. This function operates on a key code. 2849 * Return TRUE when the key was sent, FALSE when the command has been 2850 * postponed. 2851 */ 2852 int 2853 netbeans_keycommand(int key) 2854 { 2855 char keyName[60]; 2856 2857 netbeans_keyname(key, keyName); 2858 return netbeans_keystring((char_u *)keyName); 2859 } 2860 2861 2862 /* 2863 * Send a keypress event back to netbeans. This usually simulates some 2864 * kind of function key press. This function operates on a key string. 2865 * Return TRUE when the key was sent, FALSE when the command has been 2866 * postponed. 2867 */ 2868 static int 2869 netbeans_keystring(char_u *keyName) 2870 { 2871 char buf[2*MAXPATHL]; 2872 int bufno = nb_getbufno(curbuf); 2873 long off; 2874 char_u *q; 2875 2876 if (!NETBEANS_OPEN) 2877 return TRUE; 2878 2879 if (bufno == -1) 2880 { 2881 nbdebug(("got keycommand for non-NetBeans buffer, opening...\n")); 2882 q = curbuf->b_ffname == NULL ? (char_u *)"" 2883 : nb_quote(curbuf->b_ffname); 2884 if (q == NULL) 2885 return TRUE; 2886 vim_snprintf(buf, sizeof(buf), "0:fileOpened=%d \"%s\" %s %s\n", 0, 2887 q, 2888 "T", /* open in NetBeans */ 2889 "F"); /* modified */ 2890 if (curbuf->b_ffname != NULL) 2891 vim_free(q); 2892 nbdebug(("EVT: %s", buf)); 2893 nb_send(buf, "netbeans_keycommand"); 2894 2895 postpone_keycommand(keyName); 2896 return FALSE; 2897 } 2898 2899 /* sync the cursor position */ 2900 off = pos2off(curbuf, &curwin->w_cursor); 2901 sprintf(buf, "%d:newDotAndMark=%d %ld %ld\n", bufno, r_cmdno, off, off); 2902 nbdebug(("EVT: %s", buf)); 2903 nb_send(buf, "netbeans_keycommand"); 2904 2905 /* To work on Win32 you must apply patch to ExtEditor module 2906 * from ExtEdCaret.java.diff - make EVT_newDotAndMark handler 2907 * more synchronous 2908 */ 2909 2910 /* now send keyCommand event */ 2911 vim_snprintf(buf, sizeof(buf), "%d:keyCommand=%d \"%s\"\n", 2912 bufno, r_cmdno, keyName); 2913 nbdebug(("EVT: %s", buf)); 2914 nb_send(buf, "netbeans_keycommand"); 2915 2916 /* New: do both at once and include the lnum/col. */ 2917 vim_snprintf(buf, sizeof(buf), "%d:keyAtPos=%d \"%s\" %ld %ld/%ld\n", 2918 bufno, r_cmdno, keyName, 2919 off, (long)curwin->w_cursor.lnum, (long)curwin->w_cursor.col); 2920 nbdebug(("EVT: %s", buf)); 2921 nb_send(buf, "netbeans_keycommand"); 2922 return TRUE; 2923 } 2924 2925 2926 /* 2927 * Send a save event to netbeans. 2928 */ 2929 void 2930 netbeans_save_buffer(buf_T *bufp) 2931 { 2932 char_u buf[64]; 2933 int bufno; 2934 nbbuf_T *nbbuf; 2935 2936 if (!NETBEANS_OPEN) 2937 return; 2938 2939 nbbuf = nb_bufp2nbbuf_fire(bufp, &bufno); 2940 if (nbbuf == NULL) 2941 return; 2942 2943 nbbuf->modified = 0; 2944 2945 sprintf((char *)buf, "%d:save=%d\n", bufno, r_cmdno); 2946 nbdebug(("EVT: %s", buf)); 2947 nb_send((char *)buf, "netbeans_save_buffer"); 2948 } 2949 2950 2951 /* 2952 * Send remove command to netbeans (this command has been turned off). 2953 */ 2954 void 2955 netbeans_deleted_all_lines(buf_T *bufp) 2956 { 2957 char_u buf[64]; 2958 int bufno; 2959 nbbuf_T *nbbuf; 2960 2961 if (!NETBEANS_OPEN) 2962 return; 2963 2964 nbbuf = nb_bufp2nbbuf_fire(bufp, &bufno); 2965 if (nbbuf == NULL) 2966 return; 2967 2968 /* Don't mark as modified for initial read */ 2969 if (nbbuf->insertDone) 2970 nbbuf->modified = 1; 2971 2972 sprintf((char *)buf, "%d:remove=%d 0 -1\n", bufno, r_cmdno); 2973 nbdebug(("EVT(suppressed): %s", buf)); 2974 /* nb_send(buf, "netbeans_deleted_all_lines"); */ 2975 } 2976 2977 2978 /* 2979 * See if the lines are guarded. The top and bot parameters are from 2980 * u_savecommon(), these are the line above the change and the line below the 2981 * change. 2982 */ 2983 int 2984 netbeans_is_guarded(linenr_T top, linenr_T bot) 2985 { 2986 signlist_T *p; 2987 int lnum; 2988 2989 if (!NETBEANS_OPEN) 2990 return FALSE; 2991 2992 for (p = curbuf->b_signlist; p != NULL; p = p->next) 2993 if (p->id >= GUARDEDOFFSET) 2994 for (lnum = top + 1; lnum < bot; lnum++) 2995 if (lnum == p->lnum) 2996 return TRUE; 2997 2998 return FALSE; 2999 } 3000 3001 #if defined(FEAT_GUI_X11) || defined(PROTO) 3002 /* 3003 * We have multiple signs to draw at the same location. Draw the 3004 * multi-sign indicator instead. This is the Motif version. 3005 */ 3006 void 3007 netbeans_draw_multisign_indicator(int row) 3008 { 3009 int i; 3010 int y; 3011 int x; 3012 3013 if (!NETBEANS_OPEN) 3014 return; 3015 3016 x = 0; 3017 y = row * gui.char_height + 2; 3018 3019 for (i = 0; i < gui.char_height - 3; i++) 3020 XDrawPoint(gui.dpy, gui.wid, gui.text_gc, x+2, y++); 3021 3022 XDrawPoint(gui.dpy, gui.wid, gui.text_gc, x+0, y); 3023 XDrawPoint(gui.dpy, gui.wid, gui.text_gc, x+2, y); 3024 XDrawPoint(gui.dpy, gui.wid, gui.text_gc, x+4, y++); 3025 XDrawPoint(gui.dpy, gui.wid, gui.text_gc, x+1, y); 3026 XDrawPoint(gui.dpy, gui.wid, gui.text_gc, x+2, y); 3027 XDrawPoint(gui.dpy, gui.wid, gui.text_gc, x+3, y++); 3028 XDrawPoint(gui.dpy, gui.wid, gui.text_gc, x+2, y); 3029 } 3030 #endif /* FEAT_GUI_X11 */ 3031 3032 #if defined(FEAT_GUI_GTK) && !defined(PROTO) 3033 /* 3034 * We have multiple signs to draw at the same location. Draw the 3035 * multi-sign indicator instead. This is the GTK/Gnome version. 3036 */ 3037 void 3038 netbeans_draw_multisign_indicator(int row) 3039 { 3040 int i; 3041 int y; 3042 int x; 3043 #if GTK_CHECK_VERSION(3,0,0) 3044 cairo_t *cr = NULL; 3045 #else 3046 GdkDrawable *drawable = gui.drawarea->window; 3047 #endif 3048 3049 if (!NETBEANS_OPEN) 3050 return; 3051 3052 #if GTK_CHECK_VERSION(3,0,0) 3053 cr = cairo_create(gui.surface); 3054 cairo_set_source_rgba(cr, 3055 gui.fgcolor->red, gui.fgcolor->green, gui.fgcolor->blue, 3056 gui.fgcolor->alpha); 3057 #endif 3058 3059 x = 0; 3060 y = row * gui.char_height + 2; 3061 3062 for (i = 0; i < gui.char_height - 3; i++) 3063 #if GTK_CHECK_VERSION(3,0,0) 3064 cairo_rectangle(cr, x+2, y++, 1, 1); 3065 #else 3066 gdk_draw_point(drawable, gui.text_gc, x+2, y++); 3067 #endif 3068 3069 #if GTK_CHECK_VERSION(3,0,0) 3070 cairo_rectangle(cr, x+0, y, 1, 1); 3071 cairo_rectangle(cr, x+2, y, 1, 1); 3072 cairo_rectangle(cr, x+4, y++, 1, 1); 3073 cairo_rectangle(cr, x+1, y, 1, 1); 3074 cairo_rectangle(cr, x+2, y, 1, 1); 3075 cairo_rectangle(cr, x+3, y++, 1, 1); 3076 cairo_rectangle(cr, x+2, y, 1, 1); 3077 #else 3078 gdk_draw_point(drawable, gui.text_gc, x+0, y); 3079 gdk_draw_point(drawable, gui.text_gc, x+2, y); 3080 gdk_draw_point(drawable, gui.text_gc, x+4, y++); 3081 gdk_draw_point(drawable, gui.text_gc, x+1, y); 3082 gdk_draw_point(drawable, gui.text_gc, x+2, y); 3083 gdk_draw_point(drawable, gui.text_gc, x+3, y++); 3084 gdk_draw_point(drawable, gui.text_gc, x+2, y); 3085 #endif 3086 3087 #if GTK_CHECK_VERSION(3,0,0) 3088 cairo_destroy(cr); 3089 #endif 3090 } 3091 #endif /* FEAT_GUI_GTK */ 3092 3093 /* 3094 * If the mouse is clicked in the gutter of a line with multiple 3095 * annotations, cycle through the set of signs. 3096 */ 3097 void 3098 netbeans_gutter_click(linenr_T lnum) 3099 { 3100 signlist_T *p; 3101 3102 if (!NETBEANS_OPEN) 3103 return; 3104 3105 for (p = curbuf->b_signlist; p != NULL; p = p->next) 3106 { 3107 if (p->lnum == lnum && p->next && p->next->lnum == lnum) 3108 { 3109 signlist_T *tail; 3110 3111 /* remove "p" from list, reinsert it at the tail of the sublist */ 3112 if (p->prev) 3113 p->prev->next = p->next; 3114 else 3115 curbuf->b_signlist = p->next; 3116 p->next->prev = p->prev; 3117 /* now find end of sublist and insert p */ 3118 for (tail = p->next; 3119 tail->next && tail->next->lnum == lnum 3120 && tail->next->id < GUARDEDOFFSET; 3121 tail = tail->next) 3122 ; 3123 /* tail now points to last entry with same lnum (except 3124 * that "guarded" annotations are always last) */ 3125 p->next = tail->next; 3126 if (tail->next) 3127 tail->next->prev = p; 3128 p->prev = tail; 3129 tail->next = p; 3130 update_debug_sign(curbuf, lnum); 3131 break; 3132 } 3133 } 3134 } 3135 3136 /* 3137 * Add a sign of the requested type at the requested location. 3138 * 3139 * Reverse engineering: 3140 * Apparently an annotation is defined the first time it is used in a buffer. 3141 * When the same annotation is used in two buffers, the second time we do not 3142 * need to define a new sign name but reuse the existing one. But since the 3143 * ID number used in the second buffer starts counting at one again, a mapping 3144 * is made from the ID specifically for the buffer to the global sign name 3145 * (which is a number). 3146 * 3147 * globalsignmap[] stores the signs that have been defined globally. 3148 * buf->signmapused[] maps buffer-local annotation IDs to an index in 3149 * globalsignmap[]. 3150 */ 3151 static void 3152 addsigntype( 3153 nbbuf_T *buf, 3154 int typeNum, 3155 char_u *typeName, 3156 char_u *tooltip UNUSED, 3157 char_u *glyphFile, 3158 char_u *fg, 3159 char_u *bg) 3160 { 3161 int i, j; 3162 int use_fg = (*fg && STRCMP(fg, "none") != 0); 3163 int use_bg = (*bg && STRCMP(bg, "none") != 0); 3164 3165 for (i = 0; i < globalsignmapused; i++) 3166 if (STRCMP(typeName, globalsignmap[i]) == 0) 3167 break; 3168 3169 if (i == globalsignmapused) /* not found; add it to global map */ 3170 { 3171 nbdebug(("DEFINEANNOTYPE(%d,%s,%s,%s,%s,%s)\n", 3172 typeNum, typeName, tooltip, glyphFile, fg, bg)); 3173 if (use_fg || use_bg) 3174 { 3175 char fgbuf[2 * (8 + MAX_COLOR_LENGTH) + 1]; 3176 char bgbuf[2 * (8 + MAX_COLOR_LENGTH) + 1]; 3177 char *ptr; 3178 int value; 3179 3180 value = strtol((char *)fg, &ptr, 10); 3181 if (ptr != (char *)fg) 3182 sprintf(fgbuf, "guifg=#%06x", value & 0xFFFFFF); 3183 else 3184 sprintf(fgbuf, "guifg=%s ctermfg=%s", fg, fg); 3185 3186 value = strtol((char *)bg, &ptr, 10); 3187 if (ptr != (char *)bg) 3188 sprintf(bgbuf, "guibg=#%06x", value & 0xFFFFFF); 3189 else 3190 sprintf(bgbuf, "guibg=%s ctermbg=%s", bg, bg); 3191 3192 coloncmd(":highlight NB_%s %s %s", typeName, (use_fg) ? fgbuf : "", 3193 (use_bg) ? bgbuf : ""); 3194 if (*glyphFile == NUL) 3195 /* no glyph, line highlighting only */ 3196 coloncmd(":sign define %d linehl=NB_%s", i + 1, typeName); 3197 else if (vim_strsize(glyphFile) <= 2) 3198 /* one- or two-character glyph name, use as text glyph with 3199 * texthl */ 3200 coloncmd(":sign define %d text=%s texthl=NB_%s", i + 1, 3201 glyphFile, typeName); 3202 else 3203 /* glyph, line highlighting */ 3204 coloncmd(":sign define %d icon=%s linehl=NB_%s", i + 1, 3205 glyphFile, typeName); 3206 } 3207 else 3208 /* glyph, no line highlighting */ 3209 coloncmd(":sign define %d icon=%s", i + 1, glyphFile); 3210 3211 if (STRCMP(typeName,"CurrentPC") == 0) 3212 curPCtype = typeNum; 3213 3214 if (globalsignmapused == globalsignmaplen) 3215 { 3216 if (globalsignmaplen == 0) /* first allocation */ 3217 { 3218 globalsignmaplen = 20; 3219 globalsignmap = (char **)alloc_clear(globalsignmaplen*sizeof(char *)); 3220 } 3221 else /* grow it */ 3222 { 3223 int incr; 3224 int oldlen = globalsignmaplen; 3225 char **t_globalsignmap = globalsignmap; 3226 3227 globalsignmaplen *= 2; 3228 incr = globalsignmaplen - oldlen; 3229 globalsignmap = (char **)vim_realloc(globalsignmap, 3230 globalsignmaplen * sizeof(char *)); 3231 if (globalsignmap == NULL) 3232 { 3233 vim_free(t_globalsignmap); 3234 globalsignmaplen = 0; 3235 return; 3236 } 3237 vim_memset(globalsignmap + oldlen, 0, incr * sizeof(char *)); 3238 } 3239 } 3240 3241 globalsignmap[i] = (char *)typeName; 3242 globalsignmapused = i + 1; 3243 } 3244 3245 /* check local map; should *not* be found! */ 3246 for (j = 0; j < buf->signmapused; j++) 3247 if (buf->signmap[j] == i + 1) 3248 return; 3249 3250 /* add to local map */ 3251 if (buf->signmapused == buf->signmaplen) 3252 { 3253 if (buf->signmaplen == 0) /* first allocation */ 3254 { 3255 buf->signmaplen = 5; 3256 buf->signmap = (int *)alloc_clear(buf->signmaplen * sizeof(int)); 3257 } 3258 else /* grow it */ 3259 { 3260 int incr; 3261 int oldlen = buf->signmaplen; 3262 int *t_signmap = buf->signmap; 3263 3264 buf->signmaplen *= 2; 3265 incr = buf->signmaplen - oldlen; 3266 buf->signmap = (int *)vim_realloc(buf->signmap, 3267 buf->signmaplen * sizeof(int)); 3268 if (buf->signmap == NULL) 3269 { 3270 vim_free(t_signmap); 3271 buf->signmaplen = 0; 3272 return; 3273 } 3274 vim_memset(buf->signmap + oldlen, 0, incr * sizeof(int)); 3275 } 3276 } 3277 3278 buf->signmap[buf->signmapused++] = i + 1; 3279 3280 } 3281 3282 3283 /* 3284 * See if we have the requested sign type in the buffer. 3285 */ 3286 static int 3287 mapsigntype(nbbuf_T *buf, int localsigntype) 3288 { 3289 if (--localsigntype >= 0 && localsigntype < buf->signmapused) 3290 return buf->signmap[localsigntype]; 3291 3292 return 0; 3293 } 3294 3295 3296 /* 3297 * Compute length of buffer, don't print anything. 3298 */ 3299 static long 3300 get_buf_size(buf_T *bufp) 3301 { 3302 linenr_T lnum; 3303 long char_count = 0; 3304 int eol_size; 3305 long last_check = 100000L; 3306 3307 if (bufp->b_ml.ml_flags & ML_EMPTY) 3308 return 0; 3309 else 3310 { 3311 if (get_fileformat(bufp) == EOL_DOS) 3312 eol_size = 2; 3313 else 3314 eol_size = 1; 3315 for (lnum = 1; lnum <= bufp->b_ml.ml_line_count; ++lnum) 3316 { 3317 char_count += (long)STRLEN(ml_get_buf(bufp, lnum, FALSE)) 3318 + eol_size; 3319 /* Check for a CTRL-C every 100000 characters */ 3320 if (char_count > last_check) 3321 { 3322 ui_breakcheck(); 3323 if (got_int) 3324 return char_count; 3325 last_check = char_count + 100000L; 3326 } 3327 } 3328 /* Correction for when last line doesn't have an EOL. */ 3329 if (!bufp->b_p_eol && (bufp->b_p_bin || !bufp->b_p_fixeol)) 3330 char_count -= eol_size; 3331 } 3332 3333 return char_count; 3334 } 3335 3336 /* 3337 * Convert character offset to lnum,col 3338 */ 3339 static pos_T * 3340 off2pos(buf_T *buf, long offset) 3341 { 3342 linenr_T lnum; 3343 static pos_T pos; 3344 3345 pos.lnum = 0; 3346 pos.col = 0; 3347 pos.coladd = 0; 3348 3349 if (!(buf->b_ml.ml_flags & ML_EMPTY)) 3350 { 3351 if ((lnum = ml_find_line_or_offset(buf, (linenr_T)0, &offset)) < 0) 3352 return NULL; 3353 pos.lnum = lnum; 3354 pos.col = offset; 3355 } 3356 3357 return &pos; 3358 } 3359 3360 /* 3361 * Convert an argument in the form "1234" to an offset and compute the 3362 * lnum/col from it. Convert an argument in the form "123/12" directly to a 3363 * lnum/col. 3364 * "argp" is advanced to after the argument. 3365 * Return a pointer to the position, NULL if something is wrong. 3366 */ 3367 static pos_T * 3368 get_off_or_lnum(buf_T *buf, char_u **argp) 3369 { 3370 static pos_T mypos; 3371 long off; 3372 3373 off = strtol((char *)*argp, (char **)argp, 10); 3374 if (**argp == '/') 3375 { 3376 mypos.lnum = (linenr_T)off; 3377 ++*argp; 3378 mypos.col = strtol((char *)*argp, (char **)argp, 10); 3379 mypos.coladd = 0; 3380 return &mypos; 3381 } 3382 return off2pos(buf, off); 3383 } 3384 3385 3386 /* 3387 * Convert (lnum,col) to byte offset in the file. 3388 */ 3389 static long 3390 pos2off(buf_T *buf, pos_T *pos) 3391 { 3392 long offset = 0; 3393 3394 if (!(buf->b_ml.ml_flags & ML_EMPTY)) 3395 { 3396 if ((offset = ml_find_line_or_offset(buf, pos->lnum, 0)) < 0) 3397 return 0; 3398 offset += pos->col; 3399 } 3400 3401 return offset; 3402 } 3403 3404 3405 /* 3406 * This message is printed after NetBeans opens a new file. It's 3407 * similar to the message readfile() uses, but since NetBeans 3408 * doesn't normally call readfile, we do our own. 3409 */ 3410 static void 3411 print_read_msg(nbbuf_T *buf) 3412 { 3413 int lnum = buf->bufp->b_ml.ml_line_count; 3414 off_T nchars = buf->bufp->b_orig_size; 3415 char_u c; 3416 3417 msg_add_fname(buf->bufp, buf->bufp->b_ffname); 3418 c = FALSE; 3419 3420 if (buf->bufp->b_p_ro) 3421 { 3422 STRCAT(IObuff, shortmess(SHM_RO) ? _("[RO]") : _("[readonly]")); 3423 c = TRUE; 3424 } 3425 if (!buf->bufp->b_start_eol) 3426 { 3427 STRCAT(IObuff, shortmess(SHM_LAST) ? _("[noeol]") 3428 : _("[Incomplete last line]")); 3429 c = TRUE; 3430 } 3431 msg_add_lines(c, (long)lnum, nchars); 3432 3433 /* Now display it */ 3434 VIM_CLEAR(keep_msg); 3435 msg_scrolled_ign = TRUE; 3436 msg_trunc_attr((char *)IObuff, FALSE, 0); 3437 msg_scrolled_ign = FALSE; 3438 } 3439 3440 3441 /* 3442 * Print a message after NetBeans writes the file. This message should be 3443 * identical to the standard message a non-netbeans user would see when 3444 * writing a file. 3445 */ 3446 static void 3447 print_save_msg(nbbuf_T *buf, off_T nchars) 3448 { 3449 char_u c; 3450 char_u *p; 3451 3452 if (nchars >= 0) 3453 { 3454 /* put fname in IObuff with quotes */ 3455 msg_add_fname(buf->bufp, buf->bufp->b_ffname); 3456 c = FALSE; 3457 3458 msg_add_lines(c, buf->bufp->b_ml.ml_line_count, 3459 buf->bufp->b_orig_size); 3460 3461 VIM_CLEAR(keep_msg); 3462 msg_scrolled_ign = TRUE; 3463 p = (char_u *)msg_trunc_attr((char *)IObuff, FALSE, 0); 3464 if ((msg_scrolled && !need_wait_return) || !buf->initDone) 3465 { 3466 /* Need to repeat the message after redrawing when: 3467 * - When reading from stdin (the screen will be cleared next). 3468 * - When restart_edit is set (otherwise there will be a delay 3469 * before redrawing). 3470 * - When the screen was scrolled but there is no wait-return 3471 * prompt. */ 3472 set_keep_msg(p, 0); 3473 } 3474 msg_scrolled_ign = FALSE; 3475 /* add_to_input_buf((char_u *)"\f", 1); */ 3476 } 3477 else 3478 { 3479 char msgbuf[IOSIZE]; 3480 3481 vim_snprintf(msgbuf, IOSIZE, 3482 _("E505: %s is read-only (add ! to override)"), IObuff); 3483 nbdebug((" %s\n", msgbuf)); 3484 emsg(msgbuf); 3485 } 3486 } 3487 3488 #endif /* defined(FEAT_NETBEANS_INTG) */ 3489