Group 3 — File I/O Official

/* Lister le répertoire courant (groupe 3, fonction 1). */
#include <neo/api.h>

int main(void) {
    neo_file_list_directory();
    return 0;
}

PROG.NEO                        43 bytes.

// Lister le répertoire courant (groupe 3, fonction 1).
program liste;
uses crt, neo6502;
begin
  NeoShowDir;                                   // List Directory
  NeoWaitMessage;
end.

PROG.NEO                        132 bytes.

10 ' Lister le repertoire courant (groupe 3, fonction 1)
20 cat

prog.bas                        321 bytes.
boot                            <Dir>

; Lister le répertoire courant (groupe 3, fonction 1).
        .cpu "65c02"
        * = $0800
ControlPort    = $FF00             ; +0 groupe, +1 fonction, +2 erreur, +4.. paramètres
WaitMessage    = $FFF4             ; attend que la boîte aux lettres soit libre
WriteCharacter = $FFF1             ; affiche le caractère de A

start:  jsr WaitMessage
        lda #3
        ldx #1                     ; fonction 1 : List Directory
        jmp appel

; Affiche la chaîne terminée par 0 dont l'adresse est dans A (poids faible) et X (poids fort).
ecrire: sta ptr
        stx ptr+1
        ldy #0
_e:     lda (ptr),y
        beq _f
        jsr WriteCharacter
        iny
        bne _e
_f:     rts

; Affiche A (0-255) en décimal, sans zéros de tête.
decimal:
        phx
        phy
        ldx #0
        ldy #100
        jsr _chiffre
        ldy #10
        jsr _chiffre
        ora #'0'
        jsr WriteCharacter
        ply
        plx
        rts
_chiffre:
        sty diviseur
        ldy #0
_div:   cmp diviseur
        bcc _fini
        sbc diviseur
        iny
        bne _div
_fini:  pha
        tya
        bne _ecrit
        cpx #0
        beq _saute
_ecrit: ora #'0'
        jsr WriteCharacter
        ldx #1
_saute: pla
        rts

; Appel : A = groupe, X = fonction (les paramètres sont déjà en place).
appel:  stx ControlPort+1
        sta ControlPort            ; écrit en dernier : lance l'appel
        jmp WaitMessage

ptr      = $80
diviseur: .byte 0

PROG.NEO                        106 bytes.

/* Enregistrer un texte, puis le recharger (groupe 3, fonctions 3 et 2). */
#include <stdio.h>
#include <string.h>
#include <neo/api.h>

static char texte[16] = "Bonjour";
static char relu[16];

int main(void) {
    neo_file_store("salut.txt", texte, strlen(texte) + 1);   /* 3,3 : avec le zéro final */
    neo_file_load("salut.txt", relu);                      /* Load File */
    if (neo_api_error())
        printf("Erreur %u\n", neo_api_error());
    else
        printf("Charge : %s\n", relu);
    return 0;
}

Charge : Bonjour

// Enregistrer un texte, puis le recharger (groupe 3, fonctions 3 et 2).
program charger;
uses crt, neo6502;
var texte, relu: string[16];
    e: byte;
begin
  texte := 'Bonjour';
  NeoSave('salut.txt', word(@texte), length(texte) + 1);   // 3,3 : la chaîne Pascal entière
  if NeoLoad('salut.txt', word(@relu)) then             // Load File
    writeln('Charge : ', relu)
  else
  begin
    e := NeoMessage.error;                      // à lire avant writeln, qui passe par l'API
    writeln('Erreur ', e);
  end;
end.

Charge : Bonjour

10 ' Enregistrer un texte, puis le recharger (groupe 3, fonctions 3 et 2)
20 t = alloc(16) : n$ = "Bonjour" : a = t : poke a, len(n$) : for i = 1 to len(n$) : poke a + i, asc(mid$(n$, i, 1)) : next i
30 save "salut.txt", t, 8
40 r = alloc(16) : n$ = "salut.txt" : a = alloc(16) : poke a, len(n$) : for i = 1 to len(n$) : poke a + i, asc(mid$(n$, i, 1)) : next i
50 while peek($ff00) : wend
60 poke $ff04, a & 255 : poke $ff05, a >> 8 : poke $ff06, r & 255 : poke $ff07, r >> 8 : poke $ff01, 2 : poke $ff00, 3
70 while peek($ff00) : wend : e = peek($ff02)
80 s$ = "" : for i = 1 to peek(r) : s$ = s$ + chr$(peek(r + i)) : next i
90 if e = 0 then print "Charge : ";s$
100 if e <> 0 then print "Erreur ";e

Charge : Bonjour

; Enregistrer un texte, puis le recharger (groupe 3, fonctions 3 et 2).
        .cpu "65c02"
        * = $0800
ControlPort    = $FF00             ; +0 groupe, +1 fonction, +2 erreur, +4.. paramètres
WaitMessage    = $FFF4             ; attend que la boîte aux lettres soit libre
WriteCharacter = $FFF1             ; affiche le caractère de A

start:  jsr WaitMessage            ; 3,3 : créer le fichier
        lda #<nom
        sta ControlPort+4
        lda #>nom
        sta ControlPort+5
        lda #<texte
        sta ControlPort+6
        lda #>texte
        sta ControlPort+7
        lda #8                     ; 7 lettres + zéro final
        sta ControlPort+8
        stz ControlPort+9
        lda #3
        ldx #3
        jsr appel
        jsr WaitMessage
        lda #<nom
        sta ControlPort+4          ; P0-P1 : nom
        lda #>nom
        sta ControlPort+5
        lda #<relu
        sta ControlPort+6          ; P2-P3 : destination
        lda #>relu
        sta ControlPort+7
        lda #3
        ldx #2                     ; fonction 2 : Load File
        jsr appel
        lda #<m
        ldx #>m
        jsr ecrire
        lda #<relu
        ldx #>relu
        jsr ecrire
        lda #13
        jmp WriteCharacter

; Affiche la chaîne terminée par 0 dont l'adresse est dans A (poids faible) et X (poids fort).
ecrire: sta ptr
        stx ptr+1
        ldy #0
_e:     lda (ptr),y
        beq _f
        jsr WriteCharacter
        iny
        bne _e
_f:     rts

; Affiche A (0-255) en décimal, sans zéros de tête.
decimal:
        phx
        phy
        ldx #0
        ldy #100
        jsr _chiffre
        ldy #10
        jsr _chiffre
        ora #'0'
        jsr WriteCharacter
        ply
        plx
        rts
_chiffre:
        sty diviseur
        ldy #0
_div:   cmp diviseur
        bcc _fini
        sbc diviseur
        iny
        bne _div
_fini:  pha
        tya
        bne _ecrit
        cpx #0
        beq _saute
_ecrit: ora #'0'
        jsr WriteCharacter
        ldx #1
_saute: pla
        rts

; Appel : A = groupe, X = fonction (les paramètres sont déjà en place).
appel:  stx ControlPort+1
        sta ControlPort            ; écrit en dernier : lance l'appel
        jmp WaitMessage

ptr      = $80
diviseur: .byte 0

nom:    .byte 9
        .text "salut.txt"
texte:  .text "Bonjour", 0
relu:   .fill 16
m:      .text "Charge : ", 0

Charge : Bonjour

/* Enregistrer 7 octets, puis vérifier la taille du fichier (groupe 3, fonctions 3 et 16). */
/* neo_file_stat (llvm-mos, compilateur c798c31) rend une taille fausse : 3,16 est appelé directement. */
#include <stdio.h>
#include <neo6502.h>
#include <neo/api.h>

/* Appel brut de la boîte aux lettres : fonction puis groupe (écrit en dernier, il lance l'appel). */
static void api(uint8_t groupe, uint8_t fonction) {
    ControlPort.function = fonction;
    ControlPort.command = groupe;
    while (ControlPort.command)        /* attendre la fin */
        ;
}
static void libre(void) {              /* attendre que la boîte aux lettres soit libre */
    while (ControlPort.command)
        ;
}

static const uint8_t nom[] = "\x09" "salut.txt";      /* longueur, puis le nom */

int main(void) {
    neo_file_store("salut.txt", "Bonjour", 7);  /* Store File */
    libre();
    ControlPort.params[0] = (uint16_t)nom & 0xFF;
    ControlPort.params[1] = (uint16_t)nom >> 8;
    api(3, 16);                                 /* File Stat : taille en P0-P3 */
    uint32_t taille = ControlPort.params[0] | ((uint32_t)ControlPort.params[1] << 8)
                    | ((uint32_t)ControlPort.params[2] << 16) | ((uint32_t)ControlPort.params[3] << 24);
    printf("salut.txt : %lu octets\n", (unsigned long)taille);
    return 0;
}

salut.txt : 7 octets

// Enregistrer 7 octets, puis vérifier la taille du fichier (groupe 3, fonctions 3 et 16).
program sauver;
uses crt, neo6502;
var texte, nom: string[16];
    taille: cardinal;
    attr: byte;
begin
  texte := 'Bonjour';
  NeoSave('salut.txt', word(@texte) + 1, 7);    // Store File : les 7 lettres
  nom := 'salut.txt';
  if NeoStatFile(@nom, taille, attr) then       // 3,16 : taille
    writeln('salut.txt : ', taille, ' octets');
end.

salut.txt : 7 octets

10 ' Enregistrer 7 octets, puis verifier la taille du fichier (groupe 3, fonctions 3 et 16)
20 t = alloc(8) : for i = 1 to 7 : poke t + i - 1, asc(mid$("Bonjour", i, 1)) : next i
30 save "salut.txt", t, 7
40 n$ = "salut.txt" : a = alloc(16) : poke a, len(n$) : for i = 1 to len(n$) : poke a + i, asc(mid$(n$, i, 1)) : next i
50 while peek($ff00) : wend
60 poke $ff04, a & 255 : poke $ff05, a >> 8 : poke $ff01, 16 : poke $ff00, 3
70 while peek($ff00) : wend : s = peek($ff04) + 256 * peek($ff05)
80 print "salut.txt : ";s;" octets"

salut.txt : 7 octets

; Enregistrer 7 octets, puis vérifier la taille du fichier (groupe 3, fonctions 3 et 16).
        .cpu "65c02"
        * = $0800
ControlPort    = $FF00             ; +0 groupe, +1 fonction, +2 erreur, +4.. paramètres
WaitMessage    = $FFF4             ; attend que la boîte aux lettres soit libre
WriteCharacter = $FFF1             ; affiche le caractère de A

start:  jsr WaitMessage
        lda #<nom
        sta ControlPort+4          ; P0-P1 : nom
        lda #>nom
        sta ControlPort+5
        lda #<texte
        sta ControlPort+6          ; P2-P3 : données
        lda #>texte
        sta ControlPort+7
        lda #7
        sta ControlPort+8          ; P4-P5 : 7 octets
        stz ControlPort+9
        lda #3
        ldx #3                     ; fonction 3 : Store File
        jsr appel
        jsr WaitMessage
        lda #<nom
        sta ControlPort+4
        lda #>nom
        sta ControlPort+5
        lda #3
        ldx #16                    ; 3,16 : File Stat
        jsr appel
        lda ControlPort+4          ; taille (octet de poids faible)
        pha
        lda #<m1
        ldx #>m1
        jsr ecrire
        pla
        jsr decimal
        lda #<m2
        ldx #>m2
        jmp ecrire

; Affiche la chaîne terminée par 0 dont l'adresse est dans A (poids faible) et X (poids fort).
ecrire: sta ptr
        stx ptr+1
        ldy #0
_e:     lda (ptr),y
        beq _f
        jsr WriteCharacter
        iny
        bne _e
_f:     rts

; Affiche A (0-255) en décimal, sans zéros de tête.
decimal:
        phx
        phy
        ldx #0
        ldy #100
        jsr _chiffre
        ldy #10
        jsr _chiffre
        ora #'0'
        jsr WriteCharacter
        ply
        plx
        rts
_chiffre:
        sty diviseur
        ldy #0
_div:   cmp diviseur
        bcc _fini
        sbc diviseur
        iny
        bne _div
_fini:  pha
        tya
        bne _ecrit
        cpx #0
        beq _saute
_ecrit: ora #'0'
        jsr WriteCharacter
        ldx #1
_saute: pla
        rts

; Appel : A = groupe, X = fonction (les paramètres sont déjà en place).
appel:  stx ControlPort+1
        sta ControlPort            ; écrit en dernier : lance l'appel
        jmp WaitMessage

ptr      = $80
diviseur: .byte 0

nom:    .byte 9
        .text "salut.txt"
texte:  .text "Bonjour"
m1:     .text "salut.txt : ", 0
m2:     .text " octets", 13, 0

salut.txt : 7 octets

/* Créer un fichier sur le canal 1, y écrire, le fermer (groupe 3, fonctions 4, 9 et 5). */
#include <stdio.h>
#include <neo/api.h>

int main(void) {
    neo_file_open(1, "canal.txt", NEO_FILE_CREATE);     /* File Open, mode 3 */
    if (neo_api_error()) {
        printf("Ouverture impossible\n");
        return 0;
    }
    uint32_t n = neo_file_write(1, "Bonjour", 7);       /* 3,9 */
    neo_file_close(1);                                   /* 3,5 */
    printf("Ecrit : %lu octets\n", (unsigned long)n);
    return 0;
}

Ecrit : 7 octets

// Créer un fichier sur le canal 1, y écrire, le fermer (groupe 3, fonctions 4, 9 et 5).
program ouvrir;
uses crt, neo6502;
var nom, texte: string[16];
    n: word;
begin
  nom := 'canal.txt';
  texte := 'Bonjour';
  if not NeoOpenFile(1, @nom, 3) then           // File Open, mode 3 : créer
  begin
    writeln('Ouverture impossible');
    exit;
  end;
  n := NeoWriteFile(1, word(@texte) + 1, 7);    // 3,9
  NeoCloseFile(1);                              // 3,5
  writeln('Ecrit : ', n, ' octets');
end.

Ecrit : 7 octets

10 ' Creer un fichier sur le canal 1, y ecrire, le fermer (groupe 3, fonctions 4, 9 et 5)
20 n$ = "canal.txt" : a = alloc(16) : poke a, len(n$) : for i = 1 to len(n$) : poke a + i, asc(mid$(n$, i, 1)) : next i
30 d = alloc(8) : for i = 1 to 7 : poke d + i - 1, asc(mid$("Bonjour", i, 1)) : next i
40 while peek($ff00) : wend
50 poke $ff04, 1 : poke $ff05, a & 255 : poke $ff06, a >> 8 : poke $ff07, 3 : poke $ff01, 4 : poke $ff00, 3
60 while peek($ff00) : wend : e = peek($ff02)
70 if e then print "Ouverture impossible" : end
80 poke $ff04, 1 : poke $ff05, d & 255 : poke $ff06, d >> 8 : poke $ff07, 7 : poke $ff08, 0 : poke $ff01, 9 : poke $ff00, 3
90 while peek($ff00) : wend : n = peek($ff07) + 256 * peek($ff08)
100 close
110 print "Ecrit : ";n;" octets"

Ecrit : 7 octets

; Créer un fichier sur le canal 1, y écrire, le fermer (groupe 3, fonctions 4, 9 et 5).
        .cpu "65c02"
        * = $0800
ControlPort    = $FF00             ; +0 groupe, +1 fonction, +2 erreur, +4.. paramètres
WaitMessage    = $FFF4             ; attend que la boîte aux lettres soit libre
WriteCharacter = $FFF1             ; affiche le caractère de A

start:  jsr WaitMessage
        lda #1
        sta ControlPort+4          ; P0 : canal 1
        lda #<nom
        sta ControlPort+5          ; P1-P2 : nom
        lda #>nom
        sta ControlPort+6
        lda #3
        sta ControlPort+7          ; P3 : mode 3, créer
        lda #3
        ldx #4                     ; fonction 4 : File Open
        jsr appel
        lda ControlPort+2
        bne _err
        jsr WaitMessage
        lda #1
        sta ControlPort+4          ; canal 1
        lda #<texte
        sta ControlPort+5          ; P1-P2 : données
        lda #>texte
        sta ControlPort+6
        lda #7
        sta ControlPort+7          ; P3-P4 : 7 octets
        stz ControlPort+8
        lda #3
        ldx #9                     ; 3,9 : File Write
        jsr appel
        lda ControlPort+7          ; octets écrits
        sta ecrits
        jsr WaitMessage
        lda #1
        sta ControlPort+4
        lda #3
        ldx #5                     ; 3,5 : File Close
        jsr appel
        lda #<m1
        ldx #>m1
        jsr ecrire
        lda ecrits
        jsr decimal
        lda #<m2
        ldx #>m2
        jmp ecrire
_err:   lda #<err
        ldx #>err
        jmp ecrire

; Affiche la chaîne terminée par 0 dont l'adresse est dans A (poids faible) et X (poids fort).
ecrire: sta ptr
        stx ptr+1
        ldy #0
_e:     lda (ptr),y
        beq _f
        jsr WriteCharacter
        iny
        bne _e
_f:     rts

; Affiche A (0-255) en décimal, sans zéros de tête.
decimal:
        phx
        phy
        ldx #0
        ldy #100
        jsr _chiffre
        ldy #10
        jsr _chiffre
        ora #'0'
        jsr WriteCharacter
        ply
        plx
        rts
_chiffre:
        sty diviseur
        ldy #0
_div:   cmp diviseur
        bcc _fini
        sbc diviseur
        iny
        bne _div
_fini:  pha
        tya
        bne _ecrit
        cpx #0
        beq _saute
_ecrit: ora #'0'
        jsr WriteCharacter
        ldx #1
_saute: pla
        rts

; Appel : A = groupe, X = fonction (les paramètres sont déjà en place).
appel:  stx ControlPort+1
        sta ControlPort            ; écrit en dernier : lance l'appel
        jmp WaitMessage

ptr      = $80
diviseur: .byte 0

ecrits: .byte 0
nom:    .byte 9
        .text "canal.txt"
texte:  .text "Bonjour"
m1:     .text "Ecrit : ", 0
m2:     .text " octets", 13, 0
err:    .text "Ouverture impossible", 13, 0

Ecrit : 7 octets

/* Ouvrir puis fermer le canal 1 (groupe 3, fonction 5). */
#include <stdio.h>
#include <neo/api.h>

int main(void) {
    neo_file_open(1, "vide.txt", NEO_FILE_CREATE);  /* 3,4 */
    neo_file_close(1);                              /* File Close */
    printf("Canal 1 ferme, erreur %u\n", neo_api_error());
    return 0;
}

Canal 1 ferme, erreur 0

// Ouvrir puis fermer le canal 1 (groupe 3, fonction 5).
program fermer;
uses crt, neo6502;
var nom: string[16];
    e: byte;
begin
  nom := 'vide.txt';
  NeoOpenFile(1, @nom, 3);                      // 3,4
  NeoCloseFile(1);                              // File Close
  e := NeoMessage.error;                        // à lire avant writeln, qui passe par l'API
  writeln('Canal 1 ferme, erreur ', e);
end.

Canal 1 ferme, erreur 0

10 ' Ouvrir puis fermer le canal 1 (groupe 3, fonction 5)
20 n$ = "vide.txt" : a = alloc(16) : poke a, len(n$) : for i = 1 to len(n$) : poke a + i, asc(mid$(n$, i, 1)) : next i
30 m = 3 : while peek($ff00) : wend : poke $ff04, 1 : poke $ff05, a & 255 : poke $ff06, a >> 8 : poke $ff07, m : poke $ff01, 4 : poke $ff00, 3 : while peek($ff00) : wend
40 poke $ff04, 1 : poke $ff01, 5 : poke $ff00, 3
50 while peek($ff00) : wend : e = peek($ff02)
60 print "Canal 1 ferme, erreur ";e

Canal 1 ferme, erreur 0

; Ouvrir puis fermer le canal 1 (groupe 3, fonction 5).
        .cpu "65c02"
        * = $0800
ControlPort    = $FF00             ; +0 groupe, +1 fonction, +2 erreur, +4.. paramètres
WaitMessage    = $FFF4             ; attend que la boîte aux lettres soit libre
WriteCharacter = $FFF1             ; affiche le caractère de A

start:  lda #3
        jsr ouvrir
        jsr fermer                 ; fonction 5 : File Close
        lda ControlPort+2
        pha
        lda #<m
        ldx #>m
        jsr ecrire
        pla
        jsr decimal
        lda #13
        jmp WriteCharacter
; Ouvrir abc.txt sur le canal 1 dans le mode A.
ouvrir: pha
        jsr WaitMessage
        lda #1
        sta ControlPort+4          ; P0 : canal 1
        lda #<nom
        sta ControlPort+5          ; P1-P2 : nom
        lda #>nom
        sta ControlPort+6
        pla
        sta ControlPort+7          ; P3 : mode
        lda #3
        ldx #4                     ; 3,4 : File Open
        jmp appel

; Fermer le canal 1.
fermer: jsr WaitMessage
        lda #1
        sta ControlPort+4
        lda #3
        ldx #5                     ; 3,5 : File Close
        jmp appel

; Affiche la chaîne terminée par 0 dont l'adresse est dans A (poids faible) et X (poids fort).
ecrire: sta ptr
        stx ptr+1
        ldy #0
_e:     lda (ptr),y
        beq _f
        jsr WriteCharacter
        iny
        bne _e
_f:     rts

; Affiche A (0-255) en décimal, sans zéros de tête.
decimal:
        phx
        phy
        ldx #0
        ldy #100
        jsr _chiffre
        ldy #10
        jsr _chiffre
        ora #'0'
        jsr WriteCharacter
        ply
        plx
        rts
_chiffre:
        sty diviseur
        ldy #0
_div:   cmp diviseur
        bcc _fini
        sbc diviseur
        iny
        bne _div
