Morning all..

I just wondered if it was possible to obtain NMAKE for use with MASM for free, or is it part of Hutch's package ?

I have the original MASM 6.11 for dos and the old 16-bit nmake, i just wondered if i can get hold of the 32-bit version for my growing win32 projects

Thanks for help

:alright:
Posted on 2002-07-22 02:55:42 by CodeBug
http://download.microsoft.com/download/vc15/Patch/1.52/W95/EN-US/Nmake15.exe

Dunno if it is the newest version... at least, it's a PE and no NE file ;)
If you search on MSDN, you may find a newer Version.

http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vcug98/html/_asug_overview.3a_.nmake_reference.asp

Edit: If you find a newer Version, please post the Url here. Maybe hutch can make it part of Masm32v8 ;)
Posted on 2002-07-22 03:12:13 by bazik
As a matter of fact I abandoned nmake files in about 1992 as it was a pain to use and was no better than batch files which i consider more flexible and more powerful.

The other problem is it is not licenced the same way as the win98ddk that ML.EXE and LINK.EXE came from so I doubt that it can be included in a Licenced freeware package.

Regards,

hutch@movsd.com
Posted on 2002-07-22 09:10:42 by hutch--


The other problem is it is not licenced the same way as the win98ddk that ML.EXE and LINK.EXE came from so I doubt that it can be included in a Licenced freeware package.


I just remembered, that there comes a freeware nmake clone with the Windows Version of GCC, "MingW" :)
Steve, maybe you should open a poll with some points what you could include in MASM32v8. Some may
need nmake, some don't (and some switch to FASM :tongue: )
Posted on 2002-07-22 09:15:01 by bazik

As a matter of fact I abandoned nmake files in about 1992 as it was a pain to use
and was no better than batch files which i consider more flexible and more powerful.

Depends on your needs. If you're working on large projects with a few hundred files
or so, makefiles are definitely both more comfortable, powerful and flexible than
batch files. It's not as simple to write a (good) makefile as it is to write a batch
file, but there's a certain treshold where both setup and management becomes a *LOT*
simpler with makefiles than with batch files. Makefiles also has the advantage of
only rebuilding a source module if it (or one of its dependencies) has been changed;
something that doesn't matter much if you only have a handful of source files, but
certainly does matter if you have a couple hundred of them. No, this isn't only for
highlevel projects, Peter Quiring's QLIB (libc + more for 32bit dos development,
with a whole bunch of asm code) had ~90 asm files and only around 25 c/cpp files,
but rebuilds would have been slow if it hadn't used makefiles.

These days I don't really mess with makefiles though, using an integrated IDE is
easier tan manually building the (sometimes complex) makefile rules. And my IDE can
output makefiles, so everything is just fine :)
Posted on 2002-07-22 09:51:02 by f0dder
f0dder,

In the past big projects were done with response files which are far more powerful than make files and can be run directly from batch files.

As is usual, modules are built one at a time so all you normally do is compile the seperate module and then link all of the object modules to build the EXE file.

Automated response files have been around for a long time and are far more flexible than the messy syntax of make files, especially when the only action that effects the speed of the build is the linking process.

I have used the lot and I see no reason to prop up technology as old as nmake when there are better and more flexible way to build big projects.

Regards,

hutch@movsd.com
Posted on 2002-07-22 21:31:39 by hutch--
If you by response file mean "program @arguments", and still say
they are more powerful than makefiles, then I doubt you have ever
worked with very large/complex projects :).

messy syntax of make files? It's not all that bad imo... the annoying
part of makefiles is setting up all the dependencies if you want
everything to work properly. Sure there's better ways, and that is
to use some IDE - but that's really just a graphical way to set up
makefiles + some automated dependency building.

batch files for large projects? :grin:
Posted on 2002-07-23 11:34:52 by f0dder
I thought one of the benefits of using NMAKE ( I personally use MAKE that comes with the free BC++ compiler) is only files that have changed are compiled??

James
Posted on 2002-07-24 07:04:14 by jcfuller

I thought one of the benefits of using NMAKE ( I personally use MAKE that comes with the free BC++ compiler) is only files that have changed are compiled??

Indeed, which is one of the reasons using batch files for large projects is ludicruous.
Posted on 2002-07-24 07:53:57 by f0dder
James,

The virtues of the standard response file format are many including being able to run much larger than command lines size options. You can automate the whole process and just add files into a single directory if you are working with a team who write the different modules.

Having an IDE write them for you is one thing but having to write the damned things is another.

f0dder,

I will excuse your lack of skill in writing batch files because of your age but there are a few basics that even you should be able to grasp, when you LINK a colection of modules into an EXE file, whether it is fed by a response file, an nmake file or a batch file makes no difference in how long it takes LINK to do the work.

