]> https://gitweb.dealii.org/ - dealii-svn.git/commitdiff
Reindent script files
authormaier <maier@0785d39b-7218-0410-832d-ea1e28bc413d>
Thu, 10 Jul 2014 14:34:02 +0000 (14:34 +0000)
committermaier <maier@0785d39b-7218-0410-832d-ea1e28bc413d>
Thu, 10 Jul 2014 14:34:02 +0000 (14:34 +0000)
git-svn-id: https://svn.dealii.org/trunk@33131 0785d39b-7218-0410-832d-ea1e28bc413d

deal.II/cmake/scripts/expand_instantiations.cc
deal.II/cmake/scripts/make_dependencies.cc

index 6f89828b701e3a8f54645796f88a79c202996464..fd6a5af67a22d2f6e58bf2da3b1970f655b7b0a9 100644 (file)
@@ -67,40 +67,37 @@ std::map<std::string, std::list<std::string> >  expansion_lists;
 // return the result
 std::string
 replace_all (const std::string &in,
-            const std::string &pattern,
-            const std::string &substitute)
+             const std::string &pattern,
+             const std::string &substitute)
 {
   std::string x = in;
   while (x.find(pattern) != std::string::npos)
     x.replace (x.find(pattern),
-              pattern.size(),
-              substitute);
+               pattern.size(),
+               substitute);
   return x;
 }
 
 
-// extract from the start of #in the part of the string that ends with one of
-// the characters in #delim_list. The extracted part is deleted from #in
-// and returned. We skip characters in delim_list if they are preceded
-// by a backslash
+// extract from the start of #in the part of the string that ends with one
+// of the characters in #delim_list. The extracted part is deleted from #in
+// and returned. We skip characters in delim_list if they are preceded by a
+// backslash
 std::string
 get_substring_with_delim (std::string       &in,
-                         const std::string &delim_list)
+                          const std::string &delim_list)
 {
   std::string x;
   while (in.size() != 0)
     {
-                                      // stop copying to the result
-                                      // if the current character is
-                                      // a delimiter, but only if the
-                                      // previous character was not a
-                                      // backslash
+      // stop copying to the result if the current character is a
+      // delimiter, but only if the previous character was not a backslash
       if ((delim_list.find (in[0]) != std::string::npos)
-         &&
-         !((x.size() > 0)
-           &&
-           (x[x.size()-1] == '\\')))
-       break;
+          &&
+          !((x.size() > 0)
+            &&
+            (x[x.size()-1] == '\\')))
+        break;
 
       x += in[0];
       in.erase (0, 1);
@@ -115,8 +112,8 @@ void
 skip_space (std::string &in)
 {
   while ((in.size() != 0)
-        &&
-        ((in[0] == ' ') || (in[0] == '\t') || (in[0] == '\n')))
+         &&
+         ((in[0] == ' ') || (in[0] == '\t') || (in[0] == '\n')))
     in.erase (0, 1);
 }
 
@@ -132,14 +129,14 @@ std::string remove_comments (std::string line)
     {
       const std::string::size_type slash_star_comment_end = line.find ("*/");
       if (slash_star_comment_end == std::string::npos)
-       {
-         std::cerr << "The program can currently only handle /* block */"
-                   << "comments that start and end within the same line."
-                   << std::endl;
-         std::exit (1);
-       }
+        {
+          std::cerr << "The program can currently only handle /* block */"
+                    << "comments that start and end within the same line."
+                    << std::endl;
+          std::exit (1);
+        }
       line.erase (slash_star_comment_begin,
-                 slash_star_comment_end - slash_star_comment_begin + 2);
+                  slash_star_comment_end - slash_star_comment_begin + 2);
     }
 
   return line;
@@ -159,8 +156,7 @@ std::string read_whole_file (std::istream &in)
       whole_file += remove_comments (line);
       whole_file += '\n';
     }
-                                  // substitute tabs by spaces, multiple
-                                  // spaces by single ones
+  // substitute tabs by spaces, multiple spaces by single ones
   for (unsigned int i=0; i<whole_file.size(); ++i)
     if (whole_file[i] == '\t')
       whole_file[i] = ' ';
@@ -172,33 +168,33 @@ std::string read_whole_file (std::istream &in)
 
 
 
