Langage de programmation - Assembleur 6502

Directives assembleur

Les directives assembleur (aussi appelées pseudo-instructions ou pseudo-opcodes) ne génèrent pas de code machine directement mais contrôlent le processus d'assemblage : définition de données, organisation mémoire, symboles, macros et génération de listing.

Cette page documente les directives supportées par l'assembleur 6502 comme par exemple l'ASM6502.PAS inclus dans le projet DEV-COOLS. Les conventions de syntaxe sont proches de celles des assembleurs Motorola et Atari, avec des synonymes provenant de différentes traditions (Motorola, MOS Technology, Commodore, Apple,...).

Vue d'ensemble

Le ASM6502.PAS est un assembleur 6502 a deux passes écrit en Pascal. Il accepte un fichier source en entrée et produit un listing et un fichier objet binaire en sortie.

Syntaxe d'invocation :

ASM6502 [options] fichier_source [options]

L'assembleur effectue :

Passe 1 : résolution des symboles et calcul des adresses
Passe 2 : génération du code et du listing

Format d'une ligne source :

[etiquette] [opcode/directive] [operandes] [; commentaire]

Règles de formatage :

Une étiquette doit commencer en colonne 1 (aucun espace avant)
Si la ligne commence par un espace ou une tabulation, il n'y a pas d'étiquette.
Une ligne commençant par '*' en colonne 1 est un commentaire
Un ';' débute un commentaire jusqu'à la fin de la ligne
Les opcodes et directives sont insensibles a la casse
Une étiquette peut être suivie de ':' (optionnel)

Exemple de programme minimal :



        ORG  $C000        ; adresse de debut
start:  LDA  #$41         ; charger 'A' dans l'accumulateur
        JSR  $FFD2        ; appeler la routine d'affichage
        RTS               ; retour
        END               ; fin du source

Récapitulatif des directives supportées :

Directive	Synonymes	Type	Description
DB	FCB, BYTE	Données	Définir octet(s)
DW	FDB, WORD	Données	Définir mot(s) 16 bits
DS	RMB, BLKB	Données	Réserver de l'espace
FCC	-	Données	Chaîne de caractères
EQU	=	Contrôle	Définir symbole constant
SET	-	Contrôle	Definir symbole modifiable
ORG	AORG	Contrôle	Adresse absolue d'assemblage
RORG	-	Contrôle	Adresse relative d'assemblage
END	-	Contrôle	Fin du source
LIST	-	Listing	Contrôle du listing
OPT	-	Listing	Options de listing
MACRO	-	Macros	Début de définition de macro
ENDM	-	Macros	Fin de définition de macro

Directives de données

DB / FCB / BYTE - Define Byte (Définir octet)

Réservé et initialisé un ou plusieurs octets en mémoire. Les trois mnémoniques sont synonymes :

Mnémonique	Convention
DB	Notation Intel/Zilog
FCB	Form Constant Byte (notation Motorola)
BYTE	Notation générique

Syntaxe :

[etiquette] DB valeur[,valeur,...]

[etiquette] FCB valeur[,valeur,...]

[etiquette] BYTE valeur[,valeur,...]

Chaque valeur peut être :

Une constante numérique (8 bits, 0-255 ou -128..127)
Une expression arithmétique
Une chaîne de caractères entre apostrophes

Exemples :



octet1   DB   $41           ; un octet = 65 = 'A'
octets   DB   1,2,3,4,5    ; cinq octets consecutifs
mixte    DB   'A',0,$FF    ; caractere, zero, $FF
chaine   DB   'Hello',0    ; chaine terminee par zero
expr     DB   base+3       ; expression evaluee a l'assemblage
negatif  DB   -1           ; un octet = $FF

Les chaînes entre apostrophes sont décomposées en octets ASCII individuels. Pour inclure une apostrophe dans une chaîne, la doubler : DB 'l''art' produit les octets $6C,$27,$61,$72,$74.

Codage mémoire de DB 'AB',0,$FF :

Adresse	Contenu	Description
$xxxx	$41	'A'
$xxxx+1	$42	'B'
$xxxx+2	$00	zero
$xxxx+3	$FF	$FF

DW / FDB / WORD - Define Word (Définir mot 16 bits)

