← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/internal/default.cc

Merge Stewart.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/internal/default.cc
11
11
 
12
12
   You should have received a copy of the GNU General Public License
13
13
   along with this program; if not, write to the Free Software
14
 
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
15
 
16
16
/****************************************************************************
17
17
 Add all options from files named "group".cnf from the default_directories
38
38
#include "drizzled/internal/my_sys.h"
39
39
#include "drizzled/internal/m_string.h"
40
40
#include "drizzled/charset_info.h"
41
 
#include "drizzled/typelib.h"
42
41
#include <drizzled/configmake.h>
43
42
#include <drizzled/gettext.h>
44
43
 
182
181
    TYPELIB *group= ctx->group;
183
182
 
184
183
    if (!(extra_groups=
185
 
          (const char**)ctx->alloc->alloc_root(
 
184
          (const char**)alloc_root(ctx->alloc,
186
185
                                   (2*group->count+1)*sizeof(char*))))
187
186
      goto err;
188
187
 
192
191
      extra_groups[i]= group->type_names[i]; /** copy group */
193
192
 
194
193
      len= strlen(extra_groups[i]);
195
 
      if (!(ptr= (char *)ctx->alloc->alloc_root( len+instance_len+1)))
 
194
      if (!(ptr= (char *)alloc_root(ctx->alloc, len+instance_len+1)))
196
195
        goto err;
197
196
 
198
197
      extra_groups[i+group->count]= ptr;
288
287
  if (!option)
289
288
    return 0;
290
289
 
291
 
  if (ctx->group->find_type(const_cast<char*>(group_name), 3))
 
290
  if (find_type((char *)group_name, ctx->group, 3))