-// split a given string assumed to consist of a list of substrings delimited
-// by a particular character into its components
+// split a given string assumed to consist of a list of substrings
+// delimited by a particular character into its components
 std::list<std::string>
 split_string_list (const std::string &s,
-                  const char         delimiter)
+                   const char         delimiter)
 {
   std::string tmp = s;
   std::list<std::string> split_list;
 
-                                  // split the input list
+  // split the input list
   while (tmp.length() != 0)
     {
       std::string name;
       name = tmp;
 
       if (name.find(delimiter) != std::string::npos)
-       {
-         name.erase (name.find(delimiter), std::string::npos);
-         tmp.erase (0, tmp.find(delimiter)+1);
-       }
+        {
+          name.erase (name.find(delimiter), std::string::npos);
+          tmp.erase (0, tmp.find(delimiter)+1);
+        }
       else
-       tmp = "";
+        tmp = "";
 
       skip_space (name);
 
       while ((name.size() != 0) && (name[name.length()-1] == ' '))
-       name.erase (name.length()-1, 1);
+        name.erase (name.length()-1, 1);
 
       split_list.push_back (name);
     }
@@ -223,16 +219,16 @@ delete_empty_entries (const std::list<std::string> &list)
 
 
 
-// determine whether a given substring at position #pos and length #length in
-// the string #text is a real token, i.e. not just part of another word
+// determine whether a given substring at position #pos and length #length
+// in the string #text is a real token, i.e. not just part of another word
 bool is_real_token (const std::string &text,
-                   const std::string::size_type pos,
-                   const std::string::size_type length)
+                    const std::string::size_type pos,
+                    const std::string::size_type length)
 {
   static const std::string token_chars ("abcdefghijklmnopqrstuvwxyz"
-                                       "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-                                       "0123456789"
-                                       "_");
+                                        "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+                                        "0123456789"
+                                        "_");
   if ((pos != 0) && (token_chars.find (text[pos-1]) != std::string::npos))
     return false;
 
