Initialisierung in Funktionsaufruf:
BP = sp-numargs // zeigt auf Stackelement vor dem 1. Argument, bei Methoden ist das das Objekt (this)
FP = sp // zeigt auf Stackelement vor der 1. lokalen Variablen
// Anlegen der lokalen Variablen erfolgt durch OP_TSPACE am Anfang von pcode
pcode zeigt auf bytecode


   OP_NOP = 0x00, ///< no operation
   tut nichts - irgendwo verwendet??
   
   
  (NW) OP_BRT = 0x01, ///< branch on true 
     Wenn (long)*sp != 0
	    pc = (native int) [pcode+pc]
     sonst 
	    pc += sizeof(native int)
  (NW) OP_BRF = 0x02, ///< branch on false 
     Wenn (long)*sp == 0
	    pc = (native int) [pcode+pc]
     sonst 
	    pc += sizeof(native int)
   (NW) OP_BR = 0x03, ///< branch unconditionally 
	    pc = (native int) [pcode+pc]    
   OP_NIL = 0x04, ///< load top of stack with nil 
         (*_sp).dispose();
   OP_PUSH = 0x05, ///< push nil onto stack 
      ++_sp;
   OP_NOT = 0x06, ///< logical negate top of stack 
       Wenn (*long) *sp == 0
	      *sp = 1
	   sonst
	      *sp = 0
   OP_NEG = 0x07, ///< arithmetic negate top of stack
      switch (type(*sp))
	     Zahl(int, float, double): *sp = -(*sp)
		 Objekt(ref) : rufe OP_NEG auf Objekt auf
		 sonst: Typfehler
   OP_ADD = 0x08, ///< add top two stack entries 
       -> doOp_ADD
   OP_SUB = 0x09, ///< subtract top two stack entries 
       -> doOpSUB
   OP_MUL = 0x0A, ///< multiply top two stack entries 
       -> doOp_MUL
   OP_DIV = 0x0B, ///< divide top two stack entries 
       -> doOp_DIV
   OP_REM = 0x0C, ///< remainder of top two stack entries 
       -> doOp_REM
   OP_BAND = 0x0D, ///< bitwise and of top two stack entries 
       -> doOp_BAND
   OP_BOR = 0x0E, ///< bitwise or of top two stack entries 
      -> doOp_BOR
   OP_XOR = 0x0F, ///< bitwise xor of top two stack entries 
      -> doOp_XOR
   OP_BNOT = 0x10, ///< bitwise not of top two stack entries 
      -> doOp_BNOT
   OP_SHL = 0x11, ///< shift left top two stack entries 
      -> doOp_SHL
   OP_SHR = 0x12, ///< shift right top two stack entries 
      -> doOp_SHR
   OP_LT = 0x13, ///< less than 
      -> doCompare
	  wenn *sp < 0
	     *sp = 1
	  sonst *sp = 0
   OP_LE = 0x14, ///< less than or equal to 
      -> doCompare
	  wenn *sp <= 0
	     *sp = 1
	  sonst *sp = 0
   OP_EQ = 0x15, ///< equal to 
      -> doEquals
   OP_NE = 0x16, ///< not equal to 
      -> doEquals
	  wenn *sp == 0
	     *sp = 1
	  sonst *sp = 0
   OP_GE = 0x17, ///< greater than or equal to 
      -> doCompare
	  wenn *sp >= 0
	     *sp = 1
	  sonst *sp = 0
   OP_GT = 0x18, ///< greater than 
      -> doCompare
	  wenn *sp > 0
	     *sp = 1
	  sonst *sp = 0
   OP_INC = 0x19, ///< increment 
      switch (type(*sp))
	     Zahl(int, float, double): (*sp)++
		 Objekt(ref) : rufe OP_INC auf Objekt auf
		 sonst: Typfehler
   OP_DEC = 0x1A, ///< decrement 
      switch (type(*sp))
	     Zahl(int, float, double): (*sp)--
		 Objekt(ref) : rufe OP_DEC auf Objekt auf
		 sonst: Typfehler
 (xx)  OP_LIT = 0x1B, ///< load literal 
        *sp = byteCodeVec[(indextype)[pcode+pc]]
		pc += sizeof(indextype)
   OP_RETURN = 0x1C, ///< return from interpreter 
          FP[1].dispose(); // dispose exception, if any
         return true;
 (xx)  OP_CALL = 0x1D, ///< call a function 
       nargs = (indextype)[pcode+pc]  // Anzahl bergebener Argumente
	   pc += sizeof(indextype)
	   vp = sp-nargs  // vp zeigt auf aufzurufende Funktion (native code, bytecode oder Objekt)
	   switch type(*vp)
	     native code: (*vp)(VM,nargs,sp)  // native Funktion ausfhren
		 bytecode(ref): -->call(nargs,vp)
		 objekt(ref): -->send(nargs,"OP_CALL")  // rufe operator() auf Objekt auf
		 sonst: Typfehler
		wenn sp > vp // --> stack aufrumen 
	        * vp = *sp // Rckgabewert an Position der Funktion kopieren
			Werte darber vom Stack entfernen
			sp = vp // SP korrigieren
 (xx)  OP_REF = 0x1E, ///< load a variable value 
        idx = (indextype)[pcode+pc]  // Index von Variable in Bytecode-Vektor
	    pc += sizeof(indextype)
		pvar = [byteCodeVec[idx]]
		wenn keine Variable (DictionaryEntry) --> Fehler
		*sp = value(pvar)
 (xx)  OP_SET = 0x1F, ///< set the value of a variable 
        idx = (indextype)[pcode+pc]  // Index von Variable in Bytecode-Vektor
	    pc += sizeof(indextype)
		pvar = [byteCodeVec[idx]]
		wenn keine Variable (DictionaryEntry) --> Fehler
		value(pvar) = *sp
   OP_VREF = 0x20, ///< load a vector element 
       --> doOP_VREF
   OP_VSET = 0x21, ///< set a vector element 
      --> doOp_VSET
 (xx)  OP_MREF = 0x22, ///< load a member variable value 
      obj = BP[1] // Objekt (this-Zeiger)
	  wenn obj == 0  -> Fehler
       idx = (indextype)[pcode+pc]  // Index des zu lesenden Feldes
	   pc += sizeof(indextype)
	   mdata = obj->getMemberData() // Datenvektor des Objekts
	   *sp = mdata[idx]
 (xx)  OP_MSET = 0x23, ///< set a member variable 
      obj = BP[1] // Objekt (this-Zeiger)
	  wenn obj == 0  -> Fehler
       idx = (indextype)[pcode+pc]  // Index des zu setzenden Feldes
	   pc += sizeof(indextype)
	   mdata = obj->getMemberData() // Datenvektor des Objekts
	   mdata[idx] = *sp
  (xx) OP_AREF = 0x24, ///< load an argument value 
      idx = (indextype)[pcode+pc]  // Index des zu lesenden Arguments
	  pc += sizeof(indextype)
	  wenn n >= numargs: Fehler - zu wenig Argumente
	  *sp = BP[n+1]
  (xx) OP_ASET = 0x25, ///< set an argument value 
      idx = (indextype)[pcode+pc]  // Index des zu lesenden Arguments
	  pc += sizeof(indextype)
	  wenn n >= numargs: Fehler - zu wenig Argumente
	  BP[n+1] = *sp
 (xx)  OP_TREF = 0x26, ///< load a temporary variable value 
      idx = (indextype)[pcode+pc]  // Index des zu lesenden Arguments
	  pc += sizeof(indextype)
	  *sp = FP[n+1]
 (xx)  OP_TSET = 0x27, ///< set a temporary variable 
      idx = (indextype)[pcode+pc]  // Index des zu lesenden Arguments
	  pc += sizeof(indextype)
	  FP[n+1] = *sp
  (NW) OP_TSPACE = 0x28, ///< allocate temporary variable space
       ntmp = (indextype)[pcode+pc]  // Index des zu lesenden Arguments
	    pc += sizeof(indextype)
		FP = _sp; // FP points before 1st temporary
        for (BppNWord i=0;i<n;i++)
           (++_sp)->dispose(); // inc _sp and set value to NULL
  
 (xx)  OP_SEND = 0x29, ///< send a message to an object 
        nargs = (indextype)[pcode+pc]  // Index des zu lesenden Arguments
	    pc += sizeof(indextype)
		--> send(nargs)
  OP_DUP2 = 0x2A, ///< duplicate top two elements on the stack 
         _sp+=2;
         _sp[-1] = _sp[-3];
         *_sp = _sp[-2];
   OP_NEW = 0x2B, ///< create a new class object 
       wenn type(*sp) != class --> Fehler
	   *sp = new BppObject(*sp)
   OP_DELETE = 0x2C,    ///< delete object instance 
       wenn (*sp) Referenz und refcnt(*sp) == 0 --> delete ref(*sp)
	   sp->dispose
   OP_DUP = 0x2D,  ///< duplicate TOS
         ++_sp;
         *_sp = _sp[-1];
   OP_POP = 0x2E, ///< remove topmost entry from stack
          _sp->dispose();
         --_sp;  
   OP_MKREF = 0x2F, ///< make reference from reference counted value
      --> doOp_MKREF
   (NW) OP_TRY = 0x30, ///< enter try block
            _procStack->pushErrorHandler(BytePtr2NW(pcode+pc),_sp);
            pc += sizeof(BppNWord);
      
   (NW) OP_ENDTRY = 0x31, ///< leave try block
          _procStack->popErrorHandler();
         pc = BytePtr2NW(pcode+pc);
  OP_THROW = 0x32, ///< raise an exception
         returnError(*_sp);  // Fehlermeldung an *sp ausgeben
         pending = true;
   OP_ENDCATCH = 0x33, ///< reset exception on end of catch block
         FP[1].dispose(); // 0x33, dispose exception, if any
  (NW) OP_SWITCH = 0x34,   ///< enter switch block
         pc += sizeof(BppNWord);  // Was wird hier bersprungen?
  (xx) OP_SREF = 0x35,    ///< load static variable (identisch mit OP_LIT)
         *sp = byteCodeVec[(indextype)[pcode+pc]]
		pc += sizeof(indextype)
  (xx) OP_SSET = 0x36,    ///< set static variable
         byteCodeVec[(indextype)[pcode+pc]] = *sp 
		pc += sizeof(indextype)
   OP_PINC = 0x37,    ///< post increment
      switch (type(*sp))
	     Zahl(int, float, double): (*sp)++
		 Objekt(ref) : rufe OP_PINC auf Objekt auf
		 sonst: Typfehler
   OP_PDEC = 0x38,    ///< post decrement
      switch (type(*sp))
	     Zahl(int, float, double): (*sp)--
		 Objekt(ref) : rufe OP_PDECC auf Objekt auf
		 sonst: Typfehler
   // debug opcodes
   OP_TRON = 0x80, ///< switch trace on
             if (!(_trace || _step)) _debugger->setCurrentProc(_procStack);
           _trace = true;
  OP_TROFF = 0x81, ///< switch trace off
          _trace = false;
  OP_TRSTEP = 0x82, ///< switch to single step mode
             if (!(_trace || _step)) _debugger->setCurrentProc(_procStack);
           _step = true;
 (xx) OP_NEWLINE = 0x83, ///< notify source line changed
        string s = *sp
       lnum = (indextype)[pcode+pc]  // Index des zu lesenden Arguments
	    pc += sizeof(indextype)
        _step = _vm.notifySourceLineChanged(s->c_str(),lnum);
		--sp  // Zeilennummer vom Stack entfernen
