c36e914d |
1 | |
2 | struct parsed_proto { |
3 | struct { |
4 | char *reg; |
5 | const char *type; |
91977a1c |
6 | void *datap; |
c36e914d |
7 | } arg[16]; |
8 | const char *ret_type; |
9 | int is_stdcall; |
10 | int argc; |
11 | int argc_stack; |
12 | int argc_reg; |
13 | }; |
14 | |
15 | static const char *hdrfn; |
16 | static int hdrfline = 0; |
17 | |
18 | static int find_protostr(char *dst, size_t dlen, FILE *fhdr, const char *sym) |
19 | { |
20 | int line = 0; |
21 | char *p; |
22 | |
23 | rewind(fhdr); |
24 | |
25 | while (fgets(dst, dlen, fhdr)) |
26 | { |
27 | line++; |
28 | if (strstr(dst, sym) != NULL) |
29 | break; |
30 | } |
31 | hdrfline = line; |
32 | |
33 | if (feof(fhdr)) |
34 | return -1; |
35 | |
36 | p = dst + strlen(dst); |
37 | for (p--; p > dst && my_isblank(*p); --p) |
38 | *p = 0; |
39 | |
40 | return 0; |
41 | } |
42 | |
43 | static int get_regparm(char *dst, size_t dlen, char *p) |
44 | { |
45 | int i, o; |
46 | |
47 | if (*p != '<') |
48 | return 0; |
49 | |
50 | for (o = 0, i = 1; o < dlen; i++) { |
51 | if (p[i] == 0) |
52 | return 0; |
53 | if (p[i] == '>') |
54 | break; |
55 | dst[o++] = p[i]; |
56 | } |
57 | dst[o] = 0; |
58 | return i + 1; |
59 | } |
60 | |
61 | // hmh.. |
62 | static const char *known_types[] = { |
63 | "const void *", |
64 | "void *", |
65 | "char *", |
66 | "FILE *", |
f3d05b09 |
67 | "int *", |
c36e914d |
68 | "unsigned __int8", |
69 | "unsigned __int16", |
70 | "unsigned int", |
71 | "signed int", |
72 | "char", |
73 | "__int8", |
74 | "__int16", |
75 | "int", |
76 | "bool", |
77 | "void", |
78 | "BYTE", |
79 | "WORD", |
80 | "DWORD", |
91977a1c |
81 | "_DWORD", |
c36e914d |
82 | "HMODULE", |
83 | "HANDLE", |
84 | "HWND", |
85 | "LPCSTR", |
86 | "size_t", |
87 | }; |
88 | |
89 | static const char *check_type(const char *name) |
90 | { |
91 | int i, l; |
92 | |
93 | for (i = 0; i < ARRAY_SIZE(known_types); i++) { |
94 | l = strlen(known_types[i]); |
95 | if (strncmp(known_types[i], name, l) == 0) |
96 | return known_types[i]; |
97 | } |
98 | |
99 | return NULL; |
100 | } |
101 | |
102 | /* args are always expanded to 32bit */ |
103 | static const char *map_reg(const char *reg) |
104 | { |
105 | const char *regs_f[] = { "eax", "ebx", "ecx", "edx", "esi", "edi" }; |
106 | const char *regs_w[] = { "ax", "bx", "cx", "dx", "si", "di" }; |
107 | const char *regs_b[] = { "al", "bl", "cl", "dl" }; |
108 | int i; |
109 | |
110 | for (i = 0; i < ARRAY_SIZE(regs_w); i++) |
111 | if (IS(reg, regs_w[i])) |
112 | return regs_f[i]; |
113 | |
114 | for (i = 0; i < ARRAY_SIZE(regs_b); i++) |
115 | if (IS(reg, regs_b[i])) |
116 | return regs_f[i]; |
117 | |
118 | return reg; |
119 | } |
120 | |
121 | static int parse_protostr(char *protostr, struct parsed_proto *pp) |
122 | { |
123 | char regparm[16]; |
124 | char buf[256]; |
125 | char cconv[32]; |
126 | const char *kt; |
127 | int xarg = 0; |
128 | int ret; |
129 | char *p; |
130 | int i; |
131 | |
132 | p = protostr; |
133 | if (p[0] == '/' && p[1] == '/') { |
134 | //printf("warning: decl for sym '%s' is commented out\n", sym); |
135 | p = sskip(p + 2); |
136 | } |
137 | |
138 | kt = check_type(p); |
139 | if (kt == NULL) { |
140 | printf("%s:%d:%ld: unhandled return in '%s'\n", |
141 | hdrfn, hdrfline, (p - protostr) + 1, protostr); |
142 | return 1; |
143 | } |
144 | pp->ret_type = kt; |
145 | p += strlen(kt); |
146 | p = sskip(p); |
147 | |
148 | p = next_word(cconv, sizeof(cconv), p); |
149 | p = sskip(p); |
150 | if (cconv[0] == 0) { |
151 | printf("%s:%d:%ld: cconv missing\n", |
152 | hdrfn, hdrfline, (p - protostr) + 1); |
153 | return 1; |
154 | } |
155 | if (IS(cconv, "__cdecl")) |
156 | pp->is_stdcall = 0; |
157 | else if (IS(cconv, "__stdcall")) |
158 | pp->is_stdcall = 1; |
159 | else if (IS(cconv, "__fastcall")) |
160 | pp->is_stdcall = 1; |
161 | else if (IS(cconv, "__thiscall")) |
162 | pp->is_stdcall = 1; |
163 | else if (IS(cconv, "__userpurge")) |
164 | pp->is_stdcall = 1; // in all cases seen.. |
165 | else if (IS(cconv, "__usercall")) |
166 | pp->is_stdcall = 0; // ..or is it? |
167 | else { |
168 | printf("%s:%d:%ld: unhandled cconv: '%s'\n", |
169 | hdrfn, hdrfline, (p - protostr) + 1, cconv); |
170 | return 1; |
171 | } |
172 | |
173 | p = next_idt(buf, sizeof(buf), p); |
174 | p = sskip(p); |
175 | if (buf[0] == 0) { |
176 | printf("%s:%d:%ld: func name missing\n", |
177 | hdrfn, hdrfline, (p - protostr) + 1); |
178 | return 1; |
179 | } |
180 | |
181 | ret = get_regparm(regparm, sizeof(regparm), p); |
182 | if (ret > 0) { |
183 | if (!IS(regparm, "eax") && !IS(regparm, "ax") |
184 | && !IS(regparm, "al")) |
185 | { |
186 | printf("%s:%d:%ld: bad regparm: %s\n", |
187 | hdrfn, hdrfline, (p - protostr) + 1, regparm); |
188 | return 1; |
189 | } |
190 | p += ret; |
191 | p = sskip(p); |
192 | } |
193 | |
194 | if (*p != '(') { |
195 | printf("%s:%d:%ld: '(' expected, got '%c'\n", |
196 | hdrfn, hdrfline, (p - protostr) + 1, *p); |
197 | return 1; |
198 | } |
199 | p++; |
200 | |
201 | while (1) { |
202 | p = sskip(p); |
203 | if (*p == ')') |
204 | break; |
205 | if (*p == ',') |
206 | p = sskip(p + 1); |
207 | |
208 | xarg++; |
209 | |
210 | kt = check_type(p); |
211 | if (kt == NULL) { |
212 | printf("%s:%d:%ld: unhandled type for arg%d\n", |
213 | hdrfn, hdrfline, (p - protostr) + 1, xarg); |
214 | return 1; |
215 | } |
216 | pp->arg[xarg - 1].type = kt; |
217 | p += strlen(kt); |
218 | p = sskip(p); |
219 | |
220 | p = next_idt(buf, sizeof(buf), p); |
221 | p = sskip(p); |
222 | #if 0 |
223 | if (buf[0] == 0) { |
224 | printf("%s:%d:%ld: idt missing for arg%d\n", |
225 | hdrfn, hdrfline, (p - protostr) + 1, xarg); |
226 | return 1; |
227 | } |
228 | #endif |
229 | pp->arg[xarg - 1].reg = NULL; |
230 | |
231 | ret = get_regparm(regparm, sizeof(regparm), p); |
232 | if (ret > 0) { |
233 | p += ret; |
234 | p = sskip(p); |
235 | |
236 | pp->arg[xarg - 1].reg = strdup(map_reg(regparm)); |
237 | } |
238 | } |
239 | |
240 | if (xarg > 0 && (IS(cconv, "__fastcall") || IS(cconv, "__thiscall"))) { |
241 | if (pp->arg[0].reg != NULL) { |
242 | printf("%s:%d: %s with arg1 spec %s?\n", |
243 | hdrfn, hdrfline, cconv, pp->arg[0].reg); |
244 | } |
245 | pp->arg[0].reg = strdup("ecx"); |
246 | } |
247 | |
248 | if (xarg > 1 && IS(cconv, "__fastcall")) { |
249 | if (pp->arg[1].reg != NULL) { |
250 | printf("%s:%d: %s with arg2 spec %s?\n", |
251 | hdrfn, hdrfline, cconv, pp->arg[1].reg); |
252 | } |
253 | pp->arg[1].reg = strdup("edx"); |
254 | } |
255 | |
256 | pp->argc = xarg; |
257 | |
258 | for (i = 0; i < pp->argc; i++) { |
259 | if (pp->arg[i].reg == NULL) |
260 | pp->argc_stack++; |
261 | else |
262 | pp->argc_reg++; |
263 | } |
264 | |
265 | return 0; |
266 | } |
267 | |
268 | static int proto_parse(FILE *fhdr, const char *sym, struct parsed_proto *pp) |
269 | { |
270 | char protostr[256]; |
271 | int ret; |
272 | |
273 | memset(pp, 0, sizeof(*pp)); |
274 | |
275 | ret = find_protostr(protostr, sizeof(protostr), fhdr, sym); |
276 | if (ret != 0) { |
277 | printf("%s: sym '%s' is missing\n", hdrfn, sym); |
278 | return ret; |
279 | } |
280 | |
281 | return parse_protostr(protostr, pp); |
282 | } |
283 | |
284 | static void proto_release(struct parsed_proto *pp) |
285 | { |
286 | int i; |
287 | |
288 | for (i = 0; i < pp->argc; i++) { |
289 | if (pp->arg[i].reg == NULL) |
290 | free(pp->arg[i].reg); |
291 | } |
292 | } |