[Gnash-commit] gnash ChangeLog server/array.cpp

[Benjamin Wolsey]

CVSROOT:        /sources/gnash
Module name:    gnash
Changes by:     Benjamin Wolsey <bwy>   08/06/16 14:49:02

Modified files:
        .              : ChangeLog 
        server         : array.cpp 

Log message:
                * server/array.cpp: remove direct dependence on VM::get() (it's 
now
                  obtained from as_object.h), stop passing env around uselessly 
and
                  pass version instead.

CVSWeb URLs:
http://cvs.savannah.gnu.org/viewcvs/gnash/ChangeLog?cvsroot=gnash&r1=1.6942&r2=1.6943
http://cvs.savannah.gnu.org/viewcvs/gnash/server/array.cpp?cvsroot=gnash&r1=1.111&r2=1.112

Patches:
Index: ChangeLog
===================================================================
RCS file: /sources/gnash/gnash/ChangeLog,v
retrieving revision 1.6942
retrieving revision 1.6943
diff -u -b -r1.6942 -r1.6943
--- ChangeLog   16 Jun 2008 14:41:51 -0000      1.6942
+++ ChangeLog   16 Jun 2008 14:49:01 -0000      1.6943
@@ -1,3 +1,9 @@
+2008-06-16 Benjamin Wolsey <address@hidden>
+
+       * server/array.cpp: remove direct dependence on VM::get() (it's now
+         obtained from as_object.h), stop passing env around uselessly and
+         pass version instead.
+
 2008-06-16 Sandro Santilli <address@hidden>
 
        * libmedia/FLVParser.{cpp,h}: use _seekRequest from base class,

