libcore/ClassHierarchy.cpp

   1 //
   2 //   Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
   3 //
   4 // This program is free software; you can redistribute it and/or modify
   5 // it under the terms of the GNU General Public License as published by
   6 // the Free Software Foundation; either version 3 of the License, or
   7 // (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU General Public License
  15 // along with this program; if not, write to the Free Software
  16 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  17 //
  18
  19 #include "ClassHierarchy.h"
  20
  21 #include <boost/bind.hpp>
  22
  23 #include "as_object.h"
  24 #include "PropFlags.h"
  25 #include "as_value.h"
  26 #include "namedStrings.h"
  27 #include "as_function.h"
  28 #include "Global_as.h"
  29 #include "extension.h"
  30
  31 namespace gnash {
  32
  33 // anonymous namespace
  34 namespace {
  35
  36 void
  37 addVisibilityFlag(int& flags, int version)
  38 {
  39     // TODO: more visibility for swf10+?
  40     switch (version)
  41     {
  42         default:
  43             return;
  44         case 9:
  45             flags |= PropFlags::onlySWF9Up;
  46             break;
  47         case 8:
  48             flags |= PropFlags::onlySWF8Up;
  49             break;
  50         case 7:
  51             flags |= PropFlags::onlySWF7Up;
  52             break;
  53         case 6:
  54             flags |= PropFlags::onlySWF6Up;
  55             break;
  56     }
  57 }
  58
  59 class declare_extension_function : public as_function
  60 {
  61 private:
  62     ClassHierarchy::ExtensionClass _decl;
  63     as_object *mTarget;
  64     Extension *mExtension;
  65
  66 public:
  67     bool isBuiltin() { return true; }
  68
  69     declare_extension_function(ClassHierarchy::ExtensionClass &c, as_object *g,
  70             Extension* e)
  71         :
  72         as_function(getGlobal(*g)),
  73         _decl(c),
  74         mTarget(g),
  75         mExtension(e)
  76     {
  77     }
  78
  79     virtual as_value call(const fn_call& fn)
  80     {
  81         string_table& st = getStringTable(fn);
  82         log_debug("Loading extension class %s", st.value(getName(_decl.uri)));
  83
  84         if (mExtension->initModuleWithFunc(_decl.file_name,
  85             _decl.init_name, *mTarget))
  86         {
  87             // Successfully loaded it, now find it, set its proto, and return.
  88             as_value us;
  89             mTarget->get_member(_decl.uri, &us);
  90             return us;
  91         }
  92         // Error here -- not successful in loading.
  93         log_error("Could not load class %s", st.value(getName(_decl.uri)));
  94         return as_value();
  95     }
  96 };
  97
  98 class declare_native_function : public as_function
  99 {
 100
 101 public:
 102
 103     bool isBuiltin() { return true; }
 104
 105     declare_native_function(const ClassHierarchy::NativeClass &c, as_object *g)
 106         :
 107         as_function(getGlobal(*g)),
 108         _decl(c),
 109         mTarget(g)
 110     {
 111     }
 112
 113     virtual as_value call(const fn_call& fn)
 114     {
 115         string_table& st = getStringTable(fn);
 116         log_debug("Loading native class %s", st.value(getName(_decl.uri)));
 117
 118         _decl.initializer(*mTarget, _decl.uri);
 119         // Successfully loaded it, now find it, set its proto, and return.
 120         as_value us;
 121         if (mTarget->get_member(_decl.uri, &us)) {
 122             if (!toObject(us, getVM(fn))) {
 123                 log_error("Native class %s is not an object after "
 124                         "initialization (%s)",
 125                         st.value(getName(_decl.uri)), us);
 126             }
 127         }
 128         else
 129         {
 130             log_error("Native class %s is not found after initialization",
 131                 st.value(getName(_decl.uri)));
 132         }
 133         return us;
 134     }
 135
 136 private:
 137
 138     ClassHierarchy::NativeClass _decl;
 139     as_object *mTarget;
 140
 141 };
 142
 143 } // end anonymous namespace
 144
 145 ClassHierarchy::~ClassHierarchy()
 146 {
 147 }
 148
 149 bool
 150 ClassHierarchy::declareClass(ExtensionClass& c)
 151 {
 152     if (!mExtension) return false;
 153
 154     as_function* getter(new declare_extension_function(c, mGlobal, mExtension));
 155
 156     int flags = PropFlags::dontEnum;
 157     addVisibilityFlag(flags, c.version);
 158     return mGlobal->init_destructive_property(c.uri, *getter, flags);
 159 }
 160
 161 bool
 162 ClassHierarchy::declareClass(const NativeClass& c)
 163 {
 164     as_function* getter = new declare_native_function(c, mGlobal);
 165
 166     int flags = PropFlags::dontEnum;
 167     addVisibilityFlag(flags, c.version);
 168     return mGlobal->init_destructive_property(c.uri, *getter, flags);
 169 }
 170
 171
 172 void
 173 ClassHierarchy::declareAll(const NativeClasses& classes)
 174 {
 175     // This is necessary to resolve the overload...
 176     bool(ClassHierarchy::*nf)(const NativeClass& f) =
 177         &ClassHierarchy::declareClass;
 178
 179     std::for_each(classes.begin(), classes.end(), boost::bind(nf, this, _1));
 180 }
 181
 182 } // end of namespace gnash
 183
 184 // local Variables:
 185 // mode: C++
 186 // indent-tabs-mode: t
 187 // End: