Óscar Fuentes wrote:
Chuck Robey <chuckr@telenix.org> writes:
[snip]
Someone said that maybe CMake is already compatible with BSD make, so
I quicly went into one of your Makefiles and took out the first
incompatibility I found. Means ONLY that CMake != BSD Make, that's
all. Looks to me to be a great deal more like GNU Make, isn't that
so?As said on my previous reply to you, the makefiles distributed with LLVM
are not related to CMake.[snip]
My own feeling is that adding in the ability to generate BSD Makefiles
from Cmake files is going to tremendously compllicate the ability to
fix build problems,
I've never asked for (and wouldn't personally contribute to) any project to
generate BSD Makefiles from CMake input. My feelings are, you generate BSD
Makefiles directly, they are NOT that complicated, and making them be generated
like that reduces the simplicity, make troubleshooting more difficult.
Maybe there is a common misunderstanding here. CMake is not a build
tool, it is a build generator tool. That means that it competes with the
GNU autotools, for instance, but not with make, or gmake. CMake
generates makefiles (or project files for XCode, Visual Studio, etc) so
it actually requires some other tool (`make' in your case) for the
actual build. This is why I'm suggesting that you should check if CMake
generates makefiles compatible with BSD make, instead of writing (and
maintaining) them yourself. LLVM is a fast moving target: adding, moving
and removing source files and library requirements is common.Ah, and as you may prefer to avoid the autotools, you need a
BSD-specific config.h file, don't you? In principle, CMake can provide
this too.
This last sentence is quite confusing. Further above, you said the build system
isn't CMake, but in this last sentence, you're defending CMake. I can't tell
what you're trying to say here. Is it only that you're saying you are 100%
dedicated to using CMake to generate makefiles? Well, In my own opinion, that
would be like requiring folks to use a code generator tool to create all of your
C++ code. I think that C++ files should be generated directly, and the same
goes for BSD Makefiles. They are very simple things, and adding in levels of
indirection just vastly complicates what should be a simple operation.
The idea that BSD Make is complicated by folks who were too busy to read the
manual which isn't all that hard to understand. Folks who then went out, wrote
their own builds systems which were universally more complex, but since they
were NEW, they had to be better. Even if you needed to have some testing of the
environment inside the makefiles, that's simple to accomplish right inside the
BSD Makefiles, FAR more simple than any autoconf script ever was.
I got told, at first, that all patches were welcome, but since then I've seen
some folks don't want patches. Far be it from me to give patches where they're
not wanted. I CAN say that the Makefiles that CMake is generating for you are
incompatible with BSD Make, and the BSD Makefiles would be hugely more simple
than CMake files, probably needing only the maintenance forced by moving source
file locations around.
I don't really want to continue this anyhow, I wanted to spend more time
learning compilers in general (and llvm in specific), and this is (for me)
offtopic. I ofered this only because I often know more about makefiles that
others. Not always true, of course.
Kinda sad. I can't imagine that this isn't trivial. Doesn't inspire confidence...