MyLib va devenr un Interpreteur - Page 1

Voilà, j'ai décidé de faire de MyLiB un iterperteur. Je ne suis pas en info, je voudrai votre avis sur certaines modifications imminentes . Bien sur l'objectif principale reste avant tout la vitesse mais je dois aussi eviter de gaspiller de l'espace mémoire.

- Gestion des Variables : (le code existe déjà dans MyLib)
[cite]

- Gestion des Argument de Type ENTIER,FLOAT,STRING dans la pile.
- J'abandonne la gestion de LISTE et MATRIX TI-Basic dans la pile au détriment d'une structure C.
Il aura un gain considérable en vitesse .
- Je garde la possibilité de chargé le contenu d'une LISTE ou MATRIX dans une Structure.
Seul cette fonctions gerera les LISTE ou MATRIX
- J'offre la Possibilité de Retourner convertir une Structure au format TI-Basic Equivalent
[\cite]

STRUCTURE d'ARGUMENTS

*** { int num; float dec; char * str ; short type } ARG;
*** { union { int num; float dec; char * str ; } var; short type } ARG;

celle avec l'union prend moins d'espace.
en terme de vitesse pour l'union , il y a juste un (cast) à faire pour lire la donnée.
ça devrait pas trop ralentir je pense.

Gestion des ARGUMENTS

