Blog: Better line wrapping in Vim, 7th iteration: vim-7.3.944-fc17-breakindent.patch

File vim-7.3.944-fc17-breakindent.patch, 31.8 KB (added by retracile, 4 years ago)

breakindent for Vim 7.3.944 from Fedora 17

  • runtime/doc/eval.txt

    diff -urN '--exclude=*.orig' vim73.orig/runtime/doc/eval.txt vim73/runtime/doc/eval.txt
    old new  
    63426342keymap                  Compiled with 'keymap' support. 
    63436343langmap                 Compiled with 'langmap' support. 
    63446344libcall                 Compiled with |libcall()| support. 
    6345 linebreak               Compiled with 'linebreak', 'breakat' and 'showbreak' 
    6346                         support. 
     6345linebreak               Compiled with 'linebreak', 'breakat', 'showbreak' and 
     6346                        'breakindent' support. 
    63476347lispindent              Compiled with support for lisp indenting. 
    63486348listcmds                Compiled with commands for the buffer list |:files| 
    63496349                        and the argument list |arglist|. 
  • runtime/doc/options.txt

    diff -urN '--exclude=*.orig' vim73.orig/runtime/doc/options.txt vim73/runtime/doc/options.txt
    old new  
    11771177        break if 'linebreak' is on.  Only works for ASCII and also for 8-bit 
    11781178        characters when 'encoding' is an 8-bit encoding. 
    11791179 
     1180         
     1181                                                *'breakindent'* *'bri'* 
     1182'breakindent' 'bri'     boolean (default off) 
     1183                        local to window 
     1184                        {not in Vi} 
     1185                        {not available when compiled without the |+linebreak| 
     1186                        feature} 
     1187        Every wrapped line will continue visually indented (same amount of 
     1188        space as the beginning of that line), thus preserving horizontal blocks 
     1189        of text. 
     1190 
     1191                                                *'breakindentmin'* *'brimin'* 
     1192'breakindentmin' 'brimin' number (default 20) 
     1193                        local to window 
     1194                        {not in Vi} 
     1195                        {not available when compiled without the |+linebreak| 
     1196                        feature} 
     1197        Minimum text width that will be kept after applying 'breakindent', 
     1198        even if the resulting text should normally be narrower. This prevents 
     1199        text indented almost to the right window border oocupying lot of 
     1200        vertical space when broken. 
     1201 
     1202                                                *'breakindentshift'* *'brishift'* 
     1203'breakindentshift' 'brishift' number (default 20) 
     1204                        local to window 
     1205                        {not in Vi} 
     1206                        {not available when compiled without the |+linebreak| 
     1207                        feature} 
     1208        After applying 'breakindent', wrapped line beginning will be shift by 
     1209        given number of characters. It permits dynamic French paragraph 
     1210        indentation (negative) or emphasizing the line continuation 
     1211        (positive). 
     1212 
    11801213                                                *'browsedir'* *'bsdir'* 
    11811214'browsedir' 'bsdir'     string  (default: "last") 
    11821215                        global 
     
    44724505                        {not in Vi} 
    44734506                        {not available when compiled without the |+linebreak| 
    44744507                        feature} 
    4475         If on Vim will wrap long lines at a character in 'breakat' rather 
     4508        If on, Vim will wrap long lines at a character in 'breakat' rather 
    44764509        than at the last character that fits on the screen.  Unlike 
    44774510        'wrapmargin' and 'textwidth', this does not insert <EOL>s in the file, 
    4478         it only affects the way the file is displayed, not its contents.  The 
    4479         value of 'showbreak' is used to put in front of wrapped lines. 
    4480         This option is not used when the 'wrap' option is off or 'list' is on. 
     4511        it only affects the way the file is displayed, not its contents. 
     4512        If 'breakindent' is set, line is visually indented. Then, the value 
     4513        of 'showbreak' is used to put in front of wrapped lines. This option 
     4514        is not used when the 'wrap' option is off or 'list' is on. 
    44814515        Note that <Tab> characters after an <EOL> are mostly not displayed 
    44824516        with the right amount of white space. 
    44834517 
  • runtime/doc/tags

    diff -urN '--exclude=*.orig' vim73.orig/runtime/doc/tags vim73/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' vim73.orig/runtime/optwin.vim vim73/runtime/optwin.vim
    old new  
    329329call append("$", "linebreak\twrap long lines at a character in 'breakat'") 
    330330call append("$", "\t(local to window)") 
    331331call <SID>BinOptionL("lbr") 
     332call append("$", "breakindent\tpreserve indentation in wrapped text") 
     333call append("$", "\t(local to window)") 
     334call <SID>BinOptionL("bri") 
     335call append("$", "breakindentmin\tminimum text width after indent in 'breakindent'") 
     336call append("$", "\t(local to window)") 
     337call <SID>OptionL("brimin") 
     338call append("$", "breakindentshift\tshift beginning of 'breakindent'ed line by this number of characters (negative left)") 
     339call append("$", "\t(local to window)") 
     340call <SID>OptionL("brishift") 
    332341call append("$", "breakat\twhich characters might cause a line break") 
    333342call <SID>OptionG("brk", &brk) 
    334343call append("$", "showbreak\tstring to put before wrapped screen lines") 
  • src/charset.c

    diff -urN '--exclude=*.orig' vim73.orig/src/charset.c vim73/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' vim73.orig/src/edit.c vim73/src/edit.c
    old new  
    420420        if (startln) 
    421421            Insstart.col = 0; 
    422422    } 
    423     Insstart_textlen = (colnr_T)linetabsize(ml_get_curline()); 
     423    Insstart_textlen = (colnr_T)linetabsize(ml_get_curline(), Insstart.lnum); 
    424424    Insstart_blank_vcol = MAXCOL; 
    425425    if (!did_ai) 
    426426        ai_col = 0; 
     
    19431943            else 
    19441944#endif 
    19451945                ++new_cursor_col; 
    1946             vcol += lbr_chartabsize(ptr + new_cursor_col, (colnr_T)vcol); 
     1946            vcol += lbr_chartabsize(ptr + new_cursor_col, (colnr_T)vcol, curwin->w_cursor.lnum); 
    19471947        } 
    19481948        vcol = last_vcol; 
    19491949 
     
    67346734            ins_need_undo = FALSE; 
    67356735        } 
    67366736        Insstart = curwin->w_cursor;    /* new insertion starts here */ 
    6737         Insstart_textlen = (colnr_T)linetabsize(ml_get_curline()); 
     6737        Insstart_textlen = (colnr_T)linetabsize(ml_get_curline(), curwin->w_cursor.lnum); 
    67386738        ai_col = 0; 
    67396739#ifdef FEAT_VREPLACE 
    67406740        if (State & VREPLACE_FLAG) 
     
    70897089        for (;;) 
    70907090        { 
    70917091            coladvance(v - width); 
    7092             /* getviscol() is slow, skip it when 'showbreak' is empty and 
    7093              * there are no multi-byte characters */ 
    7094             if ((*p_sbr == NUL 
     7092            /* getviscol() is slow, skip it when 'showbreak' is empty, 
     7093             * 'breakindent' is not set and there are no multi-byte 
     7094             * characters */ 
     7095            if ((*p_sbr == NUL && !curwin->w_p_bri 
    70957096#  ifdef FEAT_MBYTE 
    70967097                        && !has_mbyte 
    70977098#  endif 
     
    97269727        getvcol(curwin, &fpos, &vcol, NULL, NULL); 
    97279728        getvcol(curwin, cursor, &want_vcol, NULL, NULL); 
    97289729 
    9729         /* Use as many TABs as possible.  Beware of 'showbreak' and 
     9730        /* Use as many TABs as possible.  Beware of 'breakindent', 'showbreak' and 
    97309731         * 'linebreak' adding extra virtual columns. */ 
    97319732        while (vim_iswhite(*ptr)) 
    97329733        { 
    9733             i = lbr_chartabsize((char_u *)"\t", vcol); 
     9734            i = lbr_chartabsize((char_u *)"\t", vcol, cursor->lnum); 
    97349735            if (vcol + i > want_vcol) 
    97359736                break; 
    97369737            if (*ptr != TAB) 
     
    97569757            /* Skip over the spaces we need. */ 
    97579758            while (vcol < want_vcol && *ptr == ' ') 
    97589759            { 
    9759                 vcol += lbr_chartabsize(ptr, vcol); 
     9760                vcol += lbr_chartabsize(ptr, vcol, cursor->lnum); 
    97609761                ++ptr; 
    97619762                ++repl_off; 
    97629763            } 
     
    1001210013    while ((colnr_T)temp < curwin->w_virtcol && *ptr != NUL) 
    1001310014    { 
    1001410015        prev_ptr = ptr; 
    10015         temp += lbr_chartabsize_adv(&ptr, (colnr_T)temp); 
     10016        temp += lbr_chartabsize_adv(&ptr, (colnr_T)temp, lnum); 
    1001610017    } 
    1001710018    if ((colnr_T)temp > curwin->w_virtcol) 
    1001810019        ptr = prev_ptr; 
  • src/eval.c

    diff -urN '--exclude=*.orig' vim73.orig/src/eval.c vim73/src/eval.c
    old new  
    1747417474 
    1747517475    if (argvars[1].v_type != VAR_UNKNOWN) 
    1747617476        col = get_tv_number(&argvars[1]); 
    17477  
    17478     rettv->vval.v_number = (varnumber_T)(linetabsize_col(col, s) - col); 
     17477    /* 
     17478     * FIXME: passing 0 as 3rd argument to linetabsize_col, instead of real line number; 
     17479     * (can we get it from here somehow?); might give incorrect result with breakindent! 
     17480     */ 
     17481    rettv->vval.v_number = (varnumber_T)(linetabsize_col(col, s, 0) - col);  
    1747917482} 
    1748017483 
    1748117484/* 
  • src/ex_cmds.c

    diff -urN '--exclude=*.orig' vim73.orig/src/ex_cmds.c vim73/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' vim73.orig/src/getchar.c vim73/src/getchar.c
    old new  
    26312631                                    if (!vim_iswhite(ptr[col])) 
    26322632                                        curwin->w_wcol = vcol; 
    26332633                                    vcol += lbr_chartabsize(ptr + col, 
    2634                                                                (colnr_T)vcol); 
     2634                                                               (colnr_T)vcol, curwin->w_cursor.lnum); 
    26352635#ifdef FEAT_MBYTE 
    26362636                                    if (has_mbyte) 
    26372637                                        col += (*mb_ptr2len)(ptr + col); 
  • src/gui_beval.c

    diff -urN '--exclude=*.orig' vim73.orig/src/gui_beval.c vim73/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' vim73.orig/src/misc1.c vim73/src/misc1.c
    old new  
    465465    return (int)col; 
    466466} 
    467467 
     468#ifdef FEAT_LINEBREAK 
     469/*  
     470 * Return appropriate space number for breakindent, taking influencing  
     471 * parameters into account. Window must be specified, since it is not 
     472 * necessarily always the current one. If lnum==0, current line is calculated, 
     473 * specified line otherwise. 
     474 */ 
     475   int 
     476get_breakindent_win (wp,lnum) 
     477    win_T*      wp; 
     478    linenr_T    lnum; 
     479{ 
     480    int bri; 
     481    /* window width minus barren space, i.e. what rests for text */ 
     482    const int eff_wwidth = W_WIDTH(wp) 
     483        - (wp->w_p_nu && !vim_strchr(p_cpo,CPO_NUMCOL)?number_width(wp):0); 
     484        /* - (*p_sbr == NUL ? 0 : vim_strsize(p_sbr)); */ 
     485 
     486    bri = get_indent_buf(wp->w_buffer,lnum?lnum:wp->w_cursor.lnum) + wp->w_p_brishift; 
     487 
     488    /* if numbering and 'c' in 'cpoptions', cancel it out effectively */ 
     489    /* (this could be replaced by an equivalent call to win_col_off2()) */ 
     490    if (curwin->w_p_nu && vim_strchr(p_cpo, CPO_NUMCOL)) 
     491        bri += number_width(wp); 
     492     
     493    /* never indent past left window margin */ 
     494    if (bri < 0) 
     495        bri = 0; 
     496    /* always leave at least bri_min characters on the left, 
     497     * if text width is sufficient */ 
     498    else if (bri > eff_wwidth - wp->w_p_brimin) 
     499        bri = eff_wwidth - wp->w_p_brimin < 0 ? 0 : eff_wwidth - wp->w_p_brimin; 
     500 
     501    return bri; 
     502} 
     503#endif 
     504 
     505 
    468506#if defined(FEAT_CINDENT) || defined(FEAT_SMARTINDENT) 
    469507 
    470508static int cin_is_cinword __ARGS((char_u *line)); 
     
    19471985    s = ml_get_buf(wp->w_buffer, lnum, FALSE); 
    19481986    if (*s == NUL)              /* empty line */ 
    19491987        return 1; 
    1950     col = win_linetabsize(wp, s, (colnr_T)MAXCOL); 
     1988    col = win_linetabsize(wp, s, (colnr_T)MAXCOL, lnum); 
    19511989 
    19521990    /* 
    19531991     * If list mode is on, then the '$' at the end of the line may take up one 
     
    20032041    col = 0; 
    20042042    while (*s != NUL && --column >= 0) 
    20052043    { 
    2006         col += win_lbr_chartabsize(wp, s, (colnr_T)col, NULL); 
     2044        col += win_lbr_chartabsize(wp, s, (colnr_T)col, NULL, lnum); 
    20072045        mb_ptr_adv(s); 
    20082046    } 
    20092047 
     
    20152053     * 'ts') -- webb. 
    20162054     */ 
    20172055    if (*s == TAB && (State & NORMAL) && (!wp->w_p_list || lcs_tab1)) 
    2018         col += win_lbr_chartabsize(wp, s, (colnr_T)col, NULL) - 1; 
     2056        col += win_lbr_chartabsize(wp, s, (colnr_T)col, NULL, lnum) - 1; 
    20192057 
    20202058    /* 
    20212059     * Add column offset for 'number', 'relativenumber', 'foldcolumn', etc. 
     
    90459083                amount = 0; 
    90469084                while (*that && col) 
    90479085                { 
    9048                     amount += lbr_chartabsize_adv(&that, (colnr_T)amount); 
     9086                    amount += lbr_chartabsize_adv(&that, (colnr_T)amount, pos->lnum); 
    90499087                    col--; 
    90509088                } 
    90519089 
     
    90689106 
    90699107                    while (vim_iswhite(*that)) 
    90709108                    { 
    9071                         amount += lbr_chartabsize(that, (colnr_T)amount); 
     9109                        amount += lbr_chartabsize(that, (colnr_T)amount, pos->lnum); 
    90729110                        ++that; 
    90739111                    } 
    90749112 
     
    91079145                                    --parencount; 
    91089146                                if (*that == '\\' && *(that+1) != NUL) 
    91099147                                    amount += lbr_chartabsize_adv(&that, 
    9110                                                              (colnr_T)amount); 
     9148                                                             (colnr_T)amount, pos->lnum); 
    91119149                                amount += lbr_chartabsize_adv(&that, 
    9112                                                              (colnr_T)amount); 
     9150                                                             (colnr_T)amount, pos->lnum); 
    91139151                            } 
    91149152                        } 
    91159153                        while (vim_iswhite(*that)) 
    91169154                        { 
    9117                             amount += lbr_chartabsize(that, (colnr_T)amount); 
     9155                            amount += lbr_chartabsize(that, (colnr_T)amount, pos->lnum); 
    91189156                            that++; 
    91199157                        } 
    91209158                        if (!*that || *that == ';') 
  • src/misc2.c

    diff -urN '--exclude=*.orig' vim73.orig/src/misc2.c vim73/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' vim73.orig/src/normal.c vim73/src/normal.c
    old new  
    45344534    int         dir; 
    45354535    long        dist; 
    45364536{ 
    4537     int         linelen = linetabsize(ml_get_curline()); 
     4537    int         linelen = linetabsize(ml_get_curline(), curwin->w_cursor.lnum); 
    45384538    int         retval = OK; 
    45394539    int         atend = FALSE; 
    45404540    int         n; 
     
    46074607                    (void)hasFolding(curwin->w_cursor.lnum, 
    46084608                                                &curwin->w_cursor.lnum, NULL); 
    46094609#endif 
    4610                 linelen = linetabsize(ml_get_curline()); 
     4610                linelen = linetabsize(ml_get_curline(), curwin->w_cursor.lnum); 
    46114611                if (linelen > width1) 
    46124612                    curwin->w_curswant += (((linelen - width1 - 1) / width2) 
    46134613                                                                + 1) * width2; 
     
    46374637                } 
    46384638                curwin->w_cursor.lnum++; 
    46394639                curwin->w_curswant %= width2; 
    4640                 linelen = linetabsize(ml_get_curline()); 
     4640                linelen = linetabsize(ml_get_curline(), curwin->w_cursor.lnum); 
    46414641            } 
    46424642        } 
    46434643      } 
  • src/ops.c

    diff -urN '--exclude=*.orig' vim73.orig/src/ops.c vim73/src/ops.c
    old new  
    431431        } 
    432432        for ( ; vim_iswhite(*bd.textstart); ) 
    433433        { 
    434             incr = lbr_chartabsize_adv(&bd.textstart, (colnr_T)(bd.start_vcol)); 
     434            incr = lbr_chartabsize_adv(&bd.textstart, (colnr_T)(bd.start_vcol), curwin->w_cursor.lnum); 
    435435            total += incr; 
    436436            bd.start_vcol += incr; 
    437437        } 
     
    491491 
    492492        while (vim_iswhite(*non_white)) 
    493493        { 
    494             incr = lbr_chartabsize_adv(&non_white, non_white_col); 
     494            incr = lbr_chartabsize_adv(&non_white, non_white_col, curwin->w_cursor.lnum); 
    495495            non_white_col += incr; 
    496496        } 
    497497 
     
    516516            verbatim_copy_width -= bd.start_char_vcols; 
    517517        while (verbatim_copy_width < destination_col) 
    518518        { 
    519             incr = lbr_chartabsize(verbatim_copy_end, verbatim_copy_width); 
     519            incr = lbr_chartabsize(verbatim_copy_end, verbatim_copy_width, curwin->w_cursor.lnum); 
    520520            if (verbatim_copy_width + incr > destination_col) 
    521521                break; 
    522522            verbatim_copy_width += incr; 
     
    36123612            for (ptr = oldp; vcol < col && *ptr; ) 
    36133613            { 
    36143614                /* Count a tab for what it's worth (if list mode not on) */ 
    3615                 incr = lbr_chartabsize_adv(&ptr, (colnr_T)vcol); 
     3615                incr = lbr_chartabsize_adv(&ptr, (colnr_T)vcol, lnum); 
    36163616                vcol += incr; 
    36173617            } 
    36183618            bd.textcol = (colnr_T)(ptr - oldp); 
     
    36463646            /* calculate number of spaces required to fill right side of block*/ 
    36473647            spaces = y_width + 1; 
    36483648            for (j = 0; j < yanklen; j++) 
    3649                 spaces -= lbr_chartabsize(&y_array[i][j], 0); 
     3649                spaces -= lbr_chartabsize(&y_array[i][j], 0, lnum); 
    36503650            if (spaces < 0) 
    36513651                spaces = 0; 
    36523652 
     
    51635163    while (bdp->start_vcol < oap->start_vcol && *pstart) 
    51645164    { 
    51655165        /* Count a tab for what it's worth (if list mode not on) */ 
    5166         incr = lbr_chartabsize(pstart, (colnr_T)bdp->start_vcol); 
     5166        incr = lbr_chartabsize(pstart, (colnr_T)bdp->start_vcol, lnum); 
    51675167        bdp->start_vcol += incr; 
    51685168#ifdef FEAT_VISUALEXTRA 
    51695169        if (vim_iswhite(*pstart)) 
     
    52325232            { 
    52335233                /* Count a tab for what it's worth (if list mode not on) */ 
    52345234                prev_pend = pend; 
    5235                 incr = lbr_chartabsize_adv(&pend, (colnr_T)bdp->end_vcol); 
     5235                incr = lbr_chartabsize_adv(&pend, (colnr_T)bdp->end_vcol, lnum); 
    52365236                bdp->end_vcol += incr; 
    52375237            } 
    52385238            if (bdp->end_vcol <= oap->end_vcol 
     
    67456745            validate_virtcol(); 
    67466746            col_print(buf1, sizeof(buf1), (int)curwin->w_cursor.col + 1, 
    67476747                    (int)curwin->w_virtcol + 1); 
    6748             col_print(buf2, sizeof(buf2), (int)STRLEN(p), linetabsize(p)); 
     6748            col_print(buf2, sizeof(buf2), (int)STRLEN(p), linetabsize(p, curwin->w_cursor.lnum)); 
    67496749 
    67506750            if (char_count_cursor == byte_count_cursor 
    67516751                    && char_count == byte_count) 
  • src/option.c

    diff -urN '--exclude=*.orig' vim73.orig/src/option.c vim73/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, 
     
    84858517        } 
    84868518        curwin->w_nrwidth_line_count = 0; 
    84878519    } 
     8520 
     8521    /* 'breakindentmin' must be positive */ 
     8522    else if (pp == &curwin->w_p_brimin) 
     8523    { 
     8524        if (curwin->w_p_brimin < 1) 
     8525        { 
     8526            errmsg = e_positive; 
     8527            curwin->w_p_brimin = 1; 
     8528        } 
     8529    } 
    84888530#endif 
    84898531 
    84908532    else if (pp == &curbuf->b_p_tw) 
     
    99349976        case PV_WRAP:   return (char_u *)&(curwin->w_p_wrap); 
    99359977#ifdef FEAT_LINEBREAK 
    99369978        case PV_LBR:    return (char_u *)&(curwin->w_p_lbr); 
     9979        case PV_BRI:    return (char_u *)&(curwin->w_p_bri); 
     9980        case PV_BRIMIN: return (char_u *)&(curwin->w_p_brimin); 
     9981        case PV_BRISHIFT: return (char_u *)&(curwin->w_p_brishift); 
    99379982#endif 
    99389983#ifdef FEAT_SCROLLBIND 
    99399984        case PV_SCBIND: return (char_u *)&(curwin->w_p_scb); 
     
    1012010165    to->wo_wrap = from->wo_wrap; 
    1012110166#ifdef FEAT_LINEBREAK 
    1012210167    to->wo_lbr = from->wo_lbr; 
     10168    to->wo_bri = from->wo_bri; 
     10169    to->wo_brimin = from->wo_brimin; 
    1012310170#endif 
    1012410171#ifdef FEAT_SCROLLBIND 
    1012510172    to->wo_scb = from->wo_scb; 
  • src/option.h

    diff -urN '--exclude=*.orig' vim73.orig/src/option.h vim73/src/option.h
    old new  
    10501050#ifdef FEAT_CURSORBIND 
    10511051    , WV_CRBIND 
    10521052#endif 
     1053#ifdef FEAT_LINEBREAK 
     1054    , WV_BRI 
     1055    , WV_BRIMIN 
     1056    , WV_BRISHIFT 
     1057#endif 
    10531058#ifdef FEAT_DIFF 
    10541059    , WV_DIFF 
    10551060#endif 
  • src/proto/charset.pro

    diff -urN '--exclude=*.orig' vim73.orig/src/proto/charset.pro vim73/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' vim73.orig/src/proto/misc1.pro vim73/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' vim73.orig/src/regexp.c vim73/src/regexp.c
    old new  
    42694269                    if (top.col == MAXCOL || bot.col == MAXCOL) 
    42704270                        end = MAXCOL; 
    42714271                    cols = win_linetabsize(wp, 
    4272                                       regline, (colnr_T)(reginput - regline)); 
     4272                                      regline, (colnr_T)(reginput - regline), reglnum + reg_firstlnum); 
    42734273                    if (cols < start || cols > end - (*p_sel == 'e')) 
    42744274                        status = RA_NOMATCH; 
    42754275                } 
     
    42934293          case RE_VCOL: 
    42944294            if (!re_num_cmp((long_u)win_linetabsize( 
    42954295                            reg_win == NULL ? curwin : reg_win, 
    4296                             regline, (colnr_T)(reginput - regline)) + 1, scan)) 
     4296                            regline, (colnr_T)(reginput - regline), reglnum + reg_firstlnum ) + 1, scan)) 
    42974297                status = RA_NOMATCH; 
    42984298            break; 
    42994299 
  • src/screen.c

    diff -urN '--exclude=*.orig' vim73.orig/src/screen.c vim73/src/screen.c
    old new  
    28282828# define WL_SIGN        WL_FOLD         /* column for signs */ 
    28292829#endif 
    28302830#define WL_NR           WL_SIGN + 1     /* line number */ 
     2831#ifdef FEAT_LINEBREAK 
     2832# define WL_BRI         WL_NR + 1       /* 'breakindent' */ 
     2833#else 
     2834# define WL_BRI         WL_NR 
     2835#endif 
    28312836#if defined(FEAT_LINEBREAK) || defined(FEAT_DIFF) 
    2832 # define WL_SBR         WL_NR + 1       /* 'showbreak' or 'diff' */ 
     2837# define WL_SBR         WL_BRI + 1      /* 'showbreak' or 'diff' */ 
    28332838#else 
    2834 # define WL_SBR         WL_NR 
     2839# define WL_SBR         WL_BRI 
    28352840#endif 
    28362841#define WL_LINE         WL_SBR + 1      /* text in the line */ 
    28372842    int         draw_state = WL_START;  /* what to draw next */ 
     
    31623167#endif 
    31633168        while (vcol < v && *ptr != NUL) 
    31643169        { 
    3165             c = win_lbr_chartabsize(wp, ptr, (colnr_T)vcol, NULL); 
     3170            c = win_lbr_chartabsize(wp, ptr, (colnr_T)vcol, NULL, lnum); 
    31663171            vcol += c; 
    31673172#ifdef FEAT_MBYTE 
    31683173            prev_ptr = ptr; 
     
    35413546                } 
    35423547            } 
    35433548 
     3549#ifdef FEAT_LINEBREAK  
     3550            /* draw 'breakindent': indent wrapped text accordingly */ 
     3551            if (draw_state == WL_BRI -1 && n_extra == 0){ 
     3552                draw_state = WL_BRI; 
     3553# ifdef FEAT_DIFF 
     3554                /* FIXME: handle (filler_todo > 0): or modify showbreak so that ---- lines are shorter by the amount needed? */ 
     3555# endif 
     3556                if (wp->w_p_bri && row != startrow){ /* FIXME: what is startrow? Don't we need it as well?? */ 
     3557                    p_extra = NUL; 
     3558                    c_extra = ' '; 
     3559                    n_extra = get_breakindent_win(wp,lnum); 
     3560                    char_attr = 0; /* was: hl_attr(HLF_AT); */ 
     3561                    /* FIXME: why do we need to adjust vcol if showbreak does not?? */ 
     3562                    // vcol += n_extra; 
     3563                    /* FIXME: is this relevant here? copied shamelessly from showbreak */ 
     3564                    /* Correct end of highlighted area for 'breakindent', 
     3565                     * required when 'linebreak' is also set. */ 
     3566                    if (tocol == vcol) 
     3567                        tocol += n_extra; 
     3568                } 
     3569            } 
     3570#endif 
     3571             
     3572 
    35443573#if defined(FEAT_LINEBREAK) || defined(FEAT_DIFF) 
    35453574            if (draw_state == WL_SBR - 1 && n_extra == 0) 
    35463575            { 
     
    42474276# ifdef FEAT_MBYTE 
    42484277                                has_mbyte ? mb_l : 
    42494278# endif 
    4250                                 1), (colnr_T)vcol, NULL) - 1; 
     4279                                1), (colnr_T)vcol, NULL, lnum) - 1; 
    42514280                    c_extra = ' '; 
    42524281                    if (vim_iswhite(c)) 
    42534282                        c = ' '; 
  • src/structs.h

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

    diff -urN '--exclude=*.orig' vim73.orig/src/ui.c vim73/src/ui.c
    old new  
    31683168    start = ptr = ml_get_buf(wp->w_buffer, lnum, FALSE); 
    31693169    while (count < vcol && *ptr != NUL) 
    31703170    { 
    3171         count += win_lbr_chartabsize(wp, ptr, count, NULL); 
     3171        count += win_lbr_chartabsize(wp, ptr, count, NULL, lnum); 
    31723172        mb_ptr_adv(ptr); 
    31733173    } 
    31743174    return (int)(ptr - start);