fix prototypes for data refs, tune var decl in translator
[ia32rtools.git] / tools / protoparse.h
1
2 struct parsed_proto;
3
4 struct parsed_type {
5         char *name;
6         unsigned int is_array:1;
7         unsigned int is_ptr:1;
8         unsigned int is_struct:1; // split for args
9 };
10
11 struct parsed_proto_arg {
12         char *reg;
13         struct parsed_type type;
14         struct parsed_proto *fptr;
15         void *datap;
16 };
17
18 struct parsed_proto {
19         char name[256];
20         union {
21                 struct parsed_type ret_type;
22                 struct parsed_type type;
23         };
24         struct parsed_proto_arg arg[16];
25         int argc;
26         int argc_stack;
27         int argc_reg;
28         unsigned int is_func:1;
29         unsigned int is_stdcall:1;
30         unsigned int is_vararg:1;
31         unsigned int is_fptr:1;
32         unsigned int is_noreturn:1;
33         unsigned int has_structarg:1;
34 };
35
36 static const char *hdrfn;
37 static int hdrfline = 0;
38
39 static void pp_copy_arg(struct parsed_proto_arg *d,
40         const struct parsed_proto_arg *s);
41
42 static int b_pp_c_handler(char *proto, const char *fname);
43
44 static int do_protostrs(FILE *fhdr, const char *fname)
45 {
46         const char *finc_name;
47         const char *hdrfn_saved;
48         char protostr[256];
49         char path[256];
50         char fname_inc[256];
51         FILE *finc;
52         int line = 0;
53         int ret;
54         char *p;
55
56         hdrfn_saved = hdrfn;
57         hdrfn = fname;
58
59         while (fgets(protostr, sizeof(protostr), fhdr))
60         {
61                 line++;
62                 if (strncmp(protostr, "//#include ", 11) == 0) {
63                         finc_name = protostr + 11;
64                         p = strpbrk(finc_name, "\r\n ");
65                         if (p != NULL)
66                                 *p = 0;
67
68                         path[0] = 0;
69                         p = strrchr(hdrfn_saved, '/');
70                         if (p) {
71                                 memcpy(path, hdrfn_saved,
72                                         p - hdrfn_saved + 1);
73                                 path[p - hdrfn_saved + 1] = 0;
74                         }
75                         snprintf(fname_inc, sizeof(fname_inc), "%s%s", 
76                                 path, finc_name);
77                         finc = fopen(fname_inc, "r");
78                         if (finc == NULL) {
79                                 printf("%s:%d: can't open '%s'\n",
80                                         fname_inc, line, finc_name);
81                                 continue;
82                         }
83                         ret = do_protostrs(finc, finc_name);
84                         fclose(finc);
85                         if (ret < 0)
86                                 break;
87                         continue;
88                 }
89                 if (strncmp(sskip(protostr), "//", 2) == 0)
90                         continue;
91
92                 p = protostr + strlen(protostr);
93                 for (p--; p >= protostr && my_isblank(*p); --p)
94                         *p = 0;
95                 if (p < protostr)
96                         continue;
97
98                 hdrfline = line;
99
100                 ret = b_pp_c_handler(protostr, hdrfn);
101                 if (ret < 0)
102                         break;
103         }
104
105         hdrfn = hdrfn_saved;
106
107         if (feof(fhdr))
108                 return 0;
109
110         return -1;
111 }
112
113 static int get_regparm(char *dst, size_t dlen, char *p)
114 {
115         int i, o;
116
117         if (*p != '<')
118                 return 0;
119
120         for (o = 0, i = 1; o < dlen; i++) {
121                 if (p[i] == 0)
122                         return 0;
123                 if (p[i] == '>')
124                         break;
125                 dst[o++] = p[i];
126         }
127         dst[o] = 0;
128         return i + 1;
129 }
130
131 // hmh..
132 static const char *known_type_mod[] = {
133         "const",
134         "signed",
135         "unsigned",
136         "struct",
137         "enum",
138         "CONST",
139 };
140
141 static const char *known_ptr_types[] = {
142         "HACCEL",
143         "HANDLE",
144         "HBITMAP",
145         "HCURSOR",
146         "HDC",
147         "HFONT",
148         "HGDIOBJ",
149         "HGLOBAL",
150         "HINSTANCE",
151         "HIMC",
152         "HMODULE",
153         "HRGN",
154         "HRSRC",
155         "HKEY",
156         "HMENU",
157         "HWND",
158         "PCRITICAL_SECTION",
159         "PDWORD",
160         "PHKEY",
161         "PLONG",
162         "PMEMORY_BASIC_INFORMATION",
163         "PUINT",
164         "PVOID",
165         "PCVOID",
166         "DLGPROC",
167         "TIMERPROC",
168         "WNDENUMPROC",
169         "va_list",
170         "__VALIST",
171 };
172
173 static const char *ignored_keywords[] = {
174         "extern",
175         "WINBASEAPI",
176         "WINUSERAPI",
177         "WINGDIAPI",
178         "WINADVAPI",
179 };
180
181 // returns ptr to char after type ends
182 static int typecmp(const char *n, const char *t)
183 {
184         for (; *t != 0; n++, t++) {
185                 while (n[0] == ' ' && (n[1] == ' ' || n[1] == '*'))
186                         n++;
187                 while (t[0] == ' ' && (t[1] == ' ' || t[1] == '*'))
188                         t++;
189                 if (*n != *t)
190                         return *n - *t;
191         }
192
193         return 0;
194 }
195
196 static const char *skip_type_mod(const char *n)
197 {
198         int len;
199         int i;
200
201         for (i = 0; i < ARRAY_SIZE(known_type_mod); i++) {
202                 len = strlen(known_type_mod[i]);
203                 if (strncmp(n, known_type_mod[i], len) != 0)
204                         continue;
205                 if (!my_isblank(n[len]))
206                         continue;
207
208                 n += len;
209                 while (my_isblank(*n))
210                         n++;
211                 i = 0;
212         }
213
214         return n;
215 }
216
217 static int check_type(const char *name, struct parsed_type *type)
218 {
219         const char *n, *n1;
220         int ret = -1;
221         int i;
222
223         n = skip_type_mod(name);
224
225         for (i = 0; i < ARRAY_SIZE(known_ptr_types); i++) {
226                 if (typecmp(n, known_ptr_types[i]))
227                         continue;
228
229                 type->is_ptr = 1;
230                 break;
231         }
232
233         if (n[0] == 'L' && n[1] == 'P' && strncmp(n, "LPARAM", 6))
234                 type->is_ptr = 1;
235
236         // assume single word
237         while (!my_isblank(*n) && !my_issep(*n))
238                 n++;
239
240         while (1) {
241                 n1 = n;
242                 while (my_isblank(*n))
243                         n++;
244                 if (*n == '*') {
245                         type->is_ptr = 1;
246                         n++;
247                         continue;
248                 }
249                 break;
250         }
251
252         ret = n1 - name;
253         type->name = strndup(name, ret);
254         if (IS(type->name, "VOID"))
255                 memcpy(type->name, "void", 4);
256
257         return ret;
258 }
259
260 /* args are always expanded to 32bit */
261 static const char *map_reg(const char *reg)
262 {
263         const char *regs_f[] = { "eax", "ebx", "ecx", "edx", "esi", "edi" };
264         const char *regs_w[] = { "ax",  "bx",  "cx",  "dx",  "si",  "di" };
265         const char *regs_b[] = { "al",  "bl",  "cl",  "dl" };
266         int i;
267
268         for (i = 0; i < ARRAY_SIZE(regs_w); i++)
269                 if (IS(reg, regs_w[i]))
270                         return regs_f[i];
271
272         for (i = 0; i < ARRAY_SIZE(regs_b); i++)
273                 if (IS(reg, regs_b[i]))
274                         return regs_f[i];
275
276         return reg;
277 }
278
279 static int check_struct_arg(struct parsed_proto_arg *arg)
280 {
281         if (IS(arg->type.name, "POINT"))
282                 return 2 - 1;
283
284         return 0;
285 }
286
287 static int parse_protostr(char *protostr, struct parsed_proto *pp)
288 {
289         struct parsed_proto_arg *arg;
290         char regparm[16];
291         char buf[256];
292         char cconv[32];
293         int xarg = 0;
294         char *p, *p1;
295         int i, l;
296         int ret;
297
298         p = sskip(protostr);
299         if (p[0] == '/' && p[1] == '/') {
300                 printf("%s:%d: commented out?\n", hdrfn, hdrfline);
301                 p = sskip(p + 2);
302         }
303
304         // strip unneeded stuff
305         for (p1 = p; p1[0] != 0 && p1[1] != 0; p1++) {
306                 if ((p1[0] == '/' && p1[1] == '*')
307                  || (p1[0] == '*' && p1[1] == '/'))
308                         p1[0] = p1[1] = ' ';
309         }
310
311         if (!strncmp(p, "DECLSPEC_NORETURN ", 18)) {
312                 pp->is_noreturn = 1;
313                 p = sskip(p + 18);
314         }
315
316         for (i = 0; i < ARRAY_SIZE(ignored_keywords); i++) {
317                 l = strlen(ignored_keywords[i]);
318                 if (!strncmp(p, ignored_keywords[i], l) && my_isblank(p[l]))
319                         p = sskip(p + l + 1);
320         }
321
322         ret = check_type(p, &pp->ret_type);
323         if (ret <= 0) {
324                 printf("%s:%d:%zd: unhandled return in '%s'\n",
325                         hdrfn, hdrfline, (p - protostr) + 1, protostr);
326                 return -1;
327         }
328         p = sskip(p + ret);
329
330         if (!strchr(p, ')')) {
331                 p = next_idt(buf, sizeof(buf), p);
332                 p = sskip(p);
333                 if (buf[0] == 0) {
334                         printf("%s:%d:%zd: var name missing\n",
335                                 hdrfn, hdrfline, (p - protostr) + 1);
336                         return -1;
337                 }
338                 strcpy(pp->name, buf);
339
340                 p1 = strchr(p, ']');
341                 if (p1 != NULL) {
342                         p = p1 + 1;
343                         pp->ret_type.is_array = 1;
344                 }
345                 return p - protostr;
346         }
347
348         pp->is_func = 1;
349
350         if (*p == '(') {
351                 pp->is_fptr = 1;
352                 p = sskip(p + 1);
353         }
354
355         p = next_word(cconv, sizeof(cconv), p);
356         p = sskip(p);
357         if (cconv[0] == 0) {
358                 printf("%s:%d:%zd: cconv missing\n",
359                         hdrfn, hdrfline, (p - protostr) + 1);
360                 return -1;
361         }
362         if      (IS(cconv, "__cdecl"))
363                 pp->is_stdcall = 0;
364         else if (IS(cconv, "__stdcall"))
365                 pp->is_stdcall = 1;
366         else if (IS(cconv, "__fastcall"))
367                 pp->is_stdcall = 1;
368         else if (IS(cconv, "__thiscall"))
369                 pp->is_stdcall = 1;
370         else if (IS(cconv, "__userpurge"))
371                 pp->is_stdcall = 1; // IDA
372         else if (IS(cconv, "__usercall"))
373                 pp->is_stdcall = 0; // IDA
374         else if (IS(cconv, "WINAPI"))
375                 pp->is_stdcall = 1;
376         else {
377                 printf("%s:%d:%zd: unhandled cconv: '%s'\n",
378                         hdrfn, hdrfline, (p - protostr) + 1, cconv);
379                 return -1;
380         }
381
382         if (pp->is_fptr) {
383                 if (*p != '*') {
384                         printf("%s:%d:%zd: '*' expected\n",
385                                 hdrfn, hdrfline, (p - protostr) + 1);
386                         return -1;
387                 }
388                 p++;
389                 // XXX: skipping extra asterisks, for now
390                 while (*p == '*')
391                         p++;
392                 p = sskip(p);
393         }
394
395         p = next_idt(buf, sizeof(buf), p);
396         p = sskip(p);
397         if (buf[0] == 0) {
398                 //printf("%s:%d:%zd: func name missing\n",
399                 //      hdrfn, hdrfline, (p - protostr) + 1);
400                 //return -1;
401         }
402         strcpy(pp->name, buf);
403
404         ret = get_regparm(regparm, sizeof(regparm), p);
405         if (ret > 0) {
406                 if (!IS(regparm, "eax") && !IS(regparm, "ax")
407                  && !IS(regparm, "al") && !IS(regparm, "edx:eax"))
408                 {
409                         printf("%s:%d:%zd: bad regparm: %s\n",
410                                 hdrfn, hdrfline, (p - protostr) + 1, regparm);
411                         return -1;
412                 }
413                 p += ret;
414                 p = sskip(p);
415         }
416
417         if (pp->is_fptr) {
418                 if (*p == '[') {
419                         // not really ret_type is array, but ohwell
420                         pp->ret_type.is_array = 1;
421                         p = strchr(p + 1, ']');
422                         if (p == NULL) {
423                                 printf("%s:%d:%zd: ']' expected\n",
424                                  hdrfn, hdrfline, (p - protostr) + 1);
425                                 return -1;
426                         }
427                         p = sskip(p + 1);
428                 }
429                 if (*p != ')') {
430                         printf("%s:%d:%zd: ')' expected\n",
431                                 hdrfn, hdrfline, (p - protostr) + 1);
432                         return -1;
433                 }
434                 p = sskip(p + 1);
435         }
436
437         if (*p != '(') {
438                 printf("%s:%d:%zd: '(' expected, got '%c'\n",
439                                 hdrfn, hdrfline, (p - protostr) + 1, *p);
440                 return -1;
441         }
442         p++;
443
444         // check for x(void)
445         p = sskip(p);
446         if ((!strncmp(p, "void", 4) || !strncmp(p, "VOID", 4))
447            && *sskip(p + 4) == ')')
448                 p += 4;
449
450         while (1) {
451                 p = sskip(p);
452                 if (*p == ')') {
453                         p++;
454                         break;
455                 }
456                 if (xarg > 0) {
457                         if (*p != ',') {
458                                 printf("%s:%d:%zd: ',' expected\n",
459                                  hdrfn, hdrfline, (p - protostr) + 1);
460                                 return -1;
461                         }
462                         p = sskip(p + 1);
463                 }
464
465                 if (!strncmp(p, "...", 3)) {
466                         pp->is_vararg = 1;
467                         p = sskip(p + 3);
468                         if (*p == ')') {
469                                 p++;
470                                 break;
471                         }
472                         printf("%s:%d:%zd: ')' expected\n",
473                                 hdrfn, hdrfline, (p - protostr) + 1);
474                         return -1;
475                 }
476
477                 arg = &pp->arg[xarg];
478                 xarg++;
479
480                 p1 = p;
481                 ret = check_type(p, &arg->type);
482                 if (ret <= 0) {
483                         printf("%s:%d:%zd: unhandled type for arg%d\n",
484                                 hdrfn, hdrfline, (p - protostr) + 1, xarg);
485                         return -1;
486                 }
487                 p = sskip(p + ret);
488
489                 if (*p == '(') {
490                         // func ptr
491                         arg->fptr = calloc(1, sizeof(*arg->fptr));
492                         ret = parse_protostr(p1, arg->fptr);
493                         if (ret < 0) {
494                                 printf("%s:%d:%zd: funcarg parse failed\n",
495                                         hdrfn, hdrfline, p1 - protostr);
496                                 return -1;
497                         }
498                         // we'll treat it as void * for non-calls
499                         arg->type.name = strdup("void *");
500                         arg->type.is_ptr = 1;
501
502                         p = p1 + ret;
503                 }
504
505                 p = next_idt(buf, sizeof(buf), p);
506                 p = sskip(p);
507 #if 0
508                 if (buf[0] == 0) {
509                         printf("%s:%d:%zd: idt missing for arg%d\n",
510                                 hdrfn, hdrfline, (p - protostr) + 1, xarg);
511                         return -1;
512                 }
513 #endif
514                 arg->reg = NULL;
515
516                 ret = get_regparm(regparm, sizeof(regparm), p);
517                 if (ret > 0) {
518                         p += ret;
519                         p = sskip(p);
520
521                         arg->reg = strdup(map_reg(regparm));
522                 }
523
524                 ret = check_struct_arg(arg);
525                 if (ret > 0) {
526                         pp->has_structarg = 1;
527                         arg->type.is_struct = 1;
528                         free(arg->type.name);
529                         arg->type.name = strdup("int");
530                         for (l = 0; l < ret; l++) {
531                                 pp_copy_arg(&pp->arg[xarg], arg);
532                                 xarg++;
533                         }
534                 }
535         }
536
537         if (xarg > 0 && (IS(cconv, "__fastcall") || IS(cconv, "__thiscall"))) {
538                 if (pp->arg[0].reg != NULL) {
539                         printf("%s:%d: %s with arg1 spec %s?\n",
540                                 hdrfn, hdrfline, cconv, pp->arg[0].reg);
541                 }
542                 pp->arg[0].reg = strdup("ecx");
543         }
544
545         if (xarg > 1 && IS(cconv, "__fastcall")) {
546                 if (pp->arg[1].reg != NULL) {
547                         printf("%s:%d: %s with arg2 spec %s?\n",
548                                 hdrfn, hdrfline, cconv, pp->arg[1].reg);
549                 }
550                 pp->arg[1].reg = strdup("edx");
551         }
552
553         if (pp->is_vararg && pp->is_stdcall) {
554                 printf("%s:%d: vararg stdcall?\n", hdrfn, hdrfline);
555                 return -1;
556         }
557
558         pp->argc = xarg;
559
560         for (i = 0; i < pp->argc; i++) {
561                 if (pp->arg[i].reg == NULL)
562                         pp->argc_stack++;
563                 else
564                         pp->argc_reg++;
565         }
566
567         return p - protostr;
568 }
569
570 static int pp_name_cmp(const void *p1, const void *p2)
571 {
572         const struct parsed_proto *pp1 = p1, *pp2 = p2;
573         return strcmp(pp1->name, pp2->name);
574 }
575
576 static struct parsed_proto *pp_cache;
577 static int pp_cache_size;
578 static int pp_cache_alloc;
579
580 static int b_pp_c_handler(char *proto, const char *fname)
581 {
582         int ret;
583
584         if (pp_cache_size >= pp_cache_alloc) {
585                 pp_cache_alloc = pp_cache_alloc * 2 + 64;
586                 pp_cache = realloc(pp_cache, pp_cache_alloc
587                                 * sizeof(pp_cache[0]));
588                 my_assert_not(pp_cache, NULL);
589                 memset(pp_cache + pp_cache_size, 0,
590                         (pp_cache_alloc - pp_cache_size)
591                          * sizeof(pp_cache[0]));
592         }
593
594         ret = parse_protostr(proto, &pp_cache[pp_cache_size]);
595         if (ret < 0)
596                 return -1;
597
598         pp_cache_size++;
599         return 0;
600 }
601
602 static void build_pp_cache(FILE *fhdr)
603 {
604         int ret;
605
606         rewind(fhdr);
607
608         ret = do_protostrs(fhdr, hdrfn);
609         if (ret < 0)
610                 exit(1);
611
612         qsort(pp_cache, pp_cache_size, sizeof(pp_cache[0]), pp_name_cmp);
613 }
614
615 static const struct parsed_proto *proto_parse(FILE *fhdr, const char *sym,
616         int quiet)
617 {
618         const struct parsed_proto *pp_ret;
619         struct parsed_proto pp_search;
620
621         if (pp_cache == NULL)
622                 build_pp_cache(fhdr);
623
624         if (sym[0] == '_') // && strncmp(fname, "stdc", 4) == 0)
625                 sym++;
626
627         strcpy(pp_search.name, sym);
628         pp_ret = bsearch(&pp_search, pp_cache, pp_cache_size,
629                         sizeof(pp_cache[0]), pp_name_cmp);
630         if (pp_ret == NULL && !quiet)
631                 printf("%s: sym '%s' is missing\n", hdrfn, sym);
632
633         return pp_ret;
634 }
635
636 static void pp_copy_arg(struct parsed_proto_arg *d,
637         const struct parsed_proto_arg *s)
638 {
639         memcpy(d, s, sizeof(*d));
640
641         if (s->reg != NULL) {
642                 d->reg = strdup(s->reg);
643                 my_assert_not(d->reg, NULL);
644         }
645         if (s->type.name != NULL) {
646                 d->type.name = strdup(s->type.name);
647                 my_assert_not(d->type.name, NULL);
648         }
649         if (s->fptr != NULL) {
650                 d->fptr = malloc(sizeof(*d->fptr));
651                 my_assert_not(d->fptr, NULL);
652                 memcpy(d->fptr, s->fptr, sizeof(*d->fptr));
653         }
654 }
655
656 struct parsed_proto *proto_clone(const struct parsed_proto *pp_c)
657 {
658         struct parsed_proto *pp;
659         int i;
660
661         pp = malloc(sizeof(*pp));
662         my_assert_not(pp, NULL);
663         memcpy(pp, pp_c, sizeof(*pp)); // lazy..
664
665         // do the actual deep copy..
666         for (i = 0; i < pp_c->argc; i++)
667                 pp_copy_arg(&pp->arg[i], &pp_c->arg[i]);
668         if (pp_c->ret_type.name != NULL)
669                 pp->ret_type.name = strdup(pp_c->ret_type.name);
670
671         return pp;
672 }
673
674 static inline void proto_release(struct parsed_proto *pp)
675 {
676         int i;
677
678         for (i = 0; i < pp->argc; i++) {
679                 if (pp->arg[i].reg != NULL)
680                         free(pp->arg[i].reg);
681                 if (pp->arg[i].type.name != NULL)
682                         free(pp->arg[i].type.name);
683                 if (pp->arg[i].fptr != NULL)
684                         free(pp->arg[i].fptr);
685         }
686         if (pp->ret_type.name != NULL)
687                 free(pp->ret_type.name);
688         free(pp);
689 }