Make file two macros - makefile

Question

I want to use macros in a single Makefile to compile two programs. When I run make, it produces this output:
Makefile:27: warning: overriding commands for target `compose'
Makefile:24: warning: ignoring old commands for target `compose'
g++ -g `Magick++-config --cppflags` -c alphamask.cpp
g++ -g `Magick++-config --ldflags` -o alphamask alphamask.o -L /usr/lib64/ -lglut -lGL -lGLU -lMagick++ -lm
It only compiles the second program. Is there any way to have the macros compile both programs? Here's my current Makefile:
CC = g++
C = cpp
CFLAGS = -g `Magick++-config --cppflags`
LFLAGS = -g `Magick++-config --ldflags`
ifeq ("$(shell uname)", "Darwin")
LDFLAGS = -framework Foundation -framework GLUT -framework OpenGL -lMagick++ -lm
else
ifeq ("$(shell uname)", "Linux")
LDFLAGS = -L /usr/lib64/ -lglut -lGL -lGLU -lMagick++ -lm
endif
endif
ALPHA = alphamask
COMP = compose
${ALPHA}: ${ALPHA}.o
${CC} ${LFLAGS} -o ${ALPHA} ${ALPHA}.o ${LDFLAGS}
${ALPHA}.o: ${ALPHA}.${C}
${CC} ${CFLAGS} -c ${ALPHA}.${C}
${COMP}: ${COMP}.o
${CC} ${LFLAGS} -o ${COMP} ${COMP}.o ${LDFLAGS}
${COMP}.o: ${COMP}.${C}
${CC} ${CFLAGS} -c ${COMP}.${C}
run:
./alphamask dhouse.png
./compose alphamask.png
clean:
rm -f core.* *.o *~ ${ALPHA} ${COMP}

Answer 1

First problem:
COMP = compose
${COMP}.o: ...
Adding a suffix to a variable isn't quite that simple in Make. And in this case you have some whitespace problems, which is why you're getting the warning messages, and why you couldn't build compose even if you tried.
Since you're a beginner, let's take a simple approach, crude but effective. We'll rewrite those rules, and add one at the top so that you can build both files with make:
all: alphamask compose
alphamask: alphamask.o
${CC} ${LFLAGS} -o alphamask alphamask.o ${LDFLAGS}
alphamask.o: alphamask.cpp
${CC} ${CFLAGS} -c alphamask.cpp
compose: compose.o
${CC} ${LFLAGS} -o compose compose.o ${LDFLAGS}
compose.o: compose.cpp
${CC} ${CFLAGS} -c compose.cpp
After you've got this working perfectly, a lot of improvements are possible.
EDIT:
Now that it's working perfectly, we can improve it. First let's put in automatic variables, to reduce the redundancy: $# is the name of the target, $^ is the prerequisites, and $< is the first prerequisite.
all: alphamask compose
alphamask: alphamask.o
${CC} ${LFLAGS} -o $# $^ ${LDFLAGS}
alphamask.o: alphamask.cpp
${CC} ${CFLAGS} -c $<
compose: compose.o
${CC} ${LFLAGS} -o $# $^ ${LDFLAGS}
compose.o: compose.cpp
${CC} ${CFLAGS} -c $<
Now we see redundancy in the commands, so we can combine the rules:
all: alphamask compose
alphamask: alphamask.o
compose: compose.o
alphamask compose:
${CC} ${LFLAGS} -o $# $^ ${LDFLAGS}
alphamask.o: alphamask.cpp
compose.o: compose.cpp
alphamask.o compose.o:
${CC} ${CFLAGS} -c $<
Now we can replace the object (.o) rules with a pattern rule:
all: alphamask compose
alphamask: alphamask.o
compose: compose.o
alphamask compose:
${CC} ${LFLAGS} -o $# $^ ${LDFLAGS}
%.o: %.cpp
${CC} ${CFLAGS} -c $<
And a static pattern rule for the executables. (We could use a pattern rule for these too, but that would be a little too general.)
EXECUTABLES = alphamask compose
.PHONY: all
all: $(EXECUTABLES)
$(EXECUTABLES): % : %.o
${CC} ${LFLAGS} -o $# $^ ${LDFLAGS}
%.o: %.cpp
${CC} ${CFLAGS} -c $<
When you make these improvements, get each improvement working perfectly before you advance to the next.

Answer 2

I'm pretty sure you need a rule to make them all (using dependencies for both projects):
all: ${ALPHA} ${COMP}
And then of course:
make all