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 ?...

[NicoO_O]

Et bien en fait je ne sais pas si on peut appeler sa une fonction récursive car c'est plus des fonctions qui s'appellent entre elles mais voici le principe :

Une premiere fonction de traitement de page se contente d'ouvrir les pages jsp/java.

Dans le premier cas (jsp), une fonction de traitement de ligne est appelée.
Lorsqu'une fonction va être trouvée, la fonction de traitement de page est rappelée pour ouvrir la classe java ou se trouve la fonction.

Donc on passe dans la partie de traitement de la classe dans la fonctiond de traitement de page.

La, une troisième fonction est appelée et se charge de trouver la fonction dans la classe. Une fois trouvée(car elle y est forcément) elle va lire chaque ligne se trouvant entre le début de la fonction et le début de la suivante et appeler la fonction de traitement de ligne à chaque fois (donc rebelotte on va cherche à nouveau si la fonction va en appeler une autre).

Si la fonction n'en appelle aucune, on ferme la classe et on reviens au traitement de la classe précédente (et je pense que c'est la que se trouve mon problème)

Ensuite on fini de parcourir la classe(donc celle qui précède la dernière classe femée) pour détecter s'il n'y a pas une fonction de même nom (auquel cas on recommence le traitement) et ainsi de suite jusqu'à revenir à la page jsp ou on traite les lignes jusqu'a tomber sur une nouvelle fonction (et rebelotte ^^).

Voila j'espère avoir été assez clair.

Mais je me rend bien compte que cela est vraiment compliqué car il y a pas mal de vraiantes à gérer

[gifffftane]

Mouais

Mon conseil : ne te fais pas de soucis au sujet du nombre d'ouverture de fichiers : ouvres-en autant que tu voudras (en lecture), et fais gaffe à les fermer, c'est tout.

Pour le reste...

• Pour l'analyse d'un fichier, je ne sais pas comment tu as fait, en tous cas il faut réfléchir en termes de séquences, de modèles, de grammaire.
• Réfléchis à cette grammaire dès le départ. Tu peux commencer par une simple si tu veux.
• Pour chaque motif de ta grammaire, associe une méthode ou un objet qui a son propre environnement, environnement que tu construits au début et que tu détruis à la fin de l'analyse du motif.
• Si un motif peut contenir un autre motif, alors seulement la récursivité te sera utile.

[NicoO_O]

Ok merci.

En ce qui concerne l'ouverture de fichiers, comment je peut gérer l'ouverture de mes fichiers (donc la création de buffer) quand je ne connnais pas le nombre de fichiers que j'aurais à ouvrir ? Car à chaque fichier ouvert devra être associé un unique buffer ( si ne nme trompe pas ^^).

Existe t il un moyen de créer des buffer dynamiquement ? (Comme je l'ai dit plus haut)

[gifffftane]

Tu ouvres autant de fichiers que tu veux.

Fais un test : fait un boucle for qui ouvre 10 million de fois le même fichier. Ne le ferme jamais. Trace le numéro de la boucle sur la console au fur et à mesure, et regarde à quel moment ça craque.

Quand à savoir où mémoriser le buffer, c'est très simple : ton fichier devra être ouvert sur l'apparition d'un motif dans ton fichier analysé ; à ce motif, correspond une méthode, ou une nouvelle instance de traitement de ce motif ; et le buffer devra être mémorisé en local dans cette méthode ou dans cette instance, c'est bête comme chou.

[NicoO_O]

Ce que je ne comprend pas trop c'est comment faire en sorte quel tel buffer correspond à telle fichier ouvert car si tous mes buffer portent le même nom mais font référence à des classes différentes cela ne va t il pas poser de problèmes ?


Ou alors je ne vois pas comment mémoriser un buffer ^^.

C'est pour ça que je me pose la question de comment créer des buffer dynamiquement.

[gifffftane]

Admettons que tu tombes dans tes instructions à analyser sur une ligne de ce type :

fichier: lalala.bam

Cela correspondra sans doute à un motif comme ça :

fichier: <nom du fichier>

... en détectant ce motif, tu vas déclencher une méthode, par exemple, celle-ci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
public void traiteFichier(String ligne)
{
 String nomFichier = ligne.substring("fichier: ".length());
 FileInputStream input = new FileInputStream(nomFichier);
 analyseFichier(input);
 input.close();
}

... tu vois que dans cette approche, la mémorisation du fichier se fait pratiquement d'elle même, par le simple jeu des appels de méthodes.