Merge #804 'Coverity fix resource leaks 1b'

justinmk · justinmk · commit bbd75cee82b6 · 2014-06-12T01:41:12.000-04:00
diff --git a/src/nvim/memline.c b/src/nvim/memline.c
@@ -304,8 +304,7 @@ int ml_open(buf_T *buf)
   b0p->b0_magic_int = (int)B0_MAGIC_INT;
   b0p->b0_magic_short = (short)B0_MAGIC_SHORT;
   b0p->b0_magic_char = B0_MAGIC_CHAR;
-  STRNCPY(b0p->b0_version, "VIM ", 4);
-  STRNCPY(b0p->b0_version + 4, Version, 6);
+  xstrlcpy(xstpcpy((char *) b0p->b0_version, "VIM "), Version, 6);
   long_to_char((long)mfp->mf_page_size, b0p->b0_page_size);
 
   if (!buf->b_spell) {
diff --git a/src/nvim/ops.c b/src/nvim/ops.c
@@ -90,10 +90,10 @@ struct block_def {
   colnr_T start_char_vcols;       /* number of vcols of pre-block char */
 };
 
-
 #ifdef INCLUDE_GENERATED_DECLARATIONS
 # include "ops.c.generated.h"
 #endif
+
 /*
  * The names of operators.
  * IMPORTANT: Index must correspond with defines in vim.h!!!
@@ -4704,29 +4704,48 @@ get_reg_contents (
   return retval;
 }
 
-/*
- * Store string "str" in register "name".
- * "maxlen" is the maximum number of bytes to use, -1 for all bytes.
- * If "must_append" is TRUE, always append to the register.  Otherwise append
- * if "name" is an uppercase letter.
- * Note: "maxlen" and "must_append" don't work for the "/" register.
- * Careful: 'str' is modified, you may have to use a copy!
- * If "str" ends in '\n' or '\r', use linewise, otherwise use characterwise.
- */
-void write_reg_contents(int name, char_u *str, int maxlen, int must_append)
+/// write_reg_contents - store `str` in register `name`
+///
+/// @see write_reg_contents_ex
+void write_reg_contents(int name,
+                        const char_u *str,
+                        ssize_t len,
+                        int must_append)
 {
-  write_reg_contents_ex(name, str, maxlen, must_append, MAUTO, 0L);
+  write_reg_contents_ex(name, str, len, must_append, MAUTO, 0L);
 }
 
-void write_reg_contents_ex(int name, char_u *str, int maxlen, int must_append, int yank_type, long block_len)
+/// write_reg_contents_ex - store `str` in register `name`
+///
+/// If `str` ends in '\n' or '\r', use linewise, otherwise use
+/// characterwise.
+///
+/// @warning when `name` is '/', `len` and `must_append` are ignored. This
+///          means that `str` MUST be NUL-terminated.
+///
+/// @param name The name of the register
+/// @param str The contents to write
+/// @param len If >= 0, write `len` bytes of `str`. Otherwise, write
+///               `strlen(str)` bytes. If `len` is larger than the
+///               allocated size of `src`, the behaviour is undefined.
+/// @param must_append If true, append the contents of `str` to the current
+///                    contents of the register. Note that regardless of
+///                    `must_append`, this function will append when `name`
+///                    is an uppercase letter.
+/// @param yank_type MCHAR, MLINE, MBLOCK or MAUTO
+/// @param block_len width of visual block
+void write_reg_contents_ex(int name,
+                           const char_u *str,
+                           ssize_t len,
+                           int must_append,
+                           int yank_type,
+                           long block_len)
 {
   struct yankreg  *old_y_previous, *old_y_current;
-  long len;
 
-  if (maxlen >= 0)
-    len = maxlen;
-  else
-    len = (long)STRLEN(str);
+  if (len < 0) {
+    len = (ssize_t) STRLEN(str);
+  }
 
   /* Special case: '/' search pattern */
   if (name == '/') {
@@ -4735,17 +4754,25 @@ void write_reg_contents_ex(int name, char_u *str, int maxlen, int must_append, i
   }
 
   if (name == '=') {
-    char_u      *p, *s;
-
-    p = vim_strnsave(str, (int)len);
+    size_t offset = 0;
+    size_t totlen = (size_t) len;
 
-    if (must_append) {
-      s = concat_str(get_expr_line_src(), p);
-      free(p);
-      p = s;
+    if (must_append && expr_line) {
+      // append has been specified and expr_line already exists, so we'll
+      // append the new string to expr_line.
+      size_t exprlen = STRLEN(expr_line);
 
+      totlen += exprlen;
+      offset = exprlen;
     }
-    set_expr_line(p);
+
+    // modify the global expr_line, extend/shrink it if necessary (realloc).
+    // Copy the input string into the adjusted memory at the specified
+    // offset.
+    expr_line = xrealloc(expr_line, totlen + 1);
+    memcpy(expr_line + offset, str, (size_t) len);
+    expr_line[totlen] = NUL;
+
     return;
   }
 
@@ -4773,18 +4800,20 @@ void write_reg_contents_ex(int name, char_u *str, int maxlen, int must_append, i
   y_current = old_y_current;
 }
 
-/*
- * Put a string into a register.  When the register is not empty, the string
- * is appended.
- */
-static void 
-str_to_reg (
-    struct yankreg *y_ptr,             /* pointer to yank register */
-    int yank_type,                          /* MCHAR, MLINE, MBLOCK, MAUTO */
-    char_u *str,               /* string to put in register */
-    long len,                               /* length of string */
-    long blocklen                          /* width of Visual block */
-)
+/// str_to_reg - Put a string into a register.
+///
+/// When the register is not empty, the string is appended.
+///
+/// @param y_ptr pointer to yank register
+/// @param yank_type MCHAR, MLINE, MBLOCK or MAUTO
+/// @param str string to put in register
+/// @param len length of the string
+/// @param blocklen width of visual block
+static void str_to_reg(struct yankreg *y_ptr,
+                       int yank_type,
+                       const char_u *str,
+                       long len,
+                       long blocklen)
 {
   int type;                             /* MCHAR, MLINE or MBLOCK */
   int lnum;
diff --git a/src/nvim/option.c b/src/nvim/option.c
@@ -2216,21 +2216,20 @@ set_options_default (
   win_comp_scroll(wp);
 }
 
-/*
- * Set the Vi-default value of a string option.
- * Used for 'sh', 'backupskip' and 'term'.
- */
-void set_string_default(char *name, char_u *val)
+/// Set the Vi-default value of a string option.
+/// Used for 'sh', 'backupskip' and 'term'.
+///
+/// @param name The name of the option
+/// @param val The value of the option
+void set_string_default(const char *name, const char_u *val)
 {
-  char_u      *p;
-  int opt_idx;
-
-  p = vim_strsave(val);
-  opt_idx = findoption((char_u *)name);
+  int opt_idx = findoption((char_u *)name);
   if (opt_idx >= 0) {
-    if (options[opt_idx].flags & P_DEF_ALLOCED)
+    if (options[opt_idx].flags & P_DEF_ALLOCED) {
       free(options[opt_idx].def_val[VI_DEFAULT]);
-    options[opt_idx].def_val[VI_DEFAULT] = p;
+    }
+
+    options[opt_idx].def_val[VI_DEFAULT] = (char_u *) xstrdup((char *) val);
     options[opt_idx].flags |= P_DEF_ALLOCED;
   }
 }
diff --git a/src/nvim/search.c b/src/nvim/search.c
@@ -375,14 +375,14 @@ void reset_search_dir(void)
  * Set the last search pattern.  For ":let @/ =" and viminfo.
  * Also set the saved search pattern, so that this works in an autocommand.
  */
-void set_last_search_pat(char_u *s, int idx, int magic, int setlast)
+void set_last_search_pat(const char_u *s, int idx, int magic, int setlast)
 {
   free(spats[idx].pat);
   /* An empty string means that nothing should be matched. */
   if (*s == NUL)
     spats[idx].pat = NULL;
   else
-    spats[idx].pat = vim_strsave(s);
+    spats[idx].pat = (char_u *) xstrdup((char *) s);
   spats[idx].magic = magic;
   spats[idx].no_scs = FALSE;
   spats[idx].off.dir = '/';
diff --git a/src/nvim/syntax.c b/src/nvim/syntax.c
@@ -3806,54 +3806,52 @@ static void clear_keywtab(hashtab_T *ht)
   hash_init(ht);
 }
 
-/*
- * Add a keyword to the list of keywords.
- */
-static void 
-add_keyword (
-    char_u *name,          /* name of keyword */
-    int id,                     /* group ID for this keyword */
-    int flags,                  /* flags for this keyword */
-    short *cont_in_list,     /* containedin for this keyword */
-    short *next_list,     /* nextgroup for this keyword */
-    int conceal_char
-)
+/// Add a keyword to the list of keywords.
+///
+/// @param name name of keyword
+/// @param id group ID for this keyword
+/// @param flags flags for this keyword
+/// @param cont_in_list containedin for this keyword
+/// @param next_list nextgroup for this keyword
+static void add_keyword(char_u *name,
+                        int id,
+                        int flags,
+                        short *cont_in_list,
+                        short *next_list,
+                        int conceal_char)
 {
-  hashtab_T   *ht;
-  hashitem_T  *hi;
-  char_u      *name_ic;
-  long_u hash;
   char_u name_folded[MAXKEYWLEN + 1];
+  char_u *name_ic = (curwin->w_s->b_syn_ic)
+   ? str_foldcase(name, (int)STRLEN(name), name_folded, sizeof(name_folded))
+   : name;
 
-  if (curwin->w_s->b_syn_ic)
-    name_ic = str_foldcase(name, (int)STRLEN(name),
-        name_folded, MAXKEYWLEN + 1);
-  else
-    name_ic = name;
   keyentry_T *kp = xmalloc(sizeof(keyentry_T) + STRLEN(name_ic));
   STRCPY(kp->keyword, name_ic);
   kp->k_syn.id = id;
   kp->k_syn.inc_tag = current_syn_inc_tag;
   kp->flags = flags;
   kp->k_char = conceal_char;
   kp->k_syn.cont_in_list = copy_id_list(cont_in_list);
-  if (cont_in_list != NULL)
+  if (cont_in_list != NULL) {
     curwin->w_s->b_syn_containedin = TRUE;
+  }
   kp->next_list = copy_id_list(next_list);
 
-  if (curwin->w_s->b_syn_ic)
-    ht = &curwin->w_s->b_keywtab_ic;
-  else
-    ht = &curwin->w_s->b_keywtab;
+  long_u hash = hash_hash(kp->keyword);
+  hashtab_T *ht = (curwin->w_s->b_syn_ic) ? &curwin->w_s->b_keywtab_ic
+                                          : &curwin->w_s->b_keywtab;
+  hashitem_T *hi = hash_lookup(ht, kp->keyword, hash);
 
-  hash = hash_hash(kp->keyword);
-  hi = hash_lookup(ht, kp->keyword, hash);
+  // even though it looks like only the kp->keyword member is
+  // being used here, vim uses some pointer trickery to get the orignal
+  // struct again later by using knowledge of the offset of the keyword
+  // field in the struct. See the definition of the HI2KE macro.
   if (HASHITEM_EMPTY(hi)) {
-    /* new keyword, add to hashtable */
+    // new keyword, add to hashtable
     kp->ke_next = NULL;
     hash_add_item(ht, hi, kp->keyword, hash);
   } else {
-    /* keyword already exists, prepend to list */
+    // keyword already exists, prepend to list
     kp->ke_next = HI2KE(hi);
     hi->hi_key = KE2HIKEY(kp);
   }
