Les fonctions du compilateur


Syntax
Resultat = Bool(<expression booléenne>)
Description
Bool permet d'évaluer une expression booléenne en dehors des opérateurs conditionnels réguliers comme If, While, Until, etc.

Arguments

expression booléenne L'expression booléenne à tester.

Valeur de retour

Renvoie #True si l'expression booléenne est vraie, #False sinon.

Exemple

  Salut$ = "Salut"
  LeMonde$ = "Le Monde"

  Debug Bool(Salut$ = "Salut")  ; Affichera 1
  Debug Bool(Salut$ <> "Salut" Or LeMonde$ = "Le Monde") ; Affichera 1

Exemple

  Procedure Chiffre(char.c)
    ProcedureReturn Bool(char >= '0' And char <= '9')
  EndProcedure

  Debug Chiffre('0')
  Debug Chiffre('1')
  Debug Chiffre('a')
  Debug Chiffre('z')

Syntax
Resultat = Defined(Nom, Type)
Description
Defined détermine si un objet tel qu'une structure, interface, variables etc. est déjà défini dans le programme.

Arguments

Nom Le nom de l'objet.

Le paramètre 'Nom' doit être spécifié sans aucune forme de décoration (sans le '#' pour une constante, sans les '()' pour un tableau, une liste, une map ou une procédure).
Type Peut prendre une des valeurs suivantes: 
  #PB_Constant
  #PB_Variable
  #PB_Array
  #PB_List
  #PB_Map
  #PB_Structure
  #PB_Interface
  #PB_Procedure
  #PB_Function
  #PB_OSFunction
  #PB_Label
  #PB_Prototype
  #PB_Module
  #PB_Enumeration

Valeur de retour

Renvoie une valeur non nulle si l'objet est défini, zéro sinon.

