[JNA] Récupération d'une structure C++ en Java

[kmtaz]

Bonjour,

Je tente de récupérer une structure renseignée par ma fonction en C++, mais je n'arrive pas à faire le Mapping du côté Java pour pouvoir l'utiliser à travers ma DLL.

Mon programme en C++ s'exécute bien, j'arrive à récupérer les données de ma structure pour les traiter.

Entete de ma fonction en C++ et la structure que je dois récupérer :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
 
struct donneesGrilleP recupDonneesMNT (const char* fichierDEM, int *tab)
 
struct donneesGrilleP {
 
	int longueurCase;
	int largeurCase;
	int posXAntenne;
        int posYAntenne;
	double frequence;
	double hauteurAntenne;
	double **tabObstacles;
};

Mapping fait du côté Java :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
 
/* Interface permettant d'appeler les fonctions de la dll */
public interface methodesC extends Library {
 
 
	/* Chargement de la DLL */
	methodesC INSTANCE = (methodesC) Native.loadLibrary("ParseurDEM", methodesC.class);
 
 
 
	/* Prototypages des fonctions contenues dans la DLL */
	structDonneesMNT recupDonneesMNT(String fichier, Pointer[] tabGrille);
}

Code :

1
2
3
4
5
6
7
8
9
10
11
 
public class structDonneesMNT extends Structure {
 
	public int longueurCase;
	public int largeurCase;
	public int posXAntenne;
	public int posYAntenne;
	public double frequence;
	public double hauteurAntenne;
	public PointerByReference tabObstacles;
}

A l'exécution de mon programme Java voici l'erreur retournée :

Code :

1
2
3
4
5
6
7
8
9
10
11
 
# A fatal error has been detected by the Java Runtime Environment:
#
#  EXCEPTION_UNCAUGHT_CXX_EXCEPTION (0xe06d7363) at pc=0x7569b9bc, pid=1704, tid=5720
#
# JRE version: 7.0_02-b13
# Java VM: Java HotSpot(TM) Client VM (22.0-b10 mixed mode, sharing windows-x86 )
# Problematic frame:
# C  [KERNELBASE.dll+0xb9bc]
#
# Failed to write core dump. Minidumps are not enabled by default on client versions of Windows

Je ne comprend pas comment interpréter cette erreur. Est-ce possible que le problème vienne de la mauvaise déclaration dans ma structure en Java pour le tableau de double multidimensionnel (public PointerByReference tabObstacles) ?

Ma version de Java est la 7.1 (JR7)

Merci

[John.BE]

Salut ,

Je suis aussi en plein dans les DLL, SO avec des structures, des pointeurs, des fonctions pointer dans les structures et j'en passe ^^.

Alors cette erreur survient fréquemment chez moi aussi.

C'est tout simplement que ton code Java n'est pas le même que t'as DLL ou SO.
Alors soit c'est ton code Java qui à un problème ou soit ton code contenu dans la DLL.
Le JRE détecte le problème car l'allocation mémoire est diffèrenente ->Structure c != structure Java = oui et ben il plante.

Ici, c'est ton code Java le problème je crois.....

Code :

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
 
public class Test{
    /* Chargement de la DLL */
    methodesC INSTANCE = (methodesC) Native.loadLibrary("ParseurDEM", methodesC.class);
 
    static {       
        System.setProperty("jna.library.path","chemin/de/ta/librairie"); //Petite astuce qui peut peut-être te servir ;).
    }
 
    /* Interface permettant d'appeler les fonctions de la dll */
    public interface methodesC extends com.sun.jna.Library {
 
            /* Prototypages des fonctions contenues dans la DLL */
        structDonneesMNT recupDonneesMNT(String fichierDEM, int[] tab);
 
        public static class structDonneesMNT extends com.sun.jna.Structure {
            //Si tu veux que ta classes strucutre soit en valeur
            public static class ByDonneesMNT extends structDonneesMNT implements com.sun.jna.Structure.ByValue { };
            public int longueurCase;
            public int largeurCase;
            public int posXAntenne;
            public int posYAntenne;
            public double frequence;
            public double hauteurAntenne;
            public double tabObstacles;//Pas de pointeur en Java... Je suppose que le doubme pointeur fonctionnera de la même façon que le simpe...! 
            //Si tu veux que ta classes structures soit une refenrece
            public static class ByReferenceDonneesMNT extends structDonneesMNT implements com.sun.jna.Structure.ByReference {
             };
        }
    }
 
