Annotation of src/usr.bin/vim/misccmds.c, Revision 1.1
1.1 ! downsj 1: /* $OpenBSD$ */
! 2: /* vi:set ts=4 sw=4:
! 3: *
! 4: * VIM - Vi IMproved by Bram Moolenaar
! 5: *
! 6: * Do ":help uganda" in Vim to read copying and usage conditions.
! 7: * Do ":help credits" in Vim to see a list of people who contributed.
! 8: */
! 9:
! 10: /*
! 11: * misccmds.c: functions that didn't seem to fit elsewhere
! 12: */
! 13:
! 14: #include "vim.h"
! 15: #include "globals.h"
! 16: #include "proto.h"
! 17: #include "option.h"
! 18: #ifdef HAVE_FCNTL_H
! 19: # include <fcntl.h> /* for chdir() */
! 20: #endif
! 21:
! 22: static int get_indent_str __ARGS((char_u *ptr));
! 23: static void check_status __ARGS((BUF *));
! 24:
! 25: /*
! 26: * count the size of the indent in the current line
! 27: */
! 28: int
! 29: get_indent()
! 30: {
! 31: return get_indent_str(ml_get_curline());
! 32: }
! 33:
! 34: /*
! 35: * count the size of the indent in line "lnum"
! 36: */
! 37: int
! 38: get_indent_lnum(lnum)
! 39: linenr_t lnum;
! 40: {
! 41: return get_indent_str(ml_get(lnum));
! 42: }
! 43:
! 44: /*
! 45: * count the size of the indent in line "ptr"
! 46: */
! 47: static int
! 48: get_indent_str(ptr)
! 49: register char_u *ptr;
! 50: {
! 51: register int count = 0;
! 52:
! 53: for ( ; *ptr; ++ptr)
! 54: {
! 55: if (*ptr == TAB) /* count a tab for what it is worth */
! 56: count += (int)curbuf->b_p_ts - (count % (int)curbuf->b_p_ts);
! 57: else if (*ptr == ' ')
! 58: ++count; /* count a space for one */
! 59: else
! 60: break;
! 61: }
! 62: return (count);
! 63: }
! 64:
! 65: /*
! 66: * set the indent of the current line
! 67: * leaves the cursor on the first non-blank in the line
! 68: */
! 69: void
! 70: set_indent(size, del_first)
! 71: register int size;
! 72: int del_first;
! 73: {
! 74: int oldstate = State;
! 75: register int c;
! 76:
! 77: State = INSERT; /* don't want REPLACE for State */
! 78: curwin->w_cursor.col = 0;
! 79: if (del_first) /* delete old indent */
! 80: {
! 81: /* vim_iswhite() is a define! */
! 82: while ((c = gchar_cursor()), vim_iswhite(c))
! 83: (void)delchar(FALSE);
! 84: }
! 85: if (!curbuf->b_p_et) /* if 'expandtab' is set, don't use TABs */
! 86: while (size >= (int)curbuf->b_p_ts)
! 87: {
! 88: ins_char(TAB);
! 89: size -= (int)curbuf->b_p_ts;
! 90: }
! 91: while (size)
! 92: {
! 93: ins_char(' ');
! 94: --size;
! 95: }
! 96: State = oldstate;
! 97: }
! 98:
! 99: #if defined(CINDENT) || defined(SMARTINDENT)
! 100:
! 101: static int is_cinword __ARGS((char_u *line));
! 102:
! 103: /*
! 104: * Return TRUE if the string "line" starts with a word from 'cinwords'.
! 105: */
! 106: static int
! 107: is_cinword(line)
! 108: char_u *line;
! 109: {
! 110: char_u *cinw;
! 111: char_u *cinw_buf;
! 112: int cinw_len;
! 113: int retval = FALSE;
! 114: int len;
! 115:
! 116: cinw_len = STRLEN(curbuf->b_p_cinw) + 1;
! 117: cinw_buf = alloc((unsigned)cinw_len);
! 118: if (cinw_buf != NULL)
! 119: {
! 120: line = skipwhite(line);
! 121: for (cinw = curbuf->b_p_cinw; *cinw; )
! 122: {
! 123: len = copy_option_part(&cinw, cinw_buf, cinw_len, ",");
! 124: if (STRNCMP(line, cinw_buf, len) == 0 &&
! 125: (!iswordchar(line[len]) || !iswordchar(line[len - 1])))
! 126: {
! 127: retval = TRUE;
! 128: break;
! 129: }
! 130: }
! 131: vim_free(cinw_buf);
! 132: }
! 133: return retval;
! 134: }
! 135: #endif
! 136:
! 137: /*
! 138: * Opencmd
! 139: *
! 140: * Add a new line below or above the current line.
! 141: * Caller must take care of undo.
! 142: *
! 143: * Return TRUE for success, FALSE for failure
! 144: */
! 145:
! 146: int
! 147: Opencmd(dir, redraw, del_spaces)
! 148: int dir; /* FORWARD or BACKWARD */
! 149: int redraw; /* redraw afterwards */
! 150: int del_spaces; /* delete spaces after cursor */
! 151: {
! 152: char_u *saved_line; /* copy of the original line */
! 153: char_u *p_extra = NULL; /* what goes to next line */
! 154: int extra_len = 0; /* length of p_extra string */
! 155: FPOS old_cursor; /* old cursor position */
! 156: int newcol = 0; /* new cursor column */
! 157: int newindent = 0; /* auto-indent of the new line */
! 158: int n;
! 159: int trunc_line = FALSE; /* truncate current line afterwards */
! 160: int retval = FALSE; /* return value, default is FAIL */
! 161: int lead_len; /* length of comment leader */
! 162: char_u *lead_flags; /* position in 'comments' for comment leader */
! 163: char_u *leader = NULL; /* copy of comment leader */
! 164: char_u *allocated = NULL; /* allocated memory */
! 165: char_u *p;
! 166: int saved_char = NUL; /* init for GCC */
! 167: FPOS *pos;
! 168: int old_plines = 0; /* init for GCC */
! 169: int new_plines = 0; /* init for GCC */
! 170: #ifdef SMARTINDENT
! 171: int no_si = FALSE; /* reset did_si afterwards */
! 172: int first_char = NUL; /* init for GCC */
! 173: #endif
! 174:
! 175: /*
! 176: * make a copy of the current line so we can mess with it
! 177: */
! 178: saved_line = strsave(ml_get_curline());
! 179: if (saved_line == NULL) /* out of memory! */
! 180: return FALSE;
! 181:
! 182: if (State == INSERT || State == REPLACE)
! 183: {
! 184: p_extra = saved_line + curwin->w_cursor.col;
! 185: #ifdef SMARTINDENT
! 186: if (curbuf->b_p_si) /* need first char after new line break */
! 187: {
! 188: p = skipwhite(p_extra);
! 189: first_char = *p;
! 190: }
! 191: #endif
! 192: extra_len = STRLEN(p_extra);
! 193: saved_char = *p_extra;
! 194: *p_extra = NUL;
! 195: }
! 196:
! 197: u_clearline(); /* cannot do "U" command when adding lines */
! 198: #ifdef SMARTINDENT
! 199: did_si = FALSE;
! 200: #endif
! 201:
! 202: /*
! 203: * If 'autoindent' and/or 'smartindent' is set, try to figure out what
! 204: * indent to use for the new line.
! 205: */
! 206: if (curbuf->b_p_ai
! 207: #ifdef SMARTINDENT
! 208: || curbuf->b_p_si
! 209: #endif
! 210: )
! 211: {
! 212: /*
! 213: * count white space on current line
! 214: */
! 215: newindent = get_indent();
! 216: if (newindent == 0)
! 217: newindent = old_indent; /* for ^^D command in insert mode */
! 218: old_indent = 0;
! 219:
! 220: /*
! 221: * If we just did an auto-indent, then we didn't type anything on
! 222: * the prior line, and it should be truncated.
! 223: */
! 224: if (dir == FORWARD && did_ai)
! 225: trunc_line = TRUE;
! 226:
! 227: #ifdef SMARTINDENT
! 228: /*
! 229: * Do smart indenting.
! 230: * In insert/replace mode (only when dir == FORWARD)
! 231: * we may move some text to the next line. If it starts with '{'
! 232: * don't add an indent. Fixes inserting a NL before '{' in line
! 233: * "if (condition) {"
! 234: */
! 235: else if (curbuf->b_p_si && *saved_line != NUL &&
! 236: (p_extra == NULL || first_char != '{'))
! 237: {
! 238: char_u *ptr;
! 239: char_u last_char;
! 240:
! 241: old_cursor = curwin->w_cursor;
! 242: ptr = saved_line;
! 243: lead_len = get_leader_len(ptr, NULL);
! 244: if (dir == FORWARD)
! 245: {
! 246: /*
! 247: * Skip preprocessor directives, unless they are
! 248: * recognised as comments.
! 249: */
! 250: if (lead_len == 0 && ptr[0] == '#')
! 251: {
! 252: while (ptr[0] == '#' && curwin->w_cursor.lnum > 1)
! 253: ptr = ml_get(--curwin->w_cursor.lnum);
! 254: newindent = get_indent();
! 255: }
! 256: lead_len = get_leader_len(ptr, NULL);
! 257: if (lead_len > 0)
! 258: {
! 259: /*
! 260: * This case gets the following right:
! 261: * \*
! 262: * * A comment (read "\" as "/").
! 263: * *\
! 264: * #define IN_THE_WAY
! 265: * This should line up here;
! 266: */
! 267: p = skipwhite(ptr);
! 268: if (p[0] == '/' && p[1] == '*')
! 269: p++;
! 270: if (p[0] == '*')
! 271: {
! 272: for (p++; *p; p++)
! 273: {
! 274: if (p[0] == '/' && p[-1] == '*')
! 275: {
! 276: /*
! 277: * End of C comment, indent should line up
! 278: * with the line containing the start of
! 279: * the comment
! 280: */
! 281: curwin->w_cursor.col = p - ptr;
! 282: if ((pos = findmatch(NUL)) != NULL)
! 283: {
! 284: curwin->w_cursor.lnum = pos->lnum;
! 285: newindent = get_indent();
! 286: }
! 287: }
! 288: }
! 289: }
! 290: }
! 291: else /* Not a comment line */
! 292: {
! 293: /* Find last non-blank in line */
! 294: p = ptr + STRLEN(ptr) - 1;
! 295: while (p > ptr && vim_iswhite(*p))
! 296: --p;
! 297: last_char = *p;
! 298:
! 299: /*
! 300: * find the character just before the '{' or ';'
! 301: */
! 302: if (last_char == '{' || last_char == ';')
! 303: {
! 304: if (p > ptr)
! 305: --p;
! 306: while (p > ptr && vim_iswhite(*p))
! 307: --p;
! 308: }
! 309: /*
! 310: * Try to catch lines that are split over multiple
! 311: * lines. eg:
! 312: * if (condition &&
! 313: * condition) {
! 314: * Should line up here!
! 315: * }
! 316: */
! 317: if (*p == ')')
! 318: {
! 319: curwin->w_cursor.col = p - ptr;
! 320: if ((pos = findmatch('(')) != NULL)
! 321: {
! 322: curwin->w_cursor.lnum = pos->lnum;
! 323: newindent = get_indent();
! 324: ptr = ml_get_curline();
! 325: }
! 326: }
! 327: /*
! 328: * If last character is '{' do indent, without
! 329: * checking for "if" and the like.
! 330: */
! 331: if (last_char == '{')
! 332: {
! 333: did_si = TRUE; /* do indent */
! 334: no_si = TRUE; /* don't delete it when '{' typed */
! 335: }
! 336: /*
! 337: * Look for "if" and the like, use 'cinwords'.
! 338: * Don't do this if the previous line ended in ';' or
! 339: * '}'.
! 340: */
! 341: else if (last_char != ';' && last_char != '}' &&
! 342: is_cinword(ptr))
! 343: did_si = TRUE;
! 344: }
! 345: }
! 346: else /* dir == BACKWARD */
! 347: {
! 348: /*
! 349: * Skip preprocessor directives, unless they are
! 350: * recognised as comments.
! 351: */
! 352: if (lead_len == 0 && ptr[0] == '#')
! 353: {
! 354: int was_backslashed = FALSE;
! 355:
! 356: while ((ptr[0] == '#' || was_backslashed) &&
! 357: curwin->w_cursor.lnum < curbuf->b_ml.ml_line_count)
! 358: {
! 359: if (*ptr && ptr[STRLEN(ptr) - 1] == '\\')
! 360: was_backslashed = TRUE;
! 361: else
! 362: was_backslashed = FALSE;
! 363: ptr = ml_get(++curwin->w_cursor.lnum);
! 364: }
! 365: if (was_backslashed)
! 366: newindent = 0; /* Got to end of file */
! 367: else
! 368: newindent = get_indent();
! 369: }
! 370: p = skipwhite(ptr);
! 371: if (*p == '}') /* if line starts with '}': do indent */
! 372: did_si = TRUE;
! 373: else /* can delete indent when '{' typed */
! 374: can_si_back = TRUE;
! 375: }
! 376: curwin->w_cursor = old_cursor;
! 377: }
! 378: if (curbuf->b_p_si)
! 379: can_si = TRUE;
! 380: #endif /* SMARTINDENT */
! 381:
! 382: did_ai = TRUE;
! 383: }
! 384:
! 385: /*
! 386: * Find out if the current line starts with a comment leader.
! 387: * This may then be inserted in front of the new line.
! 388: */
! 389: lead_len = get_leader_len(saved_line, &lead_flags);
! 390: if (lead_len > 0)
! 391: {
! 392: char_u *lead_repl = NULL; /* replaces comment leader */
! 393: int lead_repl_len = 0; /* length of *lead_repl */
! 394: char_u lead_middle[COM_MAX_LEN]; /* middle-comment string */
! 395: char_u lead_end[COM_MAX_LEN]; /* end-comment string */
! 396: char_u *comment_end = NULL; /* where lead_end has been found */
! 397: int extra_space = FALSE; /* append extra space */
! 398: int current_flag;
! 399:
! 400: /*
! 401: * If the comment leader has the start, middle or end flag, it may not
! 402: * be used or may be replaced with the middle leader.
! 403: */
! 404: for (p = lead_flags; *p && *p != ':'; ++p)
! 405: {
! 406: if (*p == COM_START || *p == COM_MIDDLE)
! 407: {
! 408: current_flag = *p;
! 409: if (*p == COM_START)
! 410: {
! 411: /*
! 412: * Doing "O" on a start of comment does not insert leader.
! 413: */
! 414: if (dir == BACKWARD)
! 415: {
! 416: lead_len = 0;
! 417: break;
! 418: }
! 419:
! 420: /* find start of middle part */
! 421: (void)copy_option_part(&p, lead_middle, COM_MAX_LEN, ",");
! 422: }
! 423:
! 424: /*
! 425: * Isolate the strings of the middle and end leader.
! 426: */
! 427: while (*p && p[-1] != ':') /* find end of middle flags */
! 428: ++p;
! 429: (void)copy_option_part(&p, lead_middle, COM_MAX_LEN, ",");
! 430: while (*p && p[-1] != ':') /* find end of end flags */
! 431: ++p;
! 432: (void)copy_option_part(&p, lead_end, COM_MAX_LEN, ",");
! 433:
! 434: /*
! 435: * If the end of the comment is in the same line, don't use
! 436: * the comment leader.
! 437: */
! 438: if (dir == FORWARD)
! 439: {
! 440: n = STRLEN(lead_end);
! 441: for (p = saved_line + lead_len; *p; ++p)
! 442: if (STRNCMP(p, lead_end, n) == 0)
! 443: {
! 444: comment_end = p;
! 445: lead_len = 0;
! 446: break;
! 447: }
! 448: }
! 449:
! 450: /*
! 451: * Doing "o" on a start of comment inserts the middle leader.
! 452: */
! 453: if (lead_len)
! 454: {
! 455: if (current_flag == COM_START)
! 456: {
! 457: lead_repl = lead_middle;
! 458: lead_repl_len = STRLEN(lead_middle);
! 459: }
! 460:
! 461: /*
! 462: * If we have hit RETURN immediately after the start
! 463: * comment leader, then put a space after the middle
! 464: * comment leader on the next line.
! 465: */
! 466: if (!vim_iswhite(saved_line[lead_len - 1]) &&
! 467: ((p_extra != NULL &&
! 468: (int)curwin->w_cursor.col == lead_len) ||
! 469: (p_extra == NULL && saved_line[lead_len] == NUL)))
! 470: extra_space = TRUE;
! 471: }
! 472: break;
! 473: }
! 474: if (*p == COM_END)
! 475: {
! 476: /*
! 477: * Doing "o" on the end of a comment does not insert leader.
! 478: * Remember where the end is, might want to use it to find the
! 479: * start (for C-comments).
! 480: */
! 481: if (dir == FORWARD)
! 482: {
! 483: comment_end = skipwhite(saved_line);
! 484: lead_len = 0;
! 485: break;
! 486: }
! 487:
! 488: /*
! 489: * Doing "O" on the end of a comment inserts the middle leader.
! 490: * Find the string for the middle leader, searching backwards.
! 491: */
! 492: while (p > curbuf->b_p_com && *p != ',')
! 493: --p;
! 494: for (lead_repl = p; lead_repl > curbuf->b_p_com &&
! 495: lead_repl[-1] != ':'; --lead_repl)
! 496: ;
! 497: lead_repl_len = p - lead_repl;
! 498: break;
! 499: }
! 500: if (*p == COM_FIRST)
! 501: {
! 502: /*
! 503: * Comment leader for first line only: Don't repeat leader
! 504: * when using "O", blank out leader when using "o".
! 505: */
! 506: if (dir == BACKWARD)
! 507: lead_len = 0;
! 508: else
! 509: {
! 510: lead_repl = (char_u *)"";
! 511: lead_repl_len = 0;
! 512: }
! 513: break;
! 514: }
! 515: }
! 516: if (lead_len)
! 517: {
! 518: /* allocate buffer (may concatenate p_exta later) */
! 519: leader = alloc(lead_len + lead_repl_len + extra_space +
! 520: extra_len + 1);
! 521: allocated = leader; /* remember to free it later */
! 522:
! 523: if (leader == NULL)
! 524: lead_len = 0;
! 525: else
! 526: {
! 527: STRNCPY(leader, saved_line, lead_len);
! 528: leader[lead_len] = NUL;
! 529:
! 530: /*
! 531: * Replace leader with lead_repl, right or left adjusted
! 532: */
! 533: if (lead_repl != NULL)
! 534: {
! 535: for (p = lead_flags; *p && *p != ':'; ++p)
! 536: if (*p == COM_RIGHT || *p == COM_LEFT)
! 537: break;
! 538: if (*p == COM_RIGHT) /* right adjusted leader */
! 539: {
! 540: /* find last non-white in the leader to line up with */
! 541: for (p = leader + lead_len - 1; p > leader &&
! 542: vim_iswhite(*p); --p)
! 543: ;
! 544:
! 545: ++p;
! 546: if (p < leader + lead_repl_len)
! 547: p = leader;
! 548: else
! 549: p -= lead_repl_len;
! 550: vim_memmove(p, lead_repl, (size_t)lead_repl_len);
! 551: if (p + lead_repl_len > leader + lead_len)
! 552: p[lead_repl_len] = NUL;
! 553:
! 554: /* blank-out any other chars from the old leader. */
! 555: while (--p >= leader)
! 556: if (!vim_iswhite(*p))
! 557: *p = ' ';
! 558: }
! 559: else /* left adjusted leader */
! 560: {
! 561: p = skipwhite(leader);
! 562: vim_memmove(p, lead_repl, (size_t)lead_repl_len);
! 563:
! 564: /* blank-out any other chars from the old leader. */
! 565: for (p += lead_repl_len; p < leader + lead_len; ++p)
! 566: if (!vim_iswhite(*p))
! 567: *p = ' ';
! 568: *p = NUL;
! 569: }
! 570:
! 571: /* Recompute the indent, it may have changed. */
! 572: if (curbuf->b_p_ai
! 573: #ifdef SMARTINDENT
! 574: || curbuf->b_p_si
! 575: #endif
! 576: )
! 577: newindent = get_indent_str(leader);
! 578: }
! 579:
! 580: lead_len = STRLEN(leader);
! 581: if (extra_space)
! 582: {
! 583: leader[lead_len++] = ' ';
! 584: leader[lead_len] = NUL;
! 585: }
! 586:
! 587: newcol = lead_len;
! 588:
! 589: /*
! 590: * if a new indent will be set below, remove the indent that
! 591: * is in the comment leader
! 592: */
! 593: if (newindent
! 594: #ifdef SMARTINDENT
! 595: || did_si
! 596: #endif
! 597: )
! 598: {
! 599: while (lead_len && vim_iswhite(*leader))
! 600: {
! 601: --lead_len;
! 602: --newcol;
! 603: ++leader;
! 604: }
! 605: }
! 606:
! 607: }
! 608: #ifdef SMARTINDENT
! 609: did_si = can_si = FALSE;
! 610: #endif
! 611: }
! 612: else if (comment_end != NULL)
! 613: {
! 614: /*
! 615: * We have finished a comment, so we don't use the leader.
! 616: * If this was a C-comment and 'ai' or 'si' is set do a normal
! 617: * indent to align with the line containing the start of the
! 618: * comment.
! 619: */
! 620: if (comment_end[0] == '*' && comment_end[1] == '/' &&
! 621: (curbuf->b_p_ai
! 622: #ifdef SMARTINDENT
! 623: || curbuf->b_p_si
! 624: #endif
! 625: ))
! 626: {
! 627: old_cursor = curwin->w_cursor;
! 628: curwin->w_cursor.col = comment_end - saved_line;
! 629: if ((pos = findmatch(NUL)) != NULL)
! 630: {
! 631: curwin->w_cursor.lnum = pos->lnum;
! 632: newindent = get_indent();
! 633: }
! 634: curwin->w_cursor = old_cursor;
! 635: }
! 636: }
! 637: }
! 638:
! 639: /* (State == INSERT || State == REPLACE), only when dir == FORWARD */
! 640: if (p_extra != NULL)
! 641: {
! 642: *p_extra = saved_char; /* restore char that NUL replaced */
! 643:
! 644: /*
! 645: * When 'ai' set or "del_spaces" TRUE, skip to the first non-blank.
! 646: *
! 647: * When in REPLACE mode, put the deleted blanks on the replace
! 648: * stack, followed by a NUL, so they can be put back when
! 649: * a BS is entered.
! 650: */
! 651: if (State == REPLACE)
! 652: replace_push(NUL); /* end of extra blanks */
! 653: if (curbuf->b_p_ai || del_spaces)
! 654: {
! 655: while (*p_extra == ' ' || *p_extra == '\t')
! 656: {
! 657: if (State == REPLACE)
! 658: replace_push(*p_extra);
! 659: ++p_extra;
! 660: }
! 661: }
! 662: if (*p_extra != NUL)
! 663: did_ai = FALSE; /* append some text, don't trucate now */
! 664: }
! 665:
! 666: if (p_extra == NULL)
! 667: p_extra = (char_u *)""; /* append empty line */
! 668:
! 669: /* concatenate leader and p_extra, if there is a leader */
! 670: if (lead_len)
! 671: {
! 672: STRCAT(leader, p_extra);
! 673: p_extra = leader;
! 674: }
! 675:
! 676: old_cursor = curwin->w_cursor;
! 677: if (dir == BACKWARD)
! 678: --curwin->w_cursor.lnum;
! 679: if (ml_append(curwin->w_cursor.lnum, p_extra, (colnr_t)0, FALSE) == FAIL)
! 680: goto theend;
! 681: mark_adjust(curwin->w_cursor.lnum + 1, MAXLNUM, 1L, 0L);
! 682: if (newindent
! 683: #ifdef SMARTINDENT
! 684: || did_si
! 685: #endif
! 686: )
! 687: {
! 688: ++curwin->w_cursor.lnum;
! 689: #ifdef SMARTINDENT
! 690: if (did_si)
! 691: {
! 692: if (p_sr)
! 693: newindent -= newindent % (int)curbuf->b_p_sw;
! 694: newindent += (int)curbuf->b_p_sw;
! 695: }
! 696: #endif
! 697: set_indent(newindent, FALSE);
! 698: /*
! 699: * In REPLACE mode the new indent must be put on
! 700: * the replace stack for when it is deleted with BS
! 701: */
! 702: if (State == REPLACE)
! 703: for (n = 0; n < (int)curwin->w_cursor.col; ++n)
! 704: replace_push(NUL);
! 705: newcol += curwin->w_cursor.col;
! 706: #ifdef SMARTINDENT
! 707: if (no_si)
! 708: did_si = FALSE;
! 709: #endif
! 710: }
! 711: /*
! 712: * In REPLACE mode the extra leader must be put on the replace stack for
! 713: * when it is deleted with BS.
! 714: */
! 715: if (State == REPLACE)
! 716: while (lead_len-- > 0)
! 717: replace_push(NUL);
! 718:
! 719: curwin->w_cursor = old_cursor;
! 720:
! 721: if (dir == FORWARD)
! 722: {
! 723: if (redraw) /* want to know the old number of screen lines */
! 724: {
! 725: old_plines = plines(curwin->w_cursor.lnum);
! 726: new_plines = old_plines;
! 727: }
! 728: if (trunc_line || State == INSERT || State == REPLACE)
! 729: {
! 730: if (trunc_line)
! 731: {
! 732: /* find start of trailing white space */
! 733: for (n = STRLEN(saved_line); n > 0 &&
! 734: vim_iswhite(saved_line[n - 1]); --n)
! 735: ;
! 736: saved_line[n] = NUL;
! 737: }
! 738: else /* truncate current line at cursor */
! 739: *(saved_line + curwin->w_cursor.col) = NUL;
! 740: ml_replace(curwin->w_cursor.lnum, saved_line, FALSE);
! 741: saved_line = NULL;
! 742: new_plines = plines(curwin->w_cursor.lnum);
! 743: }
! 744:
! 745: /*
! 746: * Get the cursor to the start of the line, so that 'curwin->w_row'
! 747: * gets set to the right physical line number for the stuff that
! 748: * follows...
! 749: */
! 750: curwin->w_cursor.col = 0;
! 751:
! 752: if (redraw)
! 753: {
! 754: /*
! 755: * Call cursupdate() to compute w_row.
! 756: * But we don't want it to update the srceen.
! 757: */
! 758: ++RedrawingDisabled;
! 759: cursupdate();
! 760: --RedrawingDisabled;
! 761:
! 762: /*
! 763: * If we're doing an open on the last logical line, then go ahead
! 764: * and scroll the screen up. Otherwise, just insert a blank line
! 765: * at the right place if the number of screen lines changed.
! 766: * We use calls to plines() in case the cursor is resting on a
! 767: * long line, we want to know the row below the line.
! 768: */
! 769: n = curwin->w_row + new_plines;
! 770: if (n == curwin->w_winpos + curwin->w_height)
! 771: scrollup(1L);
! 772: else
! 773: win_ins_lines(curwin, n,
! 774: plines(curwin->w_cursor.lnum + 1) + new_plines - old_plines,
! 775: TRUE, TRUE);
! 776: }
! 777:
! 778: /*
! 779: * Put the cursor on the new line. Careful: the cursupdate() and
! 780: * scrollup() above may have moved w_cursor, we must use old_cursor.
! 781: */
! 782: curwin->w_cursor.lnum = old_cursor.lnum + 1;
! 783: }
! 784: else if (redraw) /* insert physical line above current line */
! 785: win_ins_lines(curwin, curwin->w_row, 1, TRUE, TRUE);
! 786:
! 787: curwin->w_cursor.col = newcol;
! 788:
! 789: #ifdef LISPINDENT
! 790: /*
! 791: * May do lisp indenting.
! 792: */
! 793: if (leader == NULL && curbuf->b_p_lisp && curbuf->b_p_ai)
! 794: fixthisline(get_lisp_indent);
! 795: #endif
! 796: #ifdef CINDENT
! 797: /*
! 798: * May do indenting after opening a new line.
! 799: */
! 800: if (leader == NULL && curbuf->b_p_cin &&
! 801: in_cinkeys(dir == FORWARD ? KEY_OPEN_FORW :
! 802: KEY_OPEN_BACK, ' ', linewhite(curwin->w_cursor.lnum)))
! 803: fixthisline(get_c_indent);
! 804: #endif
! 805:
! 806: if (redraw)
! 807: {
! 808: updateScreen(VALID_TO_CURSCHAR);
! 809: cursupdate(); /* update curwin->w_row */
! 810: }
! 811: CHANGED;
! 812:
! 813: retval = TRUE; /* success! */
! 814: theend:
! 815: vim_free(saved_line);
! 816: vim_free(allocated);
! 817: return retval;
! 818: }
! 819:
! 820: /*
! 821: * get_leader_len() returns the length of the prefix of the given string
! 822: * which introduces a comment. If this string is not a comment then 0 is
! 823: * returned.
! 824: * When "flags" is non-zero, it is set to point to the flags of the recognized
! 825: * comment leader.
! 826: */
! 827: int
! 828: get_leader_len(line, flags)
! 829: char_u *line;
! 830: char_u **flags;
! 831: {
! 832: int i, j;
! 833: int got_com = FALSE;
! 834: int found_one;
! 835: char_u part_buf[COM_MAX_LEN]; /* buffer for one option part */
! 836: char_u *string; /* pointer to comment string */
! 837: char_u *list;
! 838:
! 839: if (!fo_do_comments) /* don't format comments at all */
! 840: return 0;
! 841:
! 842: i = 0;
! 843: while (vim_iswhite(line[i])) /* leading white space is ignored */
! 844: ++i;
! 845:
! 846: /*
! 847: * Repeat to match several nested comment strings.
! 848: */
! 849: while (line[i])
! 850: {
! 851: /*
! 852: * scan through the 'comments' option for a match
! 853: */
! 854: found_one = FALSE;
! 855: for (list = curbuf->b_p_com; *list; )
! 856: {
! 857: /*
! 858: * Get one option part into part_buf[]. Advance list to next one.
! 859: * put string at start of string.
! 860: */
! 861: if (!got_com && flags != NULL) /* remember where flags started */
! 862: *flags = list;
! 863: (void)copy_option_part(&list, part_buf, COM_MAX_LEN, ",");
! 864: string = vim_strchr(part_buf, ':');
! 865: if (string == NULL) /* missing ':', ignore this part */
! 866: continue;
! 867: *string++ = NUL; /* isolate flags from string */
! 868:
! 869: /*
! 870: * When already found a nested comment, only accept further
! 871: * nested comments.
! 872: */
! 873: if (got_com && vim_strchr(part_buf, COM_NEST) == NULL)
! 874: continue;
! 875:
! 876: /*
! 877: * Line contents and string must match.
! 878: */
! 879: for (j = 0; string[j] != NUL && string[j] == line[i + j]; ++j)
! 880: ;
! 881: if (string[j] != NUL)
! 882: continue;
! 883:
! 884: /*
! 885: * When 'b' flag used, there must be white space or an
! 886: * end-of-line after the string in the line.
! 887: */
! 888: if (vim_strchr(part_buf, COM_BLANK) != NULL &&
! 889: !vim_iswhite(line[i + j]) && line[i + j] != NUL)
! 890: continue;
! 891:
! 892: /*
! 893: * We have found a match, stop searching.
! 894: */
! 895: i += j;
! 896: got_com = TRUE;
! 897: found_one = TRUE;
! 898: break;
! 899: }
! 900:
! 901: /*
! 902: * No match found, stop scanning.
! 903: */
! 904: if (!found_one)
! 905: break;
! 906:
! 907: /*
! 908: * Include any trailing white space.
! 909: */
! 910: while (vim_iswhite(line[i]))
! 911: ++i;
! 912:
! 913: /*
! 914: * If this comment doesn't nest, stop here.
! 915: */
! 916: if (vim_strchr(part_buf, COM_NEST) == NULL)
! 917: break;
! 918: }
! 919: return (got_com ? i : 0);
! 920: }
! 921:
! 922: /*
! 923: * plines(p) - return the number of physical screen lines taken by line 'p'
! 924: */
! 925: int
! 926: plines(p)
! 927: linenr_t p;
! 928: {
! 929: return plines_win(curwin, p);
! 930: }
! 931:
! 932: int
! 933: plines_win(wp, p)
! 934: WIN *wp;
! 935: linenr_t p;
! 936: {
! 937: register long col;
! 938: register char_u *s;
! 939: register int lines;
! 940:
! 941: if (!wp->w_p_wrap)
! 942: return 1;
! 943:
! 944: s = ml_get_buf(wp->w_buffer, p, FALSE);
! 945: if (*s == NUL) /* empty line */
! 946: return 1;
! 947:
! 948: col = linetabsize(s);
! 949:
! 950: /*
! 951: * If list mode is on, then the '$' at the end of the line takes up one
! 952: * extra column.
! 953: */
! 954: if (wp->w_p_list)
! 955: col += 1;
! 956:
! 957: /*
! 958: * If 'number' mode is on, add another 8.
! 959: */
! 960: if (wp->w_p_nu)
! 961: col += 8;
! 962:
! 963: lines = (col + (Columns - 1)) / Columns;
! 964: if (lines <= wp->w_height)
! 965: return lines;
! 966: return (int)(wp->w_height); /* maximum length */
! 967: }
! 968:
! 969: /*
! 970: * Count the physical lines (rows) for the lines "first" to "last" inclusive.
! 971: */
! 972: int
! 973: plines_m(first, last)
! 974: linenr_t first, last;
! 975: {
! 976: return plines_m_win(curwin, first, last);
! 977: }
! 978:
! 979: int
! 980: plines_m_win(wp, first, last)
! 981: WIN *wp;
! 982: linenr_t first, last;
! 983: {
! 984: int count = 0;
! 985:
! 986: while (first <= last)
! 987: count += plines_win(wp, first++);
! 988: return (count);
! 989: }
! 990:
! 991: /*
! 992: * Insert or replace a single character at the cursor position.
! 993: * When in REPLACE mode, replace any existing character.
! 994: */
! 995: void
! 996: ins_char(c)
! 997: int c;
! 998: {
! 999: register char_u *p;
! 1000: char_u *newp;
! 1001: char_u *oldp;
! 1002: int oldlen;
! 1003: int extra;
! 1004: colnr_t col = curwin->w_cursor.col;
! 1005: linenr_t lnum = curwin->w_cursor.lnum;
! 1006:
! 1007: oldp = ml_get(lnum);
! 1008: oldlen = STRLEN(oldp) + 1;
! 1009:
! 1010: if (State != REPLACE || *(oldp + col) == NUL)
! 1011: extra = 1;
! 1012: else
! 1013: extra = 0;
! 1014:
! 1015: /*
! 1016: * a character has to be put on the replace stack if there is a
! 1017: * character that is replaced, so it can be put back when BS is used.
! 1018: * Otherwise a 0 is put on the stack, indicating that a new character
! 1019: * was inserted, which can be deleted when BS is used.
! 1020: */
! 1021: if (State == REPLACE)
! 1022: replace_push(!extra ? *(oldp + col) : 0);
! 1023: newp = alloc_check((unsigned)(oldlen + extra));
! 1024: if (newp == NULL)
! 1025: return;
! 1026: vim_memmove(newp, oldp, (size_t)col);
! 1027: p = newp + col;
! 1028: vim_memmove(p + extra, oldp + col, (size_t)(oldlen - col));
! 1029: *p = c;
! 1030: ml_replace(lnum, newp, FALSE);
! 1031:
! 1032: /*
! 1033: * If we're in insert or replace mode and 'showmatch' is set, then check for
! 1034: * right parens and braces. If there isn't a match, then beep. If there
! 1035: * is a match AND it's on the screen, then flash to it briefly. If it
! 1036: * isn't on the screen, don't do anything.
! 1037: */
! 1038: #ifdef RIGHTLEFT
! 1039: if (p_sm && (State & INSERT) &&
! 1040: ((!curwin->w_p_rl && (c == ')' || c == '}' || c == ']')) ||
! 1041: (curwin->w_p_rl && (c == '(' || c == '{' || c == '['))))
! 1042: #else
! 1043: if (p_sm && (State & INSERT) && (c == ')' || c == '}' || c == ']'))
! 1044: #endif
! 1045: showmatch();
! 1046:
! 1047: #ifdef RIGHTLEFT
! 1048: if (!p_ri || State == REPLACE) /* normal insert: cursor right */
! 1049: #endif
! 1050: ++curwin->w_cursor.col;
! 1051: CHANGED;
! 1052: }
! 1053:
! 1054: /*
! 1055: * Insert a string at the cursor position.
! 1056: * Note: Nothing special for replace mode.
! 1057: */
! 1058: void
! 1059: ins_str(s)
! 1060: char_u *s;
! 1061: {
! 1062: register char_u *oldp, *newp;
! 1063: register int newlen = STRLEN(s);
! 1064: int oldlen;
! 1065: colnr_t col = curwin->w_cursor.col;
! 1066: linenr_t lnum = curwin->w_cursor.lnum;
! 1067:
! 1068: oldp = ml_get(lnum);
! 1069: oldlen = STRLEN(oldp);
! 1070:
! 1071: newp = alloc_check((unsigned)(oldlen + newlen + 1));
! 1072: if (newp == NULL)
! 1073: return;
! 1074: vim_memmove(newp, oldp, (size_t)col);
! 1075: vim_memmove(newp + col, s, (size_t)newlen);
! 1076: vim_memmove(newp + col + newlen, oldp + col, (size_t)(oldlen - col + 1));
! 1077: ml_replace(lnum, newp, FALSE);
! 1078: curwin->w_cursor.col += newlen;
! 1079: CHANGED;
! 1080: }
! 1081:
! 1082: /*
! 1083: * delete one character under the cursor
! 1084: *
! 1085: * return FAIL for failure, OK otherwise
! 1086: */
! 1087: int
! 1088: delchar(fixpos)
! 1089: int fixpos; /* if TRUE fix the cursor position when done */
! 1090: {
! 1091: char_u *oldp, *newp;
! 1092: colnr_t oldlen;
! 1093: linenr_t lnum = curwin->w_cursor.lnum;
! 1094: colnr_t col = curwin->w_cursor.col;
! 1095: int was_alloced;
! 1096:
! 1097: oldp = ml_get(lnum);
! 1098: oldlen = STRLEN(oldp);
! 1099:
! 1100: if (col >= oldlen) /* can't do anything (happens with replace mode) */
! 1101: return FAIL;
! 1102:
! 1103: /*
! 1104: * If the old line has been allocated the deletion can be done in the
! 1105: * existing line. Otherwise a new line has to be allocated
! 1106: */
! 1107: was_alloced = ml_line_alloced(); /* check if oldp was allocated */
! 1108: if (was_alloced)
! 1109: newp = oldp; /* use same allocated memory */
! 1110: else
! 1111: {
! 1112: newp = alloc((unsigned)oldlen); /* need to allocated a new line */
! 1113: if (newp == NULL)
! 1114: return FAIL;
! 1115: vim_memmove(newp, oldp, (size_t)col);
! 1116: }
! 1117: vim_memmove(newp + col, oldp + col + 1, (size_t)(oldlen - col));
! 1118: if (!was_alloced)
! 1119: ml_replace(lnum, newp, FALSE);
! 1120:
! 1121: /*
! 1122: * If we just took off the last character of a non-blank line, we don't
! 1123: * want to end up positioned at the NUL.
! 1124: */
! 1125: if (fixpos && curwin->w_cursor.col > 0 && col == oldlen - 1)
! 1126: --curwin->w_cursor.col;
! 1127:
! 1128: CHANGED;
! 1129: return OK;
! 1130: }
! 1131:
! 1132: /*
! 1133: * Delete from cursor to end of line.
! 1134: *
! 1135: * return FAIL for failure, OK otherwise
! 1136: */
! 1137: int
! 1138: truncate_line(fixpos)
! 1139: int fixpos; /* if TRUE fix the cursor position when done */
! 1140: {
! 1141: char_u *newp;
! 1142: linenr_t lnum = curwin->w_cursor.lnum;
! 1143: colnr_t col = curwin->w_cursor.col;
! 1144:
! 1145: if (col == 0)
! 1146: newp = strsave((char_u *)"");
! 1147: else
! 1148: newp = strnsave(ml_get(lnum), col);
! 1149:
! 1150: if (newp == NULL)
! 1151: return FAIL;
! 1152:
! 1153: ml_replace(lnum, newp, FALSE);
! 1154:
! 1155: /*
! 1156: * If "fixpos" is TRUE we don't want to end up positioned at the NUL.
! 1157: */
! 1158: if (fixpos && curwin->w_cursor.col > 0)
! 1159: --curwin->w_cursor.col;
! 1160:
! 1161: CHANGED;
! 1162: return OK;
! 1163: }
! 1164:
! 1165: void
! 1166: dellines(nlines, dowindow, undo)
! 1167: long nlines; /* number of lines to delete */
! 1168: int dowindow; /* if true, update the window */
! 1169: int undo; /* if true, prepare for undo */
! 1170: {
! 1171: int num_plines = 0;
! 1172:
! 1173: if (nlines <= 0)
! 1174: return;
! 1175: /*
! 1176: * There's no point in keeping the window updated if redrawing is disabled
! 1177: * or we're deleting more than a window's worth of lines.
! 1178: */
! 1179: if (RedrawingDisabled)
! 1180: dowindow = FALSE;
! 1181: else if (nlines > (curwin->w_height - curwin->w_row) && dowindow)
! 1182: {
! 1183: dowindow = FALSE;
! 1184: /* flaky way to clear rest of window */
! 1185: win_del_lines(curwin, curwin->w_row, curwin->w_height, TRUE, TRUE);
! 1186: }
! 1187: /* save the deleted lines for undo */
! 1188: if (undo && u_savedel(curwin->w_cursor.lnum, nlines) == FAIL)
! 1189: return;
! 1190:
! 1191: /* adjust marks for deleted lines and lines that follow */
! 1192: mark_adjust(curwin->w_cursor.lnum, curwin->w_cursor.lnum + nlines - 1,
! 1193: MAXLNUM, -nlines);
! 1194:
! 1195: while (nlines-- > 0)
! 1196: {
! 1197: if (curbuf->b_ml.ml_flags & ML_EMPTY) /* nothing to delete */
! 1198: break;
! 1199:
! 1200: /*
! 1201: * Set up to delete the correct number of physical lines on the
! 1202: * window
! 1203: */
! 1204: if (dowindow)
! 1205: num_plines += plines(curwin->w_cursor.lnum);
! 1206:
! 1207: ml_delete(curwin->w_cursor.lnum, TRUE);
! 1208:
! 1209: CHANGED;
! 1210:
! 1211: /* If we delete the last line in the file, stop */
! 1212: if (curwin->w_cursor.lnum > curbuf->b_ml.ml_line_count)
! 1213: {
! 1214: curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count;
! 1215: break;
! 1216: }
! 1217: }
! 1218: curwin->w_cursor.col = 0;
! 1219: /*
! 1220: * Delete the correct number of physical lines on the window
! 1221: */
! 1222: if (dowindow && num_plines > 0)
! 1223: win_del_lines(curwin, curwin->w_row, num_plines, TRUE, TRUE);
! 1224: }
! 1225:
! 1226: int
! 1227: gchar(pos)
! 1228: FPOS *pos;
! 1229: {
! 1230: return (int)(*(ml_get_pos(pos)));
! 1231: }
! 1232:
! 1233: int
! 1234: gchar_cursor()
! 1235: {
! 1236: return (int)(*(ml_get_cursor()));
! 1237: }
! 1238:
! 1239: /*
! 1240: * Write a character at the current cursor position.
! 1241: * It is directly written into the block.
! 1242: */
! 1243: void
! 1244: pchar_cursor(c)
! 1245: int c;
! 1246: {
! 1247: *(ml_get_buf(curbuf, curwin->w_cursor.lnum, TRUE) +
! 1248: curwin->w_cursor.col) = c;
! 1249: }
! 1250:
! 1251: /*
! 1252: * Put *pos at end of current buffer
! 1253: */
! 1254: void
! 1255: goto_endofbuf(pos)
! 1256: FPOS *pos;
! 1257: {
! 1258: char_u *p;
! 1259:
! 1260: pos->lnum = curbuf->b_ml.ml_line_count;
! 1261: pos->col = 0;
! 1262: p = ml_get(pos->lnum);
! 1263: while (*p++)
! 1264: ++pos->col;
! 1265: }
! 1266:
! 1267: /*
! 1268: * When extra == 0: Return TRUE if the cursor is before or on the first
! 1269: * non-blank in the line.
! 1270: * When extra == 1: Return TRUE if the cursor is before the first non-blank in
! 1271: * the line.
! 1272: */
! 1273: int
! 1274: inindent(extra)
! 1275: int extra;
! 1276: {
! 1277: register char_u *ptr;
! 1278: register colnr_t col;
! 1279:
! 1280: for (col = 0, ptr = ml_get_curline(); vim_iswhite(*ptr); ++col)
! 1281: ++ptr;
! 1282: if (col >= curwin->w_cursor.col + extra)
! 1283: return TRUE;
! 1284: else
! 1285: return FALSE;
! 1286: }
! 1287:
! 1288: /*
! 1289: * skipwhite: skip over ' ' and '\t'.
! 1290: */
! 1291: char_u *
! 1292: skipwhite(p)
! 1293: register char_u *p;
! 1294: {
! 1295: while (vim_iswhite(*p)) /* skip to next non-white */
! 1296: ++p;
! 1297: return p;
! 1298: }
! 1299:
! 1300: /*
! 1301: * skipdigits: skip over digits;
! 1302: */
! 1303: char_u *
! 1304: skipdigits(p)
! 1305: register char_u *p;
! 1306: {
! 1307: while (isdigit(*p)) /* skip to next non-digit */
! 1308: ++p;
! 1309: return p;
! 1310: }
! 1311:
! 1312: /*
! 1313: * skiptowhite: skip over text until ' ' or '\t' or NUL.
! 1314: */
! 1315: char_u *
! 1316: skiptowhite(p)
! 1317: register char_u *p;
! 1318: {
! 1319: while (*p != ' ' && *p != '\t' && *p != NUL)
! 1320: ++p;
! 1321: return p;
! 1322: }
! 1323:
! 1324: /*
! 1325: * skiptowhite_esc: Like skiptowhite(), but also skip escaped chars
! 1326: */
! 1327: char_u *
! 1328: skiptowhite_esc(p)
! 1329: register char_u *p;
! 1330: {
! 1331: while (*p != ' ' && *p != '\t' && *p != NUL)
! 1332: {
! 1333: if ((*p == '\\' || *p == Ctrl('V')) && *(p + 1) != NUL)
! 1334: ++p;
! 1335: ++p;
! 1336: }
! 1337: return p;
! 1338: }
! 1339:
! 1340: /*
! 1341: * getdigits: get a number from a string and skip over it
! 1342: *
! 1343: * note: you must give a pointer to a char_u pointer!
! 1344: */
! 1345:
! 1346: long
! 1347: getdigits(pp)
! 1348: char_u **pp;
! 1349: {
! 1350: register char_u *p;
! 1351: long retval;
! 1352:
! 1353: p = *pp;
! 1354: retval = atol((char *)p);
! 1355: p = skipdigits(p); /* skip to next non-digit */
! 1356: *pp = p;
! 1357: return retval;
! 1358: }
! 1359:
! 1360: /*
! 1361: * Skip to next part of an option argument: Skip space and comma.
! 1362: */
! 1363: char_u *
! 1364: skip_to_option_part(p)
! 1365: char_u *p;
! 1366: {
! 1367: if (*p == ',')
! 1368: ++p;
! 1369: while (*p == ' ')
! 1370: ++p;
! 1371: return p;
! 1372: }
! 1373:
! 1374: char *
! 1375: plural(n)
! 1376: long n;
! 1377: {
! 1378: static char buf[2] = "s";
! 1379:
! 1380: if (n == 1)
! 1381: return &(buf[1]);
! 1382: return &(buf[0]);
! 1383: }
! 1384:
! 1385: /*
! 1386: * set_Changed is called when something in the current buffer is changed
! 1387: */
! 1388: void
! 1389: set_Changed()
! 1390: {
! 1391: if (!curbuf->b_changed)
! 1392: {
! 1393: change_warning();
! 1394: curbuf->b_changed = TRUE;
! 1395: check_status(curbuf);
! 1396: }
! 1397: modified = TRUE; /* used for redrawing */
! 1398: }
! 1399:
! 1400: /*
! 1401: * unset_Changed is called when the changed flag must be reset for buffer 'buf'
! 1402: */
! 1403: void
! 1404: unset_Changed(buf)
! 1405: BUF *buf;
! 1406: {
! 1407: if (buf->b_changed)
! 1408: {
! 1409: buf->b_changed = 0;
! 1410: check_status(buf);
! 1411: }
! 1412: }
! 1413:
! 1414: /*
! 1415: * check_status: called when the status bars for the buffer 'buf'
! 1416: * need to be updated
! 1417: */
! 1418: static void
! 1419: check_status(buf)
! 1420: BUF *buf;
! 1421: {
! 1422: WIN *wp;
! 1423: int i;
! 1424:
! 1425: i = 0;
! 1426: for (wp = firstwin; wp != NULL; wp = wp->w_next)
! 1427: if (wp->w_buffer == buf && wp->w_status_height)
! 1428: {
! 1429: wp->w_redr_status = TRUE;
! 1430: ++i;
! 1431: }
! 1432: if (i)
! 1433: redraw_later(NOT_VALID);
! 1434: }
! 1435:
! 1436: /*
! 1437: * If the file is readonly, give a warning message with the first change.
! 1438: * Don't do this for autocommands.
! 1439: * Don't use emsg(), because it flushes the macro buffer.
! 1440: * If we have undone all changes b_changed will be FALSE, but b_did_warn
! 1441: * will be TRUE.
! 1442: */
! 1443: void
! 1444: change_warning()
! 1445: {
! 1446: if (curbuf->b_did_warn == FALSE && curbuf->b_changed == 0 &&
! 1447: #ifdef AUTOCMD
! 1448: !autocmd_busy &&
! 1449: #endif
! 1450: curbuf->b_p_ro)
! 1451: {
! 1452: curbuf->b_did_warn = TRUE;
! 1453: MSG("Warning: Changing a readonly file");
! 1454: mch_delay(1000L, TRUE); /* give him some time to think about it */
! 1455: }
! 1456: }
! 1457:
! 1458: /*
! 1459: * Ask for a reply from the user, a 'y' or a 'n'.
! 1460: * No other characters are accepted, the message is repeated until a valid
! 1461: * reply is entered or CTRL-C is hit.
! 1462: * If direct is TRUE, don't use vgetc but mch_inchar, don't get characters from
! 1463: * any buffers but directly from the user.
! 1464: *
! 1465: * return the 'y' or 'n'
! 1466: */
! 1467: int
! 1468: ask_yesno(str, direct)
! 1469: char_u *str;
! 1470: int direct;
! 1471: {
! 1472: int r = ' ';
! 1473: char_u buf[20];
! 1474: int len = 0;
! 1475: int idx = 0;
! 1476:
! 1477: if (exiting) /* put terminal in raw mode for this question */
! 1478: settmode(1);
! 1479: while (r != 'y' && r != 'n')
! 1480: {
! 1481: (void)set_highlight('r'); /* same highlighting as for wait_return */
! 1482: msg_highlight = TRUE;
! 1483: smsg((char_u *)"%s (y/n)?", str);
! 1484: if (direct)
! 1485: {
! 1486: flushbuf();
! 1487: if (idx >= len)
! 1488: {
! 1489: len = mch_inchar(buf, 20, -1L);
! 1490: idx = 0;
! 1491: }
! 1492: r = buf[idx++];
! 1493: }
! 1494: else
! 1495: r = vgetc();
! 1496: if (r == Ctrl('C') || r == ESC)
! 1497: r = 'n';
! 1498: msg_outchar(r); /* show what you typed */
! 1499: flushbuf();
! 1500: }
! 1501: return r;
! 1502: }
! 1503:
! 1504: /*
! 1505: * get a number from the user
! 1506: */
! 1507: int
! 1508: get_number()
! 1509: {
! 1510: int n = 0;
! 1511: int c;
! 1512:
! 1513: for (;;)
! 1514: {
! 1515: windgoto(msg_row, msg_col);
! 1516: c = vgetc();
! 1517: if (isdigit(c))
! 1518: {
! 1519: n = n * 10 + c - '0';
! 1520: msg_outchar(c);
! 1521: }
! 1522: else if (c == K_DEL || c == K_BS || c == Ctrl('H'))
! 1523: {
! 1524: n /= 10;
! 1525: MSG_OUTSTR("\b \b");
! 1526: }
! 1527: else if (c == CR || c == NL || c == Ctrl('C'))
! 1528: break;
! 1529: }
! 1530: return n;
! 1531: }
! 1532:
! 1533: void
! 1534: msgmore(n)
! 1535: long n;
! 1536: {
! 1537: long pn;
! 1538:
! 1539: if (global_busy || /* no messages now, wait until global is finished */
! 1540: keep_msg) /* there is a message already, skip this one */
! 1541: return;
! 1542:
! 1543: if (n > 0)
! 1544: pn = n;
! 1545: else
! 1546: pn = -n;
! 1547:
! 1548: if (pn > p_report)
! 1549: {
! 1550: sprintf((char *)msg_buf, "%ld %s line%s %s",
! 1551: pn, n > 0 ? "more" : "fewer", plural(pn),
! 1552: got_int ? "(Interrupted)" : "");
! 1553: if (msg(msg_buf))
! 1554: keep_msg = msg_buf;
! 1555: }
! 1556: }
! 1557:
! 1558: /*
! 1559: * flush map and typeahead buffers and give a warning for an error
! 1560: */
! 1561: void
! 1562: beep_flush()
! 1563: {
! 1564: flush_buffers(FALSE);
! 1565: vim_beep();
! 1566: }
! 1567:
! 1568: /*
! 1569: * give a warning for an error
! 1570: */
! 1571: void
! 1572: vim_beep()
! 1573: {
! 1574: if (p_vb)
! 1575: {
! 1576: #ifdef DJGPP
! 1577: ScreenVisualBell();
! 1578: #else
! 1579: outstr(T_VB);
! 1580: #endif
! 1581: }
! 1582: else
! 1583: {
! 1584: #if defined MSDOS || defined WIN32 /* ? gvr */
! 1585: /*
! 1586: * The number of beeps outputted is reduced to avoid having to wait
! 1587: * for all the beeps to finish. This is only a problem on systems
! 1588: * where the beeps don't overlap.
! 1589: */
! 1590: if (beep_count == 0 || beep_count == 10)
! 1591: {
! 1592: outchar('\007');
! 1593: beep_count = 1;
! 1594: }
! 1595: else
! 1596: ++beep_count;
! 1597: #else
! 1598: outchar('\007');
! 1599: #endif
! 1600: }
! 1601: }
! 1602:
! 1603: /*
! 1604: * To get the "real" home directory:
! 1605: * - get value of $HOME
! 1606: * For Unix:
! 1607: * - go to that directory
! 1608: * - do mch_dirname() to get the real name of that directory.
! 1609: * This also works with mounts and links.
! 1610: * Don't do this for MS-DOS, it will change the "current dir" for a drive.
! 1611: */
! 1612: static char_u *homedir = NULL;
! 1613:
! 1614: void
! 1615: init_homedir()
! 1616: {
! 1617: char_u *var;
! 1618:
! 1619: var = vim_getenv((char_u *)"HOME");
! 1620: #if defined(OS2) || defined(MSDOS) || defined(WIN32)
! 1621: /*
! 1622: * Default home dir is C:/
! 1623: * Best assumption we can make in such a situation.
! 1624: */
! 1625: if (var == NULL)
! 1626: var = "C:/";
! 1627: #endif
! 1628: if (var != NULL)
! 1629: {
! 1630: #ifdef UNIX
! 1631: if (mch_dirname(NameBuff, MAXPATHL) == OK)
! 1632: {
! 1633: if (!vim_chdir((char *)var) && mch_dirname(IObuff, IOSIZE) == OK)
! 1634: var = IObuff;
! 1635: vim_chdir((char *)NameBuff);
! 1636: }
! 1637: #endif
! 1638: homedir = strsave(var);
! 1639: }
! 1640: }
! 1641:
! 1642: /*
! 1643: * Expand environment variable with path name.
! 1644: * For Unix and OS/2 "~/" is also expanded, like $HOME.
! 1645: * If anything fails no expansion is done and dst equals src.
! 1646: * Note that IObuff must NOT be used as either src or dst! This is because
! 1647: * vim_getenv() may use IObuff to do its expansion.
! 1648: */
! 1649: void
! 1650: expand_env(src, dst, dstlen)
! 1651: char_u *src; /* input string e.g. "$HOME/vim.hlp" */
! 1652: char_u *dst; /* where to put the result */
! 1653: int dstlen; /* maximum length of the result */
! 1654: {
! 1655: char_u *tail;
! 1656: int c;
! 1657: char_u *var;
! 1658: int copy_char;
! 1659: #if defined(UNIX) || defined(OS2)
! 1660: int mustfree;
! 1661: int at_start = TRUE;
! 1662: #endif
! 1663:
! 1664: src = skipwhite(src);
! 1665: --dstlen; /* leave one char space for "\," */
! 1666: while (*src && dstlen > 0)
! 1667: {
! 1668: copy_char = TRUE;
! 1669: if (*src == '$'
! 1670: #if defined(UNIX) || defined(OS2)
! 1671: || (*src == '~' && at_start)
! 1672: #endif
! 1673: )
! 1674: {
! 1675: #if defined(UNIX) || defined(OS2)
! 1676: mustfree = FALSE;
! 1677:
! 1678: /*
! 1679: * The variable name is copied into dst temporarily, because it may
! 1680: * be a string in read-only memory and a NUL needs to be inserted.
! 1681: */
! 1682: if (*src == '$') /* environment var */
! 1683: {
! 1684: #endif
! 1685: tail = src + 1;
! 1686: var = dst;
! 1687: c = dstlen - 1;
! 1688: while (c-- > 0 && *tail && isidchar(*tail))
! 1689: #ifdef OS2
! 1690: { /* env vars only in uppercase */
! 1691: *var++ = toupper(*tail); /* toupper() may be a macro! */
! 1692: tail++;
! 1693: }
! 1694: #else
! 1695: *var++ = *tail++;
! 1696: #endif
! 1697: *var = NUL;
! 1698: #if defined(OS2) || defined(MSDOS) || defined(WIN32)
! 1699: /* use "C:/" when $HOME is not set */
! 1700: if (STRCMP(dst, "HOME") == 0)
! 1701: var = homedir;
! 1702: else
! 1703: #endif
! 1704: var = vim_getenv(dst);
! 1705: #if defined(UNIX) || defined(OS2)
! 1706: }
! 1707: /* home directory */
! 1708: else if (src[1] == NUL ||
! 1709: vim_strchr((char_u *)"/ ,\t\n", src[1]) != NULL)
! 1710: {
! 1711: var = homedir;
! 1712: tail = src + 1;
! 1713: }
! 1714: else /* user directory */
! 1715: # ifdef OS2
! 1716: {
! 1717: /* cannot expand user's home directory, so don't try */
! 1718: var = NULL;
! 1719: tail = ""; /* shut gcc up about "may be used uninitialized" */
! 1720: }
! 1721: # else
! 1722: {
! 1723: /*
! 1724: * Copy ~user to dst[], so we can put a NUL after it.
! 1725: */
! 1726: tail = src;
! 1727: var = dst;
! 1728: c = dstlen - 1;
! 1729: while (c-- > 0 && *tail &&
! 1730: isfilechar(*tail) && !ispathsep(*tail))
! 1731: *var++ = *tail++;
! 1732: *var = NUL;
! 1733:
! 1734: /*
! 1735: * If the system supports getpwnam(), use it.
! 1736: * Otherwise, or if getpwnam() fails, the shell is used to
! 1737: * expand ~user. This is slower and may fail if the shell
! 1738: * does not support ~user (old versions of /bin/sh).
! 1739: */
! 1740: # if defined(HAVE_GETPWNAM) && defined(HAVE_PWD_H)
! 1741: {
! 1742: struct passwd *pw;
! 1743:
! 1744: pw = getpwnam((char *)dst + 1);
! 1745: if (pw != NULL)
! 1746: var = (char_u *)pw->pw_dir;
! 1747: else
! 1748: var = NULL;
! 1749: }
! 1750: if (var == NULL)
! 1751: # endif
! 1752: {
! 1753: var = ExpandOne(dst, NULL, 0, WILD_EXPAND_FREE);
! 1754: mustfree = TRUE;
! 1755: }
! 1756: }
! 1757: # endif /* OS2 */
! 1758: #endif /* UNIX || OS2 */
! 1759: if (var != NULL && *var != NUL &&
! 1760: (STRLEN(var) + STRLEN(tail) + 1 < (unsigned)dstlen))
! 1761: {
! 1762: STRCPY(dst, var);
! 1763: dstlen -= STRLEN(var);
! 1764: dst += STRLEN(var);
! 1765: /* if var[] ends in a path separator and tail[] starts
! 1766: * with it, skip a character */
! 1767: if (*var && ispathsep(*(dst-1)) && ispathsep(*tail))
! 1768: ++tail;
! 1769: src = tail;
! 1770: copy_char = FALSE;
! 1771: }
! 1772: #if defined(UNIX) || defined(OS2)
! 1773: if (mustfree)
! 1774: vim_free(var);
! 1775: #endif
! 1776: }
! 1777:
! 1778: if (copy_char) /* copy at least one char */
! 1779: {
! 1780: #if defined(UNIX) || defined(OS2)
! 1781: /*
! 1782: * Recogize the start of a new name, for '~'.
! 1783: */
! 1784: at_start = FALSE;
! 1785: #endif
! 1786: if (src[0] == '\\')
! 1787: {
! 1788: *dst++ = *src++;
! 1789: --dstlen;
! 1790: }
! 1791: #if defined(UNIX) || defined(OS2)
! 1792: else if (src[0] == ' ' || src[0] == ',')
! 1793: at_start = TRUE;
! 1794: #endif
! 1795: *dst++ = *src++;
! 1796: --dstlen;
! 1797: }
! 1798: }
! 1799: *dst = NUL;
! 1800: }
! 1801:
! 1802: /*
! 1803: * Replace home directory by "~/" in each space or comma separated filename in
! 1804: * 'src'. If anything fails (except when out of space) dst equals src.
! 1805: */
! 1806: void
! 1807: home_replace(buf, src, dst, dstlen)
! 1808: BUF *buf; /* when not NULL, check for help files */
! 1809: char_u *src; /* input file name */
! 1810: char_u *dst; /* where to put the result */
! 1811: int dstlen; /* maximum length of the result */
! 1812: {
! 1813: size_t dirlen = 0, envlen = 0;
! 1814: size_t len;
! 1815: char_u *homedir_env;
! 1816: char_u *p;
! 1817:
! 1818: if (src == NULL)
! 1819: {
! 1820: *dst = NUL;
! 1821: return;
! 1822: }
! 1823:
! 1824: /*
! 1825: * If the file is a help file, remove the path completely.
! 1826: */
! 1827: if (buf != NULL && buf->b_help)
! 1828: {
! 1829: STRCPY(dst, gettail(src));
! 1830: return;
! 1831: }
! 1832:
! 1833: /*
! 1834: * We check both the value of the $HOME environment variable and the
! 1835: * "real" home directory.
! 1836: */
! 1837: if (homedir != NULL)
! 1838: dirlen = STRLEN(homedir);
! 1839: homedir_env = vim_getenv((char_u *)"HOME");
! 1840: if (homedir_env != NULL)
! 1841: envlen = STRLEN(homedir_env);
! 1842:
! 1843: src = skipwhite(src);
! 1844: while (*src && dstlen > 0)
! 1845: {
! 1846: /*
! 1847: * Here we are at the beginning of a filename.
! 1848: * First, check to see if the beginning of the filename matches
! 1849: * $HOME or the "real" home directory. Check that there is a '/'
! 1850: * after the match (so that if e.g. the file is "/home/pieter/bla",
! 1851: * and the home directory is "/home/piet", the file does not end up
! 1852: * as "~er/bla" (which would seem to indicate the file "bla" in user
! 1853: * er's home directory)).
! 1854: */
! 1855: p = homedir;
! 1856: len = dirlen;
! 1857: for (;;)
! 1858: {
! 1859: if (len && fnamencmp(src, p, len) == 0 && (ispathsep(src[len]) ||
! 1860: src[len] == ',' || src[len] == ' ' || src[len] == NUL))
! 1861: {
! 1862: src += len;
! 1863: if (--dstlen > 0)
! 1864: *dst++ = '~';
! 1865: /*
! 1866: * If it's just the home directory, make it "~/".
! 1867: */
! 1868: if (!ispathsep(src[0]) && --dstlen > 0)
! 1869: *dst++ = '/';
! 1870: }
! 1871: if (p == homedir_env)
! 1872: break;
! 1873: p = homedir_env;
! 1874: len = envlen;
! 1875: }
! 1876:
! 1877: /* skip to separator: space or comma */
! 1878: while (*src && *src != ',' && *src != ' ' && --dstlen > 0)
! 1879: *dst++ = *src++;
! 1880: /* skip separator */
! 1881: while ((*src == ' ' || *src == ',') && --dstlen > 0)
! 1882: *dst++ = *src++;
! 1883: }
! 1884: /* if (dstlen == 0) out of space, what to do??? */
! 1885:
! 1886: *dst = NUL;
! 1887: }
! 1888:
! 1889: /*
! 1890: * Like home_replace, store the replaced string in allocated memory.
! 1891: * When something fails, NULL is returned.
! 1892: */
! 1893: char_u *
! 1894: home_replace_save(buf, src)
! 1895: BUF *buf; /* when not NULL, check for help files */
! 1896: char_u *src; /* input file name */
! 1897: {
! 1898: char_u *dst;
! 1899: unsigned len;
! 1900:
! 1901: if (src == NULL) /* just in case */
! 1902: len = 3;
! 1903: else
! 1904: len = STRLEN(src) + 3; /* extra space for "~/" and trailing NUL */
! 1905: dst = alloc(len);
! 1906: if (dst != NULL)
! 1907: home_replace(buf, src, dst, len);
! 1908: return dst;
! 1909: }
! 1910:
! 1911: /*
! 1912: * Compare two file names and return:
! 1913: * FPC_SAME if they both exist and are the same file.
! 1914: * FPC_DIFF if they both exist and are different files.
! 1915: * FPC_NOTX if they both don't exist.
! 1916: * FPC_DIFFX if one of them doesn't exist.
! 1917: * For the first name environment variables are expanded
! 1918: */
! 1919: int
! 1920: fullpathcmp(s1, s2)
! 1921: char_u *s1, *s2;
! 1922: {
! 1923: #ifdef UNIX
! 1924: char_u buf1[MAXPATHL];
! 1925: struct stat st1, st2;
! 1926: int r1, r2;
! 1927:
! 1928: expand_env(s1, buf1, MAXPATHL);
! 1929: r1 = stat((char *)buf1, &st1);
! 1930: r2 = stat((char *)s2, &st2);
! 1931: if (r1 != 0 && r2 != 0)
! 1932: return FPC_NOTX;
! 1933: if (r1 != 0 || r2 != 0)
! 1934: return FPC_DIFFX;
! 1935: if (st1.st_dev == st2.st_dev && st1.st_ino == st2.st_ino)
! 1936: return FPC_SAME;
! 1937: return FPC_DIFF;
! 1938: #else
! 1939: char_u *buf1 = NULL;
! 1940: char_u *buf2 = NULL;
! 1941: int retval = FPC_DIFF;
! 1942: int r1, r2;
! 1943:
! 1944: if ((buf1 = alloc(MAXPATHL)) != NULL && (buf2 = alloc(MAXPATHL)) != NULL)
! 1945: {
! 1946: expand_env(s1, buf2, MAXPATHL);
! 1947: /*
! 1948: * If FullName() failed, the file probably doesn't exist.
! 1949: */
! 1950: r1 = FullName(buf2, buf1, MAXPATHL, FALSE);
! 1951: r2 = FullName(s2, buf2, MAXPATHL, FALSE);
! 1952: if (r1 != OK && r2 != OK)
! 1953: retval = FPC_NOTX;
! 1954: else if (r1 != OK || r2 != OK)
! 1955: retval = FPC_DIFFX;
! 1956: else if (fnamecmp(buf1, buf2))
! 1957: retval = FPC_DIFF;
! 1958: else
! 1959: retval = FPC_SAME;
! 1960: }
! 1961: vim_free(buf1);
! 1962: vim_free(buf2);
! 1963: return retval;
! 1964: #endif
! 1965: }
! 1966:
! 1967: /*
! 1968: * get the tail of a path: the file name.
! 1969: */
! 1970: char_u *
! 1971: gettail(fname)
! 1972: char_u *fname;
! 1973: {
! 1974: register char_u *p1, *p2;
! 1975:
! 1976: if (fname == NULL)
! 1977: return (char_u *)"";
! 1978: for (p1 = p2 = fname; *p2; ++p2) /* find last part of path */
! 1979: {
! 1980: if (ispathsep(*p2))
! 1981: p1 = p2 + 1;
! 1982: }
! 1983: return p1;
! 1984: }
! 1985:
! 1986: /*
! 1987: * return TRUE if 'c' is a path separator.
! 1988: */
! 1989: int
! 1990: ispathsep(c)
! 1991: int c;
! 1992: {
! 1993: #ifdef UNIX
! 1994: return (c == PATHSEP); /* UNIX has ':' inside file names */
! 1995: #else
! 1996: # ifdef BACKSLASH_IN_FILENAME
! 1997: return (c == ':' || c == PATHSEP || c == '\\');
! 1998: # else
! 1999: return (c == ':' || c == PATHSEP);
! 2000: # endif
! 2001: #endif
! 2002: }
! 2003:
! 2004: /*
! 2005: * Concatenate filenames fname1 and fname2 into allocated memory.
! 2006: * Only add a '/' when 'sep' is TRUE and it is neccesary.
! 2007: */
! 2008: char_u *
! 2009: concat_fnames(fname1, fname2, sep)
! 2010: char_u *fname1;
! 2011: char_u *fname2;
! 2012: int sep;
! 2013: {
! 2014: char_u *dest;
! 2015:
! 2016: dest = alloc((unsigned)(STRLEN(fname1) + STRLEN(fname2) + 2));
! 2017: if (dest != NULL)
! 2018: {
! 2019: STRCPY(dest, fname1);
! 2020: if (sep && *dest && !ispathsep(*(dest + STRLEN(dest) - 1)))
! 2021: STRCAT(dest, PATHSEPSTR);
! 2022: STRCAT(dest, fname2);
! 2023: }
! 2024: return dest;
! 2025: }
! 2026:
! 2027: /*
! 2028: * FullName_save - Make an allocated copy of a full file name.
! 2029: * Returns NULL when failed.
! 2030: */
! 2031: char_u *
! 2032: FullName_save(fname)
! 2033: char_u *fname;
! 2034: {
! 2035: char_u *buf;
! 2036: char_u *new_fname = NULL;
! 2037:
! 2038: buf = alloc((unsigned)MAXPATHL);
! 2039: if (buf != NULL)
! 2040: {
! 2041: if (FullName(fname, buf, MAXPATHL, FALSE) != FAIL)
! 2042: new_fname = strsave(buf);
! 2043: vim_free(buf);
! 2044: }
! 2045: return new_fname;
! 2046: }
! 2047:
! 2048: #ifdef CINDENT
! 2049:
! 2050: /*
! 2051: * Functions for C-indenting.
! 2052: * Most of this originally comes from Eric Fischer.
! 2053: */
! 2054: /*
! 2055: * Below "XXX" means that this function may unlock the current line.
! 2056: */
! 2057:
! 2058: static int isdefault __ARGS((char_u *));
! 2059: static char_u *after_label __ARGS((char_u *l));
! 2060: static int get_indent_nolabel __ARGS((linenr_t lnum));
! 2061: static int skip_label __ARGS((linenr_t, char_u **pp, int ind_maxcomment));
! 2062: static int ispreproc __ARGS((char_u *));
! 2063: static int iscomment __ARGS((char_u *));
! 2064: static int commentorempty __ARGS((char_u *));
! 2065: static int isterminated __ARGS((char_u *));
! 2066: static int isfuncdecl __ARGS((char_u *));
! 2067: static char_u *skip_string __ARGS((char_u *p));
! 2068: static int isif __ARGS((char_u *));
! 2069: static int iselse __ARGS((char_u *));
! 2070: static int isdo __ARGS((char_u *));
! 2071: static int iswhileofdo __ARGS((char_u *, linenr_t, int));
! 2072: static FPOS *find_start_comment __ARGS((int ind_maxcomment));
! 2073: static FPOS *find_start_brace __ARGS((int));
! 2074: static FPOS *find_match_paren __ARGS((int, int));
! 2075: static int find_last_paren __ARGS((char_u *l));
! 2076: static int find_match __ARGS((int lookfor, linenr_t ourscope,
! 2077: int ind_maxparen, int ind_maxcomment));
! 2078:
! 2079: /*
! 2080: * Recognize a label: "label:".
! 2081: * Note: curwin->w_cursor must be where we are looking for the label.
! 2082: */
! 2083: int
! 2084: islabel(ind_maxcomment) /* XXX */
! 2085: int ind_maxcomment;
! 2086: {
! 2087: char_u *s;
! 2088:
! 2089: s = skipwhite(ml_get_curline());
! 2090:
! 2091: /*
! 2092: * Exclude "default" from labels, since it should be indented
! 2093: * like a switch label.
! 2094: */
! 2095:
! 2096: if (isdefault(s))
! 2097: return FALSE;
! 2098:
! 2099: if (!isidchar(*s)) /* need at least one ID character */
! 2100: return FALSE;
! 2101:
! 2102: while (isidchar(*s))
! 2103: s++;
! 2104:
! 2105: s = skipwhite(s);
! 2106:
! 2107: /* "::" is not a label, it's C++ */
! 2108: if (*s == ':' && s[1] != ':')
! 2109: {
! 2110: /*
! 2111: * Only accept a label if the previous line is terminated or is a case
! 2112: * label.
! 2113: */
! 2114: FPOS cursor_save;
! 2115: FPOS *trypos;
! 2116: char_u *line;
! 2117:
! 2118: cursor_save = curwin->w_cursor;
! 2119: while (curwin->w_cursor.lnum > 1)
! 2120: {
! 2121: --curwin->w_cursor.lnum;
! 2122:
! 2123: /*
! 2124: * If we're in a comment now, skip to the start of the comment.
! 2125: */
! 2126: curwin->w_cursor.col = 0;
! 2127: if ((trypos = find_start_comment(ind_maxcomment)) != NULL) /* XXX */
! 2128: curwin->w_cursor = *trypos;
! 2129:
! 2130: line = ml_get_curline();
! 2131: if (ispreproc(line)) /* ignore #defines, #if, etc. */
! 2132: continue;
! 2133: if (commentorempty(line))
! 2134: continue;
! 2135:
! 2136: curwin->w_cursor = cursor_save;
! 2137: if (isterminated(line) || iscase(line))
! 2138: return TRUE;
! 2139: return FALSE;
! 2140: }
! 2141: curwin->w_cursor = cursor_save;
! 2142: return TRUE; /* label at start of file??? */
! 2143: }
! 2144: return FALSE;
! 2145: }
! 2146:
! 2147: /*
! 2148: * Recognize a switch label: "case .*:" or "default:".
! 2149: */
! 2150: int
! 2151: iscase(s)
! 2152: char_u *s;
! 2153: {
! 2154: s = skipwhite(s);
! 2155: if (STRNCMP(s, "case", 4) == 0 && !isidchar(s[4]))
! 2156: {
! 2157: for (s += 4; *s; ++s)
! 2158: if (*s == ':')
! 2159: {
! 2160: if (s[1] == ':') /* skip over "::" for C++ */
! 2161: ++s;
! 2162: else
! 2163: return TRUE;
! 2164: }
! 2165: return FALSE;
! 2166: }
! 2167:
! 2168: if (isdefault(s))
! 2169: return TRUE;
! 2170: return FALSE;
! 2171: }
! 2172:
! 2173: /*
! 2174: * Recognize a "default" switch label.
! 2175: */
! 2176: static int
! 2177: isdefault(s)
! 2178: char_u *s;
! 2179: {
! 2180: return (STRNCMP(s, "default", 7) == 0 &&
! 2181: *(s = skipwhite(s + 7)) == ':' &&
! 2182: s[1] != ':');
! 2183: }
! 2184:
! 2185: /*
! 2186: * Return a pointer to the first non-empty non-comment character after a ':'.
! 2187: * Return NULL if not found.
! 2188: * case 234: a = b;
! 2189: * ^
! 2190: */
! 2191: static char_u *
! 2192: after_label(l)
! 2193: char_u *l;
! 2194: {
! 2195: for ( ; *l; ++l)
! 2196: if (*l == ':')
! 2197: {
! 2198: if (l[1] == ':') /* skip over "::" for C++ */
! 2199: ++l;
! 2200: else
! 2201: break;
! 2202: }
! 2203: if (*l == NUL)
! 2204: return NULL;
! 2205: l = skipwhite(l + 1);
! 2206: if (commentorempty(l))
! 2207: return NULL;
! 2208: return l;
! 2209: }
! 2210:
! 2211: /*
! 2212: * Get indent of line "lnum", skipping a label.
! 2213: * Return 0 if there is nothing after the label.
! 2214: */
! 2215: static int
! 2216: get_indent_nolabel(lnum) /* XXX */
! 2217: linenr_t lnum;
! 2218: {
! 2219: char_u *l;
! 2220: FPOS fp;
! 2221: colnr_t col;
! 2222: char_u *p;
! 2223:
! 2224: l = ml_get(lnum);
! 2225: p = after_label(l);
! 2226: if (p == NULL)
! 2227: return 0;
! 2228:
! 2229: fp.col = p - l;
! 2230: fp.lnum = lnum;
! 2231: getvcol(curwin, &fp, &col, NULL, NULL);
! 2232: return (int)col;
! 2233: }
! 2234:
! 2235: /*
! 2236: * Find indent for line "lnum", ignoring any case or jump label.
! 2237: * Also return a pointer to the text (after the label).
! 2238: * label: if (asdf && asdfasdf)
! 2239: * ^
! 2240: */
! 2241: static int
! 2242: skip_label(lnum, pp, ind_maxcomment)
! 2243: linenr_t lnum;
! 2244: char_u **pp;
! 2245: int ind_maxcomment;
! 2246: {
! 2247: char_u *l;
! 2248: int amount;
! 2249: FPOS cursor_save;
! 2250:
! 2251: cursor_save = curwin->w_cursor;
! 2252: curwin->w_cursor.lnum = lnum;
! 2253: l = ml_get_curline();
! 2254: if (iscase(l) || islabel(ind_maxcomment)) /* XXX */
! 2255: {
! 2256: amount = get_indent_nolabel(lnum);
! 2257: l = after_label(ml_get_curline());
! 2258: if (l == NULL) /* just in case */
! 2259: l = ml_get_curline();
! 2260: }
! 2261: else
! 2262: {
! 2263: amount = get_indent();
! 2264: l = ml_get_curline();
! 2265: }
! 2266: *pp = l;
! 2267:
! 2268: curwin->w_cursor = cursor_save;
! 2269: return amount;
! 2270: }
! 2271:
! 2272: /*
! 2273: * Recognize a preprocessor statement: Any line that starts with '#'.
! 2274: */
! 2275: static int
! 2276: ispreproc(s)
! 2277: char_u *s;
! 2278: {
! 2279: s = skipwhite(s);
! 2280: if (*s == '#')
! 2281: return TRUE;
! 2282: return 0;
! 2283: }
! 2284:
! 2285: /*
! 2286: * Recognize the start of a C or C++ comment.
! 2287: */
! 2288: static int
! 2289: iscomment(p)
! 2290: char_u *p;
! 2291: {
! 2292: return (p[0] == '/' && (p[1] == '*' || p[1] == '/'));
! 2293: }
! 2294:
! 2295: /*
! 2296: * Recognize an empty or comment line.
! 2297: */
! 2298: static int
! 2299: commentorempty(s)
! 2300: char_u *s;
! 2301: {
! 2302: s = skipwhite(s);
! 2303: if (*s == NUL || iscomment(s))
! 2304: return TRUE;
! 2305: return FALSE;
! 2306: }
! 2307:
! 2308: /*
! 2309: * Recognize a line that starts with '{' or '}', or ends with ';' or '}'.
! 2310: * Also consider a line terminated if it ends in ','. This is not 100%
! 2311: * correct, but this mostly means we are in initializations and then it's OK.
! 2312: */
! 2313: static int
! 2314: isterminated(s)
! 2315: char_u *s;
! 2316: {
! 2317: s = skipwhite(s);
! 2318:
! 2319: if (*s == '{' || *s == '}')
! 2320: return TRUE;
! 2321:
! 2322: while (*s)
! 2323: {
! 2324: if (iscomment(s)) /* at start of comment ignore rest of line */
! 2325: return FALSE;
! 2326: s = skip_string(s);
! 2327: if ((*s == ';' || *s == '{' || *s == ',') && commentorempty(s + 1))
! 2328: return TRUE;
! 2329: s++;
! 2330: }
! 2331: return FALSE;
! 2332: }
! 2333:
! 2334: /*
! 2335: * Recognize the basic picture of a function declaration -- it needs to
! 2336: * have an open paren somewhere and a close paren at the end of the line and
! 2337: * no semicolons anywhere.
! 2338: */
! 2339: static int
! 2340: isfuncdecl(s)
! 2341: char_u *s;
! 2342: {
! 2343: while (*s && *s != '(' && *s != ';')
! 2344: if (iscomment(s++))
! 2345: return FALSE; /* comment before () ??? */
! 2346: if (*s != '(')
! 2347: return FALSE; /* ';' before any () or no '(' */
! 2348:
! 2349: while (*s && *s != ';')
! 2350: {
! 2351: if (*s == ')' && commentorempty(s + 1))
! 2352: return TRUE;
! 2353: if (iscomment(s++))
! 2354: return FALSE; /* comment between ( and ) ??? */
! 2355: }
! 2356: return FALSE;
! 2357: }
! 2358:
! 2359: /*
! 2360: * Skip over a "string" and a 'c' character.
! 2361: */
! 2362: static char_u *
! 2363: skip_string(p)
! 2364: char_u *p;
! 2365: {
! 2366: int i;
! 2367:
! 2368: /*
! 2369: * We loop, because strings may be concatenated: "date""time".
! 2370: */
! 2371: for ( ; ; ++p)
! 2372: {
! 2373: if (p[0] == '\'') /* 'c' or '\n' or '\000' */
! 2374: {
! 2375: if (!p[1]) /* ' at end of line */
! 2376: break;
! 2377: i = 2;
! 2378: if (p[1] == '\\') /* '\n' or '\000' */
! 2379: {
! 2380: ++i;
! 2381: while (isdigit(p[i - 1])) /* '\000' */
! 2382: ++i;
! 2383: }
! 2384: if (p[i] == '\'') /* check for trailing ' */
! 2385: {
! 2386: p += i;
! 2387: continue;
! 2388: }
! 2389: }
! 2390: else if (p[0] == '"') /* start of string */
! 2391: {
! 2392: for (++p; p[0]; ++p)
! 2393: {
! 2394: if (p[0] == '\\' && p[1])
! 2395: ++p;
! 2396: else if (p[0] == '"') /* end of string */
! 2397: break;
! 2398: }
! 2399: continue;
! 2400: }
! 2401: break; /* no string found */
! 2402: }
! 2403: if (!*p)
! 2404: --p; /* backup from NUL */
! 2405: return p;
! 2406: }
! 2407:
! 2408: static int
! 2409: isif(p)
! 2410: char_u *p;
! 2411: {
! 2412: return (STRNCMP(p, "if", 2) == 0 && !isidchar(p[2]));
! 2413: }
! 2414:
! 2415: static int
! 2416: iselse(p)
! 2417: char_u *p;
! 2418: {
! 2419: return (STRNCMP(p, "else", 4) == 0 && !isidchar(p[4]));
! 2420: }
! 2421:
! 2422: static int
! 2423: isdo(p)
! 2424: char_u *p;
! 2425: {
! 2426: return (STRNCMP(p, "do", 2) == 0 && !isidchar(p[2]));
! 2427: }
! 2428:
! 2429: /*
! 2430: * Check if this is a "while" that should have a matching "do".
! 2431: * We only accept a "while (condition) ;", with only white space between the
! 2432: * ')' and ';'. The condition may be spread over several lines.
! 2433: */
! 2434: static int
! 2435: iswhileofdo(p, lnum, ind_maxparen) /* XXX */
! 2436: char_u *p;
! 2437: linenr_t lnum;
! 2438: int ind_maxparen;
! 2439: {
! 2440: FPOS cursor_save;
! 2441: FPOS *trypos;
! 2442: int retval = FALSE;
! 2443:
! 2444: p = skipwhite(p);
! 2445: if (STRNCMP(p, "while", 5) == 0 && !isidchar(p[5]))
! 2446: {
! 2447: cursor_save = curwin->w_cursor;
! 2448: curwin->w_cursor.lnum = lnum;
! 2449: curwin->w_cursor.col = 0;
! 2450: if ((trypos = findmatchlimit(0, 0, ind_maxparen)) != NULL)
! 2451: {
! 2452: p = ml_get_pos(trypos) + 1;
! 2453: p = skipwhite(p);
! 2454: if (*p == ';')
! 2455: retval = TRUE;
! 2456: }
! 2457: curwin->w_cursor = cursor_save;
! 2458: }
! 2459: return retval;
! 2460: }
! 2461:
! 2462: /*
! 2463: * Find the start of a comment, not knowing if we are in a comment right now.
! 2464: * Search starts at w_cursor.lnum and goes backwards.
! 2465: */
! 2466: static FPOS *
! 2467: find_start_comment(ind_maxcomment) /* XXX */
! 2468: int ind_maxcomment;
! 2469: {
! 2470: FPOS *pos;
! 2471: char_u *line;
! 2472: char_u *p;
! 2473:
! 2474: if ((pos = findmatchlimit('*', FM_BACKWARD, ind_maxcomment)) == NULL)
! 2475: return NULL;
! 2476:
! 2477: /*
! 2478: * Check if the comment start we found is inside a string.
! 2479: */
! 2480: line = ml_get(pos->lnum);
! 2481: for (p = line; *p && (unsigned)(p - line) < pos->col; ++p)
! 2482: p = skip_string(p);
! 2483: if ((unsigned)(p - line) > pos->col)
! 2484: return NULL;
! 2485: return pos;
! 2486: }
! 2487:
! 2488: /*
! 2489: * Find the '{' at the start of the block we are in.
! 2490: * Return NULL of no match found.
! 2491: * Ignore a '{' that is in a comment, makes indenting the next three lines
! 2492: * work. */
! 2493: /* foo() */
! 2494: /* { */
! 2495: /* } */
! 2496:
! 2497: static FPOS *
! 2498: find_start_brace(ind_maxcomment) /* XXX */
! 2499: int ind_maxcomment;
! 2500: {
! 2501: FPOS cursor_save;
! 2502: FPOS *trypos;
! 2503: FPOS *pos;
! 2504: static FPOS pos_copy;
! 2505:
! 2506: cursor_save = curwin->w_cursor;
! 2507: while ((trypos = findmatchlimit('{', FM_BLOCKSTOP, 0)) != NULL)
! 2508: {
! 2509: pos_copy = *trypos; /* copy FPOS, next findmatch will change it */
! 2510: trypos = &pos_copy;
! 2511: curwin->w_cursor = *trypos;
! 2512: pos = NULL;
! 2513: if (!iscomment(skipwhite(ml_get(trypos->lnum))) &&
! 2514: (pos = find_start_comment(ind_maxcomment)) == NULL) /* XXX */
! 2515: break;
! 2516: if (pos != NULL)
! 2517: curwin->w_cursor.lnum = pos->lnum;
! 2518: }
! 2519: curwin->w_cursor = cursor_save;
! 2520: return trypos;
! 2521: }
! 2522:
! 2523: /*
! 2524: * Find the matching '(', failing if it is in a comment.
! 2525: * Return NULL of no match found.
! 2526: */
! 2527: static FPOS *
! 2528: find_match_paren(ind_maxparen, ind_maxcomment) /* XXX */
! 2529: int ind_maxparen;
! 2530: int ind_maxcomment;
! 2531: {
! 2532: FPOS cursor_save;
! 2533: FPOS *trypos;
! 2534: static FPOS pos_copy;
! 2535:
! 2536: cursor_save = curwin->w_cursor;
! 2537: if ((trypos = findmatchlimit('(', 0, ind_maxparen)) != NULL)
! 2538: {
! 2539: if (iscomment(skipwhite(ml_get(trypos->lnum))))
! 2540: trypos = NULL;
! 2541: else
! 2542: {
! 2543: pos_copy = *trypos; /* copy trypos, findmatch will change it */
! 2544: trypos = &pos_copy;
! 2545: curwin->w_cursor = *trypos;
! 2546: if (find_start_comment(ind_maxcomment) != NULL) /* XXX */
! 2547: trypos = NULL;
! 2548: }
! 2549: }
! 2550: curwin->w_cursor = cursor_save;
! 2551: return trypos;
! 2552: }
! 2553:
! 2554: /*
! 2555: * Set w_cursor.col to the column number of the last ')' in line "l".
! 2556: */
! 2557: static int
! 2558: find_last_paren(l)
! 2559: char_u *l;
! 2560: {
! 2561: int i;
! 2562: int retval = FALSE;
! 2563:
! 2564: curwin->w_cursor.col = 0; /* default is start of line */
! 2565:
! 2566: for (i = 0; l[i]; i++)
! 2567: {
! 2568: i = skip_string(l + i) - l; /* ignore parens in quotes */
! 2569: if (l[i] == ')')
! 2570: {
! 2571: curwin->w_cursor.col = i;
! 2572: retval = TRUE;
! 2573: }
! 2574: }
! 2575: return retval;
! 2576: }
! 2577:
! 2578: int
! 2579: get_c_indent()
! 2580: {
! 2581: /*
! 2582: * spaces from a block's opening brace the prevailing indent for that
! 2583: * block should be
! 2584: */
! 2585: int ind_level = curbuf->b_p_sw;
! 2586:
! 2587: /*
! 2588: * spaces from the edge of the line an open brace that's at the end of a
! 2589: * line is imagined to be.
! 2590: */
! 2591: int ind_open_imag = 0;
! 2592:
! 2593: /*
! 2594: * spaces from the prevailing indent for a line that is not precededof by
! 2595: * an opening brace.
! 2596: */
! 2597: int ind_no_brace = 0;
! 2598:
! 2599: /*
! 2600: * column where the first { of a function should be located
! 2601: */
! 2602: int ind_first_open = 0;
! 2603:
! 2604: /*
! 2605: * spaces from the prevailing indent a leftmost open brace should be
! 2606: * located
! 2607: */
! 2608: int ind_open_extra = 0;
! 2609:
! 2610: /*
! 2611: * spaces from the matching open brace (real location for one at the left
! 2612: * edge; imaginary location from one that ends a line) the matching close
! 2613: * brace should be located
! 2614: */
! 2615: int ind_close_extra = 0;
! 2616:
! 2617: /*
! 2618: * spaces from the edge of the line an open brace sitting in the leftmost
! 2619: * column is imagined to be
! 2620: */
! 2621: int ind_open_left_imag = 0;
! 2622:
! 2623: /*
! 2624: * spaces from the switch() indent a "case xx" label should be located
! 2625: */
! 2626: int ind_case = curbuf->b_p_sw;
! 2627:
! 2628: /*
! 2629: * spaces from the "case xx:" code after a switch() should be located
! 2630: */
! 2631: int ind_case_code = curbuf->b_p_sw;
! 2632:
! 2633: /*
! 2634: * amount K&R-style parameters should be indented
! 2635: */
! 2636: int ind_param = curbuf->b_p_sw;
! 2637:
! 2638: /*
! 2639: * amount a function type spec should be indented
! 2640: */
! 2641: int ind_func_type = curbuf->b_p_sw;
! 2642:
! 2643: /*
! 2644: * additional spaces beyond the prevailing indent a continuation line
! 2645: * should be located
! 2646: */
! 2647: int ind_continuation = curbuf->b_p_sw;
! 2648:
! 2649: /*
! 2650: * spaces from the indent of the line with an unclosed parentheses
! 2651: */
! 2652: int ind_unclosed = curbuf->b_p_sw * 2;
! 2653:
! 2654: /*
! 2655: * spaces from the comment opener when there is nothing after it.
! 2656: */
! 2657: int ind_in_comment = 3;
! 2658:
! 2659: /*
! 2660: * max lines to search for an open paren
! 2661: */
! 2662: int ind_maxparen = 20;
! 2663:
! 2664: /*
! 2665: * max lines to search for an open comment
! 2666: */
! 2667: int ind_maxcomment = 30;
! 2668:
! 2669: FPOS cur_curpos;
! 2670: int amount;
! 2671: int scope_amount;
! 2672: int cur_amount;
! 2673: colnr_t col;
! 2674: char_u *theline;
! 2675: char_u *linecopy;
! 2676: FPOS *trypos;
! 2677: FPOS our_paren_pos;
! 2678: char_u *start;
! 2679: int start_brace;
! 2680: #define BRACE_IN_COL0 1 /* '{' is in comumn 0 */
! 2681: #define BRACE_AT_START 2 /* '{' is at start of line */
! 2682: #define BRACE_AT_END 3 /* '{' is at end of line */
! 2683: linenr_t ourscope;
! 2684: char_u *l;
! 2685: char_u *look;
! 2686: int lookfor;
! 2687: #define LOOKFOR_IF 1
! 2688: #define LOOKFOR_DO 2
! 2689: #define LOOKFOR_CASE 3
! 2690: #define LOOKFOR_ANY 4
! 2691: #define LOOKFOR_TERM 5
! 2692: #define LOOKFOR_UNTERM 6
! 2693: int whilelevel;
! 2694: linenr_t lnum;
! 2695: char_u *options;
! 2696: int fraction = 0; /* init for GCC */
! 2697: int divider;
! 2698: int n;
! 2699:
! 2700: for (options = curbuf->b_p_cino; *options; )
! 2701: {
! 2702: l = options++;
! 2703: if (*options == '-')
! 2704: ++options;
! 2705: n = getdigits(&options);
! 2706: divider = 0;
! 2707: if (*options == '.') /* ".5s" means a fraction */
! 2708: {
! 2709: fraction = atol((char *)++options);
! 2710: while (isdigit(*options))
! 2711: {
! 2712: ++options;
! 2713: if (divider)
! 2714: divider *= 10;
! 2715: else
! 2716: divider = 10;
! 2717: }
! 2718: }
! 2719: if (*options == 's') /* "2s" means two times 'shiftwidth' */
! 2720: {
! 2721: if (n == 0 && fraction == 0)
! 2722: n = curbuf->b_p_sw; /* just "s" is one 'shiftwidth' */
! 2723: else
! 2724: {
! 2725: n *= curbuf->b_p_sw;
! 2726: if (divider)
! 2727: n += (curbuf->b_p_sw * fraction + divider / 2) / divider;
! 2728: }
! 2729: ++options;
! 2730: }
! 2731: if (l[1] == '-')
! 2732: n = -n;
! 2733: switch (*l)
! 2734: {
! 2735: case '>': ind_level = n; break;
! 2736: case 'e': ind_open_imag = n; break;
! 2737: case 'n': ind_no_brace = n; break;
! 2738: case 'f': ind_first_open = n; break;
! 2739: case '{': ind_open_extra = n; break;
! 2740: case '}': ind_close_extra = n; break;
! 2741: case '^': ind_open_left_imag = n; break;
! 2742: case ':': ind_case = n; break;
! 2743: case '=': ind_case_code = n; break;
! 2744: case 'p': ind_param = n; break;
! 2745: case 't': ind_func_type = n; break;
! 2746: case 'c': ind_in_comment = n; break;
! 2747: case '+': ind_continuation = n; break;
! 2748: case '(': ind_unclosed = n; break;
! 2749: case ')': ind_maxparen = n; break;
! 2750: case '*': ind_maxcomment = n; break;
! 2751: }
! 2752: }
! 2753:
! 2754: /* remember where the cursor was when we started */
! 2755:
! 2756: cur_curpos = curwin->w_cursor;
! 2757:
! 2758: /* get the current contents of the line.
! 2759: * This is required, because onle the most recent line obtained with
! 2760: * ml_get is valid! */
! 2761:
! 2762: linecopy = strsave(ml_get(cur_curpos.lnum));
! 2763: if (linecopy == NULL)
! 2764: return 0;
! 2765:
! 2766: /*
! 2767: * In insert mode and the cursor is on a ')' trunctate the line at the
! 2768: * cursor position. We don't want to line up with the matching '(' when
! 2769: * inserting new stuff.
! 2770: */
! 2771: if ((State & INSERT) && linecopy[curwin->w_cursor.col] == ')')
! 2772: linecopy[curwin->w_cursor.col] = NUL;
! 2773:
! 2774: theline = skipwhite(linecopy);
! 2775:
! 2776: /* move the cursor to the start of the line */
! 2777:
! 2778: curwin->w_cursor.col = 0;
! 2779:
! 2780: /*
! 2781: * #defines and so on always go at the left when included in 'cinkeys'.
! 2782: */
! 2783: if (*theline == '#' && (*linecopy == '#' || in_cinkeys('#', ' ', TRUE)))
! 2784: {
! 2785: amount = 0;
! 2786: }
! 2787:
! 2788: /*
! 2789: * Is it a non-case label? Then that goes at the left margin too.
! 2790: */
! 2791: else if (islabel(ind_maxcomment)) /* XXX */
! 2792: {
! 2793: amount = 0;
! 2794: }
! 2795:
! 2796: /*
! 2797: * If we're inside a comment and not looking at the start of the
! 2798: * comment...
! 2799: */
! 2800: else if (!iscomment(theline) &&
! 2801: (trypos = find_start_comment(ind_maxcomment)) != NULL) /* XXX */
! 2802: {
! 2803:
! 2804: /* find how indented the line beginning the comment is */
! 2805: getvcol(curwin, trypos, &col, NULL, NULL);
! 2806: amount = col;
! 2807:
! 2808: /* if our line starts with an asterisk, line up with the
! 2809: * asterisk in the comment opener; otherwise, line up
! 2810: * with the first character of the comment text.
! 2811: */
! 2812: if (theline[0] == '*')
! 2813: {
! 2814: amount += 1;
! 2815: }
! 2816: else
! 2817: {
! 2818: /*
! 2819: * If we are more than one line away from the comment opener, take
! 2820: * the indent of the previous non-empty line.
! 2821: * If we are just below the comment opener and there are any
! 2822: * white characters after it line up with the text after it.
! 2823: * up with them; otherwise, just use a single space.
! 2824: */
! 2825: amount = -1;
! 2826: for (lnum = cur_curpos.lnum - 1; lnum > trypos->lnum; --lnum)
! 2827: {
! 2828: if (linewhite(lnum)) /* skip blank lines */
! 2829: continue;
! 2830: amount = get_indent_lnum(lnum); /* XXX */
! 2831: break;
! 2832: }
! 2833: if (amount == -1) /* use the comment opener */
! 2834: {
! 2835: start = ml_get(trypos->lnum);
! 2836: look = start + trypos->col + 2; /* skip / and * */
! 2837: if (*look) /* if something after it */
! 2838: trypos->col = skipwhite(look) - start;
! 2839: getvcol(curwin, trypos, &col, NULL, NULL);
! 2840: amount = col;
! 2841: if (!*look)
! 2842: amount += ind_in_comment;
! 2843: }
! 2844: }
! 2845: }
! 2846:
! 2847: /*
! 2848: * Are we inside parentheses?
! 2849: */ /* XXX */
! 2850: else if ((trypos = find_match_paren(ind_maxparen, ind_maxcomment)) != NULL)
! 2851: {
! 2852: /*
! 2853: * If the matching paren is more than one line away, use the indent of
! 2854: * a previous non-empty line that matches the same paren.
! 2855: */
! 2856: amount = -1;
! 2857: our_paren_pos = *trypos;
! 2858: if (theline[0] != ')')
! 2859: {
! 2860: for (lnum = cur_curpos.lnum - 1; lnum > our_paren_pos.lnum; --lnum)
! 2861: {
! 2862: l = skipwhite(ml_get(lnum));
! 2863: if (commentorempty(l)) /* skip comment lines */
! 2864: continue;
! 2865: if (ispreproc(l)) /* ignore #defines, #if, etc. */
! 2866: continue;
! 2867: curwin->w_cursor.lnum = lnum;
! 2868: /* XXX */
! 2869: if ((trypos = find_match_paren(ind_maxparen,
! 2870: ind_maxcomment)) != NULL &&
! 2871: trypos->lnum == our_paren_pos.lnum &&
! 2872: trypos->col == our_paren_pos.col)
! 2873: {
! 2874: amount = get_indent_lnum(lnum); /* XXX */
! 2875: break;
! 2876: }
! 2877: }
! 2878: }
! 2879:
! 2880: /*
! 2881: * Line up with line where the matching paren is.
! 2882: * If the line starts with a '(' or the indent for unclosed
! 2883: * parentheses is zero, line up with the unclosed parentheses.
! 2884: */
! 2885: if (amount == -1)
! 2886: {
! 2887: amount = skip_label(our_paren_pos.lnum, &look, ind_maxcomment);
! 2888: if (theline[0] == ')' || ind_unclosed == 0 ||
! 2889: *skipwhite(look) == '(')
! 2890: {
! 2891:
! 2892: /*
! 2893: * If we're looking at a close paren, line up right there;
! 2894: * otherwise, line up with the next non-white character.
! 2895: */
! 2896: if (theline[0] != ')')
! 2897: {
! 2898: col = our_paren_pos.col + 1;
! 2899: look = ml_get(our_paren_pos.lnum);
! 2900: while (vim_iswhite(look[col]))
! 2901: col++;
! 2902: if (look[col] != NUL) /* In case of trailing space */
! 2903: our_paren_pos.col = col;
! 2904: else
! 2905: our_paren_pos.col++;
! 2906: }
! 2907:
! 2908: /*
! 2909: * Find how indented the paren is, or the character after it if
! 2910: * we did the above "if".
! 2911: */
! 2912: getvcol(curwin, &our_paren_pos, &col, NULL, NULL);
! 2913: amount = col;
! 2914: }
! 2915: else
! 2916: amount += ind_unclosed;
! 2917: }
! 2918: }
! 2919:
! 2920: /*
! 2921: * Are we at least inside braces, then?
! 2922: */
! 2923: else if ((trypos = find_start_brace(ind_maxcomment)) != NULL) /* XXX */
! 2924: {
! 2925: ourscope = trypos->lnum;
! 2926: start = ml_get(ourscope);
! 2927:
! 2928: /*
! 2929: * Now figure out how indented the line is in general.
! 2930: * If the brace was at the start of the line, we use that;
! 2931: * otherwise, check out the indentation of the line as
! 2932: * a whole and then add the "imaginary indent" to that.
! 2933: */
! 2934: look = skipwhite(start);
! 2935: if (*look == '{')
! 2936: {
! 2937: getvcol(curwin, trypos, &col, NULL, NULL);
! 2938: amount = col;
! 2939: if (*start == '{')
! 2940: start_brace = BRACE_IN_COL0;
! 2941: else
! 2942: start_brace = BRACE_AT_START;
! 2943: }
! 2944: else
! 2945: {
! 2946: /*
! 2947: * that opening brace might have been on a continuation
! 2948: * line. if so, find the start of the line.
! 2949: */
! 2950: curwin->w_cursor.lnum = ourscope;
! 2951:
! 2952: /*
! 2953: * position the cursor over the rightmost paren, so that
! 2954: * matching it will take us back to the start of the line.
! 2955: */
! 2956: lnum = ourscope;
! 2957: if (find_last_paren(start) &&
! 2958: (trypos = find_match_paren(ind_maxparen,
! 2959: ind_maxcomment)) != NULL)
! 2960: lnum = trypos->lnum;
! 2961:
! 2962: /*
! 2963: * It could have been something like
! 2964: * case 1: if (asdf &&
! 2965: * ldfd) {
! 2966: * }
! 2967: */
! 2968: amount = skip_label(lnum, &l, ind_maxcomment);
! 2969:
! 2970: start_brace = BRACE_AT_END;
! 2971: }
! 2972:
! 2973: /*
! 2974: * if we're looking at a closing brace, that's where
! 2975: * we want to be. otherwise, add the amount of room
! 2976: * that an indent is supposed to be.
! 2977: */
! 2978: if (theline[0] == '}')
! 2979: {
! 2980: /*
! 2981: * they may want closing braces to line up with something
! 2982: * other than the open brace. indulge them, if so.
! 2983: */
! 2984: amount += ind_close_extra;
! 2985: }
! 2986: else
! 2987: {
! 2988: /*
! 2989: * If we're looking at an "else", try to find an "if"
! 2990: * to match it with.
! 2991: * If we're looking at a "while", try to find a "do"
! 2992: * to match it with.
! 2993: */
! 2994: lookfor = 0;
! 2995: if (iselse(theline))
! 2996: lookfor = LOOKFOR_IF;
! 2997: else if (iswhileofdo(theline, cur_curpos.lnum, ind_maxparen))
! 2998: /* XXX */
! 2999: lookfor = LOOKFOR_DO;
! 3000: if (lookfor)
! 3001: {
! 3002: curwin->w_cursor.lnum = cur_curpos.lnum;
! 3003: if (find_match(lookfor, ourscope, ind_maxparen,
! 3004: ind_maxcomment) == OK)
! 3005: {
! 3006: amount = get_indent(); /* XXX */
! 3007: goto theend;
! 3008: }
! 3009: }
! 3010:
! 3011: /*
! 3012: * We get here if we are not on an "while-of-do" or "else" (or
! 3013: * failed to find a matching "if").
! 3014: * Search backwards for something to line up with.
! 3015: * First set amount for when we don't find anything.
! 3016: */
! 3017:
! 3018: /*
! 3019: * if the '{' is _really_ at the left margin, use the imaginary
! 3020: * location of a left-margin brace. Otherwise, correct the
! 3021: * location for ind_open_extra.
! 3022: */
! 3023:
! 3024: if (start_brace == BRACE_IN_COL0) /* '{' is in column 0 */
! 3025: {
! 3026: amount = ind_open_left_imag;
! 3027: }
! 3028: else
! 3029: {
! 3030: if (start_brace == BRACE_AT_END) /* '{' is at end of line */
! 3031: amount += ind_open_imag;
! 3032: else
! 3033: {
! 3034: amount -= ind_open_extra;
! 3035: if (amount < 0)
! 3036: amount = 0;
! 3037: }
! 3038: }
! 3039:
! 3040: if (iscase(theline)) /* it's a switch() label */
! 3041: {
! 3042: lookfor = LOOKFOR_CASE; /* find a previous switch() label */
! 3043: amount += ind_case;
! 3044: }
! 3045: else
! 3046: {
! 3047: lookfor = LOOKFOR_ANY;
! 3048: amount += ind_level; /* ind_level from start of block */
! 3049: }
! 3050: scope_amount = amount;
! 3051: whilelevel = 0;
! 3052:
! 3053: /*
! 3054: * Search backwards. If we find something we recognize, line up
! 3055: * with that.
! 3056: *
! 3057: * if we're looking at an open brace, indent
! 3058: * the usual amount relative to the conditional
! 3059: * that opens the block.
! 3060: */
! 3061: curwin->w_cursor = cur_curpos;
! 3062: for (;;)
! 3063: {
! 3064: curwin->w_cursor.lnum--;
! 3065: curwin->w_cursor.col = 0;
! 3066:
! 3067: /*
! 3068: * If we went all the way back to the start of our scope, line
! 3069: * up with it.
! 3070: */
! 3071: if (curwin->w_cursor.lnum <= ourscope)
! 3072: {
! 3073: if (lookfor == LOOKFOR_UNTERM)
! 3074: amount += ind_continuation;
! 3075: else if (lookfor != LOOKFOR_TERM)
! 3076: amount = scope_amount;
! 3077: break;
! 3078: }
! 3079:
! 3080: /*
! 3081: * If we're in a comment now, skip to the start of the comment.
! 3082: */ /* XXX */
! 3083: if ((trypos = find_start_comment(ind_maxcomment)) != NULL)
! 3084: {
! 3085: curwin->w_cursor.lnum = trypos->lnum + 1;
! 3086: continue;
! 3087: }
! 3088:
! 3089: l = ml_get_curline();
! 3090:
! 3091: /*
! 3092: * If this is a switch() label, may line up relative to that.
! 3093: */
! 3094: if (iscase(l))
! 3095: {
! 3096: /*
! 3097: * case xx:
! 3098: * c = 99 + <- this indent plus continuation
! 3099: *-> here;
! 3100: */
! 3101: if (lookfor == LOOKFOR_UNTERM)
! 3102: {
! 3103: amount += ind_continuation;
! 3104: break;
! 3105: }
! 3106:
! 3107: /*
! 3108: * case xx: <- line up with this case
! 3109: * x = 333;
! 3110: * case yy:
! 3111: */
! 3112: if (lookfor == LOOKFOR_CASE)
! 3113: {
! 3114: /*
! 3115: * Check that this case label is not for another
! 3116: * switch()
! 3117: */ /* XXX */
! 3118: if ((trypos = find_start_brace(ind_maxcomment)) ==
! 3119: NULL || trypos->lnum == ourscope)
! 3120: {
! 3121: amount = get_indent(); /* XXX */
! 3122: break;
! 3123: }
! 3124: continue;
! 3125: }
! 3126:
! 3127: n = get_indent_nolabel(curwin->w_cursor.lnum); /* XXX */
! 3128:
! 3129: /*
! 3130: * case xx: if (cond) <- line up with this if
! 3131: * y = y + 1;
! 3132: * -> s = 99;
! 3133: *
! 3134: * case xx:
! 3135: * if (cond) <- line up with this line
! 3136: * y = y + 1;
! 3137: * -> s = 99;
! 3138: */
! 3139: if (lookfor == LOOKFOR_TERM)
! 3140: {
! 3141: if (n)
! 3142: amount = n;
! 3143: break;
! 3144: }
! 3145:
! 3146: /*
! 3147: * case xx: x = x + 1; <- line up with this x
! 3148: * -> y = y + 1;
! 3149: *
! 3150: * case xx: if (cond) <- line up with this if
! 3151: * -> y = y + 1;
! 3152: */
! 3153: if (n)
! 3154: {
! 3155: amount = n;
! 3156: l = after_label(ml_get_curline());
! 3157: if (l != NULL && is_cinword(l))
! 3158: amount += ind_level + ind_no_brace;
! 3159: break;
! 3160: }
! 3161:
! 3162: /*
! 3163: * Try to get the indent of a statement before the
! 3164: * switch label. If nothing is found, line up relative
! 3165: * to the switch label.
! 3166: * break; <- may line up with this line
! 3167: * case xx:
! 3168: * -> y = 1;
! 3169: */
! 3170: scope_amount = get_indent() + ind_case_code; /* XXX */
! 3171: lookfor = LOOKFOR_ANY;
! 3172: continue;
! 3173: }
! 3174:
! 3175: /*
! 3176: * Looking for a switch() label, ignore other lines.
! 3177: */
! 3178: if (lookfor == LOOKFOR_CASE)
! 3179: continue;
! 3180:
! 3181: /*
! 3182: * Ignore jump labels with nothing after them.
! 3183: */
! 3184: if (islabel(ind_maxcomment))
! 3185: {
! 3186: l = after_label(ml_get_curline());
! 3187: if (l == NULL || commentorempty(l))
! 3188: continue;
! 3189: }
! 3190:
! 3191: /*
! 3192: * Ignore #defines, #if, etc.
! 3193: * Ignore comment and empty lines.
! 3194: * (need to get the line again, islabel() may have unlocked it)
! 3195: */
! 3196: l = ml_get_curline();
! 3197: if (ispreproc(l) || commentorempty(l))
! 3198: continue;
! 3199:
! 3200: /*
! 3201: * What happens next depends on the line being terminated.
! 3202: */
! 3203: if (!isterminated(l))
! 3204: {
! 3205: /*
! 3206: * if we're in the middle of a paren thing,
! 3207: * go back to the line that starts it so
! 3208: * we can get the right prevailing indent
! 3209: * if ( foo &&
! 3210: * bar )
! 3211: */
! 3212: /*
! 3213: * position the cursor over the rightmost paren, so that
! 3214: * matching it will take us back to the start of the line.
! 3215: */
! 3216: (void)find_last_paren(l);
! 3217: if ((trypos = find_match_paren(ind_maxparen,
! 3218: ind_maxcomment)) != NULL)
! 3219: {
! 3220: /*
! 3221: * Check if we are on a case label now. This is
! 3222: * handled above.
! 3223: * case xx: if ( asdf &&
! 3224: * asdf)
! 3225: */
! 3226: curwin->w_cursor.lnum = trypos->lnum;
! 3227: l = ml_get_curline();
! 3228: if (iscase(l))
! 3229: {
! 3230: ++curwin->w_cursor.lnum;
! 3231: continue;
! 3232: }
! 3233: }
! 3234:
! 3235: /*
! 3236: * Get indent and pointer to text for current line,
! 3237: * ignoring any jump label. XXX
! 3238: */
! 3239: cur_amount = skip_label(curwin->w_cursor.lnum,
! 3240: &l, ind_maxcomment);
! 3241:
! 3242: /*
! 3243: * If this is just above the line we are indenting, and it
! 3244: * starts with a '{', line it up with this line.
! 3245: * while (not)
! 3246: * -> {
! 3247: * }
! 3248: */
! 3249: if (lookfor != LOOKFOR_TERM && theline[0] == '{')
! 3250: {
! 3251: amount = cur_amount + ind_open_extra;
! 3252: break;
! 3253: }
! 3254:
! 3255: /*
! 3256: * Check if we are after an "if", "while", etc.
! 3257: */
! 3258: if (is_cinword(l))
! 3259: {
! 3260: /*
! 3261: * Found an unterminated line after an if (), line up
! 3262: * with the last one.
! 3263: * if (cond)
! 3264: * 100 +
! 3265: * -> here;
! 3266: */
! 3267: if (lookfor == LOOKFOR_UNTERM)
! 3268: {
! 3269: amount += ind_continuation;
! 3270: break;
! 3271: }
! 3272:
! 3273: /*
! 3274: * If this is just above the line we are indenting, we
! 3275: * are finished.
! 3276: * while (not)
! 3277: * -> here;
! 3278: * Otherwise this indent can be used when the line
! 3279: * before this is terminated.
! 3280: * yyy;
! 3281: * if (stat)
! 3282: * while (not)
! 3283: * xxx;
! 3284: * -> here;
! 3285: */
! 3286: amount = cur_amount;
! 3287: if (lookfor != LOOKFOR_TERM)
! 3288: {
! 3289: amount += ind_level + ind_no_brace;
! 3290: break;
! 3291: }
! 3292:
! 3293: /*
! 3294: * Special trick: when expecting the while () after a
! 3295: * do, line up with the while()
! 3296: * do
! 3297: * x = 1;
! 3298: * -> here
! 3299: */
! 3300: l = skipwhite(ml_get_curline());
! 3301: if (isdo(l))
! 3302: {
! 3303: if (whilelevel == 0)
! 3304: break;
! 3305: --whilelevel;
! 3306: }
! 3307:
! 3308: /*
! 3309: * When searching for a terminated line, don't use the
! 3310: * one between the "if" and the "else".
! 3311: */
! 3312: if (iselse(l))
! 3313: {
! 3314: if (find_match(LOOKFOR_IF, ourscope,
! 3315: ind_maxparen, ind_maxcomment) == FAIL)
! 3316: break;
! 3317: }
! 3318: }
! 3319:
! 3320: /*
! 3321: * If we're below an unterminated line that is not an
! 3322: * "if" or something, we may line up with this line or
! 3323: * add someting for a continuation line, depending on
! 3324: * the line before this one.
! 3325: */
! 3326: else
! 3327: {
! 3328: /*
! 3329: * Found two unterminated lines on a row, line up with
! 3330: * the last one.
! 3331: * c = 99 +
! 3332: * 100 +
! 3333: * -> here;
! 3334: */
! 3335: if (lookfor == LOOKFOR_UNTERM)
! 3336: break;
! 3337:
! 3338: /*
! 3339: * Found first unterminated line on a row, may line up
! 3340: * with this line, remember its indent
! 3341: * 100 +
! 3342: * -> here;
! 3343: */
! 3344: amount = cur_amount;
! 3345: if (lookfor != LOOKFOR_TERM)
! 3346: lookfor = LOOKFOR_UNTERM;
! 3347: }
! 3348: }
! 3349:
! 3350: /*
! 3351: * Check if we are after a while (cond);
! 3352: * If so: Ignore the matching "do".
! 3353: */
! 3354: /* XXX */
! 3355: else if (iswhileofdo(l, curwin->w_cursor.lnum, ind_maxparen))
! 3356: {
! 3357: /*
! 3358: * Found an unterminated line after a while ();, line up
! 3359: * with the last one.
! 3360: * while (cond);
! 3361: * 100 + <- line up with this one
! 3362: * -> here;
! 3363: */
! 3364: if (lookfor == LOOKFOR_UNTERM)
! 3365: {
! 3366: amount += ind_continuation;
! 3367: break;
! 3368: }
! 3369:
! 3370: if (whilelevel == 0)
! 3371: {
! 3372: lookfor = LOOKFOR_TERM;
! 3373: amount = get_indent(); /* XXX */
! 3374: if (theline[0] == '{')
! 3375: amount += ind_open_extra;
! 3376: }
! 3377: ++whilelevel;
! 3378: }
! 3379:
! 3380: /*
! 3381: * We are after a "normal" statement.
! 3382: * If we had another statement we can stop now and use the
! 3383: * indent of that other statement.
! 3384: * Otherwise the indent of the current statement may be used,
! 3385: * search backwards for the next "normal" statement.
! 3386: */
! 3387: else
! 3388: {
! 3389: /*
! 3390: * Found a terminated line above an unterminated line. Add
! 3391: * the amount for a continuation line.
! 3392: * x = 1;
! 3393: * y = foo +
! 3394: * -> here;
! 3395: */
! 3396: if (lookfor == LOOKFOR_UNTERM)
! 3397: {
! 3398: amount += ind_continuation;
! 3399: break;
! 3400: }
! 3401:
! 3402: /*
! 3403: * Found a terminated line above a terminated line or "if"
! 3404: * etc. line. Use the amount of the line below us.
! 3405: * x = 1; x = 1;
! 3406: * if (asdf) y = 2;
! 3407: * while (asdf) ->here;
! 3408: * here;
! 3409: * ->foo;
! 3410: */
! 3411: if (lookfor == LOOKFOR_TERM)
! 3412: {
! 3413: if (whilelevel == 0)
! 3414: break;
! 3415: }
! 3416:
! 3417: /*
! 3418: * First line above the one we're indenting is terminated.
! 3419: * To know what needs to be done look further backward for
! 3420: * a terminated line.
! 3421: */
! 3422: else
! 3423: {
! 3424: /*
! 3425: * position the cursor over the rightmost paren, so
! 3426: * that matching it will take us back to the start of
! 3427: * the line. Helps for:
! 3428: * func(asdr,
! 3429: * asdfasdf);
! 3430: * here;
! 3431: */
! 3432: l = ml_get_curline();
! 3433: if (find_last_paren(l) &&
! 3434: (trypos = find_match_paren(ind_maxparen,
! 3435: ind_maxcomment)) != NULL)
! 3436: {
! 3437: /*
! 3438: * Check if we are on a case label now. This is
! 3439: * handled above.
! 3440: * case xx: if ( asdf &&
! 3441: * asdf)
! 3442: */
! 3443: curwin->w_cursor.lnum = trypos->lnum;
! 3444: l = ml_get_curline();
! 3445: if (iscase(l))
! 3446: {
! 3447: ++curwin->w_cursor.lnum;
! 3448: continue;
! 3449: }
! 3450: }
! 3451:
! 3452: /*
! 3453: * Get indent and pointer to text for current line,
! 3454: * ignoring any jump label.
! 3455: */
! 3456: amount = skip_label(curwin->w_cursor.lnum,
! 3457: &l, ind_maxcomment);
! 3458:
! 3459: if (theline[0] == '{')
! 3460: amount += ind_open_extra;
! 3461: lookfor = LOOKFOR_TERM;
! 3462:
! 3463: /*
! 3464: * If we're at the end of a block, skip to the start of
! 3465: * that block.
! 3466: */
! 3467: if (*skipwhite(l) == '}' &&
! 3468: (trypos = find_start_brace(ind_maxcomment))
! 3469: != NULL) /* XXX */
! 3470: curwin->w_cursor.lnum = trypos->lnum;
! 3471: }
! 3472: }
! 3473: }
! 3474: }
! 3475: }
! 3476:
! 3477: /*
! 3478: * ok -- we're not inside any sort of structure at all!
! 3479: *
! 3480: * this means we're at the top level, and everything should
! 3481: * basically just match where the previous line is, except
! 3482: * for the lines immediately following a function declaration,
! 3483: * which are K&R-style parameters and need to be indented.
! 3484: */
! 3485: else
! 3486: {
! 3487: /*
! 3488: * if our line starts with an open brace, forget about any
! 3489: * prevailing indent and make sure it looks like the start
! 3490: * of a function
! 3491: */
! 3492:
! 3493: if (theline[0] == '{')
! 3494: {
! 3495: amount = ind_first_open;
! 3496: }
! 3497:
! 3498: /*
! 3499: * If the NEXT line is a function declaration, the current
! 3500: * line needs to be indented as a function type spec.
! 3501: * Don't do this if the current line looks like a comment.
! 3502: */
! 3503: else if (cur_curpos.lnum < curbuf->b_ml.ml_line_count &&
! 3504: !commentorempty(theline) &&
! 3505: isfuncdecl(ml_get(cur_curpos.lnum + 1)))
! 3506: {
! 3507: amount = ind_func_type;
! 3508: }
! 3509: else
! 3510: {
! 3511: amount = 0;
! 3512: curwin->w_cursor = cur_curpos;
! 3513:
! 3514: /* search backwards until we find something we recognize */
! 3515:
! 3516: while (curwin->w_cursor.lnum > 1)
! 3517: {
! 3518: curwin->w_cursor.lnum--;
! 3519: curwin->w_cursor.col = 0;
! 3520:
! 3521: l = ml_get_curline();
! 3522:
! 3523: /*
! 3524: * If we're in a comment now, skip to the start of the comment.
! 3525: */ /* XXX */
! 3526: if ((trypos = find_start_comment(ind_maxcomment)) != NULL)
! 3527: {
! 3528: curwin->w_cursor.lnum = trypos->lnum + 1;
! 3529: continue;
! 3530: }
! 3531:
! 3532: /*
! 3533: * If the line looks like a function declaration, and we're
! 3534: * not in a comment, put it the left margin.
! 3535: */
! 3536: if (isfuncdecl(theline))
! 3537: break;
! 3538:
! 3539: /*
! 3540: * Skip preprocessor directives and blank lines.
! 3541: */
! 3542: if (ispreproc(l))
! 3543: continue;
! 3544:
! 3545: if (commentorempty(l))
! 3546: continue;
! 3547:
! 3548: /*
! 3549: * If the PREVIOUS line is a function declaration, the current
! 3550: * line (and the ones that follow) needs to be indented as
! 3551: * parameters.
! 3552: */
! 3553: if (isfuncdecl(l))
! 3554: {
! 3555: amount = ind_param;
! 3556: break;
! 3557: }
! 3558:
! 3559: /*
! 3560: * Doesn't look like anything interesting -- so just
! 3561: * use the indent of this line.
! 3562: *
! 3563: * Position the cursor over the rightmost paren, so that
! 3564: * matching it will take us back to the start of the line.
! 3565: */
! 3566: find_last_paren(l);
! 3567:
! 3568: if ((trypos = find_match_paren(ind_maxparen,
! 3569: ind_maxcomment)) != NULL)
! 3570: curwin->w_cursor.lnum = trypos->lnum;
! 3571: amount = get_indent(); /* XXX */
! 3572: break;
! 3573: }
! 3574: }
! 3575: }
! 3576:
! 3577: theend:
! 3578: /* put the cursor back where it belongs */
! 3579: curwin->w_cursor = cur_curpos;
! 3580:
! 3581: vim_free(linecopy);
! 3582:
! 3583: if (amount < 0)
! 3584: return 0;
! 3585: return amount;
! 3586: }
! 3587:
! 3588: static int
! 3589: find_match(lookfor, ourscope, ind_maxparen, ind_maxcomment)
! 3590: int lookfor;
! 3591: linenr_t ourscope;
! 3592: int ind_maxparen;
! 3593: int ind_maxcomment;
! 3594: {
! 3595: char_u *look;
! 3596: FPOS *theirscope;
! 3597: char_u *mightbeif;
! 3598: int elselevel;
! 3599: int whilelevel;
! 3600:
! 3601: if (lookfor == LOOKFOR_IF)
! 3602: {
! 3603: elselevel = 1;
! 3604: whilelevel = 0;
! 3605: }
! 3606: else
! 3607: {
! 3608: elselevel = 0;
! 3609: whilelevel = 1;
! 3610: }
! 3611:
! 3612: curwin->w_cursor.col = 0;
! 3613:
! 3614: while (curwin->w_cursor.lnum > ourscope + 1)
! 3615: {
! 3616: curwin->w_cursor.lnum--;
! 3617: curwin->w_cursor.col = 0;
! 3618:
! 3619: look = skipwhite(ml_get_curline());
! 3620: if (iselse(look) || isif(look) || isdo(look) ||
! 3621: iswhileofdo(look, curwin->w_cursor.lnum, ind_maxparen)) /* XXX */
! 3622: {
! 3623: /*
! 3624: * if we've gone outside the braces entirely,
! 3625: * we must be out of scope...
! 3626: */
! 3627: theirscope = find_start_brace(ind_maxcomment); /* XXX */
! 3628: if (theirscope == NULL)
! 3629: break;
! 3630:
! 3631: /*
! 3632: * and if the brace enclosing this is further
! 3633: * back than the one enclosing the else, we're
! 3634: * out of luck too.
! 3635: */
! 3636: if (theirscope->lnum < ourscope)
! 3637: break;
! 3638:
! 3639: /*
! 3640: * and if they're enclosed in a *deeper* brace,
! 3641: * then we can ignore it because it's in a
! 3642: * different scope...
! 3643: */
! 3644: if (theirscope->lnum > ourscope)
! 3645: continue;
! 3646:
! 3647: /*
! 3648: * if it was an "else" (that's not an "else if")
! 3649: * then we need to go back to another if, so
! 3650: * increment elselevel
! 3651: */
! 3652: look = skipwhite(ml_get_curline());
! 3653: if (iselse(look))
! 3654: {
! 3655: mightbeif = skipwhite(look + 4);
! 3656: if (!isif(mightbeif))
! 3657: ++elselevel;
! 3658: continue;
! 3659: }
! 3660:
! 3661: /*
! 3662: * if it was a "while" then we need to go back to
! 3663: * another "do", so increment whilelevel.
! 3664: */
! 3665: if (iswhileofdo(look, curwin->w_cursor.lnum, ind_maxparen))/* XXX */
! 3666: {
! 3667: ++whilelevel;
! 3668: continue;
! 3669: }
! 3670:
! 3671: /* If it's an "if" decrement elselevel */
! 3672: look = skipwhite(ml_get_curline());
! 3673: if (isif(look))
! 3674: {
! 3675: elselevel--;
! 3676: /*
! 3677: * When looking for an "if" ignore "while"s that
! 3678: * get in the way.
! 3679: */
! 3680: if (elselevel == 0 && lookfor == LOOKFOR_IF)
! 3681: whilelevel = 0;
! 3682: }
! 3683:
! 3684: /* If it's a "do" decrement whilelevel */
! 3685: if (isdo(look))
! 3686: whilelevel--;
! 3687:
! 3688: /*
! 3689: * if we've used up all the elses, then
! 3690: * this must be the if that we want!
! 3691: * match the indent level of that if.
! 3692: */
! 3693: if (elselevel <= 0 && whilelevel <= 0)
! 3694: {
! 3695: return OK;
! 3696: }
! 3697: }
! 3698: }
! 3699: return FAIL;
! 3700: }
! 3701:
! 3702: #endif /* CINDENT */
! 3703:
! 3704: #ifdef LISPINDENT
! 3705: int
! 3706: get_lisp_indent()
! 3707: {
! 3708: FPOS *pos, realpos;
! 3709: long amount = 0;
! 3710: char_u *that;
! 3711: colnr_t col;
! 3712: colnr_t maybe;
! 3713: colnr_t firsttry;
! 3714:
! 3715:
! 3716: realpos = curwin->w_cursor;
! 3717: curwin->w_cursor.col = 0;
! 3718:
! 3719: if ((pos = findmatch('(')) != NULL)
! 3720: {
! 3721: curwin->w_cursor.lnum = pos->lnum;
! 3722: curwin->w_cursor.col = pos->col;
! 3723: col = pos->col;
! 3724:
! 3725: that = ml_get_curline();
! 3726: maybe = get_indent(); /* XXX */
! 3727:
! 3728: if (maybe == 0)
! 3729: amount = 2;
! 3730: else
! 3731: {
! 3732: while (*that && col)
! 3733: {
! 3734: amount += lbr_chartabsize(that, (colnr_t)amount);
! 3735: col--;
! 3736: that++;
! 3737: }
! 3738:
! 3739: that++;
! 3740: amount++;
! 3741: firsttry = amount;
! 3742:
! 3743: /*
! 3744: * Go to the start of the second word.
! 3745: * If there is no second word, go back to firsttry.
! 3746: * Also stop at a '('.
! 3747: */
! 3748:
! 3749: while (vim_iswhite(*that))
! 3750: {
! 3751: amount += lbr_chartabsize(that, (colnr_t)amount);
! 3752: that++;
! 3753: }
! 3754: while (*that && !vim_iswhite(*that) && *that != '(')
! 3755: {
! 3756: amount += lbr_chartabsize(that, (colnr_t)amount);
! 3757: that++;
! 3758: }
! 3759: while (vim_iswhite(*that))
! 3760: {
! 3761: amount += lbr_chartabsize(that, (colnr_t)amount);
! 3762: that++;
! 3763: }
! 3764: if (! *that)
! 3765: amount = firsttry;
! 3766: }
! 3767: }
! 3768: else /* no matching '(' found, use indent of previous non-empty line */
! 3769: {
! 3770: while (curwin->w_cursor.lnum > 1)
! 3771: {
! 3772: --curwin->w_cursor.lnum;
! 3773: if (!linewhite(curwin->w_cursor.lnum))
! 3774: break;
! 3775: }
! 3776: amount = get_indent(); /* XXX */
! 3777: }
! 3778:
! 3779: curwin->w_cursor = realpos;
! 3780:
! 3781: if (amount < 0)
! 3782: amount = 0;
! 3783: return (int)amount;
! 3784: }
! 3785: #endif /* LISPINDENT */
! 3786:
! 3787: #if defined(UNIX) || defined(WIN32) || defined(__EMX__)
! 3788: /*
! 3789: * Preserve files and exit.
! 3790: * When called IObuff must contain a message.
! 3791: */
! 3792: void
! 3793: preserve_exit()
! 3794: {
! 3795: BUF *buf;
! 3796:
! 3797: #ifdef USE_GUI
! 3798: if (gui.in_use)
! 3799: {
! 3800: gui.dying = TRUE;
! 3801: trash_output_buf(); /* trash any pending output */
! 3802: }
! 3803: else
! 3804: #endif
! 3805: {
! 3806: windgoto((int)Rows - 1, 0);
! 3807:
! 3808: /*
! 3809: * Switch terminal mode back now, so these messages end up on the
! 3810: * "normal" screen (if there are two screens).
! 3811: */
! 3812: settmode(0);
! 3813: #ifdef WIN32
! 3814: if (can_end_termcap_mode(FALSE) == TRUE)
! 3815: #endif
! 3816: stoptermcap();
! 3817: flushbuf();
! 3818: }
! 3819:
! 3820: outstr(IObuff);
! 3821: screen_start(); /* don't know where cursor is now */
! 3822: flushbuf();
! 3823:
! 3824: ml_close_notmod(); /* close all not-modified buffers */
! 3825:
! 3826: for (buf = firstbuf; buf != NULL; buf = buf->b_next)
! 3827: {
! 3828: if (buf->b_ml.ml_mfp != NULL && buf->b_ml.ml_mfp->mf_fname != NULL)
! 3829: {
! 3830: OUTSTR("Vim: preserving files...\n");
! 3831: screen_start(); /* don't know where cursor is now */
! 3832: flushbuf();
! 3833: ml_sync_all(FALSE, FALSE); /* preserve all swap files */
! 3834: break;
! 3835: }
! 3836: }
! 3837:
! 3838: ml_close_all(FALSE); /* close all memfiles, without deleting */
! 3839:
! 3840: OUTSTR("Vim: Finished.\n");
! 3841:
! 3842: getout(1);
! 3843: }
! 3844: #endif /* defined(UNIX) || defined(WIN32) || defined(__EMX__) */
! 3845:
! 3846: /*
! 3847: * return TRUE if "fname" exists.
! 3848: */
! 3849: int
! 3850: vim_fexists(fname)
! 3851: char_u *fname;
! 3852: {
! 3853: struct stat st;
! 3854:
! 3855: if (stat((char *)fname, &st))
! 3856: return FALSE;
! 3857: return TRUE;
! 3858: }
! 3859:
! 3860: /*
! 3861: * Check for CTRL-C pressed, but only once in a while.
! 3862: * Should be used instead of mch_breakcheck() for functions that check for
! 3863: * each line in the file. Calling mch_breakcheck() each time takes too much
! 3864: * time, because it can be a system call.
! 3865: */
! 3866:
! 3867: #ifndef BREAKCHECK_SKIP
! 3868: # define BREAKCHECK_SKIP 32
! 3869: #endif
! 3870:
! 3871: void
! 3872: line_breakcheck()
! 3873: {
! 3874: static int count = 0;
! 3875:
! 3876: if (++count == BREAKCHECK_SKIP)
! 3877: {
! 3878: count = 0;
! 3879: mch_breakcheck();
! 3880: }
! 3881: }
! 3882:
! 3883: /*
! 3884: * Free the list of files returned by ExpandWildCards() or other expansion
! 3885: * functions.
! 3886: */
! 3887: void
! 3888: FreeWild(num, file)
! 3889: int num;
! 3890: char_u **file;
! 3891: {
! 3892: if (file == NULL || num == 0)
! 3893: return;
! 3894: #if defined(__EMX__) && defined(__ALWAYS_HAS_TRAILING_NULL_POINTER) /* XXX */
! 3895: /*
! 3896: * Is this still OK for when other functions thatn ExpandWildCards() have
! 3897: * been used???
! 3898: */
! 3899: _fnexplodefree((char **)file);
! 3900: #else
! 3901: while (num--)
! 3902: vim_free(file[num]);
! 3903: vim_free(file);
! 3904: #endif
! 3905: }
! 3906:
![[BACK]](/icons/back.gif){kind=icon}
Return to misccmds.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / vim