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

[Petteri Räty]

commit:     b37f97adcfaf9aea824aa5f1bacae4c326973434
Author:     Mu Qiao <qiaomuf <AT> gentoo <DOT> org>
AuthorDate: Mon Apr 11 13:25:42 2011 +0000
Commit:     Petteri Räty <betelgeuse <AT> gentoo <DOT> org>
CommitDate: Tue Apr 12 07:22:36 2011 +0000
URL:        http://git.overlays.gentoo.org/gitweb/?p=proj/libbash.git;a=commit;h=b37f97ad

Implement array symbol

Bash uses normal variables and arrays interchangeably. So we use
an internal map no matter if it's an array or variable.

---
 src/core/interpreter.h              |   12 ++++++---
 src/core/symbols.hpp                |   44 +++++++++++++++++++++++++++-------
 src/core/tests/interpreter_test.cpp |   27 +++++++++++++++++++++
 src/core/tests/symbols_test.cpp     |   31 +++++++++++++++++++++++-
 4 files changed, 100 insertions(+), 14 deletions(-)

diff --git a/src/core/interpreter.h b/src/core/interpreter.h
index 8fcab60..7155639 100644
--- a/src/core/interpreter.h
+++ b/src/core/interpreter.h
@@ -363,15 +363,16 @@ public:
 
   /// \brief resolve any variable
   /// \param variable name
+  /// \param array index, use index=0 if it's not an array
   /// \return the value of the variable, call default constructor if
   //          it's undefined
   template <typename T>
-  T resolve(const std::string& name)
+  T resolve(const std::string& name, const unsigned index=0)
   {
     std::shared_ptr<variable> value = members.resolve(name);
     if(!value)
       return T();
-    return value->get_value<T>();
+    return value->get_value<T>(index);
   }
 
   /// \brief check whether the value of the variable is null, return true
@@ -399,15 +400,18 @@ public:
   ///        it's readonly, will define the variable if it doesn't exist
   /// \param variable name
   /// \param new value
+  /// \param array index, use index=0 if it's not an array
   /// \return the new value of the variable
   template <typename T>
-  const T& set_value(const std::string& name, const T& new_value)
+  const T& set_value(const std::string& name,
+                     const T& new_value,
+                     const unsigned index=0)
   {
     std::shared_ptr<variable> value = members.resolve(name);
     if(!value)
       define(name, new_value, false);
     else
-      value->set_value(new_value);
+      value->set_value(new_value, index);
     return new_value;
   }
 

diff --git a/src/core/symbols.hpp b/src/core/symbols.hpp
index 077065e..f645047 100644
--- a/src/core/symbols.hpp
+++ b/src/core/symbols.hpp
@@ -25,6 +25,7 @@
 #ifndef LIBBASH_CORE_SYMBOLS_HPP_
 #define LIBBASH_CORE_SYMBOLS_HPP_
 
+#include <map>
 #include <memory>
 #include <sstream>
 #include <string>
@@ -115,8 +116,10 @@ class variable
   std::string name;
 
   /// \var private::value
-  /// \brief actual value of the variable
-  boost::variant<int, std::string> value;
+  /// \brief actual value of the variable. We put string in front of int
+  ///        because we want "" as default string value; Otherwise we
+  ///        will get "0".
+  std::map<int, boost::variant<std::string, int>> value;
 
   /// \var private::readonly
   /// \brief whether the variable is readonly
@@ -136,30 +139,43 @@ public:
 
   template <typename T>
   variable(const std::string& name,
-           T v,
+           const T& v,
            bool ro=false,
            bool is_null=false)
-    : name(name), value(v), readonly(ro), null_value(is_null){}
+    : name(name), readonly(ro), null_value(is_null)
+  {
+    value[0] = v;
+  }
 
-  /// \brief retrieve actual value of the variable
+  /// \brief retrieve actual value of the variable, if index is out of bound,
+  ///        will return the default value of type T
   /// \return the value of the variable
   template<typename T>
-  T get_value() const
+  T get_value(const unsigned index=0) const
   {
     static converter<T> visitor;
-    return boost::apply_visitor(visitor, value);
+
+    auto iter = value.find(index);
+    if(iter == value.end())
+        return T{};
+
+    return boost::apply_visitor(visitor, iter->second);
   }
 
   /// \brief set the value of the variable, raise exception if it's readonly
   /// \param the new value to be set
+  /// \param array index, use index=0 if it's not an array
   /// \param whether to set the variable to null value, default is false
   template <typename T>
-  void set_value(T new_value, bool is_null=false)
+  void set_value(const T& new_value,
+                 const unsigned index=0,
+                 bool is_null=false)
   {
     if(readonly)
       throw interpreter_exception(get_name() + " is readonly variable");
+
     null_value = is_null;
-    value = new_value;
+    value[index] = new_value;
   }
 
   /// \brief check whether the value of the variable is null
