	       DOCUMENTATION SUR LE FONCTIONNEMENT DU RPL SYSTEME 
			 (Langage de la HP 48) 

		 Variables locales, environnement temporaires,
		   Boucle parametrable (noyau..), Input,

	    Bref, tout pour crer une vritable application HP
			 en external, rpl systme.

			   16 septembre 1993



____________________________________________________________________________
Ce fichier contient quelques paragraphes traduits de l'anglais du 
fichier RPLMAN.DOC fourni dans la disquette HORN 4.
La traduction que j'ai faite n'est pas une traduction force mot  mot,
et j'ai rajout beaucoup d'information pour toffer, complter (notamment
le chapitre STRUCTURE D'UNE APPLICATION) et quelques
fois permettre une meilleure comprhension des explications qui sont
parfois obscures...
Toutefois, j'ai restitue le plus fidlement possible le 
'contenu intellectuel' de la documentation d'origine ( j'ai ainsi quand mme
bien compris de quoi il s'agissait et comment les principes dcrits 
fonctionnaient pour ne pas vous plonger dans l'erreur..)
De plus, il vous faut absolument possder le fichier JYLOG.TXT qui contient
des informations sur l'utilisation de ce fichier et des autres qui
accompagne celui-ci. Ils constituent les JYLOG'S HPROM FILES que tout
programmeur doit possder. Vous y trouverez aussi le moyen de me contacter
pour toutes remarques utiles.
je signale enfin que ce document est entirement gratuit ...

			amicalement,  Laurent JOUANNEAU  (pseudo: JYLOG)

_____________________________________________________________________________


============================
STRUCTURE D'UNE APPLICATION
============================
	On peut appeler une application, tout programme qui dfinit un nouvel
environnement, qui assigne aux touches un emploi spcifique, une interface
utilisateur spcifique. EQUATION WRITER, MATRIX WRITER, L'ENVIRONNEMENT
GRAPHIQUES ou mme l'environnement de la PILE DE CALCUL sont des
applications. par contre les fonctions du menu math par exemple n'en sont
pas, ce sont de simples routines.
Une application est donc en fait un logiciel a part entire.
	Crer une bonne application HP, c'est avant tout respecter
l'environnement  partir duquel elle a t lance. Il faut ainsi viter de
stocker des variables temporaires dans les rpertoires de home (je trouve
que ca fait dsordre) et prfrez plutt les variables locales (il est
entre autre plus rapide de dtruire un bloc de variables locales ou de lire
ces variables - cf. le chapitre suivant - qu'une liste de variables globales).
Eviter de modifier pict ou d'autres lments qui ne sont pas destines 
votre application. L'utilisateur en sera plus heureux (il pourra garder
ses graphes etc..).
	Une bonne application respecte aussi l'intgrit de la mmoire. Il
faut respecter toutes les piles gres par la machine (pile de calculs, pile
des retours, piles des environnements temporaires, pile des boucles indexes
etc.). Quand on quitte une application, la configuration de la mmoire
doit tre la mme qu'avant le dmarrage du programme.
	La structure d'une application peut tre la suivante:
** vrification des arguments (il est toutefois rare qu'une application
ait  prendre des arguments dans la pile)
** sauver la configuration de l'environnement en cours (des externals sont
fait pour ca, cf. les chapitres suivants)
** dfinir le nouvel environnement (dfinir les menus, l'affichage ...)
** boucle principale qui teste les touches et agit en fonction
** sortie de la boucle: on restaure l'environnement prcdent

l'environnement de l'application peut tre dfini par:
- l'affichage de l'cran principal
- un menu
- des dfinitions de touches


En bref, les qualits d'un logiciel doivent tre:
- FIABLE: dpourvu de bugs !
- ROBUSTE: quelques soit les manipulations de l'utilisateur, le logiciel
   doit savoir rpondre a tout. doit savoir rpondre  n'importe quelle
   touche, shifte ou non, qu'elle ait un sens pour le programme ou non.
- CONVIVIAL: il doit tre agrable et simple  utiliser. penser aux 'bip',
   aux graphismes ou logos ventuels etc. .. pensez  bien grer l'affichage.
   cela est trs important avec la grandeur de l'cran de la hp: il faut
   que cela soit clair et lisible. Il ne faut pas que l'affichage ressemble
    des gribouillis ! ordonnez les lments  afficher. ne surcharger pas
   trop non plus. pensez que vous disposez de trois tailles de caractres.
   essayez de moduler les tailles  l'cran pour faire moins monotone.
- EFFICACE: il doit tre rapide
- COMPACT: l'occupation en mmoire doit tre la plus faible possible.
- LISIBLE: le source (le listing du programme) doit tre clair pour
   pouvoir le relire et l'amliorer facilement. N'hsitez pas  l'imprimer:
   c'est plus facile de lire en ayant le source tal sur le bureau que de
   le lire  travers le petit cran de la hp. N'hsitez pas non plus
    mettre des commentaires  gogo.

Si vous respecter autant que vous le pouvez ces 6 points, votre application
aura beaucoup de chance de plaire et de connatre le succs (en n' oubliant
pas l'utilit du logiciel)



===================================================
VARIABLES TEMPORAIRES ET ENVIRONNEMENTS TEMPORAIRES
===================================================

	L'une des caractristiques implement dans le rpl est la capacit
de crer des VARIABLES TEMPORAIRES dont les noms sont donnes par 
le programmeur, et qui peuvent tre dtruites facilement quand elles
ne sont plus utiles. Ces variables temporaires servent  de nombreux
usages. Le premier, le plus important, est qu'elles liminent toutes
manipulations de pile  l'intrieur d'un programme. Les consquences
sont l'accs direct aux donnes stocks (moins d'instructions) et
la facilite du debuggage du programme. En plus, elles sont essentielles
pour l'implmentation de programmes qui prennent un nombre indfini
de paramtres et veulent sauver un ou plusieurs de ces paramtres.
	les variables temporaires sont rfrences par des objets identi-
ficateurs temporaires (noms locaux), et les attaches entre l'identificateur
et le contenu qu'il reprsente sont mmorises dans une structure appele
ENVIRONNEMENT TEMPORAIRE (que nous appellerons TE =temporary environnement) .
	les TE sont stocks dans un ordre chronologique. cela permet 
au programmeur de crer ses propres variables temporaires, sans interfrer
avec celles cres avec d'autres applications en cours d'excution. (comme
le programme qui est en permanence en fonctionnement: l'environnement de
calcul (affichage des niveaux de la pile, ligne de commande etc. .. ) ).
Quand un identificateur temporaire est excute, une recherche est faites
 travers la pile des TE, en commenant par le plus rcemment cre vers
le plus ancien. A la rencontre de l'identificateur en question dans un des TE,
l'objet lui correspondant est valu. Si l'identificateur est au contraire
introuvable, une erreur est signal  la boucle qui a excut le programme.
(voir plus loin la boucle parametrable).
	le processus de cration d'un TE (donc la cration d'un bloc de
variables locales avec leurs valeurs initiales) est excut par le
programme situe en #074D0h (de mnmonique BIND ou Ldef pour le livre LES
SECRETS DE LA HP48). Ce programme prend en argument une liste au niveau
1 contenant les noms locaux et aux autres niveaux et dans le mme ordre
que la liste, les objets  stock dans les variables correspondantes.
	Ainsi, l'excution de l'un des identificateurs, correspond 
