Documentation de CS

Mes pages perso à moi

Nom du programme : CS
Version : 1.00 beta 1
Date : 14 décembre 2003
Auteur : Matthieu Gallet
Plate-forme : TI-92Plus, V200, TI-89
Fonction : gestionnaire de fichiers (entre autres)

Sommaire :
    0    Présentation générale
    1    Définitions
    2    Comme se servir de CS
    3    Documentation des différentes fonctions
    4    CSlaunch
    5    Editeur hexadécimal
    6    CSdata
    7    Remerciements
    8    Bugs connus
    9    A venir
    10 Historique

0 Présentation générale

    CS est un puissant gestionnaire de fichiers, doublé de fonctions inédites pour gérer de nombreuses autres types d'objets sur la calculatrice. Il s'agit d'une version totalement refondue d'un autre de mes programmes, XCS (eXpérimental CS), qui m'avait servi à apprendre à programmer en assembleur 68000 et à voir comment développer un shell. J'ai ici volontairement repris l'interface du VAR-LINK à la fois pour des raisons de praticité (mêmes combinaisons de touches) et de taille.
Principales caractéristiques :
-    installation en tant qu'application flash !
-    éditeur hexadécimal / désassembleur / désinstalleur de TSR intégrés !
-    explorateur de handles !
-    nombreuses informations sur les objets présents sur la calculatrice ou sur la calculatrice elle-même !
-    fonction chercher permettant d'exécuter ou de gérer les fichiers trouvés !
-    récupération des archives effacées en RAM !
-    reconnaissance des formats de compression acf, KOMP, PEP et ZIP !
-    gestion des fichiers GRP, KOMP, PEP et ZIP !
-    CS décompresse automatiquement les fichiers en RAM avant de les exécuter (formats ZIP, KOMP, PEP)!
-    lecteurs de textes et d'images internes !
-    gestion des TSR (format evHk et EvHk)
-    désassembleur de programmes _nostub / kernel !
... ... ...

Avertissement :
    Je ne peux être tenu pour responsable de dommages et/ou de pertes
données résultant directement ou indirectement de l'utilisation de CS (ou de CSlaunch).
Vous n'êtes pas autorisés à redistribuer ce package ou une de ses
parties sans mon autorisation.

    Cette documentation n'est pas du tout finie, alors ne m'en voulez pas s'il manque des choses dans les remerciements, dans la présentation, dans les fonctions des touches... De la même façon, certaines captures d'écran peuvent ne plus correspondre à l'affichage actuel.

1 DEFINITIONS

Contrairement à la plupart des shells, CS n'est pas restreint à la gestion des fichiers mais permet de manipuler différents objets :
    -    les fichiers : il s'agit des variables créées par l'utilisateur, telles que des programmes PRGM/FUNC, des textes, des images...
    -    les répertoires ou dossiers
    -    les handles : il s'agit des blocs de mémoire. Reportez-vous à n'importe quel tutorial sur l'assembleur 68000 pour en savoir plus, mais il ne vaut mieux pas y toucher quand on ne sait pas trop ce qu'on fait : le risque de planter la TI n'est pas négligeable. Tous ne sont pas reconnus, mais il y en a en général moins d'une dizaine d'inconnus (sinon c'est pas normal je pense).
    -    les applications flash (FlashApp)
    -    les TSR (Terminate and Stay Resident) : certains programmes assembleurs restent en mémoire pour pouvoir être utilisés à tout moment. Certains (ceux respectant la convention de Kevin Kofler) peuvent être désinstallés en toute sécurité à partir de CS.
    -   la poubelle (j'aurais bien aimé l'appeler 'Corbeille', comme sur un OS pour PC bien connu, mais il me fallait un nom de moins de 8 lettres) : les fichiers archivés peuvent être récupérés à tout moment, du moment qu'aucun 'Garbage memory' (réorganisation des archives) n'a eu lieu.

2 COMMENT S'EN SERVIR

Pour se servir de CS, il faut envoyer à la calculatrice le fichier principal cs.9xz (si c'est pour une TI-92Plus, sinon c'est cs.89z pour les TI89 et cs.v2z pour les V200). Il y a un autre fichier facultatif : cslaunch.9xz. Pour plus de précisions sur ce programme, reportez-vous à la fin du texte. Seul CSLaunch permet d'utiliser CS au maximum de ses possibilités, mais ça ne marche pour l'instant que sur les TI-92Plus AMS 2.xx.
    Sur les TI-92Plus, il n'a besoin d'aucun programme extérieur pour être lancé (ni kernel du genre DoorsOS, Universal OS ou Preos, ni patch du type hw2patch ou h220xtsr, ni même lanceur du type ttstart).
Des programmes externes sont requis pour (dé-)compresser :
    format ZIP : un kernel qui soit installé (je conseille Universal OS 1.30 - sur AMS < 2.05 - ou PreOS 0.67 sinon), ainsi que les bibliothèques ziplib, graphlib, filelib et userlib,
    format KOMP : flib2 (de F. Leiber),
    format ppg : ttstart (de la TICT).
    format PEP : pepzip.

Au premier lancement, CS affiche la liste des répertoires présents sur la calculatrice et est en mode icônes. Avec ESC, on peut remonter d'un niveau et on obtient alors :

"HOME" correspond à la liste des répertoires, "POUBELLE" à la liste des fichiers effacés de l'archive, "ARCHIVE" à la liste complète des fichiers présents dans l'archive, "HANDLES" à la liste des handles, "TSR" à la liste des TSR présents sur la calculatrice, et enfin "FLASHAPP" aux applications Flash installées sur la calculatrice.

3 LES DIFFÉRENTES FONCTIONS

J'ai choisi de les documenter en fonction des touches utilisées pour y accéder et en précisant au besoin quels étaient les objets concernés. Certaines touches sont classiques, mais d'autres combinaisons sont beaucoup plus rares, c'est pourquoi il est utile de tout lire.

[ESC] : remonter d'un niveau dans le programme, jusqu'à le quitter.
[Gauche] (mode liste) : remonter d'un niveau dans le programme, mais ne permet pas de le quitter.
[Droite] (mode liste) :
dossier / fichier GRP : affiche la liste des variables de ce dossier / de ce fichier GRP.
(dossier) (groupe)

[Enter] :
    dossier : affiche la liste des variables de ce dossier.
    fichier : exécute le programme associé au type de variable.
        Les fichiers de type EXE/ASM/PRGM/FUNC sont exécutés directement s'il n'y a pas d'association adaptée.
        Les images (PIC) sont affichées à l'écran s'il n'y a pas d'association adaptée.
        Les textes (TEXT) sont lus avec le lecteur interne s'il n'y a pas d'association adaptée.

        Les groupes (GRP) sont ouverts comme des dossiers s'il n'y a pas d'association adaptée.
Quelques exemples pour bien comprendre comment marchent les associations :
    ASM si 'ASM' n'est pas défini dans les associations -> on exécute directement folder\file()
    ASM si 'ASM' est associé, par exemple avec ttstart -> folder\ttstart("folder\file") est exécuté.
    TEXT si 'TEXT' est associé à txtrider et ASM à ttstart -> on exécute folder\ttstart("folder\txtrider","folder\text")
        Comme on peut le voir, les associations s'appliquent aussi au lanceur, mais CS vérifie quand même que le lanceur n'essaie pas de se lancer lui-même. Pour chercher un lanceur de lanceur, CS ne fait pas la différence entre ASM, EXE, LIB, ni entre PRGM/FUNC.

Les fichiers compressés au format KOMP, PEP ou ZIP sont automatiquement décompressés pour l'exécution (si les programmes externes sont présents) et compressés après.

[Haut] / [Bas] (mode liste) :
    change la variable sélectionnée pour celle du haut .. ou celle du bas.
[Haut] / [Bas] / [Gauche] / [Droite] (mode icônes) :
    ai-je vraiment besoin de détailler ?
[Maj] + [Haut] / [Bas] / [Gauche] / [Droite] :
    sélectionne la variable surlignée tout en se déplaçant.
[Diamant] + [Haut] / [Bas] :
    aller au début ou à la fin de la liste
[2nd] + [Haut] / [Bas] (mode liste) :
    monter / descendre de 10 variables.
[LOCK] + [Gauche] / [Droite] :
    dossier / secteur d'archive : replier le dossier ou le secteur d'archive. Replier un dossier n'a d'importance quand dans le VAR-Link. Par contre, replier les secteurs d'archive peut être agréable.

