← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/strfunc.cc

  • Committer: Brian Aker
  • Date: 2009-10-12 06:15:02 UTC
  • mfrom: (1165.1.178 static-functions)
  • Revision ID: brian@gaz-20091012061502-cds4m0cya7ow8sj7
Merge Stewart

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/strfunc.cc
153
153
  return(0);
154
154
} /* find_type */
155
155
 
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
 
}