Merge lp:~stewart/drizzle/warning-stack-frame-32k into lp:drizzle/7.0

[Stewart Smith]

Fixes up all methods with stack usage > 32k to use less than 32kb of stack.

Before this can be merged, Monty needs to fix up a check in pandora for the GCC warning, as the GCC version on hades is old enough not to have the wonderful option.

http://hudson.drizzle.org/view/Drizzle-param/job/drizzle-param/594/

[Andrew Hutchings (linuxjedi)]

I don't know if it matters, but apparently auto_ptr is deprecated for C++0x. I suspect when that happens this will generate some kind of warning:

http://en.wikipedia.org/wiki/Auto_ptr

[Monty Taylor (mordred)]

I included this in my branch: lp:~mordred/drizzle/warning-stack-frame

[Monty Taylor (mordred)]

And yes - we should not be using auto_ptr, but instead should be using boost::scoped_ptr or boost::shared_ptr.

=== modified file 'client/drizzle.cc'
--- client/drizzle.cc	2010-10-30 01:19:00 +0000
+++ client/drizzle.cc	2010-11-08 13:25:00 +0000
@@ -61,6 +61,7 @@
 #include <cassert>
 #include <stdarg.h>
 #include <math.h>
+#include <memory>
 #include "client/linebuffer.h"
 #include <signal.h>
 #include <sys/ioctl.h>
@@ -1825,7 +1826,7 @@
 void handle_sigint(int sig)
 {
   char kill_buffer[40];
-  drizzle_con_st kill_drizzle;
+  auto_ptr<drizzle_con_st> kill_drizzle(new drizzle_con_st);
   drizzle_result_st res;
   drizzle_return_t ret;
 
@@ -1834,7 +1835,7 @@
     goto err;
   }
 
-  if (drizzle_con_add_tcp(&drizzle, &kill_drizzle, current_host.c_str(),
+  if (drizzle_con_add_tcp(&drizzle, kill_drizzle.get(), current_host.c_str(),
     opt_drizzle_port, current_user.c_str(), opt_password.c_str(), NULL,
     use_drizzle_protocol ? DRIZZLE_CON_EXPERIMENTAL : DRIZZLE_CON_MYSQL) == NULL)
   {
@@ -1845,10 +1846,10 @@
   sprintf(kill_buffer, "KILL /*!50000 QUERY */ %u",
           drizzle_con_thread_id(&con));
 
-  if (drizzle_query_str(&kill_drizzle, &res, kill_buffer, &ret) != NULL)
+  if (drizzle_query_str(kill_drizzle.get(), &res, kill_buffer, &ret) != NULL)
     drizzle_result_free(&res);
 
-  drizzle_con_free(&kill_drizzle);
+  drizzle_con_free(kill_drizzle.get());
   tee_fprintf(stdout, _("Query aborted by Ctrl+C\n"));
 
   interrupted_query= 1;

=== modified file 'client/drizzleslap.cc'
--- client/drizzleslap.cc	2010-11-04 22:54:06 +0000
+++ client/drizzleslap.cc	2010-11-08 13:25:00 +0000
@@ -95,6 +95,7 @@
 #include <iostream>
 #include <fstream>
 #include <drizzled/configmake.h>
+#include <memory>
 
 /* Added this for string translation. */
 #include <drizzled/gettext.h>
@@ -273,7 +274,8 @@
   uint64_t counter= 0, queries;
   uint64_t detach_counter;
   uint32_t commit_counter;
-  drizzle_con_st con;
+  auto_ptr<drizzle_con_st> con_ap(new drizzle_con_st);
+  drizzle_con_st &con= *con_ap.get();
   drizzle_result_st result;
   drizzle_row_t row;
   Statement *ptr;
@@ -536,7 +538,8 @@
     std::string user_config_dir((getenv("XDG_CONFIG_HOME")? getenv("XDG_CONFIG_HOME"):"~/.config"));
 
     uint64_t temp_drizzle_port= 0;
-    drizzle_con_st con;
+    auto_ptr<drizzle_con_st> con_ap(new drizzle_con_st);
+    drizzle_con_st &con= *con_ap.get();
     OptionString *eptr;
 
     // Disable allow_guessing

=== modified file 'examples/pipe_query.c'
--- examples/pipe_query.c	2010-09-28 07:50:05 +0000
+++ examples/pipe_query.c	2010-11-08 13:25:00 +0000
@@ -32,7 +32,7 @@
   size_t buffer_total= 0;
   ssize_t read_size= 0;
   drizzle_st drizzle;
-  drizzle_con_st con;
+  drizzle_con_st *con= (drizzle_con_st*)malloc(sizeof(drizzle_con_st));
   drizzle_result_st result;
   drizzle_return_t ret;
   drizzle_field_t field;
@@ -40,6 +40,12 @@
   size_t size;
   size_t total;
 
+  if (con == NULL)
+  {
+    printf("Failed to allocate memory for drizzle connection");
+    exit(1);
+  }
+
   /* The docs say this might fail, so check for errors. */
   if (drizzle_create(&drizzle) == NULL)
   {
@@ -47,7 +53,7 @@
     exit(1);
   }
 
-  if (drizzle_con_create(&drizzle, &con) == NULL)
+  if (drizzle_con_create(&drizzle, con) == NULL)
   {
     printf("drizzle_con_create:%s\n", drizzle_error(&drizzle));
     exit(1);
@@ -58,7 +64,7 @@
     switch(c)
     {
     case 'd':
-      drizzle_con_set_db(&con, optarg);
+      drizzle_con_set_db(con, optarg);
       break;
 
     case 'h':
@@ -66,7 +72,7 @@
       break;
 
     case 'm':
-      drizzle_con_add_options(&con, DRIZZLE_CON_MYSQL);
+      drizzle_con_add_options(con, DRIZZLE_CON_MYSQL);
       break;
 
     case 'p':
@@ -95,8 +101,8 @@
     }
   }
 
-  drizzle_con_set_tcp(&con, host, port);
-  drizzle_con_set_auth(&con, user, password);
+  drizzle_con_set_tcp(con, host, port);
+  drizzle_con_set_auth(con, user, password);
 
   do
   {
@@ -118,7 +124,7 @@
     buffer_total= buffer_size + BUFFER_CHUNK;
   } while ((read_size= read(0, buffer + buffer_size, BUFFER_CHUNK)) != 0);
 
-  (void)drizzle_query(&con, &result, buffer, buffer_size, &ret);
+  (void)drizzle_query(con, &result, buffer, buffer_size, &ret);
   if (ret != DRIZZLE_RETURN_OK)
   {
     printf("drizzle_query:%s\n", drizzle_error(&drizzle));
@@ -166,8 +172,9 @@
   }
 
   drizzle_result_free(&result);
-  drizzle_con_free(&con);
+  drizzle_con_free(con);
   drizzle_free(&drizzle);
 
+  free(con);
   return 0;
 }

=== modified file 'examples/proxy.c'
--- examples/proxy.c	2010-09-28 07:50:05 +0000
+++ examples/proxy.c	2010-11-08 13:25:00 +0000
@@ -45,9 +45,9 @@
   drizzle_verbose_t verbose= DRIZZLE_VERBOSE_NEVER;
   drizzle_return_t ret;
   drizzle_st drizzle;
-  drizzle_con_st con_listen;
-  drizzle_con_st server;
-  drizzle_con_st client;
+  drizzle_con_st *con_listen= (drizzle_con_st*)malloc(sizeof(drizzle_con_st));
+  drizzle_con_st *server= (drizzle_con_st*)malloc(sizeof(drizzle_con_st));
+  drizzle_con_st *client= (drizzle_con_st*)malloc(sizeof(drizzle_con_st));
   drizzle_result_st server_result;
   drizzle_result_st client_result;
   drizzle_column_st column;
@@ -112,19 +112,19 @@
   drizzle_add_options(&drizzle, DRIZZLE_FREE_OBJECTS);
   drizzle_set_verbose(&drizzle, verbose);
 
-  if (drizzle_con_create(&drizzle, &con_listen) == NULL)
+  if (drizzle_con_create(&drizzle, con_listen) == NULL)
   {
     printf("drizzle_con_create:NULL\n");
     return 1;
   }
 
-  drizzle_con_add_options(&con_listen, DRIZZLE_CON_LISTEN);
-  drizzle_con_set_tcp(&con_listen, server_host, server_port);
+  drizzle_con_add_options(con_listen, DRIZZLE_CON_LISTEN);
+  drizzle_con_set_tcp(con_listen, server_host, server_port);
 
   if (server_mysql)
-    drizzle_con_add_options(&con_listen, DRIZZLE_CON_MYSQL);
+    drizzle_con_add_options(con_listen, DRIZZLE_CON_MYSQL);
 
-  if (drizzle_con_listen(&con_listen) != DRIZZLE_RETURN_OK)
+  if (drizzle_con_listen(con_listen) != DRIZZLE_RETURN_OK)
   {
     printf("drizzle_con_listen:%s\n", drizzle_error(&drizzle));
     return 1;
@@ -132,36 +132,36 @@
 
   while (1)
   {
-    (void)drizzle_con_accept(&drizzle, &server, &ret);
+    (void)drizzle_con_accept(&drizzle, server, &ret);
     if (ret != DRIZZLE_RETURN_OK)
     {
       printf("drizzle_con_accept:%s\n", drizzle_error(&drizzle));
       return 1;
     }
 
-    if (drizzle_con_create(&drizzle, &client) == NULL)
+    if (drizzle_con_create(&drizzle, client) == NULL)
     {
       printf("drizzle_con_create:NULL\n");
       return 1;
     }
 
-    drizzle_con_add_options(&client,
+    drizzle_con_add_options(client,
                             DRIZZLE_CON_RAW_PACKET | DRIZZLE_CON_RAW_SCRAMBLE);
     if (client_mysql)
-      drizzle_con_add_options(&client, DRIZZLE_CON_MYSQL);
-    drizzle_con_set_tcp(&client, client_host, client_port);
+      drizzle_con_add_options(client, DRIZZLE_CON_MYSQL);
+    drizzle_con_set_tcp(client, client_host, client_port);
 
-    ret= drizzle_con_connect(&client);
+    ret= drizzle_con_connect(client);
     if (ret != DRIZZLE_RETURN_OK)
     {
       printf("drizzle_con_connect:%s\n", drizzle_error(&drizzle));
       return 1;
     }
 
-    proxy(&drizzle, &server, &client, &server_result, &client_result, &column);
+    proxy(&drizzle, server, client, &server_result, &client_result, &column);
 
-    drizzle_con_free(&client);
-    drizzle_con_free(&server);
+    drizzle_con_free(client);
+    drizzle_con_free(server);
 
     if (count > 0)
     {
@@ -172,9 +172,13 @@
     }
   }
 
-  drizzle_con_free(&con_listen);
+  drizzle_con_free(con_listen);
   drizzle_free(&drizzle);
 
+  free(con_listen);
+  free(server);
+  free(client);
+
   return 0;
 }
 

=== modified file 'examples/server.c'
--- examples/server.c	2010-09-28 07:50:05 +0000
+++ examples/server.c	2010-11-08 13:25:00 +0000
@@ -43,8 +43,8 @@
   drizzle_verbose_t verbose= DRIZZLE_VERBOSE_NEVER;
   drizzle_return_t ret;
   drizzle_st drizzle;
-  drizzle_con_st con_listen;
-  drizzle_con_st con;
+  drizzle_con_st *con_listen= (drizzle_con_st*)malloc(sizeof(drizzle_con_st));
+  drizzle_con_st *con= (drizzle_con_st*)malloc(sizeof(drizzle_con_st));
   drizzle_result_st result;
   drizzle_column_st column;
 
@@ -93,19 +93,19 @@
   drizzle_add_options(&drizzle, DRIZZLE_FREE_OBJECTS);
   drizzle_set_verbose(&drizzle, verbose);
 
-  if (drizzle_con_create(&drizzle, &con_listen) == NULL)
+  if (drizzle_con_create(&drizzle, con_listen) == NULL)
   {
     printf("drizzle_con_create:NULL\n");
     return 1;
   }
 
-  drizzle_con_add_options(&con_listen, DRIZZLE_CON_LISTEN);
-  drizzle_con_set_tcp(&con_listen, host, port);
+  drizzle_con_add_options(con_listen, DRIZZLE_CON_LISTEN);
+  drizzle_con_set_tcp(con_listen, host, port);
 
   if (mysql)
-    drizzle_con_add_options(&con_listen, DRIZZLE_CON_MYSQL);
+    drizzle_con_add_options(con_listen, DRIZZLE_CON_MYSQL);
 
-  if (drizzle_con_listen(&con_listen) != DRIZZLE_RETURN_OK)
+  if (drizzle_con_listen(con_listen) != DRIZZLE_RETURN_OK)
   {
     printf("drizzle_con_listen:%s\n", drizzle_error(&drizzle));
     return 1;
@@ -113,16 +113,16 @@
 
   while (1)
   {
-    (void)drizzle_con_accept(&drizzle, &con, &ret);
+    (void)drizzle_con_accept(&drizzle, con, &ret);
     if (ret != DRIZZLE_RETURN_OK)
     {
       printf("drizzle_con_accept:%s\n", drizzle_error(&drizzle));
       return 1;
     }
 
-    server(&drizzle, &con, &result, &column);
+    server(&drizzle, con, &result, &column);
 
-    drizzle_con_free(&con);
+    drizzle_con_free(con);
 
     if (count > 0)
     {
@@ -133,9 +133,12 @@
     }
   }
 
-  drizzle_con_free(&con_listen);
+  drizzle_con_free(con_listen);
   drizzle_free(&drizzle);
 
+  free(con);
+  free(con_listen);
+
   return 0;
 }
 

=== modified file 'examples/simple.c'
--- examples/simple.c	2010-09-28 07:50:05 +0000
+++ examples/simple.c	2010-11-08 13:25:00 +0000
@@ -27,7 +27,7 @@
   const char *query= "SELECT TABLE_SCHEMA,TABLE_NAME FROM TABLES";
   drizzle_verbose_t verbose= DRIZZLE_VERBOSE_NEVER;
   drizzle_st drizzle;
-  drizzle_con_st con;
+  drizzle_con_st *con= (drizzle_con_st*)malloc(sizeof(drizzle_con_st));
   drizzle_result_st result;
   drizzle_return_t ret;
   int x;
@@ -82,29 +82,29 @@
 
   drizzle_set_verbose(&drizzle, verbose);
 
-  if (drizzle_con_create(&drizzle, &con) == NULL)
+  if (drizzle_con_create(&drizzle, con) == NULL)
   {
     printf("drizzle_con_create:NULL\n");
     return 1;
   }
 
   if (mysql)
-    drizzle_con_add_options(&con, DRIZZLE_CON_MYSQL);
-
-  drizzle_con_set_tcp(&con, host, port);
-  drizzle_con_set_db(&con, db);
-
-  (void)drizzle_query_str(&con, &result, query, &ret);
+    drizzle_con_add_options(con, DRIZZLE_CON_MYSQL);
+
+  drizzle_con_set_tcp(con, host, port);
+  drizzle_con_set_db(con, db);
+
+  (void)drizzle_query_str(con, &result, query, &ret);
   if (ret != DRIZZLE_RETURN_OK)
   {
-    printf("drizzle_query:%s\n", drizzle_con_error(&con));
+    printf("drizzle_query:%s\n", drizzle_con_error(con));
     return 1;
   }
 
   ret= drizzle_result_buffer(&result);
   if (ret != DRIZZLE_RETURN_OK)
   {
-    printf("drizzle_result_buffer:%s\n", drizzle_con_error(&con));
+    printf("drizzle_result_buffer:%s\n", drizzle_con_error(con));
     return 1;
   }
 
@@ -116,8 +116,9 @@
   }
 
   drizzle_result_free(&result);
-  drizzle_con_free(&con);
+  drizzle_con_free(con);
   drizzle_free(&drizzle);
 
+  free(con);
   return 0;
 }

=== modified file 'examples/simple_multi.c'
--- examples/simple_multi.c	2010-09-28 07:50:05 +0000
+++ examples/simple_multi.c	2010-11-08 13:25:00 +0000
@@ -10,6 +10,7 @@
 
 #include <stdio.h>
 #include <string.h>
+#include <stdlib.h>
 
 #include <libdrizzle/drizzle_client.h>
 
@@ -19,13 +20,17 @@
 {
   const char *query= "SELECT table_schema,table_name FROM tables";
   drizzle_st drizzle;
-  drizzle_con_st con[SIMPLE_MULTI_COUNT];
-  drizzle_result_st result[SIMPLE_MULTI_COUNT];
-  drizzle_query_st ql[SIMPLE_MULTI_COUNT];
+  drizzle_con_st *con;
+  drizzle_result_st *result;
+  drizzle_query_st *ql;
   drizzle_return_t ret;
   drizzle_row_t row;
   int x;
 
+  con= (drizzle_con_st*)malloc(sizeof(drizzle_con_st) * SIMPLE_MULTI_COUNT);
+  result= (drizzle_result_st*)malloc(sizeof(drizzle_result_st) * SIMPLE_MULTI_COUNT);
+  ql= (drizzle_query_st*)malloc(sizeof(drizzle_query_st) * SIMPLE_MULTI_COUNT);
+
   if (drizzle_create(&drizzle) == NULL)
   {
     printf("drizzle_create:NULL\n");
@@ -92,5 +97,8 @@
 
   drizzle_free(&drizzle);
 
+  free(con);
+  free(result);
+  free(ql);
   return 0;
 }

=== modified file 'examples/sqlite_server.c'
--- examples/sqlite_server.c	2010-09-28 07:50:05 +0000
+++ examples/sqlite_server.c	2010-11-08 13:25:00 +0000
@@ -66,11 +66,11 @@
   bool mysql= false;
   in_port_t port= 0;
   drizzle_return_t ret;
-  sqlite_server server;
-  drizzle_con_st con_listen;
+  sqlite_server *server= (sqlite_server*)malloc(sizeof(sqlite_server));
+  drizzle_con_st *con_listen= (drizzle_con_st*)malloc(sizeof(drizzle_con_st));
 
-  server.db= NULL;
-  server.verbose= DRIZZLE_VERBOSE_NEVER;
+  server->db= NULL;
+  server->verbose= DRIZZLE_VERBOSE_NEVER;
 
   while((c = getopt(argc, argv, "c:h:mp:v")) != -1)
   {
@@ -93,7 +93,7 @@
       break;
 
     case 'v':
-      server.verbose++;
+      server->verbose++;
       break;
 
     default:
@@ -108,52 +108,52 @@
     return 1;
   }
 
-  sqlite3_open(argv[optind], &(server.db));
-  if (server.db == NULL)
+  sqlite3_open(argv[optind], &(server->db));
+  if (server->db == NULL)
   {
     printf("sqlite3_open: could not open sqlite3 db\n");
     return 1;
   }
 
-  if (drizzle_create(&server.drizzle) == NULL)
+  if (drizzle_create(&(server->drizzle)) == NULL)
   {
     printf("drizzle_create:NULL\n");
     return 1;
   }
 
-  drizzle_add_options(&server.drizzle, DRIZZLE_FREE_OBJECTS);
-  drizzle_set_verbose(&server.drizzle, server.verbose);
+  drizzle_add_options(&(server->drizzle), DRIZZLE_FREE_OBJECTS);
+  drizzle_set_verbose(&(server->drizzle), server->verbose);
 
-  if (drizzle_con_create(&server.drizzle, &con_listen) == NULL)
+  if (drizzle_con_create(&(server->drizzle), con_listen) == NULL)
   {
     printf("drizzle_con_create:NULL\n");
     return 1;
   }
 
-  drizzle_con_add_options(&con_listen, DRIZZLE_CON_LISTEN);
-  drizzle_con_set_tcp(&con_listen, host, port);
+  drizzle_con_add_options(con_listen, DRIZZLE_CON_LISTEN);
+  drizzle_con_set_tcp(con_listen, host, port);
 
   if (mysql)
-    drizzle_con_add_options(&con_listen, DRIZZLE_CON_MYSQL);
+    drizzle_con_add_options(con_listen, DRIZZLE_CON_MYSQL);
 
-  if (drizzle_con_listen(&con_listen) != DRIZZLE_RETURN_OK)
+  if (drizzle_con_listen(con_listen) != DRIZZLE_RETURN_OK)
   {
-    printf("drizzle_con_listen:%s\n", drizzle_error(&server.drizzle));
+    printf("drizzle_con_listen:%s\n", drizzle_error(&(server->drizzle)));
     return 1;
   }
 
   while (1)
   {
-    (void)drizzle_con_accept(&server.drizzle, &server.con, &ret);
+    (void)drizzle_con_accept(&(server->drizzle), &(server->con), &ret);
     if (ret != DRIZZLE_RETURN_OK)
     {
-      printf("drizzle_con_accept:%s\n", drizzle_error(&server.drizzle));
+      printf("drizzle_con_accept:%s\n", drizzle_error(&(server->drizzle)));
       return 1;
     }
 
-    server_run(&server);
+    server_run(server);
 
-    drizzle_con_free(&server.con);
+    drizzle_con_free(&(server->con));
 
     if (count > 0)
     {
@@ -164,9 +164,11 @@
     }
   }
 
-  drizzle_con_free(&con_listen);
-  drizzle_free(&server.drizzle);
-  sqlite3_close(server.db);
+  drizzle_con_free(con_listen);
+  drizzle_free(&(server->drizzle));
+  sqlite3_close(server->db);
+  free(con_listen);
+  free(server);
 
   return 0;
 }
@@ -308,7 +310,7 @@
   sqlite_server *server= (sqlite_server *)data;
   drizzle_return_t ret;
   int x;
-  size_t sizes[8192];
+  size_t *sizes= (size_t*)malloc(sizeof(size_t)*8192);
 
   if (server->send_columns == true)
   {
@@ -375,6 +377,8 @@
 
   server->rows++;
 
+  free(sizes);
+
   return 0;
 }
 

=== modified file 'm4/pandora_warnings.m4'
--- m4/pandora_warnings.m4	2010-10-07 05:19:48 +0000
+++ m4/pandora_warnings.m4	2010-11-08 13:25:00 +0000
@@ -209,7 +209,7 @@
         [ac_cv_safe_to_use_Wextra_=no])
       CFLAGS="$save_CFLAGS"])
 
