← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to tests/resolve_stack_dump.c

  • Committer: Brian Aker
  • Date: 2008-08-10 16:57:26 UTC
  • Revision ID: brian@tangent.org-20080810165726-mc1660l11a5vkv69
libdrizzle has ulong removed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/resolve_stack_dump.c
29
29
#define INC_SYM_TABLE  4096
30
30
#define MAX_SYM_SIZE   128
31
31
#define DUMP_VERSION "1.4"
32
 
#define HEX_INVALID  (unsigned char)255
 
32
#define HEX_INVALID  (uchar)255
33
33
 
 
34
typedef ulong my_long_addr_t ; /* at some point, we need to fix configure
 
35
                                * to define this for us  
 
36
                                */
34
37
 
35
38
typedef struct sym_entry
36
39
{
37
40
  char symbol[MAX_SYM_SIZE];
38
 
  unsigned char* addr;
 
41
  uchar* addr;
39
42
} SYM_ENTRY;
40
43
 
41
44
 
63
66
static void print_version(void)
64
67
{
65
68
  printf("%s  Ver %s Distrib %s, for %s (%s)\n",my_progname,DUMP_VERSION,
66
 
         DRIZZLE_SERVER_VERSION,SYSTEM_TYPE,MACHINE_TYPE);
 
69
         MYSQL_SERVER_VERSION,SYSTEM_TYPE,MACHINE_TYPE);
67
70
}
68
71
 
69
72
 
166
169
 
167
170
}
168
171
 
169
 
static unsigned char hex_val(char c)
 
172
static uchar hex_val(char c)
170
173
{
171
 
  unsigned char l;
172
 
  if (my_isdigit(&my_charset_utf8_general_ci,c))
 
174
  uchar l;
 
175
  if (my_isdigit(&my_charset_latin1,c))
173
176
    return c - '0';
174
 
  l = my_tolower(&my_charset_utf8_general_ci,c);
 
177
  l = my_tolower(&my_charset_latin1,c);
175
178
  if (l < 'a' || l > 'f')
176
179
    return HEX_INVALID; 
177
 
  return (unsigned char)10 + ((unsigned char)c - (unsigned char)'a');
 
180
  return (uchar)10 + ((uchar)c - (uchar)'a');
178
181
}
179
182
 
180
 
static unsigned long read_addr(char** buf)
 
183
static my_long_addr_t read_addr(char** buf)
181
184
{
182
 
  unsigned char c;
 
185
  uchar c;
183
186
  char* p = *buf;
184
 
  unsigned long addr = 0;
 
187
  my_long_addr_t addr = 0;
185
188
 
186
189
  while((c = hex_val(*p++)) != HEX_INVALID)
187
190
      addr = (addr << 4) + c;
193
196
static int init_sym_entry(SYM_ENTRY* se, char* buf)
194
197
{
195
198
  char* p, *p_end;
196
 
  se->addr = (unsigned char*)read_addr(&buf);
 
199
  se->addr = (uchar*)read_addr(&buf);
197
200
 
198
201
  if (!se->addr)
199
202
    return -1;
200
 
  while (my_isspace(&my_charset_utf8_general_ci,*buf++))
 
203
  while (my_isspace(&my_charset_latin1,*buf++))
201
204
    /* empty */;
202
205
 
203
 
  while (my_isspace(&my_charset_utf8_general_ci,*buf++))
 
206
  while (my_isspace(&my_charset_latin1,*buf++))
204
207
    /* empty - skip more space */;
205
208
  --buf;
206
209
  /* now we are on the symbol */
225
228
    SYM_ENTRY se;
226
229
    if (init_sym_entry(&se, buf))
227
230
      continue;
228
 
    if (insert_dynamic(&sym_table, (unsigned char*)&se))
 
231
    if (insert_dynamic(&sym_table, (uchar*)&se))
229
232
      die("insert_dynamic() failed - looks like we are out of memory");
230
233
  }
231
234
 
239
242
 
240
243
static void verify_sort()
241
244
{
242
 
  uint32_t i;
243
 
  unsigned char* last = 0;
 
245
  uint i;
 
246
  uchar* last = 0;
244
247
 
245
248
  for (i = 0; i < sym_table.elements; i++)
246
249
  {
247
250
    SYM_ENTRY se;
248
 
    get_dynamic(&sym_table, (unsigned char*)&se, i);
 
251
    get_dynamic(&sym_table, (uchar*)&se, i);
249
252
    if (se.addr < last)
250
253
      die("sym table does not appear to be sorted, did you forget \
251
254
--numeric-sort arg to nm? trouble addr = %p, last = %p", se.addr, last);
254
257
}
255
258
 
256
259
 
257
 
static SYM_ENTRY* resolve_addr(unsigned char* addr, SYM_ENTRY* se)
 
260
static SYM_ENTRY* resolve_addr(uchar* addr, SYM_ENTRY* se)
258
261
{
259
 
  uint32_t i;
260
 
  get_dynamic(&sym_table, (unsigned char*)se, 0);
 
262
  uint i;
 
263
  get_dynamic(&sym_table, (uchar*)se, 0);
261
264
  if (addr < se->addr)
262
265
    return 0;
263
266
 
264
267
  for (i = 1; i < sym_table.elements; i++)
265
268
  {
266
 
    get_dynamic(&sym_table, (unsigned char*)se, i);
 
269
    get_dynamic(&sym_table, (uchar*)se, i);
267
270
    if (addr < se->addr)
268
271
    {
269
 
      get_dynamic(&sym_table, (unsigned char*)se, i - 1);
 
272
      get_dynamic(&sym_table, (uchar*)se, i - 1);
270
273
      return se;
271
274
    }
272
275
  }
282
285
  {
283
286
    p = buf;
284
287
    /* skip space */
285
 
    while (my_isspace(&my_charset_utf8_general_ci,*p))
 
288
    while (my_isspace(&my_charset_latin1,*p))
286
289
      ++p;
287
290
 
288
291
    if (*p++ == '0' && *p++ == 'x')
289
292
    {
290
293
      SYM_ENTRY se ;
291
 
      unsigned char* addr = (unsigned char*)read_addr(&p);
 
294
      uchar* addr = (uchar*)read_addr(&p);
292
295
      if (resolve_addr(addr, &se))
293
296
        fprintf(fp_out, "%p %s + %d\n", addr, se.symbol,
294
297
                (int) (addr - se.addr));