Discussion :

[NicoO_O]

Bonjour,

Je suis en train de faire un programme qui va lire un fichier jsp et lister les fonctions (se trouvant dans une classe java bien entendu ^^) appelées par ce fichier.

Pour chacune des fonctions trouvées, le programme va aller regarder dans la classe java auquelle appartient la fonction si celle-ci n'en appelle pas d autre à l'intérieur de sa déclaration et ainsi de suite jusqu'a ce que toutes les sous-fonctions soient trouvées(d'ou la fonction récursive ).

Le problème c'est que lorsque une fonction trouvée dans une page jsp apelle elle-aussi une autre fonction(donc ouveture d'un autre fichier), le programme ne revient pas au traitement du premier fichier java ouvert.

J'ai pas mal de difficultés en ce qui concerne ce programme car c'est assez difficile de gérer l'ouverture et la fermeture des différents fichier et je ne m'en sors pas tres bien ^^.

Donc en fait es ce que je dois créer un buffer pour chaque fichier que j'ouvre (seulement je ne connais pas ce nombre) ou es ce que c'est un problème lié à mon algo car la j'avoue que je bloque un peu ....


Voila en espérant que vous avez compris mon problème ^^

[chtig]

Ben on a compris ce que tu voulais faire, mais de là à comprendre ton pb comme ça sans code ... humm ... dsl, mais ma boule de cristal refuse de fonctionner aujourd'hui

[woodwai]

Si tu nous donne un peut de code on pourra t'aider, mais dans tout les cas, si j'ai bien compris tu ouvre un fichier, puis un autre, puis un autre de ma nière 'récursive', donc tu doit avoir un Buffer par fichier!

[gifffftane]

Sauf cas particulier, il n'y a pas de contre indication à ouvrir plusieurs fois simultanément le même fichier en lecture, ce qui est probablement ton cas.

Pour les fonctions récursives il faut être vigilant sur les fondamentaux :

• toutes les variables en local, sauf jonglage particulier ; donc tes fichiers ouverts en local ; tu les ouvres et les fermes dans le même passage de ta fonction.
• un test d'arrêt.
• même si cela semble être une lapalissade : établir des conditions de départ correctes, ce qui nécessite souvent une méthode séparée.

[NicoO_O]

Ok merci pour les réponses.

