Divers fonctions

dayvid · Message par **dayvid** » mer. 25/mai/2011 13:49

Hello, je sais plus on ont ma parlé de ça alors je poste la

Voici divers fonction sur les string et une autre
déjà vue pour le clavier et la souris:

Code : Tout sélectionner

Procedure.l convertion_positif(nombre)
  convertion_nombre = nombre - nombre - nombre
  ProcedureReturn convertion_nombre
EndProcedure

Procedure.l convertion_negatif(nombre)
  convertion_nombre = nombre - nombre - nombre
  ProcedureReturn convertion_nombre
EndProcedure

Procedure Convertion_caractere(Chaine$, Mode)
  
  ; crée par dieppedalle david le 16 mars 2010
  ; vous pouvez crée une procedure comme la
  ; ou alors vous prenez la chaine dans un fichier:
  
  ;     If ReadFile(1, "chaine.txt")  ; Si le fichier peut être lu , on continue...
  ;     While Eof(1) = 0           ; Boucle tant que la fin du fichier n'est pas atteinte. (Eof = 'End Of File') 
  ;       chaine$ = ReadString(1)      ; Affiche ligne par ligne le contenu du fichier
  ;     Wend
  ;     CloseFile(1)               ; Ferme le fichier précédemment ouvert
  ;   Else
  ;     MessageRequester("Information","Impossible d'ouvrir le fichier !")
  ;   EndIf
  
  ; l'aventage de prendre la chaine directement dans un fichier
  ; c'est que ont peut convertire aussie les guillemet 
  ; ce qui ne peut pas ce faire avec une procedure
  ; car l'on ne peut pas mêtre de guillemet
  ; pure dans une chaine de caractère
  
  ; il y as deux mode, 0 et 1
  ; le mode 0 est pour les caractères ascii standard qui ne sont pas compatible avec la console
  ; et le mode 1 est pour les caractères ascii en mode console
  
  
  If mode = 0
    
    For converssion = 1 To Len(chaine$)    
      
      caractere$ = Mid(chaine$, converssion, 1)
      
      If caractere$ = Chr(34) Or caractere$ = "à" Or caractere$ = "â" Or caractere$ = "ä" Or caractere$ = "é" Or caractere$ = "è" Or caractere$ = "ê" Or caractere$ = "ë" Or caractere$ = "î" Or caractere$ = "ï" Or caractere$ = "ô"Or caractere$ = "ö" Or caractere$ = "û" Or caractere$ = "ü" Or caractere$ = "ÿ" Or caractere$ = "ç"
        ; si un caractères est accentuer ou que c'est un guillemet, ont le convertit
        convertisseur = 1
      Else
        convertisseur = 0
      EndIf
      
      If converssion = 1 And convertisseur = 0 ; si c'est le premier caractère de la chaine et que et que ya pas de lèttre a convertire
        caractere_convertis$ = Chr(34) + caractere$ ; je debute la chaine de caractère par un guillemet
        
      ElseIf converssion = 1 And convertisseur = 1 ; sinon si c'est le premier caractère de la chaine et que ya une lèttre a convertire
        caractere_convertis$ = "Chr(" + Str(Asc(caractere$)) + ") + " + Chr(34) ; ; je debute la chaine de caractère par un chr(identifiant caractère) plus un guillemet
        
      ElseIf converssion = Len(chaine$) And convertisseur = 0 ; sinon si c'est le dernier caractère de la chaine et que ya pas de lèttre a convertire
        caractere_convertis$ = caractere$ + Chr(34) ; je tèrmine la chaine de caractère par un guillemet
        
      ElseIf converssion = Len(chaine$) And convertisseur = 1 ; sinon si c'est le dernier caractère de la chaine et que ya une lèttre a convertire
        caractere_convertis$ = Chr(34) + " + Chr(" + Str(Asc(caractere$)) + ")" ; je tèrmine la chaine de caractère par un + chr(identifiant caractère)
        
      ElseIf converssion < Len(chaine$) And convertisseur = 0 ; sinon si c'est un caractère qui n'est ni au début ni a la fin de la chaine et que ya pas de lèttre a convertire
        caractere_convertis$ = caractere$ ; j'enregistrer le caractere
        
      ElseIf converssion < Len(chaine$) And convertisseur = 1; sinon si c'est un caractère qui n'est ni au début ni a la fin de la chaine et que ya une lèttre a convertire
        caractere_convertis$ = Chr(34) + " + Chr(" + Str(Asc(caractere$)) + ") + " + Chr(34) ; je met un guillemet + chr(identifiant caractère) + ") + " + un autre guillemet
        
      EndIf
      
      caractere_convertis_precedent$ = caractere_convertis$
      converssion_chaine$ = converssion_chaine$ + caractere_convertis$
      
    Next
    
  ElseIf mode = 1
    
    For converssion = 1 To Len(chaine$)    
      
      caractere$ = Mid(chaine$, converssion, 1)
      
      Select caractere$
          ; si un caractères est accentuer ou que c'est un guillemet, ont le convertit
          
        Case Chr(34)
          convertisseur = 1
          ascii_caractere = 34
          
        Case "à"
          convertisseur = 1
          ascii_caractere = 133
          
        Case "â"
          convertisseur = 1
          ascii_caractere = 134
          
        Case "ä"
          convertisseur = 1
          ascii_caractere = 132
          
        Case "é"
          convertisseur = 1
          ascii_caractere = 130
          
        Case "è"
          convertisseur = 1
          ascii_caractere = 138
          
        Case "ê"
          convertisseur = 1
          ascii_caractere = 136
          
        Case "ë"
          convertisseur = 1
          ascii_caractere = 137
          
        Case "î"
          convertisseur = 1
          ascii_caractere = 140
          
        Case "ï"
          convertisseur = 1
          ascii_caractere = 139
          
        Case "ô"
          convertisseur = 1
          ascii_caractere = 147
          
        Case "ö"
          convertisseur = 1
          ascii_caractere = 153
          
        Case "û"
          convertisseur = 1
          ascii_caractere = 150
          
        Case "ü"
          convertisseur = 1
          ascii_caractere = 154
          
        Case "ÿ"
          convertisseur = 1
          ascii_caractere = 152
          
        Case "ç"
          convertisseur = 1
          ascii_caractere = 128
          
        Default
          convertisseur = 0
          
      EndSelect
      
      If converssion = 1 And convertisseur = 0 ; si c'est le premier caractère de la chaine et que et que ya pas de lèttre a convertire
        caractere_convertis$ = Chr(34) + caractere$ ; je debute la chaine de caractère par un guillemet
        
      ElseIf converssion = 1 And convertisseur = 1 ; sinon si c'est le premier caractère de la chaine et que ya une lèttre a convertire
        caractere_convertis$ = "Chr(" + Str(ascii_caractere) + ") + " + Chr(34) ; ; je debute la chaine de caractère par un chr(identifiant caractère) plus un guillemet
        
      ElseIf converssion = Len(chaine$) And convertisseur = 0 ; sinon si c'est le dernier caractère de la chaine et que ya pas de lèttre a convertire
        caractere_convertis$ = caractere$ + Chr(34) ; je tèrmine la chaine de caractère par un guillemet
        
      ElseIf converssion = Len(chaine$) And convertisseur = 1 ; sinon si c'est le dernier caractère de la chaine et que ya une lèttre a convertire
        caractere_convertis$ = Chr(34) + " + Chr(" + Str(ascii_caractere) + ")" ; je tèrmine la chaine de caractère par un + chr(identifiant caractère)
        
      ElseIf converssion < Len(chaine$) And convertisseur = 0 ; sinon si c'est un caractère qui n'est ni au début ni a la fin de la chaine et que ya pas de lèttre a convertire
        caractere_convertis$ = caractere$ ; j'enregistrer le caractere
        
      ElseIf converssion < Len(chaine$) And convertisseur = 1; sinon si c'est un caractère qui n'est ni au début ni a la fin de la chaine et que ya une lèttre a convertire
        caractere_convertis$ = Chr(34) + " + Chr(" + Str(ascii_caractere) + ") + " + Chr(34) ; je met un guillemet + chr(identifiant caractère) + ") + " + un autre guillemet
        
      EndIf
      
      caractere_convertis_precedent$ = caractere_convertis$
      converssion_chaine$ = converssion_chaine$ + caractere_convertis$
      
    Next
    
  EndIf
  
  Debug converssion_chaine$
  
  ; voici ce que sa donne
  Debug ""
  
EndProcedure

Global nombre_pour_lettre
Global lettre$
Global nombre

