[gentoo-commits] proj/libbash:master commit in: scripts/, src/core/, bashast/

[Petteri Räty]

commit:     8838cef4a07903791881cc64c8c5de02370eb38b
Author:     Mu Qiao <qiaomuf <AT> gentoo <DOT> org>
AuthorDate: Tue Apr 19 13:35:06 2011 +0000
Commit:     Petteri Räty <betelgeuse <AT> gentoo <DOT> org>
CommitDate: Wed Apr 20 13:44:30 2011 +0000
URL:        http://git.overlays.gentoo.org/gitweb/?p=proj/libbash.git;a=commit;h=8838cef4

Walker: implement replacement expansion for raw string

${parameter/pattern/string} is supported for raw string. We haven't
provided any advanced pattern matching yet. Array and positional
parameter expansion like ${var[@]/foo/bar} and ${*/foo/bar} are not
supported for now.

---
 bashast/libbashWalker.g             |   34 +++++++++++++++++++++++++-
 scripts/var_expansion.ebuild        |   15 +++++++++++
 scripts/var_expansion.ebuild.result |   15 +++++++++++
 src/core/interpreter.cpp            |   36 +++++++++++++++++++++++++++
 src/core/interpreter.h              |   46 +++++++++++++++++++++++++++++++++++
 5 files changed, 145 insertions(+), 1 deletions(-)

diff --git a/bashast/libbashWalker.g b/bashast/libbashWalker.g
index b6c9a7f..752e470 100644
--- a/bashast/libbashWalker.g
+++ b/bashast/libbashWalker.g
@@ -194,7 +194,39 @@ var_expansion returns[std::string libbash_value]
 		|^(libbash_name=name_base ARRAY_SIZE) {
 			libbash_value = boost::lexical_cast<std::string>(walker->get_array_length(libbash_name));
 		}
-	));
+	))
+	|^(REPLACE_ALL var_name pattern=string_expr (replacement=string_expr)?) {
+		libbash_value = walker->do_replace_expansion($var_name.libbash_value,
+													 std::bind(&interpreter::replace_all,
+															   std::placeholders::_1,
+															   pattern.libbash_value,
+															   replacement.libbash_value),
+													 $var_name.index);
+	}
+	|^(REPLACE_AT_END var_name pattern=string_expr (replacement=string_expr)?) {
+		libbash_value = walker->do_replace_expansion($var_name.libbash_value,
+													 std::bind(&interpreter::replace_at_end,
+															   std::placeholders::_1,
+															   pattern.libbash_value,
+															   replacement.libbash_value),
+													 $var_name.index);
+	}
+	|^(REPLACE_AT_START var_name pattern=string_expr (replacement=string_expr)?) {
+		libbash_value = walker->do_replace_expansion($var_name.libbash_value,
+													 std::bind(&interpreter::replace_at_start,
+															   std::placeholders::_1,
+															   pattern.libbash_value,
+															   replacement.libbash_value),
+													 $var_name.index);
+	}
+	|^(REPLACE_FIRST var_name pattern=string_expr (replacement=string_expr)?) {
+		libbash_value = walker->do_replace_expansion($var_name.libbash_value,
+													 std::bind(&interpreter::replace_first,
+															   std::placeholders::_1,
+															   pattern.libbash_value,
+															   replacement.libbash_value),
+													 $var_name.index);
+	};
 
 word returns[std::string libbash_value]
 	:(num) => libbash_string=num { $libbash_value = libbash_string; }

diff --git a/scripts/var_expansion.ebuild b/scripts/var_expansion.ebuild
index c45ad1e..9a46277 100644
--- a/scripts/var_expansion.ebuild
+++ b/scripts/var_expansion.ebuild
@@ -37,3 +37,18 @@ FOO035="${#ARRAY[0]}"
 FOO036="${#ARRAY[@]}"
 FOO037="${#ARRAY[*]}"
 FOO038="${#ARRAY}"
