allow 'cflags' on all levels (class, classes, common, shared)

[Spacechild1]

It would be nice if 'cflags' can be defined on every level in addition to the global 'cflags':

• <classname>.class.cflags (applies to all sources for the given Pd class)
• common.cflags (applies to the static library)
• shared.cflags (applies to the shared library)

For an easy way to set the cflags for a single object file, see #65 (comment))

Use cases:

• control compile time configurations (debug levels, default values, enable/disable features)
• DLL export/import macros
• pass different language specific compiler options (C vs. C++)
• ...

[umlaeute]

i see some value in the second use-case ("DLL export/import macros"), which requires different flags to be passed to the object-classes and the aux-library.

probably something like adding class.cflags, class.ldflags and <classname>.class.cflags might do the trick.

i'm not sure, I understand the "compile time debug levels" requirement: the cflags variable will be appended to the compiler-flags for the helper-library as well.

could you provide a minimal annotated Makefile on how you would use those flags (with static and shared libraries...)

[Spacechild1]

i'm not sure, I understand the "compile time debug levels" requirement: the cflags variable will be appended to the compiler-flags for the helper-library as well.

The idea is to define cflags independently for classes and the static/dynamic library. This means I could compile my object with -DLOGLEVEL=3 and my helper library with -DLOGLEVEL=1.

This is basically the same as with the import/export problem. Usually, you would define a macro when building the library and not define it when linking against the library.

[umlaeute]

probably something like adding class.cflags, class.ldflags and <classname>.class.cflags might do the trick.

i realized that this was a bit ambiguous.
what i mean was, that adding support for these flags to Makefile.pdlibbuilder should do the trick.
these variables are not implemented yet, so adding them to your Makefile won't do much yet.

but you amended the top-description anyhow, to cover just this :-)

i don't know about cflags.common: how would it be different from cflags?

[Spacechild1]

i don't know about cflags.common: how would it be different from cflags?

I would only be applied to the static library, but not to the external classes. Maybe an edge case, but why not? Definitely useful for selective compile time logging or enabling/disabling assertions.

[katjav]

A few years ago I also thought that "it would be nice" to have cflags per class, but quickly found that it is way more difficult to implement than ldflags per class. In the compilation rules there is no relation between files and classes, only between .c / .cc / .cpp files and .o files. Bummer.

[Spacechild1]

FYI, I just ran into a real issue today on macOS:

I have a shared C++ library, but the Pd objects are in C. When I set the C++ standard with -std=c++14 I can only do this globally. GCC will just ignore -std with a warning, but clang will trigger a compilation error (at least with Apple LLVM version 8.0.0 on OSX 10.11).

My workaround has been to force compilation with C++:

define forDarwin
    CC=$(CC)
endef

[umlaeute]

i guess this should read:

define forDarwin
    CC=$(CXX)
endef

[Spacechild1]

facepalm yes

[katjav]

Compilation rules in pd-lib-builder are implemented in pattern targets, calling a generalized function which passes accumulated c / c++ flags to the compiler.

pd-lib-builder/Makefile.pdlibbuilder

Lines 940 to 959 in e6cff66

	# recipe to make .o file from source
	# argument $1 is compiler type (c or cxx)
	define make-object-file
	$(info ++++ info: making $@ in lib $(lib.name))
	$(compile-$1) \
	$($1.flags) \
	-o $@ -c $<
	endef
	# Three rules to create .o files. These are double colon 'terminal' rules,
	# meaning they are the last in a rules chain.
	%.o:: %.c
	$(call make-object-file,c)
	%.o:: %.cc
	$(call make-object-file,cxx)
	%.o:: %.cpp
	$(call make-object-file,cxx)

If a class or shared lib needs extra flags, consider defining target-specific variables for its translation units in this sense:

myclass.o: cxx.flags += -std=c++14

@Spacechild1 , can you verify if target-specific defines work for your above mentioned use cases ? This is a first step to figure out how cflags might be implemented on all levels.

[Spacechild1]

Yes, this works! Actually, I am able to do the following:

# set the C++ standard for the shared C++ library
$(shared.sources:.cpp=.o): cxx.flags += -std=c++14

# set the C standard for the common sources
$(common.sources:.c=.o): c.flags += -std=c99

# set the C standard for all Pd classes
$(class.sources:.c=.o): c.flags += -std=c90

For my use cases, this is a usable workaround.

Actually, you can have a variable common.cflags and then in Makefile.pdlibbuilder have something like

$(common.sources:.c=.o): c.flags += $(common.cflags)

$(common.sources:.cpp=.o): cxx.flags += $(common.cflags)

The same for class.sources and shared.sources.

This seems to work more or less. But me writing makefiles is like a monkey hitting on a typewriter...

[umlaeute]

so should this be closed?

[Spacechild1]

Well, at the moment we only have a workaround, as suggested by @katjav. It should either be documented as such or a "real" solution could be found, i.e. implementing what the issue suggests.

What about my "solution" in my last post? Do you think this would work reliably? Could this somehow applied to individual classes as well? Unfortunately, my make skills are too weak...