+asmcomp/cmmgen.cmi: asmcomp/compilenv.cmi asmcomp/cmm.cmi asmcomp/clambda.cmi

+toplevel/opttopdirs.cmi: parsing/longident.cmi

+toplevel/opttoploop.cmi: utils/warnings.cmi typing/types.cmi typing/path.cmi \

+ parsing/parsetree.cmi typing/outcometree.cmi parsing/longident.cmi \

+ parsing/location.cmi typing/env.cmi

+toplevel/opttopdirs.cmo: utils/warnings.cmi typing/types.cmi \

+ typing/printtyp.cmi typing/path.cmi toplevel/opttoploop.cmi \

+ utils/misc.cmi parsing/longident.cmi typing/ident.cmi typing/env.cmi \

+ typing/ctype.cmi utils/config.cmi utils/clflags.cmi \

+ toplevel/opttopdirs.cmi

+toplevel/opttopdirs.cmx: utils/warnings.cmx typing/types.cmx \

+ typing/printtyp.cmx typing/path.cmx toplevel/opttoploop.cmx \

+ utils/misc.cmx parsing/longident.cmx typing/ident.cmx typing/env.cmx \

+ typing/ctype.cmx utils/config.cmx utils/clflags.cmx \

+ toplevel/opttopdirs.cmi

+toplevel/opttoploop.cmo: utils/warnings.cmi typing/unused_var.cmi \

+ typing/types.cmi typing/typemod.cmi typing/typedtree.cmi \

+ typing/typecore.cmi bytecomp/translmod.cmi bytecomp/simplif.cmi \

+ typing/printtyp.cmi bytecomp/printlambda.cmi parsing/printast.cmi \

+ typing/predef.cmi typing/path.cmi parsing/parsetree.cmi parsing/parse.cmi \

+ typing/outcometree.cmi driver/opterrors.cmi driver/optcompile.cmi \

+ typing/oprint.cmi utils/misc.cmi parsing/longident.cmi \

+ parsing/location.cmi parsing/lexer.cmi bytecomp/lambda.cmi \

+ typing/ident.cmi toplevel/genprintval.cmi typing/env.cmi utils/config.cmi \

+ asmcomp/compilenv.cmi utils/clflags.cmi typing/btype.cmi \

+ asmcomp/asmlink.cmi asmcomp/asmgen.cmi toplevel/opttoploop.cmi

+toplevel/opttoploop.cmx: utils/warnings.cmx typing/unused_var.cmx \

+ typing/types.cmx typing/typemod.cmx typing/typedtree.cmx \

+ typing/typecore.cmx bytecomp/translmod.cmx bytecomp/simplif.cmx \

+ typing/printtyp.cmx bytecomp/printlambda.cmx parsing/printast.cmx \

+ typing/predef.cmx typing/path.cmx parsing/parsetree.cmi parsing/parse.cmx \

+ typing/outcometree.cmi driver/opterrors.cmx driver/optcompile.cmx \

+ typing/oprint.cmx utils/misc.cmx parsing/longident.cmx \

+ parsing/location.cmx parsing/lexer.cmx bytecomp/lambda.cmx \

+ typing/ident.cmx toplevel/genprintval.cmx typing/env.cmx utils/config.cmx \

+ asmcomp/compilenv.cmx utils/clflags.cmx typing/btype.cmx \

+ asmcomp/asmlink.cmx asmcomp/asmgen.cmx toplevel/opttoploop.cmi

+toplevel/opttopmain.cmo: utils/warnings.cmi asmcomp/printmach.cmi \

+ toplevel/opttoploop.cmi toplevel/opttopdirs.cmi driver/opterrors.cmi \

+ utils/misc.cmi utils/config.cmi utils/clflags.cmi asmcomp/arch.cmo \

+ toplevel/opttopmain.cmi

+toplevel/opttopmain.cmx: utils/warnings.cmx asmcomp/printmach.cmx \

+ toplevel/opttoploop.cmx toplevel/opttopdirs.cmx driver/opterrors.cmx \

+ utils/misc.cmx utils/config.cmx utils/clflags.cmx asmcomp/arch.cmx \

+ toplevel/opttopmain.cmi

+toplevel/opttopstart.cmo: toplevel/opttopmain.cmi

+toplevel/opttopstart.cmx: toplevel/opttopmain.cmx

+CAMLOPT=boot/ocamlrun ./ocamlopt -nostdlib -I stdlib -I otherlibs/dynlink

+NATTOPOBJS=$(OPTUTILS) $(PARSING) $(TYPING) $(COMP) $(ASMCOMP) \

+ driver/pparse.cmo driver/opterrors.cmo driver/optcompile.cmo \

+ toplevel/genprintval.cmo toplevel/opttoploop.cmo toplevel/opttopdirs.cmo \

+ toplevel/opttopmain.cmo toplevel/opttopstart.cmo

+

+# The native toplevel

+

+ocamlnat: ocamlopt otherlibs/dynlink/dynlink.cmxa $(NATTOPOBJS:.cmo=.cmx)

+ $(CAMLOPT) $(LINKFLAGS) otherlibs/dynlink/dynlink.cmxa -o ocamlnat $(NATTOPOBJS:.cmo=.cmx) -linkall

+

+toplevel/opttoploop.cmx: otherlibs/dynlink/dynlink.cmxa

+

+otherlibs/dynlink/dynlink.cmxa: otherlibs/dynlink/natdynlink.ml

+ cd otherlibs/dynlink && make allopt

+

+

+CAMLOPT=boot/ocamlrun ./ocamlopt -I stdlib -I otherlibs/dynlink

+NATTOPOBJS=$(OPTUTILS) $(PARSING) $(TYPING) $(COMP) $(ASMCOMP) \

+ driver/pparse.cmo driver/opterrors.cmo driver/optcompile.cmo \

+ toplevel/genprintval.cmo toplevel/opttoploop.cmo toplevel/opttopdirs.cmo \

+ toplevel/opttopmain.cmo toplevel/opttopstart.cmo

+

+# The native toplevel

+

+ocamlnat: ocamlopt otherlibs/dynlink/dynlink.cmxa $(NATTOPOBJS:.cmo=.cmx)

+ $(CAMLOPT) $(LINKFLAGS) otherlibs/dynlink/dynlink.cmxa -o ocamlnat $(NATTOPOBJS:.cmo=.cmx) -linkall

+

+toplevel/opttoploop.cmx: otherlibs/dynlink/dynlink.cmxa

+

+otherlibs/dynlink/dynlink.cmxa: otherlibs/dynlink/natdynlink.ml

+ cd otherlibs/dynlink && make allopt

+

+

+ -e "s|%%BYTELINK%%|flexlink|" \

+ -e "s|%%NATIVELINK%%|flexlink|" \

+3.11+dev5 Private_abbrevs+natdynlink (2007-11-1)

+<camlp4/Camlp4Bin.{byte,native}> or "camlp4/mkcamlp4.byte" or "camlp4/camlp4lib.cma": use_dynlink

+let emit_call s =

+ if !Clflags.dlcode

+ then `call {emit_symbol s}@PLT`

+ else `call {emit_symbol s}`

+

+let emit_jump s =

+ if !Clflags.dlcode

+ then `jmp {emit_symbol s}@PLT`

+ else `jmp {emit_symbol s}`

+

+let load_symbol_addr s =

+ if !Clflags.dlcode

+ then `movq {emit_symbol s}@GOTPCREL(%rip)`

+ else if !pic_code

+ then `leaq {emit_symbol s}(%rip)`

+ else `movq ${emit_symbol s}`

+

+

+ | Ibased _ when !Clflags.dlcode -> assert false

+ | Ibased(s, d) ->

+ `{emit_label gc.gc_lbl}: {emit_call "caml_call_gc"}\n`;

+ `{emit_label bd.bd_lbl}: {emit_call "caml_ml_array_bound_error"}\n`;

+ `{emit_label !bound_error_call}: {emit_jump "caml_ml_array_bound_error"}\n`

+ ` {load_symbol_addr s}, {emit_reg i.res.(0)}\n`

+ ` {emit_call s}\n`;

+ ` {emit_jump s}\n`

+ ` {load_symbol_addr s}, %rax\n`;

+ ` {emit_call "caml_c_call"}\n`;

+ ` {emit_call s}\n`

+ if !Clflags.dlcode then begin

+ ` {load_symbol_addr "caml_young_limit"}, %rax\n`;

+ ` cmpq (%rax), %r15\n`;

+ end else

+ ` cmpq {emit_symbol "caml_young_limit"}(%rip), %r15\n`;

+ 16 -> ` {emit_call "caml_alloc1"}\n`

+ | 24 -> ` {emit_call "caml_alloc2"}\n`

+ | 32 -> ` {emit_call "caml_alloc3"}\n`

+ ` {emit_call "caml_allocN"}\n`

+ assert (not !pic_code && not !Clflags.dlcode);

+ if !pic_code || !Clflags.dlcode then begin

+ ` {emit_call "caml_raise_exn"}\n`;

+ ` {emit_call "mcount"}\n`;

+ if !Clflags.dlcode then begin

+ (* from amd64.S; could emit these constants on demand *)

+ ` .section .rodata.cst8,\"a\",@progbits\n`;

+ ` .align 16\n`;

+ `caml_negf_mask: .quad 0x8000000000000000, 0\n`;

+ ` .align 16\n`;

+ `caml_absf_mask: .quad 0x7FFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF\n`;

+ end;

+ | Iswitch(_, _) when !pic_code || !Clflags.dlcode -> [| r11 |]

+ if !pic_code || !Clflags.dlcode

+ Cconst_symbol s when not !Clflags.dlcode ->

+ | Cconst_symbol s when not (!pic_code || !Clflags.dlcode) ->

+

+(* For the native toplevel: generates generic functions unless

+ they are already available in the process *)

+let compile_genfuns ppf f =

+ List.iter

+ (function

+ | (Cfunction {fun_name = name}) as ph when f name ->

+ compile_phrase ppf ph

+ | _ -> ())

+ (Cmmgen.generic_functions true [Compilenv.current_unit_infos ()])

+

+let compile_implementation ?toplevel prefixname ppf (size, lam) =

+ (match toplevel with None -> () | Some f -> compile_genfuns ppf f);

+ ?toplevel:(string -> bool) ->

+let runtime_lib () =

+ let libname =

+ if !Clflags.gprofile

+ then "libasmrunp" ^ ext_lib

+ else "libasmrun" ^ ext_lib in

+ try

+ if !Clflags.nopervasives then ""

+ else find_in_path !load_path libname

+ with Not_found ->

+ raise(Error(File_not_found libname))

+

+let object_file_name name =

+ let file_name =

+ try

+ find_in_path !load_path name

+ with Not_found ->

+ fatal_error "Asmlink.object_file_name: not found" in

+ if Filename.check_suffix file_name ".cmx" then

+ Filename.chop_suffix file_name ".cmx" ^ ext_obj

+ else if Filename.check_suffix file_name ".cmxa" then

