format

flap/src/hopix/hopixLexer.mll

@@ -10,8 +10,6 @@
 
   let error lexbuf =
     error "during lexing" (lex_join lexbuf.lex_start_p lexbuf.lex_curr_p)
-
-
 }
 
 let newline = ('\010' | '\013' | "\013\010")
@@ -31,7 +29,8 @@ 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*)
+(* On ne peut pas différencier au niveau du lexer var_id label_id et type_con,
+ * il faudra le faire à l'analyseur syntaxique *)
 
 let atom = '"'
 let char = ['\'']atom['\'']
@@ -68,12 +67,11 @@ rule token = parse
   | "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 (* TODO *)           }
+
-*)
   (** Operators *)
-  | '='             { EQUAL                      }
+  (* | '='             { EQUAL } *)
 
   (* ponctuation *)
   | '('             { LPAREN   }

flap/src/hopix/hopixParser.mly

@@ -19,31 +19,36 @@ program:
     definition
   }
 
+
 definition:
 | v=vdefinition {
     DefineValue v
   }
 
-vdefinition: // manque le type ici, on met None en attendant
+
+vdefinition:
+// manque le type ici, on met None en attendant
 | LET i=located(identifier) EQUAL e=located(expression) {
     SimpleValue(i, None, e)
-  }(*
+  }
+/* // marche pas
 | LET i=located(identifier) DPOINT ts=located(type_scheme) EQUAL e=located(expression) {
       SimpleValue(i,ts,e)
-}*)
+  } */
-  (* marche pas*)
+/* fun : int f a = 1 */
-  
 | FUN f=fundef  {
       RecFunctions([f])
   }
-(*fun : int f a = 1*)
 
-(* de même*)
+
+/* de même */
 fundef:
-|(*ts est temp*)  i=located(identifier) p=pattern EQUAL e=located(expression){
+/* ts est temp */
+| i=located(identifier) p=pattern EQUAL e=located(expression) {
     FunctionDefinition(p, e)
   }
-|(*ts est temp*)  DPOINT ts=located(type_scheme) i=located(identifier) p=pattern EQUAL e=located(expression){
+/* ts est temp */
+| DPOINT ts=located(type_scheme) i=located(identifier) p=pattern EQUAL e=located(expression) {
     FunctionDefinition(p, e)
   }
 
@@ -57,14 +62,12 @@ pattern:
   }
 
 
-
 ty:
 | tc = type_constructor {
     TyCon(tc, None)
   }
 
 (* Todo version avec l'optionnel*)
-
 | ty1=located(ty) ARROW ty2=located(ty) {
     TyArrow(ty1, ty2)
   }
@@ -78,6 +81,7 @@ ty:
     TyVar type_var
   }
 
+
 type_scheme:
 (* il faut peut être modifié le séparateur*)
 | LBRACK liste_typevar=separated_list(COMMA,located(type_variable)) RBRACK ty=located(ty) {
@@ -93,29 +97,31 @@ type_variable:
     TId tid
   }
 
+
 type_constructor:
 | tcon = TID {
     TCon tcon
   }
 
 
-
-
 expression:
 | l=located(literal) {
     Literal l
   }
 
+
 literal:
 | i=INT {
     LInt i
   }
 
+
 identifier:
 | i=ID {
     Id i
   }
 
+
 %inline located(X): x=X {
   Position.with_poss $startpos $endpos x
 }