292
291
  {
293
 
    if (!(tmp= (char *)ctx->alloc->alloc_root(strlen(option) + 1)))
 
292
    if (!(tmp= (char *)alloc_root(ctx->alloc, strlen(option) + 1)))
294
293
      return 1;
295
294
    if (insert_dynamic(ctx->args, (unsigned char*) &tmp))
296
295
      return 1;
325
324
  int org_argc= argc, prev_argc= 0;
326
325
  *defaults= *extra_defaults= *group_suffix= 0;
327
326
 
328
 
  const std::string DEFAULTS_FILE("--defaults-file=");
329
 
  const std::string DEFAULTS_EXTRA_FILE("--defaults-extra-file=");
330
 
  const std::string DEFAULTS_GROUP_SUFFIX("--defaults-group-suffix=");
331
 
 
332
327
  while (argc >= 2 && argc != prev_argc)
333
328
  {
334
329
    /* Skip program name or previously handled argument */
335
330
    argv++;
336
331
    prev_argc= argc;                            /* To check if we found */
337
 
    if (!*defaults && (strncmp(*argv,
338
 
                               DEFAULTS_FILE.c_str(),
339
 
                               DEFAULTS_FILE.size()) == 0))
 
332
    if (!*defaults && (strncmp(*argv,"--defaults-file=", sizeof("--defaults-file=")) == 0))
340
333
    {
341
 
      *defaults= *argv + DEFAULTS_FILE.size();
 
334
      *defaults= *argv + sizeof("--defaults-file=")-1;
342
335
       argc--;
343
336
       continue;
344
337
    }
345
 
    if (!*extra_defaults && (strncmp(*argv, 
346
 
                                     DEFAULTS_EXTRA_FILE.c_str(),
347
 
                                     DEFAULTS_EXTRA_FILE.size()) == 0))
 
338
    if (!*extra_defaults && (strncmp(*argv, "--defaults-extra-file=", sizeof("--defaults-extra-file=")) == 0))
348
339
    {
349
 
      *extra_defaults= *argv + DEFAULTS_EXTRA_FILE.size();
 
340
      *extra_defaults= *argv + sizeof("--defaults-extra-file=")-1;
350
341
      argc--;
351
342
      continue;
352
343
    }
353
 
    if (!*group_suffix && (strncmp(*argv, 
354
 
                                   DEFAULTS_GROUP_SUFFIX.c_str(),
355
 
                                   DEFAULTS_GROUP_SUFFIX.size()) == 0))
356
 
 
 
344
    if (!*group_suffix && (strncmp(*argv, "--defaults-group-suffix=", sizeof("--defaults-group-suffix=")) == 0))
357
345
    {
358
 
      *group_suffix= *argv + DEFAULTS_GROUP_SUFFIX.size();
 
346
      *group_suffix= *argv + sizeof("--defaults-group-suffix=")-1;
359
347
      argc--;
360
348
      continue;
361
349
    }
400
388
{
401
389
  DYNAMIC_ARRAY args;
402
390
  TYPELIB group;
 
391
  bool found_print_defaults= 0;
403
392
  uint32_t args_used= 0;
404
393
  int error= 0;
405
 
  memory::Root alloc(512);
 
394
  memory::Root alloc;
406
395
  char *ptr,**res;
407
396
  struct handle_option_ctx ctx;
408
397
 
409
398
  init_default_directories();
 
399
  init_alloc_root(&alloc,512);
410
400
  /*
411
401
    Check if the user doesn't want any default option processing
412
402
    --no-defaults is always the first option
415
405
  {
416
406
    /* remove the --no-defaults argument and return only the other arguments */
417
407
    uint32_t i;
418
 
    if (!(ptr=(char*) alloc.alloc_root(sizeof(alloc)+ (*argc + 1)*sizeof(char*))))
 
408
    if (!(ptr=(char*) alloc_root(&alloc,sizeof(alloc)+
 
409
                                 (*argc + 1)*sizeof(char*))))
419
410
      goto err;
420
411
    res= (char**) (ptr+sizeof(alloc));
421
412
    memset(res,0,(*argc + 1));
449
440
    Here error contains <> 0 only if we have a fully specified conf_file
450
441
    or a forced default file
451
442
  */
452
 
  if (!(ptr=(char*) alloc.alloc_root(sizeof(alloc)+ (args.elements + *argc +1) *sizeof(char*))))
 
443
  if (!(ptr=(char*) alloc_root(&alloc,sizeof(alloc)+
 
444
                               (args.elements + *argc +1) *sizeof(char*))))
453
445
    goto err;
454
446
  res= (char**) (ptr+sizeof(alloc));
455
447
 
464
456
    Check if we wan't to see the new argument list
465
457
    This options must always be the last of the default options
466
458
  */
 
459
  if (*argc >= 2 && !strcmp(argv[0][1],"--print-defaults"))
 
460
  {
 
461
    found_print_defaults=1;
 
462
    --*argc; ++*argv;                           /* skip argument */
 
463
  }
 
464
 
467
465
  if (*argc)
468
466
    memcpy(res+1+args.elements, *argv + 1, (*argc-1)*sizeof(char*));
469
467
  res[args.elements+ *argc]=0;                  /* last null */
472
470
  *argv= static_cast<char**>(res);
473
471
  *(memory::Root*) ptr= alloc;                  /* Save alloc root for free */
474
472
  delete_dynamic(&args);
475
 
 
 
473
  if (found_print_defaults)
 
474
  {
 
475
    int i;
 
476
    printf("%s would have been started with the following arguments:\n",
 
477
           **argv);
 
478
    for (i=1 ; i < *argc ; i++)
 
479
      printf("%s ", (*argv)[i]);
 
480
    puts("");
 
481
    exit(0);
 
482
  }
476
483
  return(error);
477
484
 
478
485
 err:
485
492
{
486
493
  memory::Root ptr;
487
494
  memcpy(&ptr, (char*) argv - sizeof(ptr), sizeof(ptr));
488
 
  ptr.free_root(MYF(0));
 
495
  free_root(&ptr,MYF(0));
489
496
}
490
497
 
491
498
 
937
944
    }
938
945
  }
939
946
  puts("\nThe following options may be given as the first argument:\n\
 
947
  --print-defaults      Print the program argument list and exit\n\
940
948
  --no-defaults         Don't read default options from any options file\n\
941
949
  --defaults-file=#     Only read default options from the given file #\n\
942
950
  --defaults-extra-file=# Read this file after the global files are read");
946
954
  This extra complexity is to avoid declaring 'rc' if it won't be
947
955
  used.
948
956
*/
949
 
static void add_directory(const char* dir)
950
 
{
951
 
  array_append_string_unique(dir, default_directories, array_elements(default_directories));
952
 
}
953
 
 
954
 
static void add_common_directories()
955
 
{
956
 
  const char *env= getenv("DRIZZLE_HOME"); 
957
 
  if (env) 
958
 
    add_directory(env); 
959
 
  // Placeholder for --defaults-extra-file=<path>
960
 
  add_directory(""); 
961
 
}
 
957
#define ADD_DIRECTORY(DIR)  (void) array_append_string_unique((DIR), default_directories, \
 
958
                             array_elements(default_directories))
 
959
 
 
960
#define ADD_COMMON_DIRECTORIES() \
 
961
  do { \
 
962
    const char *env; \
 
963
    if ((env= getenv("DRIZZLE_HOME"))) \
 
964
      ADD_DIRECTORY(env); \
 
965
    /* Placeholder for --defaults-extra-file=<path> */ \
 
966
    ADD_DIRECTORY(""); \
 
967
  } while (0)
 
968
 
962
969
 
963
970
/**
964
971
  Initialize default directories for Unix
975
982
static void init_default_directories(void)
976
983
{
977
984
  memset(default_directories, 0, sizeof(default_directories));
978
 
  add_directory("/etc/");
979
 
  add_directory("/etc/drizzle/");
980
 
  add_directory(SYSCONFDIR);
981
 
  add_common_directories();
982
 
  add_directory("~/");
 
985
  ADD_DIRECTORY("/etc/");
 
986
  ADD_DIRECTORY("/etc/drizzle/");
 
987
  ADD_DIRECTORY(SYSCONFDIR);
 
988
  ADD_COMMON_DIRECTORIES();
 
989
  ADD_DIRECTORY("~/");
983
990
}
984
991
 
985
992
} /* namespace internal */