Forum |  HardWare.fr | News | Articles | PC | S'identifier | S'inscrire | Shop Recherche
1789 connectés 

  FORUM HardWare.fr
  Programmation
  Divers

  [ANTLR] : Quelques questions

 
 


 Mot :   Pseudo :  
 
Bas de page
Auteur Sujet :

[ANTLR] : Quelques questions

n°1690482
Pascalito
Veni, Vidi, Vomi !
Posté le 22-02-2008 à 10:09:58  profilanswer
 

Bonjour,
 
Je débute en ANTLR et je compte sur vous pour éclaircir quelques points durs...
 
Mon but est de parser des fichiers C pour en récupérer les typedef et structures...
 
J'ai donc récupéré la grammaire C.g sur ANTLR que vous pouvez trouver en fin de message.
 
Je travaille en C#.
 
[B][U]Question 1 :[/U][/B]
J 'ai quelques warnings à la génération des fichiers Lexer et Parser. Voici les logs :

Code :
  1. ANTLR Parser Generator  Version 3.0 (May 17, 2007)  1989-2007
  2. warning(200): C.g:468:38: Decision can match input such as "'else'" using multiple alternatives: 1, 2
  3. As a result, alternative(s) 2 were disabled for that input
  4. warning(200): C.g:517:4: Decision can match input such as "{'U', 'u'}{'L', 'l'}" using multiple alternatives: 1, 2
  5. As a result, alternative(s) 2 were disabled for that input
  6. warning(200): C.g:522:9: Decision can match input such as "'0'..'9'{'E', 'e'}{'+', '-'}'0'..'9'{'D', 'F', 'd', 'f'}" using multiple alternatives: 3, 4
  7. As a result, alternative(s) 4 were disabled for that input


 
Quelqu'un a une idée ?
 
 
[B][U]Question 2 :[/U][/B]
J'aimerais afficher à chaque itération la chaine sur la laquelle on travaille. Comment puis je faire ?
Il faut rajouter un {Console.WriteLIne()} dans la grammaire mais où et avec quoi comme paramètre ?
 
[B][U]Question 3 :[/U][/B]
Quelqu'un pourrait-il m'expliquer les deux extraitrs suivants car là je suis dépassé...   :cry:
[U]Extrait 1 :[/U]

Code :
  1. translation_unit
  2. : external_declaration+
  3. ;
  5. external_declaration
  6. options {k=1;}
  7. : ( declaration_specifiers? declarator declaration* '{' )=> function_definition
  8. | declaration
  9. ;


 
[U]Extrait 2 :[/U]
Là il commence à y avoir des ? et je ne comprends plus le fond de la règle...

Code :
  1. declaration
  2. scope {
  3.   bool isTypedef;
  4. }
  5. @init {
  6.   $declaration::isTypedef = false;
  7. }
  8. : 'typedef' declaration_specifiers? {$declaration::isTypedef=true;}
  9.   init_declarator_list ';' // special case, looking for typedef  
  10. | declaration_specifiers init_declarator_list? ';'
  11. ;
  13. declaration_specifiers
  14. :   (   storage_class_specifier
  15.  |   type_specifier
  16.         |   type_qualifier
  17.         )+
  18. ;
  20. init_declarator_list
  21. : init_declarator (',' init_declarator)*
  22. ;


 
 
Merci beaucoup !
 
Pascal
 
[U]Annexe :[/U]
 
Grammaire utilisée :

