← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/plugin/loader.cc

  • Committer: Jay Pipes
  • Date: 2010-04-08 16:27:25 UTC
  • mfrom: (1405.6.10 replication-pairs)
  • mto: This revision was merged to the branch mainline in revision 1457.
  • Revision ID: jpipes@serialcoder-20100408162725-sugbgn38oxjqclq2
Merge trunk and replication-pairs with conflict resolution

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/plugin/loader.cc
22
22
#include <map>
23
23
#include <algorithm>
24
24
 
25
 
#include "drizzled/my_getopt.h"
 
25
#include "drizzled/option.h"
26
26
#include "drizzled/my_hash.h"
27
27
#include "drizzled/internal/m_string.h"
28
28
 
667
667
{
668
668
  bool fixed;
669
669
  int64_t tmp;
670
 
  struct my_option options;
 
670
  struct option options;
671
671
  value->val_int(value, &tmp);
672
672
  plugin_opt_set_limits(&options, var);
673
673
 
687
687
{
688
688
  bool fixed;
689
689
  int64_t tmp;
690
 
  struct my_option options;
 
690
  struct option options;
691
691
  value->val_int(value, &tmp);
692
692
  plugin_opt_set_limits(&options, var);
693
693
 
707
707
{
708
708
  bool fixed;
709
709
  int64_t tmp;
710
 
  struct my_option options;
 
710
  struct option options;
711
711
  value->val_int(value, &tmp);
712
712
  plugin_opt_set_limits(&options, var);
713
713
 
1370
1370
  options->block_size= (long) (opt)->blk_sz
1371
1371
 
1372
1372
 
1373
 
void plugin_opt_set_limits(struct my_option *options,
 
1373
void plugin_opt_set_limits(struct option *options,
1374
1374
                                                                                                         const drizzle_sys_var *opt)
1375
1375
{
1376
1376
  options->sub_size= 0;
1443
1443
    options->arg_type= OPT_ARG;
1444
1444
}
1445
1445
 
1446
 
static int get_one_plugin_option(int, const struct my_option *, char *)
 
1446
static int get_one_plugin_option(int, const struct option *, char *)
1447
1447
{
1448
1448
  return 0;
1449
1449
}
1450
1450
 
1451
1451
 
1452
1452
static int construct_options(memory::Root *mem_root, plugin::Module *tmp,
1453
 
                             my_option *options)
 
1453
                             option *options)
1454
1454
{
1455
1455
  
1456
1456
  int localoptionid= 256;
1620
1620
}
1621
1621
 
1622
1622
 
1623
 
static my_option *construct_help_options(memory::Root *mem_root, plugin::Module *p)
 
1623
static option *construct_help_options(memory::Root *mem_root, plugin::Module *p)
1624
1624
{
1625
1625
  drizzle_sys_var **opt;
1626
 
  my_option *opts;
 
1626
  option *opts;
1627
1627
  uint32_t count= EXTRA_OPTIONS;
1628
1628
 
1629
1629
  for (opt= p->getManifest().system_vars; opt && *opt; opt++, count++) {};
1630
1630
 
1631
 
  opts= (my_option*)alloc_root(mem_root, (sizeof(my_option) * count));
 
1631
  opts= (option*)alloc_root(mem_root, (sizeof(option) * count));
1632
1632
  if (opts == NULL)
1633
1633
    return NULL;
1634
1634
 
1635
 
  memset(opts, 0, sizeof(my_option) * count);
 
1635
  memset(opts, 0, sizeof(option) * count);
1636
1636
 
1637
1637
  if (construct_options(mem_root, p, opts))
1638
1638
    return NULL;
1674
1674
{
1675
1675
  struct sys_var_chain chain= { NULL, NULL };
1676
1676
  drizzle_sys_var **opt;
1677
 
  my_option *opts= NULL;
 
1677
  option *opts= NULL;
1678
1678
  int error;
1679
1679
  drizzle_sys_var *o;
1680
1680
  struct st_bookmark *var;
1686
1686
 
1687
1687
  if (count > EXTRA_OPTIONS || (*argc > 1))
1688
1688
  {
1689
 
    if (!(opts= (my_option*) alloc_root(tmp_root, sizeof(my_option) * count)))
 
1689
    if (!(opts= (option*) alloc_root(tmp_root, sizeof(option) * count)))
1690
1690
    {
1691
1691
      errmsg_printf(ERRMSG_LVL_ERROR, _("Out of memory for plugin '%s'."), tmp->getName().c_str());
1692
1692
      return(-1);
1693
1693
    }
1694
 
    memset(opts, 0, sizeof(my_option) * count);
 
1694
    memset(opts, 0, sizeof(option) * count);
1695
1695
 
1696
1696
    if (construct_options(tmp_root, tmp, opts))
1697
1697
    {
1776
1776
class OptionCmp
1777
1777
{
1778
1778
public:
1779
 
  bool operator() (const my_option &a, const my_option &b)
 
1779
  bool operator() (const option &a, const option &b)
1780
1780
  {
1781
1781
    return my_strcasecmp(&my_charset_utf8_general_ci, a.name, b.name);
1782
1782
  }
1783
1783
};
1784
1784
 
1785
1785
 
1786
 
void my_print_help_inc_plugins(my_option *main_options)
 
1786
void my_print_help_inc_plugins(option *main_options)
1787
1787
{
1788
1788
  plugin::Registry &registry= plugin::Registry::singleton();
1789
 
  vector<my_option> all_options;
 
1789
  vector<option> all_options;
1790
1790
  plugin::Module *p;
1791
1791
  memory::Root mem_root;
1792
 
  my_option *opt= NULL;
 
1792
  option *opt= NULL;
1793
1793
 
1794
1794
  init_alloc_root(&mem_root, 4096);
1795
1795
 
1831
1831
  }
1832
1832
 
1833
1833
  /** 
1834
 
   * @TODO: Fix the my_option building so that it doens't break sort
 
1834
   * @TODO: Fix the option building so that it doens't break sort
1835
1835
   *
1836
1836
   * sort(all_options.begin(), all_options.end(), OptionCmp());
1837
1837
   */