Réservé et initialisé un ou plusieurs mots de 16 bits en mémoire. Les mots sont stockes en format little-endian (octet de poids faible en premier), conformément a l'architecture du 6502.

Les trois mnémoniques sont synonymes :

Réservé et initialisé un ou plusieurs octets en mémoire. Les trois mnémoniques sont synonymes :

Mnémonique	Convention
DW	Notation Intel/Zilog
FDB	Form Double Byte (notation Motorola)
WORD	Notation générique

Syntaxe :

[etiquette] DW valeur[,valeur,...]

[etiquette] FDB valeur[,valeur,...]

[etiquette] WORD valeur[,valeur,...]

Chaque valeur est une expression 16 bits (0-65535 ou -32768..32767).

Exemples :



adresse  DW   $C000          ; un mot = $C000
vecteur  DW   start          ; adresse du symbole 'start'
table    DW   sub1,sub2,sub3 ; table de 3 adresses
calcul   DW   fin-debut      ; expression (difference d'adresses)

Codage mémoire de DW $1234,$ABCD :

Adresse	Contenu	Description
$xxxx	$34	octet bas de $1234
$xxxx+1	$12	octet haut de $1234
$xxxx+2	$CD	octet bas de $ABCD
$xxxx+3	$AB	octet haut de $ABCD

Utilisation typique - table de vecteurs :



; Table de saut pour un menu a 4 choix
JmpTable:
  DW  Option0        ; adresse du descripteur 0
  DW  Option1        ; adresse du descripteur 1
  DW  Option2        ; adresse du descripteur 2
  DW  Option3        ; adresse du descripteur 3
 
; Vecteurs d'interruption (a placer a $FFFA)
		ORG  $FFFA
		DW   NMI_Handler   ; vecteur NMI ($FFFA-$FFFB)
		DW   Reset_Handler ; vecteur RESET ($FFFC-$FFFD)
		DW   IRQ_Handler   ; vecteur IRQ/BRK ($FFFE-$FFFF)

DS / RMB / BLKB - Define Storage (Réserver de l'espace)

Réservé un bloc de mémoire sans l'initialiser. L'assembleur avance simplement le compteur d'adresses de la taille spécifiée sans générer d'octets dans le fichier de sortie.

Les trois mnémoniques sont synonymes :

Mnémonique	Description
DS	Define Storage
RMB	Reserve Memory Bytes (notation Motorola)
BLKB	Block Bytes

Syntaxe :

[etiquette] DS nombre_octets

[etiquette] RMB nombre_octets

[etiquette] BLKB nombre_octets

Le nombre_octets est une expression constante.

Exemples :



buffer   DS   256         ; reserver 256 octets
tampon   RMB  64          ; reserver 64 octets
espace   BLKB 128         ; reserver 128 octets
var1     DS   1           ; reserver 1 octet (variable)
var16    DS   2           ; reserver 2 octets (variable 16 bits)

Dans le listing, DS affiche la taille réservée entre parenthèses au lieu du contenu mémoire :



C100:  (0100)          buffer   DS   256

Notes :

L'espace réservé n'est pas initialise (contenu indéterminé)
Utile pour les variables en RAM
Ne produit aucun octet dans le fichier binaire de sortie
En ROM, les octets réservés auront la valeur $FF (typiquement)

FCC - Form Constant Character string (Chaîne de caractères)

FCC définit une chaîne de caractères en utilisant un délimiteur choisi par le programmeur. Le premier caractère après FCC (et les espaces) sert de délimiteur ; la chaîne se termine au prochain occurrence de ce délimiteur.

Syntaxe :

[etiquette] FCC delimiteur texte delimiteur

Le délimiteur peut être n'importe quel caractère. Les délimiteurs courants sont /, ", |, !,...

Exemples :



msg1   FCC  /Hello, World!/     ; delimiteur '/'
msg2   FCC  "Bonjour"           ; delimiteur '"'
msg3   FCC  |Texte|             ; delimiteur '|'
msg4   FCC  !Test!              ; delimiteur '!'

Pour inclure le caractère délimiteur dans la chaîne, le doubler :



msg5   FCC  /Fichier d//entree/  ; produit : Fichier d/entree

FCC produit un octet par caractère (code ASCII). Contrairement a DB avec une chaîne, FCC ne permet pas de mélanger des valeurs numériques et des caractères dans la même directive.

Codage mémoire de FCC /ABC/ :

Adresse	Contenu	Description
$xxxx	$41	'A'
$xxxx+1	$42	'B'
$xxxx+2	$43	'C'

Utilisation typique :



message  FCC  /Appuyez sur une touche.../
         DB   $0D,$0A,0    ; retour chariot + saut de ligne + zero

Comparaison DB vs FCC :

Directive	Avantage	Limitation
DB	Mélange octets et chaînes	Chaînes entre apostrophes
FCC	Délimiteur libre	Chaînes uniquement

Directives de contrôle

ORG / AORG - Origin (Adresse absolue d'assemblage)

ORG définit l'adresse a laquelle le code ou les données suivants seront assembles. AORG (Absolute Origin) est un synonyme.

Syntaxe :

ORG adresse

AORG adresse

L'adresse est une expression constante (16 bits, $0000-$FFFF).

Exemples :



ORG   $C000          ; assembler a partir de $C000
ORG   $FFFA          ; vecteurs d'interruption
 
; Programme complet avec ORG
        ORG  $0600         ; zone libre sur beaucoup de systemes
start:  LDA  #$00
        STA  $D020         ; couleur de bordure (C64)
        RTS
        ORG  $FFFC
        DW   start          ; vecteur RESET

Notes :

ORG peut apparaître plusieurs fois dans un source
Chaque ORG redéfinit l'adresse d'assemblage courante
Si aucun ORG n'est spécifié, l'assemblage commence a $0000
ORG ne génère pas de code, il positionne le compteur
AORG est identique a ORG (synonyme pour compatibilité)

RORG - Relative Origin (Adresse relative d'assemblage)

RORG définit une adresse relative (offset) pour le code suivant. Le code est généré à la position courante dans le fichier de sortie, mais les références d'adresses sont calculées comme si le code était a l'adresse spécifiée.

Syntaxe :

RORG adresse

Cela permet de générer du code relocalisable étant chargé à une adresse différente de celle d'assemblage.

Exemple :



; Code assemble dans le fichier a la suite du code precedent,
; mais avec des adresses calculees pour $8000
RORG  $8000
; Les references symboliques utiliseront des adresses $8000+

Dans le listing, RORG affiche les deux adresses :

8000 = 0200 RORG $8000

(adresse logique $8000, position physique $0200 dans le fichier)

EQU / = - Equate (Définir symbole constant)

EQU définit un symbole avec une valeur constante. Le symbole '=' est un synonyme de EQU.

Syntaxe :

etiquette EQU expression
etiquette = expression

L'étiquette est OBLIGATOIRE (une erreur est générée sinon). La valeur est une expression 16 bits résolue a l'assemblage. Un symbole défini par EQU ne peut PAS être redéfini.

Exemples :



CHROUT   EQU  $FFD2         ; adresse de la routine KERNAL
SCREEN   EQU  $0400         ; adresse de la memoire ecran
BORDER   EQU  $D020         ; registre de couleur bordure
MAXLEN   EQU  80            ; constante numerique
BUFSIZE  EQU  MAXLEN+2      ; expression
CR       =    $0D           ; retour chariot
LF       =    $0A           ; saut de ligne
CRLF     =    CR*256+LF     ; les deux combines

Utilisation typique :



; Definir les adresses du materiel (Commodore 64)
VIC_BASE EQU  $D000
VIC_CTRL EQU  VIC_BASE+$11  ; registre de controle ($D011)
VIC_RSTR EQU  VIC_BASE+$12  ; registre raster ($D012)
CIA1     EQU  $DC00
CIA2     EQU  $DD00
 
; Utilisation dans le code
                LDA  VIC_RSTR       ; lire la position du raster
                CMP  #$80
                BNE  wait

Dans le listing, EQU affiche la valeur avec '=' :

= D020 BORDER EQU $D020

Notes :

Une tentative de redéfinition d'un symbole EQU génère une erreur
Le symbole est marque 'E' dans la table des symboles
EQU est évalué en passe 1 ; les références avant sont autorisées si elles sont résolues en passe 2

SET - Définir symbole modifiable

SET est similaire a EQU mais permet de redéfinir le symbole avec une nouvelle valeur plus tard dans le source.

Syntaxe :

etiquette SET expression

Exemples :



compteur SET  0             ; valeur initiale
         DB   compteur      ; genere 0
compteur SET  compteur+1    ; incrementer
         DB   compteur      ; genere 1
compteur SET  compteur+1    ; incrementer encore
         DB   compteur      ; genere 2

Notes :

SET est utile pour créer des compteurs ou des variables d'assemblage
Le symbole est marque 'S' dans la table des symboles
A la différence de EQU, la redéfinition est autorisée

Comparaison EQU vs SET :

Propriété	EQU	SET
Redéfinition	Interdite	Autorisée
Marqueur symbole	E	S
Usage typique	Constantes	Compteurs

END - Fin du source

END signale la fin du fichier source. Tout ce qui suit la directive END est ignore par l'assembleur (sauf les directives LIST et OPT).

Syntaxe :

END [adresse_execution]

Si une adresse d'exécution est spécifiée, elle est enregistrée comme point d'entrée du programme dans le fichier objet.

Exemples :



END               ; fin du source, pas d'adresse d'execution
END  start        ; fin du source, execution a 'start'
END  $C000        ; fin du source, execution a $C000

Dans le listing avec adresse d'exécution :

(C000) END $C000

Notes :

END est optionnel ; l'assembleur traite aussi la fin physique du fichier comme fin du source
Après END, seules les directives LIST et OPT sont traitées
END n'est pas autorise a l'intérieur d'une macro

Directives de listing

LIST - Contrôle du listing

LIST contrôle la génération du fichier listing pendant l'assemblage (passe 2).

Syntaxe :

LIST ON|OFF|MACRO|NOMACRO

Options :

Option	Effet
ON	Active la génération du listing
OFF	Désactive la génération du listing
MACRO	Active le listing des expansions de macros
NOMACRO	Désactive le listing des expansions de macros

Exemples :



LIST  OFF             ; desactiver le listing
; ... code qui ne sera pas liste ...
LIST  ON              ; reactiver le listing
 
LIST  MACRO           ; montrer l'expansion des macros
; ... appels de macros avec expansion visible ...
LIST  NOMACRO         ; masquer l'expansion des macros

Notes :

Par défaut, le listing est ON et les macros sont NOMACRO
La directive LIST elle-même est toujours listée, même si le listing était désactivé (pour montrer le changement)
LIST ne prend pas d'étiquette

OPT - Options de listing

OPT est une directive alternative pour contrôler le listing, compatible avec la syntaxe Motorola.

Syntaxe :

OPT LIST|NOLIST

Options :

Option	Effet
LIST	Active la génération du listing (= LIST ON)
NOLIST	Désactive la génération du listing (= LIST OFF)

Exemples :



OPT  NOLIST           ; desactiver le listing
; ... tables de donnees volumineuses ...
OPT  LIST             ; reactiver le listing

Notes :

OPT est un synonyme partiel de LIST
OPT ne supporte pas les options MACRO/NOMACRO
OPT ne prend pas d'étiquette
La directive OPT elle-même est toujours listée

Comparaison LIST vs OPT :

Fonctionnalité	LIST	OPT
Activer listing	LIST ON	OPT LIST
Désactiver listing	LIST OFF	OPT NOLIST
Activer macros	LIST MACRO	(non supporté)
Désactiver macros	LIST NOMACRO	(non supporté)

Macros (MACRO, ENDM)

MACRO - Début de définition de macro

MACRO définit une macro-instruction qui peut être ensuite appelée comme un opcode ordinaire. Lors de l'appel, le corps de la macro est expanse (substitue) dans le code source.

Syntaxe :

nom  MACRO  [param1[,param2[,...]]]
     ; corps de la macro (instructions et directives)
     ENDM

Le nom de la macro est l'étiquette de la ligne MACRO. Les paramètres sont des noms symboliques qui seront remplaces par les arguments lors de l'appel.

Exemple de définition :



; Macro pour charger un mot 16 bits dans A:X
LOAD16  MACRO  addr
        LDA    addr       ; octet bas dans A
        LDX    addr+1     ; octet haut dans X
        ENDM
 
; Macro pour sauvegarder un mot 16 bits
STORE16 MACRO  addr
        STA    addr       ; stocker octet bas
        STX    addr+1     ; stocker octet haut
        ENDM

Utilisation (appel de macro) :



LOAD16  $0080             ; expanse en LDA $0080 / LDX $0081
STORE16 $0082             ; expanse en STA $0082 / STX $0083

Paramètres de macros

Les paramètres sont substitues textuellement lors de l'expansion. Chaque occurrence du nom de paramètre dans le corps de la macro est remplacée par l'argument correspondant.

Exemple avec plusieurs paramètres :



; Macro pour additionner deux octets et entreposer le resultat
ADD_STORE MACRO  src1,src2,dest
          CLC
          LDA    src1
          ADC    src2
          STA    dest
          ENDM
 
; Appel
ADD_STORE  score_lo,bonus_lo,total_lo
 
; Se developpe en :
;         CLC
;         LDA    score_lo
;         ADC    bonus_lo
;         STA    total_lo

Règles :

Les arguments sont séparés par des virgules
Le nombre d'arguments doit correspondre au nombre de paramètres
La substitution est purement textuelle
Les macros imbriquées ne sont pas prises en charge (une erreur est générée si un appel de macro est rencontre pendant l'expansion d'une autre macro)

ENDM - Fin de définition de macro

ENDM signale la fin du corps de la macro. Un ENDM sans MACRO correspondant génère une erreur.

Notes sur les macros :

Une macro peut contenir n'importe quelle instruction ou directive, sauf END
Une macro ne peut pas être définie à l'intérieur d'une autre macro
La directive END n'est pas autorisée dans le corps d'une macro
Les étiquettes dans les macros devraient utiliser des étiquettes locales (@) pour éviter les conflits de noms lors d'appels multiples
Avec LIST MACRO, l'expansion complète est visible dans le listing
Avec LIST NOMACRO (défaut), seule la ligne d'appel apparaît

Exemple complet avec macros



; Definir des macros utilitaires
PUSH_AXY MACRO
         PHA
         TXA
         PHA
         TYA
         PHA
         ENDM
 
PULL_AXY MACRO
         PLA
         TAY
         PLA
         TAX
         PLA
         ENDM
 
INC16    MACRO  var
         INC    var
         BNE    @skip

         INC    var+1
@skip

         ENDM
 
; Utilisation dans le code
         ORG    $C000
handler: PUSH_AXY           ; sauvegarder les registres
         INC16  counter     ; incrementer un compteur 16 bits
         PULL_AXY           ; restaurer les registres
         RTS
 
counter: DW     0
         END

Étiquettes et symboles

Étiquettes standard

Une étiquette est un nom symbolique associe a une adresse mémoire. Elle commence en colonne 1 de la ligne source et peut être suivie de ':' (optionnel).

Syntaxe :

etiquette opcode operande

etiquette: opcode operande

Règles de nommage :

Commence par une lettre (A-Z, a-z), '@' ou '_'
Contient des lettres, chiffres (0-9), '@' ou '_'
Longueur maximale : limitée par la taille du type SymStr
Insensible a la casse (convertie en majuscules)

Exemples :



start    LDA #$00        ; 'start' = adresse de cette instruction
loop:    INX             ; 'loop' = adresse de cette instruction
data     DB  1,2,3       ; 'data' = adresse du premier octet
_temp    DS  4           ; '_temp' est une etiquette valide

Une étiquette seule sur une ligne (sans opcode) est valide :



ma_routine
		 PHA              ; 'ma_routine' = adresse du PHA
		 ; ...
		 RTS

Étiquettes locales (@)

Les étiquettes commençant par '@' sont des étiquettes locales. Elles sont automatiquement préfixées par la dernière étiquette globale rencontrée, ce qui évite les conflits de noms.

Syntaxe :

@nom_local

Mécanisme interne : si la dernière étiquette globale est 'ROUTINE', alors '@loop' est stocke comme 'ROUTINE@loop' dans la table des symboles.

Exemple :



routine1
         LDX  #$10
@loop    DEX              ; stocke comme 'routine1@loop'
         BNE  @loop       ; reference 'routine1@loop'
         RTS
 
routine2
         LDY  #$20
@loop    DEY              ; stocke comme 'routine2@loop'
         BNE  @loop       ; reference 'routine2@loop'
         RTS

Sans étiquettes locales, il faudrait utiliser des noms différents (loop1, loop2) pour éviter l'erreur de définition multiple.

Table des symboles

L'assembleur maintient une table des symboles contenant :

Le nom du symbole
Sa valeur (adresse ou constante, 16 bits)
Des drapeaux : défini/non défini, EQU, SET, multi-défini

La table des symboles est affichée à la fin du listing, triée par ordre alphabétique :

NOM_SYMBOLE     VALEUR  FLAGS
--------------- ------  -----
BORDER          D020    E        ; E = symbole EQU
COMPTEUR        0003    S        ; S = symbole SET
HANDLER         C000             ; (pas de flag = etiquette)
INCONNU         0000    U        ; U = non defini (erreur)
MULTI           C010    M        ; M = definition multiple

Drapeaux :

U : symbole référence mais jamais défini (erreur)
M : symbole défini plusieurs fois (erreur si pas SET)
S : symbole défini par SET (redéfinition autorisée)
E : symbole défini par EQU (constante)

Expressions et opérateurs

L'assembleur supporte des expressions arithmétiques et logiques dans les opérandes et les directives. Les expressions sont évaluées en arithmétique 16 bits signée.

Opérateurs arithmétiques

Opérateur	Précédence	Description	Exemple
-	(unaire)	Négation	-1 = $FFFF
+	(unaire)	Positif (no-op)	+5 = 5
~	(unaire)	Complément a un	~$FF = $FF00
*	haute	Multiplication	3*4 = 12
/	haute	Division entière	10/3 = 3
%	haute	Modulo (reste)	10%3 = 1
+	basse	Addition	$10+$20 = $30
-	basse	Soustraction	$20-$10 = $10

Opérateurs binaires (bit a bit)

Opérateur	Précédence	Description	Exemple
&	très basse	ET binaire (AND)	$FF&$0F = $0F
\|	très basse	OU binaire (OR)	$F0\|$0F = $FF
<<	très basse	Décalage a gauche	$01<<4 = $10
>>	très basse	Décalage a droite	$80>>4 = $08

Opérateurs de sélection d'octet (unaires)

Opérateur	Description	Exemple
<	Octet de poids faible (low)	<$1234 = $34
>	Octet de poids fort (high)	>$1234 = $12

Ces opérateurs sont essentiels pour charger les parties basse et haute d'une adresse 16 bits dans des registres 8 bits :



LDA  #<adresse     ; charger l'octet bas de 'adresse' dans A
LDX  #>adresse     ; charger l'octet haut de 'adresse' dans X

Exemple complet :



ptr      EQU  $80          ; pointeur en page zero
target   EQU  $C000        ; adresse cible
 
; Initialiser le pointeur 16 bits
         LDA  #<target     ; A = $00 (octet bas de $C000)
         STA  ptr          ; stocker l'octet bas
         LDA  #>target     ; A = $C0 (octet haut de $C000)
         STA  ptr+1        ; stocker l'octet haut

Symbole special : compteur d'adresses

Les symboles '.' (point) et '*' (étoile) représentent la valeur courante du compteur d'adresses (location counter).

Exemples :



HERE     EQU  *           ; HERE = adresse courante
LENGTH   EQU  *-start     ; longueur depuis 'start'
 
; Boucle infinie
loop     JMP  *           ; sauter a soi-meme (= JMP loop)
 
; Table avec calcul de taille
table    DB   1,2,3,4,5
tablen   EQU  *-table     ; tablen = 5

Note : '*' en colonne 1 est un commentaire ; '*' dans une expression est le compteur d'adresses. Le contexte détermine l'interprétation.

Parenthèses

Les parenthèses '(' et ')' permettent de regrouper des sous-expressions pour contrôler l'ordre d'évaluation :



LDA  #(3+4)*2       ; = 14 (sans parentheses : 3+8 = 11)
DB   (fin-debut)/2  ; moitie de la taille

Note : dans le contexte des modes d'adressage du 6502, les parenthèses ont aussi un sens syntaxique (adressage indirect). L'assembleur distingue le contexte selon la position :



LDA  ($80),Y         ; adressage indirect indexe Y
LDA  #($80+$10)      ; expression parenthesee = $90

Ordre de précédence complet

Du plus prioritaire au moins prioritaire :

1. Opérateurs unaires : - + ~ < >
2. Multiplication, division, modulo : * / %
3. Addition, soustraction : + -
4. Opérateurs binaires : & | << >>

Les parenthèses outrepassent l'ordre de précédence.

Caractères littéraux

Un caractère entre apostrophes est évalué comme sa valeur ASCII :



LDA  #'A'           ; equivalent a LDA #$41
CMP  #'0'           ; equivalent a CMP #$30
DB   'Z'            ; equivalent a DB $5A

Formats numériques

L'assembleur ASM6502.PAS supporte quatre bases numériques pour les constantes, avec deux notations possibles pour chacune (préfixe ou suffixe).

Décimal (base 10)

Le format par défaut. Pas de préfixe ni suffixe requis, mais le suffixe 'D' peut être utilise pour la clarté.

Syntaxe :



nombre        ; decimal par defaut
nombreD       ; decimal explicite (suffixe D)

Exemples :



LDA  #100            ; decimal implicite
LDA  #100D           ; decimal explicite
DB   0,127,255       ; decimaux implicites
DW   1000            ; decimal implicite
DW   65535           ; valeur maximale 16 bits

Plage : 0 a 65535 (non signe) ou -32768 a 32767 (signe).

Hexadécimal (base 16)

Préfixe '$' (notation Motorola/MOS) ou suffixe 'H'.

Syntaxe :



$nombre       ; prefixe $ (Motorola)
nombreH       ; suffixe H
$             ; sans nombre = compteur d'adresses (locPtr)

Exemples :



LDA  #$FF            ; prefixe $
LDA  #0FFH           ; suffixe H (le 0 initial est recommande)
STA  $D020           ; adresse hexadecimale
DW   $FFFC           ; vecteur RESET
DB   $0A,$0D         ; LF, CR

Notes :

Les chiffres hexadécimaux sont A-F (ou a-f)
Avec le suffixe H, il est recommande de commencer par un chiffre (0FFH au lieu de FFH) pour éviter la confusion avec un nom de symbole
'$' seul (sans chiffres) représente le compteur d'adresses

Binaire (base 2)

Préfixe '%' ou suffixe 'B'.

Syntaxe :



%nombre       ; prefixe %
nombreB       ; suffixe B

Exemples :



LDA  #%10110011      ; prefixe %
LDA  #10110011B      ; suffixe B
AND  #%11110000      ; masquer les 4 bits de poids faible
ORA  #%00000001      ; mettre le bit 0 a 1
DB   %01010101       ; motif alterne

Le binaire est particulièrement utile pour :

Les masques de bits : AND #%11110000
Les registres hardware : LDA #%10000000
Les sprites et graphiques : DB %11111111

Octal (base 8)

Suffixe 'O'.

Syntaxe :



nombreO       ; suffixe O

Exemples :



LDA  #377O           ; octal 377 = decimal 255 = $FF
DB   101O            ; octal 101 = decimal 65 = 'A'
DW   177777O         ; octal 177777 = $FFFF

L'octal est rarement utilise en programmation 6502, mais il est supporté pour la compatibilité avec certains sources assembleur historiques.

Récapitulatif des formats numériques

Base	Préfixe	Suffixe	Exemples
Décimal	(aucun)	D	42, 255, 100D
Hexadécimal	$	H	$FF, $1234, 0FFH
Binaire	%	B	%10101010, 10101010B
Octal	(aucun)	O	377O, 101O

Equivalences entre assembleurs

Les différents assembleurs 6502 utilisent des conventions variées pour les formats numériques :

Format	ASM6502	ACME	CA65	DASM	Merlin
Décimal	42	42	42	42	42
Hexadécimal	$FF	$FF	$FF	$FF	$FF
Binaire	%1010	%1010	%1010	%1010	%1010
Octal	377O	-	-	-	-
Caractère	'A'	'A'	'A'	"A"	"A"

La notation préfixe '$' pour l'hexadécimal et '%' pour le binaire est quasi-universelle parmi les assembleurs 6502.

Dernière mise à jour : Mardi, le 24 mars 2026