C Makefile for 2 mainfiles - makefile

Question

It's my first question around here. I'm working on a project for my course.
I know this question might have been answer to many times but I can't really understand what's the problem in the other people's topics.
The project is a simple chat with pipes and forks and I need to make a Makefile to compile the program. Here's my makefile:
CC=cc
FLAGS=-c -Wall
LIBS=-lm
OBS=cliente.o server.o
all : cliente server
cliente.c : cliente
$(CC) $(FLAGS) cliente.c
server.c : server
$(CC) $(FLAGS) server.c
And the output is:
make: Circular cliente.c <- cliente dependency dropped.
cc -c -o cliente.o cliente.c
cc cliente.o -o cliente
make: Circular server.c <- server dependency dropped.
Thank you for the help.

Answer 1

First, you've got your rules backwards. The correct syntax for Makefile rules is:
target-you-are-trying-to-build: things it depends on
command to build target from things it depends on
Therefore, you want to write:
cliente : cliente.c
$(CC) $(FLAGS) cliente.c
server: server.c
$(CC) $(FLAGS) server.c
(Note the flipping of the executable and the source file in the first line of each rule.)
The reason your original Makefile works at all is because make has some built in rules, so when you type make, it tries to build all which needs cliente and server, and it generates automatic rules to build cliente from cliente.c and server from server.c. (You can tell it's using it's internal rules and not yours because it ignores your FLAGS.)
The error messages about dropped dependencies are because you've told it to build cliente, which it knows it can build from cliente.c, but your rules tell it that cliente.c should be built from cliente which makes a circular dependency, so it complains.
However, as you note in the comment, this still won't work right. That's because your rules for building cliente and server don't actually build cliente and server. The command:
cc -c -Wall cliente.c
only compiles cliente.c to an object file cliente.o because of the -c flag. It doesn't link or output an executable. The modified version in #InvicibleWolf's answer which is equivalent to:
cc -c -Wall -o cliente -c client.c
won't work either, because the (multiple) -c flags produce object files, not executables, even if you force the output to go to cliente instead of the default of cliente.o. You're getting a "permission denied" error because, by default, object files are created without execute permissions. (Giving them execute permissions wouldn't help -- object files can't be run directly, so you'd get a different error.)
There are a couple of approaches here:
Use make's built-in rules exclusively
The following Makefile will work:
CC=cc # should be "CC=", not "C="
CFLAGS=-Wall # internal rules use CFLAGS not FLAGS, don't need -c
LDLIBS=-lm # internal rules use LDLIBS not LIBS
all : cliente server
cliente: cliente.o
server: server.o
This tells makes that cliente can be built from cliente.o, and make is smart enough to generate a rule equivalent to:
cc cliente.o -lm -o cliente
using your definition of CC and LDLIBS. It will also automatically generate the rule to build cliente.o from cliente.c without any guidance, equivalent to:
cc -Wall -c -o cliente.o cliente.c
using your definition of CFLAGS. (It supplies the -c flags automatically.)
Use explicit rules that directly generate the executable from the C file
This will work, too. It's just what #InvicibleWolf has written above with a typo fixed, the -c dropped, and the LIBS value included in the rules:
CC=cc ## use CC=, not C=
FLAGS=-Wall ## no -c flag
LIBS=-lm
all : cliente server
cliente: cliente.c
$(CC) $(FLAGS) $(LIBS) -o cliente cliente.c # no -c, and use LIBS
server: server.c
$(CC) $(FLAGS) $(LIBS) -o server server.c # no -c, and use LIBS

Answer 2

To compile your make file should follow the rule #K. A. Buhr mentioned in the answer. Makefile in his answer will just create object files . Considering your question I think you want to make two binaries client and server, so your make file should look like this:
C=cc
FLAGS= -Wall
LIBS=-lm
# OBS=cliente.o server.o not necessary if you are clreating to different binaries
all : cliente server
cliente: cliente.c
$(CC) $(FLAGS) -o cliente cliente.c
server: server.c
$(CC) $(FLAGS) -o server server.c
This will create object file as well as binaries too. -o option is to output to server/cliente file, and -c option means compile and assemble, but do not link or other words generate object files.