1 /*
2 * Symbol functions
3 *
4 * Copyright 2000 Jon Griffiths
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 "winedump.h"
25
26
27 /* Items that are swapped in arguments after the symbol structure
28 * has been populated
29 */
30 static const char * const swap_after[] =
31 {
32 "\r", " ", /* Remove whitespace, normalise pointers and brackets */
33 "\t", " ",
34 " ", " ",
35 " * ", " *",
36 "* *", "**",
37 "* ", "*",
38 " ,", ",",
39 "( ", "(",
40 " )", ")",
41 "wchar_t", "WCHAR", /* Help with Unicode compiles */
42 "wctype_t", "WCHAR",
43 "wint_t", "WCHAR",
44 NULL, NULL
45 };
46
47
48 /* Items containing these substrings are assumed to be wide character
49 * strings, unless they contain more that one '*'. A preceding 'LP'
50 * counts as a '*', so 'LPWCSTR *' is a pointer, not a string
51 */
52 static const char * const wide_strings[] =
53 {
54 "WSTR", "WCSTR", NULL
55 };
56
57 /* Items containing these substrings are assumed to be wide characters,
58 * unless they contain one '*'. A preceding 'LP' counts as a '*',
59 * so 'WCHAR *' is string, while 'LPWCHAR *' is a pointer
60 */
61 static const char * const wide_chars[] =
62 {
63 "WCHAR", NULL
64 };
65
66 /* Items containing these substrings are assumed to be ASCII character
67 * strings, as above
68 */
69 static const char * const ascii_strings[] =
70 {
71 "STR", "CSTR", NULL
72 };
73
74
75 /* Items containing these substrings are assumed to be ASCII characters,
76 * as above
77 */
78 static const char * const ascii_chars[] =
79 {
80 "CHAR", "char", NULL
81 };
82
83 /* Any type other than the following will produce a FIXME warning with -v
84 * when mapped to a long, to allow fixups
85 */
86 static const char * const known_longs[] =
87 {
88 "char", "CHAR", "float", "int", "INT", "short", "SHORT", "long", "LONG",
89 "WCHAR", "BOOL", "bool", "INT16", "WORD", "DWORD", NULL
90 };
91
92 int symbol_init(parsed_symbol* sym, const char* name)
93 {
94 memset(sym, 0, sizeof(parsed_symbol));
95 sym->symbol = strdup(name);
96 return 0;
97 }
98
99 /*******************************************************************
100 * symbol_clear
101 *
102 * Free the memory used by a symbol and initialise it
103 */
104 void symbol_clear(parsed_symbol *sym)
105 {
106 int i;
107
108 assert (sym);
109 assert (sym->symbol);
110
111 free (sym->symbol);
112 free (sym->return_text);
113 free (sym->function_name);
114
115 for (i = sym->argc - 1; i >= 0; i--)
116 {
117 free (sym->arg_text [i]);
118 free (sym->arg_name [i]);
119 }
120 memset (sym, 0, sizeof (parsed_symbol));
121 }
122
123
124 /*******************************************************************
125 * symbol_is_valid_c
126 *
127 * Check if a symbol is a valid C identifier
128 */
129 int symbol_is_valid_c(const parsed_symbol *sym)
130 {
131 char *name;
132
133 assert (sym);
134 assert (sym->symbol);
135
136 name = sym->symbol;
137
138 while (*name)
139 {
140 if (!isalnum (*name) && *name != '_')
141 return 0;
142 name++;
143 }
144 return 1;
145 }
146
147
148 /*******************************************************************
149 * symbol_get_call_convention
150 *
151 * Return the calling convention of a symbol
152 */
153 const char *symbol_get_call_convention(const parsed_symbol *sym)
154 {
155 int call = sym->flags ? sym->flags : CALLING_CONVENTION;
156
157 assert (sym);
158 assert (sym->symbol);
159
160 if (call & SYM_CDECL)
161 return "cdecl";
162 return "stdcall";
163 }
164
165
166 /*******************************************************************
167 * symbol_get_spec_type
168 *
169 * Get the .spec file text for a symbol's argument
170 */
171 const char *symbol_get_spec_type (const parsed_symbol *sym, size_t arg)
172 {
173 assert (arg < sym->argc);
174 switch (sym->arg_type [arg])
175 {
176 case ARG_STRING: return "str";
177 case ARG_WIDE_STRING: return "wstr";
178 case ARG_POINTER: return "ptr";
179 case ARG_DOUBLE: return "double";
180 case ARG_STRUCT:
181 case ARG_FLOAT:
182 case ARG_LONG: return "long";
183 }
184 assert (0);
185 return NULL;
186 }
187
188
189 /*******************************************************************
190 * symbol_get_type
191 *
192 * Get the ARG_ constant for a type string
193 */
194 int symbol_get_type (const char *string)
195 {
196 const char *iter = string;
197 const char * const *tab;
198 int ptrs = 0;
199
200 while (*iter && isspace(*iter))
201 iter++;
202 if (*iter == 'P' || *iter == 'H')
203 ptrs++; /* Win32 type pointer */
204
205 iter = string;
206 while (*iter)
207 {
208 if (*iter == '*' || (*iter == 'L' && iter[1] == 'P')
209 || (*iter == '[' && iter[1] == ']'))
210 ptrs++;
211 if (ptrs > 1)
212 return ARG_POINTER;
213 iter++;
214 }
215
216 /* 0 or 1 pointer */
217 tab = wide_strings;
218 while (*tab++)
219 if (strstr (string, tab[-1]))
220 {
221 if (ptrs < 2) return ARG_WIDE_STRING;
222 else return ARG_POINTER;
223 }
224 tab = wide_chars;
225 while (*tab++)
226 if (strstr (string, tab[-1]))
227 {
228 if (!ptrs) return ARG_LONG;
229 else return ARG_WIDE_STRING;
230 }
231 tab = ascii_strings;
232 while (*tab++)
233 if (strstr (string, tab[-1]))
234 {
235 if (ptrs < 2) return ARG_STRING;
236 else return ARG_POINTER;
237 }
238 tab = ascii_chars;
239 while (*tab++)
240 if (strstr (string, tab[-1]))
241 {
242 if (!ptrs) return ARG_LONG;
243 else {
244 if (!strstr (string, "unsigned")) /* unsigned char * => ptr */
245 return ARG_STRING;
246 }
247 }
248
249 if (ptrs)
250 return ARG_POINTER; /* Pointer to some other type */
251
252 /* No pointers */
253 if (strstr (string, "double"))
254 return ARG_DOUBLE;
255
256 if (strstr (string, "float") || strstr (string, "FLOAT"))
257 return ARG_FLOAT;
258
259 if (strstr (string, "void") || strstr (string, "VOID"))
260 return ARG_VOID;
261
262 if (strstr (string, "struct") || strstr (string, "union"))
263 return ARG_STRUCT; /* Struct by value, ugh */
264
265 if (VERBOSE)
266 {
267 int known = 0;
268
269 tab = known_longs;
270 while (*tab++)
271 if (strstr (string, tab[-1]))
272 {
273 known = 1;
274 break;
275 }
276 /* Unknown types passed by value can be 'grep'ed out for fixup later */
277 if (!known)
278 printf ("/* FIXME: By value type: Assumed 'int' */ typedef int %s;\n",
279 string);
280 }
281 return ARG_LONG;
282 }
283
284
285 /*******************************************************************
286 * symbol_clean_string
287 *
288 * Make a type string more Wine-friendly. Logically const :-)
289 */
290 void symbol_clean_string (const char *string)
291 {
292 const char * const *tab = swap_after;
293 char *str = (char *)string;
294
295 #define SWAP(i, p, x, y) do { i = p; while ((i = str_replace (i, x, y))); } while(0)
296
297 while (tab [0])
298 {
299 char *p;
300 SWAP (p, str, tab [0], tab [1]);
301 tab += 2;
302 }
303 if (str [strlen (str) - 1] == ' ')
304 str [strlen (str) - 1] = '\0'; /* no trailing space */
305
306 if (*str == ' ')
307 memmove (str, str + 1, strlen (str)); /* No leading spaces */
308 }
309
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.