Shulou(Shulou.com)06/03 Report--

23. Support for independent modules is 23.1. Question:

Generally speaking, different engineers are responsible for the development of different modules, how to support the independent compilation of modules in the compilation environment?

23.2. Problem background: there are thousands of codes in large projects, and it takes a long time to complete compilation. When writing module code, syntax errors can be checked through compilation. In order to improve development efficiency, it is necessary to support independent compilation of specified modules.

23.3. The solution takes the module name (module) as the target name (pseudo-target) to establish the rule target (module), which depends on the commands in the build build/module rule to enter the corresponding module folder and compile the results in the build folder. Key technical points

How do I get the specified compiled module name on the make command line?

Predefined variable: $(MAKECMDGOALS), the target name specified on the command line (command line argument to make)

Programming experiment:

$(MODULES): $(DIR_BUILD) $(DIR_BUILD) / $(MAKECMDGOALS) @ echo "Begin to compile $@" @ set-e \ cd $$dir & &\ $(MAKE) all\ DEBUG:=$ (DEBUG)\ DIR_BUILD:=$ (addprefix $(DIR_PROJECT) /, $(DIR_BUILD))\ DIR_COMMON_INC:=$ (addprefix $(DIR_PROJECT) /, $(DIR_COMMON_INC))\ CMD_CFG:=$ (addprefix $(DIR_PROJECT) / (CMD_CFG))\ MOD_CFG:=$ (addprefix $(DIR_PROJECT) /, $(MOD_CFG))\ MOD_RULE:=$ (addprefix $(DIR_PROJECT) /, $(MOD_RULE)) & &\ cd.

Note: automatic variables can only be used in regular commands, not in dependencies

Code reuse in 23.5.Makefile

When there are a large number of repeated commands in different rules, you can consider custom functions

Custom functions in Makefile are a way of code reuse

23.6. Train of thought

Take the command set of the compiler module as the concrete implementation of the custom function.

The function parameter is used as the module name, and the module specified by the parameter is compiled after the function is called.

Call this function in different rules

Programming experiment:

Define makemodule cd $(1) & &\ $(MAKE) all\ DEBUG:=$ (DEBUG)\ DIR_BUILD:=$ (addprefix $(DIR_PROJECT) /, $(DIR_BUILD))\ DIR_COMMON_INC:=$ (addprefix $(DIR_PROJECT) /, $(DIR_COMMON_INC))\ CMD_CFG:=$ (addprefix $(DIR_PROJECT) / (CMD_CFG))\ MOD_CFG:=$ (addprefix $(DIR_PROJECT) /, $(MOD_CFG))\ MOD_RULE:=$ (addprefix $(DIR_PROJECT) /, $(MOD_RULE)) & &\ cd. ; endef23.7. Summary when writing module code can quickly check syntax errors through module independent compilation automatic variables can only be used in regular commands, can not be used in dependencies custom functions in Makefile is a way of code reuse when a large number of commands in different rules are repeated, you can consider custom functions 24. Support for third-party libraries is 24.1. problem

How to modify the makefile in the compilation environment when you need to use a third-party library file?

24.2. The experience assumes that the function library files in the library are provided by the third-party library through function calls when they are released with the header file declaring the library function prototype using the header file in the compilation phase and the library file 24.3 in the link phase. The location of the third-party library in the project

24.4. The compilation phase of the third-party library

Define the variable DIR_LIBS_INC to indicate where the header file is stored

DIR_LIBS_INC: = $(DIR_PROJECT) / libs/inc

Use DIR_LIBS_INC to prompt for the storage location of the makeheader file

Vpath% $(TYPE_INC) $(DIR_LIBS_INC)

Use DIR_LIBS_INC to prompt the compiler for the location of the header file

CFLAGS + =-i$ (DIR_LIBS_INC)

Programming experiment (the changes are as follows):

24.5. Matters needing attention

Set at DIR_LIBS_LIB: = libs/lib (location of the third-party library)

The library files in DIR_LIBS_LIB will not be linked directly when linking. You need to copy the library files to the DIR_BUILD folder first.

The relationship between the copied library file and the original library file must be considered.

$(DIR_BUILD) /%: $(DIR_LIBS_LIB) /% $(CP) $^ $@ 24.6. Support for third-party library links

Define the variable EXTERNAL_LIB to hold the list of third-party libraries

Target link needs to rely on a list of third-party libraries

The reason is that there may be situations where the submodule library name is the same as the third-party library name, so we have to link the submodule first.

Programming experiment (the changes are as follows):

Final solution: module makefile:

Include $(MOD_CFG) # Custmization Begin# # DIR_SRC: = src# DIR_INC: = inc## TYPE_INC: = .h # TYPE_SRC: = .c # TYPE_OBJ: = .o # TYPE_DEP: = .dep # # Custmization Endinclude $(CMD_CFG) include $(MOD_RULE)

The sub-module mod-cfg.mk contained in the include in the module makefile:

DIR_SRC: = srcDIR_INC: = incTYPE_INC: = .hTYPE _ SRC: = .cTYPE _ OBJ: = .oTYPE _ DEP: = .dep

The sub-module mod-rule.mk contained in the include in the module makefile:

.PHONY: allMODULE: = $(realpath.) MODULE: = $(notdir $(MODULE)) DIR_OUTPUT: = $(addprefix $(DIR_BUILD) /, $(MODULE)) OUTPUT: = $(MODULE). AOUTPUT: = $(addprefix $(DIR_BUILD) /, $(OUTPUT)) SRCS: = $(wildcard $(DIR_SRC) / * $(TYPE_SRC)) OBJS: = $(SRCS:$ (TYPE_SRC) = $(TYPE_OBJ) OBJS: = $(patsubst $(DIR_SRC) /% $(DIR_OUTPUT) /%, $(OBJS) DEPS: = $(SRCS:$ (TYPE_SRC) = $(TYPE_DEP)) DEPS: = $(patsubst $(DIR_SRC) /%, $(DIR_OUTPUT) /% $(DEPS)) vpath% $(TYPE_INC) $(DIR_INC) vpath% $(TYPE_INC) $(DIR_COMMON_INC) vpath% $(TYPE_INC) $(DIR_LIBS_INC) vpath% $(TYPE_SRC) $(DIR_SRC)-include $(DEPS) all: $(OUTPUT) @ echo "Success! Target = > $(OUTPUT) "$(OUTPUT): $(OBJS) $(AR) $(ARFLAGS) $@ $^ $(DIR_OUTPUT) /% $(TYPE_OBJ):% $(TYPE_SRC) $(CC) $(CFLAGS)-o $@-c $(filter% $(TYPE_SRC), $^) $(DIR_OUTPUT) /% $(TYPE_DEP):% $(TYPE_SRC) @ echo" Creating $@... "@ set-e \ $(CC) $(CFLAGS)-MM-E $(filter% $(TYPE_SRC), $^) | sed's,\ (.*\)\ .o [:] *, $(DIR_OUTPUT) /\ 1 $(TYPE_OBJ) $@:, g'> $@

The sub-module cmd-cfg.mk contained in the include in the module makefile:

AR: = arARFLAGS: = crsCC: = gccLFLAGS: = CFLAGS: =-I $(DIR_INC)-I $(DIR_COMMON_INC)-I $(DIR_LIBS_INC) ifeq ($(DEBUG), true) CFLAGS + =-gendifMKDIR: = mkdirRM: = rm-frCP: = cp

Project Master makefile:

Include pro-cfg.mkinclude cmd-cfg.mkinclude pro-rule.mk

The sub-module pro-cfg.mk contained in the include in the project makefile:

MODULES: = common\ module\ mainMOD_CFG: = mod-cfg.mkMOD_RULE: = mod-rule.mkCMD_CFG: = cmd-cfg.mkDIR_BUILD: = buildDIR_COMMON_INC: = common/incDIR_LIBS_INC: = libs/incDIR_LIBS_LIB: = libs/libAPP: = app.out

The sub-module pro-rele.mk contained in the include in the project makefile:

.PHONY: all compile link clean rebuild $(MODULES) DIR_PROJECT: = $(realpath.) DIR_BUILD_SUB: = $(addprefix $(DIR_BUILD) /, $(MODULES)) MODULE_LIB: = $(addsuffix .a, $(MODULES)) MODULE_LIB: = $(addprefix $(DIR_BUILD) /, $(MODULE_LIB)) EXTERNAL_LIB: = $(wildcard $(DIR_LIBS_LIB) / *) EXTERNAL_LIB: = $(patsubst $(DIR_LIBS_LIB) /%, $(DIR_BUILD) /% (EXTERNAL_LIB)) APP: = $(addprefix $(DIR_BUILD) /, $(APP)) define makemodule cd $(1) & &\ $(MAKE) all\ DEBUG:=$ (DEBUG)\ DIR_BUILD:=$ (addprefix $(DIR_PROJECT) /, $(DIR_BUILD))\ DIR_COMMON_INC:=$ (addprefix $(DIR_PROJECT) / (DIR_COMMON_INC))\ DIR_LIBS_INC:=$ (addprefix $(DIR_PROJECT) /, $(DIR_LIBS_INC))\ CMD_CFG:=$ (addprefix $(DIR_PROJECT) /, $(CMD_CFG))\ MOD_CFG:=$ (addprefix $(DIR_PROJECT) /, $(MOD_CFG))\ MOD_RULE:=$ (addprefix $(DIR_PROJECT) / (MOD_RULE) & &\ cd. Endefall: compile $(APP) @ echo "Success! Target = > $(APP) "compile: $(DIR_BUILD) $(DIR_BUILD_SUB) @ echo" Begin to compile... "@ set-e;\ for dir in $(MODULES) \ do\ $(call makemodule $dir)\ done @ echo "Compile Success!" link $(APP): $(MODULE_LIB) $(EXTERNAL_LIB) @ echo "Begin to link..." $(CC)-o $(APP)-Xlinker "- (" $^-Xlinker "-)" $(LFLAGS) @ echo "Link Success!" $(DIR_BUILD) /%: $(DIR_LIBS_LIB) /% $(CP) $^ $@ $(DIR_) BUILD) $(DIR_BUILD_SUB): $(MKDIR) $@ clean: @ echo "Begin to clean..." $(RM) $(DIR_BUILD) @ echo "Clean Success!" rebuild: clean all$ (MODULES): $(DIR_BUILD) $(DIR_BUILD) / $(MAKECMDGOALS) @ echo "Begin to compile $@" @ set-e \ $(call makemodule, $@) 24.7. Summary compilation environment must support the use of third-party libraries (static or dynamic libraries) in engineering development, special folders are generally used to store the header files attached to third-party libraries to declare library functions (required during the compilation phase). In the link phase, copy the library files to the build folder before connecting

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.