@@ -245,25 +241,26 @@ bool is_real_token (const std::string &text,
 
 
 // substitute all occurrences of #token in #text by #substitute. because a
-// replacement token could be a templated class like std::complex<double> and
-// because the token to the substituted may be a template argument itself, we
-// surround the substitution by a space which shouldn't matter in C++
+// replacement token could be a templated class like std::complex<double>
+// and because the token to the substituted may be a template argument
+// itself, we surround the substitution by a space which shouldn't matter
+// in C++
 std::string substitute_tokens (const std::string &text,
-                              const std::string &token,
-                              const std::string &substitute)
+                               const std::string &token,
+                               const std::string &substitute)
 {
   std::string x_text = text;
   std::string::size_type pos = 0;
   while ((pos = x_text.find(token, pos)) != std::string::npos)
     {
       if (is_real_token (x_text, pos, token.size()))
-       {
-         x_text.replace (pos, token.size(),
-                         std::string(" ")+substitute+std::string(" "));
-         pos += substitute.size()+2;
-       }
+        {
+          x_text.replace (pos, token.size(),
+                          std::string(" ")+substitute+std::string(" "));
+          pos += substitute.size()+2;
+        }
       else
-       ++pos;
+        ++pos;
     }
 
   return x_text;
@@ -275,9 +272,9 @@ std::string substitute_tokens (const std::string &text,
 
 
 // read and parse the expansion lists like
-//     REAL_SCALARS    := { double; float; long double }
-// as specified at the top of the file and store them in
-// the global expansion_lists variable
+//   REAL_SCALARS    := { double; float; long double }
+// as specified at the top of the file and store them in the global
+// expansion_lists variable
 void read_expansion_lists (const std::string &filename)
 {
   std::ifstream in (filename.c_str());
@@ -285,61 +282,56 @@ void read_expansion_lists (const std::string &filename)
   if (! in)
     {
       std::cerr << "Instantiation list file can not be read!"
-               << std::endl;
+                << std::endl;
       std::exit (1);
     }
 
-                                  // read the entire file into a string for
-                                  // simpler processing. replace end-of-line
-                                  // characters by spaces
+  // read the entire file into a string for simpler processing. replace
+  // end-of-line characters by spaces
   std::string whole_file = read_whole_file (in);
 
-                                  // now process entries of the form
-                                  // NAME := { class1; class2; ...}.
+  // now process entries of the form
+  //   NAME := { class1; class2; ...}.
   while (whole_file.size() != 0)
     {
       const std::string
-       name = get_substring_with_delim (whole_file, " :");
+      name = get_substring_with_delim (whole_file, " :");
 
       skip_space (whole_file);
       if (whole_file.find (":=") != 0)
-       {
-         std::cerr << "Invalid entry <" << name << '>' << std::endl;
-         std::exit (1);
-       }
+        {
+          std::cerr << "Invalid entry <" << name << '>' << std::endl;
+          std::exit (1);
+        }
       whole_file.erase (0, 2);
       skip_space (whole_file);
       if (whole_file.find ("{") != 0)
-       {
-         std::cerr << "Invalid entry <" << name << '>' << std::endl;
-         std::exit (1);
-       }
+        {
+          std::cerr << "Invalid entry <" << name << '>' << std::endl;
+          std::exit (1);
+        }
       whole_file.erase (0, 1);
       skip_space (whole_file);
 
       std::string
-       expansion = get_substring_with_delim (whole_file, "}");
+      expansion = get_substring_with_delim (whole_file, "}");
 
       if (whole_file.find ("}") != 0)
-       {
-         std::cerr << "Invalid entry <" << name << '>' << std::endl;
-         std::exit (1);
-       }
+        {
+          std::cerr << "Invalid entry <" << name << '>' << std::endl;
+          std::exit (1);
+        }
       whole_file.erase (0, 1);
       skip_space (whole_file);
 
-                                      // assign but remove empty entries;
-                                      // this may happen if an expansion list
-                                      // ends in a semicolon (then we get an
-                                      // empty entry at the end), or if there
-                                      // are multiple semicolons after each
-                                      // other (this may happen if, for
-                                      // example, we have "Vector<double>;
-                                      // TRILINOS_VECTOR;" and if
-                                      // TRILINOS_VECTOR is an empty
-                                      // expansion after running ./configure)
+      // assign but remove empty entries; this may happen if an expansion
+      // list ends in a semicolon (then we get an empty entry at the end),
+      // or if there are multiple semicolons after each other (this may
+      // happen if, for example, we have "Vector<double>; TRILINOS_VECTOR;"
+      // and if TRILINOS_VECTOR is an empty expansion after running
+      // ./configure)
       expansion_lists[name]
-       = delete_empty_entries (split_string_list (expansion, ';'));
+        = delete_empty_entries (split_string_list (expansion, ';'));
     }
 }
 
@@ -348,145 +340,138 @@ void read_expansion_lists (const std::string &filename)
 // produce all combinations of substitutions of the tokens given in the
 // #substitutions list in #text and output it to std::cout
 void substitute (const std::string &text,
-                const std::list<std::pair<std::string, std::string> > &substitutions)
+                 const std::list<std::pair<std::string, std::string> > &substitutions)
 {
-                                  // do things recursively: if the list of
-                                  // substitutions has a single entry, then
-                                  // process all of them. otherwise, process
-                                  // the first in the list and call the
-                                  // function recursively with the rest of
-                                  // the substitutions
+  // do things recursively: if the list of substitutions has a single
+  // entry, then process all of them. otherwise, process the first in the
+  // list and call the function recursively with the rest of the
+  // substitutions
   if (substitutions.size() > 1)
     {
-                                      // do the first substitution, then call
-                                      // function recursively
+      // do the first substitution, then call function recursively
       const std::string name    = substitutions.front().first,
-                       pattern = substitutions.front().second;
+                        pattern = substitutions.front().second;
 
       const std::list<std::pair<std::string, std::string> >
-       rest_of_substitutions (++substitutions.begin(),
-                              substitutions.end());
+      rest_of_substitutions (++substitutions.begin(),
+                             substitutions.end());
 
       for (std::list<std::string>::const_iterator
-            expansion = expansion_lists[pattern].begin();
-          expansion != expansion_lists[pattern].end();
-          ++expansion)
-       {
-         std::string new_text
-           = substitute_tokens (text, name, *expansion);
-
-         substitute (new_text, rest_of_substitutions);
-       }
+           expansion = expansion_lists[pattern].begin();
+           expansion != expansion_lists[pattern].end();
+           ++expansion)
+        {
+          std::string new_text
+            = substitute_tokens (text, name, *expansion);
+
+          substitute (new_text, rest_of_substitutions);
+        }
     }
   else if (substitutions.size() == 1)
     {
-                                      // do the substitutions
+      // do the substitutions
       const std::string name    = substitutions.front().first,
-                       pattern = substitutions.front().second;
+                        pattern = substitutions.front().second;
 
       for (std::list<std::string>::const_iterator
-            expansion = expansion_lists[pattern].begin();
-          expansion != expansion_lists[pattern].end();
-          ++expansion)
-       std::cout << substitute_tokens (text, name, *expansion)
-                 << std::endl;
+           expansion = expansion_lists[pattern].begin();
+           expansion != expansion_lists[pattern].end();
+           ++expansion)
+        std::cout << substitute_tokens (text, name, *expansion)
+                  << std::endl;
     }
   else
     {
       std::cout << text
-               << std::endl;
+                << std::endl;
     }
 }
 
 
 
 // process the list of instantiations given in the form
