plugins/net.mograsim.plugin.core/src/net/mograsim/plugin/launch/MachineStackFrame.java

   1 package net.mograsim.plugin.launch;
   2
   3 import org.eclipse.core.runtime.PlatformObject;
   4 import org.eclipse.debug.core.DebugException;
   5 import org.eclipse.debug.core.ILaunch;
   6 import org.eclipse.debug.core.model.IDebugTarget;
   7 import org.eclipse.debug.core.model.IRegisterGroup;
   8 import org.eclipse.debug.core.model.IStackFrame;
   9 import org.eclipse.debug.core.model.IThread;
  10 import org.eclipse.debug.core.model.IVariable;
  11
  12 import net.mograsim.machine.Machine;
  13 import net.mograsim.plugin.MograsimActivator;
  14
  15 public class MachineStackFrame extends PlatformObject implements IStackFrame
  16 {
  17         private final MachineThread thread;
  18         private final MachineRegisterGroup registerGroup;
  19
  20         public MachineStackFrame(MachineThread thread)
  21         {
  22                 this.thread = thread;
  23                 this.registerGroup = new MachineRegisterGroup(this);
  24         }
  25
  26         @Override
  27         public String getModelIdentifier()
  28         {
  29                 return MograsimActivator.PLUGIN_ID;
  30         }
  31
  32         public Machine getMachine()
  33         {
  34                 return thread.getMachine();
  35         }
  36
  37         @Override
  38         public IDebugTarget getDebugTarget()
  39         {
  40                 return thread.getDebugTarget();
  41         }
  42
  43         @Override
  44         public ILaunch getLaunch()
  45         {
  46                 return thread.getLaunch();
  47         }
  48
  49         @Override
  50         public boolean canStepInto()
  51         {
  52                 return thread.canStepInto();
  53         }
  54
  55         @Override
  56         public boolean canStepOver()
  57         {
  58                 return thread.canStepOver();
  59         }
  60
  61         @Override
  62         public boolean canStepReturn()
  63         {
  64                 return thread.canStepReturn();
  65         }
  66
  67         @Override
  68         public boolean isStepping()
  69         {
  70                 return thread.isStepping();
  71         }
  72
  73         @Override
  74         public void stepInto() throws DebugException
  75         {
  76                 thread.stepInto();
  77         }
  78
  79         @Override
  80         public void stepOver() throws DebugException
  81         {
  82                 thread.stepOver();
  83         }
  84
  85         @Override
  86         public void stepReturn() throws DebugException
  87         {
  88                 thread.stepReturn();
  89         }
  90
  91         @Override
  92         public boolean canResume()
  93         {
  94                 return thread.canResume();
  95         }
  96
  97         @Override
  98         public boolean canSuspend()
  99         {
 100                 return thread.canSuspend();
 101         }
 102
 103         @Override
 104         public boolean isSuspended()
 105         {
 106                 return thread.isSuspended();
 107         }
 108
 109         @Override
 110         public void resume() throws DebugException
 111         {
 112                 thread.resume();
 113         }
 114
 115         @Override
 116         public void suspend() throws DebugException
 117         {
 118                 thread.suspend();
 119         }
 120
 121         @Override
 122         public boolean canTerminate()
 123         {
 124                 return thread.canTerminate();
 125         }
 126
 127         @Override
 128         public boolean isTerminated()
 129         {
 130                 return thread.isTerminated();
 131         }
 132
 133         @Override
 134         public void terminate() throws DebugException
 135         {
 136                 thread.terminate();
 137         }
 138
 139         @Override
 140         public IThread getThread()
 141         {
 142                 return thread;
 143         }
 144
 145         @Override
 146         public IVariable[] getVariables() throws DebugException
 147         {
 148                 return new IVariable[0];
 149         }
 150
 151         @Override
 152         public boolean hasVariables() throws DebugException
 153         {
 154                 return false;
 155         }
 156
 157         @Override
 158         public int getLineNumber() throws DebugException
 159         {
 160                 // TODO could we transmit the active microinstruction address using this?
 161                 return -1;
 162         }
 163
 164         @Override
 165         public int getCharStart() throws DebugException
 166         {
 167                 return -1;
 168         }
 169
 170         @Override
 171         public int getCharEnd() throws DebugException
 172         {
 173                 return -1;
 174         }
 175
 176         @Override
 177         public String getName() throws DebugException
 178         {
 179                 return "pseudo stack frame";
 180         }
 181
 182         @Override
 183         public IRegisterGroup[] getRegisterGroups() throws DebugException
 184         {
 185                 return new IRegisterGroup[] { registerGroup };
 186         }
 187
 188         @Override
 189         public boolean hasRegisterGroups() throws DebugException
 190         {
 191                 return true;
 192         }
 193 }