← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysys/default.cc

  • Committer: Brian Aker
  • Date: 2009-01-24 09:43:35 UTC
  • Revision ID: brian@gir-3.local-20090124094335-6qdtvc35gl5fvivz
Adding in an example singe thread scheduler

Show diffs side-by-side

added added

removed removed

Lines of Context:
mysys/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
33
33
 --print-defaults         ; Print the modified command line and exit
34
34
****************************************************************************/
35
35
 
36
 
#include "config.h"
37
 
 
38
 
#include "drizzled/internal/my_sys.h"
39
 
#include "drizzled/internal/m_string.h"
40
 
#include "drizzled/charset_info.h"
 
36
#include "mysys_priv.h"
 
37
#include <mystrings/m_string.h>
 
38
#include <mystrings/m_ctype.h>
 
39
#include <mysys/my_dir.h>
41
40
#include <drizzled/configmake.h>
42
 
#include <drizzled/gettext.h>
43
 
 
44
 
#include "drizzled/cached_directory.h"
45
 
 
46
 
#ifdef HAVE_SYS_STAT_H
47
 
# include <sys/stat.h>
48
 
#endif
49
 
 
50
 
#include <cstdio>
51
 
#include <algorithm>
52
 
 
53
 
using namespace std;
54
 
 
55
 
namespace drizzled
56
 