+ Filename.chop_suffix file_name ".cmxa" ^ ext_lib

+ else

+ fatal_error "Asmlink.object_file_name: bad ext"

+

+type file =

+ | Unit of string * Compilenv.unit_infos * Digest.t

+ | Library of string * Compilenv.library_infos

+

+let read_file obj_name =

+ Unit (file_name,info,crc)

+ let infos =

+ try Compilenv.read_library_info file_name

+ with Compilenv.Error(Not_a_unit_info _) ->

+ raise(Error(Not_an_object_file file_name))

+ in

+ Library (file_name,infos)

+let scan_file obj_name tolink = match read_file obj_name with

+ | Unit (file_name,info,crc) ->

+ (* This is a .cmx file. It must be linked in any case.

+ Read the infos to see which modules it requires. *)

+ let (info, crc) = Compilenv.read_unit_info file_name in

+ remove_required info.ui_name;

+ List.iter (add_required file_name) info.ui_imports_cmx;

+ (info, file_name, crc) :: tolink

+ | Library (file_name,infos) ->

+ (* This is an archive file. Each unit contained in it will be linked

+ in only if needed. *)

+ add_ccobjs infos;

+ List.fold_right

+ (fun (info, crc) reqd ->

+ if info.ui_force_link

+ || !Clflags.link_everything

+ || is_required info.ui_name

+ then begin

+ remove_required info.ui_name;

+ List.iter (add_required (Printf.sprintf "%s(%s)"

+ file_name info.ui_name))

+ info.ui_imports_cmx;

+ (info, file_name, crc) :: reqd

+ end else

+ reqd)

+ infos.lib_units tolink

+(* Second pass: generate the startup file and link it with everything else *)

+ let units = List.map (fun (info,_,_) -> info) units_list in

+ List.iter compile_phrase (Cmmgen.generic_functions false units);

+ (List.map

+ (fun (unit,_,crc) ->

+ try (unit.ui_name, List.assoc unit.ui_name unit.ui_imports_cmi,

+ crc,

+ unit.ui_defines)

+ with Not_found -> assert false)

+ units_list));

+

+let make_shared_startup_file ppf units filename =

+ let compile_phrase p = Asmgen.compile_phrase ppf p in

+ let oc = open_out filename in

+ Emitaux.output_channel := oc;

+ Location.input_name := "caml_startup";

+ Compilenv.reset "_shared_startup";

+ Emit.begin_assembly();

+ List.iter compile_phrase

+ (Cmmgen.generic_functions true (List.map fst units));

+ compile_phrase (Cmmgen.plugin_header units);

+ compile_phrase

+ (Cmmgen.global_table

+ (List.map (fun (ui,_) -> ui.Compilenv.ui_symbol) units));

+ (* this is to force a reference to all units, otherwise the linker

+ might drop some of them (in case of libraries) *)

+

+ Emit.end_assembly();

+ close_out oc

+

+

+let call_linker_shared file_list output_name =

+ let files = Ccomp.quote_files file_list in

+ let cmd = match Config.system with

+ | "mingw" | "win32" | "cygwin" ->

+ Printf.sprintf

+ "flexlink -merge-manifest -chain %s -o %s %s %s %s %s %s"

+ (match Config.system with

+ | "mingw" -> "mingw"

+ | "win32" -> "msvc"

+ | "cygwin" -> "cygwin"

+ | _ -> assert false)

+ (Filename.quote output_name)

+ (String.concat " "

+ (List.map (fun s -> if s = "" then "" else

+ "-I " ^ (Filename.quote s)) !load_path))

+ files

+ (if !Clflags.verbose then "-v" else "")

+ (Ccomp.make_link_options !Clflags.ccopts)

+ (if !Clflags.verbose then "" else ">NUL")

+ | _ ->

+ Printf.sprintf

+ "gcc %s %s %s %s -o %s %s"

+ (match Config.system with

+ | "macosx" | "rhapsody" -> "-bundle -flat_namespace -undefined suppress -all_load"

+ | _ -> "-shared")

+ (Clflags.std_include_flag "-I")

+ (Ccomp.quote_files

+ (List.map (fun dir -> if dir = "" then "" else "-L" ^ dir)

+ !load_path))

+ (String.concat " " (List.rev !Clflags.ccopts))

+ (Filename.quote output_name)

+ files

+ in

+ if Ccomp.command cmd <> 0 then raise(Error Linking_error)

+

+let link_shared ppf objfiles output_name =

+ let units_tolink = List.fold_right scan_file objfiles [] in

+ List.iter

+ (fun (info, file_name, crc) -> check_consistency file_name info crc)

+ units_tolink;

+ Clflags.ccobjs := !Clflags.ccobjs @ !lib_ccobjs;

+ let objfiles = List.rev (List.map object_file_name objfiles) @

+ !Clflags.ccobjs in

+

+ let startup =

+ if !Clflags.keep_startup_file

+ then output_name ^ ".startup" ^ ext_asm

+ else Filename.temp_file "camlstartup" ext_asm in

+ make_shared_startup_file ppf

+ (List.map (fun (ui,_,crc) -> (ui,crc)) units_tolink) startup;

+ let startup_obj = output_name ^ ".startup" ^ ext_obj in

+ if Proc.assemble_file startup startup_obj <> 0

+ then raise(Error(Assembler_error startup));

+ if not !Clflags.keep_startup_file then remove_file startup;

+ call_linker_shared (startup_obj :: objfiles) output_name;

+ remove_file startup_obj

+

+ match Config.system, Config.ccomp_type with

+ | (("win32"|"mingw"|"cygwin"), _) when not !Clflags.output_c_object ->

+ let cmd =

+ Printf.sprintf

+ "flexlink -chain %s -merge-manifest -exe -o %s %s %s %s %s %s %s %s %s"

+ (match Config.system with

+ | "win32" -> "msvc"

+ | "mingw" -> "mingw"

+ | "cygwin" -> "cygwin"

+ | _ -> assert false)

+ (Filename.quote output_name)

+ (String.concat " "

+ (List.map (fun s -> if s = "" then "" else

+ "-I " ^ (Filename.quote s)) !load_path))

+ (Filename.quote startup_file)

+ (Ccomp.quote_files (List.rev file_list))

+ (Ccomp.quote_files (List.rev !Clflags.ccobjs))

+ (Filename.quote (runtime_lib ()))

+ c_lib

+ (if !Clflags.verbose then " -v" else "")

+ (Ccomp.make_link_options !Clflags.ccopts)

+ in

+ let res = Ccomp.command cmd in

+ if res <> 0 then raise(Error Linking_error)

+ | _,"cc" ->

+ (Filename.quote (runtime_lib ()))

+ | (("win32"|"mingw"|"cygwin"), _) when !Clflags.output_c_object ->

+ let cmd =

+ Printf.sprintf "%s /out:%s %s %s"

+ Config.native_partial_linker

+ (Filename.quote output_name)

+ (Filename.quote startup_file)

+ (Ccomp.quote_files (List.rev file_list))

+ in if Ccomp.command cmd <> 0 then raise(Error Linking_error)

+ let startup =

+ if !Clflags.keep_startup_file then output_name ^ ".startup" ^ ext_asm

+ else Filename.temp_file "camlstartup" ext_asm in

+(* Link a set of .cmx/.o files and produce an executable or a plugin *)

+val link_shared: formatter -> string list -> string -> unit

+

+val call_linker_shared: string list -> string -> unit

+

+ if !Clflags.keep_asm_file

+ then chop_extension_if_any targetobj ^ ".pack" ^ Config.ext_obj

+ else

+ (* Put the full name of the module in the temporary file name

+ to avoid collisions with MSVC's link /lib in case of successive

+ packs *)

+ Filename.temp_file (Compilenv.make_symbol (Some "")) Config.ext_obj in

+ List.exists (fun info -> info.ui_force_link) units;

+

+module IntSet = Set.Make(

+ struct

+ type t = int

+ let compare = compare

+ end)

+

+let default_apply = IntSet.add 2 (IntSet.add 3 IntSet.empty)

+ (* These apply funs are always present in the main program.

+ TODO: add more, and do the same for send and curry funs

+ (maybe up to 10-15?). *)

+

+let generic_functions shared units =

+ let (apply,send,curry) =

+ List.fold_left

+ (fun (apply,send,curry) ui ->

+ List.fold_right IntSet.add ui.Compilenv.ui_apply_fun apply,

+ List.fold_right IntSet.add ui.Compilenv.ui_send_fun send,

+ List.fold_right IntSet.add ui.Compilenv.ui_curry_fun curry)

+ (IntSet.empty,IntSet.empty,IntSet.empty)

+ units

+ in

+ let apply =

+ if shared then IntSet.diff apply default_apply

+ else IntSet.union apply default_apply

+ in

+ let accu = IntSet.fold (fun n accu -> apply_function n :: accu) apply [] in

+ let accu = IntSet.fold (fun n accu -> send_function n :: accu) send accu in

+ IntSet.fold (fun n accu -> curry_function n @ accu) curry accu

+

+let global_data name v =

+ Cdata(Cglobal_symbol name ::

+ emit_constant name

+ (Const_base (Const_string (Marshal.to_string v []))) [])

+

+let globals_map v = global_data "caml_globals_map" v

+

+(* Header for a plugin *)

+

+let mapflat f l = List.flatten (List.map f l)

+

+type dynunit = {

+ name: string;

+ crc: Digest.t;

+ imports_cmi: (string * Digest.t) list;

+ imports_cmx: (string * Digest.t) list;

+ defines: string list;

+}

+

+type dynheader = {

+ magic: string;

+ units: dynunit list;

+}

+

+let dyn_magic_number = "Caml2007D001"

+

+let plugin_header units =

+ let mk (ui,crc) =

+ { name = ui.Compilenv.ui_name;

+ crc = crc;

+ imports_cmi = ui.Compilenv.ui_imports_cmi;

+ imports_cmx = ui.Compilenv.ui_imports_cmx;

+ defines = ui.Compilenv.ui_defines

+ } in

+ global_data "caml_plugin_header"

+ { magic = dyn_magic_number; units = List.map mk units }

+val generic_functions: bool -> Compilenv.unit_infos list -> Cmm.phrase list

+val globals_map: (string * Digest.t * Digest.t * string list) list ->

+ Cmm.phrase

+val plugin_header: (Compilenv.unit_infos * Digest.t) list -> Cmm.phrase

+let read_library_info filename =

+ let ic = open_in_bin filename in

+ let buffer = String.create (String.length cmxa_magic_number) in

+ really_input ic buffer 0 (String.length cmxa_magic_number);

+ if buffer <> cmxa_magic_number then

+ raise(Error(Not_a_unit_info filename));

+ let infos = (input_value ic : library_infos) in

+ close_in ic;

+ infos

+

+

+let toplevel_approx = Hashtbl.create 16

+

+let record_global_approx_toplevel id =

+ Hashtbl.add toplevel_approx current_unit.ui_name current_unit.ui_approx

+

+ if Ident.is_predef_exn id then Value_unknown

