Comment récupérer valeur variable, tableaux, liste, map...

[Brayane]

Bonjour,

Je voudrais savoir comment faire pour récupérer dans mon programme toutes les variables, tableaux, liste, map, etc.
Ce que je voudrais c'est que quand dans mon programme je tape le nom d'une variable, tableaux, liste, map, etc., qu'il me donne sa valeur.

Imaginons par exemple une fenêtre avec un StringGadget dedans, quand je tape le nom d'une variable, tableaux, liste, map, etc., qu'il me donne sa valeur.

Le débogueur de PB le fait, mais j'aimerais faire la même chose
enfin si c'est possible.

Comment puis-je faire cela svp ?

[Ar-S]

Comment le debug te le fait ?

#tonstringgadget contient "blabla"
Pour ton debug tu fais Debug Getgadgettext(#tonstringgadget))
il est ou le soucis ?
Tu veux que ton soft te sorte la valeur du string (si je puis dire) tu crées un editorgadget (par exemple) et tu tapes

Code : Tout sélectionner

setgadgettext(#tonediteur, getgadgettext(#tonstringgadget))

[Brayane]

Bonsoir, merci de la rapidité de réponse
Non ce n'est pas ça que je voudrais faire.

Je ne souhaite pas utiliser le débogueur de PB.
De plus une fois le programme compiler adieu de débogueur de PB

Voici un petit code d’illustration de base:

Code : Tout sélectionner

Enumeration
  
  #Fenetre
  #EditorGadget
  #StringGadget
  
EndEnumeration

Variable$ = "Abc"
UneVariable = 145
UneAutreVariable = 456

If OpenWindow(#Fenetre, 0, 0, 350, 323, "Ma fenêtre", #PB_Window_SystemMenu | #PB_Window_TitleBar | #PB_Window_ScreenCentered)
  EditorGadget(#EditorGadget, 1, 1, 348, 300)
  StringGadget(#StringGadget, 1, 302, 348, 20, "")
  
  Repeat
    
    WindowEvent = WaitWindowEvent(1)
    
    Select WindowEvent
        
      Case #PB_Event_Gadget
        
    EndSelect
    
  Until  WindowEvent = #PB_Event_CloseWindow
  
EndIf

Je voudrait quand par exemple je tape dans le StrinGadget le nom d'une variable se trouvant dans le code PB
que sa valeur soit afficher dans l’éditeur

Ya pas quelque chose pour demander à PB toutes les variable du code ?
Ya pas un truc pour lister toutes les variable du code ?

Voilà d’où ma question, comment le débogueur de PB fais lui pour faire ça ?
Comment il liste toutes les variable et j'en passe du code ?

[Ollivier]

Regarde la bibliothèque 'Runtime'.

[Brayane]

Bonjour,

Merci bien, oui Runtime, pas mal ce petit joujou là, encore merci
Ce petit code fonctionne très bien, il suffis d'entrer le nom de la variable voulue pris en charge et zou !

Par contre je suis déçus, cella ne fonctionne pas avec les Listes, Tableaux, Maps......
Si vous avez une autre idée

Code : Tout sélectionner

Runtime Enumeration
  
  #Fenetre
  #EditorGadget
  #StringGadget
  #ButtonGadget
  
  #Constante1 = 456
  
EndEnumeration

Define VariableAlphaNumerique1$
Define VariableNumerique1

Runtime VariableAlphaNumerique1$, VariableNumerique1

VariableAlphaNumerique1$ = "Abc"
VariableNumerique1 = 145

If OpenWindow(#Fenetre, 0, 0, 350, 323, "Ma fenêtre", #PB_Window_SystemMenu | #PB_Window_TitleBar | #PB_Window_ScreenCentered)
  EditorGadget(#EditorGadget, 1, 1, 348, 300)
  StringGadget(#StringGadget, 1, 302, 323, 20, "")
  ButtonGadget(#ButtonGadget, 325, 302, 25, 20, "Ok")
  
  Repeat
    
    WindowEvent = WaitWindowEvent(1)
    
    Select WindowEvent
        
      Case #PB_Event_Gadget
        
        Select EventGadget()
            
          Case #ButtonGadget
            
            If IsRuntime(GetGadgetText(#StringGadget))
              
              If Not FindString(GetGadgetText(#StringGadget), "$", 1)
                AddGadgetItem(#EditorGadget, -1, Str(GetRuntimeInteger(GetGadgetText(#StringGadget))))
                
              Else
                AddGadgetItem(#EditorGadget, -1, GetRuntimeString(GetGadgetText(#StringGadget)))
                
              EndIf
              
            EndIf
            
        EndSelect
        
    EndSelect
    
  Until  WindowEvent = #PB_Event_CloseWindow
  
EndIf

[G-Rom]

tu stokes une map ( clé , nom de la variable ) , est un pointeur. qui pointe sur une structure contenant :

Code : Tout sélectionner

structure sVar
 type.l
 structureunion
  long.l
  int.i
  float.f
  etc...
 endstructureunion
endstructure

Cela reviens à créer un système complet des variable via les procédures.

[Ollivier]

tu stokes une map ( clé , nom de la variable ) , est un pointeur. qui pointe sur une structure contenant :

Code : Tout sélectionner

structure sVar
 type.l
 structureunion
  long.l
  int.i
  float.f
  etc...
 endstructureunion
endstructure

Cela reviens à créer un système complet des variable via les procédures.

Je n'ai pas compris grand chose (excepté le code, mais il manque le nom de l'objet dans la structure, par exemple Name.S autour de Type.I, et là, effectivement, on fait son 'runtime' perso).

[Ollivier]

Ah! J'y suis. Le nom est déjà dans la clé de la map. Monsieur s'économise!

(édité)

@Brayan

De 2 choses,
L'une, avec les macros, tu peux contrôler 'NewMap' par exemple pour qu'il ajoute l'objet en question dans la map structurée expliquée par G-Rom. Les 'NewMap' seront changés en 'NewMap_' par exemple, et la macro 'NewMap_' doit se charger de stocker le nom de la nouvelle map et l'initialiser, comme voulu initialement.

L'autre, si tu as trop d'objet à modifier dans le code, c'est carrément d'aller chercher tout ce dont tu as besoin dans le fichier (format texte standard) #Pb_Compiler_File. Il te faut connaître les deux bibliothèques sur les chaînes et sur les fichiers.
Cette 2ème méthode, c'est en cas de déboguage "open source", parce que ton source doit rester dispo pour y trouver les objets divers à recenser.

[Brayane]

Bonjour, déjà merci beaucoup de votre aide.

Ensuite, c'est un peu gros à digérer ce que vous me dites là mais je vais essayer de comprendre.
Merci G-rom pour ton exemple, merci aux autres aussi pour leur aide.

Avec des exemples je pense pouvoir me débrouiller.

Nota: Connaissais pas les Runtime, c'est vraiment bien ce truc

Pour le moment ça fonctionne bien avec les variables et les constantes mais pas avec le reste, je continue à creuser
Merci encore.

[Ollivier]

Ensuite, c'est un peu gros à digérer ce que vous me dites là mais je vais essayer de
comprendre.

Je crois que sans se concerter, on a, a priori tous suggéré que tu n'étais pas débutant pur et dur!

N'hésite pas à poser d'autres questions qui peuvent être issues des premières posées, de telle sorte que l'on s'oriente plus précisément, si tu as besoin.

Quand on découvre un nouveau venu, on ne sait pas à la perfection ce qu'il sait!

[G-Rom]

je pensais à ce genre de système , on retrouve le même principe dans un langage interprété ou la partie avant d'un compilo :
voila la base, à toi de l'améliorer

Code : Tout sélectionner

Structure sVariable
  
  type.a
  stringLength.l
    
  StructureUnion
    char.c
    ascii.a
    byte.b
    long.l
    integer.i
    float.f
    double.d
    quad.q
    *string
  EndStructureUnion
  
EndStructure


Structure sTable
  Map var.sVariable()
EndStructure


Procedure.i createTable()
  *t.sTable = AllocateMemory(SizeOf(sTable))
  If *t
    InitializeStructure(*t,sTable)
    ProcedureReturn *t
  EndIf 
  ProcedureReturn #Null 
EndProcedure


Procedure createVariable(*table.sTable, type.l, name.s, *value, size.l = 0)
  If FindMapElement(*table\var(), name) = 0
    *table\var(name)\type = type
    Select *table\var(name)\type
      Case #PB_Character
        *table\var(name)\char = PeekC(*value)
        
      Case #PB_Ascii
        *table\var(name)\ascii = PeekA(*value)
        
      Case #PB_Byte
        *table\var(name)\byte = PeekB(*value)
        
      Case #PB_Long
        *table\var(name)\long = PeekL(*value)
        
      Case #PB_Integer
        *table\var(name)\integer = PeekL(*value)
        
      Case #PB_Float
        *table\var(name)\float = PeekF(*value)
        
      Case #PB_Double
        *table\var(name)\double = PeekD(*value)
        
      Case #PB_Quad
        *table\var(name)\quad = PeekQ(*value)
        
      Case #PB_String
        If size>0
          *table\var(name)\string = AllocateMemory(size)
          CopyMemory(*value,*table\var(name)\string,size)
          *table\var(name)\stringLength = size
        EndIf 
    EndSelect
  
  EndIf 
EndProcedure 



Procedure.i getVariablePtr(*table.sTable, name.s)
  If FindMapElement(*table\var(), name) <> 0
    
    Select *table\var()\type
      Case #PB_Character
        ProcedureReturn @*table\var()\char
      Case #PB_Ascii
        ProcedureReturn @*table\var()\ascii
      Case #PB_Byte
        ProcedureReturn @*table\var()\byte
      Case #PB_Long
        ProcedureReturn @*table\var()\long
      Case #PB_Integer
        ProcedureReturn @*table\var()\integer
      Case #PB_Float
        ProcedureReturn @*table\var()\float
      Case #PB_Double
        ProcedureReturn @*table\var()\double
      Case #PB_Quad
        ProcedureReturn @*table\var()\quad
      Case #PB_String
        ProcedureReturn @*table\var()\string
    EndSelect
  Else
    ProcedureReturn #Null 
  EndIf
EndProcedure




*maTable = createTable()
If *maTable
  
  
  myVar.c = 38
  createVariable(*maTable, #PB_Character,"anotherVar",@myVar)
  
  *pointeur = getVariablePtr(*maTable,"anotherVar")
  
  Debug "pointeur vTable    :" + Str(*pointeur)
  Debug "valeur dans vTable :" + Str(PeekC(*pointeur))
  
  
EndIf

[Ollivier]

A noter que StructureUnion et EndStructureUnion peuvent être ôtés pour comprendre plus facilement le fonctionnement de cet exemple. StructureUnion évite un gaspillage de mémoire.

[Brayane]

Bonsoir,

Ensuite, c'est un peu gros à digérer ce que vous me dites là mais je vais essayer de
comprendre.

Je crois que sans se concerter, on a, a priori tous suggéré que tu n'étais pas débutant pur et dur!

N'hésite pas à poser d'autres questions qui peuvent être issues des premières posées, de telle sorte que l'on s'oriente plus précisément, si tu as besoin.

Quand on découvre un nouveau venu, on ne sait pas à la perfection ce qu'il sait!

Exacte Ollivier, pas débutant mais pas pro non plus, j'avance à mon rythme voilà

La ce que G-Rom ma donné à manger si gentiment, je ne suis pas encore capable de le digérer car c'est encore trop compliquer pour moi.
Je vois à peut prêt se que ça fait mais j'assimile pas encore...

J'ai peut être visé trop haut.

Oui je cherche à faire un Débogueur maison, je suis sur une bonne piste déjà mais je vais coincer sur l'affichage des tableaux, Liste et Map...
Pour les variable et constante ça roule grâce à RunTime

Merci à tous pour votre aide

[Ollivier]

La ce que G-Rom ma donné à manger si gentiment, je ne suis pas encore capable de le digérer car c'est encore trop compliquer pour moi.
Je vois à peut prêt se que ça fait mais j'assimile pas encore...
J'ai peut être visé trop haut.

Non, je ne pense pas du tout que tu aies visé trop haut.

D'ailleurs, tu parles de hauteur, qui dit 'travail en hauteur' dit 'échafaudage'.

Le code de G-Rom n'est pas parfait. Je le trouve même craignos, mais il a sûrement fait exprès de le simplifier, pour justement qu'il n'y ait pas 36 explications successives qui se succèdent avant de le comprendre.

On va faire un code source plus craignos encore! Mais qui n'empêche en rien de fonctionner.

On peut réfléchir du plus compliqué au plus simple.

On a là-haut, une structure complexe. car, comme en Cpp, elle contient une union.

Si on 'zappe' cette union, on a une simple structure.

Une structure, ce sont des champs qui se succèdent.
En Quickbasic, il n'y a pas de structure native au langage.

Pourtant, c'est faisable. Ça donnerait:

Code : Tout sélectionner

MaxPersonne = 99
; /!\ de 0 à 99, ça fait 100 personnes!

; Méthode à l'ancienne pour créer une structure et allouer la mémoire suffisante:
; Par exemple, avec 3 champs, on a 3 tableaux

Dim PersonneNom.S(MaxPersonne)
Dim PersonneAge.I(MaxPersonne)
Dim PersonneProfession.S(MaxPersonne)

Là, on a notre structure 'Personne'.
Chaque 'Personne' a donc un nom sous forme de chaîne, un âge sous forme de nombre et une profession sous forme de chaîne (S).
MaxPersonne est réglé à 99, donc avec la personne numéro 0, un total de 100 personnes est descriptible.
C'est-à-dire qu'on va pouvoir lire et modifier les caractéristique (champs de structure) de chacune des 100 personnes à la volée. Avant de voir cette volée, voyons l'équivalent 'moderne' de structure:

Code : Tout sélectionner

Structure PERSONNE
   Nom.S
   Age.I
   Profession.S
EndStructure

Dim Personne.PERSONNE(MaxPersonne)

Woilà! En gros, déjà deux équivalents. Et voici pour lire une caractéristique, à l'ancienne...

Code : Tout sélectionner

Debug PersonneNom(PersonneCourante)

...et façon moderne...

Code : Tout sélectionner

Debug Personne(PersonneCourante)\Nom

Et voici pour modifier une caractéristique, à l'ancienne...

Code : Tout sélectionner

PersonneNom(PersonneCourante) = "Tartempion"

...et façon moderne...

Code : Tout sélectionner

Personne(PersonneCourante)\Nom = "Tartempion"

Alors j'ai mis des exemples, mais je n'ai pas précisé 'PersonneCourante', c'est une variable, un nombre entier plus précisément entre 0 et 99 inclus ('MaxPersonne' est modifiable).

C'est donc ainsi avec les tableaux. Objet carré dont la taille est définie "à l'avance" (même si l'on peut modifier cette taille à la volée) pour être l'objet dont l'accès est le plus rapide.

Plus lent, mais gérant l'insertion et la suppression, existe les listes chaînées. C'est quand 'PersonneCourante' est impliqué en interne, donc n'a plus à être précisé.
maxPersonne, idem, n'a plus à être précisé.

Par ex:
(à l'ancienne)

Code : Tout sélectionner

PersonneNom() = "Fernande"

(moderne)

Code : Tout sélectionner

Personne()\Nom = "Fernande"

Plus lent encore, mais gérant toute transformation d'accès de données, la map. Le principe d'accès est proche d'un tableau, mais au lieu d'accéder aux données via un nombre (index de tableau), on y accède par un nom, et plus généralement , par une chaîne. Seul le caractère ASCIIZ (0) est interdit dans le nom.

Toi, tu veux stocker des infos, sur des objets. Il te faut donc faire en 1er lieu, un inventaire des objets supportés par ton futur débogueur et y déceler les diverses caractéristiques.

Après, libre à toi de commencer par un code source à l'ancienne, d'abord, puis de l'adapter ensuite en version plus moderne.

N'hésite pas si tu as d'autres question.

[Brayane]

Bonjour,

Très clair ce que tu a expliqué Ollivier, je t'en remercie
J'ai fais ça pour m’échauffer un peu:

Code : Tout sélectionner

; Lire des données en mémoire
Procedure.i LectureMemoire(*PointeurMemoire)
  ProcedureReturn PeekI(*PointeurMemoire) ; Lit le contenu complet de la mémoire à partir de l'emplacement mémoire spécifier
EndProcedure

; Exemple n°1:

; *MonPointeur_MaVariable1 est le pointeur qui va contenir l’adresse mémoire de la variable "MaVariable1"
; @MaVariable1 pointe sur l'adresse de la variable "MaVariable1", l'opérateur @ veux dire ici "Pointer vers, demander l'adresse mémoire de".

; En plus simple:

; "*MonPointeur_MaVariable1" demande à la variable "MaVariable1" à quel adresse elle se situe en mémoire
; "MaVariable1" donne sont adresse mémoire (Grâce à l'opérateur @) (Sont emplacement dans la mémoire en nombre) à "*MonPointeur_MaVariable1"
; "*MonPointeur_MaVariable1" contient maintenant l'adresse de (La position exacte en mémoire) "MaVariable1".

MaVariable1 = 0 ; Initialisation de la variable.
*MonPointeur_MaVariable1 = @MaVariable1

Debug "Valeur de MaVariable1 = " + Str(MaVariable1)
Debug "Adresse mémoire de MaVariable1 = " + Str(*MonPointeur_MaVariable1)
Debug "-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------"

For MaVariable1 = 1 To 10
  Debug "Valeur actuel de MaVariable1 à l'adresse mémoire " + Str(*MonPointeur_MaVariable1) + " = " + Str(LectureMemoire(*MonPointeur_MaVariable1)) ; Lecture de la valeur situer à l'adresse mémoire "*MonPointeur_MaVariable1".
Next

Debug ""

; Exemple n°2:

; Idem mais avec une Structure associer au pointeur.

MaVariable2 = 0
*MonPointeur_MaVariable2.integer = @MaVariable2

Debug "Valeur de MaVariable2 = " + Str(MaVariable2)
Debug "Adresse mémoire de MaVariable1 = " + Str(*MonPointeur_MaVariable2.integer)
Debug "-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------"

For MaVariable2 = 1 To 10
  Debug "Valeur actuel de MaVariable2 à l'adresse mémoire " + Str(*MonPointeur_MaVariable2) + " = " + Str(*MonPointeur_MaVariable2\i) ; Ont indique que l'on souhaite avoir la valeur Integer (Nombre) -> \i.
Next

Vous en pensez quoi ?

C'est vraiment pas facile d’appréhender ce genre de chose là pour un débutant (Que je ne suis pas certes), mais quand c'est très bien expliqué, ça roule !
Par contre avec la structure j'ai pas tous compris, j'ai fais ce code à partir de test avec d'autre code dans mes archives perso.

Quand ont y regarde de plus prêt, les pointeurs ne servent pas à grand chose si ce n'est un point très important
tout de même qui est d'identifier un pointeur (Une adresse mémoire) d'une variable numérique lambda.

Et oui car une variable numérique de base peut aussi faire office de pointeur mémoire, ce n'est qu'un nombre !
C'est juste moins lisible, moins clair, d’où la fonction première des pointeurs

J'ai raison ou je suis dans l’erreur ?