package core_unix

Release v0.17.0

• Add add_validate_parsing_flag parameter to Command.run, enabling a -validate-parsing flag in all subcommands. The command immediately exits with a return code of 0 if argument parsing is successful.
• Add Sexp_grammar support to Interval.

• In Linux_ext:

  • Reorganize and improve Epoll implementation.
  • Support memfd_create syscall.
  • Add ?follow_symlinks:bool parameter to Extended_file_attributes.getxattr and Extended_file_attributes.setxattr functions.
• Add Diffable support to Time_float_unix and Time_ns_unix.
• Enrich stable modules in Time_float_unix and Time_ns_unix.
• Documentation and automated formatting.

Release v0.16.0

Changes to Bigstring_unix:

• Add new functions pread and really_pread

Changes to Command_test_helpers:

• Add parse_command_line_or_error function

Changes to Core_unix:

• fork_exec now accepts an optional preexec_fn parameter

  • Called after forking and before executing prog
  • Must not allocate or call async-signal-unsafe functions

• getpgid return type changed to Pid.t option

  • Handles process group IDs that are zero by returning None
• Rename getlogin to username
• Add NPROCESSORS_CONF and NPROCESSORS_ONLN variants to sysconf
• Add get_all_ifnames function

Changes to Filename_unix:

• Add optional close_on_exec parameter (default: false) to open_temp_file_fd

Changes to Interval_lib:

• Add S.Set.to_list function

  • Returns a list of non-overlapping intervals defining the set, in ascending order

Add Interval_unix, a library that defines interval types and functions for Unix specific types, like Time_unix and Time_ns_unix.

Changes to Iobuf_unix:

• Add In_channel_optimized module

  • Provides similar APIs to In_channel with better performance using an intermediate Iobuf
  • New functions: fold_lines, iter_lines, input_lines, fold_lines_raw

Changes to Linux_ext:

• Add tcp_string_option type

  • Add TCP_CONGESTION variant for getting/setting the congestion-control algorithm for a socket
  • Add gettcpopt_string and settcpopt_string helper functions

• Add optional pid parameter to setpriority and getpriority

  • Omitting the [pid] argument means that (only) the calling thread will be affected

Changes to Lock_file_blocking:

• Update blocking_create function:

  • Add max_retry_delay parameter with a default value of min(300ms, timeout / 3)
  • Add random parameter with a default value of a system-dependent low-entropy seed
  • Modify behavior to retry periodically with a random delay between retries

• Update Flock.lock_exn function:

  • Add optional exclusive parameter (default: true)
  • Add optional close_on_exec parameter (default: true)

Changes to Sys_unix:

• Add with_async_exns function

  • Runs the provided function and returns its result
  • Causes any asynchronous Break or Stack_overflow exceptions from finalizers, signal handlers, or the GC to be raised from the call site of with_async_exns

Rename Time_unix to Time_float_unix

Changes to Time_ns_unix:

• Add format function, following man strftime formatting rules
• Add parse function, following man strptime formatting rules
• Add Timezone.Stable module as Zone

Old pre-v0.15 changelogs (very likely stale and incomplete)

As Core is built on top of Base and Core_kernel you might want to have a look at Base's changelog and Core_kernel's changelog.

git version

• Added Unix.map_file.
• Added Iobuf.{of,to}_bytes.
• Added Md5.digest_bigstring and used it to implement a more efficient version of Md5.digest_bin_prot.
• Optimized Time_stamp_counter.Calibrator.calibrate to not allocate.
• Removed Piecewise_linear and Crc.
• Weak_hashtbl was moved out into its own library (which is still part of the core package)
• Move Syslog out of Core.Unix into its own library core.syslog.
• Add get_bind_to_interface function to read current status of SO_BINDTODEVICE socket option. Make both bind_to_interface and get_bind_to_interface use new type Bound_interface_name.t for its argument/return value.

v0.11

