more cases for commentary

flap/src/hopix/hopixLexer.mll

@@ -20,21 +20,20 @@ let hexa = "0x" ['0'-'9' 'a'-'f' 'A'-'F']
 let bina = "0b" ['0'-'1']
 let octa = "0o" ['0'-'7']
 
-let integers = '-'? (digit+
+let printable = [' ' '\t' '\n' '\r' (* 33-126 *)] (* pas sûr *)
-             | hexa+
-             | bina+
-             | octa+)
 
-let printable = [' ' '\t' '\n' '\r' (*33-126*)] (*pas sûr*)
-let ident = ['a'-'z']['A'-'Z' 'a'-'z' '0'-'9' '_']*
-let constr_id = ['A'-'Z']['A'-'Z' 'a'-'z' '0'-'9' '_']*
-let type_variable = ['\'']['a'-'z']['A'-'Z' 'a'-'z' '0'-'9' '_']*
 (* On ne peut pas différencier au niveau du lexer var_id label_id et type_con,
- * il faudra le faire à l'analyseur syntaxique *)
+ * il faudra le faire à l'analyseur syntaxique. On fait donc un "ident" pour
+ * identificateur *)
+let ident = ['a'-'z']['A'-'Z' 'a'-'z' '0'-'9' '_']*
 
 let atom = '"'
-let char = ['\'']atom['\'']
+
-let string = ['\"']((atom | '\'' | "\\\""))['\"']
+let constr_id = ['A'-'Z']['A'-'Z' 'a'-'z' '0'-'9' '_']*
+let type_variable = '`' ['a'-'z']['A'-'Z' 'a'-'z' '0'-'9' '_']*
+let int = '-'? (digit+ | hexa+ | bina+ | octa+)
+let char = '\'' atom '\''
+let string = '\"' ((atom | '\'' | "\\\"")) '\"'
 
 (* let binop = '+' | '-' | '*' | '/' | "&&" | "||"| "=?"| "<=?" |">=?" |"<?" |">?" *)
 
@@ -44,7 +43,7 @@ rule token = parse
   | newline            { next_line_and token lexbuf      }
   | blank+             { token lexbuf                    }
   | eof                { EOF                             }
-  | "{*"            { commentary lexbuf; token lexbuf }
+  | "{*"               { commentary lexbuf               }
   | "##"               { commentary_line lexbuf          }
 
   (** Keywords *)
@@ -60,20 +59,19 @@ rule token = parse
   | "while"            { WHILE  }
   | "do"               { DO     }
   | "until"            { UNTIL  }
-  | "for"           { FOR    }
   | "from"             { FROM   }
   | "to"               { TO     }
   | "and"              { AND    }
   | "for"              { FOR    }
   (* Fini ? *)
 
-  (** Binar operation : pas sûr pour celui là*)
+  (** Binar operation : pas sûr pour celui là *)
-  (* | binop as b      { BINOP (* TODO *) } *)
+  (* | binop as b         { BINOP b } *)
 
   (** Operators *)
   (* | '='                { EQUAL } *)
 
-  (* ponctuation *)
+  (** Ponctuation *)
   | '('                { LPAREN   }
   | ')'                { RPAREN   }
   | '['                { LBRACK   }
@@ -85,17 +83,25 @@ rule token = parse
   | ">"                { SUPERIOR }
 
   (** Values *)
-  | integers as i   { INT (Mint.of_string i) }
+  | int as i           { INT (Mint.of_string i) }
   | ident as s         { ID s                   }
+  | type_variable as s { TID s                  }
 
   (** Lexing error *)
   | _                  { error lexbuf "unexpected character." }
 
-  and commentary = parse
+(* TODO: Gérer les imbrications de commentaires *)
-  | "*}"            { ()                                   }
+and commentary = parse
-  | "{*"            { commentary lexbuf; commentary lexbuf }
+  | "*}"               { token lexbuf                         }
+  | newline            { next_line_and commentary lexbuf      }
+
+  (** Error  *)
+  | eof                { error lexbuf "unclosed commentary."  }
+
+  (** Commentary content *)
   | _                  { commentary lexbuf                    }
 
-  and commentary_line = parse
+and commentary_line = parse
-  | '\n'            { next_line_and token lexbuf }
+  | newline            { next_line_and token lexbuf }
+  | eof                { EOF                        }
   | _                  { commentary_line lexbuf     }

flap/src/hopix/hopixParser.mly

@@ -48,7 +48,7 @@ fundef:
     FunctionDefinition(p, e)
   }
 /* ts est temp */
-| DPOINT ts=located(type_scheme) i=located(identifier) p=pattern EQUAL e=located(expression) {
+| DPOINT ts=located(type_scheme) i=located(identifier) p=located(pattern) EQUAL e=located(expression) {
     FunctionDefinition(p, e)
   }
 
@@ -63,18 +63,19 @@ pattern:
 
 
 ty:
-| tc = type_constructor {
+/* Temporaire None - compile pas */
+/* | tc=type_constructor {
     TyCon(tc, None)
-  }
+  } */
 
-(* Todo version avec l'optionnel*)
+/* Todo version avec l'optionnel */
 | ty1=located(ty) ARROW ty2=located(ty) {
     TyArrow(ty1, ty2)
   }
 | ty1=located(ty) STAR ty2=located(ty) {
     TyTuple([ty1; ty2])
   }
-| ty1=located(ty) STAR ty2=located(ty) STAR liste_ty = separated_list(STAR,located(ty)) {
+| ty1=located(ty) STAR ty2=located(ty) STAR liste_ty=separated_list(STAR, located(ty)) {
     TyTuple(ty1::ty2::liste_ty)
   }
 | LPAREN type_var=type_variable RPAREN {
@@ -83,8 +84,8 @@ ty:
 
 
 type_scheme:
-(* il faut peut être modifié le séparateur*)
+/* il faut peut être modifié le séparateur */
-| LBRACK liste_typevar=separated_list(COMMA,located(type_variable)) RBRACK ty=located(ty) {
+| LBRACK liste_typevar=separated_list(COMMA, located(type_variable)) RBRACK ty=located(ty) {
     ForallTy(liste_typevar, ty)
   }
 | ty=located(ty) {
@@ -99,7 +100,7 @@ type_variable:
 
 
 type_constructor:
-| tcon = TID {
+| tcon=TID {
     TCon tcon
   }