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

avec Java Discussion :

Génération de parser (regexp?)


Sujet :

avec Java

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Nouveau candidat au Club
    Femme Profil pro
    Étudiant
    Inscrit en
    Septembre 2011
    Messages
    2
    Détails du profil
    Informations personnelles :
    Sexe : Femme
    Localisation : France, Alpes Maritimes (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Septembre 2011
    Messages : 2
    Par défaut Génération de parser (regexp?)
    Bonjour à tous !

    Je recherche actuellement des infos sur la programmation de parsers en Java.

    Je vous explique rapidement ce que je recherche et j'espère que certains d'entres vous auront des pistes ou des idées pour m'aider ...

    je suis en train de réaliser une interface détachée d'un programme (qui s'appelle FDS) dont je n'ai pas le code source. FDS utilise des fichiers textes pour communiquer des data entre ses différents modules. J'aimerai pouvoir lire ces fichiers afin "d'alimenter" mon interface avec les bonnes data.

    Par la suite, afin de lancer les actions, je pourrais utiliser un pilotage en mode batch de FDS à partir de mon interface en envoyant des commandes sur un terminal. (à voir plus tard, je ne sais pas encore comment faire...)

    Le problème est que ce programme génère des fichiers qui sont formatés mais pas comme d'habitude (xml ou autre).

    Voici à quoi ressemble par exemple ces fichiers :

    process.txt

    #INPUT
    range = {
    bound = {
    min <FDS:ZDON(1)> = "500" ~km
    max <FDS:ZDON(2)> = "250" ~km
    }
    phasisMaxError <FDS:ZDON(3)> = "5" ~km
    }
    stationBias <FDS:ZDON(4)> = "90." ~deg
    altitude <FDS:ZDON(5)> = "1800.47E+00" ~km
    ...
    et ça continue sur plusieurs pages... chaque ligne servant à quelque chose ...
    et bien sur pour compliquer (un peu) le truc, il y a 4 ou 5 fichiers différents à analyser...


    J'ai essayé de programmer mon parser directement en JAVA, je ne m'en sors pas...
    j'ai essayé d'utiliser des solutions telles que CUP / JFlex ... je continue de travailler sur ça à essayer de comprendre comment faire, mais j'ai peur d'etre dans une impasse ...

    j'aimerai avoir, en sortie, un objet (que je suis en train de créer), imaginons

    Parameter avec comme attributs: Name et Value.

    Et je créerai des instances de cet objet pour avoir par example, pour les premières lignes de mon fichier:

    Parameter RangeBoudMin = new Parameter(RangeBoundMin, 500);
    Parameter RangeBoundMax = new Parameter(RangeBoundMax, 250);
    Parameter RangePhasisMaxError = new Parameter(RangePhasisMaxError, 5);
    Parameter StationBias = new Parameter(StationBias, 90.);
    Parameter Altitude = new Parameter(Altitude, 1800.47E+00);

    voilà cet objet (public) aura pour but d'être réutilisé dans le code de mon interface par des textfields. J'utiliserai alors l'attribue Value de mon objet pour remplir la valeur du bon textfield.

    Pour l'instant je ne me sers pas de l'attribut Name, mais plus tard je pourrais ajouter les attribut Unité, numéroZDON ...

    J'espère avoir été clair dans mes explications, n'hésite pas à me demander plus de précision si nécessaire!!


    Voici un extrait de l'interface que j'utilise:

    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
     
    public class newInterface extends ViewPart {
     
    	public static final String ID = "newInterface";
    	private Text text;
    	private Text text_1;
     
    	public newInterface() {
    	}
     
    	/**
             * Create contents of the view part.
             * @param parent
             */
    	@Override
    	public void createPartControl(Composite parent) {
    		Composite container = new Composite(parent, SWT.NONE);
    		container.setLayout(new GridLayout(2, false));
    		{
    			Label lblNewLabel = new Label(container, SWT.NONE);
    			lblNewLabel.setLayoutData(new GridData(SWT.RIGHT, SWT.CENTER, false, false, 1, 1));
    			lblNewLabel.setText("Range Bound Min");
    		}
    		{
    			text = new Text(container, SWT.BORDER);
    			text.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 1, 1));
    		}
    		{
    			Label lblNewLabel_1 = new Label(container, SWT.NONE);
    			lblNewLabel_1.setText("Range Bound Max");
    		}
    		{
    			text_1 = new Text(container, SWT.BORDER);
    			text_1.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 1, 1));
    		}
     
    		createActions();
    		initializeToolBar();
    		initializeMenu();
    	}
     
    	/**
             * Create the actions.
             */
    	private void createActions() {
    		// Create the actions
    	}
     
    	/**
             * Initialize the toolbar.
             */
    	private void initializeToolBar() {
    		IToolBarManager toolbarManager = getViewSite().getActionBars()
    				.getToolBarManager();
    	}
     
    	/**
             * Initialize the menu.
             */
    	private void initializeMenu() {
    		IMenuManager menuManager = getViewSite().getActionBars()
    				.getMenuManager();
    	}
     
    	@Override
    	public void setFocus() {
    		// Set the focus
    	}
     
    }


    j'ai commencé à écrire ça pour le parser:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
     
    protected void processLine(String aLine){
    	    Pattern regexp = Pattern.compile("^[a-zA-Z]*? <[\\w:\\(\\)]*?> = \"([0-9]*?)\" .*$");
    	    Matcher matcher = regexp.matcher(aLine);	    
    	    System.out.println(matcher.group(1));
    	  }
    Mais j'obtiens une erreur...

    Je vous remercie d'avance pour votre aide

    Sarah

  2. #2
    Membre émérite Avatar de NicoL__
    Homme Profil pro
    Architecte
    Inscrit en
    Janvier 2011
    Messages
    399
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Architecte

    Informations forums :
    Inscription : Janvier 2011
    Messages : 399
    Par défaut
    Salut,

    D'après moi si la syntaxe est très complexe les regex vont être très complexes...
    Je pense que la solution c'est vraiment dans un outil du genre CUP / Flex
    Avant il faut bien analyser et modéliser le fichier.
    Et pour moi cela
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
     
    #INPUT
    range = {
    bound = {
    min <FDS:ZDON(1)> = "500" ~km
    max <FDS:ZDON(2)> = "250" ~km
    }
    phasisMaxError <FDS:ZDON(3)> = "5" ~km
    }
    stationBias <FDS:ZDON(4)> = "90." ~deg
    altitude <FDS:ZDON(5)> = "1800.47E+00" ~km
    Donnerait
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
     
    Input input = new Input();
    input.add(new Range(new Bound(500,250), new PhasisMaxError(5)));
    input.add(new StationBias(90));
    input.add(new Altitude(1800.47));

  3. #3
    Nouveau candidat au Club
    Femme Profil pro
    Étudiant
    Inscrit en
    Septembre 2011
    Messages
    2
    Détails du profil
    Informations personnelles :
    Sexe : Femme
    Localisation : France, Alpes Maritimes (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Septembre 2011
    Messages : 2
    Par défaut
    Je vais regarder les outils CUP / JFlex,

    mais je n'ai peut etre pas préciser, que les "phrases" que je donne sont des exemples. Je dois en vrai analyser 4 ou 5 fichiers qui comporte une quinzaine de page chacun...ceux sont des listes de paramètres ... qui me serviront à "alimenter" une interface.

    Merci pour ton aide en tout cas, je regarde les outils CUP / JFlex

    sinon j'ai essaye quelque chose comme ça, mais ça marche pas encore bien bien:

    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
     
    public class ReadWithScanner {		
    	/**
             * the file to be read
             */
    		private final File fFile;		
    		private int i=0;	
     
    	  public static void main(String... aArgs) throws FileNotFoundException {
    	    ReadWithScanner parser = new ReadWithScanner("C:\\temp\\test.txt");
    	    parser.processLineByLine();
    	    log("Done.");
    	  }
     
    	  /**
               Constructor.
               @param aFileName full name of an existing, readable file.
              */
    	  public ReadWithScanner(String aFileName){
    	    fFile = new File(aFileName);  
    	  }
     
     
    	  public final void processLineByLine() throws FileNotFoundException {
    	    //Note that FileReader is used, not File, since File is not Closeable
    	    Scanner scanner = new Scanner(new FileReader(fFile));
    	    try {
    	      //first use a Scanner to get each line
    	      while ( scanner.hasNextLine() ){
    	        processLine( scanner.nextLine() );
    	      }
    	    }
    	    finally {
    	      //ensure the underlying stream is always closed
    	      //this only has any effect if the item passed to the Scanner
    	      //constructor implements Closeable (which it does in this case).
    	      scanner.close();
    	    }
    	  }
     
     
    	  protected void processLine(String aLine){
    	    //use a second Scanner to parse the content of each line 
    	    Scanner scanner = new Scanner(aLine);
    	    String regex = "^.* = \"(.*?)\" .*$";
    	    Matcher m = Pattern.compile(regex).matcher(aLine);	    
    	    if(m.matches()) {
    	    	System.out.println("valeur");	    	
    		      System.out.println(m.group(1));
    	    }
    	    else {System.out.println("pas de valeurs à cette ligne");}
    		  }
     
    	  private static void log(Object aObject){
    	    System.out.println(String.valueOf(aObject));
    	  }
     
    	  private String quote(String aText){
    	    String QUOTE = "'";
    	    return QUOTE + aText + QUOTE;
    	  }
    	}

    Je te remercie pour ton aide et je continue d'essayer !

  4. #4
    Membre chevronné

    Homme Profil pro
    Développeur J2EE Senior
    Inscrit en
    Mai 2008
    Messages
    419
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 40
    Localisation : France, Hauts de Seine (Île de France)

    Informations professionnelles :
    Activité : Développeur J2EE Senior
    Secteur : High Tech - Produits et services télécom et Internet

    Informations forums :
    Inscription : Mai 2008
    Messages : 419
    Par défaut
    Salut

    Je ne suis pas certain d'avoir bien compris le problème, il manque des information du style:
    - Est-ce que les fichiers ont systématiquement la même structure?
    - Est-ce que les fichiers ont toujours le même nombre de lignes avec le même type de données sur chaque ligne?
    - Y-a-t-il des données facultatives?

    Parce qu'effectivement si les données sont toujours les mêmes et viennent dans le même ordre, il est logique de parser le fichier ligne par ligne et de les récupérer au fur et à mesure.

    A l'inverse, si la structure du fichier peut présenter des variations, il va être important de dégager la structure du fichier, auquel cas l’approche du parsage ligne par ligne est à éviter car elle masque ce type d'information. Il vaudrait mieux alors charger d'un coup l'ensemble du fichier en mémoire dans une seule string, puis l'analyser dans un deuxième temps.
    Mes cours sur l'écosystème Java EE - N'oubliez pas de consulter les FAQ Java et les cours et tutoriels Java

  5. #5
    Membre expérimenté
    Homme Profil pro
    Développeur Java
    Inscrit en
    Juillet 2009
    Messages
    130
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 36
    Localisation : France, Loire Atlantique (Pays de la Loire)

    Informations professionnelles :
    Activité : Développeur Java
    Secteur : Finance

    Informations forums :
    Inscription : Juillet 2009
    Messages : 130
    Par défaut
    Bonjour,

    Peux tu nous copier l'erreur que tu obtiens ?

Discussions similaires

  1. [RegExp] Parser une date
    Par AI_LINUX dans le forum Collection et Stream
    Réponses: 9
    Dernier message: 31/12/2011, 17h32
  2. Regexp pour parser un fichier de type hosts
    Par witch dans le forum Langage
    Réponses: 6
    Dernier message: 21/05/2011, 22h58
  3. [RegExp] Parser une regExp
    Par issam_ovic dans le forum Général JavaScript
    Réponses: 13
    Dernier message: 13/04/2011, 14h01
  4. Génération d'une map 3D via un parser
    Par traex dans le forum Moteurs 3D
    Réponses: 5
    Dernier message: 10/12/2010, 18h38
  5. [RegExp] Parser les balises PHP
    Par ePoX dans le forum Langage
    Réponses: 6
    Dernier message: 19/02/2006, 18h34

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