?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gdi32: Use symbolic names for font tags.
[wine/multimedia.git] / tools / winedump / pdb.c
blobd4eb50b6b5e0d9adea202f716ea5ed94f011724b
1 /*
2 * PDB dumping utility
3 *
4 * Copyright 2006 Eric Pouech
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include "config.h"
22 #include "wine/port.h"
23
24 #include <stdlib.h>
25 #include <stdarg.h>
26 #include <stdio.h>
27 #ifdef HAVE_UNISTD_H
28 # include <unistd.h>
29 #endif
30 #include <time.h>
31 #ifdef HAVE_SYS_TYPES_H
32 # include <sys/types.h>
33 #endif
34 #ifdef HAVE_SYS_STAT_H
35 # include <sys/stat.h>
36 #endif
37 #ifdef HAVE_SYS_MMAN_H
38 #include <sys/mman.h>
39 #endif
40 #include <fcntl.h>
41
42 #define NONAMELESSUNION
43 #define NONAMELESSSTRUCT
44 #include "windef.h"
45 #include "winbase.h"
46 #include "winedump.h"
47 #include "wine/mscvpdb.h"
48
49 struct pdb_reader
50 {
51 union
52 {
53 struct
54 {
55 const struct PDB_JG_HEADER* header;
56 const struct PDB_JG_TOC* toc;
57 } jg;
58 struct
59 {
60 const struct PDB_DS_HEADER* header;
61 const struct PDB_DS_TOC* toc;
62 } ds;
63 } u;
64 void* (*read_file)(struct pdb_reader*, DWORD);
65 DWORD file_used[1024];
66 };
67
68 static void* pdb_jg_read(const struct PDB_JG_HEADER* pdb, const WORD* block_list, int size)
69 {
70 int i, nBlocks;
71 BYTE* buffer;
72
73 if (!size) return NULL;
74
75 nBlocks = (size + pdb->block_size - 1) / pdb->block_size;
76 buffer = malloc(nBlocks * pdb->block_size);
77
78 for (i = 0; i < nBlocks; i++)
79 memcpy(buffer + i * pdb->block_size,
80 (const char*)pdb + block_list[i] * pdb->block_size, pdb->block_size);
81
82 return buffer;
83 }
84
85 static void* pdb_jg_read_file(struct pdb_reader* reader, DWORD file_nr)
86 {
87 const WORD* block_list;
88 DWORD i;
89
90 if (!reader->u.jg.toc || file_nr >= reader->u.jg.toc->num_files) return NULL;
91
92 reader->file_used[file_nr / 32] |= 1 << (file_nr % 32);
93 if (reader->u.jg.toc->file[file_nr].size == 0 ||
94 reader->u.jg.toc->file[file_nr].size == 0xFFFFFFFF)
95 return NULL;
96 block_list = (const WORD*) &reader->u.jg.toc->file[reader->u.jg.toc->num_files];
97 for (i = 0; i < file_nr; i++)
98 block_list += (reader->u.jg.toc->file[i].size +
99 reader->u.jg.header->block_size - 1) / reader->u.jg.header->block_size;
100
101 return pdb_jg_read(reader->u.jg.header, block_list,
102 reader->u.jg.toc->file[file_nr].size);
103 }
104
105 static void pdb_jg_init(struct pdb_reader* reader)
106 {
107 reader->u.jg.header = PRD(0, sizeof(struct PDB_JG_HEADER));
108 reader->read_file = pdb_jg_read_file;
109 reader->u.jg.toc = pdb_jg_read(reader->u.jg.header,
110 reader->u.jg.header->toc_block,
111 reader->u.jg.header->toc.size);
112 memset(reader->file_used, 0, sizeof(reader->file_used));
113 }
114
115 static DWORD pdb_get_num_files(const struct pdb_reader* reader)
116 {
117 if (reader->read_file == pdb_jg_read_file)
118 return reader->u.jg.toc->num_files;
119 else
120 return reader->u.ds.toc->num_files;
121 }
122
123 static DWORD pdb_get_file_size(const struct pdb_reader* reader, unsigned idx)
124 {
125 if (reader->read_file == pdb_jg_read_file)
126 return reader->u.jg.toc->file[idx].size;
127 else
128 return reader->u.ds.toc->file_size[idx];
129 }
130
131 static void pdb_exit(struct pdb_reader* reader)
132 {
133 #if 1
134 unsigned i;
135 unsigned char* file;
136 DWORD size;
137
138 for (i = 0; i < pdb_get_num_files(reader); i++)
139 {
140 if (reader->file_used[i / 32] & (1 << (i % 32))) continue;
141
142 file = reader->read_file(reader, i);
143 if (!file) continue;
144
145 size = pdb_get_file_size(reader, i);
146
147 printf("File --unused-- #%d (%x)\n", i, size);
148 dump_data(file, size, " ");
149 free(file);
150 }
151 #endif
152 if (reader->read_file == pdb_jg_read_file)
153 free((char*)reader->u.jg.toc);
154 else
155 free((char*)reader->u.ds.toc);
156 }
157
158 static void pdb_dump_symbols(struct pdb_reader* reader)
159 {
160 PDB_SYMBOLS* symbols;
161 unsigned char* modimage;
162 const char* file;
163
164 symbols = reader->read_file(reader, 3);
165
166 if (!symbols) return;
167
168 switch (symbols->version)
169 {
170 case 0: /* VC 4.0 */
171 case 19960307: /* VC 5.0 */
172 case 19970606: /* VC 6.0 */
173 break;
174 default:
175 printf("-Unknown symbol info version %d\n", symbols->version);
176 }
177 printf("Symbols:\n"
178 "\tsignature: %08x\n"
179 "\tversion: %u\n"
180 "\tunknown: %08x\n"
181 "\thash1_file: %08x\n"
182 "\thash2_file: %08x\n"
183 "\tgsym_file: %08x\n"
184 "\tmodule_size: %08x\n"
185 "\toffset_size: %08x\n"
186 "\thash_size: %08x\n"
187 "\tsrc_module_size %08x\n"
188 "\tpdbimport_size %08x\n",
189 symbols->signature,
190 symbols->version,
191 symbols->unknown,
192 symbols->hash1_file,
193 symbols->hash2_file,
194 symbols->gsym_file,
195 symbols->module_size,
196 symbols->offset_size,
197 symbols->hash_size,
198 symbols->srcmodule_size,
199 symbols->pdbimport_size);
200
201 if (symbols->offset_size)
202 {
203 const BYTE* src;
204
205 printf("\t----------offsets------------\n");
206 src = (const BYTE*)((const char*)symbols + sizeof(PDB_SYMBOLS) + symbols->module_size);
207 dump_data(src, symbols->offset_size, " ");
208 }
209
210 if (symbols->srcmodule_size)
211 {
212 const PDB_SYMBOL_SOURCE*src;
213 int i;
214 const DWORD* offset;
215 const char* cstr;
216
217 printf("\t----------src module------------\n");
218 src = (const PDB_SYMBOL_SOURCE*)((const char*)symbols + sizeof(PDB_SYMBOLS) +
219 symbols->module_size + symbols->offset_size + symbols->hash_size);
220 printf("\tSource Modules\n"
221 "\t\tnModules: %u\n"
222 "\t\tnSrcFiles: %u\n"
223 "\t\ttable:\n",
224 src->nModules, src->nSrcFiles);
225
226 /* usage of table seems to be as follows:
227 * two arrays of WORD (src->nModules as size)
228 * - first array contains index into files for "module" compilation (module = compilation unit ??)
229 * - second array contains increment in index (if needed)
230 * - usage of this later is not very clear. it could be that if second array entry is null, then no file
231 * name is to be used ?
232 * an array of DWORD (src->nSrcFiles as size)
233 * - contains offset (in following string table) of the source file name
234 * a string table
235 * - each string is a pascal string (ie. with its length as first BYTE) or
236 * 0-terminated string (depending on version)
237 */
238
239 offset = (const DWORD*)&src->table[2 * src->nModules];
240 cstr = (const char*)&src->table[2 * (src->nModules + src->nSrcFiles)];
241
242 for (i = 0; i < src->nModules; i++)
243 {
244 /* FIXME: in some cases, it's a p_string but WHEN ? */
245 if (cstr + offset[src->table[i]] < (const char*)src + symbols->srcmodule_size)
246 printf("\t\t\tmodule[%2d]: src=%s (%04x)\n",
247 i, cstr + offset[src->table[i]], src->table[src->nModules + i]);
248 else
249 printf("\t\t\tmodule[%2d]: src=<<out of bounds>> (%04x)\n",
250 i, src->table[src->nModules + i]);
251 }
252 }
253 if (symbols->pdbimport_size)
254 {
255 const PDB_SYMBOL_IMPORT* imp;
256 const char* first;
257 const char* last;
258 const char* ptr;
259
260 printf("\t------------import--------------\n");
261 imp = (const PDB_SYMBOL_IMPORT*)((const char*)symbols + sizeof(PDB_SYMBOLS) +
262 symbols->module_size + symbols->offset_size +
263 symbols->hash_size + symbols->srcmodule_size);
264 first = (const char*)imp;
265 last = (const char*)imp + symbols->pdbimport_size;
266 while (imp < (const PDB_SYMBOL_IMPORT*)last)
267 {
268 ptr = (const char*)imp + sizeof(*imp) + strlen(imp->filename);
269 printf("\tImport: %lx\n"
270 "\t\tUnknown1: %08x\n"
271 "\t\tUnknown2: %08x\n"
272 "\t\tTimeDateStamp: %08x\n"
273 "\t\tAge: %08u\n"
274 "\t\tfile1: %s\n"
275 "\t\tfile2: %s\n",
276 (ULONG_PTR)((const char*)imp - (const char*)first),
277 imp->unknown1,
278 imp->unknown2,
279 imp->TimeDateStamp,
280 imp->Age,
281 imp->filename,
282 ptr);
283 imp = (const PDB_SYMBOL_IMPORT*)(first + ((ptr - first + strlen(ptr) + 1 + 3) & ~3));
284 }
285 }
286
287 /* Read global symbol table */
288 modimage = reader->read_file(reader, symbols->gsym_file);
289 if (modimage)
290 {
291 printf("\t------------globals-------------\n");
292 codeview_dump_symbols(modimage, pdb_get_file_size(reader, symbols->gsym_file));
293 free(modimage);
294 }
295
296 /* Read per-module symbol / linenumber tables */
297 file = (const char*)symbols + sizeof(PDB_SYMBOLS);
298 while (file - (const char*)symbols < sizeof(PDB_SYMBOLS) + symbols->module_size)
299 {
300 int file_nr, symbol_size, lineno_size;
301 const char* file_name;
302
303 if (symbols->version < 19970000)
304 {
305 const PDB_SYMBOL_FILE* sym_file = (const PDB_SYMBOL_FILE*) file;
306 file_nr = sym_file->file;
307 file_name = sym_file->filename;
308 symbol_size = sym_file->symbol_size;
309 lineno_size = sym_file->lineno_size;
310 printf("\t--------symbol file----------- %s\n", file_name);
311 printf("\tgot symbol_file\n"
312 "\t\tunknown1: %08x \n"
313 "\t\trange\n"
314 "\t\t\tsegment: %04x\n"
315 "\t\t\tpad1: %04x\n"
316 "\t\t\toffset: %08x\n"
317 "\t\t\tsize: %08x\n"
318 "\t\t\tcharacteristics: %08x\n"
319 "\t\t\tindex: %04x\n"
320 "\t\t\tpad2: %04x\n"
321 "\t\tflag: %04x\n"
322 "\t\tfile: %04x\n"
323 "\t\tsymb size: %08x\n"
324 "\t\tline size: %08x\n"
325 "\t\tunknown2: %08x\n"
326 "\t\tnSrcFiles: %08x\n"
327 "\t\tattribute: %08x\n",
328 sym_file->unknown1,
329 sym_file->range.segment,
330 sym_file->range.pad1,
331 sym_file->range.offset,
332 sym_file->range.size,
333 sym_file->range.characteristics,
334 sym_file->range.index,
335 sym_file->range.pad2,
336 sym_file->flag,
337 sym_file->file,
338 sym_file->symbol_size,
339 sym_file->lineno_size,
340 sym_file->unknown2,
341 sym_file->nSrcFiles,
342 sym_file->attribute);
343 }
344 else
345 {
346 const PDB_SYMBOL_FILE_EX* sym_file = (const PDB_SYMBOL_FILE_EX*) file;
347 file_nr = sym_file->file;
348 file_name = sym_file->filename;
349 symbol_size = sym_file->symbol_size;
350 lineno_size = sym_file->lineno_size;
351 printf("\t--------symbol file----------- %s\n", file_name);
352 printf("\t\tunknown1: %08x \n"
353 "\t\trange\n"
354 "\t\t\tsegment: %04x\n"
355 "\t\t\tpad1: %04x\n"
356 "\t\t\toffset: %08x\n"
357 "\t\t\tsize: %08x\n"
358 "\t\t\tcharacteristics: %08x\n"
359 "\t\t\tindex: %04x\n"
360 "\t\t\tpad2: %04x\n"
361 "\t\t\ttimestamp: %08x\n"
362 "\t\t\tunknown: %08x\n"
363 "\t\tflag: %04x\n"
364 "\t\tfile: %04x\n"
365 "\t\tsymb size: %08x\n"
366 "\t\tline size: %08x\n"
367 "\t\tunknown2: %08x\n"
368 "\t\tnSrcFiles: %08x\n"
369 "\t\tattribute: %08x\n"
370 "\t\treserved/0: %08x\n"
371 "\t\treserved/1: %08x\n",
372 sym_file->unknown1,
373 sym_file->range.segment,
374 sym_file->range.pad1,
375 sym_file->range.offset,
376 sym_file->range.size,
377 sym_file->range.characteristics,
378 sym_file->range.index,
379 sym_file->range.pad2,
380 sym_file->range.timestamp,
381 sym_file->range.unknown,
382 sym_file->flag,
383 sym_file->file,
384 sym_file->symbol_size,
385 sym_file->lineno_size,
386 sym_file->unknown2,
387 sym_file->nSrcFiles,
388 sym_file->attribute,
389 sym_file->reserved[0],
390 sym_file->reserved[1]);
391 }
392 modimage = reader->read_file(reader, file_nr);
393 if (modimage)
394 {
395 int total_size = pdb_get_file_size(reader, file_nr);
396
397 if (symbol_size)
398 codeview_dump_symbols((const char*)modimage + sizeof(DWORD), symbol_size);
399
400 /* what's that part ??? */
401 if (0)
402 dump_data(modimage + symbol_size + lineno_size, total_size - (symbol_size + lineno_size), " ");
403 free(modimage);
404 }
405
406 file_name += strlen(file_name) + 1;
407 file = (char*)((DWORD_PTR)(file_name + strlen(file_name) + 1 + 3) & ~3);
408 }
409 free(symbols);
410 }
411
412 static void pdb_dump_types(struct pdb_reader* reader)
413 {
414 PDB_TYPES* types = NULL;
415
416 types = reader->read_file(reader, 2);
417
418 switch (types->version)
419 {
420 case 19950410: /* VC 4.0 */
421 case 19951122:
422 case 19961031: /* VC 5.0 / 6.0 */
423 case 19990903: /* VC 7.0 */
424 break;
425 default:
426 printf("-Unknown type info version %d\n", types->version);
427 }
428
429 /* Read type table */
430 printf("Types:\n"
431 "\tversion: %u\n"
432 "\ttype_offset: %08x\n"
433 "\tfirst_index: %x\n"
434 "\tlast_index: %x\n"
435 "\ttype_size: %x\n"
436 "\tfile: %x\n"
437 "\tpad: %x\n"
438 "\thash_size: %x\n"
439 "\thash_base: %x\n"
440 "\thash_offset: %x\n"
441 "\thash_len: %x\n"
442 "\tsearch_offset: %x\n"
443 "\tsearch_len: %x\n"
444 "\tunknown_offset: %x\n"
445 "\tunknown_len: %x\n",
446 types->version,
447 types->type_offset,
448 types->first_index,
449 types->last_index,
450 types->type_size,
451 types->file,
452 types->pad,
453 types->hash_size,
454 types->hash_base,
455 types->hash_offset,
456 types->hash_len,
457 types->search_offset,
458 types->search_len,
459 types->unknown_offset,
460 types->unknown_len);
461 codeview_dump_types_from_block((const char*)types + types->type_offset, types->type_size);
462 free(types);
463 }
464
465 static const char pdb2[] = "Microsoft C/C++ program database 2.00";
466
467 static void pdb_jg_dump(void)
468 {
469 struct pdb_reader reader;
470 struct PDB_JG_ROOT* root = NULL;
471
472 /*
473 * Read in TOC and well-known files
474 */
475 pdb_jg_init(&reader);
476 printf("Header (JG):\n"
477 "\tident: %.*s\n"
478 "\tsignature: %08x\n"
479 "\tblock_size: %08x\n"
480 "\tfree_list: %04x\n"
481 "\ttotal_alloc:%04x\n",
482 (int)sizeof(pdb2) - 1, reader.u.jg.header->ident,
483 reader.u.jg.header->signature,
484 reader.u.jg.header->block_size,
485 reader.u.jg.header->free_list,
486 reader.u.jg.header->total_alloc);
487
488 root = reader.read_file(&reader, 1);
489
490 if (root)
491 {
492 printf("Root:\n"
493 "\tVersion: %u\n"
494 "\tTimeDateStamp: %08x\n"
495 "\tAge: %08x\n"
496 "\tnames: %.*s\n",
497 root->Version,
498 root->TimeDateStamp,
499 root->Age,
500 (unsigned)root->cbNames,
501 root->names);
502
503 /* Check for unknown versions */
504 switch (root->Version)
505 {
506 case 19950623: /* VC 4.0 */
507 case 19950814:
508 case 19960307: /* VC 5.0 */
509 case 19970604: /* VC 6.0 */
510 break;
511 default:
512 printf("-Unknown root block version %d\n", root->Version);
513 }
514 free(root);
515 }
516 else printf("-Unable to get root\n");
517
518 pdb_dump_types(&reader);
519 #if 0
520 /* segments info, index is unknown */
521 {
522 const void* segs = pdb_read_file(pdb, toc, 8); /* FIXME which index ??? */
523 const void* ptr = segs;
524
525 if (segs) while (ptr < segs + toc->file[8].size)
526 {
527 printf("Segment %s\n", (const char*)ptr);
528 ptr += (strlen(ptr) + 1 + 3) & ~3;
529 printf("\tdword[0]: %08lx\n", *(DWORD*)ptr); ptr += 4;
530 printf("\tdword[1]: %08lx\n", *(DWORD*)ptr); ptr += 4;
531 printf("\tdword[2]: %08lx\n", *(DWORD*)ptr); ptr += 4;
532 printf("\tdword[3]: %08lx\n", *(DWORD*)ptr); ptr += 4;
533 printf("\tdword[4]: %08lx\n", *(DWORD*)ptr); ptr += 4;
534 printf("\tdword[5]: %08lx\n", *(DWORD*)ptr); ptr += 4;
535 printf("\tdword[6]: %08lx\n", *(DWORD*)ptr); ptr += 4;
536 printf("\tdword[7]: %08lx\n", *(DWORD*)ptr); ptr += 4;
537 }
538 free(segs);
539 }
540 #endif
541
542 pdb_dump_symbols(&reader);
543 pdb_exit(&reader);
544 }
545
546 static void* pdb_ds_read(const struct PDB_DS_HEADER* header, const DWORD* block_list, int size)
547 {
548 int i, nBlocks;
549 BYTE* buffer;
550
551 if (!size) return NULL;
552
553 nBlocks = (size + header->block_size - 1) / header->block_size;
554 buffer = malloc(nBlocks * header->block_size);
555
556 for (i = 0; i < nBlocks; i++)
557 memcpy(buffer + i * header->block_size,
558 (const char*)header + block_list[i] * header->block_size, header->block_size);
559
560 return buffer;
561 }
562
563 static void* pdb_ds_read_file(struct pdb_reader* reader, DWORD file_number)
564 {
565 const DWORD* block_list;
566 DWORD i;
567
568 if (!reader->u.ds.toc || file_number >= reader->u.ds.toc->num_files) return NULL;
569
570 reader->file_used[file_number / 32] |= 1 << (file_number % 32);
571 if (reader->u.ds.toc->file_size[file_number] == 0 ||
572 reader->u.ds.toc->file_size[file_number] == 0xFFFFFFFF)
573 return NULL;
574 block_list = reader->u.ds.toc->file_size + reader->u.ds.toc->num_files;
575 for (i = 0; i < file_number; i++)
576 block_list += (reader->u.ds.toc->file_size[i] + reader->u.ds.header->block_size - 1) /
577 reader->u.ds.header->block_size;
578
579 return pdb_ds_read(reader->u.ds.header, block_list, reader->u.ds.toc->file_size[file_number]);
580 }
581
582 static BOOL pdb_ds_init(struct pdb_reader* reader)
583 {
584 reader->u.ds.header = PRD(0, sizeof(*reader->u.ds.header));
585 if (!reader->u.ds.header) return FALSE;
586 reader->read_file = pdb_ds_read_file;
587 reader->u.ds.toc = pdb_ds_read(reader->u.ds.header,
588 (const DWORD*)((const char*)reader->u.ds.header + reader->u.ds.header->toc_page * reader->u.ds.header->block_size),
589 reader->u.ds.header->toc_size);
590 memset(reader->file_used, 0, sizeof(reader->file_used));
591 return TRUE;
592 }
593
594 static const char pdb7[] = "Microsoft C/C++ MSF 7.00";
595
596 static void pdb_ds_dump(void)
597 {
598 struct pdb_reader reader;
599 struct PDB_DS_ROOT* root;
600
601 pdb_ds_init(&reader);
602 printf("Header (DS)\n"
603 "\tsignature: %.*s\n"
604 "\tblock_size: %08x\n"
605 "\tunknown1: %08x\n"
606 "\tnum_pages: %08x\n"
607 "\ttoc_size: %08x\n"
608 "\tunknown2: %08x\n"
609 "\ttoc_page: %08x\n",
610 (int)sizeof(pdb7) - 1, reader.u.ds.header->signature,
611 reader.u.ds.header->block_size,
612 reader.u.ds.header->unknown1,
613 reader.u.ds.header->num_pages,
614 reader.u.ds.header->toc_size,
615 reader.u.ds.header->unknown2,
616 reader.u.ds.header->toc_page);
617
618 /* files:
619 * 0: JG says old toc pages, I'd say free pages (tbc, low prio)
620 * 1: root structure
621 * 2: types
622 * 3: modules
623 */
624 root = reader.read_file(&reader, 1);
625 if (root)
626 {
627 const char* ptr;
628
629 printf("Root:\n"
630 "\tVersion: %u\n"
631 "\tTimeDateStamp: %08x\n"
632 "\tAge: %08x\n"
633 "\tguid %s\n"
634 "\tcbNames: %08x\n",
635 root->Version,
636 root->TimeDateStamp,
637 root->Age,
638 get_guid_str(&root->guid),
639 root->cbNames);
640 for (ptr = &root->names[0]; ptr < &root->names[0] + root->cbNames; ptr += strlen(ptr) + 1)
641 printf("\tString: %s\n", ptr);
642 /* follows an unknown list of DWORDs */
643 free(root);
644 }
645 else printf("-Unable to get root\n");
646
647 pdb_dump_types(&reader);
648 pdb_dump_symbols(&reader);
649
650 pdb_exit(&reader);
651 }
652
653 enum FileSig get_kind_pdb(void)
654 {
655 const char* head;
656
657 head = PRD(0, sizeof(pdb2) - 1);
658 if (head && !memcmp(head, pdb2, sizeof(pdb2) - 1))
659 return SIG_PDB;
660 head = PRD(0, sizeof(pdb7) - 1);
661 if (head && !memcmp(head, pdb7, sizeof(pdb7) - 1))
662 return SIG_PDB;
663 return SIG_UNKNOWN;
664 }
665
666 void pdb_dump(void)
667 {
668 const char* head;
669
670 /* init_types(); */
671 head = PRD(0, sizeof(pdb2) - 1);
672 if (head && !memcmp(head, pdb2, sizeof(pdb2) - 1))
673 {
674 pdb_jg_dump();
675 return;
676 }
677 head = PRD(0, sizeof(pdb7) - 1);
678 if (head && !memcmp(head, pdb7, sizeof(pdb7) - 1))
679 {
680 pdb_ds_dump();
681 return;
682 }
683 printf("Unrecognized header %s\n", head);
684 }
Maarten's multimedia branch