+ else try Hashtbl.find toplevel_approx (Ident.name id)

+ with Not_found ->

+ match get_global_info id with

+ | None -> Value_unknown

+ | Some ui -> ui.ui_approx

+val record_global_approx_toplevel: unit -> unit

+ (* Record the current approximation for the current toplevel phrase *)

+

+

+val read_library_info: string -> library_infos

+

+

+

+ Filename.quote outfile ^ " " ^ Filename.quote infile ^

+ (if !Clflags.verbose then "" else ">NUL"))

+let code_space () =

+ | "rhapsody" when !Clflags.dlcode -> " .section __TEXT,__selfmod,regular,self_modifying_code\n"

+ | "rhapsody" -> " .text\n"

+let rodata_space () =

+ | "rhapsody" when !Clflags.dlcode -> " .data\n"

+

+let external_stubs = ref StringSet.empty

+let external_non_lazy = ref StringSet.empty

+

+let emit_stub s =

+ let lbl = new_label() in

+ ` .section __TEXT,__picsymbolstub1,symbol_stubs,pure_instructions,32\n`;

+ ` .align 5\n`;

+ `L{emit_symbol s}$stub:\n`;

+ ` .indirect_symbol {emit_symbol s}\n`;

+ ` mflr r0\n`;

+ ` bcl 20,31,{emit_label lbl}\n`;

+ `{emit_label lbl}:\n`;

+ ` mflr r11\n`;

+ ` addis r11,r11,ha16(L{emit_symbol s}$lazy_ptr-{emit_label lbl})\n`;

+ ` mtlr r0\n`;

+ ` lwzu r12,lo16(L{emit_symbol s}$lazy_ptr-{emit_label lbl})(r11)\n`;

+ ` mtctr r12\n`;

+ ` bctr\n`;

+ ` .lazy_symbol_pointer\n`;

+ `L{emit_symbol s}$lazy_ptr:\n`;

+ ` .indirect_symbol {emit_symbol s}\n`;

+ ` .long dyld_stub_binding_helper\n`

+

+let emit_non_lazy s =

+ ` .non_lazy_symbol_pointer\n`;

+ `L{emit_symbol s}$non_lazy_ptr:\n`;

+ ` .indirect_symbol {emit_symbol s}\n`;

+ ` {emit_string datag} 0\n`

+

+

+ if !Clflags.dlcode then begin

+ let lbl = new_label () in

+ external_non_lazy := StringSet.add s !external_non_lazy;

+ ` bcl 20,31,{emit_label lbl}\n`;

+ `{emit_label lbl}:\n`;

+ ` mflr {emit_reg i.res.(0)}\n`;

+ ` addis {emit_reg i.res.(0)}, {emit_reg i.res.(0)}, ha16(L{emit_symbol s}$non_lazy_ptr-{emit_label lbl})\n`;

+ ` addi {emit_reg i.res.(0)}, {emit_reg i.res.(0)}, lo16(L{emit_symbol s}$non_lazy_ptr-{emit_label lbl})\n`

+ end else begin

+ ` addis {emit_reg i.res.(0)}, 0, {emit_upper emit_symbol s}\n`;

+ ` addi {emit_reg i.res.(0)}, {emit_reg i.res.(0)}, {emit_lower emit_symbol s}\n`

+ end

+ if !Clflags.dlcode then begin

+ external_stubs := StringSet.add s !external_stubs;

+ ` bl L{emit_symbol s}$stub\n`;

+ end else

+ ` bl {emit_symbol s}\n`;

+ if !Clflags.dlcode then begin

+ (* WRONG: stub will destroy r11 *)

+ external_stubs := StringSet.add "caml_c_call" !external_stubs;

+ ` bl L{emit_symbol "caml_c_call"}$stub\n`;

+ end else

+ ` bl {emit_symbol "caml_c_call"}\n`;

+ emit_string (rodata_space ());

+ emit_string (code_space ())

+ emit_string (code_space ());

+(* if !Clflags.dlcode then begin

+ (* WRONG: stub will destroy r11 *)

+ external_stubs := StringSet.add "caml_call_gc" !external_stubs;

+ ` b L{emit_symbol "caml_call_gc"}$stub\n`;

+ end else *)

+ ` b {emit_symbol "caml_call_gc"}\n`

+ emit_string (rodata_space ());

+ external_stubs := StringSet.empty;

+ external_non_lazy := StringSet.empty;

+ emit_string (code_space ());

+ StringSet.iter emit_stub !external_stubs;

+ StringSet.iter emit_non_lazy !external_non_lazy;

+ emit_string (code_space ());

+ emit_string (rodata_space ());

+ Cconst_symbol s when not !Clflags.dlcode ->

+ -DTARGET_$(ARCH) -DSYS_$(SYSTEM) $(FLEXLINK)

+ compact.o finalise.o custom.o unix.o backtrace.o natdynlink.o

+ backtrace.$(O) natdynlink.$(O)

+ $(CC) -c $(NATIVECCCOMPOPTS) -DNATIVE_CODE -I../../flexdll/ ../byterun/win32.c

+#include "misc.h"

+#include "mlvalues.h"

+#include "memory.h"

+#include "stack.h"

+#include "callback.h"

+#include "alloc.h"

+#include "natdynlink.h"

+#include "osdeps.h"

+#include "fail.h"

+

+#include <stdio.h>

+#include <string.h>

+

+static void *getsym(void *handle, char *module, char *name, int opt){

+ char *fullname = malloc(strlen(module) + strlen(name) + 5);

+ void *sym;

+ sprintf(fullname, "caml%s%s", module, name);

+ sym = caml_dlsym (handle, fullname);

+ /* printf("%s => %lx\n", fullname, (uintnat) sym); */

+ free(fullname);

+ if (NULL == sym && !opt) {

+ printf("natdynlink: cannot find symbol %s\n", fullname);

+ exit(2);

+ }

+ return sym;

+}

+

+

+/* Data segments are used by the Is_atom predicate (mlvalues.h)

+ to detect static Caml blocks.

+

+ Code segments are used in signals_asm.c

+

+ TODO: use dichotomic search

+*/

+

+typedef struct segment {

+ void *begin;

+ void *end;

+ struct segment *next;

+} segment;

+

+segment *caml_dyn_data_segments = NULL;

+segment *caml_dyn_code_segments = NULL;

+

+static segment *segment_cons(void *begin, void *end, segment *tl) {

+ segment *lnk = caml_stat_alloc(sizeof(segment));

+ lnk->begin = begin;

+ lnk->end = end;

+ lnk->next = tl;

+ return lnk;

+}

+

+int caml_is_in_data(void *p) {

+ segment *lnk;

+ for (lnk = caml_dyn_data_segments; NULL != lnk; lnk = lnk->next)

+ if (p >= lnk->begin && p <= lnk->end) return 1;

+ return 0;

+}

+int caml_is_in_code(void *p) {

+ segment *lnk;

+ for (lnk = caml_dyn_code_segments; NULL != lnk; lnk = lnk->next)

+ if (p >= lnk->begin && p <= lnk->end) return 1;

+ return 0;

+}

+

+extern char caml_globals_map[];

+

+CAMLprim value caml_natdynlink_getmap(value unit)

+{

+ return (value)caml_globals_map;

+}

+

+CAMLprim value caml_natdynlink_globals_inited(value unit)

+{

+ return Val_int(caml_globals_inited);

+}

+

+CAMLprim value caml_natdynlink_open(value filename)

+{

+ CAMLparam1 (filename);

+ CAMLlocal1 (res);

+ void *sym;

+ void *handle;

+

+ /* TODO: dlclose in case of error... */

+

+ handle = caml_dlopen(String_val(filename), 1);

+

+ if (NULL == handle)

+ CAMLreturn(caml_copy_string(caml_dlerror()));

+

+ sym = caml_dlsym(handle, "caml_plugin_header");

+ if (NULL == sym)

+ CAMLreturn(caml_copy_string("not an OCaml plugin"));

+

+ res = caml_alloc_tuple(2);

+ Field(res, 0) = (value) handle;

+ Field(res, 1) = (value) (sym);

+ CAMLreturn(res);

+}

+

+CAMLprim value caml_natdynlink_run(void *handle, value symbol) {

+ CAMLparam1 (symbol);

+ CAMLlocal1 (result);

+ void *sym,*sym2;

+

+#define optsym(n) getsym(handle,unit,n,1)

+ char *unit;

+ void (*entrypoint)(void);

+

+ unit = String_val(symbol);

+

+ sym = optsym("__frametable");

+ if (NULL != sym) caml_register_frametable(sym);

+

+ sym = optsym("");

+ if (NULL != sym) caml_register_dyn_global(sym);

+

+ sym = optsym("__data_begin");

+ sym2 = optsym("__data_end");

+ if (NULL != sym && NULL != sym2)

+ caml_dyn_data_segments = segment_cons(sym,sym2,caml_dyn_data_segments);

+

+ sym = optsym("__code_begin");

+ sym2 = optsym("__code_end");

+ if (NULL != sym && NULL != sym2)

+ caml_dyn_code_segments = segment_cons(sym,sym2,caml_dyn_code_segments);

+

+ entrypoint = optsym("__entry");

+ if (NULL != entrypoint) result = caml_callback((value)(&entrypoint), 0);

+ else result = Val_unit;

+

+#undef optsym

+

+ CAMLreturn (result);

+}

+

+CAMLprim value caml_natdynlink_run_toplevel(value filename, value symbol)

+{

+ CAMLparam2 (filename, symbol);

+ CAMLlocal2 (res, v);

+ void *handle;

+

+ /* TODO: dlclose in case of error... */

+

+ handle = caml_dlopen(String_val(filename), 1);

+

+ if (NULL == handle) {

+ res = caml_alloc(1,1);

+ v = caml_copy_string(caml_dlerror());

+ Store_field(res, 0, v);

+ } else {

+ res = caml_alloc(1,0);

+ v = caml_natdynlink_run(handle, symbol);

+ Store_field(res, 0, v);

+ }

+ CAMLreturn(res);

+}

+

+CAMLprim value caml_natdynlink_loadsym(value symbol)

+{

+ CAMLparam1 (symbol);

+ CAMLlocal1 (sym);

+

+ sym = (value) caml_globalsym(String_val(symbol));

+ if (!sym) caml_failwith(String_val(symbol));

+ CAMLreturn(sym);

+}

+#include <string.h>

+#include <stdio.h>

+/* Linked-list */

+

+typedef struct link {

+ void *data;

+ struct link *next;

+} link;

+

+static link *cons(void *data, link *tl) {

+ link *lnk = caml_stat_alloc(sizeof(link));

+ lnk->data = data;

+ lnk->next = tl;

+ return lnk;

+}

+

+#define iter_list(list,lnk) \

+ for (lnk = list; lnk != NULL; lnk = lnk->next)

+

+/* Linked-list of frametables */

+

+static link *frametables = NULL;

+