_fini:  pha
        tya
        bne _ecrit
        cpx #0
        beq _saute
_ecrit: ora #'0'
        jsr WriteCharacter
        ldx #1
_saute: pla
        rts

; Appel : A = groupe, X = fonction (les paramètres sont déjà en place).
appel:  stx ControlPort+1
        sta ControlPort            ; écrit en dernier : lance l'appel
        jmp WaitMessage

ptr      = $80
diviseur: .byte 0

nom:    .byte 7
        .text "abc.txt"
abc:    .text "ABCDEFGH"

m:      .text "Canal 1 ferme, erreur ", 0

Canal 1 ferme, erreur 0

/* Lire l'octet en position 4 de ABCDEFGH (groupe 3, fonction 6). */
#include <stdio.h>
#include <neo/api.h>

int main(void) {
    char c;
    neo_file_store("abc.txt", "ABCDEFGH", 8);  /* 3,3 : le fichier de l'exemple */
    neo_file_open(1, "abc.txt", NEO_FILE_READ);
    neo_file_seek(1, 4);                        /* File Seek */
    neo_file_read(1, &c, 1);                    /* 3,8 */
    neo_file_close(1);
    printf("Octet a la position 4 : %c\n", c);
    return 0;
}

Octet a la position 4 : E

// Lire l'octet en position 4 de ABCDEFGH (groupe 3, fonction 6).
program seek;
uses crt, neo6502;
var texte, nom: string[16];
    c: byte;
begin
  texte := 'ABCDEFGH';
  NeoSave('abc.txt', word(@texte) + 1, 8);      // 3,3 : le fichier de l'exemple
  nom := 'abc.txt';
  NeoOpenFile(1, @nom, 0);
  NeoSeekPos(1, 4);                             // File Seek
  NeoReadFile(1, word(@c), 1);                  // 3,8
  NeoCloseFile(1);
  writeln('Octet a la position 4 : ', chr(c));
end.

Octet a la position 4 : E

10 ' Lire l'octet en position 4 de ABCDEFGH (groupe 3, fonction 6)
20 d = alloc(16) : for i = 1 to 8 : poke d + i - 1, 64 + i : next i : save "abc.txt", d, 8 : ' le fichier : ABCDEFGH
25 n$ = "abc.txt" : a = alloc(16) : poke a, len(n$) : for i = 1 to len(n$) : poke a + i, asc(mid$(n$, i, 1)) : next i
30 b = alloc(4) : m = 0 : while peek($ff00) : wend : poke $ff04, 1 : poke $ff05, a & 255 : poke $ff06, a >> 8 : poke $ff07, m : poke $ff01, 4 : poke $ff00, 3 : while peek($ff00) : wend
40 poke $ff04, 1 : poke $ff05, 4 : poke $ff06, 0 : poke $ff07, 0 : poke $ff08, 0 : poke $ff01, 6 : poke $ff00, 3
50 while peek($ff00) : wend
60 poke $ff04, 1 : poke $ff05, b & 255 : poke $ff06, b >> 8 : poke $ff07, 1 : poke $ff08, 0 : poke $ff01, 8 : poke $ff00, 3
70 while peek($ff00) : wend
80 close
90 print "Octet a la position 4 : ";chr$(peek(b))

Octet a la position 4 : E

; Lire l'octet en position 4 de ABCDEFGH (groupe 3, fonction 6).
        .cpu "65c02"
        * = $0800
ControlPort    = $FF00             ; +0 groupe, +1 fonction, +2 erreur, +4.. paramètres
WaitMessage    = $FFF4             ; attend que la boîte aux lettres soit libre
WriteCharacter = $FFF1             ; affiche le caractère de A

start:
        jsr WaitMessage            ; 3,3 : le fichier de l'exemple, ABCDEFGH
        lda #<nom
        sta ControlPort+4
        lda #>nom
        sta ControlPort+5
        lda #<abc
        sta ControlPort+6
        lda #>abc
        sta ControlPort+7
        lda #8
        sta ControlPort+8
        stz ControlPort+9
        lda #3
        ldx #3
        jsr appel
        lda #0
        jsr ouvrir                 ; lecture seule
        jsr WaitMessage
        lda #1
        sta ControlPort+4          ; P0 : canal 1
        lda #4
        sta ControlPort+5          ; P1-P4 : position 4
        stz ControlPort+6
        stz ControlPort+7
        stz ControlPort+8
        lda #3
        ldx #6                     ; fonction 6 : File Seek
        jsr appel
        jsr WaitMessage
        lda #1
        sta ControlPort+4
        lda #<octet
        sta ControlPort+5          ; P1-P2 : destination
        lda #>octet
        sta ControlPort+6
        lda #1
        sta ControlPort+7          ; P3-P4 : 1 octet
        stz ControlPort+8
        lda #3
        ldx #8                     ; 3,8 : File Read
        jsr appel
        jsr fermer
        lda #<m
        ldx #>m
        jsr ecrire
        lda octet
        jsr WriteCharacter
        lda #13
        jmp WriteCharacter
; Ouvrir abc.txt sur le canal 1 dans le mode A.
ouvrir: pha
        jsr WaitMessage
        lda #1
        sta ControlPort+4          ; P0 : canal 1
        lda #<nom
        sta ControlPort+5          ; P1-P2 : nom
        lda #>nom
        sta ControlPort+6
        pla
        sta ControlPort+7          ; P3 : mode
        lda #3
        ldx #4                     ; 3,4 : File Open
        jmp appel

; Fermer le canal 1.
fermer: jsr WaitMessage
        lda #1
        sta ControlPort+4
        lda #3
        ldx #5                     ; 3,5 : File Close
        jmp appel

; Affiche la chaîne terminée par 0 dont l'adresse est dans A (poids faible) et X (poids fort).
ecrire: sta ptr
        stx ptr+1
        ldy #0
_e:     lda (ptr),y
        beq _f
        jsr WriteCharacter
        iny
        bne _e
_f:     rts

; Affiche A (0-255) en décimal, sans zéros de tête.
decimal:
        phx
        phy
        ldx #0
        ldy #100
        jsr _chiffre
        ldy #10
        jsr _chiffre
        ora #'0'
        jsr WriteCharacter
        ply
        plx
        rts
_chiffre:
        sty diviseur
        ldy #0
_div:   cmp diviseur
        bcc _fini
        sbc diviseur
        iny
        bne _div
_fini:  pha
        tya
        bne _ecrit
        cpx #0
        beq _saute
_ecrit: ora #'0'
        jsr WriteCharacter
        ldx #1
_saute: pla
        rts

; Appel : A = groupe, X = fonction (les paramètres sont déjà en place).
appel:  stx ControlPort+1
        sta ControlPort            ; écrit en dernier : lance l'appel
        jmp WaitMessage

ptr      = $80
diviseur: .byte 0

nom:    .byte 7
        .text "abc.txt"
abc:    .text "ABCDEFGH"

octet:  .byte 0
m:      .text "Octet a la position 4 : ", 0

Octet a la position 4 : E

/* Position après avoir lu 3 octets (groupe 3, fonction 7). */
#include <stdio.h>
#include <neo/api.h>

int main(void) {
    char tampon[3];
    neo_file_store("abc.txt", "ABCDEFGH", 8);  /* 3,3 : le fichier de l'exemple */
    neo_file_open(1, "abc.txt", NEO_FILE_READ);
    neo_file_read(1, tampon, 3);                /* 3,8 */
    uint32_t pos = neo_file_tell(1);            /* File Tell */
    neo_file_close(1);
    printf("Position apres 3 octets lus : %lu\n", (unsigned long)pos);
    return 0;
}

Position apres 3 octets lus : 3

// Position après avoir lu 3 octets (groupe 3, fonction 7).
program tell;
uses crt, neo6502;
var texte, nom: string[16];
    tampon: array[0..2] of byte;
    pos: cardinal;
begin
  texte := 'ABCDEFGH';
  NeoSave('abc.txt', word(@texte) + 1, 8);      // 3,3 : le fichier de l'exemple
  nom := 'abc.txt';
  NeoOpenFile(1, @nom, 0);
  NeoReadFile(1, word(@tampon), 3);             // 3,8
  pos := NeoTellPos(1);                         // File Tell
  NeoCloseFile(1);
  writeln('Position apres 3 octets lus : ', pos);
end.

Position apres 3 octets lus : 3

10 ' Position apres avoir lu 3 octets (groupe 3, fonction 7)
20 d = alloc(16) : for i = 1 to 8 : poke d + i - 1, 64 + i : next i : save "abc.txt", d, 8 : ' le fichier : ABCDEFGH
25 n$ = "abc.txt" : a = alloc(16) : poke a, len(n$) : for i = 1 to len(n$) : poke a + i, asc(mid$(n$, i, 1)) : next i
30 b = alloc(4) : m = 0 : while peek($ff00) : wend : poke $ff04, 1 : poke $ff05, a & 255 : poke $ff06, a >> 8 : poke $ff07, m : poke $ff01, 4 : poke $ff00, 3 : while peek($ff00) : wend
40 poke $ff04, 1 : poke $ff05, b & 255 : poke $ff06, b >> 8 : poke $ff07, 3 : poke $ff08, 0 : poke $ff01, 8 : poke $ff00, 3
50 while peek($ff00) : wend
60 poke $ff04, 1 : poke $ff01, 7 : poke $ff00, 3
70 while peek($ff00) : wend : p = peek($ff05) + 256 * peek($ff06)
80 close
90 print "Position apres 3 octets lus : ";p

Position apres 3 octets lus : 3

; Position après avoir lu 3 octets (groupe 3, fonction 7).
        .cpu "65c02"
        * = $0800
ControlPort    = $FF00             ; +0 groupe, +1 fonction, +2 erreur, +4.. paramètres
WaitMessage    = $FFF4             ; attend que la boîte aux lettres soit libre
WriteCharacter = $FFF1             ; affiche le caractère de A

start:
        jsr WaitMessage            ; 3,3 : le fichier de l'exemple, ABCDEFGH
        lda #<nom
        sta ControlPort+4
        lda #>nom
        sta ControlPort+5
        lda #<abc
        sta ControlPort+6
        lda #>abc
        sta ControlPort+7
        lda #8
        sta ControlPort+8
        stz ControlPort+9
        lda #3
        ldx #3
        jsr appel
        lda #0
        jsr ouvrir
        jsr WaitMessage
        lda #1
        sta ControlPort+4
        lda #<tampon
        sta ControlPort+5
        lda #>tampon
        sta ControlPort+6
        lda #3
        sta ControlPort+7          ; lire 3 octets
        stz ControlPort+8
        lda #3
        ldx #8                     ; 3,8 : File Read
        jsr appel
        jsr WaitMessage
        lda #1
        sta ControlPort+4          ; P0 : canal 1
        lda #3
        ldx #7                     ; fonction 7 : File Tell
        jsr appel
        lda ControlPort+5          ; P1 : position (poids faible)
        sta pos
        jsr fermer
        lda #<m
        ldx #>m
        jsr ecrire
        lda pos
        jsr decimal
        lda #13
        jmp WriteCharacter
; Ouvrir abc.txt sur le canal 1 dans le mode A.
ouvrir: pha
        jsr WaitMessage
        lda #1
        sta ControlPort+4          ; P0 : canal 1
        lda #<nom
        sta ControlPort+5          ; P1-P2 : nom
        lda #>nom
        sta ControlPort+6
        pla
        sta ControlPort+7          ; P3 : mode
        lda #3
        ldx #4                     ; 3,4 : File Open
        jmp appel

; Fermer le canal 1.
fermer: jsr WaitMessage
        lda #1
        sta ControlPort+4
        lda #3
        ldx #5                     ; 3,5 : File Close
        jmp appel

; Affiche la chaîne terminée par 0 dont l'adresse est dans A (poids faible) et X (poids fort).
ecrire: sta ptr
        stx ptr+1
        ldy #0
_e:     lda (ptr),y
        beq _f
        jsr WriteCharacter
        iny
        bne _e
_f:     rts

; Affiche A (0-255) en décimal, sans zéros de tête.
decimal:
        phx
        phy
        ldx #0
        ldy #100
        jsr _chiffre
        ldy #10
        jsr _chiffre
        ora #'0'
        jsr WriteCharacter
        ply
        plx
        rts
_chiffre:
        sty diviseur
        ldy #0
_div:   cmp diviseur
        bcc _fini
        sbc diviseur
        iny
        bne _div
_fini:  pha
        tya
        bne _ecrit
        cpx #0
        beq _saute
_ecrit: ora #'0'
        jsr WriteCharacter
        ldx #1
_saute: pla
        rts

; Appel : A = groupe, X = fonction (les paramètres sont déjà en place).
appel:  stx ControlPort+1
        sta ControlPort            ; écrit en dernier : lance l'appel
        jmp WaitMessage

ptr      = $80
diviseur: .byte 0

nom:    .byte 7
        .text "abc.txt"
abc:    .text "ABCDEFGH"

tampon: .fill 3
pos:    .byte 0
m:      .text "Position apres 3 octets lus : ", 0

Position apres 3 octets lus : 3

/* Lire tout le fichier, en demandant plus qu'il n'y a (groupe 3, fonction 8). */
#include <stdio.h>
#include <neo/api.h>

int main(void) {
    char tampon[21] = { 0 };
    neo_file_store("abc.txt", "ABCDEFGH", 8);  /* 3,3 : le fichier de l'exemple */
    neo_file_open(1, "abc.txt", NEO_FILE_READ);
    uint16_t n = neo_file_read(1, tampon, 20);  /* File Read : 20 demandés */
    neo_file_close(1);
    printf("Lu : %s (%u octets sur 20 demandes)\n", tampon, n);
    return 0;
}

Lu : ABCDEFGH (8 octets sur 20 demandes)

// Lire tout le fichier, en demandant plus qu'il n'y a (groupe 3, fonction 8).
program lire;
uses crt, neo6502;
var texte, nom: string[16];
    tampon: string[20];
    n: word;
begin
  texte := 'ABCDEFGH';
  NeoSave('abc.txt', word(@texte) + 1, 8);      // 3,3 : le fichier de l'exemple
  nom := 'abc.txt';
  NeoOpenFile(1, @nom, 0);
  n := NeoReadFile(1, word(@tampon) + 1, 20);   // File Read : 20 demandés
  NeoCloseFile(1);
  tampon[0] := chr(n);                          // longueur de la chaîne Pascal
  writeln('Lu : ', tampon, ' (', n, ' octets sur 20 demandes)');
end.

Lu : ABCDEFGH (8 octets sur 20 demandes)

10 ' Lire tout le fichier, en demandant plus qu'il n'y a (groupe 3, fonction 8)
20 d = alloc(16) : for i = 1 to 8 : poke d + i - 1, 64 + i : next i : save "abc.txt", d, 8 : ' le fichier : ABCDEFGH
25 n$ = "abc.txt" : a = alloc(16) : poke a, len(n$) : for i = 1 to len(n$) : poke a + i, asc(mid$(n$, i, 1)) : next i
30 b = alloc(24) : m = 0 : while peek($ff00) : wend : poke $ff04, 1 : poke $ff05, a & 255 : poke $ff06, a >> 8 : poke $ff07, m : poke $ff01, 4 : poke $ff00, 3 : while peek($ff00) : wend
40 poke $ff04, 1 : poke $ff05, b & 255 : poke $ff06, b >> 8 : poke $ff07, 20 : poke $ff08, 0 : poke $ff01, 8 : poke $ff00, 3
50 while peek($ff00) : wend : n = peek($ff07) + 256 * peek($ff08)
60 close
70 s$ = "" : for i = 0 to n - 1 : s$ = s$ + chr$(peek(b + i)) : next i
80 print "Lu : ";s$;" (";n;" octets sur 20 demandes)"

Lu : ABCDEFGH (8 octets sur 20 demandes)

; Lire tout le fichier, en demandant plus qu'il n'y a (groupe 3, fonction 8).
        .cpu "65c02"
        * = $0800
ControlPort    = $FF00             ; +0 groupe, +1 fonction, +2 erreur, +4.. paramètres
WaitMessage    = $FFF4             ; attend que la boîte aux lettres soit libre
WriteCharacter = $FFF1             ; affiche le caractère de A

start:
        jsr WaitMessage            ; 3,3 : le fichier de l'exemple, ABCDEFGH
        lda #<nom
        sta ControlPort+4
        lda #>nom
        sta ControlPort+5
        lda #<abc
        sta ControlPort+6
        lda #>abc
        sta ControlPort+7
        lda #8
        sta ControlPort+8
        stz ControlPort+9
        lda #3
        ldx #3
        jsr appel
        lda #0
        jsr ouvrir
        jsr WaitMessage
        lda #1
        sta ControlPort+4          ; P0 : canal 1
        lda #<tampon
        sta ControlPort+5          ; P1-P2 : destination
        lda #>tampon
        sta ControlPort+6
        lda #20
        sta ControlPort+7          ; P3-P4 : 20 octets demandés
        stz ControlPort+8
        lda #3
        ldx #8                     ; fonction 8 : File Read
        jsr appel
        lda ControlPort+7          ; octets réellement lus
        sta lus
        jsr fermer
        lda #<m1
        ldx #>m1
        jsr ecrire
        lda #<tampon
        ldx #>tampon
        jsr ecrire
        lda #<m2
        ldx #>m2
        jsr ecrire
        lda lus
        jsr decimal
        lda #<m3
        ldx #>m3
        jmp ecrire
; Ouvrir abc.txt sur le canal 1 dans le mode A.
ouvrir: pha
        jsr WaitMessage
        lda #1
        sta ControlPort+4          ; P0 : canal 1
        lda #<nom
        sta ControlPort+5          ; P1-P2 : nom
        lda #>nom
        sta ControlPort+6
        pla
        sta ControlPort+7          ; P3 : mode
        lda #3
        ldx #4                     ; 3,4 : File Open
        jmp appel

; Fermer le canal 1.
fermer: jsr WaitMessage
        lda #1
        sta ControlPort+4
        lda #3
        ldx #5                     ; 3,5 : File Close
        jmp appel

; Affiche la chaîne terminée par 0 dont l'adresse est dans A (poids faible) et X (poids fort).
ecrire: sta ptr
        stx ptr+1
        ldy #0
_e:     lda (ptr),y
        beq _f
        jsr WriteCharacter
        iny
        bne _e
_f:     rts

; Affiche A (0-255) en décimal, sans zéros de tête.
decimal:
        phx
        phy
        ldx #0
        ldy #100
        jsr _chiffre
        ldy #10
        jsr _chiffre
        ora #'0'
        jsr WriteCharacter
        ply
        plx
        rts
_chiffre:
        sty diviseur
        ldy #0
_div:   cmp diviseur
        bcc _fini
        sbc diviseur
        iny
        bne _div
_fini:  pha
        tya
        bne _ecrit
        cpx #0
        beq _saute
_ecrit: ora #'0'
        jsr WriteCharacter
        ldx #1
_saute: pla
        rts

; Appel : A = groupe, X = fonction (les paramètres sont déjà en place).
appel:  stx ControlPort+1
        sta ControlPort            ; écrit en dernier : lance l'appel
        jmp WaitMessage

ptr      = $80
diviseur: .byte 0

nom:    .byte 7
        .text "abc.txt"
abc:    .text "ABCDEFGH"

tampon: .fill 21                   ; zéros : la chaîne lue sera terminée
lus:    .byte 0
m1:     .text "Lu : ", 0
m2:     .text " (", 0
m3:     .text " octets sur 20 demandes)", 13, 0

Lu : ABCDEFGH (8 octets sur 20 demandes)

/* Écrire 5 octets, fermer, vérifier la taille (groupe 3, fonction 9). */
#include <stdio.h>
#include <neo6502.h>
#include <neo/api.h>

/* Appel brut de la boîte aux lettres : fonction puis groupe (écrit en dernier, il lance l'appel). */
static void api(uint8_t groupe, uint8_t fonction) {
    ControlPort.function = fonction;
    ControlPort.command = groupe;
    while (ControlPort.command)        /* attendre la fin */
        ;
}
static void libre(void) {              /* attendre que la boîte aux lettres soit libre */
    while (ControlPort.command)
        ;
}

static const uint8_t nom[] = "\x08" "neuf.txt";

int main(void) {
    neo_file_open(1, "neuf.txt", NEO_FILE_CREATE);
    uint32_t n = neo_file_write(1, "Salut", 5); /* File Write */
    neo_file_close(1);
    libre();
    ControlPort.params[0] = (uint16_t)nom & 0xFF;
    ControlPort.params[1] = (uint16_t)nom >> 8;
    api(3, 16);                                 /* 3,16 : taille en P0-P3 */
    printf("Ecrits : %lu, taille du fichier : %u\n", (unsigned long)n, ControlPort.params[0] | (ControlPort.params[1] << 8));
    return 0;
}

Ecrits : 5, taille du fichier : 5

// Écrire 5 octets, fermer, vérifier la taille (groupe 3, fonction 9).
program ecrire;
uses crt, neo6502;
var nom, texte: string[16];
    n: word;
    taille: cardinal;
    attr: byte;
begin
  nom := 'neuf.txt';
  texte := 'Salut';
  NeoOpenFile(1, @nom, 3);
  n := NeoWriteFile(1, word(@texte) + 1, 5);    // File Write
  NeoCloseFile(1);
  NeoStatFile(@nom, taille, attr);              // 3,16
  writeln('Ecrits : ', n, ', taille du fichier : ', taille);
end.

Ecrits : 5, taille du fichier : 5

10 ' Ecrire 5 octets, fermer, verifier la taille (groupe 3, fonction 9)
20 n$ = "neuf.txt" : a = alloc(16) : poke a, len(n$) : for i = 1 to len(n$) : poke a + i, asc(mid$(n$, i, 1)) : next i
30 d = alloc(8) : for i = 1 to 5 : poke d + i - 1, asc(mid$("Salut", i, 1)) : next i
40 m = 3 : while peek($ff00) : wend : poke $ff04, 1 : poke $ff05, a & 255 : poke $ff06, a >> 8 : poke $ff07, m : poke $ff01, 4 : poke $ff00, 3 : while peek($ff00) : wend
50 poke $ff04, 1 : poke $ff05, d & 255 : poke $ff06, d >> 8 : poke $ff07, 5 : poke $ff08, 0 : poke $ff01, 9 : poke $ff00, 3
60 while peek($ff00) : wend : n = peek($ff07)
70 close
80 while peek($ff00) : wend
90 poke $ff04, a & 255 : poke $ff05, a >> 8 : poke $ff01, 16 : poke $ff00, 3
100 while peek($ff00) : wend : t = peek($ff04)
110 print "Ecrits : ";n;", taille du fichier : ";t

Ecrits : 5, taille du fichier : 5

; Écrire 5 octets, fermer, vérifier la taille (groupe 3, fonction 9).
        .cpu "65c02"
        * = $0800
ControlPort    = $FF00             ; +0 groupe, +1 fonction, +2 erreur, +4.. paramètres
WaitMessage    = $FFF4             ; attend que la boîte aux lettres soit libre
WriteCharacter = $FFF1             ; affiche le caractère de A

start:  lda #3
        jsr ouvrir_neuf
        jsr WaitMessage
        lda #1
        sta ControlPort+4          ; P0 : canal 1
        lda #<salut
        sta ControlPort+5          ; P1-P2 : données
        lda #>salut
        sta ControlPort+6
        lda #5
        sta ControlPort+7          ; P3-P4 : 5 octets
        stz ControlPort+8
        lda #3
        ldx #9                     ; fonction 9 : File Write
        jsr appel
        lda ControlPort+7
        sta ecrits
        jsr fermer
        jsr WaitMessage
        lda #<neuf
        sta ControlPort+4
        lda #>neuf
        sta ControlPort+5
        lda #3
        ldx #16                    ; 3,16 : taille
        jsr appel
        lda ControlPort+4
        sta taille
        lda #<m1
        ldx #>m1
        jsr ecrire
        lda ecrits
        jsr decimal
        lda #<m2
        ldx #>m2
        jsr ecrire
        lda taille
        jsr decimal
        lda #13
        jmp WriteCharacter

ouvrir_neuf:
        pha
        jsr WaitMessage
        lda #1
        sta ControlPort+4
        lda #<neuf
        sta ControlPort+5
        lda #>neuf
        sta ControlPort+6
        pla
        sta ControlPort+7
        lda #3
        ldx #4
        jmp appel
; Ouvrir abc.txt sur le canal 1 dans le mode A.
ouvrir: pha
        jsr WaitMessage
        lda #1
        sta ControlPort+4          ; P0 : canal 1
        lda #<nom
        sta ControlPort+5          ; P1-P2 : nom
        lda #>nom
        sta ControlPort+6
        pla
        sta ControlPort+7          ; P3 : mode
        lda #3
        ldx #4                     ; 3,4 : File Open
        jmp appel

; Fermer le canal 1.
fermer: jsr WaitMessage
        lda #1
        sta ControlPort+4
        lda #3
        ldx #5                     ; 3,5 : File Close
        jmp appel

; Affiche la chaîne terminée par 0 dont l'adresse est dans A (poids faible) et X (poids fort).
ecrire: sta ptr
        stx ptr+1
        ldy #0
_e:     lda (ptr),y
        beq _f
        jsr WriteCharacter
        iny
        bne _e
_f:     rts

; Affiche A (0-255) en décimal, sans zéros de tête.
decimal:
        phx
        phy
        ldx #0
        ldy #100
        jsr _chiffre
        ldy #10
        jsr _chiffre
        ora #'0'
        jsr WriteCharacter
        ply
        plx
        rts
_chiffre:
        sty diviseur
        ldy #0
_div:   cmp diviseur
        bcc _fini
        sbc diviseur
        iny
        bne _div
_fini:  pha
        tya
        bne _ecrit
        cpx #0
        beq _saute
_ecrit: ora #'0'
        jsr WriteCharacter
        ldx #1
_saute: pla
        rts

; Appel : A = groupe, X = fonction (les paramètres sont déjà en place).
appel:  stx ControlPort+1
        sta ControlPort            ; écrit en dernier : lance l'appel
        jmp WaitMessage

ptr      = $80
diviseur: .byte 0

nom:    .byte 7
        .text "abc.txt"
abc:    .text "ABCDEFGH"

neuf:   .byte 8
        .text "neuf.txt"
salut:  .text "Salut"
ecrits: .byte 0
taille: .byte 0
m1:     .text "Ecrits : ", 0
m2:     .text ", taille du fichier : ", 0

Ecrits : 5, taille du fichier : 5

/* Taille d'un fichier ouvert (groupe 3, fonction 10). */
#include <stdio.h>
#include <neo/api.h>

int main(void) {
    neo_file_store("abc.txt", "ABCDEFGH", 8);  /* 3,3 : le fichier de l'exemple */
    neo_file_open(1, "abc.txt", NEO_FILE_READ);
    uint32_t taille = neo_file_size(1);         /* File Size */
    neo_file_close(1);
    printf("Taille du fichier ouvert : %lu\n", (unsigned long)taille);
    return 0;
}

Taille du fichier ouvert : 8

// Taille d'un fichier ouvert (groupe 3, fonction 10).
program taille;
uses crt, neo6502;
var texte, nom: string[16];
    t: cardinal;
begin
  texte := 'ABCDEFGH';
  NeoSave('abc.txt', word(@texte) + 1, 8);      // 3,3 : le fichier de l'exemple
  nom := 'abc.txt';
  NeoOpenFile(1, @nom, 0);
  t := NeoGetFileSize(1);                       // File Size
  NeoCloseFile(1);
  writeln('Taille du fichier ouvert : ', t);
end.

Taille du fichier ouvert : 8

10 ' Taille d'un fichier ouvert (groupe 3, fonction 10)
20 d = alloc(16) : for i = 1 to 8 : poke d + i - 1, 64 + i : next i : save "abc.txt", d, 8 : ' le fichier : ABCDEFGH
25 n$ = "abc.txt" : a = alloc(16) : poke a, len(n$) : for i = 1 to len(n$) : poke a + i, asc(mid$(n$, i, 1)) : next i
30 m = 0 : while peek($ff00) : wend : poke $ff04, 1 : poke $ff05, a & 255 : poke $ff06, a >> 8 : poke $ff07, m : poke $ff01, 4 : poke $ff00, 3 : while peek($ff00) : wend
40 poke $ff04, 1 : poke $ff01, 10 : poke $ff00, 3
50 while peek($ff00) : wend : t = peek($ff05) + 256 * peek($ff06)
60 close
70 print "Taille du fichier ouvert : ";t

Taille du fichier ouvert : 8

; Taille d'un fichier ouvert (groupe 3, fonction 10).
        .cpu "65c02"
        * = $0800
ControlPort    = $FF00             ; +0 groupe, +1 fonction, +2 erreur, +4.. paramètres
WaitMessage    = $FFF4             ; attend que la boîte aux lettres soit libre
WriteCharacter = $FFF1             ; affiche le caractère de A

start:
        jsr WaitMessage            ; 3,3 : le fichier de l'exemple, ABCDEFGH
        lda #<nom
        sta ControlPort+4
        lda #>nom
        sta ControlPort+5
        lda #<abc
        sta ControlPort+6
        lda #>abc
        sta ControlPort+7
        lda #8
        sta ControlPort+8
        stz ControlPort+9
        lda #3
        ldx #3
        jsr appel
        lda #0
        jsr ouvrir
        jsr WaitMessage
        lda #1
        sta ControlPort+4          ; P0 : canal 1
        lda #3
        ldx #10                    ; fonction 10 : File Size
        jsr appel
        lda ControlPort+5          ; P1 : taille (poids faible)
        sta taille
        jsr fermer
        lda #<m
        ldx #>m
        jsr ecrire
        lda taille
        jsr decimal
        lda #13
        jmp WriteCharacter
; Ouvrir abc.txt sur le canal 1 dans le mode A.
ouvrir: pha
        jsr WaitMessage
        lda #1
        sta ControlPort+4          ; P0 : canal 1
        lda #<nom
        sta ControlPort+5          ; P1-P2 : nom
        lda #>nom
        sta ControlPort+6
        pla
        sta ControlPort+7          ; P3 : mode
        lda #3
        ldx #4                     ; 3,4 : File Open
        jmp appel

; Fermer le canal 1.
fermer: jsr WaitMessage
        lda #1
        sta ControlPort+4
        lda #3
        ldx #5                     ; 3,5 : File Close
        jmp appel

; Affiche la chaîne terminée par 0 dont l'adresse est dans A (poids faible) et X (poids fort).
ecrire: sta ptr
        stx ptr+1
        ldy #0
_e:     lda (ptr),y
        beq _f
        jsr WriteCharacter
        iny
        bne _e
_f:     rts

; Affiche A (0-255) en décimal, sans zéros de tête.
decimal:
        phx
        phy
        ldx #0
        ldy #100
        jsr _chiffre
        ldy #10
        jsr _chiffre
        ora #'0'
        jsr WriteCharacter
        ply
        plx
        rts
_chiffre:
        sty diviseur
        ldy #0
_div:   cmp diviseur
        bcc _fini
        sbc diviseur
        iny
        bne _div
_fini:  pha
        tya
        bne _ecrit
        cpx #0
        beq _saute
_ecrit: ora #'0'
        jsr WriteCharacter
        ldx #1
_saute: pla
        rts

; Appel : A = groupe, X = fonction (les paramètres sont déjà en place).
appel:  stx ControlPort+1
        sta ControlPort            ; écrit en dernier : lance l'appel
        jmp WaitMessage

ptr      = $80
diviseur: .byte 0

nom:    .byte 7
        .text "abc.txt"
abc:    .text "ABCDEFGH"

taille: .byte 0
m:      .text "Taille du fichier ouvert : ", 0

Taille du fichier ouvert : 8

/* Tronquer ABCDEFGH à 3 octets (groupe 3, fonction 11). */
#include <stdio.h>
#include <neo/api.h>

int main(void) {
    neo_file_store("abc.txt", "ABCDEFGH", 8);  /* 3,3 : le fichier de l'exemple */
    neo_file_open(1, "abc.txt", NEO_FILE_READ_WRITE);
    neo_file_set_size(1, 3);                    /* File Set Size */
    uint32_t taille = neo_file_size(1);         /* 3,10 */
    neo_file_close(1);
    printf("Taille apres troncature : %lu\n", (unsigned long)taille);
    return 0;
}

Taille apres troncature : 3

// Tronquer ABCDEFGH à 3 octets (groupe 3, fonction 11).
// NeoSetFileSize (Mad Pascal 1.7.8) appelle la fonction 10 : appel direct.
program tronquer;
uses crt, neo6502;
var texte, nom: string[16];
begin
  texte := 'ABCDEFGH';
  NeoSave('abc.txt', word(@texte) + 1, 8);      // 3,3 : le fichier de l'exemple
  nom := 'abc.txt';
  NeoOpenFile(1, @nom, 2);                      // lecture-écriture
  NeoWaitMessage;
  NeoMessage.params[0] := 1;                    // P0 : canal
  FI_offset := 3;                               // P1-P4 : nouvelle taille
  NeoSendMessage(3, 11);                        // File Set Size
  NeoWaitMessage;
  writeln('Taille apres troncature : ', NeoGetFileSize(1));
  NeoCloseFile(1);
end.

Taille apres troncature : 3

10 ' Tronquer ABCDEFGH a 3 octets (groupe 3, fonction 11)
20 d = alloc(16) : for i = 1 to 8 : poke d + i - 1, 64 + i : next i : save "abc.txt", d, 8 : ' le fichier : ABCDEFGH
25 n$ = "abc.txt" : a = alloc(16) : poke a, len(n$) : for i = 1 to len(n$) : poke a + i, asc(mid$(n$, i, 1)) : next i
30 m = 2 : while peek($ff00) : wend : poke $ff04, 1 : poke $ff05, a & 255 : poke $ff06, a >> 8 : poke $ff07, m : poke $ff01, 4 : poke $ff00, 3 : while peek($ff00) : wend
40 poke $ff04, 1 : poke $ff05, 3 : poke $ff06, 0 : poke $ff07, 0 : poke $ff08, 0 : poke $ff01, 11 : poke $ff00, 3
50 while peek($ff00) : wend
60 poke $ff04, 1 : poke $ff01, 10 : poke $ff00, 3
70 while peek($ff00) : wend : t = peek($ff05)
80 close
90 print "Taille apres troncature : ";t

Taille apres troncature : 3

; Tronquer ABCDEFGH à 3 octets (groupe 3, fonction 11).
        .cpu "65c02"
        * = $0800
ControlPort    = $FF00             ; +0 groupe, +1 fonction, +2 erreur, +4.. paramètres
WaitMessage    = $FFF4             ; attend que la boîte aux lettres soit libre
WriteCharacter = $FFF1             ; affiche le caractère de A

start:
        jsr WaitMessage            ; 3,3 : le fichier de l'exemple, ABCDEFGH
        lda #<nom
        sta ControlPort+4
        lda #>nom
        sta ControlPort+5
        lda #<abc
        sta ControlPort+6
        lda #>abc
        sta ControlPort+7
        lda #8
        sta ControlPort+8
        stz ControlPort+9
        lda #3
        ldx #3
        jsr appel
        lda #2
        jsr ouvrir                 ; lecture-écriture
        jsr WaitMessage
        lda #1
        sta ControlPort+4          ; P0 : canal 1
        lda #3
        sta ControlPort+5          ; P1-P4 : 3 octets
        stz ControlPort+6
        stz ControlPort+7
        stz ControlPort+8
        lda #3
        ldx #11                    ; fonction 11 : File Set Size
        jsr appel
        jsr WaitMessage
        lda #1
        sta ControlPort+4
        lda #3
        ldx #10                    ; 3,10 : taille
        jsr appel
        lda ControlPort+5
        sta taille
        jsr fermer
        lda #<m
        ldx #>m
        jsr ecrire
        lda taille
        jsr decimal
        lda #13
        jmp WriteCharacter
; Ouvrir abc.txt sur le canal 1 dans le mode A.
ouvrir: pha
        jsr WaitMessage
        lda #1
        sta ControlPort+4          ; P0 : canal 1
        lda #<nom
        sta ControlPort+5          ; P1-P2 : nom
        lda #>nom
        sta ControlPort+6
        pla
        sta ControlPort+7          ; P3 : mode
        lda #3
        ldx #4                     ; 3,4 : File Open
        jmp appel

; Fermer le canal 1.
fermer: jsr WaitMessage
        lda #1
        sta ControlPort+4
        lda #3
        ldx #5                     ; 3,5 : File Close
        jmp appel

; Affiche la chaîne terminée par 0 dont l'adresse est dans A (poids faible) et X (poids fort).
ecrire: sta ptr
        stx ptr+1
        ldy #0
_e:     lda (ptr),y
        beq _f
        jsr WriteCharacter
        iny
        bne _e
_f:     rts

; Affiche A (0-255) en décimal, sans zéros de tête.
decimal:
        phx
        phy
        ldx #0
        ldy #100
        jsr _chiffre
        ldy #10
        jsr _chiffre
        ora #'0'
        jsr WriteCharacter
        ply
        plx
        rts
_chiffre:
        sty diviseur
        ldy #0
_div:   cmp diviseur
        bcc _fini
        sbc diviseur
        iny
        bne _div
_fini:  pha
        tya
        bne _ecrit
        cpx #0
        beq _saute
_ecrit: ora #'0'
        jsr WriteCharacter
        ldx #1
_saute: pla
        rts

; Appel : A = groupe, X = fonction (les paramètres sont déjà en place).
appel:  stx ControlPort+1
        sta ControlPort            ; écrit en dernier : lance l'appel
        jmp WaitMessage

ptr      = $80
diviseur: .byte 0

nom:    .byte 7
        .text "abc.txt"
abc:    .text "ABCDEFGH"

taille: .byte 0
m:      .text "Taille apres troncature : ", 0

Taille apres troncature : 3

/* Renommer abc.txt en xyz.txt (groupe 3, fonction 12). */
#include <stdio.h>
#include <neo/api.h>

int main(void) {
    neo_file_store("abc.txt", "ABCDEFGH", 8);  /* 3,3 : le fichier de l'exemple */
    neo_file_rename("abc.txt", "xyz.txt");      /* File Rename */
    printf("Renomme : abc.txt -> xyz.txt, erreur %u\n", neo_api_error());
    return 0;
}

Renomme : abc.txt -> xyz.txt, erreur 0

// Renommer abc.txt en xyz.txt (groupe 3, fonction 12).
program renommer;
uses crt, neo6502;
var texte, nom, nouveau: string[16];
    e: byte;
begin
  texte := 'ABCDEFGH';
  NeoSave('abc.txt', word(@texte) + 1, 8);      // 3,3 : le fichier de l'exemple
  nom := 'abc.txt';
  nouveau := 'xyz.txt';
  NeoRenameFile(@nom, @nouveau);                // File Rename
  e := NeoMessage.error;                        // à lire avant writeln, qui passe par l'API
  writeln('Renomme : abc.txt -> xyz.txt, erreur ', e);
end.

Renomme : abc.txt -> xyz.txt, erreur 0

10 ' Renommer abc.txt en xyz.txt (groupe 3, fonction 12)
20 d = alloc(16) : for i = 1 to 8 : poke d + i - 1, 64 + i : next i : save "abc.txt", d, 8 : ' le fichier : ABCDEFGH
25 n$ = "abc.txt" : a = alloc(16) : poke a, len(n$) : for i = 1 to len(n$) : poke a + i, asc(mid$(n$, i, 1)) : next i
30 b = a : n$ = "xyz.txt" : a = alloc(16) : poke a, len(n$) : for i = 1 to len(n$) : poke a + i, asc(mid$(n$, i, 1)) : next i
40 while peek($ff00) : wend
50 poke $ff04, b & 255 : poke $ff05, b >> 8 : poke $ff06, a & 255 : poke $ff07, a >> 8 : poke $ff01, 12 : poke $ff00, 3
60 while peek($ff00) : wend : e = peek($ff02)
70 print "Renomme : abc.txt -> xyz.txt, erreur ";e

Renomme : abc.txt -> xyz.txt, erreur 0

; Renommer abc.txt en xyz.txt (groupe 3, fonction 12).
        .cpu "65c02"
        * = $0800
ControlPort    = $FF00             ; +0 groupe, +1 fonction, +2 erreur, +4.. paramètres
WaitMessage    = $FFF4             ; attend que la boîte aux lettres soit libre
WriteCharacter = $FFF1             ; affiche le caractère de A

start:
        jsr WaitMessage            ; 3,3 : le fichier de l'exemple, ABCDEFGH
        lda #<nom
        sta ControlPort+4
        lda #>nom
        sta ControlPort+5
        lda #<abc
        sta ControlPort+6
        lda #>abc
        sta ControlPort+7
        lda #8
        sta ControlPort+8
        stz ControlPort+9
        lda #3
        ldx #3
        jsr appel
        jsr WaitMessage
        lda #<nom
        sta ControlPort+4          ; P0-P1 : ancien nom
        lda #>nom
        sta ControlPort+5
        lda #<xyz
        sta ControlPort+6          ; P2-P3 : nouveau nom
        lda #>xyz
        sta ControlPort+7
        lda #3
        ldx #12                    ; fonction 12 : File Rename
        jsr appel
        lda ControlPort+2
        pha
        lda #<m
        ldx #>m
        jsr ecrire
        pla
        jsr decimal
        lda #13
        jmp WriteCharacter
; Ouvrir abc.txt sur le canal 1 dans le mode A.
ouvrir: pha
        jsr WaitMessage
        lda #1
        sta ControlPort+4          ; P0 : canal 1
        lda #<nom
        sta ControlPort+5          ; P1-P2 : nom
        lda #>nom
        sta ControlPort+6
        pla
        sta ControlPort+7          ; P3 : mode
        lda #3
        ldx #4                     ; 3,4 : File Open
        jmp appel

; Fermer le canal 1.
fermer: jsr WaitMessage
        lda #1
        sta ControlPort+4
        lda #3
        ldx #5                     ; 3,5 : File Close
        jmp appel

; Affiche la chaîne terminée par 0 dont l'adresse est dans A (poids faible) et X (poids fort).
ecrire: sta ptr
        stx ptr+1
        ldy #0
_e:     lda (ptr),y
        beq _f
        jsr WriteCharacter
        iny
        bne _e
_f:     rts

; Affiche A (0-255) en décimal, sans zéros de tête.
decimal:
        phx
        phy
        ldx #0
        ldy #100
        jsr _chiffre
        ldy #10
        jsr _chiffre
        ora #'0'
        jsr WriteCharacter
        ply
        plx
        rts
_chiffre:
        sty diviseur
        ldy #0
_div:   cmp diviseur
        bcc _fini
        sbc diviseur
        iny
        bne _div
_fini:  pha
        tya
        bne _ecrit
        cpx #0
        beq _saute
_ecrit: ora #'0'
        jsr WriteCharacter
        ldx #1
_saute: pla
        rts

; Appel : A = groupe, X = fonction (les paramètres sont déjà en place).
appel:  stx ControlPort+1
        sta ControlPort            ; écrit en dernier : lance l'appel
        jmp WaitMessage

ptr      = $80
diviseur: .byte 0

nom:    .byte 7
        .text "abc.txt"
abc:    .text "ABCDEFGH"