l'excution de l'objet attach  cet identificateur. On peut changer
la valeur d'une variable temporaire en utilisant STO (ou l'external
correspondant) comme pour les variables globales du menu HOME.
	pour dtruire un environnement temporaire, il faut excut
le programme situ en #07497h (ABND ou Lpop pour le livre LES SECRETS...).
ABND dtruit donc le TE le plus rcemment cre, dans la pile des TE.
(mme principe que pour la pile avec laquelle nous faisons nos calculs)
	Des variables temporaires individuelles ne peuvent pas tre enlevs
d'un TE. La destruction d'un TE implique la destruction de toutes les 
variables qui s'y trouvent.
	Notez que le compilateur RPL ne contrle pas si il y a pour chaque
ABND un BIND. Il faut donc veillez a ce qu'il y ait les deux (cration
et destruction d'un TE) au sein d'un mme programme ou au sein d'une application,
de faon a ce que le plus rcent TE avant le lancement de votre application
redeviennent le plus rcent aprs la fin de votre application. Contrairement
au RPL utilisateur ou l'instruction  '-> <<' qui correspond en fait  BIND et
l'instruction '>>' qui correspond  ABND, doivent se trouver au sein d'un mme
objet programme, BIND et ABND peuvent se trouver dans deux objets programmes
diffrents, du moment qu'ils soient excuts quand il faut.

	structure d'un TE.
	-------------------