-// --------------------
-// for (u,v:VECTORS; z:SCALARS) { f(u, z, const v &); }
-// --------------------
+//   for (u,v:VECTORS; z:SCALARS) { f(u, z, const v &); }
 void process_instantiations ()
 {
   std::string whole_file = read_whole_file (std::cin);
 
-                                  // process entries of the form
-                                  //  for (X:Y; A:B) { INST }
+  // process entries of the form
+  //   for (X:Y; A:B) { INST }
   while (whole_file.size() != 0)
     {
       skip_space (whole_file);
       if (whole_file.find ("for") != 0)
-       {
-         std::cerr << "Invalid instantiation list: missing 'for'" << std::endl;
-         std::exit (1);
-       }
+        {
+          std::cerr << "Invalid instantiation list: missing 'for'" << std::endl;
+          std::exit (1);
+        }
       whole_file.erase (0, 3);
       skip_space (whole_file);
       if (whole_file.find ("(") != 0)
-       {
-         std::cerr << "Invalid instantiation list: missing '('" << std::endl;
-         std::exit (1);
-       }
+        {
+          std::cerr << "Invalid instantiation list: missing '('" << std::endl;
+          std::exit (1);
+        }
       whole_file.erase (0, 1);
       skip_space (whole_file);
 
       const std::list<std::string>
-       substitutions_list
-       = split_string_list (get_substring_with_delim (whole_file,
-                                                      ")"),
-                            ';');
+      substitutions_list
+        = split_string_list (get_substring_with_delim (whole_file,
+                                                       ")"),
+                             ';');
       if (whole_file.find (")") != 0)
-       {
-         std::cerr << "Invalid instantiation list: missing ')'" << std::endl;
-         std::exit (1);
-       }
+        {
+          std::cerr << "Invalid instantiation list: missing ')'" << std::endl;
+          std::exit (1);
+        }
       whole_file.erase (0, 1);
       skip_space (whole_file);
 
-                                      // process the header
+      // process the header
       std::list<std::pair<std::string, std::string> >
-       substitutions;
+      substitutions;
 
       for (std::list<std::string>::const_iterator
-            s = substitutions_list.begin();
-          s != substitutions_list.end(); ++s)
-       {
-         const std::list<std::string>
-           names_and_type = split_string_list (*s, ':');
-         if (names_and_type.size() != 2)
-           {
-             std::cerr << "Invalid instantiation header" << std::endl;
-             std::exit (1);
-           }
-
-         const std::list<std::string>
-           names = split_string_list (names_and_type.front(), ',');
-
-         for (std::list<std::string>::const_iterator
-                x = names.begin(); x != names.end(); ++x)
-           substitutions.push_back (std::make_pair (*x,
-                                                    names_and_type.back()));
-       }
-
-                                      // now read the part in {...}
+           s = substitutions_list.begin();
+           s != substitutions_list.end(); ++s)
+        {
+          const std::list<std::string>
+          names_and_type = split_string_list (*s, ':');
+          if (names_and_type.size() != 2)
+            {
+              std::cerr << "Invalid instantiation header" << std::endl;
+              std::exit (1);
+            }
+
+          const std::list<std::string>
+          names = split_string_list (names_and_type.front(), ',');
+
+          for (std::list<std::string>::const_iterator
+               x = names.begin(); x != names.end(); ++x)
+            substitutions.push_back (std::make_pair (*x,
+                                                     names_and_type.back()));
+        }
+
+      // now read the part in {...}
       skip_space (whole_file);
       if (whole_file.find ("{") != 0)
-       {
-         std::cerr << "Invalid substitution text" << std::endl;
-         std::exit (1);
-       }
+        {
+          std::cerr << "Invalid substitution text" << std::endl;
+          std::exit (1);
+        }
       whole_file.erase (0, 1);
       skip_space (whole_file);
       const std::string text_to_substitute
-       = get_substring_with_delim (whole_file, "}");
+        = get_substring_with_delim (whole_file, "}");
       whole_file.erase (0,1);
       skip_space (whole_file);
 
-                                      // now produce the
-                                      // substitutions. first replace
-                                      // all occurrences of "\{" by
-                                      // "{"
+      // now produce the substitutions. first replace all occurrences of
+      // "\{" by "{"
       substitute (replace_all(replace_all(text_to_substitute, "\\{", "{"),
-                             "\\}", "}"),
-                 substitutions);
+                              "\\}", "}"),
+                  substitutions);
     }
 }
 
@@ -497,8 +482,8 @@ int main (int argc, char **argv)
   if (argc < 2)
     {
       std::cerr << "Usage: " << std::endl
-               << "  expand_instantiations class_list_files < in_file > out_file"
-               << std::endl;
+                << "  expand_instantiations class_list_files < in_file > out_file"
+                << std::endl;
       std::exit (1);
     }
 
index b7796338bf24598f50d66740439f479e6f46616b..def292d4409a640c602e28ad4802159e4f604f59 100644 (file)
 #include <cstdlib>
 #include <sys/stat.h>
 
-                                 // base path for object files,
-                                 // including trailing slash if
-                                 // non-empty
+// base path for object files, including trailing slash if non-empty
 std::string basepath;
 
-                                 // list of include directories
+// list of include directories
 std::vector<std::string> include_directories;
 
-                                 // for each file that we ever visit,
-                                 // store the set of other files it
-                                 // includes directly
+// for each file that we ever visit, store the set of other files it
+// includes directly
 std::map<std::string,std::set<std::string> > direct_includes;
 
-                                 // A variable that stores whether
-                                 // we want old-style or new-style format
+// A variable that stores whether we want old-style or new-style format
 enum Format
-  {
-    old_style, new_style
-  } format;
+{
+  old_style, new_style
+} format;
 
 
-bool file_exists(const std::string & file)
+bool file_exists(const std::string &file)
 {
   struct stat buf;
   int error = stat (file.c_str(), &buf);
 
-    return ((error == 0) &&
-           ((buf.st_mode & S_IFMT) == S_IFREG));
+  return ((error == 0) &&
+          ((buf.st_mode & S_IFMT) == S_IFREG));
 }
 
 
