shell/SystemClass.h

   1 /* -*- Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*- */
   2 /* vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5) */
   3 /* ***** BEGIN LICENSE BLOCK *****
   4  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   5  *
   6  * The contents of this file are subject to the Mozilla Public License Version
   7  * 1.1 (the "License"); you may not use this file except in compliance with
   8  * the License. You may obtain a copy of the License at
   9  * http://www.mozilla.org/MPL/
  10  *
  11  * Software distributed under the License is distributed on an "AS IS" basis,
  12  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  13  * for the specific language governing rights and limitations under the
  14  * License.
  15  *
  16  * The Original Code is [Open Source Virtual Machine.].
  17  *
  18  * The Initial Developer of the Original Code is
  19  * Adobe System Incorporated.
  20  * Portions created by the Initial Developer are Copyright (C) 2004-2006
  21  * the Initial Developer. All Rights Reserved.
  22  *
  23  * Contributor(s):
  24  *   Adobe AS3 Team
  25  *
  26  * Alternatively, the contents of this file may be used under the terms of
  27  * either the GNU General Public License Version 2 or later (the "GPL"), or
  28  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  29  * in which case the provisions of the GPL or the LGPL are applicable instead
  30  * of those above. If you wish to allow use of your version of this file only
  31  * under the terms of either the GPL or the LGPL, and not to allow others to
  32  * use your version of this file under the terms of the MPL, indicate your
  33  * decision by deleting the provisions above and replace them with the notice
  34  * and other provisions required by the GPL or the LGPL. If you do not delete
  35  * the provisions above, a recipient may use your version of this file under
  36  * the terms of any one of the MPL, the GPL or the LGPL.
  37  *
  38  * ***** END LICENSE BLOCK ***** */
  39
  40 #ifndef __avmshell_SystemClass__
  41 #define __avmshell_SystemClass__
  42
  43
  44 namespace avmshell
  45 {
  46     class AbstractBaseClass : public avmplus::ClassClosure
  47     {
  48     public:
  49         AbstractBaseClass(VTable* cvtable) : ClassClosure(cvtable) {}
  50
  51         DECLARE_SLOTS_AbstractBaseClass;
  52     };
  53
  54     class AbstractBaseObject : public avmplus::ScriptObject
  55     {
  56     public:
  57         AbstractBaseObject(VTable* vtable, ScriptObject* prototype) : ScriptObject(vtable, prototype) {}
  58
  59         DECLARE_SLOTS_AbstractBaseObject;
  60     };
  61
  62     class NativeSubclassOfAbstractBaseClass : public avmplus::ClassClosure
  63     {
  64     public:
  65         NativeSubclassOfAbstractBaseClass(VTable* cvtable) : ClassClosure(cvtable) {}
  66
  67         DECLARE_SLOTS_NativeSubclassOfAbstractBaseClass;
  68     };
  69
  70     class NativeSubclassOfAbstractBaseObject : public AbstractBaseObject
  71     {
  72     public:
  73         NativeSubclassOfAbstractBaseObject(VTable* vtable, ScriptObject* prototype) : AbstractBaseObject(vtable, prototype) {}
  74
  75         DECLARE_SLOTS_NativeSubclassOfAbstractBaseObject;
  76     };
  77
  78     class RestrictedBaseClass : public avmplus::ClassClosure
  79     {
  80     public:
  81         RestrictedBaseClass(VTable* cvtable) : ClassClosure(cvtable) {}
  82
  83         DECLARE_SLOTS_RestrictedBaseClass;
  84     };
  85
  86     class RestrictedBaseObject : public avmplus::ScriptObject
  87     {
  88     public:
  89         RestrictedBaseObject(VTable* vtable, ScriptObject* prototype) : ScriptObject(vtable, prototype) {}
  90
  91         DECLARE_SLOTS_RestrictedBaseObject;
  92     };
  93
  94     class NativeSubclassOfRestrictedBaseClass : public avmplus::ClassClosure
  95     {
  96     public:
  97         NativeSubclassOfRestrictedBaseClass(VTable* cvtable) : ClassClosure(cvtable) {}
  98
  99         DECLARE_SLOTS_NativeSubclassOfRestrictedBaseClass;
 100     };
 101
 102     class NativeSubclassOfRestrictedBaseObject : public RestrictedBaseObject
 103     {
 104     public:
 105         NativeSubclassOfRestrictedBaseObject(VTable* vtable, ScriptObject* prototype) : RestrictedBaseObject(vtable, prototype) {}
 106
 107         DECLARE_SLOTS_NativeSubclassOfRestrictedBaseObject;
 108     };
 109
 110     class AbstractRestrictedBaseClass : public avmplus::ClassClosure
 111     {
 112     public:
 113         AbstractRestrictedBaseClass(VTable* cvtable) : ClassClosure(cvtable) {}
 114
 115         DECLARE_SLOTS_AbstractRestrictedBaseClass;
 116     };
 117
 118     class AbstractRestrictedBaseObject : public avmplus::ScriptObject
 119     {
 120     public:
 121         AbstractRestrictedBaseObject(VTable* vtable, ScriptObject* prototype) : ScriptObject(vtable, prototype) {}
 122
 123         DECLARE_SLOTS_AbstractRestrictedBaseObject;
 124     };
 125
 126     class NativeSubclassOfAbstractRestrictedBaseClass : public avmplus::ClassClosure
 127     {
 128     public:
 129         NativeSubclassOfAbstractRestrictedBaseClass(VTable* cvtable) : ClassClosure(cvtable) {}
 130
 131         DECLARE_SLOTS_NativeSubclassOfAbstractRestrictedBaseClass;
 132     };
 133
 134     class NativeSubclassOfAbstractRestrictedBaseObject : public AbstractRestrictedBaseObject
 135     {
 136     public:
 137         NativeSubclassOfAbstractRestrictedBaseObject(VTable* vtable, ScriptObject* prototype) : AbstractRestrictedBaseObject(vtable, prototype) {}
 138
 139         DECLARE_SLOTS_NativeSubclassOfAbstractRestrictedBaseObject;
 140     };
 141
 142     // this class exists solely to test native classes that use MI.
 143     class MIClass : public avmplus::ClassClosure
 144     {
 145     public:
 146         MIClass(VTable* cvtable) : ClassClosure(cvtable) {}
 147         ~MIClass() {}
 148
 149         DECLARE_SLOTS_MIClass;
 150     };
 151
 152     // this class exists solely to test native classes that use MI.
 153     class MixinClassThatDoesNotDescendFromScriptObject
 154     {
 155     public:
 156         const double factor;
 157         MixinClassThatDoesNotDescendFromScriptObject(double f) : factor(f) {}
 158         // evil, wrong version that we DO NOT WANT
 159         double plus(double v) { return v * factor; }
 160     };
 161
 162     // this class exists solely to test native classes that use MI.
 163     class MIObjectImpl : public avmplus::ScriptObject
 164     {
 165     public:
 166         const double amount;
 167         MIObjectImpl(VTable* vtable, ScriptObject* prototype, double a) : ScriptObject(vtable, prototype), amount(a) {}
 168         double plus(double v) { return v + amount; }
 169     };
 170
 171     class CheckBaseClass : public avmplus::ClassClosure
 172     {
 173     public:
 174         CheckBaseClass(VTable* cvtable) : ClassClosure(cvtable) {}
 175
 176         DECLARE_SLOTS_CheckBaseClass;
 177     };
 178
 179     class CheckBaseObject : public avmplus::ScriptObject
 180     {
 181     public:
 182         CheckBaseObject(VTable* vtable, ScriptObject* prototype) : ScriptObject(vtable, prototype) {}
 183
 184         DECLARE_SLOTS_CheckBaseObject;
 185     };
 186
 187     // this class exists solely to test native classes that use MI.
 188     class MIObject : public MIObjectImpl, public MixinClassThatDoesNotDescendFromScriptObject
 189     {
 190     public:
 191         MIObject(VTable* vtable, ScriptObject* prototype) : MIObjectImpl(vtable, prototype, 1), MixinClassThatDoesNotDescendFromScriptObject(2) {}
 192         ~MIObject() {}
 193
 194         DECLARE_SLOTS_MIObject;
 195     };
 196
 197     /**
 198      * A simple class that has some native methods.
 199      * Included as an example for writers of native methods,
 200      * and also to provide some useful QA instrumentation.
 201      */
 202     class GC_AS3_EXACT(SystemClass, avmplus::ClassClosure)
 203     {
 204         uint64_t initialTime;
 205
 206         SystemClass(VTable* cvtable);
 207     public:
 208         REALLY_INLINE static SystemClass* create(MMgc::GC* gc, VTable* cvtable)
 209         {
 210             return new (gc, MMgc::kExact, cvtable->getExtraSize()) SystemClass(cvtable);
 211         }
 212
 213         ~SystemClass();
 214
 215         // set by shell
 216         static int user_argc;
 217         static char **user_argv;
 218
 219         /**
 220          * Implementation of System.exit
 221          * AS usage: System.exit(status);
 222          * Exits the VM with OS exit code specified by  status.
 223          */
 224         void exit(int status);
 225
 226         /**
 227          * Implementation of System.getAvmplusVersion
 228          * AS usage: System.getAvmplusVersion();
 229          * Returns the current version of AVM+ in the form
 230          * "1.0 d100"
 231          */
 232         Stringp getAvmplusVersion();
 233
 234         /**
 235          * Implementation of System.getFeatures
 236          * AS usage: System.getFeatures();
 237          * Returns the compiled in features of AVM+
 238          */
 239         Stringp getFeatures();
 240
 241         /**
 242          * Implementation of System.getRunmode
 243          * AS usage: System.getRunmode();
 244          * Returns the current runmode
 245          */
 246         Stringp getRunmode();
 247
 248         /**
 249          * Implementation of System.exec
 250          * AS usage: exitCode = System.exec("command");
 251          * Executes the specified command line and returns
 252          * the status code
 253          */
 254         int exec(Stringp command);
 255
 256         void trace(ArrayObject* a);
 257         void write(Stringp s);
 258
 259
 260         /**
 261          * @name Debugging Extensions
 262          */
 263         /*@{*/
 264         void debugger();
 265         bool isDebugger();
 266         /*@}*/
 267
 268                 /**
 269          * @name ActionScript Extensions
 270          * ActionScript extensions to ECMAScript
 271          */
 272         /*@{*/
 273         unsigned getTimer();
 274         /*@}*/
 275
 276         ArrayObject * getArgv();
 277
 278         Stringp readLine();
 279
 280         double get_totalMemory();
 281         double get_freeMemory();
 282         double get_privateMemory();
 283
 284         int32_t get_swfVersion();
 285         int32_t get_apiVersion();
 286
 287         // Initiate a garbage collection; future versions will not return before completed.
 288         void forceFullCollection();
 289
 290         // Queue a garbage collection request.
 291         void queueCollection();
 292
 293         // function exists solely to test native-methods with custom namespaces
 294         void ns_example_nstest() { }
 295
 296         // function exists solely to test ScriptObject::isGlobalObject
 297         bool isGlobal(Atom o);
 298
 299         void disposeXML(XMLObject *xmlObject);
 300
 301         GC_NO_DATA(SystemClass)
 302
 303         DECLARE_SLOTS_SystemClass;
 304     };
 305 }
 306
 307 #endif /* __avmshell_SystemClass__ */