tout d'abord, voyons l'organisation de la pile des TE.
 TE 1 (le plus rcent)
 TE 2
 ....
 dernier TE (le plus ancien)
 00000

chaque TE est structure de la faon suivante:
 longueur du TE (5 quartets)
 mot de protection (5 quartets)
 adresse premier nom local
 adresse contenu de la premire variable locale
 ....
 adresse dernier nom local
 adresse contenu de la dernire variable locale
fin du TE

chaque TE  contient donc sa longueur, un mot de protection (nombre) utilise 
pour la gestion des erreurs puis les adresses des noms et des contenus de 
chaque variables temporaires du TE.
toutes ces adresses sont mises a jour a chaque modification des variables 
locales.
l'adresse de la pile des TE est indique en 70583


	noms des variables temporaires.
	------------------------------

	les variables temporaires sont normalement nommes par les identifi-
cateurs indiques dans la liste donne en argument  BIND. Ils peuvent contenir 
tout les caractres mais ne peuvent commencer par ' et #, rservs aux noms 
cres par les programmes de la rom. 
	les noms crer dans un TE ne peuvent interfrer avec ceux d'un autre 
TE, mme si ils sont identiques. Il est possible aussi de crer plusieurs 
variables dans un mme TE  ayant le mme nom mais une seule de ces variables 
sera accessible. Il est donc intressant d'avoir pour toutes les variables 
le nom local vide, ce qui permet un gain de mmoire.
	Pour accder  ces variables, on ne peut pas utiliser leur noms mais 
