Merge lp:~brianaker/drizzle/clang-support into lp:drizzle

[Brian Aker]

[lp:~brianaker/drizzle/clang-support]

2579. By Drizzle Continuous Integration on 2012-08-03

added:
  bootstrap.sh
modified:
  client/drizzletest.cc
  drizzled/field/datetime.cc
  drizzled/filesort.cc
  drizzled/function/time/unix_timestamp.cc
  drizzled/sql_insert.cc
  drizzled/sql_load.cc
  drizzled/sql_union.cc
  drizzled/table/cache.cc
  drizzled/table_function_container.cc
  plugin/logging_query/logging_query.cc
  plugin/schema_engine/schema.cc
pending merge tips: (use -v to see all merge revisions)
  Brian Aker 2012-08-02 Add bootstrap script, and fixes for clang.

2580. By Brian Aker on 2012-08-04

Fixing license on bootsrap.sh file

[Olaf van der Spek (olafvdspek)]

> (void)(ret);

Is stuff like this really necessary?

[Mark Atwood (fallenpegasus)]

On Sat, Aug 4, 2012 at 6:31 AM, Olaf van der Spek <email address hidden> wrote:
>> (void)(ret);
>
> Is stuff like this really necessary?

Do have clang compile without warnings, yes it is.

Otherwise the dataflow analyzer in clang determines that the data
result is unused, and issues a warning.

..m

[Olaf van der Spek (olafvdspek)]

Isn't it used in the assert expression?

[Mark Atwood (fallenpegasus)]

On Sat, Aug 4, 2012 at 9:39 AM, Olaf van der Spek <email address hidden> wrote:
> Isn't it used in the assert expression?

Expressions in assert() are not expanded or evaluated when NDEBUG is defined.

It is a bug to assume that assert() will evaluate, and it's most
certainly a bug to have an assert() expression that has a side
effect.

A good dataflow analyzer knows that assert() should not count as "data
used". Given that clang's DFA is pretty close to state of the
research art, I would guess that it also knows that.

Back when I was programming in Ada, the compiler I was using could
optimize assertation statements, making them test only occasionally,
only on entrance and exit of the loop they where in, only when
something "interesting" happened in the data flow, and so forth.

..m

[Olaf van der Spek (olafvdspek)]

I'm aware of assert semantics. But (void)(ret); doesn't generate any code either. Having to use (void) for all data that's only used in assert expressions doesn't seem (entirely) right.

[lp:~brianaker/drizzle/clang-support]

2581. By Brian Aker on 2012-08-04

Fix type in shell.

=== added file 'bootstrap.sh'
--- bootstrap.sh	1970-01-01 00:00:00 +0000
+++ bootstrap.sh	2012-08-11 15:59:19 +0000
@@ -0,0 +1,44 @@
+#!/bin/bash
+# 
+# Copyright (C) 2012 Brian Aker
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+# 
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+# 
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+# 
+#     * The names of its contributors may not be used to endorse or
+# promote products derived from this software without specific prior
+# written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+if test -f configure; then make clean; make merge-clean; make distclean; fi;
+
+rm -r -f autom4te.cache/ config.h config.log config.status 
+./config/autorun.sh
+if [ $(uname) = "Darwin" ];
+then
+  ./configure CC=clang CXX=clang++ --enable-assert
+else
+  ./configure --enable-assert
+fi
+make
 
=== modified file 'client/drizzletest.cc'
--- client/drizzletest.cc	2012-02-12 06:10:39 +0000
+++ client/drizzletest.cc	2012-08-11 15:59:19 +0000
@@ -734,6 +734,10 @@
       break;
     }
     assert(known_arg_type);
+    if (known_arg_type == false)
+    {
+      die("Bad argument");
+    }
 
     /* Check required arg */
     if (arg->ds->length() == 0 && arg->required)
 
=== modified file 'drizzled/field/datetime.cc'
--- drizzled/field/datetime.cc	2011-06-20 15:04:56 +0000
+++ drizzled/field/datetime.cc	2012-08-11 15:59:19 +0000
@@ -138,6 +138,7 @@
     size_t tmp_string_len;
 
     tmp_string_len= temporal.to_string(tmp_string, type::Time::MAX_STRING_LENGTH);
+    (void)(tmp_string_len);
     assert(tmp_string_len < type::Time::MAX_STRING_LENGTH);
     my_error(ER_INVALID_DATETIME_VALUE, MYF(ME_FATALERROR), tmp_string);
     return 1;
 
=== modified file 'drizzled/filesort.cc'
--- drizzled/filesort.cc	2011-10-24 11:55:49 +0000
+++ drizzled/filesort.cc	2012-08-11 15:59:19 +0000
@@ -859,6 +859,7 @@
               from= tmp_buffer;
             }
             tmp_length= cs->strnxfrm(to,sort_field->length, (unsigned char*) from, length);
+            (void)(tmp_length);
             assert(tmp_length == sort_field->length);
           }
           else
 
=== modified file 'drizzled/function/time/unix_timestamp.cc'
--- drizzled/function/time/unix_timestamp.cc	2011-04-08 13:16:30 +0000
+++ drizzled/function/time/unix_timestamp.cc	2012-08-11 15:59:19 +0000
@@ -70,6 +70,7 @@
     char buff[DateTime::MAX_STRING_LENGTH];
     int buff_len;
     buff_len= temporal.to_string(buff, DateTime::MAX_STRING_LENGTH);