xyz:    .byte 7
        .text "xyz.txt"
m:      .text "Renomme : abc.txt -> xyz.txt, erreur ", 0

Renomme : abc.txt -> xyz.txt, erreur 0

/* Supprimer un fichier, puis vérifier qu'il a disparu (groupe 3, fonction 13). */
#include <stdio.h>
#include <neo/api.h>

int main(void) {
    neo_file_stat_t st;
    neo_file_store("abc.txt", "ABCDEFGH", 8);  /* 3,3 : le fichier de l'exemple */
    neo_file_delete("abc.txt");                 /* File Delete */
    neo_file_stat("abc.txt", &st);              /* 3,16 : doit échouer */
    printf("Supprime, puis 3,16 donne l'erreur %u\n", neo_api_error());
    return 0;
}

Supprime, puis 3,16 donne l'erreur 17

// Supprimer un fichier, puis vérifier qu'il a disparu (groupe 3, fonction 13).
program supprimer;
uses crt, neo6502;
var texte, nom: string[16];
    e: byte;
    taille: cardinal;
    attr: byte;
begin
  texte := 'ABCDEFGH';
  NeoSave('abc.txt', word(@texte) + 1, 8);      // 3,3 : le fichier de l'exemple
  nom := 'abc.txt';
  NeoDeleteFile(@nom);                          // File Delete
  NeoStatFile(@nom, taille, attr);              // 3,16 : doit échouer
  e := NeoMessage.error;                        // à lire avant writeln, qui passe par l'API
  writeln('Supprime, puis 3,16 donne l''erreur ', e);
end.

Supprime, puis 3,16 donne l'erreur 17

10 ' Supprimer un fichier, puis verifier qu'il a disparu (groupe 3, fonction 13)
20 d = alloc(16) : for i = 1 to 8 : poke d + i - 1, 64 + i : next i : save "abc.txt", d, 8 : ' le fichier : ABCDEFGH
25 n$ = "abc.txt" : a = alloc(16) : poke a, len(n$) : for i = 1 to len(n$) : poke a + i, asc(mid$(n$, i, 1)) : next i
30 while peek($ff00) : wend
40 poke $ff04, a & 255 : poke $ff05, a >> 8 : poke $ff01, 13 : poke $ff00, 3
50 while peek($ff00) : wend
60 poke $ff04, a & 255 : poke $ff05, a >> 8 : poke $ff01, 16 : poke $ff00, 3
70 while peek($ff00) : wend : e = peek($ff02)
80 print "Supprime, puis 3,16 donne l'erreur ";e

Supprime, puis 3,16 donne l'erreur 17

; Supprimer un fichier, puis vérifier qu'il a disparu (groupe 3, fonction 13).
        .cpu "65c02"
        * = $0800
ControlPort    = $FF00             ; +0 groupe, +1 fonction, +2 erreur, +4.. paramètres
WaitMessage    = $FFF4             ; attend que la boîte aux lettres soit libre
WriteCharacter = $FFF1             ; affiche le caractère de A

start:
        jsr WaitMessage            ; 3,3 : le fichier de l'exemple, ABCDEFGH
        lda #<nom
        sta ControlPort+4
        lda #>nom
        sta ControlPort+5
        lda #<abc
        sta ControlPort+6
        lda #>abc
        sta ControlPort+7
        lda #8
        sta ControlPort+8
        stz ControlPort+9
        lda #3
        ldx #3
        jsr appel
        ldx #13                    ; fonction 13 : File Delete
        jsr sur_nom
        ldx #16                    ; 3,16 : doit échouer
        jsr sur_nom
        lda ControlPort+2
        pha
        lda #<m
        ldx #>m
        jsr ecrire
        pla
        jsr decimal
        lda #13
        jmp WriteCharacter

sur_nom:                           ; X = fonction du groupe 3, sur abc.txt
        jsr WaitMessage
        lda #<nom
        sta ControlPort+4
        lda #>nom
        sta ControlPort+5
        lda #3
        jmp appel
; Ouvrir abc.txt sur le canal 1 dans le mode A.
ouvrir: pha
        jsr WaitMessage
        lda #1
        sta ControlPort+4          ; P0 : canal 1
        lda #<nom
        sta ControlPort+5          ; P1-P2 : nom
        lda #>nom
        sta ControlPort+6
        pla
        sta ControlPort+7          ; P3 : mode
        lda #3
        ldx #4                     ; 3,4 : File Open
        jmp appel

; Fermer le canal 1.
fermer: jsr WaitMessage
        lda #1
        sta ControlPort+4
        lda #3
        ldx #5                     ; 3,5 : File Close
        jmp appel

; Affiche la chaîne terminée par 0 dont l'adresse est dans A (poids faible) et X (poids fort).
ecrire: sta ptr
        stx ptr+1
        ldy #0
_e:     lda (ptr),y
        beq _f
        jsr WriteCharacter
        iny
        bne _e
_f:     rts

; Affiche A (0-255) en décimal, sans zéros de tête.
decimal:
        phx
        phy
        ldx #0
        ldy #100
        jsr _chiffre
        ldy #10
        jsr _chiffre
        ora #'0'
        jsr WriteCharacter
        ply
        plx
        rts
_chiffre:
        sty diviseur
        ldy #0
_div:   cmp diviseur
        bcc _fini
        sbc diviseur
        iny
        bne _div
_fini:  pha
        tya
        bne _ecrit
        cpx #0
        beq _saute
_ecrit: ora #'0'
        jsr WriteCharacter
        ldx #1
_saute: pla
        rts

; Appel : A = groupe, X = fonction (les paramètres sont déjà en place).
appel:  stx ControlPort+1
        sta ControlPort            ; écrit en dernier : lance l'appel
        jmp WaitMessage

ptr      = $80
diviseur: .byte 0

nom:    .byte 7
        .text "abc.txt"
abc:    .text "ABCDEFGH"

m:      .text "Supprime, puis 3,16 donne l'erreur ", 0

Supprime, puis 3,16 donne l'erreur 17

/* Créer un répertoire, puis vérifier son attribut (groupe 3, fonction 14). */
#include <stdio.h>
#include <neo6502.h>
#include <neo/api.h>

/* Appel brut de la boîte aux lettres : fonction puis groupe (écrit en dernier, il lance l'appel). */
static void api(uint8_t groupe, uint8_t fonction) {
    ControlPort.function = fonction;
    ControlPort.command = groupe;
    while (ControlPort.command)        /* attendre la fin */
        ;
}
static void libre(void) {              /* attendre que la boîte aux lettres soit libre */
    while (ControlPort.command)
        ;
}

static const uint8_t rep[] = "\x03" "rep";

int main(void) {
    neo_file_mkdir("rep");                      /* Create Directory */
    libre();
    ControlPort.params[0] = (uint16_t)rep & 0xFF;
    ControlPort.params[1] = (uint16_t)rep >> 8;
    api(3, 16);                                 /* 3,16 : attributs en P4 */
    printf("Repertoire cree, bit repertoire : %u\n", ControlPort.params[4] & 1);
    return 0;
}

Repertoire cree, bit repertoire : 1

// Créer un répertoire, puis vérifier son attribut (groupe 3, fonction 14).
program creer;
uses crt, neo6502;
var rep: string[16];
    taille: cardinal;
    attr: byte;
begin
  rep := 'rep';
  NeoCreateDirectory(@rep);                     // Create Directory
  NeoStatFile(@rep, taille, attr);              // 3,16
  writeln('Repertoire cree, bit repertoire : ', attr and FI_ATTR_DIRECTORY);
end.

Repertoire cree, bit repertoire : 1

10 ' Creer un repertoire, puis verifier son attribut (groupe 3, fonction 14)
20 n$ = "rep" : a = alloc(8) : poke a, len(n$) : for i = 1 to len(n$) : poke a + i, asc(mid$(n$, i, 1)) : next i
30 while peek($ff00) : wend
40 poke $ff04, a & 255 : poke $ff05, a >> 8 : poke $ff01, 14 : poke $ff00, 3
50 while peek($ff00) : wend
60 poke $ff04, a & 255 : poke $ff05, a >> 8 : poke $ff01, 16 : poke $ff00, 3
70 while peek($ff00) : wend : t = peek($ff08) & 1
80 print "Repertoire cree, bit repertoire : ";t

Repertoire cree, bit repertoire : 1

; Créer un répertoire, puis vérifier son attribut (groupe 3, fonction 14).
        .cpu "65c02"
        * = $0800
ControlPort    = $FF00             ; +0 groupe, +1 fonction, +2 erreur, +4.. paramètres
WaitMessage    = $FFF4             ; attend que la boîte aux lettres soit libre
WriteCharacter = $FFF1             ; affiche le caractère de A

start:  lda #<rep
        ldx #>rep
        ldy #14                    ; fonction 14 : Create Directory
        jsr sur_nom
        lda #<rep
        ldx #>rep
        ldy #16                    ; 3,16 : attributs en P4
        jsr sur_nom
        lda ControlPort+8
        and #1                     ; bit 0 : répertoire
        pha
        lda #<m
        ldx #>m
        jsr ecrire
        pla
        jsr decimal
        lda #13
        jmp WriteCharacter

; Appel du groupe 3, fonction Y, avec en P0-P1 l'adresse du nom donnée par A (poids faible) et X.
sur_nom:
        pha
        jsr WaitMessage
        pla
        sta ControlPort+4
        stx ControlPort+5
        tya
        tax
        lda #3
        jmp appel

; Affiche la chaîne terminée par 0 dont l'adresse est dans A (poids faible) et X (poids fort).
ecrire: sta ptr
        stx ptr+1
        ldy #0
_e:     lda (ptr),y
        beq _f
        jsr WriteCharacter
        iny
        bne _e
_f:     rts

; Affiche A (0-255) en décimal, sans zéros de tête.
decimal:
        phx
        phy
        ldx #0
        ldy #100
        jsr _chiffre
        ldy #10
        jsr _chiffre
        ora #'0'
        jsr WriteCharacter
        ply
        plx
        rts
_chiffre:
        sty diviseur
        ldy #0
_div:   cmp diviseur
        bcc _fini
        sbc diviseur
        iny
        bne _div
_fini:  pha
        tya
        bne _ecrit
        cpx #0
        beq _saute
_ecrit: ora #'0'
        jsr WriteCharacter
        ldx #1
_saute: pla
        rts

; Appel : A = groupe, X = fonction (les paramètres sont déjà en place).
appel:  stx ControlPort+1
        sta ControlPort            ; écrit en dernier : lance l'appel
        jmp WaitMessage

ptr      = $80
diviseur: .byte 0

rep:    .byte 3
        .text "rep"
m:      .text "Repertoire cree, bit repertoire : ", 0

Repertoire cree, bit repertoire : 1

/* Créer un répertoire et s'y placer (groupe 3, fonction 15). */
#include <stdio.h>
#include <neo/api.h>

static char cwd[33];

static const char *courant(void) {
    neo_file_get_cwd(cwd, 32);                  /* 3,23 : chaîne précédée de sa longueur */
    cwd[(uint8_t)cwd[0] + 1] = 0;
    return cwd + 1;
}

int main(void) {
    neo_file_mkdir("rep");                      /* 3,14 */
    neo_file_chdir("rep");                      /* Change Directory */
    printf("Repertoire courant : %s\n", courant());
    return 0;
}

Repertoire courant : /rep

// Créer un répertoire et s'y placer (groupe 3, fonction 15).
program chdir;
uses crt, neo6502;
var rep: string[16];

function courant: string;
var cwd: string[32];
begin
  NeoWaitMessage;
  wordParams[0] := word(@cwd);                  // P0-P1 : tampon
  NeoMessage.params[2] := 32;                   // P2 : longueur maximale
  NeoSendMessage(3, 23);                        // 3,23 : Get Current Working Directory
  NeoWaitMessage;
  result := cwd;
end;

begin
  rep := 'rep';
  NeoCreateDirectory(@rep);                     // 3,14
  NeoChangeDirectory(@rep);                     // Change Directory
  writeln('Repertoire courant : ', courant);
end.

Repertoire courant : /rep

10 ' Creer un repertoire et s'y placer (groupe 3, fonction 15)
20 n$ = "rep" : a = alloc(8) : poke a, len(n$) : for i = 1 to len(n$) : poke a + i, asc(mid$(n$, i, 1)) : next i
30 while peek($ff00) : wend
40 poke $ff04, a & 255 : poke $ff05, a >> 8 : poke $ff01, 14 : poke $ff00, 3
50 while peek($ff00) : wend
60 poke $ff04, a & 255 : poke $ff05, a >> 8 : poke $ff01, 15 : poke $ff00, 3
70 while peek($ff00) : wend
80 b = alloc(34) : poke $ff04, b & 255 : poke $ff05, b >> 8 : poke $ff06, 32 : poke $ff01, 23 : poke $ff00, 3
90 while peek($ff00) : wend : s$ = "" : for i = 1 to peek(b) : s$ = s$ + chr$(peek(b + i)) : next i
100 print "Repertoire courant : ";s$

Repertoire courant : /rep

; Créer un répertoire et s'y placer (groupe 3, fonction 15).
        .cpu "65c02"
        * = $0800
ControlPort    = $FF00             ; +0 groupe, +1 fonction, +2 erreur, +4.. paramètres
WaitMessage    = $FFF4             ; attend que la boîte aux lettres soit libre
WriteCharacter = $FFF1             ; affiche le caractère de A

start:  lda #<rep
        ldx #>rep
        ldy #14                    ; 3,14 : Create Directory
        jsr sur_nom
        lda #<rep
        ldx #>rep
        ldy #15                    ; fonction 15 : Change Directory
        jsr sur_nom
        jsr courant
        lda #<m
        ldx #>m
        jsr ecrire
        lda #<cwd
        ldx #>cwd
        jsr pecrire
        lda #13
        jmp WriteCharacter

; Répertoire courant dans cwd (précédé de sa longueur).
courant:
        jsr WaitMessage
        lda #<cwd
        sta ControlPort+4          ; P0-P1 : tampon
        lda #>cwd
        sta ControlPort+5
        lda #32
        sta ControlPort+6          ; P2 : longueur maximale
        lda #3
        ldx #23                    ; 3,23 : Get Current Working Directory
        jmp appel
cwd:    .fill 34

; Appel du groupe 3, fonction Y, avec en P0-P1 l'adresse du nom donnée par A (poids faible) et X.
sur_nom:
        pha
        jsr WaitMessage
        pla
        sta ControlPort+4
        stx ControlPort+5
        tya
        tax
        lda #3
        jmp appel

; Affiche la chaîne précédée de sa longueur dont l'adresse est dans A (poids faible) et X (poids fort).
pecrire:
        sta ptr
        stx ptr+1
        lda (ptr)
        sta reste
        ldy #1
_p:     lda reste
        beq _pf
        lda (ptr),y
        jsr WriteCharacter
        iny
        dec reste
        bra _p
_pf:    rts
reste:  .byte 0

; Affiche la chaîne terminée par 0 dont l'adresse est dans A (poids faible) et X (poids fort).
ecrire: sta ptr
        stx ptr+1
        ldy #0
_e:     lda (ptr),y
        beq _f
        jsr WriteCharacter
        iny
        bne _e
_f:     rts

; Affiche A (0-255) en décimal, sans zéros de tête.
decimal:
        phx
        phy
        ldx #0
        ldy #100
        jsr _chiffre
        ldy #10
        jsr _chiffre
        ora #'0'
        jsr WriteCharacter
        ply
        plx
        rts
_chiffre:
        sty diviseur
        ldy #0
_div:   cmp diviseur
        bcc _fini
        sbc diviseur
        iny
        bne _div
_fini:  pha
        tya
        bne _ecrit
        cpx #0
        beq _saute
_ecrit: ora #'0'
        jsr WriteCharacter
        ldx #1
_saute: pla
        rts

; Appel : A = groupe, X = fonction (les paramètres sont déjà en place).
appel:  stx ControlPort+1
        sta ControlPort            ; écrit en dernier : lance l'appel
        jmp WaitMessage

ptr      = $80
diviseur: .byte 0

rep:    .byte 3
        .text "rep"
m:      .text "Repertoire courant : ", 0

Repertoire courant : /rep

/* Taille et attributs d'un fichier (groupe 3, fonction 16). */
/* neo_file_stat (llvm-mos, compilateur c798c31) rend des valeurs fausses : appel direct. */
#include <stdio.h>
#include <neo6502.h>
#include <neo/api.h>

/* Appel brut de la boîte aux lettres : fonction puis groupe (écrit en dernier, il lance l'appel). */
static void api(uint8_t groupe, uint8_t fonction) {
    ControlPort.function = fonction;
    ControlPort.command = groupe;
    while (ControlPort.command)        /* attendre la fin */
        ;
}
static void libre(void) {              /* attendre que la boîte aux lettres soit libre */
    while (ControlPort.command)
        ;
}

static const uint8_t nom[] = "\x07" "abc.txt";

int main(void) {
    neo_file_store("abc.txt", "ABCDEFGH", 8);  /* 3,3 : le fichier de l'exemple */
    libre();
    ControlPort.params[0] = (uint16_t)nom & 0xFF;   /* P0-P1 : nom */
    ControlPort.params[1] = (uint16_t)nom >> 8;
    api(3, 16);                                     /* File Stat */
    printf("abc.txt : %u octets, repertoire : %u\n",
           ControlPort.params[0] | (ControlPort.params[1] << 8), ControlPort.params[4] & 1);
    return 0;
}

abc.txt : 8 octets, repertoire : 0

// Taille et attributs d'un fichier (groupe 3, fonction 16).
program stat;
uses crt, neo6502;
var texte, nom: string[16];
    taille: cardinal;
    attr: byte;
begin
  texte := 'ABCDEFGH';
  NeoSave('abc.txt', word(@texte) + 1, 8);      // 3,3 : le fichier de l'exemple
  nom := 'abc.txt';
  NeoStatFile(@nom, taille, attr);              // File Stat
  writeln('abc.txt : ', taille, ' octets, repertoire : ', attr and FI_ATTR_DIRECTORY);
end.

abc.txt : 8 octets, repertoire : 0

10 ' Taille et attributs d'un fichier (groupe 3, fonction 16)
20 d = alloc(16) : for i = 1 to 8 : poke d + i - 1, 64 + i : next i : save "abc.txt", d, 8 : ' le fichier : ABCDEFGH
25 n$ = "abc.txt" : a = alloc(16) : poke a, len(n$) : for i = 1 to len(n$) : poke a + i, asc(mid$(n$, i, 1)) : next i
30 if exists("abc.txt")
40 while peek($ff00) : wend
50 poke $ff04, a & 255 : poke $ff05, a >> 8 : poke $ff01, 16 : poke $ff00, 3
60 while peek($ff00) : wend : t = peek($ff04) + 256 * peek($ff05) : r = peek($ff08) & 1
70 print "abc.txt : ";t;" octets, repertoire : ";r
80 endif

abc.txt : 8 octets, repertoire : 0

; Taille et attributs d'un fichier (groupe 3, fonction 16).
        .cpu "65c02"
        * = $0800
ControlPort    = $FF00             ; +0 groupe, +1 fonction, +2 erreur, +4.. paramètres
WaitMessage    = $FFF4             ; attend que la boîte aux lettres soit libre
WriteCharacter = $FFF1             ; affiche le caractère de A

start:
        jsr WaitMessage            ; 3,3 : le fichier de l'exemple, ABCDEFGH
        lda #<nom
        sta ControlPort+4
        lda #>nom
        sta ControlPort+5
        lda #<abc
        sta ControlPort+6
        lda #>abc
        sta ControlPort+7
        lda #8
        sta ControlPort+8
        stz ControlPort+9
        lda #3
        ldx #3
        jsr appel
        lda #<nom
        ldx #>nom
        ldy #16                    ; fonction 16 : File Stat
        jsr sur_nom
        lda ControlPort+4          ; P0 : taille (poids faible)
        sta taille
        lda ControlPort+8          ; P4 : attributs
        and #1
        sta dir
        lda #<m1
        ldx #>m1
        jsr ecrire
        lda taille
        jsr decimal
        lda #<m2
        ldx #>m2
        jsr ecrire
        lda dir
        jsr decimal
        lda #13
        jmp WriteCharacter

; Appel du groupe 3, fonction Y, avec en P0-P1 l'adresse du nom donnée par A (poids faible) et X.
sur_nom:
        pha
        jsr WaitMessage
        pla
        sta ControlPort+4
        stx ControlPort+5
        tya
        tax
        lda #3
        jmp appel

; Affiche la chaîne terminée par 0 dont l'adresse est dans A (poids faible) et X (poids fort).
ecrire: sta ptr
        stx ptr+1
        ldy #0
_e:     lda (ptr),y
        beq _f
        jsr WriteCharacter
        iny
        bne _e
_f:     rts

; Affiche A (0-255) en décimal, sans zéros de tête.
decimal:
        phx
        phy
        ldx #0
        ldy #100
        jsr _chiffre
        ldy #10
        jsr _chiffre
        ora #'0'
        jsr WriteCharacter
        ply
        plx
        rts
_chiffre:
        sty diviseur
        ldy #0
_div:   cmp diviseur
        bcc _fini
        sbc diviseur
        iny
        bne _div
_fini:  pha
        tya
        bne _ecrit
        cpx #0
        beq _saute
_ecrit: ora #'0'
        jsr WriteCharacter
        ldx #1
_saute: pla
        rts

; Appel : A = groupe, X = fonction (les paramètres sont déjà en place).
appel:  stx ControlPort+1
        sta ControlPort            ; écrit en dernier : lance l'appel
        jmp WaitMessage

ptr      = $80
diviseur: .byte 0

nom:    .byte 7
        .text "abc.txt"
abc:    .text "ABCDEFGH"

