.NET schutz

Debugger.IsAttached

Opcode Operand
0001:    ADD  (holt sich 2 Werte vom Stack und addiert diese)
0002:    Sub  (genauso, nur mit Subtraktion)
.... weitere Rechenarten
0010     0000: Load Var (als Var kann man eine Ziffer angeben und intern einfach mit dataarray[var] arbeiten)
0011     0000: store Var 
0012:    cmp (holt sich die 2 variablen vom Stack und vergleicht diese, stetzt dann bei Übereinstimmung den Equal Flag, bei Var1<Var2 den Signed Flag)
0013    0000: JE  Addr   jmp if equal zu Adresse (sprich, wenn Equal Flag gesetzt ist)
0014    0000: JS  Addr   jmp if smaller zu Adresse (wenn Signed Flag gesetzt ist)
0015    0000: jg   Addr   jmp if greater zu Adresse (wenn weder Equal noch Signed gesetzt sind)
0016    0000: call Addr

CONST var1=1
CONST var2=2

LOAD Var1
LOAD Var1
MUL
STORE Var2

int IP=0;
int code[]="Code aus irgendeiner Quelle/Datei/sonstiger Einbindung";
int data[]="array, welches als variablenarray dient"
bool equalflag=false;
bool signedflag=false;

Stack stack=new Stack();

while(ip<code.length)
{
  opcode1=code[ip];
  opcode2=code[ip+1];
  IF (opcode1==ADD)
  {
     int var1=Stack.pop;
     int var2=Stack.pop;
    int result=var1+var2;
    Stack.push(result);   
    IP=IP+1; //da es nur eine 1-Opcode Anweisung war, InstrucitonPointer nur um 1 weiterbewegen 
  }
  ELSE IF (opcode1==....)
  ....
  ELSE IF (opcode==STORE)
  {
    int index=opcode2;
    data[index]=Stack.pop;
   IP=IP+2;  //ist eine 2-Opcodes Anweidung
  } 
  Else IF (opcode1==Load)
  {
     int index=opcode2;
     int wert=data[index];
     Stack.push(wert);
    IP=IP+2;  //ist eine 2-Opcodes Anweidung
  }
  ELSE IF (opcode1==CMP)
  {
    int var1=Stack.pop;
    int var2=Stack.pop;
    if (var1==var2) equalflag=true ELSE equalflag=false;
    if (var1>var2) signedflag=true ELSE signedflag=false;
    IP=IP+1;
  }
  ELSE IF (opcode1==JE)
  {
    if (equalflag==true) ip=opcode2;
  }
 ... usw ...
  ELSE IF (opcode1==HALT)
     Break;    //sofern man einen HALT Opcode definiert, kann man die Ausführung auch frühzeitig beenden
}

CONST ADD=1
... wie oben im Bsp...
CONST VAR1=0
CONST VAR2=1
CONST VAR3=2
CONST VAR4=3


int mycode[] =   //hier eine Arraydefinition+initialisierungsregeln in Deiner verwendeten sprache
{   
   ILOAD, 0,  //Loadbefehl für Konstanten würde ich noch mit in die VM aufnehmen, ist nützlich
  STORE, VAR1,
  //4 ter Eintrag: also an der 4-ten Steller im mycode Array 
  LOAD, VAR2,
  LOAD, VAR3,
  MUL,
  STORE, VAR4,
  LOAD, VAR1,
  ILOAD, 1,
  ADD,
  STORE, VAR1,
  LOAD, VAR1,
  ILOAD, 10,
  CMP
  JNE,4 //setze IP auf 4 - gehe also zum 4 Eintrag im mycode Array
}
int data[]=new int[4];
data[0]=0;
data[1]=readuserinput_als_integer;   //Variablen für VM vorinitialisieren
data[2]=readuserinput_als_integer;
data[3]=0;
myVMInterpreter(mycode,data);
output(data[3]));    //VAR4, also Ergebnis, ausgeben
  }