-                                 // for the given file, fill a
-                                 // respective entry in the "direct_includes"
-                                 // map listing the names of those
-                                 // files that are directly included
+// for the given file, fill a respective entry in the "direct_includes" map
+// listing the names of those files that are directly included
 void determine_direct_includes (const std::string &file)
 {
-                                   // if this file has already been
-                                   // treated, then leave it at this
+  // if this file has already been treated, then leave it at this
   if (direct_includes.find (file) != direct_includes.end())
     return;
 
-                                   // otherwise, open the file and go
-                                   // through it line by line to
-                                   // search for other includes. we
-                                   // will have to have the path to
-                                   // the present file later, so get
-                                   // it already here
+  // otherwise, open the file and go through it line by line to search for
+  // other includes. we will have to have the path to the present file
+  // later, so get it already here
   std::string present_path;
   if (file.find ('/') != std::string::npos)
     present_path = std::string (file.begin(),
-                               file.begin()+file.rfind ('/')+1);
+                                file.begin()+file.rfind ('/')+1);
 
   std::ifstream in(file.c_str());
-                                  // If the file does not exist, for
-                                  // instance an ".inst" file which
-                                  // will be generated by make later,
-                                  // just return from this function.
-                                  //
-                                  // As a result, non-existing files
-                                  // are expected to have no
-                                  // dependencies.
+  // If the file does not exist, for instance an ".inst" file which will be
+  // generated by make later, just return from this function.
+  //
+  // As a result, non-existing files are expected to have no dependencies.
   if (! ((bool)in))
     return;
-  
+
   std::string line;
   while (in)
     {
-                                       // get one line, eat whitespace
-                                       // at the beginning and see
-                                       // whether the first
-                                       // non-whitespace is a #
-                                       // character
+      // get one line, eat whitespace at the beginning and see whether the
+      // first non-whitespace is a # character
       getline (in, line);
       unsigned int pos=0;
       for (; pos<line.length(); ++pos)
         if ((line[pos] != ' ') && (line[pos] != '\t'))
           break;
 
-                                       // if no non-whitespace, or
-                                       // something other than #: next
-                                       // line
+      // if no non-whitespace, or something other than #: next line
       if ((pos == line.length()) || (line[pos] != '#'))
         continue;
 
-                                       // ok, this is a preprocessor
-                                       // line. eat pound sign and
-                                       // again the next couple of
-                                       // whitespaces
+      // ok, this is a preprocessor line. eat pound sign and again the next
+      // couple of whitespaces
       ++pos;
       for (; pos<line.length(); ++pos)
         if ((line[pos] != ' ') && (line[pos] != '\t'))
           break;
 
-                                       // and let's see whether the
-                                       // following is the word
-                                       // include
+      // and let's see whether the following is the word include
       if ((line.length() < pos+7)
           ||
           (! ((line[pos+0] == 'i') &&
@@ -160,19 +137,17 @@ void determine_direct_includes (const std::string &file)
               (line[pos+6] == 'e'))))
         continue;
 
-                                       // ok, word found. advance pos
-                                       // and eat more whitespace
+      // ok, word found. advance pos and eat more whitespace
       pos += 7;
       for (; pos<line.length(); ++pos)
         if ((line[pos] != ' ') && (line[pos] != '\t'))
           break;
 
-                                       // check that the next char is
-                                       // either '<' or '"'
+      // check that the next char is either '<' or '"'
       if ((line[pos] != '"') && (line[pos] != '<'))
         continue;
 
-                                       // copy out name
+      // copy out name
       std::string included_file;
       for (unsigned int endpos=pos+1; endpos<line.length(); ++endpos)
         if ((line[endpos]=='"') || (line[endpos] == '>'))
@@ -182,81 +157,68 @@ void determine_direct_includes (const std::string &file)
             break;
           }
       if (included_file.length() == 0)
-       {
-         std::cerr << "Include file name empty in file <" << file << "> line: " << std::endl
-                   << line << std::endl;
-         std::abort();
-       }
-
-
-      bool is_inst_file = 
-       included_file.size()>5
-       && (included_file.rfind(".inst") == (included_file.size()-5));
-
-                                      // .inst files are always relative to
-                                      // the current path. We need a special
-                                      // case, because they might not exist
-                                      // at this point and the next block
-                                      // checks the files for existence.
+        {
+          std::cerr << "Include file name empty in file <" << file << "> line: " << std::endl
+                    << line << std::endl;
+          std::abort();
+        }
+
+
+      bool is_inst_file =
+        included_file.size()>5
+        && (included_file.rfind(".inst") == (included_file.size()-5));
+
+      // .inst files are always relative to the current path. We need a
+      // special case, because they might not exist at this point and the
+      // next block checks the files for existence.
       if (is_inst_file)
-       included_file = present_path+included_file;
-      
+        included_file = present_path+included_file;
+
 
