Skip to content

Commit

Permalink
Fix module open workaround in parser interface
Browse files Browse the repository at this point in the history
  • Loading branch information
@juusaw
juusaw committed Mar 26, 2019
1 parent 5cb06d8 commit e3c2d53
Show file tree
Hide file tree
Showing 3 changed files with 100 additions and 103 deletions.
1 change: 0 additions & 1 deletion build.sh
View file
Original file line number Diff line number Diff line change
@@ -1,5 +1,4 @@
ocamlyacc parser.mly
echo "open Syntax\n\n$(cat parser.mli)" > parser.mli
ocamllex Lexer.mll
ocamlc -o troll \
syntax.ml\
Expand Down
4 changes: 1 addition & 3 deletions parser.mli
View file
Original file line number Diff line number Diff line change
@@ -1,5 +1,3 @@
open Syntax

type token =
| NUM of (int*(int*int))
| ID of (string*(int*int))
Expand Down Expand Up @@ -74,4 +72,4 @@ type token =
| FLOAT of (float*(int*int))

val dice :
(Lexing.lexbuf -> token) -> Lexing.lexbuf -> Syntax.program
(Lexing.lexbuf -> token) -> Lexing.lexbuf -> Syntax.Syntax.program
198 changes: 99 additions & 99 deletions parser.mly
View file
Original file line number Diff line number Diff line change
@@ -1,6 +1,6 @@
%{

open Syntax
module S = Syntax

let p0 = (0,0)

Expand All @@ -9,35 +9,35 @@ let fst x = let y, _ = x in y
let snd x = let _, y = x in y

let makeUnaryFunction (name, constr) =
(name, Syntax.Func (["x"],
constr (Syntax.ID ("x", p0), p0),
(name, S.Syntax.Func (["x"],
constr (S.Syntax.ID ("x", p0), p0),
p0))

let makeBinaryFunction (name, constr) =
(name, Syntax.Func (["x"; "y"],
constr (Syntax.ID ("x", p0),
Syntax.ID ("y", p0),
(name, S.Syntax.Func (["x"; "y"],
constr (S.Syntax.ID ("x", p0),
S.Syntax.ID ("y", p0),
p0),
p0))

let predef = List.map makeUnaryFunction
[("-", (fun (x, y) -> Syntax.UMINUS (x, y)));
("d", (fun (x, y) -> Syntax.D (x, y)));
("z", (fun (x, y) -> Syntax.Z (x, y)));
("sum",(fun (x, y) -> Syntax.SUM (x, y)));
("sign",(fun (x, y) -> Syntax.SIGN (x, y)));
("count",(fun (x, y) -> Syntax.COUNT (x, y)));
("min",fun (e,p) -> Syntax.LEAST (Syntax.NUM (1,p0),e,p));
("max",fun (e,p) -> Syntax.LARGEST (Syntax.NUM (1,p0),e,p));
("minimal", (fun (x, y) -> Syntax.MINIMAL (x, y)));
("maximal", (fun (x, y) -> Syntax.MAXIMAL (x, y)));
("choose", (fun (x, y) -> Syntax.CHOOSE (x, y)));
("different", (fun (x, y) -> Syntax.DIFFERENT (x, y))) ]
[("-", (fun (x, y) -> S.Syntax.UMINUS (x, y)));
("d", (fun (x, y) -> S.Syntax.D (x, y)));
("z", (fun (x, y) -> S.Syntax.Z (x, y)));
("sum",(fun (x, y) -> S.Syntax.SUM (x, y)));
("sign",(fun (x, y) -> S.Syntax.SIGN (x, y)));
("count",(fun (x, y) -> S.Syntax.COUNT (x, y)));
("min",fun (e,p) -> S.Syntax.LEAST (S.Syntax.NUM (1,p0),e,p));
("max",fun (e,p) -> S.Syntax.LARGEST (S.Syntax.NUM (1,p0),e,p));
("minimal", (fun (x, y) -> S.Syntax.MINIMAL (x, y)));
("maximal", (fun (x, y) -> S.Syntax.MAXIMAL (x, y)));
("choose", (fun (x, y) -> S.Syntax.CHOOSE (x, y)));
("different", (fun (x, y) -> S.Syntax.DIFFERENT (x, y))) ]
@
List.map makeBinaryFunction
[("+", (fun (x, y, z) -> Syntax.PLUS (x, y, z)));
("*", (fun (x, y, z) -> Syntax.TIMES (x, y, z)));
("U", (fun (x, y, z) -> Syntax.CONC (x, y, z)))]
[("+", (fun (x, y, z) -> S.Syntax.PLUS (x, y, z)));
("*", (fun (x, y, z) -> S.Syntax.TIMES (x, y, z)));
("U", (fun (x, y, z) -> S.Syntax.CONC (x, y, z)))]
%}

%token <int*(int*int)> NUM
Expand Down Expand Up @@ -69,11 +69,11 @@ let predef = List.map makeUnaryFunction
%left D Z

%start dice
%type <Syntax.program> dice
%type <string * Syntax.declaration> Decl
%type <(string * Syntax.declaration) list> Decls
%type <Syntax.exp> Exp ExpList ExpList1
%type <Syntax.exp list> ExpList2
%type <Syntax.Syntax.program> dice
%type <string * S.Syntax.declaration> Decl
%type <(string * S.Syntax.declaration) list> Decls
%type <S.Syntax.exp> Exp ExpList ExpList1
%type <S.Syntax.exp list> ExpList2
%type <string list> Ids
%type <string> IDorUnop IDorBinop

Expand All @@ -90,9 +90,9 @@ Decls:

Decl:
FUNCTION ID LPAR Ids RPAR EQ Exp %prec FUNCTION
{ (fst $2, Syntax.Func ($4, $7, $1)) }
{ (fst $2, S.Syntax.Func ($4, $7, $1)) }
| COMPOSITIONAL ID LPAR Exp COMMA IDorUnop COMMA IDorBinop RPAR
{ (fst $2, Syntax.Comp ($4, $6, $8, $1)) }
{ (fst $2, S.Syntax.Comp ($4, $6, $8, $1)) }
;

IDorUnop:
Expand Down Expand Up @@ -122,131 +122,131 @@ Ids:
;

Exp:
NUM { Syntax.NUM (fst $1, snd $1) }
| ID { Syntax.ID (fst $1, snd $1) }
| Exp CONC Exp { Syntax.CONC ($1,$3, $2) }
| CHOOSE Exp { Syntax.CHOOSE ($2, $1) }
| DIFFERENT Exp { Syntax.DIFFERENT ($2, $1) }
NUM { S.Syntax.NUM (fst $1, snd $1) }
| ID { S.Syntax.ID (fst $1, snd $1) }
| Exp CONC Exp { S.Syntax.CONC ($1,$3, $2) }
| CHOOSE Exp { S.Syntax.CHOOSE ($2, $1) }
| DIFFERENT Exp { S.Syntax.DIFFERENT ($2, $1) }
| LBRACE ExpList RBRACE
{ $2 }
| Exp PLUS Exp { Syntax.PLUS ($1,$3, $2) }
| Exp MINUS Exp { Syntax.MINUS ($1,$3, $2) }
| Exp TIMES Exp { Syntax.TIMES ($1,$3, $2) }
| Exp PLUS Exp { S.Syntax.PLUS ($1,$3, $2) }
| Exp MINUS Exp { S.Syntax.MINUS ($1,$3, $2) }
| Exp TIMES Exp { S.Syntax.TIMES ($1,$3, $2) }
| Exp DIVIDE Exp
{ Syntax.DIVIDE ($1,$3, $2) }
| Exp MOD Exp { Syntax.MOD ($1,$3, $2) }
{ S.Syntax.DIVIDE ($1,$3, $2) }
| Exp MOD Exp { S.Syntax.MOD ($1,$3, $2) }
| MINUS Exp %prec UMINUS
{ Syntax.UMINUS ($2, $1) }
| D Exp { Syntax.D ($2, $1) }
| Z Exp { Syntax.Z ($2, $1) }
| SUM Exp { Syntax.SUM ($2, $1) }
| SIGN Exp { Syntax.SIGN ($2, $1) }
| COUNT Exp { Syntax.COUNT ($2, $1) }
| LEAST Exp Exp { Syntax.LEAST ($2,$3, $1) }
| MIN Exp { Syntax.LEAST (Syntax.NUM (1,$1),$2, $1) }
{ S.Syntax.UMINUS ($2, $1) }
| D Exp { S.Syntax.D ($2, $1) }
| Z Exp { S.Syntax.Z ($2, $1) }
| SUM Exp { S.Syntax.SUM ($2, $1) }
| SIGN Exp { S.Syntax.SIGN ($2, $1) }
| COUNT Exp { S.Syntax.COUNT ($2, $1) }
| LEAST Exp Exp { S.Syntax.LEAST ($2,$3, $1) }
| MIN Exp { S.Syntax.LEAST (S.Syntax.NUM (1,$1),$2, $1) }
| LARGEST Exp Exp
{ Syntax.LARGEST ($2,$3, $1) }
| MAX Exp { Syntax.LARGEST (Syntax.NUM (1,$1),$2, $1) }
| MEDIAN Exp { Syntax.MEDIAN ($2, $1) }
| MINIMAL Exp { Syntax.MINIMAL ($2, $1) }
| MAXIMAL Exp { Syntax.MAXIMAL ($2, $1) }
| Exp HASH Exp { Syntax.HASH ($1,$3, $2) }
| Exp AND Exp { Syntax.AND ($1,$3, $2) }
{ S.Syntax.LARGEST ($2,$3, $1) }
| MAX Exp { S.Syntax.LARGEST (S.Syntax.NUM (1,$1),$2, $1) }
| MEDIAN Exp { S.Syntax.MEDIAN ($2, $1) }
| MINIMAL Exp { S.Syntax.MINIMAL ($2, $1) }
| MAXIMAL Exp { S.Syntax.MAXIMAL ($2, $1) }
| Exp HASH Exp { S.Syntax.HASH ($1,$3, $2) }
| Exp AND Exp { S.Syntax.AND ($1,$3, $2) }
| Exp D Exp %prec HASH
{ Syntax.HASH ($1,Syntax.D ($3, $2), $2) }
{ S.Syntax.HASH ($1,S.Syntax.D ($3, $2), $2) }
| Exp Z Exp %prec HASH
{ Syntax.HASH ($1,Syntax.Z ($3, $2), $2) }
| Exp EQ Exp { Syntax.EQ ($1,$3, $2) }
| Exp NEQ Exp { Syntax.NEQ ($1,$3, $2) }
| Exp LT Exp { Syntax.LT ($1,$3, $2) }
| Exp GT Exp { Syntax.GT ($1,$3, $2) }
| Exp LE Exp { Syntax.LE ($1,$3, $2) }
| Exp GE Exp { Syntax.GE ($1,$3, $2) }
| Exp DROP Exp { Syntax.DROP ($1,$3, $2) }
| Exp KEEP Exp { Syntax.KEEP ($1,$3, $2) }
| Exp PICK Exp { Syntax.PICK ($1,$3, $2) }
{ S.Syntax.HASH ($1,S.Syntax.Z ($3, $2), $2) }
| Exp EQ Exp { S.Syntax.EQ ($1,$3, $2) }
| Exp NEQ Exp { S.Syntax.NEQ ($1,$3, $2) }
| Exp LT Exp { S.Syntax.LT ($1,$3, $2) }
| Exp GT Exp { S.Syntax.GT ($1,$3, $2) }
| Exp LE Exp { S.Syntax.LE ($1,$3, $2) }
| Exp GE Exp { S.Syntax.GE ($1,$3, $2) }
| Exp DROP Exp { S.Syntax.DROP ($1,$3, $2) }
| Exp KEEP Exp { S.Syntax.KEEP ($1,$3, $2) }
| Exp PICK Exp { S.Syntax.PICK ($1,$3, $2) }
| Exp SETMINUS Exp
{ Syntax.SETMINUS ($1,$3, $2) }
{ S.Syntax.SETMINUS ($1,$3, $2) }
| Exp DOTDOT Exp
{ Syntax.FROMTO ($1,$3, $2) }
{ S.Syntax.FROMTO ($1,$3, $2) }
| ID ASSGN Exp SEMI Exp
{ Syntax.LET (fst $1,$3,$5, $2) }
{ S.Syntax.LET (fst $1,$3,$5, $2) }
| ACCUM ID ASSGN Exp WHILE Exp
{ Syntax.ACCUM (fst $2,$4,$6, true, $1) }
{ S.Syntax.ACCUM (fst $2,$4,$6, true, $1) }
| ACCUM ID ASSGN Exp UNTIL Exp
{ Syntax.ACCUM (fst $2,$4,$6, false, $1) }
{ S.Syntax.ACCUM (fst $2,$4,$6, false, $1) }
| REPEAT ID ASSGN Exp WHILE Exp
{ Syntax.REPEAT (fst $2,$4,$6, true, $1) }
{ S.Syntax.REPEAT (fst $2,$4,$6, true, $1) }
| REPEAT ID ASSGN Exp UNTIL Exp
{ Syntax.REPEAT (fst $2,$4,$6, false, $1) }
{ S.Syntax.REPEAT (fst $2,$4,$6, false, $1) }
| FOREACH ID IN Exp DO Exp
{ Syntax.FOREACH (fst $2,$4,$6, $1) }
{ S.Syntax.FOREACH (fst $2,$4,$6, $1) }
| IF Exp THEN Exp ELSE Exp
{ Syntax.IF ($2,$4,$6, $1) }
{ S.Syntax.IF ($2,$4,$6, $1) }
| CALL ID LPAR ExpList2 RPAR
{ Syntax.CALL (fst $2, $4, $1) }
{ S.Syntax.CALL (fst $2, $4, $1) }
| STRINGS { let
pos = snd $1 in
let rec build = function
[] -> Syntax.STRING ("" ,pos)
| [s] -> Syntax.STRING (s,pos)
[] -> S.Syntax.STRING ("" ,pos)
| [s] -> S.Syntax.STRING (s,pos)
| ("|>" :: ss) ->
Syntax.VCONCL(Syntax.STRING ("",pos),
S.Syntax.VCONCL(S.Syntax.STRING ("",pos),
build ss,pos)
| ("<|" :: ss) ->
Syntax.VCONCR(Syntax.STRING ("",pos),
S.Syntax.VCONCR(S.Syntax.STRING ("",pos),
build ss,pos)
| ("<>" :: ss) ->
Syntax.VCONCC(Syntax.STRING ("",pos),
S.Syntax.VCONCC(S.Syntax.STRING ("",pos),
build ss,pos)
| ("||" :: ss) ->
Syntax.HCONC(Syntax.STRING ("",pos),
S.Syntax.HCONC(S.Syntax.STRING ("",pos),
build ss,pos)
| (s :: "|>" :: ss) ->
Syntax.VCONCL(Syntax.STRING (s,pos),
S.Syntax.VCONCL(S.Syntax.STRING (s,pos),
build ss,pos)
| (s :: "<|" :: ss) ->
Syntax.VCONCR(Syntax.STRING (s,pos),
S.Syntax.VCONCR(S.Syntax.STRING (s,pos),
build ss,pos)
| (s :: "<>" :: ss) ->
Syntax.VCONCC(Syntax.STRING (s,pos),
S.Syntax.VCONCC(S.Syntax.STRING (s,pos),
build ss,pos)
| (s :: "||" :: ss) ->
Syntax.HCONC(Syntax.STRING (s,pos),
S.Syntax.HCONC(S.Syntax.STRING (s,pos),
build ss,pos)
| (s :: ss) ->
Syntax.HCONC(Syntax.STRING (s,pos),
S.Syntax.HCONC(S.Syntax.STRING (s,pos),
build ss,pos)
in
build (fst $1)

}
| SAMPLE Exp { Syntax.SAMPLE ($2, $1) }
| SAMPLE Exp { S.Syntax.SAMPLE ($2, $1) }
| Exp SAMPLE Exp %prec HASH
{ Syntax.SAMPLES ($1, $3, $2) }
| Exp HCONC Exp { Syntax.HCONC ($1,$3,$2) }
| Exp VCONCL Exp { Syntax.VCONCL ($1,$3,$2) }
| Exp VCONCR Exp { Syntax.VCONCR ($1,$3,$2) }
| Exp VCONCC Exp { Syntax.VCONCC ($1,$3,$2) }
| QUESTION FLOAT { Syntax.QUESTION (fst $2, $1) }
| FIRST Exp { Syntax.FIRST ($2, $1) }
| SECOND Exp { Syntax.SECOND ($2, $1) }
{ S.Syntax.SAMPLES ($1, $3, $2) }
| Exp HCONC Exp { S.Syntax.HCONC ($1,$3,$2) }
| Exp VCONCL Exp { S.Syntax.VCONCL ($1,$3,$2) }
| Exp VCONCR Exp { S.Syntax.VCONCR ($1,$3,$2) }
| Exp VCONCC Exp { S.Syntax.VCONCC ($1,$3,$2) }
| QUESTION FLOAT { S.Syntax.QUESTION (fst $2, $1) }
| FIRST Exp { S.Syntax.FIRST ($2, $1) }
| SECOND Exp { S.Syntax.SECOND ($2, $1) }
| LBRACK Exp COMMA Exp RBRACK
{ Syntax.PAIR ($2, $4, $3) }
| BANG Exp { Syntax.IF ($2, Syntax.EMPTY, Syntax.NUM (1,$1), $1) }
| ID TILDE Exp { Syntax.DEFAULT (fst $1, $3, $2) }
{ S.Syntax.PAIR ($2, $4, $3) }
| BANG Exp { S.Syntax.IF ($2, S.Syntax.EMPTY, S.Syntax.NUM (1,$1), $1) }
| ID TILDE Exp { S.Syntax.DEFAULT (fst $1, $3, $2) }
| LPAR Exp RPAR { $2 }
;

ExpList:
{ Syntax.EMPTY }
{ S.Syntax.EMPTY }
| ExpList1 { $1 }
;

ExpList1:
Exp { $1 }
| Exp COMMA ExpList1
{ Syntax.CONC ($1,$3, $2) }
{ S.Syntax.CONC ($1,$3, $2) }
;

ExpList2:
Expand Down

0 comments on commit e3c2d53

Please sign in to comment.