subject:"\[CMake\] Where do all the extra clang flags come from in Xcode\?"

Re: [CMake] Where do all the extra clang flags come from in Xcode?

2015-05-18 Thread Ruslan Baratov via CMake


On 18-May-15 16:50, Parag Chandra wrote:

In other words, these flags might very
well be the same ones you’d see if you were to manually create an Xcode
project via its wizards.


Not exactly. Wizard add some extra attributes:
Xcode 6.2 -> New project -> OSX -> Application -> Command Line Tool

> grep -i warn project.pbxproj
CLANG_WARN_BOOL_CONVERSION = YES;
CLANG_WARN_CONSTANT_CONVERSION = YES;
CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
CLANG_WARN_EMPTY_BODY = YES;
CLANG_WARN_ENUM_CONVERSION = YES;
CLANG_WARN_INT_CONVERSION = YES;
CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
CLANG_WARN_UNREACHABLE_CODE = YES;
CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
GCC_WARN_UNDECLARED_SELECTOR = YES;
GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
GCC_WARN_UNUSED_FUNCTION = YES;
GCC_WARN_UNUSED_VARIABLE = YES;
CLANG_WARN_BOOL_CONVERSION = YES;
CLANG_WARN_CONSTANT_CONVERSION = YES;
CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
CLANG_WARN_EMPTY_BODY = YES;
CLANG_WARN_ENUM_CONVERSION = YES;
CLANG_WARN_INT_CONVERSION = YES;
CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
CLANG_WARN_UNREACHABLE_CODE = YES;
CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
GCC_WARN_UNDECLARED_SELECTOR = YES;
GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
GCC_WARN_UNUSED_FUNCTION = YES;
GCC_WARN_UNUSED_VARIABLE = YES;

However CMake use others:
> cmake -H. -B_builds -GXcode
> grep -i warn project.pbxproj
WARNING_CFLAGS = ("-Wmost", 
"-Wno-four-char-constants", "-Wno-unknown-pragmas", "$(inherited)", );
WARNING_CFLAGS = ("-Wmost", 
"-Wno-four-char-constants", "-Wno-unknown-pragmas", "$(inherited)", );
WARNING_CFLAGS = ("-Wmost", 
"-Wno-four-char-constants", "-Wno-unknown-pragmas", "$(inherited)", );
WARNING_CFLAGS = ("-Wmost", 
"-Wno-four-char-constants", "-Wno-unknown-pragmas", "$(inherited)", );
WARNING_CFLAGS = ("-Wmost", 
"-Wno-four-char-constants", "-Wno-unknown-pragmas", "$(inherited)", );
WARNING_CFLAGS = ("-Wmost", 
"-Wno-four-char-constants", "-Wno-unknown-pragmas", "$(inherited)", );
WARNING_CFLAGS = ("-Wmost", 
"-Wno-four-char-constants", "-Wno-unknown-pragmas", "$(inherited)", );
WARNING_CFLAGS = ("-Wmost", 
"-Wno-four-char-constants", "-Wno-unknown-pragmas", "$(inherited)", );
WARNING_CFLAGS = ("-Wmost", 
"-Wno-four-char-constants", "-Wno-unknown-pragmas", "$(inherited)", );
WARNING_CFLAGS = ("-Wmost", 
"-Wno-four-char-constants", "-Wno-unknown-pragmas", "$(inherited)", );
WARNING_CFLAGS = ("-Wmost", 
"-Wno-four-char-constants", "-Wno-unknown-pragmas", "$(inherited)", );
WARNING_CFLAGS = ("-Wmost", 
"-Wno-four-char-constants", "-Wno-unknown-pragmas", "$(inherited)", );


In CMake case Xcode set missing attributes to default values, some of 
them set to YES, some of them set to NO

--

Powered by www.kitware.com

Please keep messages on-topic and check the CMake FAQ at: 
http://www.cmake.org/Wiki/CMake_FAQ

Kitware offers various services to support the CMake community. For more 
information on each offering, please visit:

CMake Support: http://cmake.org/cmake/help/support.html
CMake Consulting: http://cmake.org/cmake/help/consulting.html
CMake Training Courses: http://cmake.org/cmake/help/training.html

Visit other Kitware open-source projects at 
http://www.kitware.com/opensource/opensource.html

Follow this link to subscribe/unsubscribe:
http://public.kitware.com/mailman/listinfo/cmake

