← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to client/drizzletest.cc

Added code necessary for building plugins dynamically.
Merged in changes from lifeless to allow autoreconf to work.
Touching plugin.ini files now triggers a rebuid - so config/autorun.sh is no
longer required to be run after touching those.
Removed the duplicate plugin names - also removed the issue that getting them
different would silently fail weirdly later.

Show diffs side-by-side

added added

removed removed

Lines of Context:
client/drizzletest.cc
53
53
 
54
54
#include PCRE_HEADER
55
55
 
56
 
#include <mysys/hash.h>
57
56
#include <stdarg.h>
58
57
 
59
58
#include "errname.h"
60
59
 
61
60
/* Added this for string translation. */
62
 
#include <drizzled/gettext.h>
 
61
#include "drizzled/gettext.h"
 
62
#include "drizzled/hash.h"
63
63
 
64
64
#ifndef DRIZZLE_RETURN_SERVER_GONE
65
65
#define DRIZZLE_RETURN_HANDSHAKE_FAILED DRIZZLE_RETURN_ERROR_CODE
206
206
/*Perl/shell-like variable registers */
207
207
VAR var_reg[10];
208
208
 
209
 
HASH var_hash;
 
209
 
 
210
drizzled::hash_map<string, VAR *> var_hash;
210
211
 
211
212
struct st_connection
212
213
{
428
429
VAR* var_from_env(const char *, const char *);
429
430
VAR* var_init(VAR* v, const char *name, int name_len, const char *val,
430
431
              int val_len);
431
 
extern "C" void var_free(void* v);
 
432
void var_free(pair<string, VAR*> v);
432
433
VAR* var_get(const char *var_name, const char** var_name_end,
433
434
             bool raw, bool ignore_not_existing);
434
435
void eval_expr(VAR* v, const char *p, const char** p_end);
900
901
 
901
902
  close_connections();
902
903
  close_files();
903
 
  hash_free(&var_hash);
 
904
  for_each(var_hash.begin(), var_hash.end(), var_free);
 
905
  var_hash.clear();
904
906
 
905
 
  vector<struct st_command *>::iterator iter;
 
907
  vector<st_command *>::iterator iter;
906
908
  for (iter= q_lines.begin() ; iter < q_lines.end() ; iter++)
907
909
  {
908
910
    struct st_command * q_line= *iter;
1615
1617
}
1616
1618
 
1617
1619
 
1618
 
unsigned char *get_var_key(const unsigned char* var, size_t *len, bool)
1619
 
{
1620
 
  register char* key;
1621
 
  key = ((VAR*)var)->name;
1622
 
  *len = ((VAR*)var)->name_len;
1623
 
  return (unsigned char*)key;
1624
 
}
1625
 
 
1626
1620
 
1627
1621
VAR *var_init(VAR *v, const char *name, int name_len, const char *val,
1628
1622
              int val_len)
1660
1654
}
1661
1655
 
1662
1656
 
1663
 
void var_free(void *v)
 
1657
void var_free(pair<string, VAR *> v)
1664
1658
{
1665
 
  free(((VAR*) v)->str_val);
1666
 
  free(((VAR*) v)->env_s);
1667
 
  if (((VAR*)v)->alloced)
1668
 
    free(v);
 
1659
  free(v.second->str_val);
 
1660
  free(v.second->env_s);
 
1661
  if (v.second->alloced)
 
1662
    free(v.second);
1669
1663
}
1670
1664
 
1671
1665
 
1677
1671
    tmp = def_val;
1678
1672
 
1679
1673
  v = var_init(0, name, strlen(name), tmp, strlen(tmp));
1680
 
  my_hash_insert(&var_hash, (unsigned char*)v);
 
1674
  string var_name(name);
 
1675
  var_hash.insert(make_pair(var_name, v));
1681
1676
  return v;
1682
1677
}
1683
1678
 
1708
1703
    if (length >= MAX_VAR_NAME_LENGTH)
1709
1704
      die("Too long variable name: %s", save_var_name);
1710
1705
 
1711
 
    if (!(v = (VAR*) hash_search(&var_hash, (const unsigned char*) save_var_name,
1712
 
                                 length)))
 
1706
    string save_var_name_str(save_var_name, length);
 
1707
    drizzled::hash_map<string, VAR*>::iterator iter=
 
1708
      var_hash.find(save_var_name_str);
 
1709
    if (iter == var_hash.end())
1713
1710
    {
1714
1711
      char buff[MAX_VAR_NAME_LENGTH+1];
1715
1712
      strncpy(buff, save_var_name, length);
1716
1713
      buff[length]= '\0';
1717
1714
      v= var_from_env(buff, "");
1718
1715
    }
 
1716
    else
 
1717
    {
 
1718
      v= (*iter).second;
 
1719
    }
1719
1720
    var_name--;  /* Point at last character */
1720
1721
  }
1721
1722
  else
1740
1741
 
1741
1742
static VAR *var_obtain(const char *name, int len)
1742
1743
{
1743
 
  VAR* v;
1744
 
  if ((v = (VAR*)hash_search(&var_hash, (const unsigned char *) name, len)))
1745
 
    return v;
1746
 
  v = var_init(0, name, len, "", 0);
1747
 
  my_hash_insert(&var_hash, (unsigned char*)v);
 
1744
  string var_name(name, len);
 
1745
  drizzled::hash_map<string, VAR*>::iterator iter=
 
1746
    var_hash.find(var_name);
 
1747
  if (iter != var_hash.end())
 
1748
    return (*iter).second;
 
1749
  VAR *v = var_init(0, name, len, "", 0);
 
1750
  var_hash.insert(make_pair(var_name, v));
1748
1751
  return v;
1749
1752
}
1750
1753
 
5639
5642
  cur_block->ok= true; /* Outer block should always be executed */
5640
5643
  cur_block->cmd= cmd_none;
5641
5644
 
5642
 
  if (hash_init(&var_hash, charset_info,
5643
 
                1024, 0, 0, get_var_key, var_free, MYF(0)))
5644
 
    die("Variable hash initialization failed");
5645
 
 
5646
5645
  var_set_string("$DRIZZLE_SERVER_VERSION", drizzle_version());
5647
5646
 
5648
5647
  memset(&master_pos, 0, sizeof(master_pos));