4

I have multiple app projects which all link to the same static library project. Each app project needs to compile the static library project using different settings.

At the moment I have a conditional compilation header in the static library project, let's call it ViewType.h which adds more types, typedefs, macros, etc specific to each view. 

#define VIEW_A 1
#define VIEW_B 2
#define VIEW_C 3

#ifndef VIEWTYPE
#define VIEWTYPE VIEW_A
#endif

#if VIEWTYPE == VIEW_A
    // further typedefs and defines tailored to VIEW_A
#elif VIEWTYPE == VIEW_B
    // further typedefs and defines tailored to VIEW_B
#elif VIEWTYPE == VIEW_C
    // further typedefs and defines tailored to VIEW_C
#endif

The problem here is that each app project needs to change the VIEWTYPE in the static library project, and every time I switch app projects I have to change the VIEWTYPE again.

Unfortunately it seems I can not define VIEWTYPE=2 (for example) as preprocessor macro in the app target. And I can't define this in the static library project either because all 3 projects include the same static library project, because the .xcodeproj is shared between the 3 apps (ie the .xcodeproj is dragged & dropped onto the app project; I'm not using a workspace).

I understand one issue is that the static library being a dependent target it is built first before the app target is even considered. So perhaps there's some way to make that decision which app the library is built for based on other conditionals (ie checking for a file, or including an optional app-specific header).

Question: How I can create a macro or otherwise perform conditional compilation based on macros/settings defined by the app target which are then adhered to by the static library project?

Improve this question

1 Answer 1

Reset to default
1

The first, simplest approach, is to get rid of the static library, and just include the source files directly into the dependent projects. I often find that intermediate static libraries are much more trouble than they're worth. Their one big benefit comes when they provide a significant build-performance improvement, but they can't here since you're rebuilding the static library for every final target anyway.

I will say that the use of a type #defines almost always makes me cry, and may suggest a design flaw that could be better handled. For instance, you may want to implement methods that return the class required (the way UIView layerClass does). Pre-processor trickery that changes type definitions can lead to extremely subtle bugs. (I just chased down a case of this last year… it was a horrible, horrible crash to figure out.)

That said, another approach for certain versions of this problem can be solved with xcconfig files. For example, if there are actually multiple copies of the static library (i.e. this is a library that is commonly copied into other projects), then you can use an xcconfig file that has an #include "../SpecialTypeDefs.xcconfig". That file would be provided by each project to set special declarations. Failure to define that file would lead to a complier error, so it's easy to not have an error.

But personally, I'd just include the files into the actual project directly and skip the library unless they're really enormous.

Improve this answer
Sign up to request clarification or add additional context in comments.

1 Comment

Since this is a library for end-users, static library is not something I can just give up on. From custom build settings to installing (drag & drop) to updating (replace folder contents) a static lib project has many advantages. Though this gave me an idea: I could simply have multiple targets inside the library project, and then I can define the macro for each target separately.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.