+FOO039="Hello World"
+FOO040=${FOO039/nothing/nothing}
+FOO041=${FOO039/o W/ow}
+FOO042=${FOO039//o/e}
+FOO043=${FOO039/#He/he}
+FOO044=${FOO039/#he/he}
+FOO045=${FOO039/%rld/rlD}
+FOO046=${FOO039/%rlD/rlD}
+FOO047=${FOO039/o W}
+FOO048=${FOO039//o}
+FOO049=${FOO039/#He}
+FOO050=${FOO039/#he}
+FOO051=${FOO039/%rld}
+FOO052=${FOO039/%rlD}
+FOO053=${FOO039/aaaaaaaaaaaa}

diff --git a/scripts/var_expansion.ebuild.result b/scripts/var_expansion.ebuild.result
index 8bea3b8..ed5fea3 100644
--- a/scripts/var_expansion.ebuild.result
+++ b/scripts/var_expansion.ebuild.result
@@ -39,3 +39,18 @@ FOO035=2
 FOO036=5
 FOO037=5
 FOO038=2
+FOO039=Hello World
+FOO040=Hello World
+FOO041=Helloworld
+FOO042=Helle Werld
+FOO043=hello World
+FOO044=Hello World
+FOO045=Hello WorlD
+FOO046=Hello World
+FOO047=Hellorld
+FOO048=Hell Wrld
+FOO049=llo World
+FOO050=Hello World
+FOO051=Hello Wo
+FOO052=Hello World
+FOO053=Hello World

diff --git a/src/core/interpreter.cpp b/src/core/interpreter.cpp
index c683315..0ac5699 100644
--- a/src/core/interpreter.cpp
+++ b/src/core/interpreter.cpp
@@ -24,8 +24,11 @@
 
 #include "core/interpreter.h"
 
+#include <functional>
+
 #include <boost/algorithm/string/classification.hpp>
 #include <boost/algorithm/string/join.hpp>
+#include <boost/algorithm/string/replace.hpp>
 #include <boost/algorithm/string/split.hpp>
 
 #include "libbashWalker.h"
@@ -109,3 +112,36 @@ bool interpreter::call(const std::string& name,
 
   return true;
 }
+
+void interpreter::replace_all(std::string& value,
+                              const std::string& pattern,
+                              const std::string& replacement)
+{
+  boost::replace_all(value, pattern, replacement);
+}
+
+void interpreter::replace_at_end(std::string& value,
+                                 const std::string& pattern,
+                                 const std::string& replacement)
+{
+  if(value.size() >= pattern.size() &&
+     value.substr(value.size() - pattern.size()) == pattern)
+    value.replace(value.size() - pattern.size(),
+                  pattern.size(),
+                  replacement);
+}
+
+void interpreter::replace_at_start(std::string& value,
+                                   const std::string& pattern,
+                                   const std::string& replacement)
+{
+  if(value.substr(0, pattern.size()) == pattern)
+    value.replace(0, pattern.size(), replacement);
+}
+
+void interpreter::replace_first(std::string& value,
+                                const std::string& pattern,
+                                const std::string& replacement)
+{
+  boost::replace_first(value, pattern, replacement);
+}

diff --git a/src/core/interpreter.h b/src/core/interpreter.h
index 22a083e..72b8e3b 100644
--- a/src/core/interpreter.h
+++ b/src/core/interpreter.h
@@ -563,6 +563,20 @@ public:
     return value.substr(offset, length);
   }
 
+  /// \brief perform replacement expansion
+  /// \param the name of the varaible that needs to be expanded
+  /// \param the function object used to perform expansion
+  /// \param array index, use index=0 if it's not an array
+  /// \return the expanded value
+  std::string do_replace_expansion(const std::string& name,
+                                   std::function<void(std::string&)> replacer,
+                                   const unsigned index) const
+  {
+    std::string value = resolve<std::string>(name, index);
+    replacer(value);
+    return value;
+  }
+
   /// \brief get the length of a string variable
   /// \param the name of the variable
   /// \return the length
@@ -600,5 +614,37 @@ public:
   /// \param the value of the word
   //. \param[out] the splitted result
   void split_word(const std::string& word, std::vector<std::string>& output);
+
+  /// \brief perform expansion like ${var//foo/bar}
+  /// \param the value to be expanded
+  /// \param the pattern used to match the value
+  /// \param the replacement string
+  static void replace_all(std::string& value,
+                          const std::string& pattern,
+                          const std::string& replacement);
+
+  /// \brief perform expansion like ${var/%foo/bar}
+  /// \param the value to be expanded
+  /// \param the pattern used to match the value
+  /// \param the replacement string
+  static void replace_at_end(std::string& value,
+                             const std::string& pattern,
+                             const std::string& replacement);
+
+  /// \brief perform expansion like ${var/#foo/bar}
+  /// \param the value to be expanded
+  /// \param the pattern used to match the value
+  /// \param the replacement string
+  static void replace_at_start(std::string& value,
+                               const std::string& pattern,
+                               const std::string& replacement);
+
+  /// \brief perform expansion like ${var/foo/bar}
+  /// \param the value to be expanded
+  /// \param the pattern used to match the value
+  /// \param the replacement string
+  static void replace_first(std::string& value,
+                            const std::string& pattern,
+                            const std::string& replacement);
 };
 #endif