Bug#28787273: FIX -WCAST-QUAL COMPILATION WARNINGS [noclose]

Avoid casting away constness using C-style cast.
Either use const consistently or explicitly remove
const with const_cast.

Patch 3.

Change-Id: Ifb539c1fe7d9c2f4ab901527890bf5df464d36f4

Author: jhauglid

dbug/dbug.cc

@@ -1381,7 +1381,7 @@ void _db_dump_(uint _line_, const char *keyword, const unsigned char *memory,
 
     pos = 0;
     while (length-- > 0) {
-      uint tmp = *((unsigned char *)memory++);
+      uint tmp = *(memory++);
       if ((pos += 3) >= 80) {
         fputc('\n', cs->stack->out_file);
         pos = 3;

include/my_sys.h

@@ -495,42 +495,64 @@ extern my_error_reporter my_charset_error_reporter;
 extern PSI_file_key key_file_io_cache;
 
 /* Test if buffer is inited */
-#define my_b_clear(info) (info)->buffer = 0
-#define my_b_inited(info) (info)->buffer
-#define my_b_EOF INT_MIN
-
-#define my_b_read(info, Buffer, Count)                       \
-  ((info)->read_pos + (Count) <= (info)->read_end            \
-       ? (memcpy(Buffer, (info)->read_pos, (size_t)(Count)), \
-          ((info)->read_pos += (Count)), 0)                  \
-       : (*(info)->read_function)((info), Buffer, Count))
-
-#define my_b_write(info, Buffer, Count)                         \
-  ((info)->write_pos + (Count) <= (info)->write_end             \
-       ? (memcpy((info)->write_pos, (Buffer), (size_t)(Count)), \
-          ((info)->write_pos += (Count)), 0)                    \
-       : (*(info)->write_function)((info), (uchar *)(Buffer), (Count)))
-
-#define my_b_get(info)                                          \
-  ((info)->read_pos != (info)->read_end                         \
-       ? ((info)->read_pos++, (int)(uchar)(info)->read_pos[-1]) \
-       : _my_b_get(info))
-
-#define my_b_tell(info) \
-  ((info)->pos_in_file + (size_t)(*(info)->current_pos - (info)->request_pos))
-
-#define my_b_get_buffer_start(info) (info)->request_pos
-#define my_b_get_bytes_in_buffer(info) \
-  (char *)(info)->read_end - (char *)my_b_get_buffer_start(info)
-#define my_b_get_pos_in_file(info) (info)->pos_in_file
+inline void my_b_clear(IO_CACHE *info) { info->buffer = nullptr; }
+
+inline bool my_b_inited(const IO_CACHE *info) {
+  return info->buffer != nullptr;
+}
+
+constexpr int my_b_EOF = INT_MIN;
+
+inline int my_b_read(IO_CACHE *info, uchar *buffer, size_t count) {
+  if (info->read_pos + count <= info->read_end) {
+    memcpy(buffer, info->read_pos, count);
+    info->read_pos += count;
+    return 0;
+  }
+  return (*info->read_function)(info, buffer, count);
+}
+
+inline int my_b_write(IO_CACHE *info, const uchar *buffer, size_t count) {
+  if (info->write_pos + count <= info->write_end) {
+    memcpy(info->write_pos, buffer, count);
+    info->write_pos += count;
+    return 0;
+  }
+  return (*info->write_function)(info, buffer, count);
+}
+
+extern int _my_b_get(IO_CACHE *info);
+
+inline int my_b_get(IO_CACHE *info) {
+  if (info->read_pos != info->read_end) {
+    info->read_pos++;
+    return info->read_pos[-1];
+  }
+  return _my_b_get(info);
+}
+
+inline my_off_t my_b_tell(const IO_CACHE *info) {
+  return info->pos_in_file + *info->current_pos - info->request_pos;
+}
+
+inline uchar *my_b_get_buffer_start(const IO_CACHE *info) {
+  return info->request_pos;
+}
+
+inline size_t my_b_get_bytes_in_buffer(const IO_CACHE *info) {
+  return info->read_end - my_b_get_buffer_start(info);
+}
+
+inline my_off_t my_b_get_pos_in_file(const IO_CACHE *info) {
+  return info->pos_in_file;
+}
 
 /* tell write offset in the SEQ_APPEND cache */
 int my_b_copy_to_file(IO_CACHE *cache, FILE *file);
-my_off_t my_b_append_tell(IO_CACHE *info);
-my_off_t my_b_safe_tell(IO_CACHE *info); /* picks the correct tell() */
 
-#define my_b_bytes_in_cache(info) \
-  (size_t)(*(info)->current_end - *(info)->current_pos)
+inline size_t my_b_bytes_in_cache(const IO_CACHE *info) {
+  return *info->current_end - *info->current_pos;
+}
 
 typedef uint32 ha_checksum;
 
@@ -669,7 +691,7 @@ void my_message_local_stderr(enum loglevel, uint ecode, va_list args);
 extern void my_message_local(enum loglevel ll, uint ecode, ...);
 extern bool my_init(void);
 extern void my_end(int infoflag);
-extern char *my_filename(File fd);
+extern const char *my_filename(File fd);
 extern MY_MODE get_file_perm(ulong perm_flags);
 extern bool my_chmod(const char *filename, ulong perm_flags, myf my_flags);
 
@@ -690,7 +712,8 @@ extern int test_if_hard_path(const char *dir_name);
 extern bool has_path(const char *name);
 extern char *convert_dirname(char *to, const char *from, const char *from_end);
 extern void to_unix_path(char *name);
-extern char *fn_ext(const char *name);
+extern char *fn_ext(char *name);
+extern const char *fn_ext(const char *name);
 extern char *fn_same(char *toname, const char *name, int flag);
 extern char *fn_format(char *to, const char *name, const char *dir,
                        const char *form, uint flag);
@@ -729,7 +752,6 @@ extern void init_io_cache_share(IO_CACHE *read_cache, IO_CACHE_SHARE *cshare,
 extern void remove_io_thread(IO_CACHE *info);
 extern int _my_b_seq_read(IO_CACHE *info, uchar *Buffer, size_t Count);
 extern int _my_b_net_read(IO_CACHE *info, uchar *Buffer, size_t Count);
-extern int _my_b_get(IO_CACHE *info);
 extern int _my_b_write(IO_CACHE *info, const uchar *Buffer, size_t Count);
 extern int my_b_append(IO_CACHE *info, const uchar *Buffer, size_t Count);
 extern int my_b_safe_write(IO_CACHE *info, const uchar *Buffer, size_t Count);

include/typelib.h

@@ -62,6 +62,6 @@ extern TYPELIB sql_protocol_typelib;
 my_ulonglong find_set_from_flags(const TYPELIB *lib, size_t default_name,
                                  my_ulonglong cur_set, my_ulonglong default_set,
                                  const char *str, unsigned int length,
-                                 char **err_pos, unsigned int *err_len);
+                                 const char **err_pos, unsigned int *err_len);
 
 #endif /* _typelib_h */

mysys/mf_fn_ext.cc

@@ -55,20 +55,19 @@
     points at the end ASCII(0) of the filename.
 */
 
-char *fn_ext(const char *name) {
-  const char *pos, *gpos;
-  DBUG_ENTER("fn_ext");
-  DBUG_PRINT("mfunkt", ("name: '%s'", name));
-
+const char *fn_ext(const char *name) {
 #if defined(FN_DEVCHAR) || defined(_WIN32)
-  {
-    char buff[FN_REFLEN];
-    size_t res_length;
-    gpos = name + dirname_part(buff, (char *)name, &res_length);
-  }
+  char buff[FN_REFLEN];
+  size_t res_length;
+  const char *gpos = name + dirname_part(buff, name, &res_length);
 #else
-  if (!(gpos = strrchr(name, FN_LIBCHAR))) gpos = name;
+  const char *gpos = strrchr(name, FN_LIBCHAR);
+  if (gpos == nullptr) gpos = name;
 #endif
-  pos = strrchr(gpos, FN_EXTCHAR);
-  DBUG_RETURN((char *)(pos ? pos : strend(gpos)));
-} /* fn_ext */
+  const char *pos = strrchr(gpos, FN_EXTCHAR);
+  return pos ? pos : strend(gpos);
+}
+
+char *fn_ext(char *name) {
+  return const_cast<char *>(fn_ext(static_cast<const char *>(name)));
+}

mysys/mf_iocache2.cc

@@ -44,6 +44,7 @@
 #include "my_sys.h"
 #include "mysql/psi/mysql_file.h"
 #include "mysql/psi/mysql_mutex.h"
+#include "template_utils.h"
 
 /*
   Copy contents of an IO_CACHE to a file.
@@ -86,60 +87,6 @@ int my_b_copy_to_file(IO_CACHE *cache, FILE *file) {
   DBUG_RETURN(0);
 }
 
-my_off_t my_b_append_tell(IO_CACHE *info) {
-/*
-  Sometimes we want to make sure that the variable is not put into
-  a register in debugging mode so we can see its value in the core
-*/
-#ifndef DBUG_OFF
-#define dbug_volatile volatile
-#else
-#define dbug_volatile
-#endif
-
-  /*
-    Prevent optimizer from putting res in a register when debugging
-    we need this to be able to see the value of res when the assert fails
-  */
-  dbug_volatile my_off_t res;
-
-  /*
-    We need to lock the append buffer mutex to keep flush_io_cache()
-    from messing with the variables that we need in order to provide the
-    answer to the question.
-  */
-  mysql_mutex_lock(&info->append_buffer_lock);
-
-#ifndef DBUG_OFF
-  /*
-    Make sure EOF is where we think it is. Note that we cannot just use
-    mysql_file_tell() because we have a reader thread that could have left the
-    file offset in a non-EOF location
-  */
-  {
-    volatile my_off_t save_pos;
-    save_pos = mysql_file_tell(info->file, MYF(0));
-    mysql_file_seek(info->file, (my_off_t)0, MY_SEEK_END, MYF(0));
-    /*
-      Save the value of mysql_file_tell in res so we can see it when studying
-      coredump
-    */
-    DBUG_ASSERT(info->end_of_file -
-                    (info->append_read_pos - info->write_buffer) ==
-                (res = mysql_file_tell(info->file, MYF(0))));
-    mysql_file_seek(info->file, save_pos, MY_SEEK_SET, MYF(0));
-  }
-#endif
-  res = info->end_of_file + (info->write_pos - info->append_read_pos);
-  mysql_mutex_unlock(&info->append_buffer_lock);
-  return res;
-}
-
-my_off_t my_b_safe_tell(IO_CACHE *info) {
-  if (unlikely(info->type == SEQ_READ_APPEND)) return my_b_append_tell(info);
-  return my_b_tell(info);
-}
-
 /*
   Make next read happen at the given position
   For write cache, make next write happen at the given position
@@ -436,7 +383,8 @@ size_t my_b_vprintf(IO_CACHE *info, const char *fmt, va_list args) {
           memset(buffz, '0', minimum_width - length2);
         else
           memset(buffz, ' ', minimum_width - length2);
-        if (my_b_write(info, buffz, minimum_width - length2)) {
+        if (my_b_write(info, pointer_cast<uchar *>(buffz),
+                       minimum_width - length2)) {
           goto err;
         }
       }
@@ -469,7 +417,8 @@ size_t my_b_vprintf(IO_CACHE *info, const char *fmt, va_list args) {
       if (my_b_write(info, (uchar *)buff, length2)) goto err;
     } else {
       /* %% or unknown code */
-      if (my_b_write(info, (uchar *)backtrack, (size_t)(fmt - backtrack)))
+      if (my_b_write(info, pointer_cast<const uchar *>(backtrack),
+                     fmt - backtrack))
         goto err;
       out_length += fmt - backtrack;
     }

mysys/mf_keycaches.cc

@@ -1,4 +1,4 @@
-/* Copyright (c) 2003, 2017, Oracle and/or its affiliates. All rights reserved.
+/* Copyright (c) 2003, 2018, Oracle and/or its affiliates. All rights reserved.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License, version 2.0,
@@ -200,7 +200,7 @@ static bool safe_hash_set(SAFE_HASH *hash, const uchar *key, uint length,
       goto end;
     }
     entry->key = (char *)(entry + 1);
-    memcpy((char *)entry->key, (char *)key, length);
+    memcpy(entry->key, key, length);
     entry->length = length;
     entry->data = data;
     /* Link entry to list */

mysys/mf_pack.cc

@@ -75,9 +75,8 @@ static char *expand_tilde(char **path);
 */
 
 size_t cleanup_dirname(char *to, const char *from) {
-  size_t length;
   char *pos;
-  char *from_ptr;
+  const char *from_ptr;
   char *start;
   char parent[5], /* for "FN_PARENTDIR" */
       buff[FN_REFLEN + 1], *end_parentdir;
@@ -88,17 +87,20 @@ size_t cleanup_dirname(char *to, const char *from) {
   DBUG_PRINT("enter", ("from: '%s'", from));
 
   start = buff;
-  from_ptr = (char *)from;
+  from_ptr = from;
 #ifdef FN_DEVCHAR
-  if ((pos = strrchr(from_ptr, FN_DEVCHAR)) != 0) { /* Skip device part */
-    length = (size_t)(pos - from_ptr) + 1;
-    start = my_stpnmov(buff, from_ptr, length);
-    from_ptr += length;
+  {
+    const char *dev_pos = strrchr(from_ptr, FN_DEVCHAR);
+    if (dev_pos != nullptr) { /* Skip device part */
+      size_t length = (dev_pos - from_ptr) + 1;
+      start = my_stpnmov(buff, from_ptr, length);
+      from_ptr += length;
+    }
   }
 #endif
 
   parent[0] = FN_LIBCHAR;
-  length = (size_t)(my_stpcpy(parent + 1, FN_PARENTDIR) - parent);
+  size_t length = my_stpcpy(parent + 1, FN_PARENTDIR) - parent;
   const char *end = start + FN_REFLEN;
   for (pos = start; pos < end && ((*pos = *from_ptr++) != 0); pos++) {
 #ifdef _WIN32

mysys/mf_path.cc

@@ -1,4 +1,4 @@
-/* Copyright (c) 2000, 2017, Oracle and/or its affiliates. All rights reserved.
+/* Copyright (c) 2000, 2018, Oracle and/or its affiliates. All rights reserved.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License, version 2.0,
@@ -59,7 +59,8 @@ static char *find_file_in_path(char *to, const char *name);
    my_path puts result in to and returns to */
 
 char *my_path(char *to, const char *progname, const char *own_pathname_part) {
-  char *start, *end, *prog;
+  char *start, *prog;
+  const char *end;
   size_t to_length;
   DBUG_ENTER("my_path");
 
@@ -78,9 +79,9 @@ char *my_path(char *to, const char *progname, const char *own_pathname_part) {
     if ((end = getenv("MY_BASEDIR_VERSION")) == 0 &&
         (end = getenv("MY_BASEDIR")) == 0) {
 #ifdef DEFAULT_BASEDIR
-      end = (char *)DEFAULT_BASEDIR;
+      end = DEFAULT_BASEDIR;
 #else
-      end = (char *)"/my/";
+      end = "/my/";
 #endif
     }
     (void)intern_filename(to, end);

mysys/my_compress.cc

@@ -80,7 +80,7 @@ uchar *my_compress_alloc(const uchar *packet, size_t *len, size_t *complen) {
     return 0; /* Not enough memory */
 
   tmp_complen = (uint)*complen;
-  res = compress((Bytef *)compbuf, &tmp_complen, (Bytef *)packet, (uLong)*len);
+  res = compress(compbuf, &tmp_complen, packet, static_cast<uLong>(*len));
   *complen = tmp_complen;
 
   if (res != Z_OK) {
@@ -127,8 +127,7 @@ bool my_uncompress(uchar *packet, size_t len, size_t *complen) {
     if (!compbuf) DBUG_RETURN(1); /* Not enough memory */
 
     tmp_complen = (uint)*complen;
-    error =
-        uncompress((Bytef *)compbuf, &tmp_complen, (Bytef *)packet, (uLong)len);
+    error = uncompress(compbuf, &tmp_complen, packet, (uLong)len);
     *complen = tmp_complen;
     if (error != Z_OK) { /* Probably wrong packet */
       DBUG_PRINT("error", ("Can't uncompress packet, error: %d", error));

mysys/my_copy.cc

@@ -1,4 +1,4 @@
-/* Copyright (c) 2000, 2017, Oracle and/or its affiliates. All rights reserved.
+/* Copyright (c) 2000, 2018, Oracle and/or its affiliates. All rights reserved.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License, version 2.0,
@@ -89,7 +89,7 @@ int my_copy(const char *from, const char *to, myf MyFlags) {
   memset(&new_stat_buff, 0, sizeof(MY_STAT));
   DBUG_ASSERT(!(MyFlags & (MY_FNABP | MY_NABP))); /* for my_read/my_write */
   if (MyFlags & MY_HOLD_ORIGINAL_MODES)           /* Copy stat if possible */
-    new_file_stat = my_stat((char *)to, &new_stat_buff, MYF(0)) != nullptr;
+    new_file_stat = my_stat(to, &new_stat_buff, MYF(0)) != nullptr;
 
   if ((from_file = my_open(from, O_RDONLY, MyFlags)) >= 0) {
     if (!my_stat(from, &stat_buff, MyFlags)) {
@@ -153,7 +153,7 @@ int my_copy(const char *from, const char *to, myf MyFlags) {
       struct utimbuf timep;
       timep.actime = stat_buff.st_atime;
       timep.modtime = stat_buff.st_mtime;
-      (void)utime((char *)to, &timep); /* last accessed and modified times */
+      (void)utime(to, &timep); /* last accessed and modified times */
     }
 
     DBUG_RETURN(0);