Mercurial > hg > cline / file revision

 #include "cline.h"

 #include "functions.h"

 suffix_list_t* new_suffix_list_t() {

   suffix_list_t* suffixList = malloc(sizeof(suffix_list_t*));

   suffixList->count = 0;

   suffixList->items = NULL;

 }

 void destroy_suffix_list_t(suffix_list_t* list) {

   while (--list->count >= 0) {

     free(list->items[list->count]);

   }

   free(list);

 }

 void add_suffix(suffix_list_t* list, char* item) {

   char** reallocated_list =

     realloc(list->items, sizeof(char**) * list->count + 1);

   if (reallocated_list != NULL) {

     list->items = reallocated_list;

     list->items[list->count] = item;

     list->count++;

   }

 }

 settings_t* new_settings_t() {

   settings_t *settings = malloc(sizeof(settings_t*));

   if (settings != NULL) {

   #ifdef _WIN32

     settings->fileSeparator      = '\\';

   #else

     settings->fileSeparator      = '/';

   #endif /* _WIN32 */

     settings->recursive          = false;

     settings->includeSuffixes    = false;

     settings->matchesOnly        = false;

     settings->suffixList         = new_suffix_list_t();

   }

   return settings;

 }

 void destroy_settings_t(settings_t* settings) {

   destroy_suffix_list_t(settings->suffixList);

   free(settings);

 }

 void printHelpText(const char* prgName) {

   // Help text

   const char* helpText = 

     "\nUsage:"

     "\n      %s [-hrm][-s suffix][<directory>]"

     "\n      %s [-hrm][-S suffix][<directory>]"

     "\n\nCounts the line terminator characters (\\n) within all"

     " files in the specified\ndirectory."

     "\n\nOptions:"

     "\n  -h, --help          - this help text"

     "\n  -m                  - print information about matching files only"

     "\n  -s <suffixes>       - only count files with these suffixes (separated"

     "\n                        by commas)"

     "\n  -S <suffixes>       - count any file except those with these suffixes"

     "\n                        (separated by commas)"

     "\n  -r, -R              - includes subdirectories"

     "\n\n"

     "The default call without any options is:"    

     "\n  %s ./\n"

     "That means each file in each subdirectory is counted. If you want to count"

     "\nC source code in your working directory and its subdirectories, type:"

     "\n  %s -rs .c\n";

   printf(helpText, prgName, prgName, prgName, prgName);

 }

 int main(int argc, char** argv) {

   // Settings

   settings_t *settings = new_settings_t();

   if (settings == NULL) {

     fprintf(stderr, "Memory allocation failed.\n");

     return 1;

   }

   // Program name

   char* prgName = strrchr(argv[0], settings->fileSeparator);

   if (prgName == NULL) {

     prgName = argv[0];

   } else {

     prgName++;

   }

   // Defaults

   char* _suffix = " ";

   char _directory[3];

   _directory[0] = '.';

   _directory[1] = settings->fileSeparator;

   _directory[2] = 0;

   // Get arguments

   char* directory;

   char* suffix;

   bool showHelp = false;

   char checked = 0;

   for (int t = 1 ; t < argc ; t++) {

     int argflags = checkArgument(argv[t], "hsSrRm");

     // s

     if ((argflags & 2) > 0) {

       if ((checked & 1) > 0) {

         printHelpText(prgName);

         destroy_settings_t(settings);

         return 1;

       }

       settings->includeSuffixes = true;

       t++;

       if (t >= argc) {

         printHelpText(prgName);

         destroy_settings_t(settings);

         return 1;

       }

       suffix = argv[t]; 

       checked |= 1;

     }

     // S

     if ((argflags & 4) > 0) {

       if ((checked & 1) > 0) {

         printHelpText(prgName);

         destroy_settings_t(settings);

         return 1;

       }

       settings->includeSuffixes = false;

       t++;

       if (t >= argc) {

         printHelpText(prgName);

         destroy_settings_t(settings);

         return 1;

       }

       suffix = argv[t];

       checked |= 1;

     }

     // h

     if ((argflags & 1) > 0 || strcmp(argv[t], "--help") == 0) {

       if ((checked & 2) > 0) {

         printHelpText(prgName);

         destroy_settings_t(settings);

         return 1;

       }

       checked |= 2;

       showHelp = true;

     }

     // r, R

     if ((argflags & 24) > 0) {

       if ((checked & 4) > 0) {

         printHelpText(prgName);

         destroy_settings_t(settings);

         return 1;

       }

       checked |= 4;

       settings->recursive = true;

     }

     if ((argflags & 32) > 0) {

       if ((checked & 32) > 0) {

         printHelpText(prgName);

         destroy_settings_t(settings);

         return 1;

       }

       checked |= 32;

       settings->matchesOnly = true;

     }

     // Path

     if (argflags == 0) {

       if ((checked & 8) > 0) {

         printHelpText(prgName);

         destroy_settings_t(settings);

         return 1;

       }

       checked |= 8;

       directory = argv[t];

     }

   }

   // Show help and quit

   if (showHelp) {

     printHelpText(prgName);

     destroy_settings_t(settings);

     return 0;

   }

   // Default values

   if ((checked & 1) == 0) {

     suffix = _suffix;

   }

   if ((checked & 8) == 0) {

     directory = _directory;

   }

   // Find tokens

   char* finder = strtok(suffix, ",");

   while (finder != NULL) {

     add_suffix(settings->suffixList, finder);

     finder = strtok(NULL, ",");

   }

   // Open directory

   DIR *dir = opendir(directory);

   if (dir == NULL) {

     perror("Operation failed");

     destroy_settings_t(settings);

     return 1;

   }

   // Scan directory

   int lines = scanDirectory(dir, 0, directory, settings);

   closedir(dir);

   // Print double line and line count

   #ifdef _WIN32

     const int columns = 79;

   #else

     const int columns = 80;

   #endif /* _WIN32 */

   for (int t = 0 ; t < columns ; t++) {

     printf("=");

   }

   #ifdef _WIN32

     printf("\n%73d lines\n", lines);

   #else

     printf("\n%74d lines\n", lines);

   #endif /* _WIN32 */

   destroy_settings_t(settings);

   return 0;

 }