Re: [CMake] Where do all the extra clang flags come from in Xcode?

2015-05-18 Thread Ruslan Baratov via CMake


On 18-May-15 15:20, Paul Smith wrote:

On Mon, 2015-05-18 at 12:32 +0200, Ruslan Baratov via CMake wrote:

This table tells you what attribute you need to set to disable/enable
specific warning.

I see, so these are CMake attributes?  That wasn't clear to me.  I
thought they were attributes of Xcode.
Please take a look at examples I've sent earlier. I have no idea how I 
can make it even more clearer.


I guess my basic question is, why are all these extra flags to disable
and enable various warnings set in the Xcode generator?
As far as I know this is Xcode defaults. So I guess you need to ask 
Apple's Xcode support team.

   I expected it
would work like the makefile generator, where if you don't set any flags
in CMakeLists.txt then you don't get any warnings enabled (or explicitly
disabled).  It surprises me that when I take the same CMakeLists.txt
file and use a Makefile generator and an Xcode generator, I get very
different compile lines.
I guess you can open a bug with feature request. Note that only it's not 
enough to just set all this attributes to YES, but also you need to read 
compiler flags (+ build types) and change attributes accordingly.
E.g. -Wno-enum-conversion in CMAKE_CXX_FLAGS automatically must add 
property `XCODE_ATTRIBUTE_CLANG_WANR_ENUM_CONVERSION NO` to all targets.


And secondarily, is there any way to get the Xcode generator to work
like the Makefile generator, where only the warning flags I explicitly
defined in my CMakeLists.txt file are added to the compile/link lines
and no others?

Again. Take a look at examples I've sent earlier. The helper function 
works exactly like you want. This is the only way known to me to achieve 
this nicely.


Cheer, Ruslo
--

Powered by www.kitware.com

Please keep messages on-topic and check the CMake FAQ at: 
http://www.cmake.org/Wiki/CMake_FAQ

Kitware offers various services to support the CMake community. For more 
information on each offering, please visit:

CMake Support: http://cmake.org/cmake/help/support.html
CMake Consulting: http://cmake.org/cmake/help/consulting.html
CMake Training Courses: http://cmake.org/cmake/help/training.html

Visit other Kitware open-source projects at 
http://www.kitware.com/opensource/opensource.html

Follow this link to subscribe/unsubscribe:
http://public.kitware.com/mailman/listinfo/cmake

Re: [CMake] Where do all the extra clang flags come from in Xcode?

2015-05-18 Thread Andreas Pakulat

Hi Paul,

On Mon, May 18, 2015 at 3:20 PM, Paul Smith  wrote:

> On Mon, 2015-05-18 at 12:32 +0200, Ruslan Baratov via CMake wrote:
> > This table tells you what attribute you need to set to disable/enable
> > specific warning.
>
> I see, so these are CMake attributes?  That wasn't clear to me.  I
> thought they were attributes of Xcode.
>
> I guess my basic question is, why are all these extra flags to disable
> and enable various warnings set in the Xcode generator?  I expected it
> would work like the makefile generator, where if you don't set any flags
> in CMakeLists.txt then you don't get any warnings enabled (or explicitly
> disabled).  It surprises me that when I take the same CMakeLists.txt
> file and use a Makefile generator and an Xcode generator, I get very
> different compile lines.
>

If you look at the foo.xcodeproj contents of a very simple CMake project
(hello-world style) you'll notice just 1 file and there are not a lot of -W
words inside that file either. I see 3 warnings being added by CMake when
generating this file.

That suggests anything else is added by Xcode itself because thats what its
default settings are. Xcode (and xcodebuild) has a lot more logics builtin
that make. Make is essentially just a dependency-tracking and execution
tool and thus cannot make any assumptions about what is being executed when
a target is to be 'made'. It cannot add any compile flags that the
make-developers deem useful, since the action executed for a target may not
be a compile run at all. Xcode on the other hand with its more structured
project file has a very clear idea of what is a compile action and what is
not and apparently the Apple devs think a certain set of flags are useful
for everybody and hence are added to all compiler invocations.

You'll also notice this when creating a new project inside xcode and then
examine and run it outside, i.e. grep for -W flags in the generated files.
There are  literally none, but still xcodebuild shows tons of -W flags
added to the compiler invocation.

> And secondarily, is there any way to get the Xcode generator to work
> like the Makefile generator, where only the warning flags I explicitly
> defined in my CMakeLists.txt file are added to the compile/link lines
> and no others?
> 
>

Given the above, your only options are: propose a patch to cmake (or find
someone to do this for you) that enhances the xcode generator to disable
all flags that are not explicitly enabled so its closer to the makefile
generator. This is however quite a lot of effort upfront and in maintenance
since each new xcode version (even just bugfix versions) may need changes
to the list.

The alternative to that is that you blacklist via the mentioned attributes
the warnings you don't want to have enabled, each and every one of them
individually.

Andreas
-- 

Powered by www.kitware.com

Please keep messages on-topic and check the CMake FAQ at: 
http://www.cmake.org/Wiki/CMake_FAQ

Kitware offers various services to support the CMake community. For more 
information on each offering, please visit:

CMake Support: http://cmake.org/cmake/help/support.html
CMake Consulting: http://cmake.org/cmake/help/consulting.html
CMake Training Courses: http://cmake.org/cmake/help/training.html

Visit other Kitware open-source projects at 
http://www.kitware.com/opensource/opensource.html

Follow this link to subscribe/unsubscribe:
http://public.kitware.com/mailman/listinfo/cmake

Re: [CMake] Where do all the extra clang flags come from in Xcode?

2015-05-18 Thread Parag Chandra

This is just a guess, but I think the reason you’re seeing all these extra 
warnings enabled/disabled when you use Xcode is that Xcode is going to, by 
default, enable many of these warnings when you create a new project, and 
CMake isn’t doing anything special to alter those in order to match up 
with the Makefiles it generates. In other words, these flags might very 
well be the same ones you’d see if you were to manually create an Xcode 
project via its wizards.

So in reference to your last question, I don’t think you’re going to be 
able to just ‘whitelist’ the flags you want enabled. You’ll also have to 
take stock of the default flags Xcode enables and ‘blacklist’ those.


Parag Chandra
Senior Software Engineer, Mobile Team
Mobile: +1.919.824.1410

  

Ionic Security Inc.
1170 Peachtree St. NE STE 400, Atlanta, GA 30309














On 5/18/15, 1:20 PM, "Paul Smith"  wrote:

>On Mon, 2015-05-18 at 12:32 +0200, Ruslan Baratov via CMake wrote:
>> This table tells you what attribute you need to set to disable/enable
>> specific warning.
>
>I see, so these are CMake attributes?  That wasn't clear to me.  I
>thought they were attributes of Xcode.
>
>I guess my basic question is, why are all these extra flags to disable
>and enable various warnings set in the Xcode generator?  I expected it
>would work like the makefile generator, where if you don't set any flags
>in CMakeLists.txt then you don't get any warnings enabled (or explicitly
>disabled).  It surprises me that when I take the same CMakeLists.txt
>file and use a Makefile generator and an Xcode generator, I get very
>different compile lines.
>
>And secondarily, is there any way to get the Xcode generator to work
>like the Makefile generator, where only the warning flags I explicitly
>defined in my CMakeLists.txt file are added to the compile/link lines
>and no others?
>
>-- 
>
>Powered by www.kitware.com
>
>Please keep messages on-topic and check the CMake FAQ at: 
>http://www.cmake.org/Wiki/CMake_FAQ
>
>Kitware offers various services to support the CMake community. For more 
>information on each offering, please visit:
>
>CMake Support: http://cmake.org/cmake/help/support.html
>CMake Consulting: http://cmake.org/cmake/help/consulting.html
>CMake Training Courses: http://cmake.org/cmake/help/training.html
>
>Visit other Kitware open-source projects at 
>http://www.kitware.com/opensource/opensource.html
>
>Follow this link to subscribe/unsubscribe:
>http://public.kitware.com/mailman/listinfo/cmake
-- 

Powered by www.kitware.com

Please keep messages on-topic and check the CMake FAQ at: 
http://www.cmake.org/Wiki/CMake_FAQ

Kitware offers various services to support the CMake community. For more 
information on each offering, please visit:

CMake Support: http://cmake.org/cmake/help/support.html
CMake Consulting: http://cmake.org/cmake/help/consulting.html
CMake Training Courses: http://cmake.org/cmake/help/training.html

Visit other Kitware open-source projects at 
http://www.kitware.com/opensource/opensource.html

