//
// Project-Shared.xcconfig
//
// Generated by BuildSettingExtractor on 02/04/2018
// https://github.com/dempseyatgithub/BuildSettingExtractor
//

PRODUCT_NAME = ${TARGET_NAME}

DEVELOPMENT_TEAM =
PROVISIONING_PROFILE =
PROVISIONING_PROFILE_SPECIFIER =
CODE_SIGN_IDENTITY =
CODE_SIGN_STYLE = Manual

// Misuse of 'nonnull'
//
// Check for misuses of `nonnull` parameter and return types.

CLANG_ANALYZER_NONNULL = YES

// Suspicious Conversions of NSNumber and CFNumberRef
//
// Warn when a number object, such as an instance of `NSNumber`, `CFNumberRef`,
// `OSNumber`, or `OSBoolean` is compared or converted to a primitive value instead of
// another object.

CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE

// Always Search User Paths (Deprecated)
// 
// This setting is deprecated as of Xcode 8.3 and may not be supported in future
// versions. It is recommended that you disable the setting.
// 
// If enabled, both `#include <header.h>`-style and `#include "header.h"`-style
// directives search the paths in `USER_HEADER_SEARCH_PATHS` before
// `HEADER_SEARCH_PATHS`. As a consequence, user headers, such as your own `String.h`
// header, have precedence over system headers when using `#include <header.h>`. This is
// done using the `-iquote` flag for the paths provided in `USER_HEADER_SEARCH_PATHS`. If
// disabled and your compiler fully supports separate user paths, user headers are only
// accessible with `#include "header.h"`-style preprocessor directives.
// 
// For backwards compatibility reasons, this setting is enabled by default. Disabling it
// is strongly recommended.

ALWAYS_SEARCH_USER_PATHS = NO



// C++ Language Dialect
// 
// Choose a standard or non-standard C++ language dialect. Options include:
// 
// * *C++98:* Accept ISO C++ 1998 with amendments, but not GNU extensions. [-std=c++98]
// * *GNU++98:* Accept ISO C++ 1998 with amendments and GNU extensions. [-std=gnu++98]
// * *C++11:* Accept the ISO C++ 2011 standard with amendments, but not GNU extensions.
// [-std=c++11]
// * *GNU++11:* Accept the ISO C++ 2011 standard with amendments and GNU extensions.
// [-std=gnu++11]
// * *C++14:* Accept the ISO C++ 2014 standard with amendments, but not GNU extensions.
// [-std=c++14]
// * *GNU++14:* Accept the ISO C++ 2014 standard with amendments and GNU extensions.
// [-std=gnu++14]
// * *C++17:* Accept the ISO C++ 2017 standard with amendments, but not GNU extensions.
// [-std=c++17]
// * *GNU++17:* Accept the ISO C++ 2017 standard with amendments and GNU extensions.
// [-std=gnu++17]
// * *Compiler Default:* Tells the compiler to use its default C++ language dialect. This
// is normally the best choice unless you have specific needs. (Currently equivalent to
// GNU++98.)

CLANG_CXX_LANGUAGE_STANDARD = gnu++0x



// C++ Standard Library
// 
// Choose a version of the C++ standard library to use.
// 
// * *libstdc++:* A traditional C++ standard library that works with GCC and the LLVM
// Compiler (default).
// * *libc++:* A highly optimized C++ standard library that works only with the LLVM
// Compiler, and is designed to support new C++11 features.

CLANG_CXX_LIBRARY = libc++



// Enable Modules (C and Objective-C)
// 
// Enables the use of modules for system APIs. System headers are imported as semantic
// modules instead of raw headers. This can result in faster builds and project indexing.

CLANG_ENABLE_MODULES = YES



// Objective-C Automatic Reference Counting
// 
// Compiles reference-counted Objective-C code (when garbage collection is not enabled)
// to use Automatic Reference Counting. Code compiled using automated reference counting
// is compatible with other code (such as frameworks) compiled using either manual
// reference counting (for example, traditional `retain` and `release` messages) or
// automated reference counting. Using this mode is currently incompatible with compiling
// code to use Objective-C Garbage Collection.

CLANG_ENABLE_OBJC_ARC = YES


// Weak References in Manual Retain Release
//
// Compiles Objective-C code to enable weak references for code compiled with manual
// retain release (MRR) semantics.

CLANG_ENABLE_OBJC_WEAK = YES


// Duplicate Method Definitions
// 
// Warn about declaring the same method more than once within the same `@interface`.

CLANG_WARN__DUPLICATE_METHOD_MATCH = YES



// Block Capture of Autoreleasing
// 
// Warn about block captures of implicitly autoreleasing parameters.

CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES



// Implicit Boolean Conversions
// 
// Warn about implicit conversions to boolean values that are suspicious. For example,
// writing `if (foo)` where `foo` is the name a function will trigger a warning.

CLANG_WARN_BOOL_CONVERSION = YES



// Suspicious Commas
// 
// Warn about suspicious uses of the comma operator.

CLANG_WARN_COMMA = YES



// Implicit Constant Conversions
// 
// Warn about implicit conversions of constant values that cause the constant value to
// change, either through a loss of precision, or entirely in its meaning.

CLANG_WARN_CONSTANT_CONVERSION = YES



// Overriding Deprecated Objective-C Methods
// 
// Warn if an Objective-C class either subclasses a deprecated class or overrides a
// method that has been marked deprecated or unavailable.

CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES



// Direct usage of 'isa'
// 
// Warn about direct accesses to the Objective-C `isa` pointer instead of using a runtime
// API.

CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR



// Empty Loop Bodies
// 
// Warn about loop bodies that are suspiciously empty.

CLANG_WARN_EMPTY_BODY = YES



// Implicit Enum Conversions
// 
// Warn about implicit conversions between different kinds of enum values. For example,
// this can catch issues when using the wrong enum flag as an argument to a function or
// method.

CLANG_WARN_ENUM_CONVERSION = YES



// Infinite Recursion
// 
// Warn if all paths through a function call itself.

CLANG_WARN_INFINITE_RECURSION = YES



// Implicit Integer to Pointer Conversions
// 
// Warn about implicit conversions between pointers and integers. For example, this can
// catch issues when one incorrectly intermixes using `NSNumber*`'s and raw integers.

CLANG_WARN_INT_CONVERSION = YES



// Implicit Non-Literal Null Conversions
// 
// Warn about non-literal expressions that evaluate to zero being treated as a null
// pointer.

CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES



// Implicit retain of 'self' within blocks
// 
// Warn about implicit retains of `self` within blocks, which can create a retain-cycle.

CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES



// Implicit Objective-C Literal Conversions
// 
// Warn about implicit conversions from Objective-C literals to values of incompatible
// type.

CLANG_WARN_OBJC_LITERAL_CONVERSION = YES



// Unintentional Root Class
// 
// Warn about classes that unintentionally do not subclass a root class, such as
// `NSObject`.

CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR



// Range-based For Loops
// 
// Warn about ranged-based for loops.

CLANG_WARN_RANGE_LOOP_ANALYSIS = YES



// Strict Prototypes
// 
// Warn about non-prototype declarations.

CLANG_WARN_STRICT_PROTOTYPES = YES



// Suspicious Moves
// 
// Warn about suspicious uses of `std::move`.

CLANG_WARN_SUSPICIOUS_MOVE = YES



// Unreachable Code
// 
// Warns about potentially unreachable code.

CLANG_WARN_UNREACHABLE_CODE = YES


// Documentation Comments
//
// Warns about issues in documentation comments (`doxygen`-style) such as missing or
// incorrect documentation tags.

CLANG_WARN_DOCUMENTATION_COMMENTS = YES


// Unguarded availability
//
// Warn if an API that is newer than the deployment target is used without "if
// (@available(...))" guards.

CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE



CODE_SIGNING_REQUIRED = NO



// Current Project Version
// 
// This setting defines the current version of the project. The value must be a integer
// or floating point number, such as `57` or `365.8`.

CURRENT_PROJECT_VERSION = 1



// Debug Information Format
// 
// The type of debug information to produce.
// 
// * *DWARF:* Object files and linked products will use DWARF as the debug information
// format. [dwarf]
// * *DWARF with dSYM File:* Object files and linked products will use DWARF as the debug
// information format, and Xcode will also produce a dSYM file containing the debug
// information from the individual object files (except that a dSYM file is not needed
// and will not be created for static library or object file products). [dwarf-with-dsym]

DEBUG_INFORMATION_FORMAT = dwarf



// Defines Module
// 
// If enabled, the product will be treated as defining its own module. This enables
// automatic production of LLVM module map files when appropriate, and allows the product
// to be imported as a module.

DEFINES_MODULE = YES



// Enable Strict Checking of objc_msgSend Calls
// 
// Controls whether `objc_msgSend` calls must be cast to the appropriate function pointer
// type before being called.

ENABLE_STRICT_OBJC_MSGSEND = YES



