Makefile slim schrijven

[Boudewijn]

Hoi


Ik ben bezig met een opdracht waar ik een makefile voor een simpele parser moet schrijven, en ik heb het op zich prima werken maar wil graag pattern rules oid gebruiken ipv de lompe-henkie-methode die ik nu toepas.

Dit moet de makefile doen:

code:

#! /bin/sh

bison -o parser.c parser.y -d
gcc -c parser.c
gcc -c main.c
flex -olexer.c lexer.l
gcc -c lexer.c
gcc -c print.c
gcc -c abstract.c
gcc -c eval.c
gcc main.o parser.o lexer.o print.o abstract.o eval.o -o interpreter

Nu heb ik dat netjes in de volgende makefile samen weten te vatten:

code:

CC=gcc
LEX=flex
BISON=bison
CSOURCES=*.c
OBJECTS=$(CSOURCES:.c=.o)

all: interpreter

clean:
        rm *.o 
        rm parser.c lexer.c

parser.c: parser.y
        ${BISON} -o parser.c parser.y -d

parser.o: parser.c
        ${CC} -c parser.c

main.o: main.c config.h eval.h print.h parser.h
        ${CC} -c main.c

lexer.c: lexer.l abstract.h parser.h
        ${LEX} -olexer.c lexer.l

lexer.o: lexer.c 
        ${CC} -c lexer.c

print.o: print.h abstract.o
        ${CC} -c print.c

abstract.o:
        ${CC} -c abstract.c abstract.h

eval.o: eval.c eval.h abstract.o
        ${CC} -c eval.c

interpreter:  main.o parser.o lexer.o print.o abstract.o eval.o
        ${CC} main.o parser.o lexer.o print.o abstract.o eval.o -o interpreter

Ik wil deze code eigenlijk beter maken, omdat ik hier gewoon alles heb uitgeschreven, en dat kan toch niet de bedoeling zijn he. Nu heb ik het idee dat dat op 2 manieren kan, en beide heb ik getest:


1: een OBJECTS variabele declareren :

code:

SOOURCES=*.c
OBJECTS=$(SOURCES:.c=.o)

En dan als deps voor interpreter ${OBJECTS} opgeven.
Hij lijkt helemaal niets meer met dependencies te doen echter?

2: Dmv pattern rules:

code:

%.o: %.c
    $(CC)  -c $(input) -o $(output)

Hier had ik het probleem dat een aantal van de C files nog niet uit de lex\bison files is gegenereerd en daardoor failt.


Weet iemand waar dit fout gaat, en hoe ik dit het mooiste op kan lossen?

[Boudewijn]

*BUMP*

[DrClaw]

CC                      = gcc
LEX                     = flex
YACC            = bison --yacc
SHELL           = /bin/sh

WARNINGS        = -Wall -ansi
OTHERS          = -g
DEFINES =
DEFINES += -DDUMP_SYNTAX # dump the syntax trees?
# DEFINES += -DDUMP_SYMBOL # dymp the symboltable?
# DEFINES += -DSHOW_TYPECHECKING # show parameter typechecking?
# DEFINES += -DDEBUG # do lexical debugging stuff?

CFLAGS          = $(WARNINGS) $(OTHERS) $(DEFINES)
LFLAGS          =
YFLAGS          = --defines --debug --verbose
LDFLAGS         = -g
LOADLIBES       = -lfl

IMPORTANT       = debug.[ch]  spascal.[hly] \
                        symboltable.[ch] syntaxtree.[ch] \
                        assert.[ch] Makefile errormessages.[ch]\
                        intermediate.[ch]
DISTFILE        = cc.tar.gz

all: democomp

# Dependency stuff
democomp: y.tab.o debug.o symboltable.o syntaxtree.o assert.o errormessages.o intermediate.o
        $(CC) $(LDFLAGS) -o $@ $^ $(LOADLIBES)

fltest: lex.yy.c debug.o symboltable.o syntaxtree.o assert.o errormessages.o
        $(CC) $(LDFLAGS) -o $@ -DSTAND_ALONE_LEXER $^ -lfl

y.tab.h y.tab.c: spascal.y lex.yy.c
        $(YACC) $(YFLAGS) $<

lex.yy.c: spascal.l debug.h
        $(LEX) $(LFLAGS) $<

clean:
        rm -f lex.yy.c y.tab.* y.output *.o \
            `find . -name core -o -name \*\.bak`

backup:
        tar cfz ../compiler-`date +'%y%m%d-%H%M'`.tar.gz $(IMPORTANT)

# Show dependencies between .c files
showdeps:
        gcc -MM *.c

$(DISTFILE).uux: $(IMPORTANT)
        $(RM) $(DISTFILE)
        tar cfz - $(IMPORTANT) | uuencode $(DISTFILE) > $(DISTFILE).uux


# Dependency stuff
debug.o: debug.c debug.h
lex.yy.o: lex.yy.c debug.h
symboltable.o: symboltable.c symboltable.h debug.h y.tab.h
syntaxtree.o: syntaxtree.c syntaxtree.h symboltable.h
y.tab.o: y.tab.c debug.h symboltable.h syntaxtree.h lex.yy.c
assert.o: assert.c assert.h
errormessages.o: errormessages.c errormessages.h
intermediate.o: intermediate.c intermediate.h y.tab.h

[Verwijderd]

Is het de bedoeling dat je een Makefile schrijft? Of is het de bedoeling dat je gewoon een fatsoenlijke Makefile kunt genereren?

Ik ben zelf groot fan van autoconf en automake voor zulke dingen. Naast de gebruikelijke dingen in configure.ac, heb je dan in je Makefile.am ongeveer het volgende staan:

code:

AM_YFLAGS = -d

bin_PROGRAMS = interpreter

BUILT_SOURCES = lexer.h

interpreter_SOURCES = main.c lexer.l parser.y print.c abstract.c eval.c

Sowieso is dit een stuk beter onderhoudbaar, en het scheelt heel wat gedoe als er weer eens iets opnieuw gegenereerd moet worden.

[Boudewijn]

nee gaat echt om zelf schrijven

@DrClaw: thanks, ik kijk ernaar.

[Boudewijn]

okay tijd voor een oplossings-schopje:

code:

bash-3.1$ cat Makefile
CC=gcc
LEX=flex
BISON=bison
CSOURCES=*.c
OBJECTS=$(CSOURCES:.c=.o)

all: interpreter

clean:
        rm *.o
        rm parser.c lexer.c

parser.c: parser.y
        ${BISON} -o parser.c parser.y -d

lexer.c: lexer.l abstract.h parser.h
        ${LEX} -olexer.c lexer.l

interpreter:  $(OBJECTS)
        ${CC} $(OBJECTS) -o interpreter

%.o: %.c parser.c lexer.c
        ${CC} -c $< -o $@

[.oisyn]

Wil je niet ook pattern rules voor *.l en *.y files dan? In mijn makefile voor de code syntax highlighter (die hier ook op GoT gebruikt wordt), staat bijv. dit:

code:

lexer_%.o : lexer_%.cpp
    g++ -I. -o $@ -c -O2 $<

lexer_%.cpp : lexer_%.l
    flex -+ -o $@ $<

Goed, ik heb natuurlijk een stuk meer dan 1 lexer en 1 parser wat typisch is (namelijk een lexer per ondersteunde taal), maar het is wel handig om niet alle lex stappen apart te specificeren.

[ Voor 80% gewijzigd door .oisyn op 08-10-2007 16:43 ]