Where the difference comes is comprehending the notion of compiling/assembling ONE module at a time. It is simply a nonsense to rebuild every module because of one module and you do not need a clapped out old piece of junk like nmake to do that, just build the single module and link all of the files together.

nmake will not build a single module any faster or better because it and the linker is not incremental, you MUST link the whole lot.

When you are finished with old junk like nmake, try writing libraries, that IS the way to build BIG projects. :tongue:

Regards,

hutch@movsd.com
Posted on 2002-07-24 11:04:55 by hutch--
makefiles automate only rebuildling the modules that have changed.
Manually compiling/assembling only the changed source files isn't
too bad in small projects, or if you only change a few modules at a
time... but when you have large projects and dependencies become
less trivial, good luck with making sure everything that needs
rebuilding is rebuilt... properly done makefiles (or a smart IDE
build system) makes this a lot easier.

Perhaps you should try to be less patronizing; I very well know
how to deal with batch and response files, however I do not limit
myself to this when there are better alternatives.

Libraries, while definitely useful, don't really make the task
easier. They're good for pieces of code that are more or less debugged
and don't change often, but for "dynamic" source code, libraries
just add extra overhead to the build time - and still don't solve
the "only rebuild modified stuff" problem.


nmake will not build a single module any faster or better because it

Of course not, but it makes the build process faster by only rebuildling
modified files. And, once properly set up, a lot simpler than manually
rebuilding modified sources. Sure, makefiles aren't exactly joyful to
write by hand (more joyful than batch files when you reach a certain
project size though), but there are tools that generate makefiles and
are pretty easy to use.


and the linker is not incremental, you MUST link the whole lot.

Depends on whether you use an incremental linker ;). But perhaps you
never heard about those?
Posted on 2002-07-24 13:42:34 by f0dder
Lordy,

My enquiry seems to have started off a whole debate on nmake !!

Anyhow, thanks to bAZiK for pointing me in the right direction to get NMAKE.

My whole reson for wanting nmake is this :

I currently have a .BAT file that assembles then compiles projects, but am I right in thinking each entry in the .BAT file can be no longer than 256 characters ? If so, then this could be a problem if there are many .OBJ files to build into the final .EXE I'm probably wrong about this but that was my line of thought...

I must admit the MAKE file syntax does look a bit daunting, but my Mircosoft 'Enviroment Tools Masm 6.1' book (from a time when MS made good written documentaion) and their MSDN website.. I think I can figure out how to get a simple MAKE file for my needs..

However.. now it has been mentioned an IDE might be better for what I need.. that's something else i could consider.

Thanks to all

Codebug
(A wee fish in a Big C)
Posted on 2002-07-25 03:59:13 by CodeBug
Never mind Codebug, its all part of the learning experience. Have a look at the specs for response files as they remove the problem of command line limitations. Instead of the project main file appearing on the command line, you use @filename.rsp and write the response file as a list of module names. Make sure you put the main file first in the list. Both ML and LINK support response files so there is no limit on the number of modules that you can assembler and link.

f0dder,

Perhaps you should try to be less patronizing; I very well know how to deal with batch and response files, however I do not limit myself to this when there are better alternatives.

There is an expression in English about the POT calling the KETTLE black. :)

Perhaps you miss the dynamics of how batch files can automatically build response files and all you have to do is ADD the next module to the current directory of the batch file and VIOLA, it gets build as well.

You seem to miss the environment that NMAKE came out of, in 1990 nmake was "high tech" project management but this was in a monotasking environment (DOS).

It was left behind with multitasking because you have far more control in a multitasking environment than you had in DOS. Technology as old hat as looking up the build date and time was based on there not being a better way to do it in DOS.

Unless you work on multiple files at a time and cannot keep track of your own project, you normally build one module at a time and then you link the lot. NMAKE will not do this faster but as you add modules to the project, you have to keep rewriting the makefile for it to build properly.

Projects that use a large number of modules profit well from being made into libraries, the obvious is that they ARE precompiled code that does not have to be rebuilt unless they are changed.

Perhaps you are well advised to stick to an automated IDE that does it all for you if you views on project management are so restricted.

Regards,

hutch@movsd.com
Posted on 2002-07-26 11:05:34 by hutch--
*my* views are restricted? Heh. Oh well, I wonder when you last worked on a project
with more than a single person and more than a few dozen source files.

But well, I don't want a stupid flamewar, I just know what works *very* well for
me and my buddies, and batch files are just too limited on their own. Sure, we
use both batch files and response files - but in real-life projects these would be
rather tedious maintaining.
Posted on 2002-07-26 20:21:49 by f0dder
personally, i prefer make file.
Posted on 2002-07-27 07:12:34 by doby