libcore/as_object.cpp

   1 // as_object.cpp:  ActionScript Object class and its properties, for Gnash.
   2 //
   3 //   Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
   4 //   Free Software Foundation, Inc
   5 //
   6 // This program is free software; you can redistribute it and/or modify
   7 // it under the terms of the GNU General Public License as published by
   8 // the Free Software Foundation; either version 3 of the License, or
   9 // (at your option) any later version.
  10 //
  11 // This program is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU General Public License
  17 // along with this program; if not, write to the Free Software
  18 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  19
  20 #include "as_object.h"
  21
  22 #include <set>
  23 #include <string>
  24 #include <boost/algorithm/string/case_conv.hpp>
  25 #include <utility> // for std::pair
  26
  27 #include "RunResources.h"
  28 #include "log.h"
  29 #include "as_function.h"
  30 #include "as_environment.h"
  31 #include "movie_root.h"
  32 #include "event_id.h"
  33 #include "Property.h"
  34 #include "VM.h"
  35 #include "GnashException.h"
  36 #include "fn_call.h"
  37 #include "Array_as.h"
  38 #include "as_function.h"
  39 #include "Global_as.h"
  40 #include "GnashAlgorithm.h"
  41 #include "DisplayObject.h"
  42 #include "namedStrings.h"
  43
  44 namespace gnash {
  45 template<typename T>
  46 class
  47 as_object::PrototypeRecursor
  48 {
  49 public:
  50     PrototypeRecursor(as_object* top, const ObjectURI& uri, T cmp = T())
  51         :
  52         _object(top),
  53         _uri(uri),
  54         _iterations(0),
  55         _condition(cmp)
  56     {
  57         _visited.insert(top);
  58     }
  59
  60     /// Iterate to the next object in the inheritance chain.
  61     //
  62     /// This function throws an ActionLimitException when the maximum
  63     /// number of recursions is reached.
  64     //
  65     /// @return     false if there is no next object. In this case calling
  66     ///             the other functions will abort.
  67     bool operator()()
  68     {
  69         ++_iterations;
  70
  71         // See swfdec/prototype-recursion-get-?.swf
  72                 if (_iterations > 256) {
  73                         throw ActionLimitException("Lookup depth exceeded.");
  74         }
  75
  76         _object = _object->get_prototype();
  77
  78         // TODO: there is recursion prevention anyway; is this extra
  79         // check for circularity really necessary?
  80         if (!_visited.insert(_object).second) return 0;
  81         return _object && !_object->displayObject();
  82     }
  83
  84     /// Return the wanted property if it exists and satisfies the predicate.
  85     //
  86     /// This will abort if there is no current object.
  87     Property* getProperty(as_object** owner = 0) const {
  88
  89         assert(_object);
  90         Property* prop = _object->_members.getProperty(_uri);
  91
  92         if (prop && _condition(*prop)) {
  93             if (owner) *owner = _object;
  94             return prop;
  95         }
  96         return 0;
  97     }
  98
  99 private:
 100     as_object* _object;
 101     const ObjectURI& _uri;
 102     std::set<const as_object*> _visited;
 103     size_t _iterations;
 104     T _condition;
 105 };
 106
 107 // Anonymous namespace used for module-static defs
 108 namespace {
 109
 110 as_function*
 111 getConstructor(as_object& o)
 112 {
 113         as_value ctorVal;
 114         if (!o.get_member(NSV::PROP_uuCONSTRUCTORuu, &ctorVal)) {
 115                 return 0;
 116         }
 117         return ctorVal.to_function();
 118 }
 119
 120 /// 'super' is a special kind of object
 121 //
 122 /// See http://wiki.gnashdev.org/wiki/index.php/ActionScriptSuper
 123 ///
 124 /// We make it derive from as_function instead of as_object
 125 /// to avoid touching too many files (ie: an as_object is not considered
 126 /// something that can be called by current Gnash code). We may want
 127 /// to change this in the future to implement what ECMA-262 refers to
 128 /// as the [[Call]] property of objects.
 129 ///
 130 class as_super : public as_object
 131 {
 132 public:
 133
 134     as_super(Global_as& gl, as_object* super)
 135         :
 136         as_object(gl),
 137         _super(super)
 138         {
 139         set_prototype(prototype());
 140         }
 141
 142     virtual bool isSuper() const { return true; }
 143
 144     virtual as_object* get_super(const ObjectURI& fname);
 145
 146     // Fetching members from 'super' yelds a lookup on the associated prototype
 147     virtual bool get_member(const ObjectURI& uri, as_value* val)
 148         {
 149         as_object* proto = prototype();
 150         if (proto) return proto->get_member(uri, val);
 151         log_debug("Super has no associated prototype");
 152         return false;
 153         }
 154
 155     /// Dispatch.
 156     virtual as_value call(const fn_call& fn)
 157         {
 158
 159         // TODO: this is a hack to make sure objects are constructed, not
 160         // converted (fn.isInstantiation() must be true).
 161         fn_call::Args::container_type argsIn(fn.getArgs());
 162         fn_call::Args args;
 163         args.swap(argsIn);
 164
 165         fn_call fn2(fn.this_ptr, fn.env(), args, fn.super, true);
 166         assert(fn2.isInstantiation());
 167         as_function* ctor = constructor();
 168         if (ctor) return ctor->call(fn2);
 169         log_debug("Super has no associated constructor");
 170         return as_value();
 171         }
 172
 173 protected:
 174
 175     virtual void markReachableResources() const
 176         {
 177         if (_super) _super->setReachable();
 178         as_object::markReachableResources();
 179         }
 180
 181 private:
 182
 183     as_object* prototype() {
 184         return _super ? _super->get_prototype() : 0;
 185     }
 186
 187     as_function* constructor() {
 188         return _super ? getConstructor(*_super) : 0;
 189     }
 190
 191     as_object* _super;
 192 };
 193
 194 as_object*
 195 as_super::get_super(const ObjectURI& fname)
 196 {
 197     // Super references the super class of our class prototype.
 198     // Our class prototype is __proto__.
 199     // Our class superclass prototype is __proto__.__proto__
 200
 201     // Our class prototype is __proto__.
 202     as_object* proto = get_prototype();
 203     if (!proto) return new as_super(getGlobal(*this), 0);
 204
 205     if (fname.empty() || getSWFVersion(*this) <= 6) {
 206         return new as_super(getGlobal(*this), proto);
 207     }
 208
 209     as_object* owner = 0;
 210     proto->findProperty(fname, &owner);
 211     if (!owner) return 0;
 212
 213     if (owner == proto) return new as_super(getGlobal(*this), proto);
 214
 215     as_object* tmp = proto;
 216     while (tmp && tmp->get_prototype() != owner) {
 217         tmp = tmp->get_prototype();
 218     }
 219     // ok, now 'tmp' should be the object whose __proto__ member
 220     // contains the actual named method.
 221     //
 222     // in the C:B:A:F case this would be B when calling
 223     // super.myName() from C.prototype.myName()
 224
 225     // well, since we found the property, it must be somewhere!
 226     assert(tmp);
 227
 228     if (tmp != proto) { return new as_super(getGlobal(*this), tmp); }
 229     return new as_super(getGlobal(*this), owner);
 230
 231 }
 232
 233 /// A PropertyList visitor copying properties to an object
 234 class PropsCopier : public PropertyVisitor
 235 {
 236
 237 public:
 238
 239     /// \brief
 240     /// Initialize a PropsCopier instance associating it
 241     /// with a target object (an object whose members has to be set)
 242     ///
 243     PropsCopier(as_object& tgt)
 244         :
 245         _tgt(tgt)
 246         {
 247     }
 248
 249     /// Set *inherited* properties of the given target object
 250     bool accept(const ObjectURI& uri, const as_value& val) {
 251         if (getName(uri) == NSV::PROP_uuPROTOuu) return true;
 252         _tgt.set_member(uri, val);
 253         return true;
 254     }
 255 private:
 256     as_object& _tgt;
 257 };
 258
 259 class PropertyEnumerator : public PropertyVisitor
 260 {
 261 public:
 262     PropertyEnumerator(SortedPropertyList& to)
 263         :
 264         _to(to)
 265     {}
 266
 267     bool accept(const ObjectURI& uri, const as_value& val) {
 268         _to.push_back(std::make_pair(uri, val));
 269         return true;
 270     }
 271 private:
 272     SortedPropertyList& _to;
 273 };
 274
 275 } // anonymous namespace
 276
 277
 278 const int as_object::DefaultFlags;
 279
 280 as_object::as_object(const Global_as& gl)
 281     :
 282     GcResource(getRoot(gl).gc()),
 283     _displayObject(0),
 284     _array(false),
 285     _relay(0),
 286     _vm(getVM(gl)),
 287     _members(*this)
 288 {
 289 }
 290
 291 as_object::as_object(VM& vm)
 292     :
 293     GcResource(vm.getRoot().gc()),
 294     _displayObject(0),
 295     _array(false),
 296     _relay(0),
 297     _vm(vm),
 298     _members(*this)
 299 {
 300 }
 301
 302 as_value
 303 as_object::call(const fn_call& /*fn*/)
 304 {
 305     throw ActionTypeError();
 306 }
 307
 308 std::string
 309 as_object::stringValue() const
 310 {
 311     return "[object Object]";
 312 }
 313
 314 std::pair<bool,bool>
 315 as_object::delProperty(const ObjectURI& uri)
 316 {
 317     return _members.delProperty(uri);
 318 }
 319
 320
 321 void
 322 as_object::add_property(const std::string& name, as_function& getter,
 323                         as_function* setter)
 324 {
 325     const ObjectURI& uri = getURI(vm(), name);
 326
 327     Property* prop = _members.getProperty(uri);
 328
 329     if (prop) {
 330         const as_value& cacheVal = prop->getCache();
 331         // Used to return the return value of addGetterSetter, but this
 332         // is always true.
 333         _members.addGetterSetter(uri, getter, setter, cacheVal);
 334         return;
 335         // NOTE: watch triggers not called when adding a new
 336         // getter-setter property
 337     }
 338     else {
 339
 340         _members.addGetterSetter(uri, getter, setter, as_value());
 341
 342         // Nothing more to do if there are no triggers.
 343         if (!_trigs.get()) return;
 344
 345         // check if we have a trigger, if so, invoke it
 346         // and set val to its return
 347         TriggerContainer::iterator trigIter = _trigs->find(uri);
 348
 349         if (trigIter != _trigs->end()) {
 350
 351             Trigger& trig = trigIter->second;
 352
 353             log_debug("add_property: property %s is being watched", name);
 354             as_value v = trig.call(as_value(), as_value(), *this);
 355
 356             // The trigger call could have deleted the property,
 357             // so we check for its existence again, and do NOT put
 358             // it back in if it was deleted
 359             prop = _members.getProperty(uri);
 360             if (!prop) {
 361                 log_debug("Property %s deleted by trigger on create (getter-setter)", name);
 362                 return;
 363             }
 364             prop->setCache(v);
 365         }
 366         return;
 367     }
 368 }
 369
 370
 371 /// Order of property lookup:
 372 //
 373 /// 1. Visible own properties.
 374 /// 2. If DisplayObject, magic properties
 375 /// 3. Visible own properties of all __proto__ objects (a DisplayObject
 376 ///    ends the chain).
 377 /// 4. __resolve property of this object and all __proto__ objects (a Display
 378 ///    Object ends the chain). This should ignore visibility but doesn't.
 379 bool
 380 as_object::get_member(const ObjectURI& uri, as_value* val)
 381 {
 382     assert(val);
 383
 384     const int version = getSWFVersion(*this);
 385
 386     PrototypeRecursor<IsVisible> pr(this, uri, IsVisible(version));
 387
 388     Property* prop = pr.getProperty();
 389     if (!prop) {
 390         if (displayObject()) {
 391             DisplayObject* d = displayObject();
 392             if (getDisplayObjectProperty(*d, uri, *val)) return true;
 393         }
 394         while (pr()) {
 395             if ((prop = pr.getProperty())) break;
 396         }
 397     }
 398
 399     // If the property isn't found or doesn't apply to any objects in the
 400     // inheritance chain, try the __resolve property.
 401     if (!prop) {
 402
 403         PrototypeRecursor<Exists> pr(this, NSV::PROP_uuRESOLVE);
 404
 405         as_value resolve;
 406
 407         for (;;) {
 408             Property* res = pr.getProperty();
 409             if (res) {
 410                 resolve = res->isGetterSetter() ? res->getCache() :
 411                                                   res->getValue(*this);
 412                 if (version < 7) break;
 413                 if (resolve.is_object()) break;
 414             }
 415             // Finished searching.
 416             if (!pr()) return false;
 417         }
 418
 419         // If __resolve exists, call it with the name of the undefined
 420         // property.
 421         string_table& st = getStringTable(*this);
 422         const std::string& undefinedName = st.value(getName(uri));
 423
 424         fn_call::Args args;
 425         args += undefinedName;
 426
 427         // Invoke the __resolve property.
 428         *val = invoke(resolve, as_environment(getVM(*this)), this, args);
 429
 430         return true;
 431     }
 432
 433     try {
 434         *val = prop->getValue(*this);
 435         return true;
 436     }
 437     catch (const ActionTypeError& exc) {
 438         IF_VERBOSE_ASCODING_ERRORS(
 439             log_aserror(_("Caught exception: %s"), exc.what());
 440             );
 441         return false;
 442     }
 443 }
 444
 445
 446 as_object*
 447 as_object::get_super(const ObjectURI& fname)
 448 {
 449     // Super references the super class of our class prototype.
 450     // Our class prototype is __proto__.
 451     // Our class superclass prototype is __proto__.__proto__
 452
 453     // Our class prototype is __proto__.
 454     as_object* proto = get_prototype();
 455
 456     if ( ! fname.empty() && getSWFVersion(*this) > 6) {
 457         as_object* owner = 0;
 458         findProperty(fname, &owner);
 459         // should be 0 if findProperty returned 0
 460         if (owner != this) proto = owner;
 461     }
 462
 463     as_object* super = new as_super(getGlobal(*this), proto);
 464
 465     return super;
 466 }
 467
 468 as_object*
 469 as_object::get_super()
 470 {
 471     // Our class prototype is __proto__.
 472     as_object* proto = get_prototype();
 473     as_object* super = new as_super(getGlobal(*this), proto);
 474
 475     return super;
 476 }
 477
 478 Property*
 479 as_object::findProperty(const ObjectURI& uri, as_object** owner)
 480 {
 481
 482     const int version = getSWFVersion(*this);
 483
 484     PrototypeRecursor<IsVisible> pr(this, uri, IsVisible(version));
 485
 486     do {
 487         Property* prop = pr.getProperty(owner);
 488         if (prop) return prop;
 489     } while (pr());
 490
 491     // No Property found
 492     return 0;
 493 }
 494
 495 Property*
 496 as_object::findUpdatableProperty(const ObjectURI& uri)
 497 {
 498
 499     PrototypeRecursor<Exists> pr(this, uri);
 500
 501     Property* prop = pr.getProperty();
 502
 503     // We won't scan the inheritance chain if we find a member,
 504     // even if invisible.
 505     if (prop) return prop;
 506
 507     const int swfVersion = getSWFVersion(*this);
 508
 509     while (pr()) {
 510         if ((prop = pr.getProperty())) {
 511             if (prop->isGetterSetter() && visible(*prop, swfVersion)) {
 512                 return prop;
 513             }
 514         }
 515     }
 516     return 0;
 517 }
 518
 519 void
 520 as_object::set_prototype(const as_value& proto)
 521 {
 522     // TODO: check what happens if __proto__ is set as a user-defined
 523     // getter/setter
 524     // TODO: check triggers !!
 525     _members.setValue(NSV::PROP_uuPROTOuu, proto, as_object::DefaultFlags);
 526 }
 527
 528 void
 529 as_object::executeTriggers(Property* prop, const ObjectURI& uri,
 530                            const as_value& val)
 531 {
 532
 533     // check if we have a trigger, if so, invoke it
 534     // and set val to its return
 535     TriggerContainer::iterator trigIter;
 536
 537     // If there are no triggers or the trigger is not found, just set
 538     // the property.
 539     if (!_trigs.get() || (trigIter = _trigs->find(uri)) == _trigs->end()) {
 540         if (prop) {
 541             prop->setValue(*this, val);
 542             prop->clearVisible(getSWFVersion(*this));
 543         }
 544         return;
 545     }
 546
 547     Trigger& trig = trigIter->second;
 548
 549     if (trig.dead()) {
 550         _trigs->erase(trigIter);
 551         return;
 552     }
 553
 554     // WARNING: getValue might itself invoke a trigger
 555     // (getter-setter)... ouch ?
 556     // TODO: in this case, return the underlying value !
 557     const as_value& curVal = prop ? prop->getCache() : as_value();
 558     const as_value& newVal = trig.call(curVal, val, *this);
 559
 560     // This is a particularly clear and concise way of removing dead triggers.
 561     EraseIf(*_trigs, boost::bind(boost::mem_fn(&Trigger::dead),
 562              boost::bind(&TriggerContainer::value_type::second, _1)));
 563
 564     // The trigger call could have deleted the property,
 565     // so we check for its existence again, and do NOT put
 566     // it back in if it was deleted
 567     prop = findUpdatableProperty(uri);
 568     if (!prop) return;
 569
 570     prop->setValue(*this, newVal);
 571     prop->clearVisible(getSWFVersion(*this));
 572
 573 }
 574
 575 /// Order of property lookup:
 576 //
 577 /// 0. MovieClip textfield variables. TODO: this is a hack and should be
 578 ///    eradicated.
 579 /// 1. Own properties even if invisible or not getter-setters.
 580 /// 2. If DisplayObject, magic properties
 581 /// 3. Visible own getter-setter properties of all __proto__ objects
 582 ///    (a DisplayObject ends the chain).
 583 bool
 584 as_object::set_member(const ObjectURI& uri, const as_value& val, bool ifFound)
 585 {
 586
 587     bool tfVarFound = false;
 588     if (displayObject()) {
 589         MovieClip* mc = dynamic_cast<MovieClip*>(displayObject());
 590         if (mc) tfVarFound = mc->setTextFieldVariables(uri, val);
 591         // We still need to set the member.
 592     }
 593
 594     // Handle the length property for arrays. NB: checkArrayLength() will
 595     // call this function again if the key is a valid index.
 596     if (array()) checkArrayLength(*this, uri, val);
 597
 598     PrototypeRecursor<Exists> pr(this, uri);
 599
 600     Property* prop = pr.getProperty();
 601
 602     // We won't scan the inheritance chain if we find a member,
 603     // even if invisible.
 604     if (!prop) {
 605
 606         if (displayObject()) {
 607             DisplayObject* d = displayObject();
 608             if (setDisplayObjectProperty(*d, uri, val)) return true;
 609             // TODO: should we execute triggers?
 610         }
 611
 612         const int version = getSWFVersion(*this);
 613         while (pr()) {
 614             if ((prop = pr.getProperty())) {
 615                 if ((prop->isGetterSetter()) && visible(*prop, version)) {
 616                     break;
 617                 }
 618                 else prop = 0;
 619             }
 620         }
 621     }
 622
 623     if (prop) {
 624         if (readOnly(*prop)) {
 625             IF_VERBOSE_ASCODING_ERRORS(
 626                 ObjectURI::Logger l(getStringTable(*this));
 627                 log_aserror(_("Attempt to set read-only property '%s'"),
 628                             l(uri));
 629                 );
 630             return true;
 631         }
 632
 633         try {
 634             executeTriggers(prop, uri, val);
 635         }
 636         catch (const ActionTypeError& exc) {
 637             IF_VERBOSE_ASCODING_ERRORS(
 638                 log_aserror(
 639                 _("%s: %s"), getStringTable(*this).value(getName(uri)), exc.what());
 640             );
 641         }
 642
 643         return true;
 644     }
 645
 646     // Else, add new property...
 647     if (ifFound) return false;
 648
 649     // Property does not exist, so it won't be read-only. Set it.
 650     if (!_members.setValue(uri, val)) {
 651
 652         IF_VERBOSE_ASCODING_ERRORS(
 653             ObjectURI::Logger l(getStringTable(*this));
 654             log_aserror(_("Unknown failure in setting property '%s' on "
 655                           "object '%p'"), l(uri), (void*) this);
 656             );
 657         return false;
 658     }
 659
 660     executeTriggers(prop, uri, val);
 661
 662     // Return true if we found a textfield variable.
 663     if (tfVarFound) return true;
 664
 665     return false;
 666 }
 667
 668
 669 void
 670 as_object::init_member(const std::string& key1, const as_value& val, int flags)
 671 {
 672     const ObjectURI& uri(getURI(vm(), key1));
 673     init_member(uri, val, flags);
 674 }
 675
 676 void
 677 as_object::init_member(const ObjectURI& uri, const as_value& val, int flags)
 678 {
 679
 680     // Set (or create) a SimpleProperty
 681     if (!_members.setValue(uri, val, flags)) {
 682         ObjectURI::Logger l(getStringTable(*this));
 683         log_error(_("Attempt to initialize read-only property '%s'"
 684                     " on object '%p' twice"), l(uri), (void*)this);
 685         // We shouldn't attempt to initialize a member twice, should we ?
 686         abort();
 687     }
 688 }
 689
 690 void
 691 as_object::init_property(const std::string& name, as_function& getter,
 692                          as_function& setter, int flags)
 693 {
 694     const ObjectURI& uri = getURI(vm(), name);
 695     init_property(uri, getter, setter, flags);
 696 }
 697
 698 void
 699 as_object::init_property(const ObjectURI& uri, as_function& getter,
 700                          as_function& setter, int flags)
 701 {
 702     _members.addGetterSetter(uri, getter, &setter, as_value(), flags);
 703 }
 704
 705 void
 706 as_object::init_property(const std::string& name, as_c_function_ptr getter,
 707                          as_c_function_ptr setter, int flags)
 708 {
 709     const ObjectURI& uri = getURI(vm(), name);
 710     init_property(uri, getter, setter, flags);
 711 }
 712
 713 void
 714 as_object::init_property(const ObjectURI& uri, as_c_function_ptr getter,
 715                          as_c_function_ptr setter, int flags)
 716 {
 717     _members.addGetterSetter(uri, getter, setter, flags);
 718 }
 719
 720 bool
 721 as_object::init_destructive_property(const ObjectURI& uri, as_function& getter,
 722                                      int flags)
 723 {
 724     return _members.addDestructiveGetter(uri, getter, flags);
 725 }
 726
 727 bool
 728 as_object::init_destructive_property(const ObjectURI& uri,
 729                                      as_c_function_ptr getter, int flags)
 730 {
 731     return _members.addDestructiveGetter(uri, getter, flags);
 732 }
 733
 734 void
 735 as_object::init_readonly_property(const std::string& name, as_function& getter,
 736                                   int initflags)
 737 {
 738     const ObjectURI& uri = getURI(vm(), name);
 739
 740     init_property(uri, getter, getter, initflags | PropFlags::readOnly);
 741     assert(_members.getProperty(uri));
 742 }
 743
 744 void
 745 as_object::init_readonly_property(const std::string& name,
 746                                   as_c_function_ptr getter, int initflags)
 747 {
 748     const ObjectURI& uri = getURI(vm(), name);
 749     init_property(uri, getter, getter, initflags | PropFlags::readOnly);
 750     assert(_members.getProperty(uri));
 751 }
 752
 753 void
 754 as_object::set_member_flags(const ObjectURI& uri, int setTrue, int setFalse)
 755 {
 756     _members.setFlags(uri, setTrue, setFalse);
 757 }
 758
 759 void
 760 as_object::addInterface(as_object* obj)
 761 {
 762     assert(obj);
 763     if (std::find(_interfaces.begin(), _interfaces.end(), obj) ==
 764         _interfaces.end()) {
 765         _interfaces.push_back(obj);
 766     }
 767 }
 768
 769 bool
 770 as_object::instanceOf(as_object* ctor)
 771 {
 772
 773     /// An object is never an instance of a null prototype.
 774     if (!ctor) return false;
 775
 776     as_value protoVal;
 777     if (!ctor->get_member(NSV::PROP_PROTOTYPE, &protoVal)) {
 778 #ifdef GNASH_DEBUG_INSTANCE_OF
 779         log_debug("Object %p can't be an instance of an object (%p) with no 'prototype'",
 780                   (void*)this, (void*)ctor);
 781 #endif
 782         return false;
 783     }
 784
 785     as_object* ctorProto = toObject(protoVal, getVM(*this));
 786     if (!ctorProto) {
 787 #ifdef GNASH_DEBUG_INSTANCE_OF
 788         log_debug("Object %p can't be an instance of an object (%p) with non-object 'prototype' (%s)",
 789                   (void*)this, (void*)ctor, protoVal);
 790 #endif
 791         return false;
 792     }
 793
 794     // TODO: cleanup the iteration, make it more readable ...
 795     std::set<as_object*> visited;
 796
 797     as_object* obj = this;
 798     while (obj && visited.insert(obj).second) {
 799         as_object* thisProto = obj->get_prototype();
 800         if (!thisProto) {
 801             break;
 802         }
 803
 804         // Check our proto
 805         if (thisProto == ctorProto) {
 806 #ifdef GNASH_DEBUG_INSTANCE_OF
 807             log_debug("Object %p is an instance of constructor %p as the constructor exposes our __proto__ %p",
 808                       (void*)obj, (void*)ctor, (void*)thisProto);
 809 #endif
 810             return true;
 811         }
 812
 813         // Check our proto interfaces
 814         if (std::find(thisProto->_interfaces.begin(),
 815                       thisProto->_interfaces.end(), ctorProto)
 816             != thisProto->_interfaces.end()) {
 817
 818 #ifdef GNASH_DEBUG_INSTANCE_OF
 819             log_debug("Object %p __proto__ %p had one interface matching with the constructor prototype %p",
 820                       (void*)obj, (void*)thisProto, (void*)ctorProto);
 821 #endif
 822             return true;
 823         }
 824
 825         obj = thisProto;
 826     }
 827
 828     return false;
 829 }
 830
 831 bool
 832 as_object::prototypeOf(as_object& instance)
 833 {
 834     as_object* obj = &instance;
 835
 836     std::set<as_object*> visited;
 837
 838     while (obj && visited.insert(obj).second ) {
 839         if (obj->get_prototype() == this) return true;
 840         obj = obj->get_prototype();
 841         }
 842
 843     // See actionscript.all/Inheritance.as for a way to trigger this
 844     IF_VERBOSE_ASCODING_ERRORS(
 845         if (obj) log_aserror(_("Circular inheritance chain detected "
 846                                "during isPrototypeOf call"));
 847         );
 848
 849     return false;
 850 }
 851
 852 void
 853 as_object::dump_members()
 854 {
 855     log_debug("%d members of object %p follow", _members.size(),
 856             static_cast<const void*>(this));
 857     _members.dump();
 858 }
 859
 860 void
 861 as_object::setPropFlags(const as_value& props_val, int set_false, int set_true)
 862 {
 863
 864     if (props_val.is_null()) {
 865         // Take all the members of the object
 866         _members.setFlagsAll(set_true, set_false);
 867         return;
 868     }
 869
 870     std::string propstr = props_val.to_string();
 871
 872     for (;;) {
 873
 874         std::string prop;
 875         size_t next_comma=propstr.find(",");
 876         if (next_comma == std::string::npos) {
 877             prop = propstr;
 878         }
 879         else {
 880             prop = propstr.substr(0,next_comma);
 881             propstr = propstr.substr(next_comma+1);
 882         }
 883
 884         // set_member_flags will take care of case conversion
 885         set_member_flags(getURI(vm(), prop), set_true, set_false);
 886
 887         if (next_comma == std::string::npos) {
 888             break;
 889         }
 890     }
 891     return;
 892 }
 893
 894
 895 void
 896 as_object::copyProperties(const as_object& o)
 897 {
 898     PropsCopier copier(*this);
 899
 900     // TODO: check if non-visible properties should be also copied !
 901     o.visitProperties<Exists>(copier);
 902 }
 903
 904 void
 905 as_object::visitKeys(KeyVisitor& visitor) const
 906 {
 907     // Hack to handle MovieClips.
 908     if (displayObject()) {
 909         displayObject()->visitNonProperties(visitor);
 910     }
 911
 912     // this set will keep track of visited objects,
 913     // to avoid infinite loops
 914     std::set<const as_object*> visited;
 915
 916     PropertyList::PropertyTracker doneList;
 917
 918     const as_object* current(this);
 919     while (current && visited.insert(current).second) {
 920         current->_members.visitKeys(visitor, doneList);
 921         current = current->get_prototype();
 922     }
 923 }
 924
 925
 926 Property*
 927 as_object::getOwnProperty(const ObjectURI& uri)
 928 {
 929     return _members.getProperty(uri);
 930 }
 931
 932 as_object*
 933 as_object::get_prototype() const
 934 {
 935     int swfVersion = getSWFVersion(*this);
 936
 937     Property* prop = _members.getProperty(NSV::PROP_uuPROTOuu);
 938     if (!prop) return 0;
 939     if (!visible(*prop, swfVersion)) return 0;
 940
 941     const as_value& proto = prop->getValue(*this);
 942
 943     return toObject(proto, getVM(*this));
 944 }
 945
 946 std::string
 947 getURLEncodedVars(as_object& o)
 948 {
 949     SortedPropertyList props = enumerateProperties(o);
 950
 951     std::string data;
 952     string_table& st = getStringTable(o);
 953
 954     for (SortedPropertyList::const_reverse_iterator i = props.rbegin(),
 955             e = props.rend(); i != e; ++i) {
 956
 957         const std::string& name = i->first.toString(st);
 958         const std::string& value = i->second.to_string();
 959
 960         // see bug #22006
 961         if (!name.empty() && name[0] == '$') continue;
 962
 963         URL::encode(value);
 964         if (i != props.rbegin()) data += '&';
 965
 966         data += name + "=" + value;
 967
 968     }
 969     return data;
 970 }
 971
 972 bool
 973 as_object::watch(const ObjectURI& uri, as_function& trig,
 974                 const as_value& cust)
 975 {
 976
 977     std::string propname = getStringTable(*this).value(getName(uri));
 978
 979     if (!_trigs.get()) _trigs.reset(new TriggerContainer);
 980
 981     TriggerContainer::iterator it = _trigs->find(uri);
 982     if (it == _trigs->end()) {
 983         return _trigs->insert(
 984             std::make_pair(uri, Trigger(propname, trig, cust))).second;
 985     }
 986     it->second = Trigger(propname, trig, cust);
 987     return true;
 988 }
 989
 990 bool
 991 as_object::unwatch(const ObjectURI& uri)
 992 {
 993     if (!_trigs.get()) return false;
 994
 995     TriggerContainer::iterator trigIter = _trigs->find(uri);
 996     if (trigIter == _trigs->end()) {
 997         log_debug("No watch for property %s",
 998                   getStringTable(*this).value(getName(uri)));
 999         return false;
1000     }
1001     Property* prop = _members.getProperty(uri);
1002     if (prop && prop->isGetterSetter()) {
1003         log_debug("Watch on %s not removed (is a getter-setter)",
1004                   getStringTable(*this).value(getName(uri)));
1005         return false;
1006     }
1007     trigIter->second.kill();
1008     return true;
1009 }
1010
1011 void
1012 as_object::markReachableResources() const
1013 {
1014     _members.setReachable();
1015
1016     if (_trigs.get()) {
1017         for (TriggerContainer::const_iterator it = _trigs->begin();
1018              it != _trigs->end(); ++it) {
1019             it->second.setReachable();
1020         }
1021     }
1022
1023     // Mark interfaces reachable.
1024     std::for_each(_interfaces.begin(), _interfaces.end(),
1025                   std::mem_fun(&as_object::setReachable));
1026
1027     // Proxy objects can contain references to other as_objects.
1028     if (_relay) _relay->setReachable();
1029     if (_displayObject) _displayObject->setReachable();
1030 }
1031
1032 void
1033 Trigger::setReachable() const
1034 {
1035         _func->setReachable();
1036         _customArg.setReachable();
1037 }
1038
1039 as_value
1040 Trigger::call(const as_value& oldval, const as_value& newval,
1041         as_object& this_obj)
1042 {
1043     assert(!_dead);
1044
1045     if (_executing) return newval;
1046
1047     _executing = true;
1048
1049     try {
1050
1051         const as_environment env(getVM(this_obj));
1052
1053         fn_call::Args args;
1054         args += _propname, oldval, newval, _customArg;
1055
1056         fn_call fn(&this_obj, env, args);
1057         as_value ret = _func->call(fn);
1058         _executing = false;
1059
1060         return ret;
1061
1062     }
1063     catch (const GnashException&) {
1064         _executing = false;
1065         throw;
1066     }
1067 }
1068
1069 SortedPropertyList
1070 enumerateProperties(as_object& obj)
1071 {
1072
1073     // this set will keep track of visited objects,
1074     // to avoid infinite loops
1075     std::set<as_object*> visited;
1076
1077     SortedPropertyList to;
1078     PropertyEnumerator e(to);
1079     as_object* current(&obj);
1080
1081     while (current && visited.insert(current).second) {
1082         current->visitProperties<IsEnumerable>(e);
1083         current = current->get_prototype();
1084     }
1085     return to;
1086
1087 }
1088
1089 as_object*
1090 getPathElement(as_object& o, const ObjectURI& uri)
1091 {
1092     as_value tmp;
1093     if (!o.get_member(uri, &tmp)) return 0;
1094     if (!tmp.is_object()) return 0;
1095     return toObject(tmp, getVM(o));
1096 }
1097
1098
1099 void
1100 sendEvent(as_object& o, const as_environment& env, const ObjectURI& name)
1101 {
1102     Property* prop = o.findProperty(name);
1103     if (prop) {
1104         fn_call::Args args;
1105         invoke(prop->getValue(o), env, &o, args);
1106     }
1107 }
1108
1109 as_object*
1110 getObjectWithPrototype(Global_as& gl, const ObjectURI& c)
1111 {
1112     as_object* ctor = toObject(getMember(gl, c), getVM(gl));
1113     as_object* proto = ctor ?
1114         toObject(getMember(*ctor, NSV::PROP_PROTOTYPE), getVM(gl)) : 0;
1115
1116     as_object* o = createObject(gl);
1117     o->set_prototype(proto ? proto : as_value());
1118     return o;
1119 }
1120
1121 /// Get the VM from an as_object
1122 VM&
1123 getVM(const as_object& o)
1124 {
1125     return o.vm();
1126 }
1127
1128 /// Get the movie_root from an as_object
1129 movie_root&
1130 getRoot(const as_object& o)
1131 {
1132     return o.vm().getRoot();
1133 }
1134
1135 /// Get the string_table from an as_object
1136 string_table&
1137 getStringTable(const as_object& o)
1138 {
1139     return o.vm().getStringTable();
1140 }
1141
1142 const RunResources&
1143 getRunResources(const as_object& o)
1144 {
1145     return o.vm().getRoot().runResources();
1146 }
1147
1148 int
1149 getSWFVersion(const as_object& o)
1150 {
1151     return o.vm().getSWFVersion();
1152 }
1153
1154 Global_as&
1155 getGlobal(const as_object& o)
1156 {
1157     return *o.vm().getGlobal();
1158 }
1159
1160 } // end of gnash namespace
1161
1162 // local Variables:
1163 // mode: C++
1164 // indent-tabs-mode: nil
1165 // End: