tools/winedump/symbol.c

   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 void symbol_init(parsed_symbol* sym, const char* name)
  93 {
  94     memset(sym, 0, sizeof(parsed_symbol));
  95     sym->symbol = strdup(name);
  96 }
  97
  98 /*******************************************************************
  99  *         symbol_clear
 100  *
 101  * Free the memory used by a symbol and initialise it
 102  */
 103 void symbol_clear(parsed_symbol *sym)
 104 {
 105  int i;
 106
 107  assert (sym);
 108  assert (sym->symbol);
 109
 110  free (sym->symbol);
 111  free (sym->return_text);
 112  free (sym->function_name);
 113
 114  for (i = sym->argc - 1; i >= 0; i--)
 115  {
 116    free (sym->arg_text [i]);
 117    free (sym->arg_name [i]);
 118  }
 119  memset (sym, 0, sizeof (parsed_symbol));
 120 }
 121
 122
 123 /*******************************************************************
 124  *         symbol_is_valid_c
 125  *
 126  * Check if a symbol is a valid C identifier
 127  */
 128 BOOL symbol_is_valid_c(const parsed_symbol *sym)
 129 {
 130   char *name;
 131
 132   assert (sym);
 133   assert (sym->symbol);
 134
 135   name = sym->symbol;
 136
 137   while (*name)
 138   {
 139     if (!isalnum (*name) && *name != '_')
 140       return FALSE;
 141     name++;
 142   }
 143   return TRUE;
 144 }
 145
 146
 147 /*******************************************************************
 148  *         symbol_get_call_convention
 149  *
 150  * Return the calling convention of a symbol
 151  */
 152 const char *symbol_get_call_convention(const parsed_symbol *sym)
 153 {
 154   int call = sym->flags ? sym->flags : CALLING_CONVENTION;
 155
 156   assert (sym);
 157   assert (sym->symbol);
 158
 159   if (call & SYM_CDECL)
 160     return "cdecl";
 161   return "stdcall";
 162 }
 163
 164
 165 /*******************************************************************
 166  *         symbol_get_spec_type
 167  *
 168  * Get the .spec file text for a symbol's argument
 169  */
 170 const char *symbol_get_spec_type (const parsed_symbol *sym, size_t arg)
 171 {
 172   assert (arg < sym->argc);
 173   switch (sym->arg_type [arg])
 174   {
 175   case ARG_STRING:      return "str";
 176   case ARG_WIDE_STRING: return "wstr";
 177   case ARG_POINTER:     return "ptr";
 178   case ARG_DOUBLE:      return "double";
 179   case ARG_STRUCT:
 180   case ARG_FLOAT:
 181   case ARG_LONG:        return "long";
 182   }
 183   assert (0);
 184   return NULL;
 185 }
 186
 187
 188 /*******************************************************************
 189  *         symbol_get_type
 190  *
 191  * Get the ARG_ constant for a type string
 192  */
 193 int   symbol_get_type (const char *string)
 194 {
 195   const char *iter = string;
 196   const char * const *tab;
 197   int ptrs = 0;
 198
 199   while (*iter && isspace(*iter))
 200     iter++;
 201   if (*iter == 'P' || *iter == 'H')
 202     ptrs++; /* Win32 type pointer */
 203
 204   iter = string;
 205   while (*iter)
 206   {
 207     if (*iter == '*' || (*iter == 'L' && iter[1] == 'P')
 208         || (*iter == '[' && iter[1] == ']'))
 209       ptrs++;
 210     if (ptrs > 1)
 211       return ARG_POINTER;
 212     iter++;
 213   }
 214
 215   /* 0 or 1 pointer */
 216   tab = wide_strings;
 217   while (*tab++)
 218     if (strstr (string, tab[-1]))
 219     {
 220       if (ptrs < 2) return ARG_WIDE_STRING;
 221       else          return ARG_POINTER;
 222     }
 223   tab = wide_chars;
 224   while (*tab++)
 225     if (strstr (string, tab[-1]))
 226     {
 227       if (!ptrs) return ARG_LONG;
 228       else       return ARG_WIDE_STRING;
 229     }
 230   tab = ascii_strings;
 231   while (*tab++)
 232     if (strstr (string, tab[-1]))
 233     {
 234       if (ptrs < 2) return ARG_STRING;
 235       else          return ARG_POINTER;
 236     }
 237   tab = ascii_chars;
 238   while (*tab++)
 239     if (strstr (string, tab[-1]))
 240     {
 241       if (!ptrs) return ARG_LONG;
 242       else {
 243         if (!strstr (string, "unsigned")) /* unsigned char * => ptr */
 244           return ARG_STRING;
 245       }
 246     }
 247
 248   if (ptrs)
 249     return ARG_POINTER; /* Pointer to some other type */
 250
 251   /* No pointers */
 252   if (strstr (string, "double"))
 253     return ARG_DOUBLE;
 254
 255   if (strstr (string, "float") || strstr (string, "FLOAT"))
 256     return ARG_FLOAT;
 257
 258   if (strstr (string, "void") || strstr (string, "VOID"))
 259     return ARG_VOID;
 260
 261   if (strstr (string, "struct") || strstr (string, "union"))
 262     return ARG_STRUCT; /* Struct by value, ugh */
 263
 264   if (VERBOSE)
 265   {
 266     BOOL known = FALSE;
 267
 268     tab = known_longs;
 269     while (*tab++)
 270     if (strstr (string, tab[-1]))
 271     {
 272       known = TRUE;
 273       break;
 274     }
 275     /* Unknown types passed by value can be 'grep'ed out for fixup later */
 276     if (!known)
 277       printf ("/* FIXME: By value type: Assumed 'int' */ typedef int %s;\n",
 278               string);
 279   }
 280   return ARG_LONG;
 281 }
 282
 283
 284 /*******************************************************************
 285  *         symbol_clean_string
 286  *
 287  * Make a type string more Wine-friendly. Logically const :-)
 288  */
 289 void  symbol_clean_string (char *str)
 290 {
 291   const char * const *tab = swap_after;
 292
 293 #define SWAP(i, p, x, y) do { i = p; while ((i = str_replace (i, x, y))); } while(0)
 294
 295   while (tab [0])
 296   {
 297     char *p;
 298     SWAP (p, str, tab [0], tab [1]);
 299     tab += 2;
 300   }
 301   if (str [strlen (str) - 1] == ' ')
 302     str [strlen (str) - 1] = '\0'; /* no trailing space */
 303
 304   if (*str == ' ')
 305     memmove (str, str + 1, strlen (str)); /* No leading spaces */
 306 }