    public static void main(String[] args){
        Test test = new Test();
        ByReferenceDonneesMNT donneesMNT = new ByReferenceDonneesMNT();
        donneesMNT.longueurCase = 2;
        /*
        .....
        * 
        */
        int[] a = {1,2,3};
        test.INSTANCE.recupDonneesMNT("plop", a);
    }
 
}

Alors voilà pour moi,

Tu dois mettre dans ton interface "methodesC" tout ce que tu reprends de ta DLL(ce qui te sert) avec exactement les même noms des méthodes, ect.
Aussi le nom de ton interface doit être le même que le header que tu mappes (Je ne suis pas sur à 100% que c'est obligatoires, mais au moins c'est clair)

Le mapping de ta structure doit être dans ton interface aussi.

Le chargement de la librairie doit être en-dehors de ton interface parce quand tu charges la librairie, il va se demander ce que c'est et à quoi ce la correspond "Native....".

Pour les pointeurs, il les prend tranquille sans se poser de question mais bon j'ai pas encore eu le cas avec le double pointeurs...

Sinon quand tu as des soucis avec JNA, tu commences par une petit DLL avec juste tes simples données et après tu grossis ta DLL tant que ça marche.

Voilà, j'espère que je me suis bien exprimé et je suis compréhensible.

Bon vu que cela fait un moi, je suppose que tu as déjà trouvé la solution ^^.

Bonne chance,

[steve25cent]

Bonjour c'est pas un élément de réponse sauf que je voici mon problème.

je travaille sur un projet de modélisation et la 1ère partie consiste à partir du code source existant en "c", écrire un programme JAVA qui permettra de récupérer les informations nécessaires telles que:Structures, Fonction et arguments qui seront exploitable par la suite.

dans un premier temps mon souci c'est de les récupérer et les afficher. la question de comment les afficher principalement sous forme de classe en java, si vous pouvez aussi me donner des éléments de réponse ce sera avec plaisir.à savoir quel API java permet de le faire, ou, existe t-il un code déjà réalisé par quelqu'un d'autre?

Merci!

[John.BE]

Salut,

Tu connaîtras les structures et les fonctions à l'avance quand même? :p

[steve25cent]

Oui pas de soucis sur ce point!

[John.BE]

Donc tu cherches comment faire des structures, des appelles de fonction à partir d'une librairie dynamique comme ici au-dessus? Parce qu'il y a déjà quelques trucs intéressant.

Maintenant, je peux te refaire un exemple d'une structure et des fonctions pour manipuler la structure en c et faire appel à JNA pour les utiliser en Java...

[steve25cent]

en fait j'ai installer CDT environnement (c/c++) sous eclipse car c'est mon ide.

donc là j'ai crée un projet c contenant des structures, type énuméré, fonctions.
ce que je veux c'est ecrire un code java qui permettra de recupérer ces informations (structures, fonctions, enumération) contenu dans mon fichier c et les afficher.

j'espère être claire!

merci!

[John.BE]

Oui, ca l'est .

Je te montre cela demain.

Bonne soirée.

[John.BE]

Salut,

Tout d'abord excuse-moi pour le retard ><.

Voilà plusieurs testes de manipulation ou d'affichage surtout.

Il y a des manipulation de pointeur, de tableau, de fonction, de structure, d'union et d'énumération.

Header c :

Code :

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
 
#ifndef HEADER_H_INCLUDED
#define HEADER_H_INCLUDED
 
typedef union {
	int  i;
	short u;
	float  f;
	char * s;
} Value;
 
typedef struct {
    char *rue;
    int numero;
}Adresse;
 
typedef struct {
    char *name;
    int age;
    Value value;
    Adresse *adresse;
}Structure;
 
typedef enum { IOT_U1, IOT_U2, IOT_U8, IOT_I8, IOT_U16, IOT_I16, IOT_U32, IOT_I32, IOT_F32, IOT_STRING, IOT_MAX } IoTypeE;
 
 
void test();
 
void testValeurInt(int t);
void testValeurTableauInt(int t[]);
void testValeurTableauChar(char t[]);
 
