Compilateur TURBO BASIC pour Alice 32-90

[Daniel]

Seul contre tous à y croire, tu as encore du travail pour nous convaincre. Il y a un moment où il faudra reconnaître l'erreur, ne tarde pas trop.

[Bernouilli92]

Si tu remplaces chaque instruction basic par le code machine de ce qui est exécuté quand l'instruction est exécutée, alors tu vas obtenir un programme en langage machine qui sera 10-20 fois plus gros que le programme basic et qui ne sera pas plus rapide étant donné que le code machine exécuté sera le même.

[__sam__]

Je crois qu'il faut considérer ceci comme de l'expérimentation de tas de trucs différents. Moi avant de savoir comment le compilateur va sérialiser le code binaire, où s'il va s'exécuter sur l'alice (car tout ceci est secondaire), je voudrais savoir s'il est capable de traduire autre chose qu'une suite de print. En effet les programmes comme ca sont hyper rares.

Un programme basic fait bien plus de choses en pratique et même déjà des petits programmes sans prétention sont facilement complexes à réaliser en langage machine. Allez encore un autre exemple dont j'aimerais bien voir la traduction automatisé:

Code : Tout sélectionner

10 A=10
20 B=2
30 FOR C=1 TO A STEP B
40 D=D+C
50 NEXT C
60 PRINT D
70 END

Il est simple mais il y a des trucs sur lesquels il faut faire attention:

• ligne 30: La boucle FOR ne termine pas sur une constante mais une variable.
• Il y a un STEP. Elle ne va pas de 1 en 1, en conséquence elle n'atteint pas la valeur de A et saute au dessus (on passe de 9 à 11). L'utilisation d'un BEQ pour détecter la fin de boucle n'ira pas ici. Or si B valait 1, c'est comme s'il n'y avait pas de STEP, donc BEQ irait. Mince, comment fait-on ? Autre cas à considérer: B=-1 ou B=-2 avec A=-10. Comment doit être traduit cette boucle dans le cas général où les valeurs de départ, de fin et le "pas" ne sont pas connues lors de la compilation ? Exemple si on a

  Code : Tout sélectionner

  10 INPUT A
  20 INPUT B

  en début de programme.
• ligne 40: La variable D est implicitement initialisée à 0.
• Que se passe t'il en cas de débordement de capacité durant l'addition ?
• ligne 60: La routine d'affichage d'une valeur décimale sera instructive car c'est complètement différent d'une chaine de caractères qui contient déjà les caractères à afficher.

[David.G]

@Bernouilli92 : Oui, c'est un problème supplémentaire et c'est justement ça qui est intéressant.

[David.G]

je voudrais savoir s'il est capable de traduire autre chose qu'une suite de print. En effet les programmes comme ca sont hyper rares.

Je m'y emploie. Mais je te demande quelques jours car je débute complètement en langage machine et tu me proposes déjà 3 programmes en BASIC à traduire en L.M.

Je trouve le défi passionnant car j'adore les casse-têtes chinois comme tu t'en doutes.

Le premier, je sais que je peux le faire et je le mettrai sur ce topic.

Le deuxième, je suis en train d'apprendre comment faire un modulo 2 en langage machine (on divise le reste, etc. je crois me souvenir)

Le troisième est encore plus corsé !

On voit tout de suite que tu pars d'un nombre impair mais que le STEP est une incrémentation de 2.

Donc si tu pars de 1 et que tu essaies d'atteindre 10 en ajoutant 2 à chaque fois, on ne peut pas car tu ne peux atteindre que 9, puis 11.

Je vais regarder comment réagit le BASIC Alice avec ce programme déjà. S'enlise t-il dans une boucle infinie ? On va voir.

Je me suis amusé à le transposer en Javascript et ça fait carrément planter le site de W3chools !! MDR

boucle For JS.png (86.72 Kio) Consulté 757 fois

[Zebulon]

@David, depuis quelques jours je suis en train de regarder comment fonctionnent les divers compilateurs de BASIC qui ont été publié sur CPC et les produits commerciaux de cette époque avaient tous de très nombreuses limitations/restrictions voire bugs donc clairement tu ne dois pas viser un truc parfait mais forcément faire des choix. Un classique est l'absence de support des nombres décimaux, la plupart ne supportent que les entiers sur 16-bit, donc exit les maths poussées. Lire les documentations et les tests des revues spécialisées est très instructif, notamment sur le fait que le gain de vitesse espéré est généralement limité aux structures de contrôles (boucles, tests, appels de sous-routines) et pas tellement aux instructions textes/graphiques qui appellent les mêmes fonctions langage machine que le BASIC.

