Langage de programmation - Turbo Pascal - Émulateur - Émulateur de microprocesseur 6502

Émulateur de microprocesseur 6502

Un émulateur de microprocesseur 6502 permet d'exécuter le code qu'exécuterait le microprocesseur 6502 utilisé par exemple dans les Apple II et la NES de Nintendo. L'émulateur 6502 en soi ne fait qu'imiter le comportement d'une puce et il ne rend pas automatiquement exécutable tout logiciel écrit pour les micro-ordinateurs et les consoles de jeux. Ainsi, pour que l'émulateur puisse exécuter des logiciels dédiés à des plateformes particulières, il doit également imiter le comportement des puces électroniques dédié à l'affichage, au son et aux périphériques y étant connecté. La puce 6502 n'a pas de port d'entrée/sortie à gérer, donc, tous signal envoyé à l'électronique passe directement par l'affectation d'une cellule mémoire de la RAM. Aussi, la pile gérable est d'un maximum de 256 octets et est toujours situé à l'adresse 0100h.

Le rôle d'un émulateur 6502 n'est pas si compliqué en soi, il s'agit de passer un par un chaque octet de mémoire (opcode) et d'effectuer les actions en mémoire en fonction de l'opération demandée. Une opération peut être, une addition, une soustraction, des tests, des opérateurs binaires, des déplacements du compteur de programme en mémoire, l'affectation de la pile,... Voici un schéma d'un émulateur 6502 :

Il est à noter également que le code suivant n'est pas optimisé pour le compilateur Turbo Pascal. Ainsi, il n'utilise pas les procédures INC et DEC afin d'incrémenter ou décrémenter des valeurs, mais plutôt une affectation manuelle. Le but de l'exemple suivant est de monter le fonctionnement et de rendre facilement portable le code sous différentes marques de compilateurs Pascal. Dans cet exemple, étant donné que l'émulateur ne contient rien dans la mémoire de la RAM de l'émulateur (variable «memory»), il arrêtera immédiatement à l'instruction d'opcode BRK. Ce sera à vous de charger des données afin pouvoir tester le comportement de routines Assembleur 6502.

L'émulateur à la fonctionnalité du débogueur d'instruction activé par défaut, lequel affiche la valeur des registres et sa position d'exécution entre chaque instruction exécutée. Il va de soit, que cette option n'est pas indispensables à l'émulateur mais permet aux développeurs de suivre facilement, pas à pas, ce qui se passe dans le programme tentant d'être exécuté.



Program emul6502;

 
Const

 DebugOn:Boolean=True;

 
