Changeset 516

Timestamp:

Dec 9, 2007, 8:58:54 AM (15 years ago)

Author:

Peter Johansson

Message:

adding filename translations in Configuration class. Before checking what type parsing to use, filename is translated according to rules set in config file. Default rule (as before) is to remove trailing .in from filenames. To solve the parsing I added a simple regexp function - see utility.h

Location:

trunk

Files:

• lib/Configuration.cc (modified) (6 diffs)
• lib/Configuration.h (modified) (2 diffs)
• lib/Parser.cc (modified) (1 diff)
• lib/utility.cc (modified) (2 diffs)
• lib/utility.h (modified) (1 diff)
• test/repo/db/current (modified) (1 diff)
• test/repo/db/revprops/56 (added)
• test/repo/db/revs/56 (added)
• test/utility_test.cc (modified) (4 diffs)

trunk/lib/Configuration.cc

@@ -65 +65 @@
   Configuration::codon(std::string file_name) const 
   {
+    if (const std::pair<std::string,std::string>* dict=dictionary(file_name))
+      try {
+        file_name = translate(file_name, *dict);
+      }
+      catch (std::runtime_error& e) {
+        std::stringstream mess;
+        mess << "svndigest: invalid config file: "
+             << "expression " << dict->second << " is invalid";
+        if (e.what()[0])
+          mess << "because " << e.what() << " is a too large.";
+        else
+          mess << ".";
+        throw std::runtime_error(mess.str());
+      }
     for (String2Codons::const_iterator i(string2codons_.begin());
          i!=string2codons_.end(); ++i) {
@@ -82 +96 @@
 
 
+  const std::pair<std::string,std::string>* 
+  Configuration::dictionary(std::string lhs) const
+  {
+    for (size_t i=0; i<dictionary_.size(); ++i)
+      if (svndigest::equal(lhs.begin(), lhs.end(), 
+                           dictionary_[i].first.begin(),
+                           dictionary_[i].first.end()))
+        return &dictionary_[i];
+    return NULL;
+  }
+
+
   bool Configuration::equal_false(const std::string& str) const
   {
@@ -108 +134 @@
 
     bool parsing_found=false;
+    bool dictionary_found=false;
     std::string line;
     std::string section;
@@ -178 +205 @@
           mess << "svndigest: invalid config file\n"
                << "line: `" << line << "' is invalid.\n"
-               << "clashes with previous given file-name-pattern: ";
+               << "clashes with previous given file name pattern: ";
           // find previous file-name-pattern
           for (String2Codons::const_iterator i(string2codons_.begin());
@@ -210 +237 @@
         }
       } 
+      else if (section == "file-name-dictionary") {
+        if (!dictionary_found) {
+          dictionary_found=true;
+          // clearing the default setting
+          dictionary_.clear();
+        }
+        
+        if (const std::pair<std::string, std::string>* entry=dictionary(lhs)) {
+          std::stringstream mess;
+          mess << "svndigest: invalid config file\n"
+               << "line: `" << line << "' is invalid.\n"
+               << "clashes with previous given file name pattern: "
+               << "`" << entry->first << "'";
+          throw std::runtime_error(mess.str());
+        }
+        lhs = trim(lhs);
+        rhs = trim(rhs);
+        if (!lhs.empty() && !rhs.empty()) 
+          dictionary_.push_back(std::make_pair(lhs, rhs));
+        else if (!lhs.empty() || !rhs.empty()) {
+            std::stringstream mess;
+            mess << "svndigest: invalid config file\n"
+                 << "line: `" << line << "' is invalid.\n";
+            throw std::runtime_error(mess.str());
+        }
+      } 
     }
   }
@@ -225 +278 @@
   {
     return missing_copyright_warning_;
+  }
+
+
+  std::string 
+  Configuration::translate(const std::string& str,
+                           const std::pair<std::string, std::string>& dic) const
+  {
+    assert(svndigest::equal(str.begin(), str.end(),
+                            dic.first.begin(), dic.first.end()));
+    std::string res;
+    std::vector<std::string> vec;
+    regexp(str.begin(), str.end(), dic.first.begin(), dic.first.end(), vec);
+    for (std::string::const_iterator i(dic.second.begin()); 
+         i!=dic.second.end(); ++i) {
+      if (*i == '$') {
+        std::stringstream ss(std::string(i, dic.second.end()));
+        size_t n = 0;
+        ss >> n;
+        if (n>vec.size()){
+          std::stringstream mess;
+          mess << n;
+          throw std::runtime_error(mess.str());
+        }
+        if (n) {
+          res += vec[n-1];
+          ++i;
+          if (n>9){
+            ++i;
+            if (n>99)
+              ++i;
+          }
+        }
+        else
+          throw std::runtime_error("");
+      }
+      else
+        res += *i;
+    }
+
+    return res;
   }
 

trunk/lib/Configuration.h

@@ -96 +96 @@
 
     void clear(void);
-
+    const std::pair<std::string,std::string>* dictionary(std::string lhs) const;
     bool equal_false(const std::string&) const;
     bool equal_true(const std::string&) const;
-    std::string trans_end_code(std::string) const;
-    std::string trans_beg_code(std::string) const;
     void set_default(void);
+    /**
+       Translate string \a str using dictionary \a dict
+
+       \note \a str must be equal to d.first, or behavior is unspecified.
+
+       \throw if a '$' character is not followed by a positive integer
+       that is not larger than number of wildcards in dictionary \a d.
+     */
+    std::string translate(const std::string& str,
+                          const std::pair<std::string, std::string>& d) const;
     
     static Configuration* instance_;
@@ -123 +131 @@
   std::ostream& operator<<(std::ostream&, const Configuration&);
 