-                                      // next try to locate the file in
-                                       // absolute paths. For includes of the
-                                       // form #include "...", we check the
-                                       // current path first. 
+      // next try to locate the file in absolute paths. For includes of the
+      // form #include "...", we check the current path first.
       if (included_file[0] != '/' && !is_inst_file)
         {
-         bool is_relative_path = false;
+          bool is_relative_path = false;
           if (line[pos] == '"' && file_exists(present_path+included_file))
-           {
-             included_file = present_path+included_file;
-             is_relative_path = true;
-           }
-         
+            {
+              included_file = present_path+included_file;
+              is_relative_path = true;
+            }
+
           if (is_relative_path == false)
-           for (std::vector<std::string>::const_iterator
-                   include_dir=include_directories.begin();
+            for (std::vector<std::string>::const_iterator
+                 include_dir=include_directories.begin();
                  include_dir!=include_directories.end(); ++include_dir)
-             {
-               if (file_exists((*include_dir+included_file)))
-                 {
-                   included_file = *include_dir+included_file;
-                   break;
-                 }
-             }
+              {
+                if (file_exists((*include_dir+included_file)))
+                  {
+                    included_file = *include_dir+included_file;
+                    break;
+                  }
+              }
         }
 
-                                       // make sure the file exists
-                                       // and that we can read from
-                                       // it, otherwise just ignore
-                                       // the line
+      // make sure the file exists and that we can read from it, otherwise
+      // just ignore the line
+
+      // If this is an ".inst" file, it will be generated by make later, so
+      // we better keep it on the list.
 
-                                      // If this is an ".inst" file,
-                                      // it will be generated by make
-                                      // later, so we better keep it
-                                      // on the list.
-      
       if (line[pos] != '"' || !is_inst_file)
-       {
-         if (!file_exists(included_file))
-             continue;
-       }
+        {
+          if (!file_exists(included_file))
+            continue;
+        }
 
 
 
-                                       // ok, so we did find an
-                                       // appropriate file. add it to
-                                       // the correct list
+      // ok, so we did find an appropriate file. add it to the correct list
       direct_includes[file].insert (included_file);
 
-                                       // work on the include file
-                                       // recursively. note that the
-                                       // first line of this function
-                                       // saves us from infinite
-                                       // recursions in case of
-                                       // include loops
+      // work on the include file recursively. note that the first line of
+      // this function saves us from infinite recursions in case of include
+      // loops
       determine_direct_includes (included_file);
     }
 }
@@ -264,132 +226,79 @@ void determine_direct_includes (const std::string &file)
 
 
 