taille: .byte 0
dir:    .byte 0
m1:     .text "abc.txt : ", 0
m2:     .text " octets, repertoire : ", 0

abc.txt : 8 octets, repertoire : 0

/* Lister le répertoire courant (groupe 3, fonction 17 : Open Directory). */
#include <stdio.h>
#include <neo/api.h>

int main(void) {
    char nom[32];
    neo_file_stat_t st;
    neo_file_store("abc.txt", "ABCDEFGH", 8);  /* 3,3 : le fichier de l'exemple */
    neo_file_opendir(".");                      /* 3,17 : Open Directory */
    for (;;) {
        nom[0] = sizeof nom - 1;                /* capacité, lue par le firmware */
        neo_file_readdir(nom, &st);             /* 3,18 : Read Directory */
        if (neo_api_error())                    /* plus d'entrée */
            break;
        printf("%s %lu\n", nom, (unsigned long)st.size);
    }
    neo_file_closedir();                        /* 3,19 : Close Directory */
    return 0;
}

abc.txt 8
PROG.NEO 4642

// Lister le répertoire courant (groupe 3, fonction 17 : Open Directory).
program liste;
uses crt, neo6502;
var texte, nom: string[16];
    f: string[31];
    taille: cardinal;
    attr: byte;
begin
  texte := 'ABCDEFGH';
  NeoSave('abc.txt', word(@texte) + 1, 8);      // 3,3 : le fichier de l'exemple
  nom := '.';
  NeoOpenDirectory(@nom);                       // 3,17 : Open Directory
  repeat
    f[0] := chr(31);                            // capacité, lue par le firmware
    if not NeoReadDirectory(f, taille, attr) then break;   // 3,18 : Read Directory
    writeln(f, ' ', taille);
  until false;
  NeoCloseDirectory;                            // 3,19 : Close Directory
end.

abc.txt 8
PROG.NEO 741

10 ' Lister le repertoire courant (groupe 3, fonction 17 : Open Directory).
20 d = alloc(16) : for i = 1 to 8 : poke d + i - 1, 64 + i : next i : save "abc.txt", d, 8 : ' le fichier : ABCDEFGH
25 n$ = "abc.txt" : a = alloc(16) : poke a, len(n$) : for i = 1 to len(n$) : poke a + i, asc(mid$(n$, i, 1)) : next i
30 n$ = "." : a = alloc(4) : poke a, len(n$) : for i = 1 to len(n$) : poke a + i, asc(mid$(n$, i, 1)) : next i
40 while peek($ff00) : wend
50 poke $ff04, a & 255 : poke $ff05, a >> 8 : poke $ff01, 17 : poke $ff00, 3 : ' Open Directory
60 b = alloc(34) : e = 0
70 while e = 0
80 poke b, 32 : while peek($ff00) : wend : ' capacite, lue par le firmware
90 poke $ff04, b & 255 : poke $ff05, b >> 8 : poke $ff01, 18 : poke $ff00, 3 : ' Read Directory
100 while peek($ff00) : wend : e = peek($ff02) : t = peek($ff06) + 256 * peek($ff07)
110 if e = 0
120 s$ = "" : for i = 1 to peek(b) : s$ = s$ + chr$(peek(b + i)) : next i
130 print s$;" ";t
140 endif
150 wend
160 while peek($ff00) : wend : poke $ff01, 19 : poke $ff00, 3 : ' Close Directory
170 while peek($ff00) : wend

abc.txt 8
prog.bas 925
boot 0

; Lister le répertoire courant (groupe 3, fonction 17 : Open Directory).
        .cpu "65c02"
        * = $0800
ControlPort    = $FF00             ; +0 groupe, +1 fonction, +2 erreur, +4.. paramètres
WaitMessage    = $FFF4             ; attend que la boîte aux lettres soit libre
WriteCharacter = $FFF1             ; affiche le caractère de A

start:
        jsr WaitMessage            ; 3,3 : le fichier de l'exemple, ABCDEFGH
        lda #<nom
        sta ControlPort+4
        lda #>nom
        sta ControlPort+5
        lda #<abc
        sta ControlPort+6
        lda #>abc
        sta ControlPort+7
        lda #8
        sta ControlPort+8
        stz ControlPort+9
        lda #3
        ldx #3
        jsr appel
        lda #<point
        ldx #>point
        ldy #17                    ; 3,17 : Open Directory
        jsr sur_nom
_suiv:  lda #32
        sta fichier                ; capacité, lue par le firmware
        lda #<fichier
        ldx #>fichier
        ldy #18                    ; 3,18 : Read Directory
        jsr sur_nom
        lda ControlPort+2
        bne _fin                   ; erreur : plus d'entrée
        lda ControlPort+6          ; P2 : taille (poids faible)
        sta taille
        lda #<fichier
        ldx #>fichier
        jsr pecrire
        lda #' '
        jsr WriteCharacter
        lda taille
        jsr decimal
        lda #13
        jsr WriteCharacter
        bra _suiv
_fin:   jsr WaitMessage
        lda #3
        ldx #19                    ; 3,19 : Close Directory
        jmp appel

; Appel du groupe 3, fonction Y, avec en P0-P1 l'adresse du nom donnée par A (poids faible) et X.
sur_nom:
        pha
        jsr WaitMessage
        pla
        sta ControlPort+4
        stx ControlPort+5
        tya
        tax
        lda #3
        jmp appel

; Affiche la chaîne précédée de sa longueur dont l'adresse est dans A (poids faible) et X (poids fort).
pecrire:
        sta ptr
        stx ptr+1
        lda (ptr)
        sta reste
        ldy #1
_p:     lda reste
        beq _pf
        lda (ptr),y
        jsr WriteCharacter
        iny
        dec reste
        bra _p
_pf:    rts
reste:  .byte 0

; Affiche la chaîne terminée par 0 dont l'adresse est dans A (poids faible) et X (poids fort).
ecrire: sta ptr
        stx ptr+1
        ldy #0
_e:     lda (ptr),y
        beq _f
        jsr WriteCharacter
        iny
        bne _e
_f:     rts

; Affiche A (0-255) en décimal, sans zéros de tête.
decimal:
        phx
        phy
        ldx #0
        ldy #100
        jsr _chiffre
        ldy #10
        jsr _chiffre
        ora #'0'
        jsr WriteCharacter
        ply
        plx
        rts
_chiffre:
        sty diviseur
        ldy #0
_div:   cmp diviseur
        bcc _fini
        sbc diviseur
        iny
        bne _div
_fini:  pha
        tya
        bne _ecrit
        cpx #0
        beq _saute
_ecrit: ora #'0'
        jsr WriteCharacter
        ldx #1
_saute: pla
        rts

; Appel : A = groupe, X = fonction (les paramètres sont déjà en place).
appel:  stx ControlPort+1
        sta ControlPort            ; écrit en dernier : lance l'appel
        jmp WaitMessage

ptr      = $80
diviseur: .byte 0

nom:    .byte 7
        .text "abc.txt"
abc:    .text "ABCDEFGH"

point:  .byte 1
        .text "."
taille: .byte 0
fichier: .fill 34

abc.txt 8
PROG.NEO 13

/* Lister le répertoire courant (groupe 3, fonction 18 : Read Directory). */
#include <stdio.h>
#include <neo/api.h>

int main(void) {
    char nom[32];
    neo_file_stat_t st;
    neo_file_store("abc.txt", "ABCDEFGH", 8);  /* 3,3 : le fichier de l'exemple */
    neo_file_opendir(".");                      /* 3,17 : Open Directory */
    for (;;) {
        nom[0] = sizeof nom - 1;                /* capacité, lue par le firmware */
        neo_file_readdir(nom, &st);             /* 3,18 : Read Directory */
        if (neo_api_error())                    /* plus d'entrée */
            break;
        printf("%s %lu\n", nom, (unsigned long)st.size);
    }
    neo_file_closedir();                        /* 3,19 : Close Directory */
    return 0;
}

abc.txt 8
PROG.NEO 4642

// Lister le répertoire courant (groupe 3, fonction 18 : Read Directory).
program liste;
uses crt, neo6502;
var texte, nom: string[16];
    f: string[31];
    taille: cardinal;
    attr: byte;
begin
  texte := 'ABCDEFGH';
  NeoSave('abc.txt', word(@texte) + 1, 8);      // 3,3 : le fichier de l'exemple
  nom := '.';
  NeoOpenDirectory(@nom);                       // 3,17 : Open Directory
  repeat
    f[0] := chr(31);                            // capacité, lue par le firmware
    if not NeoReadDirectory(f, taille, attr) then break;   // 3,18 : Read Directory
    writeln(f, ' ', taille);
  until false;
  NeoCloseDirectory;                            // 3,19 : Close Directory
end.

abc.txt 8
PROG.NEO 741

10 ' Lister le repertoire courant (groupe 3, fonction 18 : Read Directory).
20 d = alloc(16) : for i = 1 to 8 : poke d + i - 1, 64 + i : next i : save "abc.txt", d, 8 : ' le fichier : ABCDEFGH
25 n$ = "abc.txt" : a = alloc(16) : poke a, len(n$) : for i = 1 to len(n$) : poke a + i, asc(mid$(n$, i, 1)) : next i
30 n$ = "." : a = alloc(4) : poke a, len(n$) : for i = 1 to len(n$) : poke a + i, asc(mid$(n$, i, 1)) : next i
40 while peek($ff00) : wend
50 poke $ff04, a & 255 : poke $ff05, a >> 8 : poke $ff01, 17 : poke $ff00, 3 : ' Open Directory
60 b = alloc(34) : e = 0
70 while e = 0
80 poke b, 32 : while peek($ff00) : wend : ' capacite, lue par le firmware
90 poke $ff04, b & 255 : poke $ff05, b >> 8 : poke $ff01, 18 : poke $ff00, 3 : ' Read Directory
100 while peek($ff00) : wend : e = peek($ff02) : t = peek($ff06) + 256 * peek($ff07)
110 if e = 0
120 s$ = "" : for i = 1 to peek(b) : s$ = s$ + chr$(peek(b + i)) : next i
130 print s$;" ";t
140 endif
150 wend
160 while peek($ff00) : wend : poke $ff01, 19 : poke $ff00, 3 : ' Close Directory
170 while peek($ff00) : wend

abc.txt 8
prog.bas 925
boot 0

; Lister le répertoire courant (groupe 3, fonction 18 : Read Directory).
        .cpu "65c02"
        * = $0800
ControlPort    = $FF00             ; +0 groupe, +1 fonction, +2 erreur, +4.. paramètres
WaitMessage    = $FFF4             ; attend que la boîte aux lettres soit libre
WriteCharacter = $FFF1             ; affiche le caractère de A

start:
        jsr WaitMessage            ; 3,3 : le fichier de l'exemple, ABCDEFGH
        lda #<nom
        sta ControlPort+4
        lda #>nom
        sta ControlPort+5
        lda #<abc
        sta ControlPort+6
        lda #>abc
        sta ControlPort+7
        lda #8
        sta ControlPort+8
        stz ControlPort+9
        lda #3
        ldx #3
        jsr appel
        lda #<point
        ldx #>point
        ldy #17                    ; 3,17 : Open Directory
        jsr sur_nom
_suiv:  lda #32
        sta fichier                ; capacité, lue par le firmware
        lda #<fichier
        ldx #>fichier
        ldy #18                    ; 3,18 : Read Directory
        jsr sur_nom
        lda ControlPort+2
        bne _fin                   ; erreur : plus d'entrée
        lda ControlPort+6          ; P2 : taille (poids faible)
        sta taille
        lda #<fichier
        ldx #>fichier
        jsr pecrire
        lda #' '
        jsr WriteCharacter
        lda taille
        jsr decimal
        lda #13
        jsr WriteCharacter
        bra _suiv
_fin:   jsr WaitMessage
        lda #3
        ldx #19                    ; 3,19 : Close Directory
        jmp appel

; Appel du groupe 3, fonction Y, avec en P0-P1 l'adresse du nom donnée par A (poids faible) et X.
sur_nom:
        pha
        jsr WaitMessage
        pla
        sta ControlPort+4
        stx ControlPort+5
        tya
        tax
        lda #3
        jmp appel

; Affiche la chaîne précédée de sa longueur dont l'adresse est dans A (poids faible) et X (poids fort).
pecrire:
        sta ptr
        stx ptr+1
        lda (ptr)
        sta reste
        ldy #1
_p:     lda reste
        beq _pf
        lda (ptr),y
        jsr WriteCharacter
        iny
        dec reste
        bra _p
_pf:    rts
reste:  .byte 0

; Affiche la chaîne terminée par 0 dont l'adresse est dans A (poids faible) et X (poids fort).
ecrire: sta ptr
        stx ptr+1
        ldy #0
_e:     lda (ptr),y
        beq _f
        jsr WriteCharacter
        iny
        bne _e
_f:     rts

; Affiche A (0-255) en décimal, sans zéros de tête.
decimal:
        phx
        phy
        ldx #0
        ldy #100
        jsr _chiffre
        ldy #10
        jsr _chiffre
        ora #'0'
        jsr WriteCharacter
        ply
        plx
        rts
_chiffre:
        sty diviseur
        ldy #0
_div:   cmp diviseur
        bcc _fini
        sbc diviseur
        iny
        bne _div
_fini:  pha
        tya
        bne _ecrit
        cpx #0
        beq _saute
_ecrit: ora #'0'
        jsr WriteCharacter
        ldx #1
_saute: pla
        rts

; Appel : A = groupe, X = fonction (les paramètres sont déjà en place).
appel:  stx ControlPort+1
        sta ControlPort            ; écrit en dernier : lance l'appel
        jmp WaitMessage

ptr      = $80
diviseur: .byte 0

nom:    .byte 7
        .text "abc.txt"
abc:    .text "ABCDEFGH"

point:  .byte 1
        .text "."
taille: .byte 0
fichier: .fill 34

abc.txt 8
PROG.NEO 13

/* Lister le répertoire courant (groupe 3, fonction 19 : Close Directory). */
#include <stdio.h>
#include <neo/api.h>

int main(void) {
    char nom[32];
    neo_file_stat_t st;
    neo_file_store("abc.txt", "ABCDEFGH", 8);  /* 3,3 : le fichier de l'exemple */
    neo_file_opendir(".");                      /* 3,17 : Open Directory */
    for (;;) {
        nom[0] = sizeof nom - 1;                /* capacité, lue par le firmware */
        neo_file_readdir(nom, &st);             /* 3,18 : Read Directory */
        if (neo_api_error())                    /* plus d'entrée */
            break;
        printf("%s %lu\n", nom, (unsigned long)st.size);
    }
    neo_file_closedir();                        /* 3,19 : Close Directory */
    return 0;
}

abc.txt 8
PROG.NEO 4642

// Lister le répertoire courant (groupe 3, fonction 19 : Close Directory).
program liste;
uses crt, neo6502;
var texte, nom: string[16];
    f: string[31];
    taille: cardinal;
    attr: byte;
begin
  texte := 'ABCDEFGH';
  NeoSave('abc.txt', word(@texte) + 1, 8);      // 3,3 : le fichier de l'exemple
  nom := '.';
  NeoOpenDirectory(@nom);                       // 3,17 : Open Directory
  repeat
    f[0] := chr(31);                            // capacité, lue par le firmware
    if not NeoReadDirectory(f, taille, attr) then break;   // 3,18 : Read Directory
    writeln(f, ' ', taille);
  until false;
  NeoCloseDirectory;                            // 3,19 : Close Directory
end.

abc.txt 8
PROG.NEO 741

10 ' Lister le repertoire courant (groupe 3, fonction 19 : Close Directory).
20 d = alloc(16) : for i = 1 to 8 : poke d + i - 1, 64 + i : next i : save "abc.txt", d, 8 : ' le fichier : ABCDEFGH
25 n$ = "abc.txt" : a = alloc(16) : poke a, len(n$) : for i = 1 to len(n$) : poke a + i, asc(mid$(n$, i, 1)) : next i
30 n$ = "." : a = alloc(4) : poke a, len(n$) : for i = 1 to len(n$) : poke a + i, asc(mid$(n$, i, 1)) : next i
40 while peek($ff00) : wend
50 poke $ff04, a & 255 : poke $ff05, a >> 8 : poke $ff01, 17 : poke $ff00, 3 : ' Open Directory
60 b = alloc(34) : e = 0
70 while e = 0
80 poke b, 32 : while peek($ff00) : wend : ' capacite, lue par le firmware
90 poke $ff04, b & 255 : poke $ff05, b >> 8 : poke $ff01, 18 : poke $ff00, 3 : ' Read Directory
100 while peek($ff00) : wend : e = peek($ff02) : t = peek($ff06) + 256 * peek($ff07)
110 if e = 0
120 s$ = "" : for i = 1 to peek(b) : s$ = s$ + chr$(peek(b + i)) : next i
130 print s$;" ";t
140 endif
150 wend
160 while peek($ff00) : wend : poke $ff01, 19 : poke $ff00, 3 : ' Close Directory
170 while peek($ff00) : wend

abc.txt 8
prog.bas 926
boot 0

; Lister le répertoire courant (groupe 3, fonction 19 : Close Directory).
        .cpu "65c02"
        * = $0800
ControlPort    = $FF00             ; +0 groupe, +1 fonction, +2 erreur, +4.. paramètres
WaitMessage    = $FFF4             ; attend que la boîte aux lettres soit libre
WriteCharacter = $FFF1             ; affiche le caractère de A

start:
        jsr WaitMessage            ; 3,3 : le fichier de l'exemple, ABCDEFGH
        lda #<nom
        sta ControlPort+4
        lda #>nom
        sta ControlPort+5
        lda #<abc
        sta ControlPort+6
        lda #>abc
        sta ControlPort+7
        lda #8
        sta ControlPort+8
        stz ControlPort+9
        lda #3
        ldx #3
        jsr appel
        lda #<point
        ldx #>point
        ldy #17                    ; 3,17 : Open Directory
        jsr sur_nom
_suiv:  lda #32
        sta fichier                ; capacité, lue par le firmware
        lda #<fichier
        ldx #>fichier
        ldy #18                    ; 3,18 : Read Directory
        jsr sur_nom
        lda ControlPort+2
        bne _fin                   ; erreur : plus d'entrée
        lda ControlPort+6          ; P2 : taille (poids faible)
        sta taille
        lda #<fichier
        ldx #>fichier
        jsr pecrire
        lda #' '
        jsr WriteCharacter
        lda taille
        jsr decimal
        lda #13
        jsr WriteCharacter
        bra _suiv
_fin:   jsr WaitMessage
        lda #3
        ldx #19                    ; 3,19 : Close Directory
        jmp appel

; Appel du groupe 3, fonction Y, avec en P0-P1 l'adresse du nom donnée par A (poids faible) et X.
sur_nom:
        pha
        jsr WaitMessage
        pla
        sta ControlPort+4
        stx ControlPort+5
        tya
        tax
        lda #3
        jmp appel

; Affiche la chaîne précédée de sa longueur dont l'adresse est dans A (poids faible) et X (poids fort).
pecrire:
        sta ptr
        stx ptr+1
        lda (ptr)
        sta reste
        ldy #1
_p:     lda reste
        beq _pf
        lda (ptr),y
        jsr WriteCharacter
        iny
        dec reste
        bra _p
_pf:    rts
reste:  .byte 0

; Affiche la chaîne terminée par 0 dont l'adresse est dans A (poids faible) et X (poids fort).
ecrire: sta ptr
        stx ptr+1
        ldy #0
_e:     lda (ptr),y
        beq _f
        jsr WriteCharacter
        iny
        bne _e
_f:     rts

; Affiche A (0-255) en décimal, sans zéros de tête.
decimal:
        phx
        phy
        ldx #0
        ldy #100
        jsr _chiffre
        ldy #10
        jsr _chiffre
        ora #'0'
        jsr WriteCharacter
        ply
        plx
        rts
_chiffre:
        sty diviseur
        ldy #0
_div:   cmp diviseur
        bcc _fini
        sbc diviseur
        iny
        bne _div
_fini:  pha
        tya
        bne _ecrit
        cpx #0
        beq _saute
_ecrit: ora #'0'
        jsr WriteCharacter
        ldx #1
_saute: pla
        rts

; Appel : A = groupe, X = fonction (les paramètres sont déjà en place).
appel:  stx ControlPort+1
        sta ControlPort            ; écrit en dernier : lance l'appel
        jmp WaitMessage

ptr      = $80
diviseur: .byte 0

nom:    .byte 7
        .text "abc.txt"
abc:    .text "ABCDEFGH"

point:  .byte 1
        .text "."
taille: .byte 0
fichier: .fill 34

abc.txt 8
PROG.NEO 13

/* Copier abc.txt, puis relire la copie (groupe 3, fonction 20). */
#include <stdio.h>
#include <neo/api.h>

int main(void) {
    char relu[9] = { 0 };
    neo_file_store("abc.txt", "ABCDEFGH", 8);  /* 3,3 : le fichier de l'exemple */
    neo_file_copy("abc.txt", "copie.txt");      /* Copy File */
    neo_file_load("copie.txt", relu);           /* 3,2 */
    printf("Copie : %s\n", relu);
    return 0;
}

Copie : ABCDEFGH

// Copier abc.txt, puis relire la copie (groupe 3, fonction 20).
program copier;
uses crt, neo6502;
var texte, nom, copie, relu: string[16];
begin
  texte := 'ABCDEFGH';
  NeoSave('abc.txt', word(@texte) + 1, 8);      // 3,3 : le fichier de l'exemple
  nom := 'abc.txt';
  copie := 'copie.txt';
  NeoCopyFile(@nom, @copie);                    // Copy File
  NeoLoad('copie.txt', word(@relu) + 1);        // 3,2
  relu[0] := chr(8);
  writeln('Copie : ', relu);