Je conserve la même gestion des arguments que MyLiB : (
*** passage d'arguments Simple ou de type Tableau à une fonction
*** utilisation des Tag Spéciaux pour étendre les combinaison

à la place des LISTES/MATRICE , il devra y avoir le nom d'une variable car j'ai pécisé que les LISTE/MATRIX devront être chargé dans une structure avant utilisation

Voilà, j'ai décidé de faire de MyLiB un iterperteur. Je ne suis pas en info, je voudrai votre avis sur certaines modifications imminentes . Bien sur l'objectif principale reste avant tout la vitesse mais je dois aussi eviter de gaspiller de l'espace mémoire.

- Gestion des Variables : (le code existe déjà dans MyLib)

- Gestion des Argument de Type ENTIER,FLOAT,STRING dans la pile.
- J'abandonne la gestion de LISTE et MATRIX TI-Basic dans la pile au détriment d'une structure C.
Il aura un gain considérable en vitesse .
- Je garde la possibilité de chargé le contenu d'une LISTE ou MATRIX dans une Structure.
Seul cette fonctions gerera les LISTE ou MATRIX
- J'offre la Possibilité de Retourner convertir une Structure au format TI-Basic Equivalent

STRUCTURE d'ARGUMENTS

*** { int num; float dec; char * str ; short type } ARG;
*** { union { int num; float dec; char * str ; } var; short type } ARG;

celle avec l'union prend moins d'espace.
en terme de vitesse pour l'union , il y a juste un (cast) à faire pour lire la donnée.
ça devrait pas trop ralentir je pense.

Gestion des ARGUMENTS

Je conserve la même gestion des arguments que MyLiB : (
*** passage d'arguments Simple ou de type Tableau à une fonction
*** utilisation des Tag Spéciaux pour étendre les combinaison

Gestion de la VAT des STRUCTURES de Variable.

Je compte utiliser en réalité des Nombres en lieu et place des noms de variables.
je ferai la substition des noms de variable par des nombres à partir
d'une Table qui attribuera à chaque nom de variable un numéro de structure.

Au Sujet des Structures de contrôle

je ne vois que la solution suivante pour rechercher et définir les Offset de Saut :
- Après Parsing et Tokénéisation.
Reférencé les adresses des instructions de saut
Référencer les adresses des étiquettes de saut
Fait la substitution des instructions de saut par une nouvelle Instruction
'Jump', MoveOffSet de sorte qu'il se positionne sur l'étiquette de saut


J'avoue c'est encore un peu flou , car il va falloir parcourir plusieur fois le fichier
puisque chaque substitution change la taille du fichier.

Gestion de la VAT des STRUCTURES de Variable.

Je compte utiliser en réalité des Nombres en lieu et place des noms de variables.
je ferai la substition des noms de variable par des nombres à partir
d'une Table qui attribuera à chaque nom de variable un numéro de structure.

Au fait ça va faire 3 jours que j'ai commencé le parser.
Il est quasi finit puisqu'il ne me reste plus qu'à vérifier que la syntaxe des constantes ( Nom de variable, chaine, entier, double, liste, matrix )est correcte

voici les opérateurs supportée :
[cite]
2-Les opérateurs du language
----------------------------

Priorité décroissante par ligne
_______________________________
12 () []
11 ! (-) ++ --
10 ^
9 * / %
8 + - &
7 < <= > >=
6 == !=
5 &&
4 ||
3 = ^= *= /= %= += -=
2 ,
_______________________________

[\cite]

Non , il ne reste pas grand chose.
Le code d'exécution donc l'interpeteur est en tout point celui de mylib.
Au contraire vu que je supprime la gestion des liste en argument, ça simplifie les choses.

Je garde exactement les même structures de gestion des arguments.
le seul truc qui me fatigue un peu c'est la gestion des Offsets des structures de contrôle.

là j'aurai bien besoin de quelque éclaircissement pour me faciliter la tache.
C'est sur , je trouverai , bien tout seul comment faire, mais j'aimerai bien boucler
pour la fin semaine.
- Le parser et le Tokénéiseur sont quasi fini ( manque les offset de jump )
- l'interperteur est celui de MyLiB


je conserve le format PICT de TI pour les Sprites et Les Mapes.

je ne vois que la solution suivante pour rechercher et définir les Offset de Saut :
- Après Parsing et Tokénéisation.
Reférencé les adresses des instructions de saut
Référencer les adresses des étiquettes de saut
Fait la substitution des instructions de saut par une nouvelle Instruction
'Jump', MoveOffSet de sorte qu'il se positionne sur l'étiquette de saut


J'avoue c'est encore un peu flou , car il va falloir parcourir plusieur fois le fichier puisque chaque substitution change la taille du fichier.

Pour ma part je fais tout dans la phase de tokenisation et ce en une seule et unique passe.

Bon finallement , je vais me tenir au variable TI-Basic uniquement.


-> Martial Demolin , T'a raison , à force ça va devenir un Vapoware.
Alors tant qu'à faire vite, je vais Tokénéisé au même format que MyLib.

-> Ok geogeo, je vais reflechir à ce que tu dit.

je suppose que tu commences par la fin du fichier.
quelqu'un m'avait conseiller d'utiliser des offest directement en les passant à une fonction
qui se chargera de déplacer le pointeur à l'intérieur du code.
C'est intéressant mais très fastudieux.
Dans MyLiB j'utilisais un truc tellement pourri que ça ramait grave pour les Goto situé avant le Label. Je recherchait carrément le Label manuellement pour le référencer dans une table.

je crois que je vais stocker la table des JUMP à la fin du code source.
comme cela je suis tranquille. je la fait genre Tableau Statique avec Index pour retrouver la position des labels.

je suis fatigué je vais au dodo.
Pas de codage aujourd'hui.

je suppose que tu commences par la fin du fichier.
quelqu'un m'avait conseiller d'utiliser des offest directement en les passant à une fonction
qui se chargera de déplacer le pointeur à l'intérieur du code.
C'est intéressant mais très fastudieux. Dans MyLiB j'utilisais un truc tellement pourri que ça ramait grave pour les Goto situé avant le Label. Je recherchait carrément le Label manuellement pour le référencer dans une table.

Non je commence la lecture au début!

Ce qui se passe c'est qu'à la rencontre d'un goto dont je ne peux effectuer l'écriture du saut car inconnu je stocke l'offset d'écriture dans une sorte de pile avec le numéro du label ensuite à la fin de la tokenisation, je dépile la pile pour écrire les bonnes offsets. C'est assez rapide et ça ne bouffe rien en mémoire, c'est vraiment minime. De plus il faut noter que je fais pareil pour les procédures...

c'est moi, ou ./1 est pas un modele de lisibilité

-> Pollux : ça y c'est lisible

-> geogeo
en fait ça me pose un petit problème avec le format des short du TIOS car la taille est variable.
Alors qu'en C les short ont la même taille.
Ce que je vais faire c'est tester si je peux modifier la structure des shorts pour rendre invariable le nombre de byte utilisé, et surtout pouvoir lire la bonne valeur lorsque je retire la valeur de l'ESTACK de la TI.

Si ce hack marche, je pourrai faire comme tu as dit.

Pour les structures de contrôle suivante, je compte les remplacer par des Label , If(), Goto
while() EndWhile
Loop Until()

j'hésite pour le for, mais je pense que je vais faire pareil
d'ailleur peut-être que je vais remplacer les If() Then par des Label-Goto

Comme cela je n'aurais qu'à implémenter Label Goto uniquement ; toutes les autres structures de contrôle seront des syntaxes de remplacement plus agréable pour le codeur.


Allez je vais me pencher sur tout ça

Moi j'ai que 3 tokens de bases pour gérer toutes les structures (Repeat...Until, Do...Loop). Token_IF, Token_IFJump, Token_Jump. Bref c'est une sorte de langage bas niveau. Sinon pour For c'est un peu plus complexe car c'est surtout optimisé en vitesse!

Beurk... Ya pas pire moyen d'avoir un truc non optimisé :/ Eventuellement un même token de fin pour toutes les boucles, mais jamais ça... En plus ça rend le code non facilement décompilable
Un flux de token n'est pas un flux d'instructions élémentaires, et ne devrait jamais être considéré comme tel.

Donc Omikron, GFA-Basic, X11 sont des langages merdiques peu optimisés

Ok , je vais faire comme il faut.
J'ai jeté un oeil avec l'editeur hexa sur les structures de controle du TI BASIC.
je vais donc faire 1 token pour chaque instruction

IF_TAG
IF_THEN_TAG
ELSE_TAG
END_IF_TAG

WHILE_TAG
END_WHILE_TAG

FOR_TAG
END_FOR

LOOP_UNTIL_TAG
END_LOOP_TAG


faut dire que je pense pas trop au détokénéiseur pour l'instant, mais c'est pas une raison pour ne pas faire en sorte qu'un jour je puisse le faire correctement ( dans quelques années ... )

geogeo :
Donc Omikron, GFA-Basic, X11 sont des langages merdiques peu optimisés

Omikron, connais pô, et X11 je vois pas ce qu'il veint afire là A moins que X soit un language de programmation #trihum#
Quand à GFA, je n'en doute pas Particulièrement celui qui se base sur un éxécutable de 50 Ko (...)
Après, si ça fonctionne comme ça, j'immagine bien que ce sont des languages mal optimisées... Sachant qu'un If-Then prend déjà au minimum un token et qu'ensuite il faut appeller un Goto qui fait aussi un token, ça fait bien un token de plus a éxécuter a chaque itération de la boucle... (Oui, parce que si tu structures bien ton flux de tokens, une boucle ça se résume a un token de début et un token de fin plus les conditions de boucle qui sont les mêmes que pour un if... Après reste juste a optimiser ton format pour l'éxécution )

C'est vraiement chiant à finir ce genre de projet, là je peut dire que je commence à fatiguer.
ça fait 2 jours que j'ai rien codé, je vais m'y remettre ce soir en essayant de suivre les conseils qui m'ont été gracieusement dispensés.

J'ai fait une distinction entre les LISTES/MATRIX statiques et dynamique.
Disons que par Statique j'entend une LISTE(MATRIX c'est pareil) ne contenant que des Nombres.
M'enfin disons qu'au départ, je ne voulais pas gérer les listes Dynamiques( qui contiennent des variables ou formules ).
- Les Listes Statiques sont traité comme des arguments au même titre qu'un entier ou une chaîne
- les Listes dynamiques sont éclatées dans la pile pour être évaluées et ensuite reconstituées par l'intermédiaire d'une fonction '2List' aynat pour argument DIM1 [,DIM2]