• Fix a segfault in Time. (fixes #102)

v0.10

• Renamed Float.to_string as to_string_12, to reflect its 12-digit precision. And introduce a new Float.to_string with the behavior of Float.to_string_round_trippable.
• Added to Command.exec support for specifying another executable via argv.(0) rather than Sys.executable_name.
• Changed Lock_file to not delete lock files in forked processes.
• In Linux_ext.Epoll, reduced closure allocation
• Added support to Piecewise_linear for Time_ns
• Added function Iobuf.Expert.reinitialize_of_bigstring, which allows users to use an Iobuf while being passed a bigstring, without allocating
• Changed Command to no longer print the entire help on parse errors.
• Added [@@deriving hash] to Identifiable.S* and Hashable.S*. Added functors Identifiable.Make*_and_derive_hash_fold_t, which generate hash_fold_t from hash.
• Added to Iobuf inlining annotations for Flambda.
• Added to Schedule a Zoned_between constructor, which allows the span to cross the midnight boundary, and allows a different time zone for the start and end ofdays. Because of the new expressive power, renamed the existing Schedule to Schedule_v4_deprecated and added the new functionality in Schedule_v5.
• Improved Schedule_v5.Between to support crossing the midnight boundary.
• Exposed [@@deriving hash] in Uuid.
• Changed Command to display build time in the local zone.
• Changed Command.exec to allow executing a subcommand of the child executable.
• Added Command.Param.flag_optional_with_default_doc, which takes a default value and formats that value into the doc.
• Added Command.lazy_group and Command.Sexpable.Lazy, so that help for lazy commands and groups of commands doesn't have to force the lazy unless necessary.
• Changed Filename and Unix functions that generate temporary filenames and directories to include .tmp. in the name, so one can reliably recognize them.
• Changed Daemon.daemonize_wait to obey stdout/stderr redirection even when they are already pointing at a regular file.
• Fixed Time.Format's handling of zones.
• In Linux_ext, added support for the TCP_QUICKACK socket option, for use on TCP connections where latency is important
• Added Sys.quote function for quoting bash input, like Filename.quote, but with more readable output.
• Added support to Signal for signals that were added in OCaml 4.03: bus, poll, sys, trap, urg, xcpu, xfsz.
• Added support to Udp.sendto for MacOS.
• Added Linux_ext.Eventfd module, with bindings for eventfd(2).
• Removed bounds checks from Iobuf.unsafe_blit.
• Optimized Inet_addr.inet4_addr_to_int32_exn, removing an intermediate string allocation.
• Optimized Time_ns comparison functions to use the Int63 primitives; they had been shadowed to use slower generic operations exported by Identifiable.Make.
• Added to Unix.Rlimit a Limit submodule, with min and max functions.
• Added function Unix.Inet_addr.inet4_addr_of_int63, for efficient conversion from an Int63.t to an Inet_addr.t.
• Changed Unix.create_process_env's execvp emulation w.r.t environment handling, PATH, and allowed nonfatal errors.
• Changed Unix.sysconf to return an option, and to correctly detect when there is no value.
• Made Unix.IOVec.max_iovecs lazy, to avoid calling sysconf at top-level.
• Removed function Time.Ofday.Zoned.compare, which was misleading because it does not correspond to a temporal ordering. The comparison is now available as Time.Ofday.Zoned.With_nonchronolgical_compare.
• Removed Time_ns functions: of_time, local_now, of_local_time. These functions do not exist in Time.Ofday and are simple wrappers around existing functions.
• Renamed Command.basic as basic_spec. Renamed Command.basic' as basic. We want to encourage the use of Command.Param and discourage the use of Command.Spec.
• Removed Uuid.t_of_sexp.
• Switched Core to -safe-string.
• Changed Uuid.sexp_of_t to show the nil UUID when am_running_inline_test.
• Added module-level documentation for Interval.
• Changed Time_ns.Ofday's to_string and sexp_of_t functions to output nine decimal places rather than six.
• Deprecated Uuid.t_of_sexp, in favor of Unstable.t_of_sexp and Stable.V1.t_of_sexp.
• Fixed Unix.Iovec.of_string and of_bigstring so that the default len includes the suffix of the input starting at pos, as usual.
• Removed Unix.create_process's support for the old ml_create_process backend, leaving it with only the spawn_vfork backend.

v0.9

113.43.00

• Time.Ofday.of_string supports "AM and "PM" suffixes.
• Change the innards of Command.Flag so it no longer uses mutable state. It now updates a Univ_map.t instead.

• Renamed:

  core/test --> core/test-bin

  since these directories contain executables to run rather than libraries with standard unit tests. This is in preparation for moving the standard unit tests to a more "normal" test directory.

• Move unit tests from core/src to core/test .
• The output for the "version" subcommand and the "-version" flag is now the same.

• Core.Std.Lock_file doesn't work properly on OSX, see this:

  https://github.com/janestreet/jenga/issues/4#issuecomment-205176593

  This fix the issue by requiring both flock and lockf only on Linux.

  Closes janestreet/jenga#4

• Unix.fork_exec needs to handle exceptions raised by exec
• Remove Core.Core_list, which was not in Core.Std and had only an unused to_sequence.
• Array.random_element

• Shift operations are unspecified outside of the range 0 <= x < bitsize.

  This fixes unit tests for core/src/core_unix.ml in 32bit.

• Replace all occurences (in Core) of Time_ns.Span.to_int_ns and Time_ns.to_int_ns_since_epoch with their 63bit counterpart.

  Time_ns.Span.to_int_ns and Time_ns.to_int_ns_since_epoch are not implemented in 32bit.

  The is one step toward have unit tests to pass in 32bit.

• Wrap Unix.strptime in Date and Time

• New arg types in Command.Param:

  sexp = Arg_type.create Sexp.of_string

  sexp_conv a_of_sexp = Arg_type.create (fun s -> a_of_sexp (Sexp.of_string s))

• Time_ns.Ofday.create presently makes 2 function calls to caml_int_compare. Changed to use the native int comparisons and avoid the calls in create (and other comparisons).

113.33.01

• Fix build problem on BSD related to endian.h.

113.33.00

• Updated to follow core_kernel's evolution.
• Add variance annotations to a few types in Command.
• Command.Param.choice represents a sum type.
• Added Command.Spec.of_param for conversion from new-style to old style command line specifications. This is expected to be useful for gradually converting Spec-based commands into Param-based ones.

• flag_names and anon_names gives the flags and anons used by a Command.Param.t, while mnemonic combines them to give a string that's good for referring to that param in error messages.

  This feature improves the interface of Command.Param.one_of by saving the caller from passing the flag names separately.

• Remove the closure allocation from Date0.create_exn
• Many apps take schedules as command line parameters (to determine when they'll be up, or when they should raise issues, etc.). Let's add a Schedule.Stable.V4.flag function to generate the command line param to make writing this common pattern easier.

• Add Ofday.Option to time_ns.ml.

  Exports Time_ns.Span.Option.unchecked_value and .Ofday.Option.unchecked_value!

• Finally fix Time_ns.Of_day.of_local_time w.r.t. DST transitions after regression test failures at the DST transition.

  As a result, clarified slightly the role of Time_ns.Ofday, like Time.Ofday, as 24h wall-clock times, not linear time offsets, which latter would have to be up to 25h for DST.

• Adds Command.Spec.Arg_type.percent.
• Add Stable.V1 to Time_ns.Ofday.Option.t, add it to Core.Stable, and standardize the interface to Option modules in Time_ns.
• Add Time_ns.to_ofday.

113.24.02

• Deprecated core.syntax and updated coretop to use ppx_jane

113.24.01

• Updated corebuild to use ppx-jane instead of camlp4

  Closes #70

113.24.00

N.B. Some interface change were made which are not listed here, as they are only cascading from core_kernel. Look at core_kernel's CHANGES.md file to get a complete history of the changes made for this release.

• Add Core.Command.Arg_type.Export.time_zone

• Fix Command.shape to run external programs only once to get their sexp.

  Introduces a new variant of Command.t called Proxy. The Exec variant represents the top-level command of an external executable that has not yet been run; the Proxy variant represents an arbitrary subcommand that has been extracted by running an external executable. Command.exec constructs an Exec variant; Command.shape of an Exec variant runs the executable and generates a tree of Proxy variants representing all the information from the generated sexp, so the executable will not need to be re-run.

• A version of recvmmsg that pre-allocates and reuses the iovec record. Profiling indicates this is a non-trivial amount of our I/O loop (under very heavy load).

  Since nobody is using the heavyweight features of the existing recvmmsg, replace it with the lightweight one. This leads to minor but important changes to the interfaces of Iobuf.recvmmsg_assume_fd_nonblocking and Udp.recvmmsg_loop.

• Switch to ppx.

• Time.set_sexp_zone affects t_of_sexp

  If we're willing to read sexps without zones, we should be willing to let you control what timezone they're read with.

• Sped up Llimiter.
• Make Interval.Int implement Container and Binary_searchable.
• Add Identifiable.S to Unix.Cidr so that it supports hash tables. Update Unix.Cidr.t to normalize values, e.g. "192.168.1.101/24" ==> "192.168.1.0/24".
• Added "noalloc" attribute to Linux_ext.unsafe_timerfd_settime.

• In Iobuf, made some functions take:

  (> write, _) Iobuf.t

  rather than:

  (read_write, _) Iobuf.t

  if they only need to write to the iobuf and don't need to read it.

• Time.of_string_abs didn't support ISO 8601 time zone strings without colons, or those specified as locations. This version adds support for time zones without colons
• Unix.Passwd.getpwents takes the lock, partially applies Exn.protect, then releases the lock, then completes the application and actually runs stuff.

• Command.file-completion

  Files are now completed correctly when paths contain a directory.

  Previously, completion when pointed at a directory would put a space at the end. This would cause the user to hit backspace every time a directory was in the path.

• Add diff_weekdays and diff_weekend_days functions to date module.
• Time.to_date_ofday_precise implements a complete inverse for of_date_ofday. This is needed to give the DWIM-est semantics to Schedule.t that we can think of.
• Reduce allocation in Linux_ext.Epoll
• Add Time_ns.Of_day.(add_exn, sub_exn, diff).
• Adding head_padded_fixed_string to Iobuf.
• Move Core_extended.Std.Sys.home to Core.Std.Sys.home_directory.
• Add Iobuf.{read,write,input,output} akin to the bigstring versions.
• Add expert iobuf functions for extracting bigstrings and iovecs that share the iobuf's underlying storage.
• Add stable Int63.t conversions for types in Time_ns.
• Rename DNS-based Inet_addr sexp conversions to expose their blocking nature.
• Add Unix.Inet_addr.Stable.
• Add [Core.Std.Schedule].

• Fixed Iobuf_packet.iter, which behaved incorrectly if the packet didn't start at the lo_min of the iobuf. It used Iobuf.rewind when it should have used Iobuf.Lo_bound.restore.

  Added @@deriving compare to Iobuf.Bound.

• Add ability to Time.format for a specific time zone

• Make more information available via Command.Shape.t

  Expose machine-readable info on anonymous arguments.

• Remove unnecessary rebinding of (^/) in core_filename.ml. It had one call site and wasn't exposed. The (^/) everyone uses comes from std.ml

• Add getifaddrs to Core.Std.Unix.

  Handles Packet (for interfaces that do not have an address on Linux systems only), IPv4 and IPv6 address families.

• Implement Time_ns.Span.to_string_hum by analogy to Time.Span.to_string_hum. The code and tests are essentially copied from "lib/core/src/span.ml".

• Remove our stubs for Unix.stat.

  They were upstreamed in 4.02.2.

112.35.00

• Tweaked Unix.stat's C code to reduce float rounding error, by using double-precision rather than single-precision floats.

  Following Xavier's comment: http://caml.inria.fr/mantis/view.php?id=6285

• Added Date.O module.
• In Interval, exposed compare in stable types by having the appropriate modules match the Stable signature.
• Added Iobuf.Fill.decimal and Poke.decimal, for efficiently writing integers in decimal format.
• Removed Filename.O (and /^), since it's not used that much, and is inconsistent with the older operator for this that's exposed in Core.Std: ^/.

• Improved Command autocompletion to work even if some arguments can't be parsed.

  This is useful because the completion mode does not get fed precisely the same arguments that it would get if you hit RETURN.

  As a simple example, if completion is set up for my-exe which takes a sexp as its first argument, then:

    my-exe '(a b)' <TAB>

  will run my-exe in completion mode with:

    '(a b)'

  as its first argument, rather than:

    (a b)

  as would be passed if RETURN had been pressed instead. Since Sexp.of_string "'(a b)'" fails, in this example tab completion won't work.

  Changed the internals a bit to make this possible. Most notably, the Parser module is now applicative rather than monadic, which required only a few simple changes to support.

• Made Time_ns.to_time and Time_ns.Span.to_span round to the nearest microsecond in all cases.

  Previously, Time_ns.Span.to_span sometimes rounded incorrectly for negative spans.

• Added Time.Zone.prev_clock_shift, the analog of next_clock_shift.

      val prev_clock_shift
  :  t
  -> before:Time_internal.T.t
  -> (Time_internal.T.t * Span.t) option

  Implemented next_clock_shift and prev_clock_shift using Array.binary_search_segmented.

• Added Lock_file.get_pid : string -> Pid.t option.
• Added val random: unit -> int to Time_ns and Time_ns.Span.

• Renamed Iobuf.sub as Iobuf.sub_shared.

  This more closely matches Bigstring, and clarifies the semantics of Iobuf.sub vs sub in Blit_intf.S.

• Added Iobuf blit modules: Blit, Blit_consume, Blit_fill, Blit_consume_and_fill.

• Added Piecewise_linear.first_knot and last_knot.

        val first_knot : t -> (key * value) option
  val last_knot  : t -> (key * value) option

• Made Unix.Cidr match Comparable.S_binable, and added Cidr.create and Cidr.netmask_of_bits.
• Moved Unix.tm and Unix.strftime from Core_kernel to Core.

• Made Crc.crc32 return Int63.t rather than int64, and added Crc.bigstring_crc32 and Iobuf.crc32.

  Cleaned up old cruft in the C stubs for CRC checking.

• Added Iobuf.narrow_lo and narrow_hi, which comprise Iobuf.narrow.

• Changed Linux_ext.Timerfd, Epoll.wait, and Unix.select to use (int) Time_ns rather than (float) Time.

  This avoids spurious float conversions and rounding problems.

  Made all timeouts consistently treat negative timeouts as "timeout immediately".

  This fixes an incorrect behavior of Linux_ext.Timerfd.set_after and set, which had been rounding to the nearest microsecond, which was particularly bad for time spans smaller than 500ns, which would be rounded to zero, and then would cause the timerfd to never fire. Now, the small span is directly fed to timerfd_settime. We also changed a span of zero to be treated as 1ns, to avoid the behavior of timerfd_settime 0, which causes the timerfd to be cleared and never fire.

• Made Or_error match Applicative.S.

• Added Command.Param, with the intention of one day replacing Command.Spec and providing an applicative interface for command-line parsing.

  This change required lots of rearrangement of command.mli so that Command.Param and Command.Spec could share large portions of their interface. As a side effect, the interface is more sweeksy than before.

• Added Command.shape, for exposing the shape of a command, including what subcommands its has.

• Changed Syscall_result.to_result to return a preallocated object, and changed many uses to take advantage of this property.

  Pattern matching on results is much clearer than if-analysis and avoids double-checking errors in many cases.

  Syscall_result.to_result can only return preallocated results for a few Ok values from Syscall_result.Int, of course, and likewise for other large ok_value types. We have initially, and arbitrarily, limited preallocation to 64 errno's and 2048 ok_value's.

• Added Sys.big_endian : bool, from Caml.Sys.

• Disabled unit tests in Time_ns that started failing around 10:40pm NYC 2015-05-15.

  The tests indicate an off-by-one-microsecond error in round tripping between Time.Span.t and Time_ns.Span.t.

112.24.00

• Renamed Dequeue as Deque.
• Added Fdeque, a functional deque (a double-ended Fqueue, or a functional Deque).

• Changed Fqueue's bin-io format, and added a stable type.

  Deprecated deque-like functions in favor of Fdeque.

• Added Fheap, a functional heap implementation based on pairing heaps.
• Reverted the change to Or_error's bin-io format made in 112.17, going back to the format in 112.16 and before.
• Added to Unix.env type a ``Replace_rawvariant, as used inexecandfork_exec`.
• Added Array.Permissioned module, which has a permissioned array type and permissioned versions of all the regular array functions.
• Added Date.week_number : t -> int.

• Added values to Day_of_week: of_int_exn, iso_8601_weekday_number, weekdays.

        val of_int_exn : int -> t
  val iso_8601_weekday_number : t -> int
  val weekdays : t list (- [ Mon; Tue; Wed; Thu; Fri ] *)

• Switched Float IEEE functions to use Int63.t for the mantissa rather than int, so they work on 32-bit platforms.
• Added a length field to the Map.t record, making Map.length O(1) rather than O(n).
• Moved a fragment of Time_ns from Core to Core_kernel, enough so that Async_kernel can use Core_kernel.Time_ns and ultimately only depend on Core_kernel.
• Fixed compilation of Time_ns 32-bit Linux.
• Added Bounded_int_table.clear.

• Fixed the module_name passed to Identifiable.Make for a number of modules.

  The module name must be an absolute module path.

  Reported here: https://github.com/janestreet/core/issues/52

• Added Tuple.Binable functor, for making binable tuples.

• Sped up a Time_stamp_counter unit test.

  Time_stamp_counter unit test has an 18s unit test, which seems excessive. Take a couple of orders of magnitude off the number of iterations.

• Added Time_ns.pause, whose implementation is the same as Time.pause.

  This involved moving the nanosleep C code from Core to Core_kernel.

  This was necessary so that Async_kernel can pause without introducing a dependence of Async on Core.

• Made Core_kernel.Time_ns.Alternate_sexp use a similar format to Core.Time_ns.

  This was needed so that Async_kernel can use a nice sexp format for time spans.

• Changed Timing_wheel implementation to use Time_ns, and moved to Core_kernel.Timing_wheel_ns; made Core.Timing_wheel a wrapper around Timing_wheel_ns.

  Generalized the timing-wheel interface to be parametric in Time, so that one interface applies to both Timing_wheel and Timing_wheel_ns.

  Generalized the timing-wheel unit tests to a functor, Timing_wheel_unit_tests.Make, that is used to test both Timing_wheel_ns and Timing_wheel_float. Moved a few tests that depend on Time and Date from the functor into timing_wheel_float_unit_tests.ml.

  Split out Timing_wheel.Debug into a separate functor, Timing_wheel_debug.Make.

  This was done in so that Async_kernel can depend only on Core_kernel and not Core.

• Added optional arguments to Command.group: ?body and ?preserve_subcommand_order.

  preserve_subcommand_order : unit causes subcommands to be in the order they are specified, rather than sorted.

  body : (path:string list -> unit) is called when no additional arguments are passed.

• Added accessor function Command.summary : t -> string.
• Fixed a bug in Time.Span robust comparison.

• Changed Command's tab-completion bash code so that it is possible for programs to return completions containing spaces.

  Actually knowing when and how to do so is difficult, because of course there's escaping to worry about. Adding helper functions to make that sort of thing manageable is left for future work.

• In Command, made the -version and -build-info flags work at the top level when there are subcommands.
• Added Sequence.interleaved_cartesian_product, which implements cartesian product of potentially infinite sequences.

112.17.00

• Deprecated the single-line files that simply include the corresponding Core_kernel module. Those are unnecessary, because people should use Core.Std.

  We will keep these aliases around for a version before deleted them entirely.

• Changed finalizers and signal handlers to, upon an unhandled exception, exit nonzero rather than asynchronously raise.

• Removed Time.Zone.find_office.

  Replaced uses with the still-blocking Time.Zone.find_exn

• Made many changes to Time to make the time zone explicit instead of implicitly using the local timezone.

  Added zone:Time.Zone.t parameters to many functions. In almost all cases, used ~zone:Time.Zone.local where previously it was implicit.

  Removed of_local_ofday and to_local_ofday in favor of the explicit versions (with Time.Zone.local).

  Removed Time.Zone.machine_zone () in favor of local.

• Exported Core.Std.With_return.
• Exposed Core.Std.with_return_option.
• Fixed Time_ns.Ofday.of_span_since_start_of_day to check its input.
• Changed Time_ns.to_span and of_span to round to microseconds, for round trippability.
• Added Unix.Error module, for the Unix.error type.

• Added Unix.Syscall_result, a new abstract type representing the result of a Unix system call as an int, to avoid allocation.

  A lot of Unix system calls return an integer on success, so for ones that are called a lot, we can encode errors as -errno. This module abstracts this concept.

• Changed Iobuf.recvmmsg functions to return the new Unix.Syscall_result.
• Changed Unix.exec's ?env argument to support extending the environment in addition to replacing it.
• Added with compare to Unix.Exit.t and Unix.Exit_or_signal.t.

• Moved Backtrace to Core_kernel.

  Deleted backtrace_stubs.c, now that we have Printexc.get_callstack.

• Changed Bigstring.read_assume_fd_is_nonblocking and send_nonblocking_no_sigpipe to return Unix.Syscall_result.t, to reduce allocation.
• Changed Iobuf.send_nonblocking_no_sigpipe to handle EINTR like EAGAIN, instead of raising.
• Added Command.Spec.char.
• Changed Process_env.parse_ssh_client to accept an SSH_CLIENT that is just IP address without ports.

112.06.00

• Renamed Linux_ext.gettid as Unix.gettid, and added OpenBSD support.

  SYS_gettid is not available on OpenBSD, but is used in Core_extended. See the mailing list discussion about this here:

  https://groups.google.com/forum/#!topic/ocaml-core/51knlnuJ8MM

  Seems like the OpenBSD alternative is:

    pid_t        getthrid(void);

  although it's not defined in any header file, which is a bit unfortunate.

• Added Piecewise_linear.precache, which computes a lookup table that speeds up subsequent calls to Piecewise_linear.get.
• Added Time_ns module, representing times as 63-bit integers of nanoseconds since the epoch.
• Fixed build of unix_stubs.c on OpenBSD.
• In Daemon, fixed an error message regarding WSTOPPED (fixes #47).

• Added Time.Span.Stable.V2, with sexps that use new suffixes for microseconds (us) and nanoseconds (ns).

  Time.Span.of_string supports the new format, but Time.Span.to_string doesn't yet produce it -- we plan to change that later, after the new of_string has made it out more widely.

• Added Time.Span.to_string_hum, which gives more options for rendering time spans.

• Merged the recvmmsg stubs in Bigstring and Iobuf.

  Factored out a shared underlying recvmmsg call that both stubs use.

  Restored -pedantic by avoiding a C99 feature (variable-length stack arrays).

• Made Date.t abstract, and changed its representation from a 4-word record to an immediate int (packing year, month, day).
• In Daemon, changed the permissions of the std{err,out} files generated during daemonization from 0o777 to 0o644.

• Moved Thread_safe_queue from core to core_kernel.

  This was done so that Async_kernel can use it, eliminating one of Async_kernel's dependencies on Core.

  Thread_safe_queue_unit_tests remains Core, at least for now, because it has some dependencies on other stuff in Core.

112.01.00

• Removed vestigial code supporting OCaml 4.00.

• Added Command support for flags that are passed one or more times.

  Added Command.Spec.one_or_more and Command.Spec.non_empty_sequence to deal with the cases where you expect a flag or anonymous argument (respectively) to be passed one or (optionally) more times. This is common enough and distinct from the case where you want the argument passed zero or more times that it seems like we should canonize it in the library.

• In Lock_file, made stale lock detection more robust.

  Made Lock_file.create foo succeed if foo is absent and foo.nfs_lock file is present and stale. Previously, it would fail.

• Removed Syslog.syslog's add_stderr argument; use the PERROR option instead.

• Fixed unix_stubs.c compilation on NetBSD

  Closes #45

• Added Filename operators /^ and /@, and of_parts, like the same functions for Catalog paths.

• Changed Iobuf functions that advance the iobuf to not also return a redundant number of bytes processed.

  This avoids a small allocation (in the case of the int option functions) and normalizes the result (so the same information isn't returned two ways). Actually, it doesn't yet avoid the allocation in the implementation, as the corresponding Bigstring functions must still return the number of bytes processed, and currently do so as an option. We hope to eventually change that.

  In the future I expect we will change unit to some error variant to also avoid the exception construction for EWOULDBLOCK/EAGAIN. We can even make Unix syscalls noalloc if we're careful.

• In Unix module, added unit tests for Cidr.does_match.