>Depuis ce temps là j'attends la prochaine version de genalib, qui faisait passer le temps de compilation de 40 secondes à 1 seconde, pour le releaser.
Tu te moquerais pas du monde la ? Tu veux que je le release a ta place ?
geogeo
:Et tu m'expliques où est la différence avec une chaîne dans ce que tu racontes ?
Lol le comportement d'une chaîne est très différente du comportement d'un nombre, donc le descripteur est différent...
(je dis pas qu'il n'y a pas de différence dans ton implémentation, au contraire, mais je dis qu'il n'y a aucune différence entre les besoins d'une chaîne et les besoins d'un tableau : on n'a pas moins besoin de concaténer 2 tableaux que de concaténer deux chaînes -- je comprends pas trop pourquoi tu autorises la concaténation pour les chaînes, et pas pour les tableaux...)
On dirait un changement de sujet.
Lol bah fallait me le dire plutôt. Donc pour toi la concaténation de nombres est identique à la concanétation de tableaux?
Premièrement le GFA-Basic n'a jamais supporté ça, deuxièmement j'y ai jamais pensé et j'en voit pas l'utilité et troisièmement c'est possible à faire genre A()+B(). D'ailleur je crois que le TI-Basic supporte la concaténation de listes.
Pour finir je recommence sur la différence entre chaîne, tableaux et tableau de chaînes. Quant on a un tableau numérique, le but est d'accéder facilement à une valeur, pour ça c'est simple, on calcule l'adresse ou se trouve la valeur et on modiifie le contenu si necessaire. Pour une chaîne c'est autre chose, il faut parcourir le descripteur pour connaitre sa taille, récupérer une adresse à partir du numéro du handle et après faire les opérations necessaires.
)
Une chose que je ne comprend pas, vous en demandez toujours plus comme concaténer des tableaux... alors qu'il y a bien des choses plus importantes à faire avant. Surtout que cette possibilité est peu utilisée et surtout est implantable facilement lorsque mon format de variables et tableaux sera clairement défini.
Voici la première bêta de GFA-Basic avec le nouveeau moteur d'exécution des tokens GFA-TEM, elle ne fonctionne que pour les TI92+/V200. les TI89/TI89T sont supportées mais les touches ne sont pas gérées. Donc mieux vaut tester sur VTI.
Pour la tester il vous suffit d'envoyer tous les fichiers qui se trouvent dans le dossier bin de GFA-Basic et de GFA-TEM, ensuite envoyez un fichier du dossier démo soit sierpins ou carre3d et lancez sur votre TI. gfaexec("nom_du_prog")
Il y a 4 étapes de réalisés, c'est pour cela que s'est un peu long des fois.
[*]La tokenisation d'expressions, création du fichiers tokens.
[*]La détokenisation, création du fichier untokens.
[*]Le tokeniseur qui réalise un fichier contenant des tokens d'exécution utilisables par GFA-TEM. Création du fichier tokensbuf.
[*]Execution de tokensbuf avec GFA-TEM.
A noter que lorsqu'une erreur se produit, GFA-TEM est quand même exécuté car tout simplement gfaexec est un programme en TI-Basic qui appel GFA-BASIC et GFA-TEM. A noter que pour quitter un programme il faut appuyer sur ESC. Quand GFA TEM produit une erreur, rien n'est affiché sauf lorsque l'on quitte le programme avec ESC.
Vous trouverez une liste de tout ce qui est a été programmé dans beta.txt. Si vous essayez d'exécuter une fonction qui n'a pas été programmée comme End par exemple vous risquez de planter votre machine!
Cette version beta est très légère, elle ne gère pas encore les chaînes de caractères, le clavier et encore moins les sprites alors soyez indulgent.
Si vous constatez un bug postez le ici de préférence avec le code que vous avez tapé et les manipulations que vous avez effectuées.
Si vous avez des doutes sur l'utlisation d'une structure ou d'une fonction, n'hésitez pas à lire le manuel des fonctions.
Et enfin si vous pensez qu'il y a des optimisations à faire pour GFA TEM, n'hésitez pas aussi!
Dernière version du projet (je le diffuse car je compte reprendre le développement du portail de Ti-Gen et comme je ne peux pas tout faire en même temps, GFA Basic sera un peu en pause).
Cette version supporte tous les modèles de calculatrice, TI92+/TI89/TI89T & V200.
Donc comme d'habitude, envoyez tous les fichiers se trouvant dans le dossier GFA-Basic/bin et dans le dossier GFA-TEM/bin sur votre TI, ensuite envoyer une démo par exemple ce situant dans le dossier démo puis exécuter un programme en tapant gfaexec("nom_du_prog")
GFA-Basic va créer un fichier tokens.bas contenant votre programme au format GFA-Basic, tokenbuf.gtk au format langage bas niveau pour GFA-TEM et untoken.text contenant le code source de votre programme mais auto-indenté... obtenu à partir du fichier tokens.bas.
Les nouveaux sont assez importantes dans cette bêta comme le support des chaînes de caractères sans trop de restrictions (reste la pile qui a une taille limitée de 1 Ko donc faut pas abuser des grosses chaînes de caractères!!!), elle supporte les tableaux de tous les types même chaînes de caractères, elle supporte la concanétation de chaînes, les constantes (HW_VERSION, CALCULATOR, AMS_2XX, RR_LEFT, LCD_WIDTH... (voir la table des constantes dans les sources ou dans le topic sur le format d'un fichier BAS ou même dans TIGCC). Cette bêa supporte aussi le signe racine carré et exponentielle de la TI. Bref beaucoups de nouveautés très interessante.
A noter qu'un programme quitte tout seul dans demander d'appuyer sur une touche donc le mieux et d'écrire ces 2 lignes à la fin de chaque programme.
[code]
repeat
until getkey
[/code]
Voici la liste des fonctions développées et des possibilités du langage:
Evolution du projet. Et TODO:
-----------------------------
- Gestion des nombres (flottants, entiers).
- Gestion des variables numériques (flottants, entiers, booléens).
- Gestion du transtypage dynamique.
- Gestion de l'affectation.
- Gestion des opérateurs méthématiques:
Additon = +
Soustraction = -
Multiplication = *
Division = /
Division entière = \ ou Div
Puissance = ^
Modulo = Mod
- Gestion des opérateurs de comparaisons:
Egal = =
Supérieur = >
Inférieur = <
Supérieur ou égal = >= ou signe TI
Inférieur ou égal = <= ou signe TI
Différent = <> ou signe TI
- Gestion des opérateurs logiques:
NON logique = Not
ET logique = And
OU Inclusif = Or
OU Exclusif = Xor
Implication = Imp
Equivalence = Eqv
- Gestion de la négation numérique soit (-).
- Gestion des structures:
Goto Label
Do ... Loop
While ... Wend
Repeat ... Until
If ... [Then] ... ElseIf ... [Then] ... Else ... Endif
For ... [To][DownTo] ... Next
For ... To ... Step ... Next
- Gestion de Exit [If] pour quitter une structure précédente sauf structure If et Goto Label.
- Gestion des opérateurs arithmétiques optimisés:
Add, Sub, Mul, Div, Inc et Dec.
- Gestion des constantes:
TRUE
FALSE
PI
- Gestion du signe puissance de dix et Pi de la TI.
- Gestion des commentaires en début de ligne avec ' et en milieu de ligne avec !
- Gestion des nombres en binaire, hexadécimal ou en octal avec &X, &H et &O réciproquement.
- Possibilité de forcer un entier à être un flottant en ajoutant un point à la fin de ce nombre comme par exemple 52. ou 52.0
- Gestion complète de Print et Print At avec la possibilité d'utiliser , ou ; ou ' pour séparer des données. (les chaînes de caractères ne sont pas gérées).
- Autoindentation pour le détokeniseur.
- Possibilité d'utiliser - comme négation (-) ainsi A=A*-3 est possible!
- Possibilité de taper Else If à la place de Elseif.
- Apostrophes côte à côte autorisées Genre Print 25''52.
- Supporte les tableaux de flottants, d'entiers et de booléeans.
- Lecture d'une chaîne de caractères et affichage avec Print.
- Gestion des variables de type chaînes de caractères.
- Gestion des tableaux de chaînes de caractères.
- Concanétation de chaînes de caractères. Opérateur +, fonctionne avec les variables et les tableaux.
- Opérateurs de comparaisons avec les chaînes de caractères. (<, >, <=, >=, <>, =).
- Supporte les signes mathématiques de la TI soit PI, exponentielle de 1 (e), fonction exponentielle 'e^(' et la racine carrée.
- Supporte les constantes du type (CALCULATOR, HW_VERSION, LCD_xxx, AMSx_xx, RR_xxx, KEY_xxx...).
Une instruction de commandes est la première instruction d'une ligne.
Une instruction de fonctions est une instruction qui se trouve n'importe où sur une ligne et qui retourne une valeur.
Liste des instructions de commandes:
====================================
Print [,|;|'][data]= Affichage de données.
Print At(x,y)[,|;|'][data] = Affichage de données à des coordonnées précises.
Cls = Efface l'écran et positionne à 0,0 le curseur de texte pour Print.
Add var,x = Ajoute x à var soit var=var+x.
Sub var,x = Soustrait x à var soit var=var-x.
Mul var,x = Multiplie x à var soit var=var*x
Div var,x = Divise var par x soit var=var/x.
Inc x = Incrémente x de 1 soit x=x+1.
Dec x = Décremente x de 1 soit x=x-1.
Plot x,y = Affiche un point clippé au coordonnées x et y.
Line x0,y0,x1,y1 = Dessine une ligne clippée de coordonnées x0,y0 et x1,y1.
Dim tab(x[,x...])[,tab(x[,x...])...] = Dimensionne et déclare un tableau.
Box x0,y0,x1,y1 = Dessine un rectangle vide clippé de coordonnées x0,y0 à x1,y1.
Liste des instructions de fonctions:
====================================
Abs(x) = Valeur absolue de x.
Cos(x) = Cosinus de x.
Sin(x) = Sinus de x.
Rnd[()] = Retourne un nombre aléatoire compris entre 0 et 1.
Random(x) = Retourne un nombre aléatoire compris entre 0 et x-1.
Timer[()] = Retourne le temps écoulé depuis l'exécution du programme. Ce temps est donné en 1/200 de secondes.
Getkey[()] = Retourne la combinaison de touche pressées.
Atn(x) = Retourne l'arctangente de x.
Even(x) = Détermine la parité de x (paire).
Odd(x) = Détermine la parité de x (impaire).
Sgn(x) = Détermine le signe de x (0, si x=0; +1, si x>0; -1, si x<0).
Tan(x) = Calcule la tangente de x.
Log(x) = Calcule le logarithme népérien de x.
Log10(x) = Calcule le logarithme décimal (base 10) de x. Log10(x)=Log(x)/Log(10).
Sqr(x) = Calcule la racine carrée de x. Sqr(x)=x^(1/2).
Exp(x) = Calcule l'exponentielle de x (e^x e=2.7182818285).
Fix(x) = Récupère la partie entière de x.
Frac(x) = Récupère la partie décimale de x. Frac(52.36)=0.36.
Round(x) = Arrondie le nombre x. (Risque d'erreur avec des nombres supérieurs à 2 milliars en valeur absolue).
Asc(x$) = Retourne le code ASCII du premier caractère de la chaîne x$.
Bin$(x) = Convertit la valeur x en une chaîne de caractères représentant l'écriture binaire de x.
Hex$(x) = Convertit la valeur x en une chaîne de caractères représentant l'écriture hexadécimal de x.
Oct$(x) = Convertit la valeur x en une chaîne de caractères représentant l'écriture octale de x.
Chr$(x) = Retourne le caractère dont le code ASCII est x.
Len(x$) = Calcule la longueur de la chaîne de caractères x$.
Voilà j'espère que vous testerez rapidement cette version et que vous aurez le courage de développer de petits softs (avec les fonctions de tracées de base...).
.
nitro
:geogeo
: Dommage qu'aucun interpréteur OnCalc n'est sorti ou est en version bêta.
Il y a 3 ans (en fin 2001 si je ne me trompe pas), j'ai porté Small sur TI, spécialement pour genlib. Le compilateur était gros et lent (allocations AMS), mais la machine virtuelle était resonnablement petite, et suffisamment rapide pour faire de bons jeux temps réel. Technic avait fait un début de X-men (jeu de plateforme) avec.
Depuis ce temps là j'attends la prochaine version de genalib, qui faisait passer le temps de compilation de 40 secondes à 1 seconde, pour le releaser.