[2nd] + [ENTER] :
    fichier : propose différentes options pour l'exécution d'un programme :
            réarchiver : si le programme a été modifié, l'archive correspondante est réactualisée (pratique pour sauvegarder des high-scores, par exemple)
            libérer la RAM : cette option ne fonctionne que si CS est archivé et qu'il est exécuté depuis le HOME, et permet de libérer un maximum de mémoire pour l'exécution de programmes gourmands en RAM (jeux...). N'a pas d'effet si CS est exécuté en tant qu'application Flash.
            surveiller la RAM : cette option affiche une liste des handles "perdus" pendant l'exécution du programme.
            setfold : change de répertoire pour se placer dans le répertoire où se trouve la variable le temps de l'exécution.
            fonction : exécute "Disp folder\program()" au lieu de "folder\program()" et permet d'afficher d'éventuels résultats.
            attendre : fait une pause (qu'on peut abréger en appuyant sur [ON]) après l'exécution du programme, ce qui permet de lire les messages dans la Status Line.

[Diamant] + [ENTER] :
    fichier / dossier : insère le nom du dossier ou du répertoire dans l'application en cours, puis quitte CS. C'est l'équivalent de [ENTER] dans le VAR-LINK.
[2nd] + [ESC] :
    quitte le programme.
[Diamant] + [ESC] :
    quitte le programme sans désélectionner les variables.
[MODE] :
    bascule entre les modes 'ICONES' et 'LISTE'.

[2nd] + [STO] :
    fichier : insère le contenu du fichier sélectionné dans l'application en cours, puis quitte le programme. C'est l'équivalent de la touche RCL, sauf qu'elle marche avec des variables PEPées, KOMPressées et ZIPées.
[STO] :
    fichier : insère le contenu du fichier sélectionné dans le ClipBoard (buffer utilisé par le Copier-Coller usuel).
[Diamant] + [A] :
    fichier : archive un fichier. cf. le manuel de la TI, chapitre VAR-LINK.
[Diamant] + [C] :
    fichier : copie le fichier.
[Diamant] + [E] :
    fichier : décompresse un fichier au format ZIP, PEP ou KOMP.
    dans la poubelle ou un fichier GRP : recrée la variable sélectionnée en RAM.
[Diamant] + [F] :
    dossier : choisi le répertoire surligné comme étant le répertoire courant.
[Diamant] + [K] :
    fichier : compresse le fichier sélectionné au format KOMP. Le programme FLIB2 doit être présent sur la calculatrice.
[Diamant] + [K] :
    fichier : compresse le fichier sélectionné au format KOMP. Le programme FLIB2 doit être présent sur la calculatrice.
[Diamant] + [L] :
    fichier / dossier / AppFlash / handle : cf. le manuel de la TI, chapitre VAR-LINK.
[Diamant] + [P] :
    fichier : compresse le fichier sélectionné au format PEP. Le programme pepzip doit être présent sur la calculatrice.
[Diamant] + [Q] :
    quitte CS.
[Diamant] + [S] :
    fichier : envoie le fichier via le link. cf. le manuel de la TI, chapitre VAR-LINK.
[[Diamant] + [X] :
    fichier : coupe le fichier. Il ne sera effectivement effacé que quand le "coller" aura été fait.
[Diamant] + [V] :
    fichier / dossier : colle les fichiers précédemment coupés / copiés dans le dossier choisi.
[Diamant] + [Z] :
    fichier : compresse le fichier sélectionné au format ZIP. Les programmes cslaunch, ZIPLIB, FILELIB, USERLIB, GRAPHLIB ainsi qu'un kernel doivent être présents sur la calculatrice.
[Diamant] + [ON] :
    éteint la calculatrice.
[2nd] + [ON] :
    éteint la calculatrice puis quitte le programme.
[APPS] :
    lance l'éditeur hexadécimal.

[<-] , [F1] + [1] (effacer) :
    fichier : efface le fichier. Il ne sera pas désarchivé mais effacé directement dans l'archive.
    dossier : efface le dossier, qui doit être vide.
    handle : efface le handle. S'il est dans l'archive, EM_Abandon sera appelé pour l'effacer.
    FlashApp, TSR : ...

    On peut également effacer les fausses applications flash créées par ID d'ExtendeD
[F1] + [2] (copier) :
    fichier : cf. le manuel de la TI, chapitre VAR-LINK.
[F1] + [3] (renommer) :
    fichier / dossier : cf. le manuel de la TI, chapitre VAR-LINK. Toutes les variables d'un dossier renommé seront désarchivées puis archivées pour éviter qu'elles ne réapparaissent sous leur ancien nom après un reset (bug du VAR-LINK) .
    handle : change la taille du handle.
[F1] + [4] (déplacer) :
    fichier : cf. le manuel de la TI, chapitre VAR-LINK.
    handle : déplace le handle avec HeapMoveHigh en fin de RAM.
[F1] + [5] (créer un répertoire) :
    cf. le manuel de la TI, chapitre VAR-LINK.
    handle : crée un handle de taille taille.
[F1] + [6] (verrouiller) :
    fichier / dossier / AppFlash / handle : cf. le manuel de la TI, chapitre VAR-LINK.
[F1] + [7] (déverrouiller) :
    fichier / dossier / AppFlash / handle : cf. le manuel de la TI, chapitre VAR-LINK.
[F1] + [8] (archiver) :
    fichier : cf. le manuel de la TI, chapitre VAR-LINK.
[F1] + [9] (désarchiver) :
    fichier : cf. le manuel de la TI, chapitre VAR-LINK.
    archive : désarchive le fichier associé.
[F1] + [A] (cacher) :
    fichier / dossier / AppFlash : cache la variable du VAR-LINK. Il ne vaut mieux pas trop le faire avec des fichiers, mais cela ne pose aucun problème avec les dossiers ou avec des AppFlash.
[F1] + [B] (décacher) :
    fichier / dossier / AppFlash : décache les fichiers (!)
[F1] + [C] (KOMPresser) :
    fichier : compresse le fichier sélectionné au format KOMP. Le programme FLIB2 doit être présent sur la calculatrice.
[F1] + [D] (ZIPer) :
    fichier : compresse le fichier sélectionné au format ZIP. Les programmes ZIPCS, ZIPLIB, FILELIB, USERLIB, GRAPHLIB ainsi qu'un kernel doivent être présents sur la calculatrice.
[F1] + [E] (extraire) :
    fichier : décompresse un fichier au format ZIP, PEP ou KOMP.
    dans la poubelle ou un fichier GRP : recrée la variable sélectionnée en RAM.
[F1] + [F] (PEP) :
    fichier : compresse le fichier sélectionné au format PEP. Le programme pepzip doit être présent sur la calculatrice.
[F2] + [1] (setup) :
    permet de choisir quelles doivent être les variables affichées.
    La première colonne correspond au dernier octet de chaque fichier. Ils sont donc tous d'un des ces 13 types. Cependant, des informations supplémentaires peuvent être disponibles à l'intérieur du fichier pour préciser la signature. Les plus courantes sont dans la seconde colonne. Contrairement au type, il y un grand nombre de signatures possibles, et j'ai donc choisi de permettre de changer les différentes signatures filtrées avec [CLEAR].

[F2] + [2] (associations) :
    permet de choisir quel programme sera utilisé pour exécuter un fichier.

[F2] + [3] (chercher) :
    cherche tous les fichiers dont le nom correspond. * et ? sont reconnus.

[F2] + [4] (état mémoire) :
    quelques informations sur la mémoire...

[F2] + [5] (options) :

    Cela permet de choisir d'entrer directement dans un répertoire donné au lancement de CS, et d'autoriser l'effacement de variables archivées (sans les désarchiver au préalable), temporaires, ou cachées.
[F2] + [6] (vider la corbeille) :
    Provoque un garbage memory (réorganisation des archives) qui effacera les fichiers de la poubelle.
[F2] + [7] (effacer l'ID List) :
    fichier : cf. le manuel de la TI, chapitre VAR-LINK.
[F2] + [8] (Self-Test) :
    Exécute le self-test de la TI. De façon générale, on peut également l'obtenir en entrant dans l'écran IO, puis [diamant], [ ) ], [S], sauf que là ça redessine la barre en bas de l'écran.
[F2] + [9] (A propos) :
    Donne la version actuelle de CS. Le Product ID n'est pas totalement inutile, il me permet de savoir quelles sont les options d'assemblage choisies (version kernel / _nostub, 89/92+, bien sûr, mais il y a d'autres options moins visibles). Pratique quand on repère un bug. En plus, ça fait joli :)
[F3] + [1] (envoyer) :
    fichier : cf. le manuel de la TI, chapitre VAR-LINK.
[F3] + [3] (envoyer vers TI-92) :
    fichier : cf. le manuel de la TI, chapitre VAR-LINK.
[F3] + [6] (envoyer l'ID List) :
    fichier : cf. le manuel de la TI, chapitre VAR-LINK.
[F4] :
    sélectionner la variable en cours.
[F5] + [1] (tout sélectionner) :
    fichier : cf. le manuel de la TI, chapitre VAR-LINK.
[F5] + [2] (tout désélectionner) :
    fichier : cf. le manuel de la TI, chapitre VAR-LINK.
[F5] + [3] (sélectionner) :
    fichier : cf. le manuel de la TI, chapitre VAR-LINK.
[F5] + [4] (développer les dossiers) :
    cf. le manuel de la TI, chapitre VAR-LINK. Si on est dans la section "Archive", cette commande développe tous les secteurs d'archive.
[F5] + [5] (replier les dossiers) :
    cf. le manuel de la TI, chapitre VAR-LINK. Si on est dans la section "Archive", cette commande développe tous les secteurs d'archive.
[F5] + [6] (sélectionner le dossier) :
    dossier : choisi le répertoire surligné comme étant le répertoire courant.
[F6] (infos) :
    fichier / dossier :
        affiche le type, l'adresse du fichier dans la VAT, l'adresse du fichier dans la mémoire, son handle, sa taille, la taille de son handle, sa taille d'origine pour les fichiers compressés (aux formats PEP, ZIP, KOMP, ppg, acf), sa dimension pour les PIC et les PV, les arguments des PRGM/FUNC, les bibliothèques requises par les fichiers EXE/LIB, le nombre de fichiers dans les GRP, le nombre de fichiers d'un dossier...


    FlashApp :
        affiche le nom officiel, le nom interne, la taille (4 pour les apps d'origine comme le Home), le TaskID, l'adresse du certificat, les flags... Plein de choses inutiles, quoi !

    1ère ligne :
        affiche quelques informations sur la calculatrice : la version actuelle, le Product ID, la version du boot code, le kernel installé, le hardware, la présence de hw2patch ou de h220xtsr...

    Handles :

    TSR :

    Handle :

Les handles reconnus sont :
    markers : les 4 premiers handles qui servent (je crois) à marquer le début de la heap.
    Estack : la pile d'expression (Expression Stack)
    ACB : bloc créé pour une application flash permettant d'enregistrer des données (Application Control Block)
    ERD : Handle utilisé pour des sauvegardes d'écran par les boîtes de dialogue d'erreur
    Clip : handle utilisé par le ClipBoard (Copier coller)
    VAT : handle correspondant à une variable
    Sysvar : handle utilisé pour gérer les variables système (qui n'ont pas de VAT)
    custom : handles utilisé pour les menus personnalisés (custom)
    DskTop : handle utilisé par le Desktop pour classer les applications flash
    CmdLine : ligne de commande du Home
    app : handle utilisé par une application flash pour ses variables
    window : sauvegarde d'écran
    HOME : handle utilisé par le Home, mais je sais pas à quoi il sert.
    CS : handle utilisé par CS, le gros (taille >= 2000o) correspond à la liste des handles.
    kernel : bin, c'est le kernel installé !
    HOOK, evHk, EvHk : Tsr installés
    h220xtsr : handle de h220xtsr...
    IDList : cf. le var-link
    node : créé à chaque nouvelle entrée dans l'historique du home
    entry : calcul demandé entré dans l'historique du home
    ans : réponse au calcul précédent.
    LIB : bibliothèque en cours d'utilisation
    EXE : programme en cours d'utilisation

[F7] + [1] (transformer en fonction)
    fichiers de type PRGM : modifie le type et le transforme en FUNC. C'est la seule méthode que j'ai trouvée pour pouvoir utiliser les commandes ClrIO, popup, Disp "texte",... dans les fonctions. Les fonctions ne pourront toujours pas modifier des variables globales (donc pas de boîtes de dialogue), mais ça rajoute quand même quelques instructions, qui peuvent être pratique pour débuguer une fonction.
[F7] + [2] (aperçu)
    fichier : cela fait à peu près la même chose que le F6 du VAR-LINK, sauf qu'il marche avec les fichiers compressés

[F7] + [3] (éditeur hexadécimal)
    lance l'éditeur hexadécimal.
[F7] + [4] (VAT doctor :)
    fichier : Il peut toujours avoir des erreurs dans la structure des fichiers de la TI, par exemple après un crash mal récupéré, ou si des programmes écrasent des variables existantes. Cette option vérifie donc :
    -    si il y a un handle,
    -    si le handle n'est pas effacé,
    -    si le bit ¤ est armé pour une variable archivée,
    -    si l'archive n'est pas effacée,
    -    si le nom d'archive est le même que celui de la variable (le nom d'archive est celui sous lequel la variable sera récupérée après un reset) pour les AMS 2.xx,
    -    si le bit ¤ n'est pas armé alors qu'il ne devrait pas l'être,
    -    si le handle est verrouillé (attention, c'est normal qu'il le soit ssi il s'agit d'un programme en cours d'utilisation)
    -    si le handle est beaucoup plus grand que la variable
    -    si la variable est plus grande que son handle
    dans l'archive :
     -    si le bloc archivé ne correspond ni à une variable ni à un handle, il propose de recréer les deux,
    -    si le bloc ne correspond pas à un handle mais que la variable correspondante existe, il propose de marquer le bloc comme effacé,
    -    si le bloc a un handle mais n'est pas attribué à une variable, et que la variable correspondante existe, il propose de l'effacer,
    -    si le bloc a un handle mais n'est pas attribué à une variable, et que la variable correspondante n'existe pas, il propose de recréer la variable. Ce genre de problème peut arriver si vous déverrouiller une variable archivée puis que vous l'effacez depuis le VAR-LINK,
    - MAIS si jamais le bloc est attribué à une variable, il ne vérifie pas que c'est la bonne (on peut le faire depuis l'entrée en VAT).
[F7] + [5] (Exécuter)
    cf. [2nd] + [ENTER].
[F7] + [6] (désassembler)
    sur un fichier de type STR, ASM, EXE ou LIB non compressé : désassemble le programme (!). Cette fonction est en cours de développement. Pour l'instant, on ne peut pas choisir toutes les options de désassemblage. Si jamais j'y arrive (a priori oui, j'ai fait le plus dur), les options seront les suivantes :
    - désassemblage linéaire : oui | non -> désassemble tout le texte à la bourrin, sans faire gaffe aux données
    - envoyer les sources : oui | non -> envoie la source désassemblée dès qu'un fichier est plein, puis le supprime (la mémoire risque d'être trop petite si le programme est vraiment gros)
    - décalage en hexadécimal : oui | non -> écrit $x(an) au lieu de x(an)
    - constantes en hexadécimal : oui | non -> écrit #$x au lieu de #x
    - considérer les lea comme du code : oui | non -> désassemblera les parties atteintes par un lea comme du code et non comme des données
    - archiver les sources : oui | non -> archive un fichier source dès qu'il est plein (pour libérer la RAM)
    - désassembler comme _nostub -> force un fichier kernel à être désassemblé comme un fichier _nostub
    - ajouter des points d'entrées -> vous permet d'ajouter des adresses ou des offsets qui devront être désassemblées comme du code et non comme des données
Pour ajouter des points d'entrées, on écrit les offsets en décimal (ou en hexa précédé de '$') séparés par des virgules ; ex : 120,$C0,48
    CS ne vérifie pas si les données sont correctes, je trouve que cela ne sert à rien. Ceux qui savent vraiment se servir d'un désassembleur ont d'autres choses à faire que planter leur TI pour s'amuser.
Le désassembleur prend en compte :
en nostub :    _nostub, _ti92plus, _ti89, _v200, les ROM_CALL en F-Line, ER-Throw, le relogement d'EX_Patch
en kernel : _exit, _main, _comment, _library, les ROM_CALL, les RAM_CALL, les fonctions exportées et importées, les BSS, les ROM_CALL en F-Line, ER_Throw, le relogement kernel standard. Par contre, il ne prend pas en compte le relogement d'EX_Patch. J'aurais pu le faire, mais c'est inutile car un programme kernel n'a pas le relogement nostub.

La source qui en sortira sera normalement compatible avec a68k (l'assembleur que j'utilise). Tous les fichiers source seront nommés src_x (où est x est un entier), aucune précaution n'est prise pour les créer, s'il existe déjà, il sera effacé ! Il y a également un fichier de type scc_x. Il contient toutes les définitions et les include des header files. On obtient ainsi une source directement compatible avec a68k / TI-GCC.
A l'origine, je pensais donner le choix entre A68K/TI-GCC, as92 et as, mais as92 et as ne reconnaissent pas toujours très bien les commandes ASM (par exemple, il faut écrire mulu.w #x,<ea> pour as92 alors que mon désassembleur donne mulu #x,<ea>).
Pour les chaînes STR, CS ne va accepter de désassembler que celles qui ressemblent à une chaîne EXEC (i.e. avec des caractères dans {0,...,9,A,...,F} avec un nombre pair de caractères)

[F7] + [7] (grouper)
    fichier (en général toute une sélection) : regroupe les variables en une seule, de type GRP. La taille totale ne doit pas dépasser 64ko. Cette fonction est assez pratique car elle évite d'avoir des répertoires pleins de variables dont on ne se sert pas souvent. On peut les extraire ultérieurement avec [F1] + [E].
[F7] + [8] (ajouter à un groupe)
    fichier : ajoute la variable à un groupe déjà existant (il ne faut pas qu'il soit archivé).
[F7] + [9] (lire le texte)
    fichier de type TEXT : utilise le lecteur de texte interne pour lire le texte. Je l'utilise pour lire des sources ASM, car quand je fais [ENTER], c'est txtrider qui est lancé et il fait n'importe quoi quand il lit des sources ASM.
[F8] (aperçu)
    fichier : cela fait à peu près la même chose que le [F6] du VAR-LINK, sauf qu'il marche avec les fichiers compressés

4 CSLaunch

    C'est un petit programme qui me sert à faire différentes choses :
    -    lancé sans argument [cslaunch()],
Sur les TI-92Plus :
il exécute CS en mémoire archive, comme cela, CS ne consomme plus beaucoup de RAM. Avant de l'exécuter, il grossit artificiellement CS jusqu'à atteindre la taille de 65510o puis l'archive - si ce n'est pas déjà le cas. Ne soyez pas surpris s'il y a le message "Warning ! About to garbage collected archive memory" au 1er lancement. CS n'a alors besoin de rien pour pouvoir se lancer (ni kernel, ni hw2patch, ni h220xtsr...). Seul problème insoluble, on ne peut plus compresser avec ziplib pour la bonne raison que c'est cslaunch qui se charge de l'appel ziplib et qu'il est déjà en cours d'utilisation. Deux solutions : faire une copie de cslaunch et l'utiliser pour lancer CS, ou installer CS comme application flash (voir plus bas).
Sur les TI-89 / V200 :
il exécute CS en RAM, il permet d'outrepasser la limite de taille des programmes ASM existante sur certaines AMS. On ne peut alors plus compresser avec ziplib, mais ce n'est pas grave car si la limite de taille existe, c'est aucun kernel n'est installé, rendant impossible l'utilisation de ziplib. Il vaut donc mieux utiliser un kernel.
Cette fonction, que je trouve un peu inutile, va probablement disparaître.

    -    avec une syntaxe de type cslaunch("zip:folder\file"), cslaunch s'exécute en mode kernel (il faut donc un kernel comme Universal OS (AMS <= 2.05) ou PreOS (tous AMS) installé) et compresse le fichier grâce à la bibliothèque ziplib (qui doit être présente sur la calculette).

    -    avec la syntaxe cslaunch("acb"), cslaunch archive en lui faisant prendre cette taille de 65510o puis crée une fausse application Flash. On peut alors exécuter CS comme une application Flash normale. Cette méthode ne marche pour l'instant que sur les TI-92Plus AMS 2.xx, mais c'est la meilleure : presque pas de RAM utilisée, et besoin d'aucun programme externe pour le faire marcher (moi je m'en fous, j'ai toujours un kernel, mais je dis ça pour les fanatiques du mode _nostub).


        Cette méthode permet de ne consommer que très peu de RAM, et ce, même pendant l'exécution de CS.

     -    avec la syntaxe cslaunch("uninst"), cslaunch supprime l'application flash créée avec cslaunch("acb").

    5    Éditeur hexadécimal / Désassembleur

    CS possède un éditeur hexadécimal intégré, auquel on peut accéder avec la touche [APPS] ou avec [F7]+[3].
Il est de base en mode normal (on ne peut pas éditer). Pour l'instant, il n'est pas adapté à la 89, j'ai un peu la flemme de faire les conversions nécessaires...
    Les touches sont alors :
   [haut] / [bas] :
        monte / descend d'un écran.
   [2nd] / [diamant] / [shift] / [Lock] + [haut] / [bas] :
        monte / descend de 0x100, 0x1000, 0x10000, 0x 100000.
   [F1] ... [F8] :
        aller à l'adresse enregistrée n° 1 ... 8.
    [diamant] + [F1] ... [F8] :
        enregistrer l'adresse actuelle en tant que F1 ... F8.
    [ESC] :
        quitter l'éditeur hexadécimal.
    [A] :
        ajouter un offset à l'adresse actuelle.
    [B] :
        repasser en mode bitmap.
   [D] :
        passer en mode désassembleur.
    [E] :
        passer en mode EDIT.
   [F] :
        chercher.
    [G] :
        va à une adresse précise.
    [H] :
        va à un handle précis. La mémoire correspondant à ce handle sera écrite en blanc sur noir au lieu de noir sur blanc. Si vous remontez d'une ligne, les deux octets précédents seront aussi surlignés car ils concernent aussi le handle, mais je déconseille TRÈS fortement de les modifier, sous peine de ruiner la heap.
   [I] :
        regarde si l'adresse actuelle correspond à un ROM_CALL. Sinon, essaie d'identifier le handle dans lequel est située l'adresse.
   [R] :
        va à un ROM_CALL.
    [S] :
        soustraire un offset.
    [T] :
        rafraîchit l'écran (le redessine, quoi).
    [V] :
        chercher de nouveau.
   [diamant] + [P] (Protected Memory Violation) :
        protège / déprotège la mémoire en dessous de 0x120 (un petit verrou est affiché lorsque la mémoire est protégée).
En mode EDIT :

   [haut] / [bas] :
        monte / descend le curseur.
   [MODE] :
        bascule entre les modes ASCII et HEX.
    [A] ... [Z], [0] ... [9] (mode ASCII) :
        écrit le caractère voulu. Rien ne se passe si l'adresse est inférieure à 0x120 et que PVM est activée.
   [A] ... [F], [0] ... [9] (mode HEX) :
        écrit la valeur voulue. Rien ne se passe si l'adresse est inférieure à 0x120 et que PVM est activée.
    [diamant] + [A] (mode HEX) :
        permet d'écrire directement dans la mémoire archive. Demande une première fois la valeur à inscrire, puis fait un AND logique avec la valeur actuelle et affiche la valeur qui sera réellement inscrite. Appuyer sur [ENTER] confirmera l'écriture. Attention, cette opération n'est pas réversible !
   [diamant] + [P] (Protected Memory Violation) :
        protège / déprotège la mémoire en dessous de 0x120.
    [diamant] + [0] ... [7] :
        inverse le bit 0 ... 7 de l'adresse actuelle.
En mode DÉSASSEMBLEUR :

[haut] / [bas] :
        monte / descend d'une ligne.
   [2nd] / [diamant] / [shift] / [Lock] + [haut] / [bas] :
        monte / descend de 0x100, 0x1000, 0x10000, 0x 100000.
   [F1] ... [F8] :
        aller à l'adresse enregistrée n° 1 ... 8.
    [diamant] + [F1] ... [F8] :
        enregistrer l'adresse actuelle en tant que F1 ... F8.
    [ESC] :
        quitter le désassembleur.
    [ENTER] :
        page suivante.
    [A] :
        ajouter un offset à l'adresse actuelle.
    [B] :
        passer en mode bitmap.
    [E] :
        repasser en mode éditeur hexadécimal.
    [G] :
        va à une adresse précise.
    [H] :
        va à un handle précis.
   [R] :
        va à un ROM_CALL.
    [S] :
        soustraire un offset.
En mode BITMAP :
    La mémoire est affichée telle quelle à l'écran. Ce mode permet notamment de repérer des images dans des séquences de bits incompréhensibles par d'autres moyens. Dans la status line, la largeur en octets par rapport à la largeur de l'écran est inscrite en bas de l'écran.

    Par exemple, la fin de CS (là où sont stockées les icônes) est affichée, avec une largeur de 3 octets (soit 3*8=24 pixels)
   [haut] / [bas] :
        monter / descendre d'une ligne.
   [gauche] / [droite] :
        décaler l'image d'un byte à gauche / à droite.
   [diamant] + [gauche] / [droite] :
        diminuer / augmenter la largeur de l'image d'un octet (on peut afficher des images d'une largeur comprise entre 8 et 8000 pixels).
   [2nd] + [bas] / [haut] :
        descendre / monter d'un écran.
   [D] :
        passer en mode désassembleur.
    [E] :
        repasser en mode éditeur hexadécimal.

    6   CSdata

CSdata est un petit fichier automatiquement créé par CS lors de son exécution, qui lui permet d'enregistrer les options. Si CSdata est archivé, les options ne pourront pas être sauvegardées, il vaut donc mieux le laisser dans la RAM. Les informations spécifiques au filtrage et aux associations sont écrites dans CSdata ET dans CS (s'il n'est pas archivé), ainsi, si vous effacez CSdata, ces informations seront reprises pour la création de CSdata. Je conseille donc d'exécuter CS une fois depuis la ligne de commande du HOME sans l'archiver pour enregistrer les options puis de l'archive, et de laisser CSdata dans la RAM.

   7    Remerciements
     D'abord, Albert, Stan, XDanger, Bizuth, ExtendeD, DeadBird, Geogeo, Nerick, Patou, Thibaut, Pollux, Kevin Kofler pour leurs nombreux commentaires et remarques constructives.
    Ensuite, tous ceux qui m'ont permis de programmer en 68000 (Jimmy Mardell pour son 68k guide, l'équipe de TIGCC, tous ceux qui ont programmé un Shell et à qui j'aurais pris des idées)
    Tous ceux que j'ai oublié
    Enfin, tous ceux qui vont utiliser CS !

    8    Bugs connus
-    Exécution des programmes assembleur. La calc se bloque quand elle exécute un programme kernel. J'ai un peu de mal avec ce bug car il ne se produit pas sur VTI, ni sur ma 92+ 2.08 (hw2patchée), ni sur ma V200 2.09 (avec h220xtsr). Si le bug se produit entre les messages "NG_execute [ROM Call 0x25D]..." et "removing error frame...", ce n'est pas de la faute de CS.
-    Les programmes compressés au format PEP qui sont archivés sont recompressés après exécution, alors que cela ne devrait pas être le cas.
-    En mode "libérer la RAM", CS a tendance à exécuter deux fois de suite le programme. J'ai oublié si j'ai supprimé de façon satisfaisante ce bug, mais il me semble que oui.
-    Sur ma V200, quand CS est lancé avec shift-on grâce à PreOS, une erreur se produit quand on essaie d'insérer du texte dans l'application flash en cours (avec [diamant]+[ENTER])
-    Sur PedroM, le répertoire Handles plante la calc, et les menus ne s'affichent pas correctement (à cause d'un bug de MenuOn de PedroM)
-    Il y a encore quelques bugs graphiques sur AMS 1.xx (et peut-être quelques bugs tout court)
-    CS n'a jamais été testé sur PedroM 89.
-    il doit rester pas mal de bugs graphiques sur la version 89 (j'ai pas de 89 chez moi, donc c'est pas top pour tester)
    j'en ai repéré au moins un : l'aperçu d'une image ou d'un texte n'est pas assez grand.

    9    A faire
    Plein de choses :
-> peut-être un désassembleur (plus complet que l'actuel)
-> l'envoi d'applications flash et la fonction réception, mais c'est compliqué et cela prend beaucoup de place pour peu d'intérêt.
-> l'exécution des applications flash si CS est lancé en mode AppFlash
-> lecteur de textes au format txtrider (en plus du lecteur actuel) ? J'en ai commencé un on-calc, mais un bug toujours inexpliqué m'a empêché d'aller plus loin.
-> un anticrash ? je n'en vois pas trop l'utilité, à part peut-être pour pallier la relative instabilité de CS.
-> un éditeur de textes ??? L'éditeur de base est suffisamment performant je trouve.
-> des sous répertoires. C'est maintenant théoriquement possible, mais il faudrait écrire toutes les fonctions pour stocker les infos dans une variable.
-> possibilité de trier les fichiers (par type, taille, nom...)
-> afficher la corbeille sous forme de liste triée (c'est en cours de réalisation)
-> peut-être des menus dans l'éditeur hexadécimal.
-> remplacer l'éditeur hexadécimal actuel (mon hexview2) pour un nouveau (hexview3) plus compact.
-> la possibilité de stopper un désassemblage
-> gérer la compression XPACK
-> gérer les fichiers 68cA (pack archive)
-> ajouter le nom des ROM_CALL au désassembleur (ça se fera à partir d'un fichier externe)

J'ai actuellement plusieurs problèmes pour le désassembleur kernel :
- un bug qui veut pas se laisser trouver avec les ROM_CALL (mais j'ai l'impression qu'il a été éliminé :))
- je ne vois pas comment distinguer code et données parmi les fonctions exportées par une bibliothèque.

10    Historique
Désolé, je commence l'historique à la bourre, donc il manquera beaucoup de choses...

12/02/2004 version 1.00.84.6 : quelques corrections (qui ne sont pas finies) pour faire tourner CS sur PedroM et sur les AMS 1.xx. J'ai corrigé également plusieurs bugs graphiques sur le viewer de textes intégré des versions 89.
08/12/2003 version 1.00.84.1 : début du codage du désassembleur d'AMS, correction de deux bugs qui pouvaient se produire quand il y avait plus de 2000 handles.
30/11/2003 version 1.00.83.14 : correction de divers bugs dans le désassembleur de fichiers kernel (dans le relogement), dans le désassembleur général (dans l'adressage de type x(an,xr.s)), j'ai rajouté l'en-tête des fichiers kernel, enfin !
        ça avance un peu moins vite maintenant, à cause de mon intégration...
        au passage j'ai supprimé les menus dans l'éditeur hexa, car ça marchait pas très bien :(
14/09/2003 version 1.00.83.9 : correction de bugs dans le désassembleur
12/09/2003 version 1.00.83.8 : j'ai un peu changé l'éditeur hexa et le désassembleur pour laisser apparents les menus et la status line, afin de pouvoir utiliser les menus dans les éditeurs hexa (pour ne plus avoir à connaître par coeur les touches). L'entrée des adresses se fait maintenant aussi dans la status line, et j'ai changé le "PVM" tout moche par un petit verrou, toujours dans la status line. Dans le graph-ripper, j'ai rajouté dans la status line le nombre d'octets affichés par ligne par rapport à la largeur de l'écran (30o), et on peut maintenant afficher plus que 30o par lignes. J'ai également corrigé un défaut de ma nouvelle routine d'effacement de TSR. Dans l'éditeur hexa, j'ai corrigé les infos obtenues par [i], cela n'affiche plus n'importe quoi maintenant. Une partie des relogements kernel était oubliée : CS ne prenait en compte que les relogements qui donnaient une adresse (codée sur un longint), alors qu'il faut également prendre en compte les adresses codées sur un word et les valeurs immédiates. Ces relogements viennent d'être rajoutés, et il y a désormais les offsets ajoutés aux relogements (i.e. CS reconnaît les #_RAM_CALL0005+1, par exemple).
06/09/2003 version 1.00.83.2 : ça y est, CS peut effacer correctement les TSR correspondant au nouveau standard EvHk (et non plus seulement ceux au standard evHk).
05/09/2003 version 1.00.82.31 : en fait, le bug précédent d'exécution n'est pas corrigé, un programme archivé compressé en PEP est re-compressé après l'exécution alors qu'il ne devrait pas l'être. Va falloir que je retravaille tout ça. J'ai rajouté des infos sur un secteur d'archive et sur la mémoire archive elle-même. Correction d'un bug dans le désassemblage des _ROM_CALL en F-Line.
04/09/2003 version 1.00.82.30 : Il y avait un bug dans l'exécution de programmes compressés au format PEP, et il est maintenant corrigé (je pense).
31/08/2003 version 1.00.82.29 : Maintenant, quand on crée un handle, on ne revient plus au menu précédent. La poubelle est triée par ordre alphabétique (pas encore très bien, mais ça avance) et les fichiers les plus récents sont en premier (j'ai entièrement recodé la routine pour récupérer les archives et la poubelle).
08/08/2003 version 1.00.82.26 : j'ai rajouté l'affichage de la RAM libre en haut à droite. J'ai codé une routine d'insertion d'objet dans une VAT, ce qui ouvre de nouveaux horizons (sous répertoires, notamment)
29/07/2003 : CSlaunch a été modifié, l'appflash CS ne plante plus depuis le desktop et CSlaunch peut maintenant lancer CS en RAM sur les 89 et V200 (mais je vais peut-être retirer cette fonction, elle fait tout planter).
24/07/2003 version 1.00.82.25 : le format de compression PEP est géré comme les formats ZIP et KOMP. Le désassembleur peut désassembler différentes parties du stub des programmes kernel (bibliothèques importées / exportées, RAM_CALL, ROM_CALL, _main, _exit, _comment). Désassemblage de chaînes EXEC ! Le curseur reprend sa vitesse d'origine quand la calculatrice est éteinte. L'option de désassemblage "considérer les lea comme du code" est faite.
15/07/2003 version 1.00.82.16 : CS a 1 an ! affichage des commentaires sur les TSR compatibles, le désassembleur reconnaît les Line 1011 Emulator et Line 1010 Emulator. Plus de bug possible quand on affiche les infos sur les applications flash d'ID, on peut même les effacer désormais. J'ai enfin commencé les options de désassemblage (ajouter des offsets)
12/07/2003 version 1.00.82.10 ; début de l'historique.
28/08/2002 : TI m'envoie une nouvelle 92+ et retour de vacances : je commence faire l'affichage des infos (F6)
20/08/2002 : j'ai une V200, je commence à écrire des routines qui serviront plus tard (désassembleur)
03/08/2002 version 0.6.x.x : dans la continuité des essais d'exécution, crash total de ma 92+ (blue screeen pendant quelques secondes, puis le sympathique écran : 'Press [I] to reinstall a product code' et enfin à 99%, 'corrupted certificate') -> calc morte :(
31/07/2002 version 0.6.x.x : premiers essais d'exécution avec libération maximale de la RAM. 1ère conséquence : crash de l'AMS 2.05 de ma 92+ (ER_Throw à chaque reboot), mais j'arrive à réinstaller une AMS (ouf !)
28/08/2002 version 0.5.x.x : crash de disque dur, perte du code :( J'ai désassemblé la version qui était sur ma 92+ pour récupérer la source...
21/07/2002 version 0.1.0.0 : portage du code sur TIGCC.
15/07/2002 version 0.0.0.0 : début du code de YCS sur as92 entre un oral de maths :) et un de physique :( à Centrale.