// C Language Dialect
// 
// Choose a standard or non-standard C language dialect.
// 
// * *ANSI C:* Accept ISO C90 and ISO C++, turning off GNU extensions that are
// incompatible. [-ansi]
// Incompatible GNU extensions include the `asm`, `inline`, and `typeof` keywords (but
// not the equivalent `\_\_asm\_\_`, `\_\_inline\_\_`, and `\_\_typeof\_\_` forms), and
// the `//` syntax for comments.
// This setting also enables trigraphs.
// * *C89:* Accept ISO C90 (1990), but not GNU extensions. [-std=c89]
// * *GNU89:* Accept ISO C90 and GNU extensions. [-std=gnu89]
// * *C99:* Accept ISO C99 (1999), but not GNU extensions. [-std=c99]
// * *GNU99:* Accept ISO C99 and GNU extensions. [-std=gnu99]
// * *C11:* Accept ISO C11 (2011), but not GNU extensions. [-std=c11]
// * *GNU11:* Accept ISO C11 and GNU extensions. [-std=gnu11]
// * *Compiler Default:* Tells the compiler to use its default C language dialect. This
// is normally the best choice unless you have specific needs. (Currently equivalent to
// GNU99.)

GCC_C_LANGUAGE_STANDARD = gnu99



// No Common Blocks
// 
// In C, allocate even uninitialized global variables in the data section of the object
// file, rather than generating them as common blocks. This has the effect that if the
// same variable is declared (without `extern`) in two different compilations, you will
// get an error when you link them.

GCC_NO_COMMON_BLOCKS = YES



// Implicit Conversion to 32 Bit Type
// 
// Warn if a value is implicitly converted from a 64-bit type to a 32-bit type. This is a
// subset of the warnings provided by -Wconversion.

GCC_WARN_64_TO_32_BIT_CONVERSION = YES



// Mismatched Return Type
// 
// Causes warnings to be emitted when a function with a defined return type (not `void`)
// contains a return statement without a return-value. Also emits a warning when a
// function is defined without specifying a return type.

GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR



// Undeclared Selector
// 
// Warn if a `@selector(...)` expression referring to an undeclared selector is found. A
// selector is considered undeclared if no method with that name has been declared before
// the `@selector(...)` expression, either explicitly in an `@interface` or `@protocol`
// declaration, or implicitly in an `@implementation` section. This option always
// performs its checks as soon as a `@selector(...)` expression is found, while
// `-Wselector` only performs its checks in the final stage of compilation. This also
// enforces the coding style convention that methods and selectors must be declared
// before being used.

GCC_WARN_UNDECLARED_SELECTOR = YES



// Uninitialized Variables
// 
// Warn if a variable might be clobbered by a `setjmp` call or if an automatic variable
// is used without prior initialization.
// 
// The compiler may not detect all cases where an automatic variable is initialized or
// all usage patterns that may lead to use prior to initialization. You can toggle
// between the normal uninitialized value checking or the more aggressive (conservative)
// checking, which finds more issues but the checking is much stricter.

GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE



// Unused Functions
// 
// Warn whenever a static function is declared but not defined or a noninline static
// function is unused.

GCC_WARN_UNUSED_FUNCTION = YES



// Unused Labels
// 
// Warn whenever a label is declared but not used.

GCC_WARN_UNUSED_LABEL = YES



// Unused Variables
// 
// Warn whenever a local variable or nonconstant static variable is unused aside from its
// declaration.

GCC_WARN_UNUSED_VARIABLE = YES


IPHONEOS_DEPLOYMENT_TARGET = 8.0



// macOS Deployment Target
// 
// Code will load on this and later versions of macOS. Framework APIs that are
// unavailable in earlier versions will be weak-linked; your code should check for `null`
// function pointers or specific system versions before calling newer APIs.

MACOSX_DEPLOYMENT_TARGET = 10.10



// Supported Platforms
// 
// The list of supported platforms from which a base SDK can be used. This setting is
// used if the product can be built for multiple platforms using different SDKs.

SUPPORTED_PLATFORMS = iphonesimulator iphoneos macosx appletvos watchos appletvsimulator watchsimulator



SWIFT_COMPILATION_MODE = wholemodule



// Swift Language Version
// 
// 

SWIFT_VERSION = 4.2



// Targeted Device Family
// 
// The build system uses the selected device to set the correct value for the
// `UIDeviceFamily` key it adds to the target's `Info.plist` file. This also drives the
// --target-device flag to actool, which determines the idioms selected during catalog
// compilation for iOS platforms.

TARGETED_DEVICE_FAMILY = 1,2,3,4



TVOS_DEPLOYMENT_TARGET = 9.0



// Versioning Name Prefix
// 
// Used as a prefix for the name of the version info symbol in the generated versioning
// source file. If you prefix your exported symbols you will probably want to set this to
// the same prefix.

VERSION_INFO_PREFIX = 



// Versioning System
// 
// Selects the process used for version-stamping generated files.
// 
// * *None:* Use no versioning system.
// * *Apple Generic:* Use the current project version setting. [apple-generic]

VERSIONING_SYSTEM = apple-generic



WATCHOS_DEPLOYMENT_TARGET = 2.0