Index: server/array.cpp
===================================================================
RCS file: /sources/gnash/gnash/server/array.cpp,v
retrieving revision 1.111
retrieving revision 1.112
diff -u -b -r1.111 -r1.112
--- server/array.cpp    29 May 2008 09:22:00 -0000      1.111
+++ server/array.cpp    16 Jun 2008 14:49:02 -0000      1.112
@@ -65,27 +65,25 @@
 // string comparison, ascending (default sort method)
 struct as_value_lt
 {
-       as_environment& _env;
-       int _sv;
+       int _version;
 
-       as_value_lt(as_environment& env)
-               : _env(env)
+       as_value_lt(int version)
+               : _version(version)
        {
-               _sv = VM::get().getSWFVersion();
        }
 
        inline int str_cmp(const as_value& a, const as_value& b)
        {
-               std::string s = a.to_string_versioned(_sv);
-               return s.compare(b.to_string_versioned(_sv));
+               std::string s = a.to_string_versioned(_version);
+               return s.compare(b.to_string_versioned(_version));
        }
 
        inline int str_nocase_cmp(const as_value& a, const as_value& b)
        {
                using namespace boost::algorithm;
 
-               std::string c = to_upper_copy(a.to_string_versioned(_sv));
-               std::string d = to_upper_copy(b.to_string_versioned(_sv));
+               std::string c = to_upper_copy(a.to_string_versioned(_version));
+               std::string d = to_upper_copy(b.to_string_versioned(_version));
                return c.compare(d);
        }
 
@@ -134,7 +132,7 @@
 // string comparison, descending
 struct as_value_gt : public as_value_lt 
 {
-       as_value_gt(as_environment& env) : as_value_lt(env) {}
+       as_value_gt(int version) : as_value_lt(version) {}
        bool operator() (const as_value& a, const as_value& b)
        {
                return str_cmp(a, b) > 0;
@@ -144,7 +142,7 @@
 // string equality
 struct as_value_eq : public as_value_lt
 {
-       as_value_eq(as_environment& env) : as_value_lt(env) {}
+       as_value_eq(int version) : as_value_lt(version) {}
        bool operator() (const as_value& a, const as_value& b)
        {
                return str_cmp(a, b) == 0;
@@ -154,7 +152,7 @@
 // case-insensitive string comparison, ascending
 struct as_value_nocase_lt : public as_value_lt
 {
-       as_value_nocase_lt(as_environment& env) : as_value_lt(env) {}
+       as_value_nocase_lt(int version) : as_value_lt(version) {}
        bool operator() (const as_value& a, const as_value& b)
        {
                return str_nocase_cmp(a, b) < 0;
@@ -164,7 +162,7 @@
 // case-insensitive string comparison, descending
 struct as_value_nocase_gt : public as_value_lt
 {
-       as_value_nocase_gt(as_environment& env) : as_value_lt(env) {}
+       as_value_nocase_gt(int version) : as_value_lt(version) {}
        bool operator() (const as_value& a, const as_value& b)
        {
                return str_nocase_cmp(a, b) > 0;
@@ -174,7 +172,7 @@
 // case-insensitive string equality
 struct as_value_nocase_eq : public as_value_lt
 {
-       as_value_nocase_eq(as_environment& env) : as_value_lt(env) {}
+       as_value_nocase_eq(int version) : as_value_lt(version) {}
        bool operator() (const as_value& a, const as_value& b)
        {
                return str_nocase_cmp(a, b) == 0;
@@ -184,7 +182,7 @@
 // numeric comparison, ascending
 struct as_value_num_lt : public as_value_lt
 {
-       as_value_num_lt(as_environment& env) : as_value_lt(env) {}
+       as_value_num_lt(int version) : as_value_lt(version) {}
        bool operator() (const as_value& a, const as_value& b)
        {
                if (a.is_string() || b.is_string())
@@ -196,7 +194,7 @@
 // numeric comparison, descending
 struct as_value_num_gt : public as_value_lt
 {
-       as_value_num_gt(as_environment& env) : as_value_lt(env) {}
+       as_value_num_gt(int version) : as_value_lt(version) {}
        bool operator() (const as_value& a, const as_value& b)
        {
                if (a.is_string() || b.is_string())
@@ -208,7 +206,7 @@
 // numeric equality
 struct as_value_num_eq : public as_value_lt
 {
-       as_value_num_eq(as_environment& env) : as_value_lt(env) {}
+       as_value_num_eq(int version) : as_value_lt(version) {}
        bool operator() (const as_value& a, const as_value& b)
        {
                if (a.is_string() || b.is_string())
@@ -220,7 +218,7 @@
 // case-insensitive numeric comparison, ascending
 struct as_value_num_nocase_lt : public as_value_lt
 {
-       as_value_num_nocase_lt(as_environment& env) : as_value_lt(env) {}
+       as_value_num_nocase_lt(int version) : as_value_lt(version) {}
        bool operator() (const as_value& a, const as_value& b)
        {
                if (a.is_string() || b.is_string())
@@ -232,7 +230,7 @@
 // case-insensitive numeric comparison, descending
 struct as_value_num_nocase_gt : public as_value_lt
 {
-       as_value_num_nocase_gt(as_environment& env) : as_value_lt(env) {}
+       as_value_num_nocase_gt(int version) : as_value_lt(version) {}
        bool operator() (const as_value& a, const as_value& b)
        {
                if (a.is_string() || b.is_string())
@@ -244,7 +242,7 @@
 // case-insensitive numeric equality
 struct as_value_num_nocase_eq : public as_value_lt
 {
-       as_value_num_nocase_eq(as_environment& env) : as_value_lt(env) {}
+       as_value_num_nocase_eq(int version) : as_value_lt(version) {}
        bool operator() (const as_value& a, const as_value& b)
        {
                if (a.is_string() || b.is_string())
@@ -257,7 +255,7 @@
 // Note:
 // fUniqueSort and fReturnIndexedArray must first be stripped from the flag
 as_cmp_fn
-get_basic_cmp(boost::uint8_t flags, as_environment& env)
+get_basic_cmp(boost::uint8_t flags, int version)
 {
        as_cmp_fn f;
 
@@ -268,44 +266,44 @@
        switch ( flags )
        {
                case 0: // default string comparison
-                       f = as_value_lt(env);
+                       f = as_value_lt(version);
                        return f;
 
                case as_array_object::fDescending:
-                       f = as_value_gt(env);
+                       f = as_value_gt(version);
                        return f;
 
                case as_array_object::fCaseInsensitive: 
-                       f = as_value_nocase_lt(env);
+                       f = as_value_nocase_lt(version);
                        return f;
 
                case as_array_object::fCaseInsensitive | 
                                as_array_object::fDescending:
-                       f = as_value_nocase_gt(env);
+                       f = as_value_nocase_gt(version);
                        return f;
 
                case as_array_object::fNumeric: 
-                       f = as_value_num_lt(env);
+                       f = as_value_num_lt(version);
                        return f;
 
                case as_array_object::fNumeric | as_array_object::fDescending:
-                       f = as_value_num_gt(env);
+                       f = as_value_num_gt(version);
                        return f;
 
                case as_array_object::fCaseInsensitive | 
                                as_array_object::fNumeric:
-                       f = as_value_num_nocase_lt(env);
+                       f = as_value_num_nocase_lt(version);
                        return f;
 
                case as_array_object::fCaseInsensitive | 
                                as_array_object::fNumeric |
                                as_array_object::fDescending:
-                       f = as_value_num_nocase_gt(env);
+                       f = as_value_num_nocase_gt(version);
                        return f;
 
                default:
                        log_unimpl(_("Unhandled sort flags: %d (0x%X)"), 
(int)flags, (int)flags);
-                       f = as_value_lt(env);
+                       f = as_value_lt(version);
                        return f;
        }
 }
@@ -314,7 +312,7 @@
 // Note:
 // fUniqueSort and fReturnIndexedArray must first be stripped from the flag
 as_cmp_fn
-get_basic_eq(boost::uint8_t flags, as_environment& env)
+get_basic_eq(boost::uint8_t flags, int version)
 {
        as_cmp_fn f;
        flags &= ~(as_array_object::fDescending);
@@ -322,24 +320,24 @@
        switch ( flags )
        {
                case 0: // default string comparison
-                       f = as_value_eq(env);
+                       f = as_value_eq(version);
                        return f;
 
                case as_array_object::fCaseInsensitive: 
-                       f = as_value_nocase_eq(env);
+                       f = as_value_nocase_eq(version);
                        return f;
 
                case as_array_object::fNumeric: 
-                       f = as_value_num_eq(env);
+                       f = as_value_num_eq(version);
                        return f;
 
                case as_array_object::fCaseInsensitive | 
                                as_array_object::fNumeric:
-                       f = as_value_num_nocase_eq(env);
+                       f = as_value_num_nocase_eq(version);
                        return f;
 
                default:
-                       f = as_value_eq(env);
+                       f = as_value_eq(version);
                        return f;
        }
 }
@@ -589,10 +587,10 @@
 int
 as_array_object::index_requested(string_table::key name)
 {
-       std::string name_str = VM::get().getStringTable().value(name);
+       const std::string& nameString = _vm.getStringTable().value(name);
 
        as_value temp;
-       temp.set_string(name_str);
+       temp.set_string(nameString);
        double value = temp.to_number();
 
        // if we were sent a string that can't convert like "asdf", it returns 
as NaN. -1 means invalid index
@@ -967,12 +965,13 @@
        boost::intrusive_ptr<as_array_object> array = 
                ensureType<as_array_object>(fn.this_ptr);
 
-       as_environment& env = fn.env();
+       const int version = array->getVM().getSWFVersion();
+       
        boost::uint8_t flags = 0;
 
        if ( fn.nargs == 0 )
        {
-               array->sort(as_value_lt(env));
+               array->sort(as_value_lt(version));
                return as_value(array.get());
        }
        else if ( fn.nargs == 1 && fn.arg(0).is_number() )
@@ -991,11 +990,15 @@
                if (flags & as_array_object::fDescending) icmp = &int_lt_or_eq;
                else icmp = &int_gt;
 
+           as_environment& env = fn.env();
+
                as_value_custom avc = 
                        as_value_custom(*as_func, icmp, fn.this_ptr, env);
 
                if ( (flags & as_array_object::fReturnIndexedArray) )
+               {
                        return as_value(array->sort_indexed(avc));
+           }
                //log_debug("Sorting %d-sized array with custom function", 
array->size());
                array->sort(avc);
                //log_debug("After sorting, array is %d-sized", array->size());
@@ -1013,12 +1016,12 @@
        }
        bool do_unique, do_index;
        flags = flag_preprocess(flags, &do_unique, &do_index);
-       as_cmp_fn comp = get_basic_cmp(flags, env);
+       as_cmp_fn comp = get_basic_cmp(flags, version);
 
        if (do_unique)
        {
                as_cmp_fn eq =
-                       get_basic_eq(flags, env);
+                       get_basic_eq(flags, version);
                if (do_index) return array->sort_indexed(comp, eq);
                return array->sort(comp, eq);
        }
@@ -1036,14 +1039,14 @@
        bool do_unique = false, do_index = false;
        boost::uint8_t flags = 0;
 
-       VM& vm = VM::get();
-       int sv = vm.getSWFVersion();
+       VM& vm = array->getVM();
+       int version = vm.getSWFVersion();
        string_table& st = vm.getStringTable();
 
        // cases: sortOn("prop) and sortOn("prop", Array.FLAG)
        if ( fn.nargs > 0 && fn.arg(0).is_string() )
        {
-               string_table::key propField = 
st.find(PROPNAME(fn.arg(0).to_string_versioned(sv)));
+               string_table::key propField = 
st.find(PROPNAME(fn.arg(0).to_string_versioned(version)));
 
                if ( fn.nargs > 1 && fn.arg(1).is_number() )
                {
@@ -1051,11 +1054,11 @@
                        flags = flag_preprocess(flags, &do_unique, &do_index);
                }
                as_value_prop avc = as_value_prop(propField, 
-                                       get_basic_cmp(flags, env));
+                                       get_basic_cmp(flags, version));
                if (do_unique)
                {
                        as_value_prop ave = as_value_prop(propField, 
-                               get_basic_eq(flags, env));
+                               get_basic_eq(flags, version));
                        if (do_index)
                                return array->sort_indexed(avc, ave);
                        return array->sort(avc, ave);
@@ -1079,7 +1082,7 @@
                for (as_array_object::const_iterator it = props->begin();
                        it != props->end(); ++it)
                {
-                       string_table::key s = 
st.find(PROPNAME((*it).to_string_versioned(sv)));
+                       string_table::key s = 
st.find(PROPNAME((*it).to_string_versioned(version)));
                        prp.push_back(s);
                }
                
@@ -1087,7 +1090,7 @@
                if (fn.nargs == 1)
                {
                        // assign each cmp function to the standard cmp fn
-                       as_cmp_fn c = get_basic_cmp(0, env);
+                       as_cmp_fn c = get_basic_cmp(0, version);
                        cmp.assign(optnum, c);
                }
                // case: sortOn(["prop1", "prop2"], [Array.FLAG1, Array.FLAG2])
@@ -1109,18 +1112,18 @@
                                        flgs.begin();
 
                                while (it != flgs.end())
-                                       cmp.push_back(get_basic_cmp(*it++, 
env));
+                                       cmp.push_back(get_basic_cmp(*it++, 
version));
 
                                if (do_unique)
                                {
                                        it = flgs.begin();
                                        while (it != flgs.end())
-                                               
eq.push_back(get_basic_eq(*it++, env));
+                                               
eq.push_back(get_basic_eq(*it++, version));
                                }
                        }
                        else
                        {
-                               as_cmp_fn c = get_basic_cmp(0, env);
+                               as_cmp_fn c = get_basic_cmp(0, version);
                                cmp.assign(optnum, c);
                        }
                }
@@ -1130,13 +1133,13 @@
                        boost::uint8_t flags = 
                                
static_cast<boost::uint8_t>(fn.arg(1).to_number());
                        flags = flag_preprocess(flags, &do_unique, &do_index);
-                       as_cmp_fn c = get_basic_cmp(flags, env);
+                       as_cmp_fn c = get_basic_cmp(flags, version);
 
                        cmp.assign(optnum, c);
                        
                        if (do_unique)
                        {
-                               as_cmp_fn e = get_basic_eq(flags, env);
+                               as_cmp_fn e = get_basic_eq(flags, version);
                                eq.assign(optnum, e);
                        }
                }
@@ -1255,11 +1258,13 @@
        boost::intrusive_ptr<as_array_object> array = 
ensureType<as_array_object>(fn.this_ptr);
 
        std::string separator = ",";
-       int swfversion = VM::get().getSWFVersion();
+       int version = array->getVM().getSWFVersion();
        as_environment* env = &(fn.env());
 
        if (fn.nargs > 0)
-               separator = fn.arg(0).to_string_versioned(swfversion);
+    {
+               separator = fn.arg(0).to_string_versioned(version);
+    }
 
        std::string ret = array->join(separator, env);
 
@@ -1527,7 +1532,7 @@
        if ( proto == NULL )
        {
                proto = new as_object(getObjectInterface());
-               VM::get().addStatic(proto.get());
+               proto->getVM().addStatic(proto.get());
 
                attachArrayInterface(*proto);
        }