+void caml_register_frametable(intnat *table) {

+ frametables = cons(table,frametables);

+

+ if (NULL != caml_frame_descriptors) {

+ caml_stat_free(caml_frame_descriptors);

+ caml_frame_descriptors = NULL;

+ /* force caml_init_frame_descriptors to be called */

+ }

+}

+

+ link *lnk;

+ static int inited = 0;

+

+ if (!inited) {

+ for (i = 0; caml_frametable[i] != 0; i++)

+ caml_register_frametable(caml_frametable[i]);

+ inited = 1;

+ }

+

+ iter_list(frametables,lnk) {

+ num_descr += *((intnat*) lnk->data);

+ }

+ iter_list(frametables,lnk) {

+ tbl = (intnat*) lnk->data;

+ h = (h+1) & caml_frame_descriptors_mask;

+ ((uintnat)d +

+ sizeof(char *) + sizeof(short) + sizeof(short) +

+ sizeof(short) * d->num_live + sizeof(frame_descr *) - 1)

+ & -sizeof(frame_descr *);

+static link * caml_dyn_globals = NULL;

+

+void caml_register_dyn_global(void *v) {

+ caml_dyn_globals = cons((void*) v,caml_dyn_globals);

+}

+ link *lnk;

+ /* Dynamic global roots */

+ iter_list(caml_dyn_globals, lnk) {

+ glob = (value) lnk->data;

+ for (j = 0; j < Wosize_val(glob); j++){

+ Oldify (&Field (glob, j));

+ }

+ }

+

+ link *lnk;

+

+ /* Dynamic global roots */

+ iter_list(caml_dyn_globals, lnk) {

+ glob = (value) lnk->data;

+ for (j = 0; j < Wosize_val(glob); j++){

+ f (Field (glob, j), &Field (glob, j));

+ }

+ }

+

+CAMLextern int caml_is_in_code(void *);

+ ( ((char *)(pc) >= caml_code_area_start && \

+ (char *)(pc) <= caml_code_area_end) \

+ || caml_is_in_code((void *)(pc)) )

+extern void caml_register_frametable(intnat *);

+extern void caml_register_dyn_global(void *);

+#include "natdynlink.h"

+CAMLexport header_t caml_atom_table[256];

+ -e 's/^FLEX.*$//g' \

+ -e 's/^FLEX.*$//g' \

+ if not !Clflags.no_auto_link then begin

+ if

+ String.length !Clflags.use_runtime = 0

+ then begin

+ if l.lib_custom then Clflags.custom_runtime := true;

+ lib_ccobjs := l.lib_ccobjs @ !lib_ccobjs;

+ lib_ccopts := l.lib_ccopts @ !lib_ccopts;

+ end;

+ match Config.system, Config.ccomp_type with

+ | ("win32"|"mingw"|"cygwin"),_ ->

+ (* TODO: load path? *)

+ "flexlink -chain %s -merge-manifest -exe -o %s %s %s %s %s %s %s"

+ (match Config.system with

+ | "win32" -> "msvc"

+ | "mingw" -> "mingw"

+ | "cygwin" -> "cygwin"

+ | _ -> assert false)

+ (Filename.quote exec_name)

+ (Clflags.std_include_flag "-I ")

+ prim_name

+ (Ccomp.quote_files (List.rev !Clflags.ccobjs))

+ (Filename.quote "-lcamlrun")

+ Config.bytecomp_c_libraries

+ (Ccomp.make_link_options !Clflags.ccopts))

+ | _,"cc" ->

+ Ccomp.command