il faut utiliser des routines de la rom permettant accder  la premiere, 
2eme, 3eme, nieme variables (dans l'ordre ou elles ont t stockes). 
(voir le livre LES SECRETS DE LA HP 48).
	
============
LES BOUCLES
============

il y a deux types de boucles: indfinies et dfinies

+boucles indfinies
du type DO UNTIL ou WHILE REPEAT. on ne sort de ces boucles que grce  une 
condition qui renvoie a la boucle un boolen. 
pour plus d'info: LES SECRETS....

+les boucles dfinies
elles se diffrencient des boucles indfinies par l'existence d'un compteur 
de boucle et d'une valeur qui conditionne la fin de la boucle. (que l'on se 
sert (boucle FOR) ou non (boucle START) de la valeur du compteur). il vient 
donc le problme de stocker ces deux valeurs, dans des variables locales mais 
sans interfrer avec le TE en cours. Il est donc crer un TE spcial, un
TE doloop. Tout comme les TE 'normaux', ils sont stocks dans une pile. 
on peut donc avoir plusieurs boucles imbriques. Il existe des routines pour 
accder aux index des deux boucles les plus imbriques.
la structure de la pile des TE doloop est la suivante:
 nombre de boucle (5 quartets)
 boucle la plus interne (la plus rcemment crer)
   mot de protection (5 quartet. mme utilisation qu'un TE normal)
   valeur de l'index (5 quartets)
   valeur de stop (5 quartets)
 boucle qui contient la prcdente
   mot de protection (5 quartets)
   valeur de l'index (5 quartets)
   valeur de stop (5 quartets)
etc. ...
l'adresse de la pile des TE doloop est indique en 70588

==============================
GESTION ET GENERATION D'ERREUR 
==============================

	Une erreur est gnre par l'external #04ED1h de mnmonique Errjmp.
son fonctionnement sera dcrit plus tard.
	le RPL fournit des routines qui sont capables d'intercepter
l'excution d'une erreur,  l'intrieur d'un programme (un sous-systme).
	Pour intercepter une erreur il faut un test du type IFERR..THEN..END.
on dispose pour cela des externals #04E5E (Errset)= le IFERR et de #04EB8 
(Errtrap) = le Then.
	la syntaxe est la suivante:
      ...
      04E5E 
      <objet suspect> programme ou external  risque
      04EB8
      <objet iferr> excute en cas d'erreur
      ...

	Une erreur gnre par <objet suspect> est ainsi intercepter.
ainsi: si <objet suspect> gnre une erreur, alors on excute <objet iferr> 
sinon on continue aprs <objet iferr>.
	l'action de <objet iferr> est entirement flexible; quand celui-ci
prend le contrle, il peut examiner la valeur de l'erreur et le message
de l'erreur pour dterminer oui ou non  si ils sont galement concerne 
avec l'erreur en cours. 
 si non, il suffit simplement de redmarrer 
le sous-systme ou a eu lieu l'erreur en excutant ERRJMP. 
 si oui, on peut effacer le numro et le message d'erreur, ne pas redmarrer 
le sous-systme. cela pourrai aussi interrompre l'excution du reste du 
programme.

l'action de ERRJMP:
quand une procdure rpl veut lancer une erreur, elle excute ERRJMP.
il y a ainsi une sortie du rpl en cours et recherche, grce  la pile des
retours (pile contenant des adresses de retour), l'instruction ERRTRAP (04EB8)
qui prcde <objet iferr> pour ensuite excut ce dernier. ERRTRAP est donc
excute que si il n'y a pas eu d'erreur lors de l'excution de <objet suspect>.
dans ce cas, ERRTRAP sautera <objet iferr> et continuera le rpl.
si une procdure ne fait pas passer simplement  une erreur qui n'a pas
t initialiser, cette invocation de ERRJMP pourrai tre prcde par
l'excution de #04D0Eh, qui definit un numro d'erreur (donne en argument
au niveau 1 en system binary). la routine en #04CE6 renvoi ce numro, ce qui
peut tre trs utile pour savoir comment agir en fonction de ce numro
dans <objet iferr>. le numro d'erreur est code sur 5 quartets. les 3
quartets de poids forts reprsente le numro de library et les deux autres
quartets, le numro d'erreur dans cette library qui reprsente le numro
d'un des messages de la library.

le mot de protection:
vous avez pu voir que chaque TE et TE doloop possde un mot de protection.
l'unique raison de l'existence de ce mot de protection est de permettre
de distinguer les TE et TE doloop avant et aprs dtection d'une erreur.
par exemple le programme:
PROG
  BIND cration d'un TE
  ...
   0 10 START  cration d'une premiere boucle
    ERRSET   iferror
    prog2
      ...
      BIND cration d'un 2eme TE
      3 7 START cration d'une 2eme boucle
      <procdure>
      NEXT  fin 2eme boucle
      ABND destruction 2eme TE   
    endprog
    ERRTRAP  thenerror
     prog
      ... traitement des erreurs
     end
    ...
   NEXT fin 1ere boucle
  ABND destruction 1er TE
ENDPROG

si <procdure> gnre une erreur, alors cette erreur sera intercepte par
ERRTRAP. Il faut de toute faon, dtruire le TE et le TE doloop interne
(les deuximes cre) pour que, lors de la sortie de prog2 force par
ERRJMP, on retrouve les bons paramtres de la boucle 1 et du 1er TE, c'est
 dire que ces premiers TE doivent tre les premiers dans leur piles
correspondantes.
Mais pour cela, il faut savoir quel TE et quel TE doloop il faut dtruire
car il peut tre crer dans <objet suspect> plusieurs TE. Le mot de
protection sert  savoir justement lesquels il faut dtruire.
 ERRSET, quand il est excute, incrmente les mots de protection du TE
et du TE doloop les plus rcent, ceux existant avant l'excution de
<objet suspect>. ceux-ci n'ont donc plus leur mots de protection  0.
(les mots de protection des TE et TE doloop sont  0  leur
cration comme ceux qui sont cres  l'intrieur d'un <objet suspect> ).
Ainsi, ERRTRAP ou ERRJMP dtruise les TE et TE doloop jusqu' ce qu'ils y en aient
qui n'ont pas leur mot de protection  0. Ces derniers rencontrs ont leur
mot de protection decrement.
ce qui fait donc qu'il ne reste que les TE et TE doloop qui existaient avant 
l'excution de ERRSET.


================
CONTROL CLAVIER
================

un programme qui requiert des saisies claviers de la part de l'utilisateur peut
utiliser trois techniques de bases:
	-1- attente de l'appui d'une touche, quelconque ou non.
	-2- appel de la forme interne de INPUT.
	-3- branchement sur la boucle parametrable interne.

pour la premiere technique, il s'agit de routine du type KEY ou 0 WAIT. voyez 
pour cela le livre LES SECRETS...

pour la deuxime technique:
cette forme interne de input se trouve en #42F44
elle prend pour arguments:
-10- la chane  afficher  en tant que message
-9- la chane reprsentant la ligne de saisie initiale
-8- la position initial du curseur en system binary ou une liste de 2 system binary
-7- le mode du curseur: <0h> mode courant, <1h> insertion, <2h> recouvrement
-6- le mode d'entre: <0h> mode courant + PRG, <1h> PRG, <2h> ALG+PRG
-5- mode alpha: <0h> mode courant, <1h> alpha verrouille, <2h> alpha dsactive
-4- objet dfinissant le menu (programme ou liste)
-3- le numro de page de ce menu
-2- boolen: indique si l'appui sur ON  quitte le mode d'dition (true) ou 
    efface l'objet en cours d'dition (false)
-1- renvoi de INPUT: <0h> chane, <1h> chaine+objet evalue, <2h> objet evalue

enfin pour la troisime technique:

..................................
LA BOUCLE DE CONTROLE PARAMETRABLE
..................................

dans cette section, le terme de boucle de contrle parametrable dsigne un
ensemble d'utilitaire (dcrits plus loin), qui a partir d'argument spcifies 
ci dessous, prennent le contrle du clavier et prennent en charge l'affichage 
de l'cran aux moments ncessaires. Et cette boucle ne sera terminer qu'a 
certaine conditions que vous aurez dfini.
voici ses 9 arguments:

	-9- obj excute avant chaque exe des touches
	-8- programme de gestion des touches qui prendra en argument
	     2 sysbin (code touche et etat shift) et renvoi FALSE s'il ne gere
	    pas la touche, true plus un programme qui sera excute par cette boucle
	-7- boolen: false si touches non assigne seront ignores, true sinon
	-6- boolen: sert au cas ou le boolen prcdent est TRUE. les touches
	    ont alors une dfinition standards (TRUE) ou une autre dfinition
	    par dfaut (comme le mode user) (FALSE)
	-5- une liste ou un prog dcrivant le menu
	-4- le numro de page du menu
	-3- drapeau autorisant/interdisant instruction halt
	-2- clause de fin: prog qui renvoi boolen pour dire si il faut
	    quitter la boucle ou non
	-1- objet  excut en cas d'erreur


la boucle parametrable ne renvoi aucun arguments. cependant, n'importe quelle
touches utilises par l'application peut retourner des rsultats soit dans la 
pile soit par d'autres manires (cran etc. ...).

La boucle parametrable se trouve en #38985

voici les utilitaires pour la boucle parametrable

POLSaveUI       389BC: sauve l'environnement en cours. permet, aprs sortie 
		de la boucle et restauration, de se retrouver dans le contexte 
		d'avant POLSaveUI. 
POLSetUI        38A64: dfini un nouvel environnement en cours grce aux 9 
		arguments prcdents
POLKeyUI        38AEB: c'est le coeur de la boucle. 
POLResUI&Err    38B77: restaure l'environnement prcdent et excute une erreur
POLRestoreUI    38B90: restaure l'environnement prcdent (celui sauve en 
		389BC)

