Paris7/compilation
Archived
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Activity

conflict

Browse source
This commit is contained in:
Nicolas PENELOUX 2023-10-20 20:48:23 +02:00
commit 8ed2b0c51f
5 changed files with 141 additions and 113 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
flap/src/hopix/hopixAST.ml
View file

@ -110,7 +110,7 @@ and branch =
| Branch of pattern located * expression located | Branch of pattern located * expression located
and ty = and ty =
(** An instantiated type constructor [t <ty₁, .., tyₙ>]. *) (** An instantiated type constructor [t <ty₁, ..., tyₙ>]. *)
| TyCon of type_constructor * ty located list | TyCon of type_constructor * ty located list
(** A function type [ty₁ → ty₂]. *) (** A function type [ty₁ → ty₂]. *)
| TyArrow of ty located * ty located | TyArrow of ty located * ty located

242
flap/src/hopix/hopixParser.mly
View file

@ -30,8 +30,8 @@ program:
} }
/* Attrapes les erreurs de syntaxe */ /* Attrapes les erreurs de syntaxe */
| e=located(error) { | e=located(error) {
Error.error "parsing" (Position.position e) "Syntax error." Error.error "parsing" (Position.position e) "Syntax error."
} }
definition: definition:
@ -71,7 +71,9 @@ list_ty: LPAREN l=separated_nonempty_list(COMMA,located(ty)) RPAREN {
label_with_type: label_with_type:
| l=located(label) COLON t=located(ty) { l, t } | l=located(label) COLON t=located(ty) {
l, t
}
vdefinition: vdefinition:
@ -108,17 +110,17 @@ fundef:
* TODO : y'a environ 50 warnings ici, surtout au niveau du POr et PAnd */ * TODO : y'a environ 50 warnings ici, surtout au niveau du POr et PAnd */
branches: branches:
| b=separated_nonempty_list(PIPE,located(branch)){ | b=separated_nonempty_list(PIPE, located(branch)) {
b b
} }
| PIPE b = separated_nonempty_list(PIPE,located(branch)){ | PIPE b=separated_nonempty_list(PIPE, located(branch)) {
b b
} }
branch: branch:
| p = located(pattern) ARROW e=located(expression){ | p=located(pattern) ARROW e=located(expression) {
Branch(p,e) Branch(p, e)
} }
simple_pattern: simple_pattern:
@ -136,7 +138,7 @@ simple_pattern:
} }
/* Annotation de type */ /* Annotation de type */
| p=located(simple_pattern) COLON ty=located(ty) { | p=located(simple_pattern) COLON ty=located(ty) {
PTypeAnnotation(p,ty) PTypeAnnotation(p, ty)
} }
/* Entier / Caractère / String */ /* Entier / Caractère / String */
| l=located(literal) { | l=located(literal) {
@ -160,7 +162,7 @@ simple_pattern:
| LBRACE l=separated_nonempty_list(COMMA, separated_pair(located(label), EQUAL, located(pattern))) RBRACE { | LBRACE l=separated_nonempty_list(COMMA, separated_pair(located(label), EQUAL, located(pattern))) RBRACE {
PRecord(l, None) PRecord(l, None)
} }
| LBRACE l=separated_nonempty_list(COMMA,separated_pair(located(label), EQUAL, located(pattern))) RBRACE INFERIOR SUPERIOR { | LBRACE l=separated_nonempty_list(COMMA, separated_pair(located(label), EQUAL, located(pattern))) RBRACE INFERIOR SUPERIOR {
PRecord(l, None) PRecord(l, None)
} }
| LBRACE l=separated_nonempty_list(COMMA, separated_pair(located(label), EQUAL, located(pattern))) RBRACE INFERIOR liste_ty=option(separated_nonempty_list(COMMA, located(ty))) SUPERIOR { | LBRACE l=separated_nonempty_list(COMMA, separated_pair(located(label), EQUAL, located(pattern))) RBRACE INFERIOR liste_ty=option(separated_nonempty_list(COMMA, located(ty))) SUPERIOR {
@ -169,17 +171,17 @@ simple_pattern:
/* Disjonction */ /* Disjonction */
pattern: pattern:
| p1=pattern_and{ | p1=pattern_and {
p1 p1
} }
| p1=located(pattern_and) PIPE p_list=separated_nonempty_list(PIPE, located(pattern_and)) { | p1=located(pattern_and) PIPE p_list=separated_nonempty_list(PIPE, located(pattern_and)) {
POr(p1 :: p_list) POr(p1 :: p_list)
} }
/* Conjonction */ /* Conjonction */
pattern_and: pattern_and:
| p1=simple_pattern{ | p1=simple_pattern{
p1 p1
} }
| p1=located(simple_pattern) AND p_list=separated_nonempty_list(AND, located(simple_pattern)) { | p1=located(simple_pattern) AND p_list=separated_nonempty_list(AND, located(simple_pattern)) {
PAnd(p1 :: p_list) PAnd(p1 :: p_list)
} }
@ -194,10 +196,10 @@ pattern_list:
/********************************* DATA TYPE **********************************/ /********************************* DATA TYPE **********************************/
/* Pour résoudre un conflit, on a du split ty en 2 règles /* Pour résoudre un conflit, on a du split ty en 2 règles
* *
* separated_nonempty_list(STAR,located(ty)) -> ty STAR separated_nonempty_list(STAR,located(ty)) * separated_nonempty_list(STAR, located(ty)) -> ty STAR separated_nonempty_list(STAR, located(ty))
* [ ty ] -> ty * [ ty ] * [ ty ] -> ty * [ ty ]
* ET * ET
* ty -> ty STAR separated_nonempty_list(STAR,located(ty)) * ty -> ty STAR separated_nonempty_list(STAR, located(ty))
* ty -> ty * [ ty ] * ty -> ty * [ ty ]
*/ */
simple_ty: simple_ty:
@ -253,112 +255,117 @@ simple_expression:
| l=located(literal) { | l=located(literal) {
Literal l Literal l
} }
/* Variable */ /* Variable */
| i = located(identifier){ | i=located(identifier) {
Variable(i,None) Variable(i, None)
} }
| i = located(identifier) INFERIOR SUPERIOR { | i=located(identifier) INFERIOR SUPERIOR {
Variable(i,None) Variable(i, None)
} }
| i = located(identifier) INFERIOR t_list = option(separated_nonempty_list(COMMA,located(ty))) SUPERIOR{ | i=located(identifier) INFERIOR t_list=option(separated_nonempty_list(COMMA, located(ty))) SUPERIOR {
Variable(i,t_list) Variable(i, t_list)
} }
/* Tuple n = 0 and n > 1 */ /* Tuple n = 0 and n > 1 */
| LPAREN RPAREN { | LPAREN RPAREN {
Tuple([]) Tuple([])
} }
| LPAREN e=located(expression) COMMA e_list = separated_nonempty_list(COMMA,located(expression)) RPAREN { | LPAREN e=located(expression) COMMA e_list=separated_nonempty_list(COMMA, located(expression)) RPAREN {
Tuple(e::e_list) Tuple(e::e_list)
} }
/* Tagged Value*/ /* Tagged Value*/
/* K */ /* K */
| const = located(constructor){ | const=located(constructor) {
Tagged(const,None,[]) Tagged(const, None, [])
} }
/* K < > */ /* K < > */
| const = located(constructor) INFERIOR SUPERIOR{ | const=located(constructor) INFERIOR SUPERIOR {
Tagged(const,None,[]) Tagged(const, None, [])
} }
/* K < > (e1, ..., en) */ /* K < > (e1, ..., en) */
| const = located(constructor) INFERIOR SUPERIOR LPAREN e_list=separated_nonempty_list(COMMA,located(expression)) RPAREN { | const=located(constructor) INFERIOR SUPERIOR LPAREN e_list=separated_nonempty_list(COMMA, located(expression)) RPAREN {
Tagged(const,None,e_list) Tagged(const, None, e_list)
} }
/* K <ty_1, ... ty_m> */ /* K <ty_1, ... ty_m> */
| const = located(constructor) INFERIOR t_list = option(separated_nonempty_list(COMMA,located(ty))) SUPERIOR { | const=located(constructor) INFERIOR t_list=option(separated_nonempty_list(COMMA, located(ty))) SUPERIOR {
Tagged(const,t_list,[]) Tagged(const, t_list, [])
} }
/* K <ty_1, ..., ty_m> (e1,...,en) */ /* K <ty_1, ..., ty_m> (e1, ..., en) */
| const = located(constructor) INFERIOR t_list = option(separated_nonempty_list(COMMA,located(ty))) SUPERIOR LPAREN e_list=separated_nonempty_list(COMMA,located(expression)) RPAREN{ | const=located(constructor) INFERIOR t_list=option(separated_nonempty_list(COMMA, located(ty))) SUPERIOR LPAREN e_list=separated_nonempty_list(COMMA, located(expression)) RPAREN {
Tagged(const,t_list,e_list) Tagged(const, t_list, e_list)
} }
/* Record */ /* Record */
| LBRACE l=separated_nonempty_list(COMMA, separated_pair(located(label), EQUAL, located(expression))) RBRACE { | LBRACE l=separated_nonempty_list(COMMA, separated_pair(located(label), EQUAL, located(expression))) RBRACE {
Record(l, None) Record(l, None)
} }
| LBRACE l=separated_nonempty_list(COMMA, separated_pair(located(label), EQUAL, located(expression))) RBRACE INFERIOR SUPERIOR { | LBRACE l=separated_nonempty_list(COMMA, separated_pair(located(label), EQUAL, located(expression))) RBRACE INFERIOR SUPERIOR {
Record(l, None) Record(l, None)
} }
| LBRACE l=separated_nonempty_list(COMMA, separated_pair(located(label), EQUAL, located(expression))) RBRACE INFERIOR t_list = option(separated_nonempty_list(COMMA,located(ty))) SUPERIOR{ | LBRACE l=separated_nonempty_list(COMMA, separated_pair(located(label), EQUAL, located(expression))) RBRACE INFERIOR t_list=option(separated_nonempty_list(COMMA, located(ty))) SUPERIOR {
Record(l, t_list) Record(l, t_list)
} }
/* Lecture de variable */ /* Lecture de variable */
/* ! expr */ /* ! expr */
| EXCLA e=located(simple_expression) { | EXCLA e=located(simple_expression) {
Read(e) Read(e)
} }
expression:
| e=simple_expression{ expression:
| e=simple_expression {
e e
} }
/* Field */ /* Field */
/* e.l */ /* e.l */
| e=located(expression) DOT l = located(label){ | e=located(expression) DOT l=located(label) {
Field(e,l,None) Field(e, l, None)
} }
/* e.l < > */ /* e.l < > */
| e=located(expression) DOT l = located(label) INFERIOR SUPERIOR { | e=located(expression) DOT l=located(label) INFERIOR SUPERIOR {
Field(e,l,None) Field(e, l, None)
} }
/* e.l <ty_1...ty_n>*/ /* e.l <ty_1...ty_n>*/
| e = located(expression) DOT l=located(label) INFERIOR t_list = option(separated_nonempty_list(COMMA,located(ty))) SUPERIOR { | e=located(expression) DOT l=located(label) INFERIOR t_list=option(separated_nonempty_list(COMMA, located(ty))) SUPERIOR {
Field(e,l,t_list) Field(e, l, t_list)
} }
/* Sequence */ /* Sequence */
/* Pas sûr, voir s'il ne fuat pas une troisième couche d'expression */ /* Pas sûr, voir s'il ne fuat pas une troisième couche d'expression */
| e = located(simple_expression) SEMICOLON e_list = separated_nonempty_list(SEMICOLON,located(simple_expression)){ | e=located(simple_expression) SEMICOLON e_list=separated_nonempty_list(SEMICOLON, located(simple_expression)) {
Sequence(e::e_list) Sequence(e::e_list)
} }
/* Definition locale */ /* Definition locale */
| vd= vdefinition SEMICOLON e=located(expression){ | vd=vdefinition SEMICOLON e=located(expression) {
Define(vd,e) Define(vd, e)
} }
/* Fonction anonyme */ /* Fonction anonyme */
| BACKSLASH p=located(pattern) ARROW e=located(expression){ | BACKSLASH p=located(pattern) ARROW e=located(expression) {
Fun(FunctionDefinition(p,e)) Fun(FunctionDefinition(p, e))
} }
/* Application */ /* Application */
| e1=located(expression) e2=located(expression){ | e1=located(expression) e2=located(expression) {
Apply(e1,e2) Apply(e1, e2)
} }
<<<<<<< HEAD
=======
/* TODO operation binaire mais j'ai pas très bien compris encore */
/* Match (exp) {| ...| ... | ...} */ >>>>>>> 726daf228d20fae695ecf903491c8b62d9e6a673
| MATCH LPAREN e=located(expression) RPAREN
LBRACE b=branches RBRACE {
Case(e,b)
}
/* Match (exp) {| ...| ... | ...} */
| MATCH LPAREN e=located(expression) RPAREN LBRACE b=branches RBRACE {
Case(e, b)
}
<<<<<<< HEAD
/* TODO if ( exp ) then { expr } j'ai RIEN COMPRIS */ /* TODO if ( exp ) then { expr } j'ai RIEN COMPRIS */
/* /*
@ -375,46 +382,69 @@ simple_expression:
} }
/* Reference ref expr */ /* Reference ref expr */
=======
/* TODO if ( exp ) then { expr } j'ai RIEN COMPRIS */
/* | IF LPAREN e=located(expression) RPAREN
THEN LBRACE e2=located(expression) RBRACE {
IfThenElse(e, e2, None)
} */
>>>>>>> 726daf228d20fae695ecf903491c8b62d9e6a673
| REF e=located(expression){ /* if ( expr ) then { expr } else { expr } */
| IF LPAREN e=located(expression) RPAREN
THEN LBRACE e2=located(expression) RBRACE
ELSE LBRACE e3=located(expression) RBRACE {
IfThenElse(e, e2, e3)
}
/* Reference ref expr */
| REF e=located(expression) {
Ref(e) Ref(e)
} }
/* Affectation */ /* Affectation
/* expr := expr */ * expr := expr */
| e1=located(expression) ASSIGN e2=located(expression) {
| e1=located(expression) ASSIGN e2=located(expression){ Assign(e1, e2)
Assign(e1,e2)
} }
/* While */ /* While */
/* while ( expr ) { expr } */ /* while ( expr ) { expr } */
| WHILE LPAREN e=located(expression) RPAREN | WHILE LPAREN e=located(expression) RPAREN
LBRACE e2=located(expression) RBRACE { LBRACE e2=located(expression) RBRACE {
While(e,e2) While(e, e2)
} }
/* Do while TODO */ /* Do while
/* do { expr } until ( expr ) */ * do { expr } until ( expr ) */
/* TODO */
/* boucle for */ /* boucle for
/* for x in (e1 to e2) { expr } */ * for x in (e1 to e2) { expr } */
| FOR x=located(identifier) | FOR x=located(identifier)
FROM LPAREN e1=located(expression) RPAREN TO LPAREN e2=located(expression) RPAREN FROM LPAREN e1=located(expression) RPAREN TO LPAREN e2=located(expression) RPAREN
LBRACE e3=located(expression) RBRACE LBRACE e3=located(expression) RBRACE {
{ For(x,e1,e2,e3)} For(x, e1, e2, e3)
}
/* Parenthésage pas sûr mais je vois pas sinon*/ /* Parenthésage pas sûr mais je vois pas sinon */
| LPAREN e=expression RPAREN { | LPAREN e=expression RPAREN {
e e
} }
<<<<<<< HEAD
/* Annotation de type */ /* Annotation de type */
/* (e : ty) */ /* (e : ty) */
| LPAREN e=located(expression) COLON t=located(ty) RPAREN { | LPAREN e=located(expression) COLON t=located(ty) RPAREN {
TypeAnnotation(e,t) TypeAnnotation(e,t)
=======
/* Annotation de type
* (e : ty) */
| LPAREN e=located(expression) COLON t=located(ty) RPAREN {
TypeAnnotation(e, t)
>>>>>>> 726daf228d20fae695ecf903491c8b62d9e6a673
} }
@ -428,9 +458,9 @@ simple_expression:
/******************************** BASIC TYPES *********************************/ /******************************** BASIC TYPES *********************************/
type_variable: type_variable:

3
flap/src/hopix/hopixPrettyPrinter.ml
View file

@ -32,11 +32,12 @@ let rec program p =
and definition = function and definition = function
| DefineType (t, ts, tdef) -> | DefineType (t, ts, tdef) ->
let eq = match tdef with Abstract -> empty | _ -> string "=" in
nest 2 ( nest 2 (
group (group (string "type" group (group (string "type"
++ located type_constructor t ++ located type_constructor t
^^ group (type_parameters_angles ts)) ^^ group (type_parameters_angles ts))
++ string "=") ++ eq)
++ type_definition tdef) ++ type_definition tdef)
| DeclareExtern (x, t) -> | DeclareExtern (x, t) ->
group (string "extern" ++ located identifier x group (string "extern" ++ located identifier x

7
flap/src/hopix/hopixTypes.mli
View file

@ -2,11 +2,8 @@ open HopixAST
(** Abstract syntax for types. (** Abstract syntax for types.
The following internal syntax for types is the same as the one for The following internal syntax for types is the same as the one for the types
the types [ty] defined in {!HopixAST} except that all positions [ty] defined in {!HopixAST} except that all positions have been erased. *)
have been erased.
*)
type aty = type aty =
| ATyVar of type_variable | ATyVar of type_variable
| ATyCon of type_constructor * aty list | ATyCon of type_constructor * aty list

BIN
jalons/jalon-1.pdf
View file

Binary file not shown.