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

[Sandro Santilli]

CVSROOT:        /sources/gnash
Module name:    gnash
Changes by:     Sandro Santilli <strk>  07/08/04 04:23:32

Modified files:
        .              : ChangeLog 
        server         : array.cpp 
        testsuite/actionscript.all: array.as 

Log message:
        Patch #6136 by Ivor Blockley <address@hidden>:
        
                * server/array.cpp:
                  Pointers to the as_environment object in the as_value 
comparison
                  functors are now references.
                  Fix a bug caused by a missing return statement in the 
get_basic_eq
                  function.
                * testsuite/actionscript.all/array.as:
                  UNIQUE -> UNIQUESORT flag.
                  add some tests to see how AS objects implementing the valueOf 
method
                  interact with array class methods.

CVSWeb URLs:
http://cvs.savannah.gnu.org/viewcvs/gnash/ChangeLog?cvsroot=gnash&r1=1.3945&r2=1.3946
http://cvs.savannah.gnu.org/viewcvs/gnash/server/array.cpp?cvsroot=gnash&r1=1.71&r2=1.72
http://cvs.savannah.gnu.org/viewcvs/gnash/testsuite/actionscript.all/array.as?cvsroot=gnash&r1=1.28&r2=1.29

Patches:
Index: ChangeLog
===================================================================
RCS file: /sources/gnash/gnash/ChangeLog,v
retrieving revision 1.3945
retrieving revision 1.3946
diff -u -b -r1.3945 -r1.3946
--- ChangeLog   4 Aug 2007 04:19:28 -0000       1.3945
+++ ChangeLog   4 Aug 2007 04:23:31 -0000       1.3946
@@ -1,3 +1,15 @@
+2007-08-04 Ivor Blockley <address@hidden>
+
+       * server/array.cpp:
+         Pointers to the as_environment object in the as_value comparison
+         functors are now references.
+         Fix a bug caused by a missing return statement in the get_basic_eq
+         function.
+       * testsuite/actionscript.all/array.as:
+         UNIQUE -> UNIQUESORT flag.
+         add some tests to see how AS objects implementing the valueOf method
+         interact with array class methods.
+
 2007-08-04 Sandro Santilli <address@hidden>
 
        * server/asobj/xmlnode.{cpp,h}: mark reachable resources

Index: server/array.cpp
===================================================================
RCS file: /sources/gnash/gnash/server/array.cpp,v
retrieving revision 1.71
retrieving revision 1.72
diff -u -b -r1.71 -r1.72
--- server/array.cpp    3 Aug 2007 21:10:19 -0000       1.71
+++ server/array.cpp    4 Aug 2007 04:23:32 -0000       1.72
@@ -58,12 +58,14 @@
 }
 
 // simple as_value strict-weak-ordering comparison functors:
+
+// string comparison, ascending (default sort method)
 struct as_value_lt
 {
-       as_environment* _env;
+       as_environment& _env;
        int _sv;
 
-       as_value_lt(as_environment* env)
+       as_value_lt(as_environment& env)
                : _env(env)
        {
                _sv = VM::get().getSWFVersion();
@@ -71,16 +73,16 @@
 
        inline int str_cmp(const as_value& a, const as_value& b)
        {
-               std::string s = a.to_string_versioned(_sv, _env);
-               return s.compare(b.to_string_versioned(_sv, _env));
+               std::string s = a.to_string_versioned(_sv, &_env);
+               return s.compare(b.to_string_versioned(_sv,& _env));
        }
 
        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, _env));
-               std::string d = to_upper_copy(b.to_string_versioned(_sv, _env));
+               std::string c = to_upper_copy(a.to_string_versioned(_sv, 
&_env));
+               std::string d = to_upper_copy(b.to_string_versioned(_sv, 
&_env));
                return c.compare(d);
        }
 
@@ -90,8 +92,8 @@
                if (b.is_undefined()) return true;
                if (a.is_null()) return false;
                if (b.is_null()) return true;
-               double aval = a.to_number(_env);
-               double bval = b.to_number(_env);
+               double aval = a.to_number(&_env);
+               double bval = b.to_number(&_env);
                if (isnan(aval)) return false;
                if (isnan(bval)) return true;
                return aval < bval;
