Hi, There is a pointer slice code.
It works in win32 mode. but failed in x86_64 arch.

I guess it's a bug?

Here is my code. It's a simple buffer which operate data on rows.
There last test case expect copy from this:
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31]

To get this reverted rows:
[24, 25, 26, 27, 28, 29, 30, 31, 16, 17, 18, 19, 20, 21, 22, 23, 8, 9, 10, 11, 12, 13, 14, 15, 0, 1, 2, 3, 4, 5, 6, 7]

`
module vg.buffer;

import std.math : abs;
import std.algorithm.comparison : min;

class Buffer(T)
{
    T[] buffer;
    uint width;
    uint height;
    T* start; //Pointer to the first pixel, depending on stride
    int stride; //number of bytes per row, can be <0

    void attach(T[] buffer, uint width, uint height, int stride)
    {
        assert(buffer.length == width * height * T.sizeof);
        this.buffer = buffer;
        this.width = width;
        this.height = height;
        this.stride = stride;
        if (stride < 0)
            start = buffer.ptr - (height - 1) * stride;
        else
            start = buffer.ptr;
    }

    @property uint strideAbs() const
    {
        return abs(stride);
    }

    T* rowPointer(int y)
    {
        return cast(T*)(start + y * stride);
    }

    T[] row(int y)
    {
        uint begin = stride < 0 ? cast(uint)(buffer.length + (1 + y) * stride) : y * stride;
        import std.stdio : writefln;

        writefln("begin =%s y=%s length=%s", begin, y, buffer.length);
        return buffer[begin .. begin + width];
    }

    void copyFrom(Buffer!T src)
    {
        uint h = min(height, src.height);
        uint length = min(strideAbs(), src.strideAbs());
        length *= T.sizeof;

        import std.stdio : writefln;

        writefln("byte length %s  buffer: this %s, src %s", length, buffer.ptr, src.buffer.ptr);
        writefln("this start %s end =%s", start, start + length);
        writefln("src start %s, end=%s", src.start, src.start + length);
        uint w = width;
        for (uint y = 0; y < h; y++)
        {
            T* pp1 = this.rowPointer(y);
            T* pp2 = src.rowPointer(y);
//                        still buggy
//                        ubyte* bp1 = pp1;
//                        ubyte* bp2 = pp2;
//                        bp1[0 .. length] = bp2[0 .. length];

            import std.stdio : writeln;

            T[] p1 = this.row(y);
            T[] p2 = src.row(y);

            writefln("this %s == %s??, src: %s", p1.ptr, rowPointer(y), p2.ptr);
            writeln(p1.ptr, " p1=", p1[0 .. w]);
            //here pp1 will produce BUG in arch x86_64
            writeln(pp1); //, " ", pp1[0 .. length]);
            //writeln(pp1, " ", pp1[0 .. length]);
            writeln(p2.ptr, " p2=", p2[0 .. w]);
            pp1[0 .. length] = pp2[0 .. length];
            //rowPointer(y)[0 .. length] = src.rowPointer(y)[0 .. length];
            writeln(p1.ptr, " p1=", p1[0 .. w]);
        }
    }

    void clear(T value)
    {
        buffer[] = value;
    }
}

alias Buffer!ubyte RenderingBuffer;

unittest
{
    RenderingBuffer buffer = new RenderingBuffer;
    ubyte[] array = new ubyte[32];
    array[] = 8;
    buffer.attach(array, 8, 4, -8);

    import std.stdio : writeln;

    writeln(array);
    buffer.clear(3);
    writeln(array);

    ubyte[] a2 = new ubyte[16];
    a2[] = 4;
    buffer.copyFrom(a2);
    writeln(array);

    RenderingBuffer b2 = new RenderingBuffer;
    ubyte[] array2 = array.dup;
    foreach (int i, ref ubyte b; array2)
        b = cast(ubyte) i;

    writeln(array2);
    b2.attach(array2, 8, 4, 8);

    buffer.copyFrom(b2);
    writeln(array);
}
`

BUG point:
 pp1[0 .. length] = pp2[0 .. length];

//or this origin line
rowPointer(y)[0 .. length] = src.rowPointer(y)[0 .. length];

//even later lines
bp1[0 .. length] = bp2[0 .. length];

Cheers
Lyra
_______________________________________________
dmd-internals mailing list
dmd-internals@puremagic.com
http://lists.puremagic.com/mailman/listinfo/dmd-internals