.gear/js_of_ocaml.spec | 167 +++++++++++++ .gear/rules | 3 + .../tags/0ab1cacba6702ea435a4ea21114ddb79d7bde84a | 24 ++ .gear/tags/list | 1 + compiler/lib/dune | 52 ++-- compiler/lib/js_parser.conflicts.reference | 0 compiler/lib/js_parser.mly | 254 +++++++++---------- compiler/lib/standard.mly | 269 --------------------- dune-project | 3 +- ppx/ppx_deriving_json/tests/ppx.mlt | 2 +- 10 files changed, 341 insertions(+), 434 deletions(-) diff --git a/.gear/js_of_ocaml.spec b/.gear/js_of_ocaml.spec new file mode 100644 index 00000000..814e070d --- /dev/null +++ b/.gear/js_of_ocaml.spec @@ -0,0 +1,167 @@ +%ifarch %ix86 armh +%def_without check +%else +%def_with check +%endif +Name: js_of_ocaml +Version: 3.11.0 +Release: alt3 +Summary: A compiler of OCaml byte-code to Javascript +License: LGPLv2 with exceptions +Group: Development/ML +Url: http://ocsigen.org/js_of_ocaml/ +Source0: %name-%version.tar +Patch0: %name-%version-%release.patch +BuildRequires: rpm-build-ocaml >= 1.4 +BuildRequires: ocaml-cmdliner-devel +BuildRequires: ocaml +BuildRequires: ocaml-cppo +BuildRequires: ocaml-graphics +BuildRequires: ocaml-findlib-devel +BuildRequires: ocaml-ocamlbuild +BuildRequires: ocaml-lwt-devel >= 2.4.4 +BuildRequires: ocaml-menhir +BuildRequires: ocaml-tyxml-devel +BuildRequires: ocaml-reactiveData-devel +BuildRequires: ocaml-yojson-devel +BuildRequires: ocaml-ppxlib-devel +BuildRequires: ocaml-fieldslib-devel +BuildRequires: dune +BuildRequires: nodejs +BuildRequires: libX11-devel +BuildRequires: ocaml-ocamldoc +%if_with check +BuildRequires: ocaml-num-devel +BuildRequires: ocaml-ppx_here-devel +BuildRequires: ocaml-ppx_hash-devel +BuildRequires: ocaml-ppx_inline_test-devel +BuildRequires: ocaml-ppx_compare-devel +BuildRequires: ocaml-time_now-devel +BuildRequires: ocaml-ppx_sexp_conv-devel +BuildRequires: ocaml-ppx_expect-devel +BuildRequires: ocaml-ppx_enumerate-devel +%endif +Requires: ocaml-%name = %version-%release +Requires: ocaml-lwt + +%description +js_of_ocaml is a compiler of OCaml byte-code to Javascript. It makes it +possible to run OCaml programs in a Web browser. +Its key features are the following: +* the whole language, and most of the standard library are +supported; +* the generated code can be used with any web server and browser; +* you can use a standard installation of OCaml to compile your +programs. In particular, you do not have to recompile a library to +use it with Js_of_ocaml. You just have to link your program with a +specific library to interface with the browser APIs. + +%package -n ocaml-%name +Summary: Runtime files for %name +Group: Development/ML +Requires: ocaml-lwt + +%description -n ocaml-%name +The ocaml-%name package contains the bytecode libraries for running +applications that use %name. + +%package -n ocaml-%name-devel +Summary: Development files for %name +Group: Development/ML +Requires: ocaml-%name = %version-%release +Requires: ocaml-lwt-devel + +%description -n ocaml-%name-devel +The ocaml-%name-devel package contains the signature +files for developing applications that use %name. + +%prep +%setup +%patch0 -p1 +# remove vendored version of the ppx_expect +rm -rf vendor + +%build +%dune_build --release @install + +%install +%dune_install + +%check +%dune_check + +%files +%_bindir/js_of_ocaml +%_bindir/jsoo_fs +%_bindir/jsoo_minify +%_bindir/jsoo_mkcmis +%_bindir/jsoo_mktop +%_bindir/jsoo_link +%_bindir/jsoo_listunits +%_man1dir/*.1* + +%files -n ocaml-%name -f ocaml-files.runtime +%doc LICENSE README.md + +%files -n ocaml-%name-devel -f ocaml-files.devel +%doc examples +%_libdir/ocaml/js_of_ocaml-ppx/ppx_js + +%changelog +* Wed Jan 05 2022 Anton Farygin 3.11.0-alt3 +- added commit 8698bab from upstream to fix incompatability with new menhir + +* Tue Jan 04 2022 Anton Farygin 3.11.0-alt2 +- fix test for changes in exception format + +* Thu Nov 04 2021 Anton Farygin 3.11.0-alt1 +- 3.11.0 + +* Mon Sep 06 2021 Anton Farygin 3.10.0-alt1 +- 3.10.0 + +* Sun Apr 04 2021 Anton Farygin 3.9.1-alt2 +- disabled check for ocaml-4.12 task + +* Sun Mar 28 2021 Anton Farygin 3.9.1-alt1 +- 3.9.1 + +* Fri Dec 11 2020 Anton Farygin 3.8.0-alt1 +- 3.8.0 + +* Sat Sep 19 2020 Anton Farygin 3.7.0-alt2 +- optimized build dependencies + +* Tue Sep 08 2020 Anton Farygin 3.7.0-alt1 +- 3.7.0 + +* Wed Jul 01 2020 Anton Farygin 3.6.0-alt1 +- 3.6.0 + +* Wed Mar 11 2020 Anton Farygin 3.5.2-alt2 +- cleaned up build requires + +* Fri Jan 31 2020 Anton Farygin 3.5.2-alt1 +- 3.5.2 + +* Sat Aug 03 2019 Anton Farygin 3.4.0-alt3 +- rebuilt with ocaml 4.08 + +* Sun Jun 09 2019 Anton Farygin 3.4.0-alt2 +- added ocambuild to BuildRequires + +* Sat May 11 2019 Anton Farygin 3.4.0-alt1 +- 3.4.0 + +* Thu Mar 14 2019 Anton Farygin 3.3.0-alt3 +- rebuilt with ocaml-yojson-1.7.0 + +* Wed Mar 13 2019 Anton Farygin 3.3.0-alt2 +- rebuilt with dune-1.8 + +* Mon Jan 21 2019 Anton Farygin 3.3.0-alt1 +- 3.3.0 + +* Fri Oct 26 2018 Anton Farygin 3.2.1-alt1 +- first build for ALT + diff --git a/.gear/rules b/.gear/rules new file mode 100644 index 00000000..02269f4c --- /dev/null +++ b/.gear/rules @@ -0,0 +1,3 @@ +spec:.gear/js_of_ocaml.spec +tar: @version@:. +diff: @version@:. . diff --git a/.gear/tags/0ab1cacba6702ea435a4ea21114ddb79d7bde84a b/.gear/tags/0ab1cacba6702ea435a4ea21114ddb79d7bde84a new file mode 100644 index 00000000..5e26b356 --- /dev/null +++ b/.gear/tags/0ab1cacba6702ea435a4ea21114ddb79d7bde84a @@ -0,0 +1,24 @@ +object 4572278dea9cc8a7d44d65b440004a2ec3bce7a7 +type commit +tag 3.11.0 +tagger Hugo Heuzard 1633159804 +0200 + +Release 3.11.0 + +CHANGES: + +* Compiler: setting tc_depth to 0 remove direct call from the tc optimization. +* Lib: add hidden, onfullscreenchange and onwebkitfullscreenchange to document +* Runtime: fixes for Windows, all tests pass +* Runtime: make all windows drive available on nodejs. +* Runtime: add support for Sys.mkdir and Sys.rmdir +* Runtime: make stdin work on nodejs +* Runtime: add support for Unix(stat,lstat,mkdir,rmdir,symlink,readlink,unlink,getuid) on nodejs. +* Runtime: add caml_raise_with_args + +* Compiler: fix toplevel generation (#1129, #1130, #1131) +* Compiler: fix predefined exn id with separate compilation +* Compiler: js stubs without 'Provides' should still allow 'Require' +* Runtime: fix handling of uncaugh exceptions +* Runtime: fix error handling of Sys.readdir +* Dune: make git version lookup more resilient diff --git a/.gear/tags/list b/.gear/tags/list new file mode 100644 index 00000000..28b7c861 --- /dev/null +++ b/.gear/tags/list @@ -0,0 +1 @@ +0ab1cacba6702ea435a4ea21114ddb79d7bde84a 3.11.0 diff --git a/compiler/lib/dune b/compiler/lib/dune index 7c60eb4b..2fefafb3 100644 --- a/compiler/lib/dune +++ b/compiler/lib/dune @@ -19,43 +19,23 @@ (ocamllex js_lexer annot_lexer) -;; cp $(ocamlfind printconf path)/menhir/standard.mly standard.mly - -;; menhir is just noisy, both because this parser has conflicts, or -;; because we don't use --infer (to avoid having to write manually and -;; badly specified dependencieds), so we just discard stderr. - -(rule - (targets js_parser.mli js_parser.ml js_parser.conflicts) - (deps standard.mly) - (action - (run - menhir - --stdlib - . - --table - --external-tokens - Js_token - --explain - %{dep:js_parser.mly} - --unused-token - TComment - --unused-token - TCommentLineDirective - --unused-token - TUnknown))) - -(rule - (alias runtest) - (deps js_parser.conflicts.reference js_parser.conflicts) - (action - (diff js_parser.conflicts.reference js_parser.conflicts))) +(menhir + (modules js_parser) + (flags + --table + --external-tokens + Js_token + --explain + --unused-token + TComment + --unused-token + TCommentLineDirective + --unused-token + TUnknown)) -(rule - (targets annot_parser.mli annot_parser.ml) - (deps standard.mly) - (action - (run menhir --stdlib . --explain %{dep:annot_parser.mly}))) +(menhir + (modules annot_parser) + (flags --explain)) (rule (targets compiler_version.ml) diff --git a/compiler/lib/js_parser.conflicts.reference b/compiler/lib/js_parser.conflicts.reference deleted file mode 100644 index e69de29b..00000000 diff --git a/compiler/lib/js_parser.mly b/compiler/lib/js_parser.mly index 94743e2c..09a43b3e 100644 --- a/compiler/lib/js_parser.mly +++ b/compiler/lib/js_parser.mly @@ -29,9 +29,9 @@ * - jslint *) -module J = Javascript +open Javascript -let var pi name = J.ident ~loc:(Pi pi) name +let var pi name = ident ~loc:(Pi pi) name %} @@ -147,9 +147,9 @@ standalone_expression: source_element: | statement - { let statement, pi = $1 in J.Statement statement, pi } + { let statement, pi = $1 in Statement statement, pi } | function_declaration - { let declaration, pi = $1 in J.Function_declaration declaration, pi } + { let declaration, pi = $1 in Function_declaration declaration, pi } (*************************************************************************) (* 1 statement *) @@ -158,7 +158,7 @@ source_element: statement_no_semi: | block=curly_block(statement*) { let statements, pi_start, _pi_end = block in - J.Block statements, J.Pi pi_start } + Block statements, Pi pi_start } | s=if_statement | s=while_statement | s=for_statement @@ -184,7 +184,7 @@ statement: | s=statement_need_semi either(T_SEMICOLON, T_VIRTUAL_SEMICOLON) { s } labeled_statement: -| l=label T_COLON s=statement { J.Labelled_statement (l, s), J.N } +| l=label T_COLON s=statement { Labelled_statement (l, s), N } block: | block=curly_block(statement*) @@ -192,64 +192,64 @@ block: variable_statement: | pi=T_VAR list=separated_nonempty_list(T_COMMA, pair(variable, initializer_?)) - { J.Variable_statement list, J.Pi pi } + { Variable_statement list, Pi pi } initializer_: - | pi=T_ASSIGN e=assignment_expression { e, J.Pi pi } + | pi=T_ASSIGN e=assignment_expression { e, Pi pi } empty_statement: - | pi=T_SEMICOLON { J.Empty_statement, J.Pi pi } + | pi=T_SEMICOLON { Empty_statement, Pi pi } debugger_statement: - | pi=T_DEBUGGER { J.Debugger_statement, J.Pi pi } + | pi=T_DEBUGGER { Debugger_statement, Pi pi } expression_statement: - | expression_no_statement { J.Expression_statement $1, J.N } + | expression_no_statement { Expression_statement $1, N } if_statement: | pi=T_IF condition=parenthesised(expression) t=statement T_ELSE e=statement - { (J.If_statement (condition, t, Some e), J.Pi pi) } + { (If_statement (condition, t, Some e), Pi pi) } | pi=T_IF condition=parenthesised(expression) t=statement %prec p_IF - { (J.If_statement (condition, t, None), J.Pi pi) } + { (If_statement (condition, t, None), Pi pi) } do_while_statement: | pi=T_DO body=statement T_WHILE condition=parenthesised(expression) - { (J.Do_while_statement (body, condition), J.Pi pi) } + { (Do_while_statement (body, condition), Pi pi) } while_statement: | pi=T_WHILE condition=parenthesised(expression) body=statement - { (J.While_statement (condition, body), J.Pi pi) } + { (While_statement (condition, body), Pi pi) } for_statement: | pi=T_FOR T_LPAREN initial=expression_no_in? T_SEMICOLON condition=expression? T_SEMICOLON increment=expression? T_RPAREN statement=statement - { J.For_statement (J.Left initial, condition, increment, statement), J.Pi pi } + { For_statement (Left initial, condition, increment, statement), Pi pi } | pi=T_FOR T_LPAREN T_VAR initial=separated_nonempty_list(T_COMMA, pair(variable, initializer_no_in?)) T_SEMICOLON condition=expression? T_SEMICOLON increment=expression? T_RPAREN statement=statement - { J.For_statement (J.Right initial, condition, increment, statement), J.Pi pi } + { For_statement (Right initial, condition, increment, statement), Pi pi } for_in_statement: | pi=T_FOR T_LPAREN left=left_hand_side_expression T_IN right=expression T_RPAREN body=statement - { J.ForIn_statement (J.Left left, right, body), J.Pi pi } + { ForIn_statement (Left left, right, body), Pi pi } | pi=T_FOR T_LPAREN T_VAR left=pair(variable, initializer_no_in?) T_IN right=expression T_RPAREN body=statement - { J.ForIn_statement (J.Right left, right, body), J.Pi pi } + { ForIn_statement (Right left, right, body), Pi pi } initializer_no_in: - | T_ASSIGN assignment_expression_no_in { $2, J.Pi $1 } + | T_ASSIGN assignment_expression_no_in { $2, Pi $1 } continue_statement: - | pi=T_CONTINUE label? { (J.Continue_statement $2,J.Pi pi) } + | pi=T_CONTINUE label? { (Continue_statement $2,Pi pi) } break_statement: - | pi=T_BREAK label? { (J.Break_statement $2, J.Pi pi) } + | pi=T_BREAK label? { (Break_statement $2, Pi pi) } return_statement: - | pi=T_RETURN expression? { (J.Return_statement $2, J.Pi pi) } + | pi=T_RETURN expression? { (Return_statement $2, Pi pi) } with_statement: | T_WITH parenthesised(expression) statement { assert false } @@ -259,17 +259,17 @@ switch_statement: T_LCURLY pair=pair(case_clause*, pair(default_clause, case_clause*)?) T_RCURLY { let switch = match pair with | cases, None -> - J.Switch_statement (subject, cases, None, []) + Switch_statement (subject, cases, None, []) | cases, Some (default, more_cases) -> - J.Switch_statement (subject, cases, Some default, more_cases) - in switch, J.Pi pi } + Switch_statement (subject, cases, Some default, more_cases) + in switch, Pi pi } throw_statement: - | pi=T_THROW expression { (J.Throw_statement $2, J.Pi pi) } + | pi=T_THROW expression { (Throw_statement $2, Pi pi) } try_statement: - | pi=T_TRY block catch finally? { (J.Try_statement ($2, Some $3, $4), J.Pi pi) } - | pi=T_TRY block finally { (J.Try_statement ($2, None, Some $3), J.Pi pi) } + | pi=T_TRY block catch finally? { (Try_statement ($2, Some $3, $4), Pi pi) } + | pi=T_TRY block finally { (Try_statement ($2, None, Some $3), Pi pi) } catch: | T_CATCH pair=pair(parenthesised(variable), block) { pair } @@ -295,13 +295,13 @@ function_declaration: | pi=T_FUNCTION name=variable args=parenthesised(separated_list(T_COMMA, variable)) block=curly_block(source_element*) { let elements, _pi_start, pi_end = block in - (name, args, elements, J.Pi pi_end), J.Pi pi } + (name, args, elements, Pi pi_end), Pi pi } function_expression: | pi=T_FUNCTION name=variable? args=parenthesised(separated_list(T_COMMA, variable)) block=curly_block(source_element*) { let elements, _pi_start, _pi_end = block in - pi, J.EFun (name, args, elements, J.Pi pi) } + pi, EFun (name, args, elements, Pi pi) } (*************************************************************************) (* 1 expression *) @@ -309,12 +309,12 @@ function_expression: expression: | assignment_expression { $1 } - | expression T_COMMA assignment_expression { J.ESeq ($1, $3) } + | expression T_COMMA assignment_expression { ESeq ($1, $3) } assignment_expression: | conditional_expression { $1 } | left_hand_side_expression assignment_operator assignment_expression - { J.EBin ($2, $1, $3) } + { EBin ($2, $1, $3) } left_hand_side_expression: | new_expression { snd $1 } @@ -327,49 +327,49 @@ conditional_expression: ternary(condition, consequence): | condition=condition T_PLING consequence=consequence T_COLON alternative=consequence - { J.ECond (condition, consequence, alternative) } + { ECond (condition, consequence, alternative) } post_in_expression: | pre_in_expression { $1 } | left=post_in_expression op=comparison_or_logical_or_bit_operator right=post_in_expression - { J.EBin (op, left, right) } + { EBin (op, left, right) } pre_in_expression: | left_hand_side_expression { $1 } | e=pre_in_expression op=postfix_operator | op=prefix_operator e=pre_in_expression - { J.EUn (op, e) } + { EUn (op, e) } | left=pre_in_expression op=arithmetic_or_shift_operator right=pre_in_expression - { J.EBin (op, left, right) } + { EBin (op, left, right) } call_expression: | member_expression arguments - { let (start, e) = $1 in (start, J.ECall(e, $2, J.Pi start)) } + { let (start, e) = $1 in (start, ECall(e, $2, Pi start)) } | call_expression arguments - { let (start, e) = $1 in (start, J.ECall(e, $2, J.Pi start)) } + { let (start, e) = $1 in (start, ECall(e, $2, Pi start)) } | call_expression T_LBRACKET expression T_RBRACKET - { let (start, e) = $1 in (start, J.EAccess (e, $3)) } + { let (start, e) = $1 in (start, EAccess (e, $3)) } | call_expression T_PERIOD identifier_or_kw - { let (start, e) = $1 in (start, J.EDot (e, $3)) } + { let (start, e) = $1 in (start, EDot (e, $3)) } new_expression: | member_expression { $1 } - | pi=T_NEW new_expression { (pi, J.ENew (snd $2,None)) } + | pi=T_NEW new_expression { (pi, ENew (snd $2,None)) } member_expression: | e=primary_expression { e } | member_expression T_LBRACKET e2=expression T_RBRACKET - { let (start, e1) = $1 in (start, J.EAccess (e1,e2)) } + { let (start, e1) = $1 in (start, EAccess (e1,e2)) } | member_expression T_PERIOD i=identifier_or_kw - { let (start, e1) = $1 in (start, J.EDot(e1,i)) } + { let (start, e1) = $1 in (start, EDot(e1,i)) } | pi=T_NEW e1=member_expression a=arguments - { (pi, J.ENew(snd e1, Some a)) } + { (pi, ENew(snd e1, Some a)) } primary_expression: | e=primary_expression_no_statement @@ -377,12 +377,12 @@ primary_expression: | e=function_expression { e } primary_expression_no_statement: - | pi=T_THIS { (pi, J.EVar (var pi "this")) } - | variable_with_loc { let (i, pi) = $1 in (pi, J.EVar i) } + | pi=T_THIS { (pi, EVar (var pi "this")) } + | variable_with_loc { let (i, pi) = $1 in (pi, EVar i) } | n=null_literal { n } | b=boolean_literal { b } - | numeric_literal { let (start, n) = $1 in (start, J.ENum (J.Num.of_string_unsafe n)) } - | T_STRING { let (s, start, _len) = $1 in (start, J.EStr (s, `Utf8)) } + | numeric_literal { let (start, n) = $1 in (start, ENum (Num.of_string_unsafe n)) } + | T_STRING { let (s, start, _len) = $1 in (start, EStr (s, `Utf8)) } | r=regex_literal { r } | a=array_literal { a } | pi=T_LPAREN e=expression T_RPAREN { (pi, e) } @@ -393,12 +393,12 @@ primary_expression_no_statement: expression_no_in: | assignment_expression_no_in { $1 } - | expression_no_in T_COMMA assignment_expression_no_in { J.ESeq ($1, $3) } + | expression_no_in T_COMMA assignment_expression_no_in { ESeq ($1, $3) } assignment_expression_no_in: | conditional_expression_no_in { $1 } | left_hand_side_expression assignment_operator assignment_expression_no_in - { J.EBin($2,$1,$3) } + { EBin($2,$1,$3) } conditional_expression_no_in: | post_in_expression_no_in { $1 } @@ -409,7 +409,7 @@ post_in_expression_no_in: | left=post_in_expression_no_in op=comparison_or_logical_or_bit_operator_except_in right=post_in_expression - { J.EBin (op, left, right) } + { EBin (op, left, right) } (*----------------------------*) (* 2 (no statement) *) @@ -417,12 +417,12 @@ post_in_expression_no_in: expression_no_statement: | assignment_expression_no_statement { $1 } - | expression_no_statement T_COMMA assignment_expression { J.ESeq($1,$3) } + | expression_no_statement T_COMMA assignment_expression { ESeq($1,$3) } assignment_expression_no_statement: | conditional_expression_no_statement { $1 } | left_hand_side_expression_no_statement assignment_operator assignment_expression - { J.EBin ($2,$1,$3) } + { EBin ($2,$1,$3) } conditional_expression_no_statement: | post_in_expression_no_statement { $1 } @@ -433,18 +433,18 @@ post_in_expression_no_statement: | left=post_in_expression_no_statement op=comparison_or_logical_or_bit_operator right=post_in_expression - { J.EBin (op, left, right) } + { EBin (op, left, right) } pre_in_expression_no_statement: | left_hand_side_expression_no_statement { $1 } | e=pre_in_expression_no_statement op=postfix_operator | op=prefix_operator e=pre_in_expression - { J.EUn (op, e) } + { EUn (op, e) } | left=pre_in_expression_no_statement op=arithmetic_or_shift_operator right=pre_in_expression - { J.EBin (op, left, right) } + { EBin (op, left, right) } left_hand_side_expression_no_statement: | new_expression_no_statement { snd $1 } @@ -452,38 +452,38 @@ left_hand_side_expression_no_statement: new_expression_no_statement: | member_expression_no_statement { $1 } - | pi=T_NEW new_expression { (pi, J.ENew (snd $2,None)) } + | pi=T_NEW new_expression { (pi, ENew (snd $2,None)) } call_expression_no_statement: | member_expression_no_statement arguments - { let (start, e) = $1 in (start, J.ECall(e, $2, J.Pi start)) } + { let (start, e) = $1 in (start, ECall(e, $2, Pi start)) } | call_expression_no_statement arguments - { let (start, e) = $1 in (start, J.ECall(e, $2, J.Pi start)) } + { let (start, e) = $1 in (start, ECall(e, $2, Pi start)) } | call_expression_no_statement T_LBRACKET expression T_RBRACKET - { let (start, e) = $1 in (start, J.EAccess(e, $3)) } + { let (start, e) = $1 in (start, EAccess(e, $3)) } | call_expression_no_statement T_PERIOD identifier_or_kw - { let (start, e) = $1 in (start, J.EDot(e,$3)) } + { let (start, e) = $1 in (start, EDot(e,$3)) } member_expression_no_statement: | e=primary_expression_no_statement { e } | member_expression_no_statement T_LBRACKET e2=expression T_RBRACKET - { let (start, e1) = $1 in (start, J.EAccess(e1, e2)) } + { let (start, e1) = $1 in (start, EAccess(e1, e2)) } | member_expression_no_statement T_PERIOD i=identifier_or_kw - { let (start, e1) = $1 in (start, J.EDot(e1,i)) } + { let (start, e1) = $1 in (start, EDot(e1,i)) } | pi=T_NEW e=member_expression a=arguments - { (pi, J.ENew(snd e,Some a)) } + { (pi, ENew(snd e,Some a)) } (*----------------------------*) (* 2 scalar *) (*----------------------------*) null_literal: - | pi=T_NULL { (pi, J.EVar (var pi "null")) } + | pi=T_NULL { (pi, EVar (var pi "null")) } boolean_literal: - | pi=T_TRUE { (pi, J.EBool true) } - | pi=T_FALSE { (pi, J.EBool false) } + | pi=T_TRUE { (pi, EBool true) } + | pi=T_FALSE { (pi, EBool false) } numeric_literal: | T_NUMBER { let (f, pi) = $1 in (pi, f) } @@ -499,7 +499,7 @@ regex_literal: let i = String.rindex s '/' in String.sub s 1 (i - 1),Some (String.sub s (i+1) (len - i - 1)) in - (pi, J.ERegexp (regexp, option)) } + (pi, ERegexp (regexp, option)) } (*----------------------------*) (* 2 array *) @@ -507,13 +507,13 @@ regex_literal: array_literal: | pi=T_LBRACKET elison T_RBRACKET - { (pi, J.EArr $2) } + { (pi, EArr $2) } | pi=T_LBRACKET T_RBRACKET - { (pi, J.EArr []) } + { (pi, EArr []) } | pi=T_LBRACKET element_list T_RBRACKET - { (pi, J.EArr $2) } + { (pi, EArr $2) } | pi=T_LBRACKET element_list_rev elison_rev T_RBRACKET - { (pi, J.EArr (List.rev_append $2 (List.rev $3))) } + { (pi, EArr (List.rev_append $2 (List.rev $3))) } element_list: | element_list_rev { List.rev $1 } @@ -525,9 +525,9 @@ element_list_rev: object_literal: | block=curly_block(empty) - { let _pairs, pi_start, _pi_end = block in pi_start, J.EObj [] } + { let _pairs, pi_start, _pi_end = block in pi_start, EObj [] } | block=curly_block(separated_or_terminated_list(T_COMMA, object_key_value)) - { let pairs, pi_start, _pi_end = block in pi_start, J.EObj pairs } + { let pairs, pi_start, _pi_end = block in pi_start, EObj pairs } object_key_value: | pair=separated_pair(property_name, T_COLON, assignment_expression) { pair } @@ -594,13 +594,13 @@ variable_with_loc: | i=T_IDENTIFIER { let name, pi = i in var pi name, pi } label: - | T_IDENTIFIER { J.Label.of_string (fst $1) } + | T_IDENTIFIER { Label.of_string (fst $1) } property_name: - | i=identifier_or_kw { J.PNI i } + | i=identifier_or_kw { PNI i } | s=T_STRING { - let s, _info, _len = s in J.PNS s } - | n=numeric_literal { J.PNN (J.Num.of_string_unsafe (snd n)) } + let s, _info, _len = s in PNS s } + | n=numeric_literal { PNN (Num.of_string_unsafe (snd n)) } (*************************************************************************) (* 1 xxx_opt, xxx_list *) @@ -621,65 +621,65 @@ curly_block(X): (*----------------------------*) %inline comparison_or_logical_or_bit_operator_except_in: - | T_LESS_THAN { J.Lt } - | T_GREATER_THAN { J.Gt } - | T_LESS_THAN_EQUAL { J.Le } - | T_GREATER_THAN_EQUAL { J.Ge } - | T_INSTANCEOF { J.InstanceOf } - | T_EQUAL { J.EqEq } - | T_NOT_EQUAL { J.NotEq } - | T_STRICT_EQUAL { J.EqEqEq } - | T_STRICT_NOT_EQUAL { J.NotEqEq } - | T_BIT_AND { J.Band } - | T_BIT_XOR { J.Bxor } - | T_BIT_OR { J.Bor } - | T_AND { J.And } - | T_OR { J.Or } + | T_LESS_THAN { Lt } + | T_GREATER_THAN { Gt } + | T_LESS_THAN_EQUAL { Le } + | T_GREATER_THAN_EQUAL { Ge } + | T_INSTANCEOF { InstanceOf } + | T_EQUAL { EqEq } + | T_NOT_EQUAL { NotEq } + | T_STRICT_EQUAL { EqEqEq } + | T_STRICT_NOT_EQUAL { NotEqEq } + | T_BIT_AND { Band } + | T_BIT_XOR { Bxor } + | T_BIT_OR { Bor } + | T_AND { And } + | T_OR { Or } %inline comparison_or_logical_or_bit_operator: | op=comparison_or_logical_or_bit_operator_except_in { op } - | T_IN { J.In } + | T_IN { In } %inline arithmetic_or_shift_operator: - | T_MULT { J.Mul } - | T_DIV { J.Div } - | T_MOD { J.Mod } - | T_PLUS { J.Plus } - | T_MINUS { J.Minus } - | T_LSHIFT { J.Lsl } - | T_RSHIFT { J.Asr } - | T_RSHIFT3 { J.Lsr } + | T_MULT { Mul } + | T_DIV { Div } + | T_MOD { Mod } + | T_PLUS { Plus } + | T_MINUS { Minus } + | T_LSHIFT { Lsl } + | T_RSHIFT { Asr } + | T_RSHIFT3 { Lsr } %inline prefix_operator: - | T_DELETE { J.Delete } - | T_VOID { J.Void } - | T_TYPEOF { J.Typeof } - | T_INCR { J.IncrB } - | T_INCR_NB { J.IncrB } - | T_DECR { J.DecrB } - | T_DECR_NB { J.DecrB } - | T_PLUS { J.Pl } - | T_MINUS { J.Neg } - | T_BIT_NOT { J.Bnot } - | T_NOT { J.Not } + | T_DELETE { Delete } + | T_VOID { Void } + | T_TYPEOF { Typeof } + | T_INCR { IncrB } + | T_INCR_NB { IncrB } + | T_DECR { DecrB } + | T_DECR_NB { DecrB } + | T_PLUS { Pl } + | T_MINUS { Neg } + | T_BIT_NOT { Bnot } + | T_NOT { Not } postfix_operator: - | T_INCR_NB { J.IncrA } - | T_DECR_NB { J.DecrA } + | T_INCR_NB { IncrA } + | T_DECR_NB { DecrA } assignment_operator: - | T_ASSIGN { J.Eq } - | T_MULT_ASSIGN { J.StarEq } - | T_DIV_ASSIGN { J.SlashEq } - | T_MOD_ASSIGN { J.ModEq } - | T_PLUS_ASSIGN { J.PlusEq } - | T_MINUS_ASSIGN { J.MinusEq } - | T_LSHIFT_ASSIGN { J.LslEq } - | T_RSHIFT_ASSIGN { J.AsrEq } - | T_RSHIFT3_ASSIGN { J.LsrEq } - | T_BIT_AND_ASSIGN { J.BandEq } - | T_BIT_XOR_ASSIGN { J.BxorEq } - | T_BIT_OR_ASSIGN { J.BorEq } + | T_ASSIGN { Eq } + | T_MULT_ASSIGN { StarEq } + | T_DIV_ASSIGN { SlashEq } + | T_MOD_ASSIGN { ModEq } + | T_PLUS_ASSIGN { PlusEq } + | T_MINUS_ASSIGN { MinusEq } + | T_LSHIFT_ASSIGN { LslEq } + | T_RSHIFT_ASSIGN { AsrEq } + | T_RSHIFT3_ASSIGN { LsrEq } + | T_BIT_AND_ASSIGN { BandEq } + | T_BIT_XOR_ASSIGN { BxorEq } + | T_BIT_OR_ASSIGN { BorEq } (* Library definitions *) diff --git a/compiler/lib/standard.mly b/compiler/lib/standard.mly deleted file mode 100644 index 2bf85a21..00000000 --- a/compiler/lib/standard.mly +++ /dev/null @@ -1,269 +0,0 @@ -/******************************************************************************/ -/* */ -/* Menhir */ -/* */ -/* François Pottier, Inria Paris */ -/* Yann Régis-Gianas, PPS, Université Paris Diderot */ -/* */ -/* Copyright Inria. All rights reserved. This file is distributed under the */ -/* terms of the GNU Library General Public License version 2, with a */ -/* special exception on linking, as described in the file LICENSE. */ -/* */ -/******************************************************************************/ - -(* This is menhir's standard library. It offers a number of - parameterized nonterminal definitions, such as options and lists, - that should be useful in a number of circumstances. *) - -%% - -(* ------------------------------------------------------------------------- *) -(* The identity. *) - -(* [endrule(X)] is the same as [X]. *) - -(* This allows placing an anonymous subrule in the middle of a rule, as in: - - cat - endrule(dog { action1 }) - cow - { action2 } - - Because [endrule] is marked %inline, everything is expanded away. So, - this is equivalent to: - - cat dog cow { action1; action2 } - - Note that [action1] moves to the end of the rule. The anonymous subrule - can even have several branches, as in: - - cat - endrule(dog { action1a } | fox { action1b }) - cow - { action2 } - - This is expanded to: - - cat dog cow { action1a; action2 } - | cat fox cow { action1b; action2 } - -*) - -%public %inline endrule(X): -x = X - { x } - -(* [anonymous(X)] is a deprecated synonym for [endrule(X)]. - It was never documented. *) - -%public %inline anonymous(X): -x = X - { x } - -(* [midrule(X)] is the same as [X]. *) - -(* This allows placing an anonymous subrule in the middle of a rule, as in: - - cat - midrule(dog { action1 }) - cow - { action2 } - - Because [midrule] is not marked %inline, this is equivalent to: - - cat xxx cow { action2 } - - where the fresh nonterminal symbol [xxx] is separately defined by: - - xxx: dog { action1 } - - In particular, if there is no [dog], what we get is a semantic action - embedded in the middle of a rule. For instance, - - cat midrule({ action1 }) cow { action2 } - - is equivalent to: - - cat xxx cow { action2 } - - where [xxx] is separately defined by the rule: - - xxx: { action1 } - -*) - -%public midrule(X): -x = X - { x } - -(* [embedded(X)] is a deprecated synonym for [midrule(X)]. - It was never documented. *) - -%public embedded(X): -x = X - { x } - -(* ------------------------------------------------------------------------- *) -(* Options. *) - -(* [option(X)] recognizes either nothing or [X]. It produces a value - of type ['a option] if [X] produces a value of type ['a]. *) - -%public option(X): - /* nothing */ - { None } -| x = X - { Some x } - -(* [ioption(X)] is identical to [option(X)], except its definition is - inlined. This has the effect of duplicating the production that - refers to it, possibly eliminating an LR(1) conflict. *) - -%public %inline ioption(X): - /* nothing */ - { None } -| x = X - { Some x } - -(* [boption(X)] recognizes either nothing or [X]. It produces a value - of type [bool]. *) - -%public boption(X): - /* nothing */ - { false } -| X - { true } - -(* [loption(X)] recognizes either nothing or [X]. It produces a value - of type ['a list] if [X] produces a value of type ['a list]. *) - -%public loption(X): - /* nothing */ - { [] } -| x = X - { x } - -(* ------------------------------------------------------------------------- *) -(* Sequences. *) - -(* [epsilon] recognizes the empty word. It can be used instead of the - traditional /* empty */ comment. *) - -(* NOT YET ADDED because we first need to remove the limitation that - every symbol must be reachable from the start symbol! - -%public %inline epsilon: - /* empty */ - { () } - - *) - -(* [pair(X, Y)] recognizes the sequence [X Y]. It produces a value of - type ['a * 'b] if [X] and [Y] produce values of type ['a] and ['b], - respectively. *) - -%public %inline pair(X, Y): - x = X; y = Y - { (x, y) } - -(* [separated_pair(X, sep, Y)] recognizes the sequence [X sep Y]. It - produces a value of type ['a * 'b] if [X] and [Y] produce values of - type ['a] and ['b], respectively. *) - -%public %inline separated_pair(X, sep, Y): - x = X; sep; y = Y - { (x, y) } - -(* [preceded(opening, X)] recognizes the sequence [opening X]. It - passes on the value produced by [X], so that it produces a value of - type ['a] if [X] produces a value of type ['a]. *) - -%public %inline preceded(opening, X): - opening; x = X - { x } - -(* [terminated(X, closing)] recognizes the sequence [X closing]. It - passes on the value produced by [X], so that it produces a value of - type ['a] if [X] produces a value of type ['a]. *) - -%public %inline terminated(X, closing): - x = X; closing - { x } - -(* [delimited(opening, X, closing)] recognizes the sequence [opening X - closing]. It passes on the value produced by [X], so that it - produces a value of type ['a] if [X] produces a value of type - ['a]. *) - -%public %inline delimited(opening, X, closing): - opening; x = X; closing - { x } - -(* ------------------------------------------------------------------------- *) -(* Lists. *) - -(* [list(X)] recognizes a possibly empty list of [X]'s. It produces a - value of type ['a list] if [X] produces a value of type ['a]. The - front element of the list is the first element that was parsed. *) - -%public list(X): - /* nothing */ - { [] } -| x = X; xs = list(X) - { x :: xs } - -(* [nonempty_list(X)] recognizes a nonempty list of [X]'s. It produces - a value of type ['a list] if [X] produces a value of type ['a]. The - front element of the list is the first element that was parsed. *) - -%public nonempty_list(X): - x = X - { [ x ] } -| x = X; xs = nonempty_list(X) - { x :: xs } - -(* [separated_list(separator, X)] recognizes a possibly empty list of - [X]'s, separated with [separator]'s. It produces a value of type - ['a list] if [X] produces a value of type ['a]. The front element - of the list is the first element that was parsed. *) - -%public %inline separated_list(separator, X): - xs = loption(separated_nonempty_list(separator, X)) - { xs } - -(* [separated_nonempty_list(separator, X)] recognizes a nonempty list - of [X]'s, separated with [separator]'s. It produces a value of type - ['a list] if [X] produces a value of type ['a]. The front element - of the list is the first element that was parsed. *) - -%public separated_nonempty_list(separator, X): - x = X - { [ x ] } -| x = X; separator; xs = separated_nonempty_list(separator, X) - { x :: xs } - -(* ------------------------------------------------------------------------- *) -(* List manipulation and transformation. *) - -(* [rev(XS)] recognizes the same language as [XS], but reverses the resulting - OCaml list. (20181005) *) - -%public %inline rev(XS): - xs = XS - { List.rev xs } - -(* [flatten(XSS)] recognizes the same language as [XSS], and flattens the - resulting OCaml list of lists. (20181005) *) - -%public %inline flatten(XSS): - xss = XSS - { List.flatten xss } - -(* [append(XS, YS)] recognizes [XS YS], and appends (concatenates) the - resulting OCaml lists. (20181005) *) - -%public %inline append(XS, YS): - xs = XS ys = YS - { xs @ ys } - -%% diff --git a/dune-project b/dune-project index 1eec226a..191cff0b 100644 --- a/dune-project +++ b/dune-project @@ -1,4 +1,5 @@ -(lang dune 2.8) +(lang dune 2.9) +(using menhir 2.0) (name js_of_ocaml) (generate_opam_files true) diff --git a/ppx/ppx_deriving_json/tests/ppx.mlt b/ppx/ppx_deriving_json/tests/ppx.mlt index 480b2ef1..f4270740 100644 --- a/ppx/ppx_deriving_json/tests/ppx.mlt +++ b/ppx/ppx_deriving_json/tests/ppx.mlt @@ -68,7 +68,7 @@ int64 = [255,42,0,0] let () = test "nativeint" (Json_nativeint.to_string 42n) [%%expect {| -Exception: (Failure Unimplemented) +Exception: Failure "Unimplemented". |}] (* let () = test "nativeint" (Json_nativeint.to_string 42n);; *)