@@ -103,8 +105,8 @@
                if (a.is_undefined()) return true;
                if (b.is_null()) return false;
                if (a.is_null()) return true;
-               double aval = a.to_number(_env);
-               double bval = b.to_number(_env);
+               double aval = a.to_number(&_env);
+               double bval = b.to_number(&_env);
                if (isnan(bval)) return false;
                if (isnan(aval)) return true;
                return aval > bval;
@@ -114,8 +116,8 @@
        {
                if (a.is_undefined() && b.is_undefined()) return true;
                if (a.is_null() && b.is_null()) return true;
-               double aval = a.to_number(_env);
-               double bval = b.to_number(_env);
+               double aval = a.to_number(&_env);
+               double bval = b.to_number(&_env);
                if (isnan(aval) && isnan(bval)) return true;
                return aval == bval;
        }
@@ -126,54 +128,60 @@
        }
 };
 
+// string comparison, descending
 struct as_value_gt : public as_value_lt
 {
-       as_value_gt(as_environment* env) : as_value_lt(env) {}
+       as_value_gt(as_environment& env) : as_value_lt(env) {}
        bool operator() (const as_value& a, const as_value& b)
        {
                return str_cmp(a, b) > 0;
        }
 };
 
+// string equality
 struct as_value_eq : public as_value_lt
 {
-       as_value_eq(as_environment* env) : as_value_lt(env) {}
+       as_value_eq(as_environment& env) : as_value_lt(env) {}
        bool operator() (const as_value& a, const as_value& b)
        {
                return str_cmp(a, b) == 0;
        }
 };
 
+// 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(as_environment& env) : as_value_lt(env) {}
        bool operator() (const as_value& a, const as_value& b)
        {
                return str_nocase_cmp(a, b) < 0;
        }
 };
 
+// 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(as_environment& env) : as_value_lt(env) {}
        bool operator() (const as_value& a, const as_value& b)
        {
                return str_nocase_cmp(a, b) > 0;
        }
 };
 
+// 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(as_environment& env) : as_value_lt(env) {}
        bool operator() (const as_value& a, const as_value& b)
        {
                return str_nocase_cmp(a, b) == 0;
        }
 };
 
+// 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(as_environment& env) : as_value_lt(env) {}
        bool operator() (const as_value& a, const as_value& b)
        {
                if (a.is_string() || b.is_string())
@@ -182,9 +190,10 @@
        }
 };
 
+// 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(as_environment& env) : as_value_lt(env) {}
        bool operator() (const as_value& a, const as_value& b)
        {
                if (a.is_string() || b.is_string())
@@ -193,9 +202,10 @@
        }
 };
 
+// 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(as_environment& env) : as_value_lt(env) {}
        bool operator() (const as_value& a, const as_value& b)
        {
                if (a.is_string() || b.is_string())
@@ -204,9 +214,10 @@
        }
 };
 
+// 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(as_environment& env) : as_value_lt(env) {}
        bool operator() (const as_value& a, const as_value& b)
        {
                if (a.is_string() || b.is_string())
@@ -215,9 +226,10 @@
        }
 };
 
+// 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(as_environment& env) : as_value_lt(env) {}
        bool operator() (const as_value& a, const as_value& b)
        {
                if (a.is_string() || b.is_string())
@@ -226,9 +238,10 @@
        }
 };
 
+// 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(as_environment& env) : as_value_lt(env) {}
        bool operator() (const as_value& a, const as_value& b)
        {
                if (a.is_string() || b.is_string())
@@ -241,7 +254,7 @@
 // Note:
 // fUniqueSort and fReturnIndexedArray must first be stripped from the flag
 as_cmp_fn
-get_basic_cmp(uint8_t flags, as_environment* env)
+get_basic_cmp(uint8_t flags, as_environment& env)
 {
        as_cmp_fn f;
 
@@ -290,11 +303,11 @@
        }
 }
 