end.

Copie : ABCDEFGH

10 ' Copier abc.txt, puis relire la copie (groupe 3, fonction 20)
20 d = alloc(16) : for i = 1 to 8 : poke d + i - 1, 64 + i : next i : save "abc.txt", d, 8 : ' le fichier : ABCDEFGH
25 n$ = "abc.txt" : a = alloc(16) : poke a, len(n$) : for i = 1 to len(n$) : poke a + i, asc(mid$(n$, i, 1)) : next i
30 c = a : n$ = "copie.txt" : a = alloc(16) : poke a, len(n$) : for i = 1 to len(n$) : poke a + i, asc(mid$(n$, i, 1)) : next i
40 while peek($ff00) : wend
50 poke $ff04, c & 255 : poke $ff05, c >> 8 : poke $ff06, a & 255 : poke $ff07, a >> 8 : poke $ff01, 20 : poke $ff00, 3
60 while peek($ff00) : wend
70 r = alloc(16) : load "copie.txt", r
80 s$ = "" : for i = 0 to 7 : s$ = s$ + chr$(peek(r + i)) : next i
90 print "Copie : ";s$

Copie : ABCDEFGH

; Copier abc.txt, puis relire la copie (groupe 3, fonction 20).
        .cpu "65c02"
        * = $0800
ControlPort    = $FF00             ; +0 groupe, +1 fonction, +2 erreur, +4.. paramètres
WaitMessage    = $FFF4             ; attend que la boîte aux lettres soit libre
WriteCharacter = $FFF1             ; affiche le caractère de A

start:
        jsr WaitMessage            ; 3,3 : le fichier de l'exemple, ABCDEFGH
        lda #<nom
        sta ControlPort+4
        lda #>nom
        sta ControlPort+5
        lda #<abc
        sta ControlPort+6
        lda #>abc
        sta ControlPort+7
        lda #8
        sta ControlPort+8
        stz ControlPort+9
        lda #3
        ldx #3
        jsr appel
        jsr WaitMessage
        lda #<nom
        sta ControlPort+4          ; P0-P1 : nom d'origine
        lda #>nom
        sta ControlPort+5
        lda #<copie
        sta ControlPort+6          ; P2-P3 : nom de la copie
        lda #>copie
        sta ControlPort+7
        lda #3
        ldx #20                    ; fonction 20 : Copy File
        jsr appel
        jsr WaitMessage
        lda #<copie
        sta ControlPort+4
        lda #>copie
        sta ControlPort+5
        lda #<relu
        sta ControlPort+6          ; P2-P3 : destination
        lda #>relu
        sta ControlPort+7
        lda #3
        ldx #2                     ; 3,2 : Load File
        jsr appel
        lda #<m
        ldx #>m
        jsr ecrire
        lda #<relu
        ldx #>relu
        jsr ecrire
        lda #13
        jmp WriteCharacter

; Affiche la chaîne terminée par 0 dont l'adresse est dans A (poids faible) et X (poids fort).
ecrire: sta ptr
        stx ptr+1
        ldy #0
_e:     lda (ptr),y
        beq _f
        jsr WriteCharacter
        iny
        bne _e
_f:     rts

; Affiche A (0-255) en décimal, sans zéros de tête.
decimal:
        phx
        phy
        ldx #0
        ldy #100
        jsr _chiffre
        ldy #10
        jsr _chiffre
        ora #'0'
        jsr WriteCharacter
        ply
        plx
        rts
_chiffre:
        sty diviseur
        ldy #0
_div:   cmp diviseur
        bcc _fini
        sbc diviseur
        iny
        bne _div
_fini:  pha
        tya
        bne _ecrit
        cpx #0
        beq _saute
_ecrit: ora #'0'
        jsr WriteCharacter
        ldx #1
_saute: pla
        rts

; Appel : A = groupe, X = fonction (les paramètres sont déjà en place).
appel:  stx ControlPort+1
        sta ControlPort            ; écrit en dernier : lance l'appel
        jmp WaitMessage

ptr      = $80
diviseur: .byte 0

nom:    .byte 7
        .text "abc.txt"
abc:    .text "ABCDEFGH"

copie:  .byte 9
        .text "copie.txt"
relu:   .fill 9                    ; zéros : la chaîne relue sera terminée
m:      .text "Copie : ", 0

Copie : ABCDEFGH

/* Mettre un fichier en lecture seule (groupe 3, fonction 21). */
#include <stdio.h>
#include <neo6502.h>
#include <neo/api.h>

/* Appel brut de la boîte aux lettres : fonction puis groupe (écrit en dernier, il lance l'appel). */
static void api(uint8_t groupe, uint8_t fonction) {
    ControlPort.function = fonction;
    ControlPort.command = groupe;
    while (ControlPort.command)        /* attendre la fin */
        ;
}
static void libre(void) {              /* attendre que la boîte aux lettres soit libre */
    while (ControlPort.command)
        ;
}

static const uint8_t nom[] = "\x07" "abc.txt";

int main(void) {
    neo_file_store("abc.txt", "ABCDEFGH", 8);  /* 3,3 : le fichier de l'exemple */
    neo_file_set_attr("abc.txt", NEO_FILE_ATTR_READ_ONLY);  /* Set file attributes */
    libre();
    ControlPort.params[0] = (uint16_t)nom & 0xFF;
    ControlPort.params[1] = (uint16_t)nom >> 8;
    api(3, 16);                                 /* 3,16 : attributs en P4 */
    printf("Lecture seule : %u\n", ControlPort.params[4] & NEO_FILE_ATTR_READ_ONLY);
    return 0;
}

Lecture seule : 8

// Mettre un fichier en lecture seule (groupe 3, fonction 21).
program attributs;
uses crt, neo6502;
var texte, nom: string[16];
    taille: cardinal;
    attr: byte;
begin
  texte := 'ABCDEFGH';
  NeoSave('abc.txt', word(@texte) + 1, 8);      // 3,3 : le fichier de l'exemple
  nom := 'abc.txt';
  attr := FI_ATTR_READONLY;
  NeoSetAttr(@nom, attr);                       // Set file attributes
  NeoStatFile(@nom, taille, attr);              // 3,16
  writeln('Lecture seule : ', attr and FI_ATTR_READONLY);
end.

Lecture seule : 8

10 ' Mettre un fichier en lecture seule (groupe 3, fonction 21)
20 d = alloc(16) : for i = 1 to 8 : poke d + i - 1, 64 + i : next i : save "abc.txt", d, 8 : ' le fichier : ABCDEFGH
25 n$ = "abc.txt" : a = alloc(16) : poke a, len(n$) : for i = 1 to len(n$) : poke a + i, asc(mid$(n$, i, 1)) : next i
30 while peek($ff00) : wend
40 poke $ff04, a & 255 : poke $ff05, a >> 8 : poke $ff06, 8 : poke $ff01, 21 : poke $ff00, 3
50 while peek($ff00) : wend
60 poke $ff04, a & 255 : poke $ff05, a >> 8 : poke $ff01, 16 : poke $ff00, 3
70 while peek($ff00) : wend : r = peek($ff08) & 8
80 print "Lecture seule : ";r

Lecture seule : 8

; Mettre un fichier en lecture seule (groupe 3, fonction 21).
        .cpu "65c02"
        * = $0800
ControlPort    = $FF00             ; +0 groupe, +1 fonction, +2 erreur, +4.. paramètres
WaitMessage    = $FFF4             ; attend que la boîte aux lettres soit libre
WriteCharacter = $FFF1             ; affiche le caractère de A

start:
        jsr WaitMessage            ; 3,3 : le fichier de l'exemple, ABCDEFGH
        lda #<nom
        sta ControlPort+4
        lda #>nom
        sta ControlPort+5
        lda #<abc
        sta ControlPort+6
        lda #>abc
        sta ControlPort+7
        lda #8
        sta ControlPort+8
        stz ControlPort+9
        lda #3
        ldx #3
        jsr appel
        jsr WaitMessage
        lda #<nom
        sta ControlPort+4          ; P0-P1 : nom
        lda #>nom
        sta ControlPort+5
        lda #8
        sta ControlPort+6          ; P2 : lecture seule
        lda #3
        ldx #21                    ; fonction 21 : Set file attributes
        jsr appel
        lda #<nom
        ldx #>nom
        ldy #16                    ; 3,16 : attributs en P4
        jsr sur_nom
        lda ControlPort+8
        and #8
        pha
        lda #<m
        ldx #>m
        jsr ecrire
        pla
        jsr decimal
        lda #13
        jmp WriteCharacter

; Appel du groupe 3, fonction Y, avec en P0-P1 l'adresse du nom donnée par A (poids faible) et X.
sur_nom:
        pha
        jsr WaitMessage
        pla
        sta ControlPort+4
        stx ControlPort+5
        tya
        tax
        lda #3
        jmp appel

; Affiche la chaîne terminée par 0 dont l'adresse est dans A (poids faible) et X (poids fort).
ecrire: sta ptr
        stx ptr+1
        ldy #0
_e:     lda (ptr),y
        beq _f
        jsr WriteCharacter
        iny
        bne _e
_f:     rts

; Affiche A (0-255) en décimal, sans zéros de tête.
decimal:
        phx
        phy
        ldx #0
        ldy #100
        jsr _chiffre
        ldy #10
        jsr _chiffre
        ora #'0'
        jsr WriteCharacter
        ply
        plx
        rts
_chiffre:
        sty diviseur
        ldy #0
_div:   cmp diviseur
        bcc _fini
        sbc diviseur
        iny
        bne _div
_fini:  pha
        tya
        bne _ecrit
        cpx #0
        beq _saute
_ecrit: ora #'0'
        jsr WriteCharacter
        ldx #1
_saute: pla
        rts

; Appel : A = groupe, X = fonction (les paramètres sont déjà en place).
appel:  stx ControlPort+1
        sta ControlPort            ; écrit en dernier : lance l'appel
        jmp WaitMessage

ptr      = $80
diviseur: .byte 0

nom:    .byte 7
        .text "abc.txt"
abc:    .text "ABCDEFGH"

m:      .text "Lecture seule : ", 0

Lecture seule : 8

/* Lire octet par octet jusqu'à la fin du fichier (groupe 3, fonction 22). */
#include <stdio.h>
#include <neo/api.h>

int main(void) {
    char c;
    unsigned n = 0;
    neo_file_store("abc.txt", "ABCDEFGH", 8);  /* 3,3 : le fichier de l'exemple */
    neo_file_open(1, "abc.txt", NEO_FILE_READ);
    while (!neo_file_eof(1)) {                  /* Check End of File */
        neo_file_read(1, &c, 1);
        n++;
    }
    neo_file_close(1);
    printf("%u octets lus avant la fin du fichier\n", n);
    return 0;
}

8 octets lus avant la fin du fichier

// Lire octet par octet jusqu'à la fin du fichier (groupe 3, fonction 22).
program fin;
uses crt, neo6502;
var texte, nom: string[16];
    c: byte;
    n: word;

function fin_de_fichier(canal: byte): boolean;
begin
  NeoWaitMessage;
  NeoMessage.params[0] := canal;
  NeoSendMessage(3, 22);                        // Check End of File
  NeoWaitMessage;
  result := NeoMessage.params[0] <> 0;
end;

begin
  texte := 'ABCDEFGH';
  NeoSave('abc.txt', word(@texte) + 1, 8);      // 3,3 : le fichier de l'exemple
  nom := 'abc.txt';
  NeoOpenFile(1, @nom, 0);
  n := 0;
  while not fin_de_fichier(1) do
  begin
    NeoReadFile(1, word(@c), 1);
    inc(n);
  end;
  NeoCloseFile(1);
  writeln(n, ' octets lus avant la fin du fichier');
end.

8 octets lus avant la fin du fichier

10 ' Lire octet par octet jusqu'a la fin du fichier (groupe 3, fonction 22)
20 d = alloc(16) : for i = 1 to 8 : poke d + i - 1, 64 + i : next i : save "abc.txt", d, 8 : ' le fichier : ABCDEFGH
25 n$ = "abc.txt" : a = alloc(16) : poke a, len(n$) : for i = 1 to len(n$) : poke a + i, asc(mid$(n$, i, 1)) : next i
30 b = alloc(4) : m = 0 : while peek($ff00) : wend : poke $ff04, 1 : poke $ff05, a & 255 : poke $ff06, a >> 8 : poke $ff07, m : poke $ff01, 4 : poke $ff00, 3 : while peek($ff00) : wend
40 n = 0
50 while eof(1) = 0
60 poke $ff04, 1 : poke $ff05, b & 255 : poke $ff06, b >> 8 : poke $ff07, 1 : poke $ff08, 0 : poke $ff01, 8 : poke $ff00, 3
70 while peek($ff00) : wend
80 n = n + 1
90 wend
100 close
110 print n;" octets lus avant la fin du fichier"

8 octets lus avant la fin du fichier

; Lire octet par octet jusqu'à la fin du fichier (groupe 3, fonction 22).
        .cpu "65c02"
        * = $0800
ControlPort    = $FF00             ; +0 groupe, +1 fonction, +2 erreur, +4.. paramètres
WaitMessage    = $FFF4             ; attend que la boîte aux lettres soit libre
WriteCharacter = $FFF1             ; affiche le caractère de A

start:
        jsr WaitMessage            ; 3,3 : le fichier de l'exemple, ABCDEFGH
        lda #<nom
        sta ControlPort+4
        lda #>nom
        sta ControlPort+5
        lda #<abc
        sta ControlPort+6
        lda #>abc
        sta ControlPort+7
        lda #8
        sta ControlPort+8
        stz ControlPort+9
        lda #3
        ldx #3
        jsr appel
        lda #0
        jsr ouvrir
_suiv:  jsr WaitMessage
        lda #1
        sta ControlPort+4          ; P0 : canal 1
        lda #3
        ldx #22                    ; fonction 22 : Check End of File
        jsr appel
        lda ControlPort+4          ; non nul : fin
        bne _fin
        jsr WaitMessage
        lda #1
        sta ControlPort+4
        lda #<octet
        sta ControlPort+5
        lda #>octet
        sta ControlPort+6
        lda #1
        sta ControlPort+7
        stz ControlPort+8
        lda #3
        ldx #8                     ; lire un octet
        jsr appel
        inc compte
        bra _suiv
_fin:   jsr fermer
        lda compte
        jsr decimal
        lda #<m
        ldx #>m
        jmp ecrire
; Ouvrir abc.txt sur le canal 1 dans le mode A.
ouvrir: pha
        jsr WaitMessage
        lda #1
        sta ControlPort+4          ; P0 : canal 1
        lda #<nom
        sta ControlPort+5          ; P1-P2 : nom
        lda #>nom
        sta ControlPort+6
        pla
        sta ControlPort+7          ; P3 : mode
        lda #3
        ldx #4                     ; 3,4 : File Open
        jmp appel

; Fermer le canal 1.
fermer: jsr WaitMessage
        lda #1
        sta ControlPort+4
        lda #3
        ldx #5                     ; 3,5 : File Close
        jmp appel

; Affiche la chaîne terminée par 0 dont l'adresse est dans A (poids faible) et X (poids fort).
ecrire: sta ptr
        stx ptr+1
        ldy #0
_e:     lda (ptr),y
        beq _f
        jsr WriteCharacter
        iny
        bne _e
_f:     rts

; Affiche A (0-255) en décimal, sans zéros de tête.
decimal:
        phx
        phy
        ldx #0
        ldy #100
        jsr _chiffre
        ldy #10
        jsr _chiffre
        ora #'0'
        jsr WriteCharacter
        ply
        plx
        rts
_chiffre:
        sty diviseur
        ldy #0
_div:   cmp diviseur
        bcc _fini
        sbc diviseur
        iny
        bne _div
_fini:  pha
        tya
        bne _ecrit
        cpx #0
        beq _saute
_ecrit: ora #'0'
        jsr WriteCharacter
        ldx #1
_saute: pla
        rts

; Appel : A = groupe, X = fonction (les paramètres sont déjà en place).
appel:  stx ControlPort+1
        sta ControlPort            ; écrit en dernier : lance l'appel
        jmp WaitMessage

ptr      = $80
diviseur: .byte 0

nom:    .byte 7
        .text "abc.txt"
abc:    .text "ABCDEFGH"

octet:  .byte 0
compte: .byte 0
m:      .text " octets lus avant la fin du fichier", 13, 0

8 octets lus avant la fin du fichier

/* Afficher le répertoire courant (groupe 3, fonction 23). */
#include <stdio.h>
#include <neo/api.h>

static char cwd[33];

static const char *courant(void) {
    neo_file_get_cwd(cwd, 32);                  /* 3,23 : chaîne précédée de sa longueur */
    cwd[(uint8_t)cwd[0] + 1] = 0;
    return cwd + 1;
}

int main(void) {
    printf("Repertoire courant : %s\n", courant());   /* Get Current Working Directory */
    return 0;
}

Repertoire courant : /

// Afficher le répertoire courant (groupe 3, fonction 23).
program cwd;
uses crt, neo6502;

function courant: string;
var cwd: string[32];
begin
  NeoWaitMessage;
  wordParams[0] := word(@cwd);                  // P0-P1 : tampon
  NeoMessage.params[2] := 32;                   // P2 : longueur maximale
  NeoSendMessage(3, 23);                        // 3,23 : Get Current Working Directory
  NeoWaitMessage;
  result := cwd;
end;

begin
  writeln('Repertoire courant : ', courant);   // Get Current Working Directory
end.

Repertoire courant : /

10 ' Afficher le repertoire courant (groupe 3, fonction 23)
20 while peek($ff00) : wend
30 b = alloc(34) : poke $ff04, b & 255 : poke $ff05, b >> 8 : poke $ff06, 32 : poke $ff01, 23 : poke $ff00, 3
40 while peek($ff00) : wend : s$ = "" : for i = 1 to peek(b) : s$ = s$ + chr$(peek(b + i)) : next i
50 print "Repertoire courant : ";s$

Repertoire courant : /

; Afficher le répertoire courant (groupe 3, fonction 23).
        .cpu "65c02"
        * = $0800
ControlPort    = $FF00             ; +0 groupe, +1 fonction, +2 erreur, +4.. paramètres
WaitMessage    = $FFF4             ; attend que la boîte aux lettres soit libre
WriteCharacter = $FFF1             ; affiche le caractère de A

start:  jsr courant                ; fonction 23 : Get Current Working Directory
        lda #<m
        ldx #>m
        jsr ecrire
        lda #<cwd
        ldx #>cwd
        jsr pecrire
        lda #13
        jmp WriteCharacter

; Répertoire courant dans cwd (précédé de sa longueur).
courant:
        jsr WaitMessage
        lda #<cwd
        sta ControlPort+4          ; P0-P1 : tampon
        lda #>cwd
        sta ControlPort+5
        lda #32
        sta ControlPort+6          ; P2 : longueur maximale
        lda #3
        ldx #23                    ; 3,23 : Get Current Working Directory
        jmp appel
cwd:    .fill 34

; Affiche la chaîne précédée de sa longueur dont l'adresse est dans A (poids faible) et X (poids fort).
pecrire:
        sta ptr
        stx ptr+1
        lda (ptr)
        sta reste
        ldy #1
_p:     lda reste
        beq _pf
        lda (ptr),y
        jsr WriteCharacter
        iny
        dec reste
        bra _p
_pf:    rts
reste:  .byte 0

; Affiche la chaîne terminée par 0 dont l'adresse est dans A (poids faible) et X (poids fort).
ecrire: sta ptr
        stx ptr+1
        ldy #0
_e:     lda (ptr),y
        beq _f
        jsr WriteCharacter
        iny
        bne _e
_f:     rts

; Affiche A (0-255) en décimal, sans zéros de tête.
decimal:
        phx
        phy
        ldx #0
        ldy #100
        jsr _chiffre
        ldy #10
        jsr _chiffre
        ora #'0'
        jsr WriteCharacter
        ply
        plx
        rts
_chiffre:
        sty diviseur
        ldy #0
_div:   cmp diviseur
        bcc _fini
        sbc diviseur
        iny
        bne _div
_fini:  pha
        tya
        bne _ecrit
        cpx #0
        beq _saute
_ecrit: ora #'0'
        jsr WriteCharacter
        ldx #1
_saute: pla
        rts

; Appel : A = groupe, X = fonction (les paramètres sont déjà en place).
appel:  stx ControlPort+1
        sta ControlPort            ; écrit en dernier : lance l'appel
        jmp WaitMessage

ptr      = $80
diviseur: .byte 0

m:      .text "Repertoire courant : ", 0

Repertoire courant : /

/* Énumérer les volumes présents (groupe 3, fonction 24, Trinity). */
#include <stdio.h>
#include <neo6502.h>
#include <neo/api.h>

/* Appel brut de la boîte aux lettres : fonction puis groupe (écrit en dernier, il lance l'appel). */
static void api(uint8_t groupe, uint8_t fonction) {
    ControlPort.function = fonction;
    ControlPort.command = groupe;
    while (ControlPort.command)        /* attendre la fin */
        ;
}
static void libre(void) {              /* attendre que la boîte aux lettres soit libre */
    while (ControlPort.command)
        ;
}

static uint8_t nom[17];

int main(void) {
    for (uint8_t v = 0; v < 4; v++) {
        libre();
        nom[0] = 15;                            /* capacité */
        ControlPort.params[0] = v;              /* P0 : volume */
        ControlPort.params[1] = (uint16_t)nom & 0xFF;
        ControlPort.params[2] = (uint16_t)nom >> 8;
        api(3, 24);                             /* Volume Info */
        if (ControlPort.error)                  /* pas de volume n° v */
            continue;
        nom[nom[0] + 1] = 0;
        printf("Volume %u : %s\n", v, (char *)nom + 1);
    }
    return 0;
}

