एकाधिक निष्पादन योग्य के साथ मेकफ़ाइल

Question

मैं एक मेकफ़ाइल लिखने की कोशिश कर रहा हूं जो कई फ़ाइलों से एकाधिक निष्पादन योग्य बनाने के लिए मैक्रोज़ का उपयोग करता है। मैंने पहले दिए गए सवालों के माध्यम से खोज करने की कोशिश की लेकिन, क्योंकि मैं सी में प्रोग्रामिंग के साथ-साथ जीसीसी के साथ काम करने के लिए काफी नया हूं, इसलिए मुझे अपने प्रश्न का उत्तर नहीं मिला।

CC=gcc 
CFLAGS=-I. 
OBJ = ex1.c ex3.c 
EXECUTABLE = ex1 ex3 

$(EXECUTABLE): $(OBJ) 
    gcc -o $@ $^ $(CFLAGS) 

clean: 
    rm -f $(EXECUTABLE) 

मैं लाइन

$(EXECUTABLE): $(OBJ) 

क्रमशः निष्पादनयोग्य EX1 और फ़ाइलों ex1.c ex3.c से ex3 बनाना चाहेंगे:

यहाँ मैं अब तक है।

Answer 1

इस विशेष मामले हैं, जहां प्रत्येक निष्पादन .c विस्तार के साथ एक ही स्रोत फ़ाइल है के लिए, आपको केवल एक एक पंक्ति Makefile है:

$ make 
cc -O2 -pipe ex1.c -o ex1 
cc -O2 -pipe ex3.c -o ex3 

दृश्य के पीछे

, makePOSIXly mandated built-in single suffix rule

उपयोग कर रहा है

make CC=gcc CFLAGS=-O2 LDFLAGS=-s और इसी तरह के साथ अपनी पसंद के आदेश को कम करें। दिन की

सामान्य ज्ञान:

$ make -f /dev/null CC=gcc CFLAGS=-O2 LDFLAGS=-s ex1 ex3 
gcc -O2 -s ex1.c -o ex1 
gcc -O2 -s ex3.c -o ex3 
$ rm -f Makefile ex1 ex3 
$ make CC=gcc CFLAGS=-O2 LDFLAGS=-s ex1 ex3 
gcc -O2 -s ex1.c -o ex1 
gcc -O2 -s ex3.c -o ex3 

जादू बनाओ: वास्तव में, यदि आप लक्ष्य नाम के लिए तैयार हैं जब make लागू, आप एक खाली या यहाँ तक कि रन के बिना किसी भी Makefile उपयोग कर सकते हैं !

अंगूठे के नियम के रूप में, पहिया (या नियम) को पुन: पेश न करें, पहले से मौजूद नियमों का उपयोग करें। यह आपके को सरल बनाता है और जीवन को बहुत बनाता है। यह महिलाओं को प्रभावित करने के लिए छोटे और सेक्सी मेकफ़ाइल बनाता है :-)

Answer 2

आप निकट पहुंच गए हैं, लेकिन आप एक पैटर्न शासन की जरूरत है:

all: $(EXECUTABLE) 

Answer 3

कुछ सुझाव (आप का उपयोग संभालने जीएनयू: यह दोनों का निर्माण करने के लिए

$(EXECUTABLE): % : %.c 

और फिर डिफ़ॉल्ट नियम make, कुछ और नहीं)

सबसे पहले, make -p पर चलाएं, आप समझेंगे कि बिल्टिन नियम make जान रहा है। (-Wall क्योंकि तुम सच में डीबगिंग के लिए -g चाहते हैं, और सबसे चेतावनी प्राप्त करने के लिए) COMPILE.c के लिए विशेष रूप से देखने के लिए और LINK.c

फिर, मेरा सुझाव है

CFLAGS= -g -Wall -I. 

और आप शायद नहीं है

$(EXECUTABLE): $(OBJ) 
    gcc -o $@ $^ $(CFLAGS) 

हालांकि, मैं श्वास सेंट अधिकांश अन्य नियमों से पहले जोड़ने

.PHONY: all clean 

all: $(EXECUTABLES) 

वास्तव में, मैं अपने Makefile कोड होगा (के लिए जीएनयूmake!) के रूप में पालन

# file Makefile 
CC= gcc 
RM= rm -vf 
CFLAGS= -Wall -g 
CPPFLAGS= -I. 
SRCFILES= ex1.c ex2.C## or perhaps $(wildcard *.c) 
OBJFILES= $(patsubst %.c, %.o, $(SRCFILES)) 
PROGFILES= $(patsubst %.c, %, $(SRCFILES)) 

.PHONY: all clean 

all: $(PROGFILES) 
clean: 
    $(RM) $(OBJFILES) $(PROGFILES) *~ 
## eof Makefile 

याद रखें कि टैबMakefile -s में एक महत्वपूर्ण चरित्र है (rules का कार्य हिस्सा)। इस उत्तर में, कम से कम चार रिक्त स्थान से शुरू होने वाली रेखाएं वास्तव में टैब वर्ण से शुरू होनी चाहिए।

एक बार सबकुछ डीबग हो जाने पर, सब कुछ साफ करने के लिए make clean चलाने पर विचार करें, और फिर make -j CFLAGS=-O2 all ऑप्टिमाइज़ेशन के साथ समांतर सब कुछ में संकलित करने पर विचार करें।

अंत में, मैं remake का उपयोग करना चाहिये और चल remake -x डिबग करने के लिए जटिल Makefile -s

बेशक

, मैं मान रहा हूँ कि आपके निर्देशिका केवल एकल फ़ाइल कार्यक्रमों है।

बीटीडब्ल्यू, अन्य निर्माता कार्यक्रम भी हैं। शायद आप omake

^{अपनी स्रोत फ़ाइलों के लिए git जैसी संस्करण नियंत्रण प्रणाली का उपयोग करना न भूलें। यह भी एक उपकरण सीखने का समय है।}

all: ex1 ex3 

निर्मित make के लिए डिफ़ॉल्ट नियम तो पहले से ही काम करते हैं:

Answer 4

निम्नलिखित उत्तर में कई निष्पादन योग्य जैसे आरंभ, प्रक्रिया 1, प्रक्रिया 2, ..., प्रक्रिया 4 शामिल हैं।

LOCAL_INCLUDE=./ 

all: clean process_first process_second init 

process_first: 
    gcc -g -o process1 -I$(LOCAL_INCLUDE) process1.c -lzmq -L. -L./. 
    gcc -g -o process2 -I$(LOCAL_INCLUDE) process2.c -lzmq -L. -L./. 

process_second: 
    gcc -g -o process3 -I$(LOCAL_INCLUDE) process3.c -lzmq -L. -L./. 
    gcc -g -o process4 -I$(LOCAL_INCLUDE) process4.c -lzmq -L. -L./. 

init: 
    gcc -g -o initiate -I$(LOCAL_INCLUDE) initiate.c -lzmq -lconfig -lpthread -L. -L./. -ldl -lrt 

clean: 
    rm -rf init_manager.o init_manager 
    rm -rf process1 process2 process3 process4 

नोट: यह फिर से बनाने से पहले सभी निष्पादन योग्य फ़ाइलों को साफ और स्पर्श करने का एक अच्छा अभ्यास है।