j'ai jete un oeil au If Then Else EndIf du TIOS, je ne vois que des TAG et pas d'Offset de JUMP.
Esct à dire que cette structure est géré sans OffSet de JUMP et que le TIOS fait une recherche Textuelle des TAG. Ce qui métonnerai d'ailleurs. Vous n'allez pas me dire que le TIOS les référence dans une structure au fur et à mésure !!!!
je suis perplexe.

GoldenCrystal
:

geogeo :
Donc Omikron, GFA-Basic, X11 sont des langages merdiques peu optimisés

Omikron, connais pô, et X11 je vois pas ce qu'il veint afire là A moins que X soit un language de programmation #trihum#
Quand à GFA, je n'en doute pas Particulièrement celui qui se base sur un éxécutable de 50 Ko (...)
Après, si ça fonctionne comme ça, j'immagine bien que ce sont des languages mal optimisées... Sachant qu'un If-Then prend déjà au minimum un token et qu'ensuite il faut appeller un Goto qui fait aussi un token, ça fait bien un token de plus a éxécuter a chaque itération de la boucle... (Oui, parce que si tu structures bien ton flux de tokens, une boucle ça se résume a un token de début et un token de fin plus les conditions de boucle qui sont les mêmes que pour un if... Après reste juste a optimiser ton format pour l'éxécution )

X11 est un langage de programmation basic.

Je pense que tu ne visualises pas le problème des structures de ce type comme par exemple la structure Repeat...Until ou certe on peut utiliser 2 tokens soit Repeat et Until mais ça fait seulement 1 token dans mon cas soit IfJump.

Ainsi à l'approche de Repeat l'adresse de jump est mémorisée et donc à Until on a:
seulement Token_IfJump. Donc au finale pour faire la boucle il n'y a qu'un token d'où la puissance des langages cités ci-dessus.

De même avec While Wend ou ok y a 2 tokens si tu prends While et Wend mais dans mon cas j'ai aussi 2 tokens soit:
Token_IfJump.
... code dans le While
Token_Jump.

Pour la structure FOR appliquer une comparaison dynamique est catastrophique au niveau des performances d'où la lenteur du TI-Basic par exemple.

D'ailleur je vais faire un détokeniseur me permettant de mieux analyser le flux de tokens et d'encore mieux optimiser et ainsi on pourra voir que tout est fait pour avoir le moins de tokens possible et une vitesse d'execution très interessante.

Il faut bien imaginer qu'arriver à interpréter le code suivant par exemple:

Cls
T%=Timer
Dim A%(10,10)
For I%=1 To 10
  For J%=1 To 10
    For K%=1 To 100
      A%(I%,J%)=K%
   Next
  Next
Next
Print (Timer-T%)/200
Repeat
Until RR_ESC

En moins de 3 secondes avec toutes les vérifications, trantypages que ça implique.

Omikron est un langage professionnelle et est le plus rapide sur Atari ST. Le code ci-dessus en Omikron s'execute en 2.5 secondes. GFA n'est pas loin soit 3.5 secondes.
Donc dire que s'est 2 langages ne sont pas optimisés

j'ai jete un oeil au If Then Else EndIf du TIOS, je ne vois que des TAG et pas d'Offset de JUMP.
Esct à dire que cette structure est géré sans OffSet de JUMP et que le TIOS fait une recherche Textuelle des TAG. Ce qui métonnerai d'ailleurs. Vous n'allez pas me dire que le TIOS les référence dans une structure au fur et à mésure !!!! je suis perplexe.

Le TIOS référence au fur et à mesure en utilisant sans doute une pile.

Ok , merci geogeo pour tout ces éclaircissement.
Je me remet au travail cet après-midi.

geogeo
: Je pense que tu ne visualises pas le problème des structures de ce type comme par exemple la structure Repeat...Until ou certe on peut utiliser 2 tokens soit Repeat et Until mais ça fait seulement 1 token dans mon cas soit IfJump.

Nanan, je visualise parfaitement... Moi aussi ça me donne un seul token, mais c'est décompilable en +, stou

Ainsi à l'approche de Repeat l'adresse de jump est mémorisée et donc à Until on a: seulement Token_IfJump. Donc au finale pour faire la boucle il n'y a qu'un token d'où la puissance des langages cités ci-dessus.

Hmm comme dit au dessus aucune différence avec ma méthode à par l'impossibilité de détokeniser.

De même avec While Wend ou ok y a 2 tokens si tu prends While et Wend mais dans mon cas j'ai aussi 2 tokens soit:
Token_IfJump.
... code dans le While Token_Jump.

Sauf que là c'est carrément non optimisé en vitesse d'éxécution Moi j'obtiens un token éxécuté à chaque boucle et pas deux

D'ailleur je vais faire un détokeniseur me permettant de mieux analyser le flux de tokens et d'encore mieux optimiser et ainsi on pourra voir que tout est fait pour avoir le moins de tokens possible et une vitesse d'execution très interessante.

Le nombre de tokens ne fait pas tout... Il y a aussi la structure du flux et la façon dont tu éxécutes les tokens.

Il faut bien imaginer qu'arriver à interpréter le code suivant par exemple:

Cls
T%=Timer
Dim A%(10,10)
For I%=1 To 10
  For J%=1 To 10
    For K%=1 To 100
      A%(I%,J%)=K%
   Next
  Next
Next
Print (Timer-T%)/200
Repeat
Until RR_ESC

En moins de 3 secondes avec toutes les vérifications, trantypages que ça implique.

Omikron est un langage professionnelle et est le plus rapide sur Atari ST. Le code ci-dessus en Omikron s'execute en 2.5 secondes. GFA n'est pas loin soit 3.5 secondes.
Donc dire que s'est 2 langages ne sont pas optimisés

Si je me souviens bien de ce que j'avais fait dans mon ébauche d'interpréteur... On a 10*10*100 = 10000, soit ~12000000 cycles sur 68k, donc environ 1 seconde (voire moins, mais j'irai pas vérifier, pke pas le temps) sur nos TI... En admettant que je ne me sois pas trompé, bah, euh :] Sur AtariST ça se comprend a la limite, avec un CPU moins rapide et bridé, mais maintenant sur TI... :]

Hmm comme dit au dessus aucune différence avec ma méthode à par l'impossibilité de détokeniser.

LOL, c'est exagéré de dire impossible quand cela est possible.

Sauf que là c'est carrément non optimisé en vitesse d'éxécution Moi j'obtiens un token éxécuté à chaque boucle et pas deux

Je parle de la boucle While...Wend.
La seule est unique solution d'avoir un token ici est de déplacer la condition c'est-à-dire la faire à la fin de la boucle mais se pose un problème pour la première itération.
Donc oui on peut optmiser mais non c'est impossible d'avoir un seul et unique token.
De plus en optimisant ainsi c'est encore plus difficile à détokeniser.
A moins que tu m'expliques comment avec un token tu arrives à gérer While...Wend par exemple!

Si je me souviens bien de ce que j'avais fait dans mon ébauche d'interpréteur... On a 10*10*100 = 10000, soit ~12000000 cycles sur 68k, donc environ 1 seconde (voire moins, mais j'irai pas vérifier, pke pas le temps) sur nos TI... En admettant que je ne me sois pas trompé, bah, euh :] Sur AtariST ça se comprend a la limite, avec un CPU moins rapide et bridé, mais maintenant sur TI... :]

Tu sors d'où ton nombre de cycles? En admettant que tu executes environ 100 instructions par itération pour faire le code ci-dessus avec interruptions et sauts compris bah sérieusement je dis que c'est impossible! Si c'est possible si pas de transtypage, pas de vérifications d'erreurs... (donc la définition du Basic tel que GFA-basic et Omikron n'est plus valide)!
Sur Atari ST le processeur fait 8 MHz contre 12 MHz sur TI, bref il est 1.5x plus lent mais cette perte est compensée par les interfaces autour que la TI n'a pas donc théoriquement le code ci-dessus devrait mettre moins de 2.5 secondes si c'est bien optmisé sur TI comparé à l'Omikron sur Atari ST. Maintenant en GFA Basic sur TI je met 2.2 secondes donc j'estime que c'est suffisant.

Mais je crois que tu n'as pas conscience de certaines choses, tu parles de façon théorique sans te fonder sur du concret.
Dire que l'Omikron n'est pas optimisé à mort c'est du n'importe quoi surtout sur une machine tel que l'Atari ST qui a prouvé que la plupart des logiciels étaient des prouesses en programmation!

[EDIT] Y a pas moyen de polluer le topic de GFA-Basic et non ce topic parce que ça doit pas être marrant pour andoh_wilfried de voir du troll!

Dire que l'Omikron n'est pas optimisé à mort c'est du n'importe quoi surtout sur une machine tel que l'Atari ST qui a prouvé que la plupart des logiciels étaient des prouesses en programmation!

(L'om-basic n'est pas une super référence en terme d'optimisation, en tous cas en taille mémoire je trouve qu'il a tendance à vraiment manger beaucoup de RAM pour souvent pas grand chose... après, j'avoue que je ne sais pas comment il tokenise - cela dit ça dépend aussi le la version d'OM-basic que l'on a sous la main ^^)

Oui mais moi je parle en terme de vitesse d'execution. (cas extrême). Après ok il peut être plus lent dans l'affichage d'un sprite... mais cela n'a rien à voir avec son architecture de tokens, le problème est alors la routine d'affichage de sprites.
Après il est clair qu'il faut un compromis en terme de vitesse d'execution et taille d'où pour moi GFA-Basic qui est une référence.

geogeo
:

Hmm comme dit au dessus aucune différence avec ma méthode à par l'impossibilité de détokeniser.

LOL, c'est exagéré de dire impossible quand cela est possible.

Bah alors comment tu fais ça sans surcharger le fichier tokenisé de métadonnées inutiles puisque tu pouvais mettre les informations directement dans le flux de tokens ?

Sauf que là c'est carrément non optimisé en vitesse d'éxécution Moi j'obtiens un token éxécuté à chaque boucle et pas deux

Je parle de la boucle While...Wend.

Oui et moi aussi...

La seule est unique solution d'avoir un token ici est de déplacer la condition c'est-à-dire la faire à la fin de la boucle mais se pose un problème pour la première itération.

Oui, c'est optimisable comme ça, et non ça ne te pose pas de problème pour l'initialisation.

Donc oui on peut optmiser mais non c'est impossible d'avoir un seul et unique token.

Bah je te parle pas d'avoir un seul et unique token, ce qui est impossible dans ce cas précis, mais d'avoir un seul token a éxécuter a chaque boucle...

De plus en optimisant ainsi c'est encore plus difficile à détokeniser.

Bien plus facile au contraire...

A moins que tu m'expliques comment avec un token tu arrives à gérer While...Wend par exemple!

^^

Si je me souviens bien de ce que j'avais fait dans mon ébauche d'interpréteur... On a 10*10*100 = 10000, soit ~12000000 cycles sur 68k, donc environ 1 seconde (voire moins, mais j'irai pas vérifier, pke pas le temps) sur nos TI... En admettant que je ne me sois pas trompé, bah, euh :] Sur AtariST ça se comprend a la limite, avec un CPU moins rapide et bridé, mais maintenant sur TI... :]

Tu sors d'où ton nombre de cycles?

Mon nombre de cycles je le sors d'une approximation grossière que j'ai faite en me souvenant de ma boucle d'éxécutions de tokens. En considérant 100 cycles maximum pour le fetch et les tests sur le token, plus environ 200 cycles par token, plus quelques autres cyles pour être sûr d'avoir pris bien large et de pas raconter trop de conneries, bah je trouve ça...

En admettant que tu executes environ 100 instructions par itération pour faire le code ci-dessus avec interruptions et sauts compris bah sérieusement je dis que c'est impossible!

Bah, hmm la boucle d'éxécution des tokens ça doit faire dans les 2à instructions, ensuite l'interprétation des tokens, unne petite moyenne de 150 instructions, parce qu'il faut quand même appeler les routines de gestion de la mémoire de temps en temps (mais rarement quand même)

Si c'est possible si pas de transtypage, pas de vérifications d'erreurs... (donc la définition du Basic tel que GFA-basic et Omikron n'est plus valide)!

Il n'y a aucun transtypage dans ton code. Un transtypage c'est une conversion de type. Dans ton code toutes les variable sont de type explicite integer, donc pas de conversion.

Sur Atari ST le processeur fait 8 MHz contre 12 MHz sur TI, bref il est 1.5x plus lent mais cette perte est compensée par les interfaces autour que la TI n'a pas donc théoriquement le code ci-dessus devrait mettre moins de 2.5 secondes si c'est bien optmisé sur TI comparé à l'Omikron sur Atari ST. Maintenant en GFA Basic sur TI je met 2.2 secondes donc j'estime que c'est suffisant.

En fréquence, oui le CPU de l'Atari St est 1.5x moins rapide, mais ce n'est pas tout. Je ne sais pas exactement comment le CPU fonctionne sur nos TI, mais il ya de fortes chances pour que le rapport de vitesse entre les deux soit supérieur a 1.5... Maintenant l'histoire d'interfaces je vois pas ce que tu veux dire... Si tu parles du matériel, peut-être que, dans certaines limites, .... Mais si c'est du logiciel, n'importe quoi. Donc en divisant 2.5 s par deux on obtient... tadaam 1.25, donc en visant large on peut estimer qu'une version équivalente sur TI devrait tourner en 1.5 secondes, ce n'est pas le cas de ton GFA-BASIC, il te reste encore pas mal de boulot

Mais je crois que tu n'as pas conscience de certaines choses, tu parles de façon théorique sans te fonder sur du concret.

Je parle pas de façon théorique, je parle de ce que je sais parce que j'y ai réfléchi, et parce que j'ai commencé a coder un interpréteur basic, stou...

Dire que l'Omikron n'est pas optimisé à mort c'est du n'importe quoi surtout sur une machine tel que l'Atari ST qui a prouvé que la plupart des logiciels étaient des prouesses en programmation!

Je sais pas ce qui est du n'impiorte quoi, mais selon moi ce petit paragraphe, c'est certainement un très bel exemple de n'importe quoi... Ce qui est n'importe quoi c'est de dire que quelque chose est optimisé a mort Optimiser ça se résume pas a remplacer une instruction par une autre plus rapide... Optimiser c'est un processus global qui concerne le programme dans son intégralité et je pense pas que ce soit la notion que tu aies en tête.

[EDIT] Y a pas moyen de polluer le topic de GFA-Basic et non ce topic parce que ça doit pas être marrant pour andoh_wilfried de voir du troll!

Sisi ya moyen mais j'aime pas remonter les vieux topics, fais le si tu veux

Mouais je crois que vous allez effectivement pouvoir continuer votre superbe troll ailleurs...

Bah, hmm la boucle d'éxécution des tokens ça doit faire dans les 2à instructions
, ensuite l'interprétation des tokens, unne petite moyenne de 150 instructions, parce qu'il faut quand même appeler les routines de gestion de la mémoire de temps en temps (mais rarement quand même)

C'est la chose la plus stupide que j'ai jamais entendue! 2 instructions, mais lol tu ne te rend même pas compte de ce que tu dis.
Et quand je parle de transtypage il y a quand même une vérification de types qui prend des instructions donc des cycles.
Ensuite si tu parles de 20 instructions, je vasi te rassurer tu peux diviser ce chiffre par 3 dans mon cas grossièrement!

il a écrit 2à, et si tu regarde ton clavier, tu remarqueras que 'à' est la même touche que 0

#25 > On va supposer que c'est un cross avec #24, mais à partir du prochain ça va devenir plus difficile à croire déjà

(Cela dit, c'est assez dommage. C'est effectivement hors sujet et un peu trollesque, mais pour une fois qu'on a un sujet intéressant dans cette section)

Rien ne les empeche d'en parler, mais pas ici...