Volume 0 : HOST0

// Énumérer les volumes présents (groupe 3, fonction 24, Trinity).
program volumes;
uses crt, neo6502;
var nom: string[15];
    v: byte;
begin
  for v := 0 to 3 do
  begin
    nom[0] := chr(15);                          // capacité
    NeoWaitMessage;
    NeoMessage.params[0] := v;                  // P0 : volume
    wordxParams[0] := word(@nom);               // P1-P2 : tampon
    NeoSendMessage(3, 24);                      // Volume Info
    NeoWaitMessage;
    if NeoMessage.error = 0 then
      writeln('Volume ', v, ' : ', nom);
  end;
end.

Volume 0 : HOST0

10 ' Enumerer les volumes presents (groupe 3, fonction 24, Trinity)
20 b = alloc(18)
30 for v = 0 to 3
40 poke b, 15 : while peek($ff00) : wend
50 poke $ff04, v : poke $ff05, b & 255 : poke $ff06, b >> 8 : poke $ff01, 24 : poke $ff00, 3
60 while peek($ff00) : wend : e = peek($ff02)
70 if e = 0
80 s$ = "" : for i = 1 to peek(b) : s$ = s$ + chr$(peek(b + i)) : next i
90 print "Volume ";v;" : ";s$
100 endif
110 next v

Volume 0 : HOST0

; Énumérer les volumes présents (groupe 3, fonction 24, Trinity).
        .cpu "65c02"
        * = $0800
ControlPort    = $FF00             ; +0 groupe, +1 fonction, +2 erreur, +4.. paramètres
WaitMessage    = $FFF4             ; attend que la boîte aux lettres soit libre
WriteCharacter = $FFF1             ; affiche le caractère de A

start:  stz vol
_suiv:  lda #15
        sta vnom                   ; capacité
        jsr WaitMessage
        lda vol
        sta ControlPort+4          ; P0 : volume
        lda #<vnom
        sta ControlPort+5          ; P1-P2 : tampon
        lda #>vnom
        sta ControlPort+6
        lda #3
        ldx #24                    ; fonction 24 : Volume Info
        jsr appel
        lda ControlPort+2
        bne _autre                 ; pas de volume de ce numéro
        lda #<m
        ldx #>m
        jsr ecrire
        lda vol
        jsr decimal
        lda #<m2
        ldx #>m2
        jsr ecrire
        lda #<vnom
        ldx #>vnom
        jsr pecrire
        lda #13
        jsr WriteCharacter
_autre: inc vol
        lda vol
        cmp #4
        bne _suiv
        rts

; Affiche la chaîne précédée de sa longueur dont l'adresse est dans A (poids faible) et X (poids fort).
pecrire:
        sta ptr
        stx ptr+1
        lda (ptr)
        sta reste
        ldy #1
_p:     lda reste
        beq _pf
        lda (ptr),y
        jsr WriteCharacter
        iny
        dec reste
        bra _p
_pf:    rts
reste:  .byte 0

; Affiche la chaîne terminée par 0 dont l'adresse est dans A (poids faible) et X (poids fort).
ecrire: sta ptr
        stx ptr+1
        ldy #0
_e:     lda (ptr),y
        beq _f
        jsr WriteCharacter
        iny
        bne _e
_f:     rts

; Affiche A (0-255) en décimal, sans zéros de tête.
decimal:
        phx
        phy
        ldx #0
        ldy #100
        jsr _chiffre
        ldy #10
        jsr _chiffre
        ora #'0'
        jsr WriteCharacter
        ply
        plx
        rts
_chiffre:
        sty diviseur
        ldy #0
_div:   cmp diviseur
        bcc _fini
        sbc diviseur
        iny
        bne _div
_fini:  pha
        tya
        bne _ecrit
        cpx #0
        beq _saute
_ecrit: ora #'0'
        jsr WriteCharacter
        ldx #1
_saute: pla
        rts

; Appel : A = groupe, X = fonction (les paramètres sont déjà en place).
appel:  stx ControlPort+1
        sta ControlPort            ; écrit en dernier : lance l'appel
        jmp WaitMessage

ptr      = $80
diviseur: .byte 0

vol:    .byte 0
vnom:   .fill 17
m:      .text "Volume ", 0
m2:     .text " : ", 0

Volume 0 : HOST0

/* Choisir le volume 0 (groupe 3, fonction 25, Trinity). */
#include <stdio.h>
#include <neo6502.h>
#include <neo/api.h>

/* Appel brut de la boîte aux lettres : fonction puis groupe (écrit en dernier, il lance l'appel). */
static void api(uint8_t groupe, uint8_t fonction) {
    ControlPort.function = fonction;
    ControlPort.command = groupe;
    while (ControlPort.command)        /* attendre la fin */
        ;
}
static void libre(void) {              /* attendre que la boîte aux lettres soit libre */
    while (ControlPort.command)
        ;
}

static uint8_t volume_courant(void) {
    libre();
    api(3, 26);                                 /* 3,26 : Get Current Volume */
    return ControlPort.params[0];
}

int main(void) {
    libre();
    ControlPort.params[0] = 0;                  /* P0 : volume */
    api(3, 25);                                 /* Select Volume */
    uint8_t e = ControlPort.error;
    printf("Volume 0 choisi, erreur %u, volume courant : %u\n", e, volume_courant());
    return 0;
}

Volume 0 choisi, erreur 0, volume courant : 0

// Choisir le volume 0 (groupe 3, fonction 25, Trinity).
program choisir;
uses crt, neo6502;
var e, v: byte;
begin
  NeoWaitMessage;
  NeoMessage.params[0] := 0;                    // P0 : volume
  NeoSendMessage(3, 25);                        // Select Volume
  NeoWaitMessage;
  e := NeoMessage.error;
  NeoSendMessage(3, 26);                        // 3,26 : Get Current Volume
  NeoWaitMessage;
  v := NeoMessage.params[0];
  writeln('Volume 0 choisi, erreur ', e, ', volume courant : ', v);
end.

Volume 0 choisi, erreur 0, volume courant : 0

10 ' Choisir le volume 0 (groupe 3, fonction 25, Trinity)
20 while peek($ff00) : wend
30 poke $ff04, 0 : poke $ff01, 25 : poke $ff00, 3
40 while peek($ff00) : wend : e = peek($ff02)
50 poke $ff01, 26 : poke $ff00, 3
60 while peek($ff00) : wend : v = peek($ff04)
70 print "Volume 0 choisi, erreur ";e;", volume courant : ";v

Volume 0 choisi, erreur 0, volume courant : 0

; Choisir le volume 0 (groupe 3, fonction 25, Trinity).
        .cpu "65c02"
        * = $0800
ControlPort    = $FF00             ; +0 groupe, +1 fonction, +2 erreur, +4.. paramètres
WaitMessage    = $FFF4             ; attend que la boîte aux lettres soit libre
WriteCharacter = $FFF1             ; affiche le caractère de A

start:  jsr WaitMessage
        stz ControlPort+4          ; P0 : volume 0
        lda #3
        ldx #25                    ; fonction 25 : Select Volume
        jsr appel
        lda ControlPort+2
        sta err
        lda #3
        ldx #26                    ; 3,26 : Get Current Volume
        jsr appel
        lda ControlPort+4
        sta vol
        lda #<m1
        ldx #>m1
        jsr ecrire
        lda err
        jsr decimal
        lda #<m2
        ldx #>m2
        jsr ecrire
        lda vol
        jsr decimal
        lda #13
        jmp WriteCharacter

; Affiche la chaîne terminée par 0 dont l'adresse est dans A (poids faible) et X (poids fort).
ecrire: sta ptr
        stx ptr+1
        ldy #0
_e:     lda (ptr),y
        beq _f
        jsr WriteCharacter
        iny
        bne _e
_f:     rts

; Affiche A (0-255) en décimal, sans zéros de tête.
decimal:
        phx
        phy
        ldx #0
        ldy #100
        jsr _chiffre
        ldy #10
        jsr _chiffre
        ora #'0'
        jsr WriteCharacter
        ply
        plx
        rts
_chiffre:
        sty diviseur
        ldy #0
_div:   cmp diviseur
        bcc _fini
        sbc diviseur
        iny
        bne _div
_fini:  pha
        tya
        bne _ecrit
        cpx #0
        beq _saute
_ecrit: ora #'0'
        jsr WriteCharacter
        ldx #1
_saute: pla
        rts

; Appel : A = groupe, X = fonction (les paramètres sont déjà en place).
appel:  stx ControlPort+1
        sta ControlPort            ; écrit en dernier : lance l'appel
        jmp WaitMessage

ptr      = $80
diviseur: .byte 0

err:    .byte 0
vol:    .byte 0
m1:     .text "Volume 0 choisi, erreur ", 0
m2:     .text ", volume courant : ", 0

Volume 0 choisi, erreur 0, volume courant : 0

/* Numéro du volume courant (groupe 3, fonction 26, Trinity). */
#include <stdio.h>
#include <neo6502.h>
#include <neo/api.h>

/* Appel brut de la boîte aux lettres : fonction puis groupe (écrit en dernier, il lance l'appel). */
static void api(uint8_t groupe, uint8_t fonction) {
    ControlPort.function = fonction;
    ControlPort.command = groupe;
    while (ControlPort.command)        /* attendre la fin */
        ;
}
static void libre(void) {              /* attendre que la boîte aux lettres soit libre */
    while (ControlPort.command)
        ;
}

int main(void) {
    libre();
    api(3, 26);                                 /* Get Current Volume */
    printf("Volume courant : %u\n", ControlPort.params[0]);
    return 0;
}

Volume courant : 0

// Numéro du volume courant (groupe 3, fonction 26, Trinity).
program volume;
uses crt, neo6502;
var v: byte;
begin
  NeoWaitMessage;
  NeoSendMessage(3, 26);                        // Get Current Volume
  NeoWaitMessage;
  v := NeoMessage.params[0];
  writeln('Volume courant : ', v);
end.

Volume courant : 0

10 ' Numero du volume courant (groupe 3, fonction 26, Trinity)
20 while peek($ff00) : wend
30 poke $ff01, 26 : poke $ff00, 3
40 while peek($ff00) : wend : v = peek($ff04)
50 print "Volume courant : ";v

Volume courant : 0

; Numéro du volume courant (groupe 3, fonction 26, Trinity).
        .cpu "65c02"
        * = $0800
ControlPort    = $FF00             ; +0 groupe, +1 fonction, +2 erreur, +4.. paramètres
WaitMessage    = $FFF4             ; attend que la boîte aux lettres soit libre
WriteCharacter = $FFF1             ; affiche le caractère de A

start:  jsr WaitMessage
        lda #3
        ldx #26                    ; fonction 26 : Get Current Volume
        jsr appel
        lda ControlPort+4          ; P0 : volume
        pha
        lda #<m
        ldx #>m
        jsr ecrire
        pla
        jsr decimal
        lda #13
        jmp WriteCharacter

; Affiche la chaîne terminée par 0 dont l'adresse est dans A (poids faible) et X (poids fort).
ecrire: sta ptr
        stx ptr+1
        ldy #0
_e:     lda (ptr),y
        beq _f
        jsr WriteCharacter
        iny
        bne _e
_f:     rts

; Affiche A (0-255) en décimal, sans zéros de tête.
decimal:
        phx
        phy
        ldx #0
        ldy #100
        jsr _chiffre
        ldy #10
        jsr _chiffre
        ora #'0'
        jsr WriteCharacter
        ply
        plx
        rts
_chiffre:
        sty diviseur
        ldy #0
_div:   cmp diviseur
        bcc _fini
        sbc diviseur
        iny
        bne _div
_fini:  pha
        tya
        bne _ecrit
        cpx #0
        beq _saute
_ecrit: ora #'0'
        jsr WriteCharacter
        ldx #1
_saute: pla
        rts

; Appel : A = groupe, X = fonction (les paramètres sont déjà en place).
appel:  stx ControlPort+1
        sta ControlPort            ; écrit en dernier : lance l'appel
        jmp WaitMessage

ptr      = $80
diviseur: .byte 0

m:      .text "Volume courant : ", 0

Volume courant : 0

/* Lire un fichier par 3,27 en page $00 (groupe 3, fonction 27, Trinity). */
#include <stdio.h>
#include <neo6502.h>
#include <neo/api.h>

/* Appel brut de la boîte aux lettres : fonction puis groupe (écrit en dernier, il lance l'appel). */
static void api(uint8_t groupe, uint8_t fonction) {
    ControlPort.function = fonction;
    ControlPort.command = groupe;
    while (ControlPort.command)        /* attendre la fin */
        ;
}
static void libre(void) {              /* attendre que la boîte aux lettres soit libre */
    while (ControlPort.command)
        ;
}

static char tampon[9];

int main(void) {
    neo_file_store("abc.txt", "ABCDEFGH", 8);  /* 3,3 : le fichier de l'exemple */
    neo_file_open(1, "abc.txt", NEO_FILE_READ);
    libre();
    ControlPort.params[0] = 1;                  /* P0 : canal */
    ControlPort.params[1] = 0x00;               /* P1 : page $00, mémoire du 6502 */
    ControlPort.params[2] = (uint16_t)tampon & 0xFF;   /* P2-P3 : adresse */
    ControlPort.params[3] = (uint16_t)tampon >> 8;
    ControlPort.params[4] = 8;                  /* P4-P5 : 8 octets */
    ControlPort.params[5] = 0;
    api(3, 27);                                 /* File Read Paged */
    uint8_t n = ControlPort.params[4];
    neo_file_close(1);
    printf("Lu par 3,27 : %s (%u octets)\n", tampon, n);
    return 0;
}

Lu par 3,27 : ABCDEFGH (8 octets)

// Lire un fichier par 3,27 en page $00 (groupe 3, fonction 27, Trinity).
program pagine;
uses crt, neo6502;
var texte, nom, tampon: string[16];
    n: byte;
begin
  texte := 'ABCDEFGH';
  NeoSave('abc.txt', word(@texte) + 1, 8);      // 3,3 : le fichier de l'exemple
  nom := 'abc.txt';
  NeoOpenFile(1, @nom, 0);
  NeoWaitMessage;
  NeoMessage.params[0] := 1;                    // P0 : canal
  NeoMessage.params[1] := $00;                  // P1 : page $00, mémoire du 6502
  wordParams[1] := word(@tampon) + 1;           // P2-P3 : adresse
  wordParams[2] := 8;                           // P4-P5 : 8 octets
  NeoSendMessage(3, 27);                        // File Read Paged
  NeoWaitMessage;
  n := NeoMessage.params[4];
  NeoCloseFile(1);
  tampon[0] := chr(n);
  writeln('Lu par 3,27 : ', tampon, ' (', n, ' octets)');
end.

Lu par 3,27 : ABCDEFGH (8 octets)

10 ' Lire un fichier par 3,27 en page $00 (groupe 3, fonction 27, Trinity)
20 d = alloc(16) : for i = 1 to 8 : poke d + i - 1, 64 + i : next i : save "abc.txt", d, 8 : ' le fichier : ABCDEFGH
25 n$ = "abc.txt" : a = alloc(16) : poke a, len(n$) : for i = 1 to len(n$) : poke a + i, asc(mid$(n$, i, 1)) : next i
30 b = alloc(16) : while peek($ff00) : wend
40 poke $ff04, 1 : poke $ff05, a & 255 : poke $ff06, a >> 8 : poke $ff07, 0 : poke $ff01, 4 : poke $ff00, 3
50 while peek($ff00) : wend
60 poke $ff04, 1 : poke $ff05, 0 : poke $ff06, b & 255 : poke $ff07, b >> 8 : poke $ff08, 8 : poke $ff09, 0 : poke $ff01, 27 : poke $ff00, 3
70 while peek($ff00) : wend : n = peek($ff08)
80 close
90 s$ = "" : for i = 0 to n - 1 : s$ = s$ + chr$(peek(b + i)) : next i
100 print "Lu par 3,27 : ";s$;" (";n;" octets)"

Lu par 3,27 : ABCDEFGH (8 octets)

; Lire un fichier par 3,27 en page $00 (groupe 3, fonction 27, Trinity).
        .cpu "65c02"
        * = $0800
ControlPort    = $FF00             ; +0 groupe, +1 fonction, +2 erreur, +4.. paramètres
WaitMessage    = $FFF4             ; attend que la boîte aux lettres soit libre
WriteCharacter = $FFF1             ; affiche le caractère de A

start:
        jsr WaitMessage            ; 3,3 : le fichier de l'exemple, ABCDEFGH
        lda #<nom
        sta ControlPort+4
        lda #>nom
        sta ControlPort+5
        lda #<abc
        sta ControlPort+6
        lda #>abc
        sta ControlPort+7
        lda #8
        sta ControlPort+8
        stz ControlPort+9
        lda #3
        ldx #3
        jsr appel
        jsr WaitMessage
        lda #1
        sta ControlPort+4          ; P0 : canal 1
        lda #<nom
        sta ControlPort+5
        lda #>nom
        sta ControlPort+6
        stz ControlPort+7          ; lecture seule
        lda #3
        ldx #4                     ; 3,4 : File Open
        jsr appel
        jsr WaitMessage
        lda #1
        sta ControlPort+4          ; P0 : canal 1
        stz ControlPort+5          ; P1 : page $00, mémoire du 6502
        lda #<tampon
        sta ControlPort+6          ; P2-P3 : adresse
        lda #>tampon
        sta ControlPort+7
        lda #8
        sta ControlPort+8          ; P4-P5 : 8 octets
        stz ControlPort+9
        lda #3
        ldx #27                    ; fonction 27 : File Read Paged
        jsr appel
        lda ControlPort+8
        sta lus
        jsr WaitMessage
        lda #1
        sta ControlPort+4
        lda #3
        ldx #5                     ; 3,5 : File Close
        jsr appel
        lda #<m1
        ldx #>m1
        jsr ecrire
        lda #<tampon
        ldx #>tampon
        jsr ecrire
        lda #<m2
        ldx #>m2
        jsr ecrire
        lda lus
        jsr decimal
        lda #<m3
        ldx #>m3
        jmp ecrire

; Affiche la chaîne terminée par 0 dont l'adresse est dans A (poids faible) et X (poids fort).
ecrire: sta ptr
        stx ptr+1
        ldy #0
_e:     lda (ptr),y
        beq _f
        jsr WriteCharacter
        iny
        bne _e
_f:     rts

; Affiche A (0-255) en décimal, sans zéros de tête.
decimal:
        phx
        phy
        ldx #0
        ldy #100
        jsr _chiffre
        ldy #10
        jsr _chiffre
        ora #'0'
        jsr WriteCharacter
        ply
        plx
        rts
_chiffre:
        sty diviseur
        ldy #0
_div:   cmp diviseur
        bcc _fini
        sbc diviseur
        iny
        bne _div
_fini:  pha
        tya
        bne _ecrit
        cpx #0
        beq _saute
_ecrit: ora #'0'
        jsr WriteCharacter
        ldx #1
_saute: pla
        rts

; Appel : A = groupe, X = fonction (les paramètres sont déjà en place).
appel:  stx ControlPort+1
        sta ControlPort            ; écrit en dernier : lance l'appel
        jmp WaitMessage

ptr      = $80
diviseur: .byte 0

nom:    .byte 7
        .text "abc.txt"
abc:    .text "ABCDEFGH"

tampon: .fill 9                    ; zéros : la chaîne lue sera terminée
lus:    .byte 0
m1:     .text "Lu par 3,27 : ", 0
m2:     .text " (", 0
m3:     .text " octets)", 13, 0

Lu par 3,27 : ABCDEFGH (8 octets)

/* Lire un fichier sans arrêter le 65C02 (groupe 3, fonction 28, Trinity). */
#include <stdio.h>
#include <neo6502.h>
#include <neo/api.h>

/* Appel brut de la boîte aux lettres : fonction puis groupe (écrit en dernier, il lance l'appel). */
static void api(uint8_t groupe, uint8_t fonction) {
    ControlPort.function = fonction;
    ControlPort.command = groupe;
    while (ControlPort.command)        /* attendre la fin */
        ;
}
static void libre(void) {              /* attendre que la boîte aux lettres soit libre */
    while (ControlPort.command)
        ;
}

static char tampon[17];
static volatile uint8_t etat[3];                /* état, puis nombre d'octets lus (écrits par le firmware) */

static uint8_t lire(uint16_t cible, uint16_t suivi) {   /* 3,28 : 16 octets du canal 1 en cible ; erreur rendue */
    libre();
    ControlPort.params[0] = 1;                  /* P0 : canal */
    ControlPort.params[1] = 0x00;               /* P1 : page $00, mémoire du 6502 */
    ControlPort.params[2] = cible & 0xFF;       /* P2-P3 : adresse */
    ControlPort.params[3] = cible >> 8;
    ControlPort.params[4] = 16;                 /* P4-P5 : 16 octets demandés */
    ControlPort.params[5] = 0;
    ControlPort.params[6] = suivi & 0xFF;       /* P6-P7 : les 3 octets d'état */
    ControlPort.params[7] = suivi >> 8;
    api(3, 28);                                 /* File Read Background : rend la main tout de suite */
    return ControlPort.error;
}

int main(void) {
    neo_file_store("abc.txt", "ABCDEFGH", 8);  /* 3,3 : le fichier de l'exemple */
    neo_file_open(1, "abc.txt", NEO_FILE_READ);
    lire((uint16_t)tampon, (uint16_t)etat);
    uint16_t tours = 0;
    while (!(etat[0] & 0x80))                   /* le programme continue pendant la lecture */
        tours++;
    printf("Lu : %s, etat %u, %u octets\n", tampon, etat[0], etat[1] | etat[2] << 8);
    printf("Suivi dans la cible : erreur %u\n", lire((uint16_t)tampon, (uint16_t)tampon + 4));
    neo_file_close(1);
    return 0;
}