{
57
 
namespace internal
58
 
{
 
41
 
 
42
#include <stdio.h>
59
43
 
60
44
const char *my_defaults_file=0;
61
45
const char *my_defaults_group_suffix=0;
80
64
 
81
65
struct handle_option_ctx
82
66
{
83
 
   memory::Root *alloc;
 
67
   MEM_ROOT *alloc;
84
68
   DYNAMIC_ARRAY *args;
85
69
   TYPELIB *group;
86
70
};
175
159
    /* Handle --defaults-group-suffix= */
176
160
    uint32_t i;
177
161
    const char **extra_groups;
178
 
    const size_t instance_len= strlen(my_defaults_group_suffix);
 
162
    const uint32_t instance_len= strlen(my_defaults_group_suffix);
179
163
    struct handle_option_ctx *ctx= (struct handle_option_ctx*) func_ctx;
180
164
    char *ptr;
181
165
    TYPELIB *group= ctx->group;
182
166
 
183
167
    if (!(extra_groups=
184
 
          (const char**)ctx->alloc->alloc_root(
 
168
          (const char**)alloc_root(ctx->alloc,
185
169
                                   (2*group->count+1)*sizeof(char*))))
186
170
      goto err;
187
171
 
188
172
    for (i= 0; i < group->count; i++)
189
173
    {
190
 
      size_t len;
 
174
      uint32_t len;
191
175
      extra_groups[i]= group->type_names[i]; /** copy group */
192
176
 
193
177
      len= strlen(extra_groups[i]);
194
 
      if (!(ptr= (char *)ctx->alloc->alloc_root( len+instance_len+1)))
 
178
      if (!(ptr= (char *)alloc_root(ctx->alloc, len+instance_len+1)))
195
179
        goto err;
196
180
 
197
181
      extra_groups[i+group->count]= ptr;
289
273
 
290
274
  if (find_type((char *)group_name, ctx->group, 3))
291
275
  {
292
 
    if (!(tmp= (char *)ctx->alloc->alloc_root(strlen(option) + 1)))
 
276
    if (!(tmp= (char *)alloc_root(ctx->alloc, strlen(option) + 1)))
293
277
      return 1;
294
278
    if (insert_dynamic(ctx->args, (unsigned char*) &tmp))
295
279
      return 1;
324
308
  int org_argc= argc, prev_argc= 0;
325
309
  *defaults= *extra_defaults= *group_suffix= 0;
326
310
 
327
 
  const std::string DEFAULTS_FILE("--defaults-file=");
328
 
  const std::string DEFAULTS_EXTRA_FILE("--defaults-extra-file=");
329
 
  const std::string DEFAULTS_GROUP_SUFFIX("--defaults-group-suffix=");
330
 
 
331
311
  while (argc >= 2 && argc != prev_argc)
332
312
  {
333
313
    /* Skip program name or previously handled argument */
334
314
    argv++;
335
315
    prev_argc= argc;                            /* To check if we found */
336
 
    if (!*defaults && (strncmp(*argv,
337
 
                               DEFAULTS_FILE.c_str(),
338
 
                               DEFAULTS_FILE.size()) == 0))
 
316
    if (!*defaults && is_prefix(*argv,"--defaults-file="))
339
317
    {
340
 
      *defaults= *argv + DEFAULTS_FILE.size();
 
318
      *defaults= *argv + sizeof("--defaults-file=")-1;
341
319
       argc--;
342
320
       continue;
343
321
    }
344
 
    if (!*extra_defaults && (strncmp(*argv, 
345
 
                                     DEFAULTS_EXTRA_FILE.c_str(),
346
 
                                     DEFAULTS_EXTRA_FILE.size()) == 0))
 
322
    if (!*extra_defaults && is_prefix(*argv,"--defaults-extra-file="))
347
323
    {
348
 
      *extra_defaults= *argv + DEFAULTS_EXTRA_FILE.size();
 
324
      *extra_defaults= *argv + sizeof("--defaults-extra-file=")-1;
349
325
      argc--;
350
326
      continue;
351
327
    }
352
 
    if (!*group_suffix && (strncmp(*argv, 
353
 
                                   DEFAULTS_GROUP_SUFFIX.c_str(),
354
 
                                   DEFAULTS_GROUP_SUFFIX.size()) == 0))
355
 
 
 
328
    if (!*group_suffix && is_prefix(*argv, "--defaults-group-suffix="))
356
329
    {
357
 
      *group_suffix= *argv + DEFAULTS_GROUP_SUFFIX.size();
 
330
      *group_suffix= *argv + sizeof("--defaults-group-suffix=")-1;
358
331
      argc--;
359
332
      continue;
360
333
    }
399
372
{
400
373
  DYNAMIC_ARRAY args;
401
374
  TYPELIB group;
 
375
  bool found_print_defaults= 0;
402
376
  uint32_t args_used= 0;
403
377
  int error= 0;
404
 
  memory::Root alloc(512);
 
378
  MEM_ROOT alloc;
405
379
  char *ptr,**res;
406
380
  struct handle_option_ctx ctx;
407
381
 
408
382
  init_default_directories();
 
383
  init_alloc_root(&alloc,512,0);
409
384
  /*
410
385
    Check if the user doesn't want any default option processing
411
386
    --no-defaults is always the first option
414
389
  {
415
390
    /* remove the --no-defaults argument and return only the other arguments */
416
391
    uint32_t i;
417
 
    if (!(ptr=(char*) alloc.alloc_root(sizeof(alloc)+ (*argc + 1)*sizeof(char*))))
 
392
    if (!(ptr=(char*) alloc_root(&alloc,sizeof(alloc)+
 
393
                                 (*argc + 1)*sizeof(char*))))
418
394
      goto err;
419
395
    res= (char**) (ptr+sizeof(alloc));
420
 
    memset(res,0,(*argc + 1));
421
396
    res[0]= **argv;                             /* Copy program name */
422
 
    for (i=2 ; i < (uint32_t) *argc ; i++)
 
397
    for (i=2 ; i < (uint) *argc ; i++)
423
398
      res[i-1]=argv[0][i];
424
399
    res[i-1]=0;                                 /* End pointer */
425
400
    (*argc)--;
426
401
    *argv=res;
427
 
    *(memory::Root*) ptr= alloc;                        /* Save alloc root for free */
 
402
    *(MEM_ROOT*) ptr= alloc;                    /* Save alloc root for free */
428
403
    return(0);
429
404
  }
430
405
 
448
423
    Here error contains <> 0 only if we have a fully specified conf_file
449
424
    or a forced default file
450
425
  */
451
 
  if (!(ptr=(char*) alloc.alloc_root(sizeof(alloc)+ (args.elements + *argc +1) *sizeof(char*))))
 
426
  if (!(ptr=(char*) alloc_root(&alloc,sizeof(alloc)+
 
427
                               (args.elements + *argc +1) *sizeof(char*))))
452
428
    goto err;
453
429
  res= (char**) (ptr+sizeof(alloc));
454
430
 
463
439
    Check if we wan't to see the new argument list
464
440
    This options must always be the last of the default options
465
441
  */
 
442
  if (*argc >= 2 && !strcmp(argv[0][1],"--print-defaults"))
 
443
  {
 
444
    found_print_defaults=1;
 
445
    --*argc; ++*argv;                           /* skip argument */
 
446
  }
 
447
 
466
448
  if (*argc)
467
449
    memcpy(res+1+args.elements, *argv + 1, (*argc-1)*sizeof(char*));
468
450
  res[args.elements+ *argc]=0;                  /* last null */
469
451
 
470
 
  (*argc)+=int(args.elements);
471
 
  *argv= static_cast<char**>(res);
472
 
  *(memory::Root*) ptr= alloc;                  /* Save alloc root for free */
 
452
  (*argc)+=args.elements;
 
453
  *argv= (char**) res;
 
454
  *(MEM_ROOT*) ptr= alloc;                      /* Save alloc root for free */
473
455
  delete_dynamic(&args);
474
 
 
 
456
  if (found_print_defaults)
 
457
  {
 
458
    int i;
 
459
    printf("%s would have been started with the following arguments:\n",
 
460
           **argv);
 
461
    for (i=1 ; i < *argc ; i++)
 
462
      printf("%s ", (*argv)[i]);
 
463
    puts("");
 
464
    exit(0);
 
465
  }
475
466
  return(error);
476
467
 
477
468
 err:
482
473
 
483
474
void free_defaults(char **argv)
484
475
{
485
 
  memory::Root ptr;
 
476
  MEM_ROOT ptr;
486
477
  memcpy(&ptr, (char*) argv - sizeof(ptr), sizeof(ptr));
487
 
  ptr.free_root(MYF(0));
 
478
  free_root(&ptr,MYF(0));
488
479
}
489
480
 
490
481
 
597
588
  FILE *fp;
598
589
  uint32_t line=0;
599
590
  bool found_group=0;
 
591
  uint32_t i;
 
592
  MY_DIR *search_dir;
 
593
  FILEINFO *search_file;
600
594
 
601
595
  if ((dir ? strlen(dir) : 0 )+strlen(config_file) >= FN_REFLEN-3)
602
596
    return 0;                                   /* Ignore wrong paths */
629
623
      return 0;
630
624
    }
631
625
  }
632
 
  if (!(fp= fopen(name, "r")))
 
626
  if (!(fp= my_fopen(name, O_RDONLY, MYF(0))))
633
627
    return 1;                                   /* Ignore wrong files */
634
628
 
635
 
  memset(buff,0,sizeof(buff));
636
629
  while (fgets(buff, sizeof(buff) - 1, fp))
637
630
  {
638
631
    line++;
673
666
                                ptr, name, line)))
674
667
          goto err;
675
668
 
676
 
        CachedDirectory dir_cache(ptr);
677
 
 
678
 
        if (dir_cache.fail())
679
 
        {
680
 
          /**
681
 
           * @todo
682
 
           * Since clients still use this code, we use fprintf here.
683
 
           * This fprintf needs to be turned into errmsg_printf
684
 
           * as soon as the client programs no longer use mysys
685
 
           * and can use the pluggable error message system.
686
 
           */
687
 
          fprintf(stderr, _("error: could not open directory: %s\n"), ptr);
 
669
        if (!(search_dir= my_dir(ptr, MYF(MY_WME))))
688
670
          goto err;
689
 
        }
690
 
 
691
 
        CachedDirectory::Entries files= dir_cache.getEntries();
692
 
        CachedDirectory::Entries::iterator file_iter= files.begin();
693
 
 
694
 
        while (file_iter != files.end())
 
671
 
 
672
        for (i= 0; i < (uint) search_dir->number_off_files; i++)
695
673
        {
696
 
          CachedDirectory::Entry *entry= *file_iter;
697
 
          ext= fn_ext(entry->filename.c_str());
 
674
          search_file= search_dir->dir_entry + i;
 
675
          ext= fn_ext(search_file->name);
698
676
 
699
677
          /* check extension */
700
678
          for (tmp_ext= (char**) f_extensions; *tmp_ext; tmp_ext++)
701
679
          {
702
680
            if (!strcmp(ext, *tmp_ext))
703
 
            {
704
 
              fn_format(tmp, entry->filename.c_str(), ptr, "",
705
 
                        MY_UNPACK_FILENAME | MY_SAFE_PATH);
706
 
 
707
 
              search_default_file_with_ext(opt_handler, handler_ctx, "", "",
708
 
                                           tmp, recursion_level + 1);
709
 
            }
710
 
          }
711
 
 
712
 
          ++file_iter;
 
681
              break;
 
682
          }
 
683
 
 
684
          if (*tmp_ext)
 
685
          {
 
686
            fn_format(tmp, search_file->name, ptr, "",
 
687
                      MY_UNPACK_FILENAME | MY_SAFE_PATH);
 
688
 
 
689
            search_default_file_with_ext(opt_handler, handler_ctx, "", "", tmp,
 
690
                                         recursion_level + 1);
 
691
          }
713
692
        }
 
693
 
 
694
        my_dirend(search_dir);
714
695
      }
