why should this crash allegro ?
it crashes on the free(bitmap) inside of destroy_bitmap()
it says "Damage after normal block"
which sounds like memory corruption.

and yes i know, im requesting 0,0 size bitmap.

WinXP, alg 4.1.20b4 MSVC7.1 (2003 .net)

BITMAP* p = create_bitmap( 0, 0 );
if ( p )
  destroy_bitmap( p );

Try to compile in debug mode.

I.e., there is this at the beginning of the function:

ASSERT(width >= 0);
ASSERT(height > 0);

So when run, your program should exit and point you to the line in the source where the problem happened. Using ASSERT simply is the way Allegro currently uses for runtime errors (instead of making the function fail and set an error code or raise an exception or whatever).

In any case, a 0x0 bitmap is not allowed, which the documentation specifically states: http://alleg.sourceforge.net/onlinedocs/en/alleg009.html#create_bitmap

to make it a bit faster?

I think there should be a way to create bitmaps of 0x0 sizem adding another check shouldn't be so slow that it is only done with debug versions.

allthough this would probably make all image-saving functions a bit more difficult because I'm not sure if the formats even support 0x0 images. Also I think some other functions assume that bitmaps have some image-data with them(e.g 3d rasterizing perhaps)

Why the hell would anyone even try creating 0x0 bitmaps

Now that I thought of it a bit more I came to conclusion that it would probably be a lot easier to add the check to user side code, not in allegro.

really, would adding if ((w<1) || (h<1)){return(NULL);} to the beginning of create_bitmap() slow it down that much?

(it seems that passing in a negative height could cause all sorts of problems!)

Why is there so much resistance to having a library function do some sanity checking, what is the point of a library ?

Why would anyone want to create a zero sized bitmap, can anyone give me an example ?

Until BOTH these questions get answered, the only conclusion i can come too is that some of you are resisting for the sake of it.

allegro is a library, its not an application, it needs to SERVE the applications/programmers needs, not the other way around.

You tell us. It was you who started this thread because you had a problem with that. I have never before heard anyone having the same problem.

Yes, but width should be asserted to be > 0 as well

the problem is, create_bitmap(0,0) returns a valid pointer, that when passed to destroy_bitmap() crashes.
if i have a valid pointer, why does destroy_bitmap() crash ?

What is ASSERT? I agree with AJ, if the library gives lets you create a bitmap, and returns a valid bitmap without errors, why should it crash on destruction?

But, maybe destroy_bitmap() (since that's where it crashes) should be fixed? Since destroy_bitmap usually isn't called until shutdown, and you can always check bmp->w/bmp->h

I wonder, can you blit to/from the 0 sized bitmap? putpixel? If all of the graphics routines crash while using it, then create_bitmap() should return NULL, but if the only problem is destroy_bitmap, then that's where it should be fixed; regardless of why you'd create one, if it lets you create something you should be able to destroy it!

That's part of my point. If it can't create a valid bitmap it should return NULL, not allocate the wrong amount of memory and return an unusable pointer that can't be deallocated via destroy_bitmap. Just b/c there s no apparant use doesn't mean there is absolutley no use.

release build, this causes a crash.

BITMAP* p = create_bitmap(0,0);
if ( NULL != p )
  destroy_bitmap( p );

As we seem to be having some trouble communicating exactly why this is considered OK, can i get a simplified bullet point list of reasons why it is OK for a library to crash destroying objects it made?

Read up on Design by Contract. This is what Allegro implements. It's a perfectly valid and widely used methodology.