+  /**
+     If first character is '\n' replace it with "<NEWLINE>"
+   */
+  std::string trans_end_code(std::string);
+
+  /**
+     If last character is '\n' replace it with "<NEWLINE>"
+   */
+  std::string trans_beg_code(std::string);
+
 }} // end of namespace svndigest and namespace theplu
 

trunk/lib/Parser.cc

@@ -43 +43 @@
     std::ifstream is(path.c_str());
     assert(is.good());
-    // Ignore trailing '.in' in file names
-    if (match_end(path.rbegin(), path.rend(), ".in"))
-      path = path.substr(0, path.size()-3);
     const std::vector<std::pair<std::string, std::string> >* codon = 
       Configuration::instance().codon(path); 

trunk/lib/utility.cc

@@ -24 +24 @@
 #include "utility.h"
 
+#include <cassert>
 #include <cerrno> 
 #include <cstdlib>
@@ -208 +209 @@
 
 
+  bool regexp(std::string::const_iterator first1, 
+              std::string::const_iterator last1,
+              std::string::const_iterator first2,
+              std::string::const_iterator last2,
+              std::vector<std::string>& vec)
+  {
+    if (vec.empty())
+      vec.push_back("");
+
+    // first two cases when ranges are empty
+    if (first1==last1 && first2==last2){
+      vec.pop_back();
+      return true;
+    }
+    if (first1==last1 || first2==last2)
+      return false;
+
+    // then we take care of the real stuff
+    if (*first2 == '*'){
+      // trying '*' to consume another character
+      vec.back().append(1, *first1);
+      if (regexp(first1+1, last1, first2, last2, vec) )
+        return true;
+      assert(vec.back().size());
+      vec.back().resize(vec.back().size()-1);
+
+      // stepping away from the '*'
+      vec.push_back("");
+      if (regexp(first1, last1, first2+1, last2, vec)) 
+        return true;
+      vec.pop_back();
+      return false;
+    }
+    else if (*first2 == '?'){
+      // eating a character
+      vec.back() = std::string(first1, first1+1);
+      vec.push_back("");
+      if (regexp(first1+1, last1, first2+1, last2, vec) )
+        return true;
+      vec.pop_back();
+      // ? interpreted as zero characters
+      vec.back() = "";
+      vec.push_back("");
+      if (regexp(first1, last1, first2+1, last2, vec) )
+        return true;
+      vec.pop_back();
+      return false;
+    }
+    if (*first1 != *first2)
+      return false;
+    return regexp(++first1, last1, ++first2, last2, vec);
+  }
+
+
   void replace(std::string& str, std::string old_str, std::string new_str)
   {

trunk/lib/utility.h

@@ -150 +150 @@
   ///
   std::string pwd(void);
+
+  /**
+     \return true if first range match second range
+
+     Second range may contain wildcards (such as '*' and '?'), in
+     which case vector \a vec is filled with the corresponding strings
+     in first range. The algorithm is greedy, i.e., wildcard * is will
+     consume as many charcters as possible.
+
+     \note \a vec is supposed to be empty
+   */
+  bool regexp(std::string::const_iterator first1, 
+              std::string::const_iterator end1,
+              std::string::const_iterator first2,
+              std::string::const_iterator end2,
+              std::vector<std::string>& vec);
 
   /**

trunk/test/repo/db/current

@@ -1 @@
-55 1l 1
+56 1l 1

trunk/test/utility_test.cc

@@ -24 +24 @@
 #include "utility.h"
 
+#include <algorithm>
+#include <iterator>
 #include <iostream>
 #include <string>
@@ -29 +31 @@
 bool test_hex(int, u_int, std::string);
 bool test_equal(bool, std::string, std::string);
+bool test_regexp(bool, std::string, std::string, 
+                 const std::vector<std::string>&);
 
 int main(const int argc,const char* argv[])
@@ -43 +47 @@
   ok &= test_equal(true,"peter", "p*"); 
   ok &= test_equal(false,"peter", "p*j"); 
+
+  std::vector<std::string> vec;
+  ok &= test_regexp(true,"abcde", "abcde", vec); 
+  vec.push_back("");
+  ok &= test_regexp(true,"abcde", "abcd?e", vec); 
+  vec[0]="c";
+  ok &= test_regexp(true,"abcde", "ab?de", vec); 
+  vec[0] = "bcd";
+  ok &= test_regexp(true,"abcde", "a*e", vec); 
+  vec.push_back("");
+  ok &= test_regexp(true,"abcddf", "a*d*f", vec); 
+  vec[0] = "bc";
+  vec[1] = "ef";
+  ok &= test_regexp(true,"abcdefg", "a*d*g", vec); 
+  vec.push_back("");
+  ok &= test_regexp(true,"abcdefg", "a*d*?g", vec); 
 
   if (ok)
@@ -69 +89 @@
 }
 
+bool test_regexp(bool ans, std::string a, std::string b, 
+                 const std::vector<std::string>& vec)
+{
+  using namespace theplu::svndigest;
+  std::vector<std::string> v;
+  bool res = regexp(a.begin(), a.end(), b.begin(), b.end(), v);
+  if (res!=ans || v!=vec) {
+    std::cerr << "regexp(" << a << ", " << b << ") results "
+              << res << ". Expected " << ans << "\n"
+              << "resulting vector:\n";
+    std::copy(v.begin(), v.end(), 
+              std::ostream_iterator<std::string>(std::cerr, "\n"));
+    std::cerr << "expected:\n";
+    std::copy(vec.begin(), vec.end(), 
+              std::ostream_iterator<std::string>(std::cerr, "\n"));
+    return false;
+  }
+  return true;
+
+}