cline.c

#include "include.h"
#include "v2.h"


#ifdef _WIN32
static char fileSeparator = '\\';
#else
static char fileSeparator = '/';
#endif /* _WIN32 */

static int suffixc;
static char** suffixv;
static bool recursive;
static bool includeSuffixes;
static bool matchesOnly;

bool testSuffix(char* filename) {
  bool ret = false;
  int tokenlen, fnamelen = strlen(filename);
  for (int t = 0 ; t < suffixc ; t++) {
    tokenlen = strlen(suffixv[t]);
    if (fnamelen >= tokenlen && tokenlen > 0) {
      if (strncmp(filename+fnamelen-tokenlen, suffixv[t], tokenlen) == 0) {
        ret = true;
        break;
      }
    }
  }
  return ret ^ !includeSuffixes;
}

int scanDirectory(DIR *dir, const int spaces, char* currdir) {
  DIR *subdir;
  char* subdirname;
  struct dirent *entry;
  int lines, digits, a;
  int lineSum = 0;

  while ((entry = readdir(dir)) != NULL) {
    if (strcmp(entry->d_name, ".") != 0 && strcmp(entry->d_name, "..") != 0) {
      // Print occurence
      char entryname[strlen(entry->d_name)+spaces];
      for (int t = 0 ; t < spaces ; t++) {
        entryname[t]=' ';
      }
      entryname[spaces] = 0;
      strcat(entryname, entry->d_name);
  
      // Check for subdirectory
      char subdirname[(1+strlen(currdir)+strlen(entry->d_name))];
      strcpy(subdirname, currdir);
      strncat(subdirname, &fileSeparator, 1);
      strcat(subdirname, entry->d_name);
      if ((subdir = opendir(subdirname)) != NULL) {
        printf("%-60s\n", entryname);
        if (recursive) {
          lineSum += scanDirectory(subdir, spaces+1, subdirname);
        }
        closedir(subdir);
        continue;
      }

      // Count lines
      lines = 0;
      char filename[(1+strlen(currdir)+strlen(entry->d_name))];
      strcpy(filename, currdir);
      strncat(filename, &fileSeparator, 1);
      strcat(filename, entry->d_name);
      if (testSuffix(filename)) {
        FILE *file = fopen(filename, "r");
        if (file == NULL) {
          perror("  File acces failed");
          continue;
        }

        do {
          a = fgetc(file);

          if (a == 10) {
            lines++;
          }
        } while (a != EOF);
        fclose(file);

        // Print line count
        #ifdef _WIN32
          printf("%-60s%13d lines\n", entryname, lines);
        #else
          printf("%-60s%14d lines\n", entryname, lines);
        #endif /* _WIN32 */

        lineSum += lines;
      }
      else {
        if (!matchesOnly) {
          // Print hint
          #ifdef _WIN32
            printf("%-60s%19s\n", entryname, "no match");
          #else
            printf("%-60s%20s\n", entryname, "no match");
          #endif /* _WIN32 */
        }
      }
    }
  }
  return lineSum;
}

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) {

  // Program name
  char* prgName = strrchr(argv[0], fileSeparator);
  
  if (prgName == NULL) {
    prgName = argv[0];
  }
  else {
    prgName++;
  }

  // Defaults
  char* _suffix = " ";
  char _directory[3];
  _directory[0] = '.';
  _directory[1] = fileSeparator;
  _directory[2] = 0;

  // Get arguments
  char* directory;
  char* suffix;
  bool showHelp = false;
  recursive = false;
  includeSuffixes = 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);
        return -1;
      }
      includeSuffixes = true;
      t++;
      if (t >= argc) {
        printHelpText(prgName);
        return -1;
      }
      suffix = argv[t]; 
      checked |= 1;
    }
    // S
    if ((argflags & 4) > 0) {
      if ((checked & 1) > 0) {
        printHelpText(prgName);
        return -1;
      }
      includeSuffixes = false;
      t++;
      if (t >= argc) {
        printHelpText(prgName);
        return -1;
      }
      suffix = argv[t];
      checked |= 1;
    }
    // h
    if ((argflags & 1) > 0 || strcmp(argv[t], "--help") == 0) {
      if ((checked & 2) > 0) {
        printHelpText(prgName);
        return -1;
      }
      checked |= 2;
      showHelp = true;
    }
    // r, R
    if ((argflags & 24) > 0) {
      if ((checked & 4) > 0) {
        printHelpText(prgName);
        return -1;
      }
      checked |= 4;
      recursive = true;
    }
    if ((argflags & 32) > 0) {
      if ((checked & 32) > 0) {
        printHelpText(prgName);
        return -1;
      }
      checked |= 32;
      matchesOnly = true;
    }
    // other
    if (argflags == 0) {
      if ((checked & 8) > 0) {
        printHelpText(prgName);
        return -1;
      }
      checked |= 8;
      directory = argv[t];
    }
  }

  // Show help and quit
  if (showHelp) {
    printHelpText(prgName);
    return 0;
  }

  // Default values
  if ((checked & 1) == 0) {
    suffix = _suffix;
  }

  if ((checked & 8) == 0) {
    directory = _directory;
  }

  // Find tokens
  char* finder;
  suffixc = 1;
  finder = strchr(suffix, ',');
  while (finder != NULL) {
    suffixc++;
    finder = strchr(finder+1, ',');
  }
  suffixv = (char**) malloc(sizeof(suffixv)*suffixc);
  if (suffixv == NULL) {
    fprintf(stderr, "Memory allocation failed.\n");
    return 1;
  }
  finder = strtok(suffix, ",");
  int c = 0;
  while (finder != NULL) {
    suffixv[c] = finder;
    c++;
    finder = strtok(NULL, ",");
  }

  // Open directory
  DIR *dir = opendir(directory);
  if (dir == NULL) {
    perror("Operation failed");
    free(suffixv);
    return 1;
  }
  
  // Scan directory
  int lines = scanDirectory(dir, 0, directory);

  // 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 */

  closedir(dir);
  free(suffixv);
  return 0;
}