******************************************************************************* Mac2E (v2.0) Préprocesseur de macros pour le langage E Archive du 9 janvier 1994 (c) Copyright 1993, 1994, Lionel Vintenat ******************************************************************************* ATTENTION ! Mac2E nécessite le Workbench 2.0 ou plus pour fonctionner. Désolé pour les utilisateurs du 1.3 (voir `futur'). De même, il y a des restrictions pour l'utilisation des exécutables de cette archive (voir `bugs'). 1. Introduction ~~~~~~~~~~~~~~~ 1.1. Comment tout a commencé... ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Au début, il y avait l'Amiga E et moi. C'était formidable, à nous deux, on faisait de jolis programmes en un temps record. Comme je n'avais pas (et n'ai d'ailleurs toujours pas) les RKMs, ces programmes étaient trés laids, sans interface graphique, mais qu'importe, c'était le bon temps... Et puis, MUI est arrivé, et là, plus rien n'a été pareil entre Amiga E et moi. Pourquoi ? Et bien Amiga E ne permet pas l'utilisation de macros, et programmer MUI sans macro, c'est preque de la folie ! D'autre part, c'était inconcevable de passer à côté de quelque chose comme MUI. Alors, je me suis rabattu un temps sur le langage C : ca a été le début des années noires pour mon Amiga... Et puis j'ai eu accés à INTERNET. J'ai donc parlé de mon problème à Wouter qui m'a conseillé d'utiliser un préprocesseur C : en voila une grande idée ! Mais après essais, ca s'est révélé trés lourd à utiliser : les temps de compilation étaient multipliés par 100, et surtout le compilateur n'affichait plus les bons numéros de lignes en cas d'erreur. C'est à ce moment là qu'est venu l'idée de Mac2E... 1.2. Présentation ~~~~~~~~~~~~~~~~~ Mac2E est un préprocesseur pour le compilateur Amiga E de Wouter van Oortmerssen, mais qui ne sait faire qu'une seule chose : remplacer des macros dans un source E. Autrement dit, les aspects "compilation conditionnelle" et "inclusion de fichiers" par exemple ne sont pas traités par Mac2E, alors que dans la plupart des préprocesseurs C, c'est le cas. Pourquoi seulement cet aspect ? Voir `comment tout a commencé...'. Ah ! J'allais oublié : tous les exécutables de cette archive sont bien-sûr écrits en Amiga E ! 1.3. Esprit ~~~~~~~~~~~ J'ai conçu Mac2E avec 3 idées en tête : - faire quelque chose de simple à utiliser (dans l'esprit de Amiga E) - palier aux problèmes que j'avais rencontrés dans l'utilisa- tion d'un préprocesseur C avec Amiga E (voir `comment tout a commencé...') - faire un préprocesseur dont l'utilisation ne rende pas les sources E dépendants de celui-ci, autrement dit, si la prochaine version d'Amiga E qui sort contient un préprocesseur (possible d'aprés Wouter), le passage de vos sources de Mac2E vers ce préprocesseur ne devra nécessiter que trés peu de modifications de ceux-ci Dans cette version 2.0, je n'ai malheureusement pas réussi à faire tout ce que je voulais, à savoir que malgré de nombreuses optimisations (voir `historique') Mac2E n'est pas trés rapide (voire trés lent) par rapport à la fusée qu'est Amiga E, mais ne desespérez pas : je pense qu'il est quand même plus rapide qu'un préprocesseur C (je n'ai essayé que CPP, le préprocesseur de GCC), et je vais arranger ça pour les prochaines versions (voir `futur'). Par contre : - Mac2E reste trés proche au niveau de l'utilisation d'un préprocesseur C classique, donc son apprentissage sera trés rapide pour la plu- part des programmeurs - Mac2E n'introduit jamais de saut de ligne quand il remplace une macro, ce qui fait que le compilateur indique toujours la bonne ligne en cas d'erreur - la définition des macros se fait dans des fichiers à part des sources, et les fichiers de macros sont passés directement à la commande Mac2E sans que vos sources aient besoin d'être modifiés d'un caractère, donc le passage de Mac2E au futur (peut-être) préprocesseur de Amiga E sera trés simple et n'entrainera qu'un minimum de modifications de vos sources Donc en attendant la prochaine version de Mac2E (voir `futur'), je conseille à tous les possesseurs d'Amiga lents d'utiliser pour les gros fichiers qui contiennent beaucoup de macros le programme EPP de Barry Wills (e-mail bwillskkirk.safb.af.mil) disponible sur aminet. Celui-ci permet de simuler la fonction "inclusion de fichiers" d'un préprocesseur classique. Ainsi, il suffit de concentrer l'utilisation des macros dans un seul fichier source (tout le reste étant distribué dans d'autres) pour n'avoir à utiliser Mac2E que quand vous modifiez ce fichier, et non à chaque compilation. 2. Utilisation ~~~~~~~~~~~~~~ 2.1. Appel ~~~~~~~~~~ Mac2E ne s'utilise qu'à partir du CLI. Sa syntaxe d'appel est trés simple : Mac2E fichier_source_e fichier_destination_e {fichier_de_macros} où : - fichier_source_e désigne un nom de fichier source (éventuellement avec son chemin d'accés) écrit en e contenant des macros a remplacer (voir `les macros dans vos sources') - fichier_destination_e désigne un nom de fichier (éventuellement avec son chemin d'accés) qui sera créé par Mac2E, et qui contiendra fichier_source_e mais avec les macros remplacées (voir `les macros dans vos sources') - {fichier_de_macros} désigne une suite de nom de fichiers (éventuel- lement avec leur chemin d'accés) de macros séparés par un espace (voir `les fichiers de macros') Pour ceux qui connaissent, l'évaluation de la ligne de commande se fait avec la fonction ReadArgs() du Workbench 2.0. Donc l'appel "Mac2E ?" renvoie la syntaxe d'appel "au format ReadArgs", à savoir "FROM/A,TO/A,WITH/A/M". Vous pouvez donc aussi appeler Mac2E en utilisant les propiétés de la fonction ReadArgs(). 2.2. Les fichiers de macros ~~~~~~~~~~~~~~~~~~~~~~~~~~~ Les fichiers de macros sont des fichiers annexes à vos sources E qui ne contiennent que des définitions de macros. Lors de l'appel de Mac2E (voir `Appel'), les fichiers de macros passés en paramètres sont analysés pour mémoriser les macros qui y sont définies. Ce sont ces macros qui seront utilisées pour les remplacements dans le fichier source E. 2.2.1. Structure ~~~~~~~~~~~~~~~~ La structure d'un fichier de macros est trés simple. En fait, il n'y a que 2 choses à savoir. Premièrement, la syntaxe de définition d'une macro est exactement la même qu'en C (voir `définition des macros'), en particulier elle commence toujours par "#define". Deuxièmement, entre chaque définition de macro, vous pouvez insérer des commentaires sous la forme que vous voulez (il n'est pas nécessaire de les encadrer par /* et */, ou n'importe quoi d'autre). En effet, Mac2E se contente de rechercher dans le fichier de macros la chaine "#define " (en sautant tout ce qui précède) de manière a repérer le début de la définition d'une macro. La seule restriction pour un commentaire est donc qu'il ne contienne pas la chaine "#define ". 2.2.2. Définition des macros ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ La définition d'une macro doit être de la forme : #define nom_macro1 corps_de_la_macro1 ou #define nom_macro2(paramètre1,paramètre2) corps_de_la_macro2 ou #define nom_macro3 corps_de_la_macro3_partie1 \ corps_de_la_macro3_partie2 \ corps_de_la_macro3_partie3 Le 1er exemple correpond à une macro toute simple sans paramètre, et dont le corps tient sur une seule ligne. Le 2nd exemple correspond à une macro qui possède des paramètres. Le 3ème exemple correspond à une macro dont le corps ne tient pas sur une seule ligne. Une fois la macro identifiée, Mac2E recommence sa recherche aveugle de la chaine "#define ". Pour comprendre comment est utilisée une macro, voir `les macros dans vos sources'. Pour des exemples supplémentaires de définition de macro, voir `Mac2E et MUI'. 2.2.2.1. #define ~~~~~~~~~~~~~~~~ La déclaration commence donc par la chaine "#define". Elle peut se trouver n'importe où (pas forcément en début de ligne) et doit être suivie d'au moins un espace ou une tabulation. Si ce n'est pas le cas, Mac2E ne reconnaitra pas le début d'un déclaration de macro et poursuivra sans signaler d'erreur, alors faites attention ! 2.2.2.2. Nom de la macro ~~~~~~~~~~~~~~~~~~~~~~~~ Ensuite vient le nom de la macro lui-même. Celui-ci peut être une com- binaison quelconque des caractères a..z, A..Z, 0..9 et _ (underscore). Autre- ment dit, "120" ou "___" ou encore "FOR" sont des macros valables, mais sure- ment pas conseillées ! Ne soyez pas vicieux, et appelez plutôt vos macros "toto", "titi" ,"tata" ou plus sérieusement "Ouvrir_Fenêtre1"... 2.2.2.3. Les paramètres de la macro ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Ensuite vient la déclaration des paramètres. Une macro peut avoir de 0 à une infinité de paramètres. Si elle n'en possède aucun, on passe directement à la déclaration du corps de la macro. Si elle en possède, ils sont séparés les uns des autres par des virgules, et encadrés par des parenthèses. La première de celles-ci doit être accolée au nom de la macro. Il est par contre possible d'introduire des espaces et des tabulations entres les virgules, les noms des paramètres, et les parenthèses à l'intérieur de celles-ci. Les noms des para- mètres suivent les mêmes règles que le nom de la macro lui-même. 2.2.2.4. Le corps de la macro ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Enfin, la déclaration s'achève par le corps de la macro. Celui-ci doit être séparé des paramètres (ou du nom de la macro si celle-ci n'en a pas) par au moins un espace ou une tabulation. En fait, tous les espaces et toutes les tabulations rencontrés avant le corps sont éliminés. Le 1er caractere trouvé, qui soit différent de l'espace et de la tabulation, marque le début du corps. A partir de ce moment, tous les caractères trouvés (même les espaces et les tabulations) sont considérés comme appartenant au corps de la macro. Celui-ci prends fin dès qu'un retour chariot est rencontré. Si le retour chariot est précédé d'un \ (anti-slash), le retour chariot ainsi que le \ sont ignorés et Mac2E continue à lire les caractères suivants comme faisant partie du corps de la macro. Attention : la suite des 3 caractères '\', ' ' et le retour cha- riot sera interprété comme '\' et ' ' appartenant au corps de la macro et le retour chariot comme marquant la fin de ce corps. Donc le retour chariot doit suivre immédiatement le \ pour que Mac2E comprenne qu'il faut continuer la lecture du corps sur la ligne suivante. Voici un exemple concret pour illus- trer ceci. Mac2E comprendra que la macro définie ainsi #define macro corps_partie1 corps_partie2 \ corps_partie3 corps_partie4 \ \ corps_partie5 a pour corps "corps_partie1 corps_patrie2 corps_partie3 corps_partie4 \ corps_partie5" 2.3. Les macros dans vos sources ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Après avoir analysé tous les fichiers de macros, Mac2E commence le remplacement des macros dans le fichier source précisé en paramètre, et ecrit le fichier résultat. 2.3.1. Une macro dans un source ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Mac2E reconnait une macro dans le fichier source par son nom (étonnant non ?). Attention, Mac2E fait la différence entre majuscules et minuscules. Pour être reconnu, le nom d'une macro doit être précédé et suivi d'un carac- tère de séparation, c'est-à-dire différent de a..z, A..Z et _. Le contenu des commentaires (même imbriqués) ou des chaines entre quotes est sauté pour la recherche. Vous n'avez donc pas à vous soucier des conflits qu'il pourrait y avoir. De même, le caractère ' dans "'" n'est pas interprété comme le début d'une chaine. Pour autant qu'on puisse dire qu'on a pensé à tout, je pense que Mac2E peut faire face à tous les cas parti- culiers comme le précédent. Par contre, Mac2E suppose que votre source est correct. Par exemple, si vous écrivez 'l'origine' au lieu de 'l\aorigine' dans un de vos sources, Mac2E prendra le 2ème ' comme indicateur de fin de la chaine et le 3ème comme celui de début d'une chaine, ce qui a de grandes chances de provoquer des erreurs ! 2.3.2. Une macro sans paramètre ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Si Mac2E identifie une macro toto dans votre source, cette macro ayant été définie sans paramètre, il remplacera textuellement toto par le corps de la macro. Bien-sûr, si ce corps contient lui-même des noms de macros, ceux-ci seront remplacés de manière adéquate. Attention, Mac2E ne vérifie pas la récursivité de vos définitions de macros. Donc, si le programme boucle et finit par se planter lamentablement, revoyez vos définitions... 2.3.3. Une macro avec paramètres ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Plutôt qu'un long discours, prenons un exemple. Supposons que Mac2E identifie dans votre source une macro toto qui a été définie ainsi : #define toto(variable,valeur) variable:=variable+valeur Supposons maintenant que dans votre source, il y ait toto(a,3). Alors Mac2E va remplacer textuellement toto(a,3) par a:=a+3. Autrement dit, à chaque paramètre précisé au moment de la déclaration (appelé paramètre formel), Mac2E associe un paramètre précisé dans votre source (appelé paramètre réel), et remplace chaque occurence d'un paramètre formel par le paramètre réel correspondant dans le corps de la macro, avant de rem- placer la macro par son corps lui-même. Pour que cela marche, il faut que la 1ère parenthèse introduisant les paramètres réels soit directement accolée au nom de la macro. Par contre, il est possible d'introduire des espaces et des tabulations entre les virgules, les noms des paramètres, et les parenthèses à l'intérieur de celles-ci. Bien-sûr, si le corps de la macro contient lui-même des noms de macros, ceux-ci seront remplacés de manière adéquate. Attention, Mac2E ne vérifie pas la récursivité de vos définitions de macros. Donc, si le programme boucle et finit par se planter lamentablement, revoyez vos définitions... Par contre, vous pouvez tout à fait écrire toto(tata(titi)) où toto, tata et titi sont des macros, Mac2E remplacera le tout correctement. 2.4. Les erreurs ~~~~~~~~~~~~~~~~ Pour les erreurs d'entrée/sortie (impossible d'ouvrir le fichier source par exemple), Mac2E signale clairement l'erreur en question. Par contre, pour les erreurs rencontrées dans l'analyse des fichiers de macros ou du fichier source, Mac2E n'affiche qu'un simple message du type "Error in line 100 !", ceci pour une question de rapidité. Le numéro de ligne renvoyé est exact à 1 près. En effet, l'erreur peut en fait se trouver à la ligne précédente. Lors de l'analyse d'un fichier de macros, Mac2E ne retourne une erreur que si la syntaxe de définition d'une macro n'est pas correcte. Voir alors `définition des macros'. Lors de l'analyse du fichier source, Mac2E ne retourne une erreur que si une macro a été reconnue mais que le nombre d'arguments qui lui sont passés est incorrect. 3. Mac2E et MUI ~~~~~~~~~~~~~~~ Si vous avez lu `comment tout a commencé...', vous savez que Mac2E doit son existence à ce que MUI est infiniment plus facile à programmer avec des macros que sans. C'est pourquoi le 1er exemple (et le seul pour l'instant) d'utilisation de Mac2E va concerner MUI. Vous trouverez dans cette archive tout ce qu'il faut pour utiliser MUI avec Amiga E, exactement de la même manière que vous le feriez en C. Pour cela, il faut 5 choses : - Mac2E : voir `présentation' et `utilisation' - mui.m - muimaster.m - mui.e - OptiMUI2E L'idée générale qui a gouvourné la conception de mui.m et mui.e est je le rappelle de faire "une interface MUI-Amiga E" très proche de celle du C, donc pendant la programmation, il est utile de se baser sur le fichier include mui.h destiné au langage C. En effet, celui-ci contient un nombre impression- nant de commentaires que j'ai supprimé dans "la version E" pour une question de rapidité d'analyse. Toute "cette interface" est basée sur MUI 1.4. Dans l'archive de MUI, il y a déjà certains fichiers pour l'utiliser en langage E, mais en aucun cas, aussi complets ni aussi pratiques que ceux fournis ici. Oubliez les donc et essayez ceux-là ! 3.1. mui.m ~~~~~~~~~~ mui.m est comme son nom l'indique un fichier include classique de Amiga E. Il contient toutes les structures définies dans mui.h à la diffé- rence près que tous les noms (des structures et des champs de celles-ci) sont en minuscules. Cette limitation est due à Iconvert. En effet, j'utilise pour la création de mui.m un fichier include assembleur où je définis toutes les structures de mui.h en assembleur, et avec les noms originaux (en gardant donc les majuscules et les minuscules telles quelles). Malheureusement, Iconvert, qui transforme ce fichier include assembleur en fichier include E, positionne tous les noms des structures et de leurs champs en minuscules. Si donc vous voulez utiliser dans vos programmes des structures MUI, il faut mettre au début de votre fichier source MODULE 'libraries/mui.m'. 3.2. muimaster.m ~~~~~~~~~~~~~~~~ muimaster.m est comme son nom l'indique un fichier include classique de Amiga E. Il contient toutes les définitions des fonctions de la librairie muimaster.library. Les noms des fonctions sont les mêmes qu'en C excepté qu'ils commencent tous par MuI au lieu de MUI (exemple : MuI_NewObjectA). Cette limitation est imposée par Amiga E du fait que les noms de fonction doivent avoir leur première lettre en majuscule et la deuxième en minuscule. Si donc vous voulez utiliser dans vos programmes des fonctions de la librairie muimaster.library (et il y a des chances que ce soit le cas !), il faut mettre au début de votre fichier source MODULE 'muimaster.m'. 3.3. mui.e ~~~~~~~~~~ mui.e est la clé de voute de "cette interface MUI-Amiga E" puisqu'il contient toutes les macros (constantes et choses plus complexes comme la défi- nition d'objets) du fichier mui.h, mais revisitées pour le langage E. La syn- taxe des macros de mui.e, ainsi que la syntaxe de leur corps, est exactement la même que dans mui.h. En plus de l'intérêt pour l'utilisation de MUI de ce fichier, il cons- titue aussi une grosse bibliothèque d'exemples de déclaration de macros. Donc pour utiliser toutes ces macros MUI dans vos sources E, il faut lancer Mac2E sur votre fichier source avant l'appel du compilateur : Mac2E source.e destination.e MacroFiles/mui.e 3.4. OptiMUI2E ~~~~~~~~~~~~~~ Si vous jetez un coup d'oeil sur `mui.e', vous verrez dans le corps des macros qui définissent de nouveaux objets des "TAG_IGNORE,0", par exemple "#define WindowObject MuI_NewObjectA('Window.mui',TAG_IGNORE,0". Ce tag ne fait comme son nom l'indique strictement rien à l'exécution. Cependant, j'ai été obligé de les introduire pour garder la même syntaxe d'utilisation qu'en C à cause des listes en E qui doivent être entourées par [ et ]. C'est à ce niveau qu'intervient OptiMUI2E. Son rôle est d'enlever ces "TAG_IGNORE,0" inutiles des sources E. Sa syntaxe d'appel est la suivante : OptiMUI2E fichier_source_e fichier_destination_e où - fichier_source_e désigne le nom d'un fichier source (avec éventuelle- ment son chemin d'accés) écrit en E où il y a des "TAG_IGNORE,0" -fichier_destination_e désigne le nom d'un fichier (avec éventuelle- ment son chemin d'accés) qui contiendra fichier_source_e avec tous les "TAG_IGNORE,0" supprimés OptiMUI2E utilise également la fonction ReadArgs() du Workbench 2.0 pour évaluer sa ligne de commande. Le format d'entrée qu'il attend est "FROM/A,TO/A". En fait, OptiMUI2E remplace la chaine "[TAG_IGNORE,0," (caractéristique d'une macro MUI de création d'objet) par [. Attention, OptiMUI2E enlève parfois des retours chariots de vos sources pour respecter la coupure des lignes sur une virgule, obligatoire en E. Donc le fichier produit ne comporte pas forcément le même nombre de lignes que le fichier de départ, d'où de possibles problèmes pour les numéros de lignes d'erreur retournés par le compilateur. Il est donc trés vivement conseillé de n'utiliser OptiMUI2E que pour une ultime compilation une fois le programme terminé et testé. De toute façon, OptiMUI2E n'est absolument pas nécessaire pour utiliser MUI avec Amiga E. Il réduit un peu la taille des sources et des exécutables utilisant des macros MUI, mais ceci dans une faible mesure. Je n'ai inclus ce programme que parce que je suis maniaque, et je pense que seuls ceux qui ont aussi ce défaut l'utiliseront aussi ! Attention (bis), OptiMUI2E ne marche pas sur les Amiga à base de 68000 (voir `bugs'). 4. Bugs ~~~~~~~ Pas de panique ! La liste qui suit ne contient pas que des bugs, mais la plupart du temps des limitations des programmes. * Mac2E ne marche que sous Workbench 2.0 ou plus : la prochaine version tournera sur 1.3 (voir `futur'). * OptiMUI2E ne marche pas sur les Amiga à base de 68000. Ayant un 68030 sur mon Amiga, je n'ai pas fait attention à l'alignement à des adresses paires, et je me suis aperçu trop tard des conséquences... De toute façon, ce programme n'est pas primordial et je pense corriger cela dans la prochaine version (voir `futur'). * Mac2E ne vérifie pas si les déclarations de macros sont récursives, donc si c'est le cas, Mac2E peut partir dans des réflexions que seul un reset pourra stopper... * Mac2E ne vérifie pas toujours qu'il obtient bien la mémoire qu'il demande. Pour des demandes de mémoire importantes (comme pour charger un fichier), il vérifie qu'il a obtenu ce qu'il a demandé, mais pas pour de petites demandes (comme 10 octets pour stocker un nom de macro), toujours pour des raisons de rapidité. Donc ne lancez pas Mac2E dans des conditions critiques de mémoire où il pourrait provoquer un guru... Ca ne devrait cepen- dant pas être un gros problème car Mac2E n'est pas trés gourmand en mémoire : il a besoin d'à peu prés le total de la taille de tous les fichiers de macros utilisés plus la taille du source, et plus une dizaine de Ko de marge. * Mac2E ne vérifie pas exactement la validité des définitions de macro définie dans `définition des macros'. Des définitions plus laxistes peuvent passer sans problème. Cependant, je ne dirais pas lesquelles pour que personne ne soit tenté de les essayer car les prochaines versions seront peut-être moins tolérantes. Résumons tout ça en disant que les exécutables de cette archive sont bourrés de bugs, mais ils devraient s'exécuter sans problème dans 99% des cas en donnant des résultats satisfaisants. J'ai préféré sacrifier le blindage de ces programmes à leur rapidité. 5. Historique ~~~~~~~~~~~~~ * v1.0 : 1ère version fonctionnelle de Mac2E (TRES TRES LENTE...) * v2.0 : version remaniée de la v1.0 avec beaucoup d'optimisations assembleur dans le source E (10 fois plus rapide !) adjonction de Opti2MUI 1ère version distribuée 6. Futur ~~~~~~~~ Cette première version distribuée de Mac2E est tout à fait fonction- nelle mais comparée à Amiga E c'est une tortue ensablée ! Aussi, les prochaines versions iront dans le sens d'une augmentation de la vitesse : - tous les fichiers de macros seront preprocessés pour accélerer leur analyse - Mac2E permettra l'aspect "inclusion de fichier" d'un préprocesseur C classique en appelant lui-même le compilateur et en gérant lui-même les numéro des lignes d'erreur à partir des messages du compilateur - Mac2E gérera le préprocessing des macros un peu à la manière de l'outil make de manière à n'effectuer le remplacement des macros que quand cela est nécessaire - Mac2E pourra appeler directement OptiMUI2E - Mac2E marchera sous Workbench 1.3 - Mac2E changera surement de nom si il inclut tout ce qui précède ! - OptiMUI2E sera proposé en version 68000 et 68020+ Cela a peut-être l'air un peu ambitieux, mais la base est déjà là. Donc si on ne me signale pas beaucoup de bugs inconnues (ce que j'espère), ça ne devrait pas être si long à implanter. L'avenir nous le dira... 7. Distribution ~~~~~~~~~~~~~~~ Cette archive est librement distribuable par tout moyen de communica- tion et par tout individu ou organisation (collections FISH, CAM, ou DPAT, serveurs RTC, etc) tant qu'aucune rétribution autre que celle du prix des disques et des envois n'est demandée. Cependant, l'archive dans son entier doit être distribuée. Celle-ci doit avoir la structure suivante : Mac2E/Bin/Mac2E Mac2E/Bin/OptiMUI2E Mac2E/Docs/Mac2E.docE Mac2E/Docs/Mac2E.docF Mac2E/Docs/Mac2E.guideE Mac2E/Docs/Mac2E.guideF Mac2E/MacroFiles/mui.e Mac2E/Modules/libraries/mui.m Mac2E/Modules/muimaster.m Mac2E/readme.first Mac2E/ReadMe.mui D'autre part, tous ces fichiers (exceptés mui.m, muimaster.m, mui.e et ReadMe.mui) restent sous copyright de l'auteur. Aucun d'entre eux ne peut être modifié sans mon accord. Enfin je dégage toute responsabilité quant à l'utilisation de ce pro- gramme et les dommages qu'il pourrait causer : vous l'utilisez à vos risques et périls ! Ce programme est distribué selon le concept Freeware, c'est-à-dire que vous n'étes absolument pas obligé de m'envoyer quoi que ce soit ! Cependant je serais heureux de recevoir n'importe quoi, d'un Amiga 4000/40 à une simple carte postale de vos vacances, en passant par 20FF ou un simple mail ! 8. L'auteur ~~~~~~~~~~~ Vous pouvez me joindre par courrier : - à mon adresse étudiante valable jusqu'en juillet 1994 inclus : Lionel Vintenat appartement 21 11 rue François Oulié 31500 TOULOUSE FRANCE - à mon adresse familiale : Lionel Vintenat 3 impasse Boileau Lotissement Les Termes 87270 COUZEIX FRANCE Ecrivez moi plutôt à mon adresse étudiante jusqu'en juillet 1994 car j'y suis beaucoup plus souvent qu'à mon domicile familiale. Vous pouvez également me joindre sur INTERNET. Mon adresse e-mail est vintenat@irit.fr. Je préfère de trés loin que vous me contactiez par mail que par courrier. Je répondrai toujours aux questions qui me seront posées par mail, par contre n'espérez pas de réponses à un courrier (je suis trés fainéant dés qu'il s'agit de prendre un stylo...). 9. Les remerciements ~~~~~~~~~~~~~~~~~~~~ Un grand merci : - à l'Amiga pour être le meilleur ordinateur personnel - à Wouter van Oortmerssen pour son travail dans le domaine de la compilation (essayez son FALSE, surprise garantie !) en général et pour Amiga E en particulier - à Eric Totel pour m'avoir poussé a finir dans des délais raisonnables cette documentation (je suis réellement fainéant...) - à Stephan Sürken (e-mail s_suerke@informatik.uni-kl.de) pour son utilitaire Text2Guide qui a servi faire les documentations en hypertexte de cette archive - à tous ceux de la mailing liste Amiga française qui m'ont aidé - à tous ceux qui font du domaine public en général Enfin, merci d'avance à tous ceux qui me signaleront des `bugs'ou des suggestions, ou encore qui me feront parvenir des corrections ou des traduc- tions de cette documentation. Bonne programmation en E and ... NEVER FORGET, ONLY AMIGA MAKES IT POSSIBLE !