Lu : ABCDEFGH, etat 128, 8 octets
Suivi dans la cible : erreur 21

// Lire un fichier sans arrêter le 65C02 (groupe 3, fonction 28, Trinity).
program fond;
uses crt, neo6502;
var texte, nom, tampon: string[16];
    etat: array[0..2] of byte;                  // état, puis nombre d'octets lus (écrits par le firmware)
    e: byte;
    tours: word;

function lire(cible, suivi: word): byte;        // 3,28 : 16 octets du canal 1 en cible ; erreur rendue
begin
  NeoWaitMessage;
  NeoMessage.params[0] := 1;                    // P0 : canal
  NeoMessage.params[1] := $00;                  // P1 : page $00, mémoire du 6502
  wordParams[1] := cible;                       // P2-P3 : adresse
  wordParams[2] := 16;                          // P4-P5 : 16 octets demandés
  wordParams[3] := suivi;                       // P6-P7 : les 3 octets d'état
  NeoSendMessage(3, 28);                        // File Read Background : rend la main tout de suite
  NeoWaitMessage;
  result := NeoMessage.error;
end;

begin
  texte := 'ABCDEFGH';
  NeoSave('abc.txt', word(@texte) + 1, 8);      // 3,3 : le fichier de l'exemple
  nom := 'abc.txt';
  NeoOpenFile(1, @nom, 0);
  lire(word(@tampon) + 1, word(@etat));
  tours := 0;
  while etat[0] and $80 = 0 do inc(tours);      // le programme continue pendant la lecture
  tampon[0] := chr(etat[1]);
  writeln('Lu : ', tampon, ', etat ', etat[0], ', ', etat[1] + etat[2] shl 8, ' octets');
  e := lire(word(@tampon) + 1, word(@tampon) + 5);
  writeln('Suivi dans la cible : erreur ', e);
  NeoCloseFile(1);
end.

Lu : ABCDEFGH, etat 128, 8 octets
Suivi dans la cible : erreur 21

10 ' Lire un fichier sans arreter le 65C02 (groupe 3, fonction 28, Trinity)
20 d = alloc(16) : for i = 1 to 8 : poke d + i - 1, 64 + i : next i : save "abc.txt", d, 8 : ' le fichier : ABCDEFGH
25 n$ = "abc.txt" : a = alloc(16) : poke a, len(n$) : for i = 1 to len(n$) : poke a + i, asc(mid$(n$, i, 1)) : next i
30 b = alloc(16) : s = alloc(3) : while peek($ff00) : wend
40 poke $ff04, 1 : poke $ff05, a & 255 : poke $ff06, a >> 8 : poke $ff07, 0 : poke $ff01, 4 : poke $ff00, 3
50 c = b : gosub 1000 : ' lecture, suivi en s
60 repeat : until peek(s) & $80 : ' le programme continue pendant la lecture
70 e = peek(s) : n = peek(s + 1) : ' etat, octets lus
80 s$ = "" : for i = 0 to n - 1 : s$ = s$ + chr$(peek(b + i)) : next i
90 print "Lu : ";s$;", etat ";e;", ";n;" octets"
100 s = b + 4 : gosub 1000 : print "Suivi dans la cible : erreur ";r
110 close
120 end
1000 ' 3,28 : 16 octets du canal 1 en c, 3 octets d'etat en s ; erreur dans r
1010 while peek($ff00) : wend
1020 poke $ff04, 1 : poke $ff05, 0 : doke $ff06, c : doke $ff08, 16 : doke $ff0a, s
1030 poke $ff01, 28 : poke $ff00, 3 : ' File Read Background : rend la main tout de suite
1040 while peek($ff00) : wend : r = peek($ff02)
1050 return

Lu : ABCDEFGH, etat 128, 8 octets
Suivi dans la cible : erreur 21

; Lire un fichier sans arrêter le 65C02 (groupe 3, fonction 28, Trinity).
        .cpu "65c02"
        * = $0800
ControlPort    = $FF00             ; +0 groupe, +1 fonction, +2 erreur, +4.. paramètres
WaitMessage    = $FFF4             ; attend que la boîte aux lettres soit libre
WriteCharacter = $FFF1             ; affiche le caractère de A

start:
        jsr WaitMessage            ; 3,3 : le fichier de l'exemple, ABCDEFGH
        lda #<nom
        sta ControlPort+4
        lda #>nom
        sta ControlPort+5
        lda #<abc
        sta ControlPort+6
        lda #>abc
        sta ControlPort+7
        lda #8
        sta ControlPort+8
        stz ControlPort+9
        lda #3
        ldx #3
        jsr appel
        jsr WaitMessage
        lda #1
        sta ControlPort+4          ; P0 : canal 1
        lda #<nom
        sta ControlPort+5
        lda #>nom
        sta ControlPort+6
        stz ControlPort+7          ; lecture seule
        lda #3
        ldx #4                     ; 3,4 : File Open
        jsr appel
        lda #<etat                 ; suivi hors de la cible
        ldx #>etat
        jsr lire
_att:   bit etat                   ; le programme continue pendant la lecture...
        bpl _att                   ; ... jusqu'au bit 7 de l'état
        lda #<t0
        ldx #>t0
        jsr ecrire
        lda #<tampon
        ldx #>tampon
        jsr ecrire                 ; la cible est à zéro au-delà des 8 octets lus
        lda #<t1
        ldx #>t1
        jsr ecrire
        lda etat
        jsr decimal
        lda #<t2
        ldx #>t2
        jsr ecrire
        lda etat+1                 ; octets lus (poids faible)
        jsr decimal
        lda #<t3
        ldx #>t3
        jsr ecrire
        lda #<(tampon+4)           ; suivi dans la cible : refusé
        ldx #>(tampon+4)
        jsr lire
        lda ControlPort+2
        sta err
        lda #<t4
        ldx #>t4
        jsr ecrire
        lda err
        jsr decimal
        lda #13
        jsr WriteCharacter
        jsr WaitMessage
        lda #1
        sta ControlPort+4
        lda #3
        ldx #5                     ; 3,5 : File Close
        jmp appel

; 3,28 : 16 octets du canal 1 dans tampon, les 3 octets d'état à l'adresse A (poids faible), X (poids fort).
lire:   pha
        jsr WaitMessage
        pla
        sta ControlPort+10         ; P6-P7 : les 3 octets d'état
        stx ControlPort+11
        lda #1
        sta ControlPort+4          ; P0 : canal 1
        stz ControlPort+5          ; P1 : page $00, mémoire du 6502
        lda #<tampon
        sta ControlPort+6          ; P2-P3 : adresse
        lda #>tampon
        sta ControlPort+7
        lda #16
        sta ControlPort+8          ; P4-P5 : 16 octets demandés
        stz ControlPort+9
        lda #3
        ldx #28                    ; 3,28 : File Read Background, rend la main tout de suite
        jmp appel

nom:    .byte 7
        .text "abc.txt"
abc:    .text "ABCDEFGH"
tampon: .fill 17                   ; zéros : la chaîne lue sera terminée
etat:   .fill 3                    ; état, puis nombre d'octets lus (écrits par le firmware)
err:    .byte 0
t0:     .text "Lu : ", 0
t1:     .text ", etat ", 0
t2:     .text ", ", 0
t3:     .text " octets", 13, 0
t4:     .text "Suivi dans la cible : erreur ", 0

; Affiche la chaîne terminée par 0 dont l'adresse est dans A (poids faible) et X (poids fort).
ecrire: sta ptr
        stx ptr+1
        ldy #0
_e:     lda (ptr),y
        beq _f
        jsr WriteCharacter
        iny
        bne _e
_f:     rts

; Affiche A (0-255) en décimal, sans zéros de tête.
decimal:
        phx
        phy
        ldx #0
        ldy #100
        jsr _chiffre
        ldy #10
        jsr _chiffre
        ora #'0'
        jsr WriteCharacter
        ply
        plx
        rts
_chiffre:
        sty diviseur
        ldy #0
_div:   cmp diviseur
        bcc _fini
        sbc diviseur
        iny
        bne _div
_fini:  pha
        tya
        bne _ecrit
        cpx #0
        beq _saute
_ecrit: ora #'0'
        jsr WriteCharacter
        ldx #1
_saute: pla
        rts

; Appel : A = groupe, X = fonction (les paramètres sont déjà en place).
appel:  stx ControlPort+1
        sta ControlPort            ; écrit en dernier : lance l'appel
        jmp WaitMessage

ptr      = $80
diviseur: .byte 0

Lu : ABCDEFGH, etat 128, 8 octets
Suivi dans la cible : erreur 21

/* Lire la date d'un fichier (groupe 3, fonction 29, Trinity). */
#include <stdio.h>
#include <neo6502.h>
#include <neo/api.h>

/* Appel brut de la boîte aux lettres : fonction puis groupe (écrit en dernier, il lance l'appel). */
static void api(uint8_t groupe, uint8_t fonction) {
    ControlPort.function = fonction;
    ControlPort.command = groupe;
    while (ControlPort.command)        /* attendre la fin */
        ;
}
static void libre(void) {              /* attendre que la boîte aux lettres soit libre */
    while (ControlPort.command)
        ;
}

static const uint8_t nom[] = "\x07" "abc.txt";   /* chaîne à longueur */

int main(void) {
    neo_file_store("abc.txt", "ABCDEFGH", 8);  /* 3,3 : le fichier de l'exemple */
    libre();
    ControlPort.params[0] = (uint16_t)nom & 0xFF;   /* P0-P1 : nom */
    ControlPort.params[1] = (uint16_t)nom >> 8;
    api(3, 16);                                 /* File Stat : l'entrée dont on veut la date */
    api(3, 29);                                 /* Last Entry Date Time */
    uint16_t d = ControlPort.params[0] | ControlPort.params[1] << 8;   /* date FAT */
    uint16_t h = ControlPort.params[2] | ControlPort.params[3] << 8;   /* heure FAT */
    printf("abc.txt : %u-%02u-%02u %02u:%02u:%02u\n",
           1980 + (d >> 9), (d >> 5) & 15, d & 31,  /* année - 1980, mois, jour */
           h >> 11, (h >> 5) & 63, (h & 31) * 2);   /* heure, minutes, secondes / 2 */
    return 0;
}

abc.txt : 2026-10-03 15:19:38

// Lire la date d'un fichier (groupe 3, fonction 29, Trinity).
program datefichier;
uses crt, neo6502;
var texte, nom: string[16];
    taille: cardinal;
    attr: byte;
    d, h: word;

procedure deux(n: word);                        // deux chiffres
begin
  if n < 10 then write('0');
  write(n);
end;

begin
  texte := 'ABCDEFGH';
  NeoSave('abc.txt', word(@texte) + 1, 8);      // 3,3 : le fichier de l'exemple
  nom := 'abc.txt';
  NeoStatFile(@nom, taille, attr);              // 3,16 : l'entrée dont on veut la date
  NeoSendMessage(3, 29);                        // Last Entry Date Time
  NeoWaitMessage;
  d := wordParams[0];                           // date FAT
  h := wordParams[1];                           // heure FAT
  write('abc.txt : ', 1980 + d shr 9, '-');     // année - 1980
  deux((d shr 5) and 15); write('-');           // mois
  deux(d and 31); write(' ');                   // jour
  deux(h shr 11); write(':');                   // heure
  deux((h shr 5) and 63); write(':');           // minutes
  deux((h and 31) * 2);                         // secondes / 2
  writeln;
end.

abc.txt : 2026-10-03 15:19:36

10 ' Lire la date d'un fichier (groupe 3, fonction 29, Trinity)
20 d = alloc(16) : for i = 1 to 8 : poke d + i - 1, 64 + i : next i : save "abc.txt", d, 8 : ' le fichier : ABCDEFGH
25 n$ = "abc.txt" : a = alloc(16) : poke a, len(n$) : for i = 1 to len(n$) : poke a + i, asc(mid$(n$, i, 1)) : next i
30 while peek($ff00) : wend
40 poke $ff04, a & 255 : poke $ff05, a >> 8 : poke $ff01, 16 : poke $ff00, 3 : ' 3,16 : l'entree dont on veut la date
50 while peek($ff00) : wend
60 poke $ff01, 29 : poke $ff00, 3 : ' Last Entry Date Time
70 while peek($ff00) : wend : d = deek($ff04) : h = deek($ff06) : ' date et heure FAT, lues avant tout calcul
80 print "abc.txt : ";1980 + (d >> 9);"-";
90 n = (d >> 5) & 15 : gosub 1000 : print "-"; : n = d & 31 : gosub 1000 : print " ";
100 n = h >> 11 : gosub 1000 : print ":"; : n = (h >> 5) & 63 : gosub 1000 : print ":"; : n = (h & 31) * 2 : gosub 1000
110 print
120 end
1000 ' n sur deux chiffres
1010 if n < 10 then print "0";
1020 print n;
1030 return

abc.txt : 2026-10-03 15:19:38

; Lire la date d'un fichier (groupe 3, fonction 29, Trinity).
        .cpu "65c02"
        * = $0800
ControlPort    = $FF00             ; +0 groupe, +1 fonction, +2 erreur, +4.. paramètres
WaitMessage    = $FFF4             ; attend que la boîte aux lettres soit libre
WriteCharacter = $FFF1             ; affiche le caractère de A

start:
        jsr WaitMessage            ; 3,3 : le fichier de l'exemple, ABCDEFGH
        lda #<nom
        sta ControlPort+4
        lda #>nom
        sta ControlPort+5
        lda #<abc
        sta ControlPort+6
        lda #>abc
        sta ControlPort+7
        lda #8
        sta ControlPort+8
        stz ControlPort+9
        lda #3
        ldx #3
        jsr appel
        jsr WaitMessage
        lda #<nom
        sta ControlPort+4          ; P0-P1 : nom
        lda #>nom
        sta ControlPort+5
        lda #3
        ldx #16                    ; 3,16 : File Stat, l'entrée dont on veut la date
        jsr appel
        lda #3
        ldx #29                    ; 3,29 : Last Entry Date Time
        jsr appel
        ldx #3                     ; copier date et heure avant tout affichage
_cp:    lda ControlPort+4,x
        sta date,x
        dex
        bpl _cp
        lda #<t0
        ldx #>t0
        jsr ecrire
        lda date+1                 ; année - 1980 : bits 15-9
        lsr a
        clc
        adc #80                    ; 1980 + a = 1900 + (a + 80)
        cmp #100
        bcs _2000
        pha
        lda #19
        bra _siecle
_2000:  sbc #100
        pha
        lda #20
_siecle:
        jsr deux
        pla
        jsr deux
        lda #'-'
        jsr WriteCharacter
        lda date+1                 ; mois : bits 8-5
        lsr a
        lda date
        ror a
        lsr a
        lsr a
        lsr a
        lsr a
        jsr deux
        lda #'-'
        jsr WriteCharacter
        lda date                   ; jour : bits 4-0
        and #31
        jsr deux
        lda #' '
        jsr WriteCharacter
        lda heure+1                ; heure : bits 15-11
        lsr a
        lsr a
        lsr a
        jsr deux
        lda #':'
        jsr WriteCharacter
        lda heure+1                ; minutes : bits 10-5
        and #7
        sta tmp
        lda heure
        lsr tmp
        ror a
        lsr tmp
        ror a
        lsr tmp
        ror a
        lsr a
        lsr a
        jsr deux
        lda #':'
        jsr WriteCharacter
        lda heure                  ; secondes / 2 : bits 4-0
        and #31
        asl a
        jsr deux
        lda #13
        jmp WriteCharacter

; Affiche A (0-99) sur deux chiffres.
deux:   cmp #10
        bcs _d
        pha
        lda #'0'
        jsr WriteCharacter
        pla
_d:     jmp decimal

nom:    .byte 7
        .text "abc.txt"
abc:    .text "ABCDEFGH"
date:   .word 0                    ; date FAT
heure:  .word 0                    ; heure FAT
tmp:    .byte 0
t0:     .text "abc.txt : ", 0

; Affiche la chaîne terminée par 0 dont l'adresse est dans A (poids faible) et X (poids fort).
ecrire: sta ptr
        stx ptr+1
        ldy #0
_e:     lda (ptr),y
        beq _f
        jsr WriteCharacter
        iny
        bne _e
_f:     rts

; Affiche A (0-255) en décimal, sans zéros de tête.
decimal:
        phx
        phy
        ldx #0
        ldy #100
        jsr _chiffre
        ldy #10
        jsr _chiffre
        ora #'0'
        jsr WriteCharacter
        ply
        plx
        rts
_chiffre:
        sty diviseur
        ldy #0
_div:   cmp diviseur
        bcc _fini
        sbc diviseur
        iny
        bne _div
_fini:  pha
        tya
        bne _ecrit
        cpx #0
        beq _saute
_ecrit: ora #'0'
        jsr WriteCharacter
        ldx #1
_saute: pla
        rts

; Appel : A = groupe, X = fonction (les paramètres sont déjà en place).
appel:  stx ControlPort+1
        sta ControlPort            ; écrit en dernier : lance l'appel
        jmp WaitMessage

ptr      = $80
diviseur: .byte 0

abc.txt : 2026-10-03 15:19:36

/* Lister les fichiers dont le nom contient « abc » (groupe 3, fonction 32). */
#include <neo/api.h>

int main(void) {
    neo_file_store("abc.txt", "ABCDEFGH", 8);  /* 3,3 : le fichier de l'exemple */
    neo_file_store("xyz.txt", "XYZ", 3);        /* un fichier qui ne sera pas listé */
    neo_file_list_filtered("abc");              /* List Filtered */
    return 0;
}

abc.txt                         8 bytes.

// Lister les fichiers dont le nom contient « abc » (groupe 3, fonction 32).
program filtre;
uses crt, neo6502;
var texte, filtre: string[16];
begin
  texte := 'ABCDEFGH';
  NeoSave('abc.txt', word(@texte) + 1, 8);      // 3,3 : le fichier de l'exemple
  NeoSave('xyz.txt', word(@texte) + 1, 3);      // un fichier qui ne sera pas listé
  filtre := 'abc';
  NeoSearchDir(filtre);                         // List Filtered
  NeoWaitMessage;
end.

abc.txt                         8 bytes.

10 ' Lister les fichiers dont le nom contient abc (groupe 3, fonction 32)
20 d = alloc(16) : for i = 1 to 8 : poke d + i - 1, 64 + i : next i : save "abc.txt", d, 8 : ' le fichier : ABCDEFGH
25 n$ = "abc.txt" : a = alloc(16) : poke a, len(n$) : for i = 1 to len(n$) : poke a + i, asc(mid$(n$, i, 1)) : next i
30 save "xyz.txt", d, 3 : ' un fichier qui ne sera pas liste
40 cat "abc"

abc.txt                         8 bytes.

; Lister les fichiers dont le nom contient « abc » (groupe 3, fonction 32).
        .cpu "65c02"
        * = $0800
ControlPort    = $FF00             ; +0 groupe, +1 fonction, +2 erreur, +4.. paramètres
WaitMessage    = $FFF4             ; attend que la boîte aux lettres soit libre
WriteCharacter = $FFF1             ; affiche le caractère de A

start:
        jsr WaitMessage            ; 3,3 : le fichier de l'exemple, ABCDEFGH
        lda #<nom
        sta ControlPort+4
        lda #>nom
        sta ControlPort+5
        lda #<abc
        sta ControlPort+6
        lda #>abc
        sta ControlPort+7
        lda #8
        sta ControlPort+8
        stz ControlPort+9
        lda #3
        ldx #3
        jsr appel
        jsr WaitMessage            ; un fichier qui ne sera pas listé
        lda #<xyz
        sta ControlPort+4
        lda #>xyz
        sta ControlPort+5
        lda #<abc
        sta ControlPort+6
        lda #>abc
        sta ControlPort+7
        lda #3
        sta ControlPort+8
        stz ControlPort+9
        lda #3
        ldx #3
        jsr appel
        lda #<filtre
        ldx #>filtre
        ldy #32                    ; fonction 32 : List Filtered
        jmp sur_nom

; Appel du groupe 3, fonction Y, avec en P0-P1 l'adresse du nom donnée par A (poids faible) et X.
sur_nom:
        pha
        jsr WaitMessage
        pla
        sta ControlPort+4
        stx ControlPort+5
        tya
        tax
        lda #3
        jmp appel

; Affiche la chaîne terminée par 0 dont l'adresse est dans A (poids faible) et X (poids fort).
ecrire: sta ptr
        stx ptr+1
        ldy #0
_e:     lda (ptr),y
        beq _f
        jsr WriteCharacter
        iny
        bne _e
_f:     rts

; Affiche A (0-255) en décimal, sans zéros de tête.
decimal:
        phx
        phy
        ldx #0
        ldy #100
        jsr _chiffre
        ldy #10
        jsr _chiffre
        ora #'0'
        jsr WriteCharacter
        ply
        plx
        rts
_chiffre:
        sty diviseur
        ldy #0
_div:   cmp diviseur
        bcc _fini
        sbc diviseur
        iny
        bne _div
_fini:  pha
        tya
        bne _ecrit
        cpx #0
        beq _saute
_ecrit: ora #'0'
        jsr WriteCharacter
        ldx #1
_saute: pla
        rts

; Appel : A = groupe, X = fonction (les paramètres sont déjà en place).
appel:  stx ControlPort+1
        sta ControlPort            ; écrit en dernier : lance l'appel
        jmp WaitMessage

ptr      = $80
diviseur: .byte 0

nom:    .byte 7
        .text "abc.txt"
abc:    .text "ABCDEFGH"

xyz:    .byte 7
        .text "xyz.txt"
filtre: .byte 3
        .text "abc"

abc.txt                         8 bytes.