void testPointeurInt(int *t);
void testPointeurTableauInt(int * t);
void testPointeurTableauI(int *t[]);
void testPointeurTableauChar(char *t);
 
int testRetourInt(int i);
void testRetourPointerInt(int *i);
char* testRetour(char * t);
 
void testValeurStructure(Structure structre);
void testPointeurStructure(Structure *structre);
void testPointeurTableauStructure(Structure *structure);
 
void testPointeurFonction(void *testFunct);
int testReturnPointeurFonction(int (*testFunct));
 
void testUnionInt(Value value);
void testUnionChar(Value *value);
 
int testEnumeration(IoTypeE ioType);
 
#endif // HEADER_H_INCLUDED

Les corps :

Code :

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
 
#include "header.h"
#include <stdio.h>
#include <string.h>
 
void test(){
    printf("\n test :Coucou \n\n");
}
 
void testValeurInt(int t){
 
    printf("\n\n Test valeur -> Mon int est : %d",t);
}
void testValeurTableauInt(int t[]){
    printf("\n\n Test valeur Tableau ->");
    int i = 0;
    printf("\n liste :");
    while(i<10){
        printf("\n i = %d",t[i]);
        i++;
    }
}
void testValeurTableauChar(char t[]){
    printf("\n\n Test valeur char -> char : %s",t);
}
 
void testPointeurInt(int *t){
    printf("\n\n Test Pointeur int -> t = %d",*t);
}
void testPointeurTableauInt(int * t){
    printf("\n\n Test pointeur tableau (int *t)->");
    printf("\n Liste :");
    int i=0;
    while(i<10){
        printf("\n i = %d",t[i]);
        i++;
    }
}
void testPointeurTableauI(int *t[]){
    printf("\n\n Test pointeur tableau (int *t[]) ->");
    printf("\n Liste :");
    int i=0;
    while(i<10){
        printf("\n i = %d",*t[i]);
        i++;
    }
}
void testPointeurTableauChar(char *t){
    printf("\n\n Pointeur tableau de char : %s",t);
}
 
int testRetourInt(int i){
    i = i * i;
    return i;
}
void testRetourPointerInt(int *i){
    *i = (*i)*(*i);
}
 
char* testRetour(char * t){
    strcat(t," - je rajoute !!!!\0");
 
    return t;
}
 
void testValeurStructure(Structure structre){
    printf("\n test valeur Structure -> name : %s , age : %d  rue : %s",structre.name,structre.age,structre.adresse->rue);
}
void testPointeurStructure(Structure *structre){
    printf("\n test pointeur Structure -> name : %s , age : %d  rue : %s",structre->name,structre->age,structre->adresse->rue);
}
 
void testPointeurTableauStructure(Structure *structure){
    int i = 0;
    printf("\n\n Test tableau de strucutre :");
    while(i<10){
        printf("\n Structure %d : name : %s",i,structure[i].name);
        i++;
    }
}
 
void testPointeurFonction(void *testFunct){
   void (*pointeurSurFonction)(void);
   pointeurSurFonction  = testFunct;
    (*pointeurSurFonction)();
}
int testReturnPointeurFonction(int (*testFunct)){
    typedef int (*PtrFonct)();
    PtrFonct pf = testFunct;
    int i = pf();
    return i*i;
}
 
void testUnionInt(Value value){
    printf("\n\n Union int -> %d",value.i);
}
void testUnionChar(Value *value){
    printf("\n\n Value Char %s",value->s);
}
 
int testEnumeration(IoTypeE ioType){
    printf("\n\n IoType : %d",ioType);
    ioType = IOT_STRING;
    return ioType;
}

Et voici la class Java :

Code :

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
 
 
package testjna;
 
import com.sun.jna.Memory;
import com.sun.jna.Native;
import com.sun.jna.Platform;
import com.sun.jna.Pointer;
import com.sun.jna.ptr.IntByReference;
import com.sun.jna.ptr.PointerByReference;
import testjna.TestJNA.StructureProtocol.TestFunck;
 
 
public class TestJNA {
 
