minor fixes
[ia32rtools.git] / tools / protoparse.h
1 /*
2  * ia32rtools
3  * (C) notaz, 2013,2014
4  *
5  * This work is licensed under the terms of 3-clause BSD license.
6  * See COPYING file in the top-level directory.
7  */
8
9 struct parsed_proto;
10
11 struct parsed_type {
12         char *name;
13         unsigned int is_array:1;
14         unsigned int is_ptr:1;
15         unsigned int is_struct:1; // split for args
16         unsigned int is_retreg:1; // register to return to caller
17         unsigned int is_va_list:1;
18 };
19
20 struct parsed_proto_arg {
21         char *reg;
22         struct parsed_type type;
23         struct parsed_proto *fptr;
24         void *datap;
25 };
26
27 struct parsed_proto {
28         char name[256];
29         union {
30                 struct parsed_type ret_type;
31                 struct parsed_type type;
32         };
33         struct parsed_proto_arg arg[16];
34         int argc;
35         int argc_stack;
36         int argc_reg;
37         unsigned int is_func:1;
38         unsigned int is_stdcall:1;
39         unsigned int is_fastcall:1;
40         unsigned int is_vararg:1;     // vararg func
41         unsigned int is_fptr:1;
42         unsigned int is_noreturn:1;
43         unsigned int is_unresolved:1;
44         unsigned int is_userstack:1;
45         unsigned int is_include:1;    // not from top-level header
46         unsigned int is_osinc:1;      // OS/system library func
47         unsigned int is_cinc:1;       // crt library func
48         unsigned int is_arg:1;        // declared in some func arg
49         unsigned int has_structarg:1;
50         unsigned int has_retreg:1;
51 };
52
53 struct parsed_struct {
54         char name[256];
55         struct {
56                 int offset;
57                 struct parsed_proto pp;
58         } members[64];
59         int member_count;
60 };
61
62 static const char *hdrfn;
63 static int hdrfline = 0;
64
65 static void pp_copy_arg(struct parsed_proto_arg *d,
66         const struct parsed_proto_arg *s);
67
68 static int b_pp_c_handler(char *proto, const char *fname,
69         int is_include, int is_osinc, int is_cinc);
70 static int struct_handler(FILE *fhdr, char *proto, int *line);
71
72 static int do_protostrs(FILE *fhdr, const char *fname, int is_include)
73 {
74         const char *finc_name;
75         const char *hdrfn_saved;
76         char protostr[256];
77         char path[256];
78         char fname_inc[256];
79         int is_osinc;
80         int is_cinc;
81         FILE *finc;
82         int line = 0;
83         int ret;
84         char *p;
85
86         hdrfn_saved = hdrfn;
87         hdrfn = fname;
88
89         is_cinc = strstr(fname, "stdc.hlist") != NULL;
90         is_osinc = is_cinc || strstr(fname, "win32.hlist") != NULL;
91
92         while (fgets(protostr, sizeof(protostr), fhdr))
93         {
94                 line++;
95                 if (strncmp(protostr, "//#include ", 11) == 0) {
96                         finc_name = protostr + 11;
97                         p = strpbrk(finc_name, "\r\n ");
98                         if (p != NULL)
99                                 *p = 0;
100
101                         path[0] = 0;
102                         p = strrchr(hdrfn_saved, '/');
103                         if (p) {
104                                 memcpy(path, hdrfn_saved,
105                                         p - hdrfn_saved + 1);
106                                 path[p - hdrfn_saved + 1] = 0;
107                         }
108                         snprintf(fname_inc, sizeof(fname_inc), "%s%s", 
109                                 path, finc_name);
110                         finc = fopen(fname_inc, "r");
111                         if (finc == NULL) {
112                                 printf("%s:%d: can't open '%s'\n",
113                                         fname_inc, line, finc_name);
114                                 continue;
115                         }
116                         ret = do_protostrs(finc, finc_name, 1);
117                         fclose(finc);
118                         if (ret < 0)
119                                 break;
120                         continue;
121                 }
122                 if (strncmp(sskip(protostr), "//", 2) == 0)
123                         continue;
124
125                 p = protostr + strlen(protostr);
126                 for (p--; p >= protostr && my_isblank(*p); --p)
127                         *p = 0;
128                 if (p < protostr)
129                         continue;
130
131                 hdrfline = line;
132
133                 if (!strncmp(protostr, "struct", 6)
134                     && strchr(protostr, '{') != NULL)
135                         ret = struct_handler(fhdr, protostr, &line);
136                 else
137                         ret = b_pp_c_handler(protostr, hdrfn,
138                                 is_include, is_osinc, is_cinc);
139                 if (ret < 0)
140                         break;
141         }
142
143         hdrfn = hdrfn_saved;
144
145         if (feof(fhdr))
146                 return 0;
147
148         return -1;
149 }
150
151 static int get_regparm(char *dst, size_t dlen, char *p, int *retreg)
152 {
153         int i = 0, o;
154
155         *retreg = 0;
156
157         if (*p != '<')
158                 return 0;
159
160         i++;
161         if (p[i] == '*') {
162                 *retreg = 1;
163                 i++;
164         }
165
166         for (o = 0; o < dlen; i++) {
167                 if (p[i] == 0)
168                         return 0;
169                 if (p[i] == '>')
170                         break;
171                 dst[o++] = p[i];
172         }
173         dst[o] = 0;
174         return i + 1;
175 }
176
177 // hmh..
178 static const char *known_type_mod[] = {
179         "const",
180         "signed",
181         "unsigned",
182         "enum",
183         "CONST",
184         "volatile",
185 };
186
187 static const char *known_ptr_types[] = {
188         "FARPROC",
189         "WNDPROC",
190         "LINECALLBACK",
191         "HACCEL",
192         "HANDLE",
193         "HBITMAP",
194         "HCALL",
195         "HCURSOR",
196         "HDC",
197         "HFONT",
198         "HGDIOBJ",
199         "HGLOBAL",
200         "HICON",
201         "HINSTANCE",
202         "HIMC", // DWORD in mingw, ptr in wine..
203         "HLINE",
204         "HLINEAPP",
205         "HLOCAL",
206         "HMODULE",
207         "HPALETTE",
208         "HRGN",
209         "HRSRC",
210         "HKEY",
211         "HMENU",
212         "HWAVEOUT",
213         "HWND",
214         "PBYTE",
215         "PCRITICAL_SECTION",
216         "PDWORD",
217         "PFILETIME",
218         "PLARGE_INTEGER",
219         "PHKEY",
220         "PLONG",
221         "PMEMORY_BASIC_INFORMATION",
222         "PUINT",
223         "PVOID",
224         "PCVOID",
225         "PWORD",
226         "DLGPROC",
227         "TIMERPROC",
228         "WNDENUMPROC",
229         "va_list",
230         "__VALIST",
231 };
232
233 static const char *ignored_keywords[] = {
234         "extern",
235         "WINBASEAPI",
236         "WINUSERAPI",
237         "WINGDIAPI",
238         "WINADVAPI",
239 };
240
241 static int typecmp(const char *n, const char *t)
242 {
243         for (; *t != 0; n++, t++) {
244                 while (n[0] == ' ' && (n[1] == ' ' || n[1] == '*'))
245                         n++;
246                 while (t[0] == ' ' && (t[1] == ' ' || t[1] == '*'))
247                         t++;
248                 if (*n != *t)
249                         return *n - *t;
250         }
251
252         return 0;
253 }
254
255 static const char *skip_type_mod(const char *n)
256 {
257         int len;
258         int i;
259
260         for (i = 0; i < ARRAY_SIZE(known_type_mod); i++) {
261                 len = strlen(known_type_mod[i]);
262                 if (strncmp(n, known_type_mod[i], len) != 0)
263                         continue;
264                 if (!my_isblank(n[len]))
265                         continue;
266
267                 n += len;
268                 while (my_isblank(*n))
269                         n++;
270                 i = 0;
271         }
272
273         return n;
274 }
275
276 static int check_type(const char *name, struct parsed_type *type)
277 {
278         const char *n, *n1;
279         int ret = -1;
280         int i;
281
282         n = skip_type_mod(name);
283
284         if (!strncmp(n, "struct", 6) && my_isblank(n[6])) {
285                 type->is_struct = 1;
286
287                 n += 6;
288                 while (my_isblank(*n))
289                         n++;
290         }
291
292         for (i = 0; i < ARRAY_SIZE(known_ptr_types); i++) {
293                 if (typecmp(n, known_ptr_types[i]))
294                         continue;
295
296                 type->is_ptr = 1;
297                 break;
298         }
299
300         if (n[0] == 'L' && n[1] == 'P' && strncmp(n, "LPARAM", 6))
301                 type->is_ptr = 1;
302
303         // assume single word
304         while (!my_isblank(*n) && !my_issep(*n))
305                 n++;
306
307         while (1) {
308                 n1 = n;
309                 while (my_isblank(*n))
310                         n++;
311                 if (*n == '*') {
312                         type->is_ptr = 1;
313                         n++;
314                         continue;
315                 }
316                 break;
317         }
318
319         ret = n1 - name;
320         type->name = strndup(name, ret);
321         if (IS(type->name, "__VALIST") || IS(type->name, "va_list"))
322                 type->is_va_list = 1;
323         if (IS(type->name, "VOID"))
324                 memcpy(type->name, "void", 4);
325
326         return ret;
327 }
328
329 /* args are always expanded to 32bit */
330 static const char *map_reg(const char *reg)
331 {
332         const char *regs_f[] = { "eax", "ebx", "ecx", "edx", "esi", "edi" };
333         const char *regs_w[] = { "ax",  "bx",  "cx",  "dx",  "si",  "di" };
334         const char *regs_b[] = { "al",  "bl",  "cl",  "dl" };
335         int i;
336
337         for (i = 0; i < ARRAY_SIZE(regs_w); i++)
338                 if (IS(reg, regs_w[i]))
339                         return regs_f[i];
340
341         for (i = 0; i < ARRAY_SIZE(regs_b); i++)
342                 if (IS(reg, regs_b[i]))
343                         return regs_f[i];
344
345         return reg;
346 }
347
348 static int check_struct_arg(struct parsed_proto_arg *arg)
349 {
350         if (IS(arg->type.name, "POINT"))
351                 return 2 - 1;
352
353         return 0;
354 }
355
356 static int parse_protostr(char *protostr, struct parsed_proto *pp)
357 {
358         struct parsed_proto_arg *arg;
359         char regparm[16];
360         char buf[256];
361         char cconv[32];
362         int is_retreg;
363         int xarg = 0;
364         char *p, *p1;
365         int i, l;
366         int ret;
367
368         p = sskip(protostr);
369         if (p[0] == '/' && p[1] == '/') {
370                 printf("%s:%d: commented out?\n", hdrfn, hdrfline);
371                 p = sskip(p + 2);
372         }
373
374         // allow start of line comment
375         if (p[0] == '/' && p[1] == '*') {
376                 p = strstr(p + 2, "*/");
377                 if (p == NULL) {
378                         printf("%s:%d: multiline comments unsupported\n",
379                                 hdrfn, hdrfline);
380                         return -1;
381                 }
382                 p = sskip(p + 2);
383         }
384
385         // we need remaining hints in comments, so strip / *
386         for (p1 = p; p1[0] != 0 && p1[1] != 0; p1++) {
387                 if ((p1[0] == '/' && p1[1] == '*')
388                  || (p1[0] == '*' && p1[1] == '/'))
389                         p1[0] = p1[1] = ' ';
390         }
391
392         if (!strncmp(p, "DECLSPEC_NORETURN ", 18)) {
393                 pp->is_noreturn = 1;
394                 p = sskip(p + 18);
395         }
396
397         for (i = 0; i < ARRAY_SIZE(ignored_keywords); i++) {
398                 l = strlen(ignored_keywords[i]);
399                 if (!strncmp(p, ignored_keywords[i], l) && my_isblank(p[l]))
400                         p = sskip(p + l + 1);
401         }
402
403         ret = check_type(p, &pp->ret_type);
404         if (ret <= 0) {
405                 printf("%s:%d:%zd: unhandled return in '%s'\n",
406                         hdrfn, hdrfline, (p - protostr) + 1, protostr);
407                 return -1;
408         }
409         p = sskip(p + ret);
410
411         if (!strncmp(p, "noreturn ", 9)) {
412                 pp->is_noreturn = 1;
413                 p = sskip(p + 9);
414         }
415
416         if (!strchr(p, ')')) {
417                 p = next_idt(buf, sizeof(buf), p);
418                 p = sskip(p);
419                 if (buf[0] == 0) {
420                         printf("%s:%d:%zd: var name missing\n",
421                                 hdrfn, hdrfline, (p - protostr) + 1);
422                         return -1;
423                 }
424                 strcpy(pp->name, buf);
425
426                 p1 = strchr(p, ']');
427                 if (p1 != NULL) {
428                         p = p1 + 1;
429                         pp->ret_type.is_array = 1;
430                 }
431                 return p - protostr;
432         }
433
434         pp->is_func = 1;
435
436         if (*p == '(') {
437                 pp->is_fptr = 1;
438                 p = sskip(p + 1);
439         }
440
441         p = next_word(cconv, sizeof(cconv), p);
442         p = sskip(p);
443         if (cconv[0] == 0) {
444                 printf("%s:%d:%zd: cconv missing\n",
445                         hdrfn, hdrfline, (p - protostr) + 1);
446                 return -1;
447         }
448         if      (IS(cconv, "__cdecl"))
449                 pp->is_stdcall = 0;
450         else if (IS(cconv, "__stdcall"))
451                 pp->is_stdcall = 1;
452         else if (IS(cconv, "__fastcall")) {
453                 pp->is_fastcall = 1;
454                 pp->is_stdcall = 1; // sort of..
455         }
456         else if (IS(cconv, "__thiscall"))
457                 pp->is_stdcall = 1;
458         else if (IS(cconv, "__userpurge"))
459                 pp->is_stdcall = 1; // IDA
460         else if (IS(cconv, "__usercall"))
461                 pp->is_stdcall = 0; // IDA
462         else if (IS(cconv, "__userstack")) {
463                 pp->is_stdcall = 0; // custom
464                 pp->is_userstack = 1;
465         }
466         else if (IS(cconv, "WINAPI"))
467                 pp->is_stdcall = 1;
468         else {
469                 printf("%s:%d:%zd: unhandled cconv: '%s'\n",
470                         hdrfn, hdrfline, (p - protostr) + 1, cconv);
471                 return -1;
472         }
473
474         if (pp->is_fptr) {
475                 if (*p != '*') {
476                         printf("%s:%d:%zd: '*' expected\n",
477                                 hdrfn, hdrfline, (p - protostr) + 1);
478                         return -1;
479                 }
480                 p++;
481                 // XXX: skipping extra asterisks, for now
482                 while (*p == '*')
483                         p++;
484                 p = sskip(p);
485         }
486
487         p = next_idt(buf, sizeof(buf), p);
488         p = sskip(p);
489         if (buf[0] == 0) {
490                 //printf("%s:%d:%zd: func name missing\n",
491                 //      hdrfn, hdrfline, (p - protostr) + 1);
492                 //return -1;
493         }
494         strcpy(pp->name, buf);
495
496         ret = get_regparm(regparm, sizeof(regparm), p, &is_retreg);
497         if (ret > 0) {
498                 if (!IS(regparm, "eax") && !IS(regparm, "ax")
499                  && !IS(regparm, "al") && !IS(regparm, "edx:eax"))
500                 {
501                         printf("%s:%d:%zd: bad regparm: %s\n",
502                                 hdrfn, hdrfline, (p - protostr) + 1, regparm);
503                         return -1;
504                 }
505                 p += ret;
506                 p = sskip(p);
507         }
508
509         if (pp->is_fptr) {
510                 if (*p == '[') {
511                         // not really ret_type is array, but ohwell
512                         pp->ret_type.is_array = 1;
513                         p = strchr(p + 1, ']');
514                         if (p == NULL) {
515                                 printf("%s:%d:%zd: ']' expected\n",
516                                  hdrfn, hdrfline, (p - protostr) + 1);
517                                 return -1;
518                         }
519                         p = sskip(p + 1);
520                 }
521                 if (*p != ')') {
522                         printf("%s:%d:%zd: ')' expected\n",
523                                 hdrfn, hdrfline, (p - protostr) + 1);
524                         return -1;
525                 }
526                 p = sskip(p + 1);
527         }
528
529         if (*p != '(') {
530                 printf("%s:%d:%zd: '(' expected, got '%c'\n",
531                                 hdrfn, hdrfline, (p - protostr) + 1, *p);
532                 return -1;
533         }
534         p++;
535
536         // check for x(void)
537         p = sskip(p);
538         if ((!strncmp(p, "void", 4) || !strncmp(p, "VOID", 4))
539            && *sskip(p + 4) == ')')
540                 p += 4;
541
542         while (1) {
543                 p = sskip(p);
544                 if (*p == ')') {
545                         p++;
546                         break;
547                 }
548                 if (xarg > 0) {
549                         if (*p != ',') {
550                                 printf("%s:%d:%zd: ',' expected\n",
551                                  hdrfn, hdrfline, (p - protostr) + 1);
552                                 return -1;
553                         }
554                         p = sskip(p + 1);
555                 }
556
557                 if (!strncmp(p, "...", 3)) {
558                         pp->is_vararg = 1;
559                         p = sskip(p + 3);
560                         if (*p == ')') {
561                                 p++;
562                                 break;
563                         }
564                         printf("%s:%d:%zd: ')' expected\n",
565                                 hdrfn, hdrfline, (p - protostr) + 1);
566                         return -1;
567                 }
568
569                 arg = &pp->arg[xarg];
570                 xarg++;
571
572                 p1 = p;
573                 ret = check_type(p, &arg->type);
574                 if (ret <= 0) {
575                         printf("%s:%d:%zd: unhandled type for arg%d\n",
576                                 hdrfn, hdrfline, (p - protostr) + 1, xarg);
577                         return -1;
578                 }
579                 p = sskip(p + ret);
580
581                 if (*p == '(') {
582                         // func ptr
583                         arg->fptr = calloc(1, sizeof(*arg->fptr));
584                         ret = parse_protostr(p1, arg->fptr);
585                         if (ret < 0) {
586                                 printf("%s:%d:%zd: funcarg parse failed\n",
587                                         hdrfn, hdrfline, p1 - protostr);
588                                 return -1;
589                         }
590                         arg->fptr->is_arg = 1;
591                         // we don't use actual names right now..
592                         snprintf(arg->fptr->name,
593                                 sizeof(arg->fptr->name), "a%d", xarg);
594                         // we'll treat it as void * for non-calls
595                         arg->type.name = strdup("void *");
596                         arg->type.is_ptr = 1;
597
598                         p = p1 + ret;
599                 }
600
601                 p = next_idt(buf, sizeof(buf), p);
602                 p = sskip(p);
603 #if 0
604                 if (buf[0] == 0) {
605                         printf("%s:%d:%zd: idt missing for arg%d\n",
606                                 hdrfn, hdrfline, (p - protostr) + 1, xarg);
607                         return -1;
608                 }
609 #endif
610                 arg->reg = NULL;
611
612                 ret = get_regparm(regparm, sizeof(regparm), p, &is_retreg);
613                 if (ret > 0) {
614                         p += ret;
615                         p = sskip(p);
616
617                         arg->reg = strdup(map_reg(regparm));
618                         arg->type.is_retreg = is_retreg;
619                         pp->has_retreg |= is_retreg;
620                 }
621
622                 if (strstr(arg->type.name, "int64")
623                     || IS(arg->type.name, "double"))
624                 {
625                         // hack..
626                         free(arg->type.name);
627                         arg->type.name = strdup("int");
628                         pp_copy_arg(&pp->arg[xarg], arg);
629                         xarg++;
630                 }
631
632                 ret = check_struct_arg(arg);
633                 if (ret > 0) {
634                         pp->has_structarg = 1;
635                         arg->type.is_struct = 1;
636                         free(arg->type.name);
637                         arg->type.name = strdup("int");
638                         for (l = 0; l < ret; l++) {
639                                 pp_copy_arg(&pp->arg[xarg], arg);
640                                 xarg++;
641                         }
642                 }
643         }
644
645         if (xarg > 0 && (IS(cconv, "__fastcall") || IS(cconv, "__thiscall"))) {
646                 if (pp->arg[0].reg != NULL) {
647                         printf("%s:%d: %s with arg1 spec %s?\n",
648                                 hdrfn, hdrfline, cconv, pp->arg[0].reg);
649                 }
650                 pp->arg[0].reg = strdup("ecx");
651         }
652
653         if (xarg > 1 && IS(cconv, "__fastcall")) {
654                 if (pp->arg[1].reg != NULL) {
655                         printf("%s:%d: %s with arg2 spec %s?\n",
656                                 hdrfn, hdrfline, cconv, pp->arg[1].reg);
657                 }
658                 pp->arg[1].reg = strdup("edx");
659         }
660
661         pp->argc = xarg;
662
663         for (i = 0; i < pp->argc; i++) {
664                 if (pp->arg[i].reg == NULL)
665                         pp->argc_stack++;
666                 else
667                         pp->argc_reg++;
668         }
669
670         if (pp->argc == 1 && pp->arg[0].reg != NULL
671             && IS(pp->arg[0].reg, "ecx"))
672         {
673                 pp->is_fastcall = 1;
674         }
675         else if (pp->argc_reg == 2
676           && pp->arg[0].reg != NULL && IS(pp->arg[0].reg, "ecx")
677           && pp->arg[1].reg != NULL && IS(pp->arg[1].reg, "edx"))
678         {
679                 pp->is_fastcall = 1;
680         }
681
682         if (pp->is_vararg && (pp->is_stdcall || pp->is_fastcall)) {
683                 printf("%s:%d: vararg %s?\n", hdrfn, hdrfline, cconv);
684                 return -1;
685         }
686
687         return p - protostr;
688 }
689
690 static int pp_name_cmp(const void *p1, const void *p2)
691 {
692         const struct parsed_proto *pp1 = p1, *pp2 = p2;
693         return strcmp(pp1->name, pp2->name);
694 }
695
696 static int ps_name_cmp(const void *p1, const void *p2)
697 {
698         const struct parsed_struct *ps1 = p1, *ps2 = p2;
699         return strcmp(ps1->name, ps2->name);
700 }
701
702 // parsed struct cache
703 static struct parsed_struct *ps_cache;
704 static int ps_cache_size;
705 static int ps_cache_alloc;
706
707 static int struct_handler(FILE *fhdr, char *proto, int *line)
708 {
709         struct parsed_struct *ps;
710         char lstr[256], *p;
711         int offset = 0;
712         int m = 0;
713         int ret;
714
715         if (ps_cache_size >= ps_cache_alloc) {
716                 ps_cache_alloc = ps_cache_alloc * 2 + 64;
717                 ps_cache = realloc(ps_cache, ps_cache_alloc
718                                 * sizeof(ps_cache[0]));
719                 my_assert_not(ps_cache, NULL);
720                 memset(ps_cache + ps_cache_size, 0,
721                         (ps_cache_alloc - ps_cache_size)
722                          * sizeof(ps_cache[0]));
723         }
724
725         ps = &ps_cache[ps_cache_size++];
726         ret = sscanf(proto, "struct %255s {", ps->name);
727         if (ret != 1) {
728                 printf("%s:%d: struct parse failed\n", hdrfn, *line);
729                 return -1;
730         }
731
732         while (fgets(lstr, sizeof(lstr), fhdr))
733         {
734                 (*line)++;
735
736                 p = sskip(lstr);
737                 if (p[0] == '/' && p[1] == '/')
738                         continue;
739                 if (p[0] == '}')
740                         break;
741
742                 if (m >= ARRAY_SIZE(ps->members)) {
743                         printf("%s:%d: too many struct members\n",
744                                 hdrfn, *line);
745                         return -1;
746                 }
747
748                 hdrfline = *line;
749                 ret = parse_protostr(p, &ps->members[m].pp);
750                 if (ret < 0) {
751                         printf("%s:%d: struct member #%d/%02x "
752                                 "doesn't parse\n", hdrfn, *line,
753                                 m, offset);
754                         return -1;
755                 }
756                 ps->members[m].offset = offset;
757                 offset += 4;
758                 m++;
759         }
760
761         ps->member_count = m;
762
763         return 0;
764 }
765
766 // parsed proto cache
767 static struct parsed_proto *pp_cache;
768 static int pp_cache_size;
769 static int pp_cache_alloc;
770
771 static int b_pp_c_handler(char *proto, const char *fname,
772         int is_include, int is_osinc, int is_cinc)
773 {
774         int ret;
775
776         if (pp_cache_size >= pp_cache_alloc) {
777                 pp_cache_alloc = pp_cache_alloc * 2 + 64;
778                 pp_cache = realloc(pp_cache, pp_cache_alloc
779                                 * sizeof(pp_cache[0]));
780                 my_assert_not(pp_cache, NULL);
781                 memset(pp_cache + pp_cache_size, 0,
782                         (pp_cache_alloc - pp_cache_size)
783                          * sizeof(pp_cache[0]));
784         }
785
786         ret = parse_protostr(proto, &pp_cache[pp_cache_size]);
787         if (ret < 0)
788                 return -1;
789
790         pp_cache[pp_cache_size].is_include = is_include;
791         pp_cache[pp_cache_size].is_osinc = is_osinc;
792         pp_cache[pp_cache_size].is_cinc = is_cinc;
793         pp_cache_size++;
794         return 0;
795 }
796
797 static void build_caches(FILE *fhdr)
798 {
799         long pos;
800         int ret;
801
802         pos = ftell(fhdr);
803         rewind(fhdr);
804
805         ret = do_protostrs(fhdr, hdrfn, 0);
806         if (ret < 0)
807                 exit(1);
808
809         qsort(pp_cache, pp_cache_size, sizeof(pp_cache[0]), pp_name_cmp);
810         qsort(ps_cache, ps_cache_size, sizeof(ps_cache[0]), ps_name_cmp);
811         fseek(fhdr, pos, SEEK_SET);
812 }
813
814 static const struct parsed_proto *proto_parse(FILE *fhdr, const char *sym,
815         int quiet)
816 {
817         const struct parsed_proto *pp_ret;
818         struct parsed_proto pp_search;
819         char *p;
820
821         if (pp_cache == NULL)
822                 build_caches(fhdr);
823
824         if (sym[0] == '_') // && strncmp(fname, "stdc", 4) == 0)
825                 sym++;
826
827         strcpy(pp_search.name, sym);
828         p = strchr(pp_search.name, '@');
829         if (p != NULL)
830                 *p = 0;
831
832         pp_ret = bsearch(&pp_search, pp_cache, pp_cache_size,
833                         sizeof(pp_cache[0]), pp_name_cmp);
834         if (pp_ret == NULL && !quiet)
835                 printf("%s: sym '%s' is missing\n", hdrfn, sym);
836
837         return pp_ret;
838 }
839
840 static const struct parsed_proto *proto_lookup_struct(FILE *fhdr,
841         const char *type, int offset)
842 {
843         struct parsed_struct ps_search, *ps;
844         int m;
845
846         if (pp_cache == NULL)
847                 build_caches(fhdr);
848         if (ps_cache_size == 0)
849                 return NULL;
850
851         while (my_isblank(*type))
852                 type++;
853         if (!strncmp(type, "struct", 6) && my_isblank(type[6]))
854                 type += 7;
855
856         if (sscanf(type, "%255s", ps_search.name) != 1)
857                 return NULL;
858
859         ps = bsearch(&ps_search, ps_cache, ps_cache_size,
860                         sizeof(ps_cache[0]), ps_name_cmp);
861         if (ps == NULL) {
862                 printf("%s: struct '%s' is missing\n",
863                         hdrfn, ps_search.name);
864                 return NULL;
865         }
866
867         for (m = 0; m < ps->member_count; m++) {
868                 if (ps->members[m].offset == offset)
869                         return &ps->members[m].pp;
870         }
871
872         return NULL;
873 }
874
875 static void pp_copy_arg(struct parsed_proto_arg *d,
876         const struct parsed_proto_arg *s)
877 {
878         memcpy(d, s, sizeof(*d));
879
880         if (s->reg != NULL) {
881                 d->reg = strdup(s->reg);
882                 my_assert_not(d->reg, NULL);
883         }
884         if (s->type.name != NULL) {
885                 d->type.name = strdup(s->type.name);
886                 my_assert_not(d->type.name, NULL);
887         }
888         if (s->fptr != NULL) {
889                 d->fptr = malloc(sizeof(*d->fptr));
890                 my_assert_not(d->fptr, NULL);
891                 memcpy(d->fptr, s->fptr, sizeof(*d->fptr));
892         }
893 }
894
895 struct parsed_proto *proto_clone(const struct parsed_proto *pp_c)
896 {
897         struct parsed_proto *pp;
898         int i;
899
900         pp = malloc(sizeof(*pp));
901         my_assert_not(pp, NULL);
902         memcpy(pp, pp_c, sizeof(*pp)); // lazy..
903
904         // do the actual deep copy..
905         for (i = 0; i < pp_c->argc; i++)
906                 pp_copy_arg(&pp->arg[i], &pp_c->arg[i]);
907         if (pp_c->ret_type.name != NULL)
908                 pp->ret_type.name = strdup(pp_c->ret_type.name);
909
910         return pp;
911 }
912
913
914 static inline int pp_cmp_func(const struct parsed_proto *pp1,
915   const struct parsed_proto *pp2)
916 {
917   int i;
918
919   if (pp1->argc != pp2->argc || pp1->argc_reg != pp2->argc_reg)
920     return 1;
921   else {
922     for (i = 0; i < pp1->argc; i++) {
923       if ((pp1->arg[i].reg != NULL) != (pp2->arg[i].reg != NULL))
924         return 1;
925
926       if ((pp1->arg[i].reg != NULL)
927         && !IS(pp1->arg[i].reg, pp2->arg[i].reg))
928       {
929         return 1;
930       }
931     }
932   }
933
934   return 0;
935 }
936
937 static inline void pp_print(char *buf, size_t buf_size,
938   const struct parsed_proto *pp)
939 {
940   size_t l;
941   int i;
942
943   snprintf(buf, buf_size, "%s %s(", pp->ret_type.name, pp->name);
944   l = strlen(buf);
945
946   for (i = 0; i < pp->argc_reg; i++) {
947     snprintf(buf + l, buf_size - l, "%s%s",
948       i == 0 ? "" : ", ", pp->arg[i].reg);
949     l = strlen(buf);
950   }
951   if (pp->argc_stack > 0) {
952     snprintf(buf + l, buf_size - l, "%s{%d stack}",
953       i == 0 ? "" : ", ", pp->argc_stack);
954     l = strlen(buf);
955   }
956   snprintf(buf + l, buf_size - l, ")");
957 }
958
959 static inline void proto_release(struct parsed_proto *pp)
960 {
961         int i;
962
963         for (i = 0; i < pp->argc; i++) {
964                 if (pp->arg[i].reg != NULL)
965                         free(pp->arg[i].reg);
966                 if (pp->arg[i].type.name != NULL)
967                         free(pp->arg[i].type.name);
968                 if (pp->arg[i].fptr != NULL)
969                         free(pp->arg[i].fptr);
970         }
971         if (pp->ret_type.name != NULL)
972                 free(pp->ret_type.name);
973         free(pp);
974
975         (void)proto_lookup_struct;
976 }