forked from ocaml/ocaml
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathmain_args.ml
2041 lines (1810 loc) · 60.1 KB
/
main_args.ml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
(**************************************************************************)
(* *)
(* OCaml *)
(* *)
(* Damien Doligez, projet Para, INRIA Rocquencourt *)
(* *)
(* Copyright 1998 Institut National de Recherche en Informatique et *)
(* en Automatique. *)
(* *)
(* All rights reserved. This file is distributed under the terms of *)
(* the GNU Lesser General Public License version 2.1, with the *)
(* special exception on linking described in the file LICENSE. *)
(* *)
(**************************************************************************)
let mk_a f =
"-a", Arg.Unit f, " Build a library"
;;
let mk_alert f =
"-alert", Arg.String f,
Printf.sprintf
"<list> Enable or disable alerts according to <list>:\n\
\ +<alertname> enable alert <alertname>\n\
\ -<alertname> disable alert <alertname>\n\
\ ++<alertname> treat <alertname> as fatal error\n\
\ --<alertname> treat <alertname> as non-fatal\n\
\ @<alertname> enable <alertname> and treat it as fatal error\n\
\ <alertname> can be 'all' to refer to all alert names";;
let mk_absname f =
"-absname", Arg.Unit f, " Show absolute filenames in error messages"
;;
let mk_annot f =
"-annot", Arg.Unit f, " (deprecated) Save information in <filename>.annot"
;;
let mk_binannot f =
"-bin-annot", Arg.Unit f, " Save typedtree in <filename>.cmt"
;;
let mk_c f =
"-c", Arg.Unit f, " Compile only (do not link)"
;;
let mk_cc f =
"-cc", Arg.String f, "<command> Use <command> as the C compiler and linker"
;;
let mk_cclib f =
"-cclib", Arg.String f, "<opt> Pass option <opt> to the C linker"
;;
let mk_ccopt f =
"-ccopt", Arg.String f,
"<opt> Pass option <opt> to the C compiler and linker"
;;
let mk_clambda_checks f =
"-clambda-checks", Arg.Unit f, " Instrument clambda code with closure and \
field access checks (for debugging the compiler)"
;;
let mk_compact f =
"-compact", Arg.Unit f, " Optimize code size rather than speed"
;;
let mk_compat_32 f =
"-compat-32", Arg.Unit f,
" Check that generated bytecode can run on 32-bit platforms"
;;
let mk_config f =
"-config", Arg.Unit f, " Print configuration values and exit"
;;
let mk_config_var f =
"-config-var", Arg.String f,
" Print the value of a configuration variable, without a newline, and exit\n\
\ (print nothing and exit with error value if the variable does not exist)"
;;
let mk_custom f =
"-custom", Arg.Unit f, " Link in custom mode"
;;
let mk_dllib f =
"-dllib", Arg.String f, "<lib> Use the dynamically-loaded library <lib>"
;;
let mk_dllpath f =
"-dllpath", Arg.String f,
"<dir> Add <dir> to the run-time search path for shared libraries"
;;
let mk_eval f =
"-e", Arg.String f,
"<script> Evaluate given script"
;;
let mk_function_sections f =
if Config.function_sections then
"-function-sections", Arg.Unit f,
" Generate each function in a separate section if target supports it"
else
let err () =
raise (Arg.Bad "OCaml has been configured without support for \
-function-sections")
in
"-function-sections", Arg.Unit err, " (option not available)"
;;
let mk_stop_after ~native f =
let pass_names = Clflags.Compiler_pass.available_pass_names
~filter:(fun _ -> true)
~native
in
"-stop-after", Arg.Symbol (pass_names, f),
" Stop after the given compilation pass."
;;
let mk_save_ir_after ~native f =
let pass_names =
Clflags.Compiler_pass.(available_pass_names
~filter:can_save_ir_after
~native)
in
"-save-ir-after", Arg.Symbol (pass_names, f),
" Save intermediate representation after the given compilation pass\
(may be specified more than once)."
let mk_dtypes f =
"-dtypes", Arg.Unit f, " (deprecated) same as -annot"
;;
let mk_for_pack_byt f =
"-for-pack", Arg.String f,
"<ident> Generate code that can later be `packed' with\n\
\ ocamlc -pack -o <ident>.cmo"
;;
let mk_for_pack_opt f =
"-for-pack", Arg.String f,
"<ident> Generate code that can later be `packed' with\n\
\ ocamlopt -pack -o <ident>.cmx"
;;
let mk_g_byt f =
"-g", Arg.Unit f, " Save debugging information"
;;
let mk_g_opt f =
"-g", Arg.Unit f, " Record debugging information for exception backtrace"
;;
let mk_i f =
"-i", Arg.Unit f, " Print inferred interface"
;;
let mk_I f =
"-I", Arg.String f, "<dir> Add <dir> to the list of include directories"
;;
let mk_impl f =
"-impl", Arg.String f, "<file> Compile <file> as a .ml file"
;;
let mk_init f =
"-init", Arg.String f, "<file> Load <file> instead of default init file"
;;
let mk_inline f =
"-inline", Arg.String f,
Printf.sprintf "<n>|<round>=<n>[,...] Aggressiveness of inlining \
(default %.02f, higher numbers mean more aggressive)"
Clflags.default_inline_threshold
;;
let mk_inline_toplevel f =
"-inline-toplevel", Arg.String f,
Printf.sprintf "<n>|<round>=<n>[,...] Aggressiveness of inlining at \
toplevel (higher numbers mean more aggressive)"
;;
let mk_inlining_report f =
"-inlining-report", Arg.Unit f, " Emit `.<round>.inlining' file(s) (one per \
round) showing the inliner's decisions"
;;
let mk_dump_pass f =
"-dump-pass", Arg.String f,
Format.asprintf
" @[<4>Record transformations performed by these passes:@ @[%a@]@]"
(Format.pp_print_list
~pp_sep:Format.pp_print_space
Format.pp_print_string)
!Clflags.all_passes
;;
let mk_o2 f =
"-O2", Arg.Unit f, " Apply increased optimization for speed"
;;
let mk_o3 f =
"-O3", Arg.Unit f, " Apply aggressive optimization for speed (may \
significantly increase code size and compilation time)"
;;
let mk_rounds f =
"-rounds", Arg.Int f,
Printf.sprintf "<n> Repeat tree optimization and inlining phases this \
many times (default %d). Rounds are numbered starting from zero."
!Clflags.default_simplify_rounds
;;
let mk_inline_max_unroll f =
"-inline-max-unroll", Arg.String f,
Printf.sprintf "<n>|<round>=<n>[,...] Unroll recursive functions at most \
this many times (default %d)"
Clflags.default_inline_max_unroll
;;
let mk_classic_inlining f =
"-Oclassic", Arg.Unit f, " Make inlining decisions at function definition \
time rather than at the call site (replicates previous behaviour of the \
compiler)"
;;
let mk_inline_cost arg descr default f =
Printf.sprintf "-inline-%s-cost" arg,
Arg.String f,
Printf.sprintf "<n>|<round>=<n>[,...] The cost of not removing %s during \
inlining (default %d, higher numbers more costly)"
descr
default
;;
let mk_inline_call_cost =
mk_inline_cost "call" "a call" Clflags.default_inline_call_cost
let mk_inline_alloc_cost =
mk_inline_cost "alloc" "an allocation" Clflags.default_inline_alloc_cost
let mk_inline_prim_cost =
mk_inline_cost "prim" "a primitive" Clflags.default_inline_prim_cost
let mk_inline_branch_cost =
mk_inline_cost "branch" "a conditional" Clflags.default_inline_branch_cost
let mk_inline_indirect_cost =
mk_inline_cost "indirect" "an indirect call"
Clflags.default_inline_indirect_cost
let mk_inline_lifting_benefit f =
"-inline-lifting-benefit",
Arg.String f,
Printf.sprintf "<n>|<round>=<n>[,...] The benefit of lifting definitions \
to toplevel during inlining (default %d, higher numbers more beneficial)"
Clflags.default_inline_lifting_benefit
;;
let mk_inline_branch_factor f =
"-inline-branch-factor", Arg.String f,
Printf.sprintf "<n>|<round>=<n>[,...] Estimate the probability of a \
branch being cold as 1/(1+n) (used for inlining) (default %.2f)"
Clflags.default_inline_branch_factor
;;
let mk_intf f =
"-intf", Arg.String f, "<file> Compile <file> as a .mli file"
;;
let mk_intf_suffix f =
"-intf-suffix", Arg.String f,
"<string> Suffix for interface files (default: .mli)"
;;
let mk_intf_suffix_2 f =
"-intf_suffix", Arg.String f, "<string> (deprecated) same as -intf-suffix"
;;
let mk_insn_sched f =
"-insn-sched", Arg.Unit f,
Printf.sprintf " Run the instruction scheduling pass%s"
(if Clflags.insn_sched_default then " (default)" else "")
;;
let mk_no_insn_sched f =
"-no-insn-sched", Arg.Unit f,
Printf.sprintf " Do not run the instruction scheduling pass%s"
(if not Clflags.insn_sched_default then " (default)" else "")
;;
let mk_keep_docs f =
"-keep-docs", Arg.Unit f, " Keep documentation strings in .cmi files"
;;
let mk_no_keep_docs f =
"-no-keep-docs", Arg.Unit f,
" Do not keep documentation strings in .cmi files (default)"
;;
let mk_keep_locs f =
"-keep-locs", Arg.Unit f, " Keep locations in .cmi files (default)"
;;
let mk_no_keep_locs f =
"-no-keep-locs", Arg.Unit f, " Do not keep locations in .cmi files"
;;
let mk_labels f =
"-labels", Arg.Unit f, " Use commuting label mode"
;;
let mk_linkall f =
"-linkall", Arg.Unit f, " Link all modules, even unused ones"
;;
let mk_linscan f =
"-linscan", Arg.Unit f, " Use the linear scan register allocator"
;;
let mk_make_runtime f =
"-make-runtime", Arg.Unit f,
" Build a runtime system with given C objects and libraries"
;;
let mk_make_runtime_2 f =
"-make_runtime", Arg.Unit f, " (deprecated) same as -make-runtime"
;;
let mk_inline_max_depth f =
"-inline-max-depth", Arg.String f,
Printf.sprintf "<n>|<round>=<n>[,...] Maximum depth of search for \
inlining opportunities inside inlined functions (default %d)"
Clflags.default_inline_max_depth
;;
let mk_modern f =
"-modern", Arg.Unit f, " (deprecated) same as -labels"
;;
let mk_alias_deps f =
"-alias-deps", Arg.Unit f,
" Do record dependencies for module aliases"
;;
let mk_no_alias_deps f =
"-no-alias-deps", Arg.Unit f,
" Do not record dependencies for module aliases"
;;
let mk_app_funct f =
"-app-funct", Arg.Unit f, " Activate applicative functors"
;;
let mk_no_app_funct f =
"-no-app-funct", Arg.Unit f, " Deactivate applicative functors"
;;
let mk_no_check_prims f =
"-no-check-prims", Arg.Unit f, " Do not check runtime for primitives"
;;
let mk_no_float_const_prop f =
"-no-float-const-prop", Arg.Unit f,
" Deactivate constant propagation for floating-point operations"
;;
let mk_noassert f =
"-noassert", Arg.Unit f, " Do not compile assertion checks"
;;
let mk_noautolink_byt f =
"-noautolink", Arg.Unit f,
" Do not automatically link C libraries specified in .cma files"
;;
let mk_noautolink_opt f =
"-noautolink", Arg.Unit f,
" Do not automatically link C libraries specified in .cmxa files"
;;
let mk_nodynlink f =
"-nodynlink", Arg.Unit f,
" Enable optimizations for code that will not be dynlinked"
;;
let mk_noinit f =
"-noinit", Arg.Unit f,
" Do not load any init file"
let mk_nolabels f =
"-nolabels", Arg.Unit f, " Ignore non-optional labels in types"
;;
let mk_noprompt f =
"-noprompt", Arg.Unit f, " Suppress all prompts"
;;
let mk_nopromptcont f =
"-nopromptcont", Arg.Unit f,
" Suppress prompts for continuation lines of multi-line inputs"
;;
let mk_nostdlib f =
"-nostdlib", Arg.Unit f,
" Do not add default directory to the list of include directories"
;;
let mk_no_unbox_free_vars_of_closures f =
"-no-unbox-free-vars-of-closures", Arg.Unit f,
" Do not unbox variables that will appear inside function closures"
;;
let mk_no_unbox_specialised_args f =
"-no-unbox-specialised-args", Arg.Unit f,
" Do not unbox arguments to which functions have been specialised"
;;
let mk_o f =
"-o", Arg.String f, "<file> Set output file name to <file>"
;;
let mk_open f =
"-open", Arg.String f, "<module> Opens the module <module> before typing"
let mk_output_obj f =
"-output-obj", Arg.Unit f, " Output an object file instead of an executable"
;;
let mk_output_complete_obj f =
"-output-complete-obj", Arg.Unit f,
" Output an object file, including runtime, instead of an executable"
;;
let mk_output_complete_exe f =
"-output-complete-exe", Arg.Unit f,
" Output a self-contained executable, including runtime and C stubs"
;;
let mk_p f =
"-p", Arg.Unit f, " (no longer supported)"
;;
let mk_pack_byt f =
"-pack", Arg.Unit f, " Package the given .cmo files into one .cmo"
;;
let mk_pack_opt f =
"-pack", Arg.Unit f, " Package the given .cmx files into one .cmx"
;;
let mk_pp f =
"-pp", Arg.String f, "<command> Pipe sources through preprocessor <command>"
;;
let mk_ppx f =
"-ppx", Arg.String f,
"<command> Pipe abstract syntax trees through preprocessor <command>"
;;
let mk_plugin f =
"-plugin", Arg.String f,
"<plugin> (no longer supported)"
;;
let mk_principal f =
"-principal", Arg.Unit f, " Check principality of type inference"
;;
let mk_no_principal f =
"-no-principal", Arg.Unit f,
" Do not check principality of type inference (default)"
;;
let mk_rectypes f =
"-rectypes", Arg.Unit f, " Allow arbitrary recursive types"
;;
let mk_no_rectypes f =
"-no-rectypes", Arg.Unit f,
" Do not allow arbitrary recursive types (default)"
;;
let mk_remove_unused_arguments f =
"-remove-unused-arguments", Arg.Unit f,
" Remove unused function arguments"
;;
let mk_runtime_variant f =
"-runtime-variant", Arg.String f,
"<str> Use the <str> variant of the run-time system"
;;
let mk_with_runtime f =
"-with-runtime", Arg.Unit f,
"Include the runtime system in the generated program (default)"
;;
let mk_without_runtime f =
"-without-runtime", Arg.Unit f,
"Do not include the runtime system in the generated program."
;;
let mk_S f =
"-S", Arg.Unit f, " Keep intermediate assembly file"
;;
let mk_safe_string f =
"-safe-string", Arg.Unit f,
if Config.safe_string then " (was set when configuring the compiler)"
else if Config.default_safe_string then " Make strings immutable (default)"
else " Make strings immutable"
;;
let mk_shared f =
"-shared", Arg.Unit f, " Produce a dynlinkable plugin"
;;
let mk_short_paths f =
"-short-paths", Arg.Unit f, " Shorten paths in types"
;;
let mk_stdin f =
"-stdin", Arg.Unit f, " Read script from standard input"
;;
let mk_no_strict_sequence f =
"-no-strict-sequence", Arg.Unit f,
" Left-hand part of a sequence need not have type unit (default)"
;;
let mk_strict_sequence f =
"-strict-sequence", Arg.Unit f,
" Left-hand part of a sequence must have type unit"
;;
let mk_thread f =
"-thread", Arg.Unit f,
" (deprecated) same as -I +threads"
;;
let mk_dtimings f =
"-dtimings", Arg.Unit f, " Print timings information for each pass";
;;
let mk_dprofile f =
"-dprofile", Arg.Unit f, Profile.options_doc
;;
let mk_unbox_closures f =
"-unbox-closures", Arg.Unit f,
" Pass free variables via specialised arguments rather than closures"
;;
let mk_unbox_closures_factor f =
"-unbox-closures-factor", Arg.Int f,
Printf.sprintf "<n > 0> Scale the size threshold above which \
unbox-closures will slow down indirect calls rather than duplicating a \
function (default %d)"
Clflags.default_unbox_closures_factor
;;
let mk_unboxed_types f =
"-unboxed-types", Arg.Unit f,
" unannotated unboxable types will be unboxed"
;;
let mk_no_unboxed_types f =
"-no-unboxed-types", Arg.Unit f,
" unannotated unboxable types will not be unboxed (default)"
;;
let mk_force_tmc f =
"-force-tmc", Arg.Unit f, " Rewrite all possible TMC calls"
;;
let mk_unsafe f =
"-unsafe", Arg.Unit f,
" Do not compile bounds checking on array and string access"
;;
let mk_unsafe_string f =
if Config.safe_string then
let err () =
raise (Arg.Bad "OCaml has been configured with -force-safe-string: \
-unsafe-string is not available")
in
"-unsafe-string", Arg.Unit err, " (option not available)"
else if Config.default_safe_string then
"-unsafe-string", Arg.Unit f, " Make strings mutable"
else
"-unsafe-string", Arg.Unit f, " Make strings mutable (default)"
;;
let mk_use_runtime f =
"-use-runtime", Arg.String f,
"<file> Generate bytecode for the given runtime system"
;;
let mk_use_runtime_2 f =
"-use_runtime", Arg.String f,
"<file> (deprecated) same as -use-runtime"
;;
let mk_v f =
"-v", Arg.Unit f,
" Print compiler version and location of standard library and exit"
;;
let mk_verbose f =
"-verbose", Arg.Unit f, " Print calls to external commands"
;;
let mk_version f =
"-version", Arg.Unit f, " Print version and exit"
;;
let mk__version f =
"--version", Arg.Unit f, " Print version and exit"
;;
let mk_no_version f =
"-no-version", Arg.Unit f, " Do not print version at startup"
;;
let mk_vmthread f =
"-vmthread", Arg.Unit f,
" (no longer supported)"
;;
let mk_vnum f =
"-vnum", Arg.Unit f, " Print version number and exit"
;;
let mk_w f =
"-w", Arg.String f,
Printf.sprintf
"<list> Enable or disable warnings according to <list>:\n\
\ +<spec> enable warnings in <spec>\n\
\ -<spec> disable warnings in <spec>\n\
\ @<spec> enable warnings in <spec> and treat them as errors\n\
\ <spec> can be:\n\
\ <num> a single warning number\n\
\ <num1>..<num2> a range of consecutive warning numbers\n\
\ <letter> a predefined set\n\
\ default setting is %S" Warnings.defaults_w
;;
let mk_warn_error f =
"-warn-error", Arg.String f,
Printf.sprintf
"<list> Enable or disable error status for warnings according\n\
\ to <list>. See option -w for the syntax of <list>.\n\
\ Default setting is %S" Warnings.defaults_warn_error
;;
let mk_warn_help f =
"-warn-help", Arg.Unit f, " Show description of warning numbers"
;;
let mk_color f =
"-color", Arg.Symbol (["auto"; "always"; "never"], f),
Printf.sprintf
" Enable or disable colors in compiler messages\n\
\ The following settings are supported:\n\
\ auto use heuristics to enable colors only if supported\n\
\ always enable colors\n\
\ never disable colors\n\
\ The default setting is 'auto', and the current heuristic\n\
\ checks that the TERM environment variable exists and is\n\
\ not empty or \"dumb\", and that isatty(stderr) holds.\n\
\ If the option is not specified, these setting can alternatively\n\
\ be set through the OCAML_COLOR environment variable."
;;
let mk_error_style f =
"-error-style", Arg.Symbol (["contextual"; "short"], f),
Printf.sprintf
" Control the way error messages and warnings are printed\n\
\ The following settings are supported:\n\
\ short only print the error and its location\n\
\ contextual like \"short\", but also display the source code\n\
\ snippet corresponding to the location of the error\n\
\ The default setting is 'contextual'.\n\
\ If the option is not specified, these setting can alternatively\n\
\ be set through the OCAML_ERROR_STYLE environment variable."
;;
let mk_where f =
"-where", Arg.Unit f, " Print location of standard library and exit"
;;
let mk_nopervasives f =
"-nopervasives", Arg.Unit f, " (undocumented)"
;;
let mk_match_context_rows f =
"-match-context-rows", Arg.Int f,
let[@manual.ref "s:comp-options"] chapter, section = 11, 2 in
Printf.sprintf
"<n> (advanced, see manual section %d.%d.)" chapter section
;;
let mk_use_prims f =
"-use-prims", Arg.String f, "<file> (undocumented)"
;;
let mk_dump_into_file f =
"-dump-into-file", Arg.Unit f, " dump output like -dlambda into <target>.dump"
;;
let mk_dump_dir f =
"-dump-dir", Arg.String f,
"<dir> dump output like -dlambda into <dir>/<target>.dump"
;;
let mk_dparsetree f =
"-dparsetree", Arg.Unit f, " (undocumented)"
;;
let mk_dtypedtree f =
"-dtypedtree", Arg.Unit f, " (undocumented)"
;;
let mk_dshape f =
"-dshape", Arg.Unit f, " (undocumented)"
;;
let mk_drawlambda f =
"-drawlambda", Arg.Unit f, " (undocumented)"
;;
let mk_dno_unique_ids f =
"-dno-unique-ids", Arg.Unit f, " (undocumented)"
;;
let mk_dunique_ids f =
"-dunique-ids", Arg.Unit f, " (undocumented)"
;;
let mk_dno_locations f =
"-dno-locations", Arg.Unit f, " (undocumented)"
;;
let mk_dlocations f =
"-dlocations", Arg.Unit f, " (undocumented)"
;;
let mk_dsource f =
"-dsource", Arg.Unit f, " (undocumented)"
;;
let mk_dlambda f =
"-dlambda", Arg.Unit f, " (undocumented)"
;;
let mk_drawclambda f =
"-drawclambda", Arg.Unit f, " (undocumented)"
;;
let mk_dclambda f =
"-dclambda", Arg.Unit f, " (undocumented)"
;;
let mk_dflambda f =
"-dflambda", Arg.Unit f, " Print Flambda terms"
;;
let mk_drawflambda f =
"-drawflambda", Arg.Unit f, " Print Flambda terms after closure conversion"
;;
let mk_dflambda_invariants f =
"-dflambda-invariants", Arg.Unit f, " Check Flambda invariants \
around each pass"
;;
let mk_dflambda_no_invariants f =
"-dflambda-no-invariants", Arg.Unit f, " Do not Check Flambda invariants \
around each pass"
;;
let mk_dflambda_let f =
"-dflambda-let", Arg.Int f, "<stamp> Print when the given Flambda [Let] \
is created"
;;
let mk_dflambda_verbose f =
"-dflambda-verbose", Arg.Unit f, " Print Flambda terms including around \
each pass"
;;
let mk_dinstr f =
"-dinstr", Arg.Unit f, " (undocumented)"
;;
let mk_dcamlprimc f =
"-dcamlprimc", Arg.Unit f, " (undocumented)"
;;
let mk_dcmm_invariants f =
"-dcmm-invariants", Arg.Unit f, " Extra sanity checks on Cmm"
;;
let mk_dcmm f =
"-dcmm", Arg.Unit f, " (undocumented)"
;;
let mk_dsel f =
"-dsel", Arg.Unit f, " (undocumented)"
;;
let mk_dcombine f =
"-dcombine", Arg.Unit f, " (undocumented)"
;;
let mk_dcse f =
"-dcse", Arg.Unit f, " (undocumented)"
;;
let mk_dlive f =
"-dlive", Arg.Unit f, " (undocumented)"
;;
let mk_dspill f =
"-dspill", Arg.Unit f, " (undocumented)"
;;
let mk_dsplit f =
"-dsplit", Arg.Unit f, " (undocumented)"
;;
let mk_dinterf f =
"-dinterf", Arg.Unit f, " (undocumented)"
;;
let mk_dprefer f =
"-dprefer", Arg.Unit f, " (undocumented)"
;;
let mk_dalloc f =
"-dalloc", Arg.Unit f, " (undocumented)"
;;
let mk_dreload f =
"-dreload", Arg.Unit f, " (undocumented)"
;;
let mk_dscheduling f =
"-dscheduling", Arg.Unit f, " (undocumented)"
;;
let mk_dlinear f =
"-dlinear", Arg.Unit f, " (undocumented)"
;;
let mk_dinterval f =
"-dinterval", Arg.Unit f, " (undocumented)"
;;
let mk_dstartup f =
"-dstartup", Arg.Unit f, " (undocumented)"
;;
let mk_opaque f =
"-opaque", Arg.Unit f,
" Does not generate cross-module optimization information\n\
\ (reduces necessary recompilation on module change)"
;;
let mk_strict_formats f =
"-strict-formats", Arg.Unit f,
" Reject invalid formats accepted by legacy implementations\n\
\ (Warning: Invalid formats may behave differently from\n\
\ previous OCaml versions, and will become always-rejected\n\
\ in future OCaml versions. You should always use this flag\n\
\ to detect invalid formats so you can fix them.)"
let mk_no_strict_formats f =
"-no-strict-formats", Arg.Unit f,
" Accept invalid formats accepted by legacy implementations (default)\n\
\ (Warning: Invalid formats may behave differently from\n\
\ previous OCaml versions, and will become always-rejected\n\
\ in future OCaml versions. You should never use this flag\n\
\ and instead fix invalid formats.)"
;;
let mk_args f =
"-args", Arg.Expand f,
"<file> Read additional newline-terminated command line arguments\n\
\ from <file>"
;;
let mk_args0 f =
"-args0", Arg.Expand f,
"<file> Read additional null character terminated command line arguments\n\
from <file>"
;;
let mk_afl_instrument f =
"-afl-instrument", Arg.Unit f, "Enable instrumentation for afl-fuzz"
;;
let mk_afl_inst_ratio f =
"-afl-inst-ratio", Arg.Int f,
"Configure percentage of branches instrumented\n\
\ (advanced, see afl-fuzz docs for AFL_INST_RATIO)"
;;
let mk__ f =
"-", Arg.String f,
"<file> Treat <file> as a file name (even if it starts with `-')"
;;
module type Common_options = sig
val _absname : unit -> unit
val _alert : string -> unit
val _I : string -> unit
val _labels : unit -> unit
val _alias_deps : unit -> unit
val _no_alias_deps : unit -> unit
val _app_funct : unit -> unit
val _no_app_funct : unit -> unit
val _noassert : unit -> unit
val _nolabels : unit -> unit
val _nostdlib : unit -> unit
val _open : string -> unit
val _ppx : string -> unit
val _principal : unit -> unit
val _no_principal : unit -> unit
val _rectypes : unit -> unit
val _no_rectypes : unit -> unit
val _safe_string : unit -> unit
val _short_paths : unit -> unit
val _strict_sequence : unit -> unit
val _no_strict_sequence : unit -> unit
val _strict_formats : unit -> unit
val _no_strict_formats : unit -> unit
val _force_tmc : unit -> unit
val _unboxed_types : unit -> unit
val _no_unboxed_types : unit -> unit
val _unsafe_string : unit -> unit
val _version : unit -> unit
val _vnum : unit -> unit
val _w : string -> unit
val anonymous : string -> unit
end
module type Core_options = sig
include Common_options
val _nopervasives : unit -> unit
val _unsafe : unit -> unit
val _warn_error : string -> unit
val _warn_help : unit -> unit
val _dno_unique_ids : unit -> unit
val _dunique_ids : unit -> unit
val _dno_locations : unit -> unit
val _dlocations : unit -> unit
val _dsource : unit -> unit
val _dparsetree : unit -> unit
val _dtypedtree : unit -> unit
val _dshape : unit -> unit
val _drawlambda : unit -> unit
val _dlambda : unit -> unit
end
module type Compiler_options = sig
val _a : unit -> unit
val _annot : unit -> unit
val _binannot : unit -> unit
val _c : unit -> unit
val _cc : string -> unit
val _cclib : string -> unit
val _ccopt : string -> unit
val _config : unit -> unit
val _config_var : string -> unit
val _for_pack : string -> unit
val _g : unit -> unit
val _stop_after : string -> unit
val _i : unit -> unit
val _impl : string -> unit
val _intf : string -> unit
val _intf_suffix : string -> unit
val _keep_docs : unit -> unit
val _no_keep_docs : unit -> unit
val _keep_locs : unit -> unit
val _no_keep_locs : unit -> unit
val _linkall : unit -> unit
val _noautolink : unit -> unit
val _o : string -> unit
val _opaque : unit -> unit
val _output_obj : unit -> unit
val _output_complete_obj : unit -> unit
val _pack : unit -> unit
val _plugin : string -> unit
val _pp : string -> unit