Follow this link to subscribe/unsubscribe:
http://public.kitware.com/mailman/listinfo/cmake

Re: [CMake] Where do all the extra clang flags come from in Xcode?

2015-05-18 Thread Paul Smith

On Mon, 2015-05-18 at 12:32 +0200, Ruslan Baratov via CMake wrote:
> This table tells you what attribute you need to set to disable/enable
> specific warning.

I see, so these are CMake attributes?  That wasn't clear to me.  I
thought they were attributes of Xcode.

I guess my basic question is, why are all these extra flags to disable
and enable various warnings set in the Xcode generator?  I expected it
would work like the makefile generator, where if you don't set any flags
in CMakeLists.txt then you don't get any warnings enabled (or explicitly
disabled).  It surprises me that when I take the same CMakeLists.txt
file and use a Makefile generator and an Xcode generator, I get very
different compile lines.

And secondarily, is there any way to get the Xcode generator to work
like the Makefile generator, where only the warning flags I explicitly
defined in my CMakeLists.txt file are added to the compile/link lines
and no others?

-- 

Powered by www.kitware.com

Please keep messages on-topic and check the CMake FAQ at: 
http://www.cmake.org/Wiki/CMake_FAQ

Kitware offers various services to support the CMake community. For more 
information on each offering, please visit:

CMake Support: http://cmake.org/cmake/help/support.html
CMake Consulting: http://cmake.org/cmake/help/consulting.html
CMake Training Courses: http://cmake.org/cmake/help/training.html

Visit other Kitware open-source projects at 
http://www.kitware.com/opensource/opensource.html

Follow this link to subscribe/unsubscribe:
http://public.kitware.com/mailman/listinfo/cmake

Re: [CMake] Where do all the extra clang flags come from in Xcode?

2015-05-18 Thread Ruslan Baratov via CMake

On 18-May-15 06:50, Paul Smith wrote:

On Sun, 2015-05-17 at 14:43 +0200, Ruslan Baratov via CMake wrote:

As far as I know extra flags set by Xcode itself. You can use
XCODE_ATTRIBUTE_* target properties to enable/disable warnings. This
table can be helpful:
https://github.com/ruslo/leathers/wiki/List#xcodeclang-table

Thanks for your reply... but I don't quite understand what this table is
telling me.
This table tells you what attribute you need to set to disable/enable 
specific warning.

E.g.:

   | Clang   | Xcode  |

   +-++

   | enum-conversion | CLANG_WARN_ENUM_CONVERSION |

Makefile generator:

> cat CMakeLists.txt
   cmake_minimum_required(VERSION 3.0)
   project(Foo)
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wenum-conversion")
   add_library(foo foo.cpp)

> cmake -H. -B_builds "-GUnix Makefiles" -DCMAKE_VERBOSE_MAKEFILE=ON
> cmake --build _builds
   /.../usr/bin/c++ -Wenum-conversion ...

Xcode generator (default):

> cat CMakeLists.txt
   cmake_minimum_required(VERSION 3.0)
   project(Foo)
   add_library(foo foo.cpp)

> cmake -H. -B_builds -GXcode
> cmake --build _builds
   /.../usr/bin/clang ... -Wno-enum-conversion ...

Xcode generator (enable):

> cat CMakeLists.txt
   cmake_minimum_required(VERSION 3.0)
   project(Foo)
   add_library(foo foo.cpp)

   set_target_properties(
foo
PROPERTIES
XCODE_ATTRIBUTE_CLANG_WARN_ENUM_CONVERSION YES
   )

> cmake -H. -B_builds -GXcode
> cmake --build _builds
   /.../usr/bin/clang ... -Wenum-conversion ...

Xcode generator (disable):

> cat CMakeLists.txt
   cmake_minimum_required(VERSION 3.0)
   project(Foo)
   add_library(foo foo.cpp)

   set_target_properties(
foo
PROPERTIES
XCODE_ATTRIBUTE_CLANG_WARN_ENUM_CONVERSION NO
   )

> cmake -H. -B_builds -GXcode
> cmake --build _builds
   /.../usr/bin/clang ... -Wno-enum-conversion ...

As mentioned, these builds are performed on build servers running OSX,
where basically the code is retrieved via Git, then cmake is run, then
cmake -build is run (which invokes xcodebuild via the command line), all
using SSH commands from a build control server.  At no time is Xcode
itself invoked.
I don't understand what you mean by "no time is Xcode itself invoked". 
When you set generator to "Unix Makefiles" then Makefile project generated:

> cmake -H. -B_builds "-GUnix Makefiles"
> ls _builds/Makefile
_builds/Makefile

when you set generator to "Xcode" then Xcode project used:
> cmake -H. -B_builds -GXcode
> ls _builds/Foo.xcodeproj/project.pbxproj
_builds/Foo.xcodeproj/project.pbxproj

so there is no difference between:
* open Xcode project and hit "Build"
* cmake --build _builds
* (cd _builds && xcodebuild -alltargets)

So, if the properties you describe are Xcode settings that need to be
tweaked then do you know if there is some command-line way to do it,
that I could encode into my build scripts for example?

See example above.

Also you can use some helper functions to do it in cross-platform way:

   sugar_generate_warning_flags(
target_compile_options
target_properties
ENABLE enum-conversion
   )

   set_target_properties(
foo
PROPERTIES
${target_properties}
COMPILE_OPTIONS
"${target_compile_options}"
   )

This will set MSVC flags too. See this wiki: 
https://github.com/ruslo/sugar/wiki/Cross-platform-warning-suppression

Cheers, Ruslo
-- 

Powered by www.kitware.com

Please keep messages on-topic and check the CMake FAQ at: 
http://www.cmake.org/Wiki/CMake_FAQ

Kitware offers various services to support the CMake community. For more 
information on each offering, please visit:

CMake Support: http://cmake.org/cmake/help/support.html
CMake Consulting: http://cmake.org/cmake/help/consulting.html
CMake Training Courses: http://cmake.org/cmake/help/training.html

Visit other Kitware open-source projects at 
http://www.kitware.com/opensource/opensource.html

Follow this link to subscribe/unsubscribe:
http://public.kitware.com/mailman/listinfo/cmake

Re: [CMake] Where do all the extra clang flags come from in Xcode?

2015-05-17 Thread Paul Smith

On Sun, 2015-05-17 at 14:43 +0200, Ruslan Baratov via CMake wrote:
> As far as I know extra flags set by Xcode itself. You can use 
> XCODE_ATTRIBUTE_* target properties to enable/disable warnings. This 
> table can be helpful: 
> https://github.com/ruslo/leathers/wiki/List#xcodeclang-table

Thanks for your reply... but I don't quite understand what this table is
telling me.

As mentioned, these builds are performed on build servers running OSX,
where basically the code is retrieved via Git, then cmake is run, then
cmake -build is run (which invokes xcodebuild via the command line), all
using SSH commands from a build control server.  At no time is Xcode
itself invoked.

So, if the properties you describe are Xcode settings that need to be
tweaked then do you know if there is some command-line way to do it,
that I could encode into my build scripts for example?

Thanks!

-- 

Powered by www.kitware.com

Please keep messages on-topic and check the CMake FAQ at: 
http://www.cmake.org/Wiki/CMake_FAQ

Kitware offers various services to support the CMake community. For more 
information on each offering, please visit:

CMake Support: http://cmake.org/cmake/help/support.html
CMake Consulting: http://cmake.org/cmake/help/consulting.html
CMake Training Courses: http://cmake.org/cmake/help/training.html

Visit other Kitware open-source projects at 
http://www.kitware.com/opensource/opensource.html

Follow this link to subscribe/unsubscribe:
http://public.kitware.com/mailman/listinfo/cmake

Re: [CMake] Where do all the extra clang flags come from in Xcode?

2015-05-17 Thread Ruslan Baratov via CMake

On 14-May-15 23:53, Paul Smith wrote:

I was comparing the command line used when we choose an Xcode generator
on our OSX systems, vs. the command line used when we choose a Makefile
generator. We certainly have nothing in our CMakeLists.txt which sets
compiler flags based on the type of generator, only based on the type of
compiler (GCC, Clang, etc.)

But, when I look at the compiler and flags used by the Makefile
generator it uses /usr/bin/c++ (which is clang++ underneath) and it's
basically only the the compiler flags that we provided.

