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

classic Classic list List threaded Threaded
9 messages Options
Reply | Threaded
Open this post in threaded view
|

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

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
Reply | Threaded
Open this post in threaded view
|

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

CMake mailing list
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
--

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
Reply | Threaded
Open this post in threaded view
|

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

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
Reply | Threaded
Open this post in threaded view
|

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

CMake mailing list
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
Reply | Threaded
Open this post in threaded view
|

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

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
Reply | Threaded
Open this post in threaded view
|

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

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

 <https://ionic.com>

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














On 5/18/15, 1:20 PM, "Paul Smith" <[hidden email]> 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
Reply | Threaded
Open this post in threaded view
|

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

Andreas Pakulat-2
In reply to this post by Paul Smith
Hi Paul,

On Mon, May 18, 2015 at 3:20 PM, Paul Smith <[hidden email]> 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
Reply | Threaded
Open this post in threaded view
|

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

CMake mailing list
In reply to this post by Paul Smith
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
Reply | Threaded
Open this post in threaded view
|

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

CMake mailing list
In reply to this post by Parag Chandra
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