@@ -170,6 +186,16 @@ public:
   }
 };
 
+// specialization for arrays
+template <>
+inline variable::variable<>(const std::string& name,
+                            const std::map<int, std::string>& v,
+                            bool ro,
+                            bool is_null)
+    : name(name), value(v.begin(), v.end()), readonly(ro), null_value(is_null)
+{
+}
+
 ///
 /// class scope
 /// \brief implementation for symbol table

diff --git a/src/core/tests/interpreter_test.cpp b/src/core/tests/interpreter_test.cpp
index 6cc2df9..28f8d35 100644
--- a/src/core/tests/interpreter_test.cpp
+++ b/src/core/tests/interpreter_test.cpp
@@ -44,6 +44,17 @@ TEST(interpreter, define_resolve_string)
   EXPECT_STREQ("", walker.resolve<string>("undefined").c_str());
 }
 
+TEST(interpreter, define_resolve_array)
+{
+  interpreter walker;
+  std::map<int, std::string> values = {{0, "1"}, {1, "2"}, {2, "3"}};
+  walker.define("array", values);
+  EXPECT_STREQ("1", walker.resolve<string>("array", 0).c_str());
+  EXPECT_STREQ("2", walker.resolve<string>("array", 1).c_str());
+  EXPECT_STREQ("3", walker.resolve<string>("array", 2).c_str());
+  EXPECT_STREQ("", walker.resolve<string>("undefined",100).c_str());
+}
+
 TEST(interpreter, is_unset_or_null)
 {
   interpreter walker;
@@ -91,6 +102,22 @@ TEST(interpreter, set_string_value)
   EXPECT_STREQ("hi", walker.resolve<string>("astring_ro").c_str());
 }
 
+TEST(interpreter, set_array_value)
+{
+  interpreter walker;
+  std::map<int, std::string> values = {{0, "1"}, {1, "2"}, {2, "3"}};
+  walker.define("array", values);
+  EXPECT_STREQ("2", walker.set_value<string>("array", "2", 0).c_str());
+  EXPECT_STREQ("2", walker.resolve<string>("array", 0).c_str());
+  EXPECT_STREQ("out_of_bound", walker.set_value<string>("array", "out_of_bound", 10).c_str());
+  EXPECT_STREQ("out_of_bound", walker.resolve<string>("array",10).c_str());
+
+  walker.define("ro_array", values, true);
+  EXPECT_THROW(walker.set_value<string>("ro_array", "hello", 1),
+               interpreter_exception);
+  EXPECT_STREQ("2", walker.resolve<string>("ro_array", 1).c_str());
+}
+
 TEST(interperter, substring_expansion_exception)
 {
   interpreter walker;

diff --git a/src/core/tests/symbols_test.cpp b/src/core/tests/symbols_test.cpp
index 73a6a9c..2b7a65e 100644
--- a/src/core/tests/symbols_test.cpp
+++ b/src/core/tests/symbols_test.cpp
@@ -65,11 +65,40 @@ TEST(symbol_test, string_variable)
   EXPECT_EQ(123, int_string.get_value<int>());
 }
 
+TEST(symbol_test, array_variable)
+{
+  map<int, string> values = {{0, "1"}, {1, "2"}, {2, "3"}};
+
+  // readonly array
+  variable ro_array("foo", values, true);
+  EXPECT_STREQ("foo", ro_array.get_name().c_str());
+  EXPECT_STREQ("1", ro_array.get_value<string>(0).c_str());
+  EXPECT_STREQ("2", ro_array.get_value<string>(1).c_str());
+  EXPECT_STREQ("3", ro_array.get_value<string>(2).c_str());
+  EXPECT_THROW(ro_array.set_value("4", 0), interpreter_exception);
+  EXPECT_STREQ("1", ro_array.get_value<string>(0).c_str());
+
+  // out of bound
+  EXPECT_STREQ("", ro_array.get_value<string>(100).c_str());
+
+  // normal array
+  variable normal_array("foo", values);
+  normal_array.set_value("5", 4);
+  EXPECT_STREQ("1", normal_array.get_value<string>(0).c_str());
+  EXPECT_STREQ("2", normal_array.get_value<string>(1).c_str());
+  EXPECT_STREQ("3", normal_array.get_value<string>(2).c_str());
+  EXPECT_STREQ("", normal_array.get_value<string>(3).c_str());
+  EXPECT_STREQ("5", normal_array.get_value<string>(4).c_str());
+
+  // get integer value
+  EXPECT_EQ(3, normal_array.get_value<int>(2));
+}
+
 TEST(symbol_test, is_null)
 {
   variable var("foo", 10);
   EXPECT_FALSE(var.is_null());
-  var.set_value("bar", true);
+  var.set_value("bar", 0, true);
   EXPECT_TRUE(var.is_null());
   EXPECT_TRUE(variable("foo", "", false, true).is_null());
 }