Mantis - ISSUES

0004927: caml_int64_of_bits, gcc optimisation and double alignment

I just experienced a problem with caml_int64_float_of_bits. this function (as
well as others in this file) use a union to "convert" an integer into a double
: first the int64 value is copied into a union, then the double is read and
send to caml_copy_double.

With gcc 4.4.1 this was optimized into loading directly the float value into a
float register from the address of the given value (+4 for the value header).
This fails on an architecture that cannot load double words from unaligned
address.

This just happened to me on a MIPS for ocaml 3.9 (but I saw the function is
still the same on 3.11); as a workaround I declared the union as volatile, thus
preventing this optimisation, but this is not satisfactory.

IMHO gcc is not to blame here since it's undefined behaviour to read a field of
a union but the one that was written to.

I have no idea how to fix this properly.

As a reference here is the involved code :

CAMLprim value caml_int64_float_of_bits(value vi)
{
union { double d; int64 i; int32 h[2]; } u;
u.i = Int64_val(vi);
{ int32 t = u.h[0]; u.h[0] = u.h[1]; u.h[1] = t; }
return caml_copy_double(u.d);
}

0004926: Better support for recursive types

The following will be rejected by the compiler:

type 'a t = A of 'a
type u = u t

whereas this works:

type 'a t = [ `A of 'a ]
type u = u t

Maybe there are good reasons why sum types, which create a new type, should not behave similar to polymorphic variants here. But there are cases where the inability of the compiler to infer that the type recursion is "interleaved" by data constructors requires tedious workarounds (introducing new types).

If it seems easy enough to do, it would be great if some support for recursive types could be added to the compiler. Not all type recursion is evil.

0004914: Add a syntax for reference to elements on text

It would be nice to add the following text element :

{{!string}text}

This would behave like {!string} but instead of writing the reference "string", "text" would be written.

Example :

Have a look at {{!Mymodule.thetype}this type}

Currently, to do that you have to write :