When I look at the compiler and flags used by the Xcode generator, not
only does it use a different path to the compiler
(/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang
-x c++) but, more concerning (because I assume that /usr/bin/clang++
eventually gets down to the same actual compiler as above) but it contains a
huge number of extra flags, for example it appears to disable all sorts of
warnings (that we don't want disabled): -Wno-missing-prototypes,
-Wno-return-type, -Wno-non-virtual-dtor, -Wno-overloaded-virtual, etc. etc.

This means people who build on OSX using Makefile generators see extra
warnings that people who build on OSX using Xcode don't see.

Where are these extra flags all coming from? Is it from Xcode itself
somehow? Can I keep them from being added? I don't want peoples'
personal Xcode settings to disable warnings during compilation!

Note these are build servers and so no one is actually invoking Xcode:
we log in via SSH, use cmake to generate the Xcode project files, then
use cmake -build (which runs xcodebuild) to run the build itself.

As far as I know extra flags set by Xcode itself. You can use
XCODE_ATTRIBUTE_* target properties to enable/disable warnings. This
table can be helpful:
https://github.com/ruslo/leathers/wiki/List#xcodeclang-table

Cheers, Ruslo
--

Please keep messages on-topic and check the CMake FAQ at:
http://www.cmake.org/Wiki/CMake_FAQ

Kitware offers various services to support the CMake community. For more
information on each offering, please visit:

CMake Support: http://cmake.org/cmake/help/support.html
CMake Consulting: http://cmake.org/cmake/help/consulting.html
CMake Training Courses: http://cmake.org/cmake/help/training.html

Visit other Kitware open-source projects at
http://www.kitware.com/opensource/opensource.html

Follow this link to subscribe/unsubscribe:
http://public.kitware.com/mailman/listinfo/cmake

[CMake] Where do all the extra clang flags come from in Xcode?

2015-05-14 Thread Paul Smith

I was comparing the command line used when we choose an Xcode generator
on our OSX systems, vs. the command line used when we choose a Makefile
generator.  We certainly have nothing in our CMakeLists.txt which sets
compiler flags based on the type of generator, only based on the type of
compiler (GCC, Clang, etc.)

But, when I look at the compiler and flags used by the Makefile
generator it uses /usr/bin/c++ (which is clang++ underneath) and it's
basically only the the compiler flags that we provided.

When I look at the compiler and flags used by the Xcode generator, not
only does it use a different path to the compiler
(/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang
 -x c++) but, more concerning (because I assume that /usr/bin/clang++ 
eventually gets down to the same actual compiler as above) but it contains a 
huge number of extra flags, for example it appears to disable all sorts of 
warnings (that we don't want disabled):  -Wno-missing-prototypes, 
-Wno-return-type, -Wno-non-virtual-dtor, -Wno-overloaded-virtual, etc. etc.

This means people who build on OSX using Makefile generators see extra
warnings that people who build on OSX using Xcode don't see.

Where are these extra flags all coming from?  Is it from Xcode itself
somehow?  Can I keep them from being added?  I don't want peoples'
personal Xcode settings to disable warnings during compilation!

Note these are build servers and so no one is actually invoking Xcode:
we log in via SSH, use cmake to generate the Xcode project files, then
use cmake -build (which runs xcodebuild) to run the build itself.

-- 

Powered by www.kitware.com

Please keep messages on-topic and check the CMake FAQ at: 
http://www.cmake.org/Wiki/CMake_FAQ

Kitware offers various services to support the CMake community. For more 
information on each offering, please visit:

CMake Support: http://cmake.org/cmake/help/support.html
CMake Consulting: http://cmake.org/cmake/help/consulting.html
CMake Training Courses: http://cmake.org/cmake/help/training.html

Visit other Kitware open-source projects at 
http://www.kitware.com/opensource/opensource.html

Follow this link to subscribe/unsubscribe:
http://public.kitware.com/mailman/listinfo/cmake

Re: [CMake] Where do all the extra clang flags come from in Xcode?

Re: [CMake] Where do all the extra clang flags come from in Xcode?

Re: [CMake] Where do all the extra clang flags come from in Xcode?

Re: [CMake] Where do all the extra clang flags come from in Xcode?

Re: [CMake] Where do all the extra clang flags come from in Xcode?

Re: [CMake] Where do all the extra clang flags come from in Xcode?

Re: [CMake] Where do all the extra clang flags come from in Xcode?

Re: [CMake] Where do all the extra clang flags come from in Xcode?

[CMake] Where do all the extra clang flags come from in Xcode?

9 matches

Site Navigation

Mail list logo

Footer information