C'est principalement le fait d'ouvrir et de fermer les fichiers qui me bloque car s'il faut 1 buffer par fichier c'est le bazar ^^ (peut-être peut-on créer un buffeur dynamiquement genre avec une variable i que l'on incrémente) .

Je vous mets les 2 "principales" fonctions de mon programme ainsi qu'une partie d'une fonction servant à traiter une ligne d'un fichier .

la fonction qui suit permet d'ouvrir les pages, lors du premier passage elle ouvre une page jsp puis après elle ouvre des classes java tant qu'elle rencontre des fonction appelées

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
 
//***** ouvre un fichier du dossier cfg et traite ses lignes *****//
public static String TraiterPage(String Chemin,String NomFonc)
{
   String res = "";    	
    boolean eof = false;
    boolean fin = false;
 
    int j = 0;
    System.out.println(Chemin);
 
    //*** traitement des pages java
    if(nivo >= 1)
    {	 
    	try 
	{
	    LecteurBufferise = new BufferedReader(new FileReader(Chemin));
	    System.out.println("ouverture du fichier java : "+Chemin);
 
	     while (fin != true) 
	     {
	          //Lecture de la ligne
	          ligneDonnee = LecteurBufferise.readLine();
 
	         if (ligneDonnee != null) 
	       	 {
	          TrouverFonction(ligneDonnee,NomFonc,NumLigneClasse,Chemin);
	          NumLigneClasse++;
	       	}
	       	else 
	       	{
	       		System.out.println("fin du fichier java "+Chemin);
	          	NumLigneClasse=1;
	          	fin = true;
	          }
 
	      }//fin while
	   }//fin try
	   catch (FileNotFoundException ex)
	   {
	      	System.out.println("Fichier Non Trouvé !!");
	    }
	    catch (IOException ex)
	    {
	      	System.out.println("Erreur lecture ligne fichier java!! "+Chemin);
	    }
	    finally 
	    {
	      	try 
	      	{
	      		System.out.println("fermeture fichier java (1)"+Chemin);
	      		LecteurBufferise.close();
	         }
	     	 catch (IOException ex1)
	        {
	        	System.out.println("Erreur fermeture fichier !!");
	     	}
	    }
 
    	}
 
    	else// niveau 0,traitement de la page jsp
    	{
    	    try 
	    {
	        System.out.println("test 1");
	        LecteurBufferise2 = new BufferedReader(new FileReader(Chemin));
	        System.out.println("ouverture du ficheir jsp : "+Chemin);
 
	         while (eof != true) 
	          {
	    		//Lecture de la ligne
	       		ligneDonnee2 = LecteurBufferise2.readLine();
 
	       		if (ligneDonnee2 != null) 
	       		{
	          		TraiterLigne(ligneDonnee2,String.valueOf(NumLigne));
	          		NumLigne++;
	       		}
	       		else 
	       		{
	       			System.out.println("fin du fichier jsp "+Chemin);
	          		eof = true;
	          		NumLigne = 1;
	          	}
	       	}
	    }
	    catch (FileNotFoundException ex)
	    {
	      	System.out.println("Fichier Non Trouvé !!");
	    }
	    catch (IOException ex)
	    {
	      	System.out.println("Erreur lecture ligne fichier !! ");
	    }
	    finally 
	    {
	      	try 
	      	{
	      		System.out.println("eof = "+eof);
	        	System.out.println("fermeture fichier jsp (1)"+Chemin);
	        	LecteurBufferise2.close();
	         }
	     	 catch (IOException ex1)
	     	 {
	        	System.out.println("Erreur fermeture fichier !!");
	     	}
	    }
    }

Cette fonction va se charger de récupérer ce qu'il y a entre le début de la déclaration de la fonction dans la classe et la déclaration de la fonction suivante.

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
 
//**** recherche de la fonction dans une ligne de la classe *****///
public static void TrouverFonction(String ligne,String NomFonc,int NumLigne,String Chemin)
{
	String lignebis = "";
	String sFonction = "";
 
	//On a "public" et une '(' dans la ligne //
	if(ligne.indexOf("public")!=-1 && ligne.indexOf('(')!=-1)
	{	
		// on récupère la fonction déclarée
		lignebis=ligne.substring(ligne.indexOf("public"),ligne.indexOf('('));
                sFonction = lignebis.substring(lignebis.lastIndexOf(" ")+1,lignebis.length());
 
		// la fonction trouvée est celle passée en paramètre sont ==
		if(NomFonc.compareTo(sFonction)==0)
		{
                      System.out.println("classe java, ligne : "+NumLigne+"  FONCTION TROUVEE ("+NomFonc+")!!!");
                      try
		      {
			   ligneDonnee = LecteurBufferise.readLine();
			   System.out.println("ligneDonnee = "+ligneDonnee);
			   NumLigne++;
			}
			catch (IOException ex)
	    		{
	      			System.out.println("Erreur lecture ligne fichier !! ");
	    		}
 
	    		// on traite tant qu'on n'est pas à la fin du ficher ou qu'on ne rencontre pas de nouveau "public
		       while(ligneDonnee != null && ligneDonnee.indexOf("public")==-1)
		       {
			  try
			  {
				ligneDonnee = LecteurBufferise.readLine();
				System.out.println("ligneDonnee = "+ligneDonnee);
				NumLigne++;
 
				if (ligneDonnee != null) 
	       			{
	                      TraiterLigne(ligneDonnee,String.valueOf(NumLigneClasse));
				}
	       			else 
	       			{
	       					System.out.println("fin du fichier java "+Chemin);
                                }
			   }
			   catch (IOException ex)
	    		   {
	      			System.out.println("Erreur lecture ligne fichier !! ");
	    		   }
 
 
	    		//**** vérification de la présence d'une fonction lorsque l'on rencontre "public"
	    		if(ligneDonnee != null && ligneDonnee.indexOf("public")!=-1 && ligneDonnee.indexOf('(')!=-1 && q!=0)
			{
				lignebis=ligneDonnee.substring(ligneDonnee.indexOf("public"),ligneDonnee.indexOf('('));
				sFonction = lignebis.substring(lignebis.lastIndexOf(" ")+1,lignebis.length());
 
				System.out.println("Fonction : "+sFonction);
 
				// Fonction de même nom que la précedente
				if(NomFonc.compareTo(sFonction)==0)
				{
					System.out.println("classe java, ligne : "+NumLigne+"  FONCTION TROUVEE ("+NomFonc+")!!!");
					try
					{
						ligneDonnee = LecteurBufferise.readLine();
						NumLigne++;
					}
					catch (IOException ex)
	    				{
	      					System.out.println("Erreur lecture ligne fichier !!");
	    				}
				}//fin if
                            }//fin if
			}//finwhile	
	        }//fin if
	}//fin if
}

Enfin le bout de code qui suit fait partie ma fonction de traitement de ligne et fait appel à traiter page pour trouver les sous-fonctions (s'il y en a).

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
 
//fonction ou variable de classe
else
{	
	i++;
	Car = ligne.charAt(i);
 
	FPresente = true;
 
	while(Car != '(' && Car != '%' && Car != ';')
	{
		Fonction = Fonction + Car ;
		i++;
		Car = ligne.charAt(i);
		if(Car == '(')
		{
			FTemp = FTemp + Fonction;
			Fonction = Fonction+"()";	
		}
	}
	r++;
	sTab[p][q][r]= Fonction;
 
        //On incrémente le niveau pour passer dans le traitement des classe java			
	nivo++;
	q++;
 
       //Appel de traitement de page avec le chemin de la classe (récupéré au fur et à mesure) et le nom de la fonction à trouver		
	  TraiterPage(CheminClasses+sBlkTemp+"/"+sPackageTemp+"/"+sClasseTemp+".java",FTemp);

Je sais que mon problème viens de l'ouverture et de la fermeture de mes fichiers mais savoir a quel moment il faut les ouvrir/les fermer à ce stade de mon programme alors que je bloque c'est un peu chaud ^^.

Voilà c'est un peu lourd et je ne m'attend pas à des réponses précises mais cela devrait vous aider à mieux comprendre ^^.



Merci

[gifffftane]

Mais... quelle est ta méthode récursive ?...