Allegro5 Makefile错误

Question

note: this is the final exercise in the Head First C book.

I have the following problem. I am trying to make a game using the allegro5.2 libraries. I want to use multiple .c files in order to organize everything neatly. However, I have problems compiling my programs using a makefile. I am trying to compile this easy program:

#include <stdio.h>
#include <allegro5/allegro.h>

const int disp_h = 640;
const int disp_w = 480;

int main(int argc, char **argv) {

ALLEGRO_DISPLAY *display;

if(!al_init()) {
    fprintf(stderr, "failed to initialize allegro!\n");
    return -1;
}

display = al_create_display(disp_h,disp_w);
if(!display) {
    fprintf(stderr, "failed to create display!\n");
    return -1;
}

al_rest(0.4);
al_destroy_display(display);

printf("bye bye!!!\n");

return 0;
}

The makefile is:

Blasteroids.o: allegro.h Blasteroids.c
    gcc -Wall -c Blasteroids.c

Blasteroids: Blasteroids.o allegro.h
    gcc -Wall -I/usr/include/allegro5 -L/usr/lib -lallegro -lallegro_main Blasteroids.o -o Blasteroids

Now, when I use the terminal this compiles fine, but now I seem to have a problem. The error given by the terminal (using the command make Blasteroids) is:

cc   Blasteroids.o   -o Blasteroids
Undefined symbols for architecture x86_64:
  "_al_create_display", referenced from:
      __al_mangled_main in Blasteroids.o
  "_al_destroy_display", referenced from:
      __al_mangled_main in Blasteroids.o
  "_al_install_system", referenced from:
      __al_mangled_main in Blasteroids.o
  "_al_rest", referenced from:
      __al_mangled_main in Blasteroids.o
  "_main", referenced from:
     implicit entry/start for main executable
     (maybe you meant: __al_mangled_main)
ld: symbol(s) not found for architecture x86_64
clang: error: linker command failed with exit code 1 (use -v to see invocation)
make: *** [Blasteroids] Error 1

I don't know what I am doing wrong and I am very new to these things. I have searched for examples in makefiles, but they give me code like I am using now. I now I can just use a single line for the above program, but the idea is that I want to make my own .c files, make them into .o files and then link them together. Hence the makefile.

Answer 1

something like the following makefile contents should do the job

Notes:

1. header files are only needed during the compile step
2. library files are only needed during the link step
3. best to have the first 'target' be 'all' so the makefile can be successfully executed without have to include a 'Blasteroids' parameter
4. having a 'target' 'clean' makes it easy to clear away the items that will be rebuilt
5. any 'target' that does not produce a file of the same name should be listed in a '.PSEUDO' operator
6. the linker processes the linker command line items in the order listed on the command line. Therefore, list the objects, then the directories, then the library 'short' names
7. list the header files at the end of the compile command line
8. use macros (like CC and RM) that contain the full path to the executables so the correct executable is used, other wise the first item found in the $PATH that matches the name will be used.
9. $^ is a built in macro that expands to the recipe dependencies
10. $< is a built in macro that expands to the first dependency
11. $@ is a built in macro that expands to the recipe 'target'
12. the $(SRC:.c=?) statements do character replacement on the extension of the file names contained in the $(SRC) macro
13. the %.o:%.c recipe says for each source file to be compiled into a object file, use this recipe
14. the '-ggdb' is so the maximum debug information will be available to the 'gdb' debugger.
15. this pattern of 'makefile' can be extensively used for other projects with only minor variations. For more flexibility could also insert a recipe for automatically generating the header file dependencies, so would not need to list them individually in the compile recipe, but for now, the following makefile contents will do what you are currently trying to perform

and now the makefile

CC := /bin/gcc
RM := /bin/rm

CFLAGS := -Wall -Wextra -pedantic -std=gnu99 -ggdb -c
LFLAGS := -L/usr/lib -lallegro -lallegro_main

SRC    := Blasteroids.c
#OBJ    := $(SRC:.c=.0)
OBJ    := $(SRC:.c=.o)
NAME   := $(SRC:.c=)

.PSEUDO: all clean

all: $(NAME)

%.o:%.c
    #$(CC) $(CFLAGS) $^ -o $@ -I/usr/include/allegro5
    $(CC) $(CFLAGS) $< -o $@ -I/usr/include/allegro5

$(NAME): $(OBJ)
    $(CC) -ggdb  $^ -o $@  $(LFLAGS)

.clean:
    $(RM) -f $(NAME) $(OBJ)

Answer 2

The make program looks for files named makefile or Makefile , with no extension. If you name your makefile something else, such as makefile.txt , then make can't find it and it will just use its own built-in rules which don't know anything about extra flags ro libraries that may be needed.

So either rename your makefile to makefile or Makefile , or else specify the name of your makefile explicitly on the command line when you run make, such as make -f makefile.txt Blasteroids .

Secondarily, if you don't specify a target on the command line then make will always build the first target. So, if you re-order your targets so that the one you usually want to build (in this case Blasteroids ) is first, then you can just run make with no arguments and it will build that target.

Unlike a programming language, the order of target definition doesn't matter to make: eg, you don't have to define rules for all the object files first before the link line. Make reads the entire file and constructs an internal graph of prerequisite relationships, and nodes and edges in this graph can be added in any order.