tools/specmaker/search.c

   1 /*
   2  *  Prototype search and parsing functions
   3  *
   4  *  Copyright 2000 Jon Griffiths
   5  */
   6 #include "specmaker.h"
   7
   8 static char *grep_buff = NULL;
   9 static char *fgrep_buff = NULL;
  10
  11 static int symbol_from_prototype (parsed_symbol *sym, const char *prototype);
  12 static const char *get_type (parsed_symbol *sym, const char *proto, int arg);
  13
  14
  15 /*******************************************************************
  16  *         symbol_search
  17  *
  18  * Call Patrik Stridvall's 'function_grep.pl' script to retrieve a
  19  * function prototype from include file(s)
  20  */
  21 int symbol_search (parsed_symbol *sym)
  22 {
  23   static const size_t MAX_RESULT_LEN = 1024;
  24   FILE *grep;
  25   int attempt = 0;
  26
  27   assert (globals.do_code);
  28   assert (globals.directory);
  29   assert (sym && sym->symbol);
  30
  31   if (!symbol_is_valid_c (sym))
  32     return - 1;
  33
  34   if (!grep_buff)
  35     grep_buff = (char *) malloc (MAX_RESULT_LEN);
  36
  37   if (!fgrep_buff)
  38     fgrep_buff = (char *) malloc (MAX_RESULT_LEN);
  39
  40   if (!grep_buff || !fgrep_buff)
  41     fatal ("Out of Memory");
  42
  43   /* Use 'grep' to tell us which possible files the function is in,
  44    * then use 'function_grep.pl' to get the prototype. If this fails the
  45    * first time then give grep a more general query (that doesn't
  46    * require an opening argument brace on the line with the function name).
  47    */
  48   while (attempt < 2)
  49   {
  50     FILE *f_grep;
  51     char *cmd = str_create (4, "grep -d recurse -l \"", sym->symbol,
  52         !attempt ? "[:blank:]*(\" " : "\" ", globals.directory);
  53
  54     if (VERBOSE)
  55       puts (cmd);
  56
  57     fflush (NULL); /* See 'man popen' */
  58
  59     if (!(grep = popen (cmd, "r")))
  60       fatal ("Cannot execute grep -l");
  61     free (cmd);
  62
  63     while (fgets (grep_buff, MAX_RESULT_LEN, grep))
  64     {
  65       int i;
  66       for (i = 0; grep_buff[i] && grep_buff[i] != '\n' ; i++)
  67         ;
  68       grep_buff[i] = '\0';
  69
  70       if (VERBOSE)
  71         puts (grep_buff);
  72
  73       cmd = str_create (5, "function_grep.pl ", sym->symbol,
  74                         " \"", grep_buff, "\"");
  75
  76       if (VERBOSE)
  77         puts (cmd);
  78
  79       fflush (NULL); /* See 'man popen' */
  80
  81       if (!(f_grep = popen (cmd, "r")))
  82         fatal ("Cannot execute function_grep.pl");
  83       free (cmd);
  84
  85       while (fgets (grep_buff, MAX_RESULT_LEN, f_grep))
  86       {
  87         char *iter = grep_buff;
  88
  89         /* Keep only the first line */
  90         symbol_clean_string(grep_buff);
  91
  92         for (i = 0; grep_buff[i] && grep_buff[i] != '\n' ; i++)
  93           ;
  94         grep_buff[i] = '\0';
  95
  96         if (VERBOSE)
  97           puts (grep_buff);
  98
  99         while ((iter = strstr (iter, sym->symbol)))
 100         {
 101           if (iter > grep_buff && iter[-1] == ' ' &&
 102              (iter[strlen (sym->symbol)] == ' ' ||
 103              iter[strlen (sym->symbol)] == '('))
 104           {
 105             if (VERBOSE)
 106               puts ("Prototype looks OK, processing");
 107
 108             if (!symbol_from_prototype (sym, grep_buff))
 109             {
 110               pclose (f_grep);
 111               pclose (grep);
 112               return 0;  /* OK */
 113             }
 114             if (VERBOSE)
 115               puts ("Failed, trying next");
 116           }
 117           else
 118             iter += strlen (sym->symbol);
 119         }
 120       }
 121       pclose (f_grep);
 122     }
 123     pclose (grep);
 124     attempt++;
 125   }
 126
 127   return -1; /* Not found */
 128 }
 129
 130
 131 /*******************************************************************
 132  *         symbol_from_prototype
 133  *
 134  * Convert a C prototype into a symbol
 135  */
 136 static int symbol_from_prototype (parsed_symbol *sym, const char *proto)
 137 {
 138   char *iter;
 139   int found;
 140
 141   proto = get_type (sym, proto, -1); /* Get return type */
 142   if (!proto)
 143     return -1;
 144
 145   iter = (char *)str_match (proto, sym->symbol, &found);
 146
 147   if (!found)
 148   {
 149     /* Calling Convention */
 150     iter = strchr (iter, ' ');
 151     if (!iter)
 152       return -1;
 153
 154     sym->calling_convention = str_substring (proto, iter);
 155
 156     iter = (char *)str_match (iter, sym->symbol, &found);
 157
 158     if (!found)
 159       return -1;
 160   }
 161   else
 162     sym->calling_convention = strdup (CALLING_CONVENTION);
 163
 164   sym->function_name = strdup (sym->symbol);
 165   proto = iter;
 166
 167   /* Now should be the arguments */
 168   if (*proto++ != '(')
 169     return -1;
 170
 171   for (; *proto == ' '; proto++);
 172
 173   if (!strncmp (proto, "void", 4))
 174     return 0;
 175
 176   do
 177   {
 178     /* Process next argument */
 179     str_match (proto, "...", &sym->varargs);
 180     if (sym->varargs)
 181       return 0;
 182
 183     if (!(proto = get_type (sym, proto, sym->argc)))
 184       return -1;
 185
 186     sym->argc++;
 187
 188     if (*proto == ',')
 189       proto++;
 190     else if (*proto != ')')
 191       return -1;
 192
 193   } while (*proto != ')');
 194
 195   return 0;
 196 }
 197
 198
 199 /*******************************************************************
 200  *         get_type
 201  *
 202  * Read a type from a prototype
 203  */
 204 static const char *get_type (parsed_symbol *sym, const char *proto, int arg)
 205 {
 206   int is_const, is_volatile, is_struct, is_signed, is_unsigned, ptrs = 0;
 207   char *iter, *type_str, *base_type, *catch_unsigned, dest_type;
 208
 209   assert (sym && sym->symbol);
 210   assert (proto && *proto);
 211   assert (arg < 0 || (unsigned)arg == sym->argc);
 212
 213   type_str = (char *)proto;
 214
 215   proto = str_match (proto, "const", &is_const);
 216   proto = str_match (proto, "volatile", &is_volatile);
 217   proto = str_match (proto, "struct", &is_struct);
 218   if (!is_struct)
 219     proto = str_match (proto, "union", &is_struct);
 220
 221   catch_unsigned = (char *)proto;
 222
 223   proto = str_match (proto, "unsigned", &is_unsigned);
 224   proto = str_match (proto, "signed", &is_signed);
 225
 226   /* Can have 'unsigned const' or 'const unsigned' etc */
 227   if (!is_const)
 228     proto = str_match (proto, "const", &is_const);
 229   if (!is_volatile)
 230     proto = str_match (proto, "volatile", &is_volatile);
 231
 232   base_type = (char *)proto;
 233   iter = (char *)str_find_set (proto, " ,*)");
 234   if (!iter)
 235     return NULL;
 236
 237   if (arg < 0 && (is_signed || is_unsigned))
 238   {
 239     /* Prevent calling convention from being swallowed by 'un/signed' alone */
 240     if (strncmp (base_type, "int", 3) && strncmp (base_type, "long", 4) &&
 241         strncmp (base_type, "short", 5) && strncmp (base_type, "char", 4))
 242     {
 243       iter = (char *)proto;
 244       base_type = catch_unsigned;
 245     }
 246   }
 247   else
 248     catch_unsigned = NULL;
 249
 250   /* FIXME: skip const/volatile here too */
 251   for (proto = iter; *proto; proto++)
 252     if (*proto == '*')
 253       ptrs++;
 254     else if (*proto != ' ')
 255       break;
 256
 257   if (!*proto)
 258     return NULL;
 259
 260   type_str = str_substring (type_str, proto);
 261   if (iter == base_type || catch_unsigned)
 262   {
 263     /* 'unsigned' with no type */
 264     char *tmp = str_create (2, type_str, " int");
 265     free (type_str);
 266     type_str = tmp;
 267   }
 268   symbol_clean_string (type_str);
 269
 270   dest_type = symbol_get_type (type_str);
 271
 272   if (arg < 0)
 273   {
 274     sym->return_text = type_str;
 275     sym->return_type = dest_type;
 276   }
 277   else
 278   {
 279     sym->arg_type [arg] = dest_type;
 280     sym->arg_flag [arg] = is_const ? CT_CONST : is_volatile ? CT_VOLATILE : 0;
 281
 282     if (*proto == ',' || *proto == ')')
 283       sym->arg_name [arg] = str_create_num (1, arg, "arg");
 284     else
 285     {
 286       iter = (char *)str_find_set (proto, " ,)");
 287       if (!iter)
 288       {
 289         free (type_str);
 290         return NULL;
 291       }
 292       sym->arg_name [arg] = str_substring (proto, iter);
 293       proto = iter;
 294     }
 295     sym->arg_text [arg] = type_str;
 296
 297   }
 298   return proto;
 299 }
 300
 301
 302 #ifdef __GNUC__
 303 /*******************************************************************
 304  *         search_cleanup
 305  *
 306  * Free memory used while searching (a niceity)
 307  */
 308 void search_cleanup (void) __attribute__ ((destructor));
 309 void search_cleanup (void)
 310 {
 311   if (grep_buff)
 312     free (grep_buff);
 313
 314   if (fgrep_buff)
 315     free (fgrep_buff);
 316 }
 317 #endif
 318