ces utilitaires peuvent tre utilise par les applications qui
demandent un meilleur contrle sur l'interface utilisateur.
par exemple

+ pour viter l'inutile, et du ralentissement, une application qui 
utilise de multiple boucle parametrable conscutive, peut appeler POLSaveUI au 
dbut de l'application, puis appeler POLSetUI et POLKeyUI a diffrent moment 
au cours de l'application, puis pour terminer l'application, appeler 
POLRestoreUI.

description de la boucle:

POLSaveUI. sauve le systme ou l'interface utilisateur de l'application en 
  cours
IF error
  POLSetUI. paramtre la nouvelle interface utilisateur
  POLKeyUI:
   ( tant que l'valuation de l'objet donne en deuxime argument renvoi false,
   ( valuer l'argument 9, puis IFerror pendant le test et l'valuation des 
   ( touches, alors on excute l'argument 1
alors on excute POLResUI&Err
sinon on continue: POLRestoreUI
...

la boucle parametrable cre un TE quand elle sauve l'interface utilisateur 
courant. et ce TE est dtruit lors de la restauration. vous ne pouvez donc
accder aux variables locales cres avant l'excution de la boucle, par
leur numro d'ordre (cf. LES SECRETS ...). et seulement par leur nom ce qui
peut poser problme si vous avez cre un bloc de variables qui ont toutes
le mme nom. par contre il n'y a aucun problme pour les variables locales
cres pendant l'excution de la boucle parametrable: accs possible
par leurs numros. ce bloc cre alors, doit tre dtruit avant la sortie de
la boucle.


Grer les erreurs avec les utilitaires:

pour s'assurer que les sauvegardes des paramtres des interfaces utilisateur
peuvent tre restaurer convenablement si une erreur apparat  l'intrieur
de l'application, la boucle parametrable protge celles-ci en excutant
immdiatement aprs la sauvegarde par POLSaveUI, une structure IFError.
ainsi sa structure interne (dcrite plus haut aussi ) est:

POLSaveUI (sauve les paramtres de l'interface utilisateur )
ERRSET
 POLsetUI (definit la nouvelle interface)
 POLKeyUI (contrle des touche etc. ...)
ERRTRAP       (si erreur alors
 POLResUI&Err (restaure l'interface utilisateur et excute le prog d'erreur)
POLRestoreUI (restaure l'interface utilisateur prcdente)

toute application qui n'utilise pas forcement la boucle parametrable mais
les utilitaires de celle-ci, doivent obligatoirement tre conu de sorte
 retrouver la mme configuration de pile des TE et doloop
aprs sortie de l'application, qu'avant le lancement de cette dernire.
pour viter un plantage final de la machine.

grer cran:

il n'y a pas de routines d'affichage d'cran par dfaut, dans la boucle
parametrable. C'est votre application qui est responsable de l'affichage
tant au moment du lancement de celle-ci, qu'au cours de son excution,
c'est a dire le changement de l'aspect de l'affichage au cours du
temps.
pour cela vous avez deux moyens:
 - la 'mise a jour' de l'affichage peut se produire pendant l'valuation
   du programme donn en 9eme argument, qui est prvu pour cela.
   ce programme est excute avant chaque appui de touche.
 - ensuite, tant donne que vous prvoyez pour chaque touche, un programme
   qui est evalue aprs appui de la touche correspondante, (voir plus loin
   pour plus d'info sur la gestion des touches), vous pouvez inclure dans
   ce programme, des routines graphique changeant l'aspect de l'ecran
   directement.

prenons un exemple: en appuyant sur la touche flche bas dans Matrix Writer.
en simplifiant le processus : le programme correspondant  cette touche incremente
la coordonne verticale de la cellule vise. et le programme charger de
l'affichage de l'ecran (excut avant chaque appui touche), definit en fonction
des coordonnes, quelle cellule il faut afficher en noir.

chacun des deux moyens a ses avantages pour l'affichage, dans des circonstances
diffrentes.

le premier argument de la boucle: programme de gestion des erreurs.

ce programme est responsable de ce qui se passe lorsqu'une erreur apparat
lorsqu'une touche est value. Il est donc valuer lors de ces moments la.
ce programme, analyse l'erreur apparu (par son numro) et excute les
routines qu'il faut. si l'erreur en question est inconnue, il doit
excut ERRJMP.

la programme de gestion des touches (8eme argument de la boucle)

toutes les touches de la hp, sur les 6 plans (non shift, shift droite,
shifte gauche, alpha, alpha shifte droite, alpha shifte gauche),
doivent pouvoir tre contrle. ce programme justement indique
 la boucle quelle routine il faut excute pour une touche spcifique.
Si une touche n'est pas reconnu par ce programme (touche qui n'a donc
aucune utilisation pour votre application), alors la dcision de la
boucle sur quoi excute pour cette touche est dtermine par les
deux boolens donnes en argument a la boucle (6eme et 7eme).
si le boolen 7 (7eme argument) est FALSE, alors il y a un bip
et puis c'est tout.
par contre si le boolen 7 est TRUE, alors la touche  une
signification standards ou un autre processus par dfaut, suivant
le boolen 6. par exemple: si le mode user des touches est enclench,
alors la touche  une signification standard si boolen 6 est TRUE, ou
au contraire une signification definit dans le mode user, si le boolen
est FALSE.

En gnral, le boolen 7 est FALSE pour permettre un contrle total sur
le droulement de l'application.

le programme signal en sous titre, definit donc quelle routine la boucle
doit excut, pour les touches qui ont une signification bien prcise.
Il doit pouvoir prendre en arguments deux system binary. le premier,
(niveau 1 de la pile) indique le numro du plan du clavier, et le second
le numro de code de la touche (voir plus loin pour les codes).
le programme doit ensuite renvoyer la routine correspondant  la touche
au niveau 2, et TRUE au niveau 1. ou bien, si la touche n'a pas
de signification spcifique, ( donc qui a une dfinition standard, voir
aucune), le programme doit renvoyer juste FALSE.

le programme doit tre du style:
 si le plan est 0 alors excut routine plan0
 si le plan est 1 alors excut routine plan1
 etc. ...

et les routines plan0, plan1 etc. sont du type
 .si numro touche=trucmuche alors mettre la routine qui correspond
   la touche trucmuche sur la pile et TRUE puis fin du programme
 .si numro touche=bidule alors mettre la routine qui correspond
   la touche bidule sur la pile et TRUE puis fin du programme
 etc. ...
 et enfin en dernier, un FALSE qui signifie que le code de la
 touche ne correspond  rien de prcis (ou alors a une
 signification standard ou autre). le code a passe tout les tests
 sans succs.

pour ces tests, on peut utiliser la routine en 3FF1B
la syntaxe dans le rpl est <<  ... 3FF1B OBJET suite ... >>
et prend en arguments deux sysbin et excute:
si sysbin1=sysbin2 alors enlve les 2 sysbin de la pile, met
OBJET et TRUE dans la pile, puis quitte le rpl en cours.
sinon, enlve juste sysbin1 de la pile et continue le rpl 
suite. pour tester les codes de touches: sysbin2 est le code
de la touche qui vient d'tre enfonce, et OBJET, un objet 
valuer quand c'est la touche de code sysbin1 qui est enfonce.
chaque routine plan0, plan1 etc. devient
<<  <code1> 3FF1B OBJET1 <code2> 3FF1B OBJET2 etc. .... FALSE >>

si OBJET est un xlib, alors on peut remplacer 3FF1B par 3FF48.
on aura alors comme rsultat au niveau 2, non pas le xlib, mais
son contenu.

5eme argument: objet dfinissant le menu de l'application

votre logiciel peut avoir son propre menu, avec les touches
dfinies sur les trois plans de clavier. le 5eme argument de la
boucle parametrable permet de le dfinir. Il peut s'agir d'une
liste comme dcrit dans le manuel de la hp48, ou bien d'un programme
contenant des externals permettant de construire, de personnaliser le
menu et qui renvoi une liste. Vous pouvez ainsi des labels de menus
diffrents : labels de saisie comme pour HPSOLVE, labels avec des petites 
barres en haut, indiquant accs  un autre menu, ou encore des labels
aux graphismes originaux. Par ce programme, vous pouvez aussi dfinir de
faon prcise la signification des touches de menu, dfinir un 'REVIEW',
prciser quoi faire  chaque changement de page de menu etc. ...
pour plus de renseignement, reporter vous au livre LES SECRETS...
A la sortie de l'application, le menu existant avant le dmarrage
de la boucle est restaur.
Si vous ne voulez pas dfinir un menu spcifique et garder celui qui
est en cours, avant le dmarrage de la boucle, vous devez alors mettre
en 5eme argument, FALSE au lieu d'une liste ou programme.
Si le 5eme argument est une liste vide, alors la boucle definit un menu
vide.

Remarque: la dfinition des touches de menus tablie par le 8eme argument 
a la priorit sur celle tablie par le menu (5eme argument).
vous pouvez donc inclure au dbut de votre programme de test de touche,
la squence d'external suivante:
  63687 6356A
  63687: excute dup et renvoi true si le system binary du niveau 1 est
   inferieur  7
  6356A: si le boolen est true au niveau 1 est TRUE, alors met FALSE dans
   la pile et quitte le rpl en cours.
