]> granicus.if.org Git - vim/commitdiff
patch 9.0.1221: code is indented more than necessary v9.0.1221
authorYegappan Lakshmanan <yegappan@yahoo.com>
Wed, 18 Jan 2023 18:17:48 +0000 (18:17 +0000)
committerBram Moolenaar <Bram@vim.org>
Wed, 18 Jan 2023 18:17:48 +0000 (18:17 +0000)
Problem:    Code is indented more than necessary.
Solution:   Use an early return where it makes sense. (Yegappan Lakshmanan,
            closes #11833)

src/popupmenu.c
src/popupwin.c
src/profiler.c
src/quickfix.c
src/regexp.c
src/regexp_bt.c
src/regexp_nfa.c
src/register.c
src/version.c

index 512f4b3e07495b9933a7c13bdd6399003f672658..cbb45a5f1dd644254c2f778fae3f7283d9d53dd4 100644 (file)
@@ -1367,13 +1367,13 @@ failed:
     void
 ui_remove_balloon(void)
 {
-    if (balloon_array != NULL)
-    {
-       pum_undisplay();
-       while (balloon_arraysize > 0)
-           vim_free(balloon_array[--balloon_arraysize].pum_text);
-       VIM_CLEAR(balloon_array);
-    }
+    if (balloon_array == NULL)
+       return;
+
+    pum_undisplay();
+    while (balloon_arraysize > 0)
+       vim_free(balloon_array[--balloon_arraysize].pum_text);
+    VIM_CLEAR(balloon_array);
 }
 
 /*
@@ -1410,19 +1410,19 @@ ui_post_balloon(char_u *mesg, list_T *list)
     else
        balloon_arraysize = split_message(mesg, &balloon_array);
 
-    if (balloon_arraysize > 0)
-    {
-       pum_array = balloon_array;
-       pum_size = balloon_arraysize;
-       pum_compute_size();
-       pum_scrollbar = 0;
-       pum_height = balloon_arraysize;
+    if (balloon_arraysize <= 0)
+       return;
 
-       pum_position_at_mouse(BALLOON_MIN_WIDTH);
-       pum_selected = -1;
-       pum_first = 0;
-       pum_redraw();
-    }
+    pum_array = balloon_array;
+    pum_size = balloon_arraysize;
+    pum_compute_size();
+    pum_scrollbar = 0;
+    pum_height = balloon_arraysize;
+
+    pum_position_at_mouse(BALLOON_MIN_WIDTH);
+    pum_selected = -1;
+    pum_first = 0;
+    pum_redraw();
 }
 
 /*
index e487f0c225d86f310eae05e44f60b7b698d90914..ff877fd5aa253aa18619f799406c32ebd9dfb5f5 100644 (file)
@@ -98,31 +98,32 @@ set_padding_border(dict_T *dict, int *array, char *name, int max_val)
     dictitem_T *di;
 
     di = dict_find(dict, (char_u *)name, -1);
-    if (di != NULL)
+    if (di == NULL)
+       return;
+
+    if (di->di_tv.v_type != VAR_LIST)
     {
-       if (di->di_tv.v_type != VAR_LIST)
-           emsg(_(e_list_required));
-       else
-       {
-           list_T      *list = di->di_tv.vval.v_list;
-           listitem_T  *li;
-           int         i;
-           int         nr;
+       emsg(_(e_list_required));
+       return;
+    }
 
-           for (i = 0; i < 4; ++i)
-               array[i] = 1;
-           if (list != NULL)
-           {
-               CHECK_LIST_MATERIALIZE(list);
-               for (i = 0, li = list->lv_first; i < 4 && i < list->lv_len;
-                                                        ++i, li = li->li_next)
-               {
-                   nr = (int)tv_get_number(&li->li_tv);
-                   if (nr >= 0)
-                       array[i] = nr > max_val ? max_val : nr;
-               }
-           }
-       }
+    list_T     *list = di->di_tv.vval.v_list;
+    listitem_T *li;
+    int                i;
+    int                nr;
+
+    for (i = 0; i < 4; ++i)
+       array[i] = 1;
+    if (list == NULL)
+       return;
+
+    CHECK_LIST_MATERIALIZE(list);
+    for (i = 0, li = list->lv_first; i < 4 && i < list->lv_len;
+           ++i, li = li->li_next)
+    {
+       nr = (int)tv_get_number(&li->li_tv);
+       if (nr >= 0)
+           array[i] = nr > max_val ? max_val : nr;
     }
 }
 
@@ -147,11 +148,11 @@ set_moved_columns(win_T *wp, int flags)
     char_u     *ptr;
     int                len = find_ident_under_cursor(&ptr, flags | FIND_NOERROR);
 
-    if (len > 0)
-    {
-       wp->w_popup_mincol = (int)(ptr - ml_get_curline());
-       wp->w_popup_maxcol = wp->w_popup_mincol + len - 1;
-    }
+    if (len <= 0)
+       return;
+
+    wp->w_popup_mincol = (int)(ptr - ml_get_curline());
+    wp->w_popup_maxcol = wp->w_popup_mincol + len - 1;
 }
 
 /*
@@ -169,23 +170,23 @@ set_mousemoved_values(win_T *wp)
 update_popup_uses_mouse_move(void)
 {
     popup_uses_mouse_move = FALSE;
-    if (popup_visible)
-    {
-       win_T *wp;
+    if (!popup_visible)
+       return;
 
-       FOR_ALL_POPUPWINS(wp)
-           if (wp->w_popup_mouse_row != 0)
-           {
-               popup_uses_mouse_move = TRUE;
-               return;
-           }
-       FOR_ALL_POPUPWINS_IN_TAB(curtab, wp)
-           if (wp->w_popup_mouse_row != 0)
-           {
-               popup_uses_mouse_move = TRUE;
-               return;
-           }
-    }
+    win_T *wp;
+
+    FOR_ALL_POPUPWINS(wp)
+       if (wp->w_popup_mouse_row != 0)
+       {
+           popup_uses_mouse_move = TRUE;
+           return;
+       }
+    FOR_ALL_POPUPWINS_IN_TAB(curtab, wp)
+       if (wp->w_popup_mouse_row != 0)
+       {
+           popup_uses_mouse_move = TRUE;
+           return;
+       }
 }
 
 /*
@@ -201,19 +202,19 @@ set_mousemoved_columns(win_T *wp, int flags)
     colnr_T    mcol;
 
     if (find_word_under_cursor(mouse_row, mouse_col, TRUE, flags,
-                                 &textwp, &pos.lnum, &text, NULL, &col) == OK)
-    {
-       // convert text column to mouse column
-       pos.col = col;
-       pos.coladd = 0;
-       getvcol(textwp, &pos, &mcol, NULL, NULL);
-       wp->w_popup_mouse_mincol = mcol;
-
-       pos.col = col + (colnr_T)STRLEN(text) - 1;
-       getvcol(textwp, &pos, NULL, NULL, &mcol);
-       wp->w_popup_mouse_maxcol = mcol;
-       vim_free(text);
-    }
+                                 &textwp, &pos.lnum, &text, NULL, &col) != OK)
+       return;
+
+    // convert text column to mouse column
+    pos.col = col;
+    pos.coladd = 0;
+    getvcol(textwp, &pos, &mcol, NULL, NULL);
+    wp->w_popup_mouse_mincol = mcol;
+
+    pos.col = col + (colnr_T)STRLEN(text) - 1;
+    getvcol(textwp, &pos, NULL, NULL, &mcol);
+    wp->w_popup_mouse_maxcol = mcol;
+    vim_free(text);
 }
 
 /*
@@ -390,40 +391,41 @@ popup_is_in_scrollbar(win_T *wp, int row, int col)
     void
 popup_handle_scrollbar_click(win_T *wp, int row, int col)
 {
-    if (popup_is_in_scrollbar(wp, row, col))
+    if (!popup_is_in_scrollbar(wp, row, col))
+       return;
+
+    int            height = popup_height(wp);
+    int            new_topline = wp->w_topline;
+
+    if (row >= height / 2)
     {
-       int         height = popup_height(wp);
-       int         new_topline = wp->w_topline;
+       // Click in lower half, scroll down.
+       if (wp->w_topline < wp->w_buffer->b_ml.ml_line_count)
+           ++new_topline;
+    }
+    else if (wp->w_topline > 1)
+       // click on upper half, scroll up.
+       --new_topline;
+
+    if (new_topline == wp->w_topline)
+       return;
 
-       if (row >= height / 2)
+    set_topline(wp, new_topline);
+    if (wp == curwin)
+    {
+       if (wp->w_cursor.lnum < wp->w_topline)
        {
-           // Click in lower half, scroll down.
-           if (wp->w_topline < wp->w_buffer->b_ml.ml_line_count)
-               ++new_topline;
+           wp->w_cursor.lnum = wp->w_topline;
+           check_cursor();
        }
-       else if (wp->w_topline > 1)
-           // click on upper half, scroll up.
-           --new_topline;
-       if (new_topline != wp->w_topline)
+       else if (wp->w_cursor.lnum >= wp->w_botline)
        {
-           set_topline(wp, new_topline);
-           if (wp == curwin)
-           {
-               if (wp->w_cursor.lnum < wp->w_topline)
-               {
-                   wp->w_cursor.lnum = wp->w_topline;
-                   check_cursor();
-               }
-               else if (wp->w_cursor.lnum >= wp->w_botline)
-               {
-                   wp->w_cursor.lnum = wp->w_botline - 1;
-                   check_cursor();
-               }
-           }
-           popup_set_firstline(wp);
-           redraw_win_later(wp, UPD_NOT_VALID);
+           wp->w_cursor.lnum = wp->w_botline - 1;
+           check_cursor();
        }
     }
+    popup_set_firstline(wp);
+    redraw_win_later(wp, UPD_NOT_VALID);
 }
 
 #if defined(FEAT_TIMERS)
@@ -441,18 +443,18 @@ popup_add_timeout(win_T *wp, int time, int close)
     vim_snprintf((char *)cbbuf, sizeof(cbbuf),
                close ? "(_) => popup_close(%d)" : "(_) => popup_hide(%d)",
                wp->w_id);
-    if (get_lambda_tv_and_compile(&ptr, &tv, FALSE, &EVALARG_EVALUATE) == OK)
+    if (get_lambda_tv_and_compile(&ptr, &tv, FALSE, &EVALARG_EVALUATE) != OK)
+       return;
+
+    wp->w_popup_timer = create_timer(time, 0);
+    callback_T cb = get_callback(&tv);
+    if (cb.cb_name != NULL && !cb.cb_free_name)
     {
-       wp->w_popup_timer = create_timer(time, 0);
-       callback_T cb = get_callback(&tv);
-       if (cb.cb_name != NULL && !cb.cb_free_name)
-       {
-           cb.cb_name = vim_strsave(cb.cb_name);
-           cb.cb_free_name = TRUE;
-       }
-       wp->w_popup_timer->tr_callback = cb;
-       clear_tv(&tv);
+       cb.cb_name = vim_strsave(cb.cb_name);
+       cb.cb_free_name = TRUE;
     }
+    wp->w_popup_timer->tr_callback = cb;
+    clear_tv(&tv);
 }
 #endif
 
@@ -619,16 +621,16 @@ check_highlight(dict_T *dict, char *name, char_u **pval)
     char_u     *str;
 
     di = dict_find(dict, (char_u *)name, -1);
-    if (di != NULL)
+    if (di == NULL)
+       return;
+
+    if (di->di_tv.v_type != VAR_STRING)
+       semsg(_(e_invalid_value_for_argument_str), name);
+    else
     {
-       if (di->di_tv.v_type != VAR_STRING)
-           semsg(_(e_invalid_value_for_argument_str), name);
-       else
-       {
-           str = tv_get_string(&di->di_tv);
-           if (*str != NUL)
-               *pval = vim_strsave(str);
-       }
+       str = tv_get_string(&di->di_tv);
+       if (*str != NUL)
+           *pval = vim_strsave(str);
     }
 }
 
@@ -990,18 +992,17 @@ apply_general_options(win_T *wp, dict_T *dict)
     }
 
     di = dict_find(dict, (char_u *)"callback", -1);
-    if (di != NULL)
-    {
-       callback_T      callback = get_callback(&di->di_tv);
+    if (di == NULL)
+       return;
 
-       if (callback.cb_name != NULL)
-       {
-           free_callback(&wp->w_close_cb);
-           set_callback(&wp->w_close_cb, &callback);
-           if (callback.cb_free_name)
-               vim_free(callback.cb_name);
-       }
-    }
+    callback_T callback = get_callback(&di->di_tv);
+    if (callback.cb_name == NULL)
+       return;
+
+    free_callback(&wp->w_close_cb);
+    set_callback(&wp->w_close_cb, &callback);
+    if (callback.cb_free_name)
+       vim_free(callback.cb_name);
 }
 
 /*
@@ -2715,13 +2716,13 @@ popup_hide(win_T *wp)
     if (error_if_term_popup_window())
        return;
 #endif
-    if ((wp->w_popup_flags & POPF_HIDDEN) == 0)
-    {
-       wp->w_popup_flags |= POPF_HIDDEN;
-       // Do not decrement b_nwindows, we still reference the buffer.
-       redraw_all_later(UPD_NOT_VALID);
-       popup_mask_refresh = TRUE;
-    }
+    if ((wp->w_popup_flags & POPF_HIDDEN) != 0)
+       return;
+
+    wp->w_popup_flags |= POPF_HIDDEN;
+    // Do not decrement b_nwindows, we still reference the buffer.
+    redraw_all_later(UPD_NOT_VALID);
+    popup_mask_refresh = TRUE;
 }
 
 /*
@@ -2738,22 +2739,22 @@ f_popup_hide(typval_T *argvars, typval_T *rettv UNUSED)
 
     id = (int)tv_get_number(argvars);
     wp = find_popup_win(id);
-    if (wp != NULL)
-    {
-       popup_hide(wp);
-       wp->w_popup_flags |= POPF_HIDDEN_FORCE;
-    }
+    if (wp == NULL)
+       return;
+
+    popup_hide(wp);
+    wp->w_popup_flags |= POPF_HIDDEN_FORCE;
 }
 
     void
 popup_show(win_T *wp)
 {
-    if ((wp->w_popup_flags & POPF_HIDDEN) != 0)
-    {
-       wp->w_popup_flags &= ~POPF_HIDDEN;
-       redraw_all_later(UPD_NOT_VALID);
-       popup_mask_refresh = TRUE;
-    }
+    if ((wp->w_popup_flags & POPF_HIDDEN) == 0)
+       return;
+
+    wp->w_popup_flags &= ~POPF_HIDDEN;
+    redraw_all_later(UPD_NOT_VALID);
+    popup_mask_refresh = TRUE;
 }
 
 /*
@@ -2770,15 +2771,15 @@ f_popup_show(typval_T *argvars, typval_T *rettv UNUSED)
 
     id = (int)tv_get_number(argvars);
     wp = find_popup_win(id);
-    if (wp != NULL)
-    {
-       wp->w_popup_flags &= ~POPF_HIDDEN_FORCE;
-       popup_show(wp);
+    if (wp == NULL)
+       return;
+
+    wp->w_popup_flags &= ~POPF_HIDDEN_FORCE;
+    popup_show(wp);
 #ifdef FEAT_QUICKFIX
-       if (wp->w_popup_flags & POPF_INFO)
-           pum_position_info_popup(wp);
+    if (wp->w_popup_flags & POPF_INFO)
+       pum_position_info_popup(wp);
 #endif
-    }
 }
 
 /*
@@ -2797,15 +2798,15 @@ f_popup_settext(typval_T *argvars, typval_T *rettv UNUSED)
 
     id = (int)tv_get_number(&argvars[0]);
     wp = find_popup_win(id);
-    if (wp != NULL)
-    {
-       if (check_for_string_or_list_arg(argvars, 1) != FAIL)
-       {
-           popup_set_buffer_text(wp->w_buffer, argvars[1]);
-           redraw_win_later(wp, UPD_NOT_VALID);
-           popup_adjust_position(wp);
-       }
-    }
+    if (wp == NULL)
+       return;
+
+    if (check_for_string_or_list_arg(argvars, 1) == FAIL)
+       return;
+
+    popup_set_buffer_text(wp->w_buffer, argvars[1]);
+    redraw_win_later(wp, UPD_NOT_VALID);
+    popup_adjust_position(wp);
 }
 
     static void
@@ -3011,42 +3012,42 @@ f_popup_getpos(typval_T *argvars, typval_T *rettv)
     int                top_extra;
     int                left_extra;
 
-    if (rettv_dict_alloc(rettv) == OK)
-    {
-       if (in_vim9script() && check_for_number_arg(argvars, 0) == FAIL)
-           return;
+    if (rettv_dict_alloc(rettv) == FAIL)
+       return;
 
-       id = (int)tv_get_number(argvars);
-       wp = find_popup_win(id);
-       if (wp == NULL)
-           return;  // invalid {id}
-       top_extra = popup_top_extra(wp);
-       left_extra = wp->w_popup_border[3] + wp->w_popup_padding[3];
-
-       // we know how much space we need, avoid resizing halfway
-       dict = rettv->vval.v_dict;
-       hash_lock_size(&dict->dv_hashtab, 11);
-
-       dict_add_number(dict, "line", wp->w_winrow + 1);
-       dict_add_number(dict, "col", wp->w_wincol + 1);
-       dict_add_number(dict, "width", wp->w_width + left_extra
-                            + wp->w_popup_border[1] + wp->w_popup_padding[1]);
-       dict_add_number(dict, "height", wp->w_height + top_extra
-                            + wp->w_popup_border[2] + wp->w_popup_padding[2]);
-
-       dict_add_number(dict, "core_line", wp->w_winrow + 1 + top_extra);
-       dict_add_number(dict, "core_col", wp->w_wincol + 1 + left_extra);
-       dict_add_number(dict, "core_width", wp->w_width);
-       dict_add_number(dict, "core_height", wp->w_height);
-
-       dict_add_number(dict, "scrollbar", wp->w_has_scrollbar);
-       dict_add_number(dict, "firstline", wp->w_topline);
-       dict_add_number(dict, "lastline", wp->w_botline - 1);
-       dict_add_number(dict, "visible",
-                     win_valid(wp) && (wp->w_popup_flags & POPF_HIDDEN) == 0);
-
-       hash_unlock(&dict->dv_hashtab);
-    }
+    if (in_vim9script() && check_for_number_arg(argvars, 0) == FAIL)
+       return;
+
+    id = (int)tv_get_number(argvars);
+    wp = find_popup_win(id);
+    if (wp == NULL)
+       return;  // invalid {id}
+    top_extra = popup_top_extra(wp);
+    left_extra = wp->w_popup_border[3] + wp->w_popup_padding[3];
+
+    // we know how much space we need, avoid resizing halfway
+    dict = rettv->vval.v_dict;
+    hash_lock_size(&dict->dv_hashtab, 11);
+
+    dict_add_number(dict, "line", wp->w_winrow + 1);
+    dict_add_number(dict, "col", wp->w_wincol + 1);
+    dict_add_number(dict, "width", wp->w_width + left_extra
+           + wp->w_popup_border[1] + wp->w_popup_padding[1]);
+    dict_add_number(dict, "height", wp->w_height + top_extra
+           + wp->w_popup_border[2] + wp->w_popup_padding[2]);
+
+    dict_add_number(dict, "core_line", wp->w_winrow + 1 + top_extra);
+    dict_add_number(dict, "core_col", wp->w_wincol + 1 + left_extra);
+    dict_add_number(dict, "core_width", wp->w_width);
+    dict_add_number(dict, "core_height", wp->w_height);
+
+    dict_add_number(dict, "scrollbar", wp->w_has_scrollbar);
+    dict_add_number(dict, "firstline", wp->w_topline);
+    dict_add_number(dict, "lastline", wp->w_botline - 1);
+    dict_add_number(dict, "visible",
+           win_valid(wp) && (wp->w_popup_flags & POPF_HIDDEN) == 0);
+
+    hash_unlock(&dict->dv_hashtab);
 }
 
 /*
@@ -3102,13 +3103,13 @@ get_padding_border(dict_T *dict, int *array, char *name)
        return;
 
     list = list_alloc();
-    if (list != NULL)
-    {
-       dict_add_list(dict, name, list);
-       if (array[0] != 1 || array[1] != 1 || array[2] != 1 || array[3] != 1)
-           for (i = 0; i < 4; ++i)
-               list_append_number(list, array[i]);
-    }
+    if (list == NULL)
+       return;
+
+    dict_add_list(dict, name, list);
+    if (array[0] != 1 || array[1] != 1 || array[2] != 1 || array[3] != 1)
+       for (i = 0; i < 4; ++i)
+           list_append_number(list, array[i]);
 }
 
 /*
@@ -3127,12 +3128,12 @@ get_borderhighlight(dict_T *dict, win_T *wp)
        return;
 
     list = list_alloc();
-    if (list != NULL)
-    {
-       dict_add_list(dict, "borderhighlight", list);
-       for (i = 0; i < 4; ++i)
-           list_append_string(list, wp->w_border_highlight[i], -1);
-    }
+    if (list == NULL)
+       return;
+
+    dict_add_list(dict, "borderhighlight", list);
+    for (i = 0; i < 4; ++i)
+       list_append_string(list, wp->w_border_highlight[i], -1);
 }
 
 /*
@@ -3153,14 +3154,14 @@ get_borderchars(dict_T *dict, win_T *wp)
        return;
 
     list = list_alloc();
-    if (list != NULL)
+    if (list == NULL)
+       return;
+
+    dict_add_list(dict, "borderchars", list);
+    for (i = 0; i < 8; ++i)
     {
-       dict_add_list(dict, "borderchars", list);
-       for (i = 0; i < 8; ++i)
-       {
-           len = mb_char2bytes(wp->w_border_char[i], buf);
-           list_append_string(list, buf, len);
-       }
+       len = mb_char2bytes(wp->w_border_char[i], buf);
+       list_append_string(list, buf, len);
     }
 }
 
@@ -3181,13 +3182,13 @@ get_moved_list(dict_T *dict, win_T *wp)
        list_append_number(list, wp->w_popup_maxcol);
     }
     list = list_alloc();
-    if (list != NULL)
-    {
-       dict_add_list(dict, "mousemoved", list);
-       list_append_number(list, wp->w_popup_mouse_row);
-       list_append_number(list, wp->w_popup_mouse_mincol);
-       list_append_number(list, wp->w_popup_mouse_maxcol);
-    }
+    if (list == NULL)
+       return;
+
+    dict_add_list(dict, "mousemoved", list);
+    list_append_number(list, wp->w_popup_mouse_row);
+    list_append_number(list, wp->w_popup_mouse_mincol);
+    list_append_number(list, wp->w_popup_mouse_maxcol);
 }
 
 /*
@@ -3202,104 +3203,104 @@ f_popup_getoptions(typval_T *argvars, typval_T *rettv)
     tabpage_T  *tp;
     int                i;
 
-    if (rettv_dict_alloc(rettv) == OK)
-    {
-       if (in_vim9script() && check_for_number_arg(argvars, 0) == FAIL)
-           return;
+    if (rettv_dict_alloc(rettv) == FAIL)
+       return;
 
-       id = (int)tv_get_number(argvars);
-       wp = find_popup_win(id);
-       if (wp == NULL)
-           return;
+    if (in_vim9script() && check_for_number_arg(argvars, 0) == FAIL)
+       return;
 
-       dict = rettv->vval.v_dict;
-       dict_add_number(dict, "line", wp->w_wantline);
-       dict_add_number(dict, "col", wp->w_wantcol);
-       dict_add_number(dict, "minwidth", wp->w_minwidth);
-       dict_add_number(dict, "minheight", wp->w_minheight);
-       dict_add_number(dict, "maxheight", wp->w_maxheight);
-       dict_add_number(dict, "maxwidth", wp->w_maxwidth);
-       dict_add_number(dict, "firstline", wp->w_firstline);
-       dict_add_number(dict, "scrollbar", wp->w_want_scrollbar);
-       dict_add_number(dict, "zindex", wp->w_zindex);
-       dict_add_number(dict, "fixed", wp->w_popup_fixed);
-       if (wp->w_popup_prop_type && win_valid_any_tab(wp->w_popup_prop_win))
-       {
-           proptype_T *pt = text_prop_type_by_id(
-                                wp->w_popup_prop_win->w_buffer,
-                                wp->w_popup_prop_type);
-
-           if (pt != NULL)
-               dict_add_string(dict, "textprop", pt->pt_name);
-           dict_add_number(dict, "textpropwin", wp->w_popup_prop_win->w_id);
-           dict_add_number(dict, "textpropid", wp->w_popup_prop_id);
-       }
-       dict_add_string(dict, "title", wp->w_popup_title);
-       dict_add_number(dict, "wrap", wp->w_p_wrap);
-       dict_add_number(dict, "drag", (wp->w_popup_flags & POPF_DRAG) != 0);
-       dict_add_number(dict, "dragall",
-                                     (wp->w_popup_flags & POPF_DRAGALL) != 0);
-       dict_add_number(dict, "mapping",
-                                     (wp->w_popup_flags & POPF_MAPPING) != 0);
-       dict_add_number(dict, "resize", (wp->w_popup_flags & POPF_RESIZE) != 0);
-       dict_add_number(dict, "posinvert",
-                                   (wp->w_popup_flags & POPF_POSINVERT) != 0);
-       dict_add_number(dict, "cursorline",
-                                  (wp->w_popup_flags & POPF_CURSORLINE) != 0);
-       dict_add_string(dict, "highlight", wp->w_p_wcr);
-       if (wp->w_scrollbar_highlight != NULL)
-           dict_add_string(dict, "scrollbarhighlight",
-                                                   wp->w_scrollbar_highlight);
-       if (wp->w_thumb_highlight != NULL)
-           dict_add_string(dict, "thumbhighlight", wp->w_thumb_highlight);
-
-       // find the tabpage that holds this popup
-       i = 1;
-       FOR_ALL_TABPAGES(tp)
-       {
-           win_T *twp;
+    id = (int)tv_get_number(argvars);
+    wp = find_popup_win(id);
+    if (wp == NULL)
+       return;
 
-           FOR_ALL_POPUPWINS_IN_TAB(tp, twp)
-               if (twp->w_id == id)
-                   break;
-           if (twp != NULL)
+    dict = rettv->vval.v_dict;
+    dict_add_number(dict, "line", wp->w_wantline);
+    dict_add_number(dict, "col", wp->w_wantcol);
+    dict_add_number(dict, "minwidth", wp->w_minwidth);
+    dict_add_number(dict, "minheight", wp->w_minheight);
+    dict_add_number(dict, "maxheight", wp->w_maxheight);
+    dict_add_number(dict, "maxwidth", wp->w_maxwidth);
+    dict_add_number(dict, "firstline", wp->w_firstline);
+    dict_add_number(dict, "scrollbar", wp->w_want_scrollbar);
+    dict_add_number(dict, "zindex", wp->w_zindex);
+    dict_add_number(dict, "fixed", wp->w_popup_fixed);
+    if (wp->w_popup_prop_type && win_valid_any_tab(wp->w_popup_prop_win))
+    {
+       proptype_T *pt = text_prop_type_by_id(
+               wp->w_popup_prop_win->w_buffer,
+               wp->w_popup_prop_type);
+
+       if (pt != NULL)
+           dict_add_string(dict, "textprop", pt->pt_name);
+       dict_add_number(dict, "textpropwin", wp->w_popup_prop_win->w_id);
+       dict_add_number(dict, "textpropid", wp->w_popup_prop_id);
+    }
+    dict_add_string(dict, "title", wp->w_popup_title);
+    dict_add_number(dict, "wrap", wp->w_p_wrap);
+    dict_add_number(dict, "drag", (wp->w_popup_flags & POPF_DRAG) != 0);
+    dict_add_number(dict, "dragall",
+           (wp->w_popup_flags & POPF_DRAGALL) != 0);
+    dict_add_number(dict, "mapping",
+           (wp->w_popup_flags & POPF_MAPPING) != 0);
+    dict_add_number(dict, "resize", (wp->w_popup_flags & POPF_RESIZE) != 0);
+    dict_add_number(dict, "posinvert",
+           (wp->w_popup_flags & POPF_POSINVERT) != 0);
+    dict_add_number(dict, "cursorline",
+           (wp->w_popup_flags & POPF_CURSORLINE) != 0);
+    dict_add_string(dict, "highlight", wp->w_p_wcr);
+    if (wp->w_scrollbar_highlight != NULL)
+       dict_add_string(dict, "scrollbarhighlight",
+               wp->w_scrollbar_highlight);
+    if (wp->w_thumb_highlight != NULL)
+       dict_add_string(dict, "thumbhighlight", wp->w_thumb_highlight);
+
+    // find the tabpage that holds this popup
+    i = 1;
+    FOR_ALL_TABPAGES(tp)
+    {
+       win_T *twp;
+
+       FOR_ALL_POPUPWINS_IN_TAB(tp, twp)
+           if (twp->w_id == id)
                break;
-           ++i;
+       if (twp != NULL)
+           break;
+       ++i;
+    }
+    if (tp == NULL)
+       i = -1;  // must be global
+    else if (tp == curtab)
+       i = 0;
+    dict_add_number(dict, "tabpage", i);
+
+    get_padding_border(dict, wp->w_popup_padding, "padding");
+    get_padding_border(dict, wp->w_popup_border, "border");
+    get_borderhighlight(dict, wp);
+    get_borderchars(dict, wp);
+    get_moved_list(dict, wp);
+
+    if (wp->w_filter_cb.cb_name != NULL)
+       dict_add_callback(dict, "filter", &wp->w_filter_cb);
+    if (wp->w_close_cb.cb_name != NULL)
+       dict_add_callback(dict, "callback", &wp->w_close_cb);
+
+    for (i = 0; i < (int)ARRAY_LENGTH(poppos_entries); ++i)
+       if (wp->w_popup_pos == poppos_entries[i].pp_val)
+       {
+           dict_add_string(dict, "pos",
+                   (char_u *)poppos_entries[i].pp_name);
+           break;
        }
-       if (tp == NULL)
-           i = -1;  // must be global
-       else if (tp == curtab)
-           i = 0;
-       dict_add_number(dict, "tabpage", i);
-
-       get_padding_border(dict, wp->w_popup_padding, "padding");
-       get_padding_border(dict, wp->w_popup_border, "border");
-       get_borderhighlight(dict, wp);
-       get_borderchars(dict, wp);
-       get_moved_list(dict, wp);
-
-       if (wp->w_filter_cb.cb_name != NULL)
-           dict_add_callback(dict, "filter", &wp->w_filter_cb);
-       if (wp->w_close_cb.cb_name != NULL)
-           dict_add_callback(dict, "callback", &wp->w_close_cb);
-
-       for (i = 0; i < (int)ARRAY_LENGTH(poppos_entries); ++i)
-           if (wp->w_popup_pos == poppos_entries[i].pp_val)
-           {
-               dict_add_string(dict, "pos",
-                                         (char_u *)poppos_entries[i].pp_name);
-               break;
-           }
 
-       dict_add_string(dict, "close", (char_u *)(
-                   wp->w_popup_close == POPCLOSE_BUTTON ? "button"
-                   : wp->w_popup_close == POPCLOSE_CLICK ? "click" : "none"));
+    dict_add_string(dict, "close", (char_u *)(
+               wp->w_popup_close == POPCLOSE_BUTTON ? "button"
+               : wp->w_popup_close == POPCLOSE_CLICK ? "click" : "none"));
 
 # if defined(FEAT_TIMERS)
-       dict_add_number(dict, "time", wp->w_popup_timer != NULL
-                                ?  (long)wp->w_popup_timer->tr_interval : 0L);
+    dict_add_number(dict, "time", wp->w_popup_timer != NULL
+           ?  (long)wp->w_popup_timer->tr_interval : 0L);
 # endif
-    }
 }
 
 # if defined(FEAT_TERMINAL) || defined(PROTO)
@@ -3640,49 +3641,49 @@ popup_masked(win_T *wp, int width, int height, int screencol, int screenline)
     static void
 update_popup_transparent(win_T *wp, int val)
 {
-    if (wp->w_popup_mask != NULL)
+    if (wp->w_popup_mask == NULL)
+       return;
+
+    int                width = popup_width(wp);
+    int                height = popup_height(wp);
+    listitem_T *lio, *li;
+    int                cols, cole;
+    int                lines, linee;
+    int                col, line;
+
+    FOR_ALL_LIST_ITEMS(wp->w_popup_mask, lio)
     {
-       int             width = popup_width(wp);
-       int             height = popup_height(wp);
-       listitem_T      *lio, *li;
-       int             cols, cole;
-       int             lines, linee;
-       int             col, line;
-
-       FOR_ALL_LIST_ITEMS(wp->w_popup_mask, lio)
-       {
-           li = lio->li_tv.vval.v_list->lv_first;
-           cols = tv_get_number(&li->li_tv);
-           if (cols < 0)
-               cols = width + cols + 1;
-           li = li->li_next;
-           cole = tv_get_number(&li->li_tv);
-           if (cole < 0)
-               cole = width + cole + 1;
-           li = li->li_next;
-           lines = tv_get_number(&li->li_tv);
-           if (lines < 0)
-               lines = height + lines + 1;
-           li = li->li_next;
-           linee = tv_get_number(&li->li_tv);
-           if (linee < 0)
-               linee = height + linee + 1;
-
-           --cols;
-           cols -= wp->w_popup_leftoff;
-           if (cols < 0)
-               cols = 0;
-           cole -= wp->w_popup_leftoff;
-           --lines;
-           if (lines < 0)
-               lines = 0;
-           for (line = lines; line < linee
-                                 && line + wp->w_winrow < screen_Rows; ++line)
-               for (col = cols; col < cole
-                               && col + wp->w_wincol < screen_Columns; ++col)
-                   popup_transparent[(line + wp->w_winrow) * screen_Columns
-                                                  + col + wp->w_wincol] = val;
-       }
+       li = lio->li_tv.vval.v_list->lv_first;
+       cols = tv_get_number(&li->li_tv);
+       if (cols < 0)
+           cols = width + cols + 1;
+       li = li->li_next;
+       cole = tv_get_number(&li->li_tv);
+       if (cole < 0)
+           cole = width + cole + 1;
+       li = li->li_next;
+       lines = tv_get_number(&li->li_tv);
+       if (lines < 0)
+           lines = height + lines + 1;
+       li = li->li_next;
+       linee = tv_get_number(&li->li_tv);
+       if (linee < 0)
+           linee = height + linee + 1;
+
+       --cols;
+       cols -= wp->w_popup_leftoff;
+       if (cols < 0)
+           cols = 0;
+       cole -= wp->w_popup_leftoff;
+       --lines;
+       if (lines < 0)
+           lines = 0;
+       for (line = lines; line < linee
+               && line + wp->w_winrow < screen_Rows; ++line)
+           for (col = cols; col < cole
+                   && col + wp->w_wincol < screen_Columns; ++col)
+               popup_transparent[(line + wp->w_winrow) * screen_Columns
+                   + col + wp->w_wincol] = val;
     }
 }
 
@@ -4508,33 +4509,33 @@ popup_close_info(void)
     win_T *
 popup_get_message_win(void)
 {
-    if (message_win == NULL)
-    {
-       int i;
+    if (message_win != NULL)
+       return message_win;
 
-       message_win = popup_create(NULL, NULL, TYPE_MESSAGE_WIN);
+    int i;
 
-       if (message_win == NULL)
-           return NULL;
+    message_win = popup_create(NULL, NULL, TYPE_MESSAGE_WIN);
 
-       // use the full screen width
-       message_win->w_width = Columns;
+    if (message_win == NULL)
+       return NULL;
 
-       // position at bottom of screen
-       message_win->w_popup_pos = POPPOS_BOTTOM;
-       message_win->w_wantcol = 1;
-       message_win->w_minwidth = 9999;
-       message_win->w_firstline = -1;
+    // use the full screen width
+    message_win->w_width = Columns;
 
-       // no padding, border at the top
-       for (i = 0; i < 4; ++i)
-           message_win->w_popup_padding[i] = 0;
-       for (i = 1; i < 4; ++i)
-           message_win->w_popup_border[i] = 0;
+    // position at bottom of screen
+    message_win->w_popup_pos = POPPOS_BOTTOM;
+    message_win->w_wantcol = 1;
+    message_win->w_minwidth = 9999;
+    message_win->w_firstline = -1;
 
-       if (message_win->w_popup_timer != NULL)
-           message_win->w_popup_timer->tr_keep = TRUE;
-    }
+    // no padding, border at the top
+    for (i = 0; i < 4; ++i)
+       message_win->w_popup_padding[i] = 0;
+    for (i = 1; i < 4; ++i)
+       message_win->w_popup_border[i] = 0;
+
+    if (message_win->w_popup_timer != NULL)
+       message_win->w_popup_timer->tr_keep = TRUE;
     return message_win;
 }
 
@@ -4545,16 +4546,16 @@ popup_get_message_win(void)
     void
 popup_show_message_win(void)
 {
-    if (message_win != NULL)
+    if (message_win == NULL)
+       return;
+
+    if ((message_win->w_popup_flags & POPF_HIDDEN) != 0)
     {
-       if ((message_win->w_popup_flags & POPF_HIDDEN) != 0)
-       {
-           // the highlight may have changed.
-           popup_update_color(message_win, TYPE_MESSAGE_WIN);
-           popup_show(message_win);
-       }
-       start_message_win_timer = TRUE;
+       // the highlight may have changed.
+       popup_update_color(message_win, TYPE_MESSAGE_WIN);
+       popup_show(message_win);
     }
+    start_message_win_timer = TRUE;
 }
 
     static void
@@ -4664,22 +4665,22 @@ popup_win_closed(win_T *win)
     void
 popup_set_title(win_T *wp)
 {
-    if (wp->w_buffer->b_fname != NULL)
-    {
-       char_u  dirname[MAXPATHL];
-       size_t  len;
+    if (wp->w_buffer->b_fname == NULL)
+       return;
 
-       mch_dirname(dirname, MAXPATHL);
-       shorten_buf_fname(wp->w_buffer, dirname, FALSE);
+    char_u     dirname[MAXPATHL];
+    size_t     len;
 
-       vim_free(wp->w_popup_title);
-       len = STRLEN(wp->w_buffer->b_fname) + 3;
-       wp->w_popup_title = alloc((int)len);
-       if (wp->w_popup_title != NULL)
-           vim_snprintf((char *)wp->w_popup_title, len, " %s ",
-                                                       wp->w_buffer->b_fname);
-       redraw_win_later(wp, UPD_VALID);
-    }
+    mch_dirname(dirname, MAXPATHL);
+    shorten_buf_fname(wp->w_buffer, dirname, FALSE);
+
+    vim_free(wp->w_popup_title);
+    len = STRLEN(wp->w_buffer->b_fname) + 3;
+    wp->w_popup_title = alloc((int)len);
+    if (wp->w_popup_title != NULL)
+       vim_snprintf((char *)wp->w_popup_title, len, " %s ",
+               wp->w_buffer->b_fname);
+    redraw_win_later(wp, UPD_VALID);
 }
 
 # if defined(FEAT_QUICKFIX) || defined(PROTO)
index 03348dff33b5a75dfc4c7e19d9c8f9eccdef9dd0..b971cd79098e6e5b2383b8c47655b3cccbf58c81 100644 (file)
@@ -910,16 +910,16 @@ script_prof_restore(proftime_T *tm)
 {
     scriptitem_T    *si;
 
-    if (SCRIPT_ID_VALID(current_sctx.sc_sid))
+    if (!SCRIPT_ID_VALID(current_sctx.sc_sid))
+       return;
+
+    si = SCRIPT_ITEM(current_sctx.sc_sid);
+    if (si->sn_prof_on && --si->sn_pr_nest == 0)
     {
-       si = SCRIPT_ITEM(current_sctx.sc_sid);
-       if (si->sn_prof_on && --si->sn_pr_nest == 0)
-       {
-           profile_end(&si->sn_pr_child);
-           profile_sub_wait(tm, &si->sn_pr_child); // don't count wait time
-           profile_add(&si->sn_pr_children, &si->sn_pr_child);
-           profile_add(&si->sn_prl_children, &si->sn_pr_child);
-       }
+       profile_end(&si->sn_pr_child);
+       profile_sub_wait(tm, &si->sn_pr_child); // don't count wait time
+       profile_add(&si->sn_pr_children, &si->sn_pr_child);
+       profile_add(&si->sn_prl_children, &si->sn_pr_child);
     }
 }
 
@@ -1009,17 +1009,17 @@ profile_dump(void)
 {
     FILE       *fd;
 
-    if (profile_fname != NULL)
+    if (profile_fname == NULL)
+       return;
+
+    fd = mch_fopen((char *)profile_fname, "w");
+    if (fd == NULL)
+       semsg(_(e_cant_open_file_str), profile_fname);
+    else
     {
-       fd = mch_fopen((char *)profile_fname, "w");
-       if (fd == NULL)
-           semsg(_(e_cant_open_file_str), profile_fname);
-       else
-       {
-           script_dump_profile(fd);
-           func_dump_profile(fd);
-           fclose(fd);
-       }
+       script_dump_profile(fd);
+       func_dump_profile(fd);
+       fclose(fd);
     }
 }
 
index ca5b35652ceaa6decf99fdc2e1dfc05415aac12f..1454280ee70b5e5d4c99bb6d70b1d44106098e3d 100644 (file)
@@ -1898,14 +1898,14 @@ qf_store_title(qf_list_T *qfl, char_u *title)
 {
     VIM_CLEAR(qfl->qf_title);
 
-    if (title != NULL)
-    {
-       char_u *p = alloc_id(STRLEN(title) + 2, aid_qf_title);
+    if (title == NULL)
+       return;
 
-       qfl->qf_title = p;
-       if (p != NULL)
-           STRCPY(p, title);
-    }
+    char_u *p = alloc_id(STRLEN(title) + 2, aid_qf_title);
+
+    qfl->qf_title = p;
+    if (p != NULL)
+       STRCPY(p, title);
 }
 
 /*
@@ -1976,12 +1976,12 @@ locstack_queue_delreq(qf_info_T *qi)
     qf_delq_T  *q;
 
     q = ALLOC_ONE(qf_delq_T);
-    if (q != NULL)
-    {
-       q->qi = qi;
-       q->next = qf_delq_head;
-       qf_delq_head = q;
-    }
+    if (q == NULL)
+       return;
+
+    q->qi = qi;
+    q->next = qf_delq_head;
+    qf_delq_head = q;
 }
 
 /*
@@ -2002,16 +2002,16 @@ wipe_qf_buffer(qf_info_T *qi)
 {
     buf_T      *qfbuf;
 
-    if (qi->qf_bufnr != INVALID_QFBUFNR)
+    if (qi->qf_bufnr == INVALID_QFBUFNR)
+       return;
+
+    qfbuf = buflist_findnr(qi->qf_bufnr);
+    if (qfbuf != NULL && qfbuf->b_nwindows == 0)
     {
-       qfbuf = buflist_findnr(qi->qf_bufnr);
-       if (qfbuf != NULL && qfbuf->b_nwindows == 0)
-       {
-           // If the quickfix buffer is not loaded in any window, then
-           // wipe the buffer.
-           close_buffer(NULL, qfbuf, DOBUF_WIPE, FALSE, FALSE);
-           qi->qf_bufnr = INVALID_QFBUFNR;
-       }
+       // If the quickfix buffer is not loaded in any window, then
+       // wipe the buffer.
+       close_buffer(NULL, qfbuf, DOBUF_WIPE, FALSE, FALSE);
+       qi->qf_bufnr = INVALID_QFBUFNR;
     }
 }
 
@@ -2231,12 +2231,12 @@ qf_alloc_stack(qfltype_T qfltype)
     qf_info_T *qi;
 
     qi = ALLOC_CLEAR_ONE_ID(qf_info_T, aid_qf_qfinfo);
-    if (qi != NULL)
-    {
-       qi->qf_refcount++;
-       qi->qfl_type = qfltype;
-       qi->qf_bufnr = INVALID_QFBUFNR;
-    }
+    if (qi == NULL)
+       return NULL;
+
+    qi->qf_refcount++;
+    qi->qfl_type = qfltype;
+    qi->qf_bufnr = INVALID_QFBUFNR;
     return qi;
 }
 
@@ -4573,64 +4573,64 @@ qf_update_buffer(qf_info_T *qi, qfline_T *old_last)
 
     // Check if a buffer for the quickfix list exists.  Update it.
     buf = qf_find_buf(qi);
-    if (buf != NULL)
-    {
-       linenr_T        old_line_count = buf->b_ml.ml_line_count;
-       int             qf_winid = 0;
+    if (buf == NULL)
+       return;
+
+    linenr_T   old_line_count = buf->b_ml.ml_line_count;
+    int                qf_winid = 0;
 
-       if (IS_LL_STACK(qi))
+    if (IS_LL_STACK(qi))
+    {
+       if (curwin->w_llist == qi)
+           win = curwin;
+       else
        {
-           if (curwin->w_llist == qi)
-               win = curwin;
-           else
-           {
-               // Find the file window (non-quickfix) with this location list
-               win = qf_find_win_with_loclist(qi);
-               if (win == NULL)
-                   // File window is not found. Find the location list window.
-                   win = qf_find_win(qi);
-               if (win == NULL)
-                   return;
-           }
-           qf_winid = win->w_id;
+           // Find the file window (non-quickfix) with this location list
+           win = qf_find_win_with_loclist(qi);
+           if (win == NULL)
+               // File window is not found. Find the location list window.
+               win = qf_find_win(qi);
+           if (win == NULL)
+               return;
        }
+       qf_winid = win->w_id;
+    }
 
-       // autocommands may cause trouble
-       incr_quickfix_busy();
+    // autocommands may cause trouble
+    incr_quickfix_busy();
 
-       int do_fill = TRUE;
-       if (old_last == NULL)
-       {
-           // set curwin/curbuf to buf and save a few things
-           aucmd_prepbuf(&aco, buf);
-           if (curbuf != buf)
-               do_fill = FALSE;  // failed to find a window for "buf"
-       }
+    int do_fill = TRUE;
+    if (old_last == NULL)
+    {
+       // set curwin/curbuf to buf and save a few things
+       aucmd_prepbuf(&aco, buf);
+       if (curbuf != buf)
+           do_fill = FALSE;  // failed to find a window for "buf"
+    }
 
-       if (do_fill)
-       {
-           qf_update_win_titlevar(qi);
+    if (do_fill)
+    {
+       qf_update_win_titlevar(qi);
 
-           qf_fill_buffer(qf_get_curlist(qi), buf, old_last, qf_winid);
-           ++CHANGEDTICK(buf);
+       qf_fill_buffer(qf_get_curlist(qi), buf, old_last, qf_winid);
+       ++CHANGEDTICK(buf);
 
-           if (old_last == NULL)
-           {
-               (void)qf_win_pos_update(qi, 0);
+       if (old_last == NULL)
+       {
+           (void)qf_win_pos_update(qi, 0);
 
-               // restore curwin/curbuf and a few other things
-               aucmd_restbuf(&aco);
-           }
+           // restore curwin/curbuf and a few other things
+           aucmd_restbuf(&aco);
        }
+    }
 
-       // Only redraw when added lines are visible.  This avoids flickering
-       // when the added lines are not visible.
-       if ((win = qf_find_win(qi)) != NULL && old_line_count < win->w_botline)
-           redraw_buf_later(buf, UPD_NOT_VALID);
+    // Only redraw when added lines are visible.  This avoids flickering
+    // when the added lines are not visible.
+    if ((win = qf_find_win(qi)) != NULL && old_line_count < win->w_botline)
+       redraw_buf_later(buf, UPD_NOT_VALID);
 
-       // always called after incr_quickfix_busy()
-       decr_quickfix_busy();
-    }
+    // always called after incr_quickfix_busy()
+    decr_quickfix_busy();
 }
 
 /*
@@ -4924,14 +4924,14 @@ qf_restore_list(qf_info_T *qi, int_u save_qfid)
 {
     int curlist;
 
-    if (qf_get_curlist(qi)->qf_id != save_qfid)
-    {
-       curlist = qf_id2nr(qi, save_qfid);
-       if (curlist < 0)
-           // list is not present
-           return FAIL;
-       qi->qf_curlist = curlist;
-    }
+    if (qf_get_curlist(qi)->qf_id == save_qfid)
+       return OK;
+
+    curlist = qf_id2nr(qi, save_qfid);
+    if (curlist < 0)
+       // list is not present
+       return FAIL;
+    qi->qf_curlist = curlist;
     return OK;
 }
 
@@ -6544,22 +6544,22 @@ restore_start_dir(char_u *dirname_start)
 {
     char_u *dirname_now = alloc(MAXPATHL);
 
-    if (NULL != dirname_now)
+    if (dirname_now == NULL)
+       return;
+
+    mch_dirname(dirname_now, MAXPATHL);
+    if (STRCMP(dirname_start, dirname_now) != 0)
     {
-       mch_dirname(dirname_now, MAXPATHL);
-       if (STRCMP(dirname_start, dirname_now) != 0)
-       {
-           // If the directory has changed, change it back by building up an
-           // appropriate ex command and executing it.
-           exarg_T ea;
-
-           CLEAR_FIELD(ea);
-           ea.arg = dirname_start;
-           ea.cmdidx = (curwin->w_localdir == NULL) ? CMD_cd : CMD_lcd;
-           ex_cd(&ea);
-       }
-       vim_free(dirname_now);
+       // If the directory has changed, change it back by building up an
+       // appropriate ex command and executing it.
+       exarg_T ea;
+
+       CLEAR_FIELD(ea);
+       ea.arg = dirname_start;
+       ea.cmdidx = (curwin->w_localdir == NULL) ? CMD_cd : CMD_lcd;
+       ex_cd(&ea);
     }
+    vim_free(dirname_now);
 }
 
 /*
@@ -6723,13 +6723,13 @@ wipe_dummy_buffer(buf_T *buf, char_u *dirname_start)
     static void
 unload_dummy_buffer(buf_T *buf, char_u *dirname_start)
 {
-    if (curbuf != buf)         // safety check
-    {
-       close_buffer(NULL, buf, DOBUF_UNLOAD, FALSE, TRUE);
+    if (curbuf == buf)         // safety check
+       return;
 
-       // When autocommands/'autochdir' option changed directory: go back.
-       restore_start_dir(dirname_start);
-    }
+    close_buffer(NULL, buf, DOBUF_UNLOAD, FALSE, TRUE);
+
+    // When autocommands/'autochdir' option changed directory: go back.
+    restore_start_dir(dirname_start);
 }
 
 #if defined(FEAT_EVAL) || defined(PROTO)
@@ -6862,36 +6862,36 @@ qf_get_list_from_lines(dict_T *what, dictitem_T *di, dict_T *retdict)
     list_T     *l;
 
     // Only a List value is supported
-    if (di->di_tv.v_type == VAR_LIST && di->di_tv.vval.v_list != NULL)
-    {
-       // If errorformat is supplied then use it, otherwise use the 'efm'
-       // option setting
-       if ((efm_di = dict_find(what, (char_u *)"efm", -1)) != NULL)
-       {
-           if (efm_di->di_tv.v_type != VAR_STRING ||
-                   efm_di->di_tv.vval.v_string == NULL)
-               return FAIL;
-           errorformat = efm_di->di_tv.vval.v_string;
-       }
+    if (di->di_tv.v_type != VAR_LIST || di->di_tv.vval.v_list == NULL)
+       return FAIL;
 
-       l = list_alloc();
-       if (l == NULL)
+    // If errorformat is supplied then use it, otherwise use the 'efm'
+    // option setting
+    if ((efm_di = dict_find(what, (char_u *)"efm", -1)) != NULL)
+    {
+       if (efm_di->di_tv.v_type != VAR_STRING ||
+               efm_di->di_tv.vval.v_string == NULL)
            return FAIL;
+       errorformat = efm_di->di_tv.vval.v_string;
+    }
 
-       qi = qf_alloc_stack(QFLT_INTERNAL);
-       if (qi != NULL)
+    l = list_alloc();
+    if (l == NULL)
+       return FAIL;
+
+    qi = qf_alloc_stack(QFLT_INTERNAL);
+    if (qi != NULL)
+    {
+       if (qf_init_ext(qi, 0, NULL, NULL, &di->di_tv, errorformat,
+                   TRUE, (linenr_T)0, (linenr_T)0, NULL, NULL) > 0)
        {
-           if (qf_init_ext(qi, 0, NULL, NULL, &di->di_tv, errorformat,
-                       TRUE, (linenr_T)0, (linenr_T)0, NULL, NULL) > 0)
-           {
-               (void)get_errorlist(qi, NULL, 0, 0, l);
-               qf_free(&qi->qf_lists[0]);
-           }
-           free(qi);
+           (void)get_errorlist(qi, NULL, 0, 0, l);
+           qf_free(&qi->qf_lists[0]);
        }
-       dict_add_list(retdict, "items", l);
-       status = OK;
+       free(qi);
     }
+    dict_add_list(retdict, "items", l);
+    status = OK;
 
     return status;
 }
@@ -7632,12 +7632,12 @@ qf_setprop_qftf(qf_info_T *qi UNUSED, qf_list_T *qfl, dictitem_T *di)
 
     free_callback(&qfl->qf_qftf_cb);
     cb = get_callback(&di->di_tv);
-    if (cb.cb_name != NULL && *cb.cb_name != NUL)
-    {
-       set_callback(&qfl->qf_qftf_cb, &cb);
-       if (cb.cb_free_name)
-           vim_free(cb.cb_name);
-    }
+    if (cb.cb_name == NULL || *cb.cb_name == NUL)
+       return OK;
+
+    set_callback(&qfl->qf_qftf_cb, &cb);
+    if (cb.cb_free_name)
+       vim_free(cb.cb_name);
 
     return OK;
 }
@@ -8126,11 +8126,11 @@ ex_cexpr(exarg_T *eap)
     // Evaluate the expression.  When the result is a string or a list we can
     // use it to fill the errorlist.
     tv = eval_expr(eap->arg, eap);
-    if (tv != NULL)
-    {
-       (void)cexpr_core(eap, tv);
-       free_tv(tv);
-    }
+    if (tv == NULL)
+       return;
+
+    (void)cexpr_core(eap, tv);
+    free_tv(tv);
 }
 #endif
 
index af8b375b60d3062c06f57671eec67a0405da6247..f18f33d620fe4fa66c469b438a0cda088c0a2dfd 100644 (file)
@@ -710,10 +710,11 @@ peekchr(void)
 {
     static int after_slash = FALSE;
 
-    if (curchr == -1)
+    if (curchr != -1)
+       return curchr;
+
+    switch (curchr = regparse[0])
     {
-       switch (curchr = regparse[0])
-       {
        case '.':
        case '[':
        case '~':
@@ -743,7 +744,7 @@ peekchr(void)
        case ';':       // future ext.
        case '`':       // future ext.
        case '/':       // Can't be used in / command
-           // magic only after "\v"
+                       // magic only after "\v"
            if (reg_magic == MAGIC_ALL)
                curchr = Magic(curchr);
            break;
@@ -788,8 +789,8 @@ peekchr(void)
 
                // ignore \c \C \m \M \v \V and \Z after '$'
                while (p[0] == '\\' && (p[1] == 'c' || p[1] == 'C'
-                               || p[1] == 'm' || p[1] == 'M'
-                               || p[1] == 'v' || p[1] == 'V' || p[1] == 'Z'))
+                           || p[1] == 'm' || p[1] == 'M'
+                           || p[1] == 'v' || p[1] == 'V' || p[1] == 'Z'))
                {
                    if (p[1] == 'v')
                        is_magic_all = TRUE;
@@ -802,7 +803,7 @@ peekchr(void)
                            && (p[1] == '|' || p[1] == '&' || p[1] == ')'
                                || p[1] == 'n'))
                        || (is_magic_all
-                              && (p[0] == '|' || p[0] == '&' || p[0] == ')'))
+                           && (p[0] == '|' || p[0] == '&' || p[0] == ')'))
                        || reg_magic == MAGIC_ALL)
                    curchr = Magic('$');
            }
@@ -858,7 +859,6 @@ peekchr(void)
        default:
            if (has_mbyte)
                curchr = (*mb_ptr2char)(regparse);
-       }
     }
 
     return curchr;
@@ -1384,42 +1384,42 @@ prog_magic_wrong(void)
     static void
 cleanup_subexpr(void)
 {
-    if (rex.need_clear_subexpr)
+    if (!rex.need_clear_subexpr)
+       return;
+
+    if (REG_MULTI)
     {
-       if (REG_MULTI)
-       {
-           // Use 0xff to set lnum to -1
-           vim_memset(rex.reg_startpos, 0xff, sizeof(lpos_T) * NSUBEXP);
-           vim_memset(rex.reg_endpos, 0xff, sizeof(lpos_T) * NSUBEXP);
-       }
-       else
-       {
-           vim_memset(rex.reg_startp, 0, sizeof(char_u *) * NSUBEXP);
-           vim_memset(rex.reg_endp, 0, sizeof(char_u *) * NSUBEXP);
-       }
-       rex.need_clear_subexpr = FALSE;
+       // Use 0xff to set lnum to -1
+       vim_memset(rex.reg_startpos, 0xff, sizeof(lpos_T) * NSUBEXP);
+       vim_memset(rex.reg_endpos, 0xff, sizeof(lpos_T) * NSUBEXP);
     }
+    else
+    {
+       vim_memset(rex.reg_startp, 0, sizeof(char_u *) * NSUBEXP);
+       vim_memset(rex.reg_endp, 0, sizeof(char_u *) * NSUBEXP);
+    }
+    rex.need_clear_subexpr = FALSE;
 }
 
 #ifdef FEAT_SYN_HL
     static void
 cleanup_zsubexpr(void)
 {
-    if (rex.need_clear_zsubexpr)
+    if (!rex.need_clear_zsubexpr)
+       return;
+
+    if (REG_MULTI)
     {
-       if (REG_MULTI)
-       {
-           // Use 0xff to set lnum to -1
-           vim_memset(reg_startzpos, 0xff, sizeof(lpos_T) * NSUBEXP);
-           vim_memset(reg_endzpos, 0xff, sizeof(lpos_T) * NSUBEXP);
-       }
-       else
-       {
-           vim_memset(reg_startzp, 0, sizeof(char_u *) * NSUBEXP);
-           vim_memset(reg_endzp, 0, sizeof(char_u *) * NSUBEXP);
-       }
-       rex.need_clear_zsubexpr = FALSE;
+       // Use 0xff to set lnum to -1
+       vim_memset(reg_startzpos, 0xff, sizeof(lpos_T) * NSUBEXP);
+       vim_memset(reg_endzpos, 0xff, sizeof(lpos_T) * NSUBEXP);
+    }
+    else
+    {
+       vim_memset(reg_startzp, 0, sizeof(char_u *) * NSUBEXP);
+       vim_memset(reg_endzp, 0, sizeof(char_u *) * NSUBEXP);
     }
+    rex.need_clear_zsubexpr = FALSE;
 }
 #endif
 
index d2acbc2032139ad7a28ab15e504c2b2498cc77eb..33af278bf624f9f6217781560f9782b98b5869ba 100644 (file)
@@ -3187,20 +3187,20 @@ save_subexpr(regbehind_T *bp)
     // When "rex.need_clear_subexpr" is set we don't need to save the values,
     // only remember that this flag needs to be set again when restoring.
     bp->save_need_clear_subexpr = rex.need_clear_subexpr;
-    if (!rex.need_clear_subexpr)
+    if (rex.need_clear_subexpr)
+       return;
+
+    for (i = 0; i < NSUBEXP; ++i)
     {
-       for (i = 0; i < NSUBEXP; ++i)
+       if (REG_MULTI)
        {
-           if (REG_MULTI)
-           {
-               bp->save_start[i].se_u.pos = rex.reg_startpos[i];
-               bp->save_end[i].se_u.pos = rex.reg_endpos[i];
-           }
-           else
-           {
-               bp->save_start[i].se_u.ptr = rex.reg_startp[i];
-               bp->save_end[i].se_u.ptr = rex.reg_endp[i];
-           }
+           bp->save_start[i].se_u.pos = rex.reg_startpos[i];
+           bp->save_end[i].se_u.pos = rex.reg_endpos[i];
+       }
+       else
+       {
+           bp->save_start[i].se_u.ptr = rex.reg_startp[i];
+           bp->save_end[i].se_u.ptr = rex.reg_endp[i];
        }
     }
 }
@@ -3215,20 +3215,20 @@ restore_subexpr(regbehind_T *bp)
 
     // Only need to restore saved values when they are not to be cleared.
     rex.need_clear_subexpr = bp->save_need_clear_subexpr;
-    if (!rex.need_clear_subexpr)
+    if (rex.need_clear_subexpr)
+       return;
+
+    for (i = 0; i < NSUBEXP; ++i)
     {
-       for (i = 0; i < NSUBEXP; ++i)
+       if (REG_MULTI)
        {
-           if (REG_MULTI)
-           {
-               rex.reg_startpos[i] = bp->save_start[i].se_u.pos;
-               rex.reg_endpos[i] = bp->save_end[i].se_u.pos;
-           }
-           else
-           {
-               rex.reg_startp[i] = bp->save_start[i].se_u.ptr;
-               rex.reg_endp[i] = bp->save_end[i].se_u.ptr;
-           }
+           rex.reg_startpos[i] = bp->save_start[i].se_u.pos;
+           rex.reg_endpos[i] = bp->save_end[i].se_u.pos;
+       }
+       else
+       {
+           rex.reg_startp[i] = bp->save_start[i].se_u.ptr;
+           rex.reg_endp[i] = bp->save_end[i].se_u.ptr;
        }
     }
 }
index 19ee71bcdc2184aeb9457d8a0ad21eb7c2c1e7ac..619cd15d2083bb471820ecf768554ed2c0c73c55 100644 (file)
@@ -487,20 +487,20 @@ nfa_get_match_text(nfa_state_T *start)
        return NULL;
 
     ret = alloc(len);
-    if (ret != NULL)
+    if (ret == NULL)
+       return NULL;
+
+    p = start->out->out; // skip first char, it goes into regstart
+    s = ret;
+    while (p->c > 0)
     {
-       p = start->out->out; // skip first char, it goes into regstart
-       s = ret;
-       while (p->c > 0)
-       {
-           if (has_mbyte)
-               s += (*mb_char2bytes)(p->c, s);
-           else
-               *s++ = p->c;
-           p = p->out;
-       }
-       *s = NUL;
+       if (has_mbyte)
+           s += (*mb_char2bytes)(p->c, s);
+       else
+           *s++ = p->c;
+       p = p->out;
     }
+    *s = NUL;
     return ret;
 }
 
@@ -2782,25 +2782,25 @@ nfa_postfix_dump(char_u *expr, int retval)
     FILE *f;
 
     f = fopen(NFA_REGEXP_DUMP_LOG, "a");
-    if (f != NULL)
+    if (f == NULL)
+       return;
+
+    fprintf(f, "\n-------------------------\n");
+    if (retval == FAIL)
+       fprintf(f, ">>> NFA engine failed... \n");
+    else if (retval == OK)
+       fprintf(f, ">>> NFA engine succeeded !\n");
+    fprintf(f, "Regexp: \"%s\"\nPostfix notation (char): \"", expr);
+    for (p = post_start; *p && p < post_ptr; p++)
     {
-       fprintf(f, "\n-------------------------\n");
-       if (retval == FAIL)
-           fprintf(f, ">>> NFA engine failed... \n");
-       else if (retval == OK)
-           fprintf(f, ">>> NFA engine succeeded !\n");
-       fprintf(f, "Regexp: \"%s\"\nPostfix notation (char): \"", expr);
-       for (p = post_start; *p && p < post_ptr; p++)
-       {
-           nfa_set_code(*p);
-           fprintf(f, "%s, ", code);
-       }
-       fprintf(f, "\"\nPostfix notation (int): ");
-       for (p = post_start; *p && p < post_ptr; p++)
-               fprintf(f, "%d ", *p);
-       fprintf(f, "\n\n");
-       fclose(f);
+       nfa_set_code(*p);
+       fprintf(f, "%s, ", code);
     }
+    fprintf(f, "\"\nPostfix notation (int): ");
+    for (p = post_start; *p && p < post_ptr; p++)
+       fprintf(f, "%d ", *p);
+    fprintf(f, "\n\n");
+    fclose(f);
 }
 
 /*
@@ -2883,20 +2883,20 @@ nfa_dump(nfa_regprog_T *prog)
 {
     FILE *debugf = fopen(NFA_REGEXP_DUMP_LOG, "a");
 
-    if (debugf != NULL)
-    {
-       nfa_print_state(debugf, prog->start);
+    if (debugf == NULL)
+       return;
 
-       if (prog->reganch)
-           fprintf(debugf, "reganch: %d\n", prog->reganch);
-       if (prog->regstart != NUL)
-           fprintf(debugf, "regstart: %c (decimal: %d)\n",
-                                             prog->regstart, prog->regstart);
-       if (prog->match_text != NULL)
-           fprintf(debugf, "match_text: \"%s\"\n", prog->match_text);
+    nfa_print_state(debugf, prog->start);
 
-       fclose(debugf);
-    }
+    if (prog->reganch)
+       fprintf(debugf, "reganch: %d\n", prog->reganch);
+    if (prog->regstart != NUL)
+       fprintf(debugf, "regstart: %c (decimal: %d)\n",
+               prog->regstart, prog->regstart);
+    if (prog->match_text != NULL)
+       fprintf(debugf, "match_text: \"%s\"\n", prog->match_text);
+
+    fclose(debugf);
 }
 #endif     // ENABLE_LOG
 #endif     // DEBUG
@@ -4096,21 +4096,21 @@ clear_sub(regsub_T *sub)
 copy_sub(regsub_T *to, regsub_T *from)
 {
     to->in_use = from->in_use;
-    if (from->in_use > 0)
+    if (from->in_use <= 0)
+       return;
+
+    // Copy the match start and end positions.
+    if (REG_MULTI)
     {
-       // Copy the match start and end positions.
-       if (REG_MULTI)
-       {
-           mch_memmove(&to->list.multi[0],
-                       &from->list.multi[0],
-                       sizeof(struct multipos) * from->in_use);
-           to->orig_start_col = from->orig_start_col;
-       }
-       else
-           mch_memmove(&to->list.line[0],
-                       &from->list.line[0],
-                       sizeof(struct linepos) * from->in_use);
+       mch_memmove(&to->list.multi[0],
+               &from->list.multi[0],
+               sizeof(struct multipos) * from->in_use);
+       to->orig_start_col = from->orig_start_col;
     }
+    else
+       mch_memmove(&to->list.line[0],
+               &from->list.line[0],
+               sizeof(struct linepos) * from->in_use);
 }
 
 /*
@@ -4121,18 +4121,18 @@ copy_sub_off(regsub_T *to, regsub_T *from)
 {
     if (to->in_use < from->in_use)
        to->in_use = from->in_use;
-    if (from->in_use > 1)
-    {
-       // Copy the match start and end positions.
-       if (REG_MULTI)
-           mch_memmove(&to->list.multi[1],
-                       &from->list.multi[1],
-                       sizeof(struct multipos) * (from->in_use - 1));
-       else
-           mch_memmove(&to->list.line[1],
-                       &from->list.line[1],
-                       sizeof(struct linepos) * (from->in_use - 1));
-    }
+    if (from->in_use <= 1)
+       return;
+
+    // Copy the match start and end positions.
+    if (REG_MULTI)
+       mch_memmove(&to->list.multi[1],
+               &from->list.multi[1],
+               sizeof(struct multipos) * (from->in_use - 1));
+    else
+       mch_memmove(&to->list.line[1],
+               &from->list.line[1],
+               sizeof(struct linepos) * (from->in_use - 1));
 }
 
 /*
@@ -4141,22 +4141,22 @@ copy_sub_off(regsub_T *to, regsub_T *from)
     static void
 copy_ze_off(regsub_T *to, regsub_T *from)
 {
-    if (rex.nfa_has_zend)
+    if (!rex.nfa_has_zend)
+       return;
+
+    if (REG_MULTI)
     {
-       if (REG_MULTI)
+       if (from->list.multi[0].end_lnum >= 0)
        {
-           if (from->list.multi[0].end_lnum >= 0)
-           {
-               to->list.multi[0].end_lnum = from->list.multi[0].end_lnum;
-               to->list.multi[0].end_col = from->list.multi[0].end_col;
-           }
-       }
-       else
-       {
-           if (from->list.line[0].end != NULL)
-               to->list.line[0].end = from->list.line[0].end;
+           to->list.multi[0].end_lnum = from->list.multi[0].end_lnum;
+           to->list.multi[0].end_col = from->list.multi[0].end_col;
        }
     }
+    else
+    {
+       if (from->list.line[0].end != NULL)
+           to->list.line[0].end = from->list.line[0].end;
+    }
 }
 
 /*
@@ -7568,12 +7568,12 @@ fail:
     static void
 nfa_regfree(regprog_T *prog)
 {
-    if (prog != NULL)
-    {
-       vim_free(((nfa_regprog_T *)prog)->match_text);
-       vim_free(((nfa_regprog_T *)prog)->pattern);
-       vim_free(prog);
-    }
+    if (prog == NULL)
+       return;
+
+    vim_free(((nfa_regprog_T *)prog)->match_text);
+    vim_free(((nfa_regprog_T *)prog)->pattern);
+    vim_free(prog);
 }
 
 /*
index 3454cfaa610f72962280a850773e0d73bf886793..03c26cb70e4023d6c4e2ec1e971a98e8aca2212b 100644 (file)
@@ -294,25 +294,25 @@ get_register(
 
     get_yank_register(name, 0);
     reg = ALLOC_ONE(yankreg_T);
-    if (reg != NULL)
+    if (reg == NULL)
+       return (void *)NULL;
+
+    *reg = *y_current;
+    if (copy)
     {
-       *reg = *y_current;
-       if (copy)
+       // If we run out of memory some or all of the lines are empty.
+       if (reg->y_size == 0)
+           reg->y_array = NULL;
+       else
+           reg->y_array = ALLOC_MULT(char_u *, reg->y_size);
+       if (reg->y_array != NULL)
        {
-           // If we run out of memory some or all of the lines are empty.
-           if (reg->y_size == 0)
-               reg->y_array = NULL;
-           else
-               reg->y_array = ALLOC_MULT(char_u *, reg->y_size);
-           if (reg->y_array != NULL)
-           {
-               for (i = 0; i < reg->y_size; ++i)
-                   reg->y_array[i] = vim_strsave(y_current->y_array[i]);
-           }
+           for (i = 0; i < reg->y_size; ++i)
+               reg->y_array[i] = vim_strsave(y_current->y_array[i]);
        }
-       else
-           y_current->y_array = NULL;
     }
+    else
+       y_current->y_array = NULL;
     return (void *)reg;
 }
 
@@ -716,22 +716,22 @@ put_reedit_in_typebuf(int silent)
 {
     char_u     buf[3];
 
-    if (restart_edit != NUL)
+    if (restart_edit == NUL)
+       return;
+
+    if (restart_edit == 'V')
     {
-       if (restart_edit == 'V')
-       {
-           buf[0] = 'g';
-           buf[1] = 'R';
-           buf[2] = NUL;
-       }
-       else
-       {
-           buf[0] = restart_edit == 'I' ? 'i' : restart_edit;
-           buf[1] = NUL;
-       }
-       if (ins_typebuf(buf, REMAP_NONE, 0, TRUE, silent) == OK)
-           restart_edit = NUL;
+       buf[0] = 'g';
+       buf[1] = 'R';
+       buf[2] = NUL;
+    }
+    else
+    {
+       buf[0] = restart_edit == 'I' ? 'i' : restart_edit;
+       buf[1] = NUL;
     }
+    if (ins_typebuf(buf, REMAP_NONE, 0, TRUE, silent) == OK)
+       restart_edit = NUL;
 }
 
 /*
@@ -1097,14 +1097,14 @@ clear_registers(void)
     static void
 free_yank(long n)
 {
-    if (y_current->y_array != NULL)
-    {
-       long        i;
+    if (y_current->y_array == NULL)
+       return;
 
-       for (i = n; --i >= 0; )
-           vim_free(y_current->y_array[i]);
-       VIM_CLEAR(y_current->y_array);
-    }
+    long           i;
+
+    for (i = n; --i >= 0; )
+       vim_free(y_current->y_array[i]);
+    VIM_CLEAR(y_current->y_array);
 }
 
     void
@@ -2695,23 +2695,22 @@ get_reg_contents(int regname, int flags)
     }
 
     retval = alloc(len + 1);
+    if (retval == NULL)
+       return NULL;
 
     // Copy the lines of the yank register into the string.
-    if (retval != NULL)
+    len = 0;
+    for (i = 0; i < y_current->y_size; ++i)
     {
-       len = 0;
-       for (i = 0; i < y_current->y_size; ++i)
-       {
-           STRCPY(retval + len, y_current->y_array[i]);
-           len += (long)STRLEN(retval + len);
+       STRCPY(retval + len, y_current->y_array[i]);
+       len += (long)STRLEN(retval + len);
 
-           // Insert a NL between lines and after the last line if y_type is
-           // MLINE.
-           if (y_current->y_type == MLINE || i < y_current->y_size - 1)
-               retval[len++] = '\n';
-       }
-       retval[len] = NUL;
+       // Insert a NL between lines and after the last line if y_type is
+       // MLINE.
+       if (y_current->y_type == MLINE || i < y_current->y_size - 1)
+           retval[len++] = '\n';
     }
+    retval[len] = NUL;
 
     return retval;
 }
index 9bfbe4b59f2819db3737661bec405dcb85156849..d94f43f9e189388c057cc51da4f6ab0f59ea3814 100644 (file)
@@ -695,6 +695,8 @@ static char *(features[]) =
 
 static int included_patches[] =
 {   /* Add new patch number below this line */
+/**/
+    1221,
 /**/
     1220,
 /**/