Procedure convertion_de_nombre_en_lettre(nombre)
  
  nombre_pour_lettre = nombre
  
  If nombre_pour_lettre = 1
    lettre$ = "a"
    
  ElseIf nombre_pour_lettre = 2
    lettre$ = "b"
    
  ElseIf nombre_pour_lettre = 3
    lettre$ = "c"
    
  ElseIf nombre_pour_lettre = 4
    lettre$ = "d"
    
  ElseIf nombre_pour_lettre = 5
    lettre$ = "e"
    
  ElseIf nombre_pour_lettre = 6
    lettre$ = "f"
    
  ElseIf nombre_pour_lettre = 7
    lettre$ = "g"
    
  ElseIf nombre_pour_lettre = 8
    lettre$ = "h"
    
  ElseIf nombre_pour_lettre = 9
    lettre$ = "i"
    
  ElseIf nombre_pour_lettre = 10
    lettre$ = "j"
    
  ElseIf nombre_pour_lettre = 11
    lettre$ = "k"
    
  ElseIf nombre_pour_lettre = 12
    lettre$ = "l"
    
  ElseIf nombre_pour_lettre = 13
    lettre$ = "m"
    
  ElseIf nombre_pour_lettre = 14
    lettre$ = "n"
    
  ElseIf nombre_pour_lettre = 15
    lettre$ = "o"
    
  ElseIf nombre_pour_lettre = 16
    lettre$ = "p"
    
  ElseIf nombre_pour_lettre = 17
    lettre$ = "q"
    
  ElseIf nombre_pour_lettre = 18
    lettre$ = "r"
    
  ElseIf nombre_pour_lettre = 19
    lettre$ = "s"
    
  ElseIf nombre_pour_lettre = 20
    lettre$ = "t"
    
  ElseIf nombre_pour_lettre = 21
    lettre$ = "u"
    
  ElseIf nombre_pour_lettre = 22
    lettre$ = "v"
    
  ElseIf nombre_pour_lettre = 23
    lettre$ = "w"
    
  ElseIf nombre_pour_lettre = 24
    lettre$ = "x"
    
  ElseIf nombre_pour_lettre = 25
    lettre$ = "y"
    
  ElseIf nombre_pour_lettre = 26
    lettre$ = "z"
    
  Else
    lettre$ = "?"
  EndIf
EndProcedure

Procedure convertion_de_lettre_en_nombre(lettre$)
  If lettre$ = "a"
    nombre_pour_lettre = 1
    
  ElseIf lettre$ = "b"
    nombre_pour_lettre = 2
    
  ElseIf lettre$ = "c"
    nombre_pour_lettre = 3
    
  ElseIf lettre$ = "d"
    nombre_pour_lettre = 4
    
  ElseIf lettre$ = "e"
    nombre_pour_lettre = 5
    
  ElseIf lettre$ = "f"
    nombre_pour_lettre = 6
    
  ElseIf lettre$ = "g"
    nombre_pour_lettre = 7
    
  ElseIf lettre$ = "h"
    nombre_pour_lettre = 8
    
  ElseIf lettre$ = "i"
    nombre_pour_lettre = 9
    
  ElseIf lettre$ = "j"
    nombre_pour_lettre = 10
    
  ElseIf lettre$ = "k"
    nombre_pour_lettre = 11
    
  ElseIf lettre$ = "l"
    nombre_pour_lettre = 12
    
  ElseIf lettre$ = "m"
    nombre_pour_lettre = 13
    
  ElseIf lettre$ = "n"
    nombre_pour_lettre = 14
    
  ElseIf lettre$ = "o"
    nombre_pour_lettre = 15
    
  ElseIf lettre$ = "p"
    nombre_pour_lettre = 16
    
  ElseIf lettre$ = "q"
    nombre_pour_lettre = 17
    
  ElseIf lettre$ = "r"
    nombre_pour_lettre = 18
    
  ElseIf lettre$ = "s"
    nombre_pour_lettre = 19
    
  ElseIf lettre$ = "t"
    nombre_pour_lettre = 20
    
  ElseIf lettre$ = "u"
    nombre_pour_lettre = 21
    
  ElseIf lettre$ = "v"
    nombre_pour_lettre = 22
    
  ElseIf lettre$ = "w"
    nombre_pour_lettre = 23
    
  ElseIf lettre$ = "x"
    nombre_pour_lettre = 24
    
  ElseIf lettre$ = "y"
    nombre_pour_lettre = 25
    
  ElseIf lettre$ = "z"
    nombre_pour_lettre = 26
    
  Else
    nombre_pour_lettre = 0
    
  EndIf
  
  nombre = nombre_pour_lettre
  
EndProcedure

Procedure.s InverserChaine(Chaine.s)
  Protected Phrase.s = "", Premier = 1
  
  For i = CountString(Chaine, " ") + 1 To 1 Step - 1
    If Premier = 0
      Phrase + " "
    Else
      Premier = 0
    EndIf
    Phrase + StringField(Chaine, i, " ")
  Next
  
  ProcedureReturn Phrase
EndProcedure