-      BASE_WARNINGS="${W_FAIL} -pedantic -Wall -Wundef -Wshadow ${NO_UNUSED} ${F_DIAGNOSTICS_SHOW_OPTION} ${BASE_WARNINGS_FULL}"
+      BASE_WARNINGS="${W_FAIL} -pedantic -Wall -Wundef -Wshadow -Wframe-larger-than=32768 ${NO_UNUSED} ${F_DIAGNOSTICS_SHOW_OPTION} ${BASE_WARNINGS_FULL}"
       AS_IF([test "$ac_cv_safe_to_use_Wextra_" = "yes"],
             [BASE_WARNINGS="${BASE_WARNINGS} -Wextra"],
             [BASE_WARNINGS="${BASE_WARNINGS} -W"])

=== modified file 'plugin/archive/archive_performance.cc'
--- plugin/archive/archive_performance.cc	2010-06-02 21:32:27 +0000
+++ plugin/archive/archive_performance.cc	2010-11-08 13:25:00 +0000
@@ -23,6 +23,7 @@
 #include <string.h>
 #include <fcntl.h>
 #include <sys/stat.h>
+#include <memory>
 
 #if TIME_WITH_SYS_TIME
 # include <sys/time.h>
@@ -67,7 +68,8 @@
   for (method= AZ_METHOD_BLOCK; method < AZ_METHOD_MAX; method++)
   {
     unsigned int ret;
-    azio_stream reader_handle;
+    std::auto_ptr<azio_stream> reader_handle_ap(new azio_stream);
+    azio_stream &reader_handle= *reader_handle_ap.get();
 
     if (method)
       printf("Performing azio_read() test\n");
@@ -97,7 +99,8 @@
 
 static int generate_data(uint64_t rows_to_test)
 {
-  azio_stream writer_handle;
+  std::auto_ptr<azio_stream> writer_handle_ap(new azio_stream);
+  azio_stream &writer_handle= *writer_handle_ap.get();
   uint64_t x;
   unsigned int ret;
   struct timeval start_time, end_time;

=== modified file 'plugin/archive/archive_reader.cc'
--- plugin/archive/archive_reader.cc	2010-08-20 02:23:54 +0000
+++ plugin/archive/archive_reader.cc	2010-11-08 13:25:00 +0000
@@ -32,6 +32,7 @@
 #include <stdio.h>
 #include <stdarg.h>
 #include <fcntl.h>
+#include <memory>
 #include "drizzled/charset_info.h"
 #include "drizzled/internal/m_string.h"
 
@@ -85,7 +86,8 @@
   ;
 
   unsigned int ret;
-  azio_stream reader_handle;
+  std::auto_ptr<azio_stream> reader_handle_ap(new azio_stream);
+  azio_stream &reader_handle= *reader_handle_ap.get();
 
   std::string system_config_dir_archive_reader(SYSCONFDIR); 
   system_config_dir_archive_reader.append("/drizzle/archive_reader.cnf");
@@ -155,7 +157,8 @@
 
   if (opt_autoincrement)
   {
-    azio_stream writer_handle;
+    std::auto_ptr<azio_stream> writer_handle_ap(new azio_stream);
+    azio_stream &writer_handle= *writer_handle_ap.get();
 
     if (new_auto_increment_value)
     {
@@ -252,7 +255,8 @@
     uint64_t row_count= 0;
     char *buffer;
 
-    azio_stream writer_handle;
+    std::auto_ptr<azio_stream> writer_handle_ap(new azio_stream);
+    azio_stream &writer_handle= *writer_handle_ap.get();
 
     buffer= (char *)malloc(reader_handle.longest_row);
     if (buffer == NULL)

=== modified file 'plugin/archive/archive_test.cc'
--- plugin/archive/archive_test.cc	2010-06-02 21:32:27 +0000
+++ plugin/archive/archive_test.cc	2010-11-08 13:25:00 +0000
@@ -22,6 +22,7 @@
 #include <fcntl.h>
 #include <unistd.h>
 #include <cstdlib>
+#include <memory>
 
 #if TIME_WITH_SYS_TIME
 # include <sys/time.h>
@@ -111,7 +112,10 @@
   int error;
   unsigned int x;
   int written_rows= 0;
-  azio_stream writer_handle, reader_handle;
+  std::auto_ptr<azio_stream> writer_handle_ap(new azio_stream);
+  std::auto_ptr<azio_stream> reader_handle_ap(new azio_stream);
+  azio_stream &writer_handle= *writer_handle_ap.get();
+  azio_stream &reader_handle= *reader_handle_ap.get();
 
   memcpy(test_string, TEST_STRING_INIT, 1024);
 
@@ -285,7 +289,10 @@
 int size_test(uint64_t length, uint64_t rows_to_test_for,
               az_method method)
 {
-  azio_stream writer_handle, reader_handle;
+  std::auto_ptr<azio_stream> writer_handle_ap(new azio_stream);
+  std::auto_ptr<azio_stream> reader_handle_ap(new azio_stream);
+  azio_stream &writer_handle= *writer_handle_ap.get();
+  azio_stream &reader_handle= *reader_handle_ap.get();
   uint64_t write_length;
   uint64_t read_length;
   uint64_t count;

=== modified file 'plugin/archive/concurrency_test.cc'
--- plugin/archive/concurrency_test.cc	2010-06-02 21:32:27 +0000
+++ plugin/archive/concurrency_test.cc	2010-11-08 13:25:00 +0000
@@ -37,6 +37,7 @@
 #ifndef __WIN__
 #include <sys/wait.h>
 #endif
+#include <memory>
 
 #ifdef __WIN__
 #define srandom  srand
@@ -136,7 +137,8 @@
 {
   unsigned int x;
   uint64_t total;
-  azio_stream writer_handle;
+  std::auto_ptr<azio_stream> writer_handle_ap(new azio_stream);
+  azio_stream &writer_handle= *writer_handle_ap.get();
   thread_context_st *context;
   pthread_t mainthread;            /* Thread descriptor */
   pthread_attr_t attr;          /* Thread attributes */
@@ -263,7 +265,8 @@
   uint64_t count;
   int ret;
   int error;
-  azio_stream reader_handle;
+  std::auto_ptr<azio_stream> reader_handle_ap(new azio_stream);
+  azio_stream &reader_handle= *reader_handle_ap.get();
 
   if (!(ret= azopen(&reader_handle, TEST_FILENAME, O_RDONLY,
                     context->use_aio)))

=== modified file 'plugin/archive/ha_archive.cc'
--- plugin/archive/ha_archive.cc	2010-10-30 01:19:00 +0000
+++ plugin/archive/ha_archive.cc	2010-11-08 13:25:00 +0000
@@ -18,6 +18,7 @@
 #include "config.h"
 
 #include "plugin/archive/archive_engine.h"
+#include <memory>
 
 using namespace std;
 using namespace drizzled;
@@ -164,24 +165,24 @@
     error= EEXIST;
 
   {
-    azio_stream proto_stream;
+    auto_ptr<azio_stream> proto_stream(new azio_stream);
     char* proto_string;
-    if (azopen(&proto_stream, proto_path.c_str(), O_RDONLY, AZ_METHOD_BLOCK) == 0)
+    if (azopen(proto_stream.get(), proto_path.c_str(), O_RDONLY, AZ_METHOD_BLOCK) == 0)
       return HA_ERR_CRASHED_ON_USAGE;
 
-    proto_string= (char*)malloc(sizeof(char) * proto_stream.frm_length);
+    proto_string= (char*)malloc(sizeof(char) * proto_stream->frm_length);
     if (proto_string == NULL)
     {
-      azclose(&proto_stream);
+      azclose(proto_stream.get());
       return ENOMEM;
     }
 
-    azread_frm(&proto_stream, proto_string);
+    azread_frm(proto_stream.get(), proto_string);
 
-    if (table_proto.ParseFromArray(proto_string, proto_stream.frm_length) == false)
+    if (table_proto.ParseFromArray(proto_string, proto_stream->frm_length) == false)
       error= HA_ERR_CRASHED_ON_USAGE;
 
-    azclose(&proto_stream);
+    azclose(proto_stream.get());
     free(proto_string);
   }
 
@@ -259,7 +260,7 @@
 
 bool ArchiveShare::prime(uint64_t *auto_increment)
 {
-  azio_stream archive_tmp;
+  auto_ptr<azio_stream> archive_tmp(new azio_stream);
 
   /*
     We read the meta file, but do not mark it dirty. Since we are not
@@ -267,19 +268,19 @@
     anything but reading... open it for write and we will generate null
     compression writes).
   */
-  if (!(azopen(&archive_tmp, data_file_name.c_str(), O_RDONLY,
+  if (!(azopen(archive_tmp.get(), data_file_name.c_str(), O_RDONLY,
                AZ_METHOD_BLOCK)))
     return false;
 
-  *auto_increment= archive_tmp.auto_increment + 1;
-  rows_recorded= (ha_rows)archive_tmp.rows;
-  crashed= archive_tmp.dirty;
+  *auto_increment= archive_tmp->auto_increment + 1;
+  rows_recorded= (ha_rows)archive_tmp->rows;
+  crashed= archive_tmp->dirty;
   if (version < global_version)
   {
     version_rows= rows_recorded;
     version= global_version;
   }
-  azclose(&archive_tmp);
+  azclose(archive_tmp.get());
 
   return true;
 }
@@ -501,7 +502,7 @@
                                  drizzled::message::Table& proto)
 {
   int error= 0;
-  azio_stream create_stream;            /* Archive file we are working with */
+  auto_ptr<azio_stream> create_stream(new azio_stream);
   uint64_t auto_increment_value;
   string serialized_proto;
 
@@ -528,7 +529,7 @@
   named_file.append(ARZ);
 
   errno= 0;
-  if (azopen(&create_stream, named_file.c_str(), O_CREAT|O_RDWR,
+  if (azopen(create_stream.get(), named_file.c_str(), O_CREAT|O_RDWR,
              AZ_METHOD_BLOCK) == 0)
   {
     error= errno;
@@ -547,7 +548,7 @@
     return(error ? error : -1);
   }
 
-  if (azwrite_frm(&create_stream, serialized_proto.c_str(),
+  if (azwrite_frm(create_stream.get(), serialized_proto.c_str(),
                   serialized_proto.length()))
   {
     unlink(named_file.c_str());
@@ -559,7 +560,7 @@
   {
     int write_length;
 
-    write_length= azwrite_comment(&create_stream,
+    write_length= azwrite_comment(create_stream.get(),
                                   proto.options().comment().c_str(),
                                   proto.options().comment().length());
 
@@ -576,10 +577,10 @@
     Yes you need to do this, because the starting value
     for the autoincrement may not be zero.
   */
-  create_stream.auto_increment= auto_increment_value ?
+  create_stream->auto_increment= auto_increment_value ?
     auto_increment_value - 1 : 0;
 
-  if (azclose(&create_stream))
+  if (azclose(create_stream.get()))
   {
     error= errno;
     unlink(named_file.c_str());
@@ -949,7 +950,7 @@
 int ha_archive::optimize()
 {
   int rc= 0;
-  azio_stream writer;
+  auto_ptr<azio_stream> writer(new azio_stream);
 
   init_archive_reader();
 
@@ -972,13 +973,13 @@
   std::string writer_filename= share->table_name;
   writer_filename.append(ARN);
 
-  if (!(azopen(&writer, writer_filename.c_str(), O_CREAT|O_RDWR, AZ_METHOD_BLOCK)))
+  if (!(azopen(writer.get(), writer_filename.c_str(), O_CREAT|O_RDWR, AZ_METHOD_BLOCK)))
   {
     free(proto_string);
     return(HA_ERR_CRASHED_ON_USAGE);
   }
 
-  azwrite_frm(&writer, proto_string, archive.frm_length);
+  azwrite_frm(writer.get(), proto_string, archive.frm_length);
 
   /*
     An extended rebuild is a lot more effort. We open up each row and re-record it.
@@ -1016,7 +1017,7 @@
         if (rc != 0)
           break;
 
-        real_write_row(getTable()->getInsertRecord(), &writer);
+        real_write_row(getTable()->getInsertRecord(), writer.get());
         /*
           Long term it should be possible to optimize this so that
           it is not called on each row.
@@ -1036,7 +1037,7 @@
               (share->archive_write.auto_increment= auto_value) + 1;
         }
       }
-      share->rows_recorded= (ha_rows)writer.rows;
+      share->rows_recorded= (ha_rows)writer->rows;
     }
 
     if (rc && rc != HA_ERR_END_OF_FILE)
@@ -1045,7 +1046,7 @@
     }
   }
 
-  azclose(&writer);
+  azclose(writer.get());
   share->dirty= false;
 
   azclose(&archive);
@@ -1057,7 +1058,7 @@
   return(rc);
 error:
   free(proto_string);
-  azclose(&writer);
+  azclose(writer.get());
 
   return(rc);
 }

=== modified file 'plugin/innobase/row/row0merge.c'
--- plugin/innobase/row/row0merge.c	2010-10-13 05:47:19 +0000
+++ plugin/innobase/row/row0merge.c	2010-11-08 13:25:00 +0000
@@ -1395,7 +1395,7 @@
 {
 	mem_heap_t*	heap;	/*!< memory heap for offsets0, offsets1 */
 
-	mrec_buf_t	buf[3];	/*!< buffer for handling split mrec in block[] */
+	mrec_buf_t	*buf;	/*!< buffer for handling split mrec in block[] */
 	const byte*	b0;	/*!< pointer to block[0] */
 	const byte*	b1;	/*!< pointer to block[1] */
 	byte*		b2;	/*!< pointer to block[2] */
@@ -1417,6 +1417,8 @@
 
 	heap = row_merge_heap_create(index, &offsets0, &offsets1);
 
+        buf = mem_heap_alloc(heap, sizeof(mrec_buf_t) * 3);
+
 	/* Write a record and read the next record.  Split the output
 	file in two halves, which can be merged on the following pass. */
 
@@ -1501,7 +1503,7 @@
 {
 	mem_heap_t*	heap;	/*!< memory heap for offsets0, offsets1 */
 
-	mrec_buf_t	buf[3];	/*!< buffer for handling
+	mrec_buf_t	*buf;	/*!< buffer for handling
 				split mrec in block[] */
 	const byte*	b0;	/*!< pointer to block[0] */
 	byte*		b2;	/*!< pointer to block[2] */
@@ -1521,6 +1523,8 @@
 
 	heap = row_merge_heap_create(index, &offsets0, &offsets1);
 
+        buf = mem_heap_alloc(heap, sizeof(mrec_buf_t) * 3);
+
 	/* Write a record and read the next record.  Split the output
 	file in two halves, which can be merged on the following pass. */
 

=== modified file 'plugin/logging_gearman/logging_gearman.cc'
--- plugin/logging_gearman/logging_gearman.cc	2010-08-17 15:33:10 +0000
+++ plugin/logging_gearman/logging_gearman.cc	2010-11-08 13:25:00 +0000
@@ -31,6 +31,7 @@
 #include <fcntl.h>
 #include <cstdio>
 #include <cerrno>
+#include <memory>
 
 using namespace drizzled;
 namespace po= boost::program_options;
@@ -226,7 +227,7 @@
 
   virtual bool post(Session *session)
   {
-    char msgbuf[MAX_MSG_LEN];
+    std::auto_ptr<char> msgbuf(new char[MAX_MSG_LEN]);
     int msgbuf_len= 0;
   
     assert(session != NULL);
@@ -251,7 +252,7 @@
     const char *dbs= session->db.empty() ? "" : session->db.c_str();
   
     msgbuf_len=
-      snprintf(msgbuf, MAX_MSG_LEN,
+      snprintf(msgbuf.get(), MAX_MSG_LEN,
                "%"PRIu64",%"PRIu64",%"PRIu64",\"%.*s\",\"%s\",\"%.*s\","
                "%"PRIu64",%"PRIu64",%"PRIu64",%"PRIu64",%"PRIu64","
                "%"PRIu32",%"PRIu32",%"PRIu32",\"%s\"",
@@ -284,7 +285,7 @@
     (void) gearman_client_do_background(&gearman_client,
                                         sysvar_logging_gearman_function,
                                         NULL,
-                                        (void *) msgbuf,
+                                        (void *) msgbuf.get(),
                                         (size_t) msgbuf_len,
                                         job_handle);
   

=== modified file 'plugin/myisam/ha_myisam.cc'
--- plugin/myisam/ha_myisam.cc	2010-10-25 20:36:07 +0000
+++ plugin/myisam/ha_myisam.cc	2010-11-08 13:25:00 +0000
@@ -41,6 +41,7 @@
 #include <sstream>
 #include <map>
 #include <algorithm>
+#include <memory>
 #include <boost/program_options.hpp>
 #include <drizzled/module/option_map.h>
 
@@ -902,7 +903,8 @@
   else if (mode == HA_KEY_SWITCH_NONUNIQ_SAVE)
   {
     Session *session= getTable()->in_use;
-    MI_CHECK param;
+    auto_ptr<MI_CHECK> param_ap(new MI_CHECK);
+    MI_CHECK &param= *param_ap.get();
     const char *save_proc_info= session->get_proc_info();
     session->set_proc_info("Creating index");
     myisamchk_init(&param);

=== modified file 'plugin/myisam/mi_open.cc'
--- plugin/myisam/mi_open.cc	2010-10-06 20:34:11 +0000
+++ plugin/myisam/mi_open.cc	2010-11-08 13:25:00 +0000
@@ -19,6 +19,7 @@
 
 #include <string.h>
 #include <algorithm>
+#include <memory>
 
 #include "drizzled/charset_info.h"
 #include "drizzled/internal/m_string.h"
@@ -86,8 +87,11 @@
   unsigned char *disk_cache= NULL;
   unsigned char *disk_pos, *end_pos;
   MI_INFO info,*m_info,*old_info;
-  MYISAM_SHARE share_buff,*share;
-  ulong rec_per_key_part[HA_MAX_POSSIBLE_KEY*MI_MAX_KEY_SEG];
+  auto_ptr<MYISAM_SHARE> share_buff_ap(new MYISAM_SHARE);
+  MYISAM_SHARE &share_buff= *share_buff_ap.get();
+  MYISAM_SHARE *share;
+  auto_ptr<ulong> rec_per_key_part_ap(new ulong[HA_MAX_POSSIBLE_KEY*MI_MAX_KEY_SEG]);
+  ulong *rec_per_key_part= rec_per_key_part_ap.get();
   internal::my_off_t key_root[HA_MAX_POSSIBLE_KEY],key_del[MI_MAX_KEY_BLOCK_SIZE];
   uint64_t max_key_file_length, max_data_file_length;
 

=== modified file 'plugin/pbms/src/backup_ms.cc'
--- plugin/pbms/src/backup_ms.cc	2010-10-18 21:21:20 +0000
+++ plugin/pbms/src/backup_ms.cc	2010-11-08 13:25:00 +0000
@@ -469,10 +469,11 @@
 		uint8_t				blob_storage_type;
 		uint16_t				tab_index;
 		uint32_t				mod_time;
-		char				transferBuffer[MS_BACKUP_BUFFER_SIZE];
+		char				*transferBuffer;
 		CloudKeyRec			cloud_key;
 
-	
+                transferBuffer= (char*)malloc(MS_BACKUP_BUFFER_SIZE);
+
 		bu_BackupRunning = true;
 		bu_State = BU_RUNNING; 
 
@@ -684,7 +685,8 @@
 			bu_State = BU_TERMINATED; 
 		else
 			bu_State = BU_COMPLETED; 
-			
+
+                free(transferBuffer);
 	}	
 	
 	catch_(a) {

=== modified file 'plugin/pbms/src/trans_log_ms.cc'
--- plugin/pbms/src/trans_log_ms.cc	2010-10-02 21:15:42 +0000
+++ plugin/pbms/src/trans_log_ms.cc	2010-11-08 13:25:00 +0000
@@ -211,11 +211,11 @@
 		log_size = DFLT_TRANS_LOG_LIST_SIZE * sizeof(MSDiskTransRec) + sizeof(MSDiskTransHeadRec);
 
 		// Preallocate the log space and initialize it.
-		MSDiskTransRec recs[1024] = {};
+                MSDiskTransRec *recs= (MSDiskTransRec*)calloc(1024, sizeof(MSDiskTransRec));
 		off64_t offset = sizeof(MSDiskTransHeadRec);
 		uint64_t num_records = DFLT_TRANS_LOG_LIST_SIZE;
 		size_t size;
-		
+
 		while (num_records) {
 			if (num_records < 1024)
 				size = num_records;
@@ -226,6 +226,8 @@
 			num_records -= size;
 		}
 
+                free(recs);
+
 		trans->txn_MaxRecords = DFLT_TRANS_LOG_LIST_SIZE;
 		trans->txn_ReqestedMaxRecords = DFLT_TRANS_LOG_LIST_SIZE;
 		trans->txn_MaxCheckPoint = DFLT_TRANS_CHECKPOINT_THRESHOLD;