Thank you very much for your help and time!

So in your case, there would probably be a Shared.xcconfig that is shared by every project in the system. Then there would be 20 “configuration” xcconfigs that would #import Shared and would also be shared by every project in the system. At the Project level of every project, you would make 20 configurations, and base them on each of these 20 xcconfig files. That’s a bit complex, I know, and very manual if you have to add a new configuration, but it is the best solution I know of. You can Applescript it, though. Here’s the idea to get you started:

tell application "Xcode"
    duplicate build configuration type named "Debug" of first project
    set aConfig to build configuration type named "Debug copy" of first project
    set name of aConfig to "New"
end tell

Then each project would have its own xcconfig that all configurations are based on at the Target level. At this level, you can do things like:

GCC_PREPROCESSOR_DEFINITIONS = $(inherited) USE_SPECIAL_CASE2

Note the use of $(inherited) here; we’re doing it at the Target level, so we want to inherit from the Project level.

The way you create conditionals is to have separate files and base a Configuration off of that file (at the Project or Target level). So rather than having Shared.xcconfig set the macros, you set the macros in adhoc1.xcconfig and #include Shared.xcconfig there to get the rest. You can see an example of this in my template project. I have Shared.xcconfig (which is included by others, but no configuration is based on it), then I have Debug.xcconfig which the Debug Configuration is based on at the Project level, Release.xcconfig which the Release Configuration is based on at the Project level, and Application.xcconfig which all configurations are based on at the Target level. So Shared is read, then either Debug or Release overrides settings in Shared, and finally Application overrides settings in Shared, Debug or Release.

I’m not certain what “10 Distributions” mean. Do you mean 10 targets, or 10 adhoc configurations and 10 distribution configurations (20 configs in total). If 20 configs, then you’d do exactly as I’ve done, but instead of just 2 (“Debug” and “Release”) you’d have 20.

adhoc1.xconfig which would Configuration 1 be based on, if Configuration is passed to other project, in the shared.xcconfig i may have something like :

if $(CONFIGURATION) == ADHOC1

// set macros

else if

etc etc, but i am not sure if it is possible to query which configuration has been chosen in xcconfig and set settings dynamically.

Or maybe you have some other ideas you don’t mind to share?

thanks a lot.

More specific to your issue, you almost certainly want to use #include files. So you put the common settings in some SharedLibrary.xcconfig and you then #include that file into each project’s xcconfig. You can overload settings after you’ve done the #include. In the case of GCC_PREPROCESSOR_DEFINITIONS above, make sure that you’ve defined that in something you’ve #included. That would be my suspicion.

Also, remember $(inherited), which represents the value this variable has based on higher (rather than earlier) levels. What I mean is that if you set VAR to something and then #include that, $(VAR) will give you the value it was given in the earlier #include. If you set VAR at the Project level, then at the Target level $(inherited) will give you the value from the Project level. So often the first setter of VAR at a level should use $(inherited), and later setters should use $(VAR) as their first element.

Remember that each project compiles independently. What you’ve done in the “parent” project has almost no impact on the “children” projects (there really is no such thing as “parent” and “children” in xcodebuild). I say “almost no impact” because a couple of things are passed down; specifically the SDK and the Configuration. But setting GCC_PREPROCESSOR_DEFINITIONS in one project has no impact at all on other projects. If you want to share a value, you need to hoist that into a separate xcconfig file and #include it into the xcconfig files for each project.

Static libraries share a lot of the preprocessors, the idea is to decouple static libraries into the different project files and include those in the main project. But here is the Challenge, some libraries require Macros to be set depending on which product we are building. i.e. Configuration A, sets Macro USE_SPECIAL_CASE, which a few static libraries needs to compile with, Configuration B, sets USE_SPECIAL_CASE2 etc.

We have tried to add GCC_PREPROCESSOR_DEFINITIONS = $(GCC_PREPROCESSOR_DEFINITIONS) USE_SPECIAL_CASE2 but it is not propagated to other projects.

Thanks for the help.