-// Return basic as_value equality function for corresponding sort flag
+// Return basic as_value equality functor for corresponding sort flag
 // Note:
 // fUniqueSort and fReturnIndexedArray must first be stripped from the flag
 as_cmp_fn
-get_basic_eq(uint8_t flags, as_environment* env)
+get_basic_eq(uint8_t flags, as_environment& env)
 {
        as_cmp_fn f;
        flags &= ~(as_array_object::fDescending);
@@ -316,6 +329,7 @@
                case as_array_object::fCaseInsensitive | 
                                as_array_object::fNumeric:
                        f = as_value_num_nocase_eq(env);
+                       return f;
 
                default:
                        f = as_value_eq(env);
@@ -877,7 +891,7 @@
 {
        boost::intrusive_ptr<as_array_object> array = 
                ensureType<as_array_object>(fn.this_ptr);
-       as_environment* env = &(fn.env());
+       as_environment& env = fn.env();
        uint8_t flags = 0;
 
        if ( fn.nargs == 0 )
@@ -939,7 +953,7 @@
 {
        boost::intrusive_ptr<as_array_object> array = 
                ensureType<as_array_object>(fn.this_ptr);
-       as_environment* env = &(fn.env());
+       as_environment& env = fn.env();
        bool do_unique = false, do_index = false;
        uint8_t flags = 0;
        int sv = VM::get().getSWFVersion();
@@ -948,7 +962,7 @@
        if ( fn.nargs > 0 && fn.arg(0).is_string() )
        {
                std::string propField = 
-                       PROPNAME(fn.arg(0).to_string_versioned(sv, env));
+                       PROPNAME(fn.arg(0).to_string_versioned(sv, &env));
 
                if ( fn.nargs > 1 && fn.arg(1).is_number() )
                {
@@ -985,7 +999,7 @@
                        it != props->end(); ++it)
                {
                        std::string s = 
-                               PROPNAME((*it).to_string_versioned(sv, env));
+                               PROPNAME((*it).to_string_versioned(sv, &env));
                        prp.push_back(s);
                }
                

Index: testsuite/actionscript.all/array.as
===================================================================
RCS file: /sources/gnash/gnash/testsuite/actionscript.all/array.as,v
retrieving revision 1.28
retrieving revision 1.29
diff -u -b -r1.28 -r1.29
--- testsuite/actionscript.all/array.as 3 Aug 2007 21:10:19 -0000       1.28
+++ testsuite/actionscript.all/array.as 4 Aug 2007 04:23:32 -0000       1.29
@@ -5,7 +5,7 @@
 // Updated with sort functions, and to use check() macro
 // by Mike Carlson Feb. 14th, 2006
 
-rcsid="$Id: array.as,v 1.28 2007/08/03 21:10:19 strk Exp $";
+rcsid="$Id: array.as,v 1.29 2007/08/04 04:23:32 strk Exp $";
 
 #include "check.as"
 
@@ -42,6 +42,19 @@
 check(!Array.prototype.hasOwnProperty('valueOf'));
 #endif // OUTPUT_VERSION >= 6
 
+neg = new Object();
+neg.valueOf = function () { return -1; };
+zero = new Object();
+zero.valueOf = function () { return 0; };
+pos = new Object();
+pos.valueOf = function () { return 1; };
+two = new Object();
+two.valueOf = function () { return 2; };
+numeric = new Object();
+numeric.valueOf = function () { return Array.NUMERIC; };
+numericRev = new Object();
+numericRev.valueOf = function () { return (Array.NUMERIC | Array.DESCENDING); 
};
+
 var a;
 var popped;
 a=[551,"asdf",12];
@@ -76,6 +89,9 @@
 check_equals ( tmp.toString(), "," );
 #endif
 
+tmp = new Array(two);
+check_equals ( tmp.length, 2 );
+
 check_equals ( a.length, 3 );
 check_equals ( a[2], 12 );
 popped=a.pop();
@@ -228,6 +244,10 @@
 portion = concatted.slice(18);
 check_equals ( portion.toString(), "");
 
+// using objects that implement valueOf as index positions
+portion = concatted.slice(zero, two);
+check_equals ( portion.toString(), "0,1");
+
 //-------------------------------
 // Test splice
 //-------------------------------
@@ -383,6 +403,13 @@
        return 0;
 }
 
+function cmp_fn_obj(x,y)
+{
+       if (x.length < y.length) { return neg; }
+       if (x.length > y.length) { return pos; }
+       return zero;
+}
+
 function tolen(x)
 {
        var i;
@@ -437,6 +464,13 @@
 r = b.sort( Array.DESCENDING | Array.NUMERIC );
 check_equals( r.toString(), "8,5,3,1,0,-2,-7,-9" );
 check_equals( b.toString(), "8,5,3,1,0,-2,-7,-9" );
+r = b.sort( zero );
+check_equals( r.toString(), "-2,-7,-9,0,1,3,5,8" );
+check_equals( b.toString(), "-2,-7,-9,0,1,3,5,8" );
+b.sort( numeric );
+check_equals( b.toString(), "-9,-7,-2,0,1,3,5,8" );
+b.sort( numericRev );
+check_equals( b.toString(), "8,5,3,1,0,-2,-7,-9" );
 
 r = c.sort();
 check_equals( r.toString(), "-0.5,-3.7,0,0.001,2,7.2,8.35,Infinity" );
@@ -531,6 +565,19 @@
 check_equals( r.toString(), "singleton" );
 check_equals( e.toString(), "singleton" );
 
+trace(" -- Custom AS function tests using an AS comparator that returns 
objects -- ");
+r = a.sort( cmp_fn_obj, Array.DESCENDING );
+check_equals( tolen(r), "[5, 5, 4, 2, 2, 0]" );
+check_equals( tolen(a), "[5, 5, 4, 2, 2, 0]" );
+a.sort( cmp_fn_obj, Array.CASEINSENSITIVE | Array.NUMERIC );
+check_equals( tolen(a), "[0, 2, 2, 4, 5, 5]" );
+r = a.sort( cmp_fn_obj, Array.RETURNINDEXEDARRAY );
+check_equals( r.toString(), "0,1,2,3,4,5" );
+r = a.sort( cmp_fn_obj, Array.RETURNINDEXEDARRAY | Array.DESCENDING );
+check_equals( r.toString(), "5,4,3,2,1,0" );
+e.sort( cmp_fn_obj, Array.UNIQUESORT | Array.CASEINSENSITIVE );
+check_equals( e.toString(), "singleton" );
+
 a.push("ED");
 b.push(3.0);
 c.push(9/0);
@@ -811,6 +858,10 @@
 check( r instanceof Array );
 check_equals( tostr(a), "Zuse Z3,1941,false | Atanasoff-Berry,1941,true | 
Colossus,1943,true | ENIAC,1944,true" );
 
+trace("sortOn with flag as an object overriding the valueOf method");
+a.sortOn( ["Year", "Electronic", "Name"], numeric );
+check_equals( tostr(a), "ENIAC,1944,true | Colossus,1943,true | 
Atanasoff-Berry,1941,true | Zuse Z3,1941,false" );
+
 #if OUTPUT_VERSION < 7
 trace("sortOn property name case-mismatch");
 a.sortOn( "name" );
@@ -839,7 +890,7 @@
 a.sortOn( ["Mass", "Year", "Name"], [Array.NUMERIC | Array.DESCENDING, 
Array.NUMERIC | Array.DESCENDING | 0] );
 check_equals( tostr(a), "Atanasoff-Berry,1941,true | Harvard Mark 
I,1944,undefined | Zuse Z3,1941,false | Colossus,1943,true | ENIAC,1944,true" );
 
-a.sortOn( ["Mass", "Name"], [Array.UNIQUE, Array.DESCENDING] );
+a.sortOn( ["Mass", "Name"], [Array.UNIQUESORT, Array.DESCENDING] );
 check_equals( tostr(a), "Atanasoff-Berry,1941,true | Harvard Mark 
I,1944,undefined | Zuse Z3,1941,false | ENIAC,1944,true | Colossus,1943,true" );
 
 a.sortOn( ["Electronic", "Mass", "Name"], [0, Array.NUMERIC | 
Array.DESCENDING, 0] );