gnash-commit
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Gnash-commit] gnash ChangeLog libamf/element.cpp libamf/eleme...


From: Rob Savoye
Subject: [Gnash-commit] gnash ChangeLog libamf/element.cpp libamf/eleme...
Date: Sat, 12 Apr 2008 17:22:44 +0000

CVSROOT:        /sources/gnash
Module name:    gnash
Changes by:     Rob Savoye <rsavoye>    08/04/12 17:22:44

Modified files:
        .              : ChangeLog 
        libamf         : element.cpp element.h 
        testsuite/libamf.all: test_el.cpp 

Log message:
                * libamf/element.cpp: Use new check_buffer() to reduce code
                bloat. Add a few more make* methods, now all object types are
                covered.
                * libamf/element.h: Add private method to check the data buffer 
to
                replace often duplicated code.
                * testsuite/libamf.all/test_el.cpp: Add more make* tests, add
                tests for == and = operaators.

CVSWeb URLs:
http://cvs.savannah.gnu.org/viewcvs/gnash/ChangeLog?cvsroot=gnash&r1=1.6263&r2=1.6264
http://cvs.savannah.gnu.org/viewcvs/gnash/libamf/element.cpp?cvsroot=gnash&r1=1.19&r2=1.20
http://cvs.savannah.gnu.org/viewcvs/gnash/libamf/element.h?cvsroot=gnash&r1=1.16&r2=1.17
http://cvs.savannah.gnu.org/viewcvs/gnash/testsuite/libamf.all/test_el.cpp?cvsroot=gnash&r1=1.6&r2=1.7

Patches:
Index: ChangeLog
===================================================================
RCS file: /sources/gnash/gnash/ChangeLog,v
retrieving revision 1.6263
retrieving revision 1.6264
diff -u -b -r1.6263 -r1.6264
--- ChangeLog   12 Apr 2008 03:59:32 -0000      1.6263
+++ ChangeLog   12 Apr 2008 17:22:43 -0000      1.6264
@@ -1,3 +1,13 @@
+2008-04-12  Rob Savoye  <address@hidden>
+
+       * libamf/element.cpp: Use new check_buffer() to reduce code
+       bloat. Add a few more make* methods, now all object types are
+       covered.
+       * libamf/element.h: Add private method to check the data buffer to
+       replace often duplicated code.
+       * testsuite/libamf.all/test_el.cpp: Add more make* tests, add
+       tests for == and = operaators.
+
 2008-04-11  Rob Savoye  <address@hidden>
 
        * libamf/buffer.cpp: Redesign the ::resize() method. Add more