Have a look at {{:Mymodule.html#TYPEthetype}this type}

which relies on the way identifiers are generated (and is specific to one kind of output).

0004922: Ocamlbuild recompiles too many files

When a compilation fails, Ocamlbuild does not correctly remembers some of the files it has successfully built. This is very tiresome on big builds, where the same files may need to be recompiled as long as the project has not been entirely rebuilt. The attached patch fixes this problem. (Notice that there are two completely independent bugs.)

0004920: example of linking C main with OCaml runtime needs additional libraries

In the manual chapter "Interfacing C with Objective Caml", subsection "Advanced topic: callbacks from C to Caml", sub-subsection "Embedding the Caml code in the C code":

1. It's not necessary to include unix.cma in the ocamlopt command, or -lunix in the gcc command (unless required by the OCaml code, of course)

2. It is necessary to add both "-lm" and "-ldl" at the end of the gcc command line.

(on Linux, at least)

0004919: Missing code_of_unix_error() in C interface of Unix module

The C interface to the Unix module provides a unix_error_of_code() to convert C errno numbers into OCaml Unix.error. It does not provide the reverse function though. In libfuse I have callbacks that can return a C errno number. The libfuse OCaml bindings then need a way to convert a Unix.error into a C errno number before returning it to libfuse. The attached patch adds the missing code_of_unix_error() function for this.

0004909: int31 type for Bigarray

I currently have the problem that I want to read/write 31bit signed integer values to a Bigarray. The bigarray acts as a buffer that is stored on disk or restored from it from a C library.

On a 32bit CPU I can just use (int, int, c_layout) Array1.t but on a 64bit CPU I need to use (int32, int32, c_layout) Array1.t. This means I need 2 flavours of the code depending on the number of bits the cpu has.

It would be nice if there were a (int, int31_elt) kind in Bigarray allowing the use of int on 32bit and 64bit platforms.

0004918: Inlining & direct function application optimisation

ocamlopt does not recognise direct function applications which arise from inlining even trivial functions. For example,

let id f = f
let rec f n = if n <= 0 then 0 else n * f (n - 1)

let _ = f 10
let _ = id f 20

generates:

...
mov eax, 21
call _camlTest__f_60 % Direct call for f 10
L105:
mov ebx, DWORD PTR _camlTest+4
mov eax, 41
mov ecx, DWORD PTR [ebx]
call ecx % Indirect call to f 20
L106:

The call to id is correctly inlined, but then the direct call is not recognised.

See: ocaml/asmcomp/closure.ml

0004679: Better module/namespace system

The module and/or file naming system for ocaml has some annoying restrictions that a modern language like ocaml shouldn't run it.

E.g. today I was trying to create a packed module, and one of the modules to be packed into it has the same name as a module in the standard library, so I had to add a useless prefix to make it work.

This is more silly considering that the module itself wouldn't actually be a top-level module, so there wouldn't be an actual naming conflict in the general case.

I would like to see a real namespace system in ocaml rather than a tonne of top-level module names with a high risk of naming conflicts, and having to make sure one always comes up with unique module/file names. The packing approach is cumbersome.

0004917: Make Graphics module use modern X fonts instead of X core fonts

X core fonts have been deprecated for many years. Fedora are trying to identify pieces of software which still use X core fonts and could be changed to use modern X fonts (based on Xft and FontConfig). The OCaml Graphics module is one such place.

The attached patch changes the Graphics module to use modern X fonts. The changes are relatively simple - changing calls such as XDrawString to use the Xft equivalent (XftDrawString8).

One immediate advantage is that Graphics users will see anti-aliased fonts.

Another advantage is that Graphics users can specify font names like "Times-12" instead of the massive and incomprehensible XLFD strings ("-*-times-*-r-....")

0004916: Flag for automatically constraining to unit types

This issue has already come up on the list a while ago, and we have also run into problems with that. Consider the following code:

let equal f t1 t2 = f t1.a t2.a; f t1.b t2.b

This should have been:

let equal f t1 t2 = f t1.a t2.a && f t1.b t2.b

Sadly, the compiler does not warn that the first case is not quite consistent with the signature where f is of type ('a -> 'a -> bool), because the return value is thrown away (treated as if it were of unit type).

Would it be possible to add a flag to the compiler that would automatically constrain expressions to be of unit type if they are followed by a semicolon? E.g.:

let equal f t1 t2 = (f t1.a t2.a : unit); f t1.b t2.b

This would eliminate this class of errors by requiring users to explicitly ignore return values if they want to evaluate functions for side effects only.

0004915: Add a syntax to include images or alternatively raw html

Everything is in the title.

If raw html is considered, the syntax for raw latex could be extended in the style of the {!string} syntax. I.e.

{% %} is sill raw latex, but {%kind: %} is raw for the backend "kind".

Best,

Daniel

0004906: $PWD not set in Sys.command after Sys.chdir on Solaris

If you start a command with Sys.command on Solaris (not OpenSolaris), $PWD always has the same value it had at the start of the program, even after a Sys.chdir:

Objective Caml version 3.11.1

# Sys.command "echo $PWD";;
/home/fhars/godi32/bin
- : int = 0
# Sys.chdir "/home/fhars";;
- : unit = ()
# Sys.command "echo $PWD";;
/home/fhars/godi32/bin
- : int = 0
# Sys.getcwd ();;
- : string = "/home/fhars"

This at least breaks the build for godi.

0004777: Scanf tests fail

I've noticed that scanf tests from CVS test/Moretest/tscanf.ml just fail:

./tscanf.byt
0 1 2 3 4 5 6 7 8 9

********* Test suit failed. ***********

********* Test number 9 failed ***********
Fatal error: exception End_of_file
Raised at file "scanf.ml", line 159, characters 23-34
Called from file "scanf.ml", line 766, characters 12-41
Called from file "scanf.ml", line 1146, characters 17-35
Called from file "scanf.ml", line 1252, characters 12-40
Re-raised at file "scanf.ml", line 1063, characters 15-16
Called from file "tscanf.ml", line 215, characters 2-33
Called from file "tscanf.ml", line 220, characters 5-16

Test 0000009 fails and an exception happens in test 0000010. The latter can be simplified to the following:

open Scanf

let id x = x

let _ =
let unit s =
let ib = Scanning.from_string s in
Scanf.bscanf ib "%S" id in
if not (unit "\"\n\\\n a\n\\\nb\\\n\"" = "\na\nb") then
print_string "failed!\n"

Is this expected behavior (and not updated test suite) or just bugs?

0004913: ocamldoc html output is invalid for custom index files

when given the option -index, ocamldoc produce an index.html which is invalid: there are closing tags for and .
The fix is simple: in caml-3.11.1/ocamldoc/odoc_html.ml, in the method generate_index, just move the line 'bs b "\n";' 3 lines downwards.

0004675: Compiler fails to warn about pattern Top _ when Top is a 0-ary constructor

# type t = Top | Base of int ;;
type t = Top | Base of int
# let f x = match x with Base _ -> 0 | Top _ -> 1 ;;

Résultat obtenu :
val f : t -> int =

Résultat attendu :
Error: The constructor Top expects 0 argument(s),
but is here applied to 1 argument(s)

0004911: weird behaviour of underscore in pattern matching

Hello,

The following code compiles nicely with 3.11.

type t = X
let f = function X _ -> ()

It looks like a bug.

Regards,
--
Frédéric Besson

0004873: .mltop and "thread" tag

'ocamlbuild target.top' ignores "thread" tag, and so one needs to manually specify missing options.
Consider:

$ cat q.ml
let test () = Thread.delay 1.0
$ cat _tags
true: thread, use_unix
$ cat q.mltop
Q
$ ocamlbuild q.byte
Finished, 3 targets (0 cached) in 00:00:00.
$ ocamlbuild q.top
+ /usr/bin/ocamlmktop unix.cma q.cmo -o q.top
File "_none_", line 1, characters 0-1:
Error: Error while linking q.cmo:
Reference to undefined global `Thread'
Command exited with code 2.
$ ocamlbuild -cflags -thread -lflags -thread -libs unix,threads q.top
Finished, 3 targets (2 cached) in 00:00:00.

0004908: Requesting unsinged types

It would be nice if ocaml had types uint, uint32 and uin64. The later two should be trivial to add. The uint is more tricky but just an UInt module (like Int32) with compiler primitives would suffice for a start.

0004896: ocamlbuild should pass -I to ocamldoc for external libraries

Looks like ocamlbuild doesn't pass include directories to ocamldoc when building documentation referencing external libraries.

Workaround -- add the -I flag manually :
flag ["ocaml"; "doc"; "use_extLib"] (S[A"-I"; A "+extlib"]);

0004907: Type manifests do not support type variable substitutions

The following would seem like a perfectly legitimate thing to do:

type ('a, 'b) t = { a : 'a; b : 'b }
type ('a, 'b) u = ('a, 'b option) t = { a : 'a; b : 'b option }

Unfortunately, the compiler fails with:

File "foo.ml", line 3, characters 5-63:
Error: The variant or record definition does not match that of type
('a, 'b option) t

This does not quite seem correct.

This restriction makes it impossible to e.g. repeat a type definition in a more specialized way such that the preprocessor can exploit the extra syntactic representation to generate code more flexibly from the type definition.

0004905: It takes a long time to compile deeply-nested polymorphic variant type declaration.

The following source (which contains only type declarations) takes a long time to be compiled.

type 'a t01 = [ `c01 of 'a ]
type 'a t02 = [ 'a t01 | `c02 of 'a t02 ]
type 'a t03 = [ 'a t02 | `c03 of 'a t03 ]
type 'a t04 = [ 'a t03 | `c04 of 'a t04 ]
type 'a t05 = [ 'a t04 | `c05 of 'a t05 ]
type 'a t06 = [ 'a t05 | `c06 of 'a t06 ]
...
type 'a t16 = [ 'a t15 | `c16 of 'a t16 ]

The compilation time is exponential to the number of declaration.
It takes twice time when adding one more declaration.
We have no problem
- if we use normal variants instead of polymorphic variant, or
- if we do not use type variable.

0004904: Warn about repeated function arguments especially for optional arguments

If this feature is implemented, the warning should be on by default.

# let f ?(a=0) b ?(a=0) c = a+b+c;;
val f : ?a:int -> int -> ?a:int -> int -> int =
# f ~a:7 1 2;;
- : int = 3

0004903: Allow "let module ... in" in class definitions.

It would be useful to allow local binding of modules (let module M = ... in )
within class definitions:

class o x =
let module M = (val x : S) in
...

0004899: Recursive module types

It is not possible to refer to a module type inside its definition, an Unbound_modtype error is thrown.