Axe Parser
 | |
 | |
| Développeur | Kevin Horowitz (Quibigo), Runer112 |
|---|---|
| Sortie | le 1 février 2010 |
| Version Stable | Omega 1.2.1a / le 17 décembre 2012 |
| Etat du développement | En développement |
| Programmé en | Asm |
| OS | OS 1.12 à 1.19, 2.41, 2.43, et 2.55 en mode CLASSIC uniquement |
| Disponible en | 1 (en) langage(s) |
| Genre | Compilateur |
| Licence | libre |
| Site Internet |
Forum Axe (en) Documentation (en) Tutoriel (fr) |
La naissance d'un langage
Pour programmer pour calculatrice à processeur z80, il existe 2 langages officiels :
- Le TI-Basic : programmable sur la calculatrice (ou utilitaires PC). Ce langage de "haut niveau" est très simple à apprendre, mais la vitesse d'exécution des programmes TI-Basic reste lente (surtout pour les jeux).
- L'Assembleur (ASM) z80 : programmable sur calculatrice (avec l'application Mimas, ou directement en hexadécimal) mais surtout à partir de logiciels pour ordinateur. Ce langage est cependant beaucoup plus complexe que le TI-Basic mais aussi beaucoup plus puissant, car de très bas niveau (proche du processeur), et est donc considéré comme difficile à apprendre et à maîtriser pour des novices.
La nécessité d'alternatives langage s'imposait alors. Plusieurs tentatives plus ou moins abouties existent (voir tableau plus bas), mais celle qui ressort le plus du lot est l'Axe Parser.
Note:Le mot axe signifie hache (l'arme), et le mot parser est un terme pour désigner le compilateur, lorsque l'on parle de l'Axe Parser, on parle de l'application (du compilateur), mais lorsque l'on parle du langage, on parle de l'Axe )
- À 19 ans, Kevin Horowitz (alias Quigibo), étudiant en génie électrique et informatique, a eu l'idée de créer un langage permettant de bénéficier en partie des avantages de l'assembleur tout en essayant de rester dans le même domaine de simplicité que le TI-Basic.
- Le 1er février 2010 sort une première version de l'Axe Parser. C'est un succès sur le forum Omnimaga qui va en faire un de ses intérêts principaux.
- Dès lors, les versions du compilateur se succèdent et se perfectionnent (encore en développement aujourd'hui). Les possibilités de ce langage sont bien supérieures à celles du TI-Basic et son exécution bien plus rapide, certaines actions souvent utilisées pour des jeux ayant été automatisées par des routines programmées en assembleur.
Historique des Versions
| Version | Date de Parution | Ajouts | Suppressions | Bugfixes | Notes |
|---|---|---|---|---|---|
| 0.0.1 | 01/02/2010 |
|
|||
| 0.0.2 | 02/02/2010 |
|
|||
| 0.0.3 | 05/02/2010 |
|
|||
| 0.0.4 | 15/02/2010 |
|
|
| |
| 0.0.5 | 21/02/2010 |
|
|
||
| 0.0.6 | 28/02/2010 |
|
|
||
| 0.1.0 | 07/03/2010 |
|
|
||
| 0.1.1 | 10/03/2010 |
|
|
||
| 0.1.2 | 15/03/2010 | ||||
| 0.1.3 | 21/03/2010 | ||||
| 0.1.4 | 05/04/2010 | ||||
| 0.1.5 | 11/04/2010 | ||||
| 0.2.0 | 18/04/2010 | ||||
| 0.2.1 | 26/04/2010 | ||||
| 0.2.2 | 04/05/2010 | ||||
| 0.2.3 | 10/05/2010 | ||||
| 0.2.4 | 16/05/2010 | ||||
| 0.2.5 | 21/05/2010 | ||||
| 0.2.6 | 01/06/2010 | ||||
| 0.3.0 | 16/06/2010 | ||||
| 0.3.1 | 19/06/2010 | ||||
| 0.3.2 | 01/07/2010 | ||||
| 0.3.3 | 10/07/2010 | ||||
| 0.4.0 | 25/07/2010 | ||||
| 0.4.1 | 28/07/2010 | ||||
| 0.4.2 | 08/08/2010 | ||||
| 0.4.3 | 10/08/2010 | ||||
| 0.4.4 | 20/08/2010 | ||||
| 0.4.5 | 27/09/2010 | ||||
| 0.4.6 | 28/11/2010 | ||||
| 0.4.7 | 26/12/2010 | ||||
| 0.4.8 | 09/01/2011 | ||||
| 0.5.0 | 12/02/2011 | ||||
| 0.5.1 | 27/03/2011 | ||||
| 0.5.2 | 15/05/2011 | ||||
| 0.5.3 | 28/05/2011 | ||||
| 1.0.0 | 13/06/2011 | ||||
| 1.0.1 | 14/06/2011 | ||||
| 1.0.2 | 25/06/2011 | ||||
| 1.0.3 | 20/08/2011 | ||||
| 1.0.4 | 24/09/2011 | ||||
| 1.0.5 | 26/09/2011 | ||||
| 1.1.0 | 11/12/2011 | ||||
| 1.1.1 | 18/12/2011 | ||||
| 1.1.2 | 03/02/2012 | ||||
| 1.2.0 | 23/11/2012 | ||||
| 1.2.1 | 17/12/2012 |
Avantages et désavantages
Comparaison des langages
| TI-Basic | Basic Étendu | BBC Basic | Grammer | Asm z80 | Axe | |
|---|---|---|---|---|---|---|
| Difficulté du langage | Facile | Facile | Moyen | Moyen | Difficile | Moyen |
| Vitesse | Lent | Lent | Rapide | Très Rapide | Très très rapide | Très rapide |
| Taille des programmes | Normale | Normale | Lourd | Normale | Léger | Lourd |
| Éditable sur la calculatrice? | Oui | Oui | Avec un éditeur spécial | Oui | Avec un éditeur spécial | Oui |
| Programmable/Compilable sans programme assembleur/application ? | Oui | Non | Non | Non | Oui | Non |
| Exécution | Interprété | Interprété | Interprété | Interprété | Compilé | Compilé |
| Support des sprites ? | Non | Oui | Oui | Oui | Oui | Oui |
| Application nécessaire pour la programmation | Aucun | Aucun | 49Ko d'application | aucun | 32Ko d'application (ou un ordinateur) | 32Ko d'application |
| Application nécessaire pour l'exécution | Aucun | 16Ko à 49Ko d'application selon le langage | 49Ko d'application | 16Ko à 32Ko d'application | aucun ou shell | aucun ou shell |
| Compatible avec les shells ? | Oui | Oui | Non | Très Peu | Oui | Oui |
| Spécialité | Math | Tout | Varié | Varié | Tout | Jeux |
| Visibilité du code source | Toujours | Toujours | Toujours | Toujours | Optionnel | Optionnel |
Syntaxe
Le langage Axe utilise l'éditeur de programmes intégré de la calculatrice, soit le même que n'importe quel programme TI-Basic, et donc aussi une partie des tokens. Ainsi, un "hello world" en Axe peut s'écrire de la même manière qu'en TI-Basic :
Disp "Hello world !"
Le langage en lui-même (l'Axe), celui défini dans l'app faisant compilateur (l'Axe Parser), propose à ce jour (avec la version 1.2.1a du compilateur) plus de 150 fonctions par défaut, allant de la simple addition à l'affichage de sprites 8*8 en passant par le réglage du contraste et l'émission de sons par le port jack.
Les surcharges de fonctions et les modificateurs
Étant donné le nombre limité de tokens, le langage devait trouver un moyen de proposer un maximum de fonctions utiles en utilisant un minimum de tokens, pour des soucis de praticité d'utilisation et surtout pour se ménager des tokens pour des fonctions futures. Première idée, les surcharges de fonctions permettent de faire varier l'effet de certaines fonctions simplement en passant un nombre différents de paramètres. Par exemple, alors que :
GetCalc("prgmABC")
... va chercher dans la mémoire de la calculatrice le programme nommé ABC et retourner 0 s'il n'est pas trouvé,
GetCalc("prgmABC",20)
... ne s'embête pas à le chercher et va tout simplement créer ou écraser un éventuel précédent programme ABC avec un homonyme de 20 octets.
Plus tard, les modificateurs vinrent optimiser encore un peu les surcharges de fonctions : c'est en général un token, parfois deux, toujours d'un seul caractère, qu'on rajoute à la fin ou au début d'une fonction pour la "nuancer", changer subtilement son effet. On peut par exemple afficher un sprite sur le back-buffer (appelé par le token L3) de la sorte :
Pt-On(X,Y,SPRITE,L3)
Les modificateurs viennent cependant réduire légèrement la source comme l'exécutable :
Pt-On(X,Y,SPRITE)r
De la même manière, la commande DispGraph change d'effet selon que l'on utilise aucun, un ou deux modificateurs :
DispGraph // copie le main buffer à l'écran DispGraphr // copie le main buffer et le back buffer à l'écran afin de donner 3 niveaux de gris (0%,50%,100%) DispGraphrr // comme précédemment, mais donne 4 niveaux de gris (0%,33%,66%,100%)
Dernier exemple, depuis la version 1.2.1a a été rajouté les modificateurs venant avant le nom des fonctions graphiques pour les dessiner soit en blanc, soit en logique XOR ou autre.
Line(0,0,10,20) // dessine en noir ILine(0,0,10,20) // inverse tous les pixels de l'écran sur lesquels passe la ligne. C'est le token Line( précédé du modificateur I.
Une liste de toutes les commandes de la version actuelle de l'Axe Parser (1.2.1a) est disponible ici et sera mise à jour quand sortiront les différentes versions de l'Axe.
| |||||||||||