@Sam ton dernier exemple a suscité ma curiosité. Je l'ai testé sur CPC et déjà le BASIC s'en sort (ouf) et me donne 25. Après passage à la moulinette du Turbo Basic (Hisoft) le résultat est "variable" d'une exécution à l'autre. Il commence un peu au dessus de 26000 et s'incrémente de 25 à chaque exécution. Il a fallu que j'ajoute une initialisation de D à 0 avant la boucle dans le programme BASIC pour que cela fonctionne comme attendu.

Donc les critères de sortie sont bien gérés sur >= et pas juste = par contre là où le BASIC réinitialise implicitement D à 0 le LM compilé ne le fait pas.

[David.G]

@Zebulon : TRÈS intéressant ce que tu apportes là : Je ne savais pas qu'un TURBO BASIC existait sur CPC !!! Ça prouve que c'est possible !!!!!!!!!
(Je ne connaissais que celui de Borland)

Ce topic devient de plus en plus intéressant vu le niveau de difficulté technique qu'il propose !!

Il a effectivement des limitations et il les stipule. Voici la doc en pdf : https://www.cpcwiki.eu/imgs/1/1e/Hisoft ... Manual.pdf

Ce qui est SUPER c'est qu'il propose un Space Invaders en BASIC et en Binaire, exactement mon but final!

Le CPC est plus puissant que l'Alice et a plus de RAM, on voit que ses jeux sont bien meilleurs que ceux de l'Alice bien sûr,

mais je dois pouvoir sortir un truc sympa, sachant que si on peut faire un truc sur Amstrad CPC, on peut faire un truc aussi (même si moins bien) sur Alice 32-90.

Tu pourrais essayer de compiler ta première ligne de BASIC sur Amstrad CPC, je mettrai un peu de code ici si ça t'intéresse.

Cela ne m'étonnerait pas que _Sam_ en crée un pour ordinateur Thomson MO ou TO, car lui on voit qu'il est balèze en programmation en langage machine par rapport à moi qui ne connaît que 3 mnémoniques et qui débute. A vos claviers les mecs !!


Tiens tiens, un concurrent...

Hisoft Turbo Basic CPC.png (400.58 Kio) Consulté 711 fois

Basic keywords CPC.png (161.59 Kio) Consulté 724 fois

[Papy.G]

