core/avmplusDebuggerStubs.cpp

   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) 1993-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
  41 #include "avmplus.h"
  42
  43 #ifdef DEBUGGER
  44
  45 namespace avmplus
  46 {
  47     using namespace MMgc;
  48
  49     Debugger::Debugger(AvmCore *core, TraceLevel tracelevel)
  50         : astrace_console(tracelevel)
  51         , astrace_callback(TRACE_OFF)
  52         , in_trace(false)
  53         , astraceStartTime(VMPI_getTime())
  54         , core(core)
  55         , abcList(core->GetGC(), kListInitialCapacity)
  56         , pool2abcIndex()
  57     {
  58     }
  59
  60     Debugger::~Debugger()
  61     {
  62     }
  63
  64     void Debugger::stepInto()
  65     {
  66     }
  67
  68     void Debugger::stepOver()
  69     {
  70     }
  71
  72     void Debugger::stepOut()
  73     {
  74     }
  75
  76     void Debugger::stepContinue()
  77     {
  78     }
  79
  80     bool Debugger::breakpointSet(SourceInfo* source, int linenum)
  81     {
  82         return false;
  83     }
  84
  85     bool Debugger::breakpointClear(SourceInfo* source, int linenum)
  86     {
  87         return false;
  88     }
  89
  90     void Debugger::debugLine(int linenum)
  91     {
  92     }
  93
  94     void Debugger::debugFile(Stringp filename)
  95     {
  96     }
  97
  98     void Debugger::debugMethod(MethodEnv* /*env*/)
  99     {
 100     }
 101
 102     void Debugger::_debugMethod(MethodEnv* env)
 103     {
 104     }
 105
 106     void Debugger::disableAllTracing()
 107     {
 108     }
 109
 110     void Debugger::traceMethod(MethodInfo* fnc, bool ignoreArgs)
 111     {
 112     }
 113
 114     void Debugger::traceLine(int line)
 115     {
 116     }
 117
 118     void Debugger::processAbc(PoolObject* pool, ScriptBuffer code)
 119     {
 120     }
 121
 122     int Debugger::frameCount()
 123     {
 124         return 0;
 125     }
 126
 127     DebugFrame* Debugger::frameAt(int frameNbr)
 128     {
 129         return NULL;
 130     }
 131
 132     int Debugger::abcCount() const
 133     {
 134         return 0;
 135     }
 136
 137     AbcInfo* Debugger::abcAt(int index) const
 138     {
 139         return NULL;
 140     }
 141
 142     AbcFile::AbcFile(AvmCore* core, int size)
 143         : core(core),
 144           source(core->GetGC(), kListInitialCapacity),
 145           byteCount(size)
 146     {
 147         sourcemap = HeapHashtable::create(core->GetGC());
 148     }
 149
 150     int AbcFile::sourceCount() const
 151     {
 152         return 0;
 153     }
 154
 155     SourceInfo* AbcFile::sourceAt(int index) const
 156     {
 157         return NULL;
 158     }
 159
 160     int AbcFile::size() const
 161     {
 162         return 0;
 163     }
 164
 165     SourceFile* AbcFile::sourceNamed(Stringp name)
 166     {
 167         return NULL;
 168     }
 169
 170     void AbcFile::sourceAdd(SourceFile* s)
 171     {
 172     }
 173
 174     SourceFile::SourceFile(MMgc::GC* gc, Stringp name)
 175         : named(name)
 176         , functions(gc, kListInitialCapacity)
 177     {
 178     }
 179
 180     Stringp SourceFile::name() const
 181     {
 182         return NULL;
 183     }
 184
 185     void SourceFile::addLine(int linenum, MethodInfo* func, int offset)
 186     {
 187     }
 188
 189     int SourceFile::functionCount() const
 190     {
 191         return 0;
 192     }
 193
 194     MethodInfo* SourceFile::functionAt(int index) const
 195     {
 196         return NULL;
 197     }
 198
 199     bool SourceFile::setBreakpoint(int linenum)
 200     {
 201         return false;
 202     }
 203
 204     bool SourceFile::clearBreakpoint(int linenum)
 205     {
 206         return false;
 207     }
 208
 209     bool SourceFile::hasBreakpoint(int linenum)
 210     {
 211         return false;
 212     }
 213
 214     bool DebugFrame::methodName(Stringp&)
 215     {
 216         return false;
 217     }
 218
 219     bool DebugFrame::argumentName(int, Stringp&)
 220     {
 221         return false;
 222     }
 223
 224     DebugStackFrame::DebugStackFrame(int nbr, CallStackNode* tr, Debugger* debug) : trace(NULL)
 225     {
 226     }
 227
 228     bool DebugStackFrame::sourceLocation(SourceInfo*& source, int& linenum)
 229     {
 230         return false;
 231     }
 232
 233     bool DebugStackFrame::dhis(Atom& a)
 234     {
 235         return false;
 236     }
 237
 238     bool DebugStackFrame::methodName(Stringp& result) {
 239         return false;
 240     }
 241
 242     bool DebugStackFrame::argumentName(int which, Stringp& result) {
 243         return false;
 244     }
 245
 246     bool DebugStackFrame::arguments(Atom*& ar, int& count)
 247     {
 248         return false;
 249     }
 250
 251     bool DebugStackFrame::setArgument(int which, Atom& val)
 252     {
 253         return false;
 254     }
 255
 256     bool DebugStackFrame::locals(Atom*& ar, int& count)
 257     {
 258         return false;
 259     }
 260
 261     bool DebugStackFrame::setLocal(int which, Atom& val)
 262     {
 263        return false;
 264     }
 265 }
 266
 267 #endif /* DEBUGGER */