+ (Printf.sprintf

+let transl_store_subst = ref Ident.empty

+ (** In the native toplevel, this reference is threaded through successive

+ calls of transl_store_structure *)

+

+let nat_toplevel_name id =

+ try match Ident.find_same id !transl_store_subst with

+ | Lprim(Pfield pos, [Lprim(Pgetglobal glob, [])]) -> (glob,pos)

+ | _ -> raise Not_found

+ with Not_found ->

+ fatal_error("Translmod.nat_toplevel_name: " ^ Ident.unique_name id)

+

+ transl_store_subst := subst;

+ in List.fold_right store_primitive prims (transl_store !transl_store_subst str)

+let transl_store_gen module_name (str, restr) topl =

+ let f = function

+ | [ Tstr_eval expr ] when topl ->

+ assert (size = 0);

+ subst_lambda !transl_store_subst (transl_exp expr)

+ | str -> transl_store_structure module_id map prims str in

+ transl_store_label_init module_id size f str

+let transl_store_phrases module_name str =

+ transl_store_gen module_name (str,Tcoerce_none) true

+

+let transl_store_implementation module_name (str, restr) =

+ let s = !transl_store_subst in

+ transl_store_subst := Ident.empty;

+ let r = transl_store_gen module_name (str, restr) false in

+ transl_store_subst := s;

+ r

+

+val transl_store_phrases: string -> structure -> int * lambda

+val nat_toplevel_name: Ident.t -> Ident.t * int

+include Makefile.common

+CFLAGS=-DCAML_NAME_SPACE -O $(BYTECCCOMPOPTS) $(FLEXLINK)

+OBJS=$(COMMONOBJS) unix.o main.o

+ $(call MKEXE,ocamlrun$(EXE),main.o prims.o libcamlrun.a $(BYTECCLIBS), \

+ $(BYTECCCOMPOPTS) $(BYTECCLINKOPTS))

+libcamlrun.$(A): $(OBJS)

+ $(call MKLIB,libcamlrun.$(A),$(OBJS))

+#########################################################################

+# #

+# Objective Caml #

+# #

+# Xavier Leroy, projet Cristal, INRIA Rocquencourt #

+# #

+# Copyright 1999 Institut National de Recherche en Informatique et #

+# en Automatique. All rights reserved. This file is distributed #

+# under the terms of the GNU Library General Public License, with #

+# the special exception on linking described in file ../LICENSE. #

+# #

+#########################################################################

+

+# $Id$

+

+include ../config/Makefile

+

+CC=$(BYTECC)

+

+COMMONOBJS=\

+ interp.o misc.o stacks.o fix_code.o startup.o \

+ freelist.o major_gc.o minor_gc.o memory.o alloc.o roots.o globroots.o \

+ fail.o signals.o signals_byt.o printexc.o backtrace.o \

+ compare.o ints.o floats.o str.o array.o io.o extern.o intern.o \

+ hash.o sys.o meta.o parsing.o gc_ctrl.o terminfo.o md5.o obj.o \

+ lexing.o callback.o debugger.o weak.o compact.o finalise.o custom.o \

+ dynlink.o

+

+PRIMS=\

+ alloc.c array.c compare.c extern.c floats.c gc_ctrl.c hash.c \

+ intern.c interp.c ints.c io.c lexing.c md5.c meta.c obj.c parsing.c \

+ signals.c str.c sys.c terminfo.c callback.c weak.c finalise.c stacks.c \

+ dynlink.c

+

+PUBLIC_INCLUDES=\

+ alloc.h callback.h config.h custom.h fail.h intext.h \

+ memory.h misc.h mlvalues.h printexc.h signals.h compatibility.h

+

+

+all: ocamlrun$(EXE) ld.conf libcamlrun.$(A)

+

+ld.conf: ../config/Makefile

+ echo "$(STUBLIBDIR)" >ld.conf

+ echo "$(LIBDIR)" >>ld.conf

+

+install:

+ cp ocamlrun$(EXE) $(BINDIR)/ocamlrun$(EXE)

+ cp libcamlrun.$(A) $(LIBDIR)/libcamlrun.$(A)

+ cd $(LIBDIR); $(RANLIB) libcamlrun.$(A)

+ if test -d $(LIBDIR)/caml; then : ; else mkdir $(LIBDIR)/caml; fi

+ for i in $(PUBLIC_INCLUDES); do \

+ sed -f ../tools/cleanup-header $$i > $(LIBDIR)/caml/$$i; \

+ done

+ cp ld.conf $(LIBDIR)/ld.conf

+

+

+primitives : $(PRIMS)

+ sed -n -e "s/CAMLprim value \([a-z0-9_][a-z0-9_]*\).*/\1/p" \

+ $(PRIMS) > primitives

+

+prims.c : primitives

+ (echo '#include "mlvalues.h"'; \

+ echo '#include "prims.h"'; \

+ sed -e 's/.*/extern value &();/' primitives; \

+ echo 'c_primitive caml_builtin_cprim[] = {'; \

+ sed -e 's/.*/ &,/' primitives; \

+ echo ' 0 };'; \

+ echo 'char * caml_names_of_builtin_cprim[] = {'; \

+ sed -e 's/.*/ "&",/' primitives; \

+ echo ' 0 };') > prims.c

+

+opnames.h : instruct.h

+ sed -e '/\/\*/d' \

+ -e '/^#/d' \

+ -e 's/enum /char * names_of_/' \

+ -e 's/{$$/[] = {/' \

+ -e 's/\([[:upper:]][[:upper:]_0-9]*\)/"\1"/g' instruct.h > opnames.h

+

+# jumptbl.h is required only if you have GCC 2.0 or later

+jumptbl.h : instruct.h

+ sed -n -e '/^ /s/ \([A-Z]\)/ \&\&lbl_\1/gp' \

+ -e '/^}/q' instruct.h > jumptbl.h

+

+version.h : ../VERSION

+ echo "#define OCAML_VERSION \"`head -1 ../VERSION`\"" >version.h

+

+clean:

+ rm -f ocamlrun$(EXE) ocamlrund$(EXE) *.$(O) *.$(A)

+ rm -f primitives prims.c opnames.h jumptbl.h ld.conf

+ rm -f version.h

+include Makefile.common

+CFLAGS=-DOCAML_STDLIB_DIR='"$(LIBDIR)"' $(FLEXLINK)

+DBGO=d.$(O)

+OBJS=$(COMMONOBJS:.o=.$(O)) win32.$(O)

+DOBJS=$(COMMONOBJS:.o=.$(DBGO)) win32.$(DBGO) prims.$(DBGO) instrtrace.$(DBGO)

+ocamlrun$(EXE): libcamlrun.$(A) prims.$(O) main.$(O)

+ $(call MKEXE,ocamlrun$(EXE),main.$(O) prims.$(O) libcamlrun.$(A))

+ocamlrund$(EXE): libcamlrund.$(A) prims.$(O) main.$(O)

+ $(call MKEXE,ocamlrun$(EXE),$(BYTECCDBGCOMPOPTS) main.$(O) prims.$(O) libcamlrund.$(A))

+libcamlrun.$(A): $(OBJS)

+ $(call MKLIB,libcamlrun.$(A),$(OBJS))

+libcamlrund.$(A): $(DOBJS)

+ $(call MKLIB,libcamlrund.$(A),$(DOBJS))

+.SUFFIXES: .$(O) .$(DBGO)

+.c.$(O):

+

+ rm -f .depend.win32

+ echo "win32.o: win32.c fail.h compatibility.h misc.h config.h \\" >> .depend.win32

+ echo " ../config/m.h ../config/s.h mlvalues.h memory.h gc.h \\" >> .depend.win32

+ echo " major_gc.h freelist.h minor_gc.h osdeps.h signals.h" >> .depend.win32

+ cat .depend >> .depend.win32

+ sed -e '/\.d\.o/q' -e 's/^\(.*\)\.o:/\1.$$(O) \1.$$(DBGO):/' .depend.win32 > .depend.nt

+ rm -f .depend.win32

+ && (Is_young(init) || Is_in_heap(init) || Is_atom(init))

+ || (!Is_young(v) && !Is_in_heap(v) && !Is_atom(v))

+ if ((Is_young(v2) || Is_in_heap(v2) || Is_atom(v2)) &&

+ if ((Is_young(v1) || Is_in_heap(v1) || Is_atom(v1)) &&

+ if ((!Is_young(v1) && !Is_in_heap(v1) && !Is_atom(v1)) ||

+ (!Is_young(v2) && !Is_in_heap(v2) && !Is_atom(v2))) {

+ if (Is_young(obj) || Is_in_heap(obj) || Is_atom(obj)) {

+#define CAMLexport

+#define CAMLprim

+#define CAMLextern extern

+CAMLextern int caml_is_in_data(void *);

+ ( ( (char *)(v) >= caml_static_data_start \

+ &&(char *)(v) < caml_static_data_end ) \

+ || ((v) >= Atom(0) && (v) <= Atom(255)) \

+ || (caml_is_in_data((void *)v)) )

+extern void * caml_globalsym(char * name);

+

+#elif defined(__CYGWIN32__)

+#include "flexdll.h"

+void * caml_globalsym(char * name)

+{

+ return NULL;

+}

+

+#elif defined(__CYGWIN32__)

+/* Use flexdll */

+

+void * caml_dlopen(char * libname, int for_execution)

+{

+ int flags = FLEXDLL_RTLD_GLOBAL;

+ if (!for_execution) flags |= FLEXDLL_RTLD_NOEXEC;

+ return flexdll_dlopen(libname, flags);

+}

+

+void caml_dlclose(void * handle)

+{

+ flexdll_dlclose(handle);

+}

+

+void * caml_dlsym(void * handle, char * name)

+{

+ return flexdll_dlsym(handle, name);

+}

+

+void * caml_globalsym(char * name)

+{

+ return flexdll_dlsym(flexdll_dlopen(NULL,0), name);

+}

+

+char * caml_dlerror(void)

+{

+ return flexdll_dlerror();

+}

+

+void * caml_globalsym(char * name)

+{

+ return caml_dlsym(dlopen(NULL,RTLD_GLOBAL), name);

+}

+

+void * caml_globalsym(char * name)

+{

+ return NULL;

+}

+

+#include "sys.h"

+

+#include "flexdll.h"

+ void *handle;

+ int flags = FLEXDLL_RTLD_GLOBAL;

+ if (!for_execution) flags |= FLEXDLL_RTLD_NOEXEC;

+ handle = flexdll_dlopen(libname, flags);

+ if ((handle != NULL) && ((caml_verb_gc & 0x100) != 0)) {

+ flexdll_dump_exports(handle);

+ fflush(stdout);

+ }

+ return handle;

+ flexdll_dlclose(handle);

+ return flexdll_dlsym(handle, name);

+}

+

+void * caml_globalsym(char * name)

+{

+ return flexdll_dlsym(flexdll_dlopen(NULL,0), name);

+ return flexdll_dlerror();

+CAMLextern int caml_is_in_code(void *);

+ ( ((char *)(pc) >= caml_code_area_start && \

+ (char *)(pc) <= caml_code_area_end) \

+ || caml_is_in_code((void *)(pc)) )

+

+ (** [is_native] [True] if we are in native code, [False] for bytecode. *)

+ value is_native : bool;

+ do {

+ };

+

+

+value is_native = Dynlink.is_native;

+value (objext,libext) =

+ if DynLoader.is_native then (".cmxs",".cmxs")

+ else (".cmo",".cma");

+

+ DynLoader.load dyn_loader (n ^ objext);

+ let y = "Camlp4"^n^"/"^x^objext in

+<file>.%s Load this module inside the Camlp4 core@."

+(if DynLoader.is_native then "cmx " else "(cmo|cma)")

+;

+ else if Filename.check_suffix name objext then ModuleImpl name

+ else if Filename.check_suffix name libext then ModuleImpl name

+CMXS=cmxs

+### Path to the FlexDLL includes

+FLEXDIR=$(shell flexlink -where)

+FLEXLINK=-I"$(FLEXDIR)"

+

+MKEXE=flexlink -merge-manifest -chain mingw -exe -o $(1) $(2) -- $(3)

+#ml let mkexe out files opts = Printf.sprintf "flexlink -merge-manifest -chain mingw -exe -o %s %s -- %s" out files opts;;

+MKDLL=flexlink -merge-manifest -chain mingw -o $(1) $(3) -- $(4)

+#ml let mkdll out implib files opts = Printf.sprintf "flexlink -merge-manifest -chain mingw -o %s %s -- %s" out files opts;;

+OTHERLIBRARIES=win32unix str num win32graph dynlink bigarray systhreads labltk

+TK_LINK=$(TK_ROOT)/bin/tk83.dll $(TK_ROOT)/bin/tcl83.dll

+#TK_LINK=$(TK_ROOT)/lib/tk84.lib $(TK_ROOT)/lib/tcl84.lib

+CMXS=cmxs

+BYTECCCOMPOPTS=/Ox /MD

+BYTECCLINKOPTS=/MD

+DLLCCCOMPOPTS=/Ox /MD

+### Path to the FlexDLL includes

+FLEXDIR=$(shell flexlink -where)

+FLEXLINK=-I"$(FLEXDIR)"

+MKEXE=flexlink -merge-manifest -exe -o $(1) $(2) -- $(3)

+#ml let mkexe out files opts = Printf.sprintf "flexlink -merge-manifest -exe -o %s %s -- %s" out files opts;;

+MKDLL=flexlink -merge-manifest -o $(1) $(3) -- $(4)

+#ml let mkdll out implib files opts = Printf.sprintf "flexlink -merge-manifest -o %s %s -- %s" out files opts;;

+RANLIB=echo

+NATIVECCCOMPOPTS=/Ox /MD

+NATIVECCLINKOPTS=/MD

+#TK_LINK=tk84.lib tcl84.lib

+TK_LINK=tk83.lib tcl83.lib

+mkexe="\$(BYTECC) -o \$(1) \$(2) \$(3)"

+mkexe_ml="Printf.sprintf \"%s -o %s %s %s\" bytecc out opts files"

+dllccompopts=""

+ dllccompopts="-D_WIN32 -DCAML_DLL"

+ mkexe="flexlink -exe -chain cygwin -o \$(1) \$(2) -- \$(3)"

+ mkexe_ml="Printf.sprintf \"flexlink -exe -chain cygwin -o %s %s -- %s\" out files opts"

+natdynlinkopts=""

+flexlink=''

+cmxs="cmxa"

+ cmxs="cmxs"

+ *-*-cygwin*)

+ flexlink="-I`flexlink -where`"

+ mksharedlib="flexlink -chain cygwin -o"

+ shared_libraries_supported=true;;

+ natdynlinkopts="-Wl,-E"

+echo "NATDYNLINKOPTS=$natdynlinkopts" >> Makefile

+MKEXE=$mkexe

+#ml let mkexe out files opts = $mkexe_ml;;

+echo "DLLCCCOMPOPTS=$dllccompopts" >> Makefile

+echo "FLEXLINK=$flexlink" >> Makefile

+echo "CMXS=$cmxs" >> Makefile

+ || Filename.check_suffix name ".mlt" then

+ process_implementation_file ppf name

+ "-dlcode", Arg.Set dlcode,

+ " Compile into code that can be dynlinked";

+ "-shared", Arg.Unit (fun () -> shared := true; dlcode := true),

+ " Produce a dynlinkable plugin";

+ if

+ List.length (List.filter (fun x -> !x)

+ [make_archive;make_package;shared;compile_only]) > 1

+ then begin

+ prerr_endline "Please specify at most one of -pack, -a, -shared, -c";

+ exit 2

+ end;

+ let target = extract_output !output_name in

+ Asmlibrarian.create_archive (List.rev !objfiles) target;

+ let target = extract_output !output_name in

+ Asmpackager.package_files ppf (List.rev !objfiles) target;

+ end

+ else if !shared then begin

+ Optcompile.init_path();

+ let target = extract_output !output_name in

+ Asmlink.link_shared ppf (List.rev !objfiles) target;

+ let dynlink_cmxa,include_dynlink =

+ A"dynlink.cmxa", S[A"-I"; P dynlink_dir]

+ in

+ Cmd(S[ocamlopt; include_dynlink; dynlink_cmxa; include_unix; unix_cmxa; T(tags_of_pathname native++"ocaml"++"link"++"native");

+LINKFLAGS=$(INCLUDES) -nostdlib

+ $(CP) $(OCAMLDOC) $(INSTALL_BINDIR)/$(OCAMLDOC)$(EXE)

+LINKFLAGS=$(INCLUDES) -nostdlib

+#########################################################################

+# #

+# Objective Caml #

+# #

+# Xavier Leroy, projet Cristal, INRIA Rocquencourt #

+# #

+# Copyright 1999 Institut National de Recherche en Informatique et #

+# en Automatique. All rights reserved. This file is distributed #

+# under the terms of the GNU Library General Public License, with #

+# the special exception on linking described in file ../../LICENSE. #

+# #

+#########################################################################

+

+# $Id$

+

+# Common Makefile for otherlibs on the Unix ports

+

+CAMLC?=$(ROOTDIR)/ocamlcomp.sh

+CAMLOPT?=$(ROOTDIR)/ocamlcompopt.sh

+CFLAGS?=-I$(ROOTDIR)/byterun -O $(BYTECCCOMPOPTS) $(SHAREDCCCOMPOPTS) $(EXTRACFLAGS)

+

+include ../Makefile.shared

+# Note .. is the current directory (this makefile is included from

+# a subdirectory)

+#########################################################################

+# #

+# Objective Caml #

+# #

+# Xavier Leroy, projet Cristal, INRIA Rocquencourt #

+# #

+# Copyright 1999 Institut National de Recherche en Informatique et #

+# en Automatique. All rights reserved. This file is distributed #

+# under the terms of the GNU Library General Public License, with #

+# the special exception on linking described in file ../../LICENSE. #

+# #

+#########################################################################

+

+# $Id$

+

+# Common Makefile for otherlibs on the Win32/MinGW ports

+

+CAMLC=$(CAMLRUN) $(ROOTDIR)/ocamlc -nostdlib -I $(ROOTDIR)/stdlib -w s

+CAMLOPT=$(CAMLRUN) $(ROOTDIR)/ocamlopt -nostdlib -I $(ROOTDIR)/stdlib -w s

+CFLAGS=-I$(ROOTDIR)/byterun $(EXTRACFLAGS)

+

+include ../Makefile

+# Note .. is the current directory (this makefile is included from

+# a subdirectory) \ No newline at end of file

+#########################################################################

+# #

+# Objective Caml #

+# #

+# Xavier Leroy, projet Cristal, INRIA Rocquencourt #

+# #

+# Copyright 1999 Institut National de Recherche en Informatique et #

+# en Automatique. All rights reserved. This file is distributed #

+# under the terms of the GNU Library General Public License, with #

+# the special exception on linking described in file ../../LICENSE. #

+# #

+#########################################################################

+

+# $Id$

+

+# Common Makefile for otherlibs

+

+ROOTDIR=../..

+include $(ROOTDIR)/config/Makefile

+

+# Compilation options

+CC=$(BYTECC)

+CAMLRUN=$(ROOTDIR)/boot/ocamlrun

+COMPFLAGS=-warn-error A -g $(EXTRACAMLFLAGS)

+MKLIB=$(CAMLRUN) $(ROOTDIR)/tools/ocamlmklib

+

+# Variables to be defined by individual libraries:

+#LIBNAME=

+#CLIBNAME=

+#CMIFILES=

+#CAMLOBJS=

+#COBJS=

+#EXTRACFLAGS=

+#EXTRACAMLFLAGS=

+#LINKOPTS=

+#LDOPTS=

+#HEADERS=

+

+CMIFILES ?= $(CAMLOBJS:.cmo=.cmi)

+CAMLOBJS_NAT ?= $(CAMLOBJS:.cmo=.cmx)

+CLIBNAME ?= $(LIBNAME)

+

+all: lib$(CLIBNAME).$(A) $(LIBNAME).cma $(CMIFILES)

+

+allopt: lib$(CLIBNAME).$(A) $(LIBNAME).cmxa $(LIBNAME).$(CMXS) $(CMIFILES)

+

+$(LIBNAME).cma: $(CAMLOBJS)

+ $(MKLIB) -o $(LIBNAME) -oc $(CLIBNAME) -ocamlc '$(CAMLC)' -linkall $(CAMLOBJS) $(LINKOPTS)

+

+$(LIBNAME).cmxa: $(CAMLOBJS_NAT)

+ $(MKLIB) -o $(LIBNAME) -oc $(CLIBNAME) -ocamlopt '$(CAMLOPT)' -linkall $(CAMLOBJS_NAT) $(LINKOPTS)

+

+$(LIBNAME).cmxs: $(LIBNAME).cmxa lib$(CLIBNAME).$(A)

+ $(CAMLOPT) -shared -o $(LIBNAME).cmxs -I . $(LIBNAME).cmxa

+

+lib$(CLIBNAME).$(A): $(COBJS)

+ $(MKLIB) -oc $(CLIBNAME) $(COBJS) $(LDOPTS)

+

+install::

+ if test -f dll$(CLIBNAME)$(EXT_DLL); then \

+ cp dll$(CLIBNAME)$(EXT_DLL) $(STUBLIBDIR)/; fi

+ cp lib$(CLIBNAME).$(A) $(LIBDIR)/

+ cd $(LIBDIR); $(RANLIB) lib$(CLIBNAME).$(A)

+ cp $(LIBNAME).cma $(CMIFILES) $(CMIFILES:.cmi=.mli) $(LIBDIR)/

+ if test -n "$(HEADERS)"; then cp $(HEADERS) $(LIBDIR)/caml/; fi

+

+installopt:

+ cp $(CAMLOBJS_NAT) $(LIBNAME).cmxa $(LIBNAME).$(A) $(LIBDIR)/

+ cd $(LIBDIR); $(RANLIB) $(LIBNAME).a

+ if test -f $(LIBNAME).cmxs; then cp $(LIBNAME).cmxs $(LIBDIR)/; fi

+

+partialclean:

+ rm -f *.cm*

+

+clean:: partialclean

+ rm -f *.dll *.so *.a *.lib *.o *.obj

+

+.SUFFIXES: .ml .mli .cmi .cmo .cmx .$(O)

+

+.mli.cmi:

+ $(CAMLC) -c $(COMPFLAGS) $<

+

+.ml.cmo:

+ $(CAMLC) -c $(COMPFLAGS) $<

+

+.ml.cmx:

+ $(CAMLOPT) -dlcode -c $(COMPFLAGS) $<

+

+.c.$(O):

+ $(BYTECC) $(BYTECCCOMPOPTS) $(CFLAGS) -c $<

+LIBNAME=bigarray

+EXTRACFLAGS=-I../unix -DIN_OCAML_BIGARRAY

+EXTRACAMLFLAGS=-I ../unix

+COBJS=bigarray_stubs.$(O) mmap_unix.$(O)

+CAMLOBJS=bigarray.cmo

+HEADERS=bigarray.h

+include ../Makefile

+ gcc -MM $(CFLAGS) *.c > .depend

+LIBNAME=bigarray

+EXTRACFLAGS=-I../win32unix -DIN_OCAML_BIGARRAY

+EXTRACAMLFLAGS=-I ../win32unix

+COBJS=bigarray_stubs.$(O) mmap_win32.$(O)

+CAMLOBJS=bigarray.cmo

+HEADERS=bigarray.h

+

+include ../Makefile.nt

+

+external get1: unit -> unit = "caml_ba_get_1"

+external get2: unit -> unit = "caml_ba_get_2"

+external get3: unit -> unit = "caml_ba_get_3"

+external set1: unit -> unit = "caml_ba_set_1"

+external set2: unit -> unit = "caml_ba_set_2"

+external set3: unit -> unit = "caml_ba_set_3"

+LIBNAME=dbm

+CLIBNAME=mldbm

+CAMLOBJS=dbm.cmo

+EXTRACFLAGS=$(DBM_INCLUDES)

+LINKOPTS=$(DBM_LINK)

+include ../Makefile

+CAMLOPT=../../ocamlcompopt.sh

+NATOBJS=dynlink.cmx

+

+allopt: dynlink.cmxa

+dynlink.cmxa: $(NATOBJS)

+ $(CAMLOPT) $(COMPFLAGS) -ccopt "$(NATDYNLINKOPTS)" -a -o dynlink.cmxa $(NATOBJS)

+

+dynlink.cmx: dynlink.cmi natdynlink.ml

+ cp natdynlink.ml dynlink.mlopt

+ $(CAMLOPT) -c $(COMPFLAGS) -impl dynlink.mlopt

+ rm -f dynlink.mlopt

+

+ cp dynlink.cmi dynlink.cma dynlink.mli $(LIBDIR)

+ cp extract_crc $(LIBDIR)/extract_crc$(EXE)

+ cp $(NATOBJS) dynlink.cmxa dynlink.$(A) $(LIBDIR)

+ cd $(LIBDIR); $(RANLIB) dynlink.$(A)

+ rm -f extract_crc *.cm[ioax] *.cmxa

+ rm -f *.$(A) *.$(O) *.so *.dll dynlink.mlopt

+.SUFFIXES: .ml .mli .cmo .cmi .cmx

+.ml.cmx:

+ $(CAMLOPT) -c $(COMPFLAGS) $<

+

+include Makefile

+

+let is_native = false

+(** Dynamic loading of object files. *)

+

+val is_native: bool

+(** [true] if the program is native,

+ [false] if the program is bytecode. *)

+(** {6 Dynamic loading of compiled files} *)

+(** In bytecode: load the given bytecode object file ([.cmo] file) or

+ bytecode library file ([.cma] file), and link it with the running

+ program. In native code: load the given OCaml plugin file (usually

+ [.cmxs]), and link it with the running

+ program.

+ below are provided for backward compatibility only and are not

+ available in native code. *)

+(***********************************************************************)

+(* *)

+(* Objective Caml *)

+(* *)

+(* Xavier Leroy, projet Gallium, INRIA Rocquencourt *)

+(* *)

+(* Copyright 1996 Institut National de Recherche en Informatique et *)

+(* en Automatique. All rights reserved. This file is distributed *)

+(* under the terms of the GNU Library General Public License, with *)

+(* the special exception on linking described in file ../../LICENSE. *)

+(* *)

+(***********************************************************************)

+

+(* $Id$ *)

+

+(* Dynamic loading of .cmx files *)

+

+type handle

+

+external ndl_open: string -> handle * string = "caml_natdynlink_open"

+external ndl_run: handle -> string -> unit = "caml_natdynlink_run"

+external ndl_getmap : unit -> string = "caml_natdynlink_getmap"

+external ndl_globals_inited : unit -> int = "caml_natdynlink_globals_inited"

+

+(** {6 Error reporting} *)

+

+type linking_error =

+ Undefined_global of string

+ | Unavailable_primitive of string

+ | Uninitialized_global of string

+

+type error =

+ Not_a_bytecode_file of string

+ | Inconsistent_import of string

+ | Unavailable_unit of string

+ | Unsafe_file

+ | Linking_error of string * linking_error

+ | Corrupted_interface of string

+ | File_not_found of string

+ | Cannot_open_dll of string

+

+exception Error of error

+

+(* Copied from other places to avoid dependencies *)

+

+type dynunit = {

+ name: string;

+ crc: Digest.t;

+ imports_cmi: (string * Digest.t) list;

+ imports_cmx: (string * Digest.t) list;

+ defines: string list;

+}

+

+type dynheader = {

+ magic: string;

+ units: dynunit list;

+}

+

+let dyn_magic_number = "Caml2007D001"

+

+let dll_filename fname =

+ if Filename.is_implicit fname then Filename.concat (Sys.getcwd ()) fname

+ else fname

+

+let read_file filename =

+ let dll = dll_filename filename in

+ if not (Sys.file_exists dll) then raise (Error (File_not_found dll));

+

+ let (handle,data) as res = ndl_open dll in

+ if Obj.tag (Obj.repr res) = Obj.string_tag

+ then raise (Error (Cannot_open_dll (Obj.magic res)));

+

+ let header : dynheader = Marshal.from_string data 0 in

+ if header.magic <> dyn_magic_number

+ then raise(Error(Not_a_bytecode_file dll));

+ (dll, handle, header.units)

+

+let cmx_not_found_crc =

+ "\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"

+

+

+(* Management of interface and implementation CRCs *)

+

+module StrMap = Map.Make(String)

+

+type implem_state =

+ | Loaded

+ | Check_inited of int

+

+type state = {

+ ifaces: (string*string) StrMap.t;

+ implems: (string*string*implem_state) StrMap.t;

+(* loaded_symbols: string StrMap.t; *)

+}

+

+let allow_extension = ref true

+

+let add_check_ifaces allow_ext filename ui ifaces =

+ List.fold_left

+ (fun ifaces (name, crc) ->

+ if name = ui.name

+ then StrMap.add name (crc,filename) ifaces

+ else

+ try

+ let (old_crc,old_src) = StrMap.find name ifaces in

+ if old_crc <> crc

+ then raise(Error(Inconsistent_import(name)))

+ else ifaces

+ with Not_found ->

+ if allow_ext then StrMap.add name (crc,filename) ifaces

+ else raise (Error(Unavailable_unit name))

+ ) ifaces ui.imports_cmi

+

+let check_implems filename ui implems =

+ List.iter

+ (fun (name, crc) ->

+ match name with

+ |"Out_of_memory"

+ |"Sys_error"

+ |"Failure"

+ |"Invalid_argument"

+ |"End_of_file"

+ |"Division_by_zero"

+ |"Not_found"

+ |"Match_failure"

+ |"Stack_overflow"

+ |"Sys_blocked_io"

+ |"Assert_failure"

+ |"Undefined_recursive_module" -> ()

+ | _ ->

+ try

+ let (old_crc,old_src,state) = StrMap.find name implems in

+ if crc <> cmx_not_found_crc && old_crc <> crc

+ then raise(Error(Inconsistent_import(name)))

+ else match state with

+ | Check_inited i ->

+ if ndl_globals_inited() < i

+ then raise(Error(Unavailable_unit name))

+ | Loaded -> ()

+ with Not_found ->

+ raise (Error(Unavailable_unit name))

+ ) ui.imports_cmx

+

+(* Prevent redefinition of a unit symbol *)

+

+(* TODO: make loaded_symbols a global variable, otherwise could

+ break safety with load_private (or not?) *)

+(*

+let check_symbols filename ui symbols =

+ List.fold_left

+ (fun syms name ->

+ try

+ let old_src = StrMap.find name symbols in

+ raise (Error(Reloading_symbol(name,old_src,filename)))

+ with Not_found ->

+ StrMap.add name filename syms

+ )

+ symbols

+ ui.defines

+*)

+

+let empty_state = {

+ ifaces = StrMap.empty;

+ implems = StrMap.empty;

+(* loaded_symbols = StrMap.empty; *)

+}

+

+let global_state = ref empty_state

+

+let loadunits priv filename handle units state =

+(* let new_symbols =

+ List.fold_left (fun accu ui -> check_symbols filename ui accu)

+ state.loaded_symbols units in *)

+ let new_ifaces =

+ List.fold_left

+ (fun accu ui -> add_check_ifaces !allow_extension filename ui accu)

+ state.ifaces units in

+ let new_implems =

+ List.fold_left

+ (fun accu ui ->

+ check_implems filename ui accu;

+ StrMap.add ui.name (ui.crc,filename,Loaded) accu)

+ state.implems units in

+

+ let defines = List.flatten (List.map (fun ui -> ui.defines) units) in

+

+ ndl_run handle "_shared_startup";

+ List.iter (ndl_run handle) defines;

+ { implems = new_implems; ifaces = new_ifaces;

+ (*loaded_symbols = new_symbols*) }

+

+let load priv filename state =

+ let (filename,handle,units) = read_file filename in

+ loadunits priv filename handle units state

+

+let loadfile filename = global_state := load false filename !global_state

+let loadfile_private filename = ignore (load true filename !global_state)

+

+let add_builtin_map st =

+ let map : (string*Digest.t*Digest.t*string list) list =

+ Marshal.from_string (ndl_getmap ()) 0 in

+ let exe = Sys.executable_name in

+ let rank = ref 0 in

+ List.fold_left

+ (fun st (name,crc_intf,crc_impl,syms) ->

+ rank := !rank + List.length syms; {

+ ifaces = StrMap.add name (crc_intf,exe) st.ifaces;

+ implems =StrMap.add name (crc_impl,exe,Check_inited !rank) st.implems;

+(*

+ loaded_symbols =

+ List.fold_left (fun l s -> StrMap.add s exe l)

+ st.loaded_symbols syms

+*)

+ }

+ )

+ st

+ map

+

+

+(* is it ok to restrict only the accessible interfaces? *)

+let allow_only names =

+ let old = !global_state.ifaces in

+ let ifaces =

+ List.fold_left

+ (fun ifaces name ->

+ try StrMap.add name (StrMap.find name old) ifaces

+ with Not_found -> ifaces)

+ StrMap.empty names in

+ global_state := { !global_state with ifaces = ifaces };

+ allow_extension := false

+

+let prohibit names =

+ let ifaces = List.fold_right StrMap.remove names !global_state.ifaces in

+ global_state := { !global_state with ifaces = ifaces };

+ allow_extension := false

+

+let default_available_units () =

+ global_state := add_builtin_map empty_state;

+ allow_extension := true

+

+let init () =

+ default_available_units ()

+

+let digest_interface _ _ =

+ failwith "Dynlink.digest_interface: not implemented in native code"

+let add_interfaces _ _ =

+ failwith "Dynlink.add_interfaces: not implemented in native code"

+let add_available_units _ =

+ failwith "Dynlink.add_available_units: not implemented in native code"

+let clear_available_units _ =

+ failwith "Dynlink.clear_available_units: not implemented in native code"

+let allow_unsafe_modules _ =

+ ()

+(* failwith "Dynlink.allow_unsafe_modules: not implemented in native code" *)

+

+

+(* Error report *)

+

+(* Error report *)

+

+let error_message = function

+ Not_a_bytecode_file name ->

+ name ^ " is not an object file"

+ | Inconsistent_import name ->

+ "interface or implementation mismatch on " ^ name

+ | Unavailable_unit name ->

+ "no implementation available for " ^ name

+ | Unsafe_file ->

+ "this object file uses unsafe features"

+ | Linking_error (name, Undefined_global s) ->

+ "error while linking " ^ name ^ ".\n" ^

+ "Reference to undefined global `" ^ s ^ "'"

+ | Linking_error (name, Unavailable_primitive s) ->

+ "error while linking " ^ name ^ ".\n" ^

+ "The external function `" ^ s ^ "' is not available"

+ | Linking_error (name, Uninitialized_global s) ->

+ "error while linking " ^ name ^ ".\n" ^

+ "The module `" ^ s ^ "' is not yet initialized"

+ | Corrupted_interface name ->

+ "corrupted interface file " ^ name

+ | File_not_found name ->

+ "cannot find file " ^ name ^ " in search path"

+ | Cannot_open_dll reason ->

+ "error loading shared library: " ^ reason

+

+let is_native = true

+LIBNAME=graphics

+COBJS=open.o draw.o fill.o color.o text.o \

+LINKOPTS=-cclib "\"$(X11_LINK)\""

+LDOPTS=-ldopt "$(X11_LINK)"

+include ../Makefile

+#CFLAGS=-I../../byterun $(X11_INCLUDES) -O $(BYTECCCOMPOPTS) $(SHAREDCCCOMPOPTS)

+.PHONY: examples_labltk examples_camltk

+

+

+.PHONY: examples_labltk examples_camltk

+

+examples: examples_labltk examples_camltk

+examples_labltk:

+ cd examples_labltk; $(MAKE) all

+examples_camltk:

+ cd examples_camltk; $(MAKE) all

+ cp dummyUnix.mli dummy.mli

+include Makefile.shared

+

+OCAMLBR=threads.cma winmain.$(O) $(WINDOWS_APP)

+include Makefile.shared

+

+include ../support/Makefile.common

+

+LABLTKLIB=-I ../labltk -I ../lib -I ../support

+OCAMLTOPLIB=-I $(TOPDIR)/parsing -I $(TOPDIR)/utils -I $(TOPDIR)/typing

+INCLUDES=$(OTHERSLIB) $(LABLTKLIB) $(OCAMLTOPLIB)

+

+OBJ = list2.cmo useunix.cmo setpath.cmo lexical.cmo \

+ fileselect.cmo searchid.cmo searchpos.cmo shell.cmo \

+ help.cmo \

+ viewer.cmo typecheck.cmo editor.cmo main.cmo

+

+JG = jg_tk.cmo jg_config.cmo jg_bind.cmo jg_completion.cmo \

+ jg_box.cmo \

+ jg_button.cmo jg_toplevel.cmo jg_text.cmo jg_message.cmo \

+ jg_menu.cmo jg_entry.cmo jg_multibox.cmo jg_memo.cmo

+

+# Default rules

+

+.SUFFIXES: .ml .mli .cmo .cmi .cmx .c .$(O)

+

+.ml.cmo:

+ $(CAMLCOMP) $(INCLUDES) $<

+

+.mli.cmi:

+ $(CAMLCOMP) $(INCLUDES) $<

+

+.c.$(O):

+ $(BYTECC) $(BYTECCCOMPOPTS) $(CCFLAGS) -c $<

+

+all: ocamlbrowser$(EXE)

+

+ocamlbrowser$(EXE): $(TOPDIR)/toplevel/toplevellib.cma jglib.cma $(OBJ) \

+ ../support/lib$(LIBNAME).$(A)

+ $(CAMLC) -o ocamlbrowser$(EXE) $(INCLUDES) \

+ $(TOPDIR)/toplevel/toplevellib.cma \

+ unix.cma str.cma $(OCAMLBR) $(LIBNAME).cma jglib.cma $(OBJ)

+

+ocamlbrowser.cma: jglib.cma $(OBJ)

+ $(CAMLC) -a -o $@ -linkall jglib.cma $(OBJ)

+

+jglib.cma: $(JG)

+ $(CAMLCOMP) -a -o jglib.cma $(JG)

+

+help.ml:

+ echo 'let text = "\\' > $@

+ sed -e 's/^ /\\032/' -e 's/$$/\\n\\/' help.txt >> $@

+ echo '";;' >> $@

+

+install:

+ if test -f ocamlbrowser$(EXE); then : ; \

+ cp ocamlbrowser$(EXE) $(BINDIR); fi

+

+clean:

+ rm -f *.cm? ocamlbrowser$(EXE) dummy.mli *~ *.orig *.$(O)

+

+depend:

+ $(CAMLDEP) *.ml *.mli > .depend

+

+shell.cmo: dummy.cmi

+setpath.cmo fileselect.cmo lexical.cmi searchid.cmi typecheck.cmi: $(TOPDIR)/toplevel/toplevellib.cma

+mytypes.cmi searchpos.cmi searchpos.cmo typecheck.cmo: $(TOPDIR)/typing/stypes.cmi

+

+include .depend

+CAMLextern int __argc;

+CAMLextern char **__argv;

+CAMLextern void caml_expand_command_line(int * argcp, char *** argvp);

+/* extern void caml_main (char **); */

+COMPFLAGS= -I ../support -I $(OTHERS)/win32unix -I $(OTHERS)/unix

+_tkgen.ml: ../Widgets.src ../compiler/tkcompiler$(EXE)

+ cd ..; $(CAMLRUNGEN) compiler/tkcompiler$(EXE) -camltk -outdir camltk

+cTk.ml camltk.ml .depend: _tkgen.ml ../builtin/report.ml ../compiler/pp$(EXE) #../builtin/builtin_*.ml

+ $(CAMLDEP) -slash -I ../support [a-z]*.mli [a-z]*.ml > .depend

+../compiler/pp$(EXE):

+ cd ../compiler; $(MAKE) pp($EXE)

+

+../compiler/tkcompiler$(EXE):

+ cd ../compiler; $(MAKE) tkcompiler($EXE)

+ rm -f *.cm* *.ml *.mli *.$(O) *.$(A) .depend

+include Makefile.gen

+include Makefile

+include Makefile

+COMPFLAGS=-I ../camltk -I ../support

+ cp frxlib.cmxa frxlib.$(A) $(INSTALLDIR)

+ rm -f *.cm* *.$(O) *.$(A)

+include Makefile

+COMPFLAGS=-I ../labltk -I ../support -I $(OTHERS)/win32unix -I $(OTHERS)/unix -I $(OTHERS)/str

+ cp jpflib.cmxa jpflib.$(A) $(OBJS:.cmo=.cmx) $(INSTALLDIR)

+ rm -f *.cm* *.$(O) *.$(A) *~ *test

+include Makefile

+COMPFLAGS= -I ../support -I $(OTHERS)/win32unix -I $(OTHERS)/unix

+_tkgen.ml: ../Widgets.src ../compiler/tkcompiler$(EXE)

+ cd ..; $(CAMLRUNGEN) compiler/tkcompiler$(EXE) -outdir labltk

+tk.ml labltk.ml .depend: _tkgen.ml ../builtin/report.ml ../compiler/pp$(EXE) #../builtin/builtin_*.ml

+ $(CAMLDEP) -slash -I ../support [a-z]*.mli [a-z]*.ml > .depend

+../compiler/pp$(EXE):

+ cd ../compiler; $(MAKE) pp$(EXE)

+

+../compiler/tkcompiler$(EXE):

+ cd ../compiler; $(MAKE) tkcompiler$(EXE)

+ rm -f *.cm* *.ml *.mli *.$(O) *.$(A) .depend

+include Makefile.gen

+include Makefile

+ rm -f $(LIBNAME)top$(EXE) $(LIBNAME) *.cm* *.$(A)

+ rm -f *.cm* *.$(O); \

+ $(MKLIB) -ocamlc '$(CAMLC)' -o $(LIBNAME) \

+ -ccopt "\"$(TK_LINK)\""

+ -ccopt "\"$(TK_LINK)\""

+$(LIBNAME)top$(EXE) : $(TOPDEPS) $(LIBNAME).cma ../support/lib$(LIBNAME).$(A)

+ -I $(OTHERS)/unix -I $(OTHERS)/win32unix unix.cma \

+ cp $(LIBNAME).cmxa $(LIBNAME).$(A) $(INSTALLDIR)

+ cd $(INSTALLDIR); $(RANLIB) $(LIBNAME).$(A)

+ chmod 644 $(INSTALLDIR)/$(LIBNAME).$(A)

+include Makefile \ No newline at end of file

+ tkthread.cmo lib$(LIBNAME).$(A)

+ tkthread.cmx lib$(LIBNAME).$(A)

+COBJS=cltkCaml.$(O) cltkUtf.$(O) cltkEval.$(O) cltkEvent.$(O) \

+ cltkFile.$(O) cltkMain.$(O) cltkMisc.$(O) cltkTimer.$(O) \

+ cltkVar.$(O) cltkWait.$(O) cltkImg.$(O)

+COMPFLAGS=-I $(OTHERS)/win32unix -I $(OTHERS)/unix

+lib$(LIBNAME).$(A) : $(COBJS)

+ $(MKLIB) -o $(LIBNAME) $(COBJS) -ldopt "$(TK_LINK)"

+install: lib$(LIBNAME).$(A) $(PUB)

+ cp $(PUB) lib$(LIBNAME).$(A) $(INSTALLDIR)

+ cd $(INSTALLDIR); $(RANLIB) lib$(LIBNAME).$(A)

+ cd $(INSTALLDIR); chmod 644 $(PUB) lib$(LIBNAME).$(A)

+ if test -f dll$(LIBNAME)$(EXT_DLL); then \

+ cp dll$(LIBNAME)$(EXT_DLL) $(STUBLIBDIR)/; fi

+ if test -f tkthread.$(O); then \

+ cp tkthread.cmx tkthread.$(O) $(INSTALLDIR); \

+ chmod 644 $(INSTALLDIR)/tkthread.cmx $(INSTALLDIR)/tkthread.$(O); \

+ rm -f *.cm* *.o *.a *.so *.obj *.lib *.dll *.exp

+.SUFFIXES : .mli .ml .cmi .cmo .cmx .mlp .c .$(O)

+.c.$(O):

+OTHERS=$(TOPDIR)/otherlibs

+CAMLC=$(CAMLRUN) $(TOPDIR)/ocamlc -nostdlib -I $(TOPDIR)/stdlib

+CAMLOPT=$(CAMLRUN) $(TOPDIR)/ocamlopt -nostdlib -I $(TOPDIR)/stdlib

+include Makefile \ No newline at end of file

+# tkAnimGIF.c used the function Tk_ImageObjCmd, which is not available

+# in a plain Tk installation. Should we disable this subdirectory ?

+

+COMPFLAGS=-I ../support -I ../camltk -I ../../unix -I ../../win32unix

+all: tkanim.cma libtkanim.$(A)

+opt: tkanim.cmxa libtkanim.$(A)

+example: gifanimtest$(EXE)

+COBJS= cltkaniminit.$(O) tkAnimGIF.$(O)

+ $(MKLIB) -ocamlc '$(CAMLC)' -o tkanim $(OBJS)

+ $(MKLIB) -ocamlopt '$(CAMLOPT)' -o tkanim $(OBJS:.cmo=.cmx)

+libtkanim.$(A): $(COBJS)

+ $(MKLIB) -o tkanim $(COBJS)

+gifanimtest-static$(EXE): all gifanimtest.cmo

+ $(CAMLC) -custom -o $@ -I ../lib -I ../support -I ../../win32unix -I ../../unix -dllpath ../support -dllpath . unix.cma -ccopt -L. $(LIBNAME).cma tkanim.cma gifanimtest.cmo

+gifanimtest$(EXE): all gifanimtest.cmo

+ $(CAMLC) -o $@ -I ../lib -I ../support -I ../../win32unix -I ../../unix -dllpath ../support -dllpath . unix.cma $(LIBNAME).cma tkanim.cma gifanimtest.cmo

+ rm -f *.cm* *.$(O) *.$(A) dlltkanim$(EXT_DLL) gifanimtest$(EXE) gifanimtest-static$(EXE)

+.SUFFIXES : .mli .ml .cmi .cmo .mlp .cmx .c .$(O)

+.c.$(O):

+ cp tkanim.cma *.cmi *.mli libtkanim.$(A) $(INSTALLDIR)

+ if [ -f dlltkanim$(EXT_DLL) ]; then \

+ cp dlltkanim$(EXT_DLL) $(STUBLIBDIR)/; \

+ cp tkanim.cmxa tkanim.$(A) $(INSTALLDIR)

+include Makefile

+LIBNAME=nums

+EXTRACFLAGS=-DBNG_ARCH_$(BNG_ARCH) -DBNG_ASM_LEVEL=$(BNG_ASM_LEVEL)

+COBJS=bng.$(O) nat_stubs.$(O)

+include ../Makefile

+clean::

+ cd test ; $(MAKE) clean

+bng.$(O): bng.h bng_digit.c \

+LIBNAME=nums

+EXTRACFLAGS=-DBNG_ARCH_$(BNG_ARCH) -DBNG_ASM_LEVEL=$(BNG_ASM_LEVEL)

+COBJS=bng.$(O) nat_stubs.$(O)

+include ../Makefile.nt

+clean::

+bng.$(O): bng.h bng_digit.c \

+ sed -e 's/\.o/.$(O)/g' .depend > .depend.nt

+LIBNAME=str

+COBJS=strstubs.$(O)

+CAMLOBJS=str.cmo

+include ../Makefile

+depend:

+str.cmo: str.cmi

+str.cmx: str.cmi

+LIBNAME=str

+COBJS=strstubs.$(O)

+CAMLOBJS=str.cmo

+include ../Makefile.nt

+allopt: libthreadsnat.a threads.cmxa threads.$(CMXS)

+ -cclib -lthreadsnat $(PTHREAD_LINK)

+

+# Note: I removed "-cclib -lunix" from the line above.

+# Indeed, if we link threads.cmxa, then we must also link unix.cmxa,

+# which itself will pass -lunix to the C linker. It seems more

+# modular to me this way. -- Alain

+

+

+# Build threads.cmxs, even if unsafe

+threads.cmxs: threads.cmxa

+ $(CAMLOPT) -shared -dlcode -o threads.cmxs -I . threads.cmxa -linkall

+ if test -f unix.cmxs; then cp unix.cmxs $(LIBDIR)/; fi

+ $(CAMLOPT) -dlcode -c $(COMPFLAGS) $<

+MKLIB=../../boot/ocamlrun ../../tools/ocamlmklib

+CFLAGS=-I../../byterun $(EXTRACFLAGS)

+CAMLOBJS=thread.cmo mutex.cmo condition.cmo event.cmo threadUnix.cmo

+CMIFILES=$(CAMLOBJS:.cmo=.cmi)

+COBJS=win32_b.$(O)

+COBJS_NAT=win32_n.$(O)

+LIBNAME=threads

+all: lib$(LIBNAME).$(A) $(LIBNAME).cma $(CMIFILES)

+allopt: lib$(LIBNAME).$(A) $(LIBNAME).cmxa $(LIBNAME).cmxs $(CMIFILES)

+$(LIBNAME).cma: $(CAMLOBJS)

+ $(MKLIB) -o $(LIBNAME) -ocamlc "..\\..\\boot\\ocamlrun ..\\..\\ocamlc" -linkall $(CAMLOBJS) $(LINKOPTS)

+lib$(LIBNAME).$(A): $(COBJS)

+ $(MKLIB) -o $(LIBNAME) $(COBJS) $(LDOPTS)

+win32_b.$(O): win32.c

+ $(BYTECC) $(BYTECCCOMPOPTS) $(CFLAGS) -c win32.c

+ mv win32.$(O) win32_b.$(O)

+

+

+$(LIBNAME).cmxa: $(CAMLOBJS:.cmo=.cmx)

+ $(MKLIB) -o $(LIBNAME)nat -ocamlopt "..\\..\\boot\\ocamlrun ..\\..\\ocamlopt" -linkall $(CAMLOBJS:.cmo=.cmx) $(LINKOPTS)

+ mv $(LIBNAME)nat.cmxa $(LIBNAME).cmxa

+ mv $(LIBNAME)nat.$(A) $(LIBNAME).$(A)

+

+$(LIBNAME).cmxs: $(LIBNAME).cmxa lib$(LIBNAME)nat.$(A)

+ $(CAMLOPT) -shared -o $(LIBNAME).cmxs -I . $(LIBNAME).cmxa -linkall

+

+lib$(LIBNAME)nat.$(A): $(COBJS_NAT)

+ $(MKLIB) -o $(LIBNAME)nat $(COBJS_NAT) $(LDOPTS)

+$(CAMLOBJS:.cmo=.cmx): ../../ocamlopt

+ cp $(CMIFILES) threads.cma $(LIBDIR)/threads

+ cp threads.cmxs $(LIBDIR)/threads

+LIBNAME=unix

+EXTRACAMLFLAGS=-nolabels