Mais cela signifie : stocker cette adresse au début de la ligne, puis la récupérer à chaque lecture et la comparer avec l'adresse courante. Avoir un zéro en marqueur de fin, c'est juste vérifier que l'octet qu'on vient de lire (et qu'on doit de toute façon lire) est égal à zéro. C'est nettement plus rapide.

On peut aussi juste calculer l'offset pour la fin de ligne et décompter jusqu'au dernier à lire, à moins qu'une instruction JNZ ou équivalent n'existe pas sur le processeur?
Peut-être aussi que la comparaison d'adresse n'est faite qu'à l'encontre d'un 0.

Heuresement que cette façon de stocker du binaire n'est pas fréquente (car un simple octet à 0 dans le binaire marquerait une fausse fin au commentaire)

Pas si le 0 sert à déclencher la correspondance avec la fin de ligne.

Il y a quand même une phrase où j'ai sourit : "Un petit compilateur pour compiler un petit programme".
Comme si la taille du compilateur dépendait de la taille du programme

En réduisant le jeu d'instruction, il y a moyen. Si tu ne compiles que Print, List, et Goto.

Petit conseil pour les futurs débutants qui posteront leur idées sur ce forum sans même savoir si elles sont réalisables :

Ne vous laissez pas décourager par les médisants, ouvrez votre parapluie et laissez glisser les critiques et moqueries : amusez-vous.
Comme on dit aux Etats-Unis : si vous échouez ce n'est pas grave, vous aurez toujours appris quelque chose.

J'ai rejoint ce forum avec un projet en tête (voir mon sujet de présentation), qui s'est avéré bien trop ambitieux à des égards, et qui s'est finalement perdu dans les limbes, pour diverses raisons.
Effectivement, tu apprendras probablement à minima, mais tâches de ne pas être méprisant avec les personnes qui viennent ici, on voir venir régulièrement ds nouveaux membres avec des projets pharaoniques qui n'aboutissent pas, beaucoup ne restent pas à long terme, et cela se passe parfois assez mal.

Dans quelle mesure, un compilateur "idiot" peut améliorer les performances d'un programme BASIC, je me garderais de m'y prononcer.

Tu auras un gain sur l'interprétation, et sur la rapidité des boucles, princialement.

Voyons si je peux coder un PONG en BASIC et le compiler. C'est moi qui écrit le BASIC donc j'évite tout truc tarabiscoté ou nombre flottants.

Finalement, faire les routines soft de gestion de sprites en LM serait déjà moins ardu que partir sur un compilateur BASIC, et pourtant, je ne dis pas que la gestion de sprites sur cette machine ne soit facile à programmer.

Je compile les VRAIES instructions BASIC comme "CLS" en les transformant en JSR $FBD4 (en langage machine bien-sûr)

Ah, mais non, tu ne compiles pas from scratch, tu appelles les routines du BASIC en ROM!
Ce n'est pas plus mal, pour débuter, ton code "compilé" prend moins de place, et c'est plus accessible à faire.

Je vais suivre ton conseil et ne m'occuper que des vraies instructions BASIC et essayer d'aller au delà de simples PRINT.

Tu pourrais peut-être t'inspirer des routines d'interprétation du BASIC résident, voire même en appeler des portions.

Si t'as suivi, je génère du langage machine depuis le BASIC, puis je génère du BASIC depuis ce même langage machine généré !!
Ce qui fait de moi un psychopathe
Je peux aussi générer ces lignes BASIC de DATA depuis le programme BASIC lui même qui va faire des POKE et s'agrandir lui-même.
Un programme qui programme ! Un genre de mutant quoi ! [/b]

Il va falloir que tu passes au Forth très vite, ça va te plaire!

Si tu remplaces chaque instruction basic par le code machine de ce qui est exécuté quand l'instruction est exécutée, alors tu vas obtenir un programme en langage machine qui sera 10-20 fois plus gros que le programme basic et qui ne sera pas plus rapide étant donné que le code machine exécuté sera le même.

Je pense qu'il y a moyen d'être à peine plus volumineux, et plus rapide, mais pas 50x.

…pas tellement aux instructions textes/graphiques qui appellent les mêmes fonctions langage machine que le BASIC.

Attention, sur cette machine, on ajoute aussi les instructions propres au VDP à lui transmettre.

[David.G]

"on voir venir régulièrement ds nouveaux membres avec des projets pharaoniques qui n'aboutissent pas"

@Papy.G

Je suis débutant et BASIC et débutant en langage machine, donc c'est un défi intellectuel, j'essaie de faire ce que je peux,
et sur ce point, que j'y parvienne ou pas n' aucune espèce d'importance, car je n'ai de compte à rendre à personne et ce n'est pas un projet exigé par mon employeur que je sache.

Et j'ai déjà beaucoup appris de _Sam_ qui enseigne ici des choses vraiment très intéressantes et pousse le challenge, ce qui est génial.
Il explique vraiment ce qu'est un compilateur et j'étais loin d'en savoir autant. Passionnant.

D'autres personnes comme Zébulon et d'autres apportent également des informations très intéressantes.

Nous parlons ici d'informatique complexe et les réponses sont très intéressantes. J'ai pour ma part appris beacoup.

Les personnes qui continuent à me dire "fais attention tu t'attaques à un truc que tu ne réussiras pas à coder" n'ont rien compris à ma démarche :

J'essaie de créer un compilateur pour Alice90 (selon mes compétences de débutant) et que j'y parvienne ou pas n'a aucune importance :

Car j'aurai réussi à apprendre le langage machine et l'Alice de façon très avancée. Inutile de me dire fais ceci ou fais cela : JE FAIS CE QUE JE VEUX.

Voilà, merci à tous d'éviter de me répéter 100 fois la même chose,

relisez cette réponse ici et si vous ne la comprenez toujours pas, je ne peux rien pour vous.

[Daniel]

Il n'est pas choquant de chercher à programmer un compilateur Basic. Par contre il est choquant d'écrire des inepties en public dans un forum "sérieux".
Il y a beaucoup de lecteurs. Ils vont être désorientés par ce fil de discussion, et la réputation de forum "sérieux" va beaucoup en souffrir.

Programme ton compilateur sans trop te vanter, et quand il sera au point tu nous le présenteras. Aujourd'hui il y a six pages de messages et pas une ligne de compilateur. Il vaudrait mieux l'inverse. Nous pouvons t'aider au besoin, mais épargne nous les discours sans fin.

[__sam__]

On voit tout de suite que tu pars d'un nombre impair mais que le STEP est une incrémentation de 2.

Donc si tu pars de 1 et que tu essaies d'atteindre 10 en ajoutant 2 à chaque fois, on ne peut pas car tu ne peux atteindre que 9, puis 11.

Je vais regarder comment réagit le BASIC Alice avec ce programme déjà. S'enlise t-il dans une boucle infinie ? On va voir.

Je me suis amusé à le transposer en Javascript et ça fait carrément planter le site de W3chools !! MDR

Tu as utilisé l'opérateur d'affectation et pas d'égalité je crois (note: je connais pas JS plus que ca, mais en général l'égalité se note "==" voir "===").

Ensuite comme tu l'as remarqué, même avec le bon opérateur on ne peut atteindre la valeur 10, mais ca ne plantera pas le basic pour autant car tel n'est pas la sémantique des boucles FOR en basic. La sémantique serait plutôt un truc genre

Code : Tout sélectionner

let i = 1; while(i <= 10) { ... i = i + 2; }"

