Problème de lexer

Salut,

Alors voilà j'essaye de faire un moteur de template HTML à la TWIG mais en OCaml, en utilisant le duo Menhir/Ocamllex. Je me suis inspiré de ce tuto http://realworldocaml.org/v1/en/html/parsing-with-ocamllex-and-menhir.html

Pour le moment ma grammaire est simple :

• "true"/"false" : Doivent retourner un token TRUE/FALSE
• {{ id }}: est de la forme DOUBLE_LEFT_BRACE + ID + DOUBLE_RIGHT_BRACE
• Le reste (du code HTML) doit être un Token STRING.

J'ai pour l'instant j'ai 2 problèmes :

• Comment faire pour exprimer ce token STRING, vu qu'il peut contenir un nombre incroyable de caractères spéciaux (vu que c'est du HTML). J'ai cherché une expression regex magique. Normalement .* Devrait faire l'affaire mais cela ne fonctionne pas.
• Les tokens TRUE/FALSE ne fonctionne pas (Il me dit qu'il reconnait pas true/false dans le fichier à parser ), alors que pourtant ils me semblent correctement définis

Pour l'instant il y a juste {{ abc }} qui marche correctement.

Voilà mes quelques bouts de code: Le typage :

1
2
3
4
5

type value =[
    |`String of string
    |`Bool of bool
    |`Null
]

Le parser :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

%token <string> ID
%token <string> STRING
%token NULL
%token TRUE
%token FALSE
%token DOUBLE_LEFT_BRACE
%token DOUBLE_RIGHT_BRACE
%token EOF

%start <Temp.value option> prog
%%
prog:
    | EOF   {None}
    | v = value {Some v}
    ;
value:
    | DOUBLE_LEFT_BRACE;id = ID;DOUBLE_RIGHT_BRACE  {`String id}
    | TRUE  {`Bool true}
    | FALSE {`Bool false}
    | NULL  {`Null}
    ;

Le lexer :

 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

{
    open Lexing
    open Parser

    exception SyntaxError of string


    let next_line lexbuf =
    let pos = lexbuf.lex_curr_p in
    lexbuf.lex_curr_p <-
        { pos with pos_bol = lexbuf.lex_curr_pos;
                pos_lnum = pos.pos_lnum + 1
        }
}
let int = '-'?['0'-'9']['0'-'9']*
let white = [' ' '\t']+
let newline = '\r' | '\n' | "\r\n"
let id = ['a'-'z' 'A'-'Z' '_'] ['a'-'z' 'A'-'Z' '0'-'9' '_']*
rule read =
    parse
    | white { read lexbuf }
    | newline   { next_line lexbuf; read lexbuf }
    | id       { ID (Lexing.lexeme lexbuf) }
    | "true"    { TRUE }
    | "false"   { FALSE }
    | "{{"      { DOUBLE_LEFT_BRACE }
    | "}}"       { DOUBLE_RIGHT_BRACE }
    | eof       { EOF}
    | _         { raise (SyntaxError ("Unexpected character : "^Lexing.lexeme lexbuf))}

Si quelqu'un a suggestion pour me débloquer je suis preneur :' Merci

Salut,

Je n'ai jamais fais de lexing avec OCaml (en fait, j'ai jamais touché au language), mais j'ai expérimenté avec PLY.

Je n'ai pas mes tests à disposition, mais voilà une RegExp qui match jusqu'au prochain {{ : (?:[\s\S](?!{{))*. Pour tester.

Le principe est plutôt simple : on match en boucle n'importe quel caractère ([\s\S]) et on arrête si ce qui suit est {{. Ça s'appelle un negative lookahead le (?!{{), ça ne consomme pas les caractères qui suivent, ça les teste juste.

Ça pourrait être ton token STRING.

J'espère que ça t'aide.

J'ai essayé ta proposition et ça ne semble pas marcher. D'ailleurs sur ton site, il y a pas mal de cas où ça ne récupère pas les bonnes données, nottament les mots situés après les {{ foo }}.

C'est tout à fait normal, vu qu'on match jusqu'à {{. Ensuite, ça sera un match DOUBLE_LEFT_BRACE + ID + DOUBLE_RIGHT_BRACE puis un autre match de token string.