This is the mail archive of the mailing list for the Cygwin project.

Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

Re: Kudos

Gershon Kagan wrote:

Do you use make in a GNU emacs X window on both platforms for an
identical build interface?  Do you use gcc on both platforms or MS
Visual C++ ?  How do your makefiles support multiple platforms?

I wrote some templates that generate Makefiles that use make variables
to support the native  compiler on multiple platforms.  I just wanted to
compare approaches.

I use emacs for maintenance work and fixing build problems. The builds are automated, with a status monitoring system that reports on builds in real time to a database server that distributes the information to Java GUI clients, so developers can see whether their build worked and what kinds of errors have been detected.

We use AT&T nmake with native compilers on all platforms (xlC on AIX,
cc/aCC on HPUX, cc/CC on SUNOS, msvc++ 5/6 on Windows).  AT&T nmake is
vastly superior to GNU make feature-wise.  I think it was originally
written for performance reasons, to reduce the AT&T 5ESS switch build
times, which were taking several days back in the 80's.

The cross-platform abilities are a major reason we use it -- we use
the same ksh build scripts and same makefiles on all machines.  There are
some conditionals for platform tests, but it is minimal because of the
rule set we have running on top of the nmake engine (we don't use
the rule set that comes with nmake).  Basically, we developed a set
of functions that get used in the makefiles.  Like this:

temp.exe :make: file1.c file2.cpp libwhatever.a

The :make: function takes care of filename translation (libwhatever.a
becomes libewhatever.lib on a Windows box) and generation of all the
make rules and shell command blocks to generate temp.exe, build lint
for it, export it into an export area, etc.  If we want to add something,
we just change :make: in the master rules file and don't have to touch
the makefiles.

Parallel build performance is another reason we use it.  GNU make can
do parallel builds, but it does not have any mutual exclusion capabilities
built in for rules that conflict with one another -- nmake does.
Then there's automatic header file scanning, compiled makefiles (for speed),
state retention between builds (also for speed), viewpathing (for multiple
developers working against a shared baseline build), much simplified makefiles,
and probably a few other things that don't occur to me at the moment.
Oh, yes, shell command blocks are just that, blocks -- they are not
executed one line per shell and you don't need those awful \ characters
to continue lines.  Multimachine network builds are supported also,
though we don't use that (yet).
Joe Buehler

-- Unsubscribe info: Bug reporting: Documentation: FAQ:

Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]