Le truc c'est que ca ne marche pas avec un STEP negatif (il faut faire "i >= fin" si STEP est négatif). Si tu connais le signe du STEP au moment de la compilation, peux peux décider quel opérateur de comparaison utiliser "<=" ou ">=". Mais ce n'est pas toujours le cas puisqu'on peut passer une variable comme STEP. Quel est donc le cas général qui fait que le basic accepte les STEPs négatifs ou positif sans atteindre nécessairement la valeur de fin ?

Je vais trahir un secret. Le cas général est

Code : Tout sélectionner

while( (increment>=0 and i<=fin) or (increment<0 and i>=fin) ) { ... i = i + increment }

Oui c'est clairement pas le while(i<=10) auquel on s'attendait. Zut! Mais du coup ca explique pourquoi le basic est lent sur les boucle. Ouais mais c'est aussi sur ce cas général que l'OPTIMISEUR intervient, plus précisément lors de la simplification de l'arbre syntaxique (j'ai déjà parlé de l'arbre syntaxique dans les pages précédentes. Ce n'était pas sans raisons).

Par exemple ici incrément est la constante 2. Donc le test "incrément>=0" peut être replacé par "2>=0" qui ne mets en jeux que des constantes et qui s'évalue à "vrai" dans l'arbre syntaxique. Ensuite dans cet arbre on voit que "vrai AND <machin>" peut être remplacé par juste "<machin>". Similairement le test à "<0" est forcément faux, et dont "faux AND <bidule>" se réduit à faux. On se retrouve alors à avoir "<machin> OR faux", qui s'optimise à sont tour en juste "<machin>". Bref les optimisations au niveau de l'arbre syntaxique te font passer d'une grosse expression générale à un au truc aussi simple et rapide que "while(i <= 10) {... i=i+2}" auquel on s'attendais, et cela sans cas particuliers, juste à partir du cas général.

Tu vois là que l'optimisation joue un grand role pour avoir du code efficace. Cependant savoir gérer le cas général, même sans optimisation, avant les cas particuliers et optimisations est une étape dans la création d'un compilateur.

[kirion]

Aujourd'hui il y a six pages de messages et pas une ligne de compilateur. Il vaudrait mieux l'inverse.

sauf si c'est le but, le discours sans fin, et que le compilateur n'est que le moyen pour y arriver...

[Daniel]

Discours sans fin, comme dans les réseaux sociaux

[David.G]

Tu ne veux pas essayer de voir ce que donnerait le programme suivant ?

Code : Tout sélectionner

10 CLS
20 PRINT "Quel est votre nom ? ";
30 INPUT NOM$: REM INTERACTION
40 HELLO$ = "Hello " + NOM$: REM CALCUL
50 PRINT HELLO$: REM AFFICHAGE RESULTAT
60 END

Il faudrait déjà voir si on arrive à compiler autre chose qu'une série de PRINT. Par exemple mon petit programme ci-dessus.

OK. Ma routine en langage machine doit :

- effacer l'écran ($FBD4)
- récupérer une entrée clavier (je cherche comment on fait ça en assembleur) et la stocker
- stocker la valeur de HELLO$ (string)
- Concaténer les 2 string (NOM$ + HELLO$) et le stocker
- afficher le résultat ($E7A8)

A ce stade elle doit être exécutable, ce qui me fait plusieurs programmes en langage machine en mémoire en même temps.

Pour la sauvegarder, je vais créer un programme BASIC qui récupère le code machine et s'ajoute a lui-même de lignes BASIC de DATA
(Pour ne pas avoir 3 programmes en langage machine qui tourne en mémoire, trop compliqué pour moi à ce stade)
Le programme BASIC s'auto POKERA les nouvelles lignes de BASIC token DATA et ajoutera les nombres,
et je pourrai faire un CSAVE. Cela devrait fonctionner en théorie.

Je ne connais que quelques mnémoniques d'assembleur, donc je prends mon temps mais c'est faisable.

Je vais ensuite essayer de faire tes 2 autres programmes BASIC proposés, puis j'attaquerai un PONG.

D'abord une simple raquette qu'on bouge au clavier, puis ensuite la balle.

Il me faudra donc le faire en BASIC puis le compiler et l'exécuter.

[__sam__]

Avant de réfléchir à la sauvegarde et plus loin encore, il faut déjà réfléchir à comment représenter les chaines de caractères (nul-terminated ou alors avec la longueur séparée, quelle taille max pour les chaines, ainsi que où est son buffer en mémoire), comment les manipuler, comment les allouer, etc. C'est tout le but de cet exemple: traiter les chaines comme un objet de première classe (entre autre elles peuvent exister sans être attachées à une variable, comme par exemple le résultat de HELLO$+NOM$ qui n'est assigné à une variable que dans un second temps).