Exemple

  #PureConstante = 10
  
  CompilerIf Defined(PureConstante, #PB_Constant)
    Debug "La constante 'PureConstante' est déjà déclarée"
  CompilerEndIf
  
  Test = 25
  
  CompilerIf Defined(Test, #PB_Variable)
    Debug "La variable 'Test' est déjà déclarée"
  CompilerEndIf

Syntax
Resultat = Subsystem(<expression texte constante>)
Description
Subsystem permet de savoir si un sous-système est utilisé pour le programme en cours de compilation.
Le nom du sous-système est insensible à la casse.

Arguments

expression texte constante Le nom du sous-système.
Windows: DirectX9, DirectX11
Linux : Gtk2, Qt
MacOS X: Rien

Valeur de retour

Renvoie une valeur non nulle si le sous-système est utilisé, zéro sinon.

Exemple

  CompilerIf Subsystem("OpenGL")
    Debug "Compilation avec le sous-système OpenGL" 
  CompilerEndIf

Syntax
Resultat = OffsetOf(Structure\Champ)
Resultat = OffsetOf(Interface\Fonction())
Description
La commande OffsetOf permet de déterminer la position en mémoire d'un champ d'une structure ou la position en mémoire d'une fonction dans le cas d'une interface (soit IndexDeLaFunction*SizeOf(Integer)).

Arguments

Structure\Champ ou Interface\Fonction() Le champ de la structure ou la fonction de l'interface.

Valeur de retour

Renvoie l'index du champ ou de la fonction, zéro sinon.

Exemple

  Structure Personne
    Nom.s
    Prenom.s
    Age.w
  EndStructure
 
  Debug OffsetOf(Personne\Nom) ; Affichera 0
  Debug OffsetOf(Personne\Age) ; Affichera 16 avec un compilateur 64 bits ou 8 avec un compilateur 32 bits
                               ; car une un pointeur 'string' occupe 8 ou 4 octets en mémoire
 
  Interface ITest
    Creer()
    Detruire(Options)
  EndInterface
 
  Debug OffsetOf(ITest\Detruire()) ; Affichera 8 ou 4

Syntax
Resultat = SizeOf(Type)
Description
La commande SizeOf permet de renvoyer la taille en octets que prendra une structure, les types de base tels que les 'word', les 'float', etc.), une interface ou même une variable (Si une variable et une structure ont le même nom, la structure aura la priorité sur la variable.).
Comme SizeOf est une fonction du compilateur, elle ne fonctionne pas avec les tableaux, les Listes ou les Maps. Utilisez ArraySize(), ListSize() ou MapSize() à la place.
En tant que fonction du compilateur, SizeOf(x) est affectée à une constante et ne nécessite pas d'affectation à une autre variable si elle se trouve à l'intérieur d'une boucle ou d'une procédure appelée à plusieurs reprise.

Arguments

Type Le type de l'objet.

Valeur de retour

La taille de l'objet en mémoire, en octets.

Remarques

C'est très utile dans de nombreux cas, notamment lors de l'utilisation des commandes API.

Note : Une variable de type caractère (CHARACTER) (.c) est unicode et occupe 2 octets et une variable de type ASCII (.a) n'occupe qu'1 octet.

Exemple: 1

  VariableCaractere.c = '!'
  Debug SizeOf(VariableCaractere) ; affiche 2, c'est à dire 2 octets
  Debug SizeOf(CHARACTER)         ; affiche 2, c'est à dire 2 octets
  
  VariableAscii.a = '!'
  Debug SizeOf(VariableAscii)     ; affiche 1, c'est à dire 1 octets
  Debug SizeOf(ASCII)             ; affiche 1, c'est à dire 1 octets

Exemple: 2

  Structure Personne
    Nom.s
    Prenom.s
    Age.w
  EndStructure
 
  Debug "La taille de la structure 'Personne' est "+Str(Sizeof(Personne))+" octets" ; Affichera 18 avec un compilateur 64 bits(8+8+2)
                                                                                    ; ou 10 avec un compilateur 32 bits (4+4+2)
 
  Jean.Personne\Nom = "Jean"
 
  Debug SizeOf(Jean) ; Affichera 18 ou 10 aussi

Syntax
Resultat = TypeOf(Objet)
Description
TypeOf permet de déterminer le type d'une variable, ou d'un champ de structure.

Arguments

Objet L'objet à utiliser.

Valeur de retour

Le type de l'objet.

Le type peut être une des valeurs suivantes: 
  #PB_Byte      
  #PB_Word      
  #PB_Long      
  #PB_String    
  #PB_Structure
  #PB_Float
  #PB_Character
  #PB_Double
  #PB_Quad
  #PB_List
  #PB_Array
  #PB_Integer
  #PB_Map
  #PB_Ascii
  #PB_Unicode 
  #PB_Interface

Exemple

  Structure Personne
    Nom.s
    Prenom.s 
    Age.w 
  EndStructure
  
  If TypeOf(Personne\Age) = #PB_Word
    Debug "Age est un 'Word'"
  EndIf
            
  Surface.f                 
  If TypeOf(Surface) = #PB_Float
    Debug "Surface est un 'Float'"
  EndIf

Syntax
InitializeStructure(*Memoire, Structure)
Description
Initialise un objet structuré en mémoire.

En fait, cette fonction initialise les membres d'une structure. Ces membres sont de type Array, List ou Map mais les autres types ne sont pas affectés (.s .l, .i, etc.).

Arguments

*Memoire L'adresse mémoire à utiliser.
Structure Le nom de la structure qui doit être utilisé pour effectuer l'initialisation.
Il n'y a pas de contrôle pour s'assurer que la zone mémoire corresponde à la structure.

Valeur de retour

Aucune.

Remarques

Attention: plusieurs appels à InitializeStructure crée une fuite de mémoire parce que les anciens membres de la structure ne sont pas libérés de la mémoire. ClearStructure doit être appelée avant d'appeler une nouvelle fois InitializeStructure.
Cette fonction est pour les utilisateurs avancés et doit être utilisée avec précaution.
Pour allouer une structure dynamique, utiliser AllocateStructure().

Exemple

  Structure Personne
    Prenom$
    Age.l
    List Amis.s()
  EndStructure

  *Etudiant.Personne = AllocateMemory(SizeOf(Personne))
  InitializeStructure(*Etudiant, Personne)

  ; Maintenant, la liste est prête à l'emploi
  ;
  AddElement(*Etudiant\Amis())
  *Etudiant\Amis() = "John"
  
  AddElement(*Etudiant\Amis())
  *Etudiant\Amis() = "Yann"

  ; Affichage du contenu de la liste
  ;
  ForEach *Etudiant\Amis()
    Debug *Etudiant\Amis()
  Next

Syntax
CompareStructure(*Pointeur1, *Pointeur2, Structure [, Options])
Description
CompareStructure compare la mémoire de deux structures pour vérifier leur égalité. La comparaison est également appliquée de manière récursive aux éléments enfants tels que arrays, listes et maps.

Arguments

*Pointeur1 L'adresse mémoire de la première variable structurée a tester.
*Pointeur2 L'adresse mémoire de la seconde variable structurée a tester.
Structure La structure utilisée.
Options (optionnel) Le paramètre "Options" est facultatif et peut prendre l'une des valeurs suivantes : 
   #PB_String_CaseSensitive  : La comparaison de chaînes est sensible à la casse (a=a). (par défaut)
   #PB_String_NoCase         : La comparaison de chaînes n'est pas sensible à la casse (A=a).
   #PB_Memory_FollowPointers : Si un élément de structure est un pointeur qui n'est pas 0, comparez récursivement la cible du pointeur.
                               La valeur par défaut consiste à comparer uniquement la valeur (existante) du pointeur elle-même.

Remarques

Attention: L'option #PB_Memory_FollowPointers est destinée aux utilisateurs avancés et nécessite une attention particulière pour éviter les plantages. Si cette option est utilisée, alors toutes les valeurs de pointeur doivent pointer vers une mémoire valide et initialisée ou avoir la valeur 0. Il n'est pas non plus autorisé d'avoir des boucles dans les éléments pointés (une chaîne de pointeurs qui se renvoie à elle-même).

Valeur de retour

Renvoie une valeur non nulle si les structures sont les identiques, zéro sinon.

Exemple

   Structure Personne
     Nom$
     Prenom$
     Map Amis$()
     Age.l
  EndStructure

 EtudiantA.Personne\Prenom$ = "Paul"
 EtudiantA\Nom$ = "Morito"
 EtudiantA\Amis$("Tom") = "Dupont"
 EtudiantA\Amis$("Jim") = "Durand"

 EtudiantB.Personne\Prenom$ = "Paul"
 EtudiantB\Nom$ = "Morito"
 EtudiantB\Amis$("Tom") = "Dupont"
 EtudiantB\Amis$("Jim") = "Durand"

 EtudiantC.Personne\Prenom$ = "Paul"
 EtudiantC\Nom$ = "Morito"
 EtudiantC\Amis$("Tom") = "Fontaine" ; Différent dans EtudiantA
 EtudiantC\Amis$("Jim") = "Durand"

  Debug CompareStructure(@EtudiantA, @EtudiantB, Personne) ; Egal
  Debug CompareStructure(@EtudiantA, @EtudiantC, Personne) ; Pas égal

Syntax
CopyStructure(*Source, *Destination, Structure)
Description
Copie une structure en mémoire vers une autre.

Arguments

*Source L'adresse mémoire contenant la structure à copier.
*Destination L'adresse mémoire de la copie.
Structure Le nom de la structure qui doit être utilisé pour effectuer la copie.

Valeur de retour

Aucune.

Remarques

C'est particulièrement utile lors de l'utilisation de mémoire dynamique avec les pointeurs. Chaque champ de la structure sera dupliqué, y compris les tableaux dynamiques, les listes ou les maps. La structure de destination sera automatiquement effacée avant de faire la copie, il n'est pas nécessaire d'appeler ClearStructure avant CopyStructure.
Attention : La destination doit être une zone de mémoire de structure valide, ou une zone mémoire effacée. Si la zone de mémoire n'est pas effacée, cela pourrait provoquer un crash, car des valeurs aléatoires seront utilisées.
Il n'y a pas de contrôle pour s'assurer que les deux zones mémoires sont bien du type 'Structure', donc il est impératif de manipuler cette commande avec précaution.

Exemple

  Structure Personne
    Prenom$
    Nom$
    Map Amis$()
    Age.l
  EndStructure

  Etudiant.Personne\Prenom$ = "Paul"
  Etudiant\Nom$ = "Morito"
  Etudiant\Amis$("Tom") = "Jones"
  Etudiant\Amis$("Jim") = "Doe"
  
  CopyStructure(@Etudiant, @EtudiantCopy.Personne, Personne)
  
  Debug EtudiantCopy\Prenom$
  Debug EtudiantCopy\Nom$
  Debug EtudiantCopy\Amis$("Tom")
  Debug EtudiantCopy\Amis$("Jim")

Syntax
Resultat = ClearStructure(*Memoire, Structure)
Description
Vide la zone mémoire structurée et met la valeur de tous les champs à zéro.

Arguments

*Memoire L'adresse mémoire contenant la structure à effacer.
Structure Le nom de la structure qui sera utilisée pour effectuer le nettoyage.

Valeur de retour

Aucune.

Remarques

C'est particulièrement utile quand la structure contient des chaînes de caractères, des tableaux, des listes ou des maps qui ont été alloués en interne par PureBasic. Tous les champs seront mis à zéro, même les types natifs comme long, integer, etc.
Il n'y a pas de contrôle pour s'assurer que la zone mémoire est bien du type 'Structure' spécifié, donc il est impératif de manipuler cette commande avec précaution. Cette fonction est réservée aux utilisateurs avancés.

Exemple

  Structure Personne
    Prenom$
    Nom$
    Age.l
  EndStructure

  Etudiant.Personne\Prenom$ = "Paul"
  Etudiant\Nom$ = "Morito"
  Etudiant\Age = 10
  
  ClearStructure(@Etudiant, Personne)
  
  ; Affichera des chaines vide, car la structure entiere a ete videe. Tous les autres champs ont ete remis a zero
  ;
  Debug Etudiant\Prenom$
  Debug Etudiant\Nom$
  Debug Etudiant\Age

Syntax
ResetStructure(*Memoire, Structure)
Description
ResetStructure, vide la zone mémoire structurée et l'initialise pour être prête à être utilisée.

Arguments

*Memoire L'adresse mémoire contenant la structure à réinitialiser.
Structure Le nom de la structure utilisée.

Valeur de retour

Aucune.

Remarques

C'est particulièrement utile quand la structure contient des chaînes de caractères, des tableaux, des listes ou des maps qui ont été alloués en interne par PureBasic. Tous les champs seront mis à zéro, même les types natifs comme long, integer, etc.
Il n'y a pas de contrôle pour s'assurer que la zone mémoire est bien du type 'Structure' spécifié, donc il est impératif de manipuler cette commande avec précaution. Cette fonction est réservée aux utilisateurs avancés.

Exemple

  Structure Personne
    Map Amis.s()
  EndStructure

  Henri.Personne\Amis("1") = "Paul"
  
  ResetStructure(@Henri, Personne)
  
  ; Affiche une chaîne vide car l'ensemble de la structure a été réinitialisée. 
  ; La map est encore utilisable, mais vide.
  ;
  Debug Henri\Amis("1")