Blog: Better line wrapping in Vim, 8th iteration: vim-7.4.16-fc19-breakindent.patch

File vim-7.4.16-fc19-breakindent.patch, 33.8 KB (added by retracile, 5 years ago)

breakindent for Vim 7.4.16 from Fedora 19

  • runtime/doc/eval.txt

    # runtime/doc/eval.txt    |    4 +--
    # runtime/doc/options.txt |   42 ++++++++++++++++++++++++++++++++----
    # runtime/doc/tags        |    6 +++++
    # runtime/optwin.vim      |    9 +++++++
    # src/charset.c           |   56 ++++++++++++++++++++++++++++++------------------
    # src/edit.c              |   21 +++++++++---------
    # src/eval.c              |    7 ++++--
    # src/ex_cmds.c           |    2 -
    # src/getchar.c           |    2 -
    # src/gui_beval.c         |    2 -
    # src/misc1.c             |   54 +++++++++++++++++++++++++++++++++++++++-------
    # src/misc2.c             |    8 +++---
    # src/normal.c            |    6 ++---
    # src/ops.c               |   16 ++++++-------
    # src/option.c            |   47 ++++++++++++++++++++++++++++++++++++++++
    # src/option.h            |    5 ++++
    # src/proto/charset.pro   |   12 +++++-----
    # src/proto/misc1.pro     |    1 
    # src/regexp.c            |    4 +--
    # src/regexp_nfa.c        |    2 -
    # src/screen.c            |   37 ++++++++++++++++++++++++++++---
    # src/structs.h           |    8 ++++++
    # src/ui.c                |    2 -
    # 23 files changed, 275 insertions(+), 78 deletions(-)
    diff -urN '--exclude=*.orig' '--exclude=*.rej' vim74.orig/runtime/doc/eval.txt vim74/runtime/doc/eval.txt
    old new  
    64076407keymap                  Compiled with 'keymap' support. 
    64086408langmap                 Compiled with 'langmap' support. 
    64096409libcall                 Compiled with |libcall()| support. 
    6410 linebreak               Compiled with 'linebreak', 'breakat' and 'showbreak' 
    6411                         support. 
     6410linebreak               Compiled with 'linebreak', 'breakat', 'showbreak' and 
     6411                        'breakindent' support. 
    64126412lispindent              Compiled with support for lisp indenting. 
    64136413listcmds                Compiled with commands for the buffer list |:files| 
    64146414                        and the argument list |arglist|. 
  • runtime/doc/options.txt

    diff -urN '--exclude=*.orig' '--exclude=*.rej' vim74.orig/runtime/doc/options.txt vim74/runtime/doc/options.txt
    old new  
    12001200        break if 'linebreak' is on.  Only works for ASCII and also for 8-bit 
    12011201        characters when 'encoding' is an 8-bit encoding. 
    12021202 
     1203         
     1204                                                *'breakindent'* *'bri'* 
     1205'breakindent' 'bri'     boolean (default off) 
     1206                        local to window 
     1207                        {not in Vi} 
     1208                        {not available when compiled without the |+linebreak| 
     1209                        feature} 
     1210        Every wrapped line will continue visually indented (same amount of 
     1211        space as the beginning of that line), thus preserving horizontal blocks 
     1212        of text. 
     1213 
     1214                                                *'breakindentmin'* *'brimin'* 
     1215'breakindentmin' 'brimin' number (default 20) 
     1216                        local to window 
     1217                        {not in Vi} 
     1218                        {not available when compiled without the |+linebreak| 
     1219                        feature} 
     1220        Minimum text width that will be kept after applying 'breakindent', 
     1221        even if the resulting text should normally be narrower. This prevents 
     1222        text indented almost to the right window border oocupying lot of 
     1223        vertical space when broken. 
     1224 
     1225                                                *'breakindentshift'* *'brishift'* 
     1226'breakindentshift' 'brishift' number (default 20) 
     1227                        local to window 
     1228                        {not in Vi} 
     1229                        {not available when compiled without the |+linebreak| 
     1230                        feature} 
     1231        After applying 'breakindent', wrapped line beginning will be shift by 
     1232        given number of characters. It permits dynamic French paragraph 
     1233        indentation (negative) or emphasizing the line continuation 
     1234        (positive). 
     1235 
    12031236                                                *'browsedir'* *'bsdir'* 
    12041237'browsedir' 'bsdir'     string  (default: "last") 
    12051238                        global 
     
    45724605                        {not in Vi} 
    45734606                        {not available when compiled without the |+linebreak| 
    45744607                        feature} 
    4575         If on Vim will wrap long lines at a character in 'breakat' rather 
     4608        If on, Vim will wrap long lines at a character in 'breakat' rather 
    45764609        than at the last character that fits on the screen.  Unlike 
    45774610        'wrapmargin' and 'textwidth', this does not insert <EOL>s in the file, 
    4578         it only affects the way the file is displayed, not its contents.  The 
    4579         value of 'showbreak' is used to put in front of wrapped lines. 
    4580         This option is not used when the 'wrap' option is off or 'list' is on. 
     4611        it only affects the way the file is displayed, not its contents. 
     4612        If 'breakindent' is set, line is visually indented. Then, the value 
     4613        of 'showbreak' is used to put in front of wrapped lines. This option 
     4614        is not used when the 'wrap' option is off or 'list' is on. 
    45814615        Note that <Tab> characters after an <EOL> are mostly not displayed 
    45824616        with the right amount of white space. 
    45834617 
  • runtime/doc/tags

    diff -urN '--exclude=*.orig' '--exclude=*.rej' vim74.orig/runtime/doc/tags vim74/runtime/doc/tags
    old new  
    9090'bl'    options.txt     /*'bl'* 
    9191'bomb'  options.txt     /*'bomb'* 
    9292'breakat'       options.txt     /*'breakat'* 
     93'breakindent'   options.txt     /*'breakindent'* 
     94'breakindentmin'        options.txt     /*'breakindentmin'* 
     95'breakindentshift'      options.txt     /*'breakindentshift'* 
     96'bri'   options.txt     /*'bri'* 
     97'brimin'        options.txt     /*'brimin'* 
     98'brishift'      options.txt     /*'brishift'* 
    9399'brk'   options.txt     /*'brk'* 
    94100'browsedir'     options.txt     /*'browsedir'* 
    95101'bs'    options.txt     /*'bs'* 
  • runtime/optwin.vim

    diff -urN '--exclude=*.orig' '--exclude=*.rej' vim74.orig/runtime/optwin.vim vim74/runtime/optwin.vim
    old new  
    324324call append("$", "linebreak\twrap long lines at a character in 'breakat'") 
    325325call append("$", "\t(local to window)") 
    326326call <SID>BinOptionL("lbr") 
     327call append("$", "breakindent\tpreserve indentation in wrapped text") 
     328call append("$", "\t(local to window)") 
     329call <SID>BinOptionL("bri") 
     330call append("$", "breakindentmin\tminimum text width after indent in 'breakindent'") 
     331call append("$", "\t(local to window)") 
     332call <SID>OptionL("brimin") 
     333call append("$", "breakindentshift\tshift beginning of 'breakindent'ed line by this number of characters (negative left)") 
     334call append("$", "\t(local to window)") 
     335call <SID>OptionL("brishift") 
    327336call append("$", "breakat\twhich characters might cause a line break") 
    328337call <SID>OptionG("brk", &brk) 
    329338call append("$", "showbreak\tstring to put before wrapped screen lines") 
  • src/charset.c

    diff -urN '--exclude=*.orig' '--exclude=*.rej' vim74.orig/src/charset.c vim74/src/charset.c
    old new  
    852852 * taking into account the size of a tab. 
    853853 */ 
    854854    int 
    855 linetabsize(s) 
     855linetabsize(s, lnum) 
    856856    char_u      *s; 
     857    linenr_T    lnum; 
    857858{ 
    858     return linetabsize_col(0, s); 
     859    return linetabsize_col(0, s, lnum); 
    859860} 
    860861 
    861862/* 
    862863 * Like linetabsize(), but starting at column "startcol". 
    863864 */ 
    864865    int 
    865 linetabsize_col(startcol, s) 
     866linetabsize_col(startcol, s, lnum) 
    866867    int         startcol; 
    867868    char_u      *s; 
     869    linenr_T    lnum; 
    868870{ 
    869871    colnr_T     col = startcol; 
    870872 
    871873    while (*s != NUL) 
    872         col += lbr_chartabsize_adv(&s, col); 
     874        col += lbr_chartabsize_adv(&s, col, lnum); 
    873875    return (int)col; 
    874876} 
    875877 
     
    877879 * Like linetabsize(), but for a given window instead of the current one. 
    878880 */ 
    879881    int 
    880 win_linetabsize(wp, p, len) 
     882win_linetabsize(wp, p, len, lnum) 
    881883    win_T       *wp; 
    882884    char_u      *p; 
    883885    colnr_T     len; 
     886    linenr_T    lnum; 
    884887{ 
    885888    colnr_T     col = 0; 
    886889    char_u      *s; 
    887890 
    888891    for (s = p; *s != NUL && (len == MAXCOL || s < p + len); mb_ptr_adv(s)) 
    889         col += win_lbr_chartabsize(wp, s, col, NULL); 
     892        col += win_lbr_chartabsize(wp, s, col, NULL, lnum); 
    890893    return (int)col; 
    891894} 
    892895 
     
    10211024 * like chartabsize(), but also check for line breaks on the screen 
    10221025 */ 
    10231026    int 
    1024 lbr_chartabsize(s, col) 
     1027lbr_chartabsize(s, col, lnum) 
    10251028    unsigned char       *s; 
    10261029    colnr_T             col; 
     1030    linenr_T            lnum; 
    10271031{ 
    10281032#ifdef FEAT_LINEBREAK 
    1029     if (!curwin->w_p_lbr && *p_sbr == NUL) 
     1033    if (!curwin->w_p_lbr && *p_sbr == NUL && !curwin->w_p_bri) 
    10301034    { 
    10311035#endif 
    10321036#ifdef FEAT_MBYTE 
     
    10361040        RET_WIN_BUF_CHARTABSIZE(curwin, curbuf, s, col) 
    10371041#ifdef FEAT_LINEBREAK 
    10381042    } 
    1039     return win_lbr_chartabsize(curwin, s, col, NULL); 
     1043    return win_lbr_chartabsize(curwin, s, col, NULL, lnum); 
    10401044#endif 
    10411045} 
    10421046 
     
    10441048 * Call lbr_chartabsize() and advance the pointer. 
    10451049 */ 
    10461050    int 
    1047 lbr_chartabsize_adv(s, col) 
     1051lbr_chartabsize_adv(s, col, lnum) 
    10481052    char_u      **s; 
    10491053    colnr_T     col; 
     1054    linenr_T    lnum; 
    10501055{ 
    10511056    int         retval; 
    10521057 
    1053     retval = lbr_chartabsize(*s, col); 
     1058    retval = lbr_chartabsize(*s, col, lnum); 
    10541059    mb_ptr_adv(*s); 
    10551060    return retval; 
    10561061} 
     
    10611066 * If "headp" not NULL, set *headp to the size of what we for 'showbreak' 
    10621067 * string at start of line.  Warning: *headp is only set if it's a non-zero 
    10631068 * value, init to 0 before calling. 
     1069 * 
     1070 * linenr argument needed if in visual highlighting and breakindent=on, then 
     1071 * the line calculated is not current; if 0, normal functionality is preserved. 
    10641072 */ 
    10651073    int 
    1066 win_lbr_chartabsize(wp, s, col, headp) 
     1074win_lbr_chartabsize(wp, s, col, headp, lnum) 
    10671075    win_T       *wp; 
    10681076    char_u      *s; 
    10691077    colnr_T     col; 
    10701078    int         *headp UNUSED; 
     1079    linenr_T    lnum; 
    10711080{ 
    10721081#ifdef FEAT_LINEBREAK 
    10731082    int         c; 
     
    10861095    int         n; 
    10871096 
    10881097    /* 
    1089      * No 'linebreak' and 'showbreak': return quickly. 
     1098     * No 'linebreak' and 'showbreak' and 'breakindent': return quickly. 
    10901099     */ 
    1091     if (!wp->w_p_lbr && *p_sbr == NUL) 
     1100    if (!wp->w_p_lbr && !wp->w_p_bri && *p_sbr == NUL) 
    10921101#endif 
    10931102    { 
    10941103#ifdef FEAT_MBYTE 
     
    11631172# endif 
    11641173 
    11651174    /* 
    1166      * May have to add something for 'showbreak' string at start of line 
     1175     * May have to add something for 'breakindent' and/or 'showbreak' 
     1176     * string at start of line. 
    11671177     * Set *headp to the size of what we add. 
    11681178     */ 
    11691179    added = 0; 
    1170     if (*p_sbr != NUL && wp->w_p_wrap && col != 0) 
     1180    if ((*p_sbr != NUL || wp->w_p_bri) && wp->w_p_wrap && col != 0) 
    11711181    { 
    11721182        numberextra = win_col_off(wp); 
    11731183        col += numberextra + mb_added; 
     
    11801190        } 
    11811191        if (col == 0 || col + size > (colnr_T)W_WIDTH(wp)) 
    11821192        { 
    1183             added = vim_strsize(p_sbr); 
     1193            added = 0; 
     1194            if (*p_sbr != NUL) 
     1195                added += vim_strsize(p_sbr); 
     1196            if (wp->w_p_bri) 
     1197                added += get_breakindent_win(wp,lnum); 
     1198 
    11841199            if (tab_corr) 
    11851200                size += (added / wp->w_buffer->b_p_ts) * wp->w_buffer->b_p_ts; 
    11861201            else 
     
    12881303 
    12891304    /* 
    12901305     * This function is used very often, do some speed optimizations. 
    1291      * When 'list', 'linebreak' and 'showbreak' are not set use a simple loop. 
     1306     * When 'list', 'linebreak', 'showbreak' and 'breakindent' are not set 
     1307     * use a simple loop. 
    12921308     * Also use this when 'list' is set but tabs take their normal size. 
    12931309     */ 
    12941310    if ((!wp->w_p_list || lcs_tab1 != NUL) 
    12951311#ifdef FEAT_LINEBREAK 
    1296             && !wp->w_p_lbr && *p_sbr == NUL 
     1312            && !wp->w_p_lbr && *p_sbr == NUL && !wp->w_p_bri 
    12971313#endif 
    12981314       ) 
    12991315    { 
     
    13551371        { 
    13561372            /* A tab gets expanded, depending on the current column */ 
    13571373            head = 0; 
    1358             incr = win_lbr_chartabsize(wp, ptr, vcol, &head); 
     1374            incr = win_lbr_chartabsize(wp, ptr, vcol, &head, pos->lnum); 
    13591375            /* make sure we don't go past the end of the line */ 
    13601376            if (*ptr == NUL) 
    13611377            { 
  • src/edit.c

    diff -urN '--exclude=*.orig' '--exclude=*.rej' vim74.orig/src/edit.c vim74/src/edit.c
    old new  
    428428        if (startln) 
    429429            Insstart.col = 0; 
    430430    } 
    431     Insstart_textlen = (colnr_T)linetabsize(ml_get_curline()); 
     431    Insstart_textlen = (colnr_T)linetabsize(ml_get_curline(), Insstart.lnum); 
    432432    Insstart_blank_vcol = MAXCOL; 
    433433    if (!did_ai) 
    434434        ai_col = 0; 
     
    19511951            else 
    19521952#endif 
    19531953                ++new_cursor_col; 
    1954             vcol += lbr_chartabsize(ptr + new_cursor_col, (colnr_T)vcol); 
     1954            vcol += lbr_chartabsize(ptr + new_cursor_col, (colnr_T)vcol, curwin->w_cursor.lnum); 
    19551955        } 
    19561956        vcol = last_vcol; 
    19571957 
     
    67436743            ins_need_undo = FALSE; 
    67446744        } 
    67456745        Insstart = curwin->w_cursor;    /* new insertion starts here */ 
    6746         Insstart_textlen = (colnr_T)linetabsize(ml_get_curline()); 
     6746        Insstart_textlen = (colnr_T)linetabsize(ml_get_curline(), curwin->w_cursor.lnum); 
    67476747        ai_col = 0; 
    67486748#ifdef FEAT_VREPLACE 
    67496749        if (State & VREPLACE_FLAG) 
     
    70987098        for (;;) 
    70997099        { 
    71007100            coladvance(v - width); 
    7101             /* getviscol() is slow, skip it when 'showbreak' is empty and 
    7102              * there are no multi-byte characters */ 
    7103             if ((*p_sbr == NUL 
     7101            /* getviscol() is slow, skip it when 'showbreak' is empty, 
     7102             * 'breakindent' is not set and there are no multi-byte 
     7103             * characters */ 
     7104            if ((*p_sbr == NUL && !curwin->w_p_bri 
    71047105#  ifdef FEAT_MBYTE 
    71057106                        && !has_mbyte 
    71067107#  endif 
     
    97409741        getvcol(curwin, &fpos, &vcol, NULL, NULL); 
    97419742        getvcol(curwin, cursor, &want_vcol, NULL, NULL); 
    97429743 
    9743         /* Use as many TABs as possible.  Beware of 'showbreak' and 
     9744        /* Use as many TABs as possible.  Beware of 'breakindent', 'showbreak' and 
    97449745         * 'linebreak' adding extra virtual columns. */ 
    97459746        while (vim_iswhite(*ptr)) 
    97469747        { 
    9747             i = lbr_chartabsize((char_u *)"\t", vcol); 
     9748            i = lbr_chartabsize((char_u *)"\t", vcol, cursor->lnum); 
    97489749            if (vcol + i > want_vcol) 
    97499750                break; 
    97509751            if (*ptr != TAB) 
     
    97709771            /* Skip over the spaces we need. */ 
    97719772            while (vcol < want_vcol && *ptr == ' ') 
    97729773            { 
    9773                 vcol += lbr_chartabsize(ptr, vcol); 
     9774                vcol += lbr_chartabsize(ptr, vcol, cursor->lnum); 
    97749775                ++ptr; 
    97759776                ++repl_off; 
    97769777            } 
     
    1002610027    while ((colnr_T)temp < curwin->w_virtcol && *ptr != NUL) 
    1002710028    { 
    1002810029        prev_ptr = ptr; 
    10029         temp += lbr_chartabsize_adv(&ptr, (colnr_T)temp); 
     10030        temp += lbr_chartabsize_adv(&ptr, (colnr_T)temp, lnum); 
    1003010031    } 
    1003110032    if ((colnr_T)temp > curwin->w_virtcol) 
    1003210033        ptr = prev_ptr; 
  • src/eval.c

    diff -urN '--exclude=*.orig' '--exclude=*.rej' vim74.orig/src/eval.c vim74/src/eval.c
    old new  
    1758217582 
    1758317583    if (argvars[1].v_type != VAR_UNKNOWN) 
    1758417584        col = get_tv_number(&argvars[1]); 
    17585  
    17586     rettv->vval.v_number = (varnumber_T)(linetabsize_col(col, s) - col); 
     17585    /* 
     17586     * FIXME: passing 0 as 3rd argument to linetabsize_col, instead of real line number; 
     17587     * (can we get it from here somehow?); might give incorrect result with breakindent! 
     17588     */ 
     17589    rettv->vval.v_number = (varnumber_T)(linetabsize_col(col, s, 0) - col);  
    1758717590} 
    1758817591 
    1758917592/* 
  • src/ex_cmds.c

    diff -urN '--exclude=*.orig' '--exclude=*.rej' vim74.orig/src/ex_cmds.c vim74/src/ex_cmds.c
    old new  
    261261        ; 
    262262    save = *last; 
    263263    *last = NUL; 
    264     len = linetabsize(line);            /* get line length */ 
     264    len = linetabsize(line, curwin->w_cursor.lnum); /* get line length */ 
    265265    if (has_tab != NULL)                /* check for embedded TAB */ 
    266266        *has_tab = (vim_strrchr(first, TAB) != NULL); 
    267267    *last = save; 
  • src/getchar.c

    diff -urN '--exclude=*.orig' '--exclude=*.rej' vim74.orig/src/getchar.c vim74/src/getchar.c
    old new  
    26332633                                    if (!vim_iswhite(ptr[col])) 
    26342634                                        curwin->w_wcol = vcol; 
    26352635                                    vcol += lbr_chartabsize(ptr + col, 
    2636                                                                (colnr_T)vcol); 
     2636                                                               (colnr_T)vcol, curwin->w_cursor.lnum); 
    26372637#ifdef FEAT_MBYTE 
    26382638                                    if (has_mbyte) 
    26392639                                        col += (*mb_ptr2len)(ptr + col); 
  • src/gui_beval.c

    diff -urN '--exclude=*.orig' '--exclude=*.rej' vim74.orig/src/gui_beval.c vim74/src/gui_beval.c
    old new  
    335335        { 
    336336            /* Not past end of the file. */ 
    337337            lbuf = ml_get_buf(wp->w_buffer, lnum, FALSE); 
    338             if (col <= win_linetabsize(wp, lbuf, (colnr_T)MAXCOL)) 
     338            if (col <= win_linetabsize(wp, lbuf, (colnr_T)MAXCOL, lnum)) 
    339339            { 
    340340                /* Not past end of line. */ 
    341341                if (getword) 
  • src/misc1.c

    diff -urN '--exclude=*.orig' '--exclude=*.rej' vim74.orig/src/misc1.c vim74/src/misc1.c
    old new  
    468468    return (int)col; 
    469469} 
    470470 
     471#ifdef FEAT_LINEBREAK 
     472/*  
     473 * Return appropriate space number for breakindent, taking influencing  
     474 * parameters into account. Window must be specified, since it is not 
     475 * necessarily always the current one. If lnum==0, current line is calculated, 
     476 * specified line otherwise. 
     477 */ 
     478   int 
     479get_breakindent_win (wp,lnum) 
     480    win_T*      wp; 
     481    linenr_T    lnum; 
     482{ 
     483    int bri; 
     484    /* window width minus barren space, i.e. what rests for text */ 
     485    const int eff_wwidth = W_WIDTH(wp) 
     486        - (wp->w_p_nu && !vim_strchr(p_cpo,CPO_NUMCOL)?number_width(wp):0); 
     487        /* - (*p_sbr == NUL ? 0 : vim_strsize(p_sbr)); */ 
     488 
     489    bri = get_indent_buf(wp->w_buffer,lnum?lnum:wp->w_cursor.lnum) + wp->w_p_brishift; 
     490 
     491    /* if numbering and 'c' in 'cpoptions', cancel it out effectively */ 
     492    /* (this could be replaced by an equivalent call to win_col_off2()) */ 
     493    if (curwin->w_p_nu && vim_strchr(p_cpo, CPO_NUMCOL)) 
     494        bri += number_width(wp); 
     495     
     496    /* never indent past left window margin */ 
     497    if (bri < 0) 
     498        bri = 0; 
     499    /* always leave at least bri_min characters on the left, 
     500     * if text width is sufficient */ 
     501    else if (bri > eff_wwidth - wp->w_p_brimin) 
     502        bri = eff_wwidth - wp->w_p_brimin < 0 ? 0 : eff_wwidth - wp->w_p_brimin; 
     503 
     504    return bri; 
     505} 
     506#endif 
     507 
     508 
    471509#if defined(FEAT_CINDENT) || defined(FEAT_SMARTINDENT) 
    472510 
    473511static int cin_is_cinword __ARGS((char_u *line)); 
     
    19501988    s = ml_get_buf(wp->w_buffer, lnum, FALSE); 
    19511989    if (*s == NUL)              /* empty line */ 
    19521990        return 1; 
    1953     col = win_linetabsize(wp, s, (colnr_T)MAXCOL); 
     1991    col = win_linetabsize(wp, s, (colnr_T)MAXCOL, lnum); 
    19541992 
    19551993    /* 
    19561994     * If list mode is on, then the '$' at the end of the line may take up one 
     
    20062044    col = 0; 
    20072045    while (*s != NUL && --column >= 0) 
    20082046    { 
    2009         col += win_lbr_chartabsize(wp, s, (colnr_T)col, NULL); 
     2047        col += win_lbr_chartabsize(wp, s, (colnr_T)col, NULL, lnum); 
    20102048        mb_ptr_adv(s); 
    20112049    } 
    20122050 
     
    20182056     * 'ts') -- webb. 
    20192057     */ 
    20202058    if (*s == TAB && (State & NORMAL) && (!wp->w_p_list || lcs_tab1)) 
    2021         col += win_lbr_chartabsize(wp, s, (colnr_T)col, NULL) - 1; 
     2059        col += win_lbr_chartabsize(wp, s, (colnr_T)col, NULL, lnum) - 1; 
    20222060 
    20232061    /* 
    20242062     * Add column offset for 'number', 'relativenumber', 'foldcolumn', etc. 
     
    90499087                amount = 0; 
    90509088                while (*that && col) 
    90519089                { 
    9052                     amount += lbr_chartabsize_adv(&that, (colnr_T)amount); 
     9090                    amount += lbr_chartabsize_adv(&that, (colnr_T)amount, pos->lnum); 
    90539091                    col--; 
    90549092                } 
    90559093 
     
    90729110 
    90739111                    while (vim_iswhite(*that)) 
    90749112                    { 
    9075                         amount += lbr_chartabsize(that, (colnr_T)amount); 
     9113                        amount += lbr_chartabsize(that, (colnr_T)amount, pos->lnum); 
    90769114                        ++that; 
    90779115                    } 
    90789116 
     
    91119149                                    --parencount; 
    91129150                                if (*that == '\\' && *(that+1) != NUL) 
    91139151                                    amount += lbr_chartabsize_adv(&that, 
    9114                                                              (colnr_T)amount); 
     9152                                                             (colnr_T)amount, pos->lnum); 
    91159153                                amount += lbr_chartabsize_adv(&that, 
    9116                                                              (colnr_T)amount); 
     9154                                                             (colnr_T)amount, pos->lnum); 
    91179155                            } 
    91189156                        } 
    91199157                        while (vim_iswhite(*that)) 
    91209158                        { 
    9121                             amount += lbr_chartabsize(that, (colnr_T)amount); 
     9159                            amount += lbr_chartabsize(that, (colnr_T)amount, pos->lnum); 
    91229160                            that++; 
    91239161                        } 
    91249162                        if (!*that || *that == ';') 
  • src/misc2.c

    diff -urN '--exclude=*.orig' '--exclude=*.rej' vim74.orig/src/misc2.c vim74/src/misc2.c
    old new  
    166166#ifdef FEAT_VIRTUALEDIT 
    167167            if ((addspaces || finetune) && !VIsual_active) 
    168168            { 
    169                 curwin->w_curswant = linetabsize(line) + one_more; 
     169                curwin->w_curswant = linetabsize(line, pos->lnum) + one_more; 
    170170                if (curwin->w_curswant > 0) 
    171171                    --curwin->w_curswant; 
    172172            } 
     
    184184# endif 
    185185                && wcol >= (colnr_T)width) 
    186186        { 
    187             csize = linetabsize(line); 
     187            csize = linetabsize(line, pos->lnum); 
    188188            if (csize > 0) 
    189189                csize--; 
    190190 
     
    205205        { 
    206206            /* Count a tab for what it's worth (if list mode not on) */ 
    207207#ifdef FEAT_LINEBREAK 
    208             csize = win_lbr_chartabsize(curwin, ptr, col, &head); 
     208            csize = win_lbr_chartabsize(curwin, ptr, col, &head, pos->lnum); 
    209209            mb_ptr_adv(ptr); 
    210210#else 
    211             csize = lbr_chartabsize_adv(&ptr, col); 
     211            csize = lbr_chartabsize_adv(&ptr, col, pos->lnum); 
    212212#endif 
    213213            col += csize; 
    214214        } 
  • src/normal.c

    diff -urN '--exclude=*.orig' '--exclude=*.rej' vim74.orig/src/normal.c vim74/src/normal.c
    old new  
    45354535    int         dir; 
    45364536    long        dist; 
    45374537{ 
    4538     int         linelen = linetabsize(ml_get_curline()); 
     4538    int         linelen = linetabsize(ml_get_curline(), curwin->w_cursor.lnum); 
    45394539    int         retval = OK; 
    45404540    int         atend = FALSE; 
    45414541    int         n; 
     
    46084608                    (void)hasFolding(curwin->w_cursor.lnum, 
    46094609                                                &curwin->w_cursor.lnum, NULL); 
    46104610#endif 
    4611                 linelen = linetabsize(ml_get_curline()); 
     4611                linelen = linetabsize(ml_get_curline(), curwin->w_cursor.lnum); 
    46124612                if (linelen > width1) 
    46134613                    curwin->w_curswant += (((linelen - width1 - 1) / width2) 
    46144614                                                                + 1) * width2; 
     
    46384638                } 
    46394639                curwin->w_cursor.lnum++; 
    46404640                curwin->w_curswant %= width2; 
    4641                 linelen = linetabsize(ml_get_curline()); 
     4641                linelen = linetabsize(ml_get_curline(), curwin->w_cursor.lnum); 
    46424642            } 
    46434643        } 
    46444644      } 
  • src/ops.c

    diff -urN '--exclude=*.orig' '--exclude=*.rej' vim74.orig/src/ops.c vim74/src/ops.c
    old new  
    435435        } 
    436436        for ( ; vim_iswhite(*bd.textstart); ) 
    437437        { 
    438             incr = lbr_chartabsize_adv(&bd.textstart, (colnr_T)(bd.start_vcol)); 
     438            incr = lbr_chartabsize_adv(&bd.textstart, (colnr_T)(bd.start_vcol), curwin->w_cursor.lnum); 
    439439            total += incr; 
    440440            bd.start_vcol += incr; 
    441441        } 
     
    495495 
    496496        while (vim_iswhite(*non_white)) 
    497497        { 
    498             incr = lbr_chartabsize_adv(&non_white, non_white_col); 
     498            incr = lbr_chartabsize_adv(&non_white, non_white_col, curwin->w_cursor.lnum); 
    499499            non_white_col += incr; 
    500500        } 
    501501 
     
    520520            verbatim_copy_width -= bd.start_char_vcols; 
    521521        while (verbatim_copy_width < destination_col) 
    522522        { 
    523             incr = lbr_chartabsize(verbatim_copy_end, verbatim_copy_width); 
     523            incr = lbr_chartabsize(verbatim_copy_end, verbatim_copy_width, curwin->w_cursor.lnum); 
    524524            if (verbatim_copy_width + incr > destination_col) 
    525525                break; 
    526526            verbatim_copy_width += incr; 
     
    36233623            for (ptr = oldp; vcol < col && *ptr; ) 
    36243624            { 
    36253625                /* Count a tab for what it's worth (if list mode not on) */ 
    3626                 incr = lbr_chartabsize_adv(&ptr, (colnr_T)vcol); 
     3626                incr = lbr_chartabsize_adv(&ptr, (colnr_T)vcol, lnum); 
    36273627                vcol += incr; 
    36283628            } 
    36293629            bd.textcol = (colnr_T)(ptr - oldp); 
     
    36573657            /* calculate number of spaces required to fill right side of block*/ 
    36583658            spaces = y_width + 1; 
    36593659            for (j = 0; j < yanklen; j++) 
    3660                 spaces -= lbr_chartabsize(&y_array[i][j], 0); 
     3660                spaces -= lbr_chartabsize(&y_array[i][j], 0, lnum); 
    36613661            if (spaces < 0) 
    36623662                spaces = 0; 
    36633663 
     
    51745174    while (bdp->start_vcol < oap->start_vcol && *pstart) 
    51755175    { 
    51765176        /* Count a tab for what it's worth (if list mode not on) */ 
    5177         incr = lbr_chartabsize(pstart, (colnr_T)bdp->start_vcol); 
     5177        incr = lbr_chartabsize(pstart, (colnr_T)bdp->start_vcol, lnum); 
    51785178        bdp->start_vcol += incr; 
    51795179#ifdef FEAT_VISUALEXTRA 
    51805180        if (vim_iswhite(*pstart)) 
     
    52435243            { 
    52445244                /* Count a tab for what it's worth (if list mode not on) */ 
    52455245                prev_pend = pend; 
    5246                 incr = lbr_chartabsize_adv(&pend, (colnr_T)bdp->end_vcol); 
     5246                incr = lbr_chartabsize_adv(&pend, (colnr_T)bdp->end_vcol, lnum); 
    52475247                bdp->end_vcol += incr; 
    52485248            } 
    52495249            if (bdp->end_vcol <= oap->end_vcol 
     
    67566756            validate_virtcol(); 
    67576757            col_print(buf1, sizeof(buf1), (int)curwin->w_cursor.col + 1, 
    67586758                    (int)curwin->w_virtcol + 1); 
    6759             col_print(buf2, sizeof(buf2), (int)STRLEN(p), linetabsize(p)); 
     6759            col_print(buf2, sizeof(buf2), (int)STRLEN(p), linetabsize(p, curwin->w_cursor.lnum)); 
    67606760 
    67616761            if (char_count_cursor == byte_count_cursor 
    67626762                    && char_count == byte_count) 
  • src/option.c

    diff -urN '--exclude=*.orig' '--exclude=*.rej' vim74.orig/src/option.c vim74/src/option.c
    old new  
    187187#ifdef FEAT_ARABIC 
    188188# define PV_ARAB        OPT_WIN(WV_ARAB) 
    189189#endif 
     190#ifdef FEAT_LINEBREAK 
     191# define PV_BRI         OPT_WIN(WV_BRI) 
     192# define PV_BRIMIN      OPT_WIN(WV_BRIMIN) 
     193# define PV_BRISHIFT    OPT_WIN(WV_BRISHIFT) 
     194#endif 
    190195#ifdef FEAT_DIFF 
    191196# define PV_DIFF        OPT_WIN(WV_DIFF) 
    192197#endif 
     
    646651                            {(char_u *)0L, (char_u *)0L} 
    647652#endif 
    648653                            SCRIPTID_INIT}, 
     654    {"breakindent",   "bri",  P_BOOL|P_VI_DEF|P_VIM|P_RWIN, 
     655#ifdef FEAT_LINEBREAK 
     656                            (char_u *)VAR_WIN, PV_BRI, 
     657                            {(char_u *)FALSE, (char_u *)0L} 
     658#else 
     659                            (char_u *)NULL, PV_NONE, 
     660                            {(char_u *)0L, (char_u *)0L} 
     661#endif 
     662                            SCRIPTID_INIT}, 
     663    {"breakindentmin", "brimin", P_NUM|P_VI_DEF|P_VIM|P_RWIN, 
     664#ifdef FEAT_LINEBREAK 
     665                            (char_u *)VAR_WIN, PV_BRIMIN, 
     666                            {(char_u *)20L, (char_u *)20L} 
     667#else 
     668                            (char_u *)NULL, PV_NONE, 
     669                            {(char_u *)0L, (char_u *)0L} 
     670#endif 
     671                            SCRIPTID_INIT}, 
     672    {"breakindentshift", "brishift", P_NUM|P_VI_DEF|P_VIM|P_RWIN, 
     673#ifdef FEAT_LINEBREAK 
     674                            (char_u *)VAR_WIN, PV_BRISHIFT, 
     675                            {(char_u *)0L, (char_u *)0L} 
     676#else 
     677                            (char_u *)NULL, PV_NONE, 
     678                            {(char_u *)0L, (char_u *)0L} 
     679#endif 
     680                            SCRIPTID_INIT}, 
    649681    {"browsedir",   "bsdir",P_STRING|P_VI_DEF, 
    650682#ifdef FEAT_BROWSE 
    651683                            (char_u *)&p_bsdir, PV_NONE, 
     
    84848516        } 
    84858517        curwin->w_nrwidth_line_count = 0; 
    84868518    } 
     8519 
     8520    /* 'breakindentmin' must be positive */ 
     8521    else if (pp == &curwin->w_p_brimin) 
     8522    { 
     8523        if (curwin->w_p_brimin < 1) 
     8524        { 
     8525            errmsg = e_positive; 
     8526            curwin->w_p_brimin = 1; 
     8527        } 
     8528    } 
    84878529#endif 
    84888530 
    84898531    else if (pp == &curbuf->b_p_tw) 
     
    99379979        case PV_WRAP:   return (char_u *)&(curwin->w_p_wrap); 
    99389980#ifdef FEAT_LINEBREAK 
    99399981        case PV_LBR:    return (char_u *)&(curwin->w_p_lbr); 
     9982        case PV_BRI:    return (char_u *)&(curwin->w_p_bri); 
     9983        case PV_BRIMIN: return (char_u *)&(curwin->w_p_brimin); 
     9984        case PV_BRISHIFT: return (char_u *)&(curwin->w_p_brishift); 
    99409985#endif 
    99419986#ifdef FEAT_SCROLLBIND 
    99429987        case PV_SCBIND: return (char_u *)&(curwin->w_p_scb); 
     
    1012610171#endif 
    1012710172#ifdef FEAT_LINEBREAK 
    1012810173    to->wo_lbr = from->wo_lbr; 
     10174    to->wo_bri = from->wo_bri; 
     10175    to->wo_brimin = from->wo_brimin; 
    1012910176#endif 
    1013010177#ifdef FEAT_SCROLLBIND 
    1013110178    to->wo_scb = from->wo_scb; 
  • src/option.h

    diff -urN '--exclude=*.orig' '--exclude=*.rej' vim74.orig/src/option.h vim74/src/option.h
    old new  
    10531053#ifdef FEAT_CURSORBIND 
    10541054    , WV_CRBIND 
    10551055#endif 
     1056#ifdef FEAT_LINEBREAK 
     1057    , WV_BRI 
     1058    , WV_BRIMIN 
     1059    , WV_BRISHIFT 
     1060#endif 
    10561061#ifdef FEAT_DIFF 
    10571062    , WV_DIFF 
    10581063#endif 
  • src/proto/charset.pro

    diff -urN '--exclude=*.orig' '--exclude=*.rej' vim74.orig/src/proto/charset.pro vim74/src/proto/charset.pro
    old new  
    1414int vim_strsize __ARGS((char_u *s)); 
    1515int vim_strnsize __ARGS((char_u *s, int len)); 
    1616int chartabsize __ARGS((char_u *p, colnr_T col)); 
    17 int linetabsize __ARGS((char_u *s)); 
    18 int linetabsize_col __ARGS((int startcol, char_u *s)); 
    19 int win_linetabsize __ARGS((win_T *wp, char_u *p, colnr_T len)); 
     17int linetabsize __ARGS((char_u *s, linenr_T lnum)); 
     18int linetabsize_col __ARGS((int startcol, char_u *s, linenr_T lnum)); 
     19int win_linetabsize __ARGS((win_T *wp, char_u *p, colnr_T len, linenr_T lnum)); 
    2020int vim_isIDc __ARGS((int c)); 
    2121int vim_iswordc __ARGS((int c)); 
    2222int vim_iswordc_buf __ARGS((int c, buf_T *buf)); 
     
    2626int vim_isfilec_or_wc __ARGS((int c)); 
    2727int vim_isprintc __ARGS((int c)); 
    2828int vim_isprintc_strict __ARGS((int c)); 
    29 int lbr_chartabsize __ARGS((unsigned char *s, colnr_T col)); 
    30 int lbr_chartabsize_adv __ARGS((char_u **s, colnr_T col)); 
    31 int win_lbr_chartabsize __ARGS((win_T *wp, char_u *s, colnr_T col, int *headp)); 
     29int lbr_chartabsize __ARGS((unsigned char *s, colnr_T col, linenr_T lnum)); 
     30int lbr_chartabsize_adv __ARGS((char_u **s, colnr_T col, linenr_T lnum)); 
     31int win_lbr_chartabsize __ARGS((win_T *wp, char_u *s, colnr_T col, int *headp, linenr_T lnum)); 
    3232int in_win_border __ARGS((win_T *wp, colnr_T vcol)); 
    3333void getvcol __ARGS((win_T *wp, pos_T *pos, colnr_T *start, colnr_T *cursor, colnr_T *end)); 
    3434colnr_T getvcol_nolist __ARGS((pos_T *posp)); 
  • src/proto/misc1.pro

    diff -urN '--exclude=*.orig' '--exclude=*.rej' vim74.orig/src/proto/misc1.pro vim74/src/proto/misc1.pro
    old new  
    55int get_indent_str __ARGS((char_u *ptr, int ts)); 
    66int set_indent __ARGS((int size, int flags)); 
    77int get_number_indent __ARGS((linenr_T lnum)); 
     8int get_breakindent_win __ARGS((win_T *wp, linenr_T lnum)); 
    89int open_line __ARGS((int dir, int flags, int second_line_indent)); 
    910int get_leader_len __ARGS((char_u *line, char_u **flags, int backward, int include_space)); 
    1011int get_last_leader_offset __ARGS((char_u *line, char_u **flags)); 
  • src/regexp.c

    diff -urN '--exclude=*.orig' '--exclude=*.rej' vim74.orig/src/regexp.c vim74/src/regexp.c
    old new  
    42524252            end = end2; 
    42534253        if (top.col == MAXCOL || bot.col == MAXCOL) 
    42544254            end = MAXCOL; 
    4255         cols = win_linetabsize(wp, regline, (colnr_T)(reginput - regline)); 
     4255        cols = win_linetabsize(wp, regline, (colnr_T)(reginput - regline), lnum); 
    42564256        if (cols < start || cols > end - (*p_sel == 'e')) 
    42574257            return FALSE; 
    42584258    } 
     
    44604460          case RE_VCOL: 
    44614461            if (!re_num_cmp((long_u)win_linetabsize( 
    44624462                            reg_win == NULL ? curwin : reg_win, 
    4463                             regline, (colnr_T)(reginput - regline)) + 1, scan)) 
     4463                            regline, (colnr_T)(reginput - regline), reglnum + reg_firstlnum ) + 1, scan)) 
    44644464                status = RA_NOMATCH; 
    44654465            break; 
    44664466 
  • src/regexp_nfa.c

    diff -urN '--exclude=*.orig' '--exclude=*.rej' vim74.orig/src/regexp_nfa.c vim74/src/regexp_nfa.c
    old new  
    60516051                result = nfa_re_num_cmp(t->state->val, t->state->c - NFA_VCOL, 
    60526052                    (long_u)win_linetabsize( 
    60536053                            reg_win == NULL ? curwin : reg_win, 
    6054                             regline, (colnr_T)(reginput - regline)) + 1); 
     6054                            regline, (colnr_T)(reginput - regline), reglnum + reg_firstlnum) + 1); 
    60556055                if (result) 
    60566056                { 
    60576057                    add_here = TRUE; 
  • src/screen.c

    diff -urN '--exclude=*.orig' '--exclude=*.rej' vim74.orig/src/screen.c vim74/src/screen.c
    old new  
    29742974# define WL_SIGN        WL_FOLD         /* column for signs */ 
    29752975#endif 
    29762976#define WL_NR           WL_SIGN + 1     /* line number */ 
     2977#ifdef FEAT_LINEBREAK 
     2978# define WL_BRI         WL_NR + 1       /* 'breakindent' */ 
     2979#else 
     2980# define WL_BRI         WL_NR 
     2981#endif 
    29772982#if defined(FEAT_LINEBREAK) || defined(FEAT_DIFF) 
    2978 # define WL_SBR         WL_NR + 1       /* 'showbreak' or 'diff' */ 
     2983# define WL_SBR         WL_BRI + 1      /* 'showbreak' or 'diff' */ 
    29792984#else 
    2980 # define WL_SBR         WL_NR 
     2985# define WL_SBR         WL_BRI 
    29812986#endif 
    29822987#define WL_LINE         WL_SBR + 1      /* text in the line */ 
    29832988    int         draw_state = WL_START;  /* what to draw next */ 
     
    33163321#endif 
    33173322        while (vcol < v && *ptr != NUL) 
    33183323        { 
    3319             c = win_lbr_chartabsize(wp, ptr, (colnr_T)vcol, NULL); 
     3324            c = win_lbr_chartabsize(wp, ptr, (colnr_T)vcol, NULL, lnum); 
    33203325            vcol += c; 
    33213326#ifdef FEAT_MBYTE 
    33223327            prev_ptr = ptr; 
     
    36983703                } 
    36993704            } 
    37003705 
     3706#ifdef FEAT_LINEBREAK  
     3707            /* draw 'breakindent': indent wrapped text accordingly */ 
     3708            if (draw_state == WL_BRI -1 && n_extra == 0){ 
     3709                draw_state = WL_BRI; 
     3710# ifdef FEAT_DIFF 
     3711                /* FIXME: handle (filler_todo > 0): or modify showbreak so that ---- lines are shorter by the amount needed? */ 
     3712# endif 
     3713                if (wp->w_p_bri && row != startrow){ /* FIXME: what is startrow? Don't we need it as well?? */ 
     3714                    p_extra = NUL; 
     3715                    c_extra = ' '; 
     3716                    n_extra = get_breakindent_win(wp,lnum); 
     3717                    char_attr = 0; /* was: hl_attr(HLF_AT); */ 
     3718                    /* FIXME: why do we need to adjust vcol if showbreak does not?? */ 
     3719                    // vcol += n_extra; 
     3720                    /* FIXME: is this relevant here? copied shamelessly from showbreak */ 
     3721                    /* Correct end of highlighted area for 'breakindent', 
     3722                     * required when 'linebreak' is also set. */ 
     3723                    if (tocol == vcol) 
     3724                        tocol += n_extra; 
     3725                } 
     3726            } 
     3727#endif 
     3728             
     3729 
    37013730#if defined(FEAT_LINEBREAK) || defined(FEAT_DIFF) 
    37023731            if (draw_state == WL_SBR - 1 && n_extra == 0) 
    37033732            { 
     
    44094438# ifdef FEAT_MBYTE 
    44104439                                has_mbyte ? mb_l : 
    44114440# endif 
    4412                                 1), (colnr_T)vcol, NULL) - 1; 
     4441                                1), (colnr_T)vcol, NULL, lnum) - 1; 
    44134442                    c_extra = ' '; 
    44144443                    if (vim_iswhite(c)) 
    44154444                    { 
  • src/structs.h

    diff -urN '--exclude=*.orig' '--exclude=*.rej' vim74.orig/src/structs.h vim74/src/structs.h
    old new  
    134134    int         wo_arab; 
    135135# define w_p_arab w_onebuf_opt.wo_arab  /* 'arabic' */ 
    136136#endif 
     137#ifdef FEAT_LINEBREAK 
     138    int         wo_bri; 
     139# define w_p_bri w_onebuf_opt.wo_bri    /* 'breakindent' */ 
     140    long        wo_brimin; 
     141# define w_p_brimin w_onebuf_opt.wo_brimin /* 'breakindentmin' */ 
     142    long        wo_brishift; 
     143# define w_p_brishift w_onebuf_opt.wo_brishift /* 'breakindentshift' */ 
     144#endif 
    137145#ifdef FEAT_DIFF 
    138146    int         wo_diff; 
    139147# define w_p_diff w_onebuf_opt.wo_diff  /* 'diff' */ 
  • src/ui.c

    diff -urN '--exclude=*.orig' '--exclude=*.rej' vim74.orig/src/ui.c vim74/src/ui.c
    old new  
    31753175    start = ptr = ml_get_buf(wp->w_buffer, lnum, FALSE); 
    31763176    while (count < vcol && *ptr != NUL) 
    31773177    { 
    3178         count += win_lbr_chartabsize(wp, ptr, count, NULL); 
     3178        count += win_lbr_chartabsize(wp, ptr, count, NULL, lnum); 
    31793179        mb_ptr_adv(ptr); 
    31803180    } 
    31813181    return (int)(ptr - start);