Procedure.s ReplaceAccents(Chaine$)
  
  Chaine$=LCase(Chaine$) ; On passe tout en min histoire que ce soit propre et que le ReplaceString() dure 2 x moins longtemps
  CharToFind.s="àáâãäåßçèéêëìíîïñòóôõöÞùúûüýÿ"
  CharToReplace.s="aaaaaabceeeeiiiinooooopuuuuyy"
  
  For i = 1 To Len(CharToFind) 
    ReplaceString(Chaine$, Mid(CharToFind,i,1), Mid(CharToReplace,i,1),#PB_String_InPlace, 1)
  Next
  
  ; vérif pour les caractères spéciaux passant de 1 à 2 caractères
  Chaine$ = ReplaceString(Chaine$, "œ", "oe")
  Chaine$ = ReplaceString(Chaine$, "æ", "ae")
  
  ProcedureReturn Chaine$
EndProcedure

Procedure.s TrimStringPlus(Chaine$, CaractereTrim$, Option)
  
  If option = 1 Or option = 3
    For TrimPlus = 1 To Len(Chaine$)
      
      ChaineCaractere$ = Mid(Chaine$, TrimPlus, 1)
      
      For Index = 1 To CountString(CaractereTrim$, "|")
        VerificationCaractere$ = StringField(CaractereTrim$, Index, "|")
        
        If VerificationCaractere$ = ChaineCaractere$
          Trouver = 1
          Break
        Else
          Trouver = 0
        EndIf
        
      Next
      
      If Trouver = 1
        
      Else
        ResultaTrimPlus$ = Mid(Chaine$, TrimPlus)
        Break
      EndIf
      
    Next
    
  EndIf
  
  If ResultaTrimPlus$ > ""
    Chaine$ = ResultaTrimPlus$
  EndIf
  
  If option = 2 Or option = 3
    
    For TrimPlus = Len(Chaine$) To 1 Step - 1
      
      ChaineCaractere$ = Mid(Chaine$, TrimPlus, 1)
      
      For Index = CountString(CaractereTrim$, "|") To 1 Step - 1
        
        VerificationCaractere$ = StringField(CaractereTrim$, Index, "|")
        
        If VerificationCaractere$ = ChaineCaractere$
          Trouver = 1
          Break
        Else
          Trouver = 0
        EndIf
        
      Next
      
      If Trouver = 1
        
      Else
        ResultaTrimPlus$ = Mid(Chaine$, 1, TrimPlus)
        Break
      EndIf
      
    Next
  EndIf
  
  ProcedureReturn ResultaTrimPlus$
EndProcedure

Procedure.l IsNumerique(Chaine$)
  
  If Not Chaine$ Or Chaine$ = "."
    ProcedureReturn #False
  EndIf
  
  For Caractere = 0 To 255
    
    Select Caractere
        
      Case 0 To 45, 47, 58 To 255
        
        If FindString(Chaine$, Chr(Caractere), 1)
          ProcedureReturn #False
        EndIf
        
    EndSelect
    
  Next
  
  If CountString(Chaine$, ".") > 1 
    ProcedureReturn #False
  EndIf
  
  ProcedureReturn #True
EndProcedure

Procedure.l nom_variable_numerique(nom_variable_numerique$)
  
  longueur_nom_variable = Len(nom_variable_numerique$)
  
  For veriffication = 1 To longueur_nom_variable
    
    extraction$ = Mid(nom_variable_numerique$, veriffication, 1)
    
    If veriffication = 1
      If extraction$ = "0" Or extraction$ = "1" Or extraction$ = "2"Or extraction$ = "3"Or extraction$ = "4"Or extraction$ = "5" Or extraction$ = "6"Or extraction$ = "7"Or extraction$ = "8"Or extraction$ = "9"
        MessageRequester("erreur !", "attention erreur !,  le nom de la variable numérique n'est pas valide      " + Chr(13) + "       le nom d'une variable ne peut pas commancer par un chiffre", 48)
        ProcedureReturn 0
      EndIf
    EndIf
    
    If extraction$ = "a" Or extraction$ = "b" Or extraction$ = "c" Or extraction$ = "d" Or extraction$ = "e" Or extraction$ = "f" Or extraction$ = "g" Or extraction$ = "h" Or extraction$ = "i" Or extraction$ = "j" Or extraction$ = "k" Or extraction$ = "l" Or extraction$ = "m" Or extraction$ = "n" Or extraction$ = "o" Or extraction$ = "p" Or extraction$ = "q" Or extraction$ = "r" Or extraction$ = "s" Or extraction$ = "t" Or extraction$ = "u" Or extraction$ = "v" Or extraction$ = "w" Or extraction$ = "x" Or extraction$ = "y" Or extraction$ = "z"
      
    ElseIf extraction$ = "A" Or extraction$ = "B" Or extraction$ = "C" Or extraction$ = "D" Or extraction$ = "E" Or extraction$ = "F" Or extraction$ = "G" Or extraction$ = "H" Or extraction$ = "I" Or extraction$ = "J" Or extraction$ = "K" Or extraction$ = "L" Or extraction$ = "M" Or extraction$ = "N" Or extraction$ = "O" Or extraction$ = "P" Or extraction$ = "Q" Or extraction$ = "R" Or extraction$ = "S" Or extraction$ = "T" Or extraction$ = "U" Or extraction$ = "V" Or extraction$ = "W" Or extraction$ = "X" Or extraction$ = "Y" Or extraction$ = "Z"
      
    ElseIf extraction$ = "0" Or extraction$ = "1" Or extraction$ = "2"Or extraction$ = "3"Or extraction$ = "4"Or extraction$ = "5" Or extraction$ = "6"Or extraction$ = "7"Or extraction$ = "8"Or extraction$ = "9"
      
    ElseIf extraction$ = "_"
      
    Else
      MessageRequester("erreur !", "attention erreur !,  le nom de la variable numérique n'est pas valide      " + Chr(13) + "                            caractère invalide a la position " + Str(veriffication), 48)
      ProcedureReturn 0
    EndIf
    
    nom_de_la_variable_numerique$ = nom_de_la_variable_numerique$ + extraction$
    
  Next
  ProcedureReturn 1
EndProcedure

Procedure.l nom_variable_alpha_numerique(nom_variable_alpha_numerique$)
  
  longueur_nom_variable = Len(nom_variable_alpha_numerique$)
  
  For veriffication = 1 To longueur_nom_variable
    
    extraction$ = Mid(nom_variable_alpha_numerique$, veriffication, 1)
    
    If veriffication = 1
      If extraction$ = "0" Or extraction$ = "1" Or extraction$ = "2"Or extraction$ = "3"Or extraction$ = "4"Or extraction$ = "5" Or extraction$ = "6"Or extraction$ = "7"Or extraction$ = "8"Or extraction$ = "9"
        MessageRequester("erreur !", "attention erreur !,  le nom de la variable alpha_numérique n'est pas valide  " + Chr(13) + "            le nom d'une variable ne peut pas commancer par un chiffre", 48)
        ProcedureReturn 0
      EndIf
    EndIf
    
    If veriffication <> longueur_nom_variable
      If extraction$ = "$" 
        MessageRequester("erreur !", "attention erreur !,  le nom de la variable alpha_numérique n'est pas valide" + Chr(13) + "                            caractère invalide a la position " + Str(veriffication), 48)
        ProcedureReturn 0
      EndIf
    EndIf
    
    If veriffication = longueur_nom_variable
      If extraction$ <> "$" 
        MessageRequester("erreur !", " attention erreur !,  le nom de la variable alpha_numérique n'est pas valide      " + Chr(13) + "              le nom de la variable alpha-numérique doit impérativement" + Chr(13) +  "                              ce tèrminer par le caractère suivent:   $", 48)
        ProcedureReturn 0
      EndIf
    EndIf
    
    If extraction$ = "a" Or extraction$ = "b" Or extraction$ = "c" Or extraction$ = "d" Or extraction$ = "e" Or extraction$ = "f" Or extraction$ = "g" Or extraction$ = "h" Or extraction$ = "i" Or extraction$ = "j" Or extraction$ = "k" Or extraction$ = "l" Or extraction$ = "m" Or extraction$ = "n" Or extraction$ = "o" Or extraction$ = "p" Or extraction$ = "q" Or extraction$ = "r" Or extraction$ = "s" Or extraction$ = "t" Or extraction$ = "u" Or extraction$ = "v" Or extraction$ = "w" Or extraction$ = "x" Or extraction$ = "y" Or extraction$ = "z"
      
    ElseIf extraction$ = "A" Or extraction$ = "B" Or extraction$ = "C" Or extraction$ = "D" Or extraction$ = "E" Or extraction$ = "F" Or extraction$ = "G" Or extraction$ = "H" Or extraction$ = "I" Or extraction$ = "J" Or extraction$ = "K" Or extraction$ = "L" Or extraction$ = "M" Or extraction$ = "N" Or extraction$ = "O" Or extraction$ = "P" Or extraction$ = "Q" Or extraction$ = "R" Or extraction$ = "S" Or extraction$ = "T" Or extraction$ = "U" Or extraction$ = "V" Or extraction$ = "W" Or extraction$ = "X" Or extraction$ = "Y" Or extraction$ = "Z"
      
    ElseIf extraction$ = "0" Or extraction$ = "1" Or extraction$ = "2"Or extraction$ = "3"Or extraction$ = "4"Or extraction$ = "5" Or extraction$ = "6"Or extraction$ = "7"Or extraction$ = "8"Or extraction$ = "9"
      
    ElseIf extraction$ = "_" Or extraction$ = "$"
      
    Else
      MessageRequester("erreur !", "attention erreur !,  le nom de la variable alpha_numérique n'est pas valide" + Chr(13) + "                            caractère invalide a la position " + Str(veriffication), 48)
      ProcedureReturn 0
    EndIf
    
    nom_de_la_variable_alpha_numerique$ = nom_de_la_variable_alpha_numerique$ + extraction$
    
  Next
  ProcedureReturn 1
EndProcedure

Procedure.l nom_constante(nom_constante$)
  
  longueur_nom_constante = Len(nom_constante$)
  
  For veriffication = 1 To longueur_nom_constante
    
    extraction$ = Mid(nom_constante$, veriffication, 1)
    
    If veriffication = 1
      If extraction$ <> "#"
        MessageRequester("erreur !", "attention erreur !,  le nom de la constante n'est pas valide    " + Chr(13) + Chr(13) + "            le nom d'une constante doit impérativement" + Chr(13) + "               commancer par le caractère suivent:  #", 48)
        ProcedureReturn 0
      EndIf
    EndIf
    
    If veriffication = 2
      If extraction$ = "0" Or extraction$ = "1" Or extraction$ = "2"Or extraction$ = "3"Or extraction$ = "4"Or extraction$ = "5" Or extraction$ = "6"Or extraction$ = "7"Or extraction$ = "8"Or extraction$ = "9"
        MessageRequester("erreur !", "    attention erreur !,  le nom de la constante n'est pas valide  " + Chr(13) + " le nom d'une constante ne peut pas commancer par un chiffre      ", 48)
        ProcedureReturn 0
      EndIf
    EndIf
    
    If veriffication > 1
      If extraction$ = "#" 
        MessageRequester("erreur !", "attention erreur !,  le nom de la constante n'est pas valide" + Chr(13) + "                    caractère invalide a la position " + Str(veriffication), 48)
        ProcedureReturn 0
      EndIf
    EndIf
    
    If extraction$ = "a" Or extraction$ = "b" Or extraction$ = "c" Or extraction$ = "d" Or extraction$ = "e" Or extraction$ = "f" Or extraction$ = "g" Or extraction$ = "h" Or extraction$ = "i" Or extraction$ = "j" Or extraction$ = "k" Or extraction$ = "l" Or extraction$ = "m" Or extraction$ = "n" Or extraction$ = "o" Or extraction$ = "p" Or extraction$ = "q" Or extraction$ = "r" Or extraction$ = "s" Or extraction$ = "t" Or extraction$ = "u" Or extraction$ = "v" Or extraction$ = "w" Or extraction$ = "x" Or extraction$ = "y" Or extraction$ = "z"
      
    ElseIf extraction$ = "A" Or extraction$ = "B" Or extraction$ = "C" Or extraction$ = "D" Or extraction$ = "E" Or extraction$ = "F" Or extraction$ = "G" Or extraction$ = "H" Or extraction$ = "I" Or extraction$ = "J" Or extraction$ = "K" Or extraction$ = "L" Or extraction$ = "M" Or extraction$ = "N" Or extraction$ = "O" Or extraction$ = "P" Or extraction$ = "Q" Or extraction$ = "R" Or extraction$ = "S" Or extraction$ = "T" Or extraction$ = "U" Or extraction$ = "V" Or extraction$ = "W" Or extraction$ = "X" Or extraction$ = "Y" Or extraction$ = "Z"
      
    ElseIf extraction$ = "0" Or extraction$ = "1" Or extraction$ = "2"Or extraction$ = "3"Or extraction$ = "4"Or extraction$ = "5" Or extraction$ = "6"Or extraction$ = "7"Or extraction$ = "8"Or extraction$ = "9"
      
    ElseIf extraction$ = "_" Or extraction$ = "#"
      
    Else
      MessageRequester("erreur !", "attention erreur !,  le nom de la constante n'est pas valide" + Chr(13) + "                    caractère invalide a la position " + Str(veriffication), 48)
      ProcedureReturn 0
    EndIf
    
    nom_de_la_constante$ = nom_de_la_constante$ + extraction$
    
  Next
  ProcedureReturn 1
EndProcedure

Procedure.l veriffication_valeur(valeur$)
  
  longueur_valeur = Len(valeur$)
  position = 0
  
  premier_caracter_valeur$ = Mid(valeur$, 1, 1)
  
  If premier_caracter_valeur$ = "-"
    position + 1
    If longueur_valeur = 1
      MessageRequester("Attention, cette valeur est incorecte " + location$ + " !", "      il vous faut entrez des chiffre après l'oppérateur négatif ici !", 48)
      ProcedureReturn 0
    EndIf
  Else
    position + 0
  EndIf
  
  For veriffication = 1 To longueur_valeur
    position + 1
    caractere$ = Mid(valeur$, position, 1)
    
    If caractere$ <> "0" And caractere$ <> "1" And caractere$ <> "2" And caractere$ <> "3" And caractere$ <> "4" And caractere$ <> "5" And caractere$ <> "6" And caractere$ <> "7" And caractere$ <> "8" And caractere$ <> "9" And caractere$ <> "."  And caractere$ <> ""
      MessageRequester("Attention, cette valeur est incorecte " + location$ + " !", "      vous ne pouvez entrez que des chiffre ici !", 48)
      ProcedureReturn 0
    EndIf
    
  Next
  
  nombre_de_points = CountString(valeur$, ".")
  
  If nombre_de_points > 1
    MessageRequester("Attention, cette valeur est incorecte " + location$ + " !", "      vous ne pouvez entrez qu'une seule virgule a la fois !", 48)
    ProcedureReturn 0
  EndIf
  
  position_du_point = FindString(valeur$, ".", 1)
  
  If position_du_point > 0
    If longueur_valeur > 21
      MessageRequester("Attention, le nombre de chiffres est trop grand !", "      vous ne pouvez pas dépassez:    21 chiffres (virgule incluse)", 48)
    EndIf
  EndIf
  
  nombre_de_decimale_apres_le_point = longueur_valeur - position_du_point
  valeurs.d = ValD(valeur$)
  valeur$ = StrD(valeur.f, nombre_de_decimale_apres_le_point)
  
  If valeurs.d > 999999999999999999
    MessageRequester("Attention, cette valeur est trop grande !", "      vous ne pouvez pas dépassez:    999 999 999 999 999 999", 48)
  ElseIf valeurs.d < -999999999999999999
    MessageRequester("Attention, cette valeur est trop petite !", "      vous ne pouvez pas dépassez:    -999 999 999 999 999 999", 48)
  EndIf
  
  ProcedureReturn 1
EndProcedure

Procedure.s determination_valeur(valeur$)
  premier_caractere_valeur_$ = Mid(valeur$, 1, 1)
  If premier_caractere_valeur_$ = "0" Or premier_caractere_valeur_$ = "1" Or premier_caractere_valeur_$ = "2" Or premier_caractere_valeur_$ = "3" Or premier_caractere_valeur_$ = "4" Or premier_caractere_valeur_$ = "5" Or premier_caractere_valeur_$ = "6" Or premier_caractere_valeur_$ = "7" Or premier_caractere_valeur_$ = "8" Or premier_caractere_valeur_$ = "9" Or premier_caractere_valeur_$ = "." Or premier_caractere_valeur_$ = "-"
    ; c'est une valeur
    ProcedureReturn "c'est une valeur"
  Else
    If valeur$ > ""
      ; c'est une variable
      ProcedureReturn "c'est une variable"
    Else
      ProcedureReturn "il n'y à aucune valeur"
    EndIf
  EndIf
EndProcedure

Procedure.s determination_type_variable(variable$)
  If FindString(variable$, "$", 1)
    ProcedureReturn "c'est une variable alpha-numérique"
  ElseIf FindString(variable$, "#", 1)
    ProcedureReturn "c'est une constante"
  ElseIf Not FindString(variable$, "$", 1) And Not FindString(variable$, "#", 1)
    ProcedureReturn "c'est une variable numérique"
  EndIf
EndProcedure

Procedure.s determination_type_valeur(valeur$)
  extraction_premier_caractere_valeur$ = Mid(valeur$, 1, 1)
  If extraction_premier_caractere_valeur$ = "-"
    If FindString(valeur$, ".", 1)
      ProcedureReturn "c'est une valeur négative a virgule"
    Else
      ProcedureReturn "c'est une valeur négative entière"
    EndIf
  ElseIf extraction_premier_caractere_valeur$ = "."
    ProcedureReturn "c'est une valeur a virgule positive"
  Else
    If FindString(valeur$, ".", 1)
      ProcedureReturn "c'est une valeur positive a virgule"
    Else
      ProcedureReturn "c'est une valeur positive entière"
    EndIf
  EndIf
EndProcedure

Procedure.l compare_chaine(chaine_1$, chaine_2$, parametre)
  
  ; la comparaison ce fait toujour de la gauche vers la droite
  ; par defaut, le paramètre est = à 0 = respecter la case
  
  ; -1 = chaine 1 plus petite que chaine 2
  ; 0 = les deux chaine sont identique
  ; 1 = chaine 2 plus petite que chaine 1
  
  If parametre = 0 ; respecter la case
    
    If chaine_1$ = chaine_2$
      ProcedureReturn 0
      
    ElseIf chaine_1$ > chaine_2$
      ProcedureReturn 1
      
    ElseIf  chaine_1$ < chaine_2$
      ProcedureReturn -1
      
    EndIf
    
  ElseIf parametre = 1 ; ne pas respecter la case
    
    chaine_1$ = LCase(chaine_1$) 
    chaine_2$ = LCase(chaine_2$) 
    
    If chaine_1$ = chaine_2$
      ProcedureReturn 0
      
    ElseIf chaine_1$ > chaine_2$
      ProcedureReturn 1
      
    ElseIf  chaine_1$ < chaine_2$
      ProcedureReturn -1
      
    EndIf
    
  ElseIf parametre = 2
    
  Else
    
  EndIf
  
EndProcedure

Global convertion_nombre
Global convertion_nombre
Global nombre_aleatoire

Procedure convertion_positif(nombre)
  convertion_nombre = nombre - nombre - nombre
EndProcedure

Procedure convertion_negatif(nombre)
  convertion_nombre = nombre - nombre - nombre
EndProcedure

Procedure nombre_aleatoire_traitement(convertion_nombre_minimome, convertion_nombre_maximome)
  nombre = convertion_nombre_maximome - convertion_nombre_minimome
  nombre_aleatoire = Random(nombre)
  nombre_aleatoire + convertion_nombre_minimome
EndProcedure

Procedure.l nombre_aleatoire(nombre_minimome, nombre_maximome)
  
  ; crée un nombre aléatoire entre X et X
  
  ; 
  ;   sintax:
  ;   
  ;   nombre_aleatoire(nombre_minimome, nombre_maximome)
  ;   
  ;   
  ;   exemple:
  ;   
  ;   nombre_aleatoire(0, 1000) ; résulta = aléatoire entre 0 et 1000
  ;   
  ;   nombre_aleatoire(-100, 100) ; résulta = aléatoire entre -100 et 100
  ;   
  ;   nombre_aleatoire(0, 0) ; résulta = 0
  ;   
  ;   nombre_aleatoire(-50, -10) ; résulta = 0
  ;   
  ;   
  ;   
  ;   si le résulta donne 0 comme dans les deux dernier exemple
  ;   c'est tout simplement parceque soie le nombre aléatoire doigt:
  ;   
  ;   {1} être choisie entre 0 et 0 = 0
  ;   {2} être choisie entre un nombre minimome plus grand que 
  ;       le maximome ce qui n'est pas possible, ce qui donne 0
  ;   
  
  creation_du_nombre_aleatoire:
  
  If nombre_minimome < 0 And nombre_maximome < 0
    
    If nombre_minimome > nombre_maximome
      
      convertion_positif(nombre_minimome)
      convertion_nombre_minimome = convertion_nombre
      
      convertion_positif(nombre_maximome)
      convertion_nombre_maximome = convertion_nombre
      
      nombre_aleatoire_traitement(convertion_nombre_minimome, convertion_nombre_maximome)
      
      convertion_negatif(nombre_aleatoire)
      nombre_aleatoire = convertion_nombre
      
    ElseIf nombre_maximom < nombre_minimome
      nombre_aleatoire = 0
    EndIf
    
  ElseIf nombre_minimome > 0 And nombre_maximome < 0
    nombre_aleatoire = 0
    
  ElseIf nombre_minimome < 0 And nombre_maximome > 0
    
    convertion_positif(nombre_minimome)
    convertion_nombre_minimome = convertion_nombre
    
    nombre_aleatoire_A = Random(convertion_nombre_minimome)
    
    convertion_negatif(nombre_aleatoire_A)
    convertion_nombre_minimome = convertion_nombre
    
    nombre_aleatoire_A = convertion_nombre_minimome
    
    nombre_aleatoire_B = Random(nombre_maximome)
    
    retry:
    nombre_posotif_ou_negatif = Random(2)
    
    If nombre_posotif_ou_negatif = 1
      nombre_aleatoire = nombre_aleatoire_B
    ElseIf nombre_posotif_ou_negatif = 2
      nombre_aleatoire = nombre_aleatoire_A
    Else
      nombre_aleatoire = nombre_aleatoire_B
    EndIf
    
  ElseIf nombre_minimome > 0 And nombre_maximome > 0
    
    If nombre_minimome < nombre_maximome
      nombre_aleatoire_traitement(nombre_minimome, nombre_maximome)
    ElseIf nombre_maximome < nombre_minimome
      nombre_aleatoire = 0
    EndIf
    
  ElseIf nombre_minimome = 0 And nombre_maximome = 0
    
  EndIf
  
  ProcedureReturn nombre_aleatoire
  
EndProcedure

Global lettre_minimome$
Global lettre_maximome$
Global Valeur_numerique_alphabetique_lettre_minimome
Global Valeur_numerique_alphabetique_lettre_maximome
Global lettre_aleatoire
Global lettre_aleatoire$

Procedure lettre_aleatoire(lettre_minimome$, lettre_maximome$)
  
  ; sintax:
  ;   
  ;   lettre_aleatoire(lettre_minimome$, lettre_maximome$)
  ;   
  ;   
  ;   exemple:
  ;   
  ;   lettre_aleatoire("a", "z") ; résulta = aléatoire entre lettre A et Z
  ;   
  ;   lettre_aleatoire("g", "k") ; résulta = aléatoire entre lettre G et K
  ;   
  ;   lettre_aleatoire("z", "a") ; résulta = ?
  ;   
  ;   lettre_aleatoire("d", "d") ; résulta = lettre D
  ; 
  ;   lettre_aleatoire("", "") ; résulta = 
  ;   
  ;   
  ;   si le résulta donne ? comme dans le troisième exemple
  ;   c'est tout simplement parceque soie la lèttre aléatoire doigt
  ;   être choisie entre une lèttre minimome plus grand que 
  ;   la lèttre maximome ce qui n'est pas possible, ce qui donne donc:  ?
  
  longueur_lettre_minimome = Len(lettre_minimome$)
  longueur_lettre_maximome = Len(lettre_maximome$)
  
  If longueur_lettre_minimome > 1
    lettre_aleatoire$ = ""
  ElseIf longueur_lettre_maximome > 1
    lettre_aleatoire$ = ""
  EndIf
  
  Valeur_ASCII_lettre_minimome = Asc(LCase(lettre_minimome$))
  Valeur_ASCII_lettre_maximome = Asc(LCase(lettre_maximome$))
  
  If Valeur_ASCII_lettre_minimome > Valeur_ASCII_lettre_maximome
    lettre_aleatoire = 0
    Goto fin
  EndIf
  
  Valeur_numerique_lettre_minimome = Valeur_ASCII_lettre_minimome
  Valeur_numerique_lettre_maximome = Valeur_ASCII_lettre_maximome
  
  Valeur_numerique_alphabetique_lettre_minimome = Valeur_numerique_lettre_minimome - 96
  Valeur_numerique_alphabetique_lettre_maximome = Valeur_numerique_lettre_maximome - 96
  
  lettre_aleatoire = Random(Valeur_numerique_alphabetique_lettre_maximome - Valeur_numerique_alphabetique_lettre_minimome)
  ;Debug lettre_aleatoire
  
  fin:
  If lettre_aleatoire < 0
    lettre_aleatoire = 0
  EndIf
  
  If lettre_aleatoire > 26
    lettre_aleatoire = 26
  EndIf
  
  lettre_aleatoire$ = Chr(96 + Valeur_numerique_alphabetique_lettre_maximome - lettre_aleatoire)
  
  If lettre_aleatoire$ = "`"
    lettre_aleatoire$ = "?"
  EndIf
  
EndProcedure

Procedure.s GetKeyboardKeyPressed(Mode)
  
;{ Aide
;-----------------------------------------------------------Pour le clavier:---------------------------------------------------------------------------------------------------------

; Le Mode peut être entre 1 et 5, sinon si différent de 1, 2, 3, 4 ou 5,  le mode 1 sera appliquer par défaut
;
; 1 = Renvoie uniquement le nom de la touche presser (Mode par défaut)
; 2 = Renvoie le nom ainsi que le code de la touche presser
; 3 = Renvoie le nom ainsi que le code de la touche presser sous la forme Hexa
; 4 = Renvoie uniquement le code de la touche presser
; 5 = Renvoie uniquement le code de la touche presser mais sous la forme Hexa

; Syntaxe:  Touche_presser$ = GetKeyboardKeyPressed(Mode)

; La commande doit être placer a l'intérieur d'une boucle quelconque pour fonctionner correctement
; ou sinon celle-ci sera exécuter qu'une seule fois et ne renverra rien sauf si une touche est déjà enfoncer

; Normalement, toutes les touches du clavier son gérer !

;---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
;}

  Buffer$ = ""
  
  For Touche = 0 To 254
    Cle_Touche = GetAsyncKeyState_(Touche)
    
    If Cle_Touche = - 32767
      
      Buffer$ + Str(Touche) + "|"
      
      
      If Touche > 64 And Touche < 91 ; de A à Z
        Touche$ = Chr(Touche)
        
        
      ElseIf Touche = 27
        Touche$ = "Echap"
        
        
      ElseIf Touche = 32
        Touche$ = "Espace"
        
        
      ElseIf Touche > 111 And Touche < 124 ; de F1 a F12
        Touche$ = "F" + Str(Touche - 111)
        
        
      ElseIf Touche = 44
        Touche$ = "Impr écran"
        
        
      ElseIf Touche = 45
        Touche$ = "Inser"
        
        
      ElseIf Touche = 46
        Touche$ = "Suppr"
        
        
      ElseIf Touche = 36
        Touche$ = "Flèche diagonnale haut gauche"
        
        
      ElseIf Touche = 35
        Touche$ = "Fin"
        
        
      ElseIf Touche = 19
        Touche$ = "Pause-Attn"
        
        
      ElseIf Touche = 145
        Touche$ = "Arrêt Défil"
        
        
      ElseIf Touche > 47 And Touche < 58 ; de 0 à 9
        Touche$ = Str(Touche - 48)
        
        
      ElseIf Touche > 95 And Touche < 106 ; pad numérique de 0 à 9
        Touche$ = "Pad " + Str(Touche - 96)
        
        
      ElseIf Touche = 222
        Touche$ = "²"
        
        
      ElseIf Touche = 219
        Touche$ = ")"
        
        
      ElseIf Touche = 187
        Touche$ = "="
        
        
      ElseIf Touche = 8
        Touche$ = "Retour arrière"
        
        
      ElseIf Touche = 9
        Touche$ = "Tabulation Horizontal"
        
        
      ElseIf Touche = 20
        Touche$ = "Majuscule Cadena"
        
        
      ElseIf Touche = 160
        Touche$ = "Majuscule flèche gauche"
        
        
      ElseIf Touche = 162
        Touche$ = "Ctrl gauche"
        
      ElseIf Touche = 91
        Touche$ = "Appel du menue de windows"
        
        
      ElseIf Touche = 93
        Touche$ = "Appel du menue de la souris"
        
        
      ElseIf Touche = 164
        Touche$ = "Alt"
        
        
      ElseIf Touche = 226
        Touche$ = ">"
        
        
      ElseIf Touche = 221
        Touche$ = "¨"
        
        
      ElseIf Touche = 186
        Touche$ = "$"
        
        
      ElseIf Touche = 192
        Touche$ = "ù"
        
        
      ElseIf Touche = 220
        Touche$ = "*"
        
        
      ElseIf Touche = 188
        Touche$ = ","
        
        
      ElseIf Touche = 190
        Touche$ = ";"
        
        
      ElseIf Touche = 191
        Touche$ = ":"
        
        
      ElseIf Touche = 223
        Touche$ = "!"
        
        
      ElseIf Touche = 161
        Touche$ = "Majuscule flèche droite"
        
        
      ElseIf Touche = 33
        Touche$ = "Flèche arrètte haut"
        
        
      ElseIf Touche = 34
        Touche$ = "Flèche arrètte bas"
        
        
      ElseIf Touche = 163
        Touche$ = "Ctrl droite"
        
        
      ElseIf Touche = 165
        Touche$ = "Alt Gr"
        
      ElseIf Touche = 37
        Touche$ = "Flèche gauche"
        
      ElseIf Touche = 38
        Touche$ = "Flèche haut"
        
      ElseIf Touche = 39
        Touche$ = "Flèche droite"
        
      ElseIf Touche = 40
        Touche$ = "Flèche bas"
        
      ElseIf Touche = 110
        Touche$ = "Pad Suppr"
        
      ElseIf Touche = 13
        Touche$ = "Entrer"
        
      ElseIf Touche = 106
        Touche$ = "Pad Multiplication"
        
      ElseIf Touche = 107
        Touche$ = "Pad Addition"
        
      ElseIf Touche = 109
        Touche$ = "Pad soustraction"
        
      ElseIf Touche = 111
        Touche$ = "Pad Division"
        
      ElseIf Touche = 144
        Touche$ = "Verr num"
        
      ElseIf Touche = 172
        Touche$ = "Internet"
        
      ElseIf Touche = 180
        Touche$ = "Mail"
        
      ElseIf Touche = 174
        
        
        Touche$ = "Sons -"
        
      ElseIf Touche = 175
        Touche$ = "Sons +"
        
      ElseIf Touche = 177
        Touche$ = "Lecture reculer"
        
      ElseIf Touche = 178
        Touche$ = "Lecture stop"
        
      ElseIf Touche = 179
        Touche$ = "Lecture / pause"
        
      ElseIf Touche = 176
        Touche$ = "Lecture avencer"
        
        
      EndIf
      
      If Touche <> 16 And Touche <> 17 And Touche <> 18 And Touche <> 1 And Touche <> 2 And Touche <> 4        
        If Buffer$ <> "17|18|162|"
          If Mode = 1
            Touche_presser$ = Touche$
          ElseIf Mode = 2
            Touche_presser$ =  Touche$ + " | " + Str(Touche)
          ElseIf Mode = 3
            Touche_presser$ =  Touche$ + " | " + "$" + RSet(Hex(Touche), 2, "0")
          ElseIf Mode = 4
            Touche_presser$ =  Str(Touche)
          ElseIf Mode = 5
            Touche_presser$ = "$" + RSet(Hex(Touche), 2, "0")
          Else
            Touche_presser$ = Touche$
          EndIf
        ElseIf Buffer$ = "17|18|162|"
          If Mode = 1
            Touche_presser$ = "Alt Gr"
          ElseIf Mode = 2
            Touche_presser$ =  "Alt Gr" + " | " + Str(165)
          ElseIf Mode = 3
            Touche_presser$ =  "Alt Gr" + " | " + "$" + RSet(Hex(165), 2, "0")
          ElseIf Mode = 4
            Touche_presser$ =  Str(165)
          ElseIf Mode = 5
            Touche_presser$ = "$" + RSet(Hex(165), 2, "0")
          Else
            Touche_presser$ = "Alt Gr"
          EndIf
        EndIf
      EndIf
      
    EndIf
    
  Next Touche
  
  ProcedureReturn Touche_presser$
EndProcedure

Procedure.s GetMouseKeyPressed(Mode)
  
  ;{ Aide
;---------------------------------------------------------------Pour la souris:-----------------------------------------------------------------------------------------------------

; Le Mode peut être entre 1 et 5, sinon si différent de 1, 2, 3, 4 ou 5,  le mode 1 sera appliquer par défaut
;
; 1 = Renvoie uniquement le nom du clique presser (Mode par défaut)
; 2 = Renvoie le nom ainsi que le code du clique presser
; 3 = Renvoie le nom ainsi que le code du clique presser sous la forme Hexa
; 4 = Renvoie uniquement le code du clique presser
; 5 = Renvoie uniquement le code du clique presser mais sous la forme Hexa

; Syntaxe:  Clique_Souris$ = GetMouseKeyPressed(Mode)

; La commande doit être placer a l'intérieur d'une boucle quelconque pour fonctionner correctement
; ou sinon celle-ci sera exécuter qu'une seule fois et ne renverra rien sauf si un clique est déjà enfoncer

; Normalement, la plupart des cliques de la souris son gérer, mais pas tous !

;---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
;}

  For Clique = 0 To 10
    Cle_Clique = GetAsyncKeyState_(Clique)
    
    If Cle_Clique = - 32767
      
      If Clique = 1
        Clique$ = "Clique droit"
        
      ElseIf Clique = 2
        Clique$ = "Clique gauche"
        
      ElseIf Clique = 4
        Clique$ = "Clique centre"
        
      ElseIf Clique = 5
        Clique$ = "Clique Précédent"
        
      ElseIf Clique = 6
        Clique$ = "Clique Suivent"
        
      EndIf
      
      If Mode = 1
        Clique_Souris$ = Clique$
        
      ElseIf Mode = 2
        Clique_Souris$ = Clique$ + " | " + Str(Clique)
        
      ElseIf Mode = 3
        Clique_Souris$ = Clique$ + " | " + "$" + RSet(Hex(Clique), 2, "0")
        
      ElseIf Mode = 4
        Clique_Souris$ = Str(Clique)
        
      ElseIf Mode = 5
        Clique_Souris$ = "$" + RSet(Hex(Clique), 2, "0")
        
      Else
        Clique_Souris$ = Clique$
      EndIf
      
    EndIf
    
  Next
  
  ProcedureReturn Clique_Souris$
EndProcedure

Procedure.s MidPlus(Chaine$, ChaineDepart$, Chainefin$, RespecterCase, PositionDepart, PositionFin, Longueur)
  
  ;{ Aide
  ; Chaine$ est la chaine de caractères
  
  ; ChaineDepart$ est la position d'extraction de départ qui sera définie par la recherche de la chaine qui se trouve 
  ; dans ChaineDepart$, si elle n'est pas trouvé ou si elle est vide
  ; ce paramètre est ignorer et PositionDepart sera alors utiliser par défaut
  
  ; La syntaxe est la suivante et doit impérativement être respecter: »Rechercher quoi»Nombre occurrence
  ; exemple: »abc»1
  
  ; Chainefin$ est la position d'extraction de fin qui sera définie par la recherche de la chaine qui se trouve 
  ; dans Chainefin$, si elle n'est pas trouvé ou si elle est vide
  ; ce paramètre est ignorer et PositionFin sera alors utiliser par défaut
  
  ; La syntaxe est la suivante et doit impérativement être respecter: »Rechercher quoi»Nombre occurrence
  ; exemple: »def»2
  
  ; RespecterCase est pour respecter la case l'or de la recherche
  ; si ce paramètre est inférieur a ou égale à 0, alors la case est ignorer, donc "A" et "a" sera traité de la même façon
  ; mais si ce paramètre est égale à 1 ou supérieur à 1, alors la case est pris en compte, donc "A" et "a" sera traité différemment
  
  ; PositionDepart est la position d'extraction de départ, si celle-ci est inférieur ou = à 0
  ; elle sera alors automatiquement mise à 1, sinon si celle-ci est supérieure à la longueur de la chaine
  ; elle sera alors automatiquement mise à longueur de la chaine
  ; ce paramètre est ignorer si ChaineDepart$ est définie et trouvé
  
  ; PositionFin est la position d'extraction de fin, si celle-ci est inférieur ou = à 0 ou supérieur à la longueur de la chaine
  ; elle sera alors automatiquement mise à longueur de la chaine
  ; ce paramètre est ignorer si Chainefin$ est définie et trouvé
  
  ; Longueur est le nombre de caractère à extraire
  ; ce paramètre est ignorer si Chainefin$ est définie et trouvé ou si PositionFin est supérieur à 0
  ;}
  
  SauvegardeChaine$ = Chaine$
  
  If RespecterCase <= 0
    Chaine$ = LCase(Chaine$)
    ChaineDepart$ = LCase(ChaineDepart$)
    Chainefin$ = LCase(Chainefin$)
  EndIf
  
  If ChaineDepart$ > ""
    
    ChaineDepart$ = Trim(ChaineDepart$)
    RechercherChaineDepart$ = StringField(ChaineDepart$, 2, "»")
    
    If RechercherChaineDepart$ = ""
      Debug "Erreur de syntax: La vraie syntaxt est: »Rechercher quoi»Nombre occurence"
      
    Else
      
      RechercherNombreOccurenceChaineDepart$ = StringField(ChaineDepart$, 3, "»")
      
      If RechercherNombreOccurenceChaineDepart$ = ""
        Debug "Erreur de syntax: La vraie syntaxt est: »Rechercher quoi»Nombre occurence"
      ElseIf RechercherNombreOccurenceChaineDepart$ = "0"
        Debug "Erreur de syntax: Nombre d'occurence doit être au moins = à 1 dans ChaineDepart$"
      Else
        RechercherNombreOccurenceChaineDepart = Val(RechercherNombreOccurenceChaineDepart$)
        If RechercherNombreOccurenceChaineDepart < 0 Or RechercherNombreOccurenceChaineDepart = 0
          Debug "Erreur de syntax: Nombre d'occurence doit être au moins = à 1 dans ChaineDepart$"
        EndIf
      EndIf
      
      NombreOccurence = CountString(Chaine$, RechercherChaineDepart$)
      
      If RechercherNombreOccurenceChaineDepart > NombreOccurence
        RechercherNombreOccurenceChaineDepart = NombreOccurence
      EndIf
      
      For RechercheOccurence = 1 To RechercherNombreOccurenceChaineDepart
        
        RechercheCaracterePositionDepart = FindString(Chaine$, RechercherChaineDepart$, RechercheCaracterePositionDepart + 1)
        
        If RechercheCaracterePositionDepart > 0
          PositionDepart = RechercheCaracterePositionDepart
        EndIf
        
      Next
      
    EndIf
    
  EndIf
  
  If Chainefin$ > ""
    
    If Chainefin$ = "" And PositionFin = 0
      PositionFin = Len(Chaine$) + 1
    EndIf
    
    Chainefin$ = Trim(Chainefin$)
    RechercherChainefin$ = StringField(Chainefin$, 2, "»")
    
    If RechercherChainefin$ = ""
      Debug "Erreur de syntax: La vraie syntaxt est: »Rechercher quoi»Nombre occurence"
      
    Else
      
      RechercherNombreOccurenceChainefin$ = StringField(Chainefin$, 3, "»")
      
      If RechercherNombreOccurenceChainefin$ = ""
        Debug "Erreur de syntax: La vraie syntaxt est: »Rechercher quoi»Nombre occurence"
      ElseIf RechercherNombreOccurenceChainefin$ = "0"
        Debug "Erreur de syntax: Nombre d'occurence doit être au moins = à 1 dans Chainefin$"
      Else
        RechercherNombreOccurenceChainefin = Val(RechercherNombreOccurenceChainefin$)
        If RechercherNombreOccurenceChainefin < 0 Or RechercherNombreOccurenceChainefin = 0
          Debug "Erreur de syntax: Nombre d'occurence doit être au moins = à 1 dans Chainefin$"
        EndIf
      EndIf
      
      NombreOccurence = CountString(Chaine$, RechercherChainefin$)
      
      If RechercherNombreOccurenceChainefin > NombreOccurence
        RechercherNombreOccurenceChainefin = NombreOccurence
      EndIf
      
      If ChaineDepart$ > ""
        RechercherNombreOccurenceChainefin + RechercherNombreOccurenceChaineDepart - 1
      EndIf
      
      If ChaineDepart$ > "" And Chainefin$ > "" And ChaineDepart$ = Chainefin$
        RechercherNombreOccurenceChainefin + RechercherNombreOccurenceChaineDepart
      EndIf
      
      For RechercheOccurence = 1 To RechercherNombreOccurenceChainefin
        RechercheCaracterePositionFin = FindString(Chaine$, RechercherChainefin$, RechercheCaracterePositionFin + 1)
        If RechercheCaracterePositionFin > 0
          PositionFin = RechercheCaracterePositionFin + 1
        EndIf
        
      Next
      
    EndIf
    
  EndIf
  
  If ChaineDepart$ > "" And Chainefin$ = ""
    PositionFin + RechercheCaracterePositionDepart
  EndIf
  
  If ChaineDepart$ > "" And Chainefin$ = "" And PositionFin = PositionDepart And longueur = 0
    PositionFin = Len(Chaine$) + 1
  EndIf
    
  If PositionDepart <= 0
    PositionDepart = 1
    
  ElseIf PositionDepart > Len(Chaine$)
    PositionDepart = Len(Chaine$)
    
  EndIf
  
  If PositionFin <= 0
    PositionFin = Len(Chaine$) + 1
    
  ElseIf PositionFin > Len(Chaine$)
    PositionFin = Len(Chaine$) + 1
    
  ElseIf Chainefin$ > ""
    Longueur = 0
  EndIf
  
  If Longueur < 0
    Longueur = 0
    
  ElseIf Longueur > Len(Chaine$)
    PositionDepart = Len(Chaine$)
    
  EndIf
  
  If PositionFin < PositionDepart
    PositionFin = PositionDepart
  EndIf
  
  If Longueur > 0
    MidPlus$ = Mid(SauvegardeChaine$, PositionDepart, Longueur)
    
  Else
    MidPlus$ = Mid(SauvegardeChaine$, PositionDepart, PositionFin - PositionDepart)
    
  EndIf
  
  ProcedureReturn MidPlus$
  
EndProcedure

jbernard13 · Message par **jbernard13** » mer. 25/mai/2011 15:16

erreur en ligne 771 : Procedure convertion_positif(nombre)

GallyHC · Message par **GallyHC** » mer. 25/mai/2011 16:01

Bonjour,

Je ne vois pas trop l'interrer de faire deux fonction identique. Une ce nomme "convertion_positif" et l'autre "convertion_negatif" et les deux fonctions sont identique dans le code.

Code : Tout sélectionner

Procedure.l convertion_positif(nombre)
  convertion_nombre = nombre - nombre - nombre
  ProcedureReturn convertion_nombre
EndProcedure

Procedure.l convertion_negatif(nombre)
  convertion_nombre = nombre - nombre - nombre
  ProcedureReturn convertion_nombre
EndProcedure

faudrais en faire une seul avec "convertion_positifnegatif()".

Code : Tout sélectionner

Procedure.l convertion_positifnegatif(nombre)
  convertion_nombre = nombre - nombre - nombre
  ProcedureReturn convertion_nombre
EndProcedure

c'est que j'ai vu en regardans que les premiere lignes de ton code.

Cordialement,

graph100 · Message par **graph100** » mer. 25/mai/2011 16:06

Perso je vois pas l’intérêt de faire une fonction ConversionPositifNegatif(), ça ne fait que ralentir ton code

Code : Tout sélectionner

Procedure.l convertion_positifnegatif(nombre)
	convertion_nombre = nombre - nombre - nombre
	ProcedureReturn convertion_nombre
EndProcedure

un peu de math a écrit :x - x = 0
x - x - x = -x

pourquoi tu ne fais pas

Code : Tout sélectionner

-(expression numérique)

tout simplement ?

bombseb · Message par **bombseb** » mer. 25/mai/2011 17:42

Dayvid, tu devrais postuler chez microsoft, ils auraient surement du boulot pour toi sur le framework .net

Le Soldat Inconnu · Message par **Le Soldat Inconnu** » mer. 25/mai/2011 20:04

Même remarque que Graph100

la procedure convertion_positif(nombre) ne sert strictement à rien.

au lieu d'écrire
A + convertion_positif(B), il suffit de mettre A - B

Si le but était d'avoir un nombre obligatoirement positif ou négatif par contre, ta solution n'est pas bonne

Code : Tout sélectionner

Procedure Positif(Nombre.l)
	If Nombre < 0
		Nombre = -Nombre
	EndIf
	ProcedureReturn Nombre
EndProcedure

Procedure Negatif(Nombre.l)
	If Nombre > 0
		Nombre = -Nombre
	EndIf
	ProcedureReturn Nombre
EndProcedure

Debug Positif(-1)
Debug Positif(-1457)
Debug Positif(8)
Debug Positif(-547899)
Debug ""
Debug Negatif(1)
Debug Negatif(1457)
Debug Negatif(8)
Debug Negatif(-547899)

boddhi · Message par **boddhi** » mer. 25/mai/2011 20:08

@Dayvid

Je sais ne pas être le premier (ni probablement le dernier) à te le dire mais tu DOIS absolument tenir compte des conseils qui te sont donnés !
Surtout si tu veux progresser comme tu le claironnes si souvent...
Ton code est trop long et limite rébarbatif à examiner...

En la matière, il n'y pas de règle unique, si ce n'est celle d'essayer d'optimiser au maximum son code, chacun faisant, en effet, en fonction de ses connaissances.

2 exemples d'optimisations possibles dans ton code :

Le contrôle des caractères d'une chaîne sensée être numérique : Tout cet étalage de code pourrait être remplacée par deux ou trois lignes de codes faisant appel aux fonctions liées aux expressions régulières.
Une bonne partie de tes tests If...ElseIf...EndIf pourrait être remplacée par des blocs Select...Case...EndSelect... : Ce conseil t'a d'ailleurs été donné très très récemment sur un autre topic !!!!

Tu y gagnerais indéniablement en temps et, qui plus est, en lisibilité.

Demander des conseils aux uns et aux autres implique, à minima, le respect de ceux qui te sont prodigués ! Non ?

boddhi · Message par **boddhi** » mer. 25/mai/2011 20:29

Un exemple pour tester la régularité d'une chaîne "exclusivement" numérique

Code : Tout sélectionner

Procedure TestChaineNombre(Chaine.s)
  If CreateRegularExpression(0, "^[-+]?\d*[.,]?\d*$")
    If MatchRegularExpression(0, Chaine)
      Debug Chaine+" => La chaine est un nombre !"
    Else
      Debug Chaine+" => La chaine n'est pas un nombre !"
    EndIf
  Else
    Debug RegularExpressionError()
  EndIf
EndProcedure

TestChaineNombre("12345")
TestChaineNombre("12345.56")
TestChaineNombre("-12345.56")
TestChaineNombre("+12345.56")
TestChaineNombre("12345,56")
TestChaineNombre("1a235")
TestChaineNombre("aaaaaaa")

Edit : Ajout du séparateur décimal 'virgule' comme possibilité

jbernard13 · Message par **jbernard13** » mer. 25/mai/2011 21:21

bombseb a écrit :Dayvid, tu devrais postuler chez microsoft, ils auraient surement du boulot pour toi sur le framework .net

boddhi · Message par **boddhi** » jeu. 26/mai/2011 9:37

Un exemple d'optimisation de ton traitement des caractères accentués :

Code : Tout sélectionner

Procedure.s Fc_ConversionCaractereAccentue(Chaine.s)
  Select Asc(Chaine)
    Case 192 To 197
      ProcedureReturn "A"
    Case 199
      ProcedureReturn "C"
    Case 200 To 203
      ProcedureReturn "E"
    Case 204 To 207
      ProcedureReturn "I"
    Case 209
      ProcedureReturn "N"
    Case 210 To 214
      ProcedureReturn "O"
    Case 217 To 220
      ProcedureReturn "U"
    Case 221
      ProcedureReturn "Y"
    Case 224 To 229
      ProcedureReturn "a"
    Case 231 
      ProcedureReturn "c"
    Case 232 To 235
      ProcedureReturn "e"
    Case 236 To 239
      ProcedureReturn "i"
    Case 241 
      ProcedureReturn "n"
    Case 242 To 246
      ProcedureReturn "o"
    Case 249 To 252
      ProcedureReturn "u"
    Case 253,255
      ProcedureReturn "y"
    Default
      ProcedureReturn Chaine
  EndSelect
EndProcedure

Procedure.s Fc_ConversionChaine(Chaine.s)
  Define.s ChaineRetour,Caractere
  LongChaine.i=Len(Chaine)
  For Compteur=1 To LongChaine
    Caractere=Mid(Chaine,Compteur,1)
    If Asc(Caractere)>=192
      Caractere=Fc_ConversionCaractereAccentue(Caractere)
    EndIf
    ChaineRetour+Caractere
  Next
  ProcedureReturn ChaineRetour
EndProcedure

Procedure.s Fc_TraitementChaine(Chaine.s)
  If Chaine<>""
    Chaine=Fc_ConversionChaine(Chaine)
    If Left(Chaine,1)<>Chr(34)
      Chaine=Chr(34)+Chaine
    EndIf
    If Right(Chaine,1)<>Chr(34)
      Chaine+Chr(34)
    EndIf
  EndIf
  ProcedureReturn Chaine
EndProcedure

Debug Fc_TraitementChaine("ÀÁÂÃÄÅÇÈÉÊËÌÍÎÏÑÒÓÔÕÖÙÚÛÜÝàáâãäåçèéêëìíîïðñòóôõöùúûüýÿ")
Debug Fc_TraitementChaine("Du jour où je parvins à me persuader que je n'avais pas besoin d'être heureux,")
Debug Fc_TraitementChaine("commença d'habiter en moi le bonheur ; oui, du jour où je me persuadai que je n'avais besoin de rien ")
Debug Fc_TraitementChaine("pour être heureux. Il semblait, après avoir donné le coup de pioche à l'égoïsme, ")
Debug Fc_TraitementChaine("que j'avais fait jaillir aussitôt de mon coeur une telle abondance de joie que j'en pusse abreuver ")
Debug Fc_TraitementChaine("tous les autres. Je compris que le meilleur enseignement est d'exemple. j'assumai mon bonheur comme ")
Debug Fc_TraitementChaine("une vocation.  André GIDE")

falsam · Message par **falsam** » jeu. 26/mai/2011 11:13

Même résultat avec ce code

Code : Tout sélectionner

Procedure.s Fc_TraitementChaine(Buffer.s)
  Protected i
  Protected CharToFind.s="àáâãäåçèéêëìíîïñòóôõöùúûüýÿÀÁÂÃÄÅÇÈÉÊËÌÍÎÏÑÒÓÔÕÖÙÚÛÜÝŸ"
  Protected CharToReplace.s="aaaaaaceeeeiiiinooooouuuuyyAAAAAACEEEEIIIINOOOOOUUUUYY"

  For i=1 To Len(CharToFind) 
   ReplaceString(Buffer, Mid(CharToFind,i,1), Mid(CharToReplace,i,1),#PB_String_InPlace, 1)
  Next
  ProcedureReturn Buffer
EndProcedure

Debug Fc_TraitementChaine("ÀÁÂÃÄÅÇÈÉÊËÌÍÎÏÑÒÓÔÕÖÙÚÛÜÝàáâãäåçèéêëìíîïðñòóôõöùúûüýÿ")
Debug Fc_TraitementChaine("Du jour où je parvins à me persuader que je n'avais pas besoin d'être heureux,")
Debug Fc_TraitementChaine("commença d'habiter en moi le bonheur ; oui, du jour où je me persuadai que je n'avais besoin de rien ")
Debug Fc_TraitementChaine("pour être heureux. Il semblait, après avoir donné le coup de pioche à l'égoïsme, ")
Debug Fc_TraitementChaine("que j'avais fait jaillir aussitôt de mon coeur une telle abondance de joie que j'en pusse abreuver ")
Debug Fc_TraitementChaine("tous les autres. Je compris que le meilleur enseignement est d'exemple. j'assumai mon bonheur comme ")
Debug Fc_TraitementChaine("une vocation.  André GIDE")

Ar-S · Message par **Ar-S** » jeu. 26/mai/2011 11:39

On lui a déjà donné cette solution, il n'en fait rien... Je retourne à mes codes, j'ai bien assez de trucs à gérer.

boddhi · Message par **boddhi** » jeu. 26/mai/2011 14:35

@falsam : Je m'incline...

Chris · Message par **Chris** » jeu. 26/mai/2011 18:06

Ar-S a écrit :On lui a déjà donné cette solution, il n'en fait rien... Je retourne à mes codes, j'ai bien assez de trucs à gérer.

Ah!
Je vois qu'il y en a certains qui commencent enfin à comprendre.

falsam · Message par **falsam** » ven. 27/mai/2011 10:38

Ar-S a écrit :On lui a déjà donné cette solution, il n'en fait rien... Je retourne à mes codes, j'ai bien assez de trucs à gérer.

Je reve !!!!! C'est vrai qu'on lui avait déjà donner la solution il y a moins d'un mois !!! sur ce lien

@Chris : inutile de m'envoyer un mp sur le thème de la "belle brochette de couillons" :p Ha ha ha ha ha

PureBasic

Divers fonctions

Divers fonctions

Re: Divers fonctions

Re: Divers fonctions

Re: Divers fonctions

Re: Divers fonctions

Re: Divers fonctions

Re: Divers fonctions

Re: Divers fonctions

Re: Divers fonctions

Re: Divers fonctions

Re: Divers fonctions

Re: Divers fonctions

Re: Divers fonctions

Re: Divers fonctions

Re: Divers fonctions