Suivez-nous sur X
|
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z,
ALL
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z
|
|
A propos d'Obligement
|
|
David Brunet
|
|
|
|
Programmation : AMOS - Disquette auto-amorçable et non-fonctionnement compilé
(Article écrit par Denis Bernard et extrait d'Amiga News - mars 1994)
|
|
Comment faire une disquette a auto-amorçable ?
Pourquoi ça ne marche pas en compilé ?
Voici deux questions qui me sont posées régulièrement et auxquelles je vais répondre
aujourd'hui. Ainsi, je n'aurai plus qu'à dire "Reportez-vous à cet article".
Création d'une disquette auto-amorçable
Il vous faut une disquette formatée sur laquelle nous allons copier quelques fichiers système.
Si vous avez AMOS Pro, utilisez le Disc Manager pour copier les fichiers, sinon ouvrez une
fenêtre Shell. Si vous n'avez pas de disque dur, tapez d'abord les commandes suivantes :
Resident c:copy pure
Resident c:makedir pure
Resident c:install pure
Resident c:Ed pure
|
Ceci vous permettra de ne pas avoir à réintroduire votre disquette système à chaque fois que vous
entrerez une nouvelle commande. Insérez ensuite votre disquette formatée dans votre lecteur de
disquette interne (DF0:). Nous allons d'abord rendre cette disquette amorçable, c'est-à-dire
faire en sorte que l'Amiga la reconnaisse comme disquette de démarrage :
Créons ensuite les répertoires système dont nous aurons besoin :
makedir DF0:c
makedir DF0:s
makedir DF0:libs
makedir DF0:l
makedir DF0:devs
makedir DF0:devs/keymaps
|
Copions maintenant les fichiers système. Certains remarqueront que les fichiers mentionnés
n'existent pas sur leur système, notamment les possesseurs d'Amiga 500+, 600, 3000, 1200,
4000 et en général tous ceux qui ont un Amiga équipé des systèmes 2.0+ et 3.0+.
Dans ce cas, pas de panique, ignorez tout simplement les commandes concernant des fichiers
que vous n'avez pas.
A partir d'ici, à chaque copie, on vous demandera probablement d'introduire votre disquette
système puis votre disquette formatée. Introduisez simplement la disquette demandée dans le
lecteur demandée, mais n'oubliez pas de remettre votre disquette formatée dans le lecteur interne avant
d'entrer une nouvelle commande dans votre fenêtre Shell.
Un doigt de commandes CLI :
copy c:run DF0:c
copy c:cd DF0:c
copy c:echo DF0:c
copy c:setpatch DF0:c
copy Sys:system/setmap DF0:c
|
Un soupçon de bibliothèques :
copy libs:amos.library DF0:libs ; (pour AMOS Pro)
copy libs:diskfont.library DF0:libs ; (pour Get Fonts)
copy libs:mathieeedoubbas.library DF0:libs
copy libs:mathtrans.library DF0:libs
|
Une goutte de gestionnaires et autres fichiers :
copy devs:system-configuration DF0:devs
copy devs:keymaps/f DF0:devs/keymaps
copy l:disk-validator DF0:l
copy l:ram-handler DF0:l
|
Créez maintenant un fichier startup-sequence avec l'utilitaire Ed :
Ed DF0:s/startup-sequence
|
Puis, dans la fenêtre d'Ed, entrez les lignes suivantes :
setpatch >NIL:
c:setmap f
echo "patientez, chargement de toto" ; exemple de message
|
Sauvez ensuite en appuyant sur la touche "Escape" puis "x" et enfin sur la touche "Entrée".
Comme tout ceci vous a pris beaucoup de temps (surtout si vous n'avez qu'un seul lecteur de
disquette et pas de disque dur), faites une copie de votre disquette ainsi préparée,
ce qui vous évitera de renouveler l'opération la prochaine fois...
A partir d'ici, nous avons trois possibilités :
1. Vous avez un programme compilé (avec AMOS ou AMOS Pro Compiler).
Copiez simplement votre programme compilé sur la disquette puis avec l'utilitaire Ed :
Ed DF0:s/startup-sequence
|
Ajoutez à la fin du fichier la ligne :
toto ; en imaginant que vous ayez appelé votre programme compilé "toto"
|
Et sauvez avec "Escape", "x", "Entrée".
2. Vous avez un programme interprété en AMOS.
Copiez "RAMOS1.3" sur votre disquette ainsi que tout le répertoire "AMOS_System" :
makedir DF0:amos_system
copy AMOS:RAMOS1.3 DF0:
copy AMOS:amos_system/#? DF0:amos_system/
|
Copiez ensuite votre programme AMOS (imaginons que vous l'ayez sauvé sur votre disquette
AMOS et qu'il s'appelle "toto.AMOS") :
copy AMOS:toto.AMOS DF0:Autoexec.amos
|
Puis, avec l'utilitaire Ed :
Ed DF0:s/startup-sequence
|
Ajoutez à la fin du fichier la ligne :
Et sauvez avec "Escape", "x", "Entrée".
3. Vous avez un programme interprété en AMOS Pro.
Copiez tout le répertoire "APSystem" sauf les fichiers concernant l'éditeur et le moniteur :
makedir DF0:APSystem
copy AMOSPro_System:APSystem/#?.lib DF0:APSystem
copy AMOSPro_System:APSystem/AMOSPro_Default_Resource.abk DF0:APSystem
|
Copiez le fichier de configuration de l'interpréteur :
copy AMOSPro_System:s/AMOSPro_Interpreter_Config DF0:s
|
Copiez le fichier AMOSPro lui-même :
copy AMOSPro_System:AMOSPro DF0:
|
Copiez enfin votre programme (en supposant qu'il s'appelle "toto.AMOS" et qu'il soit sauvé
sur votre disquette système AMOS Pro) :
copy AMOSPro_System:toto.AMOS DF0:Autoexec.AMOS
|
Puis, avec l'utilitaire Ed :
Ed DF0:s/startup-sequence
|
Ajoutez à la fin du fichier la ligne :
Et sauvez avec "Escape", "x", "Entrée".
Ça ne marche pas en compilé !
Pour ceux qui ont commandé directement le compilateur AMOS Pro en Angleterre,
voici quelques indications intéressantes.
La fonction Val() fonctionne (!) très bien. Cependant, le compilateur fait quelques optimisations,
qui, dans un cas particulier, rendront cette fonction inopérante. Supposez que vous
ayez besoin de demander à l'utilisateur d'entrer un nombre décimal autrement qu'avec une commande
Input. Si vous utilisez l'interface, pas question d'utiliser la routine d'entrée de nombres qui
n'accepte que les nombres entiers. La seule solution est d'utiliser une routine de saisie du
nombre sous la forme d'une chaîne de caractères. Il faut ensuite enlever les caractères parasites
de la chaîne puis la réafficher à l'utilisateur pour lui montrer ce que le programme a compris.
Solution simple :
La fonction Val() va faire le tri dans la chaîne entrée et la fonction Str$()
retransforme le nombre "compris" (ou traduit par Val()) en chaîne de caractères
pour pouvoir l'afficher avec la commande "Text".
Tout ceci fonctionne très bien en mode interprété, mais dès qu'on compile, on se retrouve
avec une chaîne vide... Même pas 0, rien, le néant ! Il s'agit d'un problème d'optimisation
du compilateur. Pour éviter le problème, il faut utiliser :
A=Val(A$)
Text X,Y,Str$(A)
|
En deux temps, ça passe beaucoup mieux !
Environ une fois sur trois, un programme compilé avec AMOS Pro Compiler plante
au démarrage sur système 1.3... Problème connu et en cours de correction.
Patience !
Votre superbe programme de jeux fonctionne parfaitement en interprété, mais
en compilé l'affichage est mal synchronisé et ça flache de partout...
En fait, ceci est dû à la rapidité du programme compilé, dans lequel il faut temporiser
la boucle principale et certaines instructions à l'aide d'instructions "Wait Vbl".
Pour finir, un truc très pratique pour ceux qui utilisent AMOS Pro avec le mode "Auto
Resume" activé. C'est très bien lorsque vous travaillez sur un projet mais si vous avez
chargé un programme d'une disquette (protégée en écriture) et que vous souhaitez quitter
AMOS Pro, celui-ci veut absolument écrire quelque chose sur la disquette et refuse
de quitter s'il ne peut pas le faire. Plutôt gênant. En mode direct, tapez la commande
"System".
|