-                                 // return the set of all included
-                                 // files, directly or indirectly, for
-                                 // the given file. for this purpose,
-                                 // we consider the direct_includes
-                                 // variable to be a representation of
-                                 // a directed graph: given a file (a
-                                 // node in the graph), the elements
-                                 // of the include-set for this file
-                                 // are outgoing edges from this
-                                 // node. to get at all includes,
-                                 // direct and indirect, we keep a
-                                 // list starting with the direct
-                                 // includes, the collect all direct
-                                 // includes of the files in the list,
-                                 // then their include files, etc. We
-                                 // thus march in fronts through the
-                                 // graph.
-                                 //
-                                 // one of the complications we have
-                                 // to keep track of is that the graph
-                                 // may be cyclic (i.e. header files
-                                 // include each other mutually -- in
-                                 // the real program, one of the
-                                 // includes will be guarded by
-                                 // preprocessor #ifdefs, but we don't
-                                 // see them here), so we have to make
-                                 // sure we strip elements from the
-                                 // present front that we have already
-                                 // visited before
-                                 //
-                                 // this function could presumably be
-                                 // made more efficient in the
-                                 // following way: when we have more
-                                 // than one file for which we want to
-                                 // compute dependencies, we presently
-                                 // walk through the graph for each of
-                                 // them. however, they will likely
-                                 // have one or more includes in
-                                 // common, so they will also have
-                                 // parts of the dependency graph in
-                                 // common. if we could precompute the
-                                 // dependency graph for include files
-                                 // in advance, we wouldn't have to
-                                 // walk through _all_ the graph for
-                                 // each file we consider, but could
-                                 // just draw in blocks. the problem
-                                 // with that is that to make this
-                                 // efficient we cannot just compute
-                                 // the whole set of dependencies for
-                                 // _each_ file, but we have to do
-                                 // this on the fly and to avoid again
-                                 // problems with the cyclic nature we
-                                 // have to keep track where we are
-                                 // presently coming from. that's way
-                                 // too complicated for now and I
-                                 // leave it to times when dependency
-                                 // generation becomes again a
-                                 // noticable time hit
-                                 //
-                                 // one of the ideas to solve this
-                                 // problem would be to start at
-                                 // terminal nodes of the graph
-                                 // (i.e. nodes that have no outgoing
-                                 // edges) and fold these nodes into
-                                 // nodes that have only outgoing
-                                 // edges to terminal nodes. store the
-                                 // dependencies of these
-                                 // next-to-terminal nodes and remove
-                                 // the terminal ones. then start over
-                                 // again with the so generated
-                                 // graph. if we consider the files
-                                 // for which we want to compute
-                                 // dependency information as top
-                                 // level nodes (they will _only_ have
-                                 // outgoing nodes), we could
-                                 // presumable roll up the entire
-                                 // graph from the bottom (terminal
-                                 // nodes) and fold it one layer at a
-                                 // time
-                                 //
-                                 // in any case, there is presently no
-                                 // need for this since the actions of
-                                 // this function are presently not
-                                 // really time critical: parsing the
-                                 // files in the function above is a
-                                 // much bigger time-hit.
+// return the set of all included files, directly or indirectly, for the
+// given file. for this purpose, we consider the direct_includes variable
+// to be a representation of a directed graph: given a file (a node in the
+// graph), the elements of the include-set for this file are outgoing edges
+// from this node. to get at all includes, direct and indirect, we keep a
+// list starting with the direct includes, the collect all direct includes
+// of the files in the list, then their include files, etc. We thus march
+// in fronts through the graph.
+//
+// one of the complications we have to keep track of is that the graph may
+// be cyclic (i.e. header files include each other mutually -- in the real
+// program, one of the includes will be guarded by preprocessor #ifdefs,
+// but we don't see them here), so we have to make sure we strip elements
+// from the present front that we have already visited before
+//
+// this function could presumably be made more efficient in the following
+// way: when we have more than one file for which we want to compute
+// dependencies, we presently walk through the graph for each of them.
+// however, they will likely have one or more includes in common, so they
+// will also have parts of the dependency graph in common. if we could
+// precompute the dependency graph for include files in advance, we
+// wouldn't have to walk through _all_ the graph for each file we consider,
+// but could just draw in blocks. the problem with that is that to make
+// this efficient we cannot just compute the whole set of dependencies for
+// _each_ file, but we have to do this on the fly and to avoid again
+// problems with the cyclic nature we have to keep track where we are
+// presently coming from. that's way too complicated for now and I leave it
+// to times when dependency generation becomes again a noticable time hit
+//
+// one of the ideas to solve this problem would be to start at terminal
+// nodes of the graph (i.e. nodes that have no outgoing edges) and fold
+// these nodes into nodes that have only outgoing edges to terminal nodes.
+// store the dependencies of these next-to-terminal nodes and remove the
+// terminal ones. then start over again with the so generated graph. if we
+// consider the files for which we want to compute dependency information
+// as top level nodes (they will _only_ have outgoing nodes), we could
+// presumable roll up the entire graph from the bottom (terminal nodes) and
+// fold it one layer at a time
+//
+// in any case, there is presently no need for this since the actions of
+// this function are presently not really time critical: parsing the files
+// in the function above is a much bigger time-hit.
 std::set<std::string>
 get_all_includes (const std::string &name)
 {
-                                   // start with direct includes
+  // start with direct includes
   std::set<std::string> all_includes = direct_includes[name];
 
   std::set<std::string> next_level_includes = all_includes;
   while (true)
     {
-                                       // traverse all next level
-                                       // includes and get their
-                                       // direct include files. the
-                                       // set makes sure that
-                                       // duplicates are removed
+      // traverse all next level includes and get their direct include
+      // files. the set makes sure that duplicates are removed
       std::set<std::string> second_next;
       for (std::set<std::string>::const_iterator
-             next=next_level_includes.begin();
+           next=next_level_includes.begin();
            next!=next_level_includes.end(); ++next)
         second_next.insert (direct_includes[*next].begin(),
                             direct_includes[*next].end());
 
-                                       // for each of them, if it
-                                       // hasn't been treated then add
-                                       // it to the files of the next
-                                       // level and later add it to
-                                       // the all_includes
+      // for each of them, if it hasn't been treated then add it to the
+      // files of the next level and later add it to the all_includes
       next_level_includes.clear ();
       for (std::set<std::string>::const_iterator f=second_next.begin();
            f!=second_next.end(); ++f)
         if (all_includes.find(*f) == all_includes.end())
           next_level_includes.insert (*f);
 
-                                       // if no new includes found no
-                                       // more, then quit
+      // if no new includes found no more, then quit
       if (next_level_includes.size() == 0)
         return all_includes;
 
-                                       // otherwise, copy over and
-                                       // start over on the next level
-                                       // of the tree
+      // otherwise, copy over and start over on the next level of the tree
       all_includes.insert (next_level_includes.begin(),
                            next_level_includes.end());
     }
@@ -401,47 +310,39 @@ int main (int argc, char **argv)
 {
   std::vector<std::string> filenames;
 
-                                   // parse all arguments (except the
-                                   // name of the executable itself)
+  // parse all arguments (except the name of the executable itself)
   for (unsigned int c=1; c<static_cast<unsigned int>(argc); ++c)
     {
       const std::string arg = argv[c];
 
-                                       // if string starts with -I,
-                                       // take this as an include path
+      // if string starts with -I, take this as an include path
       if ((arg.length()>2) && (arg[0]=='-') && (arg[1]=='I'))
         {
           std::string dir (arg.begin()+2, arg.end());
 
-                                           // append a slash if not
-                                           // already there
+          // append a slash if not already there
           if (dir[dir.length()-1] != '/')
             dir += '/';
 
-                                           // drop initial ./ if this
-                                           // is there
+          // drop initial ./ if this is there
           if ((dir[0]=='.') && (dir[1]=='/'))
             dir = std::string(dir.begin()+2, dir.end());
 
           include_directories.push_back (dir);
         }
-                                       // if string starts with -B,
-                                       // then this is the base name
-                                       // for object files
+      // if string starts with -B, then this is the base name for object
+      // files
       else if ((arg.length()>2) && (arg[0]=='-') && (arg[1]=='B'))
         {
           basepath = std::string(arg.begin()+2, arg.end());
           if (basepath[basepath.size()-1] != '/')
             basepath += '/';
         }
-                                       // if string is -n,
-                                       // then use new-style format
+      // if string is -n, then use new-style format
       else if ((arg.length()==2) && (arg[0]=='-') && (arg[1]=='n'))
-       format = new_style;
+        format = new_style;
 
-                                       // otherwise assume that this
-                                       // is one of the files for
-                                       // input
+      // otherwise assume that this is one of the files for input
       else
         {
           assert (arg.size()>=1);
@@ -451,29 +352,22 @@ int main (int argc, char **argv)
         }
     }
 
-                                   // next iterate through all files
-                                   // and figure out which other files
-                                   // they include
+  // next iterate through all files and figure out which other files they
+  // include
   for (std::vector<std::string>::const_iterator file=filenames.begin();
        file != filenames.end(); ++file)
     determine_direct_includes (*file);
 
 
-                                   // now we have all files that are
-                                   // directly or indirectly included
-                                   // into the files given on the
-                                   // command lines. for each of them,
-                                   // we have recorded which files
-                                   // they include themselves. for
-                                   // each file on the command line,
-                                   // we can thus form a complete
-                                   // include tree.
+  // now we have all files that are directly or indirectly included into
+  // the files given on the command lines. for each of them, we have
+  // recorded which files they include themselves. for each file on the
+  // command line, we can thus form a complete include tree.
   for (std::vector<std::string>::const_iterator file=filenames.begin();
        file != filenames.end(); ++file)
     {
-                                       // get base of filename by
-                                       // chipping away .cc extension
-                                       // as well as path
+      // get base of filename by chipping away .cc extension as well as
+      // path
       std::string basename;
       if (file->find (".cc") != std::string::npos)
         basename = std::string (file->begin(),
@@ -488,35 +382,32 @@ int main (int argc, char **argv)
         basename = std::string (basename.begin()+basename.rfind("/")+1,
                                 basename.end());
 
-                                       // get all direct and indirect
-                                       // includes for this file...
+      // get all direct and indirect includes for this file...
       const std::set<std::string> includes = get_all_includes (*file);
 
-                                       // ...write the rule for the .o
-                                       // file...
+      // ...write the rule for the .o file...
       if (format == old_style)
-       std::cout << basepath << basename << ".o: \\"
-                 << std::endl
-                 << "\t\t" << *file;
+        std::cout << basepath << basename << ".o: \\"
+                  << std::endl
+                  << "\t\t" << *file;
       else
-       std::cout << basepath << "optimized/" << basename << ".o: \\"
-                 << std::endl
-                 << "\t\t" << *file;
+        std::cout << basepath << "optimized/" << basename << ".o: \\"
+                  << std::endl
+                  << "\t\t" << *file;
       for (std::set<std::string>::const_iterator i=includes.begin();
            i!=includes.end(); ++i)
         std::cout << "\\\n\t\t" << *i;
       std::cout << std::endl;
 
-                                       // ...and a similar rule for
-                                       // the .o file in debug mode
+      // ...and a similar rule for the .o file in debug mode
       if (format == old_style)
-       std::cout << basepath << basename << ".g.o: \\"
-                 << std::endl
-                 << "\t\t" << *file;
+        std::cout << basepath << basename << ".g.o: \\"
+                  << std::endl
+                  << "\t\t" << *file;
       else
-       std::cout << basepath << "debug/" << basename << ".o: \\"
-                 << std::endl
-                 << "\t\t" << *file;
+        std::cout << basepath << "debug/" << basename << ".o: \\"
+                  << std::endl
+                  << "\t\t" << *file;
       for (std::set<std::string>::const_iterator i=includes.begin();
            i!=includes.end(); ++i)
         std::cout << "\\\n\t\t" << *i;

In the beginning the Universe was created. This has made a lot of people very angry and has been widely regarded as a bad move.

Douglas Adams


Typeset in Trocchi and Trocchi Bold Sans Serif.