Code :
  1. /** ANSI C ANTLR v3 grammar
  3. Translated from Jutta Degener's 1995 ANSI C yacc grammar by Terence Parr
  4. July 2006.  The lexical rules were taken from the Java grammar.
  6. Jutta says: "In 1985, Jeff Lee published his Yacc grammar (which
  7. is accompanied by a matching Lex specification) for the April 30, 1985 draft
  8. version of the ANSI C standard.  Tom Stockfisch reposted it to net.sources in
  9. 1987; that original, as mentioned in the answer to question 17.25 of the
  10. comp.lang.c FAQ, can be ftp'ed from ftp.uu.net,
  11.    file usenet/net.sources/ansi.c.grammar.Z.
  12. I intend to keep this version as close to the current C Standard grammar as
  13. possible; please let me know if you discover discrepancies. Jutta Degener, 1995"
  15. Generally speaking, you need symbol table info to parse C; typedefs
  16. define types and then IDENTIFIERS are either types or plain IDs.  I'm doing
  17. the min necessary here tracking only type names.  This is a good example
  18. of the use of the global scope (called Symbols).  Every rule that declares its usage
  19. of Symbols pushes a new copy on the stack effectively creating a new
  20. symbol scope.  Also note rule declaration declares a rule scope that
  21. lets any invoked rule see isTypedef boolean.  It's much easier than
  22. passing that info down as parameters.  Very clean.  Rule
  23. direct_declarator can then easily determine whether the IDENTIFIER
  24. should be declared as a type name.
  26. I have only tested this on a single file, though it is 3500 lines.
  28. This grammar requires ANTLR v3 (3.0b3 or higher)
  30. Terence Parr
  31. July 2006
  33. ANTLR C# version - Kunle Odutola, November 2006
  34. */
  35. grammar C;
  37. options {
  38. language=CSharp;
  39.     backtrack=true;
  40.     memoize=true;
  41.     k=2;
  42. }
  44. scope Symbols {
  45. IDictionary types;
  46. }
  48. @header {
  49. }
  51. @members {
  52. bool isTypeName(string name)
  53. {
  54.  for (int i = Symbols_stack.Count-1; i>=0; i--)
  55.  {
  56.   Symbols_scope scope = (Symbols_scope)Symbols_stack[i];
  57.   if ( scope.types.Contains(name) )
  58.   {
  59.    return true;
  60.   }
  61.  }
  62.  return false;
  63. }
  64. bool isfinStruct(string token)
  65. {
  66.  if (token.ToString() == "}" )
  67.  {
  68.   return true;
  69.  }
  70.  return false;
  71. }
  72. }
  74. translation_unit
  75. scope Symbols; // entire file is a scope
  76. @init {
  77.   $Symbols::types = new Hashtable();
  78. }
  79. : external_declaration+
  80. ;
  82. /** Either a function definition or any other kind of C decl/def.
  83. *  The LL(*) analysis algorithm fails to deal with this due to
  84. *  recursion in the declarator rules.  I'm putting in a
  85. *  manual predicate here so that we don't backtrack over
  86. *  the entire function.  Further, you get a better error
  87. *  as errors within the function itself don't make it fail
  88. *  to predict that it's a function.  Weird errors previously.
  89. *  Remember: the goal is to avoid backtrack like the plague
  90. *  because it makes debugging, actions, and errors harder.
  91. *
  92. *  Note that k=1 results in a much smaller predictor for the  
  93. *  fixed lookahead; k=2 made a few extra thousand lines. ;)
  94. *  I'll have to optimize that in the future.
  95. */
  96. external_declaration
  97. options {k=1;}
  98. : ( declaration_specifiers? declarator declaration* '{' )=> function_definition
  99. | declaration
  100. ;
  102. function_definition
  103. scope Symbols; // put parameters and locals into same scope for now
  104. @init {
  105.   $Symbols::types = new Hashtable();
  106. }
  107. : declaration_specifiers? declarator
  108.  ( declaration+ compound_statement // K&R style
  109.  | compound_statement    // ANSI style
  110.  )
  111. ;
  113. declaration
  114. scope {
  115.   bool isTypedef;
  116. }
  117. @init {
  118.   $declaration::isTypedef = false;
  119. }
  120. : 'typedef' declaration_specifiers? {$declaration::isTypedef=true;}
  121.   init_declarator_list ';' // special case, looking for typedef  
  122. | declaration_specifiers init_declarator_list? ';'
  123. ;
  125. declaration_specifiers
  126. :   (   storage_class_specifier
  127.  |   type_specifier
  128.         |   type_qualifier
  129.         )+
  130. ;
  132. init_declarator_list
  133. : init_declarator (',' init_declarator)*
  134. ;
  136. init_declarator
  137. : declarator ('=' initializer)?
  138. ;
  140. storage_class_specifier
  141. : 'extern'
  142. | 'static'
  143. | 'auto'
  144. | 'register'
  145. ;
  147. type_specifier
  148. : 'void'
  149. | 'char'
  150. | 'short'
  151. | 'int'
  152. | 'long'
  153. | 'float'
  154. | 'double'
  155. | 'signed'
  156. | 'unsigned'
  157. | struct_or_union_specifier
  158. | enum_specifier
  159. | type_id
  160. ;
  162. type_id
  163.     :   {isTypeName(input.LT(1).Text)}? IDENTIFIER
  164.      {Console.Out.WriteLine("\t" + input.LT(-1).Text + " " + input.LT(1).Text);}
  165.     ;
  167. struct_or_union_specifier
  168. options {k=3;}
  169. scope Symbols; // structs are scopes
  170. @init {
  171.   $Symbols::types = new Hashtable();
  172. }
  173. : struct_or_union IDENTIFIER? '{' struct_declaration_list '}'
  174. | struct_or_union IDENTIFIER
  175. ;
  177. struct_or_union
  178. : 'struct' {Console.Out.WriteLine("\r\nStruct\r\n{" );}
  179. | 'union' {Console.Out.WriteLine("\r\nUnion\r\n{" );}
  180. ;
  182. struct_declaration_list
  183. : struct_declaration+
  184. ;
  186. struct_declaration
  187. : specifier_qualifier_list struct_declarator_list ';'
  188. ;
  190. specifier_qualifier_list
  191. : ( type_qualifier | type_specifier )+
  192. ;
  194. struct_declarator_list
  195. : struct_declarator (',' struct_declarator)*
  196. ;
  198. struct_declarator
  199. : declarator (':' constant_expression)?
  200. | ':' constant_expression
  201. ;
  203. enum_specifier
  204. options {k=3;}
  205. : 'enum' '{' enumerator_list '}'
  206. | 'enum' IDENTIFIER '{' enumerator_list '}'
  207. | 'enum' IDENTIFIER
  208. ;
  210. enumerator_list
  211. : enumerator (',' enumerator)*
  212. ;
  214. enumerator
  215. : IDENTIFIER ('=' constant_expression)?
  216. ;
  218. type_qualifier
  219. : 'const'
  220. | 'volatile'
  221. ;
  223. declarator
  224. : pointer? direct_declarator
  225. | pointer
  226. ;
  228. direct_declarator
  229. :   ( IDENTIFIER
  230.   {
  231.   if ($declaration.Count>0 && $declaration::isTypedef) {
  232.    $Symbols::types[$IDENTIFIER.Text] = $IDENTIFIER.Text;
  233.    Console.Out.WriteLine("using " + input.LT(-1).Text + " = System." + input.LT(-2).Text + ";" );
  234.   }
  235.   }
  236.  | '(' declarator ')'
  237.  )
  238.         declarator_suffix*
  239. ;
  241. declarator_suffix
  242. :   '[' constant_expression ']'
  243.     |   '[' ']'
  244.     |   '(' parameter_type_list ')'
  245.     |   '(' identifier_list ')'
  246.     |   '(' ')'
  247. ;
  249. pointer
  250. : '*' type_qualifier+ pointer?
  251. | '*' pointer
  252. | '*'
  253. ;
  255. parameter_type_list
  256. : parameter_list (',' '...')?
  257. ;
  259. parameter_list
  260. : parameter_declaration (',' parameter_declaration)*
  261. ;
  263. parameter_declaration
  264. : declaration_specifiers (declarator|abstract_declarator)*
  265. ;
  267. identifier_list
  268. : IDENTIFIER (',' IDENTIFIER)*
  269. ;
  271. type_name
  272. : specifier_qualifier_list abstract_declarator?
  273. ;
  275. abstract_declarator
  276. : pointer direct_abstract_declarator?
  277. | direct_abstract_declarator
  278. ;
  280. direct_abstract_declarator
  281. : ( '(' abstract_declarator ')' | abstract_declarator_suffix ) abstract_declarator_suffix*
  282. ;
  284. abstract_declarator_suffix
  285. : '[' ']'
  286. | '[' constant_expression ']'
  287. | '(' ')'
  288. | '(' parameter_type_list ')'
  289. ;
  291. initializer
  292. : assignment_expression
  293. | '{' initializer_list ','? '}'
  294. ;
  296. initializer_list
  297. : initializer (',' initializer)*
  298. ;
  300. // E x p r e s s i o n s
  302. argument_expression_list
  303. :   assignment_expression (',' assignment_expression)*
  304. ;
  306. additive_expression
  307. : (multiplicative_expression) ('+' multiplicative_expression | '-' multiplicative_expression)*
  308. ;
  310. multiplicative_expression
  311. : (cast_expression) ('*' cast_expression | '/' cast_expression | '%' cast_expression)*
  312. ;
  314. cast_expression
  315. : '(' type_name ')' cast_expression
  316. | unary_expression
  317. ;
  319. unary_expression
  320. : postfix_expression
  321. | '++' unary_expression
  322. | '--' unary_expression
  323. | unary_operator cast_expression
  324. | 'sizeof' unary_expression
  325. | 'sizeof' '(' type_name ')'
  326. ;
  328. postfix_expression
  329. :   primary_expression
  330.         (   '[' expression ']'
  331.         |   '(' ')'
  332.         |   '(' argument_expression_list ')'
  333.         |   '.' IDENTIFIER
  334.         |   '*' IDENTIFIER
  335.         |   '->' IDENTIFIER
  336.         |   '++'
  337.         |   '--'
  338.         )*
  339. ;
  341. unary_operator
  342. : '&'
  343. | '*'
  344. | '+'
  345. | '-'
  346. | '~'
  347. | '!'
  348. ;
  350. primary_expression
  351. : IDENTIFIER
  352. | constant
  353. | '(' expression ')'
  354. ;
  356. constant
  357.     :   HEX_LITERAL
  358.     |   OCTAL_LITERAL
  359.     |   DECIMAL_LITERAL
  360.     | CHARACTER_LITERAL
  361. | STRING_LITERAL
  362.     |   FLOATING_POINT_LITERAL
  363.     ;
  365. /////
  367. expression
  368. : assignment_expression (',' assignment_expression)*
  369. ;
  371. constant_expression
  372. : conditional_expression
  373. ;
  375. assignment_expression
  376. : lvalue assignment_operator assignment_expression
  377. | conditional_expression
  378. ;
  380. lvalue
  381. : unary_expression
  382. ;
  384. assignment_operator
  385. : '='
  386. | '*='
  387. | '/='
  388. | '%='
  389. | '+='
  390. | '-='
  391. | '<<='
  392. | '>>='
  393. | '&='
  394. | '^='
  395. | '|='
  396. ;
  398. conditional_expression
  399. : logical_or_expression ('?' expression ':' conditional_expression)?
  400. ;
  402. logical_or_expression
  403. : logical_and_expression ('||' logical_and_expression)*
  404. ;
  406. logical_and_expression
  407. : inclusive_or_expression ('&&' inclusive_or_expression)*
  408. ;
  410. inclusive_or_expression
  411. : exclusive_or_expression ('|' exclusive_or_expression)*
  412. ;
  414. exclusive_or_expression
  415. : and_expression ('^' and_expression)*
  416. ;
  418. and_expression
  419. : equality_expression ('&' equality_expression)*
  420. ;
  421. equality_expression
  422. : relational_expression (('=='|'!=') relational_expression)*
  423. ;
  425. relational_expression
  426. : shift_expression (('<'|'>'|'<='|'>=') shift_expression)*
  427. ;
  429. shift_expression
  430. : additive_expression (('<<'|'>>') additive_expression)*
  431. ;
  433. // S t a t e m e n t s
  435. statement
  436. : labeled_statement
  437. | compound_statement
  438. | expression_statement
  439. | selection_statement
  440. | iteration_statement
  441. | jump_statement
  442. ;
  444. labeled_statement
  445. : IDENTIFIER ':' statement
  446. | 'case' constant_expression ':' statement
  447. | 'default' ':' statement
  448. ;
  450. compound_statement
  451. scope Symbols; // blocks have a scope of symbols
  452. @init {
  453.   $Symbols::types = new Hashtable();
  454. }
  455. : '{' declaration* statement_list? '}'
  456. ;
  458. statement_list
  459. : statement+
  460. ;
  462. expression_statement
  463. : ';'
  464. | expression ';'
  465. ;
  467. selection_statement
  468. : 'if' '(' expression ')' statement (options {k=1; backtrack=false;}:'else' statement)?
  469. | 'switch' '(' expression ')' statement
  470. ;
  472. iteration_statement
  473. : 'while' '(' expression ')' statement
  474. | 'do' statement 'while' '(' expression ')' ';'
  475. | 'for' '(' expression_statement expression_statement expression? ')' statement
  476. ;
  478. jump_statement
  479. : 'goto' IDENTIFIER ';'
  480. | 'continue' ';'
  481. | 'break' ';'
  482. | 'return' ';'
  483. | 'return' expression ';'
  484. ;
  486. IDENTIFIER
  487. : LETTER (LETTER|'0'..'9')*
  488. ;
  490. fragment
  491. LETTER
  492. : '$'
  493. | 'A'..'Z'
  494. | 'a'..'z'
  495. | '_'
  496. ;
  498. CHARACTER_LITERAL
  499.     :   '\'' ( EscapeSequence | ~('\''|'\\') ) '\''
  500.     ;
  502. STRING_LITERAL
  503.     :  '"' ( EscapeSequence | ~('\\'|'"') )* '"'
  504.     ;
  506. HEX_LITERAL : '0' ('x'|'X') HexDigit+ IntegerTypeSuffix? ;
  508. DECIMAL_LITERAL : ('0' | '1'..'9' '0'..'9'*) IntegerTypeSuffix? ;
  510. OCTAL_LITERAL : '0' ('0'..'7')+ IntegerTypeSuffix? ;
  512. fragment
  513. HexDigit : ('0'..'9'|'a'..'f'|'A'..'F') ;
  515. fragment
  516. IntegerTypeSuffix
  517. : ('u'|'U')? ('l'|'L')
  518. | ('u'|'U')  ('l'|'L')?
  519. ;
  521. FLOATING_POINT_LITERAL
  522.     :   ('0'..'9')+ '.' ('0'..'9')* Exponent? FloatTypeSuffix?
  523.     |   '.' ('0'..'9')+ Exponent? FloatTypeSuffix?
  524.     |   ('0'..'9')+ Exponent FloatTypeSuffix?
  525.     |   ('0'..'9')+ Exponent? FloatTypeSuffix
  526. ;
  528. fragment
  529. Exponent : ('e'|'E') ('+'|'-')? ('0'..'9')+ ;
  531. fragment
  532. FloatTypeSuffix : ('f'|'F'|'d'|'D') ;
  534. fragment
  535. EscapeSequence
  536.     :   '\\' ('b'|'t'|'n'|'f'|'r'|'\"'|'\''|'\\')
  537.     |   OctalEscape
  538.     ;
  540. fragment
  541. OctalEscape
  542.     :   '\\' ('0'..'3') ('0'..'7') ('0'..'7')
  543.     |   '\\' ('0'..'7') ('0'..'7')
  544.     |   '\\' ('0'..'7')
  545.     ;
  547. fragment
  548. UnicodeEscape
  549.     :   '\\' 'u' HexDigit HexDigit HexDigit HexDigit
  550.     ;
  552. WS  :  (' '|'\r'|'\t'|'\u000C'|'\n') {$channel=HIDDEN;}
  553.     ;
  555. COMMENT
  556.     :   '/*' ( options {greedy=false;} : . )* '*/' {$channel=HIDDEN;}
  557.     ;
  559. LINE_COMMENT
  560.     : '//' ~('\n'|'\r')* '\r'? '\n' {$channel=HIDDEN;}
  561.     ;
  563. // ignore #line info for now
  564. LINE_COMMAND
  565.     : '#' ~('\n'|'\r')* '\r'? '\n' {$channel=HIDDEN;}
  566.     ;