    public static class Adresse extends com.sun.jna.Structure{        
        public static class AdresseByValue extends TestJNA.Adresse implements com.sun.jna.Structure.ByValue{};
        public String rue;
        public int numero;
        public static class AdresseByReference extends TestJNA.Adresse implements com.sun.jna.Structure.ByReference{};
 
    }
    public static class Value extends com.sun.jna.Union{
        public static class ValueByValue extends TestJNA.Value implements com.sun.jna.Union.ByValue{};
        public int  i;
	public short u;
	public float  f;
	public String s;
        public static class ValueByReference extends TestJNA.Value implements com.sun.jna.Union.ByReference{};
    }
 
    public static class Structure extends com.sun.jna.Structure{ 
 
        public Structure(){}
        public Structure(Pointer pointer){
            super(pointer);
        }
 
        public static class StructureByValue extends TestJNA.Structure implements com.sun.jna.Structure.ByValue{};
        public String name;
        public int age;
        public Value.ValueByValue value = new Value.ValueByValue();
        public Adresse.AdresseByReference adresse = new Adresse.AdresseByReference();
        public static class StructureByReference extends TestJNA.Structure implements com.sun.jna.Structure.ByReference{};
    }
 
    public enum IoTypeE{               //Enumération
        IOT_U1(1),
        IOT_U2 (2),
        IOT_U8 (3),
        IOT_I8 (4),
        IOT_U6 (5),
        IOT_I6 (6),
        IOT_U32 (7),
        IOT_I32 (8),
        IOT_F32 (9),
        IOT_STRING (10),
        IOT_MAX (11);
 
        private int value;
 
        IoTypeE(int v) {
            value = v;
        }
 
        public int value() {
            return value();
        }
 
        public static IoTypeE fromValue(int v) {
            for (IoTypeE c: IoTypeE.values()) {
                if (c.value == v) {
                    return c;
                }
            }
            return null;
        }
    }
 // Fin l'enumération
 
    public interface StructureProtocol extends com.sun.jna.Library{
        void test();
 
        void testValeurInt(int t);
        void testValeurTableauInt(int t[]);
        void testValeurTableauChar(String t);
 
        void testPointeurInt(IntByReference  t);
        void testPointeurTableauInt(PointerByReference t);
        void testPointeurTableauI(IntByReference [] t);
        void testPointeurTableauChar(String t);
 
        int testRetourInt(int i);
        void testRetourPointerInt(IntByReference  t);
        String testRetour(String t);
 
        void testValeurStructure(Structure.StructureByValue structre);
        void testPointeurStructure(Structure.StructureByReference structre);
        void testPointeurTableauStructure(Structure structure);
 
        public static interface TestFunck extends com.sun.jna.Callback{
            void invoke();
        }
        public TestFunck testFunct = null;
 
        void testPointeurFonction(TestFunck testFunct);
 
        public static interface TestFuncp extends com.sun.jna.Callback{
            int invoke();
        }
        int testReturnPointeurFonction(TestFuncp t);
 
        void testUnionInt(Value.ValueByValue value);
        void testUnionChar(Value.ValueByReference value);
 
        int testEnumeration(int ioType);
 
    }
    public interface WinStrucutreProtocol extends StructureProtocol{
 
    } 
 
    static {       
        System.setProperty("jna.library.path",".");  //Donner un chemin pour la dll
    }
 
    public StructureProtocol lib;
 
    public TestJNA(){
        this.lib = (StructureProtocol) Native.loadLibrary("Structure",
                Platform.isWindows() ? 
                WinStrucutreProtocol.class : StructureProtocol.class);
    }
 
