reactos/tools/rgenstat/rgenstat.c

   1 /*
   2  * Generate a file with API status information from a list
   3  * of files in a directory.
   4  * Casper S. Hornstrup <chorns@users.sourceforge.net>
   5  */
   6
   7 #include <stdio.h>
   8 #include <fcntl.h>
   9 #include <sys/stat.h>
  10 #include <stdlib.h>
  11 #include <string.h>
  12
  13 #ifdef WIN32
  14 #include <io.h>
  15 #include <dos.h>
  16 #else
  17 #include <sys/io.h>
  18 #include <errno.h>
  19 #include <sys/types.h>
  20 #include <dirent.h>
  21 #endif
  22 #include <ctype.h>
  23 #ifndef WIN32
  24 #ifndef MAX_PATH
  25 #define MAX_PATH 260
  26 #endif
  27 #define DIR_SEPARATOR_CHAR '/'
  28 #define DIR_SEPARATOR_STRING "/"
  29 #else
  30 #define DIR_SEPARATOR_CHAR '\\'
  31 #define DIR_SEPARATOR_STRING "\\"
  32 #endif
  33
  34 #define TAG_UNKNOWN -1
  35 #define TAG_IMPLEMENTED 0
  36 #define TAG_UNIMPLEMENTED 1
  37
  38 typedef struct _API_INFO
  39 {
  40   struct _API_INFO *next;
  41   int tag_id;
  42   char name[100];
  43 } API_INFO, *PAPI_INFO;
  44
  45
  46 PAPI_INFO sort_linked_list(PAPI_INFO,
  47     unsigned, int (*)(PAPI_INFO, PAPI_INFO));
  48
  49
  50 static FILE *in;
  51 static FILE *out;
  52 static char *file;
  53 static FILE *file_handle = NULL;
  54 static char *file_buffer = NULL;
  55 static unsigned int file_size = 0;
  56 static int file_pointer = 0;
  57 static char tagname[200];
  58 static PAPI_INFO api_info_list = NULL;
  59
  60
  61 static char*
  62 convert_path(char* origpath)
  63 {
  64    char* newpath;
  65    int i;
  66
  67    newpath = strdup(origpath);
  68
  69    i = 0;
  70    while (newpath[i] != 0)
  71      {
  72 #ifndef WIN32
  73         if (newpath[i] == '\\')
  74           {
  75              newpath[i] = '/';
  76           }
  77 #else
  78 #ifdef WIN32
  79         if (newpath[i] == '/')
  80           {
  81              newpath[i] = '\\';
  82           }
  83 #endif
  84 #endif
  85         i++;
  86      }
  87    return(newpath);
  88 }
  89
  90 static void
  91 write_line(char *line)
  92 {
  93   int n_out;
  94   char buf[200];
  95
  96   memset(buf, 0, sizeof(buf));
  97   strcpy(buf, line);
  98   /* Terminate the line */
  99   buf[strlen(buf)] = '\r';
 100   buf[strlen(buf)] = '\n';
 101
 102   n_out = fwrite(&buf[0], 1, strlen(buf), out);
 103 }
 104
 105
 106 static void
 107 read_file(char *filename)
 108 {
 109   file_handle = fopen(filename, "rb");
 110   if (file_handle == NULL)
 111     {
 112       printf("Can't open %s\n", filename);
 113       exit(1);
 114     }
 115
 116   // Get the size of the file
 117   fseek(file_handle, 0, SEEK_END);
 118   file_size = ftell(file_handle);
 119
 120   // Load it all into memory
 121   file_buffer = malloc(file_size);
 122   if (file_buffer == NULL)
 123     {
 124       fclose(file_handle);
 125       printf("Out of memory\n");
 126       exit(1);
 127     }
 128   fseek(file_handle, 0, SEEK_SET);
 129   if (file_size > 0)
 130     {
 131       if (fread (file_buffer, 1, file_size, file_handle) < 1)
 132         {
 133           fclose(file_handle);
 134           printf("Read error in file %s\n", filename);
 135           exit(1);
 136         }
 137     }
 138
 139   file_pointer = 0;
 140 }
 141
 142 static void
 143 close_file()
 144 {
 145   free(file_buffer);
 146   file_buffer = NULL;
 147   fclose(file_handle);
 148   file_handle = NULL;
 149   file_pointer = 0;
 150 }
 151
 152 static int
 153 is_whitespace(char ch)
 154 {
 155   if (ch == ' ')
 156     {
 157       return 1;
 158     }
 159   if (ch == '\t')
 160     {
 161       return 1;
 162     }
 163   return 0;
 164 }
 165
 166 static int
 167 is_eol_char(char ch)
 168 {
 169   if (ch == '\r')
 170     {
 171       return 1;
 172     }
 173   if (ch == '\n')
 174     {
 175       return 1;
 176     }
 177   return 0;
 178 }
 179
 180 static int
 181 is_end_of_tag(char ch)
 182 {
 183   if ((ch >= 'a') && (ch <= 'z'))
 184     {
 185       return 0;
 186     }
 187   if ((ch >= 'A') && (ch <= 'Z'))
 188     {
 189       return 0;
 190     }
 191   if ((ch >= '0') && (ch <= '9'))
 192     {
 193       return 0;
 194     }
 195   if (ch == '_')
 196     {
 197       return 0;
 198     }
 199   return 1;
 200 }
 201
 202 static int
 203 is_end_of_name(char ch)
 204 {
 205   /* Currently the same as is_end_of_tag() */
 206   return is_end_of_tag(ch);
 207 }
 208
 209 static int
 210 is_valid_file(char *filename)
 211 {
 212   char ext[MAX_PATH];
 213   int i;
 214
 215   i = strlen(filename);
 216   while (i > 0 && filename[i] != '.')
 217     {
 218       i--;
 219     }
 220   if (i > 0)
 221     {
 222       memset(ext, 0, sizeof(ext));
 223       strncpy(&ext[0], &filename[i], strlen(&filename[i]));
 224
 225       if ((strncmp(ext, ".c", 2) == 0) || (strncmp(ext, ".C", 2) == 0))
 226         {
 227           return 1;
 228         }
 229     }
 230   return 0;
 231 }
 232
 233 static int
 234 get_tag_id(char *tag)
 235 {
 236   if (strcasecmp(tag, "implemented") == 0)
 237     {
 238       return TAG_IMPLEMENTED;
 239     }
 240   if (strcasecmp(tag, "unimplemented") == 0)
 241     {
 242       return TAG_UNIMPLEMENTED;
 243     }
 244   return TAG_UNKNOWN;
 245 }
 246
 247 static int
 248 skip_to_next_tag()
 249 {
 250   unsigned int start;
 251   int end_of_tag;
 252   int found_tag = 0;
 253   int tag_id;
 254   int len;
 255
 256   tagname[0] = 0;
 257   while ((file_pointer < file_size) && (!found_tag))
 258     {
 259       if (file_buffer[file_pointer] == '@')
 260         {
 261           file_pointer++;
 262           start = file_pointer;
 263           end_of_tag = 0;
 264           while ((file_pointer < file_size) && (!end_of_tag))
 265             {
 266               end_of_tag = is_end_of_tag(file_buffer[file_pointer]);
 267               file_pointer++;
 268             }
 269           len = file_pointer > start ? file_pointer - start - 1 : 0;
 270           strncpy(tagname, &file_buffer[start], len);
 271           tagname[len] = 0;
 272
 273           tag_id = get_tag_id(tagname);
 274           if (tag_id != TAG_UNKNOWN)
 275             {
 276               return tag_id;
 277             }
 278         }
 279       file_pointer++;
 280     }
 281
 282   return TAG_UNKNOWN;
 283 }
 284
 285 static void
 286 skip_line()
 287 {
 288   while ((file_pointer < file_size) && (!is_eol_char(file_buffer[file_pointer])))
 289     {
 290       file_pointer++;
 291     }
 292   if ((file_pointer < file_size) && (file_buffer[file_pointer] == '\n'))
 293     {
 294       file_pointer++;
 295     }
 296 }
 297
 298 static void
 299 skip_comments()
 300 {
 301   while ((file_pointer < file_size))
 302     {
 303       if (file_buffer[file_pointer] == '*')
 304         {
 305           if ((file_pointer + 1 < file_size))
 306             {
 307               if (file_buffer[file_pointer + 1] == '/')
 308                 {
 309                   skip_line();
 310                   return;
 311                 }
 312             }
 313         }
 314       file_pointer++;
 315     }
 316 }
 317
 318 static int
 319 get_previous_identifier(unsigned int end, char *name)
 320 {
 321   unsigned int my_file_pointer = end;
 322   int len;
 323
 324   name[0] = 0;
 325
 326   while ((my_file_pointer > 0) && (is_whitespace(file_buffer[my_file_pointer])
 327     || is_eol_char(file_buffer[my_file_pointer])))
 328     {
 329       my_file_pointer--;
 330     }
 331
 332   /* Skip any comments between function name and it's parameters */
 333   if ((my_file_pointer > 0) && (file_buffer[my_file_pointer] == '/'))
 334     {
 335       if ((my_file_pointer > 0) && (file_buffer[my_file_pointer - 1] == '*'))
 336         {
 337           my_file_pointer--;
 338           while ((my_file_pointer > 0) && !((file_buffer[my_file_pointer] == '*')
 339             && (file_buffer[my_file_pointer - 1] == '/')))
 340             {
 341               my_file_pointer--;
 342             }
 343           my_file_pointer -= 2;
 344         }
 345     }
 346
 347   /* Skip any remaining whitespace */
 348   while ((my_file_pointer > 0) && (is_whitespace(file_buffer[my_file_pointer])))
 349     {
 350       my_file_pointer--;
 351     }
 352
 353   end = my_file_pointer;
 354   while ((my_file_pointer > 0))
 355     {
 356       if (is_end_of_name(file_buffer[my_file_pointer]))
 357         {
 358           len = end - my_file_pointer;
 359           strncpy(name, &file_buffer[my_file_pointer + 1], len);
 360           name[len] = 0;
 361           return 1;
 362         }
 363       my_file_pointer--;
 364     }
 365
 366   return 0;
 367 }
 368
 369 static int
 370 skip_to_next_name(char *name)
 371 {
 372   while ((file_pointer < file_size))
 373     {
 374       if (file_buffer[file_pointer] == '(')
 375         {
 376           return get_previous_identifier(file_pointer - 1, name);
 377         }
 378       file_pointer++;
 379     }
 380   return 0;
 381 }
 382
 383 static void
 384 parse_file(char *filename)
 385 {
 386   PAPI_INFO api_info;
 387   char prev[200];
 388   char name[200];
 389   int tag_id;
 390
 391   read_file(filename);
 392
 393   prev[0] = 0;
 394   do
 395     {
 396       tag_id = skip_to_next_tag();
 397       if (tag_id == TAG_UNKNOWN)
 398         {
 399           break;
 400         }
 401
 402       /* Skip rest of the comments between the tag and the function name */
 403       skip_comments();
 404
 405       if (skip_to_next_name(name))
 406         {
 407           if (strlen(name) == 0)
 408             {
 409               printf("Warning: empty function name in file %s. Previous function name was %s.\n",
 410                 filename, prev);
 411             }
 412           api_info = malloc(sizeof(API_INFO));
 413           if (api_info == NULL)
 414             {
 415               printf("Out of memory\n");
 416               exit(1);
 417             }
 418
 419           api_info->tag_id = tag_id;
 420           strcpy(api_info->name, name);
 421
 422           api_info->next = api_info_list;
 423           api_info_list = api_info;
 424           strcpy(prev, name);
 425         }
 426     } while (1);
 427
 428   close_file();
 429 }
 430
 431 #ifdef WIN32
 432
 433 /* Win32 version */
 434 static void
 435 process_directory (char *path)
 436 {
 437   struct _finddata_t f;
 438   int findhandle;
 439   char searchbuf[MAX_PATH];
 440   char buf[MAX_PATH];
 441
 442   printf("Processing '%s'\n", path);
 443
 444   strcpy(searchbuf, path);
 445   strcat(searchbuf, "*.*");
 446
 447   findhandle =_findfirst(searchbuf, &f);
 448   if (findhandle != -1)
 449     {
 450       do
 451         {
 452           if (f.attrib & _A_SUBDIR)
 453             {
 454               if (f.name[0] != '.')
 455                 {
 456                   strcpy(buf, path);
 457                   strcat(buf, f.name);
 458                   strcat(buf, DIR_SEPARATOR_STRING);
 459                   process_directory(buf);
 460                 }
 461               continue;
 462             }
 463
 464           strcpy(buf, path);
 465           strcat(buf, f.name);
 466
 467           /* Must be a .c file */
 468           if (!is_valid_file(buf))
 469             {
 470               continue;
 471             }
 472
 473           parse_file(buf);
 474         }
 475       while (_findnext(findhandle, &f) == 0);
 476       _findclose(findhandle);
 477     }
 478   else
 479     {
 480       printf("Cannot open directory '%s'", path);
 481       exit(1);
 482     }
 483 }
 484
 485 #else
 486
 487 /* Linux version */
 488 static void
 489 process_directory (char *path)
 490 {
 491   DIR *dirp;
 492   struct dirent *entry;
 493   struct stat stbuf;
 494   char buf[MAX_PATH];
 495
 496 #ifdef HAVE_D_TYPE
 497   dirp = opendir(path);
 498   if (dirp != NULL)
 499     {
 500       while ((entry = readdir(dirp)) != NULL)
 501         {
 502           if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
 503             continue; // skip self and parent
 504
 505           if (entry->d_type == DT_REG) // normal file
 506             {
 507               // Check for an absolute path
 508               if (path[0] == DIR_SEPARATOR_CHAR)
 509                 {
 510                   strcpy(buf, path);
 511                   strcat(buf, DIR_SEPARATOR_STRING);
 512                   strcat(buf, entry->d_name);
 513                 }
 514               else
 515                 {
 516                   getcwd(buf, sizeof(buf));
 517                   strcat(buf, DIR_SEPARATOR_STRING);
 518                   strcat(buf, path);
 519                   strcat(buf, entry->d_name);
 520                 }
 521
 522               if (stat(buf, &stbuf) == -1)
 523                 {
 524                   printf("Can't access '%s' (%s)\n", buf, strerror(errno));
 525                   return;
 526                 }
 527
 528               if (S_ISDIR(stbuf.st_mode))
 529                     {
 530                   process_directory(buf);
 531                   continue;
 532                     }
 533
 534               /* Must be a .c file */
 535               if (!is_valid_file(buf))
 536                 {
 537                   continue;
 538                 }
 539
 540               parse_file(buf);
 541            }
 542       }
 543       closedir(dirp);
 544     }
 545   else
 546     {
 547       printf("Can't open %s\n", path);
 548       exit(1);
 549     }
 550
 551 #else
 552
 553   dirp = opendir(path);
 554   if (dirp != NULL)
 555     {
 556       while ((entry = readdir(dirp)) != NULL)
 557         {
 558           if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
 559             continue; // skip self and parent
 560
 561           // Check for an absolute path
 562           if (path[0] == DIR_SEPARATOR_CHAR)
 563             {
 564               strcpy(buf, path);
 565               strcat(buf, DIR_SEPARATOR_STRING);
 566               strcat(buf, entry->d_name);
 567             }
 568           else
 569             {
 570               getcwd(buf, sizeof(buf));
 571               strcat(buf, DIR_SEPARATOR_STRING);
 572               strcat(buf, path);
 573               strcat(buf, entry->d_name);
 574             }
 575
 576           if (stat(buf, &stbuf) == -1)
 577             {
 578               printf("Can't access '%s' (%s)\n", buf, strerror(errno));
 579               return;
 580             }
 581
 582           if (S_ISDIR(stbuf.st_mode))
 583             {
 584               process_directory(buf);
 585               continue;
 586             }
 587
 588           /* Must be a .c file */
 589           if (!is_valid_file(buf))
 590             {
 591               continue;
 592             }
 593
 594           parse_file(buf);
 595         }
 596       closedir(dirp);
 597     }
 598   else
 599     {
 600       printf("Can't open %s\n", path);
 601       exit(1);
 602     }
 603
 604 #endif
 605 }
 606
 607 #endif
 608
 609 /*
 610  * This function compares two API entries. It returns a negative value if p is
 611  * before q, or a positive value if p is after q.
 612  */
 613 static int
 614 compare_api_order(PAPI_INFO p, PAPI_INFO q)
 615 {
 616   return strcmp(p->name, q->name);
 617 }
 618
 619 static void
 620 generate_xml_for_component(char *component_name)
 621 {
 622   PAPI_INFO api_info;
 623   char buf[200];
 624   int complete;
 625   int total;
 626   int implemented_total;
 627   int unimplemented_total;
 628
 629   // Sort list
 630   api_info_list = sort_linked_list(api_info_list, 0, compare_api_order);
 631
 632   implemented_total = 0;
 633   unimplemented_total = 0;
 634
 635   api_info = api_info_list;
 636   while (api_info != NULL)
 637     {
 638       if (api_info->tag_id == TAG_IMPLEMENTED)
 639         {
 640           implemented_total ++;
 641         }
 642       else if (api_info->tag_id == TAG_UNIMPLEMENTED)
 643         {
 644           unimplemented_total ++;
 645         }
 646
 647       api_info = api_info->next;
 648     }
 649
 650   if (implemented_total + unimplemented_total > 0)
 651     {
 652       complete = ((implemented_total) * 100) / (implemented_total + unimplemented_total);
 653     }
 654   else
 655     {
 656       complete = 100;
 657     }
 658
 659   sprintf(buf, "<component name=\"%s\" complete=\"%d\" implemented_total=\"%d\" unimplemented_total=\"%d\">",
 660     component_name, complete, implemented_total, unimplemented_total);
 661   write_line(buf);
 662
 663   if (api_info_list != NULL)
 664     {
 665       write_line("<functions>");
 666
 667       api_info = api_info_list;
 668       while (api_info != NULL)
 669         {
 670           sprintf(buf, "<function name=\"%s\" implemented=\"%s\">",
 671             api_info->name, api_info->tag_id == TAG_IMPLEMENTED ? "true" : "false");
 672           write_line(buf);
 673           write_line("</function>");
 674           api_info = api_info->next;
 675         }
 676
 677       write_line("</functions>");
 678     }
 679
 680   write_line("</component>");
 681 }
 682
 683 static void
 684 read_input_file(char *input_file)
 685 {
 686   char component_name[MAX_PATH];
 687   char component_path[MAX_PATH];
 688   char *canonical_path;
 689   unsigned int index;
 690   unsigned int start;
 691   PAPI_INFO api_info;
 692   PAPI_INFO next_api_info;
 693   char *buffer;
 694   int size;
 695   int len;
 696
 697   in = fopen(input_file, "rb");
 698   if (in == NULL)
 699     {
 700         printf("Cannot open input file");
 701         exit(1);
 702     }
 703
 704   // Get the size of the file
 705   fseek(in, 0, SEEK_END);
 706   size = ftell(in);
 707
 708   // Load it all into memory
 709   buffer = malloc(size);
 710   if (buffer == NULL)
 711     {
 712       fclose(in);
 713       printf("Out of memory\n");
 714       exit(1);
 715     }
 716   fseek(in, 0, SEEK_SET);
 717   if (fread (buffer, 1, size, in) < 1)
 718     {
 719       fclose(in);
 720       printf("Read error in file %s\n", input_file);
 721       exit(1);
 722     }
 723
 724   index = 0;
 725
 726   write_line("<?xml version=\"1.0\" encoding=\"iso-8859-1\" ?>");
 727   write_line("");
 728   write_line("<components>");
 729
 730   while (1)
 731     {
 732       /* Free previous list */
 733       for (api_info = api_info_list; api_info != NULL; api_info = next_api_info)
 734         {
 735           next_api_info = api_info->next;
 736           free(api_info);
 737         }
 738       api_info_list = NULL;
 739
 740       /* Skip whitespace and eol characters */
 741       while ((index < size) && (is_whitespace(buffer[index]) || (is_eol_char(buffer[index]))))
 742         {
 743           index++;
 744         }
 745       if ((file_pointer < size) && (buffer[index] == '\n'))
 746         {
 747           index++;
 748         }
 749
 750       if (buffer[index] == ';')
 751         {
 752           /* Skip comments */
 753           while ((index < size) && (!is_eol_char(buffer[index])))
 754             {
 755               index++;
 756             }
 757           if ((index < size) && (buffer[index] == '\n'))
 758             {
 759               index++;
 760             }
 761           continue;
 762         }
 763
 764       /* Get component name */
 765       start = index;
 766       while ((index < size) && (!is_whitespace(buffer[index])))
 767         {
 768           index++;
 769         }
 770       if (index >= size)
 771         {
 772           break;
 773         }
 774
 775       len = index - start;
 776       strncpy(component_name, &buffer[start], len);
 777       component_name[len] = 0;
 778
 779       /* Skip whitespace */
 780       while ((index < size) && (is_whitespace(buffer[index])))
 781         {
 782           index++;
 783         }
 784       if (index >= size)
 785         {
 786           break;
 787         }
 788
 789       /* Get component path */
 790       start = index;
 791       while ((index < size) && (!is_whitespace(buffer[index]) && !is_eol_char(buffer[index])))
 792         {
 793           index++;
 794         }
 795
 796       len = index - start;
 797       strncpy(component_path, &buffer[start], len);
 798       component_path[len] = 0;
 799
 800       /* Append directory separator if needed */
 801       if (component_path[strlen(component_path)] != DIR_SEPARATOR_CHAR)
 802         {
 803           int i = strlen(component_path);
 804           component_path[strlen(component_path)] = DIR_SEPARATOR_CHAR;
 805           component_path[i + 1] = 0;
 806         }
 807
 808       /* Skip to end of line */
 809       while ((index < size) && (!is_eol_char(buffer[index])))
 810         {
 811           index++;
 812         }
 813       if ((index < size) && (buffer[index] == '\n'))
 814         {
 815           index++;
 816         }
 817
 818       canonical_path = convert_path(component_path);
 819       if (canonical_path != NULL)
 820         {
 821           process_directory(canonical_path);
 822           free(canonical_path);
 823           generate_xml_for_component(component_name);
 824         }
 825     }
 826
 827   write_line("</components>");
 828 }
 829
 830 static char HELP[] =
 831   "RGENSTAT  input-filename output-filename\n"
 832   "\n"
 833   "  input-filename   File containing list of components to process\n"
 834   "  output-filename  File to create\n";
 835
 836 int main(int argc, char **argv)
 837 {
 838   char *input_file;
 839   char *output_file;
 840   int i;
 841
 842   if (argc < 2)
 843   {
 844     puts(HELP);
 845     return 1;
 846   }
 847
 848   input_file = convert_path(argv[1]);
 849   if (input_file[0] == 0)
 850     {
 851       printf("Missing input-filename\n");
 852       return 1;
 853     }
 854
 855   output_file = convert_path(argv[2]);
 856   if (output_file[0] == 0)
 857     {
 858       printf("Missing output-filename\n");
 859       return 1;
 860     }
 861
 862   out = fopen(output_file, "wb");
 863   if (out == NULL)
 864     {
 865         printf("Cannot open output file");
 866         return 1;
 867      }
 868
 869   read_input_file(input_file);
 870
 871   fclose(out);
 872
 873   return 0;
 874 }
 875
 876 /* EOF */