For the minification scripts mentioned here, I had to write a program that would go through every file of a certain type in a directory and process (in this case, minify) that file. At the heart of this problem was the need to get a directory listing.

The obvious way to get a directory listing in C is to use the system call, as in system("ls");. But this is not only lame, it does not work on all systems, and the result cannot be used very easily. The better way to get a directory listing is to use system calls to the filesystem. A complete example is shown at the bottom of this post, as usual.

The functions used in getting a directory listing are opendir and readdir (note: these functions also exist in php, and the code to get a directory listing is in fact nearly the same in php and c). opendir() can be seen as kind of like a fopen() for directories. Following this analogy, readdir() is like a fgetc() for directories. To get a directory listing, we first open the directory with opendir("/dir/name/here"), and then read the name of each file in the directory with a loop of readdir(directory_handle)s. For example:

  1. #include <stdio.h>
  2. #include <sys/types.h>
  3. #include <dirent.h>
  4.  
  5. int main() {
  6.   DIR *dh;//directory handle
  7.   struct dirent *file;//a 'directory entity' AKA file    
  8.   dh=opendir("/home/scott");
  9.   while(file=readdir(dp))
  10.     printf("%s\n",file->d_name);
  11.   return 0;
  12. }

The code sample above is a simple form of the ‘ls’ unix command – it prints out all files in a directory. Note, however, that this includes ‘files’ like ‘.’ and ‘..’, as well as other directories. This script could be improved by only printing out the name of the file if it does not begin with a ‘.’, and is not a directory:

  1. #include <stdio.h>
  2. #include <sys/types.h>
  3. #include <sys/param.h>
  4. #include <sys/stat.h>
  5. #include <dirent.h>
  6.  
  7. int main() {
  8.   DIR *dh;//directory handle
  9.   struct dirent *file;//a 'directory entity' AKA file    
  10.   struct stat info;//info about the file.
  11.   dh=opendir("/home/scott");
  12.   while(file=readdir(dp))
  13.     if(file->d_name[0]!='.') {
  14.       stat(dir->d_name,&info);
  15.       if(!S_ISDIR(info.st_mode))
  16.         printf("%s\n",file->d_name);
  17.     }
  18.   closedir(dh);
  19.   return 0;
  20. }

In the above code listing, we call stat with both the filename and a reference to the stat struct as arguments, so as to collect information about the file (like the unix ’stat’ command). Then, we can ask the stat object if this file is a function with the S_ISDIR macro. If it is not, then we print out its name; otherwise, we just ignore it and move on. Note that the above code listing will also filter out all ‘hidden’ unix files which begin with a ‘.’, whether or not they are directories. We also remembered to close the directory when we were done this time, using closedir() (analogous to fclose()).

Below is a slightly more complete code sample, of how directory listings can be used in a more complicated application. Instead of just ignoring directories, we call minifyAllIn() on them recursively, thereby hitting every file in a directory or its subdirectories. This technique can be used to do things like find the total size of a directory (the unix command ‘du’).

  1. /*
  2.  Excerpts from minification script by Scott Lawrence and Frederic Khoeler
  3. */
  4.  
  5. #include <string>
  6. #include <stdlib.h>
  7. #include <string.h>
  8. #include <dirent.h>
  9. #include <stdio.h>
  10. #include <sys/types.h>
  11. #include <sys/param.h>
  12. #include <sys/stat.h>
  13.  
  14. void minifyAllIn(string);
  15. void minifyFile(char *);
  16. string minify(string, bool css);
  17.  
  18. int main() {
  19.   //note to self (self): if fork()==0, I am the child
  20.  
  21.   minifyAllIn("/var/www/robot/js");
  22.   minifyAllIn("/var/www/robot/style");
  23.   return 0;
  24. }
  25.  
  26. void minifyAllIn(string dirname_s) {
  27.   const char *dirname=dirname_s.data();
  28.   chdir(dirname);
  29.   DIR *d=opendir(".");
  30.   struct dirent *dir;
  31.   struct stat info;
  32.   char fp[PATH_MAX*5];
  33.   while(dir=readdir(d)) {
  34.     if(strcmp(dir->d_name,".")==0) continue;
  35.     if(strcmp(dir->d_name,"..")==0) continue;
  36.     stat(dir->d_name,&info);
  37.     string name="";
  38.     name+=dir->d_name;
  39.     if(S_ISDIR(info.st_mode)) {
  40.       chdir(dir->d_name);
  41.       minifyAllIn(dir->d_name);                
  42.       chdir("..");
  43.     } else if(name.length()>3 && name.substr(name.length()-3,3)==".js") {
  44.       if(name.substr(name.length()-7,7)==".min.js") continue;
  45.       getcwd(fp,PATH_MAX+1);
  46.       strcat(fp,"/");
  47.       strcat(fp,name.data());
  48.       minifyFile(fp);
  49.     } else if(name.length()>4 && name.substr(name.length()-4,4)==".css") {
  50.       if(name.substr(name.length()-8,8)==".min.css") continue;
  51.       getcwd(fp,PATH_MAX+1);
  52.       strcat(fp,"/");
  53.       strcat(fp,name.data());
  54.       minifyFile(fp);
  55.     } else continue;
  56.   }
  57.   closedir(d);
  58. }
  59.  
  60. char* outputFilename(string originalFilename, int len_copy, string extension) {
  61.   char* name = (char*) calloc(PATH_MAX*5, sizeof(char));
  62.   strncpy(name, originalFilename.c_str(), len_copy);
  63.   strcat(name, extension.c_str());
  64.   return name;
  65. }

Related posts: