J´ai besoin d´écrire un petit programme d´interprétation de scripts qui me permettrait d´automatiser certaines tâches.
J´aimerai créer un language assez basique supportant néanmoins l´utilisation de variables que l´on pourra définir au sein des scripts.
La question est : quelle est la meilleure facon de gérer ces variables lors de l´exécution ? Je pensais utiliser une liste chainée permettant de créer autant de nouvelles variables que l´on veut mais est ce la meilleure solution ?

Sinon concernant la gestion des messages windows : existe-il une fonction permettant de savoir si la liste des messages (qui ne sont pas encore traités) est pleine ?

(Je sais que je vais me faire jeter) pourquoi ne pas inclure un langage déjà existant genre Python ?

Hum, je pense pas que lag-it créer un langage pour réelement l´utiliser, mais plutôt pour le fun (´fin pour apprendre aussi, pour pleins de raisons! )

[Lockless] > En effet

Pour les variables, la liste chainée s´impose presque.

Ce que j´avais fait dans mon basic c´est que chaque fonction a une liste chainée à elle ce qui permet de détruire toute les variables alloué par une fonction à la fin de celle ci.

Pour les messages, tu peut savoir si la liste est vide, mais je ne connait pas de moyen pour savoir si la liste est vide. Mais normallement ce n´est pas sensé arrivé puice qu´une fenêtre doit traiter ces message le plus rapidement possible sinon elle gagne le petit [ne répond pas] dans son titre. Donc je pense pas que la liste de message soit remplie si vite.

Problème de la liste chainée, c´est qu´il faut la parcourir linaierement pour retrouver la bonne valeur (enfin ceci dit tant qu´il y a pas des milliards de variable, ca va).

c´est le probleme du langage interprété.
En C, c´est simple, a la compilation, la notion de variable n´existe plus :
tout est remplacé par des adresses --> vitesse d´execution tres rapide du coup.
Pour un interprété, y´a la liste chainée qui peut etre pas mal.
Déja, si c´est du vrai basic, tu n´as pas de notion de variables locale et globale :
tout est global.
Tu peux, par exemple, faire un arbre binaire de recherche avec un classement alphabétique des noms de variables
tu auras ainsi une recherche en log2 (n)
A voir...

Lockless> C´est sûr dans ce cas..

si tu veux garder les noms en clair, un arbre lexical me parait le plus effiace, sinon tu peux associer des identifiants arbitraires et tu sorts une hash-table pour retrouver tes variables a partir des clefs.

Je commence un langage de script moi aussi.
Pour les variables je crée une structure

typedef struct
{
int ivaleur;
char *nom;
}VAR;

Après je déclare les variables

VAR *vars;

Et a chaque fois que l´interpreteur tombe sur une nouvelle variable il réalloue le tableau...

JYY : pourquoi pas de variables locale en basic ?

Dès que la notion de procédure est présente dans un basic, celui ci possède des variables locales.
Effectivement il n´y en a pas pour les premier où tout se traitait à coup de goto et gosub mais bon.

Sinon une solution qui est assez courante et assez efficace plutot que d´utiliser des arbres ou pire encore un tableau statique qu´il faut réallouer (j´imagine as la perte de performance s´il y a pas mal de variables) est d´utiliser une liste chainée normale, à l´exception du fait qu´à chaque fois que tu accède à une variable tou la raproche du début de la liste.
Une solution est de mettre la variables au tout début de la liste, mais une solution un peu meilleur est de l´insérer au milieu entre le début de la liste et sa position actuelle. Comme ça à chaque fois qu´on y accède elle avance un peu et elle finit par se retrouver au début. En plus c´est interessant, car tu peut trouver le milieu de la liste pendant que tu recherche la variable elle même (avec un pointeur milieu qui n´avance qu´une fois sur deux) et donc tu ne perd pas de temps.

Tien ça faisait longtemps que je n´etait pas revenu sur ce forum La bonne nouvelle, c´est qu´il est modere maintenant , bravo dnoob ;)

j´avais fait un petit projet de script l´an dernier, et pour les variables j´avais utilisé std::map, basé sur une hashtable, donc avec une recherche plus rapide.

Mais si tu a l´intention de creer ton propre langage de script, je te conseil de lire "Game Scripting Mastery" (en anglais). Je suis actuelement en train de le lire et je ne peut que le conseiller .

Si ce livre est consacré au scripting (avec une explication de comment l´integrer dans un jeu, ainsi que les bases de Lua, Python et TCL), une grosse partie est consacré à la creation d´un langage de script (XtremeScript).

Je vais essayer de dire brievement comment il gere les variables.
Son langage est compilé (on passe d´un script proche du C, a un code proche de l´assembleur, pour ensuite passer en bytecode).
Du coup, sa gestion des variables est vraiment bas niveau, ce qui pourait ne pas corespondre a ta façon de gerer ça. Sa gestion des fonctions (adresse de retour, parametres), variables... tout passe par une pile. Ainsi, les variables globales sont situé en dessous de la pile (on peu lire le dessous), et les variables locales sont situé sur le dessus (juste au dessus de l´adresse de retour de la fonction).

Ainsi, à la compilation les variables n´ont plus de nom, mais juste un identifiant indiquant a quel moment il a été declaré dans la fonction

Pour essayer d´illustrer ce que je dit, je vais essayer de faire un pseudo script :

var global

func myFunction(var param)
{
var myVar1
var myVar2
myVar1 = param *10
myVar2 = param * param
global = myVar1 + myVar2
}

func main()
{
...
myFunction(2)
...
}

imaginons qu´on fasse apel a la fonction main dans le programme host.
L´etat de la pile sera à peu pres ça a la fin de la fonction "myFunction" :

4 -> valeur de myVar2
20 -> valeur de myVar1
56 -> suposons que ce soit l´adresse de retour e la fonction
2 -> le parametre
...
... // autres fonctions apelé precedements
24 -> valeur de la variable "global"

ainsi, myVar1 est situé a pile[-2], myVar2 pile[-1], et global à pile[1]. On peu d´ailleur remarquer que l´index positif part du bas de la pile, alors que l´index negatif du sommet.

du coup, une fois le script compilé, l´assembleur ne fait pas ça :
mov global myVar1
mais ça :
mov 1 -2
(plus des petit flag pour preciser que ce sont des variable et non des valeurs)

Voila, j´esper avoir été assez clair dans mes explications. Je conseil la lecture du livre pour ceux que ça interesse. D´apres l´auteur, la demarche est proche de celle qui est faite en assembleur, mais j´ai pas (ou alors tres peu) de connaissance dans ce domaine pour vous l´afirmer.

dnob700 > Il est vrai que j´avais oublié les "basic évolués" avec des procédures et tout, comme Visual Basic.
Pour moi je parlais des bons vieux Basic sur lesquels j´ai commencé :

10 print "bonjour"
20 let a = 10
30 if a=10 goto 50
40 print "jette ton ordi a la poubelle"
50 print "bon, ça va encore"

t´as oublié :

45 end

C´est bien, il n´y a même pas besoin d´insérer une ligne.

C´est comme ça que j´ai appris à programmer, au moins ça t´oblige à réfléchir avant d´écrire n´importe quoi.