    public static void main(String[] args) {
        TestJNA t = new TestJNA();
        //Simple fonction d'affichage
        t.lib.test();
        //Fonction avec simplement un paramètre passé.
        t.lib.testValeurInt(5);
 
        int []r  = new int[10];
        for (int i = 0; i < 10; i++) {
            r[i]=i;
        }
        //Function simple qui prend en paramètre un tableau d'entier
        t.lib.testValeurTableauInt(r);
        //Function simple qui prend en paramètre un tableau de char
        t.lib.testValeurTableauChar("plop");
 
        IntByReference f = new IntByReference(50);
        //Fonction qui prend en paramètre un pointeur d'entier
        t.lib.testPointeurInt(f);
 
 
        Memory mem = new Memory(Integer.SIZE * 10);
 
        PointerByReference inipar = new PointerByReference();
        inipar.setPointer(mem);
 
        for (int i = 0; i < 10; i++) {
            inipar.getPointer().setInt(i * Integer.SIZE / 8, i);
        }
        //Ici, cest plus subtil car on positione ici au-dessus les entiers dans 
        //la mémoire.  Une fois compris, sans avoir regarder plus, on pourrait 
        //faire un tableau de structure vers un pointeur!
        t.lib.testPointeurTableauInt(inipar);
 
        IntByReference [] z = new IntByReference[10];
        for (int i = 0; i < 10; i++) {
            z[i] = new IntByReference(i);
        }
        //Fonction qui prend un tableau d'entier 
        t.lib.testPointeurTableauI(z);
//    
        //Fonction pour monter les fonction retour
        int temp = t.lib.testRetourInt(20);
        System.out.print("\n Test retour int: " + temp);
//        
        //Fonction pour montrer qu'on sait odifier les paramètre et bien les réccupèrer en Java
        t.lib.testRetourPointerInt(f);
        System.out.print("\n test retour par pointeur : " + f.getValue());
 
//        String tempS = t.lib.testRetour("testtttttt");
//        System.out.print("\n Test retour String :" + tempS);
//        
        Structure.StructureByValue sv = new Structure.StructureByValue();
        sv.name = "John";
        sv.age = 23;
        sv.adresse.rue = "Neuvile-haut";
 
        //Fonction qui passe simplment une structure en valeur
        t.lib.testValeurStructure(sv);
//        
//        
        Structure.StructureByReference sr = new Structure.StructureByReference();
        sr.name = "Titi";
        sr.age = 44;
        sr.adresse = new Adresse.AdresseByReference();
        sr.adresse.rue = "Vielsalm";
        PointerByReference g= new PointerByReference(sr.getPointer());
 
        //Function qui prend un pointeur de strucutre
        t.lib.testPointeurStructure(sr);
//      
        //Fonction qui pointe vers une fonction pour montrer qu'on peut faire des échnages et cela marche dans les 2 sens
        t.lib.testPointeurFonction(new TestFunck() {
 
            @Override
            public void invoke() {
               System.out.print("\n\n ICIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII\n");
            }
 
        });  
 
        int vb = t.lib.testReturnPointeurFonction(new StructureProtocol.TestFuncp() {
 
            @Override
            public int invoke() {
                return 20;
            }
        });
        System.out.print("\n\n Pointeur de fonction (retour int) : " + vb);
 
        //Union
 
        Value.ValueByValue v1 = new Value.ValueByValue();
        v1.setType(int.class); //Important de préciser le type !!!
        v1.i = 105;
        t.lib.testUnionInt(v1);
 
        Value.ValueByReference v2 = new Value.ValueByReference();
        v2.setType(String.class);
        v2.s = "Iccccccccccccccccccccccccccccciiiiiiiiiiiiiiiiiiiiii";
        t.lib.testUnionChar(v2);
 
        int i = t.lib.testEnumeration(IoTypeE.IOT_I6.value);
        IoTypeE e = IoTypeE.fromValue(i); 
        System.out.print("\n\n Enumeration :" + e.name());
    }
}

Ne pas oublié de rajouter dans le projet les librairies JNA.

Moi, pour faire la DLL sous Windows, j'utilise le compilateur MinGW32 avec la commande "gcc -Wall -shared test.c -o Structure.dll"

Voilà j’espère que c'est quand même clair et avec tout cela je pense qu'on peut faire beaucoup .
Merci à toi

[steve25cent]

Merci pour ton code et ça m'aidera bcp pour la 1ère partie d mon projet.

bon en fait mon projet c'est de créer un modèle UML contenant les différents diagrammes(les plus importants)à partir d'un d'un code source( langage c) existant.
mon problème est:
sachant que le projet est organisé en répertoires et sous répertoires, bref une arborescence contenant les fichiers sources, comment faire pour parcourir l'arborescence, accéder aux fichiers et pourvoir extraire les informations qui me permettront de réaliser mes diagrammes(séquences, classes, etc.)?
quelles notions sont susceptibles d'intervenir pour la réalisation du projet?
l'utilisation de la JNA est-elle indispensable?

pour ce faire je me suis déjà un peu penché sur les notions de: méta-modèle, parser, que je ne sais pas si elles pourraient être des solutions potentielles!

merci d'avance!