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