Parsing 'intelligent' de chaine

Bonjour,

Je voudrais parser une chaine du type : 2 + "toto + " + "4+".

Dans un premier temps, je me dis qu'il serait bien de séparer les tokens :
2
toto +
4+

Du coup, il faudra que je sois capable de splitter cette chaine, sans prendre en compte les "+" qui sont à l'intérieur des chaines... :?

Une idée d'une classe Java qui pourrait m'aider ?

Toine

Euh, je sais pas trop ce que tu te figures, mais il y a rien qui sépare ton 2 et ton toto, là.

Il y a un "+" :)

ça ressemble vaguement à de l'interprétation de code... c'est quoi le besoin fonctionnel? y'a sûrement moyen de simplifier, parce que là.... aie aie aie...

C'est de l'analyse syntaxique. En général, on voit cela en école pendant les cours liés à la définition d'un langage.

Le parser le plus connue étant JFlex

Celui-ci fait tout le travail une fois qu'on a définit le lexique du langage à parser cela à cette tête :

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
/* JFlex example: part of Java language lexer specification */
import java_cup.runtime.*;
 
/**
 * This class is a simple example lexer.
 */
%%
 
%class Lexer
%unicode
%cup
%line
%column
 
%{
  StringBuffer string = new StringBuffer();
 
  private Symbol symbol(int type) {
    return new Symbol(type, yyline, yycolumn);
  }
  private Symbol symbol(int type, Object value) {
    return new Symbol(type, yyline, yycolumn, value);
  }
%}
 
LineTerminator = \r|\n|\r\n
InputCharacter = [^\r\n]
WhiteSpace     = {LineTerminator} | [ \t\f]
 
/* comments */
Comment = {TraditionalComment} | {EndOfLineComment} | {DocumentationComment}
 
TraditionalComment   = "/*" [^*] ~"*/" | "/*" "*"+ "/"
// Comment can be the last line of the file, without line terminator.
EndOfLineComment     = "//" {InputCharacter}* {LineTerminator}?
DocumentationComment = "/**" {CommentContent} "*"+ "/"
CommentContent       = ( [^*] | \*+ [^/*] )*
 
Identifier = [:jletter:] [:jletterdigit:]*
 
DecIntegerLiteral = 0 | [1-9][0-9]*
 
%state STRING
 
%%
 
/* keywords */
<YYINITIAL> "abstract"           { return symbol(sym.ABSTRACT); }
<YYINITIAL> "boolean"            { return symbol(sym.BOOLEAN); }
<YYINITIAL> "break"              { return symbol(sym.BREAK); }
 
<YYINITIAL> {
  /* identifiers */ 
  {Identifier}                   { return symbol(sym.IDENTIFIER); }
 
  /* literals */
  {DecIntegerLiteral}            { return symbol(sym.INTEGER_LITERAL); }
  \"                             { string.setLength(0); yybegin(STRING); }
 
  /* operators */
  "="                            { return symbol(sym.EQ); }
  "=="                           { return symbol(sym.EQEQ); }
  "+"                            { return symbol(sym.PLUS); }
 
  /* comments */
  {Comment}                      { /* ignore */ }
 
  /* whitespace */
  {WhiteSpace}                   { /* ignore */ }
}
 
<STRING> {
  \"                             { yybegin(YYINITIAL); 
                                   return symbol(sym.STRING_LITERAL, 
                                   string.toString()); }
  [^\n\r\"\\]+                   { string.append( yytext() ); }
  \\t                            { string.append('\t'); }
  \\n                            { string.append('\n'); }
 
  \\r                            { string.append('\r'); }
  \\\"                           { string.append('\"'); }
  \\                             { string.append('\\'); }
}
 
/* error fallback */
[^]                              { throw new Error("Illegal character <"+
                                                    yytext()+">"); }

Il en existe d'autre, mais ils ont tous le même principe !
Personnellement, j'ai déjà utilisé CUP pour un projet d'école :
http://sourceforge.net/projects/compli-a3/

Mais, tu devrai nous préciser le but voulu pour pouvoir te conseillé sur l'utilisation d'un tel outil.

Cordialement,
Patrick Kolodziejczyk.

Source :
http://en.wikipedia.org/wiki/Lexical_analysis
http://en.wikipedia.org/wiki/Compari...ser_generators
http://jflex.de/