If you are interested in the programming language D, the attachment contains whatever one needs to use Allegro from D.

From those who don't know, D is a new programming language which combines the best parts of C/C++ and Java. It can be found here:

www.digitalmars.com

... attachment?

It seems that it was eaten. Was it too large (758K) ? anyway, i am reposting it.

EDIT: indeed, too large. I've taken out the Allegro help and alleg40.dll (I wanted it to be complete for the D guys to download). Anyway, I hope it is ok now (83K).

It may be helpful to include a small bullet point list of how to set up the D environment, a simple Allegro hello world program, and a batch file that compiles it.

Ok, here it is:

1) download the D compiler for WIN32 from here:

ftp://ftp.digitalmars.com/dmd.zip

2) download the D linker and utilities:

ftp://ftp.digitalmars.com/dmc.zip

3) unzip both packages at c:\.

4) download and install the D ide "DIDE" from here:

http://www.atari-soldiers.com/dide.html

5) set DIDE option Settings/DIDE settings/General Settings/DMD path to "C:\dmd\bin"

6) create a new project (option File/New Project). A hello world program will be created for you.

7) press F5 to compile and run the program.

8) read the D documentation from:

C:\dmd\html\d\index.html

Which improvements may I get from learning and using D instead of C?

You get to be a leet D-Dude?

-garbage collection
-no separation between header and implementation
-standard sizes of data types across different architectures
-no include files; uses import instead; results in much faster compiles
-templates and template specialization, either partial or complete (VC++ does not handle this correctly)
-class properties
-threads and synchronization
-unit tests
-design by contract
-asm
-direct interfacing to C
-no ->
-no ; after structs/classes

and lots of other things...

Generally, this language the best points of C/C++ and the best points of Java. You can code right to the metal, or as high level as Java.

Yeah. Except for that pesky memory management. No coding "right to the metal" there

Wait... since when does C/C++ not support assembly? Either inline or at link time?

Speaking of which, how does C++ (let alone C itself) not offer "direct interfacing to C"?

What's "design by contract" supposed to be, by the way?

I hope axilmar doesn't get scared off, these are good questions. One of the problems with java is loading a binary file and mapping it to a struct; you can't do it. You have to load a byte array then step thru it and extract an int here, a float there etc... makes loading an MD2 file a pain the ass. So how does D deal with that?

Design by contract allows you to check the in and out values of a method. You could for example specify that a certain parameter has to be in a certain range, and that values returned have to be in another range.

If this is a language feature, automated testing gets way more easy, since the test routine can use the provided info to create test cases.
It's also some sort of additional documentation.

It's comparable to assert() on all invalid values for your function parameters in c - and then assert on your return values as well.
With the difference that the code to do this is created by the compiler.

I've read it. It's similar to what the Eiffel language offers. You can implicitly define precondition, postconditions and bucle invariants. Preconditions and postconditions are inherited from the base class when you override a function. This info is also used by the compiler to make optimizations (lets say you say in the pre that the parameter i will be positive, maybe that leads to some optimization in some part of the code).

The tests to the pre/posts and invariants are also verified in debug builds, so they also act as ASSERT.

Here's a simple example in Eiffel:

set_type(type: INTEGER) is
require
  type = type_generic or
  type = type_terminal or
  type = type_out
do
  type_part := tipo;
ensure
  type_part = tipo
end

[edit]
It may seem that the last check is stupid. But it's not. If someone inherits from the class this method is in, that postcondition must be true also for the inherited class.

Name mangling.

extern "C" {
...
}

You have direct control of the garbage collector: you can remove objects from garbage collection anytime. You can also delete objects as in C/C++, manually, or overload the new and delete operations for custom memory management.

Most C/C++ compilers do, but with D you have it right there as standard, and there is no variation in syntax between Linux and Windows.

Not at all. My first reaction was "bah, C++ rules, I don't need another language". After a couple of weeks with D, I am at "C++ ? what C++ ?" :-)

D provides unions and structs exactly like in C/C++, so you can load data and map them to structs directly. It also provides for user-controlled alignment of members.

Another benefit of the compiler handling contracts is that all those checks can be removed by a compiler switch.

This comment is mainly aimed at Java, which can't do direct interfacing. This makes it difficult to use already existing code written with C. With D, it's a child's play.

Nor is there with C.
There is difference in how things are handled by different compilers, but I can use the same inline assembler in Linux as in Windows.
I don't think it's much of a feature of a high-level language to have a standard way to inline assembler though, since assembler is by its very nature not portable and part of the rationale for using a high-level language is to hide the hardware specifics.

Since assert isa a macro, this is true of C asserts as well. Not saying it's not a nifty language feature though.

I had a look at it, and it seems to be pretty neat. Not sure if I'm going to use it as my new language of choice, but I'll play with it a couple of weekends... it's a slick language.

Doesn't the GNU compiler use asm (no underscore?). MSVC uses _asm. And they both use different syntaxes (GNU is AT&T, MSVC is Intel).

Or are you comparing the two ports of the GNU compiler? In which case, I assume you'd be right.

Well, maybe it's whatever you want it to be. You could write very high level stuff, and have your renderer use very low level stuff, without having to use another language (excluding assembler, if you want it.) Leaving it up to smart people to make smart decisions, instead of forcing you do it their way. The one free of "potental" problems.

Yes. The difference between GCC and MSVC is just that, a difference between compilers, not platforms. The same inline code works in DOS, Windows and Linux, using gcc.