Im sorry for the bad title but I just don't know how to put this in the title, so if you do, please remove this line and update the title.
So Im trying to create a portable version of cmake (that doesnt needs admin rights) and I found this but the awnser only helped me getting cmake itself in a different location. Cmake also needs MSVS's (Microsoft Visual Studio's) Cmake tools to get it to work.
My question is where are these tools located, and can I copy them to a USB stick and make it so cmake uses the tools on the usb stick?
I thought that maybe I could make a batch file that sets a local variable to the tools on the usb stick and then start cmake so cmake knows where the tools are located, but I don't know if cmake even uses Environment Variables.
Any help would be greatly appreaciated, thanks
There are multiple points in your question that are unclear.
Portable CMake
With downloading the ZIP file of CMake you already "made CMake portable". Just unzip and run it.
CMake has an internal logic to detect installed Visual Studio versions and the compiler.
CMake Variants
Original
To use CMake with the MSVC compiler (or provided by Visual Studio) you do not need anything special from MSVC/VS. CMake uses the informations of the detected MSVC/Visual Studio to generate the project files, etc.
Visual Studio's CMake Variant
Visual Studio provides a version of CMake upon installation. To use your portable CMake variant you do not need anything from there.
Force a specific VS Generator
If you have only one Visual Studio installed then CMake will use this. If you have multiple Visual Studios installed normally CMake uses the newest one. In case you want to force a specific Version you can specifiy the CMake generator to use cmake-generators.
Another way would be to use the vcvarsall.bat or vsdevcmd.bat to setup the environment for a specific Visual Studio version and run CMake from that environment.
Finally
It is sufficient to have the original CMake release (from the ZIP file) on your USB stick. But it is not possible to provide a portable MSVC (Microsoft Visual Compiler) on your USB stick (as far as I know) as it has to be installed.
Related
So I am trying to build a basic C++ project on our university Linux server.
I went and checked the CMake version on the server, it is 2.8.12.2
I love using Visual Studio, so i tried using Visual Studio after SSH into my university server to build a basic hello world program on it.
I got the following message in my Visual Studio 2017:
CMake 3.8.x or above is not available on the remote system. See https://aka.ms/linuxcmakeconfig for more info
Is there a way to forcibly make Visual Studio accept a lower version of CMake 2.8.12.2
I made changes to the CMakeLists.txt as follows:
cmake_minimum_required(VERSION 2.8.12.2).
But still Visual Studio was complaining about not having CMake version 3.8 in the University server.
I've attached the screen shots below:
I was told to use some IDE called CLion. But I know Visual Studio is the better option, having used it all my life in the real world/non-university setting.
TL;DR
No, it's not possible.
Reason
The Visual Studio 2017 documentation states here:
The CMake support in Visual Studio requires server mode support introduced in CMake 3.8.
This means VS requires the cmake-server(7) API to query information like where CMake puts the built binaries, what include paths are used, etc. Without this information, VS would not be able to provide all the useful features of an IDE such as debugging, include path checks/auto-completion, etc. So there is no way, the CMake integration of VS (or any other IDE like CLion) is going to work with an CMake version that does not provide the server mode yet, which is definitely the case for all 2.x versions.
More Background
The server mode was actually introduced in CMake 3.7. I don't know why the VS docs suggest it's 3.8 🤷♂️. But I guess that's not an important difference for your case anyway.
Newer versions of Visual Studio (since 2019) even use the more recent cmake-file-api(7) introduced in CMake 3.14 as stated here:
Cmake version 3.14 or later should be installed on the target machine.
The server mode was even deprecated in 3.15 and completely removed in 3.20 in favor of the file-based API.
The VS devs even maintain their own CMake fork: github.com/microsoft/CMake.
This is because the server mode didn't provide them all the information they needed, as stated in their blog:
One of the differences in our CMake fork on github was the backtrace information needed for our Targets View feature inside Visual Studio. Prior to CMake 3.14 we needed the CMake version from our fork, in order for Targets View to work properly. Now, with the file-based API this is no longer required.
So maybe with VS 2017 you should use a CMake binary built by Microsoft. For VS 2019+ the "stock" CMake should probably be fine. As of now, they still maintain their fork, but I haven't found any source that indicates you're required to use it. Probably because Microsoft has become more involved in the CMake development the last couple of years and contributes to the upstream repository as well, e.g. cmake-presets(7) is the result of a cooperation between Microsoft and Kitware.
Recommended Solution
As #Shawn already commented, CMake 2.8.12 is seriously outdated (released 2013-10-08) and the best solution would be to ask the admin of your University to update CMake to a more recent version. This has the additional advantage, that you can use and benefit from the "Modern CMake" techniques.
I need to build a dependency that uses SCons, and I need to build it with VC++2017, because another dependency I have cannot be built with VC++2019.
SCons successfully detects VC++2019 (v14.2), but not VC++2017 (v14.1):
c:\Python27\Scripts\scons [...] --msvc-version=14.1 [...]
scons: Reading SConscript files ...
scons version: 3.1.1
python version: 2 7 13 'final' 0
scons: warning: VC version 14.1 not installed. C/C++ compilers are most likely not set correctly.
Installed versions are: ['14.2', '14.0', '11.0']
[...]
C++ compiler $CC does not work
I have installed Visual Studio 2019 Enterprise as well as Visual Studio 2019 Build Tools, and for both, I have installed the platform tools / compiler for v14.1 and x86/x64. Compiling with the VC++2017 platform tools works fine in Visual Studio 2019 as well as using MSBuild, so the problem seems to be with SCons only.
How does SCons detect VC++2017 and VC++2019 and where should I start looking for the problem?
(There are old threads about this, but most of them are about people wondering why the "classic" detection/config methods using registry and vcvars.bat no longer work, so these are not helpful)
For current scons, it will believe what it gets back from vswhere.exe for the versions where that tool is considered definitive - 2017 and 2019. You can try seeing what that gives you.
vswhere -products * -property installationPath
That information is used to help locate the desired vars.bat file which imports the seetings needed.
I have found a perfect and simple solution:
Open file MSCommon/vc.py, find line: vc_pdir = os.path.join(vsdir[0], 'VC')
Change [0] to [1]
Re-build, the python will use vs2017
The reason is: if you install multi vs versions, the vsdir[0] is the highest one
Update: This is still (2021-09-16) an issue, and a simple workaround may be this answer - My answer also has a workaround, but it is more complicated and mostly for educational purposes on how recent versions of VC++ compilers can be detected and are (not properly) detected by SCons. You may also want to use my workaround if you are creating a build script for a build server or multiple development machines with varying setups.
The current version of SCons does not support selecting MSVC v14.1 (aka "Visual C++ 2017") if Visual Studio 2019 is installed, but Visual Studio 2017 is not. I confirmed this by looking at the code of SCons (see below).
An alternative approach is to use the --msvc-script option instead of --msvc-version.
In the MSVC installation folder, typically c:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Auxiliary\Build\, you will find a file called vcvarsall.bat. If you run this without arguments, you will see that you can give it arguments for target platform and tools version, e.g.,
vcvarsall.bat x86 10.0.17763.0 -vcvars_ver=14.1
to compile for x86 (32-bit), Windows SDK version 10.0.17763.0 and tools version 14.1 (Visual C++ 2017).
Once you have found a command line for vcvarsall.bat that suits you, put it into a new BAT file that you create, say myvcconfig.bat (You have to use the complete path to vcvarsall.bat), then use the following command-line switch to SCons: --msvc-script=myvcconfig.bat.
*** Notes ***
Some parameters to SCons are redundant and will not work with --msvc-script, for example --32. SCons will tell you about them, so just remove them from the command-line.
The installation path of Visual Studio may be different from the one I provided above. You can find the installation path using Microsoft's own VSWhere tool. See also Locate Visual Studio
Visual Studio 2019 and Visual Studio Build Tools 2019 are separate installations with separate build tools. You can detect and use the vcvarsall.bat files of either ones. For example, if you are setting up a toolchain for a build server, you may want to use Visual Studio Build Tools 2019. If you just want to build one library one time (as in my case), just use the Visual Studio that is installed on your dev machine.
In case you are interested in how SCons detects MSVC and why it doesn't work, you can look at the source code in SCons/Tool/MSCommon/vc.py. You can clone the SCons GIT repository.
UPDATE: The following comment in vc.py (as of 2021-09-16) shows why this is still an issue in SCons and why this workaround is needed if you have both VC2017 and VC2019 compilers installed:
# make sure the cl.exe exists meaning the tool is installed
if ver_num > 14:
# 2017 and newer allowed multiple versions of the VC toolset to be
# installed at the same time. This changes the layout.
# Just get the default tool version for now
#TODO: support setting a specific minor VC version
Direct link (valid at time of writing)
How can I force Cmake to use Visual Studio 2010 for compiling my emscripten projects, and now VS 2015?
I keep running into an issue where cmake says it cannot find the build tools for MSBuild v140. I know it exists though, as the file path is
C:\Program Files (x86)\MSBuild\14.0\Bin
I've even tried setting the path in the Emscripten Command Prompt with
set PATH=C:\Program Files (x86)\MSBuild\14.0\Bin;%PATH%
but the issue still occurs.
If I open this solution in VS 2015, I can see that the configuration is set to Msbuild v 1.40, so I can't wrap my head around why Emscripten says it can't locate it.
The closest thing I could find is in this GitHub bug report on Emscripten.
Any suggestions?
Emscripten in Visual Studio is only supported for VS2010 AFAIK. Personally, I suggest you work with makefiles when generating from CMake. It is much more stable from my experience. The Visual Studio support for Emscripten is not working well, at least for me.
But if you still want to use VS2010, then you have to set the CMake generator to "Visual Studio 10 2010", and then specify the Emscripten toolchain file. You might have to set the CMake platform name to Emscripten, using the -A argument.
cmake.exe -G "Visual Studio 10 2010" -A Emscripten -DCMAKE_TOOLCHAIN_FILE=%EMSCRIPTEN%\cmake\Modules\Platform\Emscripten.cmake
I tried doing this, but each time I did, Emscripten would return a different path to Emscripten.cmake, and say it couldn't find it. Not sure where it was getting this new path from.
Long story short, I realized I installed the web installer for Emscripten installed. So I uninstalled that and instead went with the Full installer, and it all worked well.
I'm trying to compile, on Windows 10, a C++ project that is using C++14 features such as std::make_unique<> and things like that.
I'd like to be able to compile easily in command line, using CMake and make and then be able to run my program from any command line or just by clicking it's executable.
Compiling using Cygwin, even if it's indeed working (I used this tutorial), is not an option since the resulting executable won't be usable outside of the Cygwin environment due to missing DLLs.
I've read about MinGW-w64, but it seems like the latest available version for Windows corresponds to GCC 4.8.3.
Same goes for the MinGW installer mingw-get-setup.exe available here, wich only allows me to install the 4.8.1-4 version.
So I'd like to have a procedure on how to compile a C++14 project using CMake, and that will allow me to launch the executable in the default Windows environment.
Thanks.
Update : Chris Drew commented that I could use the latest Visual Studio version to build my project using the Visual C++ compiler instead of GCC. I detailed the workflow in my answer, but I'm still looking for a "GNU-style" way to compile it.
"GNU-style" : Use the link provided in Tive's comment to install a working GCC 5.1 environment and use the normal cmake . -G"Unix Makefiles" && make commands.
See this answer for more details on both solutions.
Using Visual Studio compiler
Following Chris Drew comment, here's what I did in order to compile using CMake to generate a Visual Studio 2015 solution and compile this solution in command line.
Note that this is not using the GNU toolchain as we won't be using gcc / make but the Visual C++ Compiler.
Creating and moving to a build subdirectory (it's recommended since it will generate a lot of files, instead of just a standard Makefile) :
mkdir build && cd build
Generating the Visual Studio 2015 solution :
cmake . -G"Visual Studio 14 2015"
This will generate several project files including YourProjectName.sln that we will use to build the project using the following command :
msbuild YourProjectName.sln
Note that msbuild was not in my PATH, so I had to provide the complete path to the executable wich was, in my case, C:\Program Files (x86)\MSBuild\14.0\Bin\MSBuild.exe.
Using an updated MinGW installer
Tive provided a link to a bundled installer that will automatically install GCC 5.1 on your system, this way you can use the normal GNU toolchain by generating an Unix Makefile, and using the make command.
Note that you will need to edit your PATH manually as the installer is not doing it for you.
I want to compile opencv with visual studio, so the code of opencv will be on my computer like all other local code. i.e. i want to be able to change it and debug it.
I can't find anywhere a simple directory file with all the opencv files. It is segmented into include files, modules and similar.
All explanations in the opencv documentations use CMake.
I don't understand what exactly is CMake and why would I need it in order to compile the library locally just like all other regular code.
Can anybody explain me how to do this?
cmake is an platform independent makefile. You can generate from cmake also visual studio projects, which can than imported into visual studio. But you need to install cmake on your computer.
To make a visual studio project call cmake like this:
cmake -G "Visual Studio 9 2008"
Cmake Wiki