715
696
      else if ((!strncmp(ptr, include_keyword, sizeof(include_keyword) - 1)) &&
716
697
               my_isspace(&my_charset_utf8_general_ci, ptr[sizeof(include_keyword)-1]))
741
722
      for ( ; my_isspace(&my_charset_utf8_general_ci,end[-1]) ; end--) ;
742
723
      end[0]=0;
743
724
 
744
 
      strncpy(curr_gr, ptr, min((size_t) (end-ptr)+1, sizeof(curr_gr)-1));
745
 
      curr_gr[min((size_t)(end-ptr)+1, sizeof(curr_gr)-1)] = '\0';
 
725
      strncpy(curr_gr, ptr, cmin((size_t) (end-ptr)+1, sizeof(curr_gr)-1));
 
726
      curr_gr[cmin((size_t)(end-ptr)+1, sizeof(curr_gr)-1)] = '\0';
746
727
 
747
728
      /* signal that a new group is found */
748
729
      opt_handler(handler_ctx, curr_gr, NULL);
761
742
    end= remove_end_comment(ptr);
762
743
    if ((value= strchr(ptr, '=')))
763
744
      end= value;                               /* Option without argument */
764
 
    for ( ; my_isspace(&my_charset_utf8_general_ci,end[-1]) || end[-1]== '\n'; end--) ;
 