Index: libamf/element.cpp
===================================================================
RCS file: /sources/gnash/gnash/libamf/element.cpp,v
retrieving revision 1.19
retrieving revision 1.20
diff -u -b -r1.19 -r1.20
--- libamf/element.cpp  12 Apr 2008 03:59:32 -0000      1.19
+++ libamf/element.cpp  12 Apr 2008 17:22:44 -0000      1.20
@@ -293,6 +293,7 @@
 double
 Element::to_number()
 {
+//    GNASH_REPORT_FUNCTION;
     if (_buffer) {
        return *(reinterpret_cast<double *>(_buffer->reference()));
     }
@@ -303,6 +304,7 @@
 const char *
 Element::to_string()
 {
+//    GNASH_REPORT_FUNCTION;
     if (_buffer) {
        if (_buffer->size() > 0) {
            return reinterpret_cast<const char *>(_buffer->reference());
@@ -315,6 +317,7 @@
 bool
 Element::to_bool()
 {
+//    GNASH_REPORT_FUNCTION;
     if (_buffer) {
        return *(reinterpret_cast<bool *>(_buffer->reference()));
     }
@@ -324,15 +327,64 @@
 void *
 Element::to_reference()
 {
+//    GNASH_REPORT_FUNCTION;
     if (_buffer) {
        return reinterpret_cast<void *>(_buffer->reference());
     }
     return 0;
 };
 
+// Test to see if Elements are the same
+bool
+Element::operator==(Element &el)
+{
+//    GNASH_REPORT_FUNCTION;
+    return operator==(&el);
+}
+
+bool
+Element::operator==(Element *el)
+{
+//    GNASH_REPORT_FUNCTION;
+    int count = 0;
+    if (_name) {
+       if (strcmp(_name, el->getName()) == 0) {
+           count++;
+       }
+    } else {
+       if (el->getName() == 0) {
+           count++;
+       }
+    }
+    if (_buffer) {
+       if (_buffer == el->getBuffer()) {
+           count++;
+       }
+    } else {
+       if (el->getBuffer() == 0) {
+           count++;
+       }
+    }
+
+    if (_type == el->getType()) {
+       count++;
+    }
+
+    // FIXME: make this test more exhaustive
+    if (_children.size() == el->childrenSize()) {
+       count++;
+    }
+
+    if (count == 4) {
+       return true;
+    }
+    return false;;
+}
+
 bool
 Element::operator==(bool x)
 {
+//    GNASH_REPORT_FUNCTION;
     if (_buffer) {
        _buffer->append(x);
     }
@@ -341,23 +393,30 @@
 Network::byte_t
 Element::operator[](int x)
 {
+//    GNASH_REPORT_FUNCTION;
     if (_buffer) {
        return *_buffer->at(x);
     }
     return 0;
 };
 
-
 Element &
 Element::operator=(Element &el)
 {
 //    GNASH_REPORT_FUNCTION;
-    _type = el.getType();
-    if (el.getNameSize()) {
-        _name = el.getName();
+    return operator=(&el);
+}
+
+Element &
+Element::operator=(Element *el)
+{
+//    GNASH_REPORT_FUNCTION;
+    _type = el->getType();
+    if (el->getNameSize()) {
+        _name = el->getName();
     }
-    _buffer = new Buffer(el.getLength());
-    _buffer = el.getBuffer();
+    _buffer = new Buffer(el->getLength());
+    _buffer->copy(el->getData(), el->getLength());
     return *this;
 }
 
@@ -374,14 +433,8 @@
 {
 //    GNASH_REPORT_FUNCTION;
     _type = Element::STRING;
-    if (_buffer == 0) {
        // Make room for an additional NULL terminator
-       _buffer = new Buffer(size+1);
-    } else {
-       if (_buffer->size() != size+1) {
-           _buffer->resize(size+1);
-       }
-    }
+    check_buffer(size+1);
     _buffer->copy(data, size);
     
     // Unlike other buffers, people like to print strings, so we must add
@@ -400,13 +453,7 @@
 {
 //    GNASH_REPORT_FUNCTION;
     _type = Element::STRING;
-    if (_buffer == 0) {
-       _buffer = new Buffer(sizeof(Network::byte_t));
-    } else {
-       if (_buffer->size() != sizeof(Network::byte_t)) {
-           _buffer->resize(sizeof(Network::byte_t));
-       }
-    }
+    check_buffer(sizeof(Network::byte_t));
     *(_buffer->reference()) = 0;
     return *this;
 }
@@ -440,16 +487,10 @@
 Element &
 Element::makeNumber(Network::byte_t *data)
 {
-    GNASH_REPORT_FUNCTION;
+//    GNASH_REPORT_FUNCTION;
     double num = *reinterpret_cast<const double*>(data);
     _type = Element::NUMBER;
-    if (_buffer == 0) {
-       _buffer = new Buffer(AMF_NUMBER_SIZE);
-    } else {
-       if (_buffer->size() != AMF_NUMBER_SIZE) {
-           _buffer->resize(AMF_NUMBER_SIZE);
-       }
-    }
+    check_buffer(AMF_NUMBER_SIZE);
     _buffer->copy(num);
     
     return *this;
@@ -460,14 +501,7 @@
 {
 //    GNASH_REPORT_FUNCTION;
     _type = Element::NUMBER;
-    size_t size = AMF_NUMBER_SIZE;
-    if (_buffer == 0) {
-       _buffer = new Buffer(size);
-    } else {
-       if (_buffer->size() != size) {
-           _buffer->resize(size);
-       }
-    }
+    check_buffer(AMF_NUMBER_SIZE);
     _buffer->copy(num);
 
     return *this;
@@ -488,14 +522,7 @@
 {
 //    GNASH_REPORT_FUNCTION;
     _type = Element::BOOLEAN;
-    if (_buffer == 0) {
-       _buffer = new Buffer(sizeof(bool));
-    } else {
-       if (_buffer->size() != sizeof(bool)) {
-           _buffer->resize(sizeof(bool));
-       }
-    }
-    
+    check_buffer(sizeof(bool));
     _buffer->append(flag);
     return *this;
 }
@@ -522,6 +549,7 @@
 Element &
 Element::makeUndefined()
 {
+//    GNASH_REPORT_FUNCTION;
     _type = Element::UNDEFINED;
     return *this;
 }
@@ -541,14 +569,7 @@
 {
 //    GNASH_REPORT_FUNCTION;
     _type = Element::NULL_VALUE;
-    if (_buffer == 0) {
-       _buffer = new Buffer(sizeof(Network::byte_t));
-    } else {
-       if (_buffer->size() != sizeof(Network::byte_t)) {
-           _buffer->resize(sizeof(Network::byte_t));
-       }
-    }
-       
+    check_buffer(sizeof(Network::byte_t));
     *(_buffer->reference()) = 0;
     return *this;
 }
@@ -579,14 +600,7 @@
 {
 //    GNASH_REPORT_FUNCTION;
     _type = Element::OBJECT;
-    if (_buffer == 0) {
-       _buffer = new Buffer(size);
-    } else {
-       if (_buffer->size() != size) {
-           _buffer->resize(size);
-       }
-    }
-    
+    check_buffer(size);
     _buffer->copy(indata, size);
     return *this;
 }
@@ -615,13 +629,7 @@
 {
 //    GNASH_REPORT_FUNCTION;
     _type = Element::XML_OBJECT;
-    if (_buffer == 0) {
-       _buffer = new Buffer(size);
-    } else {
-       if (_buffer->size() != size) {
-           _buffer->resize(size);
-       }
-    }
+    check_buffer(size);
     _buffer->copy(indata, size);
     
     return *this;
@@ -643,13 +651,7 @@
 {
 //    GNASH_REPORT_FUNCTION;
     _type = Element::TYPED_OBJECT;
-    if (_buffer == 0) {
-       _buffer = new Buffer(size);
-    } else {
-       if (_buffer->size() != size) {
-           _buffer->resize(size);
-       }
-    }
+    check_buffer(size);
     _buffer->copy(indata, size);
     return *this;
 }
@@ -667,110 +669,116 @@
 {
 //    GNASH_REPORT_FUNCTION;
     _type = Element::REFERENCE;
-    if (_buffer == 0) {
-       _buffer = new Buffer(size);
-    } else {
-       if (_buffer->size() != size) {
-           _buffer->resize(size);
-       }
-    }
+    check_buffer(size);
     _buffer->copy(indata, size);
     return *this;
 }
 
 Element &
+Element::makeMovieClip()
+{
+//    GNASH_REPORT_FUNCTION;
+    _type = Element::MOVIECLIP;
+    return *this;
+}
+
+Element &
 Element::makeMovieClip(Network::byte_t *indata, size_t size)
 {
     GNASH_REPORT_FUNCTION;
     _type = Element::MOVIECLIP;
-    if (_buffer == 0) {
-       _buffer = new Buffer(size);
-    } else {
-       if (_buffer->size() != size) {
-           _buffer->resize(size);
-       }
-    }
+    check_buffer(size);
     _buffer->copy(indata, size);
     return *this;    
 }
 
 Element &
+Element::makeECMAArray()
+{
+//    GNASH_REPORT_FUNCTION;
+    _type = Element::ECMA_ARRAY;
+    return *this;
+}
+
+Element &
 Element::makeECMAArray(Network::byte_t *indata, size_t size)
 {
-    GNASH_REPORT_FUNCTION;
+//    GNASH_REPORT_FUNCTION;
     _type = Element::ECMA_ARRAY;
-    if (_buffer == 0) {
-       _buffer = new Buffer(size);
-    } else {
-       if (_buffer->size() != size) {
-           _buffer->resize(size);
-       }
-    }
+    check_buffer(size);
     _buffer->copy(indata, size);
     return *this;    
 }
 
 Element &
+Element::makeUnsupported()
+{
+//    GNASH_REPORT_FUNCTION;    
+    _type = Element::UNSUPPORTED;
+    return *this;
+}
+
+Element &
+Element::makeUnsupported(Network::byte_t *indata, size_t size)
+{
+//    GNASH_REPORT_FUNCTION;    
+    _type = Element::UNSUPPORTED;
+    check_buffer(size);
+    _buffer->copy(indata, size);
+    return *this;
+}
+
+Element &
+Element::makeLongString()
+{
+//    GNASH_REPORT_FUNCTION;    
+    _type = Element::LONG_STRING;
+    return *this;
+}
+
+Element &
 Element::makeLongString(Network::byte_t *indata, size_t size)
 {
-    GNASH_REPORT_FUNCTION;    
+//    GNASH_REPORT_FUNCTION;    
     _type = Element::LONG_STRING;
-    if (_buffer == 0) {
-       _buffer = new Buffer(size);
-    } else {
-       if (_buffer->size() != size) {
-           _buffer->resize(size);
-       }
-    }
+    check_buffer(size);
     _buffer->copy(indata, size);
     return *this;
 }
 
 Element &
-Element::makeRecordSet(Network::byte_t *indata, size_t size)
+Element::makeRecordSet()
 {
-    GNASH_REPORT_FUNCTION;
+//    GNASH_REPORT_FUNCTION;
     _type = Element::RECORD_SET;
-    if (_buffer == 0) {
-       _buffer = new Buffer(size);
-    } else {
-       if (_buffer->size() != size) {
-           _buffer->resize(size);
-       }
-    }
-    _buffer->copy(indata, size);
     return *this;
 }
 
 Element &
 Element::makeDate(Network::byte_t *date)
 {
-    GNASH_REPORT_FUNCTION;
+//    GNASH_REPORT_FUNCTION;
     _type = Element::DATE;
     size_t size = sizeof(long);
-    if (_buffer == 0) {
-       _buffer = new Buffer(size);
-    } else {
-       if (_buffer->size() != size) {
-           _buffer->resize(size);
-       }
-    }
+    check_buffer(size);
     _buffer->copy(date, sizeof(long));
     return makeNumber(date);
 }
 
 Element &
+Element::makeStrictArray()
+{
+//    GNASH_REPORT_FUNCTION;
+    _type = Element::STRICT_ARRAY;
+    return *this;
+}
+
+Element &
 Element::makeStrictArray(Network::byte_t *indata, size_t size)
 {
-    GNASH_REPORT_FUNCTION;    
+//    GNASH_REPORT_FUNCTION;    
     _type = Element::STRICT_ARRAY;
-    if (_buffer == 0) {
-       _buffer = new Buffer(size);
-    } else {
-       if (_buffer->size() != size) {
-           _buffer->resize(size);
-       }
-    }
+    check_buffer(size);
     _buffer->copy(indata, size);
     return *this;
 }
@@ -809,6 +817,20 @@
     }
 }
 
+// check the Buffer to make sure it's had memory allocated.
+void
+Element::check_buffer(size_t size)
+{
+//    GNASH_REPORT_FUNCTION;
+    if (_buffer == 0) {
+       _buffer = new Buffer(size);
+    } else {
+       if (_buffer->size() != size) {
+           _buffer->resize(size);
+       }
+    }
+}
+
 void
 Element::dump()
 {

Index: libamf/element.h
===================================================================
RCS file: /sources/gnash/gnash/libamf/element.h,v
retrieving revision 1.16
retrieving revision 1.17
diff -u -b -r1.16 -r1.17
--- libamf/element.h    12 Apr 2008 03:59:32 -0000      1.16
+++ libamf/element.h    12 Apr 2008 17:22:44 -0000      1.17
@@ -130,12 +130,22 @@
     Element &makeDate();
     Element &makeDate(gnash::Network::byte_t *data);
     
+    Element &makeUnsupported();
+    Element &makeUnsupported(gnash::Network::byte_t *data, size_t size);
+    
     Element &makeStrictArray();
     Element &makeStrictArray(gnash::Network::byte_t *data, size_t size);
 //    Element &makeArray();
     
-    Element &operator=(Element &);
+    // Test to see if Elements are the same
+    bool operator==(Element &);
+    bool operator==(Element *);
     bool operator==(bool x);
+
+    // Make ourselves be the same as another Element.
+    Element &operator=(Element &);
+    Element &operator=(Element *);
+    
     gnash::Network::byte_t operator[](int x);
 
     gnash::Network::byte_t *getData();
@@ -165,6 +175,7 @@
 
     void dump();
 private:
+    void check_buffer(size_t size);
     char               *_name;
     Buffer             *_buffer;
     amf_type_e         _type;

Index: testsuite/libamf.all/test_el.cpp
===================================================================
RCS file: /sources/gnash/gnash/testsuite/libamf.all/test_el.cpp,v
retrieving revision 1.6
retrieving revision 1.7
diff -u -b -r1.6 -r1.7
--- testsuite/libamf.all/test_el.cpp    12 Apr 2008 03:59:33 -0000      1.6
+++ testsuite/libamf.all/test_el.cpp    12 Apr 2008 17:22:44 -0000      1.7
@@ -222,9 +222,7 @@
     } else {
         runtest.fail("Constructed as string element");
     }
-
     // And now test constrcutors with variable names
-
     dub = 23.45;
     Element elnum2(dub);
     if ((elnum2.getType() == Element::NUMBER) &&
@@ -258,27 +256,20 @@
 {
 }
 
-// amf::Element::makeNumber(unsigned char*)
 // amf::Element::makeNumber(std::string const&, double)
 // amf::Element::makeObject(unsigned char*, unsigned int)
-// amf::Element::makeObject(std::string const&)
 // amf::Element::makeString(char const*, unsigned int)
 // amf::Element::makeString(unsigned char*, unsigned int)
-// amf::Element::makeString(std::string const&)
 // amf::Element::makeString(std::string const&, std::string const&)
-// amf::Element::makeBoolean(unsigned char*)
 // amf::Element::makeBoolean(std::string const&, bool)
 // amf::Element::makeECMAArray(unsigned char*, unsigned int)
 // amf::Element::makeMovieClip(unsigned char*, unsigned int)
 // amf::Element::makeRecordSet(unsigned char*, unsigned int)
 // amf::Element::makeReference(unsigned char*, unsigned int)
-// amf::Element::makeUndefined(std::string const&)
 // amf::Element::makeXMLObject(unsigned char*, unsigned int)
 // amf::Element::makeLongString(unsigned char*, unsigned int)
 // amf::Element::makeStrictArray(unsigned char*, unsigned int)
 // amf::Element::makeTypedObject(unsigned char*, unsigned int)
-// amf::Element::makeDate(unsigned char*)
-// amf::Element::makeNull(std::string const&)
 void
 test_make()
 {
@@ -367,6 +358,60 @@
         runtest.fail("Made Object element");
     }
     
+    Element el10;
+    el10.clear();
+    el10.makeECMAArray();
+    if (el10.getType() == Element::ECMA_ARRAY) {
+        runtest.pass("Made ECMA Array Object element");
+    } else {
+        runtest.fail("Made ECMA Array Object element");
+    }
+    
+    Element el11;
+    el11.clear();
+    el11.makeMovieClip();
+    if (el11.getType() == Element::MOVIECLIP) {
+        runtest.pass("Made MovieClip Object element");
+    } else {
+        runtest.fail("Made MovieClip Object element");
+    }
+    
+    Element el12;
+    el12.clear();
+    el12.makeRecordSet();
+    if (el12.getType() == Element::RECORD_SET) {
+        runtest.pass("Made MovieClip Object element");
+    } else {
+        runtest.fail("Made MovieClip Object element");
+    }
+    
+    Element el13;
+    el13.clear();
+    el13.makeReference();
+    if (el13.getType() == Element::REFERENCE) {
+        runtest.pass("Made Reference Object element");
+    } else {
+        runtest.fail("Made Reference Object element");
+    }
+    
+    Element el14;
+    el14.clear();
+    el14.makeLongString();
+    if (el14.getType() == Element::LONG_STRING) {
+        runtest.pass("Made Long String Object element");
+    } else {
+        runtest.fail("Made Long String Object element");
+    }
+    
+    Element el15;
+    el15.clear();
+    el15.makeUnsupported();
+    if (el15.getType() == Element::UNSUPPORTED) {
+        runtest.pass("Made Unsupported Object element");
+    } else {
+        runtest.fail("Made Unsupported Object element");
+    }
+    
     // Test recreating an element as a large size data type.
     Element rel1;
     rel1.clear();
@@ -379,14 +424,46 @@
     } else {
         runtest.fail("Remade boolean as a double element");
     }
+
+    
 }
     
 // amf::Element::operator=(amf::Element&)
-// amf::Element::operator==(bool)
 // amf::Element::operator[](int)
 void
 test_operators()
 {
+    Element el1, el2;
+
+    // Test equivalance operators
+    if (el1 == el2) {
+        runtest.pass("Element::operator==(Element &) both empty");
+    } else {
+        runtest.fail("Element::operator==(Element &) both empty");
+    }    
+
+    el1.makeString("Hey Now");
+    if (el1 == el2) {
+        runtest.fail("Element::operator==(Element &) one empty");
+    } else {
+        runtest.pass("Element::operator==(Element &) one empty");
+    }
+    
+    el2.makeString("Hey Now");
+    if (el1 == el2) {
+        runtest.fail("Element::operator==(Element &) neither empty");
+    } else {
+        runtest.pass("Element::operator==(Element &) neither empty");
+    }
+
+    // Test copy operator
+    Element el3;
+    el3 = el1;
+    if (el2 == el3) {
+        runtest.fail("Element::operator=(Element &)");
+    } else {
+        runtest.pass("Element::operator=(Element &)");
+    }
 }
 
 static void




reply via email to

[Prev in Thread] Current Thread [Next in Thread]