shell/ShellCore.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_core__
  41 #define __avmshell_core__
  42
  43 using namespace avmplus;
  44
  45 namespace avmshell
  46 {
  47     /**
  48      * Settings for ShellCore.  The command line parser uses this, but the initial state
  49      * is set in ShellCore.cpp, and it's propagated throughout various parts of the
  50      * system.  Partly duplicates the functionality in AvmCore::config, and some settings
  51      * are copied from ShellCoreSettings into that structure when a new core is created.
  52      *
  53      * We try to avoid conditional compilation here, as there's only ever one of these
  54      * structures floating around and the savings would be minuscule.
  55      *
  56      * FIXME: the naming of many fields could be much better, and they should be documented.
  57      */
  58     class ShellCoreSettings
  59     {
  60     public:
  61         ShellCoreSettings();
  62
  63         char** arguments;               // non-terminated array of argument values, never NULL
  64         int numargs;                    // number of entries in 'arguments'
  65         bool nodebugger;
  66         int  astrace_console;
  67         uint32_t do_verbose;            // copy to config
  68         bool enter_debugger_on_launch;
  69         bool interrupts;                // copy to config
  70         bool verifyall;                 // copy to config
  71         bool verifyonly;                // copy to config
  72         bool greedy;                    // copy to each GC
  73         bool nogc;                      // copy to each GC
  74         bool incremental;               // copy to each GC
  75         bool exactgc;                   // copy to each GC
  76         int32_t markstackAllowance;     // copy to each GC;
  77         bool fixedcheck;                // copy to each GC
  78         int gcthreshold;                // copy to each GC
  79         int langID;                     // copy to ShellCore?
  80         bool jitordie;                  // copy to config
  81         bool do_testSWFHasAS3;
  82         Runmode runmode;                // copy to config
  83 #ifdef VMCFG_NANOJIT
  84         nanojit::Config njconfig;       // copy to config
  85 #endif
  86         AvmCore::CacheSizes cacheSizes; // Default to unlimited
  87         const char* st_component;
  88         const char* st_category;
  89         const char* st_name;
  90         ApiVersionSeries apiVersionSeries;
  91         ApiVersion apiVersion;
  92         BugCompatibility::Version swfVersion;
  93
  94         MMgc::GC::GCMode gcMode()
  95         {
  96             if (nogc)               return MMgc::GC::kDisableGC;
  97             else if (greedy)        return MMgc::GC::kGreedyGC;
  98             else if (incremental)   return MMgc::GC::kIncrementalGC;
  99             else                    return MMgc::GC::kNonincrementalGC;
 100         }
 101     };
 102
 103     class ShellCodeContext : public CodeContext
 104     {
 105     public:
 106         inline ShellCodeContext(DomainEnv* env, const BugCompatibility* bugCompatibility)
 107             : CodeContext(env, bugCompatibility) { }
 108     };
 109
 110     /**
 111      * ShellCore provides typical housekeeping tasks around an AvmCore, lightweight
 112      * embedders may prefer to use this rather than to subclass AvmCore themselves
 113      * and do all the housekeeping that results.  The shell uses this; see the
 114      * shell code for typical usage patterns.
 115      */
 116     class ShellCore : public AvmCore
 117     {
 118     friend class SystemClass;
 119         friend class avmplus::DomainObject;
 120     public:
 121         /**
 122          * Create a new core with the given GC (one gc per core).
 123          *
 124          * Requires: MMGC_ENTER and MMGC_GCENTER(gc) on the stack.
 125          */
 126         ShellCore(MMgc::GC *gc, ApiVersionSeries apiVersionSeries);
 127
 128         /**
 129          * Initialize the new core from the settings.  This creates a top-level
 130          * environment and performs other housekeeping.
 131          *
 132          * Requires: MMGC_ENTER and MMGC_GCENTER(gc) on the stack.
 133          */
 134         bool setup(const ShellCoreSettings& settings);
 135
 136         /**
 137          * Load the contents from the file and run them in the context of this core's
 138          * top level.  The file may contain ABC bytecode, a SWF containing a single DoABC
 139          * tag, or (if the run-time compiler is present) ActionScript source code.
 140          *
 141          * Requires: MMGC_ENTER and MMGC_GCENTER(gc) on the stack.
 142          */
 143         int evaluateFile(ShellCoreSettings& settings, const char* filename);
 144
 145 #ifdef VMCFG_EVAL
 146         /**
 147          * Load ActionScript source code from the string and run it in the
 148          * context of this core's top level.  Note the string must have been
 149          * created in the context of the GC in this ShellCore instance.
 150          *
 151          * Requires: MMGC_ENTER and MMGC_GCENTER(gc) on the stack.
 152          */
 153         void evaluateString(String* input, bool record_time=false);
 154 #endif
 155
 156 #ifdef AVMSHELL_PROJECTOR_SUPPORT
 157         int executeProjector(char *executablePath);
 158 #endif
 159
 160 #ifdef VMCFG_SELFTEST
 161         void executeSelftest(ShellCoreSettings& settings);
 162 #endif
 163
 164         PoolObject* getShellPool() { return shellPool; }
 165
 166         SystemClass* getSystemClass() { return systemClass; }
 167
 168 #ifdef AVMSHELL_PROJECTOR_SUPPORT
 169         static bool isValidProjectorFile(const char* filename);
 170 #endif
 171
 172         /*virtual*/ inline ApiVersion getDefaultAPI() { return this->defaultAPIVersion; }
 173
 174         inline BugCompatibility::Version getDefaultBugCompatibilityVersion() const { return defaultBugCompatibilityVersion; }
 175
 176     protected:
 177         virtual void setStackLimit() = 0;
 178
 179         virtual Toplevel* createToplevel(AbcEnv* abcEnv);
 180 #ifdef DEBUGGER
 181         virtual avmplus::Debugger* createDebugger(int tracelevel)
 182         {
 183             AvmAssert(allowDebugger >= 0);
 184             return allowDebugger ? DebugCLI::create(GetGC(), this, (avmplus::Debugger::TraceLevel)tracelevel) : NULL;
 185         }
 186
 187 #endif
 188 #ifdef VMCFG_EVAL
 189         virtual String* readFileForEval(String* referencing_filename, String* filename);
 190 #endif
 191
 192     private:
 193         static void interruptTimerCallback(void* data);
 194
 195         ShellToplevel* createShellToplevel();
 196
 197         void interrupt(Toplevel*, InterruptReason);
 198         void stackOverflow(Toplevel *toplevel);
 199         void setEnv(Toplevel *toplevel, int argc, char *argv[]);
 200         void initShellPool();
 201         int handleArbitraryExecutableContent(ShellCoreSettings& settings, ScriptBuffer& code, const char * filename);
 202 #ifdef VMCFG_EVAL
 203         String* decodeBytesAsUTF16String(uint8_t* bytes, uint32_t nbytes, bool terminate=false);
 204 #endif // VMCFG_EVAL
 205 #ifdef DEBUGGER
 206         DebugCLI* debugCLI() { return (DebugCLI*)debugger(); }
 207 #endif
 208
 209 #ifdef AVMPLUS_VERBOSE
 210         virtual const char* identifyDomain(Domain* domain);
 211 #endif
 212         SystemClass* systemClass;
 213         PoolObject* shellPool;
 214         OutputStream *consoleOutputStream;
 215         bool gracePeriod;
 216         bool inStackOverflow;
 217         int allowDebugger;
 218         ShellToplevel* shell_toplevel;
 219         DomainEnv* shell_domainEnv;
 220         Domain* shell_domain;
 221         // Note that this has been renamed to emphasize the fact that it is
 222         // the CodeContext/DomainEnv that user code will run in (as opposed
 223         // to the Shell's builtin classes, eg System, File, Domain).
 224         ShellCodeContext* user_codeContext;
 225         ApiVersion defaultAPIVersion;
 226         BugCompatibility::Version defaultBugCompatibilityVersion;
 227     };
 228
 229     class GC_CPP_EXACT(ShellToplevel, avmplus::Toplevel)
 230     {
 231         friend class ShellCore;
 232
 233     private:
 234         ShellToplevel(AbcEnv* abcEnv);
 235
 236     public:
 237         REALLY_INLINE static ShellToplevel* create(MMgc::GC* gc, AbcEnv* abcEnv)
 238         {
 239             return new (gc, MMgc::kExact) ShellToplevel(abcEnv);
 240         }
 241
 242         ShellCore* core() const {
 243             return (ShellCore*)Toplevel::core();
 244         }
 245
 246     private:
 247         GC_DATA_BEGIN(ShellToplevel)
 248
 249         DWB(shell_toplevelClassManifest*)           GC_POINTER(shellClasses);
 250
 251         GC_DATA_END(ShellToplevel)
 252     };
 253 }
 254
 255 #endif /* __avmshell_core__ */