Var

 codeRunning:Boolean;

 A:Byte;     { Registre accumulateur }

 X:Byte;     { Registre d'index X }

 Y:Byte;     { Registre d'index Y }

 P:Byte;     { Registre d'etat de processeur }

 PC:Word; { Registre de compteur der programmes }

 SP:Word; { Registre de pointeur de pile }

 memory:Array[0..16384] of Byte;

 
Procedure InitEmul;Begin

 codeRunning:=True;

 A:=0;

 X:=0;

 Y:=0;

 P:=0;

 PC:=$600;

 SP:=$100;

End;

 
Function num2hex(nr:Byte):String;

Const

 HexStr:Array[0..15]of Char=('0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f');

Begin

 num2hex := HexStr[(nr and $f0) shr 4] + HexStr[nr and $F];

End;

 
Function addr2hex(address:Word):String;Begin

  addr2hex := num2hex((address shr 8) and $ff)+num2hex(address and $ff);

End;

 
Function popByte:Byte;Begin

 popByte := memory[PC] and $ff;

 PC := PC + 1;

End;

 
Function popWord:Word;Begin

 popWord := popByte + (popByte shl 8);

End;

 
Procedure stackPush(value:Byte);Begin

  If SP >= 0 Then Begin

   SP := SP - 1;

   memory[(SP and $ff)+$100] := value and $ff;

  End

   else

  Begin

   WriteLn('Pile pleine: ',SP);

   codeRunning := false;

  End;

End;

 
Function stackPop:Byte;Begin

  If SP < $100 Then Begin

   stackPop := memory[SP+$100];

   SP := SP + 1;

  End

   else

  Begin

   WriteLn('Pile vide');

   codeRunning := false;

   stackPop:=0;

  End;

End;

 
Procedure jumpBranch(offset:Word);Begin

  If offset > $7f Then PC := PC - ($100 - offset) Else PC := PC + offset;

End;

 
Procedure memStoreByte(address:Word; value:Byte);Begin

 memory[address] := (value and $ff);

End;

 
Function memReadByte(address:Word):Byte;Begin

 memReadByte := memory[address];

End;

 
Procedure testADC(value:Byte);

Var

 tmp:Word;

Begin

  If (A xor value) and $80 = $80 Then P := P and $bf else P := P or $40;

  If P and 8 = 8 Then Begin

    tmp := (A and $0f) + (value and $0f) + (P and 1);

    If tmp >= 10 Then tmp := $10 or ((tmp+6) and $0f);

    tmp := tmp + (A and $f0) + (value and $f0);

    If tmp >= 160 Then Begin

      P := P or 1;

      If (P and $bf <> 0) and (tmp >= $180 ) Then P := P and $bf;

      tmp := tmp + $60;

    End

     else

    Begin

      P := P and $fe;

      If (P and $bf <> 0) and ( tmp < $80 ) Then P := P and $bf;

    End;

  End

   else

  Begin

    tmp := A + value + (P and 1);

    If tmp >= $100 Then Begin

      P := P or 1;

      If (P and $bf <> 0) and (tmp >= $180) Then P := P and $bf;

    End

     else

    Begin

      P := P and $fe;

      If (P and $bf <> 0) and (tmp < $80) Then P := P and $bf;

    End;

  End;

  A := tmp and $ff;

  If A <> 0 Then P := P and $fd else P := P or $02;

  If A and $80 = $80 Then P := P or $80 else P := P and $7f;

End;

 
Procedure testSBC(value:Byte);

Var

 tmp,w:Word;

Begin

  If P and 8 = 8 Then Begin

   tmp := $0f + (A and $0f) - (value and $0f) + (P and 1);

   If tmp < $10 Then Begin

    w := 0;

    tmp := tmp - 6;

   End

    else

   Begin

    w := $10;

    tmp := tmp - $10;

   End;

   w := w +$f0 + (A and $f0) - (value and $f0);

   If w < $100 Then Begin

    P := P and $fe;

    If (P and $bf <> 0) and (w < $80) Then P := P and $bf;

    w := w - $60;

   End

    Else

   Begin

    P := P or 1;

    If (P and $bf <> 0) and (w >= $180) Then P := P and $bf;

   End;

   w := w + tmp;

  End

   else

  Begin

   w := $ff + A - value + (P and 1);

   If w < $100 Then Begin

    P := P and $fe;

    If (P and $bf <> 0) and (w < $80) Then P := P and $bf;

   End

    else

   Begin

    P := P or 1;

    If(P and $bf<>0) and (w >= $180) Then P := P and $bf;

   End;

  End;

  A := w and $ff;

  If A <> 0 Then P := P and $fd else P := P or $02;

  If A and $80 = $80 Then P := P or $80 else P := P and $7f;

End;

 
Procedure doCompare(reg,val:Word);Begin

  if (reg+val) > $ff Then P := P or 1 else P := P and $fe;

  val := (reg-val);

  If val <> 0 Then P := P and $fd else P := P or $02;

  If val and $80 = $80 Then P := P or $80 else P := P and $7f;

End;

 
Procedure ExecEmul;

Var

 opcode,zp,offset:Byte;

 currAddr,address,value,sf:Word;

Begin

  If Not(codeRunning)Then Exit;

  opcode := popByte;

  If(DebugOn)Then WriteLn('PC=', addr2hex(PC-1), ' opcode=', opcode, ' X=', X, ' Y=', Y, ' A=', A, ' P=', P);

  Case opcode of

    $00:                            { BRK implicite }

      codeRunning := false;

    $01:Begin                       { ORA INDX }

      address := popByte + X;

      value := memReadByte(address) + (memReadByte( address+1) shl 8);

      A := A or Lo(value);

      If A <> 0 Then P := P and $fd else P := P or $02;

      If A and $80 = $80 Then P := P or $80 else P := P and $7f;

     End;

    $05:Begin                       { ORA ZP }

      zp := popByte;

      A := A or memReadByte(zp);

      If A <> 0 Then P := P and $fd else P := P or $02;

      If A and $80 = $80 Then P := P or $80 else P := P and $7f;

     End;

    $06:Begin                       { ASL ZP }

      zp := popByte;

      value := memReadByte( zp );

      P := (P and $fe) or ((value shr 7) and 1);

      value := value shl 1;

      memStoreByte( zp, value );

      If value <> 0 Then P := P and $fd else P := P or $02;

      If value and $80 = $80 Then P := P or $80 else P := P and $7f;

     End;

    $08:                            { PHP }

      stackPush(P);

    $09:Begin                       { ORA IMM }

      A := A or popByte;

      If A <> 0 Then P := P and $fd else P := P or $02;

      If A and $80 = $80 Then P := P or $80 else P := P and $7f;

     End;

    $0a:Begin                       { ASL IMPL }

       P := (P and $fe) or ((A shr 7) and 1);

       A := A shl 1;

       If A <> 0 Then P := P and $fd else P := P or $02;

       If A and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $0d:                            { ORA ABS }

      Begin

       A := A or memReadByte( popWord );

       If A <> 0 Then P := P and $fd else P := P or $02;

       If A and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $0e:Begin                       { ASL ABS }

       address := popWord;

       value := memReadByte(address);

       P := (P and $fe) or ((value shr 7) and 1);

       value := value shl 1;

       memStoreByte(address, value);

       If value <> 0 Then P := P and $fd else P := P or 2;

       If value and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $10:Begin                      { BPL }

       offset := popByte;

       If P and $80 = 0 Then jumpBranch( offset );

      End;

    $11:Begin                      { ORA INDY }

       zp := popByte;

       value := memReadByte(zp) + (memReadByte(zp+1) shl 8) + Y;

       A := A or memReadByte(value);

       If A <> 0 Then P := P and $fd  Else P := P or $02;

       If A and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $15:Begin                      { ORA ZPX }

       address := (popByte + X) and $ff;

       A := A or memReadByte(address);

       If A <> 0 Then P := P and $fd else P := P or $02;

       If A and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $16:Begin                      { ASL ZPX }

       address := (popByte + X) and $ff;

       value := memReadByte(address);

       P := (P and $fe) or ((value shr 7) and 1);

       value := value shl 1;

       memStoreByte(address, value);

       If value <> 0 Then P := P and $fd else P := P or $02;

       If value and $80 <> $80 Then P := P or $80 else P := P and $7f;

      End;

    $18:                            { CLC }

      P := P and $fe;

    $19:Begin                       { ORA ABSY }

       address := popWord + Y;

       A := A or memReadByte(address);

       If A <> 0 Then P := P and $fd else P := P or $02;

       If A and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $1d:Begin                       { ORA ABSX }

       address := popWord + X;

       A := A or memReadByte(address);

       If A <> 0 Then P := P and $fd else P := P or $02;

       If A and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $1e:Begin                       { ASL ABSX }

       address := popWord + X;

       value := memReadByte(address);

       P := (P and $fe) or ((value shr 7) and 1);

       value := value shl 1;

       memStoreByte( address, value );

       If value <> 0 Then P := P and $fd else P := P or $02;

       If value and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $20:Begin                      { JSR ABS }

       address := popWord;

       currAddr := PC - 1;

       stackPush((currAddr shr 8) and $ff);

       stackPush(currAddr and $ff);

       PC := address;

      End;

    $21:Begin                      { AND INDX }

       address := (popByte + X) and $ff;

       value := memReadByte(address) + (memReadByte(address + 1) shl 8);

       A := A and value;

       If A <> 0 Then P := P and $fd else P := P or $02;

       If A and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $24:Begin                      { BIT ZP }

       zp := popByte;

       value := memReadByte( zp );

       If value and A <> 0 Then P := P and $fd else P := P or $02;

       P := (P and $3f) or (value and $c0);

      End;

    $25:Begin                      { AND ZP }

       zp := popByte;

       A := A and memReadByte( zp );

       If A <> 0 Then P := P and $fd else P := P or 2;

       If A and $80 = $80 Then P := P and $80 else P := P and $7f;

      End;

    $26:Begin                      { ROL ZP }

       sf := (P and 1);

       address := popByte;

       value := memReadByte( address );

       P := (P and $fe) or ((value shr 7) and 1);

       value := value shl 1;

       value := value or sf;

       memStoreByte( address, value );

       If value <> 0 Then P := P and $fd else P := P or $02;

       If value and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $28:                            { PLP }

      P := stackPop or $20;

    $29:Begin                       { AND IMM }

       A := A and popByte;

       If A <> 0 Then P := P and $fd else P := P or $02;

       If A and $80 = $80 Then P := P or $80 else P := P and $7f;

     End;

    $2a:Begin                       { ROL A }

       sf := (P and 1);

       P := (P and $fe) or ((A shr 7) and 1);

       A := A shl 1;

       A := A or sf;

       If A <> 0 Then P := P and $fd else P := P or $02;

       If A and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $2c:Begin                      { BIT ABS }

       value := memReadByte(popWord);

       If value and A <> 0 Then P := P and $fd else P := P or $02;

       P := (P and $3f) or (value and $c0);

      End;

    $2d:Begin                      { AND ABS }

       value := memReadByte(popWord);

       A := A and value;

       If A <> 0 Then P := P and $fd else P := P or $02;

       If A and $80=$80 Then P := P or $80 else P := P and $7f;

      End;

    $2e:Begin                      { ROL ABS }

       sf := P and 1;

       address := popWord;

       value := memReadByte( address );

       P := (P and $fe) or ((value shr 7) and 1);

       value := value shl 1;

       value := value or sf;

       memStoreByte( address, value );

       If value <> 0 Then P := P and $fd else P := P or $02;

       If value and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $30:Begin                       { BMI }

       offset := popByte;

       If P and $80 <> $80 Then jumpBranch( offset );

      End;

    $31:Begin                       { AND INDY }

       zp := popByte;

       value := memReadByte(zp) + (memReadByte(zp+1) shl 8) + Y;

       A := A and memReadByte(value);

       If A <> 0 Then P := P and $fd else P := P or $02;

       If A and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $35:Begin                       { AND INDX }

       zp := popByte;

       value := memReadByte(zp) + (memReadByte(zp+1) shl 8) + X;

       A := A and memReadByte(value);

       If A <> 0 Then P := P and $fd else P := P or $02;

       If A and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $36:Begin                       { ROL ZPX }

       sf := P and 1;

       address := (popByte + X) and $ff;

       value := memReadByte(address);

       P := (P and $fe) or ((value shr 7) and 1);

       value := value shl 1;

       value := value or sf;

       memStoreByte( address, value );

       If value <> 0 Then P := P and $fd else P := P or $02;

       If value and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $38:                            { SEC }

      P := P or 1;

    $39:Begin                       { AND ABSY }

       address := popWord + Y;

       value := memReadByte( address );

       A := A and value;

       If A <> 0 Then P := P and $fd else P := P or $02;

       If A and $80 = $80 Then P := P or $80 else P := P and  $7f;

      End;

    $3d:Begin                       { AND ABSX }

       address := popWord + X;

       value := memReadByte(address);

       A := A and value;

       If A <> 0 Then P := P and $fd else P := P or $02;

       If A and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $3e:Begin                       { ROL ABSX }

       sf := P and 1;

       address := popWord + X;

       value := memReadByte(address);

       P := (P and $fe) or ((value shr 7) and 1);

       value := value shl 1;

       value := value or sf;

       memStoreByte(address, value);

       If value <> 0 Then P := P and $fd else P := P or $02;

       If value and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $40:;                           { RTI (non-supporté, =NOP) }

    $41:Begin                       { EOR INDX }

       zp := (popByte + X) and $ff;

       value := memReadByte(zp) + (memReadByte(zp+1) shl 8);

       A := A xor memReadByte(value);

       If A <> 0 Then P := P and $fd else P := P or $02;

       If A and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $45:Begin                       { EOR ZPX }

       address := (popByte + X) and $ff;

       value := memReadByte(address);

       A := A xor value;

       If A <> 0 Then P := P and $fd else P := P or $02;

       If A and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $46:Begin                       { LSR ZP }

       address := popByte and $ff;

       value := memReadByte(address);

       P := (P and $fe) or (value and 1);

       value := value shr 1;

       memStoreByte(address, value);

       If value <> 0 Then P := P and $fd else P := P or 2;

       If value and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $48:                            { PHA }

      stackPush(A);

    $49:Begin                       { EOR IMM }

       A := A xor popByte;

       If A <> 0 Then P := P and $fd else P := P or $02;

       If A and $80 = $80 Then P := P + $80 else P := P and $7f;

      End;

    $4a:Begin                        { LSR }

       P := (P and $fe) or (A and 1);

       A := A shr 1;

       If A <> 0 Then P := P and $fd else P := P or $02;

       If A and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $4c:                            { JMP abs }

      PC := popWord;

    $4d:Begin                       { EOR abs }

       address := popWord;

       value := memReadByte(address);

       A := A xor value;

       If A <> 0 Then P := P and $fd else P := P or $02;

       If A and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $4e:Begin                       { LSR abs }

       address := popWord;

       value := memReadByte(address);

       P := (P and $fe) or (value and 1);

       value := value shr 1;

       memStoreByte(address, value);

       If value <> 0 Then P := P and $fd else P := P or $02;

       If value and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $50:Begin                      { BVC (efface le debordement) }

       offset := popByte;

       If P and $40 = 0 Then jumpBranch(offset);

      End;

    $51:Begin                      { EOR INDY }

       zp := popByte;

       value := memReadByte(zp) + (memReadByte(zp+1) shl 8) + Y;

       A := A xor memReadByte(value);

       If A <> 0 Then P := P and $fd else P := P or $02;

       If A and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $55:Begin                      { EOR ZPX }

       address := (popByte + X) and $ff;

       A := A xor memReadByte(address);

       If A <> 0 Then P := P and $fd else P := P or $02;

       If A and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $56:Begin                      { LSR ZPX }

       address := (popByte + X) and $ff;

       value := memReadByte(address);

       P := (P and $fe) or (value and 1);

       value := value shr 1;

       memStoreByte(address, value);

       If value <> 0 Then P := P and $fd else P := P or $02;

       If value and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $58:;                          { CLI (ne fait rien) }

    $59:Begin                      { EOR ABSY }

       address := popWord + Y;

       value := memReadByte(address);

       A := A xor value;

       If A <> 0 Then P := P and $fd else P := P or $02;

       If A and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $5d:Begin                      { EOR ABSX }

       address := popWord + X;

       value := memReadByte(address);

       A := A xor value;

       If A <> 0 Then P := P and $fd else P := P or $02;

       If A and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $5e:Begin                      { LSR ABSX }

       address := popWord + X;

       value := memReadByte(address);

       P := (P and $fe) or (value and 1);

       value := value shr 1;

       memStoreByte(address, value);

       If value <> 0 Then P := P and $fd else P := P or $02;

       If value and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $60:                           { RTS }

      PC := (stackPop + 1) or (stackPop shl 8);

    $61:Begin                      { ADC INDX }

       zp := (popByte + X) and $ff;

       address := memReadByte(zp) + (memReadByte(zp+1) shl 8);

       value := memReadByte(address);

       testADC( value );

      End;

    $65:Begin                      { ADC ZP }

       address := popByte;

       value := memReadByte(address);

       testADC(value);

      End;

    $66:Begin                      { ROR ZP }

       sf := P and 1;

       address := popByte;

       value := memReadByte( address );

       P := (P and $fe) or (value and 1);

       value := value shr 1;

       If sf <> 0 Then value := value or $80;

       memStoreByte( address, value );

       If value <> 0 Then P := P and $fd else P := P or $02;

       If value and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $68:Begin                      { PLA }

       A := stackPop;

       If A <> 0 Then P := P and $fd else P := P or $02;

       If A and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $69:Begin                      { ADC IMM }

       value := popByte;

       testADC(value);

      End;

    $6a:Begin                      { ROR A }

      sf := P and 1;

      P := (P and $fe) or (A and 1);

      A := A shr 1;

      If sf <> 0 Then A := A or $80;

      If A <> 0 Then P := P and $fd else P := P or $02;

      If A and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $6c:                           { JMP INDIR }

      PC := memReadByte(popByte) + (memReadByte(popByte) shl 8);

    $6d:Begin                      { ADC ABS }

       address := popWord;

       value := memReadByte(address);

       testADC(value);

      End;

    $6e:Begin                      { ROR ABS }

       sf := P and 1;

       address := popWord;

       value := memReadByte(address);

       P := (P and $fe) or (value and 1);

       value := value shr 1;

       If sf <> 0 Then value := value or $80;

       memStoreByte(address, value);

       If value <> 0 Then P := P and $fd else P := P or $02;

       If value and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $70:Begin                     { BVS (branch on overflow set) }

       offset := popByte;

       If P and $40 = $40 Then jumpBranch(offset);

      End;

    $71:Begin                     { ADC INY }

       zp := popByte;

       address := memReadByte(zp) + (memReadByte(zp + 1) shl 8);

       value := memReadByte(address + Y);

       testADC(value);

      End;

    $75:Begin                     { ADC ZPX }

       address := (popByte + X) and $ff;

       value := memReadByte(address);

       P := (P and $fe) or (value and 1);

       testADC(value);

      End;

    $76:Begin                     { ROR ZPX }

       sf := (P and 1);

       address := (popByte + X) and $ff;

       value := memReadByte(address);

       P := (P and $fe) or (value and 1);

       value := value shr 1;

       If sf <> 0 Then value := value or $80;

       memStoreByte(address, value);

       If value <> 0 Then P := P and $fd else P := P or $02;

       If value and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $78:;                          { SEI (ne fait rien) }

    $79:Begin                      { ADC ABSY }

       address := popWord;

       value := memReadByte(address + Y);

       testADC(value);

      End;

    $7d:Begin                      { ADC ABSX }

       address := popWord;

       value := memReadByte(address + X);

       testADC(value);

      End;

    $7e:Begin                      { ROR ABSX }

       sf := P and 1;

       address := popWord + X;

       value := memReadByte(address);

       P := (P and $fe) or (value and 1);

       value := value shr 1;

       If value <> 0 Then value := value or $80;

       memStoreByte( address, value );

       If value <> 0 Then P := P and $fd else P := P or $02;

       If value and $80 = $80 Then P := P and $80 else P := P and $7f;

      End;

    $81:Begin                     { STA INDX }

       zp := (popByte + X) and $ff;

       address := memReadByte(zp) + (memReadByte(zp+1) shl 8);

       memStoreByte(address, A);

      End;

    $84:                           { STY ZP }

      memStoreByte( popByte, Y);

    $85:                           { STA ZP }

      memStoreByte( popByte, A);

    $86:                           { STX ZP }

      memStoreByte( popByte, X);

    $88:Begin                      { DEY (1 octet) }

       Y := (Y-1) and $ff;

       If Y <> 0 Then P := P and $fd else P := P or $02;

       If Y and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $8a:Begin                      { TXA (1 octet); }

      A := X and $ff;

       If A <> 0 Then P := P and $fd else P := P or $02;

       If A and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $8c:                           { STY abs }

      memStoreByte( popWord, Y );

    $8d:                           { STA ABS (3 octets) }

      memStoreByte( popWord, A );

    $8e:                           { STX abs }

      memStoreByte( popWord, X );

    $90:Begin                      { BCC (branchement dans l'effacement de retenue) }

       offset := popByte;

       If P and 1 = 0 Then jumpBranch( offset );

      End;

    $91:Begin                      { STA INDY }

       zp := popByte;

       address := memReadByte(zp) + (memReadByte(zp + 1) shl 8) + Y;

       memStoreByte(address, A);

      End;

    $94:                           { STY ZPX }

      memStoreByte( popByte + X, Y );

    $95:                           { STA ZPX }

      memStoreByte( popByte + X, A );

    $96:                           { STX ZPY }

      memStoreByte( popByte + Y, X );

    $98:Begin                      { TYA }

       A := Y and $ff;

       If A <> 0 Then P := P and $fd else P := P or $02;

       If A and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $99:                           { STA ABSY }

      memStoreByte( popWord + Y, A );

    $9a:                           { TXS }

      SP := X and $ff;

    $9d:Begin                      { STA ABSX }

       address := popWord;

       memStoreByte(address + X, A);

      End;

    $a0:Begin                      { LDY IMM }

       Y := popByte;

       If Y <> 0 Then P := P and $fd else P := P or $02;

       If Y and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $a1:Begin                      { LDA INDX }

       zp := (popByte + X) and $ff;

       address := memReadByte(zp) + (memReadByte(zp + 1) shl 8);

       A := memReadByte(address);

       If A <> 0 Then P := P and $fd else P := P or $02;

       If A and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $a2:Begin                      { LDX IMM }

       X := popByte;

       If X <> 0 Then P := P and $fd else P := P or $02;

       If X and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $a4:Begin                      { LDY ZP }

      Y := memReadByte(popByte);

      If Y <> 0 Then P := P and $fd else P := P or $02;

      If Y and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $a5:Begin                      { LDA ZP }

       A := memReadByte(popByte);

       If A <> 0 Then P := P and $fd else P := P or $02;

       If A and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $a6:Begin                      { LDX ZP }

       X := memReadByte(popByte);

       If X <> 0 Then P := P and $fd else P := P or $02;

       If X and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $a8:Begin                      { TAY }

       Y := A and $ff;

       If Y <> 0 Then P := P and $fd else P := P or $02;

       If Y and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $a9:Begin                      { LDA IMM }

       A := popByte;

       If A <> 0 Then P := P and $fd else P := P or $02;

       If A and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $aa:Begin                      { TAX }

       X := A and $ff;

       If X <> 0 Then P := P and $fd else P := P or $02;

       If X and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $ac:Begin                      { LDY ABS }

       Y := memReadByte(popWord);

       If Y <> 0 Then P := P and $fd else P := P or $02;

       If Y and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $ad:Begin                      { LDA ABS }

       A := memReadByte(popWord);

       If A <> 0 Then P := P and $fd else P := P or $02;

       If A and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $ae:Begin                      { LDX ABS }

       X := memReadByte(popWord);

       If X <> 0 Then P := P and $fd else P := P or $02;

       If X and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $b0:Begin                      { BCS }

       offset := popByte;

       If P and 1 = 1 Then jumpBranch(offset);

      End;

    $b1:Begin                      { LDA INDY }

       zp := popByte;

       address := memReadByte(zp) + (memReadByte(zp+1) shl 8) + Y;

       A := memReadByte(address);

       If A <> 0 Then P := P and $fd else P := P or $02;

       If A and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $b4:Begin                      { LDY ZPX }

       Y := memReadByte(popByte + X);

       If Y <> 0 Then P := P and $fd else P := P or $02;

       If Y = Y and $80 Then P := P or $80 else P := P and $7f;

      End;

    $b5:Begin                      { LDA ZPX }

       A := memReadByte((popByte + X) and $ff);

       If A <> 0 Then P := P and $fd else P := P or $02;

       If A and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $b6:Begin                      { LDX ZPY }

       X := memReadByte(popByte + Y);

       If X <> 0 Then P := P and $fd else P := P or $02;

       If X and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $b8:                          { CLV }

      P := P and $bf;

    $b9:Begin                     { LDA ABSY }

       address := popWord + Y;

       A := memReadByte(address);

       If A <> 0 Then P := P and $fd else P := P or $02;

       If A and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $ba:                          { TSX }

      X := SP and $ff;

    $bc:Begin                     { LDY ABSX }

       address := popWord + X;

       Y := memReadByte(address);

       If Y <> 0 Then P := P and $fd else P := P or $02;

       If Y and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $bd:Begin                     { LDA ABSX }

       address := popWord + X;

       A := memReadByte(address);

       If A <> 0 Then P := P and $fd else P := P or $02;

       If A and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $be:Begin                     { LDX ABSY }

       address := popWord + Y;

       X := memReadByte(address);

       If X <> 0 Then P := P and $fd else P := P or $02;

       If X and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $c0:Begin                     { CPY IMM }

       value := popByte;

       If Y + value > $ff Then P := P or 1 else P := P and $fe;

       value := Y-value;

       If value <> 0 Then P := P and $fd else P := P or $02;

       If value and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $c1:Begin                     { CMP INDY }

       zp := popByte;

       address := memReadByte(zp) + (memReadByte(zp + 1) shl 8) + Y;

       value := memReadByte(address);

       doCompare(A, value);

      End;

    $c4:Begin                     { CPY ZP }

       value := memReadByte(popByte);

       doCompare(Y, value);

      End;

    $c5:Begin                     { CMP ZP }

       value := memReadByte(popByte);

       doCompare(A, value);

      End;

    $c6:Begin                     { DEC ZP }

       zp := popByte;

       value := memReadByte(zp);

       value := value - 1;

       memStoreByte( zp, value and $ff );

       If value <> 0 Then P := P and $fd else P := P or $02;

       If value and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $c8:Begin                     { INY }

       Y := (Y + 1) and $ff;

       If Y <> 0 Then P := P and $fd else P := P or $02;

       If Y and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $c9:Begin                     { CMP IMM }

      value := popByte;

      doCompare( A, value );

      End;

    $ca:Begin                     { DEX }

       X := (X - 1) and $ff;

       If X <> 0 Then P := P and $fd else P := P or $02;

       If X and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $cc:Begin                     { CPY ABS }

       value := memReadByte(popWord);

       doCompare(Y, value);

      End;

    $cd:Begin                     { CMP ABS }

       value := memReadByte(popWord);

       doCompare(A, value);

      End;

    $ce:Begin                     { DEC ABS }

       address := popWord;

       value := memReadByte( address );

       value := value - 1;

       value := value and $ff;

       memStoreByte( address, value );

       If value <> 0 Then P := P and $fd else P := P  or $02;

       If value and $80 = $80 Then P := P or $80 Else P := P and $7f;

      End;

    $d0:Begin                     { BNE }

       offset := popByte;

       If P and 2 = 0 Then jumpBranch( offset );

      End;

    $d1:Begin                     { CMP INDY }

       zp := popByte;

       address := memReadByte(zp) + (memReadByte(zp + 1) shl 8) + Y;

       value := memReadByte(address);

       doCompare(A, value );

      End;

    $d5:Begin                     { CMP ZPX }

       value := memReadByte( popByte + X );

       doCompare(A, value);

      End;

    $d6:Begin                     { DEC ZPX }

       address := popByte + X;

       value := memReadByte(address);

       value := value - 1;

       value := value and $ff;

       memStoreByte( address, value );

       If value <> 0 Then P := P and $fd else P := P or $02;

       If value and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $d8:                          { CLD (CLear Decimal) }

      P := P and $f7;

    $d9:Begin                     { CMP ABSY }

       address := popWord + Y;

       value := memReadByte(address);

       doCompare(A, value);

      End;

    $dd:Begin                     { CMP ABSX }

       address := popWord + X;

       value := memReadByte(address);

       doCompare(A,value);

      End;

    $de:Begin                     { DEC ABSX }

       address := popWord + X;

       value := memReadByte(address);

       value := value - 1;

       value := value and $ff;

       memStoreByte( address, value );

       If value <> 0 Then P := P and $fd else P := P or $02;

       If value = value and $80 Then P := P or $80 else P := P and $7f;

      End;

    $e0:Begin                     { CPX IMM }

       value := popByte;

       doCompare( X, value );

      End;

    $e1:Begin                     { SBC INDX }

       zp := (popByte+X) and $ff;

       address := memReadByte(zp) + (memReadByte(zp+1) shl 8);

       value := memReadByte(address);

       testSBC(value);

      End;

    $e4:Begin                     { CPX ZP }

       value := memReadByte(popByte);

       doCompare( X, value );

      End;

    $e5:Begin                     { SBC ZP }

       address := popByte;

       value := memReadByte(address);

       testSBC(value);

      End;

    $e6:Begin                     { INC ZP }

       zp := popByte;

       value := memReadByte(zp);

       value := value + 1;

       value := value and $ff;

       memStoreByte(zp, value);

       If value <> 0 Then P := P and $fd else P := P or $02;

       If value and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $e8:Begin                     { INX }

       X := (X + 1) and $ff;

       if X <> 0 Then P := P and $fd else P := P or $02;

       if X and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $e9:Begin                     { SBC IMM }

       value := popByte;

       testSBC(value);

      End;

    $ea:;                        { NOP }

    $ec:Begin                    { CPX ABS }

       value := memReadByte(popWord);

       doCompare(X, value);

      End;

    $ed:Begin                    { SBC ABS }

       address := popWord;

       value := memReadByte( address );

       testSBC(value);

      End;

    $ee:Begin                    { INC ABS }

       address := popWord;

       value := memReadByte(address);

       value := value + 1;

       value := value and $ff;

       memStoreByte(address, value);

       If value <> 0 Then P := P and $fd else P := P or $02;

       If value and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $f0:Begin                     { BEQ }

       offset := popByte;

       If P and 2 = 2 Then jumpBranch(offset);

      End;

    $f1:Begin                     { SBC INDY }

       zp := popByte;

       address := memReadByte(zp) + (memReadByte(zp+1) shl 8);

       value := memReadByte( address + Y );

       testSBC( value );

      End;

    $f5:Begin                     { SBC ZPX }

       address := (popByte + X) and $ff;

       value := memReadByte( address );

       P := (P and $fe) or (value and 1);

       testSBC(value);

      End;

    $f6:Begin                     { INC ZPX }

       address := popByte + X;

       value := memReadByte(address);

       value := value + 1;

       value := value and $ff;

       memStoreByte(address, value);

       If value <> 0 Then P := P and $fd else P := P or $02;

       If value and $80 = $80 Then P := P or $80 else P := P and $7f;

      End;

    $f8:                         { SED }

      P := P or 8;

    $f9:Begin                    { SBC ABSY }

       address := popWord;

       value := memReadByte(address + Y);

       testSBC(value);

      End;

    $fd:Begin                    { SBC ABSX }

       address := popWord;

       value := memReadByte(address + X);

       testSBC(value);

      End;

    $fe:Begin                    { INC ABSX }

      address := popWord + X;

      value := memReadByte(address);

      value := value + 1;

      value := value and $ff;

      memStoreByte(address, value);

      If value <> 0 Then P := P and $fd else P := P or $02;

      If value and $80 = $80 Then P := P or $80 else P := P and $7f;

     End;

     Else Begin

      WriteLn('Adresse $', addr2hex(PC), ' - code inconnu ', opcode);

      codeRunning := False;

     End;

  End;

 
  If (PC = 0) or (Not codeRunning) Then Begin

    WriteLn('Programme terminé à PC=$', addr2hex(PC-1));

    codeRunning := False;

  End;

End;

 
 
BEGIN

 InitEmul;

 Repeat

  ExecEmul;

 Until Not codeRunning;

END.

Remarques

La banque de mémoire est fixé à 16 Ko dans l'exemple du programme. Or, la puce électronique peut supporté jusqu'à 64 Ko, il faudra donc ajuster celle-ci selon vos besoins.
L'émulateur n'est pas cadencé à une vitesse précise, ainsi, si vous exécutez sur une machine à 2 Ghz, votre puce exécutera le logiciel à la même vitesse. Pour résoudre se problème, il faudra donc ajouter un «Wait State» ou un délai d'attente utilisable avec une instruction comme DELAY dans de nombreuses marques de langage de programmation Pascal.
Si vous souhaitez intégré d'autres puces électroniques à cette émulateur 6502, vous devrez intercepter les cellules mémoires exécutés par chacune des instructions. Pour y arriver, vous devrez modifier la fonction «memReadByte» en lecture et la procédure memStoreByte en écriture. Par exemple, pour renvoyer systématiquement un nombre aléatoire à partir de la cellule mémoire $FE, vous devriez modifier la fonction «memReadByte» de la façon suivante :



Function memReadByte(address:Word):Byte;Begin

 If address= $fe Then Begin

  memReadByte := random(256);

 End

  Else

 memReadByte := memory[address];

End;

Pour affecter directement la mémoire vidéo à une adresse $E000, vous devriez modifier la procédure «memStoreByte» de la façon suivante :



Procedure memStoreByte(address:Word; value:Byte);Begin

 memory[address] := (value and $ff);

 If( (address >= $E000) and (address <= $E0FF) ) Then Begin

  Mem[$B800:address-$E000] := value;

 End;

End;

Un émulateur a souvent tendance a contenir des bogues, mineurs ou majeurs. La raison réside dans le fait qu'il faut effectuer des opérations avec un comportement précis et que si un comportement ne correspond pas à la spécification du fabricant, alors l'émulateur sera donc «boguer », car il ne réagira pas exactement comme le modèle du fabricant. De plus, certaines instructions ne sont pas toujours documentées par le fabricant et certains logiciels exploitent le comportement non documenté du fabricant.
L'émulateur dans l'exemple a été écrit en Pascal, mais il n'y a aucune limitation empêchant d'écrire un émulateur dans n'importe quel langage de programmation supportant des conditions et des opérateurs binaires et logiques.

PARTAGER CETTE PAGE SUR

Dernière mise à jour : Jeudi, le 30 juillet 2020

	ABAP/4
	Ada
	Assembleur
	Assembly & bytecode
	ASP (Active Server Pages)
	Basic
	C
	C++
	C# (C Sharp)
	Cobol
	ColdFusion
	Fortran
	HTML
	Java
	JavaScript
	LISP
	Logo
	LotusScript
	Oberon
	Pascal
	Perl
	PHP
	PL/1
	Prolog
	Python
	Rebol
	REXX
	Ruby
	SAS
	NoSQL
	SQL
	Swift
	X++ (Axapta)

	Assembleur 370
	Assembleur 1802
	Assembleur 4004
	Assembleur 6502
	Assembleur 6800
	Assembleur 68000
	Assembleur 8080 et 8085
	Assembleur 8089
	Assembleur 80x86
	Assembleur AGC4
	Assembleur ARM
	Assembleur DPS 8000
	Assembleur i860
	Assembleur Itanium
	Assembleur MIPS
	Assembleur PDP-11
	Assembleur PowerPC
	Assembleur RISC-V
	Assembleur SPARC
	Assembleur SuperH
	Assembleur UNIVAC I
	Assembleur VAX
	Assembleur Z80
	Assembleur Z8000
	Assembleur z/Architecture

	CIL
	Jasmin
	LLVM
	MSIL
	Parrot
	P-Code (PCode)
	SWEET16

	ASP 1.0
	ASP 2.0
	ASP 3.0
	ASP.NET

	ABasiC (Amiga)
	Adam SmartBASIC
	Altair BASIC
	AmigaBASIC (Amiga)
	AMOS Basic (Amiga)
	Atari Basic (Atari 400, 600 XL, 800, 800XL)
	Basic Apple II (Integer BASIC/APPLESOFT)
	Basic Commodore 64 (CBM-BASIC)
	Basic Commodore 128 (BASIC 7.0)
	Basic Commodore VIC-20 (CBM-BASIC 2.0)
	Basic Coco 1 (Color Basic)
	Basic Coco 2 (Extended Color Basic)
	Basic Coco 3 (Extended Color Basic 2.0)
	BASICA (PC DOS)
	Basic Pro
	BBC BASIC
	Blitz BASIC (Amiga)
	DarkBASIC
	Dartmouth BASIC
	GFA-Basic (Atari ST/Amiga)
	GWBASIC (MS-DOS)
	Liberty BASIC
	Locomotive BASIC (Amstrad CPC)
	MSX-Basic
	Omikron Basic (Atari ST)
	Oric Extended Basic
	Power Basic
	Quick Basic/QBasic (MS-DOS)
	Sinclair BASIC (ZX80, ZX81, ZX Spectrum)
	ST BASIC (Atari ST)
	Turbo Basic
	Vintage BASIC
	VBScript
	Visual Basic (VB)
	Visual Basic .NET (VB .NET)
	Visual Basic pour DOS
	Yabasic

Section courante

A propos

Section administrative du site

Émulateur de microprocesseur 6502

Remarques

	C Shell Unix (csh)

	C pour Amiga
	C pour Atari ST
	C pour DOS
	C pour Falcon030
	C pour GEMDOS (Atari ST)
	C pour Linux
	C pour PowerTV OS
	C pour OS/2
	C pour Unix
	C pour Windows

	Aztec C
	CoCo-C
	GNU C
	HiSoft C
	IBM C/2
	Introl-C
	Lattice C
	Microsoft C
	MinGW C
	MSX-C
	Open Watcom C
	OS-9 C Compiler
	Pure C
	Quick C
	Turbo C

	C++ pour OS/2
	C++ pour Windows

	Borland C++
	C++Builder
	IBM VisualAge C++
	Intel C++
	MinGW C++
	Open Watcom C++
	Symantec C++
	Turbo C++
	Visual C++
	Visual C++ .NET
	Watcom C++
	Zortech C++

	Apple Pascal
	Delphi/Kylix/Lazarus
	Free Pascal
	GNU Pascal
	HighSpeed Pascal
	IBM Personal Computer Pascal
	Lisa Pascal
	Maxon Pascal
	MPW Pascal
	OS-9 Pascal
	OSS Personal Pascal
	Pascal-86
	Pascal du Cray Research
	Pascal/VS
	Pascal-XT
	PURE Pascal
	QuickPascal
	RemObjets Chrome
	Sun Pascal
	THINK Pascal
	Tiny Pascal (TRS-80)
	Turbo Pascal
	UCSD Pascal
	VAX Pascal
	Virtual Pascal

	Turbo Pascal for CP/M-80
	Turbo Pascal for DOS
	Turbo Pascal for Macintosh
	Turbo Pascal for Windows

	CodeIgniter (Cadre d'application)
	Drupal (Projet)
	Joomla! (Projet)
	Phalanger (PHP .NET)
	phpBB (Projet)
	Smarty (balise)
	Twig (balise)
	Symfony (Cadre d'application)
	WordPress (Projet)
	Zend (Cadre d'application)

	Btrieve
	Cassandra
	Clipper
	CouchDB
	dBASE
	Hbase
	Hypertable
	MongoDB
	Redis

	Access
	BigQuery
	DB2
	H2
	Interbase
	MySQL
	Oracle
	PostgreSQL
	SAP HANA
	SQL Server
	Sybase
	U-SQL

	Introduction
	Les remarques
	Les opérateurs
	Les instructions conditionnelles
	Les instructions de boucles
	Type de données
	Référence des unités
	Références de mots réservés (mots clefs)
	Définition de procédure et fonction
	Référence de procédures et fonctions
	Référence des directives de compilation

	CRT
	DOS
	GRAPH
	OBJECTS
	OVERLAY
	PRINTER
	STRINGS
	SYSTEM
	TURBO3
	WINDOS

	Les premiers pas
	Les jetons
	Les constantes
	Les types
	Variables et constantes typées
	Les expressions
	Les instructions
	Blocs, localité et étendue
	Procédures et fonctions
	Programmes et unités
	Vue d'ensemble de la bibliothèque d'exécution
	Procédures et fonctions standard
	Entrée et sortie
	Utilisation du 80x87
	Interfaçage avec DOS
	Utilisation de chaînes de caractères terminées par NULL
	Utilisation de l'interface graphique Borland
	Utilisation de recouvrement
	Problèmes de mémoire
	Problèmes de contrôle
	Optimiser votre code
	L'assembleur intégré
	Liaison de code assembleur
	Programmation orientée objet (POO)

	GNAT
	SMALLAda
	VHDL

	ASSEMBLER/MONITOR 64
	Micol Assembler

	A86
	MASM (Macro Assembler)
	TASM (Turbo Assembler)

	BeckerBASIC
	SIMONS' BASIC

	Bonjour
	Affichage
	Astronomie
	Biochimie
	Chimie
	Conversion
	Électrotechnique
	Emulateur
	Fichiers
	Finance
	Géographie
	Géophysique
	Géométrie
	Histoire
	Jeux & stratégies
	Mathématique
	Matrice
	Médicale
	Météorologie
	Océanographie
	Onirologie
	Sport
	Temps
	Tri
	Trigonométrie
	Validation

	Aire d'un cercle
	Aire d'une surface de prisme rectangulaire
	Aire d'un triangle
	Distance entre deux points
	Treillis

	Asteroids
	Bowling
	Breakout
	Lode Runner
	Missile Command
	Pac-Man
	Patience
	Peg Leap
	Soko-Ban
	Space Invaders
	Space Jockey
	Tetris
	Tic-Tac-Toe
	Tours d'Hanois

	Ackermann
	Exp
	Factoriel
	Fibonacci
	Log
	Nombre premier
	Odd
	Random
	Sqrt
	Triangle Pascal

	Année bissextile
	Calendrier
	Date de la Pâque
	FirstDayOfMonth
	Horloge à aiguille

	AMDEKSYSTEM88LIB-TP
	APMLIB-TP
	BASICSTRLIB-TP
	BIOSLIB-TP
	COLORIMETRYLIB-TP
	CSVLIB-TP
	CYRIXLIB-TP
	DRDOSLIB-TP
	ELECTRICLIB-TP
	ERLOGLIB-TP
	FINANCIALLIB-TP
	GEOLIB-TP
	GRAPHICSSOLUTIONLIB-TP
	HDLLIB-TP
	HISTORICLIB-TP
	HTMLLIB-TP
	IALIB-TP
	INTLLIB-TP
	JSONLIB-TP
	K8042LIB-TP
	LETTRESLIB-TP
	LOTUSSCRIPTSTRLIB-TP
	METEOLIB-TP
	OCEANOGRAPHICLIB-TP
	OS2LIB-TP
	OSSPASCALLIB-TP
	POSIX-TP
	PYTHONLIB-TP
	SANE-TP
	SNOBOLLIB-TP
	SVGLIB-TP
	TPW4TPLIB-TP
	TSENGLABSET4000LIB-TP
	VGALIB-TP
	WINDOWS9XLIB-TP
	XMLLIB-TP

	AlimBase
	AMIGADOS-0
	AXTRO
	Colorix
	Corail
	COREUTILS-0
	DEV-COOLS
	EDUX
	FLEX-0
	GEO-COMMANDER
	HISTORIK
	lettrex
	LINUX-0
	MATHIX
	METEOPOLIS
	Micro Calc
	MYSTIX
	Monsterbook
	MSDOS-0
	MSXDOS-0
	OS9-0
	Renegade BBS
	Système Information
	TRSDOS-0
	Turbo Calc
	UNIX-0
	VIE

	Base de connaissances

	Table ASCII
	Table de codes ANSI et page de codes
	RAM de l'IBM PC

	Code d'erreur

	Génération du code en interne du Turbo Pascal 3
	Code source du Turbo Pascal 6
	TPU
	OBJ

	Archives de paquet
	Alternative

	Bibliographie

	Turbo Pascal à FreeDOS/FreePascal
	Turbo Pascal à Linux/FreePascal
	Turbo Pascal à FreeBSD/FreePascal
	Turbo Pascal à eComStation/FreePascal