← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/strfunc.cc

Reverted my change to interval_list

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/strfunc.cc
14
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
15
 
16
16
/* Some useful string utility functions used by the MySQL server */
17
 
#include "config.h"
18
 
 
19
 
#include "drizzled/strfunc.h"
20
 
#include "drizzled/typelib.h"
21
 
#include "drizzled/charset_info.h"
22
 
#include "drizzled/global_charset_info.h"
23
 
 
24
 
namespace drizzled
25
 
{
 
17
#include <drizzled/server_includes.h>
26
18
 
27
19
/*
28
20
  Return bitmap for strings used in a set
161
153
  return(0);
162
154
} /* find_type */
163
155
 
164
 
} /* namespace drizzled */
 
156
 
 
157
/*
 
158
  Un-hex all elements in a typelib
 
159
 
 
160
  SYNOPSIS
 
161
   unhex_type2()
 
162
   interval       TYPELIB (struct of pointer to values + lengths + count)
 
163
 
 
164
  NOTES
 
165
 
 
166
  RETURN
 
167
    N/A
 
168
*/
 
169
 
 
170
void unhex_type2(TYPELIB *interval)
 
171
{
 
172
  for (uint32_t pos= 0; pos < interval->count; pos++)
 
173
  {
 
174
    char *from, *to;
 
175
    for (from= to= (char*) interval->type_names[pos]; *from; )
 
176
    {
 
177
      /*
 
178
        Note, hexchar_to_int(*from++) doesn't work
 
179
        one some compilers, e.g. IRIX. Looks like a compiler
 
180
        bug in inline functions in combination with arguments
 
181
        that have a side effect. So, let's use from[0] and from[1]
 
182
        and increment 'from' by two later.
 
183
      */
 
184
 
 
185
      *to++= (char) (hexchar_to_int(from[0]) << 4) +
 
186
                     hexchar_to_int(from[1]);
 
187
      from+= 2;
 
188
    }
 
189
    interval->type_lengths[pos] /= 2;
 
190
  }
 
191
}
 
192
 
 
193
 
 
194
/*
 
195
  Check if the first word in a string is one of the ones in TYPELIB
 
196
 
 
197
  SYNOPSIS
 
198
    check_word()
 
199
    lib         TYPELIB
 
200
    val         String to check
 
201
    end         End of input
 
202
    end_of_word Store value of last used byte here if we found word
 
203
 
 
204
  RETURN
 
205
    0    No matching value
 
206
    > 1  lib->type_names[#-1] matched
 
207
         end_of_word will point to separator character/end in 'val'
 
208
*/
 
209
 
 
210
uint32_t check_word(TYPELIB *lib, const char *val, const char *end,
 
211
                const char **end_of_word)
 
212
{
 
213
  int res;
 
214
  const char *ptr;
 
215
 
 
216
  /* Fiend end of word */
 
217
  for (ptr= val ; ptr < end && my_isalpha(&my_charset_utf8_general_ci, *ptr) ; ptr++)
 
218
    ;
 
219
  if ((res=find_type(lib, val, (uint32_t) (ptr - val), 1)) > 0)
 
220
    *end_of_word= ptr;
 
221
  return res;
 
222
}
 
223
 
 
224
 
 
225
/*
 
226
  Searches for a LEX_STRING in an LEX_STRING array.
 
227
 
 
228
  SYNOPSIS
 
229
    find_string_in_array()
 
230
      heap    The array
 
231
      needle  The string to search for
 
232
 
 
233
  NOTE
 
234
    The last LEX_STRING in the array should have str member set to NULL
 
235
 
 
236
  RETURN VALUES
 
237
    -1   Not found
 
238
    >=0  Ordinal position
 
239
*/
 
240
 
 
241
int find_string_in_array(LEX_STRING * const haystack, LEX_STRING * const needle,
 
242
                         const CHARSET_INFO * const cs)
 
243
{
 
244
  const LEX_STRING *pos;
 
245
  for (pos= haystack; pos->str; pos++)
 
246
    if (!cs->coll->strnncollsp(cs, (unsigned char *) pos->str, pos->length,
 
247
                               (unsigned char *) needle->str, needle->length, 0))
 
248
    {
 
249
      return (pos - haystack);
 
250
    }
 
251
  return -1;
 
252
}