+    (void)(buff_len);
     assert((buff_len+1) < DateTime::MAX_STRING_LENGTH);
     my_error(ER_INVALID_UNIX_TIMESTAMP_VALUE, MYF(0), buff);
     return 0;
 
=== modified file 'drizzled/sql_insert.cc'
--- drizzled/sql_insert.cc	2012-02-12 08:49:06 +0000
+++ drizzled/sql_insert.cc	2012-08-11 15:59:19 +0000
@@ -456,6 +456,7 @@
       if (session->transaction.stmt.hasModifiedNonTransData())
 	session->transaction.all.markModifiedNonTransData();
     }
+    (void)(transactional_table);
     assert(transactional_table || !changed || session->transaction.stmt.hasModifiedNonTransData());
 
   }
@@ -1394,6 +1395,8 @@
 
     changed= (info.copied || info.deleted || info.updated);
     transactional_table= table->cursor->has_transactions();
+    (void)(transactional_table);
+    (void)(changed);
     assert(transactional_table || !changed ||
 		session->transaction.stmt.hasModifiedNonTransData());
     table->cursor->ha_release_auto_increment();
 
=== modified file 'drizzled/sql_load.cc'
--- drizzled/sql_load.cc	2012-07-11 14:06:00 +0000
+++ drizzled/sql_load.cc	2012-08-11 15:59:19 +0000
@@ -412,6 +412,7 @@
 
   session->my_ok(info.copied + info.deleted, 0, 0L, msg);
 err:
+  (void)(transactional_table);
   assert(transactional_table || !(info.copied || info.deleted) ||
               session->transaction.stmt.hasModifiedNonTransData());
   table->cursor->ha_release_auto_increment();
 
=== modified file 'drizzled/sql_union.cc'
--- drizzled/sql_union.cc	2011-08-05 13:28:48 +0000
+++ drizzled/sql_union.cc	2012-08-11 15:59:19 +0000
@@ -294,7 +294,9 @@
       information about fields lengths and exact types
     */
     if (!is_union_select)
+    {
       types= first_sl->item_list;
+    }
     else if (sl == first_sl)
     {
       /*
@@ -303,6 +305,7 @@
         The main reason of this is that we can't create
         field object without table.
       */
+      (void)(empty_table);
       assert(!empty_table);
       empty_table= (Table*) session->mem.calloc(sizeof(Table));
       types.clear();
 
=== modified file 'drizzled/table/cache.cc'
--- drizzled/table/cache.cc	2011-07-06 22:48:32 +0000
+++ drizzled/table/cache.cc	2012-08-11 15:59:19 +0000
@@ -283,6 +283,7 @@
 void Cache::insert(table::Concurrent* arg)
 {
   CacheMap::iterator returnable= cache.insert(std::make_pair(arg->getShare()->getCacheKey(), arg));
+  (void)(returnable);
 	assert(returnable != cache.end());
 }
 
 
=== modified file 'drizzled/table_function_container.cc'
--- drizzled/table_function_container.cc	2011-07-05 15:59:49 +0000
+++ drizzled/table_function_container.cc	2012-08-11 15:59:19 +0000
@@ -45,6 +45,7 @@
 void TableFunctionContainer::addFunction(plugin::TableFunction *tool)
 {
   std::pair<ToolMap::iterator, bool> ret= table_map.insert(std::make_pair(tool->getPath(), tool));
+  (void)(ret);
   assert(ret.second);
 }
 
 
=== modified file 'plugin/logging_query/logging_query.cc'
--- plugin/logging_query/logging_query.cc	2012-06-20 14:17:30 +0000
+++ plugin/logging_query/logging_query.cc	2012-08-11 15:59:19 +0000
@@ -374,6 +374,7 @@
 
     // a single write has a kernel thread lock, thus no need mutex guard this
     wrv= write(fd, msgbuf.c_str(), msgbuf.length());
+    (void)(wrv);
     assert(wrv == msgbuf.length());
 
     return false;
 
=== modified file 'plugin/schema_engine/schema.cc'
--- plugin/schema_engine/schema.cc	2012-07-11 14:06:00 +0000
+++ plugin/schema_engine/schema.cc	2012-08-11 15:59:19 +0000
@@ -102,6 +102,7 @@
       pair<SchemaCache::iterator, bool> ret=
         schema_cache.insert(make_pair(schema_identifier.getPath(), new message::Schema(schema_message)));
 
+      (void)(ret);
       assert(ret.second); // If this has happened, something really bad is going down.
     }
   }
@@ -121,7 +122,9 @@
     drizzled::message::catalog::shared_ptr message;
 
     if (not entry->filename.compare(GLOBAL_TEMPORARY_EXT))
+    {
       continue;
+    }
 
     drizzled::identifier::Catalog identifier(entry->filename);
 
@@ -176,7 +179,7 @@
     schema_cache.insert(make_pair(schema_identifier.getPath(), new message::Schema(schema_message)));
 
   assert(ret.second); // If this has happened, something really bad is going down.
-  return true;
+  return ret.second;
 }
 
 bool Schema::doDropSchema(const identifier::Schema &schema_identifier)
@@ -222,7 +225,9 @@
                                        schema_message.name());
 
   if (access(schema_identifier.getPath().c_str(), F_OK))
+  {
     return false;
+  }
 
   if (writeSchemaFile(schema_identifier, schema_message))
   {
@@ -233,9 +238,10 @@
       schema_cache.insert(make_pair(schema_identifier.getPath(), new message::Schema(schema_message)));
 
     assert(ret.second); // If this has happened, something really bad is going down.
+    return ret.second;
   }
 
-  return true;
+  return false;
 }
 
 /**