mycode={1,0,2,0,....}

int keyfile[]=read("\\licence.key");
... junkcode ...
int hardwareid[]=....
... junkcode ...
int verknüpft[]=verknüpfe_hardwareid&keyfile_irgendwie();
... junkcode ...
int mycode[]=copy(verknüpft,10,100);   //nutze Keystellen ab 10 bis 100 als Code
int mydata[]=hardwareid;
myVMInterpreter(mycode,mydata);
... junkcode...
interne_variablen_für_sonstwas=data[X];    //initialisiere die vom Programm benutzte Variablen mit berechnetem Code
interne_variablen_für_sonstwas=data[Y];

CONST VAR1=0
CONST VAR2=1
CONST VAR3=2
CONST VAR4=3

 IF (Opcode1=JMP)

#define VAR1 0
#define VAR2 1

Else IF (opcode1==Load)
  {
     int index=opcode2;
     int wert=data[index];
     Stack.push(wert);
    IP=IP+2;  //ist eine 2-Opcodes Anweidung
  }
Else IF (opcode1==ILoad)
  {
     int wert=opcode2;
     Stack.push(wert);
    IP=IP+2;  //ist eine 2-Opcodes Anweidung
  }

IF (opcode1==ADD)
  {
     int var1=Stack.pop;
     int var2=Stack.pop;
    int result=var1+var2;
    Stack.push(result);   
    IP=IP+1; //da es nur eine 1-Opcode Anweisung war, InstrucitonPointer nur um 1 weiterbewegen 
  }

IF (opcode1==ADD)
  {
     int var1=Stack.pop;
     int var2=Stack.pop;
     String junk=var1.toString;
     int junk2=junk[i]&var2;
    Stack.push(junk2);
    ...junk...
    junk[y]=var2*junk2;
    Stack.pop;
    ... usw...
    int result=var1+var2;
    Stack.push(result);   
    IP=IP+1; //da es nur eine 1-Opcode Anweisung war, InstrucitonPointer nur um 1 weiterbewegen 
  }

Shared RET As Integer 'Rückgabe

Sub
Dim Codebase() As String = _
{"ADD", "5", "ADD", "10", "MUL", "RET"}  'CODE

Call XIL(Codebase) 'VM starten

End Sub



Friend Sub XIL(ByVal Codefile() As String)
Dim IP As Integer = 0
Dim Stack(UBound(Codefile)) As Integer
Dim intStack As Integer = 1

While (IP < UBound(Codefile) + 1)

Select Case Codefile(IP)

Case "ADD"
    Stack(intStack) = CInt(Codefile(IP + 1))
    intStack += 1
    IP += 2
Case "MUL"
    Stack(intStack) = Stack(intStack - 2) * Stack(intStack - 1)
    intStack += 1
    IP += 1
Case "RET"
    RET = Stack(intStack - 1)
    IP += 1
End Select
End While
End Sub

[stack]
2
2
[Stackend]

ADD holt sich seine Parameter von Stack:

Par1=Stack.pop
[stack]
2
[stackend]

Par2=stack.pop
[stack]
[stackend]

pusht Ergebnis wieder auf den Stack:
stack.push (2+2)
[stack]
4
[stackend]

Case "ADD"
    Stack(intStack) = CInt(Codefile(IP + 1))   //Weise den zweiten Opcode auf den Stack?
    intStack += 1
    IP += 2
Case "MUL"
    Stack(intStack) = Stack(intStack - 2) * Stack(intStack - 1)  //alte Operatoren bleiben auf dem Stack
    intStack += 1
    IP += 1

Case "MUL"
    int result= Stack(intStack - 2) * Stack(intStack - 1)
    intStack =intStack-2   'beide Operanden freigeben
   Stack(intStack)=result  'Ergebis speichern
    intStack=intStack+1    'Stackpointer auf den nächsten freiverfügbaren Platz
    IP += 1