mood
Publicité
Posté le 22-02-2008 à 10:09:58  profilanswer
 

n°1692045
Pascalito
Veni, Vidi, Vomi !
Posté le 25-02-2008 à 15:20:10  profilanswer
 

Personne ?

n°1695834
el muchach​o
Comfortably Numb
Posté le 02-03-2008 à 17:45:50  profilanswer
 

Les messages semblent indiquer que la grammaire n'est pas complète et que dans certains cas, ceux indiqués, des ambiguités subsistent.
Mais alors pour la corriger, bonne chance... cependant il y a des chances que ça ne t'affecte pas pour ce que tu veux faire.
Pour le reste, ben il n'y a pas moyen de faire autrement que de te plonger dans la copieuse documentation [:spamafote]
 
Rapidement, la syntaxe des déclarations de types symboliques est grosso modo:
 
type : tokens { bout de code associé, éventuellement; } ;
 
sachant que ça peut se faire sur plusieurs lignes comme
 
type :
   (token1 | token2) { ... }
   ;
Dans le bout de code Java associé, on fait appelle à des mots-clés d'ANTLR qui commencent par $.


---------------
Les aéroports où il fait bon attendre, voila un topic qu'il est bien

Aller à :
Ajouter une réponse
  FORUM HardWare.fr
  Programmation
  Divers

  [ANTLR] : Quelques questions

 

Sujets relatifs
Questions sur l'hebergementQuestions sur swing, awt, ... Jscrollpane, voir 7 ème post
Petites questions générales sur le PythonDe l'art de poser les questions
quelques questions d'un débutant.Questions pour un débutant en CSS
Questions diverses sur le javaQuestions sur l'implémentation d'une LSI (calcul matriciel : SVD)
questions communication flash-serveurblabla@php | faq et bonnes pratiques page 1
Plus de sujets relatifs à : [ANTLR] : Quelques questions

Forum MesDiscussions.Net, Version 2010.2
(c) 2000-2011 Doctissimo
Page générée en 0.113 secondes

Copyright © 1997-2025 Groupe LDLC (Signaler un contenu illicite / Données personnelles)