Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Newer
Older
100644 741 lines (584 sloc) 26.5 kb
fccc685 Initial open-source release
MLstate authored
1 (*
2 Copyright © 2011 MLstate
3
4 This file is part of OPA.
5
6 OPA is free software: you can redistribute it and/or modify it under the
7 terms of the GNU Affero General Public License, version 3, as published by
8 the Free Software Foundation.
9
10 OPA is distributed in the hope that it will be useful, but WITHOUT ANY
11 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
12 FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for
13 more details.
14
15 You should have received a copy of the GNU Affero General Public License
16 along with OPA. If not, see <http://www.gnu.org/licenses/>.
17 *)
18
19 (**
20 The main interfaces of the Bypass Standard Library.
21
22 See the manual for more documentation.
23
24 @author Mathieu Barbin
25 @author Mehdi Bouaziz
26 *)
27
28 (* This file has no mli to avoid the duplication of sig and types definitions *)
29
30 (** {6 Type alias} *)
31 type deprecated = string
32 type skey = string
33
34 (** {6 Public Types Definitions} *)
35
36 (** The hierarchy in the bsl library : like a files system,
37 modules are directories and functions are files *)
38 type ('a, 'b) kind = Function of 'a | Module of 'b
39
40 (** A type used to export bypass for a hierarchical browsing structure *)
41 type ('a, 'b) hierarchy = HFunction of 'a | HModule of ( 'b * ('a, 'b) hierarchy list )
42
43 (**
44 A map from type (name) to path and type representation.
45
46 Note that the path is represented as lowercase. If you wish to use this in OCaml,
47 you will need to (re)capitalize things.
48
49 The first string is the name of the MLRuntime
50 *)
51 type typesmap_elt = deprecated * skey list * BslTypes.t
52 type typesmap = typesmap_elt BslKeyMap.t
53
54 type bypass_tags = BslTags.parsed_t
55
56
57 (** {6 Transtyping Modules} *)
58
59 (**
60 The bsl module is a functor which take a module in arg called the {b CTrans}.
61
62 The system of bypass-projections can be resume so :
63 + tell the way you represent the opa-values in your compiler by implementing a {b CTrans} module
64 + use this CTrans module as an argument of the corresponding functor to build a custom BSLINTROSPECTION module
65 + register all primitives you need using this custom BSLINTROSPECTION module
66 + use functions of the API to get the generated projected code corresponding to fresh bypasses,
67 with the property that they could be applied directly on values of your runtime type algebra.
68
69 For more flexibility, during the projection, you may propagate an environment. (see interface of [CTrans] modules)
70
71 Finally, note that if you don't need to generate code, and you're interressed only by some informations about bypass,
72 there is a bsl built by defaut, which is not specialized for any code generator : see module [BSL]
73 (the functor is applied with dummy arg-modules).
74 *)
75
76 (** an uniq identifiant for every record defined in bypass implementation *)
77 type record_t = string
78
79 (** indexation in record local index in the record and name of field *)
80 type field_t = int * string
81
82 (** a ident used in projection code *)
83 type meta_ident = MetaIdent of string
84
85 (** a string in the syntax of the target language *)
86 type meta_code_expr = MetaCodeExpr of string
87
88 (** the type returned by the CTrans about projection call *)
89 type meta_code =
90 | MetaCode of string (** a meta code expressed in the target language *)
91 | MetaComment of string (** just a comment to help the anderstanding of the projection code *)
92
93 type ('env,'code) bsl_projection = BslTypes.t -> env:'env -> meta_ident -> 'env * 'code option
94
95 (* TODO: simplify ITrans ? *)
96
97 (** Version of CTrans for qml interpreters *)
98 module type ML_ITRANS =
99 sig
100 (**
101 This functionnality will probably be removed.
102 @deprecated too complex, and probably not really needed
103 *)
104
105 (* Parametrisation of bsl : do you want that the bsl use your module ? *)
106 val auto_transtype : bool
107 val record_clash : record_t -> record_t -> 'a
108 val unbound_record : record_t -> 'a (** you could for example raise an exception *)
109
110 (* standard conversion *)
111 type qml (* typing of record if unable return None *)
112 val qml_of_ocaml : BslTypes.t -> ('a -> qml) option
113 val ocaml_of_qml : BslTypes.t -> (qml -> 'a) option
114
115 (* extra dynamic introspection on record *)
116 val type_of_record : qml -> record_t (* or raise exception *)
117 val get_field : qml -> field_t -> qml
118 val get_field_opt : qml -> field_t -> qml option
119 val build_record : record_t -> (field_t * qml) list -> qml
120 end
121
122 (** Version of CTrans for qml2ocaml compilers *)
123 module type ML_CTRANS =
124 sig
125 type env
126 val empty : unit -> env
127 (** standard conversion same as in the interpreted *)
128 (** at projection time, we give to the CTrans the bslkey where the projection is needed and we give also the identifier of what is going to be projected (meta_ident) *)
129 val qml_of_ocaml : bslkey:BslKey.t -> bsltags:BslTags.t -> (env,meta_code) bsl_projection (* $('a -> qml)$ : None for identity *)
130 val ocaml_of_qml : bslkey:BslKey.t -> bsltags:BslTags.t -> (env,meta_code) bsl_projection (* $(qml -> 'a)$ : None for identity *)
131
132 val runtime_ocaml_coercion : bslkey:BslKey.t -> bsltags:BslTags.t -> BslTypes.t -> env:env -> string -> env * string
133 (* the coercion with your runtime representation of qml-types
134 if you don't you want fun _ s -> s , else fun t s -> "(s : t)" *)
135
136 (** accumulator of conversion code ( you can initialize it with fun env -> env, "" *)
137 (** this function will be called at end of all generation, to be able to produce good links *)
138 val conversion_code : env -> env * string
139
140 (**
141 Additional arguments to add on projection.
142 This is used for second-order bypass in Ocaml, for adding an extra continuation
143 argument, used in projection of functionnal arguments, to be passed to the functions
144 uncps.
145
146 This code is inserted there :
147 {[
148 let bslp36 x0 x1 x2 <THERE> =
149 ]}
150 which is the place for adding a 'k' argument.
151 *)
152 val more_args : BslKey.t -> BslTags.t -> env -> string option
153
154 (**
155 Additional code add on projection.
156 This is used for second-order bypass in Ocaml, for adding a let binding introducing the
157 bslkey of the bypass we are projecting, essentially for keeping trace of the stack of blocking_wait,
158 to be passed to the projection functions uncps.
159
160 This code is inserted there :
161 {[
162 let bslp36 x0 x1 x2 =
163 <THERE>
164 ...
165 ]}
166 which is the place for adding :
167 {[
168 "let bslkey = \"mybslkey\" in"
169 ]}
170 *)
171 val more_code : BslKey.t -> BslTags.t -> env -> string option
172
173 (**
174 Combined with more_args, the [return] function is used to apply a function to
175 the result of bypass. Typically, this is a [Continuation.return]
176
177 This code is inserted there :
178 {[
179 let bslp36 x0 x1 x2 =
180 let r = ... in
181 <THERE>(r)
182 ]}
183 which is the place for adding :
184 {[
185 "QmlCpsServerLib.return k r"
186 ]}
187 *)
188 val return : BslKey.t -> BslTags.t -> env -> meta_ident -> string option
189 end
190
191 (** Version of CTrans for qml2js compilers *)
192 module type JS_CTRANS =
193 sig
194 type env
195 val empty : unit -> env
196 val qml_of_js : bslkey:BslKey.t -> bsltags:BslTags.t -> (env,(JsAst.ident list * JsAst.expr)) bsl_projection
197 val js_of_qml : bslkey:BslKey.t -> bsltags:BslTags.t -> (env,(JsAst.ident list * JsAst.expr)) bsl_projection
198 val conversion_code : env -> env * (string(*unicity_index*) * JsAst.statement) list
199 end
200
201 (** {6 Bsl Main Modules Interfaces} *)
202
203 (**
204 During the jscleaning (runtime-init)
205 some js-elt are duplicated.
206 We use this unicity_index for keeping only
207 one version of each key.
208
209 Property:
210 even if the index is generated in two different
211 packages compilation, the index should be the same
212 in case of duplicated elts.
213 *)
214 type unicity_index = string
215
216 (** The interface of BSL like modules. This is the core of {b libbsl} *)
217 module type BSLINTROSPECTION =
218 sig
219 (** {6 Functionnal API} *)
220
221 (** the type of the env of the ml_ctrans used to build this module *)
222 type ml_ctrans_env
223
224 (** the type of the env of the js_ctrans used to build this module *)
225 type js_ctrans_env
226
227 (** Manipulation of bypasses implementations *)
228 module Implementation :
229 sig
230 (**
231 Implementation expressed as concrete syntaxe.
232 e.g.:
233 {[
234 "my_bsl_function"
235 ]}
236 {[
237 "Pervasives.(+)"
238 ]}
239 *)
240 type function_name = string
241
242 type compiler_repr =
243 | Ident of Ident.t
244 | String of string
245
246 (** The abstract type of a compiled implementation *)
247 type compiled
248
249 (** The abstract type of a interpreted implementation. This means that we have an ocaml implementation available,
250 and we could get dynamically a pointer of the function *)
251 type interpreted
252
253 (** The abstract type of a implementation *)
254 type t = private Compiled of compiled | Interpreted of interpreted
255
256 (** Get the language of an implementation *)
257 val lang : t -> BslLanguage.t
258
259 (**
260 Get the type of an implementation.
261 Several implementations of the same bypass should have the same type.
262 However, these types could be protected by the [opa[]] constructor to tell
263 if the bypass works either on standard values, or projected values
264 (depending on the runtime algebra of the compiler)
265 *)
266 val trans_type : t -> BslTypes.t
267
268 (**
269 Get the tags defined in the implementation of the bypass.
270 [##register [...mytags...] etc...]
271 Since the tags can be different in each language of implementation,
272 this is not a function of the module [ByPass]. *)
273 val bsltags : t -> BslTags.t
274
275 (** Manipulation of [Compiled] implementations *)
276 module CompiledFunction :
277 sig
278 (**
279 This is the core of the {b bsl keys resolution}.
280 When a compiler based on libbsl meet a bypass, after finding it from
281 its key in the bymap, the key should be replaced by the effective code
282 of the implementation of the bypass, in each target language (Ocaml, Js).
283 This function returns the code which must be inserted in the
284 generated code, expressed as concrete syntax.
285 This can be either :
286 + the name of the implementation, as it was defined in the bsl
287 + a row string, if the bypass was defined with the injected syntax, like in
288 {[
289 ##register add_int \ `Pervasives.(+)` : int, int -> int
290 ]}
291 + the name of a fresh function which has been regenerated because of
292 bsl-projection system (CTrans).
293 In this case, the code of the function can be found in the
294 [language_init] string (bsl_ocaml_init.ml, bsl_js_init.js, ...)
295 *)
296 val compiler_repr : compiled -> function_name
297
298 val compiler_detailed_repr : compiled -> compiler_repr
299
300 (**
301 Is stident is case of an Ident.
302 Ocaml:
303 For the Ocaml, Ident.stident is the function used in fine
304 anyway, and actually this is never called since we do not
305 use anything but String case for the Ocaml.
306 Js:
307 This function is not called, the jsfun uses directly the detailed
308 representation for inserting projected bypass as ExprIdent nodes,
309 so that the runtime renaming is consistent.
310 *)
311 val string_of_repr : compiler_repr -> string
312
313 (** Get the filename where the implementation was declared. *)
314 val origin_file : compiled -> string
315
316 (** Given a compiled function, you may want to know if it needed a {b bsl projection}.
317 It depends directly on what returned the {b CTrans} module where it was called with
318 the original type of the bypass.*)
319 val is_transtype : compiled -> bool
320
321 (** Get the name of the module where the implementation has been register.
322 Used for ocaml only. *)
323 val origin_module : compiled -> string
324 end
325
326 (** From a ocaml interpreted implementation, get its function pointer.
327 This functionnality is available only if a [*Loader] module has
328 been generated by {b bslregister}
329 and statically linked with the executable calling this function.
330
331 This is how {b opatop} find its primitives.
332
333 Note : with [Interpreted] implementations, there is just this
334 function to export, that's why there is no module [InterpretedFunction] *)
335 val dynamic_repr : interpreted -> Obj.t
336
337 (** From an implementation, get a printable information for debug (used e.g. by {b bslbrowser})*)
338 val pp : t LangPrint.pprinter
339 end
340
341 (** Manipulation of bypasses *)
342 module ByPass :
343 sig
344 (** The abstract type of the bypass *)
345 type t
346
347 (** Get the key of a bypass *)
348 val key : t -> BslKey.t
349
350 (** shorthand for [BslKey.to_string (ByPass.key t)] *)
351 val skey : t -> string
352
353 (** Get the just the name of the bypass, without its module hierarchy, e.g :
354 ["string.init" --> "init"] *)
355 val name : t -> string
356
357 (** [format t fmt] print a bypass using a bsl-format.
358 Documentation of format is not yet available.
359 @param t a bypass
360 @param fmt a format *)
361 val format : t -> string -> string
362
363 (** Get the implementation of a desired language, if available (otherwise, you'll get [None]). *)
364 val implementation : t -> lang:BslLanguage.t -> Implementation.t option
365
366 (** Get all the implementations of a bypass *)
367 val all_implementations : t -> Implementation.t list
368
369 (** Get all the compiled implementations of a bypass *)
370 val compiled_implementation : t -> lang:BslLanguage.t -> Implementation.compiled option
371
372 (** Get all the interpreted implementations of a bypass *)
373 val interpreted_implementation : t -> lang:BslLanguage.t -> Implementation.interpreted option
374
375 (** Get the list of all languages implementing this bypass *)
376 val langs : t -> BslLanguage.t list
377
378 (** Check if a bypass is implemented in the asked language *)
379 val implemented_in : t -> lang:BslLanguage.t -> bool
380
381 (** Check if a bypass is implemented in {b at least one} asked language *)
382 val implemented_in_any : t -> lang:BslLanguage.t list -> bool
383
384 (** Check if a bypass is implemented in {b every} asked language *)
385 val implemented_in_all : t -> lang:BslLanguage.t list -> bool
386
387 (** Get the original type of the bypass, as it was defined in the implementation
388 and registred by [##register].
389 All implementation have the same registred type, that is checked by {b bslregister}.
390 <!> Beware, note that if the bypass needs a bsl-projection is one of
391 the implementation language (CTrans),
392 the type of the projected bypass may change
393 @see "Implementation.trans_type" to get the type of the projected bypass *)
394 val definition_type : t -> BslTypes.t
395 end
396
397 (** Functionnal structure to manipulate a collection of [ByPass.t] *)
398 module ByPassMap :
399 sig
400
401 (** The abstract type of a bypass map *)
402 type t
403
404 (** The empty val is used just for typing purposes,
405 if you need to defined a default value (e.g. in a record) before building any map *)
406 val empty : unit -> t
407
408 (** At end of generation, the final ctrans_env are contained in the bymap. *)
409 (** the resulting ml_ctrans env *)
410 val ml_ctrans_env : t -> ml_ctrans_env
411 (** the resulting js_ctrans env *)
412 val js_ctrans_env : t -> js_ctrans_env
413
414 (** {6 Type definitions} *)
415 (** The types of the bymap are every types used in all interfaces of loaded bypass.
416 + record types
417 + abstract types
418
419 For using bypasses having these types in their interface, you need to define
420 these types in opa. These functions give facilities to generate these
421 definitions, e.g. the directive [##include-type ...] handled by
422 {b bslregister} uses these functions. *)
423
424 val types : t -> typesmap_elt list
425 val typesmap : t -> typesmap
426
427 (** fold on every types *)
428 val fold_types : t -> ('a -> BslTypes.t -> 'a) -> 'a -> 'a
429
430 (** export all needed types definitions in opa syntax *)
431 val opa_types : t -> string
432
433 (** {6 Bsl-Projection} *)
434 (** Using the {b CTrans}, some bypass have been regenerated. The code of this
435 generation can be found in
436 a string available for each language, called the ["bsl-init"] string.
437 + The compilers 2ocaml produce this string in a file called ["bsl_ocaml_init.ml"].
438 + The compilers 2js produce this string in a file called ["bsl_js_init.js"],
439 or produces this string at the end
440 of the uniq generated file if the generated js is not splitted into small parts.
441 *)
442
443 (** Get the bsl-init for ocaml. *)
444 val ocaml_init : t -> string
445
446 (**
447 Get the bsl-init for js in ast format, and each
448 code elt is associated to the key of the bypass
449 it is redefining. (used by js serializer).
450
451 For the serializer to work properly, the ident of the elt
452 should be a ExprIdent. (cf JsAst)
453 *)
454 val js_init : t -> (unicity_index * JsAst.code_elt) list
455
456 (** {6 Introspection & iterators} *)
457
458 (** find_opt *)
459 val find_opt : t -> ?lang:BslLanguage.t -> BslKey.t -> ByPass.t option
460 (** suggar of interface : *)
461 val find_opt_implementation : t -> lang:BslLanguage.t -> BslKey.t -> Implementation.compiled option
462 val find_opt_interpreted_implementation : t -> lang:BslLanguage.t -> BslKey.t -> Implementation.interpreted option
463 val iter : (BslKey.t -> ByPass.t -> unit) -> t -> unit
464 val fold : (BslKey.t -> ByPass.t -> 'a -> 'a) -> t -> 'a -> 'a
465
466 (** more introspection, get the map part of t structure : *)
467 val get_map : t -> ByPass.t BslKeyMap.t
468
469 (** {6 Link with the qml typer} *)
470
471 (** you can get the bypass_typer function with a partial call here *)
472 val bypass_typer : ?typeident:(?check:bool -> string -> QmlAst.TypeIdent.t) -> t -> BslKey.t -> QmlAst.ty option
473
474 (** in some cases, you can prefer dealing with BslTypes.t instead of QmlAst.ty *)
475 val bsl_bypass_typer : t -> BslKey.t -> BslTypes.t option
476
477 (**
478 Get tags from a bypass map.
479 If the bypass is not found, or if it is not implemented in this language,
480 the function returns [None]
481 *)
482 val bsl_bypass_tags : t -> lang:BslLanguage.t -> BslKey.t -> BslTags.t option
483
484 (** Get the corresponding cps bypass of a bypass if exists. This
485 cps bypass must be named like the original bypass and suffixed
486 by "_cps". It must tagged by [cps-bypass] and the type must
487 corresponding. *)
488 val bsl_bypass_cps : t -> lang:BslLanguage.t -> BslKey.t -> BslKey.t option
489
490 (** {6 Facilities for browsing the bypass library} *)
491 (** This module offers a cyclic functionnal data structure : starting from each
492 elt you can browse all the structure
493 by accessing children and parents of every elt. *)
494 module Browser :
495 sig
496 (** If you want to work with the library, you can export the bsl representation
497 to this type *)
498 type bypass_library = (ByPass.t, string) hierarchy
499
500 (** uniq identifiant for every module or function :e.g. /module1/module2/function
501 or module3 *)
502 type path
503
504 (** an elt is a module, or a bypass *)
505 type elt
506 type module_elt
507 type public_elt = (ByPass.t, module_elt) kind
508
509 (** Build the root node constructor (bypervasives) of elt from a ByPassMap.t *)
510 val init : t -> elt
511
512 (** Deconstructor : from a Browsing structure get back the ByPassMap *)
513 val bymap : elt -> t
514
515 (** Go to root from anywhere. This is like [cd ~] in a file system *)
516 val root : elt -> elt
517
518 (** short name only, else cf string_of_path *)
519 val elt_name : elt -> string
520
521 (** Get the list of all children of a node : (name * elt). A function has no child,
522 only [module_elt] have children. *)
523 val children : module_elt -> (string * elt) list
524
525 (** Say if an elt is the root of the structure. This is like the test [$PWD=~]*)
526 val is_root : elt -> bool
527
528 (** Get the parent of an elt. Parent of the root node, is the root node *)
529 val parent : elt -> elt
530
531 (** Unwrap an elt to its public representation. *)
532 val public_elt : elt -> public_elt
533
534 (** Get Initial Code : this does not include the types definition *)
535 val export_bypass : elt -> bypass_library
536
537 (** export children : give the [function] or children of module *)
538 val export_children : elt -> bypass_library list
539
540 (**
541 produce the inclusion from parser fmt : can raise RegisterParserError exception.
542 Until we remove the qml-syntax, there is an optionnal flag to tell if we are
543 in opasyntax mode for inclusion. (default is qml)
544 *)
545 val include_format : elt -> BslIncludeFormats.fmt -> string
546
547 val preprocess_line : t -> filename:string -> line:int -> string -> string
548
549 (** A module for manipulating path *)
550 module Path :
551 sig
552 type step
553 val backward : path -> path
554 val forward : path -> step -> path
555 val step : string -> step
556 val root : path
557 val is_root : path -> bool
558 val of_string : string -> path option
559 (** for example : "/toto/bibi" or "toto/../../string/../" return None if syntax error *)
560 val build : string list -> path option
561 val to_string : path -> string (* module hierarchie *)
562 val to_list : path -> string list
563 val cd : elt -> path -> elt option
564 val pwd : elt -> path
565 end
566 end
567 end
568
569 (** {6 Imperative interfaces for registering bypasses and building bymaps} *)
570
571 (**
572 The 2 following modules work together. They share common imperatives tables.
573
574 Using them can be resumed so :
575
576 + use the [RegisterInterface] to register some primitives and types,
577 leading to a side effect on private tables
578 + use the [RegisterTable] when you're finished to build a fonctionnal
579 structure [ByPassMap.t]
580 from the current state of the private imperative tables
581
582 <!> Note that casual users may not use directly the [RegisterInterface].
583 It is provided to talk with generated code only, generated by {b bslregister}
584 ([*Loader], [*Plugin] like modules)
585 *)
586
587 module RegisterTable :
588 sig
589 (** We build a functionnal structure with all loaded bypass *)
590 (** If you want to repeat it, you can load other libs, and recompute *)
591 (** optimisation : you can build a restricted map directly here
592 (better than restrict it after) *)
593 val build_bypass_map :
594 (* trans *)
595 ?ml_ctrans:ml_ctrans_env ->
596 ?js_ctrans:js_ctrans_env ->
597
598 (* filtering *)
599 ?filter:(ByPass.t -> bool) ->
600
601 unit ->
602 ByPassMap.t
603
604 val build_restrict_map_any :
605 (* trans *)
606 ?ml_ctrans:ml_ctrans_env ->
607 ?js_ctrans:js_ctrans_env ->
608
609 (* filtering *)
610 ?filter:(BslKey.t -> bool) ->
611 lang:BslLanguage.t list ->
612
613 unit ->
614 ByPassMap.t
615
616 val build_restrict_map_all :
617 (* trans *)
618 ?ml_ctrans:ml_ctrans_env ->
619 ?js_ctrans:js_ctrans_env ->
620
621 (* filtering *)
622 ?filter:(BslKey.t -> bool) ->
623 lang:BslLanguage.t list ->
624
625 unit ->
626 ByPassMap.t
627 end
628
629 module RegisterInterface :
630 sig
631 type error
632 exception RegisterError of error
633 val pp_error : error LangPrint.pprinter
634
635 (** Gestion of MultiLoading :
636 In Each Execution of bsl, every one-day generated loader could be runned just once *)
637 module MultiLoading :
638 sig
639 val is_loaded : string -> bool
640 val first_load : string -> unit
641 end
642
643 (** cf type register_primitive in BslPluginInterface *)
644 val unsafe_register_primitive : BslPluginInterface.register_primitive
645
646 (** the bslregister call this function to declare every (records, extern)
647 in the implementations files *)
648 val unsafe_register_type : BslPluginInterface.register_type
649
650 (** Safe register *)
651 val register : BslPluginInterface.multi_loading_safe_get_dynloader_interface
652
653 (** take a Loader.dynload function, and execute it *)
654 val dynload : BslPluginInterface.dynloader -> unit
655
656 (** the same without registering the function pointers (the argument [obj:Obj.t]) *)
657 val dynload_no_obj : BslPluginInterface.dynloader -> unit
658
659 end
660 end
661
662
663 (** {6 Bsl Register} *)
664
665 type filename = string
666 type executable = filename
667 type shell_options = string list
668
669 (**
670 Options for bslregister.
671
672 The type of options you should pass to build a new bslregister session
673
674 the mlruntime_filename is given because this name appears in several places
675 in other generated files. (like the plugin). It is necessary to know it
676 a priori, before any generation.
677 *)
678 type options = {
679
680 basename : BslPluginInterface.plugin_basename ;
681 (**
682 The name of the plugin being build
683 *)
684
685 bypass_plugins : BslDynlink.bypass_plugin_file list ;
686 (**
687 The list of plugin which this lib depends on
688 *)
689
690 check_style : bool ;
691 (**
692 This option is not meant to be used all the time.
693 It performs some more check about some guidelines,
694 or some higienic practice.
695 It is meant to be checked e.g. by a distant robot,
696 or sometimes, just to see what happens.
697
698 <!> The exact things checked are not documented,
699 it can freely evoluate, not any compatibility with
700 previous versions are guarante.
701 *)
702
703 js_files : filename list ;
704 (**
705 this is needed, because for parsing jsconf files, we need to
706 know the name of all considered js files for beeing able to
707 filter them reading regexps.
708 The declaration of js files should be done before any preprocessing
709 of jsconf files.
710 *)
711
712 js_syntax_checker : ( (executable * shell_options) * filename list ) option ;
713 js_validator : ( (executable * shell_options) * filename list ) option ;
714 (**
715 The executable for performing syntax check.
716 TODO(maxime) merge them both. Not in one year please.
717 *)
718
719 ml_plugin_filename : filename ;
720 (**
721 The asked filename for the plugin.
722 e.g. ["opabslPlugin.ml"]
723 *)
724
725 ml_runtime_filename : filename ;
726 (**
727 The asked filename for the ml_runtime.
728 e.g. ["opabslMLRuntime.ml"]
729 *)
730
731 unsafe_js : bool ;
732 (**
733 Continue even if the js validation fails.
734 *)
735
736 unsafe_opa : bool ;
737 (**
738 Continue, even if the opa validation fails.
739 *)
740 }
Something went wrong with that request. Please try again.