IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Ada Discussion :

Problème de compilation


Sujet :

Ada

  1. #1
    Membre averti Avatar de RPGamer
    Homme Profil pro
    Ingénieur en systèmes embarqués
    Inscrit en
    Mars 2010
    Messages
    168
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 34
    Localisation : Suisse

    Informations professionnelles :
    Activité : Ingénieur en systèmes embarqués

    Informations forums :
    Inscription : Mars 2010
    Messages : 168
    Points : 395
    Points
    395
    Par défaut Problème de compilation
    Bonjour,

    Je ne suis pas un expert de Ada et du compilateur GNAT. Je suis étudiant et je dois réaliser deux packages pour effectuer des opérations sur un type qui m'est imposé et dont voici le code :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
     type T_Entier is range 1..100 ;
       -- subtype T_Entier is Integer range 1..100;
     
       type T_Couleur is ( Jaune, Rouge, Bleu ) ;
     
       Taille_Ensemble: constant Integer := (T_Couleur'Pos(T_couleur'Last)+1)
                                             *Integer(T_Entier'Last);
       -- Taille_Ensemble: constant Integer :=(T_Couleur'Pos(T_couleur'Last)+1)*T_Entier'Last;
     
       subtype T_Indice is Integer range 1..Taille_Ensemble;
     
       type T_Element is record
          Couleur : T_Couleur ;
          Nombre  : T_Entier ;
       end record ;
     
       type T_Tableau_Elements is array (T_Indice) of T_Element;
     
       type T_Ensemble is record
          Info: T_Tableau_Elements;
          Cardinalite: Natural:=0;
       end record;
    J'ai terminé le premier package mais je ne vois pas ensuite comment se passe la compilation. Dois-je compiler chaque fichier indépendamment (le fichier de spécification, le fichier du corps et enfin celui qui utilise le package) ?

    J'ai essayé de compiler le fichier de spécification (Ensembles.ads) et voici l'erreur que j'obtiens:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    ----jGRASP exec: C:\Labo01\Ensembles
    ----jGRASP wedge2 error: command "C:\Labo01\Ensembles" does not exist.
    ---jGRASP: operation complete.
    Qu'est-ce que ça signifie ?

    Autre question, puis-je utiliser l'opérateur = sur le type T_Element sans avoir à faire une surcharge ?

    Merci pour votre éclairage

  2. #2
    Invité
    Invité(e)
    Par défaut
    Bonjour,

    Je connais pas le compilateur que vous utilisez.
    Vous oubliez de donner votre ligne de compilation.

    Avec gnat, normalement, gnatmake "sources_files_names_list" ou gnatmake main et gnat s'occupe des d'inclure les dépendances.

    Après il manque le tout début du paquetage de votre spécification. Au moins pour savoir si c'est un générique ou pas.

  3. #3
    Membre averti Avatar de RPGamer
    Homme Profil pro
    Ingénieur en systèmes embarqués
    Inscrit en
    Mars 2010
    Messages
    168
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 34
    Localisation : Suisse

    Informations professionnelles :
    Activité : Ingénieur en systèmes embarqués

    Informations forums :
    Inscription : Mars 2010
    Messages : 168
    Points : 395
    Points
    395
    Par défaut
    Bonjour,

    Je n'utilise que les boutons de mon IDE (jGrasp) pour compiler. Jusqu'à maintenant je n'ai jamais eu de problème. Mais c'est la première fois que je réalise un package.

    Voici le code complet de la spécification :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    package Ensembles is
     
       type T_Entier is range 1..100 ;
       -- subtype T_Entier is Integer range 1..100;
     
       type T_Couleur is ( Jaune, Rouge, Bleu ) ;
     
       Taille_Ensemble: constant Integer := (T_Couleur'Pos(T_couleur'Last)+1)
                                             *Integer(T_Entier'Last);
       -- Taille_Ensemble: constant Integer :=(T_Couleur'Pos(T_couleur'Last)+1)*T_Entier'Last;
     
       subtype T_Indice is Integer range 1..Taille_Ensemble;
     
       type T_Element is record
          Couleur : T_Couleur ;
          Nombre  : T_Entier ;
       end record ;
     
       type T_Tableau_Elements is array (T_Indice) of T_Element;
     
       type T_Ensemble is record
          Info: T_Tableau_Elements;
          Cardinalite: Natural:=0;
       end record;
     
       Ensemble_Vide: constant T_Ensemble:=((T_Tableau_Elements'Range=>(T_couleur'First,T_Entier'First)),0);
     
       -- Constructeur
       -- Créer un ensemble vide
       procedure Creer_Ensemble( Ensemble : out T_Ensemble );
     
       -- Modificateurs
       -- Ajouter un élément à un ensemble
       ---- Lever l'exception Element_Existant si l'élément déjà présent
       procedure Ajouter_Element( Ensemble : in out T_Ensemble;
                                  Element : in T_Element );
     
       -- Enlever un élément d'un ensemble
       -- Lever l'exception Erreur_Ensemble_Vide si l'ensemble
       -- est vide
       -- Lever l'exception Element_Inexistant si l'élément 
       -- n'existe pas
       procedure Extraire_Element( Ensemble : in out T_Ensemble;
                                   Element : in T_Element ) ;
     
       -- Créer un ensemble composé de la réunion de deux autres
       -- ensembles
       procedure Effectuer_Union( Ensemble : out T_Ensemble ;
                                  Ensemble_1 : in T_Ensemble;
                                  Ensemble_2 : in T_Ensemble );
     
       -- Créer un ensemble composé de l'intersection de deux
       -- autres ensembles
       procedure Effectuer_Intersection(Ensemble : out T_Ensemble ;
                                        Ensemble_1 : in T_Ensemble;
                                        Ensemble_2 : in T_Ensemble );
     
     
       -- Selecteurs
       -- Vraie si le premier ensemble (Ensemble_1) est inclus 
       -- (strictement) dans le deuxième (Ensemble_2), 
       -- fausse sinon
       function "<" (Ensemble_1 : in T_Ensemble ;
                     Ensemble_2 : in T_Ensemble ) return Boolean;
     
     
       -- Vraie si le premier ensemble (Ensemble_1) est inclus 
       -- (au sens large) dans le deuxième (Ensemble_2), 
       -- fausse sinon
       function "<=" (Ensemble_1 : in T_Ensemble ;
                      Ensemble_2 : in T_Ensemble ) return Boolean;
     
       -- Vraie si l'ensemble est vide, fausse sinon
       function Vide (Ensemble: in T_Ensemble) return Boolean;
     
       Erreur_Element_Inexistant : exception;
      ---- Element_Existant : exception;
       Erreur_Ensemble_Plein: exception;
       Erreur_Ensemble_Vide:  exception;
     
    end Ensembles;
    Et le code du corps que j'ai réalisé :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255
    256
    257
    258
    259
    260
    261
    262
    263
    264
    265
    266
    267
    268
    269
    270
    271
    272
    273
    274
    275
    276
    -- Clauses de contexte
    with Ada.Text_IO;                use Ada.Text_IO;
     
    package Ensembles body is
     
       ---------------------------------------------------------------------------------------
       -- But            :  Retourne True si l'ensemble en premier paramètre est strictement
       --                   inclu dans l'ensemble passé en second paramètre, False sinon.
       -- 
       -- Paramètre(s)   : 
       --      Ensemble_1   :  Ensemble à inclure
       --      Ensemble_2   :  Ensemble cible
       ---------------------------------------------------------------------------------------
       function "<" ( Ensemble_1 : T_Ensemble;
                      Ensemble_2 : T_Ensemble ) return Boolean is;
     
          Element_Inclu    :     Boolean	:=	False;
     
       begin -- Fonction : "<"
     
          -- On parcours en priorité l'ensemble à inclure
          for Indice_1 in Ensemble_1.Info'range loop
     
             for Indice_2 in Ensemble_2.Info'range loop
     
                -- On vérifie que les éléments de l'ensemble le plus petit sont tous dans 
    				-- ceux du plus grand         
                if Ensemble_1.Info(Indice_1) = Ensemble_2.Info(Indice_2) and 
    					not Element_Inclu;
     
                   Element_Inclu	:=	True;
     
                end if;
     
             end loop;
     
    			-- Un élément n'est pas inclu, l'ensemble n'est donc pas complétement inclu
    			if not Element_Inlu then
     
    				return False;
     
    			end if;
     
          end loop;
     
          -- Tous les éléments de l'ensemble à inclure ont été testés, il est inclu
    		return True;
     
       end "<";
     
       ---------------------------------------------------------------------------------------
       -- But            :  Retourne True si l'ensemble en premier paramètre est inclu au
       --                   sens large dans l'ensemble passé en second paramètre, False sinon.
       -- 
       -- Paramètre(s)   : 
       --      Ensemble_1   :  Ensemble à inclure
       --      Ensemble_2   :  Ensemble cible
       ---------------------------------------------------------------------------------------
       function "<=" ( Ensemble_1 : T_Ensemble;
                       Ensemble_2 : T_Ensemble ) return Boolean is;
     
       begin -- Fonction : "<="
     
          -- On parcours l'ensemble à inclure en priorité
          for Indice_1 in Ensemble_1.Info'range loop
     
             for Indice_2 in Ensemble_2.Info'range loop
     
                -- Si au moins un élément est identique on retourne True
                if Ensemble_1.Info(Indice_1) = Ensemble_2.Info(Indice_2) then
     
                   return True;
     
                end if;
     
             end loop;
     
          end loop;
     
          return False;
     
       end "<=";
     
       ---------------------------------------------------------------------------------------
       -- But            :  Retourne True si l'ensemble passé en paramètre est vide, 
       --                   False dans le cas contraire.
       -- 
       -- Paramètre(s)   : 
       --      Ensemble   :  Ensemble à vérifier
       ---------------------------------------------------------------------------------------
       function Vide ( Ensemble:  T_Ensemble ) return Boolean is
     
       begin -- Fonction : Vide
     
          -- On vérifie que le tableau des éléments est vide
          return Ensemble.Info'Length = 0;
     
       end Vide;
     
       ------------------------------------------------------------------------------------
       -- But            : Retourne True si l'élément en deuxième paramètre est présent
       --                  dans l'ensemble en premier paramètre.
       -- 
       -- Paramètre(s)   : 
       --      Ensemble  :  Ensemble cible
       --      Element   :  Élément à chercher dans l'ensemble
       ------------------------------------------------------------------------------------
       function Element_Existe ( Ensemble : T_Ensemble; 
                                 Element  : T_Element ) return Boolean is
     
       begin -- Fonction : Element_Existe
     
          -- On parcours l'ensemble
          for Indice in Ensemble.Info'range loop
     
             -- Si l'élément est présent on retourne True
             if (Ensemble.Info(Indice) = Element then
     
                return True;
     
             end if;
     
          end loop;
     
          -- Si l'élément n'est pas trouvé on retourne False
          return False;
     
       end Element_Existe;
     
       ---------------------------------------------------------------------------------------
       -- But            : Crée un ensemble vide.
       -- 
       -- Paramètre(s)   : 
       --      Ensemble  :  Variables cible
       ---------------------------------------------------------------------------------------
       procedure Creer_Ensemble( Ensemble : out T_Ensemble ) is
     
       begin -- Procédure : Creer_Ensemble
     
          Ensemble :=    ENSEMBLE_VIDE;
     
       end Creer_Ensemble;
     
       ---------------------------------------------------------------------------------------
       -- But            : Ajoute l'élément passé en deuxième paramètre à un ensemble passé
       --                  en premier paramètre. Si l'élément existe déjà dans ledit ensemble,
       --                  il n'est pas ajouté.
       -- 
       -- Paramètre(s)   : 
       --      Ensemble  :  Ensemble cible
       --      Element   :  Élément à ajouter à l'ensemble cible
       ---------------------------------------------------------------------------------------
       Ajouter_Element( Ensemble : in out T_Ensemble; Element : in T_Element ) is
     
       begin -- Procédure : Ajouter_Element
     
    		-- On vérifie que l'ensemble ne soit pas plein
    		if Ensemble.Info'Length = Taille_Ensemble then
     
    			raise Erreur_Ensemble_Plein;
     
    		end if;
     
          -- On n'insère l'élément que si il n'est pas déjà présent
          if not Element_Existe(Ensemble, Element) then
     
             Ensemble.Info        :=    Ensemble.Info & Element;
             Ensemble.Cardinalite :=    Ensemble.Cardinalite'Succ;
     
          end if;
     
       end Ajouter_Element;
     
       ---------------------------------------------------------------------------------------
       -- But            :  Supprime un élément passé en deuxième paramètre de l'ensemble
       --                   en premier paramètre. 
       -- 
       -- Paramètre(s)   : 
       --      Ensemble  :  Ensemble cible
       --      Element   :  Élément à supprimer de l'ensemble cible
       ---------------------------------------------------------------------------------------
       procedure Extraire_Element ( Ensemble : in out T_Ensemble; Element : in T_Element ) is
     
          Ensemble_Temporaire  :  T_Ensemble  := ENSEMBLE_VIDE;
     
       begin -- Procédure : Extraire_Element
     
          -- On vérifie si l'ensemble est vide
          if Vide(Ensemble) then
     
             raise Erreur_Ensemble_Vide;
     
          elsif not Element_Existe(Ensemble, Element) then
     
             raise Erreur_Element_Inexistant;
     
          end if;
     
          -- On enregistre les éléments dans l'ensemble temporaire sauf celui à supprimer
          for Indice in Ensemble.Info'range loop
     
             if Ensemble.Info(Indice) /= Element then
     
                Ensemble_Temporaire.Info(Indice) := Ensemble.Info(Indice);
     
             end if;
     
          end loop;
     
          -- On met à jour la valeur de la cardinalité
          Ensemble_Temporaire.Cardinalite := Ensemble_Temporaire.Info'Length;
     
          -- On écrase l'ensemble d'origine en lui affectant l'ensemble temporaire
          Ensemble := Ensemble_Temporaire;
     
       end Extraire_Element;
     
       ---------------------------------------------------------------------------------------
       -- But            :  Uni les deux ensemble en deuxième et troisième paramètre et 
       --                   affecte le résultat à l'ensemble en premier paramètre. 
       -- 
       -- Paramètre(s)   : 
       --      Ensemble     :  Union des deux ensemble
       --      Ensemble_1   :  Premier ensemble à unir
       --      Ensemble_2   :  Deuxième ensemble à unir
       ---------------------------------------------------------------------------------------
       procedure Effectuer_Union( Ensemble   : out T_Ensemble;
                                  Ensemble_1 : in  T_Ensemble;
                                  Ensemble_2 : in  T_Ensemble ) is
     
       begin -- Procédure : Effectuer_Union
     
          -- On fusionne les deux ensembles en un seul
          Ensemble := Ensemble_1 & Ensemble_2;
     
          -- On met à jour la cardinalité
          Ensemble.Cardinalite := Ensemble.Info'Length;
     
       end Effectuer_Union;
     
       ---------------------------------------------------------------------------------------
       -- But            :  Crée un ensemble à partir de celui en premier paramètre contenant
       --                   l'intersection des ensembles en deuxième et troisième paramètre. 
       -- 
       -- Paramètre(s)   : 
       --      Ensemble     :  Intersection des deux ensemble
       --      Ensemble_1   :  Premier ensemble à sectionner
       --      Ensemble_2   :  Deuxième ensemble à sectionner
       ---------------------------------------------------------------------------------------
       procedure Effectuer_Intersection ( Ensemble   : out T_Ensemble;
                                          Ensemble_1 : in  T_Ensemble;
                                          Ensemble_2 : in  T_Ensemble ) is
     
       begin -- Procédure : Effectuer_Intersection
     
          -- On parcours les ensembles pour trouver les éléments présents dans les deux
          for Indice_1 in Ensemble_1.Info'range loop
     
             for Indice_2 in Ensemble_2.Info'range loop
     
                if Ensemble_1.Info(Indice_1) = Ensemble_2.Info(Indice_2) then
     
                   Ensemble.Info(Indice_1) := Ensemble_1.Info(Indice_1);
     
                end if;
     
             end loop;
     
          end loop;
     
          -- On met à jour la cardinalité
          Ensemble.Cardinalite := Ensemble.Info'Length;
     
       end Effectuer_Intersection;
     
    end Ensembles;
    Je dois donc lancer la compilation du fichier de corps ? Comment trouve-il le fichier de spécification ?

    EDIT : je vois que ça ne compile plus avec mes anciens programmes non plus. Je tente de réinstaller GNAT et jGrasp.

  4. #4
    Membre averti Avatar de Blackknight
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Février 2009
    Messages
    214
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 50
    Localisation : France, Seine Maritime (Haute Normandie)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Février 2009
    Messages : 214
    Points : 383
    Points
    383
    Par défaut
    En fait, il semblerait que jGrasp essaye d'exécuter le programme Ensembles qui se trouve être un package et non une unité exécutable.

    Je dois donc lancer la compilation du fichier de corps ? Comment trouve-il le fichier de spécification ?
    Et bien, il se débrouille tout seul !!

    En fait, il manque quelque chose pour que tout fonctionne hormis une faute dans l'écriture du corps. En effet, il manque une procédure qui teste ton package et qui se trouverait dans un troisième fichier.
    En tant que tel, ton package ne fait rien. C'est comme une classe en C++ ou un code C pour lesquels il n'y aurait pas main

  5. #5
    Membre averti Avatar de RPGamer
    Homme Profil pro
    Ingénieur en systèmes embarqués
    Inscrit en
    Mars 2010
    Messages
    168
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 34
    Localisation : Suisse

    Informations professionnelles :
    Activité : Ingénieur en systèmes embarqués

    Informations forums :
    Inscription : Mars 2010
    Messages : 168
    Points : 395
    Points
    395
    Par défaut
    Merci pour votre réponse.

    J'ai finalement réussi à compiler en modifiant le compilateur utilisé dans les paramètres de jGrasp.

    J'ai donc pu avancer et pas mal débugger mon code. J'ai fait un programme qui appel le package. En le compilant, je vois qu'effectivement il va checker les packages externes.

    Je dois faire un package enfant et j'ai compris que le nom du fichier devait être "parent-enfant.adb" et que le package devait être nommé "parent.enfant".

    Ca compilait jusqu'à un certain point. En effet, dans le fichier qui utilise le package j'ai mis les lignes suivantes :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    with Ada.Text_IO;                   use Ada.Text_IO;
    with Ensembles;			   use Ensembles;
    with Ensembles.Utilitaires;        use Ensembles.Utilitaires;
    Ensembles contient des fonctions qui ne sont pas présentes dans les spécifications mais qui sont utilisées dans le packages Ensembes et Ensembes.Utilitaires. Dans le package parent c'est OK, mais par contre le package enfant Ensemble.Utilitaires ne peut pas utiliser ces fonctions.

    Je ne pense pas qu'il faille ajouter ces fonction dans les spéc pour pouvoir les utiliser dans le package enfant ?

  6. #6
    Invité
    Invité(e)
    Par défaut
    Si vous voulez que le paquetage enfant ai une visibilité sur des fonction ou procédure utilisé dans le paquetage parent vous devez placer leur spécification dans la parti privé du paquetage parent.

  7. #7
    Membre averti Avatar de Blackknight
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Février 2009
    Messages
    214
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 50
    Localisation : France, Seine Maritime (Haute Normandie)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Février 2009
    Messages : 214
    Points : 383
    Points
    383
    Par défaut
    Je ne pense pas qu'il faille ajouter ces fonction dans les spéc pour pouvoir les utiliser dans le package enfant ?
    Ben, moi, j'ai bien peur que si
    Ceci dit, il y a une astuce pour que cela fonctionne correctement
    Relis cette page, elle est un peu plus claire que l'ARM à ce sujet

  8. #8
    Membre averti Avatar de Blackknight
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Février 2009
    Messages
    214
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 50
    Localisation : France, Seine Maritime (Haute Normandie)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Février 2009
    Messages : 214
    Points : 383
    Points
    383
    Par défaut
    Citation Envoyé par jovalise Voir le message
    Si vous voulez que le paquetage enfant ai une visibilité sur des fonction ou procédure utilisé dans le paquetage parent vous devez placer leur spécification dans la parti privé du paquetage parent.
    Aaaahhhh !! T'as encore donné la réponse plutôt que des indices !!!

Discussions similaires

  1. problème de compilation sous visual C++
    Par fabmili dans le forum MFC
    Réponses: 4
    Dernier message: 08/02/2004, 20h52
  2. problème de compil devc++ socket
    Par stefdem dans le forum Autres éditeurs
    Réponses: 2
    Dernier message: 11/12/2003, 12h33
  3. Réponses: 1
    Dernier message: 29/10/2003, 13h16
  4. Problème de compilation de la DLL du XMLRad
    Par [DreaMs] dans le forum XMLRAD
    Réponses: 2
    Dernier message: 16/04/2003, 17h46
  5. Réponses: 1
    Dernier message: 27/05/2002, 02h44

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo