GitLab

Sometimes the windows syscall GetExitCodeProcess returns a large result,
larger than the ocaml [int] type. This is expected and not an error. For
example the constant STATUS_QUOTA_EXCEEDED, which is 0xC0000044, may be
a valid exit code. Such large values trip up the [int_of_string] parsing
in the client.

This patch implements the following solution to this problem:
* the server doesn't care and sends the large value;
* (the server now recognizes this value, though, to set the timeout flag
  more often)
* the client uses an Int64 value to parse that big constant;
* when converting to the internal Unix.process_status type, we simply
  convert to [int], because such large values don't have any special
  meaning for Why3 anyway.

* call_provers.ml
(parse_prover_run): now directly take the exit status as argument, and
convert it to int;
(handle_answer): don't wrap argument to parse_prover_run into unix type
* prove_client.ml
(read_answer): read Int64 type now
* server-win.c
(handle_child_event): set timeout boolean also when exitcode is equal to
   constant STATUS_QUOTA_EXCEEDED

Change-Id: I1163a6f1adf1bdbfe1f53269ce0ae57dc8bd0287

add exception handler for int_of_string failure and raise the correct
exception here

this allows to account for the cumulative CPU time spent
in the dedicated server in the stats of the client process,
which is necessary to estimate correctly the execution
time of coqtop on proof scripts using the why3 tactic.

Also, make several connection attempts before giving up.

Do not store socket_name in a reference. Instead, provide two calls:
[connect_external] that takes the socket name as an argument and
[connect_internal] that starts a dedicated server on a fresh socket.
If [Prove_client.send_request] is called when no connection is
established, it calls [connect_internal].

Rationale: the only reason to have a reference for socket_name is
to delay the connection request (for example, until the first call
to [Prove_client.send_request]). However, if the server is already
running when we set [socket_name], it does not cost us anything to
establish this connection right away. This is what [connect_external]
is for. Otherwise, if the server is not running yet, the API client
must ensure that it will be started before the first [send_request],
or else the connection request fails. This requires synchronisation
between the entity that starts the server and the Why3 process. In
this case, the API client should just call [connect_external] once
it knows that the server is up and running.

TODO:
- what is the semantics of [disconnect]? How should we handle the
  tasks in progress?
- what is the semantics of [max_prover_running] when working with
  an external server?
- how should we handle server-side disconnects (if at all)?

1. No default socket name is provided. If Why3 should connect to
   an external server, Prove_client.set_socket_name must be called
   first.

2. If Prove_client.set_socket_name was never called, Why3 assumes
   to be in the stand-alone mode, and will start the server in the
   standard tmp directory (on Unix, $TMPDIR or /tmp, on Win, $TEMP or .).
   The socket name is set to be "why3server.<PID_of_Why3>.sock",
   to avoid clashes with other Why3 processes (fixes the Coq tactic).

3. Global reference Prove_client.standalone is removed.

4. Call_provers does not reexport Prove_client.set_socket_name.

5. Prove_client.connect does nothing if the socket reference is set.

Fixed this by avoiding the recursive call in the case the read is
blocked

also, do not use server_main.c, compile both .o instead

* make server aware of single client mode with command line flag
* server will quit when last client disconnects
* unix variant also deletes socket
* move why3server binary to libdir

nonblocking

* previous implementations of call_on_file and call_on_buffer are
  removed, and now directly use the prove_file_server function
* now, both blocking and nonblocking reading is supported on the socket
* wait_on_call and query_call are implemented by blocking and
  nonblocking read, together with a result buffer, if results for other
  prover runs are returned
* logging of the server is now optional

Previously, the code was written in C, but in fact it was not necessary,
the small difference between Windows and Unix could be achieved in
OCaml, too.

This reverts commit 98f2682f.

For the moment, new API functions are introduced. If existing API
functions are called, the why3server is not used.