745
    for ( ; my_isspace(&my_charset_utf8_general_ci,end[-1]) ; end--) ;
765
746
    if (!value)
766
747
    {
767
748
      strncpy(strcpy(option,"--")+2,ptr,strlen(ptr)+1);
790
771
        value++;
791
772
        value_end--;
792
773
      }
793
 
      
794
 
      memset(option,0,2+(size_t)(end-ptr)+1);
795
774
      ptr= strncpy(strcpy(option,"--")+2,ptr,(size_t) (end-ptr));
796
 
      ptr[end-ptr]= '\0';
797
775
      ptr+= strlen(ptr);
798
776
      *ptr++= '=';
799
777
 
840
818
        goto err;
841
819
    }
842
820
  }
843
 
  fclose(fp);
 
821
  my_fclose(fp,MYF(0));
844
822
  return(0);
845
823
 
846
824
 err:
847
 
  fclose(fp);
848
 
 
 
825
  my_fclose(fp,MYF(0));
849
826
  return -1;                                    /* Fatal error */
850
827
}
851
828
 
936
913
    }
937
914
  }
938
915
  puts("\nThe following options may be given as the first argument:\n\
939
 
  --no-defaults         Don't read default options from any options file\n\
940
 
  --defaults-file=#     Only read default options from the given file #\n\
941
 
  --defaults-extra-file=# Read this file after the global files are read");
 
916
--print-defaults        Print the program argument list and exit\n\
 
917
--no-defaults           Don't read default options from any options file\n\
 
918
--defaults-file=#       Only read default options from the given file #\n\
 
919
--defaults-extra-file=# Read this file after the global files are read");
942
920
}
943
921
 
944
922
/*
979
957
  ADD_COMMON_DIRECTORIES();
980
958
  ADD_DIRECTORY("~/");
981
959
}
982
 
 
983
 
} /* namespace internal */
984
 
} /* namespace drizzled */