How can I build a Qt6 application for Buildroot ? I tried a lot to build Qt6 for Buildroot but I was unable to built it.
Qt6 support was not added to Buildroot yet. However, an RFC series was posted some time ago. Feel free to try it out, comment on it, or improve it and re-post.
The actual question:
Does qmake support custom targets with different compilers (without using different qmake commands)? I am not planning to use the Qt library at all, only qmake for building.
Some background Information:
I have an existing project for which I am interested in changing the build process - we currently have an absolutely massive makefile which is... less than ideal for the situation. It worked great a couple years ago when we had no shared code.
We now share code between a Qt application and the project I mentioned earlier. As such, I believe switching to pro and pri files would be much cleaner and more maintainable than what we have now.
Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
Closed 8 years ago.
This question appears to be off-topic because it lacks sufficient information to diagnose the problem. Describe your problem in more detail or include a minimal example in the question itself.
Questions concerning problems with code you've written must describe the specific problem — and include valid code to reproduce it — in the question itself. See SSCCE.org for guidance.
Improve this question
I've got a project using Qt 5.0.2, and my OS is Windows 7 32 bit.
I am working on big project from months and I didn't had any problems with it to now.One of my dialogs, is Print Preview Dialog and the other dialog contains SSN calculation algorithms with line edit. When I put the project on Debug Mode, my Print Preview Dialog works great, I can print everything that I want, but when I start typing something in the SSN line edit, the program total crashes. And reverse, when I put Release Mode, SSN works fine, but when I do click on the "Print" button in the Print Preview Dialog, my program crashes again. Today, I tried to put in some other objects like (buttons, line edits, etc), but the program does not recognize them.For example when I write ui-> ... and I don't get the new objects.
I think that I need to download and install the newest version of Qt (5.1.1), but I don't know, could I change my Project version easy. I am afraid, that nothing will work after this new version install. Please tell me what to do. Should I install the newest version, cause I can't continue my Project.
Qt != Qt Creator. The creator is just the IDE. Qt is the framework you're using. Please don't confuse everyone by using the two terms interchangeably.
It's trivial to build your project for multiple Qt versions, even for Qt 4 and Qt 5. Qt Creator supports an arbitrary number of Qt installations. You can select what you're building for in the Projects pane of Creator. You can then build for whichever kit. Before you do that,
set up the newly downloaded version of Qt in Creator
set up a kit using that Qt version; The kit is a combination of Qt version, compiler, target environment (Desktop in your case), etc.
Most likely you have memory bugs in your program. The usual suspect is double destruction of objects caused by giving an automatic (on-the-stack) QObject/QWidget a parent. You can use Valgrind on Linux to find such issues.
To be sure of what's going on, delete the build directory and rebuild your project.
Qt Creator version is mostly irrelevant in this discussion. Qt 5.1.1 binaries coincidentally come with Qt Creator 2.8.1, that's just for your convenience. It doesn't mean you can only use creator 2.8.1 with Qt 5.1.1. I'm using it with both Qt 4.8 and Qt 5.1.
I recently read a lot of opinions on whether or not one should use an IDE or the unix toolchain to develop c++ programs. One thing I was asking myself is if you can somehow follow symbols in gvim or any editor that you like. This is one feature I use in Visual Studio or Eclipse a lot.
Or put in another way. Assume you browse some foreign code and you spot an unknown function name. How do you find out from which library it comes without manually searching all the includes?
Here are two popular tools for finding symbols.
ctags
cscope
I believe emacs and vim both have support for those two tools.
Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
Questions asking us to recommend or find a tool, library or favorite off-site resource are off-topic for Stack Overflow as they tend to attract opinionated answers and spam. Instead, describe the problem and what has been done so far to solve it.
Closed 9 years ago.
Improve this question
A few years ago I looked into using some build system that isnt Make, and tools like CMake and SCons seemed pretty primitive. I'd like to find out if the situation has improved. So, under the following criteria, what is currently the best build tool:
platform agnostic: should work on windows, linux, mac
language agnostic: should have built-in support for common things like building C/C++ and other static langs. I guess it doesn't need to support the full autotools suite.
extensible: I need to be able to write rules to generate files, like from restructuredText, latex, custom formats, etc. I dont really care what language I have to write the rules in, but I would prefer a real language rather than a DSL.
I would prefer to avoid writing any XML by hand, which I think for example ant requires.
Freely available (preferably open source)
The term "best" is slightly subjective, but I think answers can be rated objectively by the criteria above.
I'd definitively put my vote up for premake. Although it is not as powerful as it's older brothers, it's main advantage is absurd simplicity and ease of use. Makes writing multi-compiler, multi-platform code a breeze, and natively generates Visual Studio solutions, XCode projects, Makefiles, and others, without any additional work needed.
So, judging purely by the criteria set forth in the question, the build system that seems like the best fit is probably waf - pure Python, provides support for C++ and other languages, general, powerful, not a DSL.
However, from my personal experience, I prefer CMake for C++ projects. (I tried CMake, SCons, and waf, and liked them in roughly that order). CMake is a general solution, but it has built-in support for C++ that makes it nicer than a more generic solution when you're actually doing C++.
CMake's build model for C++ is more declarative and less imperative, and thus, to me, easier to use. The CMake language syntax isn't great, but a declarative build with odd syntax beats an imperative build in Python. Of the three, CMake also seems to have the best support for "advanced" things like precompiled headers. Setting up precompiled headers reduced my rebuild time by about 70%.
Other pluses for CMake include decent documentation and a sizable community. Many open source libraries have CMake build files either in-tree or provided by the CMake community. There are major projects that already use CMake (OGRE comes to mind), and other major projects, like Boost and LLVM, are in the process of moving to CMake.
Part of the issue I found when experimenting with build systems is that I was trying to build a NPAPI plugin on OS X, and it turns out that very few build systems are set up to give XCode the exact combination of flags required to do so. CMake, recognizing that XCode is a complex and moving target, provides a hook for manually setting commands in generated XCode projects (and Visual Studio, I think). This is Very Smart as far as I'm concerned.
Whether you're building a library or an application may also determine which build system is best. Boost still uses a jam-based system, in part because it provides the most comprehensive support for managing build types that are more complex than "Debug" and "Release." Most boost libraries have five or six different versions, especially on Windows, anticipating people needing compatible libraries that link against different versions of the CRT.
I didn't have any problems with CMake on Windows, but of course your mileage may vary. There's a decent GUI for setting up build dependencies, though it's clunky to use for rebuilds. Luckily there's also a command-line client. What I've settled on so far is to have a thin wrapper Makefile that invokes CMake from an objdir; CMake then generates Makefiles in the objdir, and the original Makefile uses them to do the build. This ensures that people don't accidentally invoke CMake from the source directory and clutter up their repository. Combined with MinGW, this "CMake sandwich" provides a remarkably consistent cross-platform build experience!
Of course that depends on what your priorities are. If you are looking primarily for ease of use, there are at least two new build systems that hook into the filesystem to automatically track dependencies in a language agnostic fashion.
One is tup:
http://gittup.org/tup/
and the other is fabricate:
http://code.google.com/p/fabricate/
The one that seems to be the best performing, portable, and mature (and the one I have actually used) is tup. The guy who wrote it even maintains a toy linux distro where everything is a git submodule, and everything (including the kernel) is build with tup. From what I've read about the kernel's build system, this is quite an accomplishment.
Also, Tup cleans up old targets and other cruft, and can automatically maintain your .gitignore files. The result is that it becomes trivial to experiment with the layout and names of your targets, and you can confidently jump between git revisions without rebuilding everything. It's written in C.
If you know haskell and are looking for something for very advanced use cases, check out shake:
http://community.haskell.org/~ndm/shake/
Update: I haven't tried it, but this new "buildsome" tool also hooks into the filesystem, and was inspired by tup, so is relevant:
https://github.com/ElastiLotem/buildsome
CMake
CMake is an extensible, open-source
system that manages the build process
in an operating system and in a
compiler-independent manner.
Gradle seems to match all the criteria mentioned above.
It's a build system which took the best of Maven and Ant combined. To me, that's the best.
The Selenium project is moving over to Rake, not because its the best but because it handles multiple languages slightly better than all the other build tools and is cross platform (developed in Ruby).
All build tools have their issues and people learn to live with them. Something that runs on the JVM tends to be really good for building apps so Ant, Maven (i know its hideous), Ivy, Rake
Final Builder is well known in Windows world
smooth build matches most of your requirements.
platform agnostic: yes, it's written in java
language agnostic: it doesn't support c/c++t yet, only java but it is extensible via plugins written in java so adding more compilers support is not a problem
extensible: yes, you can implement smooth function via java plugin, you can also create smooth function via defining it as expression built of other smooth functions.
I would prefer to avoid writing any XML: you won't see a single line of it